This source file includes following definitions.
- tb_tunnel_alloc
- tb_pci_activate
- tb_pci_init_path
- tb_tunnel_discover_pci
- tb_tunnel_alloc_pci
- tb_dp_xchg_caps
- tb_dp_activate
- tb_dp_init_aux_path
- tb_dp_init_video_path
- tb_tunnel_discover_dp
- tb_tunnel_alloc_dp
- tb_dma_credits
- tb_dma_activate
- tb_dma_init_path
- tb_tunnel_alloc_dma
- tb_tunnel_free
- tb_tunnel_is_invalid
- tb_tunnel_restart
- tb_tunnel_activate
- tb_tunnel_deactivate
1
2
3
4
5
6
7
8
9 #include <linux/slab.h>
10 #include <linux/list.h>
11
12 #include "tunnel.h"
13 #include "tb.h"
14
15
16 #define TB_PCI_HOPID 8
17
18 #define TB_PCI_PATH_DOWN 0
19 #define TB_PCI_PATH_UP 1
20
21
22 #define TB_DP_AUX_TX_HOPID 8
23 #define TB_DP_AUX_RX_HOPID 8
24 #define TB_DP_VIDEO_HOPID 9
25
26 #define TB_DP_VIDEO_PATH_OUT 0
27 #define TB_DP_AUX_PATH_OUT 1
28 #define TB_DP_AUX_PATH_IN 2
29
30 #define TB_DMA_PATH_OUT 0
31 #define TB_DMA_PATH_IN 1
32
33 static const char * const tb_tunnel_names[] = { "PCI", "DP", "DMA" };
34
35 #define __TB_TUNNEL_PRINT(level, tunnel, fmt, arg...) \
36 do { \
37 struct tb_tunnel *__tunnel = (tunnel); \
38 level(__tunnel->tb, "%llx:%x <-> %llx:%x (%s): " fmt, \
39 tb_route(__tunnel->src_port->sw), \
40 __tunnel->src_port->port, \
41 tb_route(__tunnel->dst_port->sw), \
42 __tunnel->dst_port->port, \
43 tb_tunnel_names[__tunnel->type], \
44 ## arg); \
45 } while (0)
46
47 #define tb_tunnel_WARN(tunnel, fmt, arg...) \
48 __TB_TUNNEL_PRINT(tb_WARN, tunnel, fmt, ##arg)
49 #define tb_tunnel_warn(tunnel, fmt, arg...) \
50 __TB_TUNNEL_PRINT(tb_warn, tunnel, fmt, ##arg)
51 #define tb_tunnel_info(tunnel, fmt, arg...) \
52 __TB_TUNNEL_PRINT(tb_info, tunnel, fmt, ##arg)
53 #define tb_tunnel_dbg(tunnel, fmt, arg...) \
54 __TB_TUNNEL_PRINT(tb_dbg, tunnel, fmt, ##arg)
55
56 static struct tb_tunnel *tb_tunnel_alloc(struct tb *tb, size_t npaths,
57 enum tb_tunnel_type type)
58 {
59 struct tb_tunnel *tunnel;
60
61 tunnel = kzalloc(sizeof(*tunnel), GFP_KERNEL);
62 if (!tunnel)
63 return NULL;
64
65 tunnel->paths = kcalloc(npaths, sizeof(tunnel->paths[0]), GFP_KERNEL);
66 if (!tunnel->paths) {
67 tb_tunnel_free(tunnel);
68 return NULL;
69 }
70
71 INIT_LIST_HEAD(&tunnel->list);
72 tunnel->tb = tb;
73 tunnel->npaths = npaths;
74 tunnel->type = type;
75
76 return tunnel;
77 }
78
79 static int tb_pci_activate(struct tb_tunnel *tunnel, bool activate)
80 {
81 int res;
82
83 res = tb_pci_port_enable(tunnel->src_port, activate);
84 if (res)
85 return res;
86
87 if (tb_port_is_pcie_up(tunnel->dst_port))
88 return tb_pci_port_enable(tunnel->dst_port, activate);
89
90 return 0;
91 }
92
93 static void tb_pci_init_path(struct tb_path *path)
94 {
95 path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
96 path->egress_shared_buffer = TB_PATH_NONE;
97 path->ingress_fc_enable = TB_PATH_ALL;
98 path->ingress_shared_buffer = TB_PATH_NONE;
99 path->priority = 3;
100 path->weight = 1;
101 path->drop_packages = 0;
102 path->nfc_credits = 0;
103 path->hops[0].initial_credits = 7;
104 path->hops[1].initial_credits = 16;
105 }
106
107
108
109
110
111
112
113
114
115
116 struct tb_tunnel *tb_tunnel_discover_pci(struct tb *tb, struct tb_port *down)
117 {
118 struct tb_tunnel *tunnel;
119 struct tb_path *path;
120
121 if (!tb_pci_port_is_enabled(down))
122 return NULL;
123
124 tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_PCI);
125 if (!tunnel)
126 return NULL;
127
128 tunnel->activate = tb_pci_activate;
129 tunnel->src_port = down;
130
131
132
133
134
135
136 path = tb_path_discover(down, TB_PCI_HOPID, NULL, -1,
137 &tunnel->dst_port, "PCIe Up");
138 if (!path) {
139
140 tb_pci_port_enable(down, false);
141 goto err_free;
142 }
143 tunnel->paths[TB_PCI_PATH_UP] = path;
144 tb_pci_init_path(tunnel->paths[TB_PCI_PATH_UP]);
145
146 path = tb_path_discover(tunnel->dst_port, -1, down, TB_PCI_HOPID, NULL,
147 "PCIe Down");
148 if (!path)
149 goto err_deactivate;
150 tunnel->paths[TB_PCI_PATH_DOWN] = path;
151 tb_pci_init_path(tunnel->paths[TB_PCI_PATH_DOWN]);
152
153
154 if (!tb_port_is_pcie_up(tunnel->dst_port)) {
155 tb_port_warn(tunnel->dst_port,
156 "path does not end on a PCIe adapter, cleaning up\n");
157 goto err_deactivate;
158 }
159
160 if (down != tunnel->src_port) {
161 tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
162 goto err_deactivate;
163 }
164
165 if (!tb_pci_port_is_enabled(tunnel->dst_port)) {
166 tb_tunnel_warn(tunnel,
167 "tunnel is not fully activated, cleaning up\n");
168 goto err_deactivate;
169 }
170
171 tb_tunnel_dbg(tunnel, "discovered\n");
172 return tunnel;
173
174 err_deactivate:
175 tb_tunnel_deactivate(tunnel);
176 err_free:
177 tb_tunnel_free(tunnel);
178
179 return NULL;
180 }
181
182
183
184
185
186
187
188
189
190
191
192
193 struct tb_tunnel *tb_tunnel_alloc_pci(struct tb *tb, struct tb_port *up,
194 struct tb_port *down)
195 {
196 struct tb_tunnel *tunnel;
197 struct tb_path *path;
198
199 tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_PCI);
200 if (!tunnel)
201 return NULL;
202
203 tunnel->activate = tb_pci_activate;
204 tunnel->src_port = down;
205 tunnel->dst_port = up;
206
207 path = tb_path_alloc(tb, down, TB_PCI_HOPID, up, TB_PCI_HOPID, 0,
208 "PCIe Down");
209 if (!path) {
210 tb_tunnel_free(tunnel);
211 return NULL;
212 }
213 tb_pci_init_path(path);
214 tunnel->paths[TB_PCI_PATH_DOWN] = path;
215
216 path = tb_path_alloc(tb, up, TB_PCI_HOPID, down, TB_PCI_HOPID, 0,
217 "PCIe Up");
218 if (!path) {
219 tb_tunnel_free(tunnel);
220 return NULL;
221 }
222 tb_pci_init_path(path);
223 tunnel->paths[TB_PCI_PATH_UP] = path;
224
225 return tunnel;
226 }
227
228 static int tb_dp_xchg_caps(struct tb_tunnel *tunnel)
229 {
230 struct tb_port *out = tunnel->dst_port;
231 struct tb_port *in = tunnel->src_port;
232 u32 in_dp_cap, out_dp_cap;
233 int ret;
234
235
236
237
238
239 if (in->sw->generation < 2 || out->sw->generation < 2)
240 return 0;
241
242
243 ret = tb_port_read(in, &in_dp_cap, TB_CFG_PORT,
244 in->cap_adap + TB_DP_LOCAL_CAP, 1);
245 if (ret)
246 return ret;
247
248 ret = tb_port_read(out, &out_dp_cap, TB_CFG_PORT,
249 out->cap_adap + TB_DP_LOCAL_CAP, 1);
250 if (ret)
251 return ret;
252
253
254 ret = tb_port_write(out, &in_dp_cap, TB_CFG_PORT,
255 out->cap_adap + TB_DP_REMOTE_CAP, 1);
256 if (ret)
257 return ret;
258
259 return tb_port_write(in, &out_dp_cap, TB_CFG_PORT,
260 in->cap_adap + TB_DP_REMOTE_CAP, 1);
261 }
262
263 static int tb_dp_activate(struct tb_tunnel *tunnel, bool active)
264 {
265 int ret;
266
267 if (active) {
268 struct tb_path **paths;
269 int last;
270
271 paths = tunnel->paths;
272 last = paths[TB_DP_VIDEO_PATH_OUT]->path_length - 1;
273
274 tb_dp_port_set_hops(tunnel->src_port,
275 paths[TB_DP_VIDEO_PATH_OUT]->hops[0].in_hop_index,
276 paths[TB_DP_AUX_PATH_OUT]->hops[0].in_hop_index,
277 paths[TB_DP_AUX_PATH_IN]->hops[last].next_hop_index);
278
279 tb_dp_port_set_hops(tunnel->dst_port,
280 paths[TB_DP_VIDEO_PATH_OUT]->hops[last].next_hop_index,
281 paths[TB_DP_AUX_PATH_IN]->hops[0].in_hop_index,
282 paths[TB_DP_AUX_PATH_OUT]->hops[last].next_hop_index);
283 } else {
284 tb_dp_port_hpd_clear(tunnel->src_port);
285 tb_dp_port_set_hops(tunnel->src_port, 0, 0, 0);
286 if (tb_port_is_dpout(tunnel->dst_port))
287 tb_dp_port_set_hops(tunnel->dst_port, 0, 0, 0);
288 }
289
290 ret = tb_dp_port_enable(tunnel->src_port, active);
291 if (ret)
292 return ret;
293
294 if (tb_port_is_dpout(tunnel->dst_port))
295 return tb_dp_port_enable(tunnel->dst_port, active);
296
297 return 0;
298 }
299
300 static void tb_dp_init_aux_path(struct tb_path *path)
301 {
302 int i;
303
304 path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
305 path->egress_shared_buffer = TB_PATH_NONE;
306 path->ingress_fc_enable = TB_PATH_ALL;
307 path->ingress_shared_buffer = TB_PATH_NONE;
308 path->priority = 2;
309 path->weight = 1;
310
311 for (i = 0; i < path->path_length; i++)
312 path->hops[i].initial_credits = 1;
313 }
314
315 static void tb_dp_init_video_path(struct tb_path *path, bool discover)
316 {
317 u32 nfc_credits = path->hops[0].in_port->config.nfc_credits;
318
319 path->egress_fc_enable = TB_PATH_NONE;
320 path->egress_shared_buffer = TB_PATH_NONE;
321 path->ingress_fc_enable = TB_PATH_NONE;
322 path->ingress_shared_buffer = TB_PATH_NONE;
323 path->priority = 1;
324 path->weight = 1;
325
326 if (discover) {
327 path->nfc_credits = nfc_credits & TB_PORT_NFC_CREDITS_MASK;
328 } else {
329 u32 max_credits;
330
331 max_credits = (nfc_credits & TB_PORT_MAX_CREDITS_MASK) >>
332 TB_PORT_MAX_CREDITS_SHIFT;
333
334 path->nfc_credits = min(max_credits - 2, 12U);
335 }
336 }
337
338
339
340
341
342
343
344
345
346
347
348
349 struct tb_tunnel *tb_tunnel_discover_dp(struct tb *tb, struct tb_port *in)
350 {
351 struct tb_tunnel *tunnel;
352 struct tb_port *port;
353 struct tb_path *path;
354
355 if (!tb_dp_port_is_enabled(in))
356 return NULL;
357
358 tunnel = tb_tunnel_alloc(tb, 3, TB_TUNNEL_DP);
359 if (!tunnel)
360 return NULL;
361
362 tunnel->init = tb_dp_xchg_caps;
363 tunnel->activate = tb_dp_activate;
364 tunnel->src_port = in;
365
366 path = tb_path_discover(in, TB_DP_VIDEO_HOPID, NULL, -1,
367 &tunnel->dst_port, "Video");
368 if (!path) {
369
370 tb_dp_port_enable(in, false);
371 goto err_free;
372 }
373 tunnel->paths[TB_DP_VIDEO_PATH_OUT] = path;
374 tb_dp_init_video_path(tunnel->paths[TB_DP_VIDEO_PATH_OUT], true);
375
376 path = tb_path_discover(in, TB_DP_AUX_TX_HOPID, NULL, -1, NULL, "AUX TX");
377 if (!path)
378 goto err_deactivate;
379 tunnel->paths[TB_DP_AUX_PATH_OUT] = path;
380 tb_dp_init_aux_path(tunnel->paths[TB_DP_AUX_PATH_OUT]);
381
382 path = tb_path_discover(tunnel->dst_port, -1, in, TB_DP_AUX_RX_HOPID,
383 &port, "AUX RX");
384 if (!path)
385 goto err_deactivate;
386 tunnel->paths[TB_DP_AUX_PATH_IN] = path;
387 tb_dp_init_aux_path(tunnel->paths[TB_DP_AUX_PATH_IN]);
388
389
390 if (!tb_port_is_dpout(tunnel->dst_port)) {
391 tb_port_warn(in, "path does not end on a DP adapter, cleaning up\n");
392 goto err_deactivate;
393 }
394
395 if (!tb_dp_port_is_enabled(tunnel->dst_port))
396 goto err_deactivate;
397
398 if (!tb_dp_port_hpd_is_active(tunnel->dst_port))
399 goto err_deactivate;
400
401 if (port != tunnel->src_port) {
402 tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
403 goto err_deactivate;
404 }
405
406 tb_tunnel_dbg(tunnel, "discovered\n");
407 return tunnel;
408
409 err_deactivate:
410 tb_tunnel_deactivate(tunnel);
411 err_free:
412 tb_tunnel_free(tunnel);
413
414 return NULL;
415 }
416
417
418
419
420
421
422
423
424
425
426
427
428 struct tb_tunnel *tb_tunnel_alloc_dp(struct tb *tb, struct tb_port *in,
429 struct tb_port *out)
430 {
431 struct tb_tunnel *tunnel;
432 struct tb_path **paths;
433 struct tb_path *path;
434
435 if (WARN_ON(!in->cap_adap || !out->cap_adap))
436 return NULL;
437
438 tunnel = tb_tunnel_alloc(tb, 3, TB_TUNNEL_DP);
439 if (!tunnel)
440 return NULL;
441
442 tunnel->init = tb_dp_xchg_caps;
443 tunnel->activate = tb_dp_activate;
444 tunnel->src_port = in;
445 tunnel->dst_port = out;
446
447 paths = tunnel->paths;
448
449 path = tb_path_alloc(tb, in, TB_DP_VIDEO_HOPID, out, TB_DP_VIDEO_HOPID,
450 1, "Video");
451 if (!path)
452 goto err_free;
453 tb_dp_init_video_path(path, false);
454 paths[TB_DP_VIDEO_PATH_OUT] = path;
455
456 path = tb_path_alloc(tb, in, TB_DP_AUX_TX_HOPID, out,
457 TB_DP_AUX_TX_HOPID, 1, "AUX TX");
458 if (!path)
459 goto err_free;
460 tb_dp_init_aux_path(path);
461 paths[TB_DP_AUX_PATH_OUT] = path;
462
463 path = tb_path_alloc(tb, out, TB_DP_AUX_RX_HOPID, in,
464 TB_DP_AUX_RX_HOPID, 1, "AUX RX");
465 if (!path)
466 goto err_free;
467 tb_dp_init_aux_path(path);
468 paths[TB_DP_AUX_PATH_IN] = path;
469
470 return tunnel;
471
472 err_free:
473 tb_tunnel_free(tunnel);
474 return NULL;
475 }
476
477 static u32 tb_dma_credits(struct tb_port *nhi)
478 {
479 u32 max_credits;
480
481 max_credits = (nhi->config.nfc_credits & TB_PORT_MAX_CREDITS_MASK) >>
482 TB_PORT_MAX_CREDITS_SHIFT;
483 return min(max_credits, 13U);
484 }
485
486 static int tb_dma_activate(struct tb_tunnel *tunnel, bool active)
487 {
488 struct tb_port *nhi = tunnel->src_port;
489 u32 credits;
490
491 credits = active ? tb_dma_credits(nhi) : 0;
492 return tb_port_set_initial_credits(nhi, credits);
493 }
494
495 static void tb_dma_init_path(struct tb_path *path, unsigned int isb,
496 unsigned int efc, u32 credits)
497 {
498 int i;
499
500 path->egress_fc_enable = efc;
501 path->ingress_fc_enable = TB_PATH_ALL;
502 path->egress_shared_buffer = TB_PATH_NONE;
503 path->ingress_shared_buffer = isb;
504 path->priority = 5;
505 path->weight = 1;
506 path->clear_fc = true;
507
508 for (i = 0; i < path->path_length; i++)
509 path->hops[i].initial_credits = credits;
510 }
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526 struct tb_tunnel *tb_tunnel_alloc_dma(struct tb *tb, struct tb_port *nhi,
527 struct tb_port *dst, int transmit_ring,
528 int transmit_path, int receive_ring,
529 int receive_path)
530 {
531 struct tb_tunnel *tunnel;
532 struct tb_path *path;
533 u32 credits;
534
535 tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_DMA);
536 if (!tunnel)
537 return NULL;
538
539 tunnel->activate = tb_dma_activate;
540 tunnel->src_port = nhi;
541 tunnel->dst_port = dst;
542
543 credits = tb_dma_credits(nhi);
544
545 path = tb_path_alloc(tb, dst, receive_path, nhi, receive_ring, 0, "DMA RX");
546 if (!path) {
547 tb_tunnel_free(tunnel);
548 return NULL;
549 }
550 tb_dma_init_path(path, TB_PATH_NONE, TB_PATH_SOURCE | TB_PATH_INTERNAL,
551 credits);
552 tunnel->paths[TB_DMA_PATH_IN] = path;
553
554 path = tb_path_alloc(tb, nhi, transmit_ring, dst, transmit_path, 0, "DMA TX");
555 if (!path) {
556 tb_tunnel_free(tunnel);
557 return NULL;
558 }
559 tb_dma_init_path(path, TB_PATH_SOURCE, TB_PATH_ALL, credits);
560 tunnel->paths[TB_DMA_PATH_OUT] = path;
561
562 return tunnel;
563 }
564
565
566
567
568
569
570
571 void tb_tunnel_free(struct tb_tunnel *tunnel)
572 {
573 int i;
574
575 if (!tunnel)
576 return;
577
578 for (i = 0; i < tunnel->npaths; i++) {
579 if (tunnel->paths[i])
580 tb_path_free(tunnel->paths[i]);
581 }
582
583 kfree(tunnel->paths);
584 kfree(tunnel);
585 }
586
587
588
589
590
591 bool tb_tunnel_is_invalid(struct tb_tunnel *tunnel)
592 {
593 int i;
594
595 for (i = 0; i < tunnel->npaths; i++) {
596 WARN_ON(!tunnel->paths[i]->activated);
597 if (tb_path_is_invalid(tunnel->paths[i]))
598 return true;
599 }
600
601 return false;
602 }
603
604
605
606
607
608
609
610 int tb_tunnel_restart(struct tb_tunnel *tunnel)
611 {
612 int res, i;
613
614 tb_tunnel_dbg(tunnel, "activating\n");
615
616
617
618
619
620 for (i = 0; i < tunnel->npaths; i++) {
621 if (tunnel->paths[i]->activated) {
622 tb_path_deactivate(tunnel->paths[i]);
623 tunnel->paths[i]->activated = false;
624 }
625 }
626
627 if (tunnel->init) {
628 res = tunnel->init(tunnel);
629 if (res)
630 return res;
631 }
632
633 for (i = 0; i < tunnel->npaths; i++) {
634 res = tb_path_activate(tunnel->paths[i]);
635 if (res)
636 goto err;
637 }
638
639 if (tunnel->activate) {
640 res = tunnel->activate(tunnel, true);
641 if (res)
642 goto err;
643 }
644
645 return 0;
646
647 err:
648 tb_tunnel_warn(tunnel, "activation failed\n");
649 tb_tunnel_deactivate(tunnel);
650 return res;
651 }
652
653
654
655
656
657
658
659 int tb_tunnel_activate(struct tb_tunnel *tunnel)
660 {
661 int i;
662
663 for (i = 0; i < tunnel->npaths; i++) {
664 if (tunnel->paths[i]->activated) {
665 tb_tunnel_WARN(tunnel,
666 "trying to activate an already activated tunnel\n");
667 return -EINVAL;
668 }
669 }
670
671 return tb_tunnel_restart(tunnel);
672 }
673
674
675
676
677
678 void tb_tunnel_deactivate(struct tb_tunnel *tunnel)
679 {
680 int i;
681
682 tb_tunnel_dbg(tunnel, "deactivating\n");
683
684 if (tunnel->activate)
685 tunnel->activate(tunnel, false);
686
687 for (i = 0; i < tunnel->npaths; i++) {
688 if (tunnel->paths[i] && tunnel->paths[i]->activated)
689 tb_path_deactivate(tunnel->paths[i]);
690 }
691 }