1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Logging driver for ChromeOS EC based USBPD Charger. 4 * 5 * Copyright 2018 Google LLC. 6 */ 7 8 #include <linux/devm-helpers.h> 9 #include <linux/ktime.h> 10 #include <linux/math64.h> 11 #include <linux/mod_devicetable.h> 12 #include <linux/module.h> 13 #include <linux/platform_data/cros_ec_commands.h> 14 #include <linux/platform_data/cros_ec_proto.h> 15 #include <linux/platform_device.h> 16 #include <linux/rtc.h> 17 #include <linux/string_choices.h> 18 19 #define DRV_NAME "cros-usbpd-logger" 20 21 #define CROS_USBPD_MAX_LOG_ENTRIES 30 22 #define CROS_USBPD_LOG_UPDATE_DELAY msecs_to_jiffies(60000) 23 #define CROS_USBPD_DATA_SIZE 16 24 #define CROS_USBPD_LOG_RESP_SIZE (sizeof(struct ec_response_pd_log) + \ 25 CROS_USBPD_DATA_SIZE) 26 #define CROS_USBPD_BUFFER_SIZE (sizeof(struct cros_ec_command) + \ 27 CROS_USBPD_LOG_RESP_SIZE) 28 /* Buffer for building the PDLOG string */ 29 #define BUF_SIZE 80 30 31 struct logger_data { 32 struct device *dev; 33 struct cros_ec_dev *ec_dev; 34 u8 ec_buffer[CROS_USBPD_BUFFER_SIZE]; 35 struct delayed_work log_work; 36 struct workqueue_struct *log_workqueue; 37 }; 38 39 static const char * const chg_type_names[] = { 40 "None", "PD", "Type-C", "Proprietary", "DCP", "CDP", "SDP", 41 "Other", "VBUS" 42 }; 43 44 static const char * const role_names[] = { 45 "Disconnected", "SRC", "SNK", "SNK (not charging)" 46 }; 47 48 static const char * const fault_names[] = { 49 "---", "OCP", "fast OCP", "OVP", "Discharge" 50 }; 51 52 __printf(3, 4) 53 static int append_str(char *buf, int pos, const char *fmt, ...) 54 { 55 va_list args; 56 int i; 57 58 va_start(args, fmt); 59 i = vsnprintf(buf + pos, BUF_SIZE - pos, fmt, args); 60 va_end(args); 61 62 return i; 63 } 64 65 static struct ec_response_pd_log *ec_get_log_entry(struct logger_data *logger) 66 { 67 struct cros_ec_dev *ec_dev = logger->ec_dev; 68 struct cros_ec_command *msg; 69 int ret; 70 71 msg = (struct cros_ec_command *)logger->ec_buffer; 72 73 msg->command = ec_dev->cmd_offset + EC_CMD_PD_GET_LOG_ENTRY; 74 msg->insize = CROS_USBPD_LOG_RESP_SIZE; 75 76 ret = cros_ec_cmd_xfer_status(ec_dev->ec_dev, msg); 77 if (ret < 0) 78 return ERR_PTR(ret); 79 80 return (struct ec_response_pd_log *)msg->data; 81 } 82 83 static void cros_usbpd_print_log_entry(struct ec_response_pd_log *r, 84 ktime_t tstamp) 85 { 86 const char *fault, *role, *chg_type; 87 struct usb_chg_measures *meas; 88 struct mcdp_info *minfo; 89 int role_idx, type_idx; 90 char buf[BUF_SIZE + 1]; 91 struct rtc_time rt; 92 int len = 0; 93 s32 rem; 94 int i; 95 96 /* The timestamp is the number of 1024th of seconds in the past */ 97 tstamp = ktime_sub_us(tstamp, r->timestamp << PD_LOG_TIMESTAMP_SHIFT); 98 rt = rtc_ktime_to_tm(tstamp); 99 100 switch (r->type) { 101 case PD_EVENT_MCU_CHARGE: 102 if (r->data & CHARGE_FLAGS_OVERRIDE) 103 len += append_str(buf, len, "override "); 104 105 if (r->data & CHARGE_FLAGS_DELAYED_OVERRIDE) 106 len += append_str(buf, len, "pending_override "); 107 108 role_idx = r->data & CHARGE_FLAGS_ROLE_MASK; 109 role = role_idx < ARRAY_SIZE(role_names) ? 110 role_names[role_idx] : "Unknown"; 111 112 type_idx = (r->data & CHARGE_FLAGS_TYPE_MASK) 113 >> CHARGE_FLAGS_TYPE_SHIFT; 114 115 chg_type = type_idx < ARRAY_SIZE(chg_type_names) ? 116 chg_type_names[type_idx] : "???"; 117 118 if (role_idx == USB_PD_PORT_POWER_DISCONNECTED || 119 role_idx == USB_PD_PORT_POWER_SOURCE) { 120 len += append_str(buf, len, "%s", role); 121 break; 122 } 123 124 meas = (struct usb_chg_measures *)r->payload; 125 len += append_str(buf, len, "%s %s %s %dmV max %dmV / %dmA", 126 role, r->data & CHARGE_FLAGS_DUAL_ROLE ? 127 "DRP" : "Charger", 128 chg_type, meas->voltage_now, 129 meas->voltage_max, meas->current_max); 130 break; 131 case PD_EVENT_ACC_RW_FAIL: 132 len += append_str(buf, len, "RW signature check failed"); 133 break; 134 case PD_EVENT_PS_FAULT: 135 fault = r->data < ARRAY_SIZE(fault_names) ? fault_names[r->data] 136 : "???"; 137 len += append_str(buf, len, "Power supply fault: %s", fault); 138 break; 139 case PD_EVENT_VIDEO_DP_MODE: 140 len += append_str(buf, len, "DP mode %s", 141 str_enabled_disabled(r->data == 1)); 142 break; 143 case PD_EVENT_VIDEO_CODEC: 144 minfo = (struct mcdp_info *)r->payload; 145 len += append_str(buf, len, "HDMI info: family:%04x chipid:%04x ", 146 MCDP_FAMILY(minfo->family), 147 MCDP_CHIPID(minfo->chipid)); 148 len += append_str(buf, len, "irom:%d.%d.%d fw:%d.%d.%d", 149 minfo->irom.major, minfo->irom.minor, 150 minfo->irom.build, minfo->fw.major, 151 minfo->fw.minor, minfo->fw.build); 152 break; 153 default: 154 len += append_str(buf, len, "Event %02x (%04x) [", r->type, 155 r->data); 156 157 for (i = 0; i < PD_LOG_SIZE(r->size_port); i++) 158 len += append_str(buf, len, "%02x ", r->payload[i]); 159 160 len += append_str(buf, len, "]"); 161 break; 162 } 163 164 div_s64_rem(ktime_to_ms(tstamp), MSEC_PER_SEC, &rem); 165 pr_info("PDLOG %d/%02d/%02d %02d:%02d:%02d.%03d P%d %s\n", 166 rt.tm_year + 1900, rt.tm_mon + 1, rt.tm_mday, 167 rt.tm_hour, rt.tm_min, rt.tm_sec, rem, 168 PD_LOG_PORT(r->size_port), buf); 169 } 170 171 static void cros_usbpd_log_check(struct work_struct *work) 172 { 173 struct logger_data *logger = container_of(to_delayed_work(work), 174 struct logger_data, 175 log_work); 176 struct device *dev = logger->dev; 177 struct ec_response_pd_log *r; 178 int entries = 0; 179 ktime_t now; 180 181 while (entries++ < CROS_USBPD_MAX_LOG_ENTRIES) { 182 r = ec_get_log_entry(logger); 183 now = ktime_get_real(); 184 if (IS_ERR(r)) { 185 dev_dbg(dev, "Cannot get PD log %ld\n", PTR_ERR(r)); 186 break; 187 } 188 if (r->type == PD_EVENT_NO_ENTRY) 189 break; 190 191 cros_usbpd_print_log_entry(r, now); 192 } 193 194 queue_delayed_work(logger->log_workqueue, &logger->log_work, 195 CROS_USBPD_LOG_UPDATE_DELAY); 196 } 197 198 static int cros_usbpd_logger_probe(struct platform_device *pd) 199 { 200 struct cros_ec_dev *ec_dev = dev_get_drvdata(pd->dev.parent); 201 struct device *dev = &pd->dev; 202 struct logger_data *logger; 203 int ret; 204 205 logger = devm_kzalloc(dev, sizeof(*logger), GFP_KERNEL); 206 if (!logger) 207 return -ENOMEM; 208 209 logger->dev = dev; 210 logger->ec_dev = ec_dev; 211 212 platform_set_drvdata(pd, logger); 213 214 /* Retrieve PD event logs periodically */ 215 logger->log_workqueue = devm_alloc_ordered_workqueue(dev, "cros_usbpd_log", 0); 216 if (!logger->log_workqueue) 217 return -ENOMEM; 218 219 ret = devm_delayed_work_autocancel(dev, &logger->log_work, cros_usbpd_log_check); 220 if (ret) 221 return ret; 222 223 queue_delayed_work(logger->log_workqueue, &logger->log_work, 224 CROS_USBPD_LOG_UPDATE_DELAY); 225 226 return 0; 227 } 228 229 static int __maybe_unused cros_usbpd_logger_resume(struct device *dev) 230 { 231 struct logger_data *logger = dev_get_drvdata(dev); 232 233 queue_delayed_work(logger->log_workqueue, &logger->log_work, 234 CROS_USBPD_LOG_UPDATE_DELAY); 235 236 return 0; 237 } 238 239 static int __maybe_unused cros_usbpd_logger_suspend(struct device *dev) 240 { 241 struct logger_data *logger = dev_get_drvdata(dev); 242 243 cancel_delayed_work_sync(&logger->log_work); 244 245 return 0; 246 } 247 248 static SIMPLE_DEV_PM_OPS(cros_usbpd_logger_pm_ops, cros_usbpd_logger_suspend, 249 cros_usbpd_logger_resume); 250 251 static const struct platform_device_id cros_usbpd_logger_id[] = { 252 { DRV_NAME, 0 }, 253 {} 254 }; 255 MODULE_DEVICE_TABLE(platform, cros_usbpd_logger_id); 256 257 static struct platform_driver cros_usbpd_logger_driver = { 258 .driver = { 259 .name = DRV_NAME, 260 .pm = &cros_usbpd_logger_pm_ops, 261 }, 262 .probe = cros_usbpd_logger_probe, 263 .id_table = cros_usbpd_logger_id, 264 }; 265 266 module_platform_driver(cros_usbpd_logger_driver); 267 268 MODULE_LICENSE("GPL v2"); 269 MODULE_DESCRIPTION("Logging driver for ChromeOS EC USBPD Charger."); 270