drivers/hwmon/sht15.c

   1 /*
   2  * sht15.c - support for the SHT15 Temperature and Humidity Sensor
   3  *
   4  * Copyright (c) 2009 Jonathan Cameron
   5  *
   6  * Copyright (c) 2007 Wouter Horre
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  * Currently ignoring checksum on readings.
  13  * Default resolution only (14bit temp, 12bit humidity)
  14  * Ignoring battery status.
  15  * Heater not enabled.
  16  * Timings are all conservative.
  17  *
  18  * Data sheet available (1/2009) at
  19  * http://www.sensirion.ch/en/pdf/product_information/Datasheet-humidity-sensor-SHT1x.pdf
  20  *
  21  * Regulator supply name = vcc
  22  */
  23
  24 #include <linux/interrupt.h>
  25 #include <linux/irq.h>
  26 #include <linux/gpio.h>
  27 #include <linux/module.h>
  28 #include <linux/init.h>
  29 #include <linux/hwmon.h>
  30 #include <linux/hwmon-sysfs.h>
  31 #include <linux/mutex.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/sched.h>
  34 #include <linux/delay.h>
  35 #include <linux/jiffies.h>
  36 #include <linux/err.h>
  37 #include <linux/sht15.h>
  38 #include <linux/regulator/consumer.h>
  39 #include <asm/atomic.h>
  40
  41 #define SHT15_MEASURE_TEMP      3
  42 #define SHT15_MEASURE_RH        5
  43
  44 #define SHT15_READING_NOTHING   0
  45 #define SHT15_READING_TEMP      1
  46 #define SHT15_READING_HUMID     2
  47
  48 /* Min timings in nsecs */
  49 #define SHT15_TSCKL             100     /* clock low */
  50 #define SHT15_TSCKH             100     /* clock high */
  51 #define SHT15_TSU               150     /* data setup time */
  52
  53 /**
  54  * struct sht15_temppair - elements of voltage dependant temp calc
  55  * @vdd:        supply voltage in microvolts
  56  * @d1:         see data sheet
  57  */
  58 struct sht15_temppair {
  59         int vdd; /* microvolts */
  60         int d1;
  61 };
  62
  63 /* Table 9 from data sheet - relates temperature calculation
  64  * to supply voltage.
  65  */
  66 static const struct sht15_temppair temppoints[] = {
  67         { 2500000, -39400 },
  68         { 3000000, -39600 },
  69         { 3500000, -39700 },
  70         { 4000000, -39800 },
  71         { 5000000, -40100 },
  72 };
  73
  74 /**
  75  * struct sht15_data - device instance specific data
  76  * @pdata:      platform data (gpio's etc)
  77  * @read_work:  bh of interrupt handler
  78  * @wait_queue: wait queue for getting values from device
  79  * @val_temp:   last temperature value read from device
  80  * @val_humid:  last humidity value read from device
  81  * @flag:       status flag used to identify what the last request was
  82  * @valid:      are the current stored values valid (start condition)
  83  * @last_updat: time of last update
  84  * @read_lock:  mutex to ensure only one read in progress
  85  *              at a time.
  86  * @dev:        associate device structure
  87  * @hwmon_dev:  device associated with hwmon subsystem
  88  * @reg:        associated regulator (if specified)
  89  * @nb:         notifier block to handle notifications of voltage changes
  90  * @supply_uV:  local copy of supply voltage used to allow
  91  *              use of regulator consumer if available
  92  * @supply_uV_valid:   indicates that an updated value has not yet
  93  *              been obtained from the regulator and so any calculations
  94  *              based upon it will be invalid.
  95  * @update_supply_work: work struct that is used to update the supply_uV
  96  * @interrupt_handled:  flag used to indicate a hander has been scheduled
  97  */
  98 struct sht15_data {
  99         struct sht15_platform_data      *pdata;
 100         struct work_struct              read_work;
 101         wait_queue_head_t               wait_queue;
 102         uint16_t                        val_temp;
 103         uint16_t                        val_humid;
 104         u8                              flag;
 105         u8                              valid;
 106         unsigned long                   last_updat;
 107         struct mutex                    read_lock;
 108         struct device                   *dev;
 109         struct device                   *hwmon_dev;
 110         struct regulator                *reg;
 111         struct notifier_block           nb;
 112         int                             supply_uV;
 113         int                             supply_uV_valid;
 114         struct work_struct              update_supply_work;
 115         atomic_t                        interrupt_handled;
 116 };
 117
 118 /**
 119  * sht15_connection_reset() - reset the comms interface
 120  * @data:       sht15 specific data
 121  *
 122  * This implements section 3.4 of the data sheet
 123  */
 124 static void sht15_connection_reset(struct sht15_data *data)
 125 {
 126         int i;
 127         gpio_direction_output(data->pdata->gpio_data, 1);
 128         ndelay(SHT15_TSCKL);
 129         gpio_set_value(data->pdata->gpio_sck, 0);
 130         ndelay(SHT15_TSCKL);
 131         for (i = 0; i < 9; ++i) {
 132                 gpio_set_value(data->pdata->gpio_sck, 1);
 133                 ndelay(SHT15_TSCKH);
 134                 gpio_set_value(data->pdata->gpio_sck, 0);
 135                 ndelay(SHT15_TSCKL);
 136         }
 137 }
 138 /**
 139  * sht15_send_bit() - send an individual bit to the device
 140  * @data:       device state data
 141  * @val:        value of bit to be sent
 142  **/
 143 static inline void sht15_send_bit(struct sht15_data *data, int val)
 144 {
 145
 146         gpio_set_value(data->pdata->gpio_data, val);
 147         ndelay(SHT15_TSU);
 148         gpio_set_value(data->pdata->gpio_sck, 1);
 149         ndelay(SHT15_TSCKH);
 150         gpio_set_value(data->pdata->gpio_sck, 0);
 151         ndelay(SHT15_TSCKL); /* clock low time */
 152 }
 153
 154 /**
 155  * sht15_transmission_start() - specific sequence for new transmission
 156  *
 157  * @data:       device state data
 158  * Timings for this are not documented on the data sheet, so very
 159  * conservative ones used in implementation. This implements
 160  * figure 12 on the data sheet.
 161  **/
 162 static void sht15_transmission_start(struct sht15_data *data)
 163 {
 164         /* ensure data is high and output */
 165         gpio_direction_output(data->pdata->gpio_data, 1);
 166         ndelay(SHT15_TSU);
 167         gpio_set_value(data->pdata->gpio_sck, 0);
 168         ndelay(SHT15_TSCKL);
 169         gpio_set_value(data->pdata->gpio_sck, 1);
 170         ndelay(SHT15_TSCKH);
 171         gpio_set_value(data->pdata->gpio_data, 0);
 172         ndelay(SHT15_TSU);
 173         gpio_set_value(data->pdata->gpio_sck, 0);
 174         ndelay(SHT15_TSCKL);
 175         gpio_set_value(data->pdata->gpio_sck, 1);
 176         ndelay(SHT15_TSCKH);
 177         gpio_set_value(data->pdata->gpio_data, 1);
 178         ndelay(SHT15_TSU);
 179         gpio_set_value(data->pdata->gpio_sck, 0);
 180         ndelay(SHT15_TSCKL);
 181 }
 182 /**
 183  * sht15_send_byte() - send a single byte to the device
 184  * @data:       device state
 185  * @byte:       value to be sent
 186  **/
 187 static void sht15_send_byte(struct sht15_data *data, u8 byte)
 188 {
 189         int i;
 190         for (i = 0; i < 8; i++) {
 191                 sht15_send_bit(data, !!(byte & 0x80));
 192                 byte <<= 1;
 193         }
 194 }
 195 /**
 196  * sht15_wait_for_response() - checks for ack from device
 197  * @data:       device state
 198  **/
 199 static int sht15_wait_for_response(struct sht15_data *data)
 200 {
 201         gpio_direction_input(data->pdata->gpio_data);
 202         gpio_set_value(data->pdata->gpio_sck, 1);
 203         ndelay(SHT15_TSCKH);
 204         if (gpio_get_value(data->pdata->gpio_data)) {
 205                 gpio_set_value(data->pdata->gpio_sck, 0);
 206                 dev_err(data->dev, "Command not acknowledged\n");
 207                 sht15_connection_reset(data);
 208                 return -EIO;
 209         }
 210         gpio_set_value(data->pdata->gpio_sck, 0);
 211         ndelay(SHT15_TSCKL);
 212         return 0;
 213 }
 214
 215 /**
 216  * sht15_send_cmd() - Sends a command to the device.
 217  * @data:       device state
 218  * @cmd:        command byte to be sent
 219  *
 220  * On entry, sck is output low, data is output pull high
 221  * and the interrupt disabled.
 222  **/
 223 static int sht15_send_cmd(struct sht15_data *data, u8 cmd)
 224 {
 225         int ret = 0;
 226         sht15_transmission_start(data);
 227         sht15_send_byte(data, cmd);
 228         ret = sht15_wait_for_response(data);
 229         return ret;
 230 }
 231 /**
 232  * sht15_update_single_val() - get a new value from device
 233  * @data:               device instance specific data
 234  * @command:            command sent to request value
 235  * @timeout_msecs:      timeout after which comms are assumed
 236  *                      to have failed are reset.
 237  **/
 238 static inline int sht15_update_single_val(struct sht15_data *data,
 239                                           int command,
 240                                           int timeout_msecs)
 241 {
 242         int ret;
 243         ret = sht15_send_cmd(data, command);
 244         if (ret)
 245                 return ret;
 246
 247         gpio_direction_input(data->pdata->gpio_data);
 248         atomic_set(&data->interrupt_handled, 0);
 249
 250         enable_irq(gpio_to_irq(data->pdata->gpio_data));
 251         if (gpio_get_value(data->pdata->gpio_data) == 0) {
 252                 disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data));
 253                 /* Only relevant if the interrupt hasn't occured. */
 254                 if (!atomic_read(&data->interrupt_handled))
 255                         schedule_work(&data->read_work);
 256         }
 257         ret = wait_event_timeout(data->wait_queue,
 258                                  (data->flag == SHT15_READING_NOTHING),
 259                                  msecs_to_jiffies(timeout_msecs));
 260         if (ret == 0) {/* timeout occurred */
 261                 disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data));
 262                 sht15_connection_reset(data);
 263                 return -ETIME;
 264         }
 265         return 0;
 266 }
 267
 268 /**
 269  * sht15_update_vals() - get updated readings from device if too old
 270  * @data:       device state
 271  **/
 272 static int sht15_update_vals(struct sht15_data *data)
 273 {
 274         int ret = 0;
 275         int timeout = HZ;
 276
 277         mutex_lock(&data->read_lock);
 278         if (time_after(jiffies, data->last_updat + timeout)
 279             || !data->valid) {
 280                 data->flag = SHT15_READING_HUMID;
 281                 ret = sht15_update_single_val(data, SHT15_MEASURE_RH, 160);
 282                 if (ret)
 283                         goto error_ret;
 284                 data->flag = SHT15_READING_TEMP;
 285                 ret = sht15_update_single_val(data, SHT15_MEASURE_TEMP, 400);
 286                 if (ret)
 287                         goto error_ret;
 288                 data->valid = 1;
 289                 data->last_updat = jiffies;
 290         }
 291 error_ret:
 292         mutex_unlock(&data->read_lock);
 293
 294         return ret;
 295 }
 296
 297 /**
 298  * sht15_calc_temp() - convert the raw reading to a temperature
 299  * @data:       device state
 300  *
 301  * As per section 4.3 of the data sheet.
 302  **/
 303 static inline int sht15_calc_temp(struct sht15_data *data)
 304 {
 305         int d1 = 0;
 306         int i;
 307
 308         for (i = 1; i < ARRAY_SIZE(temppoints); i++)
 309                 /* Find pointer to interpolate */
 310                 if (data->supply_uV > temppoints[i - 1].vdd) {
 311                         d1 = (data->supply_uV/1000 - temppoints[i - 1].vdd)
 312                                 * (temppoints[i].d1 - temppoints[i - 1].d1)
 313                                 / (temppoints[i].vdd - temppoints[i - 1].vdd)
 314                                 + temppoints[i - 1].d1;
 315                         break;
 316                 }
 317
 318         return data->val_temp*10 + d1;
 319 }
 320
 321 /**
 322  * sht15_calc_humid() - using last temperature convert raw to humid
 323  * @data:       device state
 324  *
 325  * This is the temperature compensated version as per section 4.2 of
 326  * the data sheet.
 327  **/
 328 static inline int sht15_calc_humid(struct sht15_data *data)
 329 {
 330         int RHlinear; /* milli percent */
 331         int temp = sht15_calc_temp(data);
 332
 333         const int c1 = -4;
 334         const int c2 = 40500; /* x 10 ^ -6 */
 335         const int c3 = -2800; /* x10 ^ -9 */
 336
 337         RHlinear = c1*1000
 338                 + c2 * data->val_humid/1000
 339                 + (data->val_humid * data->val_humid * c3)/1000000;
 340         return (temp - 25000) * (10000 + 80 * data->val_humid)
 341                 / 1000000 + RHlinear;
 342 }
 343
 344 static ssize_t sht15_show_temp(struct device *dev,
 345                                struct device_attribute *attr,
 346                                char *buf)
 347 {
 348         int ret;
 349         struct sht15_data *data = dev_get_drvdata(dev);
 350
 351         /* Technically no need to read humidity as well */
 352         ret = sht15_update_vals(data);
 353
 354         return ret ? ret : sprintf(buf, "%d\n",
 355                                    sht15_calc_temp(data));
 356 }
 357
 358 static ssize_t sht15_show_humidity(struct device *dev,
 359                                    struct device_attribute *attr,
 360                                    char *buf)
 361 {
 362         int ret;
 363         struct sht15_data *data = dev_get_drvdata(dev);
 364
 365         ret = sht15_update_vals(data);
 366
 367         return ret ? ret : sprintf(buf, "%d\n", sht15_calc_humid(data));
 368
 369 };
 370 static ssize_t show_name(struct device *dev,
 371                          struct device_attribute *attr,
 372                          char *buf)
 373 {
 374         struct platform_device *pdev = to_platform_device(dev);
 375         return sprintf(buf, "%s\n", pdev->name);
 376 }
 377
 378 static SENSOR_DEVICE_ATTR(temp1_input,
 379                           S_IRUGO, sht15_show_temp,
 380                           NULL, 0);
 381 static SENSOR_DEVICE_ATTR(humidity1_input,
 382                           S_IRUGO, sht15_show_humidity,
 383                           NULL, 0);
 384 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 385 static struct attribute *sht15_attrs[] = {
 386         &sensor_dev_attr_temp1_input.dev_attr.attr,
 387         &sensor_dev_attr_humidity1_input.dev_attr.attr,
 388         &dev_attr_name.attr,
 389         NULL,
 390 };
 391
 392 static const struct attribute_group sht15_attr_group = {
 393         .attrs = sht15_attrs,
 394 };
 395
 396 static irqreturn_t sht15_interrupt_fired(int irq, void *d)
 397 {
 398         struct sht15_data *data = d;
 399         /* First disable the interrupt */
 400         disable_irq_nosync(irq);
 401         atomic_inc(&data->interrupt_handled);
 402         /* Then schedule a reading work struct */
 403         if (data->flag != SHT15_READING_NOTHING)
 404                 schedule_work(&data->read_work);
 405         return IRQ_HANDLED;
 406 }
 407
 408 /* Each byte of data is acknowledged by pulling the data line
 409  * low for one clock pulse.
 410  */
 411 static void sht15_ack(struct sht15_data *data)
 412 {
 413         gpio_direction_output(data->pdata->gpio_data, 0);
 414         ndelay(SHT15_TSU);
 415         gpio_set_value(data->pdata->gpio_sck, 1);
 416         ndelay(SHT15_TSU);
 417         gpio_set_value(data->pdata->gpio_sck, 0);
 418         ndelay(SHT15_TSU);
 419         gpio_set_value(data->pdata->gpio_data, 1);
 420
 421         gpio_direction_input(data->pdata->gpio_data);
 422 }
 423 /**
 424  * sht15_end_transmission() - notify device of end of transmission
 425  * @data:       device state
 426  *
 427  * This is basically a NAK. (single clock pulse, data high)
 428  **/
 429 static void sht15_end_transmission(struct sht15_data *data)
 430 {
 431         gpio_direction_output(data->pdata->gpio_data, 1);
 432         ndelay(SHT15_TSU);
 433         gpio_set_value(data->pdata->gpio_sck, 1);
 434         ndelay(SHT15_TSCKH);
 435         gpio_set_value(data->pdata->gpio_sck, 0);
 436         ndelay(SHT15_TSCKL);
 437 }
 438
 439 static void sht15_bh_read_data(struct work_struct *work_s)
 440 {
 441         int i;
 442         uint16_t val = 0;
 443         struct sht15_data *data
 444                 = container_of(work_s, struct sht15_data,
 445                                read_work);
 446         /* Firstly, verify the line is low */
 447         if (gpio_get_value(data->pdata->gpio_data)) {
 448                 /* If not, then start the interrupt again - care
 449                    here as could have gone low in meantime so verify
 450                    it hasn't!
 451                 */
 452                 atomic_set(&data->interrupt_handled, 0);
 453                 enable_irq(gpio_to_irq(data->pdata->gpio_data));
 454                 /* If still not occured or another handler has been scheduled */
 455                 if (gpio_get_value(data->pdata->gpio_data)
 456                     || atomic_read(&data->interrupt_handled))
 457                         return;
 458         }
 459         /* Read the data back from the device */
 460         for (i = 0; i < 16; ++i) {
 461                 val <<= 1;
 462                 gpio_set_value(data->pdata->gpio_sck, 1);
 463                 ndelay(SHT15_TSCKH);
 464                 val |= !!gpio_get_value(data->pdata->gpio_data);
 465                 gpio_set_value(data->pdata->gpio_sck, 0);
 466                 ndelay(SHT15_TSCKL);
 467                 if (i == 7)
 468                         sht15_ack(data);
 469         }
 470         /* Tell the device we are done */
 471         sht15_end_transmission(data);
 472
 473         switch (data->flag) {
 474         case SHT15_READING_TEMP:
 475                 data->val_temp = val;
 476                 break;
 477         case SHT15_READING_HUMID:
 478                 data->val_humid = val;
 479                 break;
 480         }
 481
 482         data->flag = SHT15_READING_NOTHING;
 483         wake_up(&data->wait_queue);
 484 }
 485
 486 static void sht15_update_voltage(struct work_struct *work_s)
 487 {
 488         struct sht15_data *data
 489                 = container_of(work_s, struct sht15_data,
 490                                update_supply_work);
 491         data->supply_uV = regulator_get_voltage(data->reg);
 492 }
 493
 494 /**
 495  * sht15_invalidate_voltage() - mark supply voltage invalid when notified by reg
 496  * @nb:         associated notification structure
 497  * @event:      voltage regulator state change event code
 498  * @ignored:    function parameter - ignored here
 499  *
 500  * Note that as the notification code holds the regulator lock, we have
 501  * to schedule an update of the supply voltage rather than getting it directly.
 502  **/
 503 static int sht15_invalidate_voltage(struct notifier_block *nb,
 504                                 unsigned long event,
 505                                 void *ignored)
 506 {
 507         struct sht15_data *data = container_of(nb, struct sht15_data, nb);
 508
 509         if (event == REGULATOR_EVENT_VOLTAGE_CHANGE)
 510                 data->supply_uV_valid = false;
 511         schedule_work(&data->update_supply_work);
 512
 513         return NOTIFY_OK;
 514 }
 515
 516 static int __devinit sht15_probe(struct platform_device *pdev)
 517 {
 518         int ret = 0;
 519         struct sht15_data *data = kzalloc(sizeof(*data), GFP_KERNEL);
 520
 521         if (!data) {
 522                 ret = -ENOMEM;
 523                 dev_err(&pdev->dev, "kzalloc failed");
 524                 goto error_ret;
 525         }
 526
 527         INIT_WORK(&data->read_work, sht15_bh_read_data);
 528         INIT_WORK(&data->update_supply_work, sht15_update_voltage);
 529         platform_set_drvdata(pdev, data);
 530         mutex_init(&data->read_lock);
 531         data->dev = &pdev->dev;
 532         init_waitqueue_head(&data->wait_queue);
 533
 534         if (pdev->dev.platform_data == NULL) {
 535                 dev_err(&pdev->dev, "no platform data supplied");
 536                 goto err_free_data;
 537         }
 538         data->pdata = pdev->dev.platform_data;
 539         data->supply_uV = data->pdata->supply_mv*1000;
 540
 541 /* If a regulator is available, query what the supply voltage actually is!*/
 542         data->reg = regulator_get(data->dev, "vcc");
 543         if (!IS_ERR(data->reg)) {
 544                 data->supply_uV = regulator_get_voltage(data->reg);
 545                 regulator_enable(data->reg);
 546                 /* setup a notifier block to update this if another device
 547                  *  causes the voltage to change */
 548                 data->nb.notifier_call = &sht15_invalidate_voltage;
 549                 ret = regulator_register_notifier(data->reg, &data->nb);
 550         }
 551 /* Try requesting the GPIOs */
 552         ret = gpio_request(data->pdata->gpio_sck, "SHT15 sck");
 553         if (ret) {
 554                 dev_err(&pdev->dev, "gpio request failed");
 555                 goto err_free_data;
 556         }
 557         gpio_direction_output(data->pdata->gpio_sck, 0);
 558         ret = gpio_request(data->pdata->gpio_data, "SHT15 data");
 559         if (ret) {
 560                 dev_err(&pdev->dev, "gpio request failed");
 561                 goto err_release_gpio_sck;
 562         }
 563         ret = sysfs_create_group(&pdev->dev.kobj, &sht15_attr_group);
 564         if (ret) {
 565                 dev_err(&pdev->dev, "sysfs create failed");
 566                 goto err_release_gpio_data;
 567         }
 568
 569         ret = request_irq(gpio_to_irq(data->pdata->gpio_data),
 570                           sht15_interrupt_fired,
 571                           IRQF_TRIGGER_FALLING,
 572                           "sht15 data",
 573                           data);
 574         if (ret) {
 575                 dev_err(&pdev->dev, "failed to get irq for data line");
 576                 goto err_release_gpio_data;
 577         }
 578         disable_irq_nosync(gpio_to_irq(data->pdata->gpio_data));
 579         sht15_connection_reset(data);
 580         sht15_send_cmd(data, 0x1E);
 581
 582         data->hwmon_dev = hwmon_device_register(data->dev);
 583         if (IS_ERR(data->hwmon_dev)) {
 584                 ret = PTR_ERR(data->hwmon_dev);
 585                 goto err_release_irq;
 586         }
 587         return 0;
 588
 589 err_release_irq:
 590         free_irq(gpio_to_irq(data->pdata->gpio_data), data);
 591 err_release_gpio_data:
 592         gpio_free(data->pdata->gpio_data);
 593 err_release_gpio_sck:
 594         gpio_free(data->pdata->gpio_sck);
 595 err_free_data:
 596         kfree(data);
 597 error_ret:
 598
 599         return ret;
 600 }
 601
 602 static int __devexit sht15_remove(struct platform_device *pdev)
 603 {
 604         struct sht15_data *data = platform_get_drvdata(pdev);
 605
 606         /* Make sure any reads from the device are done and
 607          * prevent new ones beginnning */
 608         mutex_lock(&data->read_lock);
 609         hwmon_device_unregister(data->hwmon_dev);
 610         sysfs_remove_group(&pdev->dev.kobj, &sht15_attr_group);
 611         if (!IS_ERR(data->reg)) {
 612                 regulator_unregister_notifier(data->reg, &data->nb);
 613                 regulator_disable(data->reg);
 614                 regulator_put(data->reg);
 615         }
 616
 617         free_irq(gpio_to_irq(data->pdata->gpio_data), data);
 618         gpio_free(data->pdata->gpio_data);
 619         gpio_free(data->pdata->gpio_sck);
 620         mutex_unlock(&data->read_lock);
 621         kfree(data);
 622         return 0;
 623 }
 624
 625
 626 /*
 627  * sht_drivers simultaneously refers to __devinit and __devexit function
 628  * which causes spurious section mismatch warning. So use __refdata to
 629  * get rid from this.
 630  */
 631 static struct platform_driver __refdata sht_drivers[] = {
 632         {
 633                 .driver = {
 634                         .name = "sht10",
 635                         .owner = THIS_MODULE,
 636                 },
 637                 .probe = sht15_probe,
 638                 .remove = __devexit_p(sht15_remove),
 639         }, {
 640                 .driver = {
 641                         .name = "sht11",
 642                         .owner = THIS_MODULE,
 643                 },
 644                 .probe = sht15_probe,
 645                 .remove = __devexit_p(sht15_remove),
 646         }, {
 647                 .driver = {
 648                         .name = "sht15",
 649                         .owner = THIS_MODULE,
 650                 },
 651                 .probe = sht15_probe,
 652                 .remove = __devexit_p(sht15_remove),
 653         }, {
 654                 .driver = {
 655                         .name = "sht71",
 656                         .owner = THIS_MODULE,
 657                 },
 658                 .probe = sht15_probe,
 659                 .remove = __devexit_p(sht15_remove),
 660         }, {
 661                 .driver = {
 662                         .name = "sht75",
 663                         .owner = THIS_MODULE,
 664                 },
 665                 .probe = sht15_probe,
 666                 .remove = __devexit_p(sht15_remove),
 667         },
 668 };
 669
 670
 671 static int __init sht15_init(void)
 672 {
 673         int ret;
 674         int i;
 675
 676         for (i = 0; i < ARRAY_SIZE(sht_drivers); i++) {
 677                 ret = platform_driver_register(&sht_drivers[i]);
 678                 if (ret)
 679                         goto error_unreg;
 680         }
 681
 682         return 0;
 683
 684 error_unreg:
 685         while (--i >= 0)
 686                 platform_driver_unregister(&sht_drivers[i]);
 687
 688         return ret;
 689 }
 690 module_init(sht15_init);
 691
 692 static void __exit sht15_exit(void)
 693 {
 694         int i;
 695         for (i = ARRAY_SIZE(sht_drivers) - 1; i >= 0; i--)
 696                 platform_driver_unregister(&sht_drivers[i]);
 697 }
 698 module_exit(sht15_exit);
 699
 700 MODULE_LICENSE("GPL");