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

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
}
​
#define temp_crit_reg(offset)                       \
static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO | S_IWUSR,   \
        show_temp_crit, set_temp_crit, offset - 1);
​
temp_crit_reg(1);
temp_crit_reg(2);
temp_crit_reg(3);
​
static ssize_t show_analog_out_reg(struct device *dev,
                   struct device_attribute *attr, char *buf)
static ssize_t analog_out_show(struct device *dev,
                   struct device_attribute *attr, char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    return sprintf(buf, "%d\n", DAC_FROM_REG(data->analog_out));
}
static ssize_t set_analog_out_reg(struct device *dev,
                  struct device_attribute *attr,
                  const char *buf, size_t count)
static ssize_t analog_out_store(struct device *dev,
                struct device_attribute *attr,
                const char *buf, size_t count)
{
    struct adm1026_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    long val;
    int err;
​
    err = kstrtol(buf, 10, &val);
    if (err)
        return err;
​
    mutex_lock(&data->update_lock);
    data->analog_out = DAC_TO_REG(val);
    adm1026_write_value(client, ADM1026_REG_DAC, data->analog_out);
    mutex_unlock(&data->update_lock);
    return count;
}
​
static DEVICE_ATTR(analog_out, S_IRUGO | S_IWUSR, show_analog_out_reg,
    set_analog_out_reg);
static DEVICE_ATTR_RW(analog_out);
​
static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr,
                char *buf)
static ssize_t cpu0_vid_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    int vid = (data->gpio >> 11) & 0x1f;
​
    dev_dbg(dev, "Setting VID from GPIO11-15.\n");
    return sprintf(buf, "%d\n", vid_from_reg(vid, data->vrm));
}
​
static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
static DEVICE_ATTR_RO(cpu0_vid);
​
static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr,
                char *buf)
static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
            char *buf)
{
    struct adm1026_data *data = dev_get_drvdata(dev);
    return sprintf(buf, "%d\n", data->vrm);
}
​
static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
             const char *buf, size_t count)
{
    struct adm1026_data *data = dev_get_drvdata(dev);
    unsigned long val;
    int err;
​
    err = kstrtoul(buf, 10, &val);
    if (err)
        return err;
​
    if (val > 255)
        return -EINVAL;
​
    data->vrm = val;
    return count;
}
​
static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
static DEVICE_ATTR_RW(vrm);
​
static ssize_t show_alarms_reg(struct device *dev,
                   struct device_attribute *attr, char *buf)
