Commit | Line | Data |
---|---|---|
d6cc51cd AN |
1 | /* |
2 | * Thunderbolt Cactus Ridge driver - bus logic (NHI independent) | |
3 | * | |
4 | * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com> | |
5 | */ | |
6 | ||
7 | #ifndef TB_H_ | |
8 | #define TB_H_ | |
9 | ||
e6b245cc | 10 | #include <linux/nvmem-provider.h> |
a25c8b2f | 11 | #include <linux/pci.h> |
bfe778ac | 12 | #include <linux/uuid.h> |
a25c8b2f AN |
13 | |
14 | #include "tb_regs.h" | |
d6cc51cd | 15 | #include "ctl.h" |
3e136768 | 16 | #include "dma_port.h" |
d6cc51cd | 17 | |
e6b245cc MW |
18 | /** |
19 | * struct tb_switch_nvm - Structure holding switch NVM information | |
20 | * @major: Major version number of the active NVM portion | |
21 | * @minor: Minor version number of the active NVM portion | |
22 | * @id: Identifier used with both NVM portions | |
23 | * @active: Active portion NVMem device | |
24 | * @non_active: Non-active portion NVMem device | |
25 | * @buf: Buffer where the NVM image is stored before it is written to | |
26 | * the actual NVM flash device | |
27 | * @buf_data_size: Number of bytes actually consumed by the new NVM | |
28 | * image | |
29 | * @authenticating: The switch is authenticating the new NVM | |
30 | */ | |
31 | struct tb_switch_nvm { | |
32 | u8 major; | |
33 | u8 minor; | |
34 | int id; | |
35 | struct nvmem_device *active; | |
36 | struct nvmem_device *non_active; | |
37 | void *buf; | |
38 | size_t buf_data_size; | |
39 | bool authenticating; | |
40 | }; | |
41 | ||
f67cf491 MW |
42 | /** |
43 | * enum tb_security_level - Thunderbolt security level | |
44 | * @TB_SECURITY_NONE: No security, legacy mode | |
45 | * @TB_SECURITY_USER: User approval required at minimum | |
46 | * @TB_SECURITY_SECURE: One time saved key required at minimum | |
47 | * @TB_SECURITY_DPONLY: Only tunnel Display port (and USB) | |
48 | */ | |
49 | enum tb_security_level { | |
50 | TB_SECURITY_NONE, | |
51 | TB_SECURITY_USER, | |
52 | TB_SECURITY_SECURE, | |
53 | TB_SECURITY_DPONLY, | |
54 | }; | |
55 | ||
56 | #define TB_SWITCH_KEY_SIZE 32 | |
57 | /* Each physical port contains 2 links on modern controllers */ | |
58 | #define TB_SWITCH_LINKS_PER_PHY_PORT 2 | |
59 | ||
a25c8b2f AN |
60 | /** |
61 | * struct tb_switch - a thunderbolt switch | |
bfe778ac MW |
62 | * @dev: Device for the switch |
63 | * @config: Switch configuration | |
64 | * @ports: Ports in this switch | |
3e136768 MW |
65 | * @dma_port: If the switch has port supporting DMA configuration based |
66 | * mailbox this will hold the pointer to that (%NULL | |
e6b245cc MW |
67 | * otherwise). If set it also means the switch has |
68 | * upgradeable NVM. | |
bfe778ac MW |
69 | * @tb: Pointer to the domain the switch belongs to |
70 | * @uid: Unique ID of the switch | |
71 | * @uuid: UUID of the switch (or %NULL if not supported) | |
72 | * @vendor: Vendor ID of the switch | |
73 | * @device: Device ID of the switch | |
72ee3390 MW |
74 | * @vendor_name: Name of the vendor (or %NULL if not known) |
75 | * @device_name: Name of the device (or %NULL if not known) | |
2c3c4197 | 76 | * @generation: Switch Thunderbolt generation |
bfe778ac MW |
77 | * @cap_plug_events: Offset to the plug events capability (%0 if not found) |
78 | * @is_unplugged: The switch is going away | |
79 | * @drom: DROM of the switch (%NULL if not found) | |
e6b245cc MW |
80 | * @nvm: Pointer to the NVM if the switch has one (%NULL otherwise) |
81 | * @no_nvm_upgrade: Prevent NVM upgrade of this switch | |
82 | * @safe_mode: The switch is in safe-mode | |
f67cf491 MW |
83 | * @authorized: Whether the switch is authorized by user or policy |
84 | * @work: Work used to automatically authorize a switch | |
85 | * @security_level: Switch supported security level | |
86 | * @key: Contains the key used to challenge the device or %NULL if not | |
87 | * supported. Size of the key is %TB_SWITCH_KEY_SIZE. | |
88 | * @connection_id: Connection ID used with ICM messaging | |
89 | * @connection_key: Connection key used with ICM messaging | |
90 | * @link: Root switch link this switch is connected (ICM only) | |
91 | * @depth: Depth in the chain this switch is connected (ICM only) | |
92 | * | |
93 | * When the switch is being added or removed to the domain (other | |
94 | * switches) you need to have domain lock held. For switch authorization | |
95 | * internal switch_lock is enough. | |
a25c8b2f AN |
96 | */ |
97 | struct tb_switch { | |
bfe778ac | 98 | struct device dev; |
a25c8b2f AN |
99 | struct tb_regs_switch_header config; |
100 | struct tb_port *ports; | |
3e136768 | 101 | struct tb_dma_port *dma_port; |
a25c8b2f | 102 | struct tb *tb; |
c90553b3 | 103 | u64 uid; |
7c39ffe7 | 104 | uuid_t *uuid; |
bfe778ac MW |
105 | u16 vendor; |
106 | u16 device; | |
72ee3390 MW |
107 | const char *vendor_name; |
108 | const char *device_name; | |
2c3c4197 | 109 | unsigned int generation; |
bfe778ac MW |
110 | int cap_plug_events; |
111 | bool is_unplugged; | |
cd22e73b | 112 | u8 *drom; |
e6b245cc MW |
113 | struct tb_switch_nvm *nvm; |
114 | bool no_nvm_upgrade; | |
115 | bool safe_mode; | |
f67cf491 MW |
116 | unsigned int authorized; |
117 | struct work_struct work; | |
118 | enum tb_security_level security_level; | |
119 | u8 *key; | |
120 | u8 connection_id; | |
121 | u8 connection_key; | |
122 | u8 link; | |
123 | u8 depth; | |
a25c8b2f AN |
124 | }; |
125 | ||
126 | /** | |
127 | * struct tb_port - a thunderbolt port, part of a tb_switch | |
128 | */ | |
129 | struct tb_port { | |
130 | struct tb_regs_port_header config; | |
131 | struct tb_switch *sw; | |
132 | struct tb_port *remote; /* remote port, NULL if not connected */ | |
9da672a4 | 133 | int cap_phy; /* offset, zero if not found */ |
a25c8b2f | 134 | u8 port; /* port number on switch */ |
cd22e73b AN |
135 | bool disabled; /* disabled by eeprom */ |
136 | struct tb_port *dual_link_port; | |
137 | u8 link_nr:1; | |
a25c8b2f AN |
138 | }; |
139 | ||
520b6702 AN |
140 | /** |
141 | * struct tb_path_hop - routing information for a tb_path | |
142 | * | |
143 | * Hop configuration is always done on the IN port of a switch. | |
144 | * in_port and out_port have to be on the same switch. Packets arriving on | |
145 | * in_port with "hop" = in_hop_index will get routed to through out_port. The | |
146 | * next hop to take (on out_port->remote) is determined by next_hop_index. | |
147 | * | |
148 | * in_counter_index is the index of a counter (in TB_CFG_COUNTERS) on the in | |
149 | * port. | |
150 | */ | |
151 | struct tb_path_hop { | |
152 | struct tb_port *in_port; | |
153 | struct tb_port *out_port; | |
154 | int in_hop_index; | |
155 | int in_counter_index; /* write -1 to disable counters for this hop. */ | |
156 | int next_hop_index; | |
157 | }; | |
158 | ||
159 | /** | |
160 | * enum tb_path_port - path options mask | |
161 | */ | |
162 | enum tb_path_port { | |
163 | TB_PATH_NONE = 0, | |
164 | TB_PATH_SOURCE = 1, /* activate on the first hop (out of src) */ | |
165 | TB_PATH_INTERNAL = 2, /* activate on other hops (not the first/last) */ | |
166 | TB_PATH_DESTINATION = 4, /* activate on the last hop (into dst) */ | |
167 | TB_PATH_ALL = 7, | |
168 | }; | |
169 | ||
170 | /** | |
171 | * struct tb_path - a unidirectional path between two ports | |
172 | * | |
173 | * A path consists of a number of hops (see tb_path_hop). To establish a PCIe | |
174 | * tunnel two paths have to be created between the two PCIe ports. | |
175 | * | |
176 | */ | |
177 | struct tb_path { | |
178 | struct tb *tb; | |
179 | int nfc_credits; /* non flow controlled credits */ | |
180 | enum tb_path_port ingress_shared_buffer; | |
181 | enum tb_path_port egress_shared_buffer; | |
182 | enum tb_path_port ingress_fc_enable; | |
183 | enum tb_path_port egress_fc_enable; | |
184 | ||
185 | int priority:3; | |
186 | int weight:4; | |
187 | bool drop_packages; | |
188 | bool activated; | |
189 | struct tb_path_hop *hops; | |
190 | int path_length; /* number of hops */ | |
191 | }; | |
192 | ||
9d3cce0b MW |
193 | /** |
194 | * struct tb_cm_ops - Connection manager specific operations vector | |
f67cf491 MW |
195 | * @driver_ready: Called right after control channel is started. Used by |
196 | * ICM to send driver ready message to the firmware. | |
9d3cce0b MW |
197 | * @start: Starts the domain |
198 | * @stop: Stops the domain | |
199 | * @suspend_noirq: Connection manager specific suspend_noirq | |
200 | * @resume_noirq: Connection manager specific resume_noirq | |
f67cf491 MW |
201 | * @suspend: Connection manager specific suspend |
202 | * @complete: Connection manager specific complete | |
81a54b5e | 203 | * @handle_event: Handle thunderbolt event |
f67cf491 MW |
204 | * @approve_switch: Approve switch |
205 | * @add_switch_key: Add key to switch | |
206 | * @challenge_switch_key: Challenge switch using key | |
e6b245cc | 207 | * @disconnect_pcie_paths: Disconnects PCIe paths before NVM update |
9d3cce0b MW |
208 | */ |
209 | struct tb_cm_ops { | |
f67cf491 | 210 | int (*driver_ready)(struct tb *tb); |
9d3cce0b MW |
211 | int (*start)(struct tb *tb); |
212 | void (*stop)(struct tb *tb); | |
213 | int (*suspend_noirq)(struct tb *tb); | |
214 | int (*resume_noirq)(struct tb *tb); | |
f67cf491 MW |
215 | int (*suspend)(struct tb *tb); |
216 | void (*complete)(struct tb *tb); | |
81a54b5e MW |
217 | void (*handle_event)(struct tb *tb, enum tb_cfg_pkg_type, |
218 | const void *buf, size_t size); | |
f67cf491 MW |
219 | int (*approve_switch)(struct tb *tb, struct tb_switch *sw); |
220 | int (*add_switch_key)(struct tb *tb, struct tb_switch *sw); | |
221 | int (*challenge_switch_key)(struct tb *tb, struct tb_switch *sw, | |
222 | const u8 *challenge, u8 *response); | |
e6b245cc | 223 | int (*disconnect_pcie_paths)(struct tb *tb); |
9d3cce0b | 224 | }; |
520b6702 | 225 | |
d6cc51cd AN |
226 | /** |
227 | * struct tb - main thunderbolt bus structure | |
9d3cce0b | 228 | * @dev: Domain device |
d7f781bf | 229 | * @lock: Big lock. Must be held when accessing any struct |
9d3cce0b MW |
230 | * tb_switch / struct tb_port. |
231 | * @nhi: Pointer to the NHI structure | |
232 | * @ctl: Control channel for this domain | |
233 | * @wq: Ordered workqueue for all domain specific work | |
234 | * @root_switch: Root switch of this domain | |
235 | * @cm_ops: Connection manager specific operations vector | |
236 | * @index: Linux assigned domain number | |
f67cf491 | 237 | * @security_level: Current security level |
9d3cce0b | 238 | * @privdata: Private connection manager specific data |
d6cc51cd AN |
239 | */ |
240 | struct tb { | |
9d3cce0b MW |
241 | struct device dev; |
242 | struct mutex lock; | |
d6cc51cd AN |
243 | struct tb_nhi *nhi; |
244 | struct tb_ctl *ctl; | |
9d3cce0b | 245 | struct workqueue_struct *wq; |
a25c8b2f | 246 | struct tb_switch *root_switch; |
9d3cce0b MW |
247 | const struct tb_cm_ops *cm_ops; |
248 | int index; | |
f67cf491 | 249 | enum tb_security_level security_level; |
9d3cce0b | 250 | unsigned long privdata[0]; |
d6cc51cd AN |
251 | }; |
252 | ||
9d3cce0b MW |
253 | static inline void *tb_priv(struct tb *tb) |
254 | { | |
255 | return (void *)tb->privdata; | |
256 | } | |
257 | ||
a25c8b2f AN |
258 | /* helper functions & macros */ |
259 | ||
260 | /** | |
261 | * tb_upstream_port() - return the upstream port of a switch | |
262 | * | |
263 | * Every switch has an upstream port (for the root switch it is the NHI). | |
264 | * | |
265 | * During switch alloc/init tb_upstream_port()->remote may be NULL, even for | |
266 | * non root switches (on the NHI port remote is always NULL). | |
267 | * | |
268 | * Return: Returns the upstream port of the switch. | |
269 | */ | |
270 | static inline struct tb_port *tb_upstream_port(struct tb_switch *sw) | |
271 | { | |
272 | return &sw->ports[sw->config.upstream_port_number]; | |
273 | } | |
274 | ||
275 | static inline u64 tb_route(struct tb_switch *sw) | |
276 | { | |
277 | return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo; | |
278 | } | |
279 | ||
f67cf491 MW |
280 | static inline struct tb_port *tb_port_at(u64 route, struct tb_switch *sw) |
281 | { | |
282 | u8 port; | |
283 | ||
284 | port = route >> (sw->config.depth * 8); | |
285 | if (WARN_ON(port > sw->config.max_port_number)) | |
286 | return NULL; | |
287 | return &sw->ports[port]; | |
288 | } | |
289 | ||
a25c8b2f AN |
290 | static inline int tb_sw_read(struct tb_switch *sw, void *buffer, |
291 | enum tb_cfg_space space, u32 offset, u32 length) | |
292 | { | |
293 | return tb_cfg_read(sw->tb->ctl, | |
294 | buffer, | |
295 | tb_route(sw), | |
296 | 0, | |
297 | space, | |
298 | offset, | |
299 | length); | |
300 | } | |
301 | ||
302 | static inline int tb_sw_write(struct tb_switch *sw, void *buffer, | |
303 | enum tb_cfg_space space, u32 offset, u32 length) | |
304 | { | |
305 | return tb_cfg_write(sw->tb->ctl, | |
306 | buffer, | |
307 | tb_route(sw), | |
308 | 0, | |
309 | space, | |
310 | offset, | |
311 | length); | |
312 | } | |
313 | ||
314 | static inline int tb_port_read(struct tb_port *port, void *buffer, | |
315 | enum tb_cfg_space space, u32 offset, u32 length) | |
316 | { | |
317 | return tb_cfg_read(port->sw->tb->ctl, | |
318 | buffer, | |
319 | tb_route(port->sw), | |
320 | port->port, | |
321 | space, | |
322 | offset, | |
323 | length); | |
324 | } | |
325 | ||
16a1258a | 326 | static inline int tb_port_write(struct tb_port *port, const void *buffer, |
a25c8b2f AN |
327 | enum tb_cfg_space space, u32 offset, u32 length) |
328 | { | |
329 | return tb_cfg_write(port->sw->tb->ctl, | |
330 | buffer, | |
331 | tb_route(port->sw), | |
332 | port->port, | |
333 | space, | |
334 | offset, | |
335 | length); | |
336 | } | |
337 | ||
338 | #define tb_err(tb, fmt, arg...) dev_err(&(tb)->nhi->pdev->dev, fmt, ## arg) | |
339 | #define tb_WARN(tb, fmt, arg...) dev_WARN(&(tb)->nhi->pdev->dev, fmt, ## arg) | |
340 | #define tb_warn(tb, fmt, arg...) dev_warn(&(tb)->nhi->pdev->dev, fmt, ## arg) | |
341 | #define tb_info(tb, fmt, arg...) dev_info(&(tb)->nhi->pdev->dev, fmt, ## arg) | |
342 | ||
343 | ||
344 | #define __TB_SW_PRINT(level, sw, fmt, arg...) \ | |
345 | do { \ | |
346 | struct tb_switch *__sw = (sw); \ | |
347 | level(__sw->tb, "%llx: " fmt, \ | |
348 | tb_route(__sw), ## arg); \ | |
349 | } while (0) | |
350 | #define tb_sw_WARN(sw, fmt, arg...) __TB_SW_PRINT(tb_WARN, sw, fmt, ##arg) | |
351 | #define tb_sw_warn(sw, fmt, arg...) __TB_SW_PRINT(tb_warn, sw, fmt, ##arg) | |
352 | #define tb_sw_info(sw, fmt, arg...) __TB_SW_PRINT(tb_info, sw, fmt, ##arg) | |
353 | ||
354 | ||
355 | #define __TB_PORT_PRINT(level, _port, fmt, arg...) \ | |
356 | do { \ | |
357 | struct tb_port *__port = (_port); \ | |
358 | level(__port->sw->tb, "%llx:%x: " fmt, \ | |
359 | tb_route(__port->sw), __port->port, ## arg); \ | |
360 | } while (0) | |
361 | #define tb_port_WARN(port, fmt, arg...) \ | |
362 | __TB_PORT_PRINT(tb_WARN, port, fmt, ##arg) | |
363 | #define tb_port_warn(port, fmt, arg...) \ | |
364 | __TB_PORT_PRINT(tb_warn, port, fmt, ##arg) | |
365 | #define tb_port_info(port, fmt, arg...) \ | |
366 | __TB_PORT_PRINT(tb_info, port, fmt, ##arg) | |
367 | ||
f67cf491 | 368 | struct tb *icm_probe(struct tb_nhi *nhi); |
9d3cce0b MW |
369 | struct tb *tb_probe(struct tb_nhi *nhi); |
370 | ||
371 | extern struct bus_type tb_bus_type; | |
372 | extern struct device_type tb_domain_type; | |
bfe778ac | 373 | extern struct device_type tb_switch_type; |
9d3cce0b MW |
374 | |
375 | int tb_domain_init(void); | |
376 | void tb_domain_exit(void); | |
e6b245cc | 377 | void tb_switch_exit(void); |
a25c8b2f | 378 | |
9d3cce0b MW |
379 | struct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize); |
380 | int tb_domain_add(struct tb *tb); | |
381 | void tb_domain_remove(struct tb *tb); | |
382 | int tb_domain_suspend_noirq(struct tb *tb); | |
383 | int tb_domain_resume_noirq(struct tb *tb); | |
f67cf491 MW |
384 | int tb_domain_suspend(struct tb *tb); |
385 | void tb_domain_complete(struct tb *tb); | |
386 | int tb_domain_approve_switch(struct tb *tb, struct tb_switch *sw); | |
387 | int tb_domain_approve_switch_key(struct tb *tb, struct tb_switch *sw); | |
388 | int tb_domain_challenge_switch_key(struct tb *tb, struct tb_switch *sw); | |
e6b245cc | 389 | int tb_domain_disconnect_pcie_paths(struct tb *tb); |
9d3cce0b MW |
390 | |
391 | static inline void tb_domain_put(struct tb *tb) | |
392 | { | |
393 | put_device(&tb->dev); | |
394 | } | |
d6cc51cd | 395 | |
bfe778ac MW |
396 | struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent, |
397 | u64 route); | |
e6b245cc MW |
398 | struct tb_switch *tb_switch_alloc_safe_mode(struct tb *tb, |
399 | struct device *parent, u64 route); | |
bfe778ac MW |
400 | int tb_switch_configure(struct tb_switch *sw); |
401 | int tb_switch_add(struct tb_switch *sw); | |
402 | void tb_switch_remove(struct tb_switch *sw); | |
23dd5bb4 AN |
403 | void tb_switch_suspend(struct tb_switch *sw); |
404 | int tb_switch_resume(struct tb_switch *sw); | |
405 | int tb_switch_reset(struct tb *tb, u64 route); | |
aae20bb6 | 406 | void tb_sw_set_unplugged(struct tb_switch *sw); |
053596d9 | 407 | struct tb_switch *get_switch_at_route(struct tb_switch *sw, u64 route); |
f67cf491 MW |
408 | struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link, |
409 | u8 depth); | |
7c39ffe7 | 410 | struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid); |
f67cf491 MW |
411 | |
412 | static inline unsigned int tb_switch_phy_port_from_link(unsigned int link) | |
413 | { | |
414 | return (link - 1) / TB_SWITCH_LINKS_PER_PHY_PORT; | |
415 | } | |
a25c8b2f | 416 | |
bfe778ac MW |
417 | static inline void tb_switch_put(struct tb_switch *sw) |
418 | { | |
419 | put_device(&sw->dev); | |
420 | } | |
421 | ||
422 | static inline bool tb_is_switch(const struct device *dev) | |
423 | { | |
424 | return dev->type == &tb_switch_type; | |
425 | } | |
426 | ||
427 | static inline struct tb_switch *tb_to_switch(struct device *dev) | |
428 | { | |
429 | if (tb_is_switch(dev)) | |
430 | return container_of(dev, struct tb_switch, dev); | |
431 | return NULL; | |
432 | } | |
433 | ||
9da672a4 | 434 | int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged); |
520b6702 AN |
435 | int tb_port_add_nfc_credits(struct tb_port *port, int credits); |
436 | int tb_port_clear_counter(struct tb_port *port, int counter); | |
9da672a4 | 437 | |
da2da04b MW |
438 | int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec); |
439 | int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap); | |
e2b8785e | 440 | |
520b6702 AN |
441 | struct tb_path *tb_path_alloc(struct tb *tb, int num_hops); |
442 | void tb_path_free(struct tb_path *path); | |
443 | int tb_path_activate(struct tb_path *path); | |
444 | void tb_path_deactivate(struct tb_path *path); | |
445 | bool tb_path_is_invalid(struct tb_path *path); | |
446 | ||
cd22e73b AN |
447 | int tb_drom_read(struct tb_switch *sw); |
448 | int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid); | |
c90553b3 | 449 | |
a25c8b2f AN |
450 | |
451 | static inline int tb_route_length(u64 route) | |
452 | { | |
453 | return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT; | |
454 | } | |
455 | ||
456 | static inline bool tb_is_upstream_port(struct tb_port *port) | |
457 | { | |
458 | return port == tb_upstream_port(port->sw); | |
459 | } | |
460 | ||
9da672a4 AN |
461 | /** |
462 | * tb_downstream_route() - get route to downstream switch | |
463 | * | |
464 | * Port must not be the upstream port (otherwise a loop is created). | |
465 | * | |
466 | * Return: Returns a route to the switch behind @port. | |
467 | */ | |
468 | static inline u64 tb_downstream_route(struct tb_port *port) | |
469 | { | |
470 | return tb_route(port->sw) | |
471 | | ((u64) port->port << (port->sw->config.depth * 8)); | |
472 | } | |
473 | ||
d6cc51cd | 474 | #endif |