static s32 wl_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout) { s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; s32 err = 0; /* Setup timeout if Beacons are lost and roam is off to report link down */ if (roamvar) { bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf, sizeof(iovbuf)); err = wldev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf), true); if (unlikely(err)) { WL_ERR(("bcn_timeout error (%d)\n", err)); goto dongle_rom_out; } } /* Enable/Disable built-in roaming to allow supplicant to take care of roaming */ bcm_mkiovar("roam_off", (char *)&roamvar, 4, iovbuf, sizeof(iovbuf)); err = wldev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf), true); if (unlikely(err)) { WL_ERR(("roam_off error (%d)\n", err)); goto dongle_rom_out; } dongle_rom_out: return err; }
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; }
static s32 wl_dongle_offload(struct net_device *ndev, s32 arpoe, s32 arp_ol) { /* Room for "event_msgs" + '\0' + bitvec */ s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; s32 err = 0; /* Set ARP offload */ bcm_mkiovar("arpoe", (char *)&arpoe, 4, iovbuf, sizeof(iovbuf)); err = wldev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf), true); if (err) { if (err == -EOPNOTSUPP) WL_INFO(("arpoe is not supported\n")); else WL_ERR(("arpoe error (%d)\n", err)); goto dongle_offload_out; } bcm_mkiovar("arp_ol", (char *)&arp_ol, 4, iovbuf, sizeof(iovbuf)); err = wldev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf), true); if (err) { if (err == -EOPNOTSUPP) WL_INFO(("arp_ol is not supported\n")); else WL_ERR(("arp_ol error (%d)\n", err)); goto dongle_offload_out; } dongle_offload_out: return err; }
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)); ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf)); if (ret >= 0) { /* clear pfn */ iov_len = bcm_mkiovar("pfnclear", 0, 0, iovbuf, sizeof(iovbuf)); if (iov_len) { ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, iov_len); if (ret < 0) { DHD_ERROR(("%s failed code %d\n", __func__, ret)); } } else { ret = -1; DHD_ERROR(("%s failed code %d\n", __func__, iov_len)); } } else DHD_ERROR(("%s failed code %d\n", __func__, ret)); return ret; }
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; }
static s32 wl_dongle_glom(struct net_device *ndev, u32 glom, u32 dongle_align) { s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; s32 err = 0; /* Match Host and Dongle rx alignment */ bcm_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf, sizeof(iovbuf)); err = wldev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf), true); if (unlikely(err)) { WL_ERR(("txglomalign error (%d)\n", err)); goto dongle_glom_out; } /* disable glom option per default */ bcm_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf)); err = wldev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf), true); if (unlikely(err)) { WL_ERR(("txglom error (%d)\n", err)); goto dongle_glom_out; } dongle_glom_out: return err; }
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; }
int dhd_deepsleep(struct net_device *dev, int flag) { char iovbuf[20]; uint powervar = 0; dhd_pub_t *dhdp = dhd_get_pub(dev); int cnt = 0; int ret = 0; switch (flag) { case 1 : /* Deepsleep on */ DHD_ERROR(("[WiFi] Deepsleep On\n")); /* Disable MPC */ powervar = 0; bcm_mkiovar("mpc", (char *)&powervar, 4, iovbuf, sizeof(iovbuf)); dhdcdc_set_ioctl(dhdp, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf)); /* Enable Deepsleep*/ powervar = 1; bcm_mkiovar("deepsleep", (char *)&powervar, 4, iovbuf, sizeof(iovbuf)); dhdcdc_set_ioctl(dhdp, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf)); break; case 0: /* Deepsleep Off */ DHD_ERROR(("[WiFi] Deepsleep Off\n")); /* Disable Deepsleep */ for( cnt = 0 ; cnt < MAX_TRY_CNT ; cnt++ ) { powervar = 0; bcm_mkiovar("deepsleep", (char *)&powervar, 4, iovbuf, sizeof(iovbuf)); dhdcdc_set_ioctl(dhdp, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf)); memset(iovbuf,0,sizeof(iovbuf)); strcpy(iovbuf, "deepsleep"); if ((ret = dhdcdc_query_ioctl(dhdp, 0, WLC_GET_VAR, iovbuf, sizeof(iovbuf))) < 0 ) { DHD_ERROR(("the error of dhd deepsleep status ret value : %d\n",ret)); }else { if(!(*(int *)iovbuf )) { DHD_ERROR(("deepsleep mode is 0, ok , count : %d\n",cnt)); break; } } } /* Enable MPC */ powervar = 1; memset(iovbuf,0,sizeof(iovbuf)); bcm_mkiovar("mpc", (char *)&powervar, 4, iovbuf, sizeof(iovbuf)); dhdcdc_set_ioctl(dhdp, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf)); break; } 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; }
/* Send HCI cmd via wl iovar HCI_cmd to the dongle. */ int dhd_bta_docmd(dhd_pub_t *pub, void *cmd_buf, uint cmd_len) { amp_hci_cmd_t *cmd = (amp_hci_cmd_t *)cmd_buf; uint8 buf[BTA_HCI_CMD_MAX_LEN + 16]; uint len = sizeof(buf); wl_ioctl_t ioc; if (cmd_len < HCI_CMD_PREAMBLE_SIZE) return BCME_BADLEN; if ((uint)cmd->plen + HCI_CMD_PREAMBLE_SIZE > cmd_len) return BCME_BADLEN; len = bcm_mkiovar("HCI_cmd", (char *)cmd, (uint)cmd->plen + HCI_CMD_PREAMBLE_SIZE, (char *)buf, len); memset(&ioc, 0, sizeof(ioc)); ioc.cmd = WLC_SET_VAR; ioc.buf = buf; ioc.len = len; ioc.set = TRUE; return dhd_wl_ioctl(pub, &ioc, ioc.buf, ioc.len); }
int dhd_arp_get_arp_hostip_table(dhd_pub_t *dhd, void *buf, int buflen) { #ifdef ARP_OFFLOAD_SUPPORT int retcode; int iov_len = 0; if (!buf) return -1; dhd_os_proto_block(dhd); iov_len = bcm_mkiovar("arp_hostip", 0, 0, buf, buflen); retcode = dhdcdc_query_ioctl(dhd, 0, WLC_GET_VAR, buf, buflen); dhd_os_proto_unblock(dhd); if (retcode) { DHD_TRACE(("%s: ioctl WLC_GET_VAR error %d\n", __FUNCTION__, retcode)); return -1; } #endif /* ARP_OFFLOAD_SUPPORT */ 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", __func__)); return ret; } /* Enable/disable PNO */ ret = bcm_mkiovar("pfn", (char *)&pfn_enabled, 4, iovbuf, sizeof(iovbuf)); if (ret > 0) { ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf)); if (ret < 0) { DHD_ERROR(("%s failed for error=%d\n", __func__, ret)); return ret; } else { dhd->pno_enable = pfn_enabled; DHD_TRACE(("%s set pno as %d\n", __func__, dhd->pno_enable)); } } else DHD_ERROR(("%s failed err=%d\n", __func__, ret)); return ret; }
int dhd_iscan_request(void *dhdp, u16 action) { int rc; wl_iscan_params_t params; dhd_pub_t *dhd = dhd_bus_pub(dhdp); char buf[WLC_IOCTL_SMLEN]; memset(¶ms, 0, sizeof(wl_iscan_params_t)); memcpy(¶ms.params.bssid, ðer_bcast, ETH_ALEN); params.params.bss_type = DOT11_BSSTYPE_ANY; params.params.scan_type = DOT11_SCANTYPE_ACTIVE; params.params.nprobes = -1; params.params.active_time = -1; params.params.passive_time = -1; params.params.home_time = -1; params.params.channel_num = 0; params.version = ISCAN_REQ_VERSION; params.action = action; params.scan_duration = 0; bcm_mkiovar("iscan", (char *)¶ms, sizeof(wl_iscan_params_t), buf, WLC_IOCTL_SMLEN); rc = dhd_wl_ioctl(dhdp, WLC_SET_VAR, buf, WLC_IOCTL_SMLEN); return rc; }
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; }
/* Format a iovar buffer, not bsscfg indexed. The bsscfg index will be * taken care of in dhd_ioctl_entry. Internal use only, not exposed to * wl_iw, wl_cfg80211 and wl_cfgp2p */ static s32 wldev_mkiovar( s8 *iovar_name, s8 *param, s32 paramlen, s8 *iovar_buf, u32 buflen) { s32 iolen = 0; iolen = bcm_mkiovar(iovar_name, param, paramlen, iovar_buf, buflen); return iolen; }
/* 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; }
static int dev_wlc_bufvar_set(struct net_device *dev, char *name, char *buf, int len) { #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31) char ioctlbuf_local[1024]; #else static char ioctlbuf_local[1024]; #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31) */ bcm_mkiovar(name, buf, len, ioctlbuf_local, sizeof(ioctlbuf_local)); return (wldev_ioctl(dev, WLC_SET_VAR, ioctlbuf_local, sizeof(ioctlbuf_local), true)); }
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)); } } }
void dhd_arp_cleanup(dhd_pub_t *dhd) { #ifdef ARP_OFFLOAD_SUPPORT int ret = 0; int iov_len = 0; char iovbuf[128]; if (dhd == NULL) return; dhd_os_proto_block(dhd); iov_len = bcm_mkiovar("arp_hostip_clear", 0, 0, iovbuf, sizeof(iovbuf)); if ((ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, iov_len)) < 0) DHD_ERROR(("%s failed code %d\n", __FUNCTION__, ret)); iov_len = bcm_mkiovar("arp_table_clear", 0, 0, iovbuf, sizeof(iovbuf)); if ((ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, iov_len)) < 0) DHD_ERROR(("%s failed code %d\n", __FUNCTION__, ret)); dhd_os_proto_unblock(dhd); #endif /* ARP_OFFLOAD_SUPPORT */ }
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; iscan_cur = dhd_iscan_allocate_buf(dhd, &iscan_chain); if (!iscan_cur) { DHD_ERROR(("%s: Failed to allocate node\n", __func__)); dhd_iscan_free_buf(dhdp, 0); dhd_iscan_request(dhdp, WL_SCAN_ACTION_ABORT); 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 = 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(dhdp, WLC_GET_VAR, iscan_cur->iscan_buf, WLC_IW_ISCAN_MAXLEN); results->buflen = results->buflen; results->version = results->version; *scan_count = results->count = results->count; status = list_buf->status; dhd_iscan_unlock(); if (!(*scan_count)) dhd_iscan_free_buf(dhdp, iscan_cur); else dhd_iscan_remove_duplicates(dhdp, iscan_cur); fail: return status; }
/* * 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; }
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", __func__, arp_mode, retcode)); else DHD_TRACE(("%s: successfully set ARP offload mode to 0x%x\n", __func__, arp_mode)); }
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_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_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", __func__, arp_enable, retcode)); else DHD_TRACE(("%s: successfully enabed ARP offload to %d\n", __func__, arp_enable)); }