1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * This code REQUIRES 2.1.15 or higher/ NET3.038
8 * LAPB 001 Jonathan Naylor Started Coding
9 * LAPB 002 Jonathan Naylor New timer architecture.
10 * 2000-10-29 Henner Eisen lapb_data_indication() return status.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/module.h>
16 #include <linux/errno.h>
17 #include <linux/types.h>
18 #include <linux/socket.h>
20 #include <linux/kernel.h>
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 <linux/inet.h>
27 #include <linux/if_arp.h>
28 #include <linux/skbuff.h>
29 #include <linux/slab.h>
31 #include <linux/uaccess.h>
32 #include <linux/fcntl.h>
34 #include <linux/interrupt.h>
35 #include <linux/stat.h>
36 #include <linux/init.h>
39 static LIST_HEAD(lapb_list
);
40 static DEFINE_RWLOCK(lapb_list_lock
);
43 * Free an allocated lapb control block.
45 static void lapb_free_cb(struct lapb_cb
*lapb
)
50 static __inline__
void lapb_hold(struct lapb_cb
*lapb
)
52 refcount_inc(&lapb
->refcnt
);
55 static __inline__
void lapb_put(struct lapb_cb
*lapb
)
57 if (refcount_dec_and_test(&lapb
->refcnt
))
62 * Socket removal during an interrupt is now safe.
64 static void __lapb_remove_cb(struct lapb_cb
*lapb
)
66 if (lapb
->node
.next
) {
67 list_del(&lapb
->node
);
73 * Add a socket to the bound sockets list.
75 static void __lapb_insert_cb(struct lapb_cb
*lapb
)
77 list_add(&lapb
->node
, &lapb_list
);
81 static struct lapb_cb
*__lapb_devtostruct(struct net_device
*dev
)
83 struct list_head
*entry
;
84 struct lapb_cb
*lapb
, *use
= NULL
;
86 list_for_each(entry
, &lapb_list
) {
87 lapb
= list_entry(entry
, struct lapb_cb
, node
);
88 if (lapb
->dev
== dev
) {
100 static struct lapb_cb
*lapb_devtostruct(struct net_device
*dev
)
104 read_lock_bh(&lapb_list_lock
);
105 rc
= __lapb_devtostruct(dev
);
106 read_unlock_bh(&lapb_list_lock
);
111 * Create an empty LAPB control block.
113 static struct lapb_cb
*lapb_create_cb(void)
115 struct lapb_cb
*lapb
= kzalloc(sizeof(*lapb
), GFP_ATOMIC
);
120 skb_queue_head_init(&lapb
->write_queue
);
121 skb_queue_head_init(&lapb
->ack_queue
);
123 timer_setup(&lapb
->t1timer
, NULL
, 0);
124 timer_setup(&lapb
->t2timer
, NULL
, 0);
125 lapb
->t1timer_stop
= true;
126 lapb
->t2timer_stop
= true;
128 lapb
->t1
= LAPB_DEFAULT_T1
;
129 lapb
->t2
= LAPB_DEFAULT_T2
;
130 lapb
->n2
= LAPB_DEFAULT_N2
;
131 lapb
->mode
= LAPB_DEFAULT_MODE
;
132 lapb
->window
= LAPB_DEFAULT_WINDOW
;
133 lapb
->state
= LAPB_STATE_0
;
135 spin_lock_init(&lapb
->lock
);
136 refcount_set(&lapb
->refcnt
, 1);
141 int lapb_register(struct net_device
*dev
,
142 const struct lapb_register_struct
*callbacks
)
144 struct lapb_cb
*lapb
;
145 int rc
= LAPB_BADTOKEN
;
147 write_lock_bh(&lapb_list_lock
);
149 lapb
= __lapb_devtostruct(dev
);
155 lapb
= lapb_create_cb();
161 lapb
->callbacks
= callbacks
;
163 __lapb_insert_cb(lapb
);
165 lapb_start_t1timer(lapb
);
169 write_unlock_bh(&lapb_list_lock
);
172 EXPORT_SYMBOL(lapb_register
);
174 int lapb_unregister(struct net_device
*dev
)
176 struct lapb_cb
*lapb
;
177 int rc
= LAPB_BADTOKEN
;
179 write_lock_bh(&lapb_list_lock
);
180 lapb
= __lapb_devtostruct(dev
);
185 /* Wait for other refs to "lapb" to drop */
186 while (refcount_read(&lapb
->refcnt
) > 2)
189 spin_lock_bh(&lapb
->lock
);
191 lapb_stop_t1timer(lapb
);
192 lapb_stop_t2timer(lapb
);
194 lapb_clear_queues(lapb
);
196 spin_unlock_bh(&lapb
->lock
);
198 /* Wait for running timers to stop */
199 del_timer_sync(&lapb
->t1timer
);
200 del_timer_sync(&lapb
->t2timer
);
202 __lapb_remove_cb(lapb
);
207 write_unlock_bh(&lapb_list_lock
);
210 EXPORT_SYMBOL(lapb_unregister
);
212 int lapb_getparms(struct net_device
*dev
, struct lapb_parms_struct
*parms
)
214 int rc
= LAPB_BADTOKEN
;
215 struct lapb_cb
*lapb
= lapb_devtostruct(dev
);
220 spin_lock_bh(&lapb
->lock
);
222 parms
->t1
= lapb
->t1
/ HZ
;
223 parms
->t2
= lapb
->t2
/ HZ
;
224 parms
->n2
= lapb
->n2
;
225 parms
->n2count
= lapb
->n2count
;
226 parms
->state
= lapb
->state
;
227 parms
->window
= lapb
->window
;
228 parms
->mode
= lapb
->mode
;
230 if (!timer_pending(&lapb
->t1timer
))
233 parms
->t1timer
= (lapb
->t1timer
.expires
- jiffies
) / HZ
;
235 if (!timer_pending(&lapb
->t2timer
))
238 parms
->t2timer
= (lapb
->t2timer
.expires
- jiffies
) / HZ
;
240 spin_unlock_bh(&lapb
->lock
);
246 EXPORT_SYMBOL(lapb_getparms
);
248 int lapb_setparms(struct net_device
*dev
, struct lapb_parms_struct
*parms
)
250 int rc
= LAPB_BADTOKEN
;
251 struct lapb_cb
*lapb
= lapb_devtostruct(dev
);
256 spin_lock_bh(&lapb
->lock
);
259 if (parms
->t1
< 1 || parms
->t2
< 1 || parms
->n2
< 1)
262 if (lapb
->state
== LAPB_STATE_0
) {
263 if (parms
->mode
& LAPB_EXTENDED
) {
264 if (parms
->window
< 1 || parms
->window
> 127)
267 if (parms
->window
< 1 || parms
->window
> 7)
270 lapb
->mode
= parms
->mode
;
271 lapb
->window
= parms
->window
;
274 lapb
->t1
= parms
->t1
* HZ
;
275 lapb
->t2
= parms
->t2
* HZ
;
276 lapb
->n2
= parms
->n2
;
280 spin_unlock_bh(&lapb
->lock
);
285 EXPORT_SYMBOL(lapb_setparms
);
287 int lapb_connect_request(struct net_device
*dev
)
289 struct lapb_cb
*lapb
= lapb_devtostruct(dev
);
290 int rc
= LAPB_BADTOKEN
;
295 spin_lock_bh(&lapb
->lock
);
298 if (lapb
->state
== LAPB_STATE_1
)
302 if (lapb
->state
== LAPB_STATE_3
|| lapb
->state
== LAPB_STATE_4
)
305 lapb_establish_data_link(lapb
);
307 lapb_dbg(0, "(%p) S0 -> S1\n", lapb
->dev
);
308 lapb
->state
= LAPB_STATE_1
;
312 spin_unlock_bh(&lapb
->lock
);
317 EXPORT_SYMBOL(lapb_connect_request
);
319 static int __lapb_disconnect_request(struct lapb_cb
*lapb
)
321 switch (lapb
->state
) {
323 return LAPB_NOTCONNECTED
;
326 lapb_dbg(1, "(%p) S1 TX DISC(1)\n", lapb
->dev
);
327 lapb_dbg(0, "(%p) S1 -> S0\n", lapb
->dev
);
328 lapb_send_control(lapb
, LAPB_DISC
, LAPB_POLLON
, LAPB_COMMAND
);
329 lapb
->state
= LAPB_STATE_0
;
330 lapb_start_t1timer(lapb
);
331 return LAPB_NOTCONNECTED
;
337 lapb_clear_queues(lapb
);
339 lapb_send_control(lapb
, LAPB_DISC
, LAPB_POLLON
, LAPB_COMMAND
);
340 lapb_start_t1timer(lapb
);
341 lapb_stop_t2timer(lapb
);
342 lapb
->state
= LAPB_STATE_2
;
344 lapb_dbg(1, "(%p) S3 DISC(1)\n", lapb
->dev
);
345 lapb_dbg(0, "(%p) S3 -> S2\n", lapb
->dev
);
350 int lapb_disconnect_request(struct net_device
*dev
)
352 struct lapb_cb
*lapb
= lapb_devtostruct(dev
);
353 int rc
= LAPB_BADTOKEN
;
358 spin_lock_bh(&lapb
->lock
);
360 rc
= __lapb_disconnect_request(lapb
);
362 spin_unlock_bh(&lapb
->lock
);
367 EXPORT_SYMBOL(lapb_disconnect_request
);
369 int lapb_data_request(struct net_device
*dev
, struct sk_buff
*skb
)
371 struct lapb_cb
*lapb
= lapb_devtostruct(dev
);
372 int rc
= LAPB_BADTOKEN
;
377 spin_lock_bh(&lapb
->lock
);
379 rc
= LAPB_NOTCONNECTED
;
380 if (lapb
->state
!= LAPB_STATE_3
&& lapb
->state
!= LAPB_STATE_4
)
383 skb_queue_tail(&lapb
->write_queue
, skb
);
387 spin_unlock_bh(&lapb
->lock
);
392 EXPORT_SYMBOL(lapb_data_request
);
394 int lapb_data_received(struct net_device
*dev
, struct sk_buff
*skb
)
396 struct lapb_cb
*lapb
= lapb_devtostruct(dev
);
397 int rc
= LAPB_BADTOKEN
;
400 spin_lock_bh(&lapb
->lock
);
401 lapb_data_input(lapb
, skb
);
402 spin_unlock_bh(&lapb
->lock
);
409 EXPORT_SYMBOL(lapb_data_received
);
411 void lapb_connect_confirmation(struct lapb_cb
*lapb
, int reason
)
413 if (lapb
->callbacks
->connect_confirmation
)
414 lapb
->callbacks
->connect_confirmation(lapb
->dev
, reason
);
417 void lapb_connect_indication(struct lapb_cb
*lapb
, int reason
)
419 if (lapb
->callbacks
->connect_indication
)
420 lapb
->callbacks
->connect_indication(lapb
->dev
, reason
);
423 void lapb_disconnect_confirmation(struct lapb_cb
*lapb
, int reason
)
425 if (lapb
->callbacks
->disconnect_confirmation
)
426 lapb
->callbacks
->disconnect_confirmation(lapb
->dev
, reason
);
429 void lapb_disconnect_indication(struct lapb_cb
*lapb
, int reason
)
431 if (lapb
->callbacks
->disconnect_indication
)
432 lapb
->callbacks
->disconnect_indication(lapb
->dev
, reason
);
435 int lapb_data_indication(struct lapb_cb
*lapb
, struct sk_buff
*skb
)
437 if (lapb
->callbacks
->data_indication
)
438 return lapb
->callbacks
->data_indication(lapb
->dev
, skb
);
441 return NET_RX_SUCCESS
; /* For now; must be != NET_RX_DROP */
444 int lapb_data_transmit(struct lapb_cb
*lapb
, struct sk_buff
*skb
)
448 if (lapb
->callbacks
->data_transmit
) {
449 lapb
->callbacks
->data_transmit(lapb
->dev
, skb
);
456 /* Handle device status changes. */
457 static int lapb_device_event(struct notifier_block
*this, unsigned long event
,
460 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
461 struct lapb_cb
*lapb
;
463 if (!net_eq(dev_net(dev
), &init_net
))
466 if (dev
->type
!= ARPHRD_X25
)
469 lapb
= lapb_devtostruct(dev
);
473 spin_lock_bh(&lapb
->lock
);
477 lapb_dbg(0, "(%p) Interface up: %s\n", dev
, dev
->name
);
479 if (netif_carrier_ok(dev
)) {
480 lapb_dbg(0, "(%p): Carrier is already up: %s\n", dev
,
482 if (lapb
->mode
& LAPB_DCE
) {
483 lapb_start_t1timer(lapb
);
485 if (lapb
->state
== LAPB_STATE_0
) {
486 lapb
->state
= LAPB_STATE_1
;
487 lapb_establish_data_link(lapb
);
492 case NETDEV_GOING_DOWN
:
493 if (netif_carrier_ok(dev
))
494 __lapb_disconnect_request(lapb
);
497 lapb_dbg(0, "(%p) Interface down: %s\n", dev
, dev
->name
);
498 lapb_dbg(0, "(%p) S%d -> S0\n", dev
, lapb
->state
);
499 lapb_clear_queues(lapb
);
500 lapb
->state
= LAPB_STATE_0
;
502 lapb_stop_t1timer(lapb
);
503 lapb_stop_t2timer(lapb
);
506 if (netif_carrier_ok(dev
)) {
507 lapb_dbg(0, "(%p): Carrier detected: %s\n", dev
,
509 if (lapb
->mode
& LAPB_DCE
) {
510 lapb_start_t1timer(lapb
);
512 if (lapb
->state
== LAPB_STATE_0
) {
513 lapb
->state
= LAPB_STATE_1
;
514 lapb_establish_data_link(lapb
);
518 lapb_dbg(0, "(%p) Carrier lost: %s\n", dev
, dev
->name
);
519 lapb_dbg(0, "(%p) S%d -> S0\n", dev
, lapb
->state
);
520 lapb_clear_queues(lapb
);
521 lapb
->state
= LAPB_STATE_0
;
523 lapb_stop_t1timer(lapb
);
524 lapb_stop_t2timer(lapb
);
529 spin_unlock_bh(&lapb
->lock
);
534 static struct notifier_block lapb_dev_notifier
= {
535 .notifier_call
= lapb_device_event
,
538 static int __init
lapb_init(void)
540 return register_netdevice_notifier(&lapb_dev_notifier
);
543 static void __exit
lapb_exit(void)
545 WARN_ON(!list_empty(&lapb_list
));
547 unregister_netdevice_notifier(&lapb_dev_notifier
);
550 MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
551 MODULE_DESCRIPTION("The X.25 Link Access Procedure B link layer protocol");
552 MODULE_LICENSE("GPL");
554 module_init(lapb_init
);
555 module_exit(lapb_exit
);