[linux-2.6-block.git] / drivers / thunderbolt / retimer.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Thunderbolt/USB4 retimer support.
 *
 * Copyright (C) 2020, Intel Corporation
 * Authors: Kranthi Kuntala <kranthi.kuntala@intel.com>
 *	    Mika Westerberg <mika.westerberg@linux.intel.com>
 */

#include <linux/delay.h>
#include <linux/pm_runtime.h>
#include <linux/sched/signal.h>

#include "sb_regs.h"
#include "tb.h"

#define TB_MAX_RETIMER_INDEX	6

/**
 * tb_retimer_nvm_read() - Read contents of retimer NVM
 * @rt: Retimer device
 * @address: NVM address (in bytes) to start reading
 * @buf: Data read from NVM is stored here
 * @size: Number of bytes to read
 *
 * Reads retimer NVM and copies the contents to @buf. Returns %0 if the
 * read was successful and negative errno in case of failure.
 */
int tb_retimer_nvm_read(struct tb_retimer *rt, unsigned int address, void *buf,
			size_t size)
{
	return usb4_port_retimer_nvm_read(rt->port, rt->index, address, buf, size);
}

static int nvm_read(void *priv, unsigned int offset, void *val, size_t bytes)
{
	struct tb_nvm *nvm = priv;
	struct tb_retimer *rt = tb_to_retimer(nvm->dev);
	int ret;

	pm_runtime_get_sync(&rt->dev);

	if (!mutex_trylock(&rt->tb->lock)) {
		ret = restart_syscall();
		goto out;
	}

	ret = tb_retimer_nvm_read(rt, offset, val, bytes);
	mutex_unlock(&rt->tb->lock);

out:
	pm_runtime_mark_last_busy(&rt->dev);
	pm_runtime_put_autosuspend(&rt->dev);

	return ret;
}

static int nvm_write(void *priv, unsigned int offset, void *val, size_t bytes)
{
	struct tb_nvm *nvm = priv;
	struct tb_retimer *rt = tb_to_retimer(nvm->dev);
	int ret = 0;

	if (!mutex_trylock(&rt->tb->lock))
		return restart_syscall();

	ret = tb_nvm_write_buf(nvm, offset, val, bytes);
	mutex_unlock(&rt->tb->lock);

	return ret;
}

static int tb_retimer_nvm_add(struct tb_retimer *rt)
{
	struct tb_nvm *nvm;
	int ret;

	nvm = tb_nvm_alloc(&rt->dev);
	if (IS_ERR(nvm)) {
		ret = PTR_ERR(nvm) == -EOPNOTSUPP ? 0 : PTR_ERR(nvm);
		goto err_nvm;
	}

	ret = tb_nvm_read_version(nvm);
	if (ret)
		goto err_nvm;

	ret = tb_nvm_add_active(nvm, nvm_read);
	if (ret)
		goto err_nvm;

	ret = tb_nvm_add_non_active(nvm, nvm_write);
	if (ret)
		goto err_nvm;

	rt->nvm = nvm;
	dev_dbg(&rt->dev, "NVM version %x.%x\n", nvm->major, nvm->minor);
	return 0;

err_nvm:
	dev_dbg(&rt->dev, "NVM upgrade disabled\n");
	if (!IS_ERR(nvm))
		tb_nvm_free(nvm);

	return ret;
}

static int tb_retimer_nvm_validate_and_write(struct tb_retimer *rt)
{
	unsigned int image_size;
	const u8 *buf;
	int ret;

	ret = tb_nvm_validate(rt->nvm);
	if (ret)
		return ret;

	buf = rt->nvm->buf_data_start;
	image_size = rt->nvm->buf_data_size;

	ret = usb4_port_retimer_nvm_write(rt->port, rt->index, 0, buf,
					 image_size);
	if (ret)
		return ret;

	rt->nvm->flushed = true;
	return 0;
}

