drivers/power/supply/max14656_charger_detector.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Maxim MAX14656 / AL32 USB Charger Detector driver
   4  *
   5  * Copyright (C) 2014 LG Electronics, Inc
   6  * Copyright (C) 2016 Alexander Kurz <akurz@blala.de>
   7  *
   8  * Components from Maxim AL32 Charger detection Driver for MX50 Yoshi Board
   9  * Copyright (C) Amazon Technologies Inc. All rights reserved.
  10  * Manish Lachwani (lachwani@lab126.com)
  11  */
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/delay.h>
  15 #include <linux/i2c.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/slab.h>
  18 #include <linux/gpio.h>
  19 #include <linux/of_gpio.h>
  20 #include <linux/of_device.h>
  21 #include <linux/workqueue.h>
  22 #include <linux/power_supply.h>
  23
  24 #define MAX14656_MANUFACTURER   "Maxim Integrated"
  25 #define MAX14656_NAME           "max14656"
  26
  27 #define MAX14656_DEVICE_ID      0x00
  28 #define MAX14656_INTERRUPT_1    0x01
  29 #define MAX14656_INTERRUPT_2    0x02
  30 #define MAX14656_STATUS_1       0x03
  31 #define MAX14656_STATUS_2       0x04
  32 #define MAX14656_INTMASK_1      0x05
  33 #define MAX14656_INTMASK_2      0x06
  34 #define MAX14656_CONTROL_1      0x07
  35 #define MAX14656_CONTROL_2      0x08
  36 #define MAX14656_CONTROL_3      0x09
  37
  38 #define DEVICE_VENDOR_MASK      0xf0
  39 #define DEVICE_REV_MASK         0x0f
  40 #define INT_EN_REG_MASK         BIT(4)
  41 #define CHG_TYPE_INT_MASK       BIT(0)
  42 #define STATUS1_VB_VALID_MASK   BIT(4)
  43 #define STATUS1_CHG_TYPE_MASK   0xf
  44 #define INT1_DCD_TIMEOUT_MASK   BIT(7)
  45 #define CONTROL1_DEFAULT        0x0d
  46 #define CONTROL1_INT_EN         BIT(4)
  47 #define CONTROL1_INT_ACTIVE_HIGH        BIT(5)
  48 #define CONTROL1_EDGE           BIT(7)
  49 #define CONTROL2_DEFAULT        0x8e
  50 #define CONTROL2_ADC_EN         BIT(0)
  51 #define CONTROL3_DEFAULT        0x8d
  52
  53 enum max14656_chg_type {
  54         MAX14656_NO_CHARGER     = 0,
  55         MAX14656_SDP_CHARGER,
  56         MAX14656_CDP_CHARGER,
  57         MAX14656_DCP_CHARGER,
  58         MAX14656_APPLE_500MA_CHARGER,
  59         MAX14656_APPLE_1A_CHARGER,
  60         MAX14656_APPLE_2A_CHARGER,
  61         MAX14656_SPECIAL_500MA_CHARGER,
  62         MAX14656_APPLE_12W,
  63         MAX14656_CHARGER_LAST
  64 };
  65
  66 static const struct max14656_chg_type_props {
  67         enum power_supply_type type;
  68 } chg_type_props[] = {
  69         { POWER_SUPPLY_TYPE_UNKNOWN },
  70         { POWER_SUPPLY_TYPE_USB },
  71         { POWER_SUPPLY_TYPE_USB_CDP },
  72         { POWER_SUPPLY_TYPE_USB_DCP },
  73         { POWER_SUPPLY_TYPE_USB_DCP },
  74         { POWER_SUPPLY_TYPE_USB_DCP },
  75         { POWER_SUPPLY_TYPE_USB_DCP },
  76         { POWER_SUPPLY_TYPE_USB_DCP },
  77         { POWER_SUPPLY_TYPE_USB },
  78 };
  79
  80 struct max14656_chip {
  81         struct i2c_client       *client;
  82         struct power_supply     *detect_psy;
  83         struct power_supply_desc psy_desc;
  84         struct delayed_work     irq_work;
  85
  86         int irq;
  87         int online;
  88 };
  89
  90 static int max14656_read_reg(struct i2c_client *client, int reg, u8 *val)
  91 {
  92         s32 ret;
  93
  94         ret = i2c_smbus_read_byte_data(client, reg);
  95         if (ret < 0) {
  96                 dev_err(&client->dev,
  97                         "i2c read fail: can't read from %02x: %d\n",
  98                         reg, ret);
  99                 return ret;
 100         }
 101         *val = ret;
 102         return 0;
 103 }
 104
 105 static int max14656_write_reg(struct i2c_client *client, int reg, u8 val)
 106 {
 107         s32 ret;
 108
 109         ret = i2c_smbus_write_byte_data(client, reg, val);
 110         if (ret < 0) {
 111                 dev_err(&client->dev,
 112                         "i2c write fail: can't write %02x to %02x: %d\n",
 113                         val, reg, ret);
 114                 return ret;
 115         }
 116         return 0;
 117 }
 118
 119 static int max14656_read_block_reg(struct i2c_client *client, u8 reg,
 120                                   u8 length, u8 *val)
 121 {
 122         int ret;
 123
 124         ret = i2c_smbus_read_i2c_block_data(client, reg, length, val);
 125         if (ret < 0) {
 126                 dev_err(&client->dev, "failed to block read reg 0x%x: %d\n",
 127                                 reg, ret);
 128                 return ret;
 129         }
 130
 131         return 0;
 132 }
 133
 134 #define        REG_TOTAL_NUM   5
 135 static void max14656_irq_worker(struct work_struct *work)
 136 {
 137         struct max14656_chip *chip =
 138                 container_of(work, struct max14656_chip, irq_work.work);
 139
 140         u8 buf[REG_TOTAL_NUM];
 141         u8 chg_type;
 142         int ret = 0;
 143
 144         ret = max14656_read_block_reg(chip->client, MAX14656_DEVICE_ID,
 145                                       REG_TOTAL_NUM, buf);
 146
 147         if ((buf[MAX14656_STATUS_1] & STATUS1_VB_VALID_MASK) &&
 148                 (buf[MAX14656_STATUS_1] & STATUS1_CHG_TYPE_MASK)) {
 149                 chg_type = buf[MAX14656_STATUS_1] & STATUS1_CHG_TYPE_MASK;
 150                 if (chg_type < MAX14656_CHARGER_LAST)
 151                         chip->psy_desc.type = chg_type_props[chg_type].type;
 152                 else
 153                         chip->psy_desc.type = POWER_SUPPLY_TYPE_UNKNOWN;
 154                 chip->online = 1;
 155         } else {
 156                 chip->online = 0;
 157                 chip->psy_desc.type = POWER_SUPPLY_TYPE_UNKNOWN;
 158         }
 159
 160         power_supply_changed(chip->detect_psy);
 161 }
 162
 163 static irqreturn_t max14656_irq(int irq, void *dev_id)
 164 {
 165         struct max14656_chip *chip = dev_id;
 166
 167         schedule_delayed_work(&chip->irq_work, msecs_to_jiffies(100));
 168
 169         return IRQ_HANDLED;
 170 }
 171
 172 static int max14656_hw_init(struct max14656_chip *chip)
 173 {
 174         uint8_t val = 0;
 175         uint8_t rev;
 176         struct i2c_client *client = chip->client;
 177
 178         if (max14656_read_reg(client, MAX14656_DEVICE_ID, &val))
 179                 return -ENODEV;
 180
 181         if ((val & DEVICE_VENDOR_MASK) != 0x20) {
 182                 dev_err(&client->dev, "wrong vendor ID %d\n",
 183                         ((val & DEVICE_VENDOR_MASK) >> 4));
 184                 return -ENODEV;
 185         }
 186         rev = val & DEVICE_REV_MASK;
 187
 188         /* Turn on ADC_EN */
 189         if (max14656_write_reg(client, MAX14656_CONTROL_2, CONTROL2_ADC_EN))
 190                 return -EINVAL;
 191
 192         /* turn on interrupts and low power mode */
 193         if (max14656_write_reg(client, MAX14656_CONTROL_1,
 194                 CONTROL1_DEFAULT |
 195                 CONTROL1_INT_EN |
 196                 CONTROL1_INT_ACTIVE_HIGH |
 197                 CONTROL1_EDGE))
 198                 return -EINVAL;
 199
 200         if (max14656_write_reg(client, MAX14656_INTMASK_1, 0x3))
 201                 return -EINVAL;
 202
 203         if (max14656_write_reg(client, MAX14656_INTMASK_2, 0x1))
 204                 return -EINVAL;
 205
 206         dev_info(&client->dev, "detected revision %d\n", rev);
 207         return 0;
 208 }
 209
 210 static int max14656_get_property(struct power_supply *psy,
 211                             enum power_supply_property psp,
 212                             union power_supply_propval *val)
 213 {
 214         struct max14656_chip *chip = power_supply_get_drvdata(psy);
 215
 216         switch (psp) {
 217         case POWER_SUPPLY_PROP_ONLINE:
 218                 val->intval = chip->online;
 219                 break;
 220         case POWER_SUPPLY_PROP_MODEL_NAME:
 221                 val->strval = MAX14656_NAME;
 222                 break;
 223         case POWER_SUPPLY_PROP_MANUFACTURER:
 224                 val->strval = MAX14656_MANUFACTURER;
 225                 break;
 226         default:
 227                 return -EINVAL;
 228         }
 229
 230         return 0;
 231 }
 232
 233 static enum power_supply_property max14656_battery_props[] = {
 234         POWER_SUPPLY_PROP_ONLINE,
 235         POWER_SUPPLY_PROP_MODEL_NAME,
 236         POWER_SUPPLY_PROP_MANUFACTURER,
 237 };
 238
 239 static void stop_irq_work(void *data)
 240 {
 241         struct max14656_chip *chip = data;
 242
 243         cancel_delayed_work_sync(&chip->irq_work);
 244 }
 245
 246
 247 static int max14656_probe(struct i2c_client *client,
 248                           const struct i2c_device_id *id)
 249 {
 250         struct i2c_adapter *adapter = client->adapter;
 251         struct device *dev = &client->dev;
 252         struct power_supply_config psy_cfg = {};
 253         struct max14656_chip *chip;
 254         int irq = client->irq;
 255         int ret = 0;
 256
 257         if (irq <= 0) {
 258                 dev_err(dev, "invalid irq number: %d\n", irq);
 259                 return -ENODEV;
 260         }
 261
 262         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 263                 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
 264                 return -ENODEV;
 265         }
 266
 267         chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
 268         if (!chip)
 269                 return -ENOMEM;
 270
 271         psy_cfg.drv_data = chip;
 272         chip->client = client;
 273         chip->online = 0;
 274         chip->psy_desc.name = MAX14656_NAME;
 275         chip->psy_desc.type = POWER_SUPPLY_TYPE_UNKNOWN;
 276         chip->psy_desc.properties = max14656_battery_props;
 277         chip->psy_desc.num_properties = ARRAY_SIZE(max14656_battery_props);
 278         chip->psy_desc.get_property = max14656_get_property;
 279         chip->irq = irq;
 280
 281         ret = max14656_hw_init(chip);
 282         if (ret)
 283                 return -ENODEV;
 284
 285         chip->detect_psy = devm_power_supply_register(dev,
 286                        &chip->psy_desc, &psy_cfg);
 287         if (IS_ERR(chip->detect_psy)) {
 288                 dev_err(dev, "power_supply_register failed\n");
 289                 return -EINVAL;
 290         }
 291
 292         INIT_DELAYED_WORK(&chip->irq_work, max14656_irq_worker);
 293         ret = devm_add_action(dev, stop_irq_work, chip);
 294         if (ret) {
 295                 dev_err(dev, "devm_add_action %d failed\n", ret);
 296                 return ret;
 297         }
 298
 299         ret = devm_request_irq(dev, chip->irq, max14656_irq,
 300                                IRQF_TRIGGER_FALLING,
 301                                MAX14656_NAME, chip);
 302         if (ret) {
 303                 dev_err(dev, "request_irq %d failed\n", chip->irq);
 304                 return -EINVAL;
 305         }
 306         enable_irq_wake(chip->irq);
 307
 308         schedule_delayed_work(&chip->irq_work, msecs_to_jiffies(2000));
 309
 310         return 0;
 311 }
 312
 313 static const struct i2c_device_id max14656_id[] = {
 314         { "max14656", 0 },
 315         {}
 316 };
 317 MODULE_DEVICE_TABLE(i2c, max14656_id);
 318
 319 static const struct of_device_id max14656_match_table[] = {
 320         { .compatible = "maxim,max14656", },
 321         {}
 322 };
 323 MODULE_DEVICE_TABLE(of, max14656_match_table);
 324
 325 static struct i2c_driver max14656_i2c_driver = {
 326         .driver = {
 327                 .name   = "max14656",
 328                 .of_match_table = max14656_match_table,
 329         },
 330         .probe          = max14656_probe,
 331         .id_table       = max14656_id,
 332 };
 333 module_i2c_driver(max14656_i2c_driver);
 334
 335 MODULE_DESCRIPTION("MAX14656 USB charger detector");
 336 MODULE_LICENSE("GPL v2");