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;
}
uint32 sec_save_wlinfo(char* firm_ver, char* dhd_ver, char* nvram_p)
{
struct file *fp = NULL;
struct file *nvfp = NULL;
char *filepath = "/data/.wifiver.info";
int min_len, str_len = 0;
int ret = 0;
char* nvram_buf;
char temp_buf[256];
DHD_TRACE(("[WIFI] %s: Entered.\n", __FUNCTION__));
DHD_INFO(("[WIFI] firmware version : %s\n", firm_ver));
DHD_INFO(("[WIFI] dhd driver version : %s\n", dhd_ver));
DHD_INFO(("[WIFI] nvram path : %s\n", nvram_p));
memset(version_info,0,sizeof(version_info));
if(strlen(dhd_ver)){
min_len = min(strlen(dhd_ver) , max_len(temp_buf, DHD_prefix));
min_len += strlen(DHD_prefix) + 3;
DHD_INFO(("[WIFI] DHD ver length : %d\n", min_len));
snprintf(version_info+str_len, min_len, DHD_prefix " %s\n",dhd_ver);
str_len = strlen(version_info);
DHD_INFO(("[WIFI] version_info len : %d\n", str_len));
DHD_INFO(("[WIFI] version_info : %s\n", version_info));
}else{
DHD_ERROR(("[WIFI] Driver version is missing.\n"));
}
if(strlen(firm_ver)){
min_len = min(strlen(firm_ver) , max_len(temp_buf, Firm_prefix));
min_len += strlen(Firm_prefix) + 3;
DHD_INFO(("[WIFI] firmware ver length : %d\n", min_len));
snprintf(version_info+str_len, min_len, Firm_prefix " %s\n",firm_ver);
str_len = strlen(version_info);
DHD_INFO(("[WIFI] version_info len : %d\n", str_len));
DHD_INFO(("[WIFI] version_info : %s\n", version_info));
}else{
DHD_ERROR(("[WIFI] Firmware version is missing.\n"));
}
if(nvram_p){
memset(temp_buf,0,sizeof(temp_buf));
nvfp = filp_open(nvram_p, O_RDONLY, 0);
if (IS_ERR(nvfp) || (nvfp == NULL)) {
DHD_ERROR(("[WIFI] %s: Nvarm File open failed.\n", __FUNCTION__));
return -1;
} else {
ret = kernel_read(nvfp, nvfp->f_pos, temp_buf, sizeof(temp_buf));
filp_close(nvfp, NULL);
}
if(strlen(temp_buf)){
nvram_buf = temp_buf;
bcmstrtok(&nvram_buf, "\n", 0);
DHD_INFO(("[WIFI] nvram tolkening : %s(%d) \n", temp_buf, strlen(temp_buf)));
snprintf(version_info+str_len, tstr_len(temp_buf, Nv_prefix), Nv_prefix " %s\n", temp_buf);
str_len = strlen(version_info);
DHD_INFO(("[WIFI] version_info : %s\n", version_info));
DHD_INFO(("[WIFI] version_info len : %d, nvram len : %d\n", str_len, strlen(temp_buf)));
}else{
DHD_ERROR(("[WIFI] No info is missing.\n"));
}
}else{
DHD_ERROR(("[WIFI] No nvram path\n"));
}
DHD_INFO(("[WIFI] version_info : %s, strlen : %d\n", version_info,strlen(version_info)));
fp = filp_open(filepath, O_RDONLY, 0);
if (fp != NULL) {
if (IS_ERR(fp) || (fp == NULL)) {
DHD_INFO(("[WIFI] %s: File open failed.\n", __FUNCTION__));
} else {
memset(version_old_info, 0, sizeof(version_old_info));
ret = kernel_read(fp, fp->f_pos, version_old_info, sizeof(version_info));
filp_close(fp, NULL);
DHD_INFO(("[WIFI] kernel_read ret : %d.\n", ret));
if(strcmp(version_info,version_old_info) == 0){
DHD_ERROR(("[WIFI] %s: : already saved.\n", __FUNCTION__));
return 0;
}
}
}
fp = filp_open(filepath, O_RDWR | O_CREAT, 0666);
if (IS_ERR(fp) || (fp == NULL)) {
DHD_ERROR(("[WIFI] %s: File open failed.\n",
__FUNCTION__));
} else {
ret = write_filesystem(fp, fp->f_pos, version_info, sizeof(version_info));
DHD_INFO(("[WIFI] sec_save_wlinfo done. ret : %d\n",ret));
DHD_ERROR(("[WIFI] save .wifiver.info file.\n"));
filp_close(fp, NULL);
}
return ret;
}
void
dhd_pktfilter_offload_set(dhd_pub_t * dhd, char *arg)
{
const char *str;
wl_pkt_filter_t pkt_filter;
wl_pkt_filter_t *pkt_filterp;
int buf_len;
int str_len;
int rc;
uint32 mask_size;
uint32 pattern_size;
char *argv[8], * buf = 0;
int i = 0;
char *arg_save = 0, *arg_org = 0;
#define BUF_SIZE 2048
if (!(arg_save = MALLOC(dhd->osh, strlen(arg) + 1))) {
DHD_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
goto fail;
}
arg_org = arg_save;
if (!(buf = MALLOC(dhd->osh, BUF_SIZE))) {
DHD_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
goto fail;
}
memcpy(arg_save, arg, strlen(arg) + 1);
if (strlen(arg) > BUF_SIZE) {
DHD_ERROR(("Not enough buffer %d < %d\n", (int)strlen(arg), (int)sizeof(buf)));
goto fail;
}
argv[i] = bcmstrtok(&arg_save, " ", 0);
while (argv[i++])
argv[i] = bcmstrtok(&arg_save, " ", 0);
i = 0;
if (NULL == argv[i]) {
DHD_ERROR(("No args provided\n"));
goto fail;
}
str = "pkt_filter_add";
str_len = strlen(str);
strncpy(buf, str, str_len);
buf[ str_len ] = '\0';
buf_len = str_len + 1;
pkt_filterp = (wl_pkt_filter_t *) (buf + str_len + 1);
/* Parse packet filter id. */
pkt_filter.id = htod32(strtoul(argv[i], NULL, 0));
if (NULL == argv[++i]) {
DHD_ERROR(("Polarity not provided\n"));
goto fail;
}
/* Parse filter polarity. */
pkt_filter.negate_match = htod32(strtoul(argv[i], NULL, 0));
if (NULL == argv[++i]) {
DHD_ERROR(("Filter type not provided\n"));
goto fail;
}
/* Parse filter type. */
pkt_filter.type = htod32(strtoul(argv[i], NULL, 0));
if (NULL == argv[++i]) {
DHD_ERROR(("Offset not provided\n"));
goto fail;
}
/* Parse pattern filter offset. */
pkt_filter.u.pattern.offset = htod32(strtoul(argv[i], NULL, 0));
if (NULL == argv[++i]) {
DHD_ERROR(("Bitmask not provided\n"));
goto fail;
}
/* Parse pattern filter mask. */
mask_size =
htod32(wl_pattern_atoh(argv[i], (char *) pkt_filterp->u.pattern.mask_and_pattern));
if (NULL == argv[++i]) {
DHD_ERROR(("Pattern not provided\n"));
goto fail;
}
/* Parse pattern filter pattern. */
pattern_size =
htod32(wl_pattern_atoh(argv[i],
(char *) &pkt_filterp->u.pattern.mask_and_pattern[mask_size]));
if (mask_size != pattern_size) {
DHD_ERROR(("Mask and pattern not the same size\n"));
goto fail;
}
pkt_filter.u.pattern.size_bytes = mask_size;
buf_len += WL_PKT_FILTER_FIXED_LEN;
buf_len += (WL_PKT_FILTER_PATTERN_FIXED_LEN + 2 * mask_size);
/* Keep-alive attributes are set in local variable (keep_alive_pkt), and
** then memcpy'ed into buffer (keep_alive_pktp) since there is no
** guarantee that the buffer is properly aligned.
*/
memcpy((char *)pkt_filterp,
&pkt_filter,
WL_PKT_FILTER_FIXED_LEN + WL_PKT_FILTER_PATTERN_FIXED_LEN);
rc = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, buf, buf_len, TRUE, 0);
rc = rc >= 0 ? 0 : rc;
if (rc)
DHD_TRACE(("%s: failed to add pktfilter %s, retcode = %d\n",
__FUNCTION__, arg, rc));
else
DHD_TRACE(("%s: successfully added pktfilter %s\n",
__FUNCTION__, arg));
fail:
if (arg_org)
MFREE(dhd->osh, arg_org, strlen(arg) + 1);
if (buf)
MFREE(dhd->osh, buf, BUF_SIZE);
}
void
dhd_pktfilter_offload_enable(dhd_pub_t * dhd, char *arg, int enable, int master_mode)
{
char *argv[8];
int i = 0;
const char *str;
int buf_len;
int str_len;
char *arg_save = 0, *arg_org = 0;
int rc;
char buf[128];
wl_pkt_filter_enable_t enable_parm;
wl_pkt_filter_enable_t * pkt_filterp;
if (!(arg_save = MALLOC(dhd->osh, strlen(arg) + 1))) {
DHD_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
goto fail;
}
arg_org = arg_save;
memcpy(arg_save, arg, strlen(arg) + 1);
argv[i] = bcmstrtok(&arg_save, " ", 0);
i = 0;
if (NULL == argv[i]) {
DHD_ERROR(("No args provided\n"));
goto fail;
}
str = "pkt_filter_enable";
str_len = strlen(str);
strncpy(buf, str, str_len);
buf[str_len] = '\0';
buf_len = str_len + 1;
pkt_filterp = (wl_pkt_filter_enable_t *)(buf + str_len + 1);
/* Parse packet filter id. */
enable_parm.id = htod32(strtoul(argv[i], NULL, 0));
/* Parse enable/disable value. */
enable_parm.enable = htod32(enable);
buf_len += sizeof(enable_parm);
memcpy((char *)pkt_filterp,
&enable_parm,
sizeof(enable_parm));
/* Enable/disable the specified filter. */
rc = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, buf, buf_len, TRUE, 0);
rc = rc >= 0 ? 0 : rc;
if (rc)
DHD_TRACE(("%s: failed to add pktfilter %s, retcode = %d\n",
__FUNCTION__, arg, rc));
else
DHD_TRACE(("%s: successfully added pktfilter %s\n",
__FUNCTION__, arg));
/* Contorl the master mode */
bcm_mkiovar("pkt_filter_mode", (char *)&master_mode, 4, buf, sizeof(buf));
rc = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, buf, sizeof(buf), TRUE, 0);
rc = rc >= 0 ? 0 : rc;
if (rc)
DHD_TRACE(("%s: failed to add pktfilter %s, retcode = %d\n",
__FUNCTION__, arg, rc));
fail:
if (arg_org)
MFREE(dhd->osh, arg_org, strlen(arg) + 1);
}
/* Keep-alive attributes are set in local variable (keep_alive_pkt), and
** then memcpy'ed into buffer (keep_alive_pktp) since there is no
** guarantee that the buffer is properly aligned.
*/
memcpy((char *)pkt_filterp,
&pkt_filter,
WL_PKT_FILTER_FIXED_LEN + WL_PKT_FILTER_PATTERN_FIXED_LEN);
rc = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, buf, buf_len);
rc = rc >= 0 ? 0 : rc;
if (rc)
DHD_TRACE(("%s: failed to add pktfilter %s, retcode = %d\n",
__FUNCTION__, arg, rc));
else
DHD_TRACE(("%s: successfully added pktfilter %s\n",
__FUNCTION__, arg));
fail:
if (arg_org)
MFREE(dhd->osh, arg_org, strlen(arg) + 1);
if (buf)
MFREE(dhd->osh, buf, BUF_SIZE);
}
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 = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
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 = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
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));
}
#if defined(CONFIG_TARGET_LOCALE_KOR)
uint g_pm = PM_OFF;
#endif /* CONFIG_TARGET_LOCALE_KOR */
int
dhd_preinit_ioctls(dhd_pub_t *dhd)
{
char iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" + '\0' + bitvec */
uint up = 0;
char buf[128], *ptr;
uint power_mode = PM_FAST;
uint32 dongle_align = DHD_SDALIGN;
uint32 glom = 0;
uint bcn_timeout = 3;
int scan_assoc_time = 40;
int scan_unassoc_time = 80;
#ifdef CONFIG_TARGET_LOCALE_KOR
struct file *fp = NULL;
char* filepath = "/data/.psm.info";
char* lcdfilepath = "/data/.lcdmode.info";
#endif /* CONFIG_TARGET_LOCALE_KOR */
#ifdef SCAN_5G_HOMECHANNEL_TIME
int scan_home_time = 60;
#endif
#ifdef FCC_CERT
uint spect = 0;
#endif
#ifdef SOFTAP
if(!ap_fw_loaded) {
#endif /* SOFTAP */
/* Set Country code */
if (dhd->country_code[0] != 0) {
if (dhdcdc_set_ioctl(dhd, 0, WLC_SET_COUNTRY,
dhd->country_code, sizeof(dhd->country_code)) < 0) {
DHD_ERROR(("%s: country code setting failed\n", __FUNCTION__));
}
}
#ifdef SOFTAP
}
#endif /* SOFTAP */
/* query for 'ver' to get version info from firmware */
memset(buf, 0, sizeof(buf));
ptr = buf;
bcm_mkiovar("ver", 0, 0, buf, sizeof(buf));
dhdcdc_query_ioctl(dhd, 0, WLC_GET_VAR, buf, sizeof(buf));
bcmstrtok(&ptr, "\n", 0);
/* Print fw version info */
DHD_ERROR(("Firmware version = %s\n", buf));
#ifdef BCMDISABLE_PM
/*Disable Power save features for CERTIFICATION*/
power_mode = PM_OFF;
/* Set PowerSave mode */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode));
#ifdef CONFIG_TARGET_LOCALE_KOR
DHD_TRACE(("[BCM4329] Power Save Mode disabled\n"));
#endif /* CONFIG_TARGET_LOCALE_KOR */
/* Disable MPC */
bcm_mkiovar("mpc", (char *)&power_mode, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
#else /* BCMDISABLE_PM */
#ifdef CONFIG_TARGET_LOCALE_KOR
/* Set PowerSave mode */
fp = filp_open(filepath, O_RDONLY, 0);
if(IS_ERR(fp))// the file is not exist
{
DHD_ERROR(("[BCM4329] /data/.psm.info not found\n"));
/* Enable Power save features for CERTIFICATION*/
power_mode = PM_MAX;
g_pm = PM_MAX;
/* Set PowerSave mode */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode));
DHD_ERROR(("[BCM4329] PM Enabled\n"));
fp = filp_open(filepath, O_RDWR | O_CREAT, 0666);
if(IS_ERR(fp)||(fp==NULL))
{
DHD_TRACE(("[WIFI] %s: File open error\n", filepath));
}
else
{
char buffer[2] = {0};
if(fp->f_mode & FMODE_WRITE)
{
sprintf(buffer,"1\n");
fp->f_op->write(fp, (const char *)buffer, sizeof(buffer), &fp->f_pos);
DHD_TRACE(("[BCM4329] Write /data/.psm.info -> 1\n"));
}
}
}
else
{
char buffer;
DHD_TRACE(("[BCM4329] /data/.psm.info found!!\n"));
kernel_read(fp, fp->f_pos, &buffer, 1);
if(buffer==0x31)
{
/* Set PowerSave mode */
power_mode = PM_MAX;
g_pm = PM_MAX;
dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode));
DHD_TRACE(("[BCM4329] PM enabled\n"));
}
else
{
/*Disable Power save features for WAPI CERTIFICATION*/
power_mode = PM_OFF;
g_pm = PM_OFF;
/* Set PowerSave mode */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode));
DHD_TRACE(("[BCM4329] PM disabled\n"));
/* Disable MPC */
bcm_mkiovar("mpc", (char *)&power_mode, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
}
}
if(fp) {
filp_close(fp, NULL);
}
/* Set LCD mode */
fp = filp_open(lcdfilepath, O_RDONLY, 0);
if(IS_ERR(fp))// the file is not exist
{
DHD_TRACE(("[BCM4329] /data/.lcdmode.info not found\n"));
fp = filp_open(lcdfilepath, O_RDWR | O_CREAT, 0666);
if(IS_ERR(fp)||(fp==NULL))
{
DHD_TRACE(("[WIFI] %s: LCD mode file open error\n", filepath));
}
else
{
char buffer[2] = {0};
if(fp->f_mode & FMODE_WRITE)
{
sprintf(buffer,"0\n");
fp->f_op->write(fp, (const char *)buffer, sizeof(buffer), &fp->f_pos);
DHD_TRACE(("[BCM4329] Write /data/.lcdmode.info -> 0\n"));
}
}
if(fp) {
filp_close(fp, NULL);
}
}
#else /* CONFIG_TARGET_LOCALE_KOR */
/* Set PowerSave mode */
power_mode = PM_MAX;
#if defined(CONFIG_TARGET_LOCALE_KOR)
g_pm = PM_MAX;
#endif /* CONFIG_TARGET_LOCALE_KOR */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode));
#endif /* CONFIG_TARGET_LOCALE_KOR */
#endif //BCMDISABLE_PM
#ifdef SOFTAP
if(!ap_fw_loaded) {
#endif /* SOFTAP */
#ifdef FCC_CERT
dhdcdc_set_ioctl(dhd, 0, WLC_DOWN, (char *)&up, sizeof(up));
/* Disable TPC to get qualification of FCC */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_SPECT_MANAGMENT, (char *)&spect, sizeof(spect));
#endif /* FCC_CERT */
#ifdef SOFTAP
}
#endif /* SOFTAP */
/* Match Host and Dongle rx alignment */
bcm_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
/* disable glom option per default */
bcm_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
/* 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));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
/* Enable/Disable build-in roaming to allowed ext supplicant to take of romaing */
bcm_mkiovar("roam_off", (char *)&dhd_roam, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
/* Force STA UP */
if (dhd_radio_up)
dhdcdc_set_ioctl(dhd, 0, WLC_UP, (char *)&up, sizeof(up));
/* Setup event_msgs */
bcm_mkiovar("event_msgs", dhd->eventmask, WL_EVENTING_MASK_LEN, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_SCAN_CHANNEL_TIME, (char *)&scan_assoc_time,
sizeof(scan_assoc_time));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_SCAN_UNASSOC_TIME, (char *)&scan_unassoc_time,
sizeof(scan_unassoc_time));
#ifdef SCAN_5G_HOMECHANNEL_TIME
DHD_INFO(("Scan Channel Home Time Set : 80 ms \r\n"));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_SCAN_HOME_TIME, (char *)&scan_home_time,
sizeof(scan_home_time));
#endif
#ifdef ARP_OFFLOAD_SUPPORT
/* Set and enable ARP offload feature */
if (dhd_arp_enable)
dhd_arp_offload_set(dhd, dhd_arp_mode);
dhd_arp_offload_enable(dhd, dhd_arp_enable);
#endif /* ARP_OFFLOAD_SUPPORT */
#ifdef PKT_FILTER_SUPPORT
{
int i;
/* Set up pkt filter */
if (dhd_pkt_filter_enable) {
for (i = 0; i < dhd->pktfilter_count; i++) {
dhd_pktfilter_offload_set(dhd, dhd->pktfilter[i]);
dhd_pktfilter_offload_enable(dhd, dhd->pktfilter[i],
0, dhd_master_mode);
}
}
}
#endif /* PKT_FILTER_SUPPORT */
return 0;
}
int
dhd_preinit_ioctls(dhd_pub_t *dhd)
{
char iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" + '\0' + bitvec */
uint up = 0;
char buf[128], *ptr;
uint power_mode = PM_FAST;
uint32 dongle_align = DHD_SDALIGN;
uint32 glom = 0;
uint bcn_timeout = 3;
int scan_assoc_time = 40;
int scan_unassoc_time = 80;
int roam_delta[2];
int roam_scan_period = 2;
#ifdef SCAN_5G_HOMECHANNEL_TIME
int scan_home_time = 60;
#endif
#ifdef FCC_CERT
uint spect = 0;
#endif
struct file *fp = NULL;
char* filepath = "/data/.psm.info";
int qosinfo = 1; /* enable VO AC */
#ifdef SOFTAP
if(!ap_fw_loaded) {
#endif /* SOFTAP */
/* Set Country code */
if (dhd->country_code[0] != 0) {
if (dhdcdc_set_ioctl(dhd, 0, WLC_SET_COUNTRY,
dhd->country_code, sizeof(dhd->country_code)) < 0) {
DHD_ERROR(("%s: country code setting failed\n", __FUNCTION__));
}
}
#ifdef SOFTAP
}
#endif /* SOFTAP */
/* query for 'ver' to get version info from firmware */
memset(buf, 0, sizeof(buf));
ptr = buf;
bcm_mkiovar("ver", 0, 0, buf, sizeof(buf));
dhdcdc_query_ioctl(dhd, 0, WLC_GET_VAR, buf, sizeof(buf));
bcmstrtok(&ptr, "\n", 0);
/* Print fw version info */
DHD_ERROR(("Firmware version = %s\n", buf));
/////////////////////////
/* Set PowerSave mode */
fp = filp_open(filepath, O_RDONLY, 0);
if(IS_ERR(fp))// the file is not exist
{
/* Set PowerSave mode */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode));
fp = filp_open(filepath, O_RDWR | O_CREAT, 0666);
if(IS_ERR(fp)||(fp==NULL))
{
DHD_ERROR(("[WIFI] %s: File open error\n", filepath));
}
else
{
char buffer[2] = {1};
if(fp->f_mode & FMODE_WRITE)
{
sprintf(buffer,"1\n");
fp->f_op->write(fp, (const char *)buffer, sizeof(buffer), &fp->f_pos);
}
}
}
else
{
char buffer[1] = {0};
kernel_read(fp, fp->f_pos, buffer, 1);
if(strncmp(buffer, "1",1)==0)
{
/* Set PowerSave mode */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode));
}
else
{
/*Disable Power save features for CERTIFICATION*/
power_mode = 0;
/* Set PowerSave mode */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_PM, (char *)&power_mode, sizeof(power_mode));
/* Disable MPC */
bcm_mkiovar("mpc", (char *)&power_mode, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
fp = filp_open(filepath, O_RDWR | O_CREAT, 0666);
if(IS_ERR(fp)||(fp==NULL))
{
DHD_ERROR(("[WIFI] %s: File open error\n", filepath));
}
else
{
char buffer[2] = {1};
if(fp->f_mode & FMODE_WRITE)
{
sprintf(buffer,"1\n");
fp->f_op->write(fp, (const char *)buffer, sizeof(buffer), &fp->f_pos);
}
}
}
}
if(fp)
filp_close(fp, NULL);
#ifdef SOFTAP
if(!ap_fw_loaded) {
#endif /* SOFTAP */
#ifdef FCC_CERT
dhdcdc_set_ioctl(dhd, 0, WLC_DOWN, (char *)&up, sizeof(up));
/* Disable TPC to get qualification of FCC */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_SPECT_MANAGMENT, (char *)&spect, sizeof(spect));
#endif /* FCC_CERT */
#ifdef SOFTAP
}
#endif /* SOFTAP */
/* Match Host and Dongle rx alignment */
bcm_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
/* disable glom option per default */
bcm_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
/* 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));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
/* Enable/Disable build-in roaming to allowed ext supplicant to take of romaing */
bcm_mkiovar("roam_off", (char *)&dhd_roam, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
/* Enable UAPSD for voice packet AC=VO */
bcm_mkiovar("wme_qosinfo", (char *)&qosinfo, 4, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
/* Force STA UP */
if (dhd_radio_up)
dhdcdc_set_ioctl(dhd, 0, WLC_UP, (char *)&up, sizeof(up));
/* Setup event_msgs */
bcm_mkiovar("event_msgs", dhd->eventmask, WL_EVENTING_MASK_LEN, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_SCAN_CHANNEL_TIME, (char *)&scan_assoc_time,
sizeof(scan_assoc_time));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_SCAN_UNASSOC_TIME, (char *)&scan_unassoc_time,
sizeof(scan_unassoc_time));
/* roaming delta = 10 dBm */
roam_delta[0] = 10;
roam_delta[1] = WLC_BAND_AUTO;
dhdcdc_set_ioctl(dhd, 0, WLC_SET_ROAM_DELTA, (char *)roam_delta, sizeof(roam_delta));
/* roaming scan period = 2 seconds */
dhdcdc_set_ioctl(dhd, 0, WLC_SET_ROAM_SCAN_PERIOD, (char *)&roam_scan_period, sizeof(roam_scan_period));
#ifdef SCAN_5G_HOMECHANNEL_TIME
DHD_INFO(("Scan Channel Home Time Set : 80 ms \r\n"));
dhdcdc_set_ioctl(dhd, 0, WLC_SET_SCAN_HOME_TIME, (char *)&scan_home_time,
sizeof(scan_home_time));
#endif
#ifdef ARP_OFFLOAD_SUPPORT
/* Set and enable ARP offload feature */
if (dhd_arp_enable)
dhd_arp_offload_set(dhd, dhd_arp_mode);
dhd_arp_offload_enable(dhd, dhd_arp_enable);
#endif /* ARP_OFFLOAD_SUPPORT */
#ifdef PKT_FILTER_SUPPORT
{
int i;
/* Set up pkt filter */
if (dhd_pkt_filter_enable) {
for (i = 0; i < dhd->pktfilter_count; i++) {
dhd_pktfilter_offload_set(dhd, dhd->pktfilter[i]);
dhd_pktfilter_offload_enable(dhd, dhd->pktfilter[i],
0, dhd_master_mode);
}
}
}
#endif /* PKT_FILTER_SUPPORT */
return 0;
}
