1552 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*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 24static 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 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#endif57#if defined(CONFIG_ARCH_TEGRA_210_SOC)58 {59 .compatible = "nvidia,tegra210-xusb-padctl",60 .data = &tegra210_xusb_padctl_soc,61 },62#endif63#if defined(CONFIG_ARCH_TEGRA_186_SOC)64 {65 .compatible = "nvidia,tegra186-xusb-padctl",66 .data = &tegra186_xusb_padctl_soc,67 },68#endif69#if defined(CONFIG_ARCH_TEGRA_194_SOC)70 {71 .compatible = "nvidia,tegra194-xusb-padctl",72 .data = &tegra194_xusb_padctl_soc,73 },74#endif75#if defined(CONFIG_ARCH_TEGRA_234_SOC)76 {77 .compatible = "nvidia,tegra234-xusb-padctl",78 .data = &tegra234_xusb_padctl_soc,79 },80#endif81 { }82};83MODULE_DEVICE_TABLE(of, tegra_xusb_padctl_of_match);84 85static struct device_node *86tegra_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 100static struct device_node *101tegra_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 115int 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 138static 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 148static 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 155static const struct device_type tegra_xusb_pad_type = {156 .release = tegra_xusb_pad_release,157};158 159int 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 182unregister:183 device_unregister(&pad->dev);184 return err;185}186 187int 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 243remove:244 while (i--)245 tegra_xusb_lane_destroy(pad->lanes[i]);246 247 of_node_put(children);248 249 return err;250}251 252void 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 264static struct tegra_xusb_pad *265tegra_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 303static 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 313static 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 320static 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 343static 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 357static 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 391bool 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 399struct 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 421struct tegra_xusb_lane *422tegra_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 else444 match = lane;445 }446 447 return match;448}449 450static struct device_node *451tegra_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 473struct tegra_xusb_port *474tegra_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 496struct tegra_xusb_usb2_port *497tegra_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 508struct tegra_xusb_usb3_port *509tegra_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 520static 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 528static const struct device_type tegra_xusb_port_type = {529 .release = tegra_xusb_port_release,530};531 532static 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 559unregister:560 device_unregister(&port->dev);561 return err;562}563 564static 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 580static 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 587static const char * const usb_roles[] = {588 [USB_ROLE_NONE] = "none",589 [USB_ROLE_HOST] = "host",590 [USB_ROLE_DEVICE] = "device",591};592 593static 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 607static 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 622static 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 634static 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 647static 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 660static 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 a672 * suboptimal solution. TODO: Need to revisit this in a follow-up patch673 * where an optimal solution is possible with changes to USB role674 * 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 phy707 * 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 727static 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 743static 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 784static 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 is793 * 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 826out:827 of_node_put(np);828 return err;829}830 831void 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 838void 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 845static 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 855static 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 893out:894 of_node_put(np);895 return err;896}897 898void 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 905static int tegra_xusb_hsic_port_parse_dt(struct tegra_xusb_hsic_port *hsic)906{907 /* XXX */908 return 0;909}910 911static 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 948out:949 of_node_put(np);950 return err;951}952 953void 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 960static 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 else985 return -EINVAL;986 }987 988 return 0;989}990 991static 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 the1000 * 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 1033out:1034 of_node_put(np);1035 return err;1036}1037 1038void 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 1045static 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 1055static 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 1069static 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 1084static 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 1107static 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 1161remove_ports:1162 __tegra_xusb_remove_ports(padctl);1163unlock:1164 mutex_unlock(&padctl->lock);1165 return err;1166}1167 1168static 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 1175static 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 1266remove_pads:1267 tegra_xusb_remove_pads(padctl);1268power_down:1269 regulator_bulk_disable(padctl->soc->num_supplies, padctl->supplies);1270reset:1271 reset_control_assert(padctl->rst);1272remove:1273 platform_set_drvdata(pdev, NULL);1274 soc->ops->remove(padctl);1275 return err;1276}1277 1278static 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 1298static __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 1308static __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 1318static 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 1323static 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};1332module_platform_driver(tegra_xusb_padctl_driver);1333 1334struct 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 a1346 * registry of pad controllers, but since there will almost certainly1347 * 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}1365EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get);1366 1367void tegra_xusb_padctl_put(struct tegra_xusb_padctl *padctl)1368{1369 if (padctl)1370 put_device(padctl->dev);1371}1372EXPORT_SYMBOL_GPL(tegra_xusb_padctl_put);1373 1374int 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}1382EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_save_context);1383 1384int 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}1392EXPORT_SYMBOL_GPL(tegra_xusb_padctl_hsic_set_idle);1393 1394int 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}1404EXPORT_SYMBOL_GPL(tegra_xusb_padctl_enable_phy_sleepwalk);1405 1406int 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}1415EXPORT_SYMBOL_GPL(tegra_xusb_padctl_disable_phy_sleepwalk);1416 1417int 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}1426EXPORT_SYMBOL_GPL(tegra_xusb_padctl_enable_phy_wake);1427 1428int 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}1437EXPORT_SYMBOL_GPL(tegra_xusb_padctl_disable_phy_wake);1438 1439bool 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}1448EXPORT_SYMBOL_GPL(tegra_xusb_padctl_remote_wake_detected);1449 1450int 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}1459EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_set_lfps_detect);1460 1461int 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}1469EXPORT_SYMBOL_GPL(tegra_xusb_padctl_set_vbus_override);1470 1471int 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}1481EXPORT_SYMBOL_GPL(tegra_phy_xusb_utmi_port_reset);1482 1483void 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}1497EXPORT_SYMBOL_GPL(tegra_phy_xusb_utmi_pad_power_on);1498 1499void 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}1513EXPORT_SYMBOL_GPL(tegra_phy_xusb_utmi_pad_power_down);1514 1515int 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}1534EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get_usb3_companion);1535 1536int 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}1547EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get_port_number);1548 1549MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");1550MODULE_DESCRIPTION("Tegra XUSB Pad Controller driver");1551MODULE_LICENSE("GPL v2");1552