static int liberty_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
enum rfkill_state default_state = RFKILL_STATE_SOFT_BLOCKED;
liberty_config_bt_init(); /* bt gpio initial config */
rfkill_set_default(RFKILL_TYPE_BLUETOOTH, default_state);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!bt_rfk)
return -ENOMEM;
bt_rfk->name = bt_name;
bt_rfk->state = default_state;
/* userspace cannot take exclusive control */
bt_rfk->user_claim_unsupported = 1;
bt_rfk->user_claim = 0;
bt_rfk->data = NULL;
bt_rfk->toggle_radio = bluetooth_set_power;
rc = rfkill_register(bt_rfk);
if (rc)
goto err_rfkill_reg;
return 0;
err_rfkill_reg:
rfkill_free(bt_rfk);
return rc;
}
static int legend_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
enum rfkill_state default_state = RFKILL_STATE_SOFT_BLOCKED; /* off */
/* force BT on and off to do GPIO setting when initiate */
bluetooth_set_power(NULL, RFKILL_STATE_UNBLOCKED);
legend_config_bt_init(); /* bt gpio initial config */
rfkill_set_default(RFKILL_TYPE_BLUETOOTH, default_state);
bluetooth_set_power(NULL, default_state);
bt_rfk = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!bt_rfk)
return -ENOMEM;
bt_rfk->name = bt_name;
bt_rfk->state = default_state;
/* userspace cannot take exclusive control */
bt_rfk->user_claim_unsupported = 1;
bt_rfk->user_claim = 0;
bt_rfk->data = NULL; /* user data */
bt_rfk->toggle_radio = bluetooth_set_power;
rc = rfkill_register(bt_rfk);
if (rc)
rfkill_free(bt_rfk);
return rc;
}
static int bluetooth_power_rfkill_probe(struct platform_device *pdev)
{
struct rfkill *rfkill;
int ret;
/* force Bluetooth off during init to allow for user control */
ret = rfkill_set_default(RFKILL_TYPE_BLUETOOTH,
RFKILL_STATE_SOFT_BLOCKED);
if (ret) {
printk(KERN_DEBUG
"%s: rfkill set default failed=%d\n", __func__, ret);
return ret;
}
rfkill = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!rfkill) {
dev_err(&pdev->dev, "rfkill allocate failed\n");
return -ENOMEM;
}
rfkill->name = "bt_power";
rfkill->toggle_radio = bluetooth_toggle_radio;
rfkill->data = pdev->dev.platform_data;
ret = rfkill_register(rfkill);
if (ret) {
dev_err(&pdev->dev, "rfkill register failed=%d\n", ret);
rfkill_free(rfkill);
return ret;
}
platform_set_drvdata(pdev, rfkill);
return 0;
}
static int fxn_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
struct fxn_rfkill_platform_data *pdata = pdev->dev.platform_data;
enum rfkill_state default_state = RFKILL_STATE_UNBLOCKED;
//printk(">>> fxn_rfkill_probe\n");
// WiFi
#ifdef CONFIG_RFKILL_WIFI
if(DBG) printk("<RFKILL_WIFI>\n");
if (pdata->wifi_reset_gpio >= 0) {
rfkill_set_default(RFKILL_TYPE_WLAN, RFKILL_STATE_UNBLOCKED);
pdata->rfkill[FXN_WIFI] = rfkill_allocate(&pdev->dev, RFKILL_TYPE_WLAN);
if (unlikely(!pdata->rfkill[FXN_WIFI]))
{
return -ENOMEM;
}
// printk(" WL_RST_N GPIO %d to HIGH\n", (void *)pdata->wifi_reset_gpio);
fxn_rfkill_set_power_wifi((void *)pdata->wifi_reset_gpio, RFKILL_STATE_UNBLOCKED);
pdata->rfkill[FXN_WIFI]->name = "fxn_wifi";
pdata->rfkill[FXN_WIFI]->state = default_state;
/* userspace cannot take exclusive control */
pdata->rfkill[FXN_WIFI]->user_claim_unsupported = 1;
pdata->rfkill[FXN_WIFI]->user_claim = 0;
pdata->rfkill[FXN_WIFI]->data = (void *)pdata->wifi_reset_gpio;
pdata->rfkill[FXN_WIFI]->toggle_radio = fxn_rfkill_set_power_wifi;
rc = rfkill_register(pdata->rfkill[FXN_WIFI]);
if (unlikely(rc)) {
rfkill_free(pdata->rfkill[FXN_WIFI]);
return rc;
}
}
//&*&*&*BC1_110513:add the wifi suspend wakelock to avoid wifi or system crash
wake_lock_init(&wifi_lock, WAKE_LOCK_SUSPEND, "wifi_wake_lock");
//&*&*&*BC2_110513:add the wifi suspend wakelock to avoid wifi or system crash
#endif
// Bluetooth
#ifdef CONFIG_RFKILL_BT
if(DBG) printk("<RFKILL_BT>\n");
if (pdata->bt_reset_gpio >= 0) {
rfkill_set_default(RFKILL_TYPE_BLUETOOTH, RFKILL_STATE_SOFT_BLOCKED);
// printk(" BT_RST_N to LOW\n");
fxn_rfkill_set_power_bt((void *)pdata->bt_reset_gpio, RFKILL_STATE_SOFT_BLOCKED);
pdata->rfkill[FXN_BT] = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (unlikely(!pdata->rfkill[FXN_BT]))
{
return -ENOMEM;
}
pdata->rfkill[FXN_BT]->name = "fxn_bt";
pdata->rfkill[FXN_BT]->state = default_state;
/* userspace cannot take exclusive control */
pdata->rfkill[FXN_BT]->user_claim_unsupported = 1;
pdata->rfkill[FXN_BT]->user_claim = 0;
pdata->rfkill[FXN_BT]->data = (void *)pdata->bt_reset_gpio;
pdata->rfkill[FXN_BT]->toggle_radio = fxn_rfkill_set_power_bt;
rc = rfkill_register(pdata->rfkill[FXN_BT]);
if (unlikely(rc)) {
rfkill_free(pdata->rfkill[FXN_BT]);
return rc;
}
}
#endif
// GPS
#ifdef CONFIG_RFKILL_GPS
if(DBG) printk("<RFKILL_GPS>\n");
rc = 0;
if (pdata->gps_pwr_en_gpio >= 0) {
rfkill_set_default(RFKILL_TYPE_GPS, RFKILL_STATE_SOFT_BLOCKED);
// GPS_PWR_EN
if(DBG) printk(" GPS_PWR_EN to high\n");
gpio_direction_output(FXN_GPIO_GPS_PWR_EN, 1);
udelay(100);
// GPS_RST
if(DBG) printk(" GPS_RST to high\n");
gpio_direction_output(FXN_GPIO_GPS_RST, 1);
msleep(100);
// GPS_ON_OFF
if(DBG) printk(" GPS_ON_OFF to low\n");
gpio_direction_output(FXN_GPIO_GPS_ON_OFF, 0);
pdata->rfkill[FXN_GPS] = rfkill_allocate(&pdev->dev, RFKILL_TYPE_GPS);
if (unlikely(!pdata->rfkill[FXN_GPS]))
{
return -ENOMEM;
}
// set BLOCKED as default
fxn_rfkill_set_power_gps((void *)pdata->gps_pwr_en_gpio, RFKILL_STATE_SOFT_BLOCKED);
pdata->rfkill[FXN_GPS]->name = "fxn_gps";
pdata->rfkill[FXN_GPS]->state = default_state;
/* userspace cannot take exclusive control */
pdata->rfkill[FXN_GPS]->user_claim_unsupported = 1;
pdata->rfkill[FXN_GPS]->user_claim = 0;
pdata->rfkill[FXN_GPS]->data = (void *)pdata->gps_pwr_en_gpio;
pdata->rfkill[FXN_GPS]->toggle_radio = fxn_rfkill_set_power_gps;
rc = rfkill_register(pdata->rfkill[FXN_GPS]);
if (unlikely(rc)) {
rfkill_free(pdata->rfkill[FXN_GPS]);
return rc;
}
}
#endif
//printk("<<< fxn_rfkill_probe\n");
return 0;
}
static int __init apollo_rfkill_probe(struct platform_device *pdev)
{
int ret;
s5p_config_gpio_alive_table(ARRAY_SIZE(bt_gpio_table), bt_gpio_table);
/* Host Wake IRQ */
wake_lock_init(&bt_host_wakelock, WAKE_LOCK_SUSPEND, "bt_host_wake");
bt_rfkill = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!bt_rfkill)
goto err_rfkill;
bt_rfkill->name = "bt_rfkill";
/* userspace cannot take exclusive control */
bt_rfkill->user_claim_unsupported = 1;
bt_rfkill->user_claim = 0;
bt_rfkill->data = pdev; /* user data */
bt_rfkill->toggle_radio = bluetooth_set_power;
/* set bt_rfkill default state to off */
rfkill_set_default(RFKILL_TYPE_BLUETOOTH, RFKILL_STATE_SOFT_BLOCKED);
ret = rfkill_register(bt_rfkill);
if (ret) {
rfkill_free(bt_rfkill);
goto err_rfkill;
}
#ifdef BT_SLEEP_ENABLE
wake_lock_init(&bt_wakelock, WAKE_LOCK_SUSPEND, "bt_wake");
bt_sleep = rfkill_allocate(&pdev->dev, RFKILL_TYPE_BLUETOOTH);
if (!bt_sleep)
goto err_sleep;
bt_sleep->name = "bt_sleep";
/* userspace cannot take exclusive control */
bt_sleep->user_claim_unsupported = 1;
bt_sleep->user_claim = 0;
bt_sleep->data = NULL; /* user data */
bt_sleep->toggle_radio = bluetooth_set_sleep;
ret = rfkill_register(bt_sleep);
if (ret) {
rfkill_free(bt_sleep);
goto err_sleep;
}
/* set bt_sleep default state to wake_unlock */
rfkill_force_state(bt_sleep, RFKILL_STATE_UNBLOCKED);
#endif /* BT_SLEEP_ENABLE */
return 0;
err_sleep:
wake_lock_destroy(&bt_wakelock);
rfkill_unregister(bt_rfkill);
err_rfkill:
wake_lock_destroy(&bt_host_wakelock);
return ret;
}
