1 // SPDX-License-Identifier: GPL-2.0
3 * USB4 specific functionality
5 * Copyright (C) 2019, Intel Corporation
6 * Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
7 * Rajmohan Mani <rajmohan.mani@intel.com>
10 #include <linux/delay.h>
11 #include <linux/ktime.h>
16 #define USB4_DATA_DWORDS 16
17 #define USB4_DATA_RETRIES 3
20 USB4_SWITCH_OP_QUERY_DP_RESOURCE
= 0x10,
21 USB4_SWITCH_OP_ALLOC_DP_RESOURCE
= 0x11,
22 USB4_SWITCH_OP_DEALLOC_DP_RESOURCE
= 0x12,
23 USB4_SWITCH_OP_NVM_WRITE
= 0x20,
24 USB4_SWITCH_OP_NVM_AUTH
= 0x21,
25 USB4_SWITCH_OP_NVM_READ
= 0x22,
26 USB4_SWITCH_OP_NVM_SET_OFFSET
= 0x23,
27 USB4_SWITCH_OP_DROM_READ
= 0x24,
28 USB4_SWITCH_OP_NVM_SECTOR_SIZE
= 0x25,
32 USB4_SB_TARGET_ROUTER
,
33 USB4_SB_TARGET_PARTNER
,
34 USB4_SB_TARGET_RETIMER
,
37 #define USB4_NVM_READ_OFFSET_MASK GENMASK(23, 2)
38 #define USB4_NVM_READ_OFFSET_SHIFT 2
39 #define USB4_NVM_READ_LENGTH_MASK GENMASK(27, 24)
40 #define USB4_NVM_READ_LENGTH_SHIFT 24
42 #define USB4_NVM_SET_OFFSET_MASK USB4_NVM_READ_OFFSET_MASK
43 #define USB4_NVM_SET_OFFSET_SHIFT USB4_NVM_READ_OFFSET_SHIFT
45 #define USB4_DROM_ADDRESS_MASK GENMASK(14, 2)
46 #define USB4_DROM_ADDRESS_SHIFT 2
47 #define USB4_DROM_SIZE_MASK GENMASK(19, 15)
48 #define USB4_DROM_SIZE_SHIFT 15
50 #define USB4_NVM_SECTOR_SIZE_MASK GENMASK(23, 0)
52 typedef int (*read_block_fn
)(void *, unsigned int, void *, size_t);
53 typedef int (*write_block_fn
)(void *, const void *, size_t);
55 static int usb4_switch_wait_for_bit(struct tb_switch
*sw
, u32 offset
, u32 bit
,
56 u32 value
, int timeout_msec
)
58 ktime_t timeout
= ktime_add_ms(ktime_get(), timeout_msec
);
64 ret
= tb_sw_read(sw
, &val
, TB_CFG_SWITCH
, offset
, 1);
68 if ((val
& bit
) == value
)
71 usleep_range(50, 100);
72 } while (ktime_before(ktime_get(), timeout
));
77 static int usb4_switch_op_read_data(struct tb_switch
*sw
, void *data
,
80 if (dwords
> USB4_DATA_DWORDS
)
83 return tb_sw_read(sw
, data
, TB_CFG_SWITCH
, ROUTER_CS_9
, dwords
);
86 static int usb4_switch_op_write_data(struct tb_switch
*sw
, const void *data
,
89 if (dwords
> USB4_DATA_DWORDS
)
92 return tb_sw_write(sw
, data
, TB_CFG_SWITCH
, ROUTER_CS_9
, dwords
);
95 static int usb4_switch_op_read_metadata(struct tb_switch
*sw
, u32
*metadata
)
97 return tb_sw_read(sw
, metadata
, TB_CFG_SWITCH
, ROUTER_CS_25
, 1);
100 static int usb4_switch_op_write_metadata(struct tb_switch
*sw
, u32 metadata
)
102 return tb_sw_write(sw
, &metadata
, TB_CFG_SWITCH
, ROUTER_CS_25
, 1);
105 static int usb4_do_read_data(u16 address
, void *buf
, size_t size
,
106 read_block_fn read_block
, void *read_block_data
)
108 unsigned int retries
= USB4_DATA_RETRIES
;
111 offset
= address
& 3;
112 address
= address
& ~3;
115 size_t nbytes
= min_t(size_t, size
, USB4_DATA_DWORDS
* 4);
116 unsigned int dwaddress
, dwords
;
117 u8 data
[USB4_DATA_DWORDS
* 4];
120 dwaddress
= address
/ 4;
121 dwords
= ALIGN(nbytes
, 4) / 4;
123 ret
= read_block(read_block_data
, dwaddress
, data
, dwords
);
125 if (ret
!= -ENODEV
&& retries
--)
130 memcpy(buf
, data
+ offset
, nbytes
);
140 static int usb4_do_write_data(unsigned int address
, const void *buf
, size_t size
,
141 write_block_fn write_next_block
, void *write_block_data
)
143 unsigned int retries
= USB4_DATA_RETRIES
;
146 offset
= address
& 3;
147 address
= address
& ~3;
150 u32 nbytes
= min_t(u32
, size
, USB4_DATA_DWORDS
* 4);
151 u8 data
[USB4_DATA_DWORDS
* 4];
154 memcpy(data
+ offset
, buf
, nbytes
);
156 ret
= write_next_block(write_block_data
, data
, nbytes
/ 4);
158 if (ret
== -ETIMEDOUT
) {
174 static int usb4_switch_op(struct tb_switch
*sw
, u16 opcode
, u8
*status
)
179 val
= opcode
| ROUTER_CS_26_OV
;
180 ret
= tb_sw_write(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_26
, 1);
184 ret
= usb4_switch_wait_for_bit(sw
, ROUTER_CS_26
, ROUTER_CS_26_OV
, 0, 500);
188 ret
= tb_sw_read(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_26
, 1);
192 if (val
& ROUTER_CS_26_ONS
)
196 *status
= (val
& ROUTER_CS_26_STATUS_MASK
) >>
197 ROUTER_CS_26_STATUS_SHIFT
;
201 static void usb4_switch_check_wakes(struct tb_switch
*sw
)
203 struct tb_port
*port
;
207 if (!device_may_wakeup(&sw
->dev
))
211 if (tb_sw_read(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_6
, 1))
214 tb_sw_dbg(sw
, "PCIe wake: %s, USB3 wake: %s\n",
215 (val
& ROUTER_CS_6_WOPS
) ? "yes" : "no",
216 (val
& ROUTER_CS_6_WOUS
) ? "yes" : "no");
218 wakeup
= val
& (ROUTER_CS_6_WOPS
| ROUTER_CS_6_WOUS
);
221 /* Check for any connected downstream ports for USB4 wake */
222 tb_switch_for_each_port(sw
, port
) {
223 if (!tb_port_has_remote(port
))
226 if (tb_port_read(port
, &val
, TB_CFG_PORT
,
227 port
->cap_usb4
+ PORT_CS_18
, 1))
230 tb_port_dbg(port
, "USB4 wake: %s\n",
231 (val
& PORT_CS_18_WOU4S
) ? "yes" : "no");
233 if (val
& PORT_CS_18_WOU4S
)
238 pm_wakeup_event(&sw
->dev
, 0);
241 static bool link_is_usb4(struct tb_port
*port
)
248 if (tb_port_read(port
, &val
, TB_CFG_PORT
,
249 port
->cap_usb4
+ PORT_CS_18
, 1))
252 return !(val
& PORT_CS_18_TCM
);
256 * usb4_switch_setup() - Additional setup for USB4 device
257 * @sw: USB4 router to setup
259 * USB4 routers need additional settings in order to enable all the
260 * tunneling. This function enables USB and PCIe tunneling if it can be
261 * enabled (e.g the parent switch also supports them). If USB tunneling
262 * is not available for some reason (like that there is Thunderbolt 3
263 * switch upstream) then the internal xHCI controller is enabled
266 int usb4_switch_setup(struct tb_switch
*sw
)
268 struct tb_port
*downstream_port
;
269 struct tb_switch
*parent
;
274 usb4_switch_check_wakes(sw
);
279 ret
= tb_sw_read(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_6
, 1);
283 parent
= tb_switch_parent(sw
);
284 downstream_port
= tb_port_at(tb_route(sw
), parent
);
285 sw
->link_usb4
= link_is_usb4(downstream_port
);
286 tb_sw_dbg(sw
, "link: %s\n", sw
->link_usb4
? "USB4" : "TBT3");
288 xhci
= val
& ROUTER_CS_6_HCI
;
289 tbt3
= !(val
& ROUTER_CS_6_TNS
);
291 tb_sw_dbg(sw
, "TBT3 support: %s, xHCI: %s\n",
292 tbt3
? "yes" : "no", xhci
? "yes" : "no");
294 ret
= tb_sw_read(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_5
, 1);
298 if (sw
->link_usb4
&& tb_switch_find_port(parent
, TB_TYPE_USB3_DOWN
)) {
299 val
|= ROUTER_CS_5_UTO
;
303 /* Only enable PCIe tunneling if the parent router supports it */
304 if (tb_switch_find_port(parent
, TB_TYPE_PCIE_DOWN
)) {
305 val
|= ROUTER_CS_5_PTO
;
307 * xHCI can be enabled if PCIe tunneling is supported
308 * and the parent does not have any USB3 dowstream
309 * adapters (so we cannot do USB 3.x tunneling).
312 val
|= ROUTER_CS_5_HCO
;
315 /* TBT3 supported by the CM */
316 val
|= ROUTER_CS_5_C3S
;
317 /* Tunneling configuration is ready now */
318 val
|= ROUTER_CS_5_CV
;
320 ret
= tb_sw_write(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_5
, 1);
324 return usb4_switch_wait_for_bit(sw
, ROUTER_CS_6
, ROUTER_CS_6_CR
,
329 * usb4_switch_read_uid() - Read UID from USB4 router
331 * @uid: UID is stored here
333 * Reads 64-bit UID from USB4 router config space.
335 int usb4_switch_read_uid(struct tb_switch
*sw
, u64
*uid
)
337 return tb_sw_read(sw
, uid
, TB_CFG_SWITCH
, ROUTER_CS_7
, 2);
340 static int usb4_switch_drom_read_block(void *data
,
341 unsigned int dwaddress
, void *buf
,
344 struct tb_switch
*sw
= data
;
349 metadata
= (dwords
<< USB4_DROM_SIZE_SHIFT
) & USB4_DROM_SIZE_MASK
;
350 metadata
|= (dwaddress
<< USB4_DROM_ADDRESS_SHIFT
) &
351 USB4_DROM_ADDRESS_MASK
;
353 ret
= usb4_switch_op_write_metadata(sw
, metadata
);
357 ret
= usb4_switch_op(sw
, USB4_SWITCH_OP_DROM_READ
, &status
);
364 return usb4_switch_op_read_data(sw
, buf
, dwords
);
368 * usb4_switch_drom_read() - Read arbitrary bytes from USB4 router DROM
370 * @address: Byte address inside DROM to start reading
371 * @buf: Buffer where the DROM content is stored
372 * @size: Number of bytes to read from DROM
374 * Uses USB4 router operations to read router DROM. For devices this
375 * should always work but for hosts it may return %-EOPNOTSUPP in which
376 * case the host router does not have DROM.
378 int usb4_switch_drom_read(struct tb_switch
*sw
, unsigned int address
, void *buf
,
381 return usb4_do_read_data(address
, buf
, size
,
382 usb4_switch_drom_read_block
, sw
);
386 * usb4_switch_lane_bonding_possible() - Are conditions met for lane bonding
389 * Checks whether conditions are met so that lane bonding can be
390 * established with the upstream router. Call only for device routers.
392 bool usb4_switch_lane_bonding_possible(struct tb_switch
*sw
)
398 up
= tb_upstream_port(sw
);
399 ret
= tb_port_read(up
, &val
, TB_CFG_PORT
, up
->cap_usb4
+ PORT_CS_18
, 1);
403 return !!(val
& PORT_CS_18_BE
);
407 * usb4_switch_set_wake() - Enabled/disable wake
409 * @flags: Wakeup flags (%0 to disable)
411 * Enables/disables router to wake up from sleep.
413 int usb4_switch_set_wake(struct tb_switch
*sw
, unsigned int flags
)
415 struct tb_port
*port
;
416 u64 route
= tb_route(sw
);
421 * Enable wakes coming from all USB4 downstream ports (from
422 * child routers). For device routers do this also for the
423 * upstream USB4 port.
425 tb_switch_for_each_port(sw
, port
) {
426 if (!tb_port_is_null(port
))
428 if (!route
&& tb_is_upstream_port(port
))
433 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
434 port
->cap_usb4
+ PORT_CS_19
, 1);
438 val
&= ~(PORT_CS_19_WOC
| PORT_CS_19_WOD
| PORT_CS_19_WOU4
);
440 if (flags
& TB_WAKE_ON_CONNECT
)
441 val
|= PORT_CS_19_WOC
;
442 if (flags
& TB_WAKE_ON_DISCONNECT
)
443 val
|= PORT_CS_19_WOD
;
444 if (flags
& TB_WAKE_ON_USB4
)
445 val
|= PORT_CS_19_WOU4
;
447 ret
= tb_port_write(port
, &val
, TB_CFG_PORT
,
448 port
->cap_usb4
+ PORT_CS_19
, 1);
454 * Enable wakes from PCIe and USB 3.x on this router. Only
455 * needed for device routers.
458 ret
= tb_sw_read(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_5
, 1);
462 val
&= ~(ROUTER_CS_5_WOP
| ROUTER_CS_5_WOU
);
463 if (flags
& TB_WAKE_ON_USB3
)
464 val
|= ROUTER_CS_5_WOU
;
465 if (flags
& TB_WAKE_ON_PCIE
)
466 val
|= ROUTER_CS_5_WOP
;
468 ret
= tb_sw_write(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_5
, 1);
477 * usb4_switch_set_sleep() - Prepare the router to enter sleep
480 * Sets sleep bit for the router. Returns when the router sleep ready
481 * bit has been asserted.
483 int usb4_switch_set_sleep(struct tb_switch
*sw
)
488 /* Set sleep bit and wait for sleep ready to be asserted */
489 ret
= tb_sw_read(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_5
, 1);
493 val
|= ROUTER_CS_5_SLP
;
495 ret
= tb_sw_write(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_5
, 1);
499 return usb4_switch_wait_for_bit(sw
, ROUTER_CS_6
, ROUTER_CS_6_SLPR
,
500 ROUTER_CS_6_SLPR
, 500);
504 * usb4_switch_nvm_sector_size() - Return router NVM sector size
507 * If the router supports NVM operations this function returns the NVM
508 * sector size in bytes. If NVM operations are not supported returns
511 int usb4_switch_nvm_sector_size(struct tb_switch
*sw
)
517 ret
= usb4_switch_op(sw
, USB4_SWITCH_OP_NVM_SECTOR_SIZE
, &status
);
522 return status
== 0x2 ? -EOPNOTSUPP
: -EIO
;
524 ret
= usb4_switch_op_read_metadata(sw
, &metadata
);
528 return metadata
& USB4_NVM_SECTOR_SIZE_MASK
;
531 static int usb4_switch_nvm_read_block(void *data
,
532 unsigned int dwaddress
, void *buf
, size_t dwords
)
534 struct tb_switch
*sw
= data
;
539 metadata
= (dwords
<< USB4_NVM_READ_LENGTH_SHIFT
) &
540 USB4_NVM_READ_LENGTH_MASK
;
541 metadata
|= (dwaddress
<< USB4_NVM_READ_OFFSET_SHIFT
) &
542 USB4_NVM_READ_OFFSET_MASK
;
544 ret
= usb4_switch_op_write_metadata(sw
, metadata
);
548 ret
= usb4_switch_op(sw
, USB4_SWITCH_OP_NVM_READ
, &status
);
555 return usb4_switch_op_read_data(sw
, buf
, dwords
);
559 * usb4_switch_nvm_read() - Read arbitrary bytes from router NVM
561 * @address: Starting address in bytes
562 * @buf: Read data is placed here
563 * @size: How many bytes to read
565 * Reads NVM contents of the router. If NVM is not supported returns
568 int usb4_switch_nvm_read(struct tb_switch
*sw
, unsigned int address
, void *buf
,
571 return usb4_do_read_data(address
, buf
, size
,
572 usb4_switch_nvm_read_block
, sw
);
575 static int usb4_switch_nvm_set_offset(struct tb_switch
*sw
,
576 unsigned int address
)
578 u32 metadata
, dwaddress
;
582 dwaddress
= address
/ 4;
583 metadata
= (dwaddress
<< USB4_NVM_SET_OFFSET_SHIFT
) &
584 USB4_NVM_SET_OFFSET_MASK
;
586 ret
= usb4_switch_op_write_metadata(sw
, metadata
);
590 ret
= usb4_switch_op(sw
, USB4_SWITCH_OP_NVM_SET_OFFSET
, &status
);
594 return status
? -EIO
: 0;
597 static int usb4_switch_nvm_write_next_block(void *data
, const void *buf
,
600 struct tb_switch
*sw
= data
;
604 ret
= usb4_switch_op_write_data(sw
, buf
, dwords
);
608 ret
= usb4_switch_op(sw
, USB4_SWITCH_OP_NVM_WRITE
, &status
);
612 return status
? -EIO
: 0;
616 * usb4_switch_nvm_write() - Write to the router NVM
618 * @address: Start address where to write in bytes
619 * @buf: Pointer to the data to write
620 * @size: Size of @buf in bytes
622 * Writes @buf to the router NVM using USB4 router operations. If NVM
623 * write is not supported returns %-EOPNOTSUPP.
625 int usb4_switch_nvm_write(struct tb_switch
*sw
, unsigned int address
,
626 const void *buf
, size_t size
)
630 ret
= usb4_switch_nvm_set_offset(sw
, address
);
634 return usb4_do_write_data(address
, buf
, size
,
635 usb4_switch_nvm_write_next_block
, sw
);
639 * usb4_switch_nvm_authenticate() - Authenticate new NVM
642 * After the new NVM has been written via usb4_switch_nvm_write(), this
643 * function triggers NVM authentication process. The router gets power
644 * cycled and if the authentication is successful the new NVM starts
645 * running. In case of failure returns negative errno.
647 * The caller should call usb4_switch_nvm_authenticate_status() to read
648 * the status of the authentication after power cycle. It should be the
649 * first router operation to avoid the status being lost.
651 int usb4_switch_nvm_authenticate(struct tb_switch
*sw
)
655 ret
= usb4_switch_op(sw
, USB4_SWITCH_OP_NVM_AUTH
, NULL
);
658 * The router is power cycled once NVM_AUTH is started so it is
659 * expected to get any of the following errors back.
672 * usb4_switch_nvm_authenticate_status() - Read status of last NVM authenticate
674 * @status: Status code of the operation
676 * The function checks if there is status available from the last NVM
677 * authenticate router operation. If there is status then %0 is returned
678 * and the status code is placed in @status. Returns negative errno in case
681 * Must be called before any other router operation.
683 int usb4_switch_nvm_authenticate_status(struct tb_switch
*sw
, u32
*status
)
689 ret
= tb_sw_read(sw
, &val
, TB_CFG_SWITCH
, ROUTER_CS_26
, 1);
693 /* Check that the opcode is correct */
694 opcode
= val
& ROUTER_CS_26_OPCODE_MASK
;
695 if (opcode
== USB4_SWITCH_OP_NVM_AUTH
) {
696 if (val
& ROUTER_CS_26_OV
)
698 if (val
& ROUTER_CS_26_ONS
)
701 *status
= (val
& ROUTER_CS_26_STATUS_MASK
) >>
702 ROUTER_CS_26_STATUS_SHIFT
;
711 * usb4_switch_query_dp_resource() - Query availability of DP IN resource
715 * For DP tunneling this function can be used to query availability of
716 * DP IN resource. Returns true if the resource is available for DP
717 * tunneling, false otherwise.
719 bool usb4_switch_query_dp_resource(struct tb_switch
*sw
, struct tb_port
*in
)
724 ret
= usb4_switch_op_write_metadata(sw
, in
->port
);
728 ret
= usb4_switch_op(sw
, USB4_SWITCH_OP_QUERY_DP_RESOURCE
, &status
);
730 * If DP resource allocation is not supported assume it is
733 if (ret
== -EOPNOTSUPP
)
742 * usb4_switch_alloc_dp_resource() - Allocate DP IN resource
746 * Allocates DP IN resource for DP tunneling using USB4 router
747 * operations. If the resource was allocated returns %0. Otherwise
748 * returns negative errno, in particular %-EBUSY if the resource is
751 int usb4_switch_alloc_dp_resource(struct tb_switch
*sw
, struct tb_port
*in
)
756 ret
= usb4_switch_op_write_metadata(sw
, in
->port
);
760 ret
= usb4_switch_op(sw
, USB4_SWITCH_OP_ALLOC_DP_RESOURCE
, &status
);
761 if (ret
== -EOPNOTSUPP
)
766 return status
? -EBUSY
: 0;
770 * usb4_switch_dealloc_dp_resource() - Releases allocated DP IN resource
774 * Releases the previously allocated DP IN resource.
776 int usb4_switch_dealloc_dp_resource(struct tb_switch
*sw
, struct tb_port
*in
)
781 ret
= usb4_switch_op_write_metadata(sw
, in
->port
);
785 ret
= usb4_switch_op(sw
, USB4_SWITCH_OP_DEALLOC_DP_RESOURCE
, &status
);
786 if (ret
== -EOPNOTSUPP
)
791 return status
? -EIO
: 0;
794 static int usb4_port_idx(const struct tb_switch
*sw
, const struct tb_port
*port
)
799 /* Assume port is primary */
800 tb_switch_for_each_port(sw
, p
) {
801 if (!tb_port_is_null(p
))
803 if (tb_is_upstream_port(p
))
816 * usb4_switch_map_pcie_down() - Map USB4 port to a PCIe downstream adapter
820 * USB4 routers have direct mapping between USB4 ports and PCIe
821 * downstream adapters where the PCIe topology is extended. This
822 * function returns the corresponding downstream PCIe adapter or %NULL
823 * if no such mapping was possible.
825 struct tb_port
*usb4_switch_map_pcie_down(struct tb_switch
*sw
,
826 const struct tb_port
*port
)
828 int usb4_idx
= usb4_port_idx(sw
, port
);
832 /* Find PCIe down port matching usb4_port */
833 tb_switch_for_each_port(sw
, p
) {
834 if (!tb_port_is_pcie_down(p
))
837 if (pcie_idx
== usb4_idx
)
847 * usb4_switch_map_usb3_down() - Map USB4 port to a USB3 downstream adapter
851 * USB4 routers have direct mapping between USB4 ports and USB 3.x
852 * downstream adapters where the USB 3.x topology is extended. This
853 * function returns the corresponding downstream USB 3.x adapter or
854 * %NULL if no such mapping was possible.
856 struct tb_port
*usb4_switch_map_usb3_down(struct tb_switch
*sw
,
857 const struct tb_port
*port
)
859 int usb4_idx
= usb4_port_idx(sw
, port
);
863 /* Find USB3 down port matching usb4_port */
864 tb_switch_for_each_port(sw
, p
) {
865 if (!tb_port_is_usb3_down(p
))
868 if (usb_idx
== usb4_idx
)
878 * usb4_port_unlock() - Unlock USB4 downstream port
879 * @port: USB4 port to unlock
881 * Unlocks USB4 downstream port so that the connection manager can
882 * access the router below this port.
884 int usb4_port_unlock(struct tb_port
*port
)
889 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
, ADP_CS_4
, 1);
893 val
&= ~ADP_CS_4_LCK
;
894 return tb_port_write(port
, &val
, TB_CFG_PORT
, ADP_CS_4
, 1);
897 static int usb4_port_set_configured(struct tb_port
*port
, bool configured
)
905 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
906 port
->cap_usb4
+ PORT_CS_19
, 1);
911 val
|= PORT_CS_19_PC
;
913 val
&= ~PORT_CS_19_PC
;
915 return tb_port_write(port
, &val
, TB_CFG_PORT
,
916 port
->cap_usb4
+ PORT_CS_19
, 1);
920 * usb4_port_configure() - Set USB4 port configured
923 * Sets the USB4 link to be configured for power management purposes.
925 int usb4_port_configure(struct tb_port
*port
)
927 return usb4_port_set_configured(port
, true);
931 * usb4_port_unconfigure() - Set USB4 port unconfigured
934 * Sets the USB4 link to be unconfigured for power management purposes.
936 void usb4_port_unconfigure(struct tb_port
*port
)
938 usb4_port_set_configured(port
, false);
941 static int usb4_set_xdomain_configured(struct tb_port
*port
, bool configured
)
949 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
950 port
->cap_usb4
+ PORT_CS_19
, 1);
955 val
|= PORT_CS_19_PID
;
957 val
&= ~PORT_CS_19_PID
;
959 return tb_port_write(port
, &val
, TB_CFG_PORT
,
960 port
->cap_usb4
+ PORT_CS_19
, 1);
964 * usb4_port_configure_xdomain() - Configure port for XDomain
965 * @port: USB4 port connected to another host
967 * Marks the USB4 port as being connected to another host. Returns %0 in
968 * success and negative errno in failure.
970 int usb4_port_configure_xdomain(struct tb_port
*port
)
972 return usb4_set_xdomain_configured(port
, true);
976 * usb4_port_unconfigure_xdomain() - Unconfigure port for XDomain
977 * @port: USB4 port that was connected to another host
979 * Clears USB4 port from being marked as XDomain.
981 void usb4_port_unconfigure_xdomain(struct tb_port
*port
)
983 usb4_set_xdomain_configured(port
, false);
986 static int usb4_port_wait_for_bit(struct tb_port
*port
, u32 offset
, u32 bit
,
987 u32 value
, int timeout_msec
)
989 ktime_t timeout
= ktime_add_ms(ktime_get(), timeout_msec
);
995 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
, offset
, 1);
999 if ((val
& bit
) == value
)
1002 usleep_range(50, 100);
1003 } while (ktime_before(ktime_get(), timeout
));
1008 static int usb4_port_read_data(struct tb_port
*port
, void *data
, size_t dwords
)
1010 if (dwords
> USB4_DATA_DWORDS
)
1013 return tb_port_read(port
, data
, TB_CFG_PORT
, port
->cap_usb4
+ PORT_CS_2
,
1017 static int usb4_port_write_data(struct tb_port
*port
, const void *data
,
1020 if (dwords
> USB4_DATA_DWORDS
)
1023 return tb_port_write(port
, data
, TB_CFG_PORT
, port
->cap_usb4
+ PORT_CS_2
,
1027 static int usb4_port_sb_read(struct tb_port
*port
, enum usb4_sb_target target
,
1028 u8 index
, u8 reg
, void *buf
, u8 size
)
1030 size_t dwords
= DIV_ROUND_UP(size
, 4);
1034 if (!port
->cap_usb4
)
1038 val
|= size
<< PORT_CS_1_LENGTH_SHIFT
;
1039 val
|= (target
<< PORT_CS_1_TARGET_SHIFT
) & PORT_CS_1_TARGET_MASK
;
1040 if (target
== USB4_SB_TARGET_RETIMER
)
1041 val
|= (index
<< PORT_CS_1_RETIMER_INDEX_SHIFT
);
1042 val
|= PORT_CS_1_PND
;
1044 ret
= tb_port_write(port
, &val
, TB_CFG_PORT
,
1045 port
->cap_usb4
+ PORT_CS_1
, 1);
1049 ret
= usb4_port_wait_for_bit(port
, port
->cap_usb4
+ PORT_CS_1
,
1050 PORT_CS_1_PND
, 0, 500);
1054 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
1055 port
->cap_usb4
+ PORT_CS_1
, 1);
1059 if (val
& PORT_CS_1_NR
)
1061 if (val
& PORT_CS_1_RC
)
1064 return buf
? usb4_port_read_data(port
, buf
, dwords
) : 0;
1067 static int usb4_port_sb_write(struct tb_port
*port
, enum usb4_sb_target target
,
1068 u8 index
, u8 reg
, const void *buf
, u8 size
)
1070 size_t dwords
= DIV_ROUND_UP(size
, 4);
1074 if (!port
->cap_usb4
)
1078 ret
= usb4_port_write_data(port
, buf
, dwords
);
1084 val
|= size
<< PORT_CS_1_LENGTH_SHIFT
;
1085 val
|= PORT_CS_1_WNR_WRITE
;
1086 val
|= (target
<< PORT_CS_1_TARGET_SHIFT
) & PORT_CS_1_TARGET_MASK
;
1087 if (target
== USB4_SB_TARGET_RETIMER
)
1088 val
|= (index
<< PORT_CS_1_RETIMER_INDEX_SHIFT
);
1089 val
|= PORT_CS_1_PND
;
1091 ret
= tb_port_write(port
, &val
, TB_CFG_PORT
,
1092 port
->cap_usb4
+ PORT_CS_1
, 1);
1096 ret
= usb4_port_wait_for_bit(port
, port
->cap_usb4
+ PORT_CS_1
,
1097 PORT_CS_1_PND
, 0, 500);
1101 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
1102 port
->cap_usb4
+ PORT_CS_1
, 1);
1106 if (val
& PORT_CS_1_NR
)
1108 if (val
& PORT_CS_1_RC
)
1114 static int usb4_port_sb_op(struct tb_port
*port
, enum usb4_sb_target target
,
1115 u8 index
, enum usb4_sb_opcode opcode
, int timeout_msec
)
1122 ret
= usb4_port_sb_write(port
, target
, index
, USB4_SB_OPCODE
, &val
,
1127 timeout
= ktime_add_ms(ktime_get(), timeout_msec
);
1131 ret
= usb4_port_sb_read(port
, target
, index
, USB4_SB_OPCODE
,
1140 case USB4_SB_OPCODE_ERR
:
1143 case USB4_SB_OPCODE_ONS
:
1151 } while (ktime_before(ktime_get(), timeout
));
1157 * usb4_port_enumerate_retimers() - Send RT broadcast transaction
1160 * This forces the USB4 port to send broadcast RT transaction which
1161 * makes the retimers on the link to assign index to themselves. Returns
1162 * %0 in case of success and negative errno if there was an error.
1164 int usb4_port_enumerate_retimers(struct tb_port
*port
)
1168 val
= USB4_SB_OPCODE_ENUMERATE_RETIMERS
;
1169 return usb4_port_sb_write(port
, USB4_SB_TARGET_ROUTER
, 0,
1170 USB4_SB_OPCODE
, &val
, sizeof(val
));
1173 static inline int usb4_port_retimer_op(struct tb_port
*port
, u8 index
,
1174 enum usb4_sb_opcode opcode
,
1177 return usb4_port_sb_op(port
, USB4_SB_TARGET_RETIMER
, index
, opcode
,
1182 * usb4_port_retimer_read() - Read from retimer sideband registers
1184 * @index: Retimer index
1185 * @reg: Sideband register to read
1186 * @buf: Data from @reg is stored here
1187 * @size: Number of bytes to read
1189 * Function reads retimer sideband registers starting from @reg. The
1190 * retimer is connected to @port at @index. Returns %0 in case of
1191 * success, and read data is copied to @buf. If there is no retimer
1192 * present at given @index returns %-ENODEV. In any other failure
1193 * returns negative errno.
1195 int usb4_port_retimer_read(struct tb_port
*port
, u8 index
, u8 reg
, void *buf
,
1198 return usb4_port_sb_read(port
, USB4_SB_TARGET_RETIMER
, index
, reg
, buf
,
1203 * usb4_port_retimer_write() - Write to retimer sideband registers
1205 * @index: Retimer index
1206 * @reg: Sideband register to write
1207 * @buf: Data that is written starting from @reg
1208 * @size: Number of bytes to write
1210 * Writes retimer sideband registers starting from @reg. The retimer is
1211 * connected to @port at @index. Returns %0 in case of success. If there
1212 * is no retimer present at given @index returns %-ENODEV. In any other
1213 * failure returns negative errno.
1215 int usb4_port_retimer_write(struct tb_port
*port
, u8 index
, u8 reg
,
1216 const void *buf
, u8 size
)
1218 return usb4_port_sb_write(port
, USB4_SB_TARGET_RETIMER
, index
, reg
, buf
,
1223 * usb4_port_retimer_is_last() - Is the retimer last on-board retimer
1225 * @index: Retimer index
1227 * If the retimer at @index is last one (connected directly to the
1228 * Type-C port) this function returns %1. If it is not returns %0. If
1229 * the retimer is not present returns %-ENODEV. Otherwise returns
1232 int usb4_port_retimer_is_last(struct tb_port
*port
, u8 index
)
1237 ret
= usb4_port_retimer_op(port
, index
, USB4_SB_OPCODE_QUERY_LAST_RETIMER
,
1242 ret
= usb4_port_retimer_read(port
, index
, USB4_SB_METADATA
, &metadata
,
1244 return ret
? ret
: metadata
& 1;
1248 * usb4_port_retimer_nvm_sector_size() - Read retimer NVM sector size
1250 * @index: Retimer index
1252 * Reads NVM sector size (in bytes) of a retimer at @index. This
1253 * operation can be used to determine whether the retimer supports NVM
1254 * upgrade for example. Returns sector size in bytes or negative errno
1255 * in case of error. Specifically returns %-ENODEV if there is no
1256 * retimer at @index.
1258 int usb4_port_retimer_nvm_sector_size(struct tb_port
*port
, u8 index
)
1263 ret
= usb4_port_retimer_op(port
, index
, USB4_SB_OPCODE_GET_NVM_SECTOR_SIZE
,
1268 ret
= usb4_port_retimer_read(port
, index
, USB4_SB_METADATA
, &metadata
,
1270 return ret
? ret
: metadata
& USB4_NVM_SECTOR_SIZE_MASK
;
1273 static int usb4_port_retimer_nvm_set_offset(struct tb_port
*port
, u8 index
,
1274 unsigned int address
)
1276 u32 metadata
, dwaddress
;
1279 dwaddress
= address
/ 4;
1280 metadata
= (dwaddress
<< USB4_NVM_SET_OFFSET_SHIFT
) &
1281 USB4_NVM_SET_OFFSET_MASK
;
1283 ret
= usb4_port_retimer_write(port
, index
, USB4_SB_METADATA
, &metadata
,
1288 return usb4_port_retimer_op(port
, index
, USB4_SB_OPCODE_NVM_SET_OFFSET
,
1292 struct retimer_info
{
1293 struct tb_port
*port
;
1297 static int usb4_port_retimer_nvm_write_next_block(void *data
, const void *buf
,
1301 const struct retimer_info
*info
= data
;
1302 struct tb_port
*port
= info
->port
;
1303 u8 index
= info
->index
;
1306 ret
= usb4_port_retimer_write(port
, index
, USB4_SB_DATA
,
1311 return usb4_port_retimer_op(port
, index
,
1312 USB4_SB_OPCODE_NVM_BLOCK_WRITE
, 1000);
1316 * usb4_port_retimer_nvm_write() - Write to retimer NVM
1318 * @index: Retimer index
1319 * @address: Byte address where to start the write
1320 * @buf: Data to write
1321 * @size: Size in bytes how much to write
1323 * Writes @size bytes from @buf to the retimer NVM. Used for NVM
1324 * upgrade. Returns %0 if the data was written successfully and negative
1325 * errno in case of failure. Specifically returns %-ENODEV if there is
1326 * no retimer at @index.
1328 int usb4_port_retimer_nvm_write(struct tb_port
*port
, u8 index
, unsigned int address
,
1329 const void *buf
, size_t size
)
1331 struct retimer_info info
= { .port
= port
, .index
= index
};
1334 ret
= usb4_port_retimer_nvm_set_offset(port
, index
, address
);
1338 return usb4_do_write_data(address
, buf
, size
,
1339 usb4_port_retimer_nvm_write_next_block
, &info
);
1343 * usb4_port_retimer_nvm_authenticate() - Start retimer NVM upgrade
1345 * @index: Retimer index
1347 * After the new NVM image has been written via usb4_port_retimer_nvm_write()
1348 * this function can be used to trigger the NVM upgrade process. If
1349 * successful the retimer restarts with the new NVM and may not have the
1350 * index set so one needs to call usb4_port_enumerate_retimers() to
1351 * force index to be assigned.
1353 int usb4_port_retimer_nvm_authenticate(struct tb_port
*port
, u8 index
)
1358 * We need to use the raw operation here because once the
1359 * authentication completes the retimer index is not set anymore
1360 * so we do not get back the status now.
1362 val
= USB4_SB_OPCODE_NVM_AUTH_WRITE
;
1363 return usb4_port_sb_write(port
, USB4_SB_TARGET_RETIMER
, index
,
1364 USB4_SB_OPCODE
, &val
, sizeof(val
));
1368 * usb4_port_retimer_nvm_authenticate_status() - Read status of NVM upgrade
1370 * @index: Retimer index
1371 * @status: Raw status code read from metadata
1373 * This can be called after usb4_port_retimer_nvm_authenticate() and
1374 * usb4_port_enumerate_retimers() to fetch status of the NVM upgrade.
1376 * Returns %0 if the authentication status was successfully read. The
1377 * completion metadata (the result) is then stored into @status. If
1378 * reading the status fails, returns negative errno.
1380 int usb4_port_retimer_nvm_authenticate_status(struct tb_port
*port
, u8 index
,
1386 ret
= usb4_port_retimer_read(port
, index
, USB4_SB_OPCODE
, &val
,
1396 case USB4_SB_OPCODE_ERR
:
1397 ret
= usb4_port_retimer_read(port
, index
, USB4_SB_METADATA
,
1398 &metadata
, sizeof(metadata
));
1402 *status
= metadata
& USB4_SB_METADATA_NVM_AUTH_WRITE_MASK
;
1405 case USB4_SB_OPCODE_ONS
:
1413 static int usb4_port_retimer_nvm_read_block(void *data
, unsigned int dwaddress
,
1414 void *buf
, size_t dwords
)
1416 const struct retimer_info
*info
= data
;
1417 struct tb_port
*port
= info
->port
;
1418 u8 index
= info
->index
;
1422 metadata
= dwaddress
<< USB4_NVM_READ_OFFSET_SHIFT
;
1423 if (dwords
< USB4_DATA_DWORDS
)
1424 metadata
|= dwords
<< USB4_NVM_READ_LENGTH_SHIFT
;
1426 ret
= usb4_port_retimer_write(port
, index
, USB4_SB_METADATA
, &metadata
,
1431 ret
= usb4_port_retimer_op(port
, index
, USB4_SB_OPCODE_NVM_READ
, 500);
1435 return usb4_port_retimer_read(port
, index
, USB4_SB_DATA
, buf
,
1440 * usb4_port_retimer_nvm_read() - Read contents of retimer NVM
1442 * @index: Retimer index
1443 * @address: NVM address (in bytes) to start reading
1444 * @buf: Data read from NVM is stored here
1445 * @size: Number of bytes to read
1447 * Reads retimer NVM and copies the contents to @buf. Returns %0 if the
1448 * read was successful and negative errno in case of failure.
1449 * Specifically returns %-ENODEV if there is no retimer at @index.
1451 int usb4_port_retimer_nvm_read(struct tb_port
*port
, u8 index
,
1452 unsigned int address
, void *buf
, size_t size
)
1454 struct retimer_info info
= { .port
= port
, .index
= index
};
1456 return usb4_do_read_data(address
, buf
, size
,
1457 usb4_port_retimer_nvm_read_block
, &info
);
1461 * usb4_usb3_port_max_link_rate() - Maximum support USB3 link rate
1462 * @port: USB3 adapter port
1464 * Return maximum supported link rate of a USB3 adapter in Mb/s.
1465 * Negative errno in case of error.
1467 int usb4_usb3_port_max_link_rate(struct tb_port
*port
)
1472 if (!tb_port_is_usb3_down(port
) && !tb_port_is_usb3_up(port
))
1475 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
1476 port
->cap_adap
+ ADP_USB3_CS_4
, 1);
1480 lr
= (val
& ADP_USB3_CS_4_MSLR_MASK
) >> ADP_USB3_CS_4_MSLR_SHIFT
;
1481 return lr
== ADP_USB3_CS_4_MSLR_20G
? 20000 : 10000;
1485 * usb4_usb3_port_actual_link_rate() - Established USB3 link rate
1486 * @port: USB3 adapter port
1488 * Return actual established link rate of a USB3 adapter in Mb/s. If the
1489 * link is not up returns %0 and negative errno in case of failure.
1491 int usb4_usb3_port_actual_link_rate(struct tb_port
*port
)
1496 if (!tb_port_is_usb3_down(port
) && !tb_port_is_usb3_up(port
))
1499 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
1500 port
->cap_adap
+ ADP_USB3_CS_4
, 1);
1504 if (!(val
& ADP_USB3_CS_4_ULV
))
1507 lr
= val
& ADP_USB3_CS_4_ALR_MASK
;
1508 return lr
== ADP_USB3_CS_4_ALR_20G
? 20000 : 10000;
1511 static int usb4_usb3_port_cm_request(struct tb_port
*port
, bool request
)
1516 if (!tb_port_is_usb3_down(port
))
1518 if (tb_route(port
->sw
))
1521 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
1522 port
->cap_adap
+ ADP_USB3_CS_2
, 1);
1527 val
|= ADP_USB3_CS_2_CMR
;
1529 val
&= ~ADP_USB3_CS_2_CMR
;
1531 ret
= tb_port_write(port
, &val
, TB_CFG_PORT
,
1532 port
->cap_adap
+ ADP_USB3_CS_2
, 1);
1537 * We can use val here directly as the CMR bit is in the same place
1538 * as HCA. Just mask out others.
1540 val
&= ADP_USB3_CS_2_CMR
;
1541 return usb4_port_wait_for_bit(port
, port
->cap_adap
+ ADP_USB3_CS_1
,
1542 ADP_USB3_CS_1_HCA
, val
, 1500);
1545 static inline int usb4_usb3_port_set_cm_request(struct tb_port
*port
)
1547 return usb4_usb3_port_cm_request(port
, true);
1550 static inline int usb4_usb3_port_clear_cm_request(struct tb_port
*port
)
1552 return usb4_usb3_port_cm_request(port
, false);
1555 static unsigned int usb3_bw_to_mbps(u32 bw
, u8 scale
)
1557 unsigned long uframes
;
1559 uframes
= bw
* 512UL << scale
;
1560 return DIV_ROUND_CLOSEST(uframes
* 8000, 1000 * 1000);
1563 static u32
mbps_to_usb3_bw(unsigned int mbps
, u8 scale
)
1565 unsigned long uframes
;
1567 /* 1 uframe is 1/8 ms (125 us) -> 1 / 8000 s */
1568 uframes
= ((unsigned long)mbps
* 1000 * 1000) / 8000;
1569 return DIV_ROUND_UP(uframes
, 512UL << scale
);
1572 static int usb4_usb3_port_read_allocated_bandwidth(struct tb_port
*port
,
1579 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
1580 port
->cap_adap
+ ADP_USB3_CS_2
, 1);
1584 ret
= tb_port_read(port
, &scale
, TB_CFG_PORT
,
1585 port
->cap_adap
+ ADP_USB3_CS_3
, 1);
1589 scale
&= ADP_USB3_CS_3_SCALE_MASK
;
1591 bw
= val
& ADP_USB3_CS_2_AUBW_MASK
;
1592 *upstream_bw
= usb3_bw_to_mbps(bw
, scale
);
1594 bw
= (val
& ADP_USB3_CS_2_ADBW_MASK
) >> ADP_USB3_CS_2_ADBW_SHIFT
;
1595 *downstream_bw
= usb3_bw_to_mbps(bw
, scale
);
1601 * usb4_usb3_port_allocated_bandwidth() - Bandwidth allocated for USB3
1602 * @port: USB3 adapter port
1603 * @upstream_bw: Allocated upstream bandwidth is stored here
1604 * @downstream_bw: Allocated downstream bandwidth is stored here
1606 * Stores currently allocated USB3 bandwidth into @upstream_bw and
1607 * @downstream_bw in Mb/s. Returns %0 in case of success and negative
1610 int usb4_usb3_port_allocated_bandwidth(struct tb_port
*port
, int *upstream_bw
,
1615 ret
= usb4_usb3_port_set_cm_request(port
);
1619 ret
= usb4_usb3_port_read_allocated_bandwidth(port
, upstream_bw
,
1621 usb4_usb3_port_clear_cm_request(port
);
1626 static int usb4_usb3_port_read_consumed_bandwidth(struct tb_port
*port
,
1633 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
1634 port
->cap_adap
+ ADP_USB3_CS_1
, 1);
1638 ret
= tb_port_read(port
, &scale
, TB_CFG_PORT
,
1639 port
->cap_adap
+ ADP_USB3_CS_3
, 1);
1643 scale
&= ADP_USB3_CS_3_SCALE_MASK
;
1645 bw
= val
& ADP_USB3_CS_1_CUBW_MASK
;
1646 *upstream_bw
= usb3_bw_to_mbps(bw
, scale
);
1648 bw
= (val
& ADP_USB3_CS_1_CDBW_MASK
) >> ADP_USB3_CS_1_CDBW_SHIFT
;
1649 *downstream_bw
= usb3_bw_to_mbps(bw
, scale
);
1654 static int usb4_usb3_port_write_allocated_bandwidth(struct tb_port
*port
,
1658 u32 val
, ubw
, dbw
, scale
;
1661 /* Read the used scale, hardware default is 0 */
1662 ret
= tb_port_read(port
, &scale
, TB_CFG_PORT
,
1663 port
->cap_adap
+ ADP_USB3_CS_3
, 1);
1667 scale
&= ADP_USB3_CS_3_SCALE_MASK
;
1668 ubw
= mbps_to_usb3_bw(upstream_bw
, scale
);
1669 dbw
= mbps_to_usb3_bw(downstream_bw
, scale
);
1671 ret
= tb_port_read(port
, &val
, TB_CFG_PORT
,
1672 port
->cap_adap
+ ADP_USB3_CS_2
, 1);
1676 val
&= ~(ADP_USB3_CS_2_AUBW_MASK
| ADP_USB3_CS_2_ADBW_MASK
);
1677 val
|= dbw
<< ADP_USB3_CS_2_ADBW_SHIFT
;
1680 return tb_port_write(port
, &val
, TB_CFG_PORT
,
1681 port
->cap_adap
+ ADP_USB3_CS_2
, 1);
1685 * usb4_usb3_port_allocate_bandwidth() - Allocate bandwidth for USB3
1686 * @port: USB3 adapter port
1687 * @upstream_bw: New upstream bandwidth
1688 * @downstream_bw: New downstream bandwidth
1690 * This can be used to set how much bandwidth is allocated for the USB3
1691 * tunneled isochronous traffic. @upstream_bw and @downstream_bw are the
1692 * new values programmed to the USB3 adapter allocation registers. If
1693 * the values are lower than what is currently consumed the allocation
1694 * is set to what is currently consumed instead (consumed bandwidth
1695 * cannot be taken away by CM). The actual new values are returned in
1696 * @upstream_bw and @downstream_bw.
1698 * Returns %0 in case of success and negative errno if there was a
1701 int usb4_usb3_port_allocate_bandwidth(struct tb_port
*port
, int *upstream_bw
,
1704 int ret
, consumed_up
, consumed_down
, allocate_up
, allocate_down
;
1706 ret
= usb4_usb3_port_set_cm_request(port
);
1710 ret
= usb4_usb3_port_read_consumed_bandwidth(port
, &consumed_up
,
1715 /* Don't allow it go lower than what is consumed */
1716 allocate_up
= max(*upstream_bw
, consumed_up
);
1717 allocate_down
= max(*downstream_bw
, consumed_down
);
1719 ret
= usb4_usb3_port_write_allocated_bandwidth(port
, allocate_up
,
1724 *upstream_bw
= allocate_up
;
1725 *downstream_bw
= allocate_down
;
1728 usb4_usb3_port_clear_cm_request(port
);
1733 * usb4_usb3_port_release_bandwidth() - Release allocated USB3 bandwidth
1734 * @port: USB3 adapter port
1735 * @upstream_bw: New allocated upstream bandwidth
1736 * @downstream_bw: New allocated downstream bandwidth
1738 * Releases USB3 allocated bandwidth down to what is actually consumed.
1739 * The new bandwidth is returned in @upstream_bw and @downstream_bw.
1741 * Returns 0% in success and negative errno in case of failure.
1743 int usb4_usb3_port_release_bandwidth(struct tb_port
*port
, int *upstream_bw
,
1746 int ret
, consumed_up
, consumed_down
;
1748 ret
= usb4_usb3_port_set_cm_request(port
);
1752 ret
= usb4_usb3_port_read_consumed_bandwidth(port
, &consumed_up
,
1758 * Always keep 1000 Mb/s to make sure xHCI has at least some
1759 * bandwidth available for isochronous traffic.
1761 if (consumed_up
< 1000)
1763 if (consumed_down
< 1000)
1764 consumed_down
= 1000;
1766 ret
= usb4_usb3_port_write_allocated_bandwidth(port
, consumed_up
,
1771 *upstream_bw
= consumed_up
;
1772 *downstream_bw
= consumed_down
;
1775 usb4_usb3_port_clear_cm_request(port
);