1702 lines
46 KiB
C
1702 lines
46 KiB
C
/*** pnpmacro.c - Parse PNP Macro terms
|
|
*
|
|
* Copyright (c) 1996,1997 Microsoft Corporation
|
|
* Author: Michael Tsang (MikeTs)
|
|
* Created: 05/05/97
|
|
*
|
|
* MODIFICATION HISTORY
|
|
*/
|
|
|
|
#include "pch.h"
|
|
|
|
RESFIELD IRQFields[] =
|
|
{
|
|
"_INT", 1*8 + 0, 16,
|
|
"_HE", 3*8 + 0, 1,
|
|
"_LL", 3*8 + 3, 1,
|
|
"_SHR", 3*8 + 4, 1,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD IRQNoFlagsFields[] =
|
|
{
|
|
"_INT", 1*8 + 0, 16,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD DMAFields[] =
|
|
{
|
|
"_DMA", 1*8 + 0, 8,
|
|
"_SIZ", 2*8 + 0, 2,
|
|
"_BM", 2*8 + 2, 1,
|
|
"_TYP", 2*8 + 5, 2,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD IOFields[] =
|
|
{
|
|
"_DEC", 1*8 + 0, 1,
|
|
"_MIN", 2*8 + 0, 16,
|
|
"_MAX", 4*8 + 0, 16,
|
|
"_ALN", 6*8 + 0, 8,
|
|
"_LEN", 7*8 + 0, 8,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD FixedIOFields[] =
|
|
{
|
|
"_BAS", 1*8 + 0, 16,
|
|
"_LEN", 3*8 + 0, 8,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD Mem24Fields[] =
|
|
{
|
|
"_RW", 3*8 + 0, 1,
|
|
"_MIN", 4*8 + 0, 16,
|
|
"_MAX", 6*8 + 0, 16,
|
|
"_ALN", 8*8 + 0, 16,
|
|
"_LEN", 10*8+ 0, 16,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD Mem32Fields[] =
|
|
{
|
|
"_RW", 3*8 + 0, 1,
|
|
"_MIN", 4*8 + 0, 32,
|
|
"_MAX", 8*8 + 0, 32,
|
|
"_ALN", 12*8+ 0, 32,
|
|
"_LEN", 16*8+ 0, 32,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD FixedMem32Fields[] =
|
|
{
|
|
"_RW", 3*8 + 0, 1,
|
|
"_BAS", 4*8 + 0, 32,
|
|
"_LEN", 8*8 + 0, 32,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD GenFlagFields[] =
|
|
{
|
|
"_DEC", 4*8 + 1, 1,
|
|
"_MIF", 4*8 + 2, 1,
|
|
"_MAF", 4*8 + 3, 1,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD MemTypeFields[] =
|
|
{
|
|
"_RW", 5*8 + 0, 1,
|
|
"_MEM", 5*8 + 1, 3,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD IOTypeFields[] =
|
|
{
|
|
"_RNG", 5*8 + 0, 2,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD DWordFields[] =
|
|
{
|
|
"_GRA", 6*8 + 0, 32,
|
|
"_MIN", 10*8+ 0, 32,
|
|
"_MAX", 14*8+ 0, 32,
|
|
"_TRA", 18*8+ 0, 32,
|
|
"_LEN", 22*8+ 0, 32,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD WordFields[] =
|
|
{
|
|
"_GRA", 6*8 + 0, 16,
|
|
"_MIN", 8*8 + 0, 16,
|
|
"_MAX", 10*8+ 0, 16,
|
|
"_TRA", 12*8+ 0, 16,
|
|
"_LEN", 14*8+ 0, 16,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD QWordFields[] =
|
|
{
|
|
"_GRA", 6*8 + 0, 64,
|
|
"_MIN", 14*8+ 0, 64,
|
|
"_MAX", 22*8+ 0, 64,
|
|
"_TRA", 30*8+ 0, 64,
|
|
"_LEN", 38*8+ 0, 64,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
RESFIELD IRQExFields[] =
|
|
{
|
|
"_HE", 3*8 + 1, 1,
|
|
"_LL", 3*8 + 2, 1,
|
|
"_SHR", 3*8 + 3, 1,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
ULONG dwResBitOffset = 0;
|
|
|
|
/***LP XferCodeToBuff - Transfer code object tree to buffer
|
|
*
|
|
* ENTRY
|
|
* pbBuff -> buffer
|
|
* pdwcb -> length
|
|
* pcCode -> code object tree
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL XferCodeToBuff(PBYTE pbBuff, PDWORD pdwcb, PCODEOBJ pcCode)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
DWORD dwLen;
|
|
int iLen;
|
|
PCODEOBJ pc, pcNext;
|
|
|
|
ENTER((2, "XferCodeToBuff(pbBuff=%x,Len=%x,pcCode=%x,CodeType=%x)\n",
|
|
pbBuff, *pdwcb, pcCode, pcCode->dwCodeType));
|
|
|
|
switch (pcCode->dwCodeType)
|
|
{
|
|
case CODETYPE_ASLTERM:
|
|
if (pcCode->dwCodeValue != OP_NONE)
|
|
{
|
|
iLen = OPCODELEN(pcCode->dwCodeValue);
|
|
memcpy(&pbBuff[*pdwcb], &pcCode->dwCodeValue, iLen);
|
|
*pdwcb += (DWORD)iLen;
|
|
|
|
if ((TermTable[pcCode->dwTermIndex].dwfTerm & TF_PACKAGE_LEN) &&
|
|
((rc = EncodePktLen(pcCode->dwCodeLen, &dwLen, &iLen)) ==
|
|
ASLERR_NONE))
|
|
{
|
|
memcpy(&pbBuff[*pdwcb], &dwLen, iLen);
|
|
*pdwcb += (DWORD)iLen;
|
|
}
|
|
|
|
if ((rc == ASLERR_NONE) && (pcCode->pbDataBuff != NULL))
|
|
{
|
|
int i;
|
|
|
|
for (i = 0, pc = (PCODEOBJ)pcCode->pbDataBuff;
|
|
i < (int)pcCode->dwDataLen;
|
|
++i)
|
|
{
|
|
if ((rc = XferCodeToBuff(pbBuff, pdwcb, &pc[i])) !=
|
|
ASLERR_NONE)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
MEMFREE(pcCode->pbDataBuff);
|
|
pcCode->pbDataBuff = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
for (pc = pcCode->pcFirstChild; pc != NULL; pc = pcNext)
|
|
{
|
|
if ((rc = XferCodeToBuff(pbBuff, pdwcb, pc)) != ASLERR_NONE)
|
|
break;
|
|
//
|
|
// Am I the only one left in the list?
|
|
//
|
|
if (pc->list.plistNext == &pc->list)
|
|
pcNext = NULL;
|
|
else
|
|
pcNext = (PCODEOBJ)pc->list.plistNext;
|
|
|
|
ListRemoveEntry(&pc->list,
|
|
(PPLIST)&pcCode->pcFirstChild);
|
|
MEMFREE(pc);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CODETYPE_DATAOBJ:
|
|
case CODETYPE_STRING:
|
|
case CODETYPE_QWORD:
|
|
memcpy(&pbBuff[*pdwcb], pcCode->pbDataBuff, pcCode->dwDataLen);
|
|
*pdwcb += pcCode->dwDataLen;
|
|
break;
|
|
|
|
case CODETYPE_INTEGER:
|
|
memcpy(&pbBuff[*pdwcb], &pcCode->dwCodeValue, pcCode->dwDataLen);
|
|
*pdwcb += pcCode->dwDataLen;
|
|
break;
|
|
|
|
case CODETYPE_KEYWORD:
|
|
case CODETYPE_UNKNOWN:
|
|
break;
|
|
|
|
default:
|
|
ERROR(("XferCodeToBuff: unexpected code object type - %d",
|
|
pcCode->dwCodeType));
|
|
rc = ASLERR_INTERNAL_ERROR;
|
|
}
|
|
|
|
EXIT((2, "XferCodeToBuff=%x (Len=%x)\n", rc, *pdwcb));
|
|
return rc;
|
|
} //XferCodeToBuff
|
|
|
|
/***LP ResourceTemplate - Start of PNP Resource Template
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL ResourceTemplate(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pcData;
|
|
|
|
ENTER((1, "ResourceTemplate(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
|
|
if (fActionFL)
|
|
{
|
|
dwResBitOffset = 0;
|
|
}
|
|
else
|
|
{
|
|
if ((pcData = (PCODEOBJ)MEMALLOC(sizeof(CODEOBJ))) == NULL)
|
|
{
|
|
ERROR(("ResourceTemplate: failed to allocate buffer object"));
|
|
rc = ASLERR_OUT_OF_MEM;
|
|
}
|
|
else
|
|
{
|
|
memset(pcData, 0, sizeof(CODEOBJ));
|
|
pcData->dwCodeType = CODETYPE_DATAOBJ;
|
|
if (gpcodeScope->dwCodeLen <= 0x3f)
|
|
pcData->dwDataLen = gpcodeScope->dwCodeLen - 1;
|
|
else if (gpcodeScope->dwCodeLen <= 0xfff)
|
|
pcData->dwDataLen = gpcodeScope->dwCodeLen - 2;
|
|
else if (gpcodeScope->dwCodeLen <= 0xfffff)
|
|
pcData->dwDataLen = gpcodeScope->dwCodeLen - 3;
|
|
else
|
|
pcData->dwDataLen = gpcodeScope->dwCodeLen - 4;
|
|
|
|
pcData->dwDataLen += 2; //add length of EndTag
|
|
|
|
if ((pcData->pbDataBuff = MEMALLOC(pcData->dwDataLen)) == NULL)
|
|
{
|
|
ERROR(("ResourceTemplate: failed to allocate data buffer"));
|
|
rc = ASLERR_OUT_OF_MEM;
|
|
}
|
|
else
|
|
{
|
|
PCODEOBJ pc, pcNext;
|
|
DWORD dwcb = 0;
|
|
|
|
for (pc = gpcodeScope->pcFirstChild; pc != NULL; pc = pcNext)
|
|
{
|
|
if ((rc = XferCodeToBuff(pcData->pbDataBuff, &dwcb, pc)) !=
|
|
ASLERR_NONE)
|
|
{
|
|
break;
|
|
}
|
|
//
|
|
// Am I the only one left in the list?
|
|
//
|
|
if (pc->list.plistNext == &pc->list)
|
|
pcNext = NULL;
|
|
else
|
|
pcNext = (PCODEOBJ)pc->list.plistNext;
|
|
|
|
ListRemoveEntry(&pc->list,
|
|
(PPLIST)&gpcodeScope->pcFirstChild);
|
|
MEMFREE(pc);
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
pcData->pbDataBuff[dwcb] = 0x79; //EndTag
|
|
dwcb++;
|
|
//
|
|
// Generate a zero-checksum EndTag because the ASL code
|
|
// will probably change the resources anyway.
|
|
//
|
|
pcData->pbDataBuff[dwcb] = 0;
|
|
|
|
pcData->pcParent = gpcodeScope;
|
|
ListInsertTail(&pcData->list,
|
|
(PPLIST)&gpcodeScope->pcFirstChild);
|
|
ASSERT(dwcb + 1 == pcData->dwDataLen);
|
|
pcData->dwCodeLen = pcData->dwDataLen;
|
|
pcData->bCodeChkSum = ComputeDataChkSum(pcData->pbDataBuff,
|
|
pcData->dwDataLen);
|
|
if ((gpcodeScope->pbDataBuff = MEMALLOC(sizeof(CODEOBJ))) ==
|
|
NULL)
|
|
{
|
|
ERROR(("ResourceTemplate: failed to allocate buffer argument object"));
|
|
rc = ASLERR_OUT_OF_MEM;
|
|
}
|
|
else
|
|
{
|
|
memset(gpcodeScope->pbDataBuff, 0, sizeof(CODEOBJ));
|
|
if ((rc = MakeIntData(pcData->dwDataLen,
|
|
(PCODEOBJ)gpcodeScope->pbDataBuff))
|
|
== ASLERR_NONE)
|
|
{
|
|
gpcodeScope->dwDataLen = 1;
|
|
gpcodeScope->dwCodeLen = 0;
|
|
gpcodeScope->bCodeChkSum = 0;
|
|
ComputeChkSumLen(gpcodeScope);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
EXIT((1, "ResourceTemplate=%d\n", rc));
|
|
return rc;
|
|
} //ResourceTemplate
|
|
|
|
/***LP AddSmallOffset - Add code length to cumulative bit offset
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL AddSmallOffset(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
|
|
ENTER((1, "AddSmallOffset(ptoken=%p,fActionFL=%d)\n",
|
|
ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
ASSERT((gpcodeScope->dwCodeValue & 0x80) == 0);
|
|
|
|
dwResBitOffset += ((gpcodeScope->dwCodeValue & 0x07) + 1)*8;
|
|
|
|
EXIT((1, "AddSmallOffset=%d\n", rc));
|
|
return rc;
|
|
} //AddSmallOffset
|
|
|
|
/***LP StartDependentFn - Start of Dependent Function
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL StartDependentFn(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pArgs;
|
|
|
|
ENTER((1, "StartDependentFn(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
if (pArgs[0].dwCodeValue > 2)
|
|
{
|
|
PrintTokenErr(ptoken, "Arg0 should be between 0-2", TRUE);
|
|
rc = ASLERR_SYNTAX;
|
|
}
|
|
else if (pArgs[1].dwCodeValue > 2)
|
|
{
|
|
PrintTokenErr(ptoken, "Arg1 should be between 0-2", TRUE);
|
|
rc = ASLERR_SYNTAX;
|
|
}
|
|
else
|
|
{
|
|
pArgs[0].dwCodeValue |= pArgs[1].dwCodeValue << 2;
|
|
pArgs[0].bCodeChkSum = (BYTE)pArgs[0].dwCodeValue;
|
|
gpcodeScope->dwDataLen = 1;
|
|
ASSERT((gpcodeScope->dwCodeValue & 0x80) == 0);
|
|
dwResBitOffset += ((gpcodeScope->dwCodeValue & 0x07) + 1)*8;
|
|
}
|
|
|
|
EXIT((1, "StartDependentFn=%d\n", rc));
|
|
return rc;
|
|
} //StartDependentFn
|
|
|
|
/***LP IRQDesc - IRQ resource descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL IRQDesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pArgs;
|
|
DWORD dwLen, dwIRQ = 0, dw;
|
|
PCODEOBJ pc;
|
|
#define MAX_IRQ 0x0f
|
|
|
|
ENTER((1, "IRQDesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == FALSE);
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
if (gpcodeScope->dwDataLen == 4) //IRQ
|
|
{
|
|
dwLen = 3;
|
|
|
|
if ((rc = SetDefMissingKW(&pArgs[2], ID_EXCLUSIVE)) == ASLERR_NONE)
|
|
{
|
|
EncodeKeywords(pArgs, 0x07, 0);
|
|
if ((pArgs[0].dwCodeValue & (_LL | _HE)) == (_LL | _HE))
|
|
{
|
|
PrintTokenErr(ptoken,
|
|
"Illegal combination of interrupt level and trigger mode",
|
|
TRUE);
|
|
rc = ASLERR_SYNTAX;
|
|
}
|
|
}
|
|
}
|
|
else //IRQNoFlags
|
|
{
|
|
ASSERT(gpcodeScope->dwDataLen == 1);
|
|
|
|
dwLen = 2;
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
pc = gpcodeScope->pcFirstChild;
|
|
if (pc != NULL)
|
|
{
|
|
ASSERT(pc->dwCodeType == CODETYPE_DATAOBJ);
|
|
for (dw = 0; dw < pc->dwDataLen; ++dw)
|
|
{
|
|
if (pc->pbDataBuff[dw] > MAX_IRQ)
|
|
{
|
|
PrintTokenErr(ptoken, "Invalid IRQ number", TRUE);
|
|
rc = ASLERR_SYNTAX;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
dwIRQ |= 1 << pc->pbDataBuff[dw];
|
|
}
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
MEMFREE(pc->pbDataBuff);
|
|
pc->pbDataBuff = NULL;
|
|
}
|
|
}
|
|
else if ((pc = MEMALLOC(sizeof(CODEOBJ))) != NULL)
|
|
{
|
|
memset(pc, 0, sizeof(CODEOBJ));
|
|
pc->pcParent = gpcodeScope;
|
|
ListInsertTail(&pc->list, (PPLIST)&gpcodeScope->pcFirstChild);
|
|
}
|
|
else
|
|
{
|
|
ERROR(("IRQDesc: failed to allocate DMA descriptor"));
|
|
rc = ASLERR_OUT_OF_MEM;
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
PCODEOBJ pa;
|
|
|
|
if (dwLen == 3)
|
|
dwIRQ |= (pArgs[0].dwCodeValue & 0xff) << 16;
|
|
|
|
SetIntObject(pc, dwIRQ, dwLen);
|
|
|
|
pa = &pArgs[gpcodeScope->dwDataLen == 4? 3: 0];
|
|
if (pa->dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pa->pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
rc = CreateResFields(ptoken, pns,
|
|
gpcodeScope->dwDataLen == 4?
|
|
IRQFields: IRQNoFlagsFields);
|
|
}
|
|
MEMFREE(pa->pbDataBuff);
|
|
memset(pa, 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
gpcodeScope->dwDataLen = 0;
|
|
MEMFREE(gpcodeScope->pbDataBuff);
|
|
gpcodeScope->pbDataBuff = NULL;
|
|
gpcodeScope->dwCodeLen = 0;
|
|
gpcodeScope->bCodeChkSum = 0;
|
|
ComputeChkSumLen(gpcodeScope);
|
|
ASSERT((gpcodeScope->dwCodeValue & 0x80) == 0);
|
|
dwResBitOffset += ((gpcodeScope->dwCodeValue & 0x07) + 1)*8;
|
|
}
|
|
}
|
|
}
|
|
|
|
EXIT((1, "IRQDesc=%d\n", rc));
|
|
return rc;
|
|
} //IRQDesc
|
|
|
|
/***LP DMADesc - DMA resource descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL DMADesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pArgs;
|
|
DWORD dwDMA = 0, dw;
|
|
PCODEOBJ pc;
|
|
#define MAX_DMA 0x07
|
|
|
|
ENTER((1, "DMADesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == FALSE);
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
EncodeKeywords(pArgs, 0x07, 0);
|
|
pc = gpcodeScope->pcFirstChild;
|
|
if (pc != NULL)
|
|
{
|
|
ASSERT(pc->dwCodeType == CODETYPE_DATAOBJ);
|
|
for (dw = 0; dw < pc->dwDataLen; ++dw)
|
|
{
|
|
if (pc->pbDataBuff[dw] > MAX_DMA)
|
|
{
|
|
PrintTokenErr(ptoken, "Invalid DMA number", TRUE);
|
|
rc = ASLERR_SYNTAX;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
dwDMA |= 1 << pc->pbDataBuff[dw];
|
|
}
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
MEMFREE(pc->pbDataBuff);
|
|
pc->pbDataBuff = NULL;
|
|
}
|
|
}
|
|
else if ((pc = MEMALLOC(sizeof(CODEOBJ))) != NULL)
|
|
{
|
|
memset(pc, 0, sizeof(CODEOBJ));
|
|
pc->pcParent = gpcodeScope;
|
|
ListInsertTail(&pc->list, (PPLIST)&gpcodeScope->pcFirstChild);
|
|
}
|
|
else
|
|
{
|
|
ERROR(("DMADesc: failed to allocate DMA descriptor"));
|
|
rc = ASLERR_OUT_OF_MEM;
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
dwDMA |= (pArgs[0].dwCodeValue & 0xff) << 8;
|
|
|
|
SetIntObject(pc, dwDMA, sizeof(WORD));
|
|
|
|
if (pArgs[3].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[3].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
rc = CreateResFields(ptoken, pns, DMAFields);
|
|
}
|
|
MEMFREE(pArgs[3].pbDataBuff);
|
|
memset(&pArgs[3], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
gpcodeScope->dwDataLen = 0;
|
|
MEMFREE(gpcodeScope->pbDataBuff);
|
|
gpcodeScope->pbDataBuff = NULL;
|
|
gpcodeScope->dwCodeLen = 0;
|
|
gpcodeScope->bCodeChkSum = 0;
|
|
ComputeChkSumLen(gpcodeScope);
|
|
ASSERT((gpcodeScope->dwCodeValue & 0x80) == 0);
|
|
dwResBitOffset += ((gpcodeScope->dwCodeValue & 0x07) + 1)*8;
|
|
}
|
|
}
|
|
|
|
EXIT((1, "DMADesc=%d\n", rc));
|
|
return rc;
|
|
} //DMADesc
|
|
|
|
/***LP IODesc - IO resource descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL IODesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pArgs;
|
|
|
|
ENTER((1, "IODesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
EncodeKeywords(pArgs, 0x01, 0);
|
|
|
|
if (pArgs[5].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[5].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
rc = CreateResFields(ptoken, pns, IOFields);
|
|
}
|
|
MEMFREE(pArgs[5].pbDataBuff);
|
|
memset(&pArgs[5], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
ASSERT((gpcodeScope->dwCodeValue & 0x80) == 0);
|
|
dwResBitOffset += ((gpcodeScope->dwCodeValue & 0x07) + 1)*8;
|
|
}
|
|
|
|
EXIT((1, "IODesc=%d\n", rc));
|
|
return rc;
|
|
} //IODesc
|
|
|
|
/***LP FixedIODesc - FixedIO resource descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL FixedIODesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
|
|
ENTER((1, "FixedIODesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
if (pArgs[2].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[2].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
rc = CreateResFields(ptoken, pns, FixedIOFields);
|
|
}
|
|
MEMFREE(pArgs[2].pbDataBuff);
|
|
memset(&pArgs[2], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
ASSERT((gpcodeScope->dwCodeValue & 0x80) == 0);
|
|
dwResBitOffset += ((gpcodeScope->dwCodeValue & 0x07) + 1)*8;
|
|
}
|
|
|
|
EXIT((1, "FixedIODesc=%d\n", rc));
|
|
return rc;
|
|
} //FixedIODesc
|
|
|
|
/***LP VendorDesc - Vendor-defined resource
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* dwMaxSize - 0x07 if short resource, 0xffff if long resource
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL VendorDesc(PTOKEN ptoken, DWORD dwMaxSize)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pc;
|
|
PBYTE pbOldBuff = NULL;
|
|
DWORD dwOldLen = 0;
|
|
#define SHORT_MAX_SIZE 0x07
|
|
#define LONG_MAX_SIZE 0xffff
|
|
|
|
ENTER((1, "VendorDesc(ptoken=%p,MaxSize=%d)\n", ptoken, dwMaxSize));
|
|
|
|
ASSERT((dwMaxSize == SHORT_MAX_SIZE) || (dwMaxSize == LONG_MAX_SIZE));
|
|
pc = gpcodeScope->pcFirstChild;
|
|
if (pc != NULL)
|
|
{
|
|
ASSERT(pc->dwCodeType == CODETYPE_DATAOBJ);
|
|
if (pc->dwDataLen > dwMaxSize)
|
|
{
|
|
PrintTokenErr(ptoken, "Vendor resource data can only be up to "
|
|
"7 bytes for short descriptor and 64K-1 bytes for "
|
|
"long descriptor", TRUE);
|
|
rc = ASLERR_SYNTAX;
|
|
}
|
|
else
|
|
{
|
|
pbOldBuff = pc->pbDataBuff;
|
|
dwOldLen = pc->dwDataLen;
|
|
}
|
|
}
|
|
else if ((pc = MEMALLOC(sizeof(CODEOBJ))) != NULL)
|
|
{
|
|
memset(pc, 0, sizeof(CODEOBJ));
|
|
pc->pcParent = gpcodeScope;
|
|
ListInsertTail(&pc->list, (PPLIST)&gpcodeScope->pcFirstChild);
|
|
}
|
|
else
|
|
{
|
|
ERROR(("VendorDesc: failed to allocate vendor-defined resource object"));
|
|
rc = ASLERR_OUT_OF_MEM;
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
int i;
|
|
|
|
pc->dwCodeType = CODETYPE_DATAOBJ;
|
|
if (dwMaxSize == SHORT_MAX_SIZE)
|
|
pc->dwDataLen = dwOldLen + 1;
|
|
else
|
|
pc->dwDataLen = dwOldLen + sizeof(WORD);
|
|
|
|
if ((pc->pbDataBuff = MEMALLOC(pc->dwDataLen)) != NULL)
|
|
{
|
|
PCODEOBJ pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
|
|
if (dwMaxSize == SHORT_MAX_SIZE)
|
|
{
|
|
pc->pbDataBuff[0] = (BYTE)(0x70 | dwOldLen);
|
|
i = 1;
|
|
}
|
|
else
|
|
{
|
|
*((PWORD)&pc->pbDataBuff[0]) = (WORD)dwOldLen;
|
|
i = sizeof(WORD);
|
|
}
|
|
|
|
if (pbOldBuff != NULL)
|
|
{
|
|
memcpy(&pc->pbDataBuff[i], pbOldBuff, dwOldLen);
|
|
MEMFREE(pbOldBuff);
|
|
}
|
|
pc->dwCodeLen = pc->dwDataLen;
|
|
pc->bCodeChkSum = ComputeDataChkSum((PBYTE)&pc->pbDataBuff,
|
|
pc->dwCodeLen);
|
|
|
|
if (pArgs[0].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[0].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_RES_FIELD;
|
|
pns->ObjData.uipDataValue = dwResBitOffset +
|
|
(dwMaxSize == SHORT_MAX_SIZE?
|
|
8: 8*3);
|
|
pns->ObjData.dwDataLen = 8*dwOldLen;
|
|
}
|
|
MEMFREE(pArgs[0].pbDataBuff);
|
|
memset(&pArgs[0], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
gpcodeScope->dwDataLen = 0;
|
|
MEMFREE(gpcodeScope->pbDataBuff);
|
|
gpcodeScope->pbDataBuff = NULL;
|
|
gpcodeScope->dwCodeLen = 0;
|
|
gpcodeScope->bCodeChkSum = 0;
|
|
ComputeChkSumLen(gpcodeScope);
|
|
|
|
if (dwMaxSize == SHORT_MAX_SIZE)
|
|
{
|
|
dwResBitOffset += ((pc->pbDataBuff[0] & 0x07) + 1)*8;
|
|
}
|
|
else
|
|
{
|
|
dwResBitOffset += (*((PWORD)&pc->pbDataBuff[0]) + 3)*8;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR(("VendorDesc: failed to allocate vendor-defined resource buffer"));
|
|
rc = ASLERR_OUT_OF_MEM;
|
|
}
|
|
}
|
|
|
|
EXIT((1, "VendorDesc=%d\n", rc));
|
|
return rc;
|
|
} //VendorDesc
|
|
|
|
/***LP VendorShort - Vendor-defined short resource
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL VendorShort(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc;
|
|
|
|
ENTER((1, "VendorShort(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == FALSE);
|
|
|
|
rc = VendorDesc(ptoken, 0x07);
|
|
|
|
EXIT((1, "VendorShort=%d\n", rc));
|
|
return rc;
|
|
} //VendorShort
|
|
|
|
/***LP InsertDescLength - Insert long descriptor length
|
|
*
|
|
* ENTRY
|
|
* pcode -> code object
|
|
* dwDescLen - length of descriptor
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL InsertDescLength(PCODEOBJ pcode, DWORD dwDescLen)
|
|
{
|
|
int rc;
|
|
PCODEOBJ pNewArgs;
|
|
|
|
ENTER((2, "InsertDescLength(pcode=%x,DescLen=%d)\n", pcode, dwDescLen));
|
|
|
|
if ((pNewArgs = MEMALLOC((pcode->dwDataLen + 1)*sizeof(CODEOBJ))) != NULL)
|
|
{
|
|
memcpy(&pNewArgs[1], pcode->pbDataBuff,
|
|
pcode->dwDataLen*sizeof(CODEOBJ));
|
|
memset(&pNewArgs[0], 0, sizeof(CODEOBJ));
|
|
SetIntObject(&pNewArgs[0], dwDescLen, sizeof(WORD));
|
|
MEMFREE(pcode->pbDataBuff);
|
|
pcode->dwDataLen++;
|
|
pcode->pbDataBuff = (PBYTE)pNewArgs;
|
|
|
|
rc = ASLERR_NONE;
|
|
}
|
|
else
|
|
{
|
|
ERROR(("InsertDescLength: failed to allocate new argument objects"));
|
|
rc = ASLERR_OUT_OF_MEM;
|
|
}
|
|
|
|
EXIT((2, "InsertDescLength=%d\n", rc));
|
|
return rc;
|
|
} //InsertDescLength
|
|
|
|
/***LP Memory24Desc - 24-bit memory resource descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL Memory24Desc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pArgs;
|
|
|
|
ENTER((1, "Memory24Desc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
EncodeKeywords(pArgs, 0x01, 0);
|
|
|
|
if (pArgs[5].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[5].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
rc = CreateResFields(ptoken, pns, Mem24Fields);
|
|
}
|
|
MEMFREE(pArgs[5].pbDataBuff);
|
|
memset(&pArgs[5], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if ((rc == ASLERR_NONE) &&
|
|
((rc = InsertDescLength(gpcodeScope, 9)) == ASLERR_NONE))
|
|
{
|
|
dwResBitOffset += 12*8;
|
|
}
|
|
|
|
EXIT((1, "Memory24Desc=%d\n", rc));
|
|
return rc;
|
|
} //Memory24Desc
|
|
|
|
/***LP VendorLong - Vendor-defined long resource
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL VendorLong(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc;
|
|
|
|
ENTER((1, "VendorLong(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == FALSE);
|
|
|
|
rc = VendorDesc(ptoken, 0xffff);
|
|
|
|
EXIT((1, "VendorLong=%d\n", rc));
|
|
return rc;
|
|
} //VendorLong
|
|
|
|
/***LP Memory32Desc - 32-bit memory resource descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL Memory32Desc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pArgs;
|
|
|
|
ENTER((1, "Memory32Desc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
EncodeKeywords(pArgs, 0x01, 0);
|
|
|
|
if (pArgs[5].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[5].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
rc = CreateResFields(ptoken, pns, Mem32Fields);
|
|
}
|
|
MEMFREE(pArgs[5].pbDataBuff);
|
|
memset(&pArgs[5], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if ((rc == ASLERR_NONE) &&
|
|
((rc = InsertDescLength(gpcodeScope, 17)) == ASLERR_NONE))
|
|
{
|
|
dwResBitOffset += 20*8;
|
|
}
|
|
|
|
EXIT((1, "Memory32Desc=%d\n", rc));
|
|
return rc;
|
|
} //Memory32Desc
|
|
|
|
/***LP FixedMemory32Desc - 32-bit fixed memory resource descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL FixedMemory32Desc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pArgs;
|
|
|
|
ENTER((1, "FixedMemory32Desc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
EncodeKeywords(pArgs, 0x01, 0);
|
|
|
|
if (pArgs[3].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[3].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
rc = CreateResFields(ptoken, pns, FixedMem32Fields);
|
|
}
|
|
MEMFREE(pArgs[3].pbDataBuff);
|
|
memset(&pArgs[3], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if ((rc == ASLERR_NONE) &&
|
|
((rc = InsertDescLength(gpcodeScope, 9)) == ASLERR_NONE))
|
|
{
|
|
dwResBitOffset += 12*8;
|
|
}
|
|
|
|
EXIT((1, "FixedMemory32Desc=%d\n", rc));
|
|
return rc;
|
|
} //FixedMemory32Desc
|
|
|
|
#define RESTYPE_MEM 0
|
|
#define RESTYPE_IO 1
|
|
#define RESTYPE_BUSNUM 2
|
|
|
|
/***LP MemSpaceDesc - Memory space descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> TOKEN
|
|
* dwMinLen - minimum descriptor length
|
|
* ResFields -> resource fields table
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL MemSpaceDesc(PTOKEN ptoken, DWORD dwMinLen, PRESFIELD ResFields)
|
|
{
|
|
int rc;
|
|
PCODEOBJ pArgs;
|
|
|
|
ENTER((1, "MemSpaceDesc(ptoken=%p,MinLen=%d,ResFields=%p)\n",
|
|
ptoken, dwMinLen, ResFields));
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
if (((rc = SetDefMissingKW(&pArgs[0], ID_RESCONSUMER)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[1], ID_POSDECODE)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[2], ID_MINNOTFIXED)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[3], ID_MAXNOTFIXED)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[4], ID_NONCACHEABLE)) == ASLERR_NONE))
|
|
{
|
|
EncodeKeywords(pArgs, 0x0f, 2);
|
|
EncodeKeywords(pArgs, 0x30, 3);
|
|
SetIntObject(&pArgs[1], RESTYPE_MEM, sizeof(BYTE));
|
|
|
|
if (!(pArgs[11].dwfCode & CF_MISSING_ARG))
|
|
dwMinLen++;
|
|
|
|
if (!(pArgs[12].dwfCode & CF_MISSING_ARG))
|
|
{
|
|
ASSERT(pArgs[12].dwCodeType == CODETYPE_STRING);
|
|
dwMinLen += pArgs[12].dwDataLen;
|
|
}
|
|
|
|
SetIntObject(&pArgs[0], dwMinLen, sizeof(WORD));
|
|
|
|
if (pArgs[13].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[13].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
if (((rc = CreateResFields(ptoken, pns, GenFlagFields)) ==
|
|
ASLERR_NONE) &&
|
|
((rc = CreateResFields(ptoken, pns, MemTypeFields)) ==
|
|
ASLERR_NONE))
|
|
{
|
|
rc = CreateResFields(ptoken, pns, ResFields);
|
|
}
|
|
}
|
|
MEMFREE(pArgs[13].pbDataBuff);
|
|
memset(&pArgs[13], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
dwResBitOffset += (dwMinLen + 3)*8;
|
|
}
|
|
}
|
|
|
|
EXIT((1, "MemSpaceDesc=%d\n", rc));
|
|
return rc;
|
|
} //MemSpaceDesc
|
|
|
|
/***LP IOSpaceDesc - IO space descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> TOKEN
|
|
* dwMinLen - minimum descriptor length
|
|
* ResFields -> resource fields table
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL IOSpaceDesc(PTOKEN ptoken, DWORD dwMinLen, PRESFIELD ResFields)
|
|
{
|
|
int rc;
|
|
PCODEOBJ pArgs;
|
|
|
|
ENTER((2, "IOSpaceDesc(ptoken=%p,MinLen=%d,ResFields=%p)\n",
|
|
ptoken, dwMinLen, ResFields));
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
if (((rc = SetDefMissingKW(&pArgs[0], ID_RESCONSUMER)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[1], ID_MINNOTFIXED)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[2], ID_MAXNOTFIXED)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[3], ID_POSDECODE)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[4], ID_ENTIRERNG)) == ASLERR_NONE))
|
|
{
|
|
EncodeKeywords(pArgs, 0x0f, 2);
|
|
EncodeKeywords(pArgs, 0x10, 3);
|
|
SetIntObject(&pArgs[1], RESTYPE_IO, sizeof(BYTE));
|
|
|
|
if (!(pArgs[10].dwfCode & CF_MISSING_ARG))
|
|
dwMinLen++;
|
|
|
|
if (!(pArgs[11].dwfCode & CF_MISSING_ARG))
|
|
{
|
|
ASSERT(pArgs[11].dwCodeType == CODETYPE_STRING);
|
|
dwMinLen += pArgs[11].dwDataLen;
|
|
}
|
|
|
|
SetIntObject(&pArgs[0], dwMinLen, sizeof(WORD));
|
|
|
|
if (pArgs[12].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[12].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
if (((rc = CreateResFields(ptoken, pns, GenFlagFields)) ==
|
|
ASLERR_NONE) &&
|
|
((rc = CreateResFields(ptoken, pns, MemTypeFields)) ==
|
|
ASLERR_NONE))
|
|
{
|
|
rc = CreateResFields(ptoken, pns, ResFields);
|
|
}
|
|
}
|
|
MEMFREE(pArgs[12].pbDataBuff);
|
|
memset(&pArgs[12], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
dwResBitOffset += (dwMinLen + 3)*8;
|
|
}
|
|
}
|
|
|
|
EXIT((2, "IOSpaceDesc=%d\n", rc));
|
|
return rc;
|
|
} //IOSpaceDesc
|
|
|
|
/***LP DWordMemDesc - DWord memory descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL DWordMemDesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc;
|
|
|
|
ENTER((1, "DWordMemDesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
rc = MemSpaceDesc(ptoken, 23, DWordFields);
|
|
|
|
EXIT((1, "DWordMemDesc=%d\n", rc));
|
|
return rc;
|
|
} //DWordMemDesc
|
|
|
|
/***LP DWordIODesc - DWord IO descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL DWordIODesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc;
|
|
|
|
ENTER((1, "DWordIODesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
rc = IOSpaceDesc(ptoken, 23, DWordFields);
|
|
|
|
EXIT((1, "DWordIODesc=%d\n", rc));
|
|
return rc;
|
|
} //DWordIODesc
|
|
|
|
/***LP WordIODesc - Word IO descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL WordIODesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc;
|
|
|
|
ENTER((1, "WordIODesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
rc = IOSpaceDesc(ptoken, 13, WordFields);
|
|
|
|
EXIT((1, "WordIODesc=%d\n", rc));
|
|
return rc;
|
|
} //WordIODesc
|
|
|
|
/***LP WordBusNumDesc - Word BusNum descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL WordBusNumDesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc;
|
|
PCODEOBJ pArgs;
|
|
|
|
ENTER((1, "WordBusNumDesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
if (((rc = SetDefMissingKW(&pArgs[0], ID_RESCONSUMER)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[1], ID_MINNOTFIXED)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[2], ID_MAXNOTFIXED)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[3], ID_POSDECODE)) == ASLERR_NONE))
|
|
{
|
|
DWORD dwLen;
|
|
|
|
EncodeKeywords(pArgs, 0x0f, 2);
|
|
SetIntObject(&pArgs[1], RESTYPE_BUSNUM, sizeof(BYTE));
|
|
SetIntObject(&pArgs[3], 0, sizeof(BYTE));
|
|
|
|
dwLen = 13;
|
|
if (!(pArgs[9].dwfCode & CF_MISSING_ARG))
|
|
dwLen++;
|
|
|
|
if (!(pArgs[10].dwfCode & CF_MISSING_ARG))
|
|
{
|
|
ASSERT(pArgs[10].dwCodeType == CODETYPE_STRING);
|
|
dwLen += pArgs[10].dwDataLen;
|
|
}
|
|
|
|
SetIntObject(&pArgs[0], dwLen, sizeof(WORD));
|
|
|
|
if (pArgs[11].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
|
|
if ((rc = CreateNameSpaceObj(ptoken, (PSZ)pArgs[11].pbDataBuff,
|
|
gpnsCurrentScope, gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
if ((rc = CreateResFields(ptoken, pns, GenFlagFields)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
rc = CreateResFields(ptoken, pns, WordFields);
|
|
}
|
|
}
|
|
MEMFREE(pArgs[11].pbDataBuff);
|
|
memset(&pArgs[11], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
dwResBitOffset += (dwLen + 3)*8;
|
|
}
|
|
}
|
|
|
|
EXIT((1, "WordBusNumDesc=%d\n", rc));
|
|
return rc;
|
|
} //WordBusNumDesc
|
|
|
|
/***LP InterruptDesc - Extended Interrupt resource descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL InterruptDesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
PCODEOBJ pArgs;
|
|
PCODEOBJ pc;
|
|
|
|
ENTER((1, "InterruptDesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == FALSE);
|
|
|
|
pArgs = (PCODEOBJ)gpcodeScope->pbDataBuff;
|
|
pc = gpcodeScope->pcFirstChild;
|
|
if (((rc = SetDefMissingKW(&pArgs[0], ID_RESCONSUMER)) == ASLERR_NONE) &&
|
|
((rc = SetDefMissingKW(&pArgs[3], ID_EXCLUSIVE)) == ASLERR_NONE))
|
|
{
|
|
if (pArgs[1].dwCodeValue == ID_EDGE)
|
|
pArgs[1].dwCodeValue = ID_EXT_EDGE;
|
|
else if (pArgs[1].dwCodeValue == ID_LEVEL)
|
|
pArgs[1].dwCodeValue = ID_EXT_LEVEL;
|
|
|
|
if (pArgs[2].dwCodeValue == ID_ACTIVEHI)
|
|
pArgs[2].dwCodeValue = ID_EXT_ACTIVEHI;
|
|
else if (pArgs[2].dwCodeValue == ID_ACTIVELO)
|
|
pArgs[2].dwCodeValue = ID_EXT_ACTIVELO;
|
|
|
|
if (pArgs[3].dwCodeValue == ID_SHARED)
|
|
pArgs[3].dwCodeValue = ID_EXT_SHARED;
|
|
else if (pArgs[3].dwCodeValue == ID_EXCLUSIVE)
|
|
pArgs[3].dwCodeValue = ID_EXT_EXCLUSIVE;
|
|
|
|
if (((rc = LookupIDIndex(pArgs[1].dwCodeValue, &pArgs[1].dwTermIndex))
|
|
== ASLERR_NONE) &&
|
|
((rc = LookupIDIndex(pArgs[2].dwCodeValue, &pArgs[2].dwTermIndex))
|
|
== ASLERR_NONE) &&
|
|
((rc = LookupIDIndex(pArgs[3].dwCodeValue, &pArgs[3].dwTermIndex))
|
|
== ASLERR_NONE))
|
|
{
|
|
EncodeKeywords(pArgs, 0x0f, 1);
|
|
{
|
|
DWORD dwNumIRQs = 0;
|
|
DWORD dwLen;
|
|
|
|
if (pc != NULL)
|
|
{
|
|
ASSERT(pc->dwCodeType == CODETYPE_DATAOBJ);
|
|
dwNumIRQs = pc->dwDataLen/sizeof(DWORD);
|
|
}
|
|
|
|
SetIntObject(&pArgs[2], dwNumIRQs, sizeof(BYTE));
|
|
memcpy(&pArgs[3], pc, sizeof(CODEOBJ));
|
|
MEMFREE(pc);
|
|
gpcodeScope->pcFirstChild = NULL;
|
|
|
|
dwLen = 2 + dwNumIRQs*sizeof(DWORD);
|
|
if (!(pArgs[4].dwfCode & CF_MISSING_ARG))
|
|
dwLen++;
|
|
|
|
if (!(pArgs[5].dwfCode & CF_MISSING_ARG))
|
|
{
|
|
ASSERT(pArgs[5].dwCodeType == CODETYPE_STRING);
|
|
dwLen += pArgs[5].dwDataLen;
|
|
}
|
|
|
|
SetIntObject(&pArgs[0], dwLen, sizeof(WORD));
|
|
|
|
if (pArgs[6].dwCodeType == CODETYPE_STRING)
|
|
{
|
|
PNSOBJ pns;
|
|
static RESFIELD IRQTabFields[] =
|
|
{
|
|
"_INT", 5*8 + 0, 0,
|
|
NULL, 0, 0
|
|
};
|
|
|
|
IRQTabFields[0].dwBitSize = dwNumIRQs*32;
|
|
if ((rc = CreateNameSpaceObj(ptoken,
|
|
(PSZ)pArgs[6].pbDataBuff,
|
|
gpnsCurrentScope,
|
|
gpnsCurrentOwner,
|
|
&pns, NSF_EXIST_ERR)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_PNP_RES;
|
|
if ((rc = CreateResFields(ptoken, pns, IRQExFields)) ==
|
|
ASLERR_NONE)
|
|
{
|
|
rc = CreateResFields(ptoken, pns, IRQTabFields);
|
|
}
|
|
}
|
|
MEMFREE(pArgs[6].pbDataBuff);
|
|
memset(&pArgs[6], 0, sizeof(CODEOBJ));
|
|
}
|
|
|
|
if (rc == ASLERR_NONE)
|
|
{
|
|
gpcodeScope->dwCodeLen = 0;
|
|
gpcodeScope->bCodeChkSum = 0;
|
|
ComputeChkSumLen(gpcodeScope);
|
|
dwResBitOffset = (dwLen + 3)*8;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
EXIT((1, "InterruptDesc=%d\n", rc));
|
|
return rc;
|
|
} //InterruptDesc
|
|
|
|
/***LP QWordMemDesc - QWord memory descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL QWordMemDesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc;
|
|
|
|
ENTER((1, "QWordMemDesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
rc = MemSpaceDesc(ptoken, 43, QWordFields);
|
|
|
|
EXIT((1, "QWordMemDesc=%d\n", rc));
|
|
return rc;
|
|
} //QWordMemDesc
|
|
|
|
/***LP QWordIODesc - QWord IO descriptor
|
|
*
|
|
* ENTRY
|
|
* ptoken -> token stream
|
|
* fActionFL - TRUE if this is a fixed list action
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL QWordIODesc(PTOKEN ptoken, BOOL fActionFL)
|
|
{
|
|
int rc;
|
|
|
|
ENTER((1, "QWordIODesc(ptoken=%p,fActionFL=%d)\n", ptoken, fActionFL));
|
|
|
|
DEREF(ptoken);
|
|
DEREF(fActionFL);
|
|
ASSERT(fActionFL == TRUE);
|
|
|
|
rc = IOSpaceDesc(ptoken, 43, QWordFields);
|
|
|
|
EXIT((1, "QWordIODesc=%d\n", rc));
|
|
return rc;
|
|
} //QWordIODesc
|
|
|
|
/***LP CreateResFields - Create resource fields
|
|
*
|
|
* ENTRY
|
|
* ptoken -> TOKEN
|
|
* pnsParent -> parent object
|
|
* prf -> resource fields table
|
|
*
|
|
* EXIT-SUCCESS
|
|
* returns ASLERR_NONE
|
|
* EXIT-FAILURE
|
|
* returns negative error code
|
|
*/
|
|
|
|
int LOCAL CreateResFields(PTOKEN ptoken, PNSOBJ pnsParent, PRESFIELD prf)
|
|
{
|
|
int rc = ASLERR_NONE;
|
|
int i;
|
|
PNSOBJ pns;
|
|
|
|
ENTER((2, "CreateResFields(ptoken=%p,pnsParent=%s,prf=%p)\n",
|
|
ptoken, GetObjectPath(pnsParent), prf));
|
|
|
|
for (i = 0; prf[i].pszName != NULL; ++i)
|
|
{
|
|
if ((rc = CreateNameSpaceObj(ptoken, prf[i].pszName, pnsParent,
|
|
gpnsCurrentOwner, &pns, NSF_EXIST_ERR))
|
|
== ASLERR_NONE)
|
|
{
|
|
pns->ObjData.dwDataType = OBJTYPE_RES_FIELD;
|
|
pns->ObjData.uipDataValue = dwResBitOffset + prf[i].dwBitOffset;
|
|
pns->ObjData.dwDataLen = prf[i].dwBitSize;
|
|
}
|
|
}
|
|
|
|
EXIT((2, "CreateResFields=%d\n", rc));
|
|
return rc;
|
|
} //CreateResFields
|