/* SPDX-License-Identifier: GPL-2.0-or-later */ #include #include #include #include #include #include #include #include #include #include "chip.h" #include "retimer.h" /* Unique ID for the retimer _DSM. */ #define INTEL_USB4_RETIMER_DSM_UUID "E0053122-795B-4122-8A5E-57BE1D26ACB3" static const char *usb4_retimer_scope; static const char *usb4_retimer_path_arg(const char *arg) { /* \\_SB.PCI0.TDMx.ARG */ static char name[DEVICE_PATH_MAX]; snprintf(name, sizeof(name), "%s%c%s", usb4_retimer_scope, '.', arg); return name; } /* Each polling cycle takes up to 25 ms with a total of 12 of these iterations */ #define USB4_RETIMER_ITERATION_NUM 12 #define USB4_RETIMER_POLL_CYCLE_MS 25 static void usb4_retimer_execute_ec_cmd(uint8_t port, uint8_t cmd, uint8_t expected_value) { const char *RFWU = ec_retimer_fw_update_path(); const uint8_t data = cmd << USB_RETIMER_FW_UPDATE_OP_SHIFT | port; /* Invoke EC Retimer firmware update command execution */ ec_retimer_fw_update(data); /* If RFWU has return value 0xfe, return error -1 */ acpigen_write_if_lequal_namestr_int(RFWU, USB_RETIMER_FW_UPDATE_ERROR); acpigen_write_return_integer(-1); acpigen_pop_len(); /* If */ acpigen_write_store_int_to_op(USB4_RETIMER_ITERATION_NUM, LOCAL2_OP); acpigen_emit_byte(WHILE_OP); acpigen_write_len_f(); acpigen_emit_byte(LGREATER_OP); acpigen_emit_byte(LOCAL2_OP); acpigen_emit_byte(ZERO_OP); acpigen_write_if_lequal_namestr_int(RFWU, expected_value); acpigen_emit_byte(BREAK_OP); acpigen_pop_len(); /* If */ if (cmd == USB_RETIMER_FW_UPDATE_SET_TBT) { /* * EC return either USB_PD_MUX_USB4_ENABLED or USB_PD_MUX_TBT_COMPAT_ENABLED * to RFWU after the USB_RETIMER_FW_UPDATE_SET_TBT command execution. It is * needed to add additional check for USB_PD_MUX_TBT_COMPAT_ENABLED. */ acpigen_write_if_lequal_namestr_int(RFWU, USB_PD_MUX_TBT_COMPAT_ENABLED); acpigen_emit_byte(BREAK_OP); acpigen_pop_len(); /* If */ } acpigen_write_sleep(USB4_RETIMER_POLL_CYCLE_MS); acpigen_emit_byte(DECREMENT_OP); acpigen_emit_byte(LOCAL2_OP); acpigen_pop_len(); /* While */ /* * Check whether there is timeout error * Return: -1 if timeout error occurring */ acpigen_write_if_lequal_op_int(LOCAL2_OP, 0); acpigen_write_return_integer(-1); acpigen_pop_len(); /* If */ } static void enable_retimer_online_state(uint8_t port, struct acpi_gpio *power_gpio) { uint8_t expected_value; /* * Enable_retimer_online_state under NDA * 1. Force power on * 2. Check if there is a device connected * 3. Suspend PD * 4. Set Mux to USB mode * 5. Set Mux to Safe mode * 6. Set Mux to TBT mode */ /* Force power on for the retimer on the port */ acpigen_enable_tx_gpio(power_gpio); /* * Get MUX mode state * Return -1 if there is a device connected on the port. * Otherwise proceed Retimer firmware upgrade operation. */ expected_value = USB_PD_MUX_NONE; usb4_retimer_execute_ec_cmd(port, USB_RETIMER_FW_UPDATE_GET_MUX, expected_value); /* * Suspend PD * Command: USB_RETIMER_FW_UPDATE_SUSPEND_PD * Expect return value: 0 */ expected_value = 0; usb4_retimer_execute_ec_cmd(port, USB_RETIMER_FW_UPDATE_SUSPEND_PD, expected_value); /* * Set MUX USB Mode * Command: USB_RETIMER_FW_UPDATE_SUSPEND_PD * Expect return value: USB_PD_MUX_USB_ENABLED */ expected_value = USB_PD_MUX_USB_ENABLED; usb4_retimer_execute_ec_cmd(port, USB_RETIMER_FW_UPDATE_SET_USB, expected_value); /* * Set MUX Safe Mode * Command: USB_RETIMER_FW_UPDATE_SET_SAFE * Expect return value: USB_PD_MUX_SAFE_MODE */ expected_value = USB_PD_MUX_SAFE_MODE; usb4_retimer_execute_ec_cmd(port, USB_RETIMER_FW_UPDATE_SET_SAFE, expected_value); /* * Set MUX TBT Mode * Command: USB_RETIMER_FW_UPDATE_SET_TBT * Expect return value: USB_PD_MUX_USB4_ENABLED or USB_PD_MUX_TBT_COMPAT_ENABLED */ expected_value = USB_PD_MUX_USB4_ENABLED; usb4_retimer_execute_ec_cmd(port, USB_RETIMER_FW_UPDATE_SET_TBT, expected_value); } static void disable_retimer_online_state(uint8_t port, struct acpi_gpio *power_gpio) { uint8_t expected_value; /* * Disable_retimer_online_state * 1. Set Mux to disconnect mode * 2. Resume PD * 3. Force power off */ /* * Set MUX Disconnect Mode * Command: USB_RETIMER_FW_UPDATE_DISCONNECT * Expect return value: 0 */ expected_value = 0; usb4_retimer_execute_ec_cmd(port, USB_RETIMER_FW_UPDATE_DISCONNECT, expected_value); /* * Resume PD * Command: USB_RETIMER_FW_UPDATE_RESUME_PD * Expect return value: 1 */ expected_value = 1; usb4_retimer_execute_ec_cmd(port, USB_RETIMER_FW_UPDATE_RESUME_PD, expected_value); /* Force power off */ acpigen_disable_tx_gpio(power_gpio); } /* * Arg0: UUID e0053122-795b-4122-8a5e-57be1d26acb3 * Arg1: Revision ID (set to 1) * Arg2: Function Index * 0: Query command implemented * 1: Get power state * 2: Set power state * Arg3: A package containing parameters for the function specified * by the UUID, revision ID, function index and port index. */ static void usb4_retimer_cb_standard_query(uint8_t port, void *arg) { /* * ToInteger (Arg1, Local1) * If (Local1 == 1) { * Return(Buffer() {0x7}) * } * Return (Buffer() {0x01}) */ acpigen_write_to_integer(ARG1_OP, LOCAL1_OP); /* Revision 1 supports 2 Functions beyond the standard query */ acpigen_write_if_lequal_op_int(LOCAL1_OP, 1); acpigen_write_return_singleton_buffer(0x7); acpigen_pop_len(); /* If */ /* Other revisions support no additional functions */ acpigen_write_return_singleton_buffer(0x1); } static void usb4_retimer_cb_get_power_state(uint8_t port, void *arg) { const char *PWR; char pwr[DEVICE_PATH_MAX]; snprintf(pwr, sizeof(pwr), "HR.DFP%1d.PWR", port); PWR = usb4_retimer_path_arg(pwr); /* * If (PWR > 0) { * Return (1) * } */ acpigen_write_if(); acpigen_emit_byte(LGREATER_OP); acpigen_emit_namestring(PWR); acpigen_emit_byte(0); acpigen_write_return_integer(1); /* * Else { * Return (0) * } */ acpigen_write_else(); acpigen_write_return_integer(0); acpigen_pop_len(); } static void usb4_retimer_cb_set_power_state(uint8_t port, void *arg) { struct acpi_gpio *power_gpio = arg; const char *PWR; char pwr[DEVICE_PATH_MAX]; snprintf(pwr, sizeof(pwr), "HR.DFP%1d.PWR", port); PWR = usb4_retimer_path_arg(pwr); /* * Get information to set retimer power state from Arg3[0] * Local1 = DeRefOf (Arg3[0]) */ acpigen_get_package_op_element(ARG3_OP, 0, LOCAL1_OP); /* * If ((Local1 == 0) && (PWR > 0)) { * PWR-- * If (PWR == 0) { * // Disable retimer online state * } * } */ acpigen_write_if(); acpigen_emit_byte(LAND_OP); acpigen_emit_byte(LEQUAL_OP); acpigen_emit_byte(LOCAL1_OP); acpigen_emit_byte(0); acpigen_emit_byte(LGREATER_OP); acpigen_emit_namestring(PWR); acpigen_emit_byte(0); /* PWR-- */ acpigen_emit_byte(DECREMENT_OP); acpigen_emit_namestring(PWR); acpigen_write_if_lequal_namestr_int(PWR, 0); /* If (PWR == 0) */ disable_retimer_online_state(port, power_gpio); acpigen_pop_len(); /* If (PWR == 0) */ /* * Else If ((Local1 == 1) && (PWR == 0)) { * // Enable retimer online state * PWR++ * } */ acpigen_write_else(); acpigen_write_if(); acpigen_emit_byte(LAND_OP); acpigen_emit_byte(LEQUAL_OP); acpigen_emit_byte(LOCAL1_OP); acpigen_emit_byte(1); acpigen_emit_byte(LEQUAL_OP); acpigen_emit_namestring(PWR); acpigen_emit_byte(0); enable_retimer_online_state(port, power_gpio); /* PWR++ */ acpigen_emit_byte(INCREMENT_OP); acpigen_emit_namestring(PWR); /* * Else { * Return (0) * } */ acpigen_write_else(); acpigen_write_return_integer(0); acpigen_pop_len(); /* Else */ acpigen_pop_len(); /* If */ /* * If (PWR == 1) { * Return (1) * } */ acpigen_write_if_lequal_namestr_int(PWR, 1); acpigen_write_return_integer(1); /* * Else { * Return (0) * } */ acpigen_write_else(); acpigen_write_return_integer(0); acpigen_pop_len(); } static void (*usb4_retimer_callbacks[3])(uint8_t port, void *) = { usb4_retimer_cb_standard_query, /* Function 0 */ usb4_retimer_cb_get_power_state, /* Function 1 */ usb4_retimer_cb_set_power_state, /* Function 2 */ }; static void usb4_retimer_write_dsm(uint8_t port, const char *uuid, void (**callbacks)(uint8_t port, void *), size_t count, void *arg) { struct usb4_retimer_dsm_uuid id = DSM_UUID(uuid, callbacks, count, arg); size_t i; acpigen_write_to_integer(ARG2_OP, LOCAL0_OP); for (i = 0; i < id.count; i++) { /* If (LEqual (Local0, i)) */ acpigen_write_if_lequal_op_int(LOCAL0_OP, i); /* Callback to write if handler. */ if (id.callbacks[i]) id.callbacks[i](port, id.arg); acpigen_pop_len(); /* If */ } } static void usb4_retimer_fill_ssdt(const struct device *dev) { struct drivers_intel_usb4_retimer_config *config = dev->chip_info; const struct device *usb_device; static char dfp[DEVICE_PATH_MAX]; struct acpi_pld pld; uint8_t dfp_port, usb_port; int ec_port = 0; usb4_retimer_scope = acpi_device_scope(dev); if (!usb4_retimer_scope || !config) return; /* Scope */ acpigen_write_scope(usb4_retimer_scope); /* Host router */ acpigen_write_device("HR"); acpigen_write_ADR(0); acpigen_write_STA(ACPI_STATUS_DEVICE_ALL_ON); for (dfp_port = 0; dfp_port < DFP_NUM_MAX; dfp_port++) { if (!config->dfp[dfp_port].power_gpio.pin_count) { printk(BIOS_ERR, "%s: No DFP%1d power GPIO for %s\n", __func__, dfp_port, dev_path(dev)); continue; } usb_device = config->dfp[dfp_port].typec_port; usb_port = usb_device->path.usb.port_id; ec_port = retimer_get_index_for_typec(usb_port); if (ec_port == -1) { printk(BIOS_ERR, "%s: No relative EC port found for TC port %d\n", __func__, usb_port); continue; } /* DFPx */ snprintf(dfp, sizeof(dfp), "DFP%1d", ec_port); acpigen_write_device(dfp); /* _ADR part is for the lane adapter */ acpigen_write_ADR(dfp_port*2 + 1); /* Fill _PLD with the same USB 3.x object on the Type-C connector */ if (CONFIG(DRIVERS_USB_ACPI)) { if (usb_acpi_get_pld(usb_device, &pld)) acpigen_write_pld(&pld); else printk(BIOS_ERR, "Error retrieving PLD for USB Type-C %d\n", usb_port); } /* Power online reference counter(_PWR) */ acpigen_write_name("PWR"); acpigen_write_zero(); /* Method (_DSM, 4, Serialized) */ acpigen_write_method_serialized("_DSM", 0x4); /* ToBuffer (Arg0, Local0) */ acpigen_write_to_buffer(ARG0_OP, LOCAL0_OP); acpigen_write_if(); /* If (UUID != INTEL_USB4_RETIMER_DSM_UUID) */ acpigen_emit_byte(LNOT_OP); acpigen_emit_byte(LEQUAL_OP); acpigen_emit_byte(LOCAL0_OP); acpigen_write_uuid(INTEL_USB4_RETIMER_DSM_UUID); /* Return (Buffer (One) { 0x0 }) */ acpigen_write_return_singleton_buffer(0x0); acpigen_pop_len(); usb4_retimer_write_dsm(ec_port, INTEL_USB4_RETIMER_DSM_UUID, usb4_retimer_callbacks, ARRAY_SIZE(usb4_retimer_callbacks), (void *)&config->dfp[dfp_port].power_gpio); /* Default case: Return (Buffer (One) { 0x0 }) */ acpigen_write_return_singleton_buffer(0x0); acpigen_pop_len(); /* Method _DSM */ acpigen_pop_len(); /* DFP */ } acpigen_pop_len(); /* Host Router */ acpigen_pop_len(); /* Scope */ printk(BIOS_INFO, "%s.HR: %s at %s\n", usb4_retimer_scope, dev->chip_ops->name, dev_path(dev)); } static struct device_operations usb4_retimer_dev_ops = { .read_resources = noop_read_resources, .set_resources = noop_set_resources, .acpi_fill_ssdt = usb4_retimer_fill_ssdt, }; static void usb4_retimer_enable(struct device *dev) { dev->ops = &usb4_retimer_dev_ops; } struct chip_operations drivers_intel_usb4_retimer_ops = { CHIP_NAME("Intel USB4 Retimer") .enable_dev = usb4_retimer_enable }; __weak const char *ec_retimer_fw_update_path(void) { return NULL; } __weak void ec_retimer_fw_update(uint8_t data) { } /* * This function will convert CPU physical port mapping to abstract * EC port mapping. * For example, board might have enabled TCSS port 1 and 3 as per physical * port mapping. Since only 2 TCSS ports are enabled EC will index it as port 0 * and port 1. So there will be an issue when coreboot sends command to EC for * port 3 (with coreboot index of 2). EC will produce an error due to wrong index. * * Note: Each SoC code using retimer driver needs to implement this function * since SoC will have physical port details. */ __weak int retimer_get_index_for_typec(uint8_t typec_port) { /* By default assume that retimer port index = Type C port */ return (int)typec_port; }