platform/chrome/cros_usbpd_logger.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Logging driver for ChromeOS EC based USBPD Charger.
0004  *
0005  * Copyright 2018 Google LLC.
0006  */
0007
0008 #include <linux/ktime.h>
0009 #include <linux/math64.h>
0010 #include <linux/module.h>
0011 #include <linux/platform_data/cros_ec_commands.h>
0012 #include <linux/platform_data/cros_ec_proto.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/rtc.h>
0015
0016 #define DRV_NAME "cros-usbpd-logger"
0017
0018 #define CROS_USBPD_MAX_LOG_ENTRIES  30
0019 #define CROS_USBPD_LOG_UPDATE_DELAY msecs_to_jiffies(60000)
0020 #define CROS_USBPD_DATA_SIZE        16
0021 #define CROS_USBPD_LOG_RESP_SIZE    (sizeof(struct ec_response_pd_log) + \
0022                      CROS_USBPD_DATA_SIZE)
0023 #define CROS_USBPD_BUFFER_SIZE      (sizeof(struct cros_ec_command) + \
0024                      CROS_USBPD_LOG_RESP_SIZE)
0025 /* Buffer for building the PDLOG string */
0026 #define BUF_SIZE    80
0027
0028 struct logger_data {
0029     struct device *dev;
0030     struct cros_ec_dev *ec_dev;
0031     u8 ec_buffer[CROS_USBPD_BUFFER_SIZE];
0032     struct delayed_work log_work;
0033     struct workqueue_struct *log_workqueue;
0034 };
0035
0036 static const char * const chg_type_names[] = {
0037     "None", "PD", "Type-C", "Proprietary", "DCP", "CDP", "SDP",
0038     "Other", "VBUS"
0039 };
0040
0041 static const char * const role_names[] = {
0042     "Disconnected", "SRC", "SNK", "SNK (not charging)"
0043 };
0044
0045 static const char * const fault_names[] = {
0046     "---", "OCP", "fast OCP", "OVP", "Discharge"
0047 };
0048
0049 __printf(3, 4)
0050 static int append_str(char *buf, int pos, const char *fmt, ...)
0051 {
0052     va_list args;
0053     int i;
0054
0055     va_start(args, fmt);
0056     i = vsnprintf(buf + pos, BUF_SIZE - pos, fmt, args);
0057     va_end(args);
0058
0059     return i;
0060 }
0061
0062 static struct ec_response_pd_log *ec_get_log_entry(struct logger_data *logger)
0063 {
0064     struct cros_ec_dev *ec_dev = logger->ec_dev;
0065     struct cros_ec_command *msg;
0066     int ret;
0067
0068     msg = (struct cros_ec_command *)logger->ec_buffer;
0069
0070     msg->command = ec_dev->cmd_offset + EC_CMD_PD_GET_LOG_ENTRY;
0071     msg->insize = CROS_USBPD_LOG_RESP_SIZE;
0072
0073     ret = cros_ec_cmd_xfer_status(ec_dev->ec_dev, msg);
0074     if (ret < 0)
0075         return ERR_PTR(ret);
0076
0077     return (struct ec_response_pd_log *)msg->data;
0078 }
0079
0080 static void cros_usbpd_print_log_entry(struct ec_response_pd_log *r,
0081                        ktime_t tstamp)
0082 {
0083     const char *fault, *role, *chg_type;
0084     struct usb_chg_measures *meas;
0085     struct mcdp_info *minfo;
0086     int role_idx, type_idx;
0087     char buf[BUF_SIZE + 1];
0088     struct rtc_time rt;
0089     int len = 0;
0090     s32 rem;
0091     int i;
0092
0093     /* The timestamp is the number of 1024th of seconds in the past */
0094     tstamp = ktime_sub_us(tstamp, r->timestamp << PD_LOG_TIMESTAMP_SHIFT);
0095     rt = rtc_ktime_to_tm(tstamp);
0096
0097     switch (r->type) {
0098     case PD_EVENT_MCU_CHARGE:
0099         if (r->data & CHARGE_FLAGS_OVERRIDE)
0100             len += append_str(buf, len, "override ");
0101
0102         if (r->data & CHARGE_FLAGS_DELAYED_OVERRIDE)
0103             len += append_str(buf, len, "pending_override ");
0104
0105         role_idx = r->data & CHARGE_FLAGS_ROLE_MASK;
0106         role = role_idx < ARRAY_SIZE(role_names) ?
0107             role_names[role_idx] : "Unknown";
0108
0109         type_idx = (r->data & CHARGE_FLAGS_TYPE_MASK)
0110              >> CHARGE_FLAGS_TYPE_SHIFT;
0111
0112         chg_type = type_idx < ARRAY_SIZE(chg_type_names) ?
0113             chg_type_names[type_idx] : "???";
0114
0115         if (role_idx == USB_PD_PORT_POWER_DISCONNECTED ||
0116             role_idx == USB_PD_PORT_POWER_SOURCE) {
0117             len += append_str(buf, len, "%s", role);
0118             break;
0119         }
0120
0121         meas = (struct usb_chg_measures *)r->payload;
0122         len += append_str(buf, len, "%s %s %s %dmV max %dmV / %dmA",
0123                   role, r->data & CHARGE_FLAGS_DUAL_ROLE ?
0124                   "DRP" : "Charger",
0125                   chg_type, meas->voltage_now,
0126                   meas->voltage_max, meas->current_max);
0127         break;
0128     case PD_EVENT_ACC_RW_FAIL:
0129         len += append_str(buf, len, "RW signature check failed");
0130         break;
0131     case PD_EVENT_PS_FAULT:
0132         fault = r->data < ARRAY_SIZE(fault_names) ? fault_names[r->data]
0133                               : "???";
0134         len += append_str(buf, len, "Power supply fault: %s", fault);
0135         break;
0136     case PD_EVENT_VIDEO_DP_MODE:
0137         len += append_str(buf, len, "DP mode %sabled", r->data == 1 ?
0138                   "en" : "dis");
0139         break;
0140     case PD_EVENT_VIDEO_CODEC:
0141         minfo = (struct mcdp_info *)r->payload;
0142         len += append_str(buf, len, "HDMI info: family:%04x chipid:%04x ",
0143                   MCDP_FAMILY(minfo->family),
0144                   MCDP_CHIPID(minfo->chipid));
0145         len += append_str(buf, len, "irom:%d.%d.%d fw:%d.%d.%d",
0146                   minfo->irom.major, minfo->irom.minor,
0147                   minfo->irom.build, minfo->fw.major,
0148                   minfo->fw.minor, minfo->fw.build);
0149         break;
0150     default:
0151         len += append_str(buf, len, "Event %02x (%04x) [", r->type,
0152                   r->data);
0153
0154         for (i = 0; i < PD_LOG_SIZE(r->size_port); i++)
0155             len += append_str(buf, len, "%02x ", r->payload[i]);
0156
0157         len += append_str(buf, len, "]");
0158         break;
0159     }
0160
0161     div_s64_rem(ktime_to_ms(tstamp), MSEC_PER_SEC, &rem);
0162     pr_info("PDLOG %d/%02d/%02d %02d:%02d:%02d.%03d P%d %s\n",
0163         rt.tm_year + 1900, rt.tm_mon + 1, rt.tm_mday,
0164         rt.tm_hour, rt.tm_min, rt.tm_sec, rem,
0165         PD_LOG_PORT(r->size_port), buf);
0166 }
0167
0168 static void cros_usbpd_log_check(struct work_struct *work)
0169 {
0170     struct logger_data *logger = container_of(to_delayed_work(work),
0171                           struct logger_data,
0172                           log_work);
0173     struct device *dev = logger->dev;
0174     struct ec_response_pd_log *r;
0175     int entries = 0;
0176     ktime_t now;
0177
0178     while (entries++ < CROS_USBPD_MAX_LOG_ENTRIES) {
0179         r = ec_get_log_entry(logger);
0180         now = ktime_get_real();
0181         if (IS_ERR(r)) {
0182             dev_dbg(dev, "Cannot get PD log %ld\n", PTR_ERR(r));
0183             break;
0184         }
0185         if (r->type == PD_EVENT_NO_ENTRY)
0186             break;
0187
0188         cros_usbpd_print_log_entry(r, now);
0189     }
0190
0191     queue_delayed_work(logger->log_workqueue, &logger->log_work,
0192                CROS_USBPD_LOG_UPDATE_DELAY);
0193 }
0194
0195 static int cros_usbpd_logger_probe(struct platform_device *pd)
0196 {
0197     struct cros_ec_dev *ec_dev = dev_get_drvdata(pd->dev.parent);
0198     struct device *dev = &pd->dev;
0199     struct logger_data *logger;
0200
0201     logger = devm_kzalloc(dev, sizeof(*logger), GFP_KERNEL);
0202     if (!logger)
0203         return -ENOMEM;
0204
0205     logger->dev = dev;
0206     logger->ec_dev = ec_dev;
0207
0208     platform_set_drvdata(pd, logger);
0209
0210     /* Retrieve PD event logs periodically */
0211     INIT_DELAYED_WORK(&logger->log_work, cros_usbpd_log_check);
0212     logger->log_workqueue = create_singlethread_workqueue("cros_usbpd_log");
0213     if (!logger->log_workqueue)
0214         return -ENOMEM;
0215
0216     queue_delayed_work(logger->log_workqueue, &logger->log_work,
0217                CROS_USBPD_LOG_UPDATE_DELAY);
0218
0219     return 0;
0220 }
0221
0222 static int cros_usbpd_logger_remove(struct platform_device *pd)
0223 {
0224     struct logger_data *logger = platform_get_drvdata(pd);
0225
0226     cancel_delayed_work_sync(&logger->log_work);
0227     destroy_workqueue(logger->log_workqueue);
0228
0229     return 0;
0230 }
0231
0232 static int __maybe_unused cros_usbpd_logger_resume(struct device *dev)
0233 {
0234     struct logger_data *logger = dev_get_drvdata(dev);
0235
0236     queue_delayed_work(logger->log_workqueue, &logger->log_work,
0237                CROS_USBPD_LOG_UPDATE_DELAY);
0238
0239     return 0;
0240 }
0241
0242 static int __maybe_unused cros_usbpd_logger_suspend(struct device *dev)
0243 {
0244     struct logger_data *logger = dev_get_drvdata(dev);
0245
0246     cancel_delayed_work_sync(&logger->log_work);
0247
0248     return 0;
0249 }
0250
0251 static SIMPLE_DEV_PM_OPS(cros_usbpd_logger_pm_ops, cros_usbpd_logger_suspend,
0252              cros_usbpd_logger_resume);
0253
0254 static struct platform_driver cros_usbpd_logger_driver = {
0255     .driver = {
0256         .name = DRV_NAME,
0257         .pm = &cros_usbpd_logger_pm_ops,
0258     },
0259     .probe = cros_usbpd_logger_probe,
0260     .remove = cros_usbpd_logger_remove,
0261 };
0262
0263 module_platform_driver(cros_usbpd_logger_driver);
0264
0265 MODULE_LICENSE("GPL v2");
0266 MODULE_DESCRIPTION("Logging driver for ChromeOS EC USBPD Charger.");
0267 MODULE_ALIAS("platform:" DRV_NAME);