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 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 error:
 439         mutex_unlock(&data->update_lock);
 440         return ret;
 441 }
 442
 443 static ssize_t show_fan_value(struct device *dev,
 444                               struct device_attribute *devattr, char *buf)
 445 {
 446         struct fts_data *data = dev_get_drvdata(dev);
 447         int index = to_sensor_dev_attr(devattr)->index;
 448         int err;
 449
 450         err = fts_update_device(data);
 451         if (err < 0)
 452                 return err;
 453
 454         return sprintf(buf, "%u\n", data->fan_input[index]);
 455 }
 456
 457 static ssize_t show_fan_source(struct device *dev,
 458                                struct device_attribute *devattr, char *buf)
 459 {
 460         struct fts_data *data = dev_get_drvdata(dev);
 461         int index = to_sensor_dev_attr(devattr)->index;
 462         int err;
 463
 464         err = fts_update_device(data);
 465         if (err < 0)
 466                 return err;
 467
 468         return sprintf(buf, "%u\n", data->fan_source[index]);
 469 }
 470
 471 static ssize_t show_fan_alarm(struct device *dev,
 472                               struct device_attribute *devattr, char *buf)
 473 {
 474         struct fts_data *data = dev_get_drvdata(dev);
 475         int index = to_sensor_dev_attr(devattr)->index;
 476         int err;
 477
 478         err = fts_update_device(data);
 479         if (err < 0)
 480                 return err;
 481
 482         return sprintf(buf, "%d\n", !!(data->fan_alarm & BIT(index)));
 483 }
 484
 485 static ssize_t
 486 clear_fan_alarm(struct device *dev, struct device_attribute *devattr,
 487                 const char *buf, size_t count)
 488 {
 489         struct fts_data *data = dev_get_drvdata(dev);
 490         int index = to_sensor_dev_attr(devattr)->index;
 491         long ret;
 492
 493         ret = fts_update_device(data);
 494         if (ret < 0)
 495                 return ret;
 496
 497         if (kstrtoul(buf, 10, &ret) || ret != 0)
 498                 return -EINVAL;
 499
 500         mutex_lock(&data->update_lock);
 501         ret = fts_read_byte(data->client, FTS_REG_FAN_CONTROL(index));
 502         if (ret < 0)
 503                 goto error;
 504
 505         ret = fts_write_byte(data->client, FTS_REG_FAN_CONTROL(index),
 506                              ret | 0x1);
 507         if (ret < 0)
 508                 goto error;
 509
 510         data->valid = false;
 511 error:
 512         mutex_unlock(&data->update_lock);
 513         return ret;
 514 }
 515
 516 /*****************************************************************************/
 517 /* SysFS structs                                                             */
 518 /*****************************************************************************/
 519
 520 /* Temprature sensors */
 521 static SENSOR_DEVICE_ATTR(temp1_input,  S_IRUGO, show_temp_value, NULL, 0);
 522 static SENSOR_DEVICE_ATTR(temp2_input,  S_IRUGO, show_temp_value, NULL, 1);
 523 static SENSOR_DEVICE_ATTR(temp3_input,  S_IRUGO, show_temp_value, NULL, 2);
 524 static SENSOR_DEVICE_ATTR(temp4_input,  S_IRUGO, show_temp_value, NULL, 3);
 525 static SENSOR_DEVICE_ATTR(temp5_input,  S_IRUGO, show_temp_value, NULL, 4);
 526 static SENSOR_DEVICE_ATTR(temp6_input,  S_IRUGO, show_temp_value, NULL, 5);
 527 static SENSOR_DEVICE_ATTR(temp7_input,  S_IRUGO, show_temp_value, NULL, 6);
 528 static SENSOR_DEVICE_ATTR(temp8_input,  S_IRUGO, show_temp_value, NULL, 7);
 529 static SENSOR_DEVICE_ATTR(temp9_input,  S_IRUGO, show_temp_value, NULL, 8);
 530 static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, show_temp_value, NULL, 9);
 531 static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO, show_temp_value, NULL, 10);
 532 static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO, show_temp_value, NULL, 11);
 533 static SENSOR_DEVICE_ATTR(temp13_input, S_IRUGO, show_temp_value, NULL, 12);
 534 static SENSOR_DEVICE_ATTR(temp14_input, S_IRUGO, show_temp_value, NULL, 13);
 535 static SENSOR_DEVICE_ATTR(temp15_input, S_IRUGO, show_temp_value, NULL, 14);
 536 static SENSOR_DEVICE_ATTR(temp16_input, S_IRUGO, show_temp_value, NULL, 15);
 537
 538 static SENSOR_DEVICE_ATTR(temp1_fault,  S_IRUGO, show_temp_fault, NULL, 0);
 539 static SENSOR_DEVICE_ATTR(temp2_fault,  S_IRUGO, show_temp_fault, NULL, 1);
 540 static SENSOR_DEVICE_ATTR(temp3_fault,  S_IRUGO, show_temp_fault, NULL, 2);
 541 static SENSOR_DEVICE_ATTR(temp4_fault,  S_IRUGO, show_temp_fault, NULL, 3);
 542 static SENSOR_DEVICE_ATTR(temp5_fault,  S_IRUGO, show_temp_fault, NULL, 4);
 543 static SENSOR_DEVICE_ATTR(temp6_fault,  S_IRUGO, show_temp_fault, NULL, 5);
 544 static SENSOR_DEVICE_ATTR(temp7_fault,  S_IRUGO, show_temp_fault, NULL, 6);
 545 static SENSOR_DEVICE_ATTR(temp8_fault,  S_IRUGO, show_temp_fault, NULL, 7);
 546 static SENSOR_DEVICE_ATTR(temp9_fault,  S_IRUGO, show_temp_fault, NULL, 8);
 547 static SENSOR_DEVICE_ATTR(temp10_fault, S_IRUGO, show_temp_fault, NULL, 9);
 548 static SENSOR_DEVICE_ATTR(temp11_fault, S_IRUGO, show_temp_fault, NULL, 10);
 549 static SENSOR_DEVICE_ATTR(temp12_fault, S_IRUGO, show_temp_fault, NULL, 11);
 550 static SENSOR_DEVICE_ATTR(temp13_fault, S_IRUGO, show_temp_fault, NULL, 12);
 551 static SENSOR_DEVICE_ATTR(temp14_fault, S_IRUGO, show_temp_fault, NULL, 13);
 552 static SENSOR_DEVICE_ATTR(temp15_fault, S_IRUGO, show_temp_fault, NULL, 14);
 553 static SENSOR_DEVICE_ATTR(temp16_fault, S_IRUGO, show_temp_fault, NULL, 15);
 554
 555 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 556                           clear_temp_alarm, 0);
 557 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 558                           clear_temp_alarm, 1);
 559 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 560                           clear_temp_alarm, 2);
 561 static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 562                           clear_temp_alarm, 3);
 563 static SENSOR_DEVICE_ATTR(temp5_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 564                           clear_temp_alarm, 4);
 565 static SENSOR_DEVICE_ATTR(temp6_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 566                           clear_temp_alarm, 5);
 567 static SENSOR_DEVICE_ATTR(temp7_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 568                           clear_temp_alarm, 6);
 569 static SENSOR_DEVICE_ATTR(temp8_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 570                           clear_temp_alarm, 7);
 571 static SENSOR_DEVICE_ATTR(temp9_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 572                           clear_temp_alarm, 8);
 573 static SENSOR_DEVICE_ATTR(temp10_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 574                           clear_temp_alarm, 9);
 575 static SENSOR_DEVICE_ATTR(temp11_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 576                           clear_temp_alarm, 10);
 577 static SENSOR_DEVICE_ATTR(temp12_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 578                           clear_temp_alarm, 11);
 579 static SENSOR_DEVICE_ATTR(temp13_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 580                           clear_temp_alarm, 12);
 581 static SENSOR_DEVICE_ATTR(temp14_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 582                           clear_temp_alarm, 13);
 583 static SENSOR_DEVICE_ATTR(temp15_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 584                           clear_temp_alarm, 14);
 585 static SENSOR_DEVICE_ATTR(temp16_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
 586                           clear_temp_alarm, 15);
 587
 588 static struct attribute *fts_temp_attrs[] = {
 589         &sensor_dev_attr_temp1_input.dev_attr.attr,
 590         &sensor_dev_attr_temp2_input.dev_attr.attr,
 591         &sensor_dev_attr_temp3_input.dev_attr.attr,
 592         &sensor_dev_attr_temp4_input.dev_attr.attr,
 593         &sensor_dev_attr_temp5_input.dev_attr.attr,
 594         &sensor_dev_attr_temp6_input.dev_attr.attr,
 595         &sensor_dev_attr_temp7_input.dev_attr.attr,
 596         &sensor_dev_attr_temp8_input.dev_attr.attr,
 597         &sensor_dev_attr_temp9_input.dev_attr.attr,
 598         &sensor_dev_attr_temp10_input.dev_attr.attr,
 599         &sensor_dev_attr_temp11_input.dev_attr.attr,
 600         &sensor_dev_attr_temp12_input.dev_attr.attr,
 601         &sensor_dev_attr_temp13_input.dev_attr.attr,
 602         &sensor_dev_attr_temp14_input.dev_attr.attr,
 603         &sensor_dev_attr_temp15_input.dev_attr.attr,
 604         &sensor_dev_attr_temp16_input.dev_attr.attr,
 605
 606         &sensor_dev_attr_temp1_fault.dev_attr.attr,
 607         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 608         &sensor_dev_attr_temp3_fault.dev_attr.attr,
 609         &sensor_dev_attr_temp4_fault.dev_attr.attr,
 610         &sensor_dev_attr_temp5_fault.dev_attr.attr,
 611         &sensor_dev_attr_temp6_fault.dev_attr.attr,
 612         &sensor_dev_attr_temp7_fault.dev_attr.attr,
 613         &sensor_dev_attr_temp8_fault.dev_attr.attr,
 614         &sensor_dev_attr_temp9_fault.dev_attr.attr,
 615         &sensor_dev_attr_temp10_fault.dev_attr.attr,
 616         &sensor_dev_attr_temp11_fault.dev_attr.attr,
 617         &sensor_dev_attr_temp12_fault.dev_attr.attr,
 618         &sensor_dev_attr_temp13_fault.dev_attr.attr,
 619         &sensor_dev_attr_temp14_fault.dev_attr.attr,
 620         &sensor_dev_attr_temp15_fault.dev_attr.attr,
 621         &sensor_dev_attr_temp16_fault.dev_attr.attr,
 622
 623         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 624         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
 625         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
 626         &sensor_dev_attr_temp4_alarm.dev_attr.attr,
 627         &sensor_dev_attr_temp5_alarm.dev_attr.attr,
 628         &sensor_dev_attr_temp6_alarm.dev_attr.attr,
 629         &sensor_dev_attr_temp7_alarm.dev_attr.attr,
 630         &sensor_dev_attr_temp8_alarm.dev_attr.attr,
 631         &sensor_dev_attr_temp9_alarm.dev_attr.attr,
 632         &sensor_dev_attr_temp10_alarm.dev_attr.attr,
 633         &sensor_dev_attr_temp11_alarm.dev_attr.attr,
 634         &sensor_dev_attr_temp12_alarm.dev_attr.attr,
 635         &sensor_dev_attr_temp13_alarm.dev_attr.attr,
 636         &sensor_dev_attr_temp14_alarm.dev_attr.attr,
 637         &sensor_dev_attr_temp15_alarm.dev_attr.attr,
 638         &sensor_dev_attr_temp16_alarm.dev_attr.attr,
 639         NULL
 640 };
 641
 642 /* Fans */
 643 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_value, NULL, 0);
 644 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_value, NULL, 1);
 645 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_value, NULL, 2);
 646 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_value, NULL, 3);
 647 static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan_value, NULL, 4);
 648 static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan_value, NULL, 5);
 649 static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan_value, NULL, 6);
 650 static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan_value, NULL, 7);
 651
 652 static SENSOR_DEVICE_ATTR(fan1_source, S_IRUGO, show_fan_source, NULL, 0);
 653 static SENSOR_DEVICE_ATTR(fan2_source, S_IRUGO, show_fan_source, NULL, 1);
 654 static SENSOR_DEVICE_ATTR(fan3_source, S_IRUGO, show_fan_source, NULL, 2);
 655 static SENSOR_DEVICE_ATTR(fan4_source, S_IRUGO, show_fan_source, NULL, 3);
 656 static SENSOR_DEVICE_ATTR(fan5_source, S_IRUGO, show_fan_source, NULL, 4);
 657 static SENSOR_DEVICE_ATTR(fan6_source, S_IRUGO, show_fan_source, NULL, 5);
 658 static SENSOR_DEVICE_ATTR(fan7_source, S_IRUGO, show_fan_source, NULL, 6);
 659 static SENSOR_DEVICE_ATTR(fan8_source, S_IRUGO, show_fan_source, NULL, 7);
 660
 661 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO | S_IWUSR,
 662                          show_fan_alarm, clear_fan_alarm, 0);
 663 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO | S_IWUSR,
 664                          show_fan_alarm, clear_fan_alarm, 1);
 665 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO | S_IWUSR,
 666                          show_fan_alarm, clear_fan_alarm, 2);
 667 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO | S_IWUSR,
 668                          show_fan_alarm, clear_fan_alarm, 3);
 669 static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO | S_IWUSR,
 670                          show_fan_alarm, clear_fan_alarm, 4);
 671 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO | S_IWUSR,
 672                          show_fan_alarm, clear_fan_alarm, 5);
 673 static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO | S_IWUSR,
 674                          show_fan_alarm, clear_fan_alarm, 6);
 675 static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO | S_IWUSR,
 676                          show_fan_alarm, clear_fan_alarm, 7);
 677
 678 static struct attribute *fts_fan_attrs[] = {
 679         &sensor_dev_attr_fan1_input.dev_attr.attr,
 680         &sensor_dev_attr_fan2_input.dev_attr.attr,
 681         &sensor_dev_attr_fan3_input.dev_attr.attr,
 682         &sensor_dev_attr_fan4_input.dev_attr.attr,
 683         &sensor_dev_attr_fan5_input.dev_attr.attr,
 684         &sensor_dev_attr_fan6_input.dev_attr.attr,
 685         &sensor_dev_attr_fan7_input.dev_attr.attr,
 686         &sensor_dev_attr_fan8_input.dev_attr.attr,
 687
 688         &sensor_dev_attr_fan1_source.dev_attr.attr,
 689         &sensor_dev_attr_fan2_source.dev_attr.attr,
 690         &sensor_dev_attr_fan3_source.dev_attr.attr,
 691         &sensor_dev_attr_fan4_source.dev_attr.attr,
 692         &sensor_dev_attr_fan5_source.dev_attr.attr,
 693         &sensor_dev_attr_fan6_source.dev_attr.attr,
 694         &sensor_dev_attr_fan7_source.dev_attr.attr,
 695         &sensor_dev_attr_fan8_source.dev_attr.attr,
 696
 697         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 698         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 699         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
 700         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
 701         &sensor_dev_attr_fan5_alarm.dev_attr.attr,
 702         &sensor_dev_attr_fan6_alarm.dev_attr.attr,
 703         &sensor_dev_attr_fan7_alarm.dev_attr.attr,
 704         &sensor_dev_attr_fan8_alarm.dev_attr.attr,
 705         NULL
 706 };
 707
 708 /* Voltages */
 709 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_value, NULL, 0);
 710 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_value, NULL, 1);
 711 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_value, NULL, 2);
 712 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_value, NULL, 3);
 713 static struct attribute *fts_voltage_attrs[] = {
 714         &sensor_dev_attr_in1_input.dev_attr.attr,
 715         &sensor_dev_attr_in2_input.dev_attr.attr,
 716         &sensor_dev_attr_in3_input.dev_attr.attr,
 717         &sensor_dev_attr_in4_input.dev_attr.attr,
 718         NULL
 719 };
 720
 721 static const struct attribute_group fts_voltage_attr_group = {
 722         .attrs = fts_voltage_attrs
 723 };
 724
 725 static const struct attribute_group fts_temp_attr_group = {
 726         .attrs = fts_temp_attrs
 727 };
 728
 729 static const struct attribute_group fts_fan_attr_group = {
 730         .attrs = fts_fan_attrs
 731 };
 732
 733 static const struct attribute_group *fts_attr_groups[] = {
 734         &fts_voltage_attr_group,
 735         &fts_temp_attr_group,
 736         &fts_fan_attr_group,
 737         NULL
 738 };
 739
 740 /*****************************************************************************/
 741 /* Module initialization / remove functions                                  */
 742 /*****************************************************************************/
 743 static int fts_detect(struct i2c_client *client,
 744                       struct i2c_board_info *info)
 745 {
 746         int val;
 747
 748         /* detection works with revsion greater or equal to 0x2b */
 749         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
 750         if (val < 0x2b)
 751                 return -ENODEV;
 752
 753         /* Device Detect Regs must have 0x17 0x34 and 0x54 */
 754         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_1);
 755         if (val != 0x17)
 756                 return -ENODEV;
 757
 758         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_2);
 759         if (val != 0x34)
 760                 return -ENODEV;
 761
 762         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_3);
 763         if (val != 0x54)
 764                 return -ENODEV;
 765
 766         /*
 767          * 0x10 == Baseboard Management Controller, 0x01 == Teutates
 768          * Device ID Reg needs to be 0x11
 769          */
 770         val = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
 771         if (val != 0x11)
 772                 return -ENODEV;
 773
 774         strlcpy(info->type, fts_id[0].name, I2C_NAME_SIZE);
 775         info->flags = 0;
 776         return 0;
 777 }
 778
 779 static int fts_remove(struct i2c_client *client)
 780 {
 781         struct fts_data *data = dev_get_drvdata(&client->dev);
 782
 783         watchdog_unregister_device(&data->wdd);
 784         return 0;
 785 }
 786
 787 static int fts_probe(struct i2c_client *client, const struct i2c_device_id *id)
 788 {
 789         u8 revision;
 790         struct fts_data *data;
 791         int err;
 792         s8 deviceid;
 793         struct device *hwmon_dev;
 794
 795         if (client->addr != 0x73)
 796                 return -ENODEV;
 797
 798         /* Baseboard Management Controller check */
 799         deviceid = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
 800         if (deviceid > 0 && (deviceid & 0xF0) == 0x10) {
 801                 switch (deviceid & 0x0F) {
 802                 case 0x01:
 803                         break;
 804                 default:
 805                         dev_dbg(&client->dev,
 806                                 "No Baseboard Management Controller\n");
 807                         return -ENODEV;
 808                 }
 809         } else {
 810                 dev_dbg(&client->dev, "No fujitsu board\n");
 811                 return -ENODEV;
 812         }
 813
 814         data = devm_kzalloc(&client->dev, sizeof(struct fts_data),
 815                             GFP_KERNEL);
 816         if (!data)
 817                 return -ENOMEM;
 818
 819         mutex_init(&data->update_lock);
 820         mutex_init(&data->access_lock);
 821         data->client = client;
 822         dev_set_drvdata(&client->dev, data);
 823
 824         err = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
 825         if (err < 0)
 826                 return err;
 827         revision = err;
 828
 829         hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
 830                                                            "ftsteutates",
 831                                                            data,
 832                                                            fts_attr_groups);
 833         if (IS_ERR(hwmon_dev))
 834                 return PTR_ERR(hwmon_dev);
 835
 836         err = fts_watchdog_init(data);
 837         if (err)
 838                 return err;
 839
 840         dev_info(&client->dev, "Detected FTS Teutates chip, revision: %d.%d\n",
 841                  (revision & 0xF0) >> 4, revision & 0x0F);
 842         return 0;
 843 }
 844
 845 /*****************************************************************************/
 846 /* Module Details                                                            */
 847 /*****************************************************************************/
 848 static struct i2c_driver fts_driver = {
 849         .class = I2C_CLASS_HWMON,
 850         .driver = {
 851                 .name = "ftsteutates",
 852         },
 853         .id_table = fts_id,
 854         .probe = fts_probe,
 855         .remove = fts_remove,
 856         .detect = fts_detect,
 857         .address_list = normal_i2c,
 858 };
 859
 860 module_i2c_driver(fts_driver);
 861
 862 MODULE_AUTHOR("Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>");
 863 MODULE_DESCRIPTION("FTS Teutates driver");
 864 MODULE_LICENSE("GPL");