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
141struct tb_switch {
142 struct device dev;
143 struct tb_regs_switch_header config;
144 struct tb_port *ports;
145 struct tb_dma_port *dma_port;
146 struct tb_switch_tmu tmu;
147 struct tb *tb;
148 u64 uid;
149 uuid_t *uuid;
150 u16 vendor;
151 u16 device;
152 const char *vendor_name;
153 const char *device_name;
154 unsigned int link_speed;
155 unsigned int link_width;
156 bool link_usb4;
157 unsigned int generation;
158 int cap_plug_events;
159 int cap_lc;
160 bool is_unplugged;
161 u8 *drom;
162 struct tb_nvm *nvm;
163 bool no_nvm_upgrade;
164 bool safe_mode;
165 bool boot;
166 bool rpm;
167 unsigned int authorized;
168 enum tb_security_level security_level;
169 u8 *key;
170 u8 connection_id;
171 u8 connection_key;
172 u8 link;
173 u8 depth;
174 struct completion rpm_complete;
175 unsigned long quirks;
176};
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198struct tb_port {
199 struct tb_regs_port_header config;
200 struct tb_switch *sw;
201 struct tb_port *remote;
202 struct tb_xdomain *xdomain;
203 int cap_phy;
204 int cap_tmu;
205 int cap_adap;
206 int cap_usb4;
207 u8 port;
208 bool disabled;
209 bool bonded;
210 struct tb_port *dual_link_port;
211 u8 link_nr:1;
212 struct ida in_hopids;
213 struct ida out_hopids;
214 struct list_head list;
215};
216
217
218
219
220
221
222
223
224
225
226
227
228struct tb_retimer {
229 struct device dev;
230 struct tb *tb;
231 u8 index;
232 u32 vendor;
233 u32 device;
234 struct tb_port *port;
235 struct tb_nvm *nvm;
236 u32 auth_status;
237};
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263struct tb_path_hop {
264 struct tb_port *in_port;
265 struct tb_port *out_port;
266 int in_hop_index;
267 int in_counter_index;
268 int next_hop_index;
269 unsigned int initial_credits;
270};
271
272
273
274
275
276
277
278
279
280enum tb_path_port {
281 TB_PATH_NONE = 0,
282 TB_PATH_SOURCE = 1,
283 TB_PATH_INTERNAL = 2,
284 TB_PATH_DESTINATION = 4,
285 TB_PATH_ALL = 7,
286};
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310struct tb_path {
311 struct tb *tb;
312 const char *name;
313 int nfc_credits;
314 enum tb_path_port ingress_shared_buffer;
315 enum tb_path_port egress_shared_buffer;
316 enum tb_path_port ingress_fc_enable;
317 enum tb_path_port egress_fc_enable;
318
319 unsigned int priority:3;
320 int weight:4;
321 bool drop_packages;
322 bool activated;
323 bool clear_fc;
324 struct tb_path_hop *hops;
325 int path_length;
326};
327
328
329#define TB_PATH_MIN_HOPID 8
330
331
332
333
334#define TB_PATH_MAX_HOPS (7 * 2)
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360struct tb_cm_ops {
361 int (*driver_ready)(struct tb *tb);
362 int (*start)(struct tb *tb);
363 void (*stop)(struct tb *tb);
364 int (*suspend_noirq)(struct tb *tb);
365 int (*resume_noirq)(struct tb *tb);
366 int (*suspend)(struct tb *tb);
367 void (*complete)(struct tb *tb);
368 int (*runtime_suspend)(struct tb *tb);
369 int (*runtime_resume)(struct tb *tb);
370 int (*runtime_suspend_switch)(struct tb_switch *sw);
371 int (*runtime_resume_switch)(struct tb_switch *sw);
372 void (*handle_event)(struct tb *tb, enum tb_cfg_pkg_type,
373 const void *buf, size_t size);
374 int (*get_boot_acl)(struct tb *tb, uuid_t *uuids, size_t nuuids);
375 int (*set_boot_acl)(struct tb *tb, const uuid_t *uuids, size_t nuuids);
376 int (*approve_switch)(struct tb *tb, struct tb_switch *sw);
377 int (*add_switch_key)(struct tb *tb, struct tb_switch *sw);
378 int (*challenge_switch_key)(struct tb *tb, struct tb_switch *sw,
379 const u8 *challenge, u8 *response);
380 int (*disconnect_pcie_paths)(struct tb *tb);
381 int (*approve_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
382 int (*disconnect_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
383};
384
385static inline void *tb_priv(struct tb *tb)
386{
387 return (void *)tb->privdata;
388}
389
390#define TB_AUTOSUSPEND_DELAY 15000
391
392
393
394
395
396
397
398
399
400
401
402
403
404static inline struct tb_port *tb_upstream_port(struct tb_switch *sw)
405{
406 return &sw->ports[sw->config.upstream_port_number];
407}
408
409
410
411
412
413
414
415
416static inline bool tb_is_upstream_port(const struct tb_port *port)
417{
418 const struct tb_port *upstream_port = tb_upstream_port(port->sw);
419 return port == upstream_port || port->dual_link_port == upstream_port;
420}
421
422static inline u64 tb_route(const struct tb_switch *sw)
423{
424 return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo;
425}
426
427static inline struct tb_port *tb_port_at(u64 route, struct tb_switch *sw)
428{
429 u8 port;
430
431 port = route >> (sw->config.depth * 8);
432 if (WARN_ON(port > sw->config.max_port_number))
433 return NULL;
434 return &sw->ports[port];
435}
436
437
438
439
440
441
442
443static inline bool tb_port_has_remote(const struct tb_port *port)
444{
445 if (tb_is_upstream_port(port))
446 return false;
447 if (!port->remote)
448 return false;
449 if (port->dual_link_port && port->link_nr)
450 return false;
451
452 return true;
453}
454
455static inline bool tb_port_is_null(const struct tb_port *port)
456{
457 return port && port->port && port->config.type == TB_TYPE_PORT;
458}
459
460static inline bool tb_port_is_pcie_down(const struct tb_port *port)
461{
462 return port && port->config.type == TB_TYPE_PCIE_DOWN;
463}
464
465static inline bool tb_port_is_pcie_up(const struct tb_port *port)
466{
467 return port && port->config.type == TB_TYPE_PCIE_UP;
468}
469
470static inline bool tb_port_is_dpin(const struct tb_port *port)
471{
472 return port && port->config.type == TB_TYPE_DP_HDMI_IN;
473}
474
475static inline bool tb_port_is_dpout(const struct tb_port *port)
476{
477 return port && port->config.type == TB_TYPE_DP_HDMI_OUT;
478}
479
480static inline bool tb_port_is_usb3_down(const struct tb_port *port)
481{
482 return port && port->config.type == TB_TYPE_USB3_DOWN;
483}
484
485static inline bool tb_port_is_usb3_up(const struct tb_port *port)
486{
487 return port && port->config.type == TB_TYPE_USB3_UP;
488}
489
490static inline int tb_sw_read(struct tb_switch *sw, void *buffer,
491 enum tb_cfg_space space, u32 offset, u32 length)
492{
493 if (sw->is_unplugged)
494 return -ENODEV;
495 return tb_cfg_read(sw->tb->ctl,
496 buffer,
497 tb_route(sw),
498 0,
499 space,
500 offset,
501 length);
502}
503
504static inline int tb_sw_write(struct tb_switch *sw, const void *buffer,
505 enum tb_cfg_space space, u32 offset, u32 length)
506{
507 if (sw->is_unplugged)
508 return -ENODEV;
509 return tb_cfg_write(sw->tb->ctl,
510 buffer,
511 tb_route(sw),
512 0,
513 space,
514 offset,
515 length);
516}
517
518static inline int tb_port_read(struct tb_port *port, void *buffer,
519 enum tb_cfg_space space, u32 offset, u32 length)
520{
521 if (port->sw->is_unplugged)
522 return -ENODEV;
523 return tb_cfg_read(port->sw->tb->ctl,
524 buffer,
525 tb_route(port->sw),
526 port->port,
527 space,
528 offset,
529 length);
530}
531
532static inline int tb_port_write(struct tb_port *port, const void *buffer,
533 enum tb_cfg_space space, u32 offset, u32 length)
534{
535 if (port->sw->is_unplugged)
536 return -ENODEV;
537 return tb_cfg_write(port->sw->tb->ctl,
538 buffer,
539 tb_route(port->sw),
540 port->port,
541 space,
542 offset,
543 length);
544}
545
546#define tb_err(tb, fmt, arg...) dev_err(&(tb)->nhi->pdev->dev, fmt, ## arg)
547#define tb_WARN(tb, fmt, arg...) dev_WARN(&(tb)->nhi->pdev->dev, fmt, ## arg)
548#define tb_warn(tb, fmt, arg...) dev_warn(&(tb)->nhi->pdev->dev, fmt, ## arg)
549#define tb_info(tb, fmt, arg...) dev_info(&(tb)->nhi->pdev->dev, fmt, ## arg)
550#define tb_dbg(tb, fmt, arg...) dev_dbg(&(tb)->nhi->pdev->dev, fmt, ## arg)
551
552#define __TB_SW_PRINT(level, sw, fmt, arg...) \
553 do { \
554 const struct tb_switch *__sw = (sw); \
555 level(__sw->tb, "%llx: " fmt, \
556 tb_route(__sw), ## arg); \
557 } while (0)
558#define tb_sw_WARN(sw, fmt, arg...) __TB_SW_PRINT(tb_WARN, sw, fmt, ##arg)
559#define tb_sw_warn(sw, fmt, arg...) __TB_SW_PRINT(tb_warn, sw, fmt, ##arg)
560#define tb_sw_info(sw, fmt, arg...) __TB_SW_PRINT(tb_info, sw, fmt, ##arg)
561#define tb_sw_dbg(sw, fmt, arg...) __TB_SW_PRINT(tb_dbg, sw, fmt, ##arg)
562
563#define __TB_PORT_PRINT(level, _port, fmt, arg...) \
564 do { \
565 const struct tb_port *__port = (_port); \
566 level(__port->sw->tb, "%llx:%x: " fmt, \
567 tb_route(__port->sw), __port->port, ## arg); \
568 } while (0)
569#define tb_port_WARN(port, fmt, arg...) \
570 __TB_PORT_PRINT(tb_WARN, port, fmt, ##arg)
571#define tb_port_warn(port, fmt, arg...) \
572 __TB_PORT_PRINT(tb_warn, port, fmt, ##arg)
573#define tb_port_info(port, fmt, arg...) \
574 __TB_PORT_PRINT(tb_info, port, fmt, ##arg)
575#define tb_port_dbg(port, fmt, arg...) \
576 __TB_PORT_PRINT(tb_dbg, port, fmt, ##arg)
577
578struct tb *icm_probe(struct tb_nhi *nhi);
579struct tb *tb_probe(struct tb_nhi *nhi);
580
581extern struct device_type tb_domain_type;
582extern struct device_type tb_retimer_type;
583extern struct device_type tb_switch_type;
584
585int tb_domain_init(void);
586void tb_domain_exit(void);
587int tb_xdomain_init(void);
588void tb_xdomain_exit(void);
589
590struct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize);
591int tb_domain_add(struct tb *tb);
592void tb_domain_remove(struct tb *tb);
593int tb_domain_suspend_noirq(struct tb *tb);
594int tb_domain_resume_noirq(struct tb *tb);
595int tb_domain_suspend(struct tb *tb);
596void tb_domain_complete(struct tb *tb);
597int tb_domain_runtime_suspend(struct tb *tb);
598int tb_domain_runtime_resume(struct tb *tb);
599int tb_domain_approve_switch(struct tb *tb, struct tb_switch *sw);
600int tb_domain_approve_switch_key(struct tb *tb, struct tb_switch *sw);
601int tb_domain_challenge_switch_key(struct tb *tb, struct tb_switch *sw);
602int tb_domain_disconnect_pcie_paths(struct tb *tb);
603int tb_domain_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
604int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
605int tb_domain_disconnect_all_paths(struct tb *tb);
606
607static inline struct tb *tb_domain_get(struct tb *tb)
608{
609 if (tb)
610 get_device(&tb->dev);
611 return tb;
612}
613
614static inline void tb_domain_put(struct tb *tb)
615{
616 put_device(&tb->dev);
617}
618
619struct tb_nvm *tb_nvm_alloc(struct device *dev);
620int tb_nvm_add_active(struct tb_nvm *nvm, size_t size, nvmem_reg_read_t reg_read);
621int tb_nvm_write_buf(struct tb_nvm *nvm, unsigned int offset, void *val,
622 size_t bytes);
623int tb_nvm_add_non_active(struct tb_nvm *nvm, size_t size,
624 nvmem_reg_write_t reg_write);
625void tb_nvm_free(struct tb_nvm *nvm);
626void tb_nvm_exit(void);
627
628struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
629 u64 route);
630struct tb_switch *tb_switch_alloc_safe_mode(struct tb *tb,
631 struct device *parent, u64 route);
632int tb_switch_configure(struct tb_switch *sw);
633int tb_switch_add(struct tb_switch *sw);
634void tb_switch_remove(struct tb_switch *sw);
635void tb_switch_suspend(struct tb_switch *sw);
636int tb_switch_resume(struct tb_switch *sw);
637int tb_switch_reset(struct tb *tb, u64 route);
638void tb_sw_set_unplugged(struct tb_switch *sw);
639struct tb_port *tb_switch_find_port(struct tb_switch *sw,
640 enum tb_port_type type);
641struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link,
642 u8 depth);
643struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid);
644struct tb_switch *tb_switch_find_by_route(struct tb *tb, u64 route);
645
646
647
648
649
650
651
652
653#define tb_switch_for_each_port(sw, p) \
654 for ((p) = &(sw)->ports[1]; \
655 (p) <= &(sw)->ports[(sw)->config.max_port_number]; (p)++)
656
657static inline struct tb_switch *tb_switch_get(struct tb_switch *sw)
658{
659 if (sw)
660 get_device(&sw->dev);
661 return sw;
662}
663
664static inline void tb_switch_put(struct tb_switch *sw)
665{
666 put_device(&sw->dev);
667}
668
669static inline bool tb_is_switch(const struct device *dev)
670{
671 return dev->type == &tb_switch_type;
672}
673
674static inline struct tb_switch *tb_to_switch(struct device *dev)
675{
676 if (tb_is_switch(dev))
677 return container_of(dev, struct tb_switch, dev);
678 return NULL;
679}
680
681static inline struct tb_switch *tb_switch_parent(struct tb_switch *sw)
682{
683 return tb_to_switch(sw->dev.parent);
684}
685
686static inline bool tb_switch_is_light_ridge(const struct tb_switch *sw)
687{
688 return sw->config.device_id == PCI_DEVICE_ID_INTEL_LIGHT_RIDGE;
689}
690
691static inline bool tb_switch_is_eagle_ridge(const struct tb_switch *sw)
692{
693 return sw->config.device_id == PCI_DEVICE_ID_INTEL_EAGLE_RIDGE;
694}
695
696static inline bool tb_switch_is_cactus_ridge(const struct tb_switch *sw)
697{
698 switch (sw->config.device_id) {
699 case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_2C:
700 case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_4C:
701 return true;
702 default:
703 return false;
704 }
705}
706
707static inline bool tb_switch_is_falcon_ridge(const struct tb_switch *sw)
708{
709 switch (sw->config.device_id) {
710 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_BRIDGE:
711 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_BRIDGE:
712 return true;
713 default:
714 return false;
715 }
716}
717
718static inline bool tb_switch_is_alpine_ridge(const struct tb_switch *sw)
719{
720 switch (sw->config.device_id) {
721 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_2C_BRIDGE:
722 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_LP_BRIDGE:
723 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_4C_BRIDGE:
724 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_2C_BRIDGE:
725 return true;
726 default:
727 return false;
728 }
729}
730
731static inline bool tb_switch_is_titan_ridge(const struct tb_switch *sw)
732{
733 switch (sw->config.device_id) {
734 case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_2C_BRIDGE:
735 case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_4C_BRIDGE:
736 case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_DD_BRIDGE:
737 return true;
738 default:
739 return false;
740 }
741}
742
743
744
745
746
747
748
749static inline bool tb_switch_is_usb4(const struct tb_switch *sw)
750{
751 return sw->config.thunderbolt_version == USB4_VERSION_1_0;
752}
753
754
755
756
757
758
759
760
761
762
763static inline bool tb_switch_is_icm(const struct tb_switch *sw)
764{
765 return !sw->config.enabled;
766}
767
768int tb_switch_lane_bonding_enable(struct tb_switch *sw);
769void tb_switch_lane_bonding_disable(struct tb_switch *sw);
770
771bool tb_switch_query_dp_resource(struct tb_switch *sw, struct tb_port *in);
772int tb_switch_alloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
773void tb_switch_dealloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
774
775int tb_switch_tmu_init(struct tb_switch *sw);
776int tb_switch_tmu_post_time(struct tb_switch *sw);
777int tb_switch_tmu_disable(struct tb_switch *sw);
778int tb_switch_tmu_enable(struct tb_switch *sw);
779
780static inline bool tb_switch_tmu_is_enabled(const struct tb_switch *sw)
781{
782 return sw->tmu.rate == TB_SWITCH_TMU_RATE_HIFI &&
783 !sw->tmu.unidirectional;
784}
785
786int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged);
787int tb_port_add_nfc_credits(struct tb_port *port, int credits);
788int tb_port_set_initial_credits(struct tb_port *port, u32 credits);
789int tb_port_clear_counter(struct tb_port *port, int counter);
790int tb_port_unlock(struct tb_port *port);
791int tb_port_alloc_in_hopid(struct tb_port *port, int hopid, int max_hopid);
792void tb_port_release_in_hopid(struct tb_port *port, int hopid);
793int tb_port_alloc_out_hopid(struct tb_port *port, int hopid, int max_hopid);
794void tb_port_release_out_hopid(struct tb_port *port, int hopid);
795struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,
796 struct tb_port *prev);
797
798
799
800
801
802
803
804
805
806#define tb_for_each_port_on_path(src, dst, p) \
807 for ((p) = tb_next_port_on_path((src), (dst), NULL); (p); \
808 (p) = tb_next_port_on_path((src), (dst), (p)))
809
810int tb_port_get_link_speed(struct tb_port *port);
811
812int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec);
813int tb_switch_find_cap(struct tb_switch *sw, enum tb_switch_cap cap);
814int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap);
815bool tb_port_is_enabled(struct tb_port *port);
816
817bool tb_usb3_port_is_enabled(struct tb_port *port);
818int tb_usb3_port_enable(struct tb_port *port, bool enable);
819
820bool tb_pci_port_is_enabled(struct tb_port *port);
821int tb_pci_port_enable(struct tb_port *port, bool enable);
822
823int tb_dp_port_hpd_is_active(struct tb_port *port);
824int tb_dp_port_hpd_clear(struct tb_port *port);
825int tb_dp_port_set_hops(struct tb_port *port, unsigned int video,
826 unsigned int aux_tx, unsigned int aux_rx);
827bool tb_dp_port_is_enabled(struct tb_port *port);
828int tb_dp_port_enable(struct tb_port *port, bool enable);
829
830struct tb_path *tb_path_discover(struct tb_port *src, int src_hopid,
831 struct tb_port *dst, int dst_hopid,
832 struct tb_port **last, const char *name);
833struct tb_path *tb_path_alloc(struct tb *tb, struct tb_port *src, int src_hopid,
834 struct tb_port *dst, int dst_hopid, int link_nr,
835 const char *name);
836void tb_path_free(struct tb_path *path);
837int tb_path_activate(struct tb_path *path);
838void tb_path_deactivate(struct tb_path *path);
839bool tb_path_is_invalid(struct tb_path *path);
840bool tb_path_port_on_path(const struct tb_path *path,
841 const struct tb_port *port);
842
843int tb_drom_read(struct tb_switch *sw);
844int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid);
845
846int tb_lc_read_uuid(struct tb_switch *sw, u32 *uuid);
847int tb_lc_configure_link(struct tb_switch *sw);
848void tb_lc_unconfigure_link(struct tb_switch *sw);
849int tb_lc_set_sleep(struct tb_switch *sw);
850bool tb_lc_lane_bonding_possible(struct tb_switch *sw);
851bool tb_lc_dp_sink_query(struct tb_switch *sw, struct tb_port *in);
852int tb_lc_dp_sink_alloc(struct tb_switch *sw, struct tb_port *in);
853int tb_lc_dp_sink_dealloc(struct tb_switch *sw, struct tb_port *in);
854int tb_lc_force_power(struct tb_switch *sw);
855
856static inline int tb_route_length(u64 route)
857{
858 return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT;
859}
860
861
862
863
864
865
866
867
868static inline u64 tb_downstream_route(struct tb_port *port)
869{
870 return tb_route(port->sw)
871 | ((u64) port->port << (port->sw->config.depth * 8));
872}
873
874bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type,
875 const void *buf, size_t size);
876struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent,
877 u64 route, const uuid_t *local_uuid,
878 const uuid_t *remote_uuid);
879void tb_xdomain_add(struct tb_xdomain *xd);
880void tb_xdomain_remove(struct tb_xdomain *xd);
881struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link,
882 u8 depth);
883
884int tb_retimer_scan(struct tb_port *port);
885void tb_retimer_remove_all(struct tb_port *port);
886
887static inline bool tb_is_retimer(const struct device *dev)
888{
889 return dev->type == &tb_retimer_type;
890}
891
892static inline struct tb_retimer *tb_to_retimer(struct device *dev)
893{
894 if (tb_is_retimer(dev))
895 return container_of(dev, struct tb_retimer, dev);
896 return NULL;
897}
898
899int usb4_switch_setup(struct tb_switch *sw);
900int usb4_switch_read_uid(struct tb_switch *sw, u64 *uid);
901int usb4_switch_drom_read(struct tb_switch *sw, unsigned int address, void *buf,
902 size_t size);
903int usb4_switch_configure_link(struct tb_switch *sw);
904void usb4_switch_unconfigure_link(struct tb_switch *sw);
905bool usb4_switch_lane_bonding_possible(struct tb_switch *sw);
906int usb4_switch_set_sleep(struct tb_switch *sw);
907int usb4_switch_nvm_sector_size(struct tb_switch *sw);
908int usb4_switch_nvm_read(struct tb_switch *sw, unsigned int address, void *buf,
909 size_t size);
910int usb4_switch_nvm_write(struct tb_switch *sw, unsigned int address,
911 const void *buf, size_t size);
912int usb4_switch_nvm_authenticate(struct tb_switch *sw);
913bool usb4_switch_query_dp_resource(struct tb_switch *sw, struct tb_port *in);
914int usb4_switch_alloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
915int usb4_switch_dealloc_dp_resource(struct tb_switch *sw, struct tb_port *in);
916struct tb_port *usb4_switch_map_pcie_down(struct tb_switch *sw,
917 const struct tb_port *port);
918struct tb_port *usb4_switch_map_usb3_down(struct tb_switch *sw,
919 const struct tb_port *port);
920
921int usb4_port_unlock(struct tb_port *port);
922int usb4_port_enumerate_retimers(struct tb_port *port);
923
924int usb4_port_retimer_read(struct tb_port *port, u8 index, u8 reg, void *buf,
925 u8 size);
926int usb4_port_retimer_write(struct tb_port *port, u8 index, u8 reg,
927 const void *buf, u8 size);
928int usb4_port_retimer_is_last(struct tb_port *port, u8 index);
929int usb4_port_retimer_nvm_sector_size(struct tb_port *port, u8 index);
930int usb4_port_retimer_nvm_write(struct tb_port *port, u8 index,
931 unsigned int address, const void *buf,
932 size_t size);
933int usb4_port_retimer_nvm_authenticate(struct tb_port *port, u8 index);
934int usb4_port_retimer_nvm_authenticate_status(struct tb_port *port, u8 index,
935 u32 *status);
936int usb4_port_retimer_nvm_read(struct tb_port *port, u8 index,
937 unsigned int address, void *buf, size_t size);
938
939int usb4_usb3_port_max_link_rate(struct tb_port *port);
940int usb4_usb3_port_actual_link_rate(struct tb_port *port);
941int usb4_usb3_port_allocated_bandwidth(struct tb_port *port, int *upstream_bw,
942 int *downstream_bw);
943int usb4_usb3_port_allocate_bandwidth(struct tb_port *port, int *upstream_bw,
944 int *downstream_bw);
945int usb4_usb3_port_release_bandwidth(struct tb_port *port, int *upstream_bw,
946 int *downstream_bw);
947
948
949#define QUIRK_FORCE_POWER_LINK_CONTROLLER BIT(0)
950
951void tb_check_quirks(struct tb_switch *sw);
952
953#endif
954