1 /* SPDX-License-Identifier: GPL-2.0 */
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
11 #include <linux/nvmem-provider.h>
12 #include <linux/pci.h>
13 #include <linux/thunderbolt.h>
14 #include <linux/uuid.h>
15
16 #include "tb_regs.h"
17 #include "ctl.h"
18 #include "dma_port.h"
19
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
44 #define TB_SWITCH_KEY_SIZE 32
45
46 /**
47 * struct tb_switch - a thunderbolt switch
48 * @dev: Device for the switch
49 * @config: Switch configuration
50 * @ports: Ports in this switch
51 * @dma_port: If the switch has port supporting DMA configuration based
52 * mailbox this will hold the pointer to that (%NULL
53 * otherwise). If set it also means the switch has
54 * upgradeable NVM.
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
60 * @vendor_name: Name of the vendor (or %NULL if not known)
61 * @device_name: Name of the device (or %NULL if not known)
62 * @generation: Switch Thunderbolt generation
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)
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
69 * @boot: Whether the switch was already authorized on boot or not
70 * @rpm: The switch supports runtime PM
71 * @authorized: Whether the switch is authorized by user or policy
72 * @work: Work used to automatically authorize a switch
73 * @security_level: Switch supported security level
74 * @key: Contains the key used to challenge the device or %NULL if not
75 * supported. Size of the key is %TB_SWITCH_KEY_SIZE.
76 * @connection_id: Connection ID used with ICM messaging
77 * @connection_key: Connection key used with ICM messaging
78 * @link: Root switch link this switch is connected (ICM only)
79 * @depth: Depth in the chain this switch is connected (ICM only)
80 *
81 * When the switch is being added or removed to the domain (other
82 * switches) you need to have domain lock held.
83 */
84 struct tb_switch {
85 struct device dev;
86 struct tb_regs_switch_header config;
87 struct tb_port *ports;
88 struct tb_dma_port *dma_port;
89 struct tb *tb;
90 u64 uid;
91 uuid_t *uuid;
92 u16 vendor;
93 u16 device;
94 const char *vendor_name;
95 const char *device_name;
96 unsigned int generation;
97 int cap_plug_events;
98 bool is_unplugged;
99 u8 *drom;
100 struct tb_switch_nvm *nvm;
101 bool no_nvm_upgrade;
102 bool safe_mode;
103 bool boot;
104 bool rpm;
105 unsigned int authorized;
106 struct work_struct work;
107 enum tb_security_level security_level;
108 u8 *key;
109 u8 connection_id;
110 u8 connection_key;
111 u8 link;
112 u8 depth;
113 };
114
115 /**
116 * struct tb_port - a thunderbolt port, part of a tb_switch
117 * @config: Cached port configuration read from registers
118 * @sw: Switch the port belongs to
119 * @remote: Remote port (%NULL if not connected)
120 * @xdomain: Remote host (%NULL if not connected)
121 * @cap_phy: Offset, zero if not found
122 * @port: Port number on switch
123 * @disabled: Disabled by eeprom
124 * @dual_link_port: If the switch is connected using two ports, points
125 * to the other port.
126 * @link_nr: Is this primary or secondary port on the dual_link.
127 */
128 struct tb_port {
129 struct tb_regs_port_header config;
130 struct tb_switch *sw;
131 struct tb_port *remote;
132 struct tb_xdomain *xdomain;
133 int cap_phy;
134 u8 port;
135 bool disabled;
136 struct tb_port *dual_link_port;
137 u8 link_nr:1;
138 };
139
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
193 /**
194 * struct tb_cm_ops - Connection manager specific operations vector
195 * @driver_ready: Called right after control channel is started. Used by
196 * ICM to send driver ready message to the firmware.
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
201 * @suspend: Connection manager specific suspend
202 * @complete: Connection manager specific complete
203 * @runtime_suspend: Connection manager specific runtime_suspend
204 * @runtime_resume: Connection manager specific runtime_resume
205 * @handle_event: Handle thunderbolt event
206 * @get_boot_acl: Get boot ACL list
207 * @set_boot_acl: Set boot ACL list
208 * @approve_switch: Approve switch
209 * @add_switch_key: Add key to switch
210 * @challenge_switch_key: Challenge switch using key
211 * @disconnect_pcie_paths: Disconnects PCIe paths before NVM update
212 * @approve_xdomain_paths: Approve (establish) XDomain DMA paths
213 * @disconnect_xdomain_paths: Disconnect XDomain DMA paths
214 */
215 struct tb_cm_ops {
216 int (*driver_ready)(struct tb *tb);
217 int (*start)(struct tb *tb);
218 void (*stop)(struct tb *tb);
219 int (*suspend_noirq)(struct tb *tb);
220 int (*resume_noirq)(struct tb *tb);
221 int (*suspend)(struct tb *tb);
222 void (*complete)(struct tb *tb);
223 int (*runtime_suspend)(struct tb *tb);
224 int (*runtime_resume)(struct tb *tb);
225 void (*handle_event)(struct tb *tb, enum tb_cfg_pkg_type,
226 const void *buf, size_t size);
227 int (*get_boot_acl)(struct tb *tb, uuid_t *uuids, size_t nuuids);
228 int (*set_boot_acl)(struct tb *tb, const uuid_t *uuids, size_t nuuids);
229 int (*approve_switch)(struct tb *tb, struct tb_switch *sw);
230 int (*add_switch_key)(struct tb *tb, struct tb_switch *sw);
231 int (*challenge_switch_key)(struct tb *tb, struct tb_switch *sw,
232 const u8 *challenge, u8 *response);
233 int (*disconnect_pcie_paths)(struct tb *tb);
234 int (*approve_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
235 int (*disconnect_xdomain_paths)(struct tb *tb, struct tb_xdomain *xd);
236 };
237
tb_priv(struct tb * tb)238 static inline void *tb_priv(struct tb *tb)
239 {
240 return (void *)tb->privdata;
241 }
242
243 #define TB_AUTOSUSPEND_DELAY 15000 /* ms */
244
245 /* helper functions & macros */
246
247 /**
248 * tb_upstream_port() - return the upstream port of a switch
249 *
250 * Every switch has an upstream port (for the root switch it is the NHI).
251 *
252 * During switch alloc/init tb_upstream_port()->remote may be NULL, even for
253 * non root switches (on the NHI port remote is always NULL).
254 *
255 * Return: Returns the upstream port of the switch.
256 */
tb_upstream_port(struct tb_switch * sw)257 static inline struct tb_port *tb_upstream_port(struct tb_switch *sw)
258 {
259 return &sw->ports[sw->config.upstream_port_number];
260 }
261
tb_route(struct tb_switch * sw)262 static inline u64 tb_route(struct tb_switch *sw)
263 {
264 return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo;
265 }
266
tb_port_at(u64 route,struct tb_switch * sw)267 static inline struct tb_port *tb_port_at(u64 route, struct tb_switch *sw)
268 {
269 u8 port;
270
271 port = route >> (sw->config.depth * 8);
272 if (WARN_ON(port > sw->config.max_port_number))
273 return NULL;
274 return &sw->ports[port];
275 }
276
tb_sw_read(struct tb_switch * sw,void * buffer,enum tb_cfg_space space,u32 offset,u32 length)277 static inline int tb_sw_read(struct tb_switch *sw, void *buffer,
278 enum tb_cfg_space space, u32 offset, u32 length)
279 {
280 return tb_cfg_read(sw->tb->ctl,
281 buffer,
282 tb_route(sw),
283 0,
284 space,
285 offset,
286 length);
287 }
288
tb_sw_write(struct tb_switch * sw,void * buffer,enum tb_cfg_space space,u32 offset,u32 length)289 static inline int tb_sw_write(struct tb_switch *sw, void *buffer,
290 enum tb_cfg_space space, u32 offset, u32 length)
291 {
292 return tb_cfg_write(sw->tb->ctl,
293 buffer,
294 tb_route(sw),
295 0,
296 space,
297 offset,
298 length);
299 }
300
tb_port_read(struct tb_port * port,void * buffer,enum tb_cfg_space space,u32 offset,u32 length)301 static inline int tb_port_read(struct tb_port *port, void *buffer,
302 enum tb_cfg_space space, u32 offset, u32 length)
303 {
304 return tb_cfg_read(port->sw->tb->ctl,
305 buffer,
306 tb_route(port->sw),
307 port->port,
308 space,
309 offset,
310 length);
311 }
312
tb_port_write(struct tb_port * port,const void * buffer,enum tb_cfg_space space,u32 offset,u32 length)313 static inline int tb_port_write(struct tb_port *port, const void *buffer,
314 enum tb_cfg_space space, u32 offset, u32 length)
315 {
316 return tb_cfg_write(port->sw->tb->ctl,
317 buffer,
318 tb_route(port->sw),
319 port->port,
320 space,
321 offset,
322 length);
323 }
324
325 #define tb_err(tb, fmt, arg...) dev_err(&(tb)->nhi->pdev->dev, fmt, ## arg)
326 #define tb_WARN(tb, fmt, arg...) dev_WARN(&(tb)->nhi->pdev->dev, fmt, ## arg)
327 #define tb_warn(tb, fmt, arg...) dev_warn(&(tb)->nhi->pdev->dev, fmt, ## arg)
328 #define tb_info(tb, fmt, arg...) dev_info(&(tb)->nhi->pdev->dev, fmt, ## arg)
329
330
331 #define __TB_SW_PRINT(level, sw, fmt, arg...) \
332 do { \
333 struct tb_switch *__sw = (sw); \
334 level(__sw->tb, "%llx: " fmt, \
335 tb_route(__sw), ## arg); \
336 } while (0)
337 #define tb_sw_WARN(sw, fmt, arg...) __TB_SW_PRINT(tb_WARN, sw, fmt, ##arg)
338 #define tb_sw_warn(sw, fmt, arg...) __TB_SW_PRINT(tb_warn, sw, fmt, ##arg)
339 #define tb_sw_info(sw, fmt, arg...) __TB_SW_PRINT(tb_info, sw, fmt, ##arg)
340
341
342 #define __TB_PORT_PRINT(level, _port, fmt, arg...) \
343 do { \
344 struct tb_port *__port = (_port); \
345 level(__port->sw->tb, "%llx:%x: " fmt, \
346 tb_route(__port->sw), __port->port, ## arg); \
347 } while (0)
348 #define tb_port_WARN(port, fmt, arg...) \
349 __TB_PORT_PRINT(tb_WARN, port, fmt, ##arg)
350 #define tb_port_warn(port, fmt, arg...) \
351 __TB_PORT_PRINT(tb_warn, port, fmt, ##arg)
352 #define tb_port_info(port, fmt, arg...) \
353 __TB_PORT_PRINT(tb_info, port, fmt, ##arg)
354
355 struct tb *icm_probe(struct tb_nhi *nhi);
356 struct tb *tb_probe(struct tb_nhi *nhi);
357
358 extern struct device_type tb_domain_type;
359 extern struct device_type tb_switch_type;
360
361 int tb_domain_init(void);
362 void tb_domain_exit(void);
363 void tb_switch_exit(void);
364 int tb_xdomain_init(void);
365 void tb_xdomain_exit(void);
366
367 struct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize);
368 int tb_domain_add(struct tb *tb);
369 void tb_domain_remove(struct tb *tb);
370 int tb_domain_suspend_noirq(struct tb *tb);
371 int tb_domain_resume_noirq(struct tb *tb);
372 int tb_domain_suspend(struct tb *tb);
373 void tb_domain_complete(struct tb *tb);
374 int tb_domain_runtime_suspend(struct tb *tb);
375 int tb_domain_runtime_resume(struct tb *tb);
376 int tb_domain_approve_switch(struct tb *tb, struct tb_switch *sw);
377 int tb_domain_approve_switch_key(struct tb *tb, struct tb_switch *sw);
378 int tb_domain_challenge_switch_key(struct tb *tb, struct tb_switch *sw);
379 int tb_domain_disconnect_pcie_paths(struct tb *tb);
380 int tb_domain_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
381 int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
382 int tb_domain_disconnect_all_paths(struct tb *tb);
383
tb_domain_put(struct tb * tb)384 static inline void tb_domain_put(struct tb *tb)
385 {
386 put_device(&tb->dev);
387 }
388
389 struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
390 u64 route);
391 struct tb_switch *tb_switch_alloc_safe_mode(struct tb *tb,
392 struct device *parent, u64 route);
393 int tb_switch_configure(struct tb_switch *sw);
394 int tb_switch_add(struct tb_switch *sw);
395 void tb_switch_remove(struct tb_switch *sw);
396 void tb_switch_suspend(struct tb_switch *sw);
397 int tb_switch_resume(struct tb_switch *sw);
398 int tb_switch_reset(struct tb *tb, u64 route);
399 void tb_sw_set_unplugged(struct tb_switch *sw);
400 struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link,
401 u8 depth);
402 struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid);
403 struct tb_switch *tb_switch_find_by_route(struct tb *tb, u64 route);
404
tb_switch_get(struct tb_switch * sw)405 static inline struct tb_switch *tb_switch_get(struct tb_switch *sw)
406 {
407 if (sw)
408 get_device(&sw->dev);
409 return sw;
410 }
411
tb_switch_put(struct tb_switch * sw)412 static inline void tb_switch_put(struct tb_switch *sw)
413 {
414 put_device(&sw->dev);
415 }
416
tb_is_switch(const struct device * dev)417 static inline bool tb_is_switch(const struct device *dev)
418 {
419 return dev->type == &tb_switch_type;
420 }
421
tb_to_switch(struct device * dev)422 static inline struct tb_switch *tb_to_switch(struct device *dev)
423 {
424 if (tb_is_switch(dev))
425 return container_of(dev, struct tb_switch, dev);
426 return NULL;
427 }
428
429 int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged);
430 int tb_port_add_nfc_credits(struct tb_port *port, int credits);
431 int tb_port_clear_counter(struct tb_port *port, int counter);
432
433 int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec);
434 int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap);
435
436 struct tb_path *tb_path_alloc(struct tb *tb, int num_hops);
437 void tb_path_free(struct tb_path *path);
438 int tb_path_activate(struct tb_path *path);
439 void tb_path_deactivate(struct tb_path *path);
440 bool tb_path_is_invalid(struct tb_path *path);
441
442 int tb_drom_read(struct tb_switch *sw);
443 int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid);
444
445
tb_route_length(u64 route)446 static inline int tb_route_length(u64 route)
447 {
448 return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT;
449 }
450
tb_is_upstream_port(struct tb_port * port)451 static inline bool tb_is_upstream_port(struct tb_port *port)
452 {
453 return port == tb_upstream_port(port->sw);
454 }
455
456 /**
457 * tb_downstream_route() - get route to downstream switch
458 *
459 * Port must not be the upstream port (otherwise a loop is created).
460 *
461 * Return: Returns a route to the switch behind @port.
462 */
tb_downstream_route(struct tb_port * port)463 static inline u64 tb_downstream_route(struct tb_port *port)
464 {
465 return tb_route(port->sw)
466 | ((u64) port->port << (port->sw->config.depth * 8));
467 }
468
469 bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type,
470 const void *buf, size_t size);
471 struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent,
472 u64 route, const uuid_t *local_uuid,
473 const uuid_t *remote_uuid);
474 void tb_xdomain_add(struct tb_xdomain *xd);
475 void tb_xdomain_remove(struct tb_xdomain *xd);
476 struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link,
477 u8 depth);
478
479 #endif
480