mirror
/
xinu-avr
mirror of https://github.com/zrafa/xinu-avr.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

from bbb port

pull/1/head
Rafael Zurita 6 years ago
parent
1f48f44fe5
commit
c419170a29
8 changed files with 30 additions and 195 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      include/prototypes.h
  2. 9
      lib/avr_printf.c
  3. 186
      system/resched.c
  4. 8
      system/resume.c
  5. 3
      system/sleep.c
  6. 15
      system/start.S
  7. 2
      system/suspend.c
  8. 1
      system/userret.c

1
include/prototypes.h
Unescape View File

@ -631,6 +631,7 @@ extern devcall spiputc(struct dentry *, char);
//RAFA
extern void avr_printf(char mess[]);
extern void avr_kprintf(char mess[]);
/* NETWORK BYTE ORDER CONVERSION NOT NEEDED ON A BIG-ENDIAN COMPUTER */
#define htons(x) ( ( 0xff & ((x)>>8) ) | ( (0xff & (x)) << 8 ) )

9
lib/avr_printf.c
Unescape View File

@ -8,3 +8,12 @@ void avr_printf(char mess[])
strncpy_P(t, mess, 79);
printf("%s", t);
}
void avr_kprintf(char mess[])
{
char t[80];
memset(t, 80, 0);
strncpy_P(t, mess, 79);
printf("%s", t);
}

186
system/resched.c
Unescape View File

