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

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
​
        data->last_updated = jiffies;
        data->valid = 1;
    }
​
abort:
    mutex_unlock(&data->update_lock);
    return ret;
}
​
static ssize_t show_temp(struct device *dev,
             struct device_attribute *devattr, char *buf)
static ssize_t temp_show(struct device *dev, struct device_attribute *devattr,
             char *buf)
{
    int nr = to_sensor_dev_attr_2(devattr)->nr;
    int index = to_sensor_dev_attr_2(devattr)->index;
    struct tmp401_data *data = tmp401_update_device(dev);
​
    if (IS_ERR(data))
        return PTR_ERR(data);
​
    return sprintf(buf, "%d\n",
        tmp401_register_to_temp(data->temp[nr][index], data->config));
}
​
static ssize_t show_temp_crit_hyst(struct device *dev,
    struct device_attribute *devattr, char *buf)
static ssize_t temp_crit_hyst_show(struct device *dev,
                   struct device_attribute *devattr,
                   char *buf)
{
    int temp, index = to_sensor_dev_attr(devattr)->index;
    struct tmp401_data *data = tmp401_update_device(dev);
​
    if (IS_ERR(data))
        return PTR_ERR(data);
​
    mutex_lock(&data->update_lock);
    temp = tmp401_register_to_temp(data->temp[3][index], data->config);
    temp -= data->temp_crit_hyst * 1000;
    mutex_unlock(&data->update_lock);
​
    return sprintf(buf, "%d\n", temp);
}
​
static ssize_t show_status(struct device *dev,
    struct device_attribute *devattr, char *buf)
static ssize_t status_show(struct device *dev,
               struct device_attribute *devattr, char *buf)
{
    int nr = to_sensor_dev_attr_2(devattr)->nr;
    int mask = to_sensor_dev_attr_2(devattr)->index;
    struct tmp401_data *data = tmp401_update_device(dev);
​
    if (IS_ERR(data))
        return PTR_ERR(data);
​
    return sprintf(buf, "%d\n", !!(data->status[nr] & mask));
}
​
static ssize_t store_temp(struct device *dev, struct device_attribute *devattr,
              const char *buf, size_t count)
static ssize_t temp_store(struct device *dev,
              struct device_attribute *devattr, const char *buf,
              size_t count)
{
    int nr = to_sensor_dev_attr_2(devattr)->nr;
    int index = to_sensor_dev_attr_2(devattr)->index;
    struct tmp401_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    long val;
    u16 reg;
    u8 regaddr;
​
    if (kstrtol(buf, 10, &val))
Show more
        /* Hardware expects big endian data --> use _swapped */
        i2c_smbus_write_word_swapped(client, regaddr, reg);
    }
    data->temp[nr][index] = reg;
​
    mutex_unlock(&data->update_lock);
​
    return count;
}
​
static ssize_t store_temp_crit_hyst(struct device *dev, struct device_attribute
    *devattr, const char *buf, size_t count)
static ssize_t temp_crit_hyst_store(struct device *dev,
                    struct device_attribute *devattr,
                    const char *buf, size_t count)
{
    int temp, index = to_sensor_dev_attr(devattr)->index;
    struct tmp401_data *data = tmp401_update_device(dev);
    long val;
    u8 reg;
​
    if (IS_ERR(data))
        return PTR_ERR(data);
​
    if (kstrtol(buf, 10, &val))
Show more
    mutex_unlock(&data->update_lock);
​
    return count;
}
​
/*
 * Resets the historical measurements of minimum and maximum temperatures.
 * This is done by writing any value to any of the minimum/maximum registers
 * (0x30-0x37).
 */
static ssize_t reset_temp_history(struct device *dev,
    struct device_attribute *devattr, const char *buf, size_t count)
