xref: /linux/drivers/thunderbolt/cap.c (revision d0034a7a4ac7fae708146ac0059b9c47a1543f0d)
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 
tb_port_enable_tmu(struct tb_port * port,bool enable)18 static 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 
tb_port_dummy_read(struct tb_port * port)47 static 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  * Returns dword offset of the next capability in port config space
68  * capability list and returns it. Passing %0 returns the first entry in
69  * the capability list. If no next capability is found returns %0. In case
70  * of failure returns negative errno.
71  */
tb_port_next_cap(struct tb_port * port,unsigned int offset)72 int tb_port_next_cap(struct tb_port *port, unsigned int offset)
73 {
74 	struct tb_cap_any header;
75 	int ret;
76 
77 	if (!offset)
78 		return port->config.first_cap_offset;
79 
80 	ret = tb_port_read(port, &header, TB_CFG_PORT, offset, 1);
81 	if (ret)
82 		return ret;
83 
84 	return header.basic.next;
85 }
86 
__tb_port_find_cap(struct tb_port * port,enum tb_port_cap cap)87 static int __tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
88 {
89 	int offset = 0;
90 
91 	do {
92 		struct tb_cap_any header;
93 		int ret;
94 
95 		offset = tb_port_next_cap(port, offset);
96 		if (offset < 0)
97 			return offset;
98 
99 		ret = tb_port_read(port, &header, TB_CFG_PORT, offset, 1);
100 		if (ret)
101 			return ret;
102 
103 		if (header.basic.cap == cap)
104 			return offset;
105 	} while (offset > 0);
106 
107 	return -ENOENT;
108 }
109 
110 /**
111  * tb_port_find_cap() - Find port capability
112  * @port: Port to find the capability for
113  * @cap: Capability to look
114  *
115  * Returns offset to start of capability or %-ENOENT if no such
116  * capability was found. Negative errno is returned if there was an
117  * error.
118  */
tb_port_find_cap(struct tb_port * port,enum tb_port_cap cap)119 int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
120 {
121 	int ret;
122 
123 	ret = tb_port_enable_tmu(port, true);
124 	if (ret)
125 		return ret;
126 
127 	ret = __tb_port_find_cap(port, cap);
128 
129 	tb_port_dummy_read(port);
130 	tb_port_enable_tmu(port, false);
131 
132 	return ret;
133 }
134 
135 /**
136  * tb_switch_next_cap() - Return next capability in the linked list
137  * @sw: Switch to find the capability for
138  * @offset: Previous capability offset (%0 for start)
139  *
140  * Finds dword offset of the next capability in router config space
141  * capability list and returns it. Passing %0 returns the first entry in
142  * the capability list. If no next capability is found returns %0. In case
143  * of failure returns negative errno.
144  */
tb_switch_next_cap(struct tb_switch * sw,unsigned int offset)145 int tb_switch_next_cap(struct tb_switch *sw, unsigned int offset)
146 {
147 	struct tb_cap_any header;
148 	int ret;
149 
150 	if (!offset)
151 		return sw->config.first_cap_offset;
152 
153 	ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 2);
154 	if (ret)
155 		return ret;
156 
157 	switch (header.basic.cap) {
158 	case TB_SWITCH_CAP_TMU:
159 		ret = header.basic.next;
160 		break;
161 
162 	case TB_SWITCH_CAP_VSE:
163 		if (!header.extended_short.length)
164 			ret = header.extended_long.next;
165 		else
166 			ret = header.extended_short.next;
167 		break;
168 
169 	default:
170 		tb_sw_dbg(sw, "unknown capability %#x at %#x\n",
171 			  header.basic.cap, offset);
172 		ret = -EINVAL;
173 		break;
174 	}
175 
176 	return ret >= VSE_CAP_OFFSET_MAX ? 0 : ret;
177 }
178 
179 /**
180  * tb_switch_find_cap() - Find switch capability
181  * @sw: Switch to find the capability for
182  * @cap: Capability to look
183  *
184  * Returns offset to start of capability or %-ENOENT if no such
185  * capability was found. Negative errno is returned if there was an
186  * error.
187  */
tb_switch_find_cap(struct tb_switch * sw,enum tb_switch_cap cap)188 int tb_switch_find_cap(struct tb_switch *sw, enum tb_switch_cap cap)
189 {
190 	int offset = 0;
191 
192 	do {
193 		struct tb_cap_any header;
194 		int ret;
195 
196 		offset = tb_switch_next_cap(sw, offset);
197 		if (offset < 0)
198 			return offset;
199 
200 		ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 1);
201 		if (ret)
202 			return ret;
203 
204 		if (header.basic.cap == cap)
205 			return offset;
206 	} while (offset);
207 
208 	return -ENOENT;
209 }
210 
211 /**
212  * tb_switch_find_vse_cap() - Find switch vendor specific capability
213  * @sw: Switch to find the capability for
214  * @vsec: Vendor specific capability to look
215  *
216  * Functions enumerates vendor specific capabilities (VSEC) of a switch
217  * and returns offset when capability matching @vsec is found. If no
218  * such capability is found returns %-ENOENT. In case of error returns
219  * negative errno.
220  */
tb_switch_find_vse_cap(struct tb_switch * sw,enum tb_switch_vse_cap vsec)221 int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec)
222 {
223 	int offset = 0;
224 
225 	do {
226 		struct tb_cap_any header;
227 		int ret;
228 
229 		offset = tb_switch_next_cap(sw, offset);
230 		if (offset < 0)
231 			return offset;
232 
233 		ret = tb_sw_read(sw, &header, TB_CFG_SWITCH, offset, 1);
234 		if (ret)
235 			return ret;
236 
237 		if (header.extended_short.cap == TB_SWITCH_CAP_VSE &&
238 		    header.extended_short.vsec_id == vsec)
239 			return offset;
240 	} while (offset);
241 
242 	return -ENOENT;
243 }
244