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_setup_ports(struct tegra_xusb_padctl *padctl)
 804 {
 805         struct tegra_xusb_port *port;
 806         unsigned int i;
 807         int err = 0;
 808
 809         mutex_lock(&padctl->lock);
 810
 811         for (i = 0; i < padctl->soc->ports.usb2.count; i++) {
 812                 err = tegra_xusb_add_usb2_port(padctl, i);
 813                 if (err < 0)
 814                         goto remove_ports;
 815         }
 816
 817         for (i = 0; i < padctl->soc->ports.ulpi.count; i++) {
 818                 err = tegra_xusb_add_ulpi_port(padctl, i);
 819                 if (err < 0)
 820                         goto remove_ports;
 821         }
 822
 823         for (i = 0; i < padctl->soc->ports.hsic.count; i++) {
 824                 err = tegra_xusb_add_hsic_port(padctl, i);
 825                 if (err < 0)
 826                         goto remove_ports;
 827         }
 828
 829         for (i = 0; i < padctl->soc->ports.usb3.count; i++) {
 830                 err = tegra_xusb_add_usb3_port(padctl, i);
 831                 if (err < 0)
 832                         goto remove_ports;
 833         }
 834
 835         list_for_each_entry(port, &padctl->ports, list) {
 836                 err = port->ops->enable(port);
 837                 if (err < 0)
 838                         dev_err(padctl->dev, "failed to enable port %s: %d\n",
 839                                 dev_name(&port->dev), err);
 840         }
 841
 842         goto unlock;
 843
 844 remove_ports:
 845         __tegra_xusb_remove_ports(padctl);
 846 unlock:
 847         mutex_unlock(&padctl->lock);
 848         return err;
 849 }
 850
 851 static void tegra_xusb_remove_ports(struct tegra_xusb_padctl *padctl)
 852 {
 853         mutex_lock(&padctl->lock);
 854         __tegra_xusb_remove_ports(padctl);
 855         mutex_unlock(&padctl->lock);
 856 }
 857
 858 static int tegra_xusb_padctl_probe(struct platform_device *pdev)
 859 {
 860         struct device_node *np = pdev->dev.of_node;
 861         const struct tegra_xusb_padctl_soc *soc;
 862         struct tegra_xusb_padctl *padctl;
 863         const struct of_device_id *match;
 864         struct resource *res;
 865         unsigned int i;
 866         int err;
 867
 868         /* for backwards compatibility with old device trees */
 869         np = of_get_child_by_name(np, "pads");
 870         if (!np) {
 871                 dev_warn(&pdev->dev, "deprecated DT, using legacy driver\n");
 872                 return tegra_xusb_padctl_legacy_probe(pdev);
 873         }
 874
 875         of_node_put(np);
 876
 877         match = of_match_node(tegra_xusb_padctl_of_match, pdev->dev.of_node);
 878         soc = match->data;
 879
 880         padctl = soc->ops->probe(&pdev->dev, soc);
 881         if (IS_ERR(padctl))
 882                 return PTR_ERR(padctl);
 883
 884         platform_set_drvdata(pdev, padctl);
 885         INIT_LIST_HEAD(&padctl->ports);
 886         INIT_LIST_HEAD(&padctl->lanes);
 887         INIT_LIST_HEAD(&padctl->pads);
 888         mutex_init(&padctl->lock);
 889
 890         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 891         padctl->regs = devm_ioremap_resource(&pdev->dev, res);
 892         if (IS_ERR(padctl->regs)) {
 893                 err = PTR_ERR(padctl->regs);
 894                 goto remove;
 895         }
 896
 897         padctl->rst = devm_reset_control_get(&pdev->dev, NULL);
 898         if (IS_ERR(padctl->rst)) {
 899                 err = PTR_ERR(padctl->rst);
 900                 goto remove;
 901         }
 902
 903         padctl->supplies = devm_kcalloc(&pdev->dev, padctl->soc->num_supplies,
 904                                         sizeof(*padctl->supplies), GFP_KERNEL);
 905         if (!padctl->supplies) {
 906                 err = -ENOMEM;
 907                 goto remove;
 908         }
 909
 910         for (i = 0; i < padctl->soc->num_supplies; i++)
 911                 padctl->supplies[i].supply = padctl->soc->supply_names[i];
 912
 913         err = devm_regulator_bulk_get(&pdev->dev, padctl->soc->num_supplies,
 914                                       padctl->supplies);
 915         if (err < 0) {
 916                 dev_err(&pdev->dev, "failed to get regulators: %d\n", err);
 917                 goto remove;
 918         }
 919
 920         err = reset_control_deassert(padctl->rst);
 921         if (err < 0)
 922                 goto remove;
 923
 924         err = regulator_bulk_enable(padctl->soc->num_supplies,
 925                                     padctl->supplies);
 926         if (err < 0) {
 927                 dev_err(&pdev->dev, "failed to enable supplies: %d\n", err);
 928                 goto reset;
 929         }
 930
 931         err = tegra_xusb_setup_pads(padctl);
 932         if (err < 0) {
 933                 dev_err(&pdev->dev, "failed to setup pads: %d\n", err);
 934                 goto power_down;
 935         }
 936
 937         err = tegra_xusb_setup_ports(padctl);
 938         if (err) {
 939                 dev_err(&pdev->dev, "failed to setup XUSB ports: %d\n", err);
 940                 goto remove_pads;
 941         }
 942
 943         return 0;
 944
 945 remove_pads:
 946         tegra_xusb_remove_pads(padctl);
 947 power_down:
 948         regulator_bulk_disable(padctl->soc->num_supplies, padctl->supplies);
 949 reset:
 950         reset_control_assert(padctl->rst);
 951 remove:
 952         soc->ops->remove(padctl);
 953         return err;
 954 }
 955
 956 static int tegra_xusb_padctl_remove(struct platform_device *pdev)
 957 {
 958         struct tegra_xusb_padctl *padctl = platform_get_drvdata(pdev);
 959         int err;
 960
 961         tegra_xusb_remove_ports(padctl);
 962         tegra_xusb_remove_pads(padctl);
 963
 964         err = regulator_bulk_disable(padctl->soc->num_supplies,
 965                                      padctl->supplies);
 966         if (err < 0)
 967                 dev_err(&pdev->dev, "failed to disable supplies: %d\n", err);
 968
 969         err = reset_control_assert(padctl->rst);
 970         if (err < 0)
 971                 dev_err(&pdev->dev, "failed to assert reset: %d\n", err);
 972
 973         padctl->soc->ops->remove(padctl);
 974
 975         return err;
 976 }
 977
 978 static struct platform_driver tegra_xusb_padctl_driver = {
 979         .driver = {
 980                 .name = "tegra-xusb-padctl",
 981                 .of_match_table = tegra_xusb_padctl_of_match,
 982         },
 983         .probe = tegra_xusb_padctl_probe,
 984         .remove = tegra_xusb_padctl_remove,
 985 };
 986 module_platform_driver(tegra_xusb_padctl_driver);
 987
 988 struct tegra_xusb_padctl *tegra_xusb_padctl_get(struct device *dev)
 989 {
 990         struct tegra_xusb_padctl *padctl;
 991         struct platform_device *pdev;
 992         struct device_node *np;
 993
 994         np = of_parse_phandle(dev->of_node, "nvidia,xusb-padctl", 0);
 995         if (!np)
 996                 return ERR_PTR(-EINVAL);
 997
 998         /*
 999          * This is slightly ugly. A better implementation would be to keep a
1000          * registry of pad controllers, but since there will almost certainly
1001          * only ever be one per SoC that would be a little overkill.
1002          */
1003         pdev = of_find_device_by_node(np);
1004         if (!pdev) {
1005                 of_node_put(np);
1006                 return ERR_PTR(-ENODEV);
1007         }
1008
1009         of_node_put(np);
1010
1011         padctl = platform_get_drvdata(pdev);
1012         if (!padctl) {
1013                 put_device(&pdev->dev);
1014                 return ERR_PTR(-EPROBE_DEFER);
1015         }
1016
1017         return padctl;
1018 }
1019 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_get);
1020
1021 void tegra_xusb_padctl_put(struct tegra_xusb_padctl *padctl)
1022 {
1023         if (padctl)
1024                 put_device(padctl->dev);
1025 }
1026 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_put);
1027
1028 int tegra_xusb_padctl_usb3_save_context(struct tegra_xusb_padctl *padctl,
1029                                         unsigned int port)
1030 {
1031         if (padctl->soc->ops->usb3_save_context)
1032                 return padctl->soc->ops->usb3_save_context(padctl, port);
1033
1034         return -ENOSYS;
1035 }
1036 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_save_context);
1037
1038 int tegra_xusb_padctl_hsic_set_idle(struct tegra_xusb_padctl *padctl,
1039                                     unsigned int port, bool idle)
1040 {
1041         if (padctl->soc->ops->hsic_set_idle)
1042                 return padctl->soc->ops->hsic_set_idle(padctl, port, idle);
1043
1044         return -ENOSYS;
1045 }
1046 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_hsic_set_idle);
1047
1048 int tegra_xusb_padctl_usb3_set_lfps_detect(struct tegra_xusb_padctl *padctl,
1049                                            unsigned int port, bool enable)
1050 {
1051         if (padctl->soc->ops->usb3_set_lfps_detect)
1052                 return padctl->soc->ops->usb3_set_lfps_detect(padctl, port,
1053                                                               enable);
1054
1055         return -ENOSYS;
1056 }
1057 EXPORT_SYMBOL_GPL(tegra_xusb_padctl_usb3_set_lfps_detect);
1058
1059 MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
1060 MODULE_DESCRIPTION("Tegra XUSB Pad Controller driver");
1061 MODULE_LICENSE("GPL v2");