tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Merge tag 'tag-chrome-platform-for-v5.6' of git://git.kernel.org/pub/scm/linux/kernel/git/chrome-platform/linux

Pull chrome platform updates from Benson Leung:
"CrOS EC:

- Refactoring of some of cros_ec's headers:

include/linux/mfd/cros_ec.h now removed, new cros_ec.h added to
drivers/platform/chrome which contains shared operations of cros_ec
transport drivers.

- Response tracing in cros_ec_proto

Wilco EC:

- Fix unregistration order.

- Fix keyboard backlight probing on systems without keyboard
backlight

- Minor cleanup (newlines in printks, COMPILE_TEST)

Misc:

- chromeos_laptop converted to use i2c_new_scanned_device instead of
i2c_new_probed_device"

* tag 'tag-chrome-platform-for-v5.6' of git://git.kernel.org/pub/scm/linux/kernel/git/chrome-platform/linux:
platform/chrome: cros_ec: Match implementation with headers
platform/chrome: cros_ec: Drop unaligned.h include
platform/chrome: wilco_ec: Allow wilco to be compiled in COMPILE_TEST
platform/chrome: wilco_ec: Add newlines to printks
platform/chrome: wilco_ec: Fix unregistration order
cros_ec: treewide: Remove 'include/linux/mfd/cros_ec.h'
platform/chrome: cros_ec_ishtp: Make init_lock static
platform/chrome: chromeos_laptop: Convert to i2c_new_scanned_device
platform/chrome: cros_ec_lpc: Use platform_get_irq_optional() for optional IRQs
platform/chrome: cros_ec_proto: Add response tracing
platform/chrome: cros_ec_trace: Match trace commands with EC commands

Linus Torvalds 79703e01 eadc4e40