static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
               char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    return sprintf(buf, "%ld\n", data->alarms);
}
​
static DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
static DEVICE_ATTR_RO(alarms);
​
static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
              char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    int bitnr = to_sensor_dev_attr(attr)->index;
    return sprintf(buf, "%ld\n", (data->alarms >> bitnr) & 1);
}
​
static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 0);
Show more
static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 18);
static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 19);
static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 20);
static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL, 21);
static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO, show_alarm, NULL, 22);
static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO, show_alarm, NULL, 23);
static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 24);
static SENSOR_DEVICE_ATTR(in10_alarm, S_IRUGO, show_alarm, NULL, 25);
static SENSOR_DEVICE_ATTR(in8_alarm, S_IRUGO, show_alarm, NULL, 26);
​
static ssize_t show_alarm_mask(struct device *dev,
static ssize_t alarm_mask_show(struct device *dev,
                   struct device_attribute *attr, char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    return sprintf(buf, "%ld\n", data->alarm_mask);
}
static ssize_t set_alarm_mask(struct device *dev, struct device_attribute *attr,
                  const char *buf, size_t count)
static ssize_t alarm_mask_store(struct device *dev,
                struct device_attribute *attr,
                const char *buf, size_t count)
{
    struct adm1026_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    unsigned long mask;
    long val;
    int err;
​
    err = kstrtol(buf, 10, &val);
    if (err)
        return err;
Show more
    mask >>= 8;
    adm1026_write_value(client, ADM1026_REG_MASK3,
        mask & 0xff);
    mask >>= 8;
    adm1026_write_value(client, ADM1026_REG_MASK4,
        mask & 0xff);
    mutex_unlock(&data->update_lock);
    return count;
}
​
static DEVICE_ATTR(alarm_mask, S_IRUGO | S_IWUSR, show_alarm_mask,
    set_alarm_mask);
static DEVICE_ATTR_RW(alarm_mask);
​
​
static ssize_t show_gpio(struct device *dev, struct device_attribute *attr,
static ssize_t gpio_show(struct device *dev, struct device_attribute *attr,
             char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    return sprintf(buf, "%ld\n", data->gpio);
}
static ssize_t set_gpio(struct device *dev, struct device_attribute *attr,
            const char *buf, size_t count)
static ssize_t gpio_store(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
{
    struct adm1026_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    long gpio;
    long val;
    int err;
​
    err = kstrtol(buf, 10, &val);
    if (err)
        return err;
Show more
    gpio = data->gpio;
    adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_0_7, gpio & 0xff);
    gpio >>= 8;
    adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_8_15, gpio & 0xff);
    gpio = ((gpio >> 1) & 0x80) | (data->alarms >> 24 & 0x7f);
    adm1026_write_value(client, ADM1026_REG_STATUS4, gpio & 0xff);
    mutex_unlock(&data->update_lock);
    return count;
}
​
static DEVICE_ATTR(gpio, S_IRUGO | S_IWUSR, show_gpio, set_gpio);
static DEVICE_ATTR_RW(gpio);
​
static ssize_t show_gpio_mask(struct device *dev, struct device_attribute *attr,
static ssize_t gpio_mask_show(struct device *dev,
                  struct device_attribute *attr,
                  char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    return sprintf(buf, "%ld\n", data->gpio_mask);
}
static ssize_t set_gpio_mask(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
static ssize_t gpio_mask_store(struct device *dev,
                   struct device_attribute *attr, const char *buf,
                   size_t count)
{
    struct adm1026_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    long mask;
    long val;
    int err;
​
    err = kstrtol(buf, 10, &val);
    if (err)
        return err;
Show more
    mask = data->gpio_mask;
    adm1026_write_value(client, ADM1026_REG_GPIO_MASK_0_7, mask & 0xff);
    mask >>= 8;
    adm1026_write_value(client, ADM1026_REG_GPIO_MASK_8_15, mask & 0xff);
    mask = ((mask >> 1) & 0x80) | (data->alarm_mask >> 24 & 0x7f);
    adm1026_write_value(client, ADM1026_REG_MASK1, mask & 0xff);
    mutex_unlock(&data->update_lock);
    return count;
}
​
static DEVICE_ATTR(gpio_mask, S_IRUGO | S_IWUSR, show_gpio_mask, set_gpio_mask);
static DEVICE_ATTR_RW(gpio_mask);
​
static ssize_t show_pwm_reg(struct device *dev, struct device_attribute *attr,
                char *buf)
static ssize_t pwm1_show(struct device *dev, struct device_attribute *attr,
             char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm1.pwm));
}
​
static ssize_t set_pwm_reg(struct device *dev, struct device_attribute *attr,
               const char *buf, size_t count)
static ssize_t pwm1_store(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
{
    struct adm1026_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
​
    if (data->pwm1.enable == 1) {
        long val;
        int err;
​
        err = kstrtol(buf, 10, &val);
        if (err)
            return err;
​
        mutex_lock(&data->update_lock);
        data->pwm1.pwm = PWM_TO_REG(val);
        adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
        mutex_unlock(&data->update_lock);
    }
    return count;
}
​
static ssize_t show_auto_pwm_min(struct device *dev,
                 struct device_attribute *attr, char *buf)
static ssize_t temp1_auto_point1_pwm_show(struct device *dev,
                      struct device_attribute *attr,
                      char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    return sprintf(buf, "%d\n", data->pwm1.auto_pwm_min);
}
​
static ssize_t set_auto_pwm_min(struct device *dev,
                struct device_attribute *attr, const char *buf,
                size_t count)
static ssize_t temp1_auto_point1_pwm_store(struct device *dev,
                       struct device_attribute *attr,
                       const char *buf, size_t count)
{
    struct adm1026_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    unsigned long val;
    int err;
​
    err = kstrtoul(buf, 10, &val);
    if (err)
        return err;
​
Show more
    data->pwm1.auto_pwm_min = clamp_val(val, 0, 255);
    if (data->pwm1.enable == 2) { /* apply immediately */
        data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |
            PWM_MIN_TO_REG(data->pwm1.auto_pwm_min));
        adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
    }
    mutex_unlock(&data->update_lock);
    return count;
}
​
static ssize_t show_auto_pwm_max(struct device *dev,
                 struct device_attribute *attr, char *buf)
static ssize_t temp1_auto_point2_pwm_show(struct device *dev,
                      struct device_attribute *attr,
                      char *buf)
{
    return sprintf(buf, "%d\n", ADM1026_PWM_MAX);
}
​
static ssize_t show_pwm_enable(struct device *dev,
                   struct device_attribute *attr, char *buf)
static ssize_t pwm1_enable_show(struct device *dev,
                struct device_attribute *attr, char *buf)
{
    struct adm1026_data *data = adm1026_update_device(dev);
    return sprintf(buf, "%d\n", data->pwm1.enable);
}
​
static ssize_t set_pwm_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 adm1026_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    int old_enable;
    unsigned long val;
    int err;
​
    err = kstrtoul(buf, 10, &val);
    if (err)
        return err;
Show more
        /* set pwm to safe value */
        data->pwm1.pwm = 255;
        adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
    }
    mutex_unlock(&data->update_lock);
