/*
 * This file is part of the coreboot project.
 *
 * Copyright (C) 2011 Advanced Micro Devices, Inc.
 * Copyright (C) 2013 Sage Electronic Engineering, LLC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

External(\_SB.ALIB, MethodObj)

/* System Bus */
/*  _SB.PCI0 */

/* Operating System Capabilities Method */
Method(_OSC,4)
{
	/* Check for proper PCI/PCIe UUID */
	If(LEqual(Arg0,ToUUID("33DB4D5B-1FF7-401C-9657-7441C03DD766")))
	{
		/* Let OS control everything */
		Return (Arg3)
	} Else {
		CreateDWordField(Arg3,0,CDW1)
		Or(CDW1,4,CDW1)	// Unrecognized UUID
		Return(Arg3)
	}
}

/* Describe the Southbridge devices */

/* 0:11.0 - SATA */
Device(STCR) {
	Name(_ADR, 0x00110000)
} /* end STCR */

/* 0:14.0 - SMBUS */
Device(SBUS) {
	Name(_ADR, 0x00140000)
} /* end SBUS */

#include "usb.asl"

/* 0:14.2 - I2S Audio */

/* 0:14.3 - LPC */
#include <soc/amd/common/acpi/lpc.asl>

Name(CRES, ResourceTemplate() {
	/* Set the Bus number and Secondary Bus number for the PCI0 device
	 * The Secondary bus range for PCI0 lets the system
	 * know what bus values are allowed on the downstream
	 * side of this PCI bus if there is a PCI-PCI bridge.
	 * PCI busses can have 256 secondary busses which
	 * range from [0-0xFF] but they do not need to be
	 * sequential.
	 */
	WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
		0x0000,		/* address granularity */
		0x0000,		/* range minimum */
		0x00ff,		/* range maximum */
		0x0000,		/* translation */
		0x0100,		/* length */
		,, PSB0)		/* ResourceSourceIndex, ResourceSource, DescriptorName */

	IO(Decode16, 0x0cf8, 0x0cf8, 1,	8)

	WORDIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
		0x0000,		/* address granularity */
		0x0000,		/* range minimum */
		0x0cf7,		/* range maximum */
		0x0000,		/* translation */
		0x0cf8		/* length */
	)
	WORDIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
		0x0000,		/* address granularity */
		0x03b0,		/* range minimum */
		0x03df,		/* range maximum */
		0x0000,		/* translation */
		0x0030		/* length */
	)

	WORDIO(ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
		0x0000,		/* address granularity */
		0x0d00,		/* range minimum */
		0xffff,		/* range maximum */
		0x0000,		/* translation */
		0xf300		/* length */
	)

	Memory32Fixed(READONLY, 0x000a0000, 0x00020000, VGAM)	/* VGA memory space */
	Memory32Fixed(READONLY, 0x000c0000, 0x00020000, EMM1)	/* Assume C0000-E0000 empty */

	/* memory space for PCI BARs below 4GB */
	Memory32Fixed(ReadOnly, 0x00000000, 0x00000000, MMIO)
}) /* End Name(_SB.PCI0.CRES) */

Method(_CRS, 0) {
	/* DBGO("\\_SB\\PCI0\\_CRS\n") */
	CreateDWordField(CRES, ^MMIO._BAS, MM1B)
	CreateDWordField(CRES, ^MMIO._LEN, MM1L)

	/*
	 * Declare memory between TOM1 and 4GB as available
	 * for PCI MMIO.
	 * Use ShiftLeft to avoid 64bit constant (for XP).
	 * This will work even if the OS does 32bit arithmetic, as
	 * 32bit (0x00000000 - TOM1) will wrap and give the same
	 * result as 64bit (0x100000000 - TOM1).
	 */
	Store(TOM1, MM1B)
	ShiftLeft(0x10000000, 4, Local0)
	Subtract(Local0, TOM1, Local0)
	Store(Local0, MM1L)

	Return(CRES) /* note to change the Name buffer */
} /* end of Method(_SB.PCI0._CRS) */

/*
 *
 *               FIRST METHOD CALLED UPON BOOT
 *
 *  1. If debugging, print current OS and ACPI interpreter.
 *  2. Get PCI Interrupt routing from ACPI VSM, this
 *     value is based on user choice in BIOS setup.
 */
