1 /* 2 * omap_device implementation 3 * 4 * Copyright (C) 2009-2010 Nokia Corporation 5 * Paul Walmsley, Kevin Hilman 6 * 7 * Developed in collaboration with (alphabetical order): Benoit 8 * Cousson, Thara Gopinath, Tony Lindgren, Rajendra Nayak, Vikram 9 * Pandita, Sakari Poussa, Anand Sawant, Santosh Shilimkar, Richard 10 * Woodruff 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License version 2 as 14 * published by the Free Software Foundation. 15 * 16 * This code provides a consistent interface for OMAP device drivers 17 * to control power management and interconnect properties of their 18 * devices. 19 * 20 * In the medium- to long-term, this code should be implemented as a 21 * proper omap_bus/omap_device in Linux, no more platform_data func 22 * pointers 23 * 24 * 25 */ 26 #undef DEBUG 27 28 #include <linux/kernel.h> 29 #include <linux/platform_device.h> 30 #include <linux/slab.h> 31 #include <linux/err.h> 32 #include <linux/io.h> 33 #include <linux/clk.h> 34 #include <linux/clkdev.h> 35 #include <linux/pm_domain.h> 36 #include <linux/pm_runtime.h> 37 #include <linux/of.h> 38 #include <linux/notifier.h> 39 40 #include "common.h" 41 #include "soc.h" 42 #include "omap_device.h" 43 #include "omap_hwmod.h" 44 45 /* Private functions */ 46 47 static void _add_clkdev(struct omap_device *od, const char *clk_alias, 48 const char *clk_name) 49 { 50 struct clk *r; 51 int rc; 52 53 if (!clk_alias || !clk_name) 54 return; 55 56 dev_dbg(&od->pdev->dev, "Creating %s -> %s\n", clk_alias, clk_name); 57 58 r = clk_get_sys(dev_name(&od->pdev->dev), clk_alias); 59 if (!IS_ERR(r)) { 60 dev_dbg(&od->pdev->dev, 61 "alias %s already exists\n", clk_alias); 62 clk_put(r); 63 return; 64 } 65 66 r = clk_get_sys(NULL, clk_name); 67 68 if (IS_ERR(r) && of_have_populated_dt()) { 69 struct of_phandle_args clkspec; 70 71 clkspec.np = of_find_node_by_name(NULL, clk_name); 72 73 r = of_clk_get_from_provider(&clkspec); 74 75 rc = clk_register_clkdev(r, clk_alias, 76 dev_name(&od->pdev->dev)); 77 } else { 78 rc = clk_add_alias(clk_alias, dev_name(&od->pdev->dev), 79 clk_name, NULL); 80 } 81 82 if (rc) { 83 if (rc == -ENODEV || rc == -ENOMEM) 84 dev_err(&od->pdev->dev, 85 "clkdev_alloc for %s failed\n", clk_alias); 86 else 87 dev_err(&od->pdev->dev, 88 "clk_get for %s failed\n", clk_name); 89 } 90 } 91 92 /** 93 * _add_hwmod_clocks_clkdev - Add clkdev entry for hwmod optional clocks 94 * and main clock 95 * @od: struct omap_device *od 96 * @oh: struct omap_hwmod *oh 97 * 98 * For the main clock and every optional clock present per hwmod per 99 * omap_device, this function adds an entry in the clkdev table of the 100 * form <dev-id=dev_name, con-id=role> if it does not exist already. 101 * 102 * The function is called from inside omap_device_build_ss(), after 103 * omap_device_register. 104 * 105 * This allows drivers to get a pointer to its optional clocks based on its role 106 * by calling clk_get(<dev*>, <role>). 107 * In the case of the main clock, a "fck" alias is used. 108 * 109 * No return value. 110 */ 111 static void _add_hwmod_clocks_clkdev(struct omap_device *od, 112 struct omap_hwmod *oh) 113 { 114 int i; 115 116 _add_clkdev(od, "fck", oh->main_clk); 117 118 for (i = 0; i < oh->opt_clks_cnt; i++) 119 _add_clkdev(od, oh->opt_clks[i].role, oh->opt_clks[i].clk); 120 } 121 122 123 /** 124 * omap_device_build_from_dt - build an omap_device with multiple hwmods 125 * @pdev_name: name of the platform_device driver to use 126 * @pdev_id: this platform_device's connection ID 127 * @oh: ptr to the single omap_hwmod that backs this omap_device 128 * @pdata: platform_data ptr to associate with the platform_device 129 * @pdata_len: amount of memory pointed to by @pdata 130 * 131 * Function for building an omap_device already registered from device-tree 132 * 133 * Returns 0 or PTR_ERR() on error. 134 */ 135 static int omap_device_build_from_dt(struct platform_device *pdev) 136 { 137 struct omap_hwmod **hwmods; 138 struct omap_device *od; 139 struct omap_hwmod *oh; 140 struct device_node *node = pdev->dev.of_node; 141 const char *oh_name; 142 int oh_cnt, i, ret = 0; 143 bool device_active = false; 144 145 oh_cnt = of_property_count_strings(node, "ti,hwmods"); 146 if (oh_cnt <= 0) { 147 dev_dbg(&pdev->dev, "No 'hwmods' to build omap_device\n"); 148 return -ENODEV; 149 } 150 151 hwmods = kzalloc(sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL); 152 if (!hwmods) { 153 ret = -ENOMEM; 154 goto odbfd_exit; 155 } 156 157 for (i = 0; i < oh_cnt; i++) { 158 of_property_read_string_index(node, "ti,hwmods", i, &oh_name); 159 oh = omap_hwmod_lookup(oh_name); 160 if (!oh) { 161 dev_err(&pdev->dev, "Cannot lookup hwmod '%s'\n", 162 oh_name); 163 ret = -EINVAL; 164 goto odbfd_exit1; 165 } 166 hwmods[i] = oh; 167 if (oh->flags & HWMOD_INIT_NO_IDLE) 168 device_active = true; 169 } 170 171 od = omap_device_alloc(pdev, hwmods, oh_cnt); 172 if (IS_ERR(od)) { 173 dev_err(&pdev->dev, "Cannot allocate omap_device for :%s\n", 174 oh_name); 175 ret = PTR_ERR(od); 176 goto odbfd_exit1; 177 } 178 179 /* Fix up missing resource names */ 180 for (i = 0; i < pdev->num_resources; i++) { 181 struct resource *r = &pdev->resource[i]; 182 183 if (r->name == NULL) 184 r->name = dev_name(&pdev->dev); 185 } 186 187 dev_pm_domain_set(&pdev->dev, &omap_device_pm_domain); 188 189 if (device_active) { 190 omap_device_enable(pdev); 191 pm_runtime_set_active(&pdev->dev); 192 } 193 194 odbfd_exit1: 195 kfree(hwmods); 196 odbfd_exit: 197 /* if data/we are at fault.. load up a fail handler */ 198 if (ret) 199 dev_pm_domain_set(&pdev->dev, &omap_device_fail_pm_domain); 200 201 return ret; 202 } 203 204 static int _omap_device_notifier_call(struct notifier_block *nb, 205 unsigned long event, void *dev) 206 { 207 struct platform_device *pdev = to_platform_device(dev); 208 struct omap_device *od; 209 int err; 210 211 switch (event) { 212 case BUS_NOTIFY_REMOVED_DEVICE: 213 if (pdev->archdata.od) 214 omap_device_delete(pdev->archdata.od); 215 break; 216 case BUS_NOTIFY_UNBOUND_DRIVER: 217 od = to_omap_device(pdev); 218 if (od && (od->_state == OMAP_DEVICE_STATE_ENABLED)) { 219 dev_info(dev, "enabled after unload, idling\n"); 220 err = omap_device_idle(pdev); 221 if (err) 222 dev_err(dev, "failed to idle\n"); 223 } 224 break; 225 case BUS_NOTIFY_ADD_DEVICE: 226 if (pdev->dev.of_node) 227 omap_device_build_from_dt(pdev); 228 omap_auxdata_legacy_init(dev); 229 /* fall through */ 230 default: 231 od = to_omap_device(pdev); 232 if (od) 233 od->_driver_status = event; 234 } 235 236 return NOTIFY_DONE; 237 } 238 239 /** 240 * _omap_device_enable_hwmods - call omap_hwmod_enable() on all hwmods 241 * @od: struct omap_device *od 242 * 243 * Enable all underlying hwmods. Returns 0. 244 */ 245 static int _omap_device_enable_hwmods(struct omap_device *od) 246 { 247 int ret = 0; 248 int i; 249 250 for (i = 0; i < od->hwmods_cnt; i++) 251 ret |= omap_hwmod_enable(od->hwmods[i]); 252 253 return ret; 254 } 255 256 /** 257 * _omap_device_idle_hwmods - call omap_hwmod_idle() on all hwmods 258 * @od: struct omap_device *od 259 * 260 * Idle all underlying hwmods. Returns 0. 261 */ 262 static int _omap_device_idle_hwmods(struct omap_device *od) 263 { 264 int ret = 0; 265 int i; 266 267 for (i = 0; i < od->hwmods_cnt; i++) 268 ret |= omap_hwmod_idle(od->hwmods[i]); 269 270 return ret; 271 } 272 273 /* Public functions for use by core code */ 274 275 /** 276 * omap_device_get_context_loss_count - get lost context count 277 * @od: struct omap_device * 278 * 279 * Using the primary hwmod, query the context loss count for this 280 * device. 281 * 282 * Callers should consider context for this device lost any time this 283 * function returns a value different than the value the caller got 284 * the last time it called this function. 285 * 286 * If any hwmods exist for the omap_device associated with @pdev, 287 * return the context loss counter for that hwmod, otherwise return 288 * zero. 289 */ 290 int omap_device_get_context_loss_count(struct platform_device *pdev) 291 { 292 struct omap_device *od; 293 u32 ret = 0; 294 295 od = to_omap_device(pdev); 296 297 if (od->hwmods_cnt) 298 ret = omap_hwmod_get_context_loss_count(od->hwmods[0]); 299 300 return ret; 301 } 302 303 /** 304 * omap_device_count_resources - count number of struct resource entries needed 305 * @od: struct omap_device * 306 * @flags: Type of resources to include when counting (IRQ/DMA/MEM) 307 * 308 * Count the number of struct resource entries needed for this 309 * omap_device @od. Used by omap_device_build_ss() to determine how 310 * much memory to allocate before calling 311 * omap_device_fill_resources(). Returns the count. 312 */ 313 static int omap_device_count_resources(struct omap_device *od, 314 unsigned long flags) 315 { 316 int c = 0; 317 int i; 318 319 for (i = 0; i < od->hwmods_cnt; i++) 320 c += omap_hwmod_count_resources(od->hwmods[i], flags); 321 322 pr_debug("omap_device: %s: counted %d total resources across %d hwmods\n", 323 od->pdev->name, c, od->hwmods_cnt); 324 325 return c; 326 } 327 328 /** 329 * omap_device_fill_resources - fill in array of struct resource 330 * @od: struct omap_device * 331 * @res: pointer to an array of struct resource to be filled in 332 * 333 * Populate one or more empty struct resource pointed to by @res with 334 * the resource data for this omap_device @od. Used by 335 * omap_device_build_ss() after calling omap_device_count_resources(). 336 * Ideally this function would not be needed at all. If omap_device 337 * replaces platform_device, then we can specify our own 338 * get_resource()/ get_irq()/etc functions that use the underlying 339 * omap_hwmod information. Or if platform_device is extended to use 340 * subarchitecture-specific function pointers, the various 341 * platform_device functions can simply call omap_device internal 342 * functions to get device resources. Hacking around the existing 343 * platform_device code wastes memory. Returns 0. 344 */ 345 static int omap_device_fill_resources(struct omap_device *od, 346 struct resource *res) 347 { 348 int i, r; 349 350 for (i = 0; i < od->hwmods_cnt; i++) { 351 r = omap_hwmod_fill_resources(od->hwmods[i], res); 352 res += r; 353 } 354 355 return 0; 356 } 357 358 /** 359 * _od_fill_dma_resources - fill in array of struct resource with dma resources 360 * @od: struct omap_device * 361 * @res: pointer to an array of struct resource to be filled in 362 * 363 * Populate one or more empty struct resource pointed to by @res with 364 * the dma resource data for this omap_device @od. Used by 365 * omap_device_alloc() after calling omap_device_count_resources(). 366 * 367 * Ideally this function would not be needed at all. If we have 368 * mechanism to get dma resources from DT. 369 * 370 * Returns 0. 371 */ 372 static int _od_fill_dma_resources(struct omap_device *od, 373 struct resource *res) 374 { 375 int i, r; 376 377 for (i = 0; i < od->hwmods_cnt; i++) { 378 r = omap_hwmod_fill_dma_resources(od->hwmods[i], res); 379 res += r; 380 } 381 382 return 0; 383 } 384 385 /** 386 * omap_device_alloc - allocate an omap_device 387 * @pdev: platform_device that will be included in this omap_device 388 * @oh: ptr to the single omap_hwmod that backs this omap_device 389 * @pdata: platform_data ptr to associate with the platform_device 390 * @pdata_len: amount of memory pointed to by @pdata 391 * 392 * Convenience function for allocating an omap_device structure and filling 393 * hwmods, and resources. 394 * 395 * Returns an struct omap_device pointer or ERR_PTR() on error; 396 */ 397 struct omap_device *omap_device_alloc(struct platform_device *pdev, 398 struct omap_hwmod **ohs, int oh_cnt) 399 { 400 int ret = -ENOMEM; 401 struct omap_device *od; 402 struct resource *res = NULL; 403 int i, res_count; 404 struct omap_hwmod **hwmods; 405 406 od = kzalloc(sizeof(struct omap_device), GFP_KERNEL); 407 if (!od) { 408 ret = -ENOMEM; 409 goto oda_exit1; 410 } 411 od->hwmods_cnt = oh_cnt; 412 413 hwmods = kmemdup(ohs, sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL); 414 if (!hwmods) 415 goto oda_exit2; 416 417 od->hwmods = hwmods; 418 od->pdev = pdev; 419 420 /* 421 * Non-DT Boot: 422 * Here, pdev->num_resources = 0, and we should get all the 423 * resources from hwmod. 424 * 425 * DT Boot: 426 * OF framework will construct the resource structure (currently 427 * does for MEM & IRQ resource) and we should respect/use these 428 * resources, killing hwmod dependency. 429 * If pdev->num_resources > 0, we assume that MEM & IRQ resources 430 * have been allocated by OF layer already (through DTB). 431 * As preparation for the future we examine the OF provided resources 432 * to see if we have DMA resources provided already. In this case 433 * there is no need to update the resources for the device, we use the 434 * OF provided ones. 435 * 436 * TODO: Once DMA resource is available from OF layer, we should 437 * kill filling any resources from hwmod. 438 */ 439 if (!pdev->num_resources) { 440 /* Count all resources for the device */ 441 res_count = omap_device_count_resources(od, IORESOURCE_IRQ | 442 IORESOURCE_DMA | 443 IORESOURCE_MEM); 444 } else { 445 /* Take a look if we already have DMA resource via DT */ 446 for (i = 0; i < pdev->num_resources; i++) { 447 struct resource *r = &pdev->resource[i]; 448 449 /* We have it, no need to touch the resources */ 450 if (r->flags == IORESOURCE_DMA) 451 goto have_everything; 452 } 453 /* Count only DMA resources for the device */ 454 res_count = omap_device_count_resources(od, IORESOURCE_DMA); 455 /* The device has no DMA resource, no need for update */ 456 if (!res_count) 457 goto have_everything; 458 459 res_count += pdev->num_resources; 460 } 461 462 /* Allocate resources memory to account for new resources */ 463 res = kzalloc(sizeof(struct resource) * res_count, GFP_KERNEL); 464 if (!res) 465 goto oda_exit3; 466 467 if (!pdev->num_resources) { 468 dev_dbg(&pdev->dev, "%s: using %d resources from hwmod\n", 469 __func__, res_count); 470 omap_device_fill_resources(od, res); 471 } else { 472 dev_dbg(&pdev->dev, 473 "%s: appending %d DMA resources from hwmod\n", 474 __func__, res_count - pdev->num_resources); 475 memcpy(res, pdev->resource, 476 sizeof(struct resource) * pdev->num_resources); 477 _od_fill_dma_resources(od, &res[pdev->num_resources]); 478 } 479 480 ret = platform_device_add_resources(pdev, res, res_count); 481 kfree(res); 482 483 if (ret) 484 goto oda_exit3; 485 486 have_everything: 487 pdev->archdata.od = od; 488 489 for (i = 0; i < oh_cnt; i++) { 490 hwmods[i]->od = od; 491 _add_hwmod_clocks_clkdev(od, hwmods[i]); 492 } 493 494 return od; 495 496 oda_exit3: 497 kfree(hwmods); 498 oda_exit2: 499 kfree(od); 500 oda_exit1: 501 dev_err(&pdev->dev, "omap_device: build failed (%d)\n", ret); 502 503 return ERR_PTR(ret); 504 } 505 506 void omap_device_delete(struct omap_device *od) 507 { 508 if (!od) 509 return; 510 511 od->pdev->archdata.od = NULL; 512 kfree(od->hwmods); 513 kfree(od); 514 } 515 516 /** 517 * omap_device_build - build and register an omap_device with one omap_hwmod 518 * @pdev_name: name of the platform_device driver to use 519 * @pdev_id: this platform_device's connection ID 520 * @oh: ptr to the single omap_hwmod that backs this omap_device 521 * @pdata: platform_data ptr to associate with the platform_device 522 * @pdata_len: amount of memory pointed to by @pdata 523 * 524 * Convenience function for building and registering a single 525 * omap_device record, which in turn builds and registers a 526 * platform_device record. See omap_device_build_ss() for more 527 * information. Returns ERR_PTR(-EINVAL) if @oh is NULL; otherwise, 528 * passes along the return value of omap_device_build_ss(). 529 */ 530 struct platform_device __init *omap_device_build(const char *pdev_name, 531 int pdev_id, 532 struct omap_hwmod *oh, 533 void *pdata, int pdata_len) 534 { 535 struct omap_hwmod *ohs[] = { oh }; 536 537 if (!oh) 538 return ERR_PTR(-EINVAL); 539 540 return omap_device_build_ss(pdev_name, pdev_id, ohs, 1, pdata, 541 pdata_len); 542 } 543 544 /** 545 * omap_device_build_ss - build and register an omap_device with multiple hwmods 546 * @pdev_name: name of the platform_device driver to use 547 * @pdev_id: this platform_device's connection ID 548 * @oh: ptr to the single omap_hwmod that backs this omap_device 549 * @pdata: platform_data ptr to associate with the platform_device 550 * @pdata_len: amount of memory pointed to by @pdata 551 * 552 * Convenience function for building and registering an omap_device 553 * subsystem record. Subsystem records consist of multiple 554 * omap_hwmods. This function in turn builds and registers a 555 * platform_device record. Returns an ERR_PTR() on error, or passes 556 * along the return value of omap_device_register(). 557 */ 558 struct platform_device __init *omap_device_build_ss(const char *pdev_name, 559 int pdev_id, 560 struct omap_hwmod **ohs, 561 int oh_cnt, void *pdata, 562 int pdata_len) 563 { 564 int ret = -ENOMEM; 565 struct platform_device *pdev; 566 struct omap_device *od; 567 568 if (!ohs || oh_cnt == 0 || !pdev_name) 569 return ERR_PTR(-EINVAL); 570 571 if (!pdata && pdata_len > 0) 572 return ERR_PTR(-EINVAL); 573 574 pdev = platform_device_alloc(pdev_name, pdev_id); 575 if (!pdev) { 576 ret = -ENOMEM; 577 goto odbs_exit; 578 } 579 580 /* Set the dev_name early to allow dev_xxx in omap_device_alloc */ 581 if (pdev->id != -1) 582 dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id); 583 else 584 dev_set_name(&pdev->dev, "%s", pdev->name); 585 586 od = omap_device_alloc(pdev, ohs, oh_cnt); 587 if (IS_ERR(od)) 588 goto odbs_exit1; 589 590 ret = platform_device_add_data(pdev, pdata, pdata_len); 591 if (ret) 592 goto odbs_exit2; 593 594 ret = omap_device_register(pdev); 595 if (ret) 596 goto odbs_exit2; 597 598 return pdev; 599 600 odbs_exit2: 601 omap_device_delete(od); 602 odbs_exit1: 603 platform_device_put(pdev); 604 odbs_exit: 605 606 pr_err("omap_device: %s: build failed (%d)\n", pdev_name, ret); 607 608 return ERR_PTR(ret); 609 } 610 611 #ifdef CONFIG_PM 612 static int _od_runtime_suspend(struct device *dev) 613 { 614 struct platform_device *pdev = to_platform_device(dev); 615 int ret; 616 617 ret = pm_generic_runtime_suspend(dev); 618 if (ret) 619 return ret; 620 621 return omap_device_idle(pdev); 622 } 623 624 static int _od_runtime_resume(struct device *dev) 625 { 626 struct platform_device *pdev = to_platform_device(dev); 627 int ret; 628 629 ret = omap_device_enable(pdev); 630 if (ret) { 631 dev_err(dev, "use pm_runtime_put_sync_suspend() in driver?\n"); 632 return ret; 633 } 634 635 return pm_generic_runtime_resume(dev); 636 } 637 638 static int _od_fail_runtime_suspend(struct device *dev) 639 { 640 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__); 641 return -ENODEV; 642 } 643 644 static int _od_fail_runtime_resume(struct device *dev) 645 { 646 dev_warn(dev, "%s: FIXME: missing hwmod/omap_dev info\n", __func__); 647 return -ENODEV; 648 } 649 650 #endif 651 652 #ifdef CONFIG_SUSPEND 653 static int _od_suspend_noirq(struct device *dev) 654 { 655 struct platform_device *pdev = to_platform_device(dev); 656 struct omap_device *od = to_omap_device(pdev); 657 int ret; 658 659 /* Don't attempt late suspend on a driver that is not bound */ 660 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER) 661 return 0; 662 663 ret = pm_generic_suspend_noirq(dev); 664 665 if (!ret && !pm_runtime_status_suspended(dev)) { 666 if (pm_generic_runtime_suspend(dev) == 0) { 667 pm_runtime_set_suspended(dev); 668 omap_device_idle(pdev); 669 od->flags |= OMAP_DEVICE_SUSPENDED; 670 } 671 } 672 673 return ret; 674 } 675 676 static int _od_resume_noirq(struct device *dev) 677 { 678 struct platform_device *pdev = to_platform_device(dev); 679 struct omap_device *od = to_omap_device(pdev); 680 681 if (od->flags & OMAP_DEVICE_SUSPENDED) { 682 od->flags &= ~OMAP_DEVICE_SUSPENDED; 683 omap_device_enable(pdev); 684 /* 685 * XXX: we run before core runtime pm has resumed itself. At 686 * this point in time, we just restore the runtime pm state and 687 * considering symmetric operations in resume, we donot expect 688 * to fail. If we failed, something changed in core runtime_pm 689 * framework OR some device driver messed things up, hence, WARN 690 */ 691 WARN(pm_runtime_set_active(dev), 692 "Could not set %s runtime state active\n", dev_name(dev)); 693 pm_generic_runtime_resume(dev); 694 } 695 696 return pm_generic_resume_noirq(dev); 697 } 698 #else 699 #define _od_suspend_noirq NULL 700 #define _od_resume_noirq NULL 701 #endif 702 703 struct dev_pm_domain omap_device_fail_pm_domain = { 704 .ops = { 705 SET_RUNTIME_PM_OPS(_od_fail_runtime_suspend, 706 _od_fail_runtime_resume, NULL) 707 } 708 }; 709 710 struct dev_pm_domain omap_device_pm_domain = { 711 .ops = { 712 SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume, 713 NULL) 714 USE_PLATFORM_PM_SLEEP_OPS 715 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(_od_suspend_noirq, 716 _od_resume_noirq) 717 } 718 }; 719 720 /** 721 * omap_device_register - register an omap_device with one omap_hwmod 722 * @od: struct omap_device * to register 723 * 724 * Register the omap_device structure. This currently just calls 725 * platform_device_register() on the underlying platform_device. 726 * Returns the return value of platform_device_register(). 727 */ 728 int omap_device_register(struct platform_device *pdev) 729 { 730 pr_debug("omap_device: %s: registering\n", pdev->name); 731 732 dev_pm_domain_set(&pdev->dev, &omap_device_pm_domain); 733 return platform_device_add(pdev); 734 } 735 736 737 /* Public functions for use by device drivers through struct platform_data */ 738 739 /** 740 * omap_device_enable - fully activate an omap_device 741 * @od: struct omap_device * to activate 742 * 743 * Do whatever is necessary for the hwmods underlying omap_device @od 744 * to be accessible and ready to operate. This generally involves 745 * enabling clocks, setting SYSCONFIG registers; and in the future may 746 * involve remuxing pins. Device drivers should call this function 747 * indirectly via pm_runtime_get*(). Returns -EINVAL if called when 748 * the omap_device is already enabled, or passes along the return 749 * value of _omap_device_enable_hwmods(). 750 */ 751 int omap_device_enable(struct platform_device *pdev) 752 { 753 int ret; 754 struct omap_device *od; 755 756 od = to_omap_device(pdev); 757 758 if (od->_state == OMAP_DEVICE_STATE_ENABLED) { 759 dev_warn(&pdev->dev, 760 "omap_device: %s() called from invalid state %d\n", 761 __func__, od->_state); 762 return -EINVAL; 763 } 764 765 ret = _omap_device_enable_hwmods(od); 766 767 if (ret == 0) 768 od->_state = OMAP_DEVICE_STATE_ENABLED; 769 770 return ret; 771 } 772 773 /** 774 * omap_device_idle - idle an omap_device 775 * @od: struct omap_device * to idle 776 * 777 * Idle omap_device @od. Device drivers call this function indirectly 778 * via pm_runtime_put*(). Returns -EINVAL if the omap_device is not 779 * currently enabled, or passes along the return value of 780 * _omap_device_idle_hwmods(). 781 */ 782 int omap_device_idle(struct platform_device *pdev) 783 { 784 int ret; 785 struct omap_device *od; 786 787 od = to_omap_device(pdev); 788 789 if (od->_state != OMAP_DEVICE_STATE_ENABLED) { 790 dev_warn(&pdev->dev, 791 "omap_device: %s() called from invalid state %d\n", 792 __func__, od->_state); 793 return -EINVAL; 794 } 795 796 ret = _omap_device_idle_hwmods(od); 797 798 if (ret == 0) 799 od->_state = OMAP_DEVICE_STATE_IDLE; 800 801 return ret; 802 } 803 804 /** 805 * omap_device_assert_hardreset - set a device's hardreset line 806 * @pdev: struct platform_device * to reset 807 * @name: const char * name of the reset line 808 * 809 * Set the hardreset line identified by @name on the IP blocks 810 * associated with the hwmods backing the platform_device @pdev. All 811 * of the hwmods associated with @pdev must have the same hardreset 812 * line linked to them for this to work. Passes along the return value 813 * of omap_hwmod_assert_hardreset() in the event of any failure, or 814 * returns 0 upon success. 815 */ 816 int omap_device_assert_hardreset(struct platform_device *pdev, const char *name) 817 { 818 struct omap_device *od = to_omap_device(pdev); 819 int ret = 0; 820 int i; 821 822 for (i = 0; i < od->hwmods_cnt; i++) { 823 ret = omap_hwmod_assert_hardreset(od->hwmods[i], name); 824 if (ret) 825 break; 826 } 827 828 return ret; 829 } 830 831 /** 832 * omap_device_deassert_hardreset - release a device's hardreset line 833 * @pdev: struct platform_device * to reset 834 * @name: const char * name of the reset line 835 * 836 * Release the hardreset line identified by @name on the IP blocks 837 * associated with the hwmods backing the platform_device @pdev. All 838 * of the hwmods associated with @pdev must have the same hardreset 839 * line linked to them for this to work. Passes along the return 840 * value of omap_hwmod_deassert_hardreset() in the event of any 841 * failure, or returns 0 upon success. 842 */ 843 int omap_device_deassert_hardreset(struct platform_device *pdev, 844 const char *name) 845 { 846 struct omap_device *od = to_omap_device(pdev); 847 int ret = 0; 848 int i; 849 850 for (i = 0; i < od->hwmods_cnt; i++) { 851 ret = omap_hwmod_deassert_hardreset(od->hwmods[i], name); 852 if (ret) 853 break; 854 } 855 856 return ret; 857 } 858 859 /** 860 * omap_device_get_by_hwmod_name() - convert a hwmod name to 861 * device pointer. 862 * @oh_name: name of the hwmod device 863 * 864 * Returns back a struct device * pointer associated with a hwmod 865 * device represented by a hwmod_name 866 */ 867 struct device *omap_device_get_by_hwmod_name(const char *oh_name) 868 { 869 struct omap_hwmod *oh; 870 871 if (!oh_name) { 872 WARN(1, "%s: no hwmod name!\n", __func__); 873 return ERR_PTR(-EINVAL); 874 } 875 876 oh = omap_hwmod_lookup(oh_name); 877 if (!oh) { 878 WARN(1, "%s: no hwmod for %s\n", __func__, 879 oh_name); 880 return ERR_PTR(-ENODEV); 881 } 882 if (!oh->od) { 883 WARN(1, "%s: no omap_device for %s\n", __func__, 884 oh_name); 885 return ERR_PTR(-ENODEV); 886 } 887 888 return &oh->od->pdev->dev; 889 } 890 891 static struct notifier_block platform_nb = { 892 .notifier_call = _omap_device_notifier_call, 893 }; 894 895 static int __init omap_device_init(void) 896 { 897 bus_register_notifier(&platform_bus_type, &platform_nb); 898 return 0; 899 } 900 omap_postcore_initcall(omap_device_init); 901 902 /** 903 * omap_device_late_idle - idle devices without drivers 904 * @dev: struct device * associated with omap_device 905 * @data: unused 906 * 907 * Check the driver bound status of this device, and idle it 908 * if there is no driver attached. 909 */ 910 static int __init omap_device_late_idle(struct device *dev, void *data) 911 { 912 struct platform_device *pdev = to_platform_device(dev); 913 struct omap_device *od = to_omap_device(pdev); 914 int i; 915 916 if (!od) 917 return 0; 918 919 /* 920 * If omap_device state is enabled, but has no driver bound, 921 * idle it. 922 */ 923 924 /* 925 * Some devices (like memory controllers) are always kept 926 * enabled, and should not be idled even with no drivers. 927 */ 928 for (i = 0; i < od->hwmods_cnt; i++) 929 if (od->hwmods[i]->flags & HWMOD_INIT_NO_IDLE) 930 return 0; 931 932 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER && 933 od->_driver_status != BUS_NOTIFY_BIND_DRIVER) { 934 if (od->_state == OMAP_DEVICE_STATE_ENABLED) { 935 dev_warn(dev, "%s: enabled but no driver. Idling\n", 936 __func__); 937 omap_device_idle(pdev); 938 } 939 } 940 941 return 0; 942 } 943 944 static int __init omap_device_late_init(void) 945 { 946 bus_for_each_dev(&platform_bus_type, NULL, NULL, omap_device_late_idle); 947 948 WARN(!of_have_populated_dt(), 949 "legacy booting deprecated, please update to boot with .dts\n"); 950 951 return 0; 952 } 953 omap_late_initcall_sync(omap_device_late_init); 954