drivers/hwmon/lm70.c

   1 /*
   2  * lm70.c
   3  *
   4  * The LM70 is a temperature sensor chip from National Semiconductor (NS).
   5  * Copyright (C) 2006 Kaiwan N Billimoria <kaiwan@designergraphix.com>
   6  *
   7  * The LM70 communicates with a host processor via an SPI/Microwire Bus
   8  * interface. The complete datasheet is available at National's website
   9  * here:
  10  * http://www.national.com/pf/LM/LM70.html
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  */
  26
  27 #include <linux/init.h>
  28 #include <linux/module.h>
  29 #include <linux/kernel.h>
  30 #include <linux/device.h>
  31 #include <linux/err.h>
  32 #include <linux/sysfs.h>
  33 #include <linux/hwmon.h>
  34 #include <linux/mutex.h>
  35 #include <linux/spi/spi.h>
  36
  37
  38 #define DRVNAME         "lm70"
  39
  40 #define LM70_CHIP_LM70          0       /* original NS LM70 */
  41 #define LM70_CHIP_TMP121        1       /* TI TMP121/TMP123 */
  42
  43 struct lm70 {
  44         struct device *hwmon_dev;
  45         struct mutex lock;
  46         unsigned int chip;
  47 };
  48
  49 /* sysfs hook function */
  50 static ssize_t lm70_sense_temp(struct device *dev,
  51                 struct device_attribute *attr, char *buf)
  52 {
  53         struct spi_device *spi = to_spi_device(dev);
  54         int status, val = 0;
  55         u8 rxbuf[2];
  56         s16 raw=0;
  57         struct lm70 *p_lm70 = dev_get_drvdata(&spi->dev);
  58
  59         if (mutex_lock_interruptible(&p_lm70->lock))
  60                 return -ERESTARTSYS;
  61
  62         /*
  63          * spi_read() requires a DMA-safe buffer; so we use
  64          * spi_write_then_read(), transmitting 0 bytes.
  65          */
  66         status = spi_write_then_read(spi, NULL, 0, &rxbuf[0], 2);
  67         if (status < 0) {
  68                 printk(KERN_WARNING
  69                 "spi_write_then_read failed with status %d\n", status);
  70                 goto out;
  71         }
  72         raw = (rxbuf[0] << 8) + rxbuf[1];
  73         dev_dbg(dev, "rxbuf[0] : 0x%02x rxbuf[1] : 0x%02x raw=0x%04x\n",
  74                 rxbuf[0], rxbuf[1], raw);
  75
  76         /*
  77          * LM70:
  78          * The "raw" temperature read into rxbuf[] is a 16-bit signed 2's
  79          * complement value. Only the MSB 11 bits (1 sign + 10 temperature
  80          * bits) are meaningful; the LSB 5 bits are to be discarded.
  81          * See the datasheet.
  82          *
  83          * Further, each bit represents 0.25 degrees Celsius; so, multiply
  84          * by 0.25. Also multiply by 1000 to represent in millidegrees
  85          * Celsius.
  86          * So it's equivalent to multiplying by 0.25 * 1000 = 250.
  87          *
  88          * TMP121/TMP123:
  89          * 13 bits of 2's complement data, discard LSB 3 bits,
  90          * resolution 0.0625 degrees celsius.
  91          */
  92         switch (p_lm70->chip) {
  93         case LM70_CHIP_LM70:
  94                 val = ((int)raw / 32) * 250;
  95                 break;
  96
  97         case LM70_CHIP_TMP121:
  98                 val = ((int)raw / 8) * 625 / 10;
  99                 break;
 100         }
 101
 102         status = sprintf(buf, "%d\n", val); /* millidegrees Celsius */
 103 out:
 104         mutex_unlock(&p_lm70->lock);
 105         return status;
 106 }
 107
 108 static DEVICE_ATTR(temp1_input, S_IRUGO, lm70_sense_temp, NULL);
 109
 110 static ssize_t lm70_show_name(struct device *dev, struct device_attribute
 111                               *devattr, char *buf)
 112 {
 113         struct lm70 *p_lm70 = dev_get_drvdata(dev);
 114         int ret;
 115
 116         switch (p_lm70->chip) {
 117         case LM70_CHIP_LM70:
 118                 ret = sprintf(buf, "lm70\n");
 119                 break;
 120         case LM70_CHIP_TMP121:
 121                 ret = sprintf(buf, "tmp121\n");
 122                 break;
 123         default:
 124                 ret = -EINVAL;
 125         }
 126         return ret;
 127 }
 128
 129 static DEVICE_ATTR(name, S_IRUGO, lm70_show_name, NULL);
 130
 131 /*----------------------------------------------------------------------*/
 132
 133 static int __devinit common_probe(struct spi_device *spi, int chip)
 134 {
 135         struct lm70 *p_lm70;
 136         int status;
 137
 138         /* NOTE:  we assume 8-bit words, and convert to 16 bits manually */
 139
 140         p_lm70 = kzalloc(sizeof *p_lm70, GFP_KERNEL);
 141         if (!p_lm70)
 142                 return -ENOMEM;
 143
 144         mutex_init(&p_lm70->lock);
 145         p_lm70->chip = chip;
 146
 147         /* sysfs hook */
 148         p_lm70->hwmon_dev = hwmon_device_register(&spi->dev);
 149         if (IS_ERR(p_lm70->hwmon_dev)) {
 150                 dev_dbg(&spi->dev, "hwmon_device_register failed.\n");
 151                 status = PTR_ERR(p_lm70->hwmon_dev);
 152                 goto out_dev_reg_failed;
 153         }
 154         dev_set_drvdata(&spi->dev, p_lm70);
 155
 156         if ((status = device_create_file(&spi->dev, &dev_attr_temp1_input))
 157          || (status = device_create_file(&spi->dev, &dev_attr_name))) {
 158                 dev_dbg(&spi->dev, "device_create_file failure.\n");
 159                 goto out_dev_create_file_failed;
 160         }
 161
 162         return 0;
 163
 164 out_dev_create_file_failed:
 165         device_remove_file(&spi->dev, &dev_attr_temp1_input);
 166         hwmon_device_unregister(p_lm70->hwmon_dev);
 167 out_dev_reg_failed:
 168         dev_set_drvdata(&spi->dev, NULL);
 169         kfree(p_lm70);
 170         return status;
 171 }
 172
 173 static int __devinit lm70_probe(struct spi_device *spi)
 174 {
 175         /* signaling is SPI_MODE_0 on a 3-wire link (shared SI/SO) */
 176         if ((spi->mode & (SPI_CPOL | SPI_CPHA)) || !(spi->mode & SPI_3WIRE))
 177                 return -EINVAL;
 178
 179         return common_probe(spi, LM70_CHIP_LM70);
 180 }
 181
 182 static int __devinit tmp121_probe(struct spi_device *spi)
 183 {
 184         /* signaling is SPI_MODE_0 with only MISO connected */
 185         if (spi->mode & (SPI_CPOL | SPI_CPHA))
 186                 return -EINVAL;
 187
 188         return common_probe(spi, LM70_CHIP_TMP121);
 189 }
 190
 191 static int __devexit lm70_remove(struct spi_device *spi)
 192 {
 193         struct lm70 *p_lm70 = dev_get_drvdata(&spi->dev);
 194
 195         device_remove_file(&spi->dev, &dev_attr_temp1_input);
 196         device_remove_file(&spi->dev, &dev_attr_name);
 197         hwmon_device_unregister(p_lm70->hwmon_dev);
 198         dev_set_drvdata(&spi->dev, NULL);
 199         kfree(p_lm70);
 200
 201         return 0;
 202 }
 203
 204 static struct spi_driver tmp121_driver = {
 205         .driver = {
 206                 .name   = "tmp121",
 207                 .owner  = THIS_MODULE,
 208         },
 209         .probe  = tmp121_probe,
 210         .remove = __devexit_p(lm70_remove),
 211 };
 212
 213 static struct spi_driver lm70_driver = {
 214         .driver = {
 215                 .name   = "lm70",
 216                 .owner  = THIS_MODULE,
 217         },
 218         .probe  = lm70_probe,
 219         .remove = __devexit_p(lm70_remove),
 220 };
 221
 222 static int __init init_lm70(void)
 223 {
 224         int ret = spi_register_driver(&lm70_driver);
 225         if (ret)
 226                 return ret;
 227
 228         ret = spi_register_driver(&tmp121_driver);
 229         if (ret)
 230                 spi_unregister_driver(&lm70_driver);
 231
 232         return ret;
 233 }
 234
 235 static void __exit cleanup_lm70(void)
 236 {
 237         spi_unregister_driver(&lm70_driver);
 238         spi_unregister_driver(&tmp121_driver);
 239 }
 240
 241 module_init(init_lm70);
 242 module_exit(cleanup_lm70);
 243
 244 MODULE_AUTHOR("Kaiwan N Billimoria");
 245 MODULE_DESCRIPTION("NS LM70 / TI TMP121/TMP123 Linux driver");
 246 MODULE_LICENSE("GPL");