Method(_INI, 0, Serialized) {
	/* DBGO("\\_SB\\_INI\n") */
	/* DBGO("   DSDT.ASL code from ") */
	/* DBGO(__DATE__) */
	/* DBGO(" ") */
	/* DBGO(__TIME__) */
	/* DBGO("\n   Sleep states supported: ") */
	/* DBGO("\n") */
	/* DBGO("   \\_OS=") */
	/* DBGO(\_OS) */
	/* DBGO("\n   \\_REV=") */
	/* DBGO(\_REV) */
	/* DBGO("\n") */

	/* Determine the OS we're running on */
	OSFL()

	/* Send ALIB Function 1 the AC/DC state */
	Name(F1BF, Buffer(0x03){})
	CreateWordField(F1BF, 0, F1SZ)
	CreateByteField(F1BF, 2, F1DA)

	Store(3, F1SZ)
	Store(\PWRS, F1DA)

	\_SB.ALIB(1, F1BF)

} /* End Method(_SB._INI) */

Method(OSFL, 0){

	if (LNotEqual(OSVR, Ones)) {Return(OSVR)}	/* OS version was already detected */

	if (CondRefOf(\_OSI))
	{
		Store(1, OSVR)					/* Assume some form of XP */
		if (\_OSI("Windows 2006"))		/* Vista */
		{
			Store(2, OSVR)
		}
	} else {
		If(WCMP(\_OS,"Linux")) {
			Store(3, OSVR)				/* Linux */
		} Else {
			Store(4, OSVR)				/* Gotta be WinCE */
		}
	}
	Return(OSVR)
}

OperationRegion(SMIC, SystemMemory, 0xfed80000, 0x80000)
Field( SMIC, ByteAcc, NoLock, Preserve) {
	/* MISC registers */
	offset (0x03ee),
	U3PS, 2,  /* Usb3PowerSel */

	offset (0x0e28),
	,29 ,
	SARP, 1,  /* Sata Ref Clock Powerdown */
	U2RP, 1,  /* Usb2 Ref Clock Powerdown */
	U3RP, 1,  /* Usb3 Ref Clock Powerdown */

	/* AOAC Registers */
	offset (0x1e4a), /* I2C0 D3 Control */
	I0TD, 2,
	, 1,
	I0PD, 1,
	offset (0x1e4b), /* I2C0 D3 State */
	I0DS, 3,

	offset (0x1e4c), /* I2C1 D3 Control */
	I1TD, 2,
	, 1,
	I1PD, 1,
	offset (0x1e4d), /* I2C1 D3 State */
	I1DS, 3,

	offset (0x1e4e), /* I2C2 D3 Control */
	I2TD, 2,
	, 1,
	I2PD, 1,
	offset (0x1e4f), /* I2C2 D3 State */
	I2DS, 3,

	offset (0x1e50), /* I2C3 D3 Control */
	I3TD, 2,
	, 1,
	I3PD, 1,
	offset (0x1e51), /* I2C3 D3 State */
	I3DS, 3,

	offset (0x1e56), /* UART0 D3 Control */
	U0TD, 2,
	, 1,
	U0PD, 1,
	offset (0x1e57), /* UART0 D3 State */
	U0DS, 3,

	offset (0x1e58), /* UART1 D3 Control */
	U1TD, 2,
	, 1,
	U1PD, 1,
	offset (0x1e59), /* UART1 D3 State */
	U1DS, 3,

	offset (0x1e60), /* UART2 D3 Control */
	U2TD, 2,
	, 1,
	U2PD, 1,
	offset (0x1e61), /* UART2 D3 State */
	U2DS, 3,

	offset (0x1e71), /* SD D3 State */
	SDDS, 3,

	offset (0x1e74), /* UART3 D3 Control */
	U3TD, 2,
	, 1,
	U3PD, 1,
	offset (0x1e75), /* UART3 D3 State */
	U3DS, 3,

	offset (0x1e80), /* Shadow Register Request */
	, 15,
	RQ15, 1,
	, 2,
	RQ18, 1,
	, 4,
	RQ23, 1,
	RQ24, 1,
	, 5,
	RQTY, 1,
	offset (0x1e84), /* Shadow Register Status */
	, 15,
	SASR, 1,  /* SATA 15 Shadow Reg Request Status Register */
	, 2,
	U2SR, 1,  /* USB2 18 Shadow Reg Request Status Register */
	, 4,
	U3SR, 1,  /* USB3 23 Shadow Reg Request Status Register */
	SDSR, 1,  /* SD 24 Shadow Reg Request Status Register */

	offset (0x1ea0), /* PwrGood Control */
	PG1A, 1,
	PG2_, 1,
	,1,
	U3PG, 1,  /* Usb3 Power Good BIT3 */

	offset (0x1ea3), /* PwrGood Control b[31:24] */
	PGA3, 8 ,
}

