Merge changes I46cd4d9b,Iba009587,I41d146e8,Ic66ceab3,Iff46838a, ... into integration
* changes: drivers: renesas: rcar: io: Code cleanup drivers: renesas: rcar: pwrc: Code cleanup drivers: renesas: rcar: common: Code cleanup drivers: renesas: rcar: watchdog: Fix typo drivers: renesas: rcar: scif: Fix coding style drivers: renesas: rcar: iic_dvfs: Fix coding style
This commit is contained in:
commit
e8a96e3e23
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2018, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2018-2020, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
@ -8,24 +8,27 @@
|
||||||
|
|
||||||
#include "rcar_private.h"
|
#include "rcar_private.h"
|
||||||
|
|
||||||
void
|
|
||||||
#if IMAGE_BL31
|
#if IMAGE_BL31
|
||||||
__attribute__ ((section(".system_ram")))
|
void __attribute__ ((section(".system_ram"))) cpg_write(uintptr_t regadr, uint32_t regval)
|
||||||
|
#else
|
||||||
|
void cpg_write(uintptr_t regadr, uint32_t regval)
|
||||||
#endif
|
#endif
|
||||||
cpg_write(uintptr_t regadr, uint32_t regval)
|
|
||||||
{
|
{
|
||||||
uint32_t value = (regval);
|
uint32_t value = regval;
|
||||||
|
|
||||||
mmio_write_32((uintptr_t) RCAR_CPGWPR, ~value);
|
mmio_write_32((uintptr_t) RCAR_CPGWPR, ~value);
|
||||||
mmio_write_32(regadr, value);
|
mmio_write_32(regadr, value);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
|
||||||
#if IMAGE_BL31
|
#if IMAGE_BL31
|
||||||
__attribute__ ((section(".system_ram")))
|
void __attribute__ ((section(".system_ram"))) mstpcr_write(uint32_t mstpcr, uint32_t mstpsr,
|
||||||
|
uint32_t target_bit)
|
||||||
|
#else
|
||||||
|
void mstpcr_write(uint32_t mstpcr, uint32_t mstpsr, uint32_t target_bit)
|
||||||
#endif
|
#endif
|
||||||
mstpcr_write(uint32_t mstpcr, uint32_t mstpsr, uint32_t target_bit)
|
|
||||||
{
|
{
|
||||||
uint32_t reg;
|
uint32_t reg;
|
||||||
|
|
||||||
reg = mmio_read_32(mstpcr);
|
reg = mmio_read_32(mstpcr);
|
||||||
reg &= ~target_bit;
|
reg &= ~target_bit;
|
||||||
cpg_write(mstpcr, reg);
|
cpg_write(mstpcr, reg);
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2015-2019, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2015-2021, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
@ -7,59 +7,59 @@
|
||||||
#include <common/debug.h>
|
#include <common/debug.h>
|
||||||
#include <lib/mmio.h>
|
#include <lib/mmio.h>
|
||||||
|
|
||||||
#include "rcar_def.h"
|
|
||||||
#include "cpg_registers.h"
|
#include "cpg_registers.h"
|
||||||
#include "iic_dvfs.h"
|
#include "iic_dvfs.h"
|
||||||
|
#include "rcar_def.h"
|
||||||
#include "rcar_private.h"
|
#include "rcar_private.h"
|
||||||
|
|
||||||
#define DVFS_RETRY_MAX (2U)
|
#define DVFS_RETRY_MAX (2U)
|
||||||
|
|
||||||
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_0 (0x07)
|
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_0 (0x07U)
|
||||||
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_1 (0x09)
|
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_1 (0x09U)
|
||||||
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_2 (0x0B)
|
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_2 (0x0BU)
|
||||||
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_3 (0x0E)
|
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_3 (0x0EU)
|
||||||
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_E (0x15)
|
#define IIC_DVFS_SET_ICCL_EXTAL_TYPE_E (0x15U)
|
||||||
|
|
||||||
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_0 (0x01)
|
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_0 (0x01U)
|
||||||
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_1 (0x02)
|
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_1 (0x02U)
|
||||||
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_2 (0x03)
|
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_2 (0x03U)
|
||||||
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_3 (0x05)
|
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_3 (0x05U)
|
||||||
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_E (0x07)
|
#define IIC_DVFS_SET_ICCH_EXTAL_TYPE_E (0x07U)
|
||||||
|
|
||||||
#define CPG_BIT_SMSTPCR9_DVFS (0x04000000)
|
#define CPG_BIT_SMSTPCR9_DVFS (0x04000000U)
|
||||||
|
|
||||||
#define IIC_DVFS_REG_BASE (0xE60B0000)
|
#define IIC_DVFS_REG_BASE (0xE60B0000U)
|
||||||
#define IIC_DVFS_REG_ICDR (IIC_DVFS_REG_BASE + 0x0000)
|
#define IIC_DVFS_REG_ICDR (IIC_DVFS_REG_BASE + 0x0000U)
|
||||||
#define IIC_DVFS_REG_ICCR (IIC_DVFS_REG_BASE + 0x0004)
|
#define IIC_DVFS_REG_ICCR (IIC_DVFS_REG_BASE + 0x0004U)
|
||||||
#define IIC_DVFS_REG_ICSR (IIC_DVFS_REG_BASE + 0x0008)
|
#define IIC_DVFS_REG_ICSR (IIC_DVFS_REG_BASE + 0x0008U)
|
||||||
#define IIC_DVFS_REG_ICIC (IIC_DVFS_REG_BASE + 0x000C)
|
#define IIC_DVFS_REG_ICIC (IIC_DVFS_REG_BASE + 0x000CU)
|
||||||
#define IIC_DVFS_REG_ICCL (IIC_DVFS_REG_BASE + 0x0010)
|
#define IIC_DVFS_REG_ICCL (IIC_DVFS_REG_BASE + 0x0010U)
|
||||||
#define IIC_DVFS_REG_ICCH (IIC_DVFS_REG_BASE + 0x0014)
|
#define IIC_DVFS_REG_ICCH (IIC_DVFS_REG_BASE + 0x0014U)
|
||||||
|
|
||||||
#define IIC_DVFS_BIT_ICSR_BUSY (0x10)
|
#define IIC_DVFS_BIT_ICSR_BUSY (0x10U)
|
||||||
#define IIC_DVFS_BIT_ICSR_AL (0x08)
|
#define IIC_DVFS_BIT_ICSR_AL (0x08U)
|
||||||
#define IIC_DVFS_BIT_ICSR_TACK (0x04)
|
#define IIC_DVFS_BIT_ICSR_TACK (0x04U)
|
||||||
#define IIC_DVFS_BIT_ICSR_WAIT (0x02)
|
#define IIC_DVFS_BIT_ICSR_WAIT (0x02U)
|
||||||
#define IIC_DVFS_BIT_ICSR_DTE (0x01)
|
#define IIC_DVFS_BIT_ICSR_DTE (0x01U)
|
||||||
|
|
||||||
#define IIC_DVFS_BIT_ICCR_ENABLE (0x80)
|
#define IIC_DVFS_BIT_ICCR_ENABLE (0x80U)
|
||||||
#define IIC_DVFS_SET_ICCR_START (0x94)
|
#define IIC_DVFS_SET_ICCR_START (0x94U)
|
||||||
#define IIC_DVFS_SET_ICCR_STOP (0x90)
|
#define IIC_DVFS_SET_ICCR_STOP (0x90U)
|
||||||
#define IIC_DVFS_SET_ICCR_RETRANSMISSION (0x94)
|
#define IIC_DVFS_SET_ICCR_RETRANSMISSION (0x94U)
|
||||||
#define IIC_DVFS_SET_ICCR_CHANGE (0x81)
|
#define IIC_DVFS_SET_ICCR_CHANGE (0x81U)
|
||||||
#define IIC_DVFS_SET_ICCR_STOP_READ (0xC0)
|
#define IIC_DVFS_SET_ICCR_STOP_READ (0xC0U)
|
||||||
|
|
||||||
#define IIC_DVFS_BIT_ICIC_TACKE (0x04)
|
#define IIC_DVFS_BIT_ICIC_TACKE (0x04U)
|
||||||
#define IIC_DVFS_BIT_ICIC_WAITE (0x02)
|
#define IIC_DVFS_BIT_ICIC_WAITE (0x02U)
|
||||||
#define IIC_DVFS_BIT_ICIC_DTEE (0x01)
|
#define IIC_DVFS_BIT_ICIC_DTEE (0x01U)
|
||||||
|
|
||||||
#define DVFS_READ_MODE (0x01)
|
#define DVFS_READ_MODE (0x01U)
|
||||||
#define DVFS_WRITE_MODE (0x00)
|
#define DVFS_WRITE_MODE (0x00U)
|
||||||
|
|
||||||
#define IIC_DVFS_SET_DUMMY (0x52)
|
#define IIC_DVFS_SET_DUMMY (0x52U)
|
||||||
#define IIC_DVFS_SET_BUSY_LOOP (500000000U)
|
#define IIC_DVFS_SET_BUSY_LOOP (500000000U)
|
||||||
|
|
||||||
typedef enum {
|
enum dvfs_state_t {
|
||||||
DVFS_START = 0,
|
DVFS_START = 0,
|
||||||
DVFS_STOP,
|
DVFS_STOP,
|
||||||
DVFS_RETRANSMIT,
|
DVFS_RETRANSMIT,
|
||||||
|
@ -69,9 +69,9 @@ typedef enum {
|
||||||
DVFS_SET_SLAVE,
|
DVFS_SET_SLAVE,
|
||||||
DVFS_WRITE_ADDR,
|
DVFS_WRITE_ADDR,
|
||||||
DVFS_WRITE_DATA,
|
DVFS_WRITE_DATA,
|
||||||
DVFS_CHANGE_SEND_TO_RECIEVE,
|
DVFS_CHANGE_SEND_TO_RECEIVE,
|
||||||
DVFS_DONE,
|
DVFS_DONE,
|
||||||
} DVFS_STATE_T;
|
};
|
||||||
|
|
||||||
#define DVFS_PROCESS (1)
|
#define DVFS_PROCESS (1)
|
||||||
#define DVFS_COMPLETE (0)
|
#define DVFS_COMPLETE (0)
|
||||||
|
@ -94,11 +94,11 @@ static int32_t dvfs_ ##__name(__VA_ARGS__)
|
||||||
int32_t rcar_iic_dvfs_ ##__name(__VA_ARGS__)
|
int32_t rcar_iic_dvfs_ ##__name(__VA_ARGS__)
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
IIC_DVFS_FUNC(check_error, DVFS_STATE_T *state, uint32_t *err, uint8_t mode)
|
IIC_DVFS_FUNC(check_error, enum dvfs_state_t *state, uint32_t *err, uint8_t mode)
|
||||||
{
|
{
|
||||||
uint8_t icsr_al = 0, icsr_tack = 0;
|
uint8_t icsr_al = 0U, icsr_tack = 0U;
|
||||||
uint8_t reg, stop;
|
uint8_t reg, stop;
|
||||||
uint32_t i = 0;
|
uint32_t i = 0U;
|
||||||
|
|
||||||
stop = mode == DVFS_READ_MODE ? IIC_DVFS_SET_ICCR_STOP_READ :
|
stop = mode == DVFS_READ_MODE ? IIC_DVFS_SET_ICCR_STOP_READ :
|
||||||
IIC_DVFS_SET_ICCR_STOP;
|
IIC_DVFS_SET_ICCR_STOP;
|
||||||
|
@ -107,43 +107,48 @@ IIC_DVFS_FUNC(check_error, DVFS_STATE_T *state, uint32_t *err, uint8_t mode)
|
||||||
icsr_al = (reg & IIC_DVFS_BIT_ICSR_AL) == IIC_DVFS_BIT_ICSR_AL;
|
icsr_al = (reg & IIC_DVFS_BIT_ICSR_AL) == IIC_DVFS_BIT_ICSR_AL;
|
||||||
icsr_tack = (reg & IIC_DVFS_BIT_ICSR_TACK) == IIC_DVFS_BIT_ICSR_TACK;
|
icsr_tack = (reg & IIC_DVFS_BIT_ICSR_TACK) == IIC_DVFS_BIT_ICSR_TACK;
|
||||||
|
|
||||||
if (icsr_al == 0 && icsr_tack == 0)
|
if (icsr_al == 0U && icsr_tack == 0U) {
|
||||||
return DVFS_PROCESS;
|
return DVFS_PROCESS;
|
||||||
|
}
|
||||||
|
|
||||||
if (icsr_al) {
|
if (icsr_al) {
|
||||||
reg = mmio_read_8(IIC_DVFS_REG_ICSR) & ~IIC_DVFS_BIT_ICSR_AL;
|
reg = mmio_read_8(IIC_DVFS_REG_ICSR) & ~IIC_DVFS_BIT_ICSR_AL;
|
||||||
mmio_write_8(IIC_DVFS_REG_ICSR, reg);
|
mmio_write_8(IIC_DVFS_REG_ICSR, reg);
|
||||||
|
|
||||||
if (*state == DVFS_SET_SLAVE)
|
if (*state == DVFS_SET_SLAVE) {
|
||||||
mmio_write_8(IIC_DVFS_REG_ICDR, IIC_DVFS_SET_DUMMY);
|
mmio_write_8(IIC_DVFS_REG_ICDR, IIC_DVFS_SET_DUMMY);
|
||||||
|
}
|
||||||
|
|
||||||
do {
|
do {
|
||||||
reg = mmio_read_8(IIC_DVFS_REG_ICSR) &
|
reg = mmio_read_8(IIC_DVFS_REG_ICSR) &
|
||||||
IIC_DVFS_BIT_ICSR_WAIT;
|
IIC_DVFS_BIT_ICSR_WAIT;
|
||||||
} while (reg == 0);
|
} while (reg == 0U);
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, stop);
|
mmio_write_8(IIC_DVFS_REG_ICCR, stop);
|
||||||
|
|
||||||
reg = mmio_read_8(IIC_DVFS_REG_ICSR) & ~IIC_DVFS_BIT_ICSR_WAIT;
|
reg = mmio_read_8(IIC_DVFS_REG_ICSR) & ~IIC_DVFS_BIT_ICSR_WAIT;
|
||||||
mmio_write_8(IIC_DVFS_REG_ICSR, reg);
|
mmio_write_8(IIC_DVFS_REG_ICSR, reg);
|
||||||
|
|
||||||
i = 0;
|
i = 0U;
|
||||||
do {
|
do {
|
||||||
reg = mmio_read_8(IIC_DVFS_REG_ICSR) &
|
reg = mmio_read_8(IIC_DVFS_REG_ICSR) &
|
||||||
IIC_DVFS_BIT_ICSR_BUSY;
|
IIC_DVFS_BIT_ICSR_BUSY;
|
||||||
if (reg == 0)
|
if (reg == 0U) {
|
||||||
break;
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
if (i++ > IIC_DVFS_SET_BUSY_LOOP)
|
if (i++ > IIC_DVFS_SET_BUSY_LOOP) {
|
||||||
panic();
|
panic();
|
||||||
|
}
|
||||||
|
|
||||||
} while (1);
|
} while (true);
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, 0x00U);
|
mmio_write_8(IIC_DVFS_REG_ICCR, 0x00U);
|
||||||
|
|
||||||
(*err)++;
|
(*err)++;
|
||||||
if (*err > DVFS_RETRY_MAX)
|
if (*err > DVFS_RETRY_MAX) {
|
||||||
return DVFS_ERROR;
|
return DVFS_ERROR;
|
||||||
|
}
|
||||||
|
|
||||||
*state = DVFS_START;
|
*state = DVFS_START;
|
||||||
|
|
||||||
|
@ -161,24 +166,26 @@ IIC_DVFS_FUNC(check_error, DVFS_STATE_T *state, uint32_t *err, uint8_t mode)
|
||||||
reg = mmio_read_8(IIC_DVFS_REG_ICSR) & ~IIC_DVFS_BIT_ICSR_TACK;
|
reg = mmio_read_8(IIC_DVFS_REG_ICSR) & ~IIC_DVFS_BIT_ICSR_TACK;
|
||||||
mmio_write_8(IIC_DVFS_REG_ICSR, reg);
|
mmio_write_8(IIC_DVFS_REG_ICSR, reg);
|
||||||
|
|
||||||
i = 0;
|
i = 0U;
|
||||||
while ((mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_BUSY) != 0) {
|
while ((mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_BUSY) != 0U) {
|
||||||
if (i++ > IIC_DVFS_SET_BUSY_LOOP)
|
if (i++ > IIC_DVFS_SET_BUSY_LOOP) {
|
||||||
panic();
|
panic();
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, 0);
|
mmio_write_8(IIC_DVFS_REG_ICCR, 0U);
|
||||||
(*err)++;
|
(*err)++;
|
||||||
|
|
||||||
if (*err > DVFS_RETRY_MAX)
|
if (*err > DVFS_RETRY_MAX) {
|
||||||
return DVFS_ERROR;
|
return DVFS_ERROR;
|
||||||
|
}
|
||||||
|
|
||||||
*state = DVFS_START;
|
*state = DVFS_START;
|
||||||
|
|
||||||
return DVFS_PROCESS;
|
return DVFS_PROCESS;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(start, DVFS_STATE_T * state)
|
IIC_DVFS_FUNC(start, enum dvfs_state_t *state)
|
||||||
{
|
{
|
||||||
uint8_t iccl = IIC_DVFS_SET_ICCL_EXTAL_TYPE_E;
|
uint8_t iccl = IIC_DVFS_SET_ICCL_EXTAL_TYPE_E;
|
||||||
uint8_t icch = IIC_DVFS_SET_ICCH_EXTAL_TYPE_E;
|
uint8_t icch = IIC_DVFS_SET_ICCH_EXTAL_TYPE_E;
|
||||||
|
@ -190,8 +197,9 @@ IIC_DVFS_FUNC(start, DVFS_STATE_T * state)
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, mode);
|
mmio_write_8(IIC_DVFS_REG_ICCR, mode);
|
||||||
|
|
||||||
lsi_product = mmio_read_32(RCAR_PRR) & PRR_PRODUCT_MASK;
|
lsi_product = mmio_read_32(RCAR_PRR) & PRR_PRODUCT_MASK;
|
||||||
if (lsi_product == PRR_PRODUCT_E3)
|
if (lsi_product == PRR_PRODUCT_E3) {
|
||||||
goto start;
|
goto start;
|
||||||
|
}
|
||||||
|
|
||||||
reg = mmio_read_32(RCAR_MODEMR) & CHECK_MD13_MD14;
|
reg = mmio_read_32(RCAR_MODEMR) & CHECK_MD13_MD14;
|
||||||
switch (reg) {
|
switch (reg) {
|
||||||
|
@ -228,19 +236,21 @@ start:
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(set_slave, DVFS_STATE_T * state, uint32_t *err, uint8_t slave)
|
IIC_DVFS_FUNC(set_slave, enum dvfs_state_t *state, uint32_t *err, uint8_t slave)
|
||||||
{
|
{
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
int32_t result;
|
int32_t result;
|
||||||
uint8_t address;
|
uint8_t address;
|
||||||
|
|
||||||
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
||||||
if (result == DVFS_ERROR)
|
if (result == DVFS_ERROR) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_DTE;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_DTE;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_DTE)
|
if (mode != IIC_DVFS_BIT_ICSR_DTE) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICIC) & ~IIC_DVFS_BIT_ICIC_DTEE;
|
mode = mmio_read_8(IIC_DVFS_REG_ICIC) & ~IIC_DVFS_BIT_ICIC_DTEE;
|
||||||
mmio_write_8(IIC_DVFS_REG_ICIC, mode);
|
mmio_write_8(IIC_DVFS_REG_ICIC, mode);
|
||||||
|
@ -253,18 +263,20 @@ IIC_DVFS_FUNC(set_slave, DVFS_STATE_T * state, uint32_t *err, uint8_t slave)
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(write_addr, DVFS_STATE_T *state, uint32_t *err, uint8_t reg_addr)
|
IIC_DVFS_FUNC(write_addr, enum dvfs_state_t *state, uint32_t *err, uint8_t reg_addr)
|
||||||
{
|
{
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
int32_t result;
|
int32_t result;
|
||||||
|
|
||||||
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
||||||
if (result == DVFS_ERROR)
|
if (result == DVFS_ERROR) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_WAIT)
|
if (mode != IIC_DVFS_BIT_ICSR_WAIT) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICDR, reg_addr);
|
mmio_write_8(IIC_DVFS_REG_ICDR, reg_addr);
|
||||||
|
|
||||||
|
@ -276,18 +288,21 @@ IIC_DVFS_FUNC(write_addr, DVFS_STATE_T *state, uint32_t *err, uint8_t reg_addr)
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(write_data, DVFS_STATE_T *state, uint32_t *err, uint8_t reg_data)
|
IIC_DVFS_FUNC(write_data, enum dvfs_state_t *state, uint32_t *err,
|
||||||
|
uint8_t reg_data)
|
||||||
{
|
{
|
||||||
int32_t result;
|
int32_t result;
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
|
|
||||||
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
||||||
if (result == DVFS_ERROR)
|
if (result == DVFS_ERROR) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_WAIT)
|
if (mode != IIC_DVFS_BIT_ICSR_WAIT) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICDR, reg_data);
|
mmio_write_8(IIC_DVFS_REG_ICDR, reg_data);
|
||||||
|
|
||||||
|
@ -299,18 +314,20 @@ IIC_DVFS_FUNC(write_data, DVFS_STATE_T *state, uint32_t *err, uint8_t reg_data)
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(stop, DVFS_STATE_T *state, uint32_t *err)
|
IIC_DVFS_FUNC(stop, enum dvfs_state_t *state, uint32_t *err)
|
||||||
{
|
{
|
||||||
int32_t result;
|
int32_t result;
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
|
|
||||||
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
||||||
if (result == DVFS_ERROR)
|
if (result == DVFS_ERROR) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_WAIT)
|
if (mode != IIC_DVFS_BIT_ICSR_WAIT) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, IIC_DVFS_SET_ICCR_STOP);
|
mmio_write_8(IIC_DVFS_REG_ICCR, IIC_DVFS_SET_ICCR_STOP);
|
||||||
|
|
||||||
|
@ -326,32 +343,35 @@ IIC_DVFS_FUNC(done, void)
|
||||||
{
|
{
|
||||||
uint32_t i;
|
uint32_t i;
|
||||||
|
|
||||||
for (i = 0; i < IIC_DVFS_SET_BUSY_LOOP; i++) {
|
for (i = 0U; i < IIC_DVFS_SET_BUSY_LOOP; i++) {
|
||||||
if (mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_BUSY)
|
if ((mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_BUSY) != 0U) {
|
||||||
continue;
|
continue;
|
||||||
|
}
|
||||||
goto done;
|
goto done;
|
||||||
}
|
}
|
||||||
|
|
||||||
panic();
|
panic();
|
||||||
done:
|
done:
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, 0);
|
mmio_write_8(IIC_DVFS_REG_ICCR, 0U);
|
||||||
|
|
||||||
return DVFS_COMPLETE;
|
return DVFS_COMPLETE;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(write_reg_addr_read, DVFS_STATE_T *state, uint32_t *err,
|
IIC_DVFS_FUNC(write_reg_addr_read, enum dvfs_state_t *state, uint32_t *err,
|
||||||
uint8_t reg_addr)
|
uint8_t reg_addr)
|
||||||
{
|
{
|
||||||
int32_t result;
|
int32_t result;
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
|
|
||||||
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
||||||
if (result == DVFS_ERROR)
|
if (result == DVFS_ERROR) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_WAIT)
|
if (mode != IIC_DVFS_BIT_ICSR_WAIT) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICDR, reg_addr);
|
mmio_write_8(IIC_DVFS_REG_ICDR, reg_addr);
|
||||||
|
|
||||||
|
@ -363,18 +383,20 @@ IIC_DVFS_FUNC(write_reg_addr_read, DVFS_STATE_T *state, uint32_t *err,
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(retransmit, DVFS_STATE_T *state, uint32_t *err)
|
IIC_DVFS_FUNC(retransmit, enum dvfs_state_t *state, uint32_t *err)
|
||||||
{
|
{
|
||||||
int32_t result;
|
int32_t result;
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
|
|
||||||
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
||||||
if (result == DVFS_ERROR)
|
if (result == DVFS_ERROR) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_WAIT)
|
if (mode != IIC_DVFS_BIT_ICSR_WAIT) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, IIC_DVFS_SET_ICCR_RETRANSMISSION);
|
mmio_write_8(IIC_DVFS_REG_ICCR, IIC_DVFS_SET_ICCR_RETRANSMISSION);
|
||||||
|
|
||||||
|
@ -389,7 +411,7 @@ IIC_DVFS_FUNC(retransmit, DVFS_STATE_T *state, uint32_t *err)
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(set_slave_read, DVFS_STATE_T *state, uint32_t *err,
|
IIC_DVFS_FUNC(set_slave_read, enum dvfs_state_t *state, uint32_t *err,
|
||||||
uint8_t slave)
|
uint8_t slave)
|
||||||
{
|
{
|
||||||
uint8_t address;
|
uint8_t address;
|
||||||
|
@ -397,12 +419,14 @@ IIC_DVFS_FUNC(set_slave_read, DVFS_STATE_T *state, uint32_t *err,
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
|
|
||||||
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
||||||
if (result == DVFS_ERROR)
|
if (result == DVFS_ERROR) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_DTE;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_DTE;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_DTE)
|
if (mode != IIC_DVFS_BIT_ICSR_DTE) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICIC) & ~IIC_DVFS_BIT_ICIC_DTEE;
|
mode = mmio_read_8(IIC_DVFS_REG_ICIC) & ~IIC_DVFS_BIT_ICIC_DTEE;
|
||||||
mmio_write_8(IIC_DVFS_REG_ICIC, mode);
|
mmio_write_8(IIC_DVFS_REG_ICIC, mode);
|
||||||
|
@ -410,23 +434,25 @@ IIC_DVFS_FUNC(set_slave_read, DVFS_STATE_T *state, uint32_t *err,
|
||||||
address = ((uint8_t) (slave << 1) + DVFS_READ_MODE);
|
address = ((uint8_t) (slave << 1) + DVFS_READ_MODE);
|
||||||
mmio_write_8(IIC_DVFS_REG_ICDR, address);
|
mmio_write_8(IIC_DVFS_REG_ICDR, address);
|
||||||
|
|
||||||
*state = DVFS_CHANGE_SEND_TO_RECIEVE;
|
*state = DVFS_CHANGE_SEND_TO_RECEIVE;
|
||||||
|
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(change_send_to_recieve, DVFS_STATE_T *state, uint32_t *err)
|
IIC_DVFS_FUNC(change_send_to_receive, enum dvfs_state_t *state, uint32_t *err)
|
||||||
{
|
{
|
||||||
int32_t result;
|
int32_t result;
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
|
|
||||||
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
result = dvfs_check_error(state, err, DVFS_WRITE_MODE);
|
||||||
if (result == DVFS_ERROR)
|
if (result == DVFS_ERROR) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_WAIT)
|
if (mode != IIC_DVFS_BIT_ICSR_WAIT) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, IIC_DVFS_SET_ICCR_CHANGE);
|
mmio_write_8(IIC_DVFS_REG_ICCR, IIC_DVFS_SET_ICCR_CHANGE);
|
||||||
|
|
||||||
|
@ -438,18 +464,20 @@ IIC_DVFS_FUNC(change_send_to_recieve, DVFS_STATE_T *state, uint32_t *err)
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(stop_read, DVFS_STATE_T *state, uint32_t *err)
|
IIC_DVFS_FUNC(stop_read, enum dvfs_state_t *state, uint32_t *err)
|
||||||
{
|
{
|
||||||
int32_t result;
|
int32_t result;
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
|
|
||||||
result = dvfs_check_error(state, err, DVFS_READ_MODE);
|
result = dvfs_check_error(state, err, DVFS_READ_MODE);
|
||||||
if (result == DVFS_ERROR)
|
if (result == DVFS_ERROR) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_WAIT;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_WAIT)
|
if (mode != IIC_DVFS_BIT_ICSR_WAIT) {
|
||||||
return result;
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, IIC_DVFS_SET_ICCR_STOP_READ);
|
mmio_write_8(IIC_DVFS_REG_ICCR, IIC_DVFS_SET_ICCR_STOP_READ);
|
||||||
|
|
||||||
|
@ -464,13 +492,14 @@ IIC_DVFS_FUNC(stop_read, DVFS_STATE_T *state, uint32_t *err)
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
IIC_DVFS_FUNC(read, DVFS_STATE_T *state, uint8_t *reg_data)
|
IIC_DVFS_FUNC(read, enum dvfs_state_t *state, uint8_t *reg_data)
|
||||||
{
|
{
|
||||||
uint8_t mode;
|
uint8_t mode;
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_DTE;
|
mode = mmio_read_8(IIC_DVFS_REG_ICSR) & IIC_DVFS_BIT_ICSR_DTE;
|
||||||
if (mode != IIC_DVFS_BIT_ICSR_DTE)
|
if (mode != IIC_DVFS_BIT_ICSR_DTE) {
|
||||||
return DVFS_PROCESS;
|
return DVFS_PROCESS;
|
||||||
|
}
|
||||||
|
|
||||||
mode = mmio_read_8(IIC_DVFS_REG_ICIC) & ~IIC_DVFS_BIT_ICIC_DTEE;
|
mode = mmio_read_8(IIC_DVFS_REG_ICIC) & ~IIC_DVFS_BIT_ICIC_DTEE;
|
||||||
mmio_write_8(IIC_DVFS_REG_ICIC, mode);
|
mmio_write_8(IIC_DVFS_REG_ICIC, mode);
|
||||||
|
@ -483,12 +512,12 @@ IIC_DVFS_FUNC(read, DVFS_STATE_T *state, uint8_t *reg_data)
|
||||||
|
|
||||||
RCAR_DVFS_API(send, uint8_t slave, uint8_t reg_addr, uint8_t reg_data)
|
RCAR_DVFS_API(send, uint8_t slave, uint8_t reg_addr, uint8_t reg_data)
|
||||||
{
|
{
|
||||||
DVFS_STATE_T state = DVFS_START;
|
enum dvfs_state_t state = DVFS_START;
|
||||||
int32_t result = DVFS_PROCESS;
|
int32_t result = DVFS_PROCESS;
|
||||||
uint32_t err = 0;
|
uint32_t err = 0U;
|
||||||
|
|
||||||
mstpcr_write(SCMSTPCR9, CPG_MSTPSR9, CPG_BIT_SMSTPCR9_DVFS);
|
mstpcr_write(SCMSTPCR9, CPG_MSTPSR9, CPG_BIT_SMSTPCR9_DVFS);
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, 0);
|
mmio_write_8(IIC_DVFS_REG_ICCR, 0U);
|
||||||
again:
|
again:
|
||||||
switch (state) {
|
switch (state) {
|
||||||
case DVFS_START:
|
case DVFS_START:
|
||||||
|
@ -514,20 +543,21 @@ again:
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (result == DVFS_PROCESS)
|
if (result == DVFS_PROCESS) {
|
||||||
goto again;
|
goto again;
|
||||||
|
}
|
||||||
|
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
RCAR_DVFS_API(receive, uint8_t slave, uint8_t reg, uint8_t *data)
|
RCAR_DVFS_API(receive, uint8_t slave, uint8_t reg, uint8_t *data)
|
||||||
{
|
{
|
||||||
DVFS_STATE_T state = DVFS_START;
|
enum dvfs_state_t state = DVFS_START;
|
||||||
int32_t result = DVFS_PROCESS;
|
int32_t result = DVFS_PROCESS;
|
||||||
uint32_t err = 0;
|
uint32_t err = 0U;
|
||||||
|
|
||||||
mstpcr_write(SCMSTPCR9, CPG_MSTPSR9, CPG_BIT_SMSTPCR9_DVFS);
|
mstpcr_write(SCMSTPCR9, CPG_MSTPSR9, CPG_BIT_SMSTPCR9_DVFS);
|
||||||
mmio_write_8(IIC_DVFS_REG_ICCR, 0);
|
mmio_write_8(IIC_DVFS_REG_ICCR, 0U);
|
||||||
again:
|
again:
|
||||||
switch (state) {
|
switch (state) {
|
||||||
case DVFS_START:
|
case DVFS_START:
|
||||||
|
@ -545,8 +575,8 @@ again:
|
||||||
case DVFS_SET_SLAVE_READ:
|
case DVFS_SET_SLAVE_READ:
|
||||||
result = dvfs_set_slave_read(&state, &err, slave);
|
result = dvfs_set_slave_read(&state, &err, slave);
|
||||||
break;
|
break;
|
||||||
case DVFS_CHANGE_SEND_TO_RECIEVE:
|
case DVFS_CHANGE_SEND_TO_RECEIVE:
|
||||||
result = dvfs_change_send_to_recieve(&state, &err);
|
result = dvfs_change_send_to_receive(&state, &err);
|
||||||
break;
|
break;
|
||||||
case DVFS_STOP_READ:
|
case DVFS_STOP_READ:
|
||||||
result = dvfs_stop_read(&state, &err);
|
result = dvfs_stop_read(&state, &err);
|
||||||
|
@ -562,8 +592,9 @@ again:
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (result == DVFS_PROCESS)
|
if (result == DVFS_PROCESS) {
|
||||||
goto again;
|
goto again;
|
||||||
|
}
|
||||||
|
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2015-2017, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2015-2021, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
@ -8,14 +8,14 @@
|
||||||
#define IIC_DVFS_H
|
#define IIC_DVFS_H
|
||||||
|
|
||||||
/* PMIC slave */
|
/* PMIC slave */
|
||||||
#define PMIC (0x30)
|
#define PMIC (0x30U)
|
||||||
#define BKUP_MODE_CNT (0x20)
|
#define BKUP_MODE_CNT (0x20U)
|
||||||
#define DVFS_SET_VID (0x54)
|
#define DVFS_SET_VID (0x54U)
|
||||||
#define REG_KEEP10 (0x79)
|
#define REG_KEEP10 (0x79U)
|
||||||
|
|
||||||
/* EEPROM slave */
|
/* EEPROM slave */
|
||||||
#define EEPROM (0x50)
|
#define EEPROM (0x50U)
|
||||||
#define BOARD_ID (0x70)
|
#define BOARD_ID (0x70U)
|
||||||
|
|
||||||
int32_t rcar_iic_dvfs_receive(uint8_t slave, uint8_t reg, uint8_t *data);
|
int32_t rcar_iic_dvfs_receive(uint8_t slave, uint8_t reg, uint8_t *data);
|
||||||
int32_t rcar_iic_dvfs_send(uint8_t slave, uint8_t regr, uint8_t data);
|
int32_t rcar_iic_dvfs_send(uint8_t slave, uint8_t regr, uint8_t data);
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2015-2019, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2015-2021, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
@ -10,13 +10,13 @@
|
||||||
#include <drivers/io/io_driver.h>
|
#include <drivers/io/io_driver.h>
|
||||||
#include <drivers/io/io_storage.h>
|
#include <drivers/io/io_storage.h>
|
||||||
|
|
||||||
|
#include "emmc_config.h"
|
||||||
|
#include "emmc_def.h"
|
||||||
|
#include "emmc_hal.h"
|
||||||
|
#include "emmc_std.h"
|
||||||
#include "io_common.h"
|
#include "io_common.h"
|
||||||
#include "io_emmcdrv.h"
|
#include "io_emmcdrv.h"
|
||||||
#include "io_private.h"
|
#include "io_private.h"
|
||||||
#include "emmc_config.h"
|
|
||||||
#include "emmc_hal.h"
|
|
||||||
#include "emmc_std.h"
|
|
||||||
#include "emmc_def.h"
|
|
||||||
|
|
||||||
static int32_t emmcdrv_dev_open(const uintptr_t spec __attribute__ ((unused)),
|
static int32_t emmcdrv_dev_open(const uintptr_t spec __attribute__ ((unused)),
|
||||||
io_dev_info_t **dev_info);
|
io_dev_info_t **dev_info);
|
||||||
|
@ -41,8 +41,9 @@ static io_type_t device_type_emmcdrv(void)
|
||||||
static int32_t emmcdrv_block_seek(io_entity_t *entity, int32_t mode,
|
static int32_t emmcdrv_block_seek(io_entity_t *entity, int32_t mode,
|
||||||
signed long long offset)
|
signed long long offset)
|
||||||
{
|
{
|
||||||
if (mode != IO_SEEK_SET)
|
if (mode != IO_SEEK_SET) {
|
||||||
return IO_FAIL;
|
return IO_FAIL;
|
||||||
|
}
|
||||||
|
|
||||||
((file_state_t *) entity->info)->file_pos = offset;
|
((file_state_t *) entity->info)->file_pos = offset;
|
||||||
|
|
||||||
|
@ -64,12 +65,14 @@ static int32_t emmcdrv_block_read(io_entity_t *entity, uintptr_t buffer,
|
||||||
current_file.partition, current_file.file_pos,
|
current_file.partition, current_file.file_pos,
|
||||||
sector_add, length, sector_num);
|
sector_add, length, sector_num);
|
||||||
|
|
||||||
if ((buffer + length - 1U) <= (uintptr_t)UINT32_MAX)
|
if ((buffer + length - 1U) <= (uintptr_t)UINT32_MAX) {
|
||||||
emmc_dma = LOADIMAGE_FLAGS_DMA_ENABLE;
|
emmc_dma = LOADIMAGE_FLAGS_DMA_ENABLE;
|
||||||
|
}
|
||||||
|
|
||||||
if (emmc_read_sector((uint32_t *) buffer, sector_add, sector_num,
|
if (emmc_read_sector((uint32_t *) buffer, sector_add, sector_num,
|
||||||
emmc_dma) != EMMC_SUCCESS)
|
emmc_dma) != EMMC_SUCCESS) {
|
||||||
result = IO_FAIL;
|
result = IO_FAIL;
|
||||||
|
}
|
||||||
|
|
||||||
*length_read = length;
|
*length_read = length;
|
||||||
fp->file_pos += (signed long long)length;
|
fp->file_pos += (signed long long)length;
|
||||||
|
@ -92,8 +95,8 @@ static int32_t emmcdrv_block_open(io_dev_info_t *dev_info,
|
||||||
|
|
||||||
if (emmcdrv_bootpartition == PARTITION_ID_USER) {
|
if (emmcdrv_bootpartition == PARTITION_ID_USER) {
|
||||||
emmcdrv_bootpartition = mmc_drv_obj.boot_partition_en;
|
emmcdrv_bootpartition = mmc_drv_obj.boot_partition_en;
|
||||||
if ((PARTITION_ID_BOOT_1 == emmcdrv_bootpartition) ||
|
if ((emmcdrv_bootpartition == PARTITION_ID_BOOT_1) ||
|
||||||
(PARTITION_ID_BOOT_2 == emmcdrv_bootpartition)) {
|
(emmcdrv_bootpartition == PARTITION_ID_BOOT_2)) {
|
||||||
current_file.partition = emmcdrv_bootpartition;
|
current_file.partition = emmcdrv_bootpartition;
|
||||||
|
|
||||||
NOTICE("BL2: eMMC boot from partition %d\n",
|
NOTICE("BL2: eMMC boot from partition %d\n",
|
||||||
|
@ -103,16 +106,18 @@ static int32_t emmcdrv_block_open(io_dev_info_t *dev_info,
|
||||||
return IO_FAIL;
|
return IO_FAIL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if ((PARTITION_ID_USER == block_spec->partition) ||
|
if ((block_spec->partition == PARTITION_ID_USER) ||
|
||||||
(PARTITION_ID_BOOT_1 == block_spec->partition) ||
|
(block_spec->partition == PARTITION_ID_BOOT_1) ||
|
||||||
(PARTITION_ID_BOOT_2 == block_spec->partition))
|
(block_spec->partition == PARTITION_ID_BOOT_2)) {
|
||||||
current_file.partition = block_spec->partition;
|
current_file.partition = block_spec->partition;
|
||||||
else
|
} else {
|
||||||
current_file.partition = emmcdrv_bootpartition;
|
current_file.partition = emmcdrv_bootpartition;
|
||||||
|
}
|
||||||
|
|
||||||
done:
|
done:
|
||||||
if (emmc_select_partition(current_file.partition) != EMMC_SUCCESS)
|
if (emmc_select_partition(current_file.partition) != EMMC_SUCCESS) {
|
||||||
return IO_FAIL;
|
return IO_FAIL;
|
||||||
|
}
|
||||||
|
|
||||||
entity->info = (uintptr_t) ¤t_file;
|
entity->info = (uintptr_t) ¤t_file;
|
||||||
|
|
||||||
|
@ -166,8 +171,9 @@ int32_t rcar_register_io_dev_emmcdrv(const io_dev_connector_t **dev_con)
|
||||||
int32_t rc;
|
int32_t rc;
|
||||||
|
|
||||||
rc = io_register_device(&emmcdrv_dev_info);
|
rc = io_register_device(&emmcdrv_dev_info);
|
||||||
if (rc == IO_SUCCESS)
|
if (rc == IO_SUCCESS) {
|
||||||
*dev_con = &emmcdrv_dev_connector;
|
*dev_con = &emmcdrv_dev_connector;
|
||||||
|
}
|
||||||
|
|
||||||
return rc;
|
return rc;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2015-2019, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2015-2021, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
@ -11,8 +11,8 @@
|
||||||
#include <drivers/io/io_storage.h>
|
#include <drivers/io/io_storage.h>
|
||||||
|
|
||||||
#include "io_common.h"
|
#include "io_common.h"
|
||||||
#include "io_private.h"
|
|
||||||
#include "io_memdrv.h"
|
#include "io_memdrv.h"
|
||||||
|
#include "io_private.h"
|
||||||
#include "rcar_def.h"
|
#include "rcar_def.h"
|
||||||
|
|
||||||
extern void rcar_dma_exec(uintptr_t dst, uint32_t src, uint32_t len);
|
extern void rcar_dma_exec(uintptr_t dst, uint32_t src, uint32_t len);
|
||||||
|
@ -21,7 +21,8 @@ static int32_t memdrv_dev_open(const uintptr_t dev __attribute__ ((unused)),
|
||||||
io_dev_info_t **dev_info);
|
io_dev_info_t **dev_info);
|
||||||
static int32_t memdrv_dev_close(io_dev_info_t *dev_info);
|
static int32_t memdrv_dev_close(io_dev_info_t *dev_info);
|
||||||
|
|
||||||
/* As we need to be able to keep state for seek, only one file can be open
|
/*
|
||||||
|
* As we need to be able to keep state for seek, only one file can be open
|
||||||
* at a time. Make this a structure and point to the entity->info. When we
|
* at a time. Make this a structure and point to the entity->info. When we
|
||||||
* can malloc memory we can change this to support more open files.
|
* can malloc memory we can change this to support more open files.
|
||||||
*/
|
*/
|
||||||
|
@ -43,12 +44,14 @@ static int32_t memdrv_block_open(io_dev_info_t *dev_info, const uintptr_t spec,
|
||||||
{
|
{
|
||||||
const io_drv_spec_t *block_spec = (io_drv_spec_t *) spec;
|
const io_drv_spec_t *block_spec = (io_drv_spec_t *) spec;
|
||||||
|
|
||||||
/* Since we need to track open state for seek() we only allow one open
|
/*
|
||||||
|
* Since we need to track open state for seek() we only allow one open
|
||||||
* spec at a time. When we have dynamic memory we can malloc and set
|
* spec at a time. When we have dynamic memory we can malloc and set
|
||||||
* entity->info.
|
* entity->info.
|
||||||
*/
|
*/
|
||||||
if (current_file.in_use != 0U)
|
if (current_file.in_use != 0U) {
|
||||||
return IO_RESOURCES_EXHAUSTED;
|
return IO_RESOURCES_EXHAUSTED;
|
||||||
|
}
|
||||||
|
|
||||||
/* File cursor offset for seek and incremental reads etc. */
|
/* File cursor offset for seek and incremental reads etc. */
|
||||||
current_file.base = block_spec->offset;
|
current_file.base = block_spec->offset;
|
||||||
|
@ -63,8 +66,9 @@ static int32_t memdrv_block_open(io_dev_info_t *dev_info, const uintptr_t spec,
|
||||||
static int32_t memdrv_block_seek(io_entity_t *entity, int32_t mode,
|
static int32_t memdrv_block_seek(io_entity_t *entity, int32_t mode,
|
||||||
signed long long offset)
|
signed long long offset)
|
||||||
{
|
{
|
||||||
if (mode != IO_SEEK_SET)
|
if (mode != IO_SEEK_SET) {
|
||||||
return IO_FAIL;
|
return IO_FAIL;
|
||||||
|
}
|
||||||
|
|
||||||
((file_state_t *) entity->info)->file_pos = offset;
|
((file_state_t *) entity->info)->file_pos = offset;
|
||||||
|
|
||||||
|
@ -142,8 +146,9 @@ int32_t rcar_register_io_dev_memdrv(const io_dev_connector_t **dev_con)
|
||||||
int32_t result;
|
int32_t result;
|
||||||
|
|
||||||
result = io_register_device(&memdrv_dev_info);
|
result = io_register_device(&memdrv_dev_info);
|
||||||
if (result == IO_SUCCESS)
|
if (result == IO_SUCCESS) {
|
||||||
*dev_con = &memdrv_dev_connector;
|
*dev_con = &memdrv_dev_connector;
|
||||||
|
}
|
||||||
|
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2015-2018, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2015-2021, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
@ -8,8 +8,6 @@
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
|
|
||||||
#include <platform_def.h>
|
|
||||||
|
|
||||||
#include <arch_helpers.h>
|
#include <arch_helpers.h>
|
||||||
#include <common/bl_common.h>
|
#include <common/bl_common.h>
|
||||||
#include <common/debug.h>
|
#include <common/debug.h>
|
||||||
|
@ -24,6 +22,7 @@
|
||||||
#include "io_rcar.h"
|
#include "io_rcar.h"
|
||||||
#include "io_common.h"
|
#include "io_common.h"
|
||||||
#include "io_private.h"
|
#include "io_private.h"
|
||||||
|
#include <platform_def.h>
|
||||||
|
|
||||||
extern int32_t plat_get_drv_source(uint32_t id, uintptr_t *dev,
|
extern int32_t plat_get_drv_source(uint32_t id, uintptr_t *dev,
|
||||||
uintptr_t *image_spec);
|
uintptr_t *image_spec);
|
||||||
|
@ -39,7 +38,8 @@ typedef struct {
|
||||||
} plat_rcar_name_offset_t;
|
} plat_rcar_name_offset_t;
|
||||||
|
|
||||||
typedef struct {
|
typedef struct {
|
||||||
/* Put position above the struct to allow {0} on static init.
|
/*
|
||||||
|
* Put position above the struct to allow {0} on static init.
|
||||||
* It is a workaround for a known bug in GCC
|
* It is a workaround for a known bug in GCC
|
||||||
* http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
|
* http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
|
||||||
*/
|
*/
|
||||||
|
@ -136,9 +136,11 @@ int32_t rcar_get_certificate(const int32_t name, uint32_t *cert)
|
||||||
{
|
{
|
||||||
#if TRUSTED_BOARD_BOOT
|
#if TRUSTED_BOARD_BOOT
|
||||||
int32_t i;
|
int32_t i;
|
||||||
|
|
||||||
for (i = 0; i < ARRAY_SIZE(cert_offset); i++) {
|
for (i = 0; i < ARRAY_SIZE(cert_offset); i++) {
|
||||||
if (name != cert_offset[i].name)
|
if (name != cert_offset[i].name) {
|
||||||
continue;
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
*cert = RCAR_CERT_SIZE;
|
*cert = RCAR_CERT_SIZE;
|
||||||
*cert *= RCAR_ATTR_GET_CERTOFF(cert_offset[i].attr);
|
*cert *= RCAR_ATTR_GET_CERTOFF(cert_offset[i].attr);
|
||||||
|
@ -157,12 +159,14 @@ static int32_t file_to_offset(const int32_t name, uintptr_t *offset,
|
||||||
int32_t i;
|
int32_t i;
|
||||||
|
|
||||||
for (i = 0; i < ARRAY_SIZE(name_offset); i++) {
|
for (i = 0; i < ARRAY_SIZE(name_offset); i++) {
|
||||||
if (name != name_offset[i].name)
|
if (name != name_offset[i].name) {
|
||||||
continue;
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
addr = RCAR_ATTR_GET_CALCADDR(name_offset[i].attr);
|
addr = RCAR_ATTR_GET_CALCADDR(name_offset[i].attr);
|
||||||
if (rcar_image_number + 2 < addr)
|
if (rcar_image_number + 2U < addr) {
|
||||||
continue;
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
*offset = rcar_image_header[addr];
|
*offset = rcar_image_header[addr];
|
||||||
*cert = RCAR_CERT_SIZE;
|
*cert = RCAR_CERT_SIZE;
|
||||||
|
@ -175,8 +179,9 @@ static int32_t file_to_offset(const int32_t name, uintptr_t *offset,
|
||||||
|
|
||||||
#if TRUSTED_BOARD_BOOT
|
#if TRUSTED_BOARD_BOOT
|
||||||
for (i = 0; i < ARRAY_SIZE(cert_offset); i++) {
|
for (i = 0; i < ARRAY_SIZE(cert_offset); i++) {
|
||||||
if (name != cert_offset[i].name)
|
if (name != cert_offset[i].name) {
|
||||||
continue;
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
*no_load = RCAR_ATTR_GET_ISNOLOAD(cert_offset[i].attr);
|
*no_load = RCAR_ATTR_GET_ISNOLOAD(cert_offset[i].attr);
|
||||||
*partition = 0U;
|
*partition = 0U;
|
||||||
|
@ -282,8 +287,9 @@ static int32_t check_load_area(uintptr_t dst, uintptr_t len)
|
||||||
result = IO_FAIL;
|
result = IO_FAIL;
|
||||||
}
|
}
|
||||||
done:
|
done:
|
||||||
if (result == IO_FAIL)
|
if (result == IO_FAIL) {
|
||||||
ERROR("BL2: Out of range : dst=0x%lx len=0x%lx\n", dst, len);
|
ERROR("BL2: Out of range : dst=0x%lx len=0x%lx\n", dst, len);
|
||||||
|
}
|
||||||
|
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
@ -307,14 +313,15 @@ static int32_t load_bl33x(void)
|
||||||
BL338_IMAGE_ID
|
BL338_IMAGE_ID
|
||||||
};
|
};
|
||||||
|
|
||||||
if (loaded != IO_NOT_SUPPORTED)
|
if (loaded != IO_NOT_SUPPORTED) {
|
||||||
return loaded;
|
return loaded;
|
||||||
|
}
|
||||||
|
|
||||||
for (i = 1; i < rcar_image_number; i++) {
|
for (i = 1; i < rcar_image_number; i++) {
|
||||||
rc = file_to_offset(img[i], &offset, &cert, &noload,
|
rc = file_to_offset(img[i], &offset, &cert, &noload,
|
||||||
&partition);
|
&partition);
|
||||||
if (rc != IO_SUCCESS) {
|
if (rc != IO_SUCCESS) {
|
||||||
WARN("load_bl33x: failed to get offset\n");
|
WARN("%s: failed to get offset\n", __func__);
|
||||||
loaded = IO_FAIL;
|
loaded = IO_FAIL;
|
||||||
return loaded;
|
return loaded;
|
||||||
}
|
}
|
||||||
|
@ -324,34 +331,34 @@ static int32_t load_bl33x(void)
|
||||||
|
|
||||||
rc = io_open(rcar_handle, rcar_spec, &handle);
|
rc = io_open(rcar_handle, rcar_spec, &handle);
|
||||||
if (rc != IO_SUCCESS) {
|
if (rc != IO_SUCCESS) {
|
||||||
WARN("Failed to open FIP (%i)\n", rc);
|
WARN("%s: Failed to open FIP (%i)\n", __func__, rc);
|
||||||
loaded = IO_FAIL;
|
loaded = IO_FAIL;
|
||||||
return loaded;
|
return loaded;
|
||||||
}
|
}
|
||||||
|
|
||||||
rc = io_seek(handle, IO_SEEK_SET, offset);
|
rc = io_seek(handle, IO_SEEK_SET, offset);
|
||||||
if (rc != IO_SUCCESS) {
|
if (rc != IO_SUCCESS) {
|
||||||
WARN("load_bl33x: failed to seek\n");
|
WARN("%s: failed to seek\n", __func__);
|
||||||
loaded = IO_FAIL;
|
loaded = IO_FAIL;
|
||||||
return loaded;
|
return loaded;
|
||||||
}
|
}
|
||||||
|
|
||||||
rc = check_load_area(dst, len);
|
rc = check_load_area(dst, len);
|
||||||
if (rc != IO_SUCCESS) {
|
if (rc != IO_SUCCESS) {
|
||||||
WARN("load_bl33x: check load area\n");
|
WARN("%s: check load area\n", __func__);
|
||||||
loaded = IO_FAIL;
|
loaded = IO_FAIL;
|
||||||
return loaded;
|
return loaded;
|
||||||
}
|
}
|
||||||
|
|
||||||
rc = io_read(handle, dst, len, &cnt);
|
rc = io_read(handle, dst, len, &cnt);
|
||||||
if (rc != IO_SUCCESS) {
|
if (rc != IO_SUCCESS) {
|
||||||
WARN("load_bl33x: failed to read\n");
|
WARN("%s: failed to read\n", __func__);
|
||||||
loaded = IO_FAIL;
|
loaded = IO_FAIL;
|
||||||
return loaded;
|
return loaded;
|
||||||
}
|
}
|
||||||
#if TRUSTED_BOARD_BOOT
|
#if TRUSTED_BOARD_BOOT
|
||||||
rc = auth_mod_verify_img(img[i], (void *)dst, len);
|
rc = auth_mod_verify_img(img[i], (void *)dst, len);
|
||||||
if (rc) {
|
if (rc != 0) {
|
||||||
memset((void *)dst, 0x00, len);
|
memset((void *)dst, 0x00, len);
|
||||||
loaded = IO_FAIL;
|
loaded = IO_FAIL;
|
||||||
return loaded;
|
return loaded;
|
||||||
|
@ -367,8 +374,7 @@ static int32_t load_bl33x(void)
|
||||||
|
|
||||||
static int32_t rcar_dev_init(io_dev_info_t *dev_info, const uintptr_t name)
|
static int32_t rcar_dev_init(io_dev_info_t *dev_info, const uintptr_t name)
|
||||||
{
|
{
|
||||||
uint64_t header[64] __aligned(FLASH_TRANS_SIZE_UNIT) = {
|
uint64_t header[64] __aligned(FLASH_TRANS_SIZE_UNIT) = {0UL};
|
||||||
0};
|
|
||||||
uintptr_t handle;
|
uintptr_t handle;
|
||||||
ssize_t offset;
|
ssize_t offset;
|
||||||
uint32_t i;
|
uint32_t i;
|
||||||
|
@ -382,8 +388,9 @@ static int32_t rcar_dev_init(io_dev_info_t *dev_info, const uintptr_t name)
|
||||||
return IO_FAIL;
|
return IO_FAIL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (RCAR_CERT_LOAD == rcar_cert_load)
|
if (rcar_cert_load == RCAR_CERT_LOAD) {
|
||||||
return IO_SUCCESS;
|
return IO_SUCCESS;
|
||||||
|
}
|
||||||
|
|
||||||
rc = io_open(rcar_handle, rcar_spec, &handle);
|
rc = io_open(rcar_handle, rcar_spec, &handle);
|
||||||
if (rc != IO_SUCCESS) {
|
if (rc != IO_SUCCESS) {
|
||||||
|
@ -391,16 +398,18 @@ static int32_t rcar_dev_init(io_dev_info_t *dev_info, const uintptr_t name)
|
||||||
return IO_FAIL;
|
return IO_FAIL;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* get start address list */
|
/*
|
||||||
/* [0] address num */
|
* get start address list
|
||||||
/* [1] BL33-1 image address */
|
* [0] address num
|
||||||
/* [2] BL33-2 image address */
|
* [1] BL33-1 image address
|
||||||
/* [3] BL33-3 image address */
|
* [2] BL33-2 image address
|
||||||
/* [4] BL33-4 image address */
|
* [3] BL33-3 image address
|
||||||
/* [5] BL33-5 image address */
|
* [4] BL33-4 image address
|
||||||
/* [6] BL33-6 image address */
|
* [5] BL33-5 image address
|
||||||
/* [7] BL33-7 image address */
|
* [6] BL33-6 image address
|
||||||
/* [8] BL33-8 image address */
|
* [7] BL33-7 image address
|
||||||
|
* [8] BL33-8 image address
|
||||||
|
*/
|
||||||
offset = name == EMMC_DEV_ID ? RCAR_EMMC_CERT_HEADER :
|
offset = name == EMMC_DEV_ID ? RCAR_EMMC_CERT_HEADER :
|
||||||
RCAR_FLASH_CERT_HEADER;
|
RCAR_FLASH_CERT_HEADER;
|
||||||
rc = io_seek(handle, IO_SEEK_SET, offset);
|
rc = io_seek(handle, IO_SEEK_SET, offset);
|
||||||
|
@ -447,8 +456,9 @@ static int32_t rcar_dev_init(io_dev_info_t *dev_info, const uintptr_t name)
|
||||||
rcar_cert_load = RCAR_CERT_LOAD;
|
rcar_cert_load = RCAR_CERT_LOAD;
|
||||||
error:
|
error:
|
||||||
|
|
||||||
if (rc != IO_SUCCESS)
|
if (rc != IO_SUCCESS) {
|
||||||
rc = IO_FAIL;
|
rc = IO_FAIL;
|
||||||
|
}
|
||||||
|
|
||||||
io_close(handle);
|
io_close(handle);
|
||||||
|
|
||||||
|
@ -464,13 +474,15 @@ static int32_t rcar_file_open(io_dev_info_t *info, const uintptr_t file_spec,
|
||||||
uint32_t noload, cert, len;
|
uint32_t noload, cert, len;
|
||||||
int32_t rc;
|
int32_t rc;
|
||||||
|
|
||||||
/* Only one file open at a time. We need to track state (ie, file
|
/*
|
||||||
* cursor position). Since the header lives at * offset zero, this entry
|
* Only one file open at a time. We need to track state (ie, file
|
||||||
|
* cursor position). Since the header lives at offset zero, this entry
|
||||||
* should never be zero in an active file.
|
* should never be zero in an active file.
|
||||||
* Once the system supports dynamic memory allocation we will allow more
|
* Once the system supports dynamic memory allocation we will allow more
|
||||||
* than one open file at a time. */
|
* than one open file at a time.
|
||||||
|
*/
|
||||||
if (current_file.offset != 0U) {
|
if (current_file.offset != 0U) {
|
||||||
WARN("rcar_file_open : Only one open file at a time.\n");
|
WARN("%s: Only one open file at a time.\n", __func__);
|
||||||
return IO_RESOURCES_EXHAUSTED;
|
return IO_RESOURCES_EXHAUSTED;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -480,7 +492,7 @@ static int32_t rcar_file_open(io_dev_info_t *info, const uintptr_t file_spec,
|
||||||
return IO_FAIL;
|
return IO_FAIL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (noload) {
|
if (noload != 0U) {
|
||||||
current_file.offset = 1;
|
current_file.offset = 1;
|
||||||
current_file.dst = 0;
|
current_file.dst = 0;
|
||||||
current_file.size = 1;
|
current_file.size = 1;
|
||||||
|
@ -494,12 +506,10 @@ static int32_t rcar_file_open(io_dev_info_t *info, const uintptr_t file_spec,
|
||||||
|
|
||||||
rcar_read_certificate((uint64_t) cert, &len, &dst);
|
rcar_read_certificate((uint64_t) cert, &len, &dst);
|
||||||
|
|
||||||
/*----------------*
|
/* Baylibre: HACK */
|
||||||
* Baylibre: HACK *
|
if (spec->offset == BL31_IMAGE_ID && len < RCAR_TRUSTED_SRAM_SIZE) {
|
||||||
*----------------*/
|
WARN("%s,%s\n", "r-car ignoring the BL31 size from certificate",
|
||||||
if (BL31_IMAGE_ID == spec->offset && len < RCAR_TRUSTED_SRAM_SIZE) {
|
"using RCAR_TRUSTED_SRAM_SIZE instead");
|
||||||
WARN("r-car ignoring the BL31 size from certificate,"
|
|
||||||
"using RCAR_TRUSTED_SRAM_SIZE instead\n");
|
|
||||||
len = RCAR_TRUSTED_SRAM_SIZE;
|
len = RCAR_TRUSTED_SRAM_SIZE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -536,7 +546,7 @@ static int32_t rcar_file_read(io_entity_t *entity, uintptr_t buffer,
|
||||||
#else
|
#else
|
||||||
static uint32_t load_bl33x_counter;
|
static uint32_t load_bl33x_counter;
|
||||||
#endif
|
#endif
|
||||||
if (current_file.no_load) {
|
if (current_file.no_load != 0U) {
|
||||||
*cnt = length;
|
*cnt = length;
|
||||||
return IO_SUCCESS;
|
return IO_SUCCESS;
|
||||||
}
|
}
|
||||||
|
@ -551,14 +561,14 @@ static int32_t rcar_file_read(io_entity_t *entity, uintptr_t buffer,
|
||||||
|
|
||||||
rc = io_seek(handle, IO_SEEK_SET, offset);
|
rc = io_seek(handle, IO_SEEK_SET, offset);
|
||||||
if (rc != IO_SUCCESS) {
|
if (rc != IO_SUCCESS) {
|
||||||
WARN("rcar_file_read: failed to seek\n");
|
WARN("%s: failed to seek\n", __func__);
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (load_bl33x_counter == RCAR_COUNT_LOAD_BL33) {
|
if (load_bl33x_counter == RCAR_COUNT_LOAD_BL33) {
|
||||||
rc = check_load_area(buffer, length);
|
rc = check_load_area(buffer, length);
|
||||||
if (rc != IO_SUCCESS) {
|
if (rc != IO_SUCCESS) {
|
||||||
WARN("rcar_file_read: load area err\n");
|
WARN("%s: load area err\n", __func__);
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -573,8 +583,9 @@ static int32_t rcar_file_read(io_entity_t *entity, uintptr_t buffer,
|
||||||
io_close(handle);
|
io_close(handle);
|
||||||
|
|
||||||
load_bl33x_counter += 1;
|
load_bl33x_counter += 1;
|
||||||
if (load_bl33x_counter == RCAR_COUNT_LOAD_BL33X)
|
if (load_bl33x_counter == RCAR_COUNT_LOAD_BL33X) {
|
||||||
return load_bl33x();
|
return load_bl33x();
|
||||||
|
}
|
||||||
|
|
||||||
return IO_SUCCESS;
|
return IO_SUCCESS;
|
||||||
error:
|
error:
|
||||||
|
@ -584,8 +595,9 @@ error:
|
||||||
|
|
||||||
static int32_t rcar_file_close(io_entity_t *entity)
|
static int32_t rcar_file_close(io_entity_t *entity)
|
||||||
{
|
{
|
||||||
if (current_file.offset)
|
if (current_file.offset != 0U) {
|
||||||
memset(¤t_file, 0, sizeof(current_file));
|
memset(¤t_file, 0, sizeof(current_file));
|
||||||
|
}
|
||||||
|
|
||||||
entity->info = 0U;
|
entity->info = 0U;
|
||||||
|
|
||||||
|
@ -634,8 +646,9 @@ int32_t rcar_register_io_dev(const io_dev_connector_t **dev_con)
|
||||||
int32_t result;
|
int32_t result;
|
||||||
|
|
||||||
result = io_register_device(&rcar_dev_info);
|
result = io_register_device(&rcar_dev_info);
|
||||||
if (result == IO_SUCCESS)
|
if (result == IO_SUCCESS) {
|
||||||
*dev_con = &rcar_dev_connector;
|
*dev_con = &rcar_dev_connector;
|
||||||
|
}
|
||||||
|
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2015-2019, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2015-2020, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
@ -16,10 +16,10 @@
|
||||||
#include <plat/common/platform.h>
|
#include <plat/common/platform.h>
|
||||||
|
|
||||||
#include "iic_dvfs.h"
|
#include "iic_dvfs.h"
|
||||||
#include "rcar_def.h"
|
|
||||||
#include "rcar_private.h"
|
|
||||||
#include "micro_delay.h"
|
#include "micro_delay.h"
|
||||||
#include "pwrc.h"
|
#include "pwrc.h"
|
||||||
|
#include "rcar_def.h"
|
||||||
|
#include "rcar_private.h"
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Someday there will be a generic power controller api. At the moment each
|
* Someday there will be a generic power controller api. At the moment each
|
||||||
|
@ -140,7 +140,7 @@ RCAR_INSTANTIATE_LOCK
|
||||||
#define PMIC_BKUP_MODE_CNT (0x20U)
|
#define PMIC_BKUP_MODE_CNT (0x20U)
|
||||||
#define PMIC_QLLM_CNT (0x27U)
|
#define PMIC_QLLM_CNT (0x27U)
|
||||||
#define PMIC_RETRY_MAX (100U)
|
#define PMIC_RETRY_MAX (100U)
|
||||||
#endif
|
#endif /* PMIC_ROHM_BD9571 */
|
||||||
#define SCTLR_EL3_M_BIT ((uint32_t)1U << 0)
|
#define SCTLR_EL3_M_BIT ((uint32_t)1U << 0)
|
||||||
#define RCAR_CA53CPU_NUM_MAX (4U)
|
#define RCAR_CA53CPU_NUM_MAX (4U)
|
||||||
#define RCAR_CA57CPU_NUM_MAX (4U)
|
#define RCAR_CA57CPU_NUM_MAX (4U)
|
||||||
|
@ -320,11 +320,13 @@ void rcar_pwrc_clusteroff(uint64_t mpidr)
|
||||||
c = rcar_pwrc_get_mpidr_cluster(mpidr);
|
c = rcar_pwrc_get_mpidr_cluster(mpidr);
|
||||||
dst = IS_CA53(c) ? RCAR_CA53CPUCMCR : RCAR_CA57CPUCMCR;
|
dst = IS_CA53(c) ? RCAR_CA53CPUCMCR : RCAR_CA57CPUCMCR;
|
||||||
|
|
||||||
if (PRR_PRODUCT_M3 == product && cut < PRR_PRODUCT_30)
|
if (product == PRR_PRODUCT_M3 && cut < PRR_PRODUCT_30) {
|
||||||
goto done;
|
goto done;
|
||||||
|
}
|
||||||
|
|
||||||
if (PRR_PRODUCT_H3 == product && cut <= PRR_PRODUCT_20)
|
if (product == PRR_PRODUCT_H3 && cut <= PRR_PRODUCT_20) {
|
||||||
goto done;
|
goto done;
|
||||||
|
}
|
||||||
|
|
||||||
/* all of the CPUs in the cluster is in the CoreStandby mode */
|
/* all of the CPUs in the cluster is in the CoreStandby mode */
|
||||||
mmio_write_32(dst, MODE_L2_DOWN);
|
mmio_write_32(dst, MODE_L2_DOWN);
|
||||||
|
@ -343,7 +345,7 @@ static void rcar_pwrc_save_timer_state(void)
|
||||||
rcar_pwrc_saved_cntfid =
|
rcar_pwrc_saved_cntfid =
|
||||||
mmio_read_32((uintptr_t)(RCAR_CNTC_BASE + RCAR_CNTFID_OFF));
|
mmio_read_32((uintptr_t)(RCAR_CNTC_BASE + RCAR_CNTFID_OFF));
|
||||||
}
|
}
|
||||||
#endif
|
#endif /* RCAR_SYSTEM_SUSPEND */
|
||||||
|
|
||||||
void rcar_pwrc_restore_timer_state(void)
|
void rcar_pwrc_restore_timer_state(void)
|
||||||
{
|
{
|
||||||
|
@ -427,11 +429,13 @@ static void __attribute__ ((section(".system_ram")))
|
||||||
product = reg & PRR_PRODUCT_MASK;
|
product = reg & PRR_PRODUCT_MASK;
|
||||||
cut = reg & PRR_CUT_MASK;
|
cut = reg & PRR_CUT_MASK;
|
||||||
|
|
||||||
if (product == PRR_PRODUCT_M3 && cut < PRR_PRODUCT_30)
|
if (product == PRR_PRODUCT_M3 && cut < PRR_PRODUCT_30) {
|
||||||
goto self_refresh;
|
goto self_refresh;
|
||||||
|
}
|
||||||
|
|
||||||
if (product == PRR_PRODUCT_H3 && cut < PRR_PRODUCT_20)
|
if (product == PRR_PRODUCT_H3 && cut < PRR_PRODUCT_20) {
|
||||||
goto self_refresh;
|
goto self_refresh;
|
||||||
|
}
|
||||||
|
|
||||||
mmio_write_32(DBSC4_REG_DBSYSCNT0, DBSC4_SET_DBSYSCNT0_WRITE_ENABLE);
|
mmio_write_32(DBSC4_REG_DBSYSCNT0, DBSC4_SET_DBSYSCNT0_WRITE_ENABLE);
|
||||||
|
|
||||||
|
@ -533,8 +537,10 @@ static void __attribute__ ((section(".system_ram")))
|
||||||
while (mmio_read_32(DBSC4_REG_DBWAIT))
|
while (mmio_read_32(DBSC4_REG_DBWAIT))
|
||||||
;
|
;
|
||||||
|
|
||||||
/* Set the auto-refresh enable register */
|
/*
|
||||||
/* Set the ARFEN bit to 0 in the DBRFEN */
|
* Set the auto-refresh enable register
|
||||||
|
* Set the ARFEN bit to 0 in the DBRFEN
|
||||||
|
*/
|
||||||
mmio_write_32(DBSC4_REG_DBRFEN, 0);
|
mmio_write_32(DBSC4_REG_DBRFEN, 0);
|
||||||
|
|
||||||
mmio_write_32(DBSC4_REG_DBPDLK0, DBSC4_SET_DBPDLK0_PHY_ACCESS);
|
mmio_write_32(DBSC4_REG_DBPDLK0, DBSC4_SET_DBPDLK0_PHY_ACCESS);
|
||||||
|
@ -835,7 +841,6 @@ int32_t rcar_pwrc_cpu_on_check(uint64_t mpidr)
|
||||||
uint64_t my_cpu;
|
uint64_t my_cpu;
|
||||||
int32_t rtn;
|
int32_t rtn;
|
||||||
uint32_t my_cluster_type;
|
uint32_t my_cluster_type;
|
||||||
|
|
||||||
const uint32_t cluster_type[PLATFORM_CLUSTER_COUNT] = {
|
const uint32_t cluster_type[PLATFORM_CLUSTER_COUNT] = {
|
||||||
RCAR_CLUSTER_CA53,
|
RCAR_CLUSTER_CA53,
|
||||||
RCAR_CLUSTER_CA57
|
RCAR_CLUSTER_CA57
|
||||||
|
@ -861,6 +866,6 @@ int32_t rcar_pwrc_cpu_on_check(uint64_t mpidr)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return (rtn);
|
|
||||||
|
|
||||||
|
return rtn;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2015-2019, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2015-2020, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2015-2019, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2015-2020, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
@ -123,7 +123,8 @@
|
||||||
.globl console_rcar_putc
|
.globl console_rcar_putc
|
||||||
.globl console_rcar_flush
|
.globl console_rcar_flush
|
||||||
|
|
||||||
/* -----------------------------------------------
|
/*
|
||||||
|
* -----------------------------------------------
|
||||||
* int console_rcar_register(
|
* int console_rcar_register(
|
||||||
* uintptr_t base, uint32_t clk, uint32_t baud,
|
* uintptr_t base, uint32_t clk, uint32_t baud,
|
||||||
* console_t *console)
|
* console_t *console)
|
||||||
|
@ -154,7 +155,7 @@ register_fail:
|
||||||
ret x7
|
ret x7
|
||||||
endfunc console_rcar_register
|
endfunc console_rcar_register
|
||||||
|
|
||||||
/* -----------------------------------------------
|
/*
|
||||||
* int console_rcar_init(unsigned long base_addr,
|
* int console_rcar_init(unsigned long base_addr,
|
||||||
* unsigned int uart_clk, unsigned int baud_rate)
|
* unsigned int uart_clk, unsigned int baud_rate)
|
||||||
* Function to initialize the console without a
|
* Function to initialize the console without a
|
||||||
|
@ -166,7 +167,6 @@ endfunc console_rcar_register
|
||||||
* w2 - Baud rate
|
* w2 - Baud rate
|
||||||
* Out: return 1 on success
|
* Out: return 1 on success
|
||||||
* Clobber list : x1, x2
|
* Clobber list : x1, x2
|
||||||
* -----------------------------------------------
|
|
||||||
*/
|
*/
|
||||||
func console_rcar_init
|
func console_rcar_init
|
||||||
ldr x0, =CPG_BASE
|
ldr x0, =CPG_BASE
|
||||||
|
@ -188,8 +188,10 @@ func console_rcar_init
|
||||||
ldrh w1, [x0, #SCIF_SCFCR]
|
ldrh w1, [x0, #SCIF_SCFCR]
|
||||||
orr w1, w1, #(SCFCR_TFRST_EN + SCFCR_RFRS_EN)
|
orr w1, w1, #(SCFCR_TFRST_EN + SCFCR_RFRS_EN)
|
||||||
strh w1, [x0, #SCIF_SCFCR]
|
strh w1, [x0, #SCIF_SCFCR]
|
||||||
/* Read flags of ER, DR, BRK, and RDF in SCFSR and those of TO and ORER
|
/*
|
||||||
in SCLSR, then clear them to 0 */
|
* Read flags of ER, DR, BRK, and RDF in SCFSR and those of TO and ORER
|
||||||
|
* in SCLSR, then clear them to 0
|
||||||
|
*/
|
||||||
mov w1, #SCFSR_INIT_DATA
|
mov w1, #SCFSR_INIT_DATA
|
||||||
strh w1, [x0, #SCIF_SCFSR]
|
strh w1, [x0, #SCIF_SCFSR]
|
||||||
mov w1, #0
|
mov w1, #0
|
||||||
|
@ -265,7 +267,7 @@ func console_rcar_init
|
||||||
ret
|
ret
|
||||||
endfunc console_rcar_init
|
endfunc console_rcar_init
|
||||||
|
|
||||||
/* --------------------------------------------------------
|
/*
|
||||||
* int console_rcar_putc(int c, unsigned int base_addr)
|
* int console_rcar_putc(int c, unsigned int base_addr)
|
||||||
* Function to output a character over the console. It
|
* Function to output a character over the console. It
|
||||||
* returns the character printed on success or -1 on error.
|
* returns the character printed on success or -1 on error.
|
||||||
|
@ -273,7 +275,6 @@ endfunc console_rcar_init
|
||||||
* x1 - pointer to console_t structure
|
* x1 - pointer to console_t structure
|
||||||
* Out : return -1 on error else return character.
|
* Out : return -1 on error else return character.
|
||||||
* Clobber list : x2
|
* Clobber list : x2
|
||||||
* --------------------------------------------------------
|
|
||||||
*/
|
*/
|
||||||
func console_rcar_putc
|
func console_rcar_putc
|
||||||
ldr x1, =SCIF_BASE
|
ldr x1, =SCIF_BASE
|
||||||
|
@ -304,12 +305,11 @@ func console_rcar_putc
|
||||||
ret
|
ret
|
||||||
endfunc console_rcar_putc
|
endfunc console_rcar_putc
|
||||||
|
|
||||||
/* ---------------------------------------------
|
/*
|
||||||
* void console_rcar_flush(void)
|
* void console_rcar_flush(void)
|
||||||
* Function to force a write of all buffered
|
* Function to force a write of all buffered
|
||||||
* data that hasn't been output. It returns void
|
* data that hasn't been output. It returns void
|
||||||
* Clobber list : x0, x1
|
* Clobber list : x0, x1
|
||||||
* ---------------------------------------------
|
|
||||||
*/
|
*/
|
||||||
func console_rcar_flush
|
func console_rcar_flush
|
||||||
ldr x0, =SCIF_BASE
|
ldr x0, =SCIF_BASE
|
||||||
|
|
|
@ -1,5 +1,5 @@
|
||||||
/*
|
/*
|
||||||
* Copyright (c) 2015-2019, Renesas Electronics Corporation. All rights reserved.
|
* Copyright (c) 2015-2020, Renesas Electronics Corporation. All rights reserved.
|
||||||
*
|
*
|
||||||
* SPDX-License-Identifier: BSD-3-Clause
|
* SPDX-License-Identifier: BSD-3-Clause
|
||||||
*/
|
*/
|
||||||
|
@ -162,6 +162,6 @@ void rcar_swdt_exec(uint64_t p)
|
||||||
gicv2_end_of_interrupt(ARM_IRQ_SEC_WDT);
|
gicv2_end_of_interrupt(ARM_IRQ_SEC_WDT);
|
||||||
rcar_swdt_release();
|
rcar_swdt_release();
|
||||||
ERROR("\n");
|
ERROR("\n");
|
||||||
ERROR("System WDT overflow, occured address is %p\n", (void *)p);
|
ERROR("System WDT overflow, occurred address is %p\n", (void *)p);
|
||||||
panic();
|
panic();
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue