void
dhd_customer_gpio_wlan_ctrl(int onoff)
#endif
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
#if defined(CONFIG_LGE_BCM432X_PATCH)
if (gpio_get_value(CONFIG_BCM4325_GPIO_WL_RESET)) {
if(irq_detect_ctrl)
disable_irq(gpio_to_irq(CONFIG_BCM4325_GPIO_WL_RESET));
gpio_set_value(CONFIG_BCM4325_GPIO_WL_RESET, 0);
}
#endif
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
#if defined(CONFIG_LGE_BCM432X_PATCH)
if (!gpio_get_value(CONFIG_BCM4325_GPIO_WL_RESET)) {
gpio_set_value(CONFIG_BCM4325_GPIO_WL_RESET, 1);
if(irq_detect_ctrl)
enable_irq(gpio_to_irq(CONFIG_BCM4325_GPIO_WL_RESET));
}
#endif
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif
#if defined(CONFIG_LGE_BCM432X_PATCH)
#ifdef CONFIG_BCM4325_GPIO_WL_REGON
if (!gpio_get_value(CONFIG_BCM4325_GPIO_BT_RESET)) {
gpio_set_value(CONFIG_BCM4325_GPIO_WL_REGON, 0);
}
#endif
#endif
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif
#if defined(CONFIG_LGE_BCM432X_PATCH)
#ifdef CONFIG_BCM4325_GPIO_WL_REGON
if (!gpio_get_value(CONFIG_BCM4325_GPIO_WL_REGON)) {
gpio_set_value(CONFIG_BCM4325_GPIO_WL_REGON, 1);
mdelay(150);
}
#endif
#else
OSL_DELAY(500);
#endif
break;
}
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
#if defined CUSTOMER_ALLWINNER && defined CONFIG_SW_MMC_POWER_CONTROL
unsigned int mod_sel = mmc_pm_get_mod_type();
#endif
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
/* winner's power control */
#if defined CUSTOMER_ALLWINNER && defined CONFIG_SW_MMC_POWER_CONTROL
switch (mod_sel)
{
case 2: /* usi bm01a */
mmc_pm_gpio_ctrl("usi_bm01a_wl_rst", 0);
mmc_pm_gpio_ctrl("usi_bm01a_wl_regon", 0);
break;
case 5: /* swb b23 */
mmc_pm_gpio_ctrl("swbb23_wl_shdn", 0);
break;
default:
printk("[bcm4329]: no wifi module matched !!\n");
}
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(0, 0);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
/* winner's power control */
#if defined CUSTOMER_ALLWINNER && defined CONFIG_SW_MMC_POWER_CONTROL
switch (mod_sel)
{
case 2: /* usi bm01a */
mmc_pm_gpio_ctrl("usi_bm01a_wl_regon", 1);
mmc_pm_gpio_ctrl("usi_bm01a_wl_rst", 1);
break;
case 5: /* swb b23 */
mmc_pm_gpio_ctrl("swbb23_wl_shdn", 1);
break;
default:
printk("[bcm4329]: no wifi module matched !!\n");
}
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(1, 0);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
OSL_DELAY(10000);
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
/* winner's power control */
#if defined CUSTOMER_ALLWINNER && defined CONFIG_SW_MMC_POWER_CONTROL
switch (mod_sel)
{
case 2: /* usi bm01a */
mmc_pm_gpio_ctrl("usi_bm01a_wl_rst", 0);
mmc_pm_gpio_ctrl("usi_bm01a_wl_regon", 0);
break;
case 5: /* swb b23 */
mmc_pm_gpio_ctrl("swbb23_wl_shdn", 0);
break;
default:
printk("[bcm4329]: no wifi module matched !!\n");
}
sw_mmc_rescan_card(3, 0);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
/* winner's power control */
#if defined CUSTOMER_ALLWINNER && defined CONFIG_SW_MMC_POWER_CONTROL
switch (mod_sel)
{
case 2: /* usi bm01a */
mmc_pm_gpio_ctrl("usi_bm01a_wl_regon", 1);
mmc_pm_gpio_ctrl("usi_bm01a_wl_rst", 1);
break;
case 5: /* swb b23 */
mmc_pm_gpio_ctrl("swbb23_wl_shdn", 1);
break;
default:
printk("[bcm4329]: no wifi module matched !!\n");
}
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif /* CUSTOMER_HW */
/* Lets customer power to get stable */
OSL_DELAY(200);
#if defined CUSTOMER_ALLWINNER && defined CONFIG_SW_MMC_POWER_CONTROL
sw_mmc_rescan_card(3, 1);
#endif
break;
}
}
static int wl_cfgvendor_gscan_get_batch_results(struct wiphy *wiphy,
struct wireless_dev *wdev, const void *data, int len)
{
int err = 0;
struct wl_priv *cfg = wiphy_priv(wiphy);
gscan_results_cache_t *results, *iter;
uint32 reply_len, complete = 1;
int32 mem_needed, num_results_iter;
wifi_gscan_result_t *ptr;
uint16 num_scan_ids, num_results;
struct sk_buff *skb;
struct nlattr *scan_hdr, *complete_flag;
err = dhd_dev_wait_batch_results_complete(wl_to_prmry_ndev(cfg));
if (err != BCME_OK)
return -EBUSY;
err = dhd_dev_pno_lock_access_batch_results(wl_to_prmry_ndev(cfg));
if (err != BCME_OK) {
WL_ERR(("Can't obtain lock to access batch results %d\n", err));
return -EBUSY;
}
results = dhd_dev_pno_get_gscan(wl_to_prmry_ndev(cfg),
DHD_PNO_GET_BATCH_RESULTS, NULL, &reply_len);
if (!results) {
WL_ERR(("No results to send %d\n", err));
err = wl_cfgvendor_send_cmd_reply(wiphy, wl_to_prmry_ndev(cfg),
results, 0);
if (unlikely(err))
WL_ERR(("Vendor Command reply failed ret:%d \n", err));
dhd_dev_pno_unlock_access_batch_results(wl_to_prmry_ndev(cfg));
return err;
}
num_scan_ids = reply_len & 0xFFFF;
num_results = (reply_len & 0xFFFF0000) >> 16;
mem_needed = (num_results * sizeof(wifi_gscan_result_t)) +
(num_scan_ids * GSCAN_BATCH_RESULT_HDR_LEN) +
VENDOR_REPLY_OVERHEAD + SCAN_RESULTS_COMPLETE_FLAG_LEN;
if (mem_needed > (int32)NLMSG_DEFAULT_SIZE) {
mem_needed = (int32)NLMSG_DEFAULT_SIZE;
complete = 0;
}
WL_TRACE(("complete %d mem_needed %d max_mem %d\n", complete, mem_needed,
(int)NLMSG_DEFAULT_SIZE));
/* Alloc the SKB for vendor_event */
skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
if (unlikely(!skb)) {
WL_ERR(("skb alloc failed"));
dhd_dev_pno_unlock_access_batch_results(wl_to_prmry_ndev(cfg));
return -ENOMEM;
}
iter = results;
complete_flag = nla_reserve(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS_COMPLETE,
sizeof(complete));
mem_needed = mem_needed - (SCAN_RESULTS_COMPLETE_FLAG_LEN + VENDOR_REPLY_OVERHEAD);
while (iter) {
num_results_iter =
(mem_needed - GSCAN_BATCH_RESULT_HDR_LEN)/sizeof(wifi_gscan_result_t);
if (num_results_iter <= 0 ||
((iter->tot_count - iter->tot_consumed) > num_results_iter))
break;
scan_hdr = nla_nest_start(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS);
/* no more room? we are done then (for now) */
if (scan_hdr == NULL) {
complete = 0;
break;
}
nla_put_u32(skb, GSCAN_ATTRIBUTE_SCAN_ID, iter->scan_id);
nla_put_u8(skb, GSCAN_ATTRIBUTE_SCAN_FLAGS, iter->flag);
num_results_iter = iter->tot_count - iter->tot_consumed;
nla_put_u32(skb, GSCAN_ATTRIBUTE_NUM_OF_RESULTS, num_results_iter);
if (num_results_iter) {
ptr = &iter->results[iter->tot_consumed];
iter->tot_consumed += num_results_iter;
nla_put(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS,
num_results_iter * sizeof(wifi_gscan_result_t), ptr);
}
nla_nest_end(skb, scan_hdr);
mem_needed -= GSCAN_BATCH_RESULT_HDR_LEN +
(num_results_iter * sizeof(wifi_gscan_result_t));
iter = iter->next;
}
memcpy(nla_data(complete_flag), &complete, sizeof(complete));
dhd_dev_gscan_batch_cache_cleanup(wl_to_prmry_ndev(cfg));
dhd_dev_pno_unlock_access_batch_results(wl_to_prmry_ndev(cfg));
return cfg80211_vendor_cmd_reply(skb);
}
/* Enhanced BT COEX settings for eSCO compatibility during DHCP window */
static int set_btc_esco_params(struct net_device *dev, bool trump_sco)
{
static bool saved_status = FALSE;
char buf_reg50va_dhcp_on[8] =
{ 50, 00, 00, 00, 0x22, 0x80, 0x00, 0x00 };
char buf_reg51va_dhcp_on[8] =
{ 51, 00, 00, 00, 0x00, 0x00, 0x00, 0x00 };
char buf_reg64va_dhcp_on[8] =
{ 64, 00, 00, 00, 0x00, 0x00, 0x00, 0x00 };
char buf_reg65va_dhcp_on[8] =
{ 65, 00, 00, 00, 0x00, 0x00, 0x00, 0x00 };
char buf_reg71va_dhcp_on[8] =
{ 71, 00, 00, 00, 0x00, 0x00, 0x00, 0x00 };
uint32 regaddr;
static uint32 saved_reg50;
static uint32 saved_reg51;
static uint32 saved_reg64;
static uint32 saved_reg65;
static uint32 saved_reg71;
if (trump_sco) {
/* this should reduce eSCO agressive retransmit
* w/o breaking it
*/
/* 1st save current */
WL_TRACE(("Do new SCO/eSCO coex algo {save &"
"override}\n"));
if ((!dev_wlc_intvar_get_reg(dev, "btc_params", 50, &saved_reg50)) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 51, &saved_reg51)) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 64, &saved_reg64)) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 65, &saved_reg65)) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 71, &saved_reg71))) {
saved_status = TRUE;
WL_TRACE(("%s saved bt_params[50,51,64,65,71]:"
"0x%x 0x%x 0x%x 0x%x 0x%x\n",
__FUNCTION__, saved_reg50, saved_reg51,
saved_reg64, saved_reg65, saved_reg71));
} else {
WL_ERR((":%s: save btc_params failed\n",
__FUNCTION__));
saved_status = FALSE;
return -1;
}
WL_TRACE(("override with [50,51,64,65,71]:"
"0x%x 0x%x 0x%x 0x%x 0x%x\n",
*(u32 *)(buf_reg50va_dhcp_on+4),
*(u32 *)(buf_reg51va_dhcp_on+4),
*(u32 *)(buf_reg64va_dhcp_on+4),
*(u32 *)(buf_reg65va_dhcp_on+4),
*(u32 *)(buf_reg71va_dhcp_on+4)));
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg50va_dhcp_on[0], 8);
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg51va_dhcp_on[0], 8);
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg64va_dhcp_on[0], 8);
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg65va_dhcp_on[0], 8);
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg71va_dhcp_on[0], 8);
saved_status = TRUE;
} else if (saved_status) {
/* restore previously saved bt params */
WL_TRACE(("Do new SCO/eSCO coex algo {save &"
"override}\n"));
regaddr = 50;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg50);
regaddr = 51;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg51);
regaddr = 64;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg64);
regaddr = 65;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg65);
regaddr = 71;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg71);
WL_TRACE(("restore bt_params[50,51,64,65,71]:"
"0x%x 0x%x 0x%x 0x%x 0x%x\n",
saved_reg50, saved_reg51, saved_reg64,
saved_reg65, saved_reg71));
saved_status = FALSE;
} else {
WL_ERR((":%s att to restore not saved BTCOEX params\n",
__FUNCTION__));
return -1;
}
return 0;
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
static int first = 1;
static int sdc_id = 1;
script_item_value_type_e type;
script_item_u val;
if (first == 1) {
type = script_get_item("wifi_para", "wifi_sdc_id", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
WL_ERROR(("failed to fetch sdio card's sdcid\n"));
return -1;
}
sdc_id = val.val;
first = 0;
}
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
wifi_pm_power(0);
#endif /* CUSTOMER_HW */
#if defined(CUSTOMER_HW2)
wifi_set_power(0, 0);
#endif
mdelay(100);
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
wifi_pm_power(1);
#endif /* CUSTOMER_HW */
#if defined(CUSTOMER_HW2)
wifi_set_power(1, 0);
#endif
mdelay(100);
WL_ERROR(("=========== WLAN going back to live ========\n"));
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
wifi_pm_power(0);
sw_mci_rescan_card(sdc_id, 0);
#endif /* CUSTOMER_HW */
WL_ERROR(("=========== WLAN placed in POWER OFF ========\n"));
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
wifi_pm_power(1);
sw_mci_rescan_card(sdc_id, 1);
/* Lets customer power to get stable */
#endif /* CUSTOMER_HW */
mdelay(100);
WL_ERROR(("=========== WLAN placed in POWER ON ========\n"));
break;
}
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(0, 0);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
#if !defined(CONFIG_WIFI_CONTROL_FUNC)
gpio_tlmm_config(GPIO_CFG(CONFIG_BCMDHD_GPIO_WL_RESET, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
gpio_set_value(CONFIG_BCMDHD_GPIO_WL_RESET, 0);
mdelay(200);
disable_irq(gpio_to_irq(CONFIG_BCMDHD_GPIO_WL_RESET));
mdelay(200);
#endif
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(1, 0);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
#if !defined(CONFIG_WIFI_CONTROL_FUNC)
gpio_tlmm_config(GPIO_CFG(CONFIG_BCMDHD_GPIO_WL_RESET, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
gpio_set_value(CONFIG_BCMDHD_GPIO_WL_RESET, 1);
mdelay(200);
enable_irq(gpio_to_irq(CONFIG_BCMDHD_GPIO_WL_RESET));
mdelay(200);
#endif
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
/* Lets customer power to get stable */
OSL_DELAY(200);
#endif /* CUSTOMER_HW */
break;
}
}
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif
#if 1
#if defined(CONFIG_MACH_EVT0) || defined(CONFIG_MACH_EVT0_1) ||defined( CONFIG_MACH_EVB)
gpio_set_value(78,0);
#elif defined CONFIG_MACH_EVT1
gpio_set_value(76,0);
#else
gpio_set_value(76,0);
#endif
mdelay(100);
#if defined(CONFIG_MACH_EVT0) || defined(CONFIG_MACH_EVT0_1) ||defined( CONFIG_MACH_EVB)
gpio_set_value(78,1);
#elif defined CONFIG_MACH_EVT1
gpio_set_value(76,1);
#else
gpio_set_value(76,1);
#endif
mdelay(100);
#if defined(CONFIG_MACH_EVT0) || defined(CONFIG_MACH_EVT0_1) ||defined( CONFIG_MACH_EVB)
gpio_set_value(78,0);
#elif defined CONFIG_MACH_EVT1
gpio_set_value(76,0);
#else
gpio_set_value(76,0);
#endif
mdelay(100);
#if defined(CONFIG_MACH_EVT0) || defined(CONFIG_MACH_EVT0_1) || defined(CONFIG_MACH_EVT1)
gpio_set_value(147,0);
#elif defined CONFIG_MACH_EVB
gpio_set_value(142,0);
#else
gpio_set_value(147,0);
#endif
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif
#if 1
gpio_tlmm_config(GPIO_CFG(62,1,GPIO_OUTPUT,GPIO_NO_PULL,GPIO_8MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(63,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_8MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(64,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(65,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(66,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(67,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(94,0,GPIO_INPUT,GPIO_NO_PULL,GPIO_4MA),GPIO_ENABLE);
#if defined(CONFIG_MACH_EVT0) || defined(CONFIG_MACH_EVT0_1) || defined(CONFIG_MACH_EVT1)
gpio_tlmm_config(GPIO_CFG(147,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
#elif defined CONFIG_MACH_EVB
gpio_tlmm_config(GPIO_CFG(142,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
#else
gpio_tlmm_config(GPIO_CFG(147,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
#endif
#if defined(CONFIG_MACH_EVT0) || defined(CONFIG_MACH_EVT0_1) ||defined( CONFIG_MACH_EVB)
gpio_tlmm_config(GPIO_CFG(78,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
#elif defined CONFIG_MACH_EVT1
gpio_tlmm_config(GPIO_CFG(76,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
#else
gpio_tlmm_config(GPIO_CFG(76,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
#endif
#if !(defined(CONFIG_MACH_EVB))
gpio_tlmm_config(GPIO_CFG(30,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
#endif
#if defined(CONFIG_MACH_EVT0) || defined(CONFIG_MACH_EVT0_1) || defined(CONFIG_MACH_EVT1)
gpio_set_value(147,1);
#elif defined CONFIG_MACH_EVB
gpio_set_value(142,1);
#else
gpio_set_value(147,1);
#endif
mdelay(100);
#if defined(CONFIG_MACH_EVT0) || defined(CONFIG_MACH_EVT0_1) ||defined( CONFIG_MACH_EVB)
gpio_set_value(78,1);
#elif defined CONFIG_MACH_EVT1
gpio_set_value(76,1);
#else
gpio_set_value(76,1);
#endif
PM_LOG_EVENT(PM_LOG_ON,PM_LOG_WIFI);
#if !(defined(CONFIG_MACH_EVB))
if(gpio_get_value(29)==0) {
gpio_set_value(27,1);
printk("WLAN init: bt pulse start **************\n");
mdelay(100);
gpio_set_value(27,0);
printk("WLAN init: bt pulse done ***************\n");
}
#endif
#if !(defined(CONFIG_MACH_EVB))
gpio_set_value(30,1);
mdelay(100);
#endif
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif
OSL_DELAY(500);
break;
}
}
/**
* attach to the WL device.
*
* Attach to the WL device identified by vendor and device parameters.
* regs is a host accessible memory address pointing to WL device registers.
*
* wl_attach is not defined as static because in the case where no bus
* is defined, wl_attach will never be called, and thus, gcc will issue
* a warning that this function is defined but not used if we declare
* it as static.
*
*
* is called in wl_pci_probe() context, therefore no locking required.
*/
static struct wl_info *wl_attach(u16 vendor, u16 device, unsigned long regs,
uint bustype, void *btparam, uint irq)
{
struct wl_info *wl;
int unit, err;
unsigned long base_addr;
struct ieee80211_hw *hw;
u8 perm[ETH_ALEN];
unit = wl_found;
err = 0;
if (unit < 0) {
WL_ERROR("wl%d: unit number overflow, exiting\n", unit);
return NULL;
}
/* allocate private info */
hw = pci_get_drvdata(btparam); /* btparam == pdev */
wl = hw->priv;
ASSERT(wl);
atomic_set(&wl->callbacks, 0);
/* setup the bottom half handler */
tasklet_init(&wl->tasklet, wl_dpc, (unsigned long) wl);
base_addr = regs;
if (bustype == PCI_BUS) {
wl->piomode = false;
} else if (bustype == RPC_BUS) {
/* Do nothing */
} else {
bustype = PCI_BUS;
WL_TRACE("force to PCI\n");
}
wl->bcm_bustype = bustype;
wl->regsva = ioremap_nocache(base_addr, PCI_BAR0_WINSZ);
if (wl->regsva == NULL) {
WL_ERROR("wl%d: ioremap() failed\n", unit);
goto fail;
}
spin_lock_init(&wl->lock);
spin_lock_init(&wl->isr_lock);
/* prepare ucode */
if (wl_request_fw(wl, (struct pci_dev *)btparam) < 0) {
WL_ERROR("%s: Failed to find firmware usually in %s\n",
KBUILD_MODNAME, "/lib/firmware/brcm");
wl_release_fw(wl);
wl_remove((struct pci_dev *)btparam);
goto fail1;
}
/* common load-time initialization */
wl->wlc = wlc_attach((void *)wl, vendor, device, unit, wl->piomode,
wl->regsva, wl->bcm_bustype, btparam, &err);
wl_release_fw(wl);
if (!wl->wlc) {
WL_ERROR("%s: wlc_attach() failed with code %d\n",
KBUILD_MODNAME, err);
goto fail;
}
wl->pub = wlc_pub(wl->wlc);
wl->pub->ieee_hw = hw;
ASSERT(wl->pub->ieee_hw);
ASSERT(wl->pub->ieee_hw->priv == wl);
if (wlc_iovar_setint(wl->wlc, "mpc", 0)) {
WL_ERROR("wl%d: Error setting MPC variable to 0\n", unit);
}
/* register our interrupt handler */
if (request_irq(irq, wl_isr, IRQF_SHARED, KBUILD_MODNAME, wl)) {
WL_ERROR("wl%d: request_irq() failed\n", unit);
goto fail;
}
wl->irq = irq;
/* register module */
wlc_module_register(wl->pub, NULL, "linux", wl, NULL, wl_linux_watchdog,
NULL);
if (ieee_hw_init(hw)) {
WL_ERROR("wl%d: %s: ieee_hw_init failed!\n", unit, __func__);
goto fail;
}
memcpy(perm, &wl->pub->cur_etheraddr, ETH_ALEN);
ASSERT(is_valid_ether_addr(perm));
SET_IEEE80211_PERM_ADDR(hw, perm);
err = ieee80211_register_hw(hw);
if (err) {
WL_ERROR("%s: ieee80211_register_hw failed, status %d\n",
__func__, err);
}
if (wl->pub->srom_ccode[0])
err = wl_set_hint(wl, wl->pub->srom_ccode);
else
err = wl_set_hint(wl, "US");
if (err) {
WL_ERROR("%s: regulatory_hint failed, status %d\n",
__func__, err);
}
wl_found++;
return wl;
fail:
wl_free(wl);
fail1:
return NULL;
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
int ret;
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
//wifi_set_power(0, 0);
// wifi_set_reset(0, 0);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
ret = IW8101_wlan_power_off(RESET);
if(ret < 0){
printk("IW8101_wlan_power_off reset failed");
}
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
//wifi_set_power(1, 0);
//wifi_set_reset(1, 0);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
ret = IW8101_wlan_power_on(RESET);
if(ret < 0){
printk("IW8101_wlan_power_on reset failed");
}
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
ret = IW8101_wlan_power_off(NORMAL);
if(ret < 0){
printk("IW8101_wlan_power_off failed");
}
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
/* Lets customer power to get stable */
OSL_DELAY(200);
#endif /* CUSTOMER_HW */
ret = IW8101_wlan_power_on(NORMAL);
if(ret < 0){
printk("IW8101_wlan_power_on failed");
}
OSL_DELAY(300);
break;
}
}
/* 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)) */
}
//FIH-ADD+]
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
//FIH-ADD+[
if (getwlanmac != 0) {
bcopy(cached_mac, buf, ETHER_ADDR_LEN);
printk(KERN_INFO "%s:[WIFI] cached MAC address: '%02x:%02x:%02x:%02x:%02x:%02x'\n", __func__,
cached_mac[0], cached_mac[1], cached_mac[2], cached_mac[3], cached_mac[4], cached_mac[5]);
} else {
unsigned char cMacaddr[ETHER_ADDR_LEN];
memset(cMacaddr, 0, sizeof(cMacaddr));
ret = rpc_nv_read_wlan_mac_addr(cMacaddr);
if (ret == 0) {
fih_wifi_mac_swap(cMacaddr);
printk(KERN_INFO "%s:[WIFI] read MAC(nv 4678): '%02x:%02x:%02x:%02x:%02x:%02x\n'", __func__,
cMacaddr[0], cMacaddr[1], cMacaddr[2], cMacaddr[3], cMacaddr[4], cMacaddr[5]);
if (cMacaddr[0] == 0x0 && cMacaddr[1] == 0x0 && cMacaddr[2] == 0x0
&& cMacaddr[3] == 0x0 && cMacaddr[4] == 0x0 && cMacaddr[5] == 0x0) {
printk("%s: zero Mac is not acceptable, return error\n", __func__);
return -EINVAL;
}
else {
bcopy(cMacaddr, buf, ETHER_ADDR_LEN);
bcopy(cMacaddr, cached_mac, ETHER_ADDR_LEN);
}
#if 0 /* Do not check SoMC mac */
if ( fih_mac_is_se_mac(cMacaddr) ) {
bcopy(cMacaddr, buf, ETHER_ADDR_LEN);
bcopy(cMacaddr, cached_mac, ETHER_ADDR_LEN);
} else {
printk(KERN_INFO "%s:[WIFI]MAC from NV is not of SEMC\n", __func__);
fih_generate_mac(cMacaddr, buf);
}
#endif
} else {
printk("%s: failed to get MAC address from NV \n", __func__);
/* fih_generate_mac(cMacaddr, buf);
*
* MAC is empty in NV, break from Wi-Fi init function
*/
return -EINVAL;
}
getwlanmac = 1;
//Update the new mac address based on NV item 4678
printk("[Wlan] MAC address: '%02x:%02x:%02x:%02x:%02x:%02x'\n", cached_mac[0], cached_mac[1], cached_mac[2], cached_mac[3], cached_mac[4], cached_mac[5]);
}
//FIH-ADD+]
#ifdef EXAMPLE_GET_MAC
/* EXAMPLE code */
{
struct ether_addr ea_example = {{0x00, 0x11, 0x22, 0x33, 0x44, 0xFF}};
bcopy((char *)&ea_example, buf, sizeof(struct ether_addr));
}
#endif /* EXAMPLE_GET_MAC */
return ret;
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
{
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n", __FUNCTION__));
mmc_pm_gpio_ctrl("bcm40181_shdn", 0);
mmc_pm_gpio_ctrl("bcm40181_vcc_en", 0);
mmc_pm_gpio_ctrl("bcm40181_vdd_en", 0);
printk("[bcm40181]: bcm40181_shdn=>0 !!\n");
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CONFIG_MACH_MAHIMAHI
wifi_set_power(0, 0);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
}
break;
case WLAN_RESET_ON:
{
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n", __FUNCTION__));
mmc_pm_gpio_ctrl("bcm40181_vcc_en", 1);
udelay(100);
mmc_pm_gpio_ctrl("bcm40181_shdn", 1);
udelay(50);
mmc_pm_gpio_ctrl("bcm40181_vdd_en", 1);
printk("[bcm40181]: bcm40181_shdn=>1 !!\n");
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CONFIG_MACH_MAHIMAHI
wifi_set_power(1, 0);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
}
break;
case WLAN_POWER_OFF:
{
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n", __FUNCTION__));
mmc_pm_gpio_ctrl("bcm40181_shdn", 0);
mmc_pm_gpio_ctrl("bcm40181_vcc_en", 0);
mmc_pm_gpio_ctrl("bcm40181_vdd_en", 0);
sunximmc_rescan_card(3, 0);
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
}
break;
case WLAN_POWER_ON:
{
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n", __FUNCTION__));
mmc_pm_gpio_ctrl("bcm40181_vcc_en", 1);
udelay(100);
mmc_pm_gpio_ctrl("bcm40181_shdn", 1);
udelay(50);
mmc_pm_gpio_ctrl("bcm40181_vdd_en", 1);
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif /* CUSTOMER_HW */
/* Lets customer power to get stable */
OSL_DELAY(200);
sunximmc_rescan_card(3, 1);
}
break;
}
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
gpio_tlmm_config(GPIO_CFG(94,0,GPIO_INPUT,GPIO_NO_PULL,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(147,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
mdelay(100);
gpio_set_value(147,0);
mdelay(200);
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
WL_ERROR(("=========== WLAN going back to live ========\n"));
gpio_tlmm_config(GPIO_CFG(94,0,GPIO_INPUT,GPIO_NO_PULL,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(147,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
mdelay(100);
gpio_set_value(147,1);
mdelay(200);
PM_LOG_EVENT(PM_LOG_ON,PM_LOG_WIFI);
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
gpio_tlmm_config(GPIO_CFG(94,0,GPIO_INPUT,GPIO_NO_PULL,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(147,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
mdelay(100);
gpio_set_value(147,0);
mdelay(200);
PM_LOG_EVENT(PM_LOG_OFF,PM_LOG_WIFI);
mmc_detect_change(sdcc2_mmcptr, 0);
remove_proc_entry("q_wlan", NULL);
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
/* Lets customer power to get stable */
printk("HW rev:#%d\n",system_rev);
q_wlan_flag = 0;
entry = create_proc_read_entry("q_wlan", 0, NULL, q_proc_call, NULL);
if (!entry)
printk("cl:unable to create proc file\n");
gpio_tlmm_config(GPIO_CFG(62,1,GPIO_OUTPUT,GPIO_NO_PULL,GPIO_8MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(63,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_8MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(64,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(65,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(66,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(67,1,GPIO_OUTPUT,GPIO_PULL_UP,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(94,0,GPIO_INPUT,GPIO_NO_PULL,GPIO_4MA),GPIO_ENABLE);
gpio_tlmm_config(GPIO_CFG(147,0,GPIO_OUTPUT,GPIO_PULL_DOWN,GPIO_2MA),GPIO_ENABLE);
mdelay(100);
gpio_set_value(147,1);
mdelay(200);
PM_LOG_EVENT(PM_LOG_ON,PM_LOG_WIFI);
mmc_detect_change(sdcc2_mmcptr, 0);
OSL_DELAY(500);
break;
}
}
static void create_handler(bcm_p2p_discovery_t *discNull,
int reqLength, bcm_p2p_discovery_req_t *req, void *rspData)
{
bcm_p2p_discovery_t *disc;
create_rsp_t *rsp = (create_rsp_t *)rspData;
(void)discNull;
if (reqLength != sizeof(bcm_p2p_discovery_req_t) || req == 0 || rspData == 0) {
WL_ERROR(("invalid parameter\n"));
return;
}
WL_TRACE(("create_handler\n"));
#ifndef BCMDRIVER
/* seed the random generator */
srand((unsigned)time(NULL));
#endif /* BCMDRIVER */
rsp->disc = 0;
disc = &gDisc;
memset(disc, 0, sizeof(*disc));
disc->drv = req->create.drv;
disc->listenChannel = req->create.listenChannel;
/* initialize social channels */
disc->socialChannel[0] = 1;
disc->socialChannel[1] = 6;
disc->socialChannel[2] = 11;
#ifdef BCM_P2P_DISCOVERY_CREATE_DISCOVERY_BSSCFG
/* disable P2P discovery - to ensure bsscfg does not exist */
wl_p2p_disc(disc->drv, FALSE);
/* enable P2P discovery */
wl_p2p_disc(disc->drv, TRUE);
#endif /* BCM_P2P_DISCOVERY_CREATE_DISCOVERY_BSSCFG */
if (wl_p2p_dev(disc->drv, &disc->bsscfgIndex) < 0) {
WL_ERROR(("failed to get bsscfg index\n"));
}
WL_P2PO(("bsscfg index=%d\n", disc->bsscfgIndex));
#ifdef BCM_P2P_DISCOVERY_ADD_DELETE_IES
wl_cur_etheraddr(disc->drv, disc->bsscfgIndex, &disc->addr);
WL_PRMAC("discovery MAC address", &disc->addr);
#endif /* BCM_P2P_DISCOVERY_ADD_DELETE_IES */
#ifdef BCM_P2P_DISCOVERY_ADD_DELETE_IES
addIes(disc);
#endif /* BCM_P2P_DISCOVERY_ADD_DELETE_IES */
/* create timers */
disc->listenTimer = tmrCreate(
#ifndef BCMDRIVER
dsp(),
#else
disc->drv,
#endif /* BCMDRIVER */
listenTimeout, disc, "listenTimer");
if (disc->listenTimer == 0) {
WL_ERROR(("failed to create timer\n"));
goto fail;
}
/* reset state machine */
fsm(disc, EVENT_RESET);
/* return created instance */
rsp->disc = disc;
return;
fail:
memset(disc, 0, sizeof(*disc));
}
/* 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(CONFIG_MACH_MAHIMAHI) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
/* Lin - this will call wifi_control_data->get_mac_addr (dhd_linux.c) */
ret = wifi_get_mac_addr(buf);
#endif
#ifdef EXAMPLE_GET_MAC
/* EXAMPLE code */
{
struct ether_addr ea_example = {{0x00, 0x11, 0x22, 0x33, 0x44, 0xFF}};
bcopy((char *)&ea_example, buf, sizeof(struct ether_addr));
}
#endif /* EXAMPLE_GET_MAC */
#ifdef CUSTOMER_HW_PT
if (ret != 0) {
char panmac_path[] = "/dev/panmac";
static struct ether_addr mac;
static int custom_mac_applied = 0;
if ( custom_mac_applied )
{
memcpy(buf, &mac, sizeof(struct ether_addr));
return 0;
}
ret = dhd_read_mac_from_file(panmac_path, &mac);
if ( ret == 0 )
{
memcpy(buf, &mac, sizeof(struct ether_addr));
custom_mac_applied = 1;
}
else
{
int i;
char rand_panmac_path[] = "/data/misc/wifi/panmac";
ret = dhd_read_mac_from_file(rand_panmac_path, &mac);
if ( ret != 0 )
{
mac.octet[0] = 0x00;
mac.octet[1] = 0x0f;
mac.octet[2] = 0xe4;
for ( i = 3; i < ETHER_ADDR_LEN; i++ )
get_random_bytes(&mac.octet[i], 1);
dhd_write_mac_to_file(rand_panmac_path, &mac);
}
memcpy(buf, &mac, sizeof(struct ether_addr));
custom_mac_applied = 1;
ret = 0;
}
}
#endif
return ret;
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#if defined(CONFIG_LGE_BCM432X_PATCH)
if (get_hw_rev() <= REV_1_2)
{
disable_irq(gpio_to_irq(TEGRA_GPIO_PQ5)); //by sjpark 11-03-10
gpio_set_value(TEGRA_GPIO_PQ5, 0);
interrupt_en_flag = 1; //by sjpark 11-03-11
}
else
{
disable_irq(gpio_to_irq(TEGRA_GPIO_PU2)); //by sjpark 11-03-10
gpio_set_value(TEGRA_GPIO_PU2, 0);
interrupt_en_flag = 1; //by sjpark 11-03-11
}
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(0, 0);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#if defined(CONFIG_LGE_BCM432X_PATCH)
if (get_hw_rev() <= REV_1_2)
gpio_set_value(TEGRA_GPIO_PQ5, 1);
else
gpio_set_value(TEGRA_GPIO_PU2, 1);
mdelay(150);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(1, 0);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#if defined(CONFIG_LGE_BCM432X_PATCH)
if (get_hw_rev() <= REV_1_2)
{
gpio_set_value(TEGRA_GPIO_PQ5, 0);
if(interrupt_en_flag == 1){
printk("[sj-debug] POWER OFF : enable irq.\n");
enable_irq(gpio_to_irq(TEGRA_GPIO_PQ5)); //by sjpark 11-03-10
interrupt_en_flag = 0; //by sjpark 11-03-11
}
}
else
{
gpio_set_value(TEGRA_GPIO_PU2, 0);
if(interrupt_en_flag == 1){
printk("[sj-debug] POWER OFF : enable irq.\n");
enable_irq(gpio_to_irq(TEGRA_GPIO_PU2)); //by sjpark 11-03-10
interrupt_en_flag = 0; //by sjpark 11-03-11
}
}
mdelay(150);
/* always turn on 32k clock */
// clk_disable(wifi_32k_clk);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#if defined(CONFIG_LGE_BCM432X_PATCH)
/* Always turn on 32k clock
wifi_32k_clk = clk_get_sys(NULL, "blink");
if (IS_ERR(wifi_32k_clk)) {
pr_err("%s: unable to get blink clock\n", __func__);
//return PTR_ERR(wifi_32k_clk);
}
clk_enable(wifi_32k_clk);
printk("[Wi-Fi] wifi_32k_clk is enabled\n");
*/
if (get_hw_rev() <= REV_1_2) {
gpio_set_value(TEGRA_GPIO_PQ5, 1);
} else {
gpio_set_value(TEGRA_GPIO_PU2, 1);
}
mdelay(150);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif /* CUSTOMER_HW */
/* Lets customer power to get stable */
OSL_DELAY(200);
break;
}
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW_SAMSUNG
//bcm_wlan_power_off(2);
wlan_setup_power(0, 2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(0, 0);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW_SAMSUNG
//bcm_wlan_power_on(2);
wlan_setup_power(1, 2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(1, 0);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW_SAMSUNG
//bcm_wlan_power_off(1);
wlan_setup_power(0, 1);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW_SAMSUNG
//bcm_wlan_power_on(1);
wlan_setup_power(1, 1);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
/* Lets customer power to get stable */
OSL_DELAY(50);
#endif /* CUSTOMER_HW */
break;
}
}
static void wl_cfg80211_bt_handler(struct work_struct *work)
{
struct btcoex_info *btcx_inf;
btcx_inf = container_of(work, struct btcoex_info, work);
if (btcx_inf->timer_on) {
btcx_inf->timer_on = 0;
del_timer_sync(&btcx_inf->timer);
}
switch (btcx_inf->bt_state) {
case BT_DHCP_START:
WL_TRACE(("%s bt_dhcp stm: started \n",
__FUNCTION__));
bt_coex_retry_cnt = 0;
btcx_inf->bt_state = BT_DHCP_OPPR_WIN;
mod_timer(&btcx_inf->timer,
jiffies + msecs_to_jiffies(BT_DHCP_OPPR_WIN_TIME));
btcx_inf->timer_on = 1;
break;
case BT_DHCP_OPPR_WIN:
if ((btcx_inf->dhcp_done)||(bt_coex_retry_cnt > 7)) {
WL_TRACE(("%s DHCP Done before T1 expiration\n",
__FUNCTION__));
goto btc_coex_idle;
}
WL_TRACE(("%s DHCP T1:%d expired\n", __FUNCTION__,
BT_DHCP_OPPR_WIN_TIME));
if (btcx_inf->dev)
wl_cfg80211_bt_setflag(btcx_inf->dev, TRUE);
btcx_inf->bt_state = BT_DHCP_FLAG_FORCE_TIMEOUT;
mod_timer(&btcx_inf->timer,
jiffies + msecs_to_jiffies(BT_DHCP_FLAG_FORCE_TIME));
btcx_inf->timer_on = 1;
break;
case BT_DHCP_FLAG_FORCE_TIMEOUT:
if ((btcx_inf->dhcp_done)||(++bt_coex_retry_cnt > 7)) {
WL_TRACE(("%s DHCP Done before T2 expiration\n",
__FUNCTION__));
if (btcx_inf->dev)
wl_cfg80211_bt_setflag(btcx_inf->dev, FALSE);
goto btc_coex_idle;
} else {
WL_TRACE(("%s DHCP wait interval T2:%d"
"msec expired\n", __FUNCTION__,
BT_DHCP_FLAG_FORCE_TIME));
if (btcx_inf->dev)
wl_cfg80211_bt_setflag(btcx_inf->dev, FALSE);
btcx_inf->bt_state = BT_DHCP_OPPR_WIN;
mod_timer(&btcx_inf->timer,
jiffies + msecs_to_jiffies(BT_DHCP_OPPR_WIN_TIME));
btcx_inf->timer_on = 1;
}
if (!(btcx_inf->dhcp_done)) {
break;
}
btc_coex_idle:
btcx_inf->bt_state = BT_DHCP_IDLE;
btcx_inf->timer_on = 0;
bt_coex_retry_cnt = 0;
break;
default:
WL_ERR(("%s error g_status=%d !!!\n", __FUNCTION__,
btcx_inf->bt_state));
if (btcx_inf->dev)
wl_cfg80211_bt_setflag(btcx_inf->dev, FALSE);
btcx_inf->bt_state = BT_DHCP_IDLE;
btcx_inf->timer_on = 0;
break;
}
net_os_wake_unlock(btcx_inf->dev);
}
static int wl_cfgvendor_gscan_get_batch_results(struct wiphy *wiphy,
struct wireless_dev *wdev, const void *data, int len)
{
int err = 0;
struct bcm_cfg80211 *cfg = wiphy_priv(wiphy);
gscan_results_cache_t *results, *iter;
uint32 reply_len, complete = 0, num_results_iter;
int32 mem_needed;
wifi_gscan_result_t *ptr;
uint16 num_scan_ids, num_results;
struct sk_buff *skb;
struct nlattr *scan_hdr;
dhd_dev_wait_batch_results_complete(bcmcfg_to_prmry_ndev(cfg));
dhd_dev_pno_lock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
results = dhd_dev_pno_get_gscan(bcmcfg_to_prmry_ndev(cfg),
DHD_PNO_GET_BATCH_RESULTS, NULL, &reply_len);
if (!results) {
WL_ERR(("No results to send %d\n", err));
err = rtw_cfgvendor_send_cmd_reply(wiphy, bcmcfg_to_prmry_ndev(cfg),
results, 0);
if (unlikely(err))
WL_ERR(("Vendor Command reply failed ret:%d \n", err));
dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
return err;
}
num_scan_ids = reply_len & 0xFFFF;
num_results = (reply_len & 0xFFFF0000) >> 16;
mem_needed = (num_results * sizeof(wifi_gscan_result_t)) +
(num_scan_ids * GSCAN_BATCH_RESULT_HDR_LEN) +
VENDOR_REPLY_OVERHEAD + SCAN_RESULTS_COMPLETE_FLAG_LEN;
if (mem_needed > (int32)NLMSG_DEFAULT_SIZE) {
mem_needed = (int32)NLMSG_DEFAULT_SIZE;
complete = 0;
} else {
complete = 1;
}
WL_TRACE(("complete %d mem_needed %d max_mem %d\n", complete, mem_needed,
(int)NLMSG_DEFAULT_SIZE));
/* Alloc the SKB for vendor_event */
skb = rtw_cfg80211_vendor_cmd_alloc_reply_skb(wiphy, mem_needed);
if (unlikely(!skb)) {
WL_ERR(("skb alloc failed"));
dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
return -ENOMEM;
}
iter = results;
nla_put_u32(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS_COMPLETE, complete);
mem_needed = mem_needed - (SCAN_RESULTS_COMPLETE_FLAG_LEN + VENDOR_REPLY_OVERHEAD);
while (iter && ((mem_needed - GSCAN_BATCH_RESULT_HDR_LEN) > 0)) {
scan_hdr = nla_nest_start(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS);
nla_put_u32(skb, GSCAN_ATTRIBUTE_SCAN_ID, iter->scan_id);
nla_put_u8(skb, GSCAN_ATTRIBUTE_SCAN_FLAGS, iter->flag);
num_results_iter =
(mem_needed - GSCAN_BATCH_RESULT_HDR_LEN)/sizeof(wifi_gscan_result_t);
if ((iter->tot_count - iter->tot_consumed) < num_results_iter)
num_results_iter = iter->tot_count - iter->tot_consumed;
nla_put_u32(skb, GSCAN_ATTRIBUTE_NUM_OF_RESULTS, num_results_iter);
if (num_results_iter) {
ptr = &iter->results[iter->tot_consumed];
iter->tot_consumed += num_results_iter;
nla_put(skb, GSCAN_ATTRIBUTE_SCAN_RESULTS,
num_results_iter * sizeof(wifi_gscan_result_t), ptr);
}
nla_nest_end(skb, scan_hdr);
mem_needed -= GSCAN_BATCH_RESULT_HDR_LEN +
(num_results_iter * sizeof(wifi_gscan_result_t));
iter = iter->next;
}
dhd_dev_gscan_batch_cache_cleanup(bcmcfg_to_prmry_ndev(cfg));
dhd_dev_pno_unlock_access_batch_results(bcmcfg_to_prmry_ndev(cfg));
return rtw_cfg80211_vendor_cmd_reply(skb);
}
int wl_cfg80211_set_btcoex_dhcp(struct net_device *dev, char *command)
{
struct wl_priv *wl = wlcfg_drv_priv;
char powermode_val = 0;
char buf_reg66va_dhcp_on[8] = { 66, 00, 00, 00, 0x10, 0x27, 0x00, 0x00 };
char buf_reg41va_dhcp_on[8] = { 41, 00, 00, 00, 0x33, 0x00, 0x00, 0x00 };
char buf_reg68va_dhcp_on[8] = { 68, 00, 00, 00, 0x90, 0x01, 0x00, 0x00 };
uint32 regaddr;
static uint32 saved_reg66;
static uint32 saved_reg41;
static uint32 saved_reg68;
static bool saved_status = FALSE;
#ifdef COEX_DHCP
char buf_flag7_default[8] = { 7, 00, 00, 00, 0x0, 0x00, 0x00, 0x00};
struct btcoex_info *btco_inf = wl->btcoex_info;
#endif
#ifdef PKT_FILTER_SUPPORT
dhd_pub_t *dhd = (dhd_pub_t *)(wl->pub);
#endif
strncpy((char *)&powermode_val, command + strlen("BTCOEXMODE") +1, 1);
if (strnicmp((char *)&powermode_val, "1", strlen("1")) == 0) {
WL_TRACE_HW4(("%s: DHCP session starts\n", __FUNCTION__));
#ifdef PKT_FILTER_SUPPORT
dhd->dhcp_in_progress = 1;
if (dhd->early_suspended) {
WL_TRACE_HW4(("DHCP in progressing , disable packet filter!!!\n"));
dhd_enable_packet_filter(0, dhd);
}
#endif
if ((saved_status == FALSE) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 66, &saved_reg66)) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 41, &saved_reg41)) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 68, &saved_reg68))) {
saved_status = TRUE;
WL_TRACE(("Saved 0x%x 0x%x 0x%x\n",
saved_reg66, saved_reg41, saved_reg68));
#ifdef COEX_DHCP
if (btcoex_is_sco_active(dev)) {
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg66va_dhcp_on[0],
sizeof(buf_reg66va_dhcp_on));
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg41va_dhcp_on[0],
sizeof(buf_reg41va_dhcp_on));
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg68va_dhcp_on[0],
sizeof(buf_reg68va_dhcp_on));
saved_status = TRUE;
btco_inf->bt_state = BT_DHCP_START;
btco_inf->timer_on = 1;
btco_inf->dhcp_done = 0;
mod_timer(&btco_inf->timer, jiffies + msecs_to_jiffies(BT_DHCP_OPPR_WIN_TIME));
WL_TRACE(("%s enable BT DHCP Timer\n",
__FUNCTION__));
}
#endif
}
else if (saved_status == TRUE) {
WL_ERR(("%s was called w/o DHCP OFF. Continue\n", __FUNCTION__));
}
}
else if (strnicmp((char *)&powermode_val, "2", strlen("2")) == 0) {
#ifdef PKT_FILTER_SUPPORT
dhd->dhcp_in_progress = 0;
WL_TRACE_HW4(("%s: DHCP is complete \n", __FUNCTION__));
if (dhd->early_suspended) {
WL_TRACE_HW4(("DHCP is complete , enable packet filter!!!\n"));
dhd_enable_packet_filter(1, dhd);
}
#endif
#ifdef COEX_DHCP
WL_TRACE(("%s disable BT DHCP Timer\n", __FUNCTION__));
if (btco_inf->timer_on) {
btco_inf->timer_on = 0;
btco_inf->dhcp_done = 1;
del_timer_sync(&btco_inf->timer);
if (btco_inf->bt_state != BT_DHCP_IDLE) {
WL_TRACE(("%s bt->bt_state:%d\n",
__FUNCTION__, btco_inf->bt_state));
schedule_work(&btco_inf->work);
}
}
if (saved_status == TRUE)
dev_wlc_bufvar_set(dev, "btc_flags",
(char *)&buf_flag7_default[0], sizeof(buf_flag7_default));
#endif
if (saved_status == TRUE) {
regaddr = 66;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg66);
regaddr = 41;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg41);
regaddr = 68;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg68);
WL_TRACE(("restore regs {66,41,68} <- 0x%x 0x%x 0x%x\n",
saved_reg66, saved_reg41, saved_reg68));
}
saved_status = FALSE;
}
else {
WL_ERR(("%s Unkwown yet power setting, ignored\n",
__FUNCTION__));
}
snprintf(command, 3, "OK");
return (strlen("OK"));
}
static int dhd_cfgvendor_priv_string_handler(struct wiphy *wiphy,
struct wireless_dev *wdev, const void *data, int len)
{
const struct bcm_nlmsg_hdr *nlioc = data;
struct net_device *ndev = NULL;
struct bcm_cfg80211 *cfg;
struct sk_buff *reply;
void *buf = NULL, *cur;
dhd_pub_t *dhd;
dhd_ioctl_t ioc = { 0 };
int ret = 0, ret_len, payload, msglen;
int maxmsglen = PAGE_SIZE - 0x100;
int8 index;
WL_TRACE(("entry: cmd = %d\n", nlioc->cmd));
DHD_ERROR(("entry: cmd = %d\n", nlioc->cmd));
cfg = wiphy_priv(wiphy);
dhd = cfg->pub;
DHD_OS_WAKE_LOCK(dhd);
if (dhd->hang_was_sent) {
WL_ERR(("HANG was sent up earlier\n"));
DHD_OS_WAKE_LOCK_CTRL_TIMEOUT_ENABLE(dhd, DHD_EVENT_TIMEOUT_MS);
DHD_OS_WAKE_UNLOCK(dhd);
return OSL_ERROR(BCME_DONGLE_DOWN);
}
len -= sizeof(struct bcm_nlmsg_hdr);
ret_len = nlioc->len;
if (ret_len > 0 || len > 0) {
if (len > DHD_IOCTL_MAXLEN) {
WL_ERR(("oversize input buffer %d\n", len));
len = DHD_IOCTL_MAXLEN;
}
if (ret_len > DHD_IOCTL_MAXLEN) {
WL_ERR(("oversize return buffer %d\n", ret_len));
ret_len = DHD_IOCTL_MAXLEN;
}
payload = max(ret_len, len) + 1;
buf = vzalloc(payload);
if (!buf) {
DHD_OS_WAKE_UNLOCK(dhd);
return -ENOMEM;
}
memcpy(buf, (void *)nlioc + nlioc->offset, len);
*(char *)(buf + len) = '\0';
}
ndev = wdev_to_wlc_ndev(wdev, cfg);
index = dhd_net2idx(dhd->info, ndev);
if (index == DHD_BAD_IF) {
WL_ERR(("Bad ifidx from wdev:%p\n", wdev));
ret = BCME_ERROR;
goto done;
}
ioc.cmd = nlioc->cmd;
ioc.len = nlioc->len;
ioc.set = nlioc->set;
ioc.driver = nlioc->magic;
ret = dhd_ioctl_process(dhd, index, &ioc, buf);
if (ret) {
WL_TRACE(("dhd_ioctl_process return err %d\n", ret));
ret = OSL_ERROR(ret);
goto done;
}
cur = buf;
while (ret_len > 0) {
msglen = nlioc->len > maxmsglen ? maxmsglen : ret_len;
ret_len -= msglen;
payload = msglen + sizeof(msglen);
reply = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, payload);
if (!reply) {
WL_ERR(("Failed to allocate reply msg\n"));
ret = -ENOMEM;
break;
}
if (nla_put(reply, BCM_NLATTR_DATA, msglen, cur) ||
nla_put_u16(reply, BCM_NLATTR_LEN, msglen)) {
kfree_skb(reply);
ret = -ENOBUFS;
break;
}
ret = cfg80211_vendor_cmd_reply(reply);
if (ret) {
WL_ERR(("testmode reply failed:%d\n", ret));
break;
}
cur += msglen;
}
done:
vfree(buf);
DHD_OS_WAKE_UNLOCK(dhd);
return ret;
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CONFIG_MACH_MAHIMAHI
wifi_set_power(0, 0);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
/* LGE_CHANGE_S [[email protected]] 2009-05-14, support start/stop */
#if defined(CONFIG_LGE_BCM432X_PATCH) && defined(CONFIG_ARCH_MSM)
if (gpio_get_value(CONFIG_BCM4330_GPIO_WL_RESET)) {
disable_irq(gpio_to_irq(CONFIG_BCM4330_GPIO_WL_RESET));
gpio_set_value(CONFIG_BCM4330_GPIO_WL_RESET, 0);
}
#endif /* defined(CONFIG_LGE_BCM432X_PATCH) && defined(CONFIG_ARCH_MSM) */
/* LGE_CHANGE_E [[email protected]] 2009-05-14, support start/stop */
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CONFIG_MACH_MAHIMAHI
wifi_set_power(1, 0);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
/* LGE_CHANGE_S [[email protected]] 2009-05-14, support start/stop */
#if defined(CONFIG_LGE_BCM432X_PATCH) && defined(CONFIG_ARCH_MSM)
if (!gpio_get_value(CONFIG_BCM4330_GPIO_WL_RESET)) {
gpio_set_value(CONFIG_BCM4330_GPIO_WL_RESET, 1);
mdelay(150);
enable_irq(gpio_to_irq(CONFIG_BCM4330_GPIO_WL_RESET));
}
#endif /* defined(CONFIG_LGE_BCM432X_PATCH) && defined(CONFIG_ARCH_MSM) */
/* LGE_CHANGE_E [[email protected]] 2009-05-14, support start/stop */
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
/* LGE_CHANGE_S [[email protected]] 2009-03-05, for gpio set in dhd_linux */
#if defined(CONFIG_LGE_BCM432X_PATCH) && defined(CONFIG_ARCH_MSM)
//gpio_tlmm_config(GPIO_CFG(CONFIG_BCM4330_GPIO_WL_RESET, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA), GPIO_ENABLE);
if (!gpio_get_value(CONFIG_BCM4330_GPIO_WL_RESET)) {
gpio_set_value(CONFIG_BCM4330_GPIO_WL_RESET, 1);
enable_irq(gpio_to_irq(CONFIG_BCM4330_GPIO_WL_RESET));
}
gpio_set_value(CONFIG_BCM4330_GPIO_WL_RESET, 0);
//gpio_tlmm_config(GPIO_CFG(CONFIG_BCM4330_GPIO_WL_RESET, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA), GPIO_ENABLE);
#endif /* defined(CONFIG_LGE_BCM432X_PATCH) && defined(CONFIG_ARCH_MSM) */
/* LGE_CHANGE_E [[email protected]] 2009-03-05, for gpio set in dhd_linux */
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif /* CUSTOMER_HW */
/* LGE_CHANGE_S [[email protected]] 2009-03-05, for gpio set in dhd_linux */
#if defined(CONFIG_LGE_BCM432X_PATCH) && defined(CONFIG_ARCH_MSM)
gpio_set_value(CONFIG_BCM4330_GPIO_WL_RESET, 1);
#endif /* defined(CONFIG_LGE_BCM432X_PATCH) && defined(CONFIG_ARCH_MSM) */
/* LGE_CHANGE_E [[email protected]] 2009-03-05, for gpio set in dhd_linux */
/* Lets customer power to get stable */
OSL_DELAY(200);
break;
}
}
static void wl_cfg80211_bt_handler(struct work_struct *work)
{
struct btcoex_info *btcx_inf;
btcx_inf = container_of(work, struct btcoex_info, work);
if (btcx_inf->timer_on) {
btcx_inf->timer_on = 0;
del_timer_sync(&btcx_inf->timer);
}
switch (btcx_inf->bt_state) {
case BT_DHCP_START:
/* DHCP started
* provide OPPORTUNITY window to get DHCP address
*/
WL_TRACE(("%s bt_dhcp stm: started \n",
__FUNCTION__));
btcx_inf->bt_state = BT_DHCP_OPPR_WIN;
mod_timer(&btcx_inf->timer,
jiffies + BT_DHCP_OPPR_WIN_TIME*HZ/1000);
btcx_inf->timer_on = 1;
break;
case BT_DHCP_OPPR_WIN:
if (btcx_inf->dhcp_done) {
WL_TRACE(("%s DHCP Done before T1 expiration\n",
__FUNCTION__));
goto btc_coex_idle;
}
/* DHCP is not over yet, start lowering BT priority
* enforce btc_params + flags if necessary
*/
WL_TRACE(("%s DHCP T1:%d expired\n", __FUNCTION__,
BT_DHCP_OPPR_WIN_TIME));
if (btcx_inf->dev)
wl_cfg80211_bt_setflag(btcx_inf->dev, TRUE);
btcx_inf->bt_state = BT_DHCP_FLAG_FORCE_TIMEOUT;
mod_timer(&btcx_inf->timer,
jiffies + BT_DHCP_FLAG_FORCE_TIME*HZ/1000);
btcx_inf->timer_on = 1;
break;
case BT_DHCP_FLAG_FORCE_TIMEOUT:
if (btcx_inf->dhcp_done) {
WL_TRACE(("%s DHCP Done before T2 expiration\n",
__FUNCTION__));
} else {
/* Noo dhcp during T1+T2, restore BT priority */
WL_TRACE(("%s DHCP wait interval T2:%d"
"msec expired\n", __FUNCTION__,
BT_DHCP_FLAG_FORCE_TIME));
}
/* Restoring default bt priority */
if (btcx_inf->dev)
wl_cfg80211_bt_setflag(btcx_inf->dev, FALSE);
btc_coex_idle:
btcx_inf->bt_state = BT_DHCP_IDLE;
btcx_inf->timer_on = 0;
break;
default:
WL_ERR(("%s error g_status=%d !!!\n", __FUNCTION__,
btcx_inf->bt_state));
if (btcx_inf->dev)
wl_cfg80211_bt_setflag(btcx_inf->dev, FALSE);
btcx_inf->bt_state = BT_DHCP_IDLE;
btcx_inf->timer_on = 0;
break;
}
net_os_wake_unlock(btcx_inf->dev);
}
int dhd_cfg80211_testmode_cmd(struct wiphy *wiphy, void *data, int len)
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0) */
{
struct sk_buff *reply;
struct bcm_cfg80211 *cfg;
dhd_pub_t *dhd;
struct bcm_nlmsg_hdr *nlioc = data;
dhd_ioctl_t ioc = { 0 };
int err = 0;
void *buf = NULL, *cur;
u16 buflen;
u16 maxmsglen = PAGE_SIZE - 0x100;
bool newbuf = false;
int8 index = 0;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0))
struct net_device *ndev = NULL;
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0) */
WL_TRACE(("entry: cmd = %d\n", nlioc->cmd));
cfg = wiphy_priv(wiphy);
dhd = cfg->pub;
DHD_OS_WAKE_LOCK(dhd);
/* send to dongle only if we are not waiting for reload already */
if (dhd->hang_was_sent) {
WL_ERR(("HANG was sent up earlier\n"));
DHD_OS_WAKE_LOCK_CTRL_TIMEOUT_ENABLE(dhd, DHD_EVENT_TIMEOUT_MS);
DHD_OS_WAKE_UNLOCK(dhd);
return OSL_ERROR(BCME_DONGLE_DOWN);
}
len -= sizeof(struct bcm_nlmsg_hdr);
if (nlioc->len > 0) {
if (nlioc->len <= len) {
buf = (void *)nlioc + nlioc->offset;
*(char *)(buf + nlioc->len) = '\0';
} else {
if (nlioc->len > DHD_IOCTL_MAXLEN)
nlioc->len = DHD_IOCTL_MAXLEN;
buf = vzalloc(nlioc->len);
if (!buf)
return -ENOMEM;
newbuf = true;
memcpy(buf, (void *)nlioc + nlioc->offset, len);
*(char *)(buf + len) = '\0';
}
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0))
ndev = wdev_to_wlc_ndev(wdev, cfg);
index = dhd_net2idx(dhd->info, ndev);
if (index == DHD_BAD_IF) {
WL_ERR(("Bad ifidx from wdev:%p\n", wdev));
return BCME_ERROR;
}
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0) */
ioc.cmd = nlioc->cmd;
ioc.len = nlioc->len;
ioc.set = nlioc->set;
ioc.driver = nlioc->magic;
err = dhd_ioctl_process(dhd, index, &ioc, buf);
if (err) {
WL_TRACE(("dhd_ioctl_process return err %d\n", err));
err = OSL_ERROR(err);
goto done;
}
cur = buf;
while (nlioc->len > 0) {
buflen = nlioc->len > maxmsglen ? maxmsglen : nlioc->len;
nlioc->len -= buflen;
reply = cfg80211_testmode_alloc_reply_skb(wiphy, buflen+4);
if (!reply) {
WL_ERR(("Failed to allocate reply msg\n"));
err = -ENOMEM;
break;
}
if (nla_put(reply, BCM_NLATTR_DATA, buflen, cur) ||
nla_put_u16(reply, BCM_NLATTR_LEN, buflen)) {
kfree_skb(reply);
err = -ENOBUFS;
break;
}
do {
err = cfg80211_testmode_reply(reply);
} while (err == -EAGAIN);
if (err) {
WL_ERR(("testmode reply failed:%d\n", err));
break;
}
cur += buflen;
}
done:
if (newbuf)
vfree(buf);
DHD_OS_WAKE_UNLOCK(dhd);
return err;
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#if defined(CONFIG_LGE_BCM432X_PATCH)
//star_wifi_power(0);
gpio_set_value(177, 0);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(0, 0);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#if defined(CONFIG_LGE_BCM432X_PATCH)
//star_wifi_power(1);
gpio_set_value(177, 1);
mdelay(200);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(1, 0);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#if defined(CONFIG_LGE_BCM432X_PATCH)
//star_wifi_power(0);
gpio_set_value(177, 0);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#if defined(CONFIG_LGE_BCM432X_PATCH)
printk("[Wi-Fi] WLAN_RESET : %d\n", gpio_get_value(177));
//star_wifi_power(1);
gpio_set_value(177, 1);
mdelay(200);
printk("[Wi-Fi] WLAN_RESET : %d\n", gpio_get_value(177));
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif /* CUSTOMER_HW */
/* Lets customer power to get stable */
OSL_DELAY(500);
break;
}
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(0, 0);
#endif
#ifdef CONFIG_LCT_AE770
gpio_set_value(116, 0); //116 wifi pwd for ae770 //21 //123 is for aw70 project
#else
gpio_set_value(21, 0); //123 is for aw70 project
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(1, 0);
#endif
#ifdef CONFIG_LCT_AE770
gpio_set_value(116, 1); //116 wifi pwd for ae770 //21 //123 is for aw70 project
#else
gpio_set_value(21, 1); //123 is for aw70 project
#endif
OSL_DELAY(200);
WL_ERROR(("=========== WLAN going back to live ========\n"));
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
#ifdef CONFIG_LCT_AE770
gpio_set_value(116, 0); //116 wifi pwd for ae770 //21 //123 is for aw70 project
//wifi_detect_change(1);
#else
gpio_set_value(21, 0); //123 is for aw70 project
wifi_detect_change(1);
#endif
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif /* CUSTOMER_HW */
#ifdef CONFIG_LCT_AE770
gpio_set_value(116, 1); //116 wifi pwd for ae770 //21 //123 is for aw70 project
#else
gpio_set_value(21, 1); //123 is for aw70 project
#endif
/* Lets customer power to get stable */
OSL_DELAY(200);
wifi_detect_change(1);
break;
}
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
#if defined CONFIG_MMC_SUNXI_POWER_CONTROL
unsigned int mod_sel = mmc_pm_get_mod_type();
if (mod_sel != 6) {
printk("Config Error: not for huawei mw269x sdio wifi module\n");
}
#endif
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#if defined CONFIG_MMC_SUNXI_POWER_CONTROL
mmc_pm_gpio_ctrl("hw_mw269x_wl_enb", 0);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(0, 0);
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#if defined CONFIG_MMC_SUNXI_POWER_CONTROL
mmc_pm_gpio_ctrl("hw_mw269x_wl_enb", 1);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(1, 0);
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
OSL_DELAY(10000);
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#if defined CONFIG_MMC_SUNXI_POWER_CONTROL
mmc_pm_gpio_ctrl("hw_mw269x_wl_enb", 0);
sunximmc_rescan_card(SDIOID, 0);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#if defined CONFIG_MMC_SUNXI_POWER_CONTROL
mmc_pm_gpio_ctrl("hw_mw269x_wl_enb", 1);
#endif
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif /* CUSTOMER_HW */
/* Lets customer power to get stable */
OSL_DELAY(200);
#if defined CONFIG_MMC_SUNXI_POWER_CONTROL
sunximmc_rescan_card(SDIOID, 1);
#endif /* CUSTOMER_HW */
break;
}
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CONFIG_MACH_MAHIMAHI
wifi_set_power(0, 0);
#elif defined(CUSTOMER_HW_PT)
gpio_set_value(dhd_wl_reset_gpio, 0);
printk("WLAN_RESET_OFF[%d]\n",
gpio_get_value(dhd_wl_reset_gpio));
#endif
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CONFIG_MACH_MAHIMAHI
wifi_set_power(1, 0);
#elif defined(CUSTOMER_HW_PT)
gpio_set_value(dhd_wl_reset_gpio, 1);
printk("WLAN_RESET_ON[%d]\n",
gpio_get_value(dhd_wl_reset_gpio));
#endif
WL_ERROR(("=========== WLAN going back to live ========\n"));
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
#if defined(CUSTOMER_HW_PT) && !defined(CONFIG_MACH_MAHIMAHI)
gpio_set_value(dhd_wl_reset_gpio, 0);
printk("WLAN_POWER_OFF[%d]\n",
gpio_get_value(dhd_wl_reset_gpio));
#endif
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
#endif /* CUSTOMER_HW */
#if defined(CUSTOMER_HW_PT) && !defined(CONFIG_MACH_MAHIMAHI)
gpio_set_value(dhd_wl_reset_gpio, 1);
printk("WLAN_POWER_ON[%d]\n",
gpio_get_value(dhd_wl_reset_gpio));
#endif
/* Lets customer power to get stable */
OSL_DELAY(200);
break;
}
}
int wl_cfg80211_set_btcoex_dhcp(struct net_device *dev, char *command)
{
struct wl_priv *wl = wlcfg_drv_priv;
char powermode_val = 0;
char buf_reg66va_dhcp_on[8] = { 66, 00, 00, 00, 0x10, 0x27, 0x00, 0x00 };
char buf_reg41va_dhcp_on[8] = { 41, 00, 00, 00, 0x33, 0x00, 0x00, 0x00 };
char buf_reg68va_dhcp_on[8] = { 68, 00, 00, 00, 0x90, 0x01, 0x00, 0x00 };
uint32 regaddr;
static uint32 saved_reg66;
static uint32 saved_reg41;
static uint32 saved_reg68;
static bool saved_status = FALSE;
#ifdef COEX_DHCP
char buf_flag7_default[8] = { 7, 00, 00, 00, 0x0, 0x00, 0x00, 0x00};
struct btcoex_info *btco_inf = wl->btcoex_info;
#endif /* COEX_DHCP */
#ifdef PKT_FILTER_SUPPORT
dhd_pub_t *dhd = (dhd_pub_t *)(wl->pub);
#endif
WL_ERR(("%s enter\n", __FUNCTION__));
/* Figure out powermode 1 or o command */
strncpy((char *)&powermode_val, command + strlen("BTCOEXMODE") +1, 1);
if (strnicmp((char *)&powermode_val, "1", strlen("1")) == 0) {
WL_TRACE_HW4(("%s: DHCP session starts\n", __FUNCTION__));
#ifdef PKT_FILTER_SUPPORT
dhd->dhcp_in_progress = 1;
if (dhd->early_suspended) {
WL_TRACE_HW4(("DHCP in progressing , disable packet filter!!!\n"));
dhd_enable_packet_filter(0, dhd);
}
#endif
/* Retrieve and saved orig regs value */
if ((saved_status == FALSE) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 66, &saved_reg66)) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 41, &saved_reg41)) &&
(!dev_wlc_intvar_get_reg(dev, "btc_params", 68, &saved_reg68))) {
saved_status = TRUE;
WL_TRACE(("Saved 0x%x 0x%x 0x%x\n",
saved_reg66, saved_reg41, saved_reg68));
/* Disable PM mode during dhpc session */
/* Disable PM mode during dhpc session */
#ifdef COEX_DHCP
/* Start BT timer only for SCO connection */
if (btcoex_is_sco_active(dev)) {
/* btc_params 66 */
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg66va_dhcp_on[0],
sizeof(buf_reg66va_dhcp_on));
/* btc_params 41 0x33 */
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg41va_dhcp_on[0],
sizeof(buf_reg41va_dhcp_on));
/* btc_params 68 0x190 */
dev_wlc_bufvar_set(dev, "btc_params",
(char *)&buf_reg68va_dhcp_on[0],
sizeof(buf_reg68va_dhcp_on));
saved_status = TRUE;
btco_inf->bt_state = BT_DHCP_START;
btco_inf->timer_on = 1;
mod_timer(&btco_inf->timer, btco_inf->timer.expires);
WL_TRACE(("%s enable BT DHCP Timer\n",
__FUNCTION__));
}
#endif /* COEX_DHCP */
}
else if (saved_status == TRUE) {
WL_ERR(("%s was called w/o DHCP OFF. Continue\n", __FUNCTION__));
}
}
else if (strnicmp((char *)&powermode_val, "2", strlen("2")) == 0) {
#ifdef PKT_FILTER_SUPPORT
dhd->dhcp_in_progress = 0;
WL_TRACE_HW4(("%s: DHCP is complete \n", __FUNCTION__));
/* Enable packet filtering */
if (dhd->early_suspended) {
WL_TRACE_HW4(("DHCP is complete , enable packet filter!!!\n"));
dhd_enable_packet_filter(1, dhd);
}
#endif
/* Restoring PM mode */
#ifdef COEX_DHCP
/* Stop any bt timer because DHCP session is done */
WL_TRACE(("%s disable BT DHCP Timer\n", __FUNCTION__));
if (btcoex_is_sco_active(dev)) { // wliu ADDED!
if (btco_inf->timer_on) {
btco_inf->timer_on = 0;
del_timer_sync(&btco_inf->timer);
if (btco_inf->bt_state != BT_DHCP_IDLE) {
/* need to restore original btc flags & extra btc params */
WL_TRACE(("%s bt->bt_state:%d\n",
__FUNCTION__, btco_inf->bt_state));
/* wake up btcoex thread to restore btlags+params */
schedule_work(&btco_inf->work);
}
}
}
/* Restoring btc_flag paramter anyway */
if (saved_status == TRUE) {
dev_wlc_bufvar_set(dev, "btc_flags",
(char *)&buf_flag7_default[0], sizeof(buf_flag7_default));
}
#endif /* COEX_DHCP */
/* Restore original values */
if (saved_status == TRUE) {
regaddr = 66;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg66);
regaddr = 41;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg41);
regaddr = 68;
dev_wlc_intvar_set_reg(dev, "btc_params",
(char *)®addr, (char *)&saved_reg68);
WL_TRACE(("restore regs {66,41,68} <- 0x%x 0x%x 0x%x\n",
saved_reg66, saved_reg41, saved_reg68));
}
saved_status = FALSE;
}
else {
WL_ERR(("%s Unkwown yet power setting, ignored\n",
__FUNCTION__));
}
snprintf(command, 3, "OK");
return (strlen("OK"));
}
/* Customer function to control hw specific wlan gpios */
void
dhd_customer_gpio_wlan_ctrl(int onoff)
{
switch (onoff) {
case WLAN_RESET_OFF:
WL_TRACE(("%s: call customer specific GPIO to insert WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(0, 0);
#endif
#ifdef CUSTOMER_HW_AMLOGIC
//extern_wifi_enable(0);
#endif /* CUSTOMER_HW_AMLOGIC */
WL_ERROR(("=========== WLAN placed in RESET ========\n"));
break;
case WLAN_RESET_ON:
WL_TRACE(("%s: callc customer specific GPIO to remove WLAN RESET\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(2);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW2
wifi_set_power(1, 0);
#endif
#ifdef CUSTOMER_HW_AMLOGIC
extern_wifi_set_enable(0);
mdelay(200);
extern_wifi_set_enable(1);
mdelay(200);
sdio_reinit();
#endif /* CUSTOMER_HW_AMLOGIC */
WL_ERROR(("=========== WLAN going back to live ========\n"));
break;
case WLAN_POWER_OFF:
WL_TRACE(("%s: call customer specific GPIO to turn off WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_off(1);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW_AMLOGIC
extern_wifi_set_enable(0);
//extern_wifi_power(0);
#endif /* CUSTOMER_HW_AMLOGIC */
break;
case WLAN_POWER_ON:
WL_TRACE(("%s: call customer specific GPIO to turn on WL_REG_ON\n",
__FUNCTION__));
#ifdef CUSTOMER_HW
bcm_wlan_power_on(1);
/* Lets customer power to get stable */
OSL_DELAY(200);
#endif /* CUSTOMER_HW */
#ifdef CUSTOMER_HW_AMLOGIC
extern_wifi_set_enable(0);
mdelay(200);
extern_wifi_set_enable(1);
mdelay(200);
sdio_reinit();
#endif /* CUSTOMER_HW_AMLOGIC */
break;
}
}
