1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Texas Instruments TMP108 SMBus temperature sensor driver
3 *
4 * Copyright (C) 2016 John Muir <john@jmuir.com>
5 */
6
7 #include <linux/bitfield.h>
8 #include <linux/delay.h>
9 #include <linux/device.h>
10 #include <linux/err.h>
11 #include <linux/hwmon.h>
12 #include <linux/module.h>
13 #include <linux/i2c.h>
14 #include <linux/i3c/device.h>
15 #include <linux/init.h>
16 #include <linux/jiffies.h>
17 #include <linux/regmap.h>
18 #include <linux/regulator/consumer.h>
19 #include <linux/slab.h>
20 #include <linux/util_macros.h>
21
22 #define DRIVER_NAME "tmp108"
23
24 #define TMP108_REG_TEMP 0x00
25 #define TMP108_REG_CONF 0x01
26 #define TMP108_REG_TLOW 0x02
27 #define TMP108_REG_THIGH 0x03
28
29 #define TMP108_TEMP_MIN_MC -50000 /* Minimum millicelcius. */
30 #define TMP108_TEMP_MAX_MC 127937 /* Maximum millicelcius. */
31
32 /* Configuration register bits.
33 * Note: these bit definitions are byte swapped.
34 */
35 #define TMP108_CONF_M0 0x0100 /* Sensor mode. */
36 #define TMP108_CONF_M1 0x0200
37 #define TMP108_CONF_TM 0x0400 /* Thermostat mode. */
38 #define TMP108_CONF_FL 0x0800 /* Watchdog flag - TLOW */
39 #define TMP108_CONF_FH 0x1000 /* Watchdog flag - THIGH */
40 #define TMP108_CONF_CR0 0x2000 /* Conversion rate. */
41 #define TMP108_CONF_CR1 0x4000
42 #define TMP108_CONF_ID 0x8000
43 #define TMP108_CONF_HYS0 0x0010 /* Hysteresis. */
44 #define TMP108_CONF_HYS1 0x0020
45 #define TMP108_CONF_POL 0x0080 /* Polarity of alert. */
46
47 /* Defaults set by the hardware upon reset. */
48 #define TMP108_CONF_DEFAULTS (TMP108_CONF_CR0 | TMP108_CONF_TM |\
49 TMP108_CONF_HYS0 | TMP108_CONF_M1)
50 /* These bits are read-only. */
51 #define TMP108_CONF_READ_ONLY (TMP108_CONF_FL | TMP108_CONF_FH |\
52 TMP108_CONF_ID)
53
54 #define TMP108_CONF_MODE_MASK (TMP108_CONF_M0|TMP108_CONF_M1)
55 #define TMP108_MODE_SHUTDOWN 0x0000
56 #define TMP108_MODE_ONE_SHOT TMP108_CONF_M0
57 #define TMP108_MODE_CONTINUOUS TMP108_CONF_M1 /* Default */
58 /* When M1 is set, M0 is ignored. */
59
60 #define TMP108_CONF_CONVRATE_MASK (TMP108_CONF_CR0|TMP108_CONF_CR1)
61 #define TMP108_CONVRATE_0P25HZ 0x0000
62 #define TMP108_CONVRATE_1HZ TMP108_CONF_CR0 /* Default */
63 #define TMP108_CONVRATE_4HZ TMP108_CONF_CR1
64 #define TMP108_CONVRATE_16HZ (TMP108_CONF_CR0|TMP108_CONF_CR1)
65
66 #define TMP108_CONF_HYSTERESIS_MASK (TMP108_CONF_HYS0|TMP108_CONF_HYS1)
67 #define TMP108_HYSTERESIS_0C 0x0000
68 #define TMP108_HYSTERESIS_1C TMP108_CONF_HYS0 /* Default */
69 #define TMP108_HYSTERESIS_2C TMP108_CONF_HYS1
70 #define TMP108_HYSTERESIS_4C (TMP108_CONF_HYS0|TMP108_CONF_HYS1)
71
72 #define TMP108_CONVERSION_TIME_MS 30 /* in milli-seconds */
73
74 #define TMP108_CONF_CR0_POS 13
75 #define TMP108_CONF_CR1_POS 14
76 #define TMP108_CONF_CONVRATE_FLD GENMASK(TMP108_CONF_CR1_POS, TMP108_CONF_CR0_POS)
77
78 struct tmp108 {
79 struct regmap *regmap;
80 u16 orig_config;
81 unsigned long ready_time;
82 const struct tmp108_params *params;
83 };
84
85 struct tmp108_params {
86 bool config_reg_16bits;
87 const u16 *sample_times;
88 size_t n_sample_times;
89 };
90
91 static const u16 p3t1035_sample_times[] = {4000, 1000, 250, 125};
92 static const u16 tmp108_sample_times[] = {4000, 1000, 250, 63};
93
94 static const struct tmp108_params p3t1035_data = {
95 .sample_times = p3t1035_sample_times,
96 .n_sample_times = ARRAY_SIZE(p3t1035_sample_times),
97 .config_reg_16bits = false,
98 };
99
100 static const struct tmp108_params tmp108_data = {
101 .sample_times = tmp108_sample_times,
102 .n_sample_times = ARRAY_SIZE(tmp108_sample_times),
103 .config_reg_16bits = true,
104 };
105
106 /* convert 12-bit TMP108 register value to milliCelsius */
tmp108_temp_reg_to_mC(s16 val)107 static inline int tmp108_temp_reg_to_mC(s16 val)
108 {
109 return (val & ~0x0f) * 1000 / 256;
110 }
111
112 /* convert milliCelsius to left adjusted 12-bit TMP108 register value */
tmp108_mC_to_temp_reg(int val)113 static inline u16 tmp108_mC_to_temp_reg(int val)
114 {
115 return (val * 256) / 1000;
116 }
117
tmp108_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * temp)118 static int tmp108_read(struct device *dev, enum hwmon_sensor_types type,
119 u32 attr, int channel, long *temp)
120 {
121 struct tmp108 *tmp108 = dev_get_drvdata(dev);
122 unsigned int regval;
123 int err, hyst;
124
125 if (type == hwmon_chip) {
126 if (attr == hwmon_chip_update_interval) {
127 err = regmap_read(tmp108->regmap, TMP108_REG_CONF,
128 ®val);
129 if (err < 0)
130 return err;
131 *temp = tmp108->params->sample_times[FIELD_GET(TMP108_CONF_CONVRATE_FLD,
132 regval)];
133 return 0;
134 }
135 return -EOPNOTSUPP;
136 }
137
138 switch (attr) {
139 case hwmon_temp_input:
140 /* Is it too early to return a conversion ? */
141 if (time_before(jiffies, tmp108->ready_time)) {
142 dev_dbg(dev, "%s: Conversion not ready yet..\n",
143 __func__);
144 return -EAGAIN;
145 }
146 err = regmap_read(tmp108->regmap, TMP108_REG_TEMP, ®val);
147 if (err < 0)
148 return err;
149 *temp = tmp108_temp_reg_to_mC(regval);
150 break;
151 case hwmon_temp_min:
152 case hwmon_temp_max:
153 err = regmap_read(tmp108->regmap, attr == hwmon_temp_min ?
154 TMP108_REG_TLOW : TMP108_REG_THIGH, ®val);
155 if (err < 0)
156 return err;
157 *temp = tmp108_temp_reg_to_mC(regval);
158 break;
159 case hwmon_temp_min_alarm:
160 case hwmon_temp_max_alarm:
161 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, ®val);
162 if (err < 0)
163 return err;
164 *temp = !!(regval & (attr == hwmon_temp_min_alarm ?
165 TMP108_CONF_FL : TMP108_CONF_FH));
166 break;
167 case hwmon_temp_min_hyst:
168 case hwmon_temp_max_hyst:
169 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, ®val);
170 if (err < 0)
171 return err;
172 switch (regval & TMP108_CONF_HYSTERESIS_MASK) {
173 case TMP108_HYSTERESIS_0C:
174 default:
175 hyst = 0;
176 break;
177 case TMP108_HYSTERESIS_1C:
178 hyst = 1000;
179 break;
180 case TMP108_HYSTERESIS_2C:
181 hyst = 2000;
182 break;
183 case TMP108_HYSTERESIS_4C:
184 hyst = 4000;
185 break;
186 }
187 err = regmap_read(tmp108->regmap, attr == hwmon_temp_min_hyst ?
188 TMP108_REG_TLOW : TMP108_REG_THIGH, ®val);
189 if (err < 0)
190 return err;
191 *temp = tmp108_temp_reg_to_mC(regval);
192 if (attr == hwmon_temp_min_hyst)
193 *temp += hyst;
194 else
195 *temp -= hyst;
196 break;
197 default:
198 return -EOPNOTSUPP;
199 }
200
201 return 0;
202 }
203
tmp108_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long temp)204 static int tmp108_write(struct device *dev, enum hwmon_sensor_types type,
205 u32 attr, int channel, long temp)
206 {
207 struct tmp108 *tmp108 = dev_get_drvdata(dev);
208 u32 regval, mask;
209 size_t len;
210 u8 index;
211 int err;
212
213 if (type == hwmon_chip) {
214 if (attr == hwmon_chip_update_interval) {
215 len = tmp108->params->n_sample_times;
216 index = find_closest_descending(temp, tmp108->params->sample_times, len);
217 return regmap_update_bits(tmp108->regmap,
218 TMP108_REG_CONF,
219 TMP108_CONF_CONVRATE_MASK,
220 FIELD_PREP(TMP108_CONF_CONVRATE_FLD, index));
221 }
222 return -EOPNOTSUPP;
223 }
224
225 switch (attr) {
226 case hwmon_temp_min:
227 case hwmon_temp_max:
228 temp = clamp_val(temp, TMP108_TEMP_MIN_MC, TMP108_TEMP_MAX_MC);
229 return regmap_write(tmp108->regmap,
230 attr == hwmon_temp_min ?
231 TMP108_REG_TLOW : TMP108_REG_THIGH,
232 tmp108_mC_to_temp_reg(temp));
233 case hwmon_temp_min_hyst:
234 case hwmon_temp_max_hyst:
235 temp = clamp_val(temp, TMP108_TEMP_MIN_MC, TMP108_TEMP_MAX_MC);
236 err = regmap_read(tmp108->regmap,
237 attr == hwmon_temp_min_hyst ?
238 TMP108_REG_TLOW : TMP108_REG_THIGH,
239 ®val);
240 if (err < 0)
241 return err;
242 if (attr == hwmon_temp_min_hyst)
243 temp -= tmp108_temp_reg_to_mC(regval);
244 else
245 temp = tmp108_temp_reg_to_mC(regval) - temp;
246 if (temp < 500)
247 mask = TMP108_HYSTERESIS_0C;
248 else if (temp < 1500)
249 mask = TMP108_HYSTERESIS_1C;
250 else if (temp < 3000)
251 mask = TMP108_HYSTERESIS_2C;
252 else
253 mask = TMP108_HYSTERESIS_4C;
254 return regmap_update_bits(tmp108->regmap, TMP108_REG_CONF,
255 TMP108_CONF_HYSTERESIS_MASK, mask);
256 default:
257 return -EOPNOTSUPP;
258 }
259 }
260
tmp108_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)261 static umode_t tmp108_is_visible(const void *data, enum hwmon_sensor_types type,
262 u32 attr, int channel)
263 {
264 const struct tmp108 *tmp108 = data;
265
266 if (type == hwmon_chip && attr == hwmon_chip_update_interval)
267 return 0644;
268
269 if (type != hwmon_temp)
270 return 0;
271
272 switch (attr) {
273 case hwmon_temp_input:
274 case hwmon_temp_min_alarm:
275 case hwmon_temp_max_alarm:
276 return 0444;
277 case hwmon_temp_min:
278 case hwmon_temp_max:
279 return 0644;
280 case hwmon_temp_min_hyst:
281 case hwmon_temp_max_hyst:
282 if (!tmp108->params->config_reg_16bits)
283 return 0;
284 return 0644;
285 default:
286 return 0;
287 }
288 }
289
290 static const struct hwmon_channel_info * const tmp108_info[] = {
291 HWMON_CHANNEL_INFO(chip,
292 HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL),
293 HWMON_CHANNEL_INFO(temp,
294 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
295 HWMON_T_MIN_HYST | HWMON_T_MAX_HYST |
296 HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM),
297 NULL
298 };
299
300 static const struct hwmon_ops tmp108_hwmon_ops = {
301 .is_visible = tmp108_is_visible,
302 .read = tmp108_read,
303 .write = tmp108_write,
304 };
305
306 static const struct hwmon_chip_info tmp108_chip_info = {
307 .ops = &tmp108_hwmon_ops,
308 .info = tmp108_info,
309 };
310
tmp108_restore_config(void * data)311 static void tmp108_restore_config(void *data)
312 {
313 struct tmp108 *tmp108 = data;
314
315 regmap_write(tmp108->regmap, TMP108_REG_CONF, tmp108->orig_config);
316 }
317
tmp108_is_writeable_reg(struct device * dev,unsigned int reg)318 static bool tmp108_is_writeable_reg(struct device *dev, unsigned int reg)
319 {
320 return reg != TMP108_REG_TEMP;
321 }
322
tmp108_is_volatile_reg(struct device * dev,unsigned int reg)323 static bool tmp108_is_volatile_reg(struct device *dev, unsigned int reg)
324 {
325 /* Configuration register must be volatile to enable FL and FH. */
326 return reg == TMP108_REG_TEMP || reg == TMP108_REG_CONF;
327 }
328
tmp108_i2c_reg_read(void * context,unsigned int reg,unsigned int * val)329 static int tmp108_i2c_reg_read(void *context, unsigned int reg, unsigned int *val)
330 {
331 struct i2c_client *client = context;
332 struct tmp108 *tmp108 = i2c_get_clientdata(client);
333 int ret;
334
335 if (reg == TMP108_REG_CONF && !tmp108->params->config_reg_16bits) {
336 ret = i2c_smbus_read_byte_data(client, TMP108_REG_CONF);
337 if (ret < 0)
338 return ret;
339 *val = ret << 8;
340 return 0;
341 }
342
343 ret = i2c_smbus_read_word_swapped(client, reg);
344 if (ret < 0)
345 return ret;
346 *val = ret;
347 return 0;
348 }
349
tmp108_i2c_reg_write(void * context,unsigned int reg,unsigned int val)350 static int tmp108_i2c_reg_write(void *context, unsigned int reg, unsigned int val)
351 {
352 struct i2c_client *client = context;
353 struct tmp108 *tmp108 = i2c_get_clientdata(client);
354
355 if (reg == TMP108_REG_CONF && !tmp108->params->config_reg_16bits)
356 return i2c_smbus_write_byte_data(client, reg, val >> 8);
357 return i2c_smbus_write_word_swapped(client, reg, val);
358 }
359
360 static const struct regmap_bus tmp108_i2c_regmap_bus = {
361 .reg_read = tmp108_i2c_reg_read,
362 .reg_write = tmp108_i2c_reg_write,
363 };
364
tmp108_i3c_reg_read(void * context,unsigned int reg,unsigned int * val)365 static int tmp108_i3c_reg_read(void *context, unsigned int reg, unsigned int *val)
366 {
367 struct i3c_device *i3cdev = context;
368 struct tmp108 *tmp108 = i3cdev_get_drvdata(i3cdev);
369 u8 reg_buf[1], val_buf[2];
370 struct i3c_xfer xfers[] = {
371 {
372 .rnw = false,
373 .len = 1,
374 .data.out = reg_buf,
375 },
376 {
377 .rnw = true,
378 .len = 2,
379 .data.in = val_buf,
380 },
381 };
382 int ret;
383
384 reg_buf[0] = reg;
385
386 if (reg == TMP108_REG_CONF && !tmp108->params->config_reg_16bits)
387 xfers[1].len--;
388
389 ret = i3c_device_do_xfers(i3cdev, xfers, 2, I3C_SDR);
390 if (ret < 0)
391 return ret;
392
393 *val = val_buf[0] << 8;
394 if (reg != TMP108_REG_CONF || tmp108->params->config_reg_16bits)
395 *val |= val_buf[1];
396
397 return 0;
398 }
399
tmp108_i3c_reg_write(void * context,unsigned int reg,unsigned int val)400 static int tmp108_i3c_reg_write(void *context, unsigned int reg, unsigned int val)
401 {
402 struct i3c_device *i3cdev = context;
403 struct tmp108 *tmp108 = i3cdev_get_drvdata(i3cdev);
404 u8 val_buf[3];
405 struct i3c_xfer xfers[] = {
406 {
407 .rnw = false,
408 .len = 3,
409 .data.out = val_buf,
410 },
411 };
412
413 val_buf[0] = reg;
414 val_buf[1] = (val >> 8) & 0xff;
415
416 if (reg == TMP108_REG_CONF && !tmp108->params->config_reg_16bits)
417 xfers[0].len--;
418 else
419 val_buf[2] = val & 0xff;
420
421 return i3c_device_do_xfers(i3cdev, xfers, 1, I3C_SDR);
422 }
423
424 static const struct regmap_bus tmp108_i3c_regmap_bus = {
425 .reg_read = tmp108_i3c_reg_read,
426 .reg_write = tmp108_i3c_reg_write,
427 };
428
429 static const struct regmap_config tmp108_regmap_config = {
430 .reg_bits = 8,
431 .val_bits = 16,
432 .max_register = TMP108_REG_THIGH,
433 .writeable_reg = tmp108_is_writeable_reg,
434 .volatile_reg = tmp108_is_volatile_reg,
435 .val_format_endian = REGMAP_ENDIAN_BIG,
436 .cache_type = REGCACHE_MAPLE,
437 .use_single_read = true,
438 .use_single_write = true,
439 };
440
tmp108_common_probe(struct device * dev,struct regmap * regmap,char * name,const struct tmp108_params * params)441 static int tmp108_common_probe(struct device *dev, struct regmap *regmap, char *name,
442 const struct tmp108_params *params)
443 {
444 struct device *hwmon_dev;
445 struct tmp108 *tmp108;
446 u32 config;
447 int err;
448
449 err = devm_regulator_get_enable(dev, "vcc");
450 if (err)
451 return dev_err_probe(dev, err, "Failed to enable regulator\n");
452
453 tmp108 = devm_kzalloc(dev, sizeof(*tmp108), GFP_KERNEL);
454 if (!tmp108)
455 return -ENOMEM;
456
457 dev_set_drvdata(dev, tmp108);
458 tmp108->regmap = regmap;
459 tmp108->params = params;
460
461 err = regmap_read(tmp108->regmap, TMP108_REG_CONF, &config);
462 if (err < 0) {
463 dev_err(dev, "error reading config register: %d", err);
464 return err;
465 }
466 tmp108->orig_config = config;
467
468 /* Only continuous mode is supported. */
469 config &= ~TMP108_CONF_MODE_MASK;
470 config |= TMP108_MODE_CONTINUOUS;
471 /* Only comparator mode is supported. */
472 config &= ~TMP108_CONF_TM;
473
474 err = regmap_write(tmp108->regmap, TMP108_REG_CONF, config);
475 if (err < 0) {
476 dev_err(dev, "error writing config register: %d", err);
477 return err;
478 }
479
480 tmp108->ready_time = jiffies;
481 if ((tmp108->orig_config & TMP108_CONF_MODE_MASK) ==
482 TMP108_MODE_SHUTDOWN)
483 tmp108->ready_time +=
484 msecs_to_jiffies(TMP108_CONVERSION_TIME_MS);
485
486 err = devm_add_action_or_reset(dev, tmp108_restore_config, tmp108);
487 if (err) {
488 dev_err(dev, "add action or reset failed: %d", err);
489 return err;
490 }
491
492 hwmon_dev = devm_hwmon_device_register_with_info(dev, name,
493 tmp108,
494 &tmp108_chip_info,
495 NULL);
496 return PTR_ERR_OR_ZERO(hwmon_dev);
497 }
498
tmp108_probe(struct i2c_client * client)499 static int tmp108_probe(struct i2c_client *client)
500 {
501 struct device *dev = &client->dev;
502 struct regmap *regmap;
503
504 if (!i2c_check_functionality(client->adapter,
505 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
506 return dev_err_probe(dev, -ENODEV,
507 "adapter doesn't support SMBus word transactions\n");
508
509 regmap = devm_regmap_init(dev, &tmp108_i2c_regmap_bus, client, &tmp108_regmap_config);
510 if (IS_ERR(regmap))
511 return dev_err_probe(dev, PTR_ERR(regmap), "regmap init failed");
512
513 return tmp108_common_probe(dev, regmap, client->name, i2c_get_match_data(client));
514 }
515
tmp108_suspend(struct device * dev)516 static int tmp108_suspend(struct device *dev)
517 {
518 struct tmp108 *tmp108 = dev_get_drvdata(dev);
519
520 return regmap_update_bits(tmp108->regmap, TMP108_REG_CONF,
521 TMP108_CONF_MODE_MASK, TMP108_MODE_SHUTDOWN);
522 }
523
tmp108_resume(struct device * dev)524 static int tmp108_resume(struct device *dev)
525 {
526 struct tmp108 *tmp108 = dev_get_drvdata(dev);
527 int err;
528
529 err = regmap_update_bits(tmp108->regmap, TMP108_REG_CONF,
530 TMP108_CONF_MODE_MASK, TMP108_MODE_CONTINUOUS);
531 tmp108->ready_time = jiffies +
532 msecs_to_jiffies(TMP108_CONVERSION_TIME_MS);
533 return err;
534 }
535
536 static DEFINE_SIMPLE_DEV_PM_OPS(tmp108_dev_pm_ops, tmp108_suspend, tmp108_resume);
537
538 static const struct i2c_device_id tmp108_i2c_ids[] = {
539 { .name = "p3t1035", .driver_data = (unsigned long)&p3t1035_data },
540 { .name = "p3t1085", .driver_data = (unsigned long)&tmp108_data },
541 { .name = "tmp108", .driver_data = (unsigned long)&tmp108_data },
542 { }
543 };
544 MODULE_DEVICE_TABLE(i2c, tmp108_i2c_ids);
545
546 static const struct of_device_id tmp108_of_ids[] = {
547 { .compatible = "nxp,p3t1035", .data = &p3t1035_data },
548 { .compatible = "nxp,p3t1085", .data = &tmp108_data },
549 { .compatible = "ti,tmp108", .data = &tmp108_data },
550 {}
551 };
552 MODULE_DEVICE_TABLE(of, tmp108_of_ids);
553
554 static struct i2c_driver tmp108_driver = {
555 .driver = {
556 .name = DRIVER_NAME,
557 .pm = pm_sleep_ptr(&tmp108_dev_pm_ops),
558 .of_match_table = tmp108_of_ids,
559 },
560 .probe = tmp108_probe,
561 .id_table = tmp108_i2c_ids,
562 };
563
564 static const struct i3c_device_id p3t1085_i3c_ids[] = {
565 I3C_DEVICE(0x011B, 0x1529, &tmp108_data),
566 I3C_DEVICE(0x011B, 0x152B, &p3t1035_data),
567 {}
568 };
569 MODULE_DEVICE_TABLE(i3c, p3t1085_i3c_ids);
570
p3t1085_i3c_probe(struct i3c_device * i3cdev)571 static int p3t1085_i3c_probe(struct i3c_device *i3cdev)
572 {
573 struct device *dev = i3cdev_to_dev(i3cdev);
574 struct regmap *regmap;
575 const struct i3c_device_id *id;
576
577 regmap = devm_regmap_init(dev, &tmp108_i3c_regmap_bus, i3cdev, &tmp108_regmap_config);
578 if (IS_ERR(regmap))
579 return dev_err_probe(dev, PTR_ERR(regmap),
580 "Failed to register i3c regmap\n");
581
582 id = i3c_device_match_id(i3cdev, p3t1085_i3c_ids);
583
584 return tmp108_common_probe(dev, regmap, "p3t1085_i3c", id->data);
585 }
586
587 static struct i3c_driver p3t1085_driver = {
588 .driver = {
589 .name = "p3t1085_i3c",
590 },
591 .probe = p3t1085_i3c_probe,
592 .id_table = p3t1085_i3c_ids,
593 };
594
595 module_i3c_i2c_driver(p3t1085_driver, &tmp108_driver)
596
597 MODULE_AUTHOR("John Muir <john@jmuir.com>");
598 MODULE_DESCRIPTION("Texas Instruments TMP108 temperature sensor driver");
599 MODULE_LICENSE("GPL");
600