diff options
Diffstat (limited to 'drivers/hwmon')
| -rw-r--r-- | drivers/hwmon/Kconfig | 86 | ||||
| -rw-r--r-- | drivers/hwmon/Makefile | 6 | ||||
| -rw-r--r-- | drivers/hwmon/ab5500.c | 212 | ||||
| -rw-r--r-- | drivers/hwmon/ab8500.c | 184 | ||||
| -rw-r--r-- | drivers/hwmon/abx500.c | 698 | ||||
| -rw-r--r-- | drivers/hwmon/abx500.h | 95 | ||||
| -rw-r--r-- | drivers/hwmon/dbx500.c | 402 | ||||
| -rw-r--r-- | drivers/hwmon/hwmon.c | 21 | ||||
| -rw-r--r-- | drivers/hwmon/l3g4200d.c | 717 | ||||
| -rw-r--r-- | drivers/hwmon/lsm303dlh_a.c | 1371 | ||||
| -rw-r--r-- | drivers/hwmon/lsm303dlh_m.c | 924 | ||||
| -rw-r--r-- | drivers/hwmon/lsm303dlhc_a.c | 704 |
12 files changed, 5420 insertions, 0 deletions
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index dad895fec62..36829af0fbd 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -39,6 +39,44 @@ config HWMON_DEBUG_CHIP comment "Native drivers" +config SENSORS_AB8500 + tristate "AB8500 thermal monitoring" + depends on AB8500_GPADC + default n + help + If you say yes here you get support for the thermal sensor part + of the AB8500 chip. The driver includes thermal management for + AB8500 die and two GPADC channels. The GPADC channel are preferably + used to access sensors outside the AB8500 chip. + + This driver can also be built as a module. If so, the module + will be called abx500-temp. + +config SENSORS_AB5500 + tristate "AB5500 thermal monitoring" + depends on AB5500_GPADC + default n + help + If you say yes here you get support for the thermal sensor part + of the AB5500 chip. The driver includes thermal management for + AB5500 die, pcb and RF XTAL temperature. + + This driver can also be built as a module. If so, the module + will be called abx500-temp. + +config SENSORS_DBX500 + tristate "DBX500 thermal monitoring" + depends on MFD_DB8500_PRCMU || MFD_DB5500_PRCMU + default n + help + If you say yes here you get support for the thermal sensor part + of the DBX500 chip. The driver includes thermal management for + DBX500 die. + + This driver can also be built as a module. If so, the module + will be called dbx500_temp. + + config SENSORS_ABITUGURU tristate "Abit uGuru (rev 1 & 2)" depends on X86 && DMI && EXPERIMENTAL @@ -685,6 +723,54 @@ config SENSORS_LTC4151 This driver can also be built as a module. If so, the module will be called ltc4151. +config SENSORS_LSM303DLH + tristate "ST LSM303DLH 3-axis accelerometer and 3-axis magnetometer" + depends on I2C + default n + help + This driver provides support for the LSM303DLH chip which includes a + 3-axis accelerometer and a 3-axis magnetometer. + + This driver can also be built as modules. If so, the module for + accelerometer will be called lsm303dlh_a and for magnetometer it will + be called lsm303dlh_m. + + Say Y here if you have a device containing lsm303dlh chip. + +config SENSORS_LSM303DLH_INPUT_DEVICE + bool "ST LSM303DLH INPUT DEVICE" + depends on SENSORS_LSM303DLH + default n + help + This driver allows device to be used as an input device with + interrupts, need to be enabled only when input device support + is required. + +config SENSORS_LSM303DLHC + tristate "ST LSM303DLHC 3-axis accelerometer and 3-axis magnetometer" + depends on I2C + default n + help + This driver provides support for the LSM303DLHC chip which includes a + 3-axis accelerometer and a 3-axis magnetometer. + + This driver can also be built as modules. If so, the module for + accelerometer will be called lsm303dlhc_a and for magnetometer it will + be called lsm303dlh_m. + + Say Y here if you have a device containing lsm303dlhc chip. + +config SENSORS_L3G4200D + tristate "ST L3G4200D 3-axis gyroscope" + depends on I2C + default n + help + If you say yes here you get support for 3-axis gyroscope device + L3g4200D. + + This driver can also be built as a module. If so, the module + will be called l3g4200d. + config SENSORS_LTC4215 tristate "Linear Technology LTC4215" depends on I2C && EXPERIMENTAL diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 8251ce8cd03..e6dda2a5a66 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -19,6 +19,9 @@ obj-$(CONFIG_SENSORS_W83795) += w83795.o obj-$(CONFIG_SENSORS_W83781D) += w83781d.o obj-$(CONFIG_SENSORS_W83791D) += w83791d.o +obj-$(CONFIG_SENSORS_AB8500) += abx500.o ab8500.o +obj-$(CONFIG_SENSORS_AB5500) += abx500.o ab5500.o +obj-$(CONFIG_SENSORS_DBX500) += dbx500.o obj-$(CONFIG_SENSORS_ABITUGURU) += abituguru.o obj-$(CONFIG_SENSORS_ABITUGURU3)+= abituguru3.o obj-$(CONFIG_SENSORS_AD7314) += ad7314.o @@ -84,6 +87,9 @@ obj-$(CONFIG_SENSORS_LM93) += lm93.o obj-$(CONFIG_SENSORS_LM95241) += lm95241.o obj-$(CONFIG_SENSORS_LM95245) += lm95245.o obj-$(CONFIG_SENSORS_LTC4151) += ltc4151.o +obj-$(CONFIG_SENSORS_LSM303DLH) += lsm303dlh_a.o lsm303dlh_m.o +obj-$(CONFIG_SENSORS_LSM303DLHC)+= lsm303dlhc_a.o +obj-$(CONFIG_SENSORS_L3G4200D) += l3g4200d.o obj-$(CONFIG_SENSORS_LTC4215) += ltc4215.o obj-$(CONFIG_SENSORS_LTC4245) += ltc4245.o obj-$(CONFIG_SENSORS_LTC4261) += ltc4261.o diff --git a/drivers/hwmon/ab5500.c b/drivers/hwmon/ab5500.c new file mode 100644 index 00000000000..cafadeba51c --- /dev/null +++ b/drivers/hwmon/ab5500.c @@ -0,0 +1,212 @@ +/* + * Copyright (C) ST-Ericsson SA 2010 + * Author: Martin Persson <martin.persson@stericsson.com> for + * ST-Ericsson. + * License terms: GNU Gereral Public License (GPL) version 2 + * + * Note: + * + * If/when the AB5500 thermal warning temperature is reached (threshold + * 125C cannot be changed by SW), an interrupt is set and the driver + * notifies user space via a sysfs event. If a shut down is not + * triggered by user space and temperature reaches beyond critical + * limit(130C) pm_power off is called. + * + * If/when AB5500 thermal shutdown temperature is reached a hardware + * shutdown of the AB5500 will occur. + */ + +#include <linux/slab.h> +#include <linux/err.h> +#include <linux/hwmon.h> +#include <linux/sysfs.h> +#include <linux/hwmon-sysfs.h> +#include <linux/platform_device.h> +#include <linux/mfd/abx500/ab5500-gpadc.h> +#include <linux/mfd/abx500/ab5500-bm.h> +#include "abx500.h" +#include <asm/mach-types.h> + +/* AB5500 driver monitors GPADC - XTAL_TEMP, PCB_TEMP, + * BTEMP_BALL, BAT_CTRL and DIE_TEMP + */ +#define NUM_MONITORED_SENSORS 5 + +#define SHUTDOWN_AUTO_MIN_LIMIT -25 +#define SHUTDOWN_AUTO_MAX_LIMIT 130 + +static int ab5500_output_convert(int val, u8 sensor) +{ + int res = val; + /* GPADC returns die temperature in Celsius + * convert it to millidegree celsius + */ + if (sensor == DIE_TEMP) + res = val * 1000; + + return res; +} + +static int ab5500_read_sensor(struct abx500_temp *data, u8 sensor) +{ + int val; + /* + * Special treatment for BAT_CTRL node, since this + * temperature measurement is more complex than just + * an ADC readout + */ + if (sensor == BAT_CTRL) + val = ab5500_btemp_get_batctrl_temp(data->ab5500_btemp); + else + val = ab5500_gpadc_convert(data->ab5500_gpadc, sensor); + + if (val < 0) + return val; + else + return ab5500_output_convert(val, sensor); +} + +static ssize_t ab5500_show_name(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + return sprintf(buf, "ab5500\n"); +} + +static ssize_t ab5500_show_label(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + char *name; + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + int index = attr->index; + + /* + * Make sure these labels correspond to the attribute indexes + * used when calling SENSOR_DEVICE_ATRR. + * Temperature sensors outside ab8500 (read via GPADC) are marked + * with prefix ext_ + */ + switch (index) { + case 1: + name = "xtal_temp"; + break; + case 2: + name = "pcb_temp"; + break; + case 3: + name = "bat_temp"; + break; + case 4: + name = "bat_ctrl"; + break; + case 5: + name = "ab5500"; + break; + default: + return -EINVAL; + } + return sprintf(buf, "%s\n", name); +} + +static int temp_shutdown_trig(int mux) +{ + pm_power_off(); + return 0; +} + +static int ab5500_temp_shutdown_auto(struct abx500_temp *data) +{ + int ret; + struct adc_auto_input *auto_ip; + + auto_ip = kzalloc(sizeof(struct adc_auto_input), GFP_KERNEL); + if (!auto_ip) { + dev_err(&data->pdev->dev, "failed to allocate memory\n"); + return -ENOMEM; + } + + auto_ip->mux = DIE_TEMP; + auto_ip->freq = MS500; + /* + * As per product specification, voltage decreases as + * temperature increases. Hence the min and max values + * should be passed in reverse order. + */ + auto_ip->min = SHUTDOWN_AUTO_MAX_LIMIT; + auto_ip->max = SHUTDOWN_AUTO_MIN_LIMIT; + auto_ip->auto_adc_callback = temp_shutdown_trig; + data->gpadc_auto = auto_ip; + ret = ab5500_gpadc_convert_auto(data->ab5500_gpadc, + data->gpadc_auto); + if (ret < 0) + kfree(auto_ip); + + return ret; +} + +static int ab5500_is_visible(struct attribute *attr, int n) +{ + return attr->mode; +} + +static int ab5500_temp_irq_handler(int irq, struct abx500_temp *data) +{ + /* + * Make sure the magic numbers below corresponds to the node + * used for AB5500 thermal warning from HW. + */ + mutex_lock(&data->lock); + data->crit_alarm[4] = 1; + mutex_unlock(&data->lock); + sysfs_notify(&data->pdev->dev.kobj, NULL, "temp5_crit_alarm"); + dev_info(&data->pdev->dev, "ABX500 thermal warning," + " power off system now!\n"); + return 0; +} + +int __init ab5500_hwmon_init(struct abx500_temp *data) +{ + int err; + + data->ab5500_gpadc = ab5500_gpadc_get("ab5500-adc.0"); + if (IS_ERR(data->ab5500_gpadc)) + return PTR_ERR(data->ab5500_gpadc); + + data->ab5500_btemp = ab5500_btemp_get(); + if (IS_ERR(data->ab5500_btemp)) + return PTR_ERR(data->ab5500_btemp); + + err = ab5500_temp_shutdown_auto(data); + if (err < 0) { + dev_err(&data->pdev->dev, "Failed to register" + " auto trigger(%d)\n", err); + return err; + } + + /* + * Setup HW defined data. + * + * Reference hardware (HREF): + * + * XTAL_TEMP, PCB_TEMP, BTEMP_BALL refer to millivolts and + * BAT_CTRL and DIE_TEMP refer to millidegrees + * + * Make sure indexes correspond to the attribute indexes + * used when calling SENSOR_DEVICE_ATRR + */ + data->gpadc_addr[0] = XTAL_TEMP; + data->gpadc_addr[1] = PCB_TEMP; + data->gpadc_addr[2] = BTEMP_BALL; + data->gpadc_addr[3] = BAT_CTRL; + data->gpadc_addr[4] = DIE_TEMP; + data->monitored_sensors = NUM_MONITORED_SENSORS; + + data->ops.read_sensor = ab5500_read_sensor; + data->ops.irq_handler = ab5500_temp_irq_handler; + data->ops.show_name = ab5500_show_name; + data->ops.show_label = ab5500_show_label; + data->ops.is_visible = ab5500_is_visible; + + return 0; +} diff --git a/drivers/hwmon/ab8500.c b/drivers/hwmon/ab8500.c new file mode 100644 index 00000000000..a652f32dc75 --- /dev/null +++ b/drivers/hwmon/ab8500.c @@ -0,0 +1,184 @@ +/* + * Copyright (C) ST-Ericsson SA 2010 + * Author: Martin Persson <martin.persson@stericsson.com> for + * ST-Ericsson. + * License terms: GNU Gereral Public License (GPL) version 2 + * + * Note: + * + * If/when the AB8500 thermal warning temperature is reached (threshold + * cannot be changed by SW), an interrupt is set and the driver + * notifies user space via a sysfs event. If a shut down is not + * triggered by user space within a certain time frame, + * pm_power off is called. + * + * If/when AB8500 thermal shutdown temperature is reached a hardware + * shutdown of the AB8500 will occur. + */ + +#include <linux/slab.h> +#include <linux/err.h> +#include <linux/hwmon.h> +#include <linux/sysfs.h> +#include <linux/hwmon-sysfs.h> +#include <linux/platform_device.h> +#include <linux/mfd/abx500/ab8500-gpadc.h> +#include <linux/mfd/ab8500/bm.h> +#include "abx500.h" +#include <asm/mach-types.h> + +#define DEFAULT_POWER_OFF_DELAY 10000 + +/* + * The driver monitors GPADC - ADC_AUX1, ADC_AUX2, BTEMP_BALL + * and BAT_CTRL. + */ +#define NUM_MONITORED_SENSORS 4 + +static int ab8500_read_sensor(struct abx500_temp *data, u8 sensor) +{ + int val; + /* + * Special treatment for the BAT_CTRL node, since this + * temperature measurement is more complex than just + * an ADC readout + */ + if (sensor == BAT_CTRL) + val = ab8500_btemp_get_batctrl_temp(data->ab8500_btemp); + else + val = ab8500_gpadc_convert(data->ab8500_gpadc, sensor); + + return val; +} + +static void ab8500_thermal_power_off(struct work_struct *work) +{ + struct abx500_temp *data = container_of(work, struct abx500_temp, + power_off_work.work); + + dev_warn(&data->pdev->dev, "Power off due to AB8500 thermal warning\n"); + pm_power_off(); +} + +static ssize_t ab8500_show_name(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + return sprintf(buf, "ab8500\n"); +} + +static ssize_t ab8500_show_label(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + char *name; + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + int index = attr->index; + + /* + * Make sure these labels correspond to the attribute indexes + * used when calling SENSOR_DEVICE_ATRR. + * Temperature sensors outside ab8500 (read via GPADC) are marked + * with prefix ext_ + */ + switch (index) { + case 1: + name = "ext_rtc_xtal"; + break; + case 2: + name = "ext_db8500"; + break; + case 3: + name = "bat_temp"; + break; + case 4: + name = "bat_ctrl"; + break; + case 5: + name = "ab8500"; + break; + default: + return -EINVAL; + } + return sprintf(buf, "%s\n", name); +} + +static int ab8500_is_visible(struct attribute *attr, int n) +{ + if (!strcmp(attr->name, "temp5_input") || + !strcmp(attr->name, "temp5_min") || + !strcmp(attr->name, "temp5_max") || + !strcmp(attr->name, "temp5_max_hyst") || + !strcmp(attr->name, "temp5_min_alarm") || + !strcmp(attr->name, "temp5_max_alarm") || + !strcmp(attr->name, "temp5_max_hyst_alarm")) + return 0; + + return attr->mode; +} + +static int ab8500_temp_irq_handler(int irq, struct abx500_temp *data) +{ + unsigned long delay_in_jiffies; + /* + * Make sure the magic numbers below corresponds to the node + * used for AB8500 thermal warning from HW. + */ + mutex_lock(&data->lock); + data->crit_alarm[4] = 1; + mutex_unlock(&data->lock); + + hwmon_notify(data->crit_alarm[4], NULL); + sysfs_notify(&data->pdev->dev.kobj, NULL, "temp5_crit_alarm"); + dev_info(&data->pdev->dev, "AB8500 thermal warning," + " power off in %lu s\n", data->power_off_delay); + delay_in_jiffies = msecs_to_jiffies(data->power_off_delay); + schedule_delayed_work(&data->power_off_work, delay_in_jiffies); + return 0; +} + +int __init ab8500_hwmon_init(struct abx500_temp *data) +{ + data->ab8500_gpadc = ab8500_gpadc_get(); + if (IS_ERR(data->ab8500_gpadc)) + return PTR_ERR(data->ab8500_gpadc); + + data->ab8500_btemp = ab8500_btemp_get(); + if (IS_ERR(data->ab8500_btemp)) + return PTR_ERR(data->ab8500_btemp); + + INIT_DELAYED_WORK(&data->power_off_work, ab8500_thermal_power_off); + + /* + * Setup HW defined data. + * + * Reference hardware (HREF): + * + * GPADC - ADC_AUX1, connected to NTC R2148 next to RTC_XTAL on HREF + * GPADC - ADC_AUX2, connected to NTC R2150 near DB8500 on HREF + * Hence, temp#_min/max/max_hyst refer to millivolts and not + * millidegrees + * This is not the case for BAT_CTRL where millidegrees is used + * + * HREF HW does not support reading AB8500 temperature. BUT an + * AB8500 IRQ will be launched if die crit temp limit is reached. + * + * Make sure indexes correspond to the attribute indexes + * used when calling SENSOR_DEVICE_ATRR + */ + data->gpadc_addr[0] = ADC_AUX1; + data->gpadc_addr[1] = ADC_AUX2; + data->gpadc_addr[2] = BTEMP_BALL; + data->gpadc_addr[3] = BAT_CTRL; + data->gpadc_addr[4] = DIE_TEMP; + data->power_off_delay = DEFAULT_POWER_OFF_DELAY; + data->monitored_sensors = NUM_MONITORED_SENSORS; + + data->ops.read_sensor = ab8500_read_sensor; + data->ops.irq_handler = ab8500_temp_irq_handler; + data->ops.show_name = ab8500_show_name; + data->ops.show_label = ab8500_show_label; + data->ops.is_visible = ab8500_is_visible; + + return 0; +} diff --git a/drivers/hwmon/abx500.c b/drivers/hwmon/abx500.c new file mode 100644 index 00000000000..7aa9994c54a --- /dev/null +++ b/drivers/hwmon/abx500.c @@ -0,0 +1,698 @@ +/* + * Copyright (C) ST-Ericsson SA 2010 + * Author: Martin Persson <martin.persson@stericsson.com> for + * ST-Ericsson. + * License terms: GNU Gereral Public License (GPL) version 2 + * + * Note: + * + * ABX500 does not provide auto ADC, so to monitor the required + * temperatures, a periodic work is used. It is more important + * to not wake up the CPU than to perform this job, hence the use + * of a deferred delay. + * + * A deferred delay for thermal monitor is considered safe because: + * If the chip gets too hot during a sleep state it's most likely + * due to external factors, such as the surrounding temperature. + * I.e. no SW decisions will make any difference. + * + * If/when the ABX500 thermal warning temperature is reached (threshold + * cannot be changed by SW), an interrupt is set and the driver + * notifies user space via a sysfs event. + * + * If/when ABX500 thermal shutdown temperature is reached a hardware + * shutdown of the ABX500 will occur. + */ + +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/hwmon.h> +#include <linux/sysfs.h> +#include <linux/hwmon-sysfs.h> +#include <linux/err.h> +#include <linux/platform_device.h> +#include <linux/interrupt.h> +#include <linux/workqueue.h> +#include <linux/jiffies.h> +#include <linux/mutex.h> +#include <linux/pm.h> +#include <asm/mach-types.h> + +#include "abx500.h" + +#define DEFAULT_MONITOR_DELAY 1000 + +/* + * Thresholds are considered inactive if set to 0. + * To avoid confusion for user space applications, + * the temp monitor delay is set to 0 if all thresholds + * are 0. + */ +static bool find_active_thresholds(struct abx500_temp *data) +{ + int i; + for (i = 0; i < data->monitored_sensors; i++) + if (data->max[i] != 0 || data->max_hyst[i] != 0 + || data->min[i] != 0) + return true; + + dev_dbg(&data->pdev->dev, "No active thresholds," + "cancel deferred job (if it exists)" + "and reset temp monitor delay\n"); + cancel_delayed_work_sync(&data->work); + return false; +} + +static inline void schedule_monitor(struct abx500_temp *data) +{ + unsigned long delay_in_jiffies; + delay_in_jiffies = msecs_to_jiffies(data->gpadc_monitor_delay); + schedule_delayed_work(&data->work, delay_in_jiffies); +} + +static inline void gpadc_monitor_exit(struct abx500_temp *data) +{ + cancel_delayed_work_sync(&data->work); +} + +static void gpadc_monitor(struct work_struct *work) +{ + unsigned long delay_in_jiffies; + int val, i, ret; + /* Container for alarm node name */ + char alarm_node[30]; + + bool updated_min_alarm = false; + bool updated_max_alarm = false; + bool updated_max_hyst_alarm = false; + struct abx500_temp *data = container_of(work, struct abx500_temp, + work.work); + + for (i = 0; i < data->monitored_sensors; i++) { + /* Thresholds are considered inactive if set to 0 */ + if (data->max[i] == 0 && data->max_hyst[i] == 0 + && data->min[i] == 0) + continue; + + val = data->ops.read_sensor(data, data->gpadc_addr[i]); + if (val < 0) { + dev_err(&data->pdev->dev, "GPADC read failed\n"); + continue; + } + + mutex_lock(&data->lock); + if (data->min[i] != 0) { + if (val < data->min[i]) { + if (data->min_alarm[i] == 0) { + data->min_alarm[i] = 1; + updated_min_alarm = true; + } + } else { + if (data->min_alarm[i] == 1) { + data->min_alarm[i] = 0; + updated_min_alarm = true; + } + } + + } + if (data->max[i] != 0) { + if (val > data->max[i]) { + if (data->max_alarm[i] == 0) { + data->max_alarm[i] = 1; + updated_max_alarm = true; + } + } else { + if (data->max_alarm[i] == 1) { + data->max_alarm[i] = 0; + updated_max_alarm = true; + } + } + + } + if (data->max_hyst[i] != 0) { + if (val > data->max_hyst[i]) { + if (data->max_hyst_alarm[i] == 0) { + data->max_hyst_alarm[i] = 1; + updated_max_hyst_alarm = true; + } + } else { + if (data->max_hyst_alarm[i] == 1) { + data->max_hyst_alarm[i] = 0; + updated_max_hyst_alarm = true; + } + } + } + mutex_unlock(&data->lock); + + /* hwmon attr index starts at 1, thus "i+1" below */ + if (updated_min_alarm) { + ret = snprintf(alarm_node, 16, "temp%d_min_alarm", + (i + 1)); + if (ret < 0) { + dev_err(&data->pdev->dev, + "Unable to update alarm node (%d)", + ret); + break; + } + sysfs_notify(&data->pdev->dev.kobj, NULL, alarm_node); + } + if (updated_max_alarm) { + ret = snprintf(alarm_node, 16, "temp%d_max_alarm", + (i + 1)); + if (ret < 0) { + dev_err(&data->pdev->dev, + "Unable to update alarm node (%d)", + ret); + break; + } + hwmon_notify(data->max_alarm[i], NULL); + sysfs_notify(&data->pdev->dev.kobj, NULL, alarm_node); + } + if (updated_max_hyst_alarm) { + ret = snprintf(alarm_node, 21, "temp%d_max_hyst_alarm", + (i + 1)); + if (ret < 0) { + dev_err(&data->pdev->dev, + "Unable to update alarm node (%d)", + ret); + break; + } + sysfs_notify(&data->pdev->dev.kobj, NULL, alarm_node); + } + } + delay_in_jiffies = msecs_to_jiffies(data->gpadc_monitor_delay); + schedule_delayed_work(&data->work, delay_in_jiffies); +} + +static ssize_t set_temp_monitor_delay(struct device *dev, + struct device_attribute *devattr, + const char *buf, size_t count) +{ + int res; + unsigned long delay_in_s; + struct abx500_temp *data = dev_get_drvdata(dev); + + res = strict_strtoul(buf, 10, &delay_in_s); + if (res < 0) + return res; + + mutex_lock(&data->lock); + data->gpadc_monitor_delay = delay_in_s * 1000; + + if (find_active_thresholds(data)) + schedule_monitor(data); + + mutex_unlock(&data->lock); + + return count; +} + +static ssize_t set_temp_power_off_delay(struct device *dev, + struct device_attribute *devattr, + const char *buf, size_t count) +{ + int res; + unsigned long delay_in_s; + struct abx500_temp *data = dev_get_drvdata(dev); + + res = strict_strtoul(buf, 10, &delay_in_s); + if (res < 0) + return res; + + mutex_lock(&data->lock); + data->power_off_delay = delay_in_s * 1000; + mutex_unlock(&data->lock); + + return count; +} + +static ssize_t show_temp_monitor_delay(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + /* return time in s, not ms */ + return sprintf(buf, "%lu\n", (data->gpadc_monitor_delay) / 1000); +} + +static ssize_t show_temp_power_off_delay(struct device *dev, + struct device_attribute *devattr, + char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + /* return time in s, not ms */ + return sprintf(buf, "%lu\n", (data->power_off_delay) / 1000); +} + +/* HWMON sysfs interface */ +static ssize_t show_name(struct device *dev, struct device_attribute *devattr, + char *buf) +{ + /* + * To avoid confusion between sensor label and chip name, the function + * "show_label" is not used to return the chip name. + */ + struct abx500_temp *data = dev_get_drvdata(dev); + return data->ops.show_name(dev, devattr, buf); +} + +static ssize_t show_label(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + return data->ops.show_label(dev, devattr, buf); +} + +static ssize_t show_input(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + int val; + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + u8 gpadc_addr = data->gpadc_addr[attr->index - 1]; + + val = data->ops.read_sensor(data, gpadc_addr); + if (val < 0) + dev_err(&data->pdev->dev, "GPADC read failed\n"); + + return sprintf(buf, "%d\n", val); +} + +/* set functions (RW nodes) */ +static ssize_t set_min(struct device *dev, struct device_attribute *devattr, + const char *buf, size_t count) +{ + unsigned long val; + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + int res = strict_strtoul(buf, 10, &val); + if (res < 0) + return res; + + mutex_lock(&data->lock); + /* + * Threshold is considered inactive if set to 0 + * hwmon attr index starts at 1, thus "attr->index-1" below + */ + if (val == 0) + data->min_alarm[attr->index - 1] = 0; + + data->min[attr->index - 1] = val; + + if (val == 0) + (void) find_active_thresholds(data); + else + schedule_monitor(data); + + mutex_unlock(&data->lock); + + return count; +} + +static ssize_t set_max(struct device *dev, struct device_attribute *devattr, + const char *buf, size_t count) +{ + unsigned long val; + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + int res = strict_strtoul(buf, 10, &val); + if (res < 0) + return res; + + mutex_lock(&data->lock); + /* + * Threshold is considered inactive if set to 0 + * hwmon attr index starts at 1, thus "attr->index-1" below + */ + if (val == 0) + data->max_alarm[attr->index - 1] = 0; + + data->max[attr->index - 1] = val; + + if (val == 0) + (void) find_active_thresholds(data); + else + schedule_monitor(data); + + mutex_unlock(&data->lock); + + return count; +} + +static ssize_t set_max_hyst(struct device *dev, + struct device_attribute *devattr, + const char *buf, size_t count) +{ + unsigned long val; + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + int res = strict_strtoul(buf, 10, &val); + if (res < 0) + return res; + + mutex_lock(&data->lock); + /* + * Threshold is considered inactive if set to 0 + * hwmon attr index starts at 1, thus "attr->index-1" below + */ + if (val == 0) + data->max_hyst_alarm[attr->index - 1] = 0; + + data->max_hyst[attr->index - 1] = val; + + if (val == 0) + (void) find_active_thresholds(data); + else + schedule_monitor(data); + + mutex_unlock(&data->lock); + + return count; +} + +/* + * show functions (RO nodes) + */ +static ssize_t show_min(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%ld\n", data->min[attr->index - 1]); +} + +static ssize_t show_max(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%ld\n", data->max[attr->index - 1]); +} + +static ssize_t show_max_hyst(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%ld\n", data->max_hyst[attr->index - 1]); +} + +/* Alarms */ +static ssize_t show_min_alarm(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%ld\n", data->min_alarm[attr->index - 1]); +} + +static ssize_t show_max_alarm(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%ld\n", data->max_alarm[attr->index - 1]); +} + +static ssize_t show_max_hyst_alarm(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%ld\n", data->max_hyst_alarm[attr->index - 1]); +} + +static ssize_t show_crit_alarm(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct abx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%ld\n", data->crit_alarm[attr->index - 1]); +} + +static mode_t abx500_attrs_visible(struct kobject *kobj, + struct attribute *a, int n) +{ + struct device *dev = container_of(kobj, struct device, kobj); + struct abx500_temp *data = dev_get_drvdata(dev); + return data->ops.is_visible(a, n); +} + +static SENSOR_DEVICE_ATTR(temp_monitor_delay, S_IRUGO | S_IWUSR, + show_temp_monitor_delay, set_temp_monitor_delay, 0); +static SENSOR_DEVICE_ATTR(temp_power_off_delay, S_IRUGO | S_IWUSR, + show_temp_power_off_delay, + set_temp_power_off_delay, 0); + +/* Chip name, required by hwmon*/ +static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0); + +/* GPADC - SENSOR1 */ +static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_label, NULL, 1); +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 1); +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_min, set_min, 1); +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_max, set_max, 1); +static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, + show_max_hyst, set_max_hyst, 1); +static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_min_alarm, NULL, 1); +static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_max_alarm, NULL, 1); +static SENSOR_DEVICE_ATTR(temp1_max_hyst_alarm, S_IRUGO, + show_max_hyst_alarm, NULL, 1); + +/* GPADC - SENSOR2 */ +static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_label, NULL, 2); +static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2); +static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_min, set_min, 2); +static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_max, set_max, 2); +static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IWUSR | S_IRUGO, + show_max_hyst, set_max_hyst, 2); +static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_min_alarm, NULL, 2); +static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_max_alarm, NULL, 2); +static SENSOR_DEVICE_ATTR(temp2_max_hyst_alarm, S_IRUGO, + show_max_hyst_alarm, NULL, 2); + +/* GPADC - SENSOR3 */ +static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO, show_label, NULL, 3); +static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_input, NULL, 3); +static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_min, set_min, 3); +static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_max, set_max, 3); +static SENSOR_DEVICE_ATTR(temp3_max_hyst, S_IWUSR | S_IRUGO, + show_max_hyst, set_max_hyst, 3); +static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_min_alarm, NULL, 3); +static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_max_alarm, NULL, 3); +static SENSOR_DEVICE_ATTR(temp3_max_hyst_alarm, S_IRUGO, + show_max_hyst_alarm, NULL, 3); + +/* GPADC - SENSOR4 */ +static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO, show_label, NULL, 4); +static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_input, NULL, 4); +static SENSOR_DEVICE_ATTR(temp4_min, S_IWUSR | S_IRUGO, show_min, set_min, 4); +static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_max, set_max, 4); +static SENSOR_DEVICE_ATTR(temp4_max_hyst, S_IWUSR | S_IRUGO, + show_max_hyst, set_max_hyst, 4); +static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_min_alarm, NULL, 4); +static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_max_alarm, NULL, 4); +static SENSOR_DEVICE_ATTR(temp4_max_hyst_alarm, S_IRUGO, + show_max_hyst_alarm, NULL, 4); + +/* GPADC - SENSOR5 */ +static SENSOR_DEVICE_ATTR(temp5_label, S_IRUGO, show_label, NULL, 5); +static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_input, NULL, 5); +static SENSOR_DEVICE_ATTR(temp5_min, S_IWUSR | S_IRUGO, show_min, set_min, 5); +static SENSOR_DEVICE_ATTR(temp5_max, S_IWUSR | S_IRUGO, show_max, set_max, 5); +static SENSOR_DEVICE_ATTR(temp5_max_hyst, S_IWUSR | S_IRUGO, + show_max_hyst, set_max_hyst, 5); +static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO, show_min_alarm, NULL, 5); +static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_max_alarm, NULL, 5); +static SENSOR_DEVICE_ATTR(temp5_max_hyst_alarm, S_IRUGO, + show_max_hyst_alarm, NULL, 5); +static SENSOR_DEVICE_ATTR(temp5_crit_alarm, S_IRUGO, + show_crit_alarm, NULL, 5); + +struct attribute *abx500_temp_attributes[] = { + &sensor_dev_attr_name.dev_attr.attr, + &sensor_dev_attr_temp_monitor_delay.dev_attr.attr, + &sensor_dev_attr_temp_power_off_delay.dev_attr.attr, + /* GPADC SENSOR1 */ + &sensor_dev_attr_temp1_label.dev_attr.attr, + &sensor_dev_attr_temp1_input.dev_attr.attr, + &sensor_dev_attr_temp1_min.dev_attr.attr, + &sensor_dev_attr_temp1_max.dev_attr.attr, + &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, + &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, + &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, + &sensor_dev_attr_temp1_max_hyst_alarm.dev_attr.attr, + /* GPADC SENSOR2 */ + &sensor_dev_attr_temp2_label.dev_attr.attr, + &sensor_dev_attr_temp2_input.dev_attr.attr, + &sensor_dev_attr_temp2_min.dev_attr.attr, + &sensor_dev_attr_temp2_max.dev_attr.attr, + &sensor_dev_attr_temp2_max_hyst.dev_attr.attr, + &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, + &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, + &sensor_dev_attr_temp2_max_hyst_alarm.dev_attr.attr, + /* GPADC SENSOR3 */ + &sensor_dev_attr_temp3_label.dev_attr.attr, + &sensor_dev_attr_temp3_input.dev_attr.attr, + &sensor_dev_attr_temp3_min.dev_attr.attr, + &sensor_dev_attr_temp3_max.dev_attr.attr, + &sensor_dev_attr_temp3_max_hyst.dev_attr.attr, + &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, + &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, + &sensor_dev_attr_temp3_max_hyst_alarm.dev_attr.attr, + /* GPADC SENSOR4 */ + &sensor_dev_attr_temp4_label.dev_attr.attr, + &sensor_dev_attr_temp4_input.dev_attr.attr, + &sensor_dev_attr_temp4_min.dev_attr.attr, + &sensor_dev_attr_temp4_max.dev_attr.attr, + &sensor_dev_attr_temp4_max_hyst.dev_attr.attr, + &sensor_dev_attr_temp4_min_alarm.dev_attr.attr, + &sensor_dev_attr_temp4_max_alarm.dev_attr.attr, + &sensor_dev_attr_temp4_max_hyst_alarm.dev_attr.attr, + /* GPADC SENSOR5*/ + &sensor_dev_attr_temp5_label.dev_attr.attr, + &sensor_dev_attr_temp5_input.dev_attr.attr, + &sensor_dev_attr_temp5_min.dev_attr.attr, + &sensor_dev_attr_temp5_max.dev_attr.attr, + &sensor_dev_attr_temp5_max_hyst.dev_attr.attr, + &sensor_dev_attr_temp5_min_alarm.dev_attr.attr, + &sensor_dev_attr_temp5_max_alarm.dev_attr.attr, + &sensor_dev_attr_temp5_max_hyst_alarm.dev_attr.attr, + &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr, + NULL +}; + +static const struct attribute_group abx500_temp_group = { + .attrs = abx500_temp_attributes, + .is_visible = abx500_attrs_visible, +}; + +static irqreturn_t abx500_temp_irq_handler(int irq, void *irq_data) +{ + struct platform_device *pdev = irq_data; + struct abx500_temp *data = platform_get_drvdata(pdev); + data->ops.irq_handler(irq, data); + return IRQ_HANDLED; +} + +static int setup_irqs(struct platform_device *pdev) +{ + int ret; + int irq = platform_get_irq_byname(pdev, "ABX500_TEMP_WARM"); + + if (irq < 0) + dev_err(&pdev->dev, "Get irq by name failed\n"); + + ret = request_threaded_irq(irq, NULL, abx500_temp_irq_handler, + IRQF_NO_SUSPEND, "abx500-temp", pdev); + if (ret < 0) + dev_err(&pdev->dev, "Request threaded irq failed (%d)\n", ret); + + return ret; +} + +static int __devinit abx500_temp_probe(struct platform_device *pdev) +{ + struct abx500_temp *data; + int err; + + data = kzalloc(sizeof(struct abx500_temp), GFP_KERNEL); + if (!data) + return -ENOMEM; + + data->pdev = pdev; + mutex_init(&data->lock); + + /* Chip specific initialization */ + if (!machine_is_u5500()) + err = ab8500_hwmon_init(data); + else + err = ab5500_hwmon_init(data); + if (err < 0) { + dev_err(&pdev->dev, "abx500 init failed"); + goto exit; + } + + data->hwmon_dev = hwmon_device_register(&pdev->dev); + if (IS_ERR(data->hwmon_dev)) { + err = PTR_ERR(data->hwmon_dev); + dev_err(&pdev->dev, "Class registration failed (%d)\n", err); + goto exit; + } + + INIT_DELAYED_WORK_DEFERRABLE(&data->work, gpadc_monitor); + data->gpadc_monitor_delay = DEFAULT_MONITOR_DELAY; + + platform_set_drvdata(pdev, data); + + err = sysfs_create_group(&pdev->dev.kobj, &abx500_temp_group); + if (err < 0) { + dev_err(&pdev->dev, "Create sysfs group failed (%d)\n", err); + goto exit_platform_data; + } + + err = setup_irqs(pdev); + if (err < 0) { + dev_err(&pdev->dev, "irq setup failed (%d)\n", err); + goto exit_sysfs_group; + } + return 0; + +exit_sysfs_group: + sysfs_remove_group(&pdev->dev.kobj, &abx500_temp_group); +exit_platform_data: + hwmon_device_unregister(data->hwmon_dev); + platform_set_drvdata(pdev, NULL); +exit: + kfree(data->gpadc_auto); + kfree(data); + return err; +} + +static int __devexit abx500_temp_remove(struct platform_device *pdev) +{ + struct abx500_temp *data = platform_get_drvdata(pdev); + + gpadc_monitor_exit(data); + hwmon_device_unregister(data->hwmon_dev); + sysfs_remove_group(&pdev->dev.kobj, &abx500_temp_group); + platform_set_drvdata(pdev, NULL); + kfree(data->gpadc_auto); + kfree(data); + return 0; +} + +/* No action required in suspend/resume, thus the lack of functions */ +static struct platform_driver abx500_temp_driver = { + .driver = { + .owner = THIS_MODULE, + .name = "abx500-temp", + }, + .probe = abx500_temp_probe, + .remove = __devexit_p(abx500_temp_remove), +}; + +static int __init abx500_temp_init(void) +{ + return platform_driver_register(&abx500_temp_driver); +} + +static void __exit abx500_temp_exit(void) +{ + platform_driver_unregister(&abx500_temp_driver); +} + +MODULE_AUTHOR("Martin Persson <martin.persson@stericsson.com>"); +MODULE_DESCRIPTION("ABX500 temperature driver"); +MODULE_LICENSE("GPL"); + +module_init(abx500_temp_init) +module_exit(abx500_temp_exit) diff --git a/drivers/hwmon/abx500.h b/drivers/hwmon/abx500.h new file mode 100644 index 00000000000..9fe28dac28f --- /dev/null +++ b/drivers/hwmon/abx500.h @@ -0,0 +1,95 @@ +/* + * Copyright (C) ST-Ericsson SA 2010 + * License terms: GNU General Public License v2 + * Author: Martin Persson <martin.persson@stericsson.com> + */ + +#ifndef _ABX500_H +#define _ABX500_H + +#define NUM_SENSORS 5 + +struct ab8500_gpadc; +struct ab5500_gpadc; +struct ab8500_btemp; +struct ab5500_btemp; +struct adc_auto_input; +struct abx500_temp; + +/** + * struct abx500_temp_ops - abx500 chip specific ops + * @read_sensor: reads gpadc output + * @irq_handler: irq handler + * @show_name: hwmon device name + * @show_label: hwmon attribute label + * @is_visible: is attribute visible + */ +struct abx500_temp_ops { + int (*read_sensor)(struct abx500_temp *, u8); + int (*irq_handler)(int, struct abx500_temp *); + ssize_t (*show_name)(struct device *, + struct device_attribute *, char *); + ssize_t (*show_label) (struct device *, + struct device_attribute *, char *); + int (*is_visible)(struct attribute *, int); +}; + +/** + * struct abx500_temp - representation of temp mon device + * @pdev: platform device + * @hwmon_dev: hwmon device + * @ab8500_gpadc: gpadc interface for ab8500 + * @ab5500_gpadc: gpadc interface for ab5500 + * @btemp: battery temperature interface for ab8500 + * @adc_auto_input: gpadc auto trigger + * @gpadc_addr: gpadc channel address + * @temp: sensor temperature input value + * @min: sensor temperature min value + * @max: sensor temperature max value + * @max_hyst: sensor temperature hysteresis value for max limit + * @crit: sensor temperature critical value + * @min_alarm: sensor temperature min alarm + * @max_alarm: sensor temperature max alarm + * @max_hyst_alarm: sensor temperature hysteresis alarm + * @crit_alarm: sensor temperature critical value alarm + * @work: delayed work scheduled to monitor temperature periodically + * @power_off_work: delayed work scheduled to power off the system + when critical temperature is reached + * @lock: mutex + * @gpadc_monitor_delay: delay between temperature readings in ms + * @power_off_delay: delay before power off in ms + * @monitored_sensors: number of monitored sensors + */ +struct abx500_temp { + struct platform_device *pdev; + struct device *hwmon_dev; + struct ab8500_gpadc *ab8500_gpadc; + struct ab5500_gpadc *ab5500_gpadc; + struct ab8500_btemp *ab8500_btemp; + struct ab5500_btemp *ab5500_btemp; + struct adc_auto_input *gpadc_auto; + struct abx500_temp_ops ops; + u8 gpadc_addr[NUM_SENSORS]; + unsigned long temp[NUM_SENSORS]; + unsigned long min[NUM_SENSORS]; + unsigned long max[NUM_SENSORS]; + unsigned long max_hyst[NUM_SENSORS]; + unsigned long crit[NUM_SENSORS]; + unsigned long min_alarm[NUM_SENSORS]; + unsigned long max_alarm[NUM_SENSORS]; + unsigned long max_hyst_alarm[NUM_SENSORS]; + unsigned long crit_alarm[NUM_SENSORS]; + struct delayed_work work; + struct delayed_work power_off_work; + struct mutex lock; + /* Delay (ms) between temperature readings */ + unsigned long gpadc_monitor_delay; + /* Delay (ms) before power off */ + unsigned long power_off_delay; + int monitored_sensors; +}; + +int ab8500_hwmon_init(struct abx500_temp *data) __init; +int ab5500_hwmon_init(struct abx500_temp *data) __init; + +#endif /* _ABX500_H */ diff --git a/drivers/hwmon/dbx500.c b/drivers/hwmon/dbx500.c new file mode 100644 index 00000000000..c034b48f8dd --- /dev/null +++ b/drivers/hwmon/dbx500.c @@ -0,0 +1,402 @@ +/* + * Copyright (C) ST-Ericsson SA 2010. All rights reserved. + * This code is ST-Ericsson proprietary and confidential. + * Any use of the code for whatever purpose is subject to + * specific written permission of ST-Ericsson SA. + * + * Author: WenHai Fang <wenhai.h.fang@stericsson.com> for + * ST-Ericsson. + * License terms: GNU Gereral Public License (GPL) version 2 + * + */ + +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/platform_device.h> +#include <linux/mfd/dbx500-prcmu.h> +#include <linux/hwmon.h> +#include <linux/sysfs.h> +#include <linux/hwmon-sysfs.h> +#include <linux/err.h> +#include <linux/interrupt.h> +#include <linux/workqueue.h> +#include <linux/jiffies.h> +#include <linux/mutex.h> +#include <linux/pm.h> +#include <linux/io.h> +#include <mach/hardware.h> + +/* + * Default measure period to 0xFF x cycle32k + */ +#define DEFAULT_MEASURE_TIME 0xFF + +/* + * Default critical sensor temperature + */ +#define DEFAULT_CRITICAL_TEMP 85 + +/* This driver monitors DB thermal*/ +#define NUM_SENSORS 1 + +struct dbx500_temp { + struct platform_device *pdev; + struct device *hwmon_dev; + unsigned char min[NUM_SENSORS]; + unsigned char max[NUM_SENSORS]; + unsigned char crit[NUM_SENSORS]; + unsigned char min_alarm[NUM_SENSORS]; + unsigned char max_alarm[NUM_SENSORS]; + unsigned short measure_time; + bool monitoring_active; + struct mutex lock; +}; + +static inline void start_temp_monitoring(struct dbx500_temp *data, + const int index) +{ + unsigned int i; + + /* determine if there are any sensors worth monitoring */ + for (i = 0; i < NUM_SENSORS; i++) + if (data->min[i] || data->max[i]) + goto start_monitoring; + + return; + +start_monitoring: + /* kick off the monitor job */ + data->min_alarm[index] = 0; + data->max_alarm[index] = 0; + + (void) prcmu_start_temp_sense(data->measure_time); + data->monitoring_active = true; +} + +static inline void stop_temp_monitoring(struct dbx500_temp *data) +{ + if (data->monitoring_active) { + (void) prcmu_stop_temp_sense(); + data->monitoring_active = false; + } +} + +/* HWMON sysfs interface */ +static ssize_t show_name(struct device *dev, struct device_attribute *devattr, + char *buf) +{ + return sprintf(buf, "dbx500\n"); +} + +static ssize_t show_label(struct device *dev, struct device_attribute *devattr, + char *buf) +{ + return show_name(dev, devattr, buf); +} + +/* set functions (RW nodes) */ +static ssize_t set_min(struct device *dev, struct device_attribute *devattr, + const char *buf, size_t count) +{ + unsigned long val; + struct dbx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + int res = strict_strtoul(buf, 10, &val); + if (res < 0) + return res; + + mutex_lock(&data->lock); + val &= 0xFF; + if (val > data->max[attr->index - 1]) + val = data->max[attr->index - 1]; + + data->min[attr->index - 1] = val; + + stop_temp_monitoring(data); + + (void) prcmu_config_hotmon(data->min[attr->index - 1], + data->max[attr->index - 1]); + + start_temp_monitoring(data, (attr->index - 1)); + + mutex_unlock(&data->lock); + return count; +} + +static ssize_t set_max(struct device *dev, struct device_attribute *devattr, + const char *buf, size_t count) +{ + unsigned long val; + struct dbx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + int res = strict_strtoul(buf, 10, &val); + if (res < 0) + return res; + + mutex_lock(&data->lock); + val &= 0xFF; + if (val < data->min[attr->index - 1]) + val = data->min[attr->index - 1]; + + data->max[attr->index - 1] = val; + + stop_temp_monitoring(data); + + (void) prcmu_config_hotmon(data->min[attr->index - 1], + data->max[attr->index - 1]); + + start_temp_monitoring(data, (attr->index - 1)); + + mutex_unlock(&data->lock); + + return count; +} + +static ssize_t set_crit(struct device *dev, + struct device_attribute *devattr, + const char *buf, size_t count) +{ + unsigned long val; + struct dbx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + int res = strict_strtoul(buf, 10, &val); + if (res < 0) + return res; + + mutex_lock(&data->lock); + val &= 0xFF; + data->crit[attr->index - 1] = val; + (void) prcmu_config_hotdog(data->crit[attr->index - 1]); + mutex_unlock(&data->lock); + + return count; +} + +/* + * show functions (RO nodes) + * Notice that min/max/crit refer to degrees + */ +static ssize_t show_min(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct dbx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%d\n", data->min[attr->index - 1]); +} + +static ssize_t show_max(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct dbx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%d\n", data->max[attr->index - 1]); +} + +static ssize_t show_crit(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct dbx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%d\n", data->crit[attr->index - 1]); +} + +/* Alarms */ +static ssize_t show_min_alarm(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct dbx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%d\n", data->min_alarm[attr->index - 1]); +} + +static ssize_t show_max_alarm(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct dbx500_temp *data = dev_get_drvdata(dev); + struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr); + /* hwmon attr index starts at 1, thus "attr->index-1" below */ + return sprintf(buf, "%d\n", data->max_alarm[attr->index - 1]); +} + +/* Chip name, required by hwmon*/ +static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0); +static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_min, set_min, 1); +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_max, set_max, 1); +static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, + show_crit, set_crit, 1); +static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_label, NULL, 1); +static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_min_alarm, NULL, 1); +static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_max_alarm, NULL, 1); + +static struct attribute *dbx500_temp_attributes[] = { + &sensor_dev_attr_name.dev_attr.attr, + &sensor_dev_attr_temp1_min.dev_attr.attr, + &sensor_dev_attr_temp1_max.dev_attr.attr, + &sensor_dev_attr_temp1_crit.dev_attr.attr, + &sensor_dev_attr_temp1_label.dev_attr.attr, + &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, + &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, + NULL +}; + +static const struct attribute_group dbx500_temp_group = { + .attrs = dbx500_temp_attributes, +}; + +static irqreturn_t prcmu_hotmon_low_irq_handler(int irq, void *irq_data) +{ + struct platform_device *pdev = irq_data; + struct dbx500_temp *data = platform_get_drvdata(pdev); + + mutex_lock(&data->lock); + data->min_alarm[0] = 1; + mutex_unlock(&data->lock); + + sysfs_notify(&pdev->dev.kobj, NULL, "temp1_min_alarm"); + dev_dbg(&pdev->dev, "DBX500 thermal low warning\n"); + return IRQ_HANDLED; +} + +static irqreturn_t prcmu_hotmon_high_irq_handler(int irq, void *irq_data) +{ + struct platform_device *pdev = irq_data; + struct dbx500_temp *data = platform_get_drvdata(pdev); + + mutex_lock(&data->lock); + data->max_alarm[0] = 1; + mutex_unlock(&data->lock); + + hwmon_notify(data->max_alarm[0], NULL); + sysfs_notify(&pdev->dev.kobj, NULL, "temp1_max_alarm"); + + return IRQ_HANDLED; +} + +static int __devinit dbx500_temp_probe(struct platform_device *pdev) +{ + struct dbx500_temp *data; + int err = 0, i; + int irq; + + dev_dbg(&pdev->dev, "dbx500_temp: Function dbx500_temp_probe.\n"); + + data = kzalloc(sizeof(struct dbx500_temp), GFP_KERNEL); + if (!data) + return -ENOMEM; + + irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_LOW"); + if (irq < 0) { + dev_err(&pdev->dev, "Get IRQ_HOTMON_LOW failed\n"); + goto exit; + } + + err = request_threaded_irq(irq, NULL, + prcmu_hotmon_low_irq_handler, + IRQF_NO_SUSPEND, + "dbx500_temp_low", pdev); + if (err < 0) { + dev_err(&pdev->dev, "dbx500: Failed allocate HOTMON_LOW.\n"); + goto exit; + } else { + dev_dbg(&pdev->dev, "dbx500: Succeed allocate HOTMON_LOW.\n"); + } + + irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_HIGH"); + if (irq < 0) { + dev_err(&pdev->dev, "Get IRQ_HOTMON_HIGH failed\n"); + goto exit; + } + + err = request_threaded_irq(irq, NULL, + prcmu_hotmon_high_irq_handler, + IRQF_NO_SUSPEND, + "dbx500_temp_high", pdev); + if (err < 0) { + dev_err(&pdev->dev, "dbx500: Failed allocate HOTMON_HIGH.\n"); + goto exit; + } else { + dev_dbg(&pdev->dev, "dbx500: Succeed allocate HOTMON_HIGH.\n"); + } + + data->hwmon_dev = hwmon_device_register(&pdev->dev); + if (IS_ERR(data->hwmon_dev)) { + err = PTR_ERR(data->hwmon_dev); + dev_err(&pdev->dev, "Class registration failed (%d)\n", err); + goto exit; + } + + for (i = 0; i < NUM_SENSORS; i++) { + data->min[i] = 0; + data->max[i] = 0; + data->crit[i] = DEFAULT_CRITICAL_TEMP; + data->min_alarm[i] = 0; + data->max_alarm[i] = 0; + } + + mutex_init(&data->lock); + + data->pdev = pdev; + data->measure_time = DEFAULT_MEASURE_TIME; + data->monitoring_active = false; + + /* set PRCMU to disable platform when we get to the critical temp */ + (void) prcmu_config_hotdog(DEFAULT_CRITICAL_TEMP); + + platform_set_drvdata(pdev, data); + + err = sysfs_create_group(&pdev->dev.kobj, &dbx500_temp_group); + if (err < 0) { + dev_err(&pdev->dev, "Create sysfs group failed (%d)\n", err); + goto exit_platform_data; + } + + return 0; + +exit_platform_data: + platform_set_drvdata(pdev, NULL); +exit: + kfree(data); + return err; +} + +static int __devexit dbx500_temp_remove(struct platform_device *pdev) +{ + struct dbx500_temp *data = platform_get_drvdata(pdev); + + hwmon_device_unregister(data->hwmon_dev); + sysfs_remove_group(&pdev->dev.kobj, &dbx500_temp_group); + platform_set_drvdata(pdev, NULL); + kfree(data); + return 0; +} + +/* No action required in suspend/resume, thus the lack of functions */ +static struct platform_driver dbx500_temp_driver = { + .driver = { + .owner = THIS_MODULE, + .name = "dbx500_temp", + }, + .probe = dbx500_temp_probe, + .remove = __devexit_p(dbx500_temp_remove), +}; + +static int __init dbx500_temp_init(void) +{ + return platform_driver_register(&dbx500_temp_driver); +} + +static void __exit dbx500_temp_exit(void) +{ + platform_driver_unregister(&dbx500_temp_driver); +} + +MODULE_AUTHOR("WenHai Fang <wenhai.h.fang@stericsson.com>"); +MODULE_DESCRIPTION("DBX500 temperature driver"); +MODULE_LICENSE("GPL"); + +module_init(dbx500_temp_init) +module_exit(dbx500_temp_exit) diff --git a/drivers/hwmon/hwmon.c b/drivers/hwmon/hwmon.c index 6460487e41b..ac718a57b88 100644 --- a/drivers/hwmon/hwmon.c +++ b/drivers/hwmon/hwmon.c @@ -21,6 +21,7 @@ #include <linux/gfp.h> #include <linux/spinlock.h> #include <linux/pci.h> +#include <linux/notifier.h> #define HWMON_ID_PREFIX "hwmon" #define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d" @@ -29,6 +30,8 @@ static struct class *hwmon_class; static DEFINE_IDA(hwmon_ida); +static BLOCKING_NOTIFIER_HEAD(hwmon_notifier_list); + /** * hwmon_device_register - register w/ hwmon * @dev: the device to register @@ -73,6 +76,24 @@ void hwmon_device_unregister(struct device *dev) "hwmon_device_unregister() failed: bad class ID!\n"); } +int hwmon_notifier_register(struct notifier_block *nb) +{ + return blocking_notifier_chain_register(&hwmon_notifier_list, nb); +} +EXPORT_SYMBOL(hwmon_notifier_register); + +int hwmon_notifier_unregister(struct notifier_block *nb) +{ + return blocking_notifier_chain_unregister(&hwmon_notifier_list, nb); +} +EXPORT_SYMBOL(hwmon_notifier_unregister); + +void hwmon_notify(unsigned long val, void *v) +{ + blocking_notifier_call_chain(&hwmon_notifier_list, val, v); +} +EXPORT_SYMBOL(hwmon_notify); + static void __init hwmon_pci_quirks(void) { #if defined CONFIG_X86 && defined CONFIG_PCI diff --git a/drivers/hwmon/l3g4200d.c b/drivers/hwmon/l3g4200d.c new file mode 100644 index 00000000000..ffe3e1a9730 --- /dev/null +++ b/drivers/hwmon/l3g4200d.c @@ -0,0 +1,717 @@ +/* + * ST L3G4200D 3-Axis Gyroscope Driver + * + * Copyright (C) ST-Ericsson SA 2011 + * Author: Chethan Krishna N <chethan.krishna@stericsson.com> for ST-Ericsson + * Licence terms: GNU General Public Licence (GPL) version 2 + */ + +#include <linux/module.h> +#include <linux/i2c.h> +#include <linux/mutex.h> +#include <linux/slab.h> +#include <linux/delay.h> +#include <linux/platform_device.h> +#include <linux/err.h> + +#include <linux/l3g4200d.h> +#include <linux/regulator/consumer.h> + +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif + +/* l3g4200d gyroscope registers */ + +#define WHO_AM_I 0x0F + +#define CTRL_REG1 0x20 /* CTRL REG1 */ +#define CTRL_REG2 0x21 /* CTRL REG2 */ +#define CTRL_REG3 0x22 /* CTRL_REG3 */ +#define CTRL_REG4 0x23 /* CTRL_REG4 */ +#define CTRL_REG5 0x24 /* CTRL_REG5 */ +#define OUT_TEMP 0x26 /* OUT_TEMP */ + +#define AXISDATA_REG 0x28 + +/** Registers Contents */ + +#define WHOAMI_L3G4200D 0x00D3 /* Expected content for WAI register*/ + +/* CTRL_REG1 */ +#define PM_OFF 0x00 +#define PM_ON 0x01 +#define ENABLE_ALL_AXES 0x07 +#define BW00 0x00 +#define BW01 0x10 +#define BW10 0x20 +#define BW11 0x30 +#define ODR00 0x00 /* ODR = 100Hz */ +#define ODR01 0x40 /* ODR = 200Hz */ +#define ODR10 0x80 /* ODR = 400Hz */ +#define ODR11 0xC0 /* ODR = 800Hz */ +#define L3G4200D_PM_BIT 3 +#define L3G4200D_PM_MASK (0x01 << L3G4200D_PM_BIT) +#define L3G4200D_ODR_BIT 4 +#define L3G4200D_ODR_MASK (0x0F << L3G4200D_ODR_BIT) +#define L3G4200D_ODR_MIN_VAL 0x00 +#define L3G4200D_ODR_MAX_VAL 0x0F + +/* CTRL_REG4 */ +#define FS250 0x00 +#define FS500 0x01 +#define FS2000 0x03 +#define BDU_ENABLE 0x80 +#define L3G4200D_FS_BIT 6 +#define L3G4200D_FS_MASK (0x3 << L3G4200D_FS_BIT) + +/* multiple byte transfer enable */ +#define MULTIPLE_I2C_TR 0x80 + +/* device status defines */ +#define DEVICE_OFF 0 +#define DEVICE_ON 1 +#define DEVICE_SUSPENDED 2 + +/* + * L3G4200D gyroscope data + * brief structure containing gyroscope values for yaw, pitch and roll in + * signed short + */ + +struct l3g4200d_gyro_values { + short x; /* x-axis angular rate data. */ + short y; /* y-axis angluar rate data. */ + short z; /* z-axis angular rate data. */ +}; + +struct l3g4200d_data { + struct i2c_client *client; + struct mutex lock; + struct l3g4200d_gyro_values data; + struct l3g4200d_gyr_platform_data pdata; + struct regulator *regulator; +#ifdef CONFIG_HAS_EARLYSUSPEND + struct early_suspend early_suspend; +#endif + unsigned char powermode; + unsigned char odr; + unsigned char range; + int device_status; +}; + +#ifdef CONFIG_HAS_EARLYSUSPEND +static void l3g4200d_early_suspend(struct early_suspend *ddata); +static void l3g4200d_late_resume(struct early_suspend *ddata); +#endif + +static int l3g4200d_write(struct l3g4200d_data *ddata, u8 reg, + u8 val, char *msg) +{ + int ret = i2c_smbus_write_byte_data(ddata->client, reg, val); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_write_byte_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +static int l3g4200d_read(struct l3g4200d_data *ddata, u8 reg, char *msg) +{ + int ret = i2c_smbus_read_byte_data(ddata->client, reg); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_read_byte_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +static int l3g4200d_readdata(struct l3g4200d_data *ddata) +{ + unsigned char gyro_data[6]; + short data[3]; + int ret; + + ret = i2c_smbus_read_i2c_block_data(ddata->client, + AXISDATA_REG | MULTIPLE_I2C_TR, 6, gyro_data); + if (ret < 0) { + dev_err(&ddata->client->dev, + "i2c_smbus_read_byte_data failed error %d\ + Register AXISDATA_REG\n", ret); + return ret; + } + + data[0] = (short) (((gyro_data[1]) << 8) | gyro_data[0]); + data[1] = (short) (((gyro_data[3]) << 8) | gyro_data[2]); + data[2] = (short) (((gyro_data[5]) << 8) | gyro_data[4]); + + data[ddata->pdata.axis_map_x] = ddata->pdata.negative_x ? + -data[ddata->pdata.axis_map_x] : data[ddata->pdata.axis_map_x]; + data[ddata->pdata.axis_map_y] = ddata->pdata.negative_y ? + -data[ddata->pdata.axis_map_y] : data[ddata->pdata.axis_map_y]; + data[ddata->pdata.axis_map_z] = ddata->pdata.negative_z ? + -data[ddata->pdata.axis_map_z] : data[ddata->pdata.axis_map_z]; + + ddata->data.x = data[ddata->pdata.axis_map_x]; + ddata->data.y = data[ddata->pdata.axis_map_y]; + ddata->data.z = data[ddata->pdata.axis_map_z]; + + return ret; +} + +static ssize_t l3g4200d_show_gyrodata(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->powermode == PM_OFF || + ddata->device_status == DEVICE_SUSPENDED) { + mutex_unlock(&ddata->lock); + return ret; + } + + ret = l3g4200d_readdata(ddata); + + if (ret < 0) { + mutex_unlock(&ddata->lock); + return ret; + } + + mutex_unlock(&ddata->lock); + + return sprintf(buf, "%8x:%8x:%8x\n", ddata->data.x, ddata->data.y, + ddata->data.z); +} + +static ssize_t l3g4200d_show_range(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->range); +} + +static ssize_t l3g4200d_store_range(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + long received_value; + unsigned char value; + int error; + + error = strict_strtol(buf, 0, &received_value); + if (error) + return error; + + /* check if the received range is in valid range */ + if (received_value < FS250 || received_value > FS2000) + return -EINVAL; + + mutex_lock(&ddata->lock); + + if (ddata->powermode == PM_OFF) { + dev_info(&ddata->client->dev, + "The device is switched off, turn it ON using powermode\n"); + mutex_unlock(&ddata->lock); + return count; + } + + /* enable the BDU bit */ + value = BDU_ENABLE; + value |= ((received_value << L3G4200D_FS_BIT) & L3G4200D_FS_MASK); + + ddata->range = received_value; + + error = l3g4200d_write(ddata, CTRL_REG4, value, "CTRL_REG4"); + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + return count; +} + +static ssize_t l3g4200d_show_datarate(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->odr >> L3G4200D_ODR_BIT); +} + +static ssize_t l3g4200d_store_datarate(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + long received_value; + unsigned char value; + int error; + + error = strict_strtol(buf, 0, &received_value); + if (error) + return error; + + /* check if the received output datarate value is in valid range */ + if (received_value < L3G4200D_ODR_MIN_VAL || + received_value > L3G4200D_ODR_MAX_VAL) + return -EINVAL; + + mutex_lock(&ddata->lock); + + if (ddata->powermode == PM_OFF) { + dev_info(&ddata->client->dev, + "The device is switched off, turn it ON using powermode\n"); + mutex_unlock(&ddata->lock); + return count; + } + + /* + * read the current contents of CTRL_REG1 + * retain any bits set other than the odr bits + */ + error = l3g4200d_read(ddata, CTRL_REG1, "CTRL_REG1"); + + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } else + value = error; + + value &= ~L3G4200D_ODR_MASK; + value |= ((received_value << L3G4200D_ODR_BIT) & L3G4200D_ODR_MASK); + + ddata->odr = received_value << L3G4200D_ODR_BIT; + + error = l3g4200d_write(ddata, CTRL_REG1, value, "CTRL_REG1"); + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + return count; +} + +static ssize_t l3g4200d_show_powermode(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->powermode); +} + +static ssize_t l3g4200d_store_powermode(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + long received_value; + unsigned char value; + int error; + + error = strict_strtol(buf, 0, &received_value); + if (error) + return error; + + /* check if the received power mode is either 0 or 1 */ + if (received_value < PM_OFF || received_value > PM_ON) + return -EINVAL; + + mutex_lock(&ddata->lock); + + if (ddata->device_status == DEVICE_SUSPENDED && + received_value == PM_OFF) { + ddata->powermode = received_value; + mutex_unlock(&ddata->lock); + return count; + } + + /* if sent value is same as current value do nothing */ + if (ddata->powermode == received_value) { + mutex_unlock(&ddata->lock); + return count; + } + + /* turn on the power suppliy if it was turned off previously */ + if (ddata->regulator && ddata->powermode == PM_OFF + && (ddata->device_status == DEVICE_OFF + || ddata->device_status == DEVICE_SUSPENDED)) { + regulator_enable(ddata->regulator); + ddata->device_status = DEVICE_ON; + } + + /* + * read the current contents of CTRL_REG1 + * retain any bits set other than the power bit + */ + error = l3g4200d_read(ddata, CTRL_REG1, "CTRL_REG1"); + + if (error < 0) { + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + mutex_unlock(&ddata->lock); + return error; + } else + value = error; + + value &= ~L3G4200D_PM_MASK; + value |= ((received_value << L3G4200D_PM_BIT) & L3G4200D_PM_MASK); + + ddata->powermode = received_value; + + error = l3g4200d_write(ddata, CTRL_REG1, value, "CTRL_REG1"); + if (error < 0) { + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + mutex_unlock(&ddata->lock); + return error; + } + + if (received_value == PM_OFF) { + /* set the other configuration values to defaults */ + ddata->odr = ODR00 | BW00; + ddata->range = FS250; + + /* turn off the power supply */ + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + } + mutex_unlock(&ddata->lock); + return count; +} + +static ssize_t l3g4200d_show_gyrotemp(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct l3g4200d_data *ddata = platform_get_drvdata(pdev); + int ret; + + if (ddata->powermode == PM_OFF || + ddata->device_status == DEVICE_SUSPENDED) + return -EINVAL; + + ret = l3g4200d_read(ddata, OUT_TEMP, "OUT_TEMP"); + if (ret < 0) + return ret; + + return sprintf(buf, "%d\n", ret); +} + +static DEVICE_ATTR(gyrodata, S_IRUGO, l3g4200d_show_gyrodata, NULL); + +static DEVICE_ATTR(range, S_IRUGO | S_IWUSR, + l3g4200d_show_range, l3g4200d_store_range); + +static DEVICE_ATTR(datarate, S_IRUGO | S_IWUSR, + l3g4200d_show_datarate, l3g4200d_store_datarate); + +static DEVICE_ATTR(powermode, S_IRUGO | S_IWUSR, + l3g4200d_show_powermode, l3g4200d_store_powermode); + +static DEVICE_ATTR(gyrotemp, S_IRUGO, l3g4200d_show_gyrotemp, NULL); + +static struct attribute *l3g4200d_attributes[] = { + &dev_attr_gyrodata.attr, + &dev_attr_range.attr, + &dev_attr_datarate.attr, + &dev_attr_powermode.attr, + &dev_attr_gyrotemp.attr, + NULL +}; + +static const struct attribute_group l3g4200d_attr_group = { + .attrs = l3g4200d_attributes, +}; + +static int __devinit l3g4200d_probe(struct i2c_client *client, + const struct i2c_device_id *devid) +{ + int ret = -1; + struct l3g4200d_data *ddata = NULL; + + if (!i2c_check_functionality(client->adapter, + I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_READ_I2C_BLOCK)) + goto exit; + + ddata = kzalloc(sizeof(struct l3g4200d_data), GFP_KERNEL); + if (ddata == NULL) { + ret = -ENOMEM; + goto error_op_failed; + } + + ddata->client = client; + i2c_set_clientdata(client, ddata); + + memcpy(&ddata->pdata, client->dev.platform_data, sizeof(ddata->pdata)); + /* store default values in the data structure */ + ddata->odr = ODR00 | BW00; + ddata->range = FS250; + ddata->powermode = PM_OFF; + ddata->device_status = DEVICE_OFF; + + dev_set_name(&client->dev, ddata->pdata.name_gyr); + + ddata->regulator = regulator_get(&client->dev, "vdd"); + if (IS_ERR(ddata->regulator)) { + dev_err(&client->dev, "failed to get regulator\n"); + ret = PTR_ERR(ddata->regulator); + ddata->regulator = NULL; + } + + if (ddata->regulator) { + regulator_enable(ddata->regulator); + ddata->device_status = DEVICE_ON; + } + + ret = l3g4200d_read(ddata, WHO_AM_I, "WHO_AM_I"); + if (ret < 0) + goto exit_free_regulator; + + if (ret == WHOAMI_L3G4200D) + dev_info(&client->dev, "3-Axis Gyroscope device identification: %d\n", ret); + else + dev_info(&client->dev, "Gyroscope identification did not match\n"); + + mutex_init(&ddata->lock); + + ret = sysfs_create_group(&client->dev.kobj, &l3g4200d_attr_group); + if (ret) + goto exit_free_regulator; +#ifdef CONFIG_HAS_EARLYSUSPEND + ddata->early_suspend.level = + EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; + ddata->early_suspend.suspend = l3g4200d_early_suspend; + ddata->early_suspend.resume = l3g4200d_late_resume; + register_early_suspend(&ddata->early_suspend); +#endif + + /* + * turn off the supplies until somebody turns on the device + * using l3g4200d_store_powermode + */ + if (ddata->device_status == DEVICE_ON && ddata->regulator) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + + return ret; + +exit_free_regulator: + if (ddata->device_status == DEVICE_ON && ddata->regulator) { + regulator_disable(ddata->regulator); + regulator_put(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } +error_op_failed: + kfree(ddata); +exit: + dev_err(&client->dev, "probe function failed %x\n", ret); + return ret; +} + +static int __devexit l3g4200d_remove(struct i2c_client *client) +{ + struct l3g4200d_data *ddata; + ddata = i2c_get_clientdata(client); + sysfs_remove_group(&client->dev.kobj, &l3g4200d_attr_group); + + /* safer to turn off the device */ + if (ddata->powermode != PM_OFF) { + l3g4200d_write(ddata, CTRL_REG1, PM_OFF, "CONTROL"); + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + regulator_put(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + } + + i2c_set_clientdata(client, NULL); + kfree(ddata); + + return 0; +} +#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_PM) + +static int l3g4200d_do_suspend(struct l3g4200d_data *ddata) +{ + int ret; + + mutex_lock(&ddata->lock); + + if (ddata->powermode == PM_OFF) { + mutex_unlock(&ddata->lock); + return 0; + } + + ret = l3g4200d_write(ddata, CTRL_REG1, PM_OFF, "CONTROL"); + + /* turn off the power when suspending the device */ + if (ddata->regulator) + regulator_disable(ddata->regulator); + + ddata->device_status = DEVICE_SUSPENDED; + + mutex_unlock(&ddata->lock); + return ret; +} + +static int l3g4200d_do_resume(struct l3g4200d_data *ddata) +{ + unsigned char range_value; + unsigned char shifted_powermode = (ddata->powermode << L3G4200D_PM_BIT); + unsigned char shifted_odr = (ddata->odr << L3G4200D_ODR_BIT); + unsigned context = ((shifted_powermode | shifted_odr) | ENABLE_ALL_AXES); + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->device_status == DEVICE_ON) + goto fail; + + /* in correct mode, no need to change it */ + if (ddata->powermode == PM_OFF) { + ddata->device_status = DEVICE_OFF; + goto fail; + } else { + ddata->device_status = DEVICE_ON; + } + + /* turn on the power when resuming the device */ + if (ddata->regulator) + regulator_enable(ddata->regulator); + + ret = l3g4200d_write(ddata, CTRL_REG1, context, "CONTROL"); + if (ret < 0) + goto fail; + + range_value = ddata->range; + range_value <<= L3G4200D_FS_BIT; + range_value |= BDU_ENABLE; + + ret = l3g4200d_write(ddata, CTRL_REG4, range_value, "RANGE"); + +fail: + mutex_unlock(&ddata->lock); + return ret; +} +#endif + +#ifndef CONFIG_HAS_EARLYSUSPEND +#ifdef CONFIG_PM +static int l3g4200d_suspend(struct device *dev) +{ + struct l3g4200d_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = l3g4200d_do_suspend(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while suspending the device\n"); + + return ret; +} + +static int l3g4200d_resume(struct device *dev) +{ + struct l3g4200d_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = l3g4200d_do_resume(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while resuming the device\n"); + + return ret; +} + +static const struct dev_pm_ops l3g4200d_dev_pm_ops = { + .suspend = l3g4200d_suspend, + .resume = l3g4200d_resume, +}; +#endif +#else +static void l3g4200d_early_suspend(struct early_suspend *data) +{ + struct l3g4200d_data *ddata = + container_of(data, struct l3g4200d_data, early_suspend); + int ret; + + ret = l3g4200d_do_suspend(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while suspending the device\n"); +} + +static void l3g4200d_late_resume(struct early_suspend *data) +{ + struct l3g4200d_data *ddata = + container_of(data, struct l3g4200d_data, early_suspend); + int ret; + + ret = l3g4200d_do_resume(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while resuming the device\n"); +} +#endif + +static const struct i2c_device_id l3g4200d_id[] = { + {"l3g4200d", 0 }, + { }, +}; + +static struct i2c_driver l3g4200d_driver = { + .driver = { + .name = "l3g4200d", +#if (!defined(CONFIG_HAS_EARLYSUSPEND) && defined(CONFIG_PM)) + .pm = &l3g4200d_dev_pm_ops, +#endif + }, + .probe = l3g4200d_probe, + .remove = l3g4200d_remove, + .id_table = l3g4200d_id, +}; + +static int __init l3g4200d_init(void) +{ + return i2c_add_driver(&l3g4200d_driver); +} + +static void __exit l3g4200d_exit(void) +{ + i2c_del_driver(&l3g4200d_driver); +} + +module_init(l3g4200d_init); +module_exit(l3g4200d_exit); + +MODULE_DESCRIPTION("l3g4200d digital gyroscope driver"); +MODULE_AUTHOR("Chethan Krishna N"); +MODULE_LICENSE("GPL"); diff --git a/drivers/hwmon/lsm303dlh_a.c b/drivers/hwmon/lsm303dlh_a.c new file mode 100644 index 00000000000..a6e724facc3 --- /dev/null +++ b/drivers/hwmon/lsm303dlh_a.c @@ -0,0 +1,1371 @@ +/* + * lsm303dlh_a.c + * ST 3-Axis Accelerometer Driver + * + * Copyright (C) 2010 STMicroelectronics + * Author: Carmine Iascone (carmine.iascone@st.com) + * Author: Matteo Dameno (matteo.dameno@st.com) + * + * Copyright (C) 2010 STEricsson + * Author: Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com> + * Updated:Preetham Rao Kaskurthi <preetham.rao@stericsson.com> + * + * 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. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <linux/module.h> +#include <linux/i2c.h> +#include <linux/slab.h> +#include <linux/mutex.h> +#include <linux/platform_device.h> +#include <linux/delay.h> +#include <linux/err.h> + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE +#include <linux/input.h> +#include <linux/interrupt.h> +#include <mach/gpio.h> +#endif + +#include <linux/lsm303dlh.h> +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif +#include <linux/regulator/consumer.h> + + /* lsm303dlh accelerometer registers */ + #define WHO_AM_I 0x0F + + /* ctrl 1: pm2 pm1 pm0 dr1 dr0 zenable yenable zenable */ + #define CTRL_REG1 0x20 /* power control reg */ + #define CTRL_REG2 0x21 /* power control reg */ + #define CTRL_REG3 0x22 /* power control reg */ + #define CTRL_REG4 0x23 /* interrupt control reg */ + #define CTRL_REG5 0x24 /* interrupt control reg */ + + #define STATUS_REG 0x27 /* status register */ + + #define AXISDATA_REG 0x28 /* axis data */ + + #define INT1_CFG 0x30 /* interrupt 1 configuration */ + #define INT1_SRC 0x31 /* interrupt 1 source reg */ + #define INT1_THS 0x32 /* interrupt 1 threshold */ + #define INT1_DURATION 0x33 /* interrupt 1 threshold */ + + #define INT2_CFG 0x34 /* interrupt 2 configuration */ + #define INT2_SRC 0x35 /* interrupt 2 source reg */ + #define INT2_THS 0x36 /* interrupt 2 threshold */ + #define INT2_DURATION 0x37 /* interrupt 2 threshold */ + + /* Sensitivity adjustment */ + #define SHIFT_ADJ_2G 4 /* 1/16*/ + #define SHIFT_ADJ_4G 3 /* 2/16*/ + #define SHIFT_ADJ_8G 2 /* ~3.9/16*/ + + /* Control register 1 */ + #define LSM303DLH_A_CR1_PM_BIT 5 + #define LSM303DLH_A_CR1_PM_MASK (0x7 << LSM303DLH_A_CR1_PM_BIT) + #define LSM303DLH_A_CR1_DR_BIT 3 + #define LSM303DLH_A_CR1_DR_MASK (0x3 << LSM303DLH_A_CR1_DR_BIT) + #define LSM303DLH_A_CR1_EN_BIT 0 + #define LSM303DLH_A_CR1_EN_MASK (0x7 << LSM303DLH_A_CR1_EN_BIT) + #define LSM303DLH_A_CR1_AXIS_ENABLE 7 + + /* Control register 2 */ + #define LSM303DLH_A_CR4_ST_BIT 1 + #define LSM303DLH_A_CR4_ST_MASK (0x1 << LSM303DLH_A_CR4_ST_BIT) + #define LSM303DLH_A_CR4_STS_BIT 3 + #define LSM303DLH_A_CR4_STS_MASK (0x1 << LSM303DLH_A_CR4_STS_BIT) + #define LSM303DLH_A_CR4_FS_BIT 4 + #define LSM303DLH_A_CR4_FS_MASK (0x3 << LSM303DLH_A_CR4_FS_BIT) + #define LSM303DLH_A_CR4_BLE_BIT 6 + #define LSM303DLH_A_CR4_BLE_MASK (0x3 << LSM303DLH_A_CR4_BLE_BIT) + #define LSM303DLH_A_CR4_BDU_BIT 7 + #define LSM303DLH_A_CR4_BDU_MASK (0x1 << LSM303DLH_A_CR4_BDU_BIT) + + /* Control register 3 */ + #define LSM303DLH_A_CR3_I1_BIT 0 + #define LSM303DLH_A_CR3_I1_MASK (0x3 << LSM303DLH_A_CR3_I1_BIT) + #define LSM303DLH_A_CR3_LIR1_BIT 2 + #define LSM303DLH_A_CR3_LIR1_MASK (0x1 << LSM303DLH_A_CR3_LIR1_BIT) + #define LSM303DLH_A_CR3_I2_BIT 3 + #define LSM303DLH_A_CR3_I2_MASK (0x3 << LSM303DLH_A_CR3_I2_BIT) + #define LSM303DLH_A_CR3_LIR2_BIT 5 + #define LSM303DLH_A_CR3_LIR2_MASK (0x1 << LSM303DLH_A_CR3_LIR2_BIT) + #define LSM303DLH_A_CR3_PPOD_BIT 6 + #define LSM303DLH_A_CR3_PPOD_MASK (0x1 << LSM303DLH_A_CR3_PPOD_BIT) + #define LSM303DLH_A_CR3_IHL_BIT 7 + #define LSM303DLH_A_CR3_IHL_MASK (0x1 << LSM303DLH_A_CR3_IHL_BIT) + + #define LSM303DLH_A_CR3_I_SELF 0x0 + #define LSM303DLH_A_CR3_I_OR 0x1 + #define LSM303DLH_A_CR3_I_DATA 0x2 + #define LSM303DLH_A_CR3_I_BOOT 0x3 + + #define LSM303DLH_A_CR3_LIR_LATCH 0x1 + + /* Range */ + #define LSM303DLH_A_RANGE_2G 0x00 + #define LSM303DLH_A_RANGE_4G 0x01 + #define LSM303DLH_A_RANGE_8G 0x03 + + /* Mode */ + #define LSM303DLH_A_MODE_OFF 0x00 + #define LSM303DLH_A_MODE_NORMAL 0x01 + #define LSM303DLH_A_MODE_LP_HALF 0x02 + #define LSM303DLH_A_MODE_LP_1 0x03 + #define LSM303DLH_A_MODE_LP_2 0x02 + #define LSM303DLH_A_MODE_LP_5 0x05 + #define LSM303DLH_A_MODE_LP_10 0x06 + + /* Rate */ + #define LSM303DLH_A_RATE_50 0x00 + #define LSM303DLH_A_RATE_100 0x01 + #define LSM303DLH_A_RATE_400 0x02 + #define LSM303DLH_A_RATE_1000 0x03 + + /* Sleep & Wake */ + #define LSM303DLH_A_SLEEPWAKE_DISABLE 0x00 + #define LSM303DLH_A_SLEEPWAKE_ENABLE 0x3 + +/* Multiple byte transfer enable */ +#define MULTIPLE_I2C_TR 0x80 + +/* device status defines */ +#define DEVICE_OFF 0 +#define DEVICE_ON 1 +#define DEVICE_SUSPENDED 2 + +/* Range -2048 to 2047 */ +struct lsm303dlh_a_t { + short x; + short y; + short z; +}; + +/** + * struct lsm303dlh_a_data - data structure used by lsm303dlh_a driver + * @client: i2c client + * @lock: mutex lock for sysfs operations + * @data: lsm303dlh_a_t struct containing x, y and z values + * @input_dev: input device + * @input_dev2: input device + * @pdata: lsm303dlh platform data + * @regulator: regulator + * @range: current range value of accelerometer + * @mode: current mode of operation + * @rate: current sampling rate + * @sleep_wake: sleep wake setting + * @shift_adjust: current shift adjust value set according to range + * @interrupt_control: interrupt control settings + * @interrupt_channel: interrupt channel 0 or 1 + * @interrupt_configure: interrupt configurations for two channels + * @interrupt_duration: interrupt duration for two channels + * @interrupt_threshold: interrupt threshold for two channels + * @early_suspend: early suspend structure + * @device_status: device is ON, OFF or SUSPENDED + * @id: accelerometer device id + */ +struct lsm303dlh_a_data { + struct i2c_client *client; + /* lock for sysfs operations */ + struct mutex lock; + struct lsm303dlh_a_t data; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + struct input_dev *input_dev; + struct input_dev *input_dev2; +#endif + + struct lsm303dlh_platform_data pdata; + struct regulator *regulator; + + unsigned char range; + unsigned char mode; + unsigned char rate; + unsigned char sleep_wake; + int shift_adjust; + + unsigned char interrupt_control; + unsigned int interrupt_channel; + + unsigned char interrupt_configure[2]; + unsigned char interrupt_duration[2]; + unsigned char interrupt_threshold[2]; +#ifdef CONFIG_HAS_EARLYSUSPEND + struct early_suspend early_suspend; +#endif + int device_status; + int id; +}; + +#ifdef CONFIG_HAS_EARLYSUSPEND +static void lsm303dlh_a_early_suspend(struct early_suspend *data); +static void lsm303dlh_a_late_resume(struct early_suspend *data); +#endif + +static int lsm303dlh_a_write(struct lsm303dlh_a_data *ddata, u8 reg, + u8 val, char *msg) +{ + int ret = i2c_smbus_write_byte_data(ddata->client, reg, val); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_write_byte_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +static int lsm303dlh_a_read(struct lsm303dlh_a_data *ddata, u8 reg, char *msg) +{ + int ret = i2c_smbus_read_byte_data(ddata->client, reg); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_read_byte_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_PM) +static int lsm303dlh_a_do_suspend(struct lsm303dlh_a_data *ddata) +{ + int ret; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_A_MODE_OFF) { + mutex_unlock(&ddata->lock); + return 0; + } + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + disable_irq(gpio_to_irq(ddata->pdata.irq_a1)); + disable_irq(gpio_to_irq(ddata->pdata.irq_a2)); +#endif + + ret = lsm303dlh_a_write(ddata, CTRL_REG1, + LSM303DLH_A_MODE_OFF, "CONTROL"); + + if (ddata->regulator) + regulator_disable(ddata->regulator); + + ddata->device_status = DEVICE_SUSPENDED; + + mutex_unlock(&ddata->lock); + + return ret; +} + +static int lsm303dlh_a_restore(struct lsm303dlh_a_data *ddata) +{ + unsigned char reg; + unsigned char shifted_mode = (ddata->mode << LSM303DLH_A_CR1_PM_BIT); + unsigned char shifted_rate = (ddata->rate << LSM303DLH_A_CR1_DR_BIT); + unsigned char context = (shifted_mode | shifted_rate); + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->device_status == DEVICE_ON) { + mutex_unlock(&ddata->lock); + return 0; + } + + /* in correct mode, no need to change it */ + if (ddata->mode == LSM303DLH_A_MODE_OFF) { + ddata->device_status = DEVICE_OFF; + mutex_unlock(&ddata->lock); + return 0; + } else + ddata->device_status = DEVICE_ON; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + enable_irq(gpio_to_irq(ddata->pdata.irq_a1)); + enable_irq(gpio_to_irq(ddata->pdata.irq_a2)); +#endif + + if (ddata->regulator) + regulator_enable(ddata->regulator); + + /* BDU should be enabled by default/recommened */ + reg = ddata->range; + reg |= LSM303DLH_A_CR4_BDU_MASK; + context |= LSM303DLH_A_CR1_AXIS_ENABLE; + + ret = lsm303dlh_a_write(ddata, CTRL_REG1, context, + "CTRL_REG1"); + if (ret < 0) + goto fail; + + ret = lsm303dlh_a_write(ddata, CTRL_REG4, reg, "CTRL_REG4"); + + if (ret < 0) + goto fail; + + /* write to the boot bit to reboot memory content */ + ret = lsm303dlh_a_write(ddata, CTRL_REG2, 0x80, "CTRL_REG2"); + + if (ret < 0) + goto fail; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + ret = lsm303dlh_a_write(ddata, CTRL_REG3, ddata->interrupt_control, + "CTRL_REG3"); + + if (ret < 0) + goto fail; + + ret = lsm303dlh_a_write(ddata, INT1_CFG, ddata->interrupt_configure[0], + "INT1_CFG"); + + if (ret < 0) + goto fail; + + ret = lsm303dlh_a_write(ddata, INT2_CFG, ddata->interrupt_configure[1], + "INT2_CFG"); + + if (ret < 0) + goto fail; + + ret = lsm303dlh_a_write(ddata, INT1_THS, ddata->interrupt_threshold[0], + "INT1_THS"); + + if (ret < 0) + goto fail; + + ret = lsm303dlh_a_write(ddata, INT2_THS, ddata->interrupt_threshold[1], + "INT2_THS"); + + if (ret < 0) + goto fail; + + ret = lsm303dlh_a_write(ddata, INT1_DURATION, + ddata->interrupt_duration[0], "INT1_DURATION"); + + if (ret < 0) + goto fail; + + ret = lsm303dlh_a_write(ddata, INT1_DURATION, + ddata->interrupt_duration[1], "INT1_DURATION"); + + if (ret < 0) + goto fail; +#endif + +fail: + if (ret < 0) + dev_err(&ddata->client->dev, "could not restore the device %d\n", ret); + mutex_unlock(&ddata->lock); + return ret; +} +#endif + +static int lsm303dlh_a_readdata(struct lsm303dlh_a_data *ddata) +{ + unsigned char acc_data[6]; + short data[3]; + + int ret = i2c_smbus_read_i2c_block_data(ddata->client, + AXISDATA_REG | MULTIPLE_I2C_TR, 6, acc_data); + if (ret < 0) { + dev_err(&ddata->client->dev, + "i2c_smbus_read_byte_data failed error %d\ + Register AXISDATA_REG \n", ret); + return ret; + } + + data[0] = (short) (((acc_data[1]) << 8) | acc_data[0]); + data[1] = (short) (((acc_data[3]) << 8) | acc_data[2]); + data[2] = (short) (((acc_data[5]) << 8) | acc_data[4]); + + data[0] >>= ddata->shift_adjust; + data[1] >>= ddata->shift_adjust; + data[2] >>= ddata->shift_adjust; + + /* taking position and orientation of x,y,z axis into account*/ + + data[ddata->pdata.axis_map_x] = ddata->pdata.negative_x ? + -data[ddata->pdata.axis_map_x] : data[ddata->pdata.axis_map_x]; + data[ddata->pdata.axis_map_y] = ddata->pdata.negative_y ? + -data[ddata->pdata.axis_map_y] : data[ddata->pdata.axis_map_y]; + data[ddata->pdata.axis_map_z] = ddata->pdata.negative_z ? + -data[ddata->pdata.axis_map_z] : data[ddata->pdata.axis_map_z]; + + ddata->data.x = data[ddata->pdata.axis_map_x]; + ddata->data.y = data[ddata->pdata.axis_map_y]; + ddata->data.z = data[ddata->pdata.axis_map_z]; + + return ret; +} + +static ssize_t lsm303dlh_a_show_data(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_A_MODE_OFF || + ddata->device_status == DEVICE_SUSPENDED) { + mutex_unlock(&ddata->lock); + return ret; + } + + ret = lsm303dlh_a_readdata(ddata); + + if (ret < 0) { + mutex_unlock(&ddata->lock); + return ret; + } + + mutex_unlock(&ddata->lock); + + return sprintf(buf, "%8x:%8x:%8x\n", ddata->data.x, ddata->data.y, + ddata->data.z); +} + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE +static irqreturn_t lsm303dlh_a_gpio_irq(int irq, void *device_data) +{ + + struct lsm303dlh_a_data *ddata = device_data; + int ret; + unsigned char reg; + struct input_dev *input; + + /* know your interrupt source */ + if (irq == gpio_to_irq(ddata->pdata.irq_a1)) { + reg = INT1_SRC; + input = ddata->input_dev; + } else if (irq == gpio_to_irq(ddata->pdata.irq_a2)) { + reg = INT2_SRC; + input = ddata->input_dev2; + } else { + dev_err(&ddata->client->dev, "spurious interrupt"); + return IRQ_HANDLED; + } + + /* read the axis */ + ret = lsm303dlh_a_readdata(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "reading data of xyz failed error %d\n", ret); + + input_report_abs(input, ABS_X, ddata->data.x); + input_report_abs(input, ABS_Y, ddata->data.y); + input_report_abs(input, ABS_Z, ddata->data.z); + input_sync(input); + + /* clear the value by reading it */ + ret = lsm303dlh_a_read(ddata, reg, "INTTERUPT SOURCE"); + if (ret < 0) + dev_err(&ddata->client->dev, + "clearing interrupt source failed error %d\n", ret); + + return IRQ_HANDLED; + +} + +static ssize_t lsm303dlh_a_show_interrupt_control(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->interrupt_control); +} + +static ssize_t lsm303dlh_a_store_interrupt_control(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + unsigned long val; + int error; + + error = strict_strtoul(buf, 0, &val); + if (error) + return error; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_A_MODE_OFF) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + mutex_unlock(&ddata->lock); + return count; + } + + ddata->interrupt_control = val; + + error = lsm303dlh_a_write(ddata, CTRL_REG3, val, "CTRL_REG3"); + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + + return count; +} + +static ssize_t lsm303dlh_a_show_interrupt_channel(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->interrupt_channel); +} + +static ssize_t lsm303dlh_a_store_interrupt_channel(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + unsigned long val; + int error; + + error = strict_strtoul(buf, 0, &val); + if (error) + return error; + + ddata->interrupt_channel = val; + + return count; +} + +static ssize_t lsm303dlh_a_show_interrupt_configure(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", + ddata->interrupt_configure[ddata->interrupt_channel]); +} + +static ssize_t lsm303dlh_a_store_interrupt_configure(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + unsigned long val; + int error; + + error = strict_strtoul(buf, 0, &val); + if (error) + return error; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_A_MODE_OFF) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + mutex_unlock(&ddata->lock); + return count; + } + + ddata->interrupt_configure[ddata->interrupt_channel] = val; + + if (ddata->interrupt_channel == 0x0) + error = lsm303dlh_a_write(ddata, INT1_CFG, val, "INT1_CFG"); + else + error = lsm303dlh_a_write(ddata, INT2_CFG, val, "INT2_CFG"); + + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + + return count; +} + +static ssize_t lsm303dlh_a_show_interrupt_duration(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", + ddata->interrupt_duration[ddata->interrupt_channel]); +} + +static ssize_t lsm303dlh_a_store_interrupt_duration(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + unsigned long val; + int error; + + error = strict_strtoul(buf, 0, &val); + if (error) + return error; + + mutex_lock(&ddata->lock); + + + if (ddata->mode == LSM303DLH_A_MODE_OFF) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + mutex_unlock(&ddata->lock); + return count; + } + + ddata->interrupt_duration[ddata->interrupt_channel] = val; + + if (ddata->interrupt_channel == 0x0) + error = lsm303dlh_a_write(ddata, INT1_DURATION, val, + "INT1_DURATION"); + else + error = lsm303dlh_a_write(ddata, INT2_DURATION, val, + "INT2_DURATION"); + + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + + return count; +} + +static ssize_t lsm303dlh_a_show_interrupt_threshold(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", + ddata->interrupt_threshold[ddata->interrupt_channel]); +} + +static ssize_t lsm303dlh_a_store_interrupt_threshold(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + unsigned long val; + int error; + + error = strict_strtoul(buf, 0, &val); + if (error) + return error; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_A_MODE_OFF) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + mutex_unlock(&ddata->lock); + return count; + } + + ddata->interrupt_threshold[ddata->interrupt_channel] = val; + + if (ddata->interrupt_channel == 0x0) + error = lsm303dlh_a_write(ddata, INT1_THS, val, "INT1_THS"); + else + error = lsm303dlh_a_write(ddata, INT2_THS, val, "INT2_THS"); + + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + + return count; +} +#endif + +static ssize_t lsm303dlh_a_show_range(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->range >> LSM303DLH_A_CR4_FS_BIT); +} + +static ssize_t lsm303dlh_a_store_range(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + long val; + unsigned long bdu_enabled_val; + int error; + + + error = strict_strtol(buf, 0, &val); + if (error) + return error; + + if (val < LSM303DLH_A_RANGE_2G || val > LSM303DLH_A_RANGE_8G) + return -EINVAL; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_A_MODE_OFF) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + mutex_unlock(&ddata->lock); + return count; + } + + ddata->range = val; + ddata->range <<= LSM303DLH_A_CR4_FS_BIT; + + /* + * Block mode update is recommended for not + * ending up reading different values + */ + bdu_enabled_val = ddata->range; + bdu_enabled_val |= LSM303DLH_A_CR4_BDU_MASK; + + error = lsm303dlh_a_write(ddata, CTRL_REG4, bdu_enabled_val, + "CTRL_REG4"); + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + switch (val) { + case LSM303DLH_A_RANGE_2G: + ddata->shift_adjust = SHIFT_ADJ_2G; + break; + case LSM303DLH_A_RANGE_4G: + ddata->shift_adjust = SHIFT_ADJ_4G; + break; + case LSM303DLH_A_RANGE_8G: + ddata->shift_adjust = SHIFT_ADJ_8G; + break; + default: + mutex_unlock(&ddata->lock); + return -EINVAL; + } + + mutex_unlock(&ddata->lock); + + return count; +} + +static ssize_t lsm303dlh_a_show_mode(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->mode); +} + +static ssize_t lsm303dlh_a_store_mode(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + long val; + unsigned char data; + int error; + bool set_boot_bit = false; + + error = strict_strtol(buf, 0, &val); + if (error) + return error; + + mutex_lock(&ddata->lock); + + /* not in correct range */ + + if (val < LSM303DLH_A_MODE_OFF || val > LSM303DLH_A_MODE_LP_10) { + mutex_unlock(&ddata->lock); + return -EINVAL; + } + + if (ddata->device_status == DEVICE_SUSPENDED) { + if (val == LSM303DLH_A_MODE_OFF) { + ddata->mode = val; + mutex_unlock(&ddata->lock); + return count; + } else { + /* device is turning on after suspend, reset memory */ + set_boot_bit = true; + } + } + + /* if same mode as existing, return */ + if (ddata->mode == val) { + mutex_unlock(&ddata->lock); + return count; + } + + /* turn on the supplies if already off */ + if (ddata->regulator && ddata->mode == LSM303DLH_A_MODE_OFF + && (ddata->device_status == DEVICE_OFF + || ddata->device_status == DEVICE_SUSPENDED)) { + regulator_enable(ddata->regulator); + ddata->device_status = DEVICE_ON; +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + enable_irq(gpio_to_irq(ddata->pdata.irq_a1)); + enable_irq(gpio_to_irq(ddata->pdata.irq_a2)); +#endif + } + + data = lsm303dlh_a_read(ddata, CTRL_REG1, "CTRL_REG1"); + + /* + * If chip doesn't get reset during suspend/resume, + * x,y and z axis bits are getting cleared,so set + * these bits to get x,y,z axis data. + */ + data |= LSM303DLH_A_CR1_AXIS_ENABLE; + data &= ~LSM303DLH_A_CR1_PM_MASK; + + ddata->mode = val; + data |= ((val << LSM303DLH_A_CR1_PM_BIT) & LSM303DLH_A_CR1_PM_MASK); + + error = lsm303dlh_a_write(ddata, CTRL_REG1, data, "CTRL_REG1"); + if (error < 0) { + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + mutex_unlock(&ddata->lock); + return error; + } + + /* + * Power on request when device is in suspended state + * write to the boot bit in CTRL_REG2 to reboot memory content + * and ensure correct device behavior after it resumes + */ + if (set_boot_bit) { + error = lsm303dlh_a_write(ddata, CTRL_REG2, 0x80, "CTRL_REG2"); + if (error < 0) { + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + mutex_unlock(&ddata->lock); + return error; + } + } + + if (val == LSM303DLH_A_MODE_OFF) { +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + disable_irq(gpio_to_irq(ddata->pdata.irq_a1)); + disable_irq(gpio_to_irq(ddata->pdata.irq_a2)); +#endif + /* + * No need to store context here + * it is not like suspend/resume + * but fall back to default values + */ + ddata->rate = LSM303DLH_A_RATE_50; + ddata->range = LSM303DLH_A_RANGE_2G; + ddata->shift_adjust = SHIFT_ADJ_2G; + + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + } + mutex_unlock(&ddata->lock); + + return count; +} + +static ssize_t lsm303dlh_a_show_rate(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->rate); +} + +static ssize_t lsm303dlh_a_store_rate(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + long val; + unsigned char data; + int error; + + error = strict_strtol(buf, 0, &val); + if (error) + return error; + + if (val < LSM303DLH_A_RATE_50 || val > LSM303DLH_A_RATE_1000) + return -EINVAL; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_A_MODE_OFF) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + mutex_unlock(&ddata->lock); + return count; + } + + data = lsm303dlh_a_read(ddata, CTRL_REG1, "CTRL_REG1"); + + data &= ~LSM303DLH_A_CR1_DR_MASK; + + ddata->rate = val; + + data |= ((val << LSM303DLH_A_CR1_DR_BIT) & LSM303DLH_A_CR1_DR_MASK); + + error = lsm303dlh_a_write(ddata, CTRL_REG1, data, "CTRL_REG1"); + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + + return count; +} + +static ssize_t lsm303dlh_a_show_sleepwake(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->sleep_wake); +} + +static ssize_t lsm303dlh_a_store_sleepwake(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + long val; + int error; + + if (ddata->mode == LSM303DLH_A_MODE_OFF) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + return count; + } + + error = strict_strtoul(buf, 0, &val); + if (error) + return error; + + mutex_lock(&ddata->lock); + + ddata->sleep_wake = val; + + error = lsm303dlh_a_write(ddata, CTRL_REG5, ddata->sleep_wake, + "CTRL_REG5"); + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + + return count; +} + +static ssize_t lsm303dlh_a_show_id(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->id); +} + +static DEVICE_ATTR(id, S_IRUGO, lsm303dlh_a_show_id, NULL); + +static DEVICE_ATTR(data, S_IRUGO, lsm303dlh_a_show_data, NULL); + +static DEVICE_ATTR(range, S_IWUSR | S_IRUGO, + lsm303dlh_a_show_range, lsm303dlh_a_store_range); + +static DEVICE_ATTR(mode, S_IWUSR | S_IRUGO, + lsm303dlh_a_show_mode, lsm303dlh_a_store_mode); + +static DEVICE_ATTR(rate, S_IWUSR | S_IRUGO, + lsm303dlh_a_show_rate, lsm303dlh_a_store_rate); + +static DEVICE_ATTR(sleep_wake, S_IWUSR | S_IRUGO, + lsm303dlh_a_show_sleepwake, lsm303dlh_a_store_sleepwake); + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE +static DEVICE_ATTR(interrupt_control, S_IWUGO | S_IRUGO, + lsm303dlh_a_show_interrupt_control, + lsm303dlh_a_store_interrupt_control); + +static DEVICE_ATTR(interrupt_channel, S_IWUGO | S_IRUGO, + lsm303dlh_a_show_interrupt_channel, + lsm303dlh_a_store_interrupt_channel); + +static DEVICE_ATTR(interrupt_configure, S_IWUGO | S_IRUGO, + lsm303dlh_a_show_interrupt_configure, + lsm303dlh_a_store_interrupt_configure); + +static DEVICE_ATTR(interrupt_duration, S_IWUGO | S_IRUGO, + lsm303dlh_a_show_interrupt_duration, + lsm303dlh_a_store_interrupt_duration); + +static DEVICE_ATTR(interrupt_threshold, S_IWUGO | S_IRUGO, + lsm303dlh_a_show_interrupt_threshold, + lsm303dlh_a_store_interrupt_threshold); +#endif + +static struct attribute *lsm303dlh_a_attributes[] = { + &dev_attr_id.attr, + &dev_attr_data.attr, + &dev_attr_range.attr, + &dev_attr_mode.attr, + &dev_attr_rate.attr, + &dev_attr_sleep_wake.attr, +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + &dev_attr_interrupt_control.attr, + &dev_attr_interrupt_channel.attr, + &dev_attr_interrupt_configure.attr, + &dev_attr_interrupt_duration.attr, + &dev_attr_interrupt_threshold.attr, +#endif + NULL +}; + +static const struct attribute_group lsm303dlh_a_attr_group = { + .attrs = lsm303dlh_a_attributes, +}; + +static int __devinit lsm303dlh_a_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + int ret; + struct lsm303dlh_a_data *ddata = NULL; + + ddata = kzalloc(sizeof(struct lsm303dlh_a_data), GFP_KERNEL); + if (ddata == NULL) { + ret = -ENOMEM; + goto err_op_failed; + } + + ddata->client = client; + i2c_set_clientdata(client, ddata); + + /* copy platform specific data */ + memcpy(&ddata->pdata, client->dev.platform_data, sizeof(ddata->pdata)); + ddata->mode = LSM303DLH_A_MODE_OFF; + ddata->rate = LSM303DLH_A_RATE_50; + ddata->range = LSM303DLH_A_RANGE_2G; + ddata->sleep_wake = LSM303DLH_A_SLEEPWAKE_DISABLE; + ddata->shift_adjust = SHIFT_ADJ_2G; + ddata->device_status = DEVICE_OFF; + dev_set_name(&client->dev, ddata->pdata.name_a); + + ddata->regulator = regulator_get(&client->dev, "vdd"); + if (IS_ERR(ddata->regulator)) { + dev_err(&client->dev, "failed to get regulator\n"); + ret = PTR_ERR(ddata->regulator); + ddata->regulator = NULL; + } + + if (ddata->regulator) { + /* + * 0.83 milliamps typical with magnetic sensor setting ODR = + * 7.5 Hz, Accelerometer sensor ODR = 50 Hz. Double for + * safety. + */ + regulator_set_optimum_mode(ddata->regulator, 830 * 2); + regulator_enable(ddata->regulator); + ddata->device_status = DEVICE_ON; + } + + ret = lsm303dlh_a_read(ddata, WHO_AM_I, "WHO_AM_I"); + if (ret < 0) + goto exit_free_regulator; + + dev_info(&client->dev, "3-Axis Accelerometer, ID : %d\n", + ret); + ddata->id = ret; + + mutex_init(&ddata->lock); + + ret = sysfs_create_group(&client->dev.kobj, &lsm303dlh_a_attr_group); + if (ret) + goto exit_free_regulator; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + + /* accelerometer has two interrupts channels + (thresholds,durations and sources) + and can support two input devices */ + + ddata->input_dev = input_allocate_device(); + if (!ddata->input_dev) { + ret = -ENOMEM; + dev_err(&client->dev, "Failed to allocate input device\n"); + goto exit_free_regulator; + } + + ddata->input_dev2 = input_allocate_device(); + if (!ddata->input_dev2) { + ret = -ENOMEM; + dev_err(&client->dev, "Failed to allocate input device\n"); + goto err_input_alloc_failed; + } + + set_bit(EV_ABS, ddata->input_dev->evbit); + set_bit(EV_ABS, ddata->input_dev2->evbit); + + /* x-axis acceleration */ + input_set_abs_params(ddata->input_dev, ABS_X, -32768, 32767, 0, 0); + input_set_abs_params(ddata->input_dev2, ABS_X, -32768, 32767, 0, 0); + /* y-axis acceleration */ + input_set_abs_params(ddata->input_dev, ABS_Y, -32768, 32767, 0, 0); + input_set_abs_params(ddata->input_dev2, ABS_Y, -32768, 32767, 0, 0); + /* z-axis acceleration */ + input_set_abs_params(ddata->input_dev, ABS_Z, -32768, 32767, 0, 0); + input_set_abs_params(ddata->input_dev2, ABS_Z, -32768, 32767, 0, 0); + + ddata->input_dev->name = "accelerometer"; + ddata->input_dev2->name = "motion"; + + ret = input_register_device(ddata->input_dev); + if (ret) { + dev_err(&client->dev, "Unable to register input device: %s\n", + ddata->input_dev->name); + goto err_input_register_failed; + } + + ret = input_register_device(ddata->input_dev2); + if (ret) { + dev_err(&client->dev, "Unable to register input device: %s\n", + ddata->input_dev->name); + goto err_input_register_failed2; + } + + /* Register interrupt */ + ret = request_threaded_irq(gpio_to_irq(ddata->pdata.irq_a1), NULL, + lsm303dlh_a_gpio_irq, + IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, + "lsm303dlh_a", ddata); + if (ret) { + dev_err(&client->dev, "request irq1 failed\n"); + goto err_input_failed; + } + + ret = request_threaded_irq(gpio_to_irq(ddata->pdata.irq_a2), NULL, + lsm303dlh_a_gpio_irq, + IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, + "lsm303dlh_a", ddata); + if (ret) { + dev_err(&client->dev, "request irq2 failed\n"); + goto err_input_failed; + } + + /* only mode can enable it */ + disable_irq(gpio_to_irq(ddata->pdata.irq_a1)); + disable_irq(gpio_to_irq(ddata->pdata.irq_a2)); + +#endif + +#ifdef CONFIG_HAS_EARLYSUSPEND + ddata->early_suspend.level = + EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; + ddata->early_suspend.suspend = lsm303dlh_a_early_suspend; + ddata->early_suspend.resume = lsm303dlh_a_late_resume; + register_early_suspend(&ddata->early_suspend); +#endif + + if (ddata->device_status == DEVICE_ON && ddata->regulator) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + return ret; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE +err_input_failed: + input_unregister_device(ddata->input_dev2); +err_input_register_failed2: + input_unregister_device(ddata->input_dev); +err_input_register_failed: + input_free_device(ddata->input_dev2); +err_input_alloc_failed: + input_free_device(ddata->input_dev); +#endif +exit_free_regulator: + if (ddata->device_status == DEVICE_ON && ddata->regulator) { + regulator_disable(ddata->regulator); + regulator_put(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } +err_op_failed: + kfree(ddata); + dev_err(&client->dev, "probe function fails %x", ret); + return ret; +} + +static int __devexit lsm303dlh_a_remove(struct i2c_client *client) +{ + int ret; + struct lsm303dlh_a_data *ddata; + + ddata = i2c_get_clientdata(client); +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + input_unregister_device(ddata->input_dev); + input_unregister_device(ddata->input_dev2); + input_free_device(ddata->input_dev); + input_free_device(ddata->input_dev2); +#endif + sysfs_remove_group(&client->dev.kobj, &lsm303dlh_a_attr_group); + + /* safer to make device off */ + if (ddata->mode != LSM303DLH_A_MODE_OFF) { + ret = lsm303dlh_a_write(ddata, CTRL_REG1, 0, "CONTROL"); + + if (ret < 0) { + dev_err(&client->dev, "could not turn off the device %d", ret); + return ret; + } + + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + regulator_put(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + } + + i2c_set_clientdata(client, NULL); + kfree(ddata); + + return 0; +} + +#ifndef CONFIG_HAS_EARLYSUSPEND +#ifdef CONFIG_PM +static int lsm303dlh_a_suspend(struct device *dev) +{ + struct lsm303dlh_a_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = lsm303dlh_a_do_suspend(ddata); + + return ret; +} + +static int lsm303dlh_a_resume(struct device *dev) +{ + struct lsm303dlh_a_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = lsm303dlh_a_restore(ddata); + + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while resuming the device"); + + return ret; +} +static const struct dev_pm_ops lsm303dlh_a_dev_pm_ops = { + .suspend = lsm303dlh_a_suspend, + .resume = lsm303dlh_a_resume, +}; +#endif +#else +static void lsm303dlh_a_early_suspend(struct early_suspend *data) +{ + struct lsm303dlh_a_data *ddata = + container_of(data, struct lsm303dlh_a_data, early_suspend); + int ret; + + ret = lsm303dlh_a_do_suspend(ddata); +} + +static void lsm303dlh_a_late_resume(struct early_suspend *data) +{ + struct lsm303dlh_a_data *ddata = + container_of(data, struct lsm303dlh_a_data, early_suspend); + int ret; + + ret = lsm303dlh_a_restore(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "lsm303dlh_a late resume failed\n"); +} +#endif /* CONFIG_PM */ + +static const struct i2c_device_id lsm303dlh_a_id[] = { + { "lsm303dlh_a", 0 }, + { }, +}; + +static struct i2c_driver lsm303dlh_a_driver = { + .probe = lsm303dlh_a_probe, + .remove = lsm303dlh_a_remove, + .id_table = lsm303dlh_a_id, + .driver = { + .name = "lsm303dlh_a", +#if (!defined(CONFIG_HAS_EARLYSUSPEND) && defined(CONFIG_PM)) + .pm = &lsm303dlh_a_dev_pm_ops, +#endif + }, +}; + +static int __init lsm303dlh_a_init(void) +{ + return i2c_add_driver(&lsm303dlh_a_driver); +} + +static void __exit lsm303dlh_a_exit(void) +{ + i2c_del_driver(&lsm303dlh_a_driver); +} + +module_init(lsm303dlh_a_init) +module_exit(lsm303dlh_a_exit) + +MODULE_DESCRIPTION("lSM303DLH 3-Axis Accelerometer Driver"); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("STMicroelectronics"); diff --git a/drivers/hwmon/lsm303dlh_m.c b/drivers/hwmon/lsm303dlh_m.c new file mode 100644 index 00000000000..11815e3470f --- /dev/null +++ b/drivers/hwmon/lsm303dlh_m.c @@ -0,0 +1,924 @@ +/* + * lsm303dlh_m.c + * ST 3-Axis Magnetometer Driver + * + * Copyright (C) 2010 STMicroelectronics + * Author: Carmine Iascone (carmine.iascone@st.com) + * Author: Matteo Dameno (matteo.dameno@st.com) + * + * Copyright (C) 2010 STEricsson + * Author: Mian Yousaf Kaukab <mian.yousaf.kaukab@stericsson.com> + * Updated:Preetham Rao Kaskurthi <preetham.rao@stericsson.com> + * + * 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. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <linux/module.h> +#include <linux/i2c.h> +#include <linux/slab.h> +#include <linux/mutex.h> +#include <linux/platform_device.h> +#include <linux/delay.h> +#include <linux/err.h> + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE +#include <linux/input.h> +#include <linux/interrupt.h> +#include <mach/gpio.h> +#endif + +#include <linux/lsm303dlh.h> +#include <linux/regulator/consumer.h> +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif +#include <linux/kernel.h> + +/* lsm303dlh magnetometer registers */ +#define IRA_REG_M 0x0A + +/* Magnetometer registers */ +#define CRA_REG_M 0x00 /* Configuration register A */ +#define CRB_REG_M 0x01 /* Configuration register B */ +#define MR_REG_M 0x02 /* Mode register */ +#define SR_REG_M 0x09 /* Status register */ + +/* Output register start address*/ +#define OUT_X_M 0x03 +#define OUT_Y_M 0x05 +#define OUT_Z_M 0x07 + +/* Magnetometer X-Y gain */ +#define XY_GAIN_1_3 1055 /* XY gain at 1.3G */ +#define XY_GAIN_1_9 795 /* XY gain at 1.9G */ +#define XY_GAIN_2_5 635 /* XY gain at 2.5G */ +#define XY_GAIN_4_0 430 /* XY gain at 4.0G */ +#define XY_GAIN_4_7 375 /* XY gain at 4.7G */ +#define XY_GAIN_5_6 320 /* XY gain at 5.6G */ +#define XY_GAIN_8_1 230 /* XY gain at 8.1G */ + +/* Magnetometer Z gain */ +#define Z_GAIN_1_3 950 /* Z gain at 1.3G */ +#define Z_GAIN_1_9 710 /* Z gain at 1.9G */ +#define Z_GAIN_2_5 570 /* Z gain at 2.5G */ +#define Z_GAIN_4_0 385 /* Z gain at 4.0G */ +#define Z_GAIN_4_7 335 /* Z gain at 4.7G */ +#define Z_GAIN_5_6 285 /* Z gain at 5.6G */ +#define Z_GAIN_8_1 205 /* Z gain at 8.1G */ + +/* Control A regsiter. */ +#define LSM303DLH_M_CRA_DO_BIT 2 +#define LSM303DLH_M_CRA_DO_MASK (0x7 << LSM303DLH_M_CRA_DO_BIT) +#define LSM303DLH_M_CRA_MS_BIT 0 +#define LSM303DLH_M_CRA_MS_MASK (0x3 << LSM303DLH_M_CRA_MS_BIT) + +/* Control B regsiter. */ +#define LSM303DLH_M_CRB_GN_BIT 5 +#define LSM303DLH_M_CRB_GN_MASK (0x7 << LSM303DLH_M_CRB_GN_BIT) + +/* Control Mode regsiter. */ +#define LSM303DLH_M_MR_MD_BIT 0 +#define LSM303DLH_M_MR_MD_MASK (0x3 << LSM303DLH_M_MR_MD_BIT) + +/* Control Status regsiter. */ +#define LSM303DLH_M_SR_RDY_BIT 0 +#define LSM303DLH_M_SR_RDY_MASK (0x1 << LSM303DLH_M_SR_RDY_BIT) +#define LSM303DLH_M_SR_LOC_BIT 1 +#define LSM303DLH_M_SR_LCO_MASK (0x1 << LSM303DLH_M_SR_LOC_BIT) +#define LSM303DLH_M_SR_REN_BIT 2 +#define LSM303DLH_M_SR_REN_MASK (0x1 << LSM303DLH_M_SR_REN_BIT) + +/* Magnetometer gain setting */ +#define LSM303DLH_M_RANGE_1_3G 0x01 +#define LSM303DLH_M_RANGE_1_9G 0x02 +#define LSM303DLH_M_RANGE_2_5G 0x03 +#define LSM303DLH_M_RANGE_4_0G 0x04 +#define LSM303DLH_M_RANGE_4_7G 0x05 +#define LSM303DLH_M_RANGE_5_6G 0x06 +#define LSM303DLH_M_RANGE_8_1G 0x07 + +/* Magnetometer capturing mode */ +#define LSM303DLH_M_MODE_CONTINUOUS 0 +#define LSM303DLH_M_MODE_SINGLE 1 +#define LSM303DLH_M_MODE_SLEEP 3 + +/* Magnetometer output data rate */ +#define LSM303DLH_M_RATE_00_75 0x00 +#define LSM303DLH_M_RATE_01_50 0x01 +#define LSM303DLH_M_RATE_03_00 0x02 +#define LSM303DLH_M_RATE_07_50 0x03 +#define LSM303DLH_M_RATE_15_00 0x04 +#define LSM303DLH_M_RATE_30_00 0x05 +#define LSM303DLH_M_RATE_75_00 0x06 + +#ifdef CONFIG_SENSORS_LSM303DLHC +#define LSM303DLH_M_RATE_220_00 0x07 +#endif + +/* Multiple byte transfer enable */ +#define MULTIPLE_I2C_TR 0x80 + +/* device status defines */ +#define DEVICE_OFF 0 +#define DEVICE_ON 1 +#define DEVICE_SUSPENDED 2 + +/* device CHIP ID defines */ +#define LSM303DLHC_CHIP_ID 51 + +/** + * struct lsm303dlh_m_data - data structure used by lsm303dlh_m driver + * @client: i2c client + * @lock: mutex lock for sysfs operations + * @input_dev: input device + * @regulator: regulator + * @pdata: lsm303dlh platform data + * @gain: x, y and z axes gain + * @data: Magnetic field values of x, y and z axes + * @mode: current mode of operation + * @rate: current sampling rate + * @range: current range value of magnetometer + * @early_suspend: early suspend structure + * @device_status: device is ON, OFF or SUSPENDED + */ +struct lsm303dlh_m_data { + struct i2c_client *client; + /* lock for sysfs operations */ + struct mutex lock; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + struct input_dev *input_dev; +#endif + struct regulator *regulator; + struct lsm303dlh_platform_data pdata; + + short gain[3]; + short data[3]; + unsigned char mode; + unsigned char rate; + unsigned char range; +#ifdef CONFIG_HAS_EARLYSUSPEND + struct early_suspend early_suspend; +#endif + int device_status; +}; + +#ifdef CONFIG_HAS_EARLYSUSPEND +static void lsm303dlh_m_early_suspend(struct early_suspend *data); +static void lsm303dlh_m_late_resume(struct early_suspend *data); +#endif + +static int lsm303dlh_m_set_mode(struct lsm303dlh_m_data *ddata, + unsigned char mode); +static int lsm303dlh_m_write(struct lsm303dlh_m_data *ddata, + u8 reg, u8 val, char *msg) +{ + int ret = i2c_smbus_write_byte_data(ddata->client, reg, val); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_write_byte_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_PM) +static int lsm303dlh_m_do_suspend(struct lsm303dlh_m_data *ddata) +{ + int ret; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_M_MODE_SLEEP) { + mutex_unlock(&ddata->lock); + return 0; + } + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + disable_irq(gpio_to_irq(ddata->pdata.irq_m)); +#endif + + ret = lsm303dlh_m_set_mode(ddata, LSM303DLH_M_MODE_SLEEP); + + if (ddata->regulator) + regulator_disable(ddata->regulator); + + ddata->device_status = DEVICE_SUSPENDED; + + mutex_unlock(&ddata->lock); + + return ret; +} + +static int lsm303dlh_m_restore(struct lsm303dlh_m_data *ddata) +{ + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->device_status == DEVICE_ON) { + mutex_unlock(&ddata->lock); + return 0; + } + + /* in correct mode, no need to change it */ + if (ddata->mode == LSM303DLH_M_MODE_SLEEP) { + ddata->device_status = DEVICE_OFF; + mutex_unlock(&ddata->lock); + return 0; + } else + ddata->device_status = DEVICE_ON; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + enable_irq(gpio_to_irq(ddata->pdata.irq_m)); +#endif + + if (ddata->regulator) + regulator_enable(ddata->regulator); + + ret = lsm303dlh_m_write(ddata, CRB_REG_M, ddata->range, "SET RANGE"); + + if (ret < 0) + goto fail; + + ret = lsm303dlh_m_write(ddata, CRA_REG_M, ddata->rate, "SET RATE"); + + if (ret < 0) + goto fail; + + ret = lsm303dlh_m_set_mode(ddata, ddata->mode); + + if (ret < 0) + goto fail; + +fail: + mutex_unlock(&ddata->lock); + return ret; +} +#endif + +static int lsm303dlh_m_read_multi(struct lsm303dlh_m_data *ddata, u8 reg, + u8 count, u8 *val, char *msg) +{ + int ret = i2c_smbus_read_i2c_block_data(ddata->client, + reg | MULTIPLE_I2C_TR, count, val); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_read_i2c_block_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +static ssize_t lsm303dlh_m_show_rate(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_m_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->rate >> LSM303DLH_M_CRA_DO_BIT); +} + +/* set lsm303dlh magnetometer bandwidth */ +static ssize_t lsm303dlh_m_store_rate(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_m_data *ddata = platform_get_drvdata(pdev); + unsigned long val; + unsigned char data; + int error; + + error = strict_strtoul(buf, 0, &val); + if (error) + return error; + + mutex_lock(&ddata->lock); + if (ddata->mode == LSM303DLH_M_MODE_SLEEP) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + mutex_unlock(&ddata->lock); + return count; + } + + data = ((val << LSM303DLH_M_CRA_DO_BIT) & LSM303DLH_M_CRA_DO_MASK); + ddata->rate = data; + + error = lsm303dlh_m_write(ddata, CRA_REG_M, data, "SET RATE"); + + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + mutex_unlock(&ddata->lock); + + return count; +} + +static int lsm303dlh_m_xyz_read(struct lsm303dlh_m_data *ddata) +{ + unsigned char xyz_data[6]; + short temp; + int ret = lsm303dlh_m_read_multi(ddata, OUT_X_M, + 6, xyz_data, "OUT_X_M"); + if (ret < 0) + return -EINVAL; + + /* MSB is at lower address */ + ddata->data[0] = (short) + (((xyz_data[0]) << 8) | xyz_data[1]); + ddata->data[1] = (short) + (((xyz_data[2]) << 8) | xyz_data[3]); + ddata->data[2] = (short) + (((xyz_data[4]) << 8) | xyz_data[5]); + + /* check if chip is DHLC */ + if (ddata->pdata.chip_id == LSM303DLHC_CHIP_ID) { + /* + * the out registers are in x, z and y order + * so swap y and z values + */ + temp = ddata->data[1]; + ddata->data[1] = ddata->data[2]; + ddata->data[2] = temp; + } + /* taking orientation of x,y,z axis into account*/ + + ddata->data[ddata->pdata.axis_map_x] = ddata->pdata.negative_x ? + -ddata->data[ddata->pdata.axis_map_x] : + ddata->data[ddata->pdata.axis_map_x]; + ddata->data[ddata->pdata.axis_map_y] = ddata->pdata.negative_y ? + -ddata->data[ddata->pdata.axis_map_y] : + ddata->data[ddata->pdata.axis_map_y]; + ddata->data[ddata->pdata.axis_map_z] = ddata->pdata.negative_z ? + -ddata->data[ddata->pdata.axis_map_z] : + ddata->data[ddata->pdata.axis_map_z]; + + return ret; +} + +static ssize_t lsm303dlh_m_gain(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_m_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%8x:%8x:%8x\n", + ddata->gain[ddata->pdata.axis_map_x], + ddata->gain[ddata->pdata.axis_map_y], + ddata->gain[ddata->pdata.axis_map_z]); +} + +static ssize_t lsm303dlh_m_values(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_m_data *ddata = platform_get_drvdata(pdev); + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_M_MODE_SLEEP || + ddata->device_status == DEVICE_SUSPENDED) { + mutex_unlock(&ddata->lock); + return ret; + } + + ret = lsm303dlh_m_xyz_read(ddata); + + if (ret < 0) { + mutex_unlock(&ddata->lock); + return -EINVAL; + } + + mutex_unlock(&ddata->lock); + + /* taking orientation of x,y,z axis into account*/ + + return sprintf(buf, "%8x:%8x:%8x\n", + ddata->data[ddata->pdata.axis_map_x], + ddata->data[ddata->pdata.axis_map_y], + ddata->data[ddata->pdata.axis_map_z]); +} + +static int lsm303dlh_m_set_mode(struct lsm303dlh_m_data *ddata, + unsigned char mode) +{ + int ret; + + mode = (mode << LSM303DLH_M_MR_MD_BIT); + + ret = i2c_smbus_write_byte_data(ddata->client, MR_REG_M, mode); + + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_write_byte_data failed error %d\ + Register (%s)\n", ret, "MODE CONTROL"); + + return ret; +} + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + +static irqreturn_t lsm303dlh_m_gpio_irq(int irq, void *device_data) +{ + struct lsm303dlh_m_data *ddata = device_data; + int ret; + + ret = lsm303dlh_m_xyz_read(ddata); + + if (ret < 0) { + dev_err(&ddata->client->dev, + "reading data of xyz failed error %d\n", ret); + return IRQ_NONE; + } + + /* taking orientation of x,y,z axis into account*/ + + input_report_abs(ddata->input_dev, ABS_X, + ddata->data[ddata->pdata.axis_map_x]); + input_report_abs(ddata->input_dev, ABS_Y, + ddata->data[ddata->pdata.axis_map_y]); + input_report_abs(ddata->input_dev, ABS_Z, + ddata->data[ddata->pdata.axis_map_z]); + input_sync(ddata->input_dev); + + return IRQ_HANDLED; + +} +#endif + +static ssize_t lsm303dlh_m_show_range(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_m_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->range >> LSM303DLH_M_CRB_GN_BIT); +} + +static ssize_t lsm303dlh_m_store_range(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_m_data *ddata = platform_get_drvdata(pdev); + short xy_gain; + short z_gain; + unsigned long range; + int error; + + error = strict_strtoul(buf, 0, &range); + + if (error) + return error; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLH_M_MODE_SLEEP) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + mutex_unlock(&ddata->lock); + return count; + } + + switch (range) { + case LSM303DLH_M_RANGE_1_3G: + xy_gain = XY_GAIN_1_3; + z_gain = Z_GAIN_1_3; + break; + case LSM303DLH_M_RANGE_1_9G: + xy_gain = XY_GAIN_1_9; + z_gain = Z_GAIN_1_9; + break; + case LSM303DLH_M_RANGE_2_5G: + xy_gain = XY_GAIN_2_5; + z_gain = Z_GAIN_2_5; + break; + case LSM303DLH_M_RANGE_4_0G: + xy_gain = XY_GAIN_4_0; + z_gain = Z_GAIN_4_0; + break; + case LSM303DLH_M_RANGE_4_7G: + xy_gain = XY_GAIN_4_7; + z_gain = Z_GAIN_4_7; + break; + case LSM303DLH_M_RANGE_5_6G: + xy_gain = XY_GAIN_5_6; + z_gain = Z_GAIN_5_6; + break; + case LSM303DLH_M_RANGE_8_1G: + xy_gain = XY_GAIN_8_1; + z_gain = Z_GAIN_8_1; + break; + default: + mutex_unlock(&ddata->lock); + return -EINVAL; + } + + ddata->gain[ddata->pdata.axis_map_x] = xy_gain; + ddata->gain[ddata->pdata.axis_map_y] = xy_gain; + ddata->gain[ddata->pdata.axis_map_z] = z_gain; + + range <<= LSM303DLH_M_CRB_GN_BIT; + range &= LSM303DLH_M_CRB_GN_MASK; + + ddata->range = range; + + error = lsm303dlh_m_write(ddata, CRB_REG_M, range, "SET RANGE"); + mutex_unlock(&ddata->lock); + + if (error < 0) + return error; + + return count; +} + +static ssize_t lsm303dlh_m_show_mode(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_m_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->mode); +} + +static ssize_t lsm303dlh_m_store_mode(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlh_m_data *ddata = platform_get_drvdata(pdev); + unsigned long mode; + int error; + + error = strict_strtoul(buf, 0, &mode); + if (error) + return error; + + mutex_lock(&ddata->lock); + + if (ddata->device_status == DEVICE_SUSPENDED && + mode == LSM303DLH_M_MODE_SLEEP) { + ddata->mode = (mode >> LSM303DLH_M_MR_MD_BIT); + mutex_unlock(&ddata->lock); + return count; + } + + /* if same mode as existing, return */ + if (ddata->mode == mode) { + mutex_unlock(&ddata->lock); + return count; + } + + /* turn on the supplies if already off */ + if (ddata->mode == LSM303DLH_M_MODE_SLEEP && ddata->regulator + && (ddata->device_status == DEVICE_OFF + || ddata->device_status == DEVICE_SUSPENDED)) { + regulator_enable(ddata->regulator); + ddata->device_status = DEVICE_ON; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + enable_irq(gpio_to_irq(ddata->pdata.irq_m)); +#endif + } + + error = lsm303dlh_m_set_mode(ddata, mode); + + ddata->mode = (mode >> LSM303DLH_M_MR_MD_BIT); + if (error < 0) { + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + mutex_unlock(&ddata->lock); + return error; + } + + if (mode == LSM303DLH_M_MODE_SLEEP) { + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + disable_irq(gpio_to_irq(ddata->pdata.irq_m)); +#endif + + /* + * No need to store context here, it is not like + * suspend/resume but fall back to default values + */ + ddata->rate = LSM303DLH_M_RATE_00_75; + ddata->range = LSM303DLH_M_RANGE_1_3G; + ddata->range <<= LSM303DLH_M_CRB_GN_BIT; + ddata->range &= LSM303DLH_M_CRB_GN_MASK; + ddata->gain[ddata->pdata.axis_map_x] = XY_GAIN_1_3; + ddata->gain[ddata->pdata.axis_map_y] = XY_GAIN_1_3; + ddata->gain[ddata->pdata.axis_map_z] = Z_GAIN_1_3; + + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + } + mutex_unlock(&ddata->lock); + + return count; +} + +static DEVICE_ATTR(gain, S_IRUGO, lsm303dlh_m_gain, NULL); + +static DEVICE_ATTR(data, S_IRUGO, lsm303dlh_m_values, NULL); + +static DEVICE_ATTR(mode, S_IWUSR | S_IRUGO, + lsm303dlh_m_show_mode, lsm303dlh_m_store_mode); + +static DEVICE_ATTR(range, S_IWUSR | S_IRUGO, + lsm303dlh_m_show_range, lsm303dlh_m_store_range); + +static DEVICE_ATTR(rate, S_IWUSR | S_IRUGO, + lsm303dlh_m_show_rate, lsm303dlh_m_store_rate); + +static struct attribute *lsm303dlh_m_attributes[] = { + &dev_attr_gain.attr, + &dev_attr_data.attr, + &dev_attr_mode.attr, + &dev_attr_range.attr, + &dev_attr_rate.attr, + NULL +}; + +static const struct attribute_group lsm303dlh_m_attr_group = { + .attrs = lsm303dlh_m_attributes, +}; + +static int __devinit lsm303dlh_m_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + int ret; + struct lsm303dlh_m_data *ddata = NULL; + unsigned char version[3]; + + ddata = kzalloc(sizeof(struct lsm303dlh_m_data), GFP_KERNEL); + if (ddata == NULL) { + ret = -ENOMEM; + goto err_op_failed; + } + + ddata->client = client; + i2c_set_clientdata(client, ddata); + + /* copy platform specific data */ + memcpy(&ddata->pdata, client->dev.platform_data, sizeof(ddata->pdata)); + + ddata->mode = LSM303DLH_M_MODE_SLEEP; + ddata->rate = LSM303DLH_M_RATE_00_75; + ddata->range = LSM303DLH_M_RANGE_1_3G; + ddata->range <<= LSM303DLH_M_CRB_GN_BIT; + ddata->range &= LSM303DLH_M_CRB_GN_MASK; + ddata->gain[ddata->pdata.axis_map_x] = XY_GAIN_1_3; + ddata->gain[ddata->pdata.axis_map_y] = XY_GAIN_1_3; + ddata->gain[ddata->pdata.axis_map_z] = Z_GAIN_1_3; + ddata->device_status = DEVICE_OFF; + dev_set_name(&client->dev, ddata->pdata.name_m); + ddata->regulator = regulator_get(&client->dev, "vdd"); + + if (IS_ERR(ddata->regulator)) { + dev_err(&client->dev, "failed to get regulator\n"); + ret = PTR_ERR(ddata->regulator); + ddata->regulator = NULL; + } + + if (ddata->regulator) { + /* + * 0.83 milliamps typical with magnetic sensor setting ODR = + * 7.5 Hz, Accelerometer sensor ODR = 50 Hz. Double for + * safety. + */ + regulator_set_optimum_mode(ddata->regulator, 830 * 2); + regulator_enable(ddata->regulator); + ddata->device_status = DEVICE_ON; + } + + ret = lsm303dlh_m_read_multi(ddata, IRA_REG_M, 3, version, "IRA_REG_M"); + if (ret < 0) + goto exit_free_regulator; + + dev_info(&client->dev, "Magnetometer, ID : %x:%x:%x", + version[0], version[1], version[2]); + + mutex_init(&ddata->lock); + + ret = sysfs_create_group(&client->dev.kobj, &lsm303dlh_m_attr_group); + if (ret) + goto exit_free_regulator; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + + ddata->input_dev = input_allocate_device(); + if (!ddata->input_dev) { + ret = -ENOMEM; + dev_err(&client->dev, "Failed to allocate input device\n"); + goto exit_free_regulator; + } + + set_bit(EV_ABS, ddata->input_dev->evbit); + + /* x-axis acceleration */ + input_set_abs_params(ddata->input_dev, ABS_X, -32768, 32767, 0, 0); + /* y-axis acceleration */ + input_set_abs_params(ddata->input_dev, ABS_Y, -32768, 32767, 0, 0); + /* z-axis acceleration */ + input_set_abs_params(ddata->input_dev, ABS_Z, -32768, 32767, 0, 0); + + ddata->input_dev->name = "magnetometer"; + + ret = input_register_device(ddata->input_dev); + if (ret) { + dev_err(&client->dev, "Unable to register input device: %s\n", + ddata->input_dev->name); + goto err_input_register_failed; + } + + /* register interrupt */ + ret = request_threaded_irq(gpio_to_irq(ddata->pdata.irq_m), NULL, + lsm303dlh_m_gpio_irq, + IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "lsm303dlh_m", + ddata); + if (ret) { + dev_err(&client->dev, "request irq EGPIO_PIN_1 failed\n"); + goto err_input_failed; + } + + disable_irq(gpio_to_irq(ddata->pdata.irq_m)); +#endif + +#ifdef CONFIG_HAS_EARLYSUSPEND + ddata->early_suspend.level = + EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; + ddata->early_suspend.suspend = lsm303dlh_m_early_suspend; + ddata->early_suspend.resume = lsm303dlh_m_late_resume; + register_early_suspend(&ddata->early_suspend); +#endif + + if (ddata->device_status == DEVICE_ON && ddata->regulator) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + + return ret; + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE +err_input_failed: + input_unregister_device(ddata->input_dev); +err_input_register_failed: + input_free_device(ddata->input_dev); +#endif +exit_free_regulator: + if (ddata->device_status == DEVICE_ON && ddata->regulator) { + regulator_disable(ddata->regulator); + regulator_put(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } +err_op_failed: + dev_err(&client->dev, "lsm303dlh_m_probe failed %x", ret); + kfree(ddata); + return ret; +} + +static int __devexit lsm303dlh_m_remove(struct i2c_client *client) +{ + struct lsm303dlh_m_data *ddata; + + ddata = i2c_get_clientdata(client); + +#ifdef CONFIG_SENSORS_LSM303DLH_INPUT_DEVICE + input_unregister_device(ddata->input_dev); + input_free_device(ddata->input_dev); +#endif + + sysfs_remove_group(&client->dev.kobj, &lsm303dlh_m_attr_group); + + /* safer to make device off */ + if (ddata->mode != LSM303DLH_M_MODE_SLEEP) { + lsm303dlh_m_set_mode(ddata, LSM303DLH_M_MODE_SLEEP); + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + regulator_put(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + } + + i2c_set_clientdata(client, NULL); + kfree(ddata); + + return 0; +} + +#ifndef CONFIG_HAS_EARLYSUSPEND +#ifdef CONFIG_PM +static int lsm303dlh_m_suspend(struct device *dev) +{ + struct lsm303dlh_m_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = lsm303dlh_m_do_suspend(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while suspending the device"); + + return ret; +} + +static int lsm303dlh_m_resume(struct device *dev) +{ + struct lsm303dlh_m_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = lsm303dlh_m_restore(ddata); + + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while resuming the device"); + + return ret; +} +static const struct dev_pm_ops lsm303dlh_m_dev_pm_ops = { + .suspend = lsm303dlh_m_suspend, + .resume = lsm303dlh_m_resume, +}; +#endif +#else +static void lsm303dlh_m_early_suspend(struct early_suspend *data) +{ + struct lsm303dlh_m_data *ddata = + container_of(data, struct lsm303dlh_m_data, early_suspend); + int ret; + + ret = lsm303dlh_m_do_suspend(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while suspending the device"); +} + +static void lsm303dlh_m_late_resume(struct early_suspend *data) +{ + struct lsm303dlh_m_data *ddata = + container_of(data, struct lsm303dlh_m_data, early_suspend); + int ret; + + ret = lsm303dlh_m_restore(ddata); + + if (ret < 0) + dev_err(&ddata->client->dev, + "lsm303dlh_m late resume failed\n"); +} +#endif /* CONFIG_PM */ + +static const struct i2c_device_id lsm303dlh_m_id[] = { + { "lsm303dlh_m", 0 }, + { }, +}; + +static struct i2c_driver lsm303dlh_m_driver = { + .probe = lsm303dlh_m_probe, + .remove = lsm303dlh_m_remove, + .id_table = lsm303dlh_m_id, + .driver = { + .name = "lsm303dlh_m", +#if (!defined(CONFIG_HAS_EARLYSUSPEND) && defined(CONFIG_PM)) + .pm = &lsm303dlh_m_dev_pm_ops, +#endif + }, +}; + +static int __init lsm303dlh_m_init(void) +{ + return i2c_add_driver(&lsm303dlh_m_driver); +} + +static void __exit lsm303dlh_m_exit(void) +{ + i2c_del_driver(&lsm303dlh_m_driver); +} + +module_init(lsm303dlh_m_init); +module_exit(lsm303dlh_m_exit); + +MODULE_DESCRIPTION("lSM303DLH 3-Axis Magnetometer Driver"); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("STMicroelectronics"); diff --git a/drivers/hwmon/lsm303dlhc_a.c b/drivers/hwmon/lsm303dlhc_a.c new file mode 100644 index 00000000000..f4012442b68 --- /dev/null +++ b/drivers/hwmon/lsm303dlhc_a.c @@ -0,0 +1,704 @@ +/* + * ST LSM303DLHC 3-Axis Accelerometer Driver + * + * Copyright (C) ST-Ericsson SA 2011 + * Author: Chethan Krishna N <chethan.krishna@stericsson.com> for ST-Ericsson + * Licence terms: GNU General Public Licence (GPL) version 2 + */ + +#include <linux/module.h> +#include <linux/i2c.h> +#include <linux/mutex.h> +#include <linux/slab.h> +#include <linux/delay.h> +#include <linux/platform_device.h> +#include <linux/err.h> + +#include <linux/lsm303dlh.h> +#include <linux/regulator/consumer.h> + +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif + +#define WHO_AM_I 0x0F + +/* lsm303dlhc accelerometer registers */ +#define CTRL_REG1 0x20 +#define CTRL_REG2 0x21 +#define CTRL_REG3 0x22 +#define CTRL_REG4 0x23 +#define CTRL_REG5 0x24 +#define CTRL_REG6 0x25 + +/* lsm303dlhc accelerometer defines */ +#define LSM303DLHC_A_MODE_OFF 0x00 +#define LSM303DLHC_A_MODE_ON 0x04 +#define LSM303DLHC_A_MODE_MAX 0x09 +#define LSM303DLHC_A_CR1_MODE_BIT 4 +#define LSM303DLHC_A_CR1_MODE_MASK (0xF << LSM303DLHC_A_CR1_MODE_BIT) + #define LSM303DLHC_A_CR1_AXIS_ENABLE 7 + +/* Range */ +#define LSM303DLHC_A_RANGE_2G 0x00 +#define LSM303DLHC_A_RANGE_4G 0x01 +#define LSM303DLHC_A_RANGE_8G 0x02 +#define LSM303DLHC_A_RANGE_16G 0x03 +#define LSM303DLHC_A_CR4_FS_BIT 4 + +/* Sensitivity adjustment */ +#define SHIFT_ADJ_2G 4 /* 1/16*/ +#define SHIFT_ADJ_4G 3 /* 2/16*/ +#define SHIFT_ADJ_8G 2 /* ~3.9/16*/ +#define SHIFT_ADJ_16G 1 /* ~3.9/16*/ + +#define AXISDATA_REG 0x28 /* axis data */ + +/* lsm303dlh magnetometer registers */ +#define IRA_REG_M 0x0A + +/* multiple byte transfer enable */ +#define MULTIPLE_I2C_TR 0x80 + +/* device status defines */ +#define DEVICE_OFF 0 +#define DEVICE_ON 1 +#define DEVICE_SUSPENDED 2 + +struct lsm303dlhc_a_t { + short x; + short y; + short z; +}; + +/** + * struct lsm303dlhc_a_data - data structure used by lsm303dlhc_a driver + * @client: i2c client + * @lock: mutex lock for sysfs operations + * @data: lsm303dlhc_a_t struct containing x, y and z values + * @pdata: lsm303dlh platform data + * @regulator: regulator + * @range: current range value of accelerometer + * @mode: current mode of operation + * @rate: current sampling rate + * @shift_adjust: current shift adjust value set according to range + * @early_suspend: early suspend structure + * @device_status: device is ON, OFF or SUSPENDED + * @id: accelerometer device id + */ +struct lsm303dlhc_a_data { + struct i2c_client *client; + /* lock for sysfs operations */ + struct mutex lock; + struct lsm303dlhc_a_t data; + struct lsm303dlh_platform_data pdata; + struct regulator *regulator; +#ifdef CONFIG_HAS_EARLYSUSPEND + struct early_suspend early_suspend; +#endif + unsigned char range; + unsigned char mode; + unsigned char rate; + int shift_adjust; + int device_status; + int id; +}; + +#ifdef CONFIG_HAS_EARLYSUSPEND +static void lsm303dlhc_a_early_suspend(struct early_suspend *data); +static void lsm303dlhc_a_late_resume(struct early_suspend *data); +#endif + +static int lsm303dlhc_a_write(struct lsm303dlhc_a_data *ddata, u8 reg, + u8 val, char *msg) +{ + int ret = i2c_smbus_write_byte_data(ddata->client, reg, val); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_write_byte_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +static int lsm303dlhc_a_read(struct lsm303dlhc_a_data *ddata, u8 reg, char *msg) +{ + int ret = i2c_smbus_read_byte_data(ddata->client, reg); + if (ret < 0) + dev_err(&ddata->client->dev, + "i2c_smbus_read_byte_data failed error %d\ + Register (%s)\n", ret, msg); + return ret; +} + +#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_PM) +static int lsm303dlhc_a_do_suspend(struct lsm303dlhc_a_data *ddata) +{ + int ret; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLHC_A_MODE_OFF) { + ret = 0; + goto exit; + } + + ret = lsm303dlhc_a_write(ddata, CTRL_REG1, + LSM303DLHC_A_MODE_OFF, "CONTROL"); + + if (ddata->regulator) + regulator_disable(ddata->regulator); + + ddata->device_status = DEVICE_SUSPENDED; + +exit: + mutex_unlock(&ddata->lock); + + return ret; +} + +static int lsm303dlhc_a_restore(struct lsm303dlhc_a_data *ddata) +{ + unsigned char reg; + unsigned char shifted_mode = (ddata->mode << LSM303DLHC_A_CR1_MODE_BIT); + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->device_status == DEVICE_ON) { + mutex_unlock(&ddata->lock); + return 0; + } + + /* in correct mode, no need to change it */ + if (ddata->mode == LSM303DLHC_A_MODE_OFF) { + ddata->device_status = DEVICE_OFF; + goto fail; + } else + ddata->device_status = DEVICE_ON; + + if (ddata->regulator) + regulator_enable(ddata->regulator); + + /* BDU should be enabled by default/recommened */ + reg = ddata->range; + shifted_mode |= LSM303DLHC_A_CR1_AXIS_ENABLE; + + ret = lsm303dlhc_a_write(ddata, CTRL_REG1, shifted_mode, + "CTRL_REG1"); + if (ret < 0) + goto fail; + + ret = lsm303dlhc_a_write(ddata, CTRL_REG4, reg, "CTRL_REG4"); + + if (ret < 0) + goto fail; + + /* write to the boot bit to reboot memory content */ + ret = lsm303dlhc_a_write(ddata, CTRL_REG5, 0x80, "CTRL_REG5"); + + if (ret < 0) + goto fail; + +fail: + if (ret < 0) + dev_err(&ddata->client->dev, + "could not restore the device %d\n", ret); + mutex_unlock(&ddata->lock); + return ret; +} +#endif + +static int lsm303dlhc_a_readdata(struct lsm303dlhc_a_data *ddata) +{ + unsigned char acc_data[6]; + short data[3]; + + int ret = i2c_smbus_read_i2c_block_data(ddata->client, + AXISDATA_REG | MULTIPLE_I2C_TR, 6, acc_data); + if (ret < 0) { + dev_err(&ddata->client->dev, + "i2c_smbus_read_byte_data failed error %d\ + Register AXISDATA_REG \n", ret); + return ret; + } + + data[0] = (short) (((acc_data[1]) << 8) | acc_data[0]); + data[1] = (short) (((acc_data[3]) << 8) | acc_data[2]); + data[2] = (short) (((acc_data[5]) << 8) | acc_data[4]); + + data[0] >>= ddata->shift_adjust; + data[1] >>= ddata->shift_adjust; + data[2] >>= ddata->shift_adjust; + + /* taking position and orientation of x,y,z axis into account*/ + + data[ddata->pdata.axis_map_x] = ddata->pdata.negative_x ? + -data[ddata->pdata.axis_map_x] : data[ddata->pdata.axis_map_x]; + data[ddata->pdata.axis_map_y] = ddata->pdata.negative_y ? + -data[ddata->pdata.axis_map_y] : data[ddata->pdata.axis_map_y]; + data[ddata->pdata.axis_map_z] = ddata->pdata.negative_z ? + -data[ddata->pdata.axis_map_z] : data[ddata->pdata.axis_map_z]; + + ddata->data.x = data[ddata->pdata.axis_map_x]; + ddata->data.y = data[ddata->pdata.axis_map_y]; + ddata->data.z = data[ddata->pdata.axis_map_z]; + + return ret; +} + +static ssize_t lsm303dlhc_a_show_data(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev); + int ret = 0; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLHC_A_MODE_OFF || + ddata->device_status == DEVICE_SUSPENDED) { + mutex_unlock(&ddata->lock); + return ret; + } + + ret = lsm303dlhc_a_readdata(ddata); + + if (ret < 0) { + mutex_unlock(&ddata->lock); + return ret; + } + + mutex_unlock(&ddata->lock); + + return sprintf(buf, "%8x:%8x:%8x\n", ddata->data.x, ddata->data.y, + ddata->data.z); +} + +static ssize_t lsm303dlhc_a_show_range(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->range >> LSM303DLHC_A_CR4_FS_BIT); +} + +static ssize_t lsm303dlhc_a_store_range(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev); + long val; + int error; + + error = strict_strtol(buf, 0, &val); + if (error) + return error; + + if (val < LSM303DLHC_A_RANGE_2G || val > LSM303DLHC_A_RANGE_16G) + return -EINVAL; + + mutex_lock(&ddata->lock); + + if (ddata->mode == LSM303DLHC_A_MODE_OFF) { + dev_info(&ddata->client->dev, + "device is switched off,make it ON using MODE"); + mutex_unlock(&ddata->lock); + return count; + } + + ddata->range = val; + ddata->range <<= LSM303DLHC_A_CR4_FS_BIT; + + error = lsm303dlhc_a_write(ddata, CTRL_REG4, ddata->range, + "CTRL_REG4"); + if (error < 0) { + mutex_unlock(&ddata->lock); + return error; + } + + switch (val) { + case LSM303DLHC_A_RANGE_2G: + ddata->shift_adjust = SHIFT_ADJ_2G; + break; + case LSM303DLHC_A_RANGE_4G: + ddata->shift_adjust = SHIFT_ADJ_4G; + break; + case LSM303DLHC_A_RANGE_8G: + ddata->shift_adjust = SHIFT_ADJ_8G; + break; + case LSM303DLHC_A_RANGE_16G: + ddata->shift_adjust = SHIFT_ADJ_16G; + break; + default: + mutex_unlock(&ddata->lock); + return -EINVAL; + } + + mutex_unlock(&ddata->lock); + + return count; +} + +static ssize_t lsm303dlhc_a_show_mode(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->mode); +} + +static ssize_t lsm303dlhc_a_store_mode(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev); + long val; + unsigned char data; + int error; + bool set_boot_bit = false; + + error = strict_strtol(buf, 0, &val); + if (error) + return error; + + mutex_lock(&ddata->lock); + + /* not in correct range */ + + if (val < LSM303DLHC_A_MODE_OFF || val > LSM303DLHC_A_MODE_MAX) { + mutex_unlock(&ddata->lock); + return -EINVAL; + } + + if (ddata->device_status == DEVICE_SUSPENDED) { + if (val == LSM303DLHC_A_MODE_OFF) { + ddata->mode = val; + mutex_unlock(&ddata->lock); + return count; + } else { + /* device is turning on after suspend, reset memory */ + set_boot_bit = true; + } + } + + /* if same mode as existing, return */ + if (ddata->mode == val) { + mutex_unlock(&ddata->lock); + return count; + } + + /* turn on the supplies if already off */ + if (ddata->regulator && ddata->mode == LSM303DLHC_A_MODE_OFF + && (ddata->device_status == DEVICE_OFF + || ddata->device_status == DEVICE_SUSPENDED)) { + regulator_enable(ddata->regulator); + ddata->device_status = DEVICE_ON; + } + + data = lsm303dlhc_a_read(ddata, CTRL_REG1, "CTRL_REG1"); + + /* + * If chip doesn't get reset during suspend/resume, + * x,y and z axis bits are getting cleared,so set + * these bits to get x,y,z data. + */ + data |= LSM303DLHC_A_CR1_AXIS_ENABLE; + + data &= ~LSM303DLHC_A_CR1_MODE_MASK; + + ddata->mode = val; + + data |= ((val << LSM303DLHC_A_CR1_MODE_BIT) + & LSM303DLHC_A_CR1_MODE_MASK); + + error = lsm303dlhc_a_write(ddata, CTRL_REG1, data, "CTRL_REG1"); + if (error < 0) { + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + mutex_unlock(&ddata->lock); + return error; + } + + /* + * Power on request when device is in suspended state + * write to the boot bit in CTRL_REG2 to reboot memory content + * and ensure correct device behavior after it resumes + */ + if (set_boot_bit) { + error = lsm303dlhc_a_write(ddata, CTRL_REG5, 0x80, "CTRL_REG5"); + if (error < 0) { + if (ddata->regulator && + ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + mutex_unlock(&ddata->lock); + return error; + } + } + + if (val == LSM303DLHC_A_MODE_OFF) { + + /* + * No need to store context here + * it is not like suspend/resume + * but fall back to default values + */ + ddata->range = LSM303DLHC_A_RANGE_2G; + ddata->shift_adjust = SHIFT_ADJ_2G; + + if (ddata->regulator && ddata->device_status == DEVICE_ON) { + regulator_disable(ddata->regulator); + ddata->device_status = DEVICE_OFF; + } + } + mutex_unlock(&ddata->lock); + + return count; +} + +static ssize_t lsm303dlhc_a_show_id(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct platform_device *pdev = to_platform_device(dev); + struct lsm303dlhc_a_data *ddata = platform_get_drvdata(pdev); + + return sprintf(buf, "%d\n", ddata->id); +} + +static DEVICE_ATTR(id, S_IRUGO, lsm303dlhc_a_show_id, NULL); + +static DEVICE_ATTR(data, S_IRUGO, lsm303dlhc_a_show_data, NULL); + +static DEVICE_ATTR(range, S_IWUSR | S_IRUGO, + lsm303dlhc_a_show_range, lsm303dlhc_a_store_range); + +static DEVICE_ATTR(mode, S_IWUSR | S_IRUGO, + lsm303dlhc_a_show_mode, lsm303dlhc_a_store_mode); + +static struct attribute *lsm303dlhc_a_attributes[] = { + &dev_attr_data.attr, + &dev_attr_range.attr, + &dev_attr_mode.attr, + &dev_attr_id.attr, + NULL +}; + +static const struct attribute_group lsm303dlhc_a_attr_group = { + .attrs = lsm303dlhc_a_attributes, +}; + +static int __devinit lsm303dlhc_a_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + int ret; + struct lsm303dlhc_a_data *adata = NULL; + + adata = kzalloc(sizeof(struct lsm303dlhc_a_data), GFP_KERNEL); + if (adata == NULL) { + ret = -ENOMEM; + goto err_op_failed; + } + + adata->client = client; + i2c_set_clientdata(client, adata); + + /* copy platform specific data */ + memcpy(&adata->pdata, client->dev.platform_data, sizeof(adata->pdata)); + adata->mode = LSM303DLHC_A_MODE_OFF; + adata->range = LSM303DLHC_A_RANGE_2G; + adata->shift_adjust = SHIFT_ADJ_2G; + adata->device_status = DEVICE_OFF; + dev_set_name(&client->dev, adata->pdata.name_a); + + adata->regulator = regulator_get(&client->dev, "vdd"); + if (IS_ERR(adata->regulator)) { + dev_err(&client->dev, "failed to get regulator\n"); + ret = PTR_ERR(adata->regulator); + adata->regulator = NULL; + } + + if (adata->regulator) { + /* + * 130 microamps typical with magnetic sensor setting ODR = 7.5 + * Hz, Accelerometer sensor ODR = 50 Hz. Double for safety. + */ + regulator_set_optimum_mode(adata->regulator, 130 * 2); + regulator_enable(adata->regulator); + adata->device_status = DEVICE_ON; + } + + ret = lsm303dlhc_a_read(adata, WHO_AM_I, "WHO_AM_I"); + if (ret < 0) + goto exit_free_regulator; + + dev_info(&client->dev, "3-Axis Accelerometer, ID : %d\n", + ret); + adata->id = ret; + + mutex_init(&adata->lock); + + ret = sysfs_create_group(&client->dev.kobj, &lsm303dlhc_a_attr_group); + if (ret) + goto exit_free_regulator; + +#ifdef CONFIG_HAS_EARLYSUSPEND + adata->early_suspend.level = + EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; + adata->early_suspend.suspend = lsm303dlhc_a_early_suspend; + adata->early_suspend.resume = lsm303dlhc_a_late_resume; + register_early_suspend(&adata->early_suspend); +#endif + + if (adata->device_status == DEVICE_ON && adata->regulator) { + regulator_disable(adata->regulator); + adata->device_status = DEVICE_OFF; + } + + return ret; + +exit_free_regulator: + if (adata->device_status == DEVICE_ON && adata->regulator) { + regulator_disable(adata->regulator); + regulator_put(adata->regulator); + adata->device_status = DEVICE_OFF; + } +err_op_failed: + kfree(adata); + dev_err(&client->dev, "probe function fails %x", ret); + return ret; +} + +static int __devexit lsm303dlhc_a_remove(struct i2c_client *client) +{ + int ret; + struct lsm303dlhc_a_data *adata; + + adata = i2c_get_clientdata(client); + sysfs_remove_group(&client->dev.kobj, &lsm303dlhc_a_attr_group); + + /* safer to make device off */ + if (adata->mode != LSM303DLHC_A_MODE_OFF) { + ret = lsm303dlhc_a_write(adata, CTRL_REG1, 0, "CONTROL"); + + if (ret < 0) { + dev_err(&client->dev, + "could not turn off the device %d", + ret); + return ret; + } + + if (adata->regulator && adata->device_status == DEVICE_ON) { + regulator_disable(adata->regulator); + regulator_put(adata->regulator); + adata->device_status = DEVICE_OFF; + } + } + + i2c_set_clientdata(client, NULL); + kfree(adata); + + return 0; +} + +#if (!defined(CONFIG_HAS_EARLYSUSPEND) && defined(CONFIG_PM)) +static int lsm303dlhc_a_suspend(struct device *dev) +{ + struct lsm303dlhc_a_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = lsm303dlhc_a_do_suspend(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while suspending the device"); + + return ret; +} + +static int lsm303dlhc_a_resume(struct device *dev) +{ + struct lsm303dlhc_a_data *ddata; + int ret; + + ddata = dev_get_drvdata(dev); + + ret = lsm303dlhc_a_restore(ddata); + + if (ret < 0) + dev_err(&ddata->client->dev, + "Error while resuming the device"); + + return ret; +} +static const struct dev_pm_ops lsm303dlhc_a_dev_pm_ops = { + .suspend = lsm303dlhc_a_suspend, + .resume = lsm303dlhc_a_resume, +}; +#else +static void lsm303dlhc_a_early_suspend(struct early_suspend *data) +{ + struct lsm303dlhc_a_data *ddata = + container_of(data, struct lsm303dlhc_a_data, early_suspend); + int ret; + + ret = lsm303dlhc_a_do_suspend(ddata); +} + +static void lsm303dlhc_a_late_resume(struct early_suspend *data) +{ + struct lsm303dlhc_a_data *ddata = + container_of(data, struct lsm303dlhc_a_data, early_suspend); + int ret; + + ret = lsm303dlhc_a_restore(ddata); + if (ret < 0) + dev_err(&ddata->client->dev, + "lsm303dlhc_a late resume failed\n"); +} +#endif /* CONFIG_PM */ + +static const struct i2c_device_id lsm303dlhc_a_id[] = { + { "lsm303dlhc_a", 0 }, + { }, +}; + +static struct i2c_driver lsm303dlhc_a_driver = { + .probe = lsm303dlhc_a_probe, + .remove = lsm303dlhc_a_remove, + .id_table = lsm303dlhc_a_id, + .driver = { + .name = "lsm303dlhc_a", + #if (!defined(CONFIG_HAS_EARLYSUSPEND) && defined(CONFIG_PM)) + .pm = &lsm303dlhc_a_dev_pm_ops, + #endif + }, +}; + +static int __init lsm303dlhc_a_init(void) +{ + return i2c_add_driver(&lsm303dlhc_a_driver); +} + +static void __exit lsm303dlhc_a_exit(void) +{ + i2c_del_driver(&lsm303dlhc_a_driver); +} + +module_init(lsm303dlhc_a_init) +module_exit(lsm303dlhc_a_exit) + +MODULE_DESCRIPTION("lSM303DLH 3-Axis Accelerometer Driver"); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("STMicroelectronics"); |