Source of amc6821.c - linux-imx - PHYTEC BitBucket (Stash)

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
 */
​
static const unsigned short normal_i2c[] = {0x18, 0x19, 0x1a, 0x2c, 0x2d, 0x2e,
    0x4c, 0x4d, 0x4e, I2C_CLIENT_END};
​
/*
 * Insmod parameters
 */
​
static int pwminv;  /*Inverted PWM output. */
module_param(pwminv, int, S_IRUGO);
module_param(pwminv, int, 0444);
​
static int init = 1; /*Power-on initialization.*/
module_param(init, int, S_IRUGO);
module_param(init, int, 0444);
​
enum chips { amc6821 };
​
#define AMC6821_REG_DEV_ID 0x3D
#define AMC6821_REG_COMP_ID 0x3E
#define AMC6821_REG_CONF1 0x00
#define AMC6821_REG_CONF2 0x01
#define AMC6821_REG_CONF3 0x3F
#define AMC6821_REG_CONF4 0x04
#define AMC6821_REG_STAT1 0x02
Show more
            break;
        }
​
        data->last_updated = jiffies;
        data->valid = 1;
    }
    mutex_unlock(&data->update_lock);
    return data;
}
​
static ssize_t get_temp(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
             char *buf)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    int ix = to_sensor_dev_attr(devattr)->index;
​
    return sprintf(buf, "%d\n", data->temp[ix] * 1000);
}
​
static ssize_t set_temp(
        struct device *dev,
        struct device_attribute *attr,
        const char *buf,
        size_t count)
static ssize_t temp_store(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
{
    struct amc6821_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int ix = to_sensor_dev_attr(attr)->index;
    long val;
​
    int ret = kstrtol(buf, 10, &val);
    if (ret)
        return ret;
    val = clamp_val(val / 1000, -128, 127);
Show more
    mutex_lock(&data->update_lock);
    data->temp[ix] = val;
    if (i2c_smbus_write_byte_data(client, temp_reg[ix], data->temp[ix])) {
        dev_err(&client->dev, "Register write error, aborting.\n");
        count = -EIO;
    }
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t get_temp_alarm(
    struct device *dev,
    struct device_attribute *devattr,
    char *buf)
static ssize_t temp_alarm_show(struct device *dev,
                   struct device_attribute *devattr, char *buf)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    int ix = to_sensor_dev_attr(devattr)->index;
    u8 flag;
​
    switch (ix) {
    case IDX_TEMP1_MIN:
        flag = data->stat1 & AMC6821_STAT1_LTL;
        break;
    case IDX_TEMP1_MAX:
Show more
    default:
        dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
        return -EINVAL;
    }
    if (flag)
        return sprintf(buf, "1");
    else
        return sprintf(buf, "0");
}
​
static ssize_t get_temp2_fault(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t temp2_fault_show(struct device *dev,
                struct device_attribute *devattr, char *buf)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    if (data->stat1 & AMC6821_STAT1_RTF)
        return sprintf(buf, "1");
    else
        return sprintf(buf, "0");
}
​
static ssize_t get_pwm1(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t pwm1_show(struct device *dev, struct device_attribute *devattr,
             char *buf)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    return sprintf(buf, "%d\n", data->pwm1);
}
​
static ssize_t set_pwm1(
        struct device *dev,
        struct device_attribute *devattr,
        const char *buf,
        size_t count)
static ssize_t pwm1_store(struct device *dev,
              struct device_attribute *devattr, const char *buf,
              size_t count)
{
    struct amc6821_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    long val;
    int ret = kstrtol(buf, 10, &val);
    if (ret)
        return ret;
​
    mutex_lock(&data->update_lock);
    data->pwm1 = clamp_val(val , 0, 255);
    i2c_smbus_write_byte_data(client, AMC6821_REG_DCY, data->pwm1);
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t get_pwm1_enable(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t pwm1_enable_show(struct device *dev,
                struct device_attribute *devattr, char *buf)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    return sprintf(buf, "%d\n", data->pwm1_enable);
}
​
static ssize_t set_pwm1_enable(
        struct device *dev,
        struct device_attribute *attr,
        const char *buf,
        size_t count)
static ssize_t pwm1_enable_store(struct device *dev,
                 struct device_attribute *attr,
                 const char *buf, size_t count)
{
    struct amc6821_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    long val;
    int config = kstrtol(buf, 10, &val);
    if (config)
        return config;
​
    mutex_lock(&data->update_lock);
    config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
Show more
    if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF1, config)) {
            dev_err(&client->dev,
            "Configuration register write error, aborting.\n");
            count = -EIO;
    }
unlock:
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t get_pwm1_auto_channels_temp(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t pwm1_auto_channels_temp_show(struct device *dev,
                        struct device_attribute *devattr,
                        char *buf)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    return sprintf(buf, "%d\n", data->pwm1_auto_channels_temp);
}
​
static ssize_t get_temp_auto_point_temp(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t temp_auto_point_temp_show(struct device *dev,
                     struct device_attribute *devattr,
                     char *buf)
{
    int ix = to_sensor_dev_attr_2(devattr)->index;
    int nr = to_sensor_dev_attr_2(devattr)->nr;
    struct amc6821_data *data = amc6821_update_device(dev);
    switch (nr) {
    case 1:
        return sprintf(buf, "%d\n",
            data->temp1_auto_point_temp[ix] * 1000);
    case 2:
        return sprintf(buf, "%d\n",
            data->temp2_auto_point_temp[ix] * 1000);
    default:
        dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
        return -EINVAL;
    }
}
​
static ssize_t get_pwm1_auto_point_pwm(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t pwm1_auto_point_pwm_show(struct device *dev,
                    struct device_attribute *devattr,
                    char *buf)
{
    int ix = to_sensor_dev_attr(devattr)->index;
    struct amc6821_data *data = amc6821_update_device(dev);
    return sprintf(buf, "%d\n", data->pwm1_auto_point_pwm[ix]);
}
​
static inline ssize_t set_slope_register(struct i2c_client *client,
        u8 reg,
        u8 dpwm,
        u8 *ptemp)
Show more
    }
    tmp |= (ptemp[1] & 0x7C) << 1;
    if (i2c_smbus_write_byte_data(client,
            reg, tmp)) {
        dev_err(&client->dev, "Register write error, aborting.\n");
        return -EIO;
    }
    return 0;
}
​
static ssize_t set_temp_auto_point_temp(
        struct device *dev,
        struct device_attribute *attr,
        const char *buf,
        size_t count)
static ssize_t temp_auto_point_temp_store(struct device *dev,
                      struct device_attribute *attr,
                      const char *buf, size_t count)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    struct i2c_client *client = data->client;
    int ix = to_sensor_dev_attr_2(attr)->index;
    int nr = to_sensor_dev_attr_2(attr)->nr;
    u8 *ptemp;
    u8 reg;
    int dpwm;
    long val;
    int ret = kstrtol(buf, 10, &val);
Show more
    }
    dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
    if (set_slope_register(client, reg, dpwm, ptemp))
        count = -EIO;
