[linux-2.6-block.git] / drivers / thunderbolt / tunnel.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Thunderbolt driver - Tunneling support
 *
 * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
 * Copyright (C) 2019, Intel Corporation
 */

#ifndef TB_TUNNEL_H_
#define TB_TUNNEL_H_

#include "tb.h"

enum tb_tunnel_type {
	TB_TUNNEL_PCI,
	TB_TUNNEL_DP,
	TB_TUNNEL_DMA,
	TB_TUNNEL_USB3,
};

/**
 * struct tb_tunnel - Tunnel between two ports
 * @tb: Pointer to the domain
 * @src_port: Source port of the tunnel
 * @dst_port: Destination port of the tunnel. For discovered incomplete
 *	      tunnels may be %NULL or null adapter port instead.
 * @paths: All paths required by the tunnel
 * @npaths: Number of paths in @paths
 * @init: Optional tunnel specific initialization
 * @deinit: Optional tunnel specific de-initialization
 * @activate: Optional tunnel specific activation/deactivation
 * @maximum_bandwidth: Returns maximum possible bandwidth for this tunnel
 * @allocated_bandwidth: Return how much bandwidth is allocated for the tunnel
 * @alloc_bandwidth: Change tunnel bandwidth allocation
 * @consumed_bandwidth: Return how much bandwidth the tunnel consumes
 * @release_unused_bandwidth: Release all unused bandwidth
 * @reclaim_available_bandwidth: Reclaim back available bandwidth
 * @list: Tunnels are linked using this field
 * @type: Type of the tunnel
 * @max_up: Maximum upstream bandwidth (Mb/s) available for the tunnel.
 *	    Only set if the bandwidth needs to be limited.
 * @max_down: Maximum downstream bandwidth (Mb/s) available for the tunnel.
 *	      Only set if the bandwidth needs to be limited.
 * @allocated_up: Allocated upstream bandwidth (only for USB3)
 * @allocated_down: Allocated downstream bandwidth (only for USB3)
 * @bw_mode: DP bandwidth allocation mode registers can be used to
 *	     determine consumed and allocated bandwidth
 */
struct tb_tunnel {
	struct tb *tb;
	struct tb_port *src_port;
	struct tb_port *dst_port;
	struct tb_path **paths;
	size_t npaths;
	int (*init)(struct tb_tunnel *tunnel);
	void (*deinit)(struct tb_tunnel *tunnel);
	int (*activate)(struct tb_tunnel *tunnel, bool activate);
	int (*maximum_bandwidth)(struct tb_tunnel *tunnel, int *max_up,
				 int *max_down);
	int (*allocated_bandwidth)(struct tb_tunnel *tunnel, int *allocated_up,
				   int *allocated_down);
	int (*alloc_bandwidth)(struct tb_tunnel *tunnel, int *alloc_up,
			       int *alloc_down);
	int (*consumed_bandwidth)(struct tb_tunnel *tunnel, int *consumed_up,
				  int *consumed_down);
	int (*release_unused_bandwidth)(struct tb_tunnel *tunnel);
	void (*reclaim_available_bandwidth)(struct tb_tunnel *tunnel,
					    int *available_up,
					    int *available_down);
	struct list_head list;
	enum tb_tunnel_type type;
	int max_up;
	int max_down;
	int allocated_up;
	int allocated_down;
	bool bw_mode;
};

struct tb_tunnel *tb_tunnel_discover_pci(struct tb *tb, struct tb_port *down,
					 bool alloc_hopid);
struct tb_tunnel *tb_tunnel_alloc_pci(struct tb *tb, struct tb_port *up,
				      struct tb_port *down);
bool tb_tunnel_reserved_pci(struct tb_port *port, int *reserved_up,
			    int *reserved_down);
struct tb_tunnel *tb_tunnel_discover_dp(struct tb *tb, struct tb_port *in,
					bool alloc_hopid);
struct tb_tunnel *tb_tunnel_alloc_dp(struct tb *tb, struct tb_port *in,
				     struct tb_port *out, int link_nr,
				     int max_up, int max_down);
struct tb_tunnel *tb_tunnel_alloc_dma(struct tb *tb, struct tb_port *nhi,
				      struct tb_port *dst, int transmit_path,
				      int transmit_ring, int receive_path,
				      int receive_ring);
bool tb_tunnel_match_dma(const struct tb_tunnel *tunnel, int transmit_path,
			 int transmit_ring, int receive_path, int receive_ring);
struct tb_tunnel *tb_tunnel_discover_usb3(struct tb *tb, struct tb_port *down,
					  bool alloc_hopid);
