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