static int tb_retimer_nvm_authenticate(struct tb_retimer *rt, bool auth_only)
{
	u32 status;
	int ret;

	if (auth_only) {
		ret = usb4_port_retimer_nvm_set_offset(rt->port, rt->index, 0);
		if (ret)
			return ret;
	}

	ret = usb4_port_retimer_nvm_authenticate(rt->port, rt->index);
	if (ret)
		return ret;

	usleep_range(100, 150);

	/*
	 * Check the status now if we still can access the retimer. It
	 * is expected that the below fails.
	 */
	ret = usb4_port_retimer_nvm_authenticate_status(rt->port, rt->index,
							&status);
	if (!ret) {
		rt->auth_status = status;
		return status ? -EINVAL : 0;
	}

	return 0;
}

static ssize_t device_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct tb_retimer *rt = tb_to_retimer(dev);

	return sysfs_emit(buf, "%#x\n", rt->device);
}
static DEVICE_ATTR_RO(device);

static ssize_t nvm_authenticate_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct tb_retimer *rt = tb_to_retimer(dev);
	int ret;

	if (!mutex_trylock(&rt->tb->lock))
		return restart_syscall();

	if (!rt->nvm)
		ret = -EAGAIN;
	else if (rt->no_nvm_upgrade)
		ret = -EOPNOTSUPP;
	else
		ret = sysfs_emit(buf, "%#x\n", rt->auth_status);

	mutex_unlock(&rt->tb->lock);

	return ret;
}

static void tb_retimer_nvm_authenticate_status(struct tb_port *port, u32 *status)
{
	int i;

	tb_port_dbg(port, "reading NVM authentication status of retimers\n");

	/*
	 * Before doing anything else, read the authentication status.
	 * If the retimer has it set, store it for the new retimer
	 * device instance.
	 */
	for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
		usb4_port_retimer_nvm_authenticate_status(port, i, &status[i]);
}

static void tb_retimer_set_inbound_sbtx(struct tb_port *port)
{
	int i;

	/*
	 * When USB4 port is online sideband communications are
	 * already up.
	 */
	if (!usb4_port_device_is_offline(port->usb4))
		return;

	tb_port_dbg(port, "enabling sideband transactions\n");

	for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++)
		usb4_port_retimer_set_inbound_sbtx(port, i);
}

static void tb_retimer_unset_inbound_sbtx(struct tb_port *port)
{
	int i;

	/*
	 * When USB4 port is offline we need to keep the sideband
	 * communications up to make it possible to communicate with
	 * the connected retimers.
	 */
	if (usb4_port_device_is_offline(port->usb4))
		return;

	tb_port_dbg(port, "disabling sideband transactions\n");

	for (i = TB_MAX_RETIMER_INDEX; i >= 1; i--)
		usb4_port_retimer_unset_inbound_sbtx(port, i);
}

static ssize_t nvm_authenticate_store(struct device *dev,
	struct device_attribute *attr, const char *buf, size_t count)
{
	struct tb_retimer *rt = tb_to_retimer(dev);
	int val, ret;

	pm_runtime_get_sync(&rt->dev);

	if (!mutex_trylock(&rt->tb->lock)) {
		ret = restart_syscall();
		goto exit_rpm;
	}

	if (!rt->nvm) {
		ret = -EAGAIN;
		goto exit_unlock;
	}

	ret = kstrtoint(buf, 10, &val);
	if (ret)
		goto exit_unlock;

	/* Always clear status */
	rt->auth_status = 0;

	if (val) {
		/*
		 * When NVM authentication starts the retimer is not
		 * accessible so calling tb_retimer_unset_inbound_sbtx()
		 * will fail and therefore we do not call it. Exception
		 * is when the validation fails or we only write the new
		 * NVM image without authentication.
		 */
		tb_retimer_set_inbound_sbtx(rt->port);
		if (val == AUTHENTICATE_ONLY) {
			ret = tb_retimer_nvm_authenticate(rt, true);
		} else {
			if (!rt->nvm->flushed) {
				if (!rt->nvm->buf) {
					ret = -EINVAL;
					goto exit_unlock;
				}

				ret = tb_retimer_nvm_validate_and_write(rt);
				if (ret || val == WRITE_ONLY)
					goto exit_unlock;
			}
			if (val == WRITE_AND_AUTHENTICATE)
				ret = tb_retimer_nvm_authenticate(rt, false);
		}
	}

exit_unlock:
	if (ret || val == WRITE_ONLY)
		tb_retimer_unset_inbound_sbtx(rt->port);
	mutex_unlock(&rt->tb->lock);
exit_rpm:
	pm_runtime_mark_last_busy(&rt->dev);
	pm_runtime_put_autosuspend(&rt->dev);

