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