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