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");
337