Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Support for the FTS Systemmonitoring Chip "Teutates"
0004  *
0005  * Copyright (C) 2016 Fujitsu Technology Solutions GmbH,
0006  *        Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>
0007  */
0008 #include <linux/err.h>
0009 #include <linux/fs.h>
0010 #include <linux/hwmon.h>
0011 #include <linux/hwmon-sysfs.h>
0012 #include <linux/i2c.h>
0013 #include <linux/init.h>
0014 #include <linux/jiffies.h>
0015 #include <linux/module.h>
0016 #include <linux/mutex.h>
0017 #include <linux/slab.h>
0018 #include <linux/sysfs.h>
0019 #include <linux/uaccess.h>
0020 #include <linux/watchdog.h>
0021 
0022 #define FTS_DEVICE_ID_REG       0x0000
0023 #define FTS_DEVICE_REVISION_REG     0x0001
0024 #define FTS_DEVICE_STATUS_REG       0x0004
0025 #define FTS_SATELLITE_STATUS_REG    0x0005
0026 #define FTS_EVENT_STATUS_REG        0x0006
0027 #define FTS_GLOBAL_CONTROL_REG      0x0007
0028 
0029 #define FTS_DEVICE_DETECT_REG_1     0x0C
0030 #define FTS_DEVICE_DETECT_REG_2     0x0D
0031 #define FTS_DEVICE_DETECT_REG_3     0x0E
0032 
0033 #define FTS_SENSOR_EVENT_REG        0x0010
0034 
0035 #define FTS_FAN_EVENT_REG       0x0014
0036 #define FTS_FAN_PRESENT_REG     0x0015
0037 
0038 #define FTS_POWER_ON_TIME_COUNTER_A 0x007A
0039 #define FTS_POWER_ON_TIME_COUNTER_B 0x007B
0040 #define FTS_POWER_ON_TIME_COUNTER_C 0x007C
0041 
0042 #define FTS_PAGE_SELECT_REG     0x007F
0043 
0044 #define FTS_WATCHDOG_TIME_PRESET    0x000B
0045 #define FTS_WATCHDOG_CONTROL        0x5081
0046 
0047 #define FTS_NO_FAN_SENSORS      0x08
0048 #define FTS_NO_TEMP_SENSORS     0x10
0049 #define FTS_NO_VOLT_SENSORS     0x04
0050 
0051 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
0052 
0053 static const struct i2c_device_id fts_id[] = {
0054     { "ftsteutates", 0 },
0055     { }
0056 };
0057 MODULE_DEVICE_TABLE(i2c, fts_id);
0058 
0059 enum WATCHDOG_RESOLUTION {
0060     seconds = 1,
0061     minutes = 60
0062 };
0063 
0064 struct fts_data {
0065     struct i2c_client *client;
0066     /* update sensor data lock */
0067     struct mutex update_lock;
0068     /* read/write register lock */
0069     struct mutex access_lock;
0070     unsigned long last_updated; /* in jiffies */
0071     struct watchdog_device wdd;
0072     enum WATCHDOG_RESOLUTION resolution;
0073     bool valid; /* false until following fields are valid */
0074 
0075     u8 volt[FTS_NO_VOLT_SENSORS];
0076 
0077     u8 temp_input[FTS_NO_TEMP_SENSORS];
0078     u8 temp_alarm;
0079 
0080     u8 fan_present;
0081     u8 fan_input[FTS_NO_FAN_SENSORS]; /* in rps */
0082     u8 fan_source[FTS_NO_FAN_SENSORS];
0083     u8 fan_alarm;
0084 };
0085 
0086 #define FTS_REG_FAN_INPUT(idx) ((idx) + 0x20)
0087 #define FTS_REG_FAN_SOURCE(idx) ((idx) + 0x30)
0088 #define FTS_REG_FAN_CONTROL(idx) (((idx) << 16) + 0x4881)
0089 
0090 #define FTS_REG_TEMP_INPUT(idx) ((idx) + 0x40)
0091 #define FTS_REG_TEMP_CONTROL(idx) (((idx) << 16) + 0x0681)
0092 
0093 #define FTS_REG_VOLT(idx) ((idx) + 0x18)
0094 
0095 /*****************************************************************************/
0096 /* I2C Helper functions                              */
0097 /*****************************************************************************/
0098 static int fts_read_byte(struct i2c_client *client, unsigned short reg)
0099 {
0100     int ret;
0101     unsigned char page = reg >> 8;
0102     struct fts_data *data = dev_get_drvdata(&client->dev);
0103 
0104     mutex_lock(&data->access_lock);
0105 
0106     dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
0107     ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page);
0108     if (ret < 0)
0109         goto error;
0110 
0111     reg &= 0xFF;
0112     ret = i2c_smbus_read_byte_data(client, reg);
0113     dev_dbg(&client->dev, "read - reg: 0x%.02x: val: 0x%.02x\n", reg, ret);
0114 
0115 error:
0116     mutex_unlock(&data->access_lock);
0117     return ret;
0118 }
0119 
0120 static int fts_write_byte(struct i2c_client *client, unsigned short reg,
0121               unsigned char value)
0122 {
0123     int ret;
0124     unsigned char page = reg >> 8;
0125     struct fts_data *data = dev_get_drvdata(&client->dev);
0126 
0127     mutex_lock(&data->access_lock);
0128 
0129     dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
0130     ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page);
0131     if (ret < 0)
0132         goto error;
0133 
0134     reg &= 0xFF;
0135     dev_dbg(&client->dev,
0136         "write - reg: 0x%.02x: val: 0x%.02x\n", reg, value);
0137     ret = i2c_smbus_write_byte_data(client, reg, value);
0138 
0139 error:
0140     mutex_unlock(&data->access_lock);
0141     return ret;
0142 }
0143 
0144 /*****************************************************************************/
0145 /* Data Updater Helper function                          */
0146 /*****************************************************************************/
0147 static int fts_update_device(struct fts_data *data)
0148 {
0149     int i;
0150     int err = 0;
0151 
0152     mutex_lock(&data->update_lock);
0153     if (!time_after(jiffies, data->last_updated + 2 * HZ) && data->valid)
0154         goto exit;
0155 
0156     err = fts_read_byte(data->client, FTS_DEVICE_STATUS_REG);
0157     if (err < 0)
0158         goto exit;
0159 
0160     data->valid = !!(err & 0x02); /* Data not ready yet */
0161     if (unlikely(!data->valid)) {
0162         err = -EAGAIN;
0163         goto exit;
0164     }
0165 
0166     err = fts_read_byte(data->client, FTS_FAN_PRESENT_REG);
0167     if (err < 0)
0168         goto exit;
0169     data->fan_present = err;
0170 
0171     err = fts_read_byte(data->client, FTS_FAN_EVENT_REG);
0172     if (err < 0)
0173         goto exit;
0174     data->fan_alarm = err;
0175 
0176     for (i = 0; i < FTS_NO_FAN_SENSORS; i++) {
0177         if (data->fan_present & BIT(i)) {
0178             err = fts_read_byte(data->client, FTS_REG_FAN_INPUT(i));
0179             if (err < 0)
0180                 goto exit;
0181             data->fan_input[i] = err;
0182 
0183             err = fts_read_byte(data->client,
0184                         FTS_REG_FAN_SOURCE(i));
0185             if (err < 0)
0186                 goto exit;
0187             data->fan_source[i] = err;
0188         } else {
0189             data->fan_input[i] = 0;
0190             data->fan_source[i] = 0;
0191         }
0192     }
0193 
0194     err = fts_read_byte(data->client, FTS_SENSOR_EVENT_REG);
0195     if (err < 0)
0196         goto exit;
0197     data->temp_alarm = err;
0198 
0199     for (i = 0; i < FTS_NO_TEMP_SENSORS; i++) {
0200         err = fts_read_byte(data->client, FTS_REG_TEMP_INPUT(i));
0201         if (err < 0)
0202             goto exit;
0203         data->temp_input[i] = err;
0204     }
0205 
0206     for (i = 0; i < FTS_NO_VOLT_SENSORS; i++) {
0207         err = fts_read_byte(data->client, FTS_REG_VOLT(i));
0208         if (err < 0)
0209             goto exit;
0210         data->volt[i] = err;
0211     }
0212     data->last_updated = jiffies;
0213     err = 0;
0214 exit:
0215     mutex_unlock(&data->update_lock);
0216     return err;
0217 }
0218 
0219 /*****************************************************************************/
0220 /* Watchdog functions                                */
0221 /*****************************************************************************/
0222 static int fts_wd_set_resolution(struct fts_data *data,
0223                  enum WATCHDOG_RESOLUTION resolution)
0224 {
0225     int ret;
0226 
0227     if (data->resolution == resolution)
0228         return 0;
0229 
0230     ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL);
0231     if (ret < 0)
0232         return ret;
0233 
0234     if ((resolution == seconds && ret & BIT(1)) ||
0235         (resolution == minutes && (ret & BIT(1)) == 0)) {
0236         data->resolution = resolution;
0237         return 0;
0238     }
0239 
0240     if (resolution == seconds)
0241         ret |= BIT(1);
0242     else
0243         ret &= ~BIT(1);
0244 
0245     ret = fts_write_byte(data->client, FTS_WATCHDOG_CONTROL, ret);
0246     if (ret < 0)
0247         return ret;
0248 
0249     data->resolution = resolution;
0250     return ret;
0251 }
0252 
0253 static int fts_wd_set_timeout(struct watchdog_device *wdd, unsigned int timeout)
0254 {
0255     struct fts_data *data;
0256     enum WATCHDOG_RESOLUTION resolution = seconds;
0257     int ret;
0258 
0259     data = watchdog_get_drvdata(wdd);
0260     /* switch watchdog resolution to minutes if timeout does not fit
0261      * into a byte
0262      */
0263     if (timeout > 0xFF) {
0264         timeout = DIV_ROUND_UP(timeout, 60) * 60;
0265         resolution = minutes;
0266     }
0267 
0268     ret = fts_wd_set_resolution(data, resolution);
0269     if (ret < 0)
0270         return ret;
0271 
0272     wdd->timeout = timeout;
0273     return 0;
0274 }
0275 
0276 static int fts_wd_start(struct watchdog_device *wdd)
0277 {
0278     struct fts_data *data = watchdog_get_drvdata(wdd);
0279 
0280     return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET,
0281                   wdd->timeout / (u8)data->resolution);
0282 }
0283 
0284 static int fts_wd_stop(struct watchdog_device *wdd)
0285 {
0286     struct fts_data *data;
0287 
0288     data = watchdog_get_drvdata(wdd);
0289     return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET, 0);
0290 }
0291 
0292 static const struct watchdog_info fts_wd_info = {
0293     .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
0294     .identity = "FTS Teutates Hardware Watchdog",
0295 };
0296 
0297 static const struct watchdog_ops fts_wd_ops = {
0298     .owner = THIS_MODULE,
0299     .start = fts_wd_start,
0300     .stop = fts_wd_stop,
0301     .set_timeout = fts_wd_set_timeout,
0302 };
0303 
0304 static int fts_watchdog_init(struct fts_data *data)
0305 {
0306     int timeout, ret;
0307 
0308     watchdog_set_drvdata(&data->wdd, data);
0309 
0310     timeout = fts_read_byte(data->client, FTS_WATCHDOG_TIME_PRESET);
0311     if (timeout < 0)
0312         return timeout;
0313 
0314     /* watchdog not running, set timeout to a default of 60 sec. */
0315     if (timeout == 0) {
0316         ret = fts_wd_set_resolution(data, seconds);
0317         if (ret < 0)
0318             return ret;
0319         data->wdd.timeout = 60;
0320     } else {
0321         ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL);
0322         if (ret < 0)
0323             return ret;
0324 
0325         data->resolution = ret & BIT(1) ? seconds : minutes;
0326         data->wdd.timeout = timeout * (u8)data->resolution;
0327         set_bit(WDOG_HW_RUNNING, &data->wdd.status);
0328     }
0329 
0330     /* Register our watchdog part */
0331     data->wdd.info = &fts_wd_info;
0332     data->wdd.ops = &fts_wd_ops;
0333     data->wdd.parent = &data->client->dev;
0334     data->wdd.min_timeout = 1;
0335 
0336     /* max timeout 255 minutes. */
0337     data->wdd.max_hw_heartbeat_ms = 0xFF * 60 * MSEC_PER_SEC;
0338 
0339     return watchdog_register_device(&data->wdd);
0340 }
0341 
0342 /*****************************************************************************/
0343 /* SysFS handler functions                           */
0344 /*****************************************************************************/
0345 static ssize_t in_value_show(struct device *dev,
0346                  struct device_attribute *devattr, char *buf)
0347 {
0348     struct fts_data *data = dev_get_drvdata(dev);
0349     int index = to_sensor_dev_attr(devattr)->index;
0350     int err;
0351 
0352     err = fts_update_device(data);
0353     if (err < 0)
0354         return err;
0355 
0356     return sprintf(buf, "%u\n", data->volt[index]);
0357 }
0358 
0359 static ssize_t temp_value_show(struct device *dev,
0360                    struct device_attribute *devattr, char *buf)
0361 {
0362     struct fts_data *data = dev_get_drvdata(dev);
0363     int index = to_sensor_dev_attr(devattr)->index;
0364     int err;
0365 
0366     err = fts_update_device(data);
0367     if (err < 0)
0368         return err;
0369 
0370     return sprintf(buf, "%u\n", data->temp_input[index]);
0371 }
0372 
0373 static ssize_t temp_fault_show(struct device *dev,
0374                    struct device_attribute *devattr, char *buf)
0375 {
0376     struct fts_data *data = dev_get_drvdata(dev);
0377     int index = to_sensor_dev_attr(devattr)->index;
0378     int err;
0379 
0380     err = fts_update_device(data);
0381     if (err < 0)
0382         return err;
0383 
0384     /* 00h Temperature = Sensor Error */
0385     return sprintf(buf, "%d\n", data->temp_input[index] == 0);
0386 }
0387 
0388 static ssize_t temp_alarm_show(struct device *dev,
0389                    struct device_attribute *devattr, char *buf)
0390 {
0391     struct fts_data *data = dev_get_drvdata(dev);
0392     int index = to_sensor_dev_attr(devattr)->index;
0393     int err;
0394 
0395     err = fts_update_device(data);
0396     if (err < 0)
0397         return err;
0398 
0399     return sprintf(buf, "%u\n", !!(data->temp_alarm & BIT(index)));
0400 }
0401 
0402 static ssize_t
0403 temp_alarm_store(struct device *dev, struct device_attribute *devattr,
0404          const char *buf, size_t count)
0405 {
0406     struct fts_data *data = dev_get_drvdata(dev);
0407     int index = to_sensor_dev_attr(devattr)->index;
0408     long ret;
0409 
0410     ret = fts_update_device(data);
0411     if (ret < 0)
0412         return ret;
0413 
0414     if (kstrtoul(buf, 10, &ret) || ret != 0)
0415         return -EINVAL;
0416 
0417     mutex_lock(&data->update_lock);
0418     ret = fts_read_byte(data->client, FTS_REG_TEMP_CONTROL(index));
0419     if (ret < 0)
0420         goto error;
0421 
0422     ret = fts_write_byte(data->client, FTS_REG_TEMP_CONTROL(index),
0423                  ret | 0x1);
0424     if (ret < 0)
0425         goto error;
0426 
0427     data->valid = false;
0428     ret = count;
0429 error:
0430     mutex_unlock(&data->update_lock);
0431     return ret;
0432 }
0433 
0434 static ssize_t fan_value_show(struct device *dev,
0435                   struct device_attribute *devattr, char *buf)
0436 {
0437     struct fts_data *data = dev_get_drvdata(dev);
0438     int index = to_sensor_dev_attr(devattr)->index;
0439     int err;
0440 
0441     err = fts_update_device(data);
0442     if (err < 0)
0443         return err;
0444 
0445     return sprintf(buf, "%u\n", data->fan_input[index]);
0446 }
0447 
0448 static ssize_t fan_source_show(struct device *dev,
0449                    struct device_attribute *devattr, char *buf)
0450 {
0451     struct fts_data *data = dev_get_drvdata(dev);
0452     int index = to_sensor_dev_attr(devattr)->index;
0453     int err;
0454 
0455     err = fts_update_device(data);
0456     if (err < 0)
0457         return err;
0458 
0459     return sprintf(buf, "%u\n", data->fan_source[index]);
0460 }
0461 
0462 static ssize_t fan_alarm_show(struct device *dev,
0463                   struct device_attribute *devattr, char *buf)
0464 {
0465     struct fts_data *data = dev_get_drvdata(dev);
0466     int index = to_sensor_dev_attr(devattr)->index;
0467     int err;
0468 
0469     err = fts_update_device(data);
0470     if (err < 0)
0471         return err;
0472 
0473     return sprintf(buf, "%d\n", !!(data->fan_alarm & BIT(index)));
0474 }
0475 
0476 static ssize_t
0477 fan_alarm_store(struct device *dev, struct device_attribute *devattr,
0478         const char *buf, size_t count)
0479 {
0480     struct fts_data *data = dev_get_drvdata(dev);
0481     int index = to_sensor_dev_attr(devattr)->index;
0482     long ret;
0483 
0484     ret = fts_update_device(data);
0485     if (ret < 0)
0486         return ret;
0487 
0488     if (kstrtoul(buf, 10, &ret) || ret != 0)
0489         return -EINVAL;
0490 
0491     mutex_lock(&data->update_lock);
0492     ret = fts_read_byte(data->client, FTS_REG_FAN_CONTROL(index));
0493     if (ret < 0)
0494         goto error;
0495 
0496     ret = fts_write_byte(data->client, FTS_REG_FAN_CONTROL(index),
0497                  ret | 0x1);
0498     if (ret < 0)
0499         goto error;
0500 
0501     data->valid = false;
0502     ret = count;
0503 error:
0504     mutex_unlock(&data->update_lock);
0505     return ret;
0506 }
0507 
0508 /*****************************************************************************/
0509 /* SysFS structs                                 */
0510 /*****************************************************************************/
0511 
0512 /* Temperature sensors */
0513 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_value, 0);
0514 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_value, 1);
0515 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp_value, 2);
0516 static SENSOR_DEVICE_ATTR_RO(temp4_input, temp_value, 3);
0517 static SENSOR_DEVICE_ATTR_RO(temp5_input, temp_value, 4);
0518 static SENSOR_DEVICE_ATTR_RO(temp6_input, temp_value, 5);
0519 static SENSOR_DEVICE_ATTR_RO(temp7_input, temp_value, 6);
0520 static SENSOR_DEVICE_ATTR_RO(temp8_input, temp_value, 7);
0521 static SENSOR_DEVICE_ATTR_RO(temp9_input, temp_value, 8);
0522 static SENSOR_DEVICE_ATTR_RO(temp10_input, temp_value, 9);
0523 static SENSOR_DEVICE_ATTR_RO(temp11_input, temp_value, 10);
0524 static SENSOR_DEVICE_ATTR_RO(temp12_input, temp_value, 11);
0525 static SENSOR_DEVICE_ATTR_RO(temp13_input, temp_value, 12);
0526 static SENSOR_DEVICE_ATTR_RO(temp14_input, temp_value, 13);
0527 static SENSOR_DEVICE_ATTR_RO(temp15_input, temp_value, 14);
0528 static SENSOR_DEVICE_ATTR_RO(temp16_input, temp_value, 15);
0529 
0530 static SENSOR_DEVICE_ATTR_RO(temp1_fault, temp_fault, 0);
0531 static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp_fault, 1);
0532 static SENSOR_DEVICE_ATTR_RO(temp3_fault, temp_fault, 2);
0533 static SENSOR_DEVICE_ATTR_RO(temp4_fault, temp_fault, 3);
0534 static SENSOR_DEVICE_ATTR_RO(temp5_fault, temp_fault, 4);
0535 static SENSOR_DEVICE_ATTR_RO(temp6_fault, temp_fault, 5);
0536 static SENSOR_DEVICE_ATTR_RO(temp7_fault, temp_fault, 6);
0537 static SENSOR_DEVICE_ATTR_RO(temp8_fault, temp_fault, 7);
0538 static SENSOR_DEVICE_ATTR_RO(temp9_fault, temp_fault, 8);
0539 static SENSOR_DEVICE_ATTR_RO(temp10_fault, temp_fault, 9);
0540 static SENSOR_DEVICE_ATTR_RO(temp11_fault, temp_fault, 10);
0541 static SENSOR_DEVICE_ATTR_RO(temp12_fault, temp_fault, 11);
0542 static SENSOR_DEVICE_ATTR_RO(temp13_fault, temp_fault, 12);
0543 static SENSOR_DEVICE_ATTR_RO(temp14_fault, temp_fault, 13);
0544 static SENSOR_DEVICE_ATTR_RO(temp15_fault, temp_fault, 14);
0545 static SENSOR_DEVICE_ATTR_RO(temp16_fault, temp_fault, 15);
0546 
0547 static SENSOR_DEVICE_ATTR_RW(temp1_alarm, temp_alarm, 0);
0548 static SENSOR_DEVICE_ATTR_RW(temp2_alarm, temp_alarm, 1);
0549 static SENSOR_DEVICE_ATTR_RW(temp3_alarm, temp_alarm, 2);
0550 static SENSOR_DEVICE_ATTR_RW(temp4_alarm, temp_alarm, 3);
0551 static SENSOR_DEVICE_ATTR_RW(temp5_alarm, temp_alarm, 4);
0552 static SENSOR_DEVICE_ATTR_RW(temp6_alarm, temp_alarm, 5);
0553 static SENSOR_DEVICE_ATTR_RW(temp7_alarm, temp_alarm, 6);
0554 static SENSOR_DEVICE_ATTR_RW(temp8_alarm, temp_alarm, 7);
0555 static SENSOR_DEVICE_ATTR_RW(temp9_alarm, temp_alarm, 8);
0556 static SENSOR_DEVICE_ATTR_RW(temp10_alarm, temp_alarm, 9);
0557 static SENSOR_DEVICE_ATTR_RW(temp11_alarm, temp_alarm, 10);
0558 static SENSOR_DEVICE_ATTR_RW(temp12_alarm, temp_alarm, 11);
0559 static SENSOR_DEVICE_ATTR_RW(temp13_alarm, temp_alarm, 12);
0560 static SENSOR_DEVICE_ATTR_RW(temp14_alarm, temp_alarm, 13);
0561 static SENSOR_DEVICE_ATTR_RW(temp15_alarm, temp_alarm, 14);
0562 static SENSOR_DEVICE_ATTR_RW(temp16_alarm, temp_alarm, 15);
0563 
0564 static struct attribute *fts_temp_attrs[] = {
0565     &sensor_dev_attr_temp1_input.dev_attr.attr,
0566     &sensor_dev_attr_temp2_input.dev_attr.attr,
0567     &sensor_dev_attr_temp3_input.dev_attr.attr,
0568     &sensor_dev_attr_temp4_input.dev_attr.attr,
0569     &sensor_dev_attr_temp5_input.dev_attr.attr,
0570     &sensor_dev_attr_temp6_input.dev_attr.attr,
0571     &sensor_dev_attr_temp7_input.dev_attr.attr,
0572     &sensor_dev_attr_temp8_input.dev_attr.attr,
0573     &sensor_dev_attr_temp9_input.dev_attr.attr,
0574     &sensor_dev_attr_temp10_input.dev_attr.attr,
0575     &sensor_dev_attr_temp11_input.dev_attr.attr,
0576     &sensor_dev_attr_temp12_input.dev_attr.attr,
0577     &sensor_dev_attr_temp13_input.dev_attr.attr,
0578     &sensor_dev_attr_temp14_input.dev_attr.attr,
0579     &sensor_dev_attr_temp15_input.dev_attr.attr,
0580     &sensor_dev_attr_temp16_input.dev_attr.attr,
0581 
0582     &sensor_dev_attr_temp1_fault.dev_attr.attr,
0583     &sensor_dev_attr_temp2_fault.dev_attr.attr,
0584     &sensor_dev_attr_temp3_fault.dev_attr.attr,
0585     &sensor_dev_attr_temp4_fault.dev_attr.attr,
0586     &sensor_dev_attr_temp5_fault.dev_attr.attr,
0587     &sensor_dev_attr_temp6_fault.dev_attr.attr,
0588     &sensor_dev_attr_temp7_fault.dev_attr.attr,
0589     &sensor_dev_attr_temp8_fault.dev_attr.attr,
0590     &sensor_dev_attr_temp9_fault.dev_attr.attr,
0591     &sensor_dev_attr_temp10_fault.dev_attr.attr,
0592     &sensor_dev_attr_temp11_fault.dev_attr.attr,
0593     &sensor_dev_attr_temp12_fault.dev_attr.attr,
0594     &sensor_dev_attr_temp13_fault.dev_attr.attr,
0595     &sensor_dev_attr_temp14_fault.dev_attr.attr,
0596     &sensor_dev_attr_temp15_fault.dev_attr.attr,
0597     &sensor_dev_attr_temp16_fault.dev_attr.attr,
0598 
0599     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
0600     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
0601     &sensor_dev_attr_temp3_alarm.dev_attr.attr,
0602     &sensor_dev_attr_temp4_alarm.dev_attr.attr,
0603     &sensor_dev_attr_temp5_alarm.dev_attr.attr,
0604     &sensor_dev_attr_temp6_alarm.dev_attr.attr,
0605     &sensor_dev_attr_temp7_alarm.dev_attr.attr,
0606     &sensor_dev_attr_temp8_alarm.dev_attr.attr,
0607     &sensor_dev_attr_temp9_alarm.dev_attr.attr,
0608     &sensor_dev_attr_temp10_alarm.dev_attr.attr,
0609     &sensor_dev_attr_temp11_alarm.dev_attr.attr,
0610     &sensor_dev_attr_temp12_alarm.dev_attr.attr,
0611     &sensor_dev_attr_temp13_alarm.dev_attr.attr,
0612     &sensor_dev_attr_temp14_alarm.dev_attr.attr,
0613     &sensor_dev_attr_temp15_alarm.dev_attr.attr,
0614     &sensor_dev_attr_temp16_alarm.dev_attr.attr,
0615     NULL
0616 };
0617 
0618 /* Fans */
0619 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_value, 0);
0620 static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_value, 1);
0621 static SENSOR_DEVICE_ATTR_RO(fan3_input, fan_value, 2);
0622 static SENSOR_DEVICE_ATTR_RO(fan4_input, fan_value, 3);
0623 static SENSOR_DEVICE_ATTR_RO(fan5_input, fan_value, 4);
0624 static SENSOR_DEVICE_ATTR_RO(fan6_input, fan_value, 5);
0625 static SENSOR_DEVICE_ATTR_RO(fan7_input, fan_value, 6);
0626 static SENSOR_DEVICE_ATTR_RO(fan8_input, fan_value, 7);
0627 
0628 static SENSOR_DEVICE_ATTR_RO(fan1_source, fan_source, 0);
0629 static SENSOR_DEVICE_ATTR_RO(fan2_source, fan_source, 1);
0630 static SENSOR_DEVICE_ATTR_RO(fan3_source, fan_source, 2);
0631 static SENSOR_DEVICE_ATTR_RO(fan4_source, fan_source, 3);
0632 static SENSOR_DEVICE_ATTR_RO(fan5_source, fan_source, 4);
0633 static SENSOR_DEVICE_ATTR_RO(fan6_source, fan_source, 5);
0634 static SENSOR_DEVICE_ATTR_RO(fan7_source, fan_source, 6);
0635 static SENSOR_DEVICE_ATTR_RO(fan8_source, fan_source, 7);
0636 
0637 static SENSOR_DEVICE_ATTR_RW(fan1_alarm, fan_alarm, 0);
0638 static SENSOR_DEVICE_ATTR_RW(fan2_alarm, fan_alarm, 1);
0639 static SENSOR_DEVICE_ATTR_RW(fan3_alarm, fan_alarm, 2);
0640 static SENSOR_DEVICE_ATTR_RW(fan4_alarm, fan_alarm, 3);
0641 static SENSOR_DEVICE_ATTR_RW(fan5_alarm, fan_alarm, 4);
0642 static SENSOR_DEVICE_ATTR_RW(fan6_alarm, fan_alarm, 5);
0643 static SENSOR_DEVICE_ATTR_RW(fan7_alarm, fan_alarm, 6);
0644 static SENSOR_DEVICE_ATTR_RW(fan8_alarm, fan_alarm, 7);
0645 
0646 static struct attribute *fts_fan_attrs[] = {
0647     &sensor_dev_attr_fan1_input.dev_attr.attr,
0648     &sensor_dev_attr_fan2_input.dev_attr.attr,
0649     &sensor_dev_attr_fan3_input.dev_attr.attr,
0650     &sensor_dev_attr_fan4_input.dev_attr.attr,
0651     &sensor_dev_attr_fan5_input.dev_attr.attr,
0652     &sensor_dev_attr_fan6_input.dev_attr.attr,
0653     &sensor_dev_attr_fan7_input.dev_attr.attr,
0654     &sensor_dev_attr_fan8_input.dev_attr.attr,
0655 
0656     &sensor_dev_attr_fan1_source.dev_attr.attr,
0657     &sensor_dev_attr_fan2_source.dev_attr.attr,
0658     &sensor_dev_attr_fan3_source.dev_attr.attr,
0659     &sensor_dev_attr_fan4_source.dev_attr.attr,
0660     &sensor_dev_attr_fan5_source.dev_attr.attr,
0661     &sensor_dev_attr_fan6_source.dev_attr.attr,
0662     &sensor_dev_attr_fan7_source.dev_attr.attr,
0663     &sensor_dev_attr_fan8_source.dev_attr.attr,
0664 
0665     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
0666     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
0667     &sensor_dev_attr_fan3_alarm.dev_attr.attr,
0668     &sensor_dev_attr_fan4_alarm.dev_attr.attr,
0669     &sensor_dev_attr_fan5_alarm.dev_attr.attr,
0670     &sensor_dev_attr_fan6_alarm.dev_attr.attr,
0671     &sensor_dev_attr_fan7_alarm.dev_attr.attr,
0672     &sensor_dev_attr_fan8_alarm.dev_attr.attr,
0673     NULL
0674 };
0675 
0676 /* Voltages */
0677 static SENSOR_DEVICE_ATTR_RO(in1_input, in_value, 0);
0678 static SENSOR_DEVICE_ATTR_RO(in2_input, in_value, 1);
0679 static SENSOR_DEVICE_ATTR_RO(in3_input, in_value, 2);
0680 static SENSOR_DEVICE_ATTR_RO(in4_input, in_value, 3);
0681 static struct attribute *fts_voltage_attrs[] = {
0682     &sensor_dev_attr_in1_input.dev_attr.attr,
0683     &sensor_dev_attr_in2_input.dev_attr.attr,
0684     &sensor_dev_attr_in3_input.dev_attr.attr,
0685     &sensor_dev_attr_in4_input.dev_attr.attr,
0686     NULL
0687 };
0688 
0689 static const struct attribute_group fts_voltage_attr_group = {
0690     .attrs = fts_voltage_attrs
0691 };
0692 
0693 static const struct attribute_group fts_temp_attr_group = {
0694     .attrs = fts_temp_attrs
0695 };
0696 
0697 static const struct attribute_group fts_fan_attr_group = {
0698     .attrs = fts_fan_attrs
0699 };
0700 
0701 static const struct attribute_group *fts_attr_groups[] = {
0702     &fts_voltage_attr_group,
0703     &fts_temp_attr_group,
0704     &fts_fan_attr_group,
0705     NULL
0706 };
0707 
0708 /*****************************************************************************/
0709 /* Module initialization / remove functions                  */
0710 /*****************************************************************************/
0711 static int fts_detect(struct i2c_client *client,
0712               struct i2c_board_info *info)
0713 {
0714     int val;
0715 
0716     /* detection works with revision greater or equal to 0x2b */
0717     val = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
0718     if (val < 0x2b)
0719         return -ENODEV;
0720 
0721     /* Device Detect Regs must have 0x17 0x34 and 0x54 */
0722     val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_1);
0723     if (val != 0x17)
0724         return -ENODEV;
0725 
0726     val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_2);
0727     if (val != 0x34)
0728         return -ENODEV;
0729 
0730     val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_3);
0731     if (val != 0x54)
0732         return -ENODEV;
0733 
0734     /*
0735      * 0x10 == Baseboard Management Controller, 0x01 == Teutates
0736      * Device ID Reg needs to be 0x11
0737      */
0738     val = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
0739     if (val != 0x11)
0740         return -ENODEV;
0741 
0742     strlcpy(info->type, fts_id[0].name, I2C_NAME_SIZE);
0743     info->flags = 0;
0744     return 0;
0745 }
0746 
0747 static int fts_remove(struct i2c_client *client)
0748 {
0749     struct fts_data *data = dev_get_drvdata(&client->dev);
0750 
0751     watchdog_unregister_device(&data->wdd);
0752     return 0;
0753 }
0754 
0755 static int fts_probe(struct i2c_client *client)
0756 {
0757     u8 revision;
0758     struct fts_data *data;
0759     int err;
0760     s8 deviceid;
0761     struct device *hwmon_dev;
0762 
0763     if (client->addr != 0x73)
0764         return -ENODEV;
0765 
0766     /* Baseboard Management Controller check */
0767     deviceid = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
0768     if (deviceid > 0 && (deviceid & 0xF0) == 0x10) {
0769         switch (deviceid & 0x0F) {
0770         case 0x01:
0771             break;
0772         default:
0773             dev_dbg(&client->dev,
0774                 "No Baseboard Management Controller\n");
0775             return -ENODEV;
0776         }
0777     } else {
0778         dev_dbg(&client->dev, "No fujitsu board\n");
0779         return -ENODEV;
0780     }
0781 
0782     data = devm_kzalloc(&client->dev, sizeof(struct fts_data),
0783                 GFP_KERNEL);
0784     if (!data)
0785         return -ENOMEM;
0786 
0787     mutex_init(&data->update_lock);
0788     mutex_init(&data->access_lock);
0789     data->client = client;
0790     dev_set_drvdata(&client->dev, data);
0791 
0792     err = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
0793     if (err < 0)
0794         return err;
0795     revision = err;
0796 
0797     hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
0798                                "ftsteutates",
0799                                data,
0800                                fts_attr_groups);
0801     if (IS_ERR(hwmon_dev))
0802         return PTR_ERR(hwmon_dev);
0803 
0804     err = fts_watchdog_init(data);
0805     if (err)
0806         return err;
0807 
0808     dev_info(&client->dev, "Detected FTS Teutates chip, revision: %d.%d\n",
0809          (revision & 0xF0) >> 4, revision & 0x0F);
0810     return 0;
0811 }
0812 
0813 /*****************************************************************************/
0814 /* Module Details                                */
0815 /*****************************************************************************/
0816 static struct i2c_driver fts_driver = {
0817     .class = I2C_CLASS_HWMON,
0818     .driver = {
0819         .name = "ftsteutates",
0820     },
0821     .id_table = fts_id,
0822     .probe_new = fts_probe,
0823     .remove = fts_remove,
0824     .detect = fts_detect,
0825     .address_list = normal_i2c,
0826 };
0827 
0828 module_i2c_driver(fts_driver);
0829 
0830 MODULE_AUTHOR("Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>");
0831 MODULE_DESCRIPTION("FTS Teutates driver");
0832 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!