drivers/hwmon/sch5627.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /***************************************************************************
0003  *   Copyright (C) 2010-2012 Hans de Goede <hdegoede@redhat.com>           *
0004  *                                                                         *
0005  ***************************************************************************/
0006
0007 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0008
0009 #include <linux/module.h>
0010 #include <linux/mod_devicetable.h>
0011 #include <linux/init.h>
0012 #include <linux/slab.h>
0013 #include <linux/jiffies.h>
0014 #include <linux/platform_device.h>
0015 #include <linux/hwmon.h>
0016 #include <linux/err.h>
0017 #include <linux/mutex.h>
0018 #include "sch56xx-common.h"
0019
0020 #define DRVNAME "sch5627"
0021 #define DEVNAME DRVNAME /* We only support one model */
0022
0023 #define SCH5627_HWMON_ID        0xa5
0024 #define SCH5627_COMPANY_ID      0x5c
0025 #define SCH5627_PRIMARY_ID      0xa0
0026
0027 #define SCH5627_REG_BUILD_CODE      0x39
0028 #define SCH5627_REG_BUILD_ID        0x3a
0029 #define SCH5627_REG_HWMON_ID        0x3c
0030 #define SCH5627_REG_HWMON_REV       0x3d
0031 #define SCH5627_REG_COMPANY_ID      0x3e
0032 #define SCH5627_REG_PRIMARY_ID      0x3f
0033 #define SCH5627_REG_CTRL        0x40
0034
0035 #define SCH5627_NO_TEMPS        8
0036 #define SCH5627_NO_FANS         4
0037 #define SCH5627_NO_IN           5
0038
0039 static const u16 SCH5627_REG_TEMP_MSB[SCH5627_NO_TEMPS] = {
0040     0x2B, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x180, 0x181 };
0041 static const u16 SCH5627_REG_TEMP_LSN[SCH5627_NO_TEMPS] = {
0042     0xE2, 0xE1, 0xE1, 0xE5, 0xE5, 0xE6, 0x182, 0x182 };
0043 static const u16 SCH5627_REG_TEMP_HIGH_NIBBLE[SCH5627_NO_TEMPS] = {
0044     0, 0, 1, 1, 0, 0, 0, 1 };
0045 static const u16 SCH5627_REG_TEMP_HIGH[SCH5627_NO_TEMPS] = {
0046     0x61, 0x57, 0x59, 0x5B, 0x5D, 0x5F, 0x184, 0x186 };
0047 static const u16 SCH5627_REG_TEMP_ABS[SCH5627_NO_TEMPS] = {
0048     0x9B, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x1A8, 0x1A9 };
0049
0050 static const u16 SCH5627_REG_FAN[SCH5627_NO_FANS] = {
0051     0x2C, 0x2E, 0x30, 0x32 };
0052 static const u16 SCH5627_REG_FAN_MIN[SCH5627_NO_FANS] = {
0053     0x62, 0x64, 0x66, 0x68 };
0054
0055 static const u16 SCH5627_REG_PWM_MAP[SCH5627_NO_FANS] = {
0056     0xA0, 0xA1, 0xA2, 0xA3 };
0057
0058 static const u16 SCH5627_REG_IN_MSB[SCH5627_NO_IN] = {
0059     0x22, 0x23, 0x24, 0x25, 0x189 };
0060 static const u16 SCH5627_REG_IN_LSN[SCH5627_NO_IN] = {
0061     0xE4, 0xE4, 0xE3, 0xE3, 0x18A };
0062 static const u16 SCH5627_REG_IN_HIGH_NIBBLE[SCH5627_NO_IN] = {
0063     1, 0, 1, 0, 1 };
0064 static const u16 SCH5627_REG_IN_FACTOR[SCH5627_NO_IN] = {
0065     10745, 3660, 9765, 10745, 3660 };
0066 static const char * const SCH5627_IN_LABELS[SCH5627_NO_IN] = {
0067     "VCC", "VTT", "VBAT", "VTR", "V_IN" };
0068
0069 struct sch5627_data {
0070     unsigned short addr;
0071     u8 control;
0072     u8 temp_max[SCH5627_NO_TEMPS];
0073     u8 temp_crit[SCH5627_NO_TEMPS];
0074     u16 fan_min[SCH5627_NO_FANS];
0075
0076     struct mutex update_lock;
0077     unsigned long last_battery; /* In jiffies */
0078     char temp_valid;        /* !=0 if following fields are valid */
0079     char fan_valid;
0080     char in_valid;
0081     unsigned long temp_last_updated;    /* In jiffies */
0082     unsigned long fan_last_updated;
0083     unsigned long in_last_updated;
0084     u16 temp[SCH5627_NO_TEMPS];
0085     u16 fan[SCH5627_NO_FANS];
0086     u16 in[SCH5627_NO_IN];
0087 };
0088
0089 static int sch5627_update_temp(struct sch5627_data *data)
0090 {
0091     int ret = 0;
0092     int i, val;
0093
0094     mutex_lock(&data->update_lock);
0095
0096     /* Cache the values for 1 second */
0097     if (time_after(jiffies, data->temp_last_updated + HZ) || !data->temp_valid) {
0098         for (i = 0; i < SCH5627_NO_TEMPS; i++) {
0099             val = sch56xx_read_virtual_reg12(data->addr, SCH5627_REG_TEMP_MSB[i],
0100                              SCH5627_REG_TEMP_LSN[i],
0101                              SCH5627_REG_TEMP_HIGH_NIBBLE[i]);
0102             if (unlikely(val < 0)) {
0103                 ret = val;
0104                 goto abort;
0105             }
0106             data->temp[i] = val;
0107         }
0108         data->temp_last_updated = jiffies;
0109         data->temp_valid = 1;
0110     }
0111 abort:
0112     mutex_unlock(&data->update_lock);
0113     return ret;
0114 }
0115
0116 static int sch5627_update_fan(struct sch5627_data *data)
0117 {
0118     int ret = 0;
0119     int i, val;
0120
0121     mutex_lock(&data->update_lock);
0122
0123     /* Cache the values for 1 second */
0124     if (time_after(jiffies, data->fan_last_updated + HZ) || !data->fan_valid) {
0125         for (i = 0; i < SCH5627_NO_FANS; i++) {
0126             val = sch56xx_read_virtual_reg16(data->addr, SCH5627_REG_FAN[i]);
0127             if (unlikely(val < 0)) {
0128                 ret = val;
0129                 goto abort;
0130             }
0131             data->fan[i] = val;
0132         }
0133         data->fan_last_updated = jiffies;
0134         data->fan_valid = 1;
0135     }
0136 abort:
0137     mutex_unlock(&data->update_lock);
0138     return ret;
0139 }
0140
0141 static int sch5627_update_in(struct sch5627_data *data)
0142 {
0143     int ret = 0;
0144     int i, val;
0145
0146     mutex_lock(&data->update_lock);
0147
0148     /* Trigger a Vbat voltage measurement every 5 minutes */
0149     if (time_after(jiffies, data->last_battery + 300 * HZ)) {
0150         sch56xx_write_virtual_reg(data->addr, SCH5627_REG_CTRL, data->control | 0x10);
0151         data->last_battery = jiffies;
0152     }
0153
0154     /* Cache the values for 1 second */
0155     if (time_after(jiffies, data->in_last_updated + HZ) || !data->in_valid) {
0156         for (i = 0; i < SCH5627_NO_IN; i++) {
0157             val = sch56xx_read_virtual_reg12(data->addr, SCH5627_REG_IN_MSB[i],
0158                              SCH5627_REG_IN_LSN[i],
0159                              SCH5627_REG_IN_HIGH_NIBBLE[i]);
0160             if (unlikely(val < 0)) {
0161                 ret = val;
0162                 goto abort;
0163             }
0164             data->in[i] = val;
0165         }
0166         data->in_last_updated = jiffies;
0167         data->in_valid = 1;
0168     }
0169 abort:
0170     mutex_unlock(&data->update_lock);
0171     return ret;
0172 }
0173
0174 static int sch5627_read_limits(struct sch5627_data *data)
0175 {
0176     int i, val;
0177
0178     for (i = 0; i < SCH5627_NO_TEMPS; i++) {
0179         /*
0180          * Note what SMSC calls ABS, is what lm_sensors calls max
0181          * (aka high), and HIGH is what lm_sensors calls crit.
0182          */
0183         val = sch56xx_read_virtual_reg(data->addr,
0184                            SCH5627_REG_TEMP_ABS[i]);
0185         if (val < 0)
0186             return val;
0187         data->temp_max[i] = val;
0188
0189         val = sch56xx_read_virtual_reg(data->addr,
0190                            SCH5627_REG_TEMP_HIGH[i]);
0191         if (val < 0)
0192             return val;
0193         data->temp_crit[i] = val;
0194     }
0195     for (i = 0; i < SCH5627_NO_FANS; i++) {
0196         val = sch56xx_read_virtual_reg16(data->addr,
0197                          SCH5627_REG_FAN_MIN[i]);
0198         if (val < 0)
0199             return val;
0200         data->fan_min[i] = val;
0201     }
0202
0203     return 0;
0204 }
0205
0206 static int reg_to_temp(u16 reg)
0207 {
0208     return (reg * 625) / 10 - 64000;
0209 }
0210
0211 static int reg_to_temp_limit(u8 reg)
0212 {
0213     return (reg - 64) * 1000;
0214 }
0215
0216 static int reg_to_rpm(u16 reg)
0217 {
0218     if (reg == 0)
0219         return -EIO;
0220     if (reg == 0xffff)
0221         return 0;
0222
0223     return 5400540 / reg;
0224 }
0225
0226 static umode_t sch5627_is_visible(const void *drvdata, enum hwmon_sensor_types type, u32 attr,
0227                   int channel)
0228 {
0229     if (type == hwmon_pwm && attr == hwmon_pwm_auto_channels_temp)
0230         return 0644;
0231
0232     return 0444;
0233 }
0234
0235 static int sch5627_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
0236             long *val)
0237 {
0238     struct sch5627_data *data = dev_get_drvdata(dev);
0239     int ret;
0240
0241     switch (type) {
0242     case hwmon_temp:
0243         ret = sch5627_update_temp(data);
0244         if (ret < 0)
0245             return ret;
0246         switch (attr) {
0247         case hwmon_temp_input:
0248             *val = reg_to_temp(data->temp[channel]);
0249             return 0;
0250         case hwmon_temp_max:
0251             *val = reg_to_temp_limit(data->temp_max[channel]);
0252             return 0;
0253         case hwmon_temp_crit:
0254             *val = reg_to_temp_limit(data->temp_crit[channel]);
0255             return 0;
0256         case hwmon_temp_fault:
0257             *val = (data->temp[channel] == 0);
0258             return 0;
0259         default:
0260             break;
0261         }
0262         break;
0263     case hwmon_fan:
0264         ret = sch5627_update_fan(data);
0265         if (ret < 0)
0266             return ret;
0267         switch (attr) {
0268         case hwmon_fan_input:
0269             ret = reg_to_rpm(data->fan[channel]);
0270             if (ret < 0)
0271                 return ret;
0272             *val = ret;
0273             return 0;
0274         case hwmon_fan_min:
0275             ret = reg_to_rpm(data->fan_min[channel]);
0276             if (ret < 0)
0277                 return ret;
0278             *val = ret;
0279             return 0;
0280         case hwmon_fan_fault:
0281             *val = (data->fan[channel] == 0xffff);
0282             return 0;
0283         default:
0284             break;
0285         }
0286         break;
0287     case hwmon_pwm:
0288         switch (attr) {
0289         case hwmon_pwm_auto_channels_temp:
0290             mutex_lock(&data->update_lock);
0291             ret = sch56xx_read_virtual_reg(data->addr, SCH5627_REG_PWM_MAP[channel]);
0292             mutex_unlock(&data->update_lock);
0293
0294             if (ret < 0)
0295                 return ret;
0296
0297             *val = ret;
0298
0299             return 0;
0300         default:
0301             break;
0302         }
0303         break;
0304     case hwmon_in:
0305         ret = sch5627_update_in(data);
0306         if (ret < 0)
0307             return ret;
0308         switch (attr) {
0309         case hwmon_in_input:
0310             *val = DIV_ROUND_CLOSEST(data->in[channel] * SCH5627_REG_IN_FACTOR[channel],
0311                          10000);
0312             return 0;
0313         default:
0314             break;
0315         }
0316         break;
0317     default:
0318         break;
0319     }
0320
0321     return -EOPNOTSUPP;
0322 }
0323
0324 static int sch5627_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
0325                    int channel, const char **str)
0326 {
0327     switch (type) {
0328     case hwmon_in:
0329         switch (attr) {
0330         case hwmon_in_label:
0331             *str = SCH5627_IN_LABELS[channel];
0332             return 0;
0333         default:
0334             break;
0335         }
0336         break;
0337     default:
0338         break;
0339     }
0340
0341     return -EOPNOTSUPP;
0342 }
0343
0344 static int sch5627_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
0345              long val)
0346 {
0347     struct sch5627_data *data = dev_get_drvdata(dev);
0348     int ret;
0349
0350     switch (type) {
0351     case hwmon_pwm:
0352         switch (attr) {
0353         case hwmon_pwm_auto_channels_temp:
0354             /* registers are 8 bit wide */
0355             if (val > U8_MAX || val < 0)
0356                 return -EINVAL;
0357
0358             mutex_lock(&data->update_lock);
0359             ret = sch56xx_write_virtual_reg(data->addr, SCH5627_REG_PWM_MAP[channel],
0360                             val);
0361             mutex_unlock(&data->update_lock);
0362
0363             return ret;
0364         default:
0365             break;
0366         }
0367         break;
0368     default:
0369         break;
0370     }
0371
0372     return -EOPNOTSUPP;
0373 }
0374
0375 static const struct hwmon_ops sch5627_ops = {
0376     .is_visible = sch5627_is_visible,
0377     .read = sch5627_read,
0378     .read_string = sch5627_read_string,
0379     .write = sch5627_write,
0380 };
0381
0382 static const struct hwmon_channel_info *sch5627_info[] = {
0383     HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ),
0384     HWMON_CHANNEL_INFO(temp,
0385                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT,
0386                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT,
0387                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT,
0388                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT,
0389                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT,
0390                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT,
0391                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT,
0392                HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_CRIT | HWMON_T_FAULT
0393                ),
0394     HWMON_CHANNEL_INFO(fan,
0395                HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_FAULT,
0396                HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_FAULT,
0397                HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_FAULT,
0398                HWMON_F_INPUT | HWMON_F_MIN | HWMON_F_FAULT
0399                ),
0400     HWMON_CHANNEL_INFO(pwm,
0401                HWMON_PWM_AUTO_CHANNELS_TEMP,
0402                HWMON_PWM_AUTO_CHANNELS_TEMP,
0403                HWMON_PWM_AUTO_CHANNELS_TEMP,
0404                HWMON_PWM_AUTO_CHANNELS_TEMP
0405                ),
0406     HWMON_CHANNEL_INFO(in,
0407                HWMON_I_INPUT | HWMON_I_LABEL,
0408                HWMON_I_INPUT | HWMON_I_LABEL,
0409                HWMON_I_INPUT | HWMON_I_LABEL,
0410                HWMON_I_INPUT | HWMON_I_LABEL,
0411                HWMON_I_INPUT
0412                ),
0413     NULL
0414 };
0415
0416 static const struct hwmon_chip_info sch5627_chip_info = {
0417     .ops = &sch5627_ops,
0418     .info = sch5627_info,
0419 };
0420
0421 static int sch5627_probe(struct platform_device *pdev)
0422 {
0423     struct sch5627_data *data;
0424     struct device *hwmon_dev;
0425     int err, build_code, build_id, hwmon_rev, val;
0426
0427     data = devm_kzalloc(&pdev->dev, sizeof(struct sch5627_data),
0428                 GFP_KERNEL);
0429     if (!data)
0430         return -ENOMEM;
0431
0432     data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
0433     mutex_init(&data->update_lock);
0434     platform_set_drvdata(pdev, data);
0435
0436     val = sch56xx_read_virtual_reg(data->addr, SCH5627_REG_HWMON_ID);
0437     if (val < 0)
0438         return val;
0439
0440     if (val != SCH5627_HWMON_ID) {
0441         pr_err("invalid %s id: 0x%02X (expected 0x%02X)\n", "hwmon",
0442                val, SCH5627_HWMON_ID);
0443         return -ENODEV;
0444     }
0445
0446     val = sch56xx_read_virtual_reg(data->addr, SCH5627_REG_COMPANY_ID);
0447     if (val < 0)
0448         return val;
0449
0450     if (val != SCH5627_COMPANY_ID) {
0451         pr_err("invalid %s id: 0x%02X (expected 0x%02X)\n", "company",
0452                val, SCH5627_COMPANY_ID);
0453         return -ENODEV;
0454     }
0455
0456     val = sch56xx_read_virtual_reg(data->addr, SCH5627_REG_PRIMARY_ID);
0457     if (val < 0)
0458         return val;
0459
0460     if (val != SCH5627_PRIMARY_ID) {
0461         pr_err("invalid %s id: 0x%02X (expected 0x%02X)\n", "primary",
0462                val, SCH5627_PRIMARY_ID);
0463         return -ENODEV;
0464     }
0465
0466     build_code = sch56xx_read_virtual_reg(data->addr,
0467                           SCH5627_REG_BUILD_CODE);
0468     if (build_code < 0)
0469         return build_code;
0470
0471     build_id = sch56xx_read_virtual_reg16(data->addr,
0472                           SCH5627_REG_BUILD_ID);
0473     if (build_id < 0)
0474         return build_id;
0475
0476     hwmon_rev = sch56xx_read_virtual_reg(data->addr,
0477                          SCH5627_REG_HWMON_REV);
0478     if (hwmon_rev < 0)
0479         return hwmon_rev;
0480
0481     val = sch56xx_read_virtual_reg(data->addr, SCH5627_REG_CTRL);
0482     if (val < 0)
0483         return val;
0484
0485     data->control = val;
0486     if (!(data->control & 0x01)) {
0487         pr_err("hardware monitoring not enabled\n");
0488         return -ENODEV;
0489     }
0490     /* Trigger a Vbat voltage measurement, so that we get a valid reading
0491        the first time we read Vbat */
0492     sch56xx_write_virtual_reg(data->addr, SCH5627_REG_CTRL,
0493                   data->control | 0x10);
0494     data->last_battery = jiffies;
0495
0496     /*
0497      * Read limits, we do this only once as reading a register on
0498      * the sch5627 is quite expensive (and they don't change).
0499      */
0500     err = sch5627_read_limits(data);
0501     if (err)
0502         return err;
0503
0504     pr_info("found %s chip at %#hx\n", DEVNAME, data->addr);
0505     pr_info("firmware build: code 0x%02X, id 0x%04X, hwmon: rev 0x%02X\n",
0506         build_code, build_id, hwmon_rev);
0507
0508     hwmon_dev = devm_hwmon_device_register_with_info(&pdev->dev, DEVNAME, data,
0509                              &sch5627_chip_info, NULL);
0510     if (IS_ERR(hwmon_dev))
0511         return PTR_ERR(hwmon_dev);
0512
0513     /* Note failing to register the watchdog is not a fatal error */
0514     sch56xx_watchdog_register(&pdev->dev, data->addr,
0515                   (build_code << 24) | (build_id << 8) | hwmon_rev,
0516                   &data->update_lock, 1);
0517
0518     return 0;
0519 }
0520
0521 static const struct platform_device_id sch5627_device_id[] = {
0522     {
0523         .name = "sch5627",
0524     },
0525     { }
0526 };
0527 MODULE_DEVICE_TABLE(platform, sch5627_device_id);
0528
0529 static struct platform_driver sch5627_driver = {
0530     .driver = {
0531         .name   = DRVNAME,
0532     },
0533     .probe      = sch5627_probe,
0534     .id_table   = sch5627_device_id,
0535 };
0536
0537 module_platform_driver(sch5627_driver);
0538
0539 MODULE_DESCRIPTION("SMSC SCH5627 Hardware Monitoring Driver");
0540 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
0541 MODULE_LICENSE("GPL");