int
dhd_conf_set_roam(dhd_pub_t *dhd)
{
int bcmerror = -1;
char iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" + '\0' + bitvec */
printf("%s: Set roam_off %d\n", __FUNCTION__, dhd->conf->roam_off);
dhd_roam_disable = dhd->conf->roam_off;
bcm_mkiovar("roam_off", (char *)&dhd->conf->roam_off, 4, iovbuf, sizeof(iovbuf));
dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
if (!dhd->conf->roam_off || !dhd->conf->roam_off_suspend) {
printf("%s: Set roam_trigger %d\n", __FUNCTION__, dhd->conf->roam_trigger[0]);
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_ROAM_TRIGGER, dhd->conf->roam_trigger,
sizeof(dhd->conf->roam_trigger), TRUE, 0)) < 0)
CONFIG_ERROR(("%s: roam trigger set failed %d\n", __FUNCTION__, bcmerror));
printf("%s: Set roam_scan_period %d\n", __FUNCTION__, dhd->conf->roam_scan_period[0]);
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_ROAM_SCAN_PERIOD, dhd->conf->roam_scan_period,
sizeof(dhd->conf->roam_scan_period), TRUE, 0)) < 0)
CONFIG_ERROR(("%s: roam scan period set failed %d\n", __FUNCTION__, bcmerror));
printf("%s: Set roam_delta %d\n", __FUNCTION__, dhd->conf->roam_delta[0]);
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_ROAM_DELTA, dhd->conf->roam_delta,
sizeof(dhd->conf->roam_delta), TRUE, 0)) < 0)
CONFIG_ERROR(("%s: roam delta set failed %d\n", __FUNCTION__, bcmerror));
printf("%s: Set fullroamperiod %d\n", __FUNCTION__, dhd->conf->fullroamperiod);
bcm_mkiovar("fullroamperiod", (char *)&dhd->conf->fullroamperiod, 4, iovbuf, sizeof(iovbuf));
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) < 0)
CONFIG_ERROR(("%s: roam fullscan period set failed %d\n", __FUNCTION__, bcmerror));
}
return bcmerror;
}
int dhd_pno_clean(dhd_pub_t *dhd)
{
char iovbuf[128];
int pfn_enabled = 0;
int iov_len = 0;
int ret;
/* Disable pfn */
iov_len = bcm_mkiovar("pfn", (char *)&pfn_enabled, 4, iovbuf, sizeof(iovbuf));
if ((ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) >= 0) {
/* clear pfn */
iov_len = bcm_mkiovar("pfnclear", 0, 0, iovbuf, sizeof(iovbuf));
if (iov_len) {
if ((ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf,
iov_len, TRUE, 0)) < 0) {
DHD_ERROR(("%s failed code %d\n", __FUNCTION__, ret));
}
}
else {
ret = -1;
DHD_ERROR(("%s failed code %d\n", __FUNCTION__, iov_len));
}
}
else
DHD_ERROR(("%s failed code %d\n", __FUNCTION__, ret));
return ret;
}
void sec_control_pm(dhd_pub_t *dhd, uint *power_mode)
{
struct file *fp = NULL;
char *filepath = "/data/.psm.info";
mm_segment_t oldfs = {0};
char power_val = 0;
char iovbuf[WL_EVENTING_MASK_LEN + 12];
g_PMcontrol = FALSE;
fp = filp_open(filepath, O_RDONLY, 0);
if (IS_ERR(fp) || (fp==NULL)) {
/* Enable PowerSave Mode */
dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode, sizeof(uint), TRUE, 0);
fp = filp_open(filepath, O_RDWR | O_CREAT, 0666);
if (IS_ERR(fp) || (fp==NULL)) {
DHD_ERROR(("[%s, %d] /data/.psm.info open failed\n", __FUNCTION__, __LINE__));
return;
}
else {
oldfs = get_fs();
set_fs(get_ds());
if (fp->f_mode & FMODE_WRITE) {
power_val = '1';
fp->f_op->write(fp, (const char *)&power_val, sizeof(char), &fp->f_pos);
}
set_fs(oldfs);
}
}
else {
kernel_read(fp, fp->f_pos, &power_val, 1);
DHD_ERROR(("POWER_VAL = %c \r\n" , power_val));
if(power_val == '0') {
#ifdef ROAM_ENABLE
uint roamvar = 1;
#endif
*power_mode = PM_OFF;
/* Disable PowerSave Mode */
dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode, sizeof(uint), TRUE, 0);
/* Turn off MPC in AP mode */
bcm_mkiovar("mpc", (char *)power_mode, 4, iovbuf, sizeof(iovbuf));
dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
g_PMcontrol = TRUE;
#ifdef ROAM_ENABLE
bcm_mkiovar("roam_off", (char *)&roamvar, 4, iovbuf, sizeof(iovbuf));
dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
#endif
} else {
dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode, sizeof(uint), TRUE, 0);
}
}
if(fp)
filp_close(fp, NULL);
}
int dhd_customer_set_country(dhd_pub_t *dhd)
{
struct file *fp = NULL;
char *filepath = "/data/.ccode.info";
char iovbuf[WL_EVENTING_MASK_LEN + 12] = {0};
char buffer[10] = {0};
int ret = 0;
wl_country_t cspec;
int buf_len = 0;
char country_code[WLC_CNTRY_BUF_SZ];
int country_rev;
int country_offset;
int country_code_size;
char country_rev_buf[WLC_CNTRY_BUF_SZ];
fp = filp_open(filepath, O_RDONLY, 0);
if (IS_ERR(fp)) {
DHD_ERROR(("%s: %s open failed\n", __FUNCTION__, filepath));
return -1;
} else {
if (kernel_read(fp, 0, buffer, sizeof(buffer))) {
memset(&cspec, 0, sizeof(cspec));
memset(country_code, 0, sizeof(country_code));
memset(country_rev_buf, 0, sizeof(country_rev_buf));
country_offset = strcspn(buffer, " ");
country_code_size = country_offset;
if (country_offset != 0) {
strncpy(country_code, buffer, country_offset);
strncpy(country_rev_buf, buffer+country_offset+1, strlen(buffer) - country_code_size + 1);
country_rev = bcm_atoi(country_rev_buf);
buf_len = bcm_mkiovar("country", (char *)&cspec, sizeof(cspec), iovbuf, sizeof(iovbuf));
ret = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, iovbuf, buf_len, FALSE, 0);
memcpy((void *)&cspec, iovbuf, sizeof(cspec));
if (!ret) {
DHD_ERROR(("%s: get country ccode:%s country_abrev:%s rev:%d \n", __FUNCTION__, cspec.ccode, cspec.country_abbrev, cspec.rev));
if ((strncmp(country_code, cspec.ccode, WLC_CNTRY_BUF_SZ) != 0) || (cspec.rev != country_rev)) {
strncpy(cspec.country_abbrev, country_code, country_code_size);
strncpy(cspec.ccode, country_code, country_code_size);
cspec.rev = country_rev;
DHD_ERROR(("%s: set country ccode:%s country_abrev:%s rev:%d \n", __FUNCTION__, cspec.ccode, cspec.country_abbrev, cspec.rev));
buf_len = bcm_mkiovar("country", (char *)&cspec, sizeof(cspec), iovbuf, sizeof(iovbuf));
ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, buf_len, TRUE, 0);
}
}
} else {
DHD_ERROR(("%s: set country %s failed code \n", __FUNCTION__, country_code));
ret = -1;
}
} else {
DHD_ERROR(("%s: Reading from the '%s' returns 0 bytes \n", __FUNCTION__, filepath));
ret = -1;
}
}
if (fp)
filp_close(fp, NULL);
return ret;
}
int dhd_sel_ant_from_file(dhd_pub_t *dhd)
{
struct file *fp = NULL;
int ret = -1;
uint32 ant_val = 0;
char *filepath = "/data/.ant.info";
char iovbuf[WLC_IOCTL_SMLEN];
/* Read antenna settings from the file */
fp = filp_open(filepath, O_RDONLY, 0);
if (IS_ERR(fp)) {
DHD_ERROR(("[WIFI] %s: File [%s] open error\n", __FUNCTION__, filepath));
return ret;
} else {
ret = kernel_read(fp, 0, (char *)&ant_val, 4);
if (ret < 0) {
DHD_ERROR(("[WIFI] %s: File read error, ret=%d\n", __FUNCTION__, ret));
filp_close(fp, NULL);
return ret;
}
ant_val = bcm_atoi((char *)&ant_val);
DHD_ERROR(("[WIFI] %s: ANT val = %d\n", __FUNCTION__, ant_val));
filp_close(fp, NULL);
/* Check value from the file */
if (ant_val < 1 || ant_val > 3) {
DHD_ERROR(("[WIFI] %s: Invalid value %d read from the file %s\n",
__FUNCTION__, ant_val, filepath));
return -1;
}
}
/* Select Antenna */
bcm_mkiovar("txchain", (char *)&ant_val, 4, iovbuf, sizeof(iovbuf));
ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
if (ret) {
DHD_ERROR(("[WIFI] %s: Fail to execute dhd_wl_ioctl_cmd(): txchain, ret=%d\n",
__FUNCTION__, ret));
return ret;
}
bcm_mkiovar("rxchain", (char *)&ant_val, 4, iovbuf, sizeof(iovbuf));
ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
if (ret) {
DHD_ERROR(("[WIFI] %s: Fail to execute dhd_wl_ioctl_cmd(): rxchain, ret=%d\n",
__FUNCTION__, ret));
return ret;
}
return 0;
}
/*
* dhd_cfg80211_set_p2p_info : gets called when GO or GC created
*/
s32 dhd_cfg80211_set_p2p_info(struct wl_priv *wl, int val)
{
dhd_pub_t *dhd = (dhd_pub_t *)(wl->pub);
int bcn_timeout = DHD_BEACON_TIMEOUT_HIGH;
char iovbuf[30];
DHD_MYTRACE(("%s-%s\n", __FILE__, __FUNCTION__));
dhd->op_mode |= val;
WL_ERR(("Set : op_mode=%d\n", dhd->op_mode));
#ifdef ARP_OFFLOAD_SUPPORT
/* IF P2P is enabled, disable arpoe */
dhd_arp_offload_set(dhd, 0);
dhd_arp_offload_enable(dhd, false);
#endif /* ARP_OFFLOAD_SUPPORT */
/* diable all filtering in p2p mode */
dhd_os_set_packet_filter(dhd, 0);
/* Setup timeout if Beacons are lost and roam is off to report link down */
bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf, sizeof(iovbuf));
dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
return 0;
}
int dhd_pno_enable(dhd_pub_t *dhd, int pfn_enabled)
{
char iovbuf[128];
int ret = -1;
if ((!dhd) && ((pfn_enabled != 0) || (pfn_enabled != 1))) {
DHD_ERROR(("%s error exit\n", __FUNCTION__));
return ret;
}
/* Enable/disable PNO */
if ((ret = bcm_mkiovar("pfn", (char *)&pfn_enabled, 4, iovbuf, sizeof(iovbuf))) > 0) {
if ((ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf,
sizeof(iovbuf), TRUE, 0)) < 0) {
DHD_ERROR(("%s failed for error=%d\n", __FUNCTION__, ret));
return ret;
}
else {
dhd->pno_enable = pfn_enabled;
DHD_TRACE(("%s set pno as %d\n", __FUNCTION__, dhd->pno_enable));
}
}
else DHD_ERROR(("%s failed err=%d\n", __FUNCTION__, ret));
return ret;
}
int
dhd_iscan_request(void * dhdp, uint16 action)
{
int rc;
wl_iscan_params_t params;
dhd_pub_t *dhd = dhd_bus_pub(dhdp);
char buf[WLC_IOCTL_SMLEN];
DHD_TRACE(("%s: Entered\n", __FUNCTION__));
memset(¶ms, 0, sizeof(wl_iscan_params_t));
memcpy(¶ms.params.bssid, ðer_bcast, ETHER_ADDR_LEN);
params.params.bss_type = DOT11_BSSTYPE_ANY;
params.params.scan_type = DOT11_SCANTYPE_ACTIVE;
params.params.nprobes = htod32(-1);
params.params.active_time = htod32(-1);
params.params.passive_time = htod32(-1);
params.params.home_time = htod32(-1);
params.params.channel_num = htod32(0);
params.version = htod32(ISCAN_REQ_VERSION);
params.action = htod16(action);
params.scan_duration = htod16(0);
bcm_mkiovar("iscan", (char *)¶ms, sizeof(wl_iscan_params_t), buf, WLC_IOCTL_SMLEN);
rc = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, buf, WLC_IOCTL_SMLEN, TRUE, 0);
return rc;
}
int dhd_check_module_mac(dhd_pub_t *dhd, struct ether_addr *mac)
{
int ret = -1;
unsigned char cis_buf[CIS_BUF_SIZE] = {0};
unsigned char mac_buf[20] = {0};
unsigned char otp_mac_buf[20] = {0};
const char *macfilepath = MACINFO_EFS;
/* Try reading out from CIS */
cis_rw_t *cish = (cis_rw_t *)&cis_buf[8];
struct file *fp_mac = NULL;
cish->source = 0;
cish->byteoff = 0;
cish->nbytes = sizeof(cis_buf);
strcpy(cis_buf, "cisdump");
ret = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, cis_buf,
sizeof(cis_buf), 0, 0);
if (ret < 0) {
DHD_TRACE(("%s: CIS reading failed, err=%d\n", __func__,
ret));
sprintf(otp_mac_buf, "%02X:%02X:%02X:%02X:%02X:%02X\n",
mac->octet[0], mac->octet[1], mac->octet[2],
mac->octet[3], mac->octet[4], mac->octet[5]);
DHD_ERROR(("%s: Check module mac by legacy FW : %02X:%02X:%02X\n",
__func__, mac->octet[0], mac->octet[4], mac->octet[5]));
} else {
unsigned char mac_id[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
#ifdef DUMP_CIS
dhd_dump_cis(cis_buf, 48);
#endif
mac_id[0] = cis_buf[CIS_MAC_OFFSET];
mac_id[1] = cis_buf[CIS_MAC_OFFSET + 1];
mac_id[2] = cis_buf[CIS_MAC_OFFSET + 2];
mac_id[3] = cis_buf[CIS_MAC_OFFSET + 3];
mac_id[4] = cis_buf[CIS_MAC_OFFSET + 4];
mac_id[5] = cis_buf[CIS_MAC_OFFSET + 5];
sprintf(otp_mac_buf, "%02X:%02X:%02X:%02X:%02X:%02X\n",
mac_id[0], mac_id[1], mac_id[2], mac_id[3], mac_id[4],
mac_id[5]);
DHD_ERROR(("[WIFI]mac_id is setted from OTP \n"));
}
fp_mac = filp_open(macfilepath, O_RDONLY, 0);
if (!IS_ERR(fp_mac)) {
DHD_ERROR(("[WIFI]Check Mac address in .mac.info \n"));
kernel_read(fp_mac, fp_mac->f_pos, mac_buf, sizeof(mac_buf));
filp_close(fp_mac, NULL);
if (strncmp(mac_buf, otp_mac_buf, 17) != 0) {
DHD_ERROR(("[WIFI]file MAC is wrong. Write OTP MAC in .mac.info \n"));
dhd_write_mac_file(macfilepath, otp_mac_buf, sizeof(otp_mac_buf));
}
}
return ret;
}
int check_module_cid(dhd_pub_t *dhd)
{
int ret = -1;
unsigned char cis_buf[128] = {0};
unsigned char cid_buf[10] = {0};
const char* cidfilepath = "/data/.cid.info";
/* Try reading out from CIS */
cis_rw_t *cish = (cis_rw_t *)&cis_buf[8];
struct file *fp_cid = NULL;
fp_cid = filp_open(cidfilepath, O_RDONLY, 0);
if (!IS_ERR(fp_cid)) {
kernel_read(fp_cid, fp_cid->f_pos, cid_buf, sizeof(cid_buf));
if(strstr(cid_buf,"samsung")||strstr(cid_buf,"murata")||strstr(cid_buf,"semcove")) {
/* file does exist, just return */
filp_close(fp_cid, NULL);
return 0;
}
DHD_ERROR(("[WIFI].cid.info file already exists but it contains an unknown id [%s]\n", cid_buf));
}
cish->source = 0;
cish->byteoff = 0;
cish->nbytes = sizeof(cis_buf);
strcpy(cis_buf, "cisdump");
ret = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, cis_buf, sizeof(cis_buf), 0, 0);
if (ret < 0) {
DHD_ERROR(("%s: CIS reading failed, err=%d\n", __FUNCTION__, ret));
} else {
unsigned char id[4] = {0x80, 0x06, 0x81, 0x00};
unsigned char id_swb42a[4] = {0x80, 0x02, 0x81, 0x99}; //SWB_42A
#ifdef DUMP_CIS
dump_cis(cis_buf, 48);
#endif
if (memcmp(&cis_buf[CIS_CID_OFFSET], id, 4) == 0) {
DHD_ERROR(("CID MATCH FOUND\n"));
write_cid_file(cidfilepath, "murata", 6);
}
else if (memcmp(&cis_buf[CIS_CID_OFFSET], id_swb42a, 4) == 0) { //SWB_42A
DHD_ERROR(("CID MATCH FOUND semcove \n"));
write_cid_file(cidfilepath, "semcove", 7);
}
else {
DHD_ERROR(("CID MISMATCH 0x%02X 0x%02X 0x%02X 0x%02X\n",
cis_buf[CIS_CID_OFFSET], cis_buf[CIS_CID_OFFSET+1],
cis_buf[CIS_CID_OFFSET+2], cis_buf[CIS_CID_OFFSET+3]));
write_cid_file(cidfilepath, "samsung", 7);
}
}
return ret;
}
void
dhd_conf_set_bw(dhd_pub_t *dhd)
{
int bcmerror = -1;
char iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" + '\0' + bitvec */
uint32 mimo_bw_cap = 1; /* Turn HT40 on in 2.4 GHz */
if (dhd_bus_chip_id(dhd) == BCM43341_CHIP_ID ||
dhd_bus_chip_id(dhd) == BCM4324_CHIP_ID ||
dhd_bus_chip_id(dhd) == BCM4335_CHIP_ID ||
dhd_bus_chip_id(dhd) == BCM4339_CHIP_ID) {
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_DOWN, NULL, 0, TRUE, 0)) < 0)
CONFIG_ERROR(("%s: WLC_DOWN setting failed %d\n", __FUNCTION__, bcmerror));
/* Enable HT40 in 2.4 GHz */
printf("%s: Enable HT40 in 2.4 GHz\n", __FUNCTION__);
bcm_mkiovar("mimo_bw_cap", (char *)&mimo_bw_cap, 4, iovbuf, sizeof(iovbuf));
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) < 0)
CONFIG_ERROR(("%s: mimo_bw_cap setting failed %d\n", __FUNCTION__, bcmerror));
}
}
int
dhd_conf_set_band(dhd_pub_t *dhd)
{
int bcmerror = -1;
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_BAND, &dhd->conf->band,
sizeof(dhd->conf->band), TRUE, 0)) < 0)
CONFIG_ERROR(("%s: band set failed %d\n", __FUNCTION__, bcmerror));
return bcmerror;
}
/* Set/Get flwo ring priority map */
int dhd_flow_prio_map(dhd_pub_t *dhd, uint8 *map, bool set)
{
uint8 iovbuf[24];
if (!set) {
bcm_mkiovar("bus:fl_prio_map", NULL, 0, (char*)iovbuf, sizeof(iovbuf));
if (dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, iovbuf, sizeof(iovbuf), FALSE, 0) < 0) {
DHD_ERROR(("%s: failed to get fl_prio_map\n", __FUNCTION__));
return BCME_ERROR;
}
*map = iovbuf[0];
return BCME_OK;
}
bcm_mkiovar("bus:fl_prio_map", (char *)map, 4, (char*)iovbuf, sizeof(iovbuf));
if (dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0) < 0) {
DHD_ERROR(("%s: failed to set fl_prio_map \n",
__FUNCTION__));
return BCME_ERROR;
}
return BCME_OK;
}
void
dhd_conf_force_wme(dhd_pub_t *dhd)
{
int bcmerror = -1;
char iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" + '\0' + bitvec */
if (dhd_bus_chip_id(dhd) == BCM43362_CHIP_ID && dhd->conf->force_wme_ac) {
bcm_mkiovar("force_wme_ac", (char *)&dhd->conf->force_wme_ac, 4, iovbuf, sizeof(iovbuf));
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) < 0)
CONFIG_ERROR(("%s: force_wme_ac setting failed %d\n", __FUNCTION__, bcmerror));
}
}
static int
dhd_iscan_get_partial_result(void *dhdp, uint *scan_count)
{
wl_iscan_results_t *list_buf;
wl_iscan_results_t list;
wl_scan_results_t *results;
iscan_buf_t *iscan_cur;
int status = -1;
dhd_pub_t *dhd = dhd_bus_pub(dhdp);
int rc;
DHD_TRACE(("%s: Enter\n", __FUNCTION__));
iscan_cur = dhd_iscan_allocate_buf(dhd, &iscan_chain);
if (!iscan_cur) {
DHD_ERROR(("%s: Failed to allocate node\n", __FUNCTION__));
dhd_iscan_free_buf(dhdp, 0);
dhd_iscan_request(dhdp, WL_SCAN_ACTION_ABORT);
dhd_ind_scan_confirm(dhdp, FALSE);
goto fail;
}
dhd_iscan_lock();
memset(iscan_cur->iscan_buf, 0, WLC_IW_ISCAN_MAXLEN);
list_buf = (wl_iscan_results_t*)iscan_cur->iscan_buf;
results = &list_buf->results;
results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
results->version = 0;
results->count = 0;
memset(&list, 0, sizeof(list));
list.results.buflen = htod32(WLC_IW_ISCAN_MAXLEN);
bcm_mkiovar("iscanresults", (char *)&list, WL_ISCAN_RESULTS_FIXED_SIZE,
iscan_cur->iscan_buf, WLC_IW_ISCAN_MAXLEN);
rc = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, iscan_cur->iscan_buf,
WLC_IW_ISCAN_MAXLEN, FALSE, 0);
results->buflen = dtoh32(results->buflen);
results->version = dtoh32(results->version);
*scan_count = results->count = dtoh32(results->count);
status = dtoh32(list_buf->status);
DHD_TRACE(("%s: Got %d resuls\n", __FUNCTION__, results->count));
dhd_iscan_unlock();
if (!(*scan_count)) {
dhd_iscan_free_buf(dhdp, iscan_cur);
}
fail:
return status;
}
void
dhd_conf_set_stbc(dhd_pub_t *dhd)
{
int bcmerror = -1;
char iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" + '\0' + bitvec */
uint stbc = 0;
if (dhd_bus_chip_id(dhd) == BCM4324_CHIP_ID) {
if (dhd->conf->stbc >= 0) {
stbc = (uint)dhd->conf->stbc;
printf("%s: set stbc_tx %d\n", __FUNCTION__, stbc);
bcm_mkiovar("stbc_tx", (char *)&stbc, 4, iovbuf, sizeof(iovbuf));
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) < 0)
CONFIG_ERROR(("%s: stbc_tx setting failed %d\n", __FUNCTION__, bcmerror));
printf("%s: set stbc_rx %d\n", __FUNCTION__, stbc);
bcm_mkiovar("stbc_rx", (char *)&stbc, 4, iovbuf, sizeof(iovbuf));
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) < 0)
CONFIG_ERROR(("%s: stbc_rx setting failed %d\n", __FUNCTION__, bcmerror));
}
}
}
int wl_iw_get_wireless_stats(dhd_pub_t *pub, struct iw_statistics *wstats)
{
int res = 0;
wl_cnt_t cnt;
int phy_noise;
scb_val_t scb_val;
if (pub == NULL)
{
pub = G_dhd;
}
#if 0
phy_noise = 0;
res = dhd_wl_ioctl_cmd(pub, WLC_GET_PHY_NOISE, &phy_noise, sizeof(phy_noise), 0);
if (res)
goto done;
phy_noise = dtoh32(phy_noise);
printf("wl_iw_get_wireless_stats phy noise=%d\n", phy_noise);
#endif
bzero(&scb_val, sizeof(scb_val_t));
res = dhd_wl_ioctl_cmd(pub, WLC_GET_RSSI, &scb_val, sizeof(scb_val_t), 0);
if (res)
goto done;
WiFiCurAPRssi = -dtoh32(scb_val.val);
printf("WiFiCurAPRssi = %d\n", WiFiCurAPRssi);
//printf("wl_iw_get_wireless_stats phy rssi=%d %02x:%02x:%02x:%02x:%02x:%02x\n", WiFiCurAPRssi,
// scb_val.ea.octet[0], scb_val.ea.octet[1], scb_val.ea.octet[2], scb_val.ea.octet[3],
// scb_val.ea.octet[4], scb_val.ea.octet[5]);
done:
return res;
}
int dhd_check_module_mac(dhd_pub_t *dhd)
{
int ret = -1;
unsigned char cis_buf[250] = {0};
unsigned char mac_buf[20] = {0};
const char *macfilepath = "/efs/wifi/.mac.info";
/* Try reading out from CIS */
cis_rw_t *cish = (cis_rw_t *)&cis_buf[8];
struct file *fp_mac = NULL;
fp_mac = filp_open(macfilepath, O_RDONLY, 0);
if (!IS_ERR(fp_mac)) {
kernel_read(fp_mac, fp_mac->f_pos, mac_buf, sizeof(mac_buf));
/*DHD_ERROR(("[WIFI].mac.info file already exist : [%s]\n",
mac_buf));*/
return 0;
}
cish->source = 0;
cish->byteoff = 0;
cish->nbytes = sizeof(cis_buf);
strcpy(cis_buf, "cisdump");
ret = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, cis_buf,
sizeof(cis_buf), 0, 0);
if (ret < 0) {
DHD_ERROR(("%s: CIS reading failed, err=%d\n", __func__,
ret));
} else {
unsigned char mac_id[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
#ifdef DUMP_CIS
dump_cis(cis_buf, 48);
#endif
mac_id[0] = cis_buf[CIS_MAC_OFFSET];
mac_id[1] = cis_buf[CIS_MAC_OFFSET + 1];
mac_id[2] = cis_buf[CIS_MAC_OFFSET + 2];
mac_id[3] = cis_buf[CIS_MAC_OFFSET + 3];
mac_id[4] = cis_buf[CIS_MAC_OFFSET + 4];
mac_id[5] = cis_buf[CIS_MAC_OFFSET + 5];
sprintf(mac_buf, "%02X:%02X:%02X:%02X:%02X:%02X\n",
mac_id[0], mac_id[1], mac_id[2], mac_id[3], mac_id[4],
mac_id[5]);
/*DHD_ERROR(("[WIFI]mac_id is setted from OTP: [%s]\n", mac_buf));*/
dhd_write_mac_file(macfilepath, mac_buf, sizeof(mac_buf));
}
return ret;
}
/*
* RSDBOFFINFO = /data/.rsdb.info
* - rsdb_mode = 1 => Don't change RSDB mode / RSDB stay as turn on
* - rsdb_mode = 0 => Trun Off RSDB mode
* - file not exist => Don't change RSDB mode / RSDB stay as turn on
*/
int dhd_rsdb_mode_from_file(dhd_pub_t *dhd)
{
struct file *fp = NULL;
int ret = -1;
uint32 rsdb_mode = 0;
char *filepath = RSDBINFO;
char iovbuf[WLC_IOCTL_SMLEN];
/* Read RSDB on/off request from the file */
fp = filp_open(filepath, O_RDONLY, 0);
if (IS_ERR(fp)) {
DHD_ERROR(("[WIFI_SEC] %s: File [%s] doesn't exist\n", __FUNCTION__, filepath));
return ret;
} else {
ret = kernel_read(fp, 0, (char *)&rsdb_mode, 4);
if (ret < 0) {
DHD_ERROR(("[WIFI_SEC] %s: File read error, ret=%d\n", __FUNCTION__, ret));
filp_close(fp, NULL);
return ret;
}
rsdb_mode = bcm_atoi((char *)&rsdb_mode);
DHD_ERROR(("[WIFI_SEC] %s: RSDB mode from file = %d\n", __FUNCTION__, rsdb_mode));
filp_close(fp, NULL);
/* Check value from the file */
if (rsdb_mode > 2) {
DHD_ERROR(("[WIFI_SEC] %s: Invalid value %d read from the file %s\n",
__FUNCTION__, rsdb_mode, filepath));
return -1;
}
}
if (rsdb_mode == 0) {
bcm_mkiovar("rsdb_mode", (char *)&rsdb_mode, sizeof(rsdb_mode),
iovbuf, sizeof(iovbuf));
if ((ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR,
iovbuf, sizeof(iovbuf), TRUE, 0)) < 0) {
DHD_ERROR(("[WIFI_SEC] %s: rsdb_mode ret= %d\n", __FUNCTION__, ret));
} else {
DHD_ERROR(("[WIFI_SEC] %s: rsdb_mode to MIMO(RSDB OFF) succeeded\n",
__FUNCTION__));
}
}
return ret;
}
int
dhd_conf_get_country(dhd_pub_t *dhd)
{
int bcmerror = -1;
wl_country_t cspec;
memset(&cspec, 0, sizeof(wl_country_t));
bcm_mkiovar("country", NULL, 0, (char*)&cspec, sizeof(wl_country_t));
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, &cspec, sizeof(wl_country_t), FALSE, 0)) < 0)
printf("%s: country code getting failed %d\n", __FUNCTION__, bcmerror);
else
printf("Country code: %s (%s/%d)\n", cspec.country_abbrev, cspec.ccode, cspec.rev);
return bcmerror;
}
void
dhd_force_disable_singlcore_scan(dhd_pub_t *dhd)
{
int ret = 0;
struct file *fp = NULL;
char *filepath = "/data/.cid.info";
s8 iovbuf[WL_EVENTING_MASK_LEN + 12];
char vender[10] = {0, };
uint32 pm_bcnrx = 0;
uint32 scan_ps = 0;
if (BCM4354_CHIP_ID != dhd_bus_chip_id(dhd))
return;
fp = filp_open(filepath, O_RDONLY, 0);
if (IS_ERR(fp)) {
DHD_ERROR(("/data/.cid.info file open error\n"));
} else {
ret = kernel_read(fp, 0, (char *)vender, 5);
if (ret > 0 && NULL != strstr(vender, "wisol")) {
DHD_ERROR(("wisol module : set pm_bcnrx=0, set scan_ps=0\n"));
bcm_mkiovar("pm_bcnrx", (char *)&pm_bcnrx, 4, iovbuf, sizeof(iovbuf));
ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
if (ret < 0)
DHD_ERROR(("Set pm_bcnrx error (%d)\n", ret));
bcm_mkiovar("scan_ps", (char *)&scan_ps, 4, iovbuf, sizeof(iovbuf));
ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
if (ret < 0)
DHD_ERROR(("Set scan_ps error (%d)\n", ret));
}
filp_close(fp, NULL);
}
}
int
dhd_conf_set_country(dhd_pub_t *dhd)
{
int bcmerror = -1;
char iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" + '\0' + bitvec */
memset(&dhd->dhd_cspec, 0, sizeof(wl_country_t));
printf("%s: Set country %s, revision %d\n", __FUNCTION__,
dhd->conf->cspec.ccode, dhd->conf->cspec.rev);
bcm_mkiovar("country", (char *)&dhd->conf->cspec,
sizeof(wl_country_t), iovbuf, sizeof(iovbuf));
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) < 0)
printf("%s: country code setting failed %d\n", __FUNCTION__, bcmerror);
return bcmerror;
}
void
dhd_arp_offload_set(dhd_pub_t * dhd, int arp_mode)
{
char iovbuf[32];
int retcode;
bcm_mkiovar("arp_ol", (char *)&arp_mode, 4, iovbuf, sizeof(iovbuf));
retcode = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
retcode = retcode >= 0 ? 0 : retcode;
if (retcode)
DHD_TRACE(("%s: failed to set ARP offload mode to 0x%x, retcode = %d\n",
__FUNCTION__, arp_mode, retcode));
else
DHD_TRACE(("%s: successfully set ARP offload mode to 0x%x\n",
__FUNCTION__, arp_mode));
}
void
dhd_arp_offload_enable(dhd_pub_t * dhd, int arp_enable)
{
char iovbuf[32];
int retcode;
bcm_mkiovar("arpoe", (char *)&arp_enable, 4, iovbuf, sizeof(iovbuf));
retcode = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
retcode = retcode >= 0 ? 0 : retcode;
if (retcode)
DHD_TRACE(("%s: failed to enabe ARP offload to %d, retcode = %d\n",
__FUNCTION__, arp_enable, retcode));
else
DHD_TRACE(("%s: successfully enabed ARP offload to %d\n",
__FUNCTION__, arp_enable));
}
void
dhd_conf_update_wme(dhd_pub_t *dhd, edcf_acparam_t *acparam_cur, int aci)
{
int bcmerror = -1;
int aifsn, ecwmin, ecwmax;
edcf_acparam_t *acp;
char iovbuf[WLC_IOCTL_SMLEN];
/* Default value */
aifsn = acparam_cur->ACI&EDCF_AIFSN_MASK;
ecwmin = acparam_cur->ECW&EDCF_ECWMIN_MASK;
ecwmax = (acparam_cur->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT;
/* Modified value */
if (dhd->conf->wme.aifsn[aci] > 0)
aifsn = dhd->conf->wme.aifsn[aci];
if (dhd->conf->wme.cwmin[aci] > 0)
ecwmin = dhd->conf->wme.cwmin[aci];
if (dhd->conf->wme.cwmax[aci] > 0)
ecwmax = dhd->conf->wme.cwmax[aci];
/* Update */
acp = acparam_cur;
acp->ACI = (acp->ACI & ~EDCF_AIFSN_MASK) | (aifsn & EDCF_AIFSN_MASK);
acp->ECW = ((ecwmax << EDCF_ECWMAX_SHIFT) & EDCF_ECWMAX_MASK) | (acp->ECW & EDCF_ECWMIN_MASK);
acp->ECW = ((acp->ECW & EDCF_ECWMAX_MASK) | (ecwmin & EDCF_ECWMIN_MASK));
CONFIG_TRACE(("mod aci %d aifsn %d ecwmin %d ecwmax %d size %d\n",
acp->ACI, acp->ACI&EDCF_AIFSN_MASK,
acp->ECW&EDCF_ECWMIN_MASK, (acp->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
sizeof(edcf_acparam_t)));
/*
* Now use buf as an output buffer.
* Put WME acparams after "wme_ac\0" in buf.
* NOTE: only one of the four ACs can be set at a time.
*/
bcm_mkiovar("wme_ac_sta", (char*)acp, sizeof(edcf_acparam_t), iovbuf,
sizeof(iovbuf));
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), FALSE, 0)) < 0) {
CONFIG_ERROR(("%s: wme_ac_sta setting failed %d\n", __FUNCTION__, bcmerror));
return;
}
}
void
dhd_conf_get_wme(dhd_pub_t *dhd, edcf_acparam_t *acp)
{
int bcmerror = -1;
char iovbuf[WLC_IOCTL_SMLEN];
edcf_acparam_t *acparam;
bzero(iovbuf, sizeof(iovbuf));
/*
* Get current acparams, using buf as an input buffer.
* Return data is array of 4 ACs of wme params.
*/
bcm_mkiovar("wme_ac_sta", NULL, 0, iovbuf, sizeof(iovbuf));
if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, iovbuf, sizeof(iovbuf), FALSE, 0)) < 0) {
CONFIG_ERROR(("%s: wme_ac_sta getting failed %d\n", __FUNCTION__, bcmerror));
return;
}
memcpy((char*)acp, iovbuf, sizeof(edcf_acparam_t)*AC_COUNT);
acparam = &acp[AC_BK];
CONFIG_TRACE(("BK: aci %d aifsn %d ecwmin %d ecwmax %d size %d\n",
acparam->ACI, acparam->ACI&EDCF_AIFSN_MASK,
acparam->ECW&EDCF_ECWMIN_MASK, (acparam->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
sizeof(acp)));
acparam = &acp[AC_BE];
CONFIG_TRACE(("BE: aci %d aifsn %d ecwmin %d ecwmax %d size %d\n",
acparam->ACI, acparam->ACI&EDCF_AIFSN_MASK,
acparam->ECW&EDCF_ECWMIN_MASK, (acparam->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
sizeof(acp)));
acparam = &acp[AC_VI];
CONFIG_TRACE(("VI: aci %d aifsn %d ecwmin %d ecwmax %d size %d\n",
acparam->ACI, acparam->ACI&EDCF_AIFSN_MASK,
acparam->ECW&EDCF_ECWMIN_MASK, (acparam->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
sizeof(acp)));
acparam = &acp[AC_VO];
CONFIG_TRACE(("VO: aci %d aifsn %d ecwmin %d ecwmax %d size %d\n",
acparam->ACI, acparam->ACI&EDCF_AIFSN_MASK,
acparam->ECW&EDCF_ECWMIN_MASK, (acparam->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
sizeof(acp)));
return;
}
s32 dhd_cfg80211_clean_p2p_info(struct wl_priv *wl)
{
dhd_pub_t *dhd = (dhd_pub_t *)(wl->pub);
int bcn_timeout = DHD_BEACON_TIMEOUT_NORMAL;
char iovbuf[30];
dhd->op_mode &= ~CONCURENT_MASK;
WL_ERR(("Clean : op_mode=%d\n", dhd->op_mode));
#ifdef ARP_OFFLOAD_SUPPORT
/* IF P2P is disabled, enable arpoe back for STA mode. */
dhd_arp_offload_set(dhd, dhd_arp_mode);
dhd_arp_offload_enable(dhd, true);
#endif /* ARP_OFFLOAD_SUPPORT */
/* Setup timeout if Beacons are lost and roam is off to report link down */
bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf, sizeof(iovbuf));
dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0);
return 0;
}
int dhd_check_module_cid(dhd_pub_t *dhd)
{
int ret = -1;
unsigned char cis_buf[CIS_BUF_SIZE] = {0};
const char *cidfilepath = CIDINFO;
cis_rw_t *cish = (cis_rw_t *)&cis_buf[8];
int idx, max;
vid_info_t *cur_info;
unsigned char *vid_start;
unsigned char vid_length;
#if defined(BCM4334_CHIP) || defined(BCM4335_CHIP)
const char *revfilepath = REVINFO;
#ifdef BCM4334_CHIP
int flag_b3;
#else
char rev_str[10] = {0};
#endif /* BCM4334_CHIP */
#endif /* BCM4334_CHIP || BCM4335_CHIP */
/* Try reading out from CIS */
cish->source = 0;
cish->byteoff = 0;
cish->nbytes = sizeof(cis_buf);
strcpy(cis_buf, "cisdump");
ret = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, cis_buf,
sizeof(cis_buf), 0, 0);
if (ret < 0) {
DHD_ERROR(("%s: CIS reading failed, err=%d\n",
__FUNCTION__, ret));
return ret;
}
DHD_ERROR(("%s: CIS reading success, ret=%d\n",
__FUNCTION__, ret));
#ifdef DUMP_CIS
dhd_dump_cis(cis_buf, 48);
#endif
max = sizeof(cis_buf) - 4;
for (idx = 0; idx < max; idx++) {
if (cis_buf[idx] == CIS_TUPLE_START) {
if (cis_buf[idx + 2] == CIS_TUPLE_VENDOR) {
vid_length = cis_buf[idx + 1];
vid_start = &cis_buf[idx + 3];
/* found CIS tuple */
break;
} else {
/* Go to next tuple if tuple value is not vendor type */
idx += (cis_buf[idx + 1] + 1);
}
}
}
if (idx < max) {
max = sizeof(vid_info) / sizeof(vid_info_t);
for (idx = 0; idx < max; idx++) {
cur_info = &vid_info[idx];
if ((cur_info->vid_length == vid_length) &&
(cur_info->vid_length != 0) &&
(memcmp(cur_info->vid, vid_start, cur_info->vid_length - 1) == 0))
goto write_cid;
}
}
/* find default nvram, if exist */
DHD_ERROR(("%s: cannot find CIS TUPLE set as default\n", __FUNCTION__));
max = sizeof(vid_info) / sizeof(vid_info_t);
for (idx = 0; idx < max; idx++) {
cur_info = &vid_info[idx];
if (cur_info->vid_length == 0)
goto write_cid;
}
DHD_ERROR(("%s: cannot find default CID\n", __FUNCTION__));
return -1;
write_cid:
DHD_ERROR(("CIS MATCH FOUND : %s\n", cur_info->vname));
dhd_write_cid_file(cidfilepath, cur_info->vname, strlen(cur_info->vname)+1);
#if defined(BCM4334_CHIP)
/* Try reading out from OTP to distinguish B2 or B3 */
memset(cis_buf, 0, sizeof(cis_buf));
cish = (cis_rw_t *)&cis_buf[8];
cish->source = 0;
cish->byteoff = 0;
cish->nbytes = sizeof(cis_buf);
strcpy(cis_buf, "otpdump");
ret = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, cis_buf,
sizeof(cis_buf), 0, 0);
if (ret < 0) {
DHD_ERROR(("%s: OTP reading failed, err=%d\n",
__FUNCTION__, ret));
return ret;
}
/* otp 33th character is identifier for 4334B3 */
cis_buf[34] = '\0';
flag_b3 = bcm_atoi(&cis_buf[33]);
if (flag_b3 & 0x1) {
DHD_ERROR(("REV MATCH FOUND : 4334B3, %c\n", cis_buf[33]));
dhd_write_cid_file(revfilepath, "4334B3", 6);
}
#endif /* BCM4334_CHIP */
#if defined(BCM4335_CHIP)
DHD_TRACE(("%s: BCM4335 Multiple Revision Check\n", __FUNCTION__));
if (concate_revision(dhd->bus, rev_str, sizeof(rev_str),
rev_str, sizeof(rev_str)) < 0) {
DHD_ERROR(("%s: fail to concate revision\n", __FUNCTION__));
ret = -1;
} else {
if (strstr(rev_str, "_a0")) {
DHD_ERROR(("REV MATCH FOUND : 4335A0\n"));
dhd_write_cid_file(revfilepath, "BCM4335A0", 9);
} else {
DHD_ERROR(("REV MATCH FOUND : 4335B0\n"));
dhd_write_cid_file(revfilepath, "BCM4335B0", 9);
}
}
#endif /* BCM4335_CHIP */
return ret;
}
int dhd_check_rdwr_macaddr(struct dhd_info *dhd, dhd_pub_t *dhdp,
struct ether_addr *mac)
{
struct file *fp_mac = NULL;
struct file *fp_nvm = NULL;
char macbuffer[18] = {0};
char randommac[3] = {0};
char buf[18] = {0};
char *filepath_data = MACINFO;
char *filepath_efs = MACINFO_EFS;
#ifdef CONFIG_TARGET_LOCALE_NA
char *nvfilepath = "/data/misc/wifi/.nvmac.info";
#else
char *nvfilepath = "/efs/wifi/.nvmac.info";
#endif
char cur_mac[128] = {0};
char dummy_mac[ETHER_ADDR_LEN] = {0x00, 0x90, 0x4C, 0xC5, 0x12, 0x38};
char cur_macbuffer[18] = {0};
int ret = -1;
g_imac_flag = MACADDR_NONE;
fp_nvm = filp_open(nvfilepath, O_RDONLY, 0);
if (IS_ERR(fp_nvm)) { /* file does not exist */
/* read MAC Address */
strcpy(cur_mac, "cur_etheraddr");
ret = dhd_wl_ioctl_cmd(dhdp, WLC_GET_VAR, cur_mac,
sizeof(cur_mac), 0, 0);
if (ret < 0) {
DHD_ERROR(("Current READ MAC error \r\n"));
memset(cur_mac, 0, ETHER_ADDR_LEN);
return -1;
} else {
DHD_ERROR(("MAC (OTP) : "
"[%02X:%02X:%02X:%02X:%02X:%02X] \r\n",
cur_mac[0], cur_mac[1], cur_mac[2], cur_mac[3],
cur_mac[4], cur_mac[5]));
}
sprintf(cur_macbuffer, "%02X:%02X:%02X:%02X:%02X:%02X\n",
cur_mac[0], cur_mac[1], cur_mac[2],
cur_mac[3], cur_mac[4], cur_mac[5]);
fp_mac = filp_open(filepath_data, O_RDONLY, 0);
if (IS_ERR(fp_mac)) { /* file does not exist */
/* read mac is the dummy mac (00:90:4C:C5:12:38) */
if (memcmp(cur_mac, dummy_mac, ETHER_ADDR_LEN) == 0)
g_imac_flag = MACADDR_MOD_RANDOM;
else if (strncmp(buf, "00:00:00:00:00:00", 17) == 0)
g_imac_flag = MACADDR_MOD_RANDOM;
else
g_imac_flag = MACADDR_MOD;
} else {
int is_zeromac;
ret = kernel_read(fp_mac, 0, buf, 18);
filp_close(fp_mac, NULL);
buf[17] = '\0';
is_zeromac = strncmp(buf, "00:00:00:00:00:00", 17);
DHD_ERROR(("MAC (FILE): [%s] [%d] \r\n",
buf, is_zeromac));
if (is_zeromac == 0) {
DHD_ERROR(("Zero MAC detected."
" Trying Random MAC.\n"));
g_imac_flag = MACADDR_MOD_RANDOM;
} else {
sscanf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
(unsigned int *)&(mac->octet[0]),
(unsigned int *)&(mac->octet[1]),
(unsigned int *)&(mac->octet[2]),
(unsigned int *)&(mac->octet[3]),
(unsigned int *)&(mac->octet[4]),
(unsigned int *)&(mac->octet[5]));
/* current MAC address is same as previous one */
if (memcmp(cur_mac, mac->octet, ETHER_ADDR_LEN) == 0) {
g_imac_flag = MACADDR_NONE;
} else { /* change MAC address */
if (_dhd_set_mac_address(dhd, 0, mac) == 0) {
DHD_INFO(("%s: MACID is"
" overwritten\n", __FUNCTION__));
g_imac_flag = MACADDR_MOD;
} else {
DHD_ERROR(("%s: "
"_dhd_set_mac_address()"
" failed\n", __FUNCTION__));
g_imac_flag = MACADDR_NONE;
}
}
}
}
fp_mac = filp_open(filepath_efs, O_RDONLY, 0);
if (IS_ERR(fp_mac)) { /* file does not exist */
/* read mac is the dummy mac (00:90:4C:C5:12:38) */
if (memcmp(cur_mac, dummy_mac, ETHER_ADDR_LEN) == 0)
g_imac_flag = MACADDR_MOD_RANDOM;
else if (strncmp(buf, "00:00:00:00:00:00", 17) == 0)
g_imac_flag = MACADDR_MOD_RANDOM;
else
g_imac_flag = MACADDR_MOD;
} else {
int is_zeromac;
ret = kernel_read(fp_mac, 0, buf, 18);
filp_close(fp_mac, NULL);
buf[17] = '\0';
is_zeromac = strncmp(buf, "00:00:00:00:00:00", 17);
DHD_ERROR(("MAC (FILE): [%s] [%d] \r\n",
buf, is_zeromac));
if (is_zeromac == 0) {
DHD_ERROR(("Zero MAC detected."
" Trying Random MAC.\n"));
g_imac_flag = MACADDR_MOD_RANDOM;
} else {
sscanf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
(unsigned int *)&(mac->octet[0]),
(unsigned int *)&(mac->octet[1]),
(unsigned int *)&(mac->octet[2]),
(unsigned int *)&(mac->octet[3]),
(unsigned int *)&(mac->octet[4]),
(unsigned int *)&(mac->octet[5]));
/* current MAC address is same as previous one */
if (memcmp(cur_mac, mac->octet, ETHER_ADDR_LEN) == 0) {
g_imac_flag = MACADDR_NONE;
} else { /* change MAC address */
if (_dhd_set_mac_address(dhd, 0, mac) == 0) {
DHD_INFO(("%s: MACID is"
" overwritten\n", __FUNCTION__));
g_imac_flag = MACADDR_MOD;
} else {
DHD_ERROR(("%s: "
"_dhd_set_mac_address()"
" failed\n", __FUNCTION__));
g_imac_flag = MACADDR_NONE;
}
}
}
}
} else {
/* COB type. only COB. */
/* Reading the MAC Address from .nvmac.info file
* (the existed file or just created file)
*/
ret = kernel_read(fp_nvm, 0, buf, 18);
/* to prevent abnormal string display when mac address
* is displayed on the screen.
*/
buf[17] = '\0';
DHD_ERROR(("Read MAC : [%s] [%d] \r\n", buf,
strncmp(buf, "00:00:00:00:00:00", 17)));
if ((buf[0] == '\0') ||
(strncmp(buf, "00:00:00:00:00:00", 17) == 0)) {
g_imac_flag = MACADDR_COB_RANDOM;
} else {
sscanf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
(unsigned int *)&(mac->octet[0]),
(unsigned int *)&(mac->octet[1]),
(unsigned int *)&(mac->octet[2]),
(unsigned int *)&(mac->octet[3]),
(unsigned int *)&(mac->octet[4]),
(unsigned int *)&(mac->octet[5]));
/* Writing Newly generated MAC ID to the Dongle */
if (_dhd_set_mac_address(dhd, 0, mac) == 0) {
DHD_INFO(("%s: MACID is overwritten\n",
__FUNCTION__));
g_imac_flag = MACADDR_COB;
} else {
DHD_ERROR(("%s: _dhd_set_mac_address()"
" failed\n", __FUNCTION__));
}
}
filp_close(fp_nvm, NULL);
}
if ((g_imac_flag == MACADDR_COB_RANDOM) ||
(g_imac_flag == MACADDR_MOD_RANDOM)) {
get_random_bytes(randommac, 3);
sprintf(macbuffer, "%02X:%02X:%02X:%02X:%02X:%02X\n",
0x60, 0xd0, 0xa9, randommac[0], randommac[1],
randommac[2]);
DHD_ERROR(("[WIFI] The Random Generated MAC ID : %s\n",
macbuffer));
sscanf(macbuffer, "%02X:%02X:%02X:%02X:%02X:%02X",
(unsigned int *)&(mac->octet[0]),
(unsigned int *)&(mac->octet[1]),
(unsigned int *)&(mac->octet[2]),
(unsigned int *)&(mac->octet[3]),
(unsigned int *)&(mac->octet[4]),
(unsigned int *)&(mac->octet[5]));
if (_dhd_set_mac_address(dhd, 0, mac) == 0) {
DHD_INFO(("%s: MACID is overwritten\n", __FUNCTION__));
g_imac_flag = MACADDR_COB;
} else {
DHD_ERROR(("%s: _dhd_set_mac_address() failed\n",
__FUNCTION__));
}
}
return 0;
}
void sec_control_pm(dhd_pub_t *dhd, uint *power_mode)
{
struct file *fp = NULL;
char *filepath = PSMINFO;
char power_val = 0;
char iovbuf[WL_EVENTING_MASK_LEN + 12];
#ifdef DHD_ENABLE_LPC
int ret = 0;
uint32 lpc = 0;
#endif /* DHD_ENABLE_LPC */
g_pm_control = FALSE;
fp = filp_open(filepath, O_RDONLY, 0);
if (IS_ERR(fp) || (fp == NULL)) {
/* Enable PowerSave Mode */
dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
sizeof(uint), TRUE, 0);
DHD_ERROR(("[%s, %d] /data/.psm.info open failed,"
" so set PM to %d\n",
__FUNCTION__, __LINE__, *power_mode));
return;
} else {
kernel_read(fp, fp->f_pos, &power_val, 1);
DHD_ERROR(("POWER_VAL = %c \r\n", power_val));
if (power_val == '0') {
#ifdef ROAM_ENABLE
uint roamvar = 1;
#endif
*power_mode = PM_OFF;
/* Disable PowerSave Mode */
dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
sizeof(uint), TRUE, 0);
/* Turn off MPC in AP mode */
bcm_mkiovar("mpc", (char *)power_mode, 4,
iovbuf, sizeof(iovbuf));
dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf,
sizeof(iovbuf), TRUE, 0);
g_pm_control = TRUE;
#ifdef ROAM_ENABLE
/* Roaming off of dongle */
bcm_mkiovar("roam_off", (char *)&roamvar, 4,
iovbuf, sizeof(iovbuf));
dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf,
sizeof(iovbuf), TRUE, 0);
#endif
#ifdef DHD_ENABLE_LPC
/* Set lpc 0 */
bcm_mkiovar("lpc", (char *)&lpc, 4, iovbuf, sizeof(iovbuf));
if ((ret = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf,
sizeof(iovbuf), TRUE, 0)) < 0) {
DHD_ERROR(("%s Set lpc failed %d\n", __FUNCTION__, ret));
}
#endif /* DHD_ENABLE_LPC */
} else {
dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
sizeof(uint), TRUE, 0);
}
}
if (fp)
filp_close(fp, NULL);
}