​
    return count;
}
​
/* enable PWM fan control */
static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm_reg, set_pwm_reg);
static DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, show_pwm_reg, set_pwm_reg);
static DEVICE_ATTR(pwm3, S_IRUGO | S_IWUSR, show_pwm_reg, set_pwm_reg);
static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, show_pwm_enable,
    set_pwm_enable);
static DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR, show_pwm_enable,
    set_pwm_enable);
static DEVICE_ATTR(pwm3_enable, S_IRUGO | S_IWUSR, show_pwm_enable,
    set_pwm_enable);
static DEVICE_ATTR(temp1_auto_point1_pwm, S_IRUGO | S_IWUSR,
    show_auto_pwm_min, set_auto_pwm_min);
static DEVICE_ATTR_RW(pwm1);
static DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR, pwm1_show, pwm1_store);
static DEVICE_ATTR(pwm3, S_IRUGO | S_IWUSR, pwm1_show, pwm1_store);
static DEVICE_ATTR_RW(pwm1_enable);
static DEVICE_ATTR(pwm2_enable, S_IRUGO | S_IWUSR, pwm1_enable_show,
           pwm1_enable_store);
static DEVICE_ATTR(pwm3_enable, S_IRUGO | S_IWUSR, pwm1_enable_show,
           pwm1_enable_store);
static DEVICE_ATTR_RW(temp1_auto_point1_pwm);
static DEVICE_ATTR(temp2_auto_point1_pwm, S_IRUGO | S_IWUSR,
    show_auto_pwm_min, set_auto_pwm_min);
    temp1_auto_point1_pwm_show, temp1_auto_point1_pwm_store);
static DEVICE_ATTR(temp3_auto_point1_pwm, S_IRUGO | S_IWUSR,
    show_auto_pwm_min, set_auto_pwm_min);
    temp1_auto_point1_pwm_show, temp1_auto_point1_pwm_store);
​
static DEVICE_ATTR(temp1_auto_point2_pwm, S_IRUGO, show_auto_pwm_max, NULL);
static DEVICE_ATTR(temp2_auto_point2_pwm, S_IRUGO, show_auto_pwm_max, NULL);
static DEVICE_ATTR(temp3_auto_point2_pwm, S_IRUGO, show_auto_pwm_max, NULL);
static DEVICE_ATTR_RO(temp1_auto_point2_pwm);
static DEVICE_ATTR(temp2_auto_point2_pwm, S_IRUGO, temp1_auto_point2_pwm_show,
           NULL);
static DEVICE_ATTR(temp3_auto_point2_pwm, S_IRUGO, temp1_auto_point2_pwm_show,
           NULL);
​
static struct attribute *adm1026_attributes[] = {
    &sensor_dev_attr_in0_input.dev_attr.attr,
    &sensor_dev_attr_in0_max.dev_attr.attr,
    &sensor_dev_attr_in0_min.dev_attr.attr,
    &sensor_dev_attr_in0_alarm.dev_attr.attr,
    &sensor_dev_attr_in1_input.dev_attr.attr,
    &sensor_dev_attr_in1_max.dev_attr.attr,
    &sensor_dev_attr_in1_min.dev_attr.attr,
    &sensor_dev_attr_in1_alarm.dev_attr.attr,