drivers/hwmon/ftsteutates.c

   1 /*
   2  * Support for the FTS Systemmonitoring Chip "Teutates"
   3  *
   4  * Copyright (C) 2016 Fujitsu Technology Solutions GmbH,
   5  *                Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  */
  18 #include <linux/err.h>
  19 #include <linux/fs.h>
  20 #include <linux/hwmon.h>
  21 #include <linux/hwmon-sysfs.h>
  22 #include <linux/i2c.h>
  23 #include <linux/init.h>
  24 #include <linux/jiffies.h>
  25 #include <linux/module.h>
  26 #include <linux/mutex.h>
  27 #include <linux/slab.h>
  28 #include <linux/sysfs.h>
  29 #include <linux/uaccess.h>
  30 #include <linux/watchdog.h>
  31
  32 #define FTS_DEVICE_ID_REG               0x0000
  33 #define FTS_DEVICE_REVISION_REG         0x0001
  34 #define FTS_DEVICE_STATUS_REG           0x0004
  35 #define FTS_SATELLITE_STATUS_REG        0x0005
  36 #define FTS_EVENT_STATUS_REG            0x0006
  37 #define FTS_GLOBAL_CONTROL_REG          0x0007
  38
  39 #define FTS_DEVICE_DETECT_REG_1         0x0C
  40 #define FTS_DEVICE_DETECT_REG_2         0x0D
  41 #define FTS_DEVICE_DETECT_REG_3         0x0E
  42
  43 #define FTS_SENSOR_EVENT_REG            0x0010
  44
  45 #define FTS_FAN_EVENT_REG               0x0014
  46 #define FTS_FAN_PRESENT_REG             0x0015
  47
  48 #define FTS_POWER_ON_TIME_COUNTER_A     0x007A
  49 #define FTS_POWER_ON_TIME_COUNTER_B     0x007B
  50 #define FTS_POWER_ON_TIME_COUNTER_C     0x007C
  51
  52 #define FTS_PAGE_SELECT_REG             0x007F
  53
  54 #define FTS_WATCHDOG_TIME_PRESET        0x000B
  55 #define FTS_WATCHDOG_CONTROL            0x5081
  56
  57 #define FTS_NO_FAN_SENSORS              0x08
  58 #define FTS_NO_TEMP_SENSORS             0x10
  59 #define FTS_NO_VOLT_SENSORS             0x04
  60
  61 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
  62
  63 static const struct i2c_device_id fts_id[] = {
  64         { "ftsteutates", 0 },
  65         { }
  66 };
  67 MODULE_DEVICE_TABLE(i2c, fts_id);
  68
  69 enum WATCHDOG_RESOLUTION {
  70         seconds = 1,
  71         minutes = 60
  72 };
  73
  74 struct fts_data {
  75         struct i2c_client *client;
  76         /* update sensor data lock */
  77         struct mutex update_lock;
  78         /* read/write register lock */
  79         struct mutex access_lock;
  80         unsigned long last_updated; /* in jiffies */
  81         struct watchdog_device wdd;
  82         enum WATCHDOG_RESOLUTION resolution;
  83         bool valid; /* false until following fields are valid */
  84
  85         u8 volt[FTS_NO_VOLT_SENSORS];
  86
  87         u8 temp_input[FTS_NO_TEMP_SENSORS];
  88         u8 temp_alarm;
  89
  90         u8 fan_present;
  91         u8 fan_input[FTS_NO_FAN_SENSORS]; /* in rps */
  92         u8 fan_source[FTS_NO_FAN_SENSORS];
  93         u8 fan_alarm;
  94 };
  95
  96 #define FTS_REG_FAN_INPUT(idx) ((idx) + 0x20)
  97 #define FTS_REG_FAN_SOURCE(idx) ((idx) + 0x30)
  98 #define FTS_REG_FAN_CONTROL(idx) (((idx) << 16) + 0x4881)
  99
 100 #define FTS_REG_TEMP_INPUT(idx) ((idx) + 0x40)
 101 #define FTS_REG_TEMP_CONTROL(idx) (((idx) << 16) + 0x0681)
 102
 103 #define FTS_REG_VOLT(idx) ((idx) + 0x18)
 104
 105 /*****************************************************************************/
 106 /* I2C Helper functions                                                      */
 107 /*****************************************************************************/
 108 static int fts_read_byte(struct i2c_client *client, unsigned short reg)
 109 {
 110         int ret;
 111         unsigned char page = reg >> 8;
 112         struct fts_data *data = dev_get_drvdata(&client->dev);
 113
 114         mutex_lock(&data->access_lock);
 115
 116         dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
 117         ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page);
 118         if (ret < 0)
 119                 goto error;
 120
 121         reg &= 0xFF;
 122         ret = i2c_smbus_read_byte_data(client, reg);
 123         dev_dbg(&client->dev, "read - reg: 0x%.02x: val: 0x%.02x\n", reg, ret);
 124
 125 error:
 126         mutex_unlock(&data->access_lock);
 127         return ret;
 128 }
 129
 130 static int fts_write_byte(struct i2c_client *client, unsigned short reg,
 131                           unsigned char value)
 132 {
 133         int ret;
 134         unsigned char page = reg >> 8;
 135         struct fts_data *data = dev_get_drvdata(&client->dev);
 136
 137         mutex_lock(&data->access_lock);
 138
 139         dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
 140         ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page);
 141         if (ret < 0)
 142                 goto error;
 143
 144         reg &= 0xFF;
 145         dev_dbg(&client->dev,
 146                 "write - reg: 0x%.02x: val: 0x%.02x\n", reg, value);
 147         ret = i2c_smbus_write_byte_data(client, reg, value);
 148
 149 error:
 150         mutex_unlock(&data->access_lock);
 151         return ret;
 152 }
 153
 154 /*****************************************************************************/
 155 /* Data Updater Helper function                                              */
 156 /*****************************************************************************/
 157 static int fts_update_device(struct fts_data *data)
 158 {
 159         int i;
 160         int err = 0;
 161
 162         mutex_lock(&data->update_lock);
 163         if (!time_after(jiffies, data->last_updated + 2 * HZ) && data->valid)
 164                 goto exit;
 165
 166         err = fts_read_byte(data->client, FTS_DEVICE_STATUS_REG);
 167         if (err < 0)
 168                 goto exit;
 169
 170         data->valid = !!(err & 0x02); /* Data not ready yet */
 171         if (unlikely(!data->valid)) {
 172                 err = -EAGAIN;
 173                 goto exit;
 174         }
 175
 176         err = fts_read_byte(data->client, FTS_FAN_PRESENT_REG);
 177         if (err < 0)
 178                 goto exit;
 179         data->fan_present = err;
 180
 181         err = fts_read_byte(data->client, FTS_FAN_EVENT_REG);
 182         if (err < 0)
 183                 goto exit;
 184         data->fan_alarm = err;
 185
 186         for (i = 0; i < FTS_NO_FAN_SENSORS; i++) {
 187                 if (data->fan_present & BIT(i)) {
 188                         err = fts_read_byte(data->client, FTS_REG_FAN_INPUT(i));
 189                         if (err < 0)
 190                                 goto exit;
 191                         data->fan_input[i] = err;
 192
 193                         err = fts_read_byte(data->client,
 194                                             FTS_REG_FAN_SOURCE(i));
 195                         if (err < 0)
 196                                 goto exit;
 197                         data->fan_source[i] = err;
 198                 } else {
 199                         data->fan_input[i] = 0;
 200                         data->fan_source[i] = 0;
 201                 }
 202         }
 203
 204         err = fts_read_byte(data->client, FTS_SENSOR_EVENT_REG);
 205         if (err < 0)
 206                 goto exit;
 207         data->temp_alarm = err;
 208
 209         for (i = 0; i < FTS_NO_TEMP_SENSORS; i++) {
 210                 err = fts_read_byte(data->client, FTS_REG_TEMP_INPUT(i));
 211                 if (err < 0)
 212                         goto exit;
 213                 data->temp_input[i] = err;
 214         }
 215
 216         for (i = 0; i < FTS_NO_VOLT_SENSORS; i++) {
 217                 err = fts_read_byte(data->client, FTS_REG_VOLT(i));
 218                 if (err < 0)
 219                         goto exit;
 220                 data->volt[i] = err;
 221         }
 222         data->last_updated = jiffies;
 223         err = 0;
 224 exit:
 225         mutex_unlock(&data->update_lock);
 226         return err;
 227 }
 228
 229 /*****************************************************************************/
 230 /* Watchdog functions                                                        */
 231 /*****************************************************************************/
 232 static int fts_wd_set_resolution(struct fts_data *data,
 233                                  enum WATCHDOG_RESOLUTION resolution)
 234 {
 235         int ret;
 236
 237         if (data->resolution == resolution)
 238                 return 0;
 239
 240         ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL);
 241         if (ret < 0)
 242                 return ret;
 243
 244         if ((resolution == seconds && ret & BIT(1)) ||
 245             (resolution == minutes && (ret & BIT(1)) == 0)) {
 246                 data->resolution = resolution;
 247                 return 0;
 248         }
 249
 250         if (resolution == seconds)
 251                 ret |= BIT(1);
 252         else
 253                 ret &= ~BIT(1);
 254
 255         ret = fts_write_byte(data->client, FTS_WATCHDOG_CONTROL, ret);
 256         if (ret < 0)
 257                 return ret;
 258
 259         data->resolution = resolution;
 260         return ret;
 261 }
 262
 263 static int fts_wd_set_timeout(struct watchdog_device *wdd, unsigned int timeout)
 264 {
 265         struct fts_data *data;
 266         enum WATCHDOG_RESOLUTION resolution = seconds;
 267         int ret;
 268
 269         data = watchdog_get_drvdata(wdd);
 270         /* switch watchdog resolution to minutes if timeout does not fit
 271          * into a byte
 272          */
 273         if (timeout > 0xFF) {
 274                 timeout = DIV_ROUND_UP(timeout, 60) * 60;
 275                 resolution = minutes;
 276         }
 277
 278         ret = fts_wd_set_resolution(data, resolution);
 279         if (ret < 0)
 280                 return ret;
 281
 282         wdd->timeout = timeout;
 283         return 0;
 284 }
 285
 286 static int fts_wd_start(struct watchdog_device *wdd)
 287 {
 288         struct fts_data *data = watchdog_get_drvdata(wdd);
 289
 290         return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET,
 291                               wdd->timeout / (u8)data->resolution);
 292 }
 293
 294 static int fts_wd_stop(struct watchdog_device *wdd)
 295 {
 296         struct fts_data *data;
 297
 298         data = watchdog_get_drvdata(wdd);
 299         return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET, 0);
 300 }
 301
 302 static const struct watchdog_info fts_wd_info = {
 303         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
 304         .identity = "FTS Teutates Hardware Watchdog",
 305 };
 306
 307 static const struct watchdog_ops fts_wd_ops = {
 308         .owner = THIS_MODULE,
 309         .start = fts_wd_start,
 310         .stop = fts_wd_stop,
 311         .set_timeout = fts_wd_set_timeout,
 312 };
 313
 314 static int fts_watchdog_init(struct fts_data *data)
 315 {
 316         int timeout, ret;
 317
 318         watchdog_set_drvdata(&data->wdd, data);
 319
 320         timeout = fts_read_byte(data->client, FTS_WATCHDOG_TIME_PRESET);
 321         if (timeout < 0)
 322                 return timeout;
 323
 324         /* watchdog not running, set timeout to a default of 60 sec. */
 325         if (timeout == 0) {
 326                 ret = fts_wd_set_resolution(data, seconds);
 327                 if (ret < 0)
 328                         return ret;
 329                 data->wdd.timeout = 60;
 330         } else {
 331                 ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL);
 332                 if (ret < 0)
 333                         return ret;
 334
 335                 data->resolution = ret & BIT(1) ? seconds : minutes;
 336                 data->wdd.timeout = timeout * (u8)data->resolution;
 337                 set_bit(WDOG_HW_RUNNING, &data->wdd.status);
 338         }
 339
 340         /* Register our watchdog part */
 341         data->wdd.info = &fts_wd_info;
 342         data->wdd.ops = &fts_wd_ops;
 343         data->wdd.parent = &data->client->dev;
 344         data->wdd.min_timeout = 1;
 345
 346         /* max timeout 255 minutes. */
 347         data->wdd.max_hw_heartbeat_ms = 0xFF * 60 * MSEC_PER_SEC;
 348
 349         return watchdog_register_device(&data->wdd);
 350 }
 351
 352 /*****************************************************************************/
 353 /* SysFS handler functions                                                   */
 354 /*****************************************************************************/
 355 static ssize_t show_in_value(struct device *dev,
 356                              struct device_attribute *devattr, char *buf)
 357 {
 358         struct fts_data *data = dev_get_drvdata(dev);
 359         int index = to_sensor_dev_attr(devattr)->index;
 360         int err;
 361
 362         err = fts_update_device(data);
 363         if (err < 0)
 364                 return err;
 365
 366         return sprintf(buf, "%u\n", data->volt[index]);
 367 }
 368
 369 static ssize_t show_temp_value(struct device *dev,
 370                                struct device_attribute *devattr, char *buf)
 371 {
 372         struct fts_data *data = dev_get_drvdata(dev);
 373         int index = to_sensor_dev_attr(devattr)->index;
 374         int err;
 375
 376         err = fts_update_device(data);
 377         if (err < 0)
 378                 return err;
 379
 380         return sprintf(buf, "%u\n", data->temp_input[index]);
 381 }
 382
 383 static ssize_t show_temp_fault(struct device *dev,
 384                                struct device_attribute *devattr, char *buf)
 385 {
 386         struct fts_data *data = dev_get_drvdata(dev);
 387         int index = to_sensor_dev_attr(devattr)->index;
 388         int err;
 389
 390         err = fts_update_device(data);
 391         if (err < 0)
 392                 return err;
 393
 394         /* 00h Temperature = Sensor Error */
 395         return sprintf(buf, "%d\n", data->temp_input[index] == 0);
 396 }
 397
 398 static ssize_t show_temp_alarm(struct device *dev,
 399                                struct device_attribute *devattr, char *buf)
 400 {
 401         struct fts_data *data = dev_get_drvdata(dev);
 402         int index = to_sensor_dev_attr(devattr)->index;
 403         int err;
 404
 405         err = fts_update_device(data);
 406         if (err < 0)
 407                 return err;
 408
 409         return sprintf(buf, "%u\n", !!(data->temp_alarm & BIT(index)));
 410 }
 411
 412 static ssize_t
 413 clear_temp_alarm(struct device *dev, struct device_attribute *devattr,
 414                  const char *buf, size_t count)
 415 {
 416         struct fts_data *data = dev_get_drvdata(dev);
 417         int index = to_sensor_dev_attr(devattr)->index;
 418         long ret;
 419
 420         ret = fts_update_device(data);
 421         if (ret < 0)
 422                 return ret;
 423
 424         if (kstrtoul(buf, 10, &ret) || ret != 0)
 425                 return -EINVAL;
 426
 427         mutex_lock(&data->update_lock);
 428         ret = fts_read_byte(data->client, FTS_REG_TEMP_CONTROL(index));
 429         if (ret < 0)
 430                 goto error;
 431
 432         ret = fts_write_byte(data->client, FTS_REG_TEMP_CONTROL(index),
 433                              ret | 0x1);
 434         if (ret < 0)
 435                 goto error;
 436
 437         data->valid = false;
 438         ret = count;
 439 error:
 440         mutex_unlock(&data->update_lock);
 441         return ret;
 442 }
 443
 444 static ssize_t show_fan_value(struct device *dev,
 445                               struct device_attribute *devattr, char *buf)
 446 {
 447         struct fts_data *data = dev_get_drvdata(dev);
 448         int index = to_sensor_dev_attr(devattr)->index;
 449         int err;
 450
 451         err = fts_update_device(data);
 452         if (err < 0)
 453                 return err;
 454
 455         return sprintf(buf, "%u\n", data->fan_input[index]);
 456 }
 457
 458 static ssize_t show_fan_source(struct device *dev,
 459                                struct device_attribute *devattr, char *buf)
 460 {
 461         struct fts_data *data = dev_get_drvdata(dev);
 462         int index = to_sensor_dev_attr(devattr)->index;
 463         int err;
 464
 465         err = fts_update_device(data);
 466         if (err < 0)
 467                 return err;
 468
 469         return sprintf(buf, "%u\n", data->fan_source[index]);
 470 }
 471
 472 static ssize_t show_fan_alarm(struct device *dev,
 473                               struct device_attribute *devattr, char *buf)
 474 {
 475         struct fts_data *data = dev_get_drvdata(dev);
 476         int index = to_sensor_dev_attr(devattr)->index;
 477         int err;
 478
 479         err = fts_update_device(data);
 480         if (err < 0)
 481                 return err;
 482
 483         return sprintf(buf, "%d\n", !!(data->fan_alarm & BIT(index)));
 484 }
 485
 486 static ssize_t
 487 clear_fan_alarm(struct device *dev, struct device_attribute *devattr,
 488                 const char *buf, size_t count)
 489 {
 490         struct fts_data *data = dev_get_drvdata(dev);
 491         int index = to_sensor_dev_attr(devattr)->index;
 492         long ret;
 493
 494         ret = fts_update_device(data);
 495         if (ret < 0)
 496                 return ret;
 497
 498         if (kstrtoul(buf, 10, &ret) || ret != 0)
 499                 return -EINVAL;
 500
 501         mutex_lock(&data->update_lock);
 502         ret = fts_read_byte(data->client, FTS_REG_FAN_CONTROL(index));
 503         if (ret < 0)
 504                 goto error;
 505
 506         ret = fts_write_byte(data->client, FTS_REG_FAN_CONTROL(index),
 507                              ret | 0x1);
 508         if (ret < 0)
 509                 goto error;
 510
 511         data->valid = false;
 512         ret = count;
 513 error:
 514         mutex_unlock(&data->update_lock);
 515         return ret;
 516 }
 517
 518 /*****************************************************************************/
 519 /* SysFS structs                                                             */
 520 /*****************************************************************************/
 521
 522 /* Temprature sensors */
 523 static SENSOR_DEVICE_ATTR(temp1_input,  S_IRUGO, show_temp_value, NULL, 0);
 524 static SENSOR_DEVICE_ATTR(temp2_input,  S_IRUGO, show_temp_value, NULL, 1);
 525 static SENSOR_DEVICE_ATTR(temp3_input,  S_IRUGO, show_temp_value, NULL, 2);
 526 static SENSOR_DEVICE_ATTR(temp4_input,  S_IRUGO, show_temp_value, NULL, 3);
 527 static SENSOR_DEVICE_ATTR(temp5_input,  S_IRUGO, show_temp_value, NULL, 4);
 528 static SENSOR_DEVICE_ATTR(temp6_input,  S_IRUGO, show_temp_value, NULL, 5);
 529 static SENSOR_DEVICE_ATTR(temp7_input,  S_IRUGO, show_temp_value, NULL, 6);
 530 static SENSOR_DEVICE_ATTR(temp8_input,  S_IRUGO, show_temp_value, NULL, 7);
 531 static SENSOR_DEVICE_ATTR(temp9_input,  S_IRUGO, show_temp_value, NULL, 8);
 532 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, show_temp_value, NULL, 9);
 533 static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO, show_temp_value, NULL, 10);
 534 static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO, show_temp_value, NULL, 11);
 535 static SENSOR_DEVICE_ATTR(temp13_input, S_IRUGO, show_temp_value, NULL, 12);
 536 static SENSOR_DEVICE_ATTR(temp14_input, S_IRUGO, show_temp_value, NULL, 13);
 537 static SENSOR_DEVICE_ATTR(temp15_input, S_IRUGO, show_temp_value, NULL, 14);
 538 static SENSOR_DEVICE_ATTR(temp16_input, S_IRUGO, show_temp_value, NULL, 15);
 539
 540 static SENSOR_DEVICE_ATTR(temp1_fault,  S_IRUGO, show_temp_fault, NULL, 0);
 541 static SENSOR_DEVICE_ATTR(temp2_fault,  S_IRUGO, show_temp_fault, NULL, 1);
 542 static SENSOR_DEVICE_ATTR(temp3_fault,  S_IRUGO, show_temp_fault, NULL, 2);
 543 static SENSOR_DEVICE_ATTR(temp4_fault,  S_IRUGO, show_temp_fault, NULL, 3);
 544 static SENSOR_DEVICE_ATTR(temp5_fault,  S_IRUGO, show_temp_fault, NULL, 4);
 545 static SENSOR_DEVICE_ATTR(temp6_fault,  S_IRUGO, show_temp_fault, NULL, 5);
 546 static SENSOR_DEVICE_ATTR(temp7_fault,  S_IRUGO, show_temp_fault, NULL, 6);
 547 static SENSOR_DEVICE_ATTR(temp8_fault,  S_IRUGO, show_temp_fault, NULL, 7);
 548 static SENSOR_DEVICE_ATTR(temp9_fault,  S_IRUGO, show_temp_fault, NULL, 8);
 549 static SENSOR_DEVICE_ATTR(temp10_fault, S_IRUGO, show_temp_fault, NULL, 9);
 550 static SENSOR_DEVICE_ATTR(temp11_fault, S_IRUGO, show_temp_fault, NULL, 10);
 551 static SENSOR_DEVICE_ATTR(temp12_fault, S_IRUGO, show_temp_fault, NULL, 11);
 552 static SENSOR_DEVICE_ATTR(temp13_fault, S_IRUGO, show_temp_fault, NULL, 12);
 553 static SENSOR_DEVICE_ATTR(temp14_fault, S_IRUGO, show_temp_fault, NULL, 13);
 554 static SENSOR_DEVICE_ATTR(temp15_fault, S_IRUGO, show_temp_fault, NULL, 14);
 555 static SENSOR_DEVICE_ATTR(temp16_fault, S_IRUGO, show_temp_fault, NULL, 15);
 556
 557 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 558                           clear_temp_alarm, 0);
 559 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 560                           clear_temp_alarm, 1);
 561 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 562                           clear_temp_alarm, 2);
 563 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 564                           clear_temp_alarm, 3);
 565 static SENSOR_DEVICE_ATTR(temp5_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 566                           clear_temp_alarm, 4);
 567 static SENSOR_DEVICE_ATTR(temp6_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 568                           clear_temp_alarm, 5);
 569 static SENSOR_DEVICE_ATTR(temp7_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 570                           clear_temp_alarm, 6);
 571 static SENSOR_DEVICE_ATTR(temp8_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 572                           clear_temp_alarm, 7);
 573 static SENSOR_DEVICE_ATTR(temp9_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 574                           clear_temp_alarm, 8);
 575 static SENSOR_DEVICE_ATTR(temp10_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 576                           clear_temp_alarm, 9);
 577 static SENSOR_DEVICE_ATTR(temp11_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 578                           clear_temp_alarm, 10);
 579 static SENSOR_DEVICE_ATTR(temp12_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 580                           clear_temp_alarm, 11);
 581 static SENSOR_DEVICE_ATTR(temp13_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 582                           clear_temp_alarm, 12);
 583 static SENSOR_DEVICE_ATTR(temp14_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 584                           clear_temp_alarm, 13);
 585 static SENSOR_DEVICE_ATTR(temp15_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 586                           clear_temp_alarm, 14);
 587 static SENSOR_DEVICE_ATTR(temp16_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 588                           clear_temp_alarm, 15);
 589
 590 static struct attribute *fts_temp_attrs[] = {
 591         &sensor_dev_attr_temp1_input.dev_attr.attr,
 592         &sensor_dev_attr_temp2_input.dev_attr.attr,
 593         &sensor_dev_attr_temp3_input.dev_attr.attr,
 594         &sensor_dev_attr_temp4_input.dev_attr.attr,
 595         &sensor_dev_attr_temp5_input.dev_attr.attr,
 596         &sensor_dev_attr_temp6_input.dev_attr.attr,
 597         &sensor_dev_attr_temp7_input.dev_attr.attr,
 598         &sensor_dev_attr_temp8_input.dev_attr.attr,
 599         &sensor_dev_attr_temp9_input.dev_attr.attr,
 600         &sensor_dev_attr_temp10_input.dev_attr.attr,
 601         &sensor_dev_attr_temp11_input.dev_attr.attr,
 602         &sensor_dev_attr_temp12_input.dev_attr.attr,
 603         &sensor_dev_attr_temp13_input.dev_attr.attr,
 604         &sensor_dev_attr_temp14_input.dev_attr.attr,
 605         &sensor_dev_attr_temp15_input.dev_attr.attr,
 606         &sensor_dev_attr_temp16_input.dev_attr.attr,
 607
 608         &sensor_dev_attr_temp1_fault.dev_attr.attr,
 609         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 610         &sensor_dev_attr_temp3_fault.dev_attr.attr,
 611         &sensor_dev_attr_temp4_fault.dev_attr.attr,
 612         &sensor_dev_attr_temp5_fault.dev_attr.attr,
 613         &sensor_dev_attr_temp6_fault.dev_attr.attr,
 614         &sensor_dev_attr_temp7_fault.dev_attr.attr,
 615         &sensor_dev_attr_temp8_fault.dev_attr.attr,
 616         &sensor_dev_attr_temp9_fault.dev_attr.attr,
 617         &sensor_dev_attr_temp10_fault.dev_attr.attr,
 618         &sensor_dev_attr_temp11_fault.dev_attr.attr,
 619         &sensor_dev_attr_temp12_fault.dev_attr.attr,
 620         &sensor_dev_attr_temp13_fault.dev_attr.attr,
 621         &sensor_dev_attr_temp14_fault.dev_attr.attr,
 622         &sensor_dev_attr_temp15_fault.dev_attr.attr,
 623         &sensor_dev_attr_temp16_fault.dev_attr.attr,
 624
 625         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 626         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
 627         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
 628         &sensor_dev_attr_temp4_alarm.dev_attr.attr,
 629         &sensor_dev_attr_temp5_alarm.dev_attr.attr,
 630         &sensor_dev_attr_temp6_alarm.dev_attr.attr,
 631         &sensor_dev_attr_temp7_alarm.dev_attr.attr,
 632         &sensor_dev_attr_temp8_alarm.dev_attr.attr,
 633         &sensor_dev_attr_temp9_alarm.dev_attr.attr,
 634         &sensor_dev_attr_temp10_alarm.dev_attr.attr,
 635         &sensor_dev_attr_temp11_alarm.dev_attr.attr,
 636         &sensor_dev_attr_temp12_alarm.dev_attr.attr,
 637         &sensor_dev_attr_temp13_alarm.dev_attr.attr,
 638         &sensor_dev_attr_temp14_alarm.dev_attr.attr,
 639         &sensor_dev_attr_temp15_alarm.dev_attr.attr,
 640         &sensor_dev_attr_temp16_alarm.dev_attr.attr,
 641         NULL
 642 };
 643
 644 /* Fans */
 645 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_value, NULL, 0);
 646 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_value, NULL, 1);
 647 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_value, NULL, 2);
 648 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_value, NULL, 3);
 649 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan_value, NULL, 4);
 650 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan_value, NULL, 5);
 651 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan_value, NULL, 6);
 652 static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan_value, NULL, 7);
 653
 654 static SENSOR_DEVICE_ATTR(fan1_source, S_IRUGO, show_fan_source, NULL, 0);
 655 static SENSOR_DEVICE_ATTR(fan2_source, S_IRUGO, show_fan_source, NULL, 1);
 656 static SENSOR_DEVICE_ATTR(fan3_source, S_IRUGO, show_fan_source, NULL, 2);
 657 static SENSOR_DEVICE_ATTR(fan4_source, S_IRUGO, show_fan_source, NULL, 3);
 658 static SENSOR_DEVICE_ATTR(fan5_source, S_IRUGO, show_fan_source, NULL, 4);
 659 static SENSOR_DEVICE_ATTR(fan6_source, S_IRUGO, show_fan_source, NULL, 5);
 660 static SENSOR_DEVICE_ATTR(fan7_source, S_IRUGO, show_fan_source, NULL, 6);
 661 static SENSOR_DEVICE_ATTR(fan8_source, S_IRUGO, show_fan_source, NULL, 7);
 662
 663 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO | S_IWUSR,
 664                          show_fan_alarm, clear_fan_alarm, 0);
 665 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO | S_IWUSR,
 666                          show_fan_alarm, clear_fan_alarm, 1);
 667 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO | S_IWUSR,
 668                          show_fan_alarm, clear_fan_alarm, 2);
 669 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO | S_IWUSR,
 670                          show_fan_alarm, clear_fan_alarm, 3);
 671 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO | S_IWUSR,
 672                          show_fan_alarm, clear_fan_alarm, 4);
 673 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO | S_IWUSR,
 674                          show_fan_alarm, clear_fan_alarm, 5);
 675 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO | S_IWUSR,
 676                          show_fan_alarm, clear_fan_alarm, 6);
 677 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO | S_IWUSR,
 678                          show_fan_alarm, clear_fan_alarm, 7);
 679
 680 static struct attribute *fts_fan_attrs[] = {
 681         &sensor_dev_attr_fan1_input.dev_attr.attr,
 682         &sensor_dev_attr_fan2_input.dev_attr.attr,
 683         &sensor_dev_attr_fan3_input.dev_attr.attr,
 684         &sensor_dev_attr_fan4_input.dev_attr.attr,
 685         &sensor_dev_attr_fan5_input.dev_attr.attr,
 686         &sensor_dev_attr_fan6_input.dev_attr.attr,
 687         &sensor_dev_attr_fan7_input.dev_attr.attr,
 688         &sensor_dev_attr_fan8_input.dev_attr.attr,
 689
 690         &sensor_dev_attr_fan1_source.dev_attr.attr,
 691         &sensor_dev_attr_fan2_source.dev_attr.attr,
 692         &sensor_dev_attr_fan3_source.dev_attr.attr,
 693         &sensor_dev_attr_fan4_source.dev_attr.attr,
 694         &sensor_dev_attr_fan5_source.dev_attr.attr,
 695         &sensor_dev_attr_fan6_source.dev_attr.attr,
 696         &sensor_dev_attr_fan7_source.dev_attr.attr,
 697         &sensor_dev_attr_fan8_source.dev_attr.attr,
 698
 699         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 700         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 701         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
 702         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
 703         &sensor_dev_attr_fan5_alarm.dev_attr.attr,
 704         &sensor_dev_attr_fan6_alarm.dev_attr.attr,
 705         &sensor_dev_attr_fan7_alarm.dev_attr.attr,
 706         &sensor_dev_attr_fan8_alarm.dev_attr.attr,
 707         NULL
 708 };
 709
 710 /* Voltages */
 711 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_value, NULL, 0);
 712 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_value, NULL, 1);
 713 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_value, NULL, 2);
 714 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_value, NULL, 3);
 715 static struct attribute *fts_voltage_attrs[] = {
 716         &sensor_dev_attr_in1_input.dev_attr.attr,
 717         &sensor_dev_attr_in2_input.dev_attr.attr,
 718         &sensor_dev_attr_in3_input.dev_attr.attr,
 719         &sensor_dev_attr_in4_input.dev_attr.attr,
 720         NULL
 721 };
 722
 723 static const struct attribute_group fts_voltage_attr_group = {
 724         .attrs = fts_voltage_attrs
 725 };
 726
 727 static const struct attribute_group fts_temp_attr_group = {
 728         .attrs = fts_temp_attrs
 729 };
 730
 731 static const struct attribute_group fts_fan_attr_group = {
 732         .attrs = fts_fan_attrs
 733 };
 734
 735 static const struct attribute_group *fts_attr_groups[] = {
 736         &fts_voltage_attr_group,
 737         &fts_temp_attr_group,
 738         &fts_fan_attr_group,
 739         NULL
 740 };
 741
 742 /*****************************************************************************/
 743 /* Module initialization / remove functions                                  */
 744 /*****************************************************************************/
 745 static int fts_detect(struct i2c_client *client,
 746                       struct i2c_board_info *info)
 747 {
 748         int val;
 749
 750         /* detection works with revsion greater or equal to 0x2b */
 751         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
 752         if (val < 0x2b)
 753                 return -ENODEV;
 754
 755         /* Device Detect Regs must have 0x17 0x34 and 0x54 */
 756         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_1);
 757         if (val != 0x17)
 758                 return -ENODEV;
 759
 760         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_2);
 761         if (val != 0x34)
 762                 return -ENODEV;
 763
 764         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_3);
 765         if (val != 0x54)
 766                 return -ENODEV;
 767
 768         /*
 769          * 0x10 == Baseboard Management Controller, 0x01 == Teutates
 770          * Device ID Reg needs to be 0x11
 771          */
 772         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
 773         if (val != 0x11)
 774                 return -ENODEV;
 775
 776         strlcpy(info->type, fts_id[0].name, I2C_NAME_SIZE);
 777         info->flags = 0;
 778         return 0;
 779 }
 780
 781 static int fts_remove(struct i2c_client *client)
 782 {
 783         struct fts_data *data = dev_get_drvdata(&client->dev);
 784
 785         watchdog_unregister_device(&data->wdd);
 786         return 0;
 787 }
 788
 789 static int fts_probe(struct i2c_client *client, const struct i2c_device_id *id)
 790 {
 791         u8 revision;
 792         struct fts_data *data;
 793         int err;
 794         s8 deviceid;
 795         struct device *hwmon_dev;
 796
 797         if (client->addr != 0x73)
 798                 return -ENODEV;
 799
 800         /* Baseboard Management Controller check */
 801         deviceid = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
 802         if (deviceid > 0 && (deviceid & 0xF0) == 0x10) {
 803                 switch (deviceid & 0x0F) {
 804                 case 0x01:
 805                         break;
 806                 default:
 807                         dev_dbg(&client->dev,
 808                                 "No Baseboard Management Controller\n");
 809                         return -ENODEV;
 810                 }
 811         } else {
 812                 dev_dbg(&client->dev, "No fujitsu board\n");
 813                 return -ENODEV;
 814         }
 815
 816         data = devm_kzalloc(&client->dev, sizeof(struct fts_data),
 817                             GFP_KERNEL);
 818         if (!data)
 819                 return -ENOMEM;
 820
 821         mutex_init(&data->update_lock);
 822         mutex_init(&data->access_lock);
 823         data->client = client;
 824         dev_set_drvdata(&client->dev, data);
 825
 826         err = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
 827         if (err < 0)
 828                 return err;
 829         revision = err;
 830
 831         hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
 832                                                            "ftsteutates",
 833                                                            data,
 834                                                            fts_attr_groups);
 835         if (IS_ERR(hwmon_dev))
 836                 return PTR_ERR(hwmon_dev);
 837
 838         err = fts_watchdog_init(data);
 839         if (err)
 840                 return err;
 841
 842         dev_info(&client->dev, "Detected FTS Teutates chip, revision: %d.%d\n",
 843                  (revision & 0xF0) >> 4, revision & 0x0F);
 844         return 0;
 845 }
 846
 847 /*****************************************************************************/
 848 /* Module Details                                                            */
 849 /*****************************************************************************/
 850 static struct i2c_driver fts_driver = {
 851         .class = I2C_CLASS_HWMON,
 852         .driver = {
 853                 .name = "ftsteutates",
 854         },
 855         .id_table = fts_id,
 856         .probe = fts_probe,
 857         .remove = fts_remove,
 858         .detect = fts_detect,
 859         .address_list = normal_i2c,
 860 };
 861
 862 module_i2c_driver(fts_driver);
 863
 864 MODULE_AUTHOR("Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>");
 865 MODULE_DESCRIPTION("FTS Teutates driver");
 866 MODULE_LICENSE("GPL");