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