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 10#include <linux/pci.h> 11 12#include "tb_regs.h" 13#include "ctl.h" 14 15/** 16 * struct tb_switch - a thunderbolt switch 17 */ 18struct tb_switch { 19 struct tb_regs_switch_header config; 20 struct tb_port *ports; 21 struct tb *tb; 22 u64 uid; 23 int cap_plug_events; /* offset, zero if not found */ 24 bool is_unplugged; /* unplugged, will go away */ 25 u8 *drom; 26}; 27 28/** 29 * struct tb_port - a thunderbolt port, part of a tb_switch 30 */ 31struct tb_port { 32 struct tb_regs_port_header config; 33 struct tb_switch *sw; 34 struct tb_port *remote; /* remote port, NULL if not connected */ 35 int cap_phy; /* offset, zero if not found */ 36 u8 port; /* port number on switch */ 37 bool disabled; /* disabled by eeprom */ 38 struct tb_port *dual_link_port; 39 u8 link_nr:1; 40}; 41 42/** 43 * struct tb_path_hop - routing information for a tb_path 44 * 45 * Hop configuration is always done on the IN port of a switch. 46 * in_port and out_port have to be on the same switch. Packets arriving on 47 * in_port with "hop" = in_hop_index will get routed to through out_port. The 48 * next hop to take (on out_port->remote) is determined by next_hop_index. 49 * 50 * in_counter_index is the index of a counter (in TB_CFG_COUNTERS) on the in 51 * port. 52 */ 53struct tb_path_hop { 54 struct tb_port *in_port; 55 struct tb_port *out_port; 56 int in_hop_index; 57 int in_counter_index; /* write -1 to disable counters for this hop. */ 58 int next_hop_index; 59}; 60 61/** 62 * enum tb_path_port - path options mask 63 */ 64enum tb_path_port { 65 TB_PATH_NONE = 0, 66 TB_PATH_SOURCE = 1, /* activate on the first hop (out of src) */ 67 TB_PATH_INTERNAL = 2, /* activate on other hops (not the first/last) */ 68 TB_PATH_DESTINATION = 4, /* activate on the last hop (into dst) */ 69 TB_PATH_ALL = 7, 70}; 71 72/** 73 * struct tb_path - a unidirectional path between two ports 74 * 75 * A path consists of a number of hops (see tb_path_hop). To establish a PCIe 76 * tunnel two paths have to be created between the two PCIe ports. 77 * 78 */ 79struct tb_path { 80 struct tb *tb; 81 int nfc_credits; /* non flow controlled credits */ 82 enum tb_path_port ingress_shared_buffer; 83 enum tb_path_port egress_shared_buffer; 84 enum tb_path_port ingress_fc_enable; 85 enum tb_path_port egress_fc_enable; 86 87 int priority:3; 88 int weight:4; 89 bool drop_packages; 90 bool activated; 91 struct tb_path_hop *hops; 92 int path_length; /* number of hops */ 93}; 94 95 96/** 97 * struct tb - main thunderbolt bus structure 98 */ 99struct tb { 100 struct mutex lock; /* 101 * Big lock. Must be held when accessing cfg or 102 * any struct tb_switch / struct tb_port. 103 */ 104 struct tb_nhi *nhi; 105 struct tb_ctl *ctl; 106 struct workqueue_struct *wq; /* ordered workqueue for plug events */ 107 struct tb_switch *root_switch; 108 struct list_head tunnel_list; /* list of active PCIe tunnels */ 109 bool hotplug_active; /* 110 * tb_handle_hotplug will stop progressing plug 111 * events and exit if this is not set (it needs to 112 * acquire the lock one more time). Used to drain 113 * wq after cfg has been paused. 114 */ 115 116}; 117 118/* helper functions & macros */ 119 120/** 121 * tb_upstream_port() - return the upstream port of a switch 122 * 123 * Every switch has an upstream port (for the root switch it is the NHI). 124 * 125 * During switch alloc/init tb_upstream_port()->remote may be NULL, even for 126 * non root switches (on the NHI port remote is always NULL). 127 * 128 * Return: Returns the upstream port of the switch. 129 */ 130static inline struct tb_port *tb_upstream_port(struct tb_switch *sw) 131{ 132 return &sw->ports[sw->config.upstream_port_number]; 133} 134 135static inline u64 tb_route(struct tb_switch *sw) 136{ 137 return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo; 138} 139 140static inline int tb_sw_read(struct tb_switch *sw, void *buffer, 141 enum tb_cfg_space space, u32 offset, u32 length) 142{ 143 return tb_cfg_read(sw->tb->ctl, 144 buffer, 145 tb_route(sw), 146 0, 147 space, 148 offset, 149 length); 150} 151 152static inline int tb_sw_write(struct tb_switch *sw, void *buffer, 153 enum tb_cfg_space space, u32 offset, u32 length) 154{ 155 return tb_cfg_write(sw->tb->ctl, 156 buffer, 157 tb_route(sw), 158 0, 159 space, 160 offset, 161 length); 162} 163 164static inline int tb_port_read(struct tb_port *port, void *buffer, 165 enum tb_cfg_space space, u32 offset, u32 length) 166{ 167 return tb_cfg_read(port->sw->tb->ctl, 168 buffer, 169 tb_route(port->sw), 170 port->port, 171 space, 172 offset, 173 length); 174} 175 176static inline int tb_port_write(struct tb_port *port, void *buffer, 177 enum tb_cfg_space space, u32 offset, u32 length) 178{ 179 return tb_cfg_write(port->sw->tb->ctl, 180 buffer, 181 tb_route(port->sw), 182 port->port, 183 space, 184 offset, 185 length); 186} 187 188#define tb_err(tb, fmt, arg...) dev_err(&(tb)->nhi->pdev->dev, fmt, ## arg) 189#define tb_WARN(tb, fmt, arg...) dev_WARN(&(tb)->nhi->pdev->dev, fmt, ## arg) 190#define tb_warn(tb, fmt, arg...) dev_warn(&(tb)->nhi->pdev->dev, fmt, ## arg) 191#define tb_info(tb, fmt, arg...) dev_info(&(tb)->nhi->pdev->dev, fmt, ## arg) 192 193 194#define __TB_SW_PRINT(level, sw, fmt, arg...) \ 195 do { \ 196 struct tb_switch *__sw = (sw); \ 197 level(__sw->tb, "%llx: " fmt, \ 198 tb_route(__sw), ## arg); \ 199 } while (0) 200#define tb_sw_WARN(sw, fmt, arg...) __TB_SW_PRINT(tb_WARN, sw, fmt, ##arg) 201#define tb_sw_warn(sw, fmt, arg...) __TB_SW_PRINT(tb_warn, sw, fmt, ##arg) 202#define tb_sw_info(sw, fmt, arg...) __TB_SW_PRINT(tb_info, sw, fmt, ##arg) 203 204 205#define __TB_PORT_PRINT(level, _port, fmt, arg...) \ 206 do { \ 207 struct tb_port *__port = (_port); \ 208 level(__port->sw->tb, "%llx:%x: " fmt, \ 209 tb_route(__port->sw), __port->port, ## arg); \ 210 } while (0) 211#define tb_port_WARN(port, fmt, arg...) \ 212 __TB_PORT_PRINT(tb_WARN, port, fmt, ##arg) 213#define tb_port_warn(port, fmt, arg...) \ 214 __TB_PORT_PRINT(tb_warn, port, fmt, ##arg) 215#define tb_port_info(port, fmt, arg...) \ 216 __TB_PORT_PRINT(tb_info, port, fmt, ##arg) 217 218 219struct tb *thunderbolt_alloc_and_start(struct tb_nhi *nhi); 220void thunderbolt_shutdown_and_free(struct tb *tb); 221void thunderbolt_suspend(struct tb *tb); 222void thunderbolt_resume(struct tb *tb); 223 224struct tb_switch *tb_switch_alloc(struct tb *tb, u64 route); 225void tb_switch_free(struct tb_switch *sw); 226void tb_switch_suspend(struct tb_switch *sw); 227int tb_switch_resume(struct tb_switch *sw); 228int tb_switch_reset(struct tb *tb, u64 route); 229void tb_sw_set_unpplugged(struct tb_switch *sw); 230struct tb_switch *get_switch_at_route(struct tb_switch *sw, u64 route); 231 232int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged); 233int tb_port_add_nfc_credits(struct tb_port *port, int credits); 234int tb_port_clear_counter(struct tb_port *port, int counter); 235 236int tb_find_cap(struct tb_port *port, enum tb_cfg_space space, enum tb_cap cap); 237 238struct tb_path *tb_path_alloc(struct tb *tb, int num_hops); 239void tb_path_free(struct tb_path *path); 240int tb_path_activate(struct tb_path *path); 241void tb_path_deactivate(struct tb_path *path); 242bool tb_path_is_invalid(struct tb_path *path); 243 244int tb_drom_read(struct tb_switch *sw); 245int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid); 246 247 248static inline int tb_route_length(u64 route) 249{ 250 return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT; 251} 252 253static inline bool tb_is_upstream_port(struct tb_port *port) 254{ 255 return port == tb_upstream_port(port->sw); 256} 257 258/** 259 * tb_downstream_route() - get route to downstream switch 260 * 261 * Port must not be the upstream port (otherwise a loop is created). 262 * 263 * Return: Returns a route to the switch behind @port. 264 */ 265static inline u64 tb_downstream_route(struct tb_port *port) 266{ 267 return tb_route(port->sw) 268 | ((u64) port->port << (port->sw->config.depth * 8)); 269} 270 271#endif 272