Commit 780431e3 authored by Mike Frysinger's avatar Mike Frysinger Committed by Bryan Wu
Browse files

Blackfin arch: cleanup and promote the general purpose timers api to a core blackfin component 



Signed-off-by: default avatarMike Frysinger <michael.frysinger@analog.com>
Signed-off-by: default avatarBryan Wu <bryan.wu@analog.com>
parent 29cae113

arch/blackfin/Kconfig

+10 −0
Original line number Diff line number Diff line
@@ -788,6 +788,16 @@ config LARGE_ALLOCS 
	  a lot of RAM, and you need to able to allocate very large

	  contiguous chunks. If unsure, say N.



config BFIN_GPTIMERS

	tristate "Enable Blackfin General Purpose Timers API"

	default n

	help

	  Enable support for the General Purpose Timers API.  If you

	  are unsure, say N.



	  To compile this driver as a module, choose M here: the module

	  will be called gptimers.ko.



config BFIN_DMA_5XX

	bool "Enable DMA Support"

	depends on (BF52x || BF53x || BF561 || BF54x)

arch/blackfin/Makefile

+13 −2
Original line number Diff line number Diff line
@@ -105,12 +105,23 @@ archclean: 
	$(Q)$(MAKE) $(clean)=$(boot)





all: vmImage

boot := arch/$(ARCH)/boot

BOOT_TARGETS = vmImage

.PHONY: $(BOOT_TARGETS)

PHONY += $(BOOT_TARGETS) install

KBUILD_IMAGE := $(boot)/vmImage



all: vmImage



$(BOOT_TARGETS): vmlinux

	$(Q)$(MAKE) $(build)=$(boot) $(boot)/$@



install:

	$(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(KBUILD_IMAGE) install



define archhelp

  echo  '* vmImage         - Kernel-only image for U-Boot (arch/$(ARCH)/boot/vmImage)'

  echo  '  install         - Install kernel using'

  echo  '                     (your) ~/bin/$(CROSS_COMPILE)installkernel or'

  echo  '                     (distribution) PATH: $(CROSS_COMPILE)installkernel or'

  echo  '                     install to $$(INSTALL_PATH)'

endef

arch/blackfin/kernel/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ obj-y := \ 
	sys_bfin.o time.o traps.o irqchip.o dma-mapping.o flat.o \

	fixed_code.o cplbinit.o cacheinit.o reboot.o bfin_gpio.o



obj-$(CONFIG_BFIN_GPTIMERS)          += gptimers.o

obj-$(CONFIG_MODULES)                += module.o

obj-$(CONFIG_BFIN_DMA_5XX)           += bfin_dma_5xx.o

obj-$(CONFIG_DUAL_CORE_TEST_MODULE)  += dualcore_test.o

arch/blackfin/kernel/gptimers.c

0 → 100644
+250 −0
Original line number Diff line number Diff line 
/*

 * bfin_gptimers.c - derived from bf53x_timers.c

 *  Driver for General Purpose Timer functions on the Blackfin processor

 *

 *  Copyright (C) 2005 John DeHority

 *  Copyright (C) 2006 Hella Aglaia GmbH (awe@aglaia-gmbh.de)

 *

 * Licensed under the GPLv2.

 */



#include <linux/kernel.h>

#include <linux/module.h>



#include <asm/io.h>

#include <asm/blackfin.h>

#include <asm/gptimers.h>



#ifdef DEBUG

# define tassert(expr)

#else

# define tassert(expr) \

	if (!(expr)) \

		printk(KERN_DEBUG "%s:%s:%i: Assertion failed: " #expr "\n", \

			__FILE__, __func__, __LINE__);

#endif



#define BFIN_TIMER_NUM_GROUP  (BFIN_TIMER_OCTET(MAX_BLACKFIN_GPTIMERS - 1) + 1)



typedef struct {

	uint16_t config;

	uint16_t __pad;

	uint32_t counter;

	uint32_t period;

	uint32_t width;

} GPTIMER_timer_regs;



typedef struct {

	uint16_t enable;

	uint16_t __pad0;

	uint16_t disable;

	uint16_t __pad1;

	uint32_t status;

} GPTIMER_group_regs;



static volatile GPTIMER_timer_regs *const timer_regs[MAX_BLACKFIN_GPTIMERS] =

{

	(GPTIMER_timer_regs *)TIMER0_CONFIG,

	(GPTIMER_timer_regs *)TIMER1_CONFIG,

	(GPTIMER_timer_regs *)TIMER2_CONFIG,

#if (MAX_BLACKFIN_GPTIMERS > 3)

	(GPTIMER_timer_regs *)TIMER3_CONFIG,

	(GPTIMER_timer_regs *)TIMER4_CONFIG,

	(GPTIMER_timer_regs *)TIMER5_CONFIG,

	(GPTIMER_timer_regs *)TIMER6_CONFIG,

	(GPTIMER_timer_regs *)TIMER7_CONFIG,

#endif

#if (MAX_BLACKFIN_GPTIMERS > 8)

	(GPTIMER_timer_regs *)TIMER8_CONFIG,

	(GPTIMER_timer_regs *)TIMER9_CONFIG,

	(GPTIMER_timer_regs *)TIMER10_CONFIG,

	(GPTIMER_timer_regs *)TIMER11_CONFIG,

#endif

};



static volatile GPTIMER_group_regs *const group_regs[BFIN_TIMER_NUM_GROUP] =

{

	(GPTIMER_group_regs *)TIMER0_GROUP_REG,

#if (MAX_BLACKFIN_GPTIMERS > 8)

	(GPTIMER_group_regs *)TIMER8_GROUP_REG,

#endif

};



static uint32_t const dis_mask[MAX_BLACKFIN_GPTIMERS] =

{

	TIMER_STATUS_TRUN0,

	TIMER_STATUS_TRUN1,

	TIMER_STATUS_TRUN2,

#if (MAX_BLACKFIN_GPTIMERS > 3)

	TIMER_STATUS_TRUN3,

	TIMER_STATUS_TRUN4,

	TIMER_STATUS_TRUN5,

	TIMER_STATUS_TRUN6,

	TIMER_STATUS_TRUN7,

#endif

#if (MAX_BLACKFIN_GPTIMERS > 8)

	TIMER_STATUS_TRUN8,

	TIMER_STATUS_TRUN9,

	TIMER_STATUS_TRUN10,

	TIMER_STATUS_TRUN11,

#endif

};



static uint32_t const irq_mask[MAX_BLACKFIN_GPTIMERS] =

{

	TIMER_STATUS_TIMIL0,

	TIMER_STATUS_TIMIL1,

	TIMER_STATUS_TIMIL2,

#if (MAX_BLACKFIN_GPTIMERS > 3)

	TIMER_STATUS_TIMIL3,

	TIMER_STATUS_TIMIL4,

	TIMER_STATUS_TIMIL5,

	TIMER_STATUS_TIMIL6,

	TIMER_STATUS_TIMIL7,

#endif

#if (MAX_BLACKFIN_GPTIMERS > 8)

	TIMER_STATUS_TIMIL8,

	TIMER_STATUS_TIMIL9,

	TIMER_STATUS_TIMIL10,

	TIMER_STATUS_TIMIL11,

#endif

};



void set_gptimer_pwidth(int timer_id, uint32_t value)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	timer_regs[timer_id]->width = value;

	SSYNC();

}

