acpi summary

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
ASL        : ACPI Source Language

AML        : ACPI Machine Language

DSL        : Digital Simulation Language

E820       : a system memory map protocol, provided in ACPI spec, ch14 for 3.0b

EFI        : Enhanced Firmware Interface

HPET       : High Precision Event Timer

GPE        : General-Purpose Event

GSI        : Global System Interrupts

OSL        : OS Service Layer

OSPM       : OS Power Management, 指Linux等OS中实现对ACPI支持的代码
						// OS中已驱动程序的方式控制ACPI模块，并可以处理热插拔、SCI中断和设备事件等
PRT        : PCI IRQ Routing Table

PXE        : Preboot Execution Environment

SAPIC      : Streamlined APIC, IA64上使用的APIC。其local SAPIC和I/O SAPIC分别对 应着IA32 和x86-64上的Local APIC和I/O APIC

SBF        : Simple Boot Flag

SCI        : System Control Interrupt  (OS-visible interrupts, triggered by ACPI events)

SMBIOS/DMI : System Management BIOS/Desktop Management Interface. PC的BIOS规范。

TOM        : Top Of Memory

UUID       : Universal Uniform IDentifiers

xface      : Linux内核ACPI源文件的命名法，表示Interface。例如tbxface.c实现table的接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Generic Event Device described in ACPI 6.1 allows platforms to handle
platform interrupts in ACPI ASL statements. It borrows constructs like
_EVT from GPIO events. All interrupts are listed in _CRS and the handler
is written in _EVT method. 

