Changeset c03e2bc in rtems


Ignore:
Timestamp:
02/11/09 21:45:05 (15 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 5, master
Children:
45d107ec
Parents:
ef1be69
Message:

2009-02-11 Joel Sherrill <joel.sherrill@…>

  • cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and passing address of _Thread_Dispatch to _CPU_Initialize. Clean up comments.
Location:
cpukit/score/cpu
Files:
48 edited

Legend:

Unmodified
Added
Removed
  • cpukit/score/cpu/arm/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-09-11      Ralf Corsépius <ralf.corsepius@rtems.org>
    28
  • cpukit/score/cpu/arm/cpu.c

    ref1be69 rc03e2bc  
    3535/*  _CPU_Initialize
    3636 *
     37 *  INPUT PARAMETERS: NONE
     38 *
    3739 *  This routine performs processor dependent initialization.
    38  *
    39  *  INPUT PARAMETERS:
    40  *    thread_dispatch - address of ISR dispatching routine (unused)
    41  */
    42 
    43 void _CPU_Initialize(
    44   void      (*thread_dispatch)      /* ignored on this CPU */
    45 )
     40 */
     41
     42void _CPU_Initialize(void)
    4643{
    4744}
  • cpukit/score/cpu/arm/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    700700 */
    701701
    702 void _CPU_Initialize(
    703   void      (*thread_dispatch)
    704 );
     702void _CPU_Initialize(void);
    705703
    706704typedef enum {
  • cpukit/score/cpu/avr/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-12-11      Joel Sherrill <joel.sherrill@oarcorp.com>
    28
  • cpukit/score/cpu/avr/cpu.c

    ref1be69 rc03e2bc  
    2323 *  This routine performs processor dependent initialization.
    2424 *
    25  *  INPUT PARAMETERS:
    26  *    thread_dispatch - address of dispatching routine
     25 *  INPUT PARAMETERS: NONE
    2726 *
    2827 *  NO_CPU Specific Information:
     
    3029 *  XXX document implementation including references if appropriate
    3130 */
    32 
    33 
    34 void _CPU_Initialize(
    35   void      (*thread_dispatch)      /* ignored on this CPU */
    36 )
     31void _CPU_Initialize(void)
    3732{
    3833  printk( "AVR CPU Initialize\n" );
    39 
    40   /*
    41    *  The thread_dispatch argument is the address of the entry point
    42    *  for the routine called at the end of an ISR once it has been
    43    *  decided a context switch is necessary.  On some compilation
    44    *  systems it is difficult to call a high-level language routine
    45    *  from assembly.  This allows us to trick these systems.
    46    *
    47    *  If you encounter this problem save the entry point in a CPU
    48    *  dependent variable.
    49    */
    50 
    51   _CPU_Thread_dispatch_pointer = thread_dispatch;
    5234
    5335  /*
  • cpukit/score/cpu/avr/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    468468SCORE_EXTERN void               *_CPU_Interrupt_stack_low;
    469469SCORE_EXTERN void               *_CPU_Interrupt_stack_high;
    470 
    471 /*
    472  *  With some compilation systems, it is difficult if not impossible to
    473  *  call a high-level language routine from assembly language.  This
    474  *  is especially true of commercial Ada compilers and name mangling
    475  *  C++ ones.  This variable can be optionally defined by the CPU porter
    476  *  and contains the address of the routine _Thread_Dispatch.  This
    477  *  can make it easier to invoke that routine at the end of the interrupt
    478  *  sequence (if a dispatch is necessary).
    479  *
    480  *  AVR Specific Information:
    481  *
    482  *  XXX document implementation including references if appropriate
    483  */
    484 
    485 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)(void);
    486470
    487471/*
     
    937921 */
    938922
    939 void _CPU_Initialize(
    940   void      (*thread_dispatch)
    941 );
     923void _CPU_Initialize(void);
    942924
    943925/*
  • cpukit/score/cpu/bfin/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-09-11      Ralf Corsépius <ralf.corsepius@rtems.org>
    28
  • cpukit/score/cpu/bfin/cpu.c

    ref1be69 rc03e2bc  
    2222 *  This routine performs processor dependent initialization.
    2323 *
    24  *  INPUT PARAMETERS:
    25  *    thread_dispatch - address of dispatching routine
     24 *  INPUT PARAMETERS: NONE
    2625 *
    2726 *  NO_CPU Specific Information:
     
    3837extern void _CPU_Unhandled_Interrupt_handler(void);
    3938
    40 void _CPU_Initialize(
    41   void      (*thread_dispatch)      /* ignored on this CPU */
    42 )
    43 {
    44   /*
    45    *  The thread_dispatch argument is the address of the entry point
    46    *  for the routine called at the end of an ISR once it has been
    47    *  decided a context switch is necessary.  On some compilation
    48    *  systems it is difficult to call a high-level language routine
    49    *  from assembly.  This allows us to trick these systems.
    50    *
    51    *  If you encounter this problem save the entry point in a CPU
    52    *  dependent variable.
    53    */
    54 
    55   /*_CPU_Thread_dispatch_pointer = thread_dispatch;*/
    56 
     39void _CPU_Initialize(void)
     40{
    5741  /*
    5842   *  If there is not an easy way to initialize the FP context
  • cpukit/score/cpu/bfin/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    563563 */
    564564SCORE_EXTERN void               *_CPU_Interrupt_stack_high;
    565 
    566 /**
    567  *  @ingroup CPUInterrupt
    568  *  With some compilation systems, it is difficult if not impossible to
    569  *  call a high-level language routine from assembly language.  This
    570  *  is especially true of commercial Ada compilers and name mangling
    571  *  C++ ones.  This variable can be optionally defined by the CPU porter
    572  *  and contains the address of the routine @ref _Thread_Dispatch.  This
    573  *  can make it easier to invoke that routine at the end of the interrupt
    574  *  sequence (if a dispatch is necessary).
    575  *
    576  *  Port Specific Information:
    577  *
    578  *  XXX document implementation including references if appropriate
    579  */
    580 /* SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)();*/
    581565
    582566/*
     
    10981082 *  This routine performs CPU dependent initialization.
    10991083 *
    1100  *  @param[in] cpu_table is the CPU Dependent Configuration Table
    1101  *  @param[in] thread_dispatch is the address of @ref _Thread_Dispatch
    1102  *
    1103  *  Port Specific Information:
    1104  *
    1105  *  XXX document implementation including references if appropriate
    1106  */
    1107 void _CPU_Initialize(
    1108   void      (*thread_dispatch)
    1109 );
     1084 *  Port Specific Information:
     1085 *
     1086 *  XXX document implementation including references if appropriate
     1087 */
     1088void _CPU_Initialize(void);
    11101089
    11111090/**
  • cpukit/score/cpu/c4x/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-09-11      Ralf Corsépius <ralf.corsepius@rtems.org>
    28
  • cpukit/score/cpu/c4x/cpu.c

    ref1be69 rc03e2bc  
    2222 *  This routine performs processor dependent initialization.
    2323 *
    24  *  INPUT PARAMETERS:
    25  *    thread_dispatch - address of dispatching routine
     24 *  INPUT PARAMETERS: NONE
    2625 *
    2726 *  C4x Specific Information:
     
    2928 */
    3029
    31 void _CPU_Initialize(
    32   void      (*thread_dispatch)      /* ignored on this CPU */
    33 )
     30void _CPU_Initialize(void)
    3431{
    35 #if 0
    36   /*
    37    *  The thread_dispatch argument is the address of the entry point
    38    *  for the routine called at the end of an ISR once it has been
    39    *  decided a context switch is necessary.  On some compilation
    40    *  systems it is difficult to call a high-level language routine
    41    *  from assembly.  This allows us to trick these systems.
    42    *
    43    *  If you encounter this problem save the entry point in a CPU
    44    *  dependent variable.
    45    */
    46 
    47   _CPU_Thread_dispatch_pointer = thread_dispatch;
    48 #endif
    49 
    5032#if (CPU_HARDWARE_FP == TRUE)
    5133  /*
  • cpukit/score/cpu/c4x/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    582582
    583583/*
    584  *  With some compilation systems, it is difficult if not impossible to
    585  *  call a high-level language routine from assembly language.  This
    586  *  is especially true of commercial Ada compilers and name mangling
    587  *  C++ ones.  This variable can be optionally defined by the CPU porter
    588  *  and contains the address of the routine _Thread_Dispatch.  This
    589  *  can make it easier to invoke that routine at the end of the interrupt
    590  *  sequence (if a dispatch is necessary).
    591  *
    592  *  C4x Specific Information:
    593  *
    594  *  This port should not require this.
    595  */
    596 
    597 #if 0
    598 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)();
    599 #endif
    600 
    601 /*
    602584 *  Nothing prevents the porter from declaring more CPU specific variables.
    603585 *
     
    10791061 */
    10801062
    1081 void _CPU_Initialize(
    1082   void      (*thread_dispatch)
    1083 );
     1063void _CPU_Initialize(void);
    10841064
    10851065/*
  • cpukit/score/cpu/h8300/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
    28
  • cpukit/score/cpu/h8300/cpu.c

    ref1be69 rc03e2bc  
    2020 *  This routine performs processor dependent initialization.
    2121 *
    22  *  INPUT PARAMETERS:
    23  *    thread_dispatch - address of dispatching routine
     22 *  INPUT PARAMETERS: NONE
    2423 */
    2524
    2625
    27 void _CPU_Initialize(
    28   void      (*thread_dispatch)      /* ignored on this CPU */
    29 )
     26void _CPU_Initialize(void)
    3027{
    31   /*
    32    *  The thread_dispatch argument is the address of the entry point
    33    *  for the routine called at the end of an ISR once it has been
    34    *  decided a context switch is necessary.  On some compilation
    35    *  systems it is difficult to call a high-level language routine
    36    *  from assembly.  This allows us to trick these systems.
    37    *
    38    *  If you encounter this problem save the entry point in a CPU
    39    *  dependent variable.
    40    */
    41 
    42   _CPU_Thread_dispatch_pointer = thread_dispatch;
    43 
    4428  /*
    4529   *  If there is not an easy way to initialize the FP context
  • cpukit/score/cpu/h8300/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    451451SCORE_EXTERN void               *_CPU_Interrupt_stack_low;
    452452SCORE_EXTERN void               *_CPU_Interrupt_stack_high;
    453 
    454 /*
    455  *  With some compilation systems, it is difficult if not impossible to
    456  *  call a high-level language routine from assembly language.  This
    457  *  is especially true of commercial Ada compilers and name mangling
    458  *  C++ ones.  This variable can be optionally defined by the CPU porter
    459  *  and contains the address of the routine _Thread_Dispatch.  This
    460  *  can make it easier to invoke that routine at the end of the interrupt
    461  *  sequence (if a dispatch is necessary).
    462  *
    463  *  H8300 Specific Information:
    464  *
    465  *  XXX
    466  */
    467 
    468 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)(void);
    469453
    470454/*
     
    998982 */
    999983
    1000 void _CPU_Initialize(
    1001   void      (*thread_dispatch)
    1002 );
     984void _CPU_Initialize(void);
    1003985
    1004986/*
  • cpukit/score/cpu/i386/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-09-11      Ralf Corsépius <ralf.corsepius@rtems.org>
    28
  • cpukit/score/cpu/i386/cpu.c

    ref1be69 rc03e2bc  
    2626 *  This routine performs processor dependent initialization.
    2727 *
    28  *  INPUT PARAMETERS:
    29  *    thread_dispatch - address of dispatching routine
     28 *  INPUT PARAMETERS: NONE
    3029 */
    3130
    32 
    33 void _CPU_Initialize(
    34   void      (*thread_dispatch)      /* ignored on this CPU */
    35 )
     31void _CPU_Initialize(void)
    3632{
    3733#if CPU_HARDWARE_FP
     
    6662  }
    6763#endif
    68 
    6964}
    7065
  • cpukit/score/cpu/i386/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    387387 */
    388388
    389 void _CPU_Initialize(
    390   void      (*thread_dispatch)
    391 );
     389void _CPU_Initialize(void);
    392390
    393391/*
  • cpukit/score/cpu/lm32/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-12-05      Joel Sherrill <joel.sherrill@oarcorp.com>
    28
  • cpukit/score/cpu/lm32/cpu.c

    ref1be69 rc03e2bc  
    2424 *  This routine performs processor dependent initialization.
    2525 *
    26  *  INPUT PARAMETERS:
    27  *    thread_dispatch - address of dispatching routine
     26 *  INPUT PARAMETERS: NONE
    2827 *
    2928 *  LM32 Specific Information:
     
    3130 *  XXX document implementation including references if appropriate
    3231 */
    33 void _CPU_Initialize(
    34   void      (*thread_dispatch)      /* ignored on this CPU */
    35 )
     32
     33void _CPU_Initialize(void)
    3634{
    37   /*
    38    *  The thread_dispatch argument is the address of the entry point
    39    *  for the routine called at the end of an ISR once it has been
    40    *  decided a context switch is necessary.  On some compilation
    41    *  systems it is difficult to call a high-level language routine
    42    *  from assembly.  This allows us to trick these systems.
    43    *
    44    *  If you encounter this problem save the entry point in a CPU
    45    *  dependent variable.
    46    */
    47 
    48 #if 0
    49   _CPU_Thread_dispatch_pointer = thread_dispatch;
    50 #endif
    51 
    5235  /*
    5336   *  If there is not an easy way to initialize the FP context
  • cpukit/score/cpu/lm32/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    573573SCORE_EXTERN void               *_CPU_Interrupt_stack_high;
    574574
    575 /**
    576  *  @ingroup CPUInterrupt
    577  *  With some compilation systems, it is difficult if not impossible to
    578  *  call a high-level language routine from assembly language.  This
    579  *  is especially true of commercial Ada compilers and name mangling
    580  *  C++ ones.  This variable can be optionally defined by the CPU porter
    581  *  and contains the address of the routine @ref _Thread_Dispatch.  This
    582  *  can make it easier to invoke that routine at the end of the interrupt
    583  *  sequence (if a dispatch is necessary).
    584  *
    585  *  Port Specific Information:
    586  *
    587  *  XXX document implementation including references if appropriate
    588  */
    589 #if 0
    590 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)();
    591 #endif
    592 
    593575/*
    594576 *  Nothing prevents the porter from declaring more CPU specific variables.
     
    11011083 *  This routine performs CPU dependent initialization.
    11021084 *
    1103  *  @param[in] thread_dispatch is the address of @ref _Thread_Dispatch
    1104  *
    1105  *  Port Specific Information:
    1106  *
    1107  *  XXX document implementation including references if appropriate
    1108  */
    1109 void _CPU_Initialize(
    1110   void      (*thread_dispatch)
    1111 );
     1085 *  Port Specific Information:
     1086 *
     1087 *  XXX document implementation including references if appropriate
     1088 */
     1089void _CPU_Initialize(void);
    11121090
    11131091/**
  • cpukit/score/cpu/m32c/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
    28
  • cpukit/score/cpu/m32c/cpu.c

    ref1be69 rc03e2bc  
    2020 *  This routine performs processor dependent initialization.
    2121 *
    22  *  INPUT PARAMETERS:
    23  *    thread_dispatch - address of dispatching routine
     22 *  INPUT PARAMETERS: NONE
    2423 *
    2524 *  NO_CPU Specific Information:
     
    2726 *  XXX document implementation including references if appropriate
    2827 */
    29 void _CPU_Initialize(
    30   void      (*thread_dispatch)      /* ignored on this CPU */
    31 )
     28
     29void _CPU_Initialize(void)
    3230{
    3331  asm volatile( "ldc    #__var_vects,intb" );
  • cpukit/score/cpu/m32c/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    10421042 *  This routine performs CPU dependent initialization.
    10431043 *
    1044  *  @param[in] thread_dispatch is the address of @ref _Thread_Dispatch
    1045  *
    1046  *  Port Specific Information:
    1047  *
    1048  *  XXX document implementation including references if appropriate
    1049  */
    1050 void _CPU_Initialize(
    1051   void      (*thread_dispatch)
    1052 );
     1044 *  Port Specific Information:
     1045 *
     1046 *  XXX document implementation including references if appropriate
     1047 */
     1048void _CPU_Initialize(void);
    10531049
    10541050/**
  • cpukit/score/cpu/m32r/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-10-28      Joel Sherrill <joel.sherrill@oarcorp.com>
    28
  • cpukit/score/cpu/m32r/cpu.c

    ref1be69 rc03e2bc  
    1919 *  This routine performs processor dependent initialization.
    2020 *
    21  *  INPUT PARAMETERS:
    22  *    thread_dispatch - address of dispatching routine
     21 *  INPUT PARAMETERS: NONE
    2322 *
    2423 *  NO_CPU Specific Information:
     
    2625 *  XXX document implementation including references if appropriate
    2726 */
    28 void _CPU_Initialize(
    29   void      (*thread_dispatch)      /* ignored on this CPU */
    30 )
     27
     28void _CPU_Initialize(void)
    3129{
    3230}
  • cpukit/score/cpu/m32r/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    570570SCORE_EXTERN void               *_CPU_Interrupt_stack_high;
    571571
    572 /**
    573  *  @ingroup CPUInterrupt
    574  *  With some compilation systems, it is difficult if not impossible to
    575  *  call a high-level language routine from assembly language.  This
    576  *  is especially true of commercial Ada compilers and name mangling
    577  *  C++ ones.  This variable can be optionally defined by the CPU porter
    578  *  and contains the address of the routine @ref _Thread_Dispatch.  This
    579  *  can make it easier to invoke that routine at the end of the interrupt
    580  *  sequence (if a dispatch is necessary).
    581  *
    582  *  Port Specific Information:
    583  *
    584  *  XXX document implementation including references if appropriate
    585  */
    586 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)(void);
    587 
    588572/*
    589573 *  Nothing prevents the porter from declaring more CPU specific variables.
     
    10951079 *  This routine performs CPU dependent initialization.
    10961080 *
    1097  *  @param[in] thread_dispatch is the address of @ref _Thread_Dispatch
    1098  *
    1099  *  Port Specific Information:
    1100  *
    1101  *  XXX document implementation including references if appropriate
    1102  */
    1103 void _CPU_Initialize(
    1104   void      (*thread_dispatch)
    1105 );
     1081 *  Port Specific Information:
     1082 *
     1083 *  XXX document implementation including references if appropriate
     1084 */
     1085void _CPU_Initialize(void);
    11061086
    11071087/**
  • cpukit/score/cpu/m68k/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-12-17      Ralf Corsépius <ralf.corsepius@rtems.org>
    28
  • cpukit/score/cpu/m68k/cpu.c

    ref1be69 rc03e2bc  
    1919 *  This routine performs processor dependent initialization.
    2020 *
    21  *  INPUT PARAMETERS:
    22  *    thread_dispatch - entry pointer to thread dispatcher
     21 *  INPUT PARAMETERS: NONE
    2322 *
    2423 *  OUTPUT PARAMETERS: NONE
    2524 */
    2625
    27 void _CPU_Initialize(
    28   void      (*thread_dispatch)      /* ignored on this CPU */
    29 )
     26void _CPU_Initialize(void)
    3027{
    3128#if ( M68K_HAS_VBR == 0 )
  • cpukit/score/cpu/m68k/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    633633 */
    634634
    635 void _CPU_Initialize(
    636   void      (*thread_dispatch)
    637 );
     635void _CPU_Initialize(void);
    638636
    639637/*
  • cpukit/score/cpu/mips/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-09-11      Ralf Corsépius <ralf.corsepius@rtems.org>
    28
  • cpukit/score/cpu/mips/cpu.c

    ref1be69 rc03e2bc  
    7171 *  This routine performs processor dependent initialization.
    7272 *
    73  *  INPUT PARAMETERS:
    7473 *    thread_dispatch - address of dispatching routine
    7574 */
    76 void _CPU_Initialize(
    77   void      (*thread_dispatch)      /* ignored on this CPU */
    78 )
     75
     76void _CPU_Initialize(void)
    7977{
    8078  /*
  • cpukit/score/cpu/mips/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    634634
    635635/*
    636  *  With some compilation systems, it is difficult if not impossible to
    637  *  call a high-level language routine from assembly language.  This
    638  *  is especially true of commercial Ada compilers and name mangling
    639  *  C++ ones.  This variable can be optionally defined by the CPU porter
    640  *  and contains the address of the routine _Thread_Dispatch.  This
    641  *  can make it easier to invoke that routine at the end of the interrupt
    642  *  sequence (if a dispatch is necessary).
    643  *
    644 
    645 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)();
    646  *
    647  *  NOTE: Not needed on this port.
    648  */
    649 
    650 
    651 
    652 /*
    653636 *  Nothing prevents the porter from declaring more CPU specific variables.
    654637 */
     
    10621045 */
    10631046
    1064 void _CPU_Initialize(
    1065   void      (*thread_dispatch)
    1066 );
     1047void _CPU_Initialize(void);
    10671048
    10681049/*
  • cpukit/score/cpu/nios2/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-09-11      Ralf Corsépius <ralf.corsepius@rtems.org>
    28
  • cpukit/score/cpu/nios2/cpu.c

    ref1be69 rc03e2bc  
    2020 *  This routine performs processor dependent initialization.
    2121 *
    22  *  INPUT PARAMETERS:
    23  *    thread_dispatch - address of dispatching routine
     22 *  INPUT PARAMETERS: NONE
    2423 *
    2524 *  NO_CPU Specific Information:
     
    2827 */
    2928
    30 
    31 void _CPU_Initialize(
    32   void      (*thread_dispatch)      /* ignored on this CPU */
    33 )
     29void _CPU_Initialize(void)
    3430{
    35   /*
    36    *  The thread_dispatch argument is the address of the entry point
    37    *  for the routine called at the end of an ISR once it has been
    38    *  decided a context switch is necessary.  On some compilation
    39    *  systems it is difficult to call a high-level language routine
    40    *  from assembly.  This allows us to trick these systems.
    41    *
    42    *  If you encounter this problem save the entry point in a CPU
    43    *  dependent variable.
    44    */
    45 
    46   _CPU_Thread_dispatch_pointer = thread_dispatch;
    47 
    4831  /*
    4932   *  If there is not an easy way to initialize the FP context
  • cpukit/score/cpu/nios2/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    605605SCORE_EXTERN void               *_CPU_Interrupt_stack_high;
    606606
    607 /**
    608  *  @ingroup CPUInterrupt
    609  *  With some compilation systems, it is difficult if not impossible to
    610  *  call a high-level language routine from assembly language.  This
    611  *  is especially true of commercial Ada compilers and name mangling
    612  *  C++ ones.  This variable can be optionally defined by the CPU porter
    613  *  and contains the address of the routine @ref _Thread_Dispatch.  This
    614  *  can make it easier to invoke that routine at the end of the interrupt
    615  *  sequence (if a dispatch is necessary).
    616  *
    617  *  Port Specific Information:
    618  *
    619  *  XXX document implementation including references if appropriate
    620  */
    621 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)();
    622 
    623607/*
    624608 *  Nothing prevents the porter from declaring more CPU specific variables.
     
    11461130 *  This routine performs CPU dependent initialization.
    11471131 *
    1148  *  @param cpu_table (in) is the CPU Dependent Configuration Table
    1149  *  @param thread_dispatch (in) is the address of @ref _Thread_Dispatch
    1150  *
    1151  *  Port Specific Information:
    1152  *
    1153  *  XXX document implementation including references if appropriate
    1154  */
    1155 void _CPU_Initialize(
    1156   void      (*thread_dispatch)
    1157 );
     1132 *  Port Specific Information:
     1133 *
     1134 *  XXX document implementation including references if appropriate
     1135 */
     1136void _CPU_Initialize(void);
    11581137
    11591138/**
  • cpukit/score/cpu/no_cpu/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-10-02      Joel Sherrill <joel.sherrill@oarcorp.com>
    28
  • cpukit/score/cpu/no_cpu/cpu.c

    ref1be69 rc03e2bc  
    2121 *  This routine performs processor dependent initialization.
    2222 *
    23  *  INPUT PARAMETERS:
    24  *    thread_dispatch - address of dispatching routine
     23 *  INPUT PARAMETERS: NONE
    2524 *
    2625 *  NO_CPU Specific Information:
     
    2827 *  XXX document implementation including references if appropriate
    2928 */
    30 void _CPU_Initialize(
    31   void      (*thread_dispatch)      /* ignored on this CPU */
    32 )
     29
     30void _CPU_Initialize(void)
    3331{
    34   /*
    35    *  The thread_dispatch argument is the address of the entry point
    36    *  for the routine called at the end of an ISR once it has been
    37    *  decided a context switch is necessary.  On some compilation
    38    *  systems it is difficult to call a high-level language routine
    39    *  from assembly.  This allows us to trick these systems.
    40    *
    41    *  If you encounter this problem save the entry point in a CPU
    42    *  dependent variable.
    43    */
    44 
    45   _CPU_Thread_dispatch_pointer = thread_dispatch;
    46 
    4732  /*
    4833   *  If there is not an easy way to initialize the FP context
  • cpukit/score/cpu/no_cpu/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    562562 */
    563563SCORE_EXTERN void               *_CPU_Interrupt_stack_high;
    564 
    565 /**
    566  *  @ingroup CPUInterrupt
    567  *  With some compilation systems, it is difficult if not impossible to
    568  *  call a high-level language routine from assembly language.  This
    569  *  is especially true of commercial Ada compilers and name mangling
    570  *  C++ ones.  This variable can be optionally defined by the CPU porter
    571  *  and contains the address of the routine @ref _Thread_Dispatch.  This
    572  *  can make it easier to invoke that routine at the end of the interrupt
    573  *  sequence (if a dispatch is necessary).
    574  *
    575  *  Port Specific Information:
    576  *
    577  *  XXX document implementation including references if appropriate
    578  */
    579 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)(void);
    580564
    581565/*
     
    10821066 *  This routine performs CPU dependent initialization.
    10831067 *
    1084  *  @param[in] thread_dispatch is the address of @ref _Thread_Dispatch
    1085  *
    1086  *  Port Specific Information:
    1087  *
    1088  *  XXX document implementation including references if appropriate
    1089  */
    1090 void _CPU_Initialize(
    1091   void      (*thread_dispatch)
    1092 );
     1068 *  Port Specific Information:
     1069 *
     1070 *  XXX document implementation including references if appropriate
     1071 */
     1072void _CPU_Initialize(void);
    10931073
    10941074/**
  • cpukit/score/cpu/sh/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-09-30      Joel Sherrill <joel.sherrill@oarcorp.com>
    28
  • cpukit/score/cpu/sh/cpu.c

    ref1be69 rc03e2bc  
    4040 *  This routine performs processor dependent initialization.
    4141 *
    42  *  INPUT PARAMETERS:
    43  *    thread_dispatch - address of dispatching routine
    44  */
    45 
    46 
    47 void _CPU_Initialize(
    48   void      (*thread_dispatch)      /* ignored on this CPU */
    49 )
     42 *  INPUT PARAMETERS: NONE
     43 */
     44
     45void _CPU_Initialize(void)
    5046{
    5147  register uint32_t   level = 0;
    52 
    53   /*
    54    *  The thread_dispatch argument is the address of the entry point
    55    *  for the routine called at the end of an ISR once it has been
    56    *  decided a context switch is necessary.  On some compilation
    57    *  systems it is difficult to call a high-level language routine
    58    *  from assembly.  This allows us to trick these systems.
    59    *
    60    *  If you encounter this problem save the entry point in a CPU
    61    *  dependent variable.
    62    */
    63 
    64   _CPU_Thread_dispatch_pointer = thread_dispatch;
    6548
    6649  /*
  • cpukit/score/cpu/sh/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    428428SCORE_EXTERN void               *_CPU_Interrupt_stack_low;
    429429SCORE_EXTERN void               *_CPU_Interrupt_stack_high;
    430 
    431 /*
    432  *  With some compilation systems, it is difficult if not impossible to
    433  *  call a high-level language routine from assembly language.  This
    434  *  is especially true of commercial Ada compilers and name mangling
    435  *  C++ ones.  This variable can be optionally defined by the CPU porter
    436  *  and contains the address of the routine _Thread_Dispatch.  This
    437  *  can make it easier to invoke that routine at the end of the interrupt
    438  *  sequence (if a dispatch is necessary).
    439  */
    440 
    441 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)(void);
    442430
    443431/*
     
    826814 */
    827815
    828 void _CPU_Initialize(
    829   void      (*thread_dispatch)
    830 );
     816void _CPU_Initialize(void);
    831817
    832818/*
  • cpukit/score/cpu/sparc/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-09-11      Ralf Corsépius <ralf.corsepius@rtems.org>
    28
  • cpukit/score/cpu/sparc/cpu.c

    ref1be69 rc03e2bc  
    3939 *  This routine performs processor dependent initialization.
    4040 *
    41  *  Input Parameters:
    42  *    thread_dispatch - address of dispatching routine
     41 *  INPUT PARAMETERS: NONE
    4342 *
    4443 *  Output Parameters: NONE
     
    4847 */
    4948
    50 void _CPU_Initialize(
    51   void            (*thread_dispatch)      /* ignored on this CPU */
    52 )
     49void _CPU_Initialize(void)
    5350{
    5451#if (SPARC_HAS_FPU == 1)
  • cpukit/score/cpu/sparc/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    884884 */
    885885
    886 void _CPU_Initialize(
    887   void            (*thread_dispatch)
    888 );
     886void _CPU_Initialize(void);
    889887
    890888/*
  • cpukit/score/cpu/unix/ChangeLog

    ref1be69 rc03e2bc  
     12009-02-11      Joel Sherrill <joel.sherrill@oarcorp.com>
     2
     3        * cpu.c, rtems/score/cpu.h: Eliminate _CPU_Thread_dispatch_pointer and
     4        passing address of _Thread_Dispatch to _CPU_Initialize. Clean up
     5        comments.
     6
    172008-12-01      Joel Sherrill <joel.sherrill@OARcorp.com>
    28
  • cpukit/score/cpu/unix/cpu.c

    ref1be69 rc03e2bc  
    277277 *  This routine performs processor dependent initialization.
    278278 *
    279  *  INPUT PARAMETERS:
    280  *    thread_dispatch - address of dispatching routine
    281  */
    282 
    283 
    284 void _CPU_Initialize(
    285   void            (*thread_dispatch)      /* ignored on this CPU */
    286 )
     279 *  INPUT PARAMETERS: NONE
     280 */
     281
     282void _CPU_Initialize(void)
    287283{
    288284  /*
     
    294290  if ( sizeof(Context_Control_overlay) > sizeof(Context_Control) )
    295291    _CPU_Fatal_error(0x100 + 1);
    296 
    297   /*
    298    *  The thread_dispatch argument is the address of the entry point
    299    *  for the routine called at the end of an ISR once it has been
    300    *  decided a context switch is necessary.  On some compilation
    301    *  systems it is difficult to call a high-level language routine
    302    *  from assembly.  This allows us to trick these systems.
    303    *
    304    *  If you encounter this problem save the entry point in a CPU
    305    *  dependent variable.
    306    */
    307 
    308   _CPU_Thread_dispatch_pointer = thread_dispatch;
    309292
    310293  /*
  • cpukit/score/cpu/unix/rtems/score/cpu.h

    ref1be69 rc03e2bc  
    530530
    531531/*
    532  *  With some compilation systems, it is difficult if not impossible to
    533  *  call a high-level language routine from assembly language.  This
    534  *  is especially true of commercial Ada compilers and name mangling
    535  *  C++ ones.  This variable can be optionally defined by the CPU porter
    536  *  and contains the address of the routine _Thread_Dispatch.  This
    537  *  can make it easier to invoke that routine at the end of the interrupt
    538  *  sequence (if a dispatch is necessary).
    539  */
    540 
    541 SCORE_EXTERN void           (*_CPU_Thread_dispatch_pointer)(void);
    542 
    543 /*
    544532 *  Nothing prevents the porter from declaring more CPU specific variables.
    545533 */
     
    876864 */
    877865
    878 void _CPU_Initialize(
    879   void      (*thread_dispatch)
    880 );
     866void _CPU_Initialize(void);
    881867
    882868/*
Note: See TracChangeset for help on using the changeset viewer.