source: rtems/cpukit/score/cpu/powerpc/include/rtems/score/cpu.h @ 27bbc05

Last change on this file since 27bbc05 was 27bbc05, checked in by Sebastian Huber <sebastian.huber@…>, on Aug 2, 2018 at 12:49:01 PM

score: Remove CPU_PARTITION_ALIGNMENT

Use the CPU_SIZEOF_POINTER alignment instead. The internal alignment
requirement is defined by the use of Chain_Node (consisting of two
pointers) to manage the free chain of partitions.

It seems that previously the condition

CPU_PARTITION_ALIGNMENT >= sizeof(Chain_Node)

was true on all CPU ports. Now, we need an additional check.

Update #3482.

  • Property mode set to 100644
File size: 34.4 KB
Line 
1/**
2 * @file
3 *
4 * @brief PowerPC CPU Department Source
5 */
6
7/*
8 *  COPYRIGHT (c) 1989-2012.
9 *  On-Line Applications Research Corporation (OAR).
10 *
11 *  COPYRIGHT (c) 1995 i-cubed ltd.
12 *
13 *  To anyone who acknowledges that this file is provided "AS IS"
14 *  without any express or implied warranty:
15 *      permission to use, copy, modify, and distribute this file
16 *      for any purpose is hereby granted without fee, provided that
17 *      the above copyright notice and this notice appears in all
18 *      copies, and that the name of i-cubed limited not be used in
19 *      advertising or publicity pertaining to distribution of the
20 *      software without specific, written prior permission.
21 *      i-cubed limited makes no representations about the suitability
22 *      of this software for any purpose.
23 *
24 *  Copyright (c) 2001 Andy Dachs <a.dachs@sstl.co.uk>.
25 *
26 *  Copyright (c) 2001 Surrey Satellite Technology Limited (SSTL).
27 *
28 *  Copyright (c) 2010, 2017 embedded brains GmbH.
29 *
30 *  The license and distribution terms for this file may be
31 *  found in the file LICENSE in this distribution or at
32 *  http://www.rtems.org/license/LICENSE.
33 */
34
35#ifndef _RTEMS_SCORE_CPU_H
36#define _RTEMS_SCORE_CPU_H
37
38#include <rtems/score/basedefs.h>
39#if defined(RTEMS_PARAVIRT)
40#include <rtems/score/paravirt.h>
41#endif
42#include <rtems/score/powerpc.h>
43#include <rtems/powerpc/registers.h>
44
45#ifndef ASM
46  #include <string.h> /* for memset() */
47#endif
48
49#ifdef __cplusplus
50extern "C" {
51#endif
52
53/* conditional compilation parameters */
54
55/*
56 *  Does this port provide a CPU dependent IDLE task implementation?
57 *
58 *  If TRUE, then the routine _CPU_Thread_Idle_body
59 *  must be provided and is the default IDLE thread body instead of
60 *  _CPU_Thread_Idle_body.
61 *
62 *  If FALSE, then use the generic IDLE thread body if the BSP does
63 *  not provide one.
64 *
65 *  This is intended to allow for supporting processors which have
66 *  a low power or idle mode.  When the IDLE thread is executed, then
67 *  the CPU can be powered down.
68 *
69 *  The order of precedence for selecting the IDLE thread body is:
70 *
71 *    1.  BSP provided
72 *    2.  CPU dependent (if provided)
73 *    3.  generic (if no BSP and no CPU dependent)
74 */
75
76#define CPU_PROVIDES_IDLE_THREAD_BODY    FALSE
77
78/*
79 *  Does the stack grow up (toward higher addresses) or down
80 *  (toward lower addresses)?
81 *
82 *  If TRUE, then the grows upward.
83 *  If FALSE, then the grows toward smaller addresses.
84 */
85
86#define CPU_STACK_GROWS_UP               FALSE
87
88#define CPU_CACHE_LINE_BYTES PPC_STRUCTURE_ALIGNMENT
89
90#define CPU_STRUCTURE_ALIGNMENT RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES )
91
92/*
93 *  Does the CPU have hardware floating point?
94 *
95 *  If TRUE, then the RTEMS_FLOATING_POINT task attribute is supported.
96 *  If FALSE, then the RTEMS_FLOATING_POINT task attribute is ignored.
97 *
98 *  If there is a FP coprocessor such as the i387 or mc68881, then
99 *  the answer is TRUE.
100 *
101 *  The macro name "PPC_HAS_FPU" should be made CPU specific.
102 *  It indicates whether or not this CPU model has FP support.  For
103 *  example, it would be possible to have an i386_nofp CPU model
104 *  which set this to false to indicate that you have an i386 without
105 *  an i387 and wish to leave floating point support out of RTEMS.
106 */
107
108#if ( PPC_HAS_FPU == 1 )
109#define CPU_HARDWARE_FP     TRUE
110#define CPU_SOFTWARE_FP     FALSE
111#else
112#define CPU_HARDWARE_FP     FALSE
113#define CPU_SOFTWARE_FP     FALSE
114#endif
115
116/*
117 *  Are all tasks RTEMS_FLOATING_POINT tasks implicitly?
118 *
119 *  If TRUE, then the RTEMS_FLOATING_POINT task attribute is assumed.
120 *  If FALSE, then the RTEMS_FLOATING_POINT task attribute is followed.
121 *
122 *  If CPU_HARDWARE_FP is FALSE, then this should be FALSE as well.
123 *
124 *  PowerPC Note: It appears the GCC can implicitly generate FPU
125 *  and Altivec instructions when you least expect them.  So make
126 *  all tasks floating point.
127 */
128
129#define CPU_ALL_TASKS_ARE_FP CPU_HARDWARE_FP
130
131/*
132 *  Should the IDLE task have a floating point context?
133 *
134 *  If TRUE, then the IDLE task is created as a RTEMS_FLOATING_POINT task
135 *  and it has a floating point context which is switched in and out.
136 *  If FALSE, then the IDLE task does not have a floating point context.
137 *
138 *  Setting this to TRUE negatively impacts the time required to preempt
139 *  the IDLE task from an interrupt because the floating point context
140 *  must be saved as part of the preemption.
141 */
142
143#define CPU_IDLE_TASK_IS_FP      FALSE
144
145#define CPU_MAXIMUM_PROCESSORS 32
146
147/*
148 *  Processor defined structures required for cpukit/score.
149 */
150
151/*
152 * Contexts
153 *
154 *  Generally there are 2 types of context to save.
155 *     1. Interrupt registers to save
156 *     2. Task level registers to save
157 *
158 *  This means we have the following 3 context items:
159 *     1. task level context stuff::  Context_Control
160 *     2. floating point task stuff:: Context_Control_fp
161 *     3. special interrupt level context :: Context_Control_interrupt
162 *
163 *  On some processors, it is cost-effective to save only the callee
164 *  preserved registers during a task context switch.  This means
165 *  that the ISR code needs to save those registers which do not
166 *  persist across function calls.  It is not mandatory to make this
167 *  distinctions between the caller/callee saves registers for the
168 *  purpose of minimizing context saved during task switch and on interrupts.
169 *  If the cost of saving extra registers is minimal, simplicity is the
170 *  choice.  Save the same context on interrupt entry as for tasks in
171 *  this case.
172 *
173 *  Additionally, if gdb is to be made aware of RTEMS tasks for this CPU, then
174 *  care should be used in designing the context area.
175 *
176 *  On some CPUs with hardware floating point support, the Context_Control_fp
177 *  structure will not be used or it simply consist of an array of a
178 *  fixed number of bytes.   This is done when the floating point context
179 *  is dumped by a "FP save context" type instruction and the format
180 *  is not really defined by the CPU.  In this case, there is no need
181 *  to figure out the exact format -- only the size.  Of course, although
182 *  this is enough information for RTEMS, it is probably not enough for
183 *  a debugger such as gdb.  But that is another problem.
184 */
185
186#ifndef __SPE__
187  #define PPC_GPR_TYPE uintptr_t
188  #if defined(__powerpc64__)
189    #define PPC_GPR_SIZE 8
190    #define PPC_GPR_LOAD ld
191    #define PPC_GPR_STORE std
192  #else
193    #define PPC_GPR_SIZE 4
194    #define PPC_GPR_LOAD lwz
195    #define PPC_GPR_STORE stw
196  #endif
197#else
198  #define PPC_GPR_TYPE uint64_t
199  #define PPC_GPR_SIZE 8
200  #define PPC_GPR_LOAD evldd
201  #define PPC_GPR_STORE evstdd
202#endif
203
204#if defined(__powerpc64__)
205  #define PPC_REG_SIZE 8
206  #define PPC_REG_LOAD ld
207  #define PPC_REG_STORE std
208  #define PPC_REG_STORE_UPDATE stdu
209  #define PPC_REG_CMP cmpd
210#else
211  #define PPC_REG_SIZE 4
212  #define PPC_REG_LOAD lwz
213  #define PPC_REG_STORE stw
214  #define PPC_REG_STORE_UPDATE stwu
215  #define PPC_REG_CMP cmpw
216#endif
217
218#ifndef ASM
219
220/*
221 * Non-volatile context according to E500ABIUG, EABI and 32-bit TLS (according
222 * to "Power Architecture 32-bit Application Binary Interface Supplement 1.0 -
223 * Linux and Embedded")
224 */
225typedef struct {
226  uint32_t msr;
227  uint32_t cr;
228  uintptr_t gpr1;
229  uintptr_t lr;
230  PPC_GPR_TYPE gpr14;
231  PPC_GPR_TYPE gpr15;
232  PPC_GPR_TYPE gpr16;
233  PPC_GPR_TYPE gpr17;
234  PPC_GPR_TYPE gpr18;
235  PPC_GPR_TYPE gpr19;
236  PPC_GPR_TYPE gpr20;
237  PPC_GPR_TYPE gpr21;
238  PPC_GPR_TYPE gpr22;
239  PPC_GPR_TYPE gpr23;
240  PPC_GPR_TYPE gpr24;
241  PPC_GPR_TYPE gpr25;
242  PPC_GPR_TYPE gpr26;
243  PPC_GPR_TYPE gpr27;
244  PPC_GPR_TYPE gpr28;
245  PPC_GPR_TYPE gpr29;
246  PPC_GPR_TYPE gpr30;
247  PPC_GPR_TYPE gpr31;
248  uint32_t isr_dispatch_disable;
249  uint32_t reserved_for_alignment;
250  #if defined(PPC_MULTILIB_ALTIVEC)
251    uint8_t v20[16];
252    uint8_t v21[16];
253    uint8_t v22[16];
254    uint8_t v23[16];
255    uint8_t v24[16];
256    uint8_t v25[16];
257    uint8_t v26[16];
258    uint8_t v27[16];
259    uint8_t v28[16];
260    uint8_t v29[16];
261    uint8_t v30[16];
262    uint8_t v31[16];
263    uint32_t vrsave;
264  #elif defined(__ALTIVEC__)
265    /*
266     * 12 non-volatile vector registers, cache-aligned area for vscr/vrsave
267     * and padding to ensure cache-alignment.  Unfortunately, we can't verify
268     * the cache line size here in the cpukit but altivec support code will
269     * produce an error if this is ever different from 32 bytes.
270     *
271     * Note: it is the BSP/CPU-support's responsibility to save/restore
272     *       volatile vregs across interrupts and exceptions.
273     */
274    uint8_t altivec[16*12 + 32 + PPC_DEFAULT_CACHE_LINE_SIZE];
275  #endif
276  #if defined(PPC_MULTILIB_FPU)
277    double f14;
278    double f15;
279    double f16;
280    double f17;
281    double f18;
282    double f19;
283    double f20;
284    double f21;
285    double f22;
286    double f23;
287    double f24;
288    double f25;
289    double f26;
290    double f27;
291    double f28;
292    double f29;
293    double f30;
294    double f31;
295  #endif
296  /*
297   * The following items are at the structure end, so that we can use dcbz for
298   * the previous items to optimize the context switch.  We must not set the
299   * following items to zero via the dcbz.
300   */
301  uintptr_t tp;
302  #if defined(RTEMS_SMP)
303    volatile uint32_t is_executing;
304  #endif
305} ppc_context;
306
307typedef struct {
308  uint8_t context [
309    PPC_DEFAULT_CACHE_LINE_SIZE
310      + sizeof(ppc_context)
311      + (sizeof(ppc_context) % PPC_DEFAULT_CACHE_LINE_SIZE == 0
312        ? 0
313          : PPC_DEFAULT_CACHE_LINE_SIZE
314            - sizeof(ppc_context) % PPC_DEFAULT_CACHE_LINE_SIZE)
315  ];
316} Context_Control;
317
318static inline ppc_context *ppc_get_context( const Context_Control *context )
319{
320  uintptr_t clsz = PPC_DEFAULT_CACHE_LINE_SIZE;
321  uintptr_t mask = clsz - 1;
322  uintptr_t addr = (uintptr_t) context;
323
324  return (ppc_context *) ((addr & ~mask) + clsz);
325}
326
327#define _CPU_Context_Get_SP( _context ) \
328  ppc_get_context(_context)->gpr1
329
330#ifdef RTEMS_SMP
331  static inline bool _CPU_Context_Get_is_executing(
332    const Context_Control *context
333  )
334  {
335    return ppc_get_context(context)->is_executing;
336  }
337
338  static inline void _CPU_Context_Set_is_executing(
339    Context_Control *context,
340    bool is_executing
341  )
342  {
343    ppc_get_context(context)->is_executing = is_executing;
344  }
345#endif
346#endif /* ASM */
347
348#define PPC_CONTEXT_OFFSET_MSR (PPC_DEFAULT_CACHE_LINE_SIZE)
349#define PPC_CONTEXT_OFFSET_CR (PPC_DEFAULT_CACHE_LINE_SIZE + 4)
350#define PPC_CONTEXT_OFFSET_GPR1 (PPC_DEFAULT_CACHE_LINE_SIZE + 8)
351#define PPC_CONTEXT_OFFSET_LR (PPC_DEFAULT_CACHE_LINE_SIZE + PPC_REG_SIZE + 8)
352
353#define PPC_CONTEXT_GPR_OFFSET( gpr ) \
354  (((gpr) - 14) * PPC_GPR_SIZE + \
355    PPC_DEFAULT_CACHE_LINE_SIZE + 8 + 2 * PPC_REG_SIZE)
356
357#define PPC_CONTEXT_OFFSET_GPR14 PPC_CONTEXT_GPR_OFFSET( 14 )
358#define PPC_CONTEXT_OFFSET_GPR15 PPC_CONTEXT_GPR_OFFSET( 15 )
359#define PPC_CONTEXT_OFFSET_GPR16 PPC_CONTEXT_GPR_OFFSET( 16 )
360#define PPC_CONTEXT_OFFSET_GPR17 PPC_CONTEXT_GPR_OFFSET( 17 )
361#define PPC_CONTEXT_OFFSET_GPR18 PPC_CONTEXT_GPR_OFFSET( 18 )
362#define PPC_CONTEXT_OFFSET_GPR19 PPC_CONTEXT_GPR_OFFSET( 19 )
363#define PPC_CONTEXT_OFFSET_GPR20 PPC_CONTEXT_GPR_OFFSET( 20 )
364#define PPC_CONTEXT_OFFSET_GPR21 PPC_CONTEXT_GPR_OFFSET( 21 )
365#define PPC_CONTEXT_OFFSET_GPR22 PPC_CONTEXT_GPR_OFFSET( 22 )
366#define PPC_CONTEXT_OFFSET_GPR23 PPC_CONTEXT_GPR_OFFSET( 23 )
367#define PPC_CONTEXT_OFFSET_GPR24 PPC_CONTEXT_GPR_OFFSET( 24 )
368#define PPC_CONTEXT_OFFSET_GPR25 PPC_CONTEXT_GPR_OFFSET( 25 )
369#define PPC_CONTEXT_OFFSET_GPR26 PPC_CONTEXT_GPR_OFFSET( 26 )
370#define PPC_CONTEXT_OFFSET_GPR27 PPC_CONTEXT_GPR_OFFSET( 27 )
371#define PPC_CONTEXT_OFFSET_GPR28 PPC_CONTEXT_GPR_OFFSET( 28 )
372#define PPC_CONTEXT_OFFSET_GPR29 PPC_CONTEXT_GPR_OFFSET( 29 )
373#define PPC_CONTEXT_OFFSET_GPR30 PPC_CONTEXT_GPR_OFFSET( 30 )
374#define PPC_CONTEXT_OFFSET_GPR31 PPC_CONTEXT_GPR_OFFSET( 31 )
375#define PPC_CONTEXT_OFFSET_ISR_DISPATCH_DISABLE PPC_CONTEXT_GPR_OFFSET( 32 )
376
377#ifdef PPC_MULTILIB_ALTIVEC
378  #define PPC_CONTEXT_OFFSET_V( v ) \
379    ( ( ( v ) - 20 ) * 16 + PPC_CONTEXT_OFFSET_ISR_DISPATCH_DISABLE + 8)
380  #define PPC_CONTEXT_OFFSET_V20 PPC_CONTEXT_OFFSET_V( 20 )
381  #define PPC_CONTEXT_OFFSET_V21 PPC_CONTEXT_OFFSET_V( 21 )
382  #define PPC_CONTEXT_OFFSET_V22 PPC_CONTEXT_OFFSET_V( 22 )
383  #define PPC_CONTEXT_OFFSET_V23 PPC_CONTEXT_OFFSET_V( 23 )
384  #define PPC_CONTEXT_OFFSET_V24 PPC_CONTEXT_OFFSET_V( 24 )
385  #define PPC_CONTEXT_OFFSET_V25 PPC_CONTEXT_OFFSET_V( 25 )
386  #define PPC_CONTEXT_OFFSET_V26 PPC_CONTEXT_OFFSET_V( 26 )
387  #define PPC_CONTEXT_OFFSET_V27 PPC_CONTEXT_OFFSET_V( 27 )
388  #define PPC_CONTEXT_OFFSET_V28 PPC_CONTEXT_OFFSET_V( 28 )
389  #define PPC_CONTEXT_OFFSET_V29 PPC_CONTEXT_OFFSET_V( 29 )
390  #define PPC_CONTEXT_OFFSET_V30 PPC_CONTEXT_OFFSET_V( 30 )
391  #define PPC_CONTEXT_OFFSET_V31 PPC_CONTEXT_OFFSET_V( 31 )
392  #define PPC_CONTEXT_OFFSET_VRSAVE PPC_CONTEXT_OFFSET_V( 32 )
393  #define PPC_CONTEXT_OFFSET_F( f ) \
394    ( ( ( f ) - 14 ) * 8 + PPC_CONTEXT_OFFSET_VRSAVE + 8 )
395#else
396  #define PPC_CONTEXT_OFFSET_F( f ) \
397    ( ( ( f ) - 14 ) * 8 + PPC_CONTEXT_OFFSET_ISR_DISPATCH_DISABLE + 8 )
398#endif
399
400#ifdef PPC_MULTILIB_FPU
401  #define PPC_CONTEXT_OFFSET_F14 PPC_CONTEXT_OFFSET_F( 14 )
402  #define PPC_CONTEXT_OFFSET_F15 PPC_CONTEXT_OFFSET_F( 15 )
403  #define PPC_CONTEXT_OFFSET_F16 PPC_CONTEXT_OFFSET_F( 16 )
404  #define PPC_CONTEXT_OFFSET_F17 PPC_CONTEXT_OFFSET_F( 17 )
405  #define PPC_CONTEXT_OFFSET_F18 PPC_CONTEXT_OFFSET_F( 18 )
406  #define PPC_CONTEXT_OFFSET_F19 PPC_CONTEXT_OFFSET_F( 19 )
407  #define PPC_CONTEXT_OFFSET_F20 PPC_CONTEXT_OFFSET_F( 20 )
408  #define PPC_CONTEXT_OFFSET_F21 PPC_CONTEXT_OFFSET_F( 21 )
409  #define PPC_CONTEXT_OFFSET_F22 PPC_CONTEXT_OFFSET_F( 22 )
410  #define PPC_CONTEXT_OFFSET_F23 PPC_CONTEXT_OFFSET_F( 23 )
411  #define PPC_CONTEXT_OFFSET_F24 PPC_CONTEXT_OFFSET_F( 24 )
412  #define PPC_CONTEXT_OFFSET_F25 PPC_CONTEXT_OFFSET_F( 25 )
413  #define PPC_CONTEXT_OFFSET_F26 PPC_CONTEXT_OFFSET_F( 26 )
414  #define PPC_CONTEXT_OFFSET_F27 PPC_CONTEXT_OFFSET_F( 27 )
415  #define PPC_CONTEXT_OFFSET_F28 PPC_CONTEXT_OFFSET_F( 28 )
416  #define PPC_CONTEXT_OFFSET_F29 PPC_CONTEXT_OFFSET_F( 29 )
417  #define PPC_CONTEXT_OFFSET_F30 PPC_CONTEXT_OFFSET_F( 30 )
418  #define PPC_CONTEXT_OFFSET_F31 PPC_CONTEXT_OFFSET_F( 31 )
419#endif
420
421#if defined(PPC_MULTILIB_FPU)
422  #define PPC_CONTEXT_VOLATILE_SIZE PPC_CONTEXT_OFFSET_F( 32 )
423#elif defined(PPC_MULTILIB_ALTIVEC)
424  #define PPC_CONTEXT_VOLATILE_SIZE (PPC_CONTEXT_OFFSET_VRSAVE + 4)
425#elif defined(__ALTIVEC__)
426  #define PPC_CONTEXT_VOLATILE_SIZE \
427    (PPC_CONTEXT_GPR_OFFSET( 32 ) + 8 \
428      + 16 * 12 + 32 + PPC_DEFAULT_CACHE_LINE_SIZE)
429#else
430  #define PPC_CONTEXT_VOLATILE_SIZE (PPC_CONTEXT_GPR_OFFSET( 32 ) + 8)
431#endif
432
433#define PPC_CONTEXT_OFFSET_TP PPC_CONTEXT_VOLATILE_SIZE
434
435#ifdef RTEMS_SMP
436  #define PPC_CONTEXT_OFFSET_IS_EXECUTING \
437    (PPC_CONTEXT_OFFSET_TP + PPC_REG_SIZE)
438#endif
439
440#ifndef ASM
441typedef struct {
442#if (PPC_HAS_FPU == 1)
443    /* The ABIs (PowerOpen/SVR4/EABI) only require saving f14-f31 over
444     * procedure calls.  However, this would mean that the interrupt
445     * frame had to hold f0-f13, and the fpscr.  And as the majority
446     * of tasks will not have an FP context, we will save the whole
447     * context here.
448     */
449#if (PPC_HAS_DOUBLE == 1)
450    double      f[32];
451    uint64_t    fpscr;
452#else
453    float       f[32];
454    uint32_t    fpscr;
455#endif
456#endif /* (PPC_HAS_FPU == 1) */
457} Context_Control_fp;
458
459#endif /* ASM */
460
461/*
462 *  Does the CPU follow the simple vectored interrupt model?
463 *
464 *  If TRUE, then RTEMS allocates the vector table it internally manages.
465 *  If FALSE, then the BSP is assumed to allocate and manage the vector
466 *  table
467 *
468 *  PowerPC Specific Information:
469 *
470 *  The PowerPC and x86 were the first to use the PIC interrupt model.
471 *  They do not use the simple vectored interrupt model.
472 */
473#define CPU_SIMPLE_VECTORED_INTERRUPTS FALSE
474
475/*
476 *  Does the RTEMS invoke the user's ISR with the vector number and
477 *  a pointer to the saved interrupt frame (1) or just the vector
478 *  number (0)?
479 */
480
481#define CPU_ISR_PASSES_FRAME_POINTER FALSE
482
483/*
484 *  Should the saving of the floating point registers be deferred
485 *  until a context switch is made to another different floating point
486 *  task?
487 *
488 *  If TRUE, then the floating point context will not be stored until
489 *  necessary.  It will remain in the floating point registers and not
490 *  disturned until another floating point task is switched to.
491 *
492 *  If FALSE, then the floating point context is saved when a floating
493 *  point task is switched out and restored when the next floating point
494 *  task is restored.  The state of the floating point registers between
495 *  those two operations is not specified.
496 *
497 *  If the floating point context does NOT have to be saved as part of
498 *  interrupt dispatching, then it should be safe to set this to TRUE.
499 *
500 *  Setting this flag to TRUE results in using a different algorithm
501 *  for deciding when to save and restore the floating point context.
502 *  The deferred FP switch algorithm minimizes the number of times
503 *  the FP context is saved and restored.  The FP context is not saved
504 *  until a context switch is made to another, different FP task.
505 *  Thus in a system with only one FP task, the FP context will never
506 *  be saved or restored.
507 *
508 *  Note, however that compilers may use floating point registers/
509 *  instructions for optimization or they may save/restore FP registers
510 *  on the stack. You must not use deferred switching in these cases
511 *  and on the PowerPC attempting to do so will raise a "FP unavailable"
512 *  exception.
513 */
514/*
515 *  ACB Note:  This could make debugging tricky..
516 */
517
518/* conservative setting (FALSE); probably doesn't affect performance too much */
519#define CPU_USE_DEFERRED_FP_SWITCH       FALSE
520
521#define CPU_ENABLE_ROBUST_THREAD_DISPATCH FALSE
522
523/*
524 *  Processor defined structures required for cpukit/score.
525 */
526
527#ifndef ASM
528
529/*
530 *  This variable is optional.  It is used on CPUs on which it is difficult
531 *  to generate an "uninitialized" FP context.  It is filled in by
532 *  _CPU_Initialize and copied into the task's FP context area during
533 *  _CPU_Context_Initialize.
534 */
535
536/* EXTERN Context_Control_fp  _CPU_Null_fp_context; */
537
538#endif /* ndef ASM */
539
540/*
541 *  This defines the number of levels and the mask used to pick those
542 *  bits out of a thread mode.
543 */
544
545#define CPU_MODES_INTERRUPT_MASK   0x00000001 /* interrupt level in mode */
546
547/*
548 *  The size of the floating point context area.  On some CPUs this
549 *  will not be a "sizeof" because the format of the floating point
550 *  area is not defined -- only the size is.  This is usually on
551 *  CPUs with a "floating point save context" instruction.
552 */
553
554#define CPU_CONTEXT_FP_SIZE sizeof( Context_Control_fp )
555
556/*
557 * (Optional) # of bytes for libmisc/stackchk to check
558 * If not specifed, then it defaults to something reasonable
559 * for most architectures.
560 */
561
562#define CPU_STACK_CHECK_PATTERN_INITIALIZER \
563  { 0xFEEDF00D, 0x0BAD0D06, 0xDEADF00D, 0x600D0D06, \
564    0xFEEDF00D, 0x0BAD0D06, 0xDEADF00D, 0x600D0D06, \
565    0xFEEDF00D, 0x0BAD0D06, 0xDEADF00D, 0x600D0D06, \
566    0xFEEDF00D, 0x0BAD0D06, 0xDEADF00D, 0x600D0D06, \
567    0xFEEDF00D, 0x0BAD0D06, 0xDEADF00D, 0x600D0D06, \
568    0xFEEDF00D, 0x0BAD0D06, 0xDEADF00D, 0x600D0D06, \
569    0xFEEDF00D, 0x0BAD0D06, 0xDEADF00D, 0x600D0D06, \
570    0xFEEDF00D, 0x0BAD0D06, 0xDEADF00D, 0x600D0D06 }
571
572/*
573 *  Amount of extra stack (above minimum stack size) required by
574 *  MPCI receive server thread.  Remember that in a multiprocessor
575 *  system this thread must exist and be able to process all directives.
576 */
577
578#define CPU_MPCI_RECEIVE_SERVER_EXTRA_STACK 0
579
580/*
581 *  This is defined if the port has a special way to report the ISR nesting
582 *  level.  Most ports maintain the variable _ISR_Nest_level. Note that
583 *  this is not an option - RTEMS/score _relies_ on _ISR_Nest_level
584 *  being maintained (e.g. watchdog queues).
585 */
586
587#define CPU_PROVIDES_ISR_IS_IN_PROGRESS FALSE
588
589/*
590 *  ISR handler macros
591 */
592
593/*
594 *  Disable all interrupts for an RTEMS critical section.  The previous
595 *  level is returned in _isr_cookie.
596 */
597
598#ifndef ASM
599
600RTEMS_INLINE_ROUTINE bool _CPU_ISR_Is_enabled( uint32_t level )
601{
602  return ( level & MSR_EE ) != 0;
603}
604
605#if !defined(PPC_DISABLE_INLINE_ISR_DISABLE_ENABLE)
606
607static inline uint32_t   _CPU_ISR_Get_level( void )
608{
609  uint32_t msr;
610  _CPU_MSR_GET(msr);
611  if (msr & MSR_EE) return 0;
612  else  return 1;
613}
614
615static inline void _CPU_ISR_Set_level( uint32_t   level )
616{
617  uint32_t msr;
618  _CPU_MSR_GET(msr);
619  if (!(level & CPU_MODES_INTERRUPT_MASK)) {
620    msr |= ppc_interrupt_get_disable_mask();
621  }
622  else {
623    msr &= ~ppc_interrupt_get_disable_mask();
624  }
625  _CPU_MSR_SET(msr);
626}
627#else
628/* disable, enable, etc. are in registers.h */
629uint32_t ppc_get_interrupt_level( void );
630void ppc_set_interrupt_level( uint32_t level );
631#define _CPU_ISR_Get_level( _new_level ) ppc_get_interrupt_level()
632#define _CPU_ISR_Set_level( _new_level ) ppc_set_interrupt_level(_new_level)
633#endif
634
635#endif /* ASM */
636
637#define _CPU_Fatal_halt( _source, _error ) \
638  do { \
639    ppc_interrupt_disable(); \
640    __asm__ volatile ( \
641      "mr 3, %0\n" \
642      "mr 4, %1\n" \
643      "1:\n" \
644      "b 1b\n" \
645      : \
646      : "r" (_source), "r" (_error) \
647      : "memory" \
648    ); \
649  } while ( 0 )
650
651/*
652 *  Should be large enough to run all RTEMS tests.  This ensures
653 *  that a "reasonable" small application should not have any problems.
654 */
655
656#define CPU_STACK_MINIMUM_SIZE          (1024*8)
657
658#if defined(__powerpc64__)
659#define CPU_SIZEOF_POINTER 8
660#else
661#define CPU_SIZEOF_POINTER 4
662#endif
663
664/*
665 *  CPU's worst alignment requirement for data types on a byte boundary.  This
666 *  alignment does not take into account the requirements for the stack.
667 */
668
669#define CPU_ALIGNMENT              (PPC_ALIGNMENT)
670
671/*
672 *  This number corresponds to the byte alignment requirement for the
673 *  heap handler.  This alignment requirement may be stricter than that
674 *  for the data types alignment specified by CPU_ALIGNMENT.  It is
675 *  common for the heap to follow the same alignment requirement as
676 *  CPU_ALIGNMENT.  If the CPU_ALIGNMENT is strict enough for the heap,
677 *  then this should be set to CPU_ALIGNMENT.
678 *
679 *  NOTE:  This does not have to be a power of 2.  It does have to
680 *         be greater or equal to than CPU_ALIGNMENT.
681 */
682
683#define CPU_HEAP_ALIGNMENT         (PPC_ALIGNMENT)
684
685/*
686 *  This number corresponds to the byte alignment requirement for the
687 *  stack.  This alignment requirement may be stricter than that for the
688 *  data types alignment specified by CPU_ALIGNMENT.  If the CPU_ALIGNMENT
689 *  is strict enough for the stack, then this should be set to 0.
690 *
691 *  NOTE:  This must be a power of 2 either 0 or greater than CPU_ALIGNMENT.
692 */
693
694#define CPU_STACK_ALIGNMENT        (PPC_STACK_ALIGNMENT)
695
696#define CPU_INTERRUPT_STACK_ALIGNMENT CPU_CACHE_LINE_BYTES
697
698#ifndef ASM
699/*  The following routine swaps the endian format of an unsigned int.
700 *  It must be static because it is referenced indirectly.
701 *
702 *  This version will work on any processor, but if there is a better
703 *  way for your CPU PLEASE use it.  The most common way to do this is to:
704 *
705 *     swap least significant two bytes with 16-bit rotate
706 *     swap upper and lower 16-bits
707 *     swap most significant two bytes with 16-bit rotate
708 *
709 *  Some CPUs have special instructions which swap a 32-bit quantity in
710 *  a single instruction (e.g. i486).  It is probably best to avoid
711 *  an "endian swapping control bit" in the CPU.  One good reason is
712 *  that interrupts would probably have to be disabled to ensure that
713 *  an interrupt does not try to access the same "chunk" with the wrong
714 *  endian.  Another good reason is that on some CPUs, the endian bit
715 *  endianness for ALL fetches -- both code and data -- so the code
716 *  will be fetched incorrectly.
717 */
718
719static inline uint32_t CPU_swap_u32(
720  uint32_t value
721)
722{
723  uint32_t   swapped;
724
725  __asm__ volatile("rlwimi %0,%1,8,24,31;"
726               "rlwimi %0,%1,24,16,23;"
727               "rlwimi %0,%1,8,8,15;"
728               "rlwimi %0,%1,24,0,7;" :
729               "=&r" ((swapped)) : "r" ((value)));
730
731  return( swapped );
732}
733
734#define CPU_swap_u16( value ) \
735  (((value&0xff) << 8) | ((value >> 8)&0xff))
736
737typedef uint32_t CPU_Counter_ticks;
738
739uint32_t _CPU_Counter_frequency( void );
740
741static inline CPU_Counter_ticks _CPU_Counter_read( void )
742{
743  CPU_Counter_ticks value;
744
745#if defined(__PPC_CPU_E6500__)
746  /* Use Alternate Time Base */
747  __asm__ volatile( "mfspr %0, 526" : "=r" (value) );
748#else
749  __asm__ volatile( "mfspr %0, 268" : "=r" (value) );
750#endif
751
752  return value;
753}
754
755static inline CPU_Counter_ticks _CPU_Counter_difference(
756  CPU_Counter_ticks second,
757  CPU_Counter_ticks first
758)
759{
760  return second - first;
761}
762
763#endif /* ASM */
764
765
766#ifndef ASM
767/* Context handler macros */
768
769/*
770 *  Initialize the context to a state suitable for starting a
771 *  task after a context restore operation.  Generally, this
772 *  involves:
773 *
774 *     - setting a starting address
775 *     - preparing the stack
776 *     - preparing the stack and frame pointers
777 *     - setting the proper interrupt level in the context
778 *     - initializing the floating point context
779 *
780 *  This routine generally does not set any unnecessary register
781 *  in the context.  The state of the "general data" registers is
782 *  undefined at task start time.
783 */
784
785void _CPU_Context_Initialize(
786  Context_Control  *the_context,
787  void             *stack_base,
788  size_t            size,
789  uint32_t          new_level,
790  void             *entry_point,
791  bool              is_fp,
792  void             *tls_area
793);
794
795/*
796 *  This routine is responsible for somehow restarting the currently
797 *  executing task.  If you are lucky, then all that is necessary
798 *  is restoring the context.  Otherwise, there will need to be
799 *  a special assembly routine which does something special in this
800 *  case.  Context_Restore should work most of the time.  It will
801 *  not work if restarting self conflicts with the stack frame
802 *  assumptions of restoring a context.
803 */
804
805#define _CPU_Context_Restart_self( _the_context ) \
806   _CPU_Context_restore( (_the_context) );
807
808/*
809 *  This routine initializes the FP context area passed to it to.
810 *  There are a few standard ways in which to initialize the
811 *  floating point context.  The code included for this macro assumes
812 *  that this is a CPU in which a "initial" FP context was saved into
813 *  _CPU_Null_fp_context and it simply copies it to the destination
814 *  context passed to it.
815 *
816 *  Other models include (1) not doing anything, and (2) putting
817 *  a "null FP status word" in the correct place in the FP context.
818 */
819
820#define _CPU_Context_Initialize_fp( _destination ) \
821  memset( *(_destination), 0, sizeof( **(_destination) ) )
822
823/* end of Context handler macros */
824#endif /* ASM */
825
826#ifndef ASM
827/* Bitfield handler macros */
828
829#define CPU_USE_GENERIC_BITFIELD_CODE FALSE
830
831/*
832 *  This routine sets _output to the bit number of the first bit
833 *  set in _value.  _value is of CPU dependent type Priority_bit_map_Word.
834 *  This type may be either 16 or 32 bits wide although only the 16
835 *  least significant bits will be used.
836 *
837 *  There are a number of variables in using a "find first bit" type
838 *  instruction.
839 *
840 *    (1) What happens when run on a value of zero?
841 *    (2) Bits may be numbered from MSB to LSB or vice-versa.
842 *    (3) The numbering may be zero or one based.
843 *    (4) The "find first bit" instruction may search from MSB or LSB.
844 *
845 *  RTEMS guarantees that (1) will never happen so it is not a concern.
846 *  (2),(3), (4) are handled by the macros _CPU_Priority_mask() and
847 *  _CPU_Priority_Bits_index().  These three form a set of routines
848 *  which must logically operate together.  Bits in the _value are
849 *  set and cleared based on masks built by _CPU_Priority_mask().
850 *  The basic major and minor values calculated by _Priority_Major()
851 *  and _Priority_Minor() are "massaged" by _CPU_Priority_Bits_index()
852 *  to properly range between the values returned by the "find first bit"
853 *  instruction.  This makes it possible for _Priority_Get_highest() to
854 *  calculate the major and directly index into the minor table.
855 *  This mapping is necessary to ensure that 0 (a high priority major/minor)
856 *  is the first bit found.
857 *
858 *  This entire "find first bit" and mapping process depends heavily
859 *  on the manner in which a priority is broken into a major and minor
860 *  components with the major being the 4 MSB of a priority and minor
861 *  the 4 LSB.  Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
862 *  priority.  And (15 << 4) + 14 corresponds to priority 254 -- the next
863 *  to the lowest priority.
864 *
865 *  If your CPU does not have a "find first bit" instruction, then
866 *  there are ways to make do without it.  Here are a handful of ways
867 *  to implement this in software:
868 *
869 *    - a series of 16 bit test instructions
870 *    - a "binary search using if's"
871 *    - _number = 0
872 *      if _value > 0x00ff
873 *        _value >>=8
874 *        _number = 8;
875 *
876 *      if _value > 0x0000f
877 *        _value >=8
878 *        _number += 4
879 *
880 *      _number += bit_set_table[ _value ]
881 *
882 *    where bit_set_table[ 16 ] has values which indicate the first
883 *      bit set
884 */
885
886#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
887  { \
888    __asm__ volatile ("cntlzw %0, %1" : "=r" ((_output)), "=r" ((_value)) : \
889                  "1" ((_value))); \
890    (_output) = (_output) - 16; \
891  }
892
893/* end of Bitfield handler macros */
894
895/*
896 *  This routine builds the mask which corresponds to the bit fields
897 *  as searched by _CPU_Bitfield_Find_first_bit().  See the discussion
898 *  for that routine.
899 */
900
901#define _CPU_Priority_Mask( _bit_number ) \
902  ( 0x8000u >> (_bit_number) )
903
904/*
905 *  This routine translates the bit numbers returned by
906 *  _CPU_Bitfield_Find_first_bit() into something suitable for use as
907 *  a major or minor component of a priority.  See the discussion
908 *  for that routine.
909 */
910
911#define _CPU_Priority_bits_index( _priority ) \
912  (_priority)
913
914/* end of Priority handler macros */
915#endif /* ASM */
916
917/* functions */
918
919#ifndef ASM
920
921/*
922 *  _CPU_Initialize
923 *
924 *  This routine performs CPU dependent initialization.
925 */
926
927void _CPU_Initialize(void);
928
929/*
930 *  _CPU_ISR_install_vector
931 *
932 *  This routine installs an interrupt vector.
933 */
934
935void _CPU_ISR_install_vector(
936  uint32_t    vector,
937  proc_ptr    new_handler,
938  proc_ptr   *old_handler
939);
940
941/*
942 *  _CPU_Context_switch
943 *
944 *  This routine switches from the run context to the heir context.
945 */
946
947void _CPU_Context_switch(
948  Context_Control  *run,
949  Context_Control  *heir
950);
951
952/*
953 *  _CPU_Context_restore
954 *
955 *  This routine is generallu used only to restart self in an
956 *  efficient manner.  It may simply be a label in _CPU_Context_switch.
957 *
958 *  NOTE: May be unnecessary to reload some registers.
959 */
960
961void _CPU_Context_restore(
962  Context_Control *new_context
963) RTEMS_NO_RETURN;
964
965/*
966 *  _CPU_Context_save_fp
967 *
968 *  This routine saves the floating point context passed to it.
969 */
970
971void _CPU_Context_save_fp(
972  Context_Control_fp **fp_context_ptr
973);
974
975/*
976 *  _CPU_Context_restore_fp
977 *
978 *  This routine restores the floating point context passed to it.
979 */
980
981void _CPU_Context_restore_fp(
982  Context_Control_fp **fp_context_ptr
983);
984
985#ifdef RTEMS_SMP
986  uint32_t _CPU_SMP_Initialize( void );
987
988  bool _CPU_SMP_Start_processor( uint32_t cpu_index );
989
990  void _CPU_SMP_Finalize_initialization( uint32_t cpu_count );
991
992  void _CPU_SMP_Prepare_start_multitasking( void );
993
994  static inline uint32_t _CPU_SMP_Get_current_processor( void )
995  {
996    uint32_t pir;
997
998    /* Use Book E Processor ID Register (PIR) */
999    __asm__ volatile (
1000      "mfspr %[pir], 286"
1001      : [pir] "=&r" (pir)
1002    );
1003
1004    return pir;
1005  }
1006
1007  void _CPU_SMP_Send_interrupt( uint32_t target_processor_index );
1008
1009  static inline void _CPU_SMP_Processor_event_broadcast( void )
1010  {
1011    __asm__ volatile ( "" : : : "memory" );
1012  }
1013
1014  static inline void _CPU_SMP_Processor_event_receive( void )
1015  {
1016    __asm__ volatile ( "" : : : "memory" );
1017  }
1018#endif
1019
1020typedef struct {
1021  uintptr_t EXC_SRR0;
1022  uintptr_t EXC_SRR1;
1023  uint32_t _EXC_number;
1024  uint32_t RESERVED_FOR_ALIGNMENT_0;
1025  uint32_t EXC_CR;
1026  uint32_t EXC_XER;
1027  uintptr_t EXC_CTR;
1028  uintptr_t EXC_LR;
1029  uintptr_t RESERVED_FOR_ALIGNMENT_1;
1030  #ifdef __SPE__
1031    uint32_t EXC_SPEFSCR;
1032    uint64_t EXC_ACC;
1033  #endif
1034  PPC_GPR_TYPE GPR0;
1035  PPC_GPR_TYPE GPR1;
1036  PPC_GPR_TYPE GPR2;
1037  PPC_GPR_TYPE GPR3;
1038  PPC_GPR_TYPE GPR4;
1039  PPC_GPR_TYPE GPR5;
1040  PPC_GPR_TYPE GPR6;
1041  PPC_GPR_TYPE GPR7;
1042  PPC_GPR_TYPE GPR8;
1043  PPC_GPR_TYPE GPR9;
1044  PPC_GPR_TYPE GPR10;
1045  PPC_GPR_TYPE GPR11;
1046  PPC_GPR_TYPE GPR12;
1047  PPC_GPR_TYPE GPR13;
1048  PPC_GPR_TYPE GPR14;
1049  PPC_GPR_TYPE GPR15;
1050  PPC_GPR_TYPE GPR16;
1051  PPC_GPR_TYPE GPR17;
1052  PPC_GPR_TYPE GPR18;
1053  PPC_GPR_TYPE GPR19;
1054  PPC_GPR_TYPE GPR20;
1055  PPC_GPR_TYPE GPR21;
1056  PPC_GPR_TYPE GPR22;
1057  PPC_GPR_TYPE GPR23;
1058  PPC_GPR_TYPE GPR24;
1059  PPC_GPR_TYPE GPR25;
1060  PPC_GPR_TYPE GPR26;
1061  PPC_GPR_TYPE GPR27;
1062  PPC_GPR_TYPE GPR28;
1063  PPC_GPR_TYPE GPR29;
1064  PPC_GPR_TYPE GPR30;
1065  PPC_GPR_TYPE GPR31;
1066  uintptr_t RESERVED_FOR_ALIGNMENT_2;
1067  #ifdef PPC_MULTILIB_ALTIVEC
1068    uint32_t VRSAVE;
1069    uint32_t RESERVED_FOR_ALIGNMENT_3[3];
1070
1071    /* This field must take stvewx/lvewx requirements into account */
1072    uint32_t RESERVED_FOR_ALIGNMENT_4[3];
1073    uint32_t VSCR;
1074
1075    uint8_t V0[16];
1076    uint8_t V1[16];
1077    uint8_t V2[16];
1078    uint8_t V3[16];
1079    uint8_t V4[16];
1080    uint8_t V5[16];
1081    uint8_t V6[16];
1082    uint8_t V7[16];
1083    uint8_t V8[16];
1084    uint8_t V9[16];
1085    uint8_t V10[16];
1086    uint8_t V11[16];
1087    uint8_t V12[16];
1088    uint8_t V13[16];
1089    uint8_t V14[16];
1090    uint8_t V15[16];
1091    uint8_t V16[16];
1092    uint8_t V17[16];
1093    uint8_t V18[16];
1094    uint8_t V19[16];
1095    uint8_t V20[16];
1096    uint8_t V21[16];
1097    uint8_t V22[16];
1098    uint8_t V23[16];
1099    uint8_t V24[16];
1100    uint8_t V25[16];
1101    uint8_t V26[16];
1102    uint8_t V27[16];
1103    uint8_t V28[16];
1104    uint8_t V29[16];
1105    uint8_t V30[16];
1106    uint8_t V31[16];
1107  #endif
1108  #ifdef PPC_MULTILIB_FPU
1109    double F0;
1110    double F1;
1111    double F2;
1112    double F3;
1113    double F4;
1114    double F5;
1115    double F6;
1116    double F7;
1117    double F8;
1118    double F9;
1119    double F10;
1120    double F11;
1121    double F12;
1122    double F13;
1123    double F14;
1124    double F15;
1125    double F16;
1126    double F17;
1127    double F18;
1128    double F19;
1129    double F20;
1130    double F21;
1131    double F22;
1132    double F23;
1133    double F24;
1134    double F25;
1135    double F26;
1136    double F27;
1137    double F28;
1138    double F29;
1139    double F30;
1140    double F31;
1141    uint64_t FPSCR;
1142    uint64_t RESERVED_FOR_ALIGNMENT_5;
1143  #endif
1144} CPU_Exception_frame;
1145
1146void _CPU_Exception_frame_print( const CPU_Exception_frame *frame );
1147
1148/*
1149 * _CPU_Initialize_altivec()
1150 *
1151 * Global altivec-related initialization.
1152 */
1153void
1154_CPU_Initialize_altivec(void);
1155
1156/*
1157 * _CPU_Context_switch_altivec
1158 *
1159 * This routine switches the altivec contexts passed to it.
1160 */
1161
1162void
1163_CPU_Context_switch_altivec(
1164  ppc_context *from,
1165  ppc_context *to
1166);
1167
1168/*
1169 * _CPU_Context_restore_altivec
1170 *
1171 * This routine restores the altivec context passed to it.
1172 */
1173
1174void
1175_CPU_Context_restore_altivec(
1176  ppc_context *ctxt
1177);
1178
1179/*
1180 * _CPU_Context_initialize_altivec
1181 *
1182 * This routine initializes the altivec context passed to it.
1183 */
1184
1185void
1186_CPU_Context_initialize_altivec(
1187  ppc_context *ctxt
1188);
1189
1190void _CPU_Fatal_error(
1191  uint32_t   _error
1192);
1193
1194/** Type that can store a 32-bit integer or a pointer. */
1195typedef uintptr_t CPU_Uint32ptr;
1196
1197#endif /* ASM */
1198
1199#ifdef __cplusplus
1200}
1201#endif
1202
1203#endif /* _RTEMS_SCORE_CPU_H */
Note: See TracBrowser for help on using the repository browser.