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