/*

 * 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

 * or http://www.opensolaris.org/os/licensing.

 * 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

 */

/*

 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.

 */

#include <sys/cpu_acpi.h>

#include <sys/cpu_idle.h>

#include <sys/dtrace.h>

#include <sys/sdt.h>

/*

 * List of the processor ACPI object types that are being used.

 */

typedef enum cpu_acpi_obj {

	PDC_OBJ = 0,

	PCT_OBJ,

	PSS_OBJ,

	PSD_OBJ,

	PPC_OBJ,

	PTC_OBJ,

	TSS_OBJ,

	TSD_OBJ,

	TPC_OBJ,

	CST_OBJ,

	CSD_OBJ,

} cpu_acpi_obj_t;

/*

 * Container to store object name.

 * Other attributes can be added in the future as necessary.

 */

typedef struct cpu_acpi_obj_attr {

	char *name;

} cpu_acpi_obj_attr_t;

/*

 * List of object attributes.

 * NOTE: Please keep the ordering of the list as same as cpu_acpi_obj_t.

 */

static cpu_acpi_obj_attr_t cpu_acpi_obj_attrs[] = {

	{"_PDC"},

	{"_PCT"},

	{"_PSS"},

	{"_PSD"},

	{"_PPC"},

	{"_PTC"},

	{"_TSS"},

	{"_TSD"},

	{"_TPC"},

	{"_CST"},

	{"_CSD"}

};

/*

 * Cache the ACPI CPU control data objects.

 */

static int

cpu_acpi_cache_ctrl_regs(cpu_acpi_handle_t handle, cpu_acpi_obj_t objtype,

    cpu_acpi_ctrl_regs_t *regs)

{

	ACPI_STATUS astatus;

	ACPI_BUFFER abuf;

	ACPI_OBJECT *obj;

	AML_RESOURCE_GENERIC_REGISTER *greg;

	int ret = -1;

	int i;

	/*

	 * Fetch the control registers (if present) for the CPU node.

	 * Since they are optional, non-existence is not a failure

	 * (we just consider it a fixed hardware case).

	 */

	abuf.Length = ACPI_ALLOCATE_BUFFER;

	abuf.Pointer = NULL;

	astatus = AcpiEvaluateObjectTyped(handle->cs_handle,

	    cpu_acpi_obj_attrs[objtype].name, NULL, &abuf, ACPI_TYPE_PACKAGE);

	if (ACPI_FAILURE(astatus)) {

		if (astatus == AE_NOT_FOUND) {

			DTRACE_PROBE3(cpu_acpi__eval__err, int, handle->cs_id,

			    int, objtype, int, astatus);

			regs[0].cr_addrspace_id = ACPI_ADR_SPACE_FIXED_HARDWARE;

			regs[1].cr_addrspace_id = ACPI_ADR_SPACE_FIXED_HARDWARE;

			return (1);

		}

		cmn_err(CE_NOTE, "!cpu_acpi: error %d evaluating %s package "

		    "for CPU %d.", astatus, cpu_acpi_obj_attrs[objtype].name,

		    handle->cs_id);

		goto out;

	}

	obj = abuf.Pointer;

	if (obj->Package.Count != 2) {

		cmn_err(CE_NOTE, "!cpu_acpi: %s package bad count %d for "

		    "CPU %d.", cpu_acpi_obj_attrs[objtype].name,

		    obj->Package.Count, handle->cs_id);

		goto out;

	}

	/*

	 * Does the package look coherent?

	 */

	for (i = 0; i < obj->Package.Count; i++) {

		if (obj->Package.Elements[i].Type != ACPI_TYPE_BUFFER) {

			cmn_err(CE_NOTE, "!cpu_acpi: Unexpected data in "

			    "%s package for CPU %d.",

			    cpu_acpi_obj_attrs[objtype].name,

			    handle->cs_id);

			goto out;

		}

		greg = (AML_RESOURCE_GENERIC_REGISTER *)

		    obj->Package.Elements[i].Buffer.Pointer;

		if (greg->DescriptorType !=

		    ACPI_RESOURCE_NAME_GENERIC_REGISTER) {

			cmn_err(CE_NOTE, "!cpu_acpi: %s package has format "

			    "error for CPU %d.",

			    cpu_acpi_obj_attrs[objtype].name,

			    handle->cs_id);

			goto out;

		}

		if (greg->ResourceLength !=

		    ACPI_AML_SIZE_LARGE(AML_RESOURCE_GENERIC_REGISTER)) {

			cmn_err(CE_NOTE, "!cpu_acpi: %s package not right "

			    "size for CPU %d.",

			    cpu_acpi_obj_attrs[objtype].name,

			    handle->cs_id);

			goto out;

		}

		if (greg->AddressSpaceId != ACPI_ADR_SPACE_FIXED_HARDWARE &&

		    greg->AddressSpaceId != ACPI_ADR_SPACE_SYSTEM_IO) {

			cmn_err(CE_NOTE, "!cpu_apci: %s contains unsupported "

			    "address space type %x for CPU %d.",

			    cpu_acpi_obj_attrs[objtype].name,

			    greg->AddressSpaceId,

			    handle->cs_id);

			goto out;

		}

	}

	/*

	 * Looks good!

	 */

	for (i = 0; i < obj->Package.Count; i++) {

		greg = (AML_RESOURCE_GENERIC_REGISTER *)

		    obj->Package.Elements[i].Buffer.Pointer;

		regs[i].cr_addrspace_id = greg->AddressSpaceId;

		regs[i].cr_width = greg->BitWidth;

		regs[i].cr_offset = greg->BitOffset;

		regs[i].cr_asize = greg->AccessSize;

		regs[i].cr_address = greg->Address;

	}

	ret = 0;

out:

	if (abuf.Pointer != NULL)

		AcpiOsFree(abuf.Pointer);

	return (ret);

}

