lkml.org 
[lkml]   [2010]   [Nov]   [30]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    Date
    SubjectRE: [PATCH] input: misc: add lps001wp_prs driver
    Hello,

    > -----Original Message-----
    > From: linux-input-owner@vger.kernel.org [mailto:linux-input-
    > owner@vger.kernel.org] On Behalf Of mems applications
    > Sent: Monday, November 29, 2010 10:13 PM
    > To: dmitry.torokhov@gmail.com
    > Cc: linux-input@vger.kernel.org; linux-kernel@vger.kernel.org;
    > matteo.dameno@st.com; carmine.iascone@st.com; mems
    > Subject: [PATCH] input: misc: add lps001wp_prs driver
    >
    > From: mems <mems@mems-laptopT43.(none)>
    >
    > Added STMicroelectronics LPS001WP pressure sensor device driver
    It is a barometric pressure sensor is my understanding correct?

    >
    > Signed-off-by: Matteo Dameno <matteo.dameno@st.com>
    > ---
    > drivers/input/misc/Kconfig | 10 +
    > drivers/input/misc/Makefile | 2 +
    > drivers/input/misc/lps001wp_prs.c | 1288
    > +++++++++++++++++++++++++++++++++++++
    > include/linux/input/lps001wp.h | 82 +++
    > 4 files changed, 1382 insertions(+), 0 deletions(-)
    > create mode 100644 drivers/input/misc/lps001wp_prs.c
    > create mode 100644 include/linux/input/lps001wp.h
    >
    > diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
    > index b99b8cb..689856a 100644
    > --- a/drivers/input/misc/Kconfig
    > +++ b/drivers/input/misc/Kconfig
    > @@ -448,4 +448,14 @@ config INPUT_ADXL34X_SPI
    > To compile this driver as a module, choose M here: the
    > module will be called adxl34x-spi.
    >
    > +config INPUT_LPS001WP_PRS
    > + tristate "STMicro LPS001WP Pressure Temperature Sensor"
    > + depends on I2C
    > + default n
    You may consider removing it as anyways it is the default.

    > + help
    > + If you say yes here you get support for the
    > + STM LPS001D Barometer/Termometer on I2C bus.
    > + This driver can also be built as a module (choose M).
    > + If so, the module will be called lps001wp_prs.
    > +
    > endif
    > diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
    > index 1fe1f6c..0165e60 100644
    > --- a/drivers/input/misc/Makefile
    > +++ b/drivers/input/misc/Makefile
    > @@ -42,4 +42,6 @@ obj-$(CONFIG_INPUT_WINBOND_CIR) += winbond-
    > cir.o
    > obj-$(CONFIG_INPUT_WISTRON_BTNS) += wistron_btns.o
    > obj-$(CONFIG_INPUT_WM831X_ON) += wm831x-on.o
    > obj-$(CONFIG_INPUT_YEALINK) += yealink.o
    > +obj-$(CONFIG_INPUT_LPS001WP_PRS) += lps001wp_prs.o
    > +
    >
    > diff --git a/drivers/input/misc/lps001wp_prs.c
    > b/drivers/input/misc/lps001wp_prs.c
    > new file mode 100644
    > index 0000000..e1a3a95
    > --- /dev/null
    > +++ b/drivers/input/misc/lps001wp_prs.c
    > @@ -0,0 +1,1288 @@
    > +
    > +/******************** (C) COPYRIGHT 2010 STMicroelectronics
    > ********************
    > +*
    > +* File Name : lps001wp_prs.c
    > +* Authors : MSH - Motion Mems BU - Application Team
    > +* : Matteo Dameno (matteo.dameno@st.com)
    > +* : Carmine Iascone (carmine.iascone@st.com)
    > +* : Both authors are willing to be considered the contact
    > +* : and update points for the driver.
    > +* Version : V 1.1.1
    > +* Date : 05/11/2010
    > +* Description : LPS001WP 6D module sensor API
    > +*
    > +*************************************************************************
    > *******
    > +*
    > +* This program is free software; you can redistribute it and/or modify
    > +* it under the terms of the GNU General Public License version 2 as
    > +* published by the Free Software Foundation.
    > +*
    > +* THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT
    > WARRANTIES
    > +* OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE
    > +* PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT.
    > +* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
    > DIRECT,
    > +* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    > FROM THE
    > +* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
    > +* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    > +*
    > +* THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
    > +*
    > +*************************************************************************
    > *****
    > +
    > + Revision 0.9.0 01/10/2010:
    > + first beta release
    > + Revision 1.1.0 05/11/2010:
    > + add sysfs management
    > + Revision 1.1.1 22/11/2010:
    > + moved to input/misc
    > + updated USHRT_MAX,SHRT_MAX,SHRT_MIN macros
    > +*************************************************************************
    > *****/
    > +
    > +#include <linux/err.h>
    > +#include <linux/errno.h>
    > +#include <linux/delay.h>
    > +#include <linux/fs.h>
    > +#include <linux/i2c.h>
    > +
    > +#include <linux/input.h>
    > +#include <linux/uaccess.h>
    > +
    > +#include <linux/workqueue.h>
    > +#include <linux/irq.h>
    > +#include <linux/gpio.h>
    > +#include <linux/interrupt.h>
    > +#include <linux/device.h>
    > +#include <linux/slab.h>
    > +#include <linux/kernel.h>
    > +
    > +#include <linux/input/lps001wp.h>
    > +
    > +
    > +
    > +#define DEBUG 1
    > +
    > +
    > +#define PR_ABS_MAX USHRT_MAX
    > +
    > +#define PR_ABS_MIN (u16)(0U)
    > +#define PR_DLT_MAX SHRT_MAX
    > +#define PR_DLT_MIN SHRT_MIN
    > +#define TEMP_MAX SHRT_MAX
    > +#define TEMP_MIN SHRT_MIN
    > +
    > +
    > +#define SENSITIVITY_T_SHIFT 6 /** = 64 LSB/degrC */
    > +#define SENSITIVITY_P_SHIFT 4 /** = 16 LSB/mbar */
    > +
    > +
    > +#define OUTDATA_REG 0x28
    > +#define INDATA_REG 0X30
    > +
    > +#define WHOAMI_LPS001WP_PRS 0xBA /* Expctd content for WAI */
    > +
    > +/* CONTROL REGISTERS */
    > +#define WHO_AM_I 0x0F /* WhoAmI register */
    > +#define CTRL_REG1 0x20 /* power / ODR control reg */
    > +#define CTRL_REG2 0x21 /* boot reg */
    > +#define CTRL_REG3 0x22 /* interrupt control reg */
    > +
    > +#define STATUS_REG 0X27 /* status reg */
    > +
    > +#define PRESS_OUT_L OUTDATA_REG
    > +
    > +
    > +#define REF_P_L INDATA_REG /* pressure reference */
    > +#define REF_P_H 0x31 /* pressure reference */
    > +#define THS_P_L 0x32 /* pressure threshold */
    > +#define THS_P_H 0x33 /* pressure threshold */
    > +
    > +#define INT_CFG 0x34 /* interrupt config */
    > +#define INT_SRC 0x35 /* interrupt source */
    > +#define INT_ACK 0x36 /* interrupt acknoledge */
    > +/* end CONTROL REGISTRES */
    > +
    > +
    > +/* Barometer and Termometer output data rate ODR */
    > +#define LPS001WP_PRS_ODR_MASK 0x30 /* Mask to access odr bits only
    > */
    > +#define LPS001WP_PRS_ODR_7_1 0x00 /* 7Hz baro and 1Hz term ODR */
    > +#define LPS001WP_PRS_ODR_7_7 0x01 /* 7Hz baro and 7Hz term ODR */
    > +#define LPS001WP_PRS_ODR_12_12 0x11 /* 12.5Hz baro and 12.5Hz term
    > ODR */
    > +
    > +
    > +#define LPS001WP_PRS_ENABLE_MASK 0x40 /* */
    > +#define LPS001WP_PRS_DIFF_MASK 0x08
    > +#define LPS001WP_PRS_LPOW_MASK 0x80
    > +
    > +#define LPS001WP_PRS_DIFF_ON 0x08
    > +#define LPS001WP_PRS_DIFF_OFF 0x00
    > +
    > +#define LPS001WP_PRS_LPOW_ON 0x80
    > +#define LPS001WP_PRS_LPOW_OFF 0x00
    > +
    > +#define FUZZ 0
    > +#define FLAT 0
    > +#define I2C_RETRY_DELAY 5
    > +#define I2C_RETRIES 5
    > +#define I2C_AUTO_INCREMENT 0x80
    > +
    > +/* RESUME STATE INDICES */
    > +#define RES_CTRL_REG1 0
    > +#define RES_CTRL_REG2 1
    > +#define RES_CTRL_REG3 2
    > +#define RES_REF_P_L 3
    > +#define RES_REF_P_H 4
    > +#define RES_THS_P_L 5
    > +#define RES_THS_P_H 6
    > +#define RES_INT_CFG 7
    > +
    > +#define RESUME_ENTRIES 8
    > +/* end RESUME STATE INDICES */
    > +
    > +/* Pressure Sensor Operating Mode */
    > +#define LPS001WP_PRS_DIFF_ENABLE 1
    > +#define LPS001WP_PRS_DIFF_DISABLE 0
    > +#define LPS001WP_PRS_LPOWER_EN 1
    > +#define LPS001WP_PRS_LPOWER_DIS 0
    > +
    > +static const struct {
    > + unsigned int cutoff_ms;
    > + unsigned int mask;
    > +} lps001wp_prs_odr_table[] = {
    > + {80, LPS001WP_PRS_ODR_12_12 },
    > + {143, LPS001WP_PRS_ODR_7_7 },
    > + {1000, LPS001WP_PRS_ODR_7_1 },
    > +};
    > +
    > +struct lps001wp_prs_data {
    > + struct i2c_client *client;
    > + struct lps001wp_prs_platform_data *pdata;
    > +
    > + struct mutex lock;
    > + struct delayed_work input_work;
    > +
    > + struct input_dev *input_dev;
    > +
    > + int hw_initialized;
    > + /* hw_working=-1 means not tested yet */
    > + int hw_working;
    > + u8 diff_enabled;
    > + u8 lpowmode_enabled ;
    > +
    > + atomic_t enabled;
    > + int on_before_suspend;
    > +
    > + u8 resume_state[RESUME_ENTRIES];
    > +
    > +#ifdef DEBUG
    > + u8 reg_addr;
    > +#endif
    > +};
    > +
    > +struct outputdata {
    > + u16 abspress;
    > + s16 temperature;
    > + s16 deltapress;
    > +};
    > +
    > +
    > +static int lps001wp_prs_i2c_read(struct lps001wp_prs_data *prs,
    > + u8 *buf, int len)
    > +{
    > + int err;
    > + int tries = 0;
    > +
    > + struct i2c_msg msgs[] = {
    > + {
    > + .addr = prs->client->addr,
    > + .flags = prs->client->flags & I2C_M_TEN,
    > + .len = 1,
    > + .buf = buf,
    > + },
    > + {
    > + .addr = prs->client->addr,
    > + .flags = (prs->client->flags & I2C_M_TEN) | I2C_M_RD,
    > + .len = len,
    > + .buf = buf,
    > + },
    > + };
    > +
    > + do {
    > + err = i2c_transfer(prs->client->adapter, msgs, 2);
    > + if (err != 2)
    > + msleep_interruptible(I2C_RETRY_DELAY);
    > + } while ((err != 2) && (++tries < I2C_RETRIES));
    > +
    > + if (err != 2) {
    > + dev_err(&prs->client->dev, "read transfer error\n");
    > + err = -EIO;
    > + } else {
    > + err = 0;
    > + }
    > +
    > + return err;
    > +}
    > +
    > +static int lps001wp_prs_i2c_write(struct lps001wp_prs_data *prs,
    > + u8 *buf, int len)
    > +{
    > + int err;
    > + int tries = 0;
    > + struct i2c_msg msgs[] = {
    > + {
    > + .addr = prs->client->addr,
    > + .flags = prs->client->flags & I2C_M_TEN,
    > + .len = len + 1,
    > + .buf = buf,
    > + },
    > + };
    > +
    > + do {
    > + err = i2c_transfer(prs->client->adapter, msgs, 1);
    > + if (err != 1)
    > + msleep_interruptible(I2C_RETRY_DELAY);
    > + } while ((err != 1) && (++tries < I2C_RETRIES));
    > +
    > + if (err != 1) {
    > + dev_err(&prs->client->dev, "write transfer error\n");
    > + err = -EIO;
    > + } else {
    > + err = 0;
    > + }
    > +
    > + return err;
    > +}
    > +
    > +static int lps001wp_prs_i2c_update(struct lps001wp_prs_data *prs,
    > + u8 reg_address, u8 mask, u8 new_bit_values)
    > +{
    > + int err = -1;
    > + u8 rdbuf[1] = { reg_address };
    > + u8 wrbuf[2] = { reg_address , 0x00 };
    > +
    > + u8 init_val;
    > + u8 updated_val;
    > + err = lps001wp_prs_i2c_read(prs, rdbuf, 1);
    > + if (!(err < 0)) {
    > + init_val = rdbuf[0];
    > + updated_val = ((mask & new_bit_values) | ((~mask) &
    > init_val));
    > + wrbuf[1] = updated_val;
    > + err = lps001wp_prs_i2c_write(prs, wrbuf, 2);
    > + }
    > + return err;
    > +}
    > +/* */
    > +
    > +static int lps001wp_prs_register_write(struct lps001wp_prs_data *prs, u8
    > *buf,
    > + u8 reg_address, u8 new_value)
    > +{
    > + int err = -1;
    > +
    > + /* Sets configuration register at reg_address
    > + * NOTE: this is a straight overwrite */
    > + buf[0] = reg_address;
    > + buf[1] = new_value;
    > + err = lps001wp_prs_i2c_write(prs, buf, 1);
    > + if (err < 0)
    > + return err;
    > + return err;
    > +}
    > +
    > +static int lps001wp_prs_register_read(struct lps001wp_prs_data *prs, u8
    > *buf,
    > + u8 reg_address)
    > +{
    > +
    > + int err = -1;
    > + buf[0] = (reg_address);
    > + err = lps001wp_prs_i2c_read(prs, buf, 1);
    > +
    > + return err;
    > +}
    > +
    > +static int lps001wp_prs_register_update(struct lps001wp_prs_data *prs, u8
    > *buf,
    > + u8 reg_address, u8 mask, u8 new_bit_values)
    > +{
    > + int err = -1;
    > + u8 init_val;
    > + u8 updated_val;
    > + err = lps001wp_prs_register_read(prs, buf, reg_address);
    > + if (!(err < 0)) {
    > + init_val = buf[0];
    > + updated_val = ((mask & new_bit_values) | ((~mask) &
    > init_val));
    > + err = lps001wp_prs_register_write(prs, buf, reg_address,
    > + updated_val);
    > + }
    > + return err;
    > +}
    > +
    > +/* */
    > +
    > +
    > +static int lps001wp_prs_hw_init(struct lps001wp_prs_data *prs)
    > +{
    > + int err = -1;
    > + u8 buf[6];
    > +
    > + printk(KERN_DEBUG "%s: hw init start\n", LPS001WP_PRS_DEV_NAME);
    > +
    > + buf[0] = WHO_AM_I;
    > + err = lps001wp_prs_i2c_read(prs, buf, 1);
    > + if (err < 0)
    > + goto error_firstread;
    > + else
    > + prs->hw_working = 1;
    > + if (buf[0] != WHOAMI_LPS001WP_PRS) {
    > + err = -1; /* TODO:choose the right coded error */
    > + goto error_unknown_device;
    > + }
    > +
    > +
    > + buf[0] = (I2C_AUTO_INCREMENT | INDATA_REG);
    > + buf[1] = prs->resume_state[RES_REF_P_L];
    > + buf[2] = prs->resume_state[RES_REF_P_H];
    > + buf[3] = prs->resume_state[RES_THS_P_L];
    > + buf[4] = prs->resume_state[RES_THS_P_H];
    > + err = lps001wp_prs_i2c_write(prs, buf, 4);
    > + if (err < 0)
    > + goto error1;
    > +
    > + buf[0] = (I2C_AUTO_INCREMENT | CTRL_REG1);
    > + buf[1] = prs->resume_state[RES_CTRL_REG1];
    > + buf[2] = prs->resume_state[RES_CTRL_REG2];
    > + buf[3] = prs->resume_state[RES_CTRL_REG3];
    > + err = lps001wp_prs_i2c_write(prs, buf, 3);
    > + if (err < 0)
    > + goto error1;
    > +
    > + buf[0] = INT_CFG;
    > + buf[1] = prs->resume_state[RES_INT_CFG];
    > + err = lps001wp_prs_i2c_write(prs, buf, 1);
    > + if (err < 0)
    > + goto error1;
    > +
    Stray space.
    > +
    > + prs->hw_initialized = 1;
    > + printk(KERN_DEBUG "%s: hw init done\n", LPS001WP_PRS_DEV_NAME);
    > + return 0;
    > +
    > +error_firstread:
    > + prs->hw_working = 0;
    > + dev_warn(&prs->client->dev, "Error reading WHO_AM_I: is device "
    > + "available/working?\n");
    > + goto error1;
    > +error_unknown_device:
    > + dev_err(&prs->client->dev,
    > + "device unknown. Expected: 0x%x,"
    > + " Replies: 0x%x\n", WHOAMI_LPS001WP_PRS, buf[0]);
    > +error1:
    > + prs->hw_initialized = 0;
    > + dev_err(&prs->client->dev, "hw init error 0x%x,0x%x: %d\n", buf[0],
    > + buf[1], err);
    > + return err;
    > +}
    > +
    > +static void lps001wp_prs_device_power_off(struct lps001wp_prs_data *prs)
    > +{
    > + int err;
    > + u8 buf[2] = { CTRL_REG1, LPS001WP_PRS_PM_OFF };
    > +
    > + err = lps001wp_prs_i2c_write(prs, buf, 1);
    > + if (err < 0)
    > + dev_err(&prs->client->dev, "soft power off failed: %d\n",
    > err);
    > +
    > + if (prs->pdata->power_off) {
    > + prs->pdata->power_off();
    > + prs->hw_initialized = 0;
    > + }
    > + if (prs->hw_initialized) {
    > + ;
    Did not understand this.

    > + prs->hw_initialized = 0;
    > + }
    > +
    > +}
    > +
    > +static int lps001wp_prs_device_power_on(struct lps001wp_prs_data *prs)
    > +{
    > + int err = -1;
    > +
    > + if (prs->pdata->power_on) {
    > + err = prs->pdata->power_on();
    You may want to explain what poweron does.

    > + if (err < 0) {
    > + dev_err(&prs->client->dev,
    > + "power_on failed: %d\n", err);
    > + return err;
    > + }
    > + }
    > +
    > + if (!prs->hw_initialized) {
    > + err = lps001wp_prs_hw_init(prs);
    > + if (prs->hw_working == 1 && err < 0) {
    > + lps001wp_prs_device_power_off(prs);
    > + return err;
    > + }
    > + }
    > +
    > + return 0;
    > +}
    > +
    > +
    > +
    > +int lps001wp_prs_update_odr(struct lps001wp_prs_data *prs, int
    > poll_interval_ms)
    > +{
    > + int err = -1;
    > + int i;
    > +
    > + u8 buf[2];
    > + u8 updated_val;
    > + u8 init_val;
    > + u8 new_val;
    > + u8 mask = LPS001WP_PRS_ODR_MASK;
    > +
    > + /* Following, looks for the longest possible odr interval scrolling
    > the
    > + * odr_table vector from the end (shortest interval) backward
    > (longest
    > + * interval), to support the poll_interval requested by the system.
    > + * It must be the longest interval lower then the poll interval.*/
    > + for (i = ARRAY_SIZE(lps001wp_prs_odr_table) - 1; i >= 0; i--) {
    > + if (lps001wp_prs_odr_table[i].cutoff_ms <= poll_interval_ms)
    > + break;
    > + }
    > +
    > + new_val = lps001wp_prs_odr_table[i].mask;
    > +
    > + /* If device is currently enabled, we need to write new
    > + * configuration out to it */
    > + if (atomic_read(&prs->enabled)) {
    > + buf[0] = CTRL_REG1;
    > + err = lps001wp_prs_i2c_read(prs, buf, 1);
    > + if (err < 0)
    > + goto error;
    > + init_val = buf[0];
    > + prs->resume_state[RES_CTRL_REG1] = init_val;
    > +
    > + buf[0] = CTRL_REG1;
    > + updated_val = ((mask & new_val) | ((~mask) & init_val));
    > + buf[1] = updated_val;
    > + buf[0] = CTRL_REG1;
    > + err = lps001wp_prs_i2c_write(prs, buf, 1);
    > + if (err < 0)
    > + goto error;
    > + prs->resume_state[RES_CTRL_REG1] = updated_val;
    > + }
    > + return err;
    > +
    > +error:
    > + dev_err(&prs->client->dev, "update odr failed 0x%x,0x%x: %d\n",
    > + buf[0], buf[1], err);
    > +
    > + return err;
    > +}
    > +
    > +static int lps001wp_prs_set_press_reference(struct lps001wp_prs_data
    > *prs,
    > + u16 new_reference)
    > +{
    > + int err = -1;
    > + u8 const reg_addressL = REF_P_L;
    > + u8 const reg_addressH = REF_P_H;
    > + u8 bit_valuesL, bit_valuesH;
    > + u8 buf[2];
    > +
    > + bit_valuesL = (u8) (new_reference & 0x00FF);
    > + bit_valuesH = (u8)((new_reference & 0xFF00) >> 8);
    > +
    > + err = lps001wp_prs_register_write(prs, buf, reg_addressL,
    > + bit_valuesL);
    > + if (err < 0)
    > + return err;
    > + err = lps001wp_prs_register_write(prs, buf, reg_addressH,
    > + bit_valuesH);
    > + if (err < 0) {
    > + lps001wp_prs_register_write(prs, buf, reg_addressL,
    > + prs->resume_state[RES_REF_P_L]);
    > + return err;
    > + }
    > + prs->resume_state[RES_REF_P_L] = bit_valuesL;
    > + prs->resume_state[RES_REF_P_H] = bit_valuesH;
    > + return err;
    > +}
    > +
    > +static int lps001wp_prs_get_press_reference(struct lps001wp_prs_data
    > *prs,
    > + u16 *buf16)
    > +{
    > + int err = -1;
    > +
    > + u8 bit_valuesL, bit_valuesH;
    > + u8 buf[2] = {0};
    > + u16 temp = 0;
    > +
    > + err = lps001wp_prs_register_read(prs, buf, REF_P_L);
    > + if (err < 0)
    > + return err;
    > + bit_valuesL = buf[0];
    > + err = lps001wp_prs_register_read(prs, buf, REF_P_H);
    > + if (err < 0)
    > + return err;
    > + bit_valuesH = buf[0];
    > +
    > + temp = (((u16) bit_valuesH) << 8);
    > + *buf16 = (temp | ((u16) bit_valuesL));
    > +
    > + return err;
    > +}
    > +
    > +static int lps001wp_prs_lpow_manage(struct lps001wp_prs_data *prs, u8
    > control)
    > +{
    > + int err = -1;
    > + u8 buf[2] = {0x00, 0x00};
    > + u8 const mask = LPS001WP_PRS_LPOW_MASK;
    > + u8 bit_values = LPS001WP_PRS_LPOW_OFF;
    > +
    > + if (control >= LPS001WP_PRS_LPOWER_EN) {
    > + ;
    > + bit_values = LPS001WP_PRS_LPOW_ON;
    > + }
    > +
    > + err = lps001wp_prs_register_update(prs, buf, CTRL_REG1,
    > + mask, bit_values);
    > +
    > + if (err < 0)
    > + return err;
    > + prs->resume_state[RES_CTRL_REG1] = ((mask & bit_values) |
    > + (~mask & prs->resume_state[RES_CTRL_REG1]));
    > + if (bit_values == LPS001WP_PRS_LPOW_ON)
    > + prs->lpowmode_enabled = 1;
    > + else
    > + prs->lpowmode_enabled = 0;
    > + return err;
    > +}
    > +
    > +static int lps001wp_prs_diffen_manage(struct lps001wp_prs_data *prs, u8
    > control)
    > +{
    > + int err = -1;
    > + u8 buf[2] = {0x00, 0x00};
    > + u8 const mask = LPS001WP_PRS_DIFF_MASK;
    > + u8 bit_values = LPS001WP_PRS_DIFF_OFF;
    > +
    > + if (control >= LPS001WP_PRS_DIFF_ENABLE) {
    > + ;
    > + bit_values = LPS001WP_PRS_DIFF_ON;
    > + }
    > +
    > + err = lps001wp_prs_register_update(prs, buf, CTRL_REG1,
    > + mask, bit_values);
    > +
    > + if (err < 0)
    > + return err;
    > + prs->resume_state[RES_CTRL_REG1] = ((mask & bit_values) |
    > + (~mask & prs->resume_state[RES_CTRL_REG1]));
    > + if (bit_values == LPS001WP_PRS_DIFF_ON)
    > + prs->diff_enabled = 1;
    > + else
    > + prs->diff_enabled = 0;
    > + return err;
    > +}
    > +
    > +
    > +static int lps001wp_prs_get_presstemp_data(struct lps001wp_prs_data *prs,
    > + struct outputdata *out)
    > +{
    > + int err = -1;
    > + /* Data bytes from hardware PRESS_OUT_L, PRESS_OUT_H,
    > + * TEMP_OUT_L, TEMP_OUT_H,
    > + * DELTA_L, DELTA_H */
    > + u8 prs_data[6];
    > +
    > + u16 abspr;
    > + s16 temperature, deltapr;
    > + int regToRead = 4;
    > + prs_data[4] = 0;
    > + prs_data[5] = 0;
    > +
    > + if (prs->diff_enabled)
    > + regToRead = 6;
    > +
    > + prs_data[0] = (I2C_AUTO_INCREMENT | OUTDATA_REG);
    > + err = lps001wp_prs_i2c_read(prs, prs_data, regToRead);
    > + if (err < 0)
    > + return err;
    > +
    > + abspr = ((((u16) prs_data[1] << 8) | ((u16) prs_data[0])));
    > + temperature = ((s16) (((u16) prs_data[3] << 8) |
    > ((u16)prs_data[2])));
    > +
    > + out->abspress = abspr;
    > + out->temperature = temperature;
    > +
    > + deltapr = ((s16) (((u16) prs_data[5] << 8) | ((u16)prs_data[4])));
    > + out->deltapress = deltapr;
    > +
    > + return err;
    > +}
    > +
    > +static void lps001wp_prs_report_values(struct lps001wp_prs_data *prs,
    > + struct outputdata *out)
    > +{
    > + input_report_abs(prs->input_dev, ABS_PR, out->abspress);
    > + input_report_abs(prs->input_dev, ABS_TEMP, out->temperature);
    > + input_report_abs(prs->input_dev, ABS_DLTPR, out->deltapress);
    > + input_sync(prs->input_dev);
    > +}
    > +
    > +static int lps001wp_prs_enable(struct lps001wp_prs_data *prs)
    > +{
    > + int err;
    > +
    > + if (!atomic_cmpxchg(&prs->enabled, 0, 1)) {
    > + err = lps001wp_prs_device_power_on(prs);
    > + if (err < 0) {
    > + atomic_set(&prs->enabled, 0);
    > + return err;
    > + }
    > + schedule_delayed_work(&prs->input_work,
    > + msecs_to_jiffies(prs->pdata->poll_interval));
    > + }
    > +
    > + return 0;
    > +}
    > +
    > +static int lps001wp_prs_disable(struct lps001wp_prs_data *prs)
    > +{
    > + if (atomic_cmpxchg(&prs->enabled, 1, 0)) {
    > + cancel_delayed_work_sync(&prs->input_work);
    > + lps001wp_prs_device_power_off(prs);
    > + }
    > +
    > + return 0;
    > +}
    > +
    > +static ssize_t read_single_reg(struct device *dev, char *buf, u8 reg)
    > +{
    > + ssize_t ret;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + int rc = 0;
    > +
    > + u8 data = reg;
    > + rc = lps001wp_prs_i2c_read(prs, &data, 1);
    > + /*TODO: error need to be managed */
    > + ret = sprintf(buf, "0x%02x\n", data);
    > + return ret;
    > +
    > +}
    > +
    > +static int write_reg(struct device *dev, const char *buf, u8 reg)
    > +{
    > + int rc = 0;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + u8 x[2];
    > + unsigned long val;
    > +
    > + if (strict_strtoul(buf, 16, &val))
    > + return -EINVAL;
    > +
    > + x[0] = reg;
    > + x[1] = val;
    > + rc = lps001wp_prs_i2c_write(prs, x, 1);
    > + /*TODO: error need to be managed */
    > + return rc;
    > +}
    > +
    > +static ssize_t attr_get_polling_rate(struct device *dev,
    > + struct device_attribute *attr,
    > + char *buf)
    > +{
    > + int val;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + mutex_lock(&prs->lock);
    > + val = prs->pdata->poll_interval;
    > + mutex_unlock(&prs->lock);
    > + return sprintf(buf, "%d\n", val);
    > +}
    > +
    > +static ssize_t attr_set_polling_rate(struct device *dev,
    > + struct device_attribute *attr,
    > + const char *buf, size_t size)
    > +{
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + unsigned long interval_ms;
    Is there a limitation on the limit. Say if the rate
    > +
    > + if (strict_strtoul(buf, 10, &interval_ms))
    > + return -EINVAL;
    > + if (!interval_ms)
    > + return -EINVAL;
    > + mutex_lock(&prs->lock);
    > + prs->pdata->poll_interval = interval_ms;
    > + lps001wp_prs_update_odr(prs, interval_ms);
    What happens when the interval is smaller than the output rate is the values repeated?

    > + mutex_unlock(&prs->lock);
    > + return size;
    > +}
    > +
    > +static ssize_t attr_get_diff_enable(struct device *dev,
    > + struct device_attribute *attr,
    > + char *buf)
    > +{
    > + u8 val;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + mutex_lock(&prs->lock);
    > + val = prs->diff_enabled;
    > + mutex_unlock(&prs->lock);
    > + return sprintf(buf, "%d\n", val);
    > +}
    > +
    > +static ssize_t attr_set_diff_enable(struct device *dev,
    > + struct device_attribute *attr,
    > + const char *buf, size_t size)
    > +{
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + unsigned long val;
    > +
    > + if (strict_strtoul(buf, 10, &val))
    > + return -EINVAL;
    > +
    > + mutex_lock(&prs->lock);
    > + lps001wp_prs_diffen_manage(prs, (u8) val);
    > + mutex_unlock(&prs->lock);
    > + return size;
    > +}
    > +
    > +static ssize_t attr_get_enable(struct device *dev,
    > + struct device_attribute *attr, char *buf)
    > +{
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + int val = atomic_read(&prs->enabled);
    > + return sprintf(buf, "%d\n", val);
    > +}
    > +
    > +static ssize_t attr_set_enable(struct device *dev,
    > + struct device_attribute *attr,
    > + const char *buf, size_t size)
    > +{
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + unsigned long val;
    > +
    > + if (strict_strtoul(buf, 10, &val))
    > + return -EINVAL;
    > +
    > + if (val)
    > + lps001wp_prs_enable(prs);
    > + else
    > + lps001wp_prs_disable(prs);
    > +
    > + return size;
    > +}
    > +
    > +static ssize_t attr_get_press_ref(struct device *dev,
    > + struct device_attribute *attr, char *buf)
    > +{
    > + int err = -1;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + u16 val = 0;
    > +
    > + mutex_lock(&prs->lock);
    > + err = lps001wp_prs_get_press_reference(prs, &val);
    > + mutex_unlock(&prs->lock);
    > + if (err < 0)
    > + return err;
    > +
    > + return sprintf(buf, "%d\n", val);
    > +}
    > +
    > +static ssize_t attr_set_press_ref(struct device *dev,
    > + struct device_attribute *attr,
    > + const char *buf, size_t size)
    > +{
    > + int err = -1;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + unsigned long val = 0;
    > +
    > + if (strict_strtoul(buf, 10, &val))
    > + return -EINVAL;
    > +
    > + if (val < PR_ABS_MIN || val > PR_ABS_MAX)
    > + return -EINVAL;
    > +
    > + mutex_lock(&prs->lock);
    > + err = lps001wp_prs_set_press_reference(prs, val);
    > + mutex_unlock(&prs->lock);
    > + if (err < 0)
    > + return err;
    > + return size;
    > +}
    > +
    > +
    > +static ssize_t attr_get_lowpowmode(struct device *dev,
    > + struct device_attribute *attr, char *buf)
    > +{
    > + u8 val;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + mutex_lock(&prs->lock);
    > + val = prs->lpowmode_enabled;
    > + mutex_unlock(&prs->lock);
    > + return sprintf(buf, "%d\n", val);
    > +}
    > +
    > +static ssize_t attr_set_lowpowmode(struct device *dev,
    > + struct device_attribute *attr,
    > + const char *buf, size_t size)
    > +{
    Power management through sysfs may not be needed if the power hooks are used.

    > + int err = -1;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + unsigned long val;
    > +
    > + if (strict_strtoul(buf, 10, &val))
    > + return -EINVAL;
    > +
    > + mutex_lock(&prs->lock);
    > + err = lps001wp_prs_lpow_manage(prs, (u8) val);
    > + mutex_unlock(&prs->lock);
    > + if (err < 0)
    > + return err;
    > + return size;
    > +}
    > +
    > +
    > +#ifdef DEBUG
    Do you really want the debug code?
    Feel free to ignore this kind of a comment.

    > +static ssize_t attr_reg_set(struct device *dev, struct device_attribute
    > *attr,
    > + const char *buf, size_t size)
    > +{
    > + int rc;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + u8 x[2];
    > + unsigned long val;
    > +
    > + if (strict_strtoul(buf, 16, &val))
    > + return -EINVAL;
    > + mutex_lock(&prs->lock);
    > + x[0] = prs->reg_addr;
    > + mutex_unlock(&prs->lock);
    > + x[1] = val;
    > + rc = lps001wp_prs_i2c_write(prs, x, 1);
    > + /*TODO: error need to be managed */
    > + return size;
    > +}
    > +
    > +static ssize_t attr_reg_get(struct device *dev, struct device_attribute
    > *attr,
    > + char *buf)
    > +{
    > + ssize_t ret;
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + int rc;
    > + u8 data;
    > +
    > + mutex_lock(&prs->lock);
    > + data = prs->reg_addr;
    > + mutex_unlock(&prs->lock);
    > + rc = lps001wp_prs_i2c_read(prs, &data, 1);
    > + /*TODO: error need to be managed */
    > + ret = sprintf(buf, "0x%02x\n", data);
    > + return ret;
    > +}
    > +
    > +static ssize_t attr_addr_set(struct device *dev, struct device_attribute
    > *attr,
    > + const char *buf, size_t size)
    > +{
    > + struct lps001wp_prs_data *prs = dev_get_drvdata(dev);
    > + unsigned long val;
    > + if (strict_strtoul(buf, 16, &val))
    > + return -EINVAL;
    > + mutex_lock(&prs->lock);
    > + prs->reg_addr = val;
    > + mutex_unlock(&prs->lock);
    > + return size;
    > +}
    > +#endif
    > +
    > +
    > +
    > +static struct device_attribute attributes[] = {
    > + __ATTR(pollrate_ms, 0664, attr_get_polling_rate,
    > attr_set_polling_rate),
    > + __ATTR(enable, 0664, attr_get_enable, attr_set_enable),
    > + __ATTR(diff_enable, 0664, attr_get_diff_enable,
    > attr_set_diff_enable),
    > + __ATTR(press_reference, 0664, attr_get_press_ref,
    > attr_set_press_ref),
    > + __ATTR(lowpow_enable, 0664, attr_get_lowpowmode,
    > attr_set_lowpowmode),
    > +#ifdef DEBUG
    > + __ATTR(reg_value, 0664, attr_reg_get, attr_reg_set),
    > + __ATTR(reg_addr, 0220, NULL, attr_addr_set),
    > +#endif
    > +};
    > +
    > +static int create_sysfs_interfaces(struct device *dev)
    > +{
    > + int i;
    > + for (i = 0; i < ARRAY_SIZE(attributes); i++)
    > + if (device_create_file(dev, attributes + i))
    > + goto error;
    > + return 0;
    > +
    > +error:
    > + for ( ; i >= 0; i--)
    > + device_remove_file(dev, attributes + i);
    > + dev_err(dev, "%s:Unable to create interface\n", __func__);
    > + return -1;
    > +}
    > +
    > +static int remove_sysfs_interfaces(struct device *dev)
    > +{
    > + int i;
    > + for (i = 0; i < ARRAY_SIZE(attributes); i++)
    > + device_remove_file(dev, attributes + i);
    > + return 0;
    > +}
    > +
    > +
    > +static void lps001wp_prs_input_work_func(struct work_struct *work)
    > +{
    > + struct lps001wp_prs_data *prs;
    > +
    > + struct outputdata output;
    > + struct outputdata *out = &output;
    > + int err;
    > +
    > + prs = container_of((struct delayed_work *)work,
    > + struct lps001wp_prs_data, input_work);
    > +
    > + mutex_lock(&prs->lock);
    > + err = lps001wp_prs_get_presstemp_data(prs, out);
    > + if (err < 0)
    > + dev_err(&prs->client->dev, "get_pressure_data failed\n");
    > + else
    > + lps001wp_prs_report_values(prs, out);
    > +
    > + schedule_delayed_work(&prs->input_work,
    > + msecs_to_jiffies(prs->pdata->poll_interval));
    > + mutex_unlock(&prs->lock);
    > +}
    > +
    > +int lps001wp_prs_input_open(struct input_dev *input)
    > +{
    > + struct lps001wp_prs_data *prs = input_get_drvdata(input);
    > +
    > + return lps001wp_prs_enable(prs);
    > +}
    > +
    > +void lps001wp_prs_input_close(struct input_dev *dev)
    > +{
    > + struct lps001wp_prs_data *prs = input_get_drvdata(dev);
    > +
    > + lps001wp_prs_disable(prs);
    > +}
    > +
    > +
    > +static int lps001wp_prs_validate_pdata(struct lps001wp_prs_data *prs)
    > +{
    > + prs->pdata->poll_interval = max(prs->pdata->poll_interval,
    > + prs->pdata->min_interval);
    > +
    > + /* Enforce minimum polling interval */
    > + if (prs->pdata->poll_interval < prs->pdata->min_interval) {
    > + dev_err(&prs->client->dev, "minimum poll interval
    > violated\n");
    > + return -EINVAL;
    > + }
    > +
    > + return 0;
    > +}
    > +
    > +static int lps001wp_prs_input_init(struct lps001wp_prs_data *prs)
    > +{
    > + int err;
    > +
    > + INIT_DELAYED_WORK(&prs->input_work, lps001wp_prs_input_work_func);
    > + prs->input_dev = input_allocate_device();
    > + if (!prs->input_dev) {
    > + err = -ENOMEM;
    > + dev_err(&prs->client->dev, "input device allocate failed\n");
    > + goto err0;
    > + }
    > +
    > + prs->input_dev->open = lps001wp_prs_input_open;
    > + prs->input_dev->close = lps001wp_prs_input_close;
    > + prs->input_dev->name = LPS001WP_PRS_DEV_NAME;
    > + prs->input_dev->id.bustype = BUS_I2C;
    > + prs->input_dev->dev.parent = &prs->client->dev;
    > +
    > + input_set_drvdata(prs->input_dev, prs);
    > +
    > + set_bit(EV_ABS, prs->input_dev->evbit);
    > +
    > + input_set_abs_params(prs->input_dev, ABS_PR,
    > + PR_ABS_MIN, PR_ABS_MAX, FUZZ, FLAT);
    > + input_set_abs_params(prs->input_dev, ABS_TEMP,
    > + PR_DLT_MIN, PR_DLT_MAX, FUZZ, FLAT);
    > + input_set_abs_params(prs->input_dev, ABS_DLTPR,
    > + TEMP_MIN, TEMP_MAX, FUZZ, FLAT);
    > +
    > +
    > + prs->input_dev->name = "LPS001WP barometer";
    > +
    > + err = input_register_device(prs->input_dev);
    > + if (err) {
    > + dev_err(&prs->client->dev,
    > + "unable to register input polled device %s\n",
    > + prs->input_dev->name);
    > + goto err1;
    > + }
    > +
    > + return 0;
    > +
    > +err1:
    > + input_free_device(prs->input_dev);
    > +err0:
    > + return err;
    > +}
    > +
    > +static void lps001wp_prs_input_cleanup(struct lps001wp_prs_data *prs)
    > +{
    > + input_unregister_device(prs->input_dev);
    > + input_free_device(prs->input_dev);
    This may not be a good idea. We shouldn't free after unregister.

    > +}
    > +
    > +static int lps001wp_prs_probe(struct i2c_client *client,
    > + const struct i2c_device_id *id)
    You may consider __devinit
    > +{
    > + struct lps001wp_prs_data *prs;
    > + int err = -1;
    > + int tempvalue;
    > +
    > + pr_info("%s: probe start.\n", LPS001WP_PRS_DEV_NAME);
    > +
    > + if (client->dev.platform_data == NULL) {
    > + dev_err(&client->dev, "platform data is NULL. exiting.\n");
    > + err = -ENODEV;
    > + goto exit_check_functionality_failed;
    > + }
    > +
    > + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
    > + dev_err(&client->dev, "client not i2c capable\n");
    > + err = -ENODEV;
    > + goto exit_check_functionality_failed;
    > + }
    > +
    > + if (!i2c_check_functionality(client->adapter,
    > + I2C_FUNC_SMBUS_BYTE |
    > + I2C_FUNC_SMBUS_BYTE_DATA |
    > + I2C_FUNC_SMBUS_WORD_DATA)) {
    > + dev_err(&client->dev, "client not smb-i2c capable:2\n");
    > + err = -EIO;
    > + goto exit_check_functionality_failed;
    > + }
    > +
    > +
    > + if (!i2c_check_functionality(client->adapter,
    > + I2C_FUNC_SMBUS_I2C_BLOCK)){
    > + dev_err(&client->dev, "client not smb-i2c capable:3\n");
    > + err = -EIO;
    > + goto exit_check_functionality_failed;
    > + }
    > +
    > +
    > + prs = kzalloc(sizeof(struct lps001wp_prs_data), GFP_KERNEL);
    > + if (prs == NULL) {
    > + err = -ENOMEM;
    > + dev_err(&client->dev,
    > + "failed to allocate memory for module data: "
    > + "%d\n", err);
    > + goto exit_alloc_data_failed;
    > + }
    > +
    > + mutex_init(&prs->lock);
    > + mutex_lock(&prs->lock);
    > +
    > + prs->client = client;
    > + i2c_set_clientdata(client, prs);
    > +
    > +
    > + if (i2c_smbus_read_byte(client) < 0) {
    > + printk(KERN_ERR "i2c_smbus_read_byte error!!\n");
    > + goto err_mutexunlockfreedata;
    > + } else {
    > + printk(KERN_DEBUG "%s Device detected!\n",
    > + LPS001WP_PRS_DEV_NAME);
    > + }
    > +
    > + /* read chip id */
    > + tempvalue = i2c_smbus_read_word_data(client, WHO_AM_I);
    > + if ((tempvalue & 0x00FF) == WHOAMI_LPS001WP_PRS) {
    > + printk(KERN_DEBUG "%s I2C driver registered!\n",
    > + LPS001WP_PRS_DEV_NAME);
    > + } else {
    > + prs->client = NULL;
    > + printk(KERN_DEBUG "I2C driver not registered!"
    > + " Device unknown\n");
    > + goto err_mutexunlockfreedata;
    > + }
    > +
    > + prs->pdata = kmalloc(sizeof(*prs->pdata), GFP_KERNEL);
    > + if (prs->pdata == NULL) {
    > + err = -ENOMEM;
    > + dev_err(&client->dev,
    > + "failed to allocate memory for pdata: %d\n",
    > + err);
    > + goto err_mutexunlockfreedata;
    > + }
    > +
    > + memcpy(prs->pdata, client->dev.platform_data, sizeof(*prs->pdata));
    > +
    > + err = lps001wp_prs_validate_pdata(prs);
    > + if (err < 0) {
    > + dev_err(&client->dev, "failed to validate platform data\n");
    > + goto exit_kfree_pdata;
    > + }
    > +
    > + i2c_set_clientdata(client, prs);
    > +
    > +
    > + if (prs->pdata->init) {
    > + err = prs->pdata->init();
    > + if (err < 0) {
    > + dev_err(&client->dev, "init failed: %d\n", err);
    > + goto err2;
    > + }
    > + }
    > +
    > + memset(prs->resume_state, 0, ARRAY_SIZE(prs->resume_state));
    > +
    > + prs->resume_state[RES_CTRL_REG1] = LPS001WP_PRS_PM_NORMAL;
    > + prs->resume_state[RES_CTRL_REG2] = 0x00;
    > + prs->resume_state[RES_CTRL_REG3] = 0x00;
    > + prs->resume_state[RES_REF_P_L] = 0x00;
    > + prs->resume_state[RES_REF_P_H] = 0x00;
    > + prs->resume_state[RES_THS_P_L] = 0x00;
    > + prs->resume_state[RES_THS_P_H] = 0x00;
    > + prs->resume_state[RES_INT_CFG] = 0x00;
    > +
    > + err = lps001wp_prs_device_power_on(prs);
    > + if (err < 0) {
    > + dev_err(&client->dev, "power on failed: %d\n", err);
    > + goto err2;
    > + }
    > +
    > + prs->diff_enabled = 0;
    > + prs->lpowmode_enabled = 0;
    > + atomic_set(&prs->enabled, 1);
    > +
    > + err = lps001wp_prs_update_odr(prs, prs->pdata->poll_interval);
    > + if (err < 0) {
    > + dev_err(&client->dev, "update_odr failed\n");
    > + goto err_power_off;
    > + }
    > +
    > + err = lps001wp_prs_input_init(prs);
    > + if (err < 0) {
    > + dev_err(&client->dev, "input init failed\n");
    > + goto err_power_off;
    > + }
    > +
    > +
    > + err = create_sysfs_interfaces(&client->dev);
    > + if (err < 0) {
    > + dev_err(&client->dev,
    > + "device LPS001WP_PRS_DEV_NAME sysfs register failed\n");
    > + goto err_input_cleanup;
    > + }
    > +
    > +
    > + lps001wp_prs_device_power_off(prs);
    > +
    > + /* As default, do not report information */
    > + atomic_set(&prs->enabled, 0);
    > +
    > +
    > + mutex_unlock(&prs->lock);
    > +
    > + dev_info(&client->dev, "%s: probed\n", LPS001WP_PRS_DEV_NAME);
    > +
    > + return 0;
    > +
    > +/*
    > +remove_sysfs_int:
    > + remove_sysfs_interfaces(&client->dev);
    > +*/
    > +err_input_cleanup:
    > + lps001wp_prs_input_cleanup(prs);
    > +err_power_off:
    > + lps001wp_prs_device_power_off(prs);
    > +err2:
    > + if (prs->pdata->exit)
    > + prs->pdata->exit();
    > +exit_kfree_pdata:
    > + kfree(prs->pdata);
    > +
    > +err_mutexunlockfreedata:
    > + mutex_unlock(&prs->lock);
    > + kfree(prs);
    > +exit_alloc_data_failed:
    > +exit_check_functionality_failed:
    > + printk(KERN_ERR "%s: Driver Init failed\n", LPS001WP_PRS_DEV_NAME);
    > + return err;
    > +}
    > +
    > +static int __devexit lps001wp_prs_remove(struct i2c_client *client)
    > +{
    > + struct lps001wp_prs_data *prs = i2c_get_clientdata(client);
    > +
    > + lps001wp_prs_input_cleanup(prs);
    > + lps001wp_prs_device_power_off(prs);
    > + remove_sysfs_interfaces(&client->dev);
    > +
    > + if (prs->pdata->exit)
    > + prs->pdata->exit();
    > + kfree(prs->pdata);
    > + kfree(prs);
    > +
    > + return 0;
    > +}
    > +
    > +static int lps001wp_prs_resume(struct i2c_client *client)
    > +{
    > + struct lps001wp_prs_data *prs = i2c_get_clientdata(client);
    > +
    > + if (prs->on_before_suspend)
    > + return lps001wp_prs_enable(prs);
    > + return 0;
    > +}
    > +
    > +static int lps001wp_prs_suspend(struct i2c_client *client, pm_message_t
    > mesg)
    > +{
    > + struct lps001wp_prs_data *prs = i2c_get_clientdata(client);
    > +
    > + prs->on_before_suspend = atomic_read(&prs->enabled);
    > + return lps001wp_prs_disable(prs);
    > +}
    > +
    > +static const struct i2c_device_id lps001wp_prs_id[]
    > + = { { LPS001WP_PRS_DEV_NAME, 0}, { },};
    > +
    > +MODULE_DEVICE_TABLE(i2c, lps001wp_prs_id);
    > +
    > +static struct i2c_driver lps001wp_prs_driver = {
    > + .driver = {
    > + .name = LPS001WP_PRS_DEV_NAME,
    > + .owner = THIS_MODULE,
    > + },
    > + .probe = lps001wp_prs_probe,
    > + .remove = __devexit_p(lps001wp_prs_remove),
    > + .id_table = lps001wp_prs_id,
    > + .resume = lps001wp_prs_resume,
    > + .suspend = lps001wp_prs_suspend,
    > +};
    > +
    > +static int __init lps001wp_prs_init(void)
    > +{
    > + printk(KERN_DEBUG "%s barometer driver: init\n",
    > + LPS001WP_PRS_DEV_NAME);
    > + return i2c_add_driver(&lps001wp_prs_driver);
    > +}
    > +
    > +static void __exit lps001wp_prs_exit(void)
    > +{
    > + #if DEBUG
    > + printk(KERN_DEBUG "%s barometer driver exit\n",
    > + LPS001WP_PRS_DEV_NAME);
    > + #endif
    > + i2c_del_driver(&lps001wp_prs_driver);
    > + return;
    > +}
    > +
    > +module_init(lps001wp_prs_init);
    > +module_exit(lps001wp_prs_exit);
    > +
    > +MODULE_DESCRIPTION("STMicrolelectronics lps001wp pressure sensor misc
    > driver");
    > +MODULE_AUTHOR("Matteo Dameno, Carmine Iascone, STMicroelectronics");
    > +MODULE_LICENSE("GPL");
    > +
    > diff --git a/include/linux/input/lps001wp.h
    > b/include/linux/input/lps001wp.h
    > new file mode 100644
    > index 0000000..4c3e307
    > --- /dev/null
    > +++ b/include/linux/input/lps001wp.h
    > @@ -0,0 +1,82 @@
    > +/******************** (C) COPYRIGHT 2010 STMicroelectronics
    > ********************
    > +*
    > +* File Name : lps001wp.h
    > +* Authors : MSH - Motion Mems BU - Application Team
    > +* : Matteo Dameno (matteo.dameno@st.com)*
    > +* : Carmine Iascone (carmine.iascone@st.com)
    > +* Version : V 1.1.1
    > +* Date : 05/11/2010
    > +* Description : LPS001WP 6D module sensor API
    > +*
    > +*************************************************************************
    > *******
    > +*
    > +* This program is free software; you can redistribute it and/or modify
    > +* it under the terms of the GNU General Public License version 2 as
    > +* published by the Free Software Foundation.
    > +*
    > +* THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT
    > WARRANTIES
    > +* OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE
    > +* PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT.
    > +* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
    > DIRECT,
    > +* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    > FROM THE
    > +* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
    > +* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    > +*
    > +* THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS.
    > +*
    > +*************************************************************************
    > ******/
    > +
    > +#ifndef __LPS001WP_H__
    > +#define __LPS001WP_H__
    > +
    > +
    > +#include <linux/input.h>
    > +
    > +#define SAD0L 0x00
    > +#define SAD0H 0x01
    > +#define LPS001WP_PRS_I2C_SADROOT 0x2E
    > +#define LPS001WP_PRS_I2C_SAD_L
    > ((LPS001WP_PRS_I2C_SADROOT<<1)|SAD0L)
    > +#define LPS001WP_PRS_I2C_SAD_H
    > ((LPS001WP_PRS_I2C_SADROOT<<1)|SAD0H)
    > +#define LPS001WP_PRS_DEV_NAME "lps001wp_prs_sysfs"
    > +
    > +/* input define mappings */
    > +#define ABS_PR ABS_PRESSURE
    > +#define ABS_TEMP ABS_GAS
    > +#define ABS_DLTPR ABS_MISC
    > +
    > +
    > +
    > +/************************************************/
    > +/* Pressure section defines */
    > +/************************************************/
    > +
    > +/* Pressure Sensor Operating Mode */
    > +#define LPS001WP_PRS_ENABLE 0x01
    > +#define LPS001WP_PRS_DISABLE 0x00
    > +
    > +
    > +
    > +
    > +#define LPS001WP_PRS_PM_NORMAL 0x40
    > +#define LPS001WP_PRS_PM_OFF LPS001WP_PRS_DISABLE
    > +
    > +#define SENSITIVITY_T 64 /** = 64 LSB/degrC */
    > +#define SENSITIVITY_P 16 /** = 16 LSB/mbar */
    > +
    > +
    > +#ifdef __KERNEL__
    > +struct lps001wp_prs_platform_data {
    > +
    > + int poll_interval;
    > + int min_interval;
    > +
    > + int (*init)(void);
    > + void (*exit)(void);
    > + int (*power_on)(void);
    > + int (*power_off)(void);
    What do they initialize or power on?
    Not a comment just curious.
    > +
    > +};
    > +
    > +#endif /* __KERNEL__ */
    > +
    > +#endif /* __LPS001WP_H__ */
    > --
    > 1.5.4.3
    >
    > --
    > To unsubscribe from this list: send the line "unsubscribe linux-input" in
    > the body of a message to majordomo@vger.kernel.org
    > More majordomo info at http://vger.kernel.org/majordomo-info.html


    \
     
     \ /
      Last update: 2010-11-30 07:09    [W:0.183 / U:0.100 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site