static ssize_t reset_temp_history_store(struct device *dev,
                    struct device_attribute *devattr,
                    const char *buf, size_t count)
{
    struct tmp401_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    long val;
​
    if (kstrtol(buf, 10, &val))
        return -EINVAL;
​
    if (val != 1) {
        dev_err(dev,
Show more
    val = clamp_val(val, 125, 16000);
    rate = 7 - __fls(val * 4 / (125 * 3));
    mutex_lock(&data->update_lock);
    i2c_smbus_write_byte_data(client, TMP401_CONVERSION_RATE_WRITE, rate);
    data->update_interval = (1 << (7 - rate)) * 125;
    mutex_unlock(&data->update_lock);
​
    return count;
}
​
static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0, 0);
static SENSOR_DEVICE_ATTR_2(temp1_min, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 1, 0);
static SENSOR_DEVICE_ATTR_2(temp1_max, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 2, 0);
static SENSOR_DEVICE_ATTR_2(temp1_crit, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 3, 0);
static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO,
              show_temp_crit_hyst, store_temp_crit_hyst, 0);
static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO, show_status, NULL,
                1, TMP432_STATUS_LOCAL);
static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO, show_status, NULL,
                2, TMP432_STATUS_LOCAL);
static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO, show_status, NULL,
                3, TMP432_STATUS_LOCAL);
static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 0, 1);
static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 1, 1);
static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 2, 1);
static SENSOR_DEVICE_ATTR_2(temp2_crit, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 3, 1);
static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temp_crit_hyst,
              NULL, 1);
static SENSOR_DEVICE_ATTR_2(temp2_fault, S_IRUGO, show_status, NULL,
                0, TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO, show_status, NULL,
                1, TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO, show_status, NULL,
                2, TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO, show_status, NULL,
                3, TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2_RO(temp1_input, temp, 0, 0);
static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, 1, 0);
static SENSOR_DEVICE_ATTR_2_RW(temp1_max, temp, 2, 0);
static SENSOR_DEVICE_ATTR_2_RW(temp1_crit, temp, 3, 0);
static SENSOR_DEVICE_ATTR_RW(temp1_crit_hyst, temp_crit_hyst, 0);
static SENSOR_DEVICE_ATTR_2_RO(temp1_min_alarm, status, 1,
                   TMP432_STATUS_LOCAL);
static SENSOR_DEVICE_ATTR_2_RO(temp1_max_alarm, status, 2,
                   TMP432_STATUS_LOCAL);
static SENSOR_DEVICE_ATTR_2_RO(temp1_crit_alarm, status, 3,
                   TMP432_STATUS_LOCAL);
