// SPDX-License-Identifier: GPL-2.0 /* * USB4 specific functionality * * Copyright (C) 2019, Intel Corporation * Authors: Mika Westerberg <[email protected]> * Rajmohan Mani <[email protected]> */ #include <linux/delay.h> #include <linux/ktime.h> #include <linux/units.h> #include "sb_regs.h" #include "tb.h" #define USB4_DATA_RETRIES … #define USB4_DATA_DWORDS … #define USB4_NVM_READ_OFFSET_MASK … #define USB4_NVM_READ_OFFSET_SHIFT … #define USB4_NVM_READ_LENGTH_MASK … #define USB4_NVM_READ_LENGTH_SHIFT … #define USB4_NVM_SET_OFFSET_MASK … #define USB4_NVM_SET_OFFSET_SHIFT … #define USB4_DROM_ADDRESS_MASK … #define USB4_DROM_ADDRESS_SHIFT … #define USB4_DROM_SIZE_MASK … #define USB4_DROM_SIZE_SHIFT … #define USB4_NVM_SECTOR_SIZE_MASK … #define USB4_BA_LENGTH_MASK … #define USB4_BA_INDEX_MASK … enum usb4_ba_index { … }; #define USB4_BA_VALUE_MASK … #define USB4_BA_VALUE_SHIFT … /* Delays in us used with usb4_port_wait_for_bit() */ #define USB4_PORT_DELAY … #define USB4_PORT_SB_DELAY … static int usb4_native_switch_op(struct tb_switch *sw, u16 opcode, u32 *metadata, u8 *status, const void *tx_data, size_t tx_dwords, void *rx_data, size_t rx_dwords) { … } static int __usb4_switch_op(struct tb_switch *sw, u16 opcode, u32 *metadata, u8 *status, const void *tx_data, size_t tx_dwords, void *rx_data, size_t rx_dwords) { … } static inline int usb4_switch_op(struct tb_switch *sw, u16 opcode, u32 *metadata, u8 *status) { … } static inline int usb4_switch_op_data(struct tb_switch *sw, u16 opcode, u32 *metadata, u8 *status, const void *tx_data, size_t tx_dwords, void *rx_data, size_t rx_dwords) { … } /** * usb4_switch_check_wakes() - Check for wakes and notify PM core about them * @sw: Router whose wakes to check * * Checks wakes occurred during suspend and notify the PM core about them. */ void usb4_switch_check_wakes(struct tb_switch *sw) { … } static bool link_is_usb4(struct tb_port *port) { … } /** * usb4_switch_setup() - Additional setup for USB4 device * @sw: USB4 router to setup * * USB4 routers need additional settings in order to enable all the * tunneling. This function enables USB and PCIe tunneling if it can be * enabled (e.g the parent switch also supports them). If USB tunneling * is not available for some reason (like that there is Thunderbolt 3 * switch upstream) then the internal xHCI controller is enabled * instead. * * This does not set the configuration valid bit of the router. To do * that call usb4_switch_configuration_valid(). */ int usb4_switch_setup(struct tb_switch *sw) { … } /** * usb4_switch_configuration_valid() - Set tunneling configuration to be valid * @sw: USB4 router * * Sets configuration valid bit for the router. Must be called before * any tunnels can be set through the router and after * usb4_switch_setup() has been called. Can be called to host and device * routers (does nothing for the latter). * * Returns %0 in success and negative errno otherwise. */ int usb4_switch_configuration_valid(struct tb_switch *sw) { … } /** * usb4_switch_read_uid() - Read UID from USB4 router * @sw: USB4 router * @uid: UID is stored here * * Reads 64-bit UID from USB4 router config space. */ int usb4_switch_read_uid(struct tb_switch *sw, u64 *uid) { … } static int usb4_switch_drom_read_block(void *data, unsigned int dwaddress, void *buf, size_t dwords) { … } /** * usb4_switch_drom_read() - Read arbitrary bytes from USB4 router DROM * @sw: USB4 router * @address: Byte address inside DROM to start reading * @buf: Buffer where the DROM content is stored * @size: Number of bytes to read from DROM * * Uses USB4 router operations to read router DROM. For devices this * should always work but for hosts it may return %-EOPNOTSUPP in which * case the host router does not have DROM. */ int usb4_switch_drom_read(struct tb_switch *sw, unsigned int address, void *buf, size_t size) { … } /** * usb4_switch_lane_bonding_possible() - Are conditions met for lane bonding * @sw: USB4 router * * Checks whether conditions are met so that lane bonding can be * established with the upstream router. Call only for device routers. */ bool usb4_switch_lane_bonding_possible(struct tb_switch *sw) { … } /** * usb4_switch_set_wake() - Enabled/disable wake * @sw: USB4 router * @flags: Wakeup flags (%0 to disable) * * Enables/disables router to wake up from sleep. */ int usb4_switch_set_wake(struct tb_switch *sw, unsigned int flags) { … } /** * usb4_switch_set_sleep() - Prepare the router to enter sleep * @sw: USB4 router * * Sets sleep bit for the router. Returns when the router sleep ready * bit has been asserted. */ int usb4_switch_set_sleep(struct tb_switch *sw) { … } /** * usb4_switch_nvm_sector_size() - Return router NVM sector size * @sw: USB4 router * * If the router supports NVM operations this function returns the NVM * sector size in bytes. If NVM operations are not supported returns * %-EOPNOTSUPP. */ int usb4_switch_nvm_sector_size(struct tb_switch *sw) { … } static int usb4_switch_nvm_read_block(void *data, unsigned int dwaddress, void *buf, size_t dwords) { … } /** * usb4_switch_nvm_read() - Read arbitrary bytes from router NVM * @sw: USB4 router * @address: Starting address in bytes * @buf: Read data is placed here * @size: How many bytes to read * * Reads NVM contents of the router. If NVM is not supported returns * %-EOPNOTSUPP. */ int usb4_switch_nvm_read(struct tb_switch *sw, unsigned int address, void *buf, size_t size) { … } /** * usb4_switch_nvm_set_offset() - Set NVM write offset * @sw: USB4 router * @address: Start offset * * Explicitly sets NVM write offset. Normally when writing to NVM this * is done automatically by usb4_switch_nvm_write(). * * Returns %0 in success and negative errno if there was a failure. */ int usb4_switch_nvm_set_offset(struct tb_switch *sw, unsigned int address) { … } static int usb4_switch_nvm_write_next_block(void *data, unsigned int dwaddress, const void *buf, size_t dwords) { … } /** * usb4_switch_nvm_write() - Write to the router NVM * @sw: USB4 router * @address: Start address where to write in bytes * @buf: Pointer to the data to write * @size: Size of @buf in bytes * * Writes @buf to the router NVM using USB4 router operations. If NVM * write is not supported returns %-EOPNOTSUPP. */ int usb4_switch_nvm_write(struct tb_switch *sw, unsigned int address, const void *buf, size_t size) { … } /** * usb4_switch_nvm_authenticate() - Authenticate new NVM * @sw: USB4 router * * After the new NVM has been written via usb4_switch_nvm_write(), this * function triggers NVM authentication process. The router gets power * cycled and if the authentication is successful the new NVM starts * running. In case of failure returns negative errno. * * The caller should call usb4_switch_nvm_authenticate_status() to read * the status of the authentication after power cycle. It should be the * first router operation to avoid the status being lost. */ int usb4_switch_nvm_authenticate(struct tb_switch *sw) { … } /** * usb4_switch_nvm_authenticate_status() - Read status of last NVM authenticate * @sw: USB4 router * @status: Status code of the operation * * The function checks if there is status available from the last NVM * authenticate router operation. If there is status then %0 is returned * and the status code is placed in @status. Returns negative errno in case * of failure. * * Must be called before any other router operation. */ int usb4_switch_nvm_authenticate_status(struct tb_switch *sw, u32 *status) { … } /** * usb4_switch_credits_init() - Read buffer allocation parameters * @sw: USB4 router * * Reads @sw buffer allocation parameters and initializes @sw buffer * allocation fields accordingly. Specifically @sw->credits_allocation * is set to %true if these parameters can be used in tunneling. * * Returns %0 on success and negative errno otherwise. */ int usb4_switch_credits_init(struct tb_switch *sw) { … } /** * usb4_switch_query_dp_resource() - Query availability of DP IN resource * @sw: USB4 router * @in: DP IN adapter * * For DP tunneling this function can be used to query availability of * DP IN resource. Returns true if the resource is available for DP * tunneling, false otherwise. */ bool usb4_switch_query_dp_resource(struct tb_switch *sw, struct tb_port *in) { … } /** * usb4_switch_alloc_dp_resource() - Allocate DP IN resource * @sw: USB4 router * @in: DP IN adapter * * Allocates DP IN resource for DP tunneling using USB4 router * operations. If the resource was allocated returns %0. Otherwise * returns negative errno, in particular %-EBUSY if the resource is * already allocated. */ int usb4_switch_alloc_dp_resource(struct tb_switch *sw, struct tb_port *in) { … } /** * usb4_switch_dealloc_dp_resource() - Releases allocated DP IN resource * @sw: USB4 router * @in: DP IN adapter * * Releases the previously allocated DP IN resource. */ int usb4_switch_dealloc_dp_resource(struct tb_switch *sw, struct tb_port *in) { … } static int usb4_port_idx(const struct tb_switch *sw, const struct tb_port *port) { … } /** * usb4_switch_map_pcie_down() - Map USB4 port to a PCIe downstream adapter * @sw: USB4 router * @port: USB4 port * * USB4 routers have direct mapping between USB4 ports and PCIe * downstream adapters where the PCIe topology is extended. This * function returns the corresponding downstream PCIe adapter or %NULL * if no such mapping was possible. */ struct tb_port *usb4_switch_map_pcie_down(struct tb_switch *sw, const struct tb_port *port) { … } /** * usb4_switch_map_usb3_down() - Map USB4 port to a USB3 downstream adapter * @sw: USB4 router * @port: USB4 port * * USB4 routers have direct mapping between USB4 ports and USB 3.x * downstream adapters where the USB 3.x topology is extended. This * function returns the corresponding downstream USB 3.x adapter or * %NULL if no such mapping was possible. */ struct tb_port *usb4_switch_map_usb3_down(struct tb_switch *sw, const struct tb_port *port) { … } /** * usb4_switch_add_ports() - Add USB4 ports for this router * @sw: USB4 router * * For USB4 router finds all USB4 ports and registers devices for each. * Can be called to any router. * * Return %0 in case of success and negative errno in case of failure. */ int usb4_switch_add_ports(struct tb_switch *sw) { … } /** * usb4_switch_remove_ports() - Removes USB4 ports from this router * @sw: USB4 router * * Unregisters previously registered USB4 ports. */ void usb4_switch_remove_ports(struct tb_switch *sw) { … } /** * usb4_port_unlock() - Unlock USB4 downstream port * @port: USB4 port to unlock * * Unlocks USB4 downstream port so that the connection manager can * access the router below this port. */ int usb4_port_unlock(struct tb_port *port) { … } /** * usb4_port_hotplug_enable() - Enables hotplug for a port * @port: USB4 port to operate on * * Enables hot plug events on a given port. This is only intended * to be used on lane, DP-IN, and DP-OUT adapters. */ int usb4_port_hotplug_enable(struct tb_port *port) { … } /** * usb4_port_reset() - Issue downstream port reset * @port: USB4 port to reset * * Issues downstream port reset to @port. */ int usb4_port_reset(struct tb_port *port) { … } static int usb4_port_set_configured(struct tb_port *port, bool configured) { … } /** * usb4_port_configure() - Set USB4 port configured * @port: USB4 router * * Sets the USB4 link to be configured for power management purposes. */ int usb4_port_configure(struct tb_port *port) { … } /** * usb4_port_unconfigure() - Set USB4 port unconfigured * @port: USB4 router * * Sets the USB4 link to be unconfigured for power management purposes. */ void usb4_port_unconfigure(struct tb_port *port) { … } static int usb4_set_xdomain_configured(struct tb_port *port, bool configured) { … } /** * usb4_port_configure_xdomain() - Configure port for XDomain * @port: USB4 port connected to another host * @xd: XDomain that is connected to the port * * Marks the USB4 port as being connected to another host and updates * the link type. Returns %0 in success and negative errno in failure. */ int usb4_port_configure_xdomain(struct tb_port *port, struct tb_xdomain *xd) { … } /** * usb4_port_unconfigure_xdomain() - Unconfigure port for XDomain * @port: USB4 port that was connected to another host * * Clears USB4 port from being marked as XDomain. */ void usb4_port_unconfigure_xdomain(struct tb_port *port) { … } static int usb4_port_wait_for_bit(struct tb_port *port, u32 offset, u32 bit, u32 value, int timeout_msec, unsigned long delay_usec) { … } static int usb4_port_read_data(struct tb_port *port, void *data, size_t dwords) { … } static int usb4_port_write_data(struct tb_port *port, const void *data, size_t dwords) { … } /** * usb4_port_sb_read() - Read from sideband register * @port: USB4 port to read * @target: Sideband target * @index: Retimer index if taget is %USB4_SB_TARGET_RETIMER * @reg: Sideband register index * @buf: Buffer where the sideband data is copied * @size: Size of @buf * * Reads data from sideband register @reg and copies it into @buf. * Returns %0 in case of success and negative errno in case of failure. */ int usb4_port_sb_read(struct tb_port *port, enum usb4_sb_target target, u8 index, u8 reg, void *buf, u8 size) { … } /** * usb4_port_sb_write() - Write to sideband register * @port: USB4 port to write * @target: Sideband target * @index: Retimer index if taget is %USB4_SB_TARGET_RETIMER * @reg: Sideband register index * @buf: Data to write * @size: Size of @buf * * Writes @buf to sideband register @reg. Returns %0 in case of success * and negative errno in case of failure. */ int usb4_port_sb_write(struct tb_port *port, enum usb4_sb_target target, u8 index, u8 reg, const void *buf, u8 size) { … } static int usb4_port_sb_opcode_err_to_errno(u32 val) { … } static int usb4_port_sb_op(struct tb_port *port, enum usb4_sb_target target, u8 index, enum usb4_sb_opcode opcode, int timeout_msec) { … } static int usb4_port_set_router_offline(struct tb_port *port, bool offline) { … } /** * usb4_port_router_offline() - Put the USB4 port to offline mode * @port: USB4 port * * This function puts the USB4 port into offline mode. In this mode the * port does not react on hotplug events anymore. This needs to be * called before retimer access is done when the USB4 links is not up. * * Returns %0 in case of success and negative errno if there was an * error. */ int usb4_port_router_offline(struct tb_port *port) { … } /** * usb4_port_router_online() - Put the USB4 port back to online * @port: USB4 port * * Makes the USB4 port functional again. */ int usb4_port_router_online(struct tb_port *port) { … } /** * usb4_port_enumerate_retimers() - Send RT broadcast transaction * @port: USB4 port * * This forces the USB4 port to send broadcast RT transaction which * makes the retimers on the link to assign index to themselves. Returns * %0 in case of success and negative errno if there was an error. */ int usb4_port_enumerate_retimers(struct tb_port *port) { … } /** * usb4_port_clx_supported() - Check if CLx is supported by the link * @port: Port to check for CLx support for * * PORT_CS_18_CPS bit reflects if the link supports CLx including * active cables (if connected on the link). */ bool usb4_port_clx_supported(struct tb_port *port) { … } /** * usb4_port_asym_supported() - If the port supports asymmetric link * @port: USB4 port * * Checks if the port and the cable supports asymmetric link and returns * %true in that case. */ bool usb4_port_asym_supported(struct tb_port *port) { … } /** * usb4_port_asym_set_link_width() - Set link width to asymmetric or symmetric * @port: USB4 port * @width: Asymmetric width to configure * * Sets USB4 port link width to @width. Can be called for widths where * usb4_port_asym_width_supported() returned @true. */ int usb4_port_asym_set_link_width(struct tb_port *port, enum tb_link_width width) { … } /** * usb4_port_asym_start() - Start symmetry change and wait for completion * @port: USB4 port * * Start symmetry change of the link to asymmetric or symmetric * (according to what was previously set in tb_port_set_link_width(). * Wait for completion of the change. * * Returns %0 in case of success, %-ETIMEDOUT if case of timeout or * a negative errno in case of a failure. */ int usb4_port_asym_start(struct tb_port *port) { … } /** * usb4_port_margining_caps() - Read USB4 port marginig capabilities * @port: USB4 port * @target: Sideband target * @index: Retimer index if taget is %USB4_SB_TARGET_RETIMER * @caps: Array with at least two elements to hold the results * * Reads the USB4 port lane margining capabilities into @caps. */ int usb4_port_margining_caps(struct tb_port *port, enum usb4_sb_target target, u8 index, u32 *caps) { … } /** * usb4_port_hw_margin() - Run hardware lane margining on port * @port: USB4 port * @target: Sideband target * @index: Retimer index if taget is %USB4_SB_TARGET_RETIMER * @lanes: Which lanes to run (must match the port capabilities). Can be * %0, %1 or %7. * @ber_level: BER level contour value * @timing: Perform timing margining instead of voltage * @right_high: Use Right/high margin instead of left/low * @results: Array with at least two elements to hold the results * * Runs hardware lane margining on USB4 port and returns the result in * @results. */ int usb4_port_hw_margin(struct tb_port *port, enum usb4_sb_target target, u8 index, unsigned int lanes, unsigned int ber_level, bool timing, bool right_high, u32 *results) { … } /** * usb4_port_sw_margin() - Run software lane margining on port * @port: USB4 port * @target: Sideband target * @index: Retimer index if taget is %USB4_SB_TARGET_RETIMER * @lanes: Which lanes to run (must match the port capabilities). Can be * %0, %1 or %7. * @timing: Perform timing margining instead of voltage * @right_high: Use Right/high margin instead of left/low * @counter: What to do with the error counter * * Runs software lane margining on USB4 port. Read back the error * counters by calling usb4_port_sw_margin_errors(). Returns %0 in * success and negative errno otherwise. */ int usb4_port_sw_margin(struct tb_port *port, enum usb4_sb_target target, u8 index, unsigned int lanes, bool timing, bool right_high, u32 counter) { … } /** * usb4_port_sw_margin_errors() - Read the software margining error counters * @port: USB4 port * @target: Sideband target * @index: Retimer index if taget is %USB4_SB_TARGET_RETIMER * @errors: Error metadata is copied here. * * This reads back the software margining error counters from the port. * Returns %0 in success and negative errno otherwise. */ int usb4_port_sw_margin_errors(struct tb_port *port, enum usb4_sb_target target, u8 index, u32 *errors) { … } static inline int usb4_port_retimer_op(struct tb_port *port, u8 index, enum usb4_sb_opcode opcode, int timeout_msec) { … } /** * usb4_port_retimer_set_inbound_sbtx() - Enable sideband channel transactions * @port: USB4 port * @index: Retimer index * * Enables sideband channel transations on SBTX. Can be used when USB4 * link does not go up, for example if there is no device connected. */ int usb4_port_retimer_set_inbound_sbtx(struct tb_port *port, u8 index) { … } /** * usb4_port_retimer_unset_inbound_sbtx() - Disable sideband channel transactions * @port: USB4 port * @index: Retimer index * * Disables sideband channel transations on SBTX. The reverse of * usb4_port_retimer_set_inbound_sbtx(). */ int usb4_port_retimer_unset_inbound_sbtx(struct tb_port *port, u8 index) { … } /** * usb4_port_retimer_is_last() - Is the retimer last on-board retimer * @port: USB4 port * @index: Retimer index * * If the retimer at @index is last one (connected directly to the * Type-C port) this function returns %1. If it is not returns %0. If * the retimer is not present returns %-ENODEV. Otherwise returns * negative errno. */ int usb4_port_retimer_is_last(struct tb_port *port, u8 index) { … } /** * usb4_port_retimer_is_cable() - Is the retimer cable retimer * @port: USB4 port * @index: Retimer index * * If the retimer at @index is last cable retimer this function returns * %1 and %0 if it is on-board retimer. In case a retimer is not present * at @index returns %-ENODEV. Otherwise returns negative errno. */ int usb4_port_retimer_is_cable(struct tb_port *port, u8 index) { … } /** * usb4_port_retimer_nvm_sector_size() - Read retimer NVM sector size * @port: USB4 port * @index: Retimer index * * Reads NVM sector size (in bytes) of a retimer at @index. This * operation can be used to determine whether the retimer supports NVM * upgrade for example. Returns sector size in bytes or negative errno * in case of error. Specifically returns %-ENODEV if there is no * retimer at @index. */ int usb4_port_retimer_nvm_sector_size(struct tb_port *port, u8 index) { … } /** * usb4_port_retimer_nvm_set_offset() - Set NVM write offset * @port: USB4 port * @index: Retimer index * @address: Start offset * * Exlicitly sets NVM write offset. Normally when writing to NVM this is * done automatically by usb4_port_retimer_nvm_write(). * * Returns %0 in success and negative errno if there was a failure. */ int usb4_port_retimer_nvm_set_offset(struct tb_port *port, u8 index, unsigned int address) { … } struct retimer_info { … }; static int usb4_port_retimer_nvm_write_next_block(void *data, unsigned int dwaddress, const void *buf, size_t dwords) { … } /** * usb4_port_retimer_nvm_write() - Write to retimer NVM * @port: USB4 port * @index: Retimer index * @address: Byte address where to start the write * @buf: Data to write * @size: Size in bytes how much to write * * Writes @size bytes from @buf to the retimer NVM. Used for NVM * upgrade. Returns %0 if the data was written successfully and negative * errno in case of failure. Specifically returns %-ENODEV if there is * no retimer at @index. */ int usb4_port_retimer_nvm_write(struct tb_port *port, u8 index, unsigned int address, const void *buf, size_t size) { … } /** * usb4_port_retimer_nvm_authenticate() - Start retimer NVM upgrade * @port: USB4 port * @index: Retimer index * * After the new NVM image has been written via usb4_port_retimer_nvm_write() * this function can be used to trigger the NVM upgrade process. If * successful the retimer restarts with the new NVM and may not have the * index set so one needs to call usb4_port_enumerate_retimers() to * force index to be assigned. */ int usb4_port_retimer_nvm_authenticate(struct tb_port *port, u8 index) { … } /** * usb4_port_retimer_nvm_authenticate_status() - Read status of NVM upgrade * @port: USB4 port * @index: Retimer index * @status: Raw status code read from metadata * * This can be called after usb4_port_retimer_nvm_authenticate() and * usb4_port_enumerate_retimers() to fetch status of the NVM upgrade. * * Returns %0 if the authentication status was successfully read. The * completion metadata (the result) is then stored into @status. If * reading the status fails, returns negative errno. */ int usb4_port_retimer_nvm_authenticate_status(struct tb_port *port, u8 index, u32 *status) { … } static int usb4_port_retimer_nvm_read_block(void *data, unsigned int dwaddress, void *buf, size_t dwords) { … } /** * usb4_port_retimer_nvm_read() - Read contents of retimer NVM * @port: USB4 port * @index: Retimer index * @address: NVM address (in bytes) to start reading * @buf: Data read from NVM is stored here * @size: Number of bytes to read * * Reads retimer NVM and copies the contents to @buf. Returns %0 if the * read was successful and negative errno in case of failure. * Specifically returns %-ENODEV if there is no retimer at @index. */ int usb4_port_retimer_nvm_read(struct tb_port *port, u8 index, unsigned int address, void *buf, size_t size) { … } static inline unsigned int usb4_usb3_port_max_bandwidth(const struct tb_port *port, unsigned int bw) { … } /** * usb4_usb3_port_max_link_rate() - Maximum support USB3 link rate * @port: USB3 adapter port * * Return maximum supported link rate of a USB3 adapter in Mb/s. * Negative errno in case of error. */ int usb4_usb3_port_max_link_rate(struct tb_port *port) { … } static int usb4_usb3_port_cm_request(struct tb_port *port, bool request) { … } static inline int usb4_usb3_port_set_cm_request(struct tb_port *port) { … } static inline int usb4_usb3_port_clear_cm_request(struct tb_port *port) { … } static unsigned int usb3_bw_to_mbps(u32 bw, u8 scale) { … } static u32 mbps_to_usb3_bw(unsigned int mbps, u8 scale) { … } static int usb4_usb3_port_read_allocated_bandwidth(struct tb_port *port, int *upstream_bw, int *downstream_bw) { … } /** * usb4_usb3_port_allocated_bandwidth() - Bandwidth allocated for USB3 * @port: USB3 adapter port * @upstream_bw: Allocated upstream bandwidth is stored here * @downstream_bw: Allocated downstream bandwidth is stored here * * Stores currently allocated USB3 bandwidth into @upstream_bw and * @downstream_bw in Mb/s. Returns %0 in case of success and negative * errno in failure. */ int usb4_usb3_port_allocated_bandwidth(struct tb_port *port, int *upstream_bw, int *downstream_bw) { … } static int usb4_usb3_port_read_consumed_bandwidth(struct tb_port *port, int *upstream_bw, int *downstream_bw) { … } static int usb4_usb3_port_write_allocated_bandwidth(struct tb_port *port, int upstream_bw, int downstream_bw) { … } /** * usb4_usb3_port_allocate_bandwidth() - Allocate bandwidth for USB3 * @port: USB3 adapter port * @upstream_bw: New upstream bandwidth * @downstream_bw: New downstream bandwidth * * This can be used to set how much bandwidth is allocated for the USB3 * tunneled isochronous traffic. @upstream_bw and @downstream_bw are the * new values programmed to the USB3 adapter allocation registers. If * the values are lower than what is currently consumed the allocation * is set to what is currently consumed instead (consumed bandwidth * cannot be taken away by CM). The actual new values are returned in * @upstream_bw and @downstream_bw. * * Returns %0 in case of success and negative errno if there was a * failure. */ int usb4_usb3_port_allocate_bandwidth(struct tb_port *port, int *upstream_bw, int *downstream_bw) { … } /** * usb4_usb3_port_release_bandwidth() - Release allocated USB3 bandwidth * @port: USB3 adapter port * @upstream_bw: New allocated upstream bandwidth * @downstream_bw: New allocated downstream bandwidth * * Releases USB3 allocated bandwidth down to what is actually consumed. * The new bandwidth is returned in @upstream_bw and @downstream_bw. * * Returns 0% in success and negative errno in case of failure. */ int usb4_usb3_port_release_bandwidth(struct tb_port *port, int *upstream_bw, int *downstream_bw) { … } static bool is_usb4_dpin(const struct tb_port *port) { … } /** * usb4_dp_port_set_cm_id() - Assign CM ID to the DP IN adapter * @port: DP IN adapter * @cm_id: CM ID to assign * * Sets CM ID for the @port. Returns %0 on success and negative errno * otherwise. Speficially returns %-EOPNOTSUPP if the @port does not * support this. */ int usb4_dp_port_set_cm_id(struct tb_port *port, int cm_id) { … } /** * usb4_dp_port_bandwidth_mode_supported() - Is the bandwidth allocation mode * supported * @port: DP IN adapter to check * * Can be called to any DP IN adapter. Returns true if the adapter * supports USB4 bandwidth allocation mode, false otherwise. */ bool usb4_dp_port_bandwidth_mode_supported(struct tb_port *port) { … } /** * usb4_dp_port_bandwidth_mode_enabled() - Is the bandwidth allocation mode * enabled * @port: DP IN adapter to check * * Can be called to any DP IN adapter. Returns true if the bandwidth * allocation mode has been enabled, false otherwise. */ bool usb4_dp_port_bandwidth_mode_enabled(struct tb_port *port) { … } /** * usb4_dp_port_set_cm_bandwidth_mode_supported() - Set/clear CM support for * bandwidth allocation mode * @port: DP IN adapter * @supported: Does the CM support bandwidth allocation mode * * Can be called to any DP IN adapter. Sets or clears the CM support bit * of the DP IN adapter. Returns %0 in success and negative errno * otherwise. Specifically returns %-OPNOTSUPP if the passed in adapter * does not support this. */ int usb4_dp_port_set_cm_bandwidth_mode_supported(struct tb_port *port, bool supported) { … } /** * usb4_dp_port_group_id() - Return Group ID assigned for the adapter * @port: DP IN adapter * * Reads bandwidth allocation Group ID from the DP IN adapter and * returns it. If the adapter does not support setting Group_ID * %-EOPNOTSUPP is returned. */ int usb4_dp_port_group_id(struct tb_port *port) { … } /** * usb4_dp_port_set_group_id() - Set adapter Group ID * @port: DP IN adapter * @group_id: Group ID for the adapter * * Sets bandwidth allocation mode Group ID for the DP IN adapter. * Returns %0 in case of success and negative errno otherwise. * Specifically returns %-EOPNOTSUPP if the adapter does not support * this. */ int usb4_dp_port_set_group_id(struct tb_port *port, int group_id) { … } /** * usb4_dp_port_nrd() - Read non-reduced rate and lanes * @port: DP IN adapter * @rate: Non-reduced rate in Mb/s is placed here * @lanes: Non-reduced lanes are placed here * * Reads the non-reduced rate and lanes from the DP IN adapter. Returns * %0 in success and negative errno otherwise. Specifically returns * %-EOPNOTSUPP if the adapter does not support this. */ int usb4_dp_port_nrd(struct tb_port *port, int *rate, int *lanes) { … } /** * usb4_dp_port_set_nrd() - Set non-reduced rate and lanes * @port: DP IN adapter * @rate: Non-reduced rate in Mb/s * @lanes: Non-reduced lanes * * Before the capabilities reduction this function can be used to set * the non-reduced values for the DP IN adapter. Returns %0 in success * and negative errno otherwise. If the adapter does not support this * %-EOPNOTSUPP is returned. */ int usb4_dp_port_set_nrd(struct tb_port *port, int rate, int lanes) { … } /** * usb4_dp_port_granularity() - Return granularity for the bandwidth values * @port: DP IN adapter * * Reads the programmed granularity from @port. If the DP IN adapter does * not support bandwidth allocation mode returns %-EOPNOTSUPP and negative * errno in other error cases. */ int usb4_dp_port_granularity(struct tb_port *port) { … } /** * usb4_dp_port_set_granularity() - Set granularity for the bandwidth values * @port: DP IN adapter * @granularity: Granularity in Mb/s. Supported values: 1000, 500 and 250. * * Sets the granularity used with the estimated, allocated and requested * bandwidth. Returns %0 in success and negative errno otherwise. If the * adapter does not support this %-EOPNOTSUPP is returned. */ int usb4_dp_port_set_granularity(struct tb_port *port, int granularity) { … } /** * usb4_dp_port_set_estimated_bandwidth() - Set estimated bandwidth * @port: DP IN adapter * @bw: Estimated bandwidth in Mb/s. * * Sets the estimated bandwidth to @bw. Set the granularity by calling * usb4_dp_port_set_granularity() before calling this. The @bw is round * down to the closest granularity multiplier. Returns %0 in success * and negative errno otherwise. Specifically returns %-EOPNOTSUPP if * the adapter does not support this. */ int usb4_dp_port_set_estimated_bandwidth(struct tb_port *port, int bw) { … } /** * usb4_dp_port_allocated_bandwidth() - Return allocated bandwidth * @port: DP IN adapter * * Reads and returns allocated bandwidth for @port in Mb/s (taking into * account the programmed granularity). Returns negative errno in case * of error. */ int usb4_dp_port_allocated_bandwidth(struct tb_port *port) { … } static int __usb4_dp_port_set_cm_ack(struct tb_port *port, bool ack) { … } static inline int usb4_dp_port_set_cm_ack(struct tb_port *port) { … } static int usb4_dp_port_wait_and_clear_cm_ack(struct tb_port *port, int timeout_msec) { … } /** * usb4_dp_port_allocate_bandwidth() - Set allocated bandwidth * @port: DP IN adapter * @bw: New allocated bandwidth in Mb/s * * Communicates the new allocated bandwidth with the DPCD (graphics * driver). Takes into account the programmed granularity. Returns %0 in * success and negative errno in case of error. */ int usb4_dp_port_allocate_bandwidth(struct tb_port *port, int bw) { … } /** * usb4_dp_port_requested_bandwidth() - Read requested bandwidth * @port: DP IN adapter * * Reads the DPCD (graphics driver) requested bandwidth and returns it * in Mb/s. Takes the programmed granularity into account. In case of * error returns negative errno. Specifically returns %-EOPNOTSUPP if * the adapter does not support bandwidth allocation mode, and %ENODATA * if there is no active bandwidth request from the graphics driver. */ int usb4_dp_port_requested_bandwidth(struct tb_port *port) { … } /** * usb4_pci_port_set_ext_encapsulation() - Enable/disable extended encapsulation * @port: PCIe adapter * @enable: Enable/disable extended encapsulation * * Enables or disables extended encapsulation used in PCIe tunneling. Caller * needs to make sure both adapters support this before enabling. Returns %0 on * success and negative errno otherwise. */ int usb4_pci_port_set_ext_encapsulation(struct tb_port *port, bool enable) { … }
Codebase Browser
linux