Lines Matching defs:path
39 /* Minimum number of credits needed for PCIe path */
42 * Number of credits we try to allocate for each DMA path if not limited
46 /* Minimum number of credits for DMA path */
229 static int tb_pci_init_path(struct tb_path *path)
233 path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
234 path->egress_shared_buffer = TB_PATH_NONE;
235 path->ingress_fc_enable = TB_PATH_ALL;
236 path->ingress_shared_buffer = TB_PATH_NONE;
237 path->priority = 3;
238 path->weight = 1;
239 path->drop_packages = 0;
241 tb_path_for_each_hop(path, hop) {
266 struct tb_path *path;
283 path = tb_path_discover(down, TB_PCI_HOPID, NULL, -1,
285 if (!path) {
290 tunnel->paths[TB_PCI_PATH_UP] = path;
294 path = tb_path_discover(tunnel->dst_port, -1, down, TB_PCI_HOPID, NULL,
296 if (!path)
298 tunnel->paths[TB_PCI_PATH_DOWN] = path;
305 "path does not end on a PCIe adapter, cleaning up\n");
310 tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
346 struct tb_path *path;
356 path = tb_path_alloc(tb, down, TB_PCI_HOPID, up, TB_PCI_HOPID, 0,
358 if (!path)
360 tunnel->paths[TB_PCI_PATH_DOWN] = path;
361 if (tb_pci_init_path(path))
364 path = tb_path_alloc(tb, up, TB_PCI_HOPID, down, TB_PCI_HOPID, 0,
366 if (!path)
368 tunnel->paths[TB_PCI_PATH_UP] = path;
369 if (tb_pci_init_path(path))
1175 static void tb_dp_init_aux_path(struct tb_path *path)
1179 path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
1180 path->egress_shared_buffer = TB_PATH_NONE;
1181 path->ingress_fc_enable = TB_PATH_ALL;
1182 path->ingress_shared_buffer = TB_PATH_NONE;
1183 path->priority = 2;
1184 path->weight = 1;
1186 tb_path_for_each_hop(path, hop)
1219 static int tb_dp_init_video_path(struct tb_path *path)
1223 path->egress_fc_enable = TB_PATH_NONE;
1224 path->egress_shared_buffer = TB_PATH_NONE;
1225 path->ingress_fc_enable = TB_PATH_NONE;
1226 path->ingress_shared_buffer = TB_PATH_NONE;
1227 path->priority = 1;
1228 path->weight = 1;
1230 tb_path_for_each_hop(path, hop) {
1299 struct tb_path *path;
1317 path = tb_path_discover(in, TB_DP_VIDEO_HOPID, NULL, -1,
1319 if (!path) {
1324 tunnel->paths[TB_DP_VIDEO_PATH_OUT] = path;
1328 path = tb_path_discover(in, TB_DP_AUX_TX_HOPID, NULL, -1, NULL, "AUX TX",
1330 if (!path)
1332 tunnel->paths[TB_DP_AUX_PATH_OUT] = path;
1335 path = tb_path_discover(tunnel->dst_port, -1, in, TB_DP_AUX_RX_HOPID,
1337 if (!path)
1339 tunnel->paths[TB_DP_AUX_PATH_IN] = path;
1344 tb_port_warn(in, "path does not end on a DP adapter, cleaning up\n");
1355 tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
1394 struct tb_path *path;
1417 path = tb_path_alloc(tb, in, TB_DP_VIDEO_HOPID, out, TB_DP_VIDEO_HOPID,
1419 if (!path)
1421 tb_dp_init_video_path(path);
1422 paths[TB_DP_VIDEO_PATH_OUT] = path;
1424 path = tb_path_alloc(tb, in, TB_DP_AUX_TX_HOPID, out,
1426 if (!path)
1428 tb_dp_init_aux_path(path);
1429 paths[TB_DP_AUX_PATH_OUT] = path;
1431 path = tb_path_alloc(tb, out, TB_DP_AUX_RX_HOPID, in,
1433 if (!path)
1435 tb_dp_init_aux_path(path);
1436 paths[TB_DP_AUX_PATH_IN] = path;
1467 * DMA path cannot be established.
1475 tb_port_dbg(port, "reserving %u credits for DMA path\n",
1491 static int tb_dma_init_rx_path(struct tb_path *path, unsigned int credits)
1496 path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
1497 path->ingress_fc_enable = TB_PATH_ALL;
1498 path->egress_shared_buffer = TB_PATH_NONE;
1499 path->ingress_shared_buffer = TB_PATH_NONE;
1500 path->priority = 5;
1501 path->weight = 1;
1502 path->clear_fc = true;
1509 hop = &path->hops[0];
1514 for (i = 1; i < path->path_length; i++) {
1517 ret = tb_dma_reserve_credits(&path->hops[i], credits);
1526 static int tb_dma_init_tx_path(struct tb_path *path, unsigned int credits)
1530 path->egress_fc_enable = TB_PATH_ALL;
1531 path->ingress_fc_enable = TB_PATH_ALL;
1532 path->egress_shared_buffer = TB_PATH_NONE;
1533 path->ingress_shared_buffer = TB_PATH_NONE;
1534 path->priority = 5;
1535 path->weight = 1;
1536 path->clear_fc = true;
1538 tb_path_for_each_hop(path, hop) {
1556 tb_port_dbg(port, "released %u DMA path credits\n",
1561 static void tb_dma_deinit_path(struct tb_path *path)
1565 tb_path_for_each_hop(path, hop)
1587 * other domain. Set to %-1 if TX path is not needed.
1590 * other domain. Set to %-1 if RX path is not needed.
1601 struct tb_path *path;
1627 path = tb_path_alloc(tb, dst, receive_path, nhi, receive_ring, 0,
1629 if (!path)
1631 tunnel->paths[i++] = path;
1632 if (tb_dma_init_rx_path(path, credits)) {
1633 tb_tunnel_dbg(tunnel, "not enough buffers for RX path\n");
1639 path = tb_path_alloc(tb, nhi, transmit_ring, dst, transmit_path, 0,
1641 if (!path)
1643 tunnel->paths[i++] = path;
1644 if (tb_dma_init_tx_path(path, credits)) {
1645 tb_tunnel_dbg(tunnel, "not enough buffers for TX path\n");
1681 const struct tb_path *path = tunnel->paths[i];
1683 if (!path)
1686 if (tb_port_is_nhi(path->hops[0].in_port))
1687 tx_path = path;
1688 else if (tb_port_is_nhi(path->hops[path->path_length - 1].out_port))
1689 rx_path = path;
1866 static void tb_usb3_init_path(struct tb_path *path)
1870 path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
1871 path->egress_shared_buffer = TB_PATH_NONE;
1872 path->ingress_fc_enable = TB_PATH_ALL;
1873 path->ingress_shared_buffer = TB_PATH_NONE;
1874 path->priority = 3;
1875 path->weight = 3;
1876 path->drop_packages = 0;
1878 tb_path_for_each_hop(path, hop)
1896 struct tb_path *path;
1913 path = tb_path_discover(down, TB_USB3_HOPID, NULL, -1,
1915 if (!path) {
1920 tunnel->paths[TB_USB3_PATH_DOWN] = path;
1923 path = tb_path_discover(tunnel->dst_port, -1, down, TB_USB3_HOPID, NULL,
1925 if (!path)
1927 tunnel->paths[TB_USB3_PATH_UP] = path;
1933 "path does not end on an USB3 adapter, cleaning up\n");
1938 tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
2002 struct tb_path *path;
2035 path = tb_path_alloc(tb, down, TB_USB3_HOPID, up, TB_USB3_HOPID, 0,
2037 if (!path) {
2041 tb_usb3_init_path(path);
2042 tunnel->paths[TB_USB3_PATH_DOWN] = path;
2044 path = tb_path_alloc(tb, up, TB_USB3_HOPID, down, TB_USB3_HOPID, 0,
2046 if (!path) {
2050 tb_usb3_init_path(path);
2051 tunnel->paths[TB_USB3_PATH_UP] = path;
2094 * tb_tunnel_is_invalid - check whether an activated path is still valid