[linux-2.6-block.git] / net / lapb / lapb_timer.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *	LAPB release 002
 *
 *	This code REQUIRES 2.1.15 or higher/ NET3.038
 *
 *	History
 *	LAPB 001	Jonathan Naylor	Started Coding
 *	LAPB 002	Jonathan Naylor	New timer architecture.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/kernel.h>
#include <linux/jiffies.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/inet.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <linux/uaccess.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <net/lapb.h>

static void lapb_t1timer_expiry(struct timer_list *);
static void lapb_t2timer_expiry(struct timer_list *);

void lapb_start_t1timer(struct lapb_cb *lapb)
{
	del_timer(&lapb->t1timer);

	lapb->t1timer.function = lapb_t1timer_expiry;
	lapb->t1timer.expires  = jiffies + lapb->t1;

	lapb->t1timer_running = true;
	add_timer(&lapb->t1timer);
}

void lapb_start_t2timer(struct lapb_cb *lapb)
{
	del_timer(&lapb->t2timer);

	lapb->t2timer.function = lapb_t2timer_expiry;
	lapb->t2timer.expires  = jiffies + lapb->t2;

	lapb->t2timer_running = true;
	add_timer(&lapb->t2timer);
}

void lapb_stop_t1timer(struct lapb_cb *lapb)
{
	lapb->t1timer_running = false;
	del_timer(&lapb->t1timer);
}

void lapb_stop_t2timer(struct lapb_cb *lapb)
{
	lapb->t2timer_running = false;
	del_timer(&lapb->t2timer);
}

int lapb_t1timer_running(struct lapb_cb *lapb)
{
	return lapb->t1timer_running;
}

static void lapb_t2timer_expiry(struct timer_list *t)
{
	struct lapb_cb *lapb = from_timer(lapb, t, t2timer);

	spin_lock_bh(&lapb->lock);
	if (timer_pending(&lapb->t2timer)) /* A new timer has been set up */
		goto out;
	if (!lapb->t2timer_running) /* The timer has been stopped */
		goto out;

	if (lapb->condition & LAPB_ACK_PENDING_CONDITION) {
		lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
		lapb_timeout_response(lapb);
	}
	lapb->t2timer_running = false;

out:
	spin_unlock_bh(&lapb->lock);
}

