projects/linux·blob master · refs

256 lines · 5.7 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Thunderbolt driver - capabilities lookup
4 *
5 * Copyright (c) 2014 Andreas Noever <[email protected]>
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
18static int tb_port_enable_tmu(struct tb_port *port, bool enable)
19{
20 struct tb_switch *sw = port->sw;
21 u32 value, offset;
22 int ret;
23
24 /*
25 * Legacy devices need to have TMU access enabled before port
26 * space can be fully accessed.
27 */
28 if (tb_switch_is_light_ridge(sw))
29 offset = 0x26;
30 else if (tb_switch_is_eagle_ridge(sw))
31 offset = 0x2a;
32 else
33 return 0;
34
35 ret = tb_sw_read(sw, &value, TB_CFG_SWITCH, offset, 1);
36 if (ret)
37 return ret;
38
39 if (enable)
40 value |= TMU_ACCESS_EN;
41 else
42 value &= ~TMU_ACCESS_EN;
43
44 return tb_sw_write(sw, &value, TB_CFG_SWITCH, offset, 1);
45}
46
47static void tb_port_dummy_read(struct tb_port *port)
48{
49 /*
50 * When reading from next capability pointer location in port
51 * config space the read data is not cleared on LR. To avoid
52 * reading stale data on next read perform one dummy read after
53 * port capabilities are walked.
54 */
55 if (tb_switch_is_light_ridge(port->sw)) {
56 u32 dummy;
57
58 tb_port_read(port, &dummy, TB_CFG_PORT, 0, 1);
59 }
60}
61
62/**
63 * tb_port_next_cap() - Return next capability in the linked list
64 * @port: Port to find the capability for
65 * @offset: Previous capability offset (%0 for start)
66 *
67 * Finds dword offset of the next capability in port config space
68 * capability list. When passed %0 in @offset parameter, first entry
69 * will be returned, if it exists.
70 *
71 * Return:
72 * * Double word offset of the first or next capability - On success.
73 * * %0 - If no next capability is found.
74 * * Negative errno - Another error occurred.
75 */
76int tb_port_next_cap(struct tb_port *port, unsigned int offset)
77{
78 struct tb_cap_any header;
79 int ret;
80
81 if (!offset)
82 return port->config.first_cap_offset;
83
84 ret = tb_port_read(port, &header, TB_CFG_PORT, offset, 1);
85 if (ret)
86 return ret;
87
88 return header.basic.next;
89}
90
91static int __tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
92{
93 int offset = 0;
94
95 do {
96 struct tb_cap_any header;
97 int ret;
98
99 offset = tb_port_next_cap(port, offset);
100 if (offset < 0)
101 return offset;
102
103 ret = tb_port_read(port, &header, TB_CFG_PORT, offset, 1);
104 if (ret)
105 return ret;
106
107 if (header.basic.cap == cap)
108 return offset;
109 } while (offset > 0);
110
111 return -ENOENT;
112}
113
114/**
115 * tb_port_find_cap() - Find port capability
116 * @port: Port to find the capability for
117 * @cap: Capability to look
118 *
119 * Return:
120 * * Offset to the start of capability - On success.
121 * * %-ENOENT - If no such capability was found.
122 * * Negative errno - Another error occurred.
123 */
124int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
125{
126 int ret;
127
128 ret = tb_port_enable_tmu(port, true);
129 if (ret)
130 return ret;
131
132 ret = __tb_port_find_cap(port, cap);
133
134 tb_port_dummy_read(port);
135 tb_port_enable_tmu(port, false);
136
137 return ret;
138}
139
140/**
141 * tb_switch_next_cap() - Return next capability in the linked list
142 * @sw: Switch to find the capability for
143 * @offset: Previous capability offset (%0 for start)
144 *
145 * Finds dword offset of the next capability in port config space
146 * capability list. When passed %0 in @offset parameter, first entry
147 * will be returned, if it exists.
148 *
149 * Return:
150 * * Double word offset of the first or next capability - On success.
151 * * %0 - If no next capability is found.
152 * * Negative errno - Another error occurred.
153 */
154int tb_switch_next_cap(struct tb_switch *sw, unsigned int offset)
155{
156 struct tb_cap_any header;
157 int ret;
158
159 if (!offset)
160 return sw->config.first_cap_offset;
161
162 ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 2);
163 if (ret)
164 return ret;
165
166 switch (header.basic.cap) {
167 case TB_SWITCH_CAP_TMU:
168 ret = header.basic.next;
169 break;
170
171 case TB_SWITCH_CAP_VSE:
172 if (!header.extended_short.length)
173 ret = header.extended_long.next;
174 else
175 ret = header.extended_short.next;
176 break;
177
178 default:
179 tb_sw_dbg(sw, "unknown capability %#x at %#x\n",
180 header.basic.cap, offset);
181 ret = -EINVAL;
182 break;
183 }
184
185 return ret >= VSE_CAP_OFFSET_MAX ? 0 : ret;
186}
187
188/**
189 * tb_switch_find_cap() - Find switch capability
190 * @sw: Switch to find the capability for
191 * @cap: Capability to look
192 *
193 * Return:
194 * * Offset to the start of capability - On success.
195 * * %-ENOENT - If no such capability was found.
196 * * Negative errno - Another error occurred.
197 */
198int tb_switch_find_cap(struct tb_switch *sw, enum tb_switch_cap cap)
199{
200 int offset = 0;
201
202 do {
203 struct tb_cap_any header;
204 int ret;
205
206 offset = tb_switch_next_cap(sw, offset);
207 if (offset < 0)
208 return offset;
209
210 ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 1);
211 if (ret)
212 return ret;
213
214 if (header.basic.cap == cap)
215 return offset;
216 } while (offset);
217
218 return -ENOENT;
219}
220
221/**
222 * tb_switch_find_vse_cap() - Find switch vendor specific capability
223 * @sw: Switch to find the capability for
224 * @vsec: Vendor specific capability to look
225 *
226 * This function enumerates vendor specific capabilities (VSEC) of a
227 * switch and returns offset when capability matching @vsec is found.
228 *
229 * Return:
230 * * Offset of capability - On success.
231 * * %-ENOENT - If capability was not found.
232 * * Negative errno - Another error occurred.
233 */
234int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec)
235{
236 int offset = 0;
237
238 do {
239 struct tb_cap_any header;
240 int ret;
241
242 offset = tb_switch_next_cap(sw, offset);
243 if (offset < 0)
244 return offset;
245
246 ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 1);
247 if (ret)
248 return ret;
249
250 if (header.extended_short.cap == TB_SWITCH_CAP_VSE &&
251 header.extended_short.vsec_id == vsec)
252 return offset;
253 } while (offset);
254
255 return -ENOENT;
256}