static int legend_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
enum rfkill_state default_state = RFKILL_STATE_SOFT_BLOCKED; /* off */
/* force BT on and off to do GPIO setting when initiate */
bluetooth_set_power(NULL, RFKILL_STATE_UNBLOCKED);
legend_config_bt_init(); /* bt gpio initial config */
rfkill_set_default(RFKILL_TYPE_BLUETOOTH, default_state);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!bt_rfk)
return -ENOMEM;
bt_rfk->name = bt_name;
bt_rfk->state = default_state;
/* userspace cannot take exclusive control */
bt_rfk->user_claim_unsupported = 1;
bt_rfk->user_claim = 0;
bt_rfk->data = NULL; /* user data */
bt_rfk->toggle_radio = bluetooth_set_power;
rc = rfkill_register(bt_rfk);
if (rc)
rfkill_free(bt_rfk);
return rc;
}
/* Export an interface for the other drivers */
int bliss_bluetooth_set_power(int on)
{
if (on)
bluetooth_set_power(NULL, false);
else
bluetooth_set_power(NULL, true);
return 0;
}
static int pico_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true; /* off */
/* always turn on clock */
htc_wifi_bt_sleep_clk_ctl(CLK_ON, ID_BT);
mdelay(2);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&pico_rfkill_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
/* userspace cannot take exclusive control */
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
return rc;
}
static int __init socle_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
/* default to bluetooth off */
rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_STATE_SOFT_BLOCKED);
bluetooth_set_power(NULL, RFKILL_STATE_SOFT_BLOCKED);
bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!bt_rfk)
return -ENOMEM;
bt_rfk->name = bt_name;
bt_rfk->state = RFKILL_STATE_SOFT_BLOCKED;
/* userspace cannot take exclusive control */
bt_rfk->user_claim_unsupported = 1;
bt_rfk->user_claim = 0;
bt_rfk->data = NULL; // user data
bt_rfk->toggle_radio = bluetooth_set_power;
rc = rfkill_register(bt_rfk);
if (rc)
rfkill_free(bt_rfk);
return rc;
}
static int mogami_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true; /* off */
rc = bluetooth_set_power(pdev->dev.platform_data, default_state);
if (rc)
goto err_rfkill;
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&mogami_rfkill_ops, pdev->dev.platform_data);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill;
}
rfkill_set_states(bt_rfk, default_state, false);
/* userspace cannot take exclusive control */
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
platform_set_drvdata(pdev, bt_rfk);
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill:
return rc;
}
static int liberty_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
enum rfkill_state default_state = RFKILL_STATE_SOFT_BLOCKED;
liberty_config_bt_init(); /* bt gpio initial config */
rfkill_set_default(RFKILL_TYPE_BLUETOOTH, default_state);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!bt_rfk)
return -ENOMEM;
bt_rfk->name = bt_name;
bt_rfk->state = default_state;
/* userspace cannot take exclusive control */
bt_rfk->user_claim_unsupported = 1;
bt_rfk->user_claim = 0;
bt_rfk->data = NULL;
bt_rfk->toggle_radio = bluetooth_set_power;
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_free(bt_rfk);
return rc;
}
static int m4_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true;
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&m4_rfkill_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
return rc;
}
static int spade_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true; /* off */
spade_config_bt_init(); /* bt gpio initial config */
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&spade_rfkill_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_reset;
}
rfkill_set_states(bt_rfk, default_state, false);
/* userspace cannot take exclusive control */
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_reset:
return rc;
}
static int rfkill_bluetooth_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true;
printk(KERN_INFO "-->%s\n", __func__);
getIoResource(pdev);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&rfkill_bluetooth_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_gpio_init();
/* userspace cannot take exclusive control */
rfkill_init_sw_state(bt_rfk,false);
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
rfkill_set_sw_state(bt_rfk,true);
bluetooth_set_power(NULL, default_state);
printk(KERN_INFO "<--%s\n", __func__);
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
return rc;
}
static int bt_rfkill_set_block(void *data, bool blocked)
{
unsigned int ret =0;
ret = bluetooth_set_power(data, blocked? RFKILL_USER_STATE_SOFT_BLOCKED : RFKILL_USER_STATE_UNBLOCKED);
return ret;
}
static int lgps3_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true; /* off */
#if defined(CONFIG_BCM4335BT)
//+++BRCM 4335 AXI Patch
bcm_btlock_init();
//---BRCM
#endif // defined(CONFIG_BCM4335BT)
printk(KERN_ERR"lgps3_rfkill_probe\n");
rc = gpio_request(LGPS3_GPIO_BT_RESET_N, "bt_reset");
if (rc)
{
printk(KERN_ERR "GPIO req error no=%d",rc);
gpio_free(LGPS3_GPIO_BT_RESET_N);
rc = gpio_request(LGPS3_GPIO_BT_RESET_N, "bt_reset");
if(rc)
{
printk(KERN_ERR "GPIO req error no=%d",rc);
goto err_gpio_reset;
}
}
gpio_direction_output(LGPS3_GPIO_BT_RESET_N, 0);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&lgps3_rfkill_ops, NULL);
if (!bt_rfk) {
printk(KERN_ERR"rfkill alloc failed.\n");
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
/* userspace cannot take exclusive control */
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
err_gpio_reset:
gpio_free(LGPS3_GPIO_BT_RESET_N);
printk(KERN_ERR"lgps3_rfkill_probe error!\n");
return rc;
}
static int __init smdk6410_rfkill_probe(struct platform_device *pdev)
#endif /* #ifdef CONFIG_MACH_JET */
#endif /* #ifdef CONFIG_MACH_SPICA */
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
{
int rc = 0;
int irq,ret;
//Initialize wake locks
wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "board-rfkill");
wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt-rfkill");
//BT Host Wake IRQ
irq = IRQ_BT_HOST_WAKE;
ret = request_irq(irq, bt_host_wake_irq_handler, 0, "bt_host_wake_irq_handler", NULL);
if(ret < 0)
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] Request_irq failed \n");
#else
printk(KERN_DEBUG "[BT] Request_irq failed \n");
#endif /* #else #ifdef CONFIG_MACH_INSTINCTQ */
set_irq_type(irq, IRQ_TYPE_EDGE_BOTH);
enable_irq(IRQ_EINT(22));
//RFKILL init - default to bluetooth off
rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_STATE_SOFT_BLOCKED);
bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!bt_rfk)
return -ENOMEM;
bt_rfk->name = bt_name;
bt_rfk->state = RFKILL_STATE_SOFT_BLOCKED;
/* userspace cannot take exclusive control */
bt_rfk->user_claim_unsupported = 1;
bt_rfk->user_claim = 0;
bt_rfk->data = NULL; // user data
bt_rfk->toggle_radio = bluetooth_set_power;
#ifdef CONFIG_MACH_INSTINCTQ
printk("[BT] rfkill_register(bt_rfk) \n");
#else
printk(KERN_DEBUG "[BT] rfkill_register(bt_rfk) \n");
#endif /* #ifdef CONFIG_MACH_INSTINCTQ */
rc = rfkill_register(bt_rfk);
if (rc)
rfkill_free(bt_rfk);
bluetooth_set_power(NULL, RFKILL_STATE_SOFT_BLOCKED);
return rc;
}
static int endeavortd_rfkill_probe(struct platform_device *pdev)
{
int ret = 0;
int err = 0;
bool default_state = true; /* off */
pr_info("[BT]%s: starting initialize endeavortd_rfkill\n" , __func__);
gpio_request(ENDEAVORTD_GPIO_BT_SHUTDOWN_N, "bcm4334_nshutdown_gpio");
if (err)
pr_err("BT_SHUTDOWN_N gpio request failed:%d\n", err);
gpio_request(ENDEAVORTD_GPIO_BT_UART3_CTS, "bcm4334_uart3_cts");
if (err)
pr_err("BT_CTS_N gpio request failed:%d\n", err);
gpio_request(ENDEAVORTD_GPIO_BT_UART3_RTS, "bcm4334_uart3_rts");
if (err)
pr_err("BT_RTS_N gpio request failed:%d\n", err);
gpio_request(ENDEAVORTD_GPIO_BT_UART3_TX, "bcm4334_uart3_tx");
if (err)
pr_err("BT_TXD gpio request failed:%d\n", err);
gpio_request(ENDEAVORTD_GPIO_BT_UART3_RX, "bcm4334_uart3_rx");
if (err)
pr_err("BT_RXD gpio request failed:%d\n", err);
tegra_gpio_enable(ENDEAVORTD_GPIO_BT_SHUTDOWN_N);
gpio_direction_output(ENDEAVORTD_GPIO_BT_SHUTDOWN_N, 0);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&endeavortd_rfkill_ops, NULL);
if (!bt_rfk) {
ret = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
/* userspace cannot take exclusive control */
ret = rfkill_register(bt_rfk);
if (ret)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
return ret;
}
static int shooter_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true; /* off */
#if 0 /* Is this necessary? */
rc = gpio_request(SHOOTER_GPIO_BT_RESET_N, "bt_reset");
if (rc)
goto err_gpio_reset;
rc = gpio_request(SHOOTER_GPIO_BT_SHUTDOWN_N, "bt_shutdown");
if (rc)
goto err_gpio_shutdown;
#endif
/* always turn on clock? */
/*
htc_wifi_bt_sleep_clk_ctl(CLK_ON, ID_BT);
*/
mdelay(2);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&shooter_rfkill_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
/* userspace cannot take exclusive control */
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
#if 0
gpio_free(SHOOTER_GPIO_BT_SHUTDOWN_N);
err_gpio_shutdown:
gpio_free(SHOOTER_GPIO_BT_RESET_N);
err_gpio_reset:
#endif
return rc;
}
static int __init jupiter_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
int irq,ret;
//Initialize wake locks
wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "board-rfkill");
wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt-rfkill");
//BT Host Wake IRQ
irq = IRQ_BT_HOST_WAKE;
set_irq_type(irq, IRQ_TYPE_EDGE_BOTH);
ret = request_irq(irq, bt_host_wake_irq_handler, 0, "bt_host_wake_irq_handler", NULL);
if(ret < 0)
printk(KERN_ERR "[BT] Request_irq failed \n");
set_irq_type(irq, IRQ_TYPE_EDGE_BOTH);
// enable_irq(IRQ_EINT(22));
//RFKILL init - default to bluetooth off
rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_STATE_SOFT_BLOCKED);
bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!bt_rfk)
return -ENOMEM;
bt_rfk->name = bt_name;
bt_rfk->state = RFKILL_STATE_SOFT_BLOCKED;
/* userspace cannot take exclusive control */
bt_rfk->user_claim_unsupported = 1;
bt_rfk->user_claim = 0;
bt_rfk->data = NULL; // user data
bt_rfk->toggle_radio = bluetooth_set_power;
printk(KERN_DEBUG "[BT] rfkill_register(bt_rfk) \n");
rc = rfkill_register(bt_rfk);
if (rc)
{
printk (KERN_ERR "***********ERROR IN REGISTERING THE RFKILL***********\n");
rfkill_free(bt_rfk);
}
bluetooth_set_power(NULL, RFKILL_STATE_SOFT_BLOCKED);
rfkill_force_state(bt_rfk, RFKILL_STATE_SOFT_BLOCKED);
return rc;
}
static int __init jupiter_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
int irq,ret;
//Initialize wake locks
wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "board-rfkill");
#ifdef BT_SLEEP_ENABLER
wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt-rfkill");
#endif
//BT Host Wake IRQ
irq = IRQ_BT_HOST_WAKE;
s3c_gpio_cfgpin(GPIO_BT_HOST_WAKE, S3C_GPIO_SFN(GPIO_BT_HOST_WAKE_AF));
s3c_gpio_setpull(S5PV210_GPH2(5), S3C_GPIO_PULL_DOWN);
set_irq_type(IRQ_EINT(21), IRQ_TYPE_EDGE_BOTH);
set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
ret = request_irq(irq, bt_host_wake_irq_handler, 0, "bt_host_wake_irq_handler", NULL);
if(ret < 0)
printk(KERN_ERR "[BT] Request_irq failed \n");
// enable_irq(IRQ_BT_HOST_WAKE);
//RFKILL init - default to bluetooth off
//rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_USER_STATE_SOFT_BLOCKED);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bt_rfkill_ops, NULL);
if (!bt_rfk)
return -ENOMEM;
rfkill_init_sw_state(bt_rfk, 0);
printk(KERN_DEBUG "[BT] rfkill_register(bt_rfk) \n");
rc = rfkill_register(bt_rfk);
if (rc)
{
printk ("***********ERROR IN REGISTERING THE RFKILL***********\n");
rfkill_destroy(bt_rfk);
}
rfkill_set_sw_state(bt_rfk, 1);
bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED);
return rc;
}
static int pyramid_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true;
#if 0
rc = gpio_request(PYRAMID_GPIO_BT_RESET_N, "bt_reset");
if (rc)
goto err_gpio_reset;
rc = gpio_request(PYRAMID_GPIO_BT_SHUTDOWN_N, "bt_shutdown");
if (rc)
goto err_gpio_shutdown;
#endif
mdelay(2);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&pyramid_rfkill_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
#if 0
gpio_free(PYRAMID_GPIO_BT_SHUTDOWN_N);
err_gpio_shutdown:
gpio_free(PYRAMID_GPIO_BT_RESET_N);
err_gpio_reset:
#endif
return rc;
}
static int __init jupiter_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
int irq,ret;
//Initialize wake locks
wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "board-rfkill");
#ifdef BT_SLEEP_ENABLER
wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt-rfkill");
#endif
//BT Host Wake IRQ
irq = IRQ_BT_HOST_WAKE;
// p9p9 2010.11.12 Merged from Victory [When AP is in sleep, AP is not waken up by BT_HOST_WAKE]
set_irq_type(irq, IRQ_TYPE_EDGE_BOTH ); //set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
ret = request_irq(irq, bt_host_wake_irq_handler, 0, "bt_host_wake_irq_handler", NULL);
if(ret < 0)
printk(KERN_ERR "[BT] Request_irq failed ret=%d %d<-->%d\n", ret, IRQ_EINT(4), IRQ_EINT4);
// enable_irq(IRQ_BT_HOST_WAKE);
//RFKILL init - default to bluetooth off
//rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_USER_STATE_SOFT_BLOCKED);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bt_rfkill_ops, NULL);
if (!bt_rfk)
return -ENOMEM;
rfkill_init_sw_state(bt_rfk, 0);
printk(KERN_DEBUG "[BT] rfkill_register(bt_rfk) \n");
rc = rfkill_register(bt_rfk);
if (rc)
{
printk ("***********ERROR IN REGISTERING THE RFKILL***********\n");
rfkill_destroy(bt_rfk);
}
rfkill_set_sw_state(bt_rfk, 1);
bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED);
return rc;
}
static int holiday_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true; /* off */
#if 0 /* Is this necessary? */
rc = gpio_request(HOLIDAY_GPIO_BT_RESET_N, "bt_reset");
if (rc)
goto err_gpio_reset;
rc = gpio_request(HOLIDAY_GPIO_BT_SHUTDOWN_N, "bt_shutdown");
if (rc)
goto err_gpio_shutdown;
#endif
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&holiday_rfkill_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
/* userspace cannot take exclusive control */
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
#if 0
gpio_free(HOLIDAY_GPIO_BT_SHUTDOWN_N);
err_gpio_shutdown:
gpio_free(HOLIDAY_GPIO_BT_RESET_N);
err_gpio_reset:
#endif
return rc;
}
static int hero_rfkill_probe(struct platform_device *pdev)
{
int ret;
bool default_state = true; /* off */
ret = gpio_request(HERO_GPIO_WB_SHUT_DOWN_N, "hero_gpio_wb_shut_down_n");
if (ret) {
printk(KERN_ERR "%s: Could not request gpio: %d\n", __func__, ret);
goto err_gpio_shutdown;
}
hero_bt_status = 0;
config_bt_table(hero_bt_init_table, ARRAY_SIZE(hero_bt_init_table));
mdelay(5);
gpio_direction_output(HERO_GPIO_WB_SHUT_DOWN_N, 0);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&hero_rfkill_ops, NULL);
if (!bt_rfk){
printk(KERN_ERR "%s: Could not allocate memmory\n", __func__);
ret = -ENOMEM;
goto err_rfkill_alloc;
}
/* userspace cannot take exclusive control */
rfkill_set_states(bt_rfk, default_state, false);
ret = rfkill_register(bt_rfk);
if (ret) {
printk(KERN_ERR "%s: failed to register rfkill: %d\n", __func__, ret);
goto err_rfkill_reg;
}
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
gpio_free(HERO_GPIO_WB_SHUT_DOWN_N);
err_gpio_shutdown:
return ret;
}
static int mahimahi_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true; /* */
rc = gpio_request(MAHIMAHI_GPIO_BT_RESET_N, "bt_reset");
if (rc)
goto err_gpio_reset;
rc = gpio_request(MAHIMAHI_GPIO_BT_SHUTDOWN_N, "bt_shutdown");
if (rc)
goto err_gpio_shutdown;
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&mahimahi_rfkill_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
/* */
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
gpio_free(MAHIMAHI_GPIO_BT_SHUTDOWN_N);
err_gpio_shutdown:
gpio_free(MAHIMAHI_GPIO_BT_RESET_N);
err_gpio_reset:
return rc;
}
static int trout_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true; /* off */
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&trout_rfkill_ops, NULL);
if (!bt_rfk)
return -ENOMEM;
rfkill_set_states(bt_rfk, default_state, default_state);
/* userspace cannot take exclusive control */
rc = rfkill_register(bt_rfk);
if (rc)
rfkill_destroy(bt_rfk);
return rc;
}
static int ruby_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true;
rc = gpio_request(RUBY_GPIO_BT_EN, "bt_en");
if (rc)
goto err_gpio_en;
htc_wifi_bt_sleep_clk_ctl(CLK_ON, ID_BT);
mdelay(2);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&ruby_rfkill_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
gpio_free(RUBY_GPIO_BT_EN);
err_gpio_en:
return rc;
}
static int __init aries_rfkill_probe(struct platform_device *pdev)
{
int irq,ret;
/* Initialize wake locks */
wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "bt_host_wake");
ret = gpio_request(GPIO_WLAN_BT_EN, "GPB");
if (ret < 0) {
pr_err("[BT] Failed to request GPIO_WLAN_BT_EN!\n");
goto err_req_gpio_wlan_bt_en;
}
ret = gpio_request(GPIO_BT_nRST, "GPB");
if (ret < 0) {
pr_err("[BT] Failed to request GPIO_BT_nRST!\n");
goto err_req_gpio_bt_nrst;
}
//BT Host Wake IRQ
irq = IRQ_BT_HOST_WAKE;
ret = request_irq(irq, bt_host_wake_irq_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"bt_host_wake_irq_handler", NULL);
if (ret < 0) {
pr_err("[BT] Request_irq failed\n");
goto err_req_irq;
}
disable_irq(irq);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&bt_rfkill_ops, NULL);
if (!bt_rfk) {
pr_err("[BT] bt_rfk : rfkill_alloc is failed\n");
ret = -ENOMEM;
goto err_alloc;
}
rfkill_init_sw_state(bt_rfk, 0);
pr_debug("[BT] rfkill_register(bt_rfk)\n");
ret = rfkill_register(bt_rfk);
if (ret) {
pr_debug("********ERROR IN REGISTERING THE RFKILL********\n");
goto err_register;
}
rfkill_set_sw_state(bt_rfk, 1);
bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED);
#ifdef BT_SLEEP_ENABLER
wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt_wake");
ret = gpio_request(GPIO_BT_WAKE, "gpio_bt_wake");
if (ret < 0) {
pr_err("[BT] Failed to request GPIO_BT_WAKE\n");
goto err_req_gpio_bt_wake;
}
gpio_direction_output(GPIO_BT_WAKE, GPIO_LEVEL_LOW);
bt_sleep_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&btsleep_rfkill_ops, NULL);
if (!bt_sleep_rfk) {
pr_err("[BT] bt_sleep_rfk : rfkill_alloc is failed\n");
ret = -ENOMEM;
goto err_sleep_alloc;
}
rfkill_set_sw_state(bt_sleep_rfk, 1);
pr_debug("[BT] rfkill_register(bt_sleep_rfk)\n");
ret = rfkill_register(bt_sleep_rfk);
if (ret) {
pr_err("********ERROR IN REGISTERING THE bt_sleep_rfk********\n");
goto err_sleep_register;
}
#endif
#ifdef USE_LOCK_DVFS
bt_lock_dvfs_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&bt_lock_dvfs_rfkill_ops, NULL);
if (!bt_lock_dvfs_rfk) {
pr_err("[BT] bt_lock_dvfs_rfk : rfkill_alloc is failed\n");
ret = -ENOMEM;
goto err_dvfs_lock_alloc;
}
pr_debug("[BT] rfkill_register(bt_lock_dvfs_rfk)\n");
ret = rfkill_register(bt_lock_dvfs_rfk);
if (ret) {
pr_err("********ERROR IN REGISTERING THE bt_lock_dvfs_rfk********\n");
goto err_lock_dvfs_register;
}
bt_lock_dvfs_l2_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&bt_lock_dvfs_l2_rfkill_ops, NULL);
if (!bt_lock_dvfs_l2_rfk) {
pr_err("[BT] bt_lock_dvfs_l2_rfk : rfkill_alloc is failed\n");
ret = -ENOMEM;
goto err_dvfs_l2_lock_alloc;
}
pr_debug("[BT] rfkill_register(bt_lock_dvfs_l2_rfk)\n");
ret = rfkill_register(bt_lock_dvfs_l2_rfk);
if (ret) {
pr_err("********ERROR IN REGISTERING THE bt_lock_dvfs_l2_rfk********\n");
goto err_lock_dvfs_l2_register;
}
#endif
return ret;
#ifdef USE_LOCK_DVFS
err_lock_dvfs_l2_register:
rfkill_destroy(bt_lock_dvfs_l2_rfk);
err_dvfs_l2_lock_alloc:
rfkill_unregister(bt_lock_dvfs_rfk);
err_lock_dvfs_register:
rfkill_destroy(bt_lock_dvfs_rfk);
err_dvfs_lock_alloc:
rfkill_unregister(bt_sleep_rfk);
#endif
#ifdef BT_SLEEP_ENABLER
err_sleep_register:
rfkill_destroy(bt_sleep_rfk);
err_sleep_alloc:
gpio_free(GPIO_BT_WAKE);
err_req_gpio_bt_wake:
rfkill_unregister(bt_rfk);
#endif
err_register:
rfkill_destroy(bt_rfk);
err_alloc:
free_irq(irq, NULL);
err_req_irq:
gpio_free(GPIO_BT_nRST);
err_req_gpio_bt_nrst:
gpio_free(GPIO_WLAN_BT_EN);
err_req_gpio_wlan_bt_en:
return ret;
}
static int htc_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true;
struct pinctrl_state *set_state;
printk(KERN_INFO "[BT]== rfkill_probe ==\n");
bt_export_bd_address();
fm_ant_node_init();
if (pdev->dev.of_node) {
gpio_bt_reg_on = of_get_named_gpio(pdev->dev.of_node,
"brcm,bt-regon-gpio", 0);
if (gpio_bt_reg_on < 0) {
printk("[BT]bt-regon-gpio not provided in device tree !!!");
} else {
printk("[BT]bt-regon-gpio: %d", gpio_bt_reg_on);
}
}
bt_pinctrl = devm_pinctrl_get(&pdev->dev);
if (IS_ERR(bt_pinctrl)) {
if (PTR_ERR(bt_pinctrl) == -EPROBE_DEFER) {
printk("[BT] bt_pinctrl EPROBE_DEFER !!");
return -EPROBE_DEFER;
}
}
if (bt_pinctrl) {
printk("[BT] Init GPIO pins\n");
set_state = pinctrl_lookup_state(bt_pinctrl, "bt_wake_host_gpio_on");
if (IS_ERR(set_state)) {
printk("[BT] cannot get BT pinctrl state bt_wake_host_gpio_on\n");
} else
bt_wake_host_set_state_on = set_state;
set_state = pinctrl_lookup_state(bt_pinctrl, "bt_wake_host_gpio_off");
if (IS_ERR(set_state)) {
printk("[BT] cannot get BT pinctrl state bt_wake_host_gpio_off\n");
} else
bt_wake_host_set_state_off = set_state;
}
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&htc_rfkill_ops, NULL);
if (!bt_rfk) {
rc = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_set_states(bt_rfk, default_state, false);
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_destroy(bt_rfk);
err_rfkill_alloc:
return rc;
}
static int __init herring_rfkill_probe(struct platform_device *pdev)
{
int irq;
int ret;
/* Initialize wake locks */
wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "bt_host_wake");
ret = gpio_request(GPIO_WLAN_BT_EN, "GPB");
if (ret < 0) {
pr_err("[BT] Failed to request GPIO_WLAN_BT_EN!\n");
goto err_req_gpio_wlan_bt_en;
}
ret = gpio_request(GPIO_BT_nRST, "GPB");
if (ret < 0) {
pr_err("[BT] Failed to request GPIO_BT_nRST!\n");
goto err_req_gpio_bt_nrst;
}
/* BT Host Wake IRQ */
irq = IRQ_BT_HOST_WAKE;
ret = request_irq(irq, bt_host_wake_irq_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"bt_host_wake_irq_handler", NULL);
if (ret < 0) {
pr_err("[BT] Request_irq failed\n");
goto err_req_irq;
}
disable_irq(irq);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&bt_rfkill_ops, NULL);
if (!bt_rfk) {
pr_err("[BT] bt_rfk : rfkill_alloc is failed\n");
ret = -ENOMEM;
goto err_alloc;
}
rfkill_init_sw_state(bt_rfk, 0);
pr_debug("[BT] rfkill_register(bt_rfk)\n");
ret = rfkill_register(bt_rfk);
if (ret) {
pr_debug("********ERROR IN REGISTERING THE RFKILL********\n");
goto err_register;
}
rfkill_set_sw_state(bt_rfk, 1);
bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED);
return ret;
err_register:
rfkill_destroy(bt_rfk);
err_alloc:
free_irq(irq, NULL);
err_req_irq:
gpio_free(GPIO_BT_nRST);
err_req_gpio_bt_nrst:
gpio_free(GPIO_WLAN_BT_EN);
err_req_gpio_wlan_bt_en:
return ret;
}
