Hello, > -----Original Message----- > From: linux-input-owner@xxxxxxxxxxxxxxx [mailto:linux-input- > owner@xxxxxxxxxxxxxxx] On Behalf Of mems applications > Sent: Monday, November 29, 2010 10:13 PM > To: dmitry.torokhov@xxxxxxxxx > Cc: linux-input@xxxxxxxxxxxxxxx; linux-kernel@xxxxxxxxxxxxxxx; > matteo.dameno@xxxxxx; carmine.iascone@xxxxxx; 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@xxxxxx> > --- > 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@xxxxxx) > +* : Carmine Iascone (carmine.iascone@xxxxxx) > +* : 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@xxxxxx)* > +* : Carmine Iascone (carmine.iascone@xxxxxx) > +* 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@xxxxxxxxxxxxxxx > More majordomo info at http://vger.kernel.org/majordomo-info.html -- To unsubscribe from this list: send the line "unsubscribe linux-input" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