EXPORT_SYMBOL(set_gptimer_pwidth);



uint32_t get_gptimer_pwidth(int timer_id)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	return timer_regs[timer_id]->width;

}

EXPORT_SYMBOL(get_gptimer_pwidth);



void set_gptimer_period(int timer_id, uint32_t period)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	timer_regs[timer_id]->period = period;

	SSYNC();

}

EXPORT_SYMBOL(set_gptimer_period);



uint32_t get_gptimer_period(int timer_id)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	return timer_regs[timer_id]->period;

}

EXPORT_SYMBOL(get_gptimer_period);



uint32_t get_gptimer_count(int timer_id)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	return timer_regs[timer_id]->counter;

}

EXPORT_SYMBOL(get_gptimer_count);



uint32_t get_gptimer_status(int group)

{

	tassert(group < BFIN_TIMER_NUM_GROUP);

	return group_regs[group]->status;

}

EXPORT_SYMBOL(get_gptimer_status);



void set_gptimer_status(int group, uint32_t value)

{

	tassert(group < BFIN_TIMER_NUM_GROUP);

	group_regs[group]->status = value;

	SSYNC();

}

EXPORT_SYMBOL(set_gptimer_status);



uint16_t get_gptimer_intr(int timer_id)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	return (group_regs[BFIN_TIMER_OCTET(timer_id)]->status & irq_mask[timer_id]) ? 1 : 0;

}

EXPORT_SYMBOL(get_gptimer_intr);



void clear_gptimer_intr(int timer_id)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	group_regs[BFIN_TIMER_OCTET(timer_id)]->status = irq_mask[timer_id];

}

EXPORT_SYMBOL(clear_gptimer_intr);



void set_gptimer_config(int timer_id, uint16_t config)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	timer_regs[timer_id]->config = config;

	SSYNC();

}

EXPORT_SYMBOL(set_gptimer_config);



uint16_t get_gptimer_config(int timer_id)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	return timer_regs[timer_id]->config;

}

EXPORT_SYMBOL(get_gptimer_config);



void enable_gptimers(uint16_t mask)

{

	int i;

	tassert((mask & ~BLACKFIN_GPTIMER_IDMASK) == 0);

	for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i) {

		group_regs[i]->enable = mask & 0xFF;

		mask >>= 8;

	}

	SSYNC();

}

