static int snd_jack_dev_register(struct snd_device *device)
{
struct snd_jack *jack = device->device_data;
struct snd_card *card = device->card;
int err, i;
snprintf(jack->name, sizeof(jack->name), "%s %s",
card->shortname, jack->id);
jack->input_dev->name = jack->name;
/* Default to the sound card device. */
if (!jack->input_dev->dev.parent)
jack->input_dev->dev.parent = snd_card_get_device_link(card);
/* Add capabilities for any keys that are enabled */
for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
int testbit = SND_JACK_BTN_0 >> i;
if (!(jack->type & testbit))
continue;
if (!jack->key[i])
jack->key[i] = BTN_0 + i;
input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
}
/* Android custom switch API */
jack->sdev.name = jack->id;
err = switch_dev_register(&jack->sdev);
if (err != 0)
return err;
err = input_register_device(jack->input_dev);
if (err != 0)
goto err_switch;
jack->registered = 1;
return 0;
err_switch:
switch_dev_unregister(&jack->sdev);
return err;
}
int init_sim_hot_plug(void)
{
int rc = 0;
int sim_irq = gpio_to_irq(GPIO_SIM_PIN);
sim_state = gpio_get_value(GPIO_SIM_PIN);
RIL_INFO("GPIO = %d , irq = %d, state = %d\n", GPIO_SIM_PIN, sim_irq, sim_state);
rc = request_irq(sim_irq, sim_interrupt_handler,
IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, NAME_SIM, NULL);
if (rc < 0) {
RIL_ERR("Could not register for %s interrupt, irq = %d, rc = %d\n", NAME_SIM, sim_irq, rc);
rc = -EIO;
goto failed;
}
/* init work queue */
INIT_DELAYED_WORK(&workq, sim_irq_work);
/* register switch class*/
sim_sdev.name = NAME_SIM;
sim_sdev.print_name = print_sim_name;
sim_sdev.print_state = print_sim_state;
rc = switch_dev_register(&sim_sdev);
/*
* Because switch_dev_register will initiate sdev.state to 0,
* sdev.state will be initiated after switch_dev_register.
*/
sim_sdev.state = sim_state;
if (rc < 0) {
RIL_ERR("Could not register switch device, rc = %d\n", rc);
goto failed;
}
RIL_INFO("request irq and switch class successfully\n");
return 0;
failed:
gpio_free(GPIO_SIM_PIN);
return rc;
}
int mdp_open(struct v4l2_subdev *sd, void *arg)
{
struct mdp_instance *inst = kzalloc(sizeof(struct mdp_instance),
GFP_KERNEL);
struct mdp_msg_ops *mops = arg;
int rc = 0;
struct fb_info *fbi = NULL;
if (!inst) {
WFD_MSG_ERR("Out of memory\n");
rc = -ENOMEM;
goto mdp_open_fail;
} else if (!mops) {
WFD_MSG_ERR("Invalid arguments\n");
rc = -EINVAL;
goto mdp_open_fail;
}
fbi = msm_fb_get_writeback_fb();
if (!fbi) {
WFD_MSG_ERR("Failed to acquire mdp instance\n");
rc = -ENODEV;
goto mdp_open_fail;
}
inst->sdev.name = "wfd";
/* Register wfd node to switch driver */
rc = switch_dev_register(&inst->sdev);
if (rc) {
WFD_MSG_ERR("WFD switch registration failed\n");
goto mdp_open_fail;
}
msm_fb_writeback_init(fbi);
inst->mdp = fbi;
inst->secure = mops->secure;
inst->uses_iommu_split_domain = mops->iommu_split_domain;
mops->cookie = inst;
return rc;
mdp_open_fail:
kfree(inst);
return rc;
}
static int felica_int_probe_func(struct felica_dev *d)
{
int ret;
dev_dbg(d->dev, "%s\n", __func__);
if (!d->felica_data->flint->int_init ||
!d->felica_data->flint->int_read ||
!d->felica_data->flint->int_release) {
dev_err(d->dev, "%s: Error. Invalid operation.\n", __func__);
ret = -EINVAL;
goto err_invalid;
}
/* Init INT GPIO */
ret = d->felica_data->flint->int_init(d->felica_data->user);
if (ret) {
dev_err(d->dev, "%s: Error. INT GPIO init failed.\n", __func__);
ret = -ENODEV;
goto err_request_int_gpio;
}
/* Create INT switch device (felica_push) */
d->swdev.name = "felica_push";
if (switch_dev_register(&d->swdev)) {
dev_err(d->dev, "%s: Error. Cannot create switch dev\n",
__func__);
ret = -ENOMEM;
goto err_create_switch_dev;
}
/* Set initial state */
switch_set_state(&d->swdev, 0);
return 0;
err_create_switch_dev:
d->felica_data->flint->int_release(d->felica_data->user);
err_request_int_gpio:
err_invalid:
return ret;
}
int init_proximity(void)
{
int rc = 0;
/* register switch class*/
proxi_sdev.name = "proximity";
proxi_sdev.print_name = print_proxi_name;
proxi_sdev.print_state = print_proxi_state;
rc = switch_dev_register(&proxi_sdev);
if (rc < 0) {
RIL_ERR("Could not register switch device, rc = %d\n", rc);
goto failed;
}
RIL_INFO("register switch class successfully\n");
return 0;
failed:
return rc;
}
static __init int muic_init_switch(void)
{
int ret;
pr_info("register extcon notifier for JIG and docks\n");
switch_dev = device_create(sec_class, NULL, 0, NULL, "switch");
if (IS_ERR(switch_dev)) {
pr_err("(%s): failed to created device (switch_dev)!\n",
__func__);
return -ENODEV;
}
ret = switch_dev_register(&switch_dock);
if (ret < 0) {
pr_err("Failed to register dock switch. %d\n",
ret);
return ret;
}
return 0;
}
void max77803_muic_init_cb(void)
{
int ret;
/* for CarDock, DeskDock */
ret = switch_dev_register(&switch_dock);
pr_info("%s: MUIC ret=%d\n", __func__, ret);
if (ret < 0)
pr_err("Failed to register dock switch. %d\n", ret);
#if defined(CONFIG_SEC_H_PROJECT)
/* set gpio to enable redriver for USB3.0 */
gpio_tlmm_config(GPIO_CFG(GPIO_REDRIVER_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), 1);
gpio_set_value(GPIO_REDRIVER_EN,0);
#endif
}
static void muic_init_switch_dev_cb(void)
{
#ifdef CONFIG_SWITCH
int ret;
/* for DockObserver */
ret = switch_dev_register(&switch_dock);
if (ret < 0) {
pr_err("%s: Failed to register dock switch(%d)\n",
__func__, ret);
return;
}
#endif /* CONFIG_SWITCH */
#if defined(CONFIG_MUIC_NOTIFIER)
muic_notifier_register(&dock_notifier_block,
muic_handle_dock_notification, MUIC_NOTIFY_DEV_DOCK);
#endif /* CONFIG_MUIC_NOTIFIER */
pr_info("%s: done\n", __func__);
}
static int __init acoustic_init(void)
{
int ret = 0;
mutex_init(&api_lock);
ret = misc_register(&acoustic_misc);
if (ret < 0) {
pr_err("failed to register misc device!\n");
return ret;
}
sdev_beats.name = "Beats";
sdev_beats.print_name = beats_print_name;
ret = switch_dev_register(&sdev_beats);
if (ret < 0) {
pr_err("failed to register beats switch device!\n");
return ret;
}
return 0;
}
/**********************************************************
** Function: Headset driver init function
** Parameter: none
** Return value: none
**
************************************************************/
static int __init headset_init(void)
{
printk(KERN_INFO "%s+ #####\n", __func__);
int ret;
printk("HEADSET: Headset detection init\n");
hs_data = kzalloc(sizeof(struct headset_data), GFP_KERNEL);
if (!hs_data)
return -ENOMEM;
hs_data->debouncing_time = ktime_set(0, 100000000); /* 100 ms */
hs_data->sdev.name = "h2w";
hs_data->sdev.print_name = headset_name_show;
hs_data->sdev.print_state = headset_state_show;
ret = switch_dev_register(&hs_data->sdev);
if (ret < 0)
goto err_switch_dev_register;
g_detection_work_queue = create_workqueue("detection");
hrtimer_init(&hs_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
hs_data->timer.function = detect_event_timer_func;
printk("HEADSET: Headset detection mode\n");
btn_config_gpio();/*Config hook detection GPIO*/
jack_config_gpio();/*Config jack detection GPIO*/
INIT_WORK(&lineout_work, lineout_work_queue);
lineout_config_gpio();
printk(KERN_INFO "%s- #####\n", __func__);
return 0;
err_switch_dev_register:
printk(KERN_ERR "Headset: Failed to register driver\n");
return ret;
}
void mt_usb_otg_init(struct musb *musb)
{
/*init drrvbus*/
mt_usb_init_drvvbus();
/* init idpin interrupt */
INIT_DELAYED_WORK(&musb->id_pin_work, musb_id_pin_work);
otg_int_init();
/* EP table */
musb->fifo_cfg_host = fifo_cfg_host;
musb->fifo_cfg_host_size = ARRAY_SIZE(fifo_cfg_host);
otg_state.name = "otg_state";
otg_state.index = 0;
otg_state.state = 0;
if(switch_dev_register(&otg_state))
printk("switch_dev_register fail\n");
else
printk("switch_dev register success\n");
}
static int aml_m3_audio_probe(struct platform_device *pdev)
{
int ret;
//pdev->dev.platform_data;
// TODO
printk("***Entered %s:%s\n", __FILE__,__func__);
aml_m3_snd_device = platform_device_alloc("soc-audio", -1);
if (!aml_m3_snd_device) {
printk(KERN_ERR "ASoC: Platform device allocation failed\n");
ret = -ENOMEM;
}
platform_set_drvdata(aml_m3_snd_device,&aml_m3_snd_devdata);
aml_m3_snd_devdata.dev = &aml_m3_snd_device->dev;
ret = platform_device_add(aml_m3_snd_device);
if (ret) {
printk(KERN_ERR "ASoC: Platform device allocation failed\n");
goto error2;
}
aml_m3_platform_device = platform_device_register_simple("aml_m3_codec",
-1, NULL, 0);
aml_m3_platform_device->dev.platform_data = pdev->dev.platform_data;
#if HP_DET
sdev.name = "h2w";//for report headphone to android
ret = switch_dev_register(&sdev);
if (ret < 0){
printk(KERN_ERR "ASoC: register switch dev failed\n");
goto error1;
}
#endif
return 0;
error1:
platform_device_unregister(aml_m3_snd_device);
error2:
platform_device_put(aml_m3_snd_device);
return ret;
}
static int headphone_plug_register(void)
{
int irq, err;
int headphone_current_state;
irq = _get_headphone_irq();
err = request_irq(irq, headphone_plug_isr, IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,
"audio-headphone-int", &pt_audio_device_io);
if(err < 0)
return err;
INIT_WORK(&headphone_work, headphone_plug_work_func);
err = switch_dev_register(&headphone_sw_dev);
if(err < 0)
return err;
headphone_current_state = _get_headphone_state();
switch_set_state(&headphone_sw_dev, headphone_current_state);
return 0;
}
static int h2w_probe(struct platform_device *pdev)
{
int ret = 0;
pr_debug("Registering H2W (headset) driver\n");
hi = kzalloc(sizeof(struct h2w_info), GFP_KERNEL);
if (!hi)
return -ENOMEM;
hi->ignore_btn = 0;
hi->sdev.name = "h2w";
hi->sdev.print_name = h2w_print_name;
/* register a switch device */
ret = switch_dev_register(&hi->sdev);
if (ret < 0)
goto err_switch_dev_register;
/* register a input */
hi->input = input_allocate_device();
if (!hi->input) {
ret = -ENOMEM;
goto err_request_input_dev;
}
hi->input->name = "8930_handset";
hi->input->evbit[0] = BIT_MASK(EV_KEY);
hi->input->keybit[BIT_WORD(KEY_MEDIA)] = BIT_MASK(KEY_MEDIA);
ret = input_register_device(hi->input);
if (ret < 0)
goto err_register_input_dev;
return 0;
err_register_input_dev:
input_free_device(hi->input);
err_request_input_dev:
err_switch_dev_register:
printk(KERN_ERR "Failed to register H2W (headset) driver\n");
kfree(hi);
return ret;
}
static int hdmi_switch_probe(struct platform_device *pdev)
{
int ret;
struct hdmi_switch_device *hdmi_switch;
hdmi_switch = kzalloc(sizeof(struct hdmi_switch_device), GFP_KERNEL);
if (!hdmi_switch)
return -ENOMEM;
INIT_WORK(&hdmi_switch->work, hdmi_switch_work_func);
hdmi_switch->sdev.name = HDMI_SWITCH_NAME;
hdmi_switch->sdev.print_state = hdmi_switch_print_state;
ret = switch_dev_register(&hdmi_switch->sdev);
if (ret < 0) {
logd("err_register_switch\n");
goto err_register_switch;
}
ret = device_create_file(hdmi_switch->sdev.dev, &dev_attr_interface);
if (ret < 0) {
goto err_create_sysfs_file;
}
platform_set_drvdata(pdev, hdmi_switch);
s_hdmi_switch = hdmi_switch;
logd("hdmi_switch_probe() successed\n");
return 0;
err_create_sysfs_file:
switch_dev_unregister(&hdmi_switch->sdev);
err_register_switch:
kfree(hdmi_switch);
s_hdmi_switch = NULL;
loge("hdmi_switch_probe() failed\n");
return ret;
}
static int hdmi_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
disp_vdevice_init_data init_data;
pr_info("[DISP_I2C] hdmi_i2c_probe\n");
memset(&init_data, 0, sizeof(disp_vdevice_init_data));
ep952_i2c_client = client;
init_data.disp = hdmi_screen_id;
memcpy(init_data.name, modules_name, 32);
init_data.type = DISP_OUTPUT_TYPE_HDMI;
init_data.fix_timing = 0;
init_data.func.enable = ep952_open;
init_data.func.disable = ep952_close;
init_data.func.set_mode = ep952_set_mode;
init_data.func.mode_support = ep952_get_mode_support;
init_data.func.get_HPD_status = ep952_get_hpd_status;
init_data.func.get_input_csc = ep952_get_input_csc;
init_data.func.get_video_timing_info = ep952_get_video_timing_info;
init_data.func.suspend = ep952_suspend;
init_data.func.resume = ep952_resume;
init_data.func.early_suspend = ep952_early_suspend;
init_data.func.late_resume = ep952_late_resume;
init_data.func.get_interface_para = ep952_hdmi_get_interface_para;
disp_vdevice_get_source_ops(&hdmi_source_ops);
hdmi_parse_config();
EP_HDMI_Init();
#if defined(CONFIG_SWITCH) || defined(CONFIG_ANDROID_SWITCH)
switch_dev_register(&hdmi_switch_dev);
#endif
ep952_thread_enable();
ep952_device = disp_vdevice_register(&init_data);
return 0;
}
//[---]Debug for active wakelock before entering suspend
int __init pm_autosleep_init(void)
{
//[+++]Debug for active wakelock before entering suspend
int ret;
pmsp_dev.name = "PowerManagerServicePrinter";
pmsp_dev.index = 0;
INIT_WORK(&pms_printer, pms_printer_func);
ret = switch_dev_register(&pmsp_dev);
if (ret < 0)
printk("%s:fail to register switch power_manager_printer \n",__func__);
else
printk("%s:success to register pmsp switch \n",__func__);
//[---]Debug for active wakelock before entering suspend
autosleep_ws = wakeup_source_register("autosleep");
if (!autosleep_ws)
return -ENOMEM;
autosleep_wq = alloc_ordered_workqueue("autosleep", 0);
if (autosleep_wq)
return 0;
wakeup_source_unregister(autosleep_ws);
return -ENOMEM;
}
static int kpd_pdrv_probe(struct platform_device *pdev)
{
int i, r;
int err = 0;
#ifdef CONFIG_OF
kp_base = of_iomap(pdev->dev.of_node, 0);
if (!kp_base) {
pr_warn(KPD_SAY "KP iomap failed\n");
return -ENODEV;
};
kp_irqnr = irq_of_parse_and_map(pdev->dev.of_node, 0);
if (!kp_irqnr) {
pr_warn(KPD_SAY "KP get irqnr failed\n");
return -ENODEV;
}
pr_warn(KPD_SAY "kp base: 0x%p, addr:0x%p, kp irq: %d\n", kp_base,&kp_base, kp_irqnr);
#endif
kpd_ldvt_test_init(); /* API 2 for kpd LFVT test enviroment settings */
/* initialize and register input device (/dev/input/eventX) */
kpd_input_dev = input_allocate_device();
if (!kpd_input_dev)
return -ENOMEM;
kpd_input_dev->name = KPD_NAME;
kpd_input_dev->id.bustype = BUS_HOST;
kpd_input_dev->id.vendor = 0x2454;
kpd_input_dev->id.product = 0x6500;
kpd_input_dev->id.version = 0x0010;
kpd_input_dev->open = kpd_open;
#ifdef AEON_FCOVER_SUPPORT
spin_lock_init(&fcover_lock);
fcover_close_flag = 1;
#endif
//fulfill custom settings
kpd_memory_setting();
__set_bit(EV_KEY, kpd_input_dev->evbit);
#if (KPD_PWRKEY_USE_EINT || KPD_PWRKEY_USE_PMIC)
__set_bit(KPD_PWRKEY_MAP, kpd_input_dev->keybit);
kpd_keymap[8] = 0;
#endif
#if !KPD_USE_EXTEND_TYPE
for (i = 17; i < KPD_NUM_KEYS; i += 9) /* only [8] works for Power key */
kpd_keymap[i] = 0;
#endif
for (i = 0; i < KPD_NUM_KEYS; i++) {
if (kpd_keymap[i] != 0)
__set_bit(kpd_keymap[i], kpd_input_dev->keybit);
}
#if KPD_AUTOTEST
for (i = 0; i < ARRAY_SIZE(kpd_auto_keymap); i++)
__set_bit(kpd_auto_keymap[i], kpd_input_dev->keybit);
#endif
#if KPD_HAS_SLIDE_QWERTY
__set_bit(EV_SW, kpd_input_dev->evbit);
__set_bit(SW_LID, kpd_input_dev->swbit);
#endif
#ifdef KPD_PMIC_RSTKEY_MAP
__set_bit(KPD_PMIC_RSTKEY_MAP, kpd_input_dev->keybit);
#endif
#ifdef KPD_KEY_MAP
__set_bit(KPD_KEY_MAP, kpd_input_dev->keybit);
#endif
#ifdef AEON_FCOVER_SUPPORT
// __set_bit(KEY_FCOVER_1, kpd_input_dev->keybit);
// __set_bit(KEY_FCOVER_2, kpd_input_dev->keybit);
__set_bit(KEY_F11, kpd_input_dev->keybit);
__set_bit(KEY_F12, kpd_input_dev->keybit);
#endif
kpd_input_dev->dev.parent = &pdev->dev;
r = input_register_device(kpd_input_dev);
if (r) {
printk(KPD_SAY "register input device failed (%d)\n", r);
input_free_device(kpd_input_dev);
return r;
}
/* register device (/dev/mt6575-kpd) */
kpd_dev.parent = &pdev->dev;
r = misc_register(&kpd_dev);
if (r) {
printk(KPD_SAY "register device failed (%d)\n", r);
input_unregister_device(kpd_input_dev);
return r;
}
#ifdef CONFIG_MTK_TC1_FM_AT_SUSPEND
wake_lock_init(&kpd_suspend_lock, WAKE_LOCK_SUSPEND, "kpd wakelock");
#endif
/* register IRQ and EINT */
kpd_set_debounce(KPD_KEY_DEBOUNCE);
#ifdef CONFIG_OF
r = request_irq(kp_irqnr, kpd_irq_handler, IRQF_TRIGGER_NONE, KPD_NAME, NULL);
#else
r = request_irq(MT_KP_IRQ_ID, kpd_irq_handler, IRQF_TRIGGER_FALLING, KPD_NAME, NULL);
#endif
if (r) {
printk(KPD_SAY "register IRQ failed (%d)\n", r);
misc_deregister(&kpd_dev);
input_unregister_device(kpd_input_dev);
return r;
}
mt_eint_register();
#ifndef KPD_EARLY_PORTING /*add for avoid early porting build err the macro is defined in custom file */
long_press_reboot_function_setting(); /* /API 4 for kpd long press reboot function setting */
#endif
hrtimer_init(&aee_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer.function = aee_timer_func;
#if AEE_ENABLE_5_15
hrtimer_init(&aee_timer_5s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer_5s.function = aee_timer_5s_func;
#endif
if ((err = kpd_create_attr(&kpd_pdrv.driver))) {
kpd_print("create attr file fail\n");
kpd_delete_attr(&kpd_pdrv.driver);
return err;
}
pr_warn(KPD_SAY "%s Done\n", __FUNCTION__);
#ifdef AEON_FCOVER_SUPPORT
fcover_workqueue = create_singlethread_workqueue("fcover");
INIT_WORK(&fcover_work, fcover_key_handler);
fcover_data.name = "hall";
fcover_data.index = 0;
fcover_data.state = fcover_close_flag;
err = switch_dev_register(&fcover_data);
if(err)
{
printk("[Accdet]switch_dev_register returned:%d!\n", err);
// return 1;
}
switch_set_state((struct switch_dev *)&fcover_data, fcover_close_flag);
#ifdef AEON_FCOVER_SUPPORT
mt_set_gpio_mode(GPIO_FCOVER_EINT_PIN, GPIO_EINT_HALL_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_FCOVER_EINT_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_FCOVER_EINT_PIN, GPIO_PULL_DISABLE);
// mt_set_gpio_pull_select(GPIO_FCOVER_EINT_PIN, GPIO_PULL_UP);
mdelay(20);
fcover_close_flag = mt_get_gpio_in(GPIO_FCOVER_EINT_PIN);
// tpd_fcover_setting(fcover_close_flag);
mt_set_gpio_mode(GPIO_FCOVER_EINT_PIN, GPIO_EINT_HALL_PIN_M_EINT);
mt_eint_set_sens(FCOVER_KEY_EINT, FCOVER_KEY_SENSITIVE);
mt_eint_set_hw_debounce(FCOVER_KEY_EINT, FCOVER_KEY_DEBOUNCE);
mt_eint_registration(FCOVER_KEY_EINT, EINTF_TRIGGER_LOW,
kpd_fcover_eint_handler, 0);
mt_eint_unmask(FCOVER_KEY_EINT);
printk(KPD_SAY "xuqian kpd_fcover_eint_handler ..\n");
#else
mt_set_gpio_mode(GPIO_FCOVER_EINT_PIN, GPIO_EINT_HALL_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_FCOVER_EINT_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_FCOVER_EINT_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_FCOVER_EINT_PIN, GPIO_PULL_DOWN);
#endif
// err = device_create_file(&(pdev->dev), &dev_attr_kpd_fcover_state);
// if(err)
// {
// printk("create attr file dev_attr_kpd_fcover_state error\n");
//// kpd_delete_attr(&kpd_pdrv.driver);
//// return err;
// }
// else
// {
// printk("create attr file dev_attr_kpd_fcover_state ok\n");
// }
#endif
return 0;
}
static int __devinit pm8xxx_cradle_probe(struct platform_device *pdev)
{
int ret;
#if defined CONFIG_HALLIC_PEN
unsigned int hall_pen_gpio_irq = 0, hall_pouch_gpio_irq = 0;
#else
#if defined (CONFIG_MACH_MSM8974_T1LTE_GLOBAL_COM) || defined (CONFIG_MACH_MSM8974_T1WIFI_GLOBAL_COM) || defined (CONFIG_MACH_MSM8974_T1WIFIN_GLOBAL_COM) || defined(CONFIG_MACH_MSM8974_T1_ATT)
unsigned int hall_pouch_gpio_irq = 0;
#else
unsigned int hall_camera_gpio_irq = 0, hall_pouch_gpio_irq = 0;
#endif
#endif
struct pm8xxx_cradle_platform_data *pdata;
if (pdev->dev.of_node) {
pdata = devm_kzalloc(&pdev->dev,
sizeof(struct pm8xxx_cradle_platform_data),
GFP_KERNEL);
if (pdata == NULL) {
pr_err("%s: no pdata\n", __func__);
return -ENOMEM;
}
pdev->dev.platform_data = pdata;
#if defined(CONFIG_S5717)
s5717_parse_dt(&pdev->dev, pdata);
#else
bu52014hfv_parse_dt(&pdev->dev, pdata);
#endif
} else {
pdata = pdev->dev.platform_data;
}
if (!pdata) {
pr_err("%s: no pdata\n", __func__);
return -ENOMEM;
}
cradle = kzalloc(sizeof(*cradle), GFP_KERNEL);
if (!cradle)
return -ENOMEM;
cradle->pdata = pdata;
cradle->sdev.name = "smartcover";
cradle->sdev.print_name = cradle_print_name;
cradle->pouch = 0;
#if defined CONFIG_HALLIC_PEN
cradle->pen = 0;
#else
#if !defined (CONFIG_MACH_MSM8974_T1LTE_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFI_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFIN_GLOBAL_COM) && !defined(CONFIG_MACH_MSM8974_T1_ATT)
cradle->camera = 0;
#endif
#endif
spin_lock_init(&cradle->lock);
ret = switch_dev_register(&cradle->sdev);
if (ret < 0)
goto err_switch_dev_register;
if (pre_set_flag) {
cradle_set_deskdock(pre_set_flag);
cradle->state = pre_set_flag;
}
wake_lock_init(&cradle->wake_lock, WAKE_LOCK_SUSPEND, "hall_ic_wakeups");
INIT_DELAYED_WORK(&cradle->pouch_work, pm8xxx_pouch_work_func);
#if defined CONFIG_HALLIC_PEN
INIT_DELAYED_WORK(&cradle->pen_work, pm8xxx_pen_work_func);
#else
#if !defined (CONFIG_MACH_MSM8974_T1LTE_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFI_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFIN_GLOBAL_COM) && !defined(CONFIG_MACH_MSM8974_T1_ATT)
INIT_DELAYED_WORK(&cradle->camera_work, pm8xxx_camera_work_func);
#endif
#endif
printk("%s : init cradle\n", __func__);
/* initialize irq of gpio_hall */
if (cradle->pdata->hallic_pouch_detect_pin > 0) {
hall_pouch_gpio_irq = gpio_to_irq(cradle->pdata->hallic_pouch_detect_pin);
printk("%s : hall_pouch_gpio_irq = [%d]\n", __func__, hall_pouch_gpio_irq);
if (hall_pouch_gpio_irq < 0) {
printk("Failed : GPIO TO IRQ \n");
ret = hall_pouch_gpio_irq;
goto err_request_irq;
}
ret = request_irq(hall_pouch_gpio_irq, pm8xxx_pouch_irq_handler, pdata->irq_flags, HALL_IC_DEV_NAME, cradle);
if (ret > 0) {
printk(KERN_ERR "%s: Can't allocate irq %d, ret %d\n", __func__, hall_pouch_gpio_irq, ret);
goto err_request_irq;
}
if (enable_irq_wake(hall_pouch_gpio_irq) == 0)
printk("%s :enable_irq_wake Enable(1)\n",__func__);
else
printk("%s :enable_irq_wake failed(1)\n",__func__);
}
#if defined CONFIG_HALLIC_PEN
if (cradle->pdata->hallic_pen_detect_pin > 0) {
hall_pen_gpio_irq = gpio_to_irq(cradle->pdata->hallic_pen_detect_pin);
printk("%s : hall_pen_gpio_irq = [%d]\n", __func__, hall_pen_gpio_irq);
if (hall_pen_gpio_irq < 0) {
printk("Failed : GPIO TO IRQ \n");
ret = hall_pen_gpio_irq;
goto err_request_irq;
}
ret = request_irq(hall_pen_gpio_irq, pm8xxx_pen_irq_handler, pdata->irq_flags, HALL_IC_DEV_NAME, cradle);
if (ret > 0) {
printk(KERN_ERR "%s: Can't allocate irq %d, ret %d\n", __func__, hall_pen_gpio_irq, ret);
goto err_request_irq;
}
if (enable_irq_wake(hall_pen_gpio_irq) == 0)
printk("%s :enable_irq_wake Enable(2)\n",__func__);
else
printk("%s :enable_irq_wake failed(2)\n",__func__);
}
#else
#if !defined (CONFIG_MACH_MSM8974_T1LTE_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFI_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFIN_GLOBAL_COM) && !defined(CONFIG_MACH_MSM8974_T1_ATT)
if (cradle->pdata->hallic_camera_detect_pin > 0) {
hall_camera_gpio_irq = gpio_to_irq(cradle->pdata->hallic_camera_detect_pin);
printk("%s : hall_camera_gpio_irq = [%d]\n", __func__, hall_camera_gpio_irq);
if (hall_camera_gpio_irq < 0) {
printk("Failed : GPIO TO IRQ \n");
ret = hall_camera_gpio_irq;
goto err_request_irq;
}
ret = request_irq(hall_camera_gpio_irq, pm8xxx_camera_irq_handler, pdata->irq_flags, HALL_IC_DEV_NAME, cradle);
if (ret > 0) {
printk(KERN_ERR "%s: Can't allocate irq %d, ret %d\n", __func__, hall_camera_gpio_irq, ret);
goto err_request_irq;
}
if (enable_irq_wake(hall_camera_gpio_irq) == 0)
printk("%s :enable_irq_wake Enable(2)\n",__func__);
else
printk("%s :enable_irq_wake failed(2)\n",__func__);
}
#endif
#endif
printk("%s : pdata->irq_flags = [%d]\n", __func__,(int)pdata->irq_flags);
printk("%s :boot_cradle_det_func START\n",__func__);
boot_cradle_det_func();
ret = device_create_file(&pdev->dev, &cradle_sensing_attr);
if (ret)
goto err_request_irq;
if (cradle->pdata->hallic_pouch_detect_pin > 0) {
ret = device_create_file(&pdev->dev, &cradle_pouch_attr);
if (ret)
goto err_request_irq;
}
#if defined CONFIG_HALLIC_PEN
if (cradle->pdata->hallic_pen_detect_pin > 0) {
ret = device_create_file(&pdev->dev, &cradle_pen_attr);
if (ret)
goto err_request_irq;
}
#else
#if !defined (CONFIG_MACH_MSM8974_T1LTE_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFI_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFIN_GLOBAL_COM) && !defined(CONFIG_MACH_MSM8974_T1_ATT)
if (cradle->pdata->hallic_camera_detect_pin > 0) {
ret = device_create_file(&pdev->dev, &cradle_camera_attr);
if (ret)
goto err_request_irq;
}
#endif
#endif
platform_set_drvdata(pdev, cradle);
return 0;
err_request_irq:
if (hall_pouch_gpio_irq)
free_irq(hall_pouch_gpio_irq, 0);
#if defined CONFIG_HALLIC_PEN
if (hall_pen_gpio_irq)
free_irq(hall_pen_gpio_irq, 0);
#else
#if !defined (CONFIG_MACH_MSM8974_T1LTE_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFI_GLOBAL_COM) && !defined (CONFIG_MACH_MSM8974_T1WIFIN_GLOBAL_COM) && !defined(CONFIG_MACH_MSM8974_T1_ATT)
if (hall_camera_gpio_irq)
free_irq(hall_camera_gpio_irq, 0);
#endif
#endif
err_switch_dev_register:
switch_dev_unregister(&cradle->sdev);
kfree(cradle);
return ret;
}
static int __devinit hall_sensor_probe(struct platform_device *pdev)
{
int ret = 0;
struct ak_hall_data * hl;
struct hall_platform_data *pdata;
hl = kzalloc(sizeof(*hl), GFP_KERNEL);
if (hl == NULL) {
ret = -ENOMEM;
goto err_alloc_mem_failed;
}
HL_LOG("++++++++++++++++++");
hl->hall_enable = 1;
if (pdev->dev.of_node) {
pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
if (!pdata)
{
HL_ERR("platform_data alloc memory fail");
goto err_alloc_mem_failed;
}
ret = hall_sensor_dt_parser(pdev->dev.of_node, pdata);
if (ret < 0) {
ret = -ENOMEM;
goto err_alloc_pdata_mem_failed;
}
} else {
pdata = pdev->dev.platform_data;
}
if (pdata) {
hl->att_used = pdata->att_used;
hl->gpio_att = pdata->gpio_att;
hl->gpio_att_s = pdata->gpio_att_s;
}
ret = hall_input_register(hl);
if (ret)
goto err_input_register_device_failed;
platform_set_drvdata(pdev, hl);
wake_lock_init(&hl->wake_lock, WAKE_LOCK_SUSPEND, DRIVER_NAME);
prev_val_n = gpio_get_value(hl->gpio_att);
ret = request_threaded_irq(gpio_to_irq(hl->gpio_att), NULL, hall_npole_irq_thread,
prev_val_n? IRQF_TRIGGER_LOW|IRQF_ONESHOT : IRQF_TRIGGER_HIGH|IRQF_ONESHOT, "ak8789_att", hl);
if (ret == 0)
{
irq_set_irq_wake(gpio_to_irq(hl->gpio_att), 1);
HL_LOG("Operate in [Interrupt] mode, irq[%d]", gpio_to_irq(hl->gpio_att));
}
else
goto err_request_irq_failed;
if (hl->att_used > 1) {
prev_val_s = gpio_get_value(hl->gpio_att_s);
ret = request_threaded_irq(gpio_to_irq(hl->gpio_att_s), NULL, hall_spole_irq_thread,
prev_val_s? IRQF_TRIGGER_LOW|IRQF_ONESHOT : IRQF_TRIGGER_HIGH|IRQF_ONESHOT, "ak8789_att_s", hl);
if (ret == 0)
{
irq_set_irq_wake(gpio_to_irq(hl->gpio_att_s), 1);
HL_LOG("Operate in [Interrupt] mode, irq[%d]", gpio_to_irq(hl->gpio_att_s));
}
else
{
free_irq(gpio_to_irq(hl->gpio_att), hl);
goto err_request_irq_failed;
}
}
hall_cover_sysfs_init();
if (switch_dev_register(&cover_switch) < 0) {
pr_err("fail to register cover switch!\n");
return 0;
}
switch_set_state(&cover_switch, hl->gpio_att ? 0 : 1);
g_hl = hl;
HL_LOG("------------------");
return 0;
err_request_irq_failed:
HL_ERR("Request IRQ failed, ret=%d, gpio=%d", ret, hl->gpio_att);
wake_lock_destroy(&hl->wake_lock);
err_input_register_device_failed:
err_alloc_pdata_mem_failed:
if (pdev->dev.of_node)
kfree(pdata);
err_alloc_mem_failed:
kfree(hl);
return ret;
}
static int htc_headset_mgr_probe(struct platform_device *pdev)
{
int ret;
struct htc_headset_mgr_platform_data *pdata = pdev->dev.platform_data;
HS_LOG("++++++++++++++++++++");
hi = kzalloc(sizeof(struct htc_headset_mgr_info), GFP_KERNEL);
if (!hi)
return -ENOMEM;
hi->pdata.driver_flag = pdata->driver_flag;
hi->pdata.headset_devices_num = pdata->headset_devices_num;
hi->pdata.headset_devices = pdata->headset_devices;
hi->pdata.headset_config_num = pdata->headset_config_num;
hi->pdata.headset_config = pdata->headset_config;
hi->pdata.hptv_det_hp_gpio = pdata->hptv_det_hp_gpio;
hi->pdata.hptv_det_tv_gpio = pdata->hptv_det_tv_gpio;
hi->pdata.hptv_sel_gpio = pdata->hptv_sel_gpio;
hi->pdata.headset_init = pdata->headset_init;
hi->pdata.headset_power = pdata->headset_power;
if (hi->pdata.headset_init)
hi->pdata.headset_init();
hi->driver_init_seq = 0;
hi->early_suspend.suspend = htc_headset_mgr_early_suspend;
hi->early_suspend.resume = htc_headset_mgr_late_resume;
register_early_suspend(&hi->early_suspend);
wake_lock_init(&hi->hs_wake_lock, WAKE_LOCK_SUSPEND, DRIVER_NAME);
hi->hpin_jiffies = jiffies;
hi->usb_headset.type = USB_NO_HEADSET;
hi->usb_headset.status = STATUS_DISCONNECTED;
hi->hs_35mm_type = HEADSET_UNPLUG;
hi->h2w_35mm_type = HEADSET_UNPLUG;
hi->is_ext_insert = 0;
hi->mic_bias_state = 0;
hi->mic_detect_counter = 0;
hi->key_level_flag = -1;
hi->quick_boot_status = 0;
atomic_set(&hi->btn_state, 0);
hi->tty_enable_flag = 0;
hi->fm_flag = 0;
hi->debug_flag = 0;
mutex_init(&hi->mutex_lock);
hi->sdev_h2w.name = "h2w";
hi->sdev_h2w.print_name = h2w_print_name;
ret = switch_dev_register(&hi->sdev_h2w);
if (ret < 0)
goto err_h2w_switch_dev_register;
hi->sdev_usb_audio.name = "usb_audio";
hi->sdev_usb_audio.print_name = usb_audio_print_name;
ret = switch_dev_register(&hi->sdev_usb_audio);
if (ret < 0)
goto err_usb_audio_switch_dev_register;
detect_wq = create_workqueue("detect");
if (detect_wq == NULL) {
ret = -ENOMEM;
HS_ERR("Failed to create detect workqueue");
goto err_create_detect_work_queue;
}
button_wq = create_workqueue("button");
if (button_wq == NULL) {
ret = -ENOMEM;
HS_ERR("Failed to create button workqueue");
goto err_create_button_work_queue;
}
hi->input = input_allocate_device();
if (!hi->input) {
ret = -ENOMEM;
goto err_request_input_dev;
}
hi->input->name = "h2w headset";
set_bit(EV_SYN, hi->input->evbit);
set_bit(EV_KEY, hi->input->evbit);
set_bit(KEY_END, hi->input->keybit);
set_bit(KEY_MUTE, hi->input->keybit);
set_bit(KEY_VOLUMEDOWN, hi->input->keybit);
set_bit(KEY_VOLUMEUP, hi->input->keybit);
set_bit(KEY_NEXTSONG, hi->input->keybit);
set_bit(KEY_PLAYPAUSE, hi->input->keybit);
set_bit(KEY_PREVIOUSSONG, hi->input->keybit);
set_bit(KEY_MEDIA, hi->input->keybit);
set_bit(KEY_SEND, hi->input->keybit);
ret = input_register_device(hi->input);
if (ret < 0)
goto err_register_input_dev;
ret = register_attributes();
if (ret)
goto err_register_attributes;
#ifdef HTC_HEADSET_CONFIG_MSM_RPC
if (hi->pdata.driver_flag & DRIVER_HS_MGR_RPC_SERVER) {
/* Create RPC server */
ret = msm_rpc_create_server(&hs_rpc_server);
if (ret < 0) {
HS_ERR("Failed to create RPC server");
goto err_create_rpc_server;
}
HS_LOG("Create RPC server successfully");
}
#else
HS_DBG("NOT support RPC (%du, %du)", hs_rpc_server.prog,
hs_rpc_server.vers);
#endif
headset_mgr_init();
hs_notify_driver_ready(DRIVER_NAME);
HS_LOG("--------------------");
return 0;
#ifdef HTC_HEADSET_CONFIG_MSM_RPC
err_create_rpc_server:
#endif
err_register_attributes:
input_unregister_device(hi->input);
err_register_input_dev:
input_free_device(hi->input);
err_request_input_dev:
destroy_workqueue(button_wq);
err_create_button_work_queue:
destroy_workqueue(detect_wq);
err_create_detect_work_queue:
switch_dev_unregister(&hi->sdev_usb_audio);
err_usb_audio_switch_dev_register:
switch_dev_unregister(&hi->sdev_h2w);
err_h2w_switch_dev_register:
mutex_destroy(&hi->mutex_lock);
wake_lock_destroy(&hi->hs_wake_lock);
kfree(hi);
HS_ERR("Failed to register %s driver", DRIVER_NAME);
return ret;
}
int rk_headset_probe(struct platform_device *pdev,struct rk_headset_pdata *pdata)
{
int ret;
struct headset_priv *headset;
headset = kzalloc(sizeof(struct headset_priv), GFP_KERNEL);
if (headset == NULL) {
dev_err(&pdev->dev, "failed to allocate driver data\n");
return -ENOMEM;
}
headset->pdata = pdata;
headset->headset_status = HEADSET_OUT;
headset->hook_status = HOOK_UP;
headset->isHook_irq = disable;
headset->cur_headset_status = 0;
headset->sdev.name = "h2w";
headset->sdev.print_name = h2w_print_name;
ret = switch_dev_register(&headset->sdev);
if (ret < 0)
goto failed_free;
mutex_init(&headset->mutex_lock[HEADSET]);
mutex_init(&headset->mutex_lock[HOOK]);
INIT_DELAYED_WORK(&headset->h_delayed_work[HEADSET], headsetobserve_work);
INIT_DELAYED_WORK(&headset->h_delayed_work[HOOK], hook_work);
headset->isMic = 0;
setup_timer(&headset->headset_timer, headset_timer_callback, (unsigned long)headset);
//------------------------------------------------------------------
// Create and register the input driver.
headset->input_dev = input_allocate_device();
if (!headset->input_dev) {
dev_err(&pdev->dev, "failed to allocate input device\n");
ret = -ENOMEM;
goto failed_free;
}
headset->input_dev->name = pdev->name;
headset->input_dev->open = rk_hskey_open;
headset->input_dev->close = rk_hskey_close;
headset->input_dev->dev.parent = &pdev->dev;
//input_dev->phys = KEY_PHYS_NAME;
headset->input_dev->id.vendor = 0x0001;
headset->input_dev->id.product = 0x0001;
headset->input_dev->id.version = 0x0100;
// Register the input device
ret = input_register_device(headset->input_dev);
if (ret) {
dev_err(&pdev->dev, "failed to register input device\n");
goto failed_free_dev;
}
input_set_capability(headset->input_dev, EV_KEY,HOOK_KEY_CODE);
#ifdef CONFIG_HAS_EARLYSUSPEND
hs_early_suspend.suspend = NULL;
hs_early_suspend.resume = headset_early_resume;
hs_early_suspend.level = ~0x0;
register_early_suspend(&hs_early_suspend);
#endif
//------------------------------------------------------------------
if (pdata->headset_gpio) {
if(!pdata->headset_gpio){
dev_err(&pdev->dev,"failed init headset,please full hook_io_init function in board\n");
goto failed_free_dev;
}
headset->irq[HEADSET] = gpio_to_irq(pdata->headset_gpio);
if(pdata->headset_insert_type == HEADSET_IN_HIGH)
headset->irq_type[HEADSET] = IRQF_TRIGGER_RISING;
else
headset->irq_type[HEADSET] = IRQF_TRIGGER_FALLING;
ret = request_irq(headset->irq[HEADSET], headset_interrupt, headset->irq_type[HEADSET], "headset_input", NULL);
if (ret)
goto failed_free_dev;
enable_irq_wake(headset->irq[HEADSET]);
}
else
goto failed_free_dev;
//------------------------------------------------------------------
if (pdata->hook_gpio) {
headset->irq[HOOK] = gpio_to_irq(pdata->hook_gpio);
headset->irq_type[HOOK] = pdata->hook_down_type == HOOK_DOWN_HIGH ? IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
ret = request_irq(headset->irq[HOOK], hook_interrupt, headset->irq_type[HOOK] , "headset_hook", NULL);
if (ret)
goto failed_free_dev;
disable_irq(headset->irq[HOOK]);
}
//------------------------------------------------------------------
headset_info = headset;
schedule_delayed_work(&headset->h_delayed_work[HEADSET], msecs_to_jiffies(500));
return 0;
failed_free_dev:
platform_set_drvdata(pdev, NULL);
input_free_device(headset->input_dev);
failed_free:
dev_err(&pdev->dev, "failed to headset probe\n");
kfree(headset);
return ret;
}
static int gpio_switch_probe(struct platform_device *pdev)
{
struct gpio_switch_platform_data *pdata = pdev->dev.platform_data;
struct gpio_switch_data *switch_data;
int ret = 0;
SEC_HEADSET_DBG("");
this_dev = &pdev->dev;
if (gpio_request(EAR_MIC_BIAS_GPIO, "EARMIC") == 1)
{
gpio_direction_output(EAR_MIC_BIAS_GPIO, 0);
}
if (!pdata)
return -EBUSY;
switch_data = kzalloc(sizeof(struct gpio_switch_data), GFP_KERNEL);
if (!switch_data)
return -ENOMEM;
#ifdef USE_REGULATOR
usb3v1 = regulator_get(this_dev, "usb3v1");
if (IS_ERR(usb3v1))
return -ENODEV;
vintana2 = regulator_get(this_dev, "vintana2");
if (IS_ERR(vintana2))
return -ENODEV;
#endif
switch_data->sdev.name = pdata->name;
switch_data->gpio = pdata->gpio;
switch_data->name_on = pdata->name_on;
switch_data->name_off = pdata->name_off;
switch_data->state_on = pdata->state_on;
switch_data->state_off = pdata->state_off;
switch_data->sdev.print_state = switch_gpio_print_state;
ret = switch_dev_register(&switch_data->sdev);
if (ret < 0)
goto err_switch_dev_register;
ret = gpio_request(switch_data->gpio, pdev->name);
if (ret < 0)
goto err_request_gpio;
ret = gpio_direction_input(switch_data->gpio);
if (ret < 0)
goto err_set_gpio_input;
INIT_WORK(&switch_data->work, gpio_switch_work);
switch_data->irq = gpio_to_irq(switch_data->gpio);
if (switch_data->irq < 0) {
ret = switch_data->irq;
goto err_detect_irq_num_failed;
}
ret = request_irq(switch_data->irq, gpio_irq_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
pdev->name,
switch_data); //Iyyappan_HS
if (ret < 0)
goto err_request_irq;
data = switch_data;
init_timer(&headset_detect_timer);
headset_detect_timer.function = headset_detect_timer_handler;
wake_lock_init(&headset_wake_lock, WAKE_LOCK_SUSPEND, "headset");
enable_irq_wake(switch_data->irq);
/* Perform initial detection */
gpio_switch_work(&switch_data->work);
return 0;
err_request_irq:
err_detect_irq_num_failed:
err_set_gpio_input:
gpio_free(switch_data->gpio);
err_request_gpio:
switch_dev_unregister(&switch_data->sdev);
err_switch_dev_register:
kfree(switch_data);
return ret;
}
static int __devinit hs_probe(struct platform_device *pdev)
{
int rc;
struct input_dev *ipdev;
hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
if (!hs)
return -ENOMEM;
hs->sdev.name = "amss2w";//"h2w";//changed by flin to fix the framework detect
hs->sdev.print_name = msm_headset_print_name;
rc = switch_dev_register(&hs->sdev);
if (rc)
goto err_switch_dev_register;
ipdev = input_allocate_device();
if (!ipdev) {
rc = -ENOMEM;
goto err_alloc_input_dev;
}
input_set_drvdata(ipdev, hs);
hs->ipdev = ipdev;
if (pdev->dev.platform_data)
ipdev->name = pdev->dev.platform_data;
else
ipdev->name = DRIVER_NAME;
ipdev->id.vendor = 0x0001;
ipdev->id.product = 1;
ipdev->id.version = 1;
input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
input_set_capability(ipdev, EV_KEY, KEY_POWER);
input_set_capability(ipdev, EV_KEY, KEY_END);
rc = input_register_device(ipdev);
if (rc) {
dev_err(&ipdev->dev,
"hs_probe: input_register_device rc=%d\n", rc);
goto err_reg_input_dev;
}
platform_set_drvdata(pdev, hs);
rc = hs_rpc_init();
if (rc)
goto err_hs_rpc_init;
return 0;
err_hs_rpc_init:
input_unregister_device(ipdev);
ipdev = NULL;
err_reg_input_dev:
input_free_device(ipdev);
err_alloc_input_dev:
switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
kfree(hs);
return rc;
}
static int aml_asoc_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_card *card = rtd->card;
struct snd_soc_codec *codec = rtd->codec;
struct snd_soc_dapm_context *dapm = &codec->dapm;
struct aml_audio_private_data * p_aml_audio;
int ret = 0;
int hp_paraments[5];
printk(KERN_DEBUG "enter %s \n", __func__);
p_aml_audio = snd_soc_card_get_drvdata(card);
ret = snd_soc_add_card_controls(codec->card, aml_m8_controls,
ARRAY_SIZE(aml_m8_controls));
if (ret)
return ret;
/* Add specific widgets */
snd_soc_dapm_new_controls(dapm, aml_asoc_dapm_widgets,
ARRAY_SIZE(aml_asoc_dapm_widgets));
if (ret)
return ret;
#if HP_DET
p_aml_audio->sdev.name = "h2w";//for report headphone to android
ret = switch_dev_register(&p_aml_audio->sdev);
if (ret < 0){
printk(KERN_ERR "ASoC: register hp switch dev failed\n");
return ret;
}
p_aml_audio->mic_sdev.name = "mic_dev";//for micphone detect
ret = switch_dev_register(&p_aml_audio->mic_sdev);
if (ret < 0){
printk(KERN_ERR "ASoC: register mic switch dev failed\n");
return ret;
}
ret = snd_soc_jack_new(codec, "hp switch", SND_JACK_HEADPHONE, &p_aml_audio->jack);
if (ret < 0) {
printk(KERN_WARNING "Failed to alloc resource for hp switch\n");
} else {
ret = snd_soc_jack_add_pins(&p_aml_audio->jack, ARRAY_SIZE(jack_pins), jack_pins);
if (ret < 0) {
printk(KERN_WARNING "Failed to setup hp pins\n");
}
}
p_aml_audio->mic_det = of_property_read_bool(card->dev->of_node,"mic_det");
printk("entern %s : mic_det=%d \n",__func__,p_aml_audio->mic_det);
ret = of_property_read_u32_array(card->dev->of_node, "hp_paraments", &hp_paraments[0], 5);
if(ret){
printk("falied to get hp detect paraments from dts file\n");
}else{
p_aml_audio->hp_val_h = hp_paraments[0]; // hp adc value higher base, hp unplugged
p_aml_audio->hp_val_l = hp_paraments[1]; // hp adc value low base, 3 section hp plugged.
p_aml_audio->mic_val = hp_paraments[2]; // hp adc value mic detect value.
p_aml_audio->hp_detal = hp_paraments[3]; // hp adc value test toerance
p_aml_audio->hp_adc_ch = hp_paraments[4]; // get adc value from which adc port for hp detect
printk("hp detect paraments: h=%d,l=%d,mic=%d,det=%d,ch=%d \n",p_aml_audio->hp_val_h,p_aml_audio->hp_val_l,
p_aml_audio->mic_val,p_aml_audio->hp_detal,p_aml_audio->hp_adc_ch);
}
init_timer(&p_aml_audio->timer);
p_aml_audio->timer.function = aml_asoc_timer_func;
p_aml_audio->timer.data = (unsigned long)p_aml_audio;
p_aml_audio->data= (void*)card;
INIT_WORK(&p_aml_audio->work, aml_asoc_work_func);
mutex_init(&p_aml_audio->lock);
mutex_lock(&p_aml_audio->lock);
if (!p_aml_audio->timer_en) {
aml_audio_start_timer(p_aml_audio, msecs_to_jiffies(100));
}
mutex_unlock(&p_aml_audio->lock);
#endif
return 0;
}
static int __devinit pm8xxx_carkit_probe(struct platform_device *pdev)
{
int ret, i;
unsigned int hallic_carkit_gpio_irq = 0;
struct pm8xxx_carkit_platform_data *pdata;
printk("[Hall IC] carkit probe\n");
if (pdev->dev.of_node) {
pdata = devm_kzalloc(&pdev->dev,
sizeof(struct pm8xxx_carkit_platform_data),
GFP_KERNEL);
if (pdata == NULL) {
pr_err("%s: no pdata\n", __func__);
return -ENOMEM;
}
pdev->dev.platform_data = pdata;
bu52033nvx_parse_dt(&pdev->dev, pdata);
} else {
pdata = pdev->dev.platform_data;
}
if (!pdata) {
pr_err("%s: no pdata\n", __func__);
return -ENOMEM;
}
cradle = kzalloc(sizeof(*cradle), GFP_KERNEL);
if (!cradle)
return -ENOMEM;
cradle->pdata = pdata;
cradle->sdev.name = "dock";
cradle->sdev.print_name = cradle_print_name;
cradle->carkit = 0;
spin_lock_init(&cradle->lock);
ret = switch_dev_register(&cradle->sdev);
if (ret < 0)
goto err_switch_dev_register;
if (pre_set_flag) {
carkit_set_deskdock(pre_set_flag);
cradle->state = pre_set_flag;
}
wake_lock_init(&cradle->wake_lock, WAKE_LOCK_SUSPEND, "dock_wakeups");
INIT_DELAYED_WORK(&cradle->carkit_work, pm8xxx_carkit_work_func);
printk("%s : init carkit\n", __func__);
/* initialize irq of gpio_hall */
hallic_carkit_gpio_irq = gpio_to_irq(cradle->pdata->hallic_carkit_detect_pin);
printk("%s : hall_carkit_gpio_irq = [%d]\n", __func__, hallic_carkit_gpio_irq);
if (hallic_carkit_gpio_irq < 0) {
printk("Failed : GPIO TO IRQ \n");
ret = hallic_carkit_gpio_irq;
goto err_request_irq;
}
ret = request_irq(hallic_carkit_gpio_irq, pm8xxx_carkit_irq_handler, pdata->irq_flags, CARKIT_DEV_NAME, cradle);
if (ret > 0) {
printk(KERN_ERR "%s: Can't allocate irq %d, ret %d\n", __func__, hallic_carkit_gpio_irq, ret);
goto err_request_irq;
}
if (enable_irq_wake(hallic_carkit_gpio_irq) == 0)
printk("%s :enable_irq_wake Enable(3)\n",__func__);
else
printk("%s :enable_irq_wake failed(3)\n",__func__);
printk("%s : pdata->irq_flags = [%d]\n", __func__,(int)pdata->irq_flags);
printk("%s :boot_carkit_det_func START\n",__func__);
boot_carkit_det_func();
for (i = 0; i < ARRAY_SIZE(carkit_device_attrs); i++) {
ret = device_create_file(&pdev->dev, &carkit_device_attrs[i]);
if (ret)
goto err_request_irq;
}
platform_set_drvdata(pdev, cradle);
return 0;
err_request_irq:
if (hallic_carkit_gpio_irq)
free_irq(hallic_carkit_gpio_irq, 0);
err_switch_dev_register:
switch_dev_unregister(&cradle->sdev);
kfree(cradle);
return ret;
}
static __devinit int tegra_aic326x_driver_probe(struct platform_device *pdev)
{
struct snd_soc_card *card = &snd_soc_tegra_aic326x;
struct tegra_aic326x *machine;
struct tegra_aic326x_platform_data *pdata;
int ret, i;
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "No platform data supplied\n");
return -EINVAL;
}
machine = kzalloc(sizeof(struct tegra_aic326x), GFP_KERNEL);
if (!machine) {
dev_err(&pdev->dev, "Can't allocate tegra_aic326x struct\n");
return -ENOMEM;
}
machine->pdata = pdata;
ret = tegra_asoc_utils_init(&machine->util_data, &pdev->dev);
if (ret)
goto err_free_machine;
card->dev = &pdev->dev;
platform_set_drvdata(pdev, card);
snd_soc_card_set_drvdata(card, machine);
#ifdef CONFIG_SWITCH
/* Add h2w switch class support */
ret = switch_dev_register(&aic326x_wired_switch_dev);
if (ret < 0) {
dev_err(&pdev->dev, "not able to register switch device %d\n",
ret);
goto err_fini_utils;
}
#endif
ret = snd_soc_register_card(card);
if (ret) {
dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n",
ret);
goto err_fini_utils;
}
if (!card->instantiated) {
dev_err(&pdev->dev, "No TI AIC3262 codec\n");
goto err_unregister_card;
}
return 0;
err_unregister_card:
snd_soc_unregister_card(card);
err_fini_utils:
tegra_asoc_utils_fini(&machine->util_data);
err_free_machine:
kfree(machine);
return ret;
}
static int sec_jack_probe(struct platform_device *pdev)
{
struct sec_jack_info *hi;
struct sec_jack_platform_data *pdata = pdev->dev.platform_data;
int ret;
int sec_jack_keycode[] = {KEY_MEDIA, KEY_VOLUMEUP, KEY_VOLUMEDOWN};
int i;
struct class *audio;
struct device *earjack;
pr_info(MODULE_NAME "%s : Registering jack driver\n", __func__);
if (!pdata) {
pr_err("%s : pdata is NULL.\n", __func__);
return -ENODEV;
}
if (!pdata->get_det_jack_state ||
!pdata->get_send_key_state || !pdata->zones ||
!pdata->set_micbias_state ||
#if defined(CONFIG_SAMSUNG_JACK_GNDLDET)
!pdata->get_gnd_jack_state ||
#endif
#ifdef CONFIG_SAMSUNG_JACK_ADC_SCALE3
!pdata->get_ear_adc_value ||
#endif
!pdata->get_adc_value ||
pdata->num_zones > MAX_ZONE_LIMIT) {
pr_err("%s : need to check pdata\n", __func__);
return -ENODEV;
}
hi = kzalloc(sizeof(struct sec_jack_info), GFP_KERNEL);
if (hi == NULL) {
pr_err("%s : Failed to allocate memory.\n", __func__);
return -ENOMEM;
}
hi->is_ready = false;
hi->pdata = pdata;
hi->input = input_allocate_device();
if (hi->input == NULL) {
ret = -ENOMEM;
pr_err("%s : Failed to allocate input device.\n", __func__);
goto err_request_input_dev;
}
hi->input->name = "sec_jack";
for (i = 0 ; i < 3; i++)
input_set_capability(hi->input, EV_KEY, sec_jack_keycode[i]);
ret = input_register_device(hi->input);
if (ret) {
pr_err("%s : Failed to register driver\n", __func__);
goto err_register_input_dev;
}
ret = switch_dev_register(&switch_jack_detection);
if (ret < 0) {
pr_err("%s : Failed to register switch device\n", __func__);
goto err_switch_dev_register;
}
ret = switch_dev_register(&switch_sendend);
if (ret < 0) {
pr_err("%s : Failed to register switch device\n", __func__);
goto err_switch_dev_register;
}
wake_lock_init(&hi->det_wake_lock, WAKE_LOCK_SUSPEND, "sec_jack_det");
#ifdef CONFIG_SYSFS_SEC_SND_JACK
audio = class_create(THIS_MODULE, "audio");
if (IS_ERR(audio))
pr_err("Failed to create class(audio)!\n");
earjack = device_create(audio, NULL, 0, NULL, "earjack");
if (IS_ERR(earjack))
pr_err("Failed to create device(earjack)!\n");
ret = device_create_file(earjack, &dev_attr_key_state);
if (ret)
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_key_state.attr.name);
ret = device_create_file(earjack, &dev_attr_state);
if (ret)
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_state.attr.name);
#ifdef CONFIG_SYSFS_SEC_SND_SELECT_JACK
ret = device_create_file(earjack, &dev_attr_select_jack);
if (ret)
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_select_jack.attr.name);
ret = device_create_file(earjack, &dev_attr_reselect_jack);
if (ret)
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_reselect_jack.attr.name);
#endif
#endif
#if defined (CONFIG_MACH_MELIUS_CHN_CTC)
ret = device_create_file(earjack, &dev_attr_set_hw_rev);
if (ret)
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_set_hw_rev.attr.name);
#endif
INIT_WORK(&hi->det_work, sec_jack_det_work_func);
ret = request_threaded_irq(pdata->det_int, NULL,
sec_jack_det_irq_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
IRQF_ONESHOT, "sec_headset_detect", hi);
if (ret) {
pr_err("%s : Failed to request_irq.\n", __func__);
goto err_request_detect_irq;
}
/* to handle insert/removal when we're sleeping in a call */
ret = enable_irq_wake(pdata->det_int);
if (ret) {
pr_err("%s : Failed to enable_irq_wake.\n", __func__);
goto err_enable_irq_wake;
}
INIT_WORK(&hi->sendkey_work, sec_jack_send_key_work_func);
ret = request_threaded_irq(pdata->send_int, NULL,
sec_jack_send_key_irq_handler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
IRQF_ONESHOT,
"sec_headset_send_key", hi);
if (ret) {
pr_err("%s : Failed to request_irq.\n", __func__);
goto err_request_send_key_irq;
}
/* start with send/end interrupt disable. we only enable it
* when we detect a 4 pole headset
*/
disable_irq(pdata->send_int);
dev_set_drvdata(earjack, hi);
/* call irq_thread forcely because of missing interrupt when booting.
* 2000ms delay is enough to waiting for adc driver registration.
*/
INIT_DELAYED_WORK(&hi->powerup_work, sec_jack_powerup_work_func);
schedule_delayed_work(&hi->powerup_work, msecs_to_jiffies(2000));
return 0;
err_request_send_key_irq:
disable_irq_wake(pdata->det_int);
err_enable_irq_wake:
free_irq(pdata->det_int, hi);
err_request_detect_irq:
wake_lock_destroy(&hi->det_wake_lock);
switch_dev_unregister(&switch_jack_detection);
switch_dev_unregister(&switch_sendend);
err_switch_dev_register:
input_unregister_device(hi->input);
goto err_request_input_dev;
err_register_input_dev:
input_free_device(hi->input);
err_request_input_dev:
kfree(hi);
return ret;
}
static int __devinit hs_probe(struct platform_device *pdev)
{
int rc = 0;
struct input_dev *ipdev;
hs = kzalloc(sizeof(struct msm_handset), GFP_KERNEL);
if (!hs)
return -ENOMEM;
hs->sdev.name = "h2w";
hs->sdev.print_name = msm_headset_print_name;
rc = switch_dev_register(&hs->sdev);
if (rc)
goto err_switch_dev_register;
ipdev = input_allocate_device();
if (!ipdev) {
rc = -ENOMEM;
goto err_alloc_input_dev;
}
input_set_drvdata(ipdev, hs);
hs->ipdev = ipdev;
if (pdev->dev.platform_data)
hs->hs_pdata = pdev->dev.platform_data;
if (hs->hs_pdata->hs_name)
ipdev->name = hs->hs_pdata->hs_name;
else
ipdev->name = DRIVER_NAME;
ipdev->id.vendor = 0x0001;
ipdev->id.product = 1;
ipdev->id.version = 1;
input_set_capability(ipdev, EV_KEY, KEY_WAKEUP);
input_set_capability(ipdev, EV_KEY, KEY_MEDIA);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEUP);
input_set_capability(ipdev, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(ipdev, EV_SW, SW_HEADPHONE_INSERT);
input_set_capability(ipdev, EV_KEY, KEY_POWER);
//disable KEY_END, enable KEY_SLEEP
//input_set_capability(ipdev, EV_KEY, KEY_END);
input_set_capability(ipdev, EV_KEY, KEY_SLEEP);
rc = input_register_device(ipdev);
if (rc) {
dev_err(&ipdev->dev,
"hs_probe: input_register_device rc=%d\n", rc);
goto err_reg_input_dev;
}
platform_set_drvdata(pdev, hs);
rc = hs_rpc_init();
if (rc) {
dev_err(&ipdev->dev, "rpc init failure\n");
goto err_hs_rpc_init;
}
#if defined(CONFIG_ZTE_PLATFORM)
wake_lock_init(&hs_wake_lock, WAKE_LOCK_SUSPEND, "hs");
#endif
return 0;
err_hs_rpc_init:
input_unregister_device(ipdev);
ipdev = NULL;
err_reg_input_dev:
input_free_device(ipdev);
err_alloc_input_dev:
switch_dev_unregister(&hs->sdev);
err_switch_dev_register:
kfree(hs);
return rc;
}
static int __devinit pm8xxx_cradle_probe(struct platform_device *pdev)
#if 1
{
int ret, i;
unsigned int hall_gpio_irq;
const struct pm8xxx_cradle_platform_data *pdata =
pdev->dev.platform_data;
if (!pdata)
return -EINVAL;
cradle = kzalloc(sizeof(*cradle), GFP_KERNEL);
if (!cradle)
return -ENOMEM;
cradle->pdata = pdata;
cradle->sdev.name = "dock";
cradle->sdev.print_name = cradle_print_name;
cradle->pouch = cradle->carkit = 0;
spin_lock_init(&cradle->lock);
ret = switch_dev_register(&cradle->sdev);
if (ret < 0)
goto err_switch_dev_register;
if (pre_set_flag) {
cradle_set_deskdock(pre_set_flag);
cradle->state = pre_set_flag;
}
INIT_WORK(&cradle->work, pm8xxx_cradle_work_func);
printk("%s : init cradle\n", __func__);
/* initialize irq of gpio_hall */
hall_gpio_irq = gpio_to_irq(cradle->pdata->pouch_detect_pin);
printk("%s : hall_gpio_irq = [%d]\n", __func__,hall_gpio_irq);
if (hall_gpio_irq < 0) {
printk("Failed : GPIO TO IRQ \n");
ret = hall_gpio_irq;
goto err_request_irq;
}
printk("%s : pdata->irq_flags = [%d]\n", __func__,(int)pdata->irq_flags);
ret = request_irq(hall_gpio_irq, pm8xxx_pouch_irq_handler, pdata->irq_flags, HALL_IC_DEV_NAME, cradle);
if (ret > 0) {
printk(KERN_ERR "%s: Can't allocate irq %d, ret %d\n", __func__, hall_gpio_irq, ret);
goto err_request_irq;
}
printk("%s : enable_irq_wake \n", __func__);
if (enable_irq_wake(hall_gpio_irq) == 0)
printk("%s :enable_irq_wake Enable\n",__func__);
else
printk("%s :enable_irq_wake failed\n",__func__);
printk("%s :boot_cradle_det_func START\n",__func__);
boot_cradle_det_func();
for (i = 0; i < ARRAY_SIZE(cradle_device_attrs); i++) {
ret = device_create_file(&pdev->dev, &cradle_device_attrs[i]);
if (ret){
goto err_request_irq;
}
}
platform_set_drvdata(pdev, cradle);
return 0;
err_request_irq:
if (hall_gpio_irq)
free_irq(hall_gpio_irq, 0);
err_switch_dev_register:
switch_dev_unregister(&cradle->sdev);
kfree(cradle);
return ret;
}
