Merge tag 'for-linus-5.5-1' of git://github.com/cminyard/linux-ipmi
[linux-2.6-microblaze.git] / drivers / thunderbolt / cap.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Thunderbolt driver - capabilities lookup
4  *
5  * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
6  * Copyright (C) 2018, Intel Corporation
7  */
8
9 #include <linux/slab.h>
10 #include <linux/errno.h>
11
12 #include "tb.h"
13
14 #define CAP_OFFSET_MAX          0xff
15 #define VSE_CAP_OFFSET_MAX      0xffff
16 #define TMU_ACCESS_EN           BIT(20)
17
18 struct tb_cap_any {
19         union {
20                 struct tb_cap_basic basic;
21                 struct tb_cap_extended_short extended_short;
22                 struct tb_cap_extended_long extended_long;
23         };
24 } __packed;
25
26 static int tb_port_enable_tmu(struct tb_port *port, bool enable)
27 {
28         struct tb_switch *sw = port->sw;
29         u32 value, offset;
30         int ret;
31
32         /*
33          * Legacy devices need to have TMU access enabled before port
34          * space can be fully accessed.
35          */
36         if (tb_switch_is_lr(sw))
37                 offset = 0x26;
38         else if (tb_switch_is_er(sw))
39                 offset = 0x2a;
40         else
41                 return 0;
42
43         ret = tb_sw_read(sw, &value, TB_CFG_SWITCH, offset, 1);
44         if (ret)
45                 return ret;
46
47         if (enable)
48                 value |= TMU_ACCESS_EN;
49         else
50                 value &= ~TMU_ACCESS_EN;
51
52         return tb_sw_write(sw, &value, TB_CFG_SWITCH, offset, 1);
53 }
54
55 static void tb_port_dummy_read(struct tb_port *port)
56 {
57         /*
58          * When reading from next capability pointer location in port
59          * config space the read data is not cleared on LR. To avoid
60          * reading stale data on next read perform one dummy read after
61          * port capabilities are walked.
62          */
63         if (tb_switch_is_lr(port->sw)) {
64                 u32 dummy;
65
66                 tb_port_read(port, &dummy, TB_CFG_PORT, 0, 1);
67         }
68 }
69
70 static int __tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
71 {
72         u32 offset = 1;
73
74         do {
75                 struct tb_cap_any header;
76                 int ret;
77
78                 ret = tb_port_read(port, &header, TB_CFG_PORT, offset, 1);
79                 if (ret)
80                         return ret;
81
82                 if (header.basic.cap == cap)
83                         return offset;
84
85                 offset = header.basic.next;
86         } while (offset);
87
88         return -ENOENT;
89 }
90
91 /**
92  * tb_port_find_cap() - Find port capability
93  * @port: Port to find the capability for
94  * @cap: Capability to look
95  *
96  * Returns offset to start of capability or %-ENOENT if no such
97  * capability was found. Negative errno is returned if there was an
98  * error.
99  */
100 int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
101 {
102         int ret;
103
104         ret = tb_port_enable_tmu(port, true);
105         if (ret)
106                 return ret;
107
108         ret = __tb_port_find_cap(port, cap);
109
110         tb_port_dummy_read(port);
111         tb_port_enable_tmu(port, false);
112
113         return ret;
114 }
115
116 static int tb_switch_find_cap(struct tb_switch *sw, enum tb_switch_cap cap)
117 {
118         int offset = sw->config.first_cap_offset;
119
120         while (offset > 0 && offset < CAP_OFFSET_MAX) {
121                 struct tb_cap_any header;
122                 int ret;
123
124                 ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 1);
125                 if (ret)
126                         return ret;
127
128                 if (header.basic.cap == cap)
129                         return offset;
130
131                 offset = header.basic.next;
132         }
133
134         return -ENOENT;
135 }
136
137 /**
138  * tb_switch_find_vse_cap() - Find switch vendor specific capability
139  * @sw: Switch to find the capability for
140  * @vsec: Vendor specific capability to look
141  *
142  * Functions enumerates vendor specific capabilities (VSEC) of a switch
143  * and returns offset when capability matching @vsec is found. If no
144  * such capability is found returns %-ENOENT. In case of error returns
145  * negative errno.
146  */
147 int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec)
148 {
149         struct tb_cap_any header;
150         int offset;
151
152         offset = tb_switch_find_cap(sw, TB_SWITCH_CAP_VSE);
153         if (offset < 0)
154                 return offset;
155
156         while (offset > 0 && offset < VSE_CAP_OFFSET_MAX) {
157                 int ret;
158
159                 ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 2);
160                 if (ret)
161                         return ret;
162
163                 /*
164                  * Extended vendor specific capabilities come in two
165                  * flavors: short and long. The latter is used when
166                  * offset is over 0xff.
167                  */
168                 if (offset >= CAP_OFFSET_MAX) {
169                         if (header.extended_long.vsec_id == vsec)
170                                 return offset;
171                         offset = header.extended_long.next;
172                 } else {
173                         if (header.extended_short.vsec_id == vsec)
174                                 return offset;
175                         if (!header.extended_short.length)
176                                 return -ENOENT;
177                         offset = header.extended_short.next;
178                 }
179         }
180
181         return -ENOENT;
182 }