Context Navigation

source: trunk/softs/giet_tsar/giet.s @ 243

Last change on this file since 243 was 158, checked in by alain, 14 years ago

Introducing the three sub-directories in the softs directory:

giet_tsar
soft_filter_giet
soft_transpose_giet

File size: 31.5 KB

Line
1	/*********************************************************************************
2	* File : giet.s
3	* Author : Franck Wajsburt & Alain Greiner & Joel Porquet
4	* Date : 2009 - 2010
5	**********************************************************************************
6	* Interruption/Exception/Trap Handler for MIPS32 processor
7	* The base address of the segment containing this code
8	* MUST be 0x80000000, in order to have the entry point
9	* at address 0x80000180 !!!
10	* All messages are printed on the TTY defined by the processor ID.
11	**********************************************************************************
12	* History :
13	* 15/09/2009 : The GIET entry point has been modified to comply with
14	* the MIPS32 specification : 0x80000180
15	* 5/10/2009 : The syscall handler has been modified to comply with the
16	* MIPS32 specification : the value stored in EPC register is the
17	* syscall instruction address => it must be incremented by 4
18	* to obtain the return address.
19	* 15/10/2009 : The Interrupt handler has been modified to comply with the
20	* VCI_ICU specification : The IRQ index is obtained by a read
21	* to (icu_base_address + 16).
22	* 26/10/2009 : The interrupt handler has been modified to support
23	* multi-processors architectures with one ICU per processor.
24	* Finally, the mfc0 instruction uses now the select parameter
25	* to comply with the MIPS32 specification when accessing the
26	* processor_id (mtfc0 $x, $15, 1)
27	* 08/11/2009 : The syscall handler has been extended to support 32 values
28	* for the syscall index, and to enable interrupts when processing
29	* a system call.
30	* Five new syscalls have been introduced to access the frame buffer
31	* Three new syscalls have been introduced to access the block device
32	* The two syscalls associated to the DMA have been removed.
33	* 18/11/2009 : The syscall handler has been modified to save the SR in
34	* the stack before enabling interrupts.
35	* 15/03/2010 : replace the itoa_print assembler function by the itoa_hex()
36	* function defined in the syscalls.c file.
37	* 10/04/2010 : modify the interrupt handler to use the new ICU component
38	* supporting up to 8 output IRQs for 8 processors.
39	* The active IRQ index is obtained as ICU[32*PROC_ID+16].
40	* 12/09/2010 : The ctx_switch functionhas been included in this file to
41	* simplify the compilation process.
42	* 25/09/2010 : add '.end' directive to end the _giet function
43	* and modify the 'sharp' comment character into the regular "slash
44	* asterix ... asterix slash" comment syntax
45	* 27/09/2010 : respect stack convention with 4 minimum slots before calling
46	* C functions
47	* 28/09/2010 : Save all the non-persistant registers in the int_handler
48	* 02/02/2011 : Introduce the "segment_increment" parameter in the interrupt
49	* handler to support clusterised multi-processing.
50	* Introducing the barrier_init() & barrier_wait() system calls.
51	* 04/04/2011 : introducing the system call proc_num()
52	* 12/04/2011 : modifying the _int_handler to support the XICU component in
53	* multi_clusters/multi-processors architectures:
54	* the XICU base address depends the cluster_id and the PRIO register
55	* address depends on the local_id.
56	**********************************************************************************/
57
58	.section .giet,"ax",@progbits
59	.align 2
60	.global _interrupt_vector # makes interrupt_vector an external symbol
61
62	.extern seg_icu_base
63	.extern seg_tty_base
64	.extern NB_CLUSTERS
65	.extern NB_PROCS
66
67	.extern isr_default
68
69	.extern _procid
70	.extern _proctime
71	.extern _tty_write
72	.extern _tty_read
73	.extern _tty_read_irq
74	.extern _timer_write
75	.extern _timer_read
76	.extern _icu_write
77	.extern _icu_read
78	.extern _gcd_write
79	.extern _gcd_read
80	.extern _locks_read
81	.extern _locks_write
82	.extern _exit
83	.extern _fb_sync_write
84	.extern _fb_sync_read
85	.extern _fb_write
86	.extern _fb_read
87	.extern _fb_completed
88	.extern _ioc_write
89	.extern _ioc_read
90	.extern _ioc_completed
91	.extern _itoa_hex
92	.extern _barrier_init
93	.extern _barrier_wait
94
95	.ent _giet
96
97	/***************************************************************
98	* Cause Table (indexed by the Cause register)
99	***************************************************************/
100	tab_causes:
101	.word _int_handler # 0000 : external interrupt
102	.word _cause_ukn # 0001 : undefined exception
103	.word _cause_ukn # 0010 : undefined exception
104	.word _cause_ukn # 0011 : undefined exception
105	.word _cause_adel # 0100 : illegal address read exception
106	.word _cause_ades # 0101 : illegal address write exception
107	.word _cause_ibe # 0110 : instruction bus error exception
108	.word _cause_dbe # 0111 : data bus error exception
109	.word _sys_handler # 1000 : system call
110	.word _cause_bp # 1001 : breakpoint exception
111	.word _cause_ri # 1010 : illegal codop exception
112	.word _cause_cpu # 1011 : illegal coprocessor access
113	.word _cause_ovf # 1100 : arithmetic overflow exception
114	.word _cause_ukn # 1101 : undefined exception
115	.word _cause_ukn # 1110 : undefined exception
116	.word _cause_ukn # 1111 : undefined exception
117
118	.space 320
119
120	/***************************************************************
121	* Entry point (at address 0x80000180)
122	***************************************************************/
123	_giet:
124	mfc0 $27, $13 # Cause Register analysis
125	lui $26, 0x8000 # $26 <= tab_causes
126	andi $27, $27, 0x3c
127	addu $26, $26, $27
128	lw $26, ($26)
129	jr $26 # Jump indexed by CR
130	.end _giet
131
132	/****************************************************************
133	* System Call Handler
134	* A system call is handled as a special function call.
135	* - $2 contains the system call index (< 16).
136	* - $3 is used to store the syscall address
137	* - $4, $5, $6, $7 contain the arguments values.
138	* - The return address (EPC) iand the SR are saved in the stack.
139	* - Interrupts are enabled before branching to the syscall.
140	* - All syscalls must return to the syscall handler.
141	* - $2, $3, $4, $5, $6, $7 as well as $26 & $27 can be modified.
142	*
143	* In case of undefined system call, an error message displays
144	* the value of EPC on the TTY corresponding to the processor,
145	* and the user program is killed.
146	****************************************************************/
147	_sys_handler:
148	addiu $29, $29, -24 # 2 slots for SR&EPC, 4 slots for args passing
149	mfc0 $26, $12 # load SR
150	sw $26, 16($29) # save it in the stack
151	mfc0 $27, $14 # load EPC
152	addiu $27, $27, 4 # increment EPC for return address
153	sw $27, 20($29) # save it in the stack
154
155	andi $26, $2, 0x1F # $26 <= syscall index (i < 32)
156	sll $26, $26, 2 # $26 <= index * 4
157	la $27, tab_syscalls # $27 <= &tab_syscalls[0]
158	addu $27, $27, $26 # $27 <= &tab_syscalls[i]
159	lw $3, 0($27) # $3 <= syscall address
160
161	li $27, 0xFFFFFFED # Mask for UM & EXL bits
162	mfc0 $26, $12 # $26 <= SR
163	and $26, $26, $27 # UM = 0 / EXL = 0
164	mtc0 $26, $12 # interrupt enabled
165	jalr $3 # jump to the proper syscall
166	mtc0 $0, $12 # interrupt disbled
167
168	lw $26, 16($29) # load SR from stack
169	mtc0 $26, $12 # restore SR
170	lw $26, 20($29) # load EPC from stack
171	mtc0 $26, $14 # restore EPC
172	addiu $29, $29, 24 # restore stack pointer
173	eret # exit GIET
174
175	_sys_ukn: # undefined system call
176	la $4, msg_uknsyscall # $4 <= message address
177	li $5, 36 # $5 <= message length
178	jal _tty_write # print unknown message
179
180	la $4, msg_epc # $4 <= message address
181	li $5, 8 # $5 <= message length
182	jal _tty_write # print EPC message
183
184	mfc0 $4, $14 # $4 <= EPC
185	la $5, itoa_buffer # $5 <= buffer address
186	addiu $5, $5, 2 # skip the 0x prefix
187	jal _itoa_hex # fill the buffer
188
189	la $4, itoa_buffer # $4 <= buffer address
190	li $5, 10 # $5 <= buffer length
191	jal _tty_write # print EPC value
192
193	j _exit # end of program
194
195	itoa_buffer: .ascii "0x00000000"
196
197	.align 2
198
199	/****************************************************************
200	* System Call Table (indexed by syscall index)
201	****************************************************************/
202	tab_syscalls:
203	.word _procid # 0x00
204	.word _proctime # 0x01
205	.word _tty_write # 0x02
206	.word _tty_read # 0x03
207	.word _timer_write # 0x04
208	.word _timer_read # 0x05
209	.word _gcd_write # 0x06
210	.word _gcd_read # 0x07
211	.word _icu_write # 0x08
212	.word _icu_read # 0x09
213	.word _tty_read_irq # 0x0A
214	.word _sys_ukn # 0x0B
215	.word _locks_write # 0x0C
216	.word _locks_read # 0x0D
217	.word _exit # 0x0E
218	.word _procnumber # 0x0F
219	.word _fb_sync_write # 0x10
220	.word _fb_sync_read # 0x11
221	.word _fb_write # 0x12
222	.word _fb_read # 0x13
223	.word _fb_completed # 0x14
224	.word _ioc_write # 0x15
225	.word _ioc_read # 0x16
226	.word _ioc_completed # 0x17
227	.word _barrier_init # 0x18
228	.word _barrier_wait # 0x19
229	.word _sys_ukn # 0x1A
230	.word _sys_ukn # 0x1B
231	.word _sys_ukn # 0x1C
232	.word _sys_ukn # 0x1D
233	.word _sys_ukn # 0x1E
234	.word _sys_ukn # 0x1F
235
236	/******************************************************************
237	* Interrupt Handler
238	* This simple interrupt handler cannot be interrupted.
239	* It uses an external ICU component (Interrupt Controler Unit)
240	* that concentrates up to 32 interrupts lines to a single IRQ
241	* line that can be connected to any of the 6 MIPS IT inputs.
242	* This component returns the highest priority active interrupt index
243	* (smaller indexes have the highest priority).
244	*
245	* In case of a multi-clusters architecture, it exist one ICU
246	* per cluster. The base address of the ICU segment depends on both
247	* the cluster_id and the proc_id:
248	* - icu_base_address = seg_icu_base + (32 * local_id) +
249	* (cluster_increment * cluster _id)
250	* - cluster_id = proc_id / NB_PROCS
251	* - local_id = proc_id % NB_PROCS
252	* - cluster_increment = 4G / NB_CLUSTERS
253	*
254	* The interrupt handler reads the XICU PRIO register,
255	* using the offset 16.
256	* This component returns the highest priority interrupt index
257	* (smaller indexes have the highest priority).
258	* Any value larger than 31 means "no active interrupt", and
259	* the default ISR (that does nothing) is executed.
260	* The interrupt vector (32 ISR addresses array stored at
261	* _interrupt_vector address) is initialised with the default
262	* ISR address. The actual ISR addresses are supposed to be written
263	* in the interrupt vector array by the boot code.
264	* All non persistant registers, such as $1 to $15, and $24 to $25,
265	* as well as register $31 and EPC, are saved in the interrupted
266	* program stack, before calling the Interrupt Service Routine.
267	* These registers can be used by the ISR code.
268	*******************************************************************/
269	_int_handler:
270	addiu $29, $29, -23*4 # stack space reservation
271	.set noat
272	sw $1, 4*4($29) # save $1
273	.set at
274	sw $2, 4*5($29) # save $2
275	sw $3, 4*6($29) # save $3
276	sw $4, 4*7($29) # save $4
277	sw $5, 4*8($29) # save $5
278	sw $6, 4*9($29) # save $6
279	sw $7, 4*10($29) # save $7
280	sw $8, 4*11($29) # save $8
281	sw $9, 4*12($29) # save $9
282	sw $10, 4*13($29) # save $10
283	sw $11, 4*14($29) # save $11
284	sw $12, 4*15($29) # save $12
285	sw $13, 4*16($29) # save $13
286	sw $14, 4*17($29) # save $14
287	sw $15, 4*18($29) # save $15
288	sw $24, 4*19($29) # save $24
289	sw $25, 4*20($29) # save $25
290	sw $31, 4*21($29) # save $31
291	mfc0 $27, $14
292	sw $27, 4*22($29) # save EPC
293
294	# XICU PRIO register address computation (depending on cluster_id & local_id)
295	mfc0 $10, $15, 1 # $10 <= proc_id
296	andi $10, $10, 0x3FF # at most 1024 processors
297	la $11, NB_PROCS # $11 <= NB_PROCS
298	divu $10, $11
299	mflo $12 # $12 <= cluster_id
300	mfhi $13 # $13 <= local_id
301	la $11, NB_CLUSTERS # $11 <= NB_CLUSTERS
302	li $14, 0x80000000
303	divu $14, $11
304	mflo $15
305	sll $15, $15, 1 # $15 <= cluster_increment = 4G / NB_CLUSTERS
306	multu $15, $12
307	mflo $6 # $6 <= cluster_increment * cluster_id
308	li $7, 0b011110000000 # $7 <= PRIO offset
309	sll $8, $13, 2 # $8 <= local_id*4
310	addu $9, $7, $8 # $9 <= PRIO offset + local_id*4
311	la $27, seg_icu_base
312	addu $26, $9, $27 # $26 <= seg_icu_base + PRIO offset + local_id*4
313	addu $26, $26, $6 # $26 <= seg_icu_base + incrementcluster_id + PRIO offset + local_id4
314
315	# XICU access and interrupt vector access
316	lw $26, ($26) # $26 <= PRIO register value
317	andi $27, $26, 0x2 # test bit HWI active
318	beq $27, $0, restore # do nothing if no active IRQ
319	srl $26, $26, 14 # $26 <= $26 >> 14
320	andi $26, $26, 0x7C # $26 <= interrupt_index * 4
321	la $27, _interrupt_vector
322	addu $26, $26, $27
323	lw $26, ($26) # read ISR address
324	jalr $26 # call ISR
325	restore:
326	.set noat
327	lw $1, 4*4($29) # restore $1
328	.set at
329	lw $2, 4*5($29) # restore $2
330	lw $3, 4*6($29) # restore $3
331	lw $4, 4*7($29) # restore $4
332	lw $5, 4*8($29) # restore $5
333	lw $6, 4*9($29) # restore $6
334	lw $7, 4*10($29) # restore $7
335	lw $8, 4*11($29) # restore $8
336	lw $9, 4*12($29) # restore $9
337	lw $10, 4*13($29) # restore $10
338	lw $11, 4*14($29) # restore $11
339	lw $12, 4*15($29) # restore $12
340	lw $13, 4*16($29) # restore $13
341	lw $14, 4*17($29) # restore $14
342	lw $15, 4*18($29) # restore $15
343	lw $24, 4*19($29) # restore $24
344	lw $25, 4*20($29) # restore $25
345	lw $31, 4*21($29) # restore $31
346	lw $27, 4*22($29) # return address (EPC)
347	addiu $29, $29, 23*4 # restore stack pointer
348	mtc0 $27, $14 # restore EPC
349	eret # exit GIET
350
351	/* The default ISR is called when no specific ISR has been installed in the
352	interrupt vector. It simply displays a message on TTY 0. */
353
354	isr_default:
355	addiu $29, $29, -20 # get space in stack
356	sw $31, 16($29) # to save the return address
357	la $4, msg_default # $4 <= string address
358	addi $5, $0, 36 # $5 <= string length
359	jal _tty_write # print
360	lw $31, 16($29) # restore return address
361	addiu $29, $29, 20 # free space
362	jr $31 # returns to interrupt handler
363
364	/*****************************************************
365	Interrupt Vector Table (indexed by interrupt index)
366	32 words corresponding to 32 ISR addresses
367	******************************************************/
368	_interrupt_vector:
369	.word isr_default # ISR 0
370	.word isr_default # ISR 1
371	.word isr_default # ISR 2
372	.word isr_default # ISR 3
373	.word isr_default # ISR 4
374	.word isr_default # ISR 5
375	.word isr_default # ISR 6
376	.word isr_default # ISR 7
377	.word isr_default # ISR 8
378	.word isr_default # ISR 9
379	.word isr_default # ISR 10
380	.word isr_default # ISR 11
381	.word isr_default # ISR 12
382	.word isr_default # ISR 13
383	.word isr_default # ISR 14
384	.word isr_default # ISR 15
385	.word isr_default # ISR 16
386	.word isr_default # ISR 17
387	.word isr_default # ISR 18
388	.word isr_default # ISR 19
389	.word isr_default # ISR 20
390	.word isr_default # ISR 21
391	.word isr_default # ISR 22
392	.word isr_default # ISR 23
393	.word isr_default # ISR 24
394	.word isr_default # ISR 25
395	.word isr_default # ISR 26
396	.word isr_default # ISR 27
397	.word isr_default # ISR 28
398	.word isr_default # ISR 29
399	.word isr_default # ISR 30
400	.word isr_default # ISR 31
401
402	/***********************************************************
403	* Exception Handler
404	* Same code for all fatal exceptions :
405	* Print the exception type and the values of EPC & BAR
406	* on the TTY correspondintg to the processor PROCID,
407	* and the user program is killed.
408	***********************************************************/
409	_cause_bp:
410	_cause_ukn:
411	_cause_ri:
412	_cause_ovf:
413	_cause_adel:
414	_cause_ades:
415	_cause_ibe:
416	_cause_dbe:
417	_cause_cpu:
418	mfc0 $26, $13 # $26 <= CR
419	andi $26, $26, 0x3C # $26 <= _cause_index * 4
420	la $27, mess_causes # mess_cause table base address
421	addu $27, $26, $27 # pointer on the message base address
422
423	lw $4, ($27) # $4 <= message address
424	li $5, 36 # $5 <= message length
425	jal _tty_write # print message cause
426
427	la $4, msg_epc # $4 <= message address
428	li $5, 8 # $5 <= message length
429	jal _tty_write # print message EPC
430
431	mfc0 $4, $14 # $4 <= EPC value
432	la $5, itoa_buffer # $5 <= buffer address
433	addiu $5, $5, 2 # skip 0x prefix
434	jal _itoa_hex # fill buffer
435
436	la $4, itoa_buffer # $4 <= buffer address
437	li $5, 10 # $5 <= buffer length
438	jal _tty_write # print EPC value
439
440	la $4, msg_bar # $4 <= mesage address
441	li $5, 8 # $5 <= message length
442	jal _tty_write # print message BAR
443
444	mfc0 $4, $8 # $4 <= BAR value
445	la $5, itoa_buffer # $5 <= buffer address
446	addiu $5, $5, 2 # skip 0x prefix
447	jal _itoa_hex # fill buffer
448
449	la $4, itoa_buffer # $4 <= mesage address
450	li $5, 10 # $5 <= message length
451	jal _tty_write # print BAR value
452
453	j _exit # end program
454
455	# Exceptions Messages table (indexed by CAUSE)
456	mess_causes:
457	.word msg_ukncause
458	.word msg_ukncause
459	.word msg_ukncause
460	.word msg_ukncause
461	.word msg_adel
462	.word msg_ades
463	.word msg_ibe
464	.word msg_dbe
465	.word msg_ukncause
466	.word msg_bp
467	.word msg_ri
468	.word msg_cpu
469	.word msg_ovf
470	.word msg_ukncause
471	.word msg_ukncause
472	.word msg_ukncause
473
474	/*****************************************************************
475	* All messages
476	* Messages length are fixed : 8 or 36 characters...
477	*****************************************************************/
478	msg_bar: .asciiz "\nBAR = "
479	msg_epc: .asciiz "\nEPC = "
480	msg_default: .asciiz "\n\n !!! Default ISR !!! \n"
481	msg_uknsyscall: .asciiz "\n\n !!! Undefined System Call !!! \n"
482	msg_ukncause: .asciiz "\n\nException : strange unknown cause\n"
483	msg_adel: .asciiz "\n\nException : illegal read address \n"
484	msg_ades: .asciiz "\n\nException : illegal write address\n"
485	msg_ibe: .asciiz "\n\nException : inst bus error \n"
486	msg_dbe: .asciiz "\n\nException : data bus error \n"
487	msg_bp: .asciiz "\n\nException : breakpoint \n"
488	msg_ri: .asciiz "\n\nException : reserved instruction \n"
489	msg_ovf: .asciiz "\n\nException : arithmetic overflow \n"
490	msg_cpu: .asciiz "\n\nException : illegal coproc access\n"
491	.align 2
492
493
494	/***************************************************************************
495	* _ctx_switch
496	* The _ctx_switch function performs a context switch between the
497	* current task and another task.
498	* It can be used in a multi-processor architecture, with the assumption
499	* that the tasks are statically allocated to processors.
500	* The max number of processorsi is 8, and the max number of tasks is 4.
501	* The scheduling policy is very simple : For each processor, the task index
502	* is incremented, modulo the number of tasks allocated to the processor.
503	*
504	* It has no argument, and no return value.
505	*
506	* It uses three global variables:
507	* - _current_task_array : an array of 8 task index:
508	* (index of the task actually running on each processor)
509	* - _task_number_array : an array of 8 numbers:
510	* (the number of tasks allocated to each processor)
511	* - _task_context_array : an array of 32 task contexts:
512	* (at most 8 processors / each processor can run up to 4 tasks)
513	* A task context is an array of 64 words = 256 bytes.
514	* It is indexed by m = (proc_id*4 + task_id)
515	* It contains copies of the processor registers.
516	* As much as possible a register is stored at the index defined by its number
517	* ( for example, $8 is saved in ctx[8]).
518	* The exception are :
519	* $0 is not saved since always 0
520	* $26, $27 are not saved since not used by the task
521	*
522	* 04(ctx) SR 84(ctx) $8 164(ctx) $16 244(ctx) $24 32*4(ctx) EPC
523	* 14(ctx) $1 94(ctx) $9 174(ctx) $17 254(ctx) $25 33*4(ctx) CR
524	* 24(ctx) $2 104(ctx) $10 184(ctx) $18 264(ctx) LO 34*4(ctx) reserved
525	* 34(ctx) $3 114(ctx) $11 194(ctx) $19 274(ctx) HI 35*4(ctx) reserved
526	* 44(ctx) $4 124(ctx) $12 204(ctx) $20 284(ctx) $28 36*4(ctx) reserved
527	* 54(ctx) $5 134(ctx) $13 214(ctx) $21 294(ctx) $29 37*4(ctx) reserved
528	* 64(ctx) $6 144(ctx) $14 224(ctx) $22 304(ctx) $30 38*4(ctx) reserved
529	* 74(ctx) $7 154(ctx) $15 234(ctx) $23 314(ctx) $31 39*4(ctx) reserved
530	*
531	* The return address contained in $31 is saved in the _current task context
532	* (in the ctx[31] slot), and the function actually returns to the address contained
533	* in the ctx[31] slot of the new task context.
534	*
535	* Caution : This function is intended to be used with periodic interrupts.
536	* It can be directly called by the OS, but interrupts must be disabled before calling.
537	***************************************************************************************/
538
539	.section .ksave
540
541	.global _task_context_array # initialised in reset.s
542	.global _current_task_array # initialised in reset.s
543	.global _task_number_array # initialised in reset.s
544
545	_task_context_array: # 32 contexts : indexed by (proc_id*4 + task_id)
546	.space 8192
547
548	_current_task_array: # 8 words : indexed by the proc_id
549	.word 0 # _current_task_array[0] <= 0
550	.word 0 # _current_task_array[1] <= 0
551	.word 0 # _current_task_array[2] <= 0
552	.word 0 # _current_task_array[3] <= 0
553	.word 0 # _current_task_array[4] <= 0
554	.word 0 # _current_task_array[5] <= 0
555	.word 0 # _current_task_array[6] <= 0
556	.word 0 # _current_task_array[7] <= 0
557
558	_task_number_array: # 8 words : indexed by the proc_id
559	.word 1 # _task_number_array[0] <= 1
560	.word 1 # _task_number_array[1] <= 1
561	.word 1 # _task_number_array[2] <= 1
562	.word 1 # _task_number_array[3] <= 1
563	.word 1 # _task_number_array[4] <= 1
564	.word 1 # _task_number_array[5] <= 1
565	.word 1 # _task_number_array[6] <= 1
566	.word 1 # _task_number_array[7] <= 1
567
568	/***************************************************************************************/
569
570	.section .switch
571
572	.global _ctx_switch # makes it an external symbol
573	.align 2
574
575	_ctx_switch:
576
577	# test if more than one task on the processor
578
579	mfc0 $26, $15, 1
580	andi $26, $26, 0x7 # $26 <= proc_id
581	sll $26, $26, 2 # $26 <= 4*proc_id
582	la $27, _task_number_array # $27 <= base address of _task_number_array
583	addu $27, $27, $26 # $27 <= _task_number_array + 4*proc_id
584	lw $27, ($27) # $27 <= task number
585	addi $26, $27, -1 # $26 <= _task_number - 1
586	bnez $26, do_it # 0 if only one task
587	jr $31 # return
588
589	# save _current task context
590
591	do_it:
592	mfc0 $26, $15, 1
593	andi $26, $26, 0x7 # $26 <= proc_id
594	sll $26, $26, 2 # $26 <= 4*proc_id
595	la $27, _current_task_array # $27 <= base address of _current_task_array
596	addu $27, $27, $26 # $27 <= _current_task_array + 4*proc_id
597	lw $26, ($27) # $26 <= current task index
598	sll $26, $26, 8 # $26 <= 256*task_id
599	la $27, _task_context_array # $27 <= base address of context array
600	addu $27, $27, $26 # $27 <= _task_context_array + 256*task_id
601	mfc0 $26, $15, 1
602	andi $26, $26, 0x7 # $26 <= proc_id
603	sll $26, $26, 10 # $26 <= 1024*proc_id
604	addu $27, $27, $26 # $27 <= taxk_context_array + 256(proc_id4 + task_id)
605
606	mfc0 $26, $12 # $26 <= SR
607	sw $26, 0*4($27) # ctx[0] <= SR
608	.set noat
609	sw $1, 1*4($27) # ctx[1] <= $1
610	.set at
611	sw $2, 2*4($27) # ctx[2] <= $2
612	sw $3, 3*4($27) # ctx[3] <= $3
613	sw $4, 4*4($27) # ctx[4] <= $4
614	sw $5, 5*4($27) # ctx[5] <= $5
615	sw $6, 6*4($27) # ctx[6] <= $6
616	sw $7, 7*4($27) # ctx[7] <= $7
617	sw $8, 8*4($27) # ctx[8] <= $8
618	sw $9, 9*4($27) # ctx[9] <= $9
619	sw $10, 10*4($27) # ctx[10] <= $10
620	sw $11, 11*4($27) # ctx[11] <= $11
621	sw $12, 12*4($27) # ctx[12] <= $12
622	sw $13, 13*4($27) # ctx[13] <= $13
623	sw $14, 14*4($27) # ctx[14] <= $14
624	sw $15, 15*4($27) # ctx[15] <= $15
625	sw $16, 16*4($27) # ctx[16] <= $16
626	sw $17, 17*4($27) # ctx[17] <= $17
627	sw $18, 18*4($27) # ctx[18] <= $18
628	sw $19, 19*4($27) # ctx[19] <= $19
629	sw $20, 20*4($27) # ctx[20] <= $20
630	sw $21, 21*4($27) # ctx[21] <= $21
631	sw $22, 22*4($27) # ctx[22] <= $22
632	sw $23, 23*4($27) # ctx[23] <= $23
633	sw $24, 24*4($27) # ctx[24] <= $24
634	sw $25, 25*4($27) # ctx[25] <= $25
635	mflo $26
636	sw $26, 26*4($27) # ctx[26] <= LO
637	mfhi $26
638	sw $26, 27*4($27) # ctx[27] <= H1
639	sw $28, 28*4($27) # ctx[28] <= $28
640	sw $29, 29*4($27) # ctx[29] <= $29
641	sw $30, 30*4($27) # ctx[30] <= $30
642	sw $31, 31*4($27) # ctx[31] <= $31
643	mfc0 $26, $14
644	sw $26, 32*4($27) # ctx[32] <= EPC
645	mfc0 $26, $13
646	sw $26, 33*4($27) # ctx[33] <= CR
647
648	# select the new task
649
650	mfc0 $15, $15, 1
651	andi $15, $15, 0x7 # $15 <= proc_id
652	sll $16, $15, 2 # $16 <= 4*proc_id
653	la $17, _current_task_array # $17 <= base address of _current_task_array
654	addu $17, $17, $16 # $17 <= _current_task_array + 4*proc_id
655	lw $18, ($17) # $18 <= _current task index
656	la $19, _task_number_array # $19 <= base address of _task_number_array
657	addu $19, $19, $16 # $19 <= _task_number_array + 4*proc_id
658	lw $20, ($19) # $20 <= max = number of tasks
659	addiu $18, $18, 1 # $18 <= new task index
660	sub $2, $18, $20 # test modulo max
661	bne $2, $0, no_wrap
662	add $18, $0, $0 # $18 <= new task index
663	no_wrap:
664	sw $18, ($17) # update _current_task_array
665
666	# restore next task context
667
668	sll $19, $18, 8 # $19 <= 256*task_id
669	la $27, _task_context_array # $27 <= base address of context array
670	addu $27, $27, $19 # $27 <= _task_context_array + 256*task_id
671	sll $19, $15, 10 # $19 <= 1024*proc_id
672	addu $27, $27, $19 # $27 <= _task_context_array + 256(proc_id4 + task_id)
673
674	lw $26, 0*4($27)
675	mtc0 $26, $12 # restore SR
676	.set noat
677	lw $1, 1*4($27) # restore $1
678	.set at
679	lw $2, 2*4($27) # restore $2
680	lw $3, 3*4($27) # restore $3
681	lw $4, 4*4($27) # restore $4
682	lw $5, 5*4($27) # restore $5
683	lw $6, 6*4($27) # restore $6
684	lw $7, 7*4($27) # restore $7
685	lw $8, 8*4($27) # restore $8
686	lw $9, 9*4($27) # restore $9
687	lw $10, 10*4($27) # restore $10
688	lw $11, 11*4($27) # restore $11
689	lw $12, 12*4($27) # restore $12
690	lw $13, 13*4($27) # restore $13
691	lw $14, 14*4($27) # restore $14
692	lw $15, 15*4($27) # restore $15
693	lw $16, 16*4($27) # restore $16
694	lw $17, 17*4($27) # restore $17
695	lw $18, 18*4($27) # restore $18
696	lw $19, 19*4($27) # restore $19
697	lw $20, 20*4($27) # restore $20
698	lw $21, 21*4($27) # restore $21
699	lw $22, 22*4($27) # restore $22
700	lw $23, 23*4($27) # restore $23
701	lw $24, 24*4($27) # restore $24
702	lw $25, 25*4($27) # restore $25
703	lw $26, 26*4($27)
704	mtlo $26 # restore LO
705	lw $26, 27*4($27)
706	mthi $26 # restore HI
707	lw $28, 28*4($27) # restore $28
708	lw $29, 29*4($27) # restore $29
709	lw $30, 30*4($27) # restore $30
710	lw $31, 31*4($27) # restore $31
711	lw $26, 32*4($27)
712	mtc0 $26, $14 # restore EPC
713	lw $26, 33*4($27)
714	mtc0 $26, $13 # restore CR
715
716	jr $31 # returns to caller
717
718	/* Local Variables:
719	tab-width: 4;
720	c-basic-offset: 4;
721	c-file-offsets:((innamespace . 0)(inline-open . 0));
722	indent-tabs-mode: nil;
723	End: */
724
725	/* vim: set filetype=asm expandtab shiftwidth=4 tabstop=4 softtabstop=4: */
726

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Project-Id-Version: Trac 0.12
Report-Msgid-Bugs-To: trac-dev@googlegroups.com
POT-Creation-Date: 2018-07-07 16:55+0000
PO-Revision-Date: 2010-07-19 23:05+0200
Last-Translator: Jeroen Ruigrok van der Werven <asmodai@in-nomine.org>
Language: en_US
Language-Team: en_US <trac-dev@googlegroups.com>
Plural-Forms: nplurals=2; plural=(n != 1)
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Generated-By: Babel 2.8.0