OperationRegion(FCFG, SystemMemory, PCBA, 0x01000000)
Field(FCFG, DwordAcc, NoLock, Preserve)
{
	/* XHCI */
	Offset(0x00080010), /* Base address */
	XHBA, 32,
	Offset(0x0008002c), /* Subsystem ID / Vendor ID */
	XH2C, 32,

	Offset(0x00080048), /* Indirect PCI Index Register */
	IDEX, 32,
	DATA, 32,
	Offset(0x00080054), /* PME Control / Status */
	U_PS, 2,

	/* EHCI */
	Offset(0x00090004), /* Control */
	, 1,
	EHME, 1,
	Offset(0x00090010), /* Base address */
	EHBA, 32,
	Offset(0x0009002c), /* Subsystem ID / Vendor ID */
	EH2C, 32,
	Offset(0x00090054), /* EHCI Spare 1 */
	EH54, 8,
	Offset(0x00090064), /* Misc Control 2 */
	EH64, 8,

	Offset(0x000900c4), /* PME Control / Status */
	E_PS, 2,

	/* LPC Bridge */
	Offset(0x000a30cb), /* ClientRomProtect[31:24] */
	,  7,
	AUSS,  1, /* AutoSizeStart */
}

/*
 * Arg0:device:
 *  5=I2C0, 6=I2C1, 7=I2C2, 8=I2C3, 11=UART0, 12=UART1,
 *  18=EHCI, 23=xHCI, 24=SD
 * Arg1:D-state
 */