Device (GED0)
{

	Name (_HID, "ACPI0013")
	Name (_UID, 0)
	Name(_CRS, ResourceTemplate ()
	{
		Interrupt(ResourceConsumer, Edge, ActiveHigh, Shared, , , )
		 {123}
	})

	Method (_EVT, 1) {
		if (Lequal(123, Arg0))
		{
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
static int ged_probe(struct platform_device *pdev)
{
    acpi_status acpi_ret;

    acpi_ret = acpi_walk_resources(ACPI_HANDLE(&pdev->dev), "_CRS",
                       acpi_ged_request_interrupt, &pdev->dev);
    if (ACPI_FAILURE(acpi_ret)) {
        dev_err(&pdev->dev, "unable to parse the _CRS record\n");
        return -EINVAL;
    }

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
/* Master list of all ACPI tables that were found in the RSDT/XSDT */

ACPI_GLOBAL(struct acpi_table_list, acpi_gbl_root_table_list);

/* DSDT information. Used to check for DSDT corruption */

ACPI_GLOBAL(struct acpi_table_header *, acpi_gbl_DSDT);
ACPI_GLOBAL(struct acpi_table_header, acpi_gbl_original_dsdt_header);
ACPI_INIT_GLOBAL(u32, acpi_gbl_dsdt_index, ACPI_INVALID_TABLE_INDEX);
ACPI_INIT_GLOBAL(u32, acpi_gbl_facs_index, ACPI_INVALID_TABLE_INDEX);
ACPI_INIT_GLOBAL(u32, acpi_gbl_xfacs_index, ACPI_INVALID_TABLE_INDEX);
ACPI_INIT_GLOBAL(u32, acpi_gbl_fadt_index, ACPI_INVALID_TABLE_INDEX);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*******************************************************************************
 *
 * Master ACPI Table Header. This common header is used by all ACPI tables
 * except the RSDP and FACS.
 *
 ******************************************************************************/

struct acpi_table_header {
    char signature[ACPI_NAME_SIZE]; /* ASCII table signature */
    u32 length;     /* Length of table in bytes, including this header */
    u8 revision;        /* ACPI Specification minor version number */
    u8 checksum;        /* To make sum of entire table == 0 */
    char oem_id[ACPI_OEM_ID_SIZE];  /* ASCII OEM identification */  // 厂商id
    char oem_table_id[ACPI_OEM_TABLE_ID_SIZE];  /* ASCII OEM table identification */ // table id
    u32 oem_revision;   /* OEM revision number */
    char asl_compiler_id[ACPI_NAME_SIZE];   /* ASCII ASL compiler vendor ID */
    u32 asl_compiler_revision;  /* ASL compiler version */
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/*******************************************************************************
 *
 * FUNCTION:    acpi_tb_parse_root_table
 *
 * PARAMETERS:  rsdp_address        - Pointer to the RSDP
 *
 * RETURN:      Status
 *
 * DESCRIPTION: This function is called to parse the Root System Description
 *              Table (RSDT or XSDT)
 *
 * NOTE:        Tables are mapped (not copied) for efficiency. The FACS must
 *              be mapped and cannot be copied because it contains the actual
 *              memory location of the ACPI Global Lock.
 *
 ******************************************************************************/

acpi_status ACPI_INIT_FUNCTION
acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
{
	struct acpi_table_rsdp *rsdp;
	u32 table_entry_size;
	u32 i;
	u32 table_count;
	struct acpi_table_header *table;
	acpi_physical_address address;
	u32 length;
	u8 *table_entry;
	acpi_status status;
	u32 table_index;

	ACPI_FUNCTION_TRACE(tb_parse_root_table);

	/* Map the entire RSDP and extract the address of the RSDT or XSDT */
	rsdp = acpi_os_map_memory(rsdp_address, sizeof(struct acpi_table_rsdp));
	if (!rsdp) {
		return_ACPI_STATUS(AE_NO_MEMORY);
	}

	acpi_tb_print_table_header(rsdp_address,
				   ACPI_CAST_PTR(struct acpi_table_header,
						 rsdp));

	/* Use XSDT if present and not overridden. Otherwise, use RSDT */
// 根据ACPI版本的不同，选择使用RSDT或者XSDT，版本1 用RSDT， Reversion > 1 用XSDT，
// 两者 的区别在于 XSDT是64位的，RSDT是32位的
	if ((rsdp->revision > 1) &&
	    rsdp->xsdt_physical_address && !acpi_gbl_do_not_use_xsdt) {
		/*
		 * RSDP contains an XSDT (64-bit physical addresses). We must use
		 * the XSDT if the revision is > 1 and the XSDT pointer is present,
		 * as per the ACPI specification.
		 */
		address = (acpi_physical_address)rsdp->xsdt_physical_address;
		table_entry_size = ACPI_XSDT_ENTRY_SIZE;
	} else {
		/* Root table is an RSDT (32-bit physical addresses) */

		address = (acpi_physical_address)rsdp->rsdt_physical_address;
		table_entry_size = ACPI_RSDT_ENTRY_SIZE;
	}

	/*
	 * It is not possible to map more than one entry in some environments,
	 * so unmap the RSDP here before mapping other tables
	 */
	acpi_os_unmap_memory(rsdp, sizeof(struct acpi_table_rsdp));

	/* Map the RSDT/XSDT table header to get the full table length */

	table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
	if (!table) {
		return_ACPI_STATUS(AE_NO_MEMORY);
	}

	acpi_tb_print_table_header(address, table);

	/*
	 * Validate length of the table, and map entire table.
	 * Minimum length table must contain at least one entry.
	 */
	length = table->length;
	acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));

	if (length < (sizeof(struct acpi_table_header) + table_entry_size)) {
		ACPI_BIOS_ERROR((AE_INFO,
				 "Invalid table length 0x%X in RSDT/XSDT",
				 length));
		return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
	}

	table = acpi_os_map_memory(address, length);
	if (!table) {
		return_ACPI_STATUS(AE_NO_MEMORY);
	}

	/* Validate the root table checksum */
// 验证表校验和
	status = acpi_tb_verify_checksum(table, length);
	if (ACPI_FAILURE(status)) {
		acpi_os_unmap_memory(table, length);
		return_ACPI_STATUS(status);
	}

	/* Get the number of entries and pointer to first entry */

	table_count = (u32)((table->length - sizeof(struct acpi_table_header)) /
			    table_entry_size);
	table_entry = ACPI_ADD_PTR(u8, table, sizeof(struct acpi_table_header));

	/* Initialize the root table array from the RSDT/XSDT */

	for (i = 0; i < table_count; i++) {

		/* Get the table physical address (32-bit for RSDT, 64-bit for XSDT) */

		address =
		    acpi_tb_get_root_table_entry(table_entry, table_entry_size); // 获取一个entry

		/* Skip NULL entries in RSDT/XSDT */

		if (!address) {
			goto next_table;
		}

    // 安装标准的table
		status = acpi_tb_install_standard_table(address,
							ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL,
							FALSE, TRUE,
							&table_index);

    // 如果是FADT，调用acpi_tb_parse_fadt() 进行解析
		if (ACPI_SUCCESS(status) &&
		    ACPI_COMPARE_NAMESEG(&acpi_gbl_root_table_list.
					 tables[table_index].signature,
					 ACPI_SIG_FADT)) {
			acpi_gbl_fadt_index = table_index;
			acpi_tb_parse_fadt();
		}

next_table:

		table_entry += table_entry_size;
	}

	acpi_os_unmap_memory(table, length);
	return_ACPI_STATUS(AE_OK);
}

1
2
3
4
5
6
acpi_tb_parse_fadt
  // 设置acpi_gbl_DSDT全局变量
  // 设置表在全局变量acpi_gbl_root_table_list中的index
  // acpi_gbl_dsdt_index、acpi_gbl_facs_index、acpi_gbl_xfacs_index
	-> acpi_tb_install_standard_table
		-> acpi_tb_install_table_with_override

1
2
3
4
5
6
7
8
9
// kernel 
start_kernel
	-> setup_arch
		-> acpi_boot_table_init
			-> acpi_table_init
				-> acpi_initialize_tables
  				// 获取rsdp地址
  				-> rsdp_address = acpi_os_get_root_pointer() 
					-> acpi_tb_parse_root_table

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
static int __init acpi_init(void)
{
	int result;

	if (acpi_disabled) {
		printk(KERN_INFO PREFIX "Interpreter disabled.\n");
		return -ENODEV;
	}

	acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
	if (!acpi_kobj) {
		printk(KERN_WARNING "%s: kset create error\n", __func__);
		acpi_kobj = NULL;
	}

	result = acpi_bus_init();
	if (result) {
		disable_acpi();
		return result;
	}

	pci_mmcfg_late_init();
	acpi_iort_init();
	acpi_scan_init();
	acpi_ec_init();
	acpi_debugfs_init();
	acpi_sleep_proc_init();
	acpi_wakeup_device_init();
	acpi_debugger_init();
	acpi_setup_sb_notify_handler();
	return 0;
}
// 注意这里将该函数放在特定的段里
subsys_initcall(acpi_init);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// kernel 
start_kernel
	-> setup_arch
		-> acpi_boot_table_init
			-> acpi_table_init
				-> acpi_initialize_tables
					-> acpi_tb_parse_root_table
  -> arch_call_rest_init()
  	-> rest_init()
  		-> (new thread) kernel_thread(kernel_init, NULL, CLONE_FS);
				-> kernel_init_freeable
          -> do_basic_setup
          	-> do_initcalls
 
// 执行各个init_call的函数
static void __init do_initcalls(void)
{
	int level;

	for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
		do_initcall_level(level);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
acpi_tb_load_namespace
	// acpi_gbl_root_node是全局变量，acpi namespace的根节点
	-> acpi_ns_load_table(acpi_gbl_dsdt_index, acpi_gbl_root_node);
	-> acpi_ns_load_table(i, acpi_gbl_root_node); // 遍历list中的所有table, 并设置为加载状态
		// 该函数解析table，但是不解析control methods
		// 全部的namespace全部解析完成后，才能解析control methods
		-> acpi_ns_parse_table(table_index, node);
			// 作为有个大的control method执行该table， single pass parse
			-> acpi_ns_execute_table
				-> acpi_ps_execute_table(info)
					// 下面两个函数创建并初始化 walk_state
					-> acpi_ds_create_walk_state
					-> acpi_ds_init_aml_walk
					// 解析AML， 返回ops tree
					-> acpi_ps_parse_aml(walk_state)
						-> acpi_ps_parse_loop
							// LOOP
							(-> acpi_ps_create_op
							-> acpi_ps_complete_op)
        			// 在解析完之后
        			-> acpi_ps_complete_final_op

1
2
3
4
5
6
7
8
9
10
11
12
13
14
acpi_evaluate_object // 需要提供设备路径 方法名称 和 参数
  -> acpi_ns_evaluate(info) // 执行一个控制方法
  	// 执行该方法之前，lock aml interpreter
  	// 该方法通过AML interpreter执行设备节点中定义的method
  	-> acpi_ps_execute_method(info)
  		-> acpi_ds_create_walk_state // 创建工作状态节点
  		-> acpi_ds_init_aml_walk
  		-> acpi_ps_parse_aml(walk_state)

/*
* 函数acpi_ps_parse_aml 会扫描两次，第一次扫描主要做合法性检查 并载入参数
* 第二次扫描只扫描操作节点，
* 最后将操作对象集合发布到AML分析器执行列表中，并执行
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
acpi_enable_subsystem
	// 初始化Fixed events和GPE events
	-> acpi_ev_initialize_events()
		// 初始化 Fixed events, 设置handler=NULL, 然后disable fixed events
		-> acpi_ev_fixed_event_initialize()
		-> acpi_ev_gpe_initialize()
			-> acpi_ev_create_gpe_block
			
// acpi_ev_gpe_initialize函数中，首先获取namespace的锁， 调用函数acpi_ev_create_gpe_block，该函数根据全局变量acpi_gbl_FADT中的xgpe0_block、xgpe1_block初始化全局变量acpi_gbl_gpe_fadt_blocks数组

// 在acpi_enable_subsystem()函数的最后，初始化SCI handler和Global Lock handler
// 结束了硬件初始化流程
  -> acpi_ev_install_xrupt_handlers()
  	// 下面两个函数设置SCI中断的处理函数和global lock的处理函数
  	-> acpi_ev_install_sci_handler()   // 中断处理函数为acpi_ev_sci_xrupt_handler
  	-> acpi_ev_init_global_lock_handler()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
 * Information about a GPE register block, one per each installed block --
 * GPE0, GPE1, and one per each installed GPE Block Device.
 */
struct acpi_gpe_block_info {
// 当前GPE事件所需要在执行的名字空间的方法节点，如上面例中的Method(_L01)
	struct acpi_namespace_node *node;
	struct acpi_gpe_block_info *previous;
	struct acpi_gpe_block_info *next;
	struct acpi_gpe_xrupt_info *xrupt_block;	/* Backpointer to interrupt block */
// 指向当前GPE的寄存器组
	struct acpi_gpe_register_info *register_info;	/* One per GPE register pair */
	struct acpi_gpe_event_info *event_info;	/* One for each GPE */
	u64 address;		/* Base address of the block */
	u32 register_count;	/* Number of register pairs in block */
	u16 gpe_count;		/* Number of individual GPEs in block */
	u16 block_base_number;	/* Base GPE number for this block */
	u8 space_id;
	u8 initialized;		/* TRUE if this block is initialized */
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
 * Information about a GPE, one per each GPE in an array.
 * NOTE: Important to keep this struct as small as possible.
 */
struct acpi_gpe_event_info {
	union acpi_gpe_dispatch_info dispatch;	/* Either Method, Handler, or notify_list */
	struct acpi_gpe_register_info *register_info;	/* Backpointer to register info */
	u8 flags;		/* Misc info about this GPE */
	u8 gpe_number;		/* This GPE */
	u8 runtime_count;	/* References to a run GPE */
	u8 disable_for_dispatch;	/* Masked during dispatching */
};

/*
 * GPE dispatch info. At any time, the GPE can have at most one type
 * of dispatch - Method, Handler, or Implicit Notify.
 */
union acpi_gpe_dispatch_info {
	struct acpi_namespace_node *method_node;	/* Method node for this GPE level */
	struct acpi_gpe_handler_info *handler;  /* Installed GPE handler */
	struct acpi_gpe_notify_info *notify_list;	/* List of _PRW devices for implicit notifies */
};

1
2
3
4
5
6
7
8
9
10
11
12
acpi_ev_sci_xrupt_handler
该函数是所有SCI中断的处理函数，所有的GPE共享该中断处理句柄，
函数处理过程：
-> acpi_ev_fixed_event_detect // 该函数检查并分发fixed event
-> acpi_ev_gpe_detect(gpe_xrupt_list) // 处理并分发所有的GPE events
	-> acpi_ev_detect_gpe // 扫描acpi_gbl_gpe_xrupt_list_head全局队列上挂的GPE Block检查事件状态，。检查寄存器状态等，并分发到事件的处理进程，根据当前的使能状态寄存器决定是否响应
		-> 如果 ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) ==
	    ACPI_GPE_DISPATCH_RAW_HANDLER，调用gpe_handler_info->address(gpe_device, gpe_number, gpe_handler_info->context); 
	  -> acpi_ev_gpe_dispatch // 该函数继续进行分发，如果gpe_event_info->flags的type为ACPI_GPE_DISPATCH_HANDLER，调用function(EC等)；如果为ACPI_GPE_DISPATCH_METHOD或者ACPI_GPE_DISPATCH_NOTIFY，就调用acpi_os_execute
	  	-> acpi_os_execute // 将要执行的函数acpi_ev_asynch_execute_gpe_method放入OS的执行队列中异步执行
					-> acpi_ev_asynch_execute_gpe_method // 该函数会执行GPE控制方法
						-> acpi_ns_evaluate(info) // 执行改GPE的控制方法， _Lxx或者_Exx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// arch_initcall(acpi_pci_init); 因此该函数也是在start_kernel函数最后do_initcalls()中被调用

/* just register struct acpi_bus_type acpi_pci_bus to list: bus_type_list */
acpi_pci_init() /* arch_initcall(acpi_pci_init) */
 
acpi_init() /* subsys_initcall(acpi_init) */
    --> acpi_scan_init()
        /*
         * register pci_root_handler to list: acpi_scan_handlers_list.
         * the attach will be called in acpi_scan_attach_handler().
         * there attach is assigned as acpi_pci_root_add()
         */
        --> acpi_pci_root_init()
        /*
         * register pci_link_handler to list: acpi_scan_handlers_list.
         * this handler has relationship with PCI IRQ.
         */
        --> acpi_pci_link_init()
        /* we facus on PCI-ACPI, ignore other handlers' init */
        ...
  			/* 在root scope下查找，找到所有的设备，首先添加根设备，
  			 * 然后acpi_walk_namespace,添加scope下的所有节点
  			 */
        --> acpi_bus_scan(ACPI_ROOT_OBJECT)
  					-> acpi_bus_check_add(handle, 0, NULL, &device)
            /* create struct acpi_devices for all device in this system */
            --> acpi_walk_namespace(acpi_bus_check_add)
            --> acpi_bus_attach()
                --> acpi_scan_attach_handler() 
                    --> acpi_scan_match_handler()
                    --> handler->attach /* attach is acpi_pci_root_add */
 
acpi_pci_root_add()
    /*
     * in kernel, there are two pci_acpi_scan_root, they are in
     * arch/ia64/pci/pci.c and arch/x86/pci/acpi.c.
     * if we will implement PCI using ACPI in ARM64, we should implement
     * another this kind of function in arch/arm64/kernel/pci.c.
     * in pci_acpi_scan_root, will allocate struct pci_controller and
     * struct pci_root_info.
     */
    --> pci_acpi_scan_root()
        --> probe_pci_root_info()
	    /*
	     * will called twice, first for count_window, second for add window.
	     * this function will get infomation from ACPI table.
	     */
             --> acpi_walk_resources() /* drivers/acpi/acpica/rsxface.c */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
global list: acpi_scan_handlers_list /* drivers/acpi/scan.c */
element: struct acpi_scan_handler

static list: bus_type_list /* drivers/acpi */
element: struct acpi_bus_type

struct acpi_scan_handler:
     struct acpi_device_id *ids;
     attach;
     ...

struct acpi_bus_type
struct acpi_device  // 在APCI层上描述一个设备

struct pci_controller
struct pci_root_info:
    struct pci_controller *controller;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
pciehp_probe
	-> pcie_init_notification
		-> pciehp_request_irq
			-> irq = ctrl->pcie->irq;
			-> request_threaded_irq(irq, pciehp_isr, pciehp_ist,
				      IRQF_SHARED, "pciehp", ctrl);

// PCIe对应的中断处理函数为pciehp_ist
pciehp_ist
	-> pciehp_handle_presence_or_link_change
		-> pciehp_enable_slot
			-> __pciehp_enable_slot
				-> board_added(ctrl)
					-> cpqhp_configure_device(ctrl, new_slot);
						-> pci_hp_add_bridge(func->pci_dev);
							-> pci_scan_bridge_extend(parent, dev, busnr, available_buses, 1);
								-> pci_add_new_bus
									-> pci_alloc_child_bus
										-> pcibios_add_bus(child)
											-> acpi_pci_add_bus
												-> acpi_pci_slot_enumerate
													-> acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
				    register_slot, NULL, bus, NULL);

// 函数 register_slot： 如果handle有对应的slot, 将设备挂载到对应的插槽结构中，如果没有对应的插槽，则创建

//对应的PCI插槽结构
/* pci_slot represents a physical slot */
struct pci_slot {
	struct pci_bus		*bus;		/* Bus this slot is on */
	struct list_head	list;		/* Node in list of slots */
	struct hotplug_slot	*hotplug;	/* Hotplug info (move here) */
	unsigned char		number;		/* PCI_SLOT(pci_dev->devfn) */
	struct kobject		kobj;
};

1
2
3
acpi_init()
	-> acpi_bus_notify()
		-> acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY, &acpi_bus_notify, NULL);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
acpi_bus_notify // 根据通告类型进行处理，如果是热插拔事件，找到对应设备的驱动，调用驱动中定义的notify函数
    
    -> driver.ops->notify 
    /* 以内存为例， 注册notify函数： drivers/xen/xen-acpi-memhotplug.c
     * acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY, acpi_memory_device_notify, NULL);
     */
     	-> acpi_memory_device_notify
     		-> (case ACPI_NOTIFY_DEVICE_CHECK) acpi_memory_get_device(handle, &mem_device)
     			-> acpi_bus_scan(handle)
    			/* 在给定的namespace scope(handle)中添加设备节点 */
    				-> acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, acpi_bus_check_add, NULL, NULL, &device);
					/* 遍历， 找到对应的设备之后， 调用函数 acpi_bus_check_add */
					-> acpi_bus_attach(device)
    				/* 寻找该设备匹配的handler， 设置到device的handler字段中， 然后调用device->attach
    				 * 调用device->attach：将device 和对应的driver绑定
    				*/
                    	-> acpi_scan_attach_handler(device)
                            -> handler->attach(device, devid)

/* 以内存设备为例，attach函数为acpi_memory_device_add
 * 初始化： acpi_scan_init -> acpi_memory_hotplug_init() -> acpi_scan_add_handler_with_hotplug
 * 指定hotplug的handler 为 memory_device_handler
 */
acpi_memory_device_add
	-> acpi_memory_check_device
	/* 检查设备的 _STA 状态等 */
	-> acpi_memory_enable_device

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static void hotplug_event(u32 type, struct acpiphp_context *context)
{
        switch (type) {
        case ACPI_NOTIFY_BUS_CHECK:
        case ACPI_NOTIFY_DEVICE_CHECK:
        case ACPI_NOTIFY_EJECT_REQUEST:
}

// DSDT中PCI host bridge定义的Method
Method (PCNT, 0, NotSerialized)
        {
            BNUM = Zero
            DVNT (PCIU, One)   // 对应 ACPI_NOTIFY_DEVICE_CHECK
            DVNT (PCID, 0x03)  // 对应 ACPI_NOTIFY_EJECT_REQUEST
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
acpi_pci_root_add
  ->pci_acpi_scan_root()
	-> pci_create_root_bus()
		-> pci_register_host_bridge()
			-> pcibios_add_bus()
				-> acpi_pci_add_bus()
					-> acpiphp_enumerate_slots()
						-> acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1, acpiphp_add_context, NULL, bridge, NULL);
/* acpiphp_init_context中指定 context->hp.notify = acpiphp_hotplug_notify */

acpiphp_hotplug_notify
  ->hotplug_event
	-> (case: ACPI_NOTIFY_DEVICE_CHECK) acpiphp_check_bridge(bridge);
        -> if (device_status_valid(get_slot_status(slot))) 
        /* 首先是遍历当前宿主桥下所有的SLOT，通过调用其_STA方法获得当前每个插槽上的状态，
         * 如果没有_STA方法，就直接检查当前的SLOT上的厂商号是否为全F,如果不是，表示有设备插入。
         */
        -> (if = true) enable_slot(slot, true);
        /* 如果是native hotplug, 调用函数acpiphp_native_scan_bridge
         * 否则
         */
			|-> acpiphp_rescan_slot(slot);
			/* 对于当前slot中的所有dev, 将对应的acpi_device加入到namespace scope中（acpi_bus_scan）
			 * 给slot中的所有设备上电
			 * 扫描slot中的所有设备，对于新发现的设备，添加到@bus->devices链表中，设置is_added=true
			 */
			 	   -> pci_scan_slot()
			 	   		-> pci_scan_single_device
			 	   			-> pci_scan_device
			 	   			-> pci_device_add(dev, bus) // 设备初始化，设置cap等，
            |-> pci_scan_bridge(bus, dev, max, pass);  // 扫描两遍
                -> pci_scan_bridge_extend(bus, dev, max, 0, pass);
				/* 扫描PCI桥和下面的所有总线，扫描两遍
				 * 第一遍扫描已经配置的总线，第二扫描并配置其他总线，在此过程中会设置每个slot热插拔的callback
				 */
                    -> pci_add_new_bus(bus, dev, secondary);
                        -> pci_alloc_child_bus
                            -> pcibios_add_bus(child)
                                -> acpi_pci_add_bus(bus)
                                    -> acpiphp_enumerate_slots(bus)
             /* 下面调用pcibios_resource_survey_bus函数为bridge分配资源，
              * 并对bus下面挂载的设备分配资源
              * 然后调用函数__pci_bus_assign_resources将分配的资源，设置到设备的配置空间中
              */
             |-> pcibios_resource_survey_bus(dev->subordinate); 
             |-> __pci_bus_assign_resources
             |-> 调用所有函数的驱动函数？

1
2
3
4
5
6
7
8
9
10
/*
 * ACPI Hotplug Context
 * --------------------
 */
struct acpi_hotplug_context {
>---struct acpi_device *self;
>---int (*notify)(struct acpi_device *, u32);
>---void (*uevent)(struct acpi_device *, u32);
>---void (*fixup)(struct acpi_device *);
};

1
2
pcibios_enable_irq = acpi_pci_irq_enable;
pcibios_disable_irq = acpi_pci_irq_disable;