static int __devinit bt_power_probe(struct platform_device *pdev)
{
int ret = 0;
dev_dbg(&pdev->dev, "%s\n", __func__);
if (!pdev->dev.platform_data) {
dev_err(&pdev->dev, "platform data not initialized\n");
return -ENOSYS;
}
ret = bluetooth_power_rfkill_probe(pdev);
return ret;
}
static int bt_power_probe(struct platform_device *pdev)
{
int ret = 0;
dev_dbg(&pdev->dev, "%s\n", __func__);
bt_power_pdata =
kzalloc(sizeof(struct bluetooth_power_platform_data),
GFP_KERNEL);
if (!bt_power_pdata) {
BT_PWR_ERR("Failed to allocate memory");
return -ENOMEM;
}
if (pdev->dev.of_node) {
ret = bt_power_populate_dt_pinfo(pdev);
if (ret < 0) {
BT_PWR_ERR("Failed to populate device tree info");
goto free_pdata;
}
pdev->dev.platform_data = bt_power_pdata;
} else if (pdev->dev.platform_data) {
/* Optional data set to default if not provided */
if (!((struct bluetooth_power_platform_data *)
(pdev->dev.platform_data))->bt_power_setup)
((struct bluetooth_power_platform_data *)
(pdev->dev.platform_data))->bt_power_setup =
bluetooth_power;
memcpy(bt_power_pdata, pdev->dev.platform_data,
sizeof(struct bluetooth_power_platform_data));
} else {
BT_PWR_ERR("Failed to get platform data");
goto free_pdata;
}
if (bluetooth_power_rfkill_probe(pdev) < 0)
goto free_pdata;
btpdev = pdev;
return 0;
free_pdata:
kfree(bt_power_pdata);
return ret;
}
static int __init bt_power_probe(struct platform_device *pdev)
{
int ret = 0;
printk(KERN_DEBUG "%s\n", __func__);
if (!pdev->dev.platform_data) {
printk(KERN_ERR "%s: platform data not initialized\n",
__func__);
return -ENOSYS;
}
ret = bluetooth_power_rfkill_probe(pdev);
return ret;
}
static int __devinit bt_power_probe(struct platform_device *pdev)
{
int ret = 0;
dev_dbg(&pdev->dev, "%s\n", __func__);
if (!pdev->dev.platform_data) {
dev_err(&pdev->dev, "platform data not initialized\n");
return -ENOSYS;
}
#if defined (CONFIG_MACH_LGE)
bt_platform_data = (struct bluetooth_platform_data *)pdev->dev.platform_data;
#endif
ret = bluetooth_power_rfkill_probe(pdev);
return ret;
}
static int __devinit bt_power_probe(struct platform_device *pdev)
{
int ret = 0;
dev_dbg(&pdev->dev, "%s\n", __func__);
if (!pdev->dev.platform_data) {
dev_err(&pdev->dev, "platform data not initialized\n");
return -ENOSYS;
}
//[LGE_UPDATE_S] 20110420, BRCM BT Power, [START]
#if defined (CONFIG_MACH_LGE_I_BOARD)
bt_platform_data = (struct bluetooth_platform_data *)pdev->dev.platform_data;
#endif
//[LGE_UPDATE_E] 20110420, BRCM BT Power, [END]
ret = bluetooth_power_rfkill_probe(pdev);
return ret;
}
static int __devinit bt_power_probe(struct platform_device *pdev)
{
int ret = 0;
dev_dbg(&pdev->dev, "%s\n", __func__);
if (!pdev->dev.platform_data) {
dev_err(&pdev->dev, "platform data not initialized\n");
return -ENOSYS;
}
#ifdef CONFIG_AR6K
wifi_power_state = 0;
#endif
spin_lock(&bt_power_lock);
power_control = pdev->dev.platform_data;
if (bluetooth_power_state) {
printk(KERN_INFO
"%s: handling deferred power switch\n",
__func__);
}
//ret = (*power_control)(bluetooth_power_state);
spin_unlock(&bt_power_lock);
if (!ret && !bluetooth_power_state &&
bluetooth_power_rfkill_probe(pdev))
ret = -ENOMEM;
#ifdef CONFIG_AR6K
wifi_rfkill_probe(pdev);
#endif
return ret;
}
static int __devinit bt_power_probe(struct platform_device *pdev)
{
int ret = 0;
printk("%s\n",__func__);;//shiks_test
dev_dbg(&pdev->dev, "%s\n", __func__);
if (!pdev->dev.platform_data) {
dev_err(&pdev->dev, "platform data not initialized\n");
return -ENOSYS;
}
if (gpio_request(GPIO_BT_WLAN_REG_ON, "GPIO_BT_WLAN_REG_ON"))printk(KERN_ERR "[BTDRV] %s: gpio request 'GPIO_BT_WLAN_REG_ON' failed\n", __func__);
if (gpio_request(GPIO_BT_RESET, "GPIO_BT_RESET"))printk(KERN_ERR "[BTDRV] %s: gpio request 'GPIO_BT_RESET' failed\n", __func__);
gpio_direction_output(GPIO_BT_WLAN_REG_ON, 1);
msleep(50);
gpio_direction_output(GPIO_BT_RESET, 1);
gpio_direction_output(GPIO_WLAN_RESET, 1);
msleep(150);
gpio_direction_output(GPIO_BT_RESET, 0);
gpio_direction_output(GPIO_WLAN_RESET, 0);
msleep(50);
gpio_direction_output(GPIO_BT_WLAN_REG_ON, 0);
gpio_free(GPIO_BT_WLAN_REG_ON);
gpio_free(GPIO_BT_RESET);
gpio_free(GPIO_WLAN_RESET);
ret = bluetooth_power_rfkill_probe(pdev);
return ret;
}
/*************************************************
Function: bluetooth_power_probe
Description: bluetooth power driver probe function
Calls: bluetooth_power_rfkill_probe
Input: platform_device *pdev
Output:
Return: int ret
Others: NA
*************************************************/
static int bluetooth_power_probe(struct platform_device *pdev){
struct device *bluetooth_power_dev = &pdev->dev;
struct device_node *np = bluetooth_power_dev->of_node;
struct bluetooth_power_private_data *pdev_bluetooth_power_data = NULL;
int ret;
pdev_bluetooth_power_data = devm_kzalloc(bluetooth_power_dev, sizeof(struct bluetooth_power_private_data), GFP_KERNEL);
if ( pdev_bluetooth_power_data == NULL ) {
dev_err(bluetooth_power_dev, "failed to allocate bluetooth_power_private_data\n");
return -ENOMEM;
}
printk(KERN_INFO "bluetooth_power probe in \n");
of_property_read_u32(np, "huawei,bt_en", &(pdev_bluetooth_power_data->gpio_enable.gpio));
of_property_read_u32(np, "huawei,bt_wake_host", &(pdev_bluetooth_power_data->gpio_bt_wake_host.gpio));
of_property_read_u32(np, "huawei,host_wake_bt", &(pdev_bluetooth_power_data->gpio_host_wake_bt.gpio));
printk(KERN_INFO "devm clk get \n");
pdev_bluetooth_power_data->clk = devm_clk_get(bluetooth_power_dev, NULL);
printk(KERN_INFO "clk is 0x%x\n", (int)pdev_bluetooth_power_data->clk);
if (IS_ERR( pdev_bluetooth_power_data->clk)) {
printk(KERN_INFO "Get bt 32k clk failed\n");
ret = PTR_ERR( pdev_bluetooth_power_data->clk );
goto err_free_clk_ret;
}
/*printk(KERN_INFO "regulator_get in\n");
pdev_bluetooth_power_data->vdd = regulator_get(bluetooth_power_dev,"huawei,bt_power"); // regulator is ldo14
if (IS_ERR( pdev_bluetooth_power_data->vdd )) {
printk(KERN_INFO "bt regulator_get failed\n");
pdev_bluetooth_power_data->vdd = NULL;
ret = -ENOMEM;
goto err_free_clk_ret; // free memory
}
printk(KERN_INFO "regulator_get out\n");*/
ret = gpio_request( pdev_bluetooth_power_data->gpio_enable.gpio , "bt_gpio_enable" );
if (ret < 0) {
pr_err("%s: gpio_request %d failed, ret:%d .\n", __func__, pdev_bluetooth_power_data->gpio_enable.gpio ,ret);
goto err_free_clk_ret;
}
ret = gpio_request( pdev_bluetooth_power_data->gpio_host_wake_bt.gpio , "host_wake_bt" );
if (ret < 0) {
pr_err("%s: gpio_request %d failed, ret:%d .\n", __func__, pdev_bluetooth_power_data->gpio_host_wake_bt.gpio ,ret);
goto err_free_clk_ret;
}
ret = gpio_request( pdev_bluetooth_power_data->gpio_bt_wake_host.gpio , "bt_wake_host" );
if (ret < 0) {
pr_err("%s: gpio_request %d failed, ret:%d .\n", __func__, pdev_bluetooth_power_data->gpio_bt_wake_host.gpio ,ret);
goto err_free_clk_ret;
}
ret = gpio_direction_output( pdev_bluetooth_power_data->gpio_enable.gpio , 0);
if (ret < 0) {
pr_err("%s: gpio_direction_output %d failed, ret:%d .\n", __func__, pdev_bluetooth_power_data->gpio_enable.gpio ,ret);
goto err_free_clk_ret;
}
ret = gpio_direction_output( pdev_bluetooth_power_data->gpio_host_wake_bt.gpio , 0);
if (ret < 0) {
pr_err("%s: gpio_direction_output %d failed, ret:%d .\n", __func__, pdev_bluetooth_power_data->gpio_host_wake_bt.gpio ,ret);
goto err_free_clk_ret;
}
ret = gpio_direction_input( pdev_bluetooth_power_data->gpio_bt_wake_host.gpio);
if (ret < 0) {
pr_err("%s: gpio_direction_output %d failed, ret:%d .\n", __func__, pdev_bluetooth_power_data->gpio_bt_wake_host.gpio ,ret);
goto err_free_clk_ret;
}
/* set bluetooth vddio voltage to 1.8V */
/*printk(KERN_INFO "regulator_set_voltage in\n");
ret = regulator_set_voltage( pdev_bluetooth_power_data->vdd, BT_VDDIO_LDO_18V, BT_VDDIO_LDO_18V );
printk(KERN_INFO "regulator_set_voltage out\n");
if (ret) {
dev_err(&pdev->dev, "%s: bluetooth regulator_set_voltage err %d\n", __func__, ret);
goto err_free_clk_ret;
}*/
ret = bluetooth_power_rfkill_probe(pdev, pdev_bluetooth_power_data);
if (ret) {
dev_err(&pdev->dev, "bluetooth_power_rfkill_probe failed, ret:%d\n", ret);
goto err_free_clk_ret;
}
// other code
platform_set_drvdata(pdev, pdev_bluetooth_power_data);
printk(KERN_INFO "bluetooth_power probe out \n");
return ret;
err_free_clk_ret:
devm_clk_put(&pdev->dev, pdev_bluetooth_power_data->clk);
return ret;
}
