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 either be 21 * a) implemented via arch-specific pointers in platform_data 22 * or 23 * b) implemented as a proper omap_bus/omap_device in Linux, no more 24 * platform_data func pointers 25 * 26 * 27 * Guidelines for usage by driver authors: 28 * 29 * 1. These functions are intended to be used by device drivers via 30 * function pointers in struct platform_data. As an example, 31 * omap_device_enable() should be passed to the driver as 32 * 33 * struct foo_driver_platform_data { 34 * ... 35 * int (*device_enable)(struct platform_device *pdev); 36 * ... 37 * } 38 * 39 * Note that the generic "device_enable" name is used, rather than 40 * "omap_device_enable". This is so other architectures can pass in their 41 * own enable/disable functions here. 42 * 43 * This should be populated during device setup: 44 * 45 * ... 46 * pdata->device_enable = omap_device_enable; 47 * ... 48 * 49 * 2. Drivers should first check to ensure the function pointer is not null 50 * before calling it, as in: 51 * 52 * if (pdata->device_enable) 53 * pdata->device_enable(pdev); 54 * 55 * This allows other architectures that don't use similar device_enable()/ 56 * device_shutdown() functions to execute normally. 57 * 58 * ... 59 * 60 * Suggested usage by device drivers: 61 * 62 * During device initialization: 63 * device_enable() 64 * 65 * During device idle: 66 * (save remaining device context if necessary) 67 * device_idle(); 68 * 69 * During device resume: 70 * device_enable(); 71 * (restore context if necessary) 72 * 73 * During device shutdown: 74 * device_shutdown() 75 * (device must be reinitialized at this point to use it again) 76 * 77 */ 78#undef DEBUG 79 80#include <linux/kernel.h> 81#include <linux/platform_device.h> 82#include <linux/slab.h> 83#include <linux/err.h> 84#include <linux/io.h> 85 86#include <plat/omap_device.h> 87#include <plat/omap_hwmod.h> 88 89/* These parameters are passed to _omap_device_{de,}activate() */ 90#define USE_WAKEUP_LAT 0 91#define IGNORE_WAKEUP_LAT 1 92 93/* 94 * OMAP_DEVICE_MAGIC: used to determine whether a struct omap_device 95 * obtained via container_of() is in fact a struct omap_device 96 */ 97#define OMAP_DEVICE_MAGIC 0xf00dcafe 98 99/* Private functions */ 100 101/** 102 * _omap_device_activate - increase device readiness 103 * @od: struct omap_device * 104 * @ignore_lat: increase to latency target (0) or full readiness (1)? 105 * 106 * Increase readiness of omap_device @od (thus decreasing device 107 * wakeup latency, but consuming more power). If @ignore_lat is 108 * IGNORE_WAKEUP_LAT, make the omap_device fully active. Otherwise, 109 * if @ignore_lat is USE_WAKEUP_LAT, and the device's maximum wakeup 110 * latency is greater than the requested maximum wakeup latency, step 111 * backwards in the omap_device_pm_latency table to ensure the 112 * device's maximum wakeup latency is less than or equal to the 113 * requested maximum wakeup latency. Returns 0. 114 */ 115static int _omap_device_activate(struct omap_device *od, u8 ignore_lat) 116{ 117 struct timespec a, b, c; 118 119 pr_debug("omap_device: %s: activating\n", od->pdev.name); 120 121 while (od->pm_lat_level > 0) { 122 struct omap_device_pm_latency *odpl; 123 unsigned long long act_lat = 0; 124 125 od->pm_lat_level--; 126 127 odpl = od->pm_lats + od->pm_lat_level; 128 129 if (!ignore_lat && 130 (od->dev_wakeup_lat <= od->_dev_wakeup_lat_limit)) 131 break; 132 133 read_persistent_clock(&a); 134 135 odpl->activate_func(od); 136 137 read_persistent_clock(&b); 138 139 c = timespec_sub(b, a); 140 act_lat = timespec_to_ns(&c); 141 142 pr_debug("omap_device: %s: pm_lat %d: activate: elapsed time " 143 "%llu nsec\n", od->pdev.name, od->pm_lat_level, 144 act_lat); 145 146 if (act_lat > odpl->activate_lat) { 147 odpl->activate_lat_worst = act_lat; 148 if (odpl->flags & OMAP_DEVICE_LATENCY_AUTO_ADJUST) { 149 odpl->activate_lat = act_lat; 150 pr_warning("omap_device: %s.%d: new worst case " 151 "activate latency %d: %llu\n", 152 od->pdev.name, od->pdev.id, 153 od->pm_lat_level, act_lat); 154 } else 155 pr_warning("omap_device: %s.%d: activate " 156 "latency %d higher than exptected. " 157 "(%llu > %d)\n", 158 od->pdev.name, od->pdev.id, 159 od->pm_lat_level, act_lat, 160 odpl->activate_lat); 161 } 162 163 od->dev_wakeup_lat -= odpl->activate_lat; 164 } 165 166 return 0; 167} 168 169/** 170 * _omap_device_deactivate - decrease device readiness 171 * @od: struct omap_device * 172 * @ignore_lat: decrease to latency target (0) or full inactivity (1)? 173 * 174 * Decrease readiness of omap_device @od (thus increasing device 175 * wakeup latency, but conserving power). If @ignore_lat is 176 * IGNORE_WAKEUP_LAT, make the omap_device fully inactive. Otherwise, 177 * if @ignore_lat is USE_WAKEUP_LAT, and the device's maximum wakeup 178 * latency is less than the requested maximum wakeup latency, step 179 * forwards in the omap_device_pm_latency table to ensure the device's 180 * maximum wakeup latency is less than or equal to the requested 181 * maximum wakeup latency. Returns 0. 182 */ 183static int _omap_device_deactivate(struct omap_device *od, u8 ignore_lat) 184{ 185 struct timespec a, b, c; 186 187 pr_debug("omap_device: %s: deactivating\n", od->pdev.name); 188 189 while (od->pm_lat_level < od->pm_lats_cnt) { 190 struct omap_device_pm_latency *odpl; 191 unsigned long long deact_lat = 0; 192 193 odpl = od->pm_lats + od->pm_lat_level; 194 195 if (!ignore_lat && 196 ((od->dev_wakeup_lat + odpl->activate_lat) > 197 od->_dev_wakeup_lat_limit)) 198 break; 199 200 read_persistent_clock(&a); 201 202 odpl->deactivate_func(od); 203 204 read_persistent_clock(&b); 205 206 c = timespec_sub(b, a); 207 deact_lat = timespec_to_ns(&c); 208 209 pr_debug("omap_device: %s: pm_lat %d: deactivate: elapsed time " 210 "%llu nsec\n", od->pdev.name, od->pm_lat_level, 211 deact_lat); 212 213 if (deact_lat > odpl->deactivate_lat) { 214 odpl->deactivate_lat_worst = deact_lat; 215 if (odpl->flags & OMAP_DEVICE_LATENCY_AUTO_ADJUST) { 216 odpl->deactivate_lat = deact_lat; 217 pr_warning("omap_device: %s.%d: new worst case " 218 "deactivate latency %d: %llu\n", 219 od->pdev.name, od->pdev.id, 220 od->pm_lat_level, deact_lat); 221 } else 222 pr_warning("omap_device: %s.%d: deactivate " 223 "latency %d higher than exptected. " 224 "(%llu > %d)\n", 225 od->pdev.name, od->pdev.id, 226 od->pm_lat_level, deact_lat, 227 odpl->deactivate_lat); 228 } 229 230 231 od->dev_wakeup_lat += odpl->activate_lat; 232 233 od->pm_lat_level++; 234 } 235 236 return 0; 237} 238 239static inline struct omap_device *_find_by_pdev(struct platform_device *pdev) 240{ 241 return container_of(pdev, struct omap_device, pdev); 242} 243 244 245/* Public functions for use by core code */ 246 247/** 248 * omap_device_count_resources - count number of struct resource entries needed 249 * @od: struct omap_device * 250 * 251 * Count the number of struct resource entries needed for this 252 * omap_device @od. Used by omap_device_build_ss() to determine how 253 * much memory to allocate before calling 254 * omap_device_fill_resources(). Returns the count. 255 */ 256int omap_device_count_resources(struct omap_device *od) 257{ 258 struct omap_hwmod *oh; 259 int c = 0; 260 int i; 261 262 for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++) 263 c += omap_hwmod_count_resources(oh); 264 265 pr_debug("omap_device: %s: counted %d total resources across %d " 266 "hwmods\n", od->pdev.name, c, od->hwmods_cnt); 267 268 return c; 269} 270 271/** 272 * omap_device_fill_resources - fill in array of struct resource 273 * @od: struct omap_device * 274 * @res: pointer to an array of struct resource to be filled in 275 * 276 * Populate one or more empty struct resource pointed to by @res with 277 * the resource data for this omap_device @od. Used by 278 * omap_device_build_ss() after calling omap_device_count_resources(). 279 * Ideally this function would not be needed at all. If omap_device 280 * replaces platform_device, then we can specify our own 281 * get_resource()/ get_irq()/etc functions that use the underlying 282 * omap_hwmod information. Or if platform_device is extended to use 283 * subarchitecture-specific function pointers, the various 284 * platform_device functions can simply call omap_device internal 285 * functions to get device resources. Hacking around the existing 286 * platform_device code wastes memory. Returns 0. 287 */ 288int omap_device_fill_resources(struct omap_device *od, struct resource *res) 289{ 290 struct omap_hwmod *oh; 291 int c = 0; 292 int i, r; 293 294 for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++) { 295 r = omap_hwmod_fill_resources(oh, res); 296 res += r; 297 c += r; 298 } 299 300 return 0; 301} 302 303/** 304 * omap_device_build - build and register an omap_device with one omap_hwmod 305 * @pdev_name: name of the platform_device driver to use 306 * @pdev_id: this platform_device's connection ID 307 * @oh: ptr to the single omap_hwmod that backs this omap_device 308 * @pdata: platform_data ptr to associate with the platform_device 309 * @pdata_len: amount of memory pointed to by @pdata 310 * @pm_lats: pointer to a omap_device_pm_latency array for this device 311 * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats 312 * @is_early_device: should the device be registered as an early device or not 313 * 314 * Convenience function for building and registering a single 315 * omap_device record, which in turn builds and registers a 316 * platform_device record. See omap_device_build_ss() for more 317 * information. Returns ERR_PTR(-EINVAL) if @oh is NULL; otherwise, 318 * passes along the return value of omap_device_build_ss(). 319 */ 320struct omap_device *omap_device_build(const char *pdev_name, int pdev_id, 321 struct omap_hwmod *oh, void *pdata, 322 int pdata_len, 323 struct omap_device_pm_latency *pm_lats, 324 int pm_lats_cnt, int is_early_device) 325{ 326 struct omap_hwmod *ohs[] = { oh }; 327 328 if (!oh) 329 return ERR_PTR(-EINVAL); 330 331 return omap_device_build_ss(pdev_name, pdev_id, ohs, 1, pdata, 332 pdata_len, pm_lats, pm_lats_cnt, 333 is_early_device); 334} 335 336/** 337 * omap_device_build_ss - build and register an omap_device with multiple hwmods 338 * @pdev_name: name of the platform_device driver to use 339 * @pdev_id: this platform_device's connection ID 340 * @oh: ptr to the single omap_hwmod that backs this omap_device 341 * @pdata: platform_data ptr to associate with the platform_device 342 * @pdata_len: amount of memory pointed to by @pdata 343 * @pm_lats: pointer to a omap_device_pm_latency array for this device 344 * @pm_lats_cnt: ARRAY_SIZE() of @pm_lats 345 * @is_early_device: should the device be registered as an early device or not 346 * 347 * Convenience function for building and registering an omap_device 348 * subsystem record. Subsystem records consist of multiple 349 * omap_hwmods. This function in turn builds and registers a 350 * platform_device record. Returns an ERR_PTR() on error, or passes 351 * along the return value of omap_device_register(). 352 */ 353struct omap_device *omap_device_build_ss(const char *pdev_name, int pdev_id, 354 struct omap_hwmod **ohs, int oh_cnt, 355 void *pdata, int pdata_len, 356 struct omap_device_pm_latency *pm_lats, 357 int pm_lats_cnt, int is_early_device) 358{ 359 int ret = -ENOMEM; 360 struct omap_device *od; 361 char *pdev_name2; 362 struct resource *res = NULL; 363 int i, res_count; 364 struct omap_hwmod **hwmods; 365 366 if (!ohs || oh_cnt == 0 || !pdev_name) 367 return ERR_PTR(-EINVAL); 368 369 if (!pdata && pdata_len > 0) 370 return ERR_PTR(-EINVAL); 371 372 pr_debug("omap_device: %s: building with %d hwmods\n", pdev_name, 373 oh_cnt); 374 375 od = kzalloc(sizeof(struct omap_device), GFP_KERNEL); 376 if (!od) 377 return ERR_PTR(-ENOMEM); 378 379 od->hwmods_cnt = oh_cnt; 380 381 hwmods = kzalloc(sizeof(struct omap_hwmod *) * oh_cnt, 382 GFP_KERNEL); 383 if (!hwmods) 384 goto odbs_exit1; 385 386 memcpy(hwmods, ohs, sizeof(struct omap_hwmod *) * oh_cnt); 387 od->hwmods = hwmods; 388 389 pdev_name2 = kzalloc(strlen(pdev_name) + 1, GFP_KERNEL); 390 if (!pdev_name2) 391 goto odbs_exit2; 392 strcpy(pdev_name2, pdev_name); 393 394 od->pdev.name = pdev_name2; 395 od->pdev.id = pdev_id; 396 397 res_count = omap_device_count_resources(od); 398 if (res_count > 0) { 399 res = kzalloc(sizeof(struct resource) * res_count, GFP_KERNEL); 400 if (!res) 401 goto odbs_exit3; 402 } 403 omap_device_fill_resources(od, res); 404 405 od->pdev.num_resources = res_count; 406 od->pdev.resource = res; 407 408 ret = platform_device_add_data(&od->pdev, pdata, pdata_len); 409 if (ret) 410 goto odbs_exit4; 411 412 od->pm_lats = pm_lats; 413 od->pm_lats_cnt = pm_lats_cnt; 414 415 od->magic = OMAP_DEVICE_MAGIC; 416 417 if (is_early_device) 418 ret = omap_early_device_register(od); 419 else 420 ret = omap_device_register(od); 421 422 for (i = 0; i < oh_cnt; i++) 423 hwmods[i]->od = od; 424 425 if (ret) 426 goto odbs_exit4; 427 428 return od; 429 430odbs_exit4: 431 kfree(res); 432odbs_exit3: 433 kfree(pdev_name2); 434odbs_exit2: 435 kfree(hwmods); 436odbs_exit1: 437 kfree(od); 438 439 pr_err("omap_device: %s: build failed (%d)\n", pdev_name, ret); 440 441 return ERR_PTR(ret); 442} 443 444/** 445 * omap_early_device_register - register an omap_device as an early platform 446 * device. 447 * @od: struct omap_device * to register 448 * 449 * Register the omap_device structure. This currently just calls 450 * platform_early_add_device() on the underlying platform_device. 451 * Returns 0 by default. 452 */ 453int omap_early_device_register(struct omap_device *od) 454{ 455 struct platform_device *devices[1]; 456 457 devices[0] = &(od->pdev); 458 early_platform_add_devices(devices, 1); 459 return 0; 460} 461 462/** 463 * omap_device_register - register an omap_device with one omap_hwmod 464 * @od: struct omap_device * to register 465 * 466 * Register the omap_device structure. This currently just calls 467 * platform_device_register() on the underlying platform_device. 468 * Returns the return value of platform_device_register(). 469 */ 470int omap_device_register(struct omap_device *od) 471{ 472 pr_debug("omap_device: %s: registering\n", od->pdev.name); 473 474 return platform_device_register(&od->pdev); 475} 476 477 478/* Public functions for use by device drivers through struct platform_data */ 479 480/** 481 * omap_device_enable - fully activate an omap_device 482 * @od: struct omap_device * to activate 483 * 484 * Do whatever is necessary for the hwmods underlying omap_device @od 485 * to be accessible and ready to operate. This generally involves 486 * enabling clocks, setting SYSCONFIG registers; and in the future may 487 * involve remuxing pins. Device drivers should call this function 488 * (through platform_data function pointers) where they would normally 489 * enable clocks, etc. Returns -EINVAL if called when the omap_device 490 * is already enabled, or passes along the return value of 491 * _omap_device_activate(). 492 */ 493int omap_device_enable(struct platform_device *pdev) 494{ 495 int ret; 496 struct omap_device *od; 497 498 od = _find_by_pdev(pdev); 499 500 if (od->_state == OMAP_DEVICE_STATE_ENABLED) { 501 WARN(1, "omap_device: %s.%d: %s() called from invalid state %d\n", 502 od->pdev.name, od->pdev.id, __func__, od->_state); 503 return -EINVAL; 504 } 505 506 /* Enable everything if we're enabling this device from scratch */ 507 if (od->_state == OMAP_DEVICE_STATE_UNKNOWN) 508 od->pm_lat_level = od->pm_lats_cnt; 509 510 ret = _omap_device_activate(od, IGNORE_WAKEUP_LAT); 511 512 od->dev_wakeup_lat = 0; 513 od->_dev_wakeup_lat_limit = UINT_MAX; 514 od->_state = OMAP_DEVICE_STATE_ENABLED; 515 516 return ret; 517} 518 519/** 520 * omap_device_idle - idle an omap_device 521 * @od: struct omap_device * to idle 522 * 523 * Idle omap_device @od by calling as many .deactivate_func() entries 524 * in the omap_device's pm_lats table as is possible without exceeding 525 * the device's maximum wakeup latency limit, pm_lat_limit. Device 526 * drivers should call this function (through platform_data function 527 * pointers) where they would normally disable clocks after operations 528 * complete, etc.. Returns -EINVAL if the omap_device is not 529 * currently enabled, or passes along the return value of 530 * _omap_device_deactivate(). 531 */ 532int omap_device_idle(struct platform_device *pdev) 533{ 534 int ret; 535 struct omap_device *od; 536 537 od = _find_by_pdev(pdev); 538 539 if (od->_state != OMAP_DEVICE_STATE_ENABLED) { 540 WARN(1, "omap_device: %s.%d: %s() called from invalid state %d\n", 541 od->pdev.name, od->pdev.id, __func__, od->_state); 542 return -EINVAL; 543 } 544 545 ret = _omap_device_deactivate(od, USE_WAKEUP_LAT); 546 547 od->_state = OMAP_DEVICE_STATE_IDLE; 548 549 return ret; 550} 551 552/** 553 * omap_device_shutdown - shut down an omap_device 554 * @od: struct omap_device * to shut down 555 * 556 * Shut down omap_device @od by calling all .deactivate_func() entries 557 * in the omap_device's pm_lats table and then shutting down all of 558 * the underlying omap_hwmods. Used when a device is being "removed" 559 * or a device driver is being unloaded. Returns -EINVAL if the 560 * omap_device is not currently enabled or idle, or passes along the 561 * return value of _omap_device_deactivate(). 562 */ 563int omap_device_shutdown(struct platform_device *pdev) 564{ 565 int ret, i; 566 struct omap_device *od; 567 struct omap_hwmod *oh; 568 569 od = _find_by_pdev(pdev); 570 571 if (od->_state != OMAP_DEVICE_STATE_ENABLED && 572 od->_state != OMAP_DEVICE_STATE_IDLE) { 573 WARN(1, "omap_device: %s.%d: %s() called from invalid state %d\n", 574 od->pdev.name, od->pdev.id, __func__, od->_state); 575 return -EINVAL; 576 } 577 578 ret = _omap_device_deactivate(od, IGNORE_WAKEUP_LAT); 579 580 for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++) 581 omap_hwmod_shutdown(oh); 582 583 od->_state = OMAP_DEVICE_STATE_SHUTDOWN; 584 585 return ret; 586} 587 588/** 589 * omap_device_align_pm_lat - activate/deactivate device to match wakeup lat lim 590 * @od: struct omap_device * 591 * 592 * When a device's maximum wakeup latency limit changes, call some of 593 * the .activate_func or .deactivate_func function pointers in the 594 * omap_device's pm_lats array to ensure that the device's maximum 595 * wakeup latency is less than or equal to the new latency limit. 596 * Intended to be called by OMAP PM code whenever a device's maximum 597 * wakeup latency limit changes (e.g., via 598 * omap_pm_set_dev_wakeup_lat()). Returns 0 if nothing needs to be 599 * done (e.g., if the omap_device is not currently idle, or if the 600 * wakeup latency is already current with the new limit) or passes 601 * along the return value of _omap_device_deactivate() or 602 * _omap_device_activate(). 603 */ 604int omap_device_align_pm_lat(struct platform_device *pdev, 605 u32 new_wakeup_lat_limit) 606{ 607 int ret = -EINVAL; 608 struct omap_device *od; 609 610 od = _find_by_pdev(pdev); 611 612 if (new_wakeup_lat_limit == od->dev_wakeup_lat) 613 return 0; 614 615 od->_dev_wakeup_lat_limit = new_wakeup_lat_limit; 616 617 if (od->_state != OMAP_DEVICE_STATE_IDLE) 618 return 0; 619 else if (new_wakeup_lat_limit > od->dev_wakeup_lat) 620 ret = _omap_device_deactivate(od, USE_WAKEUP_LAT); 621 else if (new_wakeup_lat_limit < od->dev_wakeup_lat) 622 ret = _omap_device_activate(od, USE_WAKEUP_LAT); 623 624 return ret; 625} 626 627/** 628 * omap_device_is_valid - Check if pointer is a valid omap_device 629 * @od: struct omap_device * 630 * 631 * Return whether struct omap_device pointer @od points to a valid 632 * omap_device. 633 */ 634bool omap_device_is_valid(struct omap_device *od) 635{ 636 return (od && od->magic == OMAP_DEVICE_MAGIC); 637} 638 639/** 640 * omap_device_get_pwrdm - return the powerdomain * associated with @od 641 * @od: struct omap_device * 642 * 643 * Return the powerdomain associated with the first underlying 644 * omap_hwmod for this omap_device. Intended for use by core OMAP PM 645 * code. Returns NULL on error or a struct powerdomain * upon 646 * success. 647 */ 648struct powerdomain *omap_device_get_pwrdm(struct omap_device *od) 649{ 650 if (!od->hwmods_cnt) 651 return NULL; 652 653 return omap_hwmod_get_pwrdm(od->hwmods[0]); 654} 655 656/** 657 * omap_device_get_mpu_rt_va - return the MPU's virtual addr for the hwmod base 658 * @od: struct omap_device * 659 * 660 * Return the MPU's virtual address for the base of the hwmod, from 661 * the ioremap() that the hwmod code does. Only valid if there is one 662 * hwmod associated with this device. Returns NULL if there are zero 663 * or more than one hwmods associated with this omap_device; 664 * otherwise, passes along the return value from 665 * omap_hwmod_get_mpu_rt_va(). 666 */ 667void __iomem *omap_device_get_rt_va(struct omap_device *od) 668{ 669 if (od->hwmods_cnt != 1) 670 return NULL; 671 672 return omap_hwmod_get_mpu_rt_va(od->hwmods[0]); 673} 674 675/* 676 * Public functions intended for use in omap_device_pm_latency 677 * .activate_func and .deactivate_func function pointers 678 */ 679 680/** 681 * omap_device_enable_hwmods - call omap_hwmod_enable() on all hwmods 682 * @od: struct omap_device *od 683 * 684 * Enable all underlying hwmods. Returns 0. 685 */ 686int omap_device_enable_hwmods(struct omap_device *od) 687{ 688 struct omap_hwmod *oh; 689 int i; 690 691 for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++) 692 omap_hwmod_enable(oh); 693 694 return 0; 695} 696 697/** 698 * omap_device_idle_hwmods - call omap_hwmod_idle() on all hwmods 699 * @od: struct omap_device *od 700 * 701 * Idle all underlying hwmods. Returns 0. 702 */ 703int omap_device_idle_hwmods(struct omap_device *od) 704{ 705 struct omap_hwmod *oh; 706 int i; 707 708 for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++) 709 omap_hwmod_idle(oh); 710 711 return 0; 712} 713 714/** 715 * omap_device_disable_clocks - disable all main and interface clocks 716 * @od: struct omap_device *od 717 * 718 * Disable the main functional clock and interface clock for all of the 719 * omap_hwmods associated with the omap_device. Returns 0. 720 */ 721int omap_device_disable_clocks(struct omap_device *od) 722{ 723 struct omap_hwmod *oh; 724 int i; 725 726 for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++) 727 omap_hwmod_disable_clocks(oh); 728 729 return 0; 730} 731 732/** 733 * omap_device_enable_clocks - enable all main and interface clocks 734 * @od: struct omap_device *od 735 * 736 * Enable the main functional clock and interface clock for all of the 737 * omap_hwmods associated with the omap_device. Returns 0. 738 */ 739int omap_device_enable_clocks(struct omap_device *od) 740{ 741 struct omap_hwmod *oh; 742 int i; 743 744 for (i = 0, oh = *od->hwmods; i < od->hwmods_cnt; i++, oh++) 745 omap_hwmod_enable_clocks(oh); 746 747 return 0; 748} 749