Searched refs:regmap (Results 1 - 200 of 748) sorted by relevance

1234

/linux-4.1.27/drivers/base/regmap/
H A DMakefile4 obj-$(CONFIG_REGMAP) += regmap.o regcache.o
6 obj-$(CONFIG_DEBUG_FS) += regmap-debugfs.o
7 obj-$(CONFIG_REGMAP_AC97) += regmap-ac97.o
8 obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o
9 obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o
10 obj-$(CONFIG_REGMAP_SPMI) += regmap-spmi.o
11 obj-$(CONFIG_REGMAP_MMIO) += regmap-mmio.o
12 obj-$(CONFIG_REGMAP_IRQ) += regmap-irq.o
H A Dinternal.h16 #include <linux/regmap.h>
21 struct regmap;
37 void (*format_write)(struct regmap *map,
47 struct regmap *map;
51 struct regmap { struct
151 int (*init)(struct regmap *map);
152 int (*exit)(struct regmap *map);
154 void (*debugfs_init)(struct regmap *map);
156 int (*read)(struct regmap *map, unsigned int reg, unsigned int *value);
157 int (*write)(struct regmap *map, unsigned int reg, unsigned int value);
158 int (*sync)(struct regmap *map, unsigned int min, unsigned int max);
159 int (*drop)(struct regmap *map, unsigned int min, unsigned int max);
162 bool regmap_writeable(struct regmap *map, unsigned int reg);
163 bool regmap_readable(struct regmap *map, unsigned int reg);
164 bool regmap_volatile(struct regmap *map, unsigned int reg);
165 bool regmap_precious(struct regmap *map, unsigned int reg);
167 int _regmap_write(struct regmap *map, unsigned int reg,
173 struct regmap *map;
187 struct regmap *regmap; member in struct:regmap_field
199 extern void regmap_debugfs_init(struct regmap *map, const char *name);
200 extern void regmap_debugfs_exit(struct regmap *map);
203 static inline void regmap_debugfs_init(struct regmap *map, const char *name) { } regmap_debugfs_exit()
204 static inline void regmap_debugfs_exit(struct regmap *map) { } regmap_debugfs_exit()
208 int regcache_init(struct regmap *map, const struct regmap_config *config); regmap_debugfs_exit()
209 void regcache_exit(struct regmap *map); regmap_debugfs_exit()
210 int regcache_read(struct regmap *map, regmap_debugfs_exit()
212 int regcache_write(struct regmap *map, regmap_debugfs_exit()
214 int regcache_sync(struct regmap *map); regmap_debugfs_exit()
215 int regcache_sync_block(struct regmap *map, void *block, regmap_debugfs_exit()
220 static inline const void *regcache_get_val_addr(struct regmap *map, regcache_get_val_addr()
227 unsigned int regcache_get_val(struct regmap *map, const void *base,
229 bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
231 int regcache_lookup_reg(struct regmap *map, unsigned int reg);
233 int _regmap_raw_write(struct regmap *map, unsigned int reg,
246 static inline const char *regmap_name(const struct regmap *map) regmap_name()
H A Dtrace.h2 #define TRACE_SYSTEM regmap
17 TP_PROTO(struct regmap *map, unsigned int reg,
41 TP_PROTO(struct regmap *map, unsigned int reg,
50 TP_PROTO(struct regmap *map, unsigned int reg,
59 TP_PROTO(struct regmap *map, unsigned int reg,
68 TP_PROTO(struct regmap *map, unsigned int reg, int count),
91 TP_PROTO(struct regmap *map, unsigned int reg, int count),
98 TP_PROTO(struct regmap *map, unsigned int reg, int count),
105 TP_PROTO(struct regmap *map, unsigned int reg, int count),
112 TP_PROTO(struct regmap *map, unsigned int reg, int count),
119 TP_PROTO(struct regmap *map, const char *type,
143 TP_PROTO(struct regmap *map, bool flag),
163 TP_PROTO(struct regmap *map, bool flag),
171 TP_PROTO(struct regmap *map, bool flag),
179 TP_PROTO(struct regmap *map),
196 TP_PROTO(struct regmap *map, unsigned int reg, int count),
203 TP_PROTO(struct regmap *map),
211 TP_PROTO(struct regmap *map),
219 TP_PROTO(struct regmap *map),
227 TP_PROTO(struct regmap *map, unsigned int from,
H A Dregcache-flat.c19 static int regcache_flat_init(struct regmap *map) regcache_flat_init()
37 static int regcache_flat_exit(struct regmap *map) regcache_flat_exit()
45 static int regcache_flat_read(struct regmap *map, regcache_flat_read()
55 static int regcache_flat_write(struct regmap *map, unsigned int reg, regcache_flat_write()
H A Dregmap-spmi.c6 * Based on regmap-i2c.c:
20 #include <linux/regmap.h>
95 * regmap_init_spmi_base(): Create regmap for the Base register space
100 * a struct regmap.
102 struct regmap *regmap_init_spmi_base(struct spmi_device *sdev, regmap_init_spmi_base()
110 * devm_regmap_init_spmi_base(): Create managed regmap for Base register space
115 * to a struct regmap. The regmap will be automatically freed by the
118 struct regmap *devm_regmap_init_spmi_base(struct spmi_device *sdev, devm_regmap_init_spmi_base()
226 * regmap_init_spmi_ext(): Create regmap for Ext register space
231 * a struct regmap.
233 struct regmap *regmap_init_spmi_ext(struct spmi_device *sdev, regmap_init_spmi_ext()
241 * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space
246 * to a struct regmap. The regmap will be automatically freed by the
249 struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *sdev, devm_regmap_init_spmi_ext()
H A Dregmap-ac97.c24 #include <linux/regmap.h>
88 * a struct regmap.
90 struct regmap *regmap_init_ac97(struct snd_ac97 *ac97, regmap_init_ac97()
104 * to a struct regmap. The regmap will be automatically freed by the
107 struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97, devm_regmap_init_ac97()
H A Dregcache-lzo.c19 static int regcache_lzo_exit(struct regmap *map);
33 static int regcache_lzo_block_count(struct regmap *map) regcache_lzo_block_count()
72 static int regcache_lzo_compress_cache_block(struct regmap *map, regcache_lzo_compress_cache_block()
90 static int regcache_lzo_decompress_cache_block(struct regmap *map, regcache_lzo_decompress_cache_block()
108 static inline int regcache_lzo_get_blkindex(struct regmap *map, regcache_lzo_get_blkindex()
116 static inline int regcache_lzo_get_blkpos(struct regmap *map, regcache_lzo_get_blkpos()
125 static inline int regcache_lzo_get_blksize(struct regmap *map) regcache_lzo_get_blksize()
131 static int regcache_lzo_init(struct regmap *map) regcache_lzo_init()
204 static int regcache_lzo_exit(struct regmap *map) regcache_lzo_exit()
234 static int regcache_lzo_read(struct regmap *map, regcache_lzo_read()
273 static int regcache_lzo_write(struct regmap *map, regcache_lzo_write()
334 static int regcache_lzo_sync(struct regmap *map, unsigned int min, regcache_lzo_sync()
/linux-4.1.27/sound/soc/codecs/
H A Dcs4271.h4 #include <linux/regmap.h>
9 int cs4271_probe(struct device *dev, struct regmap *regmap);
H A Dadau1761.h13 #include <linux/regmap.h>
18 int adau1761_probe(struct device *dev, struct regmap *regmap,
H A Dadau1781.h13 #include <linux/regmap.h>
18 int adau1781_probe(struct device *dev, struct regmap *regmap,
H A Dadau1977.h13 #include <linux/regmap.h>
23 int adau1977_probe(struct device *dev, struct regmap *regmap,
H A Dadav80x.h12 #include <linux/regmap.h>
17 int adav80x_bus_probe(struct device *dev, struct regmap *regmap);
H A Dwm8804-i2c.c22 struct regmap *regmap; wm8804_i2c_probe() local
24 regmap = devm_regmap_init_i2c(i2c, &wm8804_regmap_config); wm8804_i2c_probe()
25 if (IS_ERR(regmap)) wm8804_i2c_probe()
26 return PTR_ERR(regmap); wm8804_i2c_probe()
28 return wm8804_probe(&i2c->dev, regmap); wm8804_i2c_probe()
H A Dwm8804-spi.c21 struct regmap *regmap; wm8804_spi_probe() local
23 regmap = devm_regmap_init_spi(spi, &wm8804_regmap_config); wm8804_spi_probe()
24 if (IS_ERR(regmap)) wm8804_spi_probe()
25 return PTR_ERR(regmap); wm8804_spi_probe()
27 return wm8804_probe(&spi->dev, regmap); wm8804_spi_probe()
H A Dtlv320aic23-spi.c15 #include <linux/regmap.h>
24 struct regmap *regmap; aic23_spi_probe() local
33 regmap = devm_regmap_init_spi(spi, &tlv320aic23_regmap); aic23_spi_probe()
34 return tlv320aic23_probe(&spi->dev, regmap); aic23_spi_probe()
H A Dad193x.c12 #include <linux/regmap.h>
25 struct regmap *regmap; member in struct:ad193x_priv
115 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL2, ad193x_mute()
119 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL2, ad193x_mute()
148 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL1, ad193x_set_tdm_slot()
150 regmap_update_bits(ad193x->regmap, AD193X_ADC_CTRL2, ad193x_set_tdm_slot()
220 regmap_update_bits(ad193x->regmap, AD193X_ADC_CTRL1, ad193x_set_dai_fmt()
222 regmap_update_bits(ad193x->regmap, AD193X_ADC_CTRL2, ad193x_set_dai_fmt()
224 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL1, ad193x_set_dai_fmt()
283 regmap_update_bits(ad193x->regmap, AD193X_PLL_CLK_CTRL0, ad193x_hw_params()
286 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL2, ad193x_hw_params()
290 regmap_update_bits(ad193x->regmap, AD193X_ADC_CTRL1, ad193x_hw_params()
333 regmap_write(ad193x->regmap, AD193X_DAC_CHNL_MUTE, 0x0); ad193x_codec_probe()
335 regmap_write(ad193x->regmap, AD193X_DAC_CTRL2, 0x1A); ad193x_codec_probe()
337 regmap_write(ad193x->regmap, AD193X_DAC_CTRL0, 0x40); ad193x_codec_probe()
339 regmap_write(ad193x->regmap, AD193X_ADC_CTRL0, 0x3); ad193x_codec_probe()
341 regmap_write(ad193x->regmap, AD193X_ADC_CTRL1, 0x43); ad193x_codec_probe()
343 regmap_write(ad193x->regmap, AD193X_PLL_CLK_CTRL0, 0x99); /* mclk=24.576Mhz: 0x9D; mclk=12.288Mhz: 0x99 */ ad193x_codec_probe()
344 regmap_write(ad193x->regmap, AD193X_PLL_CLK_CTRL1, 0x04); ad193x_codec_probe()
370 int ad193x_probe(struct device *dev, struct regmap *regmap) ad193x_probe() argument
374 if (IS_ERR(regmap)) ad193x_probe()
375 return PTR_ERR(regmap); ad193x_probe()
381 ad193x->regmap = regmap; ad193x_probe()
H A Dpcm512x-i2c.c26 struct regmap *regmap; pcm512x_i2c_probe() local
33 regmap = devm_regmap_init_i2c(i2c, &config); pcm512x_i2c_probe()
34 if (IS_ERR(regmap)) pcm512x_i2c_probe()
35 return PTR_ERR(regmap); pcm512x_i2c_probe()
37 return pcm512x_probe(&i2c->dev, regmap); pcm512x_i2c_probe()
H A Dpcm512x-spi.c25 struct regmap *regmap; pcm512x_spi_probe() local
28 regmap = devm_regmap_init_spi(spi, &pcm512x_regmap); pcm512x_spi_probe()
29 if (IS_ERR(regmap)) { pcm512x_spi_probe()
30 ret = PTR_ERR(regmap); pcm512x_spi_probe()
34 return pcm512x_probe(&spi->dev, regmap); pcm512x_spi_probe()
H A Dsigmadsp-regmap.c9 #include <linux/regmap.h>
32 * @regmap: Regmap instance to use
41 struct regmap *regmap, const struct sigmadsp_ops *ops, devm_sigmadsp_init_regmap()
50 sigmadsp->control_data = regmap; devm_sigmadsp_init_regmap()
59 MODULE_DESCRIPTION("SigmaDSP regmap firmware loader");
40 devm_sigmadsp_init_regmap(struct device *dev, struct regmap *regmap, const struct sigmadsp_ops *ops, const char *firmware_name) devm_sigmadsp_init_regmap() argument
H A Dmax98925.c11 #include <linux/regmap.h>
107 regmap_update_bits(max98925->regmap, max98925_dac_event()
115 regmap_update_bits(max98925->regmap, max98925_dac_event()
282 regmap_update_bits(max98925->regmap, max98925_set_sense_data()
285 regmap_update_bits(max98925->regmap, max98925_set_sense_data()
290 regmap_update_bits(max98925->regmap, max98925_set_sense_data()
293 regmap_update_bits(max98925->regmap, max98925_set_sense_data()
310 regmap_update_bits(max98925->regmap, max98925_dai_set_fmt()
320 regmap_update_bits(max98925->regmap, max98925_dai_set_fmt()
348 regmap_update_bits(max98925->regmap, MAX98925_FORMAT, max98925_dai_set_fmt()
364 regmap_update_bits(max98925->regmap, max98925_set_clock()
369 regmap_update_bits(max98925->regmap, max98925_set_clock()
374 regmap_update_bits(max98925->regmap, max98925_set_clock()
409 regmap_update_bits(max98925->regmap, max98925_set_clock()
413 regmap_write(max98925->regmap, max98925_set_clock()
415 regmap_write(max98925->regmap, max98925_set_clock()
418 regmap_write(max98925->regmap, max98925_set_clock()
420 regmap_write(max98925->regmap, max98925_set_clock()
423 regmap_update_bits(max98925->regmap, MAX98925_DAI_CLK_MODE1, max98925_set_clock()
437 regmap_update_bits(max98925->regmap, max98925_dai_hw_params()
443 regmap_update_bits(max98925->regmap, max98925_dai_hw_params()
449 regmap_update_bits(max98925->regmap, max98925_dai_hw_params()
473 regmap_update_bits(max98925->regmap, max98925_dai_set_sysclk()
479 regmap_update_bits(max98925->regmap, max98925_dai_set_sysclk()
526 codec->control_data = max98925->regmap; max98925_probe()
527 regmap_write(max98925->regmap, MAX98925_GLOBAL_ENABLE, 0x00); max98925_probe()
529 regmap_write(max98925->regmap, max98925_probe()
531 regmap_write(max98925->regmap, MAX98925_TDM_SLOT_SELECT, 0xC8); max98925_probe()
532 regmap_write(max98925->regmap, MAX98925_DOUT_HIZ_CFG1, 0xFF); max98925_probe()
533 regmap_write(max98925->regmap, MAX98925_DOUT_HIZ_CFG2, 0xFF); max98925_probe()
534 regmap_write(max98925->regmap, MAX98925_DOUT_HIZ_CFG3, 0xFF); max98925_probe()
535 regmap_write(max98925->regmap, MAX98925_DOUT_HIZ_CFG4, 0xF0); max98925_probe()
536 regmap_write(max98925->regmap, MAX98925_FILTERS, 0xD8); max98925_probe()
537 regmap_write(max98925->regmap, MAX98925_ALC_CONFIGURATION, 0xF8); max98925_probe()
538 regmap_write(max98925->regmap, MAX98925_CONFIGURATION, 0xF0); max98925_probe()
540 regmap_write(max98925->regmap, MAX98925_BOOST_LIMITER, 0xF8); max98925_probe()
578 max98925->regmap = devm_regmap_init_i2c(i2c, &max98925_regmap); max98925_i2c_probe()
579 if (IS_ERR(max98925->regmap)) { max98925_i2c_probe()
580 ret = PTR_ERR(max98925->regmap); max98925_i2c_probe()
582 "Failed to allocate regmap: %d\n", ret); max98925_i2c_probe()
600 ret = regmap_read(max98925->regmap, max98925_i2c_probe()
H A Djz4740.c19 #include <linux/regmap.h>
78 struct regmap *regmap; member in struct:jz4740_codec
198 regmap_update_bits(jz4740_codec->regmap, JZ4740_REG_CODEC_2, jz4740_codec_hw_params()
228 static void jz4740_codec_wakeup(struct regmap *regmap) jz4740_codec_wakeup() argument
230 regmap_update_bits(regmap, JZ4740_REG_CODEC_1, jz4740_codec_wakeup()
234 regmap_update_bits(regmap, JZ4740_REG_CODEC_1, jz4740_codec_wakeup()
237 regcache_sync(regmap); jz4740_codec_wakeup()
244 struct regmap *regmap = jz4740_codec->regmap; jz4740_codec_set_bias_level() local
257 regmap_update_bits(regmap, JZ4740_REG_CODEC_1, mask, value); jz4740_codec_set_bias_level()
262 jz4740_codec_wakeup(regmap); jz4740_codec_set_bias_level()
271 regmap_update_bits(regmap, JZ4740_REG_CODEC_1, mask, value); jz4740_codec_set_bias_level()
277 regmap_update_bits(regmap, JZ4740_REG_CODEC_1, mask, value); jz4740_codec_set_bias_level()
278 regcache_mark_dirty(regmap); jz4740_codec_set_bias_level()
293 regmap_update_bits(jz4740_codec->regmap, JZ4740_REG_CODEC_1, jz4740_codec_dev_probe()
340 jz4740_codec->regmap = devm_regmap_init_mmio(&pdev->dev, base, jz4740_codec_probe()
342 if (IS_ERR(jz4740_codec->regmap)) jz4740_codec_probe()
343 return PTR_ERR(jz4740_codec->regmap); jz4740_codec_probe()
H A Dsirf-audio-codec.c17 #include <linux/regmap.h>
30 struct regmap *regmap; member in struct:sirf_audio_codec
107 static void enable_and_reset_codec(struct regmap *regmap, enable_and_reset_codec() argument
110 regmap_update_bits(regmap, AUDIO_IC_CODEC_CTRL1, enable_and_reset_codec()
114 regmap_update_bits(regmap, AUDIO_IC_CODEC_CTRL1, enable_and_reset_codec()
127 enable_and_reset_codec(sirf_audio_codec->regmap, atlas6_codec_enable_and_reset_event()
131 regmap_update_bits(sirf_audio_codec->regmap, atlas6_codec_enable_and_reset_event()
150 enable_and_reset_codec(sirf_audio_codec->regmap, prima2_codec_enable_and_reset_event()
154 regmap_update_bits(sirf_audio_codec->regmap, prima2_codec_enable_and_reset_event()
284 regmap_update_bits(sirf_audio_codec->regmap, AUDIO_PORT_IC_TXFIFO_OP, sirf_audio_codec_tx_enable()
286 regmap_update_bits(sirf_audio_codec->regmap, AUDIO_PORT_IC_TXFIFO_OP, sirf_audio_codec_tx_enable()
288 regmap_write(sirf_audio_codec->regmap, AUDIO_PORT_IC_TXFIFO_INT_MSK, 0); sirf_audio_codec_tx_enable()
289 regmap_write(sirf_audio_codec->regmap, AUDIO_PORT_IC_TXFIFO_OP, 0); sirf_audio_codec_tx_enable()
290 regmap_update_bits(sirf_audio_codec->regmap, AUDIO_PORT_IC_TXFIFO_OP, sirf_audio_codec_tx_enable()
292 regmap_update_bits(sirf_audio_codec->regmap, sirf_audio_codec_tx_enable()
298 regmap_write(sirf_audio_codec->regmap, AUDIO_PORT_IC_TXFIFO_OP, 0); sirf_audio_codec_tx_disable()
299 regmap_update_bits(sirf_audio_codec->regmap, sirf_audio_codec_tx_disable()
306 regmap_update_bits(sirf_audio_codec->regmap, AUDIO_PORT_IC_RXFIFO_OP, sirf_audio_codec_rx_enable()
308 regmap_update_bits(sirf_audio_codec->regmap, AUDIO_PORT_IC_RXFIFO_OP, sirf_audio_codec_rx_enable()
310 regmap_write(sirf_audio_codec->regmap, sirf_audio_codec_rx_enable()
312 regmap_write(sirf_audio_codec->regmap, AUDIO_PORT_IC_RXFIFO_OP, 0); sirf_audio_codec_rx_enable()
313 regmap_update_bits(sirf_audio_codec->regmap, AUDIO_PORT_IC_RXFIFO_OP, sirf_audio_codec_rx_enable()
316 regmap_update_bits(sirf_audio_codec->regmap, sirf_audio_codec_rx_enable()
320 regmap_update_bits(sirf_audio_codec->regmap, sirf_audio_codec_rx_enable()
327 regmap_update_bits(sirf_audio_codec->regmap, sirf_audio_codec_rx_disable()
479 sirf_audio_codec->regmap = devm_regmap_init_mmio(&pdev->dev, base, sirf_audio_codec_driver_probe()
481 if (IS_ERR(sirf_audio_codec->regmap)) sirf_audio_codec_driver_probe()
482 return PTR_ERR(sirf_audio_codec->regmap); sirf_audio_codec_driver_probe()
508 regmap_update_bits(sirf_audio_codec->regmap, AUDIO_IC_CODEC_CTRL0, sirf_audio_codec_driver_probe()
512 regmap_update_bits(sirf_audio_codec->regmap, sirf_audio_codec_driver_probe()
536 regmap_read(sirf_audio_codec->regmap, AUDIO_IC_CODEC_CTRL0, sirf_audio_codec_suspend()
538 regmap_read(sirf_audio_codec->regmap, AUDIO_IC_CODEC_CTRL1, sirf_audio_codec_suspend()
554 regmap_write(sirf_audio_codec->regmap, AUDIO_IC_CODEC_CTRL0, sirf_audio_codec_resume()
556 regmap_write(sirf_audio_codec->regmap, AUDIO_IC_CODEC_CTRL1, sirf_audio_codec_resume()
H A Dtlv320aic23-i2c.c17 #include <linux/regmap.h>
25 struct regmap *regmap; tlv320aic23_i2c_probe() local
30 regmap = devm_regmap_init_i2c(i2c, &tlv320aic23_regmap); tlv320aic23_i2c_probe()
31 return tlv320aic23_probe(&i2c->dev, regmap); tlv320aic23_i2c_probe()
H A Dad1836.c22 #include <linux/regmap.h>
35 struct regmap *regmap; member in struct:ad1836_priv
186 regmap_update_bits(ad1836->regmap, AD1836_DAC_CTRL1, ad1836_hw_params()
190 regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2, ad1836_hw_params()
235 return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2, ad1836_suspend()
243 return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2, ad1836_resume()
264 regmap_write(ad1836->regmap, AD1836_DAC_CTRL1, 0x300); ad1836_probe()
266 regmap_write(ad1836->regmap, AD1836_DAC_CTRL2, 0x0); ad1836_probe()
268 regmap_write(ad1836->regmap, AD1836_ADC_CTRL1, 0x100); ad1836_probe()
270 regmap_write(ad1836->regmap, AD1836_ADC_CTRL2, 0x180); ad1836_probe()
273 regmap_write(ad1836->regmap, AD1836_DAC_L_VOL(i), 0x3FF); ad1836_probe()
274 regmap_write(ad1836->regmap, AD1836_DAC_R_VOL(i), 0x3FF); ad1836_probe()
279 regmap_write(ad1836->regmap, AD1836_ADC_CTRL3, 0x3A); ad1836_probe()
285 regmap_write(ad1836->regmap, AD1836_ADC_CTRL3, 0x00); ad1836_probe()
320 return regmap_update_bits(ad1836->regmap, AD1836_ADC_CTRL2, ad1836_remove()
375 ad1836->regmap = devm_regmap_init_spi(spi, &ad1836_regmap_config); ad1836_spi_probe()
376 if (IS_ERR(ad1836->regmap)) ad1836_spi_probe()
377 return PTR_ERR(ad1836->regmap); ad1836_spi_probe()
H A Dssm4567.c16 #include <linux/regmap.h>
89 struct regmap *regmap; member in struct:ssm4567
206 return regmap_update_bits(ssm4567->regmap, SSM4567_REG_DAC_CTRL, ssm4567_hw_params()
216 return regmap_update_bits(ssm4567->regmap, SSM4567_REG_DAC_CTRL, ssm4567_mute()
252 ret = regmap_update_bits(ssm4567->regmap, SSM4567_REG_SAI_CTRL_2, ssm4567_set_tdm_slot()
258 return regmap_update_bits(ssm4567->regmap, SSM4567_REG_SAI_CTRL_1, ssm4567_set_tdm_slot()
318 return regmap_update_bits(ssm4567->regmap, SSM4567_REG_SAI_CTRL_1, ssm4567_set_dai_fmt()
332 ret = regmap_update_bits(ssm4567->regmap, ssm4567_set_power()
335 regcache_mark_dirty(ssm4567->regmap); ssm4567_set_power()
338 regcache_cache_only(ssm4567->regmap, !enable); ssm4567_set_power()
341 ret = regmap_update_bits(ssm4567->regmap, ssm4567_set_power()
344 regcache_sync(ssm4567->regmap); ssm4567_set_power()
436 ssm4567->regmap = devm_regmap_init_i2c(i2c, &ssm4567_regmap_config); ssm4567_i2c_probe()
437 if (IS_ERR(ssm4567->regmap)) ssm4567_i2c_probe()
438 return PTR_ERR(ssm4567->regmap); ssm4567_i2c_probe()
440 ret = regmap_write(ssm4567->regmap, SSM4567_REG_SOFT_RESET, 0x00); ssm4567_i2c_probe()
H A Dts3a227e.c17 #include <linux/regmap.h>
26 struct regmap *regmap; member in struct:ts3a227e
180 regmap_update_bits(ts3a227e->regmap, ts3a227e_new_jack_state()
190 struct regmap *regmap = ts3a227e->regmap; ts3a227e_interrupt() local
194 regmap_read(regmap, TS3A227E_REG_INTERRUPT, &int_reg); ts3a227e_interrupt()
196 regmap_read(regmap, TS3A227E_REG_ACCESSORY_STATUS, &acc_reg); ts3a227e_interrupt()
201 regmap_read(regmap, TS3A227E_REG_KP_INTERRUPT, &kp_int_reg); ts3a227e_interrupt()
264 regmap_update_bits(ts3a227e->regmap, TS3A227E_REG_SETTING_3, ts3a227e_parse_dt()
286 ts3a227e->regmap = devm_regmap_init_i2c(i2c, &ts3a227e_regmap_config); ts3a227e_i2c_probe()
287 if (IS_ERR(ts3a227e->regmap)) ts3a227e_i2c_probe()
288 return PTR_ERR(ts3a227e->regmap); ts3a227e_i2c_probe()
312 regmap_update_bits(ts3a227e->regmap, TS3A227E_REG_INTERRUPT_DISABLE, ts3a227e_i2c_probe()
317 regmap_read(ts3a227e->regmap, TS3A227E_REG_ACCESSORY_STATUS, &acc_reg); ts3a227e_i2c_probe()
H A Dmax9877.c17 #include <linux/regmap.h>
23 static struct regmap *regmap; variable in typeref:struct:regmap
150 regmap = devm_regmap_init_i2c(client, &max9877_regmap); max9877_i2c_probe()
151 if (IS_ERR(regmap)) max9877_i2c_probe()
152 return PTR_ERR(regmap); max9877_i2c_probe()
156 regmap_write(regmap, max9877_regs[i].reg, max9877_regs[i].def); max9877_i2c_probe()
H A Dadau17x1.h4 #include <linux/regmap.h>
46 struct regmap *regmap; member in struct:adau
52 int adau17x1_probe(struct device *dev, struct regmap *regmap,
H A Dadau1977.c17 #include <linux/regmap.h>
112 struct regmap *regmap; member in struct:adau1977
235 regcache_cache_bypass(adau1977->regmap, true); adau1977_reset()
236 ret = regmap_write(adau1977->regmap, ADAU1977_REG_POWER, adau1977_reset()
238 regcache_cache_bypass(adau1977->regmap, false); adau1977_reset()
359 ret = regmap_update_bits(adau1977->regmap, adau1977_hw_params()
368 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_SAI_CTRL0, adau1977_hw_params()
373 return regmap_update_bits(adau1977->regmap, ADAU1977_REG_PLL, adau1977_hw_params()
384 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_POWER, adau1977_power_disable()
389 regcache_mark_dirty(adau1977->regmap); adau1977_power_disable()
394 regcache_cache_only(adau1977->regmap, true); adau1977_power_disable()
426 regcache_cache_only(adau1977->regmap, false); adau1977_power_enable()
435 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_POWER, adau1977_power_enable()
440 ret = regcache_sync(adau1977->regmap); adau1977_power_enable()
451 ret = regmap_read(adau1977->regmap, ADAU1977_REG_PLL, &val); adau1977_power_enable()
456 regcache_cache_bypass(adau1977->regmap, true); adau1977_power_enable()
457 ret = regmap_write(adau1977->regmap, ADAU1977_REG_PLL, adau1977_power_enable()
461 regcache_cache_bypass(adau1977->regmap, false); adau1977_power_enable()
517 return regmap_update_bits(adau1977->regmap, adau1977_set_tdm_slot()
573 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_SAI_OVERTEMP, adau1977_set_tdm_slot()
581 ret = regmap_write(adau1977->regmap, ADAU1977_REG_CMAP12, adau1977_set_tdm_slot()
587 ret = regmap_write(adau1977->regmap, ADAU1977_REG_CMAP34, adau1977_set_tdm_slot()
593 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_SAI_CTRL0, adau1977_set_tdm_slot()
598 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_SAI_CTRL1, adau1977_set_tdm_slot()
621 return regmap_update_bits(adau1977->regmap, ADAU1977_REG_MISC_CONTROL, adau1977_mute()
694 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_BLOCK_POWER_SAI, adau1977_set_dai_fmt()
700 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_SAI_CTRL0, adau1977_set_dai_fmt()
706 return regmap_update_bits(adau1977->regmap, ADAU1977_REG_SAI_CTRL1, adau1977_set_dai_fmt()
747 return regmap_update_bits(adau1977->regmap, ADAU1977_REG_SAI_OVERTEMP, adau1977_set_tristate()
842 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_PLL, adau1977_set_sysclk()
902 return regmap_update_bits(adau1977->regmap, ADAU1977_REG_MICBIAS, adau1977_setup_micbias()
907 int adau1977_probe(struct device *dev, struct regmap *regmap, adau1977_probe() argument
914 if (IS_ERR(regmap)) adau1977_probe()
915 return PTR_ERR(regmap); adau1977_probe()
923 adau1977->regmap = regmap; adau1977_probe()
966 ret = regmap_update_bits(adau1977->regmap, ADAU1977_REG_BLOCK_POWER_SAI, adau1977_probe()
H A Dssm2518.c13 #include <linux/regmap.h>
112 struct regmap *regmap; member in struct:ssm2518
378 ret = regmap_update_bits(ssm2518->regmap, SSM2518_REG_CLOCK, ssm2518_hw_params()
383 ret = regmap_update_bits(ssm2518->regmap, SSM2518_REG_SAI_CTRL1, ssm2518_hw_params()
388 return regmap_update_bits(ssm2518->regmap, SSM2518_REG_POWER1, ssm2518_hw_params()
402 return regmap_update_bits(ssm2518->regmap, SSM2518_REG_MUTE_CTRL, ssm2518_mute()
470 ret = regmap_write(ssm2518->regmap, SSM2518_REG_SAI_CTRL1, ctrl1); ssm2518_set_dai_fmt()
474 return regmap_write(ssm2518->regmap, SSM2518_REG_SAI_CTRL2, ctrl2); ssm2518_set_dai_fmt()
482 ret = regmap_update_bits(ssm2518->regmap, SSM2518_REG_POWER1, ssm2518_set_power()
484 regcache_mark_dirty(ssm2518->regmap); ssm2518_set_power()
490 regcache_cache_only(ssm2518->regmap, !enable); ssm2518_set_power()
493 ret = regmap_update_bits(ssm2518->regmap, SSM2518_REG_POWER1, ssm2518_set_power()
495 regcache_sync(ssm2518->regmap); ssm2518_set_power()
538 return regmap_update_bits(ssm2518->regmap, ssm2518_set_tdm_slot()
599 ret = regmap_write(ssm2518->regmap, SSM2518_REG_CHAN_MAP, ssm2518_set_tdm_slot()
605 ret = regmap_update_bits(ssm2518->regmap, SSM2518_REG_SAI_CTRL1, ssm2518_set_tdm_slot()
610 return regmap_update_bits(ssm2518->regmap, SSM2518_REG_SAI_CTRL2, ssm2518_set_tdm_slot()
714 return regmap_update_bits(ssm2518->regmap, SSM2518_REG_POWER1, ssm2518_set_sysclk()
778 ssm2518->regmap = devm_regmap_init_i2c(i2c, &ssm2518_regmap_config); ssm2518_i2c_probe()
779 if (IS_ERR(ssm2518->regmap)) ssm2518_i2c_probe()
780 return PTR_ERR(ssm2518->regmap); ssm2518_i2c_probe()
788 regcache_cache_bypass(ssm2518->regmap, true); ssm2518_i2c_probe()
789 ret = regmap_write(ssm2518->regmap, SSM2518_REG_POWER1, ssm2518_i2c_probe()
791 regcache_cache_bypass(ssm2518->regmap, false); ssm2518_i2c_probe()
795 ret = regmap_update_bits(ssm2518->regmap, SSM2518_REG_POWER2, ssm2518_i2c_probe()
H A Dpcm512x.c23 #include <linux/regmap.h>
44 struct regmap *regmap; member in struct:pcm512x_priv
73 regcache_mark_dirty(pcm512x->regmap); \
74 regcache_cache_only(pcm512x->regmap, true); \
573 struct regmap *regmap = pcm512x->regmap; pcm512x_dai_startup_slave() local
580 regmap_update_bits(regmap, PCM512x_ERROR_DETECT, pcm512x_dai_startup_slave()
584 regmap_update_bits(regmap, PCM512x_PLL_REF, pcm512x_dai_startup_slave()
624 ret = regmap_update_bits(pcm512x->regmap, PCM512x_POWER, pcm512x_set_bias_level()
634 ret = regmap_update_bits(pcm512x->regmap, PCM512x_POWER, pcm512x_set_bias_level()
894 ret = regmap_write(pcm512x->regmap, pcm512x_set_dividers()
901 ret = regmap_write(pcm512x->regmap, pcm512x_set_dividers()
908 ret = regmap_write(pcm512x->regmap, pcm512x_set_dividers()
915 ret = regmap_write(pcm512x->regmap, pcm512x_set_dividers()
922 ret = regmap_write(pcm512x->regmap, pcm512x_set_dividers()
954 ret = regmap_update_bits(pcm512x->regmap, PCM512x_DAC_REF, pcm512x_set_dividers()
963 ret = regmap_update_bits(pcm512x->regmap, PCM512x_GPIO_DACIN, pcm512x_set_dividers()
992 ret = regmap_update_bits(pcm512x->regmap, PCM512x_DAC_REF, pcm512x_set_dividers()
1029 ret = regmap_write(pcm512x->regmap, PCM512x_DSP_CLKDIV, dsp_div - 1); pcm512x_set_dividers()
1035 ret = regmap_write(pcm512x->regmap, PCM512x_DAC_CLKDIV, dac_div - 1); pcm512x_set_dividers()
1041 ret = regmap_write(pcm512x->regmap, PCM512x_NCP_CLKDIV, ncp_div - 1); pcm512x_set_dividers()
1047 ret = regmap_write(pcm512x->regmap, PCM512x_OSR_CLKDIV, osr_div - 1); pcm512x_set_dividers()
1053 ret = regmap_write(pcm512x->regmap, pcm512x_set_dividers()
1060 ret = regmap_write(pcm512x->regmap, pcm512x_set_dividers()
1067 ret = regmap_write(pcm512x->regmap, PCM512x_IDAC_1, idac >> 8); pcm512x_set_dividers()
1073 ret = regmap_write(pcm512x->regmap, PCM512x_IDAC_2, idac & 0xff); pcm512x_set_dividers()
1087 ret = regmap_update_bits(pcm512x->regmap, PCM512x_FS_SPEED_MODE, pcm512x_set_dividers()
1143 ret = regmap_update_bits(pcm512x->regmap, pcm512x_hw_params()
1154 ret = regmap_update_bits(pcm512x->regmap, PCM512x_ERROR_DETECT, pcm512x_hw_params()
1175 ret = regmap_update_bits(pcm512x->regmap, PCM512x_I2S_1, pcm512x_hw_params()
1183 ret = regmap_write(pcm512x->regmap, PCM512x_FLEX_A, 0x11); pcm512x_hw_params()
1189 ret = regmap_write(pcm512x->regmap, PCM512x_FLEX_B, 0xff); pcm512x_hw_params()
1195 ret = regmap_update_bits(pcm512x->regmap, PCM512x_ERROR_DETECT, pcm512x_hw_params()
1210 ret = regmap_update_bits(pcm512x->regmap, PCM512x_ERROR_DETECT, pcm512x_hw_params()
1225 ret = regmap_update_bits(pcm512x->regmap, PCM512x_PLL_EN, pcm512x_hw_params()
1238 ret = regmap_update_bits(pcm512x->regmap, PCM512x_PLL_REF, pcm512x_hw_params()
1247 ret = regmap_update_bits(pcm512x->regmap, PCM512x_GPIO_PLLIN, pcm512x_hw_params()
1256 ret = regmap_update_bits(pcm512x->regmap, PCM512x_PLL_EN, pcm512x_hw_params()
1264 ret = regmap_update_bits(pcm512x->regmap, PCM512x_BCLK_LRCLK_CFG, pcm512x_hw_params()
1272 ret = regmap_update_bits(pcm512x->regmap, PCM512x_MASTER_MODE, pcm512x_hw_params()
1282 ret = regmap_update_bits(pcm512x->regmap, PCM512x_GPIO_EN, pcm512x_hw_params()
1291 ret = regmap_update_bits(pcm512x->regmap, gpio, pcm512x_hw_params()
1300 ret = regmap_update_bits(pcm512x->regmap, PCM512x_SYNCHRONIZE, pcm512x_hw_params()
1307 ret = regmap_update_bits(pcm512x->regmap, PCM512x_SYNCHRONIZE, pcm512x_hw_params()
1386 int pcm512x_probe(struct device *dev, struct regmap *regmap) pcm512x_probe() argument
1396 pcm512x->regmap = regmap; pcm512x_probe()
1430 ret = regmap_write(regmap, PCM512x_RESET, pcm512x_probe()
1437 ret = regmap_write(regmap, PCM512x_RESET, 0); pcm512x_probe()
1455 ret = regmap_update_bits(pcm512x->regmap, PCM512x_POWER, pcm512x_probe()
1544 ret = regmap_update_bits(pcm512x->regmap, PCM512x_POWER, pcm512x_suspend()
1584 regcache_cache_only(pcm512x->regmap, false); pcm512x_resume()
1585 ret = regcache_sync(pcm512x->regmap); pcm512x_resume()
1591 ret = regmap_update_bits(pcm512x->regmap, PCM512x_POWER, pcm512x_resume()
H A Dlm4857.c19 #include <linux/regmap.h>
27 struct regmap *regmap; member in struct:lm4857
70 regmap_update_bits(lm4857->regmap, LM4857_CTRL, 0x0F, value + 6); lm4857_set_mode()
82 regmap_update_bits(lm4857->regmap, LM4857_CTRL, 0x0F, lm4857_set_bias_level()
86 regmap_update_bits(lm4857->regmap, LM4857_CTRL, 0x0F, 0); lm4857_set_bias_level()
178 lm4857->regmap = devm_regmap_init_i2c(i2c, &lm4857_regmap_config); lm4857_i2c_probe()
179 if (IS_ERR(lm4857->regmap)) lm4857_i2c_probe()
180 return PTR_ERR(lm4857->regmap); lm4857_i2c_probe()
H A Dssm2602.c30 #include <linux/regmap.h>
45 struct regmap *regmap; member in struct:ssm2602_priv
285 regmap_write(ssm2602->regmap, SSM2602_SRATE, srate); ssm2602_hw_params()
304 regmap_update_bits(ssm2602->regmap, SSM2602_IFACE, ssm2602_hw_params()
329 regmap_update_bits(ssm2602->regmap, SSM2602_APDIGI, ssm2602_mute()
333 regmap_update_bits(ssm2602->regmap, SSM2602_APDIGI, ssm2602_mute()
383 regmap_update_bits(ssm2602->regmap, SSM2602_PWR, ssm2602_set_dai_sysclk()
445 regmap_write(ssm2602->regmap, SSM2602_IFACE, iface); ssm2602_set_dai_fmt()
457 regmap_update_bits(ssm2602->regmap, SSM2602_PWR, ssm2602_set_bias_level()
465 regmap_update_bits(ssm2602->regmap, SSM2602_PWR, ssm2602_set_bias_level()
471 regmap_update_bits(ssm2602->regmap, SSM2602_PWR, ssm2602_set_bias_level()
520 regcache_sync(ssm2602->regmap); ssm2602_resume()
531 regmap_update_bits(ssm2602->regmap, SSM2602_LOUT1V, ssm2602_codec_probe()
533 regmap_update_bits(ssm2602->regmap, SSM2602_ROUT1V, ssm2602_codec_probe()
569 ret = regmap_write(ssm2602->regmap, SSM2602_RESET, 0); ssm260x_codec_probe()
576 regmap_update_bits(ssm2602->regmap, SSM2602_LINVOL, ssm260x_codec_probe()
578 regmap_update_bits(ssm2602->regmap, SSM2602_RINVOL, ssm260x_codec_probe()
581 regmap_write(ssm2602->regmap, SSM2602_APANA, APANA_SELECT_DAC | ssm260x_codec_probe()
629 struct regmap *regmap) ssm2602_probe()
633 if (IS_ERR(regmap)) ssm2602_probe()
634 return PTR_ERR(regmap); ssm2602_probe()
642 ssm2602->regmap = regmap; ssm2602_probe()
628 ssm2602_probe(struct device *dev, enum ssm2602_type type, struct regmap *regmap) ssm2602_probe() argument
H A Dsta350.c31 #include <linux/regmap.h>
170 struct regmap *regmap; member in struct:sta350_priv
322 regmap_read(sta350->regmap, STA350_CFUD, &cfud); sta350_coefficient_get()
328 regmap_write(sta350->regmap, STA350_CFUD, cfud); sta350_coefficient_get()
330 regmap_write(sta350->regmap, STA350_CFADDR2, index); sta350_coefficient_get()
332 regmap_write(sta350->regmap, STA350_CFUD, cfud | 0x04); sta350_coefficient_get()
334 regmap_write(sta350->regmap, STA350_CFUD, cfud | 0x08); sta350_coefficient_get()
341 regmap_read(sta350->regmap, STA350_B1CF1 + i, &val); sta350_coefficient_get()
362 regmap_read(sta350->regmap, STA350_CFUD, &cfud); sta350_coefficient_put()
368 regmap_write(sta350->regmap, STA350_CFUD, cfud); sta350_coefficient_put()
370 regmap_write(sta350->regmap, STA350_CFADDR2, index); sta350_coefficient_put()
377 regmap_write(sta350->regmap, STA350_B1CF1 + i, sta350_coefficient_put()
380 regmap_write(sta350->regmap, STA350_CFUD, cfud | 0x01); sta350_coefficient_put()
382 regmap_write(sta350->regmap, STA350_CFUD, cfud | 0x02); sta350_coefficient_put()
396 regmap_read(sta350->regmap, STA350_CFUD, &cfud); sta350_sync_coef_shadow()
400 regmap_write(sta350->regmap, STA350_CFADDR2, i); sta350_sync_coef_shadow()
401 regmap_write(sta350->regmap, STA350_B1CF1, sta350_sync_coef_shadow()
403 regmap_write(sta350->regmap, STA350_B1CF2, sta350_sync_coef_shadow()
405 regmap_write(sta350->regmap, STA350_B1CF3, sta350_sync_coef_shadow()
411 regmap_write(sta350->regmap, STA350_CFUD, cfud); sta350_sync_coef_shadow()
412 regmap_write(sta350->regmap, STA350_CFUD, cfud | 0x01); sta350_sync_coef_shadow()
424 regmap_read(sta350->regmap, STA350_CFUD, &mute); sta350_cache_sync()
425 regmap_write(sta350->regmap, STA350_MMUTE, mute | STA350_MMUTE_MMUTE); sta350_cache_sync()
427 rc = regcache_sync(sta350->regmap); sta350_cache_sync()
428 regmap_write(sta350->regmap, STA350_MMUTE, mute); sta350_cache_sync()
668 return regmap_update_bits(sta350->regmap, STA350_CONFB, sta350_set_dai_fmt()
798 ret = regmap_update_bits(sta350->regmap, STA350_CONFA, sta350_hw_params()
804 ret = regmap_update_bits(sta350->regmap, STA350_CONFB, sta350_hw_params()
850 regmap_update_bits(sta350->regmap, STA350_CONFF, sta350_set_bias_level()
871 regmap_update_bits(sta350->regmap, STA350_CONFF, sta350_set_bias_level()
879 regmap_update_bits(sta350->regmap, STA350_CONFF, sta350_set_bias_level()
941 regmap_update_bits(sta350->regmap, STA350_CONFA, sta350_probe()
947 regmap_update_bits(sta350->regmap, STA350_CONFC, sta350_probe()
951 regmap_update_bits(sta350->regmap, STA350_CONFC, sta350_probe()
955 regmap_update_bits(sta350->regmap, sta350_probe()
962 regmap_update_bits(sta350->regmap, STA350_CONFE, sta350_probe()
966 regmap_update_bits(sta350->regmap, STA350_CONFE, sta350_probe()
970 regmap_update_bits(sta350->regmap, STA350_CONFE, sta350_probe()
974 regmap_update_bits(sta350->regmap, STA350_CONFE, sta350_probe()
978 regmap_update_bits(sta350->regmap, STA350_CONFE, sta350_probe()
983 regmap_update_bits(sta350->regmap, STA350_CONFF, sta350_probe()
987 regmap_update_bits(sta350->regmap, STA350_CONFF, sta350_probe()
993 regmap_update_bits(sta350->regmap, STA350_C1CFG, sta350_probe()
997 regmap_update_bits(sta350->regmap, STA350_C2CFG, sta350_probe()
1001 regmap_update_bits(sta350->regmap, STA350_C3CFG, sta350_probe()
1007 regmap_update_bits(sta350->regmap, STA350_MISC1, sta350_probe()
1011 regmap_update_bits(sta350->regmap, STA350_MISC1, sta350_probe()
1015 regmap_update_bits(sta350->regmap, STA350_MISC1, sta350_probe()
1019 regmap_update_bits(sta350->regmap, STA350_MISC1, sta350_probe()
1024 regmap_update_bits(sta350->regmap, STA350_MISC2, sta350_probe()
1237 sta350->regmap = devm_regmap_init_i2c(i2c, &sta350_regmap); sta350_i2c_probe()
1238 if (IS_ERR(sta350->regmap)) { sta350_i2c_probe()
1239 ret = PTR_ERR(sta350->regmap); sta350_i2c_probe()
1240 dev_err(dev, "Failed to init regmap: %d\n", ret); sta350_i2c_probe()
H A Dadau1701.c19 #include <linux/regmap.h>
110 struct regmap *regmap; member in struct:adau1701
261 ret = regmap_read(adau1701->regmap, ADAU1701_DSPCTRL, &val); adau1701_safeload()
287 return regmap_update_bits(adau1701->regmap, ADAU1701_DSPCTRL, adau1701_safeload()
350 regmap_write(adau1701->regmap, ADAU1701_DACSET, ADAU1701_DACSET_DACINIT); adau1701_reset()
351 regmap_write(adau1701->regmap, ADAU1701_DSPCTRL, ADAU1701_DSPCTRL_CR); adau1701_reset()
353 regcache_mark_dirty(adau1701->regmap); adau1701_reset()
354 regcache_sync(adau1701->regmap); adau1701_reset()
395 regmap_update_bits(adau1701->regmap, ADAU1701_SEROCTL, mask, val); adau1701_set_capture_pcm_format()
423 regmap_update_bits(adau1701->regmap, ADAU1701_SERICTL, adau1701_set_playback_pcm_format()
463 regmap_update_bits(adau1701->regmap, ADAU1701_DSPCTRL, adau1701_hw_params()
538 regmap_write(adau1701->regmap, ADAU1701_SERICTL, serictl); adau1701_set_dai_fmt()
539 regmap_update_bits(adau1701->regmap, ADAU1701_SEROCTL, adau1701_set_dai_fmt()
558 regmap_update_bits(adau1701->regmap, adau1701_set_bias_level()
563 regmap_update_bits(adau1701->regmap, adau1701_set_bias_level()
584 regmap_update_bits(adau1701->regmap, ADAU1701_DSPCTRL, mask, val); adau1701_digital_mute()
606 regmap_update_bits(adau1701->regmap, ADAU1701_OSCIPOW, adau1701_set_sysclk()
690 regmap_write(adau1701->regmap, ADAU1701_PINCONF_0, val); adau1701_probe()
696 regmap_write(adau1701->regmap, ADAU1701_PINCONF_1, val); adau1701_probe()
740 adau1701->regmap = devm_regmap_init(dev, NULL, client, adau1701_i2c_probe()
742 if (IS_ERR(adau1701->regmap)) adau1701_i2c_probe()
743 return PTR_ERR(adau1701->regmap); adau1701_i2c_probe()
H A Dcs4271.c164 struct regmap *regmap; member in struct:cs4271_private
234 ret = regmap_update_bits(cs4271->regmap, CS4271_ADCCTL, cs4271_set_dai_fmt()
241 ret = regmap_update_bits(cs4271->regmap, CS4271_ADCCTL, cs4271_set_dai_fmt()
251 ret = regmap_update_bits(cs4271->regmap, CS4271_MODE1, cs4271_set_dai_fmt()
276 ret = regmap_update_bits(cs4271->regmap, CS4271_DACCTL, cs4271_set_deemph()
365 ret = regmap_update_bits(cs4271->regmap, CS4271_MODE2, cs4271_hw_params()
371 ret = regmap_update_bits(cs4271->regmap, CS4271_MODE2, cs4271_hw_params()
402 ret = regmap_update_bits(cs4271->regmap, CS4271_MODE1, cs4271_hw_params()
426 ret = regmap_update_bits(cs4271->regmap, CS4271_VOLA, cs4271_mute_stream()
431 ret = regmap_update_bits(cs4271->regmap, CS4271_VOLB, cs4271_mute_stream()
497 ret = regmap_update_bits(cs4271->regmap, CS4271_MODE2, cs4271_soc_suspend()
511 ret = regcache_sync(cs4271->regmap); cs4271_soc_resume()
516 ret = regmap_update_bits(cs4271->regmap, CS4271_MODE2, cs4271_soc_resume()
570 ret = regmap_update_bits(cs4271->regmap, CS4271_MODE2, cs4271_codec_probe()
575 ret = regmap_update_bits(cs4271->regmap, CS4271_MODE2, cs4271_codec_probe()
583 regmap_update_bits(cs4271->regmap, CS4271_MODE2, cs4271_codec_probe()
656 int cs4271_probe(struct device *dev, struct regmap *regmap) cs4271_probe() argument
661 if (IS_ERR(regmap)) cs4271_probe()
662 return PTR_ERR(regmap); cs4271_probe()
669 cs4271->regmap = regmap; cs4271_probe()
H A Dadau17x1.c22 #include <linux/regmap.h>
74 regmap_update_bits(adau->regmap, ADAU17X1_CLOCK_CONTROL, adau17x1_pll_event()
79 ret = regmap_raw_write(adau->regmap, ADAU17X1_PLL_CONTROL, adau17x1_pll_event()
84 regmap_update_bits(adau->regmap, ADAU17X1_CLOCK_CONTROL, adau17x1_pll_event()
213 ret = regmap_read(adau->regmap, reg, &val); adau17x1_dsp_mux_enum_get()
354 regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0, adau17x1_hw_params()
357 regmap_write(adau->regmap, ADAU17X1_SERIAL_SAMPLING_RATE, div); adau17x1_hw_params()
358 regmap_write(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, dsp_div); adau17x1_hw_params()
384 return regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT1, adau17x1_hw_params()
434 ret = regmap_raw_write(adau->regmap, ADAU17X1_PLL_CONTROL, adau17x1_set_dai_pll()
539 regmap_write(adau->regmap, ADAU17X1_SERIAL_PORT0, ctrl0); adau17x1_set_dai_fmt()
540 regmap_write(adau->regmap, ADAU17X1_SERIAL_PORT1, ctrl1); adau17x1_set_dai_fmt()
647 regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0, adau17x1_set_dai_tdm_slot()
649 regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER1, adau17x1_set_dai_tdm_slot()
651 regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT0, adau17x1_set_dai_tdm_slot()
653 regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT1, adau17x1_set_dai_tdm_slot()
660 regmap_write(adau->regmap, ADAU17X1_SERIAL_INPUT_ROUTE, adau17x1_set_dai_tdm_slot()
665 regmap_write(adau->regmap, ADAU17X1_SERIAL_OUTPUT_ROUTE, adau17x1_set_dai_tdm_slot()
706 return regmap_write(adau->regmap, ADAU17X1_MICBIAS, micbias << 2); adau17x1_set_micbias_voltage()
787 ret = regmap_read(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, &dspsr); adau17x1_setup_firmware()
791 regmap_write(adau->regmap, ADAU17X1_DSP_ENABLE, 1); adau17x1_setup_firmware()
792 regmap_write(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, 0xf); adau17x1_setup_firmware()
796 regmap_write(adau->regmap, ADAU17X1_DSP_ENABLE, 0); adau17x1_setup_firmware()
799 regmap_write(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, dspsr); adau17x1_setup_firmware()
871 regcache_sync(adau->regmap); adau17x1_resume()
877 int adau17x1_probe(struct device *dev, struct regmap *regmap, adau17x1_probe() argument
883 if (IS_ERR(regmap)) adau17x1_probe()
884 return PTR_ERR(regmap); adau17x1_probe()
890 adau->regmap = regmap; adau17x1_probe()
897 adau->sigmadsp = devm_sigmadsp_init_regmap(dev, regmap, NULL, adau17x1_probe()
H A Dpcm1792a.c74 struct regmap *regmap; member in struct:pcm1792a_private
96 ret = regmap_update_bits(priv->regmap, PCM1792A_SOFT_MUTE, pcm1792a_digital_mute()
148 ret = regmap_update_bits(priv->regmap, PCM1792A_FMT_CONTROL, pcm1792a_hw_params()
234 pcm1792a->regmap = devm_regmap_init_spi(spi, &pcm1792a_regmap); pcm1792a_spi_probe()
235 if (IS_ERR(pcm1792a->regmap)) { pcm1792a_spi_probe()
236 ret = PTR_ERR(pcm1792a->regmap); pcm1792a_spi_probe()
237 dev_err(&spi->dev, "Failed to register regmap: %d\n", ret); pcm1792a_spi_probe()
H A Dsta32x.c29 #include <linux/regmap.h>
144 struct regmap *regmap; member in struct:sta32x_priv
283 regmap_read(sta32x->regmap, STA32X_CFUD, &cfud); sta32x_coefficient_get()
289 regmap_write(sta32x->regmap, STA32X_CFUD, cfud); sta32x_coefficient_get()
291 regmap_write(sta32x->regmap, STA32X_CFADDR2, index); sta32x_coefficient_get()
293 regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x04); sta32x_coefficient_get()
295 regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x08); sta32x_coefficient_get()
302 regmap_read(sta32x->regmap, STA32X_B1CF1 + i, &val); sta32x_coefficient_get()
323 regmap_read(sta32x->regmap, STA32X_CFUD, &cfud); sta32x_coefficient_put()
329 regmap_write(sta32x->regmap, STA32X_CFUD, cfud); sta32x_coefficient_put()
331 regmap_write(sta32x->regmap, STA32X_CFADDR2, index); sta32x_coefficient_put()
338 regmap_write(sta32x->regmap, STA32X_B1CF1 + i, sta32x_coefficient_put()
341 regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x01); sta32x_coefficient_put()
343 regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x02); sta32x_coefficient_put()
357 regmap_read(sta32x->regmap, STA32X_CFUD, &cfud); sta32x_sync_coef_shadow()
361 regmap_write(sta32x->regmap, STA32X_CFADDR2, i); sta32x_sync_coef_shadow()
362 regmap_write(sta32x->regmap, STA32X_B1CF1, sta32x_sync_coef_shadow()
364 regmap_write(sta32x->regmap, STA32X_B1CF2, sta32x_sync_coef_shadow()
366 regmap_write(sta32x->regmap, STA32X_B1CF3, sta32x_sync_coef_shadow()
372 regmap_write(sta32x->regmap, STA32X_CFUD, cfud); sta32x_sync_coef_shadow()
373 regmap_write(sta32x->regmap, STA32X_CFUD, cfud | 0x01); sta32x_sync_coef_shadow()
385 regmap_read(sta32x->regmap, STA32X_MMUTE, &mute); sta32x_cache_sync()
386 regmap_write(sta32x->regmap, STA32X_MMUTE, mute | STA32X_MMUTE_MMUTE); sta32x_cache_sync()
388 rc = regcache_sync(sta32x->regmap); sta32x_cache_sync()
389 regmap_write(sta32x->regmap, STA32X_MMUTE, mute); sta32x_cache_sync()
403 regcache_cache_bypass(sta32x->regmap, true); sta32x_watchdog()
405 regcache_cache_bypass(sta32x->regmap, false); sta32x_watchdog()
407 regcache_mark_dirty(sta32x->regmap); sta32x_watchdog()
637 return regmap_update_bits(sta32x->regmap, STA32X_CONFB, sta32x_set_dai_fmt()
767 ret = regmap_update_bits(sta32x->regmap, STA32X_CONFA, sta32x_hw_params()
773 ret = regmap_update_bits(sta32x->regmap, STA32X_CONFB, sta32x_hw_params()
816 regmap_update_bits(sta32x->regmap, STA32X_CONFF, sta32x_set_bias_level()
837 regmap_update_bits(sta32x->regmap, STA32X_CONFF, sta32x_set_bias_level()
845 regmap_update_bits(sta32x->regmap, STA32X_CONFF, sta32x_set_bias_level()
904 regmap_update_bits(sta32x->regmap, STA32X_CONFA, sta32x_probe()
910 regmap_update_bits(sta32x->regmap, STA32X_CONFC, sta32x_probe()
916 regmap_update_bits(sta32x->regmap, STA32X_CONFE, sta32x_probe()
920 regmap_update_bits(sta32x->regmap, STA32X_CONFE, sta32x_probe()
924 regmap_update_bits(sta32x->regmap, STA32X_CONFE, sta32x_probe()
928 regmap_update_bits(sta32x->regmap, STA32X_CONFE, sta32x_probe()
934 regmap_update_bits(sta32x->regmap, STA32X_CONFF, sta32x_probe()
940 regmap_update_bits(sta32x->regmap, STA32X_CONFF, sta32x_probe()
946 regmap_update_bits(sta32x->regmap, STA32X_C1CFG, sta32x_probe()
950 regmap_update_bits(sta32x->regmap, STA32X_C2CFG, sta32x_probe()
954 regmap_update_bits(sta32x->regmap, STA32X_C3CFG, sta32x_probe()
1121 sta32x->regmap = devm_regmap_init_i2c(i2c, &sta32x_regmap); sta32x_i2c_probe()
1122 if (IS_ERR(sta32x->regmap)) { sta32x_i2c_probe()
1123 ret = PTR_ERR(sta32x->regmap); sta32x_i2c_probe()
1124 dev_err(dev, "Failed to init regmap: %d\n", ret); sta32x_i2c_probe()
H A Dcs35l32.c22 #include <linux/regmap.h>
46 struct regmap *regmap; member in struct:cs35l32_private
394 cs35l32->regmap = devm_regmap_init_i2c(i2c_client, &cs35l32_regmap); cs35l32_i2c_probe()
395 if (IS_ERR(cs35l32->regmap)) { cs35l32_i2c_probe()
396 ret = PTR_ERR(cs35l32->regmap); cs35l32_i2c_probe()
449 ret = regmap_read(cs35l32->regmap, CS35L32_DEVID_AB, &reg); cs35l32_i2c_probe()
452 ret = regmap_read(cs35l32->regmap, CS35L32_DEVID_CD, &reg); cs35l32_i2c_probe()
455 ret = regmap_read(cs35l32->regmap, CS35L32_DEVID_E, &reg); cs35l32_i2c_probe()
466 ret = regmap_read(cs35l32->regmap, CS35L32_REV_ID, &reg); cs35l32_i2c_probe()
472 ret = regmap_register_patch(cs35l32->regmap, cs35l32_monitor_patch, cs35l32_i2c_probe()
484 regmap_update_bits(cs35l32->regmap, CS35L32_AUDIO_LED_MNGR, cs35l32_i2c_probe()
490 regmap_update_bits(cs35l32->regmap, CS35L32_ADSP_CTL, cs35l32_i2c_probe()
496 regmap_update_bits(cs35l32->regmap, CS35L32_ADSP_CTL, cs35l32_i2c_probe()
502 regmap_update_bits(cs35l32->regmap, CS35L32_BATT_THRESHOLD, cs35l32_i2c_probe()
508 regmap_update_bits(cs35l32->regmap, CS35L32_BATT_THRESHOLD, cs35l32_i2c_probe()
513 regmap_update_bits(cs35l32->regmap, CS35L32_PWRCTL1, CS35L32_PDN_AMP, cs35l32_i2c_probe()
517 ret = regmap_read(cs35l32->regmap, CS35L32_INT_STATUS_1, &reg); cs35l32_i2c_probe()
551 regcache_cache_only(cs35l32->regmap, true); cs35l32_runtime_suspend()
552 regcache_mark_dirty(cs35l32->regmap); cs35l32_runtime_suspend()
582 regcache_cache_only(cs35l32->regmap, false); cs35l32_runtime_resume()
583 regcache_sync(cs35l32->regmap); cs35l32_runtime_resume()
H A Dad193x.h12 #include <linux/regmap.h>
17 int ad193x_probe(struct device *dev, struct regmap *regmap);
H A Dak4104.c50 struct regmap *regmap; member in struct:ak4104_private
92 ret = regmap_update_bits(ak4104->regmap, AK4104_REG_CONTROL1, ak4104_set_dai_fmt()
111 regmap_write(ak4104->regmap, AK4104_REG_CHN_STATUS(0), val); ak4104_hw_params()
148 ret = regmap_write(ak4104->regmap, AK4104_REG_CHN_STATUS(3), val); ak4104_hw_params()
186 ret = regmap_update_bits(ak4104->regmap, AK4104_REG_CONTROL1, ak4104_probe()
193 ret = regmap_update_bits(ak4104->regmap, AK4104_REG_TX, ak4104_probe()
209 regmap_update_bits(ak4104->regmap, AK4104_REG_CONTROL1, ak4104_remove()
290 ak4104->regmap = devm_regmap_init_spi(spi, &ak4104_regmap); ak4104_spi_probe()
291 if (IS_ERR(ak4104->regmap)) { ak4104_spi_probe()
292 ret = PTR_ERR(ak4104->regmap); ak4104_spi_probe()
313 ret = regmap_read(ak4104->regmap, AK4104_REG_RESERVED, &val); ak4104_spi_probe()
H A Dsigmadsp.h13 #include <linux/regmap.h>
56 struct regmap *regmap, const struct sigmadsp_ops *ops,
H A Dwm8804.h16 #include <linux/regmap.h>
70 int wm8804_probe(struct device *dev, struct regmap *regmap);
H A Dcs42xx8.c42 struct regmap *regmap; member in struct:cs42xx8_priv
230 regmap_update_bits(cs42xx8->regmap, CS42XX8_INTF, cs42xx8_set_dai_fmt()
275 regmap_update_bits(cs42xx8->regmap, CS42XX8_FUNCMOD, cs42xx8_hw_params()
287 regmap_update_bits(cs42xx8->regmap, CS42XX8_DACMUTE, cs42xx8_digital_mute()
399 regmap_write(cs42xx8->regmap, CS42XX8_DACMUTE, CS42XX8_DACMUTE_ALL); cs42xx8_codec_probe()
436 int cs42xx8_probe(struct device *dev, struct regmap *regmap) cs42xx8_probe() argument
485 cs42xx8->regmap = regmap; cs42xx8_probe()
486 if (IS_ERR(cs42xx8->regmap)) { cs42xx8_probe()
487 ret = PTR_ERR(cs42xx8->regmap); cs42xx8_probe()
488 dev_err(dev, "failed to allocate regmap: %d\n", ret); cs42xx8_probe()
497 regcache_cache_bypass(cs42xx8->regmap, true); cs42xx8_probe()
500 ret = regmap_read(cs42xx8->regmap, CS42XX8_CHIPID, &val); cs42xx8_probe()
517 regcache_cache_bypass(cs42xx8->regmap, false); cs42xx8_probe()
530 regcache_cache_only(cs42xx8->regmap, true); cs42xx8_probe()
562 regcache_cache_only(cs42xx8->regmap, false); cs42xx8_runtime_resume()
564 ret = regcache_sync(cs42xx8->regmap); cs42xx8_runtime_resume()
566 dev_err(dev, "failed to sync regmap: %d\n", ret); cs42xx8_runtime_resume()
585 regcache_cache_only(cs42xx8->regmap, true); cs42xx8_runtime_suspend()
/linux-4.1.27/drivers/acpi/pmic/
H A Dintel_pmic.h11 int (*get_power)(struct regmap *r, int reg, int bit, u64 *value);
12 int (*update_power)(struct regmap *r, int reg, int bit, bool on);
13 int (*get_raw_temp)(struct regmap *r, int reg);
14 int (*update_aux)(struct regmap *r, int reg, int raw_temp);
15 int (*get_policy)(struct regmap *r, int reg, u64 *value);
16 int (*update_policy)(struct regmap *r, int reg, int enable);
23 int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle, struct regmap *regmap, struct intel_pmic_opregion_data *d);
H A Dintel_pmic_crc.c19 #include <linux/regmap.h>
91 static int intel_crc_pmic_get_power(struct regmap *regmap, int reg, intel_crc_pmic_get_power() argument
96 if (regmap_read(regmap, reg, &data)) intel_crc_pmic_get_power()
103 static int intel_crc_pmic_update_power(struct regmap *regmap, int reg, intel_crc_pmic_update_power() argument
108 if (regmap_read(regmap, reg, &data)) intel_crc_pmic_update_power()
118 if (regmap_write(regmap, reg, data)) intel_crc_pmic_update_power()
123 static int intel_crc_pmic_get_raw_temp(struct regmap *regmap, int reg) intel_crc_pmic_get_raw_temp() argument
131 if (regmap_read(regmap, reg, &temp_l) || intel_crc_pmic_get_raw_temp()
132 regmap_read(regmap, reg - 1, &temp_h)) intel_crc_pmic_get_raw_temp()
138 static int intel_crc_pmic_update_aux(struct regmap *regmap, int reg, int raw) intel_crc_pmic_update_aux() argument
140 return regmap_write(regmap, reg, raw) || intel_crc_pmic_update_aux()
141 regmap_update_bits(regmap, reg - 1, 0x3, raw >> 8) ? -EIO : 0; intel_crc_pmic_update_aux()
144 static int intel_crc_pmic_get_policy(struct regmap *regmap, int reg, u64 *value) intel_crc_pmic_get_policy() argument
148 if (regmap_read(regmap, reg, &pen)) intel_crc_pmic_get_policy()
154 static int intel_crc_pmic_update_policy(struct regmap *regmap, intel_crc_pmic_update_policy() argument
160 if (regmap_read(regmap, PMIC_A0LOCK_REG, &alert0)) intel_crc_pmic_update_policy()
163 if (regmap_update_bits(regmap, PMIC_A0LOCK_REG, 0x01, 0)) intel_crc_pmic_update_policy()
166 if (regmap_update_bits(regmap, reg, 0x80, enable << 7)) intel_crc_pmic_update_policy()
170 if (regmap_write(regmap, PMIC_A0LOCK_REG, alert0)) intel_crc_pmic_update_policy()
193 ACPI_HANDLE(pdev->dev.parent), pmic->regmap, intel_crc_pmic_opregion_probe()
H A Dintel_pmic.c18 #include <linux/regmap.h>
28 struct regmap *regmap; member in struct:intel_pmic_opregion
53 struct regmap *regmap = opregion->regmap; intel_pmic_power_handler() local
71 d->get_power(regmap, reg, bit, value64) : intel_pmic_power_handler()
72 d->update_power(regmap, reg, bit, *value64 == 1); intel_pmic_power_handler()
87 raw_temp = opregion->data->get_raw_temp(opregion->regmap, reg); pmic_read_temp()
130 return opregion->data->update_aux(opregion->regmap, reg, raw_temp); pmic_thermal_aux()
137 struct regmap *regmap = opregion->regmap; pmic_thermal_pen() local
143 return d->get_policy(regmap, reg, value); pmic_thermal_pen()
148 return d->update_policy(regmap, reg, *value); pmic_thermal_pen()
207 struct regmap *regmap, intel_pmic_install_opregion_handler()
214 if (!dev || !regmap || !d) intel_pmic_install_opregion_handler()
225 opregion->regmap = regmap; intel_pmic_install_opregion_handler()
206 intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle, struct regmap *regmap, struct intel_pmic_opregion_data *d) intel_pmic_install_opregion_handler() argument
H A Dintel_pmic_xpower.c19 #include <linux/regmap.h>
152 static int intel_xpower_pmic_get_power(struct regmap *regmap, int reg, intel_xpower_pmic_get_power() argument
157 if (regmap_read(regmap, reg, &data)) intel_xpower_pmic_get_power()
164 static int intel_xpower_pmic_update_power(struct regmap *regmap, int reg, intel_xpower_pmic_update_power() argument
169 if (regmap_read(regmap, reg, &data)) intel_xpower_pmic_update_power()
177 if (regmap_write(regmap, reg, data)) intel_xpower_pmic_update_power()
186 * @regmap: regmap of the PMIC device
196 static int intel_xpower_pmic_get_raw_temp(struct regmap *regmap, int reg) intel_xpower_pmic_get_raw_temp() argument
244 ACPI_HANDLE(parent), axp20x->regmap, intel_xpower_pmic_opregion_probe()
/linux-4.1.27/include/linux/mfd/
H A Dsyscon.h23 extern struct regmap *syscon_node_to_regmap(struct device_node *np);
24 extern struct regmap *syscon_regmap_lookup_by_compatible(const char *s);
25 extern struct regmap *syscon_regmap_lookup_by_pdevname(const char *s);
26 extern struct regmap *syscon_regmap_lookup_by_phandle(
30 static inline struct regmap *syscon_node_to_regmap(struct device_node *np) syscon_node_to_regmap()
35 static inline struct regmap *syscon_regmap_lookup_by_compatible(const char *s) syscon_regmap_lookup_by_compatible()
40 static inline struct regmap *syscon_regmap_lookup_by_pdevname(const char *s) syscon_regmap_lookup_by_pdevname()
45 static inline struct regmap *syscon_regmap_lookup_by_phandle( syscon_regmap_lookup_by_phandle()
H A Drt5033.h17 #include <linux/regmap.h>
32 struct regmap *regmap; member in struct:rt5033_dev
41 struct regmap *regmap; member in struct:rt5033_battery
H A Dbcm590xx.h19 #include <linux/regmap.h>
29 struct regmap *regmap_pri;
30 struct regmap *regmap_sec;
H A Dintel_soc_pmic.h22 #include <linux/regmap.h>
26 struct regmap *regmap; member in struct:intel_soc_pmic
H A Dstw481x.h14 #include <linux/regmap.h>
45 * @map: regmap handle to access device registers
49 struct regmap *map;
H A Dsmsc.h18 #include <linux/regmap.h>
33 struct regmap *regmap; member in struct:smsc
47 return regmap_read(smsc->regmap, reg, dest); smsc_read()
55 return regmap_write(smsc->regmap, reg, value); smsc_write()
H A Dhi6421-pmic.h38 struct regmap *regmap; member in struct:hi6421_pmic
H A Datmel-hlcdc.h24 #include <linux/regmap.h>
71 * @regmap: register map used to access HLCDC IP registers
78 struct regmap *regmap; member in struct:atmel_hlcdc
H A Dlp3943.h19 #include <linux/regmap.h>
94 * @regmap: Used for I2C communication on accessing registers
105 struct regmap *regmap; member in struct:lp3943
H A Das3711.h75 struct regmap;
79 struct regmap *regmap; member in struct:as3711
/linux-4.1.27/drivers/mfd/
H A Dsyscon.c24 #include <linux/regmap.h>
35 struct regmap *regmap; member in struct:syscon
48 struct regmap *regmap; of_syscon_register() local
72 regmap = regmap_init_mmio(NULL, base, &syscon_config); of_syscon_register()
73 if (IS_ERR(regmap)) { of_syscon_register()
74 pr_err("regmap init failed\n"); of_syscon_register()
75 ret = PTR_ERR(regmap); of_syscon_register()
79 syscon->regmap = regmap; of_syscon_register()
95 struct regmap *syscon_node_to_regmap(struct device_node *np) syscon_node_to_regmap()
115 return syscon->regmap; syscon_node_to_regmap()
119 struct regmap *syscon_regmap_lookup_by_compatible(const char *s) syscon_regmap_lookup_by_compatible()
122 struct regmap *regmap; syscon_regmap_lookup_by_compatible() local
128 regmap = syscon_node_to_regmap(syscon_np); syscon_regmap_lookup_by_compatible()
131 return regmap; syscon_regmap_lookup_by_compatible()
140 struct regmap *syscon_regmap_lookup_by_pdevname(const char *s) syscon_regmap_lookup_by_pdevname()
152 return syscon->regmap; syscon_regmap_lookup_by_pdevname()
156 struct regmap *syscon_regmap_lookup_by_phandle(struct device_node *np, syscon_regmap_lookup_by_phandle()
160 struct regmap *regmap; syscon_regmap_lookup_by_phandle() local
170 regmap = syscon_node_to_regmap(syscon_np); syscon_regmap_lookup_by_phandle()
173 return regmap; syscon_regmap_lookup_by_phandle()
200 syscon->regmap = devm_regmap_init_mmio(dev, base, syscon_probe()
202 if (IS_ERR(syscon->regmap)) { syscon_probe()
203 dev_err(dev, "regmap init failed\n"); syscon_probe()
204 return PTR_ERR(syscon->regmap); syscon_probe()
209 dev_dbg(dev, "regmap %pR registered\n", res); syscon_probe()
H A Dsmsc-ece1099.c21 #include <linux/regmap.h>
48 smsc->regmap = devm_regmap_init_i2c(i2c, &smsc_regmap_config); smsc_i2c_probe()
49 if (IS_ERR(smsc->regmap)) { smsc_i2c_probe()
50 ret = PTR_ERR(smsc->regmap); smsc_i2c_probe()
61 regmap_read(smsc->regmap, SMSC_DEV_ID, &devid); smsc_i2c_probe()
62 regmap_read(smsc->regmap, SMSC_DEV_REV, &rev); smsc_i2c_probe()
63 regmap_read(smsc->regmap, SMSC_VEN_ID_L, &venid_l); smsc_i2c_probe()
64 regmap_read(smsc->regmap, SMSC_VEN_ID_H, &venid_h); smsc_i2c_probe()
69 ret = regmap_write(smsc->regmap, SMSC_CLK_CTRL, smsc->clk); smsc_i2c_probe()
H A Dsky81452.c26 #include <linux/regmap.h>
41 struct regmap *regmap; sky81452_probe() local
50 regmap = devm_regmap_init_i2c(client, &sky81452_config); sky81452_probe()
51 if (IS_ERR(regmap)) { sky81452_probe()
52 dev_err(dev, "failed to initialize.err=%ld\n", PTR_ERR(regmap)); sky81452_probe()
53 return PTR_ERR(regmap); sky81452_probe()
56 i2c_set_clientdata(client, regmap); sky81452_probe()
H A Dhi6421-pmic-core.c31 #include <linux/regmap.h>
61 pmic->regmap = devm_regmap_init_mmio_clk(&pdev->dev, NULL, base, hi6421_pmic_probe()
63 if (IS_ERR(pmic->regmap)) { hi6421_pmic_probe()
65 "regmap init failed: %ld\n", PTR_ERR(pmic->regmap)); hi6421_pmic_probe()
66 return PTR_ERR(pmic->regmap); hi6421_pmic_probe()
70 regmap_update_bits(pmic->regmap, HI6421_OCP_DEB_CTRL_REG, hi6421_pmic_probe()
H A Drn5t618.c18 #include <linux/regmap.h>
55 regmap_update_bits(rn5t618_pm_power_off->regmap, RN5T618_REPCNT, rn5t618_power_off()
58 regmap_update_bits(rn5t618_pm_power_off->regmap, RN5T618_SLPCNT, rn5t618_power_off()
74 priv->regmap = devm_regmap_init_i2c(i2c, &rn5t618_regmap_config); rn5t618_i2c_probe()
75 if (IS_ERR(priv->regmap)) { rn5t618_i2c_probe()
76 ret = PTR_ERR(priv->regmap); rn5t618_i2c_probe()
77 dev_err(&i2c->dev, "regmap init failed: %d\n", ret); rn5t618_i2c_probe()
H A Dmc13xxx.h13 #include <linux/regmap.h>
33 struct regmap *regmap; member in struct:mc13xxx
H A Dpm8921-core.c26 #include <linux/regmap.h>
59 struct regmap *regmap; member in struct:pm_irq_chip
74 rc = regmap_write(chip->regmap, SSBI_REG_ADDR_IRQ_BLK_SEL, bp); pm8xxx_read_block_irq()
80 rc = regmap_read(chip->regmap, SSBI_REG_ADDR_IRQ_IT_STATUS, ip); pm8xxx_read_block_irq()
94 rc = regmap_write(chip->regmap, SSBI_REG_ADDR_IRQ_BLK_SEL, bp); pm8xxx_config_irq()
101 rc = regmap_write(chip->regmap, SSBI_REG_ADDR_IRQ_CONFIG, cp); pm8xxx_config_irq()
140 ret = regmap_read(chip->regmap, SSBI_REG_ADDR_IRQ_M_STATUS1 + master, pm8xxx_irq_master_handler()
168 ret = regmap_read(chip->regmap, SSBI_REG_ADDR_IRQ_ROOT, &root); pm8xxx_irq_handler()
285 struct regmap *regmap; pm8921_probe() local
296 regmap = devm_regmap_init(&pdev->dev, NULL, pdev->dev.parent, pm8921_probe()
298 if (IS_ERR(regmap)) pm8921_probe()
299 return PTR_ERR(regmap); pm8921_probe()
302 rc = regmap_read(regmap, REG_HWREV, &val); pm8921_probe()
311 rc = regmap_read(regmap, REG_HWREV_2, &val); pm8921_probe()
327 chip->regmap = regmap; pm8921_probe()
H A D88pm860x-i2c.c15 #include <linux/regmap.h>
21 struct regmap *map = (i2c == chip->client) ? chip->regmap pm860x_reg_read()
38 struct regmap *map = (i2c == chip->client) ? chip->regmap pm860x_reg_write()
51 struct regmap *map = (i2c == chip->client) ? chip->regmap pm860x_bulk_read()
64 struct regmap *map = (i2c == chip->client) ? chip->regmap pm860x_bulk_write()
77 struct regmap *map = (i2c == chip->client) ? chip->regmap pm860x_set_bits()
H A Dwm8350-i2c.c23 #include <linux/regmap.h>
37 wm8350->regmap = devm_regmap_init_i2c(i2c, &wm8350_regmap); wm8350_i2c_probe()
38 if (IS_ERR(wm8350->regmap)) { wm8350_i2c_probe()
39 ret = PTR_ERR(wm8350->regmap); wm8350_i2c_probe()
H A Darizona-core.c23 #include <linux/regmap.h>
55 ret = regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, arizona_clk32k_enable()
81 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, arizona_clk32k_disable()
112 ret = regmap_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_8, arizona_underclocked()
152 ret = regmap_bulk_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_6, arizona_overclocked()
215 ret = regmap_read(arizona->regmap, reg, &val); arizona_poll_reg()
245 regmap_write(arizona->regmap, ARIZONA_INTERRUPT_STATUS_5, arizona_wait_for_boot()
259 ret = regmap_read(arizona->regmap, ARIZONA_FLL1_CONTROL_1, &fll); arizona_apply_hardware_patch()
265 ret = regmap_read(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, &sysclk); arizona_apply_hardware_patch()
273 ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, arizona_apply_hardware_patch()
289 ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 0x0144); arizona_apply_hardware_patch()
296 ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0, arizona_apply_hardware_patch()
306 regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0, arizona_apply_hardware_patch()
312 err = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, sysclk); arizona_apply_hardware_patch()
320 err = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, fll); arizona_apply_hardware_patch()
347 regcache_cache_only(arizona->regmap, false); arizona_runtime_resume()
352 ret = regmap_update_bits(arizona->regmap, arizona_runtime_resume()
384 ret = regmap_update_bits(arizona->regmap, arizona_runtime_resume()
396 ret = regcache_sync(arizona->regmap); arizona_runtime_resume()
405 regcache_cache_only(arizona->regmap, true); arizona_runtime_resume()
418 ret = regmap_update_bits(arizona->regmap, arizona_runtime_suspend()
429 regcache_cache_only(arizona->regmap, true); arizona_runtime_suspend()
430 regcache_mark_dirty(arizona->regmap); arizona_runtime_suspend()
680 regcache_cache_only(arizona->regmap, true); arizona_dev_init()
759 regcache_cache_only(arizona->regmap, false); arizona_dev_init()
762 ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg); arizona_dev_init()
780 regcache_mark_dirty(arizona->regmap); arizona_dev_init()
782 ret = regmap_write(arizona->regmap, ARIZONA_SOFTWARE_RESET, 0); arizona_dev_init()
790 ret = regcache_sync(arizona->regmap); arizona_dev_init()
800 ret = regmap_read(arizona->regmap, arizona_dev_init()
820 ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, &reg); arizona_dev_init()
826 ret = regmap_read(arizona->regmap, ARIZONA_DEVICE_REVISION, arizona_dev_init()
911 regmap_write(arizona->regmap, ARIZONA_GPIO1_CTRL + i, arizona_dev_init()
922 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, arizona_dev_init()
928 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, arizona_dev_init()
963 regmap_update_bits(arizona->regmap, arizona_dev_init()
978 regmap_update_bits(arizona->regmap, arizona_dev_init()
991 regmap_update_bits(arizona->regmap, arizona_dev_init()
998 regmap_update_bits(arizona->regmap, arizona_dev_init()
1005 regmap_update_bits(arizona->regmap, arizona_dev_init()
H A Dmt6397-core.c19 #include <linux/regmap.h>
51 regmap_write(mt6397->regmap, MT6397_INT_CON0, mt6397->irq_masks_cur[0]); mt6397_irq_sync_unlock()
52 regmap_write(mt6397->regmap, MT6397_INT_CON1, mt6397->irq_masks_cur[1]); mt6397_irq_sync_unlock()
89 ret = regmap_read(mt6397->regmap, reg, &status); mt6397_irq_handle_reg()
103 regmap_write(mt6397->regmap, reg, status); mt6397_irq_handle_reg()
144 regmap_write(mt6397->regmap, MT6397_INT_CON0, 0x0); mt6397_irq_init()
145 regmap_write(mt6397->regmap, MT6397_INT_CON1, 0x0); mt6397_irq_init()
179 mt6397->regmap = dev_get_regmap(pdev->dev.parent, NULL); mt6397_probe()
180 if (!mt6397->regmap) mt6397_probe()
H A Dwm8400-core.c23 #include <linux/regmap.h>
51 ret = regmap_read(wm8400->regmap, reg, &val); wm8400_reg_read()
61 return regmap_bulk_read(wm8400->regmap, reg, data, count); wm8400_block_read()
92 ret = regmap_read(wm8400->regmap, WM8400_RESET_ID, &reg); wm8400_init()
103 ret = regmap_read(wm8400->regmap, WM8400_ID, &reg); wm8400_init()
155 regmap_reinit_cache(wm8400->regmap, &wm8400_regmap_config); wm8400_reset_codec_reg_cache()
169 wm8400->regmap = devm_regmap_init_i2c(i2c, &wm8400_regmap_config); wm8400_i2c_probe()
170 if (IS_ERR(wm8400->regmap)) wm8400_i2c_probe()
171 return PTR_ERR(wm8400->regmap); wm8400_i2c_probe()
H A Dlp8788.c131 ret = regmap_read(lp->regmap, reg, &val); lp8788_read_byte()
144 return regmap_bulk_read(lp->regmap, reg, data, count); lp8788_read_multi_bytes()
150 return regmap_write(lp->regmap, reg, data); lp8788_write_byte()
156 return regmap_update_bits(lp->regmap, reg, mask, data); lp8788_update_bits()
183 lp->regmap = devm_regmap_init_i2c(cl, &lp8788_regmap_config); lp8788_probe()
184 if (IS_ERR(lp->regmap)) { lp8788_probe()
185 ret = PTR_ERR(lp->regmap); lp8788_probe()
186 dev_err(&cl->dev, "regmap init i2c err: %d\n", ret); lp8788_probe()
H A Dqcom-spmi-pmic.c17 #include <linux/regmap.h>
61 static void pmic_spmi_show_revid(struct regmap *map, struct device *dev) pmic_spmi_show_revid()
124 struct regmap *regmap; pmic_spmi_probe() local
126 regmap = devm_regmap_init_spmi_ext(sdev, &spmi_regmap_config); pmic_spmi_probe()
127 if (IS_ERR(regmap)) pmic_spmi_probe()
128 return PTR_ERR(regmap); pmic_spmi_probe()
130 pmic_spmi_show_revid(regmap, &sdev->dev); pmic_spmi_probe()
H A Drk808.c24 #include <linux/regmap.h>
163 ret = regmap_update_bits(rk808->regmap, rk808_device_shutdown()
188 rk808->regmap = devm_regmap_init_i2c(client, &rk808_regmap_config); rk808_probe()
189 if (IS_ERR(rk808->regmap)) { rk808_probe()
190 dev_err(&client->dev, "regmap initialization failed\n"); rk808_probe()
191 return PTR_ERR(rk808->regmap); rk808_probe()
195 ret = regmap_update_bits(rk808->regmap, pre_init_reg[i].addr, rk808_probe()
205 ret = regmap_add_irq_chip(rk808->regmap, client->irq, rk808_probe()
H A Darizona-i2c.c17 #include <linux/regmap.h>
66 arizona->regmap = devm_regmap_init_i2c(i2c, regmap_config); arizona_i2c_probe()
67 if (IS_ERR(arizona->regmap)) { arizona_i2c_probe()
68 ret = PTR_ERR(arizona->regmap); arizona_i2c_probe()
H A Darizona-spi.c16 #include <linux/regmap.h>
61 arizona->regmap = devm_regmap_init_spi(spi, regmap_config); arizona_spi_probe()
62 if (IS_ERR(arizona->regmap)) { arizona_spi_probe()
63 ret = PTR_ERR(arizona->regmap); arizona_spi_probe()
H A Dmc13xxx-i2c.c72 mc13xxx->regmap = devm_regmap_init_i2c(client, mc13xxx_i2c_probe()
74 if (IS_ERR(mc13xxx->regmap)) { mc13xxx_i2c_probe()
75 ret = PTR_ERR(mc13xxx->regmap); mc13xxx_i2c_probe()
76 dev_err(&client->dev, "Failed to initialize regmap: %d\n", ret); mc13xxx_i2c_probe()
H A Dwm831x-i2c.c22 #include <linux/regmap.h>
40 wm831x->regmap = devm_regmap_init_i2c(i2c, &wm831x_regmap_config); wm831x_i2c_probe()
41 if (IS_ERR(wm831x->regmap)) { wm831x_i2c_probe()
42 ret = PTR_ERR(wm831x->regmap); wm831x_i2c_probe()
H A Dwm831x-spi.c19 #include <linux/regmap.h>
42 wm831x->regmap = devm_regmap_init_spi(spi, &wm831x_regmap_config); wm831x_spi_probe()
43 if (IS_ERR(wm831x->regmap)) { wm831x_spi_probe()
44 ret = PTR_ERR(wm831x->regmap); wm831x_spi_probe()
H A Dwm8994.h18 #include <linux/regmap.h>
H A Dretu-mfd.c25 #include <linux/regmap.h>
42 struct regmap *regmap; member in struct:retu_dev
149 ret = regmap_read(rdev->regmap, reg, &value); retu_read()
161 ret = regmap_write(rdev->regmap, reg, data); retu_write()
176 regmap_read(rdev->regmap, RETU_REG_CC1, &reg); retu_power_off()
177 regmap_write(rdev->regmap, RETU_REG_CC1, reg | 2); retu_power_off()
180 regmap_write(rdev->regmap, RETU_REG_WATCHDOG, 0); retu_power_off()
247 rdev->regmap = devm_regmap_init(&i2c->dev, &retu_bus, &i2c->dev, retu_probe()
249 if (IS_ERR(rdev->regmap)) retu_probe()
250 return PTR_ERR(rdev->regmap); retu_probe()
269 ret = regmap_add_irq_chip(rdev->regmap, i2c->irq, IRQF_ONESHOT, -1, retu_probe()
H A Dtps65217.c25 #include <linux/regmap.h>
54 return regmap_read(tps->regmap, reg, val); tps65217_reg_read()
74 return regmap_write(tps->regmap, reg, val); tps65217_reg_write()
77 ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD, tps65217_reg_write()
82 return regmap_write(tps->regmap, reg, val); tps65217_reg_write()
85 ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD, tps65217_reg_write()
89 ret = regmap_write(tps->regmap, reg, val); tps65217_reg_write()
92 ret = regmap_write(tps->regmap, TPS65217_REG_PASSWORD, tps65217_reg_write()
96 return regmap_write(tps->regmap, reg, val); tps65217_reg_write()
195 tps->regmap = devm_regmap_init_i2c(client, &tps65217_regmap_config); tps65217_probe()
196 if (IS_ERR(tps->regmap)) { tps65217_probe()
197 ret = PTR_ERR(tps->regmap); tps65217_probe()
/linux-4.1.27/drivers/staging/media/mn88473/
H A Dmn88473.c101 ret = regmap_write(dev->regmap[2], 0x05, 0x00); mn88473_set_frontend()
102 ret = regmap_write(dev->regmap[2], 0xfb, 0x13); mn88473_set_frontend()
103 ret = regmap_write(dev->regmap[2], 0xef, 0x13); mn88473_set_frontend()
104 ret = regmap_write(dev->regmap[2], 0xf9, 0x13); mn88473_set_frontend()
105 ret = regmap_write(dev->regmap[2], 0x00, 0x18); mn88473_set_frontend()
106 ret = regmap_write(dev->regmap[2], 0x01, 0x01); mn88473_set_frontend()
107 ret = regmap_write(dev->regmap[2], 0x02, 0x21); mn88473_set_frontend()
108 ret = regmap_write(dev->regmap[2], 0x03, delivery_system_val); mn88473_set_frontend()
109 ret = regmap_write(dev->regmap[2], 0x0b, 0x00); mn88473_set_frontend()
112 ret = regmap_write(dev->regmap[2], 0x10 + i, if_val[i]); mn88473_set_frontend()
118 ret = regmap_write(dev->regmap[2], 0x13 + i, bw_val[i]); mn88473_set_frontend()
123 ret = regmap_write(dev->regmap[2], 0x2d, 0x3b); mn88473_set_frontend()
124 ret = regmap_write(dev->regmap[2], 0x2e, 0x00); mn88473_set_frontend()
125 ret = regmap_write(dev->regmap[2], 0x56, 0x0d); mn88473_set_frontend()
126 ret = regmap_write(dev->regmap[0], 0x01, 0xba); mn88473_set_frontend()
127 ret = regmap_write(dev->regmap[0], 0x02, 0x13); mn88473_set_frontend()
128 ret = regmap_write(dev->regmap[0], 0x03, 0x80); mn88473_set_frontend()
129 ret = regmap_write(dev->regmap[0], 0x04, 0xba); mn88473_set_frontend()
130 ret = regmap_write(dev->regmap[0], 0x05, 0x91); mn88473_set_frontend()
131 ret = regmap_write(dev->regmap[0], 0x07, 0xe7); mn88473_set_frontend()
132 ret = regmap_write(dev->regmap[0], 0x08, 0x28); mn88473_set_frontend()
133 ret = regmap_write(dev->regmap[0], 0x0a, 0x1a); mn88473_set_frontend()
134 ret = regmap_write(dev->regmap[0], 0x13, 0x1f); mn88473_set_frontend()
135 ret = regmap_write(dev->regmap[0], 0x19, 0x03); mn88473_set_frontend()
136 ret = regmap_write(dev->regmap[0], 0x1d, 0xb0); mn88473_set_frontend()
137 ret = regmap_write(dev->regmap[0], 0x2a, 0x72); mn88473_set_frontend()
138 ret = regmap_write(dev->regmap[0], 0x2d, 0x00); mn88473_set_frontend()
139 ret = regmap_write(dev->regmap[0], 0x3c, 0x00); mn88473_set_frontend()
140 ret = regmap_write(dev->regmap[0], 0x3f, 0xf8); mn88473_set_frontend()
141 ret = regmap_write(dev->regmap[0], 0x40, 0xf4); mn88473_set_frontend()
142 ret = regmap_write(dev->regmap[0], 0x41, 0x08); mn88473_set_frontend()
143 ret = regmap_write(dev->regmap[0], 0xd2, 0x29); mn88473_set_frontend()
144 ret = regmap_write(dev->regmap[0], 0xd4, 0x55); mn88473_set_frontend()
145 ret = regmap_write(dev->regmap[1], 0x10, 0x10); mn88473_set_frontend()
146 ret = regmap_write(dev->regmap[1], 0x11, 0xab); mn88473_set_frontend()
147 ret = regmap_write(dev->regmap[1], 0x12, 0x0d); mn88473_set_frontend()
148 ret = regmap_write(dev->regmap[1], 0x13, 0xae); mn88473_set_frontend()
149 ret = regmap_write(dev->regmap[1], 0x14, 0x1d); mn88473_set_frontend()
150 ret = regmap_write(dev->regmap[1], 0x15, 0x9d); mn88473_set_frontend()
151 ret = regmap_write(dev->regmap[1], 0xbe, 0x08); mn88473_set_frontend()
152 ret = regmap_write(dev->regmap[2], 0x09, 0x08); mn88473_set_frontend()
153 ret = regmap_write(dev->regmap[2], 0x08, 0x1d); mn88473_set_frontend()
154 ret = regmap_write(dev->regmap[0], 0xb2, 0x37); mn88473_set_frontend()
155 ret = regmap_write(dev->regmap[0], 0xd7, 0x04); mn88473_set_frontend()
156 ret = regmap_write(dev->regmap[2], 0x32, 0x80); mn88473_set_frontend()
157 ret = regmap_write(dev->regmap[2], 0x36, 0x00); mn88473_set_frontend()
158 ret = regmap_write(dev->regmap[2], 0xf8, 0x9f); mn88473_set_frontend()
188 ret = regmap_read(dev->regmap[0], 0x62, &utmp); mn88473_read_status()
199 ret = regmap_read(dev->regmap[2], 0x8B, &utmp); mn88473_read_status()
212 ret = regmap_read(dev->regmap[1], 0x85, &utmp); mn88473_read_status()
216 ret = regmap_read(dev->regmap[1], 0x89, &utmp); mn88473_read_status()
253 ret = regmap_read(dev->regmap[0], 0xf5, &tmp); mn88473_init()
273 ret = regmap_write(dev->regmap[0], 0xf5, 0x03); mn88473_init()
283 ret = regmap_bulk_write(dev->regmap[0], 0xf6, mn88473_init()
293 ret = regmap_read(dev->regmap[0], 0xf8, &tmp); mn88473_init()
306 ret = regmap_write(dev->regmap[0], 0xf5, 0x00); mn88473_init()
333 ret = regmap_write(dev->regmap[2], 0x05, 0x3e); mn88473_sleep()
415 dev->regmap[0] = regmap_init_i2c(dev->client[0], &regmap_config); mn88473_probe()
416 if (IS_ERR(dev->regmap[0])) { mn88473_probe()
417 ret = PTR_ERR(dev->regmap[0]); mn88473_probe()
422 ret = regmap_read(dev->regmap[0], 0x00, &utmp); mn88473_probe()
438 dev->regmap[1] = regmap_init_i2c(dev->client[1], &regmap_config); mn88473_probe()
439 if (IS_ERR(dev->regmap[1])) { mn88473_probe()
440 ret = PTR_ERR(dev->regmap[1]); mn88473_probe()
452 dev->regmap[2] = regmap_init_i2c(dev->client[2], &regmap_config); mn88473_probe()
453 if (IS_ERR(dev->regmap[2])) { mn88473_probe()
454 ret = PTR_ERR(dev->regmap[2]); mn88473_probe()
471 regmap_exit(dev->regmap[1]); mn88473_probe()
475 regmap_exit(dev->regmap[0]); mn88473_probe()
489 regmap_exit(dev->regmap[2]); mn88473_remove()
492 regmap_exit(dev->regmap[1]); mn88473_remove()
495 regmap_exit(dev->regmap[0]); mn88473_remove()
H A Dmn88473_priv.h23 #include <linux/regmap.h>
29 struct regmap *regmap[3]; member in struct:mn88473_dev
/linux-4.1.27/drivers/staging/media/mn88472/
H A Dmn88472.c103 ret = regmap_write(dev->regmap[2], 0xfb, 0x13); mn88472_set_frontend()
104 ret = regmap_write(dev->regmap[2], 0xef, 0x13); mn88472_set_frontend()
105 ret = regmap_write(dev->regmap[2], 0xf9, 0x13); mn88472_set_frontend()
109 ret = regmap_write(dev->regmap[2], 0x00, 0x66); mn88472_set_frontend()
112 ret = regmap_write(dev->regmap[2], 0x01, 0x00); mn88472_set_frontend()
115 ret = regmap_write(dev->regmap[2], 0x02, 0x01); mn88472_set_frontend()
118 ret = regmap_write(dev->regmap[2], 0x03, delivery_system_val); mn88472_set_frontend()
121 ret = regmap_write(dev->regmap[2], 0x04, bw_val2); mn88472_set_frontend()
126 ret = regmap_write(dev->regmap[2], 0x10 + i, if_val[i]); mn88472_set_frontend()
132 ret = regmap_write(dev->regmap[2], 0x13 + i, bw_val[i]); mn88472_set_frontend()
139 ret = regmap_write(dev->regmap[0], 0x07, 0x26); mn88472_set_frontend()
140 ret = regmap_write(dev->regmap[0], 0xb0, 0x0a); mn88472_set_frontend()
141 ret = regmap_write(dev->regmap[0], 0xb4, 0x00); mn88472_set_frontend()
142 ret = regmap_write(dev->regmap[0], 0xcd, 0x1f); mn88472_set_frontend()
143 ret = regmap_write(dev->regmap[0], 0xd4, 0x0a); mn88472_set_frontend()
144 ret = regmap_write(dev->regmap[0], 0xd6, 0x48); mn88472_set_frontend()
145 ret = regmap_write(dev->regmap[0], 0x00, 0xba); mn88472_set_frontend()
146 ret = regmap_write(dev->regmap[0], 0x01, 0x13); mn88472_set_frontend()
151 ret = regmap_write(dev->regmap[2], 0x2b, 0x13); mn88472_set_frontend()
152 ret = regmap_write(dev->regmap[2], 0x4f, 0x05); mn88472_set_frontend()
153 ret = regmap_write(dev->regmap[1], 0xf6, 0x05); mn88472_set_frontend()
154 ret = regmap_write(dev->regmap[0], 0xb0, 0x0a); mn88472_set_frontend()
155 ret = regmap_write(dev->regmap[0], 0xb4, 0xf6); mn88472_set_frontend()
156 ret = regmap_write(dev->regmap[0], 0xcd, 0x01); mn88472_set_frontend()
157 ret = regmap_write(dev->regmap[0], 0xd4, 0x09); mn88472_set_frontend()
158 ret = regmap_write(dev->regmap[0], 0xd6, 0x46); mn88472_set_frontend()
159 ret = regmap_write(dev->regmap[2], 0x30, 0x80); mn88472_set_frontend()
160 ret = regmap_write(dev->regmap[2], 0x32, 0x00); mn88472_set_frontend()
165 ret = regmap_write(dev->regmap[0], 0xb0, 0x0b); mn88472_set_frontend()
166 ret = regmap_write(dev->regmap[0], 0xb4, 0x00); mn88472_set_frontend()
167 ret = regmap_write(dev->regmap[0], 0xcd, 0x17); mn88472_set_frontend()
168 ret = regmap_write(dev->regmap[0], 0xd4, 0x09); mn88472_set_frontend()
169 ret = regmap_write(dev->regmap[0], 0xd6, 0x48); mn88472_set_frontend()
170 ret = regmap_write(dev->regmap[1], 0x00, 0xb0); mn88472_set_frontend()
179 ret = regmap_write(dev->regmap[0], 0x46, 0x00); mn88472_set_frontend()
180 ret = regmap_write(dev->regmap[0], 0xae, 0x00); mn88472_set_frontend()
184 ret = regmap_write(dev->regmap[2], 0x08, 0x1d); mn88472_set_frontend()
187 ret = regmap_write(dev->regmap[2], 0x08, 0x00); mn88472_set_frontend()
197 ret = regmap_write(dev->regmap[0], 0xd9, 0xe3); mn88472_set_frontend()
200 ret = regmap_write(dev->regmap[0], 0xd9, 0xe1); mn88472_set_frontend()
209 ret = regmap_write(dev->regmap[2], 0xf8, 0x9f); mn88472_set_frontend()
239 ret = regmap_read(dev->regmap[0], 0x7F, &utmp); mn88472_read_status()
246 ret = regmap_read(dev->regmap[2], 0x92, &utmp); mn88472_read_status()
257 ret = regmap_read(dev->regmap[1], 0x84, &utmp); mn88472_read_status()
293 ret = regmap_write(dev->regmap[2], 0x05, 0x00); mn88472_init()
297 ret = regmap_bulk_write(dev->regmap[2], 0x0b, "\x00\x00", 2); mn88472_init()
302 ret = regmap_read(dev->regmap[0], 0xf5, &tmp); mn88472_init()
323 ret = regmap_write(dev->regmap[0], 0xf5, 0x03); mn88472_init()
333 ret = regmap_bulk_write(dev->regmap[0], 0xf6, mn88472_init()
343 ret = regmap_read(dev->regmap[0], 0xf8, &tmp); mn88472_init()
356 ret = regmap_write(dev->regmap[0], 0xf5, 0x00); mn88472_init()
383 ret = regmap_write(dev->regmap[2], 0x0b, 0x30); mn88472_sleep()
388 ret = regmap_write(dev->regmap[2], 0x05, 0x3e); mn88472_sleep()
469 dev->regmap[0] = regmap_init_i2c(dev->client[0], &regmap_config); mn88472_probe()
470 if (IS_ERR(dev->regmap[0])) { mn88472_probe()
471 ret = PTR_ERR(dev->regmap[0]); mn88472_probe()
476 ret = regmap_read(dev->regmap[0], 0x00, &utmp); mn88472_probe()
492 dev->regmap[1] = regmap_init_i2c(dev->client[1], &regmap_config); mn88472_probe()
493 if (IS_ERR(dev->regmap[1])) { mn88472_probe()
494 ret = PTR_ERR(dev->regmap[1]); mn88472_probe()
506 dev->regmap[2] = regmap_init_i2c(dev->client[2], &regmap_config); mn88472_probe()
507 if (IS_ERR(dev->regmap[2])) { mn88472_probe()
508 ret = PTR_ERR(dev->regmap[2]); mn88472_probe()
525 regmap_exit(dev->regmap[1]); mn88472_probe()
529 regmap_exit(dev->regmap[0]); mn88472_probe()
543 regmap_exit(dev->regmap[2]); mn88472_remove()
546 regmap_exit(dev->regmap[1]); mn88472_remove()
549 regmap_exit(dev->regmap[0]); mn88472_remove()
H A Dmn88472_priv.h23 #include <linux/regmap.h>
29 struct regmap *regmap[3]; member in struct:mn88472_dev
/linux-4.1.27/sound/soc/sirf/
H A Dsirf-usp.c20 struct regmap *regmap; member in struct:sirf_usp
31 regmap_update_bits(usp->regmap, USP_TX_FIFO_OP, sirf_usp_tx_enable()
33 regmap_write(usp->regmap, USP_TX_FIFO_OP, 0); sirf_usp_tx_enable()
35 regmap_update_bits(usp->regmap, USP_TX_FIFO_OP, sirf_usp_tx_enable()
38 regmap_update_bits(usp->regmap, USP_TX_RX_ENABLE, sirf_usp_tx_enable()
44 regmap_update_bits(usp->regmap, USP_TX_RX_ENABLE, sirf_usp_tx_disable()
47 regmap_write(usp->regmap, USP_TX_FIFO_OP, 0); sirf_usp_tx_disable()
52 regmap_update_bits(usp->regmap, USP_RX_FIFO_OP, sirf_usp_rx_enable()
54 regmap_write(usp->regmap, USP_RX_FIFO_OP, 0); sirf_usp_rx_enable()
56 regmap_update_bits(usp->regmap, USP_RX_FIFO_OP, sirf_usp_rx_enable()
59 regmap_update_bits(usp->regmap, USP_TX_RX_ENABLE, sirf_usp_rx_enable()
65 regmap_update_bits(usp->regmap, USP_TX_RX_ENABLE, sirf_usp_rx_disable()
68 regmap_write(usp->regmap, USP_RX_FIFO_OP, 0); sirf_usp_rx_disable()
119 regmap_update_bits(usp->regmap, USP_RISC_DSP_MODE, sirf_usp_i2s_init()
126 regmap_write(usp->regmap, USP_TX_DMA_IO_LEN, 0); sirf_usp_i2s_init()
127 regmap_write(usp->regmap, USP_RX_DMA_IO_LEN, 0); sirf_usp_i2s_init()
130 regmap_write(usp->regmap, USP_MODE2, (1 << USP_RXD_DELAY_LEN_OFFSET) | sirf_usp_i2s_init()
135 regmap_write(usp->regmap, USP_MODE1, sirf_usp_i2s_init()
141 regmap_write(usp->regmap, USP_RX_DMA_IO_CTRL, 0); sirf_usp_i2s_init()
144 regmap_write(usp->regmap, USP_RX_FIFO_CTRL, sirf_usp_i2s_init()
149 regmap_write(usp->regmap, USP_RX_FIFO_LEVEL_CHK, sirf_usp_i2s_init()
153 regmap_write(usp->regmap, USP_TX_DMA_IO_CTRL, 0); sirf_usp_i2s_init()
156 regmap_write(usp->regmap, USP_TX_FIFO_CTRL, sirf_usp_i2s_init()
160 regmap_write(usp->regmap, USP_TX_FIFO_LEVEL_CHK, sirf_usp_i2s_init()
192 regmap_update_bits(usp->regmap, USP_RX_FRAME_CTRL, sirf_usp_pcm_hw_params()
196 regmap_update_bits(usp->regmap, USP_RX_FRAME_CTRL, sirf_usp_pcm_hw_params()
210 regmap_update_bits(usp->regmap, USP_MODE1, sirf_usp_pcm_hw_params()
219 regmap_update_bits(usp->regmap, USP_TX_FRAME_CTRL, sirf_usp_pcm_hw_params()
227 regmap_update_bits(usp->regmap, USP_RX_FRAME_CTRL, sirf_usp_pcm_hw_params()
320 regmap_read(usp->regmap, USP_MODE1, &usp->mode1_reg); sirf_usp_pcm_suspend()
321 regmap_read(usp->regmap, USP_MODE2, &usp->mode2_reg); sirf_usp_pcm_suspend()
336 regmap_write(usp->regmap, USP_MODE1, usp->mode1_reg); sirf_usp_pcm_resume()
337 regmap_write(usp->regmap, USP_MODE2, usp->mode2_reg); sirf_usp_pcm_resume()
374 usp->regmap = devm_regmap_init_mmio(&pdev->dev, base, sirf_usp_pcm_probe()
376 if (IS_ERR(usp->regmap)) sirf_usp_pcm_probe()
377 return PTR_ERR(usp->regmap); sirf_usp_pcm_probe()
/linux-4.1.27/drivers/clk/qcom/
H A Dclk-pll.c21 #include <linux/regmap.h>
44 ret = regmap_read(pll->clkr.regmap, pll->mode_reg, &val); clk_pll_enable()
53 ret = regmap_update_bits(pll->clkr.regmap, pll->mode_reg, PLL_BYPASSNL, clk_pll_enable()
65 ret = regmap_update_bits(pll->clkr.regmap, pll->mode_reg, PLL_RESET_N, clk_pll_enable()
74 return regmap_update_bits(pll->clkr.regmap, pll->mode_reg, PLL_OUTCTRL, clk_pll_enable()
84 regmap_read(pll->clkr.regmap, pll->mode_reg, &val); clk_pll_disable()
89 regmap_update_bits(pll->clkr.regmap, pll->mode_reg, mask, 0); clk_pll_disable()
100 regmap_read(pll->clkr.regmap, pll->l_reg, &l); clk_pll_recalc_rate()
101 regmap_read(pll->clkr.regmap, pll->m_reg, &m); clk_pll_recalc_rate()
102 regmap_read(pll->clkr.regmap, pll->n_reg, &n); clk_pll_recalc_rate()
116 regmap_read(pll->clkr.regmap, pll->config_reg, &config); clk_pll_recalc_rate()
166 regmap_read(pll->clkr.regmap, pll->mode_reg, &mode); clk_pll_set_rate()
172 regmap_update_bits(pll->clkr.regmap, pll->l_reg, 0x3ff, f->l); clk_pll_set_rate()
173 regmap_update_bits(pll->clkr.regmap, pll->m_reg, 0x7ffff, f->m); clk_pll_set_rate()
174 regmap_update_bits(pll->clkr.regmap, pll->n_reg, 0x7ffff, f->n); clk_pll_set_rate()
175 regmap_write(pll->clkr.regmap, pll->config_reg, f->ibits); clk_pll_set_rate()
201 ret = regmap_read(pll->clkr.regmap, pll->status_reg, &val); wait_for_pll()
232 clk_pll_set_fsm_mode(struct clk_pll *pll, struct regmap *regmap, u8 lock_count) clk_pll_set_fsm_mode() argument
238 regmap_update_bits(regmap, pll->mode_reg, PLL_VOTE_FSM_RESET, 0); clk_pll_set_fsm_mode()
244 regmap_update_bits(regmap, pll->mode_reg, mask, val); clk_pll_set_fsm_mode()
247 regmap_update_bits(regmap, pll->mode_reg, PLL_VOTE_FSM_ENA, clk_pll_set_fsm_mode()
251 static void clk_pll_configure(struct clk_pll *pll, struct regmap *regmap, clk_pll_configure() argument
257 regmap_write(regmap, pll->l_reg, config->l); clk_pll_configure()
258 regmap_write(regmap, pll->m_reg, config->m); clk_pll_configure()
259 regmap_write(regmap, pll->n_reg, config->n); clk_pll_configure()
275 regmap_update_bits(regmap, pll->config_reg, mask, val); clk_pll_configure()
278 void clk_pll_configure_sr(struct clk_pll *pll, struct regmap *regmap, clk_pll_configure_sr() argument
281 clk_pll_configure(pll, regmap, config); clk_pll_configure_sr()
283 clk_pll_set_fsm_mode(pll, regmap, 8); clk_pll_configure_sr()
287 void clk_pll_configure_sr_hpm_lp(struct clk_pll *pll, struct regmap *regmap, clk_pll_configure_sr_hpm_lp() argument
290 clk_pll_configure(pll, regmap, config); clk_pll_configure_sr_hpm_lp()
292 clk_pll_set_fsm_mode(pll, regmap, 0); clk_pll_configure_sr_hpm_lp()
H A Dclk-regmap.h19 struct regmap;
22 * struct clk_regmap - regmap supporting clock
24 * @regmap: regmap to use for regmap helpers and/or by providers
25 * @enable_reg: register when using regmap enable/disable ops
26 * @enable_mask: mask when using regmap enable/disable ops
32 struct regmap *regmap; member in struct:clk_regmap
H A Dclk-regmap.c16 #include <linux/regmap.h>
19 #include "clk-regmap.h"
22 * clk_is_enabled_regmap - standard is_enabled() for regmap users
26 * Clocks that use regmap for their register I/O can set the
36 ret = regmap_read(rclk->regmap, rclk->enable_reg, &val); clk_is_enabled_regmap()
48 * clk_enable_regmap - standard enable() for regmap users
52 * Clocks that use regmap for their register I/O can set the
66 return regmap_update_bits(rclk->regmap, rclk->enable_reg, clk_enable_regmap()
72 * clk_disable_regmap - standard disable() for regmap users
76 * Clocks that use regmap for their register I/O can set the
90 regmap_update_bits(rclk->regmap, rclk->enable_reg, rclk->enable_mask, clk_disable_regmap()
100 * Clocks that use regmap for their register I/O should register their
101 * clk_regmap struct via this function so that the regmap is initialized
108 rclk->regmap = dev_get_regmap(dev, NULL); devm_clk_register_regmap()
110 rclk->regmap = dev_get_regmap(dev->parent, NULL); devm_clk_register_regmap()
H A Dcommon.c15 #include <linux/regmap.h>
22 #include "clk-regmap.h"
58 struct regmap * qcom_cc_map()
75 const struct qcom_cc_desc *desc, struct regmap *regmap) qcom_cc_really_probe()
117 reset->regmap = regmap; qcom_cc_really_probe()
131 struct regmap *regmap; qcom_cc_probe() local
133 regmap = qcom_cc_map(pdev, desc); qcom_cc_probe()
134 if (IS_ERR(regmap)) qcom_cc_probe()
135 return PTR_ERR(regmap); qcom_cc_probe()
137 return qcom_cc_really_probe(pdev, desc, regmap); qcom_cc_probe()
74 qcom_cc_really_probe(struct platform_device *pdev, const struct qcom_cc_desc *desc, struct regmap *regmap) qcom_cc_really_probe() argument
H A Dclk-pll.h18 #include "clk-regmap.h"
83 void clk_pll_configure_sr(struct clk_pll *pll, struct regmap *regmap,
85 void clk_pll_configure_sr_hpm_lp(struct clk_pll *pll, struct regmap *regmap,
H A Dreset.h24 struct regmap;
28 struct regmap *regmap; member in struct:qcom_reset_controller
H A Dclk-rcg.c19 #include <linux/regmap.h>
52 ret = regmap_read(rcg->clkr.regmap, rcg->ns_reg, &ns); clk_rcg_get_parent()
81 ret = regmap_read(rcg->clkr.regmap, rcg->bank_reg, &reg); clk_dyn_rcg_get_parent()
87 ret = regmap_read(rcg->clkr.regmap, rcg->ns_reg[bank], &ns); clk_dyn_rcg_get_parent()
107 regmap_read(rcg->clkr.regmap, rcg->ns_reg, &ns); clk_rcg_set_parent()
109 regmap_write(rcg->clkr.regmap, rcg->ns_reg, ns); clk_rcg_set_parent()
221 ret = regmap_read(rcg->clkr.regmap, rcg->bank_reg, &reg); configure_bank()
228 ret = regmap_read(rcg->clkr.regmap, ns_reg, &ns); configure_bank()
237 ret = regmap_write(rcg->clkr.regmap, ns_reg, ns); configure_bank()
241 ret = regmap_read(rcg->clkr.regmap, md_reg, &md); configure_bank()
245 ret = regmap_write(rcg->clkr.regmap, md_reg, md); configure_bank()
249 ret = regmap_write(rcg->clkr.regmap, ns_reg, ns); configure_bank()
256 ret = regmap_write(rcg->clkr.regmap, ns_reg, ns); configure_bank()
261 ret = regmap_write(rcg->clkr.regmap, rcg->bank_reg, configure_bank()
268 ret = regmap_write(rcg->clkr.regmap, ns_reg, ns); configure_bank()
283 ret = regmap_write(rcg->clkr.regmap, ns_reg, ns); configure_bank()
288 ret = regmap_read(rcg->clkr.regmap, rcg->bank_reg, &reg); configure_bank()
292 ret = regmap_write(rcg->clkr.regmap, rcg->bank_reg, reg); configure_bank()
308 regmap_read(rcg->clkr.regmap, rcg->bank_reg, &reg); clk_dyn_rcg_set_parent()
311 regmap_read(rcg->clkr.regmap, rcg->ns_reg[bank], &ns); clk_dyn_rcg_set_parent()
314 regmap_read(rcg->clkr.regmap, rcg->md_reg[bank], &md); clk_dyn_rcg_set_parent()
356 regmap_read(rcg->clkr.regmap, rcg->ns_reg, &ns); clk_rcg_recalc_rate()
360 regmap_read(rcg->clkr.regmap, rcg->md_reg, &md); clk_rcg_recalc_rate()
365 regmap_read(rcg->clkr.regmap, rcg->clkr.enable_reg, &mode); clk_rcg_recalc_rate()
384 regmap_read(rcg->clkr.regmap, rcg->bank_reg, &reg); clk_dyn_rcg_recalc_rate()
387 regmap_read(rcg->clkr.regmap, rcg->ns_reg[bank], &ns); clk_dyn_rcg_recalc_rate()
392 regmap_read(rcg->clkr.regmap, rcg->md_reg[bank], &md); clk_dyn_rcg_recalc_rate()
463 regmap_read(rcg->clkr.regmap, rcg->bank_reg, &reg); clk_dyn_rcg_determine_rate()
501 regmap_update_bits(rcg->clkr.regmap, reset_reg, mask, mask); __clk_rcg_set_rate()
503 regmap_read(rcg->clkr.regmap, rcg->md_reg, &md); __clk_rcg_set_rate()
505 regmap_write(rcg->clkr.regmap, rcg->md_reg, md); __clk_rcg_set_rate()
507 regmap_read(rcg->clkr.regmap, rcg->ns_reg, &ns); __clk_rcg_set_rate()
510 regmap_read(rcg->clkr.regmap, rcg->clkr.enable_reg, &ctl); __clk_rcg_set_rate()
512 regmap_write(rcg->clkr.regmap, rcg->clkr.enable_reg, ctl); __clk_rcg_set_rate()
518 regmap_read(rcg->clkr.regmap, rcg->ns_reg, &ns); __clk_rcg_set_rate()
522 regmap_write(rcg->clkr.regmap, rcg->ns_reg, ns); __clk_rcg_set_rate()
524 regmap_update_bits(rcg->clkr.regmap, reset_reg, mask, 0); __clk_rcg_set_rate()
574 regmap_update_bits(rcg->clkr.regmap, rcg->ns_reg, gfm, 0); clk_rcg_lcc_set_rate()
578 regmap_update_bits(rcg->clkr.regmap, rcg->ns_reg, gfm, gfm); clk_rcg_lcc_set_rate()
589 return regmap_update_bits(rcg->clkr.regmap, rcg->ns_reg, gfm, gfm); clk_rcg_lcc_enable()
598 regmap_update_bits(rcg->clkr.regmap, rcg->ns_reg, gfm, 0); clk_rcg_lcc_disable()
H A Dclk-regmap-divider.c16 #include <linux/regmap.h>
19 #include "clk-regmap-divider.h"
45 return regmap_update_bits(clkr->regmap, divider->reg, div_set_rate()
57 regmap_read(clkr->regmap, divider->reg, &div); div_recalc_rate()
H A Dclk-regmap-mux.c16 #include <linux/regmap.h>
19 #include "clk-regmap-mux.h"
33 regmap_read(clkr->regmap, mux->reg, &val); mux_get_parent()
51 return regmap_update_bits(clkr->regmap, mux->reg, mask, val); mux_set_parent()
H A Dcommon.h20 struct regmap;
38 extern struct regmap *qcom_cc_map(struct platform_device *pdev,
42 struct regmap *regmap);
H A Dlcc-ipq806x.c22 #include <linux/regmap.h>
27 #include "clk-regmap.h"
31 #include "clk-regmap-divider.h"
32 #include "clk-regmap-mux.h"
439 struct regmap *regmap; lcc_ipq806x_probe() local
441 regmap = qcom_cc_map(pdev, &lcc_ipq806x_desc); lcc_ipq806x_probe()
442 if (IS_ERR(regmap)) lcc_ipq806x_probe()
443 return PTR_ERR(regmap); lcc_ipq806x_probe()
446 val = regmap_read(regmap, 0x0, &val); lcc_ipq806x_probe()
448 clk_pll_configure_sr(&pll4, regmap, &pll4_config, true); lcc_ipq806x_probe()
450 regmap_write(regmap, 0xc4, 0x1); lcc_ipq806x_probe()
452 return qcom_cc_really_probe(pdev, &lcc_ipq806x_desc, regmap); lcc_ipq806x_probe()
H A Dreset.c16 #include <linux/regmap.h>
41 return regmap_update_bits(rst->regmap, map->reg, mask, mask); qcom_reset_assert()
55 return regmap_update_bits(rst->regmap, map->reg, mask, 0); qcom_reset_deassert()
/linux-4.1.27/drivers/hwmon/
H A Dtmp103.c32 #include <linux/regmap.h>
69 struct regmap *regmap = dev_get_drvdata(dev); tmp103_show_temp() local
73 ret = regmap_read(regmap, sda->index, &regval); tmp103_show_temp()
85 struct regmap *regmap = dev_get_drvdata(dev); tmp103_set_temp() local
93 ret = regmap_write(regmap, sda->index, tmp103_mc_to_reg(val)); tmp103_set_temp()
131 struct regmap *regmap; tmp103_probe() local
134 regmap = devm_regmap_init_i2c(client, &tmp103_regmap_config); tmp103_probe()
135 if (IS_ERR(regmap)) { tmp103_probe()
137 return PTR_ERR(regmap); tmp103_probe()
140 ret = regmap_update_bits(regmap, TMP103_CONF_REG, TMP103_CONFIG_MASK, tmp103_probe()
147 i2c_set_clientdata(client, regmap); tmp103_probe()
149 regmap, tmp103_groups); tmp103_probe()
156 struct regmap *regmap = dev_get_drvdata(dev); tmp103_suspend() local
158 return regmap_update_bits(regmap, TMP103_CONF_REG, tmp103_suspend()
164 struct regmap *regmap = dev_get_drvdata(dev); tmp103_resume() local
166 return regmap_update_bits(regmap, TMP103_CONF_REG, tmp103_resume()
H A Dltc4260.c25 #include <linux/regmap.h>
48 struct regmap *regmap = dev_get_drvdata(dev); ltc4260_get_value() local
52 ret = regmap_read(regmap, reg, &val); ltc4260_get_value()
98 struct regmap *regmap = dev_get_drvdata(dev); ltc4260_show_bool() local
102 ret = regmap_read(regmap, LTC4260_FAULT, &fault); ltc4260_show_bool()
108 regmap_update_bits(regmap, LTC4260_FAULT, attr->index, 0); ltc4260_show_bool()
164 struct regmap *regmap; ltc4260_probe() local
166 regmap = devm_regmap_init_i2c(client, &ltc4260_regmap_config); ltc4260_probe()
167 if (IS_ERR(regmap)) { ltc4260_probe()
169 return PTR_ERR(regmap); ltc4260_probe()
173 regmap_write(regmap, LTC4260_FAULT, 0x00); ltc4260_probe()
176 regmap, ltc4260_probe()
H A Dltc4222.c26 #include <linux/regmap.h>
58 struct regmap *regmap = dev_get_drvdata(dev); ltc4222_get_value() local
63 ret = regmap_bulk_read(regmap, reg, buf, 2); ltc4222_get_value()
113 struct regmap *regmap = dev_get_drvdata(dev); ltc4222_show_bool() local
117 ret = regmap_read(regmap, attr->nr, &fault); ltc4222_show_bool()
122 regmap_update_bits(regmap, attr->nr, attr->index, 0); ltc4222_show_bool()
200 struct regmap *regmap; ltc4222_probe() local
202 regmap = devm_regmap_init_i2c(client, &ltc4222_regmap_config); ltc4222_probe()
203 if (IS_ERR(regmap)) { ltc4222_probe()
205 return PTR_ERR(regmap); ltc4222_probe()
209 regmap_write(regmap, LTC4222_FAULT1, 0x00); ltc4222_probe()
210 regmap_write(regmap, LTC4222_FAULT2, 0x00); ltc4222_probe()
213 regmap, ltc4222_probe()
H A Dltc2945.c25 #include <linux/regmap.h>
78 struct regmap *regmap = dev_get_drvdata(dev); ltc2945_reg_to_val() local
84 ret = regmap_bulk_read(regmap, reg, buf, ltc2945_reg_to_val()
110 ret = regmap_read(regmap, LTC2945_CONTROL, &control); ltc2945_reg_to_val()
160 struct regmap *regmap = dev_get_drvdata(dev); ltc2945_val_to_reg() local
178 ret = regmap_read(regmap, LTC2945_CONTROL, &control); ltc2945_val_to_reg()
246 struct regmap *regmap = dev_get_drvdata(dev); ltc2945_set_value() local
272 ret = regmap_bulk_write(regmap, reg, regbuf, num_regs); ltc2945_set_value()
281 struct regmap *regmap = dev_get_drvdata(dev); ltc2945_reset_history() local
295 ret = regmap_update_bits(regmap, LTC2945_CONTROL, CONTROL_TEST_MODE, ltc2945_reset_history()
299 ret = regmap_bulk_write(regmap, reg, buf_min, num_regs); ltc2945_reset_history()
321 ret = regmap_bulk_write(regmap, reg, buf_max, num_regs); ltc2945_reset_history()
324 regmap_update_bits(regmap, LTC2945_CONTROL, CONTROL_TEST_MODE, 0); ltc2945_reset_history()
333 struct regmap *regmap = dev_get_drvdata(dev); ltc2945_show_bool() local
337 ret = regmap_read(regmap, LTC2945_FAULT, &fault); ltc2945_show_bool()
343 regmap_update_bits(regmap, LTC2945_FAULT, attr->index, 0); ltc2945_show_bool()
483 struct regmap *regmap; ltc2945_probe() local
485 regmap = devm_regmap_init_i2c(client, &ltc2945_regmap_config); ltc2945_probe()
486 if (IS_ERR(regmap)) { ltc2945_probe()
488 return PTR_ERR(regmap); ltc2945_probe()
492 regmap_write(regmap, LTC2945_FAULT, 0x00); ltc2945_probe()
495 regmap, ltc2945_probe()
H A Dads7828.c35 #include <linux/regmap.h>
51 struct regmap *regmap; member in struct:ads7828_data
72 err = regmap_read(data->regmap, cmd, &regval); ads7828_show_in()
143 data->regmap = devm_regmap_init_i2c(client, ads7828_probe()
147 data->regmap = devm_regmap_init_i2c(client, ads7828_probe()
151 if (IS_ERR(data->regmap)) ads7828_probe()
152 return PTR_ERR(data->regmap); ads7828_probe()
165 regmap_read(data->regmap, data->cmd_byte, &regval); ads7828_probe()
H A Dnct7802.c27 #include <linux/regmap.h>
65 struct regmap *regmap; member in struct:nct7802_data
78 err = regmap_read(data->regmap, reg_temp, &t1); nct7802_read_temp()
83 err = regmap_read(data->regmap, reg_temp_low, &t2); nct7802_read_temp()
100 ret = regmap_read(data->regmap, reg_fan, &f1); nct7802_read_fan()
103 ret = regmap_read(data->regmap, REG_FANCOUNT_LOW, &f2); nct7802_read_fan()
124 ret = regmap_read(data->regmap, reg_fan_low, &f1); nct7802_read_fan_min()
127 ret = regmap_read(data->regmap, reg_fan_high, &f2); nct7802_read_fan_min()
153 err = regmap_write(data->regmap, reg_fan_low, limit & 0xff); nct7802_write_fan_min()
157 err = regmap_write(data->regmap, reg_fan_high, (limit & 0x1f00) >> 5); nct7802_write_fan_min()
172 ret = regmap_read(data->regmap, REG_VOLTAGE[nr], &v1); nct7802_read_voltage()
175 ret = regmap_read(data->regmap, REG_VOLTAGE_LOW, &v2); nct7802_read_voltage()
182 ret = regmap_read(data->regmap, nct7802_read_voltage()
186 ret = regmap_read(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr], nct7802_read_voltage()
207 err = regmap_write(data->regmap, nct7802_write_voltage()
213 err = regmap_update_bits(data->regmap, REG_VOLTAGE_LIMIT_MSB[nr], nct7802_write_voltage()
281 err = regmap_write(data->regmap, nr, val & 0xff); store_temp()
338 ret = regmap_read(data->regmap, sattr->nr, &val); show_alarm()
353 err = regmap_read(data->regmap, sattr->nr, &regval); show_beep()
375 err = regmap_update_bits(data->regmap, sattr->nr, 1 << sattr->index, store_beep()
540 err = regmap_read(data->regmap, REG_MODE, &reg); nct7802_temp_is_visible()
555 err = regmap_read(data->regmap, REG_PECI_ENABLE, &reg); nct7802_temp_is_visible()
652 err = regmap_read(data->regmap, REG_MODE, &reg); nct7802_in_is_visible()
716 err = regmap_read(data->regmap, REG_FAN_ENABLE, &reg); nct7802_fan_is_visible()
794 err = regmap_update_bits(data->regmap, REG_START, 0x01, 0x01); nct7802_init_chip()
799 err = regmap_update_bits(data->regmap, REG_MODE, 0x40, 0x40); nct7802_init_chip()
804 return regmap_update_bits(data->regmap, REG_VMON_ENABLE, 0x03, 0x03); nct7802_init_chip()
819 data->regmap = devm_regmap_init_i2c(client, &nct7802_regmap_config); nct7802_probe()
820 if (IS_ERR(data->regmap)) nct7802_probe()
821 return PTR_ERR(data->regmap); nct7802_probe()
/linux-4.1.27/drivers/media/tuners/
H A Dm88rs6000t.c18 #include <linux/regmap.h>
23 struct regmap *regmap; member in struct:m88rs6000t_dev
45 ret = regmap_read(dev->regmap, 0x15, &utmp); m88rs6000t_set_demod_mclk()
107 ret = regmap_read(dev->regmap, 0x1D, &utmp); m88rs6000t_set_demod_mclk()
117 ret = regmap_write(dev->regmap, 0x05, 0x40); m88rs6000t_set_demod_mclk()
120 ret = regmap_write(dev->regmap, 0x11, 0x08); m88rs6000t_set_demod_mclk()
123 ret = regmap_write(dev->regmap, 0x15, reg15); m88rs6000t_set_demod_mclk()
126 ret = regmap_write(dev->regmap, 0x16, reg16); m88rs6000t_set_demod_mclk()
129 ret = regmap_write(dev->regmap, 0x1D, reg1D); m88rs6000t_set_demod_mclk()
132 ret = regmap_write(dev->regmap, 0x1E, reg1E); m88rs6000t_set_demod_mclk()
135 ret = regmap_write(dev->regmap, 0x1F, reg1F); m88rs6000t_set_demod_mclk()
138 ret = regmap_write(dev->regmap, 0x17, 0xc1); m88rs6000t_set_demod_mclk()
141 ret = regmap_write(dev->regmap, 0x17, 0x81); m88rs6000t_set_demod_mclk()
145 ret = regmap_write(dev->regmap, 0x05, 0x00); m88rs6000t_set_demod_mclk()
148 ret = regmap_write(dev->regmap, 0x11, reg11); m88rs6000t_set_demod_mclk()
170 ret = regmap_write(dev->regmap, 0x36, (refDiv - 8)); m88rs6000t_set_pll_freq()
173 ret = regmap_write(dev->regmap, 0x31, 0x00); m88rs6000t_set_pll_freq()
176 ret = regmap_write(dev->regmap, 0x2c, 0x02); m88rs6000t_set_pll_freq()
228 ret = regmap_write(dev->regmap, 0x27, reg27); m88rs6000t_set_pll_freq()
231 ret = regmap_write(dev->regmap, 0x28, (u8)(ulNDiv1 & 0xFF)); m88rs6000t_set_pll_freq()
235 ret = regmap_write(dev->regmap, 0x29, reg29); m88rs6000t_set_pll_freq()
238 ret = regmap_write(dev->regmap, 0x2a, (u8)(ulNDiv2 & 0xFF)); m88rs6000t_set_pll_freq()
241 ret = regmap_write(dev->regmap, 0x2F, 0xf5); m88rs6000t_set_pll_freq()
244 ret = regmap_write(dev->regmap, 0x30, 0x05); m88rs6000t_set_pll_freq()
247 ret = regmap_write(dev->regmap, 0x08, 0x1f); m88rs6000t_set_pll_freq()
250 ret = regmap_write(dev->regmap, 0x08, 0x3f); m88rs6000t_set_pll_freq()
253 ret = regmap_write(dev->regmap, 0x09, 0x20); m88rs6000t_set_pll_freq()
256 ret = regmap_write(dev->regmap, 0x09, 0x00); m88rs6000t_set_pll_freq()
259 ret = regmap_write(dev->regmap, 0x3e, 0x11); m88rs6000t_set_pll_freq()
262 ret = regmap_write(dev->regmap, 0x08, 0x2f); m88rs6000t_set_pll_freq()
265 ret = regmap_write(dev->regmap, 0x08, 0x3f); m88rs6000t_set_pll_freq()
268 ret = regmap_write(dev->regmap, 0x09, 0x10); m88rs6000t_set_pll_freq()
271 ret = regmap_write(dev->regmap, 0x09, 0x00); m88rs6000t_set_pll_freq()
276 ret = regmap_read(dev->regmap, 0x42, &utmp); m88rs6000t_set_pll_freq()
281 ret = regmap_write(dev->regmap, 0x3e, 0x10); m88rs6000t_set_pll_freq()
284 ret = regmap_write(dev->regmap, 0x08, 0x2f); m88rs6000t_set_pll_freq()
287 ret = regmap_write(dev->regmap, 0x08, 0x3f); m88rs6000t_set_pll_freq()
290 ret = regmap_write(dev->regmap, 0x09, 0x10); m88rs6000t_set_pll_freq()
293 ret = regmap_write(dev->regmap, 0x09, 0x00); m88rs6000t_set_pll_freq()
298 ret = regmap_read(dev->regmap, 0x42, &utmp); m88rs6000t_set_pll_freq()
303 ret = regmap_write(dev->regmap, 0x3e, 0x11); m88rs6000t_set_pll_freq()
309 ret = regmap_read(dev->regmap, 0x2d, &utmp); m88rs6000t_set_pll_freq()
312 ret = regmap_write(dev->regmap, 0x2d, utmp); m88rs6000t_set_pll_freq()
315 ret = regmap_read(dev->regmap, 0x2e, &utmp); m88rs6000t_set_pll_freq()
318 ret = regmap_write(dev->regmap, 0x2e, utmp); m88rs6000t_set_pll_freq()
322 ret = regmap_read(dev->regmap, 0x27, &utmp); m88rs6000t_set_pll_freq()
326 ret = regmap_read(dev->regmap, 0x83, &utmp); m88rs6000t_set_pll_freq()
341 ret = regmap_write(dev->regmap, 0x36, (refDiv - 8)); m88rs6000t_set_pll_freq()
350 ret = regmap_write(dev->regmap, 0x27, reg27); m88rs6000t_set_pll_freq()
353 ret = regmap_write(dev->regmap, 0x28, (u8)(ulNDiv & 0xFF)); m88rs6000t_set_pll_freq()
356 ret = regmap_write(dev->regmap, 0x29, 0x80); m88rs6000t_set_pll_freq()
359 ret = regmap_write(dev->regmap, 0x31, 0x03); m88rs6000t_set_pll_freq()
367 ret = regmap_write(dev->regmap, 0x3b, utmp); m88rs6000t_set_pll_freq()
391 return regmap_write(dev->regmap, 0x40, reg40); m88rs6000t_set_bb()
420 ret = regmap_write(dev->regmap, 0x00, 0x01); m88rs6000t_set_params()
423 ret = regmap_write(dev->regmap, 0x00, 0x00); m88rs6000t_set_params()
441 ret = regmap_update_bits(dev->regmap, 0x11, 0x08, 0x08); m88rs6000t_init()
445 ret = regmap_update_bits(dev->regmap, 0x10, 0x01, 0x01); m88rs6000t_init()
449 ret = regmap_write(dev->regmap, 0x07, 0x7d); m88rs6000t_init()
463 ret = regmap_write(dev->regmap, 0x07, 0x6d); m88rs6000t_sleep()
511 ret = regmap_read(dev->regmap, 0x5A, &val); m88rs6000t_get_rf_strength()
516 ret = regmap_read(dev->regmap, 0x5F, &val); m88rs6000t_get_rf_strength()
521 ret = regmap_read(dev->regmap, 0x3F, &val); m88rs6000t_get_rf_strength()
526 ret = regmap_read(dev->regmap, 0x77, &val); m88rs6000t_get_rf_strength()
531 ret = regmap_read(dev->regmap, 0x76, &val); m88rs6000t_get_rf_strength()
635 dev->regmap = devm_regmap_init_i2c(client, &regmap_config); m88rs6000t_probe()
636 if (IS_ERR(dev->regmap)) { m88rs6000t_probe()
637 ret = PTR_ERR(dev->regmap); m88rs6000t_probe()
641 ret = regmap_update_bits(dev->regmap, 0x11, 0x08, 0x08); m88rs6000t_probe()
645 ret = regmap_update_bits(dev->regmap, 0x10, 0x01, 0x01); m88rs6000t_probe()
649 ret = regmap_write(dev->regmap, 0x07, 0x7d); m88rs6000t_probe()
652 ret = regmap_write(dev->regmap, 0x04, 0x01); m88rs6000t_probe()
657 ret = regmap_read(dev->regmap, 0x01, &utmp); m88rs6000t_probe()
667 ret = regmap_write(dev->regmap, 0x05, 0x40); m88rs6000t_probe()
670 ret = regmap_write(dev->regmap, 0x11, 0x08); m88rs6000t_probe()
673 ret = regmap_write(dev->regmap, 0x15, 0x6c); m88rs6000t_probe()
676 ret = regmap_write(dev->regmap, 0x17, 0xc1); m88rs6000t_probe()
679 ret = regmap_write(dev->regmap, 0x17, 0x81); m88rs6000t_probe()
683 ret = regmap_write(dev->regmap, 0x05, 0x00); m88rs6000t_probe()
686 ret = regmap_write(dev->regmap, 0x11, 0x0a); m88rs6000t_probe()
691 ret = regmap_write(dev->regmap, m88rs6000t_probe()
H A Dit913x.c24 #include <linux/regmap.h>
28 struct regmap *regmap; member in struct:it913x_dev
50 ret = regmap_write(dev->regmap, 0x80ec4c, 0x68); it913x_init()
56 ret = regmap_read(dev->regmap, 0x80ec86, &utmp); it913x_init()
80 ret = regmap_read(dev->regmap, 0x80ed03, &utmp); it913x_init()
92 ret = regmap_bulk_read(dev->regmap, 0x80ed23, buf, 2); it913x_init()
120 ret = regmap_read(dev->regmap, 0x80ec82, &utmp); it913x_init()
135 ret = regmap_write(dev->regmap, 0x80ed81, iqik_m_cal); it913x_init()
139 ret = regmap_write(dev->regmap, 0x80ec57, 0x00); it913x_init()
143 ret = regmap_write(dev->regmap, 0x80ec58, 0x00); it913x_init()
147 ret = regmap_write(dev->regmap, 0x80ec40, 0x01); it913x_init()
168 ret = regmap_bulk_write(dev->regmap, 0x80ec40, "\x00", 1); it913x_sleep()
183 ret = regmap_bulk_write(dev->regmap, 0x80ec02, it913x_sleep()
189 ret = regmap_bulk_write(dev->regmap, 0x80ec12, "\x00\x00\x00\x00", 4); it913x_sleep()
193 ret = regmap_bulk_write(dev->regmap, 0x80ec17, it913x_sleep()
198 ret = regmap_bulk_write(dev->regmap, 0x80ec22, it913x_sleep()
203 ret = regmap_bulk_write(dev->regmap, 0x80ec20, "\x00", 1); it913x_sleep()
207 ret = regmap_bulk_write(dev->regmap, 0x80ec3f, "\x01", 1); it913x_sleep()
264 ret = regmap_read(dev->regmap, 0x80ed81, &utmp); it913x_set_params()
332 ret = regmap_write(dev->regmap, 0x80ee06, lna_band); it913x_set_params()
345 ret = regmap_write(dev->regmap, 0x80ec56, u8tmp); it913x_set_params()
350 ret = regmap_write(dev->regmap, 0x80ec4c, 0xa0 | (l_band << 3)); it913x_set_params()
354 ret = regmap_write(dev->regmap, 0x80ec4d, (t_cal_freq >> 0) & 0xff); it913x_set_params()
358 ret = regmap_write(dev->regmap, 0x80ec4e, (t_cal_freq >> 8) & 0xff); it913x_set_params()
362 ret = regmap_write(dev->regmap, 0x80011e, (pre_lo_freq >> 0) & 0xff); it913x_set_params()
366 ret = regmap_write(dev->regmap, 0x80011f, (pre_lo_freq >> 8) & 0xff); it913x_set_params()
412 dev->regmap = regmap_init_i2c(client, &regmap_config); it913x_probe()
413 if (IS_ERR(dev->regmap)) { it913x_probe()
414 ret = PTR_ERR(dev->regmap); it913x_probe()
452 regmap_exit(dev->regmap); it913x_remove()
H A De4000.c32 ret = regmap_write(s->regmap, 0x02, 0x40); e4000_init()
35 ret = regmap_write(s->regmap, 0x00, 0x01); e4000_init()
40 ret = regmap_write(s->regmap, 0x06, 0x00); e4000_init()
44 ret = regmap_write(s->regmap, 0x7a, 0x96); e4000_init()
49 ret = regmap_bulk_write(s->regmap, 0x7e, "\x01\xfe", 2); e4000_init()
53 ret = regmap_write(s->regmap, 0x82, 0x00); e4000_init()
57 ret = regmap_write(s->regmap, 0x24, 0x05); e4000_init()
61 ret = regmap_bulk_write(s->regmap, 0x87, "\x20\x01", 2); e4000_init()
65 ret = regmap_bulk_write(s->regmap, 0x9f, "\x7f\x07", 2); e4000_init()
70 ret = regmap_write(s->regmap, 0x2d, 0x1f); e4000_init()
74 ret = regmap_bulk_write(s->regmap, 0x70, "\x01\x01", 2); e4000_init()
79 ret = regmap_write(s->regmap, 0x1a, 0x17); e4000_init()
83 ret = regmap_write(s->regmap, 0x1f, 0x1a); e4000_init()
104 ret = regmap_write(s->regmap, 0x00, 0x00); e4000_sleep()
128 ret = regmap_write(s->regmap, 0x1a, 0x00); e4000_set_params()
155 ret = regmap_bulk_write(s->regmap, 0x09, buf, 5); e4000_set_params()
170 ret = regmap_write(s->regmap, 0x10, e400_lna_filter_lut[i].val); e4000_set_params()
188 ret = regmap_bulk_write(s->regmap, 0x11, buf, 2); e4000_set_params()
203 ret = regmap_write(s->regmap, 0x07, e4000_band_lut[i].reg07_val); e4000_set_params()
207 ret = regmap_write(s->regmap, 0x78, e4000_band_lut[i].reg78_val); e4000_set_params()
214 ret = regmap_bulk_write(s->regmap, 0x15, "\x00\x7e\x24", 3); e4000_set_params()
216 ret = regmap_bulk_write(s->regmap, 0x15, "\x00\x7f", 2); e4000_set_params()
218 ret = regmap_bulk_write(s->regmap, 0x15, "\x01", 1); e4000_set_params()
220 ret = regmap_bulk_write(s->regmap, 0x16, "\x7e", 1); e4000_set_params()
225 ret = regmap_write(s->regmap, 0x29, 0x01); e4000_set_params()
229 ret = regmap_bulk_read(s->regmap, 0x2a, buf, 3); e4000_set_params()
240 ret = regmap_bulk_write(s->regmap, 0x50, q_data, 4); e4000_set_params()
244 ret = regmap_bulk_write(s->regmap, 0x60, i_data, 4); e4000_set_params()
249 ret = regmap_write(s->regmap, 0x1a, 0x17); e4000_set_params()
290 ret = regmap_write(s->regmap, 0x1a, u8tmp); e4000_set_lna_gain()
295 ret = regmap_write(s->regmap, 0x14, s->lna_gain->val); e4000_set_lna_gain()
321 ret = regmap_write(s->regmap, 0x20, u8tmp); e4000_set_mixer_gain()
326 ret = regmap_write(s->regmap, 0x15, s->mixer_gain->val); e4000_set_mixer_gain()
357 ret = regmap_write(s->regmap, 0x1a, u8tmp); e4000_set_if_gain()
364 ret = regmap_bulk_write(s->regmap, 0x16, buf, 2); e4000_set_if_gain()
381 ret = regmap_read(s->regmap, 0x07, &utmp); e4000_pll_lock()
499 s->regmap = devm_regmap_init_i2c(client, &regmap_config); e4000_probe()
500 if (IS_ERR(s->regmap)) { e4000_probe()
501 ret = PTR_ERR(s->regmap); e4000_probe()
506 ret = regmap_read(s->regmap, 0x02, &utmp); e4000_probe()
518 ret = regmap_write(s->regmap, 0x00, 0x00); e4000_probe()
/linux-4.1.27/drivers/iio/adc/
H A Daxp288_adc.c22 #include <linux/regmap.h>
46 struct regmap *regmap; member in struct:axp288_adc_info
115 struct regmap *regmap) axp288_adc_read_channel()
119 if (regmap_bulk_read(regmap, address, buf, 2)) axp288_adc_read_channel()
126 static int axp288_adc_set_ts(struct regmap *regmap, unsigned int mode, axp288_adc_set_ts() argument
133 return regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, mode); axp288_adc_set_ts()
146 if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_GPADC, axp288_adc_read_raw()
152 ret = axp288_adc_read_channel(val, chan->address, info->regmap); axp288_adc_read_raw()
153 if (axp288_adc_set_ts(info->regmap, AXP288_ADC_TS_PIN_ON, axp288_adc_read_raw()
165 static int axp288_adc_set_state(struct regmap *regmap) axp288_adc_set_state() argument
168 if (regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, AXP288_ADC_TS_PIN_ON)) axp288_adc_set_state()
171 return regmap_write(regmap, AXP20X_ADC_EN1, AXP288_ADC_EN_MASK); axp288_adc_set_state()
197 info->regmap = axp20x->regmap; axp288_adc_probe()
202 ret = axp288_adc_set_state(axp20x->regmap); axp288_adc_probe()
114 axp288_adc_read_channel(int *val, unsigned long address, struct regmap *regmap) axp288_adc_read_channel() argument
/linux-4.1.27/drivers/regulator/
H A Dmax8649.c19 #include <linux/regmap.h>
53 struct regmap *regmap; member in struct:max8649_regulator_info
69 ret = regmap_read(info->regmap, rdev->desc->vsel_reg, &val); max8649_enable_time()
76 ret = regmap_read(info->regmap, MAX8649_RAMP, &val); max8649_enable_time()
91 regmap_update_bits(info->regmap, rdev->desc->vsel_reg, max8649_set_mode()
95 regmap_update_bits(info->regmap, rdev->desc->vsel_reg, max8649_set_mode()
110 ret = regmap_read(info->regmap, rdev->desc->vsel_reg, &val); max8649_get_mode()
167 info->regmap = devm_regmap_init_i2c(client, &max8649_regmap_config); max8649_regulator_probe()
168 if (IS_ERR(info->regmap)) { max8649_regulator_probe()
169 ret = PTR_ERR(info->regmap); max8649_regulator_probe()
195 ret = regmap_read(info->regmap, MAX8649_CHIP_ID1, &val); max8649_regulator_probe()
204 regmap_update_bits(info->regmap, MAX8649_CONTROL, MAX8649_VID_MASK, 0); max8649_regulator_probe()
209 regmap_update_bits(info->regmap, dcdc_desc.vsel_reg, max8649_regulator_probe()
214 regmap_update_bits(info->regmap, MAX8649_SYNC, MAX8649_EXT_MASK, max8649_regulator_probe()
220 regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_MASK, max8649_regulator_probe()
226 regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_DOWN, max8649_regulator_probe()
233 config.regmap = info->regmap; max8649_regulator_probe()
H A Dmax77843.c38 struct regmap *regmap = rdev->regmap; max77843_reg_is_enabled() local
42 ret = regmap_read(regmap, rdev->desc->enable_reg, &reg); max77843_reg_is_enabled()
53 struct regmap *regmap = rdev->regmap; max77843_reg_get_current_limit() local
60 ret = regmap_read(regmap, MAX77843_CHG_REG_CHG_CNFG_02, &reg); max77843_reg_get_current_limit()
83 struct regmap *regmap = rdev->regmap; max77843_reg_set_current_limit() local
95 return regmap_write(regmap, MAX77843_CHG_REG_CHG_CNFG_02, sel); max77843_reg_set_current_limit()
159 static struct regmap *max77843_get_regmap(struct max77843 *max77843, int reg_id) max77843_get_regmap()
164 return max77843->regmap; max77843_get_regmap()
168 return max77843->regmap; max77843_get_regmap()
184 config.regmap = max77843_get_regmap(max77843, max77843_regulator_probe()
H A Dda9210-regulator.c29 #include <linux/regmap.h>
35 struct regmap *regmap; member in struct:da9210
97 return regmap_update_bits(chip->regmap, da9210_set_current_limit()
113 ret = regmap_read(chip->regmap, DA9210_REG_BUCK_ILIM, &data); da9210_get_current_limit()
140 chip->regmap = devm_regmap_init_i2c(i2c, &da9210_regmap_config); da9210_i2c_probe()
141 if (IS_ERR(chip->regmap)) { da9210_i2c_probe()
142 error = PTR_ERR(chip->regmap); da9210_i2c_probe()
152 config.regmap = chip->regmap; da9210_i2c_probe()
156 error = regmap_write(chip->regmap, DA9210_REG_MASK_A, ~0); da9210_i2c_probe()
158 error = regmap_write(chip->regmap, DA9210_REG_MASK_B, ~0); da9210_i2c_probe()
H A Dhelpers.c17 #include <linux/regmap.h>
23 * regulator_is_enabled_regmap - standard is_enabled() for regmap users
27 * Regulators that use regmap for their register I/O can set the
36 ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val); regulator_is_enabled_regmap()
55 * regulator_enable_regmap - standard enable() for regmap users
59 * Regulators that use regmap for their register I/O can set the
75 return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, regulator_enable_regmap()
81 * regulator_disable_regmap - standard disable() for regmap users
85 * Regulators that use regmap for their register I/O can set the
101 return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, regulator_disable_regmap()
107 * regulator_get_voltage_sel_regmap - standard get_voltage_sel for regmap users
111 * Regulators that use regmap for their register I/O can set the
120 ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val); regulator_get_voltage_sel_regmap()
132 * regulator_set_voltage_sel_regmap - standard set_voltage_sel for regmap users
137 * Regulators that use regmap for their register I/O can set the
147 ret = regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg, regulator_set_voltage_sel_regmap()
153 ret = regmap_update_bits(rdev->regmap, rdev->desc->apply_reg, regulator_set_voltage_sel_regmap()
426 * regulator_set_bypass_regmap - Default set_bypass() using regmap
443 return regmap_update_bits(rdev->regmap, rdev->desc->bypass_reg, regulator_set_bypass_regmap()
449 * regulator_get_bypass_regmap - Default get_bypass() using regmap
459 ret = regmap_read(rdev->regmap, rdev->desc->bypass_reg, &val); regulator_get_bypass_regmap()
H A Disl9305.c19 #include <linux/regmap.h>
146 struct regmap *regmap; isl9305_i2c_probe() local
149 regmap = devm_regmap_init_i2c(i2c, &isl9305_regmap); isl9305_i2c_probe()
150 if (IS_ERR(regmap)) { isl9305_i2c_probe()
151 ret = PTR_ERR(regmap); isl9305_i2c_probe()
152 dev_err(&i2c->dev, "Failed to create regmap: %d\n", ret); isl9305_i2c_probe()
H A Dvexpress.c29 struct regmap *regmap; member in struct:vexpress_regulator
36 int err = regmap_read(reg->regmap, 0, &uV); vexpress_regulator_get_voltage()
46 return regmap_write(reg->regmap, 0, min_uV); vexpress_regulator_set_voltage()
68 reg->regmap = devm_regmap_init_vexpress_config(&pdev->dev); vexpress_regulator_probe()
69 if (IS_ERR(reg->regmap)) vexpress_regulator_probe()
70 return PTR_ERR(reg->regmap); vexpress_regulator_probe()
H A Dda9211-regulator.c24 #include <linux/regmap.h>
46 struct regmap *regmap; member in struct:da9211
101 ret = regmap_read(chip->regmap, DA9211_REG_BUCKA_CONF+id, &data); da9211_buck_get_mode()
139 return regmap_update_bits(chip->regmap, DA9211_REG_BUCKA_CONF+id, da9211_buck_set_mode()
168 return regmap_update_bits(chip->regmap, da9211_set_current_limit()
196 ret = regmap_read(chip->regmap, DA9211_REG_BUCK_ILIM, &data); da9211_get_current_limit()
302 err = regmap_read(chip->regmap, DA9211_REG_EVENT_B, &reg_val); da9211_irq_handler()
310 err = regmap_write(chip->regmap, DA9211_REG_EVENT_B, da9211_irq_handler()
322 err = regmap_write(chip->regmap, DA9211_REG_EVENT_B, da9211_irq_handler()
343 ret = regmap_read(chip->regmap, DA9211_REG_CONFIG_E, &data); da9211_regulator_init()
368 config.regmap = chip->regmap; da9211_regulator_init()
388 ret = regmap_update_bits(chip->regmap, da9211_regulator_init()
416 chip->regmap = devm_regmap_init_i2c(i2c, &da9211_regmap_config); da9211_i2c_probe()
417 if (IS_ERR(chip->regmap)) { da9211_i2c_probe()
418 error = PTR_ERR(chip->regmap); da9211_i2c_probe()
428 ret = regmap_read(chip->regmap, DA9211_REG_DEVICE_ID, &data); da9211_i2c_probe()
H A Darizona-ldo1.c67 struct regmap *regmap = ldo->arizona->regmap; arizona_ldo1_hc_set_voltage_sel() local
76 ret = regmap_update_bits(regmap, ARIZONA_LDO1_CONTROL_2, arizona_ldo1_hc_set_voltage_sel()
81 ret = regmap_update_bits(regmap, ARIZONA_DYNAMIC_FREQUENCY_SCALING_1, arizona_ldo1_hc_set_voltage_sel()
91 return regmap_update_bits(regmap, ARIZONA_LDO1_CONTROL_1, arizona_ldo1_hc_set_voltage_sel()
98 struct regmap *regmap = ldo->arizona->regmap; arizona_ldo1_hc_get_voltage_sel() local
102 ret = regmap_read(regmap, ARIZONA_LDO1_CONTROL_2, &val); arizona_ldo1_hc_get_voltage_sel()
109 ret = regmap_read(regmap, ARIZONA_LDO1_CONTROL_1, &val); arizona_ldo1_hc_get_voltage_sel()
258 config.regmap = arizona->regmap; arizona_ldo1_probe()
H A Dfan53555.c25 #include <linux/regmap.h>
76 struct regmap *regmap; member in struct:fan53555_device_info
106 ret = regmap_update_bits(di->regmap, di->sleep_reg, fan53555_set_suspend_voltage()
123 regmap_update_bits(di->regmap, di->vol_reg, fan53555_set_mode()
127 regmap_update_bits(di->regmap, di->vol_reg, VSEL_MODE, 0); fan53555_set_mode()
141 ret = regmap_read(di->regmap, di->vol_reg, &val); fan53555_get_mode()
178 return regmap_update_bits(di->regmap, FAN53555_CONTROL, fan53555_set_ramp()
388 di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config); fan53555_regulator_probe()
389 if (IS_ERR(di->regmap)) { fan53555_regulator_probe()
390 dev_err(&client->dev, "Failed to allocate regmap!\n"); fan53555_regulator_probe()
391 return PTR_ERR(di->regmap); fan53555_regulator_probe()
396 ret = regmap_read(di->regmap, FAN53555_ID1, &val); fan53555_regulator_probe()
403 ret = regmap_read(di->regmap, FAN53555_ID2, &val); fan53555_regulator_probe()
420 config.regmap = di->regmap; fan53555_regulator_probe()
/linux-4.1.27/include/linux/
H A Dregmap.h27 struct regmap;
83 * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
85 * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
101 * @name: Optional name of the regmap. Useful when a device has multiple
132 * @lock: Optional lock callback (overrides regmap's default lock
178 * regmap bus is used.
181 * regmap bus is used.
327 struct regmap *regmap_init(struct device *dev,
331 int regmap_attach_dev(struct device *dev, struct regmap *map,
333 struct regmap *regmap_init_i2c(struct i2c_client *i2c,
335 struct regmap *regmap_init_spi(struct spi_device *dev,
337 struct regmap *regmap_init_spmi_base(struct spmi_device *dev,
339 struct regmap *regmap_init_spmi_ext(struct spmi_device *dev,
341 struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
344 struct regmap *regmap_init_ac97(struct snd_ac97 *ac97,
347 struct regmap *devm_regmap_init(struct device *dev,
351 struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
353 struct regmap *devm_regmap_init_spi(struct spi_device *dev,
355 struct regmap *devm_regmap_init_spmi_base(struct spmi_device *dev,
357 struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *dev,
359 struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
362 struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97,
375 * a struct regmap.
377 static inline struct regmap *regmap_init_mmio(struct device *dev, regmap_init_mmio()
392 * to a struct regmap. The regmap will be automatically freed by the
395 static inline struct regmap *devm_regmap_init_mmio(struct device *dev, devm_regmap_init_mmio()
402 void regmap_exit(struct regmap *map);
403 int regmap_reinit_cache(struct regmap *map,
405 struct regmap *dev_get_regmap(struct device *dev, const char *name);
406 struct device *regmap_get_device(struct regmap *map);
407 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
408 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val);
409 int regmap_raw_write(struct regmap *map, unsigned int reg,
411 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
413 int regmap_multi_reg_write(struct regmap *map, const struct reg_default *regs,
415 int regmap_multi_reg_write_bypassed(struct regmap *map,
418 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
420 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
421 int regmap_raw_read(struct regmap *map, unsigned int reg,
423 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
425 int regmap_update_bits(struct regmap *map, unsigned int reg,
427 int regmap_update_bits_async(struct regmap *map, unsigned int reg,
429 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
432 int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
435 int regmap_get_val_bytes(struct regmap *map);
436 int regmap_async_complete(struct regmap *map);
437 bool regmap_can_raw_write(struct regmap *map);
439 int regcache_sync(struct regmap *map);
440 int regcache_sync_region(struct regmap *map, unsigned int min,
442 int regcache_drop_region(struct regmap *map, unsigned int min,
444 void regcache_cache_only(struct regmap *map, bool enable);
445 void regcache_cache_bypass(struct regmap *map, bool enable);
446 void regcache_mark_dirty(struct regmap *map);
448 bool regmap_check_range_table(struct regmap *map, unsigned int reg,
451 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
453 int regmap_parse_val(struct regmap *map, const void *buf,
469 * @reg: Offset of the register within the regmap bank
489 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
494 struct regmap *regmap, struct reg_field reg_field);
510 * Description of an IRQ for the generic regmap irq_chip.
521 * Description of a generic regmap irq_chip. This is not intended to
566 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
578 * regmap based facilities, if they ever get called at runtime
583 static inline int regmap_write(struct regmap *map, unsigned int reg, regmap_write()
586 WARN_ONCE(1, "regmap API is disabled"); regmap_write()
590 static inline int regmap_write_async(struct regmap *map, unsigned int reg, regmap_write_async()
593 WARN_ONCE(1, "regmap API is disabled"); regmap_write_async()
597 static inline int regmap_raw_write(struct regmap *map, unsigned int reg, regmap_raw_write()
600 WARN_ONCE(1, "regmap API is disabled"); regmap_raw_write()
604 static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg, regmap_raw_write_async()
607 WARN_ONCE(1, "regmap API is disabled"); regmap_raw_write_async()
611 static inline int regmap_bulk_write(struct regmap *map, unsigned int reg, regmap_bulk_write()
614 WARN_ONCE(1, "regmap API is disabled"); regmap_bulk_write()
618 static inline int regmap_read(struct regmap *map, unsigned int reg, regmap_read()
621 WARN_ONCE(1, "regmap API is disabled"); regmap_read()
625 static inline int regmap_raw_read(struct regmap *map, unsigned int reg, regmap_raw_read()
628 WARN_ONCE(1, "regmap API is disabled"); regmap_raw_read()
632 static inline int regmap_bulk_read(struct regmap *map, unsigned int reg, regmap_bulk_read()
635 WARN_ONCE(1, "regmap API is disabled"); regmap_bulk_read()
639 static inline int regmap_update_bits(struct regmap *map, unsigned int reg, regmap_update_bits()
642 WARN_ONCE(1, "regmap API is disabled"); regmap_update_bits()
646 static inline int regmap_update_bits_async(struct regmap *map, regmap_update_bits_async()
650 WARN_ONCE(1, "regmap API is disabled"); regmap_update_bits_async()
654 static inline int regmap_update_bits_check(struct regmap *map, regmap_update_bits_check()
659 WARN_ONCE(1, "regmap API is disabled"); regmap_update_bits_check()
663 static inline int regmap_update_bits_check_async(struct regmap *map, regmap_update_bits_check_async()
669 WARN_ONCE(1, "regmap API is disabled"); regmap_update_bits_check_async()
673 static inline int regmap_get_val_bytes(struct regmap *map) regmap_get_val_bytes()
675 WARN_ONCE(1, "regmap API is disabled"); regmap_get_val_bytes()
679 static inline int regcache_sync(struct regmap *map) regcache_sync()
681 WARN_ONCE(1, "regmap API is disabled"); regcache_sync()
685 static inline int regcache_sync_region(struct regmap *map, unsigned int min, regcache_sync_region()
688 WARN_ONCE(1, "regmap API is disabled"); regcache_sync_region()
692 static inline int regcache_drop_region(struct regmap *map, unsigned int min, regcache_drop_region()
695 WARN_ONCE(1, "regmap API is disabled"); regcache_drop_region()
699 static inline void regcache_cache_only(struct regmap *map, bool enable) regcache_cache_only()
701 WARN_ONCE(1, "regmap API is disabled"); regcache_cache_only()
704 static inline void regcache_cache_bypass(struct regmap *map, bool enable) regcache_cache_bypass()
706 WARN_ONCE(1, "regmap API is disabled"); regcache_cache_bypass()
709 static inline void regcache_mark_dirty(struct regmap *map) regcache_mark_dirty()
711 WARN_ONCE(1, "regmap API is disabled"); regcache_mark_dirty()
714 static inline void regmap_async_complete(struct regmap *map) regmap_async_complete()
716 WARN_ONCE(1, "regmap API is disabled"); regmap_async_complete()
719 static inline int regmap_register_patch(struct regmap *map, regmap_register_patch()
723 WARN_ONCE(1, "regmap API is disabled"); regmap_register_patch()
727 static inline int regmap_parse_val(struct regmap *map, const void *buf, regmap_parse_val()
730 WARN_ONCE(1, "regmap API is disabled"); regmap_parse_val()
734 static inline struct regmap *dev_get_regmap(struct device *dev, dev_get_regmap()
740 static inline struct device *regmap_get_device(struct regmap *map) regmap_get_device()
742 WARN_ONCE(1, "regmap API is disabled"); regmap_get_device()
H A Dvexpress.h18 #include <linux/regmap.h>
39 struct regmap * (*regmap_init)(struct device *dev, void *context);
40 void (*regmap_exit)(struct regmap *regmap, void *context);
46 /* Config regmap API */
48 struct regmap *devm_regmap_init_vexpress_config(struct device *dev);
/linux-4.1.27/drivers/misc/
H A Dbmp085-spi.c28 struct regmap *regmap; bmp085_spi_probe() local
37 regmap = devm_regmap_init_spi(client, &bmp085_regmap_config); bmp085_spi_probe()
38 if (IS_ERR(regmap)) { bmp085_spi_probe()
39 err = PTR_ERR(regmap); bmp085_spi_probe()
40 dev_err(&client->dev, "Failed to init regmap: %d\n", err); bmp085_spi_probe()
44 return bmp085_probe(&client->dev, regmap, client->irq); bmp085_spi_probe()
H A Dbmp085-i2c.c43 struct regmap *regmap = devm_regmap_init_i2c(client, bmp085_i2c_probe() local
46 if (IS_ERR(regmap)) { bmp085_i2c_probe()
47 err = PTR_ERR(regmap); bmp085_i2c_probe()
48 dev_err(&client->dev, "Failed to init regmap: %d\n", err); bmp085_i2c_probe()
52 return bmp085_probe(&client->dev, regmap, client->irq); bmp085_i2c_probe()
H A Dbmp085.h23 #include <linux/regmap.h>
29 int bmp085_probe(struct device *dev, struct regmap *regmap, int irq);
H A Dvexpress-syscfg.c50 struct regmap *regmap; member in struct:vexpress_syscfg_func
145 static struct regmap *vexpress_syscfg_regmap_init(struct device *dev, vexpress_syscfg_regmap_init()
212 func->regmap = regmap_init(dev, NULL, func, vexpress_syscfg_regmap_init()
215 if (IS_ERR(func->regmap)) { vexpress_syscfg_regmap_init()
216 void *err = func->regmap; vexpress_syscfg_regmap_init()
224 return func->regmap; vexpress_syscfg_regmap_init()
227 static void vexpress_syscfg_regmap_exit(struct regmap *regmap, void *context) vexpress_syscfg_regmap_exit() argument
232 regmap_exit(regmap); vexpress_syscfg_regmap_exit()
235 if (func->regmap == regmap) { vexpress_syscfg_regmap_exit()
/linux-4.1.27/drivers/staging/iio/magnetometer/
H A Dhmc5843.h16 #include <linux/regmap.h>
37 * @lock: update and read regmap data
38 * @regmap: hardware access register maps
45 struct regmap *regmap; member in struct:hmc5843_data
50 int hmc5843_common_probe(struct device *dev, struct regmap *regmap,
/linux-4.1.27/drivers/gpu/drm/atmel-hlcdc/
H A Datmel_hlcdc_crtc.c60 struct regmap *regmap = crtc->dc->hlcdc->regmap; atmel_hlcdc_crtc_mode_set_nofb() local
75 regmap_write(regmap, ATMEL_HLCDC_CFG(1), atmel_hlcdc_crtc_mode_set_nofb()
78 regmap_write(regmap, ATMEL_HLCDC_CFG(2), atmel_hlcdc_crtc_mode_set_nofb()
81 regmap_write(regmap, ATMEL_HLCDC_CFG(3), atmel_hlcdc_crtc_mode_set_nofb()
84 regmap_write(regmap, ATMEL_HLCDC_CFG(4), atmel_hlcdc_crtc_mode_set_nofb()
103 regmap_update_bits(regmap, ATMEL_HLCDC_CFG(0), atmel_hlcdc_crtc_mode_set_nofb()
115 regmap_update_bits(regmap, ATMEL_HLCDC_CFG(5), atmel_hlcdc_crtc_mode_set_nofb()
135 struct regmap *regmap = crtc->dc->hlcdc->regmap; atmel_hlcdc_crtc_disable() local
145 regmap_write(regmap, ATMEL_HLCDC_DIS, ATMEL_HLCDC_DISP); atmel_hlcdc_crtc_disable()
146 while (!regmap_read(regmap, ATMEL_HLCDC_SR, &status) && atmel_hlcdc_crtc_disable()
150 regmap_write(regmap, ATMEL_HLCDC_DIS, ATMEL_HLCDC_SYNC); atmel_hlcdc_crtc_disable()
151 while (!regmap_read(regmap, ATMEL_HLCDC_SR, &status) && atmel_hlcdc_crtc_disable()
155 regmap_write(regmap, ATMEL_HLCDC_DIS, ATMEL_HLCDC_PIXEL_CLK); atmel_hlcdc_crtc_disable()
156 while (!regmap_read(regmap, ATMEL_HLCDC_SR, &status) && atmel_hlcdc_crtc_disable()
174 struct regmap *regmap = crtc->dc->hlcdc->regmap; atmel_hlcdc_crtc_enable() local
187 regmap_write(regmap, ATMEL_HLCDC_EN, ATMEL_HLCDC_PIXEL_CLK); atmel_hlcdc_crtc_enable()
188 while (!regmap_read(regmap, ATMEL_HLCDC_SR, &status) && atmel_hlcdc_crtc_enable()
193 regmap_write(regmap, ATMEL_HLCDC_EN, ATMEL_HLCDC_SYNC); atmel_hlcdc_crtc_enable()
194 while (!regmap_read(regmap, ATMEL_HLCDC_SR, &status) && atmel_hlcdc_crtc_enable()
198 regmap_write(regmap, ATMEL_HLCDC_EN, ATMEL_HLCDC_DISP); atmel_hlcdc_crtc_enable()
199 while (!regmap_read(regmap, ATMEL_HLCDC_SR, &status) && atmel_hlcdc_crtc_enable()
H A Datmel_hlcdc_layer.c90 struct regmap *regmap = layer->hlcdc->regmap; atmel_hlcdc_layer_update_apply() local
104 regmap_write(regmap, atmel_hlcdc_layer_update_apply()
124 regmap_write(regmap, atmel_hlcdc_layer_update_apply()
128 regmap_write(regmap, atmel_hlcdc_layer_update_apply()
132 regmap_write(regmap, atmel_hlcdc_layer_update_apply()
148 regmap_write(regmap, atmel_hlcdc_layer_update_apply()
168 regmap_write(regmap, atmel_hlcdc_layer_update_apply()
181 struct regmap *regmap = layer->hlcdc->regmap; atmel_hlcdc_layer_irq() local
191 regmap_read(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_IMR, &imr); atmel_hlcdc_layer_irq()
192 regmap_read(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_ISR, &isr); atmel_hlcdc_layer_irq()
276 regmap_write(regmap, atmel_hlcdc_layer_irq()
305 struct regmap *regmap = layer->hlcdc->regmap; atmel_hlcdc_layer_disable() local
313 regmap_write(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_CHDR, atmel_hlcdc_layer_disable()
318 regmap_read(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_ISR, &isr); atmel_hlcdc_layer_disable()
350 struct regmap *regmap = layer->hlcdc->regmap; atmel_hlcdc_layer_update_start() local
413 regmap_bulk_read(regmap, atmel_hlcdc_layer_update_start()
605 struct regmap *regmap = dc->hlcdc->regmap; atmel_hlcdc_layer_init() local
614 regmap_write(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_CHDR, atmel_hlcdc_layer_init()
635 regmap_write(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_IDR, atmel_hlcdc_layer_init()
637 regmap_read(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_ISR, atmel_hlcdc_layer_init()
648 regmap_write(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_IER, tmp); atmel_hlcdc_layer_init()
657 struct regmap *regmap = layer->hlcdc->regmap; atmel_hlcdc_layer_cleanup() local
659 regmap_write(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_IDR, atmel_hlcdc_layer_cleanup()
661 regmap_write(regmap, desc->regs_offset + ATMEL_HLCDC_LAYER_CHDR, atmel_hlcdc_layer_cleanup()
/linux-4.1.27/include/linux/mfd/da9055/
H A Dcore.h28 #include <linux/regmap.h>
42 struct regmap *regmap; member in struct:da9055
56 ret = regmap_read(da9055->regmap, reg, &val); da9055_reg_read()
66 return regmap_write(da9055->regmap, reg, val); da9055_reg_write()
72 return regmap_bulk_read(da9055->regmap, reg, val, reg_cnt); da9055_group_read()
78 return regmap_raw_write(da9055->regmap, reg, val, reg_cnt); da9055_group_write()
85 return regmap_update_bits(da9055->regmap, reg, bit_mask, reg_val); da9055_reg_update()
/linux-4.1.27/drivers/gpio/
H A Dgpio-crystalcove.c23 #include <linux/regmap.h>
74 * @regmap: the regmap from the parent device.
82 struct regmap *regmap; member in struct:crystalcove_gpio
123 regmap_update_bits(cg->regmap, mirqs0, mask, mask); crystalcove_update_irq_mask()
125 regmap_update_bits(cg->regmap, mirqs0, mask, 0); crystalcove_update_irq_mask()
132 regmap_update_bits(cg->regmap, reg, CTLI_INTCNT_BE, cg->intcnt_value); crystalcove_update_irq_ctrl()
142 return regmap_write(cg->regmap, to_reg(gpio, CTRL_OUT), crystalcove_gpio_dir_in()
154 return regmap_write(cg->regmap, to_reg(gpio, CTRL_OUT), crystalcove_gpio_dir_out()
167 ret = regmap_read(cg->regmap, to_reg(gpio, CTRL_IN), &val); crystalcove_gpio_get()
183 regmap_update_bits(cg->regmap, to_reg(gpio, CTRL_OUT), 1, 1); crystalcove_gpio_set()
185 regmap_update_bits(cg->regmap, to_reg(gpio, CTRL_OUT), 1, 0); crystalcove_gpio_set()
269 if (regmap_read(cg->regmap, GPIO0IRQ, &p0) || crystalcove_gpio_irq_handler()
270 regmap_read(cg->regmap, GPIO1IRQ, &p1)) crystalcove_gpio_irq_handler()
273 regmap_write(cg->regmap, GPIO0IRQ, p0); crystalcove_gpio_irq_handler()
274 regmap_write(cg->regmap, GPIO1IRQ, p1); crystalcove_gpio_irq_handler()
296 regmap_read(cg->regmap, to_reg(gpio, CTRL_OUT), &ctlo); crystalcove_gpio_dbg_show()
297 regmap_read(cg->regmap, to_reg(gpio, CTRL_IN), &ctli); crystalcove_gpio_dbg_show()
298 regmap_read(cg->regmap, gpio < 8 ? MGPIO0IRQS0 : MGPIO1IRQS0, crystalcove_gpio_dbg_show()
300 regmap_read(cg->regmap, gpio < 8 ? MGPIO0IRQSX : MGPIO1IRQSX, crystalcove_gpio_dbg_show()
302 regmap_read(cg->regmap, gpio < 8 ? GPIO0IRQ : GPIO1IRQ, crystalcove_gpio_dbg_show()
346 cg->regmap = pmic->regmap; crystalcove_gpio_probe()
/linux-4.1.27/drivers/gpu/drm/i2c/
H A Dadv7511.c13 #include <linux/regmap.h>
27 struct regmap *regmap; member in struct:adv7511
28 struct regmap *packet_memory_regmap;
171 regmap_update_bits(adv7511->regmap, ADV7511_REG_CSC_UPPER(1), adv7511_set_colormap()
176 regmap_update_bits(adv7511->regmap, adv7511_set_colormap()
179 regmap_write(adv7511->regmap, adv7511_set_colormap()
186 regmap_update_bits(adv7511->regmap, ADV7511_REG_CSC_UPPER(0), adv7511_set_colormap()
189 regmap_update_bits(adv7511->regmap, ADV7511_REG_CSC_UPPER(0), adv7511_set_colormap()
192 regmap_update_bits(adv7511->regmap, ADV7511_REG_CSC_UPPER(1), adv7511_set_colormap()
199 regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE0, adv7511_packet_enable()
204 regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE1, adv7511_packet_enable()
214 regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE0, adv7511_packet_disable()
219 regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE1, adv7511_packet_disable()
299 regmap_update_bits(adv7511->regmap, ADV7511_REG_VIDEO_INPUT_CFG1, 0x81, adv7511_set_config_csc()
302 regmap_update_bits(adv7511->regmap, ADV7511_REG_HDCP_HDMI_CFG, adv7511_set_config_csc()
309 regmap_bulk_write(adv7511->regmap, ADV7511_REG_AVI_INFOFRAME_VERSION, adv7511_set_config_csc()
343 regmap_update_bits(adv7511->regmap, ADV7511_REG_I2C_FREQ_ID_CFG, 0xf, adv7511_set_link_config()
345 regmap_update_bits(adv7511->regmap, ADV7511_REG_VIDEO_INPUT_CFG1, 0x7e, adv7511_set_link_config()
348 regmap_write(adv7511->regmap, ADV7511_REG_VIDEO_INPUT_CFG2, adv7511_set_link_config()
350 regmap_write(adv7511->regmap, ADV7511_REG_TIMING_GEN_SEQ, adv7511_set_link_config()
353 regmap_write(adv7511->regmap, 0xba, clock_delay << 5); adv7511_set_link_config()
365 regmap_write(adv7511->regmap, ADV7511_REG_INT(0), adv7511_power_on()
367 regmap_write(adv7511->regmap, ADV7511_REG_INT(1), adv7511_power_on()
369 regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER, adv7511_power_on()
380 regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER2, adv7511_power_on()
387 regcache_sync(adv7511->regmap); adv7511_power_on()
395 regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER, adv7511_power_off()
398 regcache_mark_dirty(adv7511->regmap); adv7511_power_off()
412 ret = regmap_read(adv7511->regmap, ADV7511_REG_INT(0), &irq0); adv7511_hpd()
417 regmap_write(adv7511->regmap, ADV7511_REG_INT(0), adv7511_hpd()
430 ret = regmap_read(adv7511->regmap, ADV7511_REG_INT(0), &irq0); adv7511_irq_process()
434 ret = regmap_read(adv7511->regmap, ADV7511_REG_INT(1), &irq1); adv7511_irq_process()
438 regmap_write(adv7511->regmap, ADV7511_REG_INT(0), irq0); adv7511_irq_process()
439 regmap_write(adv7511->regmap, ADV7511_REG_INT(1), irq1); adv7511_irq_process()
505 ret = regmap_read(adv7511->regmap, ADV7511_REG_DDC_STATUS, adv7511_get_edid_block()
512 regmap_write(adv7511->regmap, ADV7511_REG_EDID_SEGMENT, adv7511_get_edid_block()
570 regmap_write(adv7511->regmap, ADV7511_REG_INT(0), adv7511_get_modes()
572 regmap_write(adv7511->regmap, ADV7511_REG_INT(1), adv7511_get_modes()
574 regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER, adv7511_get_modes()
582 regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER, adv7511_get_modes()
619 ret = regmap_read(adv7511->regmap, ADV7511_REG_STATUS, &val); adv7511_encoder_detect()
635 regcache_mark_dirty(adv7511->regmap); adv7511_encoder_detect()
642 regmap_update_bits(adv7511->regmap, ADV7511_REG_POWER2, adv7511_encoder_detect()
685 regmap_write(adv7511->regmap, ADV7511_REG_HSYNC_PLACEMENT_MSB, adv7511_encoder_mode_set()
687 regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(0), adv7511_encoder_mode_set()
689 regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(1), adv7511_encoder_mode_set()
692 regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(2), adv7511_encoder_mode_set()
695 regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(3), adv7511_encoder_mode_set()
698 regmap_write(adv7511->regmap, ADV7511_REG_SYNC_DECODER(4), adv7511_encoder_mode_set()
742 regmap_update_bits(adv7511->regmap, 0xfb, adv7511_encoder_mode_set()
744 regmap_update_bits(adv7511->regmap, 0x17, adv7511_encoder_mode_set()
891 adv7511->regmap = devm_regmap_init_i2c(i2c, &adv7511_regmap_config); adv7511_probe()
892 if (IS_ERR(adv7511->regmap)) adv7511_probe()
893 return PTR_ERR(adv7511->regmap); adv7511_probe()
895 ret = regmap_read(adv7511->regmap, ADV7511_REG_CHIP_REVISION, &val); adv7511_probe()
900 ret = regmap_register_patch(adv7511->regmap, adv7511_fixed_registers, adv7511_probe()
905 regmap_write(adv7511->regmap, ADV7511_REG_EDID_I2C_ADDR, edid_i2c_addr); adv7511_probe()
906 regmap_write(adv7511->regmap, ADV7511_REG_PACKET_I2C_ADDR, adv7511_probe()
908 regmap_write(adv7511->regmap, ADV7511_REG_CEC_I2C_ADDR, cec_i2c_addr); adv7511_probe()
928 regmap_write(adv7511->regmap, ADV7511_REG_CEC_CTRL, adv7511_probe()
/linux-4.1.27/sound/soc/fsl/
H A Dfsl_spdif.c22 #include <linux/regmap.h>
80 * @regmap: regmap handler
98 struct regmap *regmap; member in struct:fsl_spdif_priv
116 struct regmap *regmap = spdif_priv->regmap; spdif_irq_dpll_lock() local
120 regmap_read(regmap, REG_SPDIF_SRPC, &locked); spdif_irq_dpll_lock()
132 struct regmap *regmap = spdif_priv->regmap; spdif_irq_sym_error() local
139 regmap_update_bits(regmap, REG_SPDIF_SIE, INT_SYM_ERR, 0); spdif_irq_sym_error()
146 struct regmap *regmap = spdif_priv->regmap; spdif_irq_uqrx_full() local
175 regmap_read(regmap, reg, &val); spdif_irq_uqrx_full()
201 struct regmap *regmap = spdif_priv->regmap; spdif_irq_uq_err() local
208 regmap_read(regmap, REG_SPDIF_SRU, &val); spdif_irq_uq_err()
209 regmap_read(regmap, REG_SPDIF_SRQ, &val); spdif_irq_uq_err()
220 struct regmap *regmap = spdif_priv->regmap; spdif_intr_status_clear() local
223 regmap_read(regmap, REG_SPDIF_SIS, &val); spdif_intr_status_clear()
224 regmap_read(regmap, REG_SPDIF_SIE, &val2); spdif_intr_status_clear()
226 regmap_write(regmap, REG_SPDIF_SIC, val & val2); spdif_intr_status_clear()
300 struct regmap *regmap = spdif_priv->regmap; spdif_softreset() local
303 regmap_write(regmap, REG_SPDIF_SCR, SCR_SOFT_RESET); spdif_softreset()
310 regmap_read(regmap, REG_SPDIF_SCR, &val); spdif_softreset()
329 struct regmap *regmap = spdif_priv->regmap; spdif_write_channel_status() local
336 regmap_write(regmap, REG_SPDIF_STCSCH, ch_status); spdif_write_channel_status()
341 regmap_write(regmap, REG_SPDIF_STCSCL, ch_status); spdif_write_channel_status()
350 struct regmap *regmap = spdif_priv->regmap; spdif_set_rx_clksrc() local
356 regmap_update_bits(regmap, REG_SPDIF_SRPC, spdif_set_rx_clksrc()
369 struct regmap *regmap = spdif_priv->regmap; spdif_set_sample_rate() local
444 regmap_update_bits(regmap, REG_SPDIF_STC, mask, stc); spdif_set_sample_rate()
458 struct regmap *regmap = spdif_priv->regmap; fsl_spdif_startup() local
477 regmap_update_bits(regmap, REG_SPDIF_SIE, 0xffffff, 0); fsl_spdif_startup()
495 regmap_update_bits(regmap, REG_SPDIF_SCR, mask, scr); fsl_spdif_startup()
498 regmap_update_bits(regmap, REG_SPDIF_SCR, SCR_LOW_POWER, 0); fsl_spdif_startup()
513 struct regmap *regmap = spdif_priv->regmap; fsl_spdif_shutdown() local
529 regmap_update_bits(regmap, REG_SPDIF_SCR, mask, scr); fsl_spdif_shutdown()
534 regmap_update_bits(regmap, REG_SPDIF_SCR, fsl_spdif_shutdown()
574 struct regmap *regmap = spdif_priv->regmap; fsl_spdif_trigger() local
583 regmap_update_bits(regmap, REG_SPDIF_SIE, intr, intr); fsl_spdif_trigger()
584 regmap_update_bits(regmap, REG_SPDIF_SCR, dmaen, dmaen); fsl_spdif_trigger()
589 regmap_update_bits(regmap, REG_SPDIF_SCR, dmaen, 0); fsl_spdif_trigger()
590 regmap_update_bits(regmap, REG_SPDIF_SIE, intr, 0); fsl_spdif_trigger()
664 struct regmap *regmap = spdif_priv->regmap; fsl_spdif_capture_get() local
667 regmap_read(regmap, REG_SPDIF_SIS, &val); fsl_spdif_capture_get()
671 regmap_read(regmap, REG_SPDIF_SRCSH, &cstatus); fsl_spdif_capture_get()
676 regmap_read(regmap, REG_SPDIF_SRCSL, &cstatus); fsl_spdif_capture_get()
682 regmap_write(regmap, REG_SPDIF_SIC, INT_CNEW); fsl_spdif_capture_get()
762 struct regmap *regmap = spdif_priv->regmap; fsl_spdif_vbit_get() local
765 regmap_read(regmap, REG_SPDIF_SIS, &val); fsl_spdif_vbit_get()
767 regmap_write(regmap, REG_SPDIF_SIC, INT_VAL_NOGOOD); fsl_spdif_vbit_get()
792 struct regmap *regmap = spdif_priv->regmap; spdif_get_rxclk_rate() local
798 regmap_read(regmap, REG_SPDIF_SRFM, &freqmeas); spdif_get_rxclk_rate()
799 regmap_read(regmap, REG_SPDIF_SRPC, &phaseconf); spdif_get_rxclk_rate()
861 struct regmap *regmap = spdif_priv->regmap; fsl_spdif_usync_get() local
864 regmap_read(regmap, REG_SPDIF_SRCD, &val); fsl_spdif_usync_get()
880 struct regmap *regmap = spdif_priv->regmap; fsl_spdif_usync_put() local
883 regmap_update_bits(regmap, REG_SPDIF_SRCD, SRCD_CD_USER, val); fsl_spdif_usync_put()
1183 spdif_priv->regmap = devm_regmap_init_mmio_clk(&pdev->dev, fsl_spdif_probe()
1185 if (IS_ERR(spdif_priv->regmap)) { fsl_spdif_probe()
1186 dev_err(&pdev->dev, "regmap init failed\n"); fsl_spdif_probe()
1187 return PTR_ERR(spdif_priv->regmap); fsl_spdif_probe()
H A Dfsl_sai.c18 #include <linux/regmap.h>
45 regmap_read(sai->regmap, FSL_SAI_TCSR, &xcsr); fsl_sai_isr()
75 regmap_write(sai->regmap, FSL_SAI_TCSR, flags | xcsr); fsl_sai_isr()
79 regmap_read(sai->regmap, FSL_SAI_RCSR, &xcsr); fsl_sai_isr()
109 regmap_write(sai->regmap, FSL_SAI_RCSR, flags | xcsr); fsl_sai_isr()
142 regmap_update_bits(sai->regmap, FSL_SAI_xCR2(tx), fsl_sai_set_dai_sysclk_tr()
265 regmap_update_bits(sai->regmap, FSL_SAI_xCR2(tx), fsl_sai_set_dai_fmt_tr()
267 regmap_update_bits(sai->regmap, FSL_SAI_xCR4(tx), fsl_sai_set_dai_fmt_tr()
314 regmap_update_bits(sai->regmap, FSL_SAI_xCR4(tx), fsl_sai_hw_params()
317 regmap_update_bits(sai->regmap, FSL_SAI_xCR5(tx), fsl_sai_hw_params()
320 regmap_write(sai->regmap, FSL_SAI_xMR(tx), ~0UL - ((1 << channels) - 1)); fsl_sai_hw_params()
337 regmap_update_bits(sai->regmap, FSL_SAI_TCR2, FSL_SAI_CR2_SYNC, 0); fsl_sai_trigger()
338 regmap_update_bits(sai->regmap, FSL_SAI_RCR2, FSL_SAI_CR2_SYNC, fsl_sai_trigger()
349 regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx), fsl_sai_trigger()
352 regmap_update_bits(sai->regmap, FSL_SAI_RCSR, fsl_sai_trigger()
354 regmap_update_bits(sai->regmap, FSL_SAI_TCSR, fsl_sai_trigger()
357 regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx), fsl_sai_trigger()
363 regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx), fsl_sai_trigger()
365 regmap_update_bits(sai->regmap, FSL_SAI_xCSR(tx), fsl_sai_trigger()
369 regmap_read(sai->regmap, FSL_SAI_xCSR(!tx), &xcsr); fsl_sai_trigger()
372 regmap_update_bits(sai->regmap, FSL_SAI_TCSR, fsl_sai_trigger()
374 regmap_update_bits(sai->regmap, FSL_SAI_RCSR, fsl_sai_trigger()
380 regmap_read(sai->regmap, FSL_SAI_xCSR(tx), &xcsr); fsl_sai_trigger()
383 regmap_update_bits(sai->regmap, FSL_SAI_TCSR, fsl_sai_trigger()
385 regmap_update_bits(sai->regmap, FSL_SAI_RCSR, fsl_sai_trigger()
410 regmap_update_bits(sai->regmap, FSL_SAI_xCR3(tx), FSL_SAI_CR3_TRCE, fsl_sai_startup()
422 regmap_update_bits(sai->regmap, FSL_SAI_xCR3(tx), FSL_SAI_CR3_TRCE, 0); fsl_sai_shutdown()
441 regmap_write(sai->regmap, FSL_SAI_TCSR, FSL_SAI_CSR_SR); fsl_sai_dai_probe()
442 regmap_write(sai->regmap, FSL_SAI_RCSR, FSL_SAI_CSR_SR); fsl_sai_dai_probe()
444 regmap_write(sai->regmap, FSL_SAI_TCSR, 0); fsl_sai_dai_probe()
445 regmap_write(sai->regmap, FSL_SAI_RCSR, 0); fsl_sai_dai_probe()
447 regmap_update_bits(sai->regmap, FSL_SAI_TCR1, FSL_SAI_CR1_RFW_MASK, fsl_sai_dai_probe()
449 regmap_update_bits(sai->regmap, FSL_SAI_RCR1, FSL_SAI_CR1_RFW_MASK, fsl_sai_dai_probe()
583 sai->regmap = devm_regmap_init_mmio_clk(&pdev->dev, fsl_sai_probe()
587 if (IS_ERR(sai->regmap)) fsl_sai_probe()
588 sai->regmap = devm_regmap_init_mmio_clk(&pdev->dev, fsl_sai_probe()
590 if (IS_ERR(sai->regmap)) { fsl_sai_probe()
591 dev_err(&pdev->dev, "regmap init failed\n"); fsl_sai_probe()
592 return PTR_ERR(sai->regmap); fsl_sai_probe()
H A Dfsl_esai.c34 * @regmap: regmap handler
53 struct regmap *regmap; member in struct:fsl_esai
75 regmap_read(esai_priv->regmap, REG_ESAI_ESR, &esr); esai_isr()
184 regmap_update_bits(esai_priv->regmap, REG_ESAI_xCCR(tx), fsl_esai_divisor_cal()
193 regmap_update_bits(esai_priv->regmap, REG_ESAI_xCCR(tx), fsl_esai_divisor_cal()
229 regmap_update_bits(esai_priv->regmap, REG_ESAI_xCCR(tx), fsl_esai_set_dai_sysclk()
293 regmap_update_bits(esai_priv->regmap, REG_ESAI_ECR, fsl_esai_set_dai_sysclk()
350 regmap_update_bits(esai_priv->regmap, REG_ESAI_TCCR, fsl_esai_set_dai_tdm_slot()
353 regmap_update_bits(esai_priv->regmap, REG_ESAI_TSMA, fsl_esai_set_dai_tdm_slot()
355 regmap_update_bits(esai_priv->regmap, REG_ESAI_TSMB, fsl_esai_set_dai_tdm_slot()
358 regmap_update_bits(esai_priv->regmap, REG_ESAI_RCCR, fsl_esai_set_dai_tdm_slot()
361 regmap_update_bits(esai_priv->regmap, REG_ESAI_RSMA, fsl_esai_set_dai_tdm_slot()
363 regmap_update_bits(esai_priv->regmap, REG_ESAI_RSMB, fsl_esai_set_dai_tdm_slot()
448 regmap_update_bits(esai_priv->regmap, REG_ESAI_TCR, mask, xcr); fsl_esai_set_dai_fmt()
449 regmap_update_bits(esai_priv->regmap, REG_ESAI_RCR, mask, xcr); fsl_esai_set_dai_fmt()
453 regmap_update_bits(esai_priv->regmap, REG_ESAI_TCCR, mask, xccr); fsl_esai_set_dai_fmt()
454 regmap_update_bits(esai_priv->regmap, REG_ESAI_RCCR, mask, xccr); fsl_esai_set_dai_fmt()
485 regmap_update_bits(esai_priv->regmap, REG_ESAI_SAICR, fsl_esai_startup()
490 regmap_update_bits(esai_priv->regmap, REG_ESAI_TCCR, fsl_esai_startup()
492 regmap_update_bits(esai_priv->regmap, REG_ESAI_RCCR, fsl_esai_startup()
531 regmap_update_bits(esai_priv->regmap, REG_ESAI_xCR(tx), fsl_esai_hw_params()
535 regmap_update_bits(esai_priv->regmap, REG_ESAI_xFCR(tx), fsl_esai_hw_params()
543 regmap_update_bits(esai_priv->regmap, REG_ESAI_xFCR(tx), mask, val); fsl_esai_hw_params()
548 regmap_update_bits(esai_priv->regmap, REG_ESAI_xCR(tx), mask, val); fsl_esai_hw_params()
551 regmap_update_bits(esai_priv->regmap, REG_ESAI_PRRC, fsl_esai_hw_params()
553 regmap_update_bits(esai_priv->regmap, REG_ESAI_PCRC, fsl_esai_hw_params()
582 regmap_update_bits(esai_priv->regmap, REG_ESAI_xFCR(tx), fsl_esai_trigger()
587 regmap_write(esai_priv->regmap, REG_ESAI_ETDR, 0x0); fsl_esai_trigger()
589 regmap_update_bits(esai_priv->regmap, REG_ESAI_xCR(tx), fsl_esai_trigger()
596 regmap_update_bits(esai_priv->regmap, REG_ESAI_xCR(tx), fsl_esai_trigger()
600 regmap_update_bits(esai_priv->regmap, REG_ESAI_xFCR(tx), fsl_esai_trigger()
602 regmap_update_bits(esai_priv->regmap, REG_ESAI_xFCR(tx), fsl_esai_trigger()
750 esai_priv->regmap = devm_regmap_init_mmio_clk(&pdev->dev, fsl_esai_probe()
752 if (IS_ERR(esai_priv->regmap)) { fsl_esai_probe()
753 dev_err(&pdev->dev, "failed to init regmap: %ld\n", fsl_esai_probe()
754 PTR_ERR(esai_priv->regmap)); fsl_esai_probe()
755 return PTR_ERR(esai_priv->regmap); fsl_esai_probe()
819 ret = regmap_write(esai_priv->regmap, REG_ESAI_ECR, ESAI_ECR_ERST); fsl_esai_probe()
827 * Otherwise, we would fail to dump regmap from user space. fsl_esai_probe()
829 ret = regmap_write(esai_priv->regmap, REG_ESAI_ECR, ESAI_ECR_ESAIEN); fsl_esai_probe()
/linux-4.1.27/drivers/iio/dac/
H A Dad5380.c18 #include <linux/regmap.h>
50 * @regmap: regmap instance used by the device
58 struct regmap *regmap; member in struct:ad5380_state
105 ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_DOWN, 0); ad5380_write_dac_powerdown()
107 ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_UP, 0); ad5380_write_dac_powerdown()
128 ret = regmap_read(st->regmap, AD5380_REG_SF_CTRL, &mode); ad5380_get_powerdown_mode()
143 ret = regmap_update_bits(st->regmap, AD5380_REG_SF_CTRL, ad5380_set_powerdown_mode()
186 return regmap_write(st->regmap, ad5380_write_raw()
194 return regmap_write(st->regmap, ad5380_write_raw()
212 ret = regmap_read(st->regmap, ad5380_info_to_reg(chan, info), ad5380_read_raw()
219 ret = regmap_read(st->regmap, AD5380_REG_OFFSET(chan->address), ad5380_read_raw()
369 static int ad5380_probe(struct device *dev, struct regmap *regmap, ad5380_probe() argument
387 st->regmap = regmap; ad5380_probe()
423 ret = regmap_write(st->regmap, AD5380_REG_SF_CTRL, ctrl); ad5380_probe()
483 struct regmap *regmap; ad5380_spi_probe() local
485 regmap = devm_regmap_init_spi(spi, &ad5380_regmap_config); ad5380_spi_probe()
487 if (IS_ERR(regmap)) ad5380_spi_probe()
488 return PTR_ERR(regmap); ad5380_spi_probe()
490 return ad5380_probe(&spi->dev, regmap, id->driver_data, id->name); ad5380_spi_probe()
557 struct regmap *regmap; ad5380_i2c_probe() local
559 regmap = devm_regmap_init_i2c(i2c, &ad5380_regmap_config); ad5380_i2c_probe()
561 if (IS_ERR(regmap)) ad5380_i2c_probe()
562 return PTR_ERR(regmap); ad5380_i2c_probe()
564 return ad5380_probe(&i2c->dev, regmap, id->driver_data, id->name); ad5380_i2c_probe()
/linux-4.1.27/drivers/video/backlight/
H A Dlm3639_bl.c19 #include <linux/regmap.h>
43 struct regmap *regmap; member in struct:lm3639_chip_data
59 regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x08, lm3639_chip_init()
65 ret = regmap_update_bits(pchip->regmap, REG_IO_CTRL, 0x7C, reg_val); lm3639_chip_init()
70 ret = regmap_write(pchip->regmap, REG_BL_CONF_4, pdata->init_brt_led); lm3639_chip_init()
74 ret = regmap_write(pchip->regmap, REG_BL_CONF_3, pdata->init_brt_led); lm3639_chip_init()
87 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x79, reg_val); lm3639_chip_init()
105 ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val); lm3639_bled_update_status()
124 ret = regmap_write(pchip->regmap, REG_BL_CONF_4, bl->props.brightness); lm3639_bled_update_status()
127 ret = regmap_write(pchip->regmap, REG_BL_CONF_3, bl->props.brightness); lm3639_bled_update_status()
132 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x00); lm3639_bled_update_status()
134 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x01); lm3639_bled_update_status()
160 ret = regmap_read(pchip->regmap, REG_BL_CONF_1, &reg_val); lm3639_bled_get_brightness()
164 ret = regmap_read(pchip->regmap, REG_BL_CONF_4, &reg_val); lm3639_bled_get_brightness()
166 ret = regmap_read(pchip->regmap, REG_BL_CONF_3, &reg_val); lm3639_bled_get_brightness()
198 regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10, lm3639_bled_mode_store()
202 regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10, lm3639_bled_mode_store()
232 ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val); lm3639_torch_brightness_set()
240 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00); lm3639_torch_brightness_set()
246 ret = regmap_update_bits(pchip->regmap, lm3639_torch_brightness_set()
250 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x02); lm3639_torch_brightness_set()
269 ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val); lm3639_flash_brightness_set()
276 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00); lm3639_flash_brightness_set()
284 ret = regmap_update_bits(pchip->regmap, lm3639_flash_brightness_set()
288 ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x06); lm3639_flash_brightness_set()
329 pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap); lm3639_probe()
330 if (IS_ERR(pchip->regmap)) { lm3639_probe()
331 ret = PTR_ERR(pchip->regmap); lm3639_probe()
401 regmap_write(pchip->regmap, REG_ENABLE, 0x00); lm3639_remove()
H A Dsky81452-backlight.c29 #include <linux/regmap.h>
63 struct regmap *regmap = bl_get_data(bd); sky81452_bl_update_status() local
67 ret = regmap_write(regmap, SKY81452_REG0, brightness - 1); sky81452_bl_update_status()
71 return regmap_update_bits(regmap, SKY81452_REG1, SKY81452_EN, sky81452_bl_update_status()
75 return regmap_update_bits(regmap, SKY81452_REG1, SKY81452_EN, 0); sky81452_bl_update_status()
85 struct regmap *regmap = bl_get_data(to_backlight_device(dev)); sky81452_bl_store_enable() local
93 ret = regmap_update_bits(regmap, SKY81452_REG1, SKY81452_EN, sky81452_bl_store_enable()
104 struct regmap *regmap = bl_get_data(to_backlight_device(dev)); sky81452_bl_show_open_short() local
110 ret = regmap_read(regmap, reg, &value); sky81452_bl_show_open_short()
134 struct regmap *regmap = bl_get_data(to_backlight_device(dev)); sky81452_bl_show_fault() local
138 ret = regmap_read(regmap, SKY81452_REG4, &value); sky81452_bl_show_fault()
240 static int sky81452_bl_init_device(struct regmap *regmap, sky81452_bl_init_device() argument
259 return regmap_write(regmap, SKY81452_REG2, value); sky81452_bl_init_device()
265 struct regmap *regmap = dev_get_drvdata(dev->parent); sky81452_bl_probe() local
287 ret = sky81452_bl_init_device(regmap, pdata); sky81452_bl_probe()
296 bd = devm_backlight_device_register(dev, name, dev, regmap, sky81452_bl_probe()
H A Das3711_bl.c21 #include <linux/regmap.h>
66 ret = regmap_write(as3711->regmap, AS3711_CURR1_VALUE, as3711_set_brightness_auto_i()
69 ret = regmap_write(as3711->regmap, AS3711_CURR2_VALUE, as3711_set_brightness_auto_i()
72 ret = regmap_write(as3711->regmap, AS3711_CURR3_VALUE, as3711_set_brightness_auto_i()
85 return regmap_update_bits(as3711->regmap, reg, 0xf0, as3711_set_brightness_v()
92 int ret = regmap_update_bits(as3711->regmap, AS3711_STEPUP_CONTROL_5, as3711_bl_su2_reset()
95 ret = regmap_update_bits(as3711->regmap, as3711_bl_su2_reset()
98 ret = regmap_update_bits(as3711->regmap, as3711_bl_su2_reset()
146 ret = regmap_update_bits(as3711->regmap, as3711_bl_update_status()
152 ret = regmap_write(as3711->regmap, AS3711_CURR1_VALUE, as3711_bl_update_status()
156 ret = regmap_write(as3711->regmap, AS3711_CURR2_VALUE, as3711_bl_update_status()
160 ret = regmap_write(as3711->regmap, AS3711_CURR3_VALUE, as3711_bl_update_status()
195 ret = regmap_write(as3711->regmap, AS3711_STEPUP_CONTROL_2, 0); as3711_bl_init_su2()
201 ret = regmap_update_bits(as3711->regmap, AS3711_STEPUP_CONTROL_4, 3, 0); as3711_bl_init_su2()
205 ret = regmap_update_bits(as3711->regmap, AS3711_STEPUP_CONTROL_4, 3, 1); as3711_bl_init_su2()
209 ret = regmap_update_bits(as3711->regmap, AS3711_STEPUP_CONTROL_4, 3, 2); as3711_bl_init_su2()
213 ret = regmap_update_bits(as3711->regmap, AS3711_STEPUP_CONTROL_4, 3, 3); as3711_bl_init_su2()
229 ret = regmap_write(as3711->regmap, AS3711_CURR_CONTROL, ctl); as3711_bl_init_su2()
/linux-4.1.27/drivers/leds/
H A Dleds-pm8941-wled.c18 #include <linux/regmap.h>
79 struct regmap *regmap; member in struct:pm8941_wled
103 rc = regmap_update_bits(wled->regmap, pm8941_wled_set()
112 rc = regmap_bulk_write(wled->regmap, pm8941_wled_set()
119 rc = regmap_update_bits(wled->regmap, pm8941_wled_set()
125 rc = regmap_update_bits(wled->regmap, pm8941_wled_set()
146 rc = regmap_update_bits(wled->regmap, pm8941_wled_setup()
152 rc = regmap_update_bits(wled->regmap, pm8941_wled_setup()
158 rc = regmap_update_bits(wled->regmap, pm8941_wled_setup()
168 rc = regmap_update_bits(wled->regmap, pm8941_wled_setup()
178 rc = regmap_update_bits(wled->regmap, pm8941_wled_setup()
186 rc = regmap_update_bits(wled->regmap, pm8941_wled_setup()
194 rc = regmap_update_bits(wled->regmap, pm8941_wled_setup()
201 rc = regmap_update_bits(wled->regmap, pm8941_wled_setup()
383 struct regmap *regmap; pm8941_wled_probe() local
386 regmap = dev_get_regmap(pdev->dev.parent, NULL); pm8941_wled_probe()
387 if (!regmap) { pm8941_wled_probe()
388 dev_err(&pdev->dev, "Unable to get regmap\n"); pm8941_wled_probe()
396 wled->regmap = regmap; pm8941_wled_probe()
H A Dleds-lm355x.c18 #include <linux/regmap.h>
71 struct regmap *regmap; member in struct:lm355x_chip_data
181 ret = regmap_update_bits(chip->regmap, 0xE0, 0x28, reg_val); lm355x_chip_init()
185 ret = regmap_update_bits(chip->regmap, 0xA0, 0x04, reg_val); lm355x_chip_init()
192 ret = regmap_update_bits(chip->regmap, 0x0A, 0xC4, reg_val); lm355x_chip_init()
215 ret = regmap_read(chip->regmap, preg[REG_FLAG].regno, &chip->last_flag); lm355x_control()
229 regmap_update_bits(chip->regmap, preg[REG_TORCH_CTRL].regno, lm355x_control()
238 regmap_update_bits(chip->regmap, lm355x_control()
254 regmap_update_bits(chip->regmap, preg[REG_FLASH_CTRL].regno, lm355x_control()
267 regmap_update_bits(chip->regmap, lm355x_control()
282 regmap_update_bits(chip->regmap, preg[REG_INDI_CTRL].regno, lm355x_control()
291 regmap_update_bits(chip->regmap, lm355x_control()
307 ret = regmap_update_bits(chip->regmap, preg[REG_OPMODE].regno, lm355x_control()
398 ret = regmap_write(chip->regmap, 0x04, lm3556_indicator_pattern_store()
403 ret = regmap_write(chip->regmap, 0x05, lm3556_indicator_pattern_store()
466 chip->regmap = devm_regmap_init_i2c(client, &lm355x_regmap); lm355x_probe()
467 if (IS_ERR(chip->regmap)) { lm355x_probe()
468 err = PTR_ERR(chip->regmap); lm355x_probe()
535 regmap_write(chip->regmap, preg[REG_OPMODE].regno, 0); lm355x_remove()
H A Dleds-lp8860.c17 #include <linux/regmap.h>
97 * @regmap - Devices register map
109 struct regmap *regmap; member in struct:lp8860_led
110 struct regmap *eeprom_regmap;
157 ret = regmap_write(led->regmap, lp8860_unlock_eeprom()
165 ret = regmap_write(led->regmap, lp8860_unlock_eeprom()
172 ret = regmap_write(led->regmap, lp8860_unlock_eeprom()
180 ret = regmap_write(led->regmap, lp8860_unlock_eeprom()
195 ret = regmap_read(led->regmap, LP8860_LED_FAULT, &read_buf); lp8860_fault_check()
201 ret = regmap_read(led->regmap, LP8860_FAULT, &read_buf); lp8860_fault_check()
209 ret = regmap_write(led->regmap, LP8860_FAULT_CLEAR, lp8860_fault_check()
229 ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_MSB, lp8860_led_brightness_work()
236 ret = regmap_write(led->regmap, LP8860_DISP_CL1_BRT_LSB, lp8860_led_brightness_work()
268 ret = regmap_read(led->regmap, LP8860_STATUS, &read_buf); lp8860_init()
293 ret = regmap_write(led->regmap, lp8860_init()
416 led->regmap = devm_regmap_init_i2c(client, &lp8860_regmap_config); lp8860_probe()
417 if (IS_ERR(led->regmap)) { lp8860_probe()
418 ret = PTR_ERR(led->regmap); lp8860_probe()
H A Dleds-lm3642.c17 #include <linux/regmap.h>
89 struct regmap *regmap; member in struct:lm3642_chip_data
102 ret = regmap_update_bits(chip->regmap, REG_ENABLE, EX_PIN_ENABLE_MASK, lm3642_chip_init()
115 ret = regmap_read(chip->regmap, REG_FLAG, &chip->last_flag); lm3642_control()
130 ret = regmap_update_bits(chip->regmap, REG_I_CTRL, lm3642_control()
139 ret = regmap_update_bits(chip->regmap, REG_I_CTRL, lm3642_control()
148 ret = regmap_update_bits(chip->regmap, REG_I_CTRL, lm3642_control()
168 ret = regmap_update_bits(chip->regmap, REG_ENABLE, lm3642_control()
195 ret = regmap_update_bits(chip->regmap, REG_ENABLE, lm3642_torch_pin_store()
252 ret = regmap_update_bits(chip->regmap, REG_ENABLE, lm3642_strobe_pin_store()
358 chip->regmap = devm_regmap_init_i2c(client, &lm3642_regmap); lm3642_probe()
359 if (IS_ERR(chip->regmap)) { lm3642_probe()
360 err = PTR_ERR(chip->regmap); lm3642_probe()
435 regmap_write(chip->regmap, REG_ENABLE, 0); lm3642_remove()
/linux-4.1.27/drivers/pwm/
H A Dpwm-pca9685.c25 #include <linux/regmap.h>
60 struct regmap *regmap; member in struct:pca9685
82 regmap_write(pca->regmap, reg, LED_FULL); pca9685_pwm_config()
93 regmap_write(pca->regmap, reg, LED_FULL); pca9685_pwm_config()
106 regmap_write(pca->regmap, reg, (int)duty & 0xff); pca9685_pwm_config()
113 regmap_write(pca->regmap, reg, ((int)duty >> 8) & 0xf); pca9685_pwm_config()
132 regmap_write(pca->regmap, reg, 0); pca9685_pwm_enable()
139 regmap_write(pca->regmap, reg, 0); pca9685_pwm_enable()
150 regmap_update_bits(pca->regmap, reg, LED_FULL, 0x0); pca9685_pwm_enable()
165 regmap_write(pca->regmap, reg, LED_FULL); pca9685_pwm_disable()
173 regmap_write(pca->regmap, reg, 0x0); pca9685_pwm_disable()
181 return regmap_update_bits(pca->regmap, PCA9685_MODE1, pca9685_pwm_request()
192 regmap_update_bits(pca->regmap, PCA9685_MODE1, MODE1_SLEEP, pca9685_pwm_free()
224 pca->regmap = devm_regmap_init_i2c(client, &pca9685_regmap_i2c_config); pca9685_pwm_probe()
225 if (IS_ERR(pca->regmap)) { pca9685_pwm_probe()
226 ret = PTR_ERR(pca->regmap); pca9685_pwm_probe()
234 regmap_read(pca->regmap, PCA9685_MODE2, &mode2); pca9685_pwm_probe()
246 regmap_write(pca->regmap, PCA9685_MODE2, mode2); pca9685_pwm_probe()
249 regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_L, 0); pca9685_pwm_probe()
250 regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_H, 0); pca9685_pwm_probe()
267 regmap_update_bits(pca->regmap, PCA9685_MODE1, MODE1_SLEEP, pca9685_pwm_remove()
H A Dpwm-fsl-ftm.c22 #include <linux/regmap.h>
87 struct regmap *regmap; member in struct:fsl_pwm_chip
226 regmap_read(fpc->regmap, FTM_MOD, &val); fsl_pwm_calculate_duty()
262 regmap_update_bits(fpc->regmap, FTM_SC, FTM_SC_PS_MASK, fsl_pwm_config()
264 regmap_write(fpc->regmap, FTM_MOD, period - 1); fsl_pwm_config()
273 regmap_write(fpc->regmap, FTM_CSC(pwm->hwpwm), fsl_pwm_config()
275 regmap_write(fpc->regmap, FTM_CV(pwm->hwpwm), duty); fsl_pwm_config()
287 regmap_read(fpc->regmap, FTM_POL, &val); fsl_pwm_set_polarity()
294 regmap_write(fpc->regmap, FTM_POL, val); fsl_pwm_set_polarity()
307 regmap_update_bits(fpc->regmap, FTM_SC, FTM_SC_CLK_MASK, fsl_counter_clock_enable()
329 regmap_update_bits(fpc->regmap, FTM_OUTMASK, BIT(pwm->hwpwm), 0); fsl_pwm_enable()
350 regmap_update_bits(fpc->regmap, FTM_SC, FTM_SC_CLK_MASK, 0); fsl_counter_clock_disable()
362 regmap_update_bits(fpc->regmap, FTM_OUTMASK, BIT(pwm->hwpwm), fsl_pwm_disable()
367 regmap_read(fpc->regmap, FTM_OUTMASK, &val); fsl_pwm_disable()
392 regmap_write(fpc->regmap, FTM_CNTIN, 0x00); fsl_pwm_init()
393 regmap_write(fpc->regmap, FTM_OUTINIT, 0x00); fsl_pwm_init()
394 regmap_write(fpc->regmap, FTM_OUTMASK, 0xFF); fsl_pwm_init()
440 fpc->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "ftm_sys", base, fsl_pwm_probe()
442 if (IS_ERR(fpc->regmap)) { fsl_pwm_probe()
443 dev_err(&pdev->dev, "regmap init failed\n"); fsl_pwm_probe()
444 return PTR_ERR(fpc->regmap); fsl_pwm_probe()
497 regcache_cache_only(fpc->regmap, true); fsl_pwm_suspend()
498 regcache_mark_dirty(fpc->regmap); fsl_pwm_suspend()
501 regmap_read(fpc->regmap, FTM_OUTMASK, &val); fsl_pwm_suspend()
517 regmap_read(fpc->regmap, FTM_OUTMASK, &val); fsl_pwm_resume()
525 regcache_cache_only(fpc->regmap, false); fsl_pwm_resume()
526 regcache_sync(fpc->regmap); fsl_pwm_resume()
/linux-4.1.27/drivers/media/i2c/
H A Dlm3646.c19 #include <linux/regmap.h>
62 * @regmap: reg. map for i2c
72 struct regmap *regmap; member in struct:lm3646_flash
89 return regmap_write(flash->regmap, lm3646_mode_ctrl()
92 return regmap_write(flash->regmap, lm3646_mode_ctrl()
95 return regmap_write(flash->regmap, lm3646_mode_ctrl()
111 rval = regmap_read(flash->regmap, REG_FLAG, &reg_val); lm3646_get_ctrl()
151 return regmap_update_bits(flash->regmap, lm3646_set_ctrl()
158 rval = regmap_read(flash->regmap, REG_ENABLE, &reg_val); lm3646_set_ctrl()
171 rval = regmap_read(flash->regmap, REG_ENABLE, &reg_val); lm3646_set_ctrl()
180 return regmap_update_bits(flash->regmap, lm3646_set_ctrl()
186 return regmap_update_bits(flash->regmap, lm3646_set_ctrl()
192 return regmap_update_bits(flash->regmap, lm3646_set_ctrl()
302 rval = regmap_read(flash->regmap, REG_ENABLE, &reg_val); lm3646_init_device()
316 rval = regmap_update_bits(flash->regmap, lm3646_init_device()
328 rval = regmap_update_bits(flash->regmap, lm3646_init_device()
336 return regmap_read(flash->regmap, REG_FLAG, &reg_val); lm3646_init_device()
350 flash->regmap = devm_regmap_init_i2c(client, &lm3646_regmap); lm3646_probe()
351 if (IS_ERR(flash->regmap)) lm3646_probe()
352 return PTR_ERR(flash->regmap); lm3646_probe()
H A Dlm3560.c25 #include <linux/regmap.h>
54 * @regmap: reg. map for i2c
63 struct regmap *regmap; member in struct:lm3560_flash
81 rval = regmap_update_bits(flash->regmap, lm3560_mode_ctrl()
85 rval = regmap_update_bits(flash->regmap, lm3560_mode_ctrl()
89 rval = regmap_update_bits(flash->regmap, lm3560_mode_ctrl()
104 rval = regmap_update_bits(flash->regmap, lm3560_enable_ctrl()
107 rval = regmap_update_bits(flash->regmap, lm3560_enable_ctrl()
111 rval = regmap_update_bits(flash->regmap, lm3560_enable_ctrl()
114 rval = regmap_update_bits(flash->regmap, lm3560_enable_ctrl()
134 rval = regmap_update_bits(flash->regmap, lm3560_torch_brt_ctrl()
137 rval = regmap_update_bits(flash->regmap, lm3560_torch_brt_ctrl()
157 rval = regmap_update_bits(flash->regmap, lm3560_flash_brt_ctrl()
160 rval = regmap_update_bits(flash->regmap, lm3560_flash_brt_ctrl()
177 rval = regmap_read(flash->regmap, REG_FLAG, &reg_val); lm3560_get_ctrl()
210 rval = regmap_update_bits(flash->regmap, lm3560_set_ctrl()
236 rval = regmap_update_bits(flash->regmap, lm3560_set_ctrl()
386 rval = regmap_update_bits(flash->regmap, lm3560_init_device()
396 rval = regmap_read(flash->regmap, REG_FLAG, &reg_val); lm3560_init_device()
411 flash->regmap = devm_regmap_init_i2c(client, &lm3560_regmap); lm3560_probe()
412 if (IS_ERR(flash->regmap)) { lm3560_probe()
413 rval = PTR_ERR(flash->regmap); lm3560_probe()
/linux-4.1.27/sound/soc/rockchip/
H A Drockchip_i2s.c18 #include <linux/regmap.h>
35 struct regmap *regmap; member in struct:rk_i2s_dev
80 regmap_update_bits(i2s->regmap, I2S_DMACR, rockchip_snd_txctrl()
83 regmap_update_bits(i2s->regmap, I2S_XFER, rockchip_snd_txctrl()
91 regmap_update_bits(i2s->regmap, I2S_DMACR, rockchip_snd_txctrl()
95 regmap_update_bits(i2s->regmap, I2S_XFER, rockchip_snd_txctrl()
101 regmap_update_bits(i2s->regmap, I2S_CLR, rockchip_snd_txctrl()
105 regmap_read(i2s->regmap, I2S_CLR, &val); rockchip_snd_txctrl()
109 regmap_read(i2s->regmap, I2S_CLR, &val); rockchip_snd_txctrl()
126 regmap_update_bits(i2s->regmap, I2S_DMACR, rockchip_snd_rxctrl()
129 regmap_update_bits(i2s->regmap, I2S_XFER, rockchip_snd_rxctrl()
137 regmap_update_bits(i2s->regmap, I2S_DMACR, rockchip_snd_rxctrl()
141 regmap_update_bits(i2s->regmap, I2S_XFER, rockchip_snd_rxctrl()
147 regmap_update_bits(i2s->regmap, I2S_CLR, rockchip_snd_rxctrl()
151 regmap_read(i2s->regmap, I2S_CLR, &val); rockchip_snd_rxctrl()
155 regmap_read(i2s->regmap, I2S_CLR, &val); rockchip_snd_rxctrl()
185 regmap_update_bits(i2s->regmap, I2S_CKR, mask, val); rockchip_i2s_set_fmt()
202 regmap_update_bits(i2s->regmap, I2S_TXCR, mask, val); rockchip_i2s_set_fmt()
219 regmap_update_bits(i2s->regmap, I2S_RXCR, mask, val); rockchip_i2s_set_fmt()
248 regmap_update_bits(i2s->regmap, I2S_TXCR, I2S_TXCR_VDW_MASK, val); rockchip_i2s_hw_params()
249 regmap_update_bits(i2s->regmap, I2S_RXCR, I2S_RXCR_VDW_MASK, val); rockchip_i2s_hw_params()
250 regmap_update_bits(i2s->regmap, I2S_DMACR, I2S_DMACR_TDL_MASK, rockchip_i2s_hw_params()
252 regmap_update_bits(i2s->regmap, I2S_DMACR, I2S_DMACR_RDL_MASK, rockchip_i2s_hw_params()
452 i2s->regmap = devm_regmap_init_mmio(&pdev->dev, regs, rockchip_i2s_probe()
454 if (IS_ERR(i2s->regmap)) { rockchip_i2s_probe()
457 return PTR_ERR(i2s->regmap); rockchip_i2s_probe()
/linux-4.1.27/drivers/power/
H A Dmax77693_charger.c21 #include <linux/regmap.h>
41 static int max77693_get_charger_state(struct regmap *regmap, int *val) max77693_get_charger_state() argument
46 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data); max77693_get_charger_state()
82 static int max77693_get_charge_type(struct regmap *regmap, int *val) max77693_get_charge_type() argument
87 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data); max77693_get_charge_type()
134 static int max77693_get_battery_health(struct regmap *regmap, int *val) max77693_get_battery_health() argument
139 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data); max77693_get_battery_health()
177 static int max77693_get_present(struct regmap *regmap, int *val) max77693_get_present() argument
186 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data); max77693_get_present()
195 static int max77693_get_online(struct regmap *regmap, int *val) max77693_get_online() argument
200 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data); max77693_get_online()
224 struct regmap *regmap = chg->max77693->regmap; max77693_charger_get_property() local
229 ret = max77693_get_charger_state(regmap, &val->intval); max77693_charger_get_property()
232 ret = max77693_get_charge_type(regmap, &val->intval); max77693_charger_get_property()
235 ret = max77693_get_battery_health(regmap, &val->intval); max77693_charger_get_property()
238 ret = max77693_get_present(regmap, &val->intval); max77693_charger_get_property()
241 ret = max77693_get_online(regmap, &val->intval); max77693_charger_get_property()
290 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_01, fast_charge_timer_show()
337 return regmap_update_bits(chg->max77693->regmap, max77693_set_fast_charge_timer()
356 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03, top_off_threshold_current_show()
388 return regmap_update_bits(chg->max77693->regmap, max77693_set_top_off_threshold_current()
407 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03, top_off_timer_show()
431 return regmap_update_bits(chg->max77693->regmap, max77693_set_top_off_timer()
478 return regmap_update_bits(chg->max77693->regmap, max77693_set_constant_volt()
500 return regmap_update_bits(chg->max77693->regmap, max77693_set_min_system_volt()
527 return regmap_update_bits(chg->max77693->regmap, max77693_set_thermal_regulation_temp()
551 return regmap_update_bits(chg->max77693->regmap, max77693_set_batttery_overcurrent()
579 return regmap_update_bits(chg->max77693->regmap, max77693_set_charge_input_threshold_volt()
594 ret = regmap_update_bits(chg->max77693->regmap, max77693_reg_init()
H A Dmax17042_battery.c36 #include <linux/regmap.h>
68 struct regmap *regmap; member in struct:max17042_chip
97 struct regmap *map = chip->regmap; max17042_get_property()
240 static int max17042_write_verify_reg(struct regmap *map, u8 reg, u32 value) max17042_write_verify_reg()
261 static inline void max17042_override_por(struct regmap *map, max17042_override_por()
270 struct regmap *map = chip->regmap; max10742_unlock_model()
278 struct regmap *map = chip->regmap; max10742_lock_model()
287 struct regmap *map = chip->regmap; max17042_write_model_data()
298 struct regmap *map = chip->regmap; max17042_read_model_data()
373 struct regmap *map = chip->regmap; max17042_write_config_regs()
389 struct regmap *map = chip->regmap; max17042_write_custom_regs()
413 struct regmap *map = chip->regmap; max17042_update_capacity_regs()
425 struct regmap *map = chip->regmap; max17042_reset_vfsoc0_reg()
439 struct regmap *map = chip->regmap; max17042_load_new_capacity_params()
476 struct regmap *map = chip->regmap; max17042_override_por_values()
529 struct regmap *map = chip->regmap; max17042_init_chip()
579 struct regmap *map = chip->regmap; max17042_set_soc_threshold()
597 regmap_read(chip->regmap, MAX17042_STATUS, &val); max17042_thread_handler()
699 chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config); max17042_probe()
700 if (IS_ERR(chip->regmap)) { max17042_probe()
701 dev_err(&client->dev, "Failed to initialize regmap\n"); max17042_probe()
725 regmap_write(chip->regmap, max17042_probe()
730 regmap_write(chip->regmap, MAX17042_CGAIN, 0x0000); max17042_probe()
731 regmap_write(chip->regmap, MAX17042_MiscCFG, 0x0003); max17042_probe()
732 regmap_write(chip->regmap, MAX17042_LearnCFG, 0x0007); max17042_probe()
748 regmap_update_bits(chip->regmap, MAX17042_CONFIG, max17042_probe()
759 regmap_read(chip->regmap, MAX17042_STATUS, &val); max17042_probe()
H A Drt5033_battery.c23 regmap_read(battery->regmap, RT5033_FUEL_REG_SOC_H, &msb); rt5033_battery_get_capacity()
33 regmap_read(battery->regmap, RT5033_FUEL_REG_CONFIG_L, &val); rt5033_battery_get_present()
63 regmap_read(battery->regmap, regh, &msb); rt5033_battery_get_watt_prop()
64 regmap_read(battery->regmap, regl, &lsb); rt5033_battery_get_watt_prop()
134 battery->regmap = devm_regmap_init_i2c(client, rt5033_battery_probe()
136 if (IS_ERR(battery->regmap)) { rt5033_battery_probe()
137 dev_err(&client->dev, "Failed to initialize regmap\n"); rt5033_battery_probe()
/linux-4.1.27/drivers/power/reset/
H A Dbrcmstb-reboot.c27 #include <linux/regmap.h>
34 static struct regmap *regmap; variable in typeref:struct:regmap
51 rc = regmap_write(regmap, rst_src_en, reset_masks->rst_src_en_mask); brcmstb_restart_handler()
57 rc = regmap_read(regmap, rst_src_en, &tmp); brcmstb_restart_handler()
63 rc = regmap_write(regmap, sw_mstr_rst, reset_masks->sw_mstr_rst_mask); brcmstb_restart_handler()
69 rc = regmap_read(regmap, sw_mstr_rst, &tmp); brcmstb_restart_handler()
115 regmap = syscon_regmap_lookup_by_phandle(np, "syscon"); brcmstb_reboot_probe()
116 if (IS_ERR(regmap)) { brcmstb_reboot_probe()
H A Dst-poweroff.c19 #include <linux/regmap.h>
22 struct regmap *regmap; member in struct:reset_syscfg
81 regmap_update_bits(st_restart_syscfg->regmap, st_restart()
87 regmap_update_bits(st_restart_syscfg->regmap, st_restart()
129 st_restart_syscfg->regmap = st_reset_probe()
131 if (IS_ERR(st_restart_syscfg->regmap)) { st_reset_probe()
133 return PTR_ERR(st_restart_syscfg->regmap); st_reset_probe()
H A Dvexpress-poweroff.c26 struct regmap *reg = dev_get_drvdata(dev); vexpress_reset_do()
116 struct regmap *regmap; vexpress_reset_probe() local
122 regmap = devm_regmap_init_vexpress_config(&pdev->dev); vexpress_reset_probe()
123 if (IS_ERR(regmap)) vexpress_reset_probe()
124 return PTR_ERR(regmap); vexpress_reset_probe()
125 dev_set_drvdata(&pdev->dev, regmap); vexpress_reset_probe()
/linux-4.1.27/drivers/input/misc/
H A Ddrv2667.c22 #include <linux/regmap.h>
103 * @regmap - Register map of the device
111 struct regmap *regmap; member in struct:drv2667_data
151 error = regmap_read(haptics->regmap, DRV2667_PAGE, &read_buf); drv2667_set_waveform_freq()
160 error = regmap_write(haptics->regmap, drv2667_set_waveform_freq()
169 error = regmap_write(haptics->regmap, DRV2667_RAM_FREQ, freq); drv2667_set_waveform_freq()
177 error = regmap_write(haptics->regmap, DRV2667_PAGE, read_buf); drv2667_set_waveform_freq()
194 error = regmap_write(haptics->regmap, drv2667_worker()
202 error = regmap_write(haptics->regmap, DRV2667_RAM_AMP, drv2667_worker()
210 error = regmap_write(haptics->regmap, drv2667_worker()
218 error = regmap_write(haptics->regmap, drv2667_worker()
225 error = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, drv2667_worker()
258 error = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, drv2667_close()
292 error = regmap_register_patch(haptics->regmap, drv2667_init()
302 error = regmap_write(haptics->regmap, DRV2667_PAGE, haptics->page); drv2667_init()
313 error = regmap_register_patch(haptics->regmap, drv2667_init()
323 error = regmap_write(haptics->regmap, DRV2667_PAGE, DRV2667_PAGE_0); drv2667_init()
327 regmap_write(haptics->regmap, DRV2667_PAGE, DRV2667_PAGE_0); drv2667_init()
385 haptics->regmap = devm_regmap_init_i2c(client, &drv2667_regmap_config); drv2667_probe()
386 if (IS_ERR(haptics->regmap)) { drv2667_probe()
387 error = PTR_ERR(haptics->regmap); drv2667_probe()
417 ret = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, drv2667_suspend()
428 regmap_update_bits(haptics->regmap, drv2667_suspend()
452 ret = regmap_update_bits(haptics->regmap, DRV2667_CTRL_2, drv2667_resume()
H A Dpm8xxx-vibrator.c19 #include <linux/regmap.h>
37 * @regmap: regmap for register read/write
46 struct regmap *regmap; member in struct:pm8xxx_vib
68 rc = regmap_write(vib->regmap, VIB_DRV, val); pm8xxx_vib_set()
86 rc = regmap_read(vib->regmap, VIB_DRV, &val); pm8xxx_work_handler()
155 vib->regmap = dev_get_regmap(pdev->dev.parent, NULL); pm8xxx_vib_probe()
156 if (!vib->regmap) pm8xxx_vib_probe()
167 error = regmap_read(vib->regmap, VIB_DRV, &val); pm8xxx_vib_probe()
172 error = regmap_write(vib->regmap, VIB_DRV, val); pm8xxx_vib_probe()
H A Dpm8941-pwrkey.c25 #include <linux/regmap.h>
50 struct regmap *regmap; member in struct:pm8941_pwrkey
72 error = regmap_update_bits(pwrkey->regmap, pm8941_reboot_notify()
98 error = regmap_update_bits(pwrkey->regmap, pm8941_reboot_notify()
106 error = regmap_update_bits(pwrkey->regmap, pm8941_reboot_notify()
122 error = regmap_read(pwrkey->regmap, pm8941_pwrkey_irq()
179 pwrkey->regmap = dev_get_regmap(pdev->dev.parent, NULL); pm8941_pwrkey_probe()
180 if (!pwrkey->regmap) { pm8941_pwrkey_probe()
181 dev_err(&pdev->dev, "failed to locate regmap\n"); pm8941_pwrkey_probe()
196 error = regmap_read(pwrkey->regmap, pwrkey->baseaddr + PON_REV2, pm8941_pwrkey_probe()
217 error = regmap_update_bits(pwrkey->regmap, pm8941_pwrkey_probe()
226 error = regmap_update_bits(pwrkey->regmap, pm8941_pwrkey_probe()
H A Dpmic8xxx-pwrkey.c20 #include <linux/regmap.h>
87 struct regmap *regmap; pmic8xxx_pwrkey_probe() local
102 regmap = dev_get_regmap(pdev->dev.parent, NULL); pmic8xxx_pwrkey_probe()
103 if (!regmap) { pmic8xxx_pwrkey_probe()
104 dev_err(&pdev->dev, "failed to locate regmap for the device\n"); pmic8xxx_pwrkey_probe()
128 err = regmap_read(regmap, PON_CNTL_1, &pon_cntl); pmic8xxx_pwrkey_probe()
141 err = regmap_write(regmap, PON_CNTL_1, pon_cntl); pmic8xxx_pwrkey_probe()
H A Ddrv260x.c23 #include <linux/regmap.h>
183 * @regmap - Register map of the device
196 struct regmap *regmap; member in struct:drv260x_data
268 error = regmap_write(haptics->regmap, drv260x_worker()
274 error = regmap_write(haptics->regmap, drv260x_worker()
308 error = regmap_write(haptics->regmap, DRV260X_MODE, DRV260X_STANDBY); drv260x_close()
360 error = regmap_write(haptics->regmap, drv260x_init()
369 error = regmap_write(haptics->regmap, drv260x_init()
380 error = regmap_register_patch(haptics->regmap, drv260x_init()
393 error = regmap_register_patch(haptics->regmap, drv260x_init()
403 error = regmap_update_bits(haptics->regmap, DRV260X_LIB_SEL, drv260x_init()
416 error = regmap_register_patch(haptics->regmap, drv260x_init()
426 error = regmap_update_bits(haptics->regmap, DRV260X_LIB_SEL, drv260x_init()
440 error = regmap_write(haptics->regmap, DRV260X_GO, DRV260X_GO_BIT); drv260x_init()
449 error = regmap_read(haptics->regmap, DRV260X_GO, &cal_buf); drv260x_init()
618 haptics->regmap = devm_regmap_init_i2c(client, &drv260x_regmap_config); drv260x_probe()
619 if (IS_ERR(haptics->regmap)) { drv260x_probe()
620 error = PTR_ERR(haptics->regmap); drv260x_probe()
650 ret = regmap_update_bits(haptics->regmap, drv260x_suspend()
664 regmap_update_bits(haptics->regmap, drv260x_suspend()
688 ret = regmap_update_bits(haptics->regmap, drv260x_resume()
/linux-4.1.27/drivers/rtc/
H A Drtc-max8907.c19 #include <linux/regmap.h>
45 struct regmap *regmap; member in struct:max8907_rtc
54 regmap_write(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0); max8907_irq_handler()
103 ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_RTC_SEC, regs, max8907_rtc_read_time()
120 return regmap_bulk_write(rtc->regmap, MAX8907_REG_RTC_SEC, regs, max8907_rtc_set_time()
131 ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs, max8907_rtc_read_alarm()
138 ret = regmap_read(rtc->regmap, MAX8907_REG_ALARM0_CNTL, &val); max8907_rtc_read_alarm()
156 ret = regmap_write(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0); max8907_rtc_set_alarm()
160 ret = regmap_bulk_write(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs, max8907_rtc_set_alarm()
166 ret = regmap_write(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0x77); max8907_rtc_set_alarm()
190 rtc->regmap = max8907->regmap_rtc; max8907_rtc_probe()
H A Drtc-pm8xxx.c18 #include <linux/regmap.h>
57 * @regmap: regmap used to access RTC registers
66 struct regmap *regmap; member in struct:pm8xxx_rtc
104 rc = regmap_read(rtc_dd->regmap, regs->ctrl, &ctrl_reg); pm8xxx_rtc_set_time()
111 rc = regmap_write(rtc_dd->regmap, regs->ctrl, ctrl_reg); pm8xxx_rtc_set_time()
119 rc = regmap_write(rtc_dd->regmap, regs->write, 0); pm8xxx_rtc_set_time()
126 rc = regmap_bulk_write(rtc_dd->regmap, regs->write + 1, pm8xxx_rtc_set_time()
134 rc = regmap_write(rtc_dd->regmap, regs->write, value[0]); pm8xxx_rtc_set_time()
142 rc = regmap_write(rtc_dd->regmap, regs->ctrl, ctrl_reg); pm8xxx_rtc_set_time()
164 rc = regmap_bulk_read(rtc_dd->regmap, regs->read, value, sizeof(value)); pm8xxx_rtc_read_time()
174 rc = regmap_read(rtc_dd->regmap, regs->read, &reg); pm8xxx_rtc_read_time()
181 rc = regmap_bulk_read(rtc_dd->regmap, regs->read, pm8xxx_rtc_read_time()
224 rc = regmap_bulk_write(rtc_dd->regmap, regs->alarm_rw, value, pm8xxx_rtc_set_alarm()
231 rc = regmap_read(rtc_dd->regmap, regs->alarm_ctrl, &ctrl_reg); pm8xxx_rtc_set_alarm()
240 rc = regmap_write(rtc_dd->regmap, regs->alarm_ctrl, ctrl_reg); pm8xxx_rtc_set_alarm()
263 rc = regmap_bulk_read(rtc_dd->regmap, regs->alarm_rw, value, pm8xxx_rtc_read_alarm()
298 rc = regmap_read(rtc_dd->regmap, regs->alarm_ctrl, &ctrl_reg); pm8xxx_rtc_alarm_irq_enable()
307 rc = regmap_write(rtc_dd->regmap, regs->alarm_ctrl, ctrl_reg); pm8xxx_rtc_alarm_irq_enable()
339 rc = regmap_read(rtc_dd->regmap, regs->alarm_ctrl, &ctrl_reg); pm8xxx_alarm_trigger()
347 rc = regmap_write(rtc_dd->regmap, regs->alarm_ctrl, ctrl_reg); pm8xxx_alarm_trigger()
358 rc = regmap_read(rtc_dd->regmap, regs->alarm_ctrl2, &ctrl_reg); pm8xxx_alarm_trigger()
366 rc = regmap_write(rtc_dd->regmap, regs->alarm_ctrl2, ctrl_reg); pm8xxx_alarm_trigger()
382 rc = regmap_read(rtc_dd->regmap, regs->ctrl, &ctrl_reg); pm8xxx_rtc_enable()
388 rc = regmap_write(rtc_dd->regmap, regs->ctrl, ctrl_reg); pm8xxx_rtc_enable()
454 rtc_dd->regmap = dev_get_regmap(pdev->dev.parent, NULL); pm8xxx_rtc_probe()
455 if (!rtc_dd->regmap) { pm8xxx_rtc_probe()
456 dev_err(&pdev->dev, "Parent regmap unavailable.\n"); pm8xxx_rtc_probe()
H A Drtc-da9063.c23 #include <linux/regmap.h>
92 return regmap_update_bits(rtc->hw->regmap, rtc->alarm_year, da9063_rtc_stop_alarm()
100 return regmap_update_bits(rtc->hw->regmap, rtc->alarm_year, da9063_rtc_start_alarm()
112 ret = regmap_bulk_read(rtc->hw->regmap, DA9063_REG_COUNT_S, da9063_rtc_read_time()
145 ret = regmap_bulk_write(rtc->hw->regmap, DA9063_REG_COUNT_S, da9063_rtc_set_time()
161 ret = regmap_bulk_read(rtc->hw->regmap, rtc->alarm_start, da9063_rtc_read_alarm()
170 ret = regmap_read(rtc->hw->regmap, DA9063_REG_EVENT_A, &val); da9063_rtc_read_alarm()
196 ret = regmap_bulk_write(rtc->hw->regmap, rtc->alarm_start, da9063_rtc_set_alarm()
228 regmap_update_bits(rtc->hw->regmap, rtc->alarm_year, da9063_alarm_event()
253 ret = regmap_update_bits(da9063->regmap, DA9063_REG_CONTROL_E, da9063_rtc_probe()
260 ret = regmap_update_bits(da9063->regmap, DA9063_REG_EN_32K, da9063_rtc_probe()
283 ret = regmap_update_bits(da9063->regmap, rtc->alarm_start, da9063_rtc_probe()
291 ret = regmap_update_bits(da9063->regmap, rtc->alarm_start, da9063_rtc_probe()
299 ret = regmap_update_bits(da9063->regmap, rtc->alarm_year, da9063_rtc_probe()
307 ret = regmap_bulk_read(da9063->regmap, rtc->alarm_start, da9063_rtc_probe()
H A Drtc-tps65910.c44 return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS, val); tps65910_rtc_alarm_irq_enable()
63 ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL, tps65910_rtc_read_time()
70 ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, rtc_data, tps65910_rtc_read_time()
101 ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL, tps65910_rtc_set_time()
109 ret = regmap_bulk_write(tps->regmap, TPS65910_SECONDS, rtc_data, tps65910_rtc_set_time()
117 ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL, tps65910_rtc_set_time()
135 ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, alarm_data, tps65910_rtc_read_alarm()
149 ret = regmap_read(tps->regmap, TPS65910_RTC_INTERRUPTS, &int_val); tps65910_rtc_read_alarm()
177 ret = regmap_bulk_write(tps->regmap, TPS65910_ALARM_SECONDS, tps65910_rtc_set_alarm()
199 ret = regmap_read(tps->regmap, TPS65910_RTC_STATUS, &rtc_reg); tps65910_rtc_interrupt()
206 ret = regmap_write(tps->regmap, TPS65910_RTC_STATUS, rtc_reg); tps65910_rtc_interrupt()
240 ret = regmap_read(tps65910->regmap, TPS65910_RTC_STATUS, &rtc_reg); tps65910_rtc_probe()
244 ret = regmap_write(tps65910->regmap, TPS65910_RTC_STATUS, rtc_reg); tps65910_rtc_probe()
251 ret = regmap_update_bits(tps65910->regmap, TPS65910_DEVCTRL, tps65910_rtc_probe()
257 ret = regmap_write(tps65910->regmap, TPS65910_RTC_CTRL, rtc_reg); tps65910_rtc_probe()
H A Drtc-isl12057.c31 #include <linux/regmap.h>
83 struct regmap *regmap; member in struct:isl12057_rtc_data
144 static int isl12057_i2c_validate_chip(struct regmap *regmap) isl12057_i2c_validate_chip() argument
153 ret = regmap_bulk_read(regmap, 0, regs, ISL12057_MEM_MAP_LEN); isl12057_i2c_validate_chip()
170 ret = regmap_update_bits(data->regmap, ISL12057_REG_SR, _isl12057_rtc_clear_alarm()
183 ret = regmap_update_bits(data->regmap, ISL12057_REG_INT, _isl12057_rtc_update_alarm()
196 * lock. Here, it is safe for everyone if we just use regmap internal lock
206 ret = regmap_read(data->regmap, ISL12057_REG_SR, &sr); _isl12057_rtc_read_time()
218 ret = regmap_bulk_read(data->regmap, ISL12057_REG_RTC_SC, regs, _isl12057_rtc_read_time()
255 ret = regmap_bulk_read(data->regmap, ISL12057_REG_A1_SC, regs, isl12057_rtc_read_alarm()
298 ret = regmap_read(data->regmap, ISL12057_REG_INT, &ir); isl12057_rtc_read_alarm()
378 ret = regmap_bulk_write(data->regmap, ISL12057_REG_A1_SC, regs, isl12057_rtc_set_alarm()
406 ret = regmap_bulk_write(data->regmap, ISL12057_REG_RTC_SC, regs, isl12057_rtc_set_time()
418 ret = regmap_update_bits(data->regmap, ISL12057_REG_SR, isl12057_rtc_set_time()
435 static int isl12057_check_rtc_status(struct device *dev, struct regmap *regmap) isl12057_check_rtc_status() argument
440 ret = regmap_update_bits(regmap, ISL12057_REG_INT, isl12057_check_rtc_status()
449 ret = regmap_update_bits(regmap, ISL12057_REG_SR, isl12057_check_rtc_status()
514 ret = regmap_read(rtc_data->regmap, ISL12057_REG_SR, &sr); isl12057_rtc_interrupt()
548 struct regmap *regmap; isl12057_probe() local
556 regmap = devm_regmap_init_i2c(client, &isl12057_rtc_regmap_config); isl12057_probe()
557 if (IS_ERR(regmap)) { isl12057_probe()
558 ret = PTR_ERR(regmap); isl12057_probe()
559 dev_err(dev, "%s: regmap allocation failed (%d)\n", isl12057_probe()
564 ret = isl12057_i2c_validate_chip(regmap); isl12057_probe()
568 ret = isl12057_check_rtc_status(dev, regmap); isl12057_probe()
577 data->regmap = regmap; isl12057_probe()
H A Drtc-rc5t583.c56 return regmap_update_bits(rc5t583->regmap, RC5T583_RTC_CTL1, SET_YAL, rc5t583_rtc_alarm_irq_enable()
75 ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data, rc5t583_rtc_read_time()
107 ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data, rc5t583_rtc_set_time()
124 ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data, rc5t583_rtc_read_alarm()
137 ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1, &interrupt_enable); rc5t583_rtc_read_alarm()
164 ret = regmap_bulk_write(rc5t583->regmap, RC5T583_RTC_AY_MIN, alarm_data, rc5t583_rtc_set_alarm()
186 ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL2, &rtc_reg); rc5t583_rtc_interrupt()
196 ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, rtc_reg); rc5t583_rtc_interrupt()
230 ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, 0); rc5t583_rtc_probe()
235 ret = regmap_write(rc5t583->regmap, RC5T583_RTC_ADJ, 0); rc5t583_rtc_probe()
290 ret = regmap_read(rc5t583->regmap, RC5T583_RTC_CTL1, rc5t583_rtc_suspend()
301 return regmap_write(rc5t583->regmap, RC5T583_RTC_CTL1, rc5t583_rtc_resume()
/linux-4.1.27/drivers/bus/
H A Dvexpress-config.c87 struct regmap *regmap = res; vexpress_config_devres_release() local
89 bridge->ops->regmap_exit(regmap, bridge->context); vexpress_config_devres_release()
92 struct regmap *devm_regmap_init_vexpress_config(struct device *dev) devm_regmap_init_vexpress_config()
95 struct regmap *regmap; devm_regmap_init_vexpress_config() local
96 struct regmap **res; devm_regmap_init_vexpress_config()
110 regmap = bridge->ops->regmap_init(dev, bridge->context); devm_regmap_init_vexpress_config()
111 if (IS_ERR(regmap)) { devm_regmap_init_vexpress_config()
113 return regmap; devm_regmap_init_vexpress_config()
116 *res = regmap; devm_regmap_init_vexpress_config()
119 return regmap; devm_regmap_init_vexpress_config()
/linux-4.1.27/drivers/clk/
H A Dclk-max-gen.h24 #include <linux/regmap.h>
27 int max_gen_clk_probe(struct platform_device *pdev, struct regmap *regmap,
H A Dclk-max-gen.c26 #include <linux/regmap.h>
35 struct regmap *regmap; member in struct:max_gen_clk
50 return regmap_update_bits(max_gen->regmap, max_gen->reg, max_gen_clk_prepare()
58 regmap_update_bits(max_gen->regmap, max_gen->reg, max_gen_clk_unprepare()
68 ret = regmap_read(max_gen->regmap, max_gen->reg, &val); max_gen_clk_is_prepared()
109 int max_gen_clk_probe(struct platform_device *pdev, struct regmap *regmap, max_gen_clk_probe() argument
129 max_gen_clks[i].regmap = regmap; max_gen_clk_probe()
H A Dclk-axm5516.c20 #include <linux/regmap.h>
27 * @regmap: Regmap for the clock control registers
31 struct regmap *regmap; member in struct:axxia_clk
38 * @reg: Offset into regmap for PLL control register
58 regmap_read(aclk->regmap, pll->reg, &control); axxia_pllclk_recalc()
74 * @reg: Offset into regmap for PLL control register
96 regmap_read(aclk->regmap, divclk->reg, &ctrl); axxia_divclk_recalc_rate()
109 * @reg: Offset into regmap for PLL control register
130 regmap_read(aclk->regmap, mux->reg, &ctrl); axxia_clkmux_get_parent()
545 struct regmap *regmap; axmclk_probe() local
554 regmap = devm_regmap_init_mmio(dev, base, &axmclk_regmap_config); axmclk_probe()
555 if (IS_ERR(regmap)) axmclk_probe()
556 return PTR_ERR(regmap); axmclk_probe()
568 /* Update each entry with the allocated regmap and register the clock axmclk_probe()
572 axmclk_clocks[i]->regmap = regmap; axmclk_probe()
/linux-4.1.27/drivers/media/dvb-frontends/
H A Drtl2830_priv.h26 #include <linux/regmap.h>
31 struct regmap *regmap; member in struct:rtl2830_dev
/linux-4.1.27/drivers/net/ethernet/stmicro/stmmac/
H A Ddwmac-sti.c20 #include <linux/regmap.h>
128 struct regmap *regmap; member in struct:sti_dwmac
190 regmap_update_bits(dwmac->regmap, reg, STIH4XX_RETIME_SRC_MASK, stih4xx_fix_retime_src()
221 regmap_update_bits(dwmac->regmap, reg, STID127_RETIME_SRC_MASK, val); stid127_fix_retime_src()
226 struct regmap *regmap = dwmac->regmap; sti_dwmac_ctrl_init() local
237 regmap_update_bits(regmap, reg, EN_MASK, EN); sti_dwmac_ctrl_init()
239 regmap_update_bits(regmap, reg, MII_PHY_SEL_MASK, phy_intf_sels[iface]); sti_dwmac_ctrl_init()
242 regmap_update_bits(regmap, reg, ENMII_MASK, val); sti_dwmac_ctrl_init()
282 struct regmap *regmap; sti_dwmac_parse_data() local
294 regmap = syscon_regmap_lookup_by_phandle(np, "st,syscon"); sti_dwmac_parse_data()
295 if (IS_ERR(regmap)) sti_dwmac_parse_data()
296 return PTR_ERR(regmap); sti_dwmac_parse_data()
306 dwmac->regmap = regmap; sti_dwmac_parse_data()
/linux-4.1.27/arch/arm/mach-u300/
H A Dregulator.c19 #include <linux/regmap.h>
61 struct regmap *regmap; __u300_init_boardpower() local
71 regmap = syscon_node_to_regmap(syscon_np); __u300_init_boardpower()
72 if (IS_ERR(regmap)) { __u300_init_boardpower()
73 pr_crit("U300: could not locate syscon regmap\n"); __u300_init_boardpower()
74 return PTR_ERR(regmap); __u300_init_boardpower()
97 regmap_update_bits(regmap, U300_SYSCON_PMCR, __u300_init_boardpower()
/linux-4.1.27/include/linux/mfd/wm8994/
H A Dcore.h20 #include <linux/regmap.h>
66 struct regmap *regmap; member in struct:wm8994
92 ret = regmap_read(wm8994->regmap, reg, &val); wm8994_reg_read()
103 return regmap_write(wm8994->regmap, reg, val); wm8994_reg_write()
109 return regmap_bulk_read(wm8994->regmap, reg, buf, count); wm8994_bulk_read()
115 return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16)); wm8994_bulk_write()
121 return regmap_update_bits(wm8994->regmap, reg, mask, val); wm8994_set_bits()
/linux-4.1.27/drivers/spi/
H A Dspi-meson-spifc.c23 #include <linux/regmap.h>
77 * @regmap: regmap for device registers
83 struct regmap *regmap; member in struct:meson_spifc
106 regmap_read(spifc->regmap, REG_SLAVE, &data); meson_spifc_wait_ready()
128 regmap_read(spifc->regmap, REG_C0 + i, &data); meson_spifc_drain_buffer()
159 regmap_write(spifc->regmap, REG_C0 + i, data); meson_spifc_fill_buffer()
187 regmap_write(spifc->regmap, REG_CLOCK, value); meson_spifc_setup_speed()
212 regmap_update_bits(spifc->regmap, REG_USER, USER_UC_MASK, meson_spifc_txrx()
214 regmap_write(spifc->regmap, REG_USER1, meson_spifc_txrx()
218 regmap_update_bits(spifc->regmap, REG_USER, USER_DIN_EN_MS, meson_spifc_txrx()
228 regmap_update_bits(spifc->regmap, REG_USER4, USER4_CS_ACT, meson_spifc_txrx()
232 regmap_update_bits(spifc->regmap, REG_SLAVE, SLAVE_TRST_DONE, 0); meson_spifc_txrx()
234 regmap_update_bits(spifc->regmap, REG_CMD, CMD_USER, CMD_USER); meson_spifc_txrx()
260 regmap_update_bits(spifc->regmap, REG_CTRL, CTRL_ENABLE_AHB, 0); meson_spifc_transfer_one()
270 regmap_update_bits(spifc->regmap, REG_CTRL, CTRL_ENABLE_AHB, meson_spifc_transfer_one()
283 regmap_update_bits(spifc->regmap, REG_SLAVE, SLAVE_SW_RST, meson_spifc_hw_init()
286 regmap_update_bits(spifc->regmap, REG_USER, USER_CMP_MODE, 0); meson_spifc_hw_init()
288 regmap_update_bits(spifc->regmap, REG_SLAVE, SLAVE_OP_MODE, 0); meson_spifc_hw_init()
316 spifc->regmap = devm_regmap_init_mmio(spifc->dev, base, meson_spifc_probe()
318 if (IS_ERR(spifc->regmap)) { meson_spifc_probe()
319 ret = PTR_ERR(spifc->regmap); meson_spifc_probe()
/linux-4.1.27/drivers/phy/
H A Dphy-exynos-mipi-video.c21 #include <linux/regmap.h>
46 struct regmap *regmap; member in struct:exynos_mipi_video_phy
63 if (!IS_ERR(state->regmap)) { __set_phy_state()
64 regmap_read(state->regmap, offset, &val); __set_phy_state()
69 regmap_write(state->regmap, offset, val); __set_phy_state()
74 regmap_write(state->regmap, offset, val); __set_phy_state()
144 state->regmap = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon"); exynos_mipi_video_phy_probe()
145 if (IS_ERR(state->regmap)) { exynos_mipi_video_phy_probe()
148 dev_info(dev, "regmap lookup failed: %ld\n", exynos_mipi_video_phy_probe()
149 PTR_ERR(state->regmap)); exynos_mipi_video_phy_probe()
H A Dphy-stih41x-usb.c22 #include <linux/regmap.h>
46 * @regmap: Syscfg registers bank in which PHY is configured
52 struct regmap *regmap; member in struct:stih41x_usb_phy
75 return regmap_update_bits(phy_dev->regmap, phy_dev->cfg->syscfg, stih41x_usb_phy_init()
90 ret = regmap_update_bits(phy_dev->regmap, phy_dev->cfg->syscfg, stih41x_usb_phy_power_on()
103 ret = regmap_update_bits(phy_dev->regmap, phy_dev->cfg->syscfg, stih41x_usb_phy_power_off()
143 phy_dev->regmap = syscon_regmap_lookup_by_phandle(np, "st,syscfg"); stih41x_usb_phy_probe()
144 if (IS_ERR(phy_dev->regmap)) { stih41x_usb_phy_probe()
146 return PTR_ERR(phy_dev->regmap); stih41x_usb_phy_probe()
H A Dphy-stih407-usb.c20 #include <linux/regmap.h>
38 struct regmap *regmap; member in struct:stih407_usb2_picophy
50 return regmap_update_bits(phy_dev->regmap, phy_dev->ctrl, stih407_usb2_pico_ctrl()
62 ret = regmap_update_bits(phy_dev->regmap, stih407_usb2_init_port()
123 phy_dev->regmap = syscon_regmap_lookup_by_phandle(np, "st,syscfg"); stih407_usb2_picophy_probe()
124 if (IS_ERR(phy_dev->regmap)) { stih407_usb2_picophy_probe()
126 return PTR_ERR(phy_dev->regmap); stih407_usb2_picophy_probe()
H A Dphy-samsung-usb2.h18 #include <linux/regmap.h>
44 struct regmap *reg_pmu;
45 struct regmap *reg_sys;
/linux-4.1.27/sound/soc/adi/
H A Daxi-spdif.c15 #include <linux/regmap.h>
39 struct regmap *regmap; member in struct:axi_spdif
70 regmap_update_bits(spdif->regmap, AXI_SPDIF_REG_CTRL, axi_spdif_trigger()
102 regmap_write(spdif->regmap, AXI_SPDIF_REG_STAT, stat); axi_spdif_hw_params()
103 regmap_update_bits(spdif->regmap, AXI_SPDIF_REG_CTRL, axi_spdif_hw_params()
134 regmap_update_bits(spdif->regmap, AXI_SPDIF_REG_CTRL, axi_spdif_startup()
145 regmap_update_bits(spdif->regmap, AXI_SPDIF_REG_CTRL, axi_spdif_shutdown()
198 spdif->regmap = devm_regmap_init_mmio(&pdev->dev, base, axi_spdif_probe()
200 if (IS_ERR(spdif->regmap)) axi_spdif_probe()
201 return PTR_ERR(spdif->regmap); axi_spdif_probe()
H A Daxi-i2s.c14 #include <linux/regmap.h>
42 struct regmap *regmap; member in struct:axi_i2s
81 regmap_update_bits(i2s->regmap, AXI_I2S_REG_CTRL, mask, val); axi_i2s_trigger()
98 regmap_write(i2s->regmap, AXI_I2S_REG_CLK_CTRL, (word_size << 16) | axi_i2s_hw_params()
116 regmap_write(i2s->regmap, AXI_I2S_REG_RESET, mask); axi_i2s_startup()
199 i2s->regmap = devm_regmap_init_mmio(&pdev->dev, base, axi_i2s_probe()
201 if (IS_ERR(i2s->regmap)) axi_i2s_probe()
202 return PTR_ERR(i2s->regmap); axi_i2s_probe()
232 regmap_write(i2s->regmap, AXI_I2S_REG_RESET, AXI_I2S_RESET_GLOBAL); axi_i2s_probe()
/linux-4.1.27/sound/soc/tegra/
H A Dtegra20_ac97.c32 #include <linux/regmap.h>
61 regmap_read(workdata->regmap, TEGRA20_AC97_STATUS1, &readback); tegra20_ac97_codec_reset()
90 regmap_read(workdata->regmap, TEGRA20_AC97_STATUS1, &readback); tegra20_ac97_codec_warm_reset()
103 regmap_write(workdata->regmap, TEGRA20_AC97_CMD, tegra20_ac97_codec_read()
111 regmap_read(workdata->regmap, TEGRA20_AC97_STATUS1, &readback); tegra20_ac97_codec_read()
127 regmap_write(workdata->regmap, TEGRA20_AC97_CMD, tegra20_ac97_codec_write()
137 regmap_read(workdata->regmap, TEGRA20_AC97_CMD, &readback); tegra20_ac97_codec_write()
153 regmap_update_bits(ac97->regmap, TEGRA20_AC97_FIFO1_SCR, tegra20_ac97_start_playback()
157 regmap_update_bits(ac97->regmap, TEGRA20_AC97_CTRL, tegra20_ac97_start_playback()
166 regmap_update_bits(ac97->regmap, TEGRA20_AC97_FIFO1_SCR, tegra20_ac97_stop_playback()
169 regmap_update_bits(ac97->regmap, TEGRA20_AC97_CTRL, tegra20_ac97_stop_playback()
175 regmap_update_bits(ac97->regmap, TEGRA20_AC97_FIFO1_SCR, tegra20_ac97_start_capture()
182 regmap_update_bits(ac97->regmap, TEGRA20_AC97_FIFO1_SCR, tegra20_ac97_stop_capture()
341 ac97->regmap = devm_regmap_init_mmio(&pdev->dev, regs, tegra20_ac97_platform_probe()
343 if (IS_ERR(ac97->regmap)) { tegra20_ac97_platform_probe()
344 dev_err(&pdev->dev, "regmap init failed\n"); tegra20_ac97_platform_probe()
345 ret = PTR_ERR(ac97->regmap); tegra20_ac97_platform_probe()
/linux-4.1.27/drivers/staging/iio/light/
H A Disl29028.c26 #include <linux/regmap.h>
74 struct regmap *regmap; member in struct:isl29028_chip
94 return regmap_update_bits(chip->regmap, ISL29028_REG_CONFIGURE, isl29028_set_proxim_sampling()
105 ret = regmap_update_bits(chip->regmap, ISL29028_REG_CONFIGURE, isl29028_enable_proximity()
120 return regmap_update_bits(chip->regmap, ISL29028_REG_CONFIGURE, isl29028_set_als_scale()
131 ret = regmap_update_bits(chip->regmap, ISL29028_REG_CONFIGURE, isl29028_set_als_ir_mode()
136 ret = regmap_update_bits(chip->regmap, ISL29028_REG_CONFIGURE, isl29028_set_als_ir_mode()
141 ret = regmap_update_bits(chip->regmap, ISL29028_REG_CONFIGURE, isl29028_set_als_ir_mode()
146 return regmap_update_bits(chip->regmap, ISL29028_REG_CONFIGURE, isl29028_set_als_ir_mode()
154 ret = regmap_update_bits(chip->regmap, ISL29028_REG_CONFIGURE, isl29028_set_als_ir_mode()
170 ret = regmap_read(chip->regmap, ISL29028_REG_ALSIR_L, &lsb); isl29028_read_als_ir()
177 ret = regmap_read(chip->regmap, ISL29028_REG_ALSIR_U, &msb); isl29028_read_als_ir()
193 ret = regmap_read(chip->regmap, ISL29028_REG_PROX_DATA, &data); isl29028_read_proxim()
422 ret = regmap_write(chip->regmap, ISL29028_REG_TEST1_MODE, 0x0); isl29028_chip_init()
428 ret = regmap_write(chip->regmap, ISL29028_REG_TEST2_MODE, 0x0); isl29028_chip_init()
435 ret = regmap_write(chip->regmap, ISL29028_REG_CONFIGURE, 0x0); isl29028_chip_init()
497 chip->regmap = devm_regmap_init_i2c(client, &isl29028_regmap_config); isl29028_probe()
498 if (IS_ERR(chip->regmap)) { isl29028_probe()
499 ret = PTR_ERR(chip->regmap); isl29028_probe()
500 dev_err(chip->dev, "regmap initialization failed: %d\n", ret); isl29028_probe()
/linux-4.1.27/sound/soc/xtensa/
H A Dxtfpga-i2s.c63 struct regmap *regmap; member in struct:xtfpga_i2s
184 regmap_read(i2s->regmap, XTFPGA_I2S_INT_STATUS, xtfpga_pcm_refill_fifo()
190 regmap_write(i2s->regmap, XTFPGA_I2S_INT_STATUS, xtfpga_pcm_refill_fifo()
193 regmap_read(i2s->regmap, XTFPGA_I2S_INT_STATUS, xtfpga_pcm_refill_fifo()
208 regmap_write(i2s->regmap, XTFPGA_I2S_INT_MASK, xtfpga_pcm_refill_fifo()
211 regmap_write(i2s->regmap, XTFPGA_I2S_INT_MASK, xtfpga_pcm_refill_fifo()
215 regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG, xtfpga_pcm_refill_fifo()
221 regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG, xtfpga_pcm_refill_fifo()
232 regmap_read(i2s->regmap, XTFPGA_I2S_CONFIG, &config); xtfpga_i2s_threaded_irq_handler()
233 regmap_read(i2s->regmap, XTFPGA_I2S_INT_MASK, &int_mask); xtfpga_i2s_threaded_irq_handler()
234 regmap_read(i2s->regmap, XTFPGA_I2S_INT_STATUS, &int_status); xtfpga_i2s_threaded_irq_handler()
245 regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG, xtfpga_i2s_threaded_irq_handler()
294 regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG, xtfpga_i2s_hw_params()
312 regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG, xtfpga_i2s_hw_params()
327 regmap_update_bits(i2s->regmap, XTFPGA_I2S_CONFIG, xtfpga_i2s_hw_params()
565 i2s->regmap = devm_regmap_init_mmio(&pdev->dev, i2s->regs, xtfpga_i2s_probe()
567 if (IS_ERR(i2s->regmap)) { xtfpga_i2s_probe()
568 dev_err(&pdev->dev, "regmap init failed\n"); xtfpga_i2s_probe()
569 err = PTR_ERR(i2s->regmap); xtfpga_i2s_probe()
580 regmap_write(i2s->regmap, XTFPGA_I2S_CONFIG, xtfpga_i2s_probe()
582 regmap_write(i2s->regmap, XTFPGA_I2S_INT_STATUS, XTFPGA_I2S_INT_VALID); xtfpga_i2s_probe()
583 regmap_write(i2s->regmap, XTFPGA_I2S_INT_MASK, XTFPGA_I2S_INT_UNDERRUN); xtfpga_i2s_probe()
636 if (i2s->regmap && !IS_ERR(i2s->regmap)) { xtfpga_i2s_remove()
637 regmap_write(i2s->regmap, XTFPGA_I2S_CONFIG, 0); xtfpga_i2s_remove()
638 regmap_write(i2s->regmap, XTFPGA_I2S_INT_MASK, 0); xtfpga_i2s_remove()
639 regmap_write(i2s->regmap, XTFPGA_I2S_INT_STATUS, xtfpga_i2s_remove()
/linux-4.1.27/drivers/thermal/st/
H A Dst_thermal_memmap.c57 return regmap_update_bits(sensor->regmap, STIH416_MPE_CONF, mask, val); st_mmap_power_ctrl()
63 struct regmap *regmap = sensor->regmap; st_mmap_alloc_regfields() local
66 sensor->int_thresh_hi = devm_regmap_field_alloc(dev, regmap, st_mmap_alloc_regfields()
68 sensor->int_enable = devm_regmap_field_alloc(dev, regmap, st_mmap_alloc_regfields()
141 sensor->regmap = devm_regmap_init_mmio(dev, sensor->mmio_base, st_mmap_regmap_init()
143 if (IS_ERR(sensor->regmap)) { st_mmap_regmap_init()
144 dev_err(dev, "failed to initialise regmap\n"); st_mmap_regmap_init()
145 return PTR_ERR(sensor->regmap); st_mmap_regmap_init()
H A Dst_thermal.h18 #include <linux/regmap.h>
45 * @alloc_regfields: Allocate regmap register fields, specific to a sensor.
46 * @do_memmap_regmap: Memory map the thermal register space and init regmap
47 * instance or find regmap instance.
88 struct regmap *regmap; member in struct:st_thermal_sensor
/linux-4.1.27/drivers/input/keyboard/
H A Dcap11xx.c16 #include <linux/regmap.h>
60 struct regmap *regmap; member in struct:cap11xx_priv
160 ret = regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL, 1, 0); cap11xx_thread_func()
164 ret = regmap_read(priv->regmap, CAP11XX_REG_SENSOR_INPUT, &status); cap11xx_thread_func()
180 return regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL, cap11xx_set_sleep()
228 priv->regmap = devm_regmap_init_i2c(i2c_client, &cap11xx_regmap_config); cap11xx_i2c_probe()
229 if (IS_ERR(priv->regmap)) cap11xx_i2c_probe()
230 return PTR_ERR(priv->regmap); cap11xx_i2c_probe()
232 error = regmap_read(priv->regmap, CAP11XX_REG_PRODUCT_ID, &val); cap11xx_i2c_probe()
242 error = regmap_read(priv->regmap, CAP11XX_REG_MANUFACTURER_ID, &val); cap11xx_i2c_probe()
252 error = regmap_read(priv->regmap, CAP11XX_REG_REVISION, &rev); cap11xx_i2c_probe()
268 error = regmap_update_bits(priv->regmap, CAP11XX_REG_CONFIG2, cap11xx_i2c_probe()
281 error = regmap_update_bits(priv->regmap, CAP11XX_REG_MAIN_CONTROL, cap11xx_i2c_probe()
288 error = regmap_write(priv->regmap, CAP11XX_REG_REPEAT_RATE, 0); cap11xx_i2c_probe()
/linux-4.1.27/drivers/watchdog/
H A Dimx2_wdt.c36 #include <linux/regmap.h>
64 struct regmap *regmap; member in struct:imx2_wdt_device
94 regmap_write(wdev->regmap, 0, wcr_enable); imx2_restart_handler()
102 regmap_write(wdev->regmap, 0, wcr_enable); imx2_restart_handler()
103 regmap_write(wdev->regmap, 0, wcr_enable); imx2_restart_handler()
116 regmap_read(wdev->regmap, IMX2_WDT_WCR, &val); imx2_wdt_setup()
129 regmap_write(wdev->regmap, IMX2_WDT_WCR, val); imx2_wdt_setup()
133 regmap_write(wdev->regmap, IMX2_WDT_WCR, val); imx2_wdt_setup()
140 regmap_read(wdev->regmap, IMX2_WDT_WCR, &val); imx2_wdt_is_running()
149 regmap_write(wdev->regmap, IMX2_WDT_WSR, IMX2_WDT_SEQ1); imx2_wdt_ping()
150 regmap_write(wdev->regmap, IMX2_WDT_WSR, IMX2_WDT_SEQ2); imx2_wdt_ping()
169 regmap_update_bits(wdev->regmap, IMX2_WDT_WCR, IMX2_WDT_WCR_WT, imx2_wdt_set_timeout()
241 wdev->regmap = devm_regmap_init_mmio_clk(&pdev->dev, NULL, base, imx2_wdt_probe()
243 if (IS_ERR(wdev->regmap)) { imx2_wdt_probe()
244 dev_err(&pdev->dev, "regmap init failed\n"); imx2_wdt_probe()
245 return PTR_ERR(wdev->regmap); imx2_wdt_probe()
262 regmap_read(wdev->regmap, IMX2_WDT_WRSR, &val); imx2_wdt_probe()
284 regmap_write(wdev->regmap, IMX2_WDT_WMCR, 0); imx2_wdt_probe()
H A Drn5t618_wdt.c67 ret = regmap_update_bits(wdt->rn5t618->regmap, RN5T618_WATCHDOG, rn5t618_wdt_set_timeout()
86 ret = regmap_update_bits(wdt->rn5t618->regmap, RN5T618_REPCNT, rn5t618_wdt_start()
93 ret = regmap_update_bits(wdt->rn5t618->regmap, RN5T618_WATCHDOG, rn5t618_wdt_start()
100 return regmap_update_bits(wdt->rn5t618->regmap, RN5T618_PWRIREN, rn5t618_wdt_start()
109 return regmap_update_bits(wdt->rn5t618->regmap, RN5T618_WATCHDOG, rn5t618_wdt_stop()
120 ret = regmap_read(wdt->rn5t618->regmap, RN5T618_WATCHDOG, &val); rn5t618_wdt_ping()
124 ret = regmap_write(wdt->rn5t618->regmap, RN5T618_WATCHDOG, val); rn5t618_wdt_ping()
129 return regmap_update_bits(wdt->rn5t618->regmap, RN5T618_PWRIRQ, rn5t618_wdt_ping()
/linux-4.1.27/drivers/gpu/drm/imx/
H A Dimx-tve.c21 #include <linux/regmap.h>
116 struct regmap *regmap; member in struct:imx_tve
150 ret = regmap_update_bits(tve->regmap, TVE_COM_CONF_REG, tve_enable()
156 regmap_write(tve->regmap, TVE_STAT_REG, 0xffffffff); tve_enable()
160 regmap_write(tve->regmap, TVE_INT_CONT_REG, 0); tve_enable()
162 regmap_write(tve->regmap, TVE_INT_CONT_REG, tve_enable()
174 ret = regmap_update_bits(tve->regmap, TVE_COM_CONF_REG, tve_disable()
192 ret = regmap_update_bits(tve->regmap, TVE_TVDAC0_CONT_REG, tve_setup_vga()
197 ret = regmap_update_bits(tve->regmap, TVE_TVDAC1_CONT_REG, tve_setup_vga()
202 ret = regmap_update_bits(tve->regmap, TVE_TVDAC2_CONT_REG, tve_setup_vga()
214 ret = regmap_update_bits(tve->regmap, TVE_COM_CONF_REG, mask, val); tve_setup_vga()
219 return regmap_update_bits(tve->regmap, TVE_TST_MODE_REG, tve_setup_vga()
283 ret = regmap_update_bits(tve->regmap, TVE_COM_CONF_REG, imx_tve_encoder_dpms()
394 regmap_read(tve->regmap, TVE_STAT_REG, &val); imx_tve_irq_handler()
397 regmap_write(tve->regmap, TVE_STAT_REG, 0xffffffff); imx_tve_irq_handler()
409 ret = regmap_read(tve->regmap, TVE_COM_CONF_REG, &val); clk_tve_di_recalc_rate()
455 ret = regmap_update_bits(tve->regmap, TVE_COM_CONF_REG, clk_tve_di_set_rate()
618 tve->regmap = devm_regmap_init_mmio_clk(dev, "tve", base, imx_tve_bind()
620 if (IS_ERR(tve->regmap)) { imx_tve_bind()
621 dev_err(dev, "failed to init regmap: %ld\n", imx_tve_bind()
622 PTR_ERR(tve->regmap)); imx_tve_bind()
623 return PTR_ERR(tve->regmap); imx_tve_bind()
667 ret = regmap_read(tve->regmap, TVE_COM_CONF_REG, &val); imx_tve_bind()
679 ret = regmap_write(tve->regmap, TVE_CD_CONT_REG, 0); imx_tve_bind()
/linux-4.1.27/drivers/usb/dwc3/
H A Ddwc3-st.c32 #include <linux/regmap.h>
84 * @regmap: regmap pointer for getting syscfg
94 struct regmap *regmap; member in struct:st_dwc3
123 err = regmap_read(dwc3_data->regmap, dwc3_data->syscfg_reg_off, &val); st_dwc3_drd_init()
167 return regmap_write(dwc3_data->regmap, dwc3_data->syscfg_reg_off, val); st_dwc3_drd_init()
202 struct regmap *regmap; st_dwc3_probe() local
214 regmap = syscon_regmap_lookup_by_phandle(node, "st,syscfg"); st_dwc3_probe()
215 if (IS_ERR(regmap)) st_dwc3_probe()
216 return PTR_ERR(regmap); st_dwc3_probe()
220 dwc3_data->regmap = regmap; st_dwc3_probe()
/linux-4.1.27/drivers/iio/light/
H A Djsa1212.c27 #include <linux/regmap.h>
130 struct regmap *regmap; member in struct:jsa1212_data
142 ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG, jsa1212_als_enable()
158 ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG, jsa1212_pxs_enable()
183 ret = regmap_bulk_read(data->regmap, JSA1212_ALS_DT1_REG, &als_data, 2); jsa1212_read_als_data()
209 ret = regmap_read(data->regmap, JSA1212_PXS_DATA_REG, &pxs_data); jsa1212_read_pxs_data()
282 ret = regmap_write(data->regmap, JSA1212_CONF_REG, jsa1212_chip_init()
288 ret = regmap_write(data->regmap, JSA1212_INT_REG, jsa1212_chip_init()
325 struct regmap *regmap; jsa1212_probe() local
335 regmap = devm_regmap_init_i2c(client, &jsa1212_regmap_config); jsa1212_probe()
336 if (IS_ERR(regmap)) { jsa1212_probe()
338 return PTR_ERR(regmap); jsa1212_probe()
345 data->regmap = regmap; jsa1212_probe()
375 ret = regmap_update_bits(data->regmap, JSA1212_CONF_REG, jsa1212_power_off()
/linux-4.1.27/sound/hda/
H A Dhdac_regmap.c16 #include <linux/regmap.h>
344 struct regmap *regmap; snd_hdac_regmap_init() local
346 regmap = regmap_init(&codec->dev, NULL, codec, &hda_regmap_cfg); snd_hdac_regmap_init()
347 if (IS_ERR(regmap)) snd_hdac_regmap_init()
348 return PTR_ERR(regmap); snd_hdac_regmap_init()
349 codec->regmap = regmap; snd_hdac_regmap_init()
357 if (codec->regmap) { snd_hdac_regmap_exit()
358 regmap_exit(codec->regmap); snd_hdac_regmap_exit()
359 codec->regmap = NULL; snd_hdac_regmap_exit()
366 * snd_hdac_regmap_add_vendor_verb - add a vendor-specific verb to regmap
368 * @verb: verb to allow accessing via regmap
392 if (!codec->regmap) reg_raw_write()
395 return regmap_write(codec->regmap, reg, val); reg_raw_write()
425 if (!codec->regmap) reg_raw_read()
428 return regmap_read(codec->regmap, reg, val); reg_raw_read()
/linux-4.1.27/drivers/extcon/
H A Dextcon-arizona.c168 ret = regmap_update_bits(arizona->regmap, arizona_extcon_hp_clamp()
178 ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1L, arizona_extcon_hp_clamp()
184 ret = regmap_update_bits(arizona->regmap, ARIZONA_HP_CTRL_1R, arizona_extcon_hp_clamp()
192 ret = regmap_update_bits(arizona->regmap, arizona_extcon_hp_clamp()
214 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1, arizona_extcon_set_mode()
218 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1, arizona_extcon_set_mode()
289 regmap_write(arizona->regmap, 0x80, 0x3); arizona_start_mic()
290 regmap_write(arizona->regmap, 0x294, 0); arizona_start_mic()
291 regmap_write(arizona->regmap, 0x80, 0x0); arizona_start_mic()
294 regmap_update_bits(arizona->regmap, arizona_start_mic()
300 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1, arizona_start_mic()
317 regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1, arizona_stop_mic()
330 regmap_write(arizona->regmap, 0x80, 0x3); arizona_stop_mic()
331 regmap_write(arizona->regmap, 0x294, 2); arizona_stop_mic()
332 regmap_write(arizona->regmap, 0x80, 0x0); arizona_stop_mic()
376 ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2, &val); arizona_hpdet_read()
401 ret = regmap_read(arizona->regmap, ARIZONA_HP_DACVAL, &val); arizona_hpdet_read()
408 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1, arizona_hpdet_read()
419 regmap_update_bits(arizona->regmap, arizona_hpdet_read()
456 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1, arizona_hpdet_read()
468 regmap_update_bits(arizona->regmap, arizona_hpdet_read()
504 regmap_update_bits(arizona->regmap, arizona_hpdet_do_id()
513 regmap_update_bits(arizona->regmap, arizona_hpdet_do_id()
548 regmap_update_bits(arizona->regmap, arizona_hpdet_do_id()
594 regmap_update_bits(arizona->regmap, arizona_hpdet_irq()
618 regmap_update_bits(arizona->regmap, arizona_hpdet_irq()
629 regmap_update_bits(arizona->regmap, arizona_hpdet_irq()
670 ret = regmap_update_bits(arizona->regmap, arizona_identify_headphone()
679 ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1, arizona_identify_headphone()
690 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1, arizona_identify_headphone()
721 ret = regmap_update_bits(arizona->regmap, arizona_start_hpdet_acc_id()
732 ret = regmap_update_bits(arizona->regmap, arizona_start_hpdet_acc_id()
748 regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1, arizona_start_hpdet_acc_id()
805 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val); arizona_micd_detect()
1001 ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val); arizona_jackdet()
1051 regmap_update_bits(arizona->regmap, arizona_jackdet()
1076 regmap_update_bits(arizona->regmap, arizona_jackdet()
1089 regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG, arizona_jackdet()
1120 regmap_update_bits(arizona->regmap, reg, mask, level); arizona_micd_set_level()
1245 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1, arizona_extcon_probe()
1251 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1, arizona_extcon_probe()
1257 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1, arizona_extcon_probe()
1290 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2, arizona_extcon_probe()
1314 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2, arizona_extcon_probe()
1333 regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL, arizona_extcon_probe()
1347 regmap_update_bits(arizona->regmap, arizona_extcon_probe()
1351 regmap_update_bits(arizona->regmap, arizona_extcon_probe()
1415 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE, arizona_extcon_probe()
1417 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE, arizona_extcon_probe()
1461 regmap_update_bits(arizona->regmap, arizona_extcon_remove()
1480 regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE, arizona_extcon_remove()
/linux-4.1.27/drivers/irqchip/
H A Dirq-st.c18 #include <linux/regmap.h>
43 struct regmap *regmap; member in struct:st_irq_syscfg
152 return regmap_update_bits(ddata->regmap, ddata->syscfg, st_irq_syscfg_enable()
172 ddata->regmap = syscon_regmap_lookup_by_phandle(np, "st,syscfg"); st_irq_syscfg_probe()
173 if (IS_ERR(ddata->regmap)) { st_irq_syscfg_probe()
175 return PTR_ERR(ddata->regmap); st_irq_syscfg_probe()
187 return regmap_update_bits(ddata->regmap, ddata->syscfg, st_irq_syscfg_resume()
/linux-4.1.27/include/linux/mfd/da9052/
H A Dda9052.h28 #include <linux/regmap.h>
93 struct regmap *regmap; member in struct:da9052
117 ret = regmap_read(da9052->regmap, reg, &val); da9052_reg_read()
135 ret = regmap_write(da9052->regmap, reg, val); da9052_reg_write()
156 ret = regmap_read(da9052->regmap, reg + i, &tmp); da9052_group_read()
178 ret = regmap_write(da9052->regmap, reg + i, val[i]); da9052_group_write()
198 ret = regmap_update_bits(da9052->regmap, reg, bit_mask, reg_val); da9052_reg_update()
/linux-4.1.27/include/linux/mfd/mt6397/
H A Dcore.h56 struct regmap *regmap; member in struct:mt6397_chip
/linux-4.1.27/drivers/base/
H A DMakefile21 obj-$(CONFIG_REGMAP) += regmap/
/linux-4.1.27/drivers/pinctrl/mediatek/
H A Dpinctrl-mt8135.c20 #include <linux/regmap.h>
241 static int spec_pull_set(struct regmap *regmap, unsigned int pin, spec_pull_set() argument
264 regmap_write(regmap, reg_pupd, spec_pupd[i].pupd_bit); spec_pull_set()
273 regmap_write(regmap, reg_rst_r0, spec_pupd[i].r0_bit); spec_pull_set()
274 regmap_write(regmap, reg_rst_r1, spec_pupd[i].r1_bit); spec_pull_set()
277 regmap_write(regmap, reg_set_r0, spec_pupd[i].r0_bit); spec_pull_set()
278 regmap_write(regmap, reg_rst_r1, spec_pupd[i].r1_bit); spec_pull_set()
281 regmap_write(regmap, reg_rst_r0, spec_pupd[i].r0_bit); spec_pull_set()
282 regmap_write(regmap, reg_set_r1, spec_pupd[i].r1_bit); spec_pull_set()
285 regmap_write(regmap, reg_set_r0, spec_pupd[i].r0_bit); spec_pull_set()
286 regmap_write(regmap, reg_set_r1, spec_pupd[i].r1_bit); spec_pull_set()
/linux-4.1.27/arch/arm/mach-imx/
H A Dmach-imx6sl.c15 #include <linux/regmap.h>
24 struct regmap *gpr; imx6sl_fec_init()
34 pr_err("failed to find fsl,imx6sl-iomux-gpr regmap\n"); imx6sl_fec_init()
H A Dmach-imx6sx.c12 #include <linux/regmap.h>
48 struct regmap *gpr; imx6sx_enet_clk_sel()
57 pr_err("failed to find fsl,imx6sx-iomux-gpr regmap\n"); imx6sx_enet_clk_sel()
/linux-4.1.27/sound/soc/qcom/
H A Dlpass.h22 #include <linux/regmap.h>
41 /* regmap backed by the low-power audio interface (LPAIF) registers */
42 struct regmap *lpaif_map;
/linux-4.1.27/include/linux/mfd/da9150/
H A Dcore.h19 #include <linux/regmap.h>
55 struct regmap *regmap; member in struct:da9150

Completed in 5627 milliseconds

1234