static void lapb_t1timer_expiry(struct timer_list *t)
{
	struct lapb_cb *lapb = from_timer(lapb, t, t1timer);

	spin_lock_bh(&lapb->lock);
	if (timer_pending(&lapb->t1timer)) /* A new timer has been set up */
		goto out;
	if (!lapb->t1timer_running) /* The timer has been stopped */
		goto out;

	switch (lapb->state) {

		/*
		 *	If we are a DCE, send DM up to N2 times, then switch to
		 *	STATE_1 and send SABM(E).
		 */
		case LAPB_STATE_0:
			if (lapb->mode & LAPB_DCE &&
			    lapb->n2count != lapb->n2) {
				lapb->n2count++;
				lapb_send_control(lapb, LAPB_DM, LAPB_POLLOFF, LAPB_RESPONSE);
			} else {
				lapb->state = LAPB_STATE_1;
				lapb_establish_data_link(lapb);
			}
			break;

		/*
		 *	Awaiting connection state, send SABM(E), up to N2 times.
		 */
		case LAPB_STATE_1:
			if (lapb->n2count == lapb->n2) {
				lapb_clear_queues(lapb);
				lapb->state = LAPB_STATE_0;
				lapb_disconnect_indication(lapb, LAPB_TIMEDOUT);
				lapb_dbg(0, "(%p) S1 -> S0\n", lapb->dev);
				lapb->t1timer_running = false;
				goto out;
			} else {
				lapb->n2count++;
				if (lapb->mode & LAPB_EXTENDED) {
					lapb_dbg(1, "(%p) S1 TX SABME(1)\n",
						 lapb->dev);
					lapb_send_control(lapb, LAPB_SABME, LAPB_POLLON, LAPB_COMMAND);
				} else {
					lapb_dbg(1, "(%p) S1 TX SABM(1)\n",
						 lapb->dev);
					lapb_send_control(lapb, LAPB_SABM, LAPB_POLLON, LAPB_COMMAND);
				}
			}
			break;

		/*
		 *	Awaiting disconnection state, send DISC, up to N2 times.
		 */
		case LAPB_STATE_2:
			if (lapb->n2count == lapb->n2) {
				lapb_clear_queues(lapb);
				lapb->state = LAPB_STATE_0;
				lapb_disconnect_confirmation(lapb, LAPB_TIMEDOUT);
				lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev);
				lapb->t1timer_running = false;
				goto out;
			} else {
				lapb->n2count++;
				lapb_dbg(1, "(%p) S2 TX DISC(1)\n", lapb->dev);
				lapb_send_control(lapb, LAPB_DISC, LAPB_POLLON, LAPB_COMMAND);
			}
			break;

		/*
		 *	Data transfer state, restransmit I frames, up to N2 times.
		 */
		case LAPB_STATE_3:
			if (lapb->n2count == lapb->n2) {
				lapb_clear_queues(lapb);
				lapb->state = LAPB_STATE_0;
				lapb_stop_t2timer(lapb);
				lapb_disconnect_indication(lapb, LAPB_TIMEDOUT);
				lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev);
				lapb->t1timer_running = false;
				goto out;
			} else {
				lapb->n2count++;
				lapb_requeue_frames(lapb);
				lapb_kick(lapb);
			}
			break;

		/*
		 *	Frame reject state, restransmit FRMR frames, up to N2 times.
		 */
		case LAPB_STATE_4:
			if (lapb->n2count == lapb->n2) {
				lapb_clear_queues(lapb);
				lapb->state = LAPB_STATE_0;
				lapb_disconnect_indication(lapb, LAPB_TIMEDOUT);
				lapb_dbg(0, "(%p) S4 -> S0\n", lapb->dev);
				lapb->t1timer_running = false;
				goto out;
			} else {
				lapb->n2count++;
				lapb_transmit_frmr(lapb);
			}
			break;
	}

	lapb_start_t1timer(lapb);

out:
	spin_unlock_bh(&lapb->lock);
}
Commit	Line	Data
ee5d8f4d	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
	3	* LAPB release 002
	4	*
	5	* This code REQUIRES 2.1.15 or higher/ NET3.038
	6	*
1da177e4 LT	7	* History
	8	* LAPB 001 Jonathan Naylor Started Coding
	9	* LAPB 002 Jonathan Naylor New timer architecture.
	10	*/
	11
a508da6c JP	12	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
a508da6c JP	13
1da177e4 LT	14	#include <linux/errno.h>
	15	#include <linux/types.h>
	16	#include <linux/socket.h>
	17	#include <linux/in.h>
	18	#include <linux/kernel.h>
	19	#include <linux/jiffies.h>
	20	#include <linux/timer.h>
	21	#include <linux/string.h>
	22	#include <linux/sockios.h>
	23	#include <linux/net.h>
	24	#include <linux/inet.h>
	25	#include <linux/skbuff.h>
	26	#include <net/sock.h>
7c0f6ba6	27	#include <linux/uaccess.h>
1da177e4 LT	28	#include <linux/fcntl.h>
	29	#include <linux/mm.h>
	30	#include <linux/interrupt.h>
	31	#include <net/lapb.h>
	32
