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