​
EXIT:
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t set_pwm1_auto_point_pwm(
        struct device *dev,
        struct device_attribute *attr,
        const char *buf,
        size_t count)
static ssize_t pwm1_auto_point_pwm_store(struct device *dev,
                     struct device_attribute *attr,
                     const char *buf, size_t count)
{
    struct amc6821_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int dpwm;
    long val;
    int ret = kstrtol(buf, 10, &val);
    if (ret)
        return ret;
​
    mutex_lock(&data->update_lock);
Show more
        count = -EIO;
        goto EXIT;
    }
​
EXIT:
    data->valid = 0;
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t get_fan(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
            char *buf)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    int ix = to_sensor_dev_attr(devattr)->index;
    if (0 == data->fan[ix])
        return sprintf(buf, "0");
    return sprintf(buf, "%d\n", (int)(6000000 / data->fan[ix]));
}
​
static ssize_t get_fan1_fault(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t fan1_fault_show(struct device *dev,
                   struct device_attribute *devattr, char *buf)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    if (data->stat1 & AMC6821_STAT1_FANS)
        return sprintf(buf, "1");
    else
        return sprintf(buf, "0");
}
​
static ssize_t set_fan(
        struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
static ssize_t fan_store(struct device *dev, struct device_attribute *attr,
             const char *buf, size_t count)
{
    struct amc6821_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    long val;
    int ix = to_sensor_dev_attr(attr)->index;
    int ret = kstrtol(buf, 10, &val);
    if (ret)
        return ret;
    val = 1 > val ? 0xFFFF : 6000000/val;
​
Show more
    if (i2c_smbus_write_byte_data(client,
            fan_reg_hi[ix], data->fan[ix] >> 8)) {
        dev_err(&client->dev, "Register write error, aborting.\n");
        count = -EIO;
    }
EXIT:
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t get_fan1_div(
        struct device *dev,
        struct device_attribute *devattr,
        char *buf)
static ssize_t fan1_div_show(struct device *dev,
                 struct device_attribute *devattr, char *buf)
{
    struct amc6821_data *data = amc6821_update_device(dev);
    return sprintf(buf, "%d\n", data->fan1_div);
}
​
static ssize_t set_fan1_div(
        struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
static ssize_t fan1_div_store(struct device *dev,
                  struct device_attribute *attr, const char *buf,
                  size_t count)
{
    struct amc6821_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    long val;
    int config = kstrtol(buf, 10, &val);
    if (config)
        return config;
​
    mutex_lock(&data->update_lock);
    config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
Show more
    if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4, config)) {
        dev_err(&client->dev,
            "Configuration register write error, aborting.\n");
        count = -EIO;
    }
EXIT:
    mutex_unlock(&data->update_lock);
    return count;
}
​
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
    get_temp, NULL, IDX_TEMP1_INPUT);
static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, get_temp,
    set_temp, IDX_TEMP1_MIN);
static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, get_temp,
    set_temp, IDX_TEMP1_MAX);
static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, get_temp,
    set_temp, IDX_TEMP1_CRIT);
static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO,
    get_temp_alarm, NULL, IDX_TEMP1_MIN);
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
    get_temp_alarm, NULL, IDX_TEMP1_MAX);
