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(struct_size(msg, data, 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 { 232 int i; 233 234 for (i = 0; i < charger->num_registered_psy; i++) 235 cros_pchg_get_port_status(charger->ports[i], false); 236 237 return NOTIFY_OK; 238 } 239 240 static int cros_ec_notify(struct notifier_block *nb, 241 unsigned long queued_during_suspend, 242 void *data) 243 { 244 struct cros_ec_device *ec_dev = data; 245 struct charger_data *charger = 246 container_of(nb, struct charger_data, notifier); 247 u32 host_event; 248 249 if (ec_dev->event_data.event_type != EC_MKBP_EVENT_PCHG || 250 ec_dev->event_size != sizeof(host_event)) 251 return NOTIFY_DONE; 252 253 host_event = get_unaligned_le32(&ec_dev->event_data.data.host_event); 254 255 if (!(host_event & EC_MKBP_PCHG_DEVICE_EVENT)) 256 return NOTIFY_DONE; 257 258 return cros_pchg_event(charger); 259 } 260 261 static int cros_pchg_probe(struct platform_device *pdev) 262 { 263 struct device *dev = &pdev->dev; 264 struct cros_ec_dev *ec_dev = dev_get_drvdata(dev->parent); 265 struct cros_ec_device *ec_device = ec_dev->ec_dev; 266 struct power_supply_desc *psy_desc; 267 struct charger_data *charger; 268 struct power_supply *psy; 269 struct port_data *port; 270 struct notifier_block *nb; 271 int num_ports; 272 int ret; 273 int i; 274 275 charger = devm_kzalloc(dev, sizeof(*charger), GFP_KERNEL); 276 if (!charger) 277 return -ENOMEM; 278 279 charger->dev = dev; 280 charger->ec_dev = ec_dev; 281 charger->ec_device = ec_device; 282 283 platform_set_drvdata(pdev, charger); 284 285 ret = cros_pchg_port_count(charger); 286 if (ret <= 0) { 287 /* 288 * This feature is enabled by the EC and the kernel driver is 289 * included by default for CrOS devices. Don't need to be loud 290 * since this error can be normal. 291 */ 292 dev_info(dev, "No peripheral charge ports (err:%d)\n", ret); 293 return -ENODEV; 294 } 295 296 if (!cros_pchg_cmd_ver_check(charger)) { 297 dev_err(dev, "EC_CMD_PCHG version %d isn't available.\n", 298 pchg_cmd_version); 299 return -EOPNOTSUPP; 300 } 301 302 num_ports = ret; 303 if (num_ports > EC_PCHG_MAX_PORTS) { 304 dev_err(dev, "Too many peripheral charge ports (%d)\n", 305 num_ports); 306 return -ENOBUFS; 307 } 308 309 dev_info(dev, "%d peripheral charge ports found\n", num_ports); 310 311 for (i = 0; i < num_ports; i++) { 312 struct power_supply_config psy_cfg = {}; 313 314 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); 315 if (!port) 316 return -ENOMEM; 317 318 port->charger = charger; 319 port->port_number = i; 320 snprintf(port->name, sizeof(port->name), PCHG_DIR_NAME, i); 321 322 psy_desc = &port->psy_desc; 323 psy_desc->name = port->name; 324 psy_desc->type = POWER_SUPPLY_TYPE_BATTERY; 325 psy_desc->get_property = cros_pchg_get_prop; 326 psy_desc->external_power_changed = NULL; 327 psy_desc->properties = cros_pchg_props; 328 psy_desc->num_properties = ARRAY_SIZE(cros_pchg_props); 329 psy_cfg.drv_data = port; 330 331 psy = devm_power_supply_register(dev, psy_desc, &psy_cfg); 332 if (IS_ERR(psy)) 333 return dev_err_probe(dev, PTR_ERR(psy), 334 "Failed to register power supply\n"); 335 port->psy = psy; 336 337 charger->ports[charger->num_registered_psy++] = port; 338 } 339 340 if (!charger->num_registered_psy) 341 return -ENODEV; 342 343 nb = &charger->notifier; 344 nb->notifier_call = cros_ec_notify; 345 ret = blocking_notifier_chain_register(&ec_dev->ec_dev->event_notifier, 346 nb); 347 if (ret < 0) 348 dev_err(dev, "Failed to register notifier (err:%d)\n", ret); 349 350 return 0; 351 } 352 353 #ifdef CONFIG_PM_SLEEP 354 static int __maybe_unused cros_pchg_resume(struct device *dev) 355 { 356 struct charger_data *charger = dev_get_drvdata(dev); 357 358 /* 359 * Sync all ports on resume in case reports from EC are lost during 360 * the last suspend. 361 */ 362 cros_pchg_event(charger); 363 364 return 0; 365 } 366 #endif 367 368 static SIMPLE_DEV_PM_OPS(cros_pchg_pm_ops, NULL, cros_pchg_resume); 369 370 static struct platform_driver cros_pchg_driver = { 371 .driver = { 372 .name = DRV_NAME, 373 .pm = &cros_pchg_pm_ops, 374 }, 375 .probe = cros_pchg_probe 376 }; 377 378 module_platform_driver(cros_pchg_driver); 379 380 MODULE_LICENSE("GPL"); 381 MODULE_DESCRIPTION("ChromeOS EC peripheral device charger"); 382 MODULE_ALIAS("platform:" DRV_NAME); 383