1/*******************************************************************************
2 *
3 * Module Name: rsmem24 - Memory resource descriptors
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2011, 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#define __RSMEMORY_C__
45
46#include <contrib/dev/acpica/include/acpi.h>
47#include <contrib/dev/acpica/include/accommon.h>
48#include <contrib/dev/acpica/include/acresrc.h>
49
50#define _COMPONENT          ACPI_RESOURCES
51        ACPI_MODULE_NAME    ("rsmemory")
52
53
54/*******************************************************************************
55 *
56 * AcpiRsConvertMemory24
57 *
58 ******************************************************************************/
59
60ACPI_RSCONVERT_INFO     AcpiRsConvertMemory24[4] =
61{
62    {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_MEMORY24,
63                        ACPI_RS_SIZE (ACPI_RESOURCE_MEMORY24),
64                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertMemory24)},
65
66    {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_MEMORY24,
67                        sizeof (AML_RESOURCE_MEMORY24),
68                        0},
69
70    /* Read/Write bit */
71
72    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Memory24.WriteProtect),
73                        AML_OFFSET (Memory24.Flags),
74                        0},
75    /*
76     * These fields are contiguous in both the source and destination:
77     * Minimum Base Address
78     * Maximum Base Address
79     * Address Base Alignment
80     * Range Length
81     */
82    {ACPI_RSC_MOVE16,   ACPI_RS_OFFSET (Data.Memory24.Minimum),
83                        AML_OFFSET (Memory24.Minimum),
84                        4}
85};
86
87
88/*******************************************************************************
89 *
90 * AcpiRsConvertMemory32
91 *
92 ******************************************************************************/
93
94ACPI_RSCONVERT_INFO     AcpiRsConvertMemory32[4] =
95{
96    {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_MEMORY32,
97                        ACPI_RS_SIZE (ACPI_RESOURCE_MEMORY32),
98                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertMemory32)},
99
100    {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_MEMORY32,
101                        sizeof (AML_RESOURCE_MEMORY32),
102                        0},
103
104    /* Read/Write bit */
105
106    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.Memory32.WriteProtect),
107                        AML_OFFSET (Memory32.Flags),
108                        0},
109    /*
110     * These fields are contiguous in both the source and destination:
111     * Minimum Base Address
112     * Maximum Base Address
113     * Address Base Alignment
114     * Range Length
115     */
116    {ACPI_RSC_MOVE32,   ACPI_RS_OFFSET (Data.Memory32.Minimum),
117                        AML_OFFSET (Memory32.Minimum),
118                        4}
119};
120
121
122/*******************************************************************************
123 *
124 * AcpiRsConvertFixedMemory32
125 *
126 ******************************************************************************/
127
128ACPI_RSCONVERT_INFO     AcpiRsConvertFixedMemory32[4] =
129{
130    {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_FIXED_MEMORY32,
131                        ACPI_RS_SIZE (ACPI_RESOURCE_FIXED_MEMORY32),
132                        ACPI_RSC_TABLE_SIZE (AcpiRsConvertFixedMemory32)},
133
134    {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_FIXED_MEMORY32,
135                        sizeof (AML_RESOURCE_FIXED_MEMORY32),
136                        0},
137
138    /* Read/Write bit */
139
140    {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET (Data.FixedMemory32.WriteProtect),
141                        AML_OFFSET (FixedMemory32.Flags),
142                        0},
143    /*
144     * These fields are contiguous in both the source and destination:
145     * Base Address
146     * Range Length
147     */
148    {ACPI_RSC_MOVE32,   ACPI_RS_OFFSET (Data.FixedMemory32.Address),
149                        AML_OFFSET (FixedMemory32.Address),
150                        2}
151};
152
153
154/*******************************************************************************
155 *
156 * AcpiRsGetVendorSmall
157 *
158 ******************************************************************************/
159
160ACPI_RSCONVERT_INFO     AcpiRsGetVendorSmall[3] =
161{
162    {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_VENDOR,
163                        ACPI_RS_SIZE (ACPI_RESOURCE_VENDOR),
164                        ACPI_RSC_TABLE_SIZE (AcpiRsGetVendorSmall)},
165
166    /* Length of the vendor data (byte count) */
167
168    {ACPI_RSC_COUNT16,  ACPI_RS_OFFSET (Data.Vendor.ByteLength),
169                        0,
170                        sizeof (UINT8)},
171
172    /* Vendor data */
173
174    {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.Vendor.ByteData[0]),
175                        sizeof (AML_RESOURCE_SMALL_HEADER),
176                        0}
177};
178
179
180/*******************************************************************************
181 *
182 * AcpiRsGetVendorLarge
183 *
184 ******************************************************************************/
185
186ACPI_RSCONVERT_INFO     AcpiRsGetVendorLarge[3] =
187{
188    {ACPI_RSC_INITGET,  ACPI_RESOURCE_TYPE_VENDOR,
189                        ACPI_RS_SIZE (ACPI_RESOURCE_VENDOR),
190                        ACPI_RSC_TABLE_SIZE (AcpiRsGetVendorLarge)},
191
192    /* Length of the vendor data (byte count) */
193
194    {ACPI_RSC_COUNT16,  ACPI_RS_OFFSET (Data.Vendor.ByteLength),
195                        0,
196                        sizeof (UINT8)},
197
198    /* Vendor data */
199
200    {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.Vendor.ByteData[0]),
201                        sizeof (AML_RESOURCE_LARGE_HEADER),
202                        0}
203};
204
205
206/*******************************************************************************
207 *
208 * AcpiRsSetVendor
209 *
210 ******************************************************************************/
211
212ACPI_RSCONVERT_INFO     AcpiRsSetVendor[7] =
213{
214    /* Default is a small vendor descriptor */
215
216    {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_VENDOR_SMALL,
217                        sizeof (AML_RESOURCE_SMALL_HEADER),
218                        ACPI_RSC_TABLE_SIZE (AcpiRsSetVendor)},
219
220    /* Get the length and copy the data */
221
222    {ACPI_RSC_COUNT16,  ACPI_RS_OFFSET (Data.Vendor.ByteLength),
223                        0,
224                        0},
225
226    {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.Vendor.ByteData[0]),
227                        sizeof (AML_RESOURCE_SMALL_HEADER),
228                        0},
229
230    /*
231     * All done if the Vendor byte length is 7 or less, meaning that it will
232     * fit within a small descriptor
233     */
234    {ACPI_RSC_EXIT_LE,  0, 0, 7},
235
236    /* Must create a large vendor descriptor */
237
238    {ACPI_RSC_INITSET,  ACPI_RESOURCE_NAME_VENDOR_LARGE,
239                        sizeof (AML_RESOURCE_LARGE_HEADER),
240                        0},
241
242    {ACPI_RSC_COUNT16,  ACPI_RS_OFFSET (Data.Vendor.ByteLength),
243                        0,
244                        0},
245
246    {ACPI_RSC_MOVE8,    ACPI_RS_OFFSET (Data.Vendor.ByteData[0]),
247                        sizeof (AML_RESOURCE_LARGE_HEADER),
248                        0}
249};
250
251
252