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