drivers/phy/tegra/xusb.c

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