	if (ret)
		return ret;
	return count;
}
static DEVICE_ATTR_RW(nvm_authenticate);

static ssize_t nvm_version_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct tb_retimer *rt = tb_to_retimer(dev);
	int ret;

	if (!mutex_trylock(&rt->tb->lock))
		return restart_syscall();

	if (!rt->nvm)
		ret = -EAGAIN;
	else
		ret = sysfs_emit(buf, "%x.%x\n", rt->nvm->major, rt->nvm->minor);

	mutex_unlock(&rt->tb->lock);
	return ret;
}
static DEVICE_ATTR_RO(nvm_version);

static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct tb_retimer *rt = tb_to_retimer(dev);

	return sysfs_emit(buf, "%#x\n", rt->vendor);
}
static DEVICE_ATTR_RO(vendor);

static struct attribute *retimer_attrs[] = {
	&dev_attr_device.attr,
	&dev_attr_nvm_authenticate.attr,
	&dev_attr_nvm_version.attr,
	&dev_attr_vendor.attr,
	NULL
};

static const struct attribute_group retimer_group = {
	.attrs = retimer_attrs,
};

static const struct attribute_group *retimer_groups[] = {
	&retimer_group,
	NULL
};

static void tb_retimer_release(struct device *dev)
{
	struct tb_retimer *rt = tb_to_retimer(dev);

	kfree(rt);
}

struct device_type tb_retimer_type = {
	.name = "thunderbolt_retimer",
	.groups = retimer_groups,
	.release = tb_retimer_release,
};

static int tb_retimer_add(struct tb_port *port, u8 index, u32 auth_status)
{
	struct tb_retimer *rt;
	u32 vendor, device;
	int ret;

	ret = usb4_port_retimer_read(port, index, USB4_SB_VENDOR_ID, &vendor,
				     sizeof(vendor));
	if (ret) {
		if (ret != -ENODEV)
			tb_port_warn(port, "failed read retimer VendorId: %d\n", ret);
		return ret;
	}

	ret = usb4_port_retimer_read(port, index, USB4_SB_PRODUCT_ID, &device,
				     sizeof(device));
	if (ret) {
		if (ret != -ENODEV)
			tb_port_warn(port, "failed read retimer ProductId: %d\n", ret);
		return ret;
	}

	/*
	 * Check that it supports NVM operations. If not then don't add
	 * the device at all.
	 */
	ret = usb4_port_retimer_nvm_sector_size(port, index);
	if (ret < 0)
		return ret;

	rt = kzalloc(sizeof(*rt), GFP_KERNEL);
	if (!rt)
		return -ENOMEM;

	rt->index = index;
	rt->vendor = vendor;
	rt->device = device;
	rt->auth_status = auth_status;
	rt->port = port;
	rt->tb = port->sw->tb;

	rt->dev.parent = &port->usb4->dev;
	rt->dev.bus = &tb_bus_type;
	rt->dev.type = &tb_retimer_type;
	dev_set_name(&rt->dev, "%s:%u.%u", dev_name(&port->sw->dev),
		     port->port, index);

	ret = device_register(&rt->dev);
	if (ret) {
		dev_err(&rt->dev, "failed to register retimer: %d\n", ret);
		put_device(&rt->dev);
		return ret;
	}

	ret = tb_retimer_nvm_add(rt);
	if (ret) {
		dev_err(&rt->dev, "failed to add NVM devices: %d\n", ret);
		device_unregister(&rt->dev);
		return ret;
	}

	dev_info(&rt->dev, "new retimer found, vendor=%#x device=%#x\n",
		 rt->vendor, rt->device);

	pm_runtime_no_callbacks(&rt->dev);
	pm_runtime_set_active(&rt->dev);
	pm_runtime_enable(&rt->dev);
	pm_runtime_set_autosuspend_delay(&rt->dev, TB_AUTOSUSPEND_DELAY);
	pm_runtime_mark_last_busy(&rt->dev);
	pm_runtime_use_autosuspend(&rt->dev);

	return 0;
}