EXPORT_SYMBOL(enable_gptimers);



void disable_gptimers(uint16_t mask)

{

	int i;

	uint16_t m = mask;

	tassert((mask & ~BLACKFIN_GPTIMER_IDMASK) == 0);

	for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i) {

		group_regs[i]->disable = m & 0xFF;

		m >>= 8;

	}

	for (i = 0; i < MAX_BLACKFIN_GPTIMERS; ++i)

		if (mask & (1 << i))

			group_regs[BFIN_TIMER_OCTET(i)]->status |= dis_mask[i];

	SSYNC();

}

EXPORT_SYMBOL(disable_gptimers);



void set_gptimer_pulse_hi(int timer_id)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	timer_regs[timer_id]->config |= TIMER_PULSE_HI;

	SSYNC();

}

EXPORT_SYMBOL(set_gptimer_pulse_hi);



void clear_gptimer_pulse_hi(int timer_id)

{

	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);

	timer_regs[timer_id]->config &= ~TIMER_PULSE_HI;

	SSYNC();

}

EXPORT_SYMBOL(clear_gptimer_pulse_hi);



uint16_t get_enabled_gptimers(void)

{

	int i;

	uint16_t result = 0;

	for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i)

		result |= (group_regs[i]->enable << (i << 3));

	return result;

}

EXPORT_SYMBOL(get_enabled_gptimers);



MODULE_AUTHOR("Axel Weiss (awe@aglaia-gmbh.de)");

MODULE_DESCRIPTION("Blackfin General Purpose Timers API");

MODULE_LICENSE("GPL");

include/asm-blackfin/bf5xx_timers.h→include/asm-blackfin/gptimers.h

+210 −0
Original line number Diff line number Diff line
@@ -12,9 +12,11 @@ 
#ifndef _BLACKFIN_TIMERS_H_

#define _BLACKFIN_TIMERS_H_



#undef MAX_BLACKFIN_GPTIMERS

#include <linux/types.h>

#include <asm/blackfin.h>



/*

 * BF537: 8 timers:

 * BF537/BF527: 8 timers:

 */

#if defined(BF527_FAMILY) || defined(BF537_FAMILY)

# define MAX_BLACKFIN_GPTIMERS 8
@@ -101,7 +103,7 @@ 
#endif



/*

** Timer Configuration Register Bits

 * Timer Configuration Register Bits

 */

#define TIMER_ERR           0xC000

#define TIMER_ERR_OVFL      0x4000
@@ -121,7 +123,7 @@ 
#define TIMER_MODE_EXT_CLK  0x0003



/*

** Timer Status Register Bits

 * Timer Status Register Bits

 */

#define TIMER_STATUS_TIMIL0 0x0001

#define TIMER_STATUS_TIMIL1 0x0002
@@ -164,7 +166,7 @@ 
#endif



/*

** Timer Slave Enable Status : write 1 to clear

 * Timer Slave Enable Status : write 1 to clear

 */

#define TIMER_STATUS_TRUN0  0x1000

#define TIMER_STATUS_TRUN1  0x2000
@@ -186,24 +188,23 @@ 
# define TIMER_STATUS_TRUN   0x7000

#endif



/*******************************************************************************

*	GP_TIMER API's

*******************************************************************************/



void  set_gptimer_pwidth    (int timer_id, int width);

int   get_gptimer_pwidth    (int timer_id);

void  set_gptimer_period    (int timer_id, int period);

int   get_gptimer_period    (int timer_id);

int   get_gptimer_count     (int timer_id);

short get_gptimer_intr      (int timer_id);

void  set_gptimer_config    (int timer_id, short config);

short get_gptimer_config    (int timer_id);

/* The actual gptimer API */



void     set_gptimer_pwidth    (int timer_id, uint32_t width);

uint32_t get_gptimer_pwidth    (int timer_id);

void     set_gptimer_period    (int timer_id, uint32_t period);

uint32_t get_gptimer_period    (int timer_id);

uint32_t get_gptimer_count     (int timer_id);

uint16_t get_gptimer_intr      (int timer_id);

void     clear_gptimer_intr    (int timer_id);

void     set_gptimer_config    (int timer_id, uint16_t config);

uint16_t get_gptimer_config    (int timer_id);

void     set_gptimer_pulse_hi  (int timer_id);

void     clear_gptimer_pulse_hi(int timer_id);

void  enable_gptimers       (short mask);

void  disable_gptimers      (short mask);

short get_enabled_timers    (void);

int   get_gptimer_status    (int octet);

void  set_gptimer_status    (int octet, int value);

void     enable_gptimers       (uint16_t mask);

void     disable_gptimers      (uint16_t mask);

uint16_t get_enabled_gptimers  (void);

uint32_t get_gptimer_status    (int group);

void     set_gptimer_status    (int group, uint32_t value);



#endif