drivers/phy/motorola/phy-cpcap-usb.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Motorola CPCAP PMIC USB PHY driver
   4  * Copyright (C) 2017 Tony Lindgren <tony@atomide.com>
   5  *
   6  * Some parts based on earlier Motorola Linux kernel tree code in
   7  * board-mapphone-usb.c and cpcap-usb-det.c:
   8  * Copyright (C) 2007 - 2011 Motorola, Inc.
   9  */
  10
  11 #include <linux/atomic.h>
  12 #include <linux/clk.h>
  13 #include <linux/delay.h>
  14 #include <linux/err.h>
  15 #include <linux/io.h>
  16 #include <linux/module.h>
  17 #include <linux/of.h>
  18 #include <linux/of_platform.h>
  19 #include <linux/iio/consumer.h>
  20 #include <linux/pinctrl/consumer.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/regmap.h>
  23 #include <linux/slab.h>
  24
  25 #include <linux/gpio/consumer.h>
  26 #include <linux/mfd/motorola-cpcap.h>
  27 #include <linux/phy/omap_usb.h>
  28 #include <linux/phy/phy.h>
  29 #include <linux/regulator/consumer.h>
  30 #include <linux/usb/musb.h>
  31
  32 /* CPCAP_REG_USBC1 register bits */
  33 #define CPCAP_BIT_IDPULSE               BIT(15)
  34 #define CPCAP_BIT_ID100KPU              BIT(14)
  35 #define CPCAP_BIT_IDPUCNTRL             BIT(13)
  36 #define CPCAP_BIT_IDPU                  BIT(12)
  37 #define CPCAP_BIT_IDPD                  BIT(11)
  38 #define CPCAP_BIT_VBUSCHRGTMR3          BIT(10)
  39 #define CPCAP_BIT_VBUSCHRGTMR2          BIT(9)
  40 #define CPCAP_BIT_VBUSCHRGTMR1          BIT(8)
  41 #define CPCAP_BIT_VBUSCHRGTMR0          BIT(7)
  42 #define CPCAP_BIT_VBUSPU                BIT(6)
  43 #define CPCAP_BIT_VBUSPD                BIT(5)
  44 #define CPCAP_BIT_DMPD                  BIT(4)
  45 #define CPCAP_BIT_DPPD                  BIT(3)
  46 #define CPCAP_BIT_DM1K5PU               BIT(2)
  47 #define CPCAP_BIT_DP1K5PU               BIT(1)
  48 #define CPCAP_BIT_DP150KPU              BIT(0)
  49
  50 /* CPCAP_REG_USBC2 register bits */
  51 #define CPCAP_BIT_ZHSDRV1               BIT(15)
  52 #define CPCAP_BIT_ZHSDRV0               BIT(14)
  53 #define CPCAP_BIT_DPLLCLKREQ            BIT(13)
  54 #define CPCAP_BIT_SE0CONN               BIT(12)
  55 #define CPCAP_BIT_UARTTXTRI             BIT(11)
  56 #define CPCAP_BIT_UARTSWAP              BIT(10)
  57 #define CPCAP_BIT_UARTMUX1              BIT(9)
  58 #define CPCAP_BIT_UARTMUX0              BIT(8)
  59 #define CPCAP_BIT_ULPISTPLOW            BIT(7)
  60 #define CPCAP_BIT_TXENPOL               BIT(6)
  61 #define CPCAP_BIT_USBXCVREN             BIT(5)
  62 #define CPCAP_BIT_USBCNTRL              BIT(4)
  63 #define CPCAP_BIT_USBSUSPEND            BIT(3)
  64 #define CPCAP_BIT_EMUMODE2              BIT(2)
  65 #define CPCAP_BIT_EMUMODE1              BIT(1)
  66 #define CPCAP_BIT_EMUMODE0              BIT(0)
  67
  68 /* CPCAP_REG_USBC3 register bits */
  69 #define CPCAP_BIT_SPARE_898_15          BIT(15)
  70 #define CPCAP_BIT_IHSTX03               BIT(14)
  71 #define CPCAP_BIT_IHSTX02               BIT(13)
  72 #define CPCAP_BIT_IHSTX01               BIT(12)
  73 #define CPCAP_BIT_IHSTX0                BIT(11)
  74 #define CPCAP_BIT_IDPU_SPI              BIT(10)
  75 #define CPCAP_BIT_UNUSED_898_9          BIT(9)
  76 #define CPCAP_BIT_VBUSSTBY_EN           BIT(8)
  77 #define CPCAP_BIT_VBUSEN_SPI            BIT(7)
  78 #define CPCAP_BIT_VBUSPU_SPI            BIT(6)
  79 #define CPCAP_BIT_VBUSPD_SPI            BIT(5)
  80 #define CPCAP_BIT_DMPD_SPI              BIT(4)
  81 #define CPCAP_BIT_DPPD_SPI              BIT(3)
  82 #define CPCAP_BIT_SUSPEND_SPI           BIT(2)
  83 #define CPCAP_BIT_PU_SPI                BIT(1)
  84 #define CPCAP_BIT_ULPI_SPI_SEL          BIT(0)
  85
  86 struct cpcap_usb_ints_state {
  87         bool id_ground;
  88         bool id_float;
  89         bool chrg_det;
  90         bool rvrs_chrg;
  91         bool vbusov;
  92
  93         bool chrg_se1b;
  94         bool se0conn;
  95         bool rvrs_mode;
  96         bool chrgcurr1;
  97         bool vbusvld;
  98         bool sessvld;
  99         bool sessend;
 100         bool se1;
 101
 102         bool battdetb;
 103         bool dm;
 104         bool dp;
 105 };
 106
 107 enum cpcap_gpio_mode {
 108         CPCAP_DM_DP,
 109         CPCAP_MDM_RX_TX,
 110         CPCAP_UNKNOWN_DISABLED, /* Seems to disable USB lines */
 111         CPCAP_OTG_DM_DP,
 112 };
 113
 114 struct cpcap_phy_ddata {
 115         struct regmap *reg;
 116         struct device *dev;
 117         struct usb_phy phy;
 118         struct delayed_work detect_work;
 119         struct pinctrl *pins;
 120         struct pinctrl_state *pins_ulpi;
 121         struct pinctrl_state *pins_utmi;
 122         struct pinctrl_state *pins_uart;
 123         struct gpio_desc *gpio[2];
 124         struct iio_channel *vbus;
 125         struct iio_channel *id;
 126         struct regulator *vusb;
 127         atomic_t active;
 128         unsigned int vbus_provider:1;
 129         unsigned int docked:1;
 130 };
 131
 132 static bool cpcap_usb_vbus_valid(struct cpcap_phy_ddata *ddata)
 133 {
 134         int error, value = 0;
 135
 136         error = iio_read_channel_processed(ddata->vbus, &value);
 137         if (error >= 0)
 138                 return value > 3900;
 139
 140         dev_err(ddata->dev, "error reading VBUS: %i\n", error);
 141
 142         return false;
 143 }
 144
 145 static int cpcap_usb_phy_set_host(struct usb_otg *otg, struct usb_bus *host)
 146 {
 147         otg->host = host;
 148         if (!host)
 149                 otg->state = OTG_STATE_UNDEFINED;
 150
 151         return 0;
 152 }
 153
 154 static int cpcap_usb_phy_set_peripheral(struct usb_otg *otg,
 155                                         struct usb_gadget *gadget)
 156 {
 157         otg->gadget = gadget;
 158         if (!gadget)
 159                 otg->state = OTG_STATE_UNDEFINED;
 160
 161         return 0;
 162 }
 163
 164 static const struct phy_ops ops = {
 165         .owner          = THIS_MODULE,
 166 };
 167
 168 static int cpcap_phy_get_ints_state(struct cpcap_phy_ddata *ddata,
 169                                     struct cpcap_usb_ints_state *s)
 170 {
 171         int val, error;
 172
 173         error = regmap_read(ddata->reg, CPCAP_REG_INTS1, &val);
 174         if (error)
 175                 return error;
 176
 177         s->id_ground = val & BIT(15);
 178         s->id_float = val & BIT(14);
 179         s->vbusov = val & BIT(11);
 180
 181         error = regmap_read(ddata->reg, CPCAP_REG_INTS2, &val);
 182         if (error)
 183                 return error;
 184
 185         s->vbusvld = val & BIT(3);
 186         s->sessvld = val & BIT(2);
 187         s->sessend = val & BIT(1);
 188         s->se1 = val & BIT(0);
 189
 190         error = regmap_read(ddata->reg, CPCAP_REG_INTS4, &val);
 191         if (error)
 192                 return error;
 193
 194         s->dm = val & BIT(1);
 195         s->dp = val & BIT(0);
 196
 197         return 0;
 198 }
 199
 200 static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata);
 201 static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata);
 202
 203 static void cpcap_usb_try_musb_mailbox(struct cpcap_phy_ddata *ddata,
 204                                        enum musb_vbus_id_status status)
 205 {
 206         int error;
 207
 208         error = musb_mailbox(status);
 209         if (!error)
 210                 return;
 211
 212         dev_dbg(ddata->dev, "%s: musb_mailbox failed: %i\n",
 213                 __func__, error);
 214 }
 215
 216 static void cpcap_usb_detect(struct work_struct *work)
 217 {
 218         struct cpcap_phy_ddata *ddata;
 219         struct cpcap_usb_ints_state s;
 220         bool vbus = false;
 221         int error;
 222
 223         ddata = container_of(work, struct cpcap_phy_ddata, detect_work.work);
 224
 225         error = cpcap_phy_get_ints_state(ddata, &s);
 226         if (error)
 227                 return;
 228
 229         vbus = cpcap_usb_vbus_valid(ddata);
 230
 231         /* We need to kick the VBUS as USB A-host */
 232         if (s.id_ground && ddata->vbus_provider) {
 233                 dev_dbg(ddata->dev, "still in USB A-host mode, kicking VBUS\n");
 234
 235                 cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
 236
 237                 error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
 238                                            CPCAP_BIT_VBUSSTBY_EN |
 239                                            CPCAP_BIT_VBUSEN_SPI,
 240                                            CPCAP_BIT_VBUSEN_SPI);
 241                 if (error)
 242                         goto out_err;
 243
 244                 return;
 245         }
 246
 247         if (vbus && s.id_ground && ddata->docked) {
 248                 dev_dbg(ddata->dev, "still docked as A-host, signal ID down\n");
 249
 250                 cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
 251
 252                 return;
 253         }
 254
 255         /* No VBUS needed with docks */
 256         if (vbus && s.id_ground && !ddata->vbus_provider) {
 257                 dev_dbg(ddata->dev, "connected to a dock\n");
 258
 259                 ddata->docked = true;
 260
 261                 error = cpcap_usb_set_usb_mode(ddata);
 262                 if (error)
 263                         goto out_err;
 264
 265                 cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
 266
 267                 /*
 268                  * Force check state again after musb has reoriented,
 269                  * otherwise devices won't enumerate after loading PHY
 270                  * driver.
 271                  */
 272                 schedule_delayed_work(&ddata->detect_work,
 273                                       msecs_to_jiffies(1000));
 274
 275                 return;
 276         }
 277
 278         if (s.id_ground && !ddata->docked) {
 279                 dev_dbg(ddata->dev, "id ground, USB host mode\n");
 280
 281                 ddata->vbus_provider = true;
 282
 283                 error = cpcap_usb_set_usb_mode(ddata);
 284                 if (error)
 285                         goto out_err;
 286
 287                 cpcap_usb_try_musb_mailbox(ddata, MUSB_ID_GROUND);
 288
 289                 error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
 290                                            CPCAP_BIT_VBUSSTBY_EN |
 291                                            CPCAP_BIT_VBUSEN_SPI,
 292                                            CPCAP_BIT_VBUSEN_SPI);
 293                 if (error)
 294                         goto out_err;
 295
 296                 return;
 297         }
 298
 299         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
 300                                    CPCAP_BIT_VBUSSTBY_EN |
 301                                    CPCAP_BIT_VBUSEN_SPI, 0);
 302         if (error)
 303                 goto out_err;
 304
 305         vbus = cpcap_usb_vbus_valid(ddata);
 306
 307         /* Otherwise assume we're connected to a USB host */
 308         if (vbus) {
 309                 dev_dbg(ddata->dev, "connected to USB host\n");
 310                 error = cpcap_usb_set_usb_mode(ddata);
 311                 if (error)
 312                         goto out_err;
 313                 cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_VALID);
 314
 315                 return;
 316         }
 317
 318         ddata->vbus_provider = false;
 319         ddata->docked = false;
 320         cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_OFF);
 321
 322         /* Default to debug UART mode */
 323         error = cpcap_usb_set_uart_mode(ddata);
 324         if (error)
 325                 goto out_err;
 326
 327         dev_dbg(ddata->dev, "set UART mode\n");
 328
 329         return;
 330
 331 out_err:
 332         dev_err(ddata->dev, "error setting cable state: %i\n", error);
 333 }
 334
 335 static irqreturn_t cpcap_phy_irq_thread(int irq, void *data)
 336 {
 337         struct cpcap_phy_ddata *ddata = data;
 338
 339         if (!atomic_read(&ddata->active))
 340                 return IRQ_NONE;
 341
 342         schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));
 343
 344         return IRQ_HANDLED;
 345 }
 346
 347 static int cpcap_usb_init_irq(struct platform_device *pdev,
 348                               struct cpcap_phy_ddata *ddata,
 349                               const char *name)
 350 {
 351         int irq, error;
 352
 353         irq = platform_get_irq_byname(pdev, name);
 354         if (irq < 0)
 355                 return -ENODEV;
 356
 357         error = devm_request_threaded_irq(ddata->dev, irq, NULL,
 358                                           cpcap_phy_irq_thread,
 359                                           IRQF_SHARED |
 360                                           IRQF_ONESHOT,
 361                                           name, ddata);
 362         if (error) {
 363                 dev_err(ddata->dev, "could not get irq %s: %i\n",
 364                         name, error);
 365
 366                 return error;
 367         }
 368
 369         return 0;
 370 }
 371
 372 static const char * const cpcap_phy_irqs[] = {
 373         /* REG_INT_0 */
 374         "id_ground", "id_float",
 375
 376         /* REG_INT1 */
 377         "se0conn", "vbusvld", "sessvld", "sessend", "se1",
 378
 379         /* REG_INT_3 */
 380         "dm", "dp",
 381 };
 382
 383 static int cpcap_usb_init_interrupts(struct platform_device *pdev,
 384                                      struct cpcap_phy_ddata *ddata)
 385 {
 386         int i, error;
 387
 388         for (i = 0; i < ARRAY_SIZE(cpcap_phy_irqs); i++) {
 389                 error = cpcap_usb_init_irq(pdev, ddata, cpcap_phy_irqs[i]);
 390                 if (error)
 391                         return error;
 392         }
 393
 394         return 0;
 395 }
 396
 397 /*
 398  * Optional pins and modes. At least Motorola mapphone devices
 399  * are using two GPIOs and dynamic pinctrl to multiplex PHY pins
 400  * to UART, ULPI or UTMI mode.
 401  */
 402
 403 static int cpcap_usb_gpio_set_mode(struct cpcap_phy_ddata *ddata,
 404                                    enum cpcap_gpio_mode mode)
 405 {
 406         if (!ddata->gpio[0] || !ddata->gpio[1])
 407                 return 0;
 408
 409         gpiod_set_value(ddata->gpio[0], mode & 1);
 410         gpiod_set_value(ddata->gpio[1], mode >> 1);
 411
 412         return 0;
 413 }
 414
 415 static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata)
 416 {
 417         int error;
 418
 419         /* Disable lines to prevent glitches from waking up mdm6600 */
 420         error = cpcap_usb_gpio_set_mode(ddata, CPCAP_UNKNOWN_DISABLED);
 421         if (error)
 422                 goto out_err;
 423
 424         if (ddata->pins_uart) {
 425                 error = pinctrl_select_state(ddata->pins, ddata->pins_uart);
 426                 if (error)
 427                         goto out_err;
 428         }
 429
 430         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
 431                                    CPCAP_BIT_VBUSPD,
 432                                    CPCAP_BIT_VBUSPD);
 433         if (error)
 434                 goto out_err;
 435
 436         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
 437                                    0xffff, CPCAP_BIT_UARTMUX0 |
 438                                    CPCAP_BIT_EMUMODE0);
 439         if (error)
 440                 goto out_err;
 441
 442         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3, 0x7fff,
 443                                    CPCAP_BIT_IDPU_SPI);
 444         if (error)
 445                 goto out_err;
 446
 447         /* Enable UART mode */
 448         error = cpcap_usb_gpio_set_mode(ddata, CPCAP_DM_DP);
 449         if (error)
 450                 goto out_err;
 451
 452         return 0;
 453
 454 out_err:
 455         dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
 456
 457         return error;
 458 }
 459
 460 static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata)
 461 {
 462         int error;
 463
 464         /* Disable lines to prevent glitches from waking up mdm6600 */
 465         error = cpcap_usb_gpio_set_mode(ddata, CPCAP_UNKNOWN_DISABLED);
 466         if (error)
 467                 return error;
 468
 469         if (ddata->pins_utmi) {
 470                 error = pinctrl_select_state(ddata->pins, ddata->pins_utmi);
 471                 if (error) {
 472                         dev_err(ddata->dev, "could not set usb mode: %i\n",
 473                                 error);
 474
 475                         return error;
 476                 }
 477         }
 478
 479         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
 480                                    CPCAP_BIT_VBUSPD, 0);
 481         if (error)
 482                 goto out_err;
 483
 484         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
 485                                    CPCAP_BIT_PU_SPI |
 486                                    CPCAP_BIT_DMPD_SPI |
 487                                    CPCAP_BIT_DPPD_SPI |
 488                                    CPCAP_BIT_SUSPEND_SPI |
 489                                    CPCAP_BIT_ULPI_SPI_SEL, 0);
 490         if (error)
 491                 goto out_err;
 492
 493         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
 494                                    CPCAP_BIT_USBXCVREN,
 495                                    CPCAP_BIT_USBXCVREN);
 496         if (error)
 497                 goto out_err;
 498
 499         /* Enable USB mode */
 500         error = cpcap_usb_gpio_set_mode(ddata, CPCAP_OTG_DM_DP);
 501         if (error)
 502                 goto out_err;
 503
 504         return 0;
 505
 506 out_err:
 507         dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
 508
 509         return error;
 510 }
 511
 512 static int cpcap_usb_init_optional_pins(struct cpcap_phy_ddata *ddata)
 513 {
 514         ddata->pins = devm_pinctrl_get(ddata->dev);
 515         if (IS_ERR(ddata->pins)) {
 516                 dev_info(ddata->dev, "default pins not configured: %ld\n",
 517                          PTR_ERR(ddata->pins));
 518                 ddata->pins = NULL;
 519
 520                 return 0;
 521         }
 522
 523         ddata->pins_ulpi = pinctrl_lookup_state(ddata->pins, "ulpi");
 524         if (IS_ERR(ddata->pins_ulpi)) {
 525                 dev_info(ddata->dev, "ulpi pins not configured\n");
 526                 ddata->pins_ulpi = NULL;
 527         }
 528
 529         ddata->pins_utmi = pinctrl_lookup_state(ddata->pins, "utmi");
 530         if (IS_ERR(ddata->pins_utmi)) {
 531                 dev_info(ddata->dev, "utmi pins not configured\n");
 532                 ddata->pins_utmi = NULL;
 533         }
 534
 535         ddata->pins_uart = pinctrl_lookup_state(ddata->pins, "uart");
 536         if (IS_ERR(ddata->pins_uart)) {
 537                 dev_info(ddata->dev, "uart pins not configured\n");
 538                 ddata->pins_uart = NULL;
 539         }
 540
 541         if (ddata->pins_uart)
 542                 return pinctrl_select_state(ddata->pins, ddata->pins_uart);
 543
 544         return 0;
 545 }
 546
 547 static void cpcap_usb_init_optional_gpios(struct cpcap_phy_ddata *ddata)
 548 {
 549         int i;
 550
 551         for (i = 0; i < 2; i++) {
 552                 ddata->gpio[i] = devm_gpiod_get_index(ddata->dev, "mode",
 553                                                       i, GPIOD_OUT_HIGH);
 554                 if (IS_ERR(ddata->gpio[i])) {
 555                         dev_info(ddata->dev, "no mode change GPIO%i: %li\n",
 556                                  i, PTR_ERR(ddata->gpio[i]));
 557                         ddata->gpio[i] = NULL;
 558                 }
 559         }
 560 }
 561
 562 static int cpcap_usb_init_iio(struct cpcap_phy_ddata *ddata)
 563 {
 564         enum iio_chan_type type;
 565         int error;
 566
 567         ddata->vbus = devm_iio_channel_get(ddata->dev, "vbus");
 568         if (IS_ERR(ddata->vbus)) {
 569                 error = PTR_ERR(ddata->vbus);
 570                 goto out_err;
 571         }
 572
 573         if (!ddata->vbus->indio_dev) {
 574                 error = -ENXIO;
 575                 goto out_err;
 576         }
 577
 578         error = iio_get_channel_type(ddata->vbus, &type);
 579         if (error < 0)
 580                 goto out_err;
 581
 582         if (type != IIO_VOLTAGE) {
 583                 error = -EINVAL;
 584                 goto out_err;
 585         }
 586
 587         return 0;
 588
 589 out_err:
 590         dev_err(ddata->dev, "could not initialize VBUS or ID IIO: %i\n",
 591                 error);
 592
 593         return error;
 594 }
 595
 596 #ifdef CONFIG_OF
 597 static const struct of_device_id cpcap_usb_phy_id_table[] = {
 598         {
 599                 .compatible = "motorola,cpcap-usb-phy",
 600         },
 601         {
 602                 .compatible = "motorola,mapphone-cpcap-usb-phy",
 603         },
 604         {},
 605 };
 606 MODULE_DEVICE_TABLE(of, cpcap_usb_phy_id_table);
 607 #endif
 608
 609 static int cpcap_usb_phy_probe(struct platform_device *pdev)
 610 {
 611         struct cpcap_phy_ddata *ddata;
 612         struct phy *generic_phy;
 613         struct phy_provider *phy_provider;
 614         struct usb_otg *otg;
 615         const struct of_device_id *of_id;
 616         int error;
 617
 618         of_id = of_match_device(of_match_ptr(cpcap_usb_phy_id_table),
 619                                 &pdev->dev);
 620         if (!of_id)
 621                 return -EINVAL;
 622
 623         ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
 624         if (!ddata)
 625                 return -ENOMEM;
 626
 627         ddata->reg = dev_get_regmap(pdev->dev.parent, NULL);
 628         if (!ddata->reg)
 629                 return -ENODEV;
 630
 631         otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
 632         if (!otg)
 633                 return -ENOMEM;
 634
 635         ddata->dev = &pdev->dev;
 636         ddata->phy.dev = ddata->dev;
 637         ddata->phy.label = "cpcap_usb_phy";
 638         ddata->phy.otg = otg;
 639         ddata->phy.type = USB_PHY_TYPE_USB2;
 640         otg->set_host = cpcap_usb_phy_set_host;
 641         otg->set_peripheral = cpcap_usb_phy_set_peripheral;
 642         otg->usb_phy = &ddata->phy;
 643         INIT_DELAYED_WORK(&ddata->detect_work, cpcap_usb_detect);
 644         platform_set_drvdata(pdev, ddata);
 645
 646         ddata->vusb = devm_regulator_get(&pdev->dev, "vusb");
 647         if (IS_ERR(ddata->vusb))
 648                 return PTR_ERR(ddata->vusb);
 649
 650         error = regulator_enable(ddata->vusb);
 651         if (error)
 652                 return error;
 653
 654         generic_phy = devm_phy_create(ddata->dev, NULL, &ops);
 655         if (IS_ERR(generic_phy)) {
 656                 error = PTR_ERR(generic_phy);
 657                 goto out_reg_disable;
 658         }
 659
 660         phy_set_drvdata(generic_phy, ddata);
 661
 662         phy_provider = devm_of_phy_provider_register(ddata->dev,
 663                                                      of_phy_simple_xlate);
 664         if (IS_ERR(phy_provider)) {
 665                 error = PTR_ERR(phy_provider);
 666                 goto out_reg_disable;
 667         }
 668
 669         error = cpcap_usb_init_optional_pins(ddata);
 670         if (error)
 671                 goto out_reg_disable;
 672
 673         cpcap_usb_init_optional_gpios(ddata);
 674
 675         error = cpcap_usb_init_iio(ddata);
 676         if (error)
 677                 goto out_reg_disable;
 678
 679         error = cpcap_usb_init_interrupts(pdev, ddata);
 680         if (error)
 681                 goto out_reg_disable;
 682
 683         usb_add_phy_dev(&ddata->phy);
 684         atomic_set(&ddata->active, 1);
 685         schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));
 686
 687         return 0;
 688
 689 out_reg_disable:
 690         regulator_disable(ddata->vusb);
 691
 692         return error;
 693 }
 694
 695 static void cpcap_usb_phy_remove(struct platform_device *pdev)
 696 {
 697         struct cpcap_phy_ddata *ddata = platform_get_drvdata(pdev);
 698         int error;
 699
 700         atomic_set(&ddata->active, 0);
 701         error = cpcap_usb_set_uart_mode(ddata);
 702         if (error)
 703                 dev_err(ddata->dev, "could not set UART mode\n");
 704
 705         cpcap_usb_try_musb_mailbox(ddata, MUSB_VBUS_OFF);
 706
 707         usb_remove_phy(&ddata->phy);
 708         cancel_delayed_work_sync(&ddata->detect_work);
 709         regulator_disable(ddata->vusb);
 710 }
 711
 712 static struct platform_driver cpcap_usb_phy_driver = {
 713         .probe          = cpcap_usb_phy_probe,
 714         .remove_new     = cpcap_usb_phy_remove,
 715         .driver         = {
 716                 .name   = "cpcap-usb-phy",
 717                 .of_match_table = of_match_ptr(cpcap_usb_phy_id_table),
 718         },
 719 };
 720
 721 module_platform_driver(cpcap_usb_phy_driver);
 722
 723 MODULE_ALIAS("platform:cpcap_usb");
 724 MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
 725 MODULE_DESCRIPTION("CPCAP usb phy driver");
 726 MODULE_LICENSE("GPL v2");