1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Motorola Mapphone MDM6600 modem GPIO controlled USB PHY driver 4 * Copyright (C) 2018 Tony Lindgren <tony@atomide.com> 5 */ 6 7#include <linux/delay.h> 8#include <linux/err.h> 9#include <linux/io.h> 10#include <linux/interrupt.h> 11#include <linux/module.h> 12#include <linux/of.h> 13#include <linux/platform_device.h> 14#include <linux/slab.h> 15 16#include <linux/gpio/consumer.h> 17#include <linux/of_platform.h> 18#include <linux/phy/phy.h> 19#include <linux/pinctrl/consumer.h> 20 21#define PHY_MDM6600_PHY_DELAY_MS 4000 /* PHY enable 2.2s to 3.5s */ 22#define PHY_MDM6600_ENABLED_DELAY_MS 8000 /* 8s more total for MDM6600 */ 23#define PHY_MDM6600_WAKE_KICK_MS 600 /* time on after GPIO toggle */ 24#define MDM6600_MODEM_IDLE_DELAY_MS 1000 /* modem after USB suspend */ 25#define MDM6600_MODEM_WAKE_DELAY_MS 200 /* modem response after idle */ 26 27enum phy_mdm6600_ctrl_lines { 28 PHY_MDM6600_ENABLE, /* USB PHY enable */ 29 PHY_MDM6600_POWER, /* Device power */ 30 PHY_MDM6600_RESET, /* Device reset */ 31 PHY_MDM6600_NR_CTRL_LINES, 32}; 33 34enum phy_mdm6600_bootmode_lines { 35 PHY_MDM6600_MODE0, /* out USB mode0 and OOB wake */ 36 PHY_MDM6600_MODE1, /* out USB mode1, in OOB wake */ 37 PHY_MDM6600_NR_MODE_LINES, 38}; 39 40enum phy_mdm6600_cmd_lines { 41 PHY_MDM6600_CMD0, 42 PHY_MDM6600_CMD1, 43 PHY_MDM6600_CMD2, 44 PHY_MDM6600_NR_CMD_LINES, 45}; 46 47enum phy_mdm6600_status_lines { 48 PHY_MDM6600_STATUS0, 49 PHY_MDM6600_STATUS1, 50 PHY_MDM6600_STATUS2, 51 PHY_MDM6600_NR_STATUS_LINES, 52}; 53 54/* 55 * MDM6600 command codes. These are based on Motorola Mapphone Linux 56 * kernel tree. 57 */ 58enum phy_mdm6600_cmd { 59 PHY_MDM6600_CMD_BP_PANIC_ACK, 60 PHY_MDM6600_CMD_DATA_ONLY_BYPASS, /* Reroute USB to CPCAP PHY */ 61 PHY_MDM6600_CMD_FULL_BYPASS, /* Reroute USB to CPCAP PHY */ 62 PHY_MDM6600_CMD_NO_BYPASS, /* Request normal USB mode */ 63 PHY_MDM6600_CMD_BP_SHUTDOWN_REQ, /* Request device power off */ 64 PHY_MDM6600_CMD_BP_UNKNOWN_5, 65 PHY_MDM6600_CMD_BP_UNKNOWN_6, 66 PHY_MDM6600_CMD_UNDEFINED, 67}; 68 69/* 70 * MDM6600 status codes. These are based on Motorola Mapphone Linux 71 * kernel tree. 72 */ 73enum phy_mdm6600_status { 74 PHY_MDM6600_STATUS_PANIC, /* Seems to be really off */ 75 PHY_MDM6600_STATUS_PANIC_BUSY_WAIT, 76 PHY_MDM6600_STATUS_QC_DLOAD, 77 PHY_MDM6600_STATUS_RAM_DOWNLOADER, /* MDM6600 USB flashing mode */ 78 PHY_MDM6600_STATUS_PHONE_CODE_AWAKE, /* MDM6600 normal USB mode */ 79 PHY_MDM6600_STATUS_PHONE_CODE_ASLEEP, 80 PHY_MDM6600_STATUS_SHUTDOWN_ACK, 81 PHY_MDM6600_STATUS_UNDEFINED, 82}; 83 84static const char * const 85phy_mdm6600_status_name[] = { 86 "off", "busy", "qc_dl", "ram_dl", "awake", 87 "asleep", "shutdown", "undefined", 88}; 89 90struct phy_mdm6600 { 91 struct device *dev; 92 struct phy *generic_phy; 93 struct phy_provider *phy_provider; 94 struct gpio_desc *ctrl_gpios[PHY_MDM6600_NR_CTRL_LINES]; 95 struct gpio_descs *mode_gpios; 96 struct gpio_descs *status_gpios; 97 struct gpio_descs *cmd_gpios; 98 struct delayed_work bootup_work; 99 struct delayed_work status_work; 100 struct delayed_work modem_wake_work; 101 struct completion ack; 102 bool enabled; /* mdm6600 phy enabled */ 103 bool running; /* mdm6600 boot done */ 104 bool awake; /* mdm6600 respnds on n_gsm */ 105 int status; 106}; 107 108static int phy_mdm6600_init(struct phy *x) 109{ 110 struct phy_mdm6600 *ddata = phy_get_drvdata(x); 111 struct gpio_desc *enable_gpio = ddata->ctrl_gpios[PHY_MDM6600_ENABLE]; 112 113 if (!ddata->enabled) 114 return -EPROBE_DEFER; 115 116 gpiod_set_value_cansleep(enable_gpio, 0); 117 118 return 0; 119} 120 121static int phy_mdm6600_power_on(struct phy *x) 122{ 123 struct phy_mdm6600 *ddata = phy_get_drvdata(x); 124 struct gpio_desc *enable_gpio = ddata->ctrl_gpios[PHY_MDM6600_ENABLE]; 125 126 if (!ddata->enabled) 127 return -ENODEV; 128 129 gpiod_set_value_cansleep(enable_gpio, 1); 130 131 /* Allow aggressive PM for USB, it's only needed for n_gsm port */ 132 if (pm_runtime_enabled(&x->dev)) 133 phy_pm_runtime_put(x); 134 135 return 0; 136} 137 138static int phy_mdm6600_power_off(struct phy *x) 139{ 140 struct phy_mdm6600 *ddata = phy_get_drvdata(x); 141 struct gpio_desc *enable_gpio = ddata->ctrl_gpios[PHY_MDM6600_ENABLE]; 142 int error; 143 144 if (!ddata->enabled) 145 return -ENODEV; 146 147 /* Paired with phy_pm_runtime_put() in phy_mdm6600_power_on() */ 148 if (pm_runtime_enabled(&x->dev)) { 149 error = phy_pm_runtime_get(x); 150 if (error < 0 && error != -EINPROGRESS) 151 dev_warn(ddata->dev, "%s: phy_pm_runtime_get: %i\n", 152 __func__, error); 153 } 154 155 gpiod_set_value_cansleep(enable_gpio, 0); 156 157 return 0; 158} 159 160static const struct phy_ops gpio_usb_ops = { 161 .init = phy_mdm6600_init, 162 .power_on = phy_mdm6600_power_on, 163 .power_off = phy_mdm6600_power_off, 164 .owner = THIS_MODULE, 165}; 166 167/** 168 * phy_mdm6600_cmd() - send a command request to mdm6600 169 * @ddata: device driver data 170 * @val: value of cmd to be set 171 * 172 * Configures the three command request GPIOs to the specified value. 173 */ 174static void phy_mdm6600_cmd(struct phy_mdm6600 *ddata, int val) 175{ 176 DECLARE_BITMAP(values, PHY_MDM6600_NR_CMD_LINES); 177 178 values[0] = val; 179 180 gpiod_set_array_value_cansleep(PHY_MDM6600_NR_CMD_LINES, 181 ddata->cmd_gpios->desc, 182 ddata->cmd_gpios->info, values); 183} 184 185/** 186 * phy_mdm6600_status() - read mdm6600 status lines 187 * @work: work structure 188 */ 189static void phy_mdm6600_status(struct work_struct *work) 190{ 191 struct phy_mdm6600 *ddata; 192 struct device *dev; 193 DECLARE_BITMAP(values, PHY_MDM6600_NR_STATUS_LINES); 194 int error; 195 196 ddata = container_of(work, struct phy_mdm6600, status_work.work); 197 dev = ddata->dev; 198 199 error = gpiod_get_array_value_cansleep(PHY_MDM6600_NR_STATUS_LINES, 200 ddata->status_gpios->desc, 201 ddata->status_gpios->info, 202 values); 203 if (error) 204 return; 205 206 ddata->status = values[0] & ((1 << PHY_MDM6600_NR_STATUS_LINES) - 1); 207 208 dev_info(dev, "modem status: %i %s\n", 209 ddata->status, 210 phy_mdm6600_status_name[ddata->status]); 211 complete(&ddata->ack); 212} 213 214static irqreturn_t phy_mdm6600_irq_thread(int irq, void *data) 215{ 216 struct phy_mdm6600 *ddata = data; 217 218 schedule_delayed_work(&ddata->status_work, msecs_to_jiffies(10)); 219 220 return IRQ_HANDLED; 221} 222 223/** 224 * phy_mdm6600_wakeirq_thread - handle mode1 line OOB wake after booting 225 * @irq: interrupt 226 * @data: interrupt handler data 227 * 228 * GPIO mode1 is used initially as output to configure the USB boot 229 * mode for mdm6600. After booting it is used as input for OOB wake 230 * signal from mdm6600 to the SoC. Just use it for debug info only 231 * for now. 232 */ 233static irqreturn_t phy_mdm6600_wakeirq_thread(int irq, void *data) 234{ 235 struct phy_mdm6600 *ddata = data; 236 struct gpio_desc *mode_gpio1; 237 int error, wakeup; 238 239 mode_gpio1 = ddata->mode_gpios->desc[PHY_MDM6600_MODE1]; 240 wakeup = gpiod_get_value(mode_gpio1); 241 if (!wakeup) 242 return IRQ_NONE; 243 244 dev_dbg(ddata->dev, "OOB wake on mode_gpio1: %i\n", wakeup); 245 error = pm_runtime_get_sync(ddata->dev); 246 if (error < 0) { 247 pm_runtime_put_noidle(ddata->dev); 248 249 return IRQ_NONE; 250 } 251 252 /* Just wake-up and kick the autosuspend timer */ 253 pm_runtime_mark_last_busy(ddata->dev); 254 pm_runtime_put_autosuspend(ddata->dev); 255 256 return IRQ_HANDLED; 257} 258 259/** 260 * phy_mdm6600_init_irq() - initialize mdm6600 status IRQ lines 261 * @ddata: device driver data 262 */ 263static void phy_mdm6600_init_irq(struct phy_mdm6600 *ddata) 264{ 265 struct device *dev = ddata->dev; 266 int i, error, irq; 267 268 for (i = PHY_MDM6600_STATUS0; 269 i <= PHY_MDM6600_STATUS2; i++) { 270 struct gpio_desc *gpio = ddata->status_gpios->desc[i]; 271 272 irq = gpiod_to_irq(gpio); 273 if (irq <= 0) 274 continue; 275 276 error = devm_request_threaded_irq(dev, irq, NULL, 277 phy_mdm6600_irq_thread, 278 IRQF_TRIGGER_RISING | 279 IRQF_TRIGGER_FALLING | 280 IRQF_ONESHOT, 281 "mdm6600", 282 ddata); 283 if (error) 284 dev_warn(dev, "no modem status irq%i: %i\n", 285 irq, error); 286 } 287} 288 289struct phy_mdm6600_map { 290 const char *name; 291 int direction; 292}; 293 294static const struct phy_mdm6600_map 295phy_mdm6600_ctrl_gpio_map[PHY_MDM6600_NR_CTRL_LINES] = { 296 { "enable", GPIOD_OUT_LOW, }, /* low = phy disabled */ 297 { "power", GPIOD_OUT_LOW, }, /* low = off */ 298 { "reset", GPIOD_OUT_HIGH, }, /* high = reset */ 299}; 300 301/** 302 * phy_mdm6600_init_lines() - initialize mdm6600 GPIO lines 303 * @ddata: device driver data 304 */ 305static int phy_mdm6600_init_lines(struct phy_mdm6600 *ddata) 306{ 307 struct device *dev = ddata->dev; 308 int i; 309 310 /* MDM6600 control lines */ 311 for (i = 0; i < ARRAY_SIZE(phy_mdm6600_ctrl_gpio_map); i++) { 312 const struct phy_mdm6600_map *map = 313 &phy_mdm6600_ctrl_gpio_map[i]; 314 struct gpio_desc **gpio = &ddata->ctrl_gpios[i]; 315 316 *gpio = devm_gpiod_get(dev, map->name, map->direction); 317 if (IS_ERR(*gpio)) { 318 dev_info(dev, "gpio %s error %li\n", 319 map->name, PTR_ERR(*gpio)); 320 return PTR_ERR(*gpio); 321 } 322 } 323 324 /* MDM6600 USB start-up mode output lines */ 325 ddata->mode_gpios = devm_gpiod_get_array(dev, "motorola,mode", 326 GPIOD_OUT_LOW); 327 if (IS_ERR(ddata->mode_gpios)) 328 return PTR_ERR(ddata->mode_gpios); 329 330 if (ddata->mode_gpios->ndescs != PHY_MDM6600_NR_MODE_LINES) 331 return -EINVAL; 332 333 /* MDM6600 status input lines */ 334 ddata->status_gpios = devm_gpiod_get_array(dev, "motorola,status", 335 GPIOD_IN); 336 if (IS_ERR(ddata->status_gpios)) 337 return PTR_ERR(ddata->status_gpios); 338 339 if (ddata->status_gpios->ndescs != PHY_MDM6600_NR_STATUS_LINES) 340 return -EINVAL; 341 342 /* MDM6600 cmd output lines */ 343 ddata->cmd_gpios = devm_gpiod_get_array(dev, "motorola,cmd", 344 GPIOD_OUT_LOW); 345 if (IS_ERR(ddata->cmd_gpios)) 346 return PTR_ERR(ddata->cmd_gpios); 347 348 if (ddata->cmd_gpios->ndescs != PHY_MDM6600_NR_CMD_LINES) 349 return -EINVAL; 350 351 return 0; 352} 353 354/** 355 * phy_mdm6600_device_power_on() - power on mdm6600 device 356 * @ddata: device driver data 357 * 358 * To get the integrated USB phy in MDM6600 takes some hoops. We must ensure 359 * the shared USB bootmode GPIOs are configured, then request modem start-up, 360 * reset and power-up.. And then we need to recycle the shared USB bootmode 361 * GPIOs as they are also used for Out of Band (OOB) wake for the USB and 362 * TS 27.010 serial mux. 363 */ 364static int phy_mdm6600_device_power_on(struct phy_mdm6600 *ddata) 365{ 366 struct gpio_desc *mode_gpio0, *mode_gpio1, *reset_gpio, *power_gpio; 367 int error = 0, wakeirq; 368 369 mode_gpio0 = ddata->mode_gpios->desc[PHY_MDM6600_MODE0]; 370 mode_gpio1 = ddata->mode_gpios->desc[PHY_MDM6600_MODE1]; 371 reset_gpio = ddata->ctrl_gpios[PHY_MDM6600_RESET]; 372 power_gpio = ddata->ctrl_gpios[PHY_MDM6600_POWER]; 373 374 /* 375 * Shared GPIOs must be low for normal USB mode. After booting 376 * they are used for OOB wake signaling. These can be also used 377 * to configure USB flashing mode later on based on a module 378 * parameter. 379 */ 380 gpiod_set_value_cansleep(mode_gpio0, 0); 381 gpiod_set_value_cansleep(mode_gpio1, 0); 382 383 /* Request start-up mode */ 384 phy_mdm6600_cmd(ddata, PHY_MDM6600_CMD_NO_BYPASS); 385 386 /* Request a reset first */ 387 gpiod_set_value_cansleep(reset_gpio, 0); 388 msleep(100); 389 390 /* Toggle power GPIO to request mdm6600 to start */ 391 gpiod_set_value_cansleep(power_gpio, 1); 392 msleep(100); 393 gpiod_set_value_cansleep(power_gpio, 0); 394 395 /* 396 * Looks like the USB PHY needs between 2.2 to 4 seconds. 397 * If we try to use it before that, we will get L3 errors 398 * from omap-usb-host trying to access the PHY. See also 399 * phy_mdm6600_init() for -EPROBE_DEFER. 400 */ 401 msleep(PHY_MDM6600_PHY_DELAY_MS); 402 ddata->enabled = true; 403 404 /* Booting up the rest of MDM6600 will take total about 8 seconds */ 405 dev_info(ddata->dev, "Waiting for power up request to complete..\n"); 406 if (wait_for_completion_timeout(&ddata->ack, 407 msecs_to_jiffies(PHY_MDM6600_ENABLED_DELAY_MS))) { 408 if (ddata->status > PHY_MDM6600_STATUS_PANIC && 409 ddata->status < PHY_MDM6600_STATUS_SHUTDOWN_ACK) 410 dev_info(ddata->dev, "Powered up OK\n"); 411 } else { 412 ddata->enabled = false; 413 error = -ETIMEDOUT; 414 dev_err(ddata->dev, "Timed out powering up\n"); 415 } 416 417 /* Reconfigure mode1 GPIO as input for OOB wake */ 418 gpiod_direction_input(mode_gpio1); 419 420 wakeirq = gpiod_to_irq(mode_gpio1); 421 if (wakeirq <= 0) 422 return wakeirq; 423 424 error = devm_request_threaded_irq(ddata->dev, wakeirq, NULL, 425 phy_mdm6600_wakeirq_thread, 426 IRQF_TRIGGER_RISING | 427 IRQF_TRIGGER_FALLING | 428 IRQF_ONESHOT, 429 "mdm6600-wake", 430 ddata); 431 if (error) 432 dev_warn(ddata->dev, "no modem wakeirq irq%i: %i\n", 433 wakeirq, error); 434 435 ddata->running = true; 436 437 return error; 438} 439 440/** 441 * phy_mdm6600_device_power_off() - power off mdm6600 device 442 * @ddata: device driver data 443 */ 444static void phy_mdm6600_device_power_off(struct phy_mdm6600 *ddata) 445{ 446 struct gpio_desc *reset_gpio = 447 ddata->ctrl_gpios[PHY_MDM6600_RESET]; 448 int error; 449 450 ddata->enabled = false; 451 phy_mdm6600_cmd(ddata, PHY_MDM6600_CMD_BP_SHUTDOWN_REQ); 452 msleep(100); 453 454 gpiod_set_value_cansleep(reset_gpio, 1); 455 456 dev_info(ddata->dev, "Waiting for power down request to complete.. "); 457 if (wait_for_completion_timeout(&ddata->ack, 458 msecs_to_jiffies(5000))) { 459 if (ddata->status == PHY_MDM6600_STATUS_PANIC) 460 dev_info(ddata->dev, "Powered down OK\n"); 461 } else { 462 dev_err(ddata->dev, "Timed out powering down\n"); 463 } 464 465 /* 466 * Keep reset gpio high with padconf internal pull-up resistor to 467 * prevent modem from waking up during deeper SoC idle states. The 468 * gpio bank lines can have glitches if not in the always-on wkup 469 * domain. 470 */ 471 error = pinctrl_pm_select_sleep_state(ddata->dev); 472 if (error) 473 dev_warn(ddata->dev, "%s: error with sleep_state: %i\n", 474 __func__, error); 475} 476 477static void phy_mdm6600_deferred_power_on(struct work_struct *work) 478{ 479 struct phy_mdm6600 *ddata; 480 int error; 481 482 ddata = container_of(work, struct phy_mdm6600, bootup_work.work); 483 484 error = phy_mdm6600_device_power_on(ddata); 485 if (error) 486 dev_err(ddata->dev, "Device not functional\n"); 487} 488 489/* 490 * USB suspend puts mdm6600 into low power mode. For any n_gsm using apps, 491 * we need to keep the modem awake by kicking it's mode0 GPIO. This will 492 * keep the modem awake for about 1.2 seconds. When no n_gsm apps are using 493 * the modem, runtime PM auto mode can be enabled so modem can enter low 494 * power mode. 495 */ 496static void phy_mdm6600_wake_modem(struct phy_mdm6600 *ddata) 497{ 498 struct gpio_desc *mode_gpio0; 499 500 mode_gpio0 = ddata->mode_gpios->desc[PHY_MDM6600_MODE0]; 501 gpiod_set_value_cansleep(mode_gpio0, 1); 502 usleep_range(5, 15); 503 gpiod_set_value_cansleep(mode_gpio0, 0); 504 if (ddata->awake) 505 usleep_range(5, 15); 506 else 507 msleep(MDM6600_MODEM_WAKE_DELAY_MS); 508} 509 510static void phy_mdm6600_modem_wake(struct work_struct *work) 511{ 512 struct phy_mdm6600 *ddata; 513 514 ddata = container_of(work, struct phy_mdm6600, modem_wake_work.work); 515 phy_mdm6600_wake_modem(ddata); 516 517 /* 518 * The modem does not always stay awake 1.2 seconds after toggling 519 * the wake GPIO, and sometimes it idles after about some 600 ms 520 * making writes time out. 521 */ 522 schedule_delayed_work(&ddata->modem_wake_work, 523 msecs_to_jiffies(PHY_MDM6600_WAKE_KICK_MS)); 524} 525 526static int __maybe_unused phy_mdm6600_runtime_suspend(struct device *dev) 527{ 528 struct phy_mdm6600 *ddata = dev_get_drvdata(dev); 529 530 cancel_delayed_work_sync(&ddata->modem_wake_work); 531 ddata->awake = false; 532 533 return 0; 534} 535 536static int __maybe_unused phy_mdm6600_runtime_resume(struct device *dev) 537{ 538 struct phy_mdm6600 *ddata = dev_get_drvdata(dev); 539 540 phy_mdm6600_modem_wake(&ddata->modem_wake_work.work); 541 ddata->awake = true; 542 543 return 0; 544} 545 546static const struct dev_pm_ops phy_mdm6600_pm_ops = { 547 SET_RUNTIME_PM_OPS(phy_mdm6600_runtime_suspend, 548 phy_mdm6600_runtime_resume, NULL) 549}; 550 551static const struct of_device_id phy_mdm6600_id_table[] = { 552 { .compatible = "motorola,mapphone-mdm6600", }, 553 {}, 554}; 555MODULE_DEVICE_TABLE(of, phy_mdm6600_id_table); 556 557static int phy_mdm6600_probe(struct platform_device *pdev) 558{ 559 struct phy_mdm6600 *ddata; 560 int error; 561 562 ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); 563 if (!ddata) 564 return -ENOMEM; 565 566 INIT_DELAYED_WORK(&ddata->bootup_work, 567 phy_mdm6600_deferred_power_on); 568 INIT_DELAYED_WORK(&ddata->status_work, phy_mdm6600_status); 569 INIT_DELAYED_WORK(&ddata->modem_wake_work, phy_mdm6600_modem_wake); 570 init_completion(&ddata->ack); 571 572 ddata->dev = &pdev->dev; 573 platform_set_drvdata(pdev, ddata); 574 575 error = phy_mdm6600_init_lines(ddata); 576 if (error) 577 return error; 578 579 phy_mdm6600_init_irq(ddata); 580 schedule_delayed_work(&ddata->bootup_work, 0); 581 582 /* 583 * See phy_mdm6600_device_power_on(). We should be able 584 * to remove this eventually when ohci-platform can deal 585 * with -EPROBE_DEFER. 586 */ 587 msleep(PHY_MDM6600_PHY_DELAY_MS + 500); 588 589 /* 590 * Enable PM runtime only after PHY has been powered up properly. 591 * It is currently only needed after USB suspends mdm6600 and n_gsm 592 * needs to access the device. We don't want to do this earlier as 593 * gpio mode0 pin doubles as mdm6600 wake-up gpio. 594 */ 595 pm_runtime_use_autosuspend(ddata->dev); 596 pm_runtime_set_autosuspend_delay(ddata->dev, 597 MDM6600_MODEM_IDLE_DELAY_MS); 598 pm_runtime_enable(ddata->dev); 599 error = pm_runtime_get_sync(ddata->dev); 600 if (error < 0) { 601 dev_warn(ddata->dev, "failed to wake modem: %i\n", error); 602 pm_runtime_put_noidle(ddata->dev); 603 goto cleanup; 604 } 605 606 ddata->generic_phy = devm_phy_create(ddata->dev, NULL, &gpio_usb_ops); 607 if (IS_ERR(ddata->generic_phy)) { 608 error = PTR_ERR(ddata->generic_phy); 609 goto idle; 610 } 611 612 phy_set_drvdata(ddata->generic_phy, ddata); 613 614 ddata->phy_provider = 615 devm_of_phy_provider_register(ddata->dev, 616 of_phy_simple_xlate); 617 if (IS_ERR(ddata->phy_provider)) 618 error = PTR_ERR(ddata->phy_provider); 619 620idle: 621 pm_runtime_mark_last_busy(ddata->dev); 622 pm_runtime_put_autosuspend(ddata->dev); 623 624cleanup: 625 if (error < 0) { 626 phy_mdm6600_device_power_off(ddata); 627 pm_runtime_disable(ddata->dev); 628 pm_runtime_dont_use_autosuspend(ddata->dev); 629 } 630 631 return error; 632} 633 634static void phy_mdm6600_remove(struct platform_device *pdev) 635{ 636 struct phy_mdm6600 *ddata = platform_get_drvdata(pdev); 637 struct gpio_desc *reset_gpio = ddata->ctrl_gpios[PHY_MDM6600_RESET]; 638 639 pm_runtime_get_noresume(ddata->dev); 640 pm_runtime_dont_use_autosuspend(ddata->dev); 641 pm_runtime_put_sync(ddata->dev); 642 pm_runtime_disable(ddata->dev); 643 644 if (!ddata->running) 645 wait_for_completion_timeout(&ddata->ack, 646 msecs_to_jiffies(PHY_MDM6600_ENABLED_DELAY_MS)); 647 648 gpiod_set_value_cansleep(reset_gpio, 1); 649 phy_mdm6600_device_power_off(ddata); 650 651 cancel_delayed_work_sync(&ddata->modem_wake_work); 652 cancel_delayed_work_sync(&ddata->bootup_work); 653 cancel_delayed_work_sync(&ddata->status_work); 654} 655 656static struct platform_driver phy_mdm6600_driver = { 657 .probe = phy_mdm6600_probe, 658 .remove_new = phy_mdm6600_remove, 659 .driver = { 660 .name = "phy-mapphone-mdm6600", 661 .pm = &phy_mdm6600_pm_ops, 662 .of_match_table = of_match_ptr(phy_mdm6600_id_table), 663 }, 664}; 665 666module_platform_driver(phy_mdm6600_driver); 667 668MODULE_ALIAS("platform:gpio_usb"); 669MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>"); 670MODULE_DESCRIPTION("mdm6600 gpio usb phy driver"); 671MODULE_LICENSE("GPL v2"); 672