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 143 max14656_read_block_reg(chip->client, MAX14656_DEVICE_ID, 144 REG_TOTAL_NUM, buf); 145 146 if ((buf[MAX14656_STATUS_1] & STATUS1_VB_VALID_MASK) && 147 (buf[MAX14656_STATUS_1] & STATUS1_CHG_TYPE_MASK)) { 148 chg_type = buf[MAX14656_STATUS_1] & STATUS1_CHG_TYPE_MASK; 149 if (chg_type < MAX14656_CHARGER_LAST) 150 chip->psy_desc.type = chg_type_props[chg_type].type; 151 else 152 chip->psy_desc.type = POWER_SUPPLY_TYPE_UNKNOWN; 153 chip->online = 1; 154 } else { 155 chip->online = 0; 156 chip->psy_desc.type = POWER_SUPPLY_TYPE_UNKNOWN; 157 } 158 159 power_supply_changed(chip->detect_psy); 160 } 161 162 static irqreturn_t max14656_irq(int irq, void *dev_id) 163 { 164 struct max14656_chip *chip = dev_id; 165 166 schedule_delayed_work(&chip->irq_work, msecs_to_jiffies(100)); 167 168 return IRQ_HANDLED; 169 } 170 171 static int max14656_hw_init(struct max14656_chip *chip) 172 { 173 uint8_t val = 0; 174 uint8_t rev; 175 struct i2c_client *client = chip->client; 176 177 if (max14656_read_reg(client, MAX14656_DEVICE_ID, &val)) 178 return -ENODEV; 179 180 if ((val & DEVICE_VENDOR_MASK) != 0x20) { 181 dev_err(&client->dev, "wrong vendor ID %d\n", 182 ((val & DEVICE_VENDOR_MASK) >> 4)); 183 return -ENODEV; 184 } 185 rev = val & DEVICE_REV_MASK; 186 187 /* Turn on ADC_EN */ 188 if (max14656_write_reg(client, MAX14656_CONTROL_2, CONTROL2_ADC_EN)) 189 return -EINVAL; 190 191 /* turn on interrupts and low power mode */ 192 if (max14656_write_reg(client, MAX14656_CONTROL_1, 193 CONTROL1_DEFAULT | 194 CONTROL1_INT_EN | 195 CONTROL1_INT_ACTIVE_HIGH | 196 CONTROL1_EDGE)) 197 return -EINVAL; 198 199 if (max14656_write_reg(client, MAX14656_INTMASK_1, 0x3)) 200 return -EINVAL; 201 202 if (max14656_write_reg(client, MAX14656_INTMASK_2, 0x1)) 203 return -EINVAL; 204 205 dev_info(&client->dev, "detected revision %d\n", rev); 206 return 0; 207 } 208 209 static int max14656_get_property(struct power_supply *psy, 210 enum power_supply_property psp, 211 union power_supply_propval *val) 212 { 213 struct max14656_chip *chip = power_supply_get_drvdata(psy); 214 215 switch (psp) { 216 case POWER_SUPPLY_PROP_ONLINE: 217 val->intval = chip->online; 218 break; 219 case POWER_SUPPLY_PROP_MODEL_NAME: 220 val->strval = MAX14656_NAME; 221 break; 222 case POWER_SUPPLY_PROP_MANUFACTURER: 223 val->strval = MAX14656_MANUFACTURER; 224 break; 225 default: 226 return -EINVAL; 227 } 228 229 return 0; 230 } 231 232 static enum power_supply_property max14656_battery_props[] = { 233 POWER_SUPPLY_PROP_ONLINE, 234 POWER_SUPPLY_PROP_MODEL_NAME, 235 POWER_SUPPLY_PROP_MANUFACTURER, 236 }; 237 238 static void stop_irq_work(void *data) 239 { 240 struct max14656_chip *chip = data; 241 242 cancel_delayed_work_sync(&chip->irq_work); 243 } 244 245 246 static int max14656_probe(struct i2c_client *client, 247 const struct i2c_device_id *id) 248 { 249 struct i2c_adapter *adapter = client->adapter; 250 struct device *dev = &client->dev; 251 struct power_supply_config psy_cfg = {}; 252 struct max14656_chip *chip; 253 int irq = client->irq; 254 int ret = 0; 255 256 if (irq <= 0) { 257 dev_err(dev, "invalid irq number: %d\n", irq); 258 return -ENODEV; 259 } 260 261 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 262 dev_err(dev, "No support for SMBUS_BYTE_DATA\n"); 263 return -ENODEV; 264 } 265 266 chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL); 267 if (!chip) 268 return -ENOMEM; 269 270 psy_cfg.drv_data = chip; 271 chip->client = client; 272 chip->online = 0; 273 chip->psy_desc.name = MAX14656_NAME; 274 chip->psy_desc.type = POWER_SUPPLY_TYPE_UNKNOWN; 275 chip->psy_desc.properties = max14656_battery_props; 276 chip->psy_desc.num_properties = ARRAY_SIZE(max14656_battery_props); 277 chip->psy_desc.get_property = max14656_get_property; 278 chip->irq = irq; 279 280 ret = max14656_hw_init(chip); 281 if (ret) 282 return -ENODEV; 283 284 chip->detect_psy = devm_power_supply_register(dev, 285 &chip->psy_desc, &psy_cfg); 286 if (IS_ERR(chip->detect_psy)) { 287 dev_err(dev, "power_supply_register failed\n"); 288 return -EINVAL; 289 } 290 291 INIT_DELAYED_WORK(&chip->irq_work, max14656_irq_worker); 292 ret = devm_add_action(dev, stop_irq_work, chip); 293 if (ret) { 294 dev_err(dev, "devm_add_action %d failed\n", ret); 295 return ret; 296 } 297 298 ret = devm_request_irq(dev, chip->irq, max14656_irq, 299 IRQF_TRIGGER_FALLING, 300 MAX14656_NAME, chip); 301 if (ret) { 302 dev_err(dev, "request_irq %d failed\n", chip->irq); 303 return -EINVAL; 304 } 305 enable_irq_wake(chip->irq); 306 307 schedule_delayed_work(&chip->irq_work, msecs_to_jiffies(2000)); 308 309 return 0; 310 } 311 312 static const struct i2c_device_id max14656_id[] = { 313 { "max14656", 0 }, 314 {} 315 }; 316 MODULE_DEVICE_TABLE(i2c, max14656_id); 317 318 static const struct of_device_id max14656_match_table[] = { 319 { .compatible = "maxim,max14656", }, 320 {} 321 }; 322 MODULE_DEVICE_TABLE(of, max14656_match_table); 323 324 static struct i2c_driver max14656_i2c_driver = { 325 .driver = { 326 .name = "max14656", 327 .of_match_table = max14656_match_table, 328 }, 329 .probe = max14656_probe, 330 .id_table = max14656_id, 331 }; 332 module_i2c_driver(max14656_i2c_driver); 333 334 MODULE_DESCRIPTION("MAX14656 USB charger detector"); 335 MODULE_LICENSE("GPL v2"); 336