static int anx7808_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct anx7808_data *anx7808;
struct anx7808_platform_data *pdata;
int ret = 0;
int sbl_cable_type = 0;
#ifdef SP_REGISTER_SET_TEST
val_SP_TX_LT_CTRL_REG0 = 0x19;
val_SP_TX_LT_CTRL_REG10 = 0x00;
val_SP_TX_LT_CTRL_REG11 = 0x00;
val_SP_TX_LT_CTRL_REG2 = 0x36;
val_SP_TX_LT_CTRL_REG12 = 0x00;
val_SP_TX_LT_CTRL_REG1 = 0x26;
val_SP_TX_LT_CTRL_REG6 = 0x3c;
val_SP_TX_LT_CTRL_REG16 = 0x18;
val_SP_TX_LT_CTRL_REG5 = 0x28;
val_SP_TX_LT_CTRL_REG8 = 0x2F;
val_SP_TX_LT_CTRL_REG15 = 0x10;
val_SP_TX_LT_CTRL_REG18 = 0x1F;
#endif
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_I2C_BLOCK)) {
pr_err("%s: i2c bus does not support the anx7808\n", __func__);
ret = -ENODEV;
goto exit;
}
anx7808 = kzalloc(sizeof(struct anx7808_data), GFP_KERNEL);
if (!anx7808) {
pr_err("%s: failed to allocate driver data\n", __func__);
ret = -ENOMEM;
goto exit;
}
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct anx7808_platform_data),
GFP_KERNEL);
if (!pdata) {
pr_err("%s: Failed to allocate memory\n", __func__);
return -ENOMEM;
}
client->dev.platform_data = pdata;
/* device tree parsing function call */
ret = anx7808_parse_dt(&client->dev, pdata);
if (ret != 0) /* if occurs error */
goto err0;
anx7808->pdata = pdata;
} else {
anx7808->pdata = client->dev.platform_data;
}
/* to access global platform data */
g_pdata = anx7808->pdata;
anx7808_client = client;
mutex_init(&anx7808->lock);
if (!anx7808->pdata) {
ret = -EINVAL;
goto err0;
}
ret = anx7808_init_gpio(anx7808);
if (ret) {
pr_err("%s: failed to initialize gpio\n", __func__);
goto err0;
}
INIT_DELAYED_WORK(&anx7808->work, anx7808_work_func);
INIT_DELAYED_WORK(&anx7808->dwc3_ref_clk_work, dwc3_ref_clk_work_func);
anx7808->workqueue = create_singlethread_workqueue("anx7808_work");
if (anx7808->workqueue == NULL) {
pr_err("%s: failed to create work queue\n", __func__);
ret = -ENOMEM;
goto err1;
}
anx7808->pdata->avdd_power(1);
anx7808->pdata->dvdd_power(1);
ret = anx7808_system_init();
if (ret) {
pr_err("%s: failed to initialize anx7808\n", __func__);
goto err2;
}
client->irq = gpio_to_irq(anx7808->pdata->gpio_cbl_det);
if (client->irq < 0) {
pr_err("%s : failed to get gpio irq\n", __func__);
goto err2;
}
wake_lock_init(&anx7808->slimport_lock,
WAKE_LOCK_SUSPEND,
"slimport_wake_lock");
sbl_cable_type = anx7808_get_sbl_cable_type();
if ((lge_get_laf_mode() != LGE_LAF_MODE_LAF) &&
( sbl_cable_type != CBL_910K)){
ret = request_threaded_irq(client->irq, NULL, anx7808_cbl_det_isr,
IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
| IRQF_ONESHOT,
"anx7808", anx7808);
if (ret < 0) {
pr_err("%s : failed to request irq\n", __func__);
goto err2;
}
ret = irq_set_irq_wake(client->irq, 1);
if (ret < 0) {
pr_err("%s : Request irq for cable detect", __func__);
pr_err("interrupt wake set fail\n");
goto err3;
}
ret = enable_irq_wake(client->irq);
if (ret < 0) {
pr_err("%s : Enable irq for cable detect", __func__);
pr_err("interrupt wake enable fail\n");
goto err3;
}
}else {
pr_err("%s %s : %s, Disable cbl det irq!!\n", LOG_TAG, __func__,
sbl_cable_type == CBL_910K ? "910K Cable Connected" : "Laf Mode");
}
ret = create_sysfs_interfaces(&client->dev);
if (ret < 0) {
pr_err("%s : sysfs register failed", __func__);
goto err3;
}
#ifdef CONFIG_SLIMPORT_DYNAMIC_HPD
hdmi_slimport_ops = devm_kzalloc(&client->dev,
sizeof(struct msm_hdmi_slimport_ops),
GFP_KERNEL);
if (!hdmi_slimport_ops) {
pr_err("%s: alloc hdmi slimport ops failed\n", __func__);
ret = -ENOMEM;
goto err3;
}
if (anx7808->pdata->hdmi_pdev) {
ret = msm_hdmi_register_slimport(anx7808->pdata->hdmi_pdev,
hdmi_slimport_ops, anx7808);
if (ret) {
pr_err("%s: register with hdmi failed\n", __func__);
ret = -EPROBE_DEFER;
goto err3;
}
}
#endif
#ifdef CONFIG_ZERO_WAIT
zw_irqs_info_register(client->irq, 1);
zw_notifier_chain_register(&zw_slimport_nb, anx7808);
#endif
goto exit;
err3:
free_irq(client->irq, anx7808);
err2:
destroy_workqueue(anx7808->workqueue);
err1:
anx7808_free_gpio(anx7808);
err0:
anx7808_client = NULL;
kfree(anx7808);
exit:
return ret;
}
static int lge_hsd_probe(struct platform_device *pdev)
{
int ret = 0;
struct max1462x_platform_data *pdata = pdev->dev.platform_data;
struct hsd_info *hi;
HSD_DBG("lge_hsd_probe\n");
hi = kzalloc(sizeof(struct hsd_info), GFP_KERNEL);
if ( hi == NULL) {
HSD_ERR("Failed to allloate headset per device info\n");
return -ENOMEM;
}
if(pdev->dev.of_node){
pdata = devm_kzalloc(&pdev->dev,sizeof(struct max1462x_platform_data),GFP_KERNEL);
if(!pdata){
HSD_ERR("Failed to allocate memory\n");
return -ENOMEM;
}
pdev->dev.platform_data = pdata;
max1462x_parse_dt(&pdev->dev,pdata);
} else {
pdata = devm_kzalloc(&pdev->dev,sizeof(struct max1462x_platform_data),GFP_KERNEL);
if(!pdata){
HSD_ERR("Failed to allocate memory\n");
return -ENOMEM;
}
else
pdata = pdev->dev.platform_data;
}
hi->key_code = pdata->key_code;
platform_set_drvdata(pdev, hi);
atomic_set(&hi->btn_state, 0);
atomic_set(&hi->is_3_pole_or_not, 1);
atomic_set(&hi->irq_key_enabled, FALSE);
hi->gpio_mic_en = pdata->gpio_mic_en;
hi->gpio_detect = pdata->gpio_detect;
hi->gpio_key = pdata->gpio_key;
hi->gpio_set_value_func = pdata->gpio_set_value_func;
hi->gpio_get_value_func = pdata->gpio_get_value_func;
#ifdef CONFIG_SWITCH_MAX1462X_WA
hi->latency_for_key = msecs_to_jiffies(50);
#else
hi->latency_for_key = msecs_to_jiffies(50); /* convert milli to jiffies */
#endif
mutex_init(&hi->mutex_lock);
INIT_WORK(&hi->work, detect_work);
INIT_DELAYED_WORK(&hi->work_for_key_pressed, button_pressed);
INIT_DELAYED_WORK(&hi->work_for_key_released, button_released);
ret = gpio_request(hi->gpio_mic_en, "gpio_mic_en");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_mic_en) gpio_request\n", hi->gpio_mic_en);
goto error_02;
}
ret = gpio_direction_output(hi->gpio_mic_en, 0);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_mic_en) gpio_direction_input\n", hi->gpio_mic_en);
goto error_02;
}
HSD_DBG("gpio_get_value_cansleep(hi->gpio_mic_en) = %d\n", gpio_get_value_cansleep(hi->gpio_mic_en));
/* init gpio_detect */
ret = gpio_request(hi->gpio_detect, "gpio_detect");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_det) gpio_request\n", hi->gpio_detect);
goto error_03;
}
ret = gpio_direction_input(hi->gpio_detect);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_det) gpio_direction_input\n", hi->gpio_detect);
goto error_03;
}
/*init gpio_key */
ret = gpio_request(hi->gpio_key, "gpio_key");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_key) gpio_request\n", hi->gpio_key);
goto error_04;
}
ret = gpio_direction_input(hi->gpio_key);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_key) gpio_direction_input\n", hi->gpio_key);
goto error_04;
}
/* initialize irq of gpio_key */
hi->irq_key = gpio_to_irq(hi->gpio_key);
HSD_DBG("hi->irq_key = %d\n", hi->irq_key);
if (hi->irq_key < 0) {
HSD_ERR("Failed to get interrupt number\n");
ret = hi->irq_key;
goto error_06;
}
ret = request_threaded_irq(hi->irq_key, NULL, button_irq_handler,
IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, pdev->name, hi);
if (ret) {
HSD_ERR("failed to request button irq\n");
goto error_06;
}
ret = irq_set_irq_wake(hi->irq_key, 1);
if (ret < 0) {
HSD_ERR("Failed to set irq_key interrupt wake\n");
goto error_06;
}
enable_irq(hi->irq_key);
hi->irq_detect = gpio_to_irq(hi->gpio_detect);
HSD_DBG("hi->irq_detect = %d\n", hi->irq_detect);
if (hi->irq_detect < 0) {
HSD_ERR("Failed to get interrupt number\n");
ret = hi->irq_detect;
goto error_07;
}
ret = request_threaded_irq(hi->irq_detect, NULL, earjack_det_irq_handler,
IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, pdev->name, hi);
if (ret) {
HSD_ERR("failed to request button irq\n");
goto error_07;
}
ret = irq_set_irq_wake(hi->irq_detect, 1);
if (ret < 0) {
HSD_ERR("Failed to set gpio_detect interrupt wake\n");
goto error_07;
}
/* initialize switch device */
hi->sdev.name = pdata->switch_name;
hi->sdev.print_state = lge_hsd_print_state;
hi->sdev.print_name = lge_hsd_print_name;
ret = switch_dev_register(&hi->sdev);
if (ret < 0) {
HSD_ERR("Failed to register switch device\n");
goto error_08;
}
/* initialize input device */
hi->input = input_allocate_device();
if (!hi->input) {
HSD_ERR("Failed to allocate input device\n");
ret = -ENOMEM;
goto error_09;
}
hi->input->name = pdata->keypad_name;
hi->input->id.vendor = 0x0001;
hi->input->id.product = 1;
hi->input->id.version = 1;
#ifdef CONFIG_SWITCH_MAX1462X_WA
setup_timer( &hi->hook_disable_timer, hook_disable_timer_func, 0 );
hook_disable = 0;
#endif
/* headset tx noise */
{
struct qpnp_vadc_result result;
int acc_read_value = 0;
int i, rc;
int count = 3;
for (i = 0; i < count; i++)
{
rc = qpnp_vadc_read(P_MUX6_1_1,&result);
if (rc < 0)
{
if (rc == -ETIMEDOUT) {
pr_err("[DEBUG]adc read timeout \n");
} else {
pr_err("[DEBUG]adc read error - %d\n", rc);
}
}
else
{
acc_read_value = (int)result.physical;
pr_info("%s: acc_read_value - %d\n", __func__, (int)result.physical);
break;
}
}
}
set_bit(EV_SYN, hi->input->evbit);
set_bit(EV_KEY, hi->input->evbit);
set_bit(EV_SW, hi->input->evbit);
set_bit(hi->key_code, hi->input->keybit);
set_bit(SW_HEADPHONE_INSERT, hi->input->swbit);
set_bit(SW_MICROPHONE_INSERT, hi->input->swbit);
input_set_capability(hi->input, EV_KEY, KEY_MEDIA);
input_set_capability(hi->input, EV_KEY, KEY_VOLUMEUP);
input_set_capability(hi->input, EV_KEY, KEY_VOLUMEDOWN);
ret = input_register_device(hi->input);
if (ret) {
HSD_ERR("Failed to register input device\n");
goto error_09;
}
if (!(hi->gpio_get_value_func(hi->gpio_detect)))
#ifdef CONFIG_MAX1462X_USE_LOCAL_WORK_QUEUE
/* to detect in initialization with eacjack insertion */
queue_work(local_max1462x_workqueue, &(hi->work));
#else
/* to detect in initialization with eacjack insertion */
schedule_work(&(hi->work));
#endif
zw_irqs_info_register(hi->irq_key, 1);
zw_irqs_info_register(hi->irq_detect, 1);
return ret;
error_09:
input_free_device(hi->input);
error_08:
switch_dev_unregister(&hi->sdev);
error_07:
free_irq(hi->irq_detect, 0);
error_06:
free_irq(hi->irq_key, 0);
error_04:
gpio_free(hi->gpio_key);
error_03:
gpio_free(hi->gpio_detect);
error_02:
gpio_free(hi->gpio_mic_en);
kfree(hi);
return ret;
}
