pm.c File Reference

#include "pm.h"

Include dependency graph for pm.c:

Go to the source code of this file.

Functions
int	pm_generic_clock_control (struct gen_clk_opt_t *opt, unsigned char genclk)
int	pm_interrupt_clear (unsigned int source)
int	pm_interrupt_disable (unsigned int source)
int	pm_interrupt_enable (unsigned int source)
int	pm_interrupt_mask (unsigned int source)
int	pm_interrupt_status (unsigned int source)
void	pm_mask_all_module_clocks (void)
int	pm_mask_module_clock (unsigned int clock)
int	pm_read_clock_domain_scaler (unsigned int clock_domain)
int	pm_read_mclk (void)
int	pm_read_mclk_source (void)
int	pm_read_module_frequency (int module)
int	pm_read_osc (unsigned int osc)
int	pm_read_pll_frequency (unsigned int pll)
int	pm_read_scaling_register (void)
int	pm_reset (void)
int	pm_set_clock_domain_scaler (volatile struct clk_sel_opt_t *opt)
int	pm_set_mclk_source (unsigned int source)
int	pm_set_pll (volatile struct pll_opt_t *opt)
void	pm_unmask_all_module_clocks (void)
int	pm_unmask_module_clock (unsigned int clock)
int	pm_wait_for_lock (unsigned int lockbit)

---

Function Documentation

int pm_generic_clock_control	(	struct gen_clk_opt_t *	opt,
		unsigned char	genclk
	)

Definition at line 520 of file pm.c.

References gen_clk_opt_t::cen, gen_clk_opt_t::div, gen_clk_opt_t::diven, INVALID_ARGUMENT, gen_clk_opt_t::oscsel, and gen_clk_opt_t::pllsel.

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        /* Check whether div-field is larger than 8 bits */
        if( opt->div > 0xFF)
                return INVALID_ARGUMENT;
        /* Check for valid single bits */
        if ( ((opt->diven)|(opt->cen)|(opt->pllsel)|(opt->oscsel)|(genclk > 1)) > 1 )
                return INVALID_ARGUMENT;
        else
                pm->gcctrl[genclk] = ( (opt->div << AVR32_PM_GCCTRL0_DIV_OFFSET)| \
                        (opt->diven << AVR32_PM_GCCTRL0_DIVEN_OFFSET)|\
                        (opt->cen << AVR32_PM_GCCTRL0_CEN_OFFSET)|\
                        (opt->pllsel << AVR32_PM_GCCTRL0_PLLSEL_OFFSET)|\
                        (opt->oscsel << AVR32_PM_GCCTRL0_OSCSEL_OFFSET) );
        
        return 0;
} /* End pm_generic_clock_control() */

int pm_interrupt_clear

(

unsigned int

source

)

Definition at line 491 of file pm.c.

References INVALID_ARGUMENT, and PM_INT_SOURCES.

Referenced by pm_wait_for_lock().

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        if( source > (PM_INT_SOURCES-1) )
                return INVALID_ARGUMENT;
        else{
                pm->icr |= (1 << source);
                return 0;
        }
}

int pm_interrupt_disable

(

unsigned int

source

)

Definition at line 463 of file pm.c.

References INVALID_ARGUMENT, and PM_INT_SOURCES.

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        if( source > (PM_INT_SOURCES-1) )
                return INVALID_ARGUMENT;
        else{
                pm->idr |= (1 << source);
                return 0;
        }
}

int pm_interrupt_enable

(

unsigned int

source

)

Definition at line 448 of file pm.c.

References INVALID_ARGUMENT, and PM_INT_SOURCES.

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        if( source > (PM_INT_SOURCES-1) )
                return INVALID_ARGUMENT;
        else{
                pm->ier |= (1 << source);
                return 0;
        }
}

int pm_interrupt_mask

(

unsigned int

source

)

Definition at line 506 of file pm.c.

References INVALID_ARGUMENT, and PM_INT_SOURCES.

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        if( source > (PM_INT_SOURCES-1) )
                return INVALID_ARGUMENT;
        else{
                return (pm->ier & source ) >> source ;
        }
}

int pm_interrupt_status

(

unsigned int

source

)

Definition at line 478 of file pm.c.

References INVALID_ARGUMENT, and PM_INT_SOURCES.

Referenced by pm_wait_for_lock().

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        if ( source > (PM_INT_SOURCES-1) )
                return INVALID_ARGUMENT;
        else
                return (pm->isr & source)>>source;
}

void pm_mask_all_module_clocks

(

void

)

Definition at line 413 of file pm.c.

