evrgnini.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579
  1. /******************************************************************************
  2. *
  3. * Module Name: evrgnini- ACPI address_space (op_region) init
  4. *
  5. *****************************************************************************/
  6. /*
  7. * Copyright (C) 2000 - 2006, R. Byron Moore
  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 <acpi/acevents.h>
  44. #include <acpi/acnamesp.h>
  45. #define _COMPONENT ACPI_EVENTS
  46. ACPI_MODULE_NAME("evrgnini")
  47. /*******************************************************************************
  48. *
  49. * FUNCTION: acpi_ev_system_memory_region_setup
  50. *
  51. * PARAMETERS: Handle - Region we are interested in
  52. * Function - Start or stop
  53. * handler_context - Address space handler context
  54. * region_context - Region specific context
  55. *
  56. * RETURN: Status
  57. *
  58. * DESCRIPTION: Setup a system_memory operation region
  59. *
  60. ******************************************************************************/
  61. acpi_status
  62. acpi_ev_system_memory_region_setup(acpi_handle handle,
  63. u32 function,
  64. void *handler_context, void **region_context)
  65. {
  66. union acpi_operand_object *region_desc =
  67. (union acpi_operand_object *)handle;
  68. struct acpi_mem_space_context *local_region_context;
  69. ACPI_FUNCTION_TRACE("ev_system_memory_region_setup");
  70. if (function == ACPI_REGION_DEACTIVATE) {
  71. if (*region_context) {
  72. ACPI_MEM_FREE(*region_context);
  73. *region_context = NULL;
  74. }
  75. return_ACPI_STATUS(AE_OK);
  76. }
  77. /* Create a new context */
  78. local_region_context =
  79. ACPI_MEM_CALLOCATE(sizeof(struct acpi_mem_space_context));
  80. if (!(local_region_context)) {
  81. return_ACPI_STATUS(AE_NO_MEMORY);
  82. }
  83. /* Save the region length and address for use in the handler */
  84. local_region_context->length = region_desc->region.length;
  85. local_region_context->address = region_desc->region.address;
  86. *region_context = local_region_context;
  87. return_ACPI_STATUS(AE_OK);
  88. }
  89. /*******************************************************************************
  90. *
  91. * FUNCTION: acpi_ev_io_space_region_setup
  92. *
  93. * PARAMETERS: Handle - Region we are interested in
  94. * Function - Start or stop
  95. * handler_context - Address space handler context
  96. * region_context - Region specific context
  97. *
  98. * RETURN: Status
  99. *
  100. * DESCRIPTION: Setup a IO operation region
  101. *
  102. ******************************************************************************/
  103. acpi_status
  104. acpi_ev_io_space_region_setup(acpi_handle handle,
  105. u32 function,
  106. void *handler_context, void **region_context)
  107. {
  108. ACPI_FUNCTION_TRACE("ev_io_space_region_setup");
  109. if (function == ACPI_REGION_DEACTIVATE) {
  110. *region_context = NULL;
  111. } else {
  112. *region_context = handler_context;
  113. }
  114. return_ACPI_STATUS(AE_OK);
  115. }
  116. /*******************************************************************************
  117. *
  118. * FUNCTION: acpi_ev_pci_config_region_setup
  119. *
  120. * PARAMETERS: Handle - Region we are interested in
  121. * Function - Start or stop
  122. * handler_context - Address space handler context
  123. * region_context - Region specific context
  124. *
  125. * RETURN: Status
  126. *
  127. * DESCRIPTION: Setup a PCI_Config operation region
  128. *
  129. * MUTEX: Assumes namespace is not locked
  130. *
  131. ******************************************************************************/
  132. acpi_status
  133. acpi_ev_pci_config_region_setup(acpi_handle handle,
  134. u32 function,
  135. void *handler_context, void **region_context)
  136. {
  137. acpi_status status = AE_OK;
  138. acpi_integer pci_value;
  139. struct acpi_pci_id *pci_id = *region_context;
  140. union acpi_operand_object *handler_obj;
  141. struct acpi_namespace_node *parent_node;
  142. struct acpi_namespace_node *pci_root_node;
  143. union acpi_operand_object *region_obj =
  144. (union acpi_operand_object *)handle;
  145. struct acpi_device_id object_hID;
  146. ACPI_FUNCTION_TRACE("ev_pci_config_region_setup");
  147. handler_obj = region_obj->region.handler;
  148. if (!handler_obj) {
  149. /*
  150. * No installed handler. This shouldn't happen because the dispatch
  151. * routine checks before we get here, but we check again just in case.
  152. */
  153. ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
  154. "Attempting to init a region %p, with no handler\n",
  155. region_obj));
  156. return_ACPI_STATUS(AE_NOT_EXIST);
  157. }
  158. *region_context = NULL;
  159. if (function == ACPI_REGION_DEACTIVATE) {
  160. if (pci_id) {
  161. ACPI_MEM_FREE(pci_id);
  162. }
  163. return_ACPI_STATUS(status);
  164. }
  165. parent_node = acpi_ns_get_parent_node(region_obj->region.node);
  166. /*
  167. * Get the _SEG and _BBN values from the device upon which the handler
  168. * is installed.
  169. *
  170. * We need to get the _SEG and _BBN objects relative to the PCI BUS device.
  171. * This is the device the handler has been registered to handle.
  172. */
  173. /*
  174. * If the address_space.Node is still pointing to the root, we need
  175. * to scan upward for a PCI Root bridge and re-associate the op_region
  176. * handlers with that device.
  177. */
  178. if (handler_obj->address_space.node == acpi_gbl_root_node) {
  179. /* Start search from the parent object */
  180. pci_root_node = parent_node;
  181. while (pci_root_node != acpi_gbl_root_node) {
  182. status =
  183. acpi_ut_execute_HID(pci_root_node, &object_hID);
  184. if (ACPI_SUCCESS(status)) {
  185. /*
  186. * Got a valid _HID string, check if this is a PCI root.
  187. * New for ACPI 3.0: check for a PCI Express root also.
  188. */
  189. if (!
  190. (ACPI_STRNCMP
  191. (object_hID.value, PCI_ROOT_HID_STRING,
  192. sizeof(PCI_ROOT_HID_STRING))
  193. ||
  194. !(ACPI_STRNCMP
  195. (object_hID.value,
  196. PCI_EXPRESS_ROOT_HID_STRING,
  197. sizeof(PCI_EXPRESS_ROOT_HID_STRING)))))
  198. {
  199. /* Install a handler for this PCI root bridge */
  200. status =
  201. acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
  202. if (ACPI_FAILURE(status)) {
  203. if (status == AE_SAME_HANDLER) {
  204. /*
  205. * It is OK if the handler is already installed on the root
  206. * bridge. Still need to return a context object for the
  207. * new PCI_Config operation region, however.
  208. */
  209. status = AE_OK;
  210. } else {
  211. ACPI_EXCEPTION((AE_INFO,
  212. status,
  213. "Could not install pci_config handler for Root Bridge %4.4s",
  214. acpi_ut_get_node_name
  215. (pci_root_node)));
  216. }
  217. }
  218. break;
  219. }
  220. }
  221. pci_root_node = acpi_ns_get_parent_node(pci_root_node);
  222. }
  223. /* PCI root bridge not found, use namespace root node */
  224. } else {
  225. pci_root_node = handler_obj->address_space.node;
  226. }
  227. /*
  228. * If this region is now initialized, we are done.
  229. * (install_address_space_handler could have initialized it)
  230. */
  231. if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) {
  232. return_ACPI_STATUS(AE_OK);
  233. }
  234. /* Region is still not initialized. Create a new context */
  235. pci_id = ACPI_MEM_CALLOCATE(sizeof(struct acpi_pci_id));
  236. if (!pci_id) {
  237. return_ACPI_STATUS(AE_NO_MEMORY);
  238. }
  239. /*
  240. * For PCI_Config space access, we need the segment, bus,
  241. * device and function numbers. Acquire them here.
  242. */
  243. /*
  244. * Get the PCI device and function numbers from the _ADR object
  245. * contained in the parent's scope.
  246. */
  247. status =
  248. acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, parent_node,
  249. &pci_value);
  250. /*
  251. * The default is zero, and since the allocation above zeroed
  252. * the data, just do nothing on failure.
  253. */
  254. if (ACPI_SUCCESS(status)) {
  255. pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value));
  256. pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value));
  257. }
  258. /* The PCI segment number comes from the _SEG method */
  259. status =
  260. acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG, pci_root_node,
  261. &pci_value);
  262. if (ACPI_SUCCESS(status)) {
  263. pci_id->segment = ACPI_LOWORD(pci_value);
  264. }
  265. /* The PCI bus number comes from the _BBN method */
  266. status =
  267. acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN, pci_root_node,
  268. &pci_value);
  269. if (ACPI_SUCCESS(status)) {
  270. pci_id->bus = ACPI_LOWORD(pci_value);
  271. }
  272. /* Complete this device's pci_id */
  273. acpi_os_derive_pci_id(pci_root_node, region_obj->region.node, &pci_id);
  274. *region_context = pci_id;
  275. return_ACPI_STATUS(AE_OK);
  276. }
  277. /*******************************************************************************
  278. *
  279. * FUNCTION: acpi_ev_pci_bar_region_setup
  280. *
  281. * PARAMETERS: Handle - Region we are interested in
  282. * Function - Start or stop
  283. * handler_context - Address space handler context
  284. * region_context - Region specific context
  285. *
  286. * RETURN: Status
  287. *
  288. * DESCRIPTION: Setup a pci_bAR operation region
  289. *
  290. * MUTEX: Assumes namespace is not locked
  291. *
  292. ******************************************************************************/
  293. acpi_status
  294. acpi_ev_pci_bar_region_setup(acpi_handle handle,
  295. u32 function,
  296. void *handler_context, void **region_context)
  297. {
  298. ACPI_FUNCTION_TRACE("ev_pci_bar_region_setup");
  299. return_ACPI_STATUS(AE_OK);
  300. }
  301. /*******************************************************************************
  302. *
  303. * FUNCTION: acpi_ev_cmos_region_setup
  304. *
  305. * PARAMETERS: Handle - Region we are interested in
  306. * Function - Start or stop
  307. * handler_context - Address space handler context
  308. * region_context - Region specific context
  309. *
  310. * RETURN: Status
  311. *
  312. * DESCRIPTION: Setup a CMOS operation region
  313. *
  314. * MUTEX: Assumes namespace is not locked
  315. *
  316. ******************************************************************************/
  317. acpi_status
  318. acpi_ev_cmos_region_setup(acpi_handle handle,
  319. u32 function,
  320. void *handler_context, void **region_context)
  321. {
  322. ACPI_FUNCTION_TRACE("ev_cmos_region_setup");
  323. return_ACPI_STATUS(AE_OK);
  324. }
  325. /*******************************************************************************
  326. *
  327. * FUNCTION: acpi_ev_default_region_setup
  328. *
  329. * PARAMETERS: Handle - Region we are interested in
  330. * Function - Start or stop
  331. * handler_context - Address space handler context
  332. * region_context - Region specific context
  333. *
  334. * RETURN: Status
  335. *
  336. * DESCRIPTION: Default region initialization
  337. *
  338. ******************************************************************************/
  339. acpi_status
  340. acpi_ev_default_region_setup(acpi_handle handle,
  341. u32 function,
  342. void *handler_context, void **region_context)
  343. {
  344. ACPI_FUNCTION_TRACE("ev_default_region_setup");
  345. if (function == ACPI_REGION_DEACTIVATE) {
  346. *region_context = NULL;
  347. } else {
  348. *region_context = handler_context;
  349. }
  350. return_ACPI_STATUS(AE_OK);
  351. }
  352. /*******************************************************************************
  353. *
  354. * FUNCTION: acpi_ev_initialize_region
  355. *
  356. * PARAMETERS: region_obj - Region we are initializing
  357. * acpi_ns_locked - Is namespace locked?
  358. *
  359. * RETURN: Status
  360. *
  361. * DESCRIPTION: Initializes the region, finds any _REG methods and saves them
  362. * for execution at a later time
  363. *
  364. * Get the appropriate address space handler for a newly
  365. * created region.
  366. *
  367. * This also performs address space specific initialization. For
  368. * example, PCI regions must have an _ADR object that contains
  369. * a PCI address in the scope of the definition. This address is
  370. * required to perform an access to PCI config space.
  371. *
  372. ******************************************************************************/
  373. acpi_status
  374. acpi_ev_initialize_region(union acpi_operand_object *region_obj,
  375. u8 acpi_ns_locked)
  376. {
  377. union acpi_operand_object *handler_obj;
  378. union acpi_operand_object *obj_desc;
  379. acpi_adr_space_type space_id;
  380. struct acpi_namespace_node *node;
  381. acpi_status status;
  382. struct acpi_namespace_node *method_node;
  383. acpi_name *reg_name_ptr = (acpi_name *) METHOD_NAME__REG;
  384. union acpi_operand_object *region_obj2;
  385. ACPI_FUNCTION_TRACE_U32("ev_initialize_region", acpi_ns_locked);
  386. if (!region_obj) {
  387. return_ACPI_STATUS(AE_BAD_PARAMETER);
  388. }
  389. if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) {
  390. return_ACPI_STATUS(AE_OK);
  391. }
  392. region_obj2 = acpi_ns_get_secondary_object(region_obj);
  393. if (!region_obj2) {
  394. return_ACPI_STATUS(AE_NOT_EXIST);
  395. }
  396. node = acpi_ns_get_parent_node(region_obj->region.node);
  397. space_id = region_obj->region.space_id;
  398. /* Setup defaults */
  399. region_obj->region.handler = NULL;
  400. region_obj2->extra.method_REG = NULL;
  401. region_obj->common.flags &= ~(AOPOBJ_SETUP_COMPLETE);
  402. region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED;
  403. /* Find any "_REG" method associated with this region definition */
  404. status = acpi_ns_search_node(*reg_name_ptr, node,
  405. ACPI_TYPE_METHOD, &method_node);
  406. if (ACPI_SUCCESS(status)) {
  407. /*
  408. * The _REG method is optional and there can be only one per region
  409. * definition. This will be executed when the handler is attached
  410. * or removed
  411. */
  412. region_obj2->extra.method_REG = method_node;
  413. }
  414. /*
  415. * The following loop depends upon the root Node having no parent
  416. * ie: acpi_gbl_root_node->parent_entry being set to NULL
  417. */
  418. while (node) {
  419. /* Check to see if a handler exists */
  420. handler_obj = NULL;
  421. obj_desc = acpi_ns_get_attached_object(node);
  422. if (obj_desc) {
  423. /* Can only be a handler if the object exists */
  424. switch (node->type) {
  425. case ACPI_TYPE_DEVICE:
  426. handler_obj = obj_desc->device.handler;
  427. break;
  428. case ACPI_TYPE_PROCESSOR:
  429. handler_obj = obj_desc->processor.handler;
  430. break;
  431. case ACPI_TYPE_THERMAL:
  432. handler_obj = obj_desc->thermal_zone.handler;
  433. break;
  434. default:
  435. /* Ignore other objects */
  436. break;
  437. }
  438. while (handler_obj) {
  439. /* Is this handler of the correct type? */
  440. if (handler_obj->address_space.space_id ==
  441. space_id) {
  442. /* Found correct handler */
  443. ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
  444. "Found handler %p for region %p in obj %p\n",
  445. handler_obj,
  446. region_obj,
  447. obj_desc));
  448. status =
  449. acpi_ev_attach_region(handler_obj,
  450. region_obj,
  451. acpi_ns_locked);
  452. /*
  453. * Tell all users that this region is usable by running the _REG
  454. * method
  455. */
  456. if (acpi_ns_locked) {
  457. status =
  458. acpi_ut_release_mutex
  459. (ACPI_MTX_NAMESPACE);
  460. if (ACPI_FAILURE(status)) {
  461. return_ACPI_STATUS
  462. (status);
  463. }
  464. }
  465. status =
  466. acpi_ev_execute_reg_method
  467. (region_obj, 1);
  468. if (acpi_ns_locked) {
  469. status =
  470. acpi_ut_acquire_mutex
  471. (ACPI_MTX_NAMESPACE);
  472. if (ACPI_FAILURE(status)) {
  473. return_ACPI_STATUS
  474. (status);
  475. }
  476. }
  477. return_ACPI_STATUS(AE_OK);
  478. }
  479. /* Try next handler in the list */
  480. handler_obj = handler_obj->address_space.next;
  481. }
  482. }
  483. /*
  484. * This node does not have the handler we need;
  485. * Pop up one level
  486. */
  487. node = acpi_ns_get_parent_node(node);
  488. }
  489. /* If we get here, there is no handler for this region */
  490. ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
  491. "No handler for region_type %s(%X) (region_obj %p)\n",
  492. acpi_ut_get_region_name(space_id), space_id,
  493. region_obj));
  494. return_ACPI_STATUS(AE_NOT_EXIST);
  495. }