Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * asb100.c - Part of lm_sensors, Linux kernel modules for hardware
0004  *        monitoring
0005  *
0006  * Copyright (C) 2004 Mark M. Hoffman <mhoffman@lightlink.com>
0007  *
0008  * (derived from w83781d.c)
0009  *
0010  * Copyright (C) 1998 - 2003  Frodo Looijaard <frodol@dds.nl>,
0011  *                Philip Edelbrock <phil@netroedge.com>, and
0012  *                Mark Studebaker <mdsxyz123@yahoo.com>
0013  */
0014 
0015 /*
0016  * This driver supports the hardware sensor chips: Asus ASB100 and
0017  * ASB100-A "BACH".
0018  *
0019  * ASB100-A supports pwm1, while plain ASB100 does not.  There is no known
0020  * way for the driver to tell which one is there.
0021  *
0022  * Chip     #vin    #fanin  #pwm    #temp   wchipid vendid  i2c ISA
0023  * asb100   7   3   1   4   0x31    0x0694  yes no
0024  */
0025 
0026 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0027 
0028 #include <linux/module.h>
0029 #include <linux/slab.h>
0030 #include <linux/i2c.h>
0031 #include <linux/hwmon.h>
0032 #include <linux/hwmon-sysfs.h>
0033 #include <linux/hwmon-vid.h>
0034 #include <linux/err.h>
0035 #include <linux/init.h>
0036 #include <linux/jiffies.h>
0037 #include <linux/mutex.h>
0038 #include "lm75.h"
0039 
0040 /* I2C addresses to scan */
0041 static const unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END };
0042 
0043 static unsigned short force_subclients[4];
0044 module_param_array(force_subclients, short, NULL, 0);
0045 MODULE_PARM_DESC(force_subclients,
0046     "List of subclient addresses: {bus, clientaddr, subclientaddr1, subclientaddr2}");
0047 
0048 /* Voltage IN registers 0-6 */
0049 #define ASB100_REG_IN(nr)   (0x20 + (nr))
0050 #define ASB100_REG_IN_MAX(nr)   (0x2b + (nr * 2))
0051 #define ASB100_REG_IN_MIN(nr)   (0x2c + (nr * 2))
0052 
0053 /* FAN IN registers 1-3 */
0054 #define ASB100_REG_FAN(nr)  (0x28 + (nr))
0055 #define ASB100_REG_FAN_MIN(nr)  (0x3b + (nr))
0056 
0057 /* TEMPERATURE registers 1-4 */
0058 static const u16 asb100_reg_temp[]  = {0, 0x27, 0x150, 0x250, 0x17};
0059 static const u16 asb100_reg_temp_max[]  = {0, 0x39, 0x155, 0x255, 0x18};
0060 static const u16 asb100_reg_temp_hyst[] = {0, 0x3a, 0x153, 0x253, 0x19};
0061 
0062 #define ASB100_REG_TEMP(nr) (asb100_reg_temp[nr])
0063 #define ASB100_REG_TEMP_MAX(nr) (asb100_reg_temp_max[nr])
0064 #define ASB100_REG_TEMP_HYST(nr) (asb100_reg_temp_hyst[nr])
0065 
0066 #define ASB100_REG_TEMP2_CONFIG 0x0152
0067 #define ASB100_REG_TEMP3_CONFIG 0x0252
0068 
0069 
0070 #define ASB100_REG_CONFIG   0x40
0071 #define ASB100_REG_ALARM1   0x41
0072 #define ASB100_REG_ALARM2   0x42
0073 #define ASB100_REG_SMIM1    0x43
0074 #define ASB100_REG_SMIM2    0x44
0075 #define ASB100_REG_VID_FANDIV   0x47
0076 #define ASB100_REG_I2C_ADDR 0x48
0077 #define ASB100_REG_CHIPID   0x49
0078 #define ASB100_REG_I2C_SUBADDR  0x4a
0079 #define ASB100_REG_PIN      0x4b
0080 #define ASB100_REG_IRQ      0x4c
0081 #define ASB100_REG_BANK     0x4e
0082 #define ASB100_REG_CHIPMAN  0x4f
0083 
0084 #define ASB100_REG_WCHIPID  0x58
0085 
0086 /* bit 7 -> enable, bits 0-3 -> duty cycle */
0087 #define ASB100_REG_PWM1     0x59
0088 
0089 /*
0090  * CONVERSIONS
0091  * Rounding and limit checking is only done on the TO_REG variants.
0092  */
0093 
0094 /* These constants are a guess, consistent w/ w83781d */
0095 #define ASB100_IN_MIN       0
0096 #define ASB100_IN_MAX       4080
0097 
0098 /*
0099  * IN: 1/1000 V (0V to 4.08V)
0100  * REG: 16mV/bit
0101  */
0102 static u8 IN_TO_REG(unsigned val)
0103 {
0104     unsigned nval = clamp_val(val, ASB100_IN_MIN, ASB100_IN_MAX);
0105     return (nval + 8) / 16;
0106 }
0107 
0108 static unsigned IN_FROM_REG(u8 reg)
0109 {
0110     return reg * 16;
0111 }
0112 
0113 static u8 FAN_TO_REG(long rpm, int div)
0114 {
0115     if (rpm == -1)
0116         return 0;
0117     if (rpm == 0)
0118         return 255;
0119     rpm = clamp_val(rpm, 1, 1000000);
0120     return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
0121 }
0122 
0123 static int FAN_FROM_REG(u8 val, int div)
0124 {
0125     return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
0126 }
0127 
0128 /* These constants are a guess, consistent w/ w83781d */
0129 #define ASB100_TEMP_MIN     -128000
0130 #define ASB100_TEMP_MAX     127000
0131 
0132 /*
0133  * TEMP: 0.001C/bit (-128C to +127C)
0134  * REG: 1C/bit, two's complement
0135  */
0136 static u8 TEMP_TO_REG(long temp)
0137 {
0138     int ntemp = clamp_val(temp, ASB100_TEMP_MIN, ASB100_TEMP_MAX);
0139     ntemp += (ntemp < 0 ? -500 : 500);
0140     return (u8)(ntemp / 1000);
0141 }
0142 
0143 static int TEMP_FROM_REG(u8 reg)
0144 {
0145     return (s8)reg * 1000;
0146 }
0147 
0148 /*
0149  * PWM: 0 - 255 per sensors documentation
0150  * REG: (6.25% duty cycle per bit)
0151  */
0152 static u8 ASB100_PWM_TO_REG(int pwm)
0153 {
0154     pwm = clamp_val(pwm, 0, 255);
0155     return (u8)(pwm / 16);
0156 }
0157 
0158 static int ASB100_PWM_FROM_REG(u8 reg)
0159 {
0160     return reg * 16;
0161 }
0162 
0163 #define DIV_FROM_REG(val) (1 << (val))
0164 
0165 /*
0166  * FAN DIV: 1, 2, 4, or 8 (defaults to 2)
0167  * REG: 0, 1, 2, or 3 (respectively) (defaults to 1)
0168  */
0169 static u8 DIV_TO_REG(long val)
0170 {
0171     return val == 8 ? 3 : val == 4 ? 2 : val == 1 ? 0 : 1;
0172 }
0173 
0174 /*
0175  * For each registered client, we need to keep some data in memory. That
0176  * data is pointed to by client->data. The structure itself is
0177  * dynamically allocated, at the same time the client itself is allocated.
0178  */
0179 struct asb100_data {
0180     struct device *hwmon_dev;
0181     struct mutex lock;
0182 
0183     struct mutex update_lock;
0184     unsigned long last_updated; /* In jiffies */
0185 
0186     /* array of 2 pointers to subclients */
0187     struct i2c_client *lm75[2];
0188 
0189     bool valid;     /* true if following fields are valid */
0190     u8 in[7];       /* Register value */
0191     u8 in_max[7];       /* Register value */
0192     u8 in_min[7];       /* Register value */
0193     u8 fan[3];      /* Register value */
0194     u8 fan_min[3];      /* Register value */
0195     u16 temp[4];        /* Register value (0 and 3 are u8 only) */
0196     u16 temp_max[4];    /* Register value (0 and 3 are u8 only) */
0197     u16 temp_hyst[4];   /* Register value (0 and 3 are u8 only) */
0198     u8 fan_div[3];      /* Register encoding, right justified */
0199     u8 pwm;         /* Register encoding */
0200     u8 vid;         /* Register encoding, combined */
0201     u32 alarms;     /* Register encoding, combined */
0202     u8 vrm;
0203 };
0204 
0205 static int asb100_read_value(struct i2c_client *client, u16 reg);
0206 static void asb100_write_value(struct i2c_client *client, u16 reg, u16 val);
0207 
0208 static int asb100_probe(struct i2c_client *client);
0209 static int asb100_detect(struct i2c_client *client,
0210              struct i2c_board_info *info);
0211 static int asb100_remove(struct i2c_client *client);
0212 static struct asb100_data *asb100_update_device(struct device *dev);
0213 static void asb100_init_client(struct i2c_client *client);
0214 
0215 static const struct i2c_device_id asb100_id[] = {
0216     { "asb100", 0 },
0217     { }
0218 };
0219 MODULE_DEVICE_TABLE(i2c, asb100_id);
0220 
0221 static struct i2c_driver asb100_driver = {
0222     .class      = I2C_CLASS_HWMON,
0223     .driver = {
0224         .name   = "asb100",
0225     },
0226     .probe_new  = asb100_probe,
0227     .remove     = asb100_remove,
0228     .id_table   = asb100_id,
0229     .detect     = asb100_detect,
0230     .address_list   = normal_i2c,
0231 };
0232 
0233 /* 7 Voltages */
0234 #define show_in_reg(reg) \
0235 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
0236         char *buf) \
0237 { \
0238     int nr = to_sensor_dev_attr(attr)->index; \
0239     struct asb100_data *data = asb100_update_device(dev); \
0240     return sprintf(buf, "%d\n", IN_FROM_REG(data->reg[nr])); \
0241 }
0242 
0243 show_in_reg(in)
0244 show_in_reg(in_min)
0245 show_in_reg(in_max)
0246 
0247 #define set_in_reg(REG, reg) \
0248 static ssize_t set_in_##reg(struct device *dev, struct device_attribute *attr, \
0249         const char *buf, size_t count) \
0250 { \
0251     int nr = to_sensor_dev_attr(attr)->index; \
0252     struct i2c_client *client = to_i2c_client(dev); \
0253     struct asb100_data *data = i2c_get_clientdata(client); \
0254     unsigned long val; \
0255     int err = kstrtoul(buf, 10, &val); \
0256     if (err) \
0257         return err; \
0258     mutex_lock(&data->update_lock); \
0259     data->in_##reg[nr] = IN_TO_REG(val); \
0260     asb100_write_value(client, ASB100_REG_IN_##REG(nr), \
0261         data->in_##reg[nr]); \
0262     mutex_unlock(&data->update_lock); \
0263     return count; \
0264 }
0265 
0266 set_in_reg(MIN, min)
0267 set_in_reg(MAX, max)
0268 
0269 #define sysfs_in(offset) \
0270 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
0271         show_in, NULL, offset); \
0272 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
0273         show_in_min, set_in_min, offset); \
0274 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
0275         show_in_max, set_in_max, offset)
0276 
0277 sysfs_in(0);
0278 sysfs_in(1);
0279 sysfs_in(2);
0280 sysfs_in(3);
0281 sysfs_in(4);
0282 sysfs_in(5);
0283 sysfs_in(6);
0284 
0285 /* 3 Fans */
0286 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
0287         char *buf)
0288 {
0289     int nr = to_sensor_dev_attr(attr)->index;
0290     struct asb100_data *data = asb100_update_device(dev);
0291     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
0292         DIV_FROM_REG(data->fan_div[nr])));
0293 }
0294 
0295 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
0296         char *buf)
0297 {
0298     int nr = to_sensor_dev_attr(attr)->index;
0299     struct asb100_data *data = asb100_update_device(dev);
0300     return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
0301         DIV_FROM_REG(data->fan_div[nr])));
0302 }
0303 
0304 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
0305         char *buf)
0306 {
0307     int nr = to_sensor_dev_attr(attr)->index;
0308     struct asb100_data *data = asb100_update_device(dev);
0309     return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
0310 }
0311 
0312 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
0313         const char *buf, size_t count)
0314 {
0315     int nr = to_sensor_dev_attr(attr)->index;
0316     struct i2c_client *client = to_i2c_client(dev);
0317     struct asb100_data *data = i2c_get_clientdata(client);
0318     unsigned long val;
0319     int err;
0320 
0321     err = kstrtoul(buf, 10, &val);
0322     if (err)
0323         return err;
0324 
0325     mutex_lock(&data->update_lock);
0326     data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
0327     asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
0328     mutex_unlock(&data->update_lock);
0329     return count;
0330 }
0331 
0332 /*
0333  * Note: we save and restore the fan minimum here, because its value is
0334  * determined in part by the fan divisor.  This follows the principle of
0335  * least surprise; the user doesn't expect the fan minimum to change just
0336  * because the divisor changed.
0337  */
0338 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
0339         const char *buf, size_t count)
0340 {
0341     int nr = to_sensor_dev_attr(attr)->index;
0342     struct i2c_client *client = to_i2c_client(dev);
0343     struct asb100_data *data = i2c_get_clientdata(client);
0344     unsigned long min;
0345     int reg;
0346     unsigned long val;
0347     int err;
0348 
0349     err = kstrtoul(buf, 10, &val);
0350     if (err)
0351         return err;
0352 
0353     mutex_lock(&data->update_lock);
0354 
0355     min = FAN_FROM_REG(data->fan_min[nr],
0356             DIV_FROM_REG(data->fan_div[nr]));
0357     data->fan_div[nr] = DIV_TO_REG(val);
0358 
0359     switch (nr) {
0360     case 0: /* fan 1 */
0361         reg = asb100_read_value(client, ASB100_REG_VID_FANDIV);
0362         reg = (reg & 0xcf) | (data->fan_div[0] << 4);
0363         asb100_write_value(client, ASB100_REG_VID_FANDIV, reg);
0364         break;
0365 
0366     case 1: /* fan 2 */
0367         reg = asb100_read_value(client, ASB100_REG_VID_FANDIV);
0368         reg = (reg & 0x3f) | (data->fan_div[1] << 6);
0369         asb100_write_value(client, ASB100_REG_VID_FANDIV, reg);
0370         break;
0371 
0372     case 2: /* fan 3 */
0373         reg = asb100_read_value(client, ASB100_REG_PIN);
0374         reg = (reg & 0x3f) | (data->fan_div[2] << 6);
0375         asb100_write_value(client, ASB100_REG_PIN, reg);
0376         break;
0377     }
0378 
0379     data->fan_min[nr] =
0380         FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
0381     asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
0382 
0383     mutex_unlock(&data->update_lock);
0384 
0385     return count;
0386 }
0387 
0388 #define sysfs_fan(offset) \
0389 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
0390         show_fan, NULL, offset - 1); \
0391 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
0392         show_fan_min, set_fan_min, offset - 1); \
0393 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
0394         show_fan_div, set_fan_div, offset - 1)
0395 
0396 sysfs_fan(1);
0397 sysfs_fan(2);
0398 sysfs_fan(3);
0399 
0400 /* 4 Temp. Sensors */
0401 static int sprintf_temp_from_reg(u16 reg, char *buf, int nr)
0402 {
0403     int ret = 0;
0404 
0405     switch (nr) {
0406     case 1: case 2:
0407         ret = sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(reg));
0408         break;
0409     case 0: case 3: default:
0410         ret = sprintf(buf, "%d\n", TEMP_FROM_REG(reg));
0411         break;
0412     }
0413     return ret;
0414 }
0415 
0416 #define show_temp_reg(reg) \
0417 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
0418         char *buf) \
0419 { \
0420     int nr = to_sensor_dev_attr(attr)->index; \
0421     struct asb100_data *data = asb100_update_device(dev); \
0422     return sprintf_temp_from_reg(data->reg[nr], buf, nr); \
0423 }
0424 
0425 show_temp_reg(temp);
0426 show_temp_reg(temp_max);
0427 show_temp_reg(temp_hyst);
0428 
0429 #define set_temp_reg(REG, reg) \
0430 static ssize_t set_##reg(struct device *dev, struct device_attribute *attr, \
0431         const char *buf, size_t count) \
0432 { \
0433     int nr = to_sensor_dev_attr(attr)->index; \
0434     struct i2c_client *client = to_i2c_client(dev); \
0435     struct asb100_data *data = i2c_get_clientdata(client); \
0436     long val; \
0437     int err = kstrtol(buf, 10, &val); \
0438     if (err) \
0439         return err; \
0440     mutex_lock(&data->update_lock); \
0441     switch (nr) { \
0442     case 1: case 2: \
0443         data->reg[nr] = LM75_TEMP_TO_REG(val); \
0444         break; \
0445     case 0: case 3: default: \
0446         data->reg[nr] = TEMP_TO_REG(val); \
0447         break; \
0448     } \
0449     asb100_write_value(client, ASB100_REG_TEMP_##REG(nr+1), \
0450             data->reg[nr]); \
0451     mutex_unlock(&data->update_lock); \
0452     return count; \
0453 }
0454 
0455 set_temp_reg(MAX, temp_max);
0456 set_temp_reg(HYST, temp_hyst);
0457 
0458 #define sysfs_temp(num) \
0459 static SENSOR_DEVICE_ATTR(temp##num##_input, S_IRUGO, \
0460         show_temp, NULL, num - 1); \
0461 static SENSOR_DEVICE_ATTR(temp##num##_max, S_IRUGO | S_IWUSR, \
0462         show_temp_max, set_temp_max, num - 1); \
0463 static SENSOR_DEVICE_ATTR(temp##num##_max_hyst, S_IRUGO | S_IWUSR, \
0464         show_temp_hyst, set_temp_hyst, num - 1)
0465 
0466 sysfs_temp(1);
0467 sysfs_temp(2);
0468 sysfs_temp(3);
0469 sysfs_temp(4);
0470 
0471 /* VID */
0472 static ssize_t cpu0_vid_show(struct device *dev,
0473                  struct device_attribute *attr, char *buf)
0474 {
0475     struct asb100_data *data = asb100_update_device(dev);
0476     return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
0477 }
0478 
0479 static DEVICE_ATTR_RO(cpu0_vid);
0480 
0481 /* VRM */
0482 static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
0483         char *buf)
0484 {
0485     struct asb100_data *data = dev_get_drvdata(dev);
0486     return sprintf(buf, "%d\n", data->vrm);
0487 }
0488 
0489 static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
0490              const char *buf, size_t count)
0491 {
0492     struct asb100_data *data = dev_get_drvdata(dev);
0493     unsigned long val;
0494     int err;
0495 
0496     err = kstrtoul(buf, 10, &val);
0497     if (err)
0498         return err;
0499 
0500     if (val > 255)
0501         return -EINVAL;
0502 
0503     data->vrm = val;
0504     return count;
0505 }
0506 
0507 /* Alarms */
0508 static DEVICE_ATTR_RW(vrm);
0509 
0510 static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
0511         char *buf)
0512 {
0513     struct asb100_data *data = asb100_update_device(dev);
0514     return sprintf(buf, "%u\n", data->alarms);
0515 }
0516 
0517 static DEVICE_ATTR_RO(alarms);
0518 
0519 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
0520         char *buf)
0521 {
0522     int bitnr = to_sensor_dev_attr(attr)->index;
0523     struct asb100_data *data = asb100_update_device(dev);
0524     return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
0525 }
0526 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
0527 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
0528 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
0529 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
0530 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
0531 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
0532 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
0533 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
0534 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
0535 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
0536 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13);
0537 
0538 /* 1 PWM */
0539 static ssize_t pwm1_show(struct device *dev, struct device_attribute *attr,
0540         char *buf)
0541 {
0542     struct asb100_data *data = asb100_update_device(dev);
0543     return sprintf(buf, "%d\n", ASB100_PWM_FROM_REG(data->pwm & 0x0f));
0544 }
0545 
0546 static ssize_t pwm1_store(struct device *dev, struct device_attribute *attr,
0547               const char *buf, size_t count)
0548 {
0549     struct i2c_client *client = to_i2c_client(dev);
0550     struct asb100_data *data = i2c_get_clientdata(client);
0551     unsigned long val;
0552     int err;
0553 
0554     err = kstrtoul(buf, 10, &val);
0555     if (err)
0556         return err;
0557 
0558     mutex_lock(&data->update_lock);
0559     data->pwm &= 0x80; /* keep the enable bit */
0560     data->pwm |= (0x0f & ASB100_PWM_TO_REG(val));
0561     asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
0562     mutex_unlock(&data->update_lock);
0563     return count;
0564 }
0565 
0566 static ssize_t pwm1_enable_show(struct device *dev,
0567         struct device_attribute *attr, char *buf)
0568 {
0569     struct asb100_data *data = asb100_update_device(dev);
0570     return sprintf(buf, "%d\n", (data->pwm & 0x80) ? 1 : 0);
0571 }
0572 
0573 static ssize_t pwm1_enable_store(struct device *dev,
0574                  struct device_attribute *attr,
0575                  const char *buf, size_t count)
0576 {
0577     struct i2c_client *client = to_i2c_client(dev);
0578     struct asb100_data *data = i2c_get_clientdata(client);
0579     unsigned long val;
0580     int err;
0581 
0582     err = kstrtoul(buf, 10, &val);
0583     if (err)
0584         return err;
0585 
0586     mutex_lock(&data->update_lock);
0587     data->pwm &= 0x0f; /* keep the duty cycle bits */
0588     data->pwm |= (val ? 0x80 : 0x00);
0589     asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
0590     mutex_unlock(&data->update_lock);
0591     return count;
0592 }
0593 
0594 static DEVICE_ATTR_RW(pwm1);
0595 static DEVICE_ATTR_RW(pwm1_enable);
0596 
0597 static struct attribute *asb100_attributes[] = {
0598     &sensor_dev_attr_in0_input.dev_attr.attr,
0599     &sensor_dev_attr_in0_min.dev_attr.attr,
0600     &sensor_dev_attr_in0_max.dev_attr.attr,
0601     &sensor_dev_attr_in1_input.dev_attr.attr,
0602     &sensor_dev_attr_in1_min.dev_attr.attr,
0603     &sensor_dev_attr_in1_max.dev_attr.attr,
0604     &sensor_dev_attr_in2_input.dev_attr.attr,
0605     &sensor_dev_attr_in2_min.dev_attr.attr,
0606     &sensor_dev_attr_in2_max.dev_attr.attr,
0607     &sensor_dev_attr_in3_input.dev_attr.attr,
0608     &sensor_dev_attr_in3_min.dev_attr.attr,
0609     &sensor_dev_attr_in3_max.dev_attr.attr,
0610     &sensor_dev_attr_in4_input.dev_attr.attr,
0611     &sensor_dev_attr_in4_min.dev_attr.attr,
0612     &sensor_dev_attr_in4_max.dev_attr.attr,
0613     &sensor_dev_attr_in5_input.dev_attr.attr,
0614     &sensor_dev_attr_in5_min.dev_attr.attr,
0615     &sensor_dev_attr_in5_max.dev_attr.attr,
0616     &sensor_dev_attr_in6_input.dev_attr.attr,
0617     &sensor_dev_attr_in6_min.dev_attr.attr,
0618     &sensor_dev_attr_in6_max.dev_attr.attr,
0619 
0620     &sensor_dev_attr_fan1_input.dev_attr.attr,
0621     &sensor_dev_attr_fan1_min.dev_attr.attr,
0622     &sensor_dev_attr_fan1_div.dev_attr.attr,
0623     &sensor_dev_attr_fan2_input.dev_attr.attr,
0624     &sensor_dev_attr_fan2_min.dev_attr.attr,
0625     &sensor_dev_attr_fan2_div.dev_attr.attr,
0626     &sensor_dev_attr_fan3_input.dev_attr.attr,
0627     &sensor_dev_attr_fan3_min.dev_attr.attr,
0628     &sensor_dev_attr_fan3_div.dev_attr.attr,
0629 
0630     &sensor_dev_attr_temp1_input.dev_attr.attr,
0631     &sensor_dev_attr_temp1_max.dev_attr.attr,
0632     &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
0633     &sensor_dev_attr_temp2_input.dev_attr.attr,
0634     &sensor_dev_attr_temp2_max.dev_attr.attr,
0635     &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
0636     &sensor_dev_attr_temp3_input.dev_attr.attr,
0637     &sensor_dev_attr_temp3_max.dev_attr.attr,
0638     &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
0639     &sensor_dev_attr_temp4_input.dev_attr.attr,
0640     &sensor_dev_attr_temp4_max.dev_attr.attr,
0641     &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
0642 
0643     &sensor_dev_attr_in0_alarm.dev_attr.attr,
0644     &sensor_dev_attr_in1_alarm.dev_attr.attr,
0645     &sensor_dev_attr_in2_alarm.dev_attr.attr,
0646     &sensor_dev_attr_in3_alarm.dev_attr.attr,
0647     &sensor_dev_attr_in4_alarm.dev_attr.attr,
0648     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
0649     &sensor_dev_attr_fan2_alarm.dev_attr.attr,
0650     &sensor_dev_attr_fan3_alarm.dev_attr.attr,
0651     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
0652     &sensor_dev_attr_temp2_alarm.dev_attr.attr,
0653     &sensor_dev_attr_temp3_alarm.dev_attr.attr,
0654 
0655     &dev_attr_cpu0_vid.attr,
0656     &dev_attr_vrm.attr,
0657     &dev_attr_alarms.attr,
0658     &dev_attr_pwm1.attr,
0659     &dev_attr_pwm1_enable.attr,
0660 
0661     NULL
0662 };
0663 
0664 static const struct attribute_group asb100_group = {
0665     .attrs = asb100_attributes,
0666 };
0667 
0668 static int asb100_detect_subclients(struct i2c_client *client)
0669 {
0670     int i, id, err;
0671     int address = client->addr;
0672     unsigned short sc_addr[2];
0673     struct asb100_data *data = i2c_get_clientdata(client);
0674     struct i2c_adapter *adapter = client->adapter;
0675 
0676     id = i2c_adapter_id(adapter);
0677 
0678     if (force_subclients[0] == id && force_subclients[1] == address) {
0679         for (i = 2; i <= 3; i++) {
0680             if (force_subclients[i] < 0x48 ||
0681                 force_subclients[i] > 0x4f) {
0682                 dev_err(&client->dev,
0683                     "invalid subclient address %d; must be 0x48-0x4f\n",
0684                     force_subclients[i]);
0685                 err = -ENODEV;
0686                 goto ERROR_SC_2;
0687             }
0688         }
0689         asb100_write_value(client, ASB100_REG_I2C_SUBADDR,
0690                     (force_subclients[2] & 0x07) |
0691                     ((force_subclients[3] & 0x07) << 4));
0692         sc_addr[0] = force_subclients[2];
0693         sc_addr[1] = force_subclients[3];
0694     } else {
0695         int val = asb100_read_value(client, ASB100_REG_I2C_SUBADDR);
0696         sc_addr[0] = 0x48 + (val & 0x07);
0697         sc_addr[1] = 0x48 + ((val >> 4) & 0x07);
0698     }
0699 
0700     if (sc_addr[0] == sc_addr[1]) {
0701         dev_err(&client->dev,
0702             "duplicate addresses 0x%x for subclients\n",
0703             sc_addr[0]);
0704         err = -ENODEV;
0705         goto ERROR_SC_2;
0706     }
0707 
0708     data->lm75[0] = i2c_new_dummy_device(adapter, sc_addr[0]);
0709     if (IS_ERR(data->lm75[0])) {
0710         dev_err(&client->dev,
0711             "subclient %d registration at address 0x%x failed.\n",
0712             1, sc_addr[0]);
0713         err = PTR_ERR(data->lm75[0]);
0714         goto ERROR_SC_2;
0715     }
0716 
0717     data->lm75[1] = i2c_new_dummy_device(adapter, sc_addr[1]);
0718     if (IS_ERR(data->lm75[1])) {
0719         dev_err(&client->dev,
0720             "subclient %d registration at address 0x%x failed.\n",
0721             2, sc_addr[1]);
0722         err = PTR_ERR(data->lm75[1]);
0723         goto ERROR_SC_3;
0724     }
0725 
0726     return 0;
0727 
0728 /* Undo inits in case of errors */
0729 ERROR_SC_3:
0730     i2c_unregister_device(data->lm75[0]);
0731 ERROR_SC_2:
0732     return err;
0733 }
0734 
0735 /* Return 0 if detection is successful, -ENODEV otherwise */
0736 static int asb100_detect(struct i2c_client *client,
0737              struct i2c_board_info *info)
0738 {
0739     struct i2c_adapter *adapter = client->adapter;
0740     int val1, val2;
0741 
0742     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
0743         pr_debug("detect failed, smbus byte data not supported!\n");
0744         return -ENODEV;
0745     }
0746 
0747     val1 = i2c_smbus_read_byte_data(client, ASB100_REG_BANK);
0748     val2 = i2c_smbus_read_byte_data(client, ASB100_REG_CHIPMAN);
0749 
0750     /* If we're in bank 0 */
0751     if ((!(val1 & 0x07)) &&
0752             /* Check for ASB100 ID (low byte) */
0753             (((!(val1 & 0x80)) && (val2 != 0x94)) ||
0754             /* Check for ASB100 ID (high byte ) */
0755             ((val1 & 0x80) && (val2 != 0x06)))) {
0756         pr_debug("detect failed, bad chip id 0x%02x!\n", val2);
0757         return -ENODEV;
0758     }
0759 
0760     /* Put it now into bank 0 and Vendor ID High Byte */
0761     i2c_smbus_write_byte_data(client, ASB100_REG_BANK,
0762         (i2c_smbus_read_byte_data(client, ASB100_REG_BANK) & 0x78)
0763         | 0x80);
0764 
0765     /* Determine the chip type. */
0766     val1 = i2c_smbus_read_byte_data(client, ASB100_REG_WCHIPID);
0767     val2 = i2c_smbus_read_byte_data(client, ASB100_REG_CHIPMAN);
0768 
0769     if (val1 != 0x31 || val2 != 0x06)
0770         return -ENODEV;
0771 
0772     strlcpy(info->type, "asb100", I2C_NAME_SIZE);
0773 
0774     return 0;
0775 }
0776 
0777 static int asb100_probe(struct i2c_client *client)
0778 {
0779     int err;
0780     struct asb100_data *data;
0781 
0782     data = devm_kzalloc(&client->dev, sizeof(struct asb100_data),
0783                 GFP_KERNEL);
0784     if (!data)
0785         return -ENOMEM;
0786 
0787     i2c_set_clientdata(client, data);
0788     mutex_init(&data->lock);
0789     mutex_init(&data->update_lock);
0790 
0791     /* Attach secondary lm75 clients */
0792     err = asb100_detect_subclients(client);
0793     if (err)
0794         return err;
0795 
0796     /* Initialize the chip */
0797     asb100_init_client(client);
0798 
0799     /* A few vars need to be filled upon startup */
0800     data->fan_min[0] = asb100_read_value(client, ASB100_REG_FAN_MIN(0));
0801     data->fan_min[1] = asb100_read_value(client, ASB100_REG_FAN_MIN(1));
0802     data->fan_min[2] = asb100_read_value(client, ASB100_REG_FAN_MIN(2));
0803 
0804     /* Register sysfs hooks */
0805     err = sysfs_create_group(&client->dev.kobj, &asb100_group);
0806     if (err)
0807         goto ERROR3;
0808 
0809     data->hwmon_dev = hwmon_device_register(&client->dev);
0810     if (IS_ERR(data->hwmon_dev)) {
0811         err = PTR_ERR(data->hwmon_dev);
0812         goto ERROR4;
0813     }
0814 
0815     return 0;
0816 
0817 ERROR4:
0818     sysfs_remove_group(&client->dev.kobj, &asb100_group);
0819 ERROR3:
0820     i2c_unregister_device(data->lm75[1]);
0821     i2c_unregister_device(data->lm75[0]);
0822     return err;
0823 }
0824 
0825 static int asb100_remove(struct i2c_client *client)
0826 {
0827     struct asb100_data *data = i2c_get_clientdata(client);
0828 
0829     hwmon_device_unregister(data->hwmon_dev);
0830     sysfs_remove_group(&client->dev.kobj, &asb100_group);
0831 
0832     i2c_unregister_device(data->lm75[1]);
0833     i2c_unregister_device(data->lm75[0]);
0834 
0835     return 0;
0836 }
0837 
0838 /*
0839  * The SMBus locks itself, usually, but nothing may access the chip between
0840  * bank switches.
0841  */
0842 static int asb100_read_value(struct i2c_client *client, u16 reg)
0843 {
0844     struct asb100_data *data = i2c_get_clientdata(client);
0845     struct i2c_client *cl;
0846     int res, bank;
0847 
0848     mutex_lock(&data->lock);
0849 
0850     bank = (reg >> 8) & 0x0f;
0851     if (bank > 2)
0852         /* switch banks */
0853         i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
0854 
0855     if (bank == 0 || bank > 2) {
0856         res = i2c_smbus_read_byte_data(client, reg & 0xff);
0857     } else {
0858         /* switch to subclient */
0859         cl = data->lm75[bank - 1];
0860 
0861         /* convert from ISA to LM75 I2C addresses */
0862         switch (reg & 0xff) {
0863         case 0x50: /* TEMP */
0864             res = i2c_smbus_read_word_swapped(cl, 0);
0865             break;
0866         case 0x52: /* CONFIG */
0867             res = i2c_smbus_read_byte_data(cl, 1);
0868             break;
0869         case 0x53: /* HYST */
0870             res = i2c_smbus_read_word_swapped(cl, 2);
0871             break;
0872         case 0x55: /* MAX */
0873         default:
0874             res = i2c_smbus_read_word_swapped(cl, 3);
0875             break;
0876         }
0877     }
0878 
0879     if (bank > 2)
0880         i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
0881 
0882     mutex_unlock(&data->lock);
0883 
0884     return res;
0885 }
0886 
0887 static void asb100_write_value(struct i2c_client *client, u16 reg, u16 value)
0888 {
0889     struct asb100_data *data = i2c_get_clientdata(client);
0890     struct i2c_client *cl;
0891     int bank;
0892 
0893     mutex_lock(&data->lock);
0894 
0895     bank = (reg >> 8) & 0x0f;
0896     if (bank > 2)
0897         /* switch banks */
0898         i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
0899 
0900     if (bank == 0 || bank > 2) {
0901         i2c_smbus_write_byte_data(client, reg & 0xff, value & 0xff);
0902     } else {
0903         /* switch to subclient */
0904         cl = data->lm75[bank - 1];
0905 
0906         /* convert from ISA to LM75 I2C addresses */
0907         switch (reg & 0xff) {
0908         case 0x52: /* CONFIG */
0909             i2c_smbus_write_byte_data(cl, 1, value & 0xff);
0910             break;
0911         case 0x53: /* HYST */
0912             i2c_smbus_write_word_swapped(cl, 2, value);
0913             break;
0914         case 0x55: /* MAX */
0915             i2c_smbus_write_word_swapped(cl, 3, value);
0916             break;
0917         }
0918     }
0919 
0920     if (bank > 2)
0921         i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
0922 
0923     mutex_unlock(&data->lock);
0924 }
0925 
0926 static void asb100_init_client(struct i2c_client *client)
0927 {
0928     struct asb100_data *data = i2c_get_clientdata(client);
0929 
0930     data->vrm = vid_which_vrm();
0931 
0932     /* Start monitoring */
0933     asb100_write_value(client, ASB100_REG_CONFIG,
0934         (asb100_read_value(client, ASB100_REG_CONFIG) & 0xf7) | 0x01);
0935 }
0936 
0937 static struct asb100_data *asb100_update_device(struct device *dev)
0938 {
0939     struct i2c_client *client = to_i2c_client(dev);
0940     struct asb100_data *data = i2c_get_clientdata(client);
0941     int i;
0942 
0943     mutex_lock(&data->update_lock);
0944 
0945     if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
0946         || !data->valid) {
0947 
0948         dev_dbg(&client->dev, "starting device update...\n");
0949 
0950         /* 7 voltage inputs */
0951         for (i = 0; i < 7; i++) {
0952             data->in[i] = asb100_read_value(client,
0953                 ASB100_REG_IN(i));
0954             data->in_min[i] = asb100_read_value(client,
0955                 ASB100_REG_IN_MIN(i));
0956             data->in_max[i] = asb100_read_value(client,
0957                 ASB100_REG_IN_MAX(i));
0958         }
0959 
0960         /* 3 fan inputs */
0961         for (i = 0; i < 3; i++) {
0962             data->fan[i] = asb100_read_value(client,
0963                     ASB100_REG_FAN(i));
0964             data->fan_min[i] = asb100_read_value(client,
0965                     ASB100_REG_FAN_MIN(i));
0966         }
0967 
0968         /* 4 temperature inputs */
0969         for (i = 1; i <= 4; i++) {
0970             data->temp[i-1] = asb100_read_value(client,
0971                     ASB100_REG_TEMP(i));
0972             data->temp_max[i-1] = asb100_read_value(client,
0973                     ASB100_REG_TEMP_MAX(i));
0974             data->temp_hyst[i-1] = asb100_read_value(client,
0975                     ASB100_REG_TEMP_HYST(i));
0976         }
0977 
0978         /* VID and fan divisors */
0979         i = asb100_read_value(client, ASB100_REG_VID_FANDIV);
0980         data->vid = i & 0x0f;
0981         data->vid |= (asb100_read_value(client,
0982                 ASB100_REG_CHIPID) & 0x01) << 4;
0983         data->fan_div[0] = (i >> 4) & 0x03;
0984         data->fan_div[1] = (i >> 6) & 0x03;
0985         data->fan_div[2] = (asb100_read_value(client,
0986                 ASB100_REG_PIN) >> 6) & 0x03;
0987 
0988         /* PWM */
0989         data->pwm = asb100_read_value(client, ASB100_REG_PWM1);
0990 
0991         /* alarms */
0992         data->alarms = asb100_read_value(client, ASB100_REG_ALARM1) +
0993             (asb100_read_value(client, ASB100_REG_ALARM2) << 8);
0994 
0995         data->last_updated = jiffies;
0996         data->valid = true;
0997 
0998         dev_dbg(&client->dev, "... device update complete\n");
0999     }
1000 
1001     mutex_unlock(&data->update_lock);
1002 
1003     return data;
1004 }
1005 
1006 module_i2c_driver(asb100_driver);
1007 
1008 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
1009 MODULE_DESCRIPTION("ASB100 Bach driver");
1010 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!