1#- 2# Copyright (c) 1998-2004 Doug Rabson 3# All rights reserved. 4# 5# Redistribution and use in source and binary forms, with or without 6# modification, are permitted provided that the following conditions 7# are met: 8# 1. Redistributions of source code must retain the above copyright 9# notice, this list of conditions and the following disclaimer. 10# 2. Redistributions in binary form must reproduce the above copyright 11# notice, this list of conditions and the following disclaimer in the 12# documentation and/or other materials provided with the distribution. 13# 14# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24# SUCH DAMAGE. 25# 26# $FreeBSD$ 27# 28 29#include <sys/types.h> 30#include <sys/systm.h> 31#include <sys/bus.h> 32 33/** 34 * @defgroup BUS bus - KObj methods for drivers of devices with children 35 * @brief A set of methods required device drivers that support 36 * child devices. 37 * @{ 38 */ 39INTERFACE bus; 40 41# 42# Default implementations of some methods. 43# 44CODE { 45 static struct resource * 46 null_alloc_resource(device_t dev, device_t child, 47 int type, int *rid, rman_res_t start, rman_res_t end, 48 rman_res_t count, u_int flags) 49 { 50 return (0); 51 } 52 53 static int 54 null_remap_intr(device_t bus, device_t dev, u_int irq) 55 { 56 57 if (dev != NULL) 58 return (BUS_REMAP_INTR(dev, NULL, irq)); 59 return (ENXIO); 60 } 61 62 static device_t 63 null_add_child(device_t bus, int order, const char *name, 64 int unit) 65 { 66 67 panic("bus_add_child is not implemented"); 68 } 69 70 static int null_reset_post(device_t bus, device_t dev) 71 { 72 return (0); 73 } 74 75 static int null_reset_prepare(device_t bus, device_t dev) 76 { 77 return (0); 78 } 79}; 80 81/** 82 * @brief Print a description of a child device 83 * 84 * This is called from system code which prints out a description of a 85 * device. It should describe the attachment that the child has with 86 * the parent. For instance the TurboLaser bus prints which node the 87 * device is attached to. See bus_generic_print_child() for more 88 * information. 89 * 90 * @param _dev the device whose child is being printed 91 * @param _child the child device to describe 92 * 93 * @returns the number of characters output. 94 */ 95METHOD int print_child { 96 device_t _dev; 97 device_t _child; 98} DEFAULT bus_generic_print_child; 99 100/** 101 * @brief Print a notification about an unprobed child device. 102 * 103 * Called for each child device that did not succeed in probing for a 104 * driver. 105 * 106 * @param _dev the device whose child was being probed 107 * @param _child the child device which failed to probe 108 */ 109METHOD void probe_nomatch { 110 device_t _dev; 111 device_t _child; 112}; 113 114/** 115 * @brief Read the value of a bus-specific attribute of a device 116 * 117 * This method, along with BUS_WRITE_IVAR() manages a bus-specific set 118 * of instance variables of a child device. The intention is that 119 * each different type of bus defines a set of appropriate instance 120 * variables (such as ports and irqs for ISA bus etc.) 121 * 122 * This information could be given to the child device as a struct but 123 * that makes it hard for a bus to add or remove variables without 124 * forcing an edit and recompile for all drivers which may not be 125 * possible for vendor supplied binary drivers. 126 * 127 * This method copies the value of an instance variable to the 128 * location specified by @p *_result. 129 * 130 * @param _dev the device whose child was being examined 131 * @param _child the child device whose instance variable is 132 * being read 133 * @param _index the instance variable to read 134 * @param _result a location to receive the instance variable 135 * value 136 * 137 * @retval 0 success 138 * @retval ENOENT no such instance variable is supported by @p 139 * _dev 140 */ 141METHOD int read_ivar { 142 device_t _dev; 143 device_t _child; 144 int _index; 145 uintptr_t *_result; 146}; 147 148/** 149 * @brief Write the value of a bus-specific attribute of a device 150 * 151 * This method sets the value of an instance variable to @p _value. 152 * 153 * @param _dev the device whose child was being updated 154 * @param _child the child device whose instance variable is 155 * being written 156 * @param _index the instance variable to write 157 * @param _value the value to write to that instance variable 158 * 159 * @retval 0 success 160 * @retval ENOENT no such instance variable is supported by @p 161 * _dev 162 * @retval EINVAL the instance variable was recognised but 163 * contains a read-only value 164 */ 165METHOD int write_ivar { 166 device_t _dev; 167 device_t _child; 168 int _indx; 169 uintptr_t _value; 170}; 171 172/** 173 * @brief Notify a bus that a child was deleted 174 * 175 * Called at the beginning of device_delete_child() to allow the parent 176 * to teardown any bus-specific state for the child. 177 * 178 * @param _dev the device whose child is being deleted 179 * @param _child the child device which is being deleted 180 */ 181METHOD void child_deleted { 182 device_t _dev; 183 device_t _child; 184}; 185 186/** 187 * @brief Notify a bus that a child was detached 188 * 189 * Called after the child's DEVICE_DETACH() method to allow the parent 190 * to reclaim any resources allocated on behalf of the child. 191 * 192 * @param _dev the device whose child changed state 193 * @param _child the child device which changed state 194 */ 195METHOD void child_detached { 196 device_t _dev; 197 device_t _child; 198}; 199 200/** 201 * @brief Notify a bus that a new driver was added 202 * 203 * Called when a new driver is added to the devclass which owns this 204 * bus. The generic implementation of this method attempts to probe and 205 * attach any un-matched children of the bus. 206 * 207 * @param _dev the device whose devclass had a new driver 208 * added to it 209 * @param _driver the new driver which was added 210 */ 211METHOD void driver_added { 212 device_t _dev; 213 driver_t *_driver; 214} DEFAULT bus_generic_driver_added; 215 216/** 217 * @brief Create a new child device 218 * 219 * For buses which use use drivers supporting DEVICE_IDENTIFY() to 220 * enumerate their devices, this method is used to create new 221 * device instances. The new device will be added after the last 222 * existing child with the same order. Implementations of bus_add_child 223 * call device_add_child_ordered to add the child and often add 224 * a suitable ivar to the device specific to that bus. 225 * 226 * @param _dev the bus device which will be the parent of the 227 * new child device 228 * @param _order a value which is used to partially sort the 229 * children of @p _dev - devices created using 230 * lower values of @p _order appear first in @p 231 * _dev's list of children 232 * @param _name devclass name for new device or @c NULL if not 233 * specified 234 * @param _unit unit number for new device or @c -1 if not 235 * specified 236 */ 237METHOD device_t add_child { 238 device_t _dev; 239 u_int _order; 240 const char *_name; 241 int _unit; 242} DEFAULT null_add_child; 243 244/** 245 * @brief Rescan the bus 246 * 247 * This method is called by a parent bridge or devctl to trigger a bus 248 * rescan. The rescan should delete devices no longer present and 249 * enumerate devices that have newly arrived. 250 * 251 * @param _dev the bus device 252 */ 253METHOD int rescan { 254 device_t _dev; 255} 256 257/** 258 * @brief Allocate a system resource 259 * 260 * This method is called by child devices of a bus to allocate resources. 261 * The types are defined in <machine/resource.h>; the meaning of the 262 * resource-ID field varies from bus to bus (but @p *rid == 0 is always 263 * valid if the resource type is). If a resource was allocated and the 264 * caller did not use the RF_ACTIVE to specify that it should be 265 * activated immediately, the caller is responsible for calling 266 * BUS_ACTIVATE_RESOURCE() when it actually uses the resource. 267 * 268 * @param _dev the parent device of @p _child 269 * @param _child the device which is requesting an allocation 270 * @param _type the type of resource to allocate 271 * @param _rid a pointer to the resource identifier 272 * @param _start hint at the start of the resource range - pass 273 * @c 0 for any start address 274 * @param _end hint at the end of the resource range - pass 275 * @c ~0 for any end address 276 * @param _count hint at the size of range required - pass @c 1 277 * for any size 278 * @param _flags any extra flags to control the resource 279 * allocation - see @c RF_XXX flags in 280 * <sys/rman.h> for details 281 * 282 * @returns the resource which was allocated or @c NULL if no 283 * resource could be allocated 284 */ 285METHOD struct resource * alloc_resource { 286 device_t _dev; 287 device_t _child; 288 int _type; 289 int *_rid; 290 rman_res_t _start; 291 rman_res_t _end; 292 rman_res_t _count; 293 u_int _flags; 294} DEFAULT null_alloc_resource; 295 296/** 297 * @brief Activate a resource 298 * 299 * Activate a resource previously allocated with 300 * BUS_ALLOC_RESOURCE(). This may enable decoding of this resource in a 301 * device for instance. It will also establish a mapping for the resource 302 * unless RF_UNMAPPED was set when allocating the resource. 303 * 304 * @param _dev the parent device of @p _child 305 * @param _child the device which allocated the resource 306 * @param _type the type of resource 307 * @param _rid the resource identifier 308 * @param _r the resource to activate 309 */ 310METHOD int activate_resource { 311 device_t _dev; 312 device_t _child; 313 int _type; 314 int _rid; 315 struct resource *_r; 316}; 317 318 319/** 320 * @brief Map a resource 321 * 322 * Allocate a mapping for a range of an active resource. The mapping 323 * is described by a struct resource_map object. This may for instance 324 * map a memory region into the kernel's virtual address space. 325 * 326 * @param _dev the parent device of @p _child 327 * @param _child the device which allocated the resource 328 * @param _type the type of resource 329 * @param _r the resource to map 330 * @param _args optional attributes of the mapping 331 * @param _map the mapping 332 */ 333METHOD int map_resource { 334 device_t _dev; 335 device_t _child; 336 int _type; 337 struct resource *_r; 338 struct resource_map_request *_args; 339 struct resource_map *_map; 340} DEFAULT bus_generic_map_resource; 341 342 343/** 344 * @brief Unmap a resource 345 * 346 * Release a mapping previously allocated with 347 * BUS_MAP_RESOURCE(). This may for instance unmap a memory region 348 * from the kernel's virtual address space. 349 * 350 * @param _dev the parent device of @p _child 351 * @param _child the device which allocated the resource 352 * @param _type the type of resource 353 * @param _r the resource 354 * @param _map the mapping to release 355 */ 356METHOD int unmap_resource { 357 device_t _dev; 358 device_t _child; 359 int _type; 360 struct resource *_r; 361 struct resource_map *_map; 362} DEFAULT bus_generic_unmap_resource; 363 364 365/** 366 * @brief Deactivate a resource 367 * 368 * Deactivate a resource previously allocated with 369 * BUS_ALLOC_RESOURCE(). 370 * 371 * @param _dev the parent device of @p _child 372 * @param _child the device which allocated the resource 373 * @param _type the type of resource 374 * @param _rid the resource identifier 375 * @param _r the resource to deactivate 376 */ 377METHOD int deactivate_resource { 378 device_t _dev; 379 device_t _child; 380 int _type; 381 int _rid; 382 struct resource *_r; 383}; 384 385/** 386 * @brief Adjust a resource 387 * 388 * Adjust the start and/or end of a resource allocated by 389 * BUS_ALLOC_RESOURCE. At least part of the new address range must overlap 390 * with the existing address range. If the successful, the resource's range 391 * will be adjusted to [start, end] on return. 392 * 393 * @param _dev the parent device of @p _child 394 * @param _child the device which allocated the resource 395 * @param _type the type of resource 396 * @param _res the resource to adjust 397 * @param _start the new starting address of the resource range 398 * @param _end the new ending address of the resource range 399 */ 400METHOD int adjust_resource { 401 device_t _dev; 402 device_t _child; 403 int _type; 404 struct resource *_res; 405 rman_res_t _start; 406 rman_res_t _end; 407}; 408 409/** 410 * @brief Release a resource 411 * 412 * Free a resource allocated by the BUS_ALLOC_RESOURCE. The @p _rid 413 * value must be the same as the one returned by BUS_ALLOC_RESOURCE() 414 * (which is not necessarily the same as the one the client passed). 415 * 416 * @param _dev the parent device of @p _child 417 * @param _child the device which allocated the resource 418 * @param _type the type of resource 419 * @param _rid the resource identifier 420 * @param _r the resource to release 421 */ 422METHOD int release_resource { 423 device_t _dev; 424 device_t _child; 425 int _type; 426 int _rid; 427 struct resource *_res; 428}; 429 430/** 431 * @brief Install an interrupt handler 432 * 433 * This method is used to associate an interrupt handler function with 434 * an irq resource. When the interrupt triggers, the function @p _intr 435 * will be called with the value of @p _arg as its single 436 * argument. The value returned in @p *_cookiep is used to cancel the 437 * interrupt handler - the caller should save this value to use in a 438 * future call to BUS_TEARDOWN_INTR(). 439 * 440 * @param _dev the parent device of @p _child 441 * @param _child the device which allocated the resource 442 * @param _irq the resource representing the interrupt 443 * @param _flags a set of bits from enum intr_type specifying 444 * the class of interrupt 445 * @param _intr the function to call when the interrupt 446 * triggers 447 * @param _arg a value to use as the single argument in calls 448 * to @p _intr 449 * @param _cookiep a pointer to a location to receive a cookie 450 * value that may be used to remove the interrupt 451 * handler 452 */ 453METHOD int setup_intr { 454 device_t _dev; 455 device_t _child; 456 struct resource *_irq; 457 int _flags; 458 driver_filter_t *_filter; 459 driver_intr_t *_intr; 460 void *_arg; 461 void **_cookiep; 462}; 463 464/** 465 * @brief Uninstall an interrupt handler 466 * 467 * This method is used to disassociate an interrupt handler function 468 * with an irq resource. The value of @p _cookie must be the value 469 * returned from a previous call to BUS_SETUP_INTR(). 470 * 471 * @param _dev the parent device of @p _child 472 * @param _child the device which allocated the resource 473 * @param _irq the resource representing the interrupt 474 * @param _cookie the cookie value returned when the interrupt 475 * was originally registered 476 */ 477METHOD int teardown_intr { 478 device_t _dev; 479 device_t _child; 480 struct resource *_irq; 481 void *_cookie; 482}; 483 484/** 485 * @brief Suspend an interrupt handler 486 * 487 * This method is used to mark a handler as suspended in the case 488 * that the associated device is powered down and cannot be a source 489 * for the, typically shared, interrupt. 490 * The value of @p _irq must be the interrupt resource passed 491 * to a previous call to BUS_SETUP_INTR(). 492 * 493 * @param _dev the parent device of @p _child 494 * @param _child the device which allocated the resource 495 * @param _irq the resource representing the interrupt 496 */ 497METHOD int suspend_intr { 498 device_t _dev; 499 device_t _child; 500 struct resource *_irq; 501} DEFAULT bus_generic_suspend_intr; 502 503/** 504 * @brief Resume an interrupt handler 505 * 506 * This method is used to clear suspended state of a handler when 507 * the associated device is powered up and can be an interrupt source 508 * again. 509 * The value of @p _irq must be the interrupt resource passed 510 * to a previous call to BUS_SETUP_INTR(). 511 * 512 * @param _dev the parent device of @p _child 513 * @param _child the device which allocated the resource 514 * @param _irq the resource representing the interrupt 515 */ 516METHOD int resume_intr { 517 device_t _dev; 518 device_t _child; 519 struct resource *_irq; 520} DEFAULT bus_generic_resume_intr; 521 522/** 523 * @brief Define a resource which can be allocated with 524 * BUS_ALLOC_RESOURCE(). 525 * 526 * This method is used by some buses (typically ISA) to allow a 527 * driver to describe a resource range that it would like to 528 * allocate. The resource defined by @p _type and @p _rid is defined 529 * to start at @p _start and to include @p _count indices in its 530 * range. 531 * 532 * @param _dev the parent device of @p _child 533 * @param _child the device which owns the resource 534 * @param _type the type of resource 535 * @param _rid the resource identifier 536 * @param _start the start of the resource range 537 * @param _count the size of the resource range 538 */ 539METHOD int set_resource { 540 device_t _dev; 541 device_t _child; 542 int _type; 543 int _rid; 544 rman_res_t _start; 545 rman_res_t _count; 546}; 547 548/** 549 * @brief Describe a resource 550 * 551 * This method allows a driver to examine the range used for a given 552 * resource without actually allocating it. 553 * 554 * @param _dev the parent device of @p _child 555 * @param _child the device which owns the resource 556 * @param _type the type of resource 557 * @param _rid the resource identifier 558 * @param _start the address of a location to receive the start 559 * index of the resource range 560 * @param _count the address of a location to receive the size 561 * of the resource range 562 */ 563METHOD int get_resource { 564 device_t _dev; 565 device_t _child; 566 int _type; 567 int _rid; 568 rman_res_t *_startp; 569 rman_res_t *_countp; 570}; 571 572/** 573 * @brief Delete a resource. 574 * 575 * Use this to delete a resource (possibly one previously added with 576 * BUS_SET_RESOURCE()). 577 * 578 * @param _dev the parent device of @p _child 579 * @param _child the device which owns the resource 580 * @param _type the type of resource 581 * @param _rid the resource identifier 582 */ 583METHOD void delete_resource { 584 device_t _dev; 585 device_t _child; 586 int _type; 587 int _rid; 588}; 589 590/** 591 * @brief Return a struct resource_list. 592 * 593 * Used by drivers which use bus_generic_rl_alloc_resource() etc. to 594 * implement their resource handling. It should return the resource 595 * list of the given child device. 596 * 597 * @param _dev the parent device of @p _child 598 * @param _child the device which owns the resource list 599 */ 600METHOD struct resource_list * get_resource_list { 601 device_t _dev; 602 device_t _child; 603} DEFAULT bus_generic_get_resource_list; 604 605/** 606 * @brief Is the hardware described by @p _child still attached to the 607 * system? 608 * 609 * This method should return 0 if the device is not present. It 610 * should return -1 if it is present. Any errors in determining 611 * should be returned as a normal errno value. Client drivers are to 612 * assume that the device is present, even if there is an error 613 * determining if it is there. Buses are to try to avoid returning 614 * errors, but newcard will return an error if the device fails to 615 * implement this method. 616 * 617 * @param _dev the parent device of @p _child 618 * @param _child the device which is being examined 619 */ 620METHOD int child_present { 621 device_t _dev; 622 device_t _child; 623} DEFAULT bus_generic_child_present; 624 625/** 626 * @brief Returns the pnp info for this device. 627 * 628 * Return it as a string. If the storage is insufficient for the 629 * string, then return EOVERFLOW. 630 * 631 * The string must be formatted as a space-separated list of 632 * name=value pairs. Names may only contain alphanumeric characters, 633 * underscores ('_') and hyphens ('-'). Values can contain any 634 * non-whitespace characters. Values containing whitespace can be 635 * quoted with double quotes ('"'). Double quotes and backslashes in 636 * quoted values can be escaped with backslashes ('\'). 637 * 638 * @param _dev the parent device of @p _child 639 * @param _child the device which is being examined 640 * @param _buf the address of a buffer to receive the pnp 641 * string 642 * @param _buflen the size of the buffer pointed to by @p _buf 643 */ 644METHOD int child_pnpinfo_str { 645 device_t _dev; 646 device_t _child; 647 char *_buf; 648 size_t _buflen; 649}; 650 651/** 652 * @brief Returns the location for this device. 653 * 654 * Return it as a string. If the storage is insufficient for the 655 * string, then return EOVERFLOW. 656 * 657 * The string must be formatted as a space-separated list of 658 * name=value pairs. Names may only contain alphanumeric characters, 659 * underscores ('_') and hyphens ('-'). Values can contain any 660 * non-whitespace characters. Values containing whitespace can be 661 * quoted with double quotes ('"'). Double quotes and backslashes in 662 * quoted values can be escaped with backslashes ('\'). 663 * 664 * @param _dev the parent device of @p _child 665 * @param _child the device which is being examined 666 * @param _buf the address of a buffer to receive the location 667 * string 668 * @param _buflen the size of the buffer pointed to by @p _buf 669 */ 670METHOD int child_location_str { 671 device_t _dev; 672 device_t _child; 673 char *_buf; 674 size_t _buflen; 675}; 676 677/** 678 * @brief Allow drivers to request that an interrupt be bound to a specific 679 * CPU. 680 * 681 * @param _dev the parent device of @p _child 682 * @param _child the device which allocated the resource 683 * @param _irq the resource representing the interrupt 684 * @param _cpu the CPU to bind the interrupt to 685 */ 686METHOD int bind_intr { 687 device_t _dev; 688 device_t _child; 689 struct resource *_irq; 690 int _cpu; 691} DEFAULT bus_generic_bind_intr; 692 693/** 694 * @brief Allow (bus) drivers to specify the trigger mode and polarity 695 * of the specified interrupt. 696 * 697 * @param _dev the bus device 698 * @param _irq the interrupt number to modify 699 * @param _trig the trigger mode required 700 * @param _pol the interrupt polarity required 701 */ 702METHOD int config_intr { 703 device_t _dev; 704 int _irq; 705 enum intr_trigger _trig; 706 enum intr_polarity _pol; 707} DEFAULT bus_generic_config_intr; 708 709/** 710 * @brief Allow drivers to associate a description with an active 711 * interrupt handler. 712 * 713 * @param _dev the parent device of @p _child 714 * @param _child the device which allocated the resource 715 * @param _irq the resource representing the interrupt 716 * @param _cookie the cookie value returned when the interrupt 717 * was originally registered 718 * @param _descr the description to associate with the interrupt 719 */ 720METHOD int describe_intr { 721 device_t _dev; 722 device_t _child; 723 struct resource *_irq; 724 void *_cookie; 725 const char *_descr; 726} DEFAULT bus_generic_describe_intr; 727 728/** 729 * @brief Notify a (bus) driver about a child that the hints mechanism 730 * believes it has discovered. 731 * 732 * The bus is responsible for then adding the child in the right order 733 * and discovering other things about the child. The bus driver is 734 * free to ignore this hint, to do special things, etc. It is all up 735 * to the bus driver to interpret. 736 * 737 * This method is only called in response to the parent bus asking for 738 * hinted devices to be enumerated. 739 * 740 * @param _dev the bus device 741 * @param _dname the name of the device w/o unit numbers 742 * @param _dunit the unit number of the device 743 */ 744METHOD void hinted_child { 745 device_t _dev; 746 const char *_dname; 747 int _dunit; 748}; 749 750/** 751 * @brief Returns bus_dma_tag_t for use w/ devices on the bus. 752 * 753 * @param _dev the parent device of @p _child 754 * @param _child the device to which the tag will belong 755 */ 756METHOD bus_dma_tag_t get_dma_tag { 757 device_t _dev; 758 device_t _child; 759} DEFAULT bus_generic_get_dma_tag; 760 761/** 762 * @brief Returns bus_space_tag_t for use w/ devices on the bus. 763 * 764 * @param _dev the parent device of @p _child 765 * @param _child the device to which the tag will belong 766 */ 767METHOD bus_space_tag_t get_bus_tag { 768 device_t _dev; 769 device_t _child; 770} DEFAULT bus_generic_get_bus_tag; 771 772/** 773 * @brief Allow the bus to determine the unit number of a device. 774 * 775 * @param _dev the parent device of @p _child 776 * @param _child the device whose unit is to be wired 777 * @param _name the name of the device's new devclass 778 * @param _unitp a pointer to the device's new unit value 779 */ 780METHOD void hint_device_unit { 781 device_t _dev; 782 device_t _child; 783 const char *_name; 784 int *_unitp; 785}; 786 787/** 788 * @brief Notify a bus that the bus pass level has been changed 789 * 790 * @param _dev the bus device 791 */ 792METHOD void new_pass { 793 device_t _dev; 794} DEFAULT bus_generic_new_pass; 795 796/** 797 * @brief Notify a bus that specified child's IRQ should be remapped. 798 * 799 * @param _dev the bus device 800 * @param _child the child device 801 * @param _irq the irq number 802 */ 803METHOD int remap_intr { 804 device_t _dev; 805 device_t _child; 806 u_int _irq; 807} DEFAULT null_remap_intr; 808 809/** 810 * @brief Suspend a given child 811 * 812 * @param _dev the parent device of @p _child 813 * @param _child the device to suspend 814 */ 815METHOD int suspend_child { 816 device_t _dev; 817 device_t _child; 818} DEFAULT bus_generic_suspend_child; 819 820/** 821 * @brief Resume a given child 822 * 823 * @param _dev the parent device of @p _child 824 * @param _child the device to resume 825 */ 826METHOD int resume_child { 827 device_t _dev; 828 device_t _child; 829} DEFAULT bus_generic_resume_child; 830 831/** 832 * @brief Get the VM domain handle for the given bus and child. 833 * 834 * @param _dev the bus device 835 * @param _child the child device 836 * @param _domain a pointer to the bus's domain handle identifier 837 */ 838METHOD int get_domain { 839 device_t _dev; 840 device_t _child; 841 int *_domain; 842} DEFAULT bus_generic_get_domain; 843 844/** 845 * @brief Request a set of CPUs 846 * 847 * @param _dev the bus device 848 * @param _child the child device 849 * @param _op type of CPUs to request 850 * @param _setsize the size of the set passed in _cpuset 851 * @param _cpuset a pointer to a cpuset to receive the requested 852 * set of CPUs 853 */ 854METHOD int get_cpus { 855 device_t _dev; 856 device_t _child; 857 enum cpu_sets _op; 858 size_t _setsize; 859 struct _cpuset *_cpuset; 860} DEFAULT bus_generic_get_cpus; 861 862/** 863 * @brief Prepares the given child of the bus for reset 864 * 865 * Typically bus detaches or suspends children' drivers, and then 866 * calls this method to save bus-specific information, for instance, 867 * PCI config space, which is damaged by reset. 868 * 869 * The bus_helper_reset_prepare() helper is provided to ease 870 * implementing bus reset methods. 871 * 872 * @param _dev the bus device 873 * @param _child the child device 874 */ 875METHOD int reset_prepare { 876 device_t _dev; 877 device_t _child; 878} DEFAULT null_reset_prepare; 879 880/** 881 * @brief Restores the child operations after the reset 882 * 883 * The bus_helper_reset_post() helper is provided to ease 884 * implementing bus reset methods. 885 * 886 * @param _dev the bus device 887 * @param _child the child device 888 */ 889METHOD int reset_post { 890 device_t _dev; 891 device_t _child; 892} DEFAULT null_reset_post; 893 894/** 895 * @brief Performs reset of the child 896 * 897 * @param _dev the bus device 898 * @param _child the child device 899 * @param _flags DEVF_RESET_ flags 900 */ 901METHOD int reset_child { 902 device_t _dev; 903 device_t _child; 904 int _flags; 905}; 906