/*

 * Cache the ACPI _PCT data. The _PCT data defines the interface to use

 * when making power level transitions (i.e., system IO ports, fixed

 * hardware port, etc).

 */

static int

cpu_acpi_cache_pct(cpu_acpi_handle_t handle)

{

	cpu_acpi_pct_t *pct;

	int ret;

	CPU_ACPI_OBJ_IS_NOT_CACHED(handle, CPU_ACPI_PCT_CACHED);

	pct = &CPU_ACPI_PCT(handle)[0];

	if ((ret = cpu_acpi_cache_ctrl_regs(handle, PCT_OBJ, pct)) == 0)

		CPU_ACPI_OBJ_IS_CACHED(handle, CPU_ACPI_PCT_CACHED);

	return (ret);

}

/*

 * Cache the ACPI _PTC data. The _PTC data defines the interface to use

 * when making T-state transitions (i.e., system IO ports, fixed

 * hardware port, etc).

 */

static int

cpu_acpi_cache_ptc(cpu_acpi_handle_t handle)

{

	cpu_acpi_ptc_t *ptc;

	int ret;

	CPU_ACPI_OBJ_IS_NOT_CACHED(handle, CPU_ACPI_PTC_CACHED);

	ptc = &CPU_ACPI_PTC(handle)[0];

	if ((ret = cpu_acpi_cache_ctrl_regs(handle, PTC_OBJ, ptc)) == 0)

		CPU_ACPI_OBJ_IS_CACHED(handle, CPU_ACPI_PTC_CACHED);

	return (ret);

}

/*

 * Cache the ACPI CPU state dependency data objects.

 */

static int

cpu_acpi_cache_state_dependencies(cpu_acpi_handle_t handle,

    cpu_acpi_obj_t objtype, cpu_acpi_state_dependency_t *sd)

