?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] md: allow checkpoint of recovery with version-1 superblock
[linux-2.6/mini2440.git] / net / lapb / lapb_in.c
blobb0f8713f66cae3aeeef51bac2406d57292cd58cb
1 /*
2 * LAPB release 002
3 *
4 * This code REQUIRES 2.1.15 or higher/ NET3.038
5 *
6 * This module:
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.
11 *
12 * History
13 * LAPB 001 Jonathan Naulor Started Coding
14 * LAPB 002 Jonathan Naylor New timer architecture.
15 * 2000-10-29 Henner Eisen lapb_data_indication() return status.
16 */
17
18 #include <linux/errno.h>
19 #include <linux/types.h>
20 #include <linux/socket.h>
21 #include <linux/in.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <linux/inet.h>
29 #include <linux/netdevice.h>
30 #include <linux/skbuff.h>
31 #include <net/sock.h>
32 #include <asm/uaccess.h>
33 #include <asm/system.h>
34 #include <linux/fcntl.h>
35 #include <linux/mm.h>
36 #include <linux/interrupt.h>
37 #include <net/lapb.h>
38
39 /*
40 * State machine for state 0, Disconnected State.
41 * The handling of the timer(s) is in file lapb_timer.c.
42 */
43 static void lapb_state0_machine(struct lapb_cb *lapb, struct sk_buff *skb,
44 struct lapb_frame *frame)
45 {
46 switch (frame->type) {
47 case LAPB_SABM:
48 #if LAPB_DEBUG > 1
49 printk(KERN_DEBUG "lapb: (%p) S0 RX SABM(%d)\n",
50 lapb->dev, frame->pf);
51 #endif
52 if (lapb->mode & LAPB_EXTENDED) {
53 #if LAPB_DEBUG > 1
54 printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
55 lapb->dev, frame->pf);
56 #endif
57 lapb_send_control(lapb, LAPB_DM, frame->pf,
58 LAPB_RESPONSE);
59 } else {
60 #if LAPB_DEBUG > 1
61 printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
62 lapb->dev, frame->pf);
63 #endif
64 #if LAPB_DEBUG > 0
65 printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n",
66 lapb->dev);
67 #endif
68 lapb_send_control(lapb, LAPB_UA, frame->pf,
69 LAPB_RESPONSE);
70 lapb_stop_t1timer(lapb);
71 lapb_stop_t2timer(lapb);
72 lapb->state = LAPB_STATE_3;
73 lapb->condition = 0x00;
74 lapb->n2count = 0;
75 lapb->vs = 0;
76 lapb->vr = 0;
77 lapb->va = 0;
78 lapb_connect_indication(lapb, LAPB_OK);
79 }
80 break;
81
82 case LAPB_SABME:
83 #if LAPB_DEBUG > 1
84 printk(KERN_DEBUG "lapb: (%p) S0 RX SABME(%d)\n",
85 lapb->dev, frame->pf);
86 #endif
87 if (lapb->mode & LAPB_EXTENDED) {
88 #if LAPB_DEBUG > 1
89 printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
90 lapb->dev, frame->pf);
91 #endif
92 #if LAPB_DEBUG > 0
93 printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n",
94 lapb->dev);
95 #endif
96 lapb_send_control(lapb, LAPB_UA, frame->pf,
97 LAPB_RESPONSE);
98 lapb_stop_t1timer(lapb);
99 lapb_stop_t2timer(lapb);
100 lapb->state = LAPB_STATE_3;
101 lapb->condition = 0x00;
102 lapb->n2count = 0;
103 lapb->vs = 0;
104 lapb->vr = 0;
105 lapb->va = 0;
106 lapb_connect_indication(lapb, LAPB_OK);
107 } else {
108 #if LAPB_DEBUG > 1
109 printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
110 lapb->dev, frame->pf);
111 #endif
112 lapb_send_control(lapb, LAPB_DM, frame->pf,
113 LAPB_RESPONSE);
114 }
115 break;
116
117 case LAPB_DISC:
118 #if LAPB_DEBUG > 1
119 printk(KERN_DEBUG "lapb: (%p) S0 RX DISC(%d)\n",
120 lapb->dev, frame->pf);
121 printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
122 lapb->dev, frame->pf);
123 #endif
124 lapb_send_control(lapb, LAPB_UA, frame->pf,
125 LAPB_RESPONSE);
126 break;
127
128 default:
129 break;
130 }
131
132 kfree_skb(skb);
133 }
134
135 /*
136 * State machine for state 1, Awaiting Connection State.
137 * The handling of the timer(s) is in file lapb_timer.c.
138 */
139 static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb,
140 struct lapb_frame *frame)
141 {
142 switch (frame->type) {
143 case LAPB_SABM:
144 #if LAPB_DEBUG > 1
145 printk(KERN_DEBUG "lapb: (%p) S1 RX SABM(%d)\n",
146 lapb->dev, frame->pf);
147 #endif
148 if (lapb->mode & LAPB_EXTENDED) {
149 #if LAPB_DEBUG > 1
150 printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
151 lapb->dev, frame->pf);
152 #endif
153 lapb_send_control(lapb, LAPB_DM, frame->pf,
154 LAPB_RESPONSE);
155 } else {
156 #if LAPB_DEBUG > 1
157 printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
158 lapb->dev, frame->pf);
159 #endif
160 lapb_send_control(lapb, LAPB_UA, frame->pf,
161 LAPB_RESPONSE);
162 }
163 break;
164
165 case LAPB_SABME:
166 #if LAPB_DEBUG > 1
167 printk(KERN_DEBUG "lapb: (%p) S1 RX SABME(%d)\n",
168 lapb->dev, frame->pf);
169 #endif
170 if (lapb->mode & LAPB_EXTENDED) {
171 #if LAPB_DEBUG > 1
172 printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
173 lapb->dev, frame->pf);
174 #endif
175 lapb_send_control(lapb, LAPB_UA, frame->pf,
176 LAPB_RESPONSE);
177 } else {
178 #if LAPB_DEBUG > 1
179 printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
180 lapb->dev, frame->pf);
181 #endif
182 lapb_send_control(lapb, LAPB_DM, frame->pf,
183 LAPB_RESPONSE);
184 }
185 break;
186
187 case LAPB_DISC:
188 #if LAPB_DEBUG > 1
189 printk(KERN_DEBUG "lapb: (%p) S1 RX DISC(%d)\n",
190 lapb->dev, frame->pf);
191 printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
192 lapb->dev, frame->pf);
193 #endif
194 lapb_send_control(lapb, LAPB_DM, frame->pf,
195 LAPB_RESPONSE);
196 break;
197
198 case LAPB_UA:
199 #if LAPB_DEBUG > 1
200 printk(KERN_DEBUG "lapb: (%p) S1 RX UA(%d)\n",
201 lapb->dev, frame->pf);
202 #endif
203 if (frame->pf) {
204 #if LAPB_DEBUG > 0
205 printk(KERN_DEBUG "lapb: (%p) S1 -> S3\n",
206 lapb->dev);
207 #endif
208 lapb_stop_t1timer(lapb);
209 lapb_stop_t2timer(lapb);
210 lapb->state = LAPB_STATE_3;
211 lapb->condition = 0x00;
212 lapb->n2count = 0;
213 lapb->vs = 0;
214 lapb->vr = 0;
215 lapb->va = 0;
216 lapb_connect_confirmation(lapb, LAPB_OK);
217 }
218 break;
219
220 case LAPB_DM:
221 #if LAPB_DEBUG > 1
222 printk(KERN_DEBUG "lapb: (%p) S1 RX DM(%d)\n",
223 lapb->dev, frame->pf);
224 #endif
225 if (frame->pf) {
226 #if LAPB_DEBUG > 0
227 printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n",
228 lapb->dev);
229 #endif
230 lapb_clear_queues(lapb);
231 lapb->state = LAPB_STATE_0;
232 lapb_start_t1timer(lapb);
233 lapb_stop_t2timer(lapb);
234 lapb_disconnect_indication(lapb, LAPB_REFUSED);
235 }
236 break;
237 }
238
239 kfree_skb(skb);
240 }
241
242 /*
243 * State machine for state 2, Awaiting Release State.
244 * The handling of the timer(s) is in file lapb_timer.c
245 */
246 static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb,
247 struct lapb_frame *frame)
248 {
249 switch (frame->type) {
250 case LAPB_SABM:
251 case LAPB_SABME:
252 #if LAPB_DEBUG > 1
253 printk(KERN_DEBUG "lapb: (%p) S2 RX {SABM,SABME}(%d)\n",
254 lapb->dev, frame->pf);
255 printk(KERN_DEBUG "lapb: (%p) S2 TX DM(%d)\n",
256 lapb->dev, frame->pf);
257 #endif
258 lapb_send_control(lapb, LAPB_DM, frame->pf,
259 LAPB_RESPONSE);
260 break;
261
262 case LAPB_DISC:
263 #if LAPB_DEBUG > 1
264 printk(KERN_DEBUG "lapb: (%p) S2 RX DISC(%d)\n",
265 lapb->dev, frame->pf);
266 printk(KERN_DEBUG "lapb: (%p) S2 TX UA(%d)\n",
267 lapb->dev, frame->pf);
268 #endif
269 lapb_send_control(lapb, LAPB_UA, frame->pf,
270 LAPB_RESPONSE);
271 break;
272
273 case LAPB_UA:
274 #if LAPB_DEBUG > 1
275 printk(KERN_DEBUG "lapb: (%p) S2 RX UA(%d)\n",
276 lapb->dev, frame->pf);
277 #endif
278 if (frame->pf) {
279 #if LAPB_DEBUG > 0
280 printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n",
281 lapb->dev);
282 #endif
283 lapb->state = LAPB_STATE_0;
284 lapb_start_t1timer(lapb);
285 lapb_stop_t2timer(lapb);
286 lapb_disconnect_confirmation(lapb, LAPB_OK);
287 }
288 break;
289
290 case LAPB_DM:
291 #if LAPB_DEBUG > 1
292 printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
293 lapb->dev, frame->pf);
294 #endif
295 if (frame->pf) {
296 #if LAPB_DEBUG > 0
297 printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n",
298 lapb->dev);
299 #endif
300 lapb->state = LAPB_STATE_0;
301 lapb_start_t1timer(lapb);
302 lapb_stop_t2timer(lapb);
303 lapb_disconnect_confirmation(lapb,
304 LAPB_NOTCONNECTED);
305 }
306 break;
307
308 case LAPB_I:
309 case LAPB_REJ:
310 case LAPB_RNR:
311 case LAPB_RR:
312 #if LAPB_DEBUG > 1
313 printk(KERN_DEBUG "lapb: (%p) S2 RX {I,REJ,RNR,RR}"
314 "(%d)\n", lapb->dev, frame->pf);
315 printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
316 lapb->dev, frame->pf);
317 #endif
318 if (frame->pf)
319 lapb_send_control(lapb, LAPB_DM, frame->pf,
320 LAPB_RESPONSE);
321 break;
322 }
323
324 kfree_skb(skb);
325 }
326
327 /*
328 * State machine for state 3, Connected State.
329 * The handling of the timer(s) is in file lapb_timer.c
330 */
331 static void lapb_state3_machine(struct lapb_cb *lapb, struct sk_buff *skb,
332 struct lapb_frame *frame)
333 {
334 int queued = 0;
335 int modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS :
336 LAPB_SMODULUS;
337
338 switch (frame->type) {
339 case LAPB_SABM:
340 #if LAPB_DEBUG > 1
341 printk(KERN_DEBUG "lapb: (%p) S3 RX SABM(%d)\n",
342 lapb->dev, frame->pf);
343 #endif
344 if (lapb->mode & LAPB_EXTENDED) {
345 #if LAPB_DEBUG > 1
346 printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
347 lapb->dev, frame->pf);
348 #endif
349 lapb_send_control(lapb, LAPB_DM, frame->pf,
350 LAPB_RESPONSE);
351 } else {
352 #if LAPB_DEBUG > 1
353 printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
354 lapb->dev, frame->pf);
355 #endif
356 lapb_send_control(lapb, LAPB_UA, frame->pf,
357 LAPB_RESPONSE);
358 lapb_stop_t1timer(lapb);
359 lapb_stop_t2timer(lapb);
360 lapb->condition = 0x00;
361 lapb->n2count = 0;
362 lapb->vs = 0;
363 lapb->vr = 0;
364 lapb->va = 0;
365 lapb_requeue_frames(lapb);
366 }
367 break;
368
369 case LAPB_SABME:
370 #if LAPB_DEBUG > 1
371 printk(KERN_DEBUG "lapb: (%p) S3 RX SABME(%d)\n",
372 lapb->dev, frame->pf);
373 #endif
374 if (lapb->mode & LAPB_EXTENDED) {
375 #if LAPB_DEBUG > 1
376 printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
377 lapb->dev, frame->pf);
378 #endif
379 lapb_send_control(lapb, LAPB_UA, frame->pf,
380 LAPB_RESPONSE);
381 lapb_stop_t1timer(lapb);
382 lapb_stop_t2timer(lapb);
383 lapb->condition = 0x00;
384 lapb->n2count = 0;
385 lapb->vs = 0;
386 lapb->vr = 0;
387 lapb->va = 0;
388 lapb_requeue_frames(lapb);
389 } else {
390 #if LAPB_DEBUG > 1
391 printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
392 lapb->dev, frame->pf);
393 #endif
394 lapb_send_control(lapb, LAPB_DM, frame->pf,
395 LAPB_RESPONSE);
396 }
397 break;
398
399 case LAPB_DISC:
400 #if LAPB_DEBUG > 1
401 printk(KERN_DEBUG "lapb: (%p) S3 RX DISC(%d)\n",
402 lapb->dev, frame->pf);
403 #endif
404 #if LAPB_DEBUG > 0
405 printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n",
406 lapb->dev);
407 #endif
408 lapb_clear_queues(lapb);
409 lapb_send_control(lapb, LAPB_UA, frame->pf,
410 LAPB_RESPONSE);
411 lapb_start_t1timer(lapb);
412 lapb_stop_t2timer(lapb);
413 lapb->state = LAPB_STATE_0;
414 lapb_disconnect_indication(lapb, LAPB_OK);
415 break;
416
417 case LAPB_DM:
418 #if LAPB_DEBUG > 1
419 printk(KERN_DEBUG "lapb: (%p) S3 RX DM(%d)\n",
420 lapb->dev, frame->pf);
421 #endif
422 #if LAPB_DEBUG > 0
423 printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n",
424 lapb->dev);
425 #endif
426 lapb_clear_queues(lapb);
427 lapb->state = LAPB_STATE_0;
428 lapb_start_t1timer(lapb);
429 lapb_stop_t2timer(lapb);
430 lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED);
431 break;
432
433 case LAPB_RNR:
434 #if LAPB_DEBUG > 1
435 printk(KERN_DEBUG "lapb: (%p) S3 RX RNR(%d) R%d\n",
436 lapb->dev, frame->pf, frame->nr);
437 #endif
438 lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION;
439 lapb_check_need_response(lapb, frame->cr, frame->pf);
440 if (lapb_validate_nr(lapb, frame->nr)) {
441 lapb_check_iframes_acked(lapb, frame->nr);
442 } else {
443 lapb->frmr_data = *frame;
444 lapb->frmr_type = LAPB_FRMR_Z;
445 lapb_transmit_frmr(lapb);
446 #if LAPB_DEBUG > 0
447 printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
448 lapb->dev);
449 #endif
450 lapb_start_t1timer(lapb);
451 lapb_stop_t2timer(lapb);
452 lapb->state = LAPB_STATE_4;
453 lapb->n2count = 0;
454 }
455 break;
456
457 case LAPB_RR:
458 #if LAPB_DEBUG > 1
459 printk(KERN_DEBUG "lapb: (%p) S3 RX RR(%d) R%d\n",
460 lapb->dev, frame->pf, frame->nr);
461 #endif
462 lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
463 lapb_check_need_response(lapb, frame->cr, frame->pf);
464 if (lapb_validate_nr(lapb, frame->nr)) {
465 lapb_check_iframes_acked(lapb, frame->nr);
466 } else {
467 lapb->frmr_data = *frame;
468 lapb->frmr_type = LAPB_FRMR_Z;
469 lapb_transmit_frmr(lapb);
470 #if LAPB_DEBUG > 0
471 printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
472 lapb->dev);
473 #endif
474 lapb_start_t1timer(lapb);
475 lapb_stop_t2timer(lapb);
476 lapb->state = LAPB_STATE_4;
477 lapb->n2count = 0;
478 }
479 break;
480
481 case LAPB_REJ:
482 #if LAPB_DEBUG > 1
483 printk(KERN_DEBUG "lapb: (%p) S3 RX REJ(%d) R%d\n",
484 lapb->dev, frame->pf, frame->nr);
485 #endif
486 lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
487 lapb_check_need_response(lapb, frame->cr, frame->pf);
488 if (lapb_validate_nr(lapb, frame->nr)) {
489 lapb_frames_acked(lapb, frame->nr);
490 lapb_stop_t1timer(lapb);
491 lapb->n2count = 0;
492 lapb_requeue_frames(lapb);
493 } else {
494 lapb->frmr_data = *frame;
495 lapb->frmr_type = LAPB_FRMR_Z;
496 lapb_transmit_frmr(lapb);
497 #if LAPB_DEBUG > 0
498 printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
499 lapb->dev);
500 #endif
501 lapb_start_t1timer(lapb);
502 lapb_stop_t2timer(lapb);
503 lapb->state = LAPB_STATE_4;
504 lapb->n2count = 0;
505 }
506 break;
507
508 case LAPB_I:
509 #if LAPB_DEBUG > 1
510 printk(KERN_DEBUG "lapb: (%p) S3 RX I(%d) S%d R%d\n",
511 lapb->dev, frame->pf, frame->ns, frame->nr);
512 #endif
513 if (!lapb_validate_nr(lapb, frame->nr)) {
514 lapb->frmr_data = *frame;
515 lapb->frmr_type = LAPB_FRMR_Z;
516 lapb_transmit_frmr(lapb);
517 #if LAPB_DEBUG > 0
518 printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
519 lapb->dev);
520 #endif
521 lapb_start_t1timer(lapb);
522 lapb_stop_t2timer(lapb);
523 lapb->state = LAPB_STATE_4;
524 lapb->n2count = 0;
525 break;
526 }
527 if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION)
528 lapb_frames_acked(lapb, frame->nr);
529 else
530 lapb_check_iframes_acked(lapb, frame->nr);
531
532 if (frame->ns == lapb->vr) {
533 int cn;
534 cn = lapb_data_indication(lapb, skb);
535 queued = 1;
536 /*
537 * If upper layer has dropped the frame, we
538 * basically ignore any further protocol
539 * processing. This will cause the peer
540 * to re-transmit the frame later like
541 * a frame lost on the wire.
542 */
543 if (cn == NET_RX_DROP) {
544 printk(KERN_DEBUG
545 "LAPB: rx congestion\n");
546 break;
547 }
548 lapb->vr = (lapb->vr + 1) % modulus;
549 lapb->condition &= ~LAPB_REJECT_CONDITION;
550 if (frame->pf)
551 lapb_enquiry_response(lapb);
552 else {
553 if (!(lapb->condition &
554 LAPB_ACK_PENDING_CONDITION)) {
555 lapb->condition |= LAPB_ACK_PENDING_CONDITION;
556 lapb_start_t2timer(lapb);
557 }
558 }
559 } else {
560 if (lapb->condition & LAPB_REJECT_CONDITION) {
561 if (frame->pf)
562 lapb_enquiry_response(lapb);
563 } else {
564 #if LAPB_DEBUG > 1
565 printk(KERN_DEBUG
566 "lapb: (%p) S3 TX REJ(%d) R%d\n",
567 lapb->dev, frame->pf, lapb->vr);
568 #endif
569 lapb->condition |= LAPB_REJECT_CONDITION;
570 lapb_send_control(lapb, LAPB_REJ,
571 frame->pf,
572 LAPB_RESPONSE);
573 lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
574 }
575 }
576 break;
577
578 case LAPB_FRMR:
579 #if LAPB_DEBUG > 1
580 printk(KERN_DEBUG "lapb: (%p) S3 RX FRMR(%d) %02X "
581 "%02X %02X %02X %02X\n", lapb->dev, frame->pf,
582 skb->data[0], skb->data[1], skb->data[2],
583 skb->data[3], skb->data[4]);
584 #endif
585 lapb_establish_data_link(lapb);
586 #if LAPB_DEBUG > 0
587 printk(KERN_DEBUG "lapb: (%p) S3 -> S1\n",
588 lapb->dev);
589 #endif
590 lapb_requeue_frames(lapb);
591 lapb->state = LAPB_STATE_1;
592 break;
593
594 case LAPB_ILLEGAL:
595 #if LAPB_DEBUG > 1
596 printk(KERN_DEBUG "lapb: (%p) S3 RX ILLEGAL(%d)\n",
597 lapb->dev, frame->pf);
598 #endif
599 lapb->frmr_data = *frame;
600 lapb->frmr_type = LAPB_FRMR_W;
601 lapb_transmit_frmr(lapb);
602 #if LAPB_DEBUG > 0
603 printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
604 #endif
605 lapb_start_t1timer(lapb);
606 lapb_stop_t2timer(lapb);
607 lapb->state = LAPB_STATE_4;
608 lapb->n2count = 0;
609 break;
610 }
611
612 if (!queued)
613 kfree_skb(skb);
614 }
615
616 /*
617 * State machine for state 4, Frame Reject State.
618 * The handling of the timer(s) is in file lapb_timer.c.
619 */
620 static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb,
621 struct lapb_frame *frame)
622 {
623 switch (frame->type) {
624 case LAPB_SABM:
625 #if LAPB_DEBUG > 1
626 printk(KERN_DEBUG "lapb: (%p) S4 RX SABM(%d)\n",
627 lapb->dev, frame->pf);
628 #endif
629 if (lapb->mode & LAPB_EXTENDED) {
630 #if LAPB_DEBUG > 1
631 printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
632 lapb->dev, frame->pf);
633 #endif
634 lapb_send_control(lapb, LAPB_DM, frame->pf,
635 LAPB_RESPONSE);
636 } else {
637 #if LAPB_DEBUG > 1
638 printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
639 lapb->dev, frame->pf);
640 #endif
641 #if LAPB_DEBUG > 0
642 printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n",
643 lapb->dev);
644 #endif
645 lapb_send_control(lapb, LAPB_UA, frame->pf,
646 LAPB_RESPONSE);
647 lapb_stop_t1timer(lapb);
648 lapb_stop_t2timer(lapb);
649 lapb->state = LAPB_STATE_3;
650 lapb->condition = 0x00;
651 lapb->n2count = 0;
652 lapb->vs = 0;
653 lapb->vr = 0;
654 lapb->va = 0;
655 lapb_connect_indication(lapb, LAPB_OK);
656 }
657 break;
658
659 case LAPB_SABME:
660 #if LAPB_DEBUG > 1
661 printk(KERN_DEBUG "lapb: (%p) S4 RX SABME(%d)\n",
662 lapb->dev, frame->pf);
663 #endif
664 if (lapb->mode & LAPB_EXTENDED) {
665 #if LAPB_DEBUG > 1
666 printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
667 lapb->dev, frame->pf);
668 #endif
669 #if LAPB_DEBUG > 0
670 printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n",
671 lapb->dev);
672 #endif
673 lapb_send_control(lapb, LAPB_UA, frame->pf,
674 LAPB_RESPONSE);
675 lapb_stop_t1timer(lapb);
676 lapb_stop_t2timer(lapb);
677 lapb->state = LAPB_STATE_3;
678 lapb->condition = 0x00;
679 lapb->n2count = 0;
680 lapb->vs = 0;
681 lapb->vr = 0;
682 lapb->va = 0;
683 lapb_connect_indication(lapb, LAPB_OK);
684 } else {
685 #if LAPB_DEBUG > 1
686 printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
687 lapb->dev, frame->pf);
688 #endif
689 lapb_send_control(lapb, LAPB_DM, frame->pf,
690 LAPB_RESPONSE);
691 }
692 break;
693 }
694
695 kfree_skb(skb);
696 }
697
698 /*
699 * Process an incoming LAPB frame
700 */
701 void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *skb)
702 {
703 struct lapb_frame frame;
704
705 if (lapb_decode(lapb, skb, &frame) < 0) {
706 kfree_skb(skb);
707 return;
708 }
709
710 switch (lapb->state) {
711 case LAPB_STATE_0:
712 lapb_state0_machine(lapb, skb, &frame); break;
713 case LAPB_STATE_1:
714 lapb_state1_machine(lapb, skb, &frame); break;
715 case LAPB_STATE_2:
716 lapb_state2_machine(lapb, skb, &frame); break;
717 case LAPB_STATE_3:
718 lapb_state3_machine(lapb, skb, &frame); break;
719 case LAPB_STATE_4:
720 lapb_state4_machine(lapb, skb, &frame); break;
721 }
722
723 lapb_kick(lapb);
724 }
Support for the Chinese Samsung S3C2440 based development boards