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
34 enum 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
40 enum da9063_page_sel_msgs {
41 DA9063_PAGE_SEL_MSG = 0,
42 DA9063_PAGE_SEL_CNT,
43 };
44
45 enum 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
da9063_i2c_blockreg_read(struct i2c_client * client,u16 addr,u8 * buf,int count)51 static 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
114 enum {
115 DA9063_DEV_ID_REG = 0,
116 DA9063_VAR_ID_REG,
117 DA9063_CHIP_ID_REGS,
118 };
119
da9063_get_device_type(struct i2c_client * i2c,struct da9063 * da9063)120 static 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
152 static 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
160 static 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
170 static 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
182 static 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
187 static 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
192 static 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
197 static 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
205 static 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
215 static 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
227 static 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
232 static 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
237 static 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
242 static 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
250 static 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
259 static 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
271 static 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
276 static 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
281 static 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
286 static 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
294 static 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
304 static 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
309 static 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
314 static 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
322 static 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
331 static 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
336 static 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
341 static 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
353 static 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
363 static const struct of_device_id da9063_dt_ids[] = {
364 { .compatible = "dlg,da9063", },
365 { .compatible = "dlg,da9063l", },
366 { }
367 };
368 MODULE_DEVICE_TABLE(of, da9063_dt_ids);
da9063_i2c_probe(struct i2c_client * i2c)369 static 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
478 static const struct i2c_device_id da9063_i2c_id[] = {
479 { "da9063", PMIC_TYPE_DA9063 },
480 { "da9063l", PMIC_TYPE_DA9063L },
481 {},
482 };
483 MODULE_DEVICE_TABLE(i2c, da9063_i2c_id);
484
485 static 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
494 module_i2c_driver(da9063_i2c_driver);
495