evrgnini.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634
  1. /******************************************************************************
  2. *
  3. * Module Name: evrgnini- ACPI address_space (op_region) init
  4. *
  5. *****************************************************************************/
  6. /*
  7. * Copyright (C) 2000 - 2016, Intel Corp.
  8. * All rights reserved.
  9. *
  10. * Redistribution and use in source and binary forms, with or without
  11. * modification, are permitted provided that the following conditions
  12. * are met:
  13. * 1. Redistributions of source code must retain the above copyright
  14. * notice, this list of conditions, and the following disclaimer,
  15. * without modification.
  16. * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  17. * substantially similar to the "NO WARRANTY" disclaimer below
  18. * ("Disclaimer") and any redistribution must be conditioned upon
  19. * including a substantially similar Disclaimer requirement for further
  20. * binary redistribution.
  21. * 3. Neither the names of the above-listed copyright holders nor the names
  22. * of any contributors may be used to endorse or promote products derived
  23. * from this software without specific prior written permission.
  24. *
  25. * Alternatively, this software may be distributed under the terms of the
  26. * GNU General Public License ("GPL") version 2 as published by the Free
  27. * Software Foundation.
  28. *
  29. * NO WARRANTY
  30. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  31. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  32. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  33. * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  34. * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  36. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  37. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  38. * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  39. * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  40. * POSSIBILITY OF SUCH DAMAGES.
  41. */
  42. #include <acpi/acpi.h>
  43. #include "accommon.h"
  44. #include "acevents.h"
  45. #include "acnamesp.h"
  46. #include "acinterp.h"
  47. #define _COMPONENT ACPI_EVENTS
  48. ACPI_MODULE_NAME("evrgnini")
  49. /* Local prototypes */
  50. static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node);
  51. /*******************************************************************************
  52. *
  53. * FUNCTION: acpi_ev_system_memory_region_setup
  54. *
  55. * PARAMETERS: handle - Region we are interested in
  56. * function - Start or stop
  57. * handler_context - Address space handler context
  58. * region_context - Region specific context
  59. *
  60. * RETURN: Status
  61. *
  62. * DESCRIPTION: Setup a system_memory operation region
  63. *
  64. ******************************************************************************/
  65. acpi_status
  66. acpi_ev_system_memory_region_setup(acpi_handle handle,
  67. u32 function,
  68. void *handler_context, void **region_context)
  69. {
  70. union acpi_operand_object *region_desc =
  71. (union acpi_operand_object *)handle;
  72. struct acpi_mem_space_context *local_region_context;
  73. ACPI_FUNCTION_TRACE(ev_system_memory_region_setup);
  74. if (function == ACPI_REGION_DEACTIVATE) {
  75. if (*region_context) {
  76. local_region_context =
  77. (struct acpi_mem_space_context *)*region_context;
  78. /* Delete a cached mapping if present */
  79. if (local_region_context->mapped_length) {
  80. acpi_os_unmap_memory(local_region_context->
  81. mapped_logical_address,
  82. local_region_context->
  83. mapped_length);
  84. }
  85. ACPI_FREE(local_region_context);
  86. *region_context = NULL;
  87. }
  88. return_ACPI_STATUS(AE_OK);
  89. }
  90. /* Create a new context */
  91. local_region_context =
  92. ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context));
  93. if (!(local_region_context)) {
  94. return_ACPI_STATUS(AE_NO_MEMORY);
  95. }
  96. /* Save the region length and address for use in the handler */
  97. local_region_context->length = region_desc->region.length;
  98. local_region_context->address = region_desc->region.address;
  99. *region_context = local_region_context;
  100. return_ACPI_STATUS(AE_OK);
  101. }
  102. /*******************************************************************************
  103. *
  104. * FUNCTION: acpi_ev_io_space_region_setup
  105. *
  106. * PARAMETERS: handle - Region we are interested in
  107. * function - Start or stop
  108. * handler_context - Address space handler context
  109. * region_context - Region specific context
  110. *
  111. * RETURN: Status
  112. *
  113. * DESCRIPTION: Setup a IO operation region
  114. *
  115. ******************************************************************************/
  116. acpi_status
  117. acpi_ev_io_space_region_setup(acpi_handle handle,
  118. u32 function,
  119. void *handler_context, void **region_context)
  120. {
  121. ACPI_FUNCTION_TRACE(ev_io_space_region_setup);
  122. if (function == ACPI_REGION_DEACTIVATE) {
  123. *region_context = NULL;
  124. } else {
  125. *region_context = handler_context;
  126. }
  127. return_ACPI_STATUS(AE_OK);
  128. }
  129. /*******************************************************************************
  130. *
  131. * FUNCTION: acpi_ev_pci_config_region_setup
  132. *
  133. * PARAMETERS: handle - Region we are interested in
  134. * function - Start or stop
  135. * handler_context - Address space handler context
  136. * region_context - Region specific context
  137. *
  138. * RETURN: Status
  139. *
  140. * DESCRIPTION: Setup a PCI_Config operation region
  141. *
  142. * MUTEX: Assumes namespace is not locked
  143. *
  144. ******************************************************************************/
  145. acpi_status
  146. acpi_ev_pci_config_region_setup(acpi_handle handle,
  147. u32 function,
  148. void *handler_context, void **region_context)
  149. {
  150. acpi_status status = AE_OK;
  151. u64 pci_value;
  152. struct acpi_pci_id *pci_id = *region_context;
  153. union acpi_operand_object *handler_obj;
  154. struct acpi_namespace_node *parent_node;
  155. struct acpi_namespace_node *pci_root_node;
  156. struct acpi_namespace_node *pci_device_node;
  157. union acpi_operand_object *region_obj =
  158. (union acpi_operand_object *)handle;
  159. ACPI_FUNCTION_TRACE(ev_pci_config_region_setup);
  160. handler_obj = region_obj->region.handler;
  161. if (!handler_obj) {
  162. /*
  163. * No installed handler. This shouldn't happen because the dispatch
  164. * routine checks before we get here, but we check again just in case.
  165. */
  166. ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
  167. "Attempting to init a region %p, with no handler\n",
  168. region_obj));
  169. return_ACPI_STATUS(AE_NOT_EXIST);
  170. }
  171. *region_context = NULL;
  172. if (function == ACPI_REGION_DEACTIVATE) {
  173. if (pci_id) {
  174. ACPI_FREE(pci_id);
  175. }
  176. return_ACPI_STATUS(status);
  177. }
  178. parent_node = region_obj->region.node->parent;
  179. /*
  180. * Get the _SEG and _BBN values from the device upon which the handler
  181. * is installed.
  182. *
  183. * We need to get the _SEG and _BBN objects relative to the PCI BUS device.
  184. * This is the device the handler has been registered to handle.
  185. */
  186. /*
  187. * If the address_space.Node is still pointing to the root, we need
  188. * to scan upward for a PCI Root bridge and re-associate the op_region
  189. * handlers with that device.
  190. */
  191. if (handler_obj->address_space.node == acpi_gbl_root_node) {
  192. /* Start search from the parent object */
  193. pci_root_node = parent_node;
  194. while (pci_root_node != acpi_gbl_root_node) {
  195. /* Get the _HID/_CID in order to detect a root_bridge */
  196. if (acpi_ev_is_pci_root_bridge(pci_root_node)) {
  197. /* Install a handler for this PCI root bridge */
  198. status = acpi_install_address_space_handler((acpi_handle)pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
  199. if (ACPI_FAILURE(status)) {
  200. if (status == AE_SAME_HANDLER) {
  201. /*
  202. * It is OK if the handler is already installed on the
  203. * root bridge. Still need to return a context object
  204. * for the new PCI_Config operation region, however.
  205. */
  206. status = AE_OK;
  207. } else {
  208. ACPI_EXCEPTION((AE_INFO, status,
  209. "Could not install PciConfig handler "
  210. "for Root Bridge %4.4s",
  211. acpi_ut_get_node_name
  212. (pci_root_node)));
  213. }
  214. }
  215. break;
  216. }
  217. pci_root_node = pci_root_node->parent;
  218. }
  219. /* PCI root bridge not found, use namespace root node */
  220. } else {
  221. pci_root_node = handler_obj->address_space.node;
  222. }
  223. /*
  224. * If this region is now initialized, we are done.
  225. * (install_address_space_handler could have initialized it)
  226. */
  227. if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) {
  228. return_ACPI_STATUS(AE_OK);
  229. }
  230. /* Region is still not initialized. Create a new context */
  231. pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id));
  232. if (!pci_id) {
  233. return_ACPI_STATUS(AE_NO_MEMORY);
  234. }
  235. /*
  236. * For PCI_Config space access, we need the segment, bus, device and
  237. * function numbers. Acquire them here.
  238. *
  239. * Find the parent device object. (This allows the operation region to be
  240. * within a subscope under the device, such as a control method.)
  241. */
  242. pci_device_node = region_obj->region.node;
  243. while (pci_device_node && (pci_device_node->type != ACPI_TYPE_DEVICE)) {
  244. pci_device_node = pci_device_node->parent;
  245. }
  246. if (!pci_device_node) {
  247. ACPI_FREE(pci_id);
  248. return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
  249. }
  250. /*
  251. * Get the PCI device and function numbers from the _ADR object
  252. * contained in the parent's scope.
  253. */
  254. status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR,
  255. pci_device_node, &pci_value);
  256. /*
  257. * The default is zero, and since the allocation above zeroed the data,
  258. * just do nothing on failure.
  259. */
  260. if (ACPI_SUCCESS(status)) {
  261. pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value));
  262. pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value));
  263. }
  264. /* The PCI segment number comes from the _SEG method */
  265. status = acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG,
  266. pci_root_node, &pci_value);
  267. if (ACPI_SUCCESS(status)) {
  268. pci_id->segment = ACPI_LOWORD(pci_value);
  269. }
  270. /* The PCI bus number comes from the _BBN method */
  271. status = acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN,
  272. pci_root_node, &pci_value);
  273. if (ACPI_SUCCESS(status)) {
  274. pci_id->bus = ACPI_LOWORD(pci_value);
  275. }
  276. /* Complete/update the PCI ID for this device */
  277. status =
  278. acpi_hw_derive_pci_id(pci_id, pci_root_node,
  279. region_obj->region.node);
  280. if (ACPI_FAILURE(status)) {
  281. ACPI_FREE(pci_id);
  282. return_ACPI_STATUS(status);
  283. }
  284. *region_context = pci_id;
  285. return_ACPI_STATUS(AE_OK);
  286. }
  287. /*******************************************************************************
  288. *
  289. * FUNCTION: acpi_ev_is_pci_root_bridge
  290. *
  291. * PARAMETERS: node - Device node being examined
  292. *
  293. * RETURN: TRUE if device is a PCI/PCI-Express Root Bridge
  294. *
  295. * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by
  296. * examining the _HID and _CID for the device.
  297. *
  298. ******************************************************************************/
  299. static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node)
  300. {
  301. acpi_status status;
  302. struct acpi_pnp_device_id *hid;
  303. struct acpi_pnp_device_id_list *cid;
  304. u32 i;
  305. u8 match;
  306. /* Get the _HID and check for a PCI Root Bridge */
  307. status = acpi_ut_execute_HID(node, &hid);
  308. if (ACPI_FAILURE(status)) {
  309. return (FALSE);
  310. }
  311. match = acpi_ut_is_pci_root_bridge(hid->string);
  312. ACPI_FREE(hid);
  313. if (match) {
  314. return (TRUE);
  315. }
  316. /* The _HID did not match. Get the _CID and check for a PCI Root Bridge */
  317. status = acpi_ut_execute_CID(node, &cid);
  318. if (ACPI_FAILURE(status)) {
  319. return (FALSE);
  320. }
  321. /* Check all _CIDs in the returned list */
  322. for (i = 0; i < cid->count; i++) {
  323. if (acpi_ut_is_pci_root_bridge(cid->ids[i].string)) {
  324. ACPI_FREE(cid);
  325. return (TRUE);
  326. }
  327. }
  328. ACPI_FREE(cid);
  329. return (FALSE);
  330. }
  331. /*******************************************************************************
  332. *
  333. * FUNCTION: acpi_ev_pci_bar_region_setup
  334. *
  335. * PARAMETERS: handle - Region we are interested in
  336. * function - Start or stop
  337. * handler_context - Address space handler context
  338. * region_context - Region specific context
  339. *
  340. * RETURN: Status
  341. *
  342. * DESCRIPTION: Setup a pci_BAR operation region
  343. *
  344. * MUTEX: Assumes namespace is not locked
  345. *
  346. ******************************************************************************/
  347. acpi_status
  348. acpi_ev_pci_bar_region_setup(acpi_handle handle,
  349. u32 function,
  350. void *handler_context, void **region_context)
  351. {
  352. ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup);
  353. return_ACPI_STATUS(AE_OK);
  354. }
  355. /*******************************************************************************
  356. *
  357. * FUNCTION: acpi_ev_cmos_region_setup
  358. *
  359. * PARAMETERS: handle - Region we are interested in
  360. * function - Start or stop
  361. * handler_context - Address space handler context
  362. * region_context - Region specific context
  363. *
  364. * RETURN: Status
  365. *
  366. * DESCRIPTION: Setup a CMOS operation region
  367. *
  368. * MUTEX: Assumes namespace is not locked
  369. *
  370. ******************************************************************************/
  371. acpi_status
  372. acpi_ev_cmos_region_setup(acpi_handle handle,
  373. u32 function,
  374. void *handler_context, void **region_context)
  375. {
  376. ACPI_FUNCTION_TRACE(ev_cmos_region_setup);
  377. return_ACPI_STATUS(AE_OK);
  378. }
  379. /*******************************************************************************
  380. *
  381. * FUNCTION: acpi_ev_default_region_setup
  382. *
  383. * PARAMETERS: handle - Region we are interested in
  384. * function - Start or stop
  385. * handler_context - Address space handler context
  386. * region_context - Region specific context
  387. *
  388. * RETURN: Status
  389. *
  390. * DESCRIPTION: Default region initialization
  391. *
  392. ******************************************************************************/
  393. acpi_status
  394. acpi_ev_default_region_setup(acpi_handle handle,
  395. u32 function,
  396. void *handler_context, void **region_context)
  397. {
  398. ACPI_FUNCTION_TRACE(ev_default_region_setup);
  399. if (function == ACPI_REGION_DEACTIVATE) {
  400. *region_context = NULL;
  401. } else {
  402. *region_context = handler_context;
  403. }
  404. return_ACPI_STATUS(AE_OK);
  405. }
  406. /*******************************************************************************
  407. *
  408. * FUNCTION: acpi_ev_initialize_region
  409. *
  410. * PARAMETERS: region_obj - Region we are initializing
  411. * acpi_ns_locked - Is namespace locked?
  412. *
  413. * RETURN: Status
  414. *
  415. * DESCRIPTION: Initializes the region, finds any _REG methods and saves them
  416. * for execution at a later time
  417. *
  418. * Get the appropriate address space handler for a newly
  419. * created region.
  420. *
  421. * This also performs address space specific initialization. For
  422. * example, PCI regions must have an _ADR object that contains
  423. * a PCI address in the scope of the definition. This address is
  424. * required to perform an access to PCI config space.
  425. *
  426. * MUTEX: Interpreter should be unlocked, because we may run the _REG
  427. * method for this region.
  428. *
  429. ******************************************************************************/
  430. acpi_status
  431. acpi_ev_initialize_region(union acpi_operand_object *region_obj,
  432. u8 acpi_ns_locked)
  433. {
  434. union acpi_operand_object *handler_obj;
  435. union acpi_operand_object *obj_desc;
  436. acpi_adr_space_type space_id;
  437. struct acpi_namespace_node *node;
  438. acpi_status status;
  439. ACPI_FUNCTION_TRACE_U32(ev_initialize_region, acpi_ns_locked);
  440. if (!region_obj) {
  441. return_ACPI_STATUS(AE_BAD_PARAMETER);
  442. }
  443. if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) {
  444. return_ACPI_STATUS(AE_OK);
  445. }
  446. region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED;
  447. node = region_obj->region.node->parent;
  448. space_id = region_obj->region.space_id;
  449. /*
  450. * The following loop depends upon the root Node having no parent
  451. * ie: acpi_gbl_root_node->Parent being set to NULL
  452. */
  453. while (node) {
  454. /* Check to see if a handler exists */
  455. handler_obj = NULL;
  456. obj_desc = acpi_ns_get_attached_object(node);
  457. if (obj_desc) {
  458. /* Can only be a handler if the object exists */
  459. switch (node->type) {
  460. case ACPI_TYPE_DEVICE:
  461. case ACPI_TYPE_PROCESSOR:
  462. case ACPI_TYPE_THERMAL:
  463. handler_obj = obj_desc->common_notify.handler;
  464. break;
  465. case ACPI_TYPE_METHOD:
  466. /*
  467. * If we are executing module level code, the original
  468. * Node's object was replaced by this Method object and we
  469. * saved the handler in the method object.
  470. *
  471. * See acpi_ns_exec_module_code
  472. */
  473. if (!acpi_gbl_parse_table_as_term_list &&
  474. obj_desc->method.
  475. info_flags & ACPI_METHOD_MODULE_LEVEL) {
  476. handler_obj =
  477. obj_desc->method.dispatch.handler;
  478. }
  479. break;
  480. default:
  481. /* Ignore other objects */
  482. break;
  483. }
  484. handler_obj =
  485. acpi_ev_find_region_handler(space_id, handler_obj);
  486. if (handler_obj) {
  487. /* Found correct handler */
  488. ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
  489. "Found handler %p for region %p in obj %p\n",
  490. handler_obj, region_obj,
  491. obj_desc));
  492. status =
  493. acpi_ev_attach_region(handler_obj,
  494. region_obj,
  495. acpi_ns_locked);
  496. /*
  497. * Tell all users that this region is usable by
  498. * running the _REG method
  499. */
  500. if (acpi_ns_locked) {
  501. status =
  502. acpi_ut_release_mutex
  503. (ACPI_MTX_NAMESPACE);
  504. if (ACPI_FAILURE(status)) {
  505. return_ACPI_STATUS(status);
  506. }
  507. }
  508. acpi_ex_exit_interpreter();
  509. status =
  510. acpi_ev_execute_reg_method(region_obj,
  511. ACPI_REG_CONNECT);
  512. acpi_ex_enter_interpreter();
  513. if (acpi_ns_locked) {
  514. status =
  515. acpi_ut_acquire_mutex
  516. (ACPI_MTX_NAMESPACE);
  517. if (ACPI_FAILURE(status)) {
  518. return_ACPI_STATUS(status);
  519. }
  520. }
  521. return_ACPI_STATUS(AE_OK);
  522. }
  523. }
  524. /* This node does not have the handler we need; Pop up one level */
  525. node = node->parent;
  526. }
  527. /* If we get here, there is no handler for this region */
  528. ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
  529. "No handler for RegionType %s(%X) (RegionObj %p)\n",
  530. acpi_ut_get_region_name(space_id), space_id,
  531. region_obj));
  532. return_ACPI_STATUS(AE_NOT_EXIST);
  533. }