hc
2024-03-22 a0752693d998599af469473b8dc239ef973a012f
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
/** @file
 *
 *  Core System Resource Table (CSRT)
 *
 *  Copyright (c) 2019, ARM Ltd. All rights reserved.
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *
 *  SPDX-License-Identifier: BSD-2-Clause-Patent
 *
 **/
 
#include <IndustryStandard/Acpi.h>
#include <IndustryStandard/Bcm2836.h>
 
#include "AcpiTables.h"
 
#define RPI_DMA_MAX_REQ_LINES 32
 
#pragma pack (push, 1)
 
//------------------------------------------------------------------------
// DMA Controller Vendor Data
//------------------------------------------------------------------------
typedef struct
{
  UINT32 Length;
  UINT32 Type;
  UINT64 ChannelsBaseAddress;
  UINT32 ChannelsBaseSize;
  UINT64 ControllerBaseAddress;
  UINT32 ControllerBaseSize;
  UINT32 ChannelCount;
  UINT32 ControllerInterrupt;
  UINT32 MinimumRequestLine;
  UINT32 MaximumRequestLine;
  BOOLEAN CacheCoherent;
} DMA_CONTROLLER_VENDOR_DATA;
 
//------------------------------------------------------------------------
// DMA Controller
//------------------------------------------------------------------------
typedef struct
{
  EFI_ACPI_6_3_CSRT_RESOURCE_DESCRIPTOR_HEADER DmaControllerHeader;
  DMA_CONTROLLER_VENDOR_DATA ControllerVendorData;
} RD_DMA_CONTROLLER;
 
//------------------------------------------------------------------------
// DMA Channel Vendor Data
//------------------------------------------------------------------------
typedef struct
{
  UINT32 ChannelNumber;
  UINT32 ChannelInterrupt;
  UINT16 IsReservedChannel;
  UINT16 NoSrcNoDestAddrIncr;
} DMA_CHANNEL_VENDOR_DATA;
 
//------------------------------------------------------------------------
// DMA Channel
//------------------------------------------------------------------------
typedef struct
{
  EFI_ACPI_6_3_CSRT_RESOURCE_DESCRIPTOR_HEADER DmaChannelHeader;
  DMA_CHANNEL_VENDOR_DATA ChannelVendorData;
} RD_DMA_CHANNEL;
 
//------------------------------------------------------------------------
// DMA Resource Group
//------------------------------------------------------------------------
 
typedef struct
{
  EFI_ACPI_6_3_CSRT_RESOURCE_GROUP_HEADER ResGroupHeader;
  RD_DMA_CONTROLLER DmaController;
  RD_DMA_CHANNEL DmaChannels[RPI_DMA_CHANNEL_COUNT];
} RG_DMA;
 
//----------------------------------------------------------------------------
// CSRT table structure - current revision only includes DMA
//----------------------------------------------------------------------------
typedef struct
{
// Standard ACPI Header
  EFI_ACPI_DESCRIPTION_HEADER CsrtHeader;
 
// DMA Resource Group
  RG_DMA DmaResourceGroup;
 
} EFI_ACPI_6_3_CSRT_TABLE;
 
