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 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 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 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 __init bcm4329_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true;
DBG("Enter::%s,line=%d\n",__FUNCTION__,__LINE__);
/* default to bluetooth off */
bcm4329_set_block(NULL, default_state); /* blocked -> bt off */
bt_rfk = rfkill_alloc(bt_name,
NULL,
RFKILL_TYPE_BLUETOOTH,
&bcm4329_rfk_ops,
NULL);
if (!bt_rfk)
{
printk("fail to rfkill_allocate************\n");
return -ENOMEM;
}
rfkill_set_states(bt_rfk, default_state, false);
rc = rfkill_register(bt_rfk);
if (rc)
rfkill_destroy(bt_rfk);
printk("rc=0x%x\n", rc);
return rc;
}
static int hp_wmi_rfkill2_refresh(void)
{
struct bios_rfkill2_state state;
int err, i;
err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, HPWMI_READ, &state,
0, sizeof(state));
if (err)
return err;
for (i = 0; i < rfkill2_count; i++) {
int num = rfkill2[i].num;
struct bios_rfkill2_device_state *devstate;
devstate = &state.device[num];
if (num >= state.count ||
devstate->rfkill_id != rfkill2[i].id) {
pr_warn("power configuration of the wireless devices unexpectedly changed\n");
continue;
}
rfkill_set_states(rfkill2[i].rfkill,
IS_SWBLOCKED(devstate->power),
IS_HWBLOCKED(devstate->power));
}
return 0;
}
static int emev_rfkill_probe(struct platform_device *pdev)
{
debug_print("Rfkill bt probe\n");
int rc = 0;
struct emev_rfkill_platform_data *pdata = pdev->dev.platform_data;
bcm2048_hw_init();
pdata->rfkill = rfkill_alloc("emev_bt",
&pdev->dev,
RFKILL_TYPE_BLUETOOTH,
&emev_bt_rfkill_ops,
NULL);
if (unlikely(!pdata->rfkill)) {
return -ENOMEM;
}
/* set default status */
rfkill_set_states(pdata->rfkill, true, true);
rc = rfkill_register(pdata->rfkill);
if (unlikely(rc)) {
rfkill_destroy(pdata->rfkill);
}
return 0;
}
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 void rbtn_rfkill_query(struct rfkill *rfkill, void *data)
{
struct acpi_device *device = data;
int state;
state = rbtn_get(device);
if (state < 0)
return;
rfkill_set_states(rfkill, state, state);
}
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 hp_wmi_resume_handler(struct device *device)
{
/*
* Hardware state may have changed while suspended, so trigger
* input events for the current state. As this is a switch,
* the input layer will only actually pass it on if the state
* changed.
*/
if (hp_wmi_input_dev) {
if (test_bit(SW_DOCK, hp_wmi_input_dev->swbit))
input_report_switch(hp_wmi_input_dev, SW_DOCK,
hp_wmi_hw_state(HPWMI_DOCK_MASK));
if (test_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit))
input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
hp_wmi_hw_state(HPWMI_TABLET_MASK));
input_sync(hp_wmi_input_dev);
}
if (rfkill2_count)
hp_wmi_rfkill2_refresh();
if (wifi_rfkill)
rfkill_set_states(wifi_rfkill,
hp_wmi_get_sw_state(HPWMI_WIFI),
hp_wmi_get_hw_state(HPWMI_WIFI));
if (bluetooth_rfkill)
rfkill_set_states(bluetooth_rfkill,
hp_wmi_get_sw_state(HPWMI_BLUETOOTH),
hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
if (wwan_rfkill)
rfkill_set_states(wwan_rfkill,
hp_wmi_get_sw_state(HPWMI_WWAN),
hp_wmi_get_hw_state(HPWMI_WWAN));
return 0;
}
static int rfkill_rk_pm_prepare(struct device *dev)
{
struct rfkill_rk_data *rfkill = g_rfkill;
struct rfkill_rk_gpio* rts;
struct rfkill_rk_irq* wake_host_irq;
DBG("Enter %s\n",__FUNCTION__);
if (!rfkill)
return 0;
rts = &rfkill->pdata->rts_gpio;
wake_host_irq = &rfkill->pdata->wake_host_irq;
//To prevent uart to receive bt data when suspended
if (gpio_is_valid(rts->io))
{
DBG("Disable UART_RTS\n");
if (rts->iomux.name)
{
rk_mux_api_set(rts->iomux.name, rts->iomux.fgpio);
}
gpio_direction_output(rts->io, !rts->enable);
}
#ifdef CONFIG_BT_AUTOSLEEP
// BT进入睡眠状态，不接收主控数据
rfkill_rk_sleep_bt(BT_SLEEP);
#endif
/* 至此，蓝牙不再送数据到UART，也不再接收主控的UART数据
* 接着调用enable_irq使能 bt_wake_host irq，当远端设备有数据
* 到来时，将通过该IRQ唤醒主控
*/
// enable bt wakeup host
if (gpio_is_valid(wake_host_irq->gpio.io))
{
DBG("enable irq for bt wakeup host\n");
enable_irq(wake_host_irq->irq);
}
#ifdef CONFIG_RFKILL_RESET
rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false);
rfkill_rk_set_power(rfkill, BT_BLOCKED);
#endif
return 0;
}
static int sw_rfkill_probe(struct platform_device *pdev)
{
int ret = 0;
sw_rfkill = rfkill_alloc(bt_name, &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &sw_rfkill_ops, NULL);
if (unlikely(!sw_rfkill))
return -ENOMEM;
rfkill_set_states(sw_rfkill, true, false);
ret = rfkill_register(sw_rfkill);
if (unlikely(ret)) {
rfkill_destroy(sw_rfkill);
}
return ret;
}
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 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 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 bcm4329_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true;
pr_info("Enter::%s,line=%d\n",__FUNCTION__,__LINE__);
rc = gpio_request(INFOIT50_BT_GPIO_POWER_N, "bt_shutdown");
if (rc)
return rc;
rc = gpio_request(INFOIT50_BT_GPIO_RESET_N, "bt_reset");
if (rc){
gpio_free(INFOIT50_BT_GPIO_POWER_N);
return rc;
}
/* default to bluetooth off */
bcm4329_set_block(NULL, default_state); /* blocked -> bt off */
bt_rfk = rfkill_alloc(bt_name,
NULL,
RFKILL_TYPE_BLUETOOTH,
&bcm4329_rfk_ops,
NULL);
if (!bt_rfk)
{
printk("fail to rfkill_allocate************\n");
return -ENOMEM;
}
rfkill_set_states(bt_rfk, default_state, false);
rc = rfkill_register(bt_rfk);
if (rc)
rfkill_destroy(bt_rfk);
printk("rc=0x%x\n", rc);
return rc;
}
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 wl127x_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
struct wl127x_rfkill_platform_data *pdata = pdev->dev.platform_data;
if (pdata->bt_nshutdown_gpio >= 0) {
bool default_blocked = true; /* power off */
rc = gpio_request(pdata->bt_nshutdown_gpio,
"wl127x_bt_nshutdown_gpio");
if (unlikely(rc))
return rc;
rc = gpio_direction_output(pdata->bt_nshutdown_gpio, 0);
if (unlikely(rc))
return rc;
if (pdata->bt_hw_init)
rc = pdata->bt_hw_init();
if (unlikely(rc))
return rc;
wl127x_bt_rfkill_set_power((void *)pdata, default_blocked);
pdata->rfkill[WL127X_BLUETOOTH] = rfkill_alloc(
"wl127x Bluetooth", &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &wl127x_bt_rfkill_ops,
(void *)pdata);
if (unlikely(!pdata->rfkill[WL127X_BLUETOOTH]))
return -ENOMEM;
rfkill_set_states(pdata->rfkill[WL127X_BLUETOOTH],
default_blocked, false);
rc = rfkill_register(pdata->rfkill[WL127X_BLUETOOTH]);
if (unlikely(rc)) {
rfkill_destroy(pdata->rfkill[WL127X_BLUETOOTH]);
return rc;
}
}
if (pdata->fm_enable_gpio >= 0) {
bool default_blocked = true; /* power off */
rc = gpio_request(pdata->fm_enable_gpio,
"wl127x_fm_enable_gpio");
if (unlikely(rc))
return rc;
rc = gpio_direction_output(pdata->fm_enable_gpio, 0);
if (unlikely(rc))
return rc;
wl127x_fm_rfkill_set_power((void *)pdata->fm_enable_gpio,
default_blocked);
pdata->rfkill[WL127X_FM] = rfkill_alloc("wl127x FM Radio",
&pdev->dev, RFKILL_TYPE_FM,
&wl127x_fm_rfkill_ops,
(void *)pdata->fm_enable_gpio);
if (unlikely(!pdata->rfkill[WL127X_FM]))
return -ENOMEM;
rfkill_set_states(pdata->rfkill[WL127X_FM], default_blocked,
false);
rc = rfkill_register(pdata->rfkill[WL127X_FM]);
if (unlikely(rc)) {
rfkill_destroy(pdata->rfkill[WL127X_FM]);
return rc;
}
}
return 0;
}
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 rfkill_rk_probe(struct platform_device *pdev)
{
struct rfkill_rk_data *rfkill;
struct rfkill_rk_platform_data *pdata = pdev->dev.platform_data;
int ret = 0;
DBG("Enter %s\n", __func__);
if (!pdata) {
LOG("%s: No platform data specified\n", __func__);
return -EINVAL;
}
pdata->name = (char*)bt_name;
rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL);
if (!rfkill)
return -ENOMEM;
rfkill->pdata = pdata;
g_rfkill = rfkill;
// 申请GPIO以及IRQ
DBG("init gpio\n");
// 对于RK29 BCM4329，它的poweron io与wifi共用，在boad文件中已经request
// 此处不用去申请
#if !WIFI_BT_POWER_TOGGLE
ret = rfkill_rk_setup_gpio(&pdata->poweron_gpio, IOMUX_FGPIO, pdata->name, "poweron");
if (ret) goto fail_alloc;
#endif
ret = rfkill_rk_setup_gpio(&pdata->reset_gpio, IOMUX_FGPIO, pdata->name, "reset");
if (ret) goto fail_poweron;
ret = rfkill_rk_setup_gpio(&pdata->wake_gpio, IOMUX_FGPIO, pdata->name, "wake");
if (ret) goto fail_reset;
ret = rfkill_rk_setup_wake_irq(rfkill);
if (ret) goto fail_wake;
ret = rfkill_rk_setup_gpio(&(pdata->rts_gpio), IOMUX_FNORMAL, rfkill->pdata->name, "rts");
if (ret) goto fail_wake_host_irq;
// 创建并注册RFKILL设备
DBG("setup rfkill\n");
rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type,
&rfkill_rk_ops, rfkill);
if (!rfkill->rfkill_dev)
goto fail_rts;
// cmy: 设置rfkill初始状态为blocked，在注册时不会调用 set_blocked函数
rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false);
ret = rfkill_register(rfkill->rfkill_dev);
if (ret < 0)
goto fail_rfkill;
wake_lock_init(&(rfkill->bt_irq_wl), WAKE_LOCK_SUSPEND, "rfkill_rk_irq_wl");
INIT_DELAYED_WORK(&rfkill->bt_sleep_delay_work, rfkill_rk_delay_sleep_bt);
// cmy: 设置蓝牙电源的状态为 blocked
rfkill_rk_set_power(rfkill, BT_BLOCKED);
platform_set_drvdata(pdev, rfkill);
LOG("%s device registered.\n", pdata->name);
return 0;
fail_rfkill:
rfkill_destroy(rfkill->rfkill_dev);
fail_rts:
if (gpio_is_valid(pdata->rts_gpio.io))
gpio_free(pdata->rts_gpio.io);
fail_wake_host_irq:
if (gpio_is_valid(pdata->wake_host_irq.gpio.io)){
free_irq(pdata->wake_host_irq.irq, rfkill);
gpio_free(pdata->wake_host_irq.gpio.io);
}
fail_wake:
if (gpio_is_valid(pdata->wake_gpio.io))
gpio_free(pdata->wake_gpio.io);
fail_reset:
if (gpio_is_valid(pdata->reset_gpio.io))
gpio_free(pdata->reset_gpio.io);
fail_poweron:
#if !WIFI_BT_POWER_TOGGLE
if (gpio_is_valid(pdata->poweron_gpio.io))
gpio_free(pdata->poweron_gpio.io);
#endif
fail_alloc:
kfree(rfkill);
g_rfkill = NULL;
return ret;
}
static int rfkill_rk_probe(struct platform_device *pdev)
{
struct rfkill_rk_data *rfkill;
struct rfkill_rk_platform_data *pdata = pdev->dev.platform_data;
int ret = 0;
struct proc_dir_entry *ent;
DBG("Enter %s\n", __func__);
if (!pdata) {
LOG("%s: No platform data specified\n", __func__);
return -EINVAL;
}
pdata->name = (char*)bt_name;
rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL);
if (!rfkill)
return -ENOMEM;
rfkill->pdata = pdata;
g_rfkill = rfkill;
bluetooth_dir = proc_mkdir("bluetooth", NULL);
if (bluetooth_dir == NULL) {
LOG("Unable to create /proc/bluetooth directory");
return -ENOMEM;
}
sleep_dir = proc_mkdir("sleep", bluetooth_dir);
if (sleep_dir == NULL) {
LOG("Unable to create /proc/%s directory", PROC_DIR);
return -ENOMEM;
}
/* read/write proc entries */
ent = create_proc_entry("lpm", 0, sleep_dir);
if (ent == NULL) {
LOG("Unable to create /proc/%s/lpm entry", PROC_DIR);
ret = -ENOMEM;
goto fail_alloc;
}
ent->read_proc = bluesleep_read_proc_lpm;
ent->write_proc = bluesleep_write_proc_lpm;
/* read/write proc entries */
ent = create_proc_entry("btwrite", 0, sleep_dir);
if (ent == NULL) {
LOG("Unable to create /proc/%s/btwrite entry", PROC_DIR);
ret = -ENOMEM;
goto fail_alloc;
}
ent->read_proc = bluesleep_read_proc_btwrite;
ent->write_proc = bluesleep_write_proc_btwrite;
// 申请GPIO以及IRQ
DBG("init gpio\n");
// 对于RK29 BCM4329，它的poweron io与wifi共用，在boad文件中已经request
// 此处不用去申请
#if !WIFI_BT_POWER_TOGGLE
ret = rfkill_rk_setup_gpio(&pdata->poweron_gpio, IOMUX_FGPIO, pdata->name, "poweron");
if (ret) goto fail_alloc;
#endif
ret = rfkill_rk_setup_gpio(&pdata->reset_gpio, IOMUX_FGPIO, pdata->name, "reset");
if (ret) goto fail_poweron;
ret = rfkill_rk_setup_gpio(&pdata->wake_gpio, IOMUX_FGPIO, pdata->name, "wake");
if (ret) goto fail_reset;
ret = rfkill_rk_setup_wake_irq(rfkill);
if (ret) goto fail_wake;
ret = rfkill_rk_setup_gpio(&pdata->rts_gpio, IOMUX_FMUX, rfkill->pdata->name, "rts");
if (ret) goto fail_wake_host_irq;
// 创建并注册RFKILL设备
DBG("setup rfkill\n");
rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type,
&rfkill_rk_ops, rfkill);
if (!rfkill->rfkill_dev)
goto fail_rts;
// cmy: 设置rfkill初始状态为blocked，在注册时不会调用 set_blocked函数
rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false);
ret = rfkill_register(rfkill->rfkill_dev);
if (ret < 0)
goto fail_rfkill;
wake_lock_init(&(rfkill->bt_irq_wl), WAKE_LOCK_SUSPEND, "rfkill_rk_irq_wl");
INIT_DELAYED_WORK(&rfkill->bt_sleep_delay_work, rfkill_rk_delay_sleep_bt);
// cmy: 设置蓝牙电源的状态为 blocked
rfkill_rk_set_power(rfkill, BT_BLOCKED);
platform_set_drvdata(pdev, rfkill);
LOG("%s device registered.\n", pdata->name);
return 0;
fail_rfkill:
rfkill_destroy(rfkill->rfkill_dev);
fail_rts:
if (gpio_is_valid(pdata->rts_gpio.io))
gpio_free(pdata->rts_gpio.io);
fail_wake_host_irq:
if (gpio_is_valid(pdata->wake_host_irq.gpio.io)){
free_irq(pdata->wake_host_irq.irq, rfkill);
gpio_free(pdata->wake_host_irq.gpio.io);
}
fail_wake:
if (gpio_is_valid(pdata->wake_gpio.io))
gpio_free(pdata->wake_gpio.io);
fail_reset:
if (gpio_is_valid(pdata->reset_gpio.io))
gpio_free(pdata->reset_gpio.io);
fail_poweron:
#if !WIFI_BT_POWER_TOGGLE
if (gpio_is_valid(pdata->poweron_gpio.io))
gpio_free(pdata->poweron_gpio.io);
#endif
fail_alloc:
kfree(rfkill);
g_rfkill = NULL;
remove_proc_entry("btwrite", sleep_dir);
remove_proc_entry("lpm", sleep_dir);
return ret;
}
static int bluedroid_pm_probe(struct platform_device *pdev)
{
static struct bluedroid_pm_data *bluedroid_pm;
struct rfkill *rfkill;
struct resource *res;
int ret;
bool enable = false; /* off */
bool default_sw_block_state;
bluedroid_pm = kzalloc(sizeof(*bluedroid_pm), GFP_KERNEL);
if (!bluedroid_pm)
return -ENOMEM;
bluedroid_pm->vdd_3v3 = regulator_get(&pdev->dev, "vdd_bt_3v3");
if (IS_ERR_OR_NULL(bluedroid_pm->vdd_3v3)) {
pr_warn("%s: regulator vdd_bt_3v3 not available\n", __func__);
bluedroid_pm->vdd_3v3 = NULL;
}
bluedroid_pm->vdd_1v8 = regulator_get(&pdev->dev, "vddio_bt_1v8");
if (IS_ERR_OR_NULL(bluedroid_pm->vdd_1v8)) {
pr_warn("%s: regulator vddio_bt_1v8 not available\n", __func__);
bluedroid_pm->vdd_1v8 = NULL;
}
res = platform_get_resource_byname(pdev, IORESOURCE_IO, "reset_gpio");
if (res) {
bluedroid_pm->gpio_reset = res->start;
ret = gpio_request(bluedroid_pm->gpio_reset, "reset_gpio");
if (ret) {
pr_err("%s: Failed to get reset gpio\n", __func__);
goto free_res;
}
gpio_direction_output(bluedroid_pm->gpio_reset, enable);
} else {
pr_debug("%s: Reset gpio not registered.\n", __func__);
bluedroid_pm->gpio_reset = 0;
}
res = platform_get_resource_byname(pdev, IORESOURCE_IO,
"shutdown_gpio");
if (res) {
bluedroid_pm->gpio_shutdown = res->start;
ret = gpio_request(bluedroid_pm->gpio_shutdown,
"shutdown_gpio");
if (ret) {
pr_err("%s: Failed to get shutdown gpio\n", __func__);
goto free_res;
}
gpio_direction_output(bluedroid_pm->gpio_shutdown, enable);
} else {
pr_debug("%s: shutdown gpio not registered\n", __func__);
bluedroid_pm->gpio_shutdown = 0;
}
/*
* make sure at-least one of the GPIO or regulators avaiable to
* register with rfkill is defined
*/
if (bluedroid_pm->gpio_reset || bluedroid_pm->gpio_shutdown ||
bluedroid_pm->vdd_1v8 || bluedroid_pm->vdd_3v3) {
rfkill = rfkill_alloc(pdev->name, &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &bluedroid_pm_rfkill_ops,
bluedroid_pm);
if (unlikely(!rfkill))
goto free_res;
default_sw_block_state = !enable;
rfkill_set_states(rfkill, default_sw_block_state, false);
ret = rfkill_register(rfkill);
if (unlikely(ret)) {
rfkill_destroy(rfkill);
kfree(rfkill);
goto free_res;
}
bluedroid_pm->rfkill = rfkill;
}
res = platform_get_resource_byname(pdev, IORESOURCE_IO,
"gpio_host_wake");
if (res) {
bluedroid_pm->host_wake = res->start;
ret = gpio_request(bluedroid_pm->host_wake, "bt_host_wake");
if (ret) {
pr_err("%s: Failed to get host_wake gpio\n", __func__);
goto free_res;
}
/* configure host_wake as input */
gpio_direction_input(bluedroid_pm->host_wake);
} else {
pr_debug("%s: gpio_host_wake not registered\n", __func__);
bluedroid_pm->host_wake = 0;
}
res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "host_wake");
if (res) {
pr_err("%s : found host_wake irq\n", __func__);
bluedroid_pm->host_wake_irq = res->start;
ret = request_irq(bluedroid_pm->host_wake_irq,
bluedroid_pm_hostwake_isr,
IRQF_DISABLED | IRQF_TRIGGER_RISING,
"bluetooth hostwake", bluedroid_pm);
if (ret) {
pr_err("%s: Failed to get host_wake irq\n", __func__);
goto free_res;
}
} else {
pr_debug("%s: host_wake not registered\n", __func__);
bluedroid_pm->host_wake_irq = 0;
}
res = platform_get_resource_byname(pdev, IORESOURCE_IO,
"gpio_ext_wake");
if (res) {
bluedroid_pm->ext_wake = res->start;
ret = gpio_request(bluedroid_pm->ext_wake, "bt_ext_wake");
if (ret) {
pr_err("%s: Failed to get ext_wake gpio\n", __func__);
goto free_res;
}
/* configure ext_wake as output mode*/
gpio_direction_output(bluedroid_pm->ext_wake, 1);
if (create_bt_proc_interface(bluedroid_pm)) {
pr_err("%s: Failed to create proc interface", __func__);
goto free_res;
}
} else {
pr_debug("%s: gpio_ext_wake not registered\n", __func__);
bluedroid_pm->ext_wake = 0;
}
platform_set_drvdata(pdev, bluedroid_pm);
pr_debug("RFKILL BT driver successfully registered");
return 0;
free_res:
if (bluedroid_pm->vdd_3v3)
regulator_put(bluedroid_pm->vdd_3v3);
if (bluedroid_pm->vdd_1v8)
regulator_put(bluedroid_pm->vdd_1v8);
if (bluedroid_pm->gpio_shutdown)
gpio_free(bluedroid_pm->gpio_shutdown);
if (bluedroid_pm->gpio_reset)
gpio_free(bluedroid_pm->gpio_reset);
if (bluedroid_pm->ext_wake)
gpio_free(bluedroid_pm->ext_wake);
if (bluedroid_pm->host_wake)
gpio_free(bluedroid_pm->host_wake);
if (bluedroid_pm->rfkill) {
rfkill_unregister(bluedroid_pm->rfkill);
rfkill_destroy(bluedroid_pm->rfkill);
kfree(bluedroid_pm->rfkill);
}
kfree(bluedroid_pm);
return -ENODEV;
}
static int bcm4329_rfkill_probe(struct platform_device *pdev)
{
struct rfkill *bt_rfkill;
struct resource *res;
int ret;
bool enable = false; /* off */
bool default_sw_block_state;
bcm4329_rfkill = kzalloc(sizeof(*bcm4329_rfkill), GFP_KERNEL);
if (!bcm4329_rfkill)
return -ENOMEM;
/**
bcm4329_rfkill->bt_32k_clk = clk_get(&pdev->dev, "bcm4329_32k_clk");
if (IS_ERR(bcm4329_rfkill->bt_32k_clk)) {
pr_warn("%s: can't find bcm4329_32k_clk.\
assuming 32k clock to chip\n", __func__);
bcm4329_rfkill->bt_32k_clk = NULL;
}
**/
res = platform_get_resource_byname(pdev, IORESOURCE_IO,
"bcm4329_nreset_gpio");
if (res) {
bcm4329_rfkill->gpio_reset = res->start;
ret = gpio_request(bcm4329_rfkill->gpio_reset,
"bcm4329_nreset_gpio");
} else {
pr_warn("%s : can't find reset gpio. "
"reset gpio may not be defined for "
"this platform \n", __func__);
bcm4329_rfkill->gpio_reset = 0;
}
res = platform_get_resource_byname(pdev, IORESOURCE_IO,
"bcm4329_nshutdown_gpio");
if (res) {
bcm4329_rfkill->gpio_shutdown = res->start;
ret = gpio_request(bcm4329_rfkill->gpio_shutdown,
"bcm4329_nshutdown_gpio");
} else {
pr_warn("%s : can't find shutdown gpio "
"shutdown gpio may not be defined for "
"this platform \n", __func__);
bcm4329_rfkill->gpio_shutdown = 0;
}
/* make sure at-least one of the GPIO is defined */
if (!bcm4329_rfkill->gpio_reset && !bcm4329_rfkill->gpio_shutdown)
goto free_bcm_res;
/**
if (bcm4329_rfkill->bt_32k_clk && enable)
clk_enable(bcm4329_rfkill->bt_32k_clk);
**/
if (bcm4329_rfkill->gpio_shutdown)
gpio_direction_output(bcm4329_rfkill->gpio_shutdown, enable);
if (bcm4329_rfkill->gpio_reset)
gpio_direction_output(bcm4329_rfkill->gpio_reset, enable);
bt_rfkill = rfkill_alloc("bcm4329 Bluetooth", &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &bcm4329_bt_rfkill_ops,
NULL);
if (unlikely(!bt_rfkill))
goto free_bcm_res;
default_sw_block_state = !enable;
rfkill_set_states(bt_rfkill, default_sw_block_state, false);
ret = rfkill_register(bt_rfkill);
if (unlikely(ret)) {
rfkill_destroy(bt_rfkill);
goto free_bcm_res;
}
return 0;
free_bcm_res:
if (bcm4329_rfkill->gpio_shutdown)
gpio_free(bcm4329_rfkill->gpio_shutdown);
if (bcm4329_rfkill->gpio_reset)
gpio_free(bcm4329_rfkill->gpio_reset);
/**
if (bcm4329_rfkill->bt_32k_clk && enable)
clk_disable(bcm4329_rfkill->bt_32k_clk);
if (bcm4329_rfkill->bt_32k_clk)
clk_put(bcm4329_rfkill->bt_32k_clk);
**/
kfree(bcm4329_rfkill);
return -ENODEV;
}
static int __devinit bcm4329_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true;
DBG("Enter::%s,line=%d\n",__FUNCTION__,__LINE__);
/* default to bluetooth off */
bcm4329_set_block(NULL, default_state); /* blocked -> bt off */
gBtCtrl.bt_rfk = rfkill_alloc(bt_name,
NULL,
RFKILL_TYPE_BLUETOOTH,
&bcm4329_rfk_ops,
NULL);
if (!gBtCtrl.bt_rfk)
{
printk("fail to rfkill_allocate************\n");
return -ENOMEM;
}
rfkill_set_states(gBtCtrl.bt_rfk, default_state, false);
rc = rfkill_register(gBtCtrl.bt_rfk);
if (rc)
{
printk("failed to rfkill_register,rc=0x%x\n",rc);
rfkill_destroy(gBtCtrl.bt_rfk);
}
gpio_request(BT_GPIO_POWER, NULL);
gpio_request(BT_GPIO_RESET, NULL);
gpio_request(BT_GPIO_WAKE_UP, NULL);
#if BT_WAKE_HOST_SUPPORT
init_timer(&(gBtCtrl.tl));
gBtCtrl.tl.expires = jiffies + BT_WAKE_LOCK_TIMEOUT*HZ;
gBtCtrl.tl.function = timer_hostSleep;
add_timer(&(gBtCtrl.tl));
gBtCtrl.b_HostWake = false;
wake_lock_init(&(gBtCtrl.bt_wakelock), WAKE_LOCK_SUSPEND, "bt_wake");
rc = gpio_request(BT_GPIO_WAKE_UP_HOST, "bt_wake");
if (rc) {
printk("%s:failed to request RAHO_BT_WAKE_UP_HOST\n",__FUNCTION__);
}
IOMUX_BT_GPIO_WAKE_UP_HOST();
gpio_pull_updown(BT_GPIO_WAKE_UP_HOST,GPIOPullUp);
rc = request_irq(gpio_to_irq(BT_GPIO_WAKE_UP_HOST),bcm4329_wake_host_irq,IRQF_TRIGGER_FALLING,NULL,NULL);
if(rc)
{
printk("%s:failed to request RAHO_BT_WAKE_UP_HOST irq\n",__FUNCTION__);
gpio_free(BT_GPIO_WAKE_UP_HOST);
}
enable_irq_wake(gpio_to_irq(BT_GPIO_WAKE_UP_HOST)); // so RAHO_BT_WAKE_UP_HOST can wake up system
printk(KERN_INFO "bcm4329 module has been initialized,rc=0x%x\n",rc);
#endif
return rc;
}
static int __devinit bcm4329_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
bool default_state = true;
DBG("Enter %s\n",__FUNCTION__);
/* default to bluetooth off */
bcm4329_set_block(NULL, default_state); /* blocked -> bt off */
gBtCtrl.bt_rfk = rfkill_alloc(bt_name,
NULL,
RFKILL_TYPE_BLUETOOTH,
&bcm4329_rfk_ops,
NULL);
if (!gBtCtrl.bt_rfk)
{
LOG("fail to rfkill_allocate\n");
return -ENOMEM;
}
rfkill_set_states(gBtCtrl.bt_rfk, default_state, false);
rc = rfkill_register(gBtCtrl.bt_rfk);
if (rc)
{
LOG("failed to rfkill_register,rc=0x%x\n",rc);
rfkill_destroy(gBtCtrl.bt_rfk);
}
gpio_request(BT_GPIO_POWER, NULL);
gpio_request(BT_GPIO_RESET, NULL);
gpio_request(BT_GPIO_WAKE_UP, NULL);
#ifdef CONFIG_BT_AUTOSLEEP
init_timer(&bt_sleep_tl);
bt_sleep_tl.expires = 0;
bt_sleep_tl.function = bcm4325_sleep;
bt_sleep_tl.data = 1;
add_timer(&bt_sleep_tl);
#endif
#if BT_WAKE_HOST_SUPPORT
init_timer(&(gBtCtrl.tl));
gBtCtrl.tl.expires = 0;
gBtCtrl.tl.function = timer_hostSleep;
add_timer(&(gBtCtrl.tl));
gBtCtrl.b_HostWake = false;
wake_lock_init(&(gBtCtrl.bt_wakelock), WAKE_LOCK_SUSPEND, "bt_wake");
rc = gpio_request(BT_GPIO_WAKE_UP_HOST, "bt_wake");
if (rc) {
LOG("Failed to request BT_WAKE_UP_HOST\n");
}
IOMUX_BT_GPIO_WAKE_UP_HOST();
gpio_pull_updown(BT_GPIO_WAKE_UP_HOST,GPIOPullUp);
#endif
LOG("bcm4329 module has been initialized,rc=0x%x\n",rc);
return rc;
}
static int tcc_bluetooth_probe(struct platform_device *pdev)
{
int rc = 0;
int ret = 0;
printk("[## BT ##] tcc_bluetooth_probe\n");
if( machine_is_tcc8800()|| machine_is_tcc8920()) { // #elif defined (CONFIG_MACH_TCC9300)
//gpio_set_value(TCC_GPEXT1(7), 0); /* BT-ON Disable */
gpio_request(TCC_GPEXT3(2), "bt_wake");
gpio_request(TCC_GPEXT2(4), "bt_reset");
gpio_direction_output(TCC_GPEXT3(2), 0); // output
gpio_direction_output(TCC_GPEXT2(4), 0);
#if defined(CONFIG_TCC_CSR_BC0406_MODULE_SUPPORT) && defined(CONFIG_TCC_CSR_HOST_WAKE_UP)
tcc_gpio_config(TCC_GPB(31), GPIO_FN(0));
gpio_request(TCC_GPEXT3(3), "bt_hwake");
gpio_direction_input(TCC_GPEXT3(3));
#endif // for CSR Bluetooth host wake up
}
else if(machine_is_m801_88() || machine_is_m803())
{
#if defined(CONFIG_TCC_RDA_587X_MODULE_SUPPORT)
gpio_request(TCC_GPA(13), "LDO_ON");
tcc_gpio_config(TCC_GPA(13), GPIO_FN(0));
gpio_direction_output(TCC_GPA(13), 0);
#else
gpio_request(TCC_GPA(13), "bt_reset");
gpio_request(TCC_GPB(22), "BT WAKE");
gpio_direction_output(TCC_GPA(13), 0); // output
gpio_direction_output(TCC_GPB(22), 0); // output
#endif
}
else if(machine_is_tcc8800st())
{
gpio_request(TCC_GPC(31), "bt_power");
gpio_request(TCC_GPD(12), "bt_reset");
gpio_direction_output(TCC_GPC(31), 0); // output
gpio_direction_output(TCC_GPD(12), 0); // output
}
/*
rc = gpio_request(BT_RESET_GPIO, "bcm4330_nreset_gpip");
if (unlikely(rc)) {
return rc;
}
rc = gpio_request(BT_REG_GPIO, "bcm4330_nshutdown_gpio");
if (unlikely(rc)) {
gpio_free(BT_RESET_GPIO);
return rc;
}
*/
bt_rfkill = rfkill_alloc("Telechips Bluetooth", &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &tcc_bt_rfkill_ops,
NULL);
if (unlikely(!bt_rfkill)) {
//gpio_free(BT_RESET_GPIO);
//gpio_free(BT_REG_GPIO);
printk("[## BT ##] rfkill_alloc failed \n");
return -ENOMEM;
}
rc = rfkill_register(bt_rfkill);
if (unlikely(rc)) {
printk("[## BT ##] rfkill_register failed \n");
rfkill_destroy(bt_rfkill);
//gpio_free(BT_RESET_GPIO);
//gpio_free(BT_REG_GPIO);
return -1;
}
printk("[## BT ##] rfkill_register Telechips Bluetooth \n");
rfkill_set_states(bt_rfkill, true, false);
tcc_bt_rfkill_set_power(NULL, true);
#if defined (CONFIG_TCC_BRCM_BCM4330_MODULE_SUPPORT)
ret = bcm_bt_lpm_init(pdev);
if (ret) {
rfkill_unregister(bt_rfkill);
rfkill_destroy(bt_rfkill);
//gpio_free(BT_RESET_GPIO);
//gpio_free(BT_REG_GPIO);
}
#endif
return ret;
}
