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,
 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 };
 138
 139 static bool cpcap_usb_vbus_valid(struct cpcap_phy_ddata *ddata)
 140 {
 141         int error, value = 0;
 142
 143         error = iio_read_channel_processed(ddata->vbus, &value);
 144         if (error >= 0)
 145                 return value > 3900 ? true : false;
 146
 147         dev_err(ddata->dev, "error reading VBUS: %i\n", error);
 148
 149         return false;
 150 }
 151
 152 static int cpcap_usb_phy_set_host(struct usb_otg *otg, struct usb_bus *host)
 153 {
 154         otg->host = host;
 155         if (!host)
 156                 otg->state = OTG_STATE_UNDEFINED;
 157
 158         return 0;
 159 }
 160
 161 static int cpcap_usb_phy_set_peripheral(struct usb_otg *otg,
 162                                         struct usb_gadget *gadget)
 163 {
 164         otg->gadget = gadget;
 165         if (!gadget)
 166                 otg->state = OTG_STATE_UNDEFINED;
 167
 168         return 0;
 169 }
 170
 171 static const struct phy_ops ops = {
 172         .owner          = THIS_MODULE,
 173 };
 174
 175 static int cpcap_phy_get_ints_state(struct cpcap_phy_ddata *ddata,
 176                                     struct cpcap_usb_ints_state *s)
 177 {
 178         int val, error;
 179
 180         error = regmap_read(ddata->reg, CPCAP_REG_INTS1, &val);
 181         if (error)
 182                 return error;
 183
 184         s->id_ground = val & BIT(15);
 185         s->id_float = val & BIT(14);
 186         s->vbusov = val & BIT(11);
 187
 188         error = regmap_read(ddata->reg, CPCAP_REG_INTS2, &val);
 189         if (error)
 190                 return error;
 191
 192         s->vbusvld = val & BIT(3);
 193         s->sessvld = val & BIT(2);
 194         s->sessend = val & BIT(1);
 195         s->se1 = val & BIT(0);
 196
 197         error = regmap_read(ddata->reg, CPCAP_REG_INTS4, &val);
 198         if (error)
 199                 return error;
 200
 201         s->dm = val & BIT(1);
 202         s->dp = val & BIT(0);
 203
 204         return 0;
 205 }
 206
 207 static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata);
 208 static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata);
 209
 210 static void cpcap_usb_detect(struct work_struct *work)
 211 {
 212         struct cpcap_phy_ddata *ddata;
 213         struct cpcap_usb_ints_state s;
 214         bool vbus = false;
 215         int error;
 216
 217         ddata = container_of(work, struct cpcap_phy_ddata, detect_work.work);
 218
 219         error = cpcap_phy_get_ints_state(ddata, &s);
 220         if (error)
 221                 return;
 222
 223         if (s.id_ground) {
 224                 dev_dbg(ddata->dev, "id ground, USB host mode\n");
 225                 error = cpcap_usb_set_usb_mode(ddata);
 226                 if (error)
 227                         goto out_err;
 228
 229                 error = musb_mailbox(MUSB_ID_GROUND);
 230                 if (error)
 231                         goto out_err;
 232
 233                 error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
 234                                            CPCAP_BIT_VBUSSTBY_EN,
 235                                            CPCAP_BIT_VBUSSTBY_EN);
 236                 if (error)
 237                         goto out_err;
 238
 239                 return;
 240         }
 241
 242         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
 243                                    CPCAP_BIT_VBUSSTBY_EN, 0);
 244         if (error)
 245                 goto out_err;
 246
 247         vbus = cpcap_usb_vbus_valid(ddata);
 248
 249         if (vbus) {
 250                 /* Are we connected to a docking station with vbus? */
 251                 if (s.id_ground) {
 252                         dev_dbg(ddata->dev, "connected to a dock\n");
 253
 254                         /* No VBUS needed with docks */
 255                         error = cpcap_usb_set_usb_mode(ddata);
 256                         if (error)
 257                                 goto out_err;
 258                         error = musb_mailbox(MUSB_ID_GROUND);
 259                         if (error)
 260                                 goto out_err;
 261
 262                         return;
 263                 }
 264
 265                 /* Otherwise assume we're connected to a USB host */
 266                 dev_dbg(ddata->dev, "connected to USB host\n");
 267                 error = cpcap_usb_set_usb_mode(ddata);
 268                 if (error)
 269                         goto out_err;
 270                 error = musb_mailbox(MUSB_VBUS_VALID);
 271                 if (error)
 272                         goto out_err;
 273
 274                 return;
 275         }
 276
 277         /* Default to debug UART mode */
 278         error = cpcap_usb_set_uart_mode(ddata);
 279         if (error)
 280                 goto out_err;
 281
 282         error = musb_mailbox(MUSB_VBUS_OFF);
 283         if (error)
 284                 goto out_err;
 285
 286         dev_dbg(ddata->dev, "set UART mode\n");
 287
 288         return;
 289
 290 out_err:
 291         dev_err(ddata->dev, "error setting cable state: %i\n", error);
 292 }
 293
 294 static irqreturn_t cpcap_phy_irq_thread(int irq, void *data)
 295 {
 296         struct cpcap_phy_ddata *ddata = data;
 297
 298         if (!atomic_read(&ddata->active))
 299                 return IRQ_NONE;
 300
 301         schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));
 302
 303         return IRQ_HANDLED;
 304 }
 305
 306 static int cpcap_usb_init_irq(struct platform_device *pdev,
 307                               struct cpcap_phy_ddata *ddata,
 308                               const char *name)
 309 {
 310         int irq, error;
 311
 312         irq = platform_get_irq_byname(pdev, name);
 313         if (!irq)
 314                 return -ENODEV;
 315
 316         error = devm_request_threaded_irq(ddata->dev, irq, NULL,
 317                                           cpcap_phy_irq_thread,
 318                                           IRQF_SHARED,
 319                                           name, ddata);
 320         if (error) {
 321                 dev_err(ddata->dev, "could not get irq %s: %i\n",
 322                         name, error);
 323
 324                 return error;
 325         }
 326
 327         return 0;
 328 }
 329
 330 static const char * const cpcap_phy_irqs[] = {
 331         /* REG_INT_0 */
 332         "id_ground", "id_float",
 333
 334         /* REG_INT1 */
 335         "se0conn", "vbusvld", "sessvld", "sessend", "se1",
 336
 337         /* REG_INT_3 */
 338         "dm", "dp",
 339 };
 340
 341 static int cpcap_usb_init_interrupts(struct platform_device *pdev,
 342                                      struct cpcap_phy_ddata *ddata)
 343 {
 344         int i, error;
 345
 346         for (i = 0; i < ARRAY_SIZE(cpcap_phy_irqs); i++) {
 347                 error = cpcap_usb_init_irq(pdev, ddata, cpcap_phy_irqs[i]);
 348                 if (error)
 349                         return error;
 350         }
 351
 352         return 0;
 353 }
 354
 355 /*
 356  * Optional pins and modes. At least Motorola mapphone devices
 357  * are using two GPIOs and dynamic pinctrl to multiplex PHY pins
 358  * to UART, ULPI or UTMI mode.
 359  */
 360
 361 static int cpcap_usb_gpio_set_mode(struct cpcap_phy_ddata *ddata,
 362                                    enum cpcap_gpio_mode mode)
 363 {
 364         if (!ddata->gpio[0] || !ddata->gpio[1])
 365                 return 0;
 366
 367         gpiod_set_value(ddata->gpio[0], mode & 1);
 368         gpiod_set_value(ddata->gpio[1], mode >> 1);
 369
 370         return 0;
 371 }
 372
 373 static int cpcap_usb_set_uart_mode(struct cpcap_phy_ddata *ddata)
 374 {
 375         int error;
 376
 377         error = cpcap_usb_gpio_set_mode(ddata, CPCAP_DM_DP);
 378         if (error)
 379                 goto out_err;
 380
 381         if (ddata->pins_uart) {
 382                 error = pinctrl_select_state(ddata->pins, ddata->pins_uart);
 383                 if (error)
 384                         goto out_err;
 385         }
 386
 387         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
 388                                    CPCAP_BIT_VBUSPD,
 389                                    CPCAP_BIT_VBUSPD);
 390         if (error)
 391                 goto out_err;
 392
 393         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
 394                                    0xffff, CPCAP_BIT_UARTMUX0 |
 395                                    CPCAP_BIT_EMUMODE0);
 396         if (error)
 397                 goto out_err;
 398
 399         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3, 0x7fff,
 400                                    CPCAP_BIT_IDPU_SPI);
 401         if (error)
 402                 goto out_err;
 403
 404         return 0;
 405
 406 out_err:
 407         dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
 408
 409         return error;
 410 }
 411
 412 static int cpcap_usb_set_usb_mode(struct cpcap_phy_ddata *ddata)
 413 {
 414         int error;
 415
 416         error = cpcap_usb_gpio_set_mode(ddata, CPCAP_OTG_DM_DP);
 417         if (error)
 418                 return error;
 419
 420         if (ddata->pins_utmi) {
 421                 error = pinctrl_select_state(ddata->pins, ddata->pins_utmi);
 422                 if (error) {
 423                         dev_err(ddata->dev, "could not set usb mode: %i\n",
 424                                 error);
 425
 426                         return error;
 427                 }
 428         }
 429
 430         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC1,
 431                                    CPCAP_BIT_VBUSPD, 0);
 432         if (error)
 433                 goto out_err;
 434
 435         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
 436                                    CPCAP_BIT_USBXCVREN,
 437                                    CPCAP_BIT_USBXCVREN);
 438         if (error)
 439                 goto out_err;
 440
 441         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC3,
 442                                    CPCAP_BIT_PU_SPI |
 443                                    CPCAP_BIT_DMPD_SPI |
 444                                    CPCAP_BIT_DPPD_SPI |
 445                                    CPCAP_BIT_SUSPEND_SPI |
 446                                    CPCAP_BIT_ULPI_SPI_SEL, 0);
 447         if (error)
 448                 goto out_err;
 449
 450         error = regmap_update_bits(ddata->reg, CPCAP_REG_USBC2,
 451                                    CPCAP_BIT_USBXCVREN,
 452                                    CPCAP_BIT_USBXCVREN);
 453         if (error)
 454                 goto out_err;
 455
 456         return 0;
 457
 458 out_err:
 459         dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
 460
 461         return error;
 462 }
 463
 464 static int cpcap_usb_init_optional_pins(struct cpcap_phy_ddata *ddata)
 465 {
 466         ddata->pins = devm_pinctrl_get(ddata->dev);
 467         if (IS_ERR(ddata->pins)) {
 468                 dev_info(ddata->dev, "default pins not configured: %ld\n",
 469                          PTR_ERR(ddata->pins));
 470                 ddata->pins = NULL;
 471
 472                 return 0;
 473         }
 474
 475         ddata->pins_ulpi = pinctrl_lookup_state(ddata->pins, "ulpi");
 476         if (IS_ERR(ddata->pins_ulpi)) {
 477                 dev_info(ddata->dev, "ulpi pins not configured\n");
 478                 ddata->pins_ulpi = NULL;
 479         }
 480
 481         ddata->pins_utmi = pinctrl_lookup_state(ddata->pins, "utmi");
 482         if (IS_ERR(ddata->pins_utmi)) {
 483                 dev_info(ddata->dev, "utmi pins not configured\n");
 484                 ddata->pins_utmi = NULL;
 485         }
 486
 487         ddata->pins_uart = pinctrl_lookup_state(ddata->pins, "uart");
 488         if (IS_ERR(ddata->pins_uart)) {
 489                 dev_info(ddata->dev, "uart pins not configured\n");
 490                 ddata->pins_uart = NULL;
 491         }
 492
 493         if (ddata->pins_uart)
 494                 return pinctrl_select_state(ddata->pins, ddata->pins_uart);
 495
 496         return 0;
 497 }
 498
 499 static void cpcap_usb_init_optional_gpios(struct cpcap_phy_ddata *ddata)
 500 {
 501         int i;
 502
 503         for (i = 0; i < 2; i++) {
 504                 ddata->gpio[i] = devm_gpiod_get_index(ddata->dev, "mode",
 505                                                       i, GPIOD_OUT_HIGH);
 506                 if (IS_ERR(ddata->gpio[i])) {
 507                         dev_info(ddata->dev, "no mode change GPIO%i: %li\n",
 508                                  i, PTR_ERR(ddata->gpio[i]));
 509                                  ddata->gpio[i] = NULL;
 510                 }
 511         }
 512 }
 513
 514 static int cpcap_usb_init_iio(struct cpcap_phy_ddata *ddata)
 515 {
 516         enum iio_chan_type type;
 517         int error;
 518
 519         ddata->vbus = devm_iio_channel_get(ddata->dev, "vbus");
 520         if (IS_ERR(ddata->vbus)) {
 521                 error = PTR_ERR(ddata->vbus);
 522                 goto out_err;
 523         }
 524
 525         if (!ddata->vbus->indio_dev) {
 526                 error = -ENXIO;
 527                 goto out_err;
 528         }
 529
 530         error = iio_get_channel_type(ddata->vbus, &type);
 531         if (error < 0)
 532                 goto out_err;
 533
 534         if (type != IIO_VOLTAGE) {
 535                 error = -EINVAL;
 536                 goto out_err;
 537         }
 538
 539         return 0;
 540
 541 out_err:
 542         dev_err(ddata->dev, "could not initialize VBUS or ID IIO: %i\n",
 543                 error);
 544
 545         return error;
 546 }
 547
 548 #ifdef CONFIG_OF
 549 static const struct of_device_id cpcap_usb_phy_id_table[] = {
 550         {
 551                 .compatible = "motorola,cpcap-usb-phy",
 552         },
 553         {
 554                 .compatible = "motorola,mapphone-cpcap-usb-phy",
 555         },
 556         {},
 557 };
 558 MODULE_DEVICE_TABLE(of, cpcap_usb_phy_id_table);
 559 #endif
 560
 561 static int cpcap_usb_phy_probe(struct platform_device *pdev)
 562 {
 563         struct cpcap_phy_ddata *ddata;
 564         struct phy *generic_phy;
 565         struct phy_provider *phy_provider;
 566         struct usb_otg *otg;
 567         const struct of_device_id *of_id;
 568         int error;
 569
 570         of_id = of_match_device(of_match_ptr(cpcap_usb_phy_id_table),
 571                                 &pdev->dev);
 572         if (!of_id)
 573                 return -EINVAL;
 574
 575         ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
 576         if (!ddata)
 577                 return -ENOMEM;
 578
 579         ddata->reg = dev_get_regmap(pdev->dev.parent, NULL);
 580         if (!ddata->reg)
 581                 return -ENODEV;
 582
 583         otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
 584         if (!otg)
 585                 return -ENOMEM;
 586
 587         ddata->dev = &pdev->dev;
 588         ddata->phy.dev = ddata->dev;
 589         ddata->phy.label = "cpcap_usb_phy";
 590         ddata->phy.otg = otg;
 591         ddata->phy.type = USB_PHY_TYPE_USB2;
 592         otg->set_host = cpcap_usb_phy_set_host;
 593         otg->set_peripheral = cpcap_usb_phy_set_peripheral;
 594         otg->usb_phy = &ddata->phy;
 595         INIT_DELAYED_WORK(&ddata->detect_work, cpcap_usb_detect);
 596         platform_set_drvdata(pdev, ddata);
 597
 598         ddata->vusb = devm_regulator_get(&pdev->dev, "vusb");
 599         if (IS_ERR(ddata->vusb))
 600                 return PTR_ERR(ddata->vusb);
 601
 602         error = regulator_enable(ddata->vusb);
 603         if (error)
 604                 return error;
 605
 606         generic_phy = devm_phy_create(ddata->dev, NULL, &ops);
 607         if (IS_ERR(generic_phy)) {
 608                 error = PTR_ERR(generic_phy);
 609                 return PTR_ERR(generic_phy);
 610         }
 611
 612         phy_set_drvdata(generic_phy, ddata);
 613
 614         phy_provider = devm_of_phy_provider_register(ddata->dev,
 615                                                      of_phy_simple_xlate);
 616         if (IS_ERR(phy_provider))
 617                 return PTR_ERR(phy_provider);
 618
 619         error = cpcap_usb_init_optional_pins(ddata);
 620         if (error)
 621                 return error;
 622
 623         cpcap_usb_init_optional_gpios(ddata);
 624
 625         error = cpcap_usb_init_iio(ddata);
 626         if (error)
 627                 return error;
 628
 629         error = cpcap_usb_init_interrupts(pdev, ddata);
 630         if (error)
 631                 return error;
 632
 633         usb_add_phy_dev(&ddata->phy);
 634         atomic_set(&ddata->active, 1);
 635         schedule_delayed_work(&ddata->detect_work, msecs_to_jiffies(1));
 636
 637         return 0;
 638 }
 639
 640 static int cpcap_usb_phy_remove(struct platform_device *pdev)
 641 {
 642         struct cpcap_phy_ddata *ddata = platform_get_drvdata(pdev);
 643         int error;
 644
 645         atomic_set(&ddata->active, 0);
 646         error = cpcap_usb_set_uart_mode(ddata);
 647         if (error)
 648                 dev_err(ddata->dev, "could not set UART mode\n");
 649
 650         error = musb_mailbox(MUSB_VBUS_OFF);
 651         if (error)
 652                 dev_err(ddata->dev, "could not set mailbox\n");
 653
 654         usb_remove_phy(&ddata->phy);
 655         cancel_delayed_work_sync(&ddata->detect_work);
 656         clk_unprepare(ddata->refclk);
 657         regulator_disable(ddata->vusb);
 658
 659         return 0;
 660 }
 661
 662 static struct platform_driver cpcap_usb_phy_driver = {
 663         .probe          = cpcap_usb_phy_probe,
 664         .remove         = cpcap_usb_phy_remove,
 665         .driver         = {
 666                 .name   = "cpcap-usb-phy",
 667                 .of_match_table = of_match_ptr(cpcap_usb_phy_id_table),
 668         },
 669 };
 670
 671 module_platform_driver(cpcap_usb_phy_driver);
 672
 673 MODULE_ALIAS("platform:cpcap_usb");
 674 MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
 675 MODULE_DESCRIPTION("CPCAP usb phy driver");
 676 MODULE_LICENSE("GPL v2");