{

	ACPI_STATUS astatus;

	ACPI_BUFFER abuf;

	ACPI_OBJECT *pkg, *elements;

	int number;

	int ret = -1;

	if (objtype == CSD_OBJ) {

		number = 6;

	} else {

		number = 5;

	}

	/*

	 * Fetch the dependencies (if present) for the CPU node.

	 * Since they are optional, non-existence is not a failure

	 * (it's up to the caller to determine how to handle non-existence).

	 */

	abuf.Length = ACPI_ALLOCATE_BUFFER;

	abuf.Pointer = NULL;

	astatus = AcpiEvaluateObjectTyped(handle->cs_handle,

	    cpu_acpi_obj_attrs[objtype].name, NULL, &abuf, ACPI_TYPE_PACKAGE);

	if (ACPI_FAILURE(astatus)) {

		if (astatus == AE_NOT_FOUND) {

			DTRACE_PROBE3(cpu_acpi__eval__err, int, handle->cs_id,

			    int, objtype, int, astatus);

			return (1);

		}

		cmn_err(CE_NOTE, "!cpu_acpi: error %d evaluating %s package "

		    "for CPU %d.", astatus, cpu_acpi_obj_attrs[objtype].name,

		    handle->cs_id);

		goto out;

	}

	pkg = abuf.Pointer;

	if (((objtype != CSD_OBJ) && (pkg->Package.Count != 1)) ||

	    ((objtype == CSD_OBJ) && (pkg->Package.Count != 1) &&

	    (pkg->Package.Count != 2))) {

		cmn_err(CE_NOTE, "!cpu_acpi: %s unsupported package count %d "

		    "for CPU %d.", cpu_acpi_obj_attrs[objtype].name,

		    pkg->Package.Count, handle->cs_id);

		goto out;

	}

	/*

	 * For C-state domain, we assume C2 and C3 have the same

	 * domain information

	 */

	if (pkg->Package.Elements[0].Type != ACPI_TYPE_PACKAGE ||

	    pkg->Package.Elements[0].Package.Count != number) {

		cmn_err(CE_NOTE, "!cpu_acpi: Unexpected data in %s package "

		    "for CPU %d.", cpu_acpi_obj_attrs[objtype].name,

		    handle->cs_id);

		goto out;

	}

	elements = pkg->Package.Elements[0].Package.Elements;

	if (elements[0].Integer.Value != number ||

	    elements[1].Integer.Value != 0) {

		cmn_err(CE_NOTE, "!cpu_acpi: Unexpected %s revision for "

		    "CPU %d.", cpu_acpi_obj_attrs[objtype].name,

		    handle->cs_id);

		goto out;

	}

	sd->sd_entries = elements[0].Integer.Value;

	sd->sd_revision = elements[1].Integer.Value;

	sd->sd_domain = elements[2].Integer.Value;

	sd->sd_type = elements[3].Integer.Value;

	sd->sd_num = elements[4].Integer.Value;

	if (objtype == CSD_OBJ) {

		sd->sd_index = elements[5].Integer.Value;

	}

	ret = 0;

out:

	if (abuf.Pointer != NULL)

		AcpiOsFree(abuf.Pointer);

	return (ret);

}

/*

 * Cache the ACPI _PSD data. The _PSD data defines P-state CPU dependencies

 * (think CPU domains).

 */

static int

cpu_acpi_cache_psd(cpu_acpi_handle_t handle)

{

	cpu_acpi_psd_t *psd;

	int ret;

	CPU_ACPI_OBJ_IS_NOT_CACHED(handle, CPU_ACPI_PSD_CACHED);

	psd = &CPU_ACPI_PSD(handle);

	ret = cpu_acpi_cache_state_dependencies(handle, PSD_OBJ, psd);

	if (ret == 0)

		CPU_ACPI_OBJ_IS_CACHED(handle, CPU_ACPI_PSD_CACHED);

	return (ret);

}

/*

 * Cache the ACPI _TSD data. The _TSD data defines T-state CPU dependencies

 * (think CPU domains).

 */

static int

cpu_acpi_cache_tsd(cpu_acpi_handle_t handle)

{

	cpu_acpi_tsd_t *tsd;

	int ret;

	CPU_ACPI_OBJ_IS_NOT_CACHED(handle, CPU_ACPI_TSD_CACHED);

	tsd = &CPU_ACPI_TSD(handle);

	ret = cpu_acpi_cache_state_dependencies(handle, TSD_OBJ, tsd);

	if (ret == 0)

		CPU_ACPI_OBJ_IS_CACHED(handle, CPU_ACPI_TSD_CACHED);

	return (ret);

}

/*

 * Cache the ACPI _CSD data. The _CSD data defines C-state CPU dependencies

 * (think CPU domains).

 */

static int

cpu_acpi_cache_csd(cpu_acpi_handle_t handle)

{

	cpu_acpi_csd_t *csd;

	int ret;

	CPU_ACPI_OBJ_IS_NOT_CACHED(handle, CPU_ACPI_CSD_CACHED);

	csd = &CPU_ACPI_CSD(handle);

	ret = cpu_acpi_cache_state_dependencies(handle, CSD_OBJ, csd);

	if (ret == 0)

		CPU_ACPI_OBJ_IS_CACHED(handle, CPU_ACPI_CSD_CACHED);

	return (ret);

}

static void

cpu_acpi_cache_pstate(cpu_acpi_handle_t handle, ACPI_OBJECT *obj, int cnt)

{

	cpu_acpi_pstate_t *pstate;

	ACPI_OBJECT *q, *l;

	int i, j;

	CPU_ACPI_PSTATES_COUNT(handle) = cnt;

	CPU_ACPI_PSTATES(handle) = kmem_zalloc(CPU_ACPI_PSTATES_SIZE(cnt),

	    KM_SLEEP);

	pstate = (cpu_acpi_pstate_t *)CPU_ACPI_PSTATES(handle);

	for (i = 0, l = NULL; i < obj->Package.Count && cnt > 0; i++, l = q) {

		uint32_t *up;

		q = obj->Package.Elements[i].Package.Elements;

		/*

		 * Skip duplicate entries.

		 */

		if (l != NULL && l[0].Integer.Value == q[0].Integer.Value)

			continue;

		up = (uint32_t *)pstate;

		for (j = 0; j < CPU_ACPI_PSS_CNT; j++)

			up[j] = q[j].Integer.Value;

		pstate++;

		cnt--;

	}

}