static void tb_retimer_remove(struct tb_retimer *rt)
{
	dev_info(&rt->dev, "retimer disconnected\n");
	tb_nvm_free(rt->nvm);
	device_unregister(&rt->dev);
}

struct tb_retimer_lookup {
	const struct tb_port *port;
	u8 index;
};

static int retimer_match(struct device *dev, void *data)
{
	const struct tb_retimer_lookup *lookup = data;
	struct tb_retimer *rt = tb_to_retimer(dev);

	return rt && rt->port == lookup->port && rt->index == lookup->index;
}

static struct tb_retimer *tb_port_find_retimer(struct tb_port *port, u8 index)
{
	struct tb_retimer_lookup lookup = { .port = port, .index = index };
	struct device *dev;

	dev = device_find_child(&port->usb4->dev, &lookup, retimer_match);
	if (dev)
		return tb_to_retimer(dev);

	return NULL;
}

/**
 * tb_retimer_scan() - Scan for on-board retimers under port
 * @port: USB4 port to scan
 * @add: If true also registers found retimers
 *
 * Brings the sideband into a state where retimers can be accessed.
 * Then Tries to enumerate on-board retimers connected to @port. Found
 * retimers are registered as children of @port if @add is set.  Does
 * not scan for cable retimers for now.
 */
int tb_retimer_scan(struct tb_port *port, bool add)
{
	u32 status[TB_MAX_RETIMER_INDEX + 1] = {};
	int ret, i, last_idx = 0;

	/*
	 * Send broadcast RT to make sure retimer indices facing this
	 * port are set.
	 */
	ret = usb4_port_enumerate_retimers(port);
	if (ret)
		return ret;

	/*
	 * Immediately after sending enumerate retimers read the
	 * authentication status of each retimer.
	 */
	tb_retimer_nvm_authenticate_status(port, status);

	/*
	 * Enable sideband channel for each retimer. We can do this
	 * regardless whether there is device connected or not.
	 */
	tb_retimer_set_inbound_sbtx(port);

	for (i = 1; i <= TB_MAX_RETIMER_INDEX; i++) {
		/*
		 * Last retimer is true only for the last on-board
		 * retimer (the one connected directly to the Type-C
		 * port).
		 */
		ret = usb4_port_retimer_is_last(port, i);
		if (ret > 0)
			last_idx = i;
		else if (ret < 0)
			break;
	}

	tb_retimer_unset_inbound_sbtx(port);

	if (!last_idx)
		return 0;

	/* Add on-board retimers if they do not exist already */
	ret = 0;
	for (i = 1; i <= last_idx; i++) {
		struct tb_retimer *rt;

		rt = tb_port_find_retimer(port, i);
		if (rt) {
			put_device(&rt->dev);
		} else if (add) {
			ret = tb_retimer_add(port, i, status[i]);
			if (ret && ret != -EOPNOTSUPP)
				break;
		}
	}

	return ret;
}

static int remove_retimer(struct device *dev, void *data)
{
	struct tb_retimer *rt = tb_to_retimer(dev);
	struct tb_port *port = data;

	if (rt && rt->port == port)
		tb_retimer_remove(rt);
	return 0;
}

/**
 * tb_retimer_remove_all() - Remove all retimers under port
 * @port: USB4 port whose retimers to remove
 *
 * This removes all previously added retimers under @port.
 */
void tb_retimer_remove_all(struct tb_port *port)
{
	struct usb4_port *usb4;

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