struct tb_tunnel *tb_tunnel_alloc_usb3(struct tb *tb, struct tb_port *up,
				       struct tb_port *down, int max_up,
				       int max_down);

void tb_tunnel_free(struct tb_tunnel *tunnel);
int tb_tunnel_activate(struct tb_tunnel *tunnel);
int tb_tunnel_restart(struct tb_tunnel *tunnel);
void tb_tunnel_deactivate(struct tb_tunnel *tunnel);
bool tb_tunnel_is_invalid(struct tb_tunnel *tunnel);
bool tb_tunnel_port_on_path(const struct tb_tunnel *tunnel,
			    const struct tb_port *port);
int tb_tunnel_maximum_bandwidth(struct tb_tunnel *tunnel, int *max_up,
				int *max_down);
int tb_tunnel_allocated_bandwidth(struct tb_tunnel *tunnel, int *allocated_up,
				  int *allocated_down);
int tb_tunnel_alloc_bandwidth(struct tb_tunnel *tunnel, int *alloc_up,
			      int *alloc_down);
int tb_tunnel_consumed_bandwidth(struct tb_tunnel *tunnel, int *consumed_up,
				 int *consumed_down);
int tb_tunnel_release_unused_bandwidth(struct tb_tunnel *tunnel);
void tb_tunnel_reclaim_available_bandwidth(struct tb_tunnel *tunnel,
					   int *available_up,
					   int *available_down);

static inline bool tb_tunnel_is_pci(const struct tb_tunnel *tunnel)
{
	return tunnel->type == TB_TUNNEL_PCI;
}

static inline bool tb_tunnel_is_dp(const struct tb_tunnel *tunnel)
{
	return tunnel->type == TB_TUNNEL_DP;
}

static inline bool tb_tunnel_is_dma(const struct tb_tunnel *tunnel)
{
	return tunnel->type == TB_TUNNEL_DMA;
}

static inline bool tb_tunnel_is_usb3(const struct tb_tunnel *tunnel)
{
	return tunnel->type == TB_TUNNEL_USB3;
}

const char *tb_tunnel_type_name(const struct tb_tunnel *tunnel);

