/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
*/
#include "amd_iommu_acpi.h"
#include "amd_iommu_impl.h"
static void dump_acpi_aliases(void);
/*
* Globals
*/
static int
{
switch (len_bits) {
case 0:
return (4);
case 1:
return (8);
case 2:
return (16);
case 3:
return (32);
default:
return (len_bits);
}
/*NOTREACHED*/
}
static void
{
int i;
/* 4 byte entry */
for (i = 0; i < 2; i++) {
}
switch (entry_type) {
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 0:
default:
return;
}
if (c->ivhdc_first_deventry == NULL)
c->ivhdc_first_deventry = devp;
else
c->ivhdc_last_deventry = devp;
if (entry_type == 4)
return;
AMD_IOMMU_ACPI_DATRSV) == 0);
}
static void
{
int i;
/* Length is 8 bytes */
for (i = 0; i < 2; i++) {
}
switch (entry_type) {
case 66:
break;
case 67:
break;
case 70:
break;
case 71:
break;
case 72:
default:
#ifdef BROKEN_ASSERT
for (i = 0; i < 7; i++) {
}
#endif
return;
}
if (c->ivhdc_first_deventry == NULL)
c->ivhdc_first_deventry = devp;
else
c->ivhdc_last_deventry = devp;
AMD_IOMMU_ACPI_DATRSV) == 0);
return;
}
/* Type 70 and 71 */
for (i = 0; i < 4; i++) {
}
}
static void
{
ivhd_container_t *c;
*(c->ivhdc_ivhd) = *ivhdp;
acpi->acp_first_ivhdc = c;
else
acpi->acp_last_ivhdc = c;
/* 16 byte and 32 byte size are currently reserved */
switch (type_byte_size(cp)) {
case 4:
process_4byte_deventry(c, cp);
break;
case 8:
process_8byte_deventry(c, cp);
break;
case 16:
case 32:
/* Reserved */
break;
default:
"entry in ACPI IVRS table's IVHD entry",
break;
}
}
}
static void
{
ivmd_container_t *c;
*(c->ivmdc_ivmd) = *ivmdp;
acpi->acp_first_ivmdc = c;
else
acpi->acp_last_ivmdc = c;
}
int
amd_iommu_acpi_init(void)
{
return (DDI_FAILURE);
}
/*
* Reserved field must be 0
*/
AMD_IOMMU_ACPI_IVINFO_RSV1) == 0);
AMD_IOMMU_ACPI_IVINFO_RSV2) == 0);
}
}
return (DDI_FAILURE);
}
if (amd_iommu_debug & AMD_IOMMU_DEBUG_ACPI) {
debug_enter("dump");
}
return (DDI_SUCCESS);
}
static ivhd_deventry_t *
{
return (next);
}
static ivhd_container_t *
{
}
return (next);
}
static ivmd_container_t *
{
return (next);
}
void
amd_iommu_acpi_fini(void)
{
}
/*
* TODO: Do we need to free the ACPI table for om GetFirmwareTable()
*/
static void
{
}
}
}
static uint16_t
{
return (deviceid % AMD_IOMMU_ACPI_INFO_HASH_SZ);
}
static void
{
acpi_ivhdp = last;
/* TODO ASSERT data is 0 */
return;
}
#ifdef BROKEN_ASSERT
AMD_IOMMU_ACPI_IVHD_FLAGS_RSV) == 0);
#endif
/* IVHD fields */
/* IVHD IOMMU info fields */
#ifdef BROKEN_ASSERT
AMD_IOMMU_ACPI_IOMMU_INFO_RSV1) == 0);
#endif
AMD_IOMMU_ACPI_IOMMU_INFO_RSV2) == 0);
/* Initialize deviceids to -1 */
/* All range type entries are put on hash entry 0 */
case DEVENTRY_ALL:
acpi_ivhdp->ach_deviceid_start = 0;
break;
case DEVENTRY_SELECT:
break;
case DEVENTRY_RANGE:
last = acpi_ivhdp;
break;
case DEVENTRY_RANGE_END:
/*NOTREACHED*/
case DEVENTRY_ALIAS_SELECT:
break;
case DEVENTRY_ALIAS_RANGE:
last = acpi_ivhdp;
break;
case DEVENTRY_EXTENDED_SELECT:
break;
case DEVENTRY_EXTENDED_RANGE:
last = acpi_ivhdp;
break;
case DEVENTRY_SPECIAL_DEVICE:
default:
/*NOTREACHED*/
}
/* extended data */
}
/*
* Now add it to the hash
*/
}
/*
* A device entry may be declared implicitly as a source device ID
* in an alias entry. This routine adds it to the hash
*/
static void
{
ivhd_deventry_t *d;
int deviceid;
if ((d->idev_type != DEVENTRY_ALIAS_SELECT) &&
(d->idev_type != DEVENTRY_ALIAS_RANGE))
continue;
deviceid = d->idev_src_deviceid;
/* Fake a SELECT entry */
if (amd_iommu_debug & AMD_IOMMU_DEBUG_ACPI) {
"for: deviceid = %u", deviceid);
}
}
}
}
static void
{
}
}
static void
{
}
}
static void
{
case 0x20:
acpi_ivmdp->acm_deviceid_start = 0;
break;
case 0x21:
break;
case 0x22:
break;
default:
/*NOTREACHED*/
}
AMD_IOMMU_ACPI_IVMD_RSV) == 0);
}
static void
{
}
static void
{
}
}
static void
{
global->acg_VAsize =
global->acg_PAsize =
}
static int
{
/* Last hash entry is for deviceid ranges including "all" */
KM_SLEEP);
return (DDI_SUCCESS);
}
static void
{
hinfop->ach_SysMgt);
}
/* Initialize device table according to IVHD */
int
{
int i, j;
for (i = 0; i <= AMD_IOMMU_ACPI_INFO_HASH_SZ; i++) {
for (hinfop = amd_iommu_acpi_ivhd_hash[i];
continue;
switch (hinfop->ach_dev_type) {
case DEVENTRY_ALL:
for (j = 0; j < AMD_IOMMU_MAX_DEVICEID; j++)
break;
case DEVENTRY_SELECT:
case DEVENTRY_EXTENDED_SELECT:
hinfop);
break;
case DEVENTRY_RANGE:
case DEVENTRY_EXTENDED_RANGE:
for (j = hinfop->ach_deviceid_start;
j <= hinfop->ach_deviceid_end;
j++)
break;
case DEVENTRY_ALIAS_SELECT:
case DEVENTRY_ALIAS_RANGE:
case DEVENTRY_SPECIAL_DEVICE:
hinfop);
break;
default:
"%s: Unknown deventry type",
return (DDI_FAILURE);
}
}
}
return (DDI_SUCCESS);
}
{
return (amd_iommu_acpi_global);
}
{
if (hinfop->ach_deviceid_start == 0 &&
break;
}
}
return (hinfop);
}
{
if (minfop->acm_deviceid_start == 0 &&
break;
}
}
return (minfop);
}
{
int i;
for (i = AMD_IOMMU_ACPI_INFO_HASH_SZ; i >= 0; i--) {
break;
}
return (hinfop);
}
{
int i;
for (i = AMD_IOMMU_ACPI_INFO_HASH_SZ; i >= 0; i--) {
break;
}
return (minfop);
}
static void
dump_acpi_aliases(void)
{
}
}
}
{
if (amd_iommu_debug & AMD_IOMMU_DEBUG_ACPI) {
"for deviceid: %d", deviceid);
}
/* check if special device */
if (deviceid == -1) {
break;
}
}
return (hinfop);
}
/* First search for an exact match */
continue;
if (amd_iommu_debug & AMD_IOMMU_DEBUG_ACPI) {
"actual deviceid = %u, start = %u, end = %u",
}
goto out;
}
if (idx != AMD_IOMMU_ACPI_INFO_HASH_SZ) {
goto range;
}
out:
if (amd_iommu_debug & AMD_IOMMU_DEBUG_ACPI) {
}
return (hinfop);
}
{
if (amd_iommu_debug & AMD_IOMMU_DEBUG_ACPI) {
"for deviceid: %u", deviceid);
}
/* First search for an exact match */
continue;
if (amd_iommu_debug & AMD_IOMMU_DEBUG_ACPI) {
"actual deviceid = %u, start = %u, end = %u",
}
goto out;
}
if (idx != AMD_IOMMU_ACPI_INFO_HASH_SZ) {
goto range;
}
out:
if (amd_iommu_debug & AMD_IOMMU_DEBUG_ACPI) {
}
return (minfop);
}