EFI_ACPI_6_3_CSRT_TABLE Csrt =
{
  //------------------------------------------------------------------------
  // ACPI Table Header
  //------------------------------------------------------------------------
  {
    EFI_ACPI_6_3_CORE_SYSTEM_RESOURCE_TABLE_SIGNATURE,       // Signature "CSRT"
    sizeof (EFI_ACPI_DESCRIPTION_HEADER) + sizeof (RG_DMA),  // Length
    EFI_ACPI_6_3_CSRT_REVISION,     // Revision
    0x00,                           // Checksum calculated at runtime.
    EFI_ACPI_OEM_ID,                // OEMID is a 6 bytes long field
    EFI_ACPI_OEM_TABLE_ID,          // OEM table identification (8 bytes long)
    EFI_ACPI_OEM_REVISION,          // OEM revision number.
    EFI_ACPI_CREATOR_ID,            // ASL compiler vendor ID.
    EFI_ACPI_CREATOR_REVISION       // ASL compiler revision number.
  },
 
  //------------------------------------------------------------------------
  // DMA Resource Group
  //------------------------------------------------------------------------
  {
 
    //------------------------------------------------------------------------
    // DMA Resource Group Header
    //------------------------------------------------------------------------
    {
      sizeof (RG_DMA),                // Resource Group Length
      EFI_ACPI_VENDOR_ID,             // VendorId
      0,                              // SubvendorId
      EFI_ACPI_CSRT_DEVICE_ID_DMA,    // DeviceId 9
      0,                              // SubdeviceId
      0,                              // Revision
      0,                              // Reserved
      0                               // SharedInfoLength
    },
 
    //-------------------------------------------------------------------------------
    // Resource Descriptor - DMA Controller
    //-------------------------------------------------------------------------------
    {
      {
        sizeof (RD_DMA_CONTROLLER),                    // Length of this Resource Descriptor
        EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,               // Type for this resource 3=DMA
        EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CONTROLLER, // Subtype for this resource 1=DMA Controller
        EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 0,        // ResourceId - 1st DMA controller
      },
      {
        sizeof (DMA_CONTROLLER_VENDOR_DATA),  // Controller vendor data here
        1,
        BCM2836_DMA0_BASE_ADDRESS,    // Base address for channels
        RPI_DMA_CHANNEL_COUNT * BCM2836_DMA_CHANNEL_LENGTH, // Base size = Number of channels x channel size
        BCM2836_DMA_CTRL_BASE_ADDRESS,// Base address for controller
        8,                            // Base size = two registers
        RPI_DMA_USED_CHANNEL_COUNT,
        0,                            // cannot use controller interrupt
        0,                            // Minimum Request Line
        RPI_DMA_MAX_REQ_LINES - 1,    // Maximum Request Line
        FALSE,
      },
    },
 
    //------------------------------------------------------------------------
    // Resource Descriptor(s) - DMA Channels 0 to n-1
    //------------------------------------------------------------------------
    {
 
      // Channel 0
      {
        {
          sizeof (RD_DMA_CHANNEL),                    // Length of this Resource Descriptor
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,            // Type for this resource 3=DMA
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL, // Subtype for this resource 0=DMA Channel
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 1,     // ResourceId
        },
        {
          0,        // Channel vendor data here
          0x30,     // 16+32 dma_int[0]
          0,
          0
        },
      },
 
      // Channel 1 reserved
      {
        {
          sizeof (RD_DMA_CHANNEL),
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL,
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 2,     // ResourceId
        },
        {
          1,        // Channel vendor data here
          0x31,     // 17+32 dma_int[1]
          1,
          0
        },
      },
 
      // Channel 2 - VC4 use only
      {
        {
          sizeof (RD_DMA_CHANNEL),
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL,
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 3,        // ResourceId
        },
        {
          2,        // Channel vendor data here
          0x32,     // 18+32 dma_int[2]
          1,
          0
        },
      },
 
      // Channel 3 - VC4 use only
      {
        {
          sizeof (RD_DMA_CHANNEL),
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL,
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 4,
        },
        {
          3,        // Channel vendor data here
          0x33,     // 19+32 dma_int[3]
          1,
          0
        },
      },
 
      // channel 4
      {
        {
          sizeof (RD_DMA_CHANNEL),
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL,
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 5,
        },
        {
          4,        // Channel vendor data here
          0x34,     // 20+32 dma_int[4]
          0,
          1         // SD host controller candidate
        },
      },
 
      // Channel 5
      {
        {
          sizeof (RD_DMA_CHANNEL),
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL,
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 6,
        },
        {
          5,        // Channel vendor data here
          0x35,     // 21+32 dma_int[5]
          0,
          0
        },
      },
 
      // Channel 6 is reserved
      {
        {
          sizeof (RD_DMA_CHANNEL),
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL,
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 7,
        },
        {
          6,        // Channel vendor data here
          0x36,     // 22+32 dma_int[6]
          1,
          0
        },
      },
 
      // Channel 7 is reserved
      {
        {
          sizeof (RD_DMA_CHANNEL),
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL,
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 8,
        },
        {
          7,        // Channel vendor data here
          0x37,     // 23+32 dma_int[7]
          1,
          0
        },
      },
 
      // Channel 8
      {
        {
          sizeof (RD_DMA_CHANNEL),
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL,
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 9,
        },
        {
          8,        // Channel vendor data here
          0x38,     // 24+32 dma_int[8]
          0,
          0
        },
      },
 
      // Channel 9
      {
        {
          sizeof (RD_DMA_CHANNEL),
          EFI_ACPI_CSRT_RESOURCE_TYPE_DMA,
          EFI_ACPI_CSRT_RESOURCE_SUBTYPE_DMA_CHANNEL,
          EFI_ACPI_CSRT_RESOURCE_ID_IN_DMA_GRP + 10,
        },
        {
          9,        // channel vendor data here
          0x39,     // 25+32 dma_int[9]
          0,
          0
        },
      }
 
    } // End DMA Channels 0 to 14
 
  } // End DMA Resource group
 
};
 
#pragma pack(pop)
 
//
// Reference the table being generated to prevent the optimizer from removing the
// data structure from the executable
//
VOID* CONST ReferenceAcpiTable = &Csrt;