References pm_wait_for_lock().

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        pm->cpu_mask = 0xFFFFffff;
        pm->hsb_mask = 0xFFFFffff;
        pm->pba_mask = 0xFFFFffff;
        pm->pbb_mask = 0xFFFFffff;

        pm_wait_for_lock(AVR32_PM_ISR_MSKRDY);
}

Here is the call graph for this function:

int pm_mask_module_clock

(

unsigned int

clock

)

Definition at line 357 of file pm.c.

References INVALID_ARGUMENT, PM_CPU_DOMAIN, PM_CPU_DOMAIN_SIZE, PM_HSB_DOMAIN, PM_HSB_DOMAIN_SIZE, PM_PBA_DOMAIN, PM_PBA_DOMAIN_SIZE, PM_PBB_DOMAIN, and PM_PBB_DOMAIN_SIZE.

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        switch (clock % 32){
                case PM_CPU_DOMAIN:
                        /* Check whether the clock is out of bounds */
                        if( (clock/32) > PM_CPU_DOMAIN_SIZE )
                                return INVALID_ARGUMENT;
                        else{
                                pm->cpu_mask &= ~( 1<<(clock/32) );
                                break;
                        }
                case PM_HSB_DOMAIN:
                        /* Check whether the clock is out of bounds */
                        if( (clock/32) > PM_HSB_DOMAIN_SIZE )
                                return INVALID_ARGUMENT;
                        else{
                                pm->hsb_mask &= ~( 1<<(clock/32) );
                                break;
                        }
                case PM_PBA_DOMAIN:
                        /* Check whether the clock is out of bounds */
                        if( (clock/32) > PM_PBA_DOMAIN_SIZE )
                                return INVALID_ARGUMENT;
                        else{
                                pm->pba_mask &= ~( 1<<(clock/32) );
                                break;
                        }
                case PM_PBB_DOMAIN:
                        /* Check whether the clock is out of bounds */
                        if( (clock/32) > PM_PBB_DOMAIN_SIZE )
                                return INVALID_ARGUMENT;
                        else{
                                pm->pbb_mask &= ~( 1<<(clock/32) );
                                break;
                        }
                default:
                        return INVALID_ARGUMENT;
        }
        return 0;
} /* End pm_stop_clock */

int pm_read_clock_domain_scaler

(

unsigned int

clock_domain

)

Definition at line 222 of file pm.c.

References INVALID_ARGUMENT, PM_CPU_DOMAIN, PM_HSB_DOMAIN, PM_PBA_DOMAIN, and PM_PBB_DOMAIN.

Referenced by pm_read_module_frequency().

{
        static avr32_pm_t *pm = (void *) AVR32_PM_ADDRESS;
        int divider, offset;

        /* Get offset for divider */
        if(clock_domain == PM_PBB_DOMAIN)
                offset = AVR32_PM_CKSEL_PBBSEL_OFFSET;
        else if(clock_domain == PM_PBA_DOMAIN)
                offset = AVR32_PM_CKSEL_PBASEL_OFFSET;
        else if(clock_domain == PM_HSB_DOMAIN)
                offset = AVR32_PM_CKSEL_HSBSEL_OFFSET;
        else if(clock_domain == PM_CPU_DOMAIN)
                offset = AVR32_PM_CKSEL_CPUSEL_OFFSET;
        else
                return INVALID_ARGUMENT;


        divider = pm->cksel & (AVR32_PM_CKSEL_CPUSEL_MASK<<offset);
        divider = divider >> offset;

        return (divider+1);

} /* End pm_read_clock_domain_scaler() */

int pm_read_mclk

(

void

)

Definition at line 200 of file pm.c.

References INVALID_ARGUMENT, PM_OSC0, PM_OSC0_HZ, PM_PLL0, pm_read_mclk_source(), and pm_read_pll_frequency().

Referenced by board_init(), pm_read_module_frequency(), and usdelay().

{
        unsigned int f_hz, source;

        /* Get mclk clock source */
        source = pm_read_mclk_source();

        /* check wheter oscillator 0 is used */
        if( source == PM_OSC0 )
                f_hz = PM_OSC0_HZ;
        /* check wheter pll 0 is used */
        else if ( source == PM_PLL0 )
                f_hz = pm_read_pll_frequency(PM_PLL0);
        else
                return INVALID_ARGUMENT;

        return f_hz;
} /* End pm_read_mclk() */

Here is the call graph for this function:

int pm_read_mclk_source

(

void

)

Definition at line 182 of file pm.c.

References INVALID_ARGUMENT, PM_OSC0, and PM_PLL0.

Referenced by pm_read_mclk(), and pm_set_pll().

