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