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