projects/linux·blob master · refs

600 lines · 13.3 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Thunderbolt/USB4 retimer support.
4 *
5 * Copyright (C) 2020, Intel Corporation
6 * Authors: Kranthi Kuntala <[email protected]>
7 * Mika Westerberg <[email protected]>
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#if IS_ENABLED(CONFIG_USB4_DEBUGFS_MARGINING)
18#define TB_MAX_RETIMER_INDEX 6
19#else
20#define TB_MAX_RETIMER_INDEX 2
21#endif
22
23/**
24 * tb_retimer_nvm_read() - Read contents of retimer NVM
25 * @rt: Retimer device
26 * @address: NVM address (in bytes) to start reading
27 * @buf: Data read from NVM is stored here
28 * @size: Number of bytes to read
29 *
30 * Reads retimer NVM and copies the contents to @buf.
31 *
32 * Return: %0 if the read was successful, negative errno in case of failure.
33 */
34int tb_retimer_nvm_read(struct tb_retimer *rt, unsigned int address, void *buf,
35 size_t size)
36{
37 return usb4_port_retimer_nvm_read(rt->port, rt->index, address, buf, size);
38}
39
40static int nvm_read(void *priv, unsigned int offset, void *val, size_t bytes)
41{
42 struct tb_nvm *nvm = priv;
43 struct tb_retimer *rt = tb_to_retimer(nvm->dev);
44 int ret;
45
46 pm_runtime_get_sync(&rt->dev);
47
48 if (!mutex_trylock(&rt->tb->lock)) {
49 ret = restart_syscall();
50 goto out;
51 }
52
53 ret = tb_retimer_nvm_read(rt, offset, val, bytes);
54 mutex_unlock(&rt->tb->lock);
55
56out:
57 pm_runtime_mark_last_busy(&rt->dev);
58 pm_runtime_put_autosuspend(&rt->dev);
59
60 return ret;
61}
62
63static int nvm_write(void *priv, unsigned int offset, void *val, size_t bytes)
64{
65 struct tb_nvm *nvm = priv;
66 struct tb_retimer *rt = tb_to_retimer(nvm->dev);
67 int ret = 0;
68
69 if (!mutex_trylock(&rt->tb->lock))
70 return restart_syscall();
71
72 ret = tb_nvm_write_buf(nvm, offset, val, bytes);
73 mutex_unlock(&rt->tb->lock);
74
75 return ret;
76}
77
78static int tb_retimer_nvm_add(struct tb_retimer *rt)
79{
80 struct tb_nvm *nvm;
81 int ret;
82
83 nvm = tb_nvm_alloc(&rt->dev);
84 if (IS_ERR(nvm)) {
85 ret = PTR_ERR(nvm) == -EOPNOTSUPP ? 0 : PTR_ERR(nvm);
86 goto err_nvm;
87 }
88
89 ret = tb_nvm_read_version(nvm);
90 if (ret)
91 goto err_nvm;
92
93 ret = tb_nvm_add_active(nvm, nvm_read);
94 if (ret)
95 goto err_nvm;
96
97 if (!rt->no_nvm_upgrade) {
98 ret = tb_nvm_add_non_active(nvm, nvm_write);
99 if (ret)
100 goto err_nvm;
101 }
102
103 rt->nvm = nvm;
104 dev_dbg(&rt->dev, "NVM version %x.%x\n", nvm->major, nvm->minor);
105 return 0;
106
107err_nvm:
108 dev_dbg(&rt->dev, "NVM upgrade disabled\n");
109 rt->no_nvm_upgrade = true;
110 if (!IS_ERR(nvm))
111 tb_nvm_free(nvm);
112
113 return ret;
114}
115
116static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt)
117{
118 unsigned int image_size;
119 const u8 *buf;
120 int ret;
121
122 ret = tb_nvm_validate(rt->nvm);
123 if (ret)
124 return ret;
125
126 buf = rt->nvm->buf_data_start;
127 image_size = rt->nvm->buf_data_size;
128
129 ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf,
130 image_size);
131 if (ret)
132 return ret;
133
134 rt->nvm->flushed = true;
135 return 0;
136}
137
138static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only)
139{
140 u32 status;
141 int ret;
142
143 if (auth_only) {
144 ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0);
145 if (ret)
146 return ret;
147 }
148
149 ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index);
150 if (ret)
151 return ret;
152
153 usleep_range(100, 150);
154
155 /*
156 * Check the status now if we still can access the retimer. It
157 * is expected that the below fails.
158 */
159 ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index,
160 &status);
161 if (!ret) {
162 rt->auth_status = status;
163 return status ? -EINVAL : 0;
164 }
165
166 return 0;
167}
168
169static ssize_t device_show(struct device *dev, struct device_attribute *attr,
170 char *buf)
171{
172 struct tb_retimer *rt = tb_to_retimer(dev);
173
174 return sysfs_emit(buf, "%#x\n", rt->device);
175}
176static DEVICE_ATTR_RO(device);
177
178static ssize_t nvm_authenticate_show(struct device *dev,
179 struct device_attribute *attr, char *buf)
180{
181 struct tb_retimer *rt = tb_to_retimer(dev);
182 int ret;
183
184 if (!mutex_trylock(&rt->tb->lock))
185 return restart_syscall();
186
187 if (!rt->nvm)
188 ret = -EAGAIN;
189 else
190 ret = sysfs_emit(buf, "%#x\n", rt->auth_status);
191
192 mutex_unlock(&rt->tb->lock);
193
194 return ret;
195}
196
197static void tb_retimer_nvm_authenticate_status(struct tb_port *port, u32 *status)
198{
199 int i;
200
201 tb_port_dbg(port, "reading NVM authentication status of retimers\n");
202
203 /*
204 * Before doing anything else, read the authentication status.
205 * If the retimer has it set, store it for the new retimer
206 * device instance.
207 */
208 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) {
209 if (usb4_port_retimer_nvm_authenticate_status(port, i, &status[i]))
210 break;
211 }
212}
213
214static void tb_retimer_set_inbound_sbtx(struct tb_port *port)
215{
216 int i;
217
218 /*
219 * When USB4 port is online sideband communications are
220 * already up.
221 */
222 if (!usb4_port_device_is_offline(port->usb4))
223 return;
224
225 tb_port_dbg(port, "enabling sideband transactions\n");
226
227 for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
228 usb4_port_retimer_set_inbound_sbtx(port, i);
229}
230
231static void tb_retimer_unset_inbound_sbtx(struct tb_port *port)
232{
233 int i;
234
235 /*
236 * When USB4 port is offline we need to keep the sideband
237 * communications up to make it possible to communicate with
238 * the connected retimers.
239 */
240 if (usb4_port_device_is_offline(port->usb4))
241 return;
242
243 tb_port_dbg(port, "disabling sideband transactions\n");
244
245 for (i = TB_MAX_RETIMER_INDEX; i >= 1; i--) {
246 if (usb4_port_retimer_unset_inbound_sbtx(port, i))
247 break;
248 }
249}
250
251static ssize_t nvm_authenticate_store(struct device *dev,
252 struct device_attribute *attr, const char *buf, size_t count)
253{
254 struct tb_retimer *rt = tb_to_retimer(dev);
255 int val, ret;
256
257 pm_runtime_get_sync(&rt->dev);
258
259 if (!mutex_trylock(&rt->tb->lock)) {
260 ret = restart_syscall();
261 goto exit_rpm;
262 }
263
264 if (!rt->nvm) {
265 ret = -EAGAIN;
266 goto exit_unlock;
267 }
268
269 ret = kstrtoint(buf, 10, &val);
270 if (ret)
271 goto exit_unlock;
272
273 /* Always clear status */
274 rt->auth_status = 0;
275
276 if (val) {
277 /*
278 * When NVM authentication starts the retimer is not
279 * accessible so calling tb_retimer_unset_inbound_sbtx()
280 * will fail and therefore we do not call it. Exception
281 * is when the validation fails or we only write the new
282 * NVM image without authentication.
283 */
284 tb_retimer_set_inbound_sbtx(rt->port);
285 if (val == AUTHENTICATE_ONLY) {
286 ret = tb_retimer_nvm_authenticate(rt, true);
287 } else {
288 if (!rt->nvm->flushed) {
289 if (!rt->nvm->buf) {
290 ret = -EINVAL;
291 goto exit_unlock;
292 }
293
294 ret = tb_retimer_nvm_validate_and_write(rt);
295 if (ret || val == WRITE_ONLY)
296 goto exit_unlock;
297 }
298 if (val == WRITE_AND_AUTHENTICATE)
299 ret = tb_retimer_nvm_authenticate(rt, false);
300 }
301 }
302
303exit_unlock:
304 if (ret || val == WRITE_ONLY)
305 tb_retimer_unset_inbound_sbtx(rt->port);
306 mutex_unlock(&rt->tb->lock);
307exit_rpm:
308 pm_runtime_mark_last_busy(&rt->dev);
309 pm_runtime_put_autosuspend(&rt->dev);
310
311 if (ret)
312 return ret;
313 return count;
314}
315static DEVICE_ATTR_RW(nvm_authenticate);
316
317static ssize_t nvm_version_show(struct device *dev,
318 struct device_attribute *attr, char *buf)
319{
320 struct tb_retimer *rt = tb_to_retimer(dev);
321 int ret;
322
323 if (!mutex_trylock(&rt->tb->lock))
324 return restart_syscall();
325
326 if (!rt->nvm)
327 ret = -EAGAIN;
328 else
329 ret = sysfs_emit(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);
330
331 mutex_unlock(&rt->tb->lock);
332 return ret;
333}
334static DEVICE_ATTR_RO(nvm_version);
335
336static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
337 char *buf)
338{
339 struct tb_retimer *rt = tb_to_retimer(dev);
340
341 return sysfs_emit(buf, "%#x\n", rt->vendor);
342}
343static DEVICE_ATTR_RO(vendor);
344
345static umode_t retimer_is_visible(struct kobject *kobj, struct attribute *attr,
346 int n)
347{
348 struct device *dev = kobj_to_dev(kobj);
349 struct tb_retimer *rt = tb_to_retimer(dev);
350
351 if (attr == &dev_attr_nvm_authenticate.attr ||
352 attr == &dev_attr_nvm_version.attr)
353 return rt->no_nvm_upgrade ? 0 : attr->mode;
354
355 return attr->mode;
356}
357
358static struct attribute *retimer_attrs[] = {
359 &dev_attr_device.attr,
360 &dev_attr_nvm_authenticate.attr,
361 &dev_attr_nvm_version.attr,
362 &dev_attr_vendor.attr,
363 NULL
364};
365
366static const struct attribute_group retimer_group = {
367 .is_visible = retimer_is_visible,
368 .attrs = retimer_attrs,
369};
370
371static const struct attribute_group *retimer_groups[] = {
372 &retimer_group,
373 NULL
374};
375
376static void tb_retimer_release(struct device *dev)
377{
378 struct tb_retimer *rt = tb_to_retimer(dev);
379
380 kfree(rt);
381}
382
383const struct device_type tb_retimer_type = {
384 .name = "thunderbolt_retimer",
385 .groups = retimer_groups,
386 .release = tb_retimer_release,
387};
388
389static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status,
390 bool on_board)
391{
392 struct tb_retimer *rt;
393 u32 vendor, device;
394 int ret;
395
396 ret = usb4_port_sb_read(port, USB4_SB_TARGET_RETIMER, index,
397 USB4_SB_VENDOR_ID, &vendor, sizeof(vendor));
398 if (ret) {
399 if (ret != -ENODEV)
400 tb_port_warn(port, "failed read retimer VendorId: %d\n", ret);
401 return ret;
402 }
403
404 ret = usb4_port_sb_read(port, USB4_SB_TARGET_RETIMER, index,
405 USB4_SB_PRODUCT_ID, &device, sizeof(device));
406 if (ret) {
407 if (ret != -ENODEV)
408 tb_port_warn(port, "failed read retimer ProductId: %d\n", ret);
409 return ret;
410 }
411
412
413 rt = kzalloc_obj(*rt);
414 if (!rt)
415 return -ENOMEM;
416
417 rt->index = index;
418 rt->vendor = vendor;
419 rt->device = device;
420 rt->auth_status = auth_status;
421 rt->port = port;
422 rt->tb = port->sw->tb;
423
424 /*
425 * Only support NVM upgrade for on-board retimers. The retimers
426 * on the other side of the connection.
427 */
428 if (!on_board || usb4_port_retimer_nvm_sector_size(port, index) <= 0)
429 rt->no_nvm_upgrade = true;
430
431 rt->dev.parent = &port->usb4->dev;
432 rt->dev.bus = &tb_bus_type;
433 rt->dev.type = &tb_retimer_type;
434 dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev),
435 port->port, index);
436
437 ret = device_register(&rt->dev);
438 if (ret) {
439 dev_err(&rt->dev, "failed to register retimer: %d\n", ret);
440 put_device(&rt->dev);
441 return ret;
442 }
443
444 ret = tb_retimer_nvm_add(rt);
445 if (ret) {
446 dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret);
447 device_unregister(&rt->dev);
448 return ret;
449 }
450
451 dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n",
452 rt->vendor, rt->device);
453
454 pm_runtime_no_callbacks(&rt->dev);
455 pm_runtime_set_active(&rt->dev);
456 pm_runtime_enable(&rt->dev);
457 pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY);
458 pm_runtime_mark_last_busy(&rt->dev);
459 pm_runtime_use_autosuspend(&rt->dev);
460
461 tb_retimer_debugfs_init(rt);
462 return 0;
463}
464
465static void tb_retimer_remove(struct tb_retimer *rt)
466{
467 dev_info(&rt->dev, "retimer disconnected\n");
468 tb_retimer_debugfs_remove(rt);
469 tb_nvm_free(rt->nvm);
470 device_unregister(&rt->dev);
471}
472
473struct tb_retimer_lookup {
474 const struct tb_port *port;
475 u8 index;
476};
477
478static int retimer_match(struct device *dev, const void *data)
479{
480 const struct tb_retimer_lookup *lookup = data;
481 struct tb_retimer *rt = tb_to_retimer(dev);
482
483 return rt && rt->port == lookup->port && rt->index == lookup->index;
484}
485
486static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index)
487{
488 struct tb_retimer_lookup lookup = { .port = port, .index = index };
489 struct device *dev;
490
491 dev = device_find_child(&port->usb4->dev, &lookup, retimer_match);
492 if (dev)
493 return tb_to_retimer(dev);
494
495 return NULL;
496}
497
498/**
499 * tb_retimer_scan() - Scan for on-board retimers under port
500 * @port: USB4 port to scan
501 * @add: If true also registers found retimers
502 *
503 * Brings the sideband into a state where retimers can be accessed.
504 * Then tries to enumerate on-board retimers connected to @port. Found
505 * retimers are registered as children of @port if @add is set. Does
506 * not scan for cable retimers for now.
507 *
508 * Return: %0 on success, negative errno otherwise.
509 */
510int tb_retimer_scan(struct tb_port *port, bool add)
511{
512 u32 status[TB_MAX_RETIMER_INDEX + 1] = {};
513 int ret, i, max, last_idx = 0;
514
515 /*
516 * Send broadcast RT to make sure retimer indices facing this
517 * port are set.
518 */
519 ret = usb4_port_enumerate_retimers(port);
520 if (ret)
521 return ret;
522
523 /*
524 * Immediately after sending enumerate retimers read the
525 * authentication status of each retimer.
526 */
527 tb_retimer_nvm_authenticate_status(port, status);
528
529 /*
530 * Enable sideband channel for each retimer. We can do this
531 * regardless whether there is device connected or not.
532 */
533 tb_retimer_set_inbound_sbtx(port);
534
535 for (max = 1, i = 1; i <= TB_MAX_RETIMER_INDEX; i++) {
536 /*
537 * Last retimer is true only for the last on-board
538 * retimer (the one connected directly to the Type-C
539 * port).
540 */
541 ret = usb4_port_retimer_is_last(port, i);
542 if (ret > 0)
543 last_idx = i;
544 else if (ret < 0)
545 break;
546
547 max = i;
548 }
549
550 ret = 0;
551 if (!IS_ENABLED(CONFIG_USB4_DEBUGFS_MARGINING))
552 max = min(last_idx, max);
553
554 /* Add retimers if they do not exist already */
555 for (i = 1; i <= max; i++) {
556 struct tb_retimer *rt;
557
558 /* Skip cable retimers */
559 if (usb4_port_retimer_is_cable(port, i))
560 continue;
561
562 rt = tb_port_find_retimer(port, i);
563 if (rt) {
564 put_device(&rt->dev);
565 } else if (add) {
566 ret = tb_retimer_add(port, i, status[i], i <= last_idx);
567 if (ret && ret != -EOPNOTSUPP)
568 break;
569 }
570 }
571
572 tb_retimer_unset_inbound_sbtx(port);
573 return ret;
574}
575
576static int remove_retimer(struct device *dev, void *data)
577{
578 struct tb_retimer *rt = tb_to_retimer(dev);
579 struct tb_port *port = data;
580
581 if (rt && rt->port == port)
582 tb_retimer_remove(rt);
583 return 0;
584}
585
586/**
587 * tb_retimer_remove_all() - Remove all retimers under port
588 * @port: USB4 port whose retimers to remove
589 *
590 * This removes all previously added retimers under @port.
591 */
592void tb_retimer_remove_all(struct tb_port *port)
593{
594 struct usb4_port *usb4;
595
596 usb4 = port->usb4;
597 if (usb4)
598 device_for_each_child_reverse(&usb4->dev, port,
599 remove_retimer);
600}