1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Arche Platform driver to enable Unipro link. 4 * 5 * Copyright 2014-2015 Google Inc. 6 * Copyright 2014-2015 Linaro Ltd. 7 */ 8 9 #include <linux/clk.h> 10 #include <linux/delay.h> 11 #include <linux/gpio.h> 12 #include <linux/init.h> 13 #include <linux/module.h> 14 #include <linux/of_gpio.h> 15 #include <linux/of_platform.h> 16 #include <linux/pinctrl/consumer.h> 17 #include <linux/platform_device.h> 18 #include <linux/pm.h> 19 #include <linux/interrupt.h> 20 #include <linux/irq.h> 21 #include <linux/suspend.h> 22 #include <linux/time.h> 23 #include "arche_platform.h" 24 #include "greybus.h" 25 26 #if IS_ENABLED(CONFIG_USB_HSIC_USB3613) 27 #include <linux/usb/usb3613.h> 28 #else 29 static inline int usb3613_hub_mode_ctrl(bool unused) 30 { 31 return 0; 32 } 33 #endif 34 35 #define WD_COLDBOOT_PULSE_WIDTH_MS 30 36 37 enum svc_wakedetect_state { 38 WD_STATE_IDLE, /* Default state = pulled high/low */ 39 WD_STATE_BOOT_INIT, /* WD = falling edge (low) */ 40 WD_STATE_COLDBOOT_TRIG, /* WD = rising edge (high), > 30msec */ 41 WD_STATE_STANDBYBOOT_TRIG, /* As of now not used ?? */ 42 WD_STATE_COLDBOOT_START, /* Cold boot process started */ 43 WD_STATE_STANDBYBOOT_START, /* Not used */ 44 }; 45 46 struct arche_platform_drvdata { 47 /* Control GPIO signals to and from AP <=> SVC */ 48 int svc_reset_gpio; 49 bool is_reset_act_hi; 50 int svc_sysboot_gpio; 51 int wake_detect_gpio; /* bi-dir,maps to WAKE_MOD & WAKE_FRAME signals */ 52 53 enum arche_platform_state state; 54 55 int svc_refclk_req; 56 struct clk *svc_ref_clk; 57 58 struct pinctrl *pinctrl; 59 struct pinctrl_state *pin_default; 60 61 int num_apbs; 62 63 enum svc_wakedetect_state wake_detect_state; 64 int wake_detect_irq; 65 spinlock_t wake_lock; /* Protect wake_detect_state */ 66 struct mutex platform_state_mutex; /* Protect state */ 67 unsigned long wake_detect_start; 68 struct notifier_block pm_notifier; 69 70 struct device *dev; 71 }; 72 73 /* Requires calling context to hold arche_pdata->platform_state_mutex */ 74 static void arche_platform_set_state(struct arche_platform_drvdata *arche_pdata, 75 enum arche_platform_state state) 76 { 77 arche_pdata->state = state; 78 } 79 80 /* Requires arche_pdata->wake_lock is held by calling context */ 81 static void arche_platform_set_wake_detect_state( 82 struct arche_platform_drvdata *arche_pdata, 83 enum svc_wakedetect_state state) 84 { 85 arche_pdata->wake_detect_state = state; 86 } 87 88 static inline void svc_reset_onoff(unsigned int gpio, bool onoff) 89 { 90 gpio_set_value(gpio, onoff); 91 } 92 93 static int apb_cold_boot(struct device *dev, void *data) 94 { 95 int ret; 96 97 ret = apb_ctrl_coldboot(dev); 98 if (ret) 99 dev_warn(dev, "failed to coldboot\n"); 100 101 /*Child nodes are independent, so do not exit coldboot operation */ 102 return 0; 103 } 104 105 static int apb_poweroff(struct device *dev, void *data) 106 { 107 apb_ctrl_poweroff(dev); 108 109 /* Enable HUB3613 into HUB mode. */ 110 if (usb3613_hub_mode_ctrl(false)) 111 dev_warn(dev, "failed to control hub device\n"); 112 113 return 0; 114 } 115 116 static void arche_platform_wd_irq_en(struct arche_platform_drvdata *arche_pdata) 117 { 118 /* Enable interrupt here, to read event back from SVC */ 119 gpio_direction_input(arche_pdata->wake_detect_gpio); 120 enable_irq(arche_pdata->wake_detect_irq); 121 } 122 123 static irqreturn_t arche_platform_wd_irq_thread(int irq, void *devid) 124 { 125 struct arche_platform_drvdata *arche_pdata = devid; 126 unsigned long flags; 127 128 spin_lock_irqsave(&arche_pdata->wake_lock, flags); 129 if (arche_pdata->wake_detect_state != WD_STATE_COLDBOOT_TRIG) { 130 /* Something is wrong */ 131 spin_unlock_irqrestore(&arche_pdata->wake_lock, flags); 132 return IRQ_HANDLED; 133 } 134 135 arche_platform_set_wake_detect_state(arche_pdata, 136 WD_STATE_COLDBOOT_START); 137 spin_unlock_irqrestore(&arche_pdata->wake_lock, flags); 138 139 /* It should complete power cycle, so first make sure it is poweroff */ 140 device_for_each_child(arche_pdata->dev, NULL, apb_poweroff); 141 142 /* Bring APB out of reset: cold boot sequence */ 143 device_for_each_child(arche_pdata->dev, NULL, apb_cold_boot); 144 145 /* Enable HUB3613 into HUB mode. */ 146 if (usb3613_hub_mode_ctrl(true)) 147 dev_warn(arche_pdata->dev, "failed to control hub device\n"); 148 149 spin_lock_irqsave(&arche_pdata->wake_lock, flags); 150 arche_platform_set_wake_detect_state(arche_pdata, WD_STATE_IDLE); 151 spin_unlock_irqrestore(&arche_pdata->wake_lock, flags); 152 153 return IRQ_HANDLED; 154 } 155 156 static irqreturn_t arche_platform_wd_irq(int irq, void *devid) 157 { 158 struct arche_platform_drvdata *arche_pdata = devid; 159 unsigned long flags; 160 161 spin_lock_irqsave(&arche_pdata->wake_lock, flags); 162 163 if (gpio_get_value(arche_pdata->wake_detect_gpio)) { 164 /* wake/detect rising */ 165 166 /* 167 * If wake/detect line goes high after low, within less than 168 * 30msec, then standby boot sequence is initiated, which is not 169 * supported/implemented as of now. So ignore it. 170 */ 171 if (arche_pdata->wake_detect_state == WD_STATE_BOOT_INIT) { 172 if (time_before(jiffies, 173 arche_pdata->wake_detect_start + 174 msecs_to_jiffies(WD_COLDBOOT_PULSE_WIDTH_MS))) { 175 arche_platform_set_wake_detect_state(arche_pdata, 176 WD_STATE_IDLE); 177 } else { 178 /* 179 * Check we are not in middle of irq thread 180 * already 181 */ 182 if (arche_pdata->wake_detect_state != 183 WD_STATE_COLDBOOT_START) { 184 arche_platform_set_wake_detect_state(arche_pdata, 185 WD_STATE_COLDBOOT_TRIG); 186 spin_unlock_irqrestore( 187 &arche_pdata->wake_lock, 188 flags); 189 return IRQ_WAKE_THREAD; 190 } 191 } 192 } 193 } else { 194 /* wake/detect falling */ 195 if (arche_pdata->wake_detect_state == WD_STATE_IDLE) { 196 arche_pdata->wake_detect_start = jiffies; 197 /* 198 * In the beginning, when wake/detect goes low 199 * (first time), we assume it is meant for coldboot 200 * and set the flag. If wake/detect line stays low 201 * beyond 30msec, then it is coldboot else fallback 202 * to standby boot. 203 */ 204 arche_platform_set_wake_detect_state(arche_pdata, 205 WD_STATE_BOOT_INIT); 206 } 207 } 208 209 spin_unlock_irqrestore(&arche_pdata->wake_lock, flags); 210 211 return IRQ_HANDLED; 212 } 213 214 /* 215 * Requires arche_pdata->platform_state_mutex to be held 216 */ 217 static int 218 arche_platform_coldboot_seq(struct arche_platform_drvdata *arche_pdata) 219 { 220 int ret; 221 222 if (arche_pdata->state == ARCHE_PLATFORM_STATE_ACTIVE) 223 return 0; 224 225 dev_info(arche_pdata->dev, "Booting from cold boot state\n"); 226 227 svc_reset_onoff(arche_pdata->svc_reset_gpio, 228 arche_pdata->is_reset_act_hi); 229 230 gpio_set_value(arche_pdata->svc_sysboot_gpio, 0); 231 usleep_range(100, 200); 232 233 ret = clk_prepare_enable(arche_pdata->svc_ref_clk); 234 if (ret) { 235 dev_err(arche_pdata->dev, "failed to enable svc_ref_clk: %d\n", 236 ret); 237 return ret; 238 } 239 240 /* bring SVC out of reset */ 241 svc_reset_onoff(arche_pdata->svc_reset_gpio, 242 !arche_pdata->is_reset_act_hi); 243 244 arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_ACTIVE); 245 246 return 0; 247 } 248 249 /* 250 * Requires arche_pdata->platform_state_mutex to be held 251 */ 252 static int 253 arche_platform_fw_flashing_seq(struct arche_platform_drvdata *arche_pdata) 254 { 255 int ret; 256 257 if (arche_pdata->state == ARCHE_PLATFORM_STATE_FW_FLASHING) 258 return 0; 259 260 dev_info(arche_pdata->dev, "Switching to FW flashing state\n"); 261 262 svc_reset_onoff(arche_pdata->svc_reset_gpio, 263 arche_pdata->is_reset_act_hi); 264 265 gpio_set_value(arche_pdata->svc_sysboot_gpio, 1); 266 267 usleep_range(100, 200); 268 269 ret = clk_prepare_enable(arche_pdata->svc_ref_clk); 270 if (ret) { 271 dev_err(arche_pdata->dev, "failed to enable svc_ref_clk: %d\n", 272 ret); 273 return ret; 274 } 275 276 svc_reset_onoff(arche_pdata->svc_reset_gpio, 277 !arche_pdata->is_reset_act_hi); 278 279 arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_FW_FLASHING); 280 281 return 0; 282 } 283 284 /* 285 * Requires arche_pdata->platform_state_mutex to be held 286 */ 287 static void 288 arche_platform_poweroff_seq(struct arche_platform_drvdata *arche_pdata) 289 { 290 unsigned long flags; 291 292 if (arche_pdata->state == ARCHE_PLATFORM_STATE_OFF) 293 return; 294 295 /* If in fw_flashing mode, then no need to repeate things again */ 296 if (arche_pdata->state != ARCHE_PLATFORM_STATE_FW_FLASHING) { 297 disable_irq(arche_pdata->wake_detect_irq); 298 299 spin_lock_irqsave(&arche_pdata->wake_lock, flags); 300 arche_platform_set_wake_detect_state(arche_pdata, 301 WD_STATE_IDLE); 302 spin_unlock_irqrestore(&arche_pdata->wake_lock, flags); 303 } 304 305 clk_disable_unprepare(arche_pdata->svc_ref_clk); 306 307 /* As part of exit, put APB back in reset state */ 308 svc_reset_onoff(arche_pdata->svc_reset_gpio, 309 arche_pdata->is_reset_act_hi); 310 311 arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_OFF); 312 } 313 314 static ssize_t state_store(struct device *dev, 315 struct device_attribute *attr, 316 const char *buf, size_t count) 317 { 318 struct arche_platform_drvdata *arche_pdata = dev_get_drvdata(dev); 319 int ret = 0; 320 321 mutex_lock(&arche_pdata->platform_state_mutex); 322 323 if (sysfs_streq(buf, "off")) { 324 if (arche_pdata->state == ARCHE_PLATFORM_STATE_OFF) 325 goto exit; 326 327 /* If SVC goes down, bring down APB's as well */ 328 device_for_each_child(arche_pdata->dev, NULL, apb_poweroff); 329 330 arche_platform_poweroff_seq(arche_pdata); 331 332 } else if (sysfs_streq(buf, "active")) { 333 if (arche_pdata->state == ARCHE_PLATFORM_STATE_ACTIVE) 334 goto exit; 335 336 /* First we want to make sure we power off everything 337 * and then activate back again 338 */ 339 device_for_each_child(arche_pdata->dev, NULL, apb_poweroff); 340 arche_platform_poweroff_seq(arche_pdata); 341 342 arche_platform_wd_irq_en(arche_pdata); 343 ret = arche_platform_coldboot_seq(arche_pdata); 344 if (ret) 345 goto exit; 346 347 } else if (sysfs_streq(buf, "standby")) { 348 if (arche_pdata->state == ARCHE_PLATFORM_STATE_STANDBY) 349 goto exit; 350 351 dev_warn(arche_pdata->dev, "standby state not supported\n"); 352 } else if (sysfs_streq(buf, "fw_flashing")) { 353 if (arche_pdata->state == ARCHE_PLATFORM_STATE_FW_FLASHING) 354 goto exit; 355 356 /* 357 * Here we only control SVC. 358 * 359 * In case of FW_FLASHING mode we do not want to control 360 * APBs, as in case of V2, SPI bus is shared between both 361 * the APBs. So let user chose which APB he wants to flash. 362 */ 363 arche_platform_poweroff_seq(arche_pdata); 364 365 ret = arche_platform_fw_flashing_seq(arche_pdata); 366 if (ret) 367 goto exit; 368 } else { 369 dev_err(arche_pdata->dev, "unknown state\n"); 370 ret = -EINVAL; 371 } 372 373 exit: 374 mutex_unlock(&arche_pdata->platform_state_mutex); 375 return ret ? ret : count; 376 } 377 378 static ssize_t state_show(struct device *dev, 379 struct device_attribute *attr, char *buf) 380 { 381 struct arche_platform_drvdata *arche_pdata = dev_get_drvdata(dev); 382 383 switch (arche_pdata->state) { 384 case ARCHE_PLATFORM_STATE_OFF: 385 return sprintf(buf, "off\n"); 386 case ARCHE_PLATFORM_STATE_ACTIVE: 387 return sprintf(buf, "active\n"); 388 case ARCHE_PLATFORM_STATE_STANDBY: 389 return sprintf(buf, "standby\n"); 390 case ARCHE_PLATFORM_STATE_FW_FLASHING: 391 return sprintf(buf, "fw_flashing\n"); 392 default: 393 return sprintf(buf, "unknown state\n"); 394 } 395 } 396 397 static DEVICE_ATTR_RW(state); 398 399 static int arche_platform_pm_notifier(struct notifier_block *notifier, 400 unsigned long pm_event, void *unused) 401 { 402 struct arche_platform_drvdata *arche_pdata = 403 container_of(notifier, struct arche_platform_drvdata, 404 pm_notifier); 405 int ret = NOTIFY_DONE; 406 407 mutex_lock(&arche_pdata->platform_state_mutex); 408 switch (pm_event) { 409 case PM_SUSPEND_PREPARE: 410 if (arche_pdata->state != ARCHE_PLATFORM_STATE_ACTIVE) { 411 ret = NOTIFY_STOP; 412 break; 413 } 414 device_for_each_child(arche_pdata->dev, NULL, apb_poweroff); 415 arche_platform_poweroff_seq(arche_pdata); 416 break; 417 case PM_POST_SUSPEND: 418 if (arche_pdata->state != ARCHE_PLATFORM_STATE_OFF) 419 break; 420 421 arche_platform_wd_irq_en(arche_pdata); 422 arche_platform_coldboot_seq(arche_pdata); 423 break; 424 default: 425 break; 426 } 427 mutex_unlock(&arche_pdata->platform_state_mutex); 428 429 return ret; 430 } 431 432 static int arche_platform_probe(struct platform_device *pdev) 433 { 434 struct arche_platform_drvdata *arche_pdata; 435 struct device *dev = &pdev->dev; 436 struct device_node *np = dev->of_node; 437 int ret; 438 439 arche_pdata = devm_kzalloc(&pdev->dev, sizeof(*arche_pdata), 440 GFP_KERNEL); 441 if (!arche_pdata) 442 return -ENOMEM; 443 444 /* setup svc reset gpio */ 445 arche_pdata->is_reset_act_hi = of_property_read_bool(np, 446 "svc,reset-active-high"); 447 arche_pdata->svc_reset_gpio = of_get_named_gpio(np, 448 "svc,reset-gpio", 449 0); 450 if (!gpio_is_valid(arche_pdata->svc_reset_gpio)) { 451 dev_err(dev, "failed to get reset-gpio\n"); 452 return arche_pdata->svc_reset_gpio; 453 } 454 ret = devm_gpio_request(dev, arche_pdata->svc_reset_gpio, "svc-reset"); 455 if (ret) { 456 dev_err(dev, "failed to request svc-reset gpio:%d\n", ret); 457 return ret; 458 } 459 ret = gpio_direction_output(arche_pdata->svc_reset_gpio, 460 arche_pdata->is_reset_act_hi); 461 if (ret) { 462 dev_err(dev, "failed to set svc-reset gpio dir:%d\n", ret); 463 return ret; 464 } 465 arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_OFF); 466 467 arche_pdata->svc_sysboot_gpio = of_get_named_gpio(np, 468 "svc,sysboot-gpio", 469 0); 470 if (!gpio_is_valid(arche_pdata->svc_sysboot_gpio)) { 471 dev_err(dev, "failed to get sysboot gpio\n"); 472 return arche_pdata->svc_sysboot_gpio; 473 } 474 ret = devm_gpio_request(dev, arche_pdata->svc_sysboot_gpio, "sysboot0"); 475 if (ret) { 476 dev_err(dev, "failed to request sysboot0 gpio:%d\n", ret); 477 return ret; 478 } 479 ret = gpio_direction_output(arche_pdata->svc_sysboot_gpio, 0); 480 if (ret) { 481 dev_err(dev, "failed to set svc-reset gpio dir:%d\n", ret); 482 return ret; 483 } 484 485 /* setup the clock request gpio first */ 486 arche_pdata->svc_refclk_req = of_get_named_gpio(np, 487 "svc,refclk-req-gpio", 488 0); 489 if (!gpio_is_valid(arche_pdata->svc_refclk_req)) { 490 dev_err(dev, "failed to get svc clock-req gpio\n"); 491 return arche_pdata->svc_refclk_req; 492 } 493 ret = devm_gpio_request(dev, arche_pdata->svc_refclk_req, 494 "svc-clk-req"); 495 if (ret) { 496 dev_err(dev, "failed to request svc-clk-req gpio: %d\n", ret); 497 return ret; 498 } 499 ret = gpio_direction_input(arche_pdata->svc_refclk_req); 500 if (ret) { 501 dev_err(dev, "failed to set svc-clk-req gpio dir :%d\n", ret); 502 return ret; 503 } 504 505 /* setup refclk2 to follow the pin */ 506 arche_pdata->svc_ref_clk = devm_clk_get(dev, "svc_ref_clk"); 507 if (IS_ERR(arche_pdata->svc_ref_clk)) { 508 ret = PTR_ERR(arche_pdata->svc_ref_clk); 509 dev_err(dev, "failed to get svc_ref_clk: %d\n", ret); 510 return ret; 511 } 512 513 platform_set_drvdata(pdev, arche_pdata); 514 515 arche_pdata->num_apbs = of_get_child_count(np); 516 dev_dbg(dev, "Number of APB's available - %d\n", arche_pdata->num_apbs); 517 518 arche_pdata->wake_detect_gpio = of_get_named_gpio(np, 519 "svc,wake-detect-gpio", 520 0); 521 if (arche_pdata->wake_detect_gpio < 0) { 522 dev_err(dev, "failed to get wake detect gpio\n"); 523 return arche_pdata->wake_detect_gpio; 524 } 525 526 ret = devm_gpio_request(dev, arche_pdata->wake_detect_gpio, 527 "wake detect"); 528 if (ret) { 529 dev_err(dev, "Failed requesting wake_detect gpio %d\n", 530 arche_pdata->wake_detect_gpio); 531 return ret; 532 } 533 534 arche_platform_set_wake_detect_state(arche_pdata, WD_STATE_IDLE); 535 536 arche_pdata->dev = &pdev->dev; 537 538 spin_lock_init(&arche_pdata->wake_lock); 539 mutex_init(&arche_pdata->platform_state_mutex); 540 arche_pdata->wake_detect_irq = 541 gpio_to_irq(arche_pdata->wake_detect_gpio); 542 543 ret = devm_request_threaded_irq(dev, arche_pdata->wake_detect_irq, 544 arche_platform_wd_irq, 545 arche_platform_wd_irq_thread, 546 IRQF_TRIGGER_FALLING | 547 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 548 dev_name(dev), arche_pdata); 549 if (ret) { 550 dev_err(dev, "failed to request wake detect IRQ %d\n", ret); 551 return ret; 552 } 553 disable_irq(arche_pdata->wake_detect_irq); 554 555 ret = device_create_file(dev, &dev_attr_state); 556 if (ret) { 557 dev_err(dev, "failed to create state file in sysfs\n"); 558 return ret; 559 } 560 561 ret = of_platform_populate(np, NULL, NULL, dev); 562 if (ret) { 563 dev_err(dev, "failed to populate child nodes %d\n", ret); 564 goto err_device_remove; 565 } 566 567 arche_pdata->pm_notifier.notifier_call = arche_platform_pm_notifier; 568 ret = register_pm_notifier(&arche_pdata->pm_notifier); 569 570 if (ret) { 571 dev_err(dev, "failed to register pm notifier %d\n", ret); 572 goto err_device_remove; 573 } 574 575 /* Explicitly power off if requested */ 576 if (!of_property_read_bool(pdev->dev.of_node, "arche,init-off")) { 577 mutex_lock(&arche_pdata->platform_state_mutex); 578 ret = arche_platform_coldboot_seq(arche_pdata); 579 if (ret) { 580 dev_err(dev, "Failed to cold boot svc %d\n", ret); 581 goto err_coldboot; 582 } 583 arche_platform_wd_irq_en(arche_pdata); 584 mutex_unlock(&arche_pdata->platform_state_mutex); 585 } 586 587 dev_info(dev, "Device registered successfully\n"); 588 return 0; 589 590 err_coldboot: 591 mutex_unlock(&arche_pdata->platform_state_mutex); 592 err_device_remove: 593 device_remove_file(&pdev->dev, &dev_attr_state); 594 return ret; 595 } 596 597 static int arche_remove_child(struct device *dev, void *unused) 598 { 599 struct platform_device *pdev = to_platform_device(dev); 600 601 platform_device_unregister(pdev); 602 603 return 0; 604 } 605 606 static int arche_platform_remove(struct platform_device *pdev) 607 { 608 struct arche_platform_drvdata *arche_pdata = platform_get_drvdata(pdev); 609 610 unregister_pm_notifier(&arche_pdata->pm_notifier); 611 device_remove_file(&pdev->dev, &dev_attr_state); 612 device_for_each_child(&pdev->dev, NULL, arche_remove_child); 613 arche_platform_poweroff_seq(arche_pdata); 614 615 if (usb3613_hub_mode_ctrl(false)) 616 dev_warn(arche_pdata->dev, "failed to control hub device\n"); 617 /* TODO: Should we do anything more here ?? */ 618 return 0; 619 } 620 621 static __maybe_unused int arche_platform_suspend(struct device *dev) 622 { 623 /* 624 * If timing profile premits, we may shutdown bridge 625 * completely 626 * 627 * TODO: sequence ?? 628 * 629 * Also, need to make sure we meet precondition for unipro suspend 630 * Precondition: Definition ??? 631 */ 632 return 0; 633 } 634 635 static __maybe_unused int arche_platform_resume(struct device *dev) 636 { 637 /* 638 * Atleast for ES2 we have to meet the delay requirement between 639 * unipro switch and AP bridge init, depending on whether bridge is in 640 * OFF state or standby state. 641 * 642 * Based on whether bridge is in standby or OFF state we may have to 643 * assert multiple signals. Please refer to WDM spec, for more info. 644 * 645 */ 646 return 0; 647 } 648 649 static void arche_platform_shutdown(struct platform_device *pdev) 650 { 651 struct arche_platform_drvdata *arche_pdata = platform_get_drvdata(pdev); 652 653 arche_platform_poweroff_seq(arche_pdata); 654 655 usb3613_hub_mode_ctrl(false); 656 } 657 658 static SIMPLE_DEV_PM_OPS(arche_platform_pm_ops, 659 arche_platform_suspend, 660 arche_platform_resume); 661 662 static const struct of_device_id arche_platform_of_match[] = { 663 /* Use PID/VID of SVC device */ 664 { .compatible = "google,arche-platform", }, 665 { }, 666 }; 667 668 static const struct of_device_id arche_combined_id[] = { 669 /* Use PID/VID of SVC device */ 670 { .compatible = "google,arche-platform", }, 671 { .compatible = "usbffff,2", }, 672 { }, 673 }; 674 MODULE_DEVICE_TABLE(of, arche_combined_id); 675 676 static struct platform_driver arche_platform_device_driver = { 677 .probe = arche_platform_probe, 678 .remove = arche_platform_remove, 679 .shutdown = arche_platform_shutdown, 680 .driver = { 681 .name = "arche-platform-ctrl", 682 .pm = &arche_platform_pm_ops, 683 .of_match_table = arche_platform_of_match, 684 } 685 }; 686 687 static int __init arche_init(void) 688 { 689 int retval; 690 691 retval = platform_driver_register(&arche_platform_device_driver); 692 if (retval) 693 return retval; 694 695 retval = arche_apb_init(); 696 if (retval) 697 platform_driver_unregister(&arche_platform_device_driver); 698 699 return retval; 700 } 701 module_init(arche_init); 702 703 static void __exit arche_exit(void) 704 { 705 arche_apb_exit(); 706 platform_driver_unregister(&arche_platform_device_driver); 707 } 708 module_exit(arche_exit); 709 710 MODULE_LICENSE("GPL v2"); 711 MODULE_AUTHOR("Vaibhav Hiremath <vaibhav.hiremath@linaro.org>"); 712 MODULE_DESCRIPTION("Arche Platform Driver"); 713