int mtk_bt_disable(int bt_fd)
{
LOG_TRC();
if (!glib_handle){
LOG_ERR("mtk bt library is unloaded!\n");
return -1;
}
#ifndef MTK_COMBO_SUPPORT
bt_unregister_timer();
bt_hold_wake_lock(1);
maskEint();
/* wait until thread exist */
pthread_join(eint_thr, NULL);
#endif
bt_restore(bt_fd);
dlclose(glib_handle);
glib_handle = NULL;
#ifndef MTK_COMBO_SUPPORT
bt_set_power(0);
bt_hold_wake_lock(0);
sleep_mode = 0;
#endif
return 0;
}
void EM_BT_deinit(void)
{
TRC();
if (!glib_handle){
ERR("mtk bt library is unloaded!\n");
}
else{
if (bt_fd < 0){
ERR("bt driver fd is invalid!\n");
}
else{
bt_restore(bt_fd);
bt_fd = -1;
}
dlclose(glib_handle);
glib_handle = NULL;
}
#ifndef MTK_COMBO_SUPPORT
bt_set_power(0); /* shutdown BT */
#endif
return;
}
static int bt_rfkill_set_block(void *data, bool blocked)
{
unsigned int ret = 0;
ret = bt_set_power(data, blocked ?
RFKILL_USER_STATE_SOFT_BLOCKED :
RFKILL_USER_STATE_UNBLOCKED);
return ret;
}
static int bt_ctr_remove(struct platform_device *pdev)
{
int irq = gpio_to_irq(BT_HOST_WAKE);
struct bt_gpio_info *bt_info = platform_get_drvdata(pdev);
sysfs_remove_group(&pdev->dev.kobj, &bcm_attribute_group);
free_irq(irq, bt_info);
rfkill_unregister(bt_rfk);
bt_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED);
gpio_free(BT_WAKE);
gpio_free(BT_RESET);
gpio_free(BT_POWER);
return 0;
}
static int __devexit bt_remove(struct platform_device *pdev)
{
struct bt_rfkill_info *bt_info = platform_get_drvdata(pdev);
sysfs_remove_group(&pdev->dev.kobj, &bcm_attribute_group);
free_irq(bt_info->wake_irq, NULL);
rfkill_unregister(bt_info->bt_rfk);
bt_set_power(bt_info, RFKILL_USER_STATE_SOFT_BLOCKED);
if(bt_info->bt_test_mode) {
destroy_workqueue(bt_info->monitor_wqueue);
}
return 0;
}
static ssize_t bt_enable_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
unsigned long enable = simple_strtoul(buf, NULL, 10);
struct bt_gpio_info *bt_info = dev_get_drvdata(dev);
if (enable == 1 || enable == 0){
mutex_lock(&bt_info->bt_lock);
bt_info->bt_enable = enable;
mutex_unlock(&bt_info->bt_lock);
bt_set_power(NULL, enable ? RFKILL_USER_STATE_UNBLOCKED : RFKILL_USER_STATE_SOFT_BLOCKED );
} else
dev_warn(dev, "[BT] input error\n");
return count;
}
static int bt_ctr_probe(struct platform_device *pdev)
{
int irq;
int ret;
struct bt_gpio_info *bt_info;
/* Initialize wake locks */
wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "bt_host_wake");
/* request gpio */
ret = gpio_request(BT_POWER, "GPB");
if (ret < 0) {
pr_err("[BT] Failed to request BT_POWER!\n");
goto err_req_bt_power;
}
ret = gpio_request(BT_RESET, "GPB");
if (ret < 0) {
pr_err("[BT] Failed to request BT_RESET!\n");
goto err_req_bt_reset;
}
/* BT Host Wake IRQ */
irq = gpio_to_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);
/* init rfkill */
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);
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);
/* init low power state*/
ret = bt_lpm_init();
if (ret < 0) {
pr_debug("[BT] set low power failed\n");
goto err_register;
}
/* create sysfs attributes */
bt_info = kzalloc(sizeof(struct bt_gpio_info), GFP_KERNEL);
if(!bt_info) {
pr_debug("[BT] sysfs_create_group failed\n");
goto err_register;
}
bt_info->bt_test_mode =0; //bt in normal mode
bt_info->bt_enable = 0;
bt_info->bt_wake = 0;
mutex_init(&bt_info->bt_lock);
bt_info->dev = &pdev->dev;
platform_set_drvdata(pdev, bt_info);
ret = sysfs_create_group(&pdev->dev.kobj, &bcm_attribute_group);
if (ret < 0) {
pr_debug("[BT] sysfs_create_group failed\n");
goto err_register;
}
device_init_wakeup(&pdev->dev, 1);
/* set init power state*/
bt_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(BT_RESET);
err_req_bt_reset:
gpio_free(BT_POWER);
err_req_bt_power:
return ret;
}
static int __devinit bt_probe(struct platform_device *pdev)
{
int ret = 0;
struct bt_rfkill_info *bt_info;
struct mx_rfkill_pd *pdata = pdev->dev.platform_data;
if (pdata == NULL) {
dev_err(&pdev->dev,"Failed to get platform data\n");
return -ENOENT;
}
bt_info = kzalloc(sizeof(struct bt_rfkill_info), GFP_KERNEL);
if(!bt_info) {
ret = -ENOMEM;
pr_debug("[BT] sysfs_create_group failed\n");
goto err_req_bt_mem;
}
bt_info->name = pdata->name;
bt_info->gpio_bt_power = pdata->bt_power;
bt_info->gpio_bt_reset = pdata->bt_reset;
bt_info->gpio_bt_wake = pdata->bt_wake;
bt_info->gpio_bt_host_wake = pdata->bt_host_wake;
bt_info->gpio_wifi_power = pdata->wifi_power;
bt_info->gpio_wifi_reset = pdata->wifi_reset;
bt_info->dev = &pdev->dev;
/* Initialize wake locks */
wake_lock_init(&bt_info->rfk_lock, WAKE_LOCK_SUSPEND, "bt_host_wake");
/* BT Host Wake IRQ */
bt_info->wake_irq = gpio_to_irq(bt_info->gpio_bt_host_wake);
ret = request_threaded_irq(bt_info->wake_irq, NULL, bt_host_wake_irq_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"bt_host_wake_irq_handler", bt_info);
if (ret < 0) {
pr_err("[BT] Request_irq failed\n");
goto err_req_irq;
}
disable_irq(bt_info->wake_irq);
/* init rfkill */
bt_info->bt_rfk = rfkill_alloc(bt_info->name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&bt_rfkill_ops, bt_info);
if (!bt_info->bt_rfk) {
pr_err("[BT] bt_rfk : rfkill_alloc is failed\n");
ret = -ENOMEM;
goto err_rfkill_alloc;
}
rfkill_init_sw_state(bt_info->bt_rfk, 0);
ret = rfkill_register(bt_info->bt_rfk);
if (ret) {
pr_debug("********ERROR IN REGISTERING THE RFKILL********\n");
goto err_register;
}
rfkill_set_sw_state(bt_info->bt_rfk, 1);
/* init low power state*/
ret = bt_lpm_init(bt_info);
if (ret < 0) {
pr_debug("[BT] set low power failed\n");
goto err_register;
}
bt_info->bt_test_mode =0; //bt in normal mode
bt_info->bt_enable = 0;
bt_info->bt_wake = 0;
mutex_init(&bt_info->bt_lock);
/* create sysfs attributes */
ret = sysfs_create_group(&pdev->dev.kobj, &bcm_attribute_group);
if (ret < 0) {
pr_debug("[BT] sysfs_create_group failed\n");
goto err_register;
}
device_init_wakeup(&pdev->dev, 1);
/* set init power state*/
bt_set_power(bt_info, RFKILL_USER_STATE_SOFT_BLOCKED);
platform_set_drvdata(pdev, bt_info);
g_bt_info = bt_info;
pr_info("[BT] driver loaded!\n");
return ret;
err_register:
rfkill_destroy(bt_info->bt_rfk);
err_rfkill_alloc:
free_irq(bt_info->wake_irq, NULL);
err_req_irq:
wake_lock_destroy(&bt_info->rfk_lock);
kfree(bt_info);
err_req_bt_mem:
return ret;
}
int mtk_bt_enable(int flag, void *func_cb)
{
const char *errstr;
struct uart_t u;
int bt_fd = -1;
LOG_TRC();
#ifndef MTK_COMBO_SUPPORT
bt_hold_wake_lock(1);
/* In case BT is powered on before test */
bt_set_power(0);
if(bt_set_power(1) < 0) {
LOG_ERR("BT power on fails\n");
return -1;
}
#endif
glib_handle = dlopen("libbluetooth_mtk.so", RTLD_LAZY);
if (!glib_handle){
LOG_ERR("%s\n", dlerror());
goto error;
}
dlerror(); /* Clear any existing error */
mtk = dlsym(glib_handle, "mtk");
bt_restore = dlsym(glib_handle, "bt_restore");
write_comm_port = dlsym(glib_handle, "write_comm_port");
read_comm_port = dlsym(glib_handle, "read_comm_port");
bt_send_data = dlsym(glib_handle, "bt_send_data");
bt_receive_data = dlsym(glib_handle, "bt_receive_data");
if ((errstr = dlerror()) != NULL){
LOG_ERR("Can't find function symbols %s\n", errstr);
goto error;
}
#ifndef MTK_COMBO_SUPPORT
u.flags &= ~FLOW_CTL_MASK;
u.flags |= FLOW_CTL_SW;
u.speed = CUST_BT_BAUD_RATE;
#endif
bt_fd = mtk(-1, &u, NULL);
if (bt_fd < 0)
goto error;
LOG_DBG("BT is enabled success\n");
#ifndef MTK_COMBO_SUPPORT
bt_register_timer();
/* Create thread to poll EINT event */
pthread_create(&eint_thr, NULL, bt_eint_monitor, (void*)bt_fd);
sched_yield();
#endif
return bt_fd;
error:
if (glib_handle){
dlclose(glib_handle);
glib_handle = NULL;
}
#ifndef MTK_COMBO_SUPPORT
bt_set_power(0);
bt_hold_wake_lock(0);
#endif
return -1;
}
BOOL EM_BT_init(void)
{
const char *errstr;
struct uart_t u;
TRC();
#ifndef MTK_COMBO_SUPPORT
/* In case BT is powered on before test */
bt_set_power(0);
if(bt_set_power(1) < 0) {
ERR("BT power on fails\n");
return -1;
}
#endif
glib_handle = dlopen("libbluetooth_mtk.so", RTLD_LAZY);
if (!glib_handle){
ERR("%s\n", dlerror());
goto error;
}
dlerror(); /* Clear any existing error */
mtk = dlsym(glib_handle, "mtk");
bt_restore = dlsym(glib_handle, "bt_restore");
bt_send_data = dlsym(glib_handle, "bt_send_data");
bt_receive_data = dlsym(glib_handle, "bt_receive_data");
if ((errstr = dlerror()) != NULL){
ERR("Can't find function symbols %s\n", errstr);
goto error;
}
#ifndef MTK_COMBO_SUPPORT
u.flags &= ~FLOW_CTL_MASK;
u.flags |= FLOW_CTL_SW;
u.speed = CUST_BT_BAUD_RATE;
#endif
bt_fd = mtk(-1, &u, NULL);
if (bt_fd < 0)
goto error;
DBG("BT is enabled success\n");
#ifndef MTK_COMBO_SUPPORT
/*
BT EM driver DONOT handle sleep mode and EINT,
so disable Host and Controller sleep in EM
on standalone chip;
on combo chip, THIS IS NO NEED
*/
BT_DisableSleepMode();
#endif
return TRUE;
error:
if (glib_handle){
dlclose(glib_handle);
glib_handle = NULL;
}
#ifndef MTK_COMBO_SUPPORT
bt_set_power(0);
#endif
return FALSE;
}
