Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * f75375s.c - driver for the Fintek F75375/SP, F75373 and
0004  *             F75387SG/RG hardware monitoring features
0005  * Copyright (C) 2006-2007  Riku Voipio
0006  *
0007  * Datasheets available at:
0008  *
0009  * f75375:
0010  * http://www.fintek.com.tw/files/productfiles/F75375_V026P.pdf
0011  *
0012  * f75373:
0013  * http://www.fintek.com.tw/files/productfiles/F75373_V025P.pdf
0014  *
0015  * f75387:
0016  * http://www.fintek.com.tw/files/productfiles/F75387_V027P.pdf
0017  */
0018 
0019 #include <linux/module.h>
0020 #include <linux/jiffies.h>
0021 #include <linux/hwmon.h>
0022 #include <linux/hwmon-sysfs.h>
0023 #include <linux/i2c.h>
0024 #include <linux/err.h>
0025 #include <linux/mutex.h>
0026 #include <linux/f75375s.h>
0027 #include <linux/slab.h>
0028 
0029 /* Addresses to scan */
0030 static const unsigned short normal_i2c[] = { 0x2d, 0x2e, I2C_CLIENT_END };
0031 
0032 enum chips { f75373, f75375, f75387 };
0033 
0034 /* Fintek F75375 registers  */
0035 #define F75375_REG_CONFIG0      0x0
0036 #define F75375_REG_CONFIG1      0x1
0037 #define F75375_REG_CONFIG2      0x2
0038 #define F75375_REG_CONFIG3      0x3
0039 #define F75375_REG_ADDR         0x4
0040 #define F75375_REG_INTR         0x31
0041 #define F75375_CHIP_ID          0x5A
0042 #define F75375_REG_VERSION      0x5C
0043 #define F75375_REG_VENDOR       0x5D
0044 #define F75375_REG_FAN_TIMER        0x60
0045 
0046 #define F75375_REG_VOLT(nr)     (0x10 + (nr))
0047 #define F75375_REG_VOLT_HIGH(nr)    (0x20 + (nr) * 2)
0048 #define F75375_REG_VOLT_LOW(nr)     (0x21 + (nr) * 2)
0049 
0050 #define F75375_REG_TEMP(nr)     (0x14 + (nr))
0051 #define F75387_REG_TEMP11_LSB(nr)   (0x1a + (nr))
0052 #define F75375_REG_TEMP_HIGH(nr)    (0x28 + (nr) * 2)
0053 #define F75375_REG_TEMP_HYST(nr)    (0x29 + (nr) * 2)
0054 
0055 #define F75375_REG_FAN(nr)      (0x16 + (nr) * 2)
0056 #define F75375_REG_FAN_MIN(nr)      (0x2C + (nr) * 2)
0057 #define F75375_REG_FAN_FULL(nr)     (0x70 + (nr) * 0x10)
0058 #define F75375_REG_FAN_PWM_DUTY(nr) (0x76 + (nr) * 0x10)
0059 #define F75375_REG_FAN_PWM_CLOCK(nr)    (0x7D + (nr) * 0x10)
0060 
0061 #define F75375_REG_FAN_EXP(nr)      (0x74 + (nr) * 0x10)
0062 #define F75375_REG_FAN_B_TEMP(nr, step) ((0xA0 + (nr) * 0x10) + (step))
0063 #define F75375_REG_FAN_B_SPEED(nr, step) \
0064     ((0xA5 + (nr) * 0x10) + (step) * 2)
0065 
0066 #define F75375_REG_PWM1_RAISE_DUTY  0x69
0067 #define F75375_REG_PWM2_RAISE_DUTY  0x6A
0068 #define F75375_REG_PWM1_DROP_DUTY   0x6B
0069 #define F75375_REG_PWM2_DROP_DUTY   0x6C
0070 
0071 #define F75375_FAN_CTRL_LINEAR(nr)  (4 + nr)
0072 #define F75387_FAN_CTRL_LINEAR(nr)  (1 + ((nr) * 4))
0073 #define FAN_CTRL_MODE(nr)       (4 + ((nr) * 2))
0074 #define F75387_FAN_DUTY_MODE(nr)    (2 + ((nr) * 4))
0075 #define F75387_FAN_MANU_MODE(nr)    ((nr) * 4)
0076 
0077 /*
0078  * Data structures and manipulation thereof
0079  */
0080 
0081 struct f75375_data {
0082     unsigned short addr;
0083     struct device *hwmon_dev;
0084 
0085     const char *name;
0086     int kind;
0087     struct mutex update_lock; /* protect register access */
0088     bool valid;
0089     unsigned long last_updated; /* In jiffies */
0090     unsigned long last_limits;  /* In jiffies */
0091 
0092     /* Register values */
0093     u8 in[4];
0094     u8 in_max[4];
0095     u8 in_min[4];
0096     u16 fan[2];
0097     u16 fan_min[2];
0098     u16 fan_max[2];
0099     u16 fan_target[2];
0100     u8 fan_timer;
0101     u8 pwm[2];
0102     u8 pwm_mode[2];
0103     u8 pwm_enable[2];
0104     /*
0105      * f75387: For remote temperature reading, it uses signed 11-bit
0106      * values with LSB = 0.125 degree Celsius, left-justified in 16-bit
0107      * registers. For original 8-bit temp readings, the LSB just is 0.
0108      */
0109     s16 temp11[2];
0110     s8 temp_high[2];
0111     s8 temp_max_hyst[2];
0112 };
0113 
0114 static int f75375_detect(struct i2c_client *client,
0115              struct i2c_board_info *info);
0116 static int f75375_probe(struct i2c_client *client);
0117 static int f75375_remove(struct i2c_client *client);
0118 
0119 static const struct i2c_device_id f75375_id[] = {
0120     { "f75373", f75373 },
0121     { "f75375", f75375 },
0122     { "f75387", f75387 },
0123     { }
0124 };
0125 MODULE_DEVICE_TABLE(i2c, f75375_id);
0126 
0127 static struct i2c_driver f75375_driver = {
0128     .class = I2C_CLASS_HWMON,
0129     .driver = {
0130         .name = "f75375",
0131     },
0132     .probe_new = f75375_probe,
0133     .remove = f75375_remove,
0134     .id_table = f75375_id,
0135     .detect = f75375_detect,
0136     .address_list = normal_i2c,
0137 };
0138 
0139 static inline int f75375_read8(struct i2c_client *client, u8 reg)
0140 {
0141     return i2c_smbus_read_byte_data(client, reg);
0142 }
0143 
0144 /* in most cases, should be called while holding update_lock */
0145 static inline u16 f75375_read16(struct i2c_client *client, u8 reg)
0146 {
0147     return (i2c_smbus_read_byte_data(client, reg) << 8)
0148         | i2c_smbus_read_byte_data(client, reg + 1);
0149 }
0150 
0151 static inline void f75375_write8(struct i2c_client *client, u8 reg,
0152         u8 value)
0153 {
0154     i2c_smbus_write_byte_data(client, reg, value);
0155 }
0156 
0157 static inline void f75375_write16(struct i2c_client *client, u8 reg,
0158         u16 value)
0159 {
0160     int err = i2c_smbus_write_byte_data(client, reg, (value >> 8));
0161     if (err)
0162         return;
0163     i2c_smbus_write_byte_data(client, reg + 1, (value & 0xFF));
0164 }
0165 
0166 static void f75375_write_pwm(struct i2c_client *client, int nr)
0167 {
0168     struct f75375_data *data = i2c_get_clientdata(client);
0169     if (data->kind == f75387)
0170         f75375_write16(client, F75375_REG_FAN_EXP(nr), data->pwm[nr]);
0171     else
0172         f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr),
0173                   data->pwm[nr]);
0174 }
0175 
0176 static struct f75375_data *f75375_update_device(struct device *dev)
0177 {
0178     struct i2c_client *client = to_i2c_client(dev);
0179     struct f75375_data *data = i2c_get_clientdata(client);
0180     int nr;
0181 
0182     mutex_lock(&data->update_lock);
0183 
0184     /* Limit registers cache is refreshed after 60 seconds */
0185     if (time_after(jiffies, data->last_limits + 60 * HZ)
0186         || !data->valid) {
0187         for (nr = 0; nr < 2; nr++) {
0188             data->temp_high[nr] =
0189                 f75375_read8(client, F75375_REG_TEMP_HIGH(nr));
0190             data->temp_max_hyst[nr] =
0191                 f75375_read8(client, F75375_REG_TEMP_HYST(nr));
0192             data->fan_max[nr] =
0193                 f75375_read16(client, F75375_REG_FAN_FULL(nr));
0194             data->fan_min[nr] =
0195                 f75375_read16(client, F75375_REG_FAN_MIN(nr));
0196             data->fan_target[nr] =
0197                 f75375_read16(client, F75375_REG_FAN_EXP(nr));
0198         }
0199         for (nr = 0; nr < 4; nr++) {
0200             data->in_max[nr] =
0201                 f75375_read8(client, F75375_REG_VOLT_HIGH(nr));
0202             data->in_min[nr] =
0203                 f75375_read8(client, F75375_REG_VOLT_LOW(nr));
0204         }
0205         data->fan_timer = f75375_read8(client, F75375_REG_FAN_TIMER);
0206         data->last_limits = jiffies;
0207     }
0208 
0209     /* Measurement registers cache is refreshed after 2 second */
0210     if (time_after(jiffies, data->last_updated + 2 * HZ)
0211         || !data->valid) {
0212         for (nr = 0; nr < 2; nr++) {
0213             data->pwm[nr] = f75375_read8(client,
0214                 F75375_REG_FAN_PWM_DUTY(nr));
0215             /* assign MSB, therefore shift it by 8 bits */
0216             data->temp11[nr] =
0217                 f75375_read8(client, F75375_REG_TEMP(nr)) << 8;
0218             if (data->kind == f75387)
0219                 /* merge F75387's temperature LSB (11-bit) */
0220                 data->temp11[nr] |=
0221                     f75375_read8(client,
0222                              F75387_REG_TEMP11_LSB(nr));
0223             data->fan[nr] =
0224                 f75375_read16(client, F75375_REG_FAN(nr));
0225         }
0226         for (nr = 0; nr < 4; nr++)
0227             data->in[nr] =
0228                 f75375_read8(client, F75375_REG_VOLT(nr));
0229 
0230         data->last_updated = jiffies;
0231         data->valid = true;
0232     }
0233 
0234     mutex_unlock(&data->update_lock);
0235     return data;
0236 }
0237 
0238 static inline u16 rpm_from_reg(u16 reg)
0239 {
0240     if (reg == 0 || reg == 0xffff)
0241         return 0;
0242     return 1500000 / reg;
0243 }
0244 
0245 static inline u16 rpm_to_reg(int rpm)
0246 {
0247     if (rpm < 367 || rpm > 0xffff)
0248         return 0xffff;
0249     return 1500000 / rpm;
0250 }
0251 
0252 static bool duty_mode_enabled(u8 pwm_enable)
0253 {
0254     switch (pwm_enable) {
0255     case 0: /* Manual, duty mode (full speed) */
0256     case 1: /* Manual, duty mode */
0257     case 4: /* Auto, duty mode */
0258         return true;
0259     case 2: /* Auto, speed mode */
0260     case 3: /* Manual, speed mode */
0261         return false;
0262     default:
0263         WARN(1, "Unexpected pwm_enable value %d\n", pwm_enable);
0264         return true;
0265     }
0266 }
0267 
0268 static bool auto_mode_enabled(u8 pwm_enable)
0269 {
0270     switch (pwm_enable) {
0271     case 0: /* Manual, duty mode (full speed) */
0272     case 1: /* Manual, duty mode */
0273     case 3: /* Manual, speed mode */
0274         return false;
0275     case 2: /* Auto, speed mode */
0276     case 4: /* Auto, duty mode */
0277         return true;
0278     default:
0279         WARN(1, "Unexpected pwm_enable value %d\n", pwm_enable);
0280         return false;
0281     }
0282 }
0283 
0284 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
0285         const char *buf, size_t count)
0286 {
0287     int nr = to_sensor_dev_attr(attr)->index;
0288     struct i2c_client *client = to_i2c_client(dev);
0289     struct f75375_data *data = i2c_get_clientdata(client);
0290     unsigned long val;
0291     int err;
0292 
0293     err = kstrtoul(buf, 10, &val);
0294     if (err < 0)
0295         return err;
0296 
0297     mutex_lock(&data->update_lock);
0298     data->fan_min[nr] = rpm_to_reg(val);
0299     f75375_write16(client, F75375_REG_FAN_MIN(nr), data->fan_min[nr]);
0300     mutex_unlock(&data->update_lock);
0301     return count;
0302 }
0303 
0304 static ssize_t set_fan_target(struct device *dev, struct device_attribute *attr,
0305         const char *buf, size_t count)
0306 {
0307     int nr = to_sensor_dev_attr(attr)->index;
0308     struct i2c_client *client = to_i2c_client(dev);
0309     struct f75375_data *data = i2c_get_clientdata(client);
0310     unsigned long val;
0311     int err;
0312 
0313     err = kstrtoul(buf, 10, &val);
0314     if (err < 0)
0315         return err;
0316 
0317     if (auto_mode_enabled(data->pwm_enable[nr]))
0318         return -EINVAL;
0319     if (data->kind == f75387 && duty_mode_enabled(data->pwm_enable[nr]))
0320         return -EINVAL;
0321 
0322     mutex_lock(&data->update_lock);
0323     data->fan_target[nr] = rpm_to_reg(val);
0324     f75375_write16(client, F75375_REG_FAN_EXP(nr), data->fan_target[nr]);
0325     mutex_unlock(&data->update_lock);
0326     return count;
0327 }
0328 
0329 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
0330         const char *buf, size_t count)
0331 {
0332     int nr = to_sensor_dev_attr(attr)->index;
0333     struct i2c_client *client = to_i2c_client(dev);
0334     struct f75375_data *data = i2c_get_clientdata(client);
0335     unsigned long val;
0336     int err;
0337 
0338     err = kstrtoul(buf, 10, &val);
0339     if (err < 0)
0340         return err;
0341 
0342     if (auto_mode_enabled(data->pwm_enable[nr]) ||
0343         !duty_mode_enabled(data->pwm_enable[nr]))
0344         return -EINVAL;
0345 
0346     mutex_lock(&data->update_lock);
0347     data->pwm[nr] = clamp_val(val, 0, 255);
0348     f75375_write_pwm(client, nr);
0349     mutex_unlock(&data->update_lock);
0350     return count;
0351 }
0352 
0353 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
0354         *attr, char *buf)
0355 {
0356     int nr = to_sensor_dev_attr(attr)->index;
0357     struct f75375_data *data = f75375_update_device(dev);
0358     return sprintf(buf, "%d\n", data->pwm_enable[nr]);
0359 }
0360 
0361 static int set_pwm_enable_direct(struct i2c_client *client, int nr, int val)
0362 {
0363     struct f75375_data *data = i2c_get_clientdata(client);
0364     u8 fanmode;
0365 
0366     if (val < 0 || val > 4)
0367         return -EINVAL;
0368 
0369     fanmode = f75375_read8(client, F75375_REG_FAN_TIMER);
0370     if (data->kind == f75387) {
0371         /* For now, deny dangerous toggling of duty mode */
0372         if (duty_mode_enabled(data->pwm_enable[nr]) !=
0373                 duty_mode_enabled(val))
0374             return -EOPNOTSUPP;
0375         /* clear each fanX_mode bit before setting them properly */
0376         fanmode &= ~(1 << F75387_FAN_DUTY_MODE(nr));
0377         fanmode &= ~(1 << F75387_FAN_MANU_MODE(nr));
0378         switch (val) {
0379         case 0: /* full speed */
0380             fanmode |= (1 << F75387_FAN_MANU_MODE(nr));
0381             fanmode |= (1 << F75387_FAN_DUTY_MODE(nr));
0382             data->pwm[nr] = 255;
0383             break;
0384         case 1: /* PWM */
0385             fanmode  |= (1 << F75387_FAN_MANU_MODE(nr));
0386             fanmode  |= (1 << F75387_FAN_DUTY_MODE(nr));
0387             break;
0388         case 2: /* Automatic, speed mode */
0389             break;
0390         case 3: /* fan speed */
0391             fanmode |= (1 << F75387_FAN_MANU_MODE(nr));
0392             break;
0393         case 4: /* Automatic, pwm */
0394             fanmode |= (1 << F75387_FAN_DUTY_MODE(nr));
0395             break;
0396         }
0397     } else {
0398         /* clear each fanX_mode bit before setting them properly */
0399         fanmode &= ~(3 << FAN_CTRL_MODE(nr));
0400         switch (val) {
0401         case 0: /* full speed */
0402             fanmode  |= (3 << FAN_CTRL_MODE(nr));
0403             data->pwm[nr] = 255;
0404             break;
0405         case 1: /* PWM */
0406             fanmode  |= (3 << FAN_CTRL_MODE(nr));
0407             break;
0408         case 2: /* AUTOMATIC*/
0409             fanmode  |= (1 << FAN_CTRL_MODE(nr));
0410             break;
0411         case 3: /* fan speed */
0412             break;
0413         case 4: /* Automatic pwm */
0414             return -EINVAL;
0415         }
0416     }
0417 
0418     f75375_write8(client, F75375_REG_FAN_TIMER, fanmode);
0419     data->pwm_enable[nr] = val;
0420     if (val == 0)
0421         f75375_write_pwm(client, nr);
0422     return 0;
0423 }
0424 
0425 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
0426         const char *buf, size_t count)
0427 {
0428     int nr = to_sensor_dev_attr(attr)->index;
0429     struct i2c_client *client = to_i2c_client(dev);
0430     struct f75375_data *data = i2c_get_clientdata(client);
0431     unsigned long val;
0432     int err;
0433 
0434     err = kstrtoul(buf, 10, &val);
0435     if (err < 0)
0436         return err;
0437 
0438     mutex_lock(&data->update_lock);
0439     err = set_pwm_enable_direct(client, nr, val);
0440     mutex_unlock(&data->update_lock);
0441     return err ? err : count;
0442 }
0443 
0444 static ssize_t set_pwm_mode(struct device *dev, struct device_attribute *attr,
0445         const char *buf, size_t count)
0446 {
0447     int nr = to_sensor_dev_attr(attr)->index;
0448     struct i2c_client *client = to_i2c_client(dev);
0449     struct f75375_data *data = i2c_get_clientdata(client);
0450     unsigned long val;
0451     int err;
0452     u8 conf;
0453     char reg, ctrl;
0454 
0455     err = kstrtoul(buf, 10, &val);
0456     if (err < 0)
0457         return err;
0458 
0459     if (!(val == 0 || val == 1))
0460         return -EINVAL;
0461 
0462     /* F75373 does not support DC (linear voltage) fan control mode */
0463     if (data->kind == f75373 && val == 0)
0464         return -EINVAL;
0465 
0466     /* take care for different registers */
0467     if (data->kind == f75387) {
0468         reg = F75375_REG_FAN_TIMER;
0469         ctrl = F75387_FAN_CTRL_LINEAR(nr);
0470     } else {
0471         reg = F75375_REG_CONFIG1;
0472         ctrl = F75375_FAN_CTRL_LINEAR(nr);
0473     }
0474 
0475     mutex_lock(&data->update_lock);
0476     conf = f75375_read8(client, reg);
0477     conf &= ~(1 << ctrl);
0478 
0479     if (val == 0)
0480         conf |= (1 << ctrl);
0481 
0482     f75375_write8(client, reg, conf);
0483     data->pwm_mode[nr] = val;
0484     mutex_unlock(&data->update_lock);
0485     return count;
0486 }
0487 
0488 static ssize_t show_pwm(struct device *dev, struct device_attribute
0489         *attr, char *buf)
0490 {
0491     int nr = to_sensor_dev_attr(attr)->index;
0492     struct f75375_data *data = f75375_update_device(dev);
0493     return sprintf(buf, "%d\n", data->pwm[nr]);
0494 }
0495 
0496 static ssize_t show_pwm_mode(struct device *dev, struct device_attribute
0497         *attr, char *buf)
0498 {
0499     int nr = to_sensor_dev_attr(attr)->index;
0500     struct f75375_data *data = f75375_update_device(dev);
0501     return sprintf(buf, "%d\n", data->pwm_mode[nr]);
0502 }
0503 
0504 #define VOLT_FROM_REG(val) ((val) * 8)
0505 #define VOLT_TO_REG(val) ((val) / 8)
0506 
0507 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
0508         char *buf)
0509 {
0510     int nr = to_sensor_dev_attr(attr)->index;
0511     struct f75375_data *data = f75375_update_device(dev);
0512     return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in[nr]));
0513 }
0514 
0515 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
0516         char *buf)
0517 {
0518     int nr = to_sensor_dev_attr(attr)->index;
0519     struct f75375_data *data = f75375_update_device(dev);
0520     return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_max[nr]));
0521 }
0522 
0523 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
0524         char *buf)
0525 {
0526     int nr = to_sensor_dev_attr(attr)->index;
0527     struct f75375_data *data = f75375_update_device(dev);
0528     return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_min[nr]));
0529 }
0530 
0531 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
0532         const char *buf, size_t count)
0533 {
0534     int nr = to_sensor_dev_attr(attr)->index;
0535     struct i2c_client *client = to_i2c_client(dev);
0536     struct f75375_data *data = i2c_get_clientdata(client);
0537     unsigned long val;
0538     int err;
0539 
0540     err = kstrtoul(buf, 10, &val);
0541     if (err < 0)
0542         return err;
0543 
0544     val = clamp_val(VOLT_TO_REG(val), 0, 0xff);
0545     mutex_lock(&data->update_lock);
0546     data->in_max[nr] = val;
0547     f75375_write8(client, F75375_REG_VOLT_HIGH(nr), data->in_max[nr]);
0548     mutex_unlock(&data->update_lock);
0549     return count;
0550 }
0551 
0552 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
0553         const char *buf, size_t count)
0554 {
0555     int nr = to_sensor_dev_attr(attr)->index;
0556     struct i2c_client *client = to_i2c_client(dev);
0557     struct f75375_data *data = i2c_get_clientdata(client);
0558     unsigned long val;
0559     int err;
0560 
0561     err = kstrtoul(buf, 10, &val);
0562     if (err < 0)
0563         return err;
0564 
0565     val = clamp_val(VOLT_TO_REG(val), 0, 0xff);
0566     mutex_lock(&data->update_lock);
0567     data->in_min[nr] = val;
0568     f75375_write8(client, F75375_REG_VOLT_LOW(nr), data->in_min[nr]);
0569     mutex_unlock(&data->update_lock);
0570     return count;
0571 }
0572 #define TEMP_FROM_REG(val) ((val) * 1000)
0573 #define TEMP_TO_REG(val) ((val) / 1000)
0574 #define TEMP11_FROM_REG(reg)    ((reg) / 32 * 125)
0575 
0576 static ssize_t show_temp11(struct device *dev, struct device_attribute *attr,
0577         char *buf)
0578 {
0579     int nr = to_sensor_dev_attr(attr)->index;
0580     struct f75375_data *data = f75375_update_device(dev);
0581     return sprintf(buf, "%d\n", TEMP11_FROM_REG(data->temp11[nr]));
0582 }
0583 
0584 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
0585         char *buf)
0586 {
0587     int nr = to_sensor_dev_attr(attr)->index;
0588     struct f75375_data *data = f75375_update_device(dev);
0589     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
0590 }
0591 
0592 static ssize_t show_temp_max_hyst(struct device *dev,
0593         struct device_attribute *attr, char *buf)
0594 {
0595     int nr = to_sensor_dev_attr(attr)->index;
0596     struct f75375_data *data = f75375_update_device(dev);
0597     return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[nr]));
0598 }
0599 
0600 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
0601         const char *buf, size_t count)
0602 {
0603     int nr = to_sensor_dev_attr(attr)->index;
0604     struct i2c_client *client = to_i2c_client(dev);
0605     struct f75375_data *data = i2c_get_clientdata(client);
0606     unsigned long val;
0607     int err;
0608 
0609     err = kstrtoul(buf, 10, &val);
0610     if (err < 0)
0611         return err;
0612 
0613     val = clamp_val(TEMP_TO_REG(val), 0, 127);
0614     mutex_lock(&data->update_lock);
0615     data->temp_high[nr] = val;
0616     f75375_write8(client, F75375_REG_TEMP_HIGH(nr), data->temp_high[nr]);
0617     mutex_unlock(&data->update_lock);
0618     return count;
0619 }
0620 
0621 static ssize_t set_temp_max_hyst(struct device *dev,
0622     struct device_attribute *attr, const char *buf, size_t count)
0623 {
0624     int nr = to_sensor_dev_attr(attr)->index;
0625     struct i2c_client *client = to_i2c_client(dev);
0626     struct f75375_data *data = i2c_get_clientdata(client);
0627     unsigned long val;
0628     int err;
0629 
0630     err = kstrtoul(buf, 10, &val);
0631     if (err < 0)
0632         return err;
0633 
0634     val = clamp_val(TEMP_TO_REG(val), 0, 127);
0635     mutex_lock(&data->update_lock);
0636     data->temp_max_hyst[nr] = val;
0637     f75375_write8(client, F75375_REG_TEMP_HYST(nr),
0638         data->temp_max_hyst[nr]);
0639     mutex_unlock(&data->update_lock);
0640     return count;
0641 }
0642 
0643 #define show_fan(thing) \
0644 static ssize_t show_##thing(struct device *dev, struct device_attribute *attr, \
0645             char *buf)\
0646 {\
0647     int nr = to_sensor_dev_attr(attr)->index;\
0648     struct f75375_data *data = f75375_update_device(dev); \
0649     return sprintf(buf, "%d\n", rpm_from_reg(data->thing[nr])); \
0650 }
0651 
0652 show_fan(fan);
0653 show_fan(fan_min);
0654 show_fan(fan_max);
0655 show_fan(fan_target);
0656 
0657 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0);
0658 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO|S_IWUSR,
0659     show_in_max, set_in_max, 0);
0660 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO|S_IWUSR,
0661     show_in_min, set_in_min, 0);
0662 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
0663 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO|S_IWUSR,
0664     show_in_max, set_in_max, 1);
0665 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO|S_IWUSR,
0666     show_in_min, set_in_min, 1);
0667 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
0668 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO|S_IWUSR,
0669     show_in_max, set_in_max, 2);
0670 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO|S_IWUSR,
0671     show_in_min, set_in_min, 2);
0672 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
0673 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO|S_IWUSR,
0674     show_in_max, set_in_max, 3);
0675 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO|S_IWUSR,
0676     show_in_min, set_in_min, 3);
0677 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 0);
0678 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO|S_IWUSR,
0679     show_temp_max_hyst, set_temp_max_hyst, 0);
0680 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO|S_IWUSR,
0681     show_temp_max, set_temp_max, 0);
0682 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 1);
0683 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO|S_IWUSR,
0684     show_temp_max_hyst, set_temp_max_hyst, 1);
0685 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO|S_IWUSR,
0686     show_temp_max, set_temp_max, 1);
0687 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
0688 static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO, show_fan_max, NULL, 0);
0689 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO|S_IWUSR,
0690     show_fan_min, set_fan_min, 0);
0691 static SENSOR_DEVICE_ATTR(fan1_target, S_IRUGO|S_IWUSR,
0692     show_fan_target, set_fan_target, 0);
0693 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
0694 static SENSOR_DEVICE_ATTR(fan2_max, S_IRUGO, show_fan_max, NULL, 1);
0695 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO|S_IWUSR,
0696     show_fan_min, set_fan_min, 1);
0697 static SENSOR_DEVICE_ATTR(fan2_target, S_IRUGO|S_IWUSR,
0698     show_fan_target, set_fan_target, 1);
0699 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR,
0700     show_pwm, set_pwm, 0);
0701 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR,
0702     show_pwm_enable, set_pwm_enable, 0);
0703 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO,
0704     show_pwm_mode, set_pwm_mode, 0);
0705 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR,
0706     show_pwm, set_pwm, 1);
0707 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR,
0708     show_pwm_enable, set_pwm_enable, 1);
0709 static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO,
0710     show_pwm_mode, set_pwm_mode, 1);
0711 
0712 static struct attribute *f75375_attributes[] = {
0713     &sensor_dev_attr_temp1_input.dev_attr.attr,
0714     &sensor_dev_attr_temp1_max.dev_attr.attr,
0715     &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
0716     &sensor_dev_attr_temp2_input.dev_attr.attr,
0717     &sensor_dev_attr_temp2_max.dev_attr.attr,
0718     &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
0719     &sensor_dev_attr_fan1_input.dev_attr.attr,
0720     &sensor_dev_attr_fan1_max.dev_attr.attr,
0721     &sensor_dev_attr_fan1_min.dev_attr.attr,
0722     &sensor_dev_attr_fan1_target.dev_attr.attr,
0723     &sensor_dev_attr_fan2_input.dev_attr.attr,
0724     &sensor_dev_attr_fan2_max.dev_attr.attr,
0725     &sensor_dev_attr_fan2_min.dev_attr.attr,
0726     &sensor_dev_attr_fan2_target.dev_attr.attr,
0727     &sensor_dev_attr_pwm1.dev_attr.attr,
0728     &sensor_dev_attr_pwm1_enable.dev_attr.attr,
0729     &sensor_dev_attr_pwm1_mode.dev_attr.attr,
0730     &sensor_dev_attr_pwm2.dev_attr.attr,
0731     &sensor_dev_attr_pwm2_enable.dev_attr.attr,
0732     &sensor_dev_attr_pwm2_mode.dev_attr.attr,
0733     &sensor_dev_attr_in0_input.dev_attr.attr,
0734     &sensor_dev_attr_in0_max.dev_attr.attr,
0735     &sensor_dev_attr_in0_min.dev_attr.attr,
0736     &sensor_dev_attr_in1_input.dev_attr.attr,
0737     &sensor_dev_attr_in1_max.dev_attr.attr,
0738     &sensor_dev_attr_in1_min.dev_attr.attr,
0739     &sensor_dev_attr_in2_input.dev_attr.attr,
0740     &sensor_dev_attr_in2_max.dev_attr.attr,
0741     &sensor_dev_attr_in2_min.dev_attr.attr,
0742     &sensor_dev_attr_in3_input.dev_attr.attr,
0743     &sensor_dev_attr_in3_max.dev_attr.attr,
0744     &sensor_dev_attr_in3_min.dev_attr.attr,
0745     NULL
0746 };
0747 
0748 static const struct attribute_group f75375_group = {
0749     .attrs = f75375_attributes,
0750 };
0751 
0752 static void f75375_init(struct i2c_client *client, struct f75375_data *data,
0753         struct f75375s_platform_data *f75375s_pdata)
0754 {
0755     int nr;
0756 
0757     if (!f75375s_pdata) {
0758         u8 conf, mode;
0759         int nr;
0760 
0761         conf = f75375_read8(client, F75375_REG_CONFIG1);
0762         mode = f75375_read8(client, F75375_REG_FAN_TIMER);
0763         for (nr = 0; nr < 2; nr++) {
0764             if (data->kind == f75387) {
0765                 bool manu, duty;
0766 
0767                 if (!(mode & (1 << F75387_FAN_CTRL_LINEAR(nr))))
0768                     data->pwm_mode[nr] = 1;
0769 
0770                 manu = ((mode >> F75387_FAN_MANU_MODE(nr)) & 1);
0771                 duty = ((mode >> F75387_FAN_DUTY_MODE(nr)) & 1);
0772                 if (!manu && duty)
0773                     /* auto, pwm */
0774                     data->pwm_enable[nr] = 4;
0775                 else if (manu && !duty)
0776                     /* manual, speed */
0777                     data->pwm_enable[nr] = 3;
0778                 else if (!manu && !duty)
0779                     /* automatic, speed */
0780                     data->pwm_enable[nr] = 2;
0781                 else
0782                     /* manual, pwm */
0783                     data->pwm_enable[nr] = 1;
0784             } else {
0785                 if (!(conf & (1 << F75375_FAN_CTRL_LINEAR(nr))))
0786                     data->pwm_mode[nr] = 1;
0787 
0788                 switch ((mode >> FAN_CTRL_MODE(nr)) & 3) {
0789                 case 0:     /* speed */
0790                     data->pwm_enable[nr] = 3;
0791                     break;
0792                 case 1:     /* automatic */
0793                     data->pwm_enable[nr] = 2;
0794                     break;
0795                 default:    /* manual */
0796                     data->pwm_enable[nr] = 1;
0797                     break;
0798                 }
0799             }
0800         }
0801         return;
0802     }
0803 
0804     set_pwm_enable_direct(client, 0, f75375s_pdata->pwm_enable[0]);
0805     set_pwm_enable_direct(client, 1, f75375s_pdata->pwm_enable[1]);
0806     for (nr = 0; nr < 2; nr++) {
0807         if (auto_mode_enabled(f75375s_pdata->pwm_enable[nr]) ||
0808             !duty_mode_enabled(f75375s_pdata->pwm_enable[nr]))
0809             continue;
0810         data->pwm[nr] = clamp_val(f75375s_pdata->pwm[nr], 0, 255);
0811         f75375_write_pwm(client, nr);
0812     }
0813 
0814 }
0815 
0816 static int f75375_probe(struct i2c_client *client)
0817 {
0818     struct f75375_data *data;
0819     struct f75375s_platform_data *f75375s_pdata =
0820             dev_get_platdata(&client->dev);
0821     int err;
0822 
0823     if (!i2c_check_functionality(client->adapter,
0824                 I2C_FUNC_SMBUS_BYTE_DATA))
0825         return -EIO;
0826     data = devm_kzalloc(&client->dev, sizeof(struct f75375_data),
0827                 GFP_KERNEL);
0828     if (!data)
0829         return -ENOMEM;
0830 
0831     i2c_set_clientdata(client, data);
0832     mutex_init(&data->update_lock);
0833     data->kind = i2c_match_id(f75375_id, client)->driver_data;
0834 
0835     err = sysfs_create_group(&client->dev.kobj, &f75375_group);
0836     if (err)
0837         return err;
0838 
0839     if (data->kind != f75373) {
0840         err = sysfs_chmod_file(&client->dev.kobj,
0841             &sensor_dev_attr_pwm1_mode.dev_attr.attr,
0842             S_IRUGO | S_IWUSR);
0843         if (err)
0844             goto exit_remove;
0845         err = sysfs_chmod_file(&client->dev.kobj,
0846             &sensor_dev_attr_pwm2_mode.dev_attr.attr,
0847             S_IRUGO | S_IWUSR);
0848         if (err)
0849             goto exit_remove;
0850     }
0851 
0852     data->hwmon_dev = hwmon_device_register(&client->dev);
0853     if (IS_ERR(data->hwmon_dev)) {
0854         err = PTR_ERR(data->hwmon_dev);
0855         goto exit_remove;
0856     }
0857 
0858     f75375_init(client, data, f75375s_pdata);
0859 
0860     return 0;
0861 
0862 exit_remove:
0863     sysfs_remove_group(&client->dev.kobj, &f75375_group);
0864     return err;
0865 }
0866 
0867 static int f75375_remove(struct i2c_client *client)
0868 {
0869     struct f75375_data *data = i2c_get_clientdata(client);
0870     hwmon_device_unregister(data->hwmon_dev);
0871     sysfs_remove_group(&client->dev.kobj, &f75375_group);
0872     return 0;
0873 }
0874 
0875 /* Return 0 if detection is successful, -ENODEV otherwise */
0876 static int f75375_detect(struct i2c_client *client,
0877              struct i2c_board_info *info)
0878 {
0879     struct i2c_adapter *adapter = client->adapter;
0880     u16 vendid, chipid;
0881     u8 version;
0882     const char *name;
0883 
0884     vendid = f75375_read16(client, F75375_REG_VENDOR);
0885     chipid = f75375_read16(client, F75375_CHIP_ID);
0886     if (vendid != 0x1934)
0887         return -ENODEV;
0888 
0889     if (chipid == 0x0306)
0890         name = "f75375";
0891     else if (chipid == 0x0204)
0892         name = "f75373";
0893     else if (chipid == 0x0410)
0894         name = "f75387";
0895     else
0896         return -ENODEV;
0897 
0898     version = f75375_read8(client, F75375_REG_VERSION);
0899     dev_info(&adapter->dev, "found %s version: %02X\n", name, version);
0900     strlcpy(info->type, name, I2C_NAME_SIZE);
0901 
0902     return 0;
0903 }
0904 
0905 module_i2c_driver(f75375_driver);
0906 
0907 MODULE_AUTHOR("Riku Voipio");
0908 MODULE_LICENSE("GPL");
0909 MODULE_DESCRIPTION("F75373/F75375/F75387 hardware monitoring driver");
[ 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!