[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / ax25 / ax25_timer.c

/*
 * 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.
 *
 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
 * Copyright (C) Tomi Manninen OH2BNS (oh2bns@sral.fi)
 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
 * Copyright (C) 2002 Ralf Baechle DO1GRB (ralf@gnu.org)
 */
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/jiffies.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <net/ax25.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <asm/uaccess.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/interrupt.h>

static void ax25_heartbeat_expiry(unsigned long);
static void ax25_t1timer_expiry(unsigned long);
static void ax25_t2timer_expiry(unsigned long);
static void ax25_t3timer_expiry(unsigned long);
static void ax25_idletimer_expiry(unsigned long);

void ax25_setup_timers(ax25_cb *ax25)
{
	setup_timer(&ax25->timer, ax25_heartbeat_expiry, (unsigned long)ax25);
	setup_timer(&ax25->t1timer, ax25_t1timer_expiry, (unsigned long)ax25);
	setup_timer(&ax25->t2timer, ax25_t2timer_expiry, (unsigned long)ax25);
	setup_timer(&ax25->t3timer, ax25_t3timer_expiry, (unsigned long)ax25);
	setup_timer(&ax25->idletimer, ax25_idletimer_expiry,
		    (unsigned long)ax25);
}

void ax25_start_heartbeat(ax25_cb *ax25)
{
	mod_timer(&ax25->timer, jiffies + 5 * HZ);
}

void ax25_start_t1timer(ax25_cb *ax25)
{
	mod_timer(&ax25->t1timer, jiffies + ax25->t1);
}

void ax25_start_t2timer(ax25_cb *ax25)
{
	mod_timer(&ax25->t2timer, jiffies + ax25->t2);
}

void ax25_start_t3timer(ax25_cb *ax25)
{
	if (ax25->t3 > 0)
		mod_timer(&ax25->t3timer, jiffies + ax25->t3);
	else
		del_timer(&ax25->t3timer);
}

void ax25_start_idletimer(ax25_cb *ax25)
{
	if (ax25->idle > 0)
		mod_timer(&ax25->idletimer, jiffies + ax25->idle);
	else
		del_timer(&ax25->idletimer);
}

void ax25_stop_heartbeat(ax25_cb *ax25)
{
	del_timer(&ax25->timer);
}

void ax25_stop_t1timer(ax25_cb *ax25)
{
	del_timer(&ax25->t1timer);
}

void ax25_stop_t2timer(ax25_cb *ax25)
{
	del_timer(&ax25->t2timer);
}

void ax25_stop_t3timer(ax25_cb *ax25)
{
	del_timer(&ax25->t3timer);
}

void ax25_stop_idletimer(ax25_cb *ax25)
{
	del_timer(&ax25->idletimer);
}

int ax25_t1timer_running(ax25_cb *ax25)
{
	return timer_pending(&ax25->t1timer);
}

unsigned long ax25_display_timer(struct timer_list *timer)
{
	if (!timer_pending(timer))
		return 0;

	return timer->expires - jiffies;
}

EXPORT_SYMBOL(ax25_display_timer);

static void ax25_heartbeat_expiry(unsigned long param)
{
	int proto = AX25_PROTO_STD_SIMPLEX;
	ax25_cb *ax25 = (ax25_cb *)param;

	if (ax25->ax25_dev)
		proto = ax25->ax25_dev->values[AX25_VALUES_PROTOCOL];

	switch (proto) {
	case AX25_PROTO_STD_SIMPLEX:
	case AX25_PROTO_STD_DUPLEX:
		ax25_std_heartbeat_expiry(ax25);
		break;

#ifdef CONFIG_AX25_DAMA_SLAVE
	case AX25_PROTO_DAMA_SLAVE:
		if (ax25->ax25_dev->dama.slave)
			ax25_ds_heartbeat_expiry(ax25);
		else
			ax25_std_heartbeat_expiry(ax25);
		break;
#endif
	}
}

static void ax25_t1timer_expiry(unsigned long param)
{
	ax25_cb *ax25 = (ax25_cb *)param;

	switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
	case AX25_PROTO_STD_SIMPLEX:
	case AX25_PROTO_STD_DUPLEX:
		ax25_std_t1timer_expiry(ax25);
		break;

#ifdef CONFIG_AX25_DAMA_SLAVE
	case AX25_PROTO_DAMA_SLAVE:
		if (!ax25->ax25_dev->dama.slave)
			ax25_std_t1timer_expiry(ax25);
		break;
#endif
	}
}

static void ax25_t2timer_expiry(unsigned long param)
{
	ax25_cb *ax25 = (ax25_cb *)param;

	switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
	case AX25_PROTO_STD_SIMPLEX:
	case AX25_PROTO_STD_DUPLEX:
		ax25_std_t2timer_expiry(ax25);
		break;

#ifdef CONFIG_AX25_DAMA_SLAVE
	case AX25_PROTO_DAMA_SLAVE:
		if (!ax25->ax25_dev->dama.slave)
			ax25_std_t2timer_expiry(ax25);
		break;
#endif
	}
}

