Commit | Line | Data |
---|---|---|
251eb40f JC |
1 | /* |
2 | * sht15.c - support for the SHT15 Temperature and Humidity Sensor | |
3 | * | |
4 | * Copyright (c) 2009 Jonathan Cameron | |
5 | * | |
6 | * Copyright (c) 2007 Wouter Horre | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | * | |
12 | * Currently ignoring checksum on readings. | |
13 | * Default resolution only (14bit temp, 12bit humidity) | |
14 | * Ignoring battery status. | |
15 | * Heater not enabled. | |
16 | * Timings are all conservative. | |
17 | * | |
18 | * Data sheet available (1/2009) at | |
19 | * http://www.sensirion.ch/en/pdf/product_information/Datasheet-humidity-sensor-SHT1x.pdf | |
20 | * | |
21 | * Regulator supply name = vcc | |
22 | */ | |
23 | ||
24 | #include <linux/interrupt.h> | |
25 | #include <linux/irq.h> | |
26 | #include <linux/gpio.h> | |
27 | #include <linux/module.h> | |
28 | #include <linux/init.h> | |
29 | #include <linux/hwmon.h> | |
30 | #include <linux/hwmon-sysfs.h> | |
31 | #include <linux/mutex.h> | |
32 | #include <linux/platform_device.h> | |
33 | #include <linux/delay.h> | |
34 | #include <linux/jiffies.h> | |
35 | #include <linux/err.h> | |
36 | #include <linux/sht15.h> | |
37 | #include <linux/regulator/consumer.h> | |
38 | #include <asm/atomic.h> | |
39 | ||
40 | #define SHT15_MEASURE_TEMP 3 | |
41 | #define SHT15_MEASURE_RH 5 | |
42 | ||
43 | #define SHT15_READING_NOTHING 0 | |
44 | #define SHT15_READING_TEMP 1 | |
45 | #define SHT15_READING_HUMID 2 | |
46 | ||
47 | /* Min timings in nsecs */ | |
48 | #define SHT15_TSCKL 100 /* clock low */ | |
49 | #define SHT15_TSCKH 100 /* clock high */ | |
50 | #define SHT15_TSU 150 /* data setup time */ | |
51 | ||
52 | /** | |
53 | * struct sht15_temppair - elements of voltage dependant temp calc | |
54 | * @vdd: supply voltage in microvolts | |
55 | * @d1: see data sheet | |
56 | */ | |
57 | struct sht15_temppair { | |
58 | int vdd; /* microvolts */ | |
59 | int d1; | |
60 | }; | |
61 | ||
62 | /* Table 9 from data sheet - relates temperature calculation | |
63 | * to supply voltage. | |
64 | */ | |
65 | static const struct sht15_temppair temppoints[] = { | |
66 | { 2500000, -39400 }, | |
67 | { 3000000, -39600 }, | |
68 | { 3500000, -39700 }, | |
69 | { 4000000, -39800 }, | |
70 | { 5000000, -40100 }, | |
71 | }; | |
72 | ||
73 | /** | |
74 | * struct sht15_data - device instance specific data | |
75 | * @pdata: platform data (gpio's etc) | |
76 | * @read_work: bh of interrupt handler | |
77 | * @wait_queue: wait queue for getting values from device | |
78 | * @val_temp: last temperature value read from device | |
79 | * @val_humid: last humidity value read from device | |
80 | * @flag: status flag used to identify what the last request was | |
81 | * @valid: are the current stored values valid (start condition) | |
82 | * @last_updat: time of last update | |
83 | * @read_lock: mutex to ensure only one read in progress | |
84 | * at a time. | |
85 | * @dev: associate device structure | |
86 | * @hwmon_dev: device associated with hwmon subsystem | |
87 | * @reg: associated regulator (if specified) | |
88 | * @nb: notifier block to handle notifications of voltage changes | |
89 | * @supply_uV: local copy of supply voltage used to allow | |
90 | * use of regulator consumer if available | |
91 | * @supply_uV_valid: indicates that an updated value has not yet | |
92 | * been obtained from the regulator and so any calculations | |
93 | * based upon it will be invalid. | |
94 | * @update_supply_work: work struct that is used to update the supply_uV | |
95 | * @interrupt_handled: flag used to indicate a hander has been scheduled | |
96 | */ | |
97 | struct sht15_data { | |
98 | struct sht15_platform_data *pdata; | |
99 | struct work_struct read_work; | |
100 | wait_queue_head_t wait_queue; | |
101 | uint16_t val_temp; | |
102 | uint16_t val_humid; | |
103 | u8 flag; | |
104 | u8 valid; | |
105 | unsigned long last_updat; | |
106 | struct mutex read_lock; | |
107 | struct device *dev; | |
108 | struct device *hwmon_dev; | |
109 | struct regulator *reg; | |
110 | struct notifier_block nb; | |
111 | int supply_uV; | |
112 | int supply_uV_valid; | |
113 | struct work_struct update_supply_work; | |
114 | atomic_t interrupt_handled; | |
115 | }; | |
116 | ||
117 | /** | |
118 | * sht15_connection_reset() - reset the comms interface | |
119 | * @data: sht15 specific data | |
120 | * | |
121 | * This implements section 3.4 of the data sheet | |
122 | */ | |
123 | static void sht15_connection_reset(struct sht15_data *data) | |
124 | { | |
125 | int i; | |
126 | gpio_direction_output(data->pdata->gpio_data, 1); | |
127 | ndelay(SHT15_TSCKL); | |
128 | gpio_set_value(data->pdata->gpio_sck, 0); | |
129 | ndelay(SHT15_TSCKL); | |
130 | for (i = 0; i < 9; ++i) { | |
131 | gpio_set_value(data->pdata->gpio_sck, 1); | |
132 | ndelay(SHT15_TSCKH); | |
133 | gpio_set_value(data->pdata->gpio_sck, 0); | |
134 | ndelay(SHT15_TSCKL); | |
135 | } | |
136 | } | |
137 | /** | |
138 | * sht15_send_bit() - send an individual bit to the device | |
139 | * @data: device state data | |
140 | * @val: value of bit to be sent | |
141 | **/ | |
142 | static inline void sht15_send_bit(struct sht15_data *data, int val) | |
143 | { | |
144 | ||
145 | gpio_set_value(data->pdata->gpio_data, val); | |
146 | ndelay(SHT15_TSU); | |
147 | gpio_set_value(data->pdata->gpio_sck, 1); | |
148 | ndelay(SHT15_TSCKH); | |
149 | gpio_set_value(data->pdata->gpio_sck, 0); | |
150 | ndelay(SHT15_TSCKL); /* clock low time */ | |
151 | } | |
152 | ||
153 | /** | |
154 | * sht15_transmission_start() - specific sequence for new transmission | |
155 | * | |
156 | * @data: device state data | |
157 | * Timings for this are not documented on the data sheet, so very | |
158 | * conservative ones used in implementation. This implements | |
159 | * figure 12 on the data sheet. | |
160 | **/ | |
161 | static void sht15_transmission_start(struct sht15_data *data) | |
162 | { | |
163 | /* ensure data is high and output */ | |
164 | gpio_direction_output(data->pdata->gpio_data, 1); | |
165 | ndelay(SHT15_TSU); | |
166 | gpio_set_value(data->pdata->gpio_sck, 0); | |
167 | ndelay(SHT15_TSCKL); | |
168 | gpio_set_value(data->pdata->gpio_sck, 1); | |
169 | ndelay(SHT15_TSCKH); | |
170 | gpio_set_value(data->pdata->gpio_data, 0); | |
171 | ndelay(SHT15_TSU); | |
172 | gpio_set_value(data->pdata->gpio_sck, 0); | |
173 | ndelay(SHT15_TSCKL); | |
174 | gpio_set_value(data->pdata->gpio_sck, 1); | |
175 | ndelay(SHT15_TSCKH); | |
176 | gpio_set_value(data->pdata->gpio_data, 1); | |
177 | ndelay(SHT15_TSU); | |
178 | gpio_set_value(data->pdata->gpio_sck, 0); | |
179 | ndelay(SHT15_TSCKL); | |
180 | } | |
181 | /** | |
182 | * sht15_send_byte() - send a single byte to the device | |
183 | * @data: device state | |
184 | * @byte: value to be sent | |
185 | **/ | |
186 | static void sht15_send_byte(struct sht15_data *data, u8 byte) | |
187 | { | |
188 | int i; | |
189 | for (i = 0; i < 8; i++) { | |
190 | sht15_send_bit(data, !!(byte & 0x80)); | |
191 | byte <<= 1; | |
192 | } | |
193 | } | |
194 | /** | |
195 | * sht15_wait_for_response() - checks for ack from device | |
196 | * @data: device state | |
197 | **/ | |
198 | static int sht15_wait_for_response(struct sht15_data *data) | |
199 | { | |
200 | gpio_direction_input(data->pdata->gpio_data); | |
201 | gpio_set_value(data->pdata->gpio_sck, 1); | |
202 | ndelay(SHT15_TSCKH); | |
203 | if (gpio_get_value(data->pdata->gpio_data)) { | |
204 | gpio_set_value(data->pdata->gpio_sck, 0); | |
205 | dev_err(data->dev, "Command not acknowledged\n"); | |
206 | sht15_connection_reset(data); | |
207 | return -EIO; | |
208 | } | |
209 | gpio_set_value(data->pdata->gpio_sck, 0); | |
210 | ndelay(SHT15_TSCKL); | |
211 | return 0; | |
212 | } | |
213 | ||
214 | /** | |
215 | * sht15_send_cmd() - Sends a command to the device. | |
216 | * @data: device state | |
217 | * @cmd: command byte to be sent | |
218 | * | |
219 | * On entry, sck is output low, data is output pull high | |
220 | * and the interrupt disabled. | |
221 | **/ | |
222 | static int sht15_send_cmd(struct sht15_data *data, u8 cmd) | |
223 | { | |
224 | int ret = 0; | |
225 | sht15_transmission_start(data); | |
226 | sht15_send_byte(data, cmd); | |
227 | ret = sht15_wait_for_response(data); | |
228 | return ret; | |
229 | } | |
230 | /** | |
231 | * sht15_update_single_val() - get a new value from device | |
232 | * @data: device instance specific data | |
233 | * @command: command sent to request value | |
234 | * @timeout_msecs: timeout after which comms are assumed | |
235 | * to have failed are reset. | |
236 | **/ | |
237 | static inline int sht15_update_single_val(struct sht15_data *data, | |
238 | int command, | |
239 | int timeout_msecs) | |
240 | { | |
241 | int ret; | |
242 | ret = sht15_send_cmd(data, command); | |
243 | if (ret) | |
244 | return ret; | |
245 | ||
246 | gpio_direction_input(data->pdata->gpio_data); | |
247 | atomic_set(&data->interrupt_handled, 0); | |
248 | ||
249 | enable_irq(gpio_to_irq(data->pdata->gpio_data)); | |
250 | if (gpio_get_value(data->pdata->gpio_data) == 0) { | |
251 | disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data)); | |
252 | /* Only relevant if the interrupt hasn't occured. */ | |
253 | if (!atomic_read(&data->interrupt_handled)) | |
254 | schedule_work(&data->read_work); | |
255 | } | |
256 | ret = wait_event_timeout(data->wait_queue, | |
257 | (data->flag == SHT15_READING_NOTHING), | |
258 | msecs_to_jiffies(timeout_msecs)); | |
259 | if (ret == 0) {/* timeout occurred */ | |
24205e08 | 260 | disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data)); |
251eb40f JC |
261 | sht15_connection_reset(data); |
262 | return -ETIME; | |
263 | } | |
264 | return 0; | |
265 | } | |
266 | ||
267 | /** | |
268 | * sht15_update_vals() - get updated readings from device if too old | |
269 | * @data: device state | |
270 | **/ | |
271 | static int sht15_update_vals(struct sht15_data *data) | |
272 | { | |
273 | int ret = 0; | |
274 | int timeout = HZ; | |
275 | ||
276 | mutex_lock(&data->read_lock); | |
277 | if (time_after(jiffies, data->last_updat + timeout) | |
278 | || !data->valid) { | |
279 | data->flag = SHT15_READING_HUMID; | |
280 | ret = sht15_update_single_val(data, SHT15_MEASURE_RH, 160); | |
281 | if (ret) | |
282 | goto error_ret; | |
283 | data->flag = SHT15_READING_TEMP; | |
284 | ret = sht15_update_single_val(data, SHT15_MEASURE_TEMP, 400); | |
285 | if (ret) | |
286 | goto error_ret; | |
287 | data->valid = 1; | |
288 | data->last_updat = jiffies; | |
289 | } | |
290 | error_ret: | |
291 | mutex_unlock(&data->read_lock); | |
292 | ||
293 | return ret; | |
294 | } | |
295 | ||
296 | /** | |
297 | * sht15_calc_temp() - convert the raw reading to a temperature | |
298 | * @data: device state | |
299 | * | |
300 | * As per section 4.3 of the data sheet. | |
301 | **/ | |
302 | static inline int sht15_calc_temp(struct sht15_data *data) | |
303 | { | |
304 | int d1 = 0; | |
305 | int i; | |
306 | ||
307 | for (i = 1; i < ARRAY_SIZE(temppoints) - 1; i++) | |
308 | /* Find pointer to interpolate */ | |
309 | if (data->supply_uV > temppoints[i - 1].vdd) { | |
310 | d1 = (data->supply_uV/1000 - temppoints[i - 1].vdd) | |
311 | * (temppoints[i].d1 - temppoints[i - 1].d1) | |
312 | / (temppoints[i].vdd - temppoints[i - 1].vdd) | |
313 | + temppoints[i - 1].d1; | |
314 | break; | |
315 | } | |
316 | ||
317 | return data->val_temp*10 + d1; | |
318 | } | |
319 | ||
320 | /** | |
321 | * sht15_calc_humid() - using last temperature convert raw to humid | |
322 | * @data: device state | |
323 | * | |
324 | * This is the temperature compensated version as per section 4.2 of | |
325 | * the data sheet. | |
326 | **/ | |
327 | static inline int sht15_calc_humid(struct sht15_data *data) | |
328 | { | |
329 | int RHlinear; /* milli percent */ | |
330 | int temp = sht15_calc_temp(data); | |
331 | ||
332 | const int c1 = -4; | |
333 | const int c2 = 40500; /* x 10 ^ -6 */ | |
334 | const int c3 = 2800; /* x10 ^ -9 */ | |
335 | ||
336 | RHlinear = c1*1000 | |
337 | + c2 * data->val_humid/1000 | |
338 | + (data->val_humid * data->val_humid * c3)/1000000; | |
339 | return (temp - 25000) * (10000 + 800 * data->val_humid) | |
340 | / 1000000 + RHlinear; | |
341 | } | |
342 | ||
343 | static ssize_t sht15_show_temp(struct device *dev, | |
344 | struct device_attribute *attr, | |
345 | char *buf) | |
346 | { | |
347 | int ret; | |
348 | struct sht15_data *data = dev_get_drvdata(dev); | |
349 | ||
350 | /* Technically no need to read humidity as well */ | |
351 | ret = sht15_update_vals(data); | |
352 | ||
353 | return ret ? ret : sprintf(buf, "%d\n", | |
354 | sht15_calc_temp(data)); | |
355 | } | |
356 | ||
357 | static ssize_t sht15_show_humidity(struct device *dev, | |
358 | struct device_attribute *attr, | |
359 | char *buf) | |
360 | { | |
361 | int ret; | |
362 | struct sht15_data *data = dev_get_drvdata(dev); | |
363 | ||
364 | ret = sht15_update_vals(data); | |
365 | ||
366 | return ret ? ret : sprintf(buf, "%d\n", sht15_calc_humid(data)); | |
367 | ||
368 | }; | |
369 | static ssize_t show_name(struct device *dev, | |
370 | struct device_attribute *attr, | |
371 | char *buf) | |
372 | { | |
373 | struct platform_device *pdev = to_platform_device(dev); | |
374 | return sprintf(buf, "%s\n", pdev->name); | |
375 | } | |
376 | ||
377 | static SENSOR_DEVICE_ATTR(temp1_input, | |
378 | S_IRUGO, sht15_show_temp, | |
379 | NULL, 0); | |
380 | static SENSOR_DEVICE_ATTR(humidity1_input, | |
381 | S_IRUGO, sht15_show_humidity, | |
382 | NULL, 0); | |
383 | static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); | |
384 | static struct attribute *sht15_attrs[] = { | |
385 | &sensor_dev_attr_temp1_input.dev_attr.attr, | |
386 | &sensor_dev_attr_humidity1_input.dev_attr.attr, | |
387 | &dev_attr_name.attr, | |
388 | NULL, | |
389 | }; | |
390 | ||
391 | static const struct attribute_group sht15_attr_group = { | |
392 | .attrs = sht15_attrs, | |
393 | }; | |
394 | ||
395 | static irqreturn_t sht15_interrupt_fired(int irq, void *d) | |
396 | { | |
397 | struct sht15_data *data = d; | |
398 | /* First disable the interrupt */ | |
399 | disable_irq_nosync(irq); | |
400 | atomic_inc(&data->interrupt_handled); | |
401 | /* Then schedule a reading work struct */ | |
402 | if (data->flag != SHT15_READING_NOTHING) | |
403 | schedule_work(&data->read_work); | |
404 | return IRQ_HANDLED; | |
405 | } | |
406 | ||
407 | /* Each byte of data is acknowledged by pulling the data line | |
408 | * low for one clock pulse. | |
409 | */ | |
410 | static void sht15_ack(struct sht15_data *data) | |
411 | { | |
412 | gpio_direction_output(data->pdata->gpio_data, 0); | |
413 | ndelay(SHT15_TSU); | |
414 | gpio_set_value(data->pdata->gpio_sck, 1); | |
415 | ndelay(SHT15_TSU); | |
416 | gpio_set_value(data->pdata->gpio_sck, 0); | |
417 | ndelay(SHT15_TSU); | |
418 | gpio_set_value(data->pdata->gpio_data, 1); | |
419 | ||
420 | gpio_direction_input(data->pdata->gpio_data); | |
421 | } | |
422 | /** | |
423 | * sht15_end_transmission() - notify device of end of transmission | |
424 | * @data: device state | |
425 | * | |
426 | * This is basically a NAK. (single clock pulse, data high) | |
427 | **/ | |
428 | static void sht15_end_transmission(struct sht15_data *data) | |
429 | { | |
430 | gpio_direction_output(data->pdata->gpio_data, 1); | |
431 | ndelay(SHT15_TSU); | |
432 | gpio_set_value(data->pdata->gpio_sck, 1); | |
433 | ndelay(SHT15_TSCKH); | |
434 | gpio_set_value(data->pdata->gpio_sck, 0); | |
435 | ndelay(SHT15_TSCKL); | |
436 | } | |
437 | ||
438 | static void sht15_bh_read_data(struct work_struct *work_s) | |
439 | { | |
440 | int i; | |
441 | uint16_t val = 0; | |
442 | struct sht15_data *data | |
443 | = container_of(work_s, struct sht15_data, | |
444 | read_work); | |
445 | /* Firstly, verify the line is low */ | |
446 | if (gpio_get_value(data->pdata->gpio_data)) { | |
447 | /* If not, then start the interrupt again - care | |
448 | here as could have gone low in meantime so verify | |
449 | it hasn't! | |
450 | */ | |
451 | atomic_set(&data->interrupt_handled, 0); | |
452 | enable_irq(gpio_to_irq(data->pdata->gpio_data)); | |
453 | /* If still not occured or another handler has been scheduled */ | |
454 | if (gpio_get_value(data->pdata->gpio_data) | |
455 | || atomic_read(&data->interrupt_handled)) | |
456 | return; | |
457 | } | |
458 | /* Read the data back from the device */ | |
459 | for (i = 0; i < 16; ++i) { | |
460 | val <<= 1; | |
461 | gpio_set_value(data->pdata->gpio_sck, 1); | |
462 | ndelay(SHT15_TSCKH); | |
463 | val |= !!gpio_get_value(data->pdata->gpio_data); | |
464 | gpio_set_value(data->pdata->gpio_sck, 0); | |
465 | ndelay(SHT15_TSCKL); | |
466 | if (i == 7) | |
467 | sht15_ack(data); | |
468 | } | |
469 | /* Tell the device we are done */ | |
470 | sht15_end_transmission(data); | |
471 | ||
472 | switch (data->flag) { | |
473 | case SHT15_READING_TEMP: | |
474 | data->val_temp = val; | |
475 | break; | |
476 | case SHT15_READING_HUMID: | |
477 | data->val_humid = val; | |
478 | break; | |
479 | } | |
480 | ||
481 | data->flag = SHT15_READING_NOTHING; | |
482 | wake_up(&data->wait_queue); | |
483 | } | |
484 | ||
485 | static void sht15_update_voltage(struct work_struct *work_s) | |
486 | { | |
487 | struct sht15_data *data | |
488 | = container_of(work_s, struct sht15_data, | |
489 | update_supply_work); | |
490 | data->supply_uV = regulator_get_voltage(data->reg); | |
491 | } | |
492 | ||
493 | /** | |
494 | * sht15_invalidate_voltage() - mark supply voltage invalid when notified by reg | |
495 | * @nb: associated notification structure | |
496 | * @event: voltage regulator state change event code | |
497 | * @ignored: function parameter - ignored here | |
498 | * | |
499 | * Note that as the notification code holds the regulator lock, we have | |
500 | * to schedule an update of the supply voltage rather than getting it directly. | |
501 | **/ | |
502 | static int sht15_invalidate_voltage(struct notifier_block *nb, | |
503 | unsigned long event, | |
504 | void *ignored) | |
505 | { | |
506 | struct sht15_data *data = container_of(nb, struct sht15_data, nb); | |
507 | ||
508 | if (event == REGULATOR_EVENT_VOLTAGE_CHANGE) | |
509 | data->supply_uV_valid = false; | |
510 | schedule_work(&data->update_supply_work); | |
511 | ||
512 | return NOTIFY_OK; | |
513 | } | |
514 | ||
515 | static int __devinit sht15_probe(struct platform_device *pdev) | |
516 | { | |
517 | int ret = 0; | |
518 | struct sht15_data *data = kzalloc(sizeof(*data), GFP_KERNEL); | |
519 | ||
520 | if (!data) { | |
521 | ret = -ENOMEM; | |
522 | dev_err(&pdev->dev, "kzalloc failed"); | |
523 | goto error_ret; | |
524 | } | |
525 | ||
526 | INIT_WORK(&data->read_work, sht15_bh_read_data); | |
527 | INIT_WORK(&data->update_supply_work, sht15_update_voltage); | |
528 | platform_set_drvdata(pdev, data); | |
529 | mutex_init(&data->read_lock); | |
530 | data->dev = &pdev->dev; | |
531 | init_waitqueue_head(&data->wait_queue); | |
532 | ||
533 | if (pdev->dev.platform_data == NULL) { | |
534 | dev_err(&pdev->dev, "no platform data supplied"); | |
535 | goto err_free_data; | |
536 | } | |
537 | data->pdata = pdev->dev.platform_data; | |
538 | data->supply_uV = data->pdata->supply_mv*1000; | |
539 | ||
540 | /* If a regulator is available, query what the supply voltage actually is!*/ | |
541 | data->reg = regulator_get(data->dev, "vcc"); | |
542 | if (!IS_ERR(data->reg)) { | |
543 | data->supply_uV = regulator_get_voltage(data->reg); | |
544 | regulator_enable(data->reg); | |
545 | /* setup a notifier block to update this if another device | |
546 | * causes the voltage to change */ | |
547 | data->nb.notifier_call = &sht15_invalidate_voltage; | |
548 | ret = regulator_register_notifier(data->reg, &data->nb); | |
549 | } | |
550 | /* Try requesting the GPIOs */ | |
551 | ret = gpio_request(data->pdata->gpio_sck, "SHT15 sck"); | |
552 | if (ret) { | |
553 | dev_err(&pdev->dev, "gpio request failed"); | |
554 | goto err_free_data; | |
555 | } | |
556 | gpio_direction_output(data->pdata->gpio_sck, 0); | |
557 | ret = gpio_request(data->pdata->gpio_data, "SHT15 data"); | |
558 | if (ret) { | |
559 | dev_err(&pdev->dev, "gpio request failed"); | |
560 | goto err_release_gpio_sck; | |
561 | } | |
562 | ret = sysfs_create_group(&pdev->dev.kobj, &sht15_attr_group); | |
563 | if (ret) { | |
564 | dev_err(&pdev->dev, "sysfs create failed"); | |
565 | goto err_free_data; | |
566 | } | |
567 | ||
568 | ret = request_irq(gpio_to_irq(data->pdata->gpio_data), | |
569 | sht15_interrupt_fired, | |
570 | IRQF_TRIGGER_FALLING, | |
571 | "sht15 data", | |
572 | data); | |
573 | if (ret) { | |
574 | dev_err(&pdev->dev, "failed to get irq for data line"); | |
575 | goto err_release_gpio_data; | |
576 | } | |
577 | disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data)); | |
578 | sht15_connection_reset(data); | |
579 | sht15_send_cmd(data, 0x1E); | |
580 | ||
581 | data->hwmon_dev = hwmon_device_register(data->dev); | |
582 | if (IS_ERR(data->hwmon_dev)) { | |
583 | ret = PTR_ERR(data->hwmon_dev); | |
584 | goto err_release_gpio_data; | |
585 | } | |
586 | return 0; | |
587 | ||
588 | err_release_gpio_data: | |
589 | gpio_free(data->pdata->gpio_data); | |
590 | err_release_gpio_sck: | |
591 | gpio_free(data->pdata->gpio_sck); | |
592 | err_free_data: | |
593 | kfree(data); | |
594 | error_ret: | |
595 | ||
596 | return ret; | |
597 | } | |
598 | ||
599 | static int __devexit sht15_remove(struct platform_device *pdev) | |
600 | { | |
601 | struct sht15_data *data = platform_get_drvdata(pdev); | |
602 | ||
603 | /* Make sure any reads from the device are done and | |
604 | * prevent new ones beginnning */ | |
605 | mutex_lock(&data->read_lock); | |
606 | hwmon_device_unregister(data->hwmon_dev); | |
607 | sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group); | |
608 | if (!IS_ERR(data->reg)) { | |
609 | regulator_unregister_notifier(data->reg, &data->nb); | |
610 | regulator_disable(data->reg); | |
611 | regulator_put(data->reg); | |
612 | } | |
613 | ||
614 | free_irq(gpio_to_irq(data->pdata->gpio_data), data); | |
615 | gpio_free(data->pdata->gpio_data); | |
616 | gpio_free(data->pdata->gpio_sck); | |
617 | mutex_unlock(&data->read_lock); | |
618 | kfree(data); | |
619 | return 0; | |
620 | } | |
621 | ||
622 | ||
623 | static struct platform_driver sht_drivers[] = { | |
624 | { | |
625 | .driver = { | |
626 | .name = "sht10", | |
627 | .owner = THIS_MODULE, | |
628 | }, | |
629 | .probe = sht15_probe, | |
cd659fd0 | 630 | .remove = __devexit_p(sht15_remove), |
251eb40f JC |
631 | }, { |
632 | .driver = { | |
633 | .name = "sht11", | |
634 | .owner = THIS_MODULE, | |
635 | }, | |
636 | .probe = sht15_probe, | |
cd659fd0 | 637 | .remove = __devexit_p(sht15_remove), |
251eb40f JC |
638 | }, { |
639 | .driver = { | |
640 | .name = "sht15", | |
641 | .owner = THIS_MODULE, | |
642 | }, | |
643 | .probe = sht15_probe, | |
cd659fd0 | 644 | .remove = __devexit_p(sht15_remove), |
251eb40f JC |
645 | }, { |
646 | .driver = { | |
647 | .name = "sht71", | |
648 | .owner = THIS_MODULE, | |
649 | }, | |
650 | .probe = sht15_probe, | |
cd659fd0 | 651 | .remove = __devexit_p(sht15_remove), |
251eb40f JC |
652 | }, { |
653 | .driver = { | |
654 | .name = "sht75", | |
655 | .owner = THIS_MODULE, | |
656 | }, | |
657 | .probe = sht15_probe, | |
cd659fd0 | 658 | .remove = __devexit_p(sht15_remove), |
251eb40f JC |
659 | }, |
660 | }; | |
661 | ||
662 | ||
663 | static int __init sht15_init(void) | |
664 | { | |
665 | int ret; | |
666 | int i; | |
667 | ||
668 | for (i = 0; i < ARRAY_SIZE(sht_drivers); i++) { | |
669 | ret = platform_driver_register(&sht_drivers[i]); | |
670 | if (ret) | |
671 | goto error_unreg; | |
672 | } | |
673 | ||
674 | return 0; | |
675 | ||
676 | error_unreg: | |
677 | while (--i >= 0) | |
678 | platform_driver_unregister(&sht_drivers[i]); | |
679 | ||
680 | return ret; | |
681 | } | |
682 | module_init(sht15_init); | |
683 | ||
684 | static void __exit sht15_exit(void) | |
685 | { | |
686 | int i; | |
687 | for (i = ARRAY_SIZE(sht_drivers) - 1; i >= 0; i--) | |
688 | platform_driver_unregister(&sht_drivers[i]); | |
689 | } | |
690 | module_exit(sht15_exit); | |
691 | ||
692 | MODULE_LICENSE("GPL"); |