static SENSOR_DEVICE_ATTR_2_RO(temp2_input, temp, 0, 1);
static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, 1, 1);
static SENSOR_DEVICE_ATTR_2_RW(temp2_max, temp, 2, 1);
static SENSOR_DEVICE_ATTR_2_RW(temp2_crit, temp, 3, 1);
static SENSOR_DEVICE_ATTR_RO(temp2_crit_hyst, temp_crit_hyst, 1);
static SENSOR_DEVICE_ATTR_2_RO(temp2_fault, status, 0, TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2_RO(temp2_min_alarm, status, 1,
                   TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2_RO(temp2_max_alarm, status, 2,
                   TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2_RO(temp2_crit_alarm, status, 3,
                   TMP432_STATUS_REMOTE1);
​
static DEVICE_ATTR_RW(update_interval);
​
static struct attribute *tmp401_attributes[] = {
    &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_crit_hyst.dev_attr.attr,
    &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
Show more
    .attrs = tmp401_attributes,
};
​
/*
 * Additional features of the TMP411 chip.
 * The TMP411 stores the minimum and maximum
 * temperature measured since power-on, chip-reset, or
 * minimum and maximum register reset for both the local
 * and remote channels.
 */
static SENSOR_DEVICE_ATTR_2(temp1_lowest, S_IRUGO, show_temp, NULL, 4, 0);
static SENSOR_DEVICE_ATTR_2(temp1_highest, S_IRUGO, show_temp, NULL, 5, 0);
static SENSOR_DEVICE_ATTR_2(temp2_lowest, S_IRUGO, show_temp, NULL, 4, 1);
static SENSOR_DEVICE_ATTR_2(temp2_highest, S_IRUGO, show_temp, NULL, 5, 1);
static SENSOR_DEVICE_ATTR(temp_reset_history, S_IWUSR, NULL, reset_temp_history,
              0);
static SENSOR_DEVICE_ATTR_2_RO(temp1_lowest, temp, 4, 0);
static SENSOR_DEVICE_ATTR_2_RO(temp1_highest, temp, 5, 0);
static SENSOR_DEVICE_ATTR_2_RO(temp2_lowest, temp, 4, 1);
static SENSOR_DEVICE_ATTR_2_RO(temp2_highest, temp, 5, 1);
static SENSOR_DEVICE_ATTR_WO(temp_reset_history, reset_temp_history, 0);
​
static struct attribute *tmp411_attributes[] = {
    &sensor_dev_attr_temp1_highest.dev_attr.attr,
    &sensor_dev_attr_temp1_lowest.dev_attr.attr,
    &sensor_dev_attr_temp2_highest.dev_attr.attr,
    &sensor_dev_attr_temp2_lowest.dev_attr.attr,
    &sensor_dev_attr_temp_reset_history.dev_attr.attr,
    NULL
};
​
static const struct attribute_group tmp411_group = {
    .attrs = tmp411_attributes,
};
​
static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, 0, 2);
static SENSOR_DEVICE_ATTR_2(temp3_min, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 1, 2);
static SENSOR_DEVICE_ATTR_2(temp3_max, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 2, 2);
static SENSOR_DEVICE_ATTR_2(temp3_crit, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 3, 2);
static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO, show_temp_crit_hyst,
              NULL, 2);
static SENSOR_DEVICE_ATTR_2(temp3_fault, S_IRUGO, show_status, NULL,
                0, TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO, show_status, NULL,
                1, TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO, show_status, NULL,
                2, TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO, show_status, NULL,
                3, TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2_RO(temp3_input, temp, 0, 2);
static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, 1, 2);
static SENSOR_DEVICE_ATTR_2_RW(temp3_max, temp, 2, 2);
static SENSOR_DEVICE_ATTR_2_RW(temp3_crit, temp, 3, 2);
static SENSOR_DEVICE_ATTR_RO(temp3_crit_hyst, temp_crit_hyst, 2);
static SENSOR_DEVICE_ATTR_2_RO(temp3_fault, status, 0, TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2_RO(temp3_min_alarm, status, 1,
                   TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2_RO(temp3_max_alarm, status, 2,
                   TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2_RO(temp3_crit_alarm, status, 3,
                   TMP432_STATUS_REMOTE2);
​
static struct attribute *tmp432_attributes[] = {
    &sensor_dev_attr_temp3_input.dev_attr.attr,
    &sensor_dev_attr_temp3_min.dev_attr.attr,
    &sensor_dev_attr_temp3_max.dev_attr.attr,
    &sensor_dev_attr_temp3_crit.dev_attr.attr,
    &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
    &sensor_dev_attr_temp3_fault.dev_attr.attr,
    &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
    &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
Show more
};
​
static const struct attribute_group tmp432_group = {
    .attrs = tmp432_attributes,
};
​
/*
 * Additional features of the TMP461 chip.
 * The TMP461 temperature offset for the remote channel.
 */
static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp,
                store_temp, 6, 1);
static SENSOR_DEVICE_ATTR_2_RW(temp2_offset, temp, 6, 1);
​
static struct attribute *tmp461_attributes[] = {
    &sensor_dev_attr_temp2_offset.dev_attr.attr,
    NULL
};
​
static const struct attribute_group tmp461_group = {
    .attrs = tmp461_attributes,
};
​