static void ax25_t3timer_expiry(unsigned long param)
{
	ax25_cb *ax25 = (ax25_cb *)param;

	switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
	case AX25_PROTO_STD_SIMPLEX:
	case AX25_PROTO_STD_DUPLEX:
		ax25_std_t3timer_expiry(ax25);
		break;

#ifdef CONFIG_AX25_DAMA_SLAVE
	case AX25_PROTO_DAMA_SLAVE:
		if (ax25->ax25_dev->dama.slave)
			ax25_ds_t3timer_expiry(ax25);
		else
			ax25_std_t3timer_expiry(ax25);
		break;
#endif
	}
}

static void ax25_idletimer_expiry(unsigned long param)
{
	ax25_cb *ax25 = (ax25_cb *)param;

	switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
	case AX25_PROTO_STD_SIMPLEX:
	case AX25_PROTO_STD_DUPLEX:
		ax25_std_idletimer_expiry(ax25);
		break;

#ifdef CONFIG_AX25_DAMA_SLAVE
	case AX25_PROTO_DAMA_SLAVE:
		if (ax25->ax25_dev->dama.slave)
			ax25_ds_idletimer_expiry(ax25);
		else
			ax25_std_idletimer_expiry(ax25);
		break;
#endif
	}
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This program is free software; you can redistribute it and/or modify
	3	* it under the terms of the GNU General Public License as published by
	4	* the Free Software Foundation; either version 2 of the License, or
	5	* (at your option) any later version.
	6	*
	7	* Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
	8	* Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
	9	* Copyright (C) Tomi Manninen OH2BNS (oh2bns@sral.fi)
	10	* Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
	11	* Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
	12	* Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
	13	* Copyright (C) 2002 Ralf Baechle DO1GRB (ralf@gnu.org)
	14	*/
1da177e4 LT	15	#include <linux/errno.h>
	16	#include <linux/types.h>
	17	#include <linux/socket.h>
	18	#include <linux/in.h>
	19	#include <linux/kernel.h>
70868eac	20	#include <linux/module.h>
1da177e4 LT	21	#include <linux/jiffies.h>
	22	#include <linux/timer.h>
	23	#include <linux/string.h>
	24	#include <linux/sockios.h>
	25	#include <linux/net.h>
	26	#include <net/ax25.h>
	27	#include <linux/inet.h>
	28	#include <linux/netdevice.h>
	29	#include <linux/skbuff.h>
	30	#include <net/sock.h>
	31	#include <asm/uaccess.h>
1da177e4 LT	32	#include <linux/fcntl.h>
	33	#include <linux/mm.h>
	34	#include <linux/interrupt.h>
	35
	36	static void ax25_heartbeat_expiry(unsigned long);
	37	static void ax25_t1timer_expiry(unsigned long);
	38	static void ax25_t2timer_expiry(unsigned long);
	39	static void ax25_t3timer_expiry(unsigned long);
	40	static void ax25_idletimer_expiry(unsigned long);
	41
21fab4a8	42	void ax25_setup_timers(ax25_cb *ax25)
1da177e4	43	{
21fab4a8 JP	44	setup_timer(&ax25->timer, ax25_heartbeat_expiry, (unsigned long)ax25);
	45	setup_timer(&ax25->t1timer, ax25_t1timer_expiry, (unsigned long)ax25);
	46	setup_timer(&ax25->t2timer, ax25_t2timer_expiry, (unsigned long)ax25);
	47	setup_timer(&ax25->t3timer, ax25_t3timer_expiry, (unsigned long)ax25);
	48	setup_timer(&ax25->idletimer, ax25_idletimer_expiry,
	49	(unsigned long)ax25);
	50	}
1da177e4	51
21fab4a8 JP	52	void ax25_start_heartbeat(ax25_cb *ax25)
	53	{
	54	mod_timer(&ax25->timer, jiffies + 5 * HZ);
1da177e4 LT	55	}
	56
	57	void ax25_start_t1timer(ax25_cb *ax25)
	58	{
21fab4a8	59	mod_timer(&ax25->t1timer, jiffies + ax25->t1);
1da177e4 LT	60	}
	61
	62	void ax25_start_t2timer(ax25_cb *ax25)
	63	{
21fab4a8	64	mod_timer(&ax25->t2timer, jiffies + ax25->t2);
1da177e4 LT	65	}
	66
	67	void ax25_start_t3timer(ax25_cb *ax25)
	68	{
21fab4a8 JP	69	if (ax25->t3 > 0)
	70	mod_timer(&ax25->t3timer, jiffies + ax25->t3);
	71	else
	72	del_timer(&ax25->t3timer);
1da177e4 LT	73	}
	74
	75	void ax25_start_idletimer(ax25_cb *ax25)
	76	{
21fab4a8 JP	77	if (ax25->idle > 0)
	78	mod_timer(&ax25->idletimer, jiffies + ax25->idle);
	79	else
	80	del_timer(&ax25->idletimer);
1da177e4 LT	81	}
	82
	83	void ax25_stop_heartbeat(ax25_cb *ax25)
	84	{
	85	del_timer(&ax25->timer);
	86	}
	87
	88	void ax25_stop_t1timer(ax25_cb *ax25)
	89	{
	90	del_timer(&ax25->t1timer);
	91	}
	92
	93	void ax25_stop_t2timer(ax25_cb *ax25)
	94	{
	95	del_timer(&ax25->t2timer);
	96	}
	97
	98	void ax25_stop_t3timer(ax25_cb *ax25)
	99	{
	100	del_timer(&ax25->t3timer);
	101	}
	102
	103	void ax25_stop_idletimer(ax25_cb *ax25)
	104	{
	105	del_timer(&ax25->idletimer);
	106	}
	107
	108	int ax25_t1timer_running(ax25_cb *ax25)
	109	{
	110	return timer_pending(&ax25->t1timer);
	111	}
	112
	113	unsigned long ax25_display_timer(struct timer_list *timer)
	114	{
	115	if (!timer_pending(timer))
	116	return 0;
	117
	118	return timer->expires - jiffies;
	119	}
	120
