source: soft/giet_vm/giet_kernel/ctx_handler.h @ 501

Last change on this file since 501 was 449, checked in by alain, 10 years ago

Introducing the CMA_RX, CMA_TX, NIC_RX, NIC_TX slots in the task context.
This allows an user task to have a private NIC channel and a private CMA channel.

  • Property svn:executable set to *
File size: 6.7 KB
Line 
1/////////////////////////////////////////////////////////////////////////////////////////
2// File     : ctx_handler.h
3// Date     : 01/04/2012
4// Authors  : alain greiner & joel porquet
5// Copyright (c) UPMC-LIP6
6/////////////////////////////////////////////////////////////////////////////////////////
7// The ctx_handler.h and ctx_handler.c files are part of the GIET-VM nano-kernel.
8// This code is used to support context switch when several tasks are executing
9// in time multiplexing on a single processor.
10// The tasks are statically allocated to a processor in the boot phase, and
11// there is one private scheduler per processor. Each sheduler occupies 8K bytes,
12// and contains up to 14 task contexts (task_id is from 0 to 13).
13// The task context [13] is reserved for the "idle" task that does nothing, and
14// is launched by the scheduler when there is no other runable task.
15/////////////////////////////////////////////////////////////////////////////////////////
16// A task context is an array of 64 words = 256 bytes.
17// It contains copies of processor registers (when the task is preempted)
18// and some general informations associated to a task, such as the peripherals
19// allocated to the task (private peripheral channel for multi-channels peripherals).
20/////////////////////////////////////////////////////////////////////////////////////////
21// ctx[0] <- ***   |ctx[8] <- $8     |ctx[16]<- $16   |ctx[24]<- $24
22// ctx[1] <- $1    |ctx[9] <- $9     |ctx[17]<- $17   |ctx[25]<- $25
23// ctx[2] <- $2    |ctx[10]<- $10    |ctx[18]<- $18   |ctx[26]<- LO
24// ctx[3] <- $3    |ctx[11]<- $11    |ctx[19]<- $19   |ctx[27]<- HI
25// ctx[4] <- $4    |ctx[12]<- $12    |ctx[20]<- $20   |ctx[28]<- $28
26// ctx[5] <- $5    |ctx[13]<- $13    |ctx[21]<- $21   |ctx[29]<- SP
27// ctx[6] <- $6    |ctx[14]<- $14    |ctx[22]<- $22   |ctx[30]<- $30
28// ctx[7] <- $7    |ctx[15]<- $15    |ctx[23]<- $23   |ctx[31]<- RA
29//
30// ctx[32]<- EPC   |ctx[40]<- TTY    |ctx[48]<- TRDID |ctx[56]<- ***
31// ctx[33]<- CR    |ctx[41]<- CMA_FB |ctx[49]<- GTID  |ctx[57]<- ***
32// ctx[34]<- SR    |ctx[42]<- CMA_RX |ctx[50]<- RUN   |ctx[58]<- ***
33// ctx[35]<- BVAR  |ctx[43]<- CMA_TX |ctx[51]<- ***   |ctx[59]<- ***
34// ctx[36]<- PTAB  |ctx[44]<- NIC_RX |ctx[52]<- ***   |ctx[60]<- ***
35// ctx[37]<- LTID  |ctx[45]<- NIC_TX |ctx[53]<- ***   |ctx[61]<- ***
36// ctx[38]<- VSID  |ctx[46]<- TIM    |ctx[54]<- ***   |ctx[62]<- ***
37// ctx[39]<- PTPR  |ctx[47]<- HBA    |ctx[55]<- ***   |ctx[63]<- ***
38/////////////////////////////////////////////////////////////////////////////////////////
39
40#ifndef _CTX_HANDLER_H
41#define _CTX_HANDLER_H
42
43#include <giet_config.h>
44
45/////////////////////////////////////////////////////////////////////////////////
46//    Definition of the task context slots indexes
47/////////////////////////////////////////////////////////////////////////////////
48
49#define CTX_SP_ID        29  // Stack Pointer
50#define CTX_RA_ID        31  // Return Address
51
52#define CTX_EPC_ID       32  // Exception Program Counter (CP0)
53#define CTX_CR_ID        33  // Cause Register (CP0)
54#define CTX_SR_ID        34  // Status Register (CP0)
55#define CTX_BVAR_ID      35      // Bad Virtual Address Register (CP0)
56#define CTX_PTAB_ID      36  // Page Table Virtual address
57#define CTX_LTID_ID      37  // Local  Task Index (in scheduler)
58#define CTX_VSID_ID      38  // Vspace Index     
59#define CTX_PTPR_ID      39  // Page Table Pointer Register (PADDR>>13)
60
61#define CTX_TTY_ID       40  // private TTY channel index 
62#define CTX_CMA_FB_ID    41  // private CMA channel index for FBF write
63#define CTX_CMA_RX_ID    42  // private CMA channel index for NIC_TX
64#define CTX_CMA_TX_ID    43  // private CMA channel index for NIC_RX
65#define CTX_NIC_RX_ID    44  // private NIC channel index RX transfer
66#define CTX_NIC_TX_ID    45  // private NIC channel index TX transfer
67#define CTX_TIM_ID       46  // ptivate TIM channel index
68#define CTX_HBA_ID       47  // private HBA channel index
69
70#define CTX_TRDID_ID     48  // Thread Task Index in vspace
71#define CTX_GTID_ID      49  // Global Task Index in all system
72#define CTX_RUN_ID       50  // Boolean: task runable
73
74/////////////////////////////////////////////////////////////////////////////////
75
76/////////////////////////////////////////////////////////////////////////////////
77//    Definition of the scheduler structure
78/////////////////////////////////////////////////////////////////////////////////
79
80typedef struct static_scheduler_s
81{
82    unsigned int context[14][64];      // at most 14 task (including idle_task)
83    unsigned int tasks;                // actual number of tasks
84    unsigned int current;              // current task index
85    unsigned int hwi_vector[32];       // hardware interrupt vector
86    unsigned int pti_vector[32];       // timer    interrupt vector
87    unsigned int wti_vector[32];       // software interrupt vector
88    unsigned int reserved[30];         // padding to 4 Kbytes
89    unsigned int idle_stack[1024];     // private stack for idle stack (4Kbytes)
90} static_scheduler_t;
91
92#define IDLE_TASK_INDEX        13
93
94
95/////////////////////////////////////////////////////////////////////////////////
96//                 Schedulers array
97/////////////////////////////////////////////////////////////////////////////////
98extern static_scheduler_t _scheduler[];
99
100/////////////////////////////////////////////////////////////////////////////////
101//               External Functions
102/////////////////////////////////////////////////////////////////////////////////
103
104/////////////////////////////////////////////////////////////////////////////////
105// This function performs a context switch between the running task
106// and  another task, using a round-robin sheduling policy between all
107// tasks allocated to a given processor (static allocation).
108// It selects the next runable task to resume execution.
109// If the only runable task is the current task, return without context switch.
110// If there is no runable task, the scheduler switch to the default "idle" task.
111// The return address contained in $31 is saved in the current task context
112// (in the ctx[31] slot), and the function actually returns to the address
113// contained in the ctx[31] slot of the next task context.
114/////////////////////////////////////////////////////////////////////////////////
115extern void _ctx_switch();
116
117/////////////////////////////////////////////////////////////////////////////////
118// The address of this function is used to initialise the return address
119// in the "idle" task context.
120/////////////////////////////////////////////////////////////////////////////////
121extern void _ctx_eret();
122
123/////////////////////////////////////////////////////////////////////////////////
124// This function is executed task when no other task can be executed.
125/////////////////////////////////////////////////////////////////////////////////
126extern void _idle_task();
127
128
129#endif
Note: See TracBrowser for help on using the repository browser.