static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO,
    get_temp_alarm, NULL, IDX_TEMP1_CRIT);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO,
    get_temp, NULL, IDX_TEMP2_INPUT);
static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, get_temp,
    set_temp, IDX_TEMP2_MIN);
static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, get_temp,
    set_temp, IDX_TEMP2_MAX);
static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR, get_temp,
    set_temp, IDX_TEMP2_CRIT);
static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO,
    get_temp2_fault, NULL, 0);
static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO,
    get_temp_alarm, NULL, IDX_TEMP2_MIN);
static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO,
    get_temp_alarm, NULL, IDX_TEMP2_MAX);
static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO,
    get_temp_alarm, NULL, IDX_TEMP2_CRIT);
static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, IDX_FAN1_INPUT);
static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
    get_fan, set_fan, IDX_FAN1_MIN);
static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO | S_IWUSR,
    get_fan, set_fan, IDX_FAN1_MAX);
static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_fan1_fault, NULL, 0);
static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
    get_fan1_div, set_fan1_div, 0);
​
static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm1, set_pwm1, 0);
static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
    get_pwm1_enable, set_pwm1_enable, 0);
static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IRUGO,
    get_pwm1_auto_point_pwm, NULL, 0);
static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
    get_pwm1_auto_point_pwm, set_pwm1_auto_point_pwm, 1);
static SENSOR_DEVICE_ATTR(pwm1_auto_point3_pwm, S_IRUGO,
    get_pwm1_auto_point_pwm, NULL, 2);
static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IRUGO,
    get_pwm1_auto_channels_temp, NULL, 0);
static SENSOR_DEVICE_ATTR_2(temp1_auto_point1_temp, S_IRUGO,
    get_temp_auto_point_temp, NULL, 1, 0);
static SENSOR_DEVICE_ATTR_2(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
    get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 1);
static SENSOR_DEVICE_ATTR_2(temp1_auto_point3_temp, S_IWUSR | S_IRUGO,
    get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 2);
​
static SENSOR_DEVICE_ATTR_2(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
    get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 0);
static SENSOR_DEVICE_ATTR_2(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
    get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 1);
static SENSOR_DEVICE_ATTR_2(temp2_auto_point3_temp, S_IWUSR | S_IRUGO,
    get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 2);
static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, IDX_TEMP1_INPUT);
static SENSOR_DEVICE_ATTR_RW(temp1_min, temp, IDX_TEMP1_MIN);
static SENSOR_DEVICE_ATTR_RW(temp1_max, temp, IDX_TEMP1_MAX);
static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp, IDX_TEMP1_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, temp_alarm, IDX_TEMP1_MIN);
static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, temp_alarm, IDX_TEMP1_MAX);
static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, temp_alarm, IDX_TEMP1_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, IDX_TEMP2_INPUT);
static SENSOR_DEVICE_ATTR_RW(temp2_min, temp, IDX_TEMP2_MIN);
static SENSOR_DEVICE_ATTR_RW(temp2_max, temp, IDX_TEMP2_MAX);
static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp, IDX_TEMP2_CRIT);
static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp2_fault, 0);
static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, temp_alarm, IDX_TEMP2_MIN);
static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, temp_alarm, IDX_TEMP2_MAX);
static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, temp_alarm, IDX_TEMP2_CRIT);
static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, IDX_FAN1_INPUT);
static SENSOR_DEVICE_ATTR_RW(fan1_min, fan, IDX_FAN1_MIN);
static SENSOR_DEVICE_ATTR_RW(fan1_max, fan, IDX_FAN1_MAX);
static SENSOR_DEVICE_ATTR_RO(fan1_fault, fan1_fault, 0);
static SENSOR_DEVICE_ATTR_RW(fan1_div, fan1_div, 0);
​
static SENSOR_DEVICE_ATTR_RW(pwm1, pwm1, 0);
static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm1_enable, 0);
static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point1_pwm, pwm1_auto_point_pwm, 0);
static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm1_auto_point_pwm, 1);
static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point3_pwm, pwm1_auto_point_pwm, 2);
static SENSOR_DEVICE_ATTR_RO(pwm1_auto_channels_temp, pwm1_auto_channels_temp,
                 0);
static SENSOR_DEVICE_ATTR_2_RO(temp1_auto_point1_temp, temp_auto_point_temp,
                   1, 0);
static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point2_temp, temp_auto_point_temp,
                   1, 1);
static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point3_temp, temp_auto_point_temp,
                   1, 2);
​
static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point1_temp, temp_auto_point_temp,
                   2, 0);
static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point2_temp, temp_auto_point_temp,
                   2, 1);
static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point3_temp, temp_auto_point_temp,
                   2, 2);
​
static struct attribute *amc6821_attrs[] = {
    &sensor_dev_attr_temp1_input.dev_attr.attr,
    &sensor_dev_attr_temp1_min.dev_attr.attr,
    &sensor_dev_attr_temp1_max.dev_attr.attr,
    &sensor_dev_attr_temp1_crit.dev_attr.attr,
    &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
    &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
    &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
    &sensor_dev_attr_temp2_input.dev_attr.attr,