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