Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Sonic Zhang | 1649 | 80.56% | 1 | 3.23% |
Nishad Kamdar | 173 | 8.45% | 4 | 12.90% |
Jonathan Cameron | 127 | 6.20% | 10 | 32.26% |
Sachin Kamat | 51 | 2.49% | 2 | 6.45% |
Aida Mynzhasova | 10 | 0.49% | 1 | 3.23% |
Lars-Peter Clausen | 10 | 0.49% | 3 | 9.68% |
Ksenija Stanojevic | 6 | 0.29% | 1 | 3.23% |
Julián de Gortari | 5 | 0.24% | 1 | 3.23% |
Payal Kshirsagar | 3 | 0.15% | 1 | 3.23% |
Paul Gortmaker | 3 | 0.15% | 1 | 3.23% |
Grégor Boirie | 3 | 0.15% | 1 | 3.23% |
Hardik Singh Rathore | 2 | 0.10% | 1 | 3.23% |
Greg Kroah-Hartman | 2 | 0.10% | 1 | 3.23% |
Bhumika Goyal | 1 | 0.05% | 1 | 3.23% |
Masanari Iida | 1 | 0.05% | 1 | 3.23% |
Darshana Padmadas | 1 | 0.05% | 1 | 3.23% |
Total | 2047 | 31 |
// SPDX-License-Identifier: GPL-2.0+ /* * AD7816 digital temperature sensor driver supporting AD7816/7/8 * * Copyright 2010 Analog Devices Inc. */ #include <linux/interrupt.h> #include <linux/gpio/consumer.h> #include <linux/device.h> #include <linux/kernel.h> #include <linux/slab.h> #include <linux/sysfs.h> #include <linux/list.h> #include <linux/spi/spi.h> #include <linux/module.h> #include <linux/iio/iio.h> #include <linux/iio/sysfs.h> #include <linux/iio/events.h> /* * AD7816 config masks */ #define AD7816_FULL 0x1 #define AD7816_PD 0x2 #define AD7816_CS_MASK 0x7 #define AD7816_CS_MAX 0x4 /* * AD7816 temperature masks */ #define AD7816_VALUE_OFFSET 6 #define AD7816_BOUND_VALUE_BASE 0x8 #define AD7816_BOUND_VALUE_MIN -95 #define AD7816_BOUND_VALUE_MAX 152 #define AD7816_TEMP_FLOAT_OFFSET 2 #define AD7816_TEMP_FLOAT_MASK 0x3 /* * struct ad7816_chip_info - chip specific information */ struct ad7816_chip_info { kernel_ulong_t id; struct spi_device *spi_dev; struct gpio_desc *rdwr_pin; struct gpio_desc *convert_pin; struct gpio_desc *busy_pin; u8 oti_data[AD7816_CS_MAX + 1]; u8 channel_id; /* 0 always be temperature */ u8 mode; }; enum ad7816_type { ID_AD7816, ID_AD7817, ID_AD7818, }; /* * ad7816 data access by SPI */ static int ad7816_spi_read(struct ad7816_chip_info *chip, u16 *data) { struct spi_device *spi_dev = chip->spi_dev; int ret; __be16 buf; gpiod_set_value(chip->rdwr_pin, 1); gpiod_set_value(chip->rdwr_pin, 0); ret = spi_write(spi_dev, &chip->channel_id, sizeof(chip->channel_id)); if (ret < 0) { dev_err(&spi_dev->dev, "SPI channel setting error\n"); return ret; } gpiod_set_value(chip->rdwr_pin, 1); if (chip->mode == AD7816_PD) { /* operating mode 2 */ gpiod_set_value(chip->convert_pin, 1); gpiod_set_value(chip->convert_pin, 0); } else { /* operating mode 1 */ gpiod_set_value(chip->convert_pin, 0); gpiod_set_value(chip->convert_pin, 1); } if (chip->id == ID_AD7816 || chip->id == ID_AD7817) { while (gpiod_get_value(chip->busy_pin)) cpu_relax(); } gpiod_set_value(chip->rdwr_pin, 0); gpiod_set_value(chip->rdwr_pin, 1); ret = spi_read(spi_dev, &buf, sizeof(*data)); if (ret < 0) { dev_err(&spi_dev->dev, "SPI data read error\n"); return ret; } *data = be16_to_cpu(buf); return ret; } static int ad7816_spi_write(struct ad7816_chip_info *chip, u8 data) { struct spi_device *spi_dev = chip->spi_dev; int ret; gpiod_set_value(chip->rdwr_pin, 1); gpiod_set_value(chip->rdwr_pin, 0); ret = spi_write(spi_dev, &data, sizeof(data)); if (ret < 0) dev_err(&spi_dev->dev, "SPI oti data write error\n"); return ret; } static ssize_t ad7816_show_mode(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct ad7816_chip_info *chip = iio_priv(indio_dev); if (chip->mode) return sprintf(buf, "power-save\n"); return sprintf(buf, "full\n"); } static ssize_t ad7816_store_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct ad7816_chip_info *chip = iio_priv(indio_dev); if (strcmp(buf, "full")) { gpiod_set_value(chip->rdwr_pin, 1); chip->mode = AD7816_FULL; } else { gpiod_set_value(chip->rdwr_pin, 0); chip->mode = AD7816_PD; } return len; } static IIO_DEVICE_ATTR(mode, 0644, ad7816_show_mode, ad7816_store_mode, 0); static ssize_t ad7816_show_available_modes(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "full\npower-save\n"); } static IIO_DEVICE_ATTR(available_modes, 0444, ad7816_show_available_modes, NULL, 0); static ssize_t ad7816_show_channel(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct ad7816_chip_info *chip = iio_priv(indio_dev); return sprintf(buf, "%d\n", chip->channel_id); } static ssize_t ad7816_store_channel(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct ad7816_chip_info *chip = iio_priv(indio_dev); unsigned long data; int ret; ret = kstrtoul(buf, 10, &data); if (ret) return ret; if (data > AD7816_CS_MAX && data != AD7816_CS_MASK) { dev_err(&chip->spi_dev->dev, "Invalid channel id %lu for %s.\n", data, indio_dev->name); return -EINVAL; } else if (strcmp(indio_dev->name, "ad7818") == 0 && data > 1) { dev_err(&chip->spi_dev->dev, "Invalid channel id %lu for ad7818.\n", data); return -EINVAL; } else if (strcmp(indio_dev->name, "ad7816") == 0 && data > 0) { dev_err(&chip->spi_dev->dev, "Invalid channel id %lu for ad7816.\n", data); return -EINVAL; } chip->channel_id = data; return len; } static IIO_DEVICE_ATTR(channel, 0644, ad7816_show_channel, ad7816_store_channel, 0); static ssize_t ad7816_show_value(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct ad7816_chip_info *chip = iio_priv(indio_dev); u16 data; s8 value; int ret; ret = ad7816_spi_read(chip, &data); if (ret) return -EIO; data >>= AD7816_VALUE_OFFSET; if (chip->channel_id == 0) { value = (s8)((data >> AD7816_TEMP_FLOAT_OFFSET) - 103); data &= AD7816_TEMP_FLOAT_MASK; if (value < 0) data = BIT(AD7816_TEMP_FLOAT_OFFSET) - data; return sprintf(buf, "%d.%.2d\n", value, data * 25); } return sprintf(buf, "%u\n", data); } static IIO_DEVICE_ATTR(value, 0444, ad7816_show_value, NULL, 0); static struct attribute *ad7816_attributes[] = { &iio_dev_attr_available_modes.dev_attr.attr, &iio_dev_attr_mode.dev_attr.attr, &iio_dev_attr_channel.dev_attr.attr, &iio_dev_attr_value.dev_attr.attr, NULL, }; static const struct attribute_group ad7816_attribute_group = { .attrs = ad7816_attributes, }; /* * temperature bound events */ #define IIO_EVENT_CODE_AD7816_OTI IIO_UNMOD_EVENT_CODE(IIO_TEMP, \ 0, \ IIO_EV_TYPE_THRESH, \ IIO_EV_DIR_FALLING) static irqreturn_t ad7816_event_handler(int irq, void *private) { iio_push_event(private, IIO_EVENT_CODE_AD7816_OTI, iio_get_time_ns(private)); return IRQ_HANDLED; } static ssize_t ad7816_show_oti(struct device *dev, struct device_attribute *attr, char *buf) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct ad7816_chip_info *chip = iio_priv(indio_dev); int value; if (chip->channel_id > AD7816_CS_MAX) { dev_err(dev, "Invalid oti channel id %d.\n", chip->channel_id); return -EINVAL; } else if (chip->channel_id == 0) { value = AD7816_BOUND_VALUE_MIN + (chip->oti_data[chip->channel_id] - AD7816_BOUND_VALUE_BASE); return sprintf(buf, "%d\n", value); } return sprintf(buf, "%u\n", chip->oti_data[chip->channel_id]); } static inline ssize_t ad7816_set_oti(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct iio_dev *indio_dev = dev_to_iio_dev(dev); struct ad7816_chip_info *chip = iio_priv(indio_dev); long value; u8 data; int ret; ret = kstrtol(buf, 10, &value); if (ret) return ret; if (chip->channel_id > AD7816_CS_MAX) { dev_err(dev, "Invalid oti channel id %d.\n", chip->channel_id); return -EINVAL; } else if (chip->channel_id == 0) { if (value < AD7816_BOUND_VALUE_MIN || value > AD7816_BOUND_VALUE_MAX) return -EINVAL; data = (u8)(value - AD7816_BOUND_VALUE_MIN + AD7816_BOUND_VALUE_BASE); } else { if (value < AD7816_BOUND_VALUE_BASE || value > 255) return -EINVAL; data = (u8)value; } ret = ad7816_spi_write(chip, data); if (ret) return -EIO; chip->oti_data[chip->channel_id] = data; return len; } static IIO_DEVICE_ATTR(oti, 0644, ad7816_show_oti, ad7816_set_oti, 0); static struct attribute *ad7816_event_attributes[] = { &iio_dev_attr_oti.dev_attr.attr, NULL, }; static const struct attribute_group ad7816_event_attribute_group = { .attrs = ad7816_event_attributes, .name = "events", }; static const struct iio_info ad7816_info = { .attrs = &ad7816_attribute_group, .event_attrs = &ad7816_event_attribute_group, }; /* * device probe and remove */ static int ad7816_probe(struct spi_device *spi_dev) { struct ad7816_chip_info *chip; struct iio_dev *indio_dev; int i, ret; indio_dev = devm_iio_device_alloc(&spi_dev->dev, sizeof(*chip)); if (!indio_dev) return -ENOMEM; chip = iio_priv(indio_dev); /* this is only used for device removal purposes */ dev_set_drvdata(&spi_dev->dev, indio_dev); chip->spi_dev = spi_dev; for (i = 0; i <= AD7816_CS_MAX; i++) chip->oti_data[i] = 203; chip->id = spi_get_device_id(spi_dev)->driver_data; chip->rdwr_pin = devm_gpiod_get(&spi_dev->dev, "rdwr", GPIOD_OUT_HIGH); if (IS_ERR(chip->rdwr_pin)) { ret = PTR_ERR(chip->rdwr_pin); dev_err(&spi_dev->dev, "Failed to request rdwr GPIO: %d\n", ret); return ret; } chip->convert_pin = devm_gpiod_get(&spi_dev->dev, "convert", GPIOD_OUT_HIGH); if (IS_ERR(chip->convert_pin)) { ret = PTR_ERR(chip->convert_pin); dev_err(&spi_dev->dev, "Failed to request convert GPIO: %d\n", ret); return ret; } if (chip->id == ID_AD7816 || chip->id == ID_AD7817) { chip->busy_pin = devm_gpiod_get(&spi_dev->dev, "busy", GPIOD_IN); if (IS_ERR(chip->busy_pin)) { ret = PTR_ERR(chip->busy_pin); dev_err(&spi_dev->dev, "Failed to request busy GPIO: %d\n", ret); return ret; } } indio_dev->name = spi_get_device_id(spi_dev)->name; indio_dev->info = &ad7816_info; indio_dev->modes = INDIO_DIRECT_MODE; if (spi_dev->irq) { /* Only low trigger is supported in ad7816/7/8 */ ret = devm_request_threaded_irq(&spi_dev->dev, spi_dev->irq, NULL, &ad7816_event_handler, IRQF_TRIGGER_LOW | IRQF_ONESHOT, indio_dev->name, indio_dev); if (ret) return ret; } ret = devm_iio_device_register(&spi_dev->dev, indio_dev); if (ret) return ret; dev_info(&spi_dev->dev, "%s temperature sensor and ADC registered.\n", indio_dev->name); return 0; } static const struct of_device_id ad7816_of_match[] = { { .compatible = "adi,ad7816", }, { .compatible = "adi,ad7817", }, { .compatible = "adi,ad7818", }, { } }; MODULE_DEVICE_TABLE(of, ad7816_of_match); static const struct spi_device_id ad7816_id[] = { { "ad7816", ID_AD7816 }, { "ad7817", ID_AD7817 }, { "ad7818", ID_AD7818 }, {} }; MODULE_DEVICE_TABLE(spi, ad7816_id); static struct spi_driver ad7816_driver = { .driver = { .name = "ad7816", .of_match_table = ad7816_of_match, }, .probe = ad7816_probe, .id_table = ad7816_id, }; module_spi_driver(ad7816_driver); MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>"); MODULE_DESCRIPTION("Analog Devices AD7816/7/8 digital temperature sensor driver"); MODULE_LICENSE("GPL v2");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1