Source of lm95234.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 = true;
    }
    ret = 0;
abort:
    mutex_unlock(&data->update_lock);
​
    return ret;
}
​
static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
             char *buf)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
​
    if (ret)
        return ret;
​
    return sprintf(buf, "%d\n",
               DIV_ROUND_CLOSEST(data->temp[index] * 125, 32));
}
​
static ssize_t show_alarm(struct device *dev,
              struct device_attribute *attr, char *buf)
static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
              char *buf)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    u32 mask = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
​
    if (ret)
        return ret;
​
    return sprintf(buf, "%u", !!(data->status & mask));
}
​
static ssize_t show_type(struct device *dev, struct device_attribute *attr,
static ssize_t type_show(struct device *dev, struct device_attribute *attr,
             char *buf)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    u8 mask = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
​
    if (ret)
        return ret;
​
    return sprintf(buf, data->sensor_type & mask ? "1\n" : "2\n");
}
​
static ssize_t set_type(struct device *dev, struct device_attribute *attr,
            const char *buf, size_t count)
static ssize_t type_store(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    unsigned long val;
    u8 mask = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
​
    if (ret)
        return ret;
​
    ret = kstrtoul(buf, 10, &val);
Show more
    else
        data->sensor_type &= ~mask;
    data->valid = false;
    i2c_smbus_write_byte_data(data->client, LM95234_REG_REM_MODEL,
                  data->sensor_type);
    mutex_unlock(&data->update_lock);
​
    return count;
}
​
static ssize_t show_tcrit2(struct device *dev, struct device_attribute *attr,
static ssize_t tcrit2_show(struct device *dev, struct device_attribute *attr,
               char *buf)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
​
    if (ret)
        return ret;
​
    return sprintf(buf, "%u", data->tcrit2[index] * 1000);
}
​
static ssize_t set_tcrit2(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
static ssize_t tcrit2_store(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
    long val;
    int ret = lm95234_update_device(data);
​
    if (ret)
        return ret;
​
    ret = kstrtol(buf, 10, &val);
Show more
    val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, index ? 255 : 127);
​
    mutex_lock(&data->update_lock);
    data->tcrit2[index] = val;
    i2c_smbus_write_byte_data(data->client, LM95234_REG_TCRIT2(index), val);
    mutex_unlock(&data->update_lock);
​
    return count;
}
​
static ssize_t show_tcrit2_hyst(struct device *dev,
static ssize_t tcrit2_hyst_show(struct device *dev,
                struct device_attribute *attr, char *buf)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
​
    if (ret)
        return ret;
​
    /* Result can be negative, so be careful with unsigned operands */
    return sprintf(buf, "%d",
               ((int)data->tcrit2[index] - (int)data->thyst) * 1000);
}
​
static ssize_t show_tcrit1(struct device *dev, struct device_attribute *attr,
static ssize_t tcrit1_show(struct device *dev, struct device_attribute *attr,
               char *buf)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
​
    return sprintf(buf, "%u", data->tcrit1[index] * 1000);
}
​
static ssize_t set_tcrit1(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
static ssize_t tcrit1_store(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
    long val;
​
    if (ret)
        return ret;
​
    ret = kstrtol(buf, 10, &val);
Show more
    val = clamp_val(DIV_ROUND_CLOSEST(val, 1000), 0, 255);
​
    mutex_lock(&data->update_lock);
    data->tcrit1[index] = val;
    i2c_smbus_write_byte_data(data->client, LM95234_REG_TCRIT1(index), val);
    mutex_unlock(&data->update_lock);
​
    return count;
}
​
static ssize_t show_tcrit1_hyst(struct device *dev,
static ssize_t tcrit1_hyst_show(struct device *dev,
                struct device_attribute *attr, char *buf)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
​
    if (ret)
        return ret;
​
    /* Result can be negative, so be careful with unsigned operands */
    return sprintf(buf, "%d",
               ((int)data->tcrit1[index] - (int)data->thyst) * 1000);
}
​
static ssize_t set_tcrit1_hyst(struct device *dev,
                   struct device_attribute *attr,
                   const char *buf, size_t count)
static ssize_t tcrit1_hyst_store(struct device *dev,
                 struct device_attribute *attr,
                 const char *buf, size_t count)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
    long val;
​
    if (ret)
        return ret;
​
    ret = kstrtol(buf, 10, &val);
Show more
    val = clamp_val((int)data->tcrit1[index] - val, 0, 31);
​
    mutex_lock(&data->update_lock);
    data->thyst = val;
    i2c_smbus_write_byte_data(data->client, LM95234_REG_TCRIT_HYST, val);
    mutex_unlock(&data->update_lock);
​
    return count;
}
​
static ssize_t show_offset(struct device *dev, struct device_attribute *attr,
static ssize_t offset_show(struct device *dev, struct device_attribute *attr,
               char *buf)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
​
    if (ret)
        return ret;
​
    return sprintf(buf, "%d", data->toffset[index] * 500);
}
​
static ssize_t set_offset(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
static ssize_t offset_store(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
    struct lm95234_data *data = dev_get_drvdata(dev);
    int index = to_sensor_dev_attr(attr)->index;
    int ret = lm95234_update_device(data);
    long val;
​
    if (ret)
        return ret;
​
    ret = kstrtol(buf, 10, &val);
Show more
    }
​
    mutex_lock(&data->update_lock);
    data->interval = msecs_to_jiffies(update_intervals[regval]);
    i2c_smbus_write_byte_data(data->client, LM95234_REG_CONVRATE, regval);
    mutex_unlock(&data->update_lock);
​
    return count;
}
​
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4);
​
static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL,
              BIT(0) | BIT(1));
