[deliverable/linux.git] / arch / blackfin / kernel / gptimers.c

/*
 * gptimers.c - Blackfin General Purpose Timer core API
 *
 * Copyright (c) 2005-2008 Analog Devices Inc.
 * 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 <linux/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

#ifndef CONFIG_BF60x
# define BFIN_TIMER_NUM_GROUP  (BFIN_TIMER_OCTET(MAX_BLACKFIN_GPTIMERS - 1) + 1)
#else
# define BFIN_TIMER_NUM_GROUP  1
#endif

static struct bfin_gptimer_regs * const timer_regs[MAX_BLACKFIN_GPTIMERS] =
{
	(void *)TIMER0_CONFIG,
	(void *)TIMER1_CONFIG,
	(void *)TIMER2_CONFIG,
#if (MAX_BLACKFIN_GPTIMERS > 3)
	(void *)TIMER3_CONFIG,
	(void *)TIMER4_CONFIG,
	(void *)TIMER5_CONFIG,
	(void *)TIMER6_CONFIG,
	(void *)TIMER7_CONFIG,
# if (MAX_BLACKFIN_GPTIMERS > 8)
	(void *)TIMER8_CONFIG,
	(void *)TIMER9_CONFIG,
	(void *)TIMER10_CONFIG,
#  if (MAX_BLACKFIN_GPTIMERS > 11)
	(void *)TIMER11_CONFIG,
#  endif
# endif
#endif
};

static struct bfin_gptimer_group_regs * const group_regs[BFIN_TIMER_NUM_GROUP] =
{
	(void *)TIMER0_GROUP_REG,
#if (MAX_BLACKFIN_GPTIMERS > 8)
	(void *)TIMER8_GROUP_REG,
#endif
};

static uint32_t const trun_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,
# if (MAX_BLACKFIN_GPTIMERS > 8)
	TIMER_STATUS_TRUN8,
	TIMER_STATUS_TRUN9,
	TIMER_STATUS_TRUN10,
#  if (MAX_BLACKFIN_GPTIMERS > 11)
	TIMER_STATUS_TRUN11,
#  endif
# endif
#endif
};

static uint32_t const tovf_mask[MAX_BLACKFIN_GPTIMERS] =
{
	TIMER_STATUS_TOVF0,
	TIMER_STATUS_TOVF1,
	TIMER_STATUS_TOVF2,
#if (MAX_BLACKFIN_GPTIMERS > 3)
	TIMER_STATUS_TOVF3,
	TIMER_STATUS_TOVF4,
	TIMER_STATUS_TOVF5,
	TIMER_STATUS_TOVF6,
	TIMER_STATUS_TOVF7,
# if (MAX_BLACKFIN_GPTIMERS > 8)
	TIMER_STATUS_TOVF8,
	TIMER_STATUS_TOVF9,
	TIMER_STATUS_TOVF10,
#  if (MAX_BLACKFIN_GPTIMERS > 11)
	TIMER_STATUS_TOVF11,
#  endif
# endif
#endif
};

static uint32_t const timil_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,
# if (MAX_BLACKFIN_GPTIMERS > 8)
	TIMER_STATUS_TIMIL8,
	TIMER_STATUS_TIMIL9,
	TIMER_STATUS_TIMIL10,
#  if (MAX_BLACKFIN_GPTIMERS > 11)
	TIMER_STATUS_TIMIL11,
#  endif
# endif
#endif
};

void set_gptimer_pwidth(unsigned int timer_id, uint32_t value)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write(&timer_regs[timer_id]->width, value);
	SSYNC();
}
EXPORT_SYMBOL(set_gptimer_pwidth);

uint32_t get_gptimer_pwidth(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return bfin_read(&timer_regs[timer_id]->width);
}
EXPORT_SYMBOL(get_gptimer_pwidth);

void set_gptimer_period(unsigned int timer_id, uint32_t period)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write(&timer_regs[timer_id]->period, period);
	SSYNC();
}
EXPORT_SYMBOL(set_gptimer_period);

uint32_t get_gptimer_period(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return bfin_read(&timer_regs[timer_id]->period);
}
EXPORT_SYMBOL(get_gptimer_period);

uint32_t get_gptimer_count(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return bfin_read(&timer_regs[timer_id]->counter);
}
EXPORT_SYMBOL(get_gptimer_count);

#ifdef CONFIG_BF60x
void set_gptimer_delay(unsigned int timer_id, uint32_t delay)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write(&timer_regs[timer_id]->delay, delay);
	SSYNC();
}
EXPORT_SYMBOL(set_gptimer_delay);

uint32_t get_gptimer_delay(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return bfin_read(&timer_regs[timer_id]->delay);
}
EXPORT_SYMBOL(get_gptimer_delay);
#endif

#ifdef CONFIG_BF60x
int get_gptimer_intr(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return !!(bfin_read(&group_regs[BFIN_TIMER_OCTET(timer_id)]->data_ilat) & timil_mask[timer_id]);
}
EXPORT_SYMBOL(get_gptimer_intr);

void clear_gptimer_intr(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->data_ilat, timil_mask[timer_id]);
}
EXPORT_SYMBOL(clear_gptimer_intr);

int get_gptimer_over(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return !!(bfin_read(&group_regs[BFIN_TIMER_OCTET(timer_id)]->stat_ilat) & tovf_mask[timer_id]);
}
EXPORT_SYMBOL(get_gptimer_over);

void clear_gptimer_over(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->stat_ilat, tovf_mask[timer_id]);
}
EXPORT_SYMBOL(clear_gptimer_over);

int get_gptimer_run(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return !!(bfin_read(&group_regs[BFIN_TIMER_OCTET(timer_id)]->run) & trun_mask[timer_id]);
}
EXPORT_SYMBOL(get_gptimer_run);

uint32_t get_gptimer_status(unsigned int group)
{
	tassert(group < BFIN_TIMER_NUM_GROUP);
	return bfin_read(&group_regs[group]->data_ilat);
}
EXPORT_SYMBOL(get_gptimer_status);

void set_gptimer_status(unsigned int group, uint32_t value)
{
	tassert(group < BFIN_TIMER_NUM_GROUP);
	bfin_write(&group_regs[group]->data_ilat, value);
	SSYNC();
}
EXPORT_SYMBOL(set_gptimer_status);
#else
uint32_t get_gptimer_status(unsigned int group)
{
	tassert(group < BFIN_TIMER_NUM_GROUP);
	return bfin_read(&group_regs[group]->status);
}
EXPORT_SYMBOL(get_gptimer_status);

void set_gptimer_status(unsigned int group, uint32_t value)
{
	tassert(group < BFIN_TIMER_NUM_GROUP);
	bfin_write(&group_regs[group]->status, value);
	SSYNC();
}
EXPORT_SYMBOL(set_gptimer_status);

static uint32_t read_gptimer_status(unsigned int timer_id)
{
	return bfin_read(&group_regs[BFIN_TIMER_OCTET(timer_id)]->status);
}

int get_gptimer_intr(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return !!(read_gptimer_status(timer_id) & timil_mask[timer_id]);
}
EXPORT_SYMBOL(get_gptimer_intr);

void clear_gptimer_intr(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->status, timil_mask[timer_id]);
}
EXPORT_SYMBOL(clear_gptimer_intr);

int get_gptimer_over(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return !!(read_gptimer_status(timer_id) & tovf_mask[timer_id]);
}
EXPORT_SYMBOL(get_gptimer_over);

void clear_gptimer_over(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->status, tovf_mask[timer_id]);
}
EXPORT_SYMBOL(clear_gptimer_over);

int get_gptimer_run(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return !!(read_gptimer_status(timer_id) & trun_mask[timer_id]);
}
EXPORT_SYMBOL(get_gptimer_run);
#endif

void set_gptimer_config(unsigned int timer_id, uint16_t config)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write(&timer_regs[timer_id]->config, config);
	SSYNC();
}
EXPORT_SYMBOL(set_gptimer_config);

uint16_t get_gptimer_config(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	return bfin_read(&timer_regs[timer_id]->config);
}
EXPORT_SYMBOL(get_gptimer_config);

void enable_gptimers(uint16_t mask)
{
	int i;
#ifdef CONFIG_BF60x
	uint16_t imask;
	imask = bfin_read16(TIMER_DATA_IMSK);
	imask &= ~mask;
	bfin_write16(TIMER_DATA_IMSK, imask);
#endif
	tassert((mask & ~BLACKFIN_GPTIMER_IDMASK) == 0);
	for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i) {
		bfin_write(&group_regs[i]->enable, mask & 0xFF);
		mask >>= 8;
	}
	SSYNC();
}
EXPORT_SYMBOL(enable_gptimers);

static 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) {
		bfin_write(&group_regs[i]->disable, m & 0xFF);
		m >>= 8;
	}
}

void disable_gptimers(uint16_t mask)
{
#ifndef CONFIG_BF60x
	int i;
	_disable_gptimers(mask);
	for (i = 0; i < MAX_BLACKFIN_GPTIMERS; ++i)
		if (mask & (1 << i))
			bfin_write(&group_regs[BFIN_TIMER_OCTET(i)]->status, trun_mask[i]);
	SSYNC();
#else
	_disable_gptimers(mask);
#endif
}
EXPORT_SYMBOL(disable_gptimers);

void disable_gptimers_sync(uint16_t mask)
{
	_disable_gptimers(mask);
	SSYNC();
}
EXPORT_SYMBOL(disable_gptimers_sync);

void set_gptimer_pulse_hi(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write_or(&timer_regs[timer_id]->config, TIMER_PULSE_HI);
	SSYNC();
}
EXPORT_SYMBOL(set_gptimer_pulse_hi);

void clear_gptimer_pulse_hi(unsigned int timer_id)
{
	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	bfin_write_and(&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 |= (bfin_read(&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");
Commit	Line	Data
780431e3	1	/*
fee40119	2	* gptimers.c - Blackfin General Purpose Timer core API
780431e3	3	*
fee40119 MF	4	* Copyright (c) 2005-2008 Analog Devices Inc.
	5	* Copyright (C) 2005 John DeHority
	6	* Copyright (C) 2006 Hella Aglaia GmbH (awe@aglaia-gmbh.de)
780431e3 MF	7	*
	8	* Licensed under the GPLv2.
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
f086f234	13	#include <linux/io.h>
780431e3	14
780431e3 MF	15	#include <asm/blackfin.h>
	16	#include <asm/gptimers.h>
	17
	18	#ifdef DEBUG
	19	# define tassert(expr)
	20	#else
	21	# define tassert(expr) \
	22	if (!(expr)) \
4ad1ec71	23	printk(KERN_DEBUG "%s:%s:%i: Assertion failed: " #expr "\n", __FILE__, __func__, __LINE__);
780431e3 MF	24	#endif
780431e3 MF	25
2879bb30 SM	26	#ifndef CONFIG_BF60x
	27	# define BFIN_TIMER_NUM_GROUP (BFIN_TIMER_OCTET(MAX_BLACKFIN_GPTIMERS - 1) + 1)
	28	#else
	29	# define BFIN_TIMER_NUM_GROUP 1
	30	#endif
780431e3	31
24a6b91f	32	static struct bfin_gptimer_regs * const timer_regs[MAX_BLACKFIN_GPTIMERS] =
780431e3	33	{
24a6b91f MF	34	(void *)TIMER0_CONFIG,
	35	(void *)TIMER1_CONFIG,
	36	(void *)TIMER2_CONFIG,
780431e3	37	#if (MAX_BLACKFIN_GPTIMERS > 3)
24a6b91f MF	38	(void *)TIMER3_CONFIG,
	39	(void *)TIMER4_CONFIG,
	40	(void *)TIMER5_CONFIG,
	41	(void *)TIMER6_CONFIG,
	42	(void *)TIMER7_CONFIG,
6eceb0d4	43	# if (MAX_BLACKFIN_GPTIMERS > 8)
24a6b91f MF	44	(void *)TIMER8_CONFIG,
	45	(void *)TIMER9_CONFIG,
	46	(void *)TIMER10_CONFIG,
6eceb0d4	47	# if (MAX_BLACKFIN_GPTIMERS > 11)
24a6b91f	48	(void *)TIMER11_CONFIG,
6eceb0d4 MF	49	# endif
6eceb0d4 MF	50	# endif
780431e3 MF	51	#endif
	52	};
	53
24a6b91f	54	static struct bfin_gptimer_group_regs * const group_regs[BFIN_TIMER_NUM_GROUP] =
780431e3	55	{
24a6b91f	56	(void *)TIMER0_GROUP_REG,
780431e3	57	#if (MAX_BLACKFIN_GPTIMERS > 8)
24a6b91f	58	(void *)TIMER8_GROUP_REG,
780431e3 MF	59	#endif
	60	};
	61
4ad1ec71	62	static uint32_t const trun_mask[MAX_BLACKFIN_GPTIMERS] =
780431e3 MF	63	{
	64	TIMER_STATUS_TRUN0,
	65	TIMER_STATUS_TRUN1,
	66	TIMER_STATUS_TRUN2,
	67	#if (MAX_BLACKFIN_GPTIMERS > 3)
	68	TIMER_STATUS_TRUN3,
	69	TIMER_STATUS_TRUN4,
	70	TIMER_STATUS_TRUN5,
	71	TIMER_STATUS_TRUN6,
	72	TIMER_STATUS_TRUN7,
6eceb0d4	73	# if (MAX_BLACKFIN_GPTIMERS > 8)
780431e3 MF	74	TIMER_STATUS_TRUN8,
	75	TIMER_STATUS_TRUN9,
	76	TIMER_STATUS_TRUN10,
6eceb0d4	77	# if (MAX_BLACKFIN_GPTIMERS > 11)
780431e3	78	TIMER_STATUS_TRUN11,
6eceb0d4 MF	79	# endif
6eceb0d4 MF	80	# endif
780431e3 MF	81	#endif
	82	};
	83
4ad1ec71 MF	84	static uint32_t const tovf_mask[MAX_BLACKFIN_GPTIMERS] =
	85	{
	86	TIMER_STATUS_TOVF0,
	87	TIMER_STATUS_TOVF1,
	88	TIMER_STATUS_TOVF2,
	89	#if (MAX_BLACKFIN_GPTIMERS > 3)
	90	TIMER_STATUS_TOVF3,
	91	TIMER_STATUS_TOVF4,
	92	TIMER_STATUS_TOVF5,
	93	TIMER_STATUS_TOVF6,
	94	TIMER_STATUS_TOVF7,
6eceb0d4	95	# if (MAX_BLACKFIN_GPTIMERS > 8)
4ad1ec71 MF	96	TIMER_STATUS_TOVF8,
	97	TIMER_STATUS_TOVF9,
	98	TIMER_STATUS_TOVF10,
6eceb0d4	99	# if (MAX_BLACKFIN_GPTIMERS > 11)
4ad1ec71	100	TIMER_STATUS_TOVF11,
6eceb0d4 MF	101	# endif
6eceb0d4 MF	102	# endif
4ad1ec71 MF	103	#endif
	104	};
	105
	106	static uint32_t const timil_mask[MAX_BLACKFIN_GPTIMERS] =
780431e3 MF	107	{
	108	TIMER_STATUS_TIMIL0,
	109	TIMER_STATUS_TIMIL1,
	110	TIMER_STATUS_TIMIL2,
	111	#if (MAX_BLACKFIN_GPTIMERS > 3)
	112	TIMER_STATUS_TIMIL3,
	113	TIMER_STATUS_TIMIL4,
	114	TIMER_STATUS_TIMIL5,
	115	TIMER_STATUS_TIMIL6,
	116	TIMER_STATUS_TIMIL7,
6eceb0d4	117	# if (MAX_BLACKFIN_GPTIMERS > 8)
780431e3 MF	118	TIMER_STATUS_TIMIL8,
	119	TIMER_STATUS_TIMIL9,
	120	TIMER_STATUS_TIMIL10,
6eceb0d4	121	# if (MAX_BLACKFIN_GPTIMERS > 11)
780431e3	122	TIMER_STATUS_TIMIL11,
6eceb0d4 MF	123	# endif
6eceb0d4 MF	124	# endif
780431e3 MF	125	#endif
	126	};
	127
8c0b4351	128	void set_gptimer_pwidth(unsigned int timer_id, uint32_t value)
780431e3 MF	129	{
780431e3 MF	130	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	131	bfin_write(&timer_regs[timer_id]->width, value);
780431e3 MF	132	SSYNC();
	133	}
	134	EXPORT_SYMBOL(set_gptimer_pwidth);
	135
8c0b4351	136	uint32_t get_gptimer_pwidth(unsigned int timer_id)
780431e3 MF	137	{
780431e3 MF	138	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	139	return bfin_read(&timer_regs[timer_id]->width);
780431e3 MF	140	}
	141	EXPORT_SYMBOL(get_gptimer_pwidth);
	142
8c0b4351	143	void set_gptimer_period(unsigned int timer_id, uint32_t period)
780431e3 MF	144	{
780431e3 MF	145	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	146	bfin_write(&timer_regs[timer_id]->period, period);
780431e3 MF	147	SSYNC();
	148	}
	149	EXPORT_SYMBOL(set_gptimer_period);
	150
8c0b4351	151	uint32_t get_gptimer_period(unsigned int timer_id)
780431e3 MF	152	{
780431e3 MF	153	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	154	return bfin_read(&timer_regs[timer_id]->period);
780431e3 MF	155	}
	156	EXPORT_SYMBOL(get_gptimer_period);
	157
8c0b4351	158	uint32_t get_gptimer_count(unsigned int timer_id)
780431e3 MF	159	{
780431e3 MF	160	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	161	return bfin_read(&timer_regs[timer_id]->counter);
780431e3 MF	162	}
	163	EXPORT_SYMBOL(get_gptimer_count);
	164
2879bb30 SM	165	#ifdef CONFIG_BF60x
	166	void set_gptimer_delay(unsigned int timer_id, uint32_t delay)
	167	{
	168	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	169	bfin_write(&timer_regs[timer_id]->delay, delay);
	170	SSYNC();
	171	}
	172	EXPORT_SYMBOL(set_gptimer_delay);
	173
	174	uint32_t get_gptimer_delay(unsigned int timer_id)
	175	{
	176	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	177	return bfin_read(&timer_regs[timer_id]->delay);
	178	}
	179	EXPORT_SYMBOL(get_gptimer_delay);
	180	#endif
	181
	182	#ifdef CONFIG_BF60x
	183	int get_gptimer_intr(unsigned int timer_id)
	184	{
	185	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	186	return !!(bfin_read(&group_regs[BFIN_TIMER_OCTET(timer_id)]->data_ilat) & timil_mask[timer_id]);
	187	}
	188	EXPORT_SYMBOL(get_gptimer_intr);
	189
	190	void clear_gptimer_intr(unsigned int timer_id)
	191	{
	192	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	193	bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->data_ilat, timil_mask[timer_id]);
	194	}
	195	EXPORT_SYMBOL(clear_gptimer_intr);
	196
	197	int get_gptimer_over(unsigned int timer_id)
	198	{
	199	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	200	return !!(bfin_read(&group_regs[BFIN_TIMER_OCTET(timer_id)]->stat_ilat) & tovf_mask[timer_id]);
	201	}
	202	EXPORT_SYMBOL(get_gptimer_over);
	203
	204	void clear_gptimer_over(unsigned int timer_id)
	205	{
	206	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	207	bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->stat_ilat, tovf_mask[timer_id]);
	208	}
	209	EXPORT_SYMBOL(clear_gptimer_over);
	210
	211	int get_gptimer_run(unsigned int timer_id)
	212	{
	213	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
	214	return !!(bfin_read(&group_regs[BFIN_TIMER_OCTET(timer_id)]->run) & trun_mask[timer_id]);
	215	}
	216	EXPORT_SYMBOL(get_gptimer_run);
	217
	218	uint32_t get_gptimer_status(unsigned int group)
	219	{
	220	tassert(group < BFIN_TIMER_NUM_GROUP);
	221	return bfin_read(&group_regs[group]->data_ilat);
	222	}
	223	EXPORT_SYMBOL(get_gptimer_status);
	224
	225	void set_gptimer_status(unsigned int group, uint32_t value)
	226	{
	227	tassert(group < BFIN_TIMER_NUM_GROUP);
	228	bfin_write(&group_regs[group]->data_ilat, value);
229	SSYNC();
230	}
231	EXPORT_SYMBOL(set_gptimer_status);
232	#else
8c0b4351	233	uint32_t get_gptimer_status(unsigned int group)
780431e3 MF	234	{
780431e3 MF	235	tassert(group < BFIN_TIMER_NUM_GROUP);
997f95e1	236	return bfin_read(&group_regs[group]->status);
780431e3 MF	237	}
	238	EXPORT_SYMBOL(get_gptimer_status);
	239
8c0b4351	240	void set_gptimer_status(unsigned int group, uint32_t value)
780431e3 MF	241	{
780431e3 MF	242	tassert(group < BFIN_TIMER_NUM_GROUP);
997f95e1	243	bfin_write(&group_regs[group]->status, value);
780431e3 MF	244	SSYNC();
	245	}
	246	EXPORT_SYMBOL(set_gptimer_status);
	247
997f95e1 MF	248	static uint32_t read_gptimer_status(unsigned int timer_id)
	249	{
	250	return bfin_read(&group_regs[BFIN_TIMER_OCTET(timer_id)]->status);
	251	}
	252
8c0b4351	253	int get_gptimer_intr(unsigned int timer_id)
780431e3 MF	254	{
780431e3 MF	255	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	256	return !!(read_gptimer_status(timer_id) & timil_mask[timer_id]);
780431e3 MF	257	}
	258	EXPORT_SYMBOL(get_gptimer_intr);
	259
8c0b4351	260	void clear_gptimer_intr(unsigned int timer_id)
780431e3 MF	261	{
780431e3 MF	262	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	263	bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->status, timil_mask[timer_id]);
780431e3 MF	264	}
	265	EXPORT_SYMBOL(clear_gptimer_intr);
	266
8c0b4351	267	int get_gptimer_over(unsigned int timer_id)
4ad1ec71 MF	268	{
4ad1ec71 MF	269	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	270	return !!(read_gptimer_status(timer_id) & tovf_mask[timer_id]);
4ad1ec71 MF	271	}
	272	EXPORT_SYMBOL(get_gptimer_over);
	273
8c0b4351	274	void clear_gptimer_over(unsigned int timer_id)
4ad1ec71 MF	275	{
4ad1ec71 MF	276	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	277	bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->status, tovf_mask[timer_id]);
4ad1ec71 MF	278	}
	279	EXPORT_SYMBOL(clear_gptimer_over);
	280
8c0b4351	281	int get_gptimer_run(unsigned int timer_id)
c8d5ea8c MH	282	{
c8d5ea8c MH	283	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	284	return !!(read_gptimer_status(timer_id) & trun_mask[timer_id]);
c8d5ea8c MH	285	}
c8d5ea8c MH	286	EXPORT_SYMBOL(get_gptimer_run);
2879bb30	287	#endif
c8d5ea8c	288
8c0b4351	289	void set_gptimer_config(unsigned int timer_id, uint16_t config)
780431e3 MF	290	{
780431e3 MF	291	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	292	bfin_write(&timer_regs[timer_id]->config, config);
780431e3 MF	293	SSYNC();
	294	}
	295	EXPORT_SYMBOL(set_gptimer_config);
	296
8c0b4351	297	uint16_t get_gptimer_config(unsigned int timer_id)
780431e3 MF	298	{
780431e3 MF	299	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	300	return bfin_read(&timer_regs[timer_id]->config);
780431e3 MF	301	}
	302	EXPORT_SYMBOL(get_gptimer_config);
	303
	304	void enable_gptimers(uint16_t mask)
	305	{
	306	int i;
2879bb30 SM	307	#ifdef CONFIG_BF60x
	308	uint16_t imask;
	309	imask = bfin_read16(TIMER_DATA_IMSK);
	310	imask &= ~mask;
	311	bfin_write16(TIMER_DATA_IMSK, imask);
	312	#endif
780431e3 MF	313	tassert((mask & ~BLACKFIN_GPTIMER_IDMASK) == 0);
780431e3 MF	314	for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i) {
997f95e1	315	bfin_write(&group_regs[i]->enable, mask & 0xFF);
780431e3 MF	316	mask >>= 8;
	317	}
	318	SSYNC();
	319	}
	320	EXPORT_SYMBOL(enable_gptimers);
	321
c8d5ea8c	322	static void _disable_gptimers(uint16_t mask)
780431e3 MF	323	{
	324	int i;
	325	uint16_t m = mask;
	326	tassert((mask & ~BLACKFIN_GPTIMER_IDMASK) == 0);
	327	for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i) {
997f95e1	328	bfin_write(&group_regs[i]->disable, m & 0xFF);
780431e3 MF	329	m >>= 8;
780431e3 MF	330	}
c8d5ea8c MH	331	}
	332
	333	void disable_gptimers(uint16_t mask)
	334	{
3a3cf0d7	335	#ifndef CONFIG_BF60x
c8d5ea8c MH	336	int i;
c8d5ea8c MH	337	_disable_gptimers(mask);
780431e3 MF	338	for (i = 0; i < MAX_BLACKFIN_GPTIMERS; ++i)
780431e3 MF	339	if (mask & (1 << i))
997f95e1	340	bfin_write(&group_regs[BFIN_TIMER_OCTET(i)]->status, trun_mask[i]);
780431e3	341	SSYNC();
3a3cf0d7 BL	342	#else
3a3cf0d7 BL	343	_disable_gptimers(mask);
2879bb30	344	#endif
780431e3 MF	345	}
	346	EXPORT_SYMBOL(disable_gptimers);
	347
c8d5ea8c MH	348	void disable_gptimers_sync(uint16_t mask)
	349	{
	350	_disable_gptimers(mask);
	351	SSYNC();
	352	}
	353	EXPORT_SYMBOL(disable_gptimers_sync);
	354
8c0b4351	355	void set_gptimer_pulse_hi(unsigned int timer_id)
780431e3 MF	356	{
780431e3 MF	357	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	358	bfin_write_or(&timer_regs[timer_id]->config, TIMER_PULSE_HI);
780431e3 MF	359	SSYNC();
	360	}
	361	EXPORT_SYMBOL(set_gptimer_pulse_hi);
	362
8c0b4351	363	void clear_gptimer_pulse_hi(unsigned int timer_id)
780431e3 MF	364	{
780431e3 MF	365	tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
997f95e1	366	bfin_write_and(&timer_regs[timer_id]->config, ~TIMER_PULSE_HI);
780431e3 MF	367	SSYNC();
	368	}
	369	EXPORT_SYMBOL(clear_gptimer_pulse_hi);
	370
	371	uint16_t get_enabled_gptimers(void)
	372	{
	373	int i;
	374	uint16_t result = 0;
	375	for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i)
997f95e1	376	result \|= (bfin_read(&group_regs[i]->enable) << (i << 3));
780431e3 MF	377	return result;
	378	}
	379	EXPORT_SYMBOL(get_enabled_gptimers);
	380
	381	MODULE_AUTHOR("Axel Weiss (awe@aglaia-gmbh.de)");
	382	MODULE_DESCRIPTION("Blackfin General Purpose Timers API");
	383	MODULE_LICENSE("GPL");