drivers/phy/tegra/xusb.c

   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");