drivers/thunderbolt/tb.h

   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  */
  18 struct 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  */
  31 struct 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  */
  53 struct 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  */
  64 enum 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  */
  79 struct 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  * struct tb_cm_ops - Connection manager specific operations vector
  97  * @start: Starts the domain
  98  * @stop: Stops the domain
  99  * @suspend_noirq: Connection manager specific suspend_noirq
 100  * @resume_noirq: Connection manager specific resume_noirq
 101  * @hotplug: Handle hotplug event
 102  */
 103 struct tb_cm_ops {
 104         int (*start)(struct tb *tb);
 105         void (*stop)(struct tb *tb);
 106         int (*suspend_noirq)(struct tb *tb);
 107         int (*resume_noirq)(struct tb *tb);
 108         hotplug_cb hotplug;
 109 };
 110
 111 /**
 112  * struct tb - main thunderbolt bus structure
 113  * @dev: Domain device
 114  * @lock: Big lock. Must be held when accessing cfg or any struct
 115  *        tb_switch / struct tb_port.
 116  * @nhi: Pointer to the NHI structure
 117  * @ctl: Control channel for this domain
 118  * @wq: Ordered workqueue for all domain specific work
 119  * @root_switch: Root switch of this domain
 120  * @cm_ops: Connection manager specific operations vector
 121  * @index: Linux assigned domain number
 122  * @privdata: Private connection manager specific data
 123  */
 124 struct tb {
 125         struct device dev;
 126         struct mutex lock;
 127         struct tb_nhi *nhi;
 128         struct tb_ctl *ctl;
 129         struct workqueue_struct *wq;
 130         struct tb_switch *root_switch;
 131         const struct tb_cm_ops *cm_ops;
 132         int index;
 133         unsigned long privdata[0];
 134 };
 135
 136 static inline void *tb_priv(struct tb *tb)
 137 {
 138         return (void *)tb->privdata;
 139 }
 140
 141 /* helper functions & macros */
 142
 143 /**
 144  * tb_upstream_port() - return the upstream port of a switch
 145  *
 146  * Every switch has an upstream port (for the root switch it is the NHI).
 147  *
 148  * During switch alloc/init tb_upstream_port()->remote may be NULL, even for
 149  * non root switches (on the NHI port remote is always NULL).
 150  *
 151  * Return: Returns the upstream port of the switch.
 152  */
 153 static inline struct tb_port *tb_upstream_port(struct tb_switch *sw)
 154 {
 155         return &sw->ports[sw->config.upstream_port_number];
 156 }
 157
 158 static inline u64 tb_route(struct tb_switch *sw)
 159 {
 160         return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo;
 161 }
 162
 163 static inline int tb_sw_read(struct tb_switch *sw, void *buffer,
 164                              enum tb_cfg_space space, u32 offset, u32 length)
 165 {
 166         return tb_cfg_read(sw->tb->ctl,
 167                            buffer,
 168                            tb_route(sw),
 169                            0,
 170                            space,
 171                            offset,
 172                            length);
 173 }
 174
 175 static inline int tb_sw_write(struct tb_switch *sw, void *buffer,
 176                               enum tb_cfg_space space, u32 offset, u32 length)
 177 {
 178         return tb_cfg_write(sw->tb->ctl,
 179                             buffer,
 180                             tb_route(sw),
 181                             0,
 182                             space,
 183                             offset,
 184                             length);
 185 }
 186
 187 static inline int tb_port_read(struct tb_port *port, void *buffer,
 188                                enum tb_cfg_space space, u32 offset, u32 length)
 189 {
 190         return tb_cfg_read(port->sw->tb->ctl,
 191                            buffer,
 192                            tb_route(port->sw),
 193                            port->port,
 194                            space,
 195                            offset,
 196                            length);
 197 }
 198
 199 static inline int tb_port_write(struct tb_port *port, const void *buffer,
 200                                 enum tb_cfg_space space, u32 offset, u32 length)
 201 {
 202         return tb_cfg_write(port->sw->tb->ctl,
 203                             buffer,
 204                             tb_route(port->sw),
 205                             port->port,
 206                             space,
 207                             offset,
 208                             length);
 209 }
 210
 211 #define tb_err(tb, fmt, arg...) dev_err(&(tb)->nhi->pdev->dev, fmt, ## arg)
 212 #define tb_WARN(tb, fmt, arg...) dev_WARN(&(tb)->nhi->pdev->dev, fmt, ## arg)
 213 #define tb_warn(tb, fmt, arg...) dev_warn(&(tb)->nhi->pdev->dev, fmt, ## arg)
 214 #define tb_info(tb, fmt, arg...) dev_info(&(tb)->nhi->pdev->dev, fmt, ## arg)
 215
 216
 217 #define __TB_SW_PRINT(level, sw, fmt, arg...)           \
 218         do {                                            \
 219                 struct tb_switch *__sw = (sw);          \
 220                 level(__sw->tb, "%llx: " fmt,           \
 221                       tb_route(__sw), ## arg);          \
 222         } while (0)
 223 #define tb_sw_WARN(sw, fmt, arg...) __TB_SW_PRINT(tb_WARN, sw, fmt, ##arg)
 224 #define tb_sw_warn(sw, fmt, arg...) __TB_SW_PRINT(tb_warn, sw, fmt, ##arg)
 225 #define tb_sw_info(sw, fmt, arg...) __TB_SW_PRINT(tb_info, sw, fmt, ##arg)
 226
 227
 228 #define __TB_PORT_PRINT(level, _port, fmt, arg...)                      \
 229         do {                                                            \
 230                 struct tb_port *__port = (_port);                       \
 231                 level(__port->sw->tb, "%llx:%x: " fmt,                  \
 232                       tb_route(__port->sw), __port->port, ## arg);      \
 233         } while (0)
 234 #define tb_port_WARN(port, fmt, arg...) \
 235         __TB_PORT_PRINT(tb_WARN, port, fmt, ##arg)
 236 #define tb_port_warn(port, fmt, arg...) \
 237         __TB_PORT_PRINT(tb_warn, port, fmt, ##arg)
 238 #define tb_port_info(port, fmt, arg...) \
 239         __TB_PORT_PRINT(tb_info, port, fmt, ##arg)
 240
 241 struct tb *tb_probe(struct tb_nhi *nhi);
 242
 243 extern struct bus_type tb_bus_type;
 244 extern struct device_type tb_domain_type;
 245
 246 int tb_domain_init(void);
 247 void tb_domain_exit(void);
 248
 249 struct tb *tb_domain_alloc(struct tb_nhi *nhi, size_t privsize);
 250 int tb_domain_add(struct tb *tb);
 251 void tb_domain_remove(struct tb *tb);
 252 int tb_domain_suspend_noirq(struct tb *tb);
 253 int tb_domain_resume_noirq(struct tb *tb);
 254
 255 static inline void tb_domain_put(struct tb *tb)
 256 {
 257         put_device(&tb->dev);
 258 }
 259
 260 struct tb_switch *tb_switch_alloc(struct tb *tb, u64 route);
 261 void tb_switch_free(struct tb_switch *sw);
 262 void tb_switch_suspend(struct tb_switch *sw);
 263 int tb_switch_resume(struct tb_switch *sw);
 264 int tb_switch_reset(struct tb *tb, u64 route);
 265 void tb_sw_set_unplugged(struct tb_switch *sw);
 266 struct tb_switch *get_switch_at_route(struct tb_switch *sw, u64 route);
 267
 268 int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged);
 269 int tb_port_add_nfc_credits(struct tb_port *port, int credits);
 270 int tb_port_clear_counter(struct tb_port *port, int counter);
 271
 272 int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec);
 273 int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap);
 274
 275 struct tb_path *tb_path_alloc(struct tb *tb, int num_hops);
 276 void tb_path_free(struct tb_path *path);
 277 int tb_path_activate(struct tb_path *path);
 278 void tb_path_deactivate(struct tb_path *path);
 279 bool tb_path_is_invalid(struct tb_path *path);
 280
 281 int tb_drom_read(struct tb_switch *sw);
 282 int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid);
 283
 284
 285 static inline int tb_route_length(u64 route)
 286 {
 287         return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT;
 288 }
 289
 290 static inline bool tb_is_upstream_port(struct tb_port *port)
 291 {
 292         return port == tb_upstream_port(port->sw);
 293 }
 294
 295 /**
 296  * tb_downstream_route() - get route to downstream switch
 297  *
 298  * Port must not be the upstream port (otherwise a loop is created).
 299  *
 300  * Return: Returns a route to the switch behind @port.
 301  */
 302 static inline u64 tb_downstream_route(struct tb_port *port)
 303 {
 304         return tb_route(port->sw)
 305                | ((u64) port->port << (port->sw->config.depth * 8));
 306 }
 307
 308 #endif