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 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 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); 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 return da9063_device_init(da9063, i2c->irq); 473 } 474 475 static const struct i2c_device_id da9063_i2c_id[] = { 476 { "da9063", PMIC_TYPE_DA9063 }, 477 { "da9063l", PMIC_TYPE_DA9063L }, 478 {}, 479 }; 480 MODULE_DEVICE_TABLE(i2c, da9063_i2c_id); 481 482 static struct i2c_driver da9063_i2c_driver = { 483 .driver = { 484 .name = "da9063", 485 .of_match_table = da9063_dt_ids, 486 }, 487 .probe = da9063_i2c_probe, 488 .id_table = da9063_i2c_id, 489 }; 490 491 module_i2c_driver(da9063_i2c_driver); 492