xref: /openbmc/linux/drivers/thunderbolt/retimer.c (revision c10d12e3) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Thunderbolt/USB4 retimer support.
4  *
5  * Copyright (C) 2020, Intel Corporation
6  * Authors: Kranthi Kuntala <kranthi.kuntala@intel.com>
7  *	    Mika Westerberg <mika.westerberg@linux.intel.com>
8  */
9 
10 #include <linux/delay.h>
11 #include <linux/pm_runtime.h>
12 #include <linux/sched/signal.h>
13 
14 #include "sb_regs.h"
15 #include "tb.h"
16 
17 #define TB_MAX_RETIMER_INDEX	6
18 
19 static int tb_retimer_nvm_read(void *priv, unsigned int offset, void *val,
20 			       size_t bytes)
21 {
22 	struct tb_nvm *nvm = priv;
23 	struct tb_retimer *rt = tb_to_retimer(nvm->dev);
24 	int ret;
25 
26 	pm_runtime_get_sync(&rt->dev);
27 
28 	if (!mutex_trylock(&rt->tb->lock)) {
29 		ret = restart_syscall();
30 		goto out;
31 	}
32 
33 	ret = usb4_port_retimer_nvm_read(rt->port, rt->index, offset, val, bytes);
34 	mutex_unlock(&rt->tb->lock);
35 
36 out:
37 	pm_runtime_mark_last_busy(&rt->dev);
38 	pm_runtime_put_autosuspend(&rt->dev);
39 
40 	return ret;
41 }
42 
43 static int tb_retimer_nvm_write(void *priv, unsigned int offset, void *val,
44 				size_t bytes)
45 {
46 	struct tb_nvm *nvm = priv;
47 	struct tb_retimer *rt = tb_to_retimer(nvm->dev);
48 	int ret = 0;
49 
50 	if (!mutex_trylock(&rt->tb->lock))
51 		return restart_syscall();
52 
53 	ret = tb_nvm_write_buf(nvm, offset, val, bytes);
54 	mutex_unlock(&rt->tb->lock);
55 
56 	return ret;
57 }
58 
59 static int tb_retimer_nvm_add(struct tb_retimer *rt)
60 {
61 	struct tb_nvm *nvm;
62 	u32 val, nvm_size;
63 	int ret;
64 
65 	nvm = tb_nvm_alloc(&rt->dev);
66 	if (IS_ERR(nvm))
67 		return PTR_ERR(nvm);
68 
69 	ret = usb4_port_retimer_nvm_read(rt->port, rt->index, NVM_VERSION, &val,
70 					 sizeof(val));
71 	if (ret)
72 		goto err_nvm;
73 
74 	nvm->major = val >> 16;
75 	nvm->minor = val >> 8;
76 
77 	ret = usb4_port_retimer_nvm_read(rt->port, rt->index, NVM_FLASH_SIZE,
78 					 &val, sizeof(val));
79 	if (ret)
80 		goto err_nvm;
81 
82 	nvm_size = (SZ_1M << (val & 7)) / 8;
83 	nvm_size = (nvm_size - SZ_16K) / 2;
84 
85 	ret = tb_nvm_add_active(nvm, nvm_size, tb_retimer_nvm_read);
86 	if (ret)
87 		goto err_nvm;
88 
89 	ret = tb_nvm_add_non_active(nvm, NVM_MAX_SIZE, tb_retimer_nvm_write);
90 	if (ret)
91 		goto err_nvm;
92 
93 	rt->nvm = nvm;
94 	return 0;
95 
96 err_nvm:
97 	tb_nvm_free(nvm);
98 	return ret;
99 }
100 
101 static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt)
102 {
103 	unsigned int image_size, hdr_size;
104 	const u8 *buf = rt->nvm->buf;
105 	u16 ds_size, device;
106 	int ret;
107 
108 	image_size = rt->nvm->buf_data_size;
109 	if (image_size < NVM_MIN_SIZE || image_size > NVM_MAX_SIZE)
110 		return -EINVAL;
111 
112 	/*
113 	 * FARB pointer must point inside the image and must at least
114 	 * contain parts of the digital section we will be reading here.
115 	 */
116 	hdr_size = (*(u32 *)buf) & 0xffffff;
117 	if (hdr_size + NVM_DEVID + 2 >= image_size)
118 		return -EINVAL;
119 
120 	/* Digital section start should be aligned to 4k page */
121 	if (!IS_ALIGNED(hdr_size, SZ_4K))
122 		return -EINVAL;
123 
124 	/*
125 	 * Read digital section size and check that it also fits inside
126 	 * the image.
127 	 */
128 	ds_size = *(u16 *)(buf + hdr_size);
129 	if (ds_size >= image_size)
130 		return -EINVAL;
131 
132 	/*
133 	 * Make sure the device ID in the image matches the retimer
134 	 * hardware.
135 	 */
136 	device = *(u16 *)(buf + hdr_size + NVM_DEVID);
137 	if (device != rt->device)
138 		return -EINVAL;
139 
140 	/* Skip headers in the image */
141 	buf += hdr_size;
142 	image_size -= hdr_size;
143 
144 	ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf,
145 					 image_size);
146 	if (!ret)
147 		rt->nvm->flushed = true;
148 
149 	return ret;
150 }
151 
152 static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only)
153 {
154 	u32 status;
155 	int ret;
156 
157 	if (auth_only) {
158 		ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0);
159 		if (ret)
160 			return ret;
161 	}
162 
163 	ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index);
164 	if (ret)
165 		return ret;
166 
167 	usleep_range(100, 150);
168 
169 	/*
170 	 * Check the status now if we still can access the retimer. It
171 	 * is expected that the below fails.
172 	 */
173 	ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index,
174 							&status);
175 	if (!ret) {
176 		rt->auth_status = status;
177 		return status ? -EINVAL : 0;
178 	}
179 
180 	return 0;
181 }
182 
183 static ssize_t device_show(struct device *dev, struct device_attribute *attr,
184 			   char *buf)
185 {
186 	struct tb_retimer *rt = tb_to_retimer(dev);
187 
188 	return sprintf(buf, "%#x\n", rt->device);
189 }
190 static DEVICE_ATTR_RO(device);
191 
192 static ssize_t nvm_authenticate_show(struct device *dev,
193 	struct device_attribute *attr, char *buf)
194 {
195 	struct tb_retimer *rt = tb_to_retimer(dev);
196 	int ret;
197 
198 	if (!mutex_trylock(&rt->tb->lock))
199 		return restart_syscall();
200 
201 	if (!rt->nvm)
202 		ret = -EAGAIN;
203 	else
204 		ret = sprintf(buf, "%#x\n", rt->auth_status);
205 
206 	mutex_unlock(&rt->tb->lock);
207 
208 	return ret;
209 }
210 
211 static ssize_t nvm_authenticate_store(struct device *dev,
212 	struct device_attribute *attr, const char *buf, size_t count)
213 {
214 	struct tb_retimer *rt = tb_to_retimer(dev);
215 	int val, ret;
216 
217 	pm_runtime_get_sync(&rt->dev);
218 
219 	if (!mutex_trylock(&rt->tb->lock)) {
220 		ret = restart_syscall();
221 		goto exit_rpm;
222 	}
223 
224 	if (!rt->nvm) {
225 		ret = -EAGAIN;
226 		goto exit_unlock;
227 	}
228 
229 	ret = kstrtoint(buf, 10, &val);
230 	if (ret)
231 		goto exit_unlock;
232 
233 	/* Always clear status */
234 	rt->auth_status = 0;
235 
236 	if (val) {
237 		if (val == AUTHENTICATE_ONLY) {
238 			ret = tb_retimer_nvm_authenticate(rt, true);
239 		} else {
240 			if (!rt->nvm->flushed) {
241 				if (!rt->nvm->buf) {
242 					ret = -EINVAL;
243 					goto exit_unlock;
244 				}
245 
246 				ret = tb_retimer_nvm_validate_and_write(rt);
247 				if (ret || val == WRITE_ONLY)
248 					goto exit_unlock;
249 			}
250 			if (val == WRITE_AND_AUTHENTICATE)
251 				ret = tb_retimer_nvm_authenticate(rt, false);
252 		}
253 	}
254 
255 exit_unlock:
256 	mutex_unlock(&rt->tb->lock);
257 exit_rpm:
258 	pm_runtime_mark_last_busy(&rt->dev);
259 	pm_runtime_put_autosuspend(&rt->dev);
260 
261 	if (ret)
262 		return ret;
263 	return count;
264 }
265 static DEVICE_ATTR_RW(nvm_authenticate);
266 
267 static ssize_t nvm_version_show(struct device *dev,
268 				struct device_attribute *attr, char *buf)
269 {
270 	struct tb_retimer *rt = tb_to_retimer(dev);
271 	int ret;
272 
273 	if (!mutex_trylock(&rt->tb->lock))
274 		return restart_syscall();
275 
276 	if (!rt->nvm)
277 		ret = -EAGAIN;
278 	else
279 		ret = sprintf(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);
280 
281 	mutex_unlock(&rt->tb->lock);
282 	return ret;
283 }
284 static DEVICE_ATTR_RO(nvm_version);
285 
286 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
287 			   char *buf)
288 {
289 	struct tb_retimer *rt = tb_to_retimer(dev);
290 
291 	return sprintf(buf, "%#x\n", rt->vendor);
292 }
293 static DEVICE_ATTR_RO(vendor);
294 
295 static struct attribute *retimer_attrs[] = {
296 	&dev_attr_device.attr,
297 	&dev_attr_nvm_authenticate.attr,
298 	&dev_attr_nvm_version.attr,
299 	&dev_attr_vendor.attr,
300 	NULL
301 };
302 
303 static const struct attribute_group retimer_group = {
304 	.attrs = retimer_attrs,
305 };
306 
307 static const struct attribute_group *retimer_groups[] = {
308 	&retimer_group,
309 	NULL
310 };
311 
312 static void tb_retimer_release(struct device *dev)
313 {
314 	struct tb_retimer *rt = tb_to_retimer(dev);
315 
316 	kfree(rt);
317 }
318 
319 struct device_type tb_retimer_type = {
320 	.name = "thunderbolt_retimer",
321 	.groups = retimer_groups,
322 	.release = tb_retimer_release,
323 };
324 
325 static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status)
326 {
327 	struct tb_retimer *rt;
328 	u32 vendor, device;
329 	int ret;
330 
331 	ret = usb4_port_retimer_read(port, index, USB4_SB_VENDOR_ID, &vendor,
332 				     sizeof(vendor));
333 	if (ret) {
334 		if (ret != -ENODEV)
335 			tb_port_warn(port, "failed read retimer VendorId: %d\n", ret);
336 		return ret;
337 	}
338 
339 	ret = usb4_port_retimer_read(port, index, USB4_SB_PRODUCT_ID, &device,
340 				     sizeof(device));
341 	if (ret) {
342 		if (ret != -ENODEV)
343 			tb_port_warn(port, "failed read retimer ProductId: %d\n", ret);
344 		return ret;
345 	}
346 
347 	if (vendor != PCI_VENDOR_ID_INTEL && vendor != 0x8087) {
348 		tb_port_info(port, "retimer NVM format of vendor %#x is not supported\n",
349 			     vendor);
350 		return -EOPNOTSUPP;
351 	}
352 
353 	/*
354 	 * Check that it supports NVM operations. If not then don't add
355 	 * the device at all.
356 	 */
357 	ret = usb4_port_retimer_nvm_sector_size(port, index);
358 	if (ret < 0)
359 		return ret;
360 
361 	rt = kzalloc(sizeof(*rt), GFP_KERNEL);
362 	if (!rt)
363 		return -ENOMEM;
364 
365 	rt->index = index;
366 	rt->vendor = vendor;
367 	rt->device = device;
368 	rt->auth_status = auth_status;
369 	rt->port = port;
370 	rt->tb = port->sw->tb;
371 
372 	rt->dev.parent = &port->usb4->dev;
373 	rt->dev.bus = &tb_bus_type;
374 	rt->dev.type = &tb_retimer_type;
375 	dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev),
376 		     port->port, index);
377 
378 	ret = device_register(&rt->dev);
379 	if (ret) {
380 		dev_err(&rt->dev, "failed to register retimer: %d\n", ret);
381 		put_device(&rt->dev);
382 		return ret;
383 	}
384 
385 	ret = tb_retimer_nvm_add(rt);
386 	if (ret) {
387 		dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret);
388 		device_unregister(&rt->dev);
389 		return ret;
390 	}
391 
392 	dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n",
393 		 rt->vendor, rt->device);
394 
395 	pm_runtime_no_callbacks(&rt->dev);
396 	pm_runtime_set_active(&rt->dev);
397 	pm_runtime_enable(&rt->dev);
398 	pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY);
399 	pm_runtime_mark_last_busy(&rt->dev);
400 	pm_runtime_use_autosuspend(&rt->dev);
401 
402 	return 0;
403 }
404 
405 static void tb_retimer_remove(struct tb_retimer *rt)
406 {
407 	dev_info(&rt->dev, "retimer disconnected\n");
408 	tb_nvm_free(rt->nvm);
409 	device_unregister(&rt->dev);
410 }
411 
412 struct tb_retimer_lookup {
413 	const struct tb_port *port;
414 	u8 index;
415 };
416 
417 static int retimer_match(struct device *dev, void *data)
418 {
419 	const struct tb_retimer_lookup *lookup = data;
420 	struct tb_retimer *rt = tb_to_retimer(dev);
421 
422 	return rt && rt->port == lookup->port && rt->index == lookup->index;
423 }
424 
425 static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index)
426 {
427 	struct tb_retimer_lookup lookup = { .port = port, .index = index };
428 	struct device *dev;
429 
430 	dev = device_find_child(&port->usb4->dev, &lookup, retimer_match);
431 	if (dev)
432 		return tb_to_retimer(dev);
433 
434 	return NULL;
435 }
436 
437 /**
438  * tb_retimer_scan() - Scan for on-board retimers under port
439  * @port: USB4 port to scan
440  * @add: If true also registers found retimers
441  *
442  * Brings the sideband into a state where retimers can be accessed.
443  * Then Tries to enumerate on-board retimers connected to @port. Found
444  * retimers are registered as children of @port if @add is set.  Does
445  * not scan for cable retimers for now.
446  */
447 int tb_retimer_scan(struct tb_port *port, bool add)
448 {
449 	u32 status[TB_MAX_RETIMER_INDEX + 1] = {};
450 	int ret, i, last_idx = 0;
451 	struct usb4_port *usb4;
452 
453 	usb4 = port->usb4;
454 	if (!usb4)
455 		return 0;
456 
457 	pm_runtime_get_sync(&usb4->dev);
458 
459 	/*
460 	 * Send broadcast RT to make sure retimer indices facing this
461 	 * port are set.
462 	 */
463 	ret = usb4_port_enumerate_retimers(port);
464 	if (ret)
465 		goto out;
466 
467 	/*
468 	 * Enable sideband channel for each retimer. We can do this
469 	 * regardless whether there is device connected or not.
470 	 */
471 	for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
472 		usb4_port_retimer_set_inbound_sbtx(port, i);
473 
474 	/*
475 	 * Before doing anything else, read the authentication status.
476 	 * If the retimer has it set, store it for the new retimer
477 	 * device instance.
478 	 */
479 	for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
480 		usb4_port_retimer_nvm_authenticate_status(port, i, &status[i]);
481 
482 	for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) {
483 		/*
484 		 * Last retimer is true only for the last on-board
485 		 * retimer (the one connected directly to the Type-C
486 		 * port).
487 		 */
488 		ret = usb4_port_retimer_is_last(port, i);
489 		if (ret > 0)
490 			last_idx = i;
491 		else if (ret < 0)
492 			break;
493 	}
494 
495 	if (!last_idx) {
496 		ret = 0;
497 		goto out;
498 	}
499 
500 	/* Add on-board retimers if they do not exist already */
501 	for (i = 1; i <= last_idx; i++) {
502 		struct tb_retimer *rt;
503 
504 		rt = tb_port_find_retimer(port, i);
505 		if (rt) {
506 			put_device(&rt->dev);
507 		} else if (add) {
508 			ret = tb_retimer_add(port, i, status[i]);
509 			if (ret && ret != -EOPNOTSUPP)
510 				break;
511 		}
512 	}
513 
514 out:
515 	pm_runtime_mark_last_busy(&usb4->dev);
516 	pm_runtime_put_autosuspend(&usb4->dev);
517 
518 	return ret;
519 }
520 
521 static int remove_retimer(struct device *dev, void *data)
522 {
523 	struct tb_retimer *rt = tb_to_retimer(dev);
524 	struct tb_port *port = data;
525 
526 	if (rt && rt->port == port)
527 		tb_retimer_remove(rt);
528 	return 0;
529 }
530 
531 /**
532  * tb_retimer_remove_all() - Remove all retimers under port
533  * @port: USB4 port whose retimers to remove
534  *
535  * This removes all previously added retimers under @port.
536  */
537 void tb_retimer_remove_all(struct tb_port *port)
538 {
539 	struct usb4_port *usb4;
540 
541 	usb4 = port->usb4;
542 	if (usb4)
543 		device_for_each_child_reverse(&usb4->dev, port,
544 					      remove_retimer);
545 }
546