drivers/hwmon/sht15.c

45 #define SHT15_TSU			150	/* (nsecs) data setup time */
67  * @d1:		see data sheet
120  * struct sht15_data - device instance specific data
122  * @data:		data GPIO line
129  * @checksumming:	flag used to enable the data validation with CRC.
151 	struct gpio_desc		*data;
177  * @data:	sht15 specific data.
178  * @value:	sht15 retrieved data.
179  * @len:	Length of retrieved data
183 static u8 sht15_crc8(struct sht15_data *data,
187 	u8 crc = bitrev8(data->val_status & 0x0F);
199  * @data:	sht15 specific data
201  * This implements section 3.4 of the data sheet
203 static int sht15_connection_reset(struct sht15_data *data)
207 	err = gpiod_direction_output(data->data, 1);
211 	gpiod_set_value(data->sck, 0);
214 		gpiod_set_value(data->sck, 1);
216 		gpiod_set_value(data->sck, 0);
224  * @data:	device state data
227 static inline void sht15_send_bit(struct sht15_data *data, int val)
229 	gpiod_set_value(data->data, val);
231 	gpiod_set_value(data->sck, 1);
233 	gpiod_set_value(data->sck, 0);
239  * @data:	device state data
241  * Timings for this are not documented on the data sheet, so very
243  * figure 12 on the data sheet.
245 static int sht15_transmission_start(struct sht15_data *data)
249 	/* ensure data is high and output */
250 	err = gpiod_direction_output(data->data, 1);
254 	gpiod_set_value(data->sck, 0);
256 	gpiod_set_value(data->sck, 1);
258 	gpiod_set_value(data->data, 0);
260 	gpiod_set_value(data->sck, 0);
262 	gpiod_set_value(data->sck, 1);
264 	gpiod_set_value(data->data, 1);
266 	gpiod_set_value(data->sck, 0);
273  * @data:	device state
276 static void sht15_send_byte(struct sht15_data *data, u8 byte)
281 		sht15_send_bit(data, !!(byte & 0x80));
288  * @data:	device state
290 static int sht15_wait_for_response(struct sht15_data *data)
294 	err = gpiod_direction_input(data->data);
297 	gpiod_set_value(data->sck, 1);
299 	if (gpiod_get_value(data->data)) {
300 		gpiod_set_value(data->sck, 0);
301 		dev_err(data->dev, "Command not acknowledged\n");
302 		err = sht15_connection_reset(data);
307 	gpiod_set_value(data->sck, 0);
314  * @data:	device state
317  * On entry, sck is output low, data is output pull high
320 static int sht15_send_cmd(struct sht15_data *data, u8 cmd)
324 	err = sht15_transmission_start(data);
327 	sht15_send_byte(data, cmd);
328 	return sht15_wait_for_response(data);
333  * @data:	sht15 specific data.
337 static int sht15_soft_reset(struct sht15_data *data)
341 	ret = sht15_send_cmd(data, SHT15_SOFT_RESET);
346 	data->val_status = 0;
353  * @data:	sht15 specific data.
355  * Each byte of data is acknowledged by pulling the data line
358 static int sht15_ack(struct sht15_data *data)
362 	err = gpiod_direction_output(data->data, 0);
366 	gpiod_set_value(data->sck, 1);
368 	gpiod_set_value(data->sck, 0);
370 	gpiod_set_value(data->data, 1);
372 	return gpiod_direction_input(data->data);
377  * @data:	device state.
379  * This is basically a NAK (single clock pulse, data high).
381 static int sht15_end_transmission(struct sht15_data *data)
385 	err = gpiod_direction_output(data->data, 1);
389 	gpiod_set_value(data->sck, 1);
391 	gpiod_set_value(data->sck, 0);
398  * @data:	device state.
400 static u8 sht15_read_byte(struct sht15_data *data)
407 		gpiod_set_value(data->sck, 1);
409 		byte |= !!gpiod_get_value(data->data);
410 		gpiod_set_value(data->sck, 0);
418  * @data:	sht15 specific data.
423 static int sht15_send_status(struct sht15_data *data, u8 status)
427 	err = sht15_send_cmd(data, SHT15_WRITE_STATUS);
430 	err = gpiod_direction_output(data->data, 1);
434 	sht15_send_byte(data, status);
435 	err = sht15_wait_for_response(data);
439 	data->val_status = status;
445  * @data:	device instance specific data.
449 static int sht15_update_status(struct sht15_data *data)
458 	mutex_lock(&data->read_lock);
459 	if (time_after(jiffies, data->last_status + timeout)
460 			|| !data->status_valid) {
461 		ret = sht15_send_cmd(data, SHT15_READ_STATUS);
464 		status = sht15_read_byte(data);
466 		if (data->checksumming) {
467 			sht15_ack(data);
468 			dev_checksum = bitrev8(sht15_read_byte(data));
471 			data->checksum_ok = (sht15_crc8(data, checksum_vals, 2)
475 		ret = sht15_end_transmission(data);
480 		 * Perform checksum validation on the received data.
484 		if (data->checksumming && !data->checksum_ok) {
485 			previous_config = data->val_status & 0x07;
486 			ret = sht15_soft_reset(data);
490 				ret = sht15_send_status(data, previous_config);
492 					dev_err(data->dev,
502 		data->val_status = status;
503 		data->status_valid = true;
504 		data->last_status = jiffies;
508 	mutex_unlock(&data->read_lock);
514  * @data:		device instance specific data
519 static int sht15_measurement(struct sht15_data *data,
526 	ret = sht15_send_cmd(data, command);
530 	ret = gpiod_direction_input(data->data);
533 	atomic_set(&data->interrupt_handled, 0);
535 	enable_irq(gpiod_to_irq(data->data));
536 	if (gpiod_get_value(data->data) == 0) {
537 		disable_irq_nosync(gpiod_to_irq(data->data));
539 		if (!atomic_read(&data->interrupt_handled))
540 			schedule_work(&data->read_work);
542 	ret = wait_event_timeout(data->wait_queue,
543 				 (data->state == SHT15_READING_NOTHING),
545 	if (data->state != SHT15_READING_NOTHING) { /* I/O error occurred */
546 		data->state = SHT15_READING_NOTHING;
549 		disable_irq_nosync(gpiod_to_irq(data->data));
550 		ret = sht15_connection_reset(data);
557 	 *  Perform checksum validation on the received data.
561 	if (data->checksumming && !data->checksum_ok) {
562 		previous_config = data->val_status & 0x07;
563 		ret = sht15_soft_reset(data);
567 			ret = sht15_send_status(data, previous_config);
569 				dev_err(data->dev,
583  * @data:	device state
585 static int sht15_update_measurements(struct sht15_data *data)
590 	mutex_lock(&data->read_lock);
591 	if (time_after(jiffies, data->last_measurement + timeout)
592 	    || !data->measurements_valid) {
593 		data->state = SHT15_READING_HUMID;
594 		ret = sht15_measurement(data, SHT15_MEASURE_RH, 160);
597 		data->state = SHT15_READING_TEMP;
598 		ret = sht15_measurement(data, SHT15_MEASURE_TEMP, 400);
601 		data->measurements_valid = true;
602 		data->last_measurement = jiffies;
606 	mutex_unlock(&data->read_lock);
612  * @data:	device state
614  * As per section 4.3 of the data sheet.
616 static inline int sht15_calc_temp(struct sht15_data *data)
619 	int d2 = (data->val_status & SHT15_STATUS_LOW_RESOLUTION) ? 40 : 10;
624 		if (data->supply_uv > temppoints[i - 1].vdd) {
625 			d1 = (data->supply_uv - temppoints[i - 1].vdd)
632 	return data->val_temp * d2 + d1;
637  * @data:	device state
640  * the data sheet.
645 static inline int sht15_calc_humid(struct sht15_data *data)
648 	int temp = sht15_calc_temp(data);
653 	if (data->val_status & SHT15_STATUS_LOW_RESOLUTION) {
664 		+ c2 * data->val_humid / 1000
665 		+ (data->val_humid * data->val_humid * c3) / 10000;
666 	return (temp - 25000) * (10000 + t2 * data->val_humid)
684 	struct sht15_data *data = dev_get_drvdata(dev);
687 	ret = sht15_update_status(data);
689 	return ret ? ret : sprintf(buf, "%d\n", !!(data->val_status & bit));
697  * @count:	length of the data.
707 	struct sht15_data *data = dev_get_drvdata(dev);
714 	mutex_lock(&data->read_lock);
715 	status = data->val_status & 0x07;
721 	ret = sht15_send_status(data, status);
722 	mutex_unlock(&data->read_lock);
740 	struct sht15_data *data = dev_get_drvdata(dev);
743 	ret = sht15_update_measurements(data);
746 				   sht15_calc_temp(data));
762 	struct sht15_data *data = dev_get_drvdata(dev);
764 	ret = sht15_update_measurements(data);
766 	return ret ? ret : sprintf(buf, "%d\n", sht15_calc_humid(data));
801 	struct sht15_data *data = d;
805 	atomic_inc(&data->interrupt_handled);
807 	if (data->state != SHT15_READING_NOTHING)
808 		schedule_work(&data->read_work);
817 	struct sht15_data *data
822 	if (gpiod_get_value(data->data)) {
827 		atomic_set(&data->interrupt_handled, 0);
828 		enable_irq(gpiod_to_irq(data->data));
830 		if (gpiod_get_value(data->data)
831 		    || atomic_read(&data->interrupt_handled))
835 	/* Read the data back from the device */
836 	val = sht15_read_byte(data);
838 	if (sht15_ack(data))
840 	val |= sht15_read_byte(data);
842 	if (data->checksumming) {
847 		if (sht15_ack(data))
849 		dev_checksum = bitrev8(sht15_read_byte(data));
850 		checksum_vals[0] = (data->state == SHT15_READING_TEMP) ?
854 		data->checksum_ok
855 			= (sht15_crc8(data, checksum_vals, 3) == dev_checksum);
859 	if (sht15_end_transmission(data))
862 	switch (data->state) {
864 		data->val_temp = val;
867 		data->val_humid = val;
873 	data->state = SHT15_READING_NOTHING;
875 	wake_up(&data->wait_queue);
880 	struct sht15_data *data
883 	data->supply_uv = regulator_get_voltage(data->reg);
899 	struct sht15_data *data = container_of(nb, struct sht15_data, nb);
902 		data->supply_uv_valid = false;
903 	schedule_work(&data->update_supply_work);
919 	struct sht15_data *data;
921 	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
922 	if (!data)
925 	INIT_WORK(&data->read_work, sht15_bh_read_data);
926 	INIT_WORK(&data->update_supply_work, sht15_update_voltage);
927 	platform_set_drvdata(pdev, data);
928 	mutex_init(&data->read_lock);
929 	data->dev = &pdev->dev;
930 	init_waitqueue_head(&data->wait_queue);
936 	data->reg = devm_regulator_get_optional(data->dev, "vcc");
937 	if (!IS_ERR(data->reg)) {
940 		voltage = regulator_get_voltage(data->reg);
942 			data->supply_uv = voltage;
944 		ret = regulator_enable(data->reg);
955 		data->nb.notifier_call = &sht15_invalidate_voltage;
956 		ret = regulator_register_notifier(data->reg, &data->nb);
960 			regulator_disable(data->reg);
966 	data->sck = devm_gpiod_get(&pdev->dev, "clk", GPIOD_OUT_LOW);
967 	if (IS_ERR(data->sck)) {
968 		ret = PTR_ERR(data->sck);
972 	data->data = devm_gpiod_get(&pdev->dev, "data", GPIOD_IN);
973 	if (IS_ERR(data->data)) {
974 		ret = PTR_ERR(data->data);
975 		dev_err(&pdev->dev, "data line GPIO request failed\n");
979 	ret = devm_request_irq(&pdev->dev, gpiod_to_irq(data->data),
982 			       "sht15 data",
983 			       data);
985 		dev_err(&pdev->dev, "failed to get irq for data line\n");
988 	disable_irq_nosync(gpiod_to_irq(data->data));
989 	ret = sht15_connection_reset(data);
992 	ret = sht15_soft_reset(data);
1002 	data->hwmon_dev = hwmon_device_register(data->dev);
1003 	if (IS_ERR(data->hwmon_dev)) {
1004 		ret = PTR_ERR(data->hwmon_dev);
1013 	if (!IS_ERR(data->reg)) {
1014 		regulator_unregister_notifier(data->reg, &data->nb);
1015 		regulator_disable(data->reg);
1022 	struct sht15_data *data = platform_get_drvdata(pdev);
1025 	hwmon_device_unregister(data->hwmon_dev);
1028 	ret = sht15_soft_reset(data);
1032 	if (!IS_ERR(data->reg)) {
1033 		regulator_unregister_notifier(data->reg, &data->nb);
1034 		regulator_disable(data->reg);