static void

cpu_acpi_cache_tstate(cpu_acpi_handle_t handle, ACPI_OBJECT *obj, int cnt)

{

	cpu_acpi_tstate_t *tstate;

	ACPI_OBJECT *q, *l;

	int i, j;

	CPU_ACPI_TSTATES_COUNT(handle) = cnt;

	CPU_ACPI_TSTATES(handle) = kmem_zalloc(CPU_ACPI_TSTATES_SIZE(cnt),

	    KM_SLEEP);

	tstate = (cpu_acpi_tstate_t *)CPU_ACPI_TSTATES(handle);

	for (i = 0, l = NULL; i < obj->Package.Count && cnt > 0; i++, l = q) {

		uint32_t *up;

		q = obj->Package.Elements[i].Package.Elements;

		/*

		 * Skip duplicate entries.

		 */

		if (l != NULL && l[0].Integer.Value == q[0].Integer.Value)

			continue;

		up = (uint32_t *)tstate;

		for (j = 0; j < CPU_ACPI_TSS_CNT; j++)

			up[j] = q[j].Integer.Value;

		tstate++;

		cnt--;

	}

}

/*

 * Cache the _PSS or _TSS data.

 */

static int

cpu_acpi_cache_supported_states(cpu_acpi_handle_t handle,

    cpu_acpi_obj_t objtype, int fcnt)

{

	ACPI_STATUS astatus;

	ACPI_BUFFER abuf;

	ACPI_OBJECT *obj, *q, *l;

	boolean_t eot = B_FALSE;

	int ret = -1;

	int cnt;

	int i, j;

	/*

	 * Fetch the state data (if present) for the CPU node.

	 */

	abuf.Length = ACPI_ALLOCATE_BUFFER;

	abuf.Pointer = NULL;

	astatus = AcpiEvaluateObjectTyped(handle->cs_handle,

	    cpu_acpi_obj_attrs[objtype].name, NULL, &abuf,

	    ACPI_TYPE_PACKAGE);

	if (ACPI_FAILURE(astatus)) {

		if (astatus == AE_NOT_FOUND) {

			DTRACE_PROBE3(cpu_acpi__eval__err, int, handle->cs_id,

			    int, objtype, int, astatus);

			return (1);

		}

		cmn_err(CE_NOTE, "!cpu_acpi: error %d evaluating %s package "

		    "for CPU %d.", astatus, cpu_acpi_obj_attrs[objtype].name,

		    handle->cs_id);

		goto out;

	}

	obj = abuf.Pointer;

	if (obj->Package.Count < 2) {

		cmn_err(CE_NOTE, "!cpu_acpi: %s package bad count %d for "

		    "CPU %d.", cpu_acpi_obj_attrs[objtype].name,

		    obj->Package.Count, handle->cs_id);

		goto out;

	}

	/*

	 * Does the package look coherent?

	 */

	cnt = 0;

	for (i = 0, l = NULL; i < obj->Package.Count; i++, l = q) {

		if (obj->Package.Elements[i].Type != ACPI_TYPE_PACKAGE ||

		    obj->Package.Elements[i].Package.Count != fcnt) {

			cmn_err(CE_NOTE, "!cpu_acpi: Unexpected data in "

			    "%s package for CPU %d.",

			    cpu_acpi_obj_attrs[objtype].name,

			    handle->cs_id);

			goto out;

		}

		q = obj->Package.Elements[i].Package.Elements;

		for (j = 0; j < fcnt; j++) {

			if (q[j].Type != ACPI_TYPE_INTEGER) {

				cmn_err(CE_NOTE, "!cpu_acpi: %s element "

				    "invalid (type) for CPU %d.",

				    cpu_acpi_obj_attrs[objtype].name,

				    handle->cs_id);

				goto out;

			}

		}

		/*

		 * Ignore duplicate entries.

		 */

		if (l != NULL && l[0].Integer.Value == q[0].Integer.Value)

			continue;

		/*

		 * Some supported state tables are larger than required

		 * and unused elements are filled with patterns

		 * of 0xff.  Simply check here for frequency = 0xffff

		 * and stop counting if found.

		 */

		if (q[0].Integer.Value == 0xffff) {