[DCCP]: Fix leak in net/dccp/ipv4.c
[linux-2.6.git] / net / irda / irlap_frame.c
1 /*********************************************************************
2  *
3  * Filename:      irlap_frame.c
4  * Version:       1.0
5  * Description:   Build and transmit IrLAP frames
6  * Status:        Stable
7  * Author:        Dag Brattli <dagb@cs.uit.no>
8  * Created at:    Tue Aug 19 10:27:26 1997
9  * Modified at:   Wed Jan  5 08:59:04 2000
10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
11  *
12  *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
13  *     All Rights Reserved.
14  *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
15  *
16  *     This program is free software; you can redistribute it and/or
17  *     modify it under the terms of the GNU General Public License as
18  *     published by the Free Software Foundation; either version 2 of
19  *     the License, or (at your option) any later version.
20  *
21  *     Neither Dag Brattli nor University of Tromsø admit liability nor
22  *     provide warranty for any of this software. This material is
23  *     provided "AS-IS" and at no charge.
24  *
25  ********************************************************************/
26
27 #include <linux/skbuff.h>
28 #include <linux/if.h>
29 #include <linux/if_ether.h>
30 #include <linux/netdevice.h>
31 #include <linux/irda.h>
32
33 #include <net/pkt_sched.h>
34 #include <net/sock.h>
35
36 #include <asm/byteorder.h>
37
38 #include <net/irda/irda.h>
39 #include <net/irda/irda_device.h>
40 #include <net/irda/irlap.h>
41 #include <net/irda/wrapper.h>
42 #include <net/irda/timer.h>
43 #include <net/irda/irlap_frame.h>
44 #include <net/irda/qos.h>
45
46 static void irlap_send_i_frame(struct irlap_cb *self, struct sk_buff *skb,
47                                int command);
48
49 /*
50  * Function irlap_insert_info (self, skb)
51  *
52  *    Insert minimum turnaround time and speed information into the skb. We
53  *    need to do this since it's per packet relevant information. Safe to
54  *    have this function inlined since it's only called from one place
55  */
56 static inline void irlap_insert_info(struct irlap_cb *self,
57                                      struct sk_buff *skb)
58 {
59         struct irda_skb_cb *cb = (struct irda_skb_cb *) skb->cb;
60
61         /*
62          * Insert MTT (min. turn time) and speed into skb, so that the
63          * device driver knows which settings to use
64          */
65         cb->magic = LAP_MAGIC;
66         cb->mtt = self->mtt_required;
67         cb->next_speed = self->speed;
68
69         /* Reset */
70         self->mtt_required = 0;
71
72         /*
73          * Delay equals negotiated BOFs count, plus the number of BOFs to
74          * force the negotiated minimum turnaround time
75          */
76         cb->xbofs = self->bofs_count;
77         cb->next_xbofs = self->next_bofs;
78         cb->xbofs_delay = self->xbofs_delay;
79
80         /* Reset XBOF's delay (used only for getting min turn time) */
81         self->xbofs_delay = 0;
82         /* Put the correct xbofs value for the next packet */
83         self->bofs_count = self->next_bofs;
84 }
85
86 /*
87  * Function irlap_queue_xmit (self, skb)
88  *
89  *    A little wrapper for dev_queue_xmit, so we can insert some common
90  *    code into it.
91  */
92 void irlap_queue_xmit(struct irlap_cb *self, struct sk_buff *skb)
93 {
94         /* Some common init stuff */
95         skb->dev = self->netdev;
96         skb->h.raw = skb->nh.raw = skb->mac.raw = skb->data;
97         skb->protocol = htons(ETH_P_IRDA);
98         skb->priority = TC_PRIO_BESTEFFORT;
99
100         irlap_insert_info(self, skb);
101
102         dev_queue_xmit(skb);
103 }
104
105 /*
106  * Function irlap_send_snrm_cmd (void)
107  *
108  *    Transmits a connect SNRM command frame
109  */
110 void irlap_send_snrm_frame(struct irlap_cb *self, struct qos_info *qos)
111 {
112         struct sk_buff *tx_skb;
113         struct snrm_frame *frame;
114         int ret;
115
116         IRDA_ASSERT(self != NULL, return;);
117         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
118
119         /* Allocate frame */
120         tx_skb = dev_alloc_skb(64);
121         if (!tx_skb)
122                 return;
123
124         frame = (struct snrm_frame *) skb_put(tx_skb, 2);
125
126         /* Insert connection address field */
127         if (qos)
128                 frame->caddr = CMD_FRAME | CBROADCAST;
129         else
130                 frame->caddr = CMD_FRAME | self->caddr;
131
132         /* Insert control field */
133         frame->control = SNRM_CMD | PF_BIT;
134
135         /*
136          *  If we are establishing a connection then insert QoS paramerters
137          */
138         if (qos) {
139                 skb_put(tx_skb, 9); /* 21 left */
140                 frame->saddr = cpu_to_le32(self->saddr);
141                 frame->daddr = cpu_to_le32(self->daddr);
142
143                 frame->ncaddr = self->caddr;
144
145                 ret = irlap_insert_qos_negotiation_params(self, tx_skb);
146                 if (ret < 0) {
147                         dev_kfree_skb(tx_skb);
148                         return;
149                 }
150         }
151         irlap_queue_xmit(self, tx_skb);
152 }
153
154 /*
155  * Function irlap_recv_snrm_cmd (skb, info)
156  *
157  *    Received SNRM (Set Normal Response Mode) command frame
158  *
159  */
160 static void irlap_recv_snrm_cmd(struct irlap_cb *self, struct sk_buff *skb,
161                                 struct irlap_info *info)
162 {
163         struct snrm_frame *frame;
164
165         if (pskb_may_pull(skb,sizeof(struct snrm_frame))) {
166                 frame = (struct snrm_frame *) skb->data;
167
168                 /* Copy the new connection address ignoring the C/R bit */
169                 info->caddr = frame->ncaddr & 0xFE;
170
171                 /* Check if the new connection address is valid */
172                 if ((info->caddr == 0x00) || (info->caddr == 0xfe)) {
173                         IRDA_DEBUG(3, "%s(), invalid connection address!\n",
174                                    __FUNCTION__);
175                         return;
176                 }
177
178                 /* Copy peer device address */
179                 info->daddr = le32_to_cpu(frame->saddr);
180                 info->saddr = le32_to_cpu(frame->daddr);
181
182                 /* Only accept if addressed directly to us */
183                 if (info->saddr != self->saddr) {
184                         IRDA_DEBUG(2, "%s(), not addressed to us!\n",
185                                    __FUNCTION__);
186                         return;
187                 }
188                 irlap_do_event(self, RECV_SNRM_CMD, skb, info);
189         } else {
190                 /* Signal that this SNRM frame does not contain and I-field */
191                 irlap_do_event(self, RECV_SNRM_CMD, skb, NULL);
192         }
193 }
194
195 /*
196  * Function irlap_send_ua_response_frame (qos)
197  *
198  *    Send UA (Unnumbered Acknowledgement) frame
199  *
200  */
201 void irlap_send_ua_response_frame(struct irlap_cb *self, struct qos_info *qos)
202 {
203         struct sk_buff *tx_skb;
204         struct ua_frame *frame;
205         int ret;
206
207         IRDA_DEBUG(2, "%s() <%ld>\n", __FUNCTION__, jiffies);
208
209         IRDA_ASSERT(self != NULL, return;);
210         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
211
212         /* Allocate frame */
213         tx_skb = dev_alloc_skb(64);
214         if (!tx_skb)
215                 return;
216
217         frame = (struct ua_frame *) skb_put(tx_skb, 10);
218
219         /* Build UA response */
220         frame->caddr = self->caddr;
221         frame->control = UA_RSP | PF_BIT;
222
223         frame->saddr = cpu_to_le32(self->saddr);
224         frame->daddr = cpu_to_le32(self->daddr);
225
226         /* Should we send QoS negotiation parameters? */
227         if (qos) {
228                 ret = irlap_insert_qos_negotiation_params(self, tx_skb);
229                 if (ret < 0) {
230                         dev_kfree_skb(tx_skb);
231                         return;
232                 }
233         }
234
235         irlap_queue_xmit(self, tx_skb);
236 }
237
238
239 /*
240  * Function irlap_send_dm_frame (void)
241  *
242  *    Send disconnected mode (DM) frame
243  *
244  */
245 void irlap_send_dm_frame( struct irlap_cb *self)
246 {
247         struct sk_buff *tx_skb = NULL;
248         __u8 *frame;
249
250         IRDA_ASSERT(self != NULL, return;);
251         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
252
253         tx_skb = dev_alloc_skb(32);
254         if (!tx_skb)
255                 return;
256
257         frame = skb_put(tx_skb, 2);
258
259         if (self->state == LAP_NDM)
260                 frame[0] = CBROADCAST;
261         else
262                 frame[0] = self->caddr;
263
264         frame[1] = DM_RSP | PF_BIT;
265
266         irlap_queue_xmit(self, tx_skb);
267 }
268
269 /*
270  * Function irlap_send_disc_frame (void)
271  *
272  *    Send disconnect (DISC) frame
273  *
274  */
275 void irlap_send_disc_frame(struct irlap_cb *self)
276 {
277         struct sk_buff *tx_skb = NULL;
278         __u8 *frame;
279
280         IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
281
282         IRDA_ASSERT(self != NULL, return;);
283         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
284
285         tx_skb = dev_alloc_skb(16);
286         if (!tx_skb)
287                 return;
288
289         frame = skb_put(tx_skb, 2);
290
291         frame[0] = self->caddr | CMD_FRAME;
292         frame[1] = DISC_CMD | PF_BIT;
293
294         irlap_queue_xmit(self, tx_skb);
295 }
296
297 /*
298  * Function irlap_send_discovery_xid_frame (S, s, command)
299  *
300  *    Build and transmit a XID (eXchange station IDentifier) discovery
301  *    frame.
302  */
303 void irlap_send_discovery_xid_frame(struct irlap_cb *self, int S, __u8 s,
304                                     __u8 command, discovery_t *discovery)
305 {
306         struct sk_buff *tx_skb = NULL;
307         struct xid_frame *frame;
308         __u32 bcast = BROADCAST;
309         __u8 *info;
310
311         IRDA_DEBUG(4, "%s(), s=%d, S=%d, command=%d\n", __FUNCTION__,
312                    s, S, command);
313
314         IRDA_ASSERT(self != NULL, return;);
315         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
316         IRDA_ASSERT(discovery != NULL, return;);
317
318         tx_skb = dev_alloc_skb(64);
319         if (!tx_skb)
320                 return;
321
322         skb_put(tx_skb, 14);
323         frame = (struct xid_frame *) tx_skb->data;
324
325         if (command) {
326                 frame->caddr = CBROADCAST | CMD_FRAME;
327                 frame->control =  XID_CMD | PF_BIT;
328         } else {
329                 frame->caddr = CBROADCAST;
330                 frame->control =  XID_RSP | PF_BIT;
331         }
332         frame->ident = XID_FORMAT;
333
334         frame->saddr = cpu_to_le32(self->saddr);
335
336         if (command)
337                 frame->daddr = cpu_to_le32(bcast);
338         else
339                 frame->daddr = cpu_to_le32(discovery->data.daddr);
340
341         switch (S) {
342         case 1:
343                 frame->flags = 0x00;
344                 break;
345         case 6:
346                 frame->flags = 0x01;
347                 break;
348         case 8:
349                 frame->flags = 0x02;
350                 break;
351         case 16:
352                 frame->flags = 0x03;
353                 break;
354         default:
355                 frame->flags = 0x02;
356                 break;
357         }
358
359         frame->slotnr = s;
360         frame->version = 0x00;
361
362         /*
363          *  Provide info for final slot only in commands, and for all
364          *  responses. Send the second byte of the hint only if the
365          *  EXTENSION bit is set in the first byte.
366          */
367         if (!command || (frame->slotnr == 0xff)) {
368                 int len;
369
370                 if (discovery->data.hints[0] & HINT_EXTENSION) {
371                         info = skb_put(tx_skb, 2);
372                         info[0] = discovery->data.hints[0];
373                         info[1] = discovery->data.hints[1];
374                 } else {
375                         info = skb_put(tx_skb, 1);
376                         info[0] = discovery->data.hints[0];
377                 }
378                 info = skb_put(tx_skb, 1);
379                 info[0] = discovery->data.charset;
380
381                 len = IRDA_MIN(discovery->name_len, skb_tailroom(tx_skb));
382                 info = skb_put(tx_skb, len);
383                 memcpy(info, discovery->data.info, len);
384         }
385         irlap_queue_xmit(self, tx_skb);
386 }
387
388 /*
389  * Function irlap_recv_discovery_xid_rsp (skb, info)
390  *
391  *    Received a XID discovery response
392  *
393  */
394 static void irlap_recv_discovery_xid_rsp(struct irlap_cb *self,
395                                          struct sk_buff *skb,
396                                          struct irlap_info *info)
397 {
398         struct xid_frame *xid;
399         discovery_t *discovery = NULL;
400         __u8 *discovery_info;
401         char *text;
402
403         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
404
405         IRDA_ASSERT(self != NULL, return;);
406         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
407
408         if (!pskb_may_pull(skb, sizeof(struct xid_frame))) {
409                 IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
410                 return;
411         }
412                 
413         xid = (struct xid_frame *) skb->data;
414
415         info->daddr = le32_to_cpu(xid->saddr);
416         info->saddr = le32_to_cpu(xid->daddr);
417
418         /* Make sure frame is addressed to us */
419         if ((info->saddr != self->saddr) && (info->saddr != BROADCAST)) {
420                 IRDA_DEBUG(0, "%s(), frame is not addressed to us!\n",
421                            __FUNCTION__);
422                 return;
423         }
424
425         if ((discovery = kmalloc(sizeof(discovery_t), GFP_ATOMIC)) == NULL) {
426                 IRDA_WARNING("%s: kmalloc failed!\n", __FUNCTION__);
427                 return;
428         }
429         memset(discovery, 0, sizeof(discovery_t));
430
431         discovery->data.daddr = info->daddr;
432         discovery->data.saddr = self->saddr;
433         discovery->timestamp = jiffies;
434
435         IRDA_DEBUG(4, "%s(), daddr=%08x\n", __FUNCTION__,
436                    discovery->data.daddr);
437
438         discovery_info = skb_pull(skb, sizeof(struct xid_frame));
439
440         /* Get info returned from peer */
441         discovery->data.hints[0] = discovery_info[0];
442         if (discovery_info[0] & HINT_EXTENSION) {
443                 IRDA_DEBUG(4, "EXTENSION\n");
444                 discovery->data.hints[1] = discovery_info[1];
445                 discovery->data.charset = discovery_info[2];
446                 text = (char *) &discovery_info[3];
447         } else {
448                 discovery->data.hints[1] = 0;
449                 discovery->data.charset = discovery_info[1];
450                 text = (char *) &discovery_info[2];
451         }
452         /*
453          *  Terminate info string, should be safe since this is where the
454          *  FCS bytes resides.
455          */
456         skb->data[skb->len] = '\0';
457         strncpy(discovery->data.info, text, NICKNAME_MAX_LEN);
458         discovery->name_len = strlen(discovery->data.info);
459
460         info->discovery = discovery;
461
462         irlap_do_event(self, RECV_DISCOVERY_XID_RSP, skb, info);
463 }
464
465 /*
466  * Function irlap_recv_discovery_xid_cmd (skb, info)
467  *
468  *    Received a XID discovery command
469  *
470  */
471 static void irlap_recv_discovery_xid_cmd(struct irlap_cb *self,
472                                          struct sk_buff *skb,
473                                          struct irlap_info *info)
474 {
475         struct xid_frame *xid;
476         discovery_t *discovery = NULL;
477         __u8 *discovery_info;
478         char *text;
479
480         if (!pskb_may_pull(skb, sizeof(struct xid_frame))) {
481                 IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
482                 return;
483         }
484         
485         xid = (struct xid_frame *) skb->data;
486
487         info->daddr = le32_to_cpu(xid->saddr);
488         info->saddr = le32_to_cpu(xid->daddr);
489
490         /* Make sure frame is addressed to us */
491         if ((info->saddr != self->saddr) && (info->saddr != BROADCAST)) {
492                 IRDA_DEBUG(0, "%s(), frame is not addressed to us!\n",
493                            __FUNCTION__);
494                 return;
495         }
496
497         switch (xid->flags & 0x03) {
498         case 0x00:
499                 info->S = 1;
500                 break;
501         case 0x01:
502                 info->S = 6;
503                 break;
504         case 0x02:
505                 info->S = 8;
506                 break;
507         case 0x03:
508                 info->S = 16;
509                 break;
510         default:
511                 /* Error!! */
512                 return;
513         }
514         info->s = xid->slotnr;
515
516         discovery_info = skb_pull(skb, sizeof(struct xid_frame));
517
518         /*
519          *  Check if last frame
520          */
521         if (info->s == 0xff) {
522                 /* Check if things are sane at this point... */
523                 if((discovery_info == NULL) || 
524                    !pskb_may_pull(skb, 3)) {
525                         IRDA_ERROR("%s: discovery frame to short!\n",
526                                    __FUNCTION__);
527                         return;
528                 }
529
530                 /*
531                  *  We now have some discovery info to deliver!
532                  */
533                 discovery = kmalloc(sizeof(discovery_t), GFP_ATOMIC);
534                 if (!discovery) {
535                         IRDA_WARNING("%s: unable to malloc!\n", __FUNCTION__);
536                         return;
537                 }
538
539                 discovery->data.daddr = info->daddr;
540                 discovery->data.saddr = self->saddr;
541                 discovery->timestamp = jiffies;
542
543                 discovery->data.hints[0] = discovery_info[0];
544                 if (discovery_info[0] & HINT_EXTENSION) {
545                         discovery->data.hints[1] = discovery_info[1];
546                         discovery->data.charset = discovery_info[2];
547                         text = (char *) &discovery_info[3];
548                 } else {
549                         discovery->data.hints[1] = 0;
550                         discovery->data.charset = discovery_info[1];
551                         text = (char *) &discovery_info[2];
552                 }
553                 /*
554                  *  Terminate string, should be safe since this is where the
555                  *  FCS bytes resides.
556                  */
557                 skb->data[skb->len] = '\0';
558                 strncpy(discovery->data.info, text, NICKNAME_MAX_LEN);
559                 discovery->name_len = strlen(discovery->data.info);
560
561                 info->discovery = discovery;
562         } else
563                 info->discovery = NULL;
564
565         irlap_do_event(self, RECV_DISCOVERY_XID_CMD, skb, info);
566 }
567
568 /*
569  * Function irlap_send_rr_frame (self, command)
570  *
571  *    Build and transmit RR (Receive Ready) frame. Notice that it is currently
572  *    only possible to send RR frames with the poll bit set.
573  */
574 void irlap_send_rr_frame(struct irlap_cb *self, int command)
575 {
576         struct sk_buff *tx_skb;
577         __u8 *frame;
578
579         tx_skb = dev_alloc_skb(16);
580         if (!tx_skb)
581                 return;
582
583         frame = skb_put(tx_skb, 2);
584
585         frame[0] = self->caddr;
586         frame[0] |= (command) ? CMD_FRAME : 0;
587
588         frame[1] = RR | PF_BIT | (self->vr << 5);
589
590         irlap_queue_xmit(self, tx_skb);
591 }
592
593 /*
594  * Function irlap_send_rd_frame (self)
595  *
596  *    Request disconnect. Used by a secondary station to request the
597  *    disconnection of the link.
598  */
599 void irlap_send_rd_frame(struct irlap_cb *self)
600 {
601         struct sk_buff *tx_skb;
602         __u8 *frame;
603
604         tx_skb = dev_alloc_skb(16);
605         if (!tx_skb)
606                 return;
607
608         frame = skb_put(tx_skb, 2);
609
610         frame[0] = self->caddr;
611         frame[1] = RD_RSP | PF_BIT;
612
613         irlap_queue_xmit(self, tx_skb);
614 }
615
616 /*
617  * Function irlap_recv_rr_frame (skb, info)
618  *
619  *    Received RR (Receive Ready) frame from peer station, no harm in
620  *    making it inline since its called only from one single place
621  *    (irlap_driver_rcv).
622  */
623 static inline void irlap_recv_rr_frame(struct irlap_cb *self,
624                                        struct sk_buff *skb,
625                                        struct irlap_info *info, int command)
626 {
627         info->nr = skb->data[1] >> 5;
628
629         /* Check if this is a command or a response frame */
630         if (command)
631                 irlap_do_event(self, RECV_RR_CMD, skb, info);
632         else
633                 irlap_do_event(self, RECV_RR_RSP, skb, info);
634 }
635
636 /*
637  * Function irlap_recv_rnr_frame (self, skb, info)
638  *
639  *    Received RNR (Receive Not Ready) frame from peer station
640  *
641  */
642 static void irlap_recv_rnr_frame(struct irlap_cb *self, struct sk_buff *skb,
643                                  struct irlap_info *info, int command)
644 {
645         info->nr = skb->data[1] >> 5;
646
647         IRDA_DEBUG(4, "%s(), nr=%d, %ld\n", __FUNCTION__, info->nr, jiffies);
648
649         if (command)
650                 irlap_do_event(self, RECV_RNR_CMD, skb, info);
651         else
652                 irlap_do_event(self, RECV_RNR_RSP, skb, info);
653 }
654
655 static void irlap_recv_rej_frame(struct irlap_cb *self, struct sk_buff *skb,
656                                  struct irlap_info *info, int command)
657 {
658         IRDA_DEBUG(0, "%s()\n", __FUNCTION__);
659
660         info->nr = skb->data[1] >> 5;
661
662         /* Check if this is a command or a response frame */
663         if (command)
664                 irlap_do_event(self, RECV_REJ_CMD, skb, info);
665         else
666                 irlap_do_event(self, RECV_REJ_RSP, skb, info);
667 }
668
669 static void irlap_recv_srej_frame(struct irlap_cb *self, struct sk_buff *skb,
670                                   struct irlap_info *info, int command)
671 {
672         IRDA_DEBUG(0, "%s()\n", __FUNCTION__);
673
674         info->nr = skb->data[1] >> 5;
675
676         /* Check if this is a command or a response frame */
677         if (command)
678                 irlap_do_event(self, RECV_SREJ_CMD, skb, info);
679         else
680                 irlap_do_event(self, RECV_SREJ_RSP, skb, info);
681 }
682
683 static void irlap_recv_disc_frame(struct irlap_cb *self, struct sk_buff *skb,
684                                   struct irlap_info *info, int command)
685 {
686         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
687
688         /* Check if this is a command or a response frame */
689         if (command)
690                 irlap_do_event(self, RECV_DISC_CMD, skb, info);
691         else
692                 irlap_do_event(self, RECV_RD_RSP, skb, info);
693 }
694
695 /*
696  * Function irlap_recv_ua_frame (skb, frame)
697  *
698  *    Received UA (Unnumbered Acknowledgement) frame
699  *
700  */
701 static inline void irlap_recv_ua_frame(struct irlap_cb *self,
702                                        struct sk_buff *skb,
703                                        struct irlap_info *info)
704 {
705         irlap_do_event(self, RECV_UA_RSP, skb, info);
706 }
707
708 /*
709  * Function irlap_send_data_primary(self, skb)
710  *
711  *    Send I-frames as the primary station but without the poll bit set
712  *
713  */
714 void irlap_send_data_primary(struct irlap_cb *self, struct sk_buff *skb)
715 {
716         struct sk_buff *tx_skb;
717
718         if (skb->data[1] == I_FRAME) {
719
720                 /*
721                  *  Insert frame sequence number (Vs) in control field before
722                  *  inserting into transmit window queue.
723                  */
724                 skb->data[1] = I_FRAME | (self->vs << 1);
725
726                 /*
727                  *  Insert frame in store, in case of retransmissions
728                  *  Increase skb reference count, see irlap_do_event()
729                  */
730                 skb_get(skb);
731                 skb_queue_tail(&self->wx_list, skb);
732
733                 /* Copy buffer */
734                 tx_skb = skb_clone(skb, GFP_ATOMIC);
735                 if (tx_skb == NULL) {
736                         return;
737                 }
738
739                 self->vs = (self->vs + 1) % 8;
740                 self->ack_required = FALSE;
741                 self->window -= 1;
742
743                 irlap_send_i_frame( self, tx_skb, CMD_FRAME);
744         } else {
745                 IRDA_DEBUG(4, "%s(), sending unreliable frame\n", __FUNCTION__);
746                 irlap_send_ui_frame(self, skb_get(skb), self->caddr, CMD_FRAME);
747                 self->window -= 1;
748         }
749 }
750 /*
751  * Function irlap_send_data_primary_poll (self, skb)
752  *
753  *    Send I(nformation) frame as primary with poll bit set
754  */
755 void irlap_send_data_primary_poll(struct irlap_cb *self, struct sk_buff *skb)
756 {
757         struct sk_buff *tx_skb;
758         int transmission_time;
759
760         /* Stop P timer */
761         del_timer(&self->poll_timer);
762
763         /* Is this reliable or unreliable data? */
764         if (skb->data[1] == I_FRAME) {
765
766                 /*
767                  *  Insert frame sequence number (Vs) in control field before
768                  *  inserting into transmit window queue.
769                  */
770                 skb->data[1] = I_FRAME | (self->vs << 1);
771
772                 /*
773                  *  Insert frame in store, in case of retransmissions
774                  *  Increase skb reference count, see irlap_do_event()
775                  */
776                 skb_get(skb);
777                 skb_queue_tail(&self->wx_list, skb);
778
779                 /* Copy buffer */
780                 tx_skb = skb_clone(skb, GFP_ATOMIC);
781                 if (tx_skb == NULL) {
782                         return;
783                 }
784
785                 /*
786                  *  Set poll bit if necessary. We do this to the copied
787                  *  skb, since retransmitted need to set or clear the poll
788                  *  bit depending on when they are sent.
789                  */
790                 tx_skb->data[1] |= PF_BIT;
791
792                 self->vs = (self->vs + 1) % 8;
793                 self->ack_required = FALSE;
794
795                 irlap_send_i_frame(self, tx_skb, CMD_FRAME);
796         } else {
797                 IRDA_DEBUG(4, "%s(), sending unreliable frame\n", __FUNCTION__);
798
799                 if (self->ack_required) {
800                         irlap_send_ui_frame(self, skb_get(skb), self->caddr, CMD_FRAME);
801                         irlap_send_rr_frame(self, CMD_FRAME);
802                         self->ack_required = FALSE;
803                 } else {
804                         skb->data[1] |= PF_BIT;
805                         irlap_send_ui_frame(self, skb_get(skb), self->caddr, CMD_FRAME);
806                 }
807         }
808
809         /* How much time we took for transmission of all frames.
810          * We don't know, so let assume we used the full window. Jean II */
811         transmission_time = self->final_timeout;
812
813         /* Reset parameter so that we can fill next window */
814         self->window = self->window_size;
815
816 #ifdef CONFIG_IRDA_DYNAMIC_WINDOW
817         /* Remove what we have not used. Just do a prorata of the
818          * bytes left in window to window capacity.
819          * See max_line_capacities[][] in qos.c for details. Jean II */
820         transmission_time -= (self->final_timeout * self->bytes_left
821                               / self->line_capacity);
822         IRDA_DEBUG(4, "%s() adjusting transmission_time : ft=%d, bl=%d, lc=%d -> tt=%d\n", __FUNCTION__, self->final_timeout, self->bytes_left, self->line_capacity, transmission_time);
823
824         /* We are allowed to transmit a maximum number of bytes again. */
825         self->bytes_left = self->line_capacity;
826 #endif /* CONFIG_IRDA_DYNAMIC_WINDOW */
827
828         /*
829          * The network layer has a intermediate buffer between IrLAP
830          * and the IrDA driver which can contain 8 frames. So, even
831          * though IrLAP is currently sending the *last* frame of the
832          * tx-window, the driver most likely has only just started
833          * sending the *first* frame of the same tx-window.
834          * I.e. we are always at the very begining of or Tx window.
835          * Now, we are supposed to set the final timer from the end
836          * of our tx-window to let the other peer reply. So, we need
837          * to add extra time to compensate for the fact that we
838          * are really at the start of tx-window, otherwise the final timer
839          * might expire before he can answer...
840          * Jean II
841          */
842         irlap_start_final_timer(self, self->final_timeout + transmission_time);
843
844         /*
845          * The clever amongst you might ask why we do this adjustement
846          * only here, and not in all the other cases in irlap_event.c.
847          * In all those other case, we only send a very short management
848          * frame (few bytes), so the adjustement would be lost in the
849          * noise...
850          * The exception of course is irlap_resend_rejected_frame().
851          * Jean II */
852 }
853
854 /*
855  * Function irlap_send_data_secondary_final (self, skb)
856  *
857  *    Send I(nformation) frame as secondary with final bit set
858  *
859  */
860 void irlap_send_data_secondary_final(struct irlap_cb *self,
861                                      struct sk_buff *skb)
862 {
863         struct sk_buff *tx_skb = NULL;
864
865         IRDA_ASSERT(self != NULL, return;);
866         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
867         IRDA_ASSERT(skb != NULL, return;);
868
869         /* Is this reliable or unreliable data? */
870         if (skb->data[1] == I_FRAME) {
871
872                 /*
873                  *  Insert frame sequence number (Vs) in control field before
874                  *  inserting into transmit window queue.
875                  */
876                 skb->data[1] = I_FRAME | (self->vs << 1);
877
878                 /*
879                  *  Insert frame in store, in case of retransmissions
880                  *  Increase skb reference count, see irlap_do_event()
881                  */
882                 skb_get(skb);
883                 skb_queue_tail(&self->wx_list, skb);
884
885                 tx_skb = skb_clone(skb, GFP_ATOMIC);
886                 if (tx_skb == NULL) {
887                         return;
888                 }
889
890                 tx_skb->data[1] |= PF_BIT;
891
892                 self->vs = (self->vs + 1) % 8;
893                 self->ack_required = FALSE;
894
895                 irlap_send_i_frame(self, tx_skb, RSP_FRAME);
896         } else {
897                 if (self->ack_required) {
898                         irlap_send_ui_frame(self, skb_get(skb), self->caddr, RSP_FRAME);
899                         irlap_send_rr_frame(self, RSP_FRAME);
900                         self->ack_required = FALSE;
901                 } else {
902                         skb->data[1] |= PF_BIT;
903                         irlap_send_ui_frame(self, skb_get(skb), self->caddr, RSP_FRAME);
904                 }
905         }
906
907         self->window = self->window_size;
908 #ifdef CONFIG_IRDA_DYNAMIC_WINDOW
909         /* We are allowed to transmit a maximum number of bytes again. */
910         self->bytes_left = self->line_capacity;
911 #endif /* CONFIG_IRDA_DYNAMIC_WINDOW */
912
913         irlap_start_wd_timer(self, self->wd_timeout);
914 }
915
916 /*
917  * Function irlap_send_data_secondary (self, skb)
918  *
919  *    Send I(nformation) frame as secondary without final bit set
920  *
921  */
922 void irlap_send_data_secondary(struct irlap_cb *self, struct sk_buff *skb)
923 {
924         struct sk_buff *tx_skb = NULL;
925
926         /* Is this reliable or unreliable data? */
927         if (skb->data[1] == I_FRAME) {
928
929                 /*
930                  *  Insert frame sequence number (Vs) in control field before
931                  *  inserting into transmit window queue.
932                  */
933                 skb->data[1] = I_FRAME | (self->vs << 1);
934
935                 /*
936                  *  Insert frame in store, in case of retransmissions
937                  *  Increase skb reference count, see irlap_do_event()
938                  */
939                 skb_get(skb);
940                 skb_queue_tail(&self->wx_list, skb);
941
942                 tx_skb = skb_clone(skb, GFP_ATOMIC);
943                 if (tx_skb == NULL) {
944                         return;
945                 }
946
947                 self->vs = (self->vs + 1) % 8;
948                 self->ack_required = FALSE;
949                 self->window -= 1;
950
951                 irlap_send_i_frame(self, tx_skb, RSP_FRAME);
952         } else {
953                 irlap_send_ui_frame(self, skb_get(skb), self->caddr, RSP_FRAME);
954                 self->window -= 1;
955         }
956 }
957
958 /*
959  * Function irlap_resend_rejected_frames (nr)
960  *
961  *    Resend frames which has not been acknowledged. Should be safe to
962  *    traverse the list without locking it since this function will only be
963  *    called from interrupt context (BH)
964  */
965 void irlap_resend_rejected_frames(struct irlap_cb *self, int command)
966 {
967         struct sk_buff *tx_skb;
968         struct sk_buff *skb;
969         int count;
970
971         IRDA_ASSERT(self != NULL, return;);
972         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
973
974         /* Initialize variables */
975         count = skb_queue_len(&self->wx_list);
976
977         /*  Resend unacknowledged frame(s) */
978         skb = skb_peek(&self->wx_list);
979         while (skb != NULL) {
980                 irlap_wait_min_turn_around(self, &self->qos_tx);
981
982                 /* We copy the skb to be retransmitted since we will have to
983                  * modify it. Cloning will confuse packet sniffers
984                  */
985                 /* tx_skb = skb_clone( skb, GFP_ATOMIC); */
986                 tx_skb = skb_copy(skb, GFP_ATOMIC);
987                 if (!tx_skb) {
988                         IRDA_DEBUG(0, "%s(), unable to copy\n", __FUNCTION__);
989                         return;
990                 }
991
992                 /* Clear old Nr field + poll bit */
993                 tx_skb->data[1] &= 0x0f;
994
995                 /*
996                  *  Set poll bit on the last frame retransmitted
997                  */
998                 if (count-- == 1)
999                         tx_skb->data[1] |= PF_BIT; /* Set p/f bit */
1000                 else
1001                         tx_skb->data[1] &= ~PF_BIT; /* Clear p/f bit */
1002
1003                 irlap_send_i_frame(self, tx_skb, command);
1004
1005                 /*
1006                  *  If our skb is the last buffer in the list, then
1007                  *  we are finished, if not, move to the next sk-buffer
1008                  */
1009                 if (skb == skb_peek_tail(&self->wx_list))
1010                         skb = NULL;
1011                 else
1012                         skb = skb->next;
1013         }
1014 #if 0 /* Not yet */
1015         /*
1016          *  We can now fill the window with additional data frames
1017          */
1018         while (!skb_queue_empty(&self->txq)) {
1019
1020                 IRDA_DEBUG(0, "%s(), sending additional frames!\n", __FUNCTION__);
1021                 if (self->window > 0) {
1022                         skb = skb_dequeue( &self->txq);
1023                         IRDA_ASSERT(skb != NULL, return;);
1024
1025                         /*
1026                          *  If send window > 1 then send frame with pf
1027                          *  bit cleared
1028                          */
1029                         if ((self->window > 1) &&
1030                             !skb_queue_empty(&self->txq)) {
1031                                 irlap_send_data_primary(self, skb);
1032                         } else {
1033                                 irlap_send_data_primary_poll(self, skb);
1034                         }
1035                         kfree_skb(skb);
1036                 }
1037         }
1038 #endif
1039 }
1040
1041 void irlap_resend_rejected_frame(struct irlap_cb *self, int command)
1042 {
1043         struct sk_buff *tx_skb;
1044         struct sk_buff *skb;
1045
1046         IRDA_ASSERT(self != NULL, return;);
1047         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
1048
1049         /*  Resend unacknowledged frame(s) */
1050         skb = skb_peek(&self->wx_list);
1051         if (skb != NULL) {
1052                 irlap_wait_min_turn_around(self, &self->qos_tx);
1053
1054                 /* We copy the skb to be retransmitted since we will have to
1055                  * modify it. Cloning will confuse packet sniffers
1056                  */
1057                 /* tx_skb = skb_clone( skb, GFP_ATOMIC); */
1058                 tx_skb = skb_copy(skb, GFP_ATOMIC);
1059                 if (!tx_skb) {
1060                         IRDA_DEBUG(0, "%s(), unable to copy\n", __FUNCTION__);
1061                         return;
1062                 }
1063
1064                 /* Clear old Nr field + poll bit */
1065                 tx_skb->data[1] &= 0x0f;
1066
1067                 /*  Set poll/final bit */
1068                 tx_skb->data[1] |= PF_BIT; /* Set p/f bit */
1069
1070                 irlap_send_i_frame(self, tx_skb, command);
1071         }
1072 }
1073
1074 /*
1075  * Function irlap_send_ui_frame (self, skb, command)
1076  *
1077  *    Contruct and transmit an Unnumbered Information (UI) frame
1078  *
1079  */
1080 void irlap_send_ui_frame(struct irlap_cb *self, struct sk_buff *skb,
1081                          __u8 caddr, int command)
1082 {
1083         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
1084
1085         IRDA_ASSERT(self != NULL, return;);
1086         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
1087         IRDA_ASSERT(skb != NULL, return;);
1088
1089         /* Insert connection address */
1090         skb->data[0] = caddr | ((command) ? CMD_FRAME : 0);
1091
1092         irlap_queue_xmit(self, skb);
1093 }
1094
1095 /*
1096  * Function irlap_send_i_frame (skb)
1097  *
1098  *    Contruct and transmit Information (I) frame
1099  */
1100 static void irlap_send_i_frame(struct irlap_cb *self, struct sk_buff *skb,
1101                                int command)
1102 {
1103         /* Insert connection address */
1104         skb->data[0] = self->caddr;
1105         skb->data[0] |= (command) ? CMD_FRAME : 0;
1106
1107         /* Insert next to receive (Vr) */
1108         skb->data[1] |= (self->vr << 5);  /* insert nr */
1109
1110         irlap_queue_xmit(self, skb);
1111 }
1112
1113 /*
1114  * Function irlap_recv_i_frame (skb, frame)
1115  *
1116  *    Receive and parse an I (Information) frame, no harm in making it inline
1117  *    since it's called only from one single place (irlap_driver_rcv).
1118  */
1119 static inline void irlap_recv_i_frame(struct irlap_cb *self,
1120                                       struct sk_buff *skb,
1121                                       struct irlap_info *info, int command)
1122 {
1123         info->nr = skb->data[1] >> 5;          /* Next to receive */
1124         info->pf = skb->data[1] & PF_BIT;      /* Final bit */
1125         info->ns = (skb->data[1] >> 1) & 0x07; /* Next to send */
1126
1127         /* Check if this is a command or a response frame */
1128         if (command)
1129                 irlap_do_event(self, RECV_I_CMD, skb, info);
1130         else
1131                 irlap_do_event(self, RECV_I_RSP, skb, info);
1132 }
1133
1134 /*
1135  * Function irlap_recv_ui_frame (self, skb, info)
1136  *
1137  *    Receive and parse an Unnumbered Information (UI) frame
1138  *
1139  */
1140 static void irlap_recv_ui_frame(struct irlap_cb *self, struct sk_buff *skb,
1141                                 struct irlap_info *info)
1142 {
1143         IRDA_DEBUG( 4, "%s()\n", __FUNCTION__);
1144
1145         info->pf = skb->data[1] & PF_BIT;      /* Final bit */
1146
1147         irlap_do_event(self, RECV_UI_FRAME, skb, info);
1148 }
1149
1150 /*
1151  * Function irlap_recv_frmr_frame (skb, frame)
1152  *
1153  *    Received Frame Reject response.
1154  *
1155  */
1156 static void irlap_recv_frmr_frame(struct irlap_cb *self, struct sk_buff *skb,
1157                                   struct irlap_info *info)
1158 {
1159         __u8 *frame;
1160         int w, x, y, z;
1161
1162         IRDA_DEBUG(0, "%s()\n", __FUNCTION__);
1163
1164         IRDA_ASSERT(self != NULL, return;);
1165         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
1166         IRDA_ASSERT(skb != NULL, return;);
1167         IRDA_ASSERT(info != NULL, return;);
1168
1169         if (!pskb_may_pull(skb, 4)) {
1170                 IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
1171                 return;
1172         }
1173
1174         frame = skb->data;
1175
1176         info->nr = frame[2] >> 5;          /* Next to receive */
1177         info->pf = frame[2] & PF_BIT;      /* Final bit */
1178         info->ns = (frame[2] >> 1) & 0x07; /* Next to send */
1179
1180         w = frame[3] & 0x01;
1181         x = frame[3] & 0x02;
1182         y = frame[3] & 0x04;
1183         z = frame[3] & 0x08;
1184
1185         if (w) {
1186                 IRDA_DEBUG(0, "Rejected control field is undefined or not "
1187                       "implemented.\n");
1188         }
1189         if (x) {
1190                 IRDA_DEBUG(0, "Rejected control field was invalid because it "
1191                       "contained a non permitted I field.\n");
1192         }
1193         if (y) {
1194                 IRDA_DEBUG(0, "Received I field exceeded the maximum negotiated "
1195                       "for the existing connection or exceeded the maximum "
1196                       "this station supports if no connection exists.\n");
1197         }
1198         if (z) {
1199                 IRDA_DEBUG(0, "Rejected control field control field contained an "
1200                       "invalid Nr count.\n");
1201         }
1202         irlap_do_event(self, RECV_FRMR_RSP, skb, info);
1203 }
1204
1205 /*
1206  * Function irlap_send_test_frame (self, daddr)
1207  *
1208  *    Send a test frame response
1209  *
1210  */
1211 void irlap_send_test_frame(struct irlap_cb *self, __u8 caddr, __u32 daddr,
1212                            struct sk_buff *cmd)
1213 {
1214         struct sk_buff *tx_skb;
1215         struct test_frame *frame;
1216         __u8 *info;
1217
1218         tx_skb = dev_alloc_skb(cmd->len+sizeof(struct test_frame));
1219         if (!tx_skb)
1220                 return;
1221
1222         /* Broadcast frames must include saddr and daddr fields */
1223         if (caddr == CBROADCAST) {
1224                 frame = (struct test_frame *)
1225                         skb_put(tx_skb, sizeof(struct test_frame));
1226
1227                 /* Insert the swapped addresses */
1228                 frame->saddr = cpu_to_le32(self->saddr);
1229                 frame->daddr = cpu_to_le32(daddr);
1230         } else
1231                 frame = (struct test_frame *) skb_put(tx_skb, LAP_ADDR_HEADER + LAP_CTRL_HEADER);
1232
1233         frame->caddr = caddr;
1234         frame->control = TEST_RSP | PF_BIT;
1235
1236         /* Copy info */
1237         info = skb_put(tx_skb, cmd->len);
1238         memcpy(info, cmd->data, cmd->len);
1239
1240         /* Return to sender */
1241         irlap_wait_min_turn_around(self, &self->qos_tx);
1242         irlap_queue_xmit(self, tx_skb);
1243 }
1244
1245 /*
1246  * Function irlap_recv_test_frame (self, skb)
1247  *
1248  *    Receive a test frame
1249  *
1250  */
1251 static void irlap_recv_test_frame(struct irlap_cb *self, struct sk_buff *skb,
1252                                   struct irlap_info *info, int command)
1253 {
1254         struct test_frame *frame;
1255
1256         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
1257
1258         if (!pskb_may_pull(skb, sizeof(*frame))) {
1259                 IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
1260                 return;
1261         }
1262         frame = (struct test_frame *) skb->data;
1263
1264         /* Broadcast frames must carry saddr and daddr fields */
1265         if (info->caddr == CBROADCAST) {
1266                 if (skb->len < sizeof(struct test_frame)) {
1267                         IRDA_DEBUG(0, "%s() test frame to short!\n",
1268                                    __FUNCTION__);
1269                         return;
1270                 }
1271
1272                 /* Read and swap addresses */
1273                 info->daddr = le32_to_cpu(frame->saddr);
1274                 info->saddr = le32_to_cpu(frame->daddr);
1275
1276                 /* Make sure frame is addressed to us */
1277                 if ((info->saddr != self->saddr) &&
1278                     (info->saddr != BROADCAST)) {
1279                         return;
1280                 }
1281         }
1282
1283         if (command)
1284                 irlap_do_event(self, RECV_TEST_CMD, skb, info);
1285         else
1286                 irlap_do_event(self, RECV_TEST_RSP, skb, info);
1287 }
1288
1289 /*
1290  * Function irlap_driver_rcv (skb, netdev, ptype)
1291  *
1292  *    Called when a frame is received. Dispatches the right receive function
1293  *    for processing of the frame.
1294  *
1295  * Note on skb management :
1296  * After calling the higher layers of the IrDA stack, we always
1297  * kfree() the skb, which drop the reference count (and potentially
1298  * destroy it).
1299  * If a higher layer of the stack want to keep the skb around (to put
1300  * in a queue or pass it to the higher layer), it will need to use
1301  * skb_get() to keep a reference on it. This is usually done at the
1302  * LMP level in irlmp.c.
1303  * Jean II
1304  */
1305 int irlap_driver_rcv(struct sk_buff *skb, struct net_device *dev,
1306                      struct packet_type *ptype, struct net_device *orig_dev)
1307 {
1308         struct irlap_info info;
1309         struct irlap_cb *self;
1310         int command;
1311         __u8 control;
1312
1313         /* FIXME: should we get our own field? */
1314         self = (struct irlap_cb *) dev->atalk_ptr;
1315
1316         /* If the net device is down, then IrLAP is gone! */
1317         if (!self || self->magic != LAP_MAGIC) {
1318                 dev_kfree_skb(skb);
1319                 return -1;
1320         }
1321
1322         /* We are no longer an "old" protocol, so we need to handle
1323          * share and non linear skbs. This should never happen, so
1324          * we don't need to be clever about it. Jean II */
1325         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
1326                 IRDA_ERROR("%s: can't clone shared skb!\n", __FUNCTION__);
1327                 dev_kfree_skb(skb);
1328                 return -1;
1329         }
1330
1331         /* Check if frame is large enough for parsing */
1332         if (!pskb_may_pull(skb, 2)) {
1333                 IRDA_ERROR("%s: frame to short!\n", __FUNCTION__);
1334                 dev_kfree_skb(skb);
1335                 return -1;
1336         }
1337
1338         command    = skb->data[0] & CMD_FRAME;
1339         info.caddr = skb->data[0] & CBROADCAST;
1340
1341         info.pf      = skb->data[1] &  PF_BIT;
1342         info.control = skb->data[1] & ~PF_BIT; /* Mask away poll/final bit */
1343
1344         control = info.control;
1345
1346         /*  First we check if this frame has a valid connection address */
1347         if ((info.caddr != self->caddr) && (info.caddr != CBROADCAST)) {
1348                 IRDA_DEBUG(0, "%s(), wrong connection address!\n",
1349                            __FUNCTION__);
1350                 goto out;
1351         }
1352         /*
1353          *  Optimize for the common case and check if the frame is an
1354          *  I(nformation) frame. Only I-frames have bit 0 set to 0
1355          */
1356         if (~control & 0x01) {
1357                 irlap_recv_i_frame(self, skb, &info, command);
1358                 goto out;
1359         }
1360         /*
1361          *  We now check is the frame is an S(upervisory) frame. Only
1362          *  S-frames have bit 0 set to 1 and bit 1 set to 0
1363          */
1364         if (~control & 0x02) {
1365                 /*
1366                  *  Received S(upervisory) frame, check which frame type it is
1367                  *  only the first nibble is of interest
1368                  */
1369                 switch (control & 0x0f) {
1370                 case RR:
1371                         irlap_recv_rr_frame(self, skb, &info, command);
1372                         break;
1373                 case RNR:
1374                         irlap_recv_rnr_frame(self, skb, &info, command);
1375                         break;
1376                 case REJ:
1377                         irlap_recv_rej_frame(self, skb, &info, command);
1378                         break;
1379                 case SREJ:
1380                         irlap_recv_srej_frame(self, skb, &info, command);
1381                         break;
1382                 default:
1383                         IRDA_WARNING("%s: Unknown S-frame %02x received!\n",
1384                                 __FUNCTION__, info.control);
1385                         break;
1386                 }
1387                 goto out;
1388         }
1389         /*
1390          *  This must be a C(ontrol) frame
1391          */
1392         switch (control) {
1393         case XID_RSP:
1394                 irlap_recv_discovery_xid_rsp(self, skb, &info);
1395                 break;
1396         case XID_CMD:
1397                 irlap_recv_discovery_xid_cmd(self, skb, &info);
1398                 break;
1399         case SNRM_CMD:
1400                 irlap_recv_snrm_cmd(self, skb, &info);
1401                 break;
1402         case DM_RSP:
1403                 irlap_do_event(self, RECV_DM_RSP, skb, &info);
1404                 break;
1405         case DISC_CMD: /* And RD_RSP since they have the same value */
1406                 irlap_recv_disc_frame(self, skb, &info, command);
1407                 break;
1408         case TEST_CMD:
1409                 irlap_recv_test_frame(self, skb, &info, command);
1410                 break;
1411         case UA_RSP:
1412                 irlap_recv_ua_frame(self, skb, &info);
1413                 break;
1414         case FRMR_RSP:
1415                 irlap_recv_frmr_frame(self, skb, &info);
1416                 break;
1417         case UI_FRAME:
1418                 irlap_recv_ui_frame(self, skb, &info);
1419                 break;
1420         default:
1421                 IRDA_WARNING("%s: Unknown frame %02x received!\n",
1422                                 __FUNCTION__, info.control);
1423                 break;
1424         }
1425 out:
1426         /* Always drop our reference on the skb */
1427         dev_kfree_skb(skb);
1428         return 0;
1429 }