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
22
23
24
25
26
27
28
29
30
31
32
33
34struct tb_switch_nvm {
35 u8 major;
36 u8 minor;
37 int id;
38 struct nvmem_device *active;
39 struct nvmem_device *non_active;
40 void *buf;
41 size_t buf_data_size;
42 bool authenticating;
43};
44
45#define TB_SWITCH_KEY_SIZE 32
46#define TB_SWITCH_MAX_DEPTH 6
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88struct tb_switch {
89 struct device dev;
90 struct tb_regs_switch_header config;
91 struct tb_port *ports;
92 struct tb_dma_port *dma_port;
93 struct tb *tb;
94 u64 uid;
95 uuid_t *uuid;
96 u16 vendor;
97 u16 device;
98 const char *vendor_name;
99 const char *device_name;
100 unsigned int generation;
101 int cap_plug_events;
102 int cap_lc;
103 bool is_unplugged;
104 u8 *drom;
105 struct tb_switch_nvm *nvm;
106 bool no_nvm_upgrade;
107 bool safe_mode;
108 bool boot;
109 bool rpm;
110 unsigned int authorized;
111 enum tb_security_level security_level;
112 u8 *key;
113 u8 connection_id;
114 u8 connection_key;
115 u8 link;
116 u8 depth;
117 struct completion rpm_complete;
118};
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136struct tb_port {
137 struct tb_regs_port_header config;
138 struct tb_switch *sw;
139 struct tb_port *remote;
140 struct tb_xdomain *xdomain;
141 int cap_phy;
142 int cap_adap;
143 u8 port;
144 bool disabled;
145 struct tb_port *dual_link_port;
146 u8 link_nr:1;
147 struct ida in_hopids;
148 struct ida out_hopids;
149};
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175struct tb_path_hop {
176 struct tb_port *in_port;
177 struct tb_port *out_port;
178 int in_hop_index;
179 int in_counter_index;
180 int next_hop_index;
181 unsigned int initial_credits;
182};
183
184
185
186
187
188
189
190
191
192enum tb_path_port {
193 TB_PATH_NONE = 0,
194 TB_PATH_SOURCE = 1,
195 TB_PATH_INTERNAL = 2,
196 TB_PATH_DESTINATION = 4,
197 TB_PATH_ALL = 7,
198};
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222struct tb_path {
223 struct tb *tb;
224 const char *name;
225 int nfc_credits;
226 enum tb_path_port ingress_shared_buffer;
227 enum tb_path_port egress_shared_buffer;
228 enum tb_path_port ingress_fc_enable;
229 enum tb_path_port egress_fc_enable;
230
231 unsigned int priority:3;
232 int weight:4;
233 bool drop_packages;
234 bool activated;
235 bool clear_fc;
236 struct tb_path_hop *hops;
237 int path_length;
238};
239
240
241#define TB_PATH_MIN_HOPID 8
242#define TB_PATH_MAX_HOPS 7
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268struct tb_cm_ops {
269 int (*driver_ready)(struct tb *tb);
270 int (*start)(struct tb *tb);
271 void (*stop)(struct tb *tb);
272 int (*suspend_noirq)(struct tb *tb);
273 int (*resume_noirq)(struct tb *tb);
274 int (*suspend)(struct tb *tb);
275 void (*complete)(struct tb *tb);
276 int (*runtime_suspend)(struct tb *tb);
277 int (*runtime_resume)(struct tb *tb);
278 int (*runtime_suspend_switch)(struct tb_switch *sw);
279 int (*runtime_resume_switch)(struct tb_switch *sw);
280 void (*handle_event)(struct tb *tb, enum tb_cfg_pkg_type,
281 const void *buf, size_t size);
282 int (*get_boot_acl)(struct tb *tb, uuid_t *uuids, size_t nuuids);
283 int (*set_boot_acl)(struct tb *tb, const uuid_t *uuids, size_t nuuids);
284 int (*approve_switch)(struct tb *tb, struct tb_switch *sw);
285 int (*add_switch_key)(struct tb *tb, struct tb_switch *sw);
286 int (*challenge_switch_key)(struct tb *tb, struct tb_switch *sw,
287 const u8 *challenge, u8 *response);
288 int (*disconnect_pcie_paths)(struct tb *tb);
289 int (*approve_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
290 int (*disconnect_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
291};
292
293static inline void *tb_priv(struct tb *tb)
294{
295 return (void *)tb->privdata;
296}
297
298#define TB_AUTOSUSPEND_DELAY 15000
299
300
301
302
303
304
305
306
307
308
309
310
311
312static inline struct tb_port *tb_upstream_port(struct tb_switch *sw)
313{
314 return &sw->ports[sw->config.upstream_port_number];
315}
316
317
318
319
320
321
322
323
324static inline bool tb_is_upstream_port(const struct tb_port *port)
325{
326 const struct tb_port *upstream_port = tb_upstream_port(port->sw);
327 return port == upstream_port || port->dual_link_port == upstream_port;
328}
329
330static inline u64 tb_route(const struct tb_switch *sw)
331{
332 return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo;
333}
334
335static inline struct tb_port *tb_port_at(u64 route, struct tb_switch *sw)
336{
337 u8 port;
338
339 port = route >> (sw->config.depth * 8);
340 if (WARN_ON(port > sw->config.max_port_number))
341 return NULL;
342 return &sw->ports[port];
343}
344
345
346
347
348
349
350
351static inline bool tb_port_has_remote(const struct tb_port *port)
352{
353 if (tb_is_upstream_port(port))
354 return false;
355 if (!port->remote)
356 return false;
357 if (port->dual_link_port && port->link_nr)
358 return false;
359
360 return true;
361}
362
363static inline bool tb_port_is_null(const struct tb_port *port)
364{
365 return port && port->port && port->config.type == TB_TYPE_PORT;
366}
367
368static inline bool tb_port_is_pcie_down(const struct tb_port *port)
369{
370 return port && port->config.type == TB_TYPE_PCIE_DOWN;
371}
372
373static inline bool tb_port_is_pcie_up(const struct tb_port *port)
374{
375 return port && port->config.type == TB_TYPE_PCIE_UP;
376}
377
378static inline bool tb_port_is_dpin(const struct tb_port *port)
379{
380 return port && port->config.type == TB_TYPE_DP_HDMI_IN;
381}
382
383static inline bool tb_port_is_dpout(const struct tb_port *port)
384{
385 return port && port->config.type == TB_TYPE_DP_HDMI_OUT;
386}
387
388static inline int tb_sw_read(struct tb_switch *sw, void *buffer,
389 enum tb_cfg_space space, u32 offset, u32 length)
390{
391 if (sw->is_unplugged)
392 return -ENODEV;
393 return tb_cfg_read(sw->tb->ctl,
394 buffer,
395 tb_route(sw),
396 0,
397 space,
398 offset,
399 length);
400}
401
402static inline int tb_sw_write(struct tb_switch *sw, void *buffer,
403 enum tb_cfg_space space, u32 offset, u32 length)
404{
405 if (sw->is_unplugged)
406 return -ENODEV;
407 return tb_cfg_write(sw->tb->ctl,
408 buffer,
409 tb_route(sw),
410 0,
411 space,
412 offset,
413 length);
414}
415
416static inline int tb_port_read(struct tb_port *port, void *buffer,
417 enum tb_cfg_space space, u32 offset, u32 length)
418{
419 if (port->sw->is_unplugged)
420 return -ENODEV;
421 return tb_cfg_read(port->sw->tb->ctl,
422 buffer,
423 tb_route(port->sw),
424 port->port,
425 space,
426 offset,
427 length);
428}
429
430static inline int tb_port_write(struct tb_port *port, const void *buffer,
431 enum tb_cfg_space space, u32 offset, u32 length)
432{
433 if (port->sw->is_unplugged)
434 return -ENODEV;
435 return tb_cfg_write(port->sw->tb->ctl,
436 buffer,
437 tb_route(port->sw),
438 port->port,
439 space,
440 offset,
441 length);
442}
443
444#define tb_err(tb, fmt, arg...) dev_err(&(tb)->nhi->pdev->dev, fmt, ## arg)
445#define tb_WARN(tb, fmt, arg...) dev_WARN(&(tb)->nhi->pdev->dev, fmt, ## arg)
446#define tb_warn(tb, fmt, arg...) dev_warn(&(tb)->nhi->pdev->dev, fmt, ## arg)
447#define tb_info(tb, fmt, arg...) dev_info(&(tb)->nhi->pdev->dev, fmt, ## arg)
448#define tb_dbg(tb, fmt, arg...) dev_dbg(&(tb)->nhi->pdev->dev, fmt, ## arg)
449
450#define __TB_SW_PRINT(level, sw, fmt, arg...) \
451 do { \
452 const struct tb_switch *__sw = (sw); \
453 level(__sw->tb, "%llx: " fmt, \
454 tb_route(__sw), ## arg); \
455 } while (0)
456#define tb_sw_WARN(sw, fmt, arg...) __TB_SW_PRINT(tb_WARN, sw, fmt, ##arg)
457#define tb_sw_warn(sw, fmt, arg...) __TB_SW_PRINT(tb_warn, sw, fmt, ##arg)
458#define tb_sw_info(sw, fmt, arg...) __TB_SW_PRINT(tb_info, sw, fmt, ##arg)
459#define tb_sw_dbg(sw, fmt, arg...) __TB_SW_PRINT(tb_dbg, sw, fmt, ##arg)
460
461#define __TB_PORT_PRINT(level, _port, fmt, arg...) \
462 do { \
463 const struct tb_port *__port = (_port); \
464 level(__port->sw->tb, "%llx:%x: " fmt, \
465 tb_route(__port->sw), __port->port, ## arg); \
466 } while (0)
467#define tb_port_WARN(port, fmt, arg...) \
468 __TB_PORT_PRINT(tb_WARN, port, fmt, ##arg)
469#define tb_port_warn(port, fmt, arg...) \
470 __TB_PORT_PRINT(tb_warn, port, fmt, ##arg)
471#define tb_port_info(port, fmt, arg...) \
472 __TB_PORT_PRINT(tb_info, port, fmt, ##arg)
473#define tb_port_dbg(port, fmt, arg...) \
474 __TB_PORT_PRINT(tb_dbg, port, fmt, ##arg)
475
476struct tb *icm_probe(struct tb_nhi *nhi);
477struct tb *tb_probe(struct tb_nhi *nhi);
478
479extern struct device_type tb_domain_type;
480extern struct device_type tb_switch_type;
481
482int tb_domain_init(void);
483void tb_domain_exit(void);
484void tb_switch_exit(void);
485int tb_xdomain_init(void);
486void tb_xdomain_exit(void);
487
488struct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize);
489int tb_domain_add(struct tb *tb);
490void tb_domain_remove(struct tb *tb);
491int tb_domain_suspend_noirq(struct tb *tb);
492int tb_domain_resume_noirq(struct tb *tb);
493int tb_domain_suspend(struct tb *tb);
494void tb_domain_complete(struct tb *tb);
495int tb_domain_runtime_suspend(struct tb *tb);
496int tb_domain_runtime_resume(struct tb *tb);
497int tb_domain_approve_switch(struct tb *tb, struct tb_switch *sw);
498int tb_domain_approve_switch_key(struct tb *tb, struct tb_switch *sw);
499int tb_domain_challenge_switch_key(struct tb *tb, struct tb_switch *sw);
500int tb_domain_disconnect_pcie_paths(struct tb *tb);
501int tb_domain_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
502int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
503int tb_domain_disconnect_all_paths(struct tb *tb);
504
505static inline struct tb *tb_domain_get(struct tb *tb)
506{
507 if (tb)
508 get_device(&tb->dev);
509 return tb;
510}
511
512static inline void tb_domain_put(struct tb *tb)
513{
514 put_device(&tb->dev);
515}
516
517struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
518 u64 route);
519struct tb_switch *tb_switch_alloc_safe_mode(struct tb *tb,
520 struct device *parent, u64 route);
521int tb_switch_configure(struct tb_switch *sw);
522int tb_switch_add(struct tb_switch *sw);
523void tb_switch_remove(struct tb_switch *sw);
524void tb_switch_suspend(struct tb_switch *sw);
525int tb_switch_resume(struct tb_switch *sw);
526int tb_switch_reset(struct tb *tb, u64 route);
527void tb_sw_set_unplugged(struct tb_switch *sw);
528struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link,
529 u8 depth);
530struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid);
531struct tb_switch *tb_switch_find_by_route(struct tb *tb, u64 route);
532
533static inline struct tb_switch *tb_switch_get(struct tb_switch *sw)
534{
535 if (sw)
536 get_device(&sw->dev);
537 return sw;
538}
539
540static inline void tb_switch_put(struct tb_switch *sw)
541{
542 put_device(&sw->dev);
543}
544
545static inline bool tb_is_switch(const struct device *dev)
546{
547 return dev->type == &tb_switch_type;
548}
549
550static inline struct tb_switch *tb_to_switch(struct device *dev)
551{
552 if (tb_is_switch(dev))
553 return container_of(dev, struct tb_switch, dev);
554 return NULL;
555}
556
557static inline struct tb_switch *tb_switch_parent(struct tb_switch *sw)
558{
559 return tb_to_switch(sw->dev.parent);
560}
561
562static inline bool tb_switch_is_lr(const struct tb_switch *sw)
563{
564 return sw->config.device_id == PCI_DEVICE_ID_INTEL_LIGHT_RIDGE;
565}
566
567static inline bool tb_switch_is_er(const struct tb_switch *sw)
568{
569 return sw->config.device_id == PCI_DEVICE_ID_INTEL_EAGLE_RIDGE;
570}
571
572static inline bool tb_switch_is_cr(const struct tb_switch *sw)
573{
574 switch (sw->config.device_id) {
575 case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_2C:
576 case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_4C:
577 return true;
578 default:
579 return false;
580 }
581}
582
583static inline bool tb_switch_is_fr(const struct tb_switch *sw)
584{
585 switch (sw->config.device_id) {
586 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_BRIDGE:
587 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_BRIDGE:
588 return true;
589 default:
590 return false;
591 }
592}
593
594int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged);
595int tb_port_add_nfc_credits(struct tb_port *port, int credits);
596int tb_port_set_initial_credits(struct tb_port *port, u32 credits);
597int tb_port_clear_counter(struct tb_port *port, int counter);
598int tb_port_alloc_in_hopid(struct tb_port *port, int hopid, int max_hopid);
599void tb_port_release_in_hopid(struct tb_port *port, int hopid);
600int tb_port_alloc_out_hopid(struct tb_port *port, int hopid, int max_hopid);
601void tb_port_release_out_hopid(struct tb_port *port, int hopid);
602struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,
603 struct tb_port *prev);
604
605int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec);
606int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap);
607bool tb_port_is_enabled(struct tb_port *port);
608
609bool tb_pci_port_is_enabled(struct tb_port *port);
610int tb_pci_port_enable(struct tb_port *port, bool enable);
611
612int tb_dp_port_hpd_is_active(struct tb_port *port);
613int tb_dp_port_hpd_clear(struct tb_port *port);
614int tb_dp_port_set_hops(struct tb_port *port, unsigned int video,
615 unsigned int aux_tx, unsigned int aux_rx);
616bool tb_dp_port_is_enabled(struct tb_port *port);
617int tb_dp_port_enable(struct tb_port *port, bool enable);
618
619struct tb_path *tb_path_discover(struct tb_port *src, int src_hopid,
620 struct tb_port *dst, int dst_hopid,
621 struct tb_port **last, const char *name);
622struct tb_path *tb_path_alloc(struct tb *tb, struct tb_port *src, int src_hopid,
623 struct tb_port *dst, int dst_hopid, int link_nr,
624 const char *name);
625void tb_path_free(struct tb_path *path);
626int tb_path_activate(struct tb_path *path);
627void tb_path_deactivate(struct tb_path *path);
628bool tb_path_is_invalid(struct tb_path *path);
629
630int tb_drom_read(struct tb_switch *sw);
631int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid);
632
633int tb_lc_read_uuid(struct tb_switch *sw, u32 *uuid);
634int tb_lc_configure_link(struct tb_switch *sw);
635void tb_lc_unconfigure_link(struct tb_switch *sw);
636int tb_lc_set_sleep(struct tb_switch *sw);
637
638static inline int tb_route_length(u64 route)
639{
640 return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT;
641}
642
643
644
645
646
647
648
649
650static inline u64 tb_downstream_route(struct tb_port *port)
651{
652 return tb_route(port->sw)
653 | ((u64) port->port << (port->sw->config.depth * 8));
654}
655
656bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type,
657 const void *buf, size_t size);
658struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent,
659 u64 route, const uuid_t *local_uuid,
660 const uuid_t *remote_uuid);
661void tb_xdomain_add(struct tb_xdomain *xd);
662void tb_xdomain_remove(struct tb_xdomain *xd);
663struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link,
664 u8 depth);
665
666#endif
667