1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * USB4 port device
4  *
5  * Copyright (C) 2021, Intel Corporation
6  * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
7  */
8 
9 #include <linux/pm_runtime.h>
10 #include <linux/component.h>
11 #include <linux/property.h>
12 
13 #include "tb.h"
14 
15 static int connector_bind(struct device *dev, struct device *connector, void *data)
16 {
17 	int ret;
18 
19 	ret = sysfs_create_link(&dev->kobj, &connector->kobj, "connector");
20 	if (ret)
21 		return ret;
22 
23 	ret = sysfs_create_link(&connector->kobj, &dev->kobj, dev_name(dev));
24 	if (ret)
25 		sysfs_remove_link(&dev->kobj, "connector");
26 
27 	return ret;
28 }
29 
30 static void connector_unbind(struct device *dev, struct device *connector, void *data)
31 {
32 	sysfs_remove_link(&connector->kobj, dev_name(dev));
33 	sysfs_remove_link(&dev->kobj, "connector");
34 }
35 
36 static const struct component_ops connector_ops = {
37 	.bind = connector_bind,
38 	.unbind = connector_unbind,
39 };
40 
41 static ssize_t link_show(struct device *dev, struct device_attribute *attr,
42 			 char *buf)
43 {
44 	struct usb4_port *usb4 = tb_to_usb4_port_device(dev);
45 	struct tb_port *port = usb4->port;
46 	struct tb *tb = port->sw->tb;
47 	const char *link;
48 
49 	if (mutex_lock_interruptible(&tb->lock))
50 		return -ERESTARTSYS;
51 
52 	if (tb_is_upstream_port(port))
53 		link = port->sw->link_usb4 ? "usb4" : "tbt";
54 	else if (tb_port_has_remote(port))
55 		link = port->remote->sw->link_usb4 ? "usb4" : "tbt";
56 	else if (port->xdomain)
57 		link = port->xdomain->link_usb4 ? "usb4" : "tbt";
58 	else
59 		link = "none";
60 
61 	mutex_unlock(&tb->lock);
62 
63 	return sysfs_emit(buf, "%s\n", link);
64 }
65 static DEVICE_ATTR_RO(link);
66 
67 static struct attribute *common_attrs[] = {
68 	&dev_attr_link.attr,
69 	NULL
70 };
71 
72 static const struct attribute_group common_group = {
73 	.attrs = common_attrs,
74 };
75 
76 static int usb4_port_offline(struct usb4_port *usb4)
77 {
78 	struct tb_port *port = usb4->port;
79 	int ret;
80 
81 	ret = tb_acpi_power_on_retimers(port);
82 	if (ret)
83 		return ret;
84 
85 	ret = usb4_port_router_offline(port);
86 	if (ret) {
87 		tb_acpi_power_off_retimers(port);
88 		return ret;
89 	}
90 
91 	ret = tb_retimer_scan(port, false);
92 	if (ret) {
93 		usb4_port_router_online(port);
94 		tb_acpi_power_off_retimers(port);
95 	}
96 
97 	return ret;
98 }
99 
100 static void usb4_port_online(struct usb4_port *usb4)
101 {
102 	struct tb_port *port = usb4->port;
103 
104 	usb4_port_router_online(port);
105 	tb_acpi_power_off_retimers(port);
106 }
107 
108 static ssize_t offline_show(struct device *dev,
109 	struct device_attribute *attr, char *buf)
110 {
111 	struct usb4_port *usb4 = tb_to_usb4_port_device(dev);
112 
113 	return sysfs_emit(buf, "%d\n", usb4->offline);
114 }
115 
116 static ssize_t offline_store(struct device *dev,
117 	struct device_attribute *attr, const char *buf, size_t count)
118 {
119 	struct usb4_port *usb4 = tb_to_usb4_port_device(dev);
120 	struct tb_port *port = usb4->port;
121 	struct tb *tb = port->sw->tb;
122 	bool val;
123 	int ret;
124 
125 	ret = kstrtobool(buf, &val);
126 	if (ret)
127 		return ret;
128 
129 	pm_runtime_get_sync(&usb4->dev);
130 
131 	if (mutex_lock_interruptible(&tb->lock)) {
132 		ret = -ERESTARTSYS;
133 		goto out_rpm;
134 	}
135 
136 	if (val == usb4->offline)
137 		goto out_unlock;
138 
139 	/* Offline mode works only for ports that are not connected */
140 	if (tb_port_has_remote(port)) {
141 		ret = -EBUSY;
142 		goto out_unlock;
143 	}
144 
145 	if (val) {
146 		ret = usb4_port_offline(usb4);
147 		if (ret)
148 			goto out_unlock;
149 	} else {
150 		usb4_port_online(usb4);
151 		tb_retimer_remove_all(port);
152 	}
153 
154 	usb4->offline = val;
155 	tb_port_dbg(port, "%s offline mode\n", val ? "enter" : "exit");
156 
157 out_unlock:
158 	mutex_unlock(&tb->lock);
159 out_rpm:
160 	pm_runtime_mark_last_busy(&usb4->dev);
161 	pm_runtime_put_autosuspend(&usb4->dev);
162 
163 	return ret ? ret : count;
164 }
165 static DEVICE_ATTR_RW(offline);
166 
167 static ssize_t rescan_store(struct device *dev,
168 	struct device_attribute *attr, const char *buf, size_t count)
169 {
170 	struct usb4_port *usb4 = tb_to_usb4_port_device(dev);
171 	struct tb_port *port = usb4->port;
172 	struct tb *tb = port->sw->tb;
173 	bool val;
174 	int ret;
175 
176 	ret = kstrtobool(buf, &val);
177 	if (ret)
178 		return ret;
179 
180 	if (!val)
181 		return count;
182 
183 	pm_runtime_get_sync(&usb4->dev);
184 
185 	if (mutex_lock_interruptible(&tb->lock)) {
186 		ret = -ERESTARTSYS;
187 		goto out_rpm;
188 	}
189 
190 	/* Must be in offline mode already */
191 	if (!usb4->offline) {
192 		ret = -EINVAL;
193 		goto out_unlock;
194 	}
195 
196 	tb_retimer_remove_all(port);
197 	ret = tb_retimer_scan(port, true);
198 
199 out_unlock:
200 	mutex_unlock(&tb->lock);
201 out_rpm:
202 	pm_runtime_mark_last_busy(&usb4->dev);
203 	pm_runtime_put_autosuspend(&usb4->dev);
204 
205 	return ret ? ret : count;
206 }
207 static DEVICE_ATTR_WO(rescan);
208 
209 static struct attribute *service_attrs[] = {
210 	&dev_attr_offline.attr,
211 	&dev_attr_rescan.attr,
212 	NULL
213 };
214 
215 static umode_t service_attr_is_visible(struct kobject *kobj,
216 				       struct attribute *attr, int n)
217 {
218 	struct device *dev = kobj_to_dev(kobj);
219 	struct usb4_port *usb4 = tb_to_usb4_port_device(dev);
220 
221 	/*
222 	 * Always need some platform help to cycle the modes so that
223 	 * retimers can be accessed through the sideband.
224 	 */
225 	return usb4->can_offline ? attr->mode : 0;
226 }
227 
228 static const struct attribute_group service_group = {
229 	.attrs = service_attrs,
230 	.is_visible = service_attr_is_visible,
231 };
232 
233 static const struct attribute_group *usb4_port_device_groups[] = {
234 	&common_group,
235 	&service_group,
236 	NULL
237 };
238 
239 static void usb4_port_device_release(struct device *dev)
240 {
241 	struct usb4_port *usb4 = container_of(dev, struct usb4_port, dev);
242 
243 	kfree(usb4);
244 }
245 
246 struct device_type usb4_port_device_type = {
247 	.name = "usb4_port",
248 	.groups = usb4_port_device_groups,
249 	.release = usb4_port_device_release,
250 };
251 
252 /**
253  * usb4_port_device_add() - Add USB4 port device
254  * @port: Lane 0 adapter port to add the USB4 port
255  *
256  * Creates and registers a USB4 port device for @port. Returns the new
257  * USB4 port device pointer or ERR_PTR() in case of error.
258  */
259 struct usb4_port *usb4_port_device_add(struct tb_port *port)
260 {
261 	struct usb4_port *usb4;
262 	int ret;
263 
264 	usb4 = kzalloc(sizeof(*usb4), GFP_KERNEL);
265 	if (!usb4)
266 		return ERR_PTR(-ENOMEM);
267 
268 	usb4->port = port;
269 	usb4->dev.type = &usb4_port_device_type;
270 	usb4->dev.parent = &port->sw->dev;
271 	dev_set_name(&usb4->dev, "usb4_port%d", port->port);
272 
273 	ret = device_register(&usb4->dev);
274 	if (ret) {
275 		put_device(&usb4->dev);
276 		return ERR_PTR(ret);
277 	}
278 
279 	if (dev_fwnode(&usb4->dev)) {
280 		ret = component_add(&usb4->dev, &connector_ops);
281 		if (ret) {
282 			dev_err(&usb4->dev, "failed to add component\n");
283 			device_unregister(&usb4->dev);
284 		}
285 	}
286 
287 	if (!tb_is_upstream_port(port))
288 		device_set_wakeup_capable(&usb4->dev, true);
289 
290 	pm_runtime_no_callbacks(&usb4->dev);
291 	pm_runtime_set_active(&usb4->dev);
292 	pm_runtime_enable(&usb4->dev);
293 	pm_runtime_set_autosuspend_delay(&usb4->dev, TB_AUTOSUSPEND_DELAY);
294 	pm_runtime_mark_last_busy(&usb4->dev);
295 	pm_runtime_use_autosuspend(&usb4->dev);
296 
297 	return usb4;
298 }
299 
300 /**
301  * usb4_port_device_remove() - Removes USB4 port device
302  * @usb4: USB4 port device
303  *
304  * Unregisters the USB4 port device from the system. The device will be
305  * released when the last reference is dropped.
306  */
307 void usb4_port_device_remove(struct usb4_port *usb4)
308 {
309 	if (dev_fwnode(&usb4->dev))
310 		component_del(&usb4->dev, &connector_ops);
311 	device_unregister(&usb4->dev);
312 }
313 
314 /**
315  * usb4_port_device_resume() - Resumes USB4 port device
316  * @usb4: USB4 port device
317  *
318  * Used to resume USB4 port device after sleep state.
319  */
320 int usb4_port_device_resume(struct usb4_port *usb4)
321 {
322 	return usb4->offline ? usb4_port_offline(usb4) : 0;
323 }
324