UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

chrome platform changes for 6.3 

* New drivers
 
   - Driver cros_ec_uart for ChromeOS EC protocol over UART.
   - Driver cros_typec_vdm for USB PD Vendor Defined Message.
 
 * Improvements
 
   - Preserve logs as much as possible when EC panic.
   - Shutdown to refrain from potential HW damages when EC panic.
 
 * Fixes
 
   - Fix DP_PORT_VDO to include DP_CAP_RECEPTACLE.
   - Fix a lockdep false positive.
 
 * Cleanups
 
   - Use sysfs_emit*() instead of scnprintf().
   - Use asm instead of asm-generic for unaligned.h.
 
 * Misc
 
   - Rename module name from cros_ec_typec to cros-ec-typec.
   - Minor fixes.
 -----BEGIN PGP SIGNATURE-----
 
 iIkEABYIADEWIQS0yQeDP3cjLyifNRUrxTEGBto89AUCY+n3NxMcdHp1bmdiaUBr
 ZXJuZWwub3JnAAoJECvFMQYG2jz0aF8A/RBFKFEJrKj1AkPlgSHnhCr41SmEsrqg
 MaAH2x6Nw8YqAQCjSbJmanSzOHCO5HXF1P11elTNgqH0KT6/Xw/LIcL5Dw==
 =pAno
 -----END PGP SIGNATURE-----

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

Pull chrome platform updates from Tzung-Bi Shih:
 "New drivers:
   - cros_ec_uart for ChromeOS EC protocol over UART
   - cros_typec_vdm for USB PD Vendor Defined Message

  Improvements:
   - Preserve logs as much as possible when EC panics
   - Shutdown to refrain from potential HW damages when EC panics

  Fixes:
   - Fix DP_PORT_VDO to include DP_CAP_RECEPTACLE
   - Fix a lockdep false positive

  Cleanups:
   - Use sysfs_emit*() instead of scnprintf()
   - Use asm instead of asm-generic for unaligned.h

  Misc:
   - Rename module name from cros_ec_typec to cros-ec-typec
   - Minor fixes"

* tag 'tag-chrome-platform-for-v6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/chrome-platform/linux: (34 commits)
  platform/chrome: cros_ec_typec: Fix spelling mistake
  platform/chrome: cros_typec_vdm: Add Attention support
  platform/chrome: cros_ec: Add VDM attention headers
  platform/chrome: cros_typec_vdm: Fix VDO copy
  platform/chrome: cros_ec_typec: allow deferred probe of switch handles
  platform/chrome: cros_ec_proto: remove big stub objects from stack
  platform/chrome: cros_ec_uart: fix negative type promoted to high
  platform/chrome: cros_ec: Use per-device lockdep key
  platform/chrome: fix kernel-doc warnings for cros_ec_command
  platform/chrome: fix kernel-doc warning for last_resume_result
  platform/chrome: fix kernel-doc warning for suspend_timeout_ms
  platform/chrome: fix kernel-doc warnings for panic notifier
  platform/chrome: cros_ec_lpc: initialize the buf variable
  platform/chrome: cros_ec: Fix panic notifier registration
  platform/chrome: cros_typec_switch: Check for retimer flag
  platform/chrome: cros_typec_switch: Use fwnode* prop check
  platform/chrome: cros_typec_vdm: Add VDM send support
  platform/chrome: cros_typec_vdm: Add VDM reply support
  platform/chrome: cros_ec_typec: Add initial VDM support
  platform/chrome: cros_ec_typec: Alter module name with hyphens
  ...
This commit is contained in:
Linus Torvalds 2023-02-21 17:23:39 -08:00
parent 239451e903 b0d8a67715
commit 5f5ce6bcfc
19 changed files with 846 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
MAINTAINERS
View File

@ -4823,6 +4823,13 @@ S: Maintained
F: Documentation/devicetree/bindings/sound/google,cros-ec-codec.yaml
F: sound/soc/codecs/cros_ec_codec.*
CHROMEOS EC UART DRIVER
M: Bhanu Prakash Maiya <bhanumaiya@chromium.org>
R: Benson Leung <bleung@chromium.org>
R: Tzung-Bi Shih <tzungbi@kernel.org>
S: Maintained
F: drivers/platform/chrome/cros_ec_uart.c
CHROMEOS EC SUBDRIVERS
M: Benson Leung <bleung@chromium.org>
R: Guenter Roeck <groeck@chromium.org>
@ -4836,8 +4843,9 @@ CHROMEOS EC USB TYPE-C DRIVER
M: Prashant Malani <pmalani@chromium.org>
L: chrome-platform@lists.linux.dev
S: Maintained
F: drivers/platform/chrome/cros_ec_typec.c
F: drivers/platform/chrome/cros_ec_typec.*
F: drivers/platform/chrome/cros_typec_switch.c
F: drivers/platform/chrome/cros_typec_vdm.*
CHROMEOS EC USB PD NOTIFY DRIVER
M: Prashant Malani <pmalani@chromium.org>

5
drivers/mfd/cros_ec_dev.c
View File

@ -64,11 +64,6 @@ static const struct cros_feature_to_name cros_mcu_devices[] = {
.name = CROS_EC_DEV_SCP_NAME,
.desc = "System Control Processor",
},
{
.id = EC_FEATURE_SCP_C1,
.name = CROS_EC_DEV_SCP_C1_NAME,
.desc = "System Control Processor 2nd Core",
},
{
.id = EC_FEATURE_TOUCHPAD,
.name = CROS_EC_DEV_TP_NAME,

12
drivers/platform/chrome/Kconfig
View File

@ -119,6 +119,16 @@ config CROS_EC_SPI
response time cannot be guaranteed, we support ignoring
'pre-amble' bytes before the response actually starts.
config CROS_EC_UART
tristate "ChromeOS Embedded Controller (UART)"
depends on CROS_EC && ACPI && SERIAL_DEV_BUS
help
If you say Y here, you get support for talking to the ChromeOS EC
through a UART, using a byte-level protocol.
To compile this driver as a module, choose M here: the
module will be called cros_ec_uart.
config CROS_EC_LPC
tristate "ChromeOS Embedded Controller (LPC)"
depends on CROS_EC && ACPI && (X86 || COMPILE_TEST)
@ -226,7 +236,7 @@ config CROS_EC_TYPEC
information from the Chrome OS EC.
To compile this driver as a module, choose M here: the module will be
called cros_ec_typec.
called cros-ec-typec.
config CROS_HPS_I2C
tristate "ChromeOS HPS device"

4
drivers/platform/chrome/Makefile
View File

@ -15,8 +15,10 @@ obj-$(CONFIG_CROS_EC_ISHTP) += cros_ec_ishtp.o
obj-$(CONFIG_CROS_TYPEC_SWITCH) += cros_typec_switch.o
obj-$(CONFIG_CROS_EC_RPMSG) += cros_ec_rpmsg.o
obj-$(CONFIG_CROS_EC_SPI) += cros_ec_spi.o
obj-$(CONFIG_CROS_EC_UART) += cros_ec_uart.o
cros_ec_lpcs-objs := cros_ec_lpc.o cros_ec_lpc_mec.o
obj-$(CONFIG_CROS_EC_TYPEC) += cros_ec_typec.o
cros-ec-typec-objs := cros_ec_typec.o cros_typec_vdm.o
obj-$(CONFIG_CROS_EC_TYPEC) += cros-ec-typec.o
obj-$(CONFIG_CROS_EC_LPC) += cros_ec_lpcs.o
obj-$(CONFIG_CROS_EC_PROTO) += cros_ec_proto.o cros_ec_trace.o
obj-$(CONFIG_CROS_KBD_LED_BACKLIGHT) += cros_kbd_led_backlight.o

15
drivers/platform/chrome/cros_ec.c
View File

@ -182,6 +182,7 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
int err = 0;
BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->event_notifier);
BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->panic_notifier);
ec_dev->max_request = sizeof(struct ec_params_hello);
ec_dev->max_response = sizeof(struct ec_response_get_protocol_info);
@ -198,12 +199,14 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
if (!ec_dev->dout)
return -ENOMEM;
lockdep_register_key(&ec_dev->lockdep_key);
mutex_init(&ec_dev->lock);
lockdep_set_class(&ec_dev->lock, &ec_dev->lockdep_key);
err = cros_ec_query_all(ec_dev);
if (err) {
dev_err(dev, "Cannot identify the EC: error %d\n", err);
return err;
goto destroy_mutex;
}
if (ec_dev->irq > 0) {
@ -215,7 +218,7 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
if (err) {
dev_err(dev, "Failed to request IRQ %d: %d\n",
ec_dev->irq, err);
return err;
goto destroy_mutex;
}
}
@ -226,7 +229,8 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
if (IS_ERR(ec_dev->ec)) {
dev_err(ec_dev->dev,
"Failed to create CrOS EC platform device\n");
return PTR_ERR(ec_dev->ec);
err = PTR_ERR(ec_dev->ec);
goto destroy_mutex;
}
if (ec_dev->max_passthru) {
@ -292,6 +296,9 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
exit:
platform_device_unregister(ec_dev->ec);
platform_device_unregister(ec_dev->pd);
destroy_mutex:
mutex_destroy(&ec_dev->lock);
lockdep_unregister_key(&ec_dev->lockdep_key);
return err;
}
EXPORT_SYMBOL(cros_ec_register);
@ -309,6 +316,8 @@ void cros_ec_unregister(struct cros_ec_device *ec_dev)
if (ec_dev->pd)
platform_device_unregister(ec_dev->pd);
platform_device_unregister(ec_dev->ec);
mutex_destroy(&ec_dev->lock);
lockdep_unregister_key(&ec_dev->lockdep_key);
}
EXPORT_SYMBOL(cros_ec_unregister);

