static int gs_probe(
struct i2c_client *client, const struct i2c_device_id *id)
{
int ret;
struct gs_data *gs;
struct vreg *vreg_gp4=NULL;
int rc;
vreg_gp4 = vreg_get(NULL, "gp4");
/* set gp4 voltage as 2700mV for all */
rc = vreg_set_level(vreg_gp4,VREG_GP4_VOLTAGE_VALUE_2700);
if (rc) {
printk("%s: vreg_gp4 vreg_set_level failed \n", __func__);
return rc;
}
rc = vreg_enable(vreg_gp4);
if (rc) {
printk("%s: vreg_gp4 vreg_enable failed \n", __func__);
return rc;
}
mdelay(5);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
printk(KERN_ERR "gs_probe: need I2C_FUNC_I2C\n");
ret = -ENODEV;
goto err_check_functionality_failed;
}
#ifndef GS_POLLING
ret = gs_config_int1_pin();
if(ret <0)
{
goto err_check_functionality_failed;
}
ret = gs_config_int2_pin();
if(ret <0)
{
goto err_check_functionality_failed;
}
#endif
gs = kzalloc(sizeof(*gs), GFP_KERNEL);
if (gs == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
/*BK4D00238, add mlock, dingxifeng KF14049, 2009-4-3 begin */
mutex_init(&gs->mlock);
/*BK4D00238, add mlock, dingxifeng KF14049, 2009-4-3 end */
INIT_WORK(&gs->work, gs_work_func);
gs->client = client;
i2c_set_clientdata(client, gs);
/*BK4D00238, add accelerometer code, dingxifeng KF14049, 2009-5-9 begin */
ret =reg_read(gs,GS_ADI_REG_DEVID);
if ( ret <0 )
goto err_detect_failed;
switch (ret) {
case ID_ADXL345:
break;
default:
printk(KERN_ERR, "Failed to probe \n" );
goto err_detect_failed;
}
/*BK4D01637, gs_probe interface set standby mode , dingxifeng KF14049, 2009-6-22 begin*/
ret = reg_write(gs,GS_ADI_REG_POWER_CTL,0x14); /* auto low power ,deep sleep */
/*BK4D01637, gs_probe interface set standby mode , dingxifeng KF14049, 2009-6-22 end*/
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_BW,0x0a); /* Rate: 100Hz, IDD: 130uA */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_DATA_FORMAT,0x01); /* Data Format: 8g right justified 128=1g 8g*/
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_INT_ENABLE,0x80); /* enable int Int En: Data Rdy*/
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_TAP_AXES,0x01); /* Z Axis Tap */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_THRESH_TAP,0x20); /* Tap Threshold: 2G */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_DUR,0x50); /* Dur:50ms */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_LATENT,0x20); /* Latent: 40ms */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_WINDOW,0xF0); /* Window: 300ms */
if ( ret <0 )
goto err_detect_failed;
if (sensor_dev == NULL)
{
gs->input_dev = input_allocate_device();
if (gs->input_dev == NULL) {
ret = -ENOMEM;
printk(KERN_ERR "gs_probe: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
gs->input_dev->name = "sensors";
sensor_dev = gs->input_dev;
}else{
gs->input_dev = sensor_dev;
}
gs->input_dev->id.vendor = GS_ADIX345;//for akm8973 compass detect.
set_bit(EV_ABS,gs->input_dev->evbit);
/* modify for ES-version*/
input_set_abs_params(gs->input_dev, ABS_X, -11520, 11520, 0, 0);
input_set_abs_params(gs->input_dev, ABS_Y, -11520, 11520, 0, 0);
input_set_abs_params(gs->input_dev, ABS_Z, -11520, 11520, 0, 0);
set_bit(EV_SYN,gs->input_dev->evbit);
gs->input_dev->id.bustype = BUS_I2C;
//gs->input_dev->open = gs_adi_input_open;
//gs->input_dev->close = gs_adi_input_close;
input_set_drvdata(gs->input_dev, gs);
ret = input_register_device(gs->input_dev);
if (ret) {
printk(KERN_ERR "gs_probe: Unable to register %s input device\n", gs->input_dev->name);
goto err_input_register_device_failed;
}
ret = misc_register(&gsensor_device);
if (ret) {
/*BK4D02639, modify printk mesg, dingxifeng KF14049, 2009-7-13 begin */
printk(KERN_ERR "gs_probe: gsensor_device register failed\n");
/*BK4D02639, modify printk mesg, dingxifeng KF14049, 2009-7-13 end */
goto err_misc_device_register_failed;
}
/*BK4D00263, add for input devices, dingxifeng KF14049, 2009-5-20 end*/
#ifndef GS_POLLING
if (client->irq) {
ret = request_irq(client->irq, gs_irq_handler, 0, client->name, gs);
if (ret == 0)
gs->use_irq = 1;
else
dev_err(&client->dev, "request_irq failed\n");
}
#endif
/*BK4D00238, add accelerometer code, dingxifeng KF14049, 2009-5-9 end */
if (!gs->use_irq) {
hrtimer_init(&gs->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
gs->timer.function = gs_timer_func;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
gs->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
gs->early_suspend.suspend = gs_early_suspend;
gs->early_suspend.resume = gs_late_resume;
register_early_suspend(&gs->early_suspend);
#endif
gs_wq = create_singlethread_workqueue("gs_wq");
if (!gs_wq)
return -ENOMEM;
/*BK4D00263, add for misc devices, dingxifeng KF14049, 2009-5-20begin */
#if 0
else
GS_SENSOR_ADI_FLAG =1;
#endif
this_gs_data =gs;
/*BK4D00263, add for misc devices, dingxifeng KF14049, 2009-5-20 end */
printk(KERN_INFO "gs_probe: Start gs_adixl345 in %s mode\n", gs->use_irq ? "interrupt" : "polling");
return 0;
/*BK4D00263, add for misc devices, dingxifeng KF14049, 2009-5-20 begin */
err_misc_device_register_failed:
misc_deregister(&gsensor_device);
err_input_register_device_failed:
input_free_device(gs->input_dev);
err_input_dev_alloc_failed:
/*BK4D00263, add for misc devices, dingxifeng KF14049, 2009-5-20 end */
err_detect_failed:
kfree(gs);
#ifndef GS_POLLING
gs_free_int1();
gs_free_int2();
#endif
err_alloc_data_failed:
err_check_functionality_failed:
if (vreg_gp4!=NULL)
{
rc = vreg_disable(vreg_gp4);
if (rc) {
printk("%s: vreg_gp4 vreg_enable failed \n", __func__);
return rc;
}
}
return ret;
}
static int wacom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct wacom_g5_platform_data *pdata;
struct wacom_i2c *wac_i2c;
struct input_dev *input;
int ret = 0;
int error;
int fw_ver;
/*Check I2C functionality */
ret = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
if (!ret) {
printk(KERN_ERR "%s: No I2C functionality found\n", __func__);
ret = -ENODEV;
goto err_i2c_fail;
}
/*Obtain kernel memory space for wacom i2c */
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct wacom_g5_platform_data), GFP_KERNEL);
if (!pdata) {
dev_err(&client->dev,
"%s: Failed to allocate memory\n",
__func__);
return -ENOMEM;
}
error = wacom_parse_dt(&client->dev, pdata);
if (error)
return error;
} else {
pdata = client->dev.platform_data;
if (pdata == NULL) {
dev_err(&client->dev, "%s: no pdata\n", __func__);
ret = -ENODEV;
goto err_i2c_fail;
}
}
wacom_connect_platform_data(pdata);
wacom_request_gpio(pdata);
wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL);
if (NULL == wac_i2c) {
dev_err(&client->dev,
"%s: failed to allocate wac_i2c.\n",
__func__);
ret = -ENOMEM;
goto err_i2c_fail;
}
wac_i2c->client_boot = i2c_new_dummy(client->adapter,
WACOM_I2C_BOOT);
if (!wac_i2c->client_boot) {
dev_err(&client->dev, "Fail to register sub client[0x%x]\n",
WACOM_I2C_BOOT);
}
input = input_allocate_device();
if (NULL == input) {
dev_err(&client->dev,
"%s: failed to allocate input device.\n",
__func__);
ret = -ENOMEM;
goto err_freemem;
}
wacom_i2c_set_input_values(client, wac_i2c, input);
wac_i2c->wac_feature = &wacom_feature_EMR;
wac_i2c->wac_pdata = pdata;
wac_i2c->input_dev = input;
wac_i2c->client = client;
client->irq = gpio_to_irq(pdata->gpio_int);
printk(KERN_ERR "%s: wacom : gpio_to_irq : %d\n",
__func__, client->irq);
wac_i2c->irq = client->irq;
/*Set client data */
i2c_set_clientdata(client, wac_i2c);
i2c_set_clientdata(wac_i2c->client_boot, wac_i2c);
#ifdef WACOM_PDCT_WORK_AROUND
wac_i2c->irq_pdct = gpio_to_irq(pdata->gpio_pen_pdct);
wac_i2c->pen_pdct = PDCT_NOSIGNAL;
#endif
#ifdef WACOM_PEN_DETECT
wac_i2c->gpio_pen_insert = pdata->gpio_pen_insert;
wac_i2c->irq_pen_insert = gpio_to_irq(wac_i2c->gpio_pen_insert);
#endif
#ifdef WACOM_IMPORT_FW_ALGO
wac_i2c->use_offset_table = true;
wac_i2c->use_aveTransition = false;
#endif
#ifdef USE_WACOM_CALLBACK
/*Register callbacks */
wac_i2c->callbacks.check_prox = wacom_check_emr_prox;
if (wac_i2c->wac_pdata->register_cb)
wac_i2c->wac_pdata->register_cb(&wac_i2c->callbacks);
#endif
#ifdef CONFIG_SEC_VIENNA_PROJECT
if (system_rev >= WACOM_BOOT_REVISION) {
wac_i2c->wac_pdata->ic_mpu_ver = MPU_W9007;
wac_i2c->boot_ver = 0x92;
}
#endif
#ifdef CONFIG_SEC_LT03_PROJECT
wac_i2c->boot_ver = 0x92;
#endif
if (wac_i2c->wac_pdata->ic_mpu_ver > 0) {
wac_i2c->ic_mpu_ver = wac_i2c->wac_pdata->ic_mpu_ver;
wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, false);
wac_i2c->wac_pdata->wacom_start(wac_i2c);
msleep(200);
} else {
wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, true);
/*Reset */
wac_i2c->wac_pdata->wacom_start(wac_i2c);
msleep(200);
ret = wacom_check_mpu_version(wac_i2c);
if (ret == -ETIMEDOUT)
#if defined(CONFIG_SEC_H_PROJECT) || defined(CONFIG_SEC_FRESCO_PROJECT)
goto err_wacom_i2c_send_timeout;
#else
pr_err("[E-PEN] wacom_i2c_send failed.\n");
#endif
wac_i2c->ic_mpu_ver = wacom_check_flash_mode(wac_i2c, BOOT_MPU);
dev_info(&wac_i2c->client->dev,
"%s: mpu version: %x\n", __func__, ret);
if (wac_i2c->ic_mpu_ver == MPU_W9001)
wac_i2c->client_boot = i2c_new_dummy(client->adapter,
WACOM_I2C_9001_BOOT);
else if (wac_i2c->ic_mpu_ver == MPU_W9007) {
ret = wacom_enter_bootloader(wac_i2c);
if (ret < 0) {
dev_info(&wac_i2c->client->dev,
"%s: failed to get BootLoader version, %d\n", __func__, ret);
goto err_wacom_i2c_bootloader_ver;
} else {
dev_info(&wac_i2c->client->dev,
"%s: BootLoader version: %x\n", __func__, ret);
}
}
wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, false);
wac_i2c->wac_pdata->reset_platform_hw(wac_i2c);
wac_i2c->power_enable = true;
}
/* Firmware Feature */
wacom_i2c_init_firm_data();
pr_err("%s: wacon ic turn on\n", __func__);
fw_ver = wacom_i2c_query(wac_i2c);
wacom_init_abs_params(wac_i2c);
input_set_drvdata(input, wac_i2c);
/*Initializing for semaphor */
mutex_init(&wac_i2c->lock);
#if defined(CONFIG_SEC_LT03_PROJECT) || defined(CONFIG_SEC_VIENNA_PROJECT)
mutex_init(&wac_i2c->irq_lock);
#endif
#ifdef WACOM_BOOSTER
wacom_init_dvfs(wac_i2c);
#endif
INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work);
#ifdef USE_WACOM_BLOCK_KEYEVENT
INIT_DELAYED_WORK(&wac_i2c->touch_pressed_work, wacom_i2c_touch_pressed_work);
wac_i2c->key_delay_time = 100;
#endif
#ifdef USE_WACOM_LCD_WORKAROUND
wac_i2c->wait_done = true;
wac_i2c->delay_time = 5;
INIT_DELAYED_WORK(&wac_i2c->read_vsync_work, wacom_i2c_read_vsync_work);
wac_i2c->boot_done = false;
INIT_DELAYED_WORK(&wac_i2c->boot_done_work, wacom_i2c_boot_done_work);
#endif
#ifdef WACOM_PEN_DETECT
INIT_DELAYED_WORK(&wac_i2c->pen_insert_dwork, pen_insert_work);
#endif
#ifdef WACOM_RESETPIN_DELAY
INIT_DELAYED_WORK(&wac_i2c->work_wacom_reset, wacom_reset);
#endif
/*Before registering input device, data in each input_dev must be set */
ret = input_register_device(input);
if (ret) {
pr_err("[E-PEN] failed to register input device.\n");
goto err_input_allocate_device;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
wac_i2c->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
wac_i2c->early_suspend.suspend = wacom_i2c_early_suspend;
wac_i2c->early_suspend.resume = wacom_i2c_late_resume;
register_early_suspend(&wac_i2c->early_suspend);
#endif
wac_i2c->dev = device_create(sec_class, NULL, 0, NULL, "sec_epen");
if (IS_ERR(wac_i2c->dev)) {
dev_err(&wac_i2c->client->dev,
"%s: Failed to create device(wac_i2c->dev)!\n",
__func__);
goto err_sysfs_create_group;
}
dev_set_drvdata(wac_i2c->dev, wac_i2c);
ret = sysfs_create_group(&wac_i2c->dev->kobj, &epen_attr_group);
if (ret) {
dev_err(&wac_i2c->client->dev,
"%s: failed to create sysfs group\n",
__func__);
goto err_sysfs_create_group;
}
ret = wacom_firmware_update(wac_i2c);
if (ret) {
dev_err(&wac_i2c->client->dev,
"%s: firmware update failed.\n",
__func__);
if (fw_ver > 0 && wac_i2c->ic_mpu_ver < 0)
dev_err(&wac_i2c->client->dev,
"%s: read query but not enter boot mode[%x,%x]\n",
__func__, fw_ver, wac_i2c->ic_mpu_ver);
else
goto err_fw_update;
}
/*Request IRQ */
if (pdata->irq_flags) {
ret =
request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt,
IRQF_DISABLED | pdata->irq_flags |
IRQF_ONESHOT, wac_i2c->name, wac_i2c);
if (ret < 0) {
dev_err(&wac_i2c->client->dev,
"%s: failed to request irq(%d) - %d\n",
__func__, wac_i2c->irq, ret);
goto err_fw_update;
}
#if defined(WACOM_PDCT_WORK_AROUND)
ret = request_threaded_irq(wac_i2c->irq_pdct, NULL,
wacom_interrupt_pdct,
IRQF_DISABLED | IRQF_TRIGGER_RISING |
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
wac_i2c->name, wac_i2c);
if (ret < 0) {
dev_err(&wac_i2c->client->dev,
"%s: failed to request irq(%d) - %d\n",
__func__, wac_i2c->irq_pdct, ret);
goto err_request_irq_pdct;
}
#endif
#ifdef WACOM_PEN_DETECT
ret = request_threaded_irq(
wac_i2c->irq_pen_insert, NULL,
wacom_pen_detect,
IRQF_DISABLED | IRQF_TRIGGER_RISING |
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
"pen_insert", wac_i2c);
if (ret < 0) {
dev_err(&wac_i2c->client->dev,
"%s: failed to request irq(%d) - %d\n",
__func__, wac_i2c->irq_pen_insert, ret);
goto err_request_irq_pen_inster;
}
enable_irq_wake(wac_i2c->irq_pen_insert);
/* update the current status */
schedule_delayed_work(&wac_i2c->pen_insert_dwork, HZ / 2);
#endif
}
#ifdef USE_WACOM_LCD_WORKAROUND
schedule_delayed_work(&wac_i2c->boot_done_work,
msecs_to_jiffies(20 * 1000));
#endif
#ifdef WACOM_RESETPIN_DELAY
schedule_delayed_work(&wac_i2c->work_wacom_reset, msecs_to_jiffies(5000));
#endif
return 0;
err_request_irq_pen_inster:
#ifdef WACOM_PDCT_WORK_AROUND
free_irq(wac_i2c->irq_pdct, wac_i2c);
err_request_irq_pdct:
#endif
free_irq(wac_i2c->irq, wac_i2c);
err_fw_update:
sysfs_remove_group(&wac_i2c->dev->kobj, &epen_attr_group);
err_sysfs_create_group:
wac_i2c->init_fail = true;
input_unregister_device(input);
err_input_allocate_device:
cancel_delayed_work_sync(&wac_i2c->resume_work);
cancel_delayed_work_sync(&wac_i2c->touch_pressed_work);
#ifdef USE_WACOM_LCD_WORKAROUND
cancel_delayed_work_sync(&wac_i2c->read_vsync_work);
cancel_delayed_work_sync(&wac_i2c->boot_done_work);
#endif
cancel_delayed_work_sync(&wac_i2c->pen_insert_dwork);
#ifdef WACOM_RESETPIN_DELAY
cancel_delayed_work_sync(&wac_i2c->work_wacom_reset);
#endif
#ifdef WACOM_BOOSTER
cancel_delayed_work_sync(&wac_i2c->work_dvfs_off);
cancel_delayed_work_sync(&wac_i2c->work_dvfs_chg);
mutex_destroy(&wac_i2c->dvfs_lock);
#endif
wac_i2c->wac_pdata->wacom_stop(wac_i2c);
mutex_destroy(&wac_i2c->lock);
err_wacom_i2c_bootloader_ver:
#if defined(CONFIG_SEC_H_PROJECT) || defined(CONFIG_SEC_FRESCO_PROJECT)
err_wacom_i2c_send_timeout:
#endif
input_free_device(input);
err_freemem:
kfree(wac_i2c);
err_i2c_fail:
return ret;
}
static int __devinit fsa9485_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct fsa9485_usbsw *usbsw;
int ret = 0;
struct input_dev *input;
struct device *switch_dev;
struct fsa9485_platform_data *pdata;
dev_info(&client->dev, "%s\n", __func__);
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct fsa9485_platform_data), GFP_KERNEL);
if (!pdata) {
dev_err(&client->dev, "Failed to allocate memory\n");
return -ENOMEM;
}
pdata = &fsa9485_pdata;
fsa9485_parse_dt(&client->dev, pdata);
client->irq = gpio_to_irq(pdata->gpio_int);
} else
pdata = client->dev.platform_data;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
input = input_allocate_device();
if (!input) {
dev_err(&client->dev, "failed to allocate input device data\n");
return -ENOMEM;
}
usbsw = kzalloc(sizeof(struct fsa9485_usbsw), GFP_KERNEL);
if (!usbsw) {
dev_err(&client->dev, "failed to allocate driver data\n");
input_free_device(input);
return -ENOMEM;
}
usbsw->input = input;
input->name = client->name;
input->phys = "deskdock-key/input0";
input->dev.parent = &client->dev;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0001;
/* Enable auto repeat feature of Linux input subsystem */
__set_bit(EV_REP, input->evbit);
input_set_capability(input, EV_KEY, KEY_VOLUMEUP);
input_set_capability(input, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(input, EV_KEY, KEY_PLAYPAUSE);
input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG);
input_set_capability(input, EV_KEY, KEY_NEXTSONG);
ret = input_register_device(input);
if (ret) {
dev_err(&client->dev,
"input_register_device %s: err %d\n", __func__, ret);
input_free_device(input);
kfree(usbsw);
return ret;
}
usbsw->client = client;
usbsw->pdata = pdata;
if (!usbsw->pdata)
goto fail1;
#if !defined(CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK)
usbsw->is_factory_start = false;
#endif /* !CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK */
i2c_set_clientdata(client, usbsw);
mutex_init(&usbsw->mutex);
local_usbsw = usbsw;
if (usbsw->pdata->cfg_gpio)
usbsw->pdata->cfg_gpio();
fsa9485_reg_init(usbsw);
uart_connecting = 0;
ret = sysfs_create_group(&client->dev.kobj, &fsa9485_group);
if (ret) {
dev_err(&client->dev,
"failed to create fsa9485 attribute group\n");
goto fail2;
}
/* make sysfs node /sys/class/sec/switch/usb_state */
switch_dev = device_create(sec_class, NULL, 0, NULL, "switch");
if (IS_ERR(switch_dev)) {
pr_err("[FSA9485] Failed to create device (switch_dev)!\n");
ret = PTR_ERR(switch_dev);
goto fail2;
}
ret = device_create_file(switch_dev, &dev_attr_usb_state);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (usb_state)!\n");
goto err_create_file_state;
}
ret = device_create_file(switch_dev, &dev_attr_adc);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (adc)!\n");
goto err_create_file_adc;
}
ret = device_create_file(switch_dev, &dev_attr_reset_switch);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (reset_switch)!\n");
goto err_create_file_reset_switch;
}
#if !defined(CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK)
ret = device_create_file(switch_dev, &dev_attr_apo_factory);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (apo_factory)!\n");
goto err_create_file_apo_factory;
}
#endif
dev_set_drvdata(switch_dev, usbsw);
/* fsa9485 dock init*/
if (usbsw->pdata->dock_init)
usbsw->pdata->dock_init();
/* fsa9485 reset */
if (usbsw->pdata->reset_cb)
usbsw->pdata->reset_cb();
/* set fsa9485 init flag. */
if (usbsw->pdata->set_init_flag)
usbsw->pdata->set_init_flag();
local_usbsw->dock_ready = 0;
local_usbsw->mhl_ready = 0;
/* initial cable detection */
INIT_DELAYED_WORK(&usbsw->init_work, fsa9485_init_detect);
schedule_delayed_work(&usbsw->init_work, msecs_to_jiffies(2700));
INIT_DELAYED_WORK(&usbsw->audio_work, fsa9485_delayed_audio);
schedule_delayed_work(&usbsw->audio_work, msecs_to_jiffies(20000));
#if defined(CONFIG_VIDEO_MHL_V1) || defined(CONFIG_VIDEO_MHL_V2)
INIT_WORK(&usbsw->mhl_work, fsa9485_mhl_detect);
#endif
return 0;
#if !defined(CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK)
err_create_file_apo_factory:
device_remove_file(switch_dev, &dev_attr_apo_factory);
#endif
err_create_file_reset_switch:
device_remove_file(switch_dev, &dev_attr_reset_switch);
err_create_file_adc:
device_remove_file(switch_dev, &dev_attr_adc);
err_create_file_state:
device_remove_file(switch_dev, &dev_attr_usb_state);
fail2:
if (client->irq)
free_irq(client->irq, usbsw);
fail1:
input_unregister_device(input);
mutex_destroy(&usbsw->mutex);
i2c_set_clientdata(client, NULL);
input_free_device(input);
kfree(usbsw);
return ret;
}
static int __init ami304_probe(struct i2c_client *client, const struct i2c_device_id * devid)
{
int err = 0;
struct ami304_i2c_data *data;
struct ecom_platform_data* ecom_pdata;
if (AMI304_DEBUG_FUNC_TRACE & ami304_debug_mask)
AMID("motion start....!\n");
if(!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
AMIE("adapter can NOT support I2C_FUNC_I2C.\n");
return -ENODEV;
}
if (!(data = kmalloc(sizeof(struct ami304_i2c_data), GFP_KERNEL))) {
err = -ENOMEM;
goto exit;
}
memset(data, 0, sizeof(struct ami304_i2c_data));
i2c_set_clientdata(client, data);
ami304_i2c_client = client;
ecom_pdata = ami304_i2c_client->dev.platform_data;
ecom_pdata->power(1);
AMI304_Init(AMI304_FORCE_MODE); // default is Force State
atomic_set(&o_status, 0);
atomic_set(&m_status, 0);
atomic_set(&a_status, 0);
#if defined(CONFIG_HAS_EARLYSUSPEND)
ami304_sensor_early_suspend.suspend = ami304_early_suspend;
ami304_sensor_early_suspend.resume = ami304_late_resume;
register_early_suspend(&ami304_sensor_early_suspend);
atomic_set(&ami304_report_enabled, 1);
#endif
data->input_dev = input_allocate_device();
if (!data->input_dev) {
err = -ENOMEM;
AMIE("ami304_i2c_detect: Failed to allocate input device\n");
goto exit_input_dev_alloc_failed;
}
set_bit(EV_ABS, data->input_dev->evbit);
/* yaw */
input_set_abs_params(data->input_dev, ABS_RX, 0, 360, 0, 0);
/* pitch */
input_set_abs_params(data->input_dev, ABS_RY, -180, 180, 0, 0);
/* roll */
input_set_abs_params(data->input_dev, ABS_RZ, -90, 90, 0, 0);
/* status of magnetic sensor */
input_set_abs_params(data->input_dev, ABS_RUDDER, 0, 5, 0, 0);
/* x-axis acceleration */
input_set_abs_params(data->input_dev, ABS_X, -2000, 2000, 0, 0);
/* y-axis acceleration */
input_set_abs_params(data->input_dev, ABS_Y, -2000, 2000, 0, 0);
/* z-axis acceleration */
input_set_abs_params(data->input_dev, ABS_Z, -2000, 2000, 0, 0);
/* x-axis of raw magnetic vector */
input_set_abs_params(data->input_dev, ABS_HAT0X, -3000, 3000, 0, 0);
/* y-axis of raw magnetic vector */
input_set_abs_params(data->input_dev, ABS_HAT0Y, -3000, 3000, 0, 0);
/* z-axis of raw magnetic vector */
input_set_abs_params(data->input_dev, ABS_BRAKE, -3000, 3000, 0, 0);
/* status of acceleration sensor */
input_set_abs_params(data->input_dev, ABS_WHEEL, 0, 5, 0, 0);
data->input_dev->name = "Acompass";
err = input_register_device(data->input_dev);
if (err) {
AMIE("ami304_i2c_detect: Unable to register input device: %s\n",
data->input_dev->name);
goto exit_input_register_device_failed;
}
if (AMI304_DEBUG_FUNC_TRACE & ami304_debug_mask)
AMID("register input device successfully!!!\n");
err = misc_register(&ami304_device);
if (err) {
AMIE("ami304_device register failed\n");
goto exit_misc_device_register_failed;
}
err = device_create_file(&client->dev, &dev_attr_chipinfo);
err = device_create_file(&client->dev, &dev_attr_sensordata);
err = device_create_file(&client->dev, &dev_attr_posturedata);
err = device_create_file(&client->dev, &dev_attr_calidata);
err = device_create_file(&client->dev, &dev_attr_midcontrol);
err = device_create_file(&client->dev, &dev_attr_mode);
/* Test mode attribute */
err = device_create_file(&client->dev, &dev_attr_pitch);
err = device_create_file(&client->dev, &dev_attr_roll);
err = misc_register(&ami304daemon_device);
if (err) {
AMIE("ami304daemon_device register failed\n");
goto exit_misc_device_register_failed;
}
err = misc_register(&ami304hal_device);
if (err) {
AMIE("ami304hal_device register failed\n");
goto exit_misc_device_register_failed;
}
return 0;
exit_misc_device_register_failed:
exit_input_register_device_failed:
input_free_device(data->input_dev);
exit_input_dev_alloc_failed:
kfree(data);
exit:
return err;
}
/**
* ctp_detect - Device detection callback for automatic device creation
* return value:
* = 0; success;
* < 0; err
*/
static int ctp_detect(struct i2c_client *client, struct i2c_board_info *info)
{
struct i2c_adapter *adapter = client->adapter;
int ret;
u8 buf[8] = {GTP_REG_VERSION >> 8, GTP_REG_VERSION & 0xff};
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)){
pr_err("i2c_check_functionality err\n======return=====\n");
return -ENODEV;
}
if(twi_id == adapter->nr){
pr_debug("%s: addr= %x\n",__func__,client->addr);
msleep(50);
ret = gtp_i2c_read(client, buf, 6);
gtp_i2c_end_cmd(client);
if(buf[3] != 0x18)
{
pr_debug("%s:IC is not gt818\n",__func__);
return -ENODEV;
}
GTP_INFO("IC VERSION:%02x%02x_%02x%02x", buf[3], buf[2], buf[5], buf[4]);
strlcpy(info->type, CTP_NAME, I2C_NAME_SIZE);
//printk("%s:I2C connection might be something wrong ! \n",__func__);
return 0;
}else{
return -ENODEV;
}
}
/**
* ctp_print_info - sysconfig print function
* return value:
*
*/
static void ctp_print_info(struct ctp_config_info info,int debug_level)
{
if(debug_level == DEBUG_INIT)
{
dprintk(DEBUG_INIT,"info.ctp_used:%d\n",info.ctp_used);
dprintk(DEBUG_INIT,"info.twi_id:%d\n",info.twi_id);
dprintk(DEBUG_INIT,"info.screen_max_x:%d\n",info.screen_max_x);
dprintk(DEBUG_INIT,"info.screen_max_y:%d\n",info.screen_max_y);
dprintk(DEBUG_INIT,"info.revert_x_flag:%d\n",info.revert_x_flag);
dprintk(DEBUG_INIT,"info.revert_y_flag:%d\n",info.revert_y_flag);
dprintk(DEBUG_INIT,"info.exchange_x_y_flag:%d\n",info.exchange_x_y_flag);
dprintk(DEBUG_INIT,"info.irq_gpio_number:%d\n",info.irq_gpio.gpio);
dprintk(DEBUG_INIT,"info.wakeup_gpio_number:%d\n",info.wakeup_gpio.gpio);
}
}
/**
* ctp_wakeup - function
*
*/
static int ctp_wakeup(int status,int ms)
{
dprintk(DEBUG_INIT,"***CTP*** %s:status:%d,ms = %d\n",__func__,status,ms);
if (status == 0) {
if(ms == 0) {
__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
}else {
__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
msleep(ms);
__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
}
}
if (status == 1) {
if(ms == 0) {
__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
}else {
__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
msleep(ms);
__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
}
}
msleep(5);
return 0;
}
static __devinit int adv7180_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct adv7180_state *state;
struct v4l2_subdev *sd;
int ret;
/* Check if the adapter supports the needed features */
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
v4l_info(client, "chip found @ 0x%02x (%s)\n",
client->addr << 1, client->adapter->name);
state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL);
if (state == NULL) {
ret = -ENOMEM;
goto err;
}
state->irq = client->irq;
INIT_WORK(&state->work, adv7180_work);
mutex_init(&state->mutex);
state->autodetect = true;
sd = &state->sd;
v4l2_i2c_subdev_init(sd, client, &adv7180_ops);
/* Initialize adv7180 */
/* Enable autodetection */
ret = i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG,
ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM);
if (ret < 0)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_AUTODETECT_ENABLE_REG,
ADV7180_AUTODETECT_DEFAULT);
if (ret < 0)
goto err_unreg_subdev;
/* ITU-R BT.656-4 compatible */
ret = i2c_smbus_write_byte_data(client,
ADV7180_EXTENDED_OUTPUT_CONTROL_REG,
ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS);
if (ret < 0)
goto err_unreg_subdev;
/* read current norm */
__adv7180_status(client, NULL, &state->curr_norm);
/* register for interrupts */
if (state->irq > 0) {
ret = request_irq(state->irq, adv7180_irq, 0, DRIVER_NAME,
state);
if (ret)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
ADV7180_ADI_CTRL_IRQ_SPACE);
if (ret < 0)
goto err_unreg_subdev;
/* config the Interrupt pin to be active low */
ret = i2c_smbus_write_byte_data(client, ADV7180_ICONF1_ADI,
ADV7180_ICONF1_ACTIVE_LOW | ADV7180_ICONF1_PSYNC_ONLY);
if (ret < 0)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR1_ADI, 0);
if (ret < 0)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR2_ADI, 0);
if (ret < 0)
goto err_unreg_subdev;
/* enable AD change interrupts interrupts */
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR3_ADI,
ADV7180_IRQ3_AD_CHANGE);
if (ret < 0)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR4_ADI, 0);
if (ret < 0)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
0);
if (ret < 0)
goto err_unreg_subdev;
}
return 0;
err_unreg_subdev:
mutex_destroy(&state->mutex);
v4l2_device_unregister_subdev(sd);
kfree(state);
err:
printk(KERN_ERR DRIVER_NAME ": Failed to probe: %d\n", ret);
return ret;
}
static int rt9450_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err;
struct rt9450_data* drv_data;
INFO("RT9450 irq # = %d\n",client->irq);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
{
ERR("No Support for I2C_FUNC_SMBUS_BYTE_DATA\n");
err = -ENODEV;
goto i2c_check_functionality_fail;
}
drv_data = kzalloc(sizeof(struct rt9450_data),GFP_KERNEL);
drv_data->client = client;
pDrvData = drv_data;
i2c_set_clientdata(client,drv_data);
if (client->dev.platform_data)
memcpy(&platform_data,client->dev.platform_data,sizeof(struct rtsmc_platform_data));
else
memset(&platform_data,0,sizeof(struct rtsmc_platform_data));
INIT_DELAYED_WORK_DEFERRABLE(&drv_data->rt9450_charger_work,rt9450_charger_work);
#if CONFIG_RTSMC_IRQ_NUMBER<0
client->irq = gpio_to_irq(CONFIG_RTSMC_INT_GPIO_NUMBER);
#endif
#ifdef CONFIG_RTSMC_INT_CONFIG
INFO("gpio pin # = %d\n",(int)CONFIG_RTSMC_INT_GPIO_NUMBER);
err = gpio_request(CONFIG_RTSMC_INT_GPIO_NUMBER,"RT9450_EINT"); // Request for gpio pin
if (err<0)
WARNING("Request GPIO %d failed\n",(int)CONFIG_RTSMC_INT_GPIO_NUMBER);
err = gpio_direction_input(CONFIG_RTSMC_INT_GPIO_NUMBER);
if (err<0)
WARNING("Set GPIO Direction to input : failed\n");
#endif // CONFIG_RTMUSC_INT_CONFIG
if (!init_reg_setting())
{
err = -EINVAL;
goto init_fail;
}
#ifdef CONFIG_RT_SYSFS_DBG
err = sysfs_create_group(&client->dev.kobj, &rt9450_dbg_attrs_group);
if (err<0)
{
WARNING("Can't create engineer debug node), error code = %d\r\n",err);
}
#endif //CONFIG_RT_SYSFS_DBG
err = request_irq(client->irq, rt9450smc_irq_handler, IRQF_TRIGGER_FALLING, DEVICE_NAME, drv_data);
if (err<0)
{
WARNING("Can't use INT (use polling only), error code = %d\r\n",err);
}
return 0;
init_fail:
cancel_delayed_work(&drv_data->rt9450_charger_work);
kfree(pDrvData);
pDrvData = NULL;
i2c_check_functionality_fail:
return err;
}
static int lm3554_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct lm3554_platform_data *pdata = client->dev.platform_data;
struct lm3554_data *torch_data;
int err = -1;
if (pdata == NULL) {
err = -ENODEV;
dev_err(&client->dev, "platform data is NULL. exiting.\n");
goto error1;
}
if (!pdata->flags) {
pr_err("%s: Device does not exist\n", __func__);
return -ENODEV;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
err = -ENODEV;
dev_err(&client->dev, "client not i2c capable\n");
goto error1;
}
torch_data = kzalloc(sizeof(struct lm3554_data), GFP_KERNEL);
if (torch_data == NULL) {
err = -ENOMEM;
dev_err(&client->dev, "kzalloc failed\n");
goto error1;
}
torch_data->client = client;
torch_data->pdata = pdata;
i2c_set_clientdata(client, torch_data);
err = lm3554_init_registers(torch_data);
if (err < 0)
goto error2;
torch_data->led_dev.name = LM3554_LED_DEV;
torch_data->led_dev.brightness_set = lm3554_brightness_set;
err = led_classdev_register((struct device *)
&client->dev, &torch_data->led_dev);
if (err < 0) {
err = -ENODEV;
pr_err("%s: Register led class failed: %d\n", __func__, err);
goto error3;
}
err = device_create_file(torch_data->led_dev.dev,
&dev_attr_flash_light);
if (err < 0) {
err = -ENODEV;
pr_err("%s:File device creation failed: %d\n", __func__, err);
goto error4;
}
err = device_create_file(torch_data->led_dev.dev,
&dev_attr_camera_strobe);
if (err < 0) {
err = -ENODEV;
pr_err("%s:File device creation failed: %d\n", __func__, err);
goto error5;
}
err = device_create_file(torch_data->led_dev.dev,
&dev_attr_strobe_err);
if (err < 0) {
err = -ENODEV;
pr_err("%s:File device creation failed: %d\n", __func__, err);
goto error6;
}
torch_data->spotlight_dev.name = LM3554_LED_SPOTLIGHT;
torch_data->spotlight_dev.brightness_set =
lm3554_spot_light_brightness_set;
err = led_classdev_register((struct device *)
&client->dev, &torch_data->spotlight_dev);
if (err < 0) {
err = -ENODEV;
pr_err("%s: Register led class failed: %d\n", __func__, err);
goto error6;
}
pr_info("LM3554 torch initialized\n");
return 0;
error6:
device_remove_file(torch_data->led_dev.dev, &dev_attr_camera_strobe);
error5:
device_remove_file(torch_data->led_dev.dev, &dev_attr_flash_light);
error4:
led_classdev_unregister(&torch_data->led_dev);
error3:
error2:
kfree(torch_data);
error1:
return err;
}
/* This function is called by i2c_probe */
static int bcm3450_detect(struct i2c_adapter *adapter, int address, int kind)
{
struct i2c_client *client;
int err = 0;
#ifdef PROCFS_HOOKS
struct proc_dir_entry *p;
#endif
BCM_LOG_DEBUG(BCM_LOG_ID_I2C, "Entering the function %s \n", __FUNCTION__);
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
goto exit;
if (!(pclient_data = kzalloc(sizeof(struct bcm3450_data), GFP_KERNEL)))
{
err = -ENOMEM;
goto exit;
}
/* Setup the i2c client data */
client = &pclient_data->client;
i2c_set_clientdata(client, pclient_data);
client->addr = address;
client->adapter = adapter;
client->driver = &bcm3450_driver;
client->flags = 0;
strlcpy(client->name, "bcm3450", I2C_NAME_SIZE);
/* Tell the I2C layer a new client has arrived */
if ((err = i2c_attach_client(client)))
goto exit_kfree;
#ifdef SYSFS_HOOKS
/* Register sysfs hooks */
err = sysfs_create_group(&client->dev.kobj, &bcm3450_attr_group);
if (err)
goto exit_detach;
#endif
#ifdef PROCFS_HOOKS
p = create_proc_entry(PROC_ENTRY_NAME1, 0, 0);
if (!p) {
BCM_LOG_ERROR(BCM_LOG_ID_I2C, "bcmlog: unable to create /proc/%s!\n",
PROC_ENTRY_NAME1);
err = -EIO;
#ifdef SYSFS_HOOKS
sysfs_remove_group(&client->dev.kobj, &bcm3450_attr_group);
#endif
goto exit_detach;
}
p->read_proc = b3450_proc_read;
p->write_proc = b3450_proc_write;
p->data = (void *)pclient_data;
#ifdef MOCA_I2C_TEST
p = create_proc_entry(PROC_ENTRY_NAME2, 0, 0);
if (p) {
p->proc_fops = &b3450Test_fops;
}
#endif
#endif
return 0;
#if defined(SYSFS_HOOKS) || defined(PROCFS_HOOKS)
exit_detach:
i2c_detach_client(client);
#endif
exit_kfree:
kfree(pclient_data);
exit:
return err;
}
static int gs_probe(
struct i2c_client *client, const struct i2c_device_id *id)
{
int ret;
struct gs_data *gs;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
printk(KERN_ERR "gs_probe: need I2C_FUNC_I2C\n");
ret = -ENODEV;
goto err_check_functionality_failed;
}
#ifndef GS_POLLING
ret = gs_config_int1_pin();
if(ret <0)
{
goto err_check_functionality_failed;
}
ret = gs_config_int2_pin();
if(ret <0)
{
goto err_check_functionality_failed;
}
#endif
gs = kzalloc(sizeof(*gs), GFP_KERNEL);
if (gs == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
mutex_init(&gs->mlock);
INIT_WORK(&gs->work, gs_work_func);
gs->client = client;
i2c_set_clientdata(client, gs);
ret =reg_read(gs,GS_ADI_REG_DEVID);
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_POWER_CTL,0x14); /* auto low power ,deep sleep */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_BW,0x0a); /* Rate: 100Hz, IDD: 130uA */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_DATA_FORMAT,0x01); /* Data Format: 8g right justified 128=1g 8g*/
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_INT_ENABLE,0x80); /* enable int Int En: Data Rdy*/
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_TAP_AXES,0x01); /* Z Axis Tap */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_THRESH_TAP,0x20); /* Tap Threshold: 2G */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_DUR,0x50); /* Dur:50ms */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_LATENT,0x20); /* Latent: 40ms */
if ( ret <0 )
goto err_detect_failed;
ret = reg_write(gs,GS_ADI_REG_WINDOW,0xF0); /* Window: 300ms */
if ( ret <0 )
goto err_detect_failed;
if (sensor_dev == NULL)
{
gs->input_dev = input_allocate_device();
if (gs->input_dev == NULL) {
ret = -ENOMEM;
printk(KERN_ERR "gs_probe: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
gs->input_dev->name = "sensors";
sensor_dev = gs->input_dev;
}else{
gs->input_dev = sensor_dev;
}
gs->input_dev->id.vendor = GS_ADIX345;//for akm8973 compass detect.
set_bit(EV_ABS,gs->input_dev->evbit);
set_bit(ABS_X, gs->input_dev->absbit);
set_bit(ABS_Y, gs->input_dev->absbit);
set_bit(ABS_Z, gs->input_dev->absbit);
set_bit(EV_SYN,gs->input_dev->evbit);
gs->input_dev->id.bustype = BUS_I2C;
//gs->input_dev->open = gs_adi_input_open;
//gs->input_dev->close = gs_adi_input_close;
input_set_drvdata(gs->input_dev, gs);
ret = input_register_device(gs->input_dev);
if (ret) {
printk(KERN_ERR "gs_probe: Unable to register %s input device\n", gs->input_dev->name);
goto err_input_register_device_failed;
}
ret = misc_register(&gsensor_device);
if (ret) {
printk(KERN_ERR "gs_probe: gsensor_device register failed\n");
goto err_misc_device_register_failed;
}
#ifndef GS_POLLING
if (client->irq) {
ret = request_irq(client->irq, gs_irq_handler, 0, client->name, gs);
if (ret == 0)
gs->use_irq = 1;
else
dev_err(&client->dev, "request_irq failed\n");
}
#endif
if (!gs->use_irq) {
hrtimer_init(&gs->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
gs->timer.function = gs_timer_func;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
gs->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
gs->early_suspend.suspend = gs_early_suspend;
gs->early_suspend.resume = gs_late_resume;
register_early_suspend(&gs->early_suspend);
#endif
gs_wq = create_singlethread_workqueue("gs_wq");
if (!gs_wq)
return -ENOMEM;
#if 0
else
GS_SENSOR_ADI_FLAG =1;
#endif
this_gs_data =gs;
printk(KERN_INFO "gs_probe: Start gs_adixl345 in %s mode\n", gs->use_irq ? "interrupt" : "polling");
return 0;
err_misc_device_register_failed:
misc_deregister(&gsensor_device);
err_input_register_device_failed:
input_free_device(gs->input_dev);
err_input_dev_alloc_failed:
err_detect_failed:
kfree(gs);
#ifndef GS_POLLING
gs_free_int1();
gs_free_int2();
#endif
err_alloc_data_failed:
err_check_functionality_failed:
return ret;
}
static int __devinit lm2755_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret;
int error;
struct lm2755_data *data;
struct lm2755_platform_data *pdata = NULL;
uint32_t min_tstep;
#ifdef CONFIG_OF
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct lm2755_platform_data), GFP_KERNEL);
if (!pdata) {
dev_err(&client->dev, "Failed to allocate memory\n");
return -ENOMEM;
} else {
data = devm_kzalloc(&client->dev,
sizeof(*data), GFP_KERNEL);
if (!data) {
pr_err("unable to kzalloc lm2755_data\n");
return -ENOMEM;
}
}
error = lm2755_parse_dt(&client->dev, pdata);
if (error)
return error;
}
#else
/* We need platform data */
if (!client->dev.platform_data) {
pr_err("no platform data\n");
return -EINVAL;
}
pdata = client->dev.platform_data;
#endif
/* Check I2C functionality */
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_BYTE_DATA)) {
pr_err("I2C_FUNC_SMBUS_BYTE_DATA not supported\n");
return -ENOTSUPP;
}
if (pdata->clock_mode == LM2755_CLOCK_EXT) {
if (pdata->min_tstep == 0) {
pr_err("invalid min_tstep 0 for external clock\n");
return -EINVAL;
} else {
min_tstep = pdata->min_tstep;
}
} else {
min_tstep = LM2755_MIN_TSTEP_INT * 1000;
}
/* Allocate our internal data structure */
data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
if (!data) {
pr_err("unable to kzalloc lm2755_data\n");
return -ENOMEM;
}
i2c_set_clientdata(client, data);
data->client = client;
data->config = pdata->clock_mode | pdata->charge_pump_mode;
/* Save min tstep for external clock */
if (pdata->clock_mode == LM2755_CLOCK_EXT)
data->min_tstep = min_tstep;
lm2755_set_tsteps(data, min_tstep);
pr_info("max_time = %d\n", data->max_time);
data->max_level = pdata->max_level;
if (data->max_level == 0 || data->max_level > LM2755_MAX_LEVEL)
data->max_level = LM2755_MAX_LEVEL;
/* Populate groups */
data->rgb_group[LM2755_D1] = LM2755_D1_BASE;
data->rgb_group[LM2755_D2] = LM2755_D2_BASE;
data->rgb_group[LM2755_D3] = LM2755_D3_BASE;
data->rgb_mask[LM2755_D1] = LM2755_D1_MASK;
data->rgb_mask[LM2755_D2] = LM2755_D2_MASK;
data->rgb_mask[LM2755_D3] = LM2755_D3_MASK;
mutex_init(&data->lock);
data->enable = pdata->enable;
if (data->enable)
data->enable(1);
ret = lm2755_write(data->client, LM2755_REG_GENERAL, data->config);
if (ret < 0) {
pr_err("unable to write to the chip\n");
goto fail1;
}
/* HIGH part of the brightness has power on value 1110b */
/* LOW part of the brightness has power on value 0000b */
lm2755_write(data->client, LM2755_REG_D1_HIGH, 0);
lm2755_write(data->client, LM2755_REG_D2_HIGH, 0);
lm2755_write(data->client, LM2755_REG_D3_HIGH, 0);
/* Register named LEDs */
ret = lm2755_register_leds(data, pdata->led_names);
if (ret < 0) {
pr_err("unable to register leds\n");
goto fail1;
}
/* Register RGB LED class if requested */
if (pdata->rgb_name) {
data->led_cdev.brightness_set = lm2755_rgb_brightness_set;
data->led_cdev.brightness_get = lm2755_rgb_brightness_get;
data->led_cdev.name = pdata->rgb_name;
ret = led_classdev_register(&client->dev, &data->led_cdev);
if (ret < 0) {
pr_err("couldn't register \'%s\' LED class\n",
pdata->rgb_name);
goto fail2;
}
pr_info("registered \'%s\' LED class\n", pdata->rgb_name);
INIT_WORK(&data->rgb_work, lm2755_rgb_work);
ret = sysfs_create_group(&data->led_cdev.dev->kobj,
&lm2755_attribute_group);
if (ret < 0) {
pr_err("couldn't register attribute sysfs group\n");
goto fail3;
}
}
pr_info("finished successfully\n");
return 0;
fail3:
led_classdev_unregister(&data->led_cdev);
fail2:
lm2755_unregister_leds(data);
fail1:
if (data->enable)
data->enable(0);
return ret;
}
static int bma255_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = -ENODEV;
struct bma255_p *data = NULL;
pr_info("##########################################################\n");
pr_info("[SENSOR]: %s - Probe Start!\n", __func__);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("[SENSOR]: %s - i2c_check_functionality error\n",
__func__);
goto exit;
}
data = kzalloc(sizeof(struct bma255_p), GFP_KERNEL);
if (data == NULL) {
pr_err("[SENSOR]: %s - kzalloc error\n", __func__);
ret = -ENOMEM;
goto exit_kzalloc;
}
ret = bma255_parse_dt(data, &client->dev);
if (ret < 0) {
pr_err("[SENSOR]: %s - of_node error\n", __func__);
ret = -ENODEV;
goto exit_of_node;
}
/* read chip id */
ret = i2c_smbus_read_word_data(client, BMA255_CHIP_ID_REG);
#if defined(CONFIG_MACH_CS03_SGLTE)
if ((ret & 0x00ff) != 0x95) {
#else
if ((ret & 0x00ff) != BMA255_CHIP_ID) {
#endif
pr_err("[SENSOR]: %s - chip id failed %d\n", __func__, ret);
ret = -ENODEV;
goto exit_read_chipid;
}
i2c_set_clientdata(client, data);
data->client = client;
bma255_power_on(data, 1);
ret = bma255_setup_pin(data);
if (ret < 0) {
pr_err("[SENSOR]: %s - could not setup pin\n", __func__);
goto exit_setup_pin;
}
/* input device init */
ret = bma255_input_init(data);
if (ret < 0)
goto exit_input_init;
sensors_register(data->factory_device, data, sensor_attrs, MODULE_NAME);
/* workqueue init */
INIT_DELAYED_WORK(&data->work, bma255_work_func);
atomic_set(&data->delay, BMA255_DEFAULT_DELAY);
atomic_set(&data->enable, OFF);
data->time_count = 0;
data->irq_state = 0;
data->recog_flag = OFF;
bma255_set_bandwidth(data->client, BMA255_BW_125HZ);
bma255_set_range(data->client, BMA255_RANGE_2G);
bma255_set_mode(data->client, BMA255_MODE_SUSPEND);
pr_info("[SENSOR]: %s - Probe done!(chip pos : %d)\n",
__func__, data->chip_pos);
return 0;
exit_input_init:
free_irq(data->irq1, data);
wake_lock_destroy(&data->reactive_wake_lock);
gpio_free(data->acc_int2);
gpio_free(data->acc_int1);
exit_read_chipid:
exit_setup_pin:
exit_of_node:
kfree(data);
exit_kzalloc:
exit:
pr_err("[SENSOR]: %s - Probe fail!\n", __func__);
return ret;
}
static int __devexit bma255_remove(struct i2c_client *client)
{
struct bma255_p *data = (struct bma255_p *)i2c_get_clientdata(client);
if (atomic_read(&data->enable) == ON)
bma255_set_enable(data, OFF);
cancel_delayed_work_sync(&data->work);
sensors_unregister(data->factory_device);
//sensors_delete_symlink(data->input->dev);
sysfs_remove_group(&data->input->dev.kobj, &bma255_attribute_group);
input_unregister_device(data->input);
free_irq(data->irq1, data);
wake_lock_destroy(&data->reactive_wake_lock);
gpio_free(data->acc_int2);
gpio_free(data->acc_int1);
kfree(data);
return 0;
}
static int bma255_suspend(struct device *dev)
{
struct bma255_p *data = dev_get_drvdata(dev);
//struct bma255_p *data = bma_acc_get_data();
if (atomic_read(&data->enable) == ON) {
if (data->recog_flag == ON)
bma255_set_mode(data->client, BMA255_MODE_LOWPOWER1);
else
bma255_set_mode(data->client, BMA255_MODE_SUSPEND);
cancel_delayed_work_sync(&data->work);
}
bma255_power_on(data, 0);
return 0;
}
static int bma255_resume(struct device *dev)
{
struct bma255_p *data = dev_get_drvdata(dev);
//struct bma255_p *data = bma_acc_get_data();
bma255_power_on(data, 1);
if (atomic_read(&data->enable) == ON) {
bma255_set_mode(data->client, BMA255_MODE_NORMAL);
schedule_delayed_work(&data->work,
msecs_to_jiffies(atomic_read(&data->delay)));
}
return 0;
}
static struct of_device_id bma255_match_table[] = {
{ .compatible = "bma255-i2c",},
{},
};
static int __devinit bma250_accl_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct drv_data *dd;
int rc = 0;
unsigned char tempvalue;
struct bma250_accl_platform_data *pdata = pdata =
client->dev.platform_data;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality error\n");
goto probe_exit;
}
dd = kzalloc(sizeof(struct drv_data), GFP_KERNEL);
if (!dd) {
rc = -ENOMEM;
goto probe_exit;
}
bma250_accl_client = client;
mutex_lock(&bma250_accl_dd_lock);
list_add_tail(&dd->next_dd, &dd_list);
mutex_unlock(&bma250_accl_dd_lock);
INIT_DELAYED_WORK(&dd->work_data, bma250_accl_work_f);
dd->i2c = client;
if (pdata && pdata->init) {
rc = pdata->init(&client->dev);
if (rc)
goto probe_err_cfg;
}
/* check chip id */
tempvalue = i2c_smbus_read_byte_data(client, BMA250_CHIP_ID_REG);
if (tempvalue == BMA250_CHIP_ID) {
printk(KERN_INFO "Bosch Sensortec Device detected!\n"
"BMA250 registered I2C driver!\n");
} else {
printk(KERN_INFO "Bosch Sensortec Device not found"
"i2c error %d \n", tempvalue);
goto probe_err_cfg;
}
dd->ip_dev = input_allocate_device();
if (!dd->ip_dev) {
rc = -ENOMEM;
goto probe_err_reg;
}
input_set_drvdata(dd->ip_dev, dd);
dd->irq = client->irq;
dd->ip_dev->open = bma250_accl_open;
dd->ip_dev->close = bma250_accl_release;
dd->ip_dev->name = ACCL_NAME;
dd->ip_dev->phys = ACCL_NAME;
dd->ip_dev->id.vendor = ACCL_VENDORID;
dd->ip_dev->id.product = 1;
dd->ip_dev->id.version = 1;
set_bit(EV_REL, dd->ip_dev->evbit);
set_bit(REL_X, dd->ip_dev->relbit);
set_bit(REL_Y, dd->ip_dev->relbit);
set_bit(REL_Z, dd->ip_dev->relbit);
rc = input_register_device(dd->ip_dev);
if (rc) {
dev_err(&dd->ip_dev->dev,
"bma250_accl_probe: input_register_device rc=%d\n", rc);
goto probe_err_reg_dev;
}
rc = misc_register(&bma250_accl_misc_device);
if (rc < 0) {
dev_err(&client->dev, "bma250 misc_device register failed\n");
goto probe_err_reg_misc;
}
/* bma250 sensor initial */
if (rc < 0) {
dev_err(&dd->ip_dev->dev, "bma250_accl_probe: \
Error configuring device rc=%d\n", rc);
goto probe_err_smbcfg;
}
static int lm3639_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret;
struct lm3639_chip_data *pchip;
struct lm3639_platform_data *pdata = client->dev.platform_data;
struct backlight_properties props;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev, "i2c functionality check fail.\n");
return -EOPNOTSUPP;
}
if (pdata == NULL) {
dev_err(&client->dev, "Needs Platform Data.\n");
return -ENODATA;
}
pchip = devm_kzalloc(&client->dev,
sizeof(struct lm3639_chip_data), GFP_KERNEL);
if (!pchip)
return -ENOMEM;
pchip->pdata = pdata;
pchip->dev = &client->dev;
pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap);
if (IS_ERR(pchip->regmap)) {
ret = PTR_ERR(pchip->regmap);
dev_err(&client->dev, "fail : allocate register map: %d\n",
ret);
return ret;
}
i2c_set_clientdata(client, pchip);
/* chip initialize */
ret = lm3639_chip_init(pchip);
if (ret < 0) {
dev_err(&client->dev, "fail : chip init\n");
goto err_out;
}
/* backlight */
props.type = BACKLIGHT_RAW;
props.brightness = pdata->init_brt_led;
props.max_brightness = pdata->max_brt_led;
pchip->bled =
backlight_device_register("lm3639_bled", pchip->dev, pchip,
&lm3639_bled_ops, &props);
if (IS_ERR(pchip->bled)) {
dev_err(&client->dev, "fail : backlight register\n");
ret = -EIO;
goto err_out;
}
ret = device_create_file(&(pchip->bled->dev), &dev_attr_bled_mode);
if (ret < 0) {
dev_err(&client->dev, "failed : add sysfs entries\n");
ret = -EIO;
goto err_bled_mode;
}
/* flash */
pchip->cdev_flash.name = "lm3639_flash";
pchip->cdev_flash.max_brightness = 16;
pchip->cdev_flash.brightness_set = lm3639_flash_brightness_set;
ret = led_classdev_register((struct device *)
&client->dev, &pchip->cdev_flash);
if (ret < 0) {
dev_err(&client->dev, "fail : flash register\n");
ret = -EIO;
goto err_flash;
}
/* torch */
pchip->cdev_torch.name = "lm3639_torch";
pchip->cdev_torch.max_brightness = 8;
pchip->cdev_torch.brightness_set = lm3639_torch_brightness_set;
ret = led_classdev_register((struct device *)
&client->dev, &pchip->cdev_torch);
if (ret < 0) {
dev_err(&client->dev, "fail : torch register\n");
ret = -EIO;
goto err_torch;
}
return 0;
err_torch:
led_classdev_unregister(&pchip->cdev_flash);
err_flash:
device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode);
err_bled_mode:
backlight_device_unregister(pchip->bled);
err_out:
return ret;
}
static int __devinit isl9519q_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct isl_platform_data *pdata;
struct isl9519q_struct *isl_chg;
int ret;
ret = 0;
pdata = client->dev.platform_data;
if (pdata == NULL) {
dev_err(&client->dev, "%s no platform data\n", __func__);
ret = -EINVAL;
goto out;
}
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_WORD_DATA)) {
ret = -EIO;
goto out;
}
isl_chg = kzalloc(sizeof(*isl_chg), GFP_KERNEL);
if (!isl_chg) {
ret = -ENOMEM;
goto out;
}
INIT_DELAYED_WORK(&isl_chg->charge_work, isl9519q_charge);
isl_chg->client = client;
isl_chg->chgcurrent = pdata->chgcurrent;
isl_chg->term_current = pdata->term_current;
isl_chg->input_current = pdata->input_current;
isl_chg->max_system_voltage = pdata->max_system_voltage;
isl_chg->min_system_voltage = pdata->min_system_voltage;
isl_chg->valid_n_gpio = pdata->valid_n_gpio;
/* h/w ignores lower 7 bits of charging current and input current */
isl_chg->chgcurrent &= ~0x7F;
isl_chg->input_current &= ~0x7F;
isl_chg->adapter_hw_chg.type = CHG_TYPE_AC;
isl_chg->adapter_hw_chg.rating = 2;
isl_chg->adapter_hw_chg.name = "isl-adapter";
isl_chg->adapter_hw_chg.start_charging = isl9519q_start_charging;
isl_chg->adapter_hw_chg.stop_charging = isl9519q_stop_charging;
isl_chg->adapter_hw_chg.charging_switched = isl9519q_charging_switched;
if (pdata->chg_detection_config) {
ret = pdata->chg_detection_config();
if (ret) {
dev_err(&client->dev, "%s valid config failed ret=%d\n",
__func__, ret);
goto free_isl_chg;
}
}
ret = gpio_request(pdata->valid_n_gpio, "isl_charger_valid");
if (ret) {
dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n",
__func__, pdata->valid_n_gpio, ret);
goto free_isl_chg;
}
i2c_set_clientdata(client, isl_chg);
ret = msm_charger_register(&isl_chg->adapter_hw_chg);
if (ret) {
dev_err(&client->dev,
"%s msm_charger_register failed for ret =%d\n",
__func__, ret);
goto free_gpio;
}
ret = request_threaded_irq(client->irq, NULL,
isl_valid_handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"isl_charger_valid", client);
if (ret) {
dev_err(&client->dev,
"%s request_threaded_irq failed for %d ret =%d\n",
__func__, client->irq, ret);
goto unregister;
}
set_irq_wake(client->irq, 1);
isl_chg->max_system_voltage &= MAX_VOLTAGE_REG_MASK;
isl_chg->min_system_voltage &= MIN_VOLTAGE_REG_MASK;
if (isl_chg->max_system_voltage == 0)
isl_chg->max_system_voltage = DEFAULT_MAX_VOLTAGE_REG_VALUE;
if (isl_chg->min_system_voltage == 0)
isl_chg->min_system_voltage = DEFAULT_MIN_VOLTAGE_REG_VALUE;
ret = isl9519q_write_reg(isl_chg->client, MAX_SYS_VOLTAGE_REG,
isl_chg->max_system_voltage);
if (ret) {
dev_err(&client->dev,
"%s couldnt write to MAX_SYS_VOLTAGE_REG ret=%d\n",
__func__, ret);
goto free_irq;
}
ret = isl9519q_write_reg(isl_chg->client, MIN_SYS_VOLTAGE_REG,
isl_chg->min_system_voltage);
if (ret) {
dev_err(&client->dev,
"%s couldnt write to MIN_SYS_VOLTAGE_REG ret=%d\n",
__func__, ret);
goto free_irq;
}
if (isl_chg->input_current) {
ret = isl9519q_write_reg(isl_chg->client,
INPUT_CURRENT_REG,
isl_chg->input_current);
if (ret) {
dev_err(&client->dev,
"%s couldnt write INPUT_CURRENT_REG ret=%d\n",
__func__, ret);
goto free_irq;
}
}
ret = gpio_get_value_cansleep(isl_chg->valid_n_gpio);
if (ret < 0) {
dev_err(&client->dev,
"%s gpio_get_value failed for %d ret=%d\n", __func__,
pdata->valid_n_gpio, ret);
/* assume absent */
ret = 1;
}
if (!ret) {
msm_charger_notify_event(&isl_chg->adapter_hw_chg,
CHG_INSERTED_EVENT);
isl_chg->present = 1;
}
pr_debug("%s OK chg_present=%d\n", __func__, isl_chg->present);
return 0;
free_irq:
free_irq(client->irq, NULL);
unregister:
msm_charger_register(&isl_chg->adapter_hw_chg);
free_gpio:
gpio_free(pdata->valid_n_gpio);
free_isl_chg:
kfree(isl_chg);
out:
return ret;
}
static int __devinit max17040_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct input_dev *input_data = NULL;
int ret;
#ifdef USE_MAX17040_QUICKSTART
int aflag=0;
#endif
printk("[MAX17040] max17040_probe [IN]\n");
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
max17040_data.client = client;
i2c_set_clientdata(client, &max17040_data);
//sys file system are registered
max17040_data.battery.name = "batterys";
max17040_data.battery.type = POWER_SUPPLY_TYPE_BATTERY;
max17040_data.battery.get_property = max17040_get_property;
max17040_data.battery.properties = max17040_battery_props;
max17040_data.battery.external_power_changed = max17040_bat_external_power_changed;
max17040_data.battery.num_properties = ARRAY_SIZE(max17040_battery_props);
ret = power_supply_register(&client->dev, &max17040_data.battery);
if (ret) {
pr_err("[MAX17040] failed: power supply register [ERROR]\n");
i2c_set_clientdata(client, NULL);
return ret;
}
//The code used in the test mode [TEST MODE]
ret = sysfs_create_group(&client->dev.kobj, &max17040_attr_group);
if (ret) {
pr_err("[MAX17040] failed: sysfs_create_group [ERROR]\n");
}
//mutex is init
mutex_init(&max17040_data.data_mutex);
mutex_init(&max17040_data.i2c_mutex);
mutex_init(&max17040_data.quick_mutex);
//rcomp is set
max17040_set_rcomp();
//Version of reading
max17040_get_version();
//read vell and soc
max17040_quick_get_vcell();
#ifdef USE_MAX17040_QUICKSTART
//check quick start
aflag=max17040_check_restart(max17040_data.quick_data.quick_vcell,max17040_data.quick_data.quick_soc);
if(aflag)
{
max17040_restart();
msleep(300); //quick start update time
}
#endif
//The code used in the test mode [TEST MODE]
atomic_set(&max17040_data.set_test, 0);
input_data = input_allocate_device();
if (!input_data) {
pr_err("[MAX17040]: Unable to input_allocate_device \n");
return -1;
}
set_bit(EV_ABS,input_data->evbit);
input_set_capability(input_data, EV_ABS, ABS_X);
input_set_capability(input_data, EV_ABS, ABS_Y); /* wake */
input_set_capability(input_data, EV_ABS, ABS_WAKE); /* wake */
input_data->name="max17040";
ret =input_register_device(input_data);
if (ret) {
pr_err("[MAX17040]: Unable to register input_data device\n");
return -1;
}
input_set_drvdata(input_data, &max17040_data);
max17040_data.max17040_input_data=input_data;
//initialize workqueue and alarm setting
wake_lock_init(&max17040_data.work_wake_lock, WAKE_LOCK_SUSPEND,
"max17040-battery");
#ifdef MAX17040_ALARM_RTC_ENABLE
max17040_data.last_poll=alarm_get_elapsed_realtime();
INIT_WORK(&max17040_data.monitor_work, max17040_work);
max17040_data.monitor_wqueue = create_freezeable_workqueue("max17040");
/* init to something sane */
if (!max17040_data.monitor_wqueue) {
sleep_dbg("fail_workqueue Error [PROBE FUNCTION]");
return -1;
}
alarm_init(&max17040_data.alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
max_battery_alarm_callback);
//prevent suspend
max17040_prevent_suspend();
#ifdef CONFIG_HAS_EARLYSUSPEND
max17040_data.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
max17040_data.early_suspend.suspend = max17040_batt_early_suspend;
max17040_data.early_suspend.resume = max17040_batt_late_resume;
dbg("set max17040 EARLY_SUSPEND\n");
register_early_suspend(&max17040_data.early_suspend);
#endif //CONFIG_HAS_EARLYSUSPEND
queue_work(max17040_data.monitor_wqueue, &max17040_data.monitor_work);
#else
INIT_DELAYED_WORK_DEFERRABLE(&max17040_data.work, max17040_work);
schedule_delayed_work(&max17040_data.work, 0);
#endif //MAX17040_ALARM_RTC_ENABLE
// sleep_dbg("[MAX17040] max17040_probe [OUT]\n");
pr_info("[MAX17040]max17040_probe...\n");
return 0;
}
static int __devinit tmp102_temp_sensor_probe(
struct i2c_client *client, const struct i2c_device_id *id)
{
int ret = 0;
struct tmp102_temp_sensor *tmp102;
#ifdef CONFIG_THERMAL_DEBUG
printk(KERN_DEBUG "%s\n", __func__);
#endif
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_WORD_DATA)) {
dev_err(&client->dev, "adapter doesn't support SMBus word "
"transactions\n");
return -ENODEV;
}
tmp102 = kzalloc(sizeof(struct tmp102_temp_sensor), GFP_KERNEL);
if (!tmp102)
return -ENOMEM;
tmp102_data=tmp102;
mutex_init(&tmp102->sensor_mutex);
tmp102->iclient = client;
i2c_set_clientdata(client, tmp102);
/*Reset TMP102*/
tmp102_write_reg(client, TMP102_CONF_REG,TMP102_RESET);
if (ret < 0) {
dev_err(&client->dev, "error writing config register\n");
goto free_err;;
}
/*Config TMP102*/
ret = tmp102_write_reg(client, TMP102_CONF_REG, TMP102_CONFIG);
if (ret < 0) {
dev_err(&client->dev, "error writing config register\n");
goto restore_config_err;
}
/*Verify config*/
ret = tmp102_read_reg(client, TMP102_CONF_REG);
if (ret < 0) {
dev_err(&client->dev, "error reading config register\n");
goto restore_config_err;
}
#ifdef CONFIG_THERMAL_DEBUG
printk(KERN_DEBUG "config=0x%X\n", ret);
#endif
ret &= ~TMP102_CONFIG_RD_ONLY;
if (ret != TMP102_CONFIG) {
dev_err(&client->dev, "config settings did not stick\n");
ret = -ENODEV;
goto restore_config_err;
}
tmp102->last_update = jiffies - HZ;
tmp102->temp=DEFAULT_TEMPERATURE;
tmp102->state=LOW_TEMP_STATE;
ret = sysfs_create_group(&client->dev.kobj, &temp102_attr_group);
if (ret){
dev_err(&client->dev, "unable to create attribute\n");
goto sysfs_create_err;
}
tmp102->tpcb=kzalloc(sizeof(struct pcb_sens), GFP_KERNEL);
if(tmp102->tpcb){
tmp102->tpcb->update_temp=tmp102_read_current_temp;
omap4_duty_pcb_register(tmp102->tpcb);
}else {
ret = -ENOMEM;
goto tpcb_alloc_err;
}
dev_info(&client->dev, "initialized\n");
return 0;
tpcb_alloc_err:
sysfs_remove_group(&client->dev.kobj, &temp102_attr_group);
sysfs_create_err:
restore_config_err:
tmp102_write_reg(client, TMP102_CONF_REG,(TMP102_RESET|TMP102_CONF_SD));
free_err:
mutex_destroy(&tmp102->sensor_mutex);
kfree(tmp102);
return ret;
}
static int silead_ts_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct silead_ts_data *data;
struct device *dev = &client->dev;
int error;
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_I2C |
I2C_FUNC_SMBUS_READ_I2C_BLOCK |
I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {
dev_err(dev, "I2C functionality check failed\n");
return -ENXIO;
}
data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
if (!data)
return -ENOMEM;
i2c_set_clientdata(client, data);
data->client = client;
error = silead_ts_set_default_fw_name(data, id);
if (error)
return error;
silead_ts_read_props(client);
/* We must have the IRQ provided by DT or ACPI subsytem */
if (client->irq <= 0)
return -ENODEV;
data->regulators[0].supply = "vddio";
data->regulators[1].supply = "avdd";
error = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->regulators),
data->regulators);
if (error)
return error;
/*
* Enable regulators at probe and disable them at remove, we need
* to keep the chip powered otherwise it forgets its firmware.
*/
error = regulator_bulk_enable(ARRAY_SIZE(data->regulators),
data->regulators);
if (error)
return error;
error = devm_add_action_or_reset(dev, silead_disable_regulator, data);
if (error)
return error;
/* Power GPIO pin */
data->gpio_power = devm_gpiod_get_optional(dev, "power", GPIOD_OUT_LOW);
if (IS_ERR(data->gpio_power)) {
if (PTR_ERR(data->gpio_power) != -EPROBE_DEFER)
dev_err(dev, "Shutdown GPIO request failed\n");
return PTR_ERR(data->gpio_power);
}
error = silead_ts_setup(client);
if (error)
return error;
error = silead_ts_request_input_dev(data);
if (error)
return error;
error = devm_request_threaded_irq(dev, client->irq,
NULL, silead_ts_threaded_irq_handler,
IRQF_ONESHOT, client->name, data);
if (error) {
if (error != -EPROBE_DEFER)
dev_err(dev, "IRQ request failed %d\n", error);
return error;
}
return 0;
}
static int __devinit sec_fuelgauge_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct sec_fuelgauge_info *fuelgauge;
int ret = 0;
union power_supply_propval raw_soc_val;
dev_dbg(&client->dev,
"%s: SEC Fuelgauge Driver Loading\n", __func__);
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
fuelgauge = kzalloc(sizeof(*fuelgauge), GFP_KERNEL);
if (!fuelgauge)
return -ENOMEM;
mutex_init(&fuelgauge->fg_lock);
fuelgauge->client = client;
fuelgauge->pdata = client->dev.platform_data;
i2c_set_clientdata(client, fuelgauge);
fuelgauge->psy_fg.name = "sec-fuelgauge";
fuelgauge->psy_fg.type = POWER_SUPPLY_TYPE_UNKNOWN;
fuelgauge->psy_fg.get_property = sec_fg_get_property;
fuelgauge->psy_fg.set_property = sec_fg_set_property;
fuelgauge->psy_fg.properties = sec_fuelgauge_props;
fuelgauge->psy_fg.num_properties =
ARRAY_SIZE(sec_fuelgauge_props);
fuelgauge->capacity_max = fuelgauge->pdata->capacity_max;
#if 0
raw_soc_val.intval = SEC_FUELGAUGE_CAPACITY_TYPE_RAW;
sec_hal_fg_get_property(fuelgauge->client,
POWER_SUPPLY_PROP_CAPACITY, &raw_soc_val);
raw_soc_val.intval /= 10;
if(raw_soc_val.intval > fuelgauge->pdata->capacity_max)
sec_fg_calculate_dynamic_scale(fuelgauge);
#endif
if (!fuelgauge->pdata->fg_gpio_init()) {
dev_err(&client->dev,
"%s: Failed to Initialize GPIO\n", __func__);
goto err_free;
}
if (!sec_hal_fg_init(fuelgauge->client)) {
dev_err(&client->dev,
"%s: Failed to Initialize Fuelgauge\n", __func__);
goto err_free;
}
ret = power_supply_register(&client->dev, &fuelgauge->psy_fg);
if (ret) {
dev_err(&client->dev,
"%s: Failed to Register psy_fg\n", __func__);
goto err_free;
}
if (fuelgauge->pdata->fg_irq) {
INIT_DELAYED_WORK_DEFERRABLE(
&fuelgauge->isr_work, sec_fg_isr_work);
ret = request_threaded_irq(fuelgauge->pdata->fg_irq,
NULL, sec_fg_irq_thread,
fuelgauge->pdata->fg_irq_attr,
"fuelgauge-irq", fuelgauge);
if (ret) {
dev_err(&client->dev,
"%s: Failed to Reqeust IRQ\n", __func__);
goto err_supply_unreg;
}
ret = enable_irq_wake(gpio_to_irq(fuelgauge->pdata->fg_irq));
if (ret < 0)
dev_err(&client->dev,
"%s: Failed to Enable Wakeup Source(%d)\n",
__func__, ret);
}
fuelgauge->is_fuel_alerted = false;
if (fuelgauge->pdata->fuel_alert_soc >= 0) {
if (sec_hal_fg_fuelalert_init(fuelgauge->client,
fuelgauge->pdata->fuel_alert_soc))
wake_lock_init(&fuelgauge->fuel_alert_wake_lock,
WAKE_LOCK_SUSPEND, "fuel_alerted");
else {
dev_err(&client->dev,
"%s: Failed to Initialize Fuel-alert\n",
__func__);
goto err_irq;
}
}
fuelgauge->initial_update_of_soc = true;
ret = sec_fg_create_attrs(fuelgauge->psy_fg.dev);
if (ret) {
dev_err(&client->dev,
"%s : Failed to create_attrs\n", __func__);
goto err_irq;
}
dev_dbg(&client->dev,
"%s: SEC Fuelgauge Driver Loaded\n", __func__);
return 0;
err_irq:
if (fuelgauge->pdata->fg_irq)
free_irq(fuelgauge->pdata->fg_irq, fuelgauge);
wake_lock_destroy(&fuelgauge->fuel_alert_wake_lock);
err_supply_unreg:
power_supply_unregister(&fuelgauge->psy_fg);
err_free:
mutex_destroy(&fuelgauge->fg_lock);
kfree(fuelgauge);
return ret;
}
static int bq275x0_battery_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int num;
char *name;
int retval = 0;
struct bq275x0_device_info *di;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
BQ275x0_ERR("[%s,%d]: need I2C_FUNC_I2C\n",__FUNCTION__,__LINE__);
return -ENODEV;
}
i2c_smbus_write_word_data(client,0x00,0x0008);
mdelay(2);
retval = i2c_smbus_read_word_data(client,0x00);
if(retval<0)
{
printk(KERN_ERR "[%s,%d] Coulometer Damaged or Firmware Error\n",__FUNCTION__,__LINE__);
}
else
{
printk(KERN_ERR "Normal Mode and read Firmware version=%04x\n", retval);
}
retval = driver_create_file(&(bq275x0_battery_driver.driver), &driver_attr_state);
if (0 != retval)
{
printk("failed to create sysfs entry(state): %d\n", retval);
return -1;
}
power_set_batt_measurement_type(BATT_MEASURE_BY_BQ275x0);
/* Get new ID for the new battery device */
retval = idr_pre_get(&bq275x0_battery_id, GFP_KERNEL);
if (retval == 0) {
retval = -ENOMEM;
goto batt_failed_0;
}
mutex_lock(&bq275x0_battery_mutex);
retval = idr_get_new(&bq275x0_battery_id, client, &num);
mutex_unlock(&bq275x0_battery_mutex);
if (retval < 0) {
goto batt_failed_0;
}
name = kasprintf(GFP_KERNEL, "bq275x0-%d", num);
if (!name) {
dev_err(&client->dev, "failed to allocate device name\n");
retval = -ENOMEM;
goto batt_failed_1;
}
di = kzalloc(sizeof(*di), GFP_KERNEL);
if (!di) {
dev_err(&client->dev, "failed to allocate device info data\n");
retval = -ENOMEM;
goto batt_failed_2;
}
di->id = num;
i2c_set_clientdata(client, di);
di->dev = &client->dev;
di->bat.name = name;
di->client = client;
bq275x0_powersupply_init(di);
g_battery_measure_by_bq275x0_i2c_client = client;
dev_info(&client->dev, "bq275x0 support ver. %s enabled\n", DRIVER_VERSION);
return 0;
batt_failed_2:
kfree(name);
batt_failed_1:
mutex_lock(&bq275x0_battery_mutex);
idr_remove(&bq275x0_battery_id, num);
mutex_unlock(&bq275x0_battery_mutex);
batt_failed_0:
power_set_batt_measurement_type(BATT_MEASURE_UNKNOW);
return retval;
}
int32_t msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
char front_cam[10] = "mt9m114";
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s_i2c_probe called\n", client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
CDBG("i2c_check_functionality failed\n");
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s: NULL sensor data\n", __func__);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0)
goto probe_fail;
rc = msm_sensor_match_id(s_ctrl);
/*BEGIN Chaoyen_Wu@pegatron[2012.4.12][front camera 2nd source porting]*/
if(rc < 0 && !(strcmp(client->name, front_cam))){
s_ctrl->sensor_i2c_client->client->addr = s_ctrl->sensor_i2c_addr_high;
CDBG("2nd source i2c addr: 0x%x\n",s_ctrl->sensor_i2c_client->client->addr);
rc = msm_sensor_match_id(s_ctrl);
}
/*END Chaoyen_Wu@pegatron[2012.4.12][front camera 2nd source porting]*/
if (rc < 0)
goto probe_fail;
if (s_ctrl->sensor_eeprom_client != NULL) {
struct msm_camera_eeprom_client *eeprom_client =
s_ctrl->sensor_eeprom_client;
if (eeprom_client->func_tbl.eeprom_init != NULL &&
eeprom_client->func_tbl.eeprom_release != NULL) {
rc = eeprom_client->func_tbl.eeprom_init(
eeprom_client,
s_ctrl->sensor_i2c_client->client->adapter);
if (rc < 0)
goto probe_fail;
rc = msm_camera_eeprom_read_tbl(eeprom_client,
eeprom_client->read_tbl, eeprom_client->read_tbl_size);
eeprom_client->func_tbl.eeprom_release(eeprom_client);
if (rc < 0)
goto probe_fail;
}
}
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto power_down;
probe_fail:
CDBG("%s_i2c_probe failed\n", client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
return rc;
}
static int wacom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct wacom_i2c *wac_i2c;
struct wacom_g5_platform_data *pdata = client->dev.platform_data;
int i, ret;
i = ret = 0;
printk(KERN_DEBUG "[E-PEN]:%s:\n", __func__);
/*Check I2C functionality*/
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
goto err3;
/*Obtain kernel memory space for wacom i2c*/
wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL);
if (wac_i2c == NULL) goto fail;
wac_i2c->wac_feature = &wacom_feature_EMR;
pdata->init_platform_hw();
/*Initializing for semaphor*/
mutex_init(&wac_i2c->lock);
/*Register platform data*/
wac_i2c->wac_pdata = client->dev.platform_data;
/*Register callbacks*/
wac_i2c->callbacks.check_prox = wacom_check_emr_prox;
if (wac_i2c->wac_pdata->register_cb)
wac_i2c->wac_pdata->register_cb(&wac_i2c->callbacks);
/*Register wacom i2c to input device*/
wac_i2c->input_dev = input_allocate_device();
if (wac_i2c == NULL || wac_i2c->input_dev == NULL)
goto fail;
wacom_i2c_set_input_values(client, wac_i2c, wac_i2c->input_dev);
wac_i2c->client = client;
wac_i2c->irq = client->irq;
/*Change below if irq is needed*/
wac_i2c->irq_flag = 1;
#ifdef CONFIG_HAS_EARLYSUSPEND
wac_i2c->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
wac_i2c->early_suspend.suspend = wacom_i2c_early_suspend;
wac_i2c->early_suspend.resume = wacom_i2c_late_resume;
register_early_suspend(&wac_i2c->early_suspend);
#endif
/*Init Featreus by hw rev*/
#if defined(CONFIG_USA_MODEL_SGH_I717)
if( get_hw_rev() == 0x01 ) {
printk("[E-PEN] Wacom driver is working for 4.4mm pitch pad.\n");
/* Firmware Feature */
Firmware_version_of_file = 0x340;
Binary = Binary_44;
}
else if( get_hw_rev() >= HWREV_PEN_PITCH4P4 ) {
printk("[E-PEN] Wacom driver is working for 4.4mm pitch pad.\n");
/* Firmware Feature */
Firmware_version_of_file = Firmware_version_of_file_44;
Binary = Binary_44;
}
#else
if( get_hw_rev() >= HWREV_PEN_PITCH4P4 ) {
printk("[E-PEN] Wacom driver is working for 4.4mm pitch pad.\n");
/* Firmware Feature */
Firmware_version_of_file = Firmware_version_of_file_44;
Binary = Binary_44;
}
else {
printk("[E-PEN] Wacom driver is working for 4.8mm pitch pad.\n");
/* Firmware Feature */
Firmware_version_of_file = Firmware_version_of_file_48;
Binary = Binary_48;
}
#endif
init_offset_tables();
INIT_WORK(&wac_i2c->update_work, update_work_func);
INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work);
/* Reset IC */
#if defined(CONFIG_USA_MODEL_SGH_I717)
gpio_set_value(GPIO_PEN_RESET, 0);
msleep(200);
gpio_set_value(GPIO_PEN_RESET, 1);
msleep(200);
#else
gpio_set_value(GPIO_PEN_RESET, 0);
msleep(120);
gpio_set_value(GPIO_PEN_RESET, 1);
msleep(15);
#endif
ret = wacom_i2c_query(wac_i2c);
if( ret < 0 )
epen_reset_result = false;
else
epen_reset_result = true;
input_set_abs_params(wac_i2c->input_dev, ABS_X, pdata->min_x,
pdata->max_x, 4, 0);
input_set_abs_params(wac_i2c->input_dev, ABS_Y, pdata->min_y,
pdata->max_y, 4, 0);
input_set_abs_params(wac_i2c->input_dev, ABS_PRESSURE, pdata->min_pressure,
pdata->max_pressure, 0, 0);
input_set_drvdata(wac_i2c->input_dev, wac_i2c);
/*Set client data*/
i2c_set_clientdata(client, wac_i2c);
/*Before registering input device, data in each input_dev must be set*/
if (input_register_device(wac_i2c->input_dev))
goto err2;
g_client = client;
/* if(wac_i2c->irq_flag) */
/* disable_irq(wac_i2c->irq); */
sec_epen= device_create(sec_class, NULL, 0, NULL, "sec_epen");
dev_set_drvdata(sec_epen, wac_i2c);
if (IS_ERR(sec_epen))
printk(KERN_ERR "Failed to create device(sec_epen)!\n");
if (device_create_file(sec_epen, &dev_attr_epen_firm_update)< 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_update.attr.name);
if (device_create_file(sec_epen, &dev_attr_epen_firm_update_status)< 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_update_status.attr.name);
if (device_create_file(sec_epen, &dev_attr_epen_firm_version)< 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_firm_version.attr.name);
if (device_create_file(sec_epen, &dev_attr_epen_rotation)< 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_rotation.attr.name);
if (device_create_file(sec_epen, &dev_attr_epen_hand)< 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_hand.attr.name);
if (device_create_file(sec_epen, &dev_attr_epen_reset)< 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_reset.attr.name);
if (device_create_file(sec_epen, &dev_attr_epen_reset_result)< 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_reset_result.attr.name);
if (device_create_file(sec_epen, &dev_attr_epen_checksum)< 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_checksum.attr.name);
if (device_create_file(sec_epen, &dev_attr_epen_checksum_result)< 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_epen_checksum_result.attr.name);
if (device_create_file(sec_epen, &dev_attr_set_epen_module_off) < 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_set_epen_module_off.attr.name);
if (device_create_file(sec_epen, &dev_attr_set_epen_module_on) < 0)
printk(KERN_ERR "Failed to create device file(%s)!\n", dev_attr_set_epen_module_on.attr.name);
/*Request IRQ*/
if (wac_i2c->irq_flag) {
ret = request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt, IRQF_DISABLED|IRQF_TRIGGER_RISING|IRQF_ONESHOT, wac_i2c->name, wac_i2c);
if (ret < 0)
goto err1;
}
/* firmware update */
printk(KERN_NOTICE "[E-PEN] wacom fw ver : 0x%x, new fw ver : 0x%x\n",
wac_i2c->wac_feature->fw_version, Firmware_version_of_file);
if( wac_i2c->wac_feature->fw_version < Firmware_version_of_file )
{
#if defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L)
printk("[E-PEN] %s\n", __func__);
disable_irq(wac_i2c->irq);
printk(KERN_NOTICE "[E-PEN]: INIT_FIRMWARE_FLASH is enabled.\n");
ret = wacom_i2c_flash(wac_i2c);
msleep(800);
printk(KERN_ERR "[E-PEN]: flashed.(%d)\n", ret);
wacom_i2c_query(wac_i2c);
enable_irq(wac_i2c->irq);
#else
schedule_work(&wac_i2c->update_work);
#endif
}
/* To send exact checksum data at sleep state ... Xtopher */
printk(KERN_ERR"[E-PEN]: Verify CHECKSUM.\n");
epen_checksum_read_atBoot(wac_i2c);
msleep(20);
return 0;
err3:
printk(KERN_ERR "[E-PEN]: No I2C functionality found\n");
return -ENODEV;
err2:
printk(KERN_ERR "[E-PEN]: err2 occured\n");
input_free_device(wac_i2c->input_dev);
return -EIO;
err1:
printk(KERN_ERR "[E-PEN]: err1 occured(num:%d)\n", ret);
input_free_device(wac_i2c->input_dev);
wac_i2c->input_dev = NULL;
return -EIO;
fail:
printk(KERN_ERR "[E-PEN]: fail occured\n");
return -ENOMEM;
}
static int pn544_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret;
struct pn544_i2c_platform_data *platform_data;
struct pn544_dev *pn544_dev;
platform_data = client->dev.platform_data;
if (platform_data == NULL)
{
printk("%s : nfc probe fail\n", __func__);
return -ENODEV;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
{
printk("%s : need I2C_FUNC_I2C\n", __func__);
return -ENODEV;
}
//IRQ
ret = gpio_request(platform_data->irq_gpio, "nfc_int");
if (ret)
{
printk("gpio_nfc_int request error\n");
return -ENODEV;
}
//VEN
ret = gpio_request(platform_data->ven_gpio, "nfc_ven");
if (ret)
{
printk("gpio_nfc_ven request error\n");
return -ENODEV;
}
//PVDD
ret = gpio_request(PN544_PW_EN, "nfc_pvdd");
if (ret)
{
printk("gpio_nfc_ven request error\n");
return -ENODEV;
}
//FIRM
ret = gpio_request(platform_data->firm_gpio, "nfc_firm");
if (ret)
{
printk("gpio_nfc_firm request error\n");
return -ENODEV;
}
pn544_dev = kzalloc(sizeof(*pn544_dev), GFP_KERNEL);
if (pn544_dev == NULL)
{
dev_err(&client->dev,
"failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
gpio_set_value(PN544_PW_EN, 1);
pn544_dev->irq_gpio = platform_data->irq_gpio;
pn544_dev->ven_gpio = platform_data->ven_gpio;
pn544_dev->firm_gpio = platform_data->firm_gpio;
pn544_dev->client = client;
/* init mutex and queues */
init_waitqueue_head(&pn544_dev->read_wq);
mutex_init(&pn544_dev->read_mutex);
spin_lock_init(&pn544_dev->irq_enabled_lock);
pn544_dev->pn544_device.minor = MISC_DYNAMIC_MINOR;
pn544_dev->pn544_device.name = "pn544";
pn544_dev->pn544_device.fops = &pn544_dev_fops;
ret = misc_register(&pn544_dev->pn544_device);
if (ret)
{
printk("%s : misc_register failed\n", __FILE__);
goto err_misc_register;
}
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
pr_info("%s : requesting IRQ %d\n", __func__, client->irq);
pn544_dev->irq_enabled = true;
// ts->irq = gpio_to_irq(ts->platform_data->irq_gpio);
ret = request_irq(client->irq, pn544_dev_irq_handler, IRQF_TRIGGER_HIGH, client->name, pn544_dev);
if (ret)
{
dev_err(&client->dev, "request_irq failed\n");
goto err_request_irq_failed;
}
printk("pn544_probe -> request_irq,%d\n", ret);
pn544_disable_irq(pn544_dev);
i2c_set_clientdata(client, pn544_dev);
return 0;
err_request_irq_failed:
misc_deregister(&pn544_dev->pn544_device);
err_misc_register:
mutex_destroy(&pn544_dev->read_mutex);
kfree(pn544_dev);
err_exit:
gpio_free(pn544_dev->irq_gpio);
gpio_free(pn544_dev->ven_gpio);
gpio_free(pn544_dev->firm_gpio);
return ret;
}
static int lm25066_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int config;
int ret;
struct lm25066_data *data;
struct pmbus_driver_info *info;
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_READ_BYTE_DATA))
return -ENODEV;
data = kzalloc(sizeof(struct lm25066_data), GFP_KERNEL);
if (!data)
return -ENOMEM;
config = i2c_smbus_read_byte_data(client, LM25066_DEVICE_SETUP);
if (config < 0) {
ret = config;
goto err_mem;
}
data->id = id->driver_data;
info = &data->info;
info->pages = 2;
info->format[PSC_VOLTAGE_IN] = direct;
info->format[PSC_VOLTAGE_OUT] = direct;
info->format[PSC_CURRENT_IN] = direct;
info->format[PSC_TEMPERATURE] = direct;
info->format[PSC_POWER] = direct;
info->m[PSC_TEMPERATURE] = 16;
info->b[PSC_TEMPERATURE] = 0;
info->R[PSC_TEMPERATURE] = 0;
info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT
| PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_PIN | PMBUS_HAVE_IIN
| PMBUS_HAVE_STATUS_INPUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
info->func[1] = PMBUS_HAVE_VOUT;
info->read_word_data = lm25066_read_word_data;
info->write_word_data = lm25066_write_word_data;
info->write_byte = lm25066_write_byte;
switch (id->driver_data) {
case lm25066:
info->m[PSC_VOLTAGE_IN] = 22070;
info->b[PSC_VOLTAGE_IN] = 0;
info->R[PSC_VOLTAGE_IN] = -2;
info->m[PSC_VOLTAGE_OUT] = 22070;
info->b[PSC_VOLTAGE_OUT] = 0;
info->R[PSC_VOLTAGE_OUT] = -2;
if (config & LM25066_DEV_SETUP_CL) {
info->m[PSC_CURRENT_IN] = 6852;
info->b[PSC_CURRENT_IN] = 0;
info->R[PSC_CURRENT_IN] = -2;
info->m[PSC_POWER] = 369;
info->b[PSC_POWER] = 0;
info->R[PSC_POWER] = -2;
} else {
info->m[PSC_CURRENT_IN] = 13661;
info->b[PSC_CURRENT_IN] = 0;
info->R[PSC_CURRENT_IN] = -2;
info->m[PSC_POWER] = 736;
info->b[PSC_POWER] = 0;
info->R[PSC_POWER] = -2;
}
break;
case lm5064:
info->m[PSC_VOLTAGE_IN] = 22075;
info->b[PSC_VOLTAGE_IN] = 0;
info->R[PSC_VOLTAGE_IN] = -2;
info->m[PSC_VOLTAGE_OUT] = 22075;
info->b[PSC_VOLTAGE_OUT] = 0;
info->R[PSC_VOLTAGE_OUT] = -2;
if (config & LM25066_DEV_SETUP_CL) {
info->m[PSC_CURRENT_IN] = 6713;
info->b[PSC_CURRENT_IN] = 0;
info->R[PSC_CURRENT_IN] = -2;
info->m[PSC_POWER] = 3619;
info->b[PSC_POWER] = 0;
info->R[PSC_POWER] = -3;
} else {
info->m[PSC_CURRENT_IN] = 13426;
info->b[PSC_CURRENT_IN] = 0;
info->R[PSC_CURRENT_IN] = -2;
info->m[PSC_POWER] = 7238;
info->b[PSC_POWER] = 0;
info->R[PSC_POWER] = -3;
}
break;
case lm5066:
info->m[PSC_VOLTAGE_IN] = 4587;
info->b[PSC_VOLTAGE_IN] = 0;
info->R[PSC_VOLTAGE_IN] = -2;
info->m[PSC_VOLTAGE_OUT] = 4587;
info->b[PSC_VOLTAGE_OUT] = 0;
info->R[PSC_VOLTAGE_OUT] = -2;
if (config & LM25066_DEV_SETUP_CL) {
info->m[PSC_CURRENT_IN] = 10753;
info->b[PSC_CURRENT_IN] = 0;
info->R[PSC_CURRENT_IN] = -2;
info->m[PSC_POWER] = 1204;
info->b[PSC_POWER] = 0;
info->R[PSC_POWER] = -3;
} else {
info->m[PSC_CURRENT_IN] = 5405;
info->b[PSC_CURRENT_IN] = 0;
info->R[PSC_CURRENT_IN] = -2;
info->m[PSC_POWER] = 605;
info->b[PSC_POWER] = 0;
info->R[PSC_POWER] = -3;
}
break;
default:
ret = -ENODEV;
goto err_mem;
}
ret = pmbus_do_probe(client, id, info);
if (ret)
goto err_mem;
return 0;
err_mem:
kfree(data);
return ret;
}
static int mma845x_mod_probe(struct i2c_client *client,
const struct i2c_device_id *devid)
{
struct ext_slave_platform_data *pdata;
struct mma845x_mod_private_data *private_data;
int result = 0;
unsigned char product_id = 0xff;
dev_info(&client->adapter->dev, "%s: %s\n", __func__, devid->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
result = -ENODEV;
goto out_no_free;
}
pdata = client->dev.platform_data;
if (!pdata) {
dev_err(&client->adapter->dev,
"Missing platform data for slave %s\n", devid->name);
result = -EFAULT;
goto out_no_free;
}
result = inv_serial_read(client->adapter, pdata->address,
ACCEL_MMA845X_WHO_AM_I, sizeof(product_id),
&product_id);
printk("mma845x detect 0x%x\n", product_id);
if (result || (product_id != ACCEL_MMA845X_ID)) {
dev_err(&client->adapter->dev, "mma845x not found\n");
result = -ENODEV;
goto out_no_free;
}
printk("mma845x find\n");
private_data = kzalloc(sizeof(*private_data), GFP_KERNEL);
if (!private_data) {
result = -ENOMEM;
goto out_no_free;
}
i2c_set_clientdata(client, private_data);
private_data->client = client;
private_data->pdata = pdata;
result = inv_mpu_register_slave(THIS_MODULE, client, pdata,
mma845x_get_slave_descr);
if (result) {
dev_err(&client->adapter->dev,
"Slave registration failed: %s, %d\n",
devid->name, result);
goto out_free_memory;
}
return result;
out_free_memory:
kfree(private_data);
out_no_free:
dev_err(&client->adapter->dev, "%s failed %d\n", __func__, result);
return result;
}
int akm8975_probe(struct i2c_client *client,
const struct i2c_device_id *devid)
{
struct akm8975_data *akm;
int err;
printk("ak8975 probe start!\n");
if (client->dev.platform_data == NULL) {
dev_err(&client->dev, "platform data is NULL. exiting.\n");
err = -ENODEV;
goto exit_platform_data_null;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev, "I2C check failed, exiting.\n");
err = -ENODEV;
goto exit_check_functionality_failed;
}
akm = kzalloc(sizeof(struct akm8975_data), GFP_KERNEL);
if (!akm) {
dev_err(&client->dev,
"failed to allocate memory for module data\n");
err = -ENOMEM;
goto exit_alloc_data_failed;
}
akm->pdata = client->dev.platform_data;
mutex_init(&akm->lock);
init_completion(&akm->data_ready);
i2c_set_clientdata(client, akm);
akm->this_client = client;
err = akm8975_ecs_set_mode_power_down(akm);
if (err < 0) {
pr_err("%s: akm8975_ecs_set_mode_power_down failed(%d)\n",
__func__, err);
goto exit_set_mode_power_down_failed;
}
err = akm8975_setup_irq(akm);
if (err) {
pr_err("%s: could not setup irq\n", __func__);
goto exit_setup_irq;
}
akm->akmd_device.minor = MISC_DYNAMIC_MINOR;
akm->akmd_device.name = "akm8975";
akm->akmd_device.fops = &akmd_fops;
err = misc_register(&akm->akmd_device);
if (err) {
pr_err("%s misc_register failed\n", __func__);
goto exit_akmd_device_register_failed;
}
init_waitqueue_head(&akm->state_wq);
printk("ak8975 probe success!\n");
return 0;
exit_akmd_device_register_failed:
free_irq(akm->irq, akm);
gpio_free(akm->pdata->gpio_data_ready_int);
exit_setup_irq:
exit_set_mode_power_down_failed:
mutex_destroy(&akm->lock);
kfree(akm);
exit_alloc_data_failed:
exit_check_functionality_failed:
exit_platform_data_null:
return err;
}
static int s5k8aay_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CAM_DEBUG(" E");
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
cam_err("i2c_check_functionality failed");
rc = -ENOTSUPP;
goto probe_failure;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
cam_err("s_ctrl->sensor_i2c_client is NULL");
rc = -EFAULT;
goto probe_failure;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
cam_err(" NULL sensor data");
rc = -EFAULT;
goto probe_failure;
}
s5k8aay_client = client;
s5k8aay_dev = s_ctrl->sensor_i2c_client->client->dev;
s5k8aay_ctrl = kzalloc(sizeof(struct s5k8aay_ctrl), GFP_KERNEL);
if (!s5k8aay_ctrl) {
cam_err(" s5k8aay_ctrl alloc failed!");
rc = -ENOMEM;
goto probe_failure;
}
memset(s5k8aay_ctrl, 0, sizeof(s5k8aay_ctrl));
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
&s5k8aay_subdev_ops);
s5k8aay_ctrl->sensor_dev = &s_ctrl->sensor_v4l2_subdev;
s5k8aay_ctrl->sensordata = client->dev.platform_data;
rc = msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
if (rc < 0) {
cam_err(" msm_sensor_register failed!");
kfree(s5k8aay_ctrl);
goto probe_failure;
}
CAM_DEBUG(" success!");
CAM_DEBUG(" X");
return 0;
probe_failure:
CAM_DEBUG(" fail!");
CAM_DEBUG(" X");
return rc;
}
static int rs5c372_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err = 0;
int smbus_mode = 0;
struct rs5c372 *rs5c372;
struct rtc_time tm;
dev_dbg(&client->dev, "%s\n", __func__);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) {
if (i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_BYTE_DATA |
I2C_FUNC_SMBUS_I2C_BLOCK))
smbus_mode = 1;
else {
err = -ENODEV;
goto exit;
}
}
if (!(rs5c372 = kzalloc(sizeof(struct rs5c372), GFP_KERNEL))) {
err = -ENOMEM;
goto exit;
}
rs5c372->client = client;
i2c_set_clientdata(client, rs5c372);
rs5c372->type = id->driver_data;
rs5c372->regs = &rs5c372->buf[1];
rs5c372->smbus = smbus_mode;
err = rs5c_get_regs(rs5c372);
if (err < 0)
goto exit_kfree;
switch (rs5c372->type) {
case rtc_rs5c372a:
case rtc_rs5c372b:
if (rs5c372->regs[RS5C_REG_CTRL2] & RS5C372_CTRL2_24)
rs5c372->time24 = 1;
break;
case rtc_r2025sd:
case rtc_rv5c386:
case rtc_rv5c387a:
if (rs5c372->regs[RS5C_REG_CTRL1] & RV5C387_CTRL1_24)
rs5c372->time24 = 1;
break;
default:
dev_err(&client->dev, "unknown RTC type\n");
goto exit_kfree;
}
err = rs5c_oscillator_setup(rs5c372);
if (unlikely(err < 0)) {
dev_err(&client->dev, "setup error\n");
goto exit_kfree;
}
if (rs5c372_get_datetime(client, &tm) < 0)
dev_warn(&client->dev, "clock needs to be set\n");
dev_info(&client->dev, "%s found, %s, driver version " DRV_VERSION "\n",
({ char *s; switch (rs5c372->type) {
case rtc_r2025sd: s = "r2025sd"; break;
case rtc_rs5c372a: s = "rs5c372a"; break;
case rtc_rs5c372b: s = "rs5c372b"; break;
case rtc_rv5c386: s = "rv5c386"; break;
case rtc_rv5c387a: s = "rv5c387a"; break;
default: s = "chip"; break;
}; s;}),
static int pn547_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
int rc = 0;
struct clk *nfc_clk = NULL;
struct pn547_i2c_platform_data *platform_data;
struct pn547_dev *pn547_dev;
printk("### %s begin! \n",__func__);
dev_info(&client->dev, "%s ++\n", __func__);
platform_data = kzalloc(sizeof(struct pn547_i2c_platform_data),
GFP_KERNEL);
if (platform_data == NULL) {
dev_err(&client->dev, "failed to allocate memory\n");
ret = -ENOMEM;
goto err_platform_data;
}
printk("### %s 11 begin! \n",__func__);
ret = pn547_parse_dt(&client->dev, platform_data);
if (ret < 0) {
dev_err(&client->dev, "failed to parse device tree: %d\n", ret);
goto err_parse_dt;
}
printk("pn547 dev kobj_name=%s,init_name=%s,id=%d\n",client->dev.kobj.name,client->dev.init_name, client->dev.id);
nfc_clk = clk_get(&client->dev, "nfc_pn547clk");
if (nfc_clk == NULL) {
dev_err(&client->dev, "failed to get clk: %d\n", ret);
goto err_parse_dt;
}
rc = clk_set_rate(nfc_clk,19200000);
if(rc){
dev_err(&client->dev, "Clock set rate failed: %d\n",rc);
}
ret = clk_prepare_enable(nfc_clk);
if (ret) {
dev_err(&client->dev, "failed to enable clk: %d\n", ret);
goto err_parse_dt;
}
ret = pn547_gpio_request(&client->dev, platform_data);
if (ret) {
dev_err(&client->dev, "failed to request gpio\n");
goto err_gpio_request;
}
dev_dbg(&client->dev, "%s:\n", __func__);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev, "%s: i2c check failed\n", __func__);
ret = -ENODEV;
goto err_i2c;
}
printk("### %s 22 begin! \n",__func__);
pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL);
if (pn547_dev == NULL) {
dev_err(&client->dev,
"failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
client->irq = gpio_to_irq(platform_data->irq_gpio);
pn547_dev->irq_gpio = platform_data->irq_gpio;
pn547_dev->ven_gpio = platform_data->ven_gpio;
pn547_dev->firm_gpio = platform_data->fwdl_en_gpio;
pn547_dev->clk_req_gpio = platform_data->clk_req_gpio;
pn547_dev->client = client;
pn547_dev->dev = &client->dev;
pn547_dev->do_reading = 0;
/* Initialise mutex and work queue */
init_waitqueue_head(&pn547_dev->read_wq);
mutex_init(&pn547_dev->read_mutex);
spin_lock_init(&pn547_dev->irq_enabled_lock);
wake_lock_init(&pn547_dev->wl,WAKE_LOCK_SUSPEND,"nfc_locker");
pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR;
pn547_dev->pn547_device.name = "pn544";
pn547_dev->pn547_device.fops = &pn547_dev_fops;
printk("### %s 33 begin! \n",__func__);
ret = misc_register(&pn547_dev->pn547_device);
if (ret) {
dev_err(&client->dev, "%s: misc_register err %d\n",
__func__, ret);
goto err_misc_register;
}
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
dev_info(&client->dev, "%s : requesting IRQ %d\n",
__func__, client->irq);
pn547_dev->irq_enabled = true;
ret = request_irq(client->irq, pn547_dev_irq_handler,
IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND | IRQF_ONESHOT,
client->name, pn547_dev);
if (ret) {
dev_err(&client->dev, "request_irq failed\n");
goto err_request_irq_failed;
}
pn547_disable_irq(pn547_dev);
i2c_set_clientdata(client, pn547_dev);
return 0;
err_request_irq_failed:
misc_deregister(&pn547_dev->pn547_device);
err_misc_register:
mutex_destroy(&pn547_dev->read_mutex);
kfree(pn547_dev);
err_exit:
err_i2c:
pn547_gpio_release(platform_data);
err_gpio_request:
err_parse_dt:
kfree(platform_data);
err_platform_data:
dev_err(&client->dev, "%s: err %d\n", __func__, ret);
return ret;
}
static int pm2xxx_wall_charger_probe(struct i2c_client *i2c_client,
const struct i2c_device_id *id)
{
struct pm2xxx_platform_data *pl_data = i2c_client->dev.platform_data;
struct power_supply_config psy_cfg = {};
struct pm2xxx_charger *pm2;
int ret = 0;
u8 val;
int i;
if (!pl_data) {
dev_err(&i2c_client->dev, "No platform data supplied\n");
return -EINVAL;
}
pm2 = kzalloc(sizeof(struct pm2xxx_charger), GFP_KERNEL);
if (!pm2) {
dev_err(&i2c_client->dev, "pm2xxx_charger allocation failed\n");
return -ENOMEM;
}
/* get parent data */
pm2->dev = &i2c_client->dev;
pm2->pm2_int = &pm2xxx_int;
/* get charger spcific platform data */
if (!pl_data->wall_charger) {
dev_err(pm2->dev, "no charger platform data supplied\n");
ret = -EINVAL;
goto free_device_info;
}
pm2->pdata = pl_data->wall_charger;
/* get battery specific platform data */
if (!pl_data->battery) {
dev_err(pm2->dev, "no battery platform data supplied\n");
ret = -EINVAL;
goto free_device_info;
}
pm2->bat = pl_data->battery;
if (!i2c_check_functionality(i2c_client->adapter,
I2C_FUNC_SMBUS_BYTE_DATA |
I2C_FUNC_SMBUS_READ_WORD_DATA)) {
ret = -ENODEV;
dev_info(pm2->dev, "pm2301 i2c_check_functionality failed\n");
goto free_device_info;
}
pm2->config.pm2xxx_i2c = i2c_client;
pm2->config.pm2xxx_id = (struct i2c_device_id *) id;
i2c_set_clientdata(i2c_client, pm2);
/* AC supply */
/* power_supply base class */
pm2->ac_chg_desc.name = pm2->pdata->label;
pm2->ac_chg_desc.type = POWER_SUPPLY_TYPE_MAINS;
pm2->ac_chg_desc.properties = pm2xxx_charger_ac_props;
pm2->ac_chg_desc.num_properties = ARRAY_SIZE(pm2xxx_charger_ac_props);
pm2->ac_chg_desc.get_property = pm2xxx_charger_ac_get_property;
psy_cfg.supplied_to = pm2->pdata->supplied_to;
psy_cfg.num_supplicants = pm2->pdata->num_supplicants;
/* pm2xxx_charger sub-class */
pm2->ac_chg.ops.enable = &pm2xxx_charger_ac_en;
pm2->ac_chg.ops.kick_wd = &pm2xxx_charger_watchdog_kick;
pm2->ac_chg.ops.update_curr = &pm2xxx_charger_update_charger_current;
pm2->ac_chg.max_out_volt = pm2xxx_charger_voltage_map[
ARRAY_SIZE(pm2xxx_charger_voltage_map) - 1];
pm2->ac_chg.max_out_curr = pm2xxx_charger_current_map[
ARRAY_SIZE(pm2xxx_charger_current_map) - 1];
pm2->ac_chg.wdt_refresh = WD_KICK_INTERVAL;
pm2->ac_chg.enabled = true;
pm2->ac_chg.external = true;
/* Create a work queue for the charger */
pm2->charger_wq = create_singlethread_workqueue("pm2xxx_charger_wq");
if (pm2->charger_wq == NULL) {
ret = -ENOMEM;
dev_err(pm2->dev, "failed to create work queue\n");
goto free_device_info;
}
/* Init work for charger detection */
INIT_WORK(&pm2->ac_work, pm2xxx_charger_ac_work);
/* Init work for checking HW status */
INIT_WORK(&pm2->check_main_thermal_prot_work,
pm2xxx_charger_check_main_thermal_prot_work);
/* Init work for HW failure check */
INIT_DEFERRABLE_WORK(&pm2->check_hw_failure_work,
pm2xxx_charger_check_hw_failure_work);
/*
* VDD ADC supply needs to be enabled from this driver when there
* is a charger connected to avoid erroneous BTEMP_HIGH/LOW
* interrupts during charging
*/
pm2->regu = regulator_get(pm2->dev, "vddadc");
if (IS_ERR(pm2->regu)) {
ret = PTR_ERR(pm2->regu);
dev_err(pm2->dev, "failed to get vddadc regulator\n");
goto free_charger_wq;
}
/* Register AC charger class */
pm2->ac_chg.psy = power_supply_register(pm2->dev, &pm2->ac_chg_desc,
&psy_cfg);
if (IS_ERR(pm2->ac_chg.psy)) {
dev_err(pm2->dev, "failed to register AC charger\n");
ret = PTR_ERR(pm2->ac_chg.psy);
goto free_regulator;
}
/* Register interrupts */
ret = request_threaded_irq(gpio_to_irq(pm2->pdata->gpio_irq_number),
NULL,
pm2xxx_charger_irq[0].isr,
pm2->pdata->irq_type,
pm2xxx_charger_irq[0].name, pm2);
if (ret != 0) {
dev_err(pm2->dev, "failed to request %s IRQ %d: %d\n",
pm2xxx_charger_irq[0].name,
gpio_to_irq(pm2->pdata->gpio_irq_number), ret);
goto unregister_pm2xxx_charger;
}
ret = pm_runtime_set_active(pm2->dev);
if (ret)
dev_err(pm2->dev, "set active Error\n");
pm_runtime_enable(pm2->dev);
pm_runtime_set_autosuspend_delay(pm2->dev, PM2XXX_AUTOSUSPEND_DELAY);
pm_runtime_use_autosuspend(pm2->dev);
pm_runtime_resume(pm2->dev);
/* pm interrupt can wake up system */
ret = enable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
if (ret) {
dev_err(pm2->dev, "failed to set irq wake\n");
goto unregister_pm2xxx_interrupt;
}
mutex_init(&pm2->lock);
if (gpio_is_valid(pm2->pdata->lpn_gpio)) {
/* get lpn GPIO from platform data */
pm2->lpn_pin = pm2->pdata->lpn_gpio;
/*
* Charger detection mechanism requires pulling up the LPN pin
* while i2c communication if Charger is not connected
* LPN pin of PM2301 is GPIO60 of AB9540
*/
ret = gpio_request(pm2->lpn_pin, "pm2301_lpm_gpio");
if (ret < 0) {
dev_err(pm2->dev, "pm2301_lpm_gpio request failed\n");
goto disable_pm2_irq_wake;
}
ret = gpio_direction_output(pm2->lpn_pin, 0);
if (ret < 0) {
dev_err(pm2->dev, "pm2301_lpm_gpio direction failed\n");
goto free_gpio;
}
set_lpn_pin(pm2);
}
/* read interrupt registers */
for (i = 0; i < PM2XXX_NUM_INT_REG; i++)
pm2xxx_reg_read(pm2,
pm2xxx_interrupt_registers[i],
&val);
ret = pm2xxx_charger_detection(pm2, &val);
if ((ret == 0) && val) {
pm2->ac.charger_connected = 1;
ab8500_override_turn_on_stat(~AB8500_POW_KEY_1_ON,
AB8500_MAIN_CH_DET);
pm2->ac_conn = true;
power_supply_changed(pm2->ac_chg.psy);
sysfs_notify(&pm2->ac_chg.psy->dev.kobj, NULL, "present");
}
return 0;
free_gpio:
if (gpio_is_valid(pm2->lpn_pin))
gpio_free(pm2->lpn_pin);
disable_pm2_irq_wake:
disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
unregister_pm2xxx_interrupt:
/* disable interrupt */
free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2);
unregister_pm2xxx_charger:
/* unregister power supply */
power_supply_unregister(pm2->ac_chg.psy);
free_regulator:
/* disable the regulator */
regulator_put(pm2->regu);
free_charger_wq:
destroy_workqueue(pm2->charger_wq);
free_device_info:
kfree(pm2);
return ret;
}
