Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*******************************************************************************
  2.  *
  3.  * Module Name: rsaddr - Address resource descriptors (16/32/64)
  4.  *
  5.  ******************************************************************************/
  6.  
  7. /*
  8.  * Copyright (C) 2000 - 2015, Intel Corp.
  9.  * All rights reserved.
  10.  *
  11.  * Redistribution and use in source and binary forms, with or without
  12.  * modification, are permitted provided that the following conditions
  13.  * are met:
  14.  * 1. Redistributions of source code must retain the above copyright
  15.  *    notice, this list of conditions, and the following disclaimer,
  16.  *    without modification.
  17.  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18.  *    substantially similar to the "NO WARRANTY" disclaimer below
  19.  *    ("Disclaimer") and any redistribution must be conditioned upon
  20.  *    including a substantially similar Disclaimer requirement for further
  21.  *    binary redistribution.
  22.  * 3. Neither the names of the above-listed copyright holders nor the names
  23.  *    of any contributors may be used to endorse or promote products derived
  24.  *    from this software without specific prior written permission.
  25.  *
  26.  * Alternatively, this software may be distributed under the terms of the
  27.  * GNU General Public License ("GPL") version 2 as published by the Free
  28.  * Software Foundation.
  29.  *
  30.  * NO WARRANTY
  31.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35.  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40.  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41.  * POSSIBILITY OF SUCH DAMAGES.
  42.  */
  43.  
  44. #include <acpi/acpi.h>
  45. #include "accommon.h"
  46. #include "acresrc.h"
  47.  
  48. #define _COMPONENT          ACPI_RESOURCES
  49. ACPI_MODULE_NAME("rsaddr")
  50.  
  51. /*******************************************************************************
  52.  *
  53.  * acpi_rs_convert_address16 - All WORD (16-bit) address resources
  54.  *
  55.  ******************************************************************************/
  56. struct acpi_rsconvert_info acpi_rs_convert_address16[5] = {
  57.         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS16,
  58.          ACPI_RS_SIZE(struct acpi_resource_address16),
  59.          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address16)},
  60.  
  61.         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS16,
  62.          sizeof(struct aml_resource_address16),
  63.          0},
  64.  
  65.         /* Resource Type, General Flags, and Type-Specific Flags */
  66.  
  67.         {ACPI_RSC_ADDRESS, 0, 0, 0},
  68.  
  69.         /*
  70.          * These fields are contiguous in both the source and destination:
  71.          * Address Granularity
  72.          * Address Range Minimum
  73.          * Address Range Maximum
  74.          * Address Translation Offset
  75.          * Address Length
  76.          */
  77.         {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.address16.address.granularity),
  78.          AML_OFFSET(address16.granularity),
  79.          5},
  80.  
  81.         /* Optional resource_source (Index and String) */
  82.  
  83.         {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address16.resource_source),
  84.          0,
  85.          sizeof(struct aml_resource_address16)}
  86. };
  87.  
  88. /*******************************************************************************
  89.  *
  90.  * acpi_rs_convert_address32 - All DWORD (32-bit) address resources
  91.  *
  92.  ******************************************************************************/
  93.  
  94. struct acpi_rsconvert_info acpi_rs_convert_address32[5] = {
  95.         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS32,
  96.          ACPI_RS_SIZE(struct acpi_resource_address32),
  97.          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address32)},
  98.  
  99.         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS32,
  100.          sizeof(struct aml_resource_address32),
  101.          0},
  102.  
  103.         /* Resource Type, General Flags, and Type-Specific Flags */
  104.  
  105.         {ACPI_RSC_ADDRESS, 0, 0, 0},
  106.  
  107.         /*
  108.          * These fields are contiguous in both the source and destination:
  109.          * Address Granularity
  110.          * Address Range Minimum
  111.          * Address Range Maximum
  112.          * Address Translation Offset
  113.          * Address Length
  114.          */
  115.         {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.address32.address.granularity),
  116.          AML_OFFSET(address32.granularity),
  117.          5},
  118.  
  119.         /* Optional resource_source (Index and String) */
  120.  
  121.         {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address32.resource_source),
  122.          0,
  123.          sizeof(struct aml_resource_address32)}
  124. };
  125.  
  126. /*******************************************************************************
  127.  *
  128.  * acpi_rs_convert_address64 - All QWORD (64-bit) address resources
  129.  *
  130.  ******************************************************************************/
  131.  
  132. struct acpi_rsconvert_info acpi_rs_convert_address64[5] = {
  133.         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS64,
  134.          ACPI_RS_SIZE(struct acpi_resource_address64),
  135.          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address64)},
  136.  
  137.         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS64,
  138.          sizeof(struct aml_resource_address64),
  139.          0},
  140.  
  141.         /* Resource Type, General Flags, and Type-Specific Flags */
  142.  
  143.         {ACPI_RSC_ADDRESS, 0, 0, 0},
  144.  
  145.         /*
  146.          * These fields are contiguous in both the source and destination:
  147.          * Address Granularity
  148.          * Address Range Minimum
  149.          * Address Range Maximum
  150.          * Address Translation Offset
  151.          * Address Length
  152.          */
  153.         {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.address64.address.granularity),
  154.          AML_OFFSET(address64.granularity),
  155.          5},
  156.  
  157.         /* Optional resource_source (Index and String) */
  158.  
  159.         {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address64.resource_source),
  160.          0,
  161.          sizeof(struct aml_resource_address64)}
  162. };
  163.  
  164. /*******************************************************************************
  165.  *
  166.  * acpi_rs_convert_ext_address64 - All Extended (64-bit) address resources
  167.  *
  168.  ******************************************************************************/
  169.  
  170. struct acpi_rsconvert_info acpi_rs_convert_ext_address64[5] = {
  171.         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
  172.          ACPI_RS_SIZE(struct acpi_resource_extended_address64),
  173.          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_ext_address64)},
  174.  
  175.         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
  176.          sizeof(struct aml_resource_extended_address64),
  177.          0},
  178.  
  179.         /* Resource Type, General Flags, and Type-Specific Flags */
  180.  
  181.         {ACPI_RSC_ADDRESS, 0, 0, 0},
  182.  
  183.         /* Revision ID */
  184.  
  185.         {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.ext_address64.revision_ID),
  186.          AML_OFFSET(ext_address64.revision_ID),
  187.          1},
  188.         /*
  189.          * These fields are contiguous in both the source and destination:
  190.          * Address Granularity
  191.          * Address Range Minimum
  192.          * Address Range Maximum
  193.          * Address Translation Offset
  194.          * Address Length
  195.          * Type-Specific Attribute
  196.          */
  197.         {ACPI_RSC_MOVE64,
  198.          ACPI_RS_OFFSET(data.ext_address64.address.granularity),
  199.          AML_OFFSET(ext_address64.granularity),
  200.          6}
  201. };
  202.  
  203. /*******************************************************************************
  204.  *
  205.  * acpi_rs_convert_general_flags - Flags common to all address descriptors
  206.  *
  207.  ******************************************************************************/
  208.  
  209. static struct acpi_rsconvert_info acpi_rs_convert_general_flags[6] = {
  210.         {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.flags),
  211.          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_general_flags)},
  212.  
  213.         /* Resource Type (Memory, Io, bus_number, etc.) */
  214.  
  215.         {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.address.resource_type),
  216.          AML_OFFSET(address.resource_type),
  217.          1},
  218.  
  219.         /* General flags - Consume, Decode, min_fixed, max_fixed */
  220.  
  221.         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.producer_consumer),
  222.          AML_OFFSET(address.flags),
  223.          0},
  224.  
  225.         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.decode),
  226.          AML_OFFSET(address.flags),
  227.          1},
  228.  
  229.         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.min_address_fixed),
  230.          AML_OFFSET(address.flags),
  231.          2},
  232.  
  233.         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.max_address_fixed),
  234.          AML_OFFSET(address.flags),
  235.          3}
  236. };
  237.  
  238. /*******************************************************************************
  239.  *
  240.  * acpi_rs_convert_mem_flags - Flags common to Memory address descriptors
  241.  *
  242.  ******************************************************************************/
  243.  
  244. static struct acpi_rsconvert_info acpi_rs_convert_mem_flags[5] = {
  245.         {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
  246.          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_mem_flags)},
  247.  
  248.         /* Memory-specific flags */
  249.  
  250.         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.write_protect),
  251.          AML_OFFSET(address.specific_flags),
  252.          0},
  253.  
  254.         {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.caching),
  255.          AML_OFFSET(address.specific_flags),
  256.          1},
  257.  
  258.         {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.range_type),
  259.          AML_OFFSET(address.specific_flags),
  260.          3},
  261.  
  262.         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.translation),
  263.          AML_OFFSET(address.specific_flags),
  264.          5}
  265. };
  266.  
  267. /*******************************************************************************
  268.  *
  269.  * acpi_rs_convert_io_flags - Flags common to I/O address descriptors
  270.  *
  271.  ******************************************************************************/
  272.  
  273. static struct acpi_rsconvert_info acpi_rs_convert_io_flags[4] = {
  274.         {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
  275.          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io_flags)},
  276.  
  277.         /* I/O-specific flags */
  278.  
  279.         {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.io.range_type),
  280.          AML_OFFSET(address.specific_flags),
  281.          0},
  282.  
  283.         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.io.translation),
  284.          AML_OFFSET(address.specific_flags),
  285.          4},
  286.  
  287.         {ACPI_RSC_1BITFLAG,
  288.          ACPI_RS_OFFSET(data.address.info.io.translation_type),
  289.          AML_OFFSET(address.specific_flags),
  290.          5}
  291. };
  292.  
  293. /*******************************************************************************
  294.  *
  295.  * FUNCTION:    acpi_rs_get_address_common
  296.  *
  297.  * PARAMETERS:  resource            - Pointer to the internal resource struct
  298.  *              aml                 - Pointer to the AML resource descriptor
  299.  *
  300.  * RETURN:      TRUE if the resource_type field is OK, FALSE otherwise
  301.  *
  302.  * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
  303.  *              to an internal resource descriptor
  304.  *
  305.  ******************************************************************************/
  306.  
  307. u8
  308. acpi_rs_get_address_common(struct acpi_resource *resource,
  309.                            union aml_resource *aml)
  310. {
  311.         ACPI_FUNCTION_ENTRY();
  312.  
  313.         /* Validate the Resource Type */
  314.  
  315.         if ((aml->address.resource_type > 2)
  316.             && (aml->address.resource_type < 0xC0)) {
  317.                 return (FALSE);
  318.         }
  319.  
  320.         /* Get the Resource Type and General Flags */
  321.  
  322.         (void)acpi_rs_convert_aml_to_resource(resource, aml,
  323.                                               acpi_rs_convert_general_flags);
  324.  
  325.         /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
  326.  
  327.         if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
  328.                 (void)acpi_rs_convert_aml_to_resource(resource, aml,
  329.                                                       acpi_rs_convert_mem_flags);
  330.         } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
  331.                 (void)acpi_rs_convert_aml_to_resource(resource, aml,
  332.                                                       acpi_rs_convert_io_flags);
  333.         } else {
  334.                 /* Generic resource type, just grab the type_specific byte */
  335.  
  336.                 resource->data.address.info.type_specific =
  337.                     aml->address.specific_flags;
  338.         }
  339.  
  340.         return (TRUE);
  341. }
  342.  
  343. /*******************************************************************************
  344.  *
  345.  * FUNCTION:    acpi_rs_set_address_common
  346.  *
  347.  * PARAMETERS:  aml                 - Pointer to the AML resource descriptor
  348.  *              resource            - Pointer to the internal resource struct
  349.  *
  350.  * RETURN:      None
  351.  *
  352.  * DESCRIPTION: Convert common flag fields from a resource descriptor to an
  353.  *              AML descriptor
  354.  *
  355.  ******************************************************************************/
  356.  
  357. void
  358. acpi_rs_set_address_common(union aml_resource *aml,
  359.                            struct acpi_resource *resource)
  360. {
  361.         ACPI_FUNCTION_ENTRY();
  362.  
  363.         /* Set the Resource Type and General Flags */
  364.  
  365.         (void)acpi_rs_convert_resource_to_aml(resource, aml,
  366.                                               acpi_rs_convert_general_flags);
  367.  
  368.         /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
  369.  
  370.         if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
  371.                 (void)acpi_rs_convert_resource_to_aml(resource, aml,
  372.                                                       acpi_rs_convert_mem_flags);
  373.         } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
  374.                 (void)acpi_rs_convert_resource_to_aml(resource, aml,
  375.                                                       acpi_rs_convert_io_flags);
  376.         } else {
  377.                 /* Generic resource type, just copy the type_specific byte */
  378.  
  379.                 aml->address.specific_flags =
  380.                     resource->data.address.info.type_specific;
  381.         }
  382. }
  383.