static int mag3110_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct mag3110_data *data = iio_priv(indio_dev); __be16 buffer[3]; int i, ret; switch (mask) { case IIO_CHAN_INFO_RAW: if (iio_buffer_enabled(indio_dev)) return -EBUSY; switch (chan->type) { case IIO_MAGN: /* in 0.1 uT / LSB */ ret = mag3110_read(data, buffer); if (ret < 0) return ret; *val = sign_extend32( be16_to_cpu(buffer[chan->scan_index]), 15); return IIO_VAL_INT; case IIO_TEMP: /* in 1 C / LSB */ mutex_lock(&data->lock); ret = mag3110_request(data); if (ret < 0) { mutex_unlock(&data->lock); return ret; } ret = i2c_smbus_read_byte_data(data->client, MAG3110_DIE_TEMP); mutex_unlock(&data->lock); if (ret < 0) return ret; *val = sign_extend32(ret, 7); return IIO_VAL_INT; default: return -EINVAL; } case IIO_CHAN_INFO_SCALE: switch (chan->type) { case IIO_MAGN: *val = 0; *val2 = 1000; return IIO_VAL_INT_PLUS_MICRO; case IIO_TEMP: *val = 1000; return IIO_VAL_INT; default: return -EINVAL; } case IIO_CHAN_INFO_SAMP_FREQ: i = data->ctrl_reg1 >> MAG3110_CTRL_DR_SHIFT; *val = mag3110_samp_freq[i][0]; *val2 = mag3110_samp_freq[i][1]; return IIO_VAL_INT_PLUS_MICRO; } return -EINVAL; }
static int nau7802_read_conversion(struct nau7802_state *st) { int data; mutex_lock(&st->data_lock); data = i2c_smbus_read_byte_data(st->client, NAU7802_REG_ADC_B2); if (data < 0) goto nau7802_read_conversion_out; st->last_value = data << 16; data = i2c_smbus_read_byte_data(st->client, NAU7802_REG_ADC_B1); if (data < 0) goto nau7802_read_conversion_out; st->last_value |= data << 8; data = i2c_smbus_read_byte_data(st->client, NAU7802_REG_ADC_B0); if (data < 0) goto nau7802_read_conversion_out; st->last_value |= data; st->last_value = sign_extend32(st->last_value, 23); nau7802_read_conversion_out: mutex_unlock(&st->data_lock); return data; }
static int mma8452_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct mma8452_data *data = iio_priv(indio_dev); __be16 buffer[3]; int i, ret; switch (mask) { case IIO_CHAN_INFO_RAW: if (iio_buffer_enabled(indio_dev)) return -EBUSY; mutex_lock(&data->lock); ret = mma8452_read(data, buffer); mutex_unlock(&data->lock); if (ret < 0) return ret; *val = sign_extend32(be16_to_cpu( buffer[chan->scan_index]) >> chan->scan_type.shift, chan->scan_type.realbits - 1); return IIO_VAL_INT; case IIO_CHAN_INFO_SCALE: i = data->data_cfg & MMA8452_DATA_CFG_FS_MASK; *val = data->chip_info->mma_scales[i][0]; *val2 = data->chip_info->mma_scales[i][1]; return IIO_VAL_INT_PLUS_MICRO; case IIO_CHAN_INFO_SAMP_FREQ: i = mma8452_get_odr_index(data); *val = mma8452_samp_freq[i][0]; *val2 = mma8452_samp_freq[i][1]; return IIO_VAL_INT_PLUS_MICRO; case IIO_CHAN_INFO_CALIBBIAS: ret = i2c_smbus_read_byte_data(data->client, MMA8452_OFF_X + chan->scan_index); if (ret < 0) return ret; *val = sign_extend32(ret, 7); return IIO_VAL_INT; case IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY: if (data->data_cfg & MMA8452_DATA_CFG_HPF_MASK) { ret = mma8452_read_hp_filter(data, val, val2); if (ret < 0) return ret; } else { *val = 0; *val2 = 0; } return IIO_VAL_INT_PLUS_MICRO; } return -EINVAL; }
static int adxl345_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct adxl345_data *data = iio_priv(indio_dev); __le16 regval; int ret; switch (mask) { case IIO_CHAN_INFO_RAW: /* * Data is stored in adjacent registers: * ADXL345_REG_DATA(X0/Y0/Z0) contain the least significant byte * and ADXL345_REG_DATA(X0/Y0/Z0) + 1 the most significant byte */ ret = regmap_bulk_read(data->regmap, chan->address, ®val, sizeof(regval)); if (ret < 0) return ret; *val = sign_extend32(le16_to_cpu(regval), 12); return IIO_VAL_INT; case IIO_CHAN_INFO_SCALE: *val = 0; *val2 = adxl345_uscale; return IIO_VAL_INT_PLUS_MICRO; } return -EINVAL; }
static int ad7298_scan_temp(struct ad7298_state *st, int *val) { int ret; __be16 buf; buf = cpu_to_be16(AD7298_WRITE | AD7298_TSENSE | AD7298_TAVG | st->ext_ref); ret = spi_write(st->spi, (u8 *)&buf, 2); if (ret) return ret; buf = cpu_to_be16(0); ret = spi_write(st->spi, (u8 *)&buf, 2); if (ret) return ret; usleep_range(101, 1000); /* sleep > 100us */ ret = spi_read(st->spi, (u8 *)&buf, 2); if (ret) return ret; *val = sign_extend32(be16_to_cpu(buf), 11); return 0; }
static int dmard10_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct dmard10_data *data = iio_priv(indio_dev); __le16 buf[4]; int ret; switch (mask) { case IIO_CHAN_INFO_RAW: /* * Read 8 bytes starting at the REG_STADR register, trying to * read the individual X, Y, Z registers will always read 0. */ ret = i2c_smbus_read_i2c_block_data(data->client, DMARD10_REG_STADR, sizeof(buf), (u8 *)buf); if (ret < 0) return ret; ret = le16_to_cpu(buf[chan->address]); *val = sign_extend32(ret, 12); return IIO_VAL_INT; case IIO_CHAN_INFO_SCALE: *val = 0; *val2 = dmard10_nscale; return IIO_VAL_INT_PLUS_NANO; default: return -EINVAL; } }
/* Return the measurement value from the specified channel */ static int hmc5843_read_measurement(struct iio_dev *indio_dev, int address, int *val) { struct i2c_client *client = to_i2c_client(indio_dev->dev.parent); struct hmc5843_data *data = iio_priv(indio_dev); s32 result; int tries = 150; mutex_lock(&data->lock); while (tries-- > 0) { result = i2c_smbus_read_byte_data(client, HMC5843_STATUS_REG); if (result & HMC5843_DATA_READY) break; msleep(20); } if (tries < 0) { dev_err(&client->dev, "data not ready\n"); mutex_unlock(&data->lock); return -EIO; } result = i2c_smbus_read_word_swapped(client, address); mutex_unlock(&data->lock); if (result < 0) return -EINVAL; *val = sign_extend32(result, 15); return IIO_VAL_INT; }
static int mma7455_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct mma7455_data *mma7455 = iio_priv(indio_dev); unsigned int reg; __le16 data; int ret; switch (mask) { case IIO_CHAN_INFO_RAW: if (iio_buffer_enabled(indio_dev)) return -EBUSY; ret = mma7455_drdy(mma7455); if (ret) return ret; ret = regmap_bulk_read(mma7455->regmap, chan->address, &data, sizeof(data)); if (ret) return ret; *val = sign_extend32(le16_to_cpu(data), 9); return IIO_VAL_INT; case IIO_CHAN_INFO_SCALE: *val = 0; *val2 = MMA7455_10BIT_SCALE; return IIO_VAL_INT_PLUS_MICRO; case IIO_CHAN_INFO_SAMP_FREQ: ret = regmap_read(mma7455->regmap, MMA7455_REG_CTL1, ®); if (ret) return ret; if (reg & MMA7455_CTL1_DFBW_MASK) *val = 250; else *val = 125; return IIO_VAL_INT; } return -EINVAL; }
static int uniphier_tm_get_temp(void *data, int *out_temp) { struct uniphier_tm_dev *tdev = data; struct regmap *map = tdev->regmap; int ret; u32 temp; ret = regmap_read(map, tdev->data->map_base + TMOD, &temp); if (ret) return ret; /* MSB of the TMOD field is a sign bit */ *out_temp = sign_extend32(temp, TMOD_WIDTH - 1) * 1000; return 0; }
static int pcf2123_read_offset(struct device *dev, long *offset) { int ret; s8 reg; ret = pcf2123_read(dev, PCF2123_REG_OFFSET, ®, 1); if (ret < 0) return ret; if (reg & OFFSET_COARSE) reg <<= 1; /* multiply by 2 and sign extend */ else reg = sign_extend32(reg, OFFSET_SIGN_BIT); *offset = ((long)reg) * OFFSET_STEP; return 0; }
static inline void adjust_pc(struct pt_regs *regs, unsigned long address) { int displacement; unsigned int rb, op, jmp; if (unlikely(in_delay_slot(regs))) { /* In delay slot, instruction at pc is a branch, simulate it */ jmp = *((unsigned int *)regs->pc); displacement = sign_extend32(((jmp) & 0x3ffffff) << 2, 27); rb = (jmp & 0x0000ffff) >> 11; op = jmp >> 26; switch (op) { case 0x00: /* l.j */ regs->pc += displacement; return; case 0x01: /* l.jal */ regs->pc += displacement; regs->gpr[9] = regs->pc + 8; return; case 0x03: /* l.bnf */ if (regs->sr & SPR_SR_F) regs->pc += 8; else regs->pc += displacement; return; case 0x04: /* l.bf */ if (regs->sr & SPR_SR_F) regs->pc += displacement; else regs->pc += 8; return; case 0x11: /* l.jr */ regs->pc = regs->gpr[rb]; return; case 0x12: /* l.jalr */ regs->pc = regs->gpr[rb]; regs->gpr[9] = regs->pc + 8; return; default: break; } } else {
static int mma8452_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct mma8452_data *data = iio_priv(indio_dev); __be16 buffer[3]; int i, ret; switch (mask) { case IIO_CHAN_INFO_RAW: if (iio_buffer_enabled(indio_dev)) return -EBUSY; mutex_lock(&data->lock); ret = mma8452_read(data, buffer); mutex_unlock(&data->lock); if (ret < 0) return ret; *val = sign_extend32( be16_to_cpu(buffer[chan->scan_index]) >> 4, 11); return IIO_VAL_INT; case IIO_CHAN_INFO_SCALE: i = data->data_cfg & MMA8452_DATA_CFG_FS_MASK; *val = mma8452_scales[i][0]; *val2 = mma8452_scales[i][1]; return IIO_VAL_INT_PLUS_MICRO; case IIO_CHAN_INFO_SAMP_FREQ: i = (data->ctrl_reg1 & MMA8452_CTRL_DR_MASK) >> MMA8452_CTRL_DR_SHIFT; *val = mma8452_samp_freq[i][0]; *val2 = mma8452_samp_freq[i][1]; return IIO_VAL_INT_PLUS_MICRO; case IIO_CHAN_INFO_CALIBBIAS: ret = i2c_smbus_read_byte_data(data->client, MMA8452_OFF_X + chan->scan_index); if (ret < 0) return ret; *val = sign_extend32(ret, 7); return IIO_VAL_INT; } return -EINVAL; }
static ssize_t show_power(struct device *dev, struct device_attribute *attr, char *buf) { u32 val, tdp_limit, running_avg_range; s32 running_avg_capture; u64 curr_pwr_watts; struct fam15h_power_data *data = dev_get_drvdata(dev); struct pci_dev *f4 = data->pdev; pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 5), REG_TDP_RUNNING_AVERAGE, &val); /* * On Carrizo and later platforms, TdpRunAvgAccCap bit field * is extended to 4:31 from 4:25. */ if (is_carrizo_or_later()) { running_avg_capture = val >> 4; running_avg_capture = sign_extend32(running_avg_capture, 27); } else {
/* Return the measurement value from the specified channel */ static int hmc5843_read_measurement(struct hmc5843_data *data, int idx, int *val) { s32 result; __be16 values[3]; mutex_lock(&data->lock); result = hmc5843_wait_measurement(data); if (result < 0) { mutex_unlock(&data->lock); return result; } result = i2c_smbus_read_i2c_block_data(data->client, HMC5843_DATA_OUT_MSB_REGS, sizeof(values), (u8 *) values); mutex_unlock(&data->lock); if (result < 0) return -EINVAL; *val = sign_extend32(be16_to_cpu(values[idx]), 15); return IIO_VAL_INT; }
static int mcp3422_read(struct mcp3422 *adc, int *value, u8 *config) { int ret = 0; u8 sample_rate = MCP3422_SAMPLE_RATE(adc->config); u8 buf[4] = {0, 0, 0, 0}; u32 temp; if (sample_rate == MCP3422_SRATE_3) { ret = i2c_master_recv(adc->i2c, buf, 4); temp = buf[0] << 16 | buf[1] << 8 | buf[2]; *config = buf[3]; } else { ret = i2c_master_recv(adc->i2c, buf, 3); temp = buf[0] << 8 | buf[1]; *config = buf[2]; } *value = sign_extend32(temp, mcp3422_sign_extend[sample_rate]); return ret; }
/* Return the measurement value from the specified channel */ static int hmc5843_read_measurement(struct hmc5843_data *data, int idx, int *val) { __be16 values[3]; int ret; mutex_lock(&data->lock); ret = hmc5843_wait_measurement(data); if (ret < 0) { mutex_unlock(&data->lock); return ret; } ret = regmap_bulk_read(data->regmap, HMC5843_DATA_OUT_MSB_REGS, values, sizeof(values)); mutex_unlock(&data->lock); if (ret < 0) return ret; *val = sign_extend32(be16_to_cpu(values[idx]), 15); return IIO_VAL_INT; }
static int mc3230_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct mc3230_data *data = iio_priv(indio_dev); int ret; switch (mask) { case IIO_CHAN_INFO_RAW: ret = i2c_smbus_read_byte_data(data->client, chan->address); if (ret < 0) return ret; *val = sign_extend32(ret, 7); return IIO_VAL_INT; case IIO_CHAN_INFO_SCALE: *val = 0; *val2 = mc3230_nscale; return IIO_VAL_INT_PLUS_NANO; default: return -EINVAL; } }
static int adis16136_read_raw(struct iio_dev *indio_dev, const struct iio_chan_spec *chan, int *val, int *val2, long info) { struct adis16136 *adis16136 = iio_priv(indio_dev); uint32_t val32; int ret; switch (info) { case IIO_CHAN_INFO_RAW: return adis_single_conversion(indio_dev, chan, 0, val); case IIO_CHAN_INFO_SCALE: switch (chan->type) { case IIO_ANGL_VEL: *val = adis16136->chip_info->precision; *val2 = (adis16136->chip_info->fullscale << 16); return IIO_VAL_FRACTIONAL; case IIO_TEMP: *val = 10; *val2 = 697000; /* 0.010697 degree Celsius */ return IIO_VAL_INT_PLUS_MICRO; default: return -EINVAL; } case IIO_CHAN_INFO_CALIBBIAS: ret = adis_read_reg_32(&adis16136->adis, ADIS16136_REG_GYRO_OFF2, &val32); if (ret < 0) return ret; *val = sign_extend32(val32, 31); return IIO_VAL_INT; case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: return adis16136_get_filter(indio_dev, val); default: return -EINVAL; } }
/***************************************************************************//** * @brief Reads data from the AD9122. * * @return Returns negative error code or 0 in case of success. *******************************************************************************/ uint32_t ad9122_show(uint32_t address, int32_t* val) { int32_t ret = 0; ret = ad9122_read((uint32_t)address); if (ret < 0) goto out; *val = ret << 8; ret = ad9122_read((uint32_t)address - 1); if (ret < 0) goto out; *val |= ret & 0xFF; switch ((uint32_t)address) { case AD9122_REG_I_PHA_ADJ_MSB: case AD9122_REG_Q_PHA_ADJ_MSB: *val = sign_extend32(*val, 9); break; } out: return ret; }
static int adis16400_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long info) { struct adis16400_state *st = iio_priv(indio_dev); int16_t val16; int ret; switch (info) { case IIO_CHAN_INFO_RAW: return adis_single_conversion(indio_dev, chan, 0, val); case IIO_CHAN_INFO_SCALE: switch (chan->type) { case IIO_ANGL_VEL: *val = 0; *val2 = st->variant->gyro_scale_micro; return IIO_VAL_INT_PLUS_MICRO; case IIO_VOLTAGE: *val = 0; if (chan->channel == 0) { *val = 2; *val2 = 418000; /* 2.418 mV */ } else { *val = 0; *val2 = 805800; /* 805.8 uV */ } return IIO_VAL_INT_PLUS_MICRO; case IIO_ACCEL: *val = 0; *val2 = st->variant->accel_scale_micro; return IIO_VAL_INT_PLUS_MICRO; case IIO_MAGN: *val = 0; *val2 = 500; /* 0.5 mgauss */ return IIO_VAL_INT_PLUS_MICRO; case IIO_TEMP: *val = st->variant->temp_scale_nano / 1000000; *val2 = (st->variant->temp_scale_nano % 1000000); return IIO_VAL_INT_PLUS_MICRO; case IIO_PRESSURE: /* 20 uBar = 0.002kPascal */ *val = 0; *val2 = 2000; return IIO_VAL_INT_PLUS_MICRO; default: return -EINVAL; } case IIO_CHAN_INFO_CALIBBIAS: mutex_lock(&indio_dev->mlock); ret = adis_read_reg_16(&st->adis, adis16400_addresses[chan->scan_index], &val16); mutex_unlock(&indio_dev->mlock); if (ret) return ret; val16 = sign_extend32(val16, 11); *val = val16; return IIO_VAL_INT; case IIO_CHAN_INFO_OFFSET: /* currently only temperature */ *val = st->variant->temp_offset; return IIO_VAL_INT; case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY: mutex_lock(&indio_dev->mlock); /* Need both the number of taps and the sampling frequency */ ret = adis_read_reg_16(&st->adis, ADIS16400_SENS_AVG, &val16); if (ret < 0) { mutex_unlock(&indio_dev->mlock); return ret; } ret = st->variant->get_freq(st); if (ret >= 0) { ret /= adis16400_3db_divisors[val16 & 0x07]; *val = ret / 1000; *val2 = (ret % 1000) * 1000; } mutex_unlock(&indio_dev->mlock); if (ret < 0) return ret; return IIO_VAL_INT_PLUS_MICRO; case IIO_CHAN_INFO_SAMP_FREQ: ret = st->variant->get_freq(st); if (ret < 0) return ret; *val = ret / 1000; *val2 = (ret % 1000) * 1000; return IIO_VAL_INT_PLUS_MICRO; default: return -EINVAL; } }
static int adis16260_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct adis *adis = iio_priv(indio_dev); int ret; u8 addr; s16 val16; switch (mask) { case IIO_CHAN_INFO_RAW: return adis_single_conversion(indio_dev, chan, ADIS16260_ERROR_ACTIVE, val); case IIO_CHAN_INFO_SCALE: switch (chan->type) { case IIO_ANGL_VEL: *val = 0; if (spi_get_device_id(adis->spi)->driver_data) { /* 0.01832 degree / sec */ *val2 = IIO_DEGREE_TO_RAD(18320); } else { /* 0.07326 degree / sec */ *val2 = IIO_DEGREE_TO_RAD(73260); } return IIO_VAL_INT_PLUS_MICRO; case IIO_INCLI: *val = 0; *val2 = IIO_DEGREE_TO_RAD(36630); return IIO_VAL_INT_PLUS_MICRO; case IIO_VOLTAGE: if (chan->channel == 0) { *val = 1; *val2 = 831500; /* 1.8315 mV */ } else { *val = 0; *val2 = 610500; /* 610.5 uV */ } return IIO_VAL_INT_PLUS_MICRO; case IIO_TEMP: *val = 145; *val2 = 300000; /* 0.1453 C */ return IIO_VAL_INT_PLUS_MICRO; default: return -EINVAL; } case IIO_CHAN_INFO_OFFSET: *val = 250000 / 1453; /* 25 C = 0x00 */ return IIO_VAL_INT; case IIO_CHAN_INFO_CALIBBIAS: addr = adis16260_addresses[chan->scan_index][0]; ret = adis_read_reg_16(adis, addr, &val16); if (ret) return ret; *val = sign_extend32(val16, 11); return IIO_VAL_INT; case IIO_CHAN_INFO_CALIBSCALE: addr = adis16260_addresses[chan->scan_index][1]; ret = adis_read_reg_16(adis, addr, &val16); if (ret) return ret; *val = val16; return IIO_VAL_INT; case IIO_CHAN_INFO_SAMP_FREQ: ret = adis_read_reg_16(adis, ADIS16260_SMPL_PRD, &val16); if (ret) return ret; if (spi_get_device_id(adis->spi)->driver_data) /* If an adis16251 */ *val = (val16 & ADIS16260_SMPL_PRD_TIME_BASE) ? 8 : 256; else *val = (val16 & ADIS16260_SMPL_PRD_TIME_BASE) ? 66 : 2048; *val /= (val16 & ADIS16260_SMPL_PRD_DIV_MASK) + 1; return IIO_VAL_INT; } return -EINVAL; }
static int ep93xx_read_raw(struct iio_dev *iiodev, struct iio_chan_spec const *channel, int *value, int *shift, long mask) { struct ep93xx_adc_priv *priv = iio_priv(iiodev); unsigned long timeout; int ret; switch (mask) { case IIO_CHAN_INFO_RAW: mutex_lock(&priv->lock); if (priv->lastch != channel->channel) { priv->lastch = channel->channel; /* * Switch register is software-locked, unlocking must be * immediately followed by write */ local_irq_disable(); writel_relaxed(0xAA, priv->base + EP93XX_ADC_SW_LOCK); writel_relaxed(channel->address, priv->base + EP93XX_ADC_SWITCH); local_irq_enable(); /* * Settling delay depends on module clock and could be * 2ms or 500us */ ep93xx_adc_delay(2000, 2000); } /* Start the conversion, eventually discarding old result */ readl_relaxed(priv->base + EP93XX_ADC_RESULT); /* Ensure maximum conversion rate is not exceeded */ ep93xx_adc_delay(DIV_ROUND_UP(1000000, 925), DIV_ROUND_UP(1000000, 925)); /* At this point conversion must be completed, but anyway... */ ret = IIO_VAL_INT; timeout = jiffies + msecs_to_jiffies(1) + 1; while (1) { u32 t; t = readl_relaxed(priv->base + EP93XX_ADC_RESULT); if (t & EP93XX_ADC_SDR) { *value = sign_extend32(t, 15); break; } if (time_after(jiffies, timeout)) { dev_err(&iiodev->dev, "Conversion timeout\n"); ret = -ETIMEDOUT; break; } cpu_relax(); } mutex_unlock(&priv->lock); return ret; case IIO_CHAN_INFO_OFFSET: /* According to datasheet, range is -25000..25000 */ *value = 25000; return IIO_VAL_INT; case IIO_CHAN_INFO_SCALE: /* Typical supply voltage is 3.3v */ *value = (1ULL << 32) * 3300 / 50000; *shift = 32; return IIO_VAL_FRACTIONAL_LOG2; } return -EINVAL; }
static int ltc2990_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *channel, int *val, int *val2, long mask) { struct ltc2990_data *data = iio_priv(indio_dev); int ret = -EINVAL; u8 address; int tries = 10; mutex_lock(&indio_dev->mlock); switch (mask) { case IIO_CHAN_INFO_RAW: switch (channel->type) { case IIO_TEMP: switch (channel->channel) { case 0: address = LTC2990_REG_TINT_MSB; break; case 1: address = LTC2990_REG_V1_V1V2_TR1_MSB; break; case 2: address = LTC2990_REG_V3_V3V4_TR2_MSB; break; default: break; } while (tries-- > 0) { ret = i2c_smbus_read_word_swapped(data->client, address); if (ret & LTC2990_TEMPERATURE_DATA_VALID) { break; } msleep(167); } if (tries < 0) { printk(KERN_ERR "Data valid bit unset even after multiple tries, giving up.\n"); ret = -EIO; goto out; } if (ret & LTC2990_TEMPERATURE_SENSOR_OPEN) { printk(KERN_ERR "Sensor connection broken, wire open.\n"); ret = -EIO; } else if (ret & LTC2990_TEMPERATURE_SENSOR_SHORT) { printk(KERN_ERR "Sensor connection broken, wire shorted.\n"); ret = -EIO; } else { *val = sign_extend32((ret & 0x1FFF), 12); ret = IIO_VAL_INT; } break; case IIO_VOLTAGE: while (tries-- > 0) { ret = i2c_smbus_read_word_swapped(data->client, LTC2990_REG_VCC_MSB); if (ret & LTC2990_VOLTAGE_DATA_VALID) { break; } msleep(200); } if (tries < 0) { printk(KERN_ERR "Data valid bit unset even after multiple tries, giving up.\n"); ret = -EIO; goto out; } *val = (ret & 0x3FFF); ret = IIO_VAL_INT; break; default: break; } break; case IIO_CHAN_INFO_OFFSET: switch (channel->type) { case IIO_TEMP: *val = 0; ret = IIO_VAL_INT; break; case IIO_VOLTAGE: if (channel->datasheet_name == "vcc") { *val = 250000000; *val2 = 30518; ret = IIO_VAL_FRACTIONAL; } else { *val = 0; ret = IIO_VAL_INT; } break; default: break; } break; case IIO_CHAN_INFO_SCALE: switch (channel->type) { case IIO_TEMP: *val = 62; *val2 = 500000; ret = IIO_VAL_INT_PLUS_MICRO; break; case IIO_VOLTAGE: if (channel->datasheet_name == "vcc") { *val = 0; *val2 = 305180; } else { *val = 0; *val2 = 305180; // Valid for single-ended measurements only, else 19420 } ret = IIO_VAL_INT_PLUS_MICRO; break; default: break; } break; default: break; } out: mutex_unlock(&indio_dev->mlock); return ret; }
static int adxl345_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct adxl345_data *data = iio_priv(indio_dev); __le16 accel; long long samp_freq_nhz; unsigned int regval; int ret; switch (mask) { case IIO_CHAN_INFO_RAW: /* * Data is stored in adjacent registers: * ADXL345_REG_DATA(X0/Y0/Z0) contain the least significant byte * and ADXL345_REG_DATA(X0/Y0/Z0) + 1 the most significant byte */ ret = regmap_bulk_read(data->regmap, ADXL345_REG_DATA_AXIS(chan->address), &accel, sizeof(accel)); if (ret < 0) return ret; *val = sign_extend32(le16_to_cpu(accel), 12); return IIO_VAL_INT; case IIO_CHAN_INFO_SCALE: *val = 0; switch (data->type) { case ADXL345: *val2 = adxl345_uscale; break; case ADXL375: *val2 = adxl375_uscale; break; } return IIO_VAL_INT_PLUS_MICRO; case IIO_CHAN_INFO_CALIBBIAS: ret = regmap_read(data->regmap, ADXL345_REG_OFS_AXIS(chan->address), ®val); if (ret < 0) return ret; /* * 8-bit resolution at +/- 2g, that is 4x accel data scale * factor */ *val = sign_extend32(regval, 7) * 4; return IIO_VAL_INT; case IIO_CHAN_INFO_SAMP_FREQ: ret = regmap_read(data->regmap, ADXL345_REG_BW_RATE, ®val); if (ret < 0) return ret; samp_freq_nhz = ADXL345_BASE_RATE_NANO_HZ << (regval & ADXL345_BW_RATE); *val = div_s64_rem(samp_freq_nhz, NHZ_PER_HZ, val2); return IIO_VAL_INT_PLUS_NANO; } return -EINVAL; }
struct fam15h_power_data *data = dev_get_drvdata(dev); struct pci_dev *f4 = data->pdev; pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 5), REG_TDP_RUNNING_AVERAGE, &val); /* * On Carrizo and later platforms, TdpRunAvgAccCap bit field * is extended to 4:31 from 4:25. */ if (is_carrizo_or_later()) { running_avg_capture = val >> 4; running_avg_capture = sign_extend32(running_avg_capture, 27); } else { running_avg_capture = (val >> 4) & 0x3fffff; running_avg_capture = sign_extend32(running_avg_capture, 21); } running_avg_range = (val & 0xf) + 1; pci_bus_read_config_dword(f4->bus, PCI_DEVFN(PCI_SLOT(f4->devfn), 5), REG_TDP_LIMIT3, &val); /* * On Carrizo and later platforms, ApmTdpLimit bit field * is extended to 16:31 from 16:28. */ if (is_carrizo_or_later()) tdp_limit = val >> 16; else tdp_limit = (val >> 16) & 0x1fff;
static int adis16209_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct adis *st = iio_priv(indio_dev); int ret; int bits; u8 addr; s16 val16; switch (mask) { case IIO_CHAN_INFO_RAW: return adis_single_conversion(indio_dev, chan, ADIS16209_ERROR_ACTIVE, val); case IIO_CHAN_INFO_SCALE: switch (chan->type) { case IIO_VOLTAGE: *val = 0; switch (chan->channel) { case 0: *val2 = 305180; /* 0.30518 mV */ break; case 1: *val2 = 610500; /* 0.6105 mV */ break; default: return -EINVAL; } return IIO_VAL_INT_PLUS_MICRO; case IIO_TEMP: *val = -470; *val2 = 0; return IIO_VAL_INT_PLUS_MICRO; case IIO_ACCEL: /* * IIO base unit for sensitivity of accelerometer * is milli g. * 1 LSB represents 0.244 mg. */ *val = 0; *val2 = IIO_G_TO_M_S_2(244140); return IIO_VAL_INT_PLUS_NANO; case IIO_INCLI: case IIO_ROT: /* * IIO base units for rotation are degrees. * 1 LSB represents 0.025 milli degrees. */ *val = 0; *val2 = 25000; return IIO_VAL_INT_PLUS_MICRO; default: return -EINVAL; } break; case IIO_CHAN_INFO_OFFSET: /* * The raw ADC value is 0x4FE when the temperature * is 25 degrees and the scale factor per milli * degree celcius is -470. */ *val = 25000 / -470 - 0x4FE; return IIO_VAL_INT; case IIO_CHAN_INFO_CALIBBIAS: switch (chan->type) { case IIO_ACCEL: bits = 14; break; default: return -EINVAL; } addr = adis16209_addresses[chan->scan_index][0]; ret = adis_read_reg_16(st, addr, &val16); if (ret) return ret; *val = sign_extend32(val16, bits - 1); return IIO_VAL_INT; } return -EINVAL; }
/* * URB callback routine. Called when we get IRQ reports from the * digitizer. * * This bridges the USB and input device worlds. It generates events * on the input device based on the USB reports. */ static void gtco_urb_callback(struct urb *urbinfo) { struct gtco *device = urbinfo->context; struct input_dev *inputdev; int rc; u32 val = 0; char le_buffer[2]; inputdev = device->inputdevice; /* Was callback OK? */ if (urbinfo->status == -ECONNRESET || urbinfo->status == -ENOENT || urbinfo->status == -ESHUTDOWN) { /* Shutdown is occurring. Return and don't queue up any more */ return; } if (urbinfo->status != 0) { /* * Some unknown error. Hopefully temporary. Just go and * requeue an URB */ goto resubmit; } /* * Good URB, now process */ /* PID dependent when we interpret the report */ if (inputdev->id.product == PID_1000 || inputdev->id.product == PID_1001 || inputdev->id.product == PID_1002) { /* * Switch on the report ID * Conveniently, the reports have more information, the higher * the report number. We can just fall through the case * statements if we start with the highest number report */ switch (device->buffer[0]) { case 5: /* Pressure is 9 bits */ val = ((u16)(device->buffer[8]) << 1); val |= (u16)(device->buffer[7] >> 7); input_report_abs(inputdev, ABS_PRESSURE, device->buffer[8]); /* Mask out the Y tilt value used for pressure */ device->buffer[7] = (u8)((device->buffer[7]) & 0x7F); /* Fall thru */ case 4: /* Tilt */ input_report_abs(inputdev, ABS_TILT_X, sign_extend32(device->buffer[6], 6)); input_report_abs(inputdev, ABS_TILT_Y, sign_extend32(device->buffer[7], 6)); /* Fall thru */ case 2: case 3: /* Convert buttons, only 5 bits possible */ val = (device->buffer[5]) & MASK_BUTTON; /* We don't apply any meaning to the bitmask, just report */ input_event(inputdev, EV_MSC, MSC_SERIAL, val); /* Fall thru */ case 1: /* All reports have X and Y coords in the same place */ val = get_unaligned_le16(&device->buffer[1]); input_report_abs(inputdev, ABS_X, val); val = get_unaligned_le16(&device->buffer[3]); input_report_abs(inputdev, ABS_Y, val); /* Ditto for proximity bit */ val = device->buffer[5] & MASK_INRANGE ? 1 : 0; input_report_abs(inputdev, ABS_DISTANCE, val); /* Report 1 is an exception to how we handle buttons */ /* Buttons are an index, not a bitmask */ if (device->buffer[0] == 1) { /* * Convert buttons, 5 bit index * Report value of index set as one, * the rest as 0 */ val = device->buffer[5] & MASK_BUTTON; dev_dbg(&device->intf->dev, "======>>>>>>REPORT 1: val 0x%X(%d)\n", val, val); /* * We don't apply any meaning to the button * index, just report it */ input_event(inputdev, EV_MSC, MSC_SERIAL, val); } break; case 7: /* Menu blocks */ input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]); break; } } /* Other pid class */ if (inputdev->id.product == PID_400 || inputdev->id.product == PID_401) { /* Report 2 */ if (device->buffer[0] == 2) { /* Menu blocks */ input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]); } /* Report 1 */ if (device->buffer[0] == 1) { char buttonbyte; /* IF X max > 64K, we still a bit from the y report */ if (device->max_X > 0x10000) { val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]); val |= (u32)(((u8)device->buffer[3] & 0x1) << 16); input_report_abs(inputdev, ABS_X, val); le_buffer[0] = (u8)((u8)(device->buffer[3]) >> 1); le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7); le_buffer[1] = (u8)(device->buffer[4] >> 1); le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7); val = get_unaligned_le16(le_buffer); input_report_abs(inputdev, ABS_Y, val); /* * Shift the button byte right by one to * make it look like the standard report */ buttonbyte = device->buffer[5] >> 1; } else {
static int hp206c_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { int ret; struct hp206c_data *data = iio_priv(indio_dev); const struct hp206c_osr_setting *osr_setting; u8 conv_cmd; mutex_lock(&data->mutex); switch (mask) { case IIO_CHAN_INFO_OVERSAMPLING_RATIO: switch (chan->type) { case IIO_TEMP: *val = hp206c_osr_rates[data->temp_osr_index]; ret = IIO_VAL_INT; break; case IIO_PRESSURE: *val = hp206c_osr_rates[data->pres_osr_index]; ret = IIO_VAL_INT; break; default: ret = -EINVAL; } break; case IIO_CHAN_INFO_RAW: switch (chan->type) { case IIO_TEMP: osr_setting = &hp206c_osr_settings[data->temp_osr_index]; conv_cmd = HP206C_CMD_ADC_CVT | osr_setting->osr_mask | HP206C_CMD_ADC_CVT_CHNL_T; ret = hp206c_conv_and_read(indio_dev, conv_cmd, HP206C_CMD_READ_T, osr_setting->temp_conv_time_us); if (ret >= 0) { /* 20 significant bits are provided. * Extend sign over the rest. */ *val = sign_extend32(ret, 19); ret = IIO_VAL_INT; } break; case IIO_PRESSURE: osr_setting = &hp206c_osr_settings[data->pres_osr_index]; conv_cmd = HP206C_CMD_ADC_CVT | osr_setting->osr_mask | HP206C_CMD_ADC_CVT_CHNL_PT; ret = hp206c_conv_and_read(indio_dev, conv_cmd, HP206C_CMD_READ_P, osr_setting->pres_conv_time_us); if (ret >= 0) { *val = ret; ret = IIO_VAL_INT; } break; default: ret = -EINVAL; } break; case IIO_CHAN_INFO_SCALE: switch (chan->type) { case IIO_TEMP: *val = 0; *val2 = 10000; ret = IIO_VAL_INT_PLUS_MICRO; break; case IIO_PRESSURE: *val = 0; *val2 = 1000; ret = IIO_VAL_INT_PLUS_MICRO; break; default: ret = -EINVAL; } break; default: ret = -EINVAL; } mutex_unlock(&data->mutex); return ret; }