acpi/acpica/rsirq.c

0001 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
0002 /*******************************************************************************
0003  *
0004  * Module Name: rsirq - IRQ resource descriptors
0005  *
0006  ******************************************************************************/
0007
0008 #include <acpi/acpi.h>
0009 #include "accommon.h"
0010 #include "acresrc.h"
0011
0012 #define _COMPONENT          ACPI_RESOURCES
0013 ACPI_MODULE_NAME("rsirq")
0014
0015 /*******************************************************************************
0016  *
0017  * acpi_rs_get_irq
0018  *
0019  ******************************************************************************/
0020 struct acpi_rsconvert_info acpi_rs_get_irq[9] = {
0021     {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_IRQ,
0022      ACPI_RS_SIZE(struct acpi_resource_irq),
0023      ACPI_RSC_TABLE_SIZE(acpi_rs_get_irq)},
0024
0025     /* Get the IRQ mask (bytes 1:2) */
0026
0027     {ACPI_RSC_BITMASK16, ACPI_RS_OFFSET(data.irq.interrupts[0]),
0028      AML_OFFSET(irq.irq_mask),
0029      ACPI_RS_OFFSET(data.irq.interrupt_count)},
0030
0031     /* Set default flags (others are zero) */
0032
0033     {ACPI_RSC_SET8, ACPI_RS_OFFSET(data.irq.triggering),
0034      ACPI_EDGE_SENSITIVE,
0035      1},
0036
0037     /* Get the descriptor length (2 or 3 for IRQ descriptor) */
0038
0039     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.irq.descriptor_length),
0040      AML_OFFSET(irq.descriptor_type),
0041      0},
0042
0043     /* All done if no flag byte present in descriptor */
0044
0045     {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_AML_LENGTH, 0, 3},
0046
0047     /* Get flags: Triggering[0], Polarity[3], Sharing[4], Wake[5] */
0048
0049     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.triggering),
0050      AML_OFFSET(irq.flags),
0051      0},
0052
0053     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.polarity),
0054      AML_OFFSET(irq.flags),
0055      3},
0056
0057     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.shareable),
0058      AML_OFFSET(irq.flags),
0059      4},
0060
0061     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.wake_capable),
0062      AML_OFFSET(irq.flags),
0063      5}
0064 };
0065
0066 /*******************************************************************************
0067  *
0068  * acpi_rs_set_irq
0069  *
0070  ******************************************************************************/
0071
0072 struct acpi_rsconvert_info acpi_rs_set_irq[14] = {
0073     /* Start with a default descriptor of length 3 */
0074
0075     {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_IRQ,
0076      sizeof(struct aml_resource_irq),
0077      ACPI_RSC_TABLE_SIZE(acpi_rs_set_irq)},
0078
0079     /* Convert interrupt list to 16-bit IRQ bitmask */
0080
0081     {ACPI_RSC_BITMASK16, ACPI_RS_OFFSET(data.irq.interrupts[0]),
0082      AML_OFFSET(irq.irq_mask),
0083      ACPI_RS_OFFSET(data.irq.interrupt_count)},
0084
0085     /* Set flags: Triggering[0], Polarity[3], Sharing[4], Wake[5] */
0086
0087     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.triggering),
0088      AML_OFFSET(irq.flags),
0089      0},
0090
0091     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.polarity),
0092      AML_OFFSET(irq.flags),
0093      3},
0094
0095     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.shareable),
0096      AML_OFFSET(irq.flags),
0097      4},
0098
0099     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.wake_capable),
0100      AML_OFFSET(irq.flags),
0101      5},
0102
0103     /*
0104      * All done if the output descriptor length is required to be 3
0105      * (i.e., optimization to 2 bytes cannot be attempted)
0106      */
0107     {ACPI_RSC_EXIT_EQ, ACPI_RSC_COMPARE_VALUE,
0108      ACPI_RS_OFFSET(data.irq.descriptor_length),
0109      3},
0110
0111     /* Set length to 2 bytes (no flags byte) */
0112
0113     {ACPI_RSC_LENGTH, 0, 0, sizeof(struct aml_resource_irq_noflags)},
0114
0115     /*
0116      * All done if the output descriptor length is required to be 2.
0117      *
0118      * TBD: Perhaps we should check for error if input flags are not
0119      * compatible with a 2-byte descriptor.
0120      */
0121     {ACPI_RSC_EXIT_EQ, ACPI_RSC_COMPARE_VALUE,
0122      ACPI_RS_OFFSET(data.irq.descriptor_length),
0123      2},
0124
0125     /* Reset length to 3 bytes (descriptor with flags byte) */
0126
0127     {ACPI_RSC_LENGTH, 0, 0, sizeof(struct aml_resource_irq)},
0128
0129     /*
0130      * Check if the flags byte is necessary. Not needed if the flags are:
0131      * ACPI_EDGE_SENSITIVE, ACPI_ACTIVE_HIGH, ACPI_EXCLUSIVE
0132      */
0133     {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
0134      ACPI_RS_OFFSET(data.irq.triggering),
0135      ACPI_EDGE_SENSITIVE},
0136
0137     {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
0138      ACPI_RS_OFFSET(data.irq.polarity),
0139      ACPI_ACTIVE_HIGH},
0140
0141     {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
0142      ACPI_RS_OFFSET(data.irq.shareable),
0143      ACPI_EXCLUSIVE},
0144
0145     /* We can optimize to a 2-byte irq_no_flags() descriptor */
0146
0147     {ACPI_RSC_LENGTH, 0, 0, sizeof(struct aml_resource_irq_noflags)}
0148 };
0149
0150 /*******************************************************************************
0151  *
0152  * acpi_rs_convert_ext_irq
0153  *
0154  ******************************************************************************/
0155
0156 struct acpi_rsconvert_info acpi_rs_convert_ext_irq[10] = {
0157     {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_EXTENDED_IRQ,
0158      ACPI_RS_SIZE(struct acpi_resource_extended_irq),
0159      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_ext_irq)},
0160
0161     {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_IRQ,
0162      sizeof(struct aml_resource_extended_irq),
0163      0},
0164
0165     /*
0166      * Flags: Producer/Consumer[0], Triggering[1], Polarity[2],
0167      *        Sharing[3], Wake[4]
0168      */
0169     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.producer_consumer),
0170      AML_OFFSET(extended_irq.flags),
0171      0},
0172
0173     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.triggering),
0174      AML_OFFSET(extended_irq.flags),
0175      1},
0176
0177     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.polarity),
0178      AML_OFFSET(extended_irq.flags),
0179      2},
0180
0181     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.shareable),
0182      AML_OFFSET(extended_irq.flags),
0183      3},
0184
0185     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.wake_capable),
0186      AML_OFFSET(extended_irq.flags),
0187      4},
0188
0189     /* IRQ Table length (Byte4) */
0190
0191     {ACPI_RSC_COUNT, ACPI_RS_OFFSET(data.extended_irq.interrupt_count),
0192      AML_OFFSET(extended_irq.interrupt_count),
0193      sizeof(u32)},
0194
0195     /* Copy every IRQ in the table, each is 32 bits */
0196
0197     {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.extended_irq.interrupts[0]),
0198      AML_OFFSET(extended_irq.interrupts[0]),
0199      0},
0200
0201     /* Optional resource_source (Index and String) */
0202
0203     {ACPI_RSC_SOURCEX, ACPI_RS_OFFSET(data.extended_irq.resource_source),
0204      ACPI_RS_OFFSET(data.extended_irq.interrupts[0]),
0205      sizeof(struct aml_resource_extended_irq)}
0206 };
0207
0208 /*******************************************************************************
0209  *
0210  * acpi_rs_convert_dma
0211  *
0212  ******************************************************************************/
0213
0214 struct acpi_rsconvert_info acpi_rs_convert_dma[6] = {
0215     {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_DMA,
0216      ACPI_RS_SIZE(struct acpi_resource_dma),
0217      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_dma)},
0218
0219     {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_DMA,
0220      sizeof(struct aml_resource_dma),
0221      0},
0222
0223     /* Flags: transfer preference, bus mastering, channel speed */
0224
0225     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.dma.transfer),
0226      AML_OFFSET(dma.flags),
0227      0},
0228
0229     {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.dma.bus_master),
0230      AML_OFFSET(dma.flags),
0231      2},
0232
0233     {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.dma.type),
0234      AML_OFFSET(dma.flags),
0235      5},
0236
0237     /* DMA channel mask bits */
0238
0239     {ACPI_RSC_BITMASK, ACPI_RS_OFFSET(data.dma.channels[0]),
0240      AML_OFFSET(dma.dma_channel_mask),
0241      ACPI_RS_OFFSET(data.dma.channel_count)}
0242 };
0243
0244 /*******************************************************************************
0245  *
0246  * acpi_rs_convert_fixed_dma
0247  *
0248  ******************************************************************************/
0249
0250 struct acpi_rsconvert_info acpi_rs_convert_fixed_dma[4] = {
0251     {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_FIXED_DMA,
0252      ACPI_RS_SIZE(struct acpi_resource_fixed_dma),
0253      ACPI_RSC_TABLE_SIZE(acpi_rs_convert_fixed_dma)},
0254
0255     {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_FIXED_DMA,
0256      sizeof(struct aml_resource_fixed_dma),
0257      0},
0258
0259     /*
0260      * These fields are contiguous in both the source and destination:
0261      * request_lines
0262      * Channels
0263      */
0264     {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.fixed_dma.request_lines),
0265      AML_OFFSET(fixed_dma.request_lines),
0266      2},
0267
0268     {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.fixed_dma.width),
0269      AML_OFFSET(fixed_dma.width),
0270      1},
0271 };