295 lines
7.1 KiB
C
295 lines
7.1 KiB
C
#include "sys_config.h"
|
|
#include "typesdef.h"
|
|
#include "errno.h"
|
|
#include "list.h"
|
|
#include "dev.h"
|
|
#include "devid.h"
|
|
#include "osal/task.h"
|
|
#include "osal/sleep.h"
|
|
#include "osal/string.h"
|
|
#include "osal/irq.h"
|
|
#include "hal/dma.h"
|
|
#include "hal/crc.h"
|
|
#include "lib/common/common.h"
|
|
#include "lib/heap/sysheap.h"
|
|
|
|
extern void *krhino_mm_alloc(size_t size, void *caller);
|
|
extern void krhino_mm_free(void *ptr);
|
|
|
|
__bobj uint64 cpu_loading_tick;
|
|
#ifdef M2M_DMA
|
|
__bobj struct dma_device *m2mdma;
|
|
#endif
|
|
|
|
void cpu_loading_print(uint8 all, struct os_task_info *tsk_info, uint32 size)
|
|
{
|
|
uint32 i = 0;
|
|
uint32 diff_tick = 0;
|
|
uint32 irq_time = 0;
|
|
uint32 count;
|
|
uint64 jiff = os_jiffies();
|
|
|
|
if(tsk_info == NULL) return;
|
|
diff_tick = DIFF_JIFFIES(cpu_loading_tick, jiff);
|
|
cpu_loading_tick = jiff;
|
|
|
|
irq_time = irq_status();
|
|
os_printf("--------------------------------------------------------------------\r\n");
|
|
os_printf("Task Runtime Statistic, interval:%dms\r\n", os_jiffies_to_msecs(diff_tick));
|
|
os_printf("PID Name %%CPU(Time) Stack Prio Status\r\n");
|
|
os_printf("--------------------------------------------------------------------\r\n");
|
|
if(irq_time > 0){
|
|
count = 100 * os_msecs_to_jiffies(irq_time/1000);
|
|
os_printf("SYS IRQ: %dms, %d%%\r\n", (irq_time/1000), (count/diff_tick));
|
|
os_printf("--------------------------------------------------------------------\r\n");
|
|
}
|
|
|
|
count = os_task_runtime(tsk_info, size);
|
|
for (i = 0; i < count; i++) {
|
|
if (tsk_info[i].time > 0 || all) {
|
|
os_printf("%2d %-12s\t%2d%%(%6d) %4d %2d (%08x) %s\r\n",
|
|
tsk_info[i].id,
|
|
tsk_info[i].name ? tsk_info[i].name : "----",
|
|
#ifdef CSKY_OS
|
|
(tsk_info[i].time * 100) / diff_tick,
|
|
#elif defined(OHOS)
|
|
tsk_info[i].time,
|
|
#endif
|
|
|
|
tsk_info[i].time,
|
|
tsk_info[i].stack * 4,
|
|
tsk_info[i].prio,
|
|
tsk_info[i].arg,
|
|
tsk_info[i].status);
|
|
}
|
|
}
|
|
os_printf("--------------------------------------------------------------------\r\n");
|
|
}
|
|
|
|
int strncasecmp(const char *s1, const char *s2, size_t n)
|
|
{
|
|
size_t i = 0;
|
|
|
|
for (i = 0; i < n && s1[i] && s2[i]; i++) {
|
|
if (s1[i] == s2[i] || s1[i] + 32 == s2[i] || s1[i] - 32 == s2[i]) {
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return (i != n);
|
|
}
|
|
|
|
int strcasecmp(const char *s1, const char *s2)
|
|
{
|
|
while (*s1 || *s2) {
|
|
if (*s1 == *s2 || *s1 + 32 == *s2 || *s1 - 32 == *s2) {
|
|
s1++; s2++;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#ifdef M2M_DMA
|
|
void hw_memcpy(void *dest, const void *src, uint32 size)
|
|
{
|
|
if (dest && src) {
|
|
if (m2mdma && size > 45) {
|
|
#ifdef MEM_TRACE
|
|
#ifdef PSRAM_HEAP
|
|
struct sys_heap *heap = sysheap_valid_addr(&psram_heap, dest) ? &psram_heap : &sram_heap;
|
|
#else
|
|
struct sys_heap *heap = &sram_heap;
|
|
#endif
|
|
int32 ret = sysheap_of_check(heap, dest, size);
|
|
if (ret == -1) {
|
|
//os_printf("%s: WARING: OF CHECK 0x%x\r\n", dest, __FUNCTION__);
|
|
} else {
|
|
if (!ret) {
|
|
os_printf("check addr fail: %x, size:%d \r\n", dest, size);
|
|
}
|
|
ASSERT(ret == 1);
|
|
}
|
|
#endif
|
|
dma_memcpy(m2mdma, dest, src, size);
|
|
} else {
|
|
os_memcpy(dest, src, size);
|
|
}
|
|
}
|
|
}
|
|
|
|
void hw_memcpy0(void *dest, const void *src, uint32 size)
|
|
{
|
|
if (m2mdma && size > 45) {
|
|
#ifdef MEM_TRACE
|
|
#ifdef PSRAM_HEAP
|
|
struct sys_heap *heap = sysheap_valid_addr(&psram_heap, dest) ? &psram_heap : &sram_heap;
|
|
#else
|
|
struct sys_heap *heap = &sram_heap;
|
|
#endif
|
|
int32 ret = sysheap_of_check(heap, dest, size);
|
|
if (ret == -1) {
|
|
//os_printf("%s: WARING: OF CHECK 0x%x\r\n", dest, __FUNCTION__);
|
|
} else {
|
|
if (!ret) {
|
|
os_printf("check addr fail: %x, size:%d \r\n", dest, size);
|
|
}
|
|
ASSERT(ret == 1);
|
|
}
|
|
#endif
|
|
dma_memcpy(m2mdma, dest, src, size);
|
|
} else {
|
|
os_memcpy(dest, src, size);
|
|
}
|
|
}
|
|
|
|
void hw_memset(void *dest, uint8 val, uint32 n)
|
|
{
|
|
if (dest) {
|
|
if (m2mdma && n > 12) {
|
|
#ifdef MEM_TRACE
|
|
#ifdef PSRAM_HEAP
|
|
struct sys_heap *heap = sysheap_valid_addr(&psram_heap, dest) ? &psram_heap : &sram_heap;
|
|
#else
|
|
struct sys_heap *heap = &sram_heap;
|
|
#endif
|
|
int32 ret = sysheap_of_check(heap, dest, n);
|
|
if (ret == -1) {
|
|
//os_printf("%s: WARING: OF CHECK 0x%x\r\n", dest, __FUNCTION__);
|
|
} else {
|
|
if (!ret) {
|
|
os_printf("check addr fail: %x, size:%d \r\n", dest, n);
|
|
}
|
|
ASSERT(ret == 1);
|
|
}
|
|
#endif
|
|
dma_memset(m2mdma, dest, val, n);
|
|
} else {
|
|
os_memset(dest, val, n);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void *os_memdup(const void *ptr, uint32 len)
|
|
{
|
|
void *p;
|
|
if (!ptr || len == 0) {
|
|
return NULL;
|
|
}
|
|
p = os_malloc(len);
|
|
if (p) {
|
|
hw_memcpy(p, ptr, len);
|
|
}
|
|
return p;
|
|
}
|
|
|
|
|
|
int32 os_random_bytes(uint8 *data, int32 len)
|
|
{
|
|
int32 i = 0;
|
|
int32 seed;
|
|
#ifdef TXW4002ACK803
|
|
seed = csi_coret_get_value() ^ (csi_coret_get_value() << 8) ^ (csi_coret_get_value() >> 8);
|
|
#else
|
|
seed = csi_coret_get_value() ^ sysctrl_get_trng() ^ (sysctrl_get_trng() >> 8);
|
|
#endif
|
|
for (i = 0; i < len; i++) {
|
|
seed = seed * 214013L + 2531011L;
|
|
data[i] = (uint8)(((seed >> 16) & 0x7fff) & 0xff);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint32 hw_crc(enum CRC_DEV_TYPE type, uint8 *data, uint32 len)
|
|
{
|
|
uint32 crc = 0xffff;
|
|
struct crc_dev_req req;
|
|
struct crc_dev *crcdev = (struct crc_dev *)dev_get(HG_CRC_DEVID);
|
|
if (crcdev) {
|
|
req.type = type;
|
|
req.data = data;
|
|
req.len = len;
|
|
//ASSERT((uint32)data % 4 == 0); // crc模块数据地址必须4字节对齐检查
|
|
crc_dev_calc(crcdev, &req, &crc, 0);
|
|
} else {
|
|
os_printf("no crc dev\r\n");
|
|
crc = (uint32)os_jiffies();
|
|
}
|
|
return crc;
|
|
}
|
|
|
|
int ffs(int x)
|
|
{
|
|
int r = 1;
|
|
|
|
if (!x) {
|
|
return 0;
|
|
}
|
|
|
|
if (!(x & 0xffff)) {
|
|
x >>= 16;
|
|
r += 16;
|
|
}
|
|
if (!(x & 0xff)) {
|
|
x >>= 8;
|
|
r += 8;
|
|
}
|
|
if (!(x & 0xf)) {
|
|
x >>= 4;
|
|
r += 4;
|
|
}
|
|
if (!(x & 3)) {
|
|
x >>= 2;
|
|
r += 2;
|
|
}
|
|
if (!(x & 1)) {
|
|
x >>= 1;
|
|
r += 1;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
int fls(int x)
|
|
{
|
|
int r = 32;
|
|
|
|
if (!x) {
|
|
return 0;
|
|
}
|
|
|
|
if (!(x & 0xffff0000u)) {
|
|
x <<= 16;
|
|
r -= 16;
|
|
}
|
|
if (!(x & 0xff000000u)) {
|
|
x <<= 8;
|
|
r -= 8;
|
|
}
|
|
if (!(x & 0xf0000000u)) {
|
|
x <<= 4;
|
|
r -= 4;
|
|
}
|
|
if (!(x & 0xc0000000u)) {
|
|
x <<= 2;
|
|
r -= 2;
|
|
}
|
|
if (!(x & 0x80000000u)) {
|
|
x <<= 1;
|
|
r -= 1;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
uint32 scatter_data_size(scatter_data *data, uint32 count)
|
|
{
|
|
uint32 size = 0;
|
|
uint32 i = 0;
|
|
for (i = 0; i < count; i++) {
|
|
size += data[i].size;
|
|
}
|
|
return size;
|
|
}
|
|
|