+190 -97
-1
drivers/iio/accel/cros_ec_accel_legacy.c
··· 18 18 #include <linux/iio/trigger_consumer.h> 19 19 #include <linux/iio/triggered_buffer.h> 20 20 #include <linux/kernel.h> 21 - #include <linux/mfd/cros_ec.h> 22 21 #include <linux/module.h> 23 22 #include <linux/slab.h> 24 23 #include <linux/platform_data/cros_ec_commands.h>
-1
drivers/iio/common/cros_ec_sensors/cros_ec_sensors.c
··· 16 16 #include <linux/iio/trigger_consumer.h> 17 17 #include <linux/iio/triggered_buffer.h> 18 18 #include <linux/kernel.h> 19 - #include <linux/mfd/cros_ec.h> 20 19 #include <linux/module.h> 21 20 #include <linux/platform_data/cros_ec_commands.h> 22 21 #include <linux/platform_data/cros_ec_proto.h>
-1
drivers/iio/common/cros_ec_sensors/cros_ec_sensors_core.c
··· 13 13 #include <linux/iio/kfifo_buf.h> 14 14 #include <linux/iio/trigger_consumer.h> 15 15 #include <linux/kernel.h> 16 - #include <linux/mfd/cros_ec.h> 17 16 #include <linux/module.h> 18 17 #include <linux/slab.h> 19 18 #include <linux/platform_data/cros_ec_commands.h>
-1
drivers/iio/light/cros_ec_light_prox.c
··· 14 14 #include <linux/iio/triggered_buffer.h> 15 15 #include <linux/iio/trigger_consumer.h> 16 16 #include <linux/kernel.h> 17 - #include <linux/mfd/cros_ec.h> 18 17 #include <linux/module.h> 19 18 #include <linux/platform_data/cros_ec_commands.h> 20 19 #include <linux/platform_data/cros_ec_proto.h>
-1
drivers/iio/pressure/cros_ec_baro.c
··· 14 14 #include <linux/iio/triggered_buffer.h> 15 15 #include <linux/iio/trigger_consumer.h> 16 16 #include <linux/kernel.h> 17 - #include <linux/mfd/cros_ec.h> 18 17 #include <linux/module.h> 19 18 #include <linux/slab.h> 20 19 #include <linux/platform_data/cros_ec_commands.h>
-1
drivers/media/platform/cros-ec-cec/cros-ec-cec.c
··· 14 14 #include <linux/cec.h> 15 15 #include <linux/slab.h> 16 16 #include <linux/interrupt.h> 17 - #include <linux/mfd/cros_ec.h> 18 17 #include <linux/platform_data/cros_ec_commands.h> 19 18 #include <linux/platform_data/cros_ec_proto.h> 20 19 #include <media/cec.h>
-1
drivers/mfd/cros_ec_dev.c
··· 7 7 8 8 #include <linux/kconfig.h> 9 9 #include <linux/mfd/core.h> 10 - #include <linux/mfd/cros_ec.h> 11 10 #include <linux/module.h> 12 11 #include <linux/mod_devicetable.h> 13 12 #include <linux/of_platform.h>
+10 -8
drivers/platform/chrome/chromeos_laptop.c
··· 63 63 struct chromeos_laptop { 64 64 /* 65 65 * Note that we can't mark this pointer as const because 66 - * i2c_new_probed_device() changes passed in I2C board info, so. 66 + * i2c_new_scanned_device() changes passed in I2C board info, so. 67 67 */ 68 68 struct i2c_peripheral *i2c_peripherals; 69 69 unsigned int num_i2c_peripherals; ··· 87 87 * address we scan secondary addresses. In any case the client 88 88 * structure gets assigned primary address. 89 89 */ 90 - client = i2c_new_probed_device(adapter, info, addr_list, NULL); 91 - if (!client && alt_addr) { 90 + client = i2c_new_scanned_device(adapter, info, addr_list, NULL); 91 + if (IS_ERR(client) && alt_addr) { 92 92 struct i2c_board_info dummy_info = { 93 93 I2C_BOARD_INFO("dummy", info->addr), 94 94 }; ··· 97 97 }; 98 98 struct i2c_client *dummy; 99 99 100 - dummy = i2c_new_probed_device(adapter, &dummy_info, 101 - alt_addr_list, NULL); 102 - if (dummy) { 100 + dummy = i2c_new_scanned_device(adapter, &dummy_info, 101 + alt_addr_list, NULL); 102 + if (!IS_ERR(dummy)) { 103 103 pr_debug("%d-%02x is probed at %02x\n", 104 104 adapter->nr, info->addr, dummy->addr); 105 105 i2c_unregister_device(dummy); ··· 107 107 } 108 108 } 109 109 110 - if (!client) 110 + if (IS_ERR(client)) { 111 + client = NULL; 111 112 pr_debug("failed to register device %d-%02x\n", 112 113 adapter->nr, info->addr); 113 - else 114 + } else { 114 115 pr_debug("added i2c device %d-%02x\n", 115 116 adapter->nr, info->addr); 117 + } 116 118 117 119 return client; 118 120 }
+2 -1
drivers/platform/chrome/cros_ec.c
··· 16 16 #include <linux/platform_data/cros_ec_commands.h> 17 17 #include <linux/platform_data/cros_ec_proto.h> 18 18 #include <linux/suspend.h> 19 - #include <asm/unaligned.h> 19 + 20 + #include "cros_ec.h" 20 21 21 22 #define CROS_EC_DEV_EC_INDEX 0 22 23 #define CROS_EC_DEV_PD_INDEX 1
+19
drivers/platform/chrome/cros_ec.h
··· 1 + /* SPDX-License-Identifier: GPL-2.0-only */ 2 + /* 3 + * ChromeOS Embedded Controller core interface. 4 + * 5 + * Copyright (C) 2020 Google LLC 6 + */ 7 + 8 + #ifndef __CROS_EC_H 9 + #define __CROS_EC_H 10 + 11 + int cros_ec_register(struct cros_ec_device *ec_dev); 12 + int cros_ec_unregister(struct cros_ec_device *ec_dev); 13 + 14 + int cros_ec_suspend(struct cros_ec_device *ec_dev); 15 + int cros_ec_resume(struct cros_ec_device *ec_dev); 16 + 17 + bool cros_ec_handle_event(struct cros_ec_device *ec_dev); 18 + 19 + #endif /* __CROS_EC_H */
-1
drivers/platform/chrome/cros_ec_chardev.c
··· 13 13 #include <linux/init.h> 14 14 #include <linux/device.h> 15 15 #include <linux/fs.h> 16 - #include <linux/mfd/cros_ec.h> 17 16 #include <linux/miscdevice.h> 18 17 #include <linux/module.h> 19 18 #include <linux/notifier.h>
-1
drivers/platform/chrome/cros_ec_debugfs.c
··· 7 7 #include <linux/debugfs.h> 8 8 #include <linux/delay.h> 9 9 #include <linux/fs.h> 10 - #include <linux/mfd/cros_ec.h> 11 10 #include <linux/module.h> 12 11 #include <linux/mutex.h> 13 12 #include <linux/platform_data/cros_ec_commands.h>
+2
drivers/platform/chrome/cros_ec_i2c.c
··· 14 14 #include <linux/platform_device.h> 15 15 #include <linux/slab.h> 16 16 17 + #include "cros_ec.h" 18 + 17 19 /** 18 20 * Request format for protocol v3 19 21 * byte 0 0xda (EC_COMMAND_PROTOCOL_3)
+3 -1
drivers/platform/chrome/cros_ec_ishtp.c
··· 14 14 #include <linux/platform_data/cros_ec_proto.h> 15 15 #include <linux/intel-ish-client-if.h> 16 16 17 + #include "cros_ec.h" 18 + 17 19 /* 18 20 * ISH TX/RX ring buffer pool size 19 21 * ··· 78 76 * 79 77 * The writers are .reset() and .probe() function. 80 78 */ 81 - DECLARE_RWSEM(init_lock); 79 + static DECLARE_RWSEM(init_lock); 82 80 83 81 /** 84 82 * struct response_info - Encapsulate firmware response related
-1
drivers/platform/chrome/cros_ec_lightbar.c
··· 8 8 #include <linux/device.h> 9 9 #include <linux/fs.h> 10 10 #include <linux/kobject.h> 11 - #include <linux/mfd/cros_ec.h> 12 11 #include <linux/module.h> 13 12 #include <linux/platform_data/cros_ec_commands.h> 14 13 #include <linux/platform_data/cros_ec_proto.h>
+2 -1
drivers/platform/chrome/cros_ec_lpc.c
··· 23 23 #include <linux/printk.h> 24 24 #include <linux/suspend.h> 25 25 26 + #include "cros_ec.h" 26 27 #include "cros_ec_lpc_mec.h" 27 28 28 29 #define DRV_NAME "cros_ec_lpcs" ··· 397 396 * Some boards do not have an IRQ allotted for cros_ec_lpc, 398 397 * which makes ENXIO an expected (and safe) scenario. 399 398 */ 400 - irq = platform_get_irq(pdev, 0); 399 + irq = platform_get_irq_optional(pdev, 0); 401 400 if (irq > 0) 402 401 ec_dev->irq = irq; 403 402 else if (irq != -ENXIO) {
+4 -2
drivers/platform/chrome/cros_ec_proto.c
··· 54 54 int ret; 55 55 int (*xfer_fxn)(struct cros_ec_device *ec, struct cros_ec_command *msg); 56 56 57 - trace_cros_ec_cmd(msg); 58 - 59 57 if (ec_dev->proto_version > 2) 60 58 xfer_fxn = ec_dev->pkt_xfer; 61 59 else ··· 70 72 return -EIO; 71 73 } 72 74 75 + trace_cros_ec_request_start(msg); 73 76 ret = (*xfer_fxn)(ec_dev, msg); 77 + trace_cros_ec_request_done(msg, ret); 74 78 if (msg->result == EC_RES_IN_PROGRESS) { 75 79 int i; 76 80 struct cros_ec_command *status_msg; ··· 95 95 for (i = 0; i < EC_COMMAND_RETRIES; i++) { 96 96 usleep_range(10000, 11000); 97 97 98 + trace_cros_ec_request_start(status_msg); 98 99 ret = (*xfer_fxn)(ec_dev, status_msg); 100 + trace_cros_ec_request_done(status_msg, ret); 99 101 if (ret == -EAGAIN) 100 102 continue; 101 103 if (ret < 0)
+2
drivers/platform/chrome/cros_ec_rpmsg.c
··· 13 13 #include <linux/rpmsg.h> 14 14 #include <linux/slab.h> 15 15 16 + #include "cros_ec.h" 17 + 16 18 #define EC_MSG_TIMEOUT_MS 200 17 19 #define HOST_COMMAND_MARK 1 18 20 #define HOST_EVENT_MARK 2
-1
drivers/platform/chrome/cros_ec_sensorhub.c
··· 9 9 #include <linux/init.h> 10 10 #include <linux/device.h> 11 11 #include <linux/module.h> 12 - #include <linux/mfd/cros_ec.h> 13 12 #include <linux/platform_data/cros_ec_commands.h> 14 13 #include <linux/platform_data/cros_ec_proto.h> 15 14 #include <linux/platform_data/cros_ec_sensorhub.h>
+2
drivers/platform/chrome/cros_ec_spi.c
··· 14 14 #include <linux/spi/spi.h> 15 15 #include <uapi/linux/sched/types.h> 16 16 17 + #include "cros_ec.h" 18 + 17 19 /* The header byte, which follows the preamble */ 18 20 #define EC_MSG_HEADER 0xec 19 21
-1
drivers/platform/chrome/cros_ec_sysfs.c
··· 8 8 #include <linux/device.h> 9 9 #include <linux/fs.h> 10 10 #include <linux/kobject.h> 11 - #include <linux/mfd/cros_ec.h> 12 11 #include <linux/module.h> 13 12 #include <linux/platform_data/cros_ec_commands.h> 14 13 #include <linux/platform_data/cros_ec_proto.h>
+90 -7
drivers/platform/chrome/cros_ec_trace.c
··· 8 8 // Generate the list using the following script: 9 9 // sed -n 's/^#define \(EC_CMD_[[:alnum:]_]*\)\s.*/\tTRACE_SYMBOL(\1), \\/p' include/linux/platform_data/cros_ec_commands.h 10 10 #define EC_CMDS \ 11 + TRACE_SYMBOL(EC_CMD_ACPI_READ), \ 12 + TRACE_SYMBOL(EC_CMD_ACPI_WRITE), \ 13 + TRACE_SYMBOL(EC_CMD_ACPI_BURST_ENABLE), \ 14 + TRACE_SYMBOL(EC_CMD_ACPI_BURST_DISABLE), \ 15 + TRACE_SYMBOL(EC_CMD_ACPI_QUERY_EVENT), \ 11 16 TRACE_SYMBOL(EC_CMD_PROTO_VERSION), \ 12 17 TRACE_SYMBOL(EC_CMD_HELLO), \ 13 18 TRACE_SYMBOL(EC_CMD_GET_VERSION), \ ··· 27 22 TRACE_SYMBOL(EC_CMD_GET_PROTOCOL_INFO), \ 28 23 TRACE_SYMBOL(EC_CMD_GSV_PAUSE_IN_S5), \ 29 24 TRACE_SYMBOL(EC_CMD_GET_FEATURES), \ 25 + TRACE_SYMBOL(EC_CMD_GET_SKU_ID), \ 26 + TRACE_SYMBOL(EC_CMD_SET_SKU_ID), \ 30 27 TRACE_SYMBOL(EC_CMD_FLASH_INFO), \ 31 28 TRACE_SYMBOL(EC_CMD_FLASH_READ), \ 32 29 TRACE_SYMBOL(EC_CMD_FLASH_WRITE), \ ··· 36 29 TRACE_SYMBOL(EC_CMD_FLASH_PROTECT), \ 37 30 TRACE_SYMBOL(EC_CMD_FLASH_REGION_INFO), \ 38 31 TRACE_SYMBOL(EC_CMD_VBNV_CONTEXT), \ 32 + TRACE_SYMBOL(EC_CMD_FLASH_SPI_INFO), \ 33 + TRACE_SYMBOL(EC_CMD_FLASH_SELECT), \ 39 34 TRACE_SYMBOL(EC_CMD_PWM_GET_FAN_TARGET_RPM), \ 40 35 TRACE_SYMBOL(EC_CMD_PWM_SET_FAN_TARGET_RPM), \ 41 36 TRACE_SYMBOL(EC_CMD_PWM_GET_KEYBOARD_BACKLIGHT), \ ··· 49 40 TRACE_SYMBOL(EC_CMD_LED_CONTROL), \ 50 41 TRACE_SYMBOL(EC_CMD_VBOOT_HASH), \ 51 42 TRACE_SYMBOL(EC_CMD_MOTION_SENSE_CMD), \ 43 + TRACE_SYMBOL(EC_CMD_FORCE_LID_OPEN), \ 44 + TRACE_SYMBOL(EC_CMD_CONFIG_POWER_BUTTON), \ 52 45 TRACE_SYMBOL(EC_CMD_USB_CHARGE_SET_MODE), \ 53 46 TRACE_SYMBOL(EC_CMD_PSTORE_INFO), \ 54 47 TRACE_SYMBOL(EC_CMD_PSTORE_READ), \ ··· 61 50 TRACE_SYMBOL(EC_CMD_RTC_SET_ALARM), \ 62 51 TRACE_SYMBOL(EC_CMD_PORT80_LAST_BOOT), \ 63 52 TRACE_SYMBOL(EC_CMD_PORT80_READ), \ 53 + TRACE_SYMBOL(EC_CMD_VSTORE_INFO), \ 54 + TRACE_SYMBOL(EC_CMD_VSTORE_READ), \ 55 + TRACE_SYMBOL(EC_CMD_VSTORE_WRITE), \ 64 56 TRACE_SYMBOL(EC_CMD_THERMAL_SET_THRESHOLD), \ 65 57 TRACE_SYMBOL(EC_CMD_THERMAL_GET_THRESHOLD), \ 66 58 TRACE_SYMBOL(EC_CMD_THERMAL_AUTO_FAN_CTRL), \ ··· 73 59 TRACE_SYMBOL(EC_CMD_MKBP_STATE), \ 74 60 TRACE_SYMBOL(EC_CMD_MKBP_INFO), \ 75 61 TRACE_SYMBOL(EC_CMD_MKBP_SIMULATE_KEY), \ 62 + TRACE_SYMBOL(EC_CMD_GET_KEYBOARD_ID), \ 76 63 TRACE_SYMBOL(EC_CMD_MKBP_SET_CONFIG), \ 77 64 TRACE_SYMBOL(EC_CMD_MKBP_GET_CONFIG), \ 78 65 TRACE_SYMBOL(EC_CMD_KEYSCAN_SEQ_CTRL), \ 79 66 TRACE_SYMBOL(EC_CMD_GET_NEXT_EVENT), \ 67 + TRACE_SYMBOL(EC_CMD_KEYBOARD_FACTORY_TEST), \ 80 68 TRACE_SYMBOL(EC_CMD_TEMP_SENSOR_GET_INFO), \ 81 69 TRACE_SYMBOL(EC_CMD_HOST_EVENT_GET_B), \ 82 70 TRACE_SYMBOL(EC_CMD_HOST_EVENT_GET_SMI_MASK), \ ··· 89 73 TRACE_SYMBOL(EC_CMD_HOST_EVENT_CLEAR), \ 90 74 TRACE_SYMBOL(EC_CMD_HOST_EVENT_SET_WAKE_MASK), \ 91 75 TRACE_SYMBOL(EC_CMD_HOST_EVENT_CLEAR_B), \ 76 + TRACE_SYMBOL(EC_CMD_HOST_EVENT), \ 92 77 TRACE_SYMBOL(EC_CMD_SWITCH_ENABLE_BKLIGHT), \ 93 78 TRACE_SYMBOL(EC_CMD_SWITCH_ENABLE_WIRELESS), \ 94 79 TRACE_SYMBOL(EC_CMD_GPIO_SET), \ ··· 109 92 TRACE_SYMBOL(EC_CMD_CHARGE_STATE), \ 110 93 TRACE_SYMBOL(EC_CMD_CHARGE_CURRENT_LIMIT), \ 111 94 TRACE_SYMBOL(EC_CMD_EXTERNAL_POWER_LIMIT), \ 95 + TRACE_SYMBOL(EC_CMD_OVERRIDE_DEDICATED_CHARGER_LIMIT), \ 96 + TRACE_SYMBOL(EC_CMD_HIBERNATION_DELAY), \ 112 97 TRACE_SYMBOL(EC_CMD_HOST_SLEEP_EVENT), \ 98 + TRACE_SYMBOL(EC_CMD_DEVICE_EVENT), \ 113 99 TRACE_SYMBOL(EC_CMD_SB_READ_WORD), \ 114 100 TRACE_SYMBOL(EC_CMD_SB_WRITE_WORD), \ 115 101 TRACE_SYMBOL(EC_CMD_SB_READ_BLOCK), \ 116 102 TRACE_SYMBOL(EC_CMD_SB_WRITE_BLOCK), \ 117 103 TRACE_SYMBOL(EC_CMD_BATTERY_VENDOR_PARAM), \ 104 + TRACE_SYMBOL(EC_CMD_SB_FW_UPDATE), \ 105 + TRACE_SYMBOL(EC_CMD_ENTERING_MODE), \ 106 + TRACE_SYMBOL(EC_CMD_I2C_PASSTHRU_PROTECT), \ 107 + TRACE_SYMBOL(EC_CMD_CEC_WRITE_MSG), \ 108 + TRACE_SYMBOL(EC_CMD_CEC_SET), \ 109 + TRACE_SYMBOL(EC_CMD_CEC_GET), \ 118 110 TRACE_SYMBOL(EC_CMD_EC_CODEC), \ 119 111 TRACE_SYMBOL(EC_CMD_EC_CODEC_DMIC), \ 120 112 TRACE_SYMBOL(EC_CMD_EC_CODEC_I2S_RX), \ 121 113 TRACE_SYMBOL(EC_CMD_EC_CODEC_WOV), \ 122 114 TRACE_SYMBOL(EC_CMD_REBOOT_EC), \ 123 115 TRACE_SYMBOL(EC_CMD_GET_PANIC_INFO), \ 124 - TRACE_SYMBOL(EC_CMD_ACPI_READ), \ 125 - TRACE_SYMBOL(EC_CMD_ACPI_WRITE), \ 126 - TRACE_SYMBOL(EC_CMD_ACPI_QUERY_EVENT), \ 127 - TRACE_SYMBOL(EC_CMD_CEC_WRITE_MSG), \ 128 - TRACE_SYMBOL(EC_CMD_CEC_SET), \ 129 - TRACE_SYMBOL(EC_CMD_CEC_GET), \ 130 116 TRACE_SYMBOL(EC_CMD_REBOOT), \ 131 117 TRACE_SYMBOL(EC_CMD_RESEND_RESPONSE), \ 132 118 TRACE_SYMBOL(EC_CMD_VERSION0), \ 133 119 TRACE_SYMBOL(EC_CMD_PD_EXCHANGE_STATUS), \ 120 + TRACE_SYMBOL(EC_CMD_PD_HOST_EVENT_STATUS), \ 134 121 TRACE_SYMBOL(EC_CMD_USB_PD_CONTROL), \ 135 122 TRACE_SYMBOL(EC_CMD_USB_PD_PORTS), \ 136 123 TRACE_SYMBOL(EC_CMD_USB_PD_POWER_INFO), \ 137 124 TRACE_SYMBOL(EC_CMD_CHARGE_PORT_COUNT), \ 125 + TRACE_SYMBOL(EC_CMD_USB_PD_FW_UPDATE), \ 126 + TRACE_SYMBOL(EC_CMD_USB_PD_RW_HASH_ENTRY), \ 127 + TRACE_SYMBOL(EC_CMD_USB_PD_DEV_INFO), \ 138 128 TRACE_SYMBOL(EC_CMD_USB_PD_DISCOVERY), \ 139 129 TRACE_SYMBOL(EC_CMD_PD_CHARGE_PORT_OVERRIDE), \ 140 130 TRACE_SYMBOL(EC_CMD_PD_GET_LOG_ENTRY), \ 141 - TRACE_SYMBOL(EC_CMD_USB_PD_MUX_INFO) 131 + TRACE_SYMBOL(EC_CMD_USB_PD_GET_AMODE), \ 132 + TRACE_SYMBOL(EC_CMD_USB_PD_SET_AMODE), \ 133 + TRACE_SYMBOL(EC_CMD_PD_WRITE_LOG_ENTRY), \ 134 + TRACE_SYMBOL(EC_CMD_PD_CONTROL), \ 135 + TRACE_SYMBOL(EC_CMD_USB_PD_MUX_INFO), \ 136 + TRACE_SYMBOL(EC_CMD_PD_CHIP_INFO), \ 137 + TRACE_SYMBOL(EC_CMD_RWSIG_CHECK_STATUS), \ 138 + TRACE_SYMBOL(EC_CMD_RWSIG_ACTION), \ 139 + TRACE_SYMBOL(EC_CMD_EFS_VERIFY), \ 140 + TRACE_SYMBOL(EC_CMD_GET_CROS_BOARD_INFO), \ 141 + TRACE_SYMBOL(EC_CMD_SET_CROS_BOARD_INFO), \ 142 + TRACE_SYMBOL(EC_CMD_GET_UPTIME_INFO), \ 143 + TRACE_SYMBOL(EC_CMD_ADD_ENTROPY), \ 144 + TRACE_SYMBOL(EC_CMD_ADC_READ), \ 145 + TRACE_SYMBOL(EC_CMD_ROLLBACK_INFO), \ 146 + TRACE_SYMBOL(EC_CMD_AP_RESET), \ 147 + TRACE_SYMBOL(EC_CMD_CR51_BASE), \ 148 + TRACE_SYMBOL(EC_CMD_CR51_LAST), \ 149 + TRACE_SYMBOL(EC_CMD_FP_PASSTHRU), \ 150 + TRACE_SYMBOL(EC_CMD_FP_MODE), \ 151 + TRACE_SYMBOL(EC_CMD_FP_INFO), \ 152 + TRACE_SYMBOL(EC_CMD_FP_FRAME), \ 153 + TRACE_SYMBOL(EC_CMD_FP_TEMPLATE), \ 154 + TRACE_SYMBOL(EC_CMD_FP_CONTEXT), \ 155 + TRACE_SYMBOL(EC_CMD_FP_STATS), \ 156 + TRACE_SYMBOL(EC_CMD_FP_SEED), \ 157 + TRACE_SYMBOL(EC_CMD_FP_ENC_STATUS), \ 158 + TRACE_SYMBOL(EC_CMD_TP_SELF_TEST), \ 159 + TRACE_SYMBOL(EC_CMD_TP_FRAME_INFO), \ 160 + TRACE_SYMBOL(EC_CMD_TP_FRAME_SNAPSHOT), \ 161 + TRACE_SYMBOL(EC_CMD_TP_FRAME_GET), \ 162 + TRACE_SYMBOL(EC_CMD_BATTERY_GET_STATIC), \ 163 + TRACE_SYMBOL(EC_CMD_BATTERY_GET_DYNAMIC), \ 164 + TRACE_SYMBOL(EC_CMD_CHARGER_CONTROL), \ 165 + TRACE_SYMBOL(EC_CMD_BOARD_SPECIFIC_BASE), \ 166 + TRACE_SYMBOL(EC_CMD_BOARD_SPECIFIC_LAST) 167 + 168 + /* See the enum ec_status in include/linux/platform_data/cros_ec_commands.h */ 169 + #define EC_RESULT \ 170 + TRACE_SYMBOL(EC_RES_SUCCESS), \ 171 + TRACE_SYMBOL(EC_RES_INVALID_COMMAND), \ 172 + TRACE_SYMBOL(EC_RES_ERROR), \ 173 + TRACE_SYMBOL(EC_RES_INVALID_PARAM), \ 174 + TRACE_SYMBOL(EC_RES_ACCESS_DENIED), \ 175 + TRACE_SYMBOL(EC_RES_INVALID_RESPONSE), \ 176 + TRACE_SYMBOL(EC_RES_INVALID_VERSION), \ 177 + TRACE_SYMBOL(EC_RES_INVALID_CHECKSUM), \ 178 + TRACE_SYMBOL(EC_RES_IN_PROGRESS), \ 179 + TRACE_SYMBOL(EC_RES_UNAVAILABLE), \ 180 + TRACE_SYMBOL(EC_RES_TIMEOUT), \ 181 + TRACE_SYMBOL(EC_RES_OVERFLOW), \ 182 + TRACE_SYMBOL(EC_RES_INVALID_HEADER), \ 183 + TRACE_SYMBOL(EC_RES_REQUEST_TRUNCATED), \ 184 + TRACE_SYMBOL(EC_RES_RESPONSE_TOO_BIG), \ 185 + TRACE_SYMBOL(EC_RES_BUS_ERROR), \ 186 + TRACE_SYMBOL(EC_RES_BUSY), \ 187 + TRACE_SYMBOL(EC_RES_INVALID_HEADER_VERSION), \ 188 + TRACE_SYMBOL(EC_RES_INVALID_HEADER_CRC), \ 189 + TRACE_SYMBOL(EC_RES_INVALID_DATA_CRC), \ 190 + TRACE_SYMBOL(EC_RES_DUP_UNAVAILABLE) 142 191 143 192 #define CREATE_TRACE_POINTS 144 193 #include "cros_ec_trace.h"
+21 -5
drivers/platform/chrome/cros_ec_trace.h
··· 18 18 19 19 #include <linux/tracepoint.h> 20 20 21 - DECLARE_EVENT_CLASS(cros_ec_cmd_class, 21 + TRACE_EVENT(cros_ec_request_start, 22 22 TP_PROTO(struct cros_ec_command *cmd), 23 23 TP_ARGS(cmd), 24 24 TP_STRUCT__entry( ··· 33 33 __print_symbolic(__entry->command, EC_CMDS)) 34 34 ); 35 35 36 - 37 - DEFINE_EVENT(cros_ec_cmd_class, cros_ec_cmd, 38 - TP_PROTO(struct cros_ec_command *cmd), 39 - TP_ARGS(cmd) 36 + TRACE_EVENT(cros_ec_request_done, 37 + TP_PROTO(struct cros_ec_command *cmd, int retval), 38 + TP_ARGS(cmd, retval), 39 + TP_STRUCT__entry( 40 + __field(uint32_t, version) 41 + __field(uint32_t, command) 42 + __field(uint32_t, result) 43 + __field(int, retval) 44 + ), 45 + TP_fast_assign( 46 + __entry->version = cmd->version; 47 + __entry->command = cmd->command; 48 + __entry->result = cmd->result; 49 + __entry->retval = retval; 50 + ), 51 + TP_printk("version: %u, command: %s, ec result: %s, retval: %d", 52 + __entry->version, 53 + __print_symbolic(__entry->command, EC_CMDS), 54 + __print_symbolic(__entry->result, EC_RESULT), 55 + __entry->retval) 40 56 ); 41 57 42 58
-1
drivers/platform/chrome/cros_ec_vbc.c
··· 6 6 7 7 #include <linux/of.h> 8 8 #include <linux/platform_device.h> 9 - #include <linux/mfd/cros_ec.h> 10 9 #include <linux/module.h> 11 10 #include <linux/platform_data/cros_ec_commands.h> 12 11 #include <linux/platform_data/cros_ec_proto.h>
-1
drivers/platform/chrome/cros_usbpd_logger.c
··· 6 6 */ 7 7 8 8 #include <linux/ktime.h> 9 - #include <linux/mfd/cros_ec.h> 10 9 #include <linux/math64.h> 11 10 #include <linux/module.h> 12 11 #include <linux/platform_data/cros_ec_commands.h>
+2 -1
drivers/platform/chrome/wilco_ec/Kconfig
··· 1 1 # SPDX-License-Identifier: GPL-2.0-only 2 2 config WILCO_EC 3 3 tristate "ChromeOS Wilco Embedded Controller" 4 - depends on ACPI && X86 && CROS_EC_LPC && LEDS_CLASS 4 + depends on X86 || COMPILE_TEST 5 + depends on ACPI && CROS_EC_LPC && LEDS_CLASS 5 6 help 6 7 If you say Y here, you get support for talking to the ChromeOS 7 8 Wilco EC over an eSPI bus. This uses a simple byte-level protocol
+2 -2
drivers/platform/chrome/wilco_ec/core.c
··· 94 94 95 95 ret = wilco_ec_add_sysfs(ec); 96 96 if (ret < 0) { 97 - dev_err(dev, "Failed to create sysfs entries: %d", ret); 97 + dev_err(dev, "Failed to create sysfs entries: %d\n", ret); 98 98 goto unregister_rtc; 99 99 } 100 100 ··· 137 137 { 138 138 struct wilco_ec_device *ec = platform_get_drvdata(pdev); 139 139 140 + platform_device_unregister(ec->telem_pdev); 140 141 platform_device_unregister(ec->charger_pdev); 141 142 wilco_ec_remove_sysfs(ec); 142 - platform_device_unregister(ec->telem_pdev); 143 143 platform_device_unregister(ec->rtc_pdev); 144 144 if (ec->debugfs_pdev) 145 145 platform_device_unregister(ec->debugfs_pdev);
+4 -4
drivers/platform/chrome/wilco_ec/keyboard_leds.c
··· 69 69 ret = wilco_ec_mailbox(ec, &msg); 70 70 if (ret < 0) { 71 71 dev_err(ec->dev, 72 - "Failed sending keyboard LEDs command: %d", ret); 72 + "Failed sending keyboard LEDs command: %d\n", ret); 73 73 return ret; 74 74 } 75 75 ··· 94 94 95 95 if (response.status) { 96 96 dev_err(ec->dev, 97 - "EC reported failure sending keyboard LEDs command: %d", 97 + "EC reported failure sending keyboard LEDs command: %d\n", 98 98 response.status); 99 99 return -EIO; 100 100 } ··· 147 147 148 148 if (response.status) { 149 149 dev_err(ec->dev, 150 - "EC reported failure sending keyboard LEDs command: %d", 150 + "EC reported failure sending keyboard LEDs command: %d\n", 151 151 response.status); 152 152 return -EIO; 153 153 } ··· 179 179 ret = kbbl_exist(ec, &leds_exist); 180 180 if (ret < 0) { 181 181 dev_err(ec->dev, 182 - "Failed checking keyboard LEDs support: %d", ret); 182 + "Failed checking keyboard LEDs support: %d\n", ret); 183 183 return ret; 184 184 } 185 185 if (!leds_exist)
+2 -2
drivers/platform/chrome/wilco_ec/mailbox.c
··· 163 163 } 164 164 165 165 if (rs->data_size != EC_MAILBOX_DATA_SIZE) { 166 - dev_dbg(ec->dev, "unexpected packet size (%u != %u)", 166 + dev_dbg(ec->dev, "unexpected packet size (%u != %u)\n", 167 167 rs->data_size, EC_MAILBOX_DATA_SIZE); 168 168 return -EMSGSIZE; 169 169 } 170 170 171 171 if (rs->data_size < msg->response_size) { 172 - dev_dbg(ec->dev, "EC didn't return enough data (%u < %zu)", 172 + dev_dbg(ec->dev, "EC didn't return enough data (%u < %zu)\n", 173 173 rs->data_size, msg->response_size); 174 174 return -EMSGSIZE; 175 175 }
+3 -3
drivers/platform/chrome/wilco_ec/telemetry.c
··· 367 367 minor = ida_alloc_max(&telem_ida, TELEM_MAX_DEV-1, GFP_KERNEL); 368 368 if (minor < 0) { 369 369 error = minor; 370 - dev_err(&pdev->dev, "Failed to find minor number: %d", error); 370 + dev_err(&pdev->dev, "Failed to find minor number: %d\n", error); 371 371 return error; 372 372 } 373 373 ··· 427 427 428 428 ret = class_register(&telem_class); 429 429 if (ret) { 430 - pr_err(DRV_NAME ": Failed registering class: %d", ret); 430 + pr_err(DRV_NAME ": Failed registering class: %d\n", ret); 431 431 return ret; 432 432 } 433 433 434 434 /* Request the kernel for device numbers, starting with minor=0 */ 435 435 ret = alloc_chrdev_region(&dev_num, 0, TELEM_MAX_DEV, TELEM_DEV_NAME); 436 436 if (ret) { 437 - pr_err(DRV_NAME ": Failed allocating dev numbers: %d", ret); 437 + pr_err(DRV_NAME ": Failed allocating dev numbers: %d\n", ret); 438 438 goto destroy_class; 439 439 } 440 440 telem_major = MAJOR(dev_num);
-1
drivers/power/supply/cros_usbpd-charger.c
··· 5 5 * Copyright (c) 2014 - 2018 Google, Inc 6 6 */ 7 7 8 - #include <linux/mfd/cros_ec.h> 9 8 #include <linux/module.h> 10 9 #include <linux/platform_data/cros_ec_commands.h> 11 10 #include <linux/platform_data/cros_ec_proto.h>
-1
drivers/rtc/rtc-cros-ec.c
··· 5 5 // Author: Stephen Barber <smbarber@chromium.org> 6 6 7 7 #include <linux/kernel.h> 8 - #include <linux/mfd/cros_ec.h> 9 8 #include <linux/module.h> 10 9 #include <linux/platform_data/cros_ec_commands.h> 11 10 #include <linux/platform_data/cros_ec_proto.h>
-35
include/linux/mfd/cros_ec.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0-only */ 2 - /* 3 - * ChromeOS EC multi-function device 4 - * 5 - * Copyright (C) 2012 Google, Inc 6 - */ 7 - 8 - #ifndef __LINUX_MFD_CROS_EC_H 9 - #define __LINUX_MFD_CROS_EC_H 10 - 11 - #include <linux/device.h> 12 - 13 - /** 14 - * struct cros_ec_dev - ChromeOS EC device entry point. 15 - * @class_dev: Device structure used in sysfs. 16 - * @ec_dev: cros_ec_device structure to talk to the physical device. 17 - * @dev: Pointer to the platform device. 18 - * @debug_info: cros_ec_debugfs structure for debugging information. 19 - * @has_kb_wake_angle: True if at least 2 accelerometer are connected to the EC. 20 - * @cmd_offset: Offset to apply for each command. 21 - * @features: Features supported by the EC. 22 - */ 23 - struct cros_ec_dev { 24 - struct device class_dev; 25 - struct cros_ec_device *ec_dev; 26 - struct device *dev; 27 - struct cros_ec_debugfs *debug_info; 28 - bool has_kb_wake_angle; 29 - u16 cmd_offset; 30 - u32 features[2]; 31 - }; 32 - 33 - #define to_cros_ec_dev(dev) container_of(dev, struct cros_ec_dev, class_dev) 34 - 35 - #endif /* __LINUX_MFD_CROS_EC_H */
+20 -9
include/linux/platform_data/cros_ec_proto.h
··· 12 12 #include <linux/mutex.h> 13 13 #include <linux/notifier.h> 14 14 15 - #include <linux/mfd/cros_ec.h> 16 15 #include <linux/platform_data/cros_ec_commands.h> 17 16 18 17 #define CROS_EC_DEV_NAME "cros_ec" ··· 184 185 u16 cmd_offset; 185 186 }; 186 187 187 - int cros_ec_suspend(struct cros_ec_device *ec_dev); 188 + /** 189 + * struct cros_ec_dev - ChromeOS EC device entry point. 190 + * @class_dev: Device structure used in sysfs. 191 + * @ec_dev: cros_ec_device structure to talk to the physical device. 192 + * @dev: Pointer to the platform device. 193 + * @debug_info: cros_ec_debugfs structure for debugging information. 194 + * @has_kb_wake_angle: True if at least 2 accelerometer are connected to the EC. 195 + * @cmd_offset: Offset to apply for each command. 196 + * @features: Features supported by the EC. 197 + */ 198 + struct cros_ec_dev { 199 + struct device class_dev; 200 + struct cros_ec_device *ec_dev; 201 + struct device *dev; 202 + struct cros_ec_debugfs *debug_info; 203 + bool has_kb_wake_angle; 204 + u16 cmd_offset; 205 + u32 features[2]; 206 + }; 188 207 189 - int cros_ec_resume(struct cros_ec_device *ec_dev); 208 + #define to_cros_ec_dev(dev) container_of(dev, struct cros_ec_dev, class_dev) 190 209 191 210 int cros_ec_prepare_tx(struct cros_ec_device *ec_dev, 192 211 struct cros_ec_command *msg); ··· 218 201 int cros_ec_cmd_xfer_status(struct cros_ec_device *ec_dev, 219 202 struct cros_ec_command *msg); 220 203 221 - int cros_ec_register(struct cros_ec_device *ec_dev); 222 - 223 - int cros_ec_unregister(struct cros_ec_device *ec_dev); 224 - 225 204 int cros_ec_query_all(struct cros_ec_device *ec_dev); 226 205 227 206 int cros_ec_get_next_event(struct cros_ec_device *ec_dev, ··· 229 216 int cros_ec_check_features(struct cros_ec_dev *ec, int feature); 230 217 231 218 int cros_ec_get_sensor_count(struct cros_ec_dev *ec); 232 - 233 - bool cros_ec_handle_event(struct cros_ec_device *ec_dev); 234 219 235 220 /** 236 221 * cros_ec_get_time_ns() - Return time in ns.