static int ltr501_read_thresh(struct iio_dev *indio_dev, const struct iio_chan_spec *chan, enum iio_event_type type, enum iio_event_direction dir, enum iio_event_info info, int *val, int *val2) { struct ltr501_data *data = iio_priv(indio_dev); int ret, thresh_data; switch (chan->type) { case IIO_INTENSITY: switch (dir) { case IIO_EV_DIR_RISING: ret = regmap_bulk_read(data->regmap, LTR501_ALS_THRESH_UP, &thresh_data, 2); if (ret < 0) return ret; *val = thresh_data & LTR501_ALS_THRESH_MASK; return IIO_VAL_INT; case IIO_EV_DIR_FALLING: ret = regmap_bulk_read(data->regmap, LTR501_ALS_THRESH_LOW, &thresh_data, 2); if (ret < 0) return ret; *val = thresh_data & LTR501_ALS_THRESH_MASK; return IIO_VAL_INT; default: return -EINVAL; } case IIO_PROXIMITY: switch (dir) { case IIO_EV_DIR_RISING: ret = regmap_bulk_read(data->regmap, LTR501_PS_THRESH_UP, &thresh_data, 2); if (ret < 0) return ret; *val = thresh_data & LTR501_PS_THRESH_MASK; return IIO_VAL_INT; case IIO_EV_DIR_FALLING: ret = regmap_bulk_read(data->regmap, LTR501_PS_THRESH_LOW, &thresh_data, 2); if (ret < 0) return ret; *val = thresh_data & LTR501_PS_THRESH_MASK; return IIO_VAL_INT; default: return -EINVAL; } default: return -EINVAL; } return -EINVAL; }
static irqreturn_t ltr501_trigger_handler(int irq, void *p) { struct iio_poll_func *pf = p; struct iio_dev *indio_dev = pf->indio_dev; struct ltr501_data *data = iio_priv(indio_dev); u16 buf[8]; __le16 als_buf[2]; u8 mask = 0; int j = 0; int ret, psdata; memset(buf, 0, sizeof(buf)); /* figure out which data needs to be ready */ if (test_bit(0, indio_dev->active_scan_mask) || test_bit(1, indio_dev->active_scan_mask)) mask |= LTR501_STATUS_ALS_RDY; if (test_bit(2, indio_dev->active_scan_mask)) mask |= LTR501_STATUS_PS_RDY; ret = ltr501_drdy(data, mask); if (ret < 0) goto done; if (mask & LTR501_STATUS_ALS_RDY) { ret = regmap_bulk_read(data->regmap, LTR501_ALS_DATA1, (u8 *)als_buf, sizeof(als_buf)); if (ret < 0) return ret; if (test_bit(0, indio_dev->active_scan_mask)) buf[j++] = le16_to_cpu(als_buf[1]); if (test_bit(1, indio_dev->active_scan_mask)) buf[j++] = le16_to_cpu(als_buf[0]); } if (mask & LTR501_STATUS_PS_RDY) { ret = regmap_bulk_read(data->regmap, LTR501_PS_DATA, &psdata, 2); if (ret < 0) goto done; buf[j++] = psdata & LTR501_PS_DATA_MASK; } iio_push_to_buffers_with_timestamp(indio_dev, buf, iio_get_time_ns(indio_dev)); done: iio_trigger_notify_done(indio_dev->trig); return IRQ_HANDLED; }
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; }
/** * mpu3050_read_mem() - read MPU-3050 internal memory * @mpu3050: device to read from * @bank: target bank * @addr: target address * @len: number of bytes * @buf: the buffer to store the read bytes in */ static int mpu3050_read_mem(struct mpu3050 *mpu3050, u8 bank, u8 addr, u8 len, u8 *buf) { int ret; ret = regmap_write(mpu3050->map, MPU3050_BANK_SEL, bank); if (ret) return ret; ret = regmap_write(mpu3050->map, MPU3050_MEM_START_ADDR, addr); if (ret) return ret; return regmap_bulk_read(mpu3050->map, MPU3050_MEM_R_W, buf, len); }
/* Read alarm time and date in RTC */ static int rk808_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm) { struct rk808_rtc *rk808_rtc = dev_get_drvdata(dev); struct rk808 *rk808 = rk808_rtc->rk808; u8 alrm_data[NUM_ALARM_REGS]; uint32_t int_reg; int ret; ret = regmap_bulk_read(rk808->regmap, RK808_ALARM_SECONDS_REG, alrm_data, NUM_ALARM_REGS); alrm->time.tm_sec = bcd2bin(alrm_data[0] & SECONDS_REG_MSK); alrm->time.tm_min = bcd2bin(alrm_data[1] & MINUTES_REG_MAK); alrm->time.tm_hour = bcd2bin(alrm_data[2] & HOURS_REG_MSK); alrm->time.tm_mday = bcd2bin(alrm_data[3] & DAYS_REG_MSK); alrm->time.tm_mon = (bcd2bin(alrm_data[4] & MONTHS_REG_MSK)) - 1; alrm->time.tm_year = (bcd2bin(alrm_data[5] & YEARS_REG_MSK)) + 100; rockchip_to_gregorian(&alrm->time); ret = regmap_read(rk808->regmap, RK808_RTC_INT_REG, &int_reg); if (ret) { dev_err(dev, "Failed to read RTC INT REG: %d\n", ret); return ret; } dev_dbg(dev, "alrm read RTC date/time %4d-%02d-%02d(%d) %02d:%02d:%02d\n", 1900 + alrm->time.tm_year, alrm->time.tm_mon + 1, alrm->time.tm_mday, alrm->time.tm_wday, alrm->time.tm_hour, alrm->time.tm_min, alrm->time.tm_sec); alrm->enabled = (int_reg & BIT_RTC_INTERRUPTS_REG_IT_ALARM_M) ? 1 : 0; return 0; }
static irqreturn_t mma7455_trigger_handler(int irq, void *p) { struct iio_poll_func *pf = p; struct iio_dev *indio_dev = pf->indio_dev; struct mma7455_data *mma7455 = iio_priv(indio_dev); u8 buf[16]; /* 3 x 16-bit channels + padding + ts */ int ret; ret = mma7455_drdy(mma7455); if (ret) goto done; ret = regmap_bulk_read(mma7455->regmap, MMA7455_REG_XOUTL, buf, sizeof(__le16) * 3); if (ret) goto done; iio_push_to_buffers_with_timestamp(indio_dev, buf, iio_get_time_ns(indio_dev)); done: iio_trigger_notify_done(indio_dev->trig); return IRQ_HANDLED; }
static int hmc5843_init(struct hmc5843_data *data) { int ret; u8 id[3]; ret = regmap_bulk_read(data->regmap, HMC5843_ID_REG, id, ARRAY_SIZE(id)); if (ret < 0) return ret; if (id[0] != 'H' || id[1] != '4' || id[2] != '3') { dev_err(data->dev, "no HMC5843/5883/5883L/5983 sensor\n"); return -ENODEV; } ret = hmc5843_set_meas_conf(data, HMC5843_MEAS_CONF_NORMAL); if (ret < 0) return ret; ret = hmc5843_set_samp_freq(data, HMC5843_RATE_DEFAULT); if (ret < 0) return ret; ret = hmc5843_set_range_gain(data, HMC5843_RANGE_GAIN_DEFAULT); if (ret < 0) return ret; return hmc5843_set_mode(data, HMC5843_MODE_CONVERSION_CONTINUOUS); }
static int jsa1212_read_als_data(struct jsa1212_data *data, unsigned int *val) { int ret; __le16 als_data; ret = jsa1212_als_enable(data, JSA1212_CONF_ALS_ENABLE); if (ret < 0) return ret; /* Delay for data output */ msleep(JSA1212_ALS_DELAY_MS); /* Read 12 bit data */ ret = regmap_bulk_read(data->regmap, JSA1212_ALS_DT1_REG, &als_data, 2); if (ret < 0) { dev_err(&data->client->dev, "als data read err\n"); goto als_data_read_err; } *val = le16_to_cpu(als_data); als_data_read_err: return jsa1212_als_enable(data, JSA1212_CONF_ALS_DISABLE); }
static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm) { struct s5m_rtc_info *info = dev_get_drvdata(dev); u8 data[8]; int ret; ret = regmap_bulk_read(info->rtc, SEC_RTC_SEC, data, 8); if (ret < 0) return ret; switch (info->device_type) { case S5M8763X: s5m8763_data_to_tm(data, tm); break; case S5M8767X: s5m8767_data_to_tm(data, tm, info->rtc_24hr_mode); break; default: return -EINVAL; } dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__, 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday); return rtc_valid_tm(tm); }
/* * Gets current tps65910 RTC time and date parameters. * * The RTC's time/alarm representation is not what gmtime(3) requires * Linux to use: * * - Months are 1..12 vs Linux 0-11 * - Years are 0..99 vs Linux 1900..N (we assume 21st century) */ static int tps65910_rtc_read_time(struct device *dev, struct rtc_time *tm) { unsigned char rtc_data[NUM_TIME_REGS]; struct tps65910 *tps = dev_get_drvdata(dev->parent); int ret; /* Copy RTC counting registers to static registers or latches */ ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL, TPS65910_RTC_CTRL_GET_TIME, TPS65910_RTC_CTRL_GET_TIME); if (ret < 0) { dev_err(dev, "RTC CTRL reg update failed with err:%d\n", ret); return ret; } ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, rtc_data, NUM_TIME_REGS); if (ret < 0) { dev_err(dev, "reading from RTC failed with err:%d\n", ret); return ret; } tm->tm_sec = bcd2bin(rtc_data[0]); tm->tm_min = bcd2bin(rtc_data[1]); tm->tm_hour = bcd2bin(rtc_data[2]); tm->tm_mday = bcd2bin(rtc_data[3]); tm->tm_mon = bcd2bin(rtc_data[4]) - 1; tm->tm_year = bcd2bin(rtc_data[5]) + 100; return ret; }
static irqreturn_t hmc5843_trigger_handler(int irq, void *p) { struct iio_poll_func *pf = p; struct iio_dev *indio_dev = pf->indio_dev; struct hmc5843_data *data = iio_priv(indio_dev); int ret; mutex_lock(&data->lock); ret = hmc5843_wait_measurement(data); if (ret < 0) { mutex_unlock(&data->lock); goto done; } ret = regmap_bulk_read(data->regmap, HMC5843_DATA_OUT_MSB_REGS, data->buffer, 3 * sizeof(__be16)); mutex_unlock(&data->lock); if (ret < 0) goto done; iio_push_to_buffers_with_timestamp(indio_dev, data->buffer, iio_get_time_ns(indio_dev)); done: iio_trigger_notify_done(indio_dev->trig); return IRQ_HANDLED; }
static int max77686_rtc_read_time(struct device *dev, struct rtc_time *tm) { struct max77686_rtc_info *info = dev_get_drvdata(dev); u8 data[RTC_NR_TIME]; int ret; mutex_lock(&info->lock); ret = max77686_rtc_update(info, MAX77686_RTC_READ); if (ret < 0) goto out; ret = regmap_bulk_read(info->max77686->rtc_regmap, MAX77686_RTC_SEC, data, RTC_NR_TIME); if (ret < 0) { dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__, ret); goto out; } max77686_rtc_data_to_tm(data, tm, info->rtc_24hr_mode); ret = rtc_valid_tm(tm); out: mutex_unlock(&info->lock); return ret; }
static int imx_ocotp_read(struct device_d *dev, const int offset, void *val, int bytes) { struct ocotp_priv *priv = dev->parent->priv; return regmap_bulk_read(priv->map, offset, val, bytes); }
static int rc5t583_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) { struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); unsigned char alarm_data[NUM_YAL_REGS]; u32 interrupt_enable; int ret; ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data, NUM_YAL_REGS); if (ret < 0) { dev_err(dev, "rtc_read_alarm error %d\n", ret); return ret; } alm->time.tm_min = bcd2bin(alarm_data[0]); alm->time.tm_hour = bcd2bin(alarm_data[1]); alm->time.tm_mday = bcd2bin(alarm_data[2]); alm->time.tm_mon = bcd2bin(alarm_data[3]) - 1; alm->time.tm_year = bcd2bin(alarm_data[4]) + 100; ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1, &interrupt_enable); if (ret < 0) return ret; /* check if YALE is set */ if (interrupt_enable & SET_YAL) alm->enabled = 1; return ret; }
static irqreturn_t arizona_overclocked(int irq, void *data) { struct arizona *arizona = data; unsigned int val[2]; int ret; ret = regmap_bulk_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_6, &val[0], 2); if (ret != 0) { dev_err(arizona->dev, "Failed to read overclock status: %d\n", ret); return IRQ_NONE; } if (val[0] & ARIZONA_PWM_OVERCLOCKED_STS) dev_err(arizona->dev, "PWM overclocked\n"); if (val[0] & ARIZONA_FX_CORE_OVERCLOCKED_STS) dev_err(arizona->dev, "FX core overclocked\n"); if (val[0] & ARIZONA_DAC_SYS_OVERCLOCKED_STS) dev_err(arizona->dev, "DAC SYS overclocked\n"); if (val[0] & ARIZONA_DAC_WARP_OVERCLOCKED_STS) dev_err(arizona->dev, "DAC WARP overclocked\n"); if (val[0] & ARIZONA_ADC_OVERCLOCKED_STS) dev_err(arizona->dev, "ADC overclocked\n"); if (val[0] & ARIZONA_MIXER_OVERCLOCKED_STS) dev_err(arizona->dev, "Mixer overclocked\n"); if (val[0] & ARIZONA_AIF3_SYNC_OVERCLOCKED_STS) dev_err(arizona->dev, "AIF3 overclocked\n"); if (val[0] & ARIZONA_AIF2_SYNC_OVERCLOCKED_STS) dev_err(arizona->dev, "AIF2 overclocked\n"); if (val[0] & ARIZONA_AIF1_SYNC_OVERCLOCKED_STS) dev_err(arizona->dev, "AIF1 overclocked\n"); if (val[0] & ARIZONA_PAD_CTRL_OVERCLOCKED_STS) dev_err(arizona->dev, "Pad control overclocked\n"); if (val[1] & ARIZONA_SLIMBUS_SUBSYS_OVERCLOCKED_STS) dev_err(arizona->dev, "Slimbus subsystem overclocked\n"); if (val[1] & ARIZONA_SLIMBUS_ASYNC_OVERCLOCKED_STS) dev_err(arizona->dev, "Slimbus async overclocked\n"); if (val[1] & ARIZONA_SLIMBUS_SYNC_OVERCLOCKED_STS) dev_err(arizona->dev, "Slimbus sync overclocked\n"); if (val[1] & ARIZONA_ASRC_ASYNC_SYS_OVERCLOCKED_STS) dev_err(arizona->dev, "ASRC async system overclocked\n"); if (val[1] & ARIZONA_ASRC_ASYNC_WARP_OVERCLOCKED_STS) dev_err(arizona->dev, "ASRC async WARP overclocked\n"); if (val[1] & ARIZONA_ASRC_SYNC_SYS_OVERCLOCKED_STS) dev_err(arizona->dev, "ASRC sync system overclocked\n"); if (val[1] & ARIZONA_ASRC_SYNC_WARP_OVERCLOCKED_STS) dev_err(arizona->dev, "ASRC sync WARP overclocked\n"); if (val[1] & ARIZONA_ADSP2_1_OVERCLOCKED_STS) dev_err(arizona->dev, "DSP1 overclocked\n"); if (val[1] & ARIZONA_ISRC3_OVERCLOCKED_STS) dev_err(arizona->dev, "ISRC3 overclocked\n"); if (val[1] & ARIZONA_ISRC2_OVERCLOCKED_STS) dev_err(arizona->dev, "ISRC2 overclocked\n"); if (val[1] & ARIZONA_ISRC1_OVERCLOCKED_STS) dev_err(arizona->dev, "ISRC1 overclocked\n"); return IRQ_HANDLED; }
static int da9063_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) { struct da9063_rtc *rtc = dev_get_drvdata(dev); u8 data[RTC_DATA_LEN]; int ret; unsigned int val; data[RTC_SEC] = 0; ret = regmap_bulk_read(rtc->hw->regmap, rtc->alarm_start, &data[rtc->data_start], rtc->alarm_len); if (ret < 0) return ret; da9063_data_to_tm(data, &alrm->time); alrm->enabled = !!(data[RTC_YEAR] & DA9063_ALARM_ON); ret = regmap_read(rtc->hw->regmap, DA9063_REG_EVENT_A, &val); if (ret < 0) return ret; if (val & (DA9063_E_ALARM)) alrm->pending = 1; else alrm->pending = 0; return 0; }
static int da9063_rtc_read_time(struct device *dev, struct rtc_time *tm) { struct da9063_rtc *rtc = dev_get_drvdata(dev); unsigned long tm_secs; unsigned long al_secs; u8 data[RTC_DATA_LEN]; int ret; ret = regmap_bulk_read(rtc->hw->regmap, DA9063_REG_COUNT_S, data, RTC_DATA_LEN); if (ret < 0) { dev_err(dev, "Failed to read RTC time data: %d\n", ret); return ret; } if (!(data[RTC_SEC] & DA9063_RTC_READ)) { dev_dbg(dev, "RTC not yet ready to be read by the host\n"); return -EINVAL; } da9063_data_to_tm(data, tm); rtc_tm_to_time(tm, &tm_secs); rtc_tm_to_time(&rtc->alarm_time, &al_secs); /* handle the rtc synchronisation delay */ if (rtc->rtc_sync == true && al_secs - tm_secs == 1) memcpy(tm, &rtc->alarm_time, sizeof(struct rtc_time)); else rtc->rtc_sync = false; return rtc_valid_tm(tm); }
static int ds1343_nvram_read(void *priv, unsigned int off, void *val, size_t bytes) { struct ds1343_priv *ds1343 = priv; return regmap_bulk_read(ds1343->map, DS1343_NVRAM + off, val, bytes); }
/* * DS3232 has two alarm, we only use alarm1 * According to linux specification, only support one-shot alarm * no periodic alarm mode */ static int ds3232_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) { struct ds3232 *ds3232 = dev_get_drvdata(dev); int control, stat; int ret; u8 buf[4]; ret = regmap_read(ds3232->regmap, DS3232_REG_SR, &stat); if (ret) goto out; ret = regmap_read(ds3232->regmap, DS3232_REG_CR, &control); if (ret) goto out; ret = regmap_bulk_read(ds3232->regmap, DS3232_REG_ALARM1, buf, 4); if (ret) goto out; alarm->time.tm_sec = bcd2bin(buf[0] & 0x7F); alarm->time.tm_min = bcd2bin(buf[1] & 0x7F); alarm->time.tm_hour = bcd2bin(buf[2] & 0x7F); alarm->time.tm_mday = bcd2bin(buf[3] & 0x7F); alarm->enabled = !!(control & DS3232_REG_CR_A1IE); alarm->pending = !!(stat & DS3232_REG_SR_A1F); ret = 0; out: return ret; }
/* * Gets current tps65910 RTC alarm time. */ static int tps65910_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) { unsigned char alarm_data[NUM_TIME_REGS]; u32 int_val; struct tps65910 *tps = dev_get_drvdata(dev->parent); int ret; ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, alarm_data, NUM_TIME_REGS); if (ret < 0) { dev_err(dev, "rtc_read_alarm error %d\n", ret); return ret; } alm->time.tm_sec = bcd2bin(alarm_data[0]); alm->time.tm_min = bcd2bin(alarm_data[1]); alm->time.tm_hour = bcd2bin(alarm_data[2]); alm->time.tm_mday = bcd2bin(alarm_data[3]); alm->time.tm_mon = bcd2bin(alarm_data[4]) - 1; alm->time.tm_year = bcd2bin(alarm_data[5]) + 100; ret = regmap_read(tps->regmap, TPS65910_RTC_INTERRUPTS, &int_val); if (ret < 0) return ret; if (int_val & TPS65910_RTC_INTERRUPTS_IT_ALARM) alm->enabled = 1; return ret; }
static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) { struct s5m_rtc_info *info = dev_get_drvdata(dev); u8 data[8]; unsigned int val; int ret, i; ret = regmap_bulk_read(info->rtc, SEC_ALARM0_SEC, data, 8); if (ret < 0) return ret; switch (info->device_type) { case S5M8763X: s5m8763_data_to_tm(data, &alrm->time); ret = regmap_read(info->rtc, SEC_ALARM0_CONF, &val); if (ret < 0) return ret; alrm->enabled = !!val; ret = regmap_read(info->rtc, SEC_RTC_STATUS, &val); if (ret < 0) return ret; break; case S5M8767X: s5m8767_data_to_tm(data, &alrm->time, info->rtc_24hr_mode); dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__, 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon, alrm->time.tm_mday, alrm->time.tm_hour, alrm->time.tm_min, alrm->time.tm_sec, alrm->time.tm_wday); alrm->enabled = 0; for (i = 0; i < 7; i++) { if (data[i] & ALARM_ENABLE_MASK) { alrm->enabled = 1; break; } } alrm->pending = 0; ret = regmap_read(info->rtc, SEC_RTC_STATUS, &val); if (ret < 0) return ret; break; default: return -EINVAL; } if (val & ALARM0_STATUS) alrm->pending = 1; else alrm->pending = 0; return 0; }
int max77693_bulk_read(struct regmap *map, u8 reg, int count, u8 *buf) { int ret; ret = regmap_bulk_read(map, reg, buf, count); return ret; }
void da9150_bulk_read(struct da9150 *da9150, u16 reg, int count, u8 *buf) { int ret; ret = regmap_bulk_read(da9150->regmap, reg, buf, count); if (ret) dev_err(da9150->dev, "Failed to bulk read from reg 0x%x: %d\n", reg, ret); }
/* * Read alarm currently configured via a watchdog timer using timer A. This * is done by reading current RTC time and adding remaining timer time. */ static int _abb5zes3_rtc_read_timer(struct device *dev, struct rtc_wkalrm *alarm) { struct abb5zes3_rtc_data *data = dev_get_drvdata(dev); struct rtc_time rtc_tm, *alarm_tm = &alarm->time; u8 regs[ABB5ZES3_TIMA_SEC_LEN + 1]; unsigned long rtc_secs; unsigned int reg; u8 timer_secs; int ret; /* * Instead of doing two separate calls, because they are consecutive, * we grab both clockout register and Timer A section. The latter is * used to decide if timer A is enabled (as a watchdog timer). */ ret = regmap_bulk_read(data->regmap, ABB5ZES3_REG_TIM_CLK, regs, ABB5ZES3_TIMA_SEC_LEN + 1); if (ret) { dev_err(dev, "%s: reading Timer A section failed (%d)\n", __func__, ret); goto err; } /* get current time ... */ ret = _abb5zes3_rtc_read_time(dev, &rtc_tm); if (ret) goto err; /* ... convert to seconds ... */ ret = rtc_tm_to_time(&rtc_tm, &rtc_secs); if (ret) goto err; /* ... add remaining timer A time ... */ ret = sec_from_timer_a(&timer_secs, regs[1], regs[2]); if (ret) goto err; /* ... and convert back. */ rtc_time_to_tm(rtc_secs + timer_secs, alarm_tm); ret = regmap_read(data->regmap, ABB5ZES3_REG_CTRL2, ®); if (ret) { dev_err(dev, "%s: reading ctrl reg failed (%d)\n", __func__, ret); goto err; } alarm->enabled = !!(reg & ABB5ZES3_REG_CTRL2_WTAIE); err: return ret; }
static int rv3029_read_regs(struct device *dev, u8 reg, u8 *buf, unsigned int len) { struct rv3029_data *rv3029 = dev_get_drvdata(dev); if ((reg > RV3029_USR1_RAM_PAGE + 7) || (reg + len > RV3029_USR1_RAM_PAGE + 8)) return -EINVAL; return regmap_bulk_read(rv3029->regmap, reg, buf, len); }
static int ltr501_read_als(struct ltr501_data *data, __le16 buf[2]) { int ret; ret = ltr501_drdy(data, LTR501_STATUS_ALS_RDY); if (ret < 0) return ret; /* always read both ALS channels in given order */ return regmap_bulk_read(data->regmap, LTR501_ALS_DATA1, buf, 2 * sizeof(__le16)); }
static int regcache_hw_init(struct regmap *map) { int i, j; int ret; int count; unsigned int val; void *tmp_buf; if (!map->num_reg_defaults_raw) return -EINVAL; if (!map->reg_defaults_raw) { dev_warn(map->dev, "No cache defaults, reading back from HW\n"); tmp_buf = kmalloc(map->cache_size_raw, GFP_KERNEL); if (!tmp_buf) return -EINVAL; ret = regmap_bulk_read(map, 0, tmp_buf, map->num_reg_defaults_raw); if (ret < 0) { kfree(tmp_buf); return ret; } map->reg_defaults_raw = tmp_buf; map->cache_free = 1; } /* calculate the size of reg_defaults */ for (count = 0, i = 0; i < map->num_reg_defaults_raw; i++) { val = regcache_get_val(map->reg_defaults_raw, i, map->cache_word_size); if (!val) continue; count++; } map->reg_defaults = kmalloc(count * sizeof(struct reg_default), GFP_KERNEL); if (!map->reg_defaults) return -ENOMEM; /* fill the reg_defaults */ map->num_reg_defaults = count; for (i = 0, j = 0; i < map->num_reg_defaults_raw; i++) { val = regcache_get_val(map->reg_defaults_raw, i, map->cache_word_size); if (!val) continue; map->reg_defaults[j].reg = i; map->reg_defaults[j].def = val; j++; } return 0; }
static int palmas_rtc_read_block(void *mfd, u8 *dest, u8 reg, int no_regs) { struct palmas *palmas = mfd; int slave; unsigned int addr; slave = PALMAS_BASE_TO_SLAVE(PALMAS_RTC_BASE); addr = PALMAS_BASE_TO_REG(PALMAS_RTC_BASE, reg); return regmap_bulk_read(palmas->regmap[slave], addr, dest, no_regs); }
static int ds3232_read_time(struct device *dev, struct rtc_time *time) { struct ds3232 *ds3232 = dev_get_drvdata(dev); int ret; u8 buf[7]; unsigned int year, month, day, hour, minute, second; unsigned int week, twelve_hr, am_pm; unsigned int century, add_century = 0; ret = regmap_bulk_read(ds3232->regmap, DS3232_REG_SECONDS, buf, 7); if (ret) return ret; second = buf[0]; minute = buf[1]; hour = buf[2]; week = buf[3]; day = buf[4]; month = buf[5]; year = buf[6]; /* Extract additional information for AM/PM and century */ twelve_hr = hour & 0x40; am_pm = hour & 0x20; century = month & 0x80; /* Write to rtc_time structure */ time->tm_sec = bcd2bin(second); time->tm_min = bcd2bin(minute); if (twelve_hr) { /* Convert to 24 hr */ if (am_pm) time->tm_hour = bcd2bin(hour & 0x1F) + 12; else time->tm_hour = bcd2bin(hour & 0x1F); } else { time->tm_hour = bcd2bin(hour); } /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */ time->tm_wday = bcd2bin(week) - 1; time->tm_mday = bcd2bin(day); /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */ time->tm_mon = bcd2bin(month & 0x7F) - 1; if (century) add_century = 100; time->tm_year = bcd2bin(year) + add_century; return rtc_valid_tm(time); }
extern int get_dynamicbiasgpadc(int *tbat, int gpadc_bias, unsigned int channel) { int ret = -1, adc_data, data; unsigned char buf[2]; unsigned int bias_reg; struct pm822_chip *chip = g_pm822_chip; switch (channel) { case PM822_GPADC0_MEAS1: bias_reg = PM822_GPADC_BIAS1; break; case PM822_GPADC1_MEAS1: bias_reg = PM822_GPADC_BIAS2; break; case PM822_GPADC2_MEAS1: bias_reg = PM822_GPADC_BIAS3; break; case PM822_GPADC3_MEAS1: bias_reg = PM822_GPADC_BIAS4; break; default: dev_err(chip->dev, "not supported GPADC!\n"); return -EINVAL; } regmap_read(chip->subchip->regmap_gpadc, bias_reg, &data); data &= 0xF0; data |= gpadc_bias; regmap_write(chip->subchip->regmap_gpadc, bias_reg, data); /* * There is no way to measure the temperature of battery, * report the pmic temperature value */ ret = regmap_bulk_read(chip->subchip->regmap_gpadc, channel, buf, 2); if (ret < 0) { dev_err(chip->dev, "Attention: failed to get battery tbat!\n"); return -EINVAL; } adc_data = ((buf[0] & 0xff) << 4) | (buf[1] & 0x0f); /* tbat = value * 1.4 *1000/(2^12) */ adc_data = ((adc_data & 0xfff) * 7 * 100) >> 11; dev_info(chip->dev, "%s: adc_channel = 0x%x, adc_data value = 0x%x\n", __func__, channel, adc_data); *tbat = adc_data; return ret; }