source: rtems/c/src/lib/libbsp/m68k/uC5282/clock/clock.c @ 2dfdecd

4.115
Last change on this file since 2dfdecd was 2dfdecd, checked in by Joel Sherrill <joel.sherrill@…>, on 09/30/13 at 17:07:07

uC5282/.../clock.c: Change get nanoseconds handler to static

  • Property mode set to 100644
File size: 5.5 KB
Line 
1/*
2 * Use the last periodic interval timer (PIT3) as the system clock.
3 *
4 *  Author: W. Eric Norum <norume@aps.anl.gov>
5 *
6 *  COPYRIGHT (c) 2005.
7 *  On-Line Applications Research Corporation (OAR).
8 *
9 *  The license and distribution terms for this file may be
10 *  found in the file LICENSE in this distribution or at
11 *  http://www.rtems.com/license/LICENSE.
12 */
13
14#include <rtems.h>
15#include <bsp.h>
16#include <mcf5282/mcf5282.h>
17
18/*
19 * Use INTC0 base
20 */
21#define CLOCK_VECTOR (64+58)
22
23/*
24 * CPU load counters
25 * Place in static RAM so updates don't hit the SDRAM
26 */
27#define IDLE_COUNTER    __SRAMBASE.idle_counter
28#define FILTERED_IDLE   __SRAMBASE.filtered_idle
29#define MAX_IDLE_COUNT  __SRAMBASE.max_idle_count
30#define PITC_PER_TICK   __SRAMBASE.pitc_per_tick
31#define NSEC_PER_PITC   __SRAMBASE.nsec_per_pitc
32#define FILTER_SHIFT    6
33
34static uint32_t bsp_clock_nanoseconds_since_last_tick(void)
35{
36    int i = MCF5282_PIT3_PCNTR;
37    if (MCF5282_PIT3_PCSR & MCF5282_PIT_PCSR_PIF)
38        i = MCF5282_PIT3_PCNTR - PITC_PER_TICK;
39    return (PITC_PER_TICK - i) * NSEC_PER_PITC;
40}
41
42#define Clock_driver_nanoseconds_since_last_tick \
43    bsp_clock_nanoseconds_since_last_tick
44
45/*
46 * Periodic interval timer interrupt handler
47 */
48#define Clock_driver_support_at_tick()                                       \
49    do {                                                                     \
50        unsigned idle = IDLE_COUNTER;                                        \
51        IDLE_COUNTER = 0;                                                    \
52        if (idle > MAX_IDLE_COUNT)                                           \
53            MAX_IDLE_COUNT = idle;                                           \
54        FILTERED_IDLE = idle + FILTERED_IDLE - (FILTERED_IDLE>>FILTER_SHIFT);\
55        MCF5282_PIT3_PCSR |= MCF5282_PIT_PCSR_PIF;                           \
56    } while (0)
57
58/*
59 * Attach clock interrupt handler
60 */
61#define Clock_driver_support_install_isr( _new, _old )              \
62    do {                                                            \
63        _old = (rtems_isr_entry)set_vector(_new, CLOCK_VECTOR, 1);  \
64    } while(0)
65
66/*
67 * Turn off the clock
68 */
69#define Clock_driver_support_shutdown_hardware()   \
70    do {                                           \
71        MCF5282_PIT3_PCSR &= ~MCF5282_PIT_PCSR_EN; \
72    } while(0)
73
74/*
75 * Set up the clock hardware
76 *
77 * f_pit = f_clk / 2^(preScaleCode+1) / N  = 1/(us_per_tick/us_per_s)
78 *
79 * N = f_clk / 2^(preScaleCode+1) * us_per_tick / us_per_s
80 *
81 * ns_per_pit_clk = ns_per_s / (f_clk / 2^(preScaleCode+1))
82 *                = ns_per_s * 2^(preScaleCode+1) / f_clk;
83 */
84#define Clock_driver_support_initialize_hardware()                       \
85    do {                                                                 \
86                unsigned long long N;                                            \
87        int level;                                                       \
88        int preScaleCode = 0;                                            \
89                N  = bsp_get_CPU_clock_speed();                                  \
90                N *= rtems_configuration_get_microseconds_per_tick();            \
91                N /= 2*1000000; /* min_prescale * us_per_s */                    \
92                while ( N > 0x10000 ) {                                          \
93                        preScaleCode++;                                              \
94                        N >>= 1;                                                     \
95                }                                                                \
96                PITC_PER_TICK  = N;                                              \
97                N  = 2000000000ULL << preScaleCode;                              \
98                N /= bsp_get_CPU_clock_speed();                                  \
99                NSEC_PER_PITC  = N;                                              \
100        IDLE_COUNTER   = 0;                                              \
101        FILTERED_IDLE  = 0;                                              \
102        MAX_IDLE_COUNT = 0;                                              \
103        bsp_allocate_interrupt(PIT3_IRQ_LEVEL, PIT3_IRQ_PRIORITY);       \
104        MCF5282_INTC0_ICR58 = MCF5282_INTC_ICR_IL(PIT3_IRQ_LEVEL) |      \
105                              MCF5282_INTC_ICR_IP(PIT3_IRQ_PRIORITY);    \
106        rtems_interrupt_disable( level );                                \
107        MCF5282_INTC0_IMRH &= ~MCF5282_INTC_IMRH_INT58;                  \
108        MCF5282_PIT3_PCSR &= ~MCF5282_PIT_PCSR_EN;                       \
109        rtems_interrupt_enable( level );                                 \
110        MCF5282_PIT3_PCSR = MCF5282_PIT_PCSR_PRE(preScaleCode) |         \
111                            MCF5282_PIT_PCSR_OVW |                       \
112                            MCF5282_PIT_PCSR_PIE |                       \
113                            MCF5282_PIT_PCSR_RLD;                        \
114        MCF5282_PIT3_PMR = PITC_PER_TICK - 1;                            \
115        MCF5282_PIT3_PCSR = MCF5282_PIT_PCSR_PRE(preScaleCode) |         \
116                            MCF5282_PIT_PCSR_PIE |                       \
117                            MCF5282_PIT_PCSR_RLD |                       \
118                            MCF5282_PIT_PCSR_EN;                         \
119    } while (0)
120
121/*
122 * Provide our own version of the idle task
123 */
124Thread bsp_idle_thread(uint32_t ignored)
125{
126  /* Atomic increment */
127  for(;;)
128    __asm__ volatile ("addq.l #1,%0"::"m"(IDLE_COUNTER));
129}
130
131int rtems_bsp_cpu_load_percentage(void)
132{
133    return MAX_IDLE_COUNT ?
134           (100 - ((100 * (FILTERED_IDLE >> FILTER_SHIFT)) / MAX_IDLE_COUNT)) :
135           0;
136}
137
138#include "../../../shared/clockdrv_shell.h"
Note: See TracBrowser for help on using the repository browser.