drivers/mfd/da9063-i2c.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /* I2C support for Dialog DA9063
0003  *
0004  * Copyright 2012 Dialog Semiconductor Ltd.
0005  * Copyright 2013 Philipp Zabel, Pengutronix
0006  *
0007  * Author: Krystian Garbaciak, Dialog Semiconductor
0008  */
0009
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/i2c.h>
0013 #include <linux/regmap.h>
0014 #include <linux/delay.h>
0015 #include <linux/slab.h>
0016 #include <linux/err.h>
0017
0018 #include <linux/mfd/core.h>
0019 #include <linux/mfd/da9063/core.h>
0020 #include <linux/mfd/da9063/registers.h>
0021
0022 #include <linux/of.h>
0023 #include <linux/regulator/of_regulator.h>
0024
0025 /*
0026  * Raw I2C access required for just accessing chip and variant info before we
0027  * know which device is present. The info read from the device using this
0028  * approach is then used to select the correct regmap tables.
0029  */
0030
0031 #define DA9063_REG_PAGE_SIZE        0x100
0032 #define DA9063_REG_PAGED_ADDR_MASK  0xFF
0033
0034 enum da9063_page_sel_buf_fmt {
0035     DA9063_PAGE_SEL_BUF_PAGE_REG = 0,
0036     DA9063_PAGE_SEL_BUF_PAGE_VAL,
0037     DA9063_PAGE_SEL_BUF_SIZE,
0038 };
0039
0040 enum da9063_paged_read_msgs {
0041     DA9063_PAGED_READ_MSG_PAGE_SEL = 0,
0042     DA9063_PAGED_READ_MSG_REG_SEL,
0043     DA9063_PAGED_READ_MSG_DATA,
0044     DA9063_PAGED_READ_MSG_CNT,
0045 };
0046
0047 static int da9063_i2c_blockreg_read(struct i2c_client *client, u16 addr,
0048                     u8 *buf, int count)
0049 {
0050     struct i2c_msg xfer[DA9063_PAGED_READ_MSG_CNT];
0051     u8 page_sel_buf[DA9063_PAGE_SEL_BUF_SIZE];
0052     u8 page_num, paged_addr;
0053     int ret;
0054
0055     /* Determine page info based on register address */
0056     page_num = (addr / DA9063_REG_PAGE_SIZE);
0057     if (page_num > 1) {
0058         dev_err(&client->dev, "Invalid register address provided\n");
0059         return -EINVAL;
0060     }
0061
0062     paged_addr = (addr % DA9063_REG_PAGE_SIZE) & DA9063_REG_PAGED_ADDR_MASK;
0063     page_sel_buf[DA9063_PAGE_SEL_BUF_PAGE_REG] = DA9063_REG_PAGE_CON;
0064     page_sel_buf[DA9063_PAGE_SEL_BUF_PAGE_VAL] =
0065         (page_num << DA9063_I2C_PAGE_SEL_SHIFT) & DA9063_REG_PAGE_MASK;
0066
0067     /* Write reg address, page selection */
0068     xfer[DA9063_PAGED_READ_MSG_PAGE_SEL].addr = client->addr;
0069     xfer[DA9063_PAGED_READ_MSG_PAGE_SEL].flags = 0;
0070     xfer[DA9063_PAGED_READ_MSG_PAGE_SEL].len = DA9063_PAGE_SEL_BUF_SIZE;
0071     xfer[DA9063_PAGED_READ_MSG_PAGE_SEL].buf = page_sel_buf;
0072
0073     /* Select register address */
0074     xfer[DA9063_PAGED_READ_MSG_REG_SEL].addr = client->addr;
0075     xfer[DA9063_PAGED_READ_MSG_REG_SEL].flags = 0;
0076     xfer[DA9063_PAGED_READ_MSG_REG_SEL].len = sizeof(paged_addr);
0077     xfer[DA9063_PAGED_READ_MSG_REG_SEL].buf = &paged_addr;
0078
0079     /* Read data */
0080     xfer[DA9063_PAGED_READ_MSG_DATA].addr = client->addr;
0081     xfer[DA9063_PAGED_READ_MSG_DATA].flags = I2C_M_RD;
0082     xfer[DA9063_PAGED_READ_MSG_DATA].len = count;
0083     xfer[DA9063_PAGED_READ_MSG_DATA].buf = buf;
0084
0085     ret = i2c_transfer(client->adapter, xfer, DA9063_PAGED_READ_MSG_CNT);
0086     if (ret < 0) {
0087         dev_err(&client->dev, "Paged block read failed: %d\n", ret);
0088         return ret;
0089     }
0090
0091     if (ret != DA9063_PAGED_READ_MSG_CNT) {
0092         dev_err(&client->dev, "Paged block read failed to complete\n");
0093         return -EIO;
0094     }
0095
0096     return 0;
0097 }
0098
0099 enum {
0100     DA9063_DEV_ID_REG = 0,
0101     DA9063_VAR_ID_REG,
0102     DA9063_CHIP_ID_REGS,
0103 };
0104
0105 static int da9063_get_device_type(struct i2c_client *i2c, struct da9063 *da9063)
0106 {
0107     u8 buf[DA9063_CHIP_ID_REGS];
0108     int ret;
0109
0110     ret = da9063_i2c_blockreg_read(i2c, DA9063_REG_DEVICE_ID, buf,
0111                        DA9063_CHIP_ID_REGS);
0112     if (ret)
0113         return ret;
0114
0115     if (buf[DA9063_DEV_ID_REG] != PMIC_CHIP_ID_DA9063) {
0116         dev_err(da9063->dev,
0117             "Invalid chip device ID: 0x%02x\n",
0118             buf[DA9063_DEV_ID_REG]);
0119         return -ENODEV;
0120     }
0121
0122     dev_info(da9063->dev,
0123          "Device detected (chip-ID: 0x%02X, var-ID: 0x%02X)\n",
0124          buf[DA9063_DEV_ID_REG], buf[DA9063_VAR_ID_REG]);
0125
0126     da9063->variant_code =
0127         (buf[DA9063_VAR_ID_REG] & DA9063_VARIANT_ID_MRC_MASK)
0128         >> DA9063_VARIANT_ID_MRC_SHIFT;
0129
0130     return 0;
0131 }
0132
0133 /*
0134  * Variant specific regmap configs
0135  */
0136
0137 static const struct regmap_range da9063_ad_readable_ranges[] = {
0138     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_AD_REG_SECOND_D),
0139     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0140     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0141     regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_AD_REG_GP_ID_19),
0142     regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
0143 };
0144
0145 static const struct regmap_range da9063_ad_writeable_ranges[] = {
0146     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
0147     regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
0148     regmap_reg_range(DA9063_REG_COUNT_S, DA9063_AD_REG_ALARM_Y),
0149     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0150     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0151     regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_AD_REG_MON_REG_4),
0152     regmap_reg_range(DA9063_AD_REG_GP_ID_0, DA9063_AD_REG_GP_ID_19),
0153 };
0154
0155 static const struct regmap_range da9063_ad_volatile_ranges[] = {
0156     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_EVENT_D),
0157     regmap_reg_range(DA9063_REG_CONTROL_A, DA9063_REG_CONTROL_B),
0158     regmap_reg_range(DA9063_REG_CONTROL_E, DA9063_REG_CONTROL_F),
0159     regmap_reg_range(DA9063_REG_BCORE2_CONT, DA9063_REG_LDO11_CONT),
0160     regmap_reg_range(DA9063_REG_DVC_1, DA9063_REG_ADC_MAN),
0161     regmap_reg_range(DA9063_REG_ADC_RES_L, DA9063_AD_REG_SECOND_D),
0162     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_SEQ),
0163     regmap_reg_range(DA9063_REG_EN_32K, DA9063_REG_EN_32K),
0164     regmap_reg_range(DA9063_AD_REG_MON_REG_5, DA9063_AD_REG_MON_REG_6),
0165 };
0166
0167 static const struct regmap_access_table da9063_ad_readable_table = {
0168     .yes_ranges = da9063_ad_readable_ranges,
0169     .n_yes_ranges = ARRAY_SIZE(da9063_ad_readable_ranges),
0170 };
0171
0172 static const struct regmap_access_table da9063_ad_writeable_table = {
0173     .yes_ranges = da9063_ad_writeable_ranges,
0174     .n_yes_ranges = ARRAY_SIZE(da9063_ad_writeable_ranges),
0175 };
0176
0177 static const struct regmap_access_table da9063_ad_volatile_table = {
0178     .yes_ranges = da9063_ad_volatile_ranges,
0179     .n_yes_ranges = ARRAY_SIZE(da9063_ad_volatile_ranges),
0180 };
0181
0182 static const struct regmap_range da9063_bb_readable_ranges[] = {
0183     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_BB_REG_SECOND_D),
0184     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0185     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0186     regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_19),
0187     regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
0188 };
0189
0190 static const struct regmap_range da9063_bb_writeable_ranges[] = {
0191     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
0192     regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
0193     regmap_reg_range(DA9063_REG_COUNT_S, DA9063_BB_REG_ALARM_Y),
0194     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0195     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0196     regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
0197     regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_19),
0198 };
0199
0200 static const struct regmap_range da9063_bb_da_volatile_ranges[] = {
0201     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_EVENT_D),
0202     regmap_reg_range(DA9063_REG_CONTROL_A, DA9063_REG_CONTROL_B),
0203     regmap_reg_range(DA9063_REG_CONTROL_E, DA9063_REG_CONTROL_F),
0204     regmap_reg_range(DA9063_REG_BCORE2_CONT, DA9063_REG_LDO11_CONT),
0205     regmap_reg_range(DA9063_REG_DVC_1, DA9063_REG_ADC_MAN),
0206     regmap_reg_range(DA9063_REG_ADC_RES_L, DA9063_BB_REG_SECOND_D),
0207     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_SEQ),
0208     regmap_reg_range(DA9063_REG_EN_32K, DA9063_REG_EN_32K),
0209     regmap_reg_range(DA9063_BB_REG_MON_REG_5, DA9063_BB_REG_MON_REG_6),
0210 };
0211
0212 static const struct regmap_access_table da9063_bb_readable_table = {
0213     .yes_ranges = da9063_bb_readable_ranges,
0214     .n_yes_ranges = ARRAY_SIZE(da9063_bb_readable_ranges),
0215 };
0216
0217 static const struct regmap_access_table da9063_bb_writeable_table = {
0218     .yes_ranges = da9063_bb_writeable_ranges,
0219     .n_yes_ranges = ARRAY_SIZE(da9063_bb_writeable_ranges),
0220 };
0221
0222 static const struct regmap_access_table da9063_bb_da_volatile_table = {
0223     .yes_ranges = da9063_bb_da_volatile_ranges,
0224     .n_yes_ranges = ARRAY_SIZE(da9063_bb_da_volatile_ranges),
0225 };
0226
0227 static const struct regmap_range da9063l_bb_readable_ranges[] = {
0228     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_MON_A10_RES),
0229     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0230     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0231     regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_19),
0232     regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
0233 };
0234
0235 static const struct regmap_range da9063l_bb_writeable_ranges[] = {
0236     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
0237     regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
0238     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0239     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0240     regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
0241     regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_19),
0242 };
0243
0244 static const struct regmap_range da9063l_bb_da_volatile_ranges[] = {
0245     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_EVENT_D),
0246     regmap_reg_range(DA9063_REG_CONTROL_A, DA9063_REG_CONTROL_B),
0247     regmap_reg_range(DA9063_REG_CONTROL_E, DA9063_REG_CONTROL_F),
0248     regmap_reg_range(DA9063_REG_BCORE2_CONT, DA9063_REG_LDO11_CONT),
0249     regmap_reg_range(DA9063_REG_DVC_1, DA9063_REG_ADC_MAN),
0250     regmap_reg_range(DA9063_REG_ADC_RES_L, DA9063_REG_MON_A10_RES),
0251     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_SEQ),
0252     regmap_reg_range(DA9063_REG_EN_32K, DA9063_REG_EN_32K),
0253     regmap_reg_range(DA9063_BB_REG_MON_REG_5, DA9063_BB_REG_MON_REG_6),
0254 };
0255
0256 static const struct regmap_access_table da9063l_bb_readable_table = {
0257     .yes_ranges = da9063l_bb_readable_ranges,
0258     .n_yes_ranges = ARRAY_SIZE(da9063l_bb_readable_ranges),
0259 };
0260
0261 static const struct regmap_access_table da9063l_bb_writeable_table = {
0262     .yes_ranges = da9063l_bb_writeable_ranges,
0263     .n_yes_ranges = ARRAY_SIZE(da9063l_bb_writeable_ranges),
0264 };
0265
0266 static const struct regmap_access_table da9063l_bb_da_volatile_table = {
0267     .yes_ranges = da9063l_bb_da_volatile_ranges,
0268     .n_yes_ranges = ARRAY_SIZE(da9063l_bb_da_volatile_ranges),
0269 };
0270
0271 static const struct regmap_range da9063_da_readable_ranges[] = {
0272     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_BB_REG_SECOND_D),
0273     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0274     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0275     regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_11),
0276     regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
0277 };
0278
0279 static const struct regmap_range da9063_da_writeable_ranges[] = {
0280     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
0281     regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
0282     regmap_reg_range(DA9063_REG_COUNT_S, DA9063_BB_REG_ALARM_Y),
0283     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0284     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0285     regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
0286     regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_11),
0287 };
0288
0289 static const struct regmap_access_table da9063_da_readable_table = {
0290     .yes_ranges = da9063_da_readable_ranges,
0291     .n_yes_ranges = ARRAY_SIZE(da9063_da_readable_ranges),
0292 };
0293
0294 static const struct regmap_access_table da9063_da_writeable_table = {
0295     .yes_ranges = da9063_da_writeable_ranges,
0296     .n_yes_ranges = ARRAY_SIZE(da9063_da_writeable_ranges),
0297 };
0298
0299 static const struct regmap_range da9063l_da_readable_ranges[] = {
0300     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_MON_A10_RES),
0301     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0302     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0303     regmap_reg_range(DA9063_REG_T_OFFSET, DA9063_BB_REG_GP_ID_11),
0304     regmap_reg_range(DA9063_REG_DEVICE_ID, DA9063_REG_VARIANT_ID),
0305 };
0306
0307 static const struct regmap_range da9063l_da_writeable_ranges[] = {
0308     regmap_reg_range(DA9063_REG_PAGE_CON, DA9063_REG_PAGE_CON),
0309     regmap_reg_range(DA9063_REG_FAULT_LOG, DA9063_REG_VSYS_MON),
0310     regmap_reg_range(DA9063_REG_SEQ, DA9063_REG_ID_32_31),
0311     regmap_reg_range(DA9063_REG_SEQ_A, DA9063_REG_AUTO3_LOW),
0312     regmap_reg_range(DA9063_REG_CONFIG_I, DA9063_BB_REG_MON_REG_4),
0313     regmap_reg_range(DA9063_BB_REG_GP_ID_0, DA9063_BB_REG_GP_ID_11),
0314 };
0315
0316 static const struct regmap_access_table da9063l_da_readable_table = {
0317     .yes_ranges = da9063l_da_readable_ranges,
0318     .n_yes_ranges = ARRAY_SIZE(da9063l_da_readable_ranges),
0319 };
0320
0321 static const struct regmap_access_table da9063l_da_writeable_table = {
0322     .yes_ranges = da9063l_da_writeable_ranges,
0323     .n_yes_ranges = ARRAY_SIZE(da9063l_da_writeable_ranges),
0324 };
0325
0326 static const struct regmap_range_cfg da9063_range_cfg[] = {
0327     {
0328         .range_min = DA9063_REG_PAGE_CON,
0329         .range_max = DA9063_REG_CONFIG_ID,
0330         .selector_reg = DA9063_REG_PAGE_CON,
0331         .selector_mask = 1 << DA9063_I2C_PAGE_SEL_SHIFT,
0332         .selector_shift = DA9063_I2C_PAGE_SEL_SHIFT,
0333         .window_start = 0,
0334         .window_len = 256,
0335     }
0336 };
0337
0338 static struct regmap_config da9063_regmap_config = {
0339     .reg_bits = 8,
0340     .val_bits = 8,
0341     .ranges = da9063_range_cfg,
0342     .num_ranges = ARRAY_SIZE(da9063_range_cfg),
0343     .max_register = DA9063_REG_CONFIG_ID,
0344
0345     .cache_type = REGCACHE_RBTREE,
0346 };
0347
0348 static const struct of_device_id da9063_dt_ids[] = {
0349     { .compatible = "dlg,da9063", },
0350     { .compatible = "dlg,da9063l", },
0351     { }
0352 };
0353 MODULE_DEVICE_TABLE(of, da9063_dt_ids);
0354 static int da9063_i2c_probe(struct i2c_client *i2c,
0355                 const struct i2c_device_id *id)
0356 {
0357     struct da9063 *da9063;
0358     int ret;
0359
0360     da9063 = devm_kzalloc(&i2c->dev, sizeof(struct da9063), GFP_KERNEL);
0361     if (da9063 == NULL)
0362         return -ENOMEM;
0363
0364     i2c_set_clientdata(i2c, da9063);
0365     da9063->dev = &i2c->dev;
0366     da9063->chip_irq = i2c->irq;
0367     da9063->type = id->driver_data;
0368
0369     ret = da9063_get_device_type(i2c, da9063);
0370     if (ret)
0371         return ret;
0372
0373     switch (da9063->type) {
0374     case PMIC_TYPE_DA9063:
0375         switch (da9063->variant_code) {
0376         case PMIC_DA9063_AD:
0377             da9063_regmap_config.rd_table =
0378                 &da9063_ad_readable_table;
0379             da9063_regmap_config.wr_table =
0380                 &da9063_ad_writeable_table;
0381             da9063_regmap_config.volatile_table =
0382                 &da9063_ad_volatile_table;
0383             break;
0384         case PMIC_DA9063_BB:
0385         case PMIC_DA9063_CA:
0386             da9063_regmap_config.rd_table =
0387                 &da9063_bb_readable_table;
0388             da9063_regmap_config.wr_table =
0389                 &da9063_bb_writeable_table;
0390             da9063_regmap_config.volatile_table =
0391                 &da9063_bb_da_volatile_table;
0392             break;
0393         case PMIC_DA9063_DA:
0394         case PMIC_DA9063_EA:
0395             da9063_regmap_config.rd_table =
0396                 &da9063_da_readable_table;
0397             da9063_regmap_config.wr_table =
0398                 &da9063_da_writeable_table;
0399             da9063_regmap_config.volatile_table =
0400                 &da9063_bb_da_volatile_table;
0401             break;
0402         default:
0403             dev_err(da9063->dev,
0404                 "Chip variant not supported for DA9063\n");
0405             return -ENODEV;
0406         }
0407         break;
0408     case PMIC_TYPE_DA9063L:
0409         switch (da9063->variant_code) {
0410         case PMIC_DA9063_BB:
0411         case PMIC_DA9063_CA:
0412             da9063_regmap_config.rd_table =
0413                 &da9063l_bb_readable_table;
0414             da9063_regmap_config.wr_table =
0415                 &da9063l_bb_writeable_table;
0416             da9063_regmap_config.volatile_table =
0417                 &da9063l_bb_da_volatile_table;
0418             break;
0419         case PMIC_DA9063_DA:
0420         case PMIC_DA9063_EA:
0421             da9063_regmap_config.rd_table =
0422                 &da9063l_da_readable_table;
0423             da9063_regmap_config.wr_table =
0424                 &da9063l_da_writeable_table;
0425             da9063_regmap_config.volatile_table =
0426                 &da9063l_bb_da_volatile_table;
0427             break;
0428         default:
0429             dev_err(da9063->dev,
0430                 "Chip variant not supported for DA9063L\n");
0431             return -ENODEV;
0432         }
0433         break;
0434     default:
0435         dev_err(da9063->dev, "Chip type not supported\n");
0436         return -ENODEV;
0437     }
0438
0439     da9063->regmap = devm_regmap_init_i2c(i2c, &da9063_regmap_config);
0440     if (IS_ERR(da9063->regmap)) {
0441         ret = PTR_ERR(da9063->regmap);
0442         dev_err(da9063->dev, "Failed to allocate register map: %d\n",
0443             ret);
0444         return ret;
0445     }
0446
0447     /* If SMBus is not available and only I2C is possible, enter I2C mode */
0448     if (i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C)) {
0449         ret = regmap_clear_bits(da9063->regmap, DA9063_REG_CONFIG_J,
0450                     DA9063_TWOWIRE_TO);
0451         if (ret < 0) {
0452             dev_err(da9063->dev, "Failed to set Two-Wire Bus Mode.\n");
0453             return ret;
0454         }
0455     }
0456
0457     return da9063_device_init(da9063, i2c->irq);
0458 }
0459
0460 static const struct i2c_device_id da9063_i2c_id[] = {
0461     { "da9063", PMIC_TYPE_DA9063 },
0462     { "da9063l", PMIC_TYPE_DA9063L },
0463     {},
0464 };
0465 MODULE_DEVICE_TABLE(i2c, da9063_i2c_id);
0466
0467 static struct i2c_driver da9063_i2c_driver = {
0468     .driver = {
0469         .name = "da9063",
0470         .of_match_table = da9063_dt_ids,
0471     },
0472     .probe    = da9063_i2c_probe,
0473     .id_table = da9063_i2c_id,
0474 };
0475
0476 module_i2c_driver(da9063_i2c_driver);