xref: /linux/drivers/phy/tegra/xusb.c (revision b50ecc5aca4d18f1f0c4942f5c797bc85edef144) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2014-2022, NVIDIA CORPORATION.  All rights reserved.
4  */
5 
6 #include <linux/delay.h>
7 #include <linux/io.h>
8 #include <linux/mailbox_client.h>
9 #include <linux/module.h>
10 #include <linux/of.h>
11 #include <linux/of_platform.h>
12 #include <linux/phy/phy.h>
13 #include <linux/phy/tegra/xusb.h>
14 #include <linux/platform_device.h>
15 #include <linux/regulator/consumer.h>
16 #include <linux/reset.h>
17 #include <linux/slab.h>
18 #include <linux/workqueue.h>
19 
20 #include <soc/tegra/fuse.h>
21 
22 #include "xusb.h"
23 
24 static struct phy *tegra_xusb_pad_of_xlate(struct device *dev,
25 					   const struct of_phandle_args *args)
26 {
27 	struct tegra_xusb_pad *pad = dev_get_drvdata(dev);
28 	struct phy *phy = NULL;
29 	unsigned int i;
30 
31 	if (args->args_count != 0)
32 		return ERR_PTR(-EINVAL);
33 
34 	for (i = 0; i < pad->soc->num_lanes; i++) {
35 		if (!pad->lanes[i])
36 			continue;
37 
38 		if (pad->lanes[i]->dev.of_node == args->np) {
39 			phy = pad->lanes[i];
40 			break;
41 		}
42 	}
43 
44 	if (phy == NULL)
45 		phy = ERR_PTR(-ENODEV);
46 
47 	return phy;
48 }
49 
50 static const struct of_device_id tegra_xusb_padctl_of_match[] = {
51 #if defined(CONFIG_ARCH_TEGRA_124_SOC) || defined(CONFIG_ARCH_TEGRA_132_SOC)
52 	{
53 		.compatible = "nvidia,tegra124-xusb-padctl",
54 		.data = &tegra124_xusb_padctl_soc,
55 	},
56 #endif
57 #if defined(CONFIG_ARCH_TEGRA_210_SOC)
58 	{
59 		.compatible = "nvidia,tegra210-xusb-padctl",
60 		.data = &tegra210_xusb_padctl_soc,
61 	},
62 #endif
63 #if defined(CONFIG_ARCH_TEGRA_186_SOC)
64 	{
65 		.compatible = "nvidia,tegra186-xusb-padctl",
66 		.data = &tegra186_xusb_padctl_soc,
67 	},
68 #endif
69 #if defined(CONFIG_ARCH_TEGRA_194_SOC)
70 	{
71 		.compatible = "nvidia,tegra194-xusb-padctl",
72 		.data = &tegra194_xusb_padctl_soc,
73 	},
74 #endif
75 #if defined(CONFIG_ARCH_TEGRA_234_SOC)
76 	{
77 		.compatible = "nvidia,tegra234-xusb-padctl",
78 		.data = &tegra234_xusb_padctl_soc,
79 	},
80 #endif
81 	{ }
82 };
83 MODULE_DEVICE_TABLE(of, tegra_xusb_padctl_of_match);
84 
85 static struct device_node *
86 tegra_xusb_find_pad_node(struct tegra_xusb_padctl *padctl, const char *name)
87 {
88 	struct device_node *pads, *np;
89 
90 	pads = of_get_child_by_name(padctl->dev->of_node, "pads");
91 	if (!pads)
92 		return NULL;
93 
94 	np = of_get_child_by_name(pads, name);
95 	of_node_put(pads);
96 
97 	return np;
98 }
99 
100 static struct device_node *
101 tegra_xusb_pad_find_phy_node(struct tegra_xusb_pad *pad, unsigned int index)
102 {
103 	struct device_node *np, *lanes;
104 
105 	lanes = of_get_child_by_name(pad->dev.of_node, "lanes");
106 	if (!lanes)
107 		return NULL;
108 
109 	np = of_get_child_by_name(lanes, pad->soc->lanes[index].name);
110 	of_node_put(lanes);
111 
112 	return np;
113 }
114 
115 int tegra_xusb_lane_parse_dt(struct tegra_xusb_lane *lane,
116 			     struct device_node *np)
117 {
118 	struct device *dev = &lane->pad->dev;
119 	const char *function;
120 	int err;
121 
122 	err = of_property_read_string(np, "nvidia,function", &function);
123 	if (err < 0)
124 		return err;
125 
126 	err = match_string(lane->soc->funcs, lane->soc->num_funcs, function);
127 	if (err < 0) {
128 		dev_err(dev, "invalid function \"%s\" for lane \"%pOFn\"\n",
129 			function, np);
130 		return err;
131 	}
132 
133 	lane->function = err;
134 
135 	return 0;
136 }
137 
138 static void tegra_xusb_lane_destroy(struct phy *phy)
139 {
140 	if (phy) {
141 		struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
142 
143 		lane->pad->ops->remove(lane);
144 		phy_destroy(phy);
145 	}
146 }
147 
148 static void tegra_xusb_pad_release(struct device *dev)
149 {
150 	struct tegra_xusb_pad *pad = to_tegra_xusb_pad(dev);
151 
152 	pad->soc->ops->remove(pad);
153 }
154 
155 static const struct device_type tegra_xusb_pad_type = {
156 	.release = tegra_xusb_pad_release,
157 };
158 
159 int tegra_xusb_pad_init(struct tegra_xusb_pad *pad,
160 			struct tegra_xusb_padctl *padctl,
161 			struct device_node *np)
162 {
163 	int err;
164 
165 	device_initialize(&pad->dev);
166 	INIT_LIST_HEAD(&pad->list);
167 	pad->dev.parent = padctl->dev;
168 	pad->dev.type = &tegra_xusb_pad_type;
169 	pad->dev.of_node = np;
170 	pad->padctl = padctl;
171 
172 	err = dev_set_name(&pad->dev, "%s", pad->soc->name);
173 	if (err < 0)
174 		goto unregister;
175 
176 	err = device_add(&pad->dev);
177 	if (err < 0)
178 		goto unregister;
179 
180 	return 0;
181 
182 unregister:
183 	device_unregister(&pad->dev);
184 	return err;
185 }
186 
187 int tegra_xusb_pad_register(struct tegra_xusb_pad *pad,
188 			    const struct phy_ops *ops)
189 {
190 	struct device_node *children;
191 	struct phy *lane;
192 	unsigned int i;
193 	int err;
194 
195 	children = of_get_child_by_name(pad->dev.of_node, "lanes");
196 	if (!children)
197 		return -ENODEV;
198 
199 	pad->lanes = devm_kcalloc(&pad->dev, pad->soc->num_lanes, sizeof(lane),
200 				  GFP_KERNEL);
201 	if (!pad->lanes) {
202 		of_node_put(children);
203 		return -ENOMEM;
204 	}
205 
206 	for (i = 0; i < pad->soc->num_lanes; i++) {
207 		struct device_node *np = tegra_xusb_pad_find_phy_node(pad, i);
208 		struct tegra_xusb_lane *lane;
209 
210 		/* skip disabled lanes */
211 		if (!np || !of_device_is_available(np)) {
212 			of_node_put(np);
213 			continue;
214 		}
215 
216 		pad->lanes[i] = phy_create(&pad->dev, np, ops);
217 		if (IS_ERR(pad->lanes[i])) {
218 			err = PTR_ERR(pad->lanes[i]);
219 			of_node_put(np);
220 			goto remove;
221 		}
222 
223 		lane = pad->ops->probe(pad, np, i);
224 		if (IS_ERR(lane)) {
225 			phy_destroy(pad->lanes[i]);
226 			err = PTR_ERR(lane);
227 			goto remove;
228 		}
229 
230 		list_add_tail(&lane->list, &pad->padctl->lanes);
231 		phy_set_drvdata(pad->lanes[i], lane);
232 	}
233 
234 	pad->provider = of_phy_provider_register_full(&pad->dev, children,
235 						      tegra_xusb_pad_of_xlate);
236 	if (IS_ERR(pad->provider)) {
237 		err = PTR_ERR(pad->provider);
238 		goto remove;
239 	}
240 
241 	return 0;
242 
243 remove:
244 	while (i--)
245 		tegra_xusb_lane_destroy(pad->lanes[i]);
246 
247 	of_node_put(children);
248 
249 	return err;
250 }
251 
252 void tegra_xusb_pad_unregister(struct tegra_xusb_pad *pad)
253 {
254 	unsigned int i = pad->soc->num_lanes;
255 
256 	of_phy_provider_unregister(pad->provider);
257 
258 	while (i--)
259 		tegra_xusb_lane_destroy(pad->lanes[i]);
260 
261 	device_unregister(&pad->dev);
262 }
263 
264 static struct tegra_xusb_pad *
265 tegra_xusb_pad_create(struct tegra_xusb_padctl *padctl,
266 		      const struct tegra_xusb_pad_soc *soc)
267 {
268 	struct tegra_xusb_pad *pad;
269 	struct device_node *np;
270 	int err;
271 
272 	np = tegra_xusb_find_pad_node(padctl, soc->name);
273 	if (!np || !of_device_is_available(np))
274 		return NULL;
275 
276 	pad = soc->ops->probe(padctl, soc, np);
277 	if (IS_ERR(pad)) {
278 		err = PTR_ERR(pad);
279 		dev_err(padctl->dev, "failed to create pad %s: %d\n",
280 			soc->name, err);
281 		return ERR_PTR(err);
282 	}
283 
284 	/* XXX move this into ->probe() to avoid string comparison */
285 	if (strcmp(soc->name, "pcie") == 0)
286 		padctl->pcie = pad;
287 
288 	if (strcmp(soc->name, "sata") == 0)
289 		padctl->sata = pad;
290 
291 	if (strcmp(soc->name, "usb2") == 0)
292 		padctl->usb2 = pad;
293 
294 	if (strcmp(soc->name, "ulpi") == 0)
295 		padctl->ulpi = pad;
296 
297 	if (strcmp(soc->name, "hsic") == 0)
298 		padctl->hsic = pad;
299 
300 	return pad;
301 }
302 
303 static void __tegra_xusb_remove_pads(struct tegra_xusb_padctl *padctl)
304 {
305 	struct tegra_xusb_pad *pad, *tmp;
306 
307 	list_for_each_entry_safe_reverse(pad, tmp, &padctl->pads, list) {
308 		list_del(&pad->list);
309 		tegra_xusb_pad_unregister(pad);
310 	}
311 }
312 
313 static void tegra_xusb_remove_pads(struct tegra_xusb_padctl *padctl)
314 {
315 	mutex_lock(&padctl->lock);
316 	__tegra_xusb_remove_pads(padctl);
317 	mutex_unlock(&padctl->lock);
318 }
319 
320 static void tegra_xusb_lane_program(struct tegra_xusb_lane *lane)
321 {
322 	struct tegra_xusb_padctl *padctl = lane->pad->padctl;
323 	const struct tegra_xusb_lane_soc *soc = lane->soc;
324 	u32 value;
325 
326 	/* skip single function lanes */
327 	if (soc->num_funcs < 2)
328 		return;
329 
330 	if (lane->pad->ops->iddq_enable)
331 		lane->pad->ops->iddq_enable(lane);
332 
333 	/* choose function */
334 	value = padctl_readl(padctl, soc->offset);
335 	value &= ~(soc->mask << soc->shift);
336 	value |= lane->function << soc->shift;
337 	padctl_writel(padctl, value, soc->offset);
338 
339 	if (lane->pad->ops->iddq_disable)
340 		lane->pad->ops->iddq_disable(lane);
341 }
342 
343 static void tegra_xusb_pad_program(struct tegra_xusb_pad *pad)
344 {
345 	unsigned int i;
346 
347 	for (i = 0; i < pad->soc->num_lanes; i++) {
348 		struct tegra_xusb_lane *lane;
349 
350 		if (pad->lanes[i]) {
351 			lane = phy_get_drvdata(pad->lanes[i]);
352 			tegra_xusb_lane_program(lane);
353 		}
354 	}
355 }
356 
357 static int tegra_xusb_setup_pads(struct tegra_xusb_padctl *padctl)
358 {
359 	struct tegra_xusb_pad *pad;
360 	unsigned int i;
361 
362 	mutex_lock(&padctl->lock);
363 
364 	for (i = 0; i < padctl->soc->num_pads; i++) {
365 		const struct tegra_xusb_pad_soc *soc = padctl->soc->pads[i];
366 		int err;
367 
368 		pad = tegra_xusb_pad_create(padctl, soc);
369 		if (IS_ERR(pad)) {
370 			err = PTR_ERR(pad);
371 			dev_err(padctl->dev, "failed to create pad %s: %d\n",
372 				soc->name, err);
373 			__tegra_xusb_remove_pads(padctl);
374 			mutex_unlock(&padctl->lock);
375 			return err;
376 		}
377 
378 		if (!pad)
379 			continue;
380 
381 		list_add_tail(&pad->list, &padctl->pads);
382 	}
383 
384 	list_for_each_entry(pad, &padctl->pads, list)
385 		tegra_xusb_pad_program(pad);
386 
387 	mutex_unlock(&padctl->lock);
388 	return 0;
389 }
390 
391 bool tegra_xusb_lane_check(struct tegra_xusb_lane *lane,
392 				  const char *function)
393 {
394 	const char *func = lane->soc->funcs[lane->function];
395 
396 	return strcmp(function, func) == 0;
397 }
398 
399 struct tegra_xusb_lane *tegra_xusb_find_lane(struct tegra_xusb_padctl *padctl,
400 					     const char *type,
401 					     unsigned int index)
402 {
403 	struct tegra_xusb_lane *lane, *hit = ERR_PTR(-ENODEV);
404 	char *name;
405 
406 	name = kasprintf(GFP_KERNEL, "%s-%u", type, index);
407 	if (!name)
408 		return ERR_PTR(-ENOMEM);
409 
410 	list_for_each_entry(lane, &padctl->lanes, list) {
411 		if (strcmp(lane->soc->name, name) == 0) {
412 			hit = lane;
413 			break;
414 		}
415 	}
416 
417 	kfree(name);
418 	return hit;
419 }
420 
421 struct tegra_xusb_lane *
422 tegra_xusb_port_find_lane(struct tegra_xusb_port *port,
423 			  const struct tegra_xusb_lane_map *map,
424 			  const char *function)
425 {
426 	struct tegra_xusb_lane *lane, *match = ERR_PTR(-ENODEV);
427 
428 	for (; map->type; map++) {
429 		if (port->index != map->port)
430 			continue;
431 
432 		lane = tegra_xusb_find_lane(port->padctl, map->type,
433 					    map->index);
434 		if (IS_ERR(lane))
435 			continue;
436 
437 		if (!tegra_xusb_lane_check(lane, function))
438 			continue;
439 
440 		if (!IS_ERR(match))
441 			dev_err(&port->dev, "conflicting match: %s-%u / %s\n",
442 				map->type, map->index, match->soc->name);
443 		else
444 			match = lane;
445 	}
446 
447 	return match;
448 }
449 
450 static struct device_node *
451 tegra_xusb_find_port_node(struct tegra_xusb_padctl *padctl, const char *type,
452 			  unsigned int index)
453 {
454 	struct device_node *ports, *np;
455 	char *name;
456 
457 	ports = of_get_child_by_name(padctl->dev->of_node, "ports");
458 	if (!ports)
459 		return NULL;
460 
461 	name = kasprintf(GFP_KERNEL, "%s-%u", type, index);
462 	if (!name) {
463 		of_node_put(ports);
464 		return NULL;
465 	}
466 	np = of_get_child_by_name(ports, name);
467 	kfree(name);
468 	of_node_put(ports);
469 
470 	return np;
471 }
472 
473 struct tegra_xusb_port *
474 tegra_xusb_find_port(struct tegra_xusb_padctl *padctl, const char *type,
475 		     unsigned int index)
476 {
477 	struct tegra_xusb_port *port;
478 	struct device_node *np;
479 
480 	np = tegra_xusb_find_port_node(padctl, type, index);
481 	if (!np)
482 		return NULL;
483 
484 	list_for_each_entry(port, &padctl->ports, list) {
485 		if (np == port->dev.of_node) {
486 			of_node_put(np);
487 			return port;
488 		}
489 	}
490 
491 	of_node_put(np);
492 
493 	return NULL;
494 }
495 
496 struct tegra_xusb_usb2_port *
497 tegra_xusb_find_usb2_port(struct tegra_xusb_padctl *padctl, unsigned int index)
498 {
499 	struct tegra_xusb_port *port;
500 
501 	port = tegra_xusb_find_port(padctl, "usb2", index);
502 	if (port)
503 		return to_usb2_port(port);
504 
505 	return NULL;
506 }
507 
508 struct tegra_xusb_usb3_port *
509 tegra_xusb_find_usb3_port(struct tegra_xusb_padctl *padctl, unsigned int index)
510 {
511 	struct tegra_xusb_port *port;
512 
513 	port = tegra_xusb_find_port(padctl, "usb3", index);
514 	if (port)
515 		return to_usb3_port(port);
516 
517 	return NULL;
518 }
519 
520 static void tegra_xusb_port_release(struct device *dev)
521 {
522 	struct tegra_xusb_port *port = to_tegra_xusb_port(dev);
523 
524 	if (port->ops->release)
525 		port->ops->release(port);
526 }
527 
528 static const struct device_type tegra_xusb_port_type = {
529 	.release = tegra_xusb_port_release,
530 };
531 
532 static int tegra_xusb_port_init(struct tegra_xusb_port *port,
533 				struct tegra_xusb_padctl *padctl,
534 				struct device_node *np,
535 				const char *name,
536 				unsigned int index)
537 {
538 	int err;
539 
540 	INIT_LIST_HEAD(&port->list);
541 	port->padctl = padctl;
542 	port->index = index;
543 
544 	device_initialize(&port->dev);
545 	port->dev.type = &tegra_xusb_port_type;
546 	port->dev.of_node = of_node_get(np);
547 	port->dev.parent = padctl->dev;
548 
549 	err = dev_set_name(&port->dev, "%s-%u", name, index);
550 	if (err < 0)
551 		goto unregister;
552 
553 	err = device_add(&port->dev);
554 	if (err < 0)
555 		goto unregister;
556 
557 	return 0;
558 
559 unregister:
560 	device_unregister(&port->dev);
561 	return err;
562 }
563 
564 static void tegra_xusb_port_unregister(struct tegra_xusb_port *port)
565 {
566 	if (!IS_ERR_OR_NULL(port->usb_role_sw)) {
567 		of_platform_depopulate(&port->dev);
568 		usb_role_switch_unregister(port->usb_role_sw);
569 		cancel_work_sync(&port->usb_phy_work);
570 		usb_remove_phy(&port->usb_phy);
571 		port->usb_phy.dev->driver = NULL;
572 	}
573 
574 	if (port->ops->remove)
575 		port->ops->remove(port);
576 
577 	device_unregister(&port->dev);
578 }
579 
580 static const char *const modes[] = {
581 	[USB_DR_MODE_UNKNOWN] = "",
582 	[USB_DR_MODE_HOST] = "host",
583 	[USB_DR_MODE_PERIPHERAL] = "peripheral",
584 	[USB_DR_MODE_OTG] = "otg",
585 };
586 
587 static const char * const usb_roles[] = {
588 	[USB_ROLE_NONE]		= "none",
589 	[USB_ROLE_HOST]		= "host",
590 	[USB_ROLE_DEVICE]	= "device",
591 };
592 
593 static enum usb_phy_events to_usb_phy_event(enum usb_role role)
594 {
595 	switch (role) {
596 	case USB_ROLE_DEVICE:
597 		return USB_EVENT_VBUS;
598 
599 	case USB_ROLE_HOST:
600 		return USB_EVENT_ID;
601 
602 	default:
603 		return USB_EVENT_NONE;
604 	}
605 }
606 
607 static void tegra_xusb_usb_phy_work(struct work_struct *work)
608 {
609 	struct tegra_xusb_port *port = container_of(work,
610 						    struct tegra_xusb_port,
611 						    usb_phy_work);
612 	enum usb_role role = usb_role_switch_get_role(port->usb_role_sw);
613 
614 	usb_phy_set_event(&port->usb_phy, to_usb_phy_event(role));
615 
616 	dev_dbg(&port->dev, "%s(): calling notifier for role %s\n", __func__,
617 		usb_roles[role]);
618 
619 	atomic_notifier_call_chain(&port->usb_phy.notifier, 0, &port->usb_phy);
620 }
621 
622 static int tegra_xusb_role_sw_set(struct usb_role_switch *sw,
623 				  enum usb_role role)
624 {
625 	struct tegra_xusb_port *port = usb_role_switch_get_drvdata(sw);
626 
627 	dev_dbg(&port->dev, "%s(): role %s\n", __func__, usb_roles[role]);
628 
629 	schedule_work(&port->usb_phy_work);
630 
631 	return 0;
632 }
633 
634 static int tegra_xusb_set_peripheral(struct usb_otg *otg,
635 				     struct usb_gadget *gadget)
636 {
637 	struct tegra_xusb_port *port = container_of(otg->usb_phy,
638 						    struct tegra_xusb_port,
639 						    usb_phy);
640 
641 	if (gadget != NULL)
642 		schedule_work(&port->usb_phy_work);
643 
644 	return 0;
645 }
646 
647 static int tegra_xusb_set_host(struct usb_otg *otg, struct usb_bus *host)
648 {
649 	struct tegra_xusb_port *port = container_of(otg->usb_phy,
650 						    struct tegra_xusb_port,
651 						    usb_phy);
652 
653 	if (host != NULL)
654 		schedule_work(&port->usb_phy_work);
655 
656 	return 0;
657 }
658 
659 
660 static int tegra_xusb_setup_usb_role_switch(struct tegra_xusb_port *port)
661 {
662 	struct tegra_xusb_lane *lane;
663 	struct usb_role_switch_desc role_sx_desc = {
664 		.fwnode = dev_fwnode(&port->dev),
665 		.set = tegra_xusb_role_sw_set,
666 		.allow_userspace_control = true,
667 	};
668 	int err = 0;
669 
670 	/*
671 	 * USB role switch driver needs parent driver owner info. This is a
672 	 * suboptimal solution. TODO: Need to revisit this in a follow-up patch
673 	 * where an optimal solution is possible with changes to USB role
674 	 * switch driver.
675 	 */
676 	port->dev.driver = devm_kzalloc(&port->dev,
677 					sizeof(struct device_driver),
678 					GFP_KERNEL);
679 	if (!port->dev.driver)
680 		return -ENOMEM;
681 
682 	port->dev.driver->owner	 = THIS_MODULE;
683 
684 	port->usb_role_sw = usb_role_switch_register(&port->dev,
685 						     &role_sx_desc);
686 	if (IS_ERR(port->usb_role_sw)) {
687 		err = PTR_ERR(port->usb_role_sw);
688 		dev_err(&port->dev, "failed to register USB role switch: %d",
689 			err);
690 		return err;
691 	}
692 
693 	INIT_WORK(&port->usb_phy_work, tegra_xusb_usb_phy_work);
694 	usb_role_switch_set_drvdata(port->usb_role_sw, port);
695 
696 	port->usb_phy.otg = devm_kzalloc(&port->dev, sizeof(struct usb_otg),
697 					 GFP_KERNEL);
698 	if (!port->usb_phy.otg)
699 		return -ENOMEM;
700 
701 	lane = tegra_xusb_find_lane(port->padctl, "usb2", port->index);
702 	if (IS_ERR(lane))
703 		return PTR_ERR(lane);
704 
705 	/*
706 	 * Assign phy dev to usb-phy dev. Host/device drivers can use phy
707 	 * reference to retrieve usb-phy details.
708 	 */
709 	port->usb_phy.dev = &lane->pad->lanes[port->index]->dev;
710 	port->usb_phy.dev->driver = port->dev.driver;
711 	port->usb_phy.otg->usb_phy = &port->usb_phy;
712 	port->usb_phy.otg->set_peripheral = tegra_xusb_set_peripheral;
713 	port->usb_phy.otg->set_host = tegra_xusb_set_host;
714 
715 	err = usb_add_phy_dev(&port->usb_phy);
716 	if (err < 0) {
717 		dev_err(&port->dev, "Failed to add USB PHY: %d\n", err);
718 		return err;
719 	}
720 
721 	/* populate connector entry */
722 	of_platform_populate(port->dev.of_node, NULL, NULL, &port->dev);
723 
724 	return err;
725 }
726 
727 static void tegra_xusb_parse_usb_role_default_mode(struct tegra_xusb_port *port)
728 {
729 	enum usb_role role = USB_ROLE_NONE;
730 	enum usb_dr_mode mode = usb_get_role_switch_default_mode(&port->dev);
731 
732 	if (mode == USB_DR_MODE_HOST)
733 		role = USB_ROLE_HOST;
734 	else if (mode == USB_DR_MODE_PERIPHERAL)
735 		role = USB_ROLE_DEVICE;
736 
737 	if (role != USB_ROLE_NONE) {
738 		usb_role_switch_set_role(port->usb_role_sw, role);
739 		dev_dbg(&port->dev, "usb role default mode is %s", modes[mode]);
740 	}
741 }
742 
743 static int tegra_xusb_usb2_port_parse_dt(struct tegra_xusb_usb2_port *usb2)
744 {
745 	struct tegra_xusb_port *port = &usb2->base;
746 	struct device_node *np = port->dev.of_node;
747 	const char *mode;
748 	int err;
749 
750 	usb2->internal = of_property_read_bool(np, "nvidia,internal");
751 
752 	if (!of_property_read_string(np, "mode", &mode)) {
753 		int err = match_string(modes, ARRAY_SIZE(modes), mode);
754 		if (err < 0) {
755 			dev_err(&port->dev, "invalid value %s for \"mode\"\n",
756 				mode);
757 			usb2->mode = USB_DR_MODE_UNKNOWN;
758 		} else {
759 			usb2->mode = err;
760 		}
761 	} else {
762 		usb2->mode = USB_DR_MODE_HOST;
763 	}
764 
765 	/* usb-role-switch property is mandatory for OTG/Peripheral modes */
766 	if (usb2->mode == USB_DR_MODE_PERIPHERAL ||
767 	    usb2->mode == USB_DR_MODE_OTG) {
768 		if (of_property_read_bool(np, "usb-role-switch")) {
769 			err = tegra_xusb_setup_usb_role_switch(port);
770 			if (err < 0)
771 				return err;
772 			tegra_xusb_parse_usb_role_default_mode(port);
773 		} else {
774 			dev_err(&port->dev, "usb-role-switch not found for %s mode",
775 				modes[usb2->mode]);
776 			return -EINVAL;
777 		}
778 	}
779 
780 	usb2->supply = regulator_get(&port->dev, "vbus");
781 	return PTR_ERR_OR_ZERO(usb2->supply);
782 }
783 
784 static int tegra_xusb_add_usb2_port(struct tegra_xusb_padctl *padctl,
785 				    unsigned int index)
786 {
787 	struct tegra_xusb_usb2_port *usb2;
788 	struct device_node *np;
789 	int err = 0;
790 
791 	/*
792 	 * USB2 ports don't require additional properties, but if the port is
793 	 * marked as disabled there is no reason to register it.
794 	 */
795 	np = tegra_xusb_find_port_node(padctl, "usb2", index);
796 	if (!np || !of_device_is_available(np))
797 		goto out;
798 
799 	usb2 = kzalloc(sizeof(*usb2), GFP_KERNEL);
800 	if (!usb2) {
801 		err = -ENOMEM;
802 		goto out;
803 	}
804 
805 	err = tegra_xusb_port_init(&usb2->base, padctl, np, "usb2", index);
806 	if (err < 0)
807 		goto out;
808 
809 	usb2->base.ops = padctl->soc->ports.usb2.ops;
810 
811 	usb2->base.lane = usb2->base.ops->map(&usb2->base);
812 	if (IS_ERR(usb2->base.lane)) {
813 		err = PTR_ERR(usb2->base.lane);
814 		tegra_xusb_port_unregister(&usb2->base);
815 		goto out;
816 	}
817 
818 	err = tegra_xusb_usb2_port_parse_dt(usb2);
819 	if (err < 0) {
820 		tegra_xusb_port_unregister(&usb2->base);
821 		goto out;
822 	}
823 
824 	list_add_tail(&usb2->base.list, &padctl->ports);
825 
826 out:
827 	of_node_put(np);
828 	return err;
829 }
830 
831 void tegra_xusb_usb2_port_release(struct tegra_xusb_port *port)
832 {
833 	struct tegra_xusb_usb2_port *usb2 = to_usb2_port(port);
834 
835 	kfree(usb2);
836 }
837 
838 void tegra_xusb_usb2_port_remove(struct tegra_xusb_port *port)
839 {
840 	struct tegra_xusb_usb2_port *usb2 = to_usb2_port(port);
841 
842 	regulator_put(usb2->supply);
843 }
844 
845 static int tegra_xusb_ulpi_port_parse_dt(struct tegra_xusb_ulpi_port *ulpi)
846 {
847 	struct tegra_xusb_port *port = &ulpi->base;
848 	struct device_node *np = port->dev.of_node;
849 
850 	ulpi->internal = of_property_read_bool(np, "nvidia,internal");
851 
852 	return 0;
853 }
854 
855 static int tegra_xusb_add_ulpi_port(struct tegra_xusb_padctl *padctl,
856 				    unsigned int index)
857 {
858 	struct tegra_xusb_ulpi_port *ulpi;
859 	struct device_node *np;
860 	int err = 0;
861 
862 	np = tegra_xusb_find_port_node(padctl, "ulpi", index);
863 	if (!np || !of_device_is_available(np))
864 		goto out;
865 
866 	ulpi = kzalloc(sizeof(*ulpi), GFP_KERNEL);
867 	if (!ulpi) {
868 		err = -ENOMEM;
869 		goto out;
870 	}
871 
872 	err = tegra_xusb_port_init(&ulpi->base, padctl, np, "ulpi", index);
873 	if (err < 0)
874 		goto out;
875 
876 	ulpi->base.ops = padctl->soc->ports.ulpi.ops;
877 
878 	ulpi->base.lane = ulpi->base.ops->map(&ulpi->base);
879 	if (IS_ERR(ulpi->base.lane)) {
880 		err = PTR_ERR(ulpi->base.lane);
881 		tegra_xusb_port_unregister(&ulpi->base);
882 		goto out;
883 	}
884 
885 	err = tegra_xusb_ulpi_port_parse_dt(ulpi);
886 	if (err < 0) {
887 		tegra_xusb_port_unregister(&ulpi->base);
888 		goto out;
889 	}
890 
891 	list_add_tail(&ulpi->base.list, &padctl->ports);
892 
893 out:
894 	of_node_put(np);
895 	return err;
896 }
897 
898 void tegra_xusb_ulpi_port_release(struct tegra_xusb_port *port)
899 {
900 	struct tegra_xusb_ulpi_port *ulpi = to_ulpi_port(port);
901 
902 	kfree(ulpi);
903 }
904 
905 static int tegra_xusb_hsic_port_parse_dt(struct tegra_xusb_hsic_port *hsic)
906 {
907 	/* XXX */
908 	return 0;
909 }
910 
911 static int tegra_xusb_add_hsic_port(struct tegra_xusb_padctl *padctl,
912 				    unsigned int index)
913 {
914 	struct tegra_xusb_hsic_port *hsic;
915 	struct device_node *np;
916 	int err = 0;
917 
918 	np = tegra_xusb_find_port_node(padctl, "hsic", index);
919 	if (!np || !of_device_is_available(np))
920 		goto out;
921 
922 	hsic = kzalloc(sizeof(*hsic), GFP_KERNEL);
923 	if (!hsic) {
924 		err = -ENOMEM;
925 		goto out;
926 	}
927 
928 	err = tegra_xusb_port_init(&hsic->base, padctl, np, "hsic", index);
929 	if (err < 0)
930 		goto out;
931 
932 	hsic->base.ops = padctl->soc->ports.hsic.ops;
933 
934 	hsic->base.lane = hsic->base.ops->map(&hsic->base);
935 	if (IS_ERR(hsic->base.lane)) {
936 		err = PTR_ERR(hsic->base.lane);
937 		goto out;
938 	}
939 
940 	err = tegra_xusb_hsic_port_parse_dt(hsic);
941 	if (err < 0) {
942 		tegra_xusb_port_unregister(&hsic->base);
943 		goto out;
944 	}
945 
946 	list_add_tail(&hsic->base.list, &padctl->ports);
947 
948 out:
949 	of_node_put(np);
950 	return err;
951 }
952 
953 void tegra_xusb_hsic_port_release(struct tegra_xusb_port *port)
954 {
955 	struct tegra_xusb_hsic_port *hsic = to_hsic_port(port);
956 
957 	kfree(hsic);
958 }
959 
960 static int tegra_xusb_usb3_port_parse_dt(struct tegra_xusb_usb3_port *usb3)
961 {
962 	struct tegra_xusb_port *port = &usb3->base;
963 	struct device_node *np = port->dev.of_node;
964 	enum usb_device_speed maximum_speed;
965 	u32 value;
966 	int err;
967 
968 	err = of_property_read_u32(np, "nvidia,usb2-companion", &value);
969 	if (err < 0) {
970 		dev_err(&port->dev, "failed to read port: %d\n", err);
971 		return err;
972 	}
973 
974 	usb3->port = value;
975 
976 	usb3->internal = of_property_read_bool(np, "nvidia,internal");
977 
978 	if (device_property_present(&port->dev, "maximum-speed")) {
979 		maximum_speed =  usb_get_maximum_speed(&port->dev);
980 		if (maximum_speed == USB_SPEED_SUPER)
981 			usb3->disable_gen2 = true;
982 		else if (maximum_speed == USB_SPEED_SUPER_PLUS)
983 			usb3->disable_gen2 = false;
984 		else
985 			return -EINVAL;
986 	}
987 
988 	return 0;
989 }
990 
991 static int tegra_xusb_add_usb3_port(struct tegra_xusb_padctl *padctl,
992 				    unsigned int index)
993 {
994 	struct tegra_xusb_usb3_port *usb3;
995 	struct device_node *np;
996 	int err = 0;
997 
998 	/*
999 	 * If there is no supplemental configuration in the device tree the
1000 	 * port is unusable. But it is valid to configure only a single port,
1001 	 * hence return 0 instead of an error to allow ports to be optional.
1002 	 */
1003 	np = tegra_xusb_find_port_node(padctl, "usb3", index);
1004 	if (!np || !of_device_is_available(np))
1005 		goto out;
1006 
1007 	usb3 = kzalloc(sizeof(*usb3), GFP_KERNEL);
1008 	if (!usb3) {
1009 		err = -ENOMEM;
1010 		goto out;
1011 	}
1012 
1013 	err = tegra_xusb_port_init(&usb3->base, padctl, np, "usb3", index);
1014 	if (err < 0)
1015 		goto out;
1016 
1017 	usb3->base.ops = padctl->soc->ports.usb3.ops;
1018 
1019 	usb3->base.lane = usb3->base.ops->map(&usb3->base);
1020 	if (IS_ERR(usb3->base.lane)) {
1021 		err = PTR_ERR(usb3->base.lane);
1022 		goto out;
1023 	}
1024 
1025 	err = tegra_xusb_usb3_port_parse_dt(usb3);
1026 	if (err < 0) {
1027 		tegra_xusb_port_unregister(&usb3->base);
1028 		goto out;
1029 	}
1030 
1031 	list_add_tail(&usb3->base.list, &padctl->ports);
1032 
1033 out:
1034 	of_node_put(np);
1035 	return err;
1036 }
1037 
1038 void tegra_xusb_usb3_port_release(struct tegra_xusb_port *port)
1039 {
1040 	struct tegra_xusb_usb3_port *usb3 = to_usb3_port(port);
1041 
1042 	kfree(usb3);
1043 }
1044 
1045 static void __tegra_xusb_remove_ports(struct tegra_xusb_padctl *padctl)
1046 {
1047 	struct tegra_xusb_port *port, *tmp;
1048 
1049 	list_for_each_entry_safe_reverse(port, tmp, &padctl->ports, list) {
1050 		list_del(&port->list);
1051 		tegra_xusb_port_unregister(port);
1052 	}
1053 }
1054 
1055 static int tegra_xusb_find_unused_usb3_port(struct tegra_xusb_padctl *padctl)
1056 {
1057 	struct device_node *np;
1058 	unsigned int i;
1059 
1060 	for (i = 0; i < padctl->soc->ports.usb3.count; i++) {
1061 		np = tegra_xusb_find_port_node(padctl, "usb3", i);
1062 		if (!np || !of_device_is_available(np))
1063 			return i;
1064 	}
1065 
1066 	return -ENODEV;
1067 }
1068 
1069 static bool tegra_xusb_port_is_companion(struct tegra_xusb_usb2_port *usb2)
1070 {
1071 	unsigned int i;
1072 	struct tegra_xusb_usb3_port *usb3;
1073 	struct tegra_xusb_padctl *padctl = usb2->base.padctl;
1074 
1075 	for (i = 0; i < padctl->soc->ports.usb3.count; i++) {
1076 		usb3 = tegra_xusb_find_usb3_port(padctl, i);
1077 		if (usb3 && usb3->port == usb2->base.index)
1078 			return true;
1079 	}
1080 
1081 	return false;
1082 }
1083 
1084 static int tegra_xusb_update_usb3_fake_port(struct tegra_xusb_usb2_port *usb2)
1085 {
1086 	int fake;
1087 
1088 	/* Disable usb3_port_fake usage by default and assign if needed */
1089 	usb2->usb3_port_fake = -1;
1090 
1091 	if ((usb2->mode == USB_DR_MODE_OTG ||
1092 	     usb2->mode == USB_DR_MODE_PERIPHERAL) &&
1093 		!tegra_xusb_port_is_companion(usb2)) {
1094 		fake = tegra_xusb_find_unused_usb3_port(usb2->base.padctl);
1095 		if (fake < 0) {
1096 			dev_err(&usb2->base.dev, "no unused USB3 ports available\n");
1097 			return -ENODEV;
1098 		}
1099 
1100 		dev_dbg(&usb2->base.dev, "Found unused usb3 port: %d\n", fake);
1101 		usb2->usb3_port_fake = fake;
1102 	}
1103 
1104 	return 0;
1105 }
1106 
1107 static int tegra_xusb_setup_ports(struct tegra_xusb_padctl *padctl)
1108 {
1109 	struct tegra_xusb_port *port;
1110 	struct tegra_xusb_usb2_port *usb2;
1111 	unsigned int i;
1112 	int err = 0;
1113 
1114 	mutex_lock(&padctl->lock);
1115 
1116 	for (i = 0; i < padctl->soc->ports.usb2.count; i++) {
1117 		err = tegra_xusb_add_usb2_port(padctl, i);
1118 		if (err < 0)
1119 			goto remove_ports;
1120 	}
1121 
1122 	for (i = 0; i < padctl->soc->ports.ulpi.count; i++) {
1123 		err = tegra_xusb_add_ulpi_port(padctl, i);
1124 		if (err < 0)
1125 			goto remove_ports;
1126 	}
1127 
1128 	for (i = 0; i < padctl->soc->ports.hsic.count; i++) {
1129 		err = tegra_xusb_add_hsic_port(padctl, i);
1130 		if (err < 0)
1131 			goto remove_ports;
1132 	}
1133 
1134 	for (i = 0; i < padctl->soc->ports.usb3.count; i++) {
1135 		err = tegra_xusb_add_usb3_port(padctl, i);
1136 		if (err < 0)
1137 			goto remove_ports;
1138 	}
1139 
1140 	if (padctl->soc->need_fake_usb3_port) {
1141 		for (i = 0; i < padctl->soc->ports.usb2.count; i++) {
1142 			usb2 = tegra_xusb_find_usb2_port(padctl, i);
1143 			if (!usb2)
1144 				continue;
1145 
1146 			err = tegra_xusb_update_usb3_fake_port(usb2);
1147 			if (err < 0)
1148 				goto remove_ports;
1149 		}
1150 	}
1151 
1152 	list_for_each_entry(port, &padctl->ports, list) {
1153 		err = port->ops->enable(port);
1154 		if (err < 0)
1155 			dev_err(padctl->dev, "failed to enable port %s: %d\n",
1156 				dev_name(&port->dev), err);
1157 	}
1158 
1159 	goto unlock;
1160 
1161 remove_ports:
1162 	__tegra_xusb_remove_ports(padctl);
1163 unlock:
1164 	mutex_unlock(&padctl->lock);
1165 	return err;
1166 }
1167 
1168 static void tegra_xusb_remove_ports(struct tegra_xusb_padctl *padctl)
1169 {
1170 	mutex_lock(&padctl->lock);
1171 	__tegra_xusb_remove_ports(padctl);
1172 	mutex_unlock(&padctl->lock);
1173 }
1174 
1175 static int tegra_xusb_padctl_probe(struct platform_device *pdev)
1176 {
1177 	struct device_node *np = pdev->dev.of_node;
1178 	const struct tegra_xusb_padctl_soc *soc;
1179 	struct tegra_xusb_padctl *padctl;
1180 	const struct of_device_id *match;
1181 	int err;
1182 
1183 	/* for backwards compatibility with old device trees */
1184 	np = of_get_child_by_name(np, "pads");
1185 	if (!np) {
1186 		dev_warn(&pdev->dev, "deprecated DT, using legacy driver\n");
1187 		return tegra_xusb_padctl_legacy_probe(pdev);
1188 	}
1189 
1190 	of_node_put(np);
1191 
1192 	match = of_match_node(tegra_xusb_padctl_of_match, pdev->dev.of_node);
1193 	soc = match->data;
1194 
1195 	padctl = soc->ops->probe(&pdev->dev, soc);
1196 	if (IS_ERR(padctl))
1197 		return PTR_ERR(padctl);
1198 
1199 	platform_set_drvdata(pdev, padctl);
1200 	INIT_LIST_HEAD(&padctl->ports);
1201 	INIT_LIST_HEAD(&padctl->lanes);
1202 	INIT_LIST_HEAD(&padctl->pads);
1203 	mutex_init(&padctl->lock);
1204 
1205 	padctl->regs = devm_platform_ioremap_resource(pdev, 0);
1206 	if (IS_ERR(padctl->regs)) {
1207 		err = PTR_ERR(padctl->regs);
1208 		goto remove;
1209 	}
1210 
1211 	padctl->rst = devm_reset_control_get(&pdev->dev, NULL);
1212 	if (IS_ERR(padctl->rst)) {
1213 		err = PTR_ERR(padctl->rst);
1214 		goto remove;
1215 	}
1216 
1217 	padctl->supplies = devm_kcalloc(&pdev->dev, padctl->soc->num_supplies,
1218 					sizeof(*padctl->supplies), GFP_KERNEL);
1219 	if (!padctl->supplies) {
1220 		err = -ENOMEM;
1221 		goto remove;
1222 	}
1223 
1224 	regulator_bulk_set_supply_names(padctl->supplies,
1225 					padctl->soc->supply_names,
1226 					padctl->soc->num_supplies);
1227 
1228 	err = devm_regulator_bulk_get(&pdev->dev, padctl->soc->num_supplies,
1229 				      padctl->supplies);
1230 	if (err < 0) {
1231 		dev_err_probe(&pdev->dev, err, "failed to get regulators\n");
1232 		goto remove;
1233 	}
1234 
1235 	err = reset_control_deassert(padctl->rst);
1236 	if (err < 0)
1237 		goto remove;
1238 
1239 	err = regulator_bulk_enable(padctl->soc->num_supplies,
1240 				    padctl->supplies);
1241 	if (err < 0) {
1242 		dev_err(&pdev->dev, "failed to enable supplies: %d\n", err);
1243 		goto reset;
1244 	}
1245 
1246 	err = tegra_xusb_setup_pads(padctl);
1247 	if (err < 0) {
1248 		dev_err(&pdev->dev, "failed to setup pads: %d\n", err);
1249 		goto power_down;
1250 	}
1251 
1252 	err = tegra_xusb_setup_ports(padctl);
1253 	if (err) {
1254 		const char *level = KERN_ERR;
1255 
1256 		if (err == -EPROBE_DEFER)
1257 			level = KERN_DEBUG;
1258 
1259 		dev_printk(level, &pdev->dev,
1260 			   dev_fmt("failed to setup XUSB ports: %d\n"), err);
1261 		goto remove_pads;
1262 	}
1263 
1264 	return 0;
1265 
1266 remove_pads:
1267 	tegra_xusb_remove_pads(padctl);
1268 power_down:
1269 	regulator_bulk_disable(padctl->soc->num_supplies, padctl->supplies);
1270 reset:
1271 	reset_control_assert(padctl->rst);
1272 remove:
1273 	platform_set_drvdata(pdev, NULL);
1274 	soc->ops->remove(padctl);
1275 	return err;
1276 }
1277 
1278 static void tegra_xusb_padctl_remove(struct platform_device *pdev)
1279 {
1280 	struct tegra_xusb_padctl *padctl = platform_get_drvdata(pdev);
1281 	int err;
1282 
1283 	tegra_xusb_remove_ports(padctl);
1284 	tegra_xusb_remove_pads(padctl);
1285 
1286 	err = regulator_bulk_disable(padctl->soc->num_supplies,
1287 				     padctl->supplies);
1288 	if (err < 0)
1289 		dev_err(&pdev->dev, "failed to disable supplies: %d\n", err);
1290 
1291 	err = reset_control_assert(padctl->rst);
1292 	if (err < 0)
1293 		dev_err(&pdev->dev, "failed to assert reset: %d\n", err);
1294 
1295 	padctl->soc->ops->remove(padctl);
1296 }
1297 
1298 static __maybe_unused int tegra_xusb_padctl_suspend_noirq(struct device *dev)
1299 {
1300 	struct tegra_xusb_padctl *padctl = dev_get_drvdata(dev);
1301 
1302 	if (padctl->soc && padctl->soc->ops && padctl->soc->ops->suspend_noirq)
1303 		return padctl->soc->ops->suspend_noirq(padctl);
1304 
1305 	return 0;
1306 }
1307 
1308 static __maybe_unused int tegra_xusb_padctl_resume_noirq(struct device *dev)
1309 {
1310 	struct tegra_xusb_padctl *padctl = dev_get_drvdata(dev);
1311 
1312 	if (padctl->soc && padctl->soc->ops && padctl->soc->ops->resume_noirq)
1313 		return padctl->soc->ops->resume_noirq(padctl);
1314 
1315 	return 0;
1316 }
1317 
1318 static const struct dev_pm_ops tegra_xusb_padctl_pm_ops = {
1319 	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(tegra_xusb_padctl_suspend_noirq,
1320 				      tegra_xusb_padctl_resume_noirq)
1321 };
1322 
1323 static struct platform_driver tegra_xusb_padctl_driver = {
1324 	.driver = {
1325 		.name = "tegra-xusb-padctl",
1326 		.of_match_table = tegra_xusb_padctl_of_match,
1327 		.pm = &tegra_xusb_padctl_pm_ops,
1328 	},
1329 	.probe = tegra_xusb_padctl_probe,
1330 	.remove_new = tegra_xusb_padctl_remove,
1331 };
1332 module_platform_driver(tegra_xusb_padctl_driver);
1333 
1334 struct tegra_xusb_padctl *tegra_xusb_padctl_get(struct device *dev)
1335 {
1336 	struct tegra_xusb_padctl *padctl;
1337 	struct platform_device *pdev;
1338 	struct device_node *np;
1339 
1340 	np = of_parse_phandle(dev->of_node, "nvidia,xusb-padctl", 0);
1341 	if (!np)
1342 		return ERR_PTR(-EINVAL);
1343 
1344 	/*
1345 	 * This is slightly ugly. A better implementation would be to keep a
1346 	 * registry of pad controllers, but since there will almost certainly
1347 	 * only ever be one per SoC that would be a little overkill.
1348 	 */
1349 	pdev = of_find_device_by_node(np);
1350 	if (!pdev) {
1351 		of_node_put(np);
1352 		return ERR_PTR(-ENODEV);
1353 	}
1354 
1355 	of_node_put(np);
1356 
1357 	padctl = platform_get_drvdata(pdev);
1358 	if (!padctl) {
1359 		put_device(&pdev->dev);
1360 		return ERR_PTR(-EPROBE_DEFER);
1361 	}
1362 
1363 	return padctl;
1364 }
1365 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get);
1366 
1367 void tegra_xusb_padctl_put(struct tegra_xusb_padctl *padctl)
1368 {
1369 	if (padctl)
1370 		put_device(padctl->dev);
1371 }
1372 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_put);
1373 
1374 int tegra_xusb_padctl_usb3_save_context(struct tegra_xusb_padctl *padctl,
1375 					unsigned int port)
1376 {
1377 	if (padctl->soc->ops->usb3_save_context)
1378 		return padctl->soc->ops->usb3_save_context(padctl, port);
1379 
1380 	return -ENOSYS;
1381 }
1382 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_save_context);
1383 
1384 int tegra_xusb_padctl_hsic_set_idle(struct tegra_xusb_padctl *padctl,
1385 				    unsigned int port, bool idle)
1386 {
1387 	if (padctl->soc->ops->hsic_set_idle)
1388 		return padctl->soc->ops->hsic_set_idle(padctl, port, idle);
1389 
1390 	return -ENOSYS;
1391 }
1392 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_hsic_set_idle);
1393 
1394 int tegra_xusb_padctl_enable_phy_sleepwalk(struct tegra_xusb_padctl *padctl, struct phy *phy,
1395 					   enum usb_device_speed speed)
1396 {
1397 	struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1398 
1399 	if (lane->pad->ops->enable_phy_sleepwalk)
1400 		return lane->pad->ops->enable_phy_sleepwalk(lane, speed);
1401 
1402 	return -EOPNOTSUPP;
1403 }
1404 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_enable_phy_sleepwalk);
1405 
1406 int tegra_xusb_padctl_disable_phy_sleepwalk(struct tegra_xusb_padctl *padctl, struct phy *phy)
1407 {
1408 	struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1409 
1410 	if (lane->pad->ops->disable_phy_sleepwalk)
1411 		return lane->pad->ops->disable_phy_sleepwalk(lane);
1412 
1413 	return -EOPNOTSUPP;
1414 }
1415 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_disable_phy_sleepwalk);
1416 
1417 int tegra_xusb_padctl_enable_phy_wake(struct tegra_xusb_padctl *padctl, struct phy *phy)
1418 {
1419 	struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1420 
1421 	if (lane->pad->ops->enable_phy_wake)
1422 		return lane->pad->ops->enable_phy_wake(lane);
1423 
1424 	return -EOPNOTSUPP;
1425 }
1426 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_enable_phy_wake);
1427 
1428 int tegra_xusb_padctl_disable_phy_wake(struct tegra_xusb_padctl *padctl, struct phy *phy)
1429 {
1430 	struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1431 
1432 	if (lane->pad->ops->disable_phy_wake)
1433 		return lane->pad->ops->disable_phy_wake(lane);
1434 
1435 	return -EOPNOTSUPP;
1436 }
1437 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_disable_phy_wake);
1438 
1439 bool tegra_xusb_padctl_remote_wake_detected(struct tegra_xusb_padctl *padctl, struct phy *phy)
1440 {
1441 	struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1442 
1443 	if (lane->pad->ops->remote_wake_detected)
1444 		return lane->pad->ops->remote_wake_detected(lane);
1445 
1446 	return false;
1447 }
1448 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_remote_wake_detected);
1449 
1450 int tegra_xusb_padctl_usb3_set_lfps_detect(struct tegra_xusb_padctl *padctl,
1451 					   unsigned int port, bool enable)
1452 {
1453 	if (padctl->soc->ops->usb3_set_lfps_detect)
1454 		return padctl->soc->ops->usb3_set_lfps_detect(padctl, port,
1455 							      enable);
1456 
1457 	return -ENOSYS;
1458 }
1459 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_set_lfps_detect);
1460 
1461 int tegra_xusb_padctl_set_vbus_override(struct tegra_xusb_padctl *padctl,
1462 							bool val)
1463 {
1464 	if (padctl->soc->ops->vbus_override)
1465 		return padctl->soc->ops->vbus_override(padctl, val);
1466 
1467 	return -ENOTSUPP;
1468 }
1469 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_set_vbus_override);
1470 
1471 int tegra_phy_xusb_utmi_port_reset(struct phy *phy)
1472 {
1473 	struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
1474 	struct tegra_xusb_padctl *padctl = lane->pad->padctl;
1475 
1476 	if (padctl->soc->ops->utmi_port_reset)
1477 		return padctl->soc->ops->utmi_port_reset(phy);
1478 
1479 	return -ENOTSUPP;
1480 }
1481 EXPORT_SYMBOL_GPL(tegra_phy_xusb_utmi_port_reset);
1482 
1483 void tegra_phy_xusb_utmi_pad_power_on(struct phy *phy)
1484 {
1485 	struct tegra_xusb_lane *lane;
1486 	struct tegra_xusb_padctl *padctl;
1487 
1488 	if (!phy)
1489 		return;
1490 
1491 	lane = phy_get_drvdata(phy);
1492 	padctl = lane->pad->padctl;
1493 
1494 	if (padctl->soc->ops->utmi_pad_power_on)
1495 		padctl->soc->ops->utmi_pad_power_on(phy);
1496 }
1497 EXPORT_SYMBOL_GPL(tegra_phy_xusb_utmi_pad_power_on);
1498 
1499 void tegra_phy_xusb_utmi_pad_power_down(struct phy *phy)
1500 {
1501 	struct tegra_xusb_lane *lane;
1502 	struct tegra_xusb_padctl *padctl;
1503 
1504 	if (!phy)
1505 		return;
1506 
1507 	lane = phy_get_drvdata(phy);
1508 	padctl = lane->pad->padctl;
1509 
1510 	if (padctl->soc->ops->utmi_pad_power_down)
1511 		padctl->soc->ops->utmi_pad_power_down(phy);
1512 }
1513 EXPORT_SYMBOL_GPL(tegra_phy_xusb_utmi_pad_power_down);
1514 
1515 int tegra_xusb_padctl_get_usb3_companion(struct tegra_xusb_padctl *padctl,
1516 				    unsigned int port)
1517 {
1518 	struct tegra_xusb_usb2_port *usb2;
1519 	struct tegra_xusb_usb3_port *usb3;
1520 	int i;
1521 
1522 	usb2 = tegra_xusb_find_usb2_port(padctl, port);
1523 	if (!usb2)
1524 		return -EINVAL;
1525 
1526 	for (i = 0; i < padctl->soc->ports.usb3.count; i++) {
1527 		usb3 = tegra_xusb_find_usb3_port(padctl, i);
1528 		if (usb3 && usb3->port == usb2->base.index)
1529 			return usb3->base.index;
1530 	}
1531 
1532 	return -ENODEV;
1533 }
1534 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get_usb3_companion);
1535 
1536 int tegra_xusb_padctl_get_port_number(struct phy *phy)
1537 {
1538 	struct tegra_xusb_lane *lane;
1539 
1540 	if (!phy)
1541 		return -ENODEV;
1542 
1543 	lane = phy_get_drvdata(phy);
1544 
1545 	return lane->index;
1546 }
1547 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get_port_number);
1548 
1549 MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
1550 MODULE_DESCRIPTION("Tegra XUSB Pad Controller driver");
1551 MODULE_LICENSE("GPL v2");
1552