开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
pr.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：11k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

pr.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * Module Name: pr.c
  4.  *   $Revision: 34 $
  5.  *
  6.  *****************************************************************************/
  8. /*
  9.  *  Copyright (C) 2000, 2001 Andrew Grover
  10.  *
  11.  *  This program is free software; you can redistribute it and/or modify
  12.  *  it under the terms of the GNU General Public License as published by
  13.  *  the Free Software Foundation; either version 2 of the License, or
  14.  *  (at your option) any later version.
  15.  *
  16.  *  This program is distributed in the hope that it will be useful,
  17.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  *  GNU General Public License for more details.
  20.  *
  21.  *  You should have received a copy of the GNU General Public License
  22.  *  along with this program; if not, write to the Free Software
  23.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24.  */
  27. #include <acpi.h>
  28. #include <bm.h>
  29. #include "pr.h"
  32. #define _COMPONENT ACPI_PROCESSOR
  33. MODULE_NAME ("pr")
  36. /****************************************************************************
  37.  *                                  Globals
  38.  ****************************************************************************/
  40. extern fadt_descriptor_rev2 acpi_fadt;
  43. /****************************************************************************
  44.  *                             Internal Functions
  45.  ****************************************************************************/
  47. /****************************************************************************
  48.  *
  49.  * FUNCTION:    pr_print
  50.  *
  51.  * PARAMETERS:
  52.  *
  53.  * RETURN:
  54.  *
  55.  * DESCRIPTION: Prints out information on a specific thermal zone.
  56.  *
  57.  ****************************************************************************/
  59. void
  60. pr_print (
  61. PR_CONTEXT              *processor)
  62. {
  63. #ifdef ACPI_DEBUG
  64. acpi_buffer             buffer;
  66. FUNCTION_TRACE("pr_print");
  68. buffer.length = 256;
  69. buffer.pointer = acpi_os_callocate(buffer.length);
  70. if (!buffer.pointer) {
  71. return;
  72. }
  74. /*
  75.  * Get the full pathname for this ACPI object.
  76.  */
  77. acpi_get_name(processor->acpi_handle, ACPI_FULL_PATHNAME, &buffer);
  79. /*
  80.  * Print out basic processor information.
  81.  */
  82. ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "+------------------------------------------------------------n"));
  83. ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "| Processor[%02x]:[%p] uid[%02x] %sn", processor->device_handle, processor->acpi_handle, processor->uid, (char*)buffer.pointer));
  84. ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "|   power: %cC0 %cC1 %cC2[%d] %cC3[%d]n", (processor->power.state[0].is_valid?'+':'-'), (processor->power.state[1].is_valid?'+':'-'), (processor->power.state[2].is_valid?'+':'-'), processor->power.state[2].latency, (processor->power.state[3].is_valid?'+':'-'), processor->power.state[3].latency));
  85. ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "|   performance: states[%d]n", processor->performance.state_count));
  86. ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO, "+------------------------------------------------------------n"));
  88. acpi_os_free(buffer.pointer);
  89. #endif /* ACPI_DEBUG */
  91. return;
  92. }
  95. /****************************************************************************
  96.  *
  97.  * FUNCTION:    pr_add_device
  98.  *
  99.  * PARAMETERS:  <none>
  100.  *
  101.  * RETURN:
  102.  *
  103.  * DESCRIPTION:
  104.  *
  105.  ****************************************************************************/
  107. acpi_status
  108. pr_add_device(
  109. BM_HANDLE device_handle,
  110. void **context)
  111. {
  112. acpi_status status = AE_OK;
  113. PR_CONTEXT *processor = NULL;
  114. BM_DEVICE *device = NULL;
  115. acpi_buffer buffer;
  116. acpi_object acpi_object;
  117. static u32 processor_count = 0;
  120. FUNCTION_TRACE("pr_add_device");
  122. if (!context || *context) {
  123. return_ACPI_STATUS(AE_BAD_PARAMETER);
  124. }
  126. status = bm_get_device_info(device_handle, &device);
  127. if (ACPI_FAILURE(status)) {
  128. return_ACPI_STATUS(status);
  129. }
  131. processor = acpi_os_callocate(sizeof(PR_CONTEXT));
  132. if (!processor) {
  133. return AE_NO_MEMORY;
  134. }
  136. processor->device_handle = device->handle;
  137. processor->acpi_handle = device->acpi_handle;
  139. /*
  140.  * Processor Block:
  141.  * ----------------
  142.  */
  143. memset(&acpi_object, 0, sizeof(acpi_object));
  145. buffer.length = sizeof(acpi_object);
  146. buffer.pointer = &acpi_object;
  148. status = acpi_evaluate_object(processor->acpi_handle, NULL, NULL, &buffer);
  149. if (ACPI_FAILURE(status)) {
  150. goto end;
  151. }
  153. /*
  154.  * Processor ID:
  155.  * -------------
  156.  * TBD:  We need to synchronize the processor ID values in ACPI
  157.  *       with those of the APIC.  For example, an IBM T20 has a
  158.  *       proc_id value of '1', where the Linux value for the
  159.  *       first CPU on this system is '0'.  Since x86 CPUs are
  160.  *       mapped 1:1 we can simply use a zero-based counter.  Note
  161.  *       that this assumes that processor objects are enumerated
  162.  *       in the proper order.
  163.  */
  164. /* processor->uid = acpi_object.processor.proc_id; */
  165. processor->uid = processor_count++;
  167. processor->pblk.length = acpi_object.processor.pblk_length;
  168. processor->pblk.address = acpi_object.processor.pblk_address;
  170. status = pr_power_add_device(processor);
  171. if (ACPI_FAILURE(status)) {
  172. goto end;
  173. }
  175. status = pr_perf_add_device(processor);
  176. if (ACPI_FAILURE(status)) {
  177. goto end;
  178. }
  180. status = pr_osl_add_device(processor);
  181. if (ACPI_FAILURE(status)) {
  182. goto end;
  183. }
  185. *context = processor;
  187. pr_print(processor);
  189. end:
  190. if (ACPI_FAILURE(status)) {
  191. acpi_os_free(processor);
  192. }
  194. return_ACPI_STATUS(status);
  195. }
  198. /****************************************************************************
  199.  *
  200.  * FUNCTION:    pr_remove_device
  201.  *
  202.  * PARAMETERS:  <none>
  203.  *
  204.  * RETURN:
  205.  *
  206.  * DESCRIPTION:
  207.  *
  208.  ****************************************************************************/
  210. acpi_status
  211. pr_remove_device (
  212. void **context)
  213. {
  214. acpi_status status = AE_OK;
  215. PR_CONTEXT *processor= NULL;
  217. FUNCTION_TRACE("pr_remove_device");
  219. if (!context || !*context) {
  220. return_ACPI_STATUS(AE_BAD_PARAMETER);
  221. }
  223. processor = (PR_CONTEXT*)(*context);
  225. ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Removing processor device [%02x].n", processor->device_handle));
  227. pr_osl_remove_device(processor);
  229. pr_perf_remove_device(processor);
  231. pr_power_remove_device(processor);
  233. acpi_os_free(processor);
  235. return_ACPI_STATUS(status);
  236. }
  239. /****************************************************************************
  240.  *                            External Functions
  241.  ****************************************************************************/
  243. /****************************************************************************
  244.  *
  245.  * FUNCTION:    pr_initialize
  246.  *
  247.  * PARAMETERS:  <none>
  248.  *
  249.  * RETURN:
  250.  *
  251.  * DESCRIPTION:
  252.  *
  253.  ****************************************************************************/
  255. acpi_status
  256. pr_initialize (void)
  257. {
  258. acpi_status status = AE_OK;
  259. BM_DEVICE_ID criteria;
  260. BM_DRIVER driver;
  262. FUNCTION_TRACE("pr_initialize");
  264. memset(&criteria, 0, sizeof(BM_DEVICE_ID));
  265. memset(&driver, 0, sizeof(BM_DRIVER));
  267. /*
  268.  * Initialize power (Cx state) policy.
  269.  */
  270. status = pr_power_initialize();
  271. if (ACPI_FAILURE(status)) {
  272. return_ACPI_STATUS(status);
  273. }
  275. /*
  276.  * Register driver for processor devices.
  277.  */
  278. criteria.type = BM_TYPE_PROCESSOR;
  280. driver.notify = &pr_notify;
  281. driver.request = &pr_request;
  283. status = bm_register_driver(&criteria, &driver);
  285. return_ACPI_STATUS(status);
  286. }
  289. /****************************************************************************
  290.  *
  291.  * FUNCTION:    pr_terminate
  292.  *
  293.  * PARAMETERS:  <none>
  294.  *
  295.  * RETURN:
  296.  *
  297.  * DESCRIPTION:
  298.  *
  299.  ****************************************************************************/
  301. acpi_status
  302. pr_terminate (void)
  303. {
  304. acpi_status             status = AE_OK;
  305. BM_DEVICE_ID criteria;
  306. BM_DRIVER driver;
  308. FUNCTION_TRACE("pr_terminate");
  310. memset(&criteria, 0, sizeof(BM_DEVICE_ID));
  311. memset(&driver, 0, sizeof(BM_DRIVER));
  313. /*
  314.  * Terminate power (Cx state) policy.
  315.  */
  316. status = pr_power_terminate();
  317. if (ACPI_FAILURE(status)) {
  318. return_ACPI_STATUS(status);
  319. }
  321. /*
  322.  * Unegister driver for processor devices.
  323.  */
  324. criteria.type = BM_TYPE_PROCESSOR;
  326. driver.notify = &pr_notify;
  327. driver.request = &pr_request;
  329. status = bm_unregister_driver(&criteria, &driver);
  331. return_ACPI_STATUS(status);
  332. }
  335. /****************************************************************************
  336.  *
  337.  * FUNCTION:    pr_notify
  338.  *
  339.  * PARAMETERS:
  340.  *
  341.  * RETURN:
  342.  *
  343.  * DESCRIPTION:
  344.  *
  345.  ****************************************************************************/
  347. acpi_status
  348. pr_notify (
  349. BM_NOTIFY notify_type,
  350. BM_HANDLE device_handle,
  351. void **context)
  352. {
  353. acpi_status status = AE_OK;
  354. PR_CONTEXT *processor = NULL;
  356. FUNCTION_TRACE("pr_notify");
  358. processor = (PR_CONTEXT*)*context;
  360. switch (notify_type) {
  362. case BM_NOTIFY_DEVICE_ADDED:
  363. status = pr_add_device(device_handle, context);
  364. break;
  366. case BM_NOTIFY_DEVICE_REMOVED:
  367. status = pr_remove_device(context);
  368. break;
  370. case PR_NOTIFY_PERF_STATES:
  371. ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Performance states change event detected on processor [%02x].n", device_handle));
  372. /* TBD: Streamline (this is simple but overkill). */
  373. status = pr_perf_remove_device(processor);
  374. if (ACPI_SUCCESS(status)) {
  375. status = pr_perf_add_device(processor);
  376. }
  377. if (ACPI_SUCCESS(status)) {
  378. status = pr_osl_generate_event(notify_type,
  379. (processor));
  380. }
  381. break;
  383. case PR_NOTIFY_POWER_STATES:
  384. ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Power states change event detected on processor [%02x].n", device_handle));
  385. /* TBD: Streamline (this is simple but overkill). */
  386. status = pr_power_remove_device(processor);
  387. if (ACPI_SUCCESS(status)) {
  388. status = pr_power_add_device(processor);
  389. }
  390. if (ACPI_SUCCESS(status)) {
  391. status = pr_osl_generate_event(notify_type,
  392. (processor));
  393. }
  394. break;
  396. default:
  397. status = AE_SUPPORT;
  398. break;
  399. }
  401. return_ACPI_STATUS(status);
  402. }
  405. /****************************************************************************
  406.  *
  407.  * FUNCTION:    pr_request
  408.  *
  409.  * PARAMETERS:
  410.  *
  411.  * RETURN:
  412.  *
  413.  * DESCRIPTION:
  414.  *
  415.  ****************************************************************************/
  417. acpi_status
  418. pr_request (
  419. BM_REQUEST *request,
  420. void *context)
  421. {
  422. acpi_status status = AE_OK;
  423. PR_CONTEXT *processor = NULL;
  425. FUNCTION_TRACE("pr_request");
  427. /*
  428.  * Must have a valid request structure and context.
  429.  */
  430. if (!request || !context) {
  431. return_ACPI_STATUS(AE_BAD_PARAMETER);
  432. }
  434. processor = (PR_CONTEXT*)context;
  436. /*
  437.  * Handle request:
  438.  * ---------------
  439.  */
  440. switch (request->command) {
  442. case PR_COMMAND_GET_POWER_INFO:
  443. status = bm_copy_to_buffer(&(request->buffer),
  444. &(processor->power), sizeof(PR_POWER));
  445. break;
  447. case PR_COMMAND_SET_POWER_INFO:
  448.  {
  449. PR_POWER *power_info = NULL;
  450. u32 i = 0;
  452. status = bm_cast_buffer(&(request->buffer),
  453. (void**)&power_info, sizeof(PR_POWER));
  454. if (ACPI_SUCCESS(status)) {
  455. for (i=0; i<processor->power.state_count; i++) {
  456. MEMCPY(&(processor->power.state[i].promotion),
  457. &(power_info->state[i].promotion),
  458. sizeof(PR_CX_POLICY_VALUES));
  459. MEMCPY(&(processor->power.state[i].demotion),
  460. &(power_info->state[i].demotion),
  461. sizeof(PR_CX_POLICY_VALUES));
  462. }
  463. }
  464. }
  465. break;
  467. case PR_COMMAND_GET_PERF_INFO:
  468. status = bm_copy_to_buffer(&(request->buffer),
  469. &(processor->performance), sizeof(PR_PERFORMANCE));
  470. break;
  472. case PR_COMMAND_GET_PERF_STATE:
  473. status = bm_copy_to_buffer(&(request->buffer),
  474. &(processor->performance.active_state), sizeof(u32));
  475. break;
  477. case PR_COMMAND_SET_PERF_LIMIT:
  478.  {
  479. u32 *limit = NULL;
  481. status = bm_cast_buffer(&(request->buffer),
  482. (void**)&limit, sizeof(u32));
  483. if (ACPI_SUCCESS(status)) {
  484. status = pr_perf_set_limit(processor, *limit);
  485. }
  486. }
  487. break;
  489. default:
  490. status = AE_SUPPORT;
  491. break;
  492. }
  494. request->status = status;
  496. return_ACPI_STATUS(status);
  497. }