25
drivers/platform/chrome/cros_ec_debugfs.c
View File

@ -38,6 +38,8 @@ static DECLARE_WAIT_QUEUE_HEAD(cros_ec_debugfs_log_wq);
* @log_mutex: mutex to protect circular buffer
* @log_poll_work: recurring task to poll EC for new console log data
* @panicinfo_blob: panicinfo debugfs blob
* @notifier_panic: notifier_block to let kernel to flush buffered log
* when EC panic
*/
struct cros_ec_debugfs {
struct cros_ec_dev *ec;
@ -49,6 +51,7 @@ struct cros_ec_debugfs {
struct delayed_work log_poll_work;
/* EC panicinfo */
struct debugfs_blob_wrapper panicinfo_blob;
struct notifier_block notifier_panic;
};
/*
@ -437,6 +440,22 @@ free:
return ret;
}
static int cros_ec_debugfs_panic_event(struct notifier_block *nb,
unsigned long queued_during_suspend, void *_notify)
{
struct cros_ec_debugfs *debug_info =
container_of(nb, struct cros_ec_debugfs, notifier_panic);
if (debug_info->log_buffer.buf) {
/* Force log poll work to run immediately */
mod_delayed_work(debug_info->log_poll_work.wq, &debug_info->log_poll_work, 0);
/* Block until log poll work finishes */
flush_delayed_work(&debug_info->log_poll_work);
}
return NOTIFY_DONE;
}
static int cros_ec_debugfs_probe(struct platform_device *pd)
{
struct cros_ec_dev *ec = dev_get_drvdata(pd->dev.parent);
@ -473,6 +492,12 @@ static int cros_ec_debugfs_probe(struct platform_device *pd)
debugfs_create_u16("suspend_timeout_ms", 0664, debug_info->dir,
&ec->ec_dev->suspend_timeout_ms);
debug_info->notifier_panic.notifier_call = cros_ec_debugfs_panic_event;
ret = blocking_notifier_chain_register(&ec->ec_dev->panic_notifier,
&debug_info->notifier_panic);
if (ret)
goto remove_debugfs;
ec->debug_info = debug_info;
dev_set_drvdata(&pd->dev, ec);

14
drivers/platform/chrome/cros_ec_lightbar.c
View File

@ -34,7 +34,7 @@ static ssize_t interval_msec_show(struct device *dev,
{
unsigned long msec = lb_interval_jiffies * 1000 / HZ;
return scnprintf(buf, PAGE_SIZE, "%lu\n", msec);
return sysfs_emit(buf, "%lu\n", msec);
}
static ssize_t interval_msec_store(struct device *dev,
@ -169,7 +169,7 @@ static ssize_t version_show(struct device *dev,
if (!get_lightbar_version(ec, &version, &flags))
return -EIO;
return scnprintf(buf, PAGE_SIZE, "%d %d\n", version, flags);
return sysfs_emit(buf, "%d %d\n", version, flags);
}
static ssize_t brightness_store(struct device *dev,
@ -302,17 +302,15 @@ static ssize_t sequence_show(struct device *dev,
ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
if (ret < 0) {
ret = scnprintf(buf, PAGE_SIZE, "XFER / EC ERROR %d / %d\n",
ret, msg->result);
ret = sysfs_emit(buf, "XFER / EC ERROR %d / %d\n", ret, msg->result);
goto exit;
}
resp = (struct ec_response_lightbar *)msg->data;
if (resp->get_seq.num >= ARRAY_SIZE(seqname))
ret = scnprintf(buf, PAGE_SIZE, "%d\n", resp->get_seq.num);
ret = sysfs_emit(buf, "%d\n", resp->get_seq.num);
else
ret = scnprintf(buf, PAGE_SIZE, "%s\n",
seqname[resp->get_seq.num]);
ret = sysfs_emit(buf, "%s\n", seqname[resp->get_seq.num]);
exit:
kfree(msg);
@ -483,7 +481,7 @@ static ssize_t userspace_control_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
return scnprintf(buf, PAGE_SIZE, "%d\n", userspace_control);
return sysfs_emit(buf, "%d\n", userspace_control);
}
static ssize_t userspace_control_store(struct device *dev,

12
drivers/platform/chrome/cros_ec_lpc.c
View File

@ -21,6 +21,7 @@
#include <linux/platform_data/cros_ec_proto.h>
#include <linux/platform_device.h>
#include <linux/printk.h>
#include <linux/reboot.h>
#include <linux/suspend.h>
#include "cros_ec.h"
@ -320,6 +321,15 @@ static void cros_ec_lpc_acpi_notify(acpi_handle device, u32 value, void *data)
ec_dev->last_event_time = cros_ec_get_time_ns();
if (value == ACPI_NOTIFY_CROS_EC_PANIC) {
dev_emerg(ec_dev->dev, "CrOS EC Panic Reported. Shutdown is imminent!");
blocking_notifier_call_chain(&ec_dev->panic_notifier, 0, ec_dev);
/* Begin orderly shutdown. Force shutdown after 1 second. */
hw_protection_shutdown("CrOS EC Panic", 1000);
/* Do not query for other events after a panic is reported */
return;
}
if (ec_dev->mkbp_event_supported)
do {
ret = cros_ec_get_next_event(ec_dev, NULL,
@ -340,7 +350,7 @@ static int cros_ec_lpc_probe(struct platform_device *pdev)
struct acpi_device *adev;
acpi_status status;
struct cros_ec_device *ec_dev;
u8 buf[2];
u8 buf[2] = {};
int irq, ret;
/*

13
drivers/platform/chrome/cros_ec_proto_test.c
View File

@ -5,7 +5,8 @@
#include <kunit/test.h>
#include <asm-generic/unaligned.h>
#include <asm/unaligned.h>
#include <linux/platform_data/cros_ec_commands.h>
#include <linux/platform_data/cros_ec_proto.h>
@ -2370,7 +2371,7 @@ static void cros_ec_proto_test_get_host_event_normal(struct kunit *test)
static void cros_ec_proto_test_check_features_cached(struct kunit *test)
{
int ret, i;
struct cros_ec_dev ec;
static struct cros_ec_dev ec;
ec.features.flags[0] = EC_FEATURE_MASK_0(EC_FEATURE_FINGERPRINT);
ec.features.flags[1] = EC_FEATURE_MASK_0(EC_FEATURE_SCP);
@ -2395,7 +2396,7 @@ static void cros_ec_proto_test_check_features_not_cached(struct kunit *test)
struct cros_ec_device *ec_dev = &priv->ec_dev;
struct ec_xfer_mock *mock;
int ret, i;
struct cros_ec_dev ec;
static struct cros_ec_dev ec;
ec_dev->max_request = 0xff;
ec_dev->max_response = 0xee;
@ -2448,7 +2449,7 @@ static void cros_ec_proto_test_get_sensor_count_normal(struct kunit *test)
struct cros_ec_device *ec_dev = &priv->ec_dev;
struct ec_xfer_mock *mock;
int ret;
struct cros_ec_dev ec;
static struct cros_ec_dev ec;
ec_dev->max_request = 0xff;
ec_dev->max_response = 0xee;
@ -2493,7 +2494,7 @@ static void cros_ec_proto_test_get_sensor_count_xfer_error(struct kunit *test)
struct cros_ec_device *ec_dev = &priv->ec_dev;
struct ec_xfer_mock *mock;
int ret;
struct cros_ec_dev ec;
static struct cros_ec_dev ec;
ec_dev->max_request = 0xff;
ec_dev->max_response = 0xee;
@ -2533,7 +2534,7 @@ static void cros_ec_proto_test_get_sensor_count_legacy(struct kunit *test)
struct cros_ec_device *ec_dev = &priv->ec_dev;
struct ec_xfer_mock *mock;
int ret, i;
struct cros_ec_dev ec;
static struct cros_ec_dev ec;
struct {
u8 readmem_data;
int expected_result;

40
drivers/platform/chrome/cros_ec_sysfs.c
View File

@ -27,10 +27,9 @@ static ssize_t reboot_show(struct device *dev,
{
int count = 0;
count += scnprintf(buf + count, PAGE_SIZE - count,
"ro|rw|cancel|cold|disable-jump|hibernate|cold-ap-off");
count += scnprintf(buf + count, PAGE_SIZE - count,
" [at-shutdown]\n");
count += sysfs_emit_at(buf, count,
"ro|rw|cancel|cold|disable-jump|hibernate|cold-ap-off");
count += sysfs_emit_at(buf, count, " [at-shutdown]\n");
return count;
}
@ -138,12 +137,9 @@ static ssize_t version_show(struct device *dev,
/* Strings should be null-terminated, but let's be sure. */
r_ver->version_string_ro[sizeof(r_ver->version_string_ro) - 1] = '\0';
r_ver->version_string_rw[sizeof(r_ver->version_string_rw) - 1] = '\0';
count += scnprintf(buf + count, PAGE_SIZE - count,
"RO version: %s\n", r_ver->version_string_ro);
count += scnprintf(buf + count, PAGE_SIZE - count,
"RW version: %s\n", r_ver->version_string_rw);
count += scnprintf(buf + count, PAGE_SIZE - count,
"Firmware copy: %s\n",
count += sysfs_emit_at(buf, count, "RO version: %s\n", r_ver->version_string_ro);
count += sysfs_emit_at(buf, count, "RW version: %s\n", r_ver->version_string_rw);
count += sysfs_emit_at(buf, count, "Firmware copy: %s\n",
(r_ver->current_image < ARRAY_SIZE(image_names) ?
image_names[r_ver->current_image] : "?"));
@ -152,13 +148,12 @@ static ssize_t version_show(struct device *dev,
msg->insize = EC_HOST_PARAM_SIZE;
ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
if (ret < 0) {
count += scnprintf(buf + count, PAGE_SIZE - count,
count += sysfs_emit_at(buf, count,
"Build info: XFER / EC ERROR %d / %d\n",
ret, msg->result);
} else {
msg->data[EC_HOST_PARAM_SIZE - 1] = '\0';
count += scnprintf(buf + count, PAGE_SIZE - count,
"Build info: %s\n", msg->data);
count += sysfs_emit_at(buf, count, "Build info: %s\n", msg->data);
}
/* Get chip info. */
@ -166,7 +161,7 @@ static ssize_t version_show(struct device *dev,
msg->insize = sizeof(*r_chip);
ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
if (ret < 0) {
count += scnprintf(buf + count, PAGE_SIZE - count,
count += sysfs_emit_at(buf, count,
"Chip info: XFER / EC ERROR %d / %d\n",
ret, msg->result);
} else {
@ -175,12 +170,9 @@ static ssize_t version_show(struct device *dev,
r_chip->vendor[sizeof(r_chip->vendor) - 1] = '\0';
r_chip->name[sizeof(r_chip->name) - 1] = '\0';
r_chip->revision[sizeof(r_chip->revision) - 1] = '\0';
count += scnprintf(buf + count, PAGE_SIZE - count,
"Chip vendor: %s\n", r_chip->vendor);
count += scnprintf(buf + count, PAGE_SIZE - count,
"Chip name: %s\n", r_chip->name);
count += scnprintf(buf + count, PAGE_SIZE - count,
"Chip revision: %s\n", r_chip->revision);
count += sysfs_emit_at(buf, count, "Chip vendor: %s\n", r_chip->vendor);
count += sysfs_emit_at(buf, count, "Chip name: %s\n", r_chip->name);
count += sysfs_emit_at(buf, count, "Chip revision: %s\n", r_chip->revision);
}
/* Get board version */
@ -188,13 +180,13 @@ static ssize_t version_show(struct device *dev,
msg->insize = sizeof(*r_board);
ret = cros_ec_cmd_xfer_status(ec->ec_dev, msg);
if (ret < 0) {
count += scnprintf(buf + count, PAGE_SIZE - count,
count += sysfs_emit_at(buf, count,
"Board version: XFER / EC ERROR %d / %d\n",
ret, msg->result);
} else {
r_board = (struct ec_response_board_version *)msg->data;
count += scnprintf(buf + count, PAGE_SIZE - count,
count += sysfs_emit_at(buf, count,
"Board version: %d\n",
r_board->board_version);
}
@ -227,7 +219,7 @@ static ssize_t flashinfo_show(struct device *dev,
resp = (struct ec_response_flash_info *)msg->data;
ret = scnprintf(buf, PAGE_SIZE,
ret = sysfs_emit(buf,
"FlashSize %d\nWriteSize %d\n"
"EraseSize %d\nProtectSize %d\n",
resp->flash_size, resp->write_block_size,
@ -264,7 +256,7 @@ static ssize_t kb_wake_angle_show(struct device *dev,
goto exit;
resp = (struct ec_response_motion_sense *)msg->data;
ret = scnprintf(buf, PAGE_SIZE, "%d\n", resp->kb_wake_angle.ret);
ret = sysfs_emit(buf, "%d\n", resp->kb_wake_angle.ret);
exit:
kfree(msg);
return ret;

123
drivers/platform/chrome/cros_ec_typec.c
View File

@ -7,92 +7,22 @@
*/
#include <linux/acpi.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_data/cros_ec_commands.h>
#include <linux/platform_data/cros_ec_proto.h>
#include <linux/platform_data/cros_usbpd_notify.h>
#include <linux/platform_device.h>
#include <linux/usb/pd.h>
#include <linux/usb/pd_vdo.h>
#include <linux/usb/typec.h>
#include <linux/usb/typec_altmode.h>
#include <linux/usb/typec_dp.h>
#include <linux/usb/typec_mux.h>
#include <linux/usb/typec_retimer.h>
#include <linux/usb/typec_tbt.h>
#include <linux/usb/role.h>
#include "cros_ec_typec.h"
#include "cros_typec_vdm.h"
#define DRV_NAME "cros-ec-typec"
#define DP_PORT_VDO (DP_CONF_SET_PIN_ASSIGN(BIT(DP_PIN_ASSIGN_C) | BIT(DP_PIN_ASSIGN_D)) | \
DP_CAP_DFP_D)
/* Supported alt modes. */
enum {
CROS_EC_ALTMODE_DP = 0,
CROS_EC_ALTMODE_TBT,
CROS_EC_ALTMODE_MAX,
};
/* Container for altmode pointer nodes. */
struct cros_typec_altmode_node {
struct typec_altmode *amode;
struct list_head list;
};
/* Per port data. */
struct cros_typec_port {
struct typec_port *port;
/* Initial capabilities for the port. */
struct typec_capability caps;
struct typec_partner *partner;
struct typec_cable *cable;
/* SOP' plug. */
struct typec_plug *plug;
/* Port partner PD identity info. */
struct usb_pd_identity p_identity;
/* Port cable PD identity info. */
struct usb_pd_identity c_identity;
struct typec_switch *ori_sw;
struct typec_mux *mux;
struct typec_retimer *retimer;
struct usb_role_switch *role_sw;
/* Variables keeping track of switch state. */
struct typec_mux_state state;
uint8_t mux_flags;
uint8_t role;
struct typec_altmode *port_altmode[CROS_EC_ALTMODE_MAX];
/* Flag indicating that PD partner discovery data parsing is completed. */
bool sop_disc_done;
bool sop_prime_disc_done;
struct ec_response_typec_discovery *disc_data;
struct list_head partner_mode_list;
struct list_head plug_mode_list;
/* PDO-related structs */
struct usb_power_delivery *partner_pd;
struct usb_power_delivery_capabilities *partner_src_caps;
struct usb_power_delivery_capabilities *partner_sink_caps;
};
/* Platform-specific data for the Chrome OS EC Type C controller. */
struct cros_typec_data {
struct device *dev;
struct cros_ec_device *ec;
int num_ports;
unsigned int pd_ctrl_ver;
/* Array of ports, indexed by port number. */
struct cros_typec_port *ports[EC_USB_PD_MAX_PORTS];
struct notifier_block nb;
struct work_struct port_work;
bool typec_cmd_supported;
bool needs_mux_ack;
};
DP_CAP_DFP_D | DP_CAP_RECEPTACLE)
static int cros_typec_parse_port_props(struct typec_capability *cap,
struct fwnode_handle *fwnode,
@ -145,27 +75,33 @@ static int cros_typec_get_switch_handles(struct cros_typec_port *port,
struct fwnode_handle *fwnode,
struct device *dev)
{
int ret = 0;
port->mux = fwnode_typec_mux_get(fwnode, NULL);
if (IS_ERR(port->mux)) {
dev_dbg(dev, "Mux handle not found.\n");
ret = PTR_ERR(port->mux);
dev_dbg(dev, "Mux handle not found: %d.\n", ret);
goto mux_err;
}
port->retimer = fwnode_typec_retimer_get(fwnode);
if (IS_ERR(port->retimer)) {
dev_dbg(dev, "Retimer handle not found.\n");
ret = PTR_ERR(port->retimer);
dev_dbg(dev, "Retimer handle not found: %d.\n", ret);
goto retimer_sw_err;
}
port->ori_sw = fwnode_typec_switch_get(fwnode);
if (IS_ERR(port->ori_sw)) {
dev_dbg(dev, "Orientation switch handle not found.\n");
ret = PTR_ERR(port->ori_sw);
dev_dbg(dev, "Orientation switch handle not found: %d\n", ret);
goto ori_sw_err;
}
port->role_sw = fwnode_usb_role_switch_get(fwnode);
if (IS_ERR(port->role_sw)) {
dev_dbg(dev, "USB role switch handle not found.\n");
ret = PTR_ERR(port->role_sw);
dev_dbg(dev, "USB role switch handle not found: %d\n", ret);
goto role_sw_err;
}
@ -181,7 +117,7 @@ retimer_sw_err:
typec_mux_put(port->mux);
port->mux = NULL;
mux_err:
return -ENODEV;
return ret;
}
static int cros_typec_add_partner(struct cros_typec_data *typec, int port_num,
@ -342,6 +278,8 @@ static int cros_typec_register_port_altmodes(struct cros_typec_data *typec,
if (IS_ERR(amode))
return PTR_ERR(amode);
port->port_altmode[CROS_EC_ALTMODE_DP] = amode;
typec_altmode_set_drvdata(amode, port);
amode->ops = &port_amode_ops;
/*
* Register TBT compatibility alt mode. The EC will not enter the mode
@ -355,6 +293,8 @@ static int cros_typec_register_port_altmodes(struct cros_typec_data *typec,
if (IS_ERR(amode))
return PTR_ERR(amode);
port->port_altmode[CROS_EC_ALTMODE_TBT] = amode;
typec_altmode_set_drvdata(amode, port);
amode->ops = &port_amode_ops;
port->state.alt = NULL;
port->state.mode = TYPEC_STATE_USB;
@ -408,6 +348,8 @@ static int cros_typec_init_ports(struct cros_typec_data *typec)
goto unregister_ports;
}
cros_port->port_num = port_num;
cros_port->typec_data = typec;
typec->ports[port_num] = cros_port;
cap = &cros_port->caps;
@ -423,9 +365,11 @@ static int cros_typec_init_ports(struct cros_typec_data *typec)
}
ret = cros_typec_get_switch_handles(cros_port, fwnode, dev);
if (ret)
dev_dbg(dev, "No switch control for port %d\n",
port_num);
if (ret) {
dev_dbg(dev, "No switch control for port %d, err: %d\n", port_num, ret);
if (ret == -EPROBE_DEFER)
goto unregister_ports;
}
ret = cros_typec_register_port_altmodes(typec, port_num);
if (ret) {
@ -1064,6 +1008,21 @@ static void cros_typec_handle_status(struct cros_typec_data *typec, int port_num
"Failed SOP Disc event clear, port: %d\n", port_num);
}
}
if (resp.events & PD_STATUS_EVENT_VDM_REQ_REPLY) {
cros_typec_handle_vdm_response(typec, port_num);
ret = cros_typec_send_clear_event(typec, port_num, PD_STATUS_EVENT_VDM_REQ_REPLY);
if (ret < 0)
dev_warn(typec->dev, "Failed VDM Reply event clear, port: %d\n", port_num);
}
if (resp.events & PD_STATUS_EVENT_VDM_ATTENTION) {
cros_typec_handle_vdm_attention(typec, port_num);
ret = cros_typec_send_clear_event(typec, port_num, PD_STATUS_EVENT_VDM_ATTENTION);
if (ret < 0)
dev_warn(typec->dev, "Failed VDM attention event clear, port: %d\n",
port_num);
}
}
static int cros_typec_port_update(struct cros_typec_data *typec, int port_num)

85
drivers/platform/chrome/cros_ec_typec.h Normal file
View File

@ -0,0 +1,85 @@
/* SPDX-License-Identifier: GPL-2.0-only */
#ifndef __CROS_EC_TYPEC__
#define __CROS_EC_TYPEC__
#include <linux/list.h>
#include <linux/notifier.h>
#include <linux/platform_data/cros_ec_proto.h>
#include <linux/usb/pd.h>
#include <linux/usb/role.h>
#include <linux/usb/typec.h>
#include <linux/usb/typec_altmode.h>
#include <linux/usb/typec_mux.h>
#include <linux/usb/typec_retimer.h>
#include <linux/workqueue.h>
/* Supported alt modes. */
enum {
CROS_EC_ALTMODE_DP = 0,
CROS_EC_ALTMODE_TBT,
CROS_EC_ALTMODE_MAX,
};
/* Container for altmode pointer nodes. */
struct cros_typec_altmode_node {
struct typec_altmode *amode;
struct list_head list;
};
/* Platform-specific data for the Chrome OS EC Type C controller. */
struct cros_typec_data {
struct device *dev;
struct cros_ec_device *ec;
int num_ports;
unsigned int pd_ctrl_ver;
/* Array of ports, indexed by port number. */
struct cros_typec_port *ports[EC_USB_PD_MAX_PORTS];
struct notifier_block nb;
struct work_struct port_work;
bool typec_cmd_supported;
bool needs_mux_ack;
};
/* Per port data. */
struct cros_typec_port {
struct typec_port *port;
int port_num;
/* Initial capabilities for the port. */
struct typec_capability caps;
struct typec_partner *partner;
struct typec_cable *cable;
/* SOP' plug. */
struct typec_plug *plug;
/* Port partner PD identity info. */
struct usb_pd_identity p_identity;
/* Port cable PD identity info. */
struct usb_pd_identity c_identity;
struct typec_switch *ori_sw;
struct typec_mux *mux;
struct typec_retimer *retimer;
struct usb_role_switch *role_sw;
/* Variables keeping track of switch state. */
struct typec_mux_state state;
uint8_t mux_flags;
uint8_t role;
struct typec_altmode *port_altmode[CROS_EC_ALTMODE_MAX];
/* Flag indicating that PD partner discovery data parsing is completed. */
bool sop_disc_done;
bool sop_prime_disc_done;
struct ec_response_typec_discovery *disc_data;
struct list_head partner_mode_list;
struct list_head plug_mode_list;
/* PDO-related structs */
struct usb_power_delivery *partner_pd;
struct usb_power_delivery_capabilities *partner_src_caps;
struct usb_power_delivery_capabilities *partner_sink_caps;
struct cros_typec_data *typec_data;
};
#endif /* __CROS_EC_TYPEC__ */

362
drivers/platform/chrome/cros_ec_uart.c Normal file
View File

@ -0,0 +1,362 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* UART interface for ChromeOS Embedded Controller
*
* Copyright 2020-2022 Google LLC.
*/
#include <linux/acpi.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_data/cros_ec_proto.h>
#include <linux/serdev.h>
#include <linux/slab.h>
#include <uapi/linux/sched/types.h>
#include "cros_ec.h"
/*
* EC sends contiguous bytes of response packet on UART AP RX.
* TTY driver in AP accumulates incoming bytes and calls the registered callback
* function. Byte count can range from 1 to MAX bytes supported by EC.
* This driver should wait for long time for all callbacks to be processed.
* Considering the worst case scenario, wait for 500 msec. This timeout should
* account for max latency and some additional guard time.
* Best case: Entire packet is received in ~200 ms, wait queue will be released
* and packet will be processed.
* Worst case: TTY driver sends bytes in multiple callbacks. In this case this
* driver will wait for ~1 sec beyond which it will timeout.
* This timeout value should not exceed ~500 msec because in case if
* EC_CMD_REBOOT_EC sent, high level driver should be able to intercept EC
* in RO.
*/
#define EC_MSG_DEADLINE_MS 500
/**
* struct response_info - Encapsulate EC response related
* information for passing between function
* cros_ec_uart_pkt_xfer() and cros_ec_uart_rx_bytes()
* callback.
* @data: Copy the data received from EC here.
* @max_size: Max size allocated for the @data buffer. If the
* received data exceeds this value, we log an error.
* @size: Actual size of data received from EC. This is also
* used to accumulate byte count with response is received
* in dma chunks.
* @exp_len: Expected bytes of response from EC including header.
* @status: Re-init to 0 before sending a cmd. Updated to 1 when
* a response is successfully received, or an error number
* on failure.
* @wait_queue: Wait queue EC response where the cros_ec sends request
* to EC and waits
*/
struct response_info {
void *data;
size_t max_size;
size_t size;
size_t exp_len;
int status;
wait_queue_head_t wait_queue;
};
/**
* struct cros_ec_uart - information about a uart-connected EC
*
* @serdev: serdev uart device we are connected to.
* @baudrate: UART baudrate of attached EC device.
* @flowcontrol: UART flowcontrol of attached device.
* @irq: Linux IRQ number of associated serial device.
* @response: Response info passing between cros_ec_uart_pkt_xfer()
* and cros_ec_uart_rx_bytes()
*/
struct cros_ec_uart {
struct serdev_device *serdev;
u32 baudrate;
u8 flowcontrol;
u32 irq;
struct response_info response;
};
static int cros_ec_uart_rx_bytes(struct serdev_device *serdev,
const u8 *data,
size_t count)
{
struct ec_host_response *host_response;
struct cros_ec_device *ec_dev = serdev_device_get_drvdata(serdev);
struct cros_ec_uart *ec_uart = ec_dev->priv;
struct response_info *resp = &ec_uart->response;
/* Check if bytes were sent out of band */
if (!resp->data) {
/* Discard all bytes */
dev_warn(ec_dev->dev, "Bytes received out of band, dropping them.\n");
return count;
}
/*
* Check if incoming bytes + resp->size is greater than allocated
* buffer in din by cros_ec. This will ensure that if EC sends more
* bytes than max_size, waiting process will be notified with an error.
*/
if (resp->size + count > resp->max_size) {
resp->status = -EMSGSIZE;
wake_up(&resp->wait_queue);
return count;
}
memcpy(resp->data + resp->size, data, count);
resp->size += count;
/* Read data_len if we received response header and if exp_len was not read before. */
if (resp->size >= sizeof(*host_response) && resp->exp_len == 0) {
host_response = (struct ec_host_response *)resp->data;
resp->exp_len = host_response->data_len + sizeof(*host_response);
}
/* If driver received response header and payload from EC, wake up the wait queue. */
if (resp->size >= sizeof(*host_response) && resp->size == resp->exp_len) {
resp->status = 1;
wake_up(&resp->wait_queue);
}
return count;
}
static int cros_ec_uart_pkt_xfer(struct cros_ec_device *ec_dev,
struct cros_ec_command *ec_msg)
{
struct cros_ec_uart *ec_uart = ec_dev->priv;
struct serdev_device *serdev = ec_uart->serdev;
struct response_info *resp = &ec_uart->response;
struct ec_host_response *host_response;
unsigned int len;
int ret, i;
u8 sum;
len = cros_ec_prepare_tx(ec_dev, ec_msg);
dev_dbg(ec_dev->dev, "Prepared len=%d\n", len);
/* Setup for incoming response */
resp->data = ec_dev->din;
resp->max_size = ec_dev->din_size;
resp->size = 0;
resp->exp_len = 0;
resp->status = 0;
ret = serdev_device_write_buf(serdev, ec_dev->dout, len);
if (ret < 0 || ret < len) {
dev_err(ec_dev->dev, "Unable to write data\n");
if (ret >= 0)
ret = -EIO;
goto exit;
}
ret = wait_event_timeout(resp->wait_queue, resp->status,
msecs_to_jiffies(EC_MSG_DEADLINE_MS));
if (ret == 0) {
dev_warn(ec_dev->dev, "Timed out waiting for response.\n");
ret = -ETIMEDOUT;
goto exit;
}
if (resp->status < 0) {
ret = resp->status;
dev_warn(ec_dev->dev, "Error response received: %d\n", ret);
goto exit;
}
host_response = (struct ec_host_response *)ec_dev->din;
ec_msg->result = host_response->result;
if (host_response->data_len > ec_msg->insize) {
dev_err(ec_dev->dev, "Resp too long (%d bytes, expected %d)\n",
host_response->data_len, ec_msg->insize);
ret = -ENOSPC;
goto exit;
}
/* Validate checksum */
sum = 0;
for (i = 0; i < sizeof(*host_response) + host_response->data_len; i++)
sum += ec_dev->din[i];
if (sum) {
dev_err(ec_dev->dev, "Bad packet checksum calculated %x\n", sum);
ret = -EBADMSG;
goto exit;
}
memcpy(ec_msg->data, ec_dev->din + sizeof(*host_response), host_response->data_len);
ret = host_response->data_len;
exit:
/* Invalidate response buffer to guard against out of band rx data */
resp->data = NULL;
if (ec_msg->command == EC_CMD_REBOOT_EC)
msleep(EC_REBOOT_DELAY_MS);
return ret;
}
static int cros_ec_uart_resource(struct acpi_resource *ares, void *data)
{
struct cros_ec_uart *ec_uart = data;
struct acpi_resource_uart_serialbus *sb = &ares->data.uart_serial_bus;
if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS &&
sb->type == ACPI_RESOURCE_SERIAL_TYPE_UART) {
ec_uart->baudrate = sb->default_baud_rate;
dev_dbg(&ec_uart->serdev->dev, "Baudrate %d\n", ec_uart->baudrate);
ec_uart->flowcontrol = sb->flow_control;
dev_dbg(&ec_uart->serdev->dev, "Flow control %d\n", ec_uart->flowcontrol);
}
return 0;
}
static int cros_ec_uart_acpi_probe(struct cros_ec_uart *ec_uart)
{
int ret;
LIST_HEAD(resources);
struct acpi_device *adev = ACPI_COMPANION(&ec_uart->serdev->dev);
ret = acpi_dev_get_resources(adev, &resources, cros_ec_uart_resource, ec_uart);
if (ret < 0)
return ret;
acpi_dev_free_resource_list(&resources);
/* Retrieve GpioInt and translate it to Linux IRQ number */
ret = acpi_dev_gpio_irq_get(adev, 0);
if (ret < 0)
return ret;
ec_uart->irq = ret;
dev_dbg(&ec_uart->serdev->dev, "IRQ number %d\n", ec_uart->irq);
return 0;
}
static const struct serdev_device_ops cros_ec_uart_client_ops = {
.receive_buf = cros_ec_uart_rx_bytes,
};
static int cros_ec_uart_probe(struct serdev_device *serdev)
{
struct device *dev = &serdev->dev;
struct cros_ec_device *ec_dev;
struct cros_ec_uart *ec_uart;
int ret;
ec_uart = devm_kzalloc(dev, sizeof(*ec_uart), GFP_KERNEL);
if (!ec_uart)
return -ENOMEM;
ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL);
if (!ec_dev)
return -ENOMEM;
ret = devm_serdev_device_open(dev, serdev);
if (ret) {
dev_err(dev, "Unable to open UART device");
return ret;
}
serdev_device_set_drvdata(serdev, ec_dev);
init_waitqueue_head(&ec_uart->response.wait_queue);
ec_uart->serdev = serdev;
ret = cros_ec_uart_acpi_probe(ec_uart);
if (ret < 0) {
dev_err(dev, "Failed to get ACPI info (%d)", ret);
return ret;
}
ret = serdev_device_set_baudrate(serdev, ec_uart->baudrate);
if (ret < 0) {
dev_err(dev, "Failed to set up host baud rate (%d)", ret);
return ret;
}
serdev_device_set_flow_control(serdev, ec_uart->flowcontrol);
/* Initialize ec_dev for cros_ec */
ec_dev->phys_name = dev_name(dev);
ec_dev->dev = dev;
ec_dev->priv = ec_uart;
ec_dev->irq = ec_uart->irq;
ec_dev->cmd_xfer = NULL;
ec_dev->pkt_xfer = cros_ec_uart_pkt_xfer;
ec_dev->din_size = sizeof(struct ec_host_response) +
sizeof(struct ec_response_get_protocol_info);
ec_dev->dout_size = sizeof(struct ec_host_request);
serdev_device_set_client_ops(serdev, &cros_ec_uart_client_ops);
return cros_ec_register(ec_dev);
}
static void cros_ec_uart_remove(struct serdev_device *serdev)
{
struct cros_ec_device *ec_dev = serdev_device_get_drvdata(serdev);
cros_ec_unregister(ec_dev);
};
static int __maybe_unused cros_ec_uart_suspend(struct device *dev)
{
struct cros_ec_device *ec_dev = dev_get_drvdata(dev);
return cros_ec_suspend(ec_dev);
}
static int __maybe_unused cros_ec_uart_resume(struct device *dev)
{
struct cros_ec_device *ec_dev = dev_get_drvdata(dev);
return cros_ec_resume(ec_dev);
}
static SIMPLE_DEV_PM_OPS(cros_ec_uart_pm_ops, cros_ec_uart_suspend,
cros_ec_uart_resume);
static const struct of_device_id cros_ec_uart_of_match[] = {
{ .compatible = "google,cros-ec-uart" },
{}
};
MODULE_DEVICE_TABLE(of, cros_ec_uart_of_match);
#ifdef CONFIG_ACPI
static const struct acpi_device_id cros_ec_uart_acpi_id[] = {
{ "GOOG0019", 0 },
{}
};
MODULE_DEVICE_TABLE(acpi, cros_ec_uart_acpi_id);
#endif
static struct serdev_device_driver cros_ec_uart_driver = {
.driver = {
.name = "cros-ec-uart",
.acpi_match_table = ACPI_PTR(cros_ec_uart_acpi_id),
.of_match_table = cros_ec_uart_of_match,
.pm = &cros_ec_uart_pm_ops,
},
.probe = cros_ec_uart_probe,
.remove = cros_ec_uart_remove,
};
module_serdev_device_driver(cros_ec_uart_driver);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("UART interface for ChromeOS Embedded Controller");
MODULE_AUTHOR("Bhanu Prakash Maiya <bhanumaiya@chromium.org>");

16
drivers/platform/chrome/cros_typec_switch.c
View File

@ -246,15 +246,17 @@ static int cros_typec_register_switches(struct cros_typec_switch_data *sdata)
port->port_num = index;
sdata->ports[index] = port;
ret = cros_typec_register_retimer(port, fwnode);
if (ret) {
dev_err(dev, "Retimer switch register failed\n");
goto err_switch;
if (fwnode_property_present(fwnode, "retimer-switch")) {
ret = cros_typec_register_retimer(port, fwnode);
if (ret) {
dev_err(dev, "Retimer switch register failed\n");
goto err_switch;
}
dev_dbg(dev, "Retimer switch registered for index %llu\n", index);
}
dev_dbg(dev, "Retimer switch registered for index %llu\n", index);
if (!device_property_present(fwnode->dev, "mode-switch"))
if (!fwnode_property_present(fwnode, "mode-switch"))
continue;
ret = cros_typec_register_mode_switch(port, fwnode);

148
drivers/platform/chrome/cros_typec_vdm.c Normal file
View File

@ -0,0 +1,148 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* USB Power Delivery Vendor Defined Message (VDM) support code.
*
* Copyright 2023 Google LLC
* Author: Prashant Malani <pmalani@chromium.org>
*/
#include <linux/module.h>
#include <linux/platform_data/cros_ec_commands.h>
#include <linux/usb/pd_vdo.h>
#include "cros_ec_typec.h"
#include "cros_typec_vdm.h"
/*
* Retrieves pending VDM attention messages from the EC and forwards them to the altmode driver
* based on SVID.
*/
void cros_typec_handle_vdm_attention(struct cros_typec_data *typec, int port_num)
{
struct ec_response_typec_vdm_response resp;
struct ec_params_typec_vdm_response req = {
.port = port_num,
};
struct typec_altmode *amode;
u16 svid;
u32 hdr;
int ret;
do {
ret = cros_ec_cmd(typec->ec, 0, EC_CMD_TYPEC_VDM_RESPONSE, &req,
sizeof(req), &resp, sizeof(resp));
if (ret < 0) {
dev_warn(typec->dev, "Failed VDM response fetch, port: %d\n", port_num);
return;
}
hdr = resp.vdm_response[0];
svid = PD_VDO_VID(hdr);
dev_dbg(typec->dev, "Received VDM Attention header: %x, port: %d\n", hdr, port_num);
amode = typec_match_altmode(typec->ports[port_num]->port_altmode,
CROS_EC_ALTMODE_MAX, svid, PD_VDO_OPOS(hdr));
if (!amode) {
dev_err(typec->dev,
"Received VDM for unregistered altmode (SVID:%x), port: %d\n",
svid, port_num);
return;
}
typec_altmode_attention(amode, resp.vdm_attention[1]);
} while (resp.vdm_attention_left);
}
/*
* Retrieves a VDM response from the EC and forwards it to the altmode driver based on SVID.
*/
void cros_typec_handle_vdm_response(struct cros_typec_data *typec, int port_num)
{
struct ec_response_typec_vdm_response resp;
struct ec_params_typec_vdm_response req = {
.port = port_num,
};
struct typec_altmode *amode;
u16 svid;
u32 hdr;
int ret;
ret = cros_ec_cmd(typec->ec, 0, EC_CMD_TYPEC_VDM_RESPONSE, &req,
sizeof(req), &resp, sizeof(resp));
if (ret < 0) {
dev_warn(typec->dev, "Failed VDM response fetch, port: %d\n", port_num);
return;
}
hdr = resp.vdm_response[0];
svid = PD_VDO_VID(hdr);
dev_dbg(typec->dev, "Received VDM header: %x, port: %d\n", hdr, port_num);
amode = typec_match_altmode(typec->ports[port_num]->port_altmode, CROS_EC_ALTMODE_MAX,
svid, PD_VDO_OPOS(hdr));
if (!amode) {
dev_err(typec->dev, "Received VDM for unregistered altmode (SVID:%x), port: %d\n",
svid, port_num);
return;
}
ret = typec_altmode_vdm(amode, hdr, &resp.vdm_response[1], resp.vdm_data_objects);
if (ret)
dev_err(typec->dev, "Failed to forward VDM to altmode (SVID:%x), port: %d\n",
svid, port_num);
}
static int cros_typec_port_amode_enter(struct typec_altmode *amode, u32 *vdo)
{
struct cros_typec_port *port = typec_altmode_get_drvdata(amode);
struct ec_params_typec_control req = {
.port = port->port_num,
.command = TYPEC_CONTROL_COMMAND_SEND_VDM_REQ,
};
struct typec_vdm_req vdm_req = {};
u32 hdr;
hdr = VDO(amode->svid, 1, SVDM_VER_2_0, CMD_ENTER_MODE);
hdr |= VDO_OPOS(amode->mode);
vdm_req.vdm_data[0] = hdr;
vdm_req.vdm_data_objects = 1;
vdm_req.partner_type = TYPEC_PARTNER_SOP;
req.vdm_req_params = vdm_req;
dev_dbg(port->typec_data->dev, "Sending EnterMode VDM, hdr: %x, port: %d\n",
hdr, port->port_num);
return cros_ec_cmd(port->typec_data->ec, 0, EC_CMD_TYPEC_CONTROL, &req,
sizeof(req), NULL, 0);
}
static int cros_typec_port_amode_vdm(struct typec_altmode *amode, const u32 hdr,
const u32 *vdo, int cnt)
{
struct cros_typec_port *port = typec_altmode_get_drvdata(amode);
struct ec_params_typec_control req = {
.port = port->port_num,
.command = TYPEC_CONTROL_COMMAND_SEND_VDM_REQ,
};
struct typec_vdm_req vdm_req = {};
int i;
vdm_req.vdm_data[0] = hdr;
vdm_req.vdm_data_objects = cnt;
for (i = 1; i < cnt; i++)
vdm_req.vdm_data[i] = vdo[i-1];
vdm_req.partner_type = TYPEC_PARTNER_SOP;
req.vdm_req_params = vdm_req;
dev_dbg(port->typec_data->dev, "Sending VDM, hdr: %x, num_objects: %d, port: %d\n",
hdr, cnt, port->port_num);
return cros_ec_cmd(port->typec_data->ec, 0, EC_CMD_TYPEC_CONTROL, &req,
sizeof(req), NULL, 0);
}
struct typec_altmode_ops port_amode_ops = {
.enter = cros_typec_port_amode_enter,
.vdm = cros_typec_port_amode_vdm,
};

13
drivers/platform/chrome/cros_typec_vdm.h Normal file
View File

@ -0,0 +1,13 @@
/* SPDX-License-Identifier: GPL-2.0-only */
#ifndef __CROS_TYPEC_VDM__
#define __CROS_TYPEC_VDM__
#include <linux/usb/typec_altmode.h>
extern struct typec_altmode_ops port_amode_ops;
void cros_typec_handle_vdm_attention(struct cros_typec_data *typec, int port_num);
void cros_typec_handle_vdm_response(struct cros_typec_data *typec, int port_num);
#endif /* __CROS_TYPEC_VDM__ */

3
drivers/platform/chrome/wilco_ec/sysfs.c
View File

@ -119,8 +119,7 @@ static ssize_t get_info(struct device *dev, char *buf, enum get_ec_info_op op)
if (ret < 0)
return ret;
return scnprintf(buf, PAGE_SIZE, "%.*s\n", (int)sizeof(resp.value),
(char *)&resp.value);
return sysfs_emit(buf, "%.*s\n", (int)sizeof(resp.value), (char *)&resp.value);
}
static ssize_t version_show(struct device *dev, struct device_attribute *attr,

69
include/linux/platform_data/cros_ec_commands.h
View File

@ -1082,7 +1082,7 @@ struct ec_params_get_cmd_versions_v1 {
} __ec_align2;
/**
* struct ec_response_get_cmd_version - Response to the get command versions.
* struct ec_response_get_cmd_versions - Response to the get command versions.
* @version_mask: Mask of supported versions; use EC_VER_MASK() to compare with
* a desired version.
*/
@ -1300,8 +1300,18 @@ enum ec_feature_code {
* mux.
*/
EC_FEATURE_TYPEC_MUX_REQUIRE_AP_ACK = 43,
/* The MCU is a System Companion Processor (SCP) 2nd Core. */
EC_FEATURE_SCP_C1 = 45,
/*
* The EC supports entering and residing in S4.
*/
EC_FEATURE_S4_RESIDENCY = 44,
/*
* The EC supports the AP directing mux sets for the board.
*/
EC_FEATURE_TYPEC_AP_MUX_SET = 45,
/*
* The EC supports the AP composing VDMs for us to send.
*/
EC_FEATURE_TYPEC_AP_VDM_SEND = 46,
};
#define EC_FEATURE_MASK_0(event_code) BIT(event_code % 32)
@ -5470,7 +5480,7 @@ struct ec_response_rollback_info {
/* Issue AP reset */
#define EC_CMD_AP_RESET 0x0125
/**
/*
* Get the number of peripheral charge ports
*/
#define EC_CMD_PCHG_COUNT 0x0134
@ -5481,7 +5491,7 @@ struct ec_response_pchg_count {
uint8_t port_count;
} __ec_align1;
/**
/*
* Get the status of a peripheral charge port
*/
#define EC_CMD_PCHG 0x0135
@ -5726,6 +5736,8 @@ enum typec_control_command {
TYPEC_CONTROL_COMMAND_ENTER_MODE,
TYPEC_CONTROL_COMMAND_TBT_UFP_REPLY,
TYPEC_CONTROL_COMMAND_USB_MUX_SET,
TYPEC_CONTROL_COMMAND_BIST_SHARE_MODE,
TYPEC_CONTROL_COMMAND_SEND_VDM_REQ,
};
/* Replies the AP may specify to the TBT EnterMode command as a UFP */
@ -5739,6 +5751,17 @@ struct typec_usb_mux_set {
uint8_t mux_flags; /* USB_PD_MUX_*-encoded USB mux state to set */
} __ec_align1;
#define VDO_MAX_SIZE 7
struct typec_vdm_req {
/* VDM data, including VDM header */
uint32_t vdm_data[VDO_MAX_SIZE];
/* Number of 32-bit fields filled in */
uint8_t vdm_data_objects;
/* Partner to address - see enum typec_partner_type */
uint8_t partner_type;
} __ec_align1;
struct ec_params_typec_control {
uint8_t port;
uint8_t command; /* enum typec_control_command */
@ -5754,6 +5777,8 @@ struct ec_params_typec_control {
uint8_t mode_to_enter; /* enum typec_mode */
uint8_t tbt_ufp_reply; /* enum typec_tbt_ufp_reply */
struct typec_usb_mux_set mux_params;
/* Used for VMD_REQ */
struct typec_vdm_req vdm_req_params;
uint8_t placeholder[128];
};
} __ec_align1;
@ -5835,6 +5860,9 @@ enum tcpc_cc_polarity {
#define PD_STATUS_EVENT_DISCONNECTED BIT(3)
#define PD_STATUS_EVENT_MUX_0_SET_DONE BIT(4)
#define PD_STATUS_EVENT_MUX_1_SET_DONE BIT(5)
#define PD_STATUS_EVENT_VDM_REQ_REPLY BIT(6)
#define PD_STATUS_EVENT_VDM_REQ_FAILED BIT(7)
#define PD_STATUS_EVENT_VDM_ATTENTION BIT(8)
struct ec_params_typec_status {
uint8_t port;
@ -5878,6 +5906,37 @@ struct ec_response_typec_status {
uint32_t sink_cap_pdos[7]; /* Max 7 PDOs can be present */
} __ec_align1;
/*
* Gather the response to the most recent VDM REQ from the AP, as well
* as popping the oldest VDM:Attention from the DPM queue
*/
#define EC_CMD_TYPEC_VDM_RESPONSE 0x013C
struct ec_params_typec_vdm_response {
uint8_t port;
} __ec_align1;
struct ec_response_typec_vdm_response {
/* Number of 32-bit fields filled in */
uint8_t vdm_data_objects;
/* Partner to address - see enum typec_partner_type */
uint8_t partner_type;
/* enum ec_status describing VDM response */
uint16_t vdm_response_err;
/* VDM data, including VDM header */
uint32_t vdm_response[VDO_MAX_SIZE];
/* Number of 32-bit Attention fields filled in */
uint8_t vdm_attention_objects;
/* Number of remaining messages to consume */
uint8_t vdm_attention_left;
/* Reserved */
uint16_t reserved1;
/* VDM:Attention contents */
uint32_t vdm_attention[2];
} __ec_align1;
#undef VDO_MAX_SIZE
/*****************************************************************************/
/* The command range 0x200-0x2FF is reserved for Rotor. */

24
include/linux/platform_data/cros_ec_proto.h
View File

@ -9,6 +9,7 @@
#define __LINUX_CROS_EC_PROTO_H
#include <linux/device.h>
#include <linux/lockdep_types.h>
#include <linux/mutex.h>
#include <linux/notifier.h>
@ -19,7 +20,6 @@
#define CROS_EC_DEV_ISH_NAME "cros_ish"
#define CROS_EC_DEV_PD_NAME "cros_pd"
#define CROS_EC_DEV_SCP_NAME "cros_scp"
#define CROS_EC_DEV_SCP_C1_NAME "cros_scp_c1"
#define CROS_EC_DEV_TP_NAME "cros_tp"
#define CROS_EC_DEV_EC_INDEX 0
@ -41,6 +41,13 @@
#define EC_MAX_REQUEST_OVERHEAD 1
#define EC_MAX_RESPONSE_OVERHEAD 32
/*
* EC panic is not covered by the standard (0-F) ACPI notify values.
* Arbitrarily choosing B0 to notify ec panic, which is in the 84-BF
* device specific ACPI notify range.
*/
#define ACPI_NOTIFY_CROS_EC_PANIC 0xB0
/*
* Command interface between EC and AP, for LPC, I2C and SPI interfaces.
*/
@ -116,6 +123,8 @@ struct cros_ec_command {
* command. The caller should check msg.result for the EC's result
* code.
* @pkt_xfer: Send packet to EC and get response.
* @lockdep_key: Lockdep class for each instance. Unused if CONFIG_LOCKDEP is
* not enabled.
* @lock: One transaction at a time.
* @mkbp_event_supported: 0 if MKBP not supported. Otherwise its value is
* the maximum supported version of the MKBP host event
@ -125,6 +134,15 @@ struct cros_ec_command {
* @event_data: Raw payload transferred with the MKBP event.
* @event_size: Size in bytes of the event data.
* @host_event_wake_mask: Mask of host events that cause wake from suspend.
* @suspend_timeout_ms: The timeout in milliseconds between when sleep event
* is received and when the EC will declare sleep
* transition failure if the sleep signal is not
* asserted. See also struct
* ec_params_host_sleep_event_v1 in cros_ec_commands.h.
* @last_resume_result: The number of sleep power signal transitions that
* occurred since the suspend message. The high bit
* indicates a timeout occurred. See also struct
* ec_response_host_sleep_event_v1 in cros_ec_commands.h.
* @last_event_time: exact time from the hard irq when we got notified of
* a new event.
* @notifier_ready: The notifier_block to let the kernel re-query EC
@ -134,6 +152,7 @@ struct cros_ec_command {
* main EC.
* @pd: The platform_device used by the mfd driver to interface with the
* PD behind an EC.
* @panic_notifier: EC panic notifier.
*/
struct cros_ec_device {
/* These are used by other drivers that want to talk to the EC */
@ -160,6 +179,7 @@ struct cros_ec_device {
struct cros_ec_command *msg);
int (*pkt_xfer)(struct cros_ec_device *ec,
struct cros_ec_command *msg);
struct lock_class_key lockdep_key;
struct mutex lock;
u8 mkbp_event_supported;
bool host_sleep_v1;
@ -176,6 +196,8 @@ struct cros_ec_device {
/* The platform devices used by the mfd driver */
struct platform_device *ec;
struct platform_device *pd;
struct blocking_notifier_head panic_notifier;
};
/**