83a37b32 KC	33	static void lapb_t1timer_expiry(struct timer_list *);
83a37b32 KC	34	static void lapb_t2timer_expiry(struct timer_list *);
1da177e4 LT	35
	36	void lapb_start_t1timer(struct lapb_cb *lapb)
	37	{
	38	del_timer(&lapb->t1timer);
	39
841b86f3	40	lapb->t1timer.function = lapb_t1timer_expiry;
1da177e4 LT	41	lapb->t1timer.expires = jiffies + lapb->t1;
1da177e4 LT	42
65d2dbb3	43	lapb->t1timer_running = true;
1da177e4 LT	44	add_timer(&lapb->t1timer);
	45	}
	46
	47	void lapb_start_t2timer(struct lapb_cb *lapb)
	48	{
	49	del_timer(&lapb->t2timer);
	50
841b86f3	51	lapb->t2timer.function = lapb_t2timer_expiry;
1da177e4 LT	52	lapb->t2timer.expires = jiffies + lapb->t2;
1da177e4 LT	53
65d2dbb3	54	lapb->t2timer_running = true;
1da177e4 LT	55	add_timer(&lapb->t2timer);
	56	}
	57
	58	void lapb_stop_t1timer(struct lapb_cb *lapb)
	59	{
65d2dbb3	60	lapb->t1timer_running = false;
1da177e4 LT	61	del_timer(&lapb->t1timer);
	62	}
	63
	64	void lapb_stop_t2timer(struct lapb_cb *lapb)
	65	{
65d2dbb3	66	lapb->t2timer_running = false;
1da177e4 LT	67	del_timer(&lapb->t2timer);
	68	}
	69
	70	int lapb_t1timer_running(struct lapb_cb *lapb)
	71	{
65d2dbb3	72	return lapb->t1timer_running;
1da177e4 LT	73	}
1da177e4 LT	74
83a37b32	75	static void lapb_t2timer_expiry(struct timer_list *t)
1da177e4	76	{
83a37b32	77	struct lapb_cb *lapb = from_timer(lapb, t, t2timer);
1da177e4	78
b491e6a7 XH	79	spin_lock_bh(&lapb->lock);
	80	if (timer_pending(&lapb->t2timer)) /* A new timer has been set up */
	81	goto out;
65d2dbb3	82	if (!lapb->t2timer_running) /* The timer has been stopped */
b491e6a7 XH	83	goto out;
b491e6a7 XH	84
1da177e4 LT	85	if (lapb->condition & LAPB_ACK_PENDING_CONDITION) {
	86	lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
	87	lapb_timeout_response(lapb);
	88	}
65d2dbb3	89	lapb->t2timer_running = false;
b491e6a7 XH	90
	91	out:
	92	spin_unlock_bh(&lapb->lock);
1da177e4 LT	93	}
1da177e4 LT	94
83a37b32	95	static void lapb_t1timer_expiry(struct timer_list *t)
1da177e4	96	{
83a37b32	97	struct lapb_cb *lapb = from_timer(lapb, t, t1timer);
1da177e4	98
b491e6a7 XH	99	spin_lock_bh(&lapb->lock);
	100	if (timer_pending(&lapb->t1timer)) /* A new timer has been set up */
	101	goto out;
65d2dbb3	102	if (!lapb->t1timer_running) /* The timer has been stopped */
b491e6a7 XH	103	goto out;
b491e6a7 XH	104
1da177e4 LT	105	switch (lapb->state) {
	106
	107	/*
62480b99 MS	108	* If we are a DCE, send DM up to N2 times, then switch to
62480b99 MS	109	* STATE_1 and send SABM(E).
1da177e4 LT	110	*/
1da177e4 LT	111	case LAPB_STATE_0:
62480b99 MS	112	if (lapb->mode & LAPB_DCE &&
	113	lapb->n2count != lapb->n2) {
	114	lapb->n2count++;
1da177e4	115	lapb_send_control(lapb, LAPB_DM, LAPB_POLLOFF, LAPB_RESPONSE);
62480b99 MS	116	} else {
	117	lapb->state = LAPB_STATE_1;
	118	lapb_establish_data_link(lapb);
	119	}
1da177e4 LT	120	break;
	121
	122	/*
	123	* Awaiting connection state, send SABM(E), up to N2 times.
	124	*/
56d6c3d7	125	case LAPB_STATE_1:
1da177e4 LT	126	if (lapb->n2count == lapb->n2) {
	127	lapb_clear_queues(lapb);
	128	lapb->state = LAPB_STATE_0;
	129	lapb_disconnect_indication(lapb, LAPB_TIMEDOUT);
a508da6c	130	lapb_dbg(0, "(%p) S1 -> S0\n", lapb->dev);
65d2dbb3	131	lapb->t1timer_running = false;
b491e6a7	132	goto out;
1da177e4 LT	133	} else {
	134	lapb->n2count++;
	135	if (lapb->mode & LAPB_EXTENDED) {
a508da6c JP	136	lapb_dbg(1, "(%p) S1 TX SABME(1)\n",
a508da6c JP	137	lapb->dev);
1da177e4 LT	138	lapb_send_control(lapb, LAPB_SABME, LAPB_POLLON, LAPB_COMMAND);
1da177e4 LT	139	} else {
a508da6c JP	140	lapb_dbg(1, "(%p) S1 TX SABM(1)\n",
a508da6c JP	141	lapb->dev);
1da177e4 LT	142	lapb_send_control(lapb, LAPB_SABM, LAPB_POLLON, LAPB_COMMAND);
	143	}
	144	}
	145	break;
	146
	147	/*
	148	* Awaiting disconnection state, send DISC, up to N2 times.
	149	*/
	150	case LAPB_STATE_2:
	151	if (lapb->n2count == lapb->n2) {
	152	lapb_clear_queues(lapb);
	153	lapb->state = LAPB_STATE_0;
	154	lapb_disconnect_confirmation(lapb, LAPB_TIMEDOUT);
a508da6c	155	lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev);
65d2dbb3	156	lapb->t1timer_running = false;
b491e6a7	157	goto out;
1da177e4 LT	158	} else {
1da177e4 LT	159	lapb->n2count++;
a508da6c	160	lapb_dbg(1, "(%p) S2 TX DISC(1)\n", lapb->dev);
1da177e4 LT	161	lapb_send_control(lapb, LAPB_DISC, LAPB_POLLON, LAPB_COMMAND);
	162	}
	163	break;
	164
	165	/*
	166	* Data transfer state, restransmit I frames, up to N2 times.
	167	*/
	168	case LAPB_STATE_3:
	169	if (lapb->n2count == lapb->n2) {
	170	lapb_clear_queues(lapb);
	171	lapb->state = LAPB_STATE_0;
	172	lapb_stop_t2timer(lapb);
	173	lapb_disconnect_indication(lapb, LAPB_TIMEDOUT);
a508da6c	174	lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev);
65d2dbb3	175	lapb->t1timer_running = false;
b491e6a7	176	goto out;
1da177e4 LT	177	} else {
	178	lapb->n2count++;
	179	lapb_requeue_frames(lapb);
a224bd36	180	lapb_kick(lapb);
1da177e4 LT	181	}
	182	break;
	183
	184	/*
	185	* Frame reject state, restransmit FRMR frames, up to N2 times.
	186	*/
	187	case LAPB_STATE_4:
	188	if (lapb->n2count == lapb->n2) {
	189	lapb_clear_queues(lapb);
	190	lapb->state = LAPB_STATE_0;
	191	lapb_disconnect_indication(lapb, LAPB_TIMEDOUT);
a508da6c	192	lapb_dbg(0, "(%p) S4 -> S0\n", lapb->dev);
65d2dbb3	193	lapb->t1timer_running = false;
b491e6a7	194	goto out;
1da177e4 LT	195	} else {
	196	lapb->n2count++;
	197	lapb_transmit_frmr(lapb);
	198	}
	199	break;
	200	}
	201
	202	lapb_start_t1timer(lapb);
b491e6a7 XH	203
	204	out:
	205	spin_unlock_bh(&lapb->lock);
1da177e4	206	}