static void chgic_interrupt_plug_out(void)
{
    int32_t usbphy_val = gpio_get_value_cansleep(CHGIC_USBPHY_LC824204_GPIO);
    CHGIC_DBG_PRINT("### %s:before:usbphy=%d\n",__func__,usbphy_val);
    if(usbphy_val != CHGIC_GPIO_OFF)
    {
        gpio_set_value_cansleep(CHGIC_USBPHY_LC824204_GPIO, CHGIC_GPIO_OFF);
    }
    chgic_fix_accessory(KC_CHANGER_NO_ACCESSORY);

    CHGIC_REG_WRITE_DATA(changer_info->client, CHGIC_REG_07H, CHGIC_DATA_ALL_NORMAL);
    CHGIC_REG_WRITE_DATA(changer_info->client, CHGIC_REG_05H, CHGIC_DATA_05H_SW);

    bk_interrupt_mask = CHGIC_DATA_06H_STANDBY;
    if (earphone_flg == true)
    {
        key_dm_driver_set_port(0x12);
        kc_hs_jack_change_state(false);
        earphone_flg = false;
    }

}
static void chgic_interrupt_plug_in(void)
{
    u8 sw_state = 0;
    u8 interrupt_case = 0;
    u8 id_state = 0;
    u8 chg_det_mode = 0;
    u8 set_mode = 0;
    int32_t usbphy_val = 0;

    set_mode = chgic_read_register_status(&sw_state, &interrupt_case, &id_state, &chg_det_mode, true);
    CHGIC_DBG_PRINT("### set_mode:%x, sw_state:%x, interrupt_case:%x, id_state:%x, chg_det_mode:%x\n", set_mode, sw_state, interrupt_case, id_state, chg_det_mode);

    if(!(changer_set_mode == KC_CHANGER_UNINITIALIZE) &&
        (changer_set_mode != KC_CHANGER_NO_ACCESSORY) &&
       !((set_mode == KC_CHANGER_NO_ACCESSORY) ||
        (kc_changer_delay_fix_accessory(sw_state) == true)))
    {
       CHGIC_DBG_PRINT("chgic_interrupt_plug_in:Return changer_set_mode:%x delay_fix_flag:%x\n",
                         changer_set_mode,delay_fix_flag);
       return;
    }

    usbphy_val = gpio_get_value_cansleep(CHGIC_USBPHY_LC824204_GPIO);
    CHGIC_DBG_PRINT("### %s:before:usbphy=%d\n",__func__,usbphy_val);
    if(sw_state & CHGIC_DATA_01H_VBUS_DET &&
        usbphy_val == CHGIC_GPIO_OFF)
    {
        gpio_set_value_cansleep(CHGIC_USBPHY_LC824204_GPIO, CHGIC_GPIO_ON);
    }

    switch (id_state)
    {
        case CHGIC_DATA_RID_OPEN:
        {
            if (set_mode == KC_CHANGER_AC_ADAPTER)
            {
                CHGIC_SET_DM_INFO(sw_state, id_state, interrupt_case, chg_det_mode);
            }
            if (set_mode == KC_CHANGER_NO_ACCESSORY)
            {
               chgic_interrupt_plug_out();
            }
            else
            {
                chgic_fix_accessory(set_mode);
            }
        }
        break;
        case CHGIC_DATA_AUDIO_MIC_MONO:
        case CHGIC_DATA_AUDIO_MIC_MONO_CHG:
        case CHGIC_DATA_AUDIO_MIC_STEREO:
        case CHGIC_DATA_AUDIO_STEREO:
        {
            CHGIC_SET_DM_INFO(sw_state, id_state, interrupt_case, chg_det_mode);
            chgic_fix_accessory(set_mode);

            if ((id_state == CHGIC_DATA_AUDIO_MIC_MONO) || 
                 (id_state == CHGIC_DATA_AUDIO_MIC_MONO_CHG) || 
                 (id_state == CHGIC_DATA_AUDIO_MIC_STEREO))
            {
                CHGIC_REG_WRITE_DATA(changer_info->client, CHGIC_REG_05H, CHGIC_DATA_05H_OFF);
                bk_interrupt_mask = CHGIC_DATA_06H_ALL;
            }
            else
            {
                CHGIC_REG_WRITE_DATA(changer_info->client, CHGIC_REG_07H, CHGIC_DATA_ALL_NORMAL);
            }
            kc_hs_jack_change_state(true);
            earphone_flg = true;
        }
        break;
        case CHGIC_DATA_AUDIO_SW_ON_INS:
        case CHGIC_DATA_AUDIO_CHG_SW_ON_INS:
        {
            CHGIC_SET_DM_INFO(sw_state, id_state, interrupt_case, chg_det_mode);
            if ((sw_state & CHGIC_DATA_01H_VBUS_DET) == 0)
            {
                chgic_fix_accessory(KC_CHANGER_AUDIO_MIC_STEREO);
            }
            else
            {
                chgic_fix_accessory(KC_CHANGER_AUDIO_CHG_STEREO);
            }
            next_detect_force_flag = true;

            CHGIC_REG_WRITE_DATA(changer_info->client, CHGIC_REG_05H, CHGIC_DATA_05H_OFF);
            bk_interrupt_mask = CHGIC_DATA_06H_ALL;

            kc_hs_jack_change_state(true);
            earphone_flg = true;
        }
        break;
        default:
        {
            CHGIC_SET_DM_INFO(sw_state, id_state, interrupt_case, chg_det_mode);
            chgic_fix_accessory(set_mode);
            CHGIC_REG_WRITE_DATA(changer_info->client, CHGIC_REG_07H, CHGIC_DATA_ALL_NORMAL);
        }
        break;
    }
}
Exemplo n.º 3
0
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_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_SW, SW_MICROPHONE_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) {
		dev_err(&ipdev->dev, "rpc init failure\n");
		goto err_hs_rpc_init;
	}
#ifdef CONFIG_FEATURE_KCC_F45
	g_init_flag = true;
	if (kc_changer_ic_is_audio(kc_changer_ic_get_accessory())) {
		kc_hs_jack_change_state(true);
	}
#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;
}