/* * sht15.c - support for the SHT15 Temperature and Humidity Sensor * * Portions Copyright (c) 2010-2012 Savoir-faire Linux Inc. * Jerome Oufella * Vivien Didelot * * Copyright (c) 2009 Jonathan Cameron * * Copyright (c) 2007 Wouter Horre * * 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. * * For further information, see the Documentation/hwmon/sht15 file. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Commands */ #define SHT15_MEASURE_TEMP 0x03 #define SHT15_MEASURE_RH 0x05 #define SHT15_WRITE_STATUS 0x06 #define SHT15_READ_STATUS 0x07 #define SHT15_SOFT_RESET 0x1E /* Min timings */ #define SHT15_TSCKL 100 /* (nsecs) clock low */ #define SHT15_TSCKH 100 /* (nsecs) clock high */ #define SHT15_TSU 150 /* (nsecs) data setup time */ #define SHT15_TSRST 11 /* (msecs) soft reset time */ /* Status Register Bits */ #define SHT15_STATUS_LOW_RESOLUTION 0x01 #define SHT15_STATUS_NO_OTP_RELOAD 0x02 #define SHT15_STATUS_HEATER 0x04 #define SHT15_STATUS_LOW_BATTERY 0x40 /* List of supported chips */ enum sht15_chips { sht10, sht11, sht15, sht71, sht75 }; /* Actions the driver may be doing */ enum sht15_state { SHT15_READING_NOTHING, SHT15_READING_TEMP, SHT15_READING_HUMID }; /** * struct sht15_temppair - elements of voltage dependent temp calc * @vdd: supply voltage in microvolts * @d1: see data sheet */ struct sht15_temppair { int vdd; /* microvolts */ int d1; }; /* Table 9 from datasheet - relates temperature calculation to supply voltage */ static const struct sht15_temppair temppoints[] = { { 2500000, -39400 }, { 3000000, -39600 }, { 3500000, -39700 }, { 4000000, -39800 }, { 5000000, -40100 }, }; /* Table from CRC datasheet, section 2.4 */ static const u8 sht15_crc8_table[] = { 0, 49, 98, 83, 196, 245, 166, 151, 185, 136, 219, 234, 125, 76, 31, 46, 67, 114, 33, 16, 135, 182, 229, 212, 250, 203, 152, 169, 62, 15, 92, 109, 134, 183, 228, 213, 66, 115, 32, 17, 63, 14, 93, 108, 251, 202, 153, 168, 197, 244, 167, 150, 1, 48, 99, 82, 124, 77, 30, 47, 184, 137, 218, 235, 61, 12, 95, 110, 249, 200, 155, 170, 132, 181, 230, 215, 64, 113, 34, 19, 126, 79, 28, 45, 186, 139, 216, 233, 199, 246, 165, 148, 3, 50, 97, 80, 187, 138, 217, 232, 127, 78, 29, 44, 2, 51, 96, 81, 198, 247, 164, 149, 248, 201, 154, 171, 60, 13, 94, 111, 65, 112, 35, 18, 133, 180, 231, 214, 122, 75, 24, 41, 190, 143, 220, 237, 195, 242, 161, 144, 7, 54, 101, 84, 57, 8, 91, 106, 253, 204, 159, 174, 128, 177, 226, 211, 68, 117, 38, 23, 252, 205, 158, 175, 56, 9, 90, 107, 69, 116, 39, 22, 129, 176, 227, 210, 191, 142, 221, 236, 123, 74, 25, 40, 6, 55, 100, 85, 194, 243, 160, 145, 71, 118, 37, 20, 131, 178, 225, 208, 254, 207, 156, 173, 58, 11, 88, 105, 4, 53, 102, 87, 192, 241, 162, 147, 189, 140, 223, 238, 121, 72, 27, 42, 193, 240, 163, 146, 5, 52, 103, 86, 120, 73, 26, 43, 188, 141, 222, 239, 130, 179, 224, 209, 70, 119, 36, 21, 59, 10, 89, 104, 255, 206, 157, 172 }; /** * struct sht15_data - device instance specific data * @pdata: platform data (gpio's etc). * @read_work: bh of interrupt handler. * @wait_queue: wait queue for getting values from device. * @val_temp: last temperature value read from device. * @val_humid: last humidity value read from device. * @val_status: last status register value read from device. * @checksum_ok: last value read from the device passed CRC validation. * @checksumming: flag used to enable the data validation with CRC. * @state: state identifying the action the driver is doing. * @measurements_valid: are the current stored measures valid (start condition). * @status_valid: is the current stored status valid (start condition). * @last_measurement: time of last measure. * @last_status: time of last status reading. * @read_lock: mutex to ensure only one read in progress at a time. * @dev: associate device structure. * @hwmon_dev: device associated with hwmon subsystem. * @reg: associated regulator (if specified). * @nb: notifier block to handle notifications of voltage * changes. * @supply_uv: local copy of supply voltage used to allow use of * regulator consumer if available. * @supply_uv_valid: indicates that an updated value has not yet been * obtained from the regulator and so any calculations * based upon it will be invalid. * @update_supply_work: work struct that is used to update the supply_uv. * @interrupt_handled: flag used to indicate a handler has been scheduled. */ struct sht15_data { struct sht15_platform_data *pdata; struct work_struct read_work; wait_queue_head_t wait_queue; uint16_t val_temp; uint16_t val_humid; u8 val_status; bool checksum_ok; bool checksumming; enum sht15_state state; bool measurements_valid; bool status_valid; unsigned long last_measurement; unsigned long last_status; struct mutex read_lock; struct device *dev; struct device *hwmon_dev; struct regulator *reg; struct notifier_block nb; int supply_uv; bool supply_uv_valid; struct work_struct update_supply_work; atomic_t interrupt_handled; }; /** * sht15_reverse() - reverse a byte * @byte: byte to reverse. */ static u8 sht15_reverse(u8 byte) { u8 i, c; for (c = 0, i = 0; i < 8; i++) c |= (!!(byte & (1 << i))) << (7 - i); return c; } /** * sht15_crc8() - compute crc8 * @data: sht15 specific data. * @value: sht15 retrieved data. * * This implements section 2 of the CRC datasheet. */ static u8 sht15_crc8(struct sht15_data *data, const u8 *value, int len) { u8 crc = sht15_reverse(data->val_status & 0x0F); while (len--) { crc = sht15_crc8_table[*value ^ crc]; value++; } return crc; } /** * sht15_connection_reset() - reset the comms interface * @data: sht15 specific data * * This implements section 3.4 of the data sheet */ static int sht15_connection_reset(struct sht15_data *data) { int i, err; err = gpio_direction_output(data->pdata->gpio_data, 1); if (err) return err; ndelay(SHT15_TSCKL); gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSCKL); for (i = 0; i < 9; ++i) { gpio_set_value(data->pdata->gpio_sck, 1); ndelay(SHT15_TSCKH); gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSCKL); } return 0; } /** * sht15_send_bit() - send an individual bit to the device * @data: device state data * @val: value of bit to be sent */ static inline void sht15_send_bit(struct sht15_data *data, int val) { gpio_set_value(data->pdata->gpio_data, val); ndelay(SHT15_TSU); gpio_set_value(data->pdata->gpio_sck, 1); ndelay(SHT15_TSCKH); gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSCKL); /* clock low time */ } /** * sht15_transmission_start() - specific sequence for new transmission * @data: device state data * * Timings for this are not documented on the data sheet, so very * conservative ones used in implementation. This implements * figure 12 on the data sheet. */ static int sht15_transmission_start(struct sht15_data *data) { int err; /* ensure data is high and output */ err = gpio_direction_output(data->pdata->gpio_data, 1); if (err) return err; ndelay(SHT15_TSU); gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSCKL); gpio_set_value(data->pdata->gpio_sck, 1); ndelay(SHT15_TSCKH); gpio_set_value(data->pdata->gpio_data, 0); ndelay(SHT15_TSU); gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSCKL); gpio_set_value(data->pdata->gpio_sck, 1); ndelay(SHT15_TSCKH); gpio_set_value(data->pdata->gpio_data, 1); ndelay(SHT15_TSU); gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSCKL); return 0; } /** * sht15_send_byte() - send a single byte to the device * @data: device state * @byte: value to be sent */ static void sht15_send_byte(struct sht15_data *data, u8 byte) { int i; for (i = 0; i < 8; i++) { sht15_send_bit(data, !!(byte & 0x80)); byte <<= 1; } } /** * sht15_wait_for_response() - checks for ack from device * @data: device state */ static int sht15_wait_for_response(struct sht15_data *data) { int err; err = gpio_direction_input(data->pdata->gpio_data); if (err) return err; gpio_set_value(data->pdata->gpio_sck, 1); ndelay(SHT15_TSCKH); if (gpio_get_value(data->pdata->gpio_data)) { gpio_set_value(data->pdata->gpio_sck, 0); dev_err(data->dev, "Command not acknowledged\n"); err = sht15_connection_reset(data); if (err) return err; return -EIO; } gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSCKL); return 0; } /** * sht15_send_cmd() - Sends a command to the device. * @data: device state * @cmd: command byte to be sent * * On entry, sck is output low, data is output pull high * and the interrupt disabled. */ static int sht15_send_cmd(struct sht15_data *data, u8 cmd) { int err; err = sht15_transmission_start(data); if (err) return err; sht15_send_byte(data, cmd); return sht15_wait_for_response(data); } /** * sht15_soft_reset() - send a soft reset command * @data: sht15 specific data. * * As described in section 3.2 of the datasheet. */ static int sht15_soft_reset(struct sht15_data *data) { int ret; ret = sht15_send_cmd(data, SHT15_SOFT_RESET); if (ret) return ret; msleep(SHT15_TSRST); /* device resets default hardware status register value */ data->val_status = 0; return ret; } /** * sht15_ack() - send a ack * @data: sht15 specific data. * * Each byte of data is acknowledged by pulling the data line * low for one clock pulse. */ static int sht15_ack(struct sht15_data *data) { int err; err = gpio_direction_output(data->pdata->gpio_data, 0); if (err) return err; ndelay(SHT15_TSU); gpio_set_value(data->pdata->gpio_sck, 1); ndelay(SHT15_TSU); gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSU); gpio_set_value(data->pdata->gpio_data, 1); return gpio_direction_input(data->pdata->gpio_data); } /** * sht15_end_transmission() - notify device of end of transmission * @data: device state. * * This is basically a NAK (single clock pulse, data high). */ static int sht15_end_transmission(struct sht15_data *data) { int err; err = gpio_direction_output(data->pdata->gpio_data, 1); if (err) return err; ndelay(SHT15_TSU); gpio_set_value(data->pdata->gpio_sck, 1); ndelay(SHT15_TSCKH); gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSCKL); return 0; } /** * sht15_read_byte() - Read a byte back from the device * @data: device state. */ static u8 sht15_read_byte(struct sht15_data *data) { int i; u8 byte = 0; for (i = 0; i < 8; ++i) { byte <<= 1; gpio_set_value(data->pdata->gpio_sck, 1); ndelay(SHT15_TSCKH); byte |= !!gpio_get_value(data->pdata->gpio_data); gpio_set_value(data->pdata->gpio_sck, 0); ndelay(SHT15_TSCKL); } return byte; } /** * sht15_send_status() - write the status register byte * @data: sht15 specific data. * @status: the byte to set the status register with. * * As described in figure 14 and table 5 of the datasheet. */ static int sht15_send_status(struct sht15_data *data, u8 status) { int err; err = sht15_send_cmd(data, SHT15_WRITE_STATUS); if (err) return err; err = gpio_direction_output(data->pdata->gpio_data, 1); if (err) return err; ndelay(SHT15_TSU); sht15_send_byte(data, status); err = sht15_wait_for_response(data); if (err) return err; data->val_status = status; return 0; } /** * sht15_update_status() - get updated status register from device if too old * @data: device instance specific data. * * As described in figure 15 and table 5 of the datasheet. */ static int sht15_update_status(struct sht15_data *data) { int ret = 0; u8 status; u8 previous_config; u8 dev_checksum = 0; u8 checksum_vals[2]; int timeout = HZ; mutex_lock(&data->read_lock); if (time_after(jiffies, data->last_status + timeout) || !data->status_valid) { ret = sht15_send_cmd(data, SHT15_READ_STATUS); if (ret) goto unlock; status = sht15_read_byte(data); if (data->checksumming) { sht15_ack(data); dev_checksum = sht15_reverse(sht15_read_byte(data)); checksum_vals[0] = SHT15_READ_STATUS; checksum_vals[1] = status; data->checksum_ok = (sht15_crc8(data, checksum_vals, 2) == dev_checksum); } ret = sht15_end_transmission(data); if (ret) goto unlock; /* * Perform checksum validation on the received data. * Specification mentions that in case a checksum verification * fails, a soft reset command must be sent to the device. */ if (data->checksumming && !data->checksum_ok) { previous_config = data->val_status & 0x07; ret = sht15_soft_reset(data); if (ret) goto unlock; if (previous_config) { ret = sht15_send_status(data, previous_config); if (ret) { dev_err(data->dev, "CRC validation failed, unable " "to restore device settings\n"); goto unlock; } } ret = -EAGAIN; goto unlock; } data->val_status = status; data->status_valid = true; data->last_status = jiffies; } unlock: mutex_unlock(&data->read_lock); return ret; } /** * sht15_measurement() - get a new value from device * @data: device instance specific data * @command: command sent to request value * @timeout_msecs: timeout after which comms are assumed * to have failed are reset. */ static int sht15_measurement(struct sht15_data *data, int command, int timeout_msecs) { int ret; u8 previous_config; ret = sht15_send_cmd(data, command); if (ret) return ret; ret = gpio_direction_input(data->pdata->gpio_data); if (ret) return ret; atomic_set(&data->interrupt_handled, 0); enable_irq(gpio_to_irq(data->pdata->gpio_data)); if (gpio_get_value(data->pdata->gpio_data) == 0) { disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data)); /* Only relevant if the interrupt hasn't occurred. */ if (!atomic_read(&data->interrupt_handled)) schedule_work(&data->read_work); } ret = wait_event_timeout(data->wait_queue, (data->state == SHT15_READING_NOTHING), msecs_to_jiffies(timeout_msecs)); if (data->state != SHT15_READING_NOTHING) { /* I/O error occurred */ data->state = SHT15_READING_NOTHING; return -EIO; } else if (ret == 0) { /* timeout occurred */ disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data)); ret = sht15_connection_reset(data); if (ret) return ret; return -ETIME; } /* * Perform checksum validation on the received data. * Specification mentions that in case a checksum verification fails, * a soft reset command must be sent to the device. */ if (data->checksumming && !data->checksum_ok) { previous_config = data->val_status & 0x07; ret = sht15_soft_reset(data); if (ret) return ret; if (previous_config) { ret = sht15_send_status(data, previous_config); if (ret) { dev_err(data->dev, "CRC validation failed, unable " "to restore device settings\n"); return ret; } } return -EAGAIN; } return 0; } /** * sht15_update_measurements() - get updated measures from device if too old * @data: device state */ static int sht15_update_measurements(struct sht15_data *data) { int ret = 0; int timeout = HZ; mutex_lock(&data->read_lock); if (time_after(jiffies, data->last_measurement + timeout) || !data->measurements_valid) { data->state = SHT15_READING_HUMID; ret = sht15_measurement(data, SHT15_MEASURE_RH, 160); if (ret) goto unlock; data->state = SHT15_READING_TEMP; ret = sht15_measurement(data, SHT15_MEASURE_TEMP, 400); if (ret) goto unlock; data->measurements_valid = true; data->last_measurement = jiffies; } unlock: mutex_unlock(&data->read_lock); return ret; } /** * sht15_calc_temp() - convert the raw reading to a temperature * @data: device state * * As per section 4.3 of the data sheet. */ static inline int sht15_calc_temp(struct sht15_data *data) { int d1 = temppoints[0].d1; int d2 = (data->val_status & SHT15_STATUS_LOW_RESOLUTION) ? 40 : 10; int i; for (i = ARRAY_SIZE(temppoints) - 1; i > 0; i--) /* Find pointer to interpolate */ if (data->supply_uv > temppoints[i - 1].vdd) { d1 = (data->supply_uv - temppoints[i - 1].vdd) * (temppoints[i].d1 - temppoints[i - 1].d1) / (temppoints[i].vdd - temppoints[i - 1].vdd) + temppoints[i - 1].d1; break; } return data->val_temp * d2 + d1; } /** * sht15_calc_humid() - using last temperature convert raw to humid * @data: device state * * This is the temperature compensated version as per section 4.2 of * the data sheet. * * The sensor is assumed to be V3, which is compatible with V4. * Humidity conversion coefficients are shown in table 7 of the datasheet. */ static inline int sht15_calc_humid(struct sht15_data *data) { int rh_linear; /* milli percent */ int temp = sht15_calc_temp(data); int c2, c3; int t2; const int c1 = -4; if (data->val_status & SHT15_STATUS_LOW_RESOLUTION) { c2 = 648000; /* x 10 ^ -6 */ c3 = -7200; /* x 10 ^ -7 */ t2 = 1280; } else { c2 = 40500; /* x 10 ^ -6 */ c3 = -28; /* x 10 ^ -7 */ t2 = 80; } rh_linear = c1 * 1000 + c2 * data->val_humid / 1000 + (data->val_humid * data->val_humid * c3) / 10000; return (temp - 25000) * (10000 + t2 * data->val_humid) / 1000000 + rh_linear; } /** * sht15_show_status() - show status information in sysfs * @dev: device. * @attr: device attribute. * @buf: sysfs buffer where information is written to. * * Will be called on read access to temp1_fault, humidity1_fault * and heater_enable sysfs attributes. * Returns number of bytes written into buffer, negative errno on error. */ static ssize_t sht15_show_status(struct device *dev, struct device_attribute *attr, char *buf) { int ret; struct sht15_data *data = dev_get_drvdata(dev); u8 bit = to_sensor_dev_attr(attr)->index; ret = sht15_update_status(data); return ret ? ret : sprintf(buf, "%d\n", !!(data->val_status & bit)); } /** * sht15_store_heater() - change heater state via sysfs * @dev: device. * @attr: device attribute. * @buf: sysfs buffer to read the new heater state from. * @count: length of the data. * * Will be called on write access to heater_enable sysfs attribute. * Returns number of bytes actually decoded, negative errno on error. */ static ssize_t sht15_store_heater(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int ret; struct sht15_data *data = dev_get_drvdata(dev); long value; u8 status; if (kstrtol(buf, 10, &value)) return -EINVAL; mutex_lock(&data->read_lock); status = data->val_status & 0x07; if (!!value) status |= SHT15_STATUS_HEATER; else status &= ~SHT15_STATUS_HEATER; ret = sht15_send_status(data, status); mutex_unlock(&data->read_lock); return ret ? ret : count; } /** * sht15_show_temp() - show temperature measurement value in sysfs * @dev: device. * @attr: device attribute. * @buf: sysfs buffer where measurement values are written to. * * Will be called on read access to temp1_input sysfs attribute. * Returns number of bytes written into buffer, negative errno on error. */ static ssize_t sht15_show_temp(struct device *dev, struct device_attribute *attr, char *buf) { int ret; struct sht15_data *data = dev_get_drvdata(dev); /* Technically no need to read humidity as well */ ret = sht15_update_measurements(data); return ret ? ret : sprintf(buf, "%d\n", sht15_calc_temp(data)); } /** * sht15_show_humidity() - show humidity measurement value in sysfs * @dev: device. * @attr: device attribute. * @buf: sysfs buffer where measurement values are written to. * * Will be called on read access to humidity1_input sysfs attribute. * Returns number of bytes written into buffer, negative errno on error. */ static ssize_t sht15_show_humidity(struct device *dev, struct device_attribute *attr, char *buf) { int ret; struct sht15_data *data = dev_get_drvdata(dev); ret = sht15_update_measurements(data); return ret ? ret : sprintf(buf, "%d\n", sht15_calc_humid(data)); } static ssize_t show_name(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = to_platform_device(dev); return sprintf(buf, "%s\n", pdev->name); } static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, sht15_show_temp, NULL, 0); static SENSOR_DEVICE_ATTR(humidity1_input, S_IRUGO, sht15_show_humidity, NULL, 0); static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, sht15_show_status, NULL, SHT15_STATUS_LOW_BATTERY); static SENSOR_DEVICE_ATTR(humidity1_fault, S_IRUGO, sht15_show_status, NULL, SHT15_STATUS_LOW_BATTERY); static SENSOR_DEVICE_ATTR(heater_enable, S_IRUGO | S_IWUSR, sht15_show_status, sht15_store_heater, SHT15_STATUS_HEATER); static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); static struct attribute *sht15_attrs[] = { &sensor_dev_attr_temp1_input.dev_attr.attr, &sensor_dev_attr_humidity1_input.dev_attr.attr, &sensor_dev_attr_temp1_fault.dev_attr.attr, &sensor_dev_attr_humidity1_fault.dev_attr.attr, &sensor_dev_attr_heater_enable.dev_attr.attr, &dev_attr_name.attr, NULL, }; static const struct attribute_group sht15_attr_group = { .attrs = sht15_attrs, }; static irqreturn_t sht15_interrupt_fired(int irq, void *d) { struct sht15_data *data = d; /* First disable the interrupt */ disable_irq_nosync(irq); atomic_inc(&data->interrupt_handled); /* Then schedule a reading work struct */ if (data->state != SHT15_READING_NOTHING) schedule_work(&data->read_work); return IRQ_HANDLED; } static void sht15_bh_read_data(struct work_struct *work_s) { uint16_t val = 0; u8 dev_checksum = 0; u8 checksum_vals[3]; struct sht15_data *data = container_of(work_s, struct sht15_data, read_work); /* Firstly, verify the line is low */ if (gpio_get_value(data->pdata->gpio_data)) { /* * If not, then start the interrupt again - care here as could * have gone low in meantime so verify it hasn't! */ atomic_set(&data->interrupt_handled, 0); enable_irq(gpio_to_irq(data->pdata->gpio_data)); /* If still not occurred or another handler was scheduled */ if (gpio_get_value(data->pdata->gpio_data) || atomic_read(&data->interrupt_handled)) return; } /* Read the data back from the device */ val = sht15_read_byte(data); val <<= 8; if (sht15_ack(data)) goto wakeup; val |= sht15_read_byte(data); if (data->checksumming) { /* * Ask the device for a checksum and read it back. * Note: the device sends the checksum byte reversed. */ if (sht15_ack(data)) goto wakeup; dev_checksum = sht15_reverse(sht15_read_byte(data)); checksum_vals[0] = (data->state == SHT15_READING_TEMP) ? SHT15_MEASURE_TEMP : SHT15_MEASURE_RH; checksum_vals[1] = (u8) (val >> 8); checksum_vals[2] = (u8) val; data->checksum_ok = (sht15_crc8(data, checksum_vals, 3) == dev_checksum); } /* Tell the device we are done */ if (sht15_end_transmission(data)) goto wakeup; switch (data->state) { case SHT15_READING_TEMP: data->val_temp = val; break; case SHT15_READING_HUMID: data->val_humid = val; break; default: break; } data->state = SHT15_READING_NOTHING; wakeup: wake_up(&data->wait_queue); } static void sht15_update_voltage(struct work_struct *work_s) { struct sht15_data *data = container_of(work_s, struct sht15_data, update_supply_work); data->supply_uv = regulator_get_voltage(data->reg); } /** * sht15_invalidate_voltage() - mark supply voltage invalid when notified by reg * @nb: associated notification structure * @event: voltage regulator state change event code * @ignored: function parameter - ignored here * * Note that as the notification code holds the regulator lock, we have * to schedule an update of the supply voltage rather than getting it directly. */ static int sht15_invalidate_voltage(struct notifier_block *nb, unsigned long event, void *ignored) { struct sht15_data *data = container_of(nb, struct sht15_data, nb); if (event == REGULATOR_EVENT_VOLTAGE_CHANGE) data->supply_uv_valid = false; schedule_work(&data->update_supply_work); return NOTIFY_OK; } static int sht15_probe(struct platform_device *pdev) { int ret; struct sht15_data *data; u8 status = 0; data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; INIT_WORK(&data->read_work, sht15_bh_read_data); INIT_WORK(&data->update_supply_work, sht15_update_voltage); platform_set_drvdata(pdev, data); mutex_init(&data->read_lock); data->dev = &pdev->dev; init_waitqueue_head(&data->wait_queue); if (pdev->dev.platform_data == NULL) { dev_err(&pdev->dev, "no platform data supplied\n"); return -EINVAL; } data->pdata = pdev->dev.platform_data; data->supply_uv = data->pdata->supply_mv * 1000; if (data->pdata->checksum) data->checksumming = true; if (data->pdata->no_otp_reload) status |= SHT15_STATUS_NO_OTP_RELOAD; if (data->pdata->low_resolution) status |= SHT15_STATUS_LOW_RESOLUTION; /* * If a regulator is available, * query what the supply voltage actually is! */ data->reg = devm_regulator_get(data->dev, "vcc"); if (!IS_ERR(data->reg)) { int voltage; voltage = regulator_get_voltage(data->reg); if (voltage) data->supply_uv = voltage; ret = regulator_enable(data->reg); if (ret != 0) { dev_err(&pdev->dev, "failed to enable regulator: %d\n", ret); return ret; } /* * Setup a notifier block to update this if another device * causes the voltage to change */ data->nb.notifier_call = &sht15_invalidate_voltage; ret = regulator_register_notifier(data->reg, &data->nb); if (ret) { dev_err(&pdev->dev, "regulator notifier request failed\n"); regulator_disable(data->reg); return ret; } } /* Try requesting the GPIOs */ ret = devm_gpio_request_one(&pdev->dev, data->pdata->gpio_sck, GPIOF_OUT_INIT_LOW, "SHT15 sck"); if (ret) { dev_err(&pdev->dev, "clock line GPIO request failed\n"); goto err_release_reg; } ret = devm_gpio_request(&pdev->dev, data->pdata->gpio_data, "SHT15 data"); if (ret) { dev_err(&pdev->dev, "data line GPIO request failed\n"); goto err_release_reg; } ret = devm_request_irq(&pdev->dev, gpio_to_irq(data->pdata->gpio_data), sht15_interrupt_fired, IRQF_TRIGGER_FALLING, "sht15 data", data); if (ret) { dev_err(&pdev->dev, "failed to get irq for data line\n"); goto err_release_reg; } disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data)); ret = sht15_connection_reset(data); if (ret) goto err_release_reg; ret = sht15_soft_reset(data); if (ret) goto err_release_reg; /* write status with platform data options */ if (status) { ret = sht15_send_status(data, status); if (ret) goto err_release_reg; } ret = sysfs_create_group(&pdev->dev.kobj, &sht15_attr_group); if (ret) { dev_err(&pdev->dev, "sysfs create failed\n"); goto err_release_reg; } data->hwmon_dev = hwmon_device_register(data->dev); if (IS_ERR(data->hwmon_dev)) { ret = PTR_ERR(data->hwmon_dev); goto err_release_sysfs_group; } return 0; err_release_sysfs_group: sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group); err_release_reg: if (!IS_ERR(data->reg)) { regulator_unregister_notifier(data->reg, &data->nb); regulator_disable(data->reg); } return ret; } static int sht15_remove(struct platform_device *pdev) { struct sht15_data *data = platform_get_drvdata(pdev); /* * Make sure any reads from the device are done and * prevent new ones beginning */ mutex_lock(&data->read_lock); if (sht15_soft_reset(data)) { mutex_unlock(&data->read_lock); return -EFAULT; } hwmon_device_unregister(data->hwmon_dev); sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group); if (!IS_ERR(data->reg)) { regulator_unregister_notifier(data->reg, &data->nb); regulator_disable(data->reg); } mutex_unlock(&data->read_lock); return 0; } static struct platform_device_id sht15_device_ids[] = { { "sht10", sht10 }, { "sht11", sht11 }, { "sht15", sht15 }, { "sht71", sht71 }, { "sht75", sht75 }, { } }; MODULE_DEVICE_TABLE(platform, sht15_device_ids); static struct platform_driver sht15_driver = { .driver = { .name = "sht15", .owner = THIS_MODULE, }, .probe = sht15_probe, .remove = sht15_remove, .id_table = sht15_device_ids, }; module_platform_driver(sht15_driver); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Sensirion SHT15 temperature and humidity sensor driver");