root/drivers/phy/tegra/xusb.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. tegra_xusb_pad_of_xlate
  2. tegra_xusb_find_pad_node
  3. tegra_xusb_pad_find_phy_node
  4. tegra_xusb_lane_parse_dt
  5. tegra_xusb_lane_destroy
  6. tegra_xusb_pad_release
  7. tegra_xusb_pad_init
  8. tegra_xusb_pad_register
  9. tegra_xusb_pad_unregister
  10. tegra_xusb_pad_create
  11. __tegra_xusb_remove_pads
  12. tegra_xusb_remove_pads
  13. tegra_xusb_lane_program
  14. tegra_xusb_pad_program
  15. tegra_xusb_setup_pads
  16. tegra_xusb_lane_check
  17. tegra_xusb_find_lane
  18. tegra_xusb_port_find_lane
  19. tegra_xusb_find_port_node
  20. tegra_xusb_find_port
  21. tegra_xusb_find_usb2_port
  22. tegra_xusb_find_usb3_port
  23. tegra_xusb_port_release
  24. tegra_xusb_port_init
  25. tegra_xusb_port_unregister
  26. tegra_xusb_usb2_port_parse_dt
  27. tegra_xusb_add_usb2_port
  28. tegra_xusb_ulpi_port_parse_dt
  29. tegra_xusb_add_ulpi_port
  30. tegra_xusb_hsic_port_parse_dt
  31. tegra_xusb_add_hsic_port
  32. tegra_xusb_usb3_port_parse_dt
  33. tegra_xusb_add_usb3_port
  34. __tegra_xusb_remove_ports
  35. tegra_xusb_setup_ports
  36. tegra_xusb_remove_ports
  37. tegra_xusb_padctl_probe
  38. tegra_xusb_padctl_remove
  39. tegra_xusb_padctl_get
  40. tegra_xusb_padctl_put
  41. tegra_xusb_padctl_usb3_save_context
  42. tegra_xusb_padctl_hsic_set_idle
  43. tegra_xusb_padctl_usb3_set_lfps_detect

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

/* [<][>][^][v][top][bottom][index][help] */