Source of gl520sm.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 DEVICE_ATTR_RO(cpu0_vid);
​
#define VDD_FROM_REG(val)   DIV_ROUND_CLOSEST((val) * 95, 4)
#define VDD_CLAMP(val)      clamp_val(val, 0, 255 * 95 / 4)
#define VDD_TO_REG(val)     DIV_ROUND_CLOSEST(VDD_CLAMP(val) * 4, 95)
​
#define IN_FROM_REG(val)    ((val) * 19)
#define IN_CLAMP(val)       clamp_val(val, 0, 255 * 19)
#define IN_TO_REG(val)      DIV_ROUND_CLOSEST(IN_CLAMP(val), 19)
​
static ssize_t get_in_input(struct device *dev, struct device_attribute *attr,
                char *buf)
static ssize_t in_input_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
    u8 r = data->in_input[n];
​
    if (n == 0)
        return sprintf(buf, "%d\n", VDD_FROM_REG(r));
    else
        return sprintf(buf, "%d\n", IN_FROM_REG(r));
}
​
static ssize_t get_in_min(struct device *dev, struct device_attribute *attr,
              char *buf)
static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
               char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
    u8 r = data->in_min[n];
​
    if (n == 0)
        return sprintf(buf, "%d\n", VDD_FROM_REG(r));
    else
        return sprintf(buf, "%d\n", IN_FROM_REG(r));
}
​
static ssize_t get_in_max(struct device *dev, struct device_attribute *attr,
              char *buf)
static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
               char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
    u8 r = data->in_max[n];
​
    if (n == 0)
        return sprintf(buf, "%d\n", VDD_FROM_REG(r));
    else
        return sprintf(buf, "%d\n", IN_FROM_REG(r));
}
​
static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
    struct gl520_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int n = to_sensor_dev_attr(attr)->index;
    u8 r;
    long v;
    int err;
​
    err = kstrtol(buf, 10, &v);
    if (err)
Show more
        gl520_write_value(client, GL520_REG_IN_MIN[n],
                  (gl520_read_value(client, GL520_REG_IN_MIN[n])
                   & ~0xff) | r);
    else
        gl520_write_value(client, GL520_REG_IN_MIN[n], r);
​
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
    struct gl520_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int n = to_sensor_dev_attr(attr)->index;
    u8 r;
    long v;
    int err;
​
    err = kstrtol(buf, 10, &v);
    if (err)
Show more
        gl520_write_value(client, GL520_REG_IN_MAX[n],
                  (gl520_read_value(client, GL520_REG_IN_MAX[n])
                   & ~0xff00) | (r << 8));
    else
        gl520_write_value(client, GL520_REG_IN_MAX[n], r);
​
    mutex_unlock(&data->update_lock);
    return count;
}
​
static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, get_in_input, NULL, 0);
static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, get_in_input, NULL, 1);
static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, get_in_input, NULL, 2);
static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, get_in_input, NULL, 3);
static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, get_in_input, NULL, 4);
static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
        get_in_min, set_in_min, 0);
static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR,
        get_in_min, set_in_min, 1);
static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR,
        get_in_min, set_in_min, 2);
static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR,
        get_in_min, set_in_min, 3);
static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR,
        get_in_min, set_in_min, 4);
static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
        get_in_max, set_in_max, 0);
static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR,
        get_in_max, set_in_max, 1);
static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR,
        get_in_max, set_in_max, 2);
static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR,
        get_in_max, set_in_max, 3);
static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S_IWUSR,
        get_in_max, set_in_max, 4);
static SENSOR_DEVICE_ATTR_RO(in0_input, in_input, 0);
static SENSOR_DEVICE_ATTR_RO(in1_input, in_input, 1);
static SENSOR_DEVICE_ATTR_RO(in2_input, in_input, 2);
static SENSOR_DEVICE_ATTR_RO(in3_input, in_input, 3);
static SENSOR_DEVICE_ATTR_RO(in4_input, in_input, 4);
static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
​
#define DIV_FROM_REG(val) (1 << (val))
#define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : (480000 / ((val) << (div))))
​
#define FAN_BASE(div)       (480000 >> (div))
#define FAN_CLAMP(val, div) clamp_val(val, FAN_BASE(div) / 255, \
                      FAN_BASE(div))
#define FAN_TO_REG(val, div)    ((val) == 0 ? 0 : \
                 DIV_ROUND_CLOSEST(480000, \
                        FAN_CLAMP(val, div) << (div)))
