static int rfkill_init(struct platform_device *sdev)
{
/* add rfkill */
int retval;
/* keep the hardware wireless state */
get_wireless_state_ec_standard();
rfk_bluetooth = rfkill_alloc("msi-bluetooth", &sdev->dev,
RFKILL_TYPE_BLUETOOTH,
&rfkill_bluetooth_ops, NULL);
if (!rfk_bluetooth) {
retval = -ENOMEM;
goto err_bluetooth;
}
retval = rfkill_register(rfk_bluetooth);
if (retval)
goto err_bluetooth;
rfk_wlan = rfkill_alloc("msi-wlan", &sdev->dev, RFKILL_TYPE_WLAN,
&rfkill_wlan_ops, NULL);
if (!rfk_wlan) {
retval = -ENOMEM;
goto err_wlan;
}
retval = rfkill_register(rfk_wlan);
if (retval)
goto err_wlan;
if (threeg_exists) {
rfk_threeg = rfkill_alloc("msi-threeg", &sdev->dev,
RFKILL_TYPE_WWAN, &rfkill_threeg_ops, NULL);
if (!rfk_threeg) {
retval = -ENOMEM;
goto err_threeg;
}
retval = rfkill_register(rfk_threeg);
if (retval)
goto err_threeg;
}
/* schedule to run rfkill state initial */
if (quirks->ec_delay) {
schedule_delayed_work(&msi_rfkill_init,
round_jiffies_relative(1 * HZ));
} else
schedule_work(&msi_rfkill_work);
return 0;
err_threeg:
rfkill_destroy(rfk_threeg);
if (rfk_wlan)
rfkill_unregister(rfk_wlan);
err_wlan:
rfkill_destroy(rfk_wlan);
if (rfk_bluetooth)
rfkill_unregister(rfk_bluetooth);
err_bluetooth:
rfkill_destroy(rfk_bluetooth);
return retval;
}
static int bcm2076_bluetooth_probe(struct platform_device *pdev)
{
int rc = 0;
int ret = 0;
pr_debug( "%s: TOP\n",__FUNCTION__);
#if 1
pr_debug( "%s: skipping gpio_request(BT_RESET and BT_REG_GPIO). was done in boardconfig\n",__FUNCTION__);
#else
rc = gpio_request(BT_RESET_GPIO, "bcm2076");
if (unlikely(rc)) {
return rc;
}
rc = gpio_request(BT_REG_GPIO, "bcm2076");
if (unlikely(rc)) {
gpio_free(BT_RESET_GPIO);
return rc;
}
#endif //att already done in board config
#if 1
pr_debug( "%s: clk32kaudio always on. No need to call regulator_get()\n",__FUNCTION__);
#else
clk32kaudio_reg = regulator_get(0, "clk32kaudio");
if (IS_ERR(clk32kaudio_reg)) {
pr_err("clk32kaudio reg not found!\n");
clk32kaudio_reg = NULL;
}
#endif
#if 1
pr_debug( "%s skipping powering on BT_REG_GPIO, already done in board config\n",__FUNCTION__);
#else
gpio_direction_output(BT_REG_GPIO, 1);
gpio_direction_output(BT_RESET_GPIO, 1);
#endif
bt_rfkill = rfkill_alloc("bcm2076 Bluetooth", &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &bcm2076_bt_rfkill_ops,
NULL);
if (unlikely(!bt_rfkill)) {
pr_debug( "%s: rfkill_alloc('bcm2076_Bluetooth') failed, bt_rfkill=%d\n",__FUNCTION__,(int)bt_rfkill);
return -ENOMEM;
}
rc = rfkill_register(bt_rfkill);
if (unlikely(rc)) {
pr_debug( "%s: rfkill_register(bt_rfkill) failed, rc=%d\n",__FUNCTION__,rc);
rfkill_destroy(bt_rfkill);
return -1;
}
rfkill_set_states(bt_rfkill, true, false);
bcm2076_bt_rfkill_set_power(NULL, true);
ret = bcm_bt_lpm_init(pdev);
if (ret) {
pr_debug( "%s: bcm_bt_lpm_init failed, ret=%d\n",__FUNCTION__,ret);
rfkill_unregister(bt_rfkill);
rfkill_destroy(bt_rfkill);
}
pr_debug( "%s: END ret = %d\n",__FUNCTION__,ret);
return ret;
}
static int __init crespo_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_BT_EN, "GPB");
if (ret < 0) {
pr_err("[BT] Failed to request GPIO_BT_EN!\n");
goto err_req_gpio_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,
"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
return ret;
#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_BT_EN);
err_req_gpio_bt_en:
return ret;
}
static int pico_rfkill_remove(struct platform_device *dev)
{
rfkill_unregister(bt_rfk);
rfkill_destroy(bt_rfk);
return 0;
}
/* ----- Initialization/removal -------------------------------------------- */
static int __init shuttle_wlan_probe(struct platform_device *pdev)
{
/* default-on */
const int default_blocked_state = 0;
struct rfkill *rfkill;
struct regulator *regulator[2];
struct shuttle_pm_wlan_data *wlan_data;
int ret;
wlan_data = kzalloc(sizeof(*wlan_data), GFP_KERNEL);
if (!wlan_data) {
dev_err(&pdev->dev, "no memory for context\n");
return -ENOMEM;
}
dev_set_drvdata(&pdev->dev, wlan_data);
regulator[0] = regulator_get(&pdev->dev, "vddio_wlan"); /* 1.8v */
if (IS_ERR(regulator[0])) {
dev_err(&pdev->dev, "unable to get regulator 0 (1.8v)\n");
kfree(wlan_data);
dev_set_drvdata(&pdev->dev, NULL);
return -ENODEV;
}
wlan_data->regulator[0] = regulator[0];
regulator[1] = regulator_get(&pdev->dev, "vcore_wifi"); /* 1.2v */
if (IS_ERR(regulator[1])) {
dev_err(&pdev->dev, "unable to get regulator 1 (1.2v)\n");
regulator_put(regulator[0]);
kfree(wlan_data);
dev_set_drvdata(&pdev->dev, NULL);
return -ENODEV;
}
wlan_data->regulator[1] = regulator[1];
/* Init io pins */
gpio_request(SHUTTLE_WLAN_POWER, "wlan_power");
gpio_direction_output(SHUTTLE_WLAN_POWER, 0);
gpio_request(SHUTTLE_WLAN_RESET, "wlan_reset");
gpio_direction_output(SHUTTLE_WLAN_RESET, 0);
rfkill = rfkill_alloc(pdev->name, &pdev->dev, RFKILL_TYPE_WLAN,
&shuttle_wlan_rfkill_ops, &pdev->dev);
if (!rfkill) {
dev_err(&pdev->dev, "Failed to allocate rfkill\n");
regulator_put(regulator[1]);
regulator_put(regulator[0]);
kfree(wlan_data);
dev_set_drvdata(&pdev->dev, NULL);
return -ENOMEM;
}
wlan_data->rfkill = rfkill;
/* Tell the SDIO stack the card is not there... otherwise, it could
be using a non powered card not properly initialized */
shuttle_wlan_set_carddetect(&pdev->dev,0);
/* Set the default state */
rfkill_init_sw_state(rfkill, default_blocked_state);
shuttle_wlan_set_carddetect(&pdev->dev, !default_blocked_state);
ret = rfkill_register(rfkill);
if (ret) {
dev_err(&pdev->dev, "Failed to register rfkill\n");
rfkill_destroy(rfkill);
regulator_put(regulator[1]);
regulator_put(regulator[0]);
kfree(wlan_data);
dev_set_drvdata(&pdev->dev, NULL);
return ret;
}
dev_info(&pdev->dev, "WLAN RFKill driver loaded\n");
return sysfs_create_group(&pdev->dev.kobj, &shuttle_wlan_attr_group);
}
static int __init smba1002_bt_probe(struct platform_device *pdev)
{
struct rfkill *rfkill;
struct regulator *regulator;
struct clk *clk;
struct smba1002_pm_bt_data *bt_data;
int ret;
dev_dbg(&pdev->dev, "starting\n");
bt_data = kzalloc(sizeof(*bt_data), GFP_KERNEL);
if (!bt_data) {
dev_err(&pdev->dev, "no memory for context\n");
return -ENOMEM;
}
dev_set_drvdata(&pdev->dev, bt_data);
regulator = regulator_get(&pdev->dev, "vddhostif_bt");
if (IS_ERR(regulator)) {
dev_err(&pdev->dev, "Failed to get regulator\n");
ret = -ENODEV;
goto err4;
}
bt_data->regulator = regulator;
clk = clk_get(&pdev->dev, "blink");
if (IS_ERR(clk)) {
dev_err(&pdev->dev, "Failed to get clock\n");
ret = -ENODEV;
goto err3;
}
bt_data->clk = clk;
/* Init io pins */
gpio_request(SMBA1002_BT_RESET, "bluetooth_reset");
gpio_direction_output(SMBA1002_BT_RESET, 0);
rfkill = rfkill_alloc(pdev->name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&smba1002_bt_rfkill_ops, &pdev->dev);
if (!rfkill) {
dev_err(&pdev->dev, "Failed to allocate rfkill\n");
ret = -ENOMEM;
goto err2;
}
bt_data->rfkill = rfkill;
/* Disable bluetooth */
rfkill_init_sw_state(rfkill, 0);
ret = rfkill_register(rfkill);
if (ret) {
dev_err(&pdev->dev, "Failed to register rfkill\n");
goto err1;
}
dev_info(&pdev->dev, "Bluetooth RFKill driver registered\n");
return sysfs_create_group(&pdev->dev.kobj, &smba1002_bt_attr_group);
err1:
rfkill_destroy(rfkill);
bt_data->rfkill = NULL;
err2:
clk_put(clk);
bt_data->clk = NULL;
err3:
regulator_put(regulator);
bt_data->regulator = NULL;
err4:
kfree(bt_data);
dev_set_drvdata(&pdev->dev, NULL);
return ret;
}
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->pwr_ctl >= 0) {
bool default_blocked = true; /* power off */
pdata->rfkill[WL127X_PWR_CTL] = rfkill_alloc(
"wl127x Power_Control", &pdev->dev,
RFKILL_TYPE_PWR_CTL, &wl127x_pwr_ctl_rfkill_ops,
(void *)pdata);
if (unlikely(!pdata->rfkill[WL127X_PWR_CTL]))
return -ENOMEM;
rfkill_set_states(pdata->rfkill[WL127X_PWR_CTL],
default_blocked, false);
rc = rfkill_register(pdata->rfkill[WL127X_PWR_CTL]);
if (unlikely(rc)) {
rfkill_destroy(pdata->rfkill[WL127X_PWR_CTL]);
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 __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 rfkill_gpio_probe(struct platform_device *pdev)
{
struct rfkill_gpio_data *rfkill;
struct rfkill_gpio_platform_data *pdata = pdev->dev.platform_data;
int ret = 0;
int len = 0;
if (!pdata) {
pr_warn("%s: No platform data specified\n", __func__);
return -EINVAL;
}
/*
*/
if (!pdata->name || (!gpio_is_valid(pdata->reset_gpio) &&
!gpio_is_valid(pdata->shutdown_gpio))) {
pr_warn("%s: invalid platform data\n", __func__);
return -EINVAL;
}
rfkill = kzalloc(sizeof(*rfkill), GFP_KERNEL);
if (!rfkill)
return -ENOMEM;
if (pdata->gpio_runtime_setup) {
ret = pdata->gpio_runtime_setup(pdev);
if (ret) {
pr_warn("%s: can't set up gpio\n", __func__);
goto fail_alloc;
}
}
rfkill->pdata = pdata;
len = strlen(pdata->name);
rfkill->reset_name = kzalloc(len + 7, GFP_KERNEL);
if (!rfkill->reset_name) {
ret = -ENOMEM;
goto fail_alloc;
}
rfkill->shutdown_name = kzalloc(len + 10, GFP_KERNEL);
if (!rfkill->shutdown_name) {
ret = -ENOMEM;
goto fail_reset_name;
}
snprintf(rfkill->reset_name, len + 6 , "%s_reset", pdata->name);
snprintf(rfkill->shutdown_name, len + 9, "%s_shutdown", pdata->name);
if (pdata->power_clk_name) {
rfkill->pwr_clk = clk_get(&pdev->dev, pdata->power_clk_name);
if (IS_ERR(rfkill->pwr_clk)) {
pr_warn("%s: can't find pwr_clk.\n", __func__);
goto fail_shutdown_name;
}
}
if (gpio_is_valid(pdata->reset_gpio)) {
ret = gpio_request(pdata->reset_gpio, rfkill->reset_name);
if (ret) {
pr_warn("%s: failed to get reset gpio.\n", __func__);
goto fail_clock;
}
}
if (gpio_is_valid(pdata->shutdown_gpio)) {
ret = gpio_request(pdata->shutdown_gpio, rfkill->shutdown_name);
if (ret) {
pr_warn("%s: failed to get shutdown gpio.\n", __func__);
goto fail_reset;
}
}
rfkill->rfkill_dev = rfkill_alloc(pdata->name, &pdev->dev, pdata->type,
&rfkill_gpio_ops, rfkill);
if (!rfkill->rfkill_dev)
goto fail_shutdown;
ret = rfkill_register(rfkill->rfkill_dev);
if (ret < 0)
goto fail_rfkill;
platform_set_drvdata(pdev, rfkill);
dev_info(&pdev->dev, "%s device registered.\n", pdata->name);
return 0;
fail_rfkill:
rfkill_destroy(rfkill->rfkill_dev);
fail_shutdown:
if (gpio_is_valid(pdata->shutdown_gpio))
gpio_free(pdata->shutdown_gpio);
fail_reset:
if (gpio_is_valid(pdata->reset_gpio))
gpio_free(pdata->reset_gpio);
fail_clock:
if (rfkill->pwr_clk)
clk_put(rfkill->pwr_clk);
fail_shutdown_name:
kfree(rfkill->shutdown_name);
fail_reset_name:
kfree(rfkill->reset_name);
fail_alloc:
kfree(rfkill);
return ret;
}
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;
}
static int rfkill_regulator_probe(struct platform_device *pdev)
{
struct rfkill_regulator_platform_data *pdata = pdev->dev.platform_data;
struct rfkill_regulator_data *rfkill_data;
struct regulator *vcc;
struct rfkill *rf_kill;
int ret = 0;
if (pdata == NULL) {
dev_err(&pdev->dev, "no platform data\n");
return -ENODEV;
}
if (pdata->name == NULL || pdata->type == 0) {
dev_err(&pdev->dev, "invalid name or type in platform data\n");
return -EINVAL;
}
vcc = regulator_get_exclusive(&pdev->dev, "vrfkill");
if (IS_ERR(vcc)) {
dev_err(&pdev->dev, "Cannot get vcc for %s\n", pdata->name);
ret = PTR_ERR(vcc);
goto out;
}
rfkill_data = kzalloc(sizeof(*rfkill_data), GFP_KERNEL);
if (rfkill_data == NULL) {
ret = -ENOMEM;
goto err_data_alloc;
}
rf_kill = rfkill_alloc(pdata->name, &pdev->dev,
pdata->type,
&rfkill_regulator_ops, rfkill_data);
if (rf_kill == NULL) {
ret = -ENOMEM;
goto err_rfkill_alloc;
}
if (regulator_is_enabled(vcc)) {
dev_dbg(&pdev->dev, "Regulator already enabled\n");
rfkill_data->reg_enabled = true;
}
rfkill_data->vcc = vcc;
rfkill_data->rf_kill = rf_kill;
ret = rfkill_register(rf_kill);
if (ret) {
dev_err(&pdev->dev, "Cannot register rfkill device\n");
goto err_rfkill_register;
}
platform_set_drvdata(pdev, rfkill_data);
dev_info(&pdev->dev, "%s initialized\n", pdata->name);
return 0;
err_rfkill_register:
rfkill_destroy(rf_kill);
err_rfkill_alloc:
kfree(rfkill_data);
err_data_alloc:
regulator_put(vcc);
out:
return ret;
}
static int lbee9qmb_rfkill_btwake_probe(struct platform_device *pdev)
{
struct lbee9qmb_platform_data *plat = pdev->dev.platform_data;
struct rfkill *rfkill;
int rc;
int irq;
int ret;
int host_wake;
if (!plat) {
dev_err(&pdev->dev, "no platform data\n");
return -ENOSYS;
}
wake_lock_init(&bt_lpm.bt_wake_lock, WAKE_LOCK_SUSPEND,
"bt_wake");
#ifdef BRCM_HOST_WAKE
wake_lock_init(&bt_lpm.host_wake_lock, WAKE_LOCK_SUSPEND,
"host_wake");
bt_lpm.gpio_host_wake=plat->gpio_hostwake;
//spin_lock_init(&bt_lpm.bt_lock);
INIT_WORK(&bt_lpm.host_wake_work, brcm_host_wake_work_func);
#endif
rc = gpio_request(plat->gpio_btwake, "lbee9qmb_reset_btwake");
if (rc < 0) {
dev_err(&pdev->dev, "gpio_request failed\n");
return rc;
}
rfkill = rfkill_alloc("lbee9qmb-rfkill_btwake", &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &lbee9qmb_rfkill_btwake_ops, pdev);
if (!rfkill) {
rc = -ENOMEM;
goto fail_gpio;
}
platform_set_drvdata(pdev, rfkill);
gpio_direction_output(plat->gpio_btwake, 1);
rc = rfkill_register(rfkill);
if (rc < 0)
goto fail_alloc;
#ifdef BRCM_HOST_WAKE
rc = gpio_request(plat->gpio_hostwake, "lbee9qmb_reset_hostwake");
gpio_direction_input(plat->gpio_hostwake);
host_wake=gpio_get_value(bt_lpm.gpio_host_wake);
irq = gpio_to_irq(plat->gpio_hostwake);
bt_lpm.host_wake_irq=irq;
#ifdef BRCM_WAKELOCKTIMEOUT
hrtimer_init(&bt_lpm.check_hostwakeup_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
bt_lpm.check_hostwakeup_delay = ktime_set(5, 0); /* 5 sec */
bt_lpm.check_hostwakeup_timer.function = check_hostwakeup;
set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
ret = request_irq(irq, host_wake_isr, 0,
"bt host_wake", NULL);
#else
ret = request_irq(irq, host_wake_isr, IRQF_TRIGGER_HIGH,
"bt host_wake", NULL);
#endif
printk(KERN_ERR "BRCM_LPM: irq=%d ret=%d HOST_WAKE=%d\n",irq,ret,host_wake);
#endif
return 0;
fail_alloc:
rfkill_destroy(rfkill);
fail_gpio:
gpio_free(plat->gpio_btwake);
return rc;
}
static int __init shuttle_gsm_probe(struct platform_device *pdev)
{
/* default-on */
const int default_blocked_state = 0;
struct rfkill *rfkill;
struct regulator *regulator[2];
struct shuttle_pm_gsm_data *gsm_data;
int ret;
gsm_data = kzalloc(sizeof(*gsm_data), GFP_KERNEL);
if (!gsm_data) {
dev_err(&pdev->dev, "no memory for context\n");
return -ENOMEM;
}
dev_set_drvdata(&pdev->dev, gsm_data);
regulator[0] = regulator_get(&pdev->dev, "avdd_usb_pll");
if (IS_ERR(regulator[0])) {
dev_err(&pdev->dev, "unable to get regulator for usb pll\n");
kfree(gsm_data);
dev_set_drvdata(&pdev->dev, NULL);
return -ENODEV;
}
gsm_data->regulator[0] = regulator[0];
regulator[1] = regulator_get(&pdev->dev, "avdd_usb");
if (IS_ERR(regulator[1])) {
dev_err(&pdev->dev, "unable to get regulator for usb\n");
regulator_put(regulator[0]);
kfree(gsm_data);
dev_set_drvdata(&pdev->dev, NULL);
return -ENODEV;
}
gsm_data->regulator[1] = regulator[1];
/* Init control pins */
shuttle_3g_gps_init();
/* register rfkill interface */
rfkill = rfkill_alloc(pdev->name, &pdev->dev, RFKILL_TYPE_WWAN,
&shuttle_gsm_rfkill_ops, &pdev->dev);
if (!rfkill) {
dev_err(&pdev->dev, "Failed to allocate rfkill\n");
regulator_put(regulator[1]);
regulator_put(regulator[0]);
kfree(gsm_data);
dev_set_drvdata(&pdev->dev, NULL);
return -ENOMEM;
}
gsm_data->rfkill = rfkill;
/* Set the default state */
rfkill_init_sw_state(rfkill, default_blocked_state);
__shuttle_pm_gsm_toggle_radio(&pdev->dev, !default_blocked_state);
ret = rfkill_register(rfkill);
if (ret) {
dev_err(&pdev->dev, "Failed to register rfkill\n");
rfkill_destroy(rfkill);
regulator_put(regulator[1]);
regulator_put(regulator[0]);
kfree(gsm_data);
dev_set_drvdata(&pdev->dev, NULL);
return ret;
}
dev_info(&pdev->dev, "GSM/UMTS RFKill driver loaded\n");
return sysfs_create_group(&pdev->dev.kobj, &shuttle_gsm_attr_group);
}
static int bcm43xx_bluetooth_probe(struct platform_device *pdev)
{
bool default_state = true; /* off */
int ret = 0;
#ifdef LPM_ON
int_handler_enabled = false;
#endif
printk("[Progress][bcm_bt_lpm] Probe starts\n");
#ifdef CONFIG_ACPI
if (ACPI_HANDLE(&pdev->dev)) {
/*
* acpi specific probe
*/
pr_debug("%s for ACPI device %s\n", __func__,
dev_name(&pdev->dev));
if (bcm_bt_lpm_acpi_probe(pdev) < 0)
ret = -EINVAL;
} else
ret = -ENODEV;
#else
ret = bcm43xx_bluetooth_pdata_probe(pdev);
#endif
if (ret < 0) {
pr_err("%s: Cannot register platform data\n", __func__);
goto err_data_probe;
}
ret = gpio_request(bt_lpm.gpio_enable_bt, pdev->name);
if (ret < 0) {
pr_err("%s: Unable to request gpio %d\n", __func__,
bt_lpm.gpio_enable_bt);
goto err_gpio_enable_req;
}
ret = gpio_direction_output(bt_lpm.gpio_enable_bt, 0);
if (ret < 0) {
pr_err("%s: Unable to set int direction for gpio %d\n",
__func__, bt_lpm.gpio_enable_bt);
goto err_gpio_enable_dir;
}
#ifdef LPM_ON
ret = gpio_request(bt_lpm.gpio_host_wake, pdev->name);
if (ret < 0) {
pr_err("%s: Unable to request gpio %d\n",
__func__, bt_lpm.gpio_host_wake);
goto err_gpio_host_wake_req;
}
ret = gpio_direction_input(bt_lpm.gpio_host_wake);
if (ret < 0) {
pr_err("%s: Unable to set direction for gpio %d\n", __func__,
bt_lpm.gpio_host_wake);
goto err_gpio_host_wake_dir;
}
ret = gpio_request(bt_lpm.gpio_wake, pdev->name);
if (ret < 0) {
pr_err("%s: Unable to request gpio %d\n", __func__,
bt_lpm.gpio_wake);
goto err_gpio_wake_req;
}
ret = gpio_direction_output(bt_lpm.gpio_wake, 0);
if (ret < 0) {
pr_err("%s: Unable to set direction for gpio %d\n", __func__,
bt_lpm.gpio_wake);
goto err_gpio_wake_dir;
}
pr_debug("%s: gpio_enable=%d, gpio_wake=%d, gpio_host_wake=%d\n",
__func__,
bt_lpm.gpio_enable_bt,
bt_lpm.gpio_wake,
bt_lpm.gpio_host_wake);
#endif
bt_rfkill = rfkill_alloc("bcm43xx Bluetooth", &pdev->dev,
RFKILL_TYPE_BLUETOOTH, &bcm43xx_bt_rfkill_ops,
NULL);
if (unlikely(!bt_rfkill)) {
ret = -ENOMEM;
goto err_rfkill_alloc;
}
bcm43xx_bt_rfkill_set_power(NULL, default_state);
rfkill_init_sw_state(bt_rfkill, default_state);
ret = rfkill_register(bt_rfkill);
if (unlikely(ret))
goto err_rfkill_register;
#ifdef LPM_ON
ret = bcm_bt_lpm_init(pdev);
if (ret)
goto err_lpm_init;
#endif
printk("[Progress][bcm_bt_lpm] Probe ends\n");
return ret;
err_lpm_init:
rfkill_unregister(bt_rfkill);
err_rfkill_register:
rfkill_destroy(bt_rfkill);
err_rfkill_alloc:
#ifdef LPM_ON
err_gpio_wake_dir:
gpio_free(bt_lpm.gpio_wake);
err_gpio_wake_req:
err_gpio_host_wake_dir:
gpio_free(bt_lpm.gpio_host_wake);
err_gpio_host_wake_req:
#endif
err_gpio_enable_dir:
gpio_free(bt_lpm.gpio_enable_bt);
err_gpio_enable_req:
err_data_probe:
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 __init smba1002_gsm_probe(struct platform_device *pdev)
{
struct rfkill *rfkill;
struct regulator *regulator[2];
struct smba1002_pm_gsm_data *gsm_data;
int ret;
gsm_data = kzalloc(sizeof(*gsm_data), GFP_KERNEL);
if (!gsm_data) {
dev_err(&pdev->dev, "no memory for context\n");
return -ENOMEM;
}
dev_set_drvdata(&pdev->dev, gsm_data);
regulator[0] = regulator_get(&pdev->dev, "avdd_usb_pll");
if (IS_ERR(regulator[0])) {
dev_err(&pdev->dev, "unable to get regulator for usb pll\n");
kfree(gsm_data);
dev_set_drvdata(&pdev->dev, NULL);
return -ENODEV;
}
gsm_data->regulator[0] = regulator[0];
regulator[1] = regulator_get(&pdev->dev, "avdd_usb");
if (IS_ERR(regulator[1])) {
dev_err(&pdev->dev, "unable to get regulator for usb\n");
regulator_put(regulator[0]);
gsm_data->regulator[0] = NULL;
kfree(gsm_data);
dev_set_drvdata(&pdev->dev, NULL);
return -ENODEV;
}
gsm_data->regulator[1] = regulator[1];
/* Init control pins */
gpio_request(SMBA1002_3G_DISABLE, "gsm_disable");
gpio_direction_output(SMBA1002_3G_DISABLE, 1);
// smba1002_3g_gps_init();
/* register rfkill interface */
rfkill = rfkill_alloc(pdev->name, &pdev->dev, RFKILL_TYPE_WWAN,
&smba1002_gsm_rfkill_ops, &pdev->dev);
if (!rfkill) {
dev_err(&pdev->dev, "Failed to allocate rfkill\n");
regulator_put(regulator[1]);
gsm_data->regulator[1] = NULL;
regulator_put(regulator[0]);
gsm_data->regulator[0] = NULL;
kfree(gsm_data);
dev_set_drvdata(&pdev->dev, NULL);
return -ENOMEM;
}
gsm_data->rfkill = rfkill;
/* Disable bluetooth */
rfkill_init_sw_state(rfkill, 0);
ret = rfkill_register(rfkill);
if (ret) {
rfkill_destroy(rfkill);
dev_err(&pdev->dev, "Failed to register rfkill\n");
return ret;
}
dev_info(&pdev->dev, "GSM/UMTS RFKill driver loaded\n");
return sysfs_create_group(&pdev->dev.kobj, &smba1002_gsm_attr_group);
}
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 toshiba_acpi_add(struct acpi_device *acpi_dev)
{
struct toshiba_acpi_dev *dev;
const char *hci_method;
u32 dummy;
bool bt_present;
int ret = 0;
if (toshiba_acpi)
return -EBUSY;
pr_info("Toshiba Laptop ACPI Extras version %s\n",
TOSHIBA_ACPI_VERSION);
hci_method = find_hci_method(acpi_dev->handle);
if (!hci_method) {
pr_err("HCI interface not found\n");
return -ENODEV;
}
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev)
return -ENOMEM;
dev->acpi_dev = acpi_dev;
dev->method_hci = hci_method;
acpi_dev->driver_data = dev;
if (toshiba_acpi_setup_keyboard(dev))
pr_info("Unable to activate hotkeys\n");
mutex_init(&dev->mutex);
ret = toshiba_acpi_setup_backlight(dev);
if (ret)
goto error;
/* Register rfkill switch for Bluetooth */
if (hci_get_bt_present(dev, &bt_present) == HCI_SUCCESS && bt_present) {
dev->bt_rfk = rfkill_alloc("Toshiba Bluetooth",
&acpi_dev->dev,
RFKILL_TYPE_BLUETOOTH,
&toshiba_rfk_ops,
dev);
if (!dev->bt_rfk) {
pr_err("unable to allocate rfkill device\n");
ret = -ENOMEM;
goto error;
}
ret = rfkill_register(dev->bt_rfk);
if (ret) {
pr_err("unable to register rfkill device\n");
rfkill_destroy(dev->bt_rfk);
goto error;
}
}
if (toshiba_illumination_available(dev)) {
dev->led_dev.name = "toshiba::illumination";
dev->led_dev.max_brightness = 1;
dev->led_dev.brightness_set = toshiba_illumination_set;
dev->led_dev.brightness_get = toshiba_illumination_get;
if (!led_classdev_register(&acpi_dev->dev, &dev->led_dev))
dev->illumination_supported = 1;
}
/* Determine whether or not BIOS supports fan and video interfaces */
ret = get_video_status(dev, &dummy);
dev->video_supported = !ret;
ret = get_fan_status(dev, &dummy);
dev->fan_supported = !ret;
create_toshiba_proc_entries(dev);
toshiba_acpi = dev;
return 0;
error:
toshiba_acpi_remove(acpi_dev);
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;
/*sunzizhi delate regulator not used
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;
}
*///sunzizhi delate
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
*/
/*sunzizhi modify*/
//if (bluedroid_pm->gpio_reset || bluedroid_pm->gpio_shutdown ||
//bluedroid_pm->vdd_1v8 || bluedroid_pm->vdd_3v3) {
if (bluedroid_pm->gpio_reset || bluedroid_pm->gpio_shutdown ) {
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;
}
#if 0
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__);
#if 0
bt_lpm.host_wake = 0;
wake_lock_init(&bt_lpm.host_wake_lock, WAKE_LOCK_SUSPEND,
"BTHostWakeLowPower");
#endif
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, 0);
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;
}
#endif
platform_set_drvdata(pdev, bluedroid_pm);
pr_debug("RFKILL BT driver successfully registered");
return 0;
free_res:
//if (bluedroid_pm->vdd_3v3) sunzizhi delate
//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 0
if (bluedroid_pm->ext_wake)
gpio_free(bluedroid_pm->ext_wake);
if (bluedroid_pm->host_wake)
gpio_free(bluedroid_pm->host_wake);
#endif
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 bluetooth_pm_probe(struct platform_device *pdev)
{
int ret;
bool default_state = true; /* off */
struct bluetooth_pm_device_info *bdev;
struct pinctrl *bt_pinctrl;
struct pinctrl_state *gpio_state_active;
printk("%s: bluetooth_pm_probe is called \n", __func__);
bsi = kzalloc(sizeof(struct bluetooth_pm_data), GFP_KERNEL);
if (!bsi) {
printk("%s: bsi is null \n", __func__);
return -ENOMEM;
}
if (pdev->dev.of_node) {
pdev->dev.platform_data = bsi;
ret = bluetooth_pm_parse_dt(&pdev->dev);
if (ret < 0) {
printk("%s: failed to parse device tree\n",__func__);
goto free_res;
}
} else {
printk("%s: No Device Node\n", __func__);
goto free_res;
}
if(!bsi) {
printk("%s: no bluetooth_pm_data \n", __func__);
return -ENODEV;
}
bdev = kzalloc(sizeof(struct bluetooth_pm_device_info), GFP_KERNEL);
if (!bdev) {
printk("%s: bdev is null \n", __func__);
return -ENOMEM;
}
bdev->gpio_bt_reset = bsi->bt_reset;
bdev->gpio_bt_host_wake = bsi->host_wake;
bdev->gpio_bt_ext_wake = bsi->ext_wake;
platform_set_drvdata(pdev, bdev);
//BT_RESET
ret = gpio_request_one(bdev->gpio_bt_reset, GPIOF_OUT_INIT_LOW, "bt_reset");
if (ret) {
pr_err("%s: failed to request gpio(%d)\n", __func__, bdev->gpio_bt_reset);
goto free_res;
}
//BT_HOST_WAKE
ret = gpio_request_one(bdev->gpio_bt_host_wake, GPIOF_IN, "bt_host_wake");
if (ret) {
pr_err("%s: failed to request gpio(%d)\n", __func__, bdev->gpio_bt_host_wake);
goto free_res;
}
bt_pinctrl = devm_pinctrl_get(&pdev->dev);
if (IS_ERR_OR_NULL(bt_pinctrl)) {
pr_err("%s: target does not use pinctrl for host wake \n", __func__);
return -ENODEV;
}
gpio_state_active = pinctrl_lookup_state(bt_pinctrl, "bt_active" );
if (IS_ERR_OR_NULL(gpio_state_active)) {
pr_err("%s: can't get gpio_state_active for host wake \n", __func__);
return -ENODEV;
}
if (pinctrl_select_state(bt_pinctrl, gpio_state_active))
pr_err("%s: error on pinctrl_select_state for host wake \n", __func__);
else
printk("%s: success to set pinctrl_select_state for host wake \n", __func__);
//BT_EXT_WAKE
ret = gpio_request_one(bdev->gpio_bt_ext_wake, GPIOF_OUT_INIT_LOW, "bt_ext_wake");
if (ret) {
pr_err("%s: failed to request gpio(%d)\n", __func__, bdev->gpio_bt_ext_wake);
goto free_res;
}
bluetooth_pm_rfkill_set_power(bdev, default_state);
bdev->rfk = rfkill_alloc(pdev->name, &pdev->dev, RFKILL_TYPE_BLUETOOTH,
&bluetooth_pm_rfkill_ops, bsi);
if(unlikely(!bdev->rfk)) {
pr_err("%s: failed to alloc rfkill \n", __func__);
ret = -ENOMEM;
goto free_res;
}
rfkill_set_states(bdev->rfk, default_state, false);
ret = rfkill_register(bdev->rfk);
if (unlikely(ret)) {
pr_err("%s: failed to register rfkill \n", __func__);
rfkill_destroy(bdev->rfk);
kfree(bdev->rfk);
goto free_res;
}
bsi->rfkill = bdev->rfk;
bsi->host_wake_irq = platform_get_irq_byname(pdev, "host_wake_interrupt");
if (bsi->host_wake_irq < 0) {
pr_err("%s: Couldn't find host_wake irq \n",__func__);
}
printk("%s : hostwake GPIO : %d(%u), btwake GPIO : %d(%u) \n",__func__,
bsi->host_wake,gpio_get_value(bsi->host_wake),bsi->ext_wake,gpio_get_value(bsi->ext_wake));
printk("%s: bsi->host_wake_irq: %d \n", __func__,bsi->host_wake_irq);
ret = bt_enable_pinctrl_init(&pdev->dev, bdev);
if (ret) {
pr_err("%s: failed to init pinctrl\n", __func__);
goto free_res;
}
#ifdef UART_CONTROL_MSM
bsi->uport = NULL;//msm_hs_get_bt_uport(BT_PORT_NUM);
#endif/*UART_CONTROL_MSM*/
#ifdef QOS_REQUEST_MSM
bsi->dma_qos_request = NOT_REQUESTED;
#endif /* QOS_REQUEST_MSM */
#ifdef QOS_REQUEST_TEGRA
bsi->resume_min_frequency = 204000;
#endif/*QOS_REQUEST_TEGRA*/
wake_lock_init(&bsi->wake_lock, WAKE_LOCK_SUSPEND, "bluetooth_pm");
bluetooth_pm_create_bt_proc_interface();
return 0;
free_res:
if(bsi->ext_wake)
gpio_free(bsi->ext_wake);
if(bsi->host_wake)
gpio_free(bsi->host_wake);
if(bsi->bt_reset)
gpio_free(bsi->bt_reset);
if (bsi->rfkill) {
rfkill_unregister(bsi->rfkill);
rfkill_destroy(bsi->rfkill);
kfree(bsi->rfkill);
}
kfree(bsi);
return ret;
}