#define __TB_TUNNEL_PRINT(level, tunnel, fmt, arg...)                   \
	do {                                                            \
		struct tb_tunnel *__tunnel = (tunnel);                  \
		level(__tunnel->tb, "%llx:%u <-> %llx:%u (%s): " fmt,   \
		      tb_route(__tunnel->src_port->sw),                 \
		      __tunnel->src_port->port,                         \
		      tb_route(__tunnel->dst_port->sw),                 \
		      __tunnel->dst_port->port,                         \
		      tb_tunnel_type_name(__tunnel),			\
		      ## arg);                                          \
	} while (0)

#define tb_tunnel_WARN(tunnel, fmt, arg...) \
	__TB_TUNNEL_PRINT(tb_WARN, tunnel, fmt, ##arg)
#define tb_tunnel_warn(tunnel, fmt, arg...) \
	__TB_TUNNEL_PRINT(tb_warn, tunnel, fmt, ##arg)
#define tb_tunnel_info(tunnel, fmt, arg...) \
	__TB_TUNNEL_PRINT(tb_info, tunnel, fmt, ##arg)
#define tb_tunnel_dbg(tunnel, fmt, arg...) \
	__TB_TUNNEL_PRINT(tb_dbg, tunnel, fmt, ##arg)

#endif
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
3364f0c1	2	/*
93f36ade	3	* Thunderbolt driver - Tunneling support
3364f0c1 AN	4	*
3364f0c1 AN	5	* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
93f36ade	6	* Copyright (C) 2019, Intel Corporation
3364f0c1 AN	7	*/
3364f0c1 AN	8
1752b9f7 MW	9	#ifndef TB_TUNNEL_H_
1752b9f7 MW	10	#define TB_TUNNEL_H_
3364f0c1 AN	11
	12	#include "tb.h"
	13
4f807e47 MW	14	enum tb_tunnel_type {
	15	TB_TUNNEL_PCI,
	16	TB_TUNNEL_DP,
44242d6c	17	TB_TUNNEL_DMA,
e6f81858	18	TB_TUNNEL_USB3,
4f807e47 MW	19	};
4f807e47 MW	20
93f36ade MW	21	/**
	22	* struct tb_tunnel - Tunnel between two ports
	23	* @tb: Pointer to the domain
	24	* @src_port: Source port of the tunnel
0414bec5 MW	25	* @dst_port: Destination port of the tunnel. For discovered incomplete
0414bec5 MW	26	* tunnels may be %NULL or null adapter port instead.
93f36ade MW	27	* @paths: All paths required by the tunnel
93f36ade MW	28	* @npaths: Number of paths in @paths
4f807e47	29	* @init: Optional tunnel specific initialization
6ed541c5	30	* @deinit: Optional tunnel specific de-initialization
93f36ade	31	* @activate: Optional tunnel specific activation/deactivation
06cbcbfa	32	* @maximum_bandwidth: Returns maximum possible bandwidth for this tunnel
6ce35635 MW	33	* @allocated_bandwidth: Return how much bandwidth is allocated for the tunnel
6ce35635 MW	34	* @alloc_bandwidth: Change tunnel bandwidth allocation
a11b88ad	35	* @consumed_bandwidth: Return how much bandwidth the tunnel consumes
0bd680cd MW	36	* @release_unused_bandwidth: Release all unused bandwidth
0bd680cd MW	37	* @reclaim_available_bandwidth: Reclaim back available bandwidth
93f36ade	38	* @list: Tunnels are linked using this field
4f807e47	39	* @type: Type of the tunnel
0bd680cd	40	* @max_up: Maximum upstream bandwidth (Mb/s) available for the tunnel.
a11b88ad	41	* Only set if the bandwidth needs to be limited.
0bd680cd MW	42	* @max_down: Maximum downstream bandwidth (Mb/s) available for the tunnel.
	43	* Only set if the bandwidth needs to be limited.
	44	* @allocated_up: Allocated upstream bandwidth (only for USB3)
	45	* @allocated_down: Allocated downstream bandwidth (only for USB3)
6ce35635 MW	46	* @bw_mode: DP bandwidth allocation mode registers can be used to
6ce35635 MW	47	* determine consumed and allocated bandwidth
93f36ade MW	48	*/
93f36ade MW	49	struct tb_tunnel {
3364f0c1	50	struct tb *tb;
93f36ade MW	51	struct tb_port *src_port;
	52	struct tb_port *dst_port;
	53	struct tb_path **paths;
	54	size_t npaths;
4f807e47	55	int (init)(struct tb_tunnel tunnel);
6ed541c5	56	void (deinit)(struct tb_tunnel tunnel);
93f36ade	57	int (activate)(struct tb_tunnel tunnel, bool activate);
6ce35635 MW	58	int (maximum_bandwidth)(struct tb_tunnel tunnel, int *max_up,
	59	int *max_down);
	60	int (allocated_bandwidth)(struct tb_tunnel tunnel, int *allocated_up,
	61	int *allocated_down);
	62	int (alloc_bandwidth)(struct tb_tunnel tunnel, int *alloc_up,
	63	int *alloc_down);
7c0ee8fd MW	64	int (consumed_bandwidth)(struct tb_tunnel tunnel, int *consumed_up,
7c0ee8fd MW	65	int *consumed_down);
0bd680cd MW	66	int (release_unused_bandwidth)(struct tb_tunnel tunnel);
	67	void (reclaim_available_bandwidth)(struct tb_tunnel tunnel,
	68	int *available_up,
	69	int *available_down);
3364f0c1	70	struct list_head list;
4f807e47	71	enum tb_tunnel_type type;
0bd680cd MW	72	int max_up;
	73	int max_down;
	74	int allocated_up;
	75	int allocated_down;
6ce35635	76	bool bw_mode;
3364f0c1 AN	77	};
3364f0c1 AN	78
43bddb26 MW	79	struct tb_tunnel tb_tunnel_discover_pci(struct tb tb, struct tb_port *down,
43bddb26 MW	80	bool alloc_hopid);
93f36ade MW	81	struct tb_tunnel tb_tunnel_alloc_pci(struct tb tb, struct tb_port *up,
93f36ade MW	82	struct tb_port *down);
582e70b0 GF	83	bool tb_tunnel_reserved_pci(struct tb_port port, int reserved_up,
582e70b0 GF	84	int *reserved_down);
43bddb26 MW	85	struct tb_tunnel tb_tunnel_discover_dp(struct tb tb, struct tb_port *in,
43bddb26 MW	86	bool alloc_hopid);
4f807e47	87	struct tb_tunnel tb_tunnel_alloc_dp(struct tb tb, struct tb_port *in,
9d2d0a5c MW	88	struct tb_port *out, int link_nr,
9d2d0a5c MW	89	int max_up, int max_down);
44242d6c	90	struct tb_tunnel tb_tunnel_alloc_dma(struct tb tb, struct tb_port *nhi,
180b0689 MW	91	struct tb_port *dst, int transmit_path,
	92	int transmit_ring, int receive_path,
	93	int receive_ring);
	94	bool tb_tunnel_match_dma(const struct tb_tunnel *tunnel, int transmit_path,
	95	int transmit_ring, int receive_path, int receive_ring);
43bddb26 MW	96	struct tb_tunnel tb_tunnel_discover_usb3(struct tb tb, struct tb_port *down,
43bddb26 MW	97	bool alloc_hopid);
e6f81858	98	struct tb_tunnel tb_tunnel_alloc_usb3(struct tb tb, struct tb_port *up,
0bd680cd MW	99	struct tb_port *down, int max_up,
0bd680cd MW	100	int max_down);
4f807e47	101
93f36ade MW	102	void tb_tunnel_free(struct tb_tunnel *tunnel);
	103	int tb_tunnel_activate(struct tb_tunnel *tunnel);
	104	int tb_tunnel_restart(struct tb_tunnel *tunnel);
	105	void tb_tunnel_deactivate(struct tb_tunnel *tunnel);
	106	bool tb_tunnel_is_invalid(struct tb_tunnel *tunnel);
0bd680cd MW	107	bool tb_tunnel_port_on_path(const struct tb_tunnel *tunnel,
0bd680cd MW	108	const struct tb_port *port);
6ce35635 MW	109	int tb_tunnel_maximum_bandwidth(struct tb_tunnel tunnel, int max_up,
	110	int *max_down);
	111	int tb_tunnel_allocated_bandwidth(struct tb_tunnel tunnel, int allocated_up,
	112	int *allocated_down);
	113	int tb_tunnel_alloc_bandwidth(struct tb_tunnel tunnel, int alloc_up,
	114	int *alloc_down);
7c0ee8fd MW	115	int tb_tunnel_consumed_bandwidth(struct tb_tunnel tunnel, int consumed_up,
7c0ee8fd MW	116	int *consumed_down);
0bd680cd MW	117	int tb_tunnel_release_unused_bandwidth(struct tb_tunnel *tunnel);
	118	void tb_tunnel_reclaim_available_bandwidth(struct tb_tunnel *tunnel,
	119	int *available_up,
	120	int *available_down);
3364f0c1	121
4f807e47 MW	122	static inline bool tb_tunnel_is_pci(const struct tb_tunnel *tunnel)
	123	{
	124	return tunnel->type == TB_TUNNEL_PCI;
	125	}
	126
	127	static inline bool tb_tunnel_is_dp(const struct tb_tunnel *tunnel)
	128	{
	129	return tunnel->type == TB_TUNNEL_DP;
	130	}
	131
44242d6c MW	132	static inline bool tb_tunnel_is_dma(const struct tb_tunnel *tunnel)
	133	{
	134	return tunnel->type == TB_TUNNEL_DMA;
	135	}
	136
e6f81858 RM	137	static inline bool tb_tunnel_is_usb3(const struct tb_tunnel *tunnel)
	138	{
	139	return tunnel->type == TB_TUNNEL_USB3;
	140	}
	141
d27bd2c3 MW	142	const char tb_tunnel_type_name(const struct tb_tunnel tunnel);
	143
	144	#define __TB_TUNNEL_PRINT(level, tunnel, fmt, arg...) \
	145	do { \
	146	struct tb_tunnel *__tunnel = (tunnel); \
	147	level(__tunnel->tb, "%llx:%u <-> %llx:%u (%s): " fmt, \
	148	tb_route(__tunnel->src_port->sw), \
	149	__tunnel->src_port->port, \
	150	tb_route(__tunnel->dst_port->sw), \
	151	__tunnel->dst_port->port, \
	152	tb_tunnel_type_name(__tunnel), \
	153	## arg); \
	154	} while (0)
3364f0c1	155
d27bd2c3 MW	156	#define tb_tunnel_WARN(tunnel, fmt, arg...) \
	157	__TB_TUNNEL_PRINT(tb_WARN, tunnel, fmt, ##arg)
	158	#define tb_tunnel_warn(tunnel, fmt, arg...) \
	159	__TB_TUNNEL_PRINT(tb_warn, tunnel, fmt, ##arg)
	160	#define tb_tunnel_info(tunnel, fmt, arg...) \
	161	__TB_TUNNEL_PRINT(tb_info, tunnel, fmt, ##arg)
	162	#define tb_tunnel_dbg(tunnel, fmt, arg...) \
	163	__TB_TUNNEL_PRINT(tb_dbg, tunnel, fmt, ##arg)
	164
	165	#endif