​
static ssize_t get_fan_input(struct device *dev, struct device_attribute *attr,
                 char *buf)
static ssize_t fan_input_show(struct device *dev,
                  struct device_attribute *attr, char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
​
    return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_input[n],
                         data->fan_div[n]));
}
​
static ssize_t get_fan_min(struct device *dev, struct device_attribute *attr,
               char *buf)
static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
                char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
​
    return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[n],
                         data->fan_div[n]));
}
​
static ssize_t get_fan_div(struct device *dev, struct device_attribute *attr,
               char *buf)
static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
                char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
​
    return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[n]));
}
​
static ssize_t fan1_off_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
{
    struct gl520_data *data = gl520_update_device(dev);
    return sprintf(buf, "%d\n", data->fan_off);
}
​
static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
               const char *buf, size_t count)
static ssize_t fan_min_store(struct device *dev,
                 struct device_attribute *attr, const char *buf,
                 size_t count)
{
    struct gl520_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int n = to_sensor_dev_attr(attr)->index;
    u8 r;
    unsigned long v;
    int err;
​
    err = kstrtoul(buf, 10, &v);
    if (err)
Show more
        data->alarm_mask &= (n == 0) ? ~0x20 : ~0x40;
    else
        data->alarm_mask |= (n == 0) ? 0x20 : 0x40;
    data->beep_mask &= data->alarm_mask;
    gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
​
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
               const char *buf, size_t count)
static ssize_t fan_div_store(struct device *dev,
                 struct device_attribute *attr, const char *buf,
                 size_t count)
{
    struct gl520_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int n = to_sensor_dev_attr(attr)->index;
    u8 r;
    unsigned long v;
    int err;
​
    err = kstrtoul(buf, 10, &v);
    if (err)
Show more
​
    mutex_lock(&data->update_lock);
    data->fan_off = r;
    gl520_write_value(client, GL520_REG_FAN_OFF,
              (gl520_read_value(client, GL520_REG_FAN_OFF)
               & ~0x0c) | (r << 2));
    mutex_unlock(&data->update_lock);
    return count;
}
​
static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan_input, NULL, 0);
static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan_input, NULL, 1);
static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
        get_fan_min, set_fan_min, 0);
static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
        get_fan_min, set_fan_min, 1);
static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
        get_fan_div, set_fan_div, 0);
static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
        get_fan_div, set_fan_div, 1);
static SENSOR_DEVICE_ATTR_RO(fan1_input, fan_input, 0);
static SENSOR_DEVICE_ATTR_RO(fan2_input, fan_input, 1);
static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
static DEVICE_ATTR_RW(fan1_off);
​
#define TEMP_FROM_REG(val)  (((val) - 130) * 1000)
#define TEMP_CLAMP(val)     clamp_val(val, -130000, 125000)
#define TEMP_TO_REG(val)    (DIV_ROUND_CLOSEST(TEMP_CLAMP(val), 1000) + 130)
​
static ssize_t get_temp_input(struct device *dev, struct device_attribute *attr,
                  char *buf)
static ssize_t temp_input_show(struct device *dev,
                   struct device_attribute *attr, char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
​
    return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_input[n]));
}
​
static ssize_t get_temp_max(struct device *dev, struct device_attribute *attr,
                char *buf)
static ssize_t temp_max_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
​
    return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[n]));
}
​
static ssize_t get_temp_max_hyst(struct device *dev,
                 struct device_attribute *attr, char *buf)
static ssize_t temp_max_hyst_show(struct device *dev,
                  struct device_attribute *attr, char *buf)
{
    int n = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
​
    return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[n]));
}
​
static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
static ssize_t temp_max_store(struct device *dev,
                  struct device_attribute *attr, const char *buf,
                  size_t count)
{
    struct gl520_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int n = to_sensor_dev_attr(attr)->index;
    long v;
    int err;
​
    err = kstrtol(buf, 10, &v);
    if (err)
        return err;
​
    mutex_lock(&data->update_lock);
    data->temp_max[n] = TEMP_TO_REG(v);
    gl520_write_value(client, GL520_REG_TEMP_MAX[n], data->temp_max[n]);
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute
                 *attr, const char *buf, size_t count)
static ssize_t temp_max_hyst_store(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf, size_t count)
{
    struct gl520_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int n = to_sensor_dev_attr(attr)->index;
    long v;
    int err;
​
    err = kstrtol(buf, 10, &v);
    if (err)
        return err;
​
    mutex_lock(&data->update_lock);
    data->temp_max_hyst[n] = TEMP_TO_REG(v);
    gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n],
              data->temp_max_hyst[n]);
    mutex_unlock(&data->update_lock);
    return count;
}
​
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, get_temp_input, NULL, 0);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, get_temp_input, NULL, 1);
static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
        get_temp_max, set_temp_max, 0);
