| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Michael Hennerich | 4201 | 96.09% | 3 | 23.08% |
| Dmitry Torokhov | 141 | 3.23% | 1 | 7.69% |
| JJ Ding | 8 | 0.18% | 1 | 7.69% |
| Dan Carpenter | 6 | 0.14% | 1 | 7.69% |
| Wolfram Sang | 5 | 0.11% | 2 | 15.38% |
| Jingoo Han | 3 | 0.07% | 1 | 7.69% |
| Paul Gortmaker | 3 | 0.07% | 1 | 7.69% |
| Thomas Gleixner | 2 | 0.05% | 1 | 7.69% |
| Arnd Bergmann | 2 | 0.05% | 1 | 7.69% |
| Lucas De Marchi | 1 | 0.02% | 1 | 7.69% |
| Total | 4372 | 13 |
// SPDX-License-Identifier: GPL-2.0-or-later /* * ADXL345/346 Three-Axis Digital Accelerometers * * Enter bugs at http://blackfin.uclinux.org/ * * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc. */ #include <linux/device.h> #include <linux/delay.h> #include <linux/input.h> #include <linux/interrupt.h> #include <linux/irq.h> #include <linux/slab.h> #include <linux/workqueue.h> #include <linux/input/adxl34x.h> #include <linux/module.h> #include "adxl34x.h" /* ADXL345/6 Register Map */ #define DEVID 0x00 /* R Device ID */ #define THRESH_TAP 0x1D /* R/W Tap threshold */ #define OFSX 0x1E /* R/W X-axis offset */ #define OFSY 0x1F /* R/W Y-axis offset */ #define OFSZ 0x20 /* R/W Z-axis offset */ #define DUR 0x21 /* R/W Tap duration */ #define LATENT 0x22 /* R/W Tap latency */ #define WINDOW 0x23 /* R/W Tap window */ #define THRESH_ACT 0x24 /* R/W Activity threshold */ #define THRESH_INACT 0x25 /* R/W Inactivity threshold */ #define TIME_INACT 0x26 /* R/W Inactivity time */ #define ACT_INACT_CTL 0x27 /* R/W Axis enable control for activity and */ /* inactivity detection */ #define THRESH_FF 0x28 /* R/W Free-fall threshold */ #define TIME_FF 0x29 /* R/W Free-fall time */ #define TAP_AXES 0x2A /* R/W Axis control for tap/double tap */ #define ACT_TAP_STATUS 0x2B /* R Source of tap/double tap */ #define BW_RATE 0x2C /* R/W Data rate and power mode control */ #define POWER_CTL 0x2D /* R/W Power saving features control */ #define INT_ENABLE 0x2E /* R/W Interrupt enable control */ #define INT_MAP 0x2F /* R/W Interrupt mapping control */ #define INT_SOURCE 0x30 /* R Source of interrupts */ #define DATA_FORMAT 0x31 /* R/W Data format control */ #define DATAX0 0x32 /* R X-Axis Data 0 */ #define DATAX1 0x33 /* R X-Axis Data 1 */ #define DATAY0 0x34 /* R Y-Axis Data 0 */ #define DATAY1 0x35 /* R Y-Axis Data 1 */ #define DATAZ0 0x36 /* R Z-Axis Data 0 */ #define DATAZ1 0x37 /* R Z-Axis Data 1 */ #define FIFO_CTL 0x38 /* R/W FIFO control */ #define FIFO_STATUS 0x39 /* R FIFO status */ #define TAP_SIGN 0x3A /* R Sign and source for tap/double tap */ /* Orientation ADXL346 only */ #define ORIENT_CONF 0x3B /* R/W Orientation configuration */ #define ORIENT 0x3C /* R Orientation status */ /* DEVIDs */ #define ID_ADXL345 0xE5 #define ID_ADXL346 0xE6 /* INT_ENABLE/INT_MAP/INT_SOURCE Bits */ #define DATA_READY (1 << 7) #define SINGLE_TAP (1 << 6) #define DOUBLE_TAP (1 << 5) #define ACTIVITY (1 << 4) #define INACTIVITY (1 << 3) #define FREE_FALL (1 << 2) #define WATERMARK (1 << 1) #define OVERRUN (1 << 0) /* ACT_INACT_CONTROL Bits */ #define ACT_ACDC (1 << 7) #define ACT_X_EN (1 << 6) #define ACT_Y_EN (1 << 5) #define ACT_Z_EN (1 << 4) #define INACT_ACDC (1 << 3) #define INACT_X_EN (1 << 2) #define INACT_Y_EN (1 << 1) #define INACT_Z_EN (1 << 0) /* TAP_AXES Bits */ #define SUPPRESS (1 << 3) #define TAP_X_EN (1 << 2) #define TAP_Y_EN (1 << 1) #define TAP_Z_EN (1 << 0) /* ACT_TAP_STATUS Bits */ #define ACT_X_SRC (1 << 6) #define ACT_Y_SRC (1 << 5) #define ACT_Z_SRC (1 << 4) #define ASLEEP (1 << 3) #define TAP_X_SRC (1 << 2) #define TAP_Y_SRC (1 << 1) #define TAP_Z_SRC (1 << 0) /* BW_RATE Bits */ #define LOW_POWER (1 << 4) #define RATE(x) ((x) & 0xF) /* POWER_CTL Bits */ #define PCTL_LINK (1 << 5) #define PCTL_AUTO_SLEEP (1 << 4) #define PCTL_MEASURE (1 << 3) #define PCTL_SLEEP (1 << 2) #define PCTL_WAKEUP(x) ((x) & 0x3) /* DATA_FORMAT Bits */ #define SELF_TEST (1 << 7) #define SPI (1 << 6) #define INT_INVERT (1 << 5) #define FULL_RES (1 << 3) #define JUSTIFY (1 << 2) #define RANGE(x) ((x) & 0x3) #define RANGE_PM_2g 0 #define RANGE_PM_4g 1 #define RANGE_PM_8g 2 #define RANGE_PM_16g 3 /* * Maximum value our axis may get in full res mode for the input device * (signed 13 bits) */ #define ADXL_FULLRES_MAX_VAL 4096 /* * Maximum value our axis may get in fixed res mode for the input device * (signed 10 bits) */ #define ADXL_FIXEDRES_MAX_VAL 512 /* FIFO_CTL Bits */ #define FIFO_MODE(x) (((x) & 0x3) << 6) #define FIFO_BYPASS 0 #define FIFO_FIFO 1 #define FIFO_STREAM 2 #define FIFO_TRIGGER 3 #define TRIGGER (1 << 5) #define SAMPLES(x) ((x) & 0x1F) /* FIFO_STATUS Bits */ #define FIFO_TRIG (1 << 7) #define ENTRIES(x) ((x) & 0x3F) /* TAP_SIGN Bits ADXL346 only */ #define XSIGN (1 << 6) #define YSIGN (1 << 5) #define ZSIGN (1 << 4) #define XTAP (1 << 3) #define YTAP (1 << 2) #define ZTAP (1 << 1) /* ORIENT_CONF ADXL346 only */ #define ORIENT_DEADZONE(x) (((x) & 0x7) << 4) #define ORIENT_DIVISOR(x) ((x) & 0x7) /* ORIENT ADXL346 only */ #define ADXL346_2D_VALID (1 << 6) #define ADXL346_2D_ORIENT(x) (((x) & 0x30) >> 4) #define ADXL346_3D_VALID (1 << 3) #define ADXL346_3D_ORIENT(x) ((x) & 0x7) #define ADXL346_2D_PORTRAIT_POS 0 /* +X */ #define ADXL346_2D_PORTRAIT_NEG 1 /* -X */ #define ADXL346_2D_LANDSCAPE_POS 2 /* +Y */ #define ADXL346_2D_LANDSCAPE_NEG 3 /* -Y */ #define ADXL346_3D_FRONT 3 /* +X */ #define ADXL346_3D_BACK 4 /* -X */ #define ADXL346_3D_RIGHT 2 /* +Y */ #define ADXL346_3D_LEFT 5 /* -Y */ #define ADXL346_3D_TOP 1 /* +Z */ #define ADXL346_3D_BOTTOM 6 /* -Z */ #undef ADXL_DEBUG #define ADXL_X_AXIS 0 #define ADXL_Y_AXIS 1 #define ADXL_Z_AXIS 2 #define AC_READ(ac, reg) ((ac)->bops->read((ac)->dev, reg)) #define AC_WRITE(ac, reg, val) ((ac)->bops->write((ac)->dev, reg, val)) struct axis_triple { int x; int y; int z; }; struct adxl34x { struct device *dev; struct input_dev *input; struct mutex mutex; /* reentrant protection for struct */ struct adxl34x_platform_data pdata; struct axis_triple swcal; struct axis_triple hwcal; struct axis_triple saved; char phys[32]; unsigned orient2d_saved; unsigned orient3d_saved; bool disabled; /* P: mutex */ bool opened; /* P: mutex */ bool suspended; /* P: mutex */ bool fifo_delay; int irq; unsigned model; unsigned int_mask; const struct adxl34x_bus_ops *bops; }; static const struct adxl34x_platform_data adxl34x_default_init = { .tap_threshold = 35, .tap_duration = 3, .tap_latency = 20, .tap_window = 20, .tap_axis_control = ADXL_TAP_X_EN | ADXL_TAP_Y_EN | ADXL_TAP_Z_EN, .act_axis_control = 0xFF, .activity_threshold = 6, .inactivity_threshold = 4, .inactivity_time = 3, .free_fall_threshold = 8, .free_fall_time = 0x20, .data_rate = 8, .data_range = ADXL_FULL_RES, .ev_type = EV_ABS, .ev_code_x = ABS_X, /* EV_REL */ .ev_code_y = ABS_Y, /* EV_REL */ .ev_code_z = ABS_Z, /* EV_REL */ .ev_code_tap = {BTN_TOUCH, BTN_TOUCH, BTN_TOUCH}, /* EV_KEY {x,y,z} */ .power_mode = ADXL_AUTO_SLEEP | ADXL_LINK, .fifo_mode = ADXL_FIFO_STREAM, .watermark = 0, }; static void adxl34x_get_triple(struct adxl34x *ac, struct axis_triple *axis) { short buf[3]; ac->bops->read_block(ac->dev, DATAX0, DATAZ1 - DATAX0 + 1, buf); mutex_lock(&ac->mutex); ac->saved.x = (s16) le16_to_cpu(buf[0]); axis->x = ac->saved.x; ac->saved.y = (s16) le16_to_cpu(buf[1]); axis->y = ac->saved.y; ac->saved.z = (s16) le16_to_cpu(buf[2]); axis->z = ac->saved.z; mutex_unlock(&ac->mutex); } static void adxl34x_service_ev_fifo(struct adxl34x *ac) { struct adxl34x_platform_data *pdata = &ac->pdata; struct axis_triple axis; adxl34x_get_triple(ac, &axis); input_event(ac->input, pdata->ev_type, pdata->ev_code_x, axis.x - ac->swcal.x); input_event(ac->input, pdata->ev_type, pdata->ev_code_y, axis.y - ac->swcal.y); input_event(ac->input, pdata->ev_type, pdata->ev_code_z, axis.z - ac->swcal.z); } static void adxl34x_report_key_single(struct input_dev *input, int key) { input_report_key(input, key, true); input_sync(input); input_report_key(input, key, false); } static void adxl34x_send_key_events(struct adxl34x *ac, struct adxl34x_platform_data *pdata, int status, int press) { int i; for (i = ADXL_X_AXIS; i <= ADXL_Z_AXIS; i++) { if (status & (1 << (ADXL_Z_AXIS - i))) input_report_key(ac->input, pdata->ev_code_tap[i], press); } } static void adxl34x_do_tap(struct adxl34x *ac, struct adxl34x_platform_data *pdata, int status) { adxl34x_send_key_events(ac, pdata, status, true); input_sync(ac->input); adxl34x_send_key_events(ac, pdata, status, false); } static irqreturn_t adxl34x_irq(int irq, void *handle) { struct adxl34x *ac = handle; struct adxl34x_platform_data *pdata = &ac->pdata; int int_stat, tap_stat, samples, orient, orient_code; /* * ACT_TAP_STATUS should be read before clearing the interrupt * Avoid reading ACT_TAP_STATUS in case TAP detection is disabled */ if (pdata->tap_axis_control & (TAP_X_EN | TAP_Y_EN | TAP_Z_EN)) tap_stat = AC_READ(ac, ACT_TAP_STATUS); else tap_stat = 0; int_stat = AC_READ(ac, INT_SOURCE); if (int_stat & FREE_FALL) adxl34x_report_key_single(ac->input, pdata->ev_code_ff); if (int_stat & OVERRUN) dev_dbg(ac->dev, "OVERRUN\n"); if (int_stat & (SINGLE_TAP | DOUBLE_TAP)) { adxl34x_do_tap(ac, pdata, tap_stat); if (int_stat & DOUBLE_TAP) adxl34x_do_tap(ac, pdata, tap_stat); } if (pdata->ev_code_act_inactivity) { if (int_stat & ACTIVITY) input_report_key(ac->input, pdata->ev_code_act_inactivity, 1); if (int_stat & INACTIVITY) input_report_key(ac->input, pdata->ev_code_act_inactivity, 0); } /* * ORIENTATION SENSING ADXL346 only */ if (pdata->orientation_enable) { orient = AC_READ(ac, ORIENT); if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_2D) && (orient & ADXL346_2D_VALID)) { orient_code = ADXL346_2D_ORIENT(orient); /* Report orientation only when it changes */ if (ac->orient2d_saved != orient_code) { ac->orient2d_saved = orient_code; adxl34x_report_key_single(ac->input, pdata->ev_codes_orient_2d[orient_code]); } } if ((pdata->orientation_enable & ADXL_EN_ORIENTATION_3D) && (orient & ADXL346_3D_VALID)) { orient_code = ADXL346_3D_ORIENT(orient) - 1; /* Report orientation only when it changes */ if (ac->orient3d_saved != orient_code) { ac->orient3d_saved = orient_code; adxl34x_report_key_single(ac->input, pdata->ev_codes_orient_3d[orient_code]); } } } if (int_stat & (DATA_READY | WATERMARK)) { if (pdata->fifo_mode) samples = ENTRIES(AC_READ(ac, FIFO_STATUS)) + 1; else samples = 1; for (; samples > 0; samples--) { adxl34x_service_ev_fifo(ac); /* * To ensure that the FIFO has * completely popped, there must be at least 5 us between * the end of reading the data registers, signified by the * transition to register 0x38 from 0x37 or the CS pin * going high, and the start of new reads of the FIFO or * reading the FIFO_STATUS register. For SPI operation at * 1.5 MHz or lower, the register addressing portion of the * transmission is sufficient delay to ensure the FIFO has * completely popped. It is necessary for SPI operation * greater than 1.5 MHz to de-assert the CS pin to ensure a * total of 5 us, which is at most 3.4 us at 5 MHz * operation. */ if (ac->fifo_delay && (samples > 1)) udelay(3); } } input_sync(ac->input); return IRQ_HANDLED; } static void __adxl34x_disable(struct adxl34x *ac) { /* * A '0' places the ADXL34x into standby mode * with minimum power consumption. */ AC_WRITE(ac, POWER_CTL, 0); } static void __adxl34x_enable(struct adxl34x *ac) { AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE); } void adxl34x_suspend(struct adxl34x *ac) { mutex_lock(&ac->mutex); if (!ac->suspended && !ac->disabled && ac->opened) __adxl34x_disable(ac); ac->suspended = true; mutex_unlock(&ac->mutex); } EXPORT_SYMBOL_GPL(adxl34x_suspend); void adxl34x_resume(struct adxl34x *ac) { mutex_lock(&ac->mutex); if (ac->suspended && !ac->disabled && ac->opened) __adxl34x_enable(ac); ac->suspended = false; mutex_unlock(&ac->mutex); } EXPORT_SYMBOL_GPL(adxl34x_resume); static ssize_t adxl34x_disable_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); return sprintf(buf, "%u\n", ac->disabled); } static ssize_t adxl34x_disable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); unsigned int val; int error; error = kstrtouint(buf, 10, &val); if (error) return error; mutex_lock(&ac->mutex); if (!ac->suspended && ac->opened) { if (val) { if (!ac->disabled) __adxl34x_disable(ac); } else { if (ac->disabled) __adxl34x_enable(ac); } } ac->disabled = !!val; mutex_unlock(&ac->mutex); return count; } static DEVICE_ATTR(disable, 0664, adxl34x_disable_show, adxl34x_disable_store); static ssize_t adxl34x_calibrate_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); ssize_t count; mutex_lock(&ac->mutex); count = sprintf(buf, "%d,%d,%d\n", ac->hwcal.x * 4 + ac->swcal.x, ac->hwcal.y * 4 + ac->swcal.y, ac->hwcal.z * 4 + ac->swcal.z); mutex_unlock(&ac->mutex); return count; } static ssize_t adxl34x_calibrate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); /* * Hardware offset calibration has a resolution of 15.6 mg/LSB. * We use HW calibration and handle the remaining bits in SW. (4mg/LSB) */ mutex_lock(&ac->mutex); ac->hwcal.x -= (ac->saved.x / 4); ac->swcal.x = ac->saved.x % 4; ac->hwcal.y -= (ac->saved.y / 4); ac->swcal.y = ac->saved.y % 4; ac->hwcal.z -= (ac->saved.z / 4); ac->swcal.z = ac->saved.z % 4; AC_WRITE(ac, OFSX, (s8) ac->hwcal.x); AC_WRITE(ac, OFSY, (s8) ac->hwcal.y); AC_WRITE(ac, OFSZ, (s8) ac->hwcal.z); mutex_unlock(&ac->mutex); return count; } static DEVICE_ATTR(calibrate, 0664, adxl34x_calibrate_show, adxl34x_calibrate_store); static ssize_t adxl34x_rate_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); return sprintf(buf, "%u\n", RATE(ac->pdata.data_rate)); } static ssize_t adxl34x_rate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); unsigned char val; int error; error = kstrtou8(buf, 10, &val); if (error) return error; mutex_lock(&ac->mutex); ac->pdata.data_rate = RATE(val); AC_WRITE(ac, BW_RATE, ac->pdata.data_rate | (ac->pdata.low_power_mode ? LOW_POWER : 0)); mutex_unlock(&ac->mutex); return count; } static DEVICE_ATTR(rate, 0664, adxl34x_rate_show, adxl34x_rate_store); static ssize_t adxl34x_autosleep_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); return sprintf(buf, "%u\n", ac->pdata.power_mode & (PCTL_AUTO_SLEEP | PCTL_LINK) ? 1 : 0); } static ssize_t adxl34x_autosleep_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); unsigned int val; int error; error = kstrtouint(buf, 10, &val); if (error) return error; mutex_lock(&ac->mutex); if (val) ac->pdata.power_mode |= (PCTL_AUTO_SLEEP | PCTL_LINK); else ac->pdata.power_mode &= ~(PCTL_AUTO_SLEEP | PCTL_LINK); if (!ac->disabled && !ac->suspended && ac->opened) AC_WRITE(ac, POWER_CTL, ac->pdata.power_mode | PCTL_MEASURE); mutex_unlock(&ac->mutex); return count; } static DEVICE_ATTR(autosleep, 0664, adxl34x_autosleep_show, adxl34x_autosleep_store); static ssize_t adxl34x_position_show(struct device *dev, struct device_attribute *attr, char *buf) { struct adxl34x *ac = dev_get_drvdata(dev); ssize_t count; mutex_lock(&ac->mutex); count = sprintf(buf, "(%d, %d, %d)\n", ac->saved.x, ac->saved.y, ac->saved.z); mutex_unlock(&ac->mutex); return count; } static DEVICE_ATTR(position, S_IRUGO, adxl34x_position_show, NULL); #ifdef ADXL_DEBUG static ssize_t adxl34x_write_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct adxl34x *ac = dev_get_drvdata(dev); unsigned int val; int error; /* * This allows basic ADXL register write access for debug purposes. */ error = kstrtouint(buf, 16, &val); if (error) return error; mutex_lock(&ac->mutex); AC_WRITE(ac, val >> 8, val & 0xFF); mutex_unlock(&ac->mutex); return count; } static DEVICE_ATTR(write, 0664, NULL, adxl34x_write_store); #endif static struct attribute *adxl34x_attributes[] = { &dev_attr_disable.attr, &dev_attr_calibrate.attr, &dev_attr_rate.attr, &dev_attr_autosleep.attr, &dev_attr_position.attr, #ifdef ADXL_DEBUG &dev_attr_write.attr, #endif NULL }; static const struct attribute_group adxl34x_attr_group = { .attrs = adxl34x_attributes, }; static int adxl34x_input_open(struct input_dev *input) { struct adxl34x *ac = input_get_drvdata(input); mutex_lock(&ac->mutex); if (!ac->suspended && !ac->disabled) __adxl34x_enable(ac); ac->opened = true; mutex_unlock(&ac->mutex); return 0; } static void adxl34x_input_close(struct input_dev *input) { struct adxl34x *ac = input_get_drvdata(input); mutex_lock(&ac->mutex); if (!ac->suspended && !ac->disabled) __adxl34x_disable(ac); ac->opened = false; mutex_unlock(&ac->mutex); } struct adxl34x *adxl34x_probe(struct device *dev, int irq, bool fifo_delay_default, const struct adxl34x_bus_ops *bops) { struct adxl34x *ac; struct input_dev *input_dev; const struct adxl34x_platform_data *pdata; int err, range, i; unsigned char revid; if (!irq) { dev_err(dev, "no IRQ?\n"); err = -ENODEV; goto err_out; } ac = kzalloc(sizeof(*ac), GFP_KERNEL); input_dev = input_allocate_device(); if (!ac || !input_dev) { err = -ENOMEM; goto err_free_mem; } ac->fifo_delay = fifo_delay_default; pdata = dev_get_platdata(dev); if (!pdata) { dev_dbg(dev, "No platform data: Using default initialization\n"); pdata = &adxl34x_default_init; } ac->pdata = *pdata; pdata = &ac->pdata; ac->input = input_dev; ac->dev = dev; ac->irq = irq; ac->bops = bops; mutex_init(&ac->mutex); input_dev->name = "ADXL34x accelerometer"; revid = AC_READ(ac, DEVID); switch (revid) { case ID_ADXL345: ac->model = 345; break; case ID_ADXL346: ac->model = 346; break; default: dev_err(dev, "Failed to probe %s\n", input_dev->name); err = -ENODEV; goto err_free_mem; } snprintf(ac->phys, sizeof(ac->phys), "%s/input0", dev_name(dev)); input_dev->phys = ac->phys; input_dev->dev.parent = dev; input_dev->id.product = ac->model; input_dev->id.bustype = bops->bustype; input_dev->open = adxl34x_input_open; input_dev->close = adxl34x_input_close; 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[ADXL_X_AXIS], input_dev->keybit); __set_bit(pdata->ev_code_tap[ADXL_Y_AXIS], input_dev->keybit); __set_bit(pdata->ev_code_tap[ADXL_Z_AXIS], 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) == FIFO_BYPASS) ac->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 = false; AC_WRITE(ac, POWER_CTL, 0); err = request_threaded_irq(ac->irq, NULL, adxl34x_irq, IRQF_TRIGGER_HIGH | IRQF_ONESHOT, dev_name(dev), ac); if (err) { dev_err(dev, "irq %d busy?\n", ac->irq); goto err_free_mem; } err = sysfs_create_group(&dev->kobj, &adxl34x_attr_group); if (err) goto err_free_irq; err = input_register_device(input_dev); if (err) goto err_remove_attr; 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)); if (pdata->use_int2) { /* Map all INTs to INT2 */ AC_WRITE(ac, INT_MAP, ac->int_mask | OVERRUN); } else { /* Map all INTs to INT1 */ AC_WRITE(ac, INT_MAP, 0); } if (ac->model == 346 && ac->pdata.orientation_enable) { AC_WRITE(ac, ORIENT_CONF, ORIENT_DEADZONE(ac->pdata.deadzone_angle) | ORIENT_DIVISOR(ac->pdata.divisor_length)); ac->orient2d_saved = 1234; ac->orient3d_saved = 1234; if (pdata->orientation_enable & ADXL_EN_ORIENTATION_3D) for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_3d); i++) __set_bit(pdata->ev_codes_orient_3d[i], input_dev->keybit); if (pdata->orientation_enable & ADXL_EN_ORIENTATION_2D) for (i = 0; i < ARRAY_SIZE(pdata->ev_codes_orient_2d); i++) __set_bit(pdata->ev_codes_orient_2d[i], input_dev->keybit); } else { ac->pdata.orientation_enable = 0; } AC_WRITE(ac, INT_ENABLE, ac->int_mask | OVERRUN); ac->pdata.power_mode &= (PCTL_AUTO_SLEEP | PCTL_LINK); return ac; err_remove_attr: sysfs_remove_group(&dev->kobj, &adxl34x_attr_group); err_free_irq: free_irq(ac->irq, ac); err_free_mem: input_free_device(input_dev); kfree(ac); err_out: return ERR_PTR(err); } EXPORT_SYMBOL_GPL(adxl34x_probe); int adxl34x_remove(struct adxl34x *ac) { sysfs_remove_group(&ac->dev->kobj, &adxl34x_attr_group); free_irq(ac->irq, ac); input_unregister_device(ac->input); dev_dbg(ac->dev, "unregistered accelerometer\n"); kfree(ac); return 0; } EXPORT_SYMBOL_GPL(adxl34x_remove); MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer Driver"); MODULE_LICENSE("GPL");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1