{
        int source;
        avr32_pm_t *pm = (void *) AVR32_PM_ADDRESS;

        source = (pm->mcctrl)&AVR32_PM_PLLSEL_MASK;

        if(source==0)
                return PM_OSC0;
        else if(source==AVR32_PM_PLLSEL_MASK)
                return PM_PLL0;
        else
                return INVALID_ARGUMENT;
}

int pm_read_module_frequency

(

int

module

)

Definition at line 425 of file pm.c.

References INVALID_ARGUMENT, PM_HSB_DOMAIN, PM_PBA_DOMAIN, PM_PBB_DOMAIN, pm_read_clock_domain_scaler(), and pm_read_mclk().

Referenced by init_spiMaster(), init_uart_a(), and mt481c2m32b2tg_init().

{
        int clk, domain, divider;

        clk = pm_read_mclk();
        divider = pm_read_clock_domain_scaler(PM_HSB_DOMAIN);
        domain = module/32;
        
        if ( domain == PM_HSB_DOMAIN )
                divider = divider;
        else if( domain==PM_PBA_DOMAIN )
                divider = divider * pm_read_clock_domain_scaler(PM_PBA_DOMAIN);
        else if( domain==PM_PBB_DOMAIN )
                divider = divider * pm_read_clock_domain_scaler(PM_PBB_DOMAIN);
        else
                return INVALID_ARGUMENT;

        /* CHECK WHETHER THE CLOCK IS MASKED */

        return clk/divider;
}

Here is the call graph for this function:

int pm_read_osc

(

unsigned int

osc

)

Definition at line 151 of file pm.c.

References INVALID_ARGUMENT, PM_OSC0_HZ, and PM_OSC1_HZ.

{
        if(osc == 0)
                return PM_OSC0_HZ;
        else if(osc == 1)
                return PM_OSC1_HZ;
        else
                return INVALID_ARGUMENT;
}

int pm_read_pll_frequency

(

unsigned int

pll

)

Definition at line 122 of file pm.c.

References INVALID_ARGUMENT, PM_OSC0_HZ, PM_OSC1_HZ, PM_PLL0, and PM_PLL1.

Referenced by pm_read_mclk().

{
        volatile avr32_pm_t *pm = (void *) AVR32_PM_ADDRESS;
        unsigned int mul,div,osc;

        if ( pll==PM_PLL0 ){
                mul = ( (pm->pll0&AVR32_PM_PLL0_PLLMUL_MASK)>>AVR32_PM_PLL0_PLLMUL_OFFSET)+1;
                div = ( (pm->pll0&AVR32_PM_PLL0_PLLDIV_MASK)>>AVR32_PM_PLL0_PLLDIV_OFFSET)+1;
                if((pm->pll0&AVR32_PM_PLL0_PLLOSC_MASK)>>AVR32_PM_PLL0_PLLOSC_OFFSET) /* Oscillator #1 */
                        osc = PM_OSC1_HZ;
                else
                        osc = PM_OSC0_HZ;
        }
        else if ( pll==PM_PLL1 ){
                mul = ( (pm->pll1&AVR32_PM_PLL1_PLLMUL_MASK)>>AVR32_PM_PLL1_PLLMUL_OFFSET)+1;
                div = ( (pm->pll1&AVR32_PM_PLL1_PLLDIV_MASK)>>AVR32_PM_PLL1_PLLDIV_OFFSET)+1;
                if((pm->pll1&AVR32_PM_PLL1_PLLOSC_MASK)>>AVR32_PM_PLL1_PLLOSC_OFFSET) /* Oscillator #1 */
                        osc = PM_OSC1_HZ;
                else
                        osc = PM_OSC0_HZ;
        }
        else
                return INVALID_ARGUMENT;

        return (mul*osc)/div;
}

int pm_read_scaling_register

(

void

)

Definition at line 303 of file pm.c.

{
        volatile avr32_pm_t *pm = (void *) AVR32_PM_ADDRESS;

        return pm->cksel;
}

int pm_reset

(

void

)

Definition at line 31 of file pm.c.

References PM_OSC0, pm_set_mclk_source(), pm_wait_for_lock(), and SUCCESS.