static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
        get_temp_max, set_temp_max, 1);
static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
        get_temp_max_hyst, set_temp_max_hyst, 0);
static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
        get_temp_max_hyst, set_temp_max_hyst, 1);
static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
static SENSOR_DEVICE_ATTR_RO(temp2_input, temp_input, 1);
static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, temp_max_hyst, 0);
static SENSOR_DEVICE_ATTR_RW(temp2_max_hyst, temp_max_hyst, 1);
​
static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
               char *buf)
{
    struct gl520_data *data = gl520_update_device(dev);
    return sprintf(buf, "%d\n", data->alarms);
}
​
static ssize_t beep_enable_show(struct device *dev,
                struct device_attribute *attr, char *buf)
Show more
    data->beep_mask = r;
    gl520_write_value(client, GL520_REG_BEEP_MASK, r);
    mutex_unlock(&data->update_lock);
    return count;
}
​
static DEVICE_ATTR_RO(alarms);
static DEVICE_ATTR_RW(beep_enable);
static DEVICE_ATTR_RW(beep_mask);
​
static ssize_t get_alarm(struct device *dev, struct device_attribute *attr,
             char *buf)
static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
              char *buf)
{
    int bit_nr = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
​
    return sprintf(buf, "%d\n", (data->alarms >> bit_nr) & 1);
}
​
static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, get_alarm, NULL, 0);
static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, get_alarm, NULL, 1);
static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, get_alarm, NULL, 2);
static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, get_alarm, NULL, 3);
static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, get_alarm, NULL, 4);
static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, get_alarm, NULL, 5);
static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, get_alarm, NULL, 6);
static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, get_alarm, NULL, 7);
static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, get_alarm, NULL, 7);
static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0);
static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 1);
static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 2);
static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 3);
static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 4);
static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 5);
static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 6);
static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 7);
static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 7);
​
static ssize_t get_beep(struct device *dev, struct device_attribute *attr,
            char *buf)
static ssize_t beep_show(struct device *dev, struct device_attribute *attr,
             char *buf)
{
    int bitnr = to_sensor_dev_attr(attr)->index;
    struct gl520_data *data = gl520_update_device(dev);
​
    return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
}
​
static ssize_t set_beep(struct device *dev, struct device_attribute *attr,
            const char *buf, size_t count)
static ssize_t beep_store(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
{
    struct gl520_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int bitnr = to_sensor_dev_attr(attr)->index;
    unsigned long bit;
​
    int err;
​
    err = kstrtoul(buf, 10, &bit);
    if (err)
Show more
    data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
    if (bit)
        data->beep_mask |= (1 << bitnr);
    else
        data->beep_mask &= ~(1 << bitnr);
    gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
    mutex_unlock(&data->update_lock);
    return count;
}
​
static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 0);
static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 1);
static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 2);
static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 3);
static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 4);
static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 5);
static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 6);
static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
static SENSOR_DEVICE_ATTR_RW(in0_beep, beep, 0);
static SENSOR_DEVICE_ATTR_RW(in1_beep, beep, 1);
static SENSOR_DEVICE_ATTR_RW(in2_beep, beep, 2);
static SENSOR_DEVICE_ATTR_RW(in3_beep, beep, 3);
static SENSOR_DEVICE_ATTR_RW(temp1_beep, beep, 4);
static SENSOR_DEVICE_ATTR_RW(fan1_beep, beep, 5);
static SENSOR_DEVICE_ATTR_RW(fan2_beep, beep, 6);
static SENSOR_DEVICE_ATTR_RW(temp2_beep, beep, 7);
static SENSOR_DEVICE_ATTR_RW(in4_beep, beep, 7);
​
static struct attribute *gl520_attributes[] = {
    &dev_attr_cpu0_vid.attr,
​
    &sensor_dev_attr_in0_input.dev_attr.attr,
    &sensor_dev_attr_in0_min.dev_attr.attr,
    &sensor_dev_attr_in0_max.dev_attr.attr,
    &sensor_dev_attr_in0_alarm.dev_attr.attr,
    &sensor_dev_attr_in0_beep.dev_attr.attr,
    &sensor_dev_attr_in1_input.dev_attr.attr,