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

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