{
        avr32_pm_t *pm = (void *) AVR32_PM_ADDRESS;
        unsigned int status = SUCCESS;
        int disable_clock_mask = 0xFFFFffff;

        pm_set_mclk_source(PM_OSC0);

        pm->cksel = 0x00000000;
        status |= pm_wait_for_lock(AVR32_PM_ISR_CKRDY);

        pm->cpu_mask = disable_clock_mask;
        status |= pm_wait_for_lock(AVR32_PM_ISR_MSKRDY);

        pm->hsb_mask = disable_clock_mask;
        status |= pm_wait_for_lock(AVR32_PM_ISR_MSKRDY);

        pm->pba_mask = disable_clock_mask;
        status |= pm_wait_for_lock(AVR32_PM_ISR_MSKRDY);

        pm->pbb_mask = disable_clock_mask;
        status |= pm_wait_for_lock(AVR32_PM_ISR_MSKRDY);

        pm->ier = 0x7F; /* enable all interrupts*/
        pm->icr |= 0x7F; /* clear all interrupts */

        return status;
}

Here is the call graph for this function:

int pm_set_clock_domain_scaler

(

volatile struct clk_sel_opt_t *

opt

)

Definition at line 250 of file pm.c.

References clk_sel_opt_t::clock, clk_sel_opt_t::div_enable, clk_sel_opt_t::divider, INVALID_ARGUMENT, PM_CPU_DOMAIN, PM_HSB_DOMAIN, PM_PBA_DOMAIN, PM_PBB_DOMAIN, pm_wait_for_lock(), and SUCCESS.

{
        volatile avr32_pm_t *pm = (void *) AVR32_PM_ADDRESS;
        int offset,new_settings;

        // Check for invalid division factor
        if( (opt->div_enable == 1) & ((opt->divider == 0)|(opt->divider >= (1<<AVR32_PM_CKSEL_CPUSEL_SIZE))) )
                return INVALID_ARGUMENT;

        // Get offset for bitfields
        switch (opt->clock){
                case PM_PBB_DOMAIN:
                        offset = AVR32_PM_CKSEL_PBBSEL_OFFSET;
                        break;
                case PM_PBA_DOMAIN:
                        offset = AVR32_PM_CKSEL_PBASEL_OFFSET;
                        break;
                case PM_HSB_DOMAIN:
                        offset = AVR32_PM_CKSEL_HSBSEL_OFFSET;
                        break;
                case PM_CPU_DOMAIN:
                        offset = AVR32_PM_CKSEL_CPUSEL_OFFSET;
                        break;
                default:
                        return INVALID_ARGUMENT;
                        break;
        } /* end switch */

        // Check whether division should be disabled
        if(opt->div_enable == 0){
                new_settings = 0x00;
        }

        // Division is to be used
        else if (opt->div_enable == 1) {
                new_settings = 1<<AVR32_PM_CKSEL_CPUDIV;
                new_settings |= ((opt->divider)-1);
        }

        // Error. div_enable >1
        else
                return INVALID_ARGUMENT;

        pm->cksel &=  ~((AVR32_PM_CKSEL_CPUDIV_MASK|AVR32_PM_CKSEL_CPUSEL_MASK)<<offset);
        pm->cksel |= (new_settings<<offset);

        pm_wait_for_lock(AVR32_PM_ISR_CKRDY);

        return SUCCESS;

} /* End pm_set_clock_domain_scaler() */

Here is the call graph for this function:

int pm_set_mclk_source

(

unsigned int

source

)

Definition at line 162 of file pm.c.

References INVALID_ARGUMENT, PM_OSC0, PM_PLL0, and pm_wait_for_lock().

Referenced by board_init(), pm_reset(), and pm_set_pll().

{
        volatile avr32_pm_t *pm = (void *) AVR32_PM_ADDRESS;

        if( (source == PM_OSC0) ){
                pm->mcctrl = (0 << AVR32_PM_PLLSEL_OFFSET);
        }
        else if( source ==PM_PLL0 ){
                pm->mcctrl = (1 << AVR32_PM_PLLSEL_OFFSET);
        }
        else
                return INVALID_ARGUMENT;

        return pm_wait_for_lock(AVR32_PM_ISR_CKRDY);

}

Here is the call graph for this function:

int pm_set_pll

(

volatile struct pll_opt_t *

opt

)

Definition at line 78 of file pm.c.

References pll_opt_t::divider, INVALID_ARGUMENT, pll_opt_t::multiplier, pll_opt_t::oscillator, pll_opt_t::pll, PM_OSC0, PM_PLL0, PM_PLL1, pm_read_mclk_source(), pm_set_mclk_source(), and pm_wait_for_lock().

Referenced by board_init().

