drivers/hwmon/ftsteutates.c

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