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

Last change on this file since 766 was 760, checked in by alain, 9 years ago
  • Property svn:executable set to *
File size: 8.4 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 threads are executing
9// in time multiplexing on a single processor.
10// The threads 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 thread contexts (thread_id is from 0 to 13).
13// The thread context [13] is reserved for the "idle" thread that is
14// launched by the scheduler when there is no other runable thread.
15/////////////////////////////////////////////////////////////////////////////////
16// A thread context is an array of 64 uint32 words => 256 bytes.
17// It contains copies of processor registers (when the thread is preempted)
18// and some general informations associated to a thread, such as the private
19// peripheral channels allocated to the thread, the vspace index, the two
20// thread index, and the runnable status.
21/////////////////////////////////////////////////////////////////////////////////
22// ctx[0] <- ***   |ctx[8] <- $8     |ctx[16]<- $16    |ctx[24]<- $24
23// ctx[1] <- $1    |ctx[9] <- $9     |ctx[17]<- $17    |ctx[25]<- $25
24// ctx[2] <- $2    |ctx[10]<- $10    |ctx[18]<- $18    |ctx[26]<- LO
25// ctx[3] <- $3    |ctx[11]<- $11    |ctx[19]<- $19    |ctx[27]<- HI
26// ctx[4] <- A0    |ctx[12]<- $12    |ctx[20]<- $20    |ctx[28]<- $28
27// ctx[5] <- A1    |ctx[13]<- $13    |ctx[21]<- $21    |ctx[29]<- SP
28// ctx[6] <- A2    |ctx[14]<- $14    |ctx[22]<- $22    |ctx[30]<- $30
29// ctx[7] <- A3    |ctx[15]<- $15    |ctx[23]<- $23    |ctx[31]<- RA
30//
31// ctx[32]<- EPC   |ctx[40]<- TTY    |ctx[48]<- TRDID  |ctx[56]<- ***
32// ctx[33]<- CR    |ctx[41]<- CMA_FB |ctx[49]<- LTID   |ctx[57]<- ***
33// ctx[34]<- SR    |ctx[42]<- CMA_RX |ctx[50]<- NORUN  |ctx[58]<- ***
34// ctx[35]<- BVAR  |ctx[43]<- CMA_TX |ctx[51]<- COPROC |ctx[59]<- ***
35// ctx[36]<- PTAB  |ctx[44]<- NIC_RX |ctx[52]<- ENTRY  |ctx[60]<- ***
36// ctx[37]<- NPT2  |ctx[45]<- NIC_TX |ctx[53]<- SIGS   |ctx[61]<- ***
37// ctx[38]<- ***   |ctx[46]<- TIM    |ctx[54]<- VSID   |ctx[62]<- ***
38// ctx[39]<- PTPR  |ctx[47]<- HBA    |ctx[55]<- LOCKS  |ctx[63]<- ***
39/////////////////////////////////////////////////////////////////////////////////
40
41#ifndef _CTX_HANDLER_H
42#define _CTX_HANDLER_H
43
44#include <giet_config.h>
45
46/////////////////////////////////////////////////////////////////////////////////
47//    Definition of some thread context slots indexes
48/////////////////////////////////////////////////////////////////////////////////
49
50#define CTX_A0_ID        4     // Argument 0
51#define CTX_A1_ID        5     // Argument 1
52#define CTX_A2_ID        6     // Argument 2
53#define CTX_A3_ID        7     // Argument 3
54
55#define CTX_SP_ID        29    // Stack Pointer
56#define CTX_RA_ID        31    // Return Address
57
58#define CTX_EPC_ID       32    // Exception Program Counter (CP0)
59#define CTX_CR_ID        33    // Cause Register (CP0)
60#define CTX_SR_ID        34    // Status Register (CP0)
61#define CTX_BVAR_ID      35        // Bad Virtual Address Register (CP0)
62#define CTX_PTAB_ID      36    // Page Table Virtual address
63#define CTX_NPT2_ID      37    // Next free PT2 index
64//                       38
65#define CTX_PTPR_ID      39    // Page Table Pointer Register (PADDR>>13)
66
67#define CTX_TTY_ID       40    // private TTY channel index 
68#define CTX_CMA_FB_ID    41    // private CMA channel index for FBF write
69#define CTX_CMA_RX_ID    42    // private CMA channel index for NIC_TX
70#define CTX_CMA_TX_ID    43    // private CMA channel index for NIC_RX
71#define CTX_NIC_RX_ID    44    // private NIC channel index RX transfer
72#define CTX_NIC_TX_ID    45    // private NIC channel index TX transfer
73#define CTX_TIM_ID       46    // ptivate TIM channel index
74#define CTX_HBA_ID       47    // private HBA channel index
75
76#define CTX_TRDID_ID     48    // Global Thread Index ( x | y | p | ltid )
77#define CTX_LTID_ID      49    // Local Thread Index in scheduler
78#define CTX_NORUN_ID     50    // bit-vector : thread runable if all zero
79#define CTX_COPROC_ID    51    // coprocessor coordinates (cluster_xy)
80#define CTX_ENTRY_ID     52    // Virtual address of thread entry point
81#define CTX_SIGS_ID      53    // bit-vector : pending signals
82#define CTX_VSID_ID      54    // Vspace Index     
83#define CTX_LOCKS_ID     55    // bit-vector : kernel locks taken
84
85/////////////////////////////////////////////////////////////////////////////////
86//    Definition of the NORUN bit-vector masks
87/////////////////////////////////////////////////////////////////////////////////
88
89#define NORUN_MASK_THREAD     0x00000001   // Task not active 
90#define NORUN_MASK_IOC        0x00000002   // Task blocked on IOC transfer
91#define NORUN_MASK_COPROC     0x00000004   // Task blocked on COPROC transfer
92#define NORUN_MASK_TTY        0x00000008   // Task blocked on TTY_RX transfer
93
94/////////////////////////////////////////////////////////////////////////////////
95//    Definition of the SIGS bit-vector masks
96/////////////////////////////////////////////////////////////////////////////////
97
98#define SIGS_MASK_KILL        0x00000001   // Task desactivated at next tick
99
100/////////////////////////////////////////////////////////////////////////////////
101//    Definition of the LOCKS bit-vector masks
102/////////////////////////////////////////////////////////////////////////////////
103
104#define LOCKS_MASK_BDV        0x00000001   // BDV kernel lock taken
105#define LOCKS_MASK_FAT        0x00000002   // FAT kernel lock taken
106#define LOCKS_MASK_FBF        0x00000004   // FBF kernel lock taken
107
108/////////////////////////////////////////////////////////////////////////////////
109//    Task context and  scheduler structures
110/////////////////////////////////////////////////////////////////////////////////
111
112typedef struct thread_context_s             // 256 bytes
113{
114    unsigned int slot[64];     
115} thread_context_t;
116
117
118typedef struct static_scheduler_s           // 8 Kbytes
119{
120    thread_context_t  context[14];          // at most 14 threads (including idle_thread)
121    unsigned int      threads;              // actual number of allocated threads
122    unsigned int      current;              // current thread index
123    unsigned int      hwi_vector[32];       // hardware interrupt vector
124    unsigned int      pti_vector[32];       // timer    interrupt vector
125    unsigned int      wti_vector[32];       // software interrupt vector
126    unsigned int      reserved[30];         // padding to 4 Kbytes
127    unsigned int      idle_stack[1024];     // private stack for idle stack (4Kbytes)
128} static_scheduler_t;
129
130#define IDLE_THREAD_INDEX        13
131
132
133/////////////////////////////////////////////////////////////////////////////////
134//               Extern Functions
135/////////////////////////////////////////////////////////////////////////////////
136
137/////////////////////////////////////////////////////////////////////////////////
138// This function performs a context switch between the running thread
139// and  another thread, using a round-robin sheduling policy between all
140// threads allocated to a given processor (static allocation).
141// It selects the next runable thread to resume execution.
142// If the only runable thread is the current thread, return without context switch.
143// If there is no runable thread, the scheduler switch to the default "idle" thread.
144// The return address contained in $31 is saved in the current thread context
145// (in the ctx[31] slot), and the function actually returns to the address
146// contained in the ctx[31] slot of the next thread context.
147/////////////////////////////////////////////////////////////////////////////////
148extern void _ctx_switch();
149
150/////////////////////////////////////////////////////////////////////////////////
151// The address of this function is used to initialise the return address
152// in the "idle" thread context.
153/////////////////////////////////////////////////////////////////////////////////
154extern void _ctx_eret();
155
156/////////////////////////////////////////////////////////////////////////////////
157// This function is executed thread when no other thread can be executed.
158/////////////////////////////////////////////////////////////////////////////////
159extern void _idle_thread();
160
161#endif
Note: See TracBrowser for help on using the repository browser.