Mutex (FDAS, 0) /* FCH Device AOAC Semophore */
Method(FDDC, 2, Serialized)
{
	Acquire(FDAS, 0xffff)

	if(LEqual(Arg1, 0)) {
		Switch(ToInteger(Arg0)) {
			Case(Package() {5, 15, 24}) {
				Store(One, PG1A)
			}
			Case(Package() {6, 7, 8, 11, 12, 18}) {
				Store(One, PG2_)
			}
		}
		/* put device into D0 */
		Switch(ToInteger(Arg0))
		{
			Case(5) {
				Store(0x00, I0TD)
				Store(One, I0PD)
				Store(I0DS, Local0)
				while(LNotEqual(Local0,0x7)) {
					Store(I0DS, Local0)
				}
			}
			Case(6) {
				Store(0x00, I1TD)
				Store(One, I1PD)
				Store(I1DS, Local0)
				while(LNotEqual(Local0,0x7)) {
					Store(I1DS, Local0)
				}
			}
			Case(7) {
				Store(0x00, I2TD)
				Store(One, I2PD)
				Store(I2DS, Local0)
				while(LNotEqual(Local0,0x7)) {
					Store(I2DS, Local0)
				}
			}
			Case(8) {Store(0x00, I3TD)
				Store(One, I3PD)
				Store(I3DS, Local0)
				while(LNotEqual(Local0,0x7)) {
					Store(I3DS, Local0)
				}
			}
			Case(11) {
				Store(0x00, U0TD)
				Store(One, U0PD)
				Store(U0DS, Local0)
				while(LNotEqual(Local0,0x7)) {
					Store(U0DS, Local0)
				}
			}
			Case(12) {
				Store(0x00, U1TD)
				Store(One, U1PD)
				Store(U1DS, Local0)
				while(LNotEqual(Local0,0x7)) {
					Store(U1DS, Local0)
				}
			}
			Case(16) {
				Store(0x00, U2TD)
				Store(One, U2PD)
				Store(U2DS, Local0)
				while(LNotEqual(Local0,0x7)) {
					Store(U2DS, Local0)
				}
			}
			Case(26) {
				Store(0x00, U3TD)
				Store(One, U3PD)
				Store(U3DS, Local0)
				while(LNotEqual(Local0,0x7)) {
					Store(U3DS, Local0)
				}
			}
		}
	} else {
		/* put device into D3cold */
		Switch(ToInteger(Arg0))
		{
			Case(5) {
				Store(Zero, I0PD)
				Store(I0DS, Local0)
				while(LNotEqual(Local0,0x0)) {
					Store(I0DS, Local0)
				}
				Store(0x03, I0TD)
			}
			Case(6) {
				Store(Zero, I1PD)
				Store(I1DS, Local0)
				while(LNotEqual(Local0,0x0)) {
					Store(I1DS, Local0)
				}
				Store(0x03, I1TD)
			}
			Case(7)  {
				Store(Zero, I2PD)
				Store(I2DS, Local0)
				while(LNotEqual(Local0,0x0)) {
					Store(I2DS, Local0)
				}
				Store(0x03, I2TD)}
			Case(8) {
				Store(Zero, I3PD)
				Store(I3DS, Local0)
				while(LNotEqual(Local0,0x0)) {
					Store(I3DS, Local0)
				}
				Store(0x03, I3TD)
			}
			Case(11) {
				Store(Zero, U0PD)
				Store(U0DS, Local0)
				while(LNotEqual(Local0,0x0)) {
					Store(U0DS, Local0)
				}
				Store(0x03, U0TD)
			}
			Case(12) {
				Store(Zero, U1PD)
				Store(U1DS, Local0)
				while(LNotEqual(Local0,0x0)) {
					Store(U1DS, Local0)
				}
				Store(0x03, U1TD)
			}
			Case(16) {
				Store(Zero, U2PD)
				Store(U2DS, Local0)
				while(LNotEqual(Local0,0x0)) {
					Store(U2DS, Local0)
				}
				Store(0x03, U2TD)
			}
			Case(26) {
				Store(Zero, U3PD)
				Store(U3DS, Local0)
				while(LNotEqual(Local0,0x0)) {
					Store(U3DS, Local0)
				}
				Store(0x03, U3TD)
			}
		}
		if(LEqual(I1TD, 3)) {
			if(LEqual(I2TD, 3)) {
				if(LEqual(I3TD, 3)) {
					if(LEqual(U0TD, 3)) {
						if(LEqual(U1TD, 3)) {
							Store(Zero, PG2_)
						}
					}
				}
			}
		}
	}
	Release(FDAS)
}

Method(FPTS,0, Serialized)  /* FCH _PTS */
{
}

Method(FWAK,0, Serialized)  /* FCH _WAK */
{
	if(LEqual(\UT0E, zero)) {
		if(LNotEqual(U0TD, 0x03)) {
			FDDC(11, 3)
		}
	}
	if(LEqual(\UT1E, zero)) {
		if(LNotEqual(U1TD, 0x03)) {
			FDDC(12, 3)
		}
	}
	if(LEqual(\IC2E, zero)) {
		if(LNotEqual(I2TD, 0x03)) {
			FDDC(7, 3)
		}
	}
	if(LEqual(\IC3E, zero)) {
		if(LNotEqual(I3TD, 0x03)) {
			FDDC(8, 3)
		}
	}
}

/*
 * Helper for setting a bit in AOACxA0 PwrGood Control
 * Arg0: bit to set or clear
 * Arg1: 0 = clear bit[Arg0], non-zero = set bit[Arg0]
 */
Method(PWGC,2, Serialized)
{
	And (PGA3, 0xdf, Local0)  /* do SwUsb3SlpShutdown below */
	if(Arg1) {
		Or(Arg0, Local0, Local0)
	} else {
		Not(Arg0, Local1)
		And(Local1, Local0, Local0)
	}
	Store(Local0, PGA3)
	if(LEqual(Arg0, 0x20)) { /* if SwUsb3SlpShutdown */
		Store(PGA3, Local0)
		And(Arg0, Local0, Local0)
		while(LNot(Local0)) { /* wait SwUsb3SlpShutdown to complete */
			Store(PGA3, Local0)
			And(Arg0, Local0, Local0)
		}
	}
}