drivers/power/supply/ucs1002_power.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Driver for UCS1002 Programmable USB Port Power Controller
   4  *
   5  * Copyright (C) 2019 Zodiac Inflight Innovations
   6  */
   7 #include <linux/bits.h>
   8 #include <linux/freezer.h>
   9 #include <linux/gpio/consumer.h>
  10 #include <linux/i2c.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/kernel.h>
  13 #include <linux/kthread.h>
  14 #include <linux/device.h>
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <linux/of_irq.h>
  18 #include <linux/power_supply.h>
  19 #include <linux/regmap.h>
  20 #include <linux/regulator/driver.h>
  21 #include <linux/regulator/of_regulator.h>
  22
  23 /* UCS1002 Registers */
  24 #define UCS1002_REG_CURRENT_MEASUREMENT 0x00
  25
  26 /*
  27  * The Total Accumulated Charge registers store the total accumulated
  28  * charge delivered from the VS source to a portable device. The total
  29  * value is calculated using four registers, from 01h to 04h. The bit
  30  * weighting of the registers is given in mA/hrs.
  31  */
  32 #define UCS1002_REG_TOTAL_ACC_CHARGE    0x01
  33
  34 /* Other Status Register */
  35 #define UCS1002_REG_OTHER_STATUS        0x0f
  36 #  define F_ADET_PIN                    BIT(4)
  37 #  define F_CHG_ACT                     BIT(3)
  38
  39 /* Interrupt Status */
  40 #define UCS1002_REG_INTERRUPT_STATUS    0x10
  41 #  define F_DISCHARGE_ERR               BIT(6)
  42 #  define F_RESET                       BIT(5)
  43 #  define F_MIN_KEEP_OUT                BIT(4)
  44 #  define F_TSD                         BIT(3)
  45 #  define F_OVER_VOLT                   BIT(2)
  46 #  define F_BACK_VOLT                   BIT(1)
  47 #  define F_OVER_ILIM                   BIT(0)
  48
  49 /* Pin Status Register */
  50 #define UCS1002_REG_PIN_STATUS          0x14
  51 #  define UCS1002_PWR_STATE_MASK        0x03
  52 #  define F_PWR_EN_PIN                  BIT(6)
  53 #  define F_M2_PIN                      BIT(5)
  54 #  define F_M1_PIN                      BIT(4)
  55 #  define F_EM_EN_PIN                   BIT(3)
  56 #  define F_SEL_PIN                     BIT(2)
  57 #  define F_ACTIVE_MODE_MASK            GENMASK(5, 3)
  58 #  define F_ACTIVE_MODE_PASSTHROUGH     F_M2_PIN
  59 #  define F_ACTIVE_MODE_DEDICATED       F_EM_EN_PIN
  60 #  define F_ACTIVE_MODE_BC12_DCP        (F_M2_PIN | F_EM_EN_PIN)
  61 #  define F_ACTIVE_MODE_BC12_SDP        F_M1_PIN
  62 #  define F_ACTIVE_MODE_BC12_CDP        (F_M1_PIN | F_M2_PIN | F_EM_EN_PIN)
  63
  64 /* General Configuration Register */
  65 #define UCS1002_REG_GENERAL_CFG         0x15
  66 #  define F_RATION_EN                   BIT(3)
  67
  68 /* Emulation Configuration Register */
  69 #define UCS1002_REG_EMU_CFG             0x16
  70
  71 /* Switch Configuration Register */
  72 #define UCS1002_REG_SWITCH_CFG          0x17
  73 #  define F_PIN_IGNORE                  BIT(7)
  74 #  define F_EM_EN_SET                   BIT(5)
  75 #  define F_M2_SET                      BIT(4)
  76 #  define F_M1_SET                      BIT(3)
  77 #  define F_S0_SET                      BIT(2)
  78 #  define F_PWR_EN_SET                  BIT(1)
  79 #  define F_LATCH_SET                   BIT(0)
  80 #  define V_SET_ACTIVE_MODE_MASK        GENMASK(5, 3)
  81 #  define V_SET_ACTIVE_MODE_PASSTHROUGH F_M2_SET
  82 #  define V_SET_ACTIVE_MODE_DEDICATED   F_EM_EN_SET
  83 #  define V_SET_ACTIVE_MODE_BC12_DCP    (F_M2_SET | F_EM_EN_SET)
  84 #  define V_SET_ACTIVE_MODE_BC12_SDP    F_M1_SET
  85 #  define V_SET_ACTIVE_MODE_BC12_CDP    (F_M1_SET | F_M2_SET | F_EM_EN_SET)
  86
  87 /* Current Limit Register */
  88 #define UCS1002_REG_ILIMIT              0x19
  89 #  define UCS1002_ILIM_SW_MASK          GENMASK(3, 0)
  90
  91 /* Product ID */
  92 #define UCS1002_REG_PRODUCT_ID          0xfd
  93 #  define UCS1002_PRODUCT_ID            0x4e
  94
  95 /* Manufacture name */
  96 #define UCS1002_MANUFACTURER            "SMSC"
  97
  98 struct ucs1002_info {
  99         struct power_supply *charger;
 100         struct i2c_client *client;
 101         struct regmap *regmap;
 102         struct regulator_desc *regulator_descriptor;
 103         bool present;
 104 };
 105
 106 static enum power_supply_property ucs1002_props[] = {
 107         POWER_SUPPLY_PROP_ONLINE,
 108         POWER_SUPPLY_PROP_CHARGE_NOW,
 109         POWER_SUPPLY_PROP_CURRENT_NOW,
 110         POWER_SUPPLY_PROP_CURRENT_MAX,
 111         POWER_SUPPLY_PROP_PRESENT, /* the presence of PED */
 112         POWER_SUPPLY_PROP_MANUFACTURER,
 113         POWER_SUPPLY_PROP_USB_TYPE,
 114         POWER_SUPPLY_PROP_HEALTH,
 115 };
 116
 117 static int ucs1002_get_online(struct ucs1002_info *info,
 118                               union power_supply_propval *val)
 119 {
 120         unsigned int reg;
 121         int ret;
 122
 123         ret = regmap_read(info->regmap, UCS1002_REG_OTHER_STATUS, &reg);
 124         if (ret)
 125                 return ret;
 126
 127         val->intval = !!(reg & F_CHG_ACT);
 128
 129         return 0;
 130 }
 131
 132 static int ucs1002_get_charge(struct ucs1002_info *info,
 133                               union power_supply_propval *val)
 134 {
 135         /*
 136          * To fit within 32 bits some values are rounded (uA/h)
 137          *
 138          * For Total Accumulated Charge Middle Low Byte register, addr
 139          * 03h, byte 2
 140          *
 141          *   B0: 0.01084 mA/h rounded to 11 uA/h
 142          *   B1: 0.02169 mA/h rounded to 22 uA/h
 143          *   B2: 0.04340 mA/h rounded to 43 uA/h
 144          *   B3: 0.08676 mA/h rounded to 87 uA/h
 145          *   B4: 0.17350 mA/h rounded to 173 uÁ/h
 146          *
 147          * For Total Accumulated Charge Low Byte register, addr 04h,
 148          * byte 3
 149          *
 150          *   B6: 0.00271 mA/h rounded to 3 uA/h
 151          *   B7: 0.005422 mA/h rounded to 5 uA/h
 152          */
 153         static const int bit_weights_uAh[BITS_PER_TYPE(u32)] = {
 154                 /*
 155                  * Bit corresponding to low byte (offset 0x04)
 156                  * B0 B1 B2 B3 B4 B5 B6 B7
 157                  */
 158                 0, 0, 0, 0, 0, 0, 3, 5,
 159                 /*
 160                  * Bit corresponding to middle low byte (offset 0x03)
 161                  * B0 B1 B2 B3 B4 B5 B6 B7
 162                  */
 163                 11, 22, 43, 87, 173, 347, 694, 1388,
 164                 /*
 165                  * Bit corresponding to middle high byte (offset 0x02)
 166                  * B0 B1 B2 B3 B4 B5 B6 B7
 167                  */
 168                 2776, 5552, 11105, 22210, 44420, 88840, 177700, 355400,
 169                 /*
 170                  * Bit corresponding to high byte (offset 0x01)
 171                  * B0 B1 B2 B3 B4 B5 B6 B7
 172                  */
 173                 710700, 1421000, 2843000, 5685000, 11371000, 22742000,
 174                 45484000, 90968000,
 175         };
 176         unsigned long total_acc_charger;
 177         unsigned int reg;
 178         int i, ret;
 179
 180         ret = regmap_bulk_read(info->regmap, UCS1002_REG_TOTAL_ACC_CHARGE,
 181                                &reg, sizeof(u32));
 182         if (ret)
 183                 return ret;
 184
 185         total_acc_charger = be32_to_cpu(reg); /* BE as per offsets above */
 186         val->intval = 0;
 187
 188         for_each_set_bit(i, &total_acc_charger, ARRAY_SIZE(bit_weights_uAh))
 189                 val->intval += bit_weights_uAh[i];
 190
 191         return 0;
 192 }
 193
 194 static int ucs1002_get_current(struct ucs1002_info *info,
 195                                union power_supply_propval *val)
 196 {
 197         /*
 198          * The Current Measurement register stores the measured
 199          * current value delivered to the portable device. The range
 200          * is from 9.76 mA to 2.5 A.
 201          */
 202         static const int bit_weights_uA[BITS_PER_TYPE(u8)] = {
 203                 9760, 19500, 39000, 78100, 156200, 312300, 624600, 1249300,
 204         };
 205         unsigned long current_measurement;
 206         unsigned int reg;
 207         int i, ret;
 208
 209         ret = regmap_read(info->regmap, UCS1002_REG_CURRENT_MEASUREMENT, &reg);
 210         if (ret)
 211                 return ret;
 212
 213         current_measurement = reg;
 214         val->intval = 0;
 215
 216         for_each_set_bit(i, &current_measurement, ARRAY_SIZE(bit_weights_uA))
 217                 val->intval += bit_weights_uA[i];
 218
 219         return 0;
 220 }
 221
 222 /*
 223  * The Current Limit register stores the maximum current used by the
 224  * port switch. The range is from 500mA to 2.5 A.
 225  */
 226 static const u32 ucs1002_current_limit_uA[] = {
 227         500000, 900000, 1000000, 1200000, 1500000, 1800000, 2000000, 2500000,
 228 };
 229
 230 static int ucs1002_get_max_current(struct ucs1002_info *info,
 231                                    union power_supply_propval *val)
 232 {
 233         unsigned int reg;
 234         int ret;
 235
 236         ret = regmap_read(info->regmap, UCS1002_REG_ILIMIT, &reg);
 237         if (ret)
 238                 return ret;
 239
 240         val->intval = ucs1002_current_limit_uA[reg & UCS1002_ILIM_SW_MASK];
 241
 242         return 0;
 243 }
 244
 245 static int ucs1002_set_max_current(struct ucs1002_info *info, u32 val)
 246 {
 247         unsigned int reg;
 248         int ret, idx;
 249
 250         for (idx = 0; idx < ARRAY_SIZE(ucs1002_current_limit_uA); idx++) {
 251                 if (val == ucs1002_current_limit_uA[idx])
 252                         break;
 253         }
 254
 255         if (idx == ARRAY_SIZE(ucs1002_current_limit_uA))
 256                 return -EINVAL;
 257
 258         ret = regmap_write(info->regmap, UCS1002_REG_ILIMIT, idx);
 259         if (ret)
 260                 return ret;
 261         /*
 262          * Any current limit setting exceeding the one set via ILIM
 263          * pin will be rejected, so we read out freshly changed limit
 264          * to make sure that it took effect.
 265          */
 266         ret = regmap_read(info->regmap, UCS1002_REG_ILIMIT, &reg);
 267         if (ret)
 268                 return ret;
 269
 270         if (reg != idx)
 271                 return -EINVAL;
 272
 273         return 0;
 274 }
 275
 276 static enum power_supply_usb_type ucs1002_usb_types[] = {
 277         POWER_SUPPLY_USB_TYPE_PD,
 278         POWER_SUPPLY_USB_TYPE_SDP,
 279         POWER_SUPPLY_USB_TYPE_DCP,
 280         POWER_SUPPLY_USB_TYPE_CDP,
 281         POWER_SUPPLY_USB_TYPE_UNKNOWN,
 282 };
 283
 284 static int ucs1002_set_usb_type(struct ucs1002_info *info, int val)
 285 {
 286         unsigned int mode;
 287
 288         if (val < 0 || val >= ARRAY_SIZE(ucs1002_usb_types))
 289                 return -EINVAL;
 290
 291         switch (ucs1002_usb_types[val]) {
 292         case POWER_SUPPLY_USB_TYPE_PD:
 293                 mode = V_SET_ACTIVE_MODE_DEDICATED;
 294                 break;
 295         case POWER_SUPPLY_USB_TYPE_SDP:
 296                 mode = V_SET_ACTIVE_MODE_BC12_SDP;
 297                 break;
 298         case POWER_SUPPLY_USB_TYPE_DCP:
 299                 mode = V_SET_ACTIVE_MODE_BC12_DCP;
 300                 break;
 301         case POWER_SUPPLY_USB_TYPE_CDP:
 302                 mode = V_SET_ACTIVE_MODE_BC12_CDP;
 303                 break;
 304         default:
 305                 return -EINVAL;
 306         }
 307
 308         return regmap_update_bits(info->regmap, UCS1002_REG_SWITCH_CFG,
 309                                   V_SET_ACTIVE_MODE_MASK, mode);
 310 }
 311
 312 static int ucs1002_get_usb_type(struct ucs1002_info *info,
 313                                 union power_supply_propval *val)
 314 {
 315         enum power_supply_usb_type type;
 316         unsigned int reg;
 317         int ret;
 318
 319         ret = regmap_read(info->regmap, UCS1002_REG_PIN_STATUS, &reg);
 320         if (ret)
 321                 return ret;
 322
 323         switch (reg & F_ACTIVE_MODE_MASK) {
 324         default:
 325                 type = POWER_SUPPLY_USB_TYPE_UNKNOWN;
 326                 break;
 327         case F_ACTIVE_MODE_DEDICATED:
 328                 type = POWER_SUPPLY_USB_TYPE_PD;
 329                 break;
 330         case F_ACTIVE_MODE_BC12_SDP:
 331                 type = POWER_SUPPLY_USB_TYPE_SDP;
 332                 break;
 333         case F_ACTIVE_MODE_BC12_DCP:
 334                 type = POWER_SUPPLY_USB_TYPE_DCP;
 335                 break;
 336         case F_ACTIVE_MODE_BC12_CDP:
 337                 type = POWER_SUPPLY_USB_TYPE_CDP;
 338                 break;
 339         }
 340
 341         val->intval = type;
 342
 343         return 0;
 344 }
 345
 346 static int ucs1002_get_health(struct ucs1002_info *info,
 347                               union power_supply_propval *val)
 348 {
 349         unsigned int reg;
 350         int ret, health;
 351
 352         ret = regmap_read(info->regmap, UCS1002_REG_INTERRUPT_STATUS, &reg);
 353         if (ret)
 354                 return ret;
 355
 356         if (reg & F_TSD)
 357                 health = POWER_SUPPLY_HEALTH_OVERHEAT;
 358         else if (reg & (F_OVER_VOLT | F_BACK_VOLT))
 359                 health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 360         else if (reg & F_OVER_ILIM)
 361                 health = POWER_SUPPLY_HEALTH_OVERCURRENT;
 362         else if (reg & (F_DISCHARGE_ERR | F_MIN_KEEP_OUT))
 363                 health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 364         else
 365                 health = POWER_SUPPLY_HEALTH_GOOD;
 366
 367         val->intval = health;
 368
 369         return 0;
 370 }
 371
 372 static int ucs1002_get_property(struct power_supply *psy,
 373                                 enum power_supply_property psp,
 374                                 union power_supply_propval *val)
 375 {
 376         struct ucs1002_info *info = power_supply_get_drvdata(psy);
 377
 378         switch (psp) {
 379         case POWER_SUPPLY_PROP_ONLINE:
 380                 return ucs1002_get_online(info, val);
 381         case POWER_SUPPLY_PROP_CHARGE_NOW:
 382                 return ucs1002_get_charge(info, val);
 383         case POWER_SUPPLY_PROP_CURRENT_NOW:
 384                 return ucs1002_get_current(info, val);
 385         case POWER_SUPPLY_PROP_CURRENT_MAX:
 386                 return ucs1002_get_max_current(info, val);
 387         case POWER_SUPPLY_PROP_USB_TYPE:
 388                 return ucs1002_get_usb_type(info, val);
 389         case POWER_SUPPLY_PROP_HEALTH:
 390                 return ucs1002_get_health(info, val);
 391         case POWER_SUPPLY_PROP_PRESENT:
 392                 val->intval = info->present;
 393                 return 0;
 394         case POWER_SUPPLY_PROP_MANUFACTURER:
 395                 val->strval = UCS1002_MANUFACTURER;
 396                 return 0;
 397         default:
 398                 return -EINVAL;
 399         }
 400 }
 401
 402 static int ucs1002_set_property(struct power_supply *psy,
 403                                 enum power_supply_property psp,
 404                                 const union power_supply_propval *val)
 405 {
 406         struct ucs1002_info *info = power_supply_get_drvdata(psy);
 407
 408         switch (psp) {
 409         case POWER_SUPPLY_PROP_CURRENT_MAX:
 410                 return ucs1002_set_max_current(info, val->intval);
 411         case POWER_SUPPLY_PROP_USB_TYPE:
 412                 return ucs1002_set_usb_type(info, val->intval);
 413         default:
 414                 return -EINVAL;
 415         }
 416 }
 417
 418 static int ucs1002_property_is_writeable(struct power_supply *psy,
 419                                          enum power_supply_property psp)
 420 {
 421         switch (psp) {
 422         case POWER_SUPPLY_PROP_CURRENT_MAX:
 423         case POWER_SUPPLY_PROP_USB_TYPE:
 424                 return true;
 425         default:
 426                 return false;
 427         }
 428 }
 429
 430 static const struct power_supply_desc ucs1002_charger_desc = {
 431         .name                   = "ucs1002",
 432         .type                   = POWER_SUPPLY_TYPE_USB,
 433         .usb_types              = ucs1002_usb_types,
 434         .num_usb_types          = ARRAY_SIZE(ucs1002_usb_types),
 435         .get_property           = ucs1002_get_property,
 436         .set_property           = ucs1002_set_property,
 437         .property_is_writeable  = ucs1002_property_is_writeable,
 438         .properties             = ucs1002_props,
 439         .num_properties         = ARRAY_SIZE(ucs1002_props),
 440 };
 441
 442 static irqreturn_t ucs1002_charger_irq(int irq, void *data)
 443 {
 444         int ret, regval;
 445         bool present;
 446         struct ucs1002_info *info = data;
 447
 448         present = info->present;
 449
 450         ret = regmap_read(info->regmap, UCS1002_REG_OTHER_STATUS, &regval);
 451         if (ret)
 452                 return IRQ_HANDLED;
 453
 454         /* update attached status */
 455         info->present = regval & F_ADET_PIN;
 456
 457         /* notify the change */
 458         if (present != info->present)
 459                 power_supply_changed(info->charger);
 460
 461         return IRQ_HANDLED;
 462 }
 463
 464 static irqreturn_t ucs1002_alert_irq(int irq, void *data)
 465 {
 466         struct ucs1002_info *info = data;
 467
 468         power_supply_changed(info->charger);
 469
 470         return IRQ_HANDLED;
 471 }
 472
 473 static const struct regulator_ops ucs1002_regulator_ops = {
 474         .is_enabled     = regulator_is_enabled_regmap,
 475         .enable         = regulator_enable_regmap,
 476         .disable        = regulator_disable_regmap,
 477 };
 478
 479 static const struct regulator_desc ucs1002_regulator_descriptor = {
 480         .name           = "ucs1002-vbus",
 481         .ops            = &ucs1002_regulator_ops,
 482         .type           = REGULATOR_VOLTAGE,
 483         .owner          = THIS_MODULE,
 484         .enable_reg     = UCS1002_REG_SWITCH_CFG,
 485         .enable_mask    = F_PWR_EN_SET,
 486         .enable_val     = F_PWR_EN_SET,
 487         .fixed_uV       = 5000000,
 488         .n_voltages     = 1,
 489 };
 490
 491 static int ucs1002_probe(struct i2c_client *client,
 492                          const struct i2c_device_id *dev_id)
 493 {
 494         struct device *dev = &client->dev;
 495         struct power_supply_config charger_config = {};
 496         const struct regmap_config regmap_config = {
 497                 .reg_bits = 8,
 498                 .val_bits = 8,
 499         };
 500         struct regulator_config regulator_config = {};
 501         int irq_a_det, irq_alert, ret;
 502         struct regulator_dev *rdev;
 503         struct ucs1002_info *info;
 504         unsigned int regval;
 505
 506         info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
 507         if (!info)
 508                 return -ENOMEM;
 509
 510         info->regmap = devm_regmap_init_i2c(client, &regmap_config);
 511         ret = PTR_ERR_OR_ZERO(info->regmap);
 512         if (ret) {
 513                 dev_err(dev, "Regmap initialization failed: %d\n", ret);
 514                 return ret;
 515         }
 516
 517         info->client = client;
 518
 519         irq_a_det = of_irq_get_byname(dev->of_node, "a_det");
 520         irq_alert = of_irq_get_byname(dev->of_node, "alert");
 521
 522         charger_config.of_node = dev->of_node;
 523         charger_config.drv_data = info;
 524
 525         ret = regmap_read(info->regmap, UCS1002_REG_PRODUCT_ID, &regval);
 526         if (ret) {
 527                 dev_err(dev, "Failed to read product ID: %d\n", ret);
 528                 return ret;
 529         }
 530
 531         if (regval != UCS1002_PRODUCT_ID) {
 532                 dev_err(dev,
 533                         "Product ID does not match (0x%02x != 0x%02x)\n",
 534                         regval, UCS1002_PRODUCT_ID);
 535                 return -ENODEV;
 536         }
 537
 538         /* Enable charge rationing by default */
 539         ret = regmap_update_bits(info->regmap, UCS1002_REG_GENERAL_CFG,
 540                                  F_RATION_EN, F_RATION_EN);
 541         if (ret) {
 542                 dev_err(dev, "Failed to read general config: %d\n", ret);
 543                 return ret;
 544         }
 545
 546         /*
 547          * Ignore the M1, M2, PWR_EN, and EM_EN pin states. Set active
 548          * mode selection to BC1.2 CDP.
 549          */
 550         ret = regmap_update_bits(info->regmap, UCS1002_REG_SWITCH_CFG,
 551                                  V_SET_ACTIVE_MODE_MASK | F_PIN_IGNORE,
 552                                  V_SET_ACTIVE_MODE_BC12_CDP | F_PIN_IGNORE);
 553         if (ret) {
 554                 dev_err(dev, "Failed to configure default mode: %d\n", ret);
 555                 return ret;
 556         }
 557         /*
 558          * Be safe and set initial current limit to 500mA
 559          */
 560         ret = ucs1002_set_max_current(info, 500000);
 561         if (ret) {
 562                 dev_err(dev, "Failed to set max current default: %d\n", ret);
 563                 return ret;
 564         }
 565
 566         info->charger = devm_power_supply_register(dev, &ucs1002_charger_desc,
 567                                                    &charger_config);
 568         ret = PTR_ERR_OR_ZERO(info->charger);
 569         if (ret) {
 570                 dev_err(dev, "Failed to register power supply: %d\n", ret);
 571                 return ret;
 572         }
 573
 574         ret = regmap_read(info->regmap, UCS1002_REG_PIN_STATUS, &regval);
 575         if (ret) {
 576                 dev_err(dev, "Failed to read pin status: %d\n", ret);
 577                 return ret;
 578         }
 579
 580         info->regulator_descriptor =
 581                 devm_kmemdup(dev, &ucs1002_regulator_descriptor,
 582                              sizeof(ucs1002_regulator_descriptor),
 583                              GFP_KERNEL);
 584         if (!info->regulator_descriptor)
 585                 return -ENOMEM;
 586
 587         info->regulator_descriptor->enable_is_inverted = !(regval & F_SEL_PIN);
 588
 589         regulator_config.dev = dev;
 590         regulator_config.of_node = dev->of_node;
 591         regulator_config.regmap = info->regmap;
 592
 593         rdev = devm_regulator_register(dev, info->regulator_descriptor,
 594                                        &regulator_config);
 595         ret = PTR_ERR_OR_ZERO(rdev);
 596         if (ret) {
 597                 dev_err(dev, "Failed to register VBUS regulator: %d\n", ret);
 598                 return ret;
 599         }
 600
 601         if (irq_a_det > 0) {
 602                 ret = devm_request_threaded_irq(dev, irq_a_det, NULL,
 603                                                 ucs1002_charger_irq,
 604                                                 IRQF_ONESHOT,
 605                                                 "ucs1002-a_det", info);
 606                 if (ret) {
 607                         dev_err(dev, "Failed to request A_DET threaded irq: %d\n",
 608                                 ret);
 609                         return ret;
 610                 }
 611         }
 612
 613         if (irq_alert > 0) {
 614                 ret = devm_request_threaded_irq(dev, irq_alert, NULL,
 615                                                 ucs1002_alert_irq,
 616                                                 IRQF_ONESHOT,
 617                                                 "ucs1002-alert", info);
 618                 if (ret) {
 619                         dev_err(dev, "Failed to request ALERT threaded irq: %d\n",
 620                                 ret);
 621                         return ret;
 622                 }
 623         }
 624
 625         return 0;
 626 }
 627
 628 static const struct of_device_id ucs1002_of_match[] = {
 629         { .compatible = "microchip,ucs1002", },
 630         { /* sentinel */ },
 631 };
 632 MODULE_DEVICE_TABLE(of, ucs1002_of_match);
 633
 634 static struct i2c_driver ucs1002_driver = {
 635         .driver = {
 636                    .name = "ucs1002",
 637                    .of_match_table = ucs1002_of_match,
 638         },
 639         .probe = ucs1002_probe,
 640 };
 641 module_i2c_driver(ucs1002_driver);
 642
 643 MODULE_DESCRIPTION("Microchip UCS1002 Programmable USB Port Power Controller");
 644 MODULE_AUTHOR("Enric Balletbo Serra <enric.balletbo@collabora.com>");
 645 MODULE_AUTHOR("Andrey Smirnov <andrew.smirnov@gmail.com>");
 646 MODULE_LICENSE("GPL");