static int __init aries_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_err("********ERROR IN REGISTERING THE bt_rfk********\n");
goto err_register;
}
rfkill_set_sw_state(bt_rfk, 1);
bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED);
#ifdef BT_SLEEP_ENABLE
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_ENABLE
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 __init m8_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");
#if 0
ret = gpio_request(GPIO_WLAN_BT_EN, "GPK");
if (ret < 0) {
printk(KERN_ERR"[BT] Failed to request GPIO_WLAN_BT_EN!\n");//pr_error
goto err_req_gpio_wlan_bt_en;
}
ret = gpio_request(GPIO_BT_nRST, "GPM");
if (ret < 0) {
printk(KERN_ERR"[BT] Failed to request GPIO_BT_nRST!\n");//pr_error
goto err_req_gpio_bt_nrst;
}
#endif
/* BT Host Wake IRQ */
irq = IRQ_WLAN_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) {
printk(KERN_ERR"[BT] bt_rfk : rfkill_alloc is failed\n");//pr_error
ret = -ENOMEM;
goto err_alloc;
}
rfkill_init_sw_state(bt_rfk, 0);
printk("[BT] rfkill_register(bt_rfk)\n");//pr_debug
ret = rfkill_register(bt_rfk);
if (ret) {
printk("********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);
loaded = 1;
return ret;
err_register:
rfkill_destroy(bt_rfk);
err_alloc:
free_irq(irq, NULL);
err_req_irq:
#if 0
gpio_free(GPIO_BT_nRST);
err_req_gpio_bt_nrst:
gpio_free(GPIO_WLAN_BT_EN);
err_req_gpio_wlan_bt_en:
#endif
return ret;
}
static int bcm4334_bluetooth_probe(struct platform_device *pdev)
{
int rc = 0;
int ret;
rc = gpio_request(GPIO_BT_EN, "bcm4334_bten_gpio");
if (unlikely(rc)) {
pr_err("[BT] GPIO_BT_EN request failed.\n");
return rc;
}
rc = gpio_request(gpio_rev(GPIO_BT_WAKE), "bcm4334_btwake_gpio");
if (unlikely(rc)) {
pr_err("[BT] GPIO_BT_WAKE request failed.\n");
gpio_free(GPIO_BT_EN);
return rc;
}
rc = gpio_request(GPIO_BT_HOST_WAKE, "bcm4334_bthostwake_gpio");
if (unlikely(rc)) {
pr_err("[BT] GPIO_BT_HOST_WAKE request failed.\n");
gpio_free(gpio_rev(GPIO_BT_WAKE));
gpio_free(GPIO_BT_EN);
return rc;
}
gpio_direction_input(GPIO_BT_HOST_WAKE);
gpio_direction_output(gpio_rev(GPIO_BT_WAKE), 0);
gpio_direction_output(GPIO_BT_EN, 0);
bt_rfkill = rfkill_alloc("bcm4334 Bluetooth", &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &bcm4334_bt_rfkill_ops,
NULL);
if (unlikely(!bt_rfkill)) {
pr_err("[BT] bt_rfkill alloc failed.\n");
gpio_free(GPIO_BT_HOST_WAKE);
gpio_free(gpio_rev(GPIO_BT_WAKE));
gpio_free(GPIO_BT_EN);
return -ENOMEM;
}
rfkill_init_sw_state(bt_rfkill, 0);
rc = rfkill_register(bt_rfkill);
if (unlikely(rc)) {
pr_err("[BT] bt_rfkill register failed.\n");
rfkill_destroy(bt_rfkill);
gpio_free(GPIO_BT_HOST_WAKE);
gpio_free(gpio_rev(GPIO_BT_WAKE));
gpio_free(GPIO_BT_EN);
return -1;
}
rfkill_set_sw_state(bt_rfkill, true);
#ifdef BT_LPM_ENABLE
ret = bcm_bt_lpm_init(pdev);
if (ret) {
rfkill_unregister(bt_rfkill);
rfkill_destroy(bt_rfkill);
gpio_free(GPIO_BT_HOST_WAKE);
gpio_free(gpio_rev(GPIO_BT_WAKE));
gpio_free(GPIO_BT_EN);
}
#endif
return rc;
}
static int bcm4343_bluetooth_probe(struct platform_device *pdev)
{
int rc = 0;
#ifdef BT_LPM_ENABLE
int ret;
#endif
pr_info("[BT] bcm4343_bluetooth_probe.\n");
bt_gpio.bt_en = of_get_gpio(pdev->dev.of_node, 0);
if (!gpio_is_valid(bt_gpio.bt_en)) {
pr_err("[BT] bt_gpio.bt_en get gpio failed.\n");
return -EINVAL;
}
rc = gpio_request(bt_gpio.bt_en, "bten_gpio");
if (unlikely(rc)) {
pr_err("[BT] bt_gpio.bt_en request failed.\n");
return rc;
}
bt_gpio.bt_wake =of_get_gpio(pdev->dev.of_node, 1);
if (!gpio_is_valid(bt_gpio.bt_wake)) {
pr_err("[BT] bt_gpio.bt_wake get gpio failed.\n");
return -EINVAL;
}
rc = gpio_request(bt_gpio.bt_wake, "btwake_gpio");
if (unlikely(rc)) {
pr_err("[BT] bt_gpio.bt_wake request failed.\n");
gpio_free(bt_gpio.bt_en);
return rc;
}
bt_gpio.bt_hostwake =of_get_gpio(pdev->dev.of_node, 2);
if (!gpio_is_valid(bt_gpio.bt_hostwake)) {
pr_err("[BT] bt_gpio.bt_hostwake get gpio failed.\n");
return -EINVAL;
}
rc = gpio_request(bt_gpio.bt_hostwake,"bthostwake_gpio");
if (unlikely(rc)) {
pr_err("[BT] bt_gpio.bt_hostwake request failed.\n");
gpio_free(bt_gpio.bt_wake);
gpio_free(bt_gpio.bt_en);
return rc;
}
gpio_direction_input(bt_gpio.bt_hostwake);
gpio_direction_output(bt_gpio.bt_wake, 0);
gpio_direction_output(bt_gpio.bt_en, 0);
bt_rfkill = rfkill_alloc("bcm4343 Bluetooth", &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &bcm4343_bt_rfkill_ops,
NULL);
if (unlikely(!bt_rfkill)) {
pr_err("[BT] bt_rfkill alloc failed.\n");
gpio_free(bt_gpio.bt_hostwake);
gpio_free(bt_gpio.bt_wake);
gpio_free(bt_gpio.bt_en);
return -ENOMEM;
}
rfkill_init_sw_state(bt_rfkill, 0);
rc = rfkill_register(bt_rfkill);
if (unlikely(rc)) {
pr_err("[BT] bt_rfkill register failed.\n");
rfkill_destroy(bt_rfkill);
gpio_free(bt_gpio.bt_hostwake);
gpio_free(bt_gpio.bt_wake);
gpio_free(bt_gpio.bt_en);
return -1;
}
rfkill_set_sw_state(bt_rfkill, true);
#ifdef BT_LPM_ENABLE
ret = bcm_bt_lpm_init(pdev);
if (ret) {
rfkill_unregister(bt_rfkill);
rfkill_destroy(bt_rfkill);
gpio_free(bt_gpio.bt_hostwake);
gpio_free(bt_gpio.bt_wake);
gpio_free(bt_gpio.bt_en);
}
#endif
pr_info("[BT] bcm4343_bluetooth_probe End \n");
return rc;
}
