woody/Tool
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add IPL

Browse Source
This commit is contained in:
woody
2025-12-24 17:21:08 +09:00
parent a96323de19
commit 96dc62d8dc
2302 changed files with 455822 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

273
IPL/Customer/Mobis/V4H_Cx_Loader/common/crc32.c Normal file
View File

@@ -0,0 +1,273 @@
/*
* This file is derived from crc32.c from the zlib-1.1.3 distribution
* by Jean-loup Gailly and Mark Adler.
*/
/* crc32.c -- compute the CRC-32 of a data stream
* Copyright (C) 1995-1998 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifdef USE_HOSTCC
#include <arpa/inet.h>
#include <u-boot/crc.h>
#else
// #include <common.h>
#include <string.h>
#endif
// #include <compiler.h>
#include <stddef.h>
/* from u-boot's compiler_types.h */
#define __inline__ inline
/* from u-boot's linux/types.h */
#ifdef __CHECKER__
#define __bitwise__ __attribute__((bitwise))
# define __force __attribute__((force))
#else
#define __bitwise__
# define __force
#endif
/* from u-boot's compiler.h */
# define cpu_to_le32(x) (x)
# define le32_to_cpu(x) (x)
#include <stdint.h>
/* from u-boot's asm-generic/int-ll64.h */
typedef unsigned int __u32;
/* from u-boot's linux/types.h */
// typedef __u32 __bitwise __be32;
#define __be32 __u32
/* from u-boot's linux/byteorder/swab.h */
#define ___swab32(x) \
((__u32)( \
(((__u32)(x) & (__u32)0x000000ffUL) << 24) | \
(((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \
(((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \
(((__u32)(x) & (__u32)0xff000000UL) >> 24) ))
#ifndef __arch__swab32
# define __arch__swab32(x) ___swab32(x)
#endif
static __inline__ __attribute__((const)) __u32 __fswab32(__u32 x)
{
return __arch__swab32(x);
}
# define __swab32(x) \
(__builtin_constant_p((__u32)(x)) ? \
___swab32((x)) : \
__fswab32((x)))
/* from u-boot's linux/byteorder/little_endian.h */
#define __cpu_to_be32(x) ((__force __be32)__swab32((x)))
/* from u-boot's generic.h */
#undef htonl
#define ___htonl(x) __cpu_to_be32(x)
#define htonl(x) ___htonl(x)
// #include <u-boot/crc.h>
#include <crc.h>
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
#include <watchdog.h>
#endif
#define tole(x) cpu_to_le32(x)
#ifdef CONFIG_DYNAMIC_CRC_TABLE
static int crc_table_empty = 1;
static uint32_t crc_table[256];
static void make_crc_table OF((void));
/*
Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
Polynomials over GF(2) are represented in binary, one bit per coefficient,
with the lowest powers in the most significant bit. Then adding polynomials
is just exclusive-or, and multiplying a polynomial by x is a right shift by
one. If we call the above polynomial p, and represent a byte as the
polynomial q, also with the lowest power in the most significant bit (so the
byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
where a mod b means the remainder after dividing a by b.
This calculation is done using the shift-register method of multiplying and
taking the remainder. The register is initialized to zero, and for each
incoming bit, x^32 is added mod p to the register if the bit is a one (where
x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
x (which is shifting right by one and adding x^32 mod p if the bit shifted
out is a one). We start with the highest power (least significant bit) of
q and repeat for all eight bits of q.
The table is simply the CRC of all possible eight bit values. This is all
the information needed to generate CRC's on data a byte at a time for all
combinations of CRC register values and incoming bytes.
*/
static void make_crc_table(void)
{
uint32_t c;
int n, k;
uLong poly; /* polynomial exclusive-or pattern */
/* terms of polynomial defining this crc (except x^32): */
static uint8_t p[] = {
0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26};
/* make exclusive-or pattern from polynomial (0xedb88320L) */
poly = 0L;
for (n = 0; n < sizeof(p)/sizeof(uint8_t); n++)
poly |= 1L << (31 - p[n]);
for (n = 0; n < 256; n++)
{
c = (uLong)n;
for (k = 0; k < 8; k++)
c = c & 1 ? poly ^ (c >> 1) : c >> 1;
crc_table[n] = tole(c);
}
crc_table_empty = 0;
}
#elif !defined(CONFIG_ARM64_CRC32)
/* ========================================================================
* Table of CRC-32's of all single-byte values (made by make_crc_table)
*/
static const uint32_t crc_table[256] = {
tole(0x00000000L), tole(0x77073096L), tole(0xee0e612cL), tole(0x990951baL),
tole(0x076dc419L), tole(0x706af48fL), tole(0xe963a535L), tole(0x9e6495a3L),
tole(0x0edb8832L), tole(0x79dcb8a4L), tole(0xe0d5e91eL), tole(0x97d2d988L),
tole(0x09b64c2bL), tole(0x7eb17cbdL), tole(0xe7b82d07L), tole(0x90bf1d91L),
tole(0x1db71064L), tole(0x6ab020f2L), tole(0xf3b97148L), tole(0x84be41deL),
tole(0x1adad47dL), tole(0x6ddde4ebL), tole(0xf4d4b551L), tole(0x83d385c7L),
tole(0x136c9856L), tole(0x646ba8c0L), tole(0xfd62f97aL), tole(0x8a65c9ecL),
tole(0x14015c4fL), tole(0x63066cd9L), tole(0xfa0f3d63L), tole(0x8d080df5L),
tole(0x3b6e20c8L), tole(0x4c69105eL), tole(0xd56041e4L), tole(0xa2677172L),
tole(0x3c03e4d1L), tole(0x4b04d447L), tole(0xd20d85fdL), tole(0xa50ab56bL),
tole(0x35b5a8faL), tole(0x42b2986cL), tole(0xdbbbc9d6L), tole(0xacbcf940L),
tole(0x32d86ce3L), tole(0x45df5c75L), tole(0xdcd60dcfL), tole(0xabd13d59L),
tole(0x26d930acL), tole(0x51de003aL), tole(0xc8d75180L), tole(0xbfd06116L),
tole(0x21b4f4b5L), tole(0x56b3c423L), tole(0xcfba9599L), tole(0xb8bda50fL),
tole(0x2802b89eL), tole(0x5f058808L), tole(0xc60cd9b2L), tole(0xb10be924L),
tole(0x2f6f7c87L), tole(0x58684c11L), tole(0xc1611dabL), tole(0xb6662d3dL),
tole(0x76dc4190L), tole(0x01db7106L), tole(0x98d220bcL), tole(0xefd5102aL),
tole(0x71b18589L), tole(0x06b6b51fL), tole(0x9fbfe4a5L), tole(0xe8b8d433L),
tole(0x7807c9a2L), tole(0x0f00f934L), tole(0x9609a88eL), tole(0xe10e9818L),
tole(0x7f6a0dbbL), tole(0x086d3d2dL), tole(0x91646c97L), tole(0xe6635c01L),
tole(0x6b6b51f4L), tole(0x1c6c6162L), tole(0x856530d8L), tole(0xf262004eL),
tole(0x6c0695edL), tole(0x1b01a57bL), tole(0x8208f4c1L), tole(0xf50fc457L),
tole(0x65b0d9c6L), tole(0x12b7e950L), tole(0x8bbeb8eaL), tole(0xfcb9887cL),
tole(0x62dd1ddfL), tole(0x15da2d49L), tole(0x8cd37cf3L), tole(0xfbd44c65L),
tole(0x4db26158L), tole(0x3ab551ceL), tole(0xa3bc0074L), tole(0xd4bb30e2L),
tole(0x4adfa541L), tole(0x3dd895d7L), tole(0xa4d1c46dL), tole(0xd3d6f4fbL),
tole(0x4369e96aL), tole(0x346ed9fcL), tole(0xad678846L), tole(0xda60b8d0L),
tole(0x44042d73L), tole(0x33031de5L), tole(0xaa0a4c5fL), tole(0xdd0d7cc9L),
tole(0x5005713cL), tole(0x270241aaL), tole(0xbe0b1010L), tole(0xc90c2086L),
tole(0x5768b525L), tole(0x206f85b3L), tole(0xb966d409L), tole(0xce61e49fL),
tole(0x5edef90eL), tole(0x29d9c998L), tole(0xb0d09822L), tole(0xc7d7a8b4L),
tole(0x59b33d17L), tole(0x2eb40d81L), tole(0xb7bd5c3bL), tole(0xc0ba6cadL),
tole(0xedb88320L), tole(0x9abfb3b6L), tole(0x03b6e20cL), tole(0x74b1d29aL),
tole(0xead54739L), tole(0x9dd277afL), tole(0x04db2615L), tole(0x73dc1683L),
tole(0xe3630b12L), tole(0x94643b84L), tole(0x0d6d6a3eL), tole(0x7a6a5aa8L),
tole(0xe40ecf0bL), tole(0x9309ff9dL), tole(0x0a00ae27L), tole(0x7d079eb1L),
tole(0xf00f9344L), tole(0x8708a3d2L), tole(0x1e01f268L), tole(0x6906c2feL),
tole(0xf762575dL), tole(0x806567cbL), tole(0x196c3671L), tole(0x6e6b06e7L),
tole(0xfed41b76L), tole(0x89d32be0L), tole(0x10da7a5aL), tole(0x67dd4accL),
tole(0xf9b9df6fL), tole(0x8ebeeff9L), tole(0x17b7be43L), tole(0x60b08ed5L),
tole(0xd6d6a3e8L), tole(0xa1d1937eL), tole(0x38d8c2c4L), tole(0x4fdff252L),
tole(0xd1bb67f1L), tole(0xa6bc5767L), tole(0x3fb506ddL), tole(0x48b2364bL),
tole(0xd80d2bdaL), tole(0xaf0a1b4cL), tole(0x36034af6L), tole(0x41047a60L),
tole(0xdf60efc3L), tole(0xa867df55L), tole(0x316e8eefL), tole(0x4669be79L),
tole(0xcb61b38cL), tole(0xbc66831aL), tole(0x256fd2a0L), tole(0x5268e236L),
tole(0xcc0c7795L), tole(0xbb0b4703L), tole(0x220216b9L), tole(0x5505262fL),
tole(0xc5ba3bbeL), tole(0xb2bd0b28L), tole(0x2bb45a92L), tole(0x5cb36a04L),
tole(0xc2d7ffa7L), tole(0xb5d0cf31L), tole(0x2cd99e8bL), tole(0x5bdeae1dL),
tole(0x9b64c2b0L), tole(0xec63f226L), tole(0x756aa39cL), tole(0x026d930aL),
tole(0x9c0906a9L), tole(0xeb0e363fL), tole(0x72076785L), tole(0x05005713L),
tole(0x95bf4a82L), tole(0xe2b87a14L), tole(0x7bb12baeL), tole(0x0cb61b38L),
tole(0x92d28e9bL), tole(0xe5d5be0dL), tole(0x7cdcefb7L), tole(0x0bdbdf21L),
tole(0x86d3d2d4L), tole(0xf1d4e242L), tole(0x68ddb3f8L), tole(0x1fda836eL),
tole(0x81be16cdL), tole(0xf6b9265bL), tole(0x6fb077e1L), tole(0x18b74777L),
tole(0x88085ae6L), tole(0xff0f6a70L), tole(0x66063bcaL), tole(0x11010b5cL),
tole(0x8f659effL), tole(0xf862ae69L), tole(0x616bffd3L), tole(0x166ccf45L),
tole(0xa00ae278L), tole(0xd70dd2eeL), tole(0x4e048354L), tole(0x3903b3c2L),
tole(0xa7672661L), tole(0xd06016f7L), tole(0x4969474dL), tole(0x3e6e77dbL),
tole(0xaed16a4aL), tole(0xd9d65adcL), tole(0x40df0b66L), tole(0x37d83bf0L),
tole(0xa9bcae53L), tole(0xdebb9ec5L), tole(0x47b2cf7fL), tole(0x30b5ffe9L),
tole(0xbdbdf21cL), tole(0xcabac28aL), tole(0x53b39330L), tole(0x24b4a3a6L),
tole(0xbad03605L), tole(0xcdd70693L), tole(0x54de5729L), tole(0x23d967bfL),
tole(0xb3667a2eL), tole(0xc4614ab8L), tole(0x5d681b02L), tole(0x2a6f2b94L),
tole(0xb40bbe37L), tole(0xc30c8ea1L), tole(0x5a05df1bL), tole(0x2d02ef8dL)
};
#endif
/* ========================================================================= */
// # if __BYTE_ORDER == __LITTLE_ENDIAN
# define DO_CRC(x) crc = tab[(crc ^ (x)) & 255] ^ (crc >> 8)
// # else
// # define DO_CRC(x) crc = tab[((crc >> 24) ^ (x)) & 255] ^ (crc << 8)
// # endif
/* ========================================================================= */
/* No ones complement version. JFFS2 (and other things ?)
* don't use ones compliment in their CRC calculations.
*/
uint32_t crc32_no_comp(uint32_t crc, const unsigned char *buf, uint len)
{
#ifdef CONFIG_ARM64_CRC32
crc = cpu_to_le32(crc);
while (len--)
crc = __builtin_aarch64_crc32b(crc, *buf++);
return le32_to_cpu(crc);
#else
const uint32_t *tab = crc_table;
const uint32_t *b =(const uint32_t *)buf;
size_t rem_len;
#ifdef CONFIG_DYNAMIC_CRC_TABLE
if (crc_table_empty)
make_crc_table();
#endif
crc = cpu_to_le32(crc);
/* Align it */
if (((long)b) & 3 && len) {
uint8_t *p = (uint8_t *)b;
do {
DO_CRC(*p++);
} while ((--len) && ((long)p)&3);
b = (uint32_t *)p;
}
rem_len = len & 3;
len = len >> 2;
for (--b; len; --len) {
/* load data 32 bits wide, xor data 32 bits wide. */
crc ^= *++b; /* use pre increment for speed */
DO_CRC(0);
DO_CRC(0);
DO_CRC(0);
DO_CRC(0);
}
len = rem_len;
/* And the last few bytes */
if (len) {
uint8_t *p = (uint8_t *)(b + 1) - 1;
do {
DO_CRC(*++p); /* use pre increment for speed */
} while (--len);
}
return le32_to_cpu(crc);
#endif
}
#undef DO_CRC
uint32_t crc32(uint32_t crc, const unsigned char *p, uint len)
{
return crc32_no_comp(crc ^ 0xffffffffL, p, len) ^ 0xffffffffL;
}

264
IPL/Customer/Mobis/V4H_Cx_Loader/common/log/log.c Normal file
View File

@@ -0,0 +1,264 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright 2018-2023 Renesas Electronics Corporation All rights reserved.
*******************************************************************************/
/*******************************************************************************
* DESCRIPTION : log
******************************************************************************/
/******************************************************************************
* @file log.c
* - Version : 0.04
* @brief Access protection setting driver.
* .
*****************************************************************************/
/******************************************************************************
* History : DD.MM.YYYY Version Description
* : 03.07.2020 0.01 First Release
* : 16.06.2022 0.02 Change log output
* : 31.10.2022 0.03 License notation change.
* : 04.04.2023 0.04 Removed sprintf.
*****************************************************************************/
#include "stdarg.h"
#include "stdint.h"
#include "math.h"
#include "log.h"
#include "scif.h"
#define NULL_CHAR '\0'
/***********************************************************
* log_printf
***********************************************************/
#define DOUBLE_PRINT_RES (0.001)
static uint32_t double_print(double num)
{
uint8_t num_buf[10];
uint32_t count = 0U;
uint32_t i = 0U;
uint32_t rem;
double unum;
double res = 1/DOUBLE_PRINT_RES;
if (num < 0) {
(void)console_putc((uint8_t)'-');
count = 1U;
unum = -num;
} else {
unum = num;
}
unum /= (DOUBLE_PRINT_RES);
while (1) {
if (i == 0) {
rem = fmin(9, round( fmod(unum, 10.0) ) ); //last digit is rounded to correctly handle hidden digits. (last digit is processed first)
} else {
rem = fmod(unum, 10.0);
}
num_buf[i] = (uint8_t)('0' + rem);
i++;
unum = unum / 10.0;
res = res / 10.0;
if ( (res <= 5.0) && (res > 0.5) ) {
num_buf[i] = (uint8_t)('.');
i++;
}
if ( (unum < 1.0) && (res < 1.0) ) {
break;
}
}
while (i != 0U) {
i--;
(void)console_putc(num_buf[i]);
count++;
};
return count;
}
static uint32_t uint32_print(uint32_t num)
{
uint8_t num_buf[10];
uint32_t count = 0U;
uint32_t i = 0U;
uint32_t rem;
uint32_t unum = num;
while (1) {
rem = unum % 10U;
num_buf[i] = (uint8_t)('0' + rem);
i++;
unum = unum / 10U;
if (unum < 1U) {
break;
}
}
while (i != 0U) {
i--;
(void)console_putc(num_buf[i]);
count++;
};
return count;
}
static uint32_t int32_print(int32_t num)
{
uint32_t unum;
uint32_t count = 0U;
if (num < 0) {
(void)console_putc((uint8_t)'-');
count = 1U;
unum = (uint32_t)-num;
} else {
unum = (uint32_t)num;
}
count += uint32_print(unum);
return count;
}
static uint32_t uint32_hex_print(uint32_t num)
{
uint32_t i;
uint32_t count = 0U;
uint8_t c;
for (i = 0U; i < 8U; i++) {
/* 0-F */
c = (uint8_t)((num >> ((7U - i) * 4U)) & 0x0FU);
if (c >= 0x0AU) {
/* A-F */
c += (uint8_t)('a' - 0x0AU);
} else {
/* 0-9 */
c += (uint8_t)'0';
}
(void)console_putc(c);
count++;
}
return count;
}
static uint32_t uint8_hex_print(uint8_t num)
{
uint32_t i;
uint32_t count = 0U;
uint8_t c;
for (i = 0U; i < 2U; i++) {
/* 0-F */
c = ((num >> ((1U - i) * 4U)) & 0x0FU);
if (c >= 0x0AU) {
/* A-F */
c += (uint8_t)('a' - 0x0AU);
} else {
/* 0-9 */
c += (uint8_t)'0';
}
(void)console_putc(c);
count++;
}
return count;
}
static uint32_t str_print(const char *str)
{
uint32_t count = 0;
while (*str != NULL_CHAR) {
(void)console_putc((uint8_t)*str);
str++;
count++;
}
return count;
}
void log_printf(const char *fmt, ...)
{
va_list args;
double dnum;
int32_t num;
uint32_t unum;
char *str;
uint32_t count = 0U;
va_start(args, fmt);
while (*fmt != NULL_CHAR) {
if (*fmt == '%') {
fmt++;
switch (*fmt) {
case 'i':
/* No break */
case 'd':
num = va_arg(args, int32_t);
count += int32_print(num);
break;
case 's':
str = va_arg(args, char *);
count += str_print(str);
break;
case 'x':
unum = va_arg(args, uint32_t);
count += uint32_hex_print(unum);
break;
case 'b':
unum = (uint8_t)va_arg(args, uint32_t);
count += uint8_hex_print(unum);
break;
case 'u':
unum = va_arg(args, uint32_t);
count += uint32_print(unum);
break;
case 'f':
dnum = va_arg(args, double);
count += double_print(dnum);
break;
default:
break;
}
} else {
(void)console_putc((uint8_t)*fmt);
count++;
}
fmt++;
}
va_end(args);
}

172
IPL/Customer/Mobis/V4H_Cx_Loader/common/log/scif.c Normal file
View File

@@ -0,0 +1,172 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright 2018-2022 Renesas Electronics Corporation All rights reserved.
*******************************************************************************/
/*******************************************************************************
* DESCRIPTION : SCIF driver
******************************************************************************/
/******************************************************************************
* @file scif.c
* - Version : 0.07
* @brief 1. Initial setting of SCIF.
* 2. Initial setting of HSCIF.
* 3. Log output function.
* .
*****************************************************************************/
/******************************************************************************
* History : DD.MM.YYYY Version Description
* : 28.07.2021 0.01 First Release
* : 03.09.2021 0.02 Modify the timing of MODEMR judgement.
* : 15.10.2021 0.03 Modify register access to read modify write.
* : 03.12.2021 0.04 Fix incorrect configuration process.
* : 06.01.2022 0.05 Static analysis support
* : 16.06.2022 0.06 Change line feed code
* : 31.10.2022 0.07 License notation change.
*****************************************************************************/
#include <stdint.h>
#include <types.h>
#include <scif.h>
#include <mem_io.h>
#include <rst_register.h>
/* Define */
#define SCIF_SCFSR_TEND (uint16_t)((uint16_t)1U << 6U)
#define SCIF_SCFSR_TDFE (uint16_t)((uint16_t)1U << 5U)
#define TRANS_END_CHECK (uint16_t)(SCIF_SCFSR_TEND | SCIF_SCFSR_TDFE)
static void (*rcar_putc)(uint8_t outchar);
static void scif_console_init(uint32_t modemr);
static void scif_console_putc(uint8_t outchar);
static void hscif_console_putc(uint8_t outchar);
static void scif_console_init(uint32_t modemr)
{
switch(modemr)
{
case MODEMR_HSCIF_DLMODE_3000000:
{
/* Set the pointer to a function that outputs one character. */
rcar_putc = hscif_console_putc;
break;
}
case MODEMR_HSCIF_DLMODE_1843200:
{
/* Set the pointer to a function that outputs one character. */
rcar_putc = hscif_console_putc;
break;
}
case MODEMR_HSCIF_DLMODE_921600:
{
/* Set the pointer to a function that outputs one character. */
rcar_putc = hscif_console_putc;
break;
}
case MODEMR_SCIF_DLMODE:
default:
{
/* Set the pointer to a function that outputs one character. */
rcar_putc = scif_console_putc;
break;
}
}
}
/* End of function scif_console_init(void) */
void scif_init(void)
{
uint32_t modemr;
#ifdef FORCE_115200 /* force to serial speed to 115200 bps */
#define _MODE31 (0xEB22FFF0) /* Gen4_ICUMX_loader at RT-VRAM */
#define _MODE_115200 0x00115200
modemr = mem_read32(_MODE31);
if (modemr == _MODE_115200)
modemr = MODEMR_SCIF_DLMODE;
else
#endif
{
modemr = ((mem_read32(RST_MODEMR0) & RST_MODEMR0_MD31) >> 31U);
modemr |= ((mem_read32(RST_MODEMR1) & RST_MODEMR1_MD32) << 1U);
}
scif_console_init(modemr);
}
/* End of function scif_init(void) */
void console_putc(uint8_t outchar)
{
if (outchar == 0x0A) /* \n */
{
rcar_putc( 0x0D ); /* \r */
}
rcar_putc(outchar);
}
/* End of function console_putc(void) */
static void scif_console_putc(uint8_t outchar)
{
uint16_t reg;
/* Check that transfer of SCIF0 is completed */
while (!((TRANS_END_CHECK & mem_read16(SCIF_SCFSR)) == TRANS_END_CHECK))
{
;
}
mem_write8(SCIF_SCFTDR, outchar); /* Transfer one character */
reg = mem_read16(SCIF_SCFSR);
reg &= (uint16_t)(~(TRANS_END_CHECK)); /* TEND,TDFE clear */
mem_write16(SCIF_SCFSR, reg);
/* Check that transfer of SCIF0 is completed */
while (!((TRANS_END_CHECK & mem_read16(SCIF_SCFSR)) == TRANS_END_CHECK))
{
;
}
}
/* End of function scif_console_putc(uint8_t outchar) */
static void hscif_console_putc(uint8_t outchar)
{
uint16_t reg;
/* Check that transfer of SCIF0 is completed */
while (!((TRANS_END_CHECK & mem_read16(HSCIF_HSFSR)) == TRANS_END_CHECK))
{
;
}
mem_write8(HSCIF_HSFTDR, outchar); /* Transfer one character */
reg = mem_read16(HSCIF_HSFSR);
reg &= (uint16_t)(~(TRANS_END_CHECK)); /* TEND,TDFE clear */
mem_write16(HSCIF_HSFSR, reg);
/* Check that transfer of SCIF0 is completed */
while (!((TRANS_END_CHECK & mem_read16(HSCIF_HSFSR)) == TRANS_END_CHECK))
{
;
}
}
/* End of function hscif_console_putc(uint8_t outchar) */

0
IPL/Customer/Mobis/V4H_Cx_Loader/common/scmt_checkpoint.c Normal file
View File

84
IPL/Customer/Mobis/V4H_Cx_Loader/common/string.c Normal file
View File

@@ -0,0 +1,84 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright 2023 Renesas Electronics Corporation All rights reserved.
*******************************************************************************/
/*******************************************************************************
* DESCRIPTION : Standard library
******************************************************************************/
/******************************************************************************
* @file string.c
* - Version : 0.01
* @brief standard library.
* .
*****************************************************************************/
/******************************************************************************
* History : DD.MM.YYYY Version Description
* : 04.04.2023 0.01 First Release
*****************************************************************************/
#include <stdint.h>
#include <stddef.h>
#include <string.h>
void *memcpy(void *dst, const void *src, size_t len)
{
uint8_t *p1 = (uint8_t *)dst;
const uint8_t *p2 = (const uint8_t *)src;
while(len > 0U)
{
*(p1++) = *(p2++);
len--;
}
return dst;
}
/* End of function memcpy( void* dst, const void* src, size_t n ) */
void *memset(void *dst, int val, size_t len)
{
uint8_t *p = (uint8_t *)dst;
const uint8_t uc = (uint8_t)val;
while (len > 0U)
{
*p++ = uc;
len--;
}
return (dst);
}
/* End of function memset(void *dst, int val, size_t len) */
/**
* memcmp - Compare two areas of memory
* @cs: One area of memory
* @ct: Another area of memory
* @count: The size of the area.
*/
int memcmp(const void * cs, const void * ct, size_t count)
{
const unsigned char *su1, *su2;
int res = 0;
for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
if ((res = *su1 - *su2) != 0)
break;
return res;
}

177
IPL/Customer/Mobis/V4H_Cx_Loader/common/timer/generic_timer.c Normal file
View File

@@ -0,0 +1,177 @@
/*******************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only
* intended for use with Renesas products. No other uses are authorized. This
* software is owned by Renesas Electronics Corporation and is protected under
* all applicable laws, including copyright laws.
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING
* THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT
* LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
* AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.
* TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS
* ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE
* FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR
* ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE
* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software
* and to discontinue the availability of this software. By using this software,
* you agree to the additional terms and conditions found by accessing the
* following link:
* http://www.renesas.com/disclaimer
* Copyright 2018-2023 Renesas Electronics Corporation All rights reserved.
*******************************************************************************/
/*******************************************************************************
* DESCRIPTION : generic timer
******************************************************************************/
/******************************************************************************
* @file generic_timer.c
* - Version : 0.08
* @brief
* .
*****************************************************************************/
/******************************************************************************
* History : DD.MM.YYYY Version Description
* : 19.01.2022 0.01 First Release
* : 17.02.2022 0.02 Support AArch32
* : 09.05.2022 0.03 Supports argument check of micro_wait()
* Moved the definition of the define value
* Removed __ARM_ARCH_8R__ and __ARM_ARCH_8A__
* Change macro to inline function
* Added initial settings
* Remove unnecessary casts
* Change the value of RCAR_CNTC_EXTAL
* : 16.06.2022 0.04 Change the value of RCAR_CNTC_EXTAL
* : 16.06.2022 0.05 Change log output
* : 31.10.2022 0.06 License notation change.
* : 04.04.2023 0.07 Removed stdio.h.
* : 21.08.2023 0.08 Add support for V4M.
*****************************************************************************/
#include <stdint.h>
#include <mem_io.h>
#include <timer.h>
#include <log.h>
#if (RCAR_LSI == RCAR_S4)
#define RCAR_CNTC_EXTAL (16666666U) /* 16.666666MHz */
#elif ((RCAR_LSI == RCAR_V4H) || (RCAR_LSI == RCAR_V4M))
#define RCAR_CNTC_EXTAL (16666600U) /* 16.666600MHz */
#endif /* RCAR_LSI == RCAR_S4 */
#define CNTFID_OFF (0x0020U)
#define CNTCR_OFF (0x0000U)
#define CNTCR_EN ((1U) << 0U)
#define RCAR_CNTC_BASE (0xE6080000U)
#define RCAR_CONV_MICROSEC (1000000U)
#define RCAR_MAX_WAITTIME (10000000U)
#define RCAR_MIN_WAITTIME (0U)
#ifdef __aarch64__
static inline uint64_t get_cntfrq(void)
{
uint64_t freq;
__asm__ volatile ("mrs %0, cntfrq_el0" : "=r" (freq));
return(freq);
}
static inline void set_cntfrq(uint64_t reg_cntfid)
{
__asm__ volatile ("msr cntfrq_el0, %0" :: "r" (reg_cntfid));
}
static inline uint64_t get_cntpct(void)
{
uint64_t base_count;
__asm__ volatile ("mrs %0, cntpct_el0" : "=r" (base_count));
return(base_count);
}
#elif __arm__
static inline uint32_t get_cntfrq(void)
{
uint32_t freq;
__asm__ volatile("mrc p15, 0, %0, c14, c0, 0" : "=r" (freq));
return(freq);
}
static inline void set_cntfrq(uint32_t reg_cntfid)
{
__asm__ volatile("mcr p15, 0, %0, c14, c0, 0" : : "r" (reg_cntfid));
}
static inline uint64_t get_cntpct(void)
{
uint64_t base_count;
__asm__ volatile ("mrrc p15, 0, %Q0, %R0, c14" : "=r" (base_count));
return(base_count);
}
#endif /* __aarch64__ */
void generic_timer_init(void)
{
/* Update memory mapped and register based freqency */
/* AArch64:cntfrq_el0 */
/* AArch32:cntfrq */
set_cntfrq(RCAR_CNTC_EXTAL);
mem_write32(RCAR_CNTC_BASE + CNTFID_OFF, RCAR_CNTC_EXTAL);
/* Enable counter */
mem_bitset32(RCAR_CNTC_BASE + CNTCR_OFF, CNTCR_EN);
}
/* End of function generic_timer_init(void) */
void micro_wait(uint64_t micro_sec)
{
uint64_t base_count = 0U;
uint64_t get_count = 0U;
uint64_t wait_time = 0U;
#ifdef __aarch64__
uint64_t freq = 0U;
#elif __arm__
uint32_t freq = 0U;
#endif /* __aarch64__ */
if((micro_sec > RCAR_MIN_WAITTIME) && (micro_sec <= RCAR_MAX_WAITTIME))
{
/* AArch64:cntfrq_el0 */
/* AArch32:cntfrq */
freq = get_cntfrq();
/* AArch64:cntpct_el0 */
/* AArch32:cntpct */
base_count = get_cntpct();
micro_sec *= freq;
while (micro_sec > wait_time)
{
/* cntpct */
get_count = get_cntpct();
/* INT30-C Pre confirmation */
if (get_count < base_count)
{
ERROR("micro_wait(Timer value error!!).\n");
panic;
}
else
{
wait_time = ((get_count - base_count) * RCAR_CONV_MICROSEC);
}
}
}
else
{
ERROR("micro_wait(wait time)\n");
ERROR("wait time = 0x%x\n", (unsigned int)micro_sec);
panic;
}
}
/* End of function micro_wait(uint64_t micro_sec) */

0
IPL/Customer/Mobis/V4H_Cx_Loader/common/timer/scmt.c Normal file
View File