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