[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / skfp / smttimer.c

/******************************************************************************
 *
 *	(C)Copyright 1998,1999 SysKonnect,
 *	a business unit of Schneider & Koch & Co. Datensysteme GmbH.
 *
 *	See the file "skfddi.c" for further information.
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2 of the License, or
 *	(at your option) any later version.
 *
 *	The information in this file is provided "AS IS" without warranty.
 *
 ******************************************************************************/

/*
	SMT timer
*/

#include "h/types.h"
#include "h/fddi.h"
#include "h/smc.h"

#ifndef	lint
static const char ID_sccs[] = "@(#)smttimer.c	2.4 97/08/04 (C) SK " ;
#endif

static void timer_done(struct s_smc *smc, int restart);

void smt_timer_init(struct s_smc *smc)
{
	smc->t.st_queue = NULL;
	smc->t.st_fast.tm_active = FALSE ;
	smc->t.st_fast.tm_next = NULL;
	hwt_init(smc) ;
}

void smt_timer_stop(struct s_smc *smc, struct smt_timer *timer)
{
	struct smt_timer	**prev ;
	struct smt_timer	*tm ;

	/*
	 * remove timer from queue
	 */
	timer->tm_active = FALSE ;
	if (smc->t.st_queue == timer && !timer->tm_next) {
		hwt_stop(smc) ;
	}
	for (prev = &smc->t.st_queue ; (tm = *prev) ; prev = &tm->tm_next ) {
		if (tm == timer) {
			*prev = tm->tm_next ;
			if (tm->tm_next) {
				tm->tm_next->tm_delta += tm->tm_delta ;
			}
			return ;
		}
	}
}

void smt_timer_start(struct s_smc *smc, struct smt_timer *timer, u_long time,
		     u_long token)
{
	struct smt_timer	**prev ;
	struct smt_timer	*tm ;
	u_long			delta = 0 ;

	time /= 16 ;		/* input is uS, clock ticks are 16uS */
	if (!time)
		time = 1 ;
	smt_timer_stop(smc,timer) ;
	timer->tm_smc = smc ;
	timer->tm_token = token ;
	timer->tm_active = TRUE ;
	if (!smc->t.st_queue) {
		smc->t.st_queue = timer ;
		timer->tm_next = NULL;
		timer->tm_delta = time ;
		hwt_start(smc,time) ;
		return ;
	}
	/*
	 * timer correction
	 */
	timer_done(smc,0) ;

	/*
	 * find position in queue
	 */
	delta = 0 ;
	for (prev = &smc->t.st_queue ; (tm = *prev) ; prev = &tm->tm_next ) {
		if (delta + tm->tm_delta > time) {
			break ;
		}
		delta += tm->tm_delta ;
	}
	/* insert in queue */
	*prev = timer ;
	timer->tm_next = tm ;
	timer->tm_delta = time - delta ;
	if (tm)
		tm->tm_delta -= timer->tm_delta ;
	/*
	 * start new with first
	 */
	hwt_start(smc,smc->t.st_queue->tm_delta) ;
}

void smt_force_irq(struct s_smc *smc)
{
	smt_timer_start(smc,&smc->t.st_fast,32L, EV_TOKEN(EVENT_SMT,SM_FAST)); 
}

void smt_timer_done(struct s_smc *smc)
{
	timer_done(smc,1) ;
}

static void timer_done(struct s_smc *smc, int restart)
{
	u_long			delta ;
	struct smt_timer	*tm ;
	struct smt_timer	*next ;
	struct smt_timer	**last ;
	int			done = 0 ;

	delta = hwt_read(smc) ;
	last = &smc->t.st_queue ;
	tm = smc->t.st_queue ;
	while (tm && !done) {
		if (delta >= tm->tm_delta) {
			tm->tm_active = FALSE ;
			delta -= tm->tm_delta ;
			last = &tm->tm_next ;
			tm = tm->tm_next ;
		}
		else {
			tm->tm_delta -= delta ;
			delta = 0 ;
			done = 1 ;
		}
	}
	*last = NULL;
	next = smc->t.st_queue ;
	smc->t.st_queue = tm ;

	for ( tm = next ; tm ; tm = next) {
		next = tm->tm_next ;
		timer_event(smc,tm->tm_token) ;
	}

	if (restart && smc->t.st_queue)
		hwt_start(smc,smc->t.st_queue->tm_delta) ;
}
Commit	Line	Data
1da177e4 LT	1	/******************************************************************************
	2	*
	3	* (C)Copyright 1998,1999 SysKonnect,
	4	* a business unit of Schneider & Koch & Co. Datensysteme GmbH.
	5	*
	6	* See the file "skfddi.c" for further information.
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* The information in this file is provided "AS IS" without warranty.
	14	*
	15	******************************************************************************/
	16
	17	/*
	18	SMT timer
	19	*/
	20
	21	#include "h/types.h"
	22	#include "h/fddi.h"
	23	#include "h/smc.h"
	24
	25	#ifndef lint
	26	static const char ID_sccs[] = "@(#)smttimer.c 2.4 97/08/04 (C) SK " ;
	27	#endif
	28
	29	static void timer_done(struct s_smc *smc, int restart);
	30
	31	void smt_timer_init(struct s_smc *smc)
	32	{
	33	smc->t.st_queue = NULL;
	34	smc->t.st_fast.tm_active = FALSE ;
	35	smc->t.st_fast.tm_next = NULL;
	36	hwt_init(smc) ;
	37	}
	38
	39	void smt_timer_stop(struct s_smc smc, struct smt_timer timer)
	40	{
	41	struct smt_timer **prev ;
	42	struct smt_timer *tm ;
	43
	44	/*
	45	* remove timer from queue
	46	*/
	47	timer->tm_active = FALSE ;
	48	if (smc->t.st_queue == timer && !timer->tm_next) {
	49	hwt_stop(smc) ;
	50	}
	51	for (prev = &smc->t.st_queue ; (tm = *prev) ; prev = &tm->tm_next ) {
	52	if (tm == timer) {
	53	*prev = tm->tm_next ;
	54	if (tm->tm_next) {
	55	tm->tm_next->tm_delta += tm->tm_delta ;
	56	}
	57	return ;
	58	}
	59	}
	60	}
	61
	62	void smt_timer_start(struct s_smc smc, struct smt_timer timer, u_long time,
	63	u_long token)
	64	{
65	struct smt_timer **prev ;
66	struct smt_timer *tm ;
67	u_long delta = 0 ;
68
69	time /= 16 ; /* input is uS, clock ticks are 16uS */
70	if (!time)
71	time = 1 ;
72	smt_timer_stop(smc,timer) ;
73	timer->tm_smc = smc ;
74	timer->tm_token = token ;
75	timer->tm_active = TRUE ;
76	if (!smc->t.st_queue) {
77	smc->t.st_queue = timer ;
78	timer->tm_next = NULL;
79	timer->tm_delta = time ;
80	hwt_start(smc,time) ;
81	return ;
82	}
83	/*
84	* timer correction
85	*/
86	timer_done(smc,0) ;
87
88	/*
89	* find position in queue
90	*/
91	delta = 0 ;
92	for (prev = &smc->t.st_queue ; (tm = *prev) ; prev = &tm->tm_next ) {
93	if (delta + tm->tm_delta > time) {
94	break ;
95	}
96	delta += tm->tm_delta ;
97	}
98	/* insert in queue */
99	*prev = timer ;
100	timer->tm_next = tm ;
101	timer->tm_delta = time - delta ;
102	if (tm)
103	tm->tm_delta -= timer->tm_delta ;
104	/*
105	* start new with first
106	*/
107	hwt_start(smc,smc->t.st_queue->tm_delta) ;
108	}
109
110	void smt_force_irq(struct s_smc *smc)
111	{
112	smt_timer_start(smc,&smc->t.st_fast,32L, EV_TOKEN(EVENT_SMT,SM_FAST));
113	}
114
115	void smt_timer_done(struct s_smc *smc)
116	{
117	timer_done(smc,1) ;
118	}
119
120	static void timer_done(struct s_smc *smc, int restart)
121	{
122	u_long delta ;
123	struct smt_timer *tm ;
124	struct smt_timer *next ;
125	struct smt_timer **last ;
126	int done = 0 ;
127
128	delta = hwt_read(smc) ;
129	last = &smc->t.st_queue ;
130	tm = smc->t.st_queue ;
131	while (tm && !done) {
132	if (delta >= tm->tm_delta) {
133	tm->tm_active = FALSE ;
134	delta -= tm->tm_delta ;
135	last = &tm->tm_next ;
136	tm = tm->tm_next ;
137	}
138	else {
139	tm->tm_delta -= delta ;
140	delta = 0 ;
141	done = 1 ;
142	}
143	}
144	*last = NULL;
145	next = smc->t.st_queue ;
146	smc->t.st_queue = tm ;
147
148	for ( tm = next ; tm ; tm = next) {
149	next = tm->tm_next ;
150	timer_event(smc,tm->tm_token) ;
151	}
152
153	if (restart && smc->t.st_queue)
154	hwt_start(smc,smc->t.st_queue->tm_delta) ;
155	}
156