Merge tag 'amd-drm-next-5.13-2021-03-23' of https://gitlab.freedesktop.org/agd5f...
[linux-2.6-microblaze.git] / drivers / thunderbolt / lc.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Thunderbolt link controller support
4  *
5  * Copyright (C) 2019, Intel Corporation
6  * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
7  */
8
9 #include "tb.h"
10
11 /**
12  * tb_lc_read_uuid() - Read switch UUID from link controller common register
13  * @sw: Switch whose UUID is read
14  * @uuid: UUID is placed here
15  */
16 int tb_lc_read_uuid(struct tb_switch *sw, u32 *uuid)
17 {
18         if (!sw->cap_lc)
19                 return -EINVAL;
20         return tb_sw_read(sw, uuid, TB_CFG_SWITCH, sw->cap_lc + TB_LC_FUSE, 4);
21 }
22
23 static int read_lc_desc(struct tb_switch *sw, u32 *desc)
24 {
25         if (!sw->cap_lc)
26                 return -EINVAL;
27         return tb_sw_read(sw, desc, TB_CFG_SWITCH, sw->cap_lc + TB_LC_DESC, 1);
28 }
29
30 static int find_port_lc_cap(struct tb_port *port)
31 {
32         struct tb_switch *sw = port->sw;
33         int start, phys, ret, size;
34         u32 desc;
35
36         ret = read_lc_desc(sw, &desc);
37         if (ret)
38                 return ret;
39
40         /* Start of port LC registers */
41         start = (desc & TB_LC_DESC_SIZE_MASK) >> TB_LC_DESC_SIZE_SHIFT;
42         size = (desc & TB_LC_DESC_PORT_SIZE_MASK) >> TB_LC_DESC_PORT_SIZE_SHIFT;
43         phys = tb_phy_port_from_link(port->port);
44
45         return sw->cap_lc + start + phys * size;
46 }
47
48 static int tb_lc_set_port_configured(struct tb_port *port, bool configured)
49 {
50         bool upstream = tb_is_upstream_port(port);
51         struct tb_switch *sw = port->sw;
52         u32 ctrl, lane;
53         int cap, ret;
54
55         if (sw->generation < 2)
56                 return 0;
57
58         cap = find_port_lc_cap(port);
59         if (cap < 0)
60                 return cap;
61
62         ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
63         if (ret)
64                 return ret;
65
66         /* Resolve correct lane */
67         if (port->port % 2)
68                 lane = TB_LC_SX_CTRL_L1C;
69         else
70                 lane = TB_LC_SX_CTRL_L2C;
71
72         if (configured) {
73                 ctrl |= lane;
74                 if (upstream)
75                         ctrl |= TB_LC_SX_CTRL_UPSTREAM;
76         } else {
77                 ctrl &= ~lane;
78                 if (upstream)
79                         ctrl &= ~TB_LC_SX_CTRL_UPSTREAM;
80         }
81
82         return tb_sw_write(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
83 }
84
85 /**
86  * tb_lc_configure_port() - Let LC know about configured port
87  * @port: Port that is set as configured
88  *
89  * Sets the port configured for power management purposes.
90  */
91 int tb_lc_configure_port(struct tb_port *port)
92 {
93         return tb_lc_set_port_configured(port, true);
94 }
95
96 /**
97  * tb_lc_unconfigure_port() - Let LC know about unconfigured port
98  * @port: Port that is set as configured
99  *
100  * Sets the port unconfigured for power management purposes.
101  */
102 void tb_lc_unconfigure_port(struct tb_port *port)
103 {
104         tb_lc_set_port_configured(port, false);
105 }
106
107 static int tb_lc_set_xdomain_configured(struct tb_port *port, bool configure)
108 {
109         struct tb_switch *sw = port->sw;
110         u32 ctrl, lane;
111         int cap, ret;
112
113         if (sw->generation < 2)
114                 return 0;
115
116         cap = find_port_lc_cap(port);
117         if (cap < 0)
118                 return cap;
119
120         ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
121         if (ret)
122                 return ret;
123
124         /* Resolve correct lane */
125         if (port->port % 2)
126                 lane = TB_LC_SX_CTRL_L1D;
127         else
128                 lane = TB_LC_SX_CTRL_L2D;
129
130         if (configure)
131                 ctrl |= lane;
132         else
133                 ctrl &= ~lane;
134
135         return tb_sw_write(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
136 }
137
138 /**
139  * tb_lc_configure_xdomain() - Inform LC that the link is XDomain
140  * @port: Switch downstream port connected to another host
141  *
142  * Sets the lane configured for XDomain accordingly so that the LC knows
143  * about this. Returns %0 in success and negative errno in failure.
144  */
145 int tb_lc_configure_xdomain(struct tb_port *port)
146 {
147         return tb_lc_set_xdomain_configured(port, true);
148 }
149
150 /**
151  * tb_lc_unconfigure_xdomain() - Unconfigure XDomain from port
152  * @port: Switch downstream port that was connected to another host
153  *
154  * Unsets the lane XDomain configuration.
155  */
156 void tb_lc_unconfigure_xdomain(struct tb_port *port)
157 {
158         tb_lc_set_xdomain_configured(port, false);
159 }
160
161 /**
162  * tb_lc_start_lane_initialization() - Start lane initialization
163  * @port: Device router lane 0 adapter
164  *
165  * Starts lane initialization for @port after the router resumed from
166  * sleep. Should be called for those downstream lane adapters that were
167  * not connected (tb_lc_configure_port() was not called) before sleep.
168  *
169  * Returns %0 in success and negative errno in case of failure.
170  */
171 int tb_lc_start_lane_initialization(struct tb_port *port)
172 {
173         struct tb_switch *sw = port->sw;
174         int ret, cap;
175         u32 ctrl;
176
177         if (!tb_route(sw))
178                 return 0;
179
180         if (sw->generation < 2)
181                 return 0;
182
183         cap = find_port_lc_cap(port);
184         if (cap < 0)
185                 return cap;
186
187         ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
188         if (ret)
189                 return ret;
190
191         ctrl |= TB_LC_SX_CTRL_SLI;
192
193         return tb_sw_write(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
194 }
195
196 static int tb_lc_set_wake_one(struct tb_switch *sw, unsigned int offset,
197                               unsigned int flags)
198 {
199         u32 ctrl;
200         int ret;
201
202         /*
203          * Enable wake on PCIe and USB4 (wake coming from another
204          * router).
205          */
206         ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH,
207                          offset + TB_LC_SX_CTRL, 1);
208         if (ret)
209                 return ret;
210
211         ctrl &= ~(TB_LC_SX_CTRL_WOC | TB_LC_SX_CTRL_WOD | TB_LC_SX_CTRL_WOP |
212                   TB_LC_SX_CTRL_WOU4);
213
214         if (flags & TB_WAKE_ON_CONNECT)
215                 ctrl |= TB_LC_SX_CTRL_WOC | TB_LC_SX_CTRL_WOD;
216         if (flags & TB_WAKE_ON_USB4)
217                 ctrl |= TB_LC_SX_CTRL_WOU4;
218         if (flags & TB_WAKE_ON_PCIE)
219                 ctrl |= TB_LC_SX_CTRL_WOP;
220
221         return tb_sw_write(sw, &ctrl, TB_CFG_SWITCH, offset + TB_LC_SX_CTRL, 1);
222 }
223
224 /**
225  * tb_lc_set_wake() - Enable/disable wake
226  * @sw: Switch whose wakes to configure
227  * @flags: Wakeup flags (%0 to disable)
228  *
229  * For each LC sets wake bits accordingly.
230  */
231 int tb_lc_set_wake(struct tb_switch *sw, unsigned int flags)
232 {
233         int start, size, nlc, ret, i;
234         u32 desc;
235
236         if (sw->generation < 2)
237                 return 0;
238
239         if (!tb_route(sw))
240                 return 0;
241
242         ret = read_lc_desc(sw, &desc);
243         if (ret)
244                 return ret;
245
246         /* Figure out number of link controllers */
247         nlc = desc & TB_LC_DESC_NLC_MASK;
248         start = (desc & TB_LC_DESC_SIZE_MASK) >> TB_LC_DESC_SIZE_SHIFT;
249         size = (desc & TB_LC_DESC_PORT_SIZE_MASK) >> TB_LC_DESC_PORT_SIZE_SHIFT;
250
251         /* For each link controller set sleep bit */
252         for (i = 0; i < nlc; i++) {
253                 unsigned int offset = sw->cap_lc + start + i * size;
254
255                 ret = tb_lc_set_wake_one(sw, offset, flags);
256                 if (ret)
257                         return ret;
258         }
259
260         return 0;
261 }
262
263 /**
264  * tb_lc_set_sleep() - Inform LC that the switch is going to sleep
265  * @sw: Switch to set sleep
266  *
267  * Let the switch link controllers know that the switch is going to
268  * sleep.
269  */
270 int tb_lc_set_sleep(struct tb_switch *sw)
271 {
272         int start, size, nlc, ret, i;
273         u32 desc;
274
275         if (sw->generation < 2)
276                 return 0;
277
278         ret = read_lc_desc(sw, &desc);
279         if (ret)
280                 return ret;
281
282         /* Figure out number of link controllers */
283         nlc = desc & TB_LC_DESC_NLC_MASK;
284         start = (desc & TB_LC_DESC_SIZE_MASK) >> TB_LC_DESC_SIZE_SHIFT;
285         size = (desc & TB_LC_DESC_PORT_SIZE_MASK) >> TB_LC_DESC_PORT_SIZE_SHIFT;
286
287         /* For each link controller set sleep bit */
288         for (i = 0; i < nlc; i++) {
289                 unsigned int offset = sw->cap_lc + start + i * size;
290                 u32 ctrl;
291
292                 ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH,
293                                  offset + TB_LC_SX_CTRL, 1);
294                 if (ret)
295                         return ret;
296
297                 ctrl |= TB_LC_SX_CTRL_SLP;
298                 ret = tb_sw_write(sw, &ctrl, TB_CFG_SWITCH,
299                                   offset + TB_LC_SX_CTRL, 1);
300                 if (ret)
301                         return ret;
302         }
303
304         return 0;
305 }
306
307 /**
308  * tb_lc_lane_bonding_possible() - Is lane bonding possible towards switch
309  * @sw: Switch to check
310  *
311  * Checks whether conditions for lane bonding from parent to @sw are
312  * possible.
313  */
314 bool tb_lc_lane_bonding_possible(struct tb_switch *sw)
315 {
316         struct tb_port *up;
317         int cap, ret;
318         u32 val;
319
320         if (sw->generation < 2)
321                 return false;
322
323         up = tb_upstream_port(sw);
324         cap = find_port_lc_cap(up);
325         if (cap < 0)
326                 return false;
327
328         ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, cap + TB_LC_PORT_ATTR, 1);
329         if (ret)
330                 return false;
331
332         return !!(val & TB_LC_PORT_ATTR_BE);
333 }
334
335 static int tb_lc_dp_sink_from_port(const struct tb_switch *sw,
336                                    struct tb_port *in)
337 {
338         struct tb_port *port;
339
340         /* The first DP IN port is sink 0 and second is sink 1 */
341         tb_switch_for_each_port(sw, port) {
342                 if (tb_port_is_dpin(port))
343                         return in != port;
344         }
345
346         return -EINVAL;
347 }
348
349 static int tb_lc_dp_sink_available(struct tb_switch *sw, int sink)
350 {
351         u32 val, alloc;
352         int ret;
353
354         ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
355                          sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
356         if (ret)
357                 return ret;
358
359         /*
360          * Sink is available for CM/SW to use if the allocation valie is
361          * either 0 or 1.
362          */
363         if (!sink) {
364                 alloc = val & TB_LC_SNK_ALLOCATION_SNK0_MASK;
365                 if (!alloc || alloc == TB_LC_SNK_ALLOCATION_SNK0_CM)
366                         return 0;
367         } else {
368                 alloc = (val & TB_LC_SNK_ALLOCATION_SNK1_MASK) >>
369                         TB_LC_SNK_ALLOCATION_SNK1_SHIFT;
370                 if (!alloc || alloc == TB_LC_SNK_ALLOCATION_SNK1_CM)
371                         return 0;
372         }
373
374         return -EBUSY;
375 }
376
377 /**
378  * tb_lc_dp_sink_query() - Is DP sink available for DP IN port
379  * @sw: Switch whose DP sink is queried
380  * @in: DP IN port to check
381  *
382  * Queries through LC SNK_ALLOCATION registers whether DP sink is available
383  * for the given DP IN port or not.
384  */
385 bool tb_lc_dp_sink_query(struct tb_switch *sw, struct tb_port *in)
386 {
387         int sink;
388
389         /*
390          * For older generations sink is always available as there is no
391          * allocation mechanism.
392          */
393         if (sw->generation < 3)
394                 return true;
395
396         sink = tb_lc_dp_sink_from_port(sw, in);
397         if (sink < 0)
398                 return false;
399
400         return !tb_lc_dp_sink_available(sw, sink);
401 }
402
403 /**
404  * tb_lc_dp_sink_alloc() - Allocate DP sink
405  * @sw: Switch whose DP sink is allocated
406  * @in: DP IN port the DP sink is allocated for
407  *
408  * Allocate DP sink for @in via LC SNK_ALLOCATION registers. If the
409  * resource is available and allocation is successful returns %0. In all
410  * other cases returs negative errno. In particular %-EBUSY is returned if
411  * the resource was not available.
412  */
413 int tb_lc_dp_sink_alloc(struct tb_switch *sw, struct tb_port *in)
414 {
415         int ret, sink;
416         u32 val;
417
418         if (sw->generation < 3)
419                 return 0;
420
421         sink = tb_lc_dp_sink_from_port(sw, in);
422         if (sink < 0)
423                 return sink;
424
425         ret = tb_lc_dp_sink_available(sw, sink);
426         if (ret)
427                 return ret;
428
429         ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
430                          sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
431         if (ret)
432                 return ret;
433
434         if (!sink) {
435                 val &= ~TB_LC_SNK_ALLOCATION_SNK0_MASK;
436                 val |= TB_LC_SNK_ALLOCATION_SNK0_CM;
437         } else {
438                 val &= ~TB_LC_SNK_ALLOCATION_SNK1_MASK;
439                 val |= TB_LC_SNK_ALLOCATION_SNK1_CM <<
440                         TB_LC_SNK_ALLOCATION_SNK1_SHIFT;
441         }
442
443         ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
444                           sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
445
446         if (ret)
447                 return ret;
448
449         tb_port_dbg(in, "sink %d allocated\n", sink);
450         return 0;
451 }
452
453 /**
454  * tb_lc_dp_sink_dealloc() - De-allocate DP sink
455  * @sw: Switch whose DP sink is de-allocated
456  * @in: DP IN port whose DP sink is de-allocated
457  *
458  * De-allocate DP sink from @in using LC SNK_ALLOCATION registers.
459  */
460 int tb_lc_dp_sink_dealloc(struct tb_switch *sw, struct tb_port *in)
461 {
462         int ret, sink;
463         u32 val;
464
465         if (sw->generation < 3)
466                 return 0;
467
468         sink = tb_lc_dp_sink_from_port(sw, in);
469         if (sink < 0)
470                 return sink;
471
472         /* Needs to be owned by CM/SW */
473         ret = tb_lc_dp_sink_available(sw, sink);
474         if (ret)
475                 return ret;
476
477         ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
478                          sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
479         if (ret)
480                 return ret;
481
482         if (!sink)
483                 val &= ~TB_LC_SNK_ALLOCATION_SNK0_MASK;
484         else
485                 val &= ~TB_LC_SNK_ALLOCATION_SNK1_MASK;
486
487         ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
488                           sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
489         if (ret)
490                 return ret;
491
492         tb_port_dbg(in, "sink %d de-allocated\n", sink);
493         return 0;
494 }
495
496 /**
497  * tb_lc_force_power() - Forces LC to be powered on
498  * @sw: Thunderbolt switch
499  *
500  * This is useful to let authentication cycle pass even without
501  * a Thunderbolt link present.
502  */
503 int tb_lc_force_power(struct tb_switch *sw)
504 {
505         u32 in = 0xffff;
506
507         return tb_sw_write(sw, &in, TB_CFG_SWITCH, TB_LC_POWER, 1);
508 }