xref: /openbmc/linux/drivers/phy/tegra/xusb.c (revision bc5aa3a0) 
1 /*
2  * Copyright (c) 2014-2015, NVIDIA CORPORATION.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  */
13 
14 #include <linux/delay.h>
15 #include <linux/io.h>
16 #include <linux/mailbox_client.h>
17 #include <linux/module.h>
18 #include <linux/of.h>
19 #include <linux/of_device.h>
20 #include <linux/phy/phy.h>
21 #include <linux/platform_device.h>
22 #include <linux/regulator/consumer.h>
23 #include <linux/reset.h>
24 #include <linux/slab.h>
25 #include <linux/workqueue.h>
26 
27 #include <soc/tegra/fuse.h>
28 
29 #include "xusb.h"
30 
31 static struct phy *tegra_xusb_pad_of_xlate(struct device *dev,
32 					   struct of_phandle_args *args)
33 {
34 	struct tegra_xusb_pad *pad = dev_get_drvdata(dev);
35 	struct phy *phy = NULL;
36 	unsigned int i;
37 
38 	if (args->args_count != 0)
39 		return ERR_PTR(-EINVAL);
40 
41 	for (i = 0; i < pad->soc->num_lanes; i++) {
42 		if (!pad->lanes[i])
43 			continue;
44 
45 		if (pad->lanes[i]->dev.of_node == args->np) {
46 			phy = pad->lanes[i];
47 			break;
48 		}
49 	}
50 
51 	if (phy == NULL)
52 		phy = ERR_PTR(-ENODEV);
53 
54 	return phy;
55 }
56 
57 static const struct of_device_id tegra_xusb_padctl_of_match[] = {
58 #if defined(CONFIG_ARCH_TEGRA_124_SOC) || defined(CONFIG_ARCH_TEGRA_132_SOC)
59 	{
60 		.compatible = "nvidia,tegra124-xusb-padctl",
61 		.data = &tegra124_xusb_padctl_soc,
62 	},
63 #endif
64 #if defined(CONFIG_ARCH_TEGRA_210_SOC)
65 	{
66 		.compatible = "nvidia,tegra210-xusb-padctl",
67 		.data = &tegra210_xusb_padctl_soc,
68 	},
69 #endif
70 	{ }
71 };
72 MODULE_DEVICE_TABLE(of, tegra_xusb_padctl_of_match);
73 
74 static struct device_node *
75 tegra_xusb_find_pad_node(struct tegra_xusb_padctl *padctl, const char *name)
76 {
77 	/*
78 	 * of_find_node_by_name() drops a reference, so make sure to grab one.
79 	 */
80 	struct device_node *np = of_node_get(padctl->dev->of_node);
81 
82 	np = of_find_node_by_name(np, "pads");
83 	if (np)
84 		np = of_find_node_by_name(np, name);
85 
86 	return np;
87 }
88 
89 static struct device_node *
90 tegra_xusb_pad_find_phy_node(struct tegra_xusb_pad *pad, unsigned int index)
91 {
92 	/*
93 	 * of_find_node_by_name() drops a reference, so make sure to grab one.
94 	 */
95 	struct device_node *np = of_node_get(pad->dev.of_node);
96 
97 	np = of_find_node_by_name(np, "lanes");
98 	if (!np)
99 		return NULL;
100 
101 	return of_find_node_by_name(np, pad->soc->lanes[index].name);
102 }
103 
104 int tegra_xusb_lane_lookup_function(struct tegra_xusb_lane *lane,
105 				    const char *function)
106 {
107 	unsigned int i;
108 
109 	for (i = 0; i < lane->soc->num_funcs; i++)
110 		if (strcmp(function, lane->soc->funcs[i]) == 0)
111 			return i;
112 
113 	return -EINVAL;
114 }
115 
116 int tegra_xusb_lane_parse_dt(struct tegra_xusb_lane *lane,
117 			     struct device_node *np)
118 {
119 	struct device *dev = &lane->pad->dev;
120 	const char *function;
121 	int err;
122 
123 	err = of_property_read_string(np, "nvidia,function", &function);
124 	if (err < 0)
125 		return err;
126 
127 	err = tegra_xusb_lane_lookup_function(lane, function);
128 	if (err < 0) {
129 		dev_err(dev, "invalid function \"%s\" for lane \"%s\"\n",
130 			function, np->name);
131 		return err;
132 	}
133 
134 	lane->function = err;
135 
136 	return 0;
137 }
138 
139 static void tegra_xusb_lane_destroy(struct phy *phy)
140 {
141 	if (phy) {
142 		struct tegra_xusb_lane *lane = phy_get_drvdata(phy);
143 
144 		lane->pad->ops->remove(lane);
145 		phy_destroy(phy);
146 	}
147 }
148 
149 static void tegra_xusb_pad_release(struct device *dev)
150 {
151 	struct tegra_xusb_pad *pad = to_tegra_xusb_pad(dev);
152 
153 	pad->soc->ops->remove(pad);
154 }
155 
156 static struct device_type tegra_xusb_pad_type = {
157 	.release = tegra_xusb_pad_release,
158 };
159 
160 int tegra_xusb_pad_init(struct tegra_xusb_pad *pad,
161 			struct tegra_xusb_padctl *padctl,
162 			struct device_node *np)
163 {
164 	int err;
165 
166 	device_initialize(&pad->dev);
167 	INIT_LIST_HEAD(&pad->list);
168 	pad->dev.parent = padctl->dev;
169 	pad->dev.type = &tegra_xusb_pad_type;
170 	pad->dev.of_node = np;
171 	pad->padctl = padctl;
172 
173 	err = dev_set_name(&pad->dev, "%s", pad->soc->name);
174 	if (err < 0)
175 		goto unregister;
176 
177 	err = device_add(&pad->dev);
178 	if (err < 0)
179 		goto unregister;
180 
181 	return 0;
182 
183 unregister:
184 	device_unregister(&pad->dev);
185 	return err;
186 }
187 
188 int tegra_xusb_pad_register(struct tegra_xusb_pad *pad,
189 			    const struct phy_ops *ops)
190 {
191 	struct device_node *children;
192 	struct phy *lane;
193 	unsigned int i;
194 	int err;
195 
196 	children = of_find_node_by_name(pad->dev.of_node, "lanes");
197 	if (!children)
198 		return -ENODEV;
199 
200 	pad->lanes = devm_kcalloc(&pad->dev, pad->soc->num_lanes, sizeof(lane),
201 				  GFP_KERNEL);
202 	if (!pad->lanes) {
203 		of_node_put(children);
204 		return -ENOMEM;
205 	}
206 
207 	for (i = 0; i < pad->soc->num_lanes; i++) {
208 		struct device_node *np = tegra_xusb_pad_find_phy_node(pad, i);
209 		struct tegra_xusb_lane *lane;
210 
211 		/* skip disabled lanes */
212 		if (!np || !of_device_is_available(np)) {
213 			of_node_put(np);
214 			continue;
215 		}
216 
217 		pad->lanes[i] = phy_create(&pad->dev, np, ops);
218 		if (IS_ERR(pad->lanes[i])) {
219 			err = PTR_ERR(pad->lanes[i]);
220 			of_node_put(np);
221 			goto remove;
222 		}
223 
224 		lane = pad->ops->probe(pad, np, i);
225 		if (IS_ERR(lane)) {
226 			phy_destroy(pad->lanes[i]);
227 			err = PTR_ERR(lane);
228 			goto remove;
229 		}
230 
231 		list_add_tail(&lane->list, &pad->padctl->lanes);
232 		phy_set_drvdata(pad->lanes[i], lane);
233 	}
234 
235 	pad->provider = of_phy_provider_register_full(&pad->dev, children,
236 						      tegra_xusb_pad_of_xlate);
237 	if (IS_ERR(pad->provider)) {
238 		err = PTR_ERR(pad->provider);
239 		goto remove;
240 	}
241 
242 	return 0;
243 
244 remove:
245 	while (i--)
246 		tegra_xusb_lane_destroy(pad->lanes[i]);
247 
248 	of_node_put(children);
249 
250 	return err;
251 }
252 
253 void tegra_xusb_pad_unregister(struct tegra_xusb_pad *pad)
254 {
255 	unsigned int i = pad->soc->num_lanes;
256 
257 	of_phy_provider_unregister(pad->provider);
258 
259 	while (i--)
260 		tegra_xusb_lane_destroy(pad->lanes[i]);
261 
262 	device_unregister(&pad->dev);
263 }
264 
265 static struct tegra_xusb_pad *
266 tegra_xusb_pad_create(struct tegra_xusb_padctl *padctl,
267 		      const struct tegra_xusb_pad_soc *soc)
268 {
269 	struct tegra_xusb_pad *pad;
270 	struct device_node *np;
271 	int err;
272 
273 	np = tegra_xusb_find_pad_node(padctl, soc->name);
274 	if (!np || !of_device_is_available(np))
275 		return NULL;
276 
277 	pad = soc->ops->probe(padctl, soc, np);
278 	if (IS_ERR(pad)) {
279 		err = PTR_ERR(pad);
280 		dev_err(padctl->dev, "failed to create pad %s: %d\n",
281 			soc->name, err);
282 		return ERR_PTR(err);
283 	}
284 
285 	/* XXX move this into ->probe() to avoid string comparison */
286 	if (strcmp(soc->name, "pcie") == 0)
287 		padctl->pcie = pad;
288 
289 	if (strcmp(soc->name, "sata") == 0)
290 		padctl->sata = pad;
291 
292 	if (strcmp(soc->name, "usb2") == 0)
293 		padctl->usb2 = pad;
294 
295 	if (strcmp(soc->name, "ulpi") == 0)
296 		padctl->ulpi = pad;
297 
298 	if (strcmp(soc->name, "hsic") == 0)
299 		padctl->hsic = pad;
300 
301 	return pad;
302 }
303 
304 static void __tegra_xusb_remove_pads(struct tegra_xusb_padctl *padctl)
305 {
306 	struct tegra_xusb_pad *pad, *tmp;
307 
308 	list_for_each_entry_safe_reverse(pad, tmp, &padctl->pads, list) {
309 		list_del(&pad->list);
310 		tegra_xusb_pad_unregister(pad);
311 	}
312 }
313 
314 static void tegra_xusb_remove_pads(struct tegra_xusb_padctl *padctl)
315 {
316 	mutex_lock(&padctl->lock);
317 	__tegra_xusb_remove_pads(padctl);
318 	mutex_unlock(&padctl->lock);
319 }
320 
321 static void tegra_xusb_lane_program(struct tegra_xusb_lane *lane)
322 {
323 	struct tegra_xusb_padctl *padctl = lane->pad->padctl;
324 	const struct tegra_xusb_lane_soc *soc = lane->soc;
325 	u32 value;
326 
327 	/* choose function */
328 	value = padctl_readl(padctl, soc->offset);
329 	value &= ~(soc->mask << soc->shift);
330 	value |= lane->function << soc->shift;
331 	padctl_writel(padctl, value, soc->offset);
332 }
333 
334 static void tegra_xusb_pad_program(struct tegra_xusb_pad *pad)
335 {
336 	unsigned int i;
337 
338 	for (i = 0; i < pad->soc->num_lanes; i++) {
339 		struct tegra_xusb_lane *lane;
340 
341 		if (pad->lanes[i]) {
342 			lane = phy_get_drvdata(pad->lanes[i]);
343 			tegra_xusb_lane_program(lane);
344 		}
345 	}
346 }
347 
348 static int tegra_xusb_setup_pads(struct tegra_xusb_padctl *padctl)
349 {
350 	struct tegra_xusb_pad *pad;
351 	unsigned int i;
352 
353 	mutex_lock(&padctl->lock);
354 
355 	for (i = 0; i < padctl->soc->num_pads; i++) {
356 		const struct tegra_xusb_pad_soc *soc = padctl->soc->pads[i];
357 		int err;
358 
359 		pad = tegra_xusb_pad_create(padctl, soc);
360 		if (IS_ERR(pad)) {
361 			err = PTR_ERR(pad);
362 			dev_err(padctl->dev, "failed to create pad %s: %d\n",
363 				soc->name, err);
364 			__tegra_xusb_remove_pads(padctl);
365 			mutex_unlock(&padctl->lock);
366 			return err;
367 		}
368 
369 		if (!pad)
370 			continue;
371 
372 		list_add_tail(&pad->list, &padctl->pads);
373 	}
374 
375 	list_for_each_entry(pad, &padctl->pads, list)
376 		tegra_xusb_pad_program(pad);
377 
378 	mutex_unlock(&padctl->lock);
379 	return 0;
380 }
381 
382 static bool tegra_xusb_lane_check(struct tegra_xusb_lane *lane,
383 				  const char *function)
384 {
385 	const char *func = lane->soc->funcs[lane->function];
386 
387 	return strcmp(function, func) == 0;
388 }
389 
390 struct tegra_xusb_lane *tegra_xusb_find_lane(struct tegra_xusb_padctl *padctl,
391 					     const char *type,
392 					     unsigned int index)
393 {
394 	struct tegra_xusb_lane *lane, *hit = ERR_PTR(-ENODEV);
395 	char *name;
396 
397 	name = kasprintf(GFP_KERNEL, "%s-%u", type, index);
398 	if (!name)
399 		return ERR_PTR(-ENOMEM);
400 
401 	list_for_each_entry(lane, &padctl->lanes, list) {
402 		if (strcmp(lane->soc->name, name) == 0) {
403 			hit = lane;
404 			break;
405 		}
406 	}
407 
408 	kfree(name);
409 	return hit;
410 }
411 
412 struct tegra_xusb_lane *
413 tegra_xusb_port_find_lane(struct tegra_xusb_port *port,
414 			  const struct tegra_xusb_lane_map *map,
415 			  const char *function)
416 {
417 	struct tegra_xusb_lane *lane, *match = ERR_PTR(-ENODEV);
418 
419 	for (map = map; map->type; map++) {
420 		if (port->index != map->port)
421 			continue;
422 
423 		lane = tegra_xusb_find_lane(port->padctl, map->type,
424 					    map->index);
425 		if (IS_ERR(lane))
426 			continue;
427 
428 		if (!tegra_xusb_lane_check(lane, function))
429 			continue;
430 
431 		if (!IS_ERR(match))
432 			dev_err(&port->dev, "conflicting match: %s-%u / %s\n",
433 				map->type, map->index, match->soc->name);
434 		else
435 			match = lane;
436 	}
437 
438 	return match;
439 }
440 
441 static struct device_node *
442 tegra_xusb_find_port_node(struct tegra_xusb_padctl *padctl, const char *type,
443 			  unsigned int index)
444 {
445 	/*
446 	 * of_find_node_by_name() drops a reference, so make sure to grab one.
447 	 */
448 	struct device_node *np = of_node_get(padctl->dev->of_node);
449 
450 	np = of_find_node_by_name(np, "ports");
451 	if (np) {
452 		char *name;
453 
454 		name = kasprintf(GFP_KERNEL, "%s-%u", type, index);
455 		np = of_find_node_by_name(np, name);
456 		kfree(name);
457 	}
458 
459 	return np;
460 }
461 
462 struct tegra_xusb_port *
463 tegra_xusb_find_port(struct tegra_xusb_padctl *padctl, const char *type,
464 		     unsigned int index)
465 {
466 	struct tegra_xusb_port *port;
467 	struct device_node *np;
468 
469 	np = tegra_xusb_find_port_node(padctl, type, index);
470 	if (!np)
471 		return NULL;
472 
473 	list_for_each_entry(port, &padctl->ports, list) {
474 		if (np == port->dev.of_node) {
475 			of_node_put(np);
476 			return port;
477 		}
478 	}
479 
480 	of_node_put(np);
481 
482 	return NULL;
483 }
484 
485 struct tegra_xusb_usb2_port *
486 tegra_xusb_find_usb2_port(struct tegra_xusb_padctl *padctl, unsigned int index)
487 {
488 	struct tegra_xusb_port *port;
489 
490 	port = tegra_xusb_find_port(padctl, "usb2", index);
491 	if (port)
492 		return to_usb2_port(port);
493 
494 	return NULL;
495 }
496 
497 struct tegra_xusb_usb3_port *
498 tegra_xusb_find_usb3_port(struct tegra_xusb_padctl *padctl, unsigned int index)
499 {
500 	struct tegra_xusb_port *port;
501 
502 	port = tegra_xusb_find_port(padctl, "usb3", index);
503 	if (port)
504 		return to_usb3_port(port);
505 
506 	return NULL;
507 }
508 
509 static void tegra_xusb_port_release(struct device *dev)
510 {
511 }
512 
513 static struct device_type tegra_xusb_port_type = {
514 	.release = tegra_xusb_port_release,
515 };
516 
517 static int tegra_xusb_port_init(struct tegra_xusb_port *port,
518 				struct tegra_xusb_padctl *padctl,
519 				struct device_node *np,
520 				const char *name,
521 				unsigned int index)
522 {
523 	int err;
524 
525 	INIT_LIST_HEAD(&port->list);
526 	port->padctl = padctl;
527 	port->index = index;
528 
529 	device_initialize(&port->dev);
530 	port->dev.type = &tegra_xusb_port_type;
531 	port->dev.of_node = of_node_get(np);
532 	port->dev.parent = padctl->dev;
533 
534 	err = dev_set_name(&port->dev, "%s-%u", name, index);
535 	if (err < 0)
536 		goto unregister;
537 
538 	err = device_add(&port->dev);
539 	if (err < 0)
540 		goto unregister;
541 
542 	return 0;
543 
544 unregister:
545 	device_unregister(&port->dev);
546 	return err;
547 }
548 
549 static void tegra_xusb_port_unregister(struct tegra_xusb_port *port)
550 {
551 	device_unregister(&port->dev);
552 }
553 
554 static int tegra_xusb_usb2_port_parse_dt(struct tegra_xusb_usb2_port *usb2)
555 {
556 	struct tegra_xusb_port *port = &usb2->base;
557 	struct device_node *np = port->dev.of_node;
558 
559 	usb2->internal = of_property_read_bool(np, "nvidia,internal");
560 
561 	usb2->supply = devm_regulator_get(&port->dev, "vbus");
562 	if (IS_ERR(usb2->supply))
563 		return PTR_ERR(usb2->supply);
564 
565 	return 0;
566 }
567 
568 static int tegra_xusb_add_usb2_port(struct tegra_xusb_padctl *padctl,
569 				    unsigned int index)
570 {
571 	struct tegra_xusb_usb2_port *usb2;
572 	struct device_node *np;
573 	int err = 0;
574 
575 	/*
576 	 * USB2 ports don't require additional properties, but if the port is
577 	 * marked as disabled there is no reason to register it.
578 	 */
579 	np = tegra_xusb_find_port_node(padctl, "usb2", index);
580 	if (!np || !of_device_is_available(np))
581 		goto out;
582 
583 	usb2 = devm_kzalloc(padctl->dev, sizeof(*usb2), GFP_KERNEL);
584 	if (!usb2) {
585 		err = -ENOMEM;
586 		goto out;
587 	}
588 
589 	err = tegra_xusb_port_init(&usb2->base, padctl, np, "usb2", index);
590 	if (err < 0)
591 		goto out;
592 
593 	usb2->base.ops = padctl->soc->ports.usb2.ops;
594 
595 	usb2->base.lane = usb2->base.ops->map(&usb2->base);
596 	if (IS_ERR(usb2->base.lane)) {
597 		err = PTR_ERR(usb2->base.lane);
598 		goto out;
599 	}
600 
601 	err = tegra_xusb_usb2_port_parse_dt(usb2);
602 	if (err < 0) {
603 		tegra_xusb_port_unregister(&usb2->base);
604 		goto out;
605 	}
606 
607 	list_add_tail(&usb2->base.list, &padctl->ports);
608 
609 out:
610 	of_node_put(np);
611 	return err;
612 }
613 
614 static int tegra_xusb_ulpi_port_parse_dt(struct tegra_xusb_ulpi_port *ulpi)
615 {
616 	struct tegra_xusb_port *port = &ulpi->base;
617 	struct device_node *np = port->dev.of_node;
618 
619 	ulpi->internal = of_property_read_bool(np, "nvidia,internal");
620 
621 	return 0;
622 }
623 
624 static int tegra_xusb_add_ulpi_port(struct tegra_xusb_padctl *padctl,
625 				    unsigned int index)
626 {
627 	struct tegra_xusb_ulpi_port *ulpi;
628 	struct device_node *np;
629 	int err = 0;
630 
631 	np = tegra_xusb_find_port_node(padctl, "ulpi", index);
632 	if (!np || !of_device_is_available(np))
633 		goto out;
634 
635 	ulpi = devm_kzalloc(padctl->dev, sizeof(*ulpi), GFP_KERNEL);
636 	if (!ulpi) {
637 		err = -ENOMEM;
638 		goto out;
639 	}
640 
641 	err = tegra_xusb_port_init(&ulpi->base, padctl, np, "ulpi", index);
642 	if (err < 0)
643 		goto out;
644 
645 	ulpi->base.ops = padctl->soc->ports.ulpi.ops;
646 
647 	ulpi->base.lane = ulpi->base.ops->map(&ulpi->base);
648 	if (IS_ERR(ulpi->base.lane)) {
649 		err = PTR_ERR(ulpi->base.lane);
650 		goto out;
651 	}
652 
653 	err = tegra_xusb_ulpi_port_parse_dt(ulpi);
654 	if (err < 0) {
655 		tegra_xusb_port_unregister(&ulpi->base);
656 		goto out;
657 	}
658 
659 	list_add_tail(&ulpi->base.list, &padctl->ports);
660 
661 out:
662 	of_node_put(np);
663 	return err;
664 }
665 
666 static int tegra_xusb_hsic_port_parse_dt(struct tegra_xusb_hsic_port *hsic)
667 {
668 	/* XXX */
669 	return 0;
670 }
671 
672 static int tegra_xusb_add_hsic_port(struct tegra_xusb_padctl *padctl,
673 				    unsigned int index)
674 {
675 	struct tegra_xusb_hsic_port *hsic;
676 	struct device_node *np;
677 	int err = 0;
678 
679 	np = tegra_xusb_find_port_node(padctl, "hsic", index);
680 	if (!np || !of_device_is_available(np))
681 		goto out;
682 
683 	hsic = devm_kzalloc(padctl->dev, sizeof(*hsic), GFP_KERNEL);
684 	if (!hsic) {
685 		err = -ENOMEM;
686 		goto out;
687 	}
688 
689 	err = tegra_xusb_port_init(&hsic->base, padctl, np, "hsic", index);
690 	if (err < 0)
691 		goto out;
692 
693 	hsic->base.ops = padctl->soc->ports.hsic.ops;
694 
695 	hsic->base.lane = hsic->base.ops->map(&hsic->base);
696 	if (IS_ERR(hsic->base.lane)) {
697 		err = PTR_ERR(hsic->base.lane);
698 		goto out;
699 	}
700 
701 	err = tegra_xusb_hsic_port_parse_dt(hsic);
702 	if (err < 0) {
703 		tegra_xusb_port_unregister(&hsic->base);
704 		goto out;
705 	}
706 
707 	list_add_tail(&hsic->base.list, &padctl->ports);
708 
709 out:
710 	of_node_put(np);
711 	return err;
712 }
713 
714 static int tegra_xusb_usb3_port_parse_dt(struct tegra_xusb_usb3_port *usb3)
715 {
716 	struct tegra_xusb_port *port = &usb3->base;
717 	struct device_node *np = port->dev.of_node;
718 	u32 value;
719 	int err;
720 
721 	err = of_property_read_u32(np, "nvidia,usb2-companion", &value);
722 	if (err < 0) {
723 		dev_err(&port->dev, "failed to read port: %d\n", err);
724 		return err;
725 	}
726 
727 	usb3->port = value;
728 
729 	usb3->internal = of_property_read_bool(np, "nvidia,internal");
730 
731 	usb3->supply = devm_regulator_get(&port->dev, "vbus");
732 	if (IS_ERR(usb3->supply))
733 		return PTR_ERR(usb3->supply);
734 
735 	return 0;
736 }
737 
738 static int tegra_xusb_add_usb3_port(struct tegra_xusb_padctl *padctl,
739 				    unsigned int index)
740 {
741 	struct tegra_xusb_usb3_port *usb3;
742 	struct device_node *np;
743 	int err = 0;
744 
745 	/*
746 	 * If there is no supplemental configuration in the device tree the
747 	 * port is unusable. But it is valid to configure only a single port,
748 	 * hence return 0 instead of an error to allow ports to be optional.
749 	 */
750 	np = tegra_xusb_find_port_node(padctl, "usb3", index);
751 	if (!np || !of_device_is_available(np))
752 		goto out;
753 
754 	usb3 = devm_kzalloc(padctl->dev, sizeof(*usb3), GFP_KERNEL);
755 	if (!usb3) {
756 		err = -ENOMEM;
757 		goto out;
758 	}
759 
760 	err = tegra_xusb_port_init(&usb3->base, padctl, np, "usb3", index);
761 	if (err < 0)
762 		goto out;
763 
764 	usb3->base.ops = padctl->soc->ports.usb3.ops;
765 
766 	usb3->base.lane = usb3->base.ops->map(&usb3->base);
767 	if (IS_ERR(usb3->base.lane)) {
768 		err = PTR_ERR(usb3->base.lane);
769 		goto out;
770 	}
771 
772 	err = tegra_xusb_usb3_port_parse_dt(usb3);
773 	if (err < 0) {
774 		tegra_xusb_port_unregister(&usb3->base);
775 		goto out;
776 	}
777 
778 	list_add_tail(&usb3->base.list, &padctl->ports);
779 
780 out:
781 	of_node_put(np);
782 	return err;
783 }
784 
785 static void __tegra_xusb_remove_ports(struct tegra_xusb_padctl *padctl)
786 {
787 	struct tegra_xusb_port *port, *tmp;
788 
789 	list_for_each_entry_safe_reverse(port, tmp, &padctl->ports, list) {
790 		list_del(&port->list);
791 		tegra_xusb_port_unregister(port);
792 	}
793 }
794 
795 static int tegra_xusb_setup_ports(struct tegra_xusb_padctl *padctl)
796 {
797 	struct tegra_xusb_port *port;
798 	unsigned int i;
799 	int err = 0;
800 
801 	mutex_lock(&padctl->lock);
802 
803 	for (i = 0; i < padctl->soc->ports.usb2.count; i++) {
804 		err = tegra_xusb_add_usb2_port(padctl, i);
805 		if (err < 0)
806 			goto remove_ports;
807 	}
808 
809 	for (i = 0; i < padctl->soc->ports.ulpi.count; i++) {
810 		err = tegra_xusb_add_ulpi_port(padctl, i);
811 		if (err < 0)
812 			goto remove_ports;
813 	}
814 
815 	for (i = 0; i < padctl->soc->ports.hsic.count; i++) {
816 		err = tegra_xusb_add_hsic_port(padctl, i);
817 		if (err < 0)
818 			goto remove_ports;
819 	}
820 
821 	for (i = 0; i < padctl->soc->ports.usb3.count; i++) {
822 		err = tegra_xusb_add_usb3_port(padctl, i);
823 		if (err < 0)
824 			goto remove_ports;
825 	}
826 
827 	list_for_each_entry(port, &padctl->ports, list) {
828 		err = port->ops->enable(port);
829 		if (err < 0)
830 			dev_err(padctl->dev, "failed to enable port %s: %d\n",
831 				dev_name(&port->dev), err);
832 	}
833 
834 	goto unlock;
835 
836 remove_ports:
837 	__tegra_xusb_remove_ports(padctl);
838 unlock:
839 	mutex_unlock(&padctl->lock);
840 	return err;
841 }
842 
843 static void tegra_xusb_remove_ports(struct tegra_xusb_padctl *padctl)
844 {
845 	mutex_lock(&padctl->lock);
846 	__tegra_xusb_remove_ports(padctl);
847 	mutex_unlock(&padctl->lock);
848 }
849 
850 static int tegra_xusb_padctl_probe(struct platform_device *pdev)
851 {
852 	struct device_node *np = of_node_get(pdev->dev.of_node);
853 	const struct tegra_xusb_padctl_soc *soc;
854 	struct tegra_xusb_padctl *padctl;
855 	const struct of_device_id *match;
856 	struct resource *res;
857 	int err;
858 
859 	/* for backwards compatibility with old device trees */
860 	np = of_find_node_by_name(np, "pads");
861 	if (!np) {
862 		dev_warn(&pdev->dev, "deprecated DT, using legacy driver\n");
863 		return tegra_xusb_padctl_legacy_probe(pdev);
864 	}
865 
866 	of_node_put(np);
867 
868 	match = of_match_node(tegra_xusb_padctl_of_match, pdev->dev.of_node);
869 	soc = match->data;
870 
871 	padctl = soc->ops->probe(&pdev->dev, soc);
872 	if (IS_ERR(padctl))
873 		return PTR_ERR(padctl);
874 
875 	platform_set_drvdata(pdev, padctl);
876 	INIT_LIST_HEAD(&padctl->ports);
877 	INIT_LIST_HEAD(&padctl->lanes);
878 	INIT_LIST_HEAD(&padctl->pads);
879 	mutex_init(&padctl->lock);
880 
881 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
882 	padctl->regs = devm_ioremap_resource(&pdev->dev, res);
883 	if (IS_ERR(padctl->regs)) {
884 		err = PTR_ERR(padctl->regs);
885 		goto remove;
886 	}
887 
888 	padctl->rst = devm_reset_control_get(&pdev->dev, NULL);
889 	if (IS_ERR(padctl->rst)) {
890 		err = PTR_ERR(padctl->rst);
891 		goto remove;
892 	}
893 
894 	err = reset_control_deassert(padctl->rst);
895 	if (err < 0)
896 		goto remove;
897 
898 	err = tegra_xusb_setup_pads(padctl);
899 	if (err < 0) {
900 		dev_err(&pdev->dev, "failed to setup pads: %d\n", err);
901 		goto reset;
902 	}
903 
904 	err = tegra_xusb_setup_ports(padctl);
905 	if (err) {
906 		dev_err(&pdev->dev, "failed to setup XUSB ports: %d\n", err);
907 		goto remove_pads;
908 	}
909 
910 	return 0;
911 
912 remove_pads:
913 	tegra_xusb_remove_pads(padctl);
914 reset:
915 	reset_control_assert(padctl->rst);
916 remove:
917 	soc->ops->remove(padctl);
918 	return err;
919 }
920 
921 static int tegra_xusb_padctl_remove(struct platform_device *pdev)
922 {
923 	struct tegra_xusb_padctl *padctl = platform_get_drvdata(pdev);
924 	int err;
925 
926 	tegra_xusb_remove_ports(padctl);
927 	tegra_xusb_remove_pads(padctl);
928 
929 	err = reset_control_assert(padctl->rst);
930 	if (err < 0)
931 		dev_err(&pdev->dev, "failed to assert reset: %d\n", err);
932 
933 	padctl->soc->ops->remove(padctl);
934 
935 	return err;
936 }
937 
938 static struct platform_driver tegra_xusb_padctl_driver = {
939 	.driver = {
940 		.name = "tegra-xusb-padctl",
941 		.of_match_table = tegra_xusb_padctl_of_match,
942 	},
943 	.probe = tegra_xusb_padctl_probe,
944 	.remove = tegra_xusb_padctl_remove,
945 };
946 module_platform_driver(tegra_xusb_padctl_driver);
947 
948 struct tegra_xusb_padctl *tegra_xusb_padctl_get(struct device *dev)
949 {
950 	struct tegra_xusb_padctl *padctl;
951 	struct platform_device *pdev;
952 	struct device_node *np;
953 
954 	np = of_parse_phandle(dev->of_node, "nvidia,xusb-padctl", 0);
955 	if (!np)
956 		return ERR_PTR(-EINVAL);
957 
958 	/*
959 	 * This is slightly ugly. A better implementation would be to keep a
960 	 * registry of pad controllers, but since there will almost certainly
961 	 * only ever be one per SoC that would be a little overkill.
962 	 */
963 	pdev = of_find_device_by_node(np);
964 	if (!pdev) {
965 		of_node_put(np);
966 		return ERR_PTR(-ENODEV);
967 	}
968 
969 	of_node_put(np);
970 
971 	padctl = platform_get_drvdata(pdev);
972 	if (!padctl) {
973 		put_device(&pdev->dev);
974 		return ERR_PTR(-EPROBE_DEFER);
975 	}
976 
977 	return padctl;
978 }
979 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get);
980 
981 void tegra_xusb_padctl_put(struct tegra_xusb_padctl *padctl)
982 {
983 	if (padctl)
984 		put_device(padctl->dev);
985 }
986 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_put);
987 
988 int tegra_xusb_padctl_usb3_save_context(struct tegra_xusb_padctl *padctl,
989 					unsigned int port)
990 {
991 	if (padctl->soc->ops->usb3_save_context)
992 		return padctl->soc->ops->usb3_save_context(padctl, port);
993 
994 	return -ENOSYS;
995 }
996 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_save_context);
997 
998 int tegra_xusb_padctl_hsic_set_idle(struct tegra_xusb_padctl *padctl,
999 				    unsigned int port, bool idle)
1000 {
1001 	if (padctl->soc->ops->hsic_set_idle)
1002 		return padctl->soc->ops->hsic_set_idle(padctl, port, idle);
1003 
1004 	return -ENOSYS;
1005 }
1006 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_hsic_set_idle);
1007 
1008 int tegra_xusb_padctl_usb3_set_lfps_detect(struct tegra_xusb_padctl *padctl,
1009 					   unsigned int port, bool enable)
1010 {
1011 	if (padctl->soc->ops->usb3_set_lfps_detect)
1012 		return padctl->soc->ops->usb3_set_lfps_detect(padctl, port,
1013 							      enable);
1014 
1015 	return -ENOSYS;
1016 }
1017 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_set_lfps_detect);
1018 
1019 MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
1020 MODULE_DESCRIPTION("Tegra XUSB Pad Controller driver");
1021 MODULE_LICENSE("GPL v2");
1022