static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL,
              BIT(2) | BIT(3));
static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_alarm, NULL,
              BIT(4) | BIT(5));
static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_alarm, NULL,
              BIT(6) | BIT(7));
​
static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type, set_type,
              BIT(1));
static SENSOR_DEVICE_ATTR(temp3_type, S_IWUSR | S_IRUGO, show_type, set_type,
              BIT(2));
static SENSOR_DEVICE_ATTR(temp4_type, S_IWUSR | S_IRUGO, show_type, set_type,
              BIT(3));
static SENSOR_DEVICE_ATTR(temp5_type, S_IWUSR | S_IRUGO, show_type, set_type,
              BIT(4));
​
static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_tcrit1,
              set_tcrit1, 0);
static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_tcrit2,
              set_tcrit2, 0);
static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_tcrit2,
              set_tcrit2, 1);
static SENSOR_DEVICE_ATTR(temp4_max, S_IWUSR | S_IRUGO, show_tcrit1,
              set_tcrit1, 3);
static SENSOR_DEVICE_ATTR(temp5_max, S_IWUSR | S_IRUGO, show_tcrit1,
              set_tcrit1, 4);
​
static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, show_tcrit1_hyst,
              set_tcrit1_hyst, 0);
static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO, show_tcrit2_hyst, NULL, 0);
static SENSOR_DEVICE_ATTR(temp3_max_hyst, S_IRUGO, show_tcrit2_hyst, NULL, 1);
static SENSOR_DEVICE_ATTR(temp4_max_hyst, S_IRUGO, show_tcrit1_hyst, NULL, 3);
static SENSOR_DEVICE_ATTR(temp5_max_hyst, S_IRUGO, show_tcrit1_hyst, NULL, 4);
​
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL,
              BIT(0 + 8));
static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL,
              BIT(1 + 16));
static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL,
              BIT(2 + 16));
static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL,
              BIT(3 + 8));
static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_alarm, NULL,
              BIT(4 + 8));
​
static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_tcrit1,
              set_tcrit1, 1);
static SENSOR_DEVICE_ATTR(temp3_crit, S_IWUSR | S_IRUGO, show_tcrit1,
              set_tcrit1, 2);
​
static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_tcrit1_hyst, NULL, 1);
static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO, show_tcrit1_hyst, NULL, 2);
​
static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL,
              BIT(1 + 8));
static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL,
              BIT(2 + 8));
​
static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_offset,
              set_offset, 0);
static SENSOR_DEVICE_ATTR(temp3_offset, S_IWUSR | S_IRUGO, show_offset,
              set_offset, 1);
