static int aps_12d_probe(
struct i2c_client *client, const struct i2c_device_id *id)
{
/* define and initialization the value */
int value_lsb = 0;
int value_msb = 0;
int ret;
struct aps_data *aps;
/*the aps_12d sensors ispower on*/
int i;
#ifdef CONFIG_ARCH_MSM7X30
struct vreg *vreg_gp4=NULL;
int rc;
/*delete this line,27A don't have to match the power supply*/
vreg_gp4 = vreg_get(NULL, VREG_GP4_NAME);
if (IS_ERR(vreg_gp4))
{
pr_err("%s:gp4 power init get failed\n", __func__);
}
/* set gp4 voltage as 2700mV for all */
rc = vreg_set_level(vreg_gp4,VREG_GP4_VOLTAGE_VALUE_2700);
if (rc) {
pr_err("%s: vreg_gp4 vreg_set_level failed (%d)\n", __func__, rc);
return rc;
}
rc = vreg_enable(vreg_gp4);
if (rc) {
pr_err("%s: vreg_gp4 vreg_enable failed (%d)\n", __func__, rc);
return rc;
}
#endif
mdelay(5);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
printk(KERN_ERR "aps_12d_probe: need I2C_FUNC_I2C\n");
ret = -ENODEV;
goto err_check_functionality_failed;
}
/* if querry the board is T1 or T2 turn off the proximity */
/* This modification for version A&B of U8800,only */
if((machine_is_msm7x30_u8800())&&((get_hw_sub_board_id() == HW_VER_SUB_VA) || ((get_hw_sub_board_id() == HW_VER_SUB_VB))))
{
printk(KERN_ERR "aps_12d_probe: aps is not supported in U8800 and U8800 T1 board!\n");
ret = -ENODEV;
goto err_check_functionality_failed;
}
aps = kzalloc(sizeof(*aps), GFP_KERNEL);
if (aps == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
mutex_init(&aps->mlock);
INIT_WORK(&aps->work, aps_12d_work_func);
aps->client = client;
i2c_set_clientdata(client, aps);
PROXIMITY_DEBUG(KERN_INFO "ghj aps_12d_probe send command 2\n ");
/* Command 2 register: 25mA,DC,12bit,Range1 */
/*power_down to avoid the iic read error */
aps_i2c_reg_write(aps, APS_12D_REG_CMD1, APS_12D_POWER_DOWN);
/*init the flag,because everlight's 0x06,0x07's register's value low 4 bit is 0*/
value_lsb = aps_i2c_reg_read(aps, APS_INT_HT_LSB);
value_msb = aps_i2c_reg_read(aps, APS_INT_HT_MSB);
old_lsb = value_lsb;
old_msb = value_msb;
/* debug--- stare at the value of lsb & msb */
APS_DBG("value_lsb=%d,value_msb=%d\n",value_lsb,value_msb);
/* judge the device type */
/* when 06 07 registers don't equal 0x00, we think it's a intersil hardware */
if((0x00 == value_lsb) && (0x00 == value_msb))
{
intersil_flag = EVERLIGHT;
}
else
{
intersil_flag = INTERSIL;
}
/* write reg value for the two device */
if(EVERLIGHT == intersil_flag)
{
ret = aps_i2c_reg_write(aps, APS_12D_REG_CMD2, \
(uint8_t)(APS_12D_IRDR_SEL_50MA << 6 | \
APS_12D_FREQ_SEL_DC << 4 | \
APS_12D_RES_SEL_12 << 2 | \
APS_12D_RANGE_SEL_ALS_1000));
}
else
{
/*because Power-up and Power Supply Considerations is not good enough for intersil's datasheet,so avoid it via software*/
ret = aps_i2c_reg_write(aps, APS_TEST, APS_12D_POWER_DOWN);
if (ret < 0)
{
PROXIMITY_DEBUG("APS_TEST error!\n");
}
msleep(10);
ret = aps_i2c_reg_write(aps, APS_12D_REG_CMD1, APS_12D_POWER_DOWN);
if (ret < 0)
{
PROXIMITY_DEBUG("APS_12D_POWER_DOWN error!\n");
}
msleep(10);
ret = aps_i2c_reg_write(aps, APS_12D_REG_CMD2, \
(uint8_t)(APS_12D_IRDR_SEL_INTERSIL_50MA << 4 | \
APS_FREQ_INTERSIL_DC << 6 | \
APS_ADC_12 << 2 | \
APS_INTERSIL_SCHEME_OFF| \
APS_12D_RANGE_SEL_ALS_1000));
}
err_threshold_value[1] = 50;
if (ret < 0) {
goto err_detect_failed;
}
range_index = 0;
#ifdef CONFIG_HUAWEI_HW_DEV_DCT
/* detect current device successful, set the flag as present */
set_hw_dev_flag(DEV_I2C_APS);
#endif
for(i = 0; i < TOTAL_RANGE_NUM; i++)
{
/* NOTE: do NOT use the last one */
/* get the down_range_value */
if(EVERLIGHT == intersil_flag)
{
up_range_value[i] = MAX_ADC_OUTPUT - high_threshold_value_U8661[i] - RANGE_FIX + 500;
}
else
{
up_range_value[i] = MAX_ADC_OUTPUT - high_threshold_value_U8661_I[i] - RANGE_FIX + 500;
}
}
down_range_value[0] = 0;
for(i = 1; i < TOTAL_RANGE_NUM; i++)
{
/* NOTE: do not use the first one */
/* get the down_range_value */
if(EVERLIGHT == intersil_flag)
{
down_range_value[i] = (MAX_ADC_OUTPUT - high_threshold_value_U8661[i-1] - (MAX_ADC_OUTPUT / ADJUST_GATE)) / 4 - 650;
}
else
{
down_range_value[i] = (MAX_ADC_OUTPUT - high_threshold_value_U8661_I[i-1] - (MAX_ADC_OUTPUT / ADJUST_GATE)) / 4 - 650;
}
}
/*we don't use the input device sensors again */
aps->input_dev = input_allocate_device();
if (aps->input_dev == NULL) {
ret = -ENOMEM;
PROXIMITY_DEBUG(KERN_ERR "aps_12d_probe: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
aps->input_dev->name = "sensors_aps";
aps->input_dev->id.bustype = BUS_I2C;
input_set_drvdata(aps->input_dev, aps);
ret = input_register_device(aps->input_dev);
if (ret) {
printk(KERN_ERR "aps_probe: Unable to register %s input device\n", aps->input_dev->name);
goto err_input_register_device_failed;
}
set_bit(EV_ABS, aps->input_dev->evbit);
input_set_abs_params(aps->input_dev, ABS_LIGHT, 0, 10240, 0, 0);
input_set_abs_params(aps->input_dev, ABS_DISTANCE, 0, 1, 0, 0);
ret = misc_register(&light_device);
if (ret) {
printk(KERN_ERR "aps_12d_probe: light_device register failed\n");
goto err_light_misc_device_register_failed;
}
ret = misc_register(&proximity_device);
if (ret) {
printk(KERN_ERR "aps_12d_probe: proximity_device register failed\n");
goto err_proximity_misc_device_register_failed;
}
if( light_device.minor != MISC_DYNAMIC_MINOR ){
light_device_minor = light_device.minor;
}
if( proximity_device.minor != MISC_DYNAMIC_MINOR ){
proximity_device_minor = proximity_device.minor ;
}
wake_lock_init(&proximity_wake_lock, WAKE_LOCK_SUSPEND, "proximity");
hrtimer_init(&aps->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aps->timer.function = aps_timer_func;
aps_wq = create_singlethread_workqueue("aps_wq");
if (!aps_wq)
{
ret = -ENOMEM;
goto err_create_workqueue_failed;
}
this_aps_data =aps;
ret = set_sensor_input(PS, aps->input_dev->dev.kobj.name);
if (ret) {
dev_err(&client->dev, "%s set_sensor_input failed\n", __func__);
goto err_create_workqueue_failed;
}
ret = set_sensor_input(ALS, aps->input_dev->dev.kobj.name);
if (ret) {
dev_err(&client->dev, "%s set_sensor_input failed\n", __func__);
goto err_create_workqueue_failed;
}
/* delete the redundant code */
printk(KERN_INFO "aps_12d_probe: Start Proximity Sensor APS-12D\n");
set_sensors_list(L_SENSOR + P_SENSOR);
return 0;
err_create_workqueue_failed:
misc_deregister(&proximity_device);
err_proximity_misc_device_register_failed:
misc_deregister(&light_device);
err_light_misc_device_register_failed:
err_input_register_device_failed:
input_free_device(aps->input_dev);
err_input_dev_alloc_failed:
err_detect_failed:
kfree(aps);
err_alloc_data_failed:
err_check_functionality_failed:
#ifdef CONFIG_ARCH_MSM7X30
if(NULL != vreg_gp4)
{
/* can't use the flag ret here, it will change the return value of probe function */
vreg_disable(vreg_gp4);
/* delete a line */
}
#endif
return ret;
}
static int l3g4200d_probe(struct i2c_client *client,
const struct i2c_device_id *devid)
{
struct l3g4200d_data *data;
struct gyro_platform_data *platform_data = NULL;
int ret = -1;
int tempvalue;
GYRO_DBG("l3g4200d_probe start!\n");
if (client->dev.platform_data == NULL) {
dev_err(&client->dev, "platform data is NULL. exiting.\n");
ret = -ENODEV;
goto exit;
}
/*gyro mate power*/
platform_data = client->dev.platform_data;
if(platform_data->gyro_power)
{
ret = platform_data->gyro_power(IC_PM_ON);
if( ret < 0)
{
dev_err(&client->dev, "gyro power on error!\n");
goto exit;
}
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
ret = -ENODEV;
goto exit_pm_off;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)){
ret = -ENODEV;
goto exit_pm_off;
}
/*
* OK. For now, we presume we have a valid client. We now create the
* client structure, even though we cannot fill it completely yet.
*/
data = kzalloc(sizeof(struct l3g4200d_data), GFP_KERNEL);
if (NULL == data) {
dev_err(&client->dev,
"failed to allocate memory for module data\n");
ret = -ENOMEM;
goto exit_pm_off;
}
mutex_init(&data->mlock);
INIT_WORK(&data->work, gy_work_func);
i2c_set_clientdata(client, data);
data->client = client;
data->pdata = platform_data;
ret = l3g4200d_validate_pdata(data);
if (ret < 0) {
dev_err(&client->dev, "failed to validate platform data\n");
goto exit_kfree;
}
ret = i2c_smbus_read_byte(client);
if ( ret < 0) {
GYRO_DBG("i2c_smbus_read_byte error!!\n");
goto err_detect_failed;
} else {
GYRO_DBG("L3G4200D Device detected!\n");
}
/* read chip id */
tempvalue = i2c_smbus_read_word_data(client, WHO_AM_I);
if ((tempvalue & 0x00FF) == 0x00D3) {
GYRO_DBG("I2C driver registered!\n");
} else {
data->client = NULL;
ret = -ENODEV;
goto err_detect_failed;
}
if (sensor_dev == NULL)
{
data->input_dev = input_allocate_device();
if (data->input_dev == NULL) {
ret = -ENOMEM;
printk(KERN_ERR "gs_probe: Failed to allocate input device\n");
goto err_input_dev_alloc_failed;
}
data->input_dev->name = "gy_sensors";
sensor_dev = data->input_dev;
}else{
data->input_dev = sensor_dev;
}
data->input_dev->id.vendor = VENDOR;
#if 0
set_bit(EV_REL,data->input_dev->evbit);
set_bit(REL_RX, data->input_dev->absbit);
set_bit(REL_RY, data->input_dev->absbit);
set_bit(REL_RZ, data->input_dev->absbit);
#endif
set_bit(EV_ABS,data->input_dev->evbit);
/* modify the func of init */
input_set_abs_params(data->input_dev, ABS_RX, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_RY, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_RZ, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_X, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_Y, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_Z, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_THROTTLE, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_RUDDER, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_WHEEL, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_GAS, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_HAT0X, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_HAT0Y, MIN_VALUE, MAX_VALUE, 0, 0);
input_set_abs_params(data->input_dev, ABS_BRAKE, MIN_VALUE, MAX_VALUE, 0, 0);
set_bit(EV_SYN,data->input_dev->evbit);
data->input_dev->id.bustype = BUS_I2C;
input_set_drvdata(data->input_dev, data);
ret = input_register_device(data->input_dev);
if (ret) {
printk(KERN_ERR "gy_probe: Unable to register %s input device\n", data->input_dev->name);
/* create l3g-dev device class */
goto err_input_register_device_failed;
}
ret = misc_register(&gysensor_device);
if (ret) {
printk(KERN_ERR "gy_probe: gysensor_device register failed\n");
goto err_misc_device_register_failed;
}
hrtimer_init(&data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
data->timer.function = gy_timer_func;
atomic_set(&a_flag, 0);
data->flags = -1;
#ifdef CONFIG_HAS_EARLYSUSPEND
data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
data->early_suspend.suspend = gy_early_suspend;
data->early_suspend.resume = gy_late_resume;
register_early_suspend(&data->early_suspend);
#endif
GYRO_DBG("L3G4200D device created successfully\n");
gy_wq = create_singlethread_workqueue("gy_wq");
/* log for create workqueue fail */
if (!gy_wq)
{
ret = -ENOMEM;
printk(KERN_ERR "%s, line %d: create_singlethread_workqueue fail!\n", __func__, __LINE__);
goto err_gy_create_workqueue_failed;
}
gyro = data;
// hrtimer_start(&this_gs_data->timer, ktime_set(0, 500000000), HRTIMER_MODE_REL);
#ifdef CONFIG_HUAWEI_HW_DEV_DCT
/* detect current device successful, set the flag as present */
set_hw_dev_flag(DEV_I2C_GYROSCOPE);
#endif
ret = set_sensor_input(GYRO, data->input_dev->dev.kobj.name);
if (ret) {
dev_err(&client->dev, "%s set_sensor_input failed\n", __func__);
goto err_misc_device_register_failed;
}
printk(KERN_DEBUG "l3g4200d_probe successful");
set_sensors_list(GY_SENSOR);
return 0;
/*add gyro exception process*/
err_gy_create_workqueue_failed:
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&data->early_suspend);
#endif
hrtimer_cancel(&data->timer);
err_misc_device_register_failed:
misc_deregister(&gysensor_device);
err_input_register_device_failed:
input_free_device(gyro->input_dev);
err_input_dev_alloc_failed:
err_detect_failed:
exit_kfree:
kfree(gyro);
exit_pm_off:
/*No need to power down*/
exit:
return ret;
}
