672 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Motorola Mapphone MDM6600 modem GPIO controlled USB PHY driver4 * 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 Linux56 * 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 Linux71 * 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 * const85phy_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 mdm6600169 * @ddata: device driver data170 * @val: value of cmd to be set171 *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 lines187 * @work: work structure188 */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 booting225 * @irq: interrupt226 * @data: interrupt handler data227 *228 * GPIO mode1 is used initially as output to configure the USB boot229 * mode for mdm6600. After booting it is used as input for OOB wake230 * signal from mdm6600 to the SoC. Just use it for debug info only231 * 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 lines261 * @ddata: device driver data262 */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_map295phy_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 lines303 * @ddata: device driver data304 */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 device356 * @ddata: device driver data357 *358 * To get the integrated USB phy in MDM6600 takes some hoops. We must ensure359 * 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 bootmode361 * GPIOs as they are also used for Out of Band (OOB) wake for the USB and362 * 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 booting376 * they are used for OOB wake signaling. These can be also used377 * to configure USB flashing mode later on based on a module378 * 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 errors398 * from omap-usb-host trying to access the PHY. See also399 * 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 device442 * @ddata: device driver data443 */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 to467 * prevent modem from waking up during deeper SoC idle states. The468 * gpio bank lines can have glitches if not in the always-on wkup469 * 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 will492 * keep the modem awake for about 1.2 seconds. When no n_gsm apps are using493 * the modem, runtime PM auto mode can be enabled so modem can enter low494 * 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 else507 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 toggling519 * the wake GPIO, and sometimes it idles after about some 600 ms520 * 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 able584 * to remove this eventually when ohci-platform can deal585 * 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_gsm592 * needs to access the device. We don't want to do this earlier as593 * 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