4 * This code REQUIRES 2.1.15 or higher/ NET3.038
7 * This module is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
13 * LAPB 001 Jonathan Naylor Started Coding
14 * LAPB 002 Jonathan Naylor New timer architecture.
15 * 2000-10-29 Henner Eisen lapb_data_indication() return status.
18 #include <linux/module.h>
19 #include <linux/errno.h>
20 #include <linux/types.h>
21 #include <linux/socket.h>
23 #include <linux/kernel.h>
24 #include <linux/jiffies.h>
25 #include <linux/timer.h>
26 #include <linux/string.h>
27 #include <linux/sockios.h>
28 #include <linux/net.h>
29 #include <linux/inet.h>
30 #include <linux/if_arp.h>
31 #include <linux/skbuff.h>
33 #include <asm/uaccess.h>
34 #include <asm/system.h>
35 #include <linux/fcntl.h>
37 #include <linux/interrupt.h>
38 #include <linux/stat.h>
39 #include <linux/init.h>
42 static struct list_head lapb_list = LIST_HEAD_INIT(lapb_list);
43 static rwlock_t lapb_list_lock = RW_LOCK_UNLOCKED;
46 * Free an allocated lapb control block.
48 static void lapb_free_cb(struct lapb_cb *lapb)
53 static __inline__ void lapb_hold(struct lapb_cb *lapb)
55 atomic_inc(&lapb->refcnt);
58 static __inline__ void lapb_put(struct lapb_cb *lapb)
60 if (atomic_dec_and_test(&lapb->refcnt))
65 * Socket removal during an interrupt is now safe.
67 static void __lapb_remove_cb(struct lapb_cb *lapb)
69 if (lapb->node.next) {
70 list_del(&lapb->node);
76 * Add a socket to the bound sockets list.
78 static void __lapb_insert_cb(struct lapb_cb *lapb)
80 list_add(&lapb->node, &lapb_list);
85 * Convert the integer token used by the device driver into a pointer
86 * to a LAPB control structure.
88 static struct lapb_cb *__lapb_tokentostruct(void *token)
90 struct list_head *entry;
91 struct lapb_cb *lapb, *use = NULL;
93 list_for_each(entry, &lapb_list) {
94 lapb = list_entry(entry, struct lapb_cb, node);
95 if (lapb->token == token) {
107 static struct lapb_cb *lapb_tokentostruct(void *token)
111 read_lock_bh(&lapb_list_lock);
112 rc = __lapb_tokentostruct(token);
113 read_unlock_bh(&lapb_list_lock);
118 * Create an empty LAPB control block.
120 static struct lapb_cb *lapb_create_cb(void)
122 struct lapb_cb *lapb = kmalloc(sizeof(*lapb), GFP_ATOMIC);
128 memset(lapb, 0x00, sizeof(*lapb));
130 skb_queue_head_init(&lapb->write_queue);
131 skb_queue_head_init(&lapb->ack_queue);
133 init_timer(&lapb->t1timer);
134 init_timer(&lapb->t2timer);
136 lapb->t1 = LAPB_DEFAULT_T1;
137 lapb->t2 = LAPB_DEFAULT_T2;
138 lapb->n2 = LAPB_DEFAULT_N2;
139 lapb->mode = LAPB_DEFAULT_MODE;
140 lapb->window = LAPB_DEFAULT_WINDOW;
141 lapb->state = LAPB_STATE_0;
142 atomic_set(&lapb->refcnt, 1);
147 int lapb_register(void *token, struct lapb_register_struct *callbacks)
149 struct lapb_cb *lapb;
150 int rc = LAPB_BADTOKEN;
152 write_lock_bh(&lapb_list_lock);
154 lapb = __lapb_tokentostruct(token);
160 lapb = lapb_create_cb();
166 lapb->callbacks = *callbacks;
168 __lapb_insert_cb(lapb);
170 lapb_start_t1timer(lapb);
174 write_unlock_bh(&lapb_list_lock);
178 int lapb_unregister(void *token)
180 struct lapb_cb *lapb;
181 int rc = LAPB_BADTOKEN;
183 write_unlock_bh(&lapb_list_lock);
184 lapb = __lapb_tokentostruct(token);
188 lapb_stop_t1timer(lapb);
189 lapb_stop_t2timer(lapb);
191 lapb_clear_queues(lapb);
193 __lapb_remove_cb(lapb);
198 write_unlock_bh(&lapb_list_lock);
202 int lapb_getparms(void *token, struct lapb_parms_struct *parms)
204 int rc = LAPB_BADTOKEN;
205 struct lapb_cb *lapb = lapb_tokentostruct(token);
210 parms->t1 = lapb->t1 / HZ;
211 parms->t2 = lapb->t2 / HZ;
212 parms->n2 = lapb->n2;
213 parms->n2count = lapb->n2count;
214 parms->state = lapb->state;
215 parms->window = lapb->window;
216 parms->mode = lapb->mode;
218 if (!timer_pending(&lapb->t1timer))
221 parms->t1timer = (lapb->t1timer.expires - jiffies) / HZ;
223 if (!timer_pending(&lapb->t2timer))
226 parms->t2timer = (lapb->t2timer.expires - jiffies) / HZ;
234 int lapb_setparms(void *token, struct lapb_parms_struct *parms)
236 int rc = LAPB_BADTOKEN;
237 struct lapb_cb *lapb = lapb_tokentostruct(token);
243 if (parms->t1 < 1 || parms->t2 < 1 || parms->n2 < 1)
246 if (lapb->state == LAPB_STATE_0) {
247 if (((parms->mode & LAPB_EXTENDED) &&
248 (parms->window < 1 || parms->window > 127)) ||
249 (parms->window < 1 || parms->window > 7))
252 lapb->mode = parms->mode;
253 lapb->window = parms->window;
256 lapb->t1 = parms->t1 * HZ;
257 lapb->t2 = parms->t2 * HZ;
258 lapb->n2 = parms->n2;
267 int lapb_connect_request(void *token)
269 struct lapb_cb *lapb = lapb_tokentostruct(token);
270 int rc = LAPB_BADTOKEN;
276 if (lapb->state == LAPB_STATE_1)
280 if (lapb->state == LAPB_STATE_3 || lapb->state == LAPB_STATE_4)
283 lapb_establish_data_link(lapb);
286 printk(KERN_DEBUG "lapb: (%p) S0 -> S1\n", lapb->token);
288 lapb->state = LAPB_STATE_1;
297 int lapb_disconnect_request(void *token)
299 struct lapb_cb *lapb = lapb_tokentostruct(token);
300 int rc = LAPB_BADTOKEN;
305 switch (lapb->state) {
307 rc = LAPB_NOTCONNECTED;
312 printk(KERN_DEBUG "lapb: (%p) S1 TX DISC(1)\n", lapb->token);
315 printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n", lapb->token);
317 lapb_send_control(lapb, LAPB_DISC, LAPB_POLLON, LAPB_COMMAND);
318 lapb->state = LAPB_STATE_0;
319 lapb_start_t1timer(lapb);
320 rc = LAPB_NOTCONNECTED;
328 lapb_clear_queues(lapb);
330 lapb_send_control(lapb, LAPB_DISC, LAPB_POLLON, LAPB_COMMAND);
331 lapb_start_t1timer(lapb);
332 lapb_stop_t2timer(lapb);
333 lapb->state = LAPB_STATE_2;
336 printk(KERN_DEBUG "lapb: (%p) S3 DISC(1)\n", lapb->token);
339 printk(KERN_DEBUG "lapb: (%p) S3 -> S2\n", lapb->token);
349 int lapb_data_request(void *token, struct sk_buff *skb)
351 struct lapb_cb *lapb = lapb_tokentostruct(token);
352 int rc = LAPB_BADTOKEN;
357 rc = LAPB_NOTCONNECTED;
358 if (lapb->state != LAPB_STATE_3 && lapb->state != LAPB_STATE_4)
361 skb_queue_tail(&lapb->write_queue, skb);
370 int lapb_data_received(void *token, struct sk_buff *skb)
372 struct lapb_cb *lapb = lapb_tokentostruct(token);
373 int rc = LAPB_BADTOKEN;
376 lapb_data_input(lapb, skb);
384 void lapb_connect_confirmation(struct lapb_cb *lapb, int reason)
386 if (lapb->callbacks.connect_confirmation)
387 lapb->callbacks.connect_confirmation(lapb->token, reason);
390 void lapb_connect_indication(struct lapb_cb *lapb, int reason)
392 if (lapb->callbacks.connect_indication)
393 lapb->callbacks.connect_indication(lapb->token, reason);
396 void lapb_disconnect_confirmation(struct lapb_cb *lapb, int reason)
398 if (lapb->callbacks.disconnect_confirmation)
399 lapb->callbacks.disconnect_confirmation(lapb->token, reason);
402 void lapb_disconnect_indication(struct lapb_cb *lapb, int reason)
404 if (lapb->callbacks.disconnect_indication)
405 lapb->callbacks.disconnect_indication(lapb->token, reason);
408 int lapb_data_indication(struct lapb_cb *lapb, struct sk_buff *skb)
410 if (lapb->callbacks.data_indication)
411 return lapb->callbacks.data_indication(lapb->token, skb);
414 return NET_RX_CN_HIGH; /* For now; must be != NET_RX_DROP */
417 int lapb_data_transmit(struct lapb_cb *lapb, struct sk_buff *skb)
421 if (lapb->callbacks.data_transmit) {
422 lapb->callbacks.data_transmit(lapb->token, skb);
429 EXPORT_SYMBOL(lapb_register);
430 EXPORT_SYMBOL(lapb_unregister);
431 EXPORT_SYMBOL(lapb_getparms);
432 EXPORT_SYMBOL(lapb_setparms);
433 EXPORT_SYMBOL(lapb_connect_request);
434 EXPORT_SYMBOL(lapb_disconnect_request);
435 EXPORT_SYMBOL(lapb_data_request);
436 EXPORT_SYMBOL(lapb_data_received);
438 static int __init lapb_init(void)
443 static void __exit lapb_exit(void)
445 WARN_ON(!list_empty(&lapb_list));
448 MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
449 MODULE_DESCRIPTION("The X.25 Link Access Procedure B link layer protocol");
450 MODULE_LICENSE("GPL");
452 module_init(lapb_init);
453 module_exit(lapb_exit);