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

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
​
/*
 * Chip dependent ADC conversion time, in uS
 */
#define SMM665_ADC_WAIT_SMM665  70
#define SMM665_ADC_WAIT_SMM766  185
​
struct smm665_data {
    enum chips type;
    int conversion_time;        /* ADC conversion time */
    struct device *hwmon_dev;
    struct i2c_client *client;
    struct mutex update_lock;
    bool valid;
    unsigned long last_updated; /* in jiffies */
    u16 adc[SMM665_NUM_ADC];    /* adc values (raw) */
    u16 faults;         /* fault status */
    /* The following values are in mV */
    int critical_min_limit[SMM665_NUM_ADC];
    int alarm_min_limit[SMM665_NUM_ADC];
    int critical_max_limit[SMM665_NUM_ADC];
    int alarm_max_limit[SMM665_NUM_ADC];
Show more
        dev_dbg(&client->dev, "Unexpected RADC: Expected %d got %d",
            adc, radc);
        return -EIO;
    }
​
    return rv & SMM665_ADC_MASK;
}
​
static struct smm665_data *smm665_update_device(struct device *dev)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct smm665_data *data = i2c_get_clientdata(client);
    struct smm665_data *data = dev_get_drvdata(dev);
    struct i2c_client *client = data->client;
    struct smm665_data *ret = data;
​
    mutex_lock(&data->update_lock);
​
    if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
        int i, val;
​
        /*
         * read status registers
         */
Show more
        /* If we get here, the developer messed up */
        WARN_ON_ONCE(1);
        break;
    }
​
    return val;
}
​
static int smm665_get_min(struct device *dev, int index)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct smm665_data *data = i2c_get_clientdata(client);
    struct smm665_data *data = dev_get_drvdata(dev);
​
    return data->alarm_min_limit[index];
}
​
static int smm665_get_max(struct device *dev, int index)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct smm665_data *data = i2c_get_clientdata(client);
    struct smm665_data *data = dev_get_drvdata(dev);
​
    return data->alarm_max_limit[index];
}
​
static int smm665_get_lcrit(struct device *dev, int index)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct smm665_data *data = i2c_get_clientdata(client);
    struct smm665_data *data = dev_get_drvdata(dev);
​
    return data->critical_min_limit[index];
}
​
static int smm665_get_crit(struct device *dev, int index)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct smm665_data *data = i2c_get_clientdata(client);
    struct smm665_data *data = dev_get_drvdata(dev);
​
    return data->critical_max_limit[index];
}
​
static ssize_t smm665_show_crit_alarm(struct device *dev,
                      struct device_attribute *da, char *buf)
{
    struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
    struct smm665_data *data = smm665_update_device(dev);
    int val = 0;
Show more
SMM665_ATTR(temp1, min, SMM665_MISC16_ADC_DATA_INT_TEMP);
SMM665_ATTR(temp1, max, SMM665_MISC16_ADC_DATA_INT_TEMP);
SMM665_ATTR(temp1, lcrit, SMM665_MISC16_ADC_DATA_INT_TEMP);
SMM665_ATTR(temp1, crit, SMM665_MISC16_ADC_DATA_INT_TEMP);
SMM665_ATTR(temp1, crit_alarm, SMM665_FAULT_TEMP);
​
/*
 * Finally, construct an array of pointers to members of the above objects,
 * as required for sysfs_create_group()
 */
static struct attribute *smm665_attributes[] = {
static struct attribute *smm665_attrs[] = {
    &sensor_dev_attr_in1_input.dev_attr.attr,
    &sensor_dev_attr_in1_min.dev_attr.attr,
    &sensor_dev_attr_in1_max.dev_attr.attr,
    &sensor_dev_attr_in1_lcrit.dev_attr.attr,
    &sensor_dev_attr_in1_crit.dev_attr.attr,
    &sensor_dev_attr_in1_crit_alarm.dev_attr.attr,
​
    &sensor_dev_attr_in2_input.dev_attr.attr,
    &sensor_dev_attr_in2_min.dev_attr.attr,
    &sensor_dev_attr_in2_max.dev_attr.attr,
Show more
    &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_lcrit.dev_attr.attr,
    &sensor_dev_attr_temp1_crit.dev_attr.attr,
    &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
​
    NULL,
};
​
static const struct attribute_group smm665_group = {
    .attrs = smm665_attributes,
};
ATTRIBUTE_GROUPS(smm665);
​
static int smm665_probe(struct i2c_client *client,
            const struct i2c_device_id *id)
{
    struct i2c_adapter *adapter = client->adapter;
    struct smm665_data *data;
    struct device *hwmon_dev;
    int i, ret;
​
    if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
                     | I2C_FUNC_SMBUS_WORD_DATA))
        return -ENODEV;
​
    if (i2c_smbus_read_byte_data(client, SMM665_ADOC_ENABLE) < 0)
        return -ENODEV;
​
    data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
    if (!data)
        return -ENOMEM;
​
    i2c_set_clientdata(client, data);
    mutex_init(&data->update_lock);
​
    data->client = client;
    data->type = id->driver_data;
    data->cmdreg = i2c_new_dummy(adapter, (client->addr & ~SMM665_REGMASK)
                     | SMM665_CMDREG_BASE);
    if (!data->cmdreg)
        return -ENOMEM;
​
    switch (data->type) {
    case smm465:
    case smm665:
        data->conversion_time = SMM665_ADC_WAIT_SMM665;
Show more
          = smm665_convert(val, i);
        val = smm665_read16(client, SMM665_LIMIT_BASE + i * 8 + 6);
        if (unlikely(val < 0))
            goto out_unregister;
        if (smm665_is_critical(val))
            data->critical_max_limit[i] = smm665_convert(val, i);
        else
            data->alarm_max_limit[i] = smm665_convert(val, i);
    }
​
    /* Register sysfs hooks */
    ret = sysfs_create_group(&client->dev.kobj, &smm665_group);
    if (ret)
    hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
                               client->name, data,
                               smm665_groups);
    if (IS_ERR(hwmon_dev)) {
        ret = PTR_ERR(hwmon_dev);
        goto out_unregister;
​
    data->hwmon_dev = hwmon_device_register(&client->dev);
    if (IS_ERR(data->hwmon_dev)) {
        ret = PTR_ERR(data->hwmon_dev);
        goto out_remove_group;
    }
​
    return 0;
​
out_remove_group:
    sysfs_remove_group(&client->dev.kobj, &smm665_group);
out_unregister:
    i2c_unregister_device(data->cmdreg);
    return ret;
}
​
static int smm665_remove(struct i2c_client *client)
{
    struct smm665_data *data = i2c_get_clientdata(client);
​
    i2c_unregister_device(data->cmdreg);
    hwmon_device_unregister(data->hwmon_dev);
    sysfs_remove_group(&client->dev.kobj, &smm665_group);
​
    return 0;
}
​
static const struct i2c_device_id smm665_id[] = {
    {"smm465", smm465},
    {"smm665", smm665},
    {"smm665c", smm665c},
    {"smm764", smm764},
    {"smm766", smm766},
    {}