70868eac RB	121	EXPORT_SYMBOL(ax25_display_timer);
70868eac RB	122
1da177e4 LT	123	static void ax25_heartbeat_expiry(unsigned long param)
	124	{
	125	int proto = AX25_PROTO_STD_SIMPLEX;
	126	ax25_cb ax25 = (ax25_cb )param;
	127
	128	if (ax25->ax25_dev)
	129	proto = ax25->ax25_dev->values[AX25_VALUES_PROTOCOL];
	130
	131	switch (proto) {
	132	case AX25_PROTO_STD_SIMPLEX:
	133	case AX25_PROTO_STD_DUPLEX:
	134	ax25_std_heartbeat_expiry(ax25);
	135	break;
	136
	137	#ifdef CONFIG_AX25_DAMA_SLAVE
	138	case AX25_PROTO_DAMA_SLAVE:
	139	if (ax25->ax25_dev->dama.slave)
	140	ax25_ds_heartbeat_expiry(ax25);
	141	else
	142	ax25_std_heartbeat_expiry(ax25);
	143	break;
	144	#endif
	145	}
	146	}
	147
	148	static void ax25_t1timer_expiry(unsigned long param)
	149	{
	150	ax25_cb ax25 = (ax25_cb )param;
	151
	152	switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
	153	case AX25_PROTO_STD_SIMPLEX:
	154	case AX25_PROTO_STD_DUPLEX:
	155	ax25_std_t1timer_expiry(ax25);
	156	break;
	157
	158	#ifdef CONFIG_AX25_DAMA_SLAVE
	159	case AX25_PROTO_DAMA_SLAVE:
	160	if (!ax25->ax25_dev->dama.slave)
	161	ax25_std_t1timer_expiry(ax25);
	162	break;
	163	#endif
	164	}
	165	}
	166
	167	static void ax25_t2timer_expiry(unsigned long param)
	168	{
	169	ax25_cb ax25 = (ax25_cb )param;
	170
	171	switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
	172	case AX25_PROTO_STD_SIMPLEX:
	173	case AX25_PROTO_STD_DUPLEX:
	174	ax25_std_t2timer_expiry(ax25);
	175	break;
	176
	177	#ifdef CONFIG_AX25_DAMA_SLAVE
	178	case AX25_PROTO_DAMA_SLAVE:
	179	if (!ax25->ax25_dev->dama.slave)
	180	ax25_std_t2timer_expiry(ax25);
	181	break;
	182	#endif
	183	}
	184	}
	185
	186	static void ax25_t3timer_expiry(unsigned long param)
187	{
188	ax25_cb ax25 = (ax25_cb )param;
189
190	switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
191	case AX25_PROTO_STD_SIMPLEX:
192	case AX25_PROTO_STD_DUPLEX:
193	ax25_std_t3timer_expiry(ax25);
194	break;
195
196	#ifdef CONFIG_AX25_DAMA_SLAVE
197	case AX25_PROTO_DAMA_SLAVE:
198	if (ax25->ax25_dev->dama.slave)
199	ax25_ds_t3timer_expiry(ax25);
200	else
201	ax25_std_t3timer_expiry(ax25);
202	break;
203	#endif
204	}
205	}
206
207	static void ax25_idletimer_expiry(unsigned long param)
208	{
209	ax25_cb ax25 = (ax25_cb )param;
210
211	switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
212	case AX25_PROTO_STD_SIMPLEX:
213	case AX25_PROTO_STD_DUPLEX:
214	ax25_std_idletimer_expiry(ax25);
215	break;
216
217	#ifdef CONFIG_AX25_DAMA_SLAVE
218	case AX25_PROTO_DAMA_SLAVE:
219	if (ax25->ax25_dev->dama.slave)
220	ax25_ds_idletimer_expiry(ax25);
221	else
222	ax25_std_idletimer_expiry(ax25);
223	break;
224	#endif
225	}
226	}