int notmain ( void )
{
unsigned int beg,end;
unsigned int one,two;
uart_init();
hexstring(0x12345678);
IRQEN();
FIQEN();
PUT32(TIMER1_MATCH,0xFFF);
PUT32(TIMER_CONTROL,0x0C02);
beg=GET32(0xD1000000);
if(onetime()) return(1);
end=GET32(0xD1000000);
hexstring(end-beg);
one=end-beg;
hexstring(0x12345678);
cache_enable();
beg=GET32(0xD1000000);
if(onetime()) return(1);
end=GET32(0xD1000000);
hexstring(end-beg);
two=end-beg;
hexstring(0x12345678);
hexstring(one-two);
hexstring(0x12345678);
return(0);
}
/**
* enable I-Cache
*
*/
void rt_hw_cpu_icache_enable()
{
cache_enable(ICACHE_MASK);
}
/**
* enable D-Cache
*
*/
void rt_hw_cpu_dcache_enable()
{
cache_enable(DCACHE_MASK);
}
/*
* Machine-dependent startup code
*/
cpu_startup()
{
register unsigned i;
register caddr_t v;
register int sz;
int base, residual;
#ifdef DEBUG
extern int pmapdebug;
int opmapdebug = pmapdebug;
#endif
vm_offset_t minaddr, maxaddr;
vm_size_t size;
#ifdef DEBUG
pmapdebug = 0;
#endif
/*
* Good {morning,afternoon,evening,night}.
*/
printf(version);
/*identifycpu();*/
physmem = btoc(avail_end);
printf("real mem = %d\n", avail_end);
/*
* Find out how much space we need, allocate it,
* and then give everything true virtual addresses.
*/
sz = (int)allocsys((caddr_t)0);
if ((v = (caddr_t)kmem_alloc(kernel_map, round_page(sz))) == 0)
panic("startup: no room for tables");
if (allocsys(v) - v != sz)
panic("startup: table size inconsistency");
/*
* Now allocate buffers proper. They are different than the above
* in that they usually occupy more virtual memory than physical.
*/
size = MAXBSIZE * nbuf;
buffer_map = kmem_suballoc(kernel_map, (vm_offset_t *)&buffers,
&maxaddr, size, TRUE);
minaddr = (vm_offset_t)buffers;
if (vm_map_find(buffer_map, vm_object_allocate(size), (vm_offset_t)0,
&minaddr, size, FALSE) != KERN_SUCCESS)
panic("startup: cannot allocate buffers");
base = bufpages / nbuf;
residual = bufpages % nbuf;
for (i = 0; i < nbuf; i++) {
vm_size_t curbufsize;
vm_offset_t curbuf;
/*
* First <residual> buffers get (base+1) physical pages
* allocated for them. The rest get (base) physical pages.
*
* The rest of each buffer occupies virtual space,
* but has no physical memory allocated for it.
*/
curbuf = (vm_offset_t)buffers + i * MAXBSIZE;
curbufsize = CLBYTES * (i < residual ? base+1 : base);
vm_map_pageable(buffer_map, curbuf, curbuf+curbufsize, FALSE);
vm_map_simplify(buffer_map, curbuf);
}
/*
* Allocate a submap for exec arguments. This map effectively
* limits the number of processes exec'ing at any time.
*/
exec_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
16*NCARGS, TRUE);
/*
* Allocate a map for physio. Others use a submap of the kernel
* map, but we want one completely separate, even though it uses
* the same pmap.
*/
phys_map = vm_map_create(kernel_pmap, DVMA_BASE, DVMA_END, 1);
if (phys_map == NULL)
panic("unable to create DVMA map");
/*
* Finally, allocate mbuf pool. Since mclrefcnt is an off-size
* we use the more space efficient malloc in place of kmem_alloc.
*/
mclrefcnt = (char *)malloc(NMBCLUSTERS+CLBYTES/MCLBYTES,
M_MBUF, M_NOWAIT);
bzero(mclrefcnt, NMBCLUSTERS+CLBYTES/MCLBYTES);
mb_map = kmem_suballoc(kernel_map, (vm_offset_t *)&mbutl, &maxaddr,
VM_MBUF_SIZE, FALSE);
/*
* Initialize callouts
*/
callfree = callout;
for (i = 1; i < ncallout; i++)
callout[i-1].c_next = &callout[i];
callout[i-1].c_next = NULL;
#ifdef DEBUG
pmapdebug = opmapdebug;
#endif
printf("avail mem = %d\n", ptoa(cnt.v_free_count));
printf("using %d buffers containing %d bytes of memory\n",
nbuf, bufpages * CLBYTES);
/*
* Set up buffers, so they can be used to read disk labels.
*/
bufinit();
/*
* Configure the system, then turn on the cache. Should be able
* to do this earlier, but then esp.c fails on SS1+ boxes (??).
*/
configure();
cache_enable();
}
/*******************************************************************************
Function:
void SYS_Initialize ( void *data )
Summary:
Initializes the board, services, drivers, application and other modules
Description:
This routine initializes the board, services, drivers, application and other
modules as configured at build time. In a bare-metal environment (where no
OS is supported), this routine should be called almost immediately after
entering the "main" routine.
Precondition:
The C-language run-time environment and stack must have been initialized.
Parameters:
data - Pointer to the system initialzation data structure containing
pointers to the board, system service, and driver
initialization routines
Returns:
None.
Example:
<code>
SYS_INT_Initialize(NULL);
</code>
Remarks:
Basic System Initialization Sequence:
1. Initilize minimal board services and processor-specific items
(enough to use the board to initialize drivers and services)
2. Initialize all supported system services
3. Initialize all supported modules
(libraries, drivers, middleware, and application-level modules)
4. Initialize the main (static) application, if present.
The order in which services and modules are initialized and started may be
important.
For a static system (a system not using the ISP's dynamic implementation
of the initialization and "Tasks" services) this routine is implemented
for the specific configuration of an application.
*/
void SYS_Initialize(void* data)
{
BSP_Initialize();
// cache configuration
cache_enable(0);
SetPic32MZIoPins();
/* Initializethe interrupt system */
SYS_INT_Initialize();
/* Remap the SPI pins */
PLIB_PORTS_RemapOutput(PORTS_ID_0, OTPUT_FUNC_SDO2, OUTPUT_PIN_RPG8);
PLIB_PORTS_RemapInput(PORTS_ID_0, INPUT_FUNC_SDI2, INPUT_PIN_RPD7);
/* set priority for SPI interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_SPI2_TX, INT_PRIORITY_LEVEL3);
SYS_INT_VectorPrioritySet(INT_VECTOR_SPI2_RX, INT_PRIORITY_LEVEL3);
/* set sub-priority for SPI interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_SPI2_TX, INT_SUBPRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_SPI2_RX, INT_SUBPRIORITY_LEVEL1);
clkObject.systemClock = 200000000L;
//Turn ON the system clock
if(!SYS_TICK_Initialize(clkObject.systemClock, SYS_TICKS_PER_SECOND))
{
return;
}
SYS_INT_Enable();
/* Initialize the clock system service. This is used
* by the SPI Driver. */
clkObject.MZperipheralClock[2] = 100000000L;
clkObject.peripheralClock = 100000000L;
/* Initialize the SPI driver */
appDrvObjects.drvSPIObject = DRV_SPI_Initialize(DRV_SPI_INDEX_0,
(SYS_MODULE_INIT *)&drvSPIInit);
/* Initialize the SDCARD driver*/
appDrvObjects.drvSDCARDObject = DRV_SDCARD_Initialize(DRV_SDCARD_INDEX_0,
(SYS_MODULE_INIT *)&drvSDCARDInit);
/* Initialize the SYS_FS Layer */
SYS_FS_Initialize( (const void *) sysFATFSInit );
if(!_SYS_DEBUG_INIT(SYS_DEBUG_PORT))
{
return;
}
if(!_SYS_CONSOLE_INIT(SYS_CONSOLE_PORT))
{
return;
}
if(!_SYS_RANDOM_INIT())
{
return;
}
if (!_SYS_COMMAND_INIT())
{
return;
}
if (!SYS_USERIO_Initialize(0))
{
return;
}
// TCP/IP stack initialization
SYS_OUT_MESSAGE("TCPStack " TCPIP_STACK_VERSION " "" ");
// Initialize the TCPIP stack
if (!TCPIP_STACK_Init())
{
return;
}
APP_Initialize();
return;
} //SYS_Initialize
