reset.h (31684B)
1/* SPDX-License-Identifier: GPL-2.0 */ 2#ifndef _LINUX_RESET_H_ 3#define _LINUX_RESET_H_ 4 5#include <linux/err.h> 6#include <linux/errno.h> 7#include <linux/types.h> 8 9struct device; 10struct device_node; 11struct reset_control; 12 13/** 14 * struct reset_control_bulk_data - Data used for bulk reset control operations. 15 * 16 * @id: reset control consumer ID 17 * @rstc: struct reset_control * to store the associated reset control 18 * 19 * The reset APIs provide a series of reset_control_bulk_*() API calls as 20 * a convenience to consumers which require multiple reset controls. 21 * This structure is used to manage data for these calls. 22 */ 23struct reset_control_bulk_data { 24 const char *id; 25 struct reset_control *rstc; 26}; 27 28#ifdef CONFIG_RESET_CONTROLLER 29 30int reset_control_reset(struct reset_control *rstc); 31int reset_control_rearm(struct reset_control *rstc); 32int reset_control_assert(struct reset_control *rstc); 33int reset_control_deassert(struct reset_control *rstc); 34int reset_control_status(struct reset_control *rstc); 35int reset_control_acquire(struct reset_control *rstc); 36void reset_control_release(struct reset_control *rstc); 37 38int reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs); 39int reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs); 40int reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs); 41int reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs); 42void reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs); 43 44struct reset_control *__of_reset_control_get(struct device_node *node, 45 const char *id, int index, bool shared, 46 bool optional, bool acquired); 47struct reset_control *__reset_control_get(struct device *dev, const char *id, 48 int index, bool shared, 49 bool optional, bool acquired); 50void reset_control_put(struct reset_control *rstc); 51int __reset_control_bulk_get(struct device *dev, int num_rstcs, 52 struct reset_control_bulk_data *rstcs, 53 bool shared, bool optional, bool acquired); 54void reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs); 55 56int __device_reset(struct device *dev, bool optional); 57struct reset_control *__devm_reset_control_get(struct device *dev, 58 const char *id, int index, bool shared, 59 bool optional, bool acquired); 60int __devm_reset_control_bulk_get(struct device *dev, int num_rstcs, 61 struct reset_control_bulk_data *rstcs, 62 bool shared, bool optional, bool acquired); 63 64struct reset_control *devm_reset_control_array_get(struct device *dev, 65 bool shared, bool optional); 66struct reset_control *of_reset_control_array_get(struct device_node *np, 67 bool shared, bool optional, 68 bool acquired); 69 70int reset_control_get_count(struct device *dev); 71 72#else 73 74static inline int reset_control_reset(struct reset_control *rstc) 75{ 76 return 0; 77} 78 79static inline int reset_control_rearm(struct reset_control *rstc) 80{ 81 return 0; 82} 83 84static inline int reset_control_assert(struct reset_control *rstc) 85{ 86 return 0; 87} 88 89static inline int reset_control_deassert(struct reset_control *rstc) 90{ 91 return 0; 92} 93 94static inline int reset_control_status(struct reset_control *rstc) 95{ 96 return 0; 97} 98 99static inline int reset_control_acquire(struct reset_control *rstc) 100{ 101 return 0; 102} 103 104static inline void reset_control_release(struct reset_control *rstc) 105{ 106} 107 108static inline void reset_control_put(struct reset_control *rstc) 109{ 110} 111 112static inline int __device_reset(struct device *dev, bool optional) 113{ 114 return optional ? 0 : -ENOTSUPP; 115} 116 117static inline struct reset_control *__of_reset_control_get( 118 struct device_node *node, 119 const char *id, int index, bool shared, 120 bool optional, bool acquired) 121{ 122 return optional ? NULL : ERR_PTR(-ENOTSUPP); 123} 124 125static inline struct reset_control *__reset_control_get( 126 struct device *dev, const char *id, 127 int index, bool shared, bool optional, 128 bool acquired) 129{ 130 return optional ? NULL : ERR_PTR(-ENOTSUPP); 131} 132 133static inline int 134reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs) 135{ 136 return 0; 137} 138 139static inline int 140reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs) 141{ 142 return 0; 143} 144 145static inline int 146reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs) 147{ 148 return 0; 149} 150 151static inline int 152reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs) 153{ 154 return 0; 155} 156 157static inline void 158reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs) 159{ 160} 161 162static inline int 163__reset_control_bulk_get(struct device *dev, int num_rstcs, 164 struct reset_control_bulk_data *rstcs, 165 bool shared, bool optional, bool acquired) 166{ 167 return optional ? 0 : -EOPNOTSUPP; 168} 169 170static inline void 171reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs) 172{ 173} 174 175static inline struct reset_control *__devm_reset_control_get( 176 struct device *dev, const char *id, 177 int index, bool shared, bool optional, 178 bool acquired) 179{ 180 return optional ? NULL : ERR_PTR(-ENOTSUPP); 181} 182 183static inline int 184__devm_reset_control_bulk_get(struct device *dev, int num_rstcs, 185 struct reset_control_bulk_data *rstcs, 186 bool shared, bool optional, bool acquired) 187{ 188 return optional ? 0 : -EOPNOTSUPP; 189} 190 191static inline struct reset_control * 192devm_reset_control_array_get(struct device *dev, bool shared, bool optional) 193{ 194 return optional ? NULL : ERR_PTR(-ENOTSUPP); 195} 196 197static inline struct reset_control * 198of_reset_control_array_get(struct device_node *np, bool shared, bool optional, 199 bool acquired) 200{ 201 return optional ? NULL : ERR_PTR(-ENOTSUPP); 202} 203 204static inline int reset_control_get_count(struct device *dev) 205{ 206 return -ENOENT; 207} 208 209#endif /* CONFIG_RESET_CONTROLLER */ 210 211static inline int __must_check device_reset(struct device *dev) 212{ 213 return __device_reset(dev, false); 214} 215 216static inline int device_reset_optional(struct device *dev) 217{ 218 return __device_reset(dev, true); 219} 220 221/** 222 * reset_control_get_exclusive - Lookup and obtain an exclusive reference 223 * to a reset controller. 224 * @dev: device to be reset by the controller 225 * @id: reset line name 226 * 227 * Returns a struct reset_control or IS_ERR() condition containing errno. 228 * If this function is called more than once for the same reset_control it will 229 * return -EBUSY. 230 * 231 * See reset_control_get_shared() for details on shared references to 232 * reset-controls. 233 * 234 * Use of id names is optional. 235 */ 236static inline struct reset_control * 237__must_check reset_control_get_exclusive(struct device *dev, const char *id) 238{ 239 return __reset_control_get(dev, id, 0, false, false, true); 240} 241 242/** 243 * reset_control_bulk_get_exclusive - Lookup and obtain exclusive references to 244 * multiple reset controllers. 245 * @dev: device to be reset by the controller 246 * @num_rstcs: number of entries in rstcs array 247 * @rstcs: array of struct reset_control_bulk_data with reset line names set 248 * 249 * Fills the rstcs array with pointers to exclusive reset controls and 250 * returns 0, or an IS_ERR() condition containing errno. 251 */ 252static inline int __must_check 253reset_control_bulk_get_exclusive(struct device *dev, int num_rstcs, 254 struct reset_control_bulk_data *rstcs) 255{ 256 return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, true); 257} 258 259/** 260 * reset_control_get_exclusive_released - Lookup and obtain a temoprarily 261 * exclusive reference to a reset 262 * controller. 263 * @dev: device to be reset by the controller 264 * @id: reset line name 265 * 266 * Returns a struct reset_control or IS_ERR() condition containing errno. 267 * reset-controls returned by this function must be acquired via 268 * reset_control_acquire() before they can be used and should be released 269 * via reset_control_release() afterwards. 270 * 271 * Use of id names is optional. 272 */ 273static inline struct reset_control * 274__must_check reset_control_get_exclusive_released(struct device *dev, 275 const char *id) 276{ 277 return __reset_control_get(dev, id, 0, false, false, false); 278} 279 280/** 281 * reset_control_bulk_get_exclusive_released - Lookup and obtain temporarily 282 * exclusive references to multiple reset 283 * controllers. 284 * @dev: device to be reset by the controller 285 * @num_rstcs: number of entries in rstcs array 286 * @rstcs: array of struct reset_control_bulk_data with reset line names set 287 * 288 * Fills the rstcs array with pointers to exclusive reset controls and 289 * returns 0, or an IS_ERR() condition containing errno. 290 * reset-controls returned by this function must be acquired via 291 * reset_control_bulk_acquire() before they can be used and should be released 292 * via reset_control_bulk_release() afterwards. 293 */ 294static inline int __must_check 295reset_control_bulk_get_exclusive_released(struct device *dev, int num_rstcs, 296 struct reset_control_bulk_data *rstcs) 297{ 298 return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, false); 299} 300 301/** 302 * reset_control_bulk_get_optional_exclusive_released - Lookup and obtain optional 303 * temporarily exclusive references to multiple 304 * reset controllers. 305 * @dev: device to be reset by the controller 306 * @num_rstcs: number of entries in rstcs array 307 * @rstcs: array of struct reset_control_bulk_data with reset line names set 308 * 309 * Optional variant of reset_control_bulk_get_exclusive_released(). If the 310 * requested reset is not specified in the device tree, this function returns 0 311 * instead of an error and missing rtsc is set to NULL. 312 * 313 * See reset_control_bulk_get_exclusive_released() for more information. 314 */ 315static inline int __must_check 316reset_control_bulk_get_optional_exclusive_released(struct device *dev, int num_rstcs, 317 struct reset_control_bulk_data *rstcs) 318{ 319 return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, false); 320} 321 322/** 323 * reset_control_get_shared - Lookup and obtain a shared reference to a 324 * reset controller. 325 * @dev: device to be reset by the controller 326 * @id: reset line name 327 * 328 * Returns a struct reset_control or IS_ERR() condition containing errno. 329 * This function is intended for use with reset-controls which are shared 330 * between hardware blocks. 331 * 332 * When a reset-control is shared, the behavior of reset_control_assert / 333 * deassert is changed, the reset-core will keep track of a deassert_count 334 * and only (re-)assert the reset after reset_control_assert has been called 335 * as many times as reset_control_deassert was called. Also see the remark 336 * about shared reset-controls in the reset_control_assert docs. 337 * 338 * Calling reset_control_assert without first calling reset_control_deassert 339 * is not allowed on a shared reset control. Calling reset_control_reset is 340 * also not allowed on a shared reset control. 341 * 342 * Use of id names is optional. 343 */ 344static inline struct reset_control *reset_control_get_shared( 345 struct device *dev, const char *id) 346{ 347 return __reset_control_get(dev, id, 0, true, false, false); 348} 349 350/** 351 * reset_control_bulk_get_shared - Lookup and obtain shared references to 352 * multiple reset controllers. 353 * @dev: device to be reset by the controller 354 * @num_rstcs: number of entries in rstcs array 355 * @rstcs: array of struct reset_control_bulk_data with reset line names set 356 * 357 * Fills the rstcs array with pointers to shared reset controls and 358 * returns 0, or an IS_ERR() condition containing errno. 359 */ 360static inline int __must_check 361reset_control_bulk_get_shared(struct device *dev, int num_rstcs, 362 struct reset_control_bulk_data *rstcs) 363{ 364 return __reset_control_bulk_get(dev, num_rstcs, rstcs, true, false, false); 365} 366 367/** 368 * reset_control_get_optional_exclusive - optional reset_control_get_exclusive() 369 * @dev: device to be reset by the controller 370 * @id: reset line name 371 * 372 * Optional variant of reset_control_get_exclusive(). If the requested reset 373 * is not specified in the device tree, this function returns NULL instead of 374 * an error. 375 * 376 * See reset_control_get_exclusive() for more information. 377 */ 378static inline struct reset_control *reset_control_get_optional_exclusive( 379 struct device *dev, const char *id) 380{ 381 return __reset_control_get(dev, id, 0, false, true, true); 382} 383 384/** 385 * reset_control_bulk_get_optional_exclusive - optional 386 * reset_control_bulk_get_exclusive() 387 * @dev: device to be reset by the controller 388 * @num_rstcs: number of entries in rstcs array 389 * @rstcs: array of struct reset_control_bulk_data with reset line names set 390 * 391 * Optional variant of reset_control_bulk_get_exclusive(). If any of the 392 * requested resets are not specified in the device tree, this function sets 393 * them to NULL instead of returning an error. 394 * 395 * See reset_control_bulk_get_exclusive() for more information. 396 */ 397static inline int __must_check 398reset_control_bulk_get_optional_exclusive(struct device *dev, int num_rstcs, 399 struct reset_control_bulk_data *rstcs) 400{ 401 return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, true); 402} 403 404/** 405 * reset_control_get_optional_shared - optional reset_control_get_shared() 406 * @dev: device to be reset by the controller 407 * @id: reset line name 408 * 409 * Optional variant of reset_control_get_shared(). If the requested reset 410 * is not specified in the device tree, this function returns NULL instead of 411 * an error. 412 * 413 * See reset_control_get_shared() for more information. 414 */ 415static inline struct reset_control *reset_control_get_optional_shared( 416 struct device *dev, const char *id) 417{ 418 return __reset_control_get(dev, id, 0, true, true, false); 419} 420 421/** 422 * reset_control_bulk_get_optional_shared - optional 423 * reset_control_bulk_get_shared() 424 * @dev: device to be reset by the controller 425 * @num_rstcs: number of entries in rstcs array 426 * @rstcs: array of struct reset_control_bulk_data with reset line names set 427 * 428 * Optional variant of reset_control_bulk_get_shared(). If the requested resets 429 * are not specified in the device tree, this function sets them to NULL 430 * instead of returning an error. 431 * 432 * See reset_control_bulk_get_shared() for more information. 433 */ 434static inline int __must_check 435reset_control_bulk_get_optional_shared(struct device *dev, int num_rstcs, 436 struct reset_control_bulk_data *rstcs) 437{ 438 return __reset_control_bulk_get(dev, num_rstcs, rstcs, true, true, false); 439} 440 441/** 442 * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference 443 * to a reset controller. 444 * @node: device to be reset by the controller 445 * @id: reset line name 446 * 447 * Returns a struct reset_control or IS_ERR() condition containing errno. 448 * 449 * Use of id names is optional. 450 */ 451static inline struct reset_control *of_reset_control_get_exclusive( 452 struct device_node *node, const char *id) 453{ 454 return __of_reset_control_get(node, id, 0, false, false, true); 455} 456 457/** 458 * of_reset_control_get_optional_exclusive - Lookup and obtain an optional exclusive 459 * reference to a reset controller. 460 * @node: device to be reset by the controller 461 * @id: reset line name 462 * 463 * Optional variant of of_reset_control_get_exclusive(). If the requested reset 464 * is not specified in the device tree, this function returns NULL instead of 465 * an error. 466 * 467 * Returns a struct reset_control or IS_ERR() condition containing errno. 468 * 469 * Use of id names is optional. 470 */ 471static inline struct reset_control *of_reset_control_get_optional_exclusive( 472 struct device_node *node, const char *id) 473{ 474 return __of_reset_control_get(node, id, 0, false, true, true); 475} 476 477/** 478 * of_reset_control_get_shared - Lookup and obtain a shared reference 479 * to a reset controller. 480 * @node: device to be reset by the controller 481 * @id: reset line name 482 * 483 * When a reset-control is shared, the behavior of reset_control_assert / 484 * deassert is changed, the reset-core will keep track of a deassert_count 485 * and only (re-)assert the reset after reset_control_assert has been called 486 * as many times as reset_control_deassert was called. Also see the remark 487 * about shared reset-controls in the reset_control_assert docs. 488 * 489 * Calling reset_control_assert without first calling reset_control_deassert 490 * is not allowed on a shared reset control. Calling reset_control_reset is 491 * also not allowed on a shared reset control. 492 * Returns a struct reset_control or IS_ERR() condition containing errno. 493 * 494 * Use of id names is optional. 495 */ 496static inline struct reset_control *of_reset_control_get_shared( 497 struct device_node *node, const char *id) 498{ 499 return __of_reset_control_get(node, id, 0, true, false, false); 500} 501 502/** 503 * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive 504 * reference to a reset controller 505 * by index. 506 * @node: device to be reset by the controller 507 * @index: index of the reset controller 508 * 509 * This is to be used to perform a list of resets for a device or power domain 510 * in whatever order. Returns a struct reset_control or IS_ERR() condition 511 * containing errno. 512 */ 513static inline struct reset_control *of_reset_control_get_exclusive_by_index( 514 struct device_node *node, int index) 515{ 516 return __of_reset_control_get(node, NULL, index, false, false, true); 517} 518 519/** 520 * of_reset_control_get_shared_by_index - Lookup and obtain a shared 521 * reference to a reset controller 522 * by index. 523 * @node: device to be reset by the controller 524 * @index: index of the reset controller 525 * 526 * When a reset-control is shared, the behavior of reset_control_assert / 527 * deassert is changed, the reset-core will keep track of a deassert_count 528 * and only (re-)assert the reset after reset_control_assert has been called 529 * as many times as reset_control_deassert was called. Also see the remark 530 * about shared reset-controls in the reset_control_assert docs. 531 * 532 * Calling reset_control_assert without first calling reset_control_deassert 533 * is not allowed on a shared reset control. Calling reset_control_reset is 534 * also not allowed on a shared reset control. 535 * Returns a struct reset_control or IS_ERR() condition containing errno. 536 * 537 * This is to be used to perform a list of resets for a device or power domain 538 * in whatever order. Returns a struct reset_control or IS_ERR() condition 539 * containing errno. 540 */ 541static inline struct reset_control *of_reset_control_get_shared_by_index( 542 struct device_node *node, int index) 543{ 544 return __of_reset_control_get(node, NULL, index, true, false, false); 545} 546 547/** 548 * devm_reset_control_get_exclusive - resource managed 549 * reset_control_get_exclusive() 550 * @dev: device to be reset by the controller 551 * @id: reset line name 552 * 553 * Managed reset_control_get_exclusive(). For reset controllers returned 554 * from this function, reset_control_put() is called automatically on driver 555 * detach. 556 * 557 * See reset_control_get_exclusive() for more information. 558 */ 559static inline struct reset_control * 560__must_check devm_reset_control_get_exclusive(struct device *dev, 561 const char *id) 562{ 563 return __devm_reset_control_get(dev, id, 0, false, false, true); 564} 565 566/** 567 * devm_reset_control_bulk_get_exclusive - resource managed 568 * reset_control_bulk_get_exclusive() 569 * @dev: device to be reset by the controller 570 * @num_rstcs: number of entries in rstcs array 571 * @rstcs: array of struct reset_control_bulk_data with reset line names set 572 * 573 * Managed reset_control_bulk_get_exclusive(). For reset controllers returned 574 * from this function, reset_control_put() is called automatically on driver 575 * detach. 576 * 577 * See reset_control_bulk_get_exclusive() for more information. 578 */ 579static inline int __must_check 580devm_reset_control_bulk_get_exclusive(struct device *dev, int num_rstcs, 581 struct reset_control_bulk_data *rstcs) 582{ 583 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, true); 584} 585 586/** 587 * devm_reset_control_get_exclusive_released - resource managed 588 * reset_control_get_exclusive_released() 589 * @dev: device to be reset by the controller 590 * @id: reset line name 591 * 592 * Managed reset_control_get_exclusive_released(). For reset controllers 593 * returned from this function, reset_control_put() is called automatically on 594 * driver detach. 595 * 596 * See reset_control_get_exclusive_released() for more information. 597 */ 598static inline struct reset_control * 599__must_check devm_reset_control_get_exclusive_released(struct device *dev, 600 const char *id) 601{ 602 return __devm_reset_control_get(dev, id, 0, false, false, false); 603} 604 605/** 606 * devm_reset_control_bulk_get_exclusive_released - resource managed 607 * reset_control_bulk_get_exclusive_released() 608 * @dev: device to be reset by the controller 609 * @num_rstcs: number of entries in rstcs array 610 * @rstcs: array of struct reset_control_bulk_data with reset line names set 611 * 612 * Managed reset_control_bulk_get_exclusive_released(). For reset controllers 613 * returned from this function, reset_control_put() is called automatically on 614 * driver detach. 615 * 616 * See reset_control_bulk_get_exclusive_released() for more information. 617 */ 618static inline int __must_check 619devm_reset_control_bulk_get_exclusive_released(struct device *dev, int num_rstcs, 620 struct reset_control_bulk_data *rstcs) 621{ 622 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, false); 623} 624 625/** 626 * devm_reset_control_get_optional_exclusive_released - resource managed 627 * reset_control_get_optional_exclusive_released() 628 * @dev: device to be reset by the controller 629 * @id: reset line name 630 * 631 * Managed-and-optional variant of reset_control_get_exclusive_released(). For 632 * reset controllers returned from this function, reset_control_put() is called 633 * automatically on driver detach. 634 * 635 * See reset_control_get_exclusive_released() for more information. 636 */ 637static inline struct reset_control * 638__must_check devm_reset_control_get_optional_exclusive_released(struct device *dev, 639 const char *id) 640{ 641 return __devm_reset_control_get(dev, id, 0, false, true, false); 642} 643 644/** 645 * devm_reset_control_bulk_get_optional_exclusive_released - resource managed 646 * reset_control_bulk_optional_get_exclusive_released() 647 * @dev: device to be reset by the controller 648 * @num_rstcs: number of entries in rstcs array 649 * @rstcs: array of struct reset_control_bulk_data with reset line names set 650 * 651 * Managed reset_control_bulk_optional_get_exclusive_released(). For reset 652 * controllers returned from this function, reset_control_put() is called 653 * automatically on driver detach. 654 * 655 * See reset_control_bulk_optional_get_exclusive_released() for more information. 656 */ 657static inline int __must_check 658devm_reset_control_bulk_get_optional_exclusive_released(struct device *dev, int num_rstcs, 659 struct reset_control_bulk_data *rstcs) 660{ 661 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, false); 662} 663 664/** 665 * devm_reset_control_get_shared - resource managed reset_control_get_shared() 666 * @dev: device to be reset by the controller 667 * @id: reset line name 668 * 669 * Managed reset_control_get_shared(). For reset controllers returned from 670 * this function, reset_control_put() is called automatically on driver detach. 671 * See reset_control_get_shared() for more information. 672 */ 673static inline struct reset_control *devm_reset_control_get_shared( 674 struct device *dev, const char *id) 675{ 676 return __devm_reset_control_get(dev, id, 0, true, false, false); 677} 678 679/** 680 * devm_reset_control_bulk_get_shared - resource managed 681 * reset_control_bulk_get_shared() 682 * @dev: device to be reset by the controller 683 * @num_rstcs: number of entries in rstcs array 684 * @rstcs: array of struct reset_control_bulk_data with reset line names set 685 * 686 * Managed reset_control_bulk_get_shared(). For reset controllers returned 687 * from this function, reset_control_put() is called automatically on driver 688 * detach. 689 * 690 * See reset_control_bulk_get_shared() for more information. 691 */ 692static inline int __must_check 693devm_reset_control_bulk_get_shared(struct device *dev, int num_rstcs, 694 struct reset_control_bulk_data *rstcs) 695{ 696 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, true, false, false); 697} 698 699/** 700 * devm_reset_control_get_optional_exclusive - resource managed 701 * reset_control_get_optional_exclusive() 702 * @dev: device to be reset by the controller 703 * @id: reset line name 704 * 705 * Managed reset_control_get_optional_exclusive(). For reset controllers 706 * returned from this function, reset_control_put() is called automatically on 707 * driver detach. 708 * 709 * See reset_control_get_optional_exclusive() for more information. 710 */ 711static inline struct reset_control *devm_reset_control_get_optional_exclusive( 712 struct device *dev, const char *id) 713{ 714 return __devm_reset_control_get(dev, id, 0, false, true, true); 715} 716 717/** 718 * devm_reset_control_bulk_get_optional_exclusive - resource managed 719 * reset_control_bulk_get_optional_exclusive() 720 * @dev: device to be reset by the controller 721 * @num_rstcs: number of entries in rstcs array 722 * @rstcs: array of struct reset_control_bulk_data with reset line names set 723 * 724 * Managed reset_control_bulk_get_optional_exclusive(). For reset controllers 725 * returned from this function, reset_control_put() is called automatically on 726 * driver detach. 727 * 728 * See reset_control_bulk_get_optional_exclusive() for more information. 729 */ 730static inline int __must_check 731devm_reset_control_bulk_get_optional_exclusive(struct device *dev, int num_rstcs, 732 struct reset_control_bulk_data *rstcs) 733{ 734 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, true, false, true); 735} 736 737/** 738 * devm_reset_control_get_optional_shared - resource managed 739 * reset_control_get_optional_shared() 740 * @dev: device to be reset by the controller 741 * @id: reset line name 742 * 743 * Managed reset_control_get_optional_shared(). For reset controllers returned 744 * from this function, reset_control_put() is called automatically on driver 745 * detach. 746 * 747 * See reset_control_get_optional_shared() for more information. 748 */ 749static inline struct reset_control *devm_reset_control_get_optional_shared( 750 struct device *dev, const char *id) 751{ 752 return __devm_reset_control_get(dev, id, 0, true, true, false); 753} 754 755/** 756 * devm_reset_control_bulk_get_optional_shared - resource managed 757 * reset_control_bulk_get_optional_shared() 758 * @dev: device to be reset by the controller 759 * @num_rstcs: number of entries in rstcs array 760 * @rstcs: array of struct reset_control_bulk_data with reset line names set 761 * 762 * Managed reset_control_bulk_get_optional_shared(). For reset controllers 763 * returned from this function, reset_control_put() is called automatically on 764 * driver detach. 765 * 766 * See reset_control_bulk_get_optional_shared() for more information. 767 */ 768static inline int __must_check 769devm_reset_control_bulk_get_optional_shared(struct device *dev, int num_rstcs, 770 struct reset_control_bulk_data *rstcs) 771{ 772 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, true, true, false); 773} 774 775/** 776 * devm_reset_control_get_exclusive_by_index - resource managed 777 * reset_control_get_exclusive() 778 * @dev: device to be reset by the controller 779 * @index: index of the reset controller 780 * 781 * Managed reset_control_get_exclusive(). For reset controllers returned from 782 * this function, reset_control_put() is called automatically on driver 783 * detach. 784 * 785 * See reset_control_get_exclusive() for more information. 786 */ 787static inline struct reset_control * 788devm_reset_control_get_exclusive_by_index(struct device *dev, int index) 789{ 790 return __devm_reset_control_get(dev, NULL, index, false, false, true); 791} 792 793/** 794 * devm_reset_control_get_shared_by_index - resource managed 795 * reset_control_get_shared 796 * @dev: device to be reset by the controller 797 * @index: index of the reset controller 798 * 799 * Managed reset_control_get_shared(). For reset controllers returned from 800 * this function, reset_control_put() is called automatically on driver detach. 801 * See reset_control_get_shared() for more information. 802 */ 803static inline struct reset_control * 804devm_reset_control_get_shared_by_index(struct device *dev, int index) 805{ 806 return __devm_reset_control_get(dev, NULL, index, true, false, false); 807} 808 809/* 810 * TEMPORARY calls to use during transition: 811 * 812 * of_reset_control_get() => of_reset_control_get_exclusive() 813 * 814 * These inline function calls will be removed once all consumers 815 * have been moved over to the new explicit API. 816 */ 817static inline struct reset_control *of_reset_control_get( 818 struct device_node *node, const char *id) 819{ 820 return of_reset_control_get_exclusive(node, id); 821} 822 823static inline struct reset_control *of_reset_control_get_by_index( 824 struct device_node *node, int index) 825{ 826 return of_reset_control_get_exclusive_by_index(node, index); 827} 828 829static inline struct reset_control *devm_reset_control_get( 830 struct device *dev, const char *id) 831{ 832 return devm_reset_control_get_exclusive(dev, id); 833} 834 835static inline struct reset_control *devm_reset_control_get_optional( 836 struct device *dev, const char *id) 837{ 838 return devm_reset_control_get_optional_exclusive(dev, id); 839 840} 841 842static inline struct reset_control *devm_reset_control_get_by_index( 843 struct device *dev, int index) 844{ 845 return devm_reset_control_get_exclusive_by_index(dev, index); 846} 847 848/* 849 * APIs to manage a list of reset controllers 850 */ 851static inline struct reset_control * 852devm_reset_control_array_get_exclusive(struct device *dev) 853{ 854 return devm_reset_control_array_get(dev, false, false); 855} 856 857static inline struct reset_control * 858devm_reset_control_array_get_shared(struct device *dev) 859{ 860 return devm_reset_control_array_get(dev, true, false); 861} 862 863static inline struct reset_control * 864devm_reset_control_array_get_optional_exclusive(struct device *dev) 865{ 866 return devm_reset_control_array_get(dev, false, true); 867} 868 869static inline struct reset_control * 870devm_reset_control_array_get_optional_shared(struct device *dev) 871{ 872 return devm_reset_control_array_get(dev, true, true); 873} 874 875static inline struct reset_control * 876of_reset_control_array_get_exclusive(struct device_node *node) 877{ 878 return of_reset_control_array_get(node, false, false, true); 879} 880 881static inline struct reset_control * 882of_reset_control_array_get_exclusive_released(struct device_node *node) 883{ 884 return of_reset_control_array_get(node, false, false, false); 885} 886 887static inline struct reset_control * 888of_reset_control_array_get_shared(struct device_node *node) 889{ 890 return of_reset_control_array_get(node, true, false, true); 891} 892 893static inline struct reset_control * 894of_reset_control_array_get_optional_exclusive(struct device_node *node) 895{ 896 return of_reset_control_array_get(node, false, true, true); 897} 898 899static inline struct reset_control * 900of_reset_control_array_get_optional_shared(struct device_node *node) 901{ 902 return of_reset_control_array_get(node, true, true, true); 903} 904#endif