{
        volatile avr32_pm_t *pm = (void *) AVR32_PM_ADDRESS;
        unsigned int pllreg, lockbit;

        /* Ensure that mclk is driven by the current pll */
        if(pm_read_mclk_source()==PM_PLL0)
                pm_set_mclk_source(PM_OSC0);

        if ( (opt->multiplier == 0) | (opt->divider == 0) )
                return INVALID_ARGUMENT;

        pllreg = (1<<AVR32_PM_PLL0_PLLCOUNT_OFFSET)|(1<<AVR32_PM_PLL0_PLLEN_OFFSET);

        // add multiplier
        if (opt->multiplier != 0)
        pllreg = pllreg | (((opt->multiplier) -1 ) << AVR32_PM_PLLMUL_OFFSET);
        // add divider
        if(opt->divider != 0)
        pllreg = pllreg | (((opt->divider) - 1) << AVR32_PM_PLLDIV_OFFSET);
        // select oscillator
        if(opt->oscillator <= 1)
        pllreg = pllreg | ((opt->oscillator) << AVR32_PM_PLLOSC_OFFSET);


        /* CHECK FOR VALID ARGUMENTS*/
        if( opt->pll == PM_PLL0 )
                pm->pll0 = pllreg;
        else if ( opt->pll == PM_PLL1 )
                pm->pll1 = pllreg;
        else
                return INVALID_ARGUMENT;

        // Get lock bit
        if(opt->pll == PM_PLL0){
                lockbit =  AVR32_PM_ISR_LOCK0;
        }
        else{
                lockbit =  AVR32_PM_ISR_LOCK1;
        }

        return pm_wait_for_lock(lockbit);
}

Here is the call graph for this function:

void pm_unmask_all_module_clocks

(

void

)

Definition at line 401 of file pm.c.

References pm_wait_for_lock().

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        pm->cpu_mask = 0x00000000;
        pm->hsb_mask = 0x00000000;
        pm->pba_mask = 0x00000000;
        pm->pbb_mask = 0x00000000;
        pm_wait_for_lock(AVR32_PM_ISR_MSKRDY);
}

Here is the call graph for this function:

int pm_unmask_module_clock

(

unsigned int

clock

)

Definition at line 311 of file pm.c.

References INVALID_ARGUMENT, PM_CPU_DOMAIN, PM_CPU_DOMAIN_SIZE, PM_HSB_DOMAIN, PM_HSB_DOMAIN_SIZE, PM_PBA_DOMAIN, PM_PBA_DOMAIN_SIZE, PM_PBB_DOMAIN, and PM_PBB_DOMAIN_SIZE.

{
        avr32_pm_t *pm = (void *)AVR32_PM_ADDRESS;

        switch (clock % 32){
                case PM_CPU_DOMAIN:
                        /* Check whether the clock is out of bounds */
                        if( (clock/32) > PM_CPU_DOMAIN_SIZE )
                                return INVALID_ARGUMENT;
                        else{
                                pm->cpu_mask |= ( 1<<(clock/32) );
                                break;
                        }
                case PM_HSB_DOMAIN:
                        /* Check whether the clock is out of bounds */
                        if( (clock/32) > PM_HSB_DOMAIN_SIZE )
                                return INVALID_ARGUMENT;
                        else{
                                pm->hsb_mask |= ( 1<<(clock/32) );
                                break;
                        }
                case PM_PBA_DOMAIN:
                        /* Check whether the clock is out of bounds */
                        if( (clock/32) > PM_PBA_DOMAIN_SIZE )
                                return INVALID_ARGUMENT;
                        else{
                                pm->pba_mask |= ( 1<<(clock/32) );
                                break;
                        }
                case PM_PBB_DOMAIN:
                        /* Check whether the clock is out of bounds */
                        if( (clock/32) > PM_PBB_DOMAIN_SIZE )
                                return INVALID_ARGUMENT;
                        else{
                                pm->pbb_mask |= ( 1<<(clock/32) );
                                break;
                        }
                default:
                        return INVALID_ARGUMENT;
        }
        return 0;
} /* End pm_start_clock() */

int pm_wait_for_lock

(

unsigned int

lockbit

)

Definition at line 60 of file pm.c.

References pm_interrupt_clear(), pm_interrupt_status(), PM_LOCK_ERROR, PM_TIMEOUT, and SUCCESS.

Referenced by pm_mask_all_module_clocks(), pm_reset(), pm_set_clock_domain_scaler(), pm_set_mclk_source(), pm_set_pll(), and pm_unmask_all_module_clocks().

{
        unsigned int timeout = PM_TIMEOUT;
        unsigned int lockStatus=0;

        while (!lockStatus){
                lockStatus =  pm_interrupt_status(lockbit);
                --timeout;
                if (timeout==0)
                        return PM_LOCK_ERROR;
        }

        pm_interrupt_clear(lockbit);

        return SUCCESS;
}

Here is the call graph for this function:

---