394 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2 3/*4 * aht10.c - Linux hwmon driver for AHT10/AHT20 Temperature and Humidity sensors5 * Copyright (C) 2020 Johannes Cornelis Draaijer6 */7 8#include <linux/delay.h>9#include <linux/hwmon.h>10#include <linux/i2c.h>11#include <linux/ktime.h>12#include <linux/module.h>13#include <linux/crc8.h>14 15#define AHT10_MEAS_SIZE 616 17#define AHT20_MEAS_SIZE 718#define AHT20_CRC8_POLY 0x3119 20/*21 * Poll intervals (in milliseconds)22 */23#define AHT10_DEFAULT_MIN_POLL_INTERVAL 200024#define AHT10_MIN_POLL_INTERVAL 200025 26/*27 * I2C command delays (in microseconds)28 */29#define AHT10_MEAS_DELAY 8000030#define AHT10_CMD_DELAY 35000031#define AHT10_DELAY_EXTRA 10000032 33/*34 * Command bytes35 */36#define AHT10_CMD_INIT 0b1110000137#define AHT10_CMD_MEAS 0b1010110038#define AHT10_CMD_RST 0b1011101039 40/*41 * Flags in the answer byte/command42 */43#define AHT10_CAL_ENABLED BIT(3)44#define AHT10_BUSY BIT(7)45#define AHT10_MODE_NOR (BIT(5) | BIT(6))46#define AHT10_MODE_CYC BIT(5)47#define AHT10_MODE_CMD BIT(6)48 49#define AHT10_MAX_POLL_INTERVAL_LEN 3050 51enum aht10_variant { aht10, aht20 };52 53static const struct i2c_device_id aht10_id[] = {54 { "aht10", aht10 },55 { "aht20", aht20 },56 { },57};58MODULE_DEVICE_TABLE(i2c, aht10_id);59 60/**61 * struct aht10_data - All the data required to operate an AHT10/AHT20 chip62 * @client: the i2c client associated with the AHT10/AHT2063 * @lock: a mutex that is used to prevent parallel access to the64 * i2c client65 * @min_poll_interval: the minimum poll interval66 * While the poll rate limit is not 100% necessary,67 * the datasheet recommends that a measurement68 * is not performed too often to prevent69 * the chip from warming up due to the heat it generates.70 * If it's unwanted, it can be ignored setting it to71 * it to 0. Default value is 2000 ms72 * @previous_poll_time: the previous time that the AHT10/AHT2073 * was polled74 * @temperature: the latest temperature value received from75 * the AHT10/AHT2076 * @humidity: the latest humidity value received from the77 * AHT10/AHT2078 * @crc8: crc8 support flag79 * @meas_size: measurements data size80 */81 82struct aht10_data {83 struct i2c_client *client;84 /*85 * Prevent simultaneous access to the i2c86 * client and previous_poll_time87 */88 struct mutex lock;89 ktime_t min_poll_interval;90 ktime_t previous_poll_time;91 int temperature;92 int humidity;93 bool crc8;94 unsigned int meas_size;95};96 97/**98 * aht10_init() - Initialize an AHT10/AHT20 chip99 * @data: the data associated with this AHT10/AHT20 chip100 * Return: 0 if successful, 1 if not101 */102static int aht10_init(struct aht10_data *data)103{104 const u8 cmd_init[] = {AHT10_CMD_INIT, AHT10_CAL_ENABLED | AHT10_MODE_CYC,105 0x00};106 int res;107 u8 status;108 struct i2c_client *client = data->client;109 110 res = i2c_master_send(client, cmd_init, 3);111 if (res < 0)112 return res;113 114 usleep_range(AHT10_CMD_DELAY, AHT10_CMD_DELAY +115 AHT10_DELAY_EXTRA);116 117 res = i2c_master_recv(client, &status, 1);118 if (res != 1)119 return -ENODATA;120 121 if (status & AHT10_BUSY)122 return -EBUSY;123 124 return 0;125}126 127/**128 * aht10_polltime_expired() - check if the minimum poll interval has129 * expired130 * @data: the data containing the time to compare131 * Return: 1 if the minimum poll interval has expired, 0 if not132 */133static int aht10_polltime_expired(struct aht10_data *data)134{135 ktime_t current_time = ktime_get_boottime();136 ktime_t difference = ktime_sub(current_time, data->previous_poll_time);137 138 return ktime_after(difference, data->min_poll_interval);139}140 141DECLARE_CRC8_TABLE(crc8_table);142 143/**144 * crc8_check() - check crc of the sensor's measurements145 * @raw_data: data frame received from sensor(including crc as the last byte)146 * @count: size of the data frame147 * Return: 0 if successful, 1 if not148 */149static int crc8_check(u8 *raw_data, int count)150{151 /*152 * crc calculated on the whole frame(including crc byte) should yield153 * zero in case of correctly received bytes154 */155 return crc8(crc8_table, raw_data, count, CRC8_INIT_VALUE);156}157 158/**159 * aht10_read_values() - read and parse the raw data from the AHT10/AHT20160 * @data: the struct aht10_data to use for the lock161 * Return: 0 if successful, 1 if not162 */163static int aht10_read_values(struct aht10_data *data)164{165 const u8 cmd_meas[] = {AHT10_CMD_MEAS, 0x33, 0x00};166 u32 temp, hum;167 int res;168 u8 raw_data[AHT20_MEAS_SIZE];169 struct i2c_client *client = data->client;170 171 mutex_lock(&data->lock);172 if (!aht10_polltime_expired(data)) {173 mutex_unlock(&data->lock);174 return 0;175 }176 177 res = i2c_master_send(client, cmd_meas, sizeof(cmd_meas));178 if (res < 0) {179 mutex_unlock(&data->lock);180 return res;181 }182 183 usleep_range(AHT10_MEAS_DELAY, AHT10_MEAS_DELAY + AHT10_DELAY_EXTRA);184 185 res = i2c_master_recv(client, raw_data, data->meas_size);186 if (res != data->meas_size) {187 mutex_unlock(&data->lock);188 if (res >= 0)189 return -ENODATA;190 return res;191 }192 193 if (data->crc8 && crc8_check(raw_data, data->meas_size)) {194 mutex_unlock(&data->lock);195 return -EIO;196 }197 198 hum = ((u32)raw_data[1] << 12u) |199 ((u32)raw_data[2] << 4u) |200 ((raw_data[3] & 0xF0u) >> 4u);201 202 temp = ((u32)(raw_data[3] & 0x0Fu) << 16u) |203 ((u32)raw_data[4] << 8u) |204 raw_data[5];205 206 temp = ((temp * 625) >> 15u) * 10;207 hum = ((hum * 625) >> 16u) * 10;208 209 data->temperature = (int)temp - 50000;210 data->humidity = hum;211 data->previous_poll_time = ktime_get_boottime();212 213 mutex_unlock(&data->lock);214 return 0;215}216 217/**218 * aht10_interval_write() - store the given minimum poll interval.219 * Return: 0 on success, -EINVAL if a value lower than the220 * AHT10_MIN_POLL_INTERVAL is given221 */222static ssize_t aht10_interval_write(struct aht10_data *data,223 long val)224{225 data->min_poll_interval = ms_to_ktime(clamp_val(val, 2000, LONG_MAX));226 return 0;227}228 229/**230 * aht10_interval_read() - read the minimum poll interval231 * in milliseconds232 */233static ssize_t aht10_interval_read(struct aht10_data *data,234 long *val)235{236 *val = ktime_to_ms(data->min_poll_interval);237 return 0;238}239 240/**241 * aht10_temperature1_read() - read the temperature in millidegrees242 */243static int aht10_temperature1_read(struct aht10_data *data, long *val)244{245 int res;246 247 res = aht10_read_values(data);248 if (res < 0)249 return res;250 251 *val = data->temperature;252 return 0;253}254 255/**256 * aht10_humidity1_read() - read the relative humidity in millipercent257 */258static int aht10_humidity1_read(struct aht10_data *data, long *val)259{260 int res;261 262 res = aht10_read_values(data);263 if (res < 0)264 return res;265 266 *val = data->humidity;267 return 0;268}269 270static umode_t aht10_hwmon_visible(const void *data, enum hwmon_sensor_types type,271 u32 attr, int channel)272{273 switch (type) {274 case hwmon_temp:275 case hwmon_humidity:276 return 0444;277 case hwmon_chip:278 return 0644;279 default:280 return 0;281 }282}283 284static int aht10_hwmon_read(struct device *dev, enum hwmon_sensor_types type,285 u32 attr, int channel, long *val)286{287 struct aht10_data *data = dev_get_drvdata(dev);288 289 switch (type) {290 case hwmon_temp:291 return aht10_temperature1_read(data, val);292 case hwmon_humidity:293 return aht10_humidity1_read(data, val);294 case hwmon_chip:295 return aht10_interval_read(data, val);296 default:297 return -EOPNOTSUPP;298 }299}300 301static int aht10_hwmon_write(struct device *dev, enum hwmon_sensor_types type,302 u32 attr, int channel, long val)303{304 struct aht10_data *data = dev_get_drvdata(dev);305 306 switch (type) {307 case hwmon_chip:308 return aht10_interval_write(data, val);309 default:310 return -EOPNOTSUPP;311 }312}313 314static const struct hwmon_channel_info * const aht10_info[] = {315 HWMON_CHANNEL_INFO(chip, HWMON_C_UPDATE_INTERVAL),316 HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT),317 HWMON_CHANNEL_INFO(humidity, HWMON_H_INPUT),318 NULL,319};320 321static const struct hwmon_ops aht10_hwmon_ops = {322 .is_visible = aht10_hwmon_visible,323 .read = aht10_hwmon_read,324 .write = aht10_hwmon_write,325};326 327static const struct hwmon_chip_info aht10_chip_info = {328 .ops = &aht10_hwmon_ops,329 .info = aht10_info,330};331 332static int aht10_probe(struct i2c_client *client)333{334 enum aht10_variant variant = (uintptr_t)i2c_get_match_data(client);335 struct device *device = &client->dev;336 struct device *hwmon_dev;337 struct aht10_data *data;338 int res;339 340 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))341 return -ENOENT;342 343 data = devm_kzalloc(device, sizeof(*data), GFP_KERNEL);344 if (!data)345 return -ENOMEM;346 347 data->min_poll_interval = ms_to_ktime(AHT10_DEFAULT_MIN_POLL_INTERVAL);348 data->client = client;349 350 switch (variant) {351 case aht20:352 data->meas_size = AHT20_MEAS_SIZE;353 data->crc8 = true;354 crc8_populate_msb(crc8_table, AHT20_CRC8_POLY);355 break;356 default:357 data->meas_size = AHT10_MEAS_SIZE;358 break;359 }360 361 mutex_init(&data->lock);362 363 res = aht10_init(data);364 if (res < 0)365 return res;366 367 res = aht10_read_values(data);368 if (res < 0)369 return res;370 371 hwmon_dev = devm_hwmon_device_register_with_info(device,372 client->name,373 data,374 &aht10_chip_info,375 NULL);376 377 return PTR_ERR_OR_ZERO(hwmon_dev);378}379 380static struct i2c_driver aht10_driver = {381 .driver = {382 .name = "aht10",383 },384 .probe = aht10_probe,385 .id_table = aht10_id,386};387 388module_i2c_driver(aht10_driver);389 390MODULE_AUTHOR("Johannes Cornelis Draaijer <jcdra1@gmail.com>");391MODULE_DESCRIPTION("AHT10/AHT20 Temperature and Humidity sensor driver");392MODULE_VERSION("1.0");393MODULE_LICENSE("GPL v2");394