da9063-i2c.c

  1// SPDX-License-Identifier: GPL-2.0+
  2/* I2C support for Dialog DA9063
  3 *
  4 * Copyright 2012 Dialog Semiconductor Ltd.
  5 * Copyright 2013 Philipp Zabel, Pengutronix
  6 *
  7 * Author: Krystian Garbaciak, Dialog Semiconductor
  8 */
  9
 10#include <linux/kernel.h>
 11#include <linux/module.h>
 12#include <linux/i2c.h>
 13#include <linux/regmap.h>
 14#include <linux/delay.h>
 15#include <linux/slab.h>
 16#include <linux/err.h>
 17
 18#include <linux/mfd/core.h>
 19#include <linux/mfd/da9063/core.h>
 20#include <linux/mfd/da9063/registers.h>
 21
 22#include <linux/of.h>
 23#include <linux/regulator/of_regulator.h>
 24
 25/*
 26 * Raw I2C access required for just accessing chip and variant info before we
 27 * know which device is present. The info read from the device using this
 28 * approach is then used to select the correct regmap tables.
 29 */
 30
 31#define DA9063_REG_PAGE_SIZE		0x100
 32#define DA9063_REG_PAGED_ADDR_MASK	0xFF
 33
 34enum da9063_page_sel_buf_fmt {
 35	DA9063_PAGE_SEL_BUF_PAGE_REG = 0,
 36	DA9063_PAGE_SEL_BUF_PAGE_VAL,
 37	DA9063_PAGE_SEL_BUF_SIZE,
 38};
 39
 40enum da9063_page_sel_msgs {
 41	DA9063_PAGE_SEL_MSG = 0,
 42	DA9063_PAGE_SEL_CNT,
 43};
 44
 45enum da9063_paged_read_msgs {
 46	DA9063_PAGED_READ_MSG_REG_SEL = 0,
 47	DA9063_PAGED_READ_MSG_DATA,
 48	DA9063_PAGED_READ_MSG_CNT,
 49};
 50
 51static int da9063_i2c_blockreg_read(struct i2c_client *client, u16 addr,
 52				    u8 *buf, int count)
 53{
 54	struct i2c_msg xfer[DA9063_PAGED_READ_MSG_CNT];
 55	u8 page_sel_buf[DA9063_PAGE_SEL_BUF_SIZE];
 56	u8 page_num, paged_addr;
 57	int ret;
 58
 59	/* Determine page info based on register address */
 60	page_num = (addr / DA9063_REG_PAGE_SIZE);
 61	if (page_num > 1) {
 62		dev_err(&client->dev, "Invalid register address provided\n");
 63		return -EINVAL;
 64	}
 65
 66	paged_addr = (addr % DA9063_REG_PAGE_SIZE) & DA9063_REG_PAGED_ADDR_MASK;
 67	page_sel_buf[DA9063_PAGE_SEL_BUF_PAGE_REG] = DA9063_REG_PAGE_CON;
 68	page_sel_buf[DA9063_PAGE_SEL_BUF_PAGE_VAL] =
 69		(page_num << DA9063_I2C_PAGE_SEL_SHIFT) & DA9063_REG_PAGE_MASK;
 70
 71	/* Write reg address, page selection */
 72	xfer[DA9063_PAGE_SEL_MSG].addr = client->addr;
 73	xfer[DA9063_PAGE_SEL_MSG].flags = 0;
 74	xfer[DA9063_PAGE_SEL_MSG].len = DA9063_PAGE_SEL_BUF_SIZE;
 75	xfer[DA9063_PAGE_SEL_MSG].buf = page_sel_buf;
 76
 77	ret = i2c_transfer(client->adapter, xfer, DA9063_PAGE_SEL_CNT);
 78	if (ret < 0) {
 79		dev_err(&client->dev, "Page switch failed: %d\n", ret);
 80		return ret;
 81	}
 82
 83	if (ret != DA9063_PAGE_SEL_CNT) {
 84		dev_err(&client->dev, "Page switch failed to complete\n");
 85		return -EIO;
 86	}
 87
 88	/* Select register address */
 89	xfer[DA9063_PAGED_READ_MSG_REG_SEL].addr = client->addr;
 90	xfer[DA9063_PAGED_READ_MSG_REG_SEL].flags = 0;
 91	xfer[DA9063_PAGED_READ_MSG_REG_SEL].len = sizeof(paged_addr);
 92	xfer[DA9063_PAGED_READ_MSG_REG_SEL].buf = &paged_addr;
 93
 94	/* Read data */
 95	xfer[DA9063_PAGED_READ_MSG_DATA].addr = client->addr;
 96	xfer[DA9063_PAGED_READ_MSG_DATA].flags = I2C_M_RD;
 97	xfer[DA9063_PAGED_READ_MSG_DATA].len = count;
 98	xfer[DA9063_PAGED_READ_MSG_DATA].buf = buf;
 99
100	ret = i2c_transfer(client->adapter, xfer, DA9063_PAGED_READ_MSG_CNT);
101	if (ret < 0) {
102		dev_err(&client->dev, "Paged block read failed: %d\n", ret);
103		return ret;
104	}
105
106	if (ret != DA9063_PAGED_READ_MSG_CNT) {
107		dev_err(&client->dev, "Paged block read failed to complete\n");
108		return -EIO;
109	}
110
111	return 0;
112}
113
114enum {
115	DA9063_DEV_ID_REG = 0,
116	DA9063_VAR_ID_REG,
117	DA9063_CHIP_ID_REGS,
118};
119
120static int da9063_get_device_type(struct i2c_client *i2c, struct da9063 *da9063)
121{
122	u8 buf[DA9063_CHIP_ID_REGS];
123	int ret;
124
125	ret = da9063_i2c_blockreg_read(i2c, DA9063_REG_DEVICE_ID, buf,
126				       DA9063_CHIP_ID_REGS);
127	if (ret)
128		return ret;
129
130	if (buf[DA9063_DEV_ID_REG] != PMIC_CHIP_ID_DA9063) {
131		dev_err(da9063->dev,
132			"Invalid chip device ID: 0x%02x\n",
133			buf[DA9063_DEV_ID_REG]);
134		return -ENODEV;
135	}
136
137	dev_info(da9063->dev,
138		 "Device detected (chip-ID: 0x%02X, var-ID: 0x%02X)\n",
139		 buf[DA9063_DEV_ID_REG], buf[DA9063_VAR_ID_REG]);
140
141	da9063->variant_code =
142		(buf[DA9063_VAR_ID_REG] & DA9063_VARIANT_ID_MRC_MASK)
143		>> DA9063_VARIANT_ID_MRC_SHIFT;
144
145	return 0;
146}
147
148/*
149 * Variant specific regmap configs
150 */
151
152static const struct regmap_range da9063_ad_readable_ranges[] = {
153	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_AD_REG_SECOND_D),
154	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
155	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
156	regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_AD_REG_GP_ID_19),
157	regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
158};
159
160static const struct regmap_range da9063_ad_writeable_ranges[] = {
161	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
162	regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
163	regmap_reg_range(DA9063_REG_COUNT_S, DA9063_AD_REG_ALARM_Y),
164	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
165	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
166	regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_AD_REG_MON_REG_4),
167	regmap_reg_range(DA9063_AD_REG_GP_ID_0, DA9063_AD_REG_GP_ID_19),
168};
169
170static const struct regmap_range da9063_ad_volatile_ranges[] = {
171	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_EVENT_D),
172	regmap_reg_range(DA9063_REG_CONTROL_A, DA9063_REG_CONTROL_B),
173	regmap_reg_range(DA9063_REG_CONTROL_E, DA9063_REG_CONTROL_F),
174	regmap_reg_range(DA9063_REG_BCORE2_CONT, DA9063_REG_LDO11_CONT),
175	regmap_reg_range(DA9063_REG_DVC_1, DA9063_REG_ADC_MAN),
176	regmap_reg_range(DA9063_REG_ADC_RES_L, DA9063_AD_REG_SECOND_D),
177	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_SEQ),
178	regmap_reg_range(DA9063_REG_EN_32K, DA9063_REG_EN_32K),
179	regmap_reg_range(DA9063_AD_REG_MON_REG_5, DA9063_AD_REG_MON_REG_6),
180};
181
182static const struct regmap_access_table da9063_ad_readable_table = {
183	.yes_ranges = da9063_ad_readable_ranges,
184	.n_yes_ranges = ARRAY_SIZE(da9063_ad_readable_ranges),
185};
186
187static const struct regmap_access_table da9063_ad_writeable_table = {
188	.yes_ranges = da9063_ad_writeable_ranges,
189	.n_yes_ranges = ARRAY_SIZE(da9063_ad_writeable_ranges),
190};
191
192static const struct regmap_access_table da9063_ad_volatile_table = {
193	.yes_ranges = da9063_ad_volatile_ranges,
194	.n_yes_ranges = ARRAY_SIZE(da9063_ad_volatile_ranges),
195};
196
197static const struct regmap_range da9063_bb_readable_ranges[] = {
198	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_BB_REG_SECOND_D),
199	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
200	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
201	regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_19),
202	regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
203};
204
205static const struct regmap_range da9063_bb_writeable_ranges[] = {
206	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
207	regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
208	regmap_reg_range(DA9063_REG_COUNT_S, DA9063_BB_REG_ALARM_Y),
209	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
210	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
211	regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
212	regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_19),
213};
214
215static const struct regmap_range da9063_bb_da_volatile_ranges[] = {
216	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_EVENT_D),
217	regmap_reg_range(DA9063_REG_CONTROL_A, DA9063_REG_CONTROL_B),
218	regmap_reg_range(DA9063_REG_CONTROL_E, DA9063_REG_CONTROL_F),
219	regmap_reg_range(DA9063_REG_BCORE2_CONT, DA9063_REG_LDO11_CONT),
220	regmap_reg_range(DA9063_REG_DVC_1, DA9063_REG_ADC_MAN),
221	regmap_reg_range(DA9063_REG_ADC_RES_L, DA9063_BB_REG_SECOND_D),
222	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_SEQ),
223	regmap_reg_range(DA9063_REG_EN_32K, DA9063_REG_EN_32K),
224	regmap_reg_range(DA9063_BB_REG_MON_REG_5, DA9063_BB_REG_MON_REG_6),
225};
226
227static const struct regmap_access_table da9063_bb_readable_table = {
228	.yes_ranges = da9063_bb_readable_ranges,
229	.n_yes_ranges = ARRAY_SIZE(da9063_bb_readable_ranges),
230};
231
232static const struct regmap_access_table da9063_bb_writeable_table = {
233	.yes_ranges = da9063_bb_writeable_ranges,
234	.n_yes_ranges = ARRAY_SIZE(da9063_bb_writeable_ranges),
235};
236
237static const struct regmap_access_table da9063_bb_da_volatile_table = {
238	.yes_ranges = da9063_bb_da_volatile_ranges,
239	.n_yes_ranges = ARRAY_SIZE(da9063_bb_da_volatile_ranges),
240};
241
242static const struct regmap_range da9063l_bb_readable_ranges[] = {
243	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_MON_A10_RES),
244	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
245	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
246	regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_19),
247	regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
248};
249
250static const struct regmap_range da9063l_bb_writeable_ranges[] = {
251	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
252	regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
253	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
254	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
255	regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
256	regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_19),
257};
258
259static const struct regmap_range da9063l_bb_da_volatile_ranges[] = {
260	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_EVENT_D),
261	regmap_reg_range(DA9063_REG_CONTROL_A, DA9063_REG_CONTROL_B),
262	regmap_reg_range(DA9063_REG_CONTROL_E, DA9063_REG_CONTROL_F),
263	regmap_reg_range(DA9063_REG_BCORE2_CONT, DA9063_REG_LDO11_CONT),
264	regmap_reg_range(DA9063_REG_DVC_1, DA9063_REG_ADC_MAN),
265	regmap_reg_range(DA9063_REG_ADC_RES_L, DA9063_REG_MON_A10_RES),
266	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_SEQ),
267	regmap_reg_range(DA9063_REG_EN_32K, DA9063_REG_EN_32K),
268	regmap_reg_range(DA9063_BB_REG_MON_REG_5, DA9063_BB_REG_MON_REG_6),
269};
270
271static const struct regmap_access_table da9063l_bb_readable_table = {
272	.yes_ranges = da9063l_bb_readable_ranges,
273	.n_yes_ranges = ARRAY_SIZE(da9063l_bb_readable_ranges),
274};
275
276static const struct regmap_access_table da9063l_bb_writeable_table = {
277	.yes_ranges = da9063l_bb_writeable_ranges,
278	.n_yes_ranges = ARRAY_SIZE(da9063l_bb_writeable_ranges),
279};
280
281static const struct regmap_access_table da9063l_bb_da_volatile_table = {
282	.yes_ranges = da9063l_bb_da_volatile_ranges,
283	.n_yes_ranges = ARRAY_SIZE(da9063l_bb_da_volatile_ranges),
284};
285
286static const struct regmap_range da9063_da_readable_ranges[] = {
287	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_BB_REG_SECOND_D),
288	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
289	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
290	regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_11),
291	regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
292};
293
294static const struct regmap_range da9063_da_writeable_ranges[] = {
295	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
296	regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
297	regmap_reg_range(DA9063_REG_COUNT_S, DA9063_BB_REG_ALARM_Y),
298	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
299	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
300	regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
301	regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_11),
302};
303
304static const struct regmap_access_table da9063_da_readable_table = {
305	.yes_ranges = da9063_da_readable_ranges,
306	.n_yes_ranges = ARRAY_SIZE(da9063_da_readable_ranges),
307};
308
309static const struct regmap_access_table da9063_da_writeable_table = {
310	.yes_ranges = da9063_da_writeable_ranges,
311	.n_yes_ranges = ARRAY_SIZE(da9063_da_writeable_ranges),
312};
313
314static const struct regmap_range da9063l_da_readable_ranges[] = {
315	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_MON_A10_RES),
316	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
317	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
318	regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_11),
319	regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
320};
321
322static const struct regmap_range da9063l_da_writeable_ranges[] = {
323	regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
324	regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
325	regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
326	regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
327	regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
328	regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_11),
329};
330
331static const struct regmap_access_table da9063l_da_readable_table = {
332	.yes_ranges = da9063l_da_readable_ranges,
333	.n_yes_ranges = ARRAY_SIZE(da9063l_da_readable_ranges),
334};
335
336static const struct regmap_access_table da9063l_da_writeable_table = {
337	.yes_ranges = da9063l_da_writeable_ranges,
338	.n_yes_ranges = ARRAY_SIZE(da9063l_da_writeable_ranges),
339};
340
341static const struct regmap_range_cfg da9063_range_cfg[] = {
342	{
343		.range_min = DA9063_REG_PAGE_CON,
344		.range_max = DA9063_REG_CONFIG_ID,
345		.selector_reg = DA9063_REG_PAGE_CON,
346		.selector_mask = 1 << DA9063_I2C_PAGE_SEL_SHIFT,
347		.selector_shift = DA9063_I2C_PAGE_SEL_SHIFT,
348		.window_start = 0,
349		.window_len = 256,
350	}
351};
352
353static struct regmap_config da9063_regmap_config = {
354	.reg_bits = 8,
355	.val_bits = 8,
356	.ranges = da9063_range_cfg,
357	.num_ranges = ARRAY_SIZE(da9063_range_cfg),
358	.max_register = DA9063_REG_CONFIG_ID,
359
360	.cache_type = REGCACHE_MAPLE,
361};
362
363static const struct of_device_id da9063_dt_ids[] = {
364	{ .compatible = "dlg,da9063", },
365	{ .compatible = "dlg,da9063l", },
366	{ }
367};
368MODULE_DEVICE_TABLE(of, da9063_dt_ids);
369static int da9063_i2c_probe(struct i2c_client *i2c)
370{
371	const struct i2c_device_id *id = i2c_client_get_device_id(i2c);
372	struct da9063 *da9063;
373	int ret;
374
375	da9063 = devm_kzalloc(&i2c->dev, sizeof(struct da9063), GFP_KERNEL);
376	if (da9063 == NULL)
377		return -ENOMEM;
378
379	i2c_set_clientdata(i2c, da9063);
380	da9063->dev = &i2c->dev;
381	da9063->chip_irq = i2c->irq;
382	da9063->type = id->driver_data;
383
384	ret = da9063_get_device_type(i2c, da9063);
385	if (ret)
386		return ret;
387
388	switch (da9063->type) {
389	case PMIC_TYPE_DA9063:
390		switch (da9063->variant_code) {
391		case PMIC_DA9063_AD:
392			da9063_regmap_config.rd_table =
393				&da9063_ad_readable_table;
394			da9063_regmap_config.wr_table =
395				&da9063_ad_writeable_table;
396			da9063_regmap_config.volatile_table =
397				&da9063_ad_volatile_table;
398			break;
399		case PMIC_DA9063_BB:
400		case PMIC_DA9063_CA:
401			da9063_regmap_config.rd_table =
402				&da9063_bb_readable_table;
403			da9063_regmap_config.wr_table =
404				&da9063_bb_writeable_table;
405			da9063_regmap_config.volatile_table =
406				&da9063_bb_da_volatile_table;
407			break;
408		case PMIC_DA9063_DA:
409		case PMIC_DA9063_EA:
410			da9063_regmap_config.rd_table =
411				&da9063_da_readable_table;
412			da9063_regmap_config.wr_table =
413				&da9063_da_writeable_table;
414			da9063_regmap_config.volatile_table =
415				&da9063_bb_da_volatile_table;
416			break;
417		default:
418			dev_err(da9063->dev,
419				"Chip variant not supported for DA9063\n");
420			return -ENODEV;
421		}
422		break;
423	case PMIC_TYPE_DA9063L:
424		switch (da9063->variant_code) {
425		case PMIC_DA9063_BB:
426		case PMIC_DA9063_CA:
427			da9063_regmap_config.rd_table =
428				&da9063l_bb_readable_table;
429			da9063_regmap_config.wr_table =
430				&da9063l_bb_writeable_table;
431			da9063_regmap_config.volatile_table =
432				&da9063l_bb_da_volatile_table;
433			break;
434		case PMIC_DA9063_DA:
435		case PMIC_DA9063_EA:
436			da9063_regmap_config.rd_table =
437				&da9063l_da_readable_table;
438			da9063_regmap_config.wr_table =
439				&da9063l_da_writeable_table;
440			da9063_regmap_config.volatile_table =
441				&da9063l_bb_da_volatile_table;
442			break;
443		default:
444			dev_err(da9063->dev,
445				"Chip variant not supported for DA9063L\n");
446			return -ENODEV;
447		}
448		break;
449	default:
450		dev_err(da9063->dev, "Chip type not supported\n");
451		return -ENODEV;
452	}
453
454	da9063->regmap = devm_regmap_init_i2c(i2c, &da9063_regmap_config);
455	if (IS_ERR(da9063->regmap)) {
456		ret = PTR_ERR(da9063->regmap);
457		dev_err(da9063->dev, "Failed to allocate register map: %d\n",
458			ret);
459		return ret;
460	}
461
462	/* If SMBus is not available and only I2C is possible, enter I2C mode */
463	if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C)) {
464		ret = regmap_clear_bits(da9063->regmap, DA9063_REG_CONFIG_J,
465					DA9063_TWOWIRE_TO);
466		if (ret < 0) {
467			dev_err(da9063->dev, "Failed to set Two-Wire Bus Mode.\n");
468			return ret;
469		}
470	}
471
472	/* Reserve our unused second address so userspace won't interfere */
473	devm_i2c_new_dummy_device(&i2c->dev, i2c->adapter, i2c->addr + 1);
474
475	return da9063_device_init(da9063, i2c->irq);
476}
477
478static const struct i2c_device_id da9063_i2c_id[] = {
479	{ "da9063", PMIC_TYPE_DA9063 },
480	{ "da9063l", PMIC_TYPE_DA9063L },
481	{},
482};
483MODULE_DEVICE_TABLE(i2c, da9063_i2c_id);
484
485static struct i2c_driver da9063_i2c_driver = {
486	.driver = {
487		.name = "da9063",
488		.of_match_table = da9063_dt_ids,
489	},
490	.probe = da9063_i2c_probe,
491	.id_table = da9063_i2c_id,
492};
493
494module_i2c_driver(da9063_i2c_driver);