{OFSX, 0, 0},
{OFSY, 0, 0},
{OFSZ, 0, 0},
{DUR, 3, 0},
{LATENT, 20, 0},
{WINDOW, 20, 0},
{THRESH_ACT, 4, 0},
{THRESH_INACT, 2, 0},
{TIME_INACT, 6, 0},
{THRESH_FF, 8, 0},
{TIME_FF, 0x20, 0},
{TAP_AXES, 0, 0},
{ACT_INACT_CTL, 0xFF, 0},
{BW_RATE, RATE(8), 0},
{DATA_FORMAT, FULL_RES, 0},
{FIFO_CTL, FIFO_MODE(FIFO_STREAM) | SAMPLES(0), 0},
#ifdef ADXL346_GINT2
{INT_MAP, ADXL34X_INT_MASK | OVERRUN, 0},
#else
{INT_MAP, 0, 0},
#endif
{INT_ENABLE, ADXL34X_INT_MASK | OVERRUN, 0}
};
static int adxl34x_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret;
struct hua_input_chip *chip;
pr_pos_info();
static int __devinit adxl34x_initialize(bus_device *bus, struct adxl34x *ac)
{
struct input_dev *input_dev;
struct adxl34x_platform_data *devpd = bus->dev.platform_data;
struct adxl34x_platform_data *pdata;
int err, range;
unsigned char revid;
if (!bus->irq) {
dev_err(&bus->dev, "no IRQ?\n");
return -ENODEV;
}
if (NULL == devpd) {
dev_err(&bus->dev, "No platfrom data: Using default initialization\n");
return -ENOMEM;
}
memcpy(&ac->pdata, devpd, sizeof(ac->pdata));
pdata = &ac->pdata;
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&bus->dev, "%s: input device allocation failed\n", __func__);
return -ENOMEM;
}
ac->input = input_dev;
ac->disabled = 1;
INIT_WORK(&ac->work, adxl34x_work);
mutex_init(&ac->mutex);
revid = ac->read(bus, DEVID);
switch (revid) {
case ID_ADXL345:
ac->model = ACC_ADXL345;
break;
case ID_ADXL346:
ac->model = ACC_ADXL346;
break;
default:
dev_err(&bus->dev, "Read ACC ADXL Chip ID Err 0x%x\n", revid);
err = -ENODEV;
goto err_free_mem;
}
dev_info(&bus->dev, "Read ACC ADXL OK ,Chip ID is 0x%x\n", revid);
snprintf(ac->phys, sizeof(ac->phys), "%s/input0", dev_name(&bus->dev));
input_dev->name = ACCL_INPUT_DEV_NAME;
input_dev->phys = ac->phys;
input_dev->dev.parent = &bus->dev;
input_dev->id.product = ac->model;
input_dev->id.bustype = BUS_I2C;
/*input_dev->open = adxl34x_input_open;*/
/*input_dev->close = adxl34x_input_close;*/
input_dev->open = NULL;
input_dev->close = NULL;
input_set_drvdata(input_dev, ac);
__set_bit(ac->pdata.ev_type, input_dev->evbit);
if (ac->pdata.ev_type == EV_REL) {
__set_bit(REL_X, input_dev->relbit);
__set_bit(REL_Y, input_dev->relbit);
__set_bit(REL_Z, input_dev->relbit);
} else {
/* EV_ABS */
__set_bit(ABS_X, input_dev->absbit);
__set_bit(ABS_Y, input_dev->absbit);
__set_bit(ABS_Z, input_dev->absbit);
if (pdata->data_range & FULL_RES)
range = ADXL_FULLRES_MAX_VAL; /* Signed 13-bit */
else
range = ADXL_FIXEDRES_MAX_VAL; /* Signed 10-bit */
input_set_abs_params(input_dev, ABS_X, -range, range, 3, 3);
input_set_abs_params(input_dev, ABS_Y, -range, range, 3, 3);
input_set_abs_params(input_dev, ABS_Z, -range, range, 3, 3);
}
__set_bit(EV_KEY, input_dev->evbit);
__set_bit(pdata->ev_code_tap_x, input_dev->keybit);
__set_bit(pdata->ev_code_tap_y, input_dev->keybit);
__set_bit(pdata->ev_code_tap_z, input_dev->keybit);
if (pdata->ev_code_ff) {
ac->int_mask = FREE_FALL;
__set_bit(pdata->ev_code_ff, input_dev->keybit);
}
if (pdata->ev_code_act_inactivity)
__set_bit(pdata->ev_code_act_inactivity, input_dev->keybit);
ac->int_mask |= ACTIVITY | INACTIVITY;
if (pdata->watermark) {
ac->int_mask |= WATERMARK;
if (!FIFO_MODE(pdata->fifo_mode))
pdata->fifo_mode |= FIFO_STREAM;
} else {
ac->int_mask |= DATA_READY;
}
if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN))
ac->int_mask |= SINGLE_TAP | DOUBLE_TAP;
if (FIFO_MODE(pdata->fifo_mode) == FIFO_BYPASS)
ac->fifo_delay = 0;
ac->write(bus, POWER_CTL, 0);
err = adxl34x_config_gpio(&bus->dev, ac);
if (err < 0) {
dev_err(&bus->dev, "%s: failed to config gpio lowpower mode\n", __func__);
goto err_clear_inputdev;
}
if (bus->irq >= 0) {
err = gpio_request(irq_to_gpio(bus->irq), "gsensor_gpio");
if (err) {
dev_err(&bus->dev, "%s: failed to request gpio for irq\n", __func__);
goto err_clear_inputdev;
}
gpio_direction_input(bus->irq);
}
err = sysfs_create_group(&bus->dev.kobj, &adxl34x_attr_group);
if (err) {
dev_err(&bus->dev, "ADXL34X register sysfs failed\n");
goto err_free_gpio;
}
err = input_register_device(input_dev);
if (err) {
dev_err(&bus->dev, "ADXL34X register input device failed\n");
goto err_remove_attr;
}
AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
AC_WRITE(ac, OFSX, pdata->x_axis_offset);
ac->hwcal.x = pdata->x_axis_offset;
AC_WRITE(ac, OFSY, pdata->y_axis_offset);
ac->hwcal.y = pdata->y_axis_offset;
AC_WRITE(ac, OFSZ, pdata->z_axis_offset);
ac->hwcal.z = pdata->z_axis_offset;
AC_WRITE(ac, THRESH_TAP, pdata->tap_threshold);
AC_WRITE(ac, DUR, pdata->tap_duration);
AC_WRITE(ac, LATENT, pdata->tap_latency);
AC_WRITE(ac, WINDOW, pdata->tap_window);
AC_WRITE(ac, THRESH_ACT, pdata->activity_threshold);
AC_WRITE(ac, THRESH_INACT, pdata->inactivity_threshold);
AC_WRITE(ac, TIME_INACT, pdata->inactivity_time);
AC_WRITE(ac, THRESH_FF, pdata->free_fall_threshold);
AC_WRITE(ac, TIME_FF, pdata->free_fall_time);
AC_WRITE(ac, TAP_AXES, pdata->tap_axis_control);
AC_WRITE(ac, ACT_INACT_CTL, pdata->act_axis_control);
AC_WRITE(ac, BW_RATE, RATE(ac->pdata.data_rate) |
(pdata->low_power_mode ? LOW_POWER : 0));
AC_WRITE(ac, DATA_FORMAT, pdata->data_range);
AC_WRITE(ac, FIFO_CTL, FIFO_MODE(pdata->fifo_mode) |
SAMPLES(pdata->watermark));
AC_WRITE(ac, INT_MAP, 0); /* Map all INTs to INT1 */
AC_WRITE(ac, INT_ENABLE, 0);
/* pdata->power_mode &= (PCTL_AUTO_SLEEP | PCTL_LINK); */
pdata->power_mode &= PCTL_LINK;
if (bus->irq >= 0) {
err = request_irq(bus->irq, adxl34x_irq,
IRQF_TRIGGER_HIGH, bus->dev.driver->name, ac);
if (err) {
dev_err(&bus->dev, "irq %d busy?\n", bus->irq);
goto err_unreg_inputdev;
}
}
#ifdef CONFIG_HUAWEI_SENSORS_INPUT_INFO
err = set_sensor_input(ACC, input_dev->dev.kobj.name);
if (err) {
if (bus->irq >= 0) {
free_irq(ac->bus->irq, ac);
}
dev_err(&bus->dev, "%s set_sensor_input failed\n", __func__);
goto err_unreg_inputdev;
}
#endif
dev_dbg(&bus->dev, "ADXL%d accelerometer, irq %d\n",
ac->model, bus->irq);
return 0;
err_unreg_inputdev:
input_unregister_device(input_dev);
err_remove_attr:
sysfs_remove_group(&bus->dev.kobj, &adxl34x_attr_group);
err_free_gpio:
if (bus->irq >= 0)
gpio_free(irq_to_gpio(bus->irq));
err_clear_inputdev:
input_set_drvdata(input_dev, NULL);
err_free_mem:
input_free_device(input_dev);
return err;
}
