1 /*******************************************************************************
2 *
3 * Module Name: rsmem24 - Memory resource descriptors
4 *
5 ******************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 "acpi.h"
47 #include "accommon.h"
48 #include "acresrc.h"
49
50 #define _COMPONENT ACPI_RESOURCES
51 ACPI_MODULE_NAME ("rsmemory")
52
53
54 /*******************************************************************************
55 *
56 * AcpiRsConvertMemory24
57 *
58 ******************************************************************************/
59
60 ACPI_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
94 ACPI_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
128 ACPI_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
160 ACPI_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
186 ACPI_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
212 ACPI_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 };