1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Power supply driver for ChromeOS EC based Peripheral Device Charger.
4  *
5  * Copyright 2020 Google LLC.
6  */
7 
8 #include <linux/module.h>
9 #include <linux/notifier.h>
10 #include <linux/platform_data/cros_ec_commands.h>
11 #include <linux/platform_data/cros_ec_proto.h>
12 #include <linux/platform_device.h>
13 #include <linux/power_supply.h>
14 #include <linux/slab.h>
15 #include <linux/stringify.h>
16 #include <linux/types.h>
17 #include <asm/unaligned.h>
18 
19 #define DRV_NAME		"cros-ec-pchg"
20 #define PCHG_DIR_PREFIX		"peripheral"
21 #define PCHG_DIR_NAME		PCHG_DIR_PREFIX "%d"
22 #define PCHG_DIR_NAME_LENGTH \
23 		sizeof(PCHG_DIR_PREFIX __stringify(EC_PCHG_MAX_PORTS))
24 #define PCHG_CACHE_UPDATE_DELAY	msecs_to_jiffies(500)
25 
26 struct port_data {
27 	int port_number;
28 	char name[PCHG_DIR_NAME_LENGTH];
29 	struct power_supply *psy;
30 	struct power_supply_desc psy_desc;
31 	int psy_status;
32 	int battery_percentage;
33 	int charge_type;
34 	struct charger_data *charger;
35 	unsigned long last_update;
36 };
37 
38 struct charger_data {
39 	struct device *dev;
40 	struct cros_ec_dev *ec_dev;
41 	struct cros_ec_device *ec_device;
42 	int num_registered_psy;
43 	struct port_data *ports[EC_PCHG_MAX_PORTS];
44 	struct notifier_block notifier;
45 };
46 
47 static enum power_supply_property cros_pchg_props[] = {
48 	POWER_SUPPLY_PROP_STATUS,
49 	POWER_SUPPLY_PROP_CHARGE_TYPE,
50 	POWER_SUPPLY_PROP_CAPACITY,
51 	POWER_SUPPLY_PROP_SCOPE,
52 };
53 
54 static int cros_pchg_ec_command(const struct charger_data *charger,
55 				unsigned int version,
56 				unsigned int command,
57 				const void *outdata,
58 				unsigned int outsize,
59 				void *indata,
60 				unsigned int insize)
61 {
62 	struct cros_ec_dev *ec_dev = charger->ec_dev;
63 	struct cros_ec_command *msg;
64 	int ret;
65 
66 	msg = kzalloc(sizeof(*msg) + max(outsize, insize), GFP_KERNEL);
67 	if (!msg)
68 		return -ENOMEM;
69 
70 	msg->version = version;
71 	msg->command = ec_dev->cmd_offset + command;
72 	msg->outsize = outsize;
73 	msg->insize = insize;
74 
75 	if (outsize)
76 		memcpy(msg->data, outdata, outsize);
77 
78 	ret = cros_ec_cmd_xfer_status(charger->ec_device, msg);
79 	if (ret >= 0 && insize)
80 		memcpy(indata, msg->data, insize);
81 
82 	kfree(msg);
83 	return ret;
84 }
85 
86 static const unsigned int pchg_cmd_version = 1;
87 
88 static bool cros_pchg_cmd_ver_check(const struct charger_data *charger)
89 {
90 	struct ec_params_get_cmd_versions_v1 req;
91 	struct ec_response_get_cmd_versions rsp;
92 	int ret;
93 
94 	req.cmd = EC_CMD_PCHG;
95 	ret = cros_pchg_ec_command(charger, 1, EC_CMD_GET_CMD_VERSIONS,
96 				   &req, sizeof(req), &rsp, sizeof(rsp));
97 	if (ret < 0) {
98 		dev_warn(charger->dev,
99 			 "Unable to get versions of EC_CMD_PCHG (err:%d)\n",
100 			 ret);
101 		return false;
102 	}
103 
104 	return !!(rsp.version_mask & BIT(pchg_cmd_version));
105 }
106 
107 static int cros_pchg_port_count(const struct charger_data *charger)
108 {
109 	struct ec_response_pchg_count rsp;
110 	int ret;
111 
112 	ret = cros_pchg_ec_command(charger, 0, EC_CMD_PCHG_COUNT,
113 				   NULL, 0, &rsp, sizeof(rsp));
114 	if (ret < 0) {
115 		dev_warn(charger->dev,
116 			 "Unable to get number or ports (err:%d)\n", ret);
117 		return ret;
118 	}
119 
120 	return rsp.port_count;
121 }
122 
123 static int cros_pchg_get_status(struct port_data *port)
124 {
125 	struct charger_data *charger = port->charger;
126 	struct ec_params_pchg req;
127 	struct ec_response_pchg rsp;
128 	struct device *dev = charger->dev;
129 	int old_status = port->psy_status;
130 	int old_percentage = port->battery_percentage;
131 	int ret;
132 
133 	req.port = port->port_number;
134 	ret = cros_pchg_ec_command(charger, pchg_cmd_version, EC_CMD_PCHG,
135 				   &req, sizeof(req), &rsp, sizeof(rsp));
136 	if (ret < 0) {
137 		dev_err(dev, "Unable to get port.%d status (err:%d)\n",
138 			port->port_number, ret);
139 		return ret;
140 	}
141 
142 	switch (rsp.state) {
143 	case PCHG_STATE_RESET:
144 	case PCHG_STATE_INITIALIZED:
145 	case PCHG_STATE_ENABLED:
146 	default:
147 		port->psy_status = POWER_SUPPLY_STATUS_UNKNOWN;
148 		port->charge_type = POWER_SUPPLY_CHARGE_TYPE_NONE;
149 		break;
150 	case PCHG_STATE_DETECTED:
151 		port->psy_status = POWER_SUPPLY_STATUS_CHARGING;
152 		port->charge_type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
153 		break;
154 	case PCHG_STATE_CHARGING:
155 		port->psy_status = POWER_SUPPLY_STATUS_CHARGING;
156 		port->charge_type = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
157 		break;
158 	case PCHG_STATE_FULL:
159 		port->psy_status = POWER_SUPPLY_STATUS_FULL;
160 		port->charge_type = POWER_SUPPLY_CHARGE_TYPE_NONE;
161 		break;
162 	}
163 
164 	port->battery_percentage = rsp.battery_percentage;
165 
166 	if (port->psy_status != old_status ||
167 			port->battery_percentage != old_percentage)
168 		power_supply_changed(port->psy);
169 
170 	dev_dbg(dev,
171 		"Port %d: state=%d battery=%d%%\n",
172 		port->port_number, rsp.state, rsp.battery_percentage);
173 
174 	return 0;
175 }
176 
177 static int cros_pchg_get_port_status(struct port_data *port, bool ratelimit)
178 {
179 	int ret;
180 
181 	if (ratelimit &&
182 	    time_is_after_jiffies(port->last_update + PCHG_CACHE_UPDATE_DELAY))
183 		return 0;
184 
185 	ret = cros_pchg_get_status(port);
186 	if (ret < 0)
187 		return ret;
188 
189 	port->last_update = jiffies;
190 
191 	return ret;
192 }
193 
194 static int cros_pchg_get_prop(struct power_supply *psy,
195 			      enum power_supply_property psp,
196 			      union power_supply_propval *val)
197 {
198 	struct port_data *port = power_supply_get_drvdata(psy);
199 
200 	switch (psp) {
201 	case POWER_SUPPLY_PROP_STATUS:
202 	case POWER_SUPPLY_PROP_CAPACITY:
203 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
204 		cros_pchg_get_port_status(port, true);
205 		break;
206 	default:
207 		break;
208 	}
209 
210 	switch (psp) {
211 	case POWER_SUPPLY_PROP_STATUS:
212 		val->intval = port->psy_status;
213 		break;
214 	case POWER_SUPPLY_PROP_CAPACITY:
215 		val->intval = port->battery_percentage;
216 		break;
217 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
218 		val->intval = port->charge_type;
219 		break;
220 	case POWER_SUPPLY_PROP_SCOPE:
221 		val->intval = POWER_SUPPLY_SCOPE_DEVICE;
222 		break;
223 	default:
224 		return -EINVAL;
225 	}
226 
227 	return 0;
228 }
229 
230 static int cros_pchg_event(const struct charger_data *charger,
231 			   unsigned long host_event)
232 {
233 	int i;
234 
235 	for (i = 0; i < charger->num_registered_psy; i++)
236 		cros_pchg_get_port_status(charger->ports[i], false);
237 
238 	return NOTIFY_OK;
239 }
240 
241 static int cros_ec_notify(struct notifier_block *nb,
242 			  unsigned long queued_during_suspend,
243 			  void *data)
244 {
245 	struct cros_ec_device *ec_dev = data;
246 	struct charger_data *charger =
247 			container_of(nb, struct charger_data, notifier);
248 	u32 host_event;
249 
250 	if (ec_dev->event_data.event_type != EC_MKBP_EVENT_PCHG ||
251 			ec_dev->event_size != sizeof(host_event))
252 		return NOTIFY_DONE;
253 
254 	host_event = get_unaligned_le32(&ec_dev->event_data.data.host_event);
255 
256 	if (!(host_event & EC_MKBP_PCHG_DEVICE_EVENT))
257 		return NOTIFY_DONE;
258 
259 	return cros_pchg_event(charger, host_event);
260 }
261 
262 static int cros_pchg_probe(struct platform_device *pdev)
263 {
264 	struct device *dev = &pdev->dev;
265 	struct cros_ec_dev *ec_dev = dev_get_drvdata(dev->parent);
266 	struct cros_ec_device *ec_device = ec_dev->ec_dev;
267 	struct power_supply_desc *psy_desc;
268 	struct charger_data *charger;
269 	struct power_supply *psy;
270 	struct port_data *port;
271 	struct notifier_block *nb;
272 	int num_ports;
273 	int ret;
274 	int i;
275 
276 	charger = devm_kzalloc(dev, sizeof(*charger), GFP_KERNEL);
277 	if (!charger)
278 		return -ENOMEM;
279 
280 	charger->dev = dev;
281 	charger->ec_dev = ec_dev;
282 	charger->ec_device = ec_device;
283 
284 	ret = cros_pchg_port_count(charger);
285 	if (ret <= 0) {
286 		/*
287 		 * This feature is enabled by the EC and the kernel driver is
288 		 * included by default for CrOS devices. Don't need to be loud
289 		 * since this error can be normal.
290 		 */
291 		dev_info(dev, "No peripheral charge ports (err:%d)\n", ret);
292 		return -ENODEV;
293 	}
294 
295 	if (!cros_pchg_cmd_ver_check(charger)) {
296 		dev_err(dev, "EC_CMD_PCHG version %d isn't available.\n",
297 			pchg_cmd_version);
298 		return -EOPNOTSUPP;
299 	}
300 
301 	num_ports = ret;
302 	if (num_ports > EC_PCHG_MAX_PORTS) {
303 		dev_err(dev, "Too many peripheral charge ports (%d)\n",
304 			num_ports);
305 		return -ENOBUFS;
306 	}
307 
308 	dev_info(dev, "%d peripheral charge ports found\n", num_ports);
309 
310 	for (i = 0; i < num_ports; i++) {
311 		struct power_supply_config psy_cfg = {};
312 
313 		port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
314 		if (!port)
315 			return -ENOMEM;
316 
317 		port->charger = charger;
318 		port->port_number = i;
319 		snprintf(port->name, sizeof(port->name), PCHG_DIR_NAME, i);
320 
321 		psy_desc = &port->psy_desc;
322 		psy_desc->name = port->name;
323 		psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
324 		psy_desc->get_property = cros_pchg_get_prop;
325 		psy_desc->external_power_changed = NULL;
326 		psy_desc->properties = cros_pchg_props;
327 		psy_desc->num_properties = ARRAY_SIZE(cros_pchg_props);
328 		psy_cfg.drv_data = port;
329 
330 		psy = devm_power_supply_register(dev, psy_desc, &psy_cfg);
331 		if (IS_ERR(psy))
332 			return dev_err_probe(dev, PTR_ERR(psy),
333 					"Failed to register power supply\n");
334 		port->psy = psy;
335 
336 		charger->ports[charger->num_registered_psy++] = port;
337 	}
338 
339 	if (!charger->num_registered_psy)
340 		return -ENODEV;
341 
342 	nb = &charger->notifier;
343 	nb->notifier_call = cros_ec_notify;
344 	ret = blocking_notifier_chain_register(&ec_dev->ec_dev->event_notifier,
345 					       nb);
346 	if (ret < 0)
347 		dev_err(dev, "Failed to register notifier (err:%d)\n", ret);
348 
349 	return 0;
350 }
351 
352 static struct platform_driver cros_pchg_driver = {
353 	.driver = {
354 		.name = DRV_NAME,
355 	},
356 	.probe = cros_pchg_probe
357 };
358 
359 module_platform_driver(cros_pchg_driver);
360 
361 MODULE_LICENSE("GPL");
362 MODULE_DESCRIPTION("ChromeOS EC peripheral device charger");
363 MODULE_ALIAS("platform:" DRV_NAME);
364