@ -1,197 +1,39 @@
/* Xinu for STM32
*
* Original license applies
* Modifications for STM32 by Robin Krens
* Please see LICENSE and AUTHORS
*
* $LOG$
* 2019/11/11 - ROBIN KRENS
* Initial version
*
* $DESCRIPTION$
*
* */
/* resched.c - resched, resched_cntl */
#include <xinu.h>
struct defer Defer;
/* Reschedule is implemented on Cortex's PendSV call
* The __attribute__((naked)) makes sure the compiler doesn't
* places registers on the stack
*
* A PendSV is similar to an exception or interrupt
* A stack frame is pushed on entry and popped
* on exit BY PROCESSOR. */
/* A pendSV call before entering this handler
* places the following on the stack
*
* R0 <- args[0]
* R1 <- args[1]
* R2
* R3
* R12
* LR <- Not a real LR, A certain 'mask'
* PC
* PSR <- Status of processor before call
*
* */
// RAFA __attribute__ ((naked))
// RAFA void resched(void)
// RAFA {
// RAFA uint32 * restorestk;
/*
asm volatile("mrs r0, psp");
asm volatile("stmdb r0!, {r4-r11}");
asm volatile("mov %0, r0" : "=r" (restorestk)); // save tmp pointer
*/
// RAFA struct procent *ptold; /* Ptr to table entry for old process */
// RAFA struct procent *ptnew; /* Ptr to table entry for new process */
/* If rescheduling is deferred, record attempt and return */
// RAFA if (Defer.ndefers > 0) {
/*
Defer.attempt = TRUE;
asm volatile ("mov r0, %0" : : "r" (restorestk));
asm volatile("ldmia r0!, {r4-r11} ");
asm volatile ("msr psp, r0");
asm volatile (
"ldr r0, =0xFFFFFFFD" "\n\t"
"mov lr, r0" "\n\t"
"bx lr");
*/
// RAFA }
/* Point to process table entry for the current (old) process */
//RAFA ptold = &proctab[currpid];
//RAFA if (ptold->prstate == PR_CURR) { /* Process remains eligible */
//RAFA if (ptold->prprio > firstkey(readylist)) {
//RAFA return (OK);
//RAFA }
/*
asm volatile ("mov r0, %0" : : "r" (restorestk));
asm volatile("ldmia r0!, {r4-r11} ");
asm volatile ("msr psp, r0");
asm volatile (
"ldr r0, =0xFFFFFFFD" "\n\t"
"mov lr, r0" "\n\t"
"bx lr");
*/
// RAFA }
/* Old process will no longer remain current */
//RAFA ptold->prstate = PR_READY;
//RAFA insert(currpid, readylist, ptold->prprio);
//RAFA }
/* Force context switch to highest priority ready process */
// RAFA currpid = dequeue(readylist);
// RAFA ptnew = &proctab[currpid];
// RAFA ptnew->prstate = PR_CURR;
// RAFA preempt = QUANTUM; /* Reset time slice for process */
// RAFA ptold->prstkptr = restorestk;
/* Old process returns here when resumed */
/*
asm volatile ("mov r0, %0" : : "r" (ptnew->prstkptr));
asm volatile("ldmia r0!, {r4-r11} ");
asm volatile ("msr psp, r0");
asm volatile (
"ldr r0, =0xFFFFFFFD" "\n\t"
"mov lr, r0" "\n\t"
"bx lr");
*/
// RAFA }
/*
print_free_mem() {
struct memblk *memptr;
uint32 free_mem;
free_mem = 0;
for (memptr = memlist.mnext; memptr != NULL;
memptr = memptr->mnext) {
free_mem += memptr->mlength;
}
kprintf("%10d bytes of free memory. Free list:\n", free_mem);
for (memptr=memlist.mnext; memptr!=NULL;memptr = memptr->mnext) {
kprintf(" [0x%08X to 0x%08X]\n",
(uint32)memptr, (uint32)memptr);
kprintf(" [0x%08X ]\n",
(uint32)memptr + memptr->mlength - 1);
}
}
*/
/* avr specific */
int resched(void)
{
// register struct pentry volatile *ptold; /* pointer to old process entry */
// register struct pentry volatile *nptr; /* pointer to new process entry */
register struct procent volatile *ptold; /* Ptr to table entry for old process */
register struct procent volatile *ptnew; /* Ptr to table entry for new process */
int newpid;
// print_free_mem();
preempt = QUANTUM; /* reset preemption counter */
// serial_put_char('X');
/* no switch needed if current process priority higher than next */
ptold = (struct pentry *)&proctab[currpid];
ptold = (struct pentry *)&proctab[currpid];
if (ptold->prstate == PR_CURR) { /* Process remains eligible */
if (ptold->prprio > firstkey(readylist)) {
// kprintf("resch no %s\n", ptold->prname);
return (OK);
}
ptold->prstate = PR_READY;
insert(currpid, readylist, ptold->prprio);
if (ptold->prstate == PR_CURR) { /* Process remains eligible */
if (ptold->prprio > firstkey(readylist)) {
// kprintf("resch no %s\n", ptold->prname);
return (OK);
}
//RAFA if ( ( (optr= &proctab[currpid])->pstate == PRCURR) &&
//RAFA ( lastkey(rdytail) < optr->pprio) ) {
// kprintf("resched: No Switch currpid=%d\n", currpid);
//RAFA return(OK);
//RAFA}
/* force context switch */
//RAFA if (optr->pstate == PRCURR) {
//RAFA optr->pstate = PRREADY;
//RAFA insert(currpid,rdyhead,optr->pprio);
//RAFA }
/* remove highest priority process at end of ready list */
currpid = dequeue(readylist);
ptnew = &proctab[currpid];
ptnew->prstate = PR_CURR;
ptold->prstate = PR_READY;
insert(currpid, readylist, ptold->prprio);
}
// if ( (newpid = getlast(rdytail)) == EMPTY )
// return(EMPTY);
/* remove highest priority process at end of ready list */
// nptr = &proctab[ ( currpid = newpid ) ];
// nptr->pstate = PRCURR; /* mark it currently running */
// kprintf("resched: Yes Switch currpid=%d\n", currpid);
currpid = dequeue(readylist);
ptnew = &proctab[currpid];
ptnew->prstate = PR_CURR;
// kprintf("ctxs %s\n", ptnew->prname);
// serial_put_char('W');
ctxsw(&ptold->pregs[0],&ptnew->pregs[0]); /* switch context from old to new */
return(OK);
@ -220,7 +62,7 @@ status resched_cntl( /* Assumes interrupts are disabled */
return SYSERR;
}
if ( (--Defer.ndefers == 0) && Defer.attempt ) {
*SCB_ICSR |= (1 << PENDSV_INTR);
resched();
}
return OK;

8
system/resume.c
Unescape View File

@ -10,29 +10,21 @@ pri16 resume(
pid32 pid /* ID of process to unsuspend */
)
{
intmask mask; /* Saved interrupt mask */
struct procent *prptr; /* Ptr to process's table entry */
pri16 prio; /* Priority to return */
mask = disable();
if (isbadpid(pid)) {
// RAFA ACA ABORTA notmain();
// kprintf("nores1\n");
restore(mask);
return (pri16)SYSERR;
}
prptr = &proctab[pid];
if (prptr->prstate != PR_SUSP) {
restore(mask);
// kprintf("no resume 2%d\n", prptr->prstate);
// kprintf("nores2\n");
return (pri16)SYSERR;
}
prio = prptr->prprio; /* Record priority to return */
// kprintf("resume\n");
ready(pid);
restore(mask);
return prio;

3
system/sleep.c
Unescape View File

@ -47,8 +47,7 @@ syscall sleepms(
}
proctab[currpid].prstate = PR_SLEEP;
*SCB_ICSR |= (1 << PENDSV_INTR);
resched();
restore(mask);
return OK;
}

15
system/start.S
Unescape View File

@ -1,3 +1,7 @@
/* avr specific */
/* We do a hack for calling (insert) nulluser before main,
* so avr-libc does everything : ld scripts, startup, etc
*/
#include <avr/io.h>
.weak __heap_end
@ -11,7 +15,6 @@
.section .vectors
__vectors:
// jmp __init
jmp __ctors_end
vector __vector_1
vector __vector_2
@ -39,15 +42,5 @@ __vectors:
vector __vector_24
vector __vector_25
// .section .init2
// __init:
// clr r1
// out _SFR_IO_ADDR(SREG), r1
// ldi r28, lo8(RAMEND)
// ldi r29, hi8(RAMEND)
// out _SFR_IO_ADDR(SPL), r28
// out _SFR_IO_ADDR(SPH), r29
// .section .init9
.section .init8
jmp nulluser

2
system/suspend.c
Unescape View File

@ -33,7 +33,7 @@ syscall suspend(
prptr->prstate = PR_SUSP;
} else {
prptr->prstate = PR_SUSP; /* Mark the current process */
*SCB_ICSR |= (1 << PENDSV_INTR);
resched(); /* suspended and resched. */
}
prio = prptr->prprio;
restore(mask);

1
system/userret.c
Unescape View File

@ -1,7 +1,6 @@
/* userret.c - userret */
#include <xinu.h>
#include <avr/interrupt.h>
/*------------------------------------------------------------------------
* userret - Called when a process returns from the top-level function

Write Preview
Loading…
Cancel
Save