Merge branch 'akpm' (patches from Andrew)
[firefly-linux-kernel-4.4.55.git] / drivers / hwmon / tmp102.c
1 /* Texas Instruments TMP102 SMBus temperature sensor driver
2  *
3  * Copyright (C) 2010 Steven King <sfking@fdwdc.com>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA
18  */
19
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/slab.h>
23 #include <linux/i2c.h>
24 #include <linux/hwmon.h>
25 #include <linux/hwmon-sysfs.h>
26 #include <linux/err.h>
27 #include <linux/mutex.h>
28 #include <linux/device.h>
29 #include <linux/jiffies.h>
30 #include <linux/thermal.h>
31 #include <linux/of.h>
32
33 #define DRIVER_NAME "tmp102"
34
35 #define TMP102_TEMP_REG                 0x00
36 #define TMP102_CONF_REG                 0x01
37 /* note: these bit definitions are byte swapped */
38 #define         TMP102_CONF_SD          0x0100
39 #define         TMP102_CONF_TM          0x0200
40 #define         TMP102_CONF_POL         0x0400
41 #define         TMP102_CONF_F0          0x0800
42 #define         TMP102_CONF_F1          0x1000
43 #define         TMP102_CONF_R0          0x2000
44 #define         TMP102_CONF_R1          0x4000
45 #define         TMP102_CONF_OS          0x8000
46 #define         TMP102_CONF_EM          0x0010
47 #define         TMP102_CONF_AL          0x0020
48 #define         TMP102_CONF_CR0         0x0040
49 #define         TMP102_CONF_CR1         0x0080
50 #define TMP102_TLOW_REG                 0x02
51 #define TMP102_THIGH_REG                0x03
52
53 struct tmp102 {
54         struct i2c_client *client;
55         struct device *hwmon_dev;
56         struct thermal_zone_device *tz;
57         struct mutex lock;
58         u16 config_orig;
59         unsigned long last_update;
60         int temp[3];
61         bool first_time;
62 };
63
64 /* convert left adjusted 13-bit TMP102 register value to milliCelsius */
65 static inline int tmp102_reg_to_mC(s16 val)
66 {
67         return ((val & ~0x01) * 1000) / 128;
68 }
69
70 /* convert milliCelsius to left adjusted 13-bit TMP102 register value */
71 static inline u16 tmp102_mC_to_reg(int val)
72 {
73         return (val * 128) / 1000;
74 }
75
76 static const u8 tmp102_reg[] = {
77         TMP102_TEMP_REG,
78         TMP102_TLOW_REG,
79         TMP102_THIGH_REG,
80 };
81
82 static struct tmp102 *tmp102_update_device(struct device *dev)
83 {
84         struct tmp102 *tmp102 = dev_get_drvdata(dev);
85         struct i2c_client *client = tmp102->client;
86
87         mutex_lock(&tmp102->lock);
88         if (time_after(jiffies, tmp102->last_update + HZ / 3)) {
89                 int i;
90                 for (i = 0; i < ARRAY_SIZE(tmp102->temp); ++i) {
91                         int status = i2c_smbus_read_word_swapped(client,
92                                                                  tmp102_reg[i]);
93                         if (status > -1)
94                                 tmp102->temp[i] = tmp102_reg_to_mC(status);
95                 }
96                 tmp102->last_update = jiffies;
97                 tmp102->first_time = false;
98         }
99         mutex_unlock(&tmp102->lock);
100         return tmp102;
101 }
102
103 static int tmp102_read_temp(void *dev, int *temp)
104 {
105         struct tmp102 *tmp102 = tmp102_update_device(dev);
106
107         /* Is it too early even to return a conversion? */
108         if (tmp102->first_time) {
109                 dev_dbg(dev, "%s: Conversion not ready yet..\n", __func__);
110                 return -EAGAIN;
111         }
112
113         *temp = tmp102->temp[0];
114
115         return 0;
116 }
117
118 static ssize_t tmp102_show_temp(struct device *dev,
119                                 struct device_attribute *attr,
120                                 char *buf)
121 {
122         struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
123         struct tmp102 *tmp102 = tmp102_update_device(dev);
124
125         /* Is it too early even to return a read? */
126         if (tmp102->first_time)
127                 return -EAGAIN;
128
129         return sprintf(buf, "%d\n", tmp102->temp[sda->index]);
130 }
131
132 static ssize_t tmp102_set_temp(struct device *dev,
133                                struct device_attribute *attr,
134                                const char *buf, size_t count)
135 {
136         struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
137         struct tmp102 *tmp102 = dev_get_drvdata(dev);
138         struct i2c_client *client = tmp102->client;
139         long val;
140         int status;
141
142         if (kstrtol(buf, 10, &val) < 0)
143                 return -EINVAL;
144         val = clamp_val(val, -256000, 255000);
145
146         mutex_lock(&tmp102->lock);
147         tmp102->temp[sda->index] = val;
148         status = i2c_smbus_write_word_swapped(client, tmp102_reg[sda->index],
149                                               tmp102_mC_to_reg(val));
150         mutex_unlock(&tmp102->lock);
151         return status ? : count;
152 }
153
154 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp102_show_temp, NULL , 0);
155
156 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, tmp102_show_temp,
157                           tmp102_set_temp, 1);
158
159 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp102_show_temp,
160                           tmp102_set_temp, 2);
161
162 static struct attribute *tmp102_attrs[] = {
163         &sensor_dev_attr_temp1_input.dev_attr.attr,
164         &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
165         &sensor_dev_attr_temp1_max.dev_attr.attr,
166         NULL
167 };
168 ATTRIBUTE_GROUPS(tmp102);
169
170 #define TMP102_CONFIG  (TMP102_CONF_TM | TMP102_CONF_EM | TMP102_CONF_CR1)
171 #define TMP102_CONFIG_RD_ONLY (TMP102_CONF_R0 | TMP102_CONF_R1 | TMP102_CONF_AL)
172
173 static const struct thermal_zone_of_device_ops tmp102_of_thermal_ops = {
174         .get_temp = tmp102_read_temp,
175 };
176
177 static int tmp102_probe(struct i2c_client *client,
178                                   const struct i2c_device_id *id)
179 {
180         struct device *dev = &client->dev;
181         struct device *hwmon_dev;
182         struct tmp102 *tmp102;
183         int status;
184
185         if (!i2c_check_functionality(client->adapter,
186                                      I2C_FUNC_SMBUS_WORD_DATA)) {
187                 dev_err(dev,
188                         "adapter doesn't support SMBus word transactions\n");
189                 return -ENODEV;
190         }
191
192         tmp102 = devm_kzalloc(dev, sizeof(*tmp102), GFP_KERNEL);
193         if (!tmp102)
194                 return -ENOMEM;
195
196         i2c_set_clientdata(client, tmp102);
197         tmp102->client = client;
198
199         status = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG);
200         if (status < 0) {
201                 dev_err(dev, "error reading config register\n");
202                 return status;
203         }
204         tmp102->config_orig = status;
205         status = i2c_smbus_write_word_swapped(client, TMP102_CONF_REG,
206                                               TMP102_CONFIG);
207         if (status < 0) {
208                 dev_err(dev, "error writing config register\n");
209                 goto fail_restore_config;
210         }
211         status = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG);
212         if (status < 0) {
213                 dev_err(dev, "error reading config register\n");
214                 goto fail_restore_config;
215         }
216         status &= ~TMP102_CONFIG_RD_ONLY;
217         if (status != TMP102_CONFIG) {
218                 dev_err(dev, "config settings did not stick\n");
219                 status = -ENODEV;
220                 goto fail_restore_config;
221         }
222         tmp102->last_update = jiffies;
223         /* Mark that we are not ready with data until conversion is complete */
224         tmp102->first_time = true;
225         mutex_init(&tmp102->lock);
226
227         hwmon_dev = hwmon_device_register_with_groups(dev, client->name,
228                                                       tmp102, tmp102_groups);
229         if (IS_ERR(hwmon_dev)) {
230                 dev_dbg(dev, "unable to register hwmon device\n");
231                 status = PTR_ERR(hwmon_dev);
232                 goto fail_restore_config;
233         }
234         tmp102->hwmon_dev = hwmon_dev;
235         tmp102->tz = thermal_zone_of_sensor_register(hwmon_dev, 0, hwmon_dev,
236                                                      &tmp102_of_thermal_ops);
237         if (IS_ERR(tmp102->tz))
238                 tmp102->tz = NULL;
239
240         dev_info(dev, "initialized\n");
241
242         return 0;
243
244 fail_restore_config:
245         i2c_smbus_write_word_swapped(client, TMP102_CONF_REG,
246                                      tmp102->config_orig);
247         return status;
248 }
249
250 static int tmp102_remove(struct i2c_client *client)
251 {
252         struct tmp102 *tmp102 = i2c_get_clientdata(client);
253
254         thermal_zone_of_sensor_unregister(tmp102->hwmon_dev, tmp102->tz);
255         hwmon_device_unregister(tmp102->hwmon_dev);
256
257         /* Stop monitoring if device was stopped originally */
258         if (tmp102->config_orig & TMP102_CONF_SD) {
259                 int config;
260
261                 config = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG);
262                 if (config >= 0)
263                         i2c_smbus_write_word_swapped(client, TMP102_CONF_REG,
264                                                      config | TMP102_CONF_SD);
265         }
266
267         return 0;
268 }
269
270 #ifdef CONFIG_PM_SLEEP
271 static int tmp102_suspend(struct device *dev)
272 {
273         struct i2c_client *client = to_i2c_client(dev);
274         int config;
275
276         config = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG);
277         if (config < 0)
278                 return config;
279
280         config |= TMP102_CONF_SD;
281         return i2c_smbus_write_word_swapped(client, TMP102_CONF_REG, config);
282 }
283
284 static int tmp102_resume(struct device *dev)
285 {
286         struct i2c_client *client = to_i2c_client(dev);
287         int config;
288
289         config = i2c_smbus_read_word_swapped(client, TMP102_CONF_REG);
290         if (config < 0)
291                 return config;
292
293         config &= ~TMP102_CONF_SD;
294         return i2c_smbus_write_word_swapped(client, TMP102_CONF_REG, config);
295 }
296 #endif /* CONFIG_PM */
297
298 static SIMPLE_DEV_PM_OPS(tmp102_dev_pm_ops, tmp102_suspend, tmp102_resume);
299
300 static const struct i2c_device_id tmp102_id[] = {
301         { "tmp102", 0 },
302         { }
303 };
304 MODULE_DEVICE_TABLE(i2c, tmp102_id);
305
306 static struct i2c_driver tmp102_driver = {
307         .driver.name    = DRIVER_NAME,
308         .driver.pm      = &tmp102_dev_pm_ops,
309         .probe          = tmp102_probe,
310         .remove         = tmp102_remove,
311         .id_table       = tmp102_id,
312 };
313
314 module_i2c_driver(tmp102_driver);
315
316 MODULE_AUTHOR("Steven King <sfking@fdwdc.com>");
317 MODULE_DESCRIPTION("Texas Instruments TMP102 temperature sensor driver");
318 MODULE_LICENSE("GPL");