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