Lines Matching refs:cmd
66 #define CODEC_CAD(cmd) (((cmd) & CODEC_CAD_MASK) >> CODEC_CAD_SHIFT)
67 #define CODEC_DIRECT(cmd) ((cmd) & CODEC_DIRECT_MASK)
68 #define CODEC_NID(cmd) ((((cmd) & CODEC_NID_MASK)) >> CODEC_NID_SHIFT)
69 #define CODEC_VERBDATA(cmd) ((cmd) & CODEC_VERBDATA_MASK)
70 #define CODEC_VERB_CMD(cmd, mask, x) (((cmd) & (mask)) >> (x))
71 #define CODEC_VERB_CMD4(cmd) (CODEC_VERB_CMD((cmd), CODEC_VERB_4BIT_CMD, 4))
72 #define CODEC_VERB_CMD8(cmd) (CODEC_VERB_CMD((cmd), CODEC_VERB_8BIT_CMD, 8))
73 #define CODEC_VERB_CMD16(cmd) (CODEC_VERB_CMD((cmd), CODEC_VERB_16BIT_CMD, 16))
74 #define CODEC_VERB_PAYLOAD4(cmd) ((cmd) & CODEC_VERB_4BIT_DATA)
75 #define CODEC_VERB_PAYLOAD8(cmd) ((cmd) & CODEC_VERB_8BIT_DATA)
76 #define CODEC_VERB_PAYLOAD16(cmd) ((cmd) & CODEC_VERB_16BIT_DATA)
83 #define CODEC_GET_AMP_DIRECTION(cmd) (((cmd) & CODEC_VERB_GET_AMP_DIRECTION) >> 15)
84 #define CODEC_GET_AMP_SIDE(cmd) (((cmd) & CODEC_VERB_GET_AMP_SIDE) >> 13)
85 #define CODEC_GET_AMP_INDEX(cmd) (CODEC_GET_AMP_DIRECTION(cmd) ? 0 : ((cmd) & CODEC_VERB_GET_AMP_INDEX))
94 #define CODEC_SET_AMP_IS_OUT_DIRECTION(cmd) (((cmd) & CODEC_VERB_SET_AMP_OUT_DIRECTION) != 0)
95 #define CODEC_SET_AMP_IS_IN_DIRECTION(cmd) (((cmd) & CODEC_VERB_SET_AMP_IN_DIRECTION) != 0)
96 #define CODEC_SET_AMP_IS_LEFT_SIDE(cmd) (((cmd) & CODEC_VERB_SET_AMP_LEFT_SIDE) != 0)
97 #define CODEC_SET_AMP_IS_RIGHT_SIDE(cmd) (((cmd) & CODEC_VERB_SET_AMP_RIGHT_SIDE) != 0)
98 #define CODEC_SET_AMP_INDEX(cmd) (((cmd) & CODEC_VERB_SET_AMP_INDEX) >> 7)
1237 static DECLCALLBACK(int) vrbProcUnimplemented(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1239 LogFlowFunc(("cmd(raw:%x: cad:%x, d:%c, nid:%x, verb:%x)\n", cmd,
1240 CODEC_CAD(cmd), CODEC_DIRECT(cmd) ? 'N' : 'Y', CODEC_NID(cmd), CODEC_VERBDATA(cmd)));
1245 static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1248 rc = vrbProcUnimplemented(pThis, cmd, pResp);
1254 static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1256 Assert(CODEC_CAD(cmd) == pThis->id);
1257 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1258 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1260 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1266 uint8_t u8Index = CODEC_GET_AMP_DIRECTION(cmd) == AMPLIFIER_OUT? 0 : CODEC_GET_AMP_INDEX(cmd);
1268 PCODECNODE pNode = &pThis->paNodes[CODEC_NID(cmd)];
1269 if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1271 CODEC_GET_AMP_DIRECTION(cmd),
1272 CODEC_GET_AMP_SIDE(cmd),
1274 else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1276 CODEC_GET_AMP_DIRECTION(cmd),
1277 CODEC_GET_AMP_SIDE(cmd),
1279 else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
1281 CODEC_GET_AMP_DIRECTION(cmd),
1282 CODEC_GET_AMP_SIDE(cmd),
1284 else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
1286 CODEC_GET_AMP_DIRECTION(cmd),
1287 CODEC_GET_AMP_SIDE(cmd),
1289 else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1291 CODEC_GET_AMP_DIRECTION(cmd),
1292 CODEC_GET_AMP_SIDE(cmd),
1294 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1296 CODEC_GET_AMP_DIRECTION(cmd),
1297 CODEC_GET_AMP_SIDE(cmd),
1300 AssertMsgFailedReturn(("access to fields of %x need to be implemented\n", CODEC_NID(cmd)), VINF_SUCCESS);
1305 static DECLCALLBACK(int) vrbProcSetAmplifier(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1312 Assert(CODEC_CAD(cmd) == pThis->id);
1313 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1315 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1319 PCODECNODE pNode = &pThis->paNodes[CODEC_NID(cmd)];
1321 if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1323 else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1325 else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
1327 else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
1329 else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1331 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1336 fIsOut = CODEC_SET_AMP_IS_OUT_DIRECTION(cmd);
1337 fIsIn = CODEC_SET_AMP_IS_IN_DIRECTION(cmd);
1338 fIsRight = CODEC_SET_AMP_IS_RIGHT_SIDE(cmd);
1339 fIsLeft = CODEC_SET_AMP_IS_LEFT_SIDE(cmd);
1340 u8Index = CODEC_SET_AMP_INDEX(cmd);
1347 hdaCodecSetRegisterU8(&LIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd, 0);
1349 hdaCodecSetRegisterU8(&LIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd, 0);
1361 hdaCodecSetRegisterU8(&LIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd, 0);
1363 hdaCodecSetRegisterU8(&LIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd, 0);
1376 static DECLCALLBACK(int) vrbProcGetParameter(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1378 Assert(CODEC_CAD(cmd) == pThis->id);
1379 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1381 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1384 Assert((cmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F00_PARAM_LENGTH);
1385 if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F00_PARAM_LENGTH)
1387 LogFlowFunc(("invalid F00 parameter %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
1390 *pResp = pThis->paNodes[CODEC_NID(cmd)].node.au32F00_param[cmd & CODEC_VERB_8BIT_DATA];
1395 static DECLCALLBACK(int) vrbProcGetConSelectCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1397 Assert(CODEC_CAD(cmd) == pThis->id);
1398 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1399 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1401 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1405 if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
1406 *pResp = pThis->paNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
1407 else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1408 *pResp = pThis->paNodes[CODEC_NID(cmd)].digout.u32F01_param;
1409 else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1410 *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F01_param;
1411 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1412 *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F01_param;
1413 else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1414 *pResp = pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
1419 static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1421 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1422 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1424 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1429 if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
1430 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
1431 else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1432 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digout.u32F01_param;
1433 else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1434 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F01_param;
1435 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1436 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adc.u32F01_param;
1437 else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1438 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
1441 hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1446 static DECLCALLBACK(int) vrbProcGetPinCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1448 Assert(CODEC_CAD(cmd) == pThis->id);
1449 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1450 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1452 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1456 if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1457 *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F07_param;
1458 else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1459 *pResp = pThis->paNodes[CODEC_NID(cmd)].digout.u32F07_param;
1460 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1461 *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F07_param;
1462 else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
1463 *pResp = pThis->paNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
1464 else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
1465 *pResp = pThis->paNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
1466 else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1467 *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
1474 static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1476 Assert(CODEC_CAD(cmd) == pThis->id);
1477 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1478 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1480 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1485 if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1486 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F07_param;
1487 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1488 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F07_param;
1489 else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1490 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digout.u32F07_param;
1491 else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
1492 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
1493 else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
1494 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
1495 else if ( hdaCodecIsReservedNode(pThis, CODEC_NID(cmd))
1496 && CODEC_NID(cmd) == 0x1b)
1497 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
1500 hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1505 static DECLCALLBACK(int) vrbProcGetUnsolicitedEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1507 Assert(CODEC_CAD(cmd) == pThis->id);
1508 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1509 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1511 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1515 if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1516 *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F08_param;
1517 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1518 *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
1519 else if ((cmd) == 1 /* AFG */)
1520 *pResp = pThis->paNodes[CODEC_NID(cmd)].afg.u32F08_param;
1521 else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
1522 *pResp = pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
1523 else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1524 *pResp = pThis->paNodes[CODEC_NID(cmd)].digout.u32F08_param;
1525 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1526 *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
1528 AssertMsgFailed(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
1533 static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1535 Assert(CODEC_CAD(cmd) == pThis->id);
1536 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1537 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1539 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1544 if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1545 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F08_param;
1546 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1547 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
1548 else if (CODEC_NID(cmd) == 1 /* AFG */)
1549 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].afg.u32F08_param;
1550 else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
1551 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
1552 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1553 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
1554 else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
1555 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digout.u32F08_param;
1557 AssertMsgFailedReturn(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)), VINF_SUCCESS);
1558 hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1563 static DECLCALLBACK(int) vrbProcGetPinSense(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1565 Assert(CODEC_CAD(cmd) == pThis->id);
1566 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1567 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1569 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1573 if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1574 *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F09_param;
1575 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1576 *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
1578 AssertMsgFailed(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
1583 static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1585 Assert(CODEC_CAD(cmd) == pThis->id);
1586 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1587 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1589 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1594 if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
1595 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F09_param;
1596 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1597 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
1600 hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
1604 static DECLCALLBACK(int) vrbProcGetConnectionListEntry(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1606 Assert(CODEC_CAD(cmd) == pThis->id);
1607 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1609 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1611 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1614 Assert((cmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F02_PARAM_LENGTH);
1615 if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F02_PARAM_LENGTH)
1617 LogFlowFunc(("access to invalid F02 index %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
1620 *pResp = pThis->paNodes[CODEC_NID(cmd)].node.au32F02_param[cmd & CODEC_VERB_8BIT_DATA];
1625 static DECLCALLBACK(int) vrbProcGetProcessingState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1627 Assert(CODEC_CAD(cmd) == pThis->id);
1628 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1629 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1631 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1635 if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1636 *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F03_param;
1641 static DECLCALLBACK(int) vrbProcSetProcessingState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1643 Assert(CODEC_CAD(cmd) == pThis->id);
1644 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1645 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1647 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1651 if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1652 hdaCodecSetRegisterU8(&pThis->paNodes[CODEC_NID(cmd)].adc.u32F03_param, cmd, 0);
1657 static DECLCALLBACK(int) vrbProcGetDigitalConverter(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1659 Assert(CODEC_CAD(cmd) == pThis->id);
1660 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1661 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1663 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1667 if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1668 *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F0d_param;
1669 else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1670 *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F0d_param;
1674 static int codecSetDigitalConverter(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
1676 Assert(CODEC_CAD(cmd) == pThis->id);
1677 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1678 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1680 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1684 if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1685 hdaCodecSetRegisterU8(&pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F0d_param, cmd, u8Offset);
1686 else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1687 hdaCodecSetRegisterU8(&pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F0d_param, cmd, u8Offset);
1692 static DECLCALLBACK(int) vrbProcSetDigitalConverter1(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1694 return codecSetDigitalConverter(pThis, cmd, 0, pResp);
1698 static DECLCALLBACK(int) vrbProcSetDigitalConverter2(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1700 return codecSetDigitalConverter(pThis, cmd, 8, pResp);
1704 static DECLCALLBACK(int) vrbProcGetSubId(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1706 Assert(CODEC_CAD(cmd) == pThis->id);
1707 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1708 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1710 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1713 if (CODEC_NID(cmd) == 1 /* AFG */)
1714 *pResp = pThis->paNodes[CODEC_NID(cmd)].afg.u32F20_param;
1720 static int codecSetSubIdX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
1722 Assert(CODEC_CAD(cmd) == pThis->id);
1723 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1724 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1726 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1730 if (CODEC_NID(cmd) == 0x1 /* AFG */)
1731 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].afg.u32F20_param;
1734 hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
1739 static DECLCALLBACK(int) vrbProcSetSubId0(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1742 return codecSetSubIdX(pThis, cmd, 0);
1746 static DECLCALLBACK(int) vrbProcSetSubId1(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1749 return codecSetSubIdX(pThis, cmd, 8);
1753 static DECLCALLBACK(int) vrbProcSetSubId2(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1756 return codecSetSubIdX(pThis, cmd, 16);
1760 static DECLCALLBACK(int) vrbProcSetSubId3(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1763 return codecSetSubIdX(pThis, cmd, 24);
1766 static DECLCALLBACK(int) vrbProcReset(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1768 Assert(CODEC_CAD(cmd) == pThis->id);
1769 Assert(CODEC_NID(cmd) == 1 /* AFG */);
1770 if ( CODEC_NID(cmd) == 1 /* AFG */
1788 static DECLCALLBACK(int) vrbProcGetPowerState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1790 Assert(CODEC_CAD(cmd) == pThis->id);
1791 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1792 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1794 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1798 if (CODEC_NID(cmd) == 1 /* AFG */)
1799 *pResp = pThis->paNodes[CODEC_NID(cmd)].afg.u32F05_param;
1800 else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1801 *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
1802 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1803 *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
1804 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1805 *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
1806 else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1807 *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
1808 else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1809 *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
1810 else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1811 *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
1828 static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1830 Assert(CODEC_CAD(cmd) == pThis->id);
1831 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1832 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1834 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1839 if (CODEC_NID(cmd) == 1 /* AFG */)
1840 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].afg.u32F05_param;
1841 else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1842 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
1843 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
1844 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
1845 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1846 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
1847 else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1848 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
1849 else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1850 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
1851 else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1852 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
1859 if (CODEC_NID(cmd) != 1 /* AFG */)
1866 CODEC_F05_SET(cmd));
1870 if ( CODEC_NID(cmd) == 1 /* AFG */
1873 *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, CODEC_F05_SET(cmd), CODEC_F05_SET(cmd));
1874 if ( CODEC_NID(cmd) == 1 /* AFG */
1875 && (CODEC_F05_SET(cmd)) == CODEC_F05_D0)
1894 static DECLCALLBACK(int) vrbProcGetStreamId(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1896 Assert(CODEC_CAD(cmd) == pThis->id);
1897 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1898 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1900 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1904 if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1905 *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
1906 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1907 *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F06_param;
1908 else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1909 *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
1910 else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1911 *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
1912 else if (CODEC_NID(cmd) == 0x1A)
1913 *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
1917 static DECLCALLBACK(int) vrbProcSetStreamId(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1919 Assert(CODEC_CAD(cmd) == pThis->id);
1920 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1921 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1923 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1928 if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1929 pu32addr = &pThis->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
1930 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1931 pu32addr = &pThis->paNodes[CODEC_NID(cmd)].adc.u32F06_param;
1932 else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1933 pu32addr = &pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
1934 else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1935 pu32addr = &pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
1936 else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
1937 pu32addr = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
1940 hdaCodecSetRegisterU8(pu32addr, cmd, 0);
1944 static DECLCALLBACK(int) vrbProcGetConverterFormat(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1946 Assert(CODEC_CAD(cmd) == pThis->id);
1947 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1948 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1950 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1954 if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1955 *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32A_param;
1956 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1957 *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32A_param;
1958 else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1959 *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifout.u32A_param;
1960 else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1961 *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifin.u32A_param;
1965 static DECLCALLBACK(int) vrbProcSetConverterFormat(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1967 Assert(CODEC_CAD(cmd) == pThis->id);
1968 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1969 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1971 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1975 if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
1976 hdaCodecSetRegisterU16(&pThis->paNodes[CODEC_NID(cmd)].dac.u32A_param, cmd, 0);
1977 else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
1978 hdaCodecSetRegisterU16(&pThis->paNodes[CODEC_NID(cmd)].adc.u32A_param, cmd, 0);
1979 else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
1980 hdaCodecSetRegisterU16(&pThis->paNodes[CODEC_NID(cmd)].spdifout.u32A_param, cmd, 0);
1981 else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
1982 hdaCodecSetRegisterU16(&pThis->paNodes[CODEC_NID(cmd)].spdifin.u32A_param, cmd, 0);
1987 static DECLCALLBACK(int) vrbProcGetEAPD_BTLEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
1989 Assert(CODEC_CAD(cmd) == pThis->id);
1990 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
1991 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
1993 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
1997 if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
1998 *pResp = pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
1999 else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
2000 *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32F0c_param;
2001 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
2002 *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
2007 static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2009 Assert(CODEC_CAD(cmd) == pThis->id);
2010 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
2011 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
2013 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
2019 if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
2020 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
2021 else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
2022 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].dac.u32F0c_param;
2023 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
2024 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
2027 hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
2033 static DECLCALLBACK(int) vrbProcGetVolumeKnobCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2035 Assert(CODEC_CAD(cmd) == pThis->id);
2036 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
2037 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
2039 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
2043 if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
2044 *pResp = pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
2049 static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2051 Assert(CODEC_CAD(cmd) == pThis->id);
2052 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
2053 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
2055 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
2060 if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
2061 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
2064 hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
2069 static DECLCALLBACK(int) vrbProcGetGPIOUnsolisted(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2071 Assert(CODEC_CAD(cmd) == pThis->id);
2072 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
2073 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
2075 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
2080 if (CODEC_NID(cmd) == 0x1 /* AFG */)
2086 static DECLCALLBACK(int) vrbProcSetGPIOUnsolisted(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2088 Assert(CODEC_CAD(cmd) == pThis->id);
2089 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
2090 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
2092 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
2097 if (CODEC_NID(cmd) == 1 /* AFG */)
2101 hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
2106 static DECLCALLBACK(int) vrbProcGetConfig(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2108 Assert(CODEC_CAD(cmd) == pThis->id);
2109 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
2110 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
2112 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
2116 if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
2117 *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F1c_param;
2118 else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
2119 *pResp = pThis->paNodes[CODEC_NID(cmd)].digout.u32F1c_param;
2120 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
2121 *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F1c_param;
2122 else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
2123 *pResp = pThis->paNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
2124 else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
2125 *pResp = pThis->paNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
2126 else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
2127 *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
2131 static int codecSetConfigX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
2133 Assert(CODEC_CAD(cmd) == pThis->id);
2134 Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
2135 if (CODEC_NID(cmd) >= pThis->cTotalNodes)
2137 LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
2141 if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
2142 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F1c_param;
2143 else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
2144 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F1c_param;
2145 else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
2146 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digout.u32F1c_param;
2147 else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
2148 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
2149 else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
2150 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
2151 else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
2152 pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
2155 hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
2160 static DECLCALLBACK(int) vrbProcSetConfig0(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2163 return codecSetConfigX(pThis, cmd, 0);
2167 static DECLCALLBACK(int) vrbProcSetConfig1(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2170 return codecSetConfigX(pThis, cmd, 8);
2174 static DECLCALLBACK(int) vrbProcSetConfig2(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2177 return codecSetConfigX(pThis, cmd, 16);
2181 static DECLCALLBACK(int) vrbProcSetConfig3(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
2184 return codecSetConfigX(pThis, cmd, 24);
2238 static int codecLookup(PHDACODEC pThis, uint32_t cmd, PPFNHDACODECVERBPROCESSOR pfn)
2240 Assert(CODEC_CAD(cmd) == pThis->id);
2241 if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
2242 LogFlowFunc(("cmd %x was addressed to reserved node\n", cmd));
2244 if ( CODEC_VERBDATA(cmd) == 0
2245 || CODEC_NID(cmd) >= pThis->cTotalNodes)
2249 LogFlowFunc(("cmd %x was ignored\n", cmd));
2255 if ((CODEC_VERBDATA(cmd) & pThis->paVerbs[i].mask) == pThis->paVerbs[i].verb)
2263 LogFlowFunc(("callback for %x wasn't found\n", CODEC_VERBDATA(cmd)));