static ssize_t store_pwm_sensor(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); unsigned long val = simple_strtoul(buf, NULL, 10) - 1; ssize_t ret = count; mutex_lock(&data->update_lock); if (val < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]) { u8 orig_val = data->pwm_settings[attr->index][0]; u8 address = data->bank1_address[ABIT_UGURU_TEMP_SENSOR][val]; data->pwm_settings[attr->index][0] &= 0xF0; data->pwm_settings[attr->index][0] |= address; if (data->pwm_settings[attr->index][0] != orig_val) { if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1, attr->index, data->pwm_settings[attr->index], 5) < 1) { data->pwm_settings[attr->index][0] = orig_val; ret = -EIO; } } } else ret = -EINVAL; mutex_unlock(&data->update_lock); return ret; }
static ssize_t store_pwm_enable(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); u8 orig_val, user_val = simple_strtoul(buf, NULL, 10); ssize_t ret = count; mutex_lock(&data->update_lock); orig_val = data->pwm_settings[attr->index][0]; switch (user_val) { case 0: data->pwm_settings[attr->index][0] &= ~ABIT_UGURU_FAN_PWM_ENABLE; break; case 2: data->pwm_settings[attr->index][0] |= ABIT_UGURU_FAN_PWM_ENABLE; break; default: ret = -EINVAL; } if ((data->pwm_settings[attr->index][0] != orig_val) && (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1, attr->index, data->pwm_settings[attr->index], 5) < 1)) { data->pwm_settings[attr->index][0] = orig_val; ret = -EIO; } mutex_unlock(&data->update_lock); return ret; }
/* * Generic counter attributes */ static ssize_t ds1682_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); struct i2c_client *client = to_i2c_client(dev); __le32 val = 0; int rc; dev_dbg(dev, "ds1682_show() called on %s\n", attr->attr.name); /* Read the register */ rc = i2c_smbus_read_i2c_block_data(client, sattr->index, sattr->nr, (u8 *) & val); if (rc < 0) return -EIO; /* Special case: the 32 bit regs are time values with 1/4s * resolution, scale them up to milliseconds */ if (sattr->nr == 4) return sprintf(buf, "%llu\n", ((unsigned long long)le32_to_cpu(val)) * 250); /* Format the output string and return # of bytes */ return sprintf(buf, "%li\n", (long)le32_to_cpu(val)); }
static ssize_t store_bank2_mask(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); int mask = simple_strtoul(buf, NULL, 10); ssize_t ret = count; u8 orig_val; mutex_lock(&data->update_lock); orig_val = data->bank2_settings[attr->index][0]; if (mask) data->bank2_settings[attr->index][0] |= attr->nr; else data->bank2_settings[attr->index][0] &= ~attr->nr; if ((data->bank2_settings[attr->index][0] != orig_val) && (abituguru_write(data, ABIT_UGURU_SENSOR_BANK2 + 2, attr->index, data->bank2_settings[attr->index], 2) < 1)) { data->bank2_settings[attr->index][0] = orig_val; ret = -EIO; } mutex_unlock(&data->update_lock); return ret; }
// Set input signal state value static ssize_t set_in(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct sensor_device_attribute_2 *sensor_attr_2 = to_sensor_dev_attr_2(attr); int ix = sensor_attr_2->index; int fn = sensor_attr_2->nr; long val = simple_strtol(buf, NULL, 10); if(val < 0) return 0; mutex_lock(&aio_data->update_lock); switch (fn) { case SYS_IN_DEBOUNCE: if(val < 20 || val > 3000) val = 20; // min value in milliseconds aio_data->debounce_time[ix] = val; break; default: printk("%s(): Unknown function %d.\n", __func__, fn); break; } mutex_unlock(&aio_data->update_lock); return count; }
/* Function called on read access on in{0,1,2,3,4,5,6,7}_{min,max} */ static ssize_t max197_show_range(struct device *dev, struct device_attribute *devattr, char *buf) { struct max197_data *data = dev_get_drvdata(dev); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); int channel = attr->index; bool is_min = attr->nr; int range; if (mutex_lock_interruptible(&data->lock)) return -ERESTARTSYS; range = max197_is_full_range(data, channel) ? data->limit : data->limit / 2; if (is_min) { if (max197_is_bipolar(data, channel)) range = -range; else range = 0; } mutex_unlock(&data->lock); return sprintf(buf, "%d\n", range); }
static ssize_t store_bit(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct i2c_client *client = to_i2c_client(dev); struct thermal_data *data = i2c_get_clientdata(client); struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr); unsigned long val; int retval; if (kstrtoul(buf, 10, &val)) return -EINVAL; mutex_lock(&data->mutex); retval = i2c_smbus_read_byte_data(client, sda->nr); if (retval < 0) goto fail; retval &= ~sda->index; if (val) retval |= sda->index; retval = i2c_smbus_write_byte_data(client, sda->index, retval); if (retval == 0) retval = count; fail: mutex_unlock(&data->mutex); return retval; }
static ssize_t store_bank2_setting(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); unsigned long val; ssize_t ret; ret = kstrtoul(buf, 10, &val); if (ret) return ret; ret = count; val = (val * 255 + ABIT_UGURU_FAN_MAX / 2) / ABIT_UGURU_FAN_MAX; if (val < abituguru_bank2_min_threshold || val > abituguru_bank2_max_threshold) return -EINVAL; mutex_lock(&data->update_lock); if (data->bank2_settings[attr->index][attr->nr] != val) { u8 orig_val = data->bank2_settings[attr->index][attr->nr]; data->bank2_settings[attr->index][attr->nr] = val; if (abituguru_write(data, ABIT_UGURU_SENSOR_BANK2 + 2, attr->index, data->bank2_settings[attr->index], 2) <= attr->nr) { data->bank2_settings[attr->index][attr->nr] = orig_val; ret = -EIO; } } mutex_unlock(&data->update_lock); return ret; }
static ssize_t show_pwm_setting(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); return sprintf(buf, "%d\n", data->pwm_settings[attr->index][attr->nr] * abituguru_pwm_settings_multiplier[attr->nr]); }
static ssize_t show_bank2_setting(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); return sprintf(buf, "%d\n", (data->bank2_settings[attr->index][attr->nr] * ABIT_UGURU_FAN_MAX + 128) / 255); }
static ssize_t show_pwm(struct device *dev, struct device_attribute *attr, char *buf) { struct nct6683_data *data = nct6683_update_device(dev); struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); int index = sattr->index; return sprintf(buf, "%d\n", data->pwm[index]); }
static ssize_t show_temp8(struct device *dev, struct device_attribute *attr, char *buf) { struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); struct nct6683_data *data = nct6683_update_device(dev); int index = sattr->index; int nr = sattr->nr; return sprintf(buf, "%d\n", data->temp[index][nr] * 1000); }
static ssize_t show_bank2_value(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = abituguru_update_device(dev); if (!data) return -EIO; return sprintf(buf, "%d\n", (data->bank2_value[attr->index] * ABIT_UGURU_FAN_MAX + 128) / 255); }
static ssize_t show_pwm_enable(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); int res = 0; if (data->pwm_settings[attr->index][0] & ABIT_UGURU_FAN_PWM_ENABLE) res = 2; return sprintf(buf, "%d\n", res); }
static ssize_t show_bank2_mask(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); if (data->bank2_settings[attr->index][0] & attr->nr) return sprintf(buf, "1\n"); else return sprintf(buf, "0\n"); }
static ssize_t ltc4215_show_alarm(struct device *dev, struct device_attribute *da, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da); struct ltc4215_data *data = ltc4215_update_device(dev); const u8 reg = data->regs[attr->index]; const u32 mask = attr->nr; return snprintf(buf, PAGE_SIZE, "%u\n", (reg & mask) ? 1 : 0); }
static ssize_t show_in_reg(struct device *dev, struct device_attribute *attr, char *buf) { struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); struct nct6683_data *data = nct6683_update_device(dev); int index = sattr->index; int nr = sattr->nr; return sprintf(buf, "%ld\n", in_from_reg(data->in[index][nr], data->in_index[index])); }
static ssize_t show_pwm_auto_point_fan(struct device *dev, struct device_attribute *devattr, char* buf) { struct f71805f_data *data = dev_get_drvdata(dev); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); int pwmnr = attr->nr; int apnr = attr->index; return sprintf(buf, "%ld\n", fan_from_reg(data->auto_points[pwmnr].fan[apnr])); }
/* Function called on write access on in{0,1,2,3,4,5,6,7}_{min,max} */ static ssize_t max197_store_range(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count) { struct max197_data *data = dev_get_drvdata(dev); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); int channel = attr->index; bool is_min = attr->nr; long value; int half = data->limit / 2; int full = data->limit; if (kstrtol(buf, 10, &value)) return -EINVAL; if (is_min) { if (value <= -full) value = -full; else if (value < 0) value = -half; else value = 0; } else { if (value >= full) value = full; else value = half; } if (mutex_lock_interruptible(&data->lock)) return -ERESTARTSYS; if (value == 0) { /* We can deduce only the polarity */ max197_set_unipolarity(data, channel); } else if (value == -half) { max197_set_bipolarity(data, channel); max197_set_half_range(data, channel); } else if (value == -full) { max197_set_bipolarity(data, channel); max197_set_full_range(data, channel); } else if (value == half) { /* We can deduce only the range */ max197_set_half_range(data, channel); } else if (value == full) { /* We can deduce only the range */ max197_set_full_range(data, channel); } mutex_unlock(&data->lock); return count; }
static ssize_t show_bit(struct device *dev, struct device_attribute *attr, char *buf) { struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr); struct thermal_data *data = dev_get_drvdata(dev); int retval; retval = i2c_smbus_read_byte_data(data->client, sda->nr); if (retval < 0) return retval; return sprintf(buf, "%d\n", !!(retval & sda->index)); }
static ssize_t show_bit(struct device *dev, struct device_attribute *attr, char *buf) { struct i2c_client *client = to_i2c_client(dev); struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr); int retval = i2c_smbus_read_byte_data(client, sda->nr); if (retval < 0) return retval; retval &= sda->index; return sprintf(buf, "%d\n", retval ? 1 : 0); }
static ssize_t show_bank2_alarm(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = abituguru_update_device(dev); if (!data) return -EIO; if (data->alarms[2] & (0x01 << attr->index)) return sprintf(buf, "1\n"); else return sprintf(buf, "0\n"); }
/* * Show boolean, either a fault or an alarm. * .nr points to the register, .index is the bit mask to check */ static ssize_t pem_show_bool(struct device *dev, struct device_attribute *da, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da); struct pem_data *data = pem_update_device(dev); u8 status; if (IS_ERR(data)) return PTR_ERR(data); status = data->data_string[attr->nr] & attr->index; return snprintf(buf, PAGE_SIZE, "%d\n", !!status); }
static ssize_t show_pwm_sensor(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); int i; for (i = 0; i < data->bank1_sensors[ABIT_UGURU_TEMP_SENSOR]; i++) if (data->bank1_address[ABIT_UGURU_TEMP_SENSOR][i] == (data->pwm_settings[attr->index][0] & 0x0F)) return sprintf(buf, "%d\n", i+1); return -ENXIO; }
static ssize_t show_bank1_alarm(struct device *dev, struct device_attribute *devattr, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = abituguru_update_device(dev); if (!data) return -EIO; if ((data->alarms[attr->index / 8] & (0x01 << (attr->index % 8))) && (data->bank1_settings[attr->index][0] & attr->nr)) return sprintf(buf, "1\n"); else return sprintf(buf, "0\n"); }
static ssize_t store_pwm_setting(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); struct abituguru_data *data = dev_get_drvdata(dev); u8 min; unsigned long val; ssize_t ret; ret = kstrtoul(buf, 10, &val); if (ret) return ret; ret = count; val = (val + abituguru_pwm_settings_multiplier[attr->nr] / 2) / abituguru_pwm_settings_multiplier[attr->nr]; if ((attr->index == 0) && ((attr->nr == 1) || (attr->nr == 2))) min = 77; else min = abituguru_pwm_min[attr->nr]; if (val < min || val > abituguru_pwm_max[attr->nr]) return -EINVAL; mutex_lock(&data->update_lock); if ((attr->nr & 1) && (val >= data->pwm_settings[attr->index][attr->nr + 1])) ret = -EINVAL; else if (!(attr->nr & 1) && (val <= data->pwm_settings[attr->index][attr->nr - 1])) ret = -EINVAL; else if (data->pwm_settings[attr->index][attr->nr] != val) { u8 orig_val = data->pwm_settings[attr->index][attr->nr]; data->pwm_settings[attr->index][attr->nr] = val; if (abituguru_write(data, ABIT_UGURU_FAN_PWM + 1, attr->index, data->pwm_settings[attr->index], 5) <= attr->nr) { data->pwm_settings[attr->index][attr->nr] = orig_val; ret = -EIO; } } mutex_unlock(&data->update_lock); return ret; }
static ssize_t ltc4222_bool_show(struct device *dev, struct device_attribute *da, char *buf) { struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da); struct regmap *regmap = dev_get_drvdata(dev); unsigned int fault; int ret; ret = regmap_read(regmap, attr->nr, &fault); if (ret < 0) return ret; fault &= attr->index; if (fault) /* Clear reported faults in chip register */ regmap_update_bits(regmap, attr->nr, attr->index, 0); return snprintf(buf, PAGE_SIZE, "%d\n", !!fault); }
// Show input signal state value static ssize_t show_in(struct device *dev, struct device_attribute *attr, char *buf) { // struct dme1737_data *data = dme1737_update_device(dev); struct sensor_device_attribute_2 *sensor_attr_2 = to_sensor_dev_attr_2(attr); int ix = sensor_attr_2->index; int fn = sensor_attr_2->nr; // attribute function int res; if( ix > AUTOMOTIVE_TOTAL_INPUTS_NUM-1 || ix < 0 ){ return sprintf(buf, "in%d - NO HW SUPPORT\n", ix); } if (ix < AUTOMOTIVE_GPIO_MAX_INPUTS) { if (-1 == aio_data->pdata->gpio_in[ix]) { return sprintf(buf, "in%d - NO HW SUPPORT\n", ix); } } switch (fn) { case SYS_IN_INPUT: #if defined (CONFIG_MICRONET_MCU_GENERIC) if (ix >= AUTOMOTIVE_GPIO_MAX_INPUTS) {// MCU input case res = mic_mcu_get_input_value(ix - AUTOMOTIVE_GPIO_MAX_INPUTS) ^ aio_data->pdata->in_active_low[ix]; } else #endif { res = gpio_get_value(aio_data->pdata->gpio_in[ix]) ^ (aio_data->pdata->in_active_low[ix]); } break; case SYS_IN_DEBOUNCE: res = aio_data->debounce_time[ix]; break; case SYS_IN_ACTIVE_LOW: res = aio_data->pdata->in_active_low[ix]; break; default: res = 0; return printk("%s: Unknown function %d.\n", __func__, fn); } return sprintf(buf, "%d\n", res); }
static ssize_t set_pwm_auto_point_fan(struct device *dev, struct device_attribute *devattr, const char* buf, size_t count) { struct f71805f_data *data = dev_get_drvdata(dev); struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); int pwmnr = attr->nr; int apnr = attr->index; unsigned long val = simple_strtoul(buf, NULL, 10); mutex_lock(&data->update_lock); data->auto_points[pwmnr].fan[apnr] = fan_to_reg(val); f71805f_write16(data, F71805F_REG_PWM_AUTO_POINT_FAN(pwmnr, apnr), data->auto_points[pwmnr].fan[apnr]); mutex_unlock(&data->update_lock); return count; }
/* * Generic counter attributes */ static ssize_t ds1682_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); struct i2c_client *client = to_i2c_client(dev); unsigned long long val, check; __le32 val_le = 0; int rc; dev_dbg(dev, "ds1682_show() called on %s\n", attr->attr.name); /* Read the register */ rc = i2c_smbus_read_i2c_block_data(client, sattr->index, sattr->nr, (u8 *)&val_le); if (rc < 0) return -EIO; val = le32_to_cpu(val_le); if (sattr->index == DS1682_REG_ELAPSED) { int retries = 5; /* Detect and retry when a tick occurs mid-read */ do { rc = i2c_smbus_read_i2c_block_data(client, sattr->index, sattr->nr, (u8 *)&val_le); if (rc < 0 || retries <= 0) return -EIO; check = val; val = le32_to_cpu(val_le); retries--; } while (val != check && val != (check + 1)); } /* Format the output string and return # of bytes * Special case: the 32 bit regs are time values with 1/4s * resolution, scale them up to milliseconds */ return sprintf(buf, "%llu\n", (sattr->nr == 4) ? (val * 250) : val); }