static SENSOR_DEVICE_ATTR(temp4_offset, S_IWUSR | S_IRUGO, show_offset,
              set_offset, 2);
static SENSOR_DEVICE_ATTR(temp5_offset, S_IWUSR | S_IRUGO, show_offset,
              set_offset, 3);
static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
static SENSOR_DEVICE_ATTR_RO(temp4_input, temp, 3);
static SENSOR_DEVICE_ATTR_RO(temp5_input, temp, 4);
​
static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, BIT(0) | BIT(1));
static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, BIT(2) | BIT(3));
static SENSOR_DEVICE_ATTR_RO(temp4_fault, alarm, BIT(4) | BIT(5));
static SENSOR_DEVICE_ATTR_RO(temp5_fault, alarm, BIT(6) | BIT(7));
​
static SENSOR_DEVICE_ATTR_RW(temp2_type, type, BIT(1));
static SENSOR_DEVICE_ATTR_RW(temp3_type, type, BIT(2));
static SENSOR_DEVICE_ATTR_RW(temp4_type, type, BIT(3));
static SENSOR_DEVICE_ATTR_RW(temp5_type, type, BIT(4));
​
static SENSOR_DEVICE_ATTR_RW(temp1_max, tcrit1, 0);
static SENSOR_DEVICE_ATTR_RW(temp2_max, tcrit2, 0);
static SENSOR_DEVICE_ATTR_RW(temp3_max, tcrit2, 1);
static SENSOR_DEVICE_ATTR_RW(temp4_max, tcrit1, 3);
static SENSOR_DEVICE_ATTR_RW(temp5_max, tcrit1, 4);
​
static SENSOR_DEVICE_ATTR_RW(temp1_max_hyst, tcrit1_hyst, 0);
static SENSOR_DEVICE_ATTR_RO(temp2_max_hyst, tcrit2_hyst, 0);
static SENSOR_DEVICE_ATTR_RO(temp3_max_hyst, tcrit2_hyst, 1);
static SENSOR_DEVICE_ATTR_RO(temp4_max_hyst, tcrit1_hyst, 3);
static SENSOR_DEVICE_ATTR_RO(temp5_max_hyst, tcrit1_hyst, 4);
​
static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, BIT(0 + 8));
static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, BIT(1 + 16));
static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, alarm, BIT(2 + 16));
static SENSOR_DEVICE_ATTR_RO(temp4_max_alarm, alarm, BIT(3 + 8));
static SENSOR_DEVICE_ATTR_RO(temp5_max_alarm, alarm, BIT(4 + 8));
​
static SENSOR_DEVICE_ATTR_RW(temp2_crit, tcrit1, 1);
static SENSOR_DEVICE_ATTR_RW(temp3_crit, tcrit1, 2);
​
static SENSOR_DEVICE_ATTR_RO(temp2_crit_hyst, tcrit1_hyst, 1);
static SENSOR_DEVICE_ATTR_RO(temp3_crit_hyst, tcrit1_hyst, 2);
​
static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, BIT(1 + 8));
static SENSOR_DEVICE_ATTR_RO(temp3_crit_alarm, alarm, BIT(2 + 8));
​
static SENSOR_DEVICE_ATTR_RW(temp2_offset, offset, 0);
static SENSOR_DEVICE_ATTR_RW(temp3_offset, offset, 1);
static SENSOR_DEVICE_ATTR_RW(temp4_offset, offset, 2);
static SENSOR_DEVICE_ATTR_RW(temp5_offset, offset, 3);
​
static DEVICE_ATTR_RW(update_interval);
​
static struct attribute *lm95234_common_attrs[] = {
    &sensor_dev_attr_temp1_input.dev_attr.attr,
    &sensor_dev_attr_temp2_input.dev_attr.attr,
    &sensor_dev_attr_temp3_input.dev_attr.attr,
    &sensor_dev_attr_temp2_fault.dev_attr.attr,
    &sensor_dev_attr_temp3_fault.dev_attr.attr,
    &sensor_dev_attr_temp2_type.dev_attr.attr,