blob: 5633dbccf4ffd19a6f477f2f1d2c597b98067df7 [file] [log] [blame]
/*
* Copyright (c) 2008, Google Inc.
* All rights reserved.
*
* Copyright (c) 2009-2012, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <debug.h>
#include <reg.h>
#include <dev/gpio.h>
#include <platform/iomap.h>
#define ACPU_CLK 0 /* Applications processor clock */
#define ADM_CLK 1 /* Applications data mover clock */
#define ADSP_CLK 2 /* ADSP clock */
#define EBI1_CLK 3 /* External bus interface 1 clock */
#define EBI2_CLK 4 /* External bus interface 2 clock */
#define ECODEC_CLK 5 /* External CODEC clock */
#define EMDH_CLK 6 /* External MDDI host clock */
#define GP_CLK 7 /* General purpose clock */
#define GRP_CLK 8 /* Graphics clock */
#define I2C_CLK 9 /* I2C clock */
#define ICODEC_RX_CLK 10 /* Internal CODEX RX clock */
#define ICODEC_TX_CLK 11 /* Internal CODEX TX clock */
#define IMEM_CLK 12 /* Internal graphics memory clock */
#define MDC_CLK 13 /* MDDI client clock */
#define MDP_CLK 14 /* Mobile display processor clock */
#define PBUS_CLK 15 /* Peripheral bus clock */
#define PCM_CLK 16 /* PCM clock */
#define PMDH_CLK 17 /* Primary MDDI host clock */
#define SDAC_CLK 18 /* Stereo DAC clock */
#define SDC1_CLK 19 /* Secure Digital Card clocks */
#define SDC1_PCLK 20
#define SDC2_CLK 21
#define SDC2_PCLK 22
#define SDC3_CLK 23
#define SDC3_PCLK 24
#define SDC4_CLK 25
#define SDC4_PCLK 26
#define TSIF_CLK 27 /* Transport Stream Interface clocks */
#define TSIF_REF_CLK 28
#define TV_DAC_CLK 29 /* TV clocks */
#define TV_ENC_CLK 30
#define UART1_CLK 31 /* UART clocks */
#define UART2_CLK 32
#define UART3_CLK 33
#define UART1DM_CLK 34
#define UART2DM_CLK 35
#define USB_HS_CLK 36 /* High speed USB core clock */
#define USB_HS_PCLK 37 /* High speed USB pbus clock */
#define USB_OTG_CLK 38 /* Full speed USB clock */
#define VDC_CLK 39 /* Video controller clock */
#define VFE_CLK 40 /* Camera / Video Front End clock */
#define VFE_MDC_CLK 41 /* VFE MDDI client clock */
/* qsd8k adds... */
#define MDP_LCDC_PCLK_CLK 42
#define MDP_LCDC_PAD_PCLK_CLK 43
#define MDP_VSYNC_CLK 44
#define P_USB_HS_CORE_CLK 53 /* High speed USB 1 core clock */
/* msm7x30 adds... */
#define PMDH_P_CLK 82
#define MDP_P_CLK 86
enum {
PCOM_CMD_IDLE = 0x0,
PCOM_CMD_DONE,
PCOM_RESET_APPS,
PCOM_RESET_CHIP,
PCOM_CONFIG_NAND_MPU,
PCOM_CONFIG_USB_CLKS,
PCOM_GET_POWER_ON_STATUS,
PCOM_GET_WAKE_UP_STATUS,
PCOM_GET_BATT_LEVEL,
PCOM_CHG_IS_CHARGING,
PCOM_POWER_DOWN,
PCOM_USB_PIN_CONFIG,
PCOM_USB_PIN_SEL,
PCOM_SET_RTC_ALARM,
PCOM_NV_READ,
PCOM_NV_WRITE,
PCOM_GET_UUID_HIGH,
PCOM_GET_UUID_LOW,
PCOM_GET_HW_ENTROPY,
PCOM_RPC_GPIO_TLMM_CONFIG_REMOTE,
PCOM_CLKCTL_RPC_ENABLE,
PCOM_CLKCTL_RPC_DISABLE,
PCOM_CLKCTL_RPC_RESET,
PCOM_CLKCTL_RPC_SET_FLAGS,
PCOM_CLKCTL_RPC_SET_RATE,
PCOM_CLKCTL_RPC_MIN_RATE,
PCOM_CLKCTL_RPC_MAX_RATE,
PCOM_CLKCTL_RPC_RATE,
PCOM_CLKCTL_RPC_PLL_REQUEST,
PCOM_CLKCTL_RPC_ENABLED,
PCOM_VREG_SWITCH,
PCOM_VREG_SET_LEVEL,
PCOM_GPIO_TLMM_CONFIG_GROUP,
PCOM_GPIO_TLMM_UNCONFIG_GROUP,
PCOM_NV_READ_HIGH_BITS,
PCOM_NV_WRITE_HIGH_BITS,
PCOM_RPC_GPIO_TLMM_CONFIG_EX = 0x25,
PCOM_NUM_CMDS,
PCOM_KERNEL_SEC_BOOT = 0x7A,
};
enum {
PCOM_INVALID_STATUS = 0x0,
PCOM_READY,
PCOM_CMD_RUNNING,
PCOM_CMD_SUCCESS,
PCOM_CMD_FAIL,
};
#ifndef PLATFORM_MSM7X30
#define MSM_A2M_INT(n) (MSM_CSR_BASE + 0x400 + (n) * 4)
#endif
static inline void notify_other_proc_comm(void)
{
#ifndef PLATFORM_MSM7X30
writel(1, MSM_A2M_INT(6));
#else
writel(1 << 6, (MSM_GCC_BASE + 0x8));
#endif
}
#define APP_COMMAND (MSM_SHARED_BASE + 0x00)
#define APP_STATUS (MSM_SHARED_BASE + 0x04)
#define APP_DATA1 (MSM_SHARED_BASE + 0x08)
#define APP_DATA2 (MSM_SHARED_BASE + 0x0C)
#define MDM_COMMAND (MSM_SHARED_BASE + 0x10)
#define MDM_STATUS (MSM_SHARED_BASE + 0x14)
#define MDM_DATA1 (MSM_SHARED_BASE + 0x18)
#define MDM_DATA2 (MSM_SHARED_BASE + 0x1C)
int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2)
{
int ret = -1;
unsigned status;
// dprintf(INFO, "proc_comm(%d,%d,%d)\n",
// cmd, data1 ? *data1 : 0, data2 ? *data2 : 0);
while (readl(MDM_STATUS) != PCOM_READY) {
/* XXX check for A9 reset */
}
if (data1)
writel(*data1, APP_DATA1);
if (data2)
writel(*data2, APP_DATA2);
/*
* As per the specs write data, cmd, interrupt for
* proc comm processing
*/
writel(cmd, APP_COMMAND);
// dprintf(INFO, "proc_comm tx\n");
notify_other_proc_comm();
while (readl(APP_COMMAND) != PCOM_CMD_DONE) {
/* XXX check for A9 reset */
}
status = readl(APP_STATUS);
// dprintf(INFO, "proc_comm status %d\n", status);
if (status != PCOM_CMD_FAIL) {
if (data1)
*data1 = readl(APP_DATA1);
if (data2)
*data2 = readl(APP_DATA2);
ret = 0;
/*
* Write command idle to indicate non HLOS that
* apps has finished reading the status & data
* of proc comm command
*/
writel(PCOM_CMD_IDLE, APP_COMMAND);
}
return ret;
}
static int clock_enable(unsigned id)
{
return msm_proc_comm(PCOM_CLKCTL_RPC_ENABLE, &id, 0);
}
static int clock_disable(unsigned id)
{
return msm_proc_comm(PCOM_CLKCTL_RPC_DISABLE, &id, 0);
}
static int clock_set_rate(unsigned id, unsigned rate)
{
return msm_proc_comm(PCOM_CLKCTL_RPC_SET_RATE, &id, &rate);
}
static int clock_get_rate(unsigned id)
{
if (msm_proc_comm(PCOM_CLKCTL_RPC_RATE, &id, 0)) {
return -1;
} else {
return (int)id;
}
}
void usb_clock_init()
{
clock_enable(USB_HS_PCLK);
clock_enable(USB_HS_CLK);
clock_enable(P_USB_HS_CORE_CLK);
}
void lcdc_clock_init(unsigned rate)
{
clock_set_rate(MDP_LCDC_PCLK_CLK, rate);
clock_enable(MDP_LCDC_PCLK_CLK);
clock_enable(MDP_LCDC_PAD_PCLK_CLK);
}
void mdp_clock_init(unsigned rate)
{
clock_set_rate(MDP_CLK, rate);
clock_enable(MDP_CLK);
}
void mdp_clock_disable(void)
{
if(!target_cont_splash_screen())
clock_disable(MDP_CLK);
}
void lcdc_clock_disable(void)
{
clock_disable(MDP_LCDC_PAD_PCLK_CLK);
clock_disable(MDP_LCDC_PCLK_CLK);
}
void uart3_clock_init(void)
{
clock_enable(UART3_CLK);
clock_set_rate(UART3_CLK, 19200000 / 4);
}
void uart2_clock_init(void)
{
clock_enable(UART2_CLK);
clock_set_rate(UART2_CLK, 19200000);
}
void uart1_clock_init(void)
{
clock_enable(UART1_CLK);
clock_set_rate(UART1_CLK, 19200000 / 4);
}
void mddi_clock_init(unsigned num, unsigned rate)
{
unsigned clock_id;
if (num == 0)
clock_id = PMDH_CLK;
else
clock_id = EMDH_CLK;
clock_enable(clock_id);
clock_set_rate(clock_id, rate);
#ifdef PLATFORM_MSM7X30
clock_enable(PMDH_P_CLK);
#endif
}
void reboot(unsigned reboot_reason)
{
msm_proc_comm(PCOM_RESET_CHIP, &reboot_reason, 0);
for (;;) ;
}
int mmc_clock_enable_disable(unsigned id, unsigned enable)
{
if (enable) {
return clock_enable(id); //Enable mmc clock rate
} else {
return clock_disable(id); //Disable mmc clock rate
}
}
int mmc_clock_set_rate(unsigned id, unsigned rate)
{
return clock_set_rate(id, rate); //Set mmc clock rate
}
int mmc_clock_get_rate(unsigned id)
{
return clock_get_rate(id); //Get mmc clock rate
}
int gpio_tlmm_config(unsigned config, unsigned disable)
{
return msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, &disable);
}
int vreg_set_level(unsigned id, unsigned mv)
{
return msm_proc_comm(PCOM_VREG_SET_LEVEL, &id, &mv);
}
int vreg_enable(unsigned id)
{
int enable = 1;
return msm_proc_comm(PCOM_VREG_SWITCH, &id, &enable);
}
int vreg_disable(unsigned id)
{
int enable = 0;
return msm_proc_comm(PCOM_VREG_SWITCH, &id, &enable);
}
void set_tamper_flag(int tamper)
{
return msm_proc_comm(PCOM_KERNEL_SEC_BOOT, &tamper, 0);
}