1
2
3
4
5
6
7
8
9#ifndef TB_H_
10#define TB_H_
11
12#include <linux/nvmem-provider.h>
13#include <linux/pci.h>
14#include <linux/thunderbolt.h>
15#include <linux/uuid.h>
16
17#include "tb_regs.h"
18#include "ctl.h"
19#include "dma_port.h"
20
21#define NVM_MIN_SIZE SZ_32K
22#define NVM_MAX_SIZE SZ_512K
23
24
25#define NVM_DEVID 0x05
26#define NVM_VERSION 0x08
27#define NVM_FLASH_SIZE 0x45
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47struct tb_nvm {
48 struct device *dev;
49 u8 major;
50 u8 minor;
51 int id;
52 struct nvmem_device *active;
53 struct nvmem_device *non_active;
54 void *buf;
55 size_t buf_data_size;
56 bool authenticating;
57 bool flushed;
58};
59
60#define TB_SWITCH_KEY_SIZE 32
61#define TB_SWITCH_MAX_DEPTH 6
62#define USB4_SWITCH_MAX_DEPTH 5
63
64
65
66
67
68
69
70
71
72
73
74enum tb_switch_tmu_rate {
75 TB_SWITCH_TMU_RATE_OFF = 0,
76 TB_SWITCH_TMU_RATE_HIFI = 16,
77 TB_SWITCH_TMU_RATE_NORMAL = 1000,
78};
79
80
81
82
83
84
85
86
87
88
89struct tb_switch_tmu {
90 int cap;
91 bool has_ucap;
92 enum tb_switch_tmu_rate rate;
93 bool unidirectional;
94};
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142struct tb_switch {
143 struct device dev;
144 struct tb_regs_switch_header config;
145 struct tb_port *ports;
146 struct tb_dma_port *dma_port;
147 struct tb_switch_tmu tmu;
148 struct tb *tb;
149 u64 uid;
150 uuid_t *uuid;
151 u16 vendor;
152 u16 device;
153 const char *vendor_name;
154 const char *device_name;
155 unsigned int link_speed;
156 unsigned int link_width;
157 bool link_usb4;
158 unsigned int generation;
159 int cap_plug_events;
160 int cap_lc;
161 bool is_unplugged;
162 u8 *drom;
163 struct tb_nvm *nvm;
164 bool no_nvm_upgrade;
165 bool safe_mode;
166 bool boot;
167 bool rpm;
168 unsigned int authorized;
169 enum tb_security_level security_level;
170 struct dentry *debugfs_dir;
171 u8 *key;
172 u8 connection_id;
173 u8 connection_key;
174 u8 link;
175 u8 depth;
176 struct completion rpm_complete;
177 unsigned long quirks;
178};
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200struct tb_port {
201 struct tb_regs_port_header config;
202 struct tb_switch *sw;
203 struct tb_port *remote;
204 struct tb_xdomain *xdomain;
205 int cap_phy;
206 int cap_tmu;
207 int cap_adap;
208 int cap_usb4;
209 u8 port;
210 bool disabled;
211 bool bonded;
212 struct tb_port *dual_link_port;
213 u8 link_nr:1;
214 struct ida in_hopids;
215 struct ida out_hopids;
216 struct list_head list;
217};
218
219
220
221
222
223
224
225
226
227
228
229
230struct tb_retimer {
231 struct device dev;
232 struct tb *tb;
233 u8 index;
234 u32 vendor;
235 u32 device;
236 struct tb_port *port;
237 struct tb_nvm *nvm;
238 u32 auth_status;
239};
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265struct tb_path_hop {
266 struct tb_port *in_port;
267 struct tb_port *out_port;
268 int in_hop_index;
269 int in_counter_index;
270 int next_hop_index;
271 unsigned int initial_credits;
272};
273
274
275
276
277
278
279
280
281
282enum tb_path_port {
283 TB_PATH_NONE = 0,
284 TB_PATH_SOURCE = 1,
285 TB_PATH_INTERNAL = 2,
286 TB_PATH_DESTINATION = 4,
287 TB_PATH_ALL = 7,
288};
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312struct tb_path {
313 struct tb *tb;
314 const char *name;
315 int nfc_credits;
316 enum tb_path_port ingress_shared_buffer;
317 enum tb_path_port egress_shared_buffer;
318 enum tb_path_port ingress_fc_enable;
319 enum tb_path_port egress_fc_enable;
320
321 unsigned int priority:3;
322 int weight:4;
323 bool drop_packages;
324 bool activated;
325 bool clear_fc;
326 struct tb_path_hop *hops;
327 int path_length;
328};
329
330
331#define TB_PATH_MIN_HOPID 8
332
333
334
335
336#define TB_PATH_MAX_HOPS (7 * 2)
337
338
339#define TB_WAKE_ON_CONNECT BIT(0)
340#define TB_WAKE_ON_DISCONNECT BIT(1)
341#define TB_WAKE_ON_USB4 BIT(2)
342#define TB_WAKE_ON_USB3 BIT(3)
343#define TB_WAKE_ON_PCIE BIT(4)
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379struct tb_cm_ops {
380 int (*driver_ready)(struct tb *tb);
381 int (*start)(struct tb *tb);
382 void (*stop)(struct tb *tb);
383 int (*suspend_noirq)(struct tb *tb);
384 int (*resume_noirq)(struct tb *tb);
385 int (*suspend)(struct tb *tb);
386 int (*freeze_noirq)(struct tb *tb);
387 int (*thaw_noirq)(struct tb *tb);
388 void (*complete)(struct tb *tb);
389 int (*runtime_suspend)(struct tb *tb);
390 int (*runtime_resume)(struct tb *tb);
391 int (*runtime_suspend_switch)(struct tb_switch *sw);
392 int (*runtime_resume_switch)(struct tb_switch *sw);
393 void (*handle_event)(struct tb *tb, enum tb_cfg_pkg_type,
394 const void *buf, size_t size);
395 int (*get_boot_acl)(struct tb *tb, uuid_t *uuids, size_t nuuids);
396 int (*set_boot_acl)(struct tb *tb, const uuid_t *uuids, size_t nuuids);
397 int (*approve_switch)(struct tb *tb, struct tb_switch *sw);
398 int (*add_switch_key)(struct tb *tb, struct tb_switch *sw);
399 int (*challenge_switch_key)(struct tb *tb, struct tb_switch *sw,
400 const u8 *challenge, u8 *response);
401 int (*disconnect_pcie_paths)(struct tb *tb);
402 int (*approve_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
403 int (*disconnect_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
404 int (*usb4_switch_op)(struct tb_switch *sw, u16 opcode, u32 *metadata,
405 u8 *status, const void *tx_data, size_t tx_data_len,
406 void *rx_data, size_t rx_data_len);
407 int (*usb4_switch_nvm_authenticate_status)(struct tb_switch *sw,
408 u32 *status);
409};
410
411static inline void *tb_priv(struct tb *tb)
412{
413 return (void *)tb->privdata;
414}
415
416#define TB_AUTOSUSPEND_DELAY 15000
417
418
419
420
421
422
423
424
425
426
427
428
429
430static inline struct tb_port *tb_upstream_port(struct tb_switch *sw)
431{
432 return &sw->ports[sw->config.upstream_port_number];
433}
434
435
436
437
438
439
440
441
442static inline bool tb_is_upstream_port(const struct tb_port *port)
443{
444 const struct tb_port *upstream_port = tb_upstream_port(port->sw);
445 return port == upstream_port || port->dual_link_port == upstream_port;
446}
447
448static inline u64 tb_route(const struct tb_switch *sw)
449{
450 return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo;
451}
452
453static inline struct tb_port *tb_port_at(u64 route, struct tb_switch *sw)
454{
455 u8 port;
456
457 port = route >> (sw->config.depth * 8);
458 if (WARN_ON(port > sw->config.max_port_number))
459 return NULL;
460 return &sw->ports[port];
461}
462
463
464
465
466
467
468
469static inline bool tb_port_has_remote(const struct tb_port *port)
470{
471 if (tb_is_upstream_port(port))
472 return false;
473 if (!port->remote)
474 return false;
475 if (port->dual_link_port && port->link_nr)
476 return false;
477
478 return true;
479}
480
481static inline bool tb_port_is_null(const struct tb_port *port)
482{
483 return port && port->port && port->config.type == TB_TYPE_PORT;
484}
485
486static inline bool tb_port_is_nhi(const struct tb_port *port)
487{
488 return port && port->config.type == TB_TYPE_NHI;
489}
490
491static inline bool tb_port_is_pcie_down(const struct tb_port *port)
492{
493 return port && port->config.type == TB_TYPE_PCIE_DOWN;
494}
495
496static inline bool tb_port_is_pcie_up(const struct tb_port *port)
497{
498 return port && port->config.type == TB_TYPE_PCIE_UP;
499}
500
501static inline bool tb_port_is_dpin(const struct tb_port *port)
502{
503 return port && port->config.type == TB_TYPE_DP_HDMI_IN;
504}
505
506static inline bool tb_port_is_dpout(const struct tb_port *port)
507{
508 return port && port->config.type == TB_TYPE_DP_HDMI_OUT;
509}
510
511static inline bool tb_port_is_usb3_down(const struct tb_port *port)
512{
513 return port && port->config.type == TB_TYPE_USB3_DOWN;
514}
515
516static inline bool tb_port_is_usb3_up(const struct tb_port *port)
517{
518 return port && port->config.type == TB_TYPE_USB3_UP;
519}
520
521static inline int tb_sw_read(struct tb_switch *sw, void *buffer,
522 enum tb_cfg_space space, u32 offset, u32 length)
523{
524 if (sw->is_unplugged)
525 return -ENODEV;
526 return tb_cfg_read(sw->tb->ctl,
527 buffer,
528 tb_route(sw),
529 0,
530 space,
531 offset,
532 length);
533}
534
535static inline int tb_sw_write(struct tb_switch *sw, const void *buffer,
536 enum tb_cfg_space space, u32 offset, u32 length)
537{
538 if (sw->is_unplugged)
539 return -ENODEV;
540 return tb_cfg_write(sw->tb->ctl,
541 buffer,
542 tb_route(sw),
543 0,
544 space,
545 offset,
546 length);
547}
548
549static inline int tb_port_read(struct tb_port *port, void *buffer,
550 enum tb_cfg_space space, u32 offset, u32 length)
551{
552 if (port->sw->is_unplugged)
553 return -ENODEV;
554 return tb_cfg_read(port->sw->tb->ctl,
555 buffer,
556 tb_route(port->sw),
557 port->port,
558 space,
559 offset,
560 length);
561}
562
563static inline int tb_port_write(struct tb_port *port, const void *buffer,
564 enum tb_cfg_space space, u32 offset, u32 length)
565{
566 if (port->sw->is_unplugged)
567 return -ENODEV;
568 return tb_cfg_write(port->sw->tb->ctl,
569 buffer,
570 tb_route(port->sw),
571 port->port,
572 space,
573 offset,
574 length);
575}
576
577#define tb_err(tb, fmt, arg...) dev_err(&(tb)->nhi->pdev->dev, fmt, ## arg)
578#define tb_WARN(tb, fmt, arg...) dev_WARN(&(tb)->nhi->pdev->dev, fmt, ## arg)
579#define tb_warn(tb, fmt, arg...) dev_warn(&(tb)->nhi->pdev->dev, fmt, ## arg)
580#define tb_info(tb, fmt, arg...) dev_info(&(tb)->nhi->pdev->dev, fmt, ## arg)
581#define tb_dbg(tb, fmt, arg...) dev_dbg(&(tb)->nhi->pdev->dev, fmt, ## arg)
582
583#define __TB_SW_PRINT(level, sw, fmt, arg...) \
584 do { \
585 const struct tb_switch *__sw = (sw); \
586 level(__sw->tb, "%llx: " fmt, \
587 tb_route(__sw), ## arg); \
588 } while (0)
589#define tb_sw_WARN(sw, fmt, arg...) __TB_SW_PRINT(tb_WARN, sw, fmt, ##arg)
590#define tb_sw_warn(sw, fmt, arg...) __TB_SW_PRINT(tb_warn, sw, fmt, ##arg)
591#define tb_sw_info(sw, fmt, arg...) __TB_SW_PRINT(tb_info, sw, fmt, ##arg)
592#define tb_sw_dbg(sw, fmt, arg...) __TB_SW_PRINT(tb_dbg, sw, fmt, ##arg)
593
594#define __TB_PORT_PRINT(level, _port, fmt, arg...) \
595 do { \
596 const struct tb_port *__port = (_port); \
597 level(__port->sw->tb, "%llx:%x: " fmt, \
598 tb_route(__port->sw), __port->port, ## arg); \
599 } while (0)
600#define tb_port_WARN(port, fmt, arg...) \
601 __TB_PORT_PRINT(tb_WARN, port, fmt, ##arg)
602#define tb_port_warn(port, fmt, arg...) \
603 __TB_PORT_PRINT(tb_warn, port, fmt, ##arg)
604#define tb_port_info(port, fmt, arg...) \
605 __TB_PORT_PRINT(tb_info, port, fmt, ##arg)
606#define tb_port_dbg(port, fmt, arg...) \
607 __TB_PORT_PRINT(tb_dbg, port, fmt, ##arg)
608
609struct tb *icm_probe(struct tb_nhi *nhi);
610struct tb *tb_probe(struct tb_nhi *nhi);
611
612extern struct device_type tb_domain_type;
613extern struct device_type tb_retimer_type;
614extern struct device_type tb_switch_type;
615
616int tb_domain_init(void);
617void tb_domain_exit(void);
618int tb_xdomain_init(void);
619void tb_xdomain_exit(void);
620
621struct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize);
622int tb_domain_add(struct tb *tb);
623void tb_domain_remove(struct tb *tb);
624int tb_domain_suspend_noirq(struct tb *tb);
625int tb_domain_resume_noirq(struct tb *tb);
626int tb_domain_suspend(struct tb *tb);
627int tb_domain_freeze_noirq(struct tb *tb);
628int tb_domain_thaw_noirq(struct tb *tb);
629void tb_domain_complete(struct tb *tb);
630int tb_domain_runtime_suspend(struct tb *tb);
631int tb_domain_runtime_resume(struct tb *tb);
632int tb_domain_approve_switch(struct tb *tb, struct tb_switch *sw);
633int tb_domain_approve_switch_key(struct tb *tb, struct tb_switch *sw);
634int tb_domain_challenge_switch_key(struct tb *tb, struct tb_switch *sw);
635int tb_domain_disconnect_pcie_paths(struct tb *tb);
636int tb_domain_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
637int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
638int tb_domain_disconnect_all_paths(struct tb *tb);
639
640static inline struct tb *tb_domain_get(struct tb *tb)
641{
642 if (tb)
643 get_device(&tb->dev);
644 return tb;
645}
646
647static inline void tb_domain_put(struct tb *tb)
648{
649 put_device(&tb->dev);
650}
651
652struct tb_nvm *tb_nvm_alloc(struct device *dev);
653int tb_nvm_add_active(struct tb_nvm *nvm, size_t size, nvmem_reg_read_t reg_read);
654int tb_nvm_write_buf(struct tb_nvm *nvm, unsigned int offset, void *val,
655 size_t bytes);
656int tb_nvm_add_non_active(struct tb_nvm *nvm, size_t size,
657 nvmem_reg_write_t reg_write);
658void tb_nvm_free(struct tb_nvm *nvm);
659void tb_nvm_exit(void);
660
661struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
662 u64 route);
663struct tb_switch *tb_switch_alloc_safe_mode(struct tb *tb,
664 struct device *parent, u64 route);
665int tb_switch_configure(struct tb_switch *sw);
666int tb_switch_add(struct tb_switch *sw);
667void tb_switch_remove(struct tb_switch *sw);
668void tb_switch_suspend(struct tb_switch *sw, bool runtime);
669int tb_switch_resume(struct tb_switch *sw);
670int tb_switch_reset(struct tb_switch *sw);
671void tb_sw_set_unplugged(struct tb_switch *sw);
672struct tb_port *tb_switch_find_port(struct tb_switch *sw,
673 enum tb_port_type type);
674struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link,
675 u8 depth);
676struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid);
677struct tb_switch *tb_switch_find_by_route(struct tb *tb, u64 route);
678
679
680
681
682
683
684
685
686#define tb_switch_for_each_port(sw, p) \
687 for ((p) = &(sw)->ports[1]; \
688 (p) <= &(sw)->ports[(sw)->config.max_port_number]; (p)++)
689
690static inline struct tb_switch *tb_switch_get(struct tb_switch *sw)
691{
692 if (sw)
693 get_device(&sw->dev);
694 return sw;
695}
696
697static inline void tb_switch_put(struct tb_switch *sw)
698{
699 put_device(&sw->dev);
700}
701
702static inline bool tb_is_switch(const struct device *dev)
703{
704 return dev->type == &tb_switch_type;
705}
706
707static inline struct tb_switch *tb_to_switch(struct device *dev)
708{
709 if (tb_is_switch(dev))
710 return container_of(dev, struct tb_switch, dev);
711 return NULL;
712}
713
714static inline struct tb_switch *tb_switch_parent(struct tb_switch *sw)
715{
716 return tb_to_switch(sw->dev.parent);
717}
718
719static inline bool tb_switch_is_light_ridge(const struct tb_switch *sw)
720{
721 return sw->config.vendor_id == PCI_VENDOR_ID_INTEL &&
722 sw->config.device_id == PCI_DEVICE_ID_INTEL_LIGHT_RIDGE;
723}
724
725static inline bool tb_switch_is_eagle_ridge(const struct tb_switch *sw)
726{
727 return sw->config.vendor_id == PCI_VENDOR_ID_INTEL &&
728 sw->config.device_id == PCI_DEVICE_ID_INTEL_EAGLE_RIDGE;
729}
730
731static inline bool tb_switch_is_cactus_ridge(const struct tb_switch *sw)
732{
733 if (sw->config.vendor_id == PCI_VENDOR_ID_INTEL) {
734 switch (sw->config.device_id) {
735 case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_2C:
736 case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_4C:
737 return true;
738 }
739 }
740 return false;
741}
742
743static inline bool tb_switch_is_falcon_ridge(const struct tb_switch *sw)
744{
745 if (sw->config.vendor_id == PCI_VENDOR_ID_INTEL) {
746 switch (sw->config.device_id) {
747 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_BRIDGE:
748 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_BRIDGE:
749 return true;
750 }
751 }
752 return false;
753}
754
755static inline bool tb_switch_is_alpine_ridge(const struct tb_switch *sw)
756{
757 if (sw->config.vendor_id == PCI_VENDOR_ID_INTEL) {
758 switch (sw->config.device_id) {
759 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_2C_BRIDGE:
760 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_LP_BRIDGE:
761 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_4C_BRIDGE:
762 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_2C_BRIDGE:
763 return true;
764 }
765 }
766 return false;
767}
768
769static inline bool tb_switch_is_titan_ridge(const struct tb_switch *sw)
770{
771 if (sw->config.vendor_id == PCI_VENDOR_ID_INTEL) {
772 switch (sw->config.device_id) {
773 case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_2C_BRIDGE:
774 case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_4C_BRIDGE:
775 case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_DD_BRIDGE:
776 return true;
777 }
778 }
779 return false;
780}
781
782static inline bool tb_switch_is_ice_lake(const struct tb_switch *sw)
783{
784 if (sw->config.vendor_id == PCI_VENDOR_ID_INTEL) {
785 switch (sw->config.device_id) {
786 case PCI_DEVICE_ID_INTEL_ICL_NHI0:
787 case PCI_DEVICE_ID_INTEL_ICL_NHI1:
788 return true;
789 }
790 }
791 return false;
792}
793
794static inline bool tb_switch_is_tiger_lake(const struct tb_switch *sw)
795{
796 if (sw->config.vendor_id == PCI_VENDOR_ID_INTEL) {
797 switch (sw->config.device_id) {
798 case PCI_DEVICE_ID_INTEL_TGL_NHI0:
799 case PCI_DEVICE_ID_INTEL_TGL_NHI1:
800 case PCI_DEVICE_ID_INTEL_TGL_H_NHI0:
801 case PCI_DEVICE_ID_INTEL_TGL_H_NHI1:
802 return true;
803 }
804 }
805 return false;
806}
807
808
809
810
811
812
813
814static inline bool tb_switch_is_usb4(const struct tb_switch *sw)
815{
816 return sw->config.thunderbolt_version == USB4_VERSION_1_0;
817}
818
819
820
821
822
823
824
825
826
827
828static inline bool tb_switch_is_icm(const struct tb_switch *sw)
829{
830 return !sw->config.enabled;
831}
832
833int tb_switch_lane_bonding_enable(struct tb_switch *sw);
834void tb_switch_lane_bonding_disable(struct tb_switch *sw);
835int tb_switch_configure_link(struct tb_switch *sw);
836void tb_switch_unconfigure_link(struct tb_switch *sw);
837
838bool tb_switch_query_dp_resource(struct tb_switch *sw, struct tb_port *in);
839int tb_switch_alloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
840void tb_switch_dealloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
841
842int tb_switch_tmu_init(struct tb_switch *sw);
843int tb_switch_tmu_post_time(struct tb_switch *sw);
844int tb_switch_tmu_disable(struct tb_switch *sw);
845int tb_switch_tmu_enable(struct tb_switch *sw);
846
847static inline bool tb_switch_tmu_is_enabled(const struct tb_switch *sw)
848{
849 return sw->tmu.rate == TB_SWITCH_TMU_RATE_HIFI &&
850 !sw->tmu.unidirectional;
851}
852
853int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged);
854int tb_port_add_nfc_credits(struct tb_port *port, int credits);
855int tb_port_set_initial_credits(struct tb_port *port, u32 credits);
856int tb_port_clear_counter(struct tb_port *port, int counter);
857int tb_port_unlock(struct tb_port *port);
858int tb_port_enable(struct tb_port *port);
859int tb_port_disable(struct tb_port *port);
860int tb_port_alloc_in_hopid(struct tb_port *port, int hopid, int max_hopid);
861void tb_port_release_in_hopid(struct tb_port *port, int hopid);
862int tb_port_alloc_out_hopid(struct tb_port *port, int hopid, int max_hopid);
863void tb_port_release_out_hopid(struct tb_port *port, int hopid);
864struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,
865 struct tb_port *prev);
866
867
868
869
870
871
872
873
874
875#define tb_for_each_port_on_path(src, dst, p) \
876 for ((p) = tb_next_port_on_path((src), (dst), NULL); (p); \
877 (p) = tb_next_port_on_path((src), (dst), (p)))
878
879int tb_port_get_link_speed(struct tb_port *port);
880int tb_port_get_link_width(struct tb_port *port);
881int tb_port_state(struct tb_port *port);
882int tb_port_lane_bonding_enable(struct tb_port *port);
883void tb_port_lane_bonding_disable(struct tb_port *port);
884
885int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec);
886int tb_switch_find_cap(struct tb_switch *sw, enum tb_switch_cap cap);
887int tb_switch_next_cap(struct tb_switch *sw, unsigned int offset);
888int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap);
889int tb_port_next_cap(struct tb_port *port, unsigned int offset);
890bool tb_port_is_enabled(struct tb_port *port);
891
892bool tb_usb3_port_is_enabled(struct tb_port *port);
893int tb_usb3_port_enable(struct tb_port *port, bool enable);
894
895bool tb_pci_port_is_enabled(struct tb_port *port);
896int tb_pci_port_enable(struct tb_port *port, bool enable);
897
898int tb_dp_port_hpd_is_active(struct tb_port *port);
899int tb_dp_port_hpd_clear(struct tb_port *port);
900int tb_dp_port_set_hops(struct tb_port *port, unsigned int video,
901 unsigned int aux_tx, unsigned int aux_rx);
902bool tb_dp_port_is_enabled(struct tb_port *port);
903int tb_dp_port_enable(struct tb_port *port, bool enable);
904
905struct tb_path *tb_path_discover(struct tb_port *src, int src_hopid,
906 struct tb_port *dst, int dst_hopid,
907 struct tb_port **last, const char *name);
908struct tb_path *tb_path_alloc(struct tb *tb, struct tb_port *src, int src_hopid,
909 struct tb_port *dst, int dst_hopid, int link_nr,
910 const char *name);
911void tb_path_free(struct tb_path *path);
912int tb_path_activate(struct tb_path *path);
913void tb_path_deactivate(struct tb_path *path);
914bool tb_path_is_invalid(struct tb_path *path);
915bool tb_path_port_on_path(const struct tb_path *path,
916 const struct tb_port *port);
917
918int tb_drom_read(struct tb_switch *sw);
919int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid);
920
921int tb_lc_read_uuid(struct tb_switch *sw, u32 *uuid);
922int tb_lc_configure_port(struct tb_port *port);
923void tb_lc_unconfigure_port(struct tb_port *port);
924int tb_lc_configure_xdomain(struct tb_port *port);
925void tb_lc_unconfigure_xdomain(struct tb_port *port);
926int tb_lc_set_wake(struct tb_switch *sw, unsigned int flags);
927int tb_lc_set_sleep(struct tb_switch *sw);
928bool tb_lc_lane_bonding_possible(struct tb_switch *sw);
929bool tb_lc_dp_sink_query(struct tb_switch *sw, struct tb_port *in);
930int tb_lc_dp_sink_alloc(struct tb_switch *sw, struct tb_port *in);
931int tb_lc_dp_sink_dealloc(struct tb_switch *sw, struct tb_port *in);
932int tb_lc_force_power(struct tb_switch *sw);
933
934static inline int tb_route_length(u64 route)
935{
936 return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT;
937}
938
939
940
941
942
943
944
945
946static inline u64 tb_downstream_route(struct tb_port *port)
947{
948 return tb_route(port->sw)
949 | ((u64) port->port << (port->sw->config.depth * 8));
950}
951
952bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type,
953 const void *buf, size_t size);
954struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent,
955 u64 route, const uuid_t *local_uuid,
956 const uuid_t *remote_uuid);
957void tb_xdomain_add(struct tb_xdomain *xd);
958void tb_xdomain_remove(struct tb_xdomain *xd);
959struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link,
960 u8 depth);
961
962int tb_retimer_scan(struct tb_port *port);
963void tb_retimer_remove_all(struct tb_port *port);
964
965static inline bool tb_is_retimer(const struct device *dev)
966{
967 return dev->type == &tb_retimer_type;
968}
969
970static inline struct tb_retimer *tb_to_retimer(struct device *dev)
971{
972 if (tb_is_retimer(dev))
973 return container_of(dev, struct tb_retimer, dev);
974 return NULL;
975}
976
977int usb4_switch_setup(struct tb_switch *sw);
978int usb4_switch_read_uid(struct tb_switch *sw, u64 *uid);
979int usb4_switch_drom_read(struct tb_switch *sw, unsigned int address, void *buf,
980 size_t size);
981bool usb4_switch_lane_bonding_possible(struct tb_switch *sw);
982int usb4_switch_set_wake(struct tb_switch *sw, unsigned int flags);
983int usb4_switch_set_sleep(struct tb_switch *sw);
984int usb4_switch_nvm_sector_size(struct tb_switch *sw);
985int usb4_switch_nvm_read(struct tb_switch *sw, unsigned int address, void *buf,
986 size_t size);
987int usb4_switch_nvm_write(struct tb_switch *sw, unsigned int address,
988 const void *buf, size_t size);
989int usb4_switch_nvm_authenticate(struct tb_switch *sw);
990int usb4_switch_nvm_authenticate_status(struct tb_switch *sw, u32 *status);
991bool usb4_switch_query_dp_resource(struct tb_switch *sw, struct tb_port *in);
992int usb4_switch_alloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
993int usb4_switch_dealloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
994struct tb_port *usb4_switch_map_pcie_down(struct tb_switch *sw,
995 const struct tb_port *port);
996struct tb_port *usb4_switch_map_usb3_down(struct tb_switch *sw,
997 const struct tb_port *port);
998
999int usb4_port_unlock(struct tb_port *port);
1000int usb4_port_configure(struct tb_port *port);
1001void usb4_port_unconfigure(struct tb_port *port);
1002int usb4_port_configure_xdomain(struct tb_port *port);
1003void usb4_port_unconfigure_xdomain(struct tb_port *port);
1004int usb4_port_enumerate_retimers(struct tb_port *port);
1005
1006int usb4_port_retimer_read(struct tb_port *port, u8 index, u8 reg, void *buf,
1007 u8 size);
1008int usb4_port_retimer_write(struct tb_port *port, u8 index, u8 reg,
1009 const void *buf, u8 size);
1010int usb4_port_retimer_is_last(struct tb_port *port, u8 index);
1011int usb4_port_retimer_nvm_sector_size(struct tb_port *port, u8 index);
1012int usb4_port_retimer_nvm_write(struct tb_port *port, u8 index,
1013 unsigned int address, const void *buf,
1014 size_t size);
1015int usb4_port_retimer_nvm_authenticate(struct tb_port *port, u8 index);
1016int usb4_port_retimer_nvm_authenticate_status(struct tb_port *port, u8 index,
1017 u32 *status);
1018int usb4_port_retimer_nvm_read(struct tb_port *port, u8 index,
1019 unsigned int address, void *buf, size_t size);
1020
1021int usb4_usb3_port_max_link_rate(struct tb_port *port);
1022int usb4_usb3_port_actual_link_rate(struct tb_port *port);
1023int usb4_usb3_port_allocated_bandwidth(struct tb_port *port, int *upstream_bw,
1024 int *downstream_bw);
1025int usb4_usb3_port_allocate_bandwidth(struct tb_port *port, int *upstream_bw,
1026 int *downstream_bw);
1027int usb4_usb3_port_release_bandwidth(struct tb_port *port, int *upstream_bw,
1028 int *downstream_bw);
1029
1030
1031#define QUIRK_FORCE_POWER_LINK_CONTROLLER BIT(0)
1032
1033void tb_check_quirks(struct tb_switch *sw);
1034
1035#ifdef CONFIG_ACPI
1036void tb_acpi_add_links(struct tb_nhi *nhi);
1037#else
1038static inline void tb_acpi_add_links(struct tb_nhi *nhi) { }
1039#endif
1040
1041#ifdef CONFIG_DEBUG_FS
1042void tb_debugfs_init(void);
1043void tb_debugfs_exit(void);
1044void tb_switch_debugfs_init(struct tb_switch *sw);
1045void tb_switch_debugfs_remove(struct tb_switch *sw);
1046void tb_service_debugfs_init(struct tb_service *svc);
1047void tb_service_debugfs_remove(struct tb_service *svc);
1048#else
1049static inline void tb_debugfs_init(void) { }
1050static inline void tb_debugfs_exit(void) { }
1051static inline void tb_switch_debugfs_init(struct tb_switch *sw) { }
1052static inline void tb_switch_debugfs_remove(struct tb_switch *sw) { }
1053static inline void tb_service_debugfs_init(struct tb_service *svc) { }
1054static inline void tb_service_debugfs_remove(struct tb_service *svc) { }
1055#endif
1056
1057#ifdef CONFIG_USB4_KUNIT_TEST
1058int tb_test_init(void);
1059void tb_test_exit(void);
1060#else
1061static inline int tb_test_init(void) { return 0; }
1062static inline void tb_test_exit(void) { }
1063#endif
1064
1065#endif
1066