drivers/thunderbolt/tunnel.c

51 /* Minimum number of credits needed for PCIe path */
54  * Number of credits we try to allocate for each DMA path if not limited
58 /* Minimum number of credits for DMA path */
261 static int tb_pci_init_path(struct tb_path *path)
265 	path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
266 	path->egress_shared_buffer = TB_PATH_NONE;
267 	path->ingress_fc_enable = TB_PATH_ALL;
268 	path->ingress_shared_buffer = TB_PATH_NONE;
269 	path->priority = TB_PCI_PRIORITY;
270 	path->weight = TB_PCI_WEIGHT;
271 	path->drop_packages = 0;
273 	tb_path_for_each_hop(path, hop) {
298 	struct tb_path *path;
315 	path = tb_path_discover(down, TB_PCI_HOPID, NULL, -1,
317 	if (!path) {
322 	tunnel->paths[TB_PCI_PATH_UP] = path;
326 	path = tb_path_discover(tunnel->dst_port, -1, down, TB_PCI_HOPID, NULL,
328 	if (!path)
330 	tunnel->paths[TB_PCI_PATH_DOWN] = path;
337 			     "path does not end on a PCIe adapter, cleaning up\n");
342 		tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
378 	struct tb_path *path;
388 	path = tb_path_alloc(tb, down, TB_PCI_HOPID, up, TB_PCI_HOPID, 0,
390 	if (!path)
392 	tunnel->paths[TB_PCI_PATH_DOWN] = path;
393 	if (tb_pci_init_path(path))
396 	path = tb_path_alloc(tb, up, TB_PCI_HOPID, down, TB_PCI_HOPID, 0,
398 	if (!path)
400 	tunnel->paths[TB_PCI_PATH_UP] = path;
401 	if (tb_pci_init_path(path))
1230 static void tb_dp_init_aux_path(struct tb_path *path, bool pm_support)
1234 	path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
1235 	path->egress_shared_buffer = TB_PATH_NONE;
1236 	path->ingress_fc_enable = TB_PATH_ALL;
1237 	path->ingress_shared_buffer = TB_PATH_NONE;
1238 	path->priority = TB_DP_AUX_PRIORITY;
1239 	path->weight = TB_DP_AUX_WEIGHT;
1241 	tb_path_for_each_hop(path, hop) {
1277 static int tb_dp_init_video_path(struct tb_path *path, bool pm_support)
1281 	path->egress_fc_enable = TB_PATH_NONE;
1282 	path->egress_shared_buffer = TB_PATH_NONE;
1283 	path->ingress_fc_enable = TB_PATH_NONE;
1284 	path->ingress_shared_buffer = TB_PATH_NONE;
1285 	path->priority = TB_DP_VIDEO_PRIORITY;
1286 	path->weight = TB_DP_VIDEO_WEIGHT;
1288 	tb_path_for_each_hop(path, hop) {
1359 	struct tb_path *path;
1377 	path = tb_path_discover(in, TB_DP_VIDEO_HOPID, NULL, -1,
1379 	if (!path) {
1384 	tunnel->paths[TB_DP_VIDEO_PATH_OUT] = path;
1388 	path = tb_path_discover(in, TB_DP_AUX_TX_HOPID, NULL, -1, NULL, "AUX TX",
1390 	if (!path)
1392 	tunnel->paths[TB_DP_AUX_PATH_OUT] = path;
1395 	path = tb_path_discover(tunnel->dst_port, -1, in, TB_DP_AUX_RX_HOPID,
1397 	if (!path)
1399 	tunnel->paths[TB_DP_AUX_PATH_IN] = path;
1404 		tb_port_warn(in, "path does not end on a DP adapter, cleaning up\n");
1415 		tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
1454 	struct tb_path *path;
1479 	path = tb_path_alloc(tb, in, TB_DP_VIDEO_HOPID, out, TB_DP_VIDEO_HOPID,
1481 	if (!path)
1483 	tb_dp_init_video_path(path, pm_support);
1484 	paths[TB_DP_VIDEO_PATH_OUT] = path;
1486 	path = tb_path_alloc(tb, in, TB_DP_AUX_TX_HOPID, out,
1488 	if (!path)
1490 	tb_dp_init_aux_path(path, pm_support);
1491 	paths[TB_DP_AUX_PATH_OUT] = path;
1493 	path = tb_path_alloc(tb, out, TB_DP_AUX_RX_HOPID, in,
1495 	if (!path)
1497 	tb_dp_init_aux_path(path, pm_support);
1498 	paths[TB_DP_AUX_PATH_IN] = path;
1529 		 * DMA path cannot be established.
1537 		tb_port_dbg(port, "reserving %u credits for DMA path\n",
1553 static int tb_dma_init_rx_path(struct tb_path *path, unsigned int credits)
1558 	path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
1559 	path->ingress_fc_enable = TB_PATH_ALL;
1560 	path->egress_shared_buffer = TB_PATH_NONE;
1561 	path->ingress_shared_buffer = TB_PATH_NONE;
1562 	path->priority = TB_DMA_PRIORITY;
1563 	path->weight = TB_DMA_WEIGHT;
1564 	path->clear_fc = true;
1571 	hop = &path->hops[0];
1576 	for (i = 1; i < path->path_length; i++) {
1579 		ret = tb_dma_reserve_credits(&path->hops[i], credits);
1588 static int tb_dma_init_tx_path(struct tb_path *path, unsigned int credits)
1592 	path->egress_fc_enable = TB_PATH_ALL;
1593 	path->ingress_fc_enable = TB_PATH_ALL;
1594 	path->egress_shared_buffer = TB_PATH_NONE;
1595 	path->ingress_shared_buffer = TB_PATH_NONE;
1596 	path->priority = TB_DMA_PRIORITY;
1597 	path->weight = TB_DMA_WEIGHT;
1598 	path->clear_fc = true;
1600 	tb_path_for_each_hop(path, hop) {
1618 		tb_port_dbg(port, "released %u DMA path credits\n",
1623 static void tb_dma_deinit_path(struct tb_path *path)
1627 	tb_path_for_each_hop(path, hop)
1649  *		   other domain. Set to %-1 if TX path is not needed.
1652  *		  other domain. Set to %-1 if RX path is not needed.
1663 	struct tb_path *path;
1689 		path = tb_path_alloc(tb, dst, receive_path, nhi, receive_ring, 0,
1691 		if (!path)
1693 		tunnel->paths[i++] = path;
1694 		if (tb_dma_init_rx_path(path, credits)) {
1695 			tb_tunnel_dbg(tunnel, "not enough buffers for RX path\n");
1701 		path = tb_path_alloc(tb, nhi, transmit_ring, dst, transmit_path, 0,
1703 		if (!path)
1705 		tunnel->paths[i++] = path;
1706 		if (tb_dma_init_tx_path(path, credits)) {
1707 			tb_tunnel_dbg(tunnel, "not enough buffers for TX path\n");
1743 		const struct tb_path *path = tunnel->paths[i];
1745 		if (!path)
1748 		if (tb_port_is_nhi(path->hops[0].in_port))
1749 			tx_path = path;
1750 		else if (tb_port_is_nhi(path->hops[path->path_length - 1].out_port))
1751 			rx_path = path;
1930 static void tb_usb3_init_path(struct tb_path *path)
1934 	path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
1935 	path->egress_shared_buffer = TB_PATH_NONE;
1936 	path->ingress_fc_enable = TB_PATH_ALL;
1937 	path->ingress_shared_buffer = TB_PATH_NONE;
1938 	path->priority = TB_USB3_PRIORITY;
1939 	path->weight = TB_USB3_WEIGHT;
1940 	path->drop_packages = 0;
1942 	tb_path_for_each_hop(path, hop)
1960 	struct tb_path *path;
1977 	path = tb_path_discover(down, TB_USB3_HOPID, NULL, -1,
1979 	if (!path) {
1984 	tunnel->paths[TB_USB3_PATH_DOWN] = path;
1987 	path = tb_path_discover(tunnel->dst_port, -1, down, TB_USB3_HOPID, NULL,
1989 	if (!path)
1991 	tunnel->paths[TB_USB3_PATH_UP] = path;
1997 			     "path does not end on an USB3 adapter, cleaning up\n");
2002 		tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
2066 	struct tb_path *path;
2094 	path = tb_path_alloc(tb, down, TB_USB3_HOPID, up, TB_USB3_HOPID, 0,
2096 	if (!path) {
2100 	tb_usb3_init_path(path);
2101 	tunnel->paths[TB_USB3_PATH_DOWN] = path;
2103 	path = tb_path_alloc(tb, up, TB_USB3_HOPID, down, TB_USB3_HOPID, 0,
2105 	if (!path) {
2109 	tb_usb3_init_path(path);
2110 	tunnel->paths[TB_USB3_PATH_UP] = path;
2153  * tb_tunnel_is_invalid - check whether an activated path is still valid