1 /*********************************************************************
5 * Description: Tiny Transport Protocol (TTP) implementation
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sun Aug 31 20:14:31 1997
9 * Modified at: Wed Jan 5 11:31:27 2000
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
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>
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.
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.
25 ********************************************************************/
27 #include <linux/skbuff.h>
28 #include <linux/init.h>
30 #include <linux/seq_file.h>
31 #include <linux/slab.h>
32 #include <linux/export.h>
34 #include <asm/byteorder.h>
35 #include <asm/unaligned.h>
37 #include <net/irda/irda.h>
38 #include <net/irda/irlap.h>
39 #include <net/irda/irlmp.h>
40 #include <net/irda/parameters.h>
41 #include <net/irda/irttp.h>
43 static struct irttp_cb
*irttp
;
45 static void __irttp_close_tsap(struct tsap_cb
*self
);
47 static int irttp_data_indication(void *instance
, void *sap
,
49 static int irttp_udata_indication(void *instance
, void *sap
,
51 static void irttp_disconnect_indication(void *instance
, void *sap
,
52 LM_REASON reason
, struct sk_buff
*);
53 static void irttp_connect_indication(void *instance
, void *sap
,
54 struct qos_info
*qos
, __u32 max_sdu_size
,
55 __u8 header_size
, struct sk_buff
*skb
);
56 static void irttp_connect_confirm(void *instance
, void *sap
,
57 struct qos_info
*qos
, __u32 max_sdu_size
,
58 __u8 header_size
, struct sk_buff
*skb
);
59 static void irttp_run_tx_queue(struct tsap_cb
*self
);
60 static void irttp_run_rx_queue(struct tsap_cb
*self
);
62 static void irttp_flush_queues(struct tsap_cb
*self
);
63 static void irttp_fragment_skb(struct tsap_cb
*self
, struct sk_buff
*skb
);
64 static struct sk_buff
*irttp_reassemble_skb(struct tsap_cb
*self
);
65 static void irttp_todo_expired(unsigned long data
);
66 static int irttp_param_max_sdu_size(void *instance
, irda_param_t
*param
,
69 static void irttp_flow_indication(void *instance
, void *sap
, LOCAL_FLOW flow
);
70 static void irttp_status_indication(void *instance
,
71 LINK_STATUS link
, LOCK_STATUS lock
);
73 /* Information for parsing parameters in IrTTP */
74 static pi_minor_info_t pi_minor_call_table
[] = {
75 { NULL
, 0 }, /* 0x00 */
76 { irttp_param_max_sdu_size
, PV_INTEGER
| PV_BIG_ENDIAN
} /* 0x01 */
78 static pi_major_info_t pi_major_call_table
[] = { { pi_minor_call_table
, 2 } };
79 static pi_param_info_t param_info
= { pi_major_call_table
, 1, 0x0f, 4 };
81 /************************ GLOBAL PROCEDURES ************************/
84 * Function irttp_init (void)
86 * Initialize the IrTTP layer. Called by module initialization code
89 int __init
irttp_init(void)
91 irttp
= kzalloc(sizeof(struct irttp_cb
), GFP_KERNEL
);
95 irttp
->magic
= TTP_MAGIC
;
97 irttp
->tsaps
= hashbin_new(HB_LOCK
);
99 net_err_ratelimited("%s: can't allocate IrTTP hashbin!\n",
109 * Function irttp_cleanup (void)
111 * Called by module destruction/cleanup code
114 void irttp_cleanup(void)
116 /* Check for main structure */
117 IRDA_ASSERT(irttp
->magic
== TTP_MAGIC
, return;);
120 * Delete hashbin and close all TSAP instances in it
122 hashbin_delete(irttp
->tsaps
, (FREE_FUNC
) __irttp_close_tsap
);
126 /* De-allocate main structure */
132 /*************************** SUBROUTINES ***************************/
135 * Function irttp_start_todo_timer (self, timeout)
139 * Made it more effient and unsensitive to race conditions - Jean II
141 static inline void irttp_start_todo_timer(struct tsap_cb
*self
, int timeout
)
143 /* Set new value for timer */
144 mod_timer(&self
->todo_timer
, jiffies
+ timeout
);
148 * Function irttp_todo_expired (data)
150 * Todo timer has expired!
152 * One of the restriction of the timer is that it is run only on the timer
153 * interrupt which run every 10ms. This mean that even if you set the timer
154 * with a delay of 0, it may take up to 10ms before it's run.
155 * So, to minimise latency and keep cache fresh, we try to avoid using
156 * it as much as possible.
157 * Note : we can't use tasklets, because they can't be asynchronously
158 * killed (need user context), and we can't guarantee that here...
161 static void irttp_todo_expired(unsigned long data
)
163 struct tsap_cb
*self
= (struct tsap_cb
*) data
;
165 /* Check that we still exist */
166 if (!self
|| self
->magic
!= TTP_TSAP_MAGIC
)
169 pr_debug("%s(instance=%p)\n", __func__
, self
);
171 /* Try to make some progress, especially on Tx side - Jean II */
172 irttp_run_rx_queue(self
);
173 irttp_run_tx_queue(self
);
175 /* Check if time for disconnect */
176 if (test_bit(0, &self
->disconnect_pend
)) {
177 /* Check if it's possible to disconnect yet */
178 if (skb_queue_empty(&self
->tx_queue
)) {
179 /* Make sure disconnect is not pending anymore */
180 clear_bit(0, &self
->disconnect_pend
); /* FALSE */
182 /* Note : self->disconnect_skb may be NULL */
183 irttp_disconnect_request(self
, self
->disconnect_skb
,
185 self
->disconnect_skb
= NULL
;
187 /* Try again later */
188 irttp_start_todo_timer(self
, HZ
/10);
190 /* No reason to try and close now */
195 /* Check if it's closing time */
196 if (self
->close_pend
)
198 irttp_close_tsap(self
);
202 * Function irttp_flush_queues (self)
204 * Flushes (removes all frames) in transitt-buffer (tx_list)
206 static void irttp_flush_queues(struct tsap_cb
*self
)
210 IRDA_ASSERT(self
!= NULL
, return;);
211 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
213 /* Deallocate frames waiting to be sent */
214 while ((skb
= skb_dequeue(&self
->tx_queue
)) != NULL
)
217 /* Deallocate received frames */
218 while ((skb
= skb_dequeue(&self
->rx_queue
)) != NULL
)
221 /* Deallocate received fragments */
222 while ((skb
= skb_dequeue(&self
->rx_fragments
)) != NULL
)
227 * Function irttp_reassemble (self)
229 * Makes a new (continuous) skb of all the fragments in the fragment
233 static struct sk_buff
*irttp_reassemble_skb(struct tsap_cb
*self
)
235 struct sk_buff
*skb
, *frag
;
236 int n
= 0; /* Fragment index */
238 IRDA_ASSERT(self
!= NULL
, return NULL
;);
239 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return NULL
;);
241 pr_debug("%s(), self->rx_sdu_size=%d\n", __func__
,
244 skb
= dev_alloc_skb(TTP_HEADER
+ self
->rx_sdu_size
);
249 * Need to reserve space for TTP header in case this skb needs to
250 * be requeued in case delivery failes
252 skb_reserve(skb
, TTP_HEADER
);
253 skb_put(skb
, self
->rx_sdu_size
);
256 * Copy all fragments to a new buffer
258 while ((frag
= skb_dequeue(&self
->rx_fragments
)) != NULL
) {
259 skb_copy_to_linear_data_offset(skb
, n
, frag
->data
, frag
->len
);
265 pr_debug("%s(), frame len=%d, rx_sdu_size=%d, rx_max_sdu_size=%d\n",
266 __func__
, n
, self
->rx_sdu_size
, self
->rx_max_sdu_size
);
267 /* Note : irttp_run_rx_queue() calculate self->rx_sdu_size
268 * by summing the size of all fragments, so we should always
269 * have n == self->rx_sdu_size, except in cases where we
270 * droped the last fragment (when self->rx_sdu_size exceed
271 * self->rx_max_sdu_size), where n < self->rx_sdu_size.
273 IRDA_ASSERT(n
<= self
->rx_sdu_size
, n
= self
->rx_sdu_size
;);
275 /* Set the new length */
278 self
->rx_sdu_size
= 0;
284 * Function irttp_fragment_skb (skb)
286 * Fragments a frame and queues all the fragments for transmission
289 static inline void irttp_fragment_skb(struct tsap_cb
*self
,
292 struct sk_buff
*frag
;
295 IRDA_ASSERT(self
!= NULL
, return;);
296 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
297 IRDA_ASSERT(skb
!= NULL
, return;);
300 * Split frame into a number of segments
302 while (skb
->len
> self
->max_seg_size
) {
303 pr_debug("%s(), fragmenting ...\n", __func__
);
305 /* Make new segment */
306 frag
= alloc_skb(self
->max_seg_size
+self
->max_header_size
,
311 skb_reserve(frag
, self
->max_header_size
);
313 /* Copy data from the original skb into this fragment. */
314 skb_copy_from_linear_data(skb
, skb_put(frag
, self
->max_seg_size
),
317 /* Insert TTP header, with the more bit set */
318 frame
= skb_push(frag
, TTP_HEADER
);
321 /* Hide the copied data from the original skb */
322 skb_pull(skb
, self
->max_seg_size
);
325 skb_queue_tail(&self
->tx_queue
, frag
);
327 /* Queue what is left of the original skb */
328 pr_debug("%s(), queuing last segment\n", __func__
);
330 frame
= skb_push(skb
, TTP_HEADER
);
331 frame
[0] = 0x00; /* Clear more bit */
334 skb_queue_tail(&self
->tx_queue
, skb
);
338 * Function irttp_param_max_sdu_size (self, param)
340 * Handle the MaxSduSize parameter in the connect frames, this function
341 * will be called both when this parameter needs to be inserted into, and
342 * extracted from the connect frames
344 static int irttp_param_max_sdu_size(void *instance
, irda_param_t
*param
,
347 struct tsap_cb
*self
;
351 IRDA_ASSERT(self
!= NULL
, return -1;);
352 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return -1;);
355 param
->pv
.i
= self
->tx_max_sdu_size
;
357 self
->tx_max_sdu_size
= param
->pv
.i
;
359 pr_debug("%s(), MaxSduSize=%d\n", __func__
, param
->pv
.i
);
364 /*************************** CLIENT CALLS ***************************/
365 /************************** LMP CALLBACKS **************************/
366 /* Everything is happily mixed up. Waiting for next clean up - Jean II */
369 * Initialization, that has to be done on new tsap
370 * instance allocation and on duplication
372 static void irttp_init_tsap(struct tsap_cb
*tsap
)
374 spin_lock_init(&tsap
->lock
);
375 init_timer(&tsap
->todo_timer
);
377 skb_queue_head_init(&tsap
->rx_queue
);
378 skb_queue_head_init(&tsap
->tx_queue
);
379 skb_queue_head_init(&tsap
->rx_fragments
);
383 * Function irttp_open_tsap (stsap, notify)
385 * Create TSAP connection endpoint,
387 struct tsap_cb
*irttp_open_tsap(__u8 stsap_sel
, int credit
, notify_t
*notify
)
389 struct tsap_cb
*self
;
390 struct lsap_cb
*lsap
;
393 IRDA_ASSERT(irttp
->magic
== TTP_MAGIC
, return NULL
;);
395 /* The IrLMP spec (IrLMP 1.1 p10) says that we have the right to
396 * use only 0x01-0x6F. Of course, we can use LSAP_ANY as well.
398 if ((stsap_sel
!= LSAP_ANY
) &&
399 ((stsap_sel
< 0x01) || (stsap_sel
>= 0x70))) {
400 pr_debug("%s(), invalid tsap!\n", __func__
);
404 self
= kzalloc(sizeof(struct tsap_cb
), GFP_ATOMIC
);
408 /* Initialize internal objects */
409 irttp_init_tsap(self
);
411 /* Initialise todo timer */
412 self
->todo_timer
.data
= (unsigned long) self
;
413 self
->todo_timer
.function
= &irttp_todo_expired
;
415 /* Initialize callbacks for IrLMP to use */
416 irda_notify_init(&ttp_notify
);
417 ttp_notify
.connect_confirm
= irttp_connect_confirm
;
418 ttp_notify
.connect_indication
= irttp_connect_indication
;
419 ttp_notify
.disconnect_indication
= irttp_disconnect_indication
;
420 ttp_notify
.data_indication
= irttp_data_indication
;
421 ttp_notify
.udata_indication
= irttp_udata_indication
;
422 ttp_notify
.flow_indication
= irttp_flow_indication
;
423 if (notify
->status_indication
!= NULL
)
424 ttp_notify
.status_indication
= irttp_status_indication
;
425 ttp_notify
.instance
= self
;
426 strncpy(ttp_notify
.name
, notify
->name
, NOTIFY_MAX_NAME
);
428 self
->magic
= TTP_TSAP_MAGIC
;
429 self
->connected
= FALSE
;
432 * Create LSAP at IrLMP layer
434 lsap
= irlmp_open_lsap(stsap_sel
, &ttp_notify
, 0);
436 pr_debug("%s: unable to allocate LSAP!!\n", __func__
);
437 __irttp_close_tsap(self
);
442 * If user specified LSAP_ANY as source TSAP selector, then IrLMP
443 * will replace it with whatever source selector which is free, so
444 * the stsap_sel we have might not be valid anymore
446 self
->stsap_sel
= lsap
->slsap_sel
;
447 pr_debug("%s(), stsap_sel=%02x\n", __func__
, self
->stsap_sel
);
449 self
->notify
= *notify
;
452 hashbin_insert(irttp
->tsaps
, (irda_queue_t
*) self
, (long) self
, NULL
);
454 if (credit
> TTP_RX_MAX_CREDIT
)
455 self
->initial_credit
= TTP_RX_MAX_CREDIT
;
457 self
->initial_credit
= credit
;
461 EXPORT_SYMBOL(irttp_open_tsap
);
464 * Function irttp_close (handle)
466 * Remove an instance of a TSAP. This function should only deal with the
467 * deallocation of the TSAP, and resetting of the TSAPs values;
470 static void __irttp_close_tsap(struct tsap_cb
*self
)
472 /* First make sure we're connected. */
473 IRDA_ASSERT(self
!= NULL
, return;);
474 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
476 irttp_flush_queues(self
);
478 del_timer(&self
->todo_timer
);
480 /* This one won't be cleaned up if we are disconnect_pend + close_pend
481 * and we receive a disconnect_indication */
482 if (self
->disconnect_skb
)
483 dev_kfree_skb(self
->disconnect_skb
);
485 self
->connected
= FALSE
;
486 self
->magic
= ~TTP_TSAP_MAGIC
;
492 * Function irttp_close (self)
494 * Remove TSAP from list of all TSAPs and then deallocate all resources
495 * associated with this TSAP
497 * Note : because we *free* the tsap structure, it is the responsibility
498 * of the caller to make sure we are called only once and to deal with
499 * possible race conditions. - Jean II
501 int irttp_close_tsap(struct tsap_cb
*self
)
503 struct tsap_cb
*tsap
;
505 IRDA_ASSERT(self
!= NULL
, return -1;);
506 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return -1;);
508 /* Make sure tsap has been disconnected */
509 if (self
->connected
) {
510 /* Check if disconnect is not pending */
511 if (!test_bit(0, &self
->disconnect_pend
)) {
512 net_warn_ratelimited("%s: TSAP still connected!\n",
514 irttp_disconnect_request(self
, NULL
, P_NORMAL
);
516 self
->close_pend
= TRUE
;
517 irttp_start_todo_timer(self
, HZ
/10);
519 return 0; /* Will be back! */
522 tsap
= hashbin_remove(irttp
->tsaps
, (long) self
, NULL
);
524 IRDA_ASSERT(tsap
== self
, return -1;);
526 /* Close corresponding LSAP */
528 irlmp_close_lsap(self
->lsap
);
532 __irttp_close_tsap(self
);
536 EXPORT_SYMBOL(irttp_close_tsap
);
539 * Function irttp_udata_request (self, skb)
541 * Send unreliable data on this TSAP
544 int irttp_udata_request(struct tsap_cb
*self
, struct sk_buff
*skb
)
548 IRDA_ASSERT(self
!= NULL
, return -1;);
549 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return -1;);
550 IRDA_ASSERT(skb
!= NULL
, return -1;);
552 /* Take shortcut on zero byte packets */
558 /* Check that nothing bad happens */
559 if (!self
->connected
) {
560 net_warn_ratelimited("%s(), Not connected\n", __func__
);
565 if (skb
->len
> self
->max_seg_size
) {
566 net_err_ratelimited("%s(), UData is too large for IrLAP!\n",
572 irlmp_udata_request(self
->lsap
, skb
);
573 self
->stats
.tx_packets
++;
581 EXPORT_SYMBOL(irttp_udata_request
);
585 * Function irttp_data_request (handle, skb)
587 * Queue frame for transmission. If SAR is enabled, fragement the frame
588 * and queue the fragments for transmission
590 int irttp_data_request(struct tsap_cb
*self
, struct sk_buff
*skb
)
595 IRDA_ASSERT(self
!= NULL
, return -1;);
596 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return -1;);
597 IRDA_ASSERT(skb
!= NULL
, return -1;);
599 pr_debug("%s() : queue len = %d\n", __func__
,
600 skb_queue_len(&self
->tx_queue
));
602 /* Take shortcut on zero byte packets */
608 /* Check that nothing bad happens */
609 if (!self
->connected
) {
610 net_warn_ratelimited("%s: Not connected\n", __func__
);
616 * Check if SAR is disabled, and the frame is larger than what fits
617 * inside an IrLAP frame
619 if ((self
->tx_max_sdu_size
== 0) && (skb
->len
> self
->max_seg_size
)) {
620 net_err_ratelimited("%s: SAR disabled, and data is too large for IrLAP!\n",
627 * Check if SAR is enabled, and the frame is larger than the
630 if ((self
->tx_max_sdu_size
!= 0) &&
631 (self
->tx_max_sdu_size
!= TTP_SAR_UNBOUND
) &&
632 (skb
->len
> self
->tx_max_sdu_size
)) {
633 net_err_ratelimited("%s: SAR enabled, but data is larger than TxMaxSduSize!\n",
639 * Check if transmit queue is full
641 if (skb_queue_len(&self
->tx_queue
) >= TTP_TX_MAX_QUEUE
) {
643 * Give it a chance to empty itself
645 irttp_run_tx_queue(self
);
647 /* Drop packet. This error code should trigger the caller
648 * to resend the data in the client code - Jean II */
653 /* Queue frame, or queue frame segments */
654 if ((self
->tx_max_sdu_size
== 0) || (skb
->len
< self
->max_seg_size
)) {
656 IRDA_ASSERT(skb_headroom(skb
) >= TTP_HEADER
, return -1;);
657 frame
= skb_push(skb
, TTP_HEADER
);
658 frame
[0] = 0x00; /* Clear more bit */
660 skb_queue_tail(&self
->tx_queue
, skb
);
663 * Fragment the frame, this function will also queue the
664 * fragments, we don't care about the fact the transmit
665 * queue may be overfilled by all the segments for a little
668 irttp_fragment_skb(self
, skb
);
671 /* Check if we can accept more data from client */
672 if ((!self
->tx_sdu_busy
) &&
673 (skb_queue_len(&self
->tx_queue
) > TTP_TX_HIGH_THRESHOLD
)) {
674 /* Tx queue filling up, so stop client. */
675 if (self
->notify
.flow_indication
) {
676 self
->notify
.flow_indication(self
->notify
.instance
,
679 /* self->tx_sdu_busy is the state of the client.
680 * Update state after notifying client to avoid
681 * race condition with irttp_flow_indication().
682 * If the queue empty itself after our test but before
683 * we set the flag, we will fix ourselves below in
684 * irttp_run_tx_queue().
686 self
->tx_sdu_busy
= TRUE
;
689 /* Try to make some progress */
690 irttp_run_tx_queue(self
);
698 EXPORT_SYMBOL(irttp_data_request
);
701 * Function irttp_run_tx_queue (self)
703 * Transmit packets queued for transmission (if possible)
706 static void irttp_run_tx_queue(struct tsap_cb
*self
)
712 pr_debug("%s() : send_credit = %d, queue_len = %d\n",
714 self
->send_credit
, skb_queue_len(&self
->tx_queue
));
716 /* Get exclusive access to the tx queue, otherwise don't touch it */
717 if (irda_lock(&self
->tx_queue_lock
) == FALSE
)
720 /* Try to send out frames as long as we have credits
721 * and as long as LAP is not full. If LAP is full, it will
722 * poll us through irttp_flow_indication() - Jean II */
723 while ((self
->send_credit
> 0) &&
724 (!irlmp_lap_tx_queue_full(self
->lsap
)) &&
725 (skb
= skb_dequeue(&self
->tx_queue
))) {
727 * Since we can transmit and receive frames concurrently,
728 * the code below is a critical region and we must assure that
729 * nobody messes with the credits while we update them.
731 spin_lock_irqsave(&self
->lock
, flags
);
733 n
= self
->avail_credit
;
734 self
->avail_credit
= 0;
736 /* Only room for 127 credits in frame */
738 self
->avail_credit
= n
-127;
741 self
->remote_credit
+= n
;
744 spin_unlock_irqrestore(&self
->lock
, flags
);
747 * More bit must be set by the data_request() or fragment()
750 skb
->data
[0] |= (n
& 0x7f);
752 /* Detach from socket.
753 * The current skb has a reference to the socket that sent
754 * it (skb->sk). When we pass it to IrLMP, the skb will be
755 * stored in in IrLAP (self->wx_list). When we are within
756 * IrLAP, we lose the notion of socket, so we should not
757 * have a reference to a socket. So, we drop it here.
759 * Why does it matter ?
760 * When the skb is freed (kfree_skb), if it is associated
761 * with a socket, it release buffer space on the socket
762 * (through sock_wfree() and sock_def_write_space()).
763 * If the socket no longer exist, we may crash. Hard.
764 * When we close a socket, we make sure that associated packets
765 * in IrTTP are freed. However, we have no way to cancel
766 * the packet that we have passed to IrLAP. So, if a packet
767 * remains in IrLAP (retry on the link or else) after we
768 * close the socket, we are dead !
770 if (skb
->sk
!= NULL
) {
771 /* IrSOCK application, IrOBEX, ... */
774 /* IrCOMM over IrTTP, IrLAN, ... */
776 /* Pass the skb to IrLMP - done */
777 irlmp_data_request(self
->lsap
, skb
);
778 self
->stats
.tx_packets
++;
781 /* Check if we can accept more frames from client.
782 * We don't want to wait until the todo timer to do that, and we
783 * can't use tasklets (grr...), so we are obliged to give control
784 * to client. That's ok, this test will be true not too often
785 * (max once per LAP window) and we are called from places
786 * where we can spend a bit of time doing stuff. - Jean II */
787 if ((self
->tx_sdu_busy
) &&
788 (skb_queue_len(&self
->tx_queue
) < TTP_TX_LOW_THRESHOLD
) &&
789 (!self
->close_pend
)) {
790 if (self
->notify
.flow_indication
)
791 self
->notify
.flow_indication(self
->notify
.instance
,
794 /* self->tx_sdu_busy is the state of the client.
795 * We don't really have a race here, but it's always safer
796 * to update our state after the client - Jean II */
797 self
->tx_sdu_busy
= FALSE
;
801 self
->tx_queue_lock
= 0;
805 * Function irttp_give_credit (self)
807 * Send a dataless flowdata TTP-PDU and give available credit to peer
810 static inline void irttp_give_credit(struct tsap_cb
*self
)
812 struct sk_buff
*tx_skb
= NULL
;
816 IRDA_ASSERT(self
!= NULL
, return;);
817 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
819 pr_debug("%s() send=%d,avail=%d,remote=%d\n",
821 self
->send_credit
, self
->avail_credit
, self
->remote_credit
);
823 /* Give credit to peer */
824 tx_skb
= alloc_skb(TTP_MAX_HEADER
, GFP_ATOMIC
);
828 /* Reserve space for LMP, and LAP header */
829 skb_reserve(tx_skb
, LMP_MAX_HEADER
);
832 * Since we can transmit and receive frames concurrently,
833 * the code below is a critical region and we must assure that
834 * nobody messes with the credits while we update them.
836 spin_lock_irqsave(&self
->lock
, flags
);
838 n
= self
->avail_credit
;
839 self
->avail_credit
= 0;
841 /* Only space for 127 credits in frame */
843 self
->avail_credit
= n
- 127;
846 self
->remote_credit
+= n
;
848 spin_unlock_irqrestore(&self
->lock
, flags
);
851 tx_skb
->data
[0] = (__u8
) (n
& 0x7f);
853 irlmp_data_request(self
->lsap
, tx_skb
);
854 self
->stats
.tx_packets
++;
858 * Function irttp_udata_indication (instance, sap, skb)
860 * Received some unit-data (unreliable)
863 static int irttp_udata_indication(void *instance
, void *sap
,
866 struct tsap_cb
*self
;
871 IRDA_ASSERT(self
!= NULL
, return -1;);
872 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return -1;);
873 IRDA_ASSERT(skb
!= NULL
, return -1;);
875 self
->stats
.rx_packets
++;
877 /* Just pass data to layer above */
878 if (self
->notify
.udata_indication
) {
879 err
= self
->notify
.udata_indication(self
->notify
.instance
,
881 /* Same comment as in irttp_do_data_indication() */
885 /* Either no handler, or handler returns an error */
892 * Function irttp_data_indication (instance, sap, skb)
894 * Receive segment from IrLMP.
897 static int irttp_data_indication(void *instance
, void *sap
,
900 struct tsap_cb
*self
;
906 n
= skb
->data
[0] & 0x7f; /* Extract the credits */
908 self
->stats
.rx_packets
++;
910 /* Deal with inbound credit
911 * Since we can transmit and receive frames concurrently,
912 * the code below is a critical region and we must assure that
913 * nobody messes with the credits while we update them.
915 spin_lock_irqsave(&self
->lock
, flags
);
916 self
->send_credit
+= n
;
918 self
->remote_credit
--;
919 spin_unlock_irqrestore(&self
->lock
, flags
);
922 * Data or dataless packet? Dataless frames contains only the
927 * We don't remove the TTP header, since we must preserve the
928 * more bit, so the defragment routing knows what to do
930 skb_queue_tail(&self
->rx_queue
, skb
);
932 /* Dataless flowdata TTP-PDU */
937 /* Push data to the higher layer.
938 * We do it synchronously because running the todo timer for each
939 * receive packet would be too much overhead and latency.
940 * By passing control to the higher layer, we run the risk that
941 * it may take time or grab a lock. Most often, the higher layer
942 * will only put packet in a queue.
943 * Anyway, packets are only dripping through the IrDA, so we can
944 * have time before the next packet.
945 * Further, we are run from NET_BH, so the worse that can happen is
946 * us missing the optimal time to send back the PF bit in LAP.
948 irttp_run_rx_queue(self
);
950 /* We now give credits to peer in irttp_run_rx_queue().
951 * We need to send credit *NOW*, otherwise we are going
952 * to miss the next Tx window. The todo timer may take
953 * a while before it's run... - Jean II */
956 * If the peer device has given us some credits and we didn't have
957 * anyone from before, then we need to shedule the tx queue.
958 * We need to do that because our Tx have stopped (so we may not
959 * get any LAP flow indication) and the user may be stopped as
962 if (self
->send_credit
== n
) {
963 /* Restart pushing stuff to LAP */
964 irttp_run_tx_queue(self
);
965 /* Note : we don't want to schedule the todo timer
966 * because it has horrible latency. No tasklets
967 * because the tasklet API is broken. - Jean II */
974 * Function irttp_status_indication (self, reason)
976 * Status_indication, just pass to the higher layer...
979 static void irttp_status_indication(void *instance
,
980 LINK_STATUS link
, LOCK_STATUS lock
)
982 struct tsap_cb
*self
;
986 IRDA_ASSERT(self
!= NULL
, return;);
987 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
989 /* Check if client has already closed the TSAP and gone away */
990 if (self
->close_pend
)
994 * Inform service user if he has requested it
996 if (self
->notify
.status_indication
!= NULL
)
997 self
->notify
.status_indication(self
->notify
.instance
,
1000 pr_debug("%s(), no handler\n", __func__
);
1004 * Function irttp_flow_indication (self, reason)
1006 * Flow_indication : IrLAP tells us to send more data.
1009 static void irttp_flow_indication(void *instance
, void *sap
, LOCAL_FLOW flow
)
1011 struct tsap_cb
*self
;
1015 IRDA_ASSERT(self
!= NULL
, return;);
1016 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
1018 pr_debug("%s(instance=%p)\n", __func__
, self
);
1020 /* We are "polled" directly from LAP, and the LAP want to fill
1021 * its Tx window. We want to do our best to send it data, so that
1022 * we maximise the window. On the other hand, we want to limit the
1023 * amount of work here so that LAP doesn't hang forever waiting
1024 * for packets. - Jean II */
1026 /* Try to send some packets. Currently, LAP calls us every time
1027 * there is one free slot, so we will send only one packet.
1028 * This allow the scheduler to do its round robin - Jean II */
1029 irttp_run_tx_queue(self
);
1031 /* Note regarding the interraction with higher layer.
1032 * irttp_run_tx_queue() may call the client when its queue
1033 * start to empty, via notify.flow_indication(). Initially.
1034 * I wanted this to happen in a tasklet, to avoid client
1035 * grabbing the CPU, but we can't use tasklets safely. And timer
1036 * is definitely too slow.
1037 * This will happen only once per LAP window, and usually at
1038 * the third packet (unless window is smaller). LAP is still
1039 * doing mtt and sending first packet so it's sort of OK
1040 * to do that. Jean II */
1042 /* If we need to send disconnect. try to do it now */
1043 if (self
->disconnect_pend
)
1044 irttp_start_todo_timer(self
, 0);
1048 * Function irttp_flow_request (self, command)
1050 * This function could be used by the upper layers to tell IrTTP to stop
1051 * delivering frames if the receive queues are starting to get full, or
1052 * to tell IrTTP to start delivering frames again.
1054 void irttp_flow_request(struct tsap_cb
*self
, LOCAL_FLOW flow
)
1056 IRDA_ASSERT(self
!= NULL
, return;);
1057 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
1061 pr_debug("%s(), flow stop\n", __func__
);
1062 self
->rx_sdu_busy
= TRUE
;
1065 pr_debug("%s(), flow start\n", __func__
);
1066 self
->rx_sdu_busy
= FALSE
;
1068 /* Client say he can accept more data, try to free our
1069 * queues ASAP - Jean II */
1070 irttp_run_rx_queue(self
);
1074 pr_debug("%s(), Unknown flow command!\n", __func__
);
1077 EXPORT_SYMBOL(irttp_flow_request
);
1080 * Function irttp_connect_request (self, dtsap_sel, daddr, qos)
1082 * Try to connect to remote destination TSAP selector
1085 int irttp_connect_request(struct tsap_cb
*self
, __u8 dtsap_sel
,
1086 __u32 saddr
, __u32 daddr
,
1087 struct qos_info
*qos
, __u32 max_sdu_size
,
1088 struct sk_buff
*userdata
)
1090 struct sk_buff
*tx_skb
;
1094 pr_debug("%s(), max_sdu_size=%d\n", __func__
, max_sdu_size
);
1096 IRDA_ASSERT(self
!= NULL
, return -EBADR
;);
1097 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return -EBADR
;);
1099 if (self
->connected
) {
1101 dev_kfree_skb(userdata
);
1105 /* Any userdata supplied? */
1106 if (userdata
== NULL
) {
1107 tx_skb
= alloc_skb(TTP_MAX_HEADER
+ TTP_SAR_HEADER
,
1112 /* Reserve space for MUX_CONTROL and LAP header */
1113 skb_reserve(tx_skb
, TTP_MAX_HEADER
+ TTP_SAR_HEADER
);
1117 * Check that the client has reserved enough space for
1120 IRDA_ASSERT(skb_headroom(userdata
) >= TTP_MAX_HEADER
,
1121 { dev_kfree_skb(userdata
); return -1; });
1124 /* Initialize connection parameters */
1125 self
->connected
= FALSE
;
1126 self
->avail_credit
= 0;
1127 self
->rx_max_sdu_size
= max_sdu_size
;
1128 self
->rx_sdu_size
= 0;
1129 self
->rx_sdu_busy
= FALSE
;
1130 self
->dtsap_sel
= dtsap_sel
;
1132 n
= self
->initial_credit
;
1134 self
->remote_credit
= 0;
1135 self
->send_credit
= 0;
1138 * Give away max 127 credits for now
1141 self
->avail_credit
= n
- 127;
1145 self
->remote_credit
= n
;
1148 if (max_sdu_size
> 0) {
1149 IRDA_ASSERT(skb_headroom(tx_skb
) >= (TTP_MAX_HEADER
+ TTP_SAR_HEADER
),
1150 { dev_kfree_skb(tx_skb
); return -1; });
1152 /* Insert SAR parameters */
1153 frame
= skb_push(tx_skb
, TTP_HEADER
+ TTP_SAR_HEADER
);
1155 frame
[0] = TTP_PARAMETERS
| n
;
1156 frame
[1] = 0x04; /* Length */
1157 frame
[2] = 0x01; /* MaxSduSize */
1158 frame
[3] = 0x02; /* Value length */
1160 put_unaligned(cpu_to_be16((__u16
) max_sdu_size
),
1161 (__be16
*)(frame
+4));
1163 /* Insert plain TTP header */
1164 frame
= skb_push(tx_skb
, TTP_HEADER
);
1166 /* Insert initial credit in frame */
1167 frame
[0] = n
& 0x7f;
1170 /* Connect with IrLMP. No QoS parameters for now */
1171 return irlmp_connect_request(self
->lsap
, dtsap_sel
, saddr
, daddr
, qos
,
1174 EXPORT_SYMBOL(irttp_connect_request
);
1177 * Function irttp_connect_confirm (handle, qos, skb)
1179 * Service user confirms TSAP connection with peer.
1182 static void irttp_connect_confirm(void *instance
, void *sap
,
1183 struct qos_info
*qos
, __u32 max_seg_size
,
1184 __u8 max_header_size
, struct sk_buff
*skb
)
1186 struct tsap_cb
*self
;
1194 IRDA_ASSERT(self
!= NULL
, return;);
1195 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
1196 IRDA_ASSERT(skb
!= NULL
, return;);
1198 self
->max_seg_size
= max_seg_size
- TTP_HEADER
;
1199 self
->max_header_size
= max_header_size
+ TTP_HEADER
;
1202 * Check if we have got some QoS parameters back! This should be the
1203 * negotiated QoS for the link.
1206 pr_debug("IrTTP, Negotiated BAUD_RATE: %02x\n",
1207 qos
->baud_rate
.bits
);
1208 pr_debug("IrTTP, Negotiated BAUD_RATE: %d bps.\n",
1209 qos
->baud_rate
.value
);
1212 n
= skb
->data
[0] & 0x7f;
1214 pr_debug("%s(), Initial send_credit=%d\n", __func__
, n
);
1216 self
->send_credit
= n
;
1217 self
->tx_max_sdu_size
= 0;
1218 self
->connected
= TRUE
;
1220 parameters
= skb
->data
[0] & 0x80;
1222 IRDA_ASSERT(skb
->len
>= TTP_HEADER
, return;);
1223 skb_pull(skb
, TTP_HEADER
);
1226 plen
= skb
->data
[0];
1228 ret
= irda_param_extract_all(self
, skb
->data
+1,
1229 IRDA_MIN(skb
->len
-1, plen
),
1232 /* Any errors in the parameter list? */
1234 net_warn_ratelimited("%s: error extracting parameters\n",
1238 /* Do not accept this connection attempt */
1241 /* Remove parameters */
1242 skb_pull(skb
, IRDA_MIN(skb
->len
, plen
+1));
1245 pr_debug("%s() send=%d,avail=%d,remote=%d\n", __func__
,
1246 self
->send_credit
, self
->avail_credit
, self
->remote_credit
);
1248 pr_debug("%s(), MaxSduSize=%d\n", __func__
,
1249 self
->tx_max_sdu_size
);
1251 if (self
->notify
.connect_confirm
) {
1252 self
->notify
.connect_confirm(self
->notify
.instance
, self
, qos
,
1253 self
->tx_max_sdu_size
,
1254 self
->max_header_size
, skb
);
1260 * Function irttp_connect_indication (handle, skb)
1262 * Some other device is connecting to this TSAP
1265 static void irttp_connect_indication(void *instance
, void *sap
,
1266 struct qos_info
*qos
, __u32 max_seg_size
, __u8 max_header_size
,
1267 struct sk_buff
*skb
)
1269 struct tsap_cb
*self
;
1270 struct lsap_cb
*lsap
;
1278 IRDA_ASSERT(self
!= NULL
, return;);
1279 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
1280 IRDA_ASSERT(skb
!= NULL
, return;);
1284 self
->max_seg_size
= max_seg_size
- TTP_HEADER
;
1285 self
->max_header_size
= max_header_size
+TTP_HEADER
;
1287 pr_debug("%s(), TSAP sel=%02x\n", __func__
, self
->stsap_sel
);
1289 /* Need to update dtsap_sel if its equal to LSAP_ANY */
1290 self
->dtsap_sel
= lsap
->dlsap_sel
;
1292 n
= skb
->data
[0] & 0x7f;
1294 self
->send_credit
= n
;
1295 self
->tx_max_sdu_size
= 0;
1297 parameters
= skb
->data
[0] & 0x80;
1299 IRDA_ASSERT(skb
->len
>= TTP_HEADER
, return;);
1300 skb_pull(skb
, TTP_HEADER
);
1303 plen
= skb
->data
[0];
1305 ret
= irda_param_extract_all(self
, skb
->data
+1,
1306 IRDA_MIN(skb
->len
-1, plen
),
1309 /* Any errors in the parameter list? */
1311 net_warn_ratelimited("%s: error extracting parameters\n",
1315 /* Do not accept this connection attempt */
1319 /* Remove parameters */
1320 skb_pull(skb
, IRDA_MIN(skb
->len
, plen
+1));
1323 if (self
->notify
.connect_indication
) {
1324 self
->notify
.connect_indication(self
->notify
.instance
, self
,
1325 qos
, self
->tx_max_sdu_size
,
1326 self
->max_header_size
, skb
);
1332 * Function irttp_connect_response (handle, userdata)
1334 * Service user is accepting the connection, just pass it down to
1338 int irttp_connect_response(struct tsap_cb
*self
, __u32 max_sdu_size
,
1339 struct sk_buff
*userdata
)
1341 struct sk_buff
*tx_skb
;
1346 IRDA_ASSERT(self
!= NULL
, return -1;);
1347 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return -1;);
1349 pr_debug("%s(), Source TSAP selector=%02x\n", __func__
,
1352 /* Any userdata supplied? */
1353 if (userdata
== NULL
) {
1354 tx_skb
= alloc_skb(TTP_MAX_HEADER
+ TTP_SAR_HEADER
,
1359 /* Reserve space for MUX_CONTROL and LAP header */
1360 skb_reserve(tx_skb
, TTP_MAX_HEADER
+ TTP_SAR_HEADER
);
1364 * Check that the client has reserved enough space for
1367 IRDA_ASSERT(skb_headroom(userdata
) >= TTP_MAX_HEADER
,
1368 { dev_kfree_skb(userdata
); return -1; });
1371 self
->avail_credit
= 0;
1372 self
->remote_credit
= 0;
1373 self
->rx_max_sdu_size
= max_sdu_size
;
1374 self
->rx_sdu_size
= 0;
1375 self
->rx_sdu_busy
= FALSE
;
1377 n
= self
->initial_credit
;
1379 /* Frame has only space for max 127 credits (7 bits) */
1381 self
->avail_credit
= n
- 127;
1385 self
->remote_credit
= n
;
1386 self
->connected
= TRUE
;
1389 if (max_sdu_size
> 0) {
1390 IRDA_ASSERT(skb_headroom(tx_skb
) >= (TTP_MAX_HEADER
+ TTP_SAR_HEADER
),
1391 { dev_kfree_skb(tx_skb
); return -1; });
1393 /* Insert TTP header with SAR parameters */
1394 frame
= skb_push(tx_skb
, TTP_HEADER
+ TTP_SAR_HEADER
);
1396 frame
[0] = TTP_PARAMETERS
| n
;
1397 frame
[1] = 0x04; /* Length */
1399 /* irda_param_insert(self, IRTTP_MAX_SDU_SIZE, frame+1, */
1400 /* TTP_SAR_HEADER, ¶m_info) */
1402 frame
[2] = 0x01; /* MaxSduSize */
1403 frame
[3] = 0x02; /* Value length */
1405 put_unaligned(cpu_to_be16((__u16
) max_sdu_size
),
1406 (__be16
*)(frame
+4));
1408 /* Insert TTP header */
1409 frame
= skb_push(tx_skb
, TTP_HEADER
);
1411 frame
[0] = n
& 0x7f;
1414 ret
= irlmp_connect_response(self
->lsap
, tx_skb
);
1418 EXPORT_SYMBOL(irttp_connect_response
);
1421 * Function irttp_dup (self, instance)
1423 * Duplicate TSAP, can be used by servers to confirm a connection on a
1424 * new TSAP so it can keep listening on the old one.
1426 struct tsap_cb
*irttp_dup(struct tsap_cb
*orig
, void *instance
)
1428 struct tsap_cb
*new;
1429 unsigned long flags
;
1431 /* Protect our access to the old tsap instance */
1432 spin_lock_irqsave(&irttp
->tsaps
->hb_spinlock
, flags
);
1434 /* Find the old instance */
1435 if (!hashbin_find(irttp
->tsaps
, (long) orig
, NULL
)) {
1436 pr_debug("%s(), unable to find TSAP\n", __func__
);
1437 spin_unlock_irqrestore(&irttp
->tsaps
->hb_spinlock
, flags
);
1441 /* Allocate a new instance */
1442 new = kmemdup(orig
, sizeof(struct tsap_cb
), GFP_ATOMIC
);
1444 pr_debug("%s(), unable to kmalloc\n", __func__
);
1445 spin_unlock_irqrestore(&irttp
->tsaps
->hb_spinlock
, flags
);
1448 spin_lock_init(&new->lock
);
1450 /* We don't need the old instance any more */
1451 spin_unlock_irqrestore(&irttp
->tsaps
->hb_spinlock
, flags
);
1453 /* Try to dup the LSAP (may fail if we were too slow) */
1454 new->lsap
= irlmp_dup(orig
->lsap
, new);
1456 pr_debug("%s(), dup failed!\n", __func__
);
1461 /* Not everything should be copied */
1462 new->notify
.instance
= instance
;
1464 /* Initialize internal objects */
1465 irttp_init_tsap(new);
1467 /* This is locked */
1468 hashbin_insert(irttp
->tsaps
, (irda_queue_t
*) new, (long) new, NULL
);
1472 EXPORT_SYMBOL(irttp_dup
);
1475 * Function irttp_disconnect_request (self)
1477 * Close this connection please! If priority is high, the queued data
1478 * segments, if any, will be deallocated first
1481 int irttp_disconnect_request(struct tsap_cb
*self
, struct sk_buff
*userdata
,
1486 IRDA_ASSERT(self
!= NULL
, return -1;);
1487 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return -1;);
1489 /* Already disconnected? */
1490 if (!self
->connected
) {
1491 pr_debug("%s(), already disconnected!\n", __func__
);
1493 dev_kfree_skb(userdata
);
1497 /* Disconnect already pending ?
1498 * We need to use an atomic operation to prevent reentry. This
1499 * function may be called from various context, like user, timer
1500 * for following a disconnect_indication() (i.e. net_bh).
1502 if (test_and_set_bit(0, &self
->disconnect_pend
)) {
1503 pr_debug("%s(), disconnect already pending\n",
1506 dev_kfree_skb(userdata
);
1508 /* Try to make some progress */
1509 irttp_run_tx_queue(self
);
1514 * Check if there is still data segments in the transmit queue
1516 if (!skb_queue_empty(&self
->tx_queue
)) {
1517 if (priority
== P_HIGH
) {
1519 * No need to send the queued data, if we are
1520 * disconnecting right now since the data will
1521 * not have any usable connection to be sent on
1523 pr_debug("%s(): High priority!!()\n", __func__
);
1524 irttp_flush_queues(self
);
1525 } else if (priority
== P_NORMAL
) {
1527 * Must delay disconnect until after all data segments
1528 * have been sent and the tx_queue is empty
1530 /* We'll reuse this one later for the disconnect */
1531 self
->disconnect_skb
= userdata
; /* May be NULL */
1533 irttp_run_tx_queue(self
);
1535 irttp_start_todo_timer(self
, HZ
/10);
1539 /* Note : we don't need to check if self->rx_queue is full and the
1540 * state of self->rx_sdu_busy because the disconnect response will
1541 * be sent at the LMP level (so even if the peer has its Tx queue
1542 * full of data). - Jean II */
1544 pr_debug("%s(), Disconnecting ...\n", __func__
);
1545 self
->connected
= FALSE
;
1548 struct sk_buff
*tx_skb
;
1549 tx_skb
= alloc_skb(LMP_MAX_HEADER
, GFP_ATOMIC
);
1554 * Reserve space for MUX and LAP header
1556 skb_reserve(tx_skb
, LMP_MAX_HEADER
);
1560 ret
= irlmp_disconnect_request(self
->lsap
, userdata
);
1562 /* The disconnect is no longer pending */
1563 clear_bit(0, &self
->disconnect_pend
); /* FALSE */
1567 EXPORT_SYMBOL(irttp_disconnect_request
);
1570 * Function irttp_disconnect_indication (self, reason)
1572 * Disconnect indication, TSAP disconnected by peer?
1575 static void irttp_disconnect_indication(void *instance
, void *sap
,
1576 LM_REASON reason
, struct sk_buff
*skb
)
1578 struct tsap_cb
*self
;
1582 IRDA_ASSERT(self
!= NULL
, return;);
1583 IRDA_ASSERT(self
->magic
== TTP_TSAP_MAGIC
, return;);
1585 /* Prevent higher layer to send more data */
1586 self
->connected
= FALSE
;
1588 /* Check if client has already tried to close the TSAP */
1589 if (self
->close_pend
) {
1590 /* In this case, the higher layer is probably gone. Don't
1591 * bother it and clean up the remains - Jean II */
1594 irttp_close_tsap(self
);
1598 /* If we are here, we assume that is the higher layer is still
1599 * waiting for the disconnect notification and able to process it,
1600 * even if he tried to disconnect. Otherwise, it would have already
1601 * attempted to close the tsap and self->close_pend would be TRUE.
1604 /* No need to notify the client if has already tried to disconnect */
1605 if (self
->notify
.disconnect_indication
)
1606 self
->notify
.disconnect_indication(self
->notify
.instance
, self
,
1614 * Function irttp_do_data_indication (self, skb)
1616 * Try to deliver reassembled skb to layer above, and requeue it if that
1617 * for some reason should fail. We mark rx sdu as busy to apply back
1618 * pressure is necessary.
1620 static void irttp_do_data_indication(struct tsap_cb
*self
, struct sk_buff
*skb
)
1624 /* Check if client has already closed the TSAP and gone away */
1625 if (self
->close_pend
) {
1630 err
= self
->notify
.data_indication(self
->notify
.instance
, self
, skb
);
1632 /* Usually the layer above will notify that it's input queue is
1633 * starting to get filled by using the flow request, but this may
1634 * be difficult, so it can instead just refuse to eat it and just
1635 * give an error back
1638 pr_debug("%s() requeueing skb!\n", __func__
);
1640 /* Make sure we take a break */
1641 self
->rx_sdu_busy
= TRUE
;
1643 /* Need to push the header in again */
1644 skb_push(skb
, TTP_HEADER
);
1645 skb
->data
[0] = 0x00; /* Make sure MORE bit is cleared */
1647 /* Put skb back on queue */
1648 skb_queue_head(&self
->rx_queue
, skb
);
1653 * Function irttp_run_rx_queue (self)
1655 * Check if we have any frames to be transmitted, or if we have any
1656 * available credit to give away.
1658 static void irttp_run_rx_queue(struct tsap_cb
*self
)
1660 struct sk_buff
*skb
;
1663 pr_debug("%s() send=%d,avail=%d,remote=%d\n", __func__
,
1664 self
->send_credit
, self
->avail_credit
, self
->remote_credit
);
1666 /* Get exclusive access to the rx queue, otherwise don't touch it */
1667 if (irda_lock(&self
->rx_queue_lock
) == FALSE
)
1671 * Reassemble all frames in receive queue and deliver them
1673 while (!self
->rx_sdu_busy
&& (skb
= skb_dequeue(&self
->rx_queue
))) {
1674 /* This bit will tell us if it's the last fragment or not */
1675 more
= skb
->data
[0] & 0x80;
1677 /* Remove TTP header */
1678 skb_pull(skb
, TTP_HEADER
);
1680 /* Add the length of the remaining data */
1681 self
->rx_sdu_size
+= skb
->len
;
1684 * If SAR is disabled, or user has requested no reassembly
1685 * of received fragments then we just deliver them
1686 * immediately. This can be requested by clients that
1687 * implements byte streams without any message boundaries
1689 if (self
->rx_max_sdu_size
== TTP_SAR_DISABLE
) {
1690 irttp_do_data_indication(self
, skb
);
1691 self
->rx_sdu_size
= 0;
1696 /* Check if this is a fragment, and not the last fragment */
1699 * Queue the fragment if we still are within the
1700 * limits of the maximum size of the rx_sdu
1702 if (self
->rx_sdu_size
<= self
->rx_max_sdu_size
) {
1703 pr_debug("%s(), queueing frag\n",
1705 skb_queue_tail(&self
->rx_fragments
, skb
);
1707 /* Free the part of the SDU that is too big */
1713 * This is the last fragment, so time to reassemble!
1715 if ((self
->rx_sdu_size
<= self
->rx_max_sdu_size
) ||
1716 (self
->rx_max_sdu_size
== TTP_SAR_UNBOUND
)) {
1718 * A little optimizing. Only queue the fragment if
1719 * there are other fragments. Since if this is the
1720 * last and only fragment, there is no need to
1723 if (!skb_queue_empty(&self
->rx_fragments
)) {
1724 skb_queue_tail(&self
->rx_fragments
,
1727 skb
= irttp_reassemble_skb(self
);
1730 /* Now we can deliver the reassembled skb */
1731 irttp_do_data_indication(self
, skb
);
1733 pr_debug("%s(), Truncated frame\n", __func__
);
1735 /* Free the part of the SDU that is too big */
1738 /* Deliver only the valid but truncated part of SDU */
1739 skb
= irttp_reassemble_skb(self
);
1741 irttp_do_data_indication(self
, skb
);
1743 self
->rx_sdu_size
= 0;
1747 * It's not trivial to keep track of how many credits are available
1748 * by incrementing at each packet, because delivery may fail
1749 * (irttp_do_data_indication() may requeue the frame) and because
1750 * we need to take care of fragmentation.
1751 * We want the other side to send up to initial_credit packets.
1752 * We have some frames in our queues, and we have already allowed it
1753 * to send remote_credit.
1754 * No need to spinlock, write is atomic and self correcting...
1757 self
->avail_credit
= (self
->initial_credit
-
1758 (self
->remote_credit
+
1759 skb_queue_len(&self
->rx_queue
) +
1760 skb_queue_len(&self
->rx_fragments
)));
1762 /* Do we have too much credits to send to peer ? */
1763 if ((self
->remote_credit
<= TTP_RX_MIN_CREDIT
) &&
1764 (self
->avail_credit
> 0)) {
1765 /* Send explicit credit frame */
1766 irttp_give_credit(self
);
1767 /* Note : do *NOT* check if tx_queue is non-empty, that
1768 * will produce deadlocks. I repeat : send a credit frame
1769 * even if we have something to send in our Tx queue.
1770 * If we have credits, it means that our Tx queue is blocked.
1772 * Let's suppose the peer can't keep up with our Tx. He will
1773 * flow control us by not sending us any credits, and we
1774 * will stop Tx and start accumulating credits here.
1775 * Up to the point where the peer will stop its Tx queue,
1776 * for lack of credits.
1777 * Let's assume the peer application is single threaded.
1778 * It will block on Tx and never consume any Rx buffer.
1779 * Deadlock. Guaranteed. - Jean II
1784 self
->rx_queue_lock
= 0;
1787 #ifdef CONFIG_PROC_FS
1788 struct irttp_iter_state
{
1792 static void *irttp_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1794 struct irttp_iter_state
*iter
= seq
->private;
1795 struct tsap_cb
*self
;
1797 /* Protect our access to the tsap list */
1798 spin_lock_irq(&irttp
->tsaps
->hb_spinlock
);
1801 for (self
= (struct tsap_cb
*) hashbin_get_first(irttp
->tsaps
);
1803 self
= (struct tsap_cb
*) hashbin_get_next(irttp
->tsaps
)) {
1804 if (iter
->id
== *pos
)
1812 static void *irttp_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1814 struct irttp_iter_state
*iter
= seq
->private;
1818 return (void *) hashbin_get_next(irttp
->tsaps
);
1821 static void irttp_seq_stop(struct seq_file
*seq
, void *v
)
1823 spin_unlock_irq(&irttp
->tsaps
->hb_spinlock
);
1826 static int irttp_seq_show(struct seq_file
*seq
, void *v
)
1828 const struct irttp_iter_state
*iter
= seq
->private;
1829 const struct tsap_cb
*self
= v
;
1831 seq_printf(seq
, "TSAP %d, ", iter
->id
);
1832 seq_printf(seq
, "stsap_sel: %02x, ",
1834 seq_printf(seq
, "dtsap_sel: %02x\n",
1836 seq_printf(seq
, " connected: %s, ",
1837 self
->connected
? "TRUE" : "FALSE");
1838 seq_printf(seq
, "avail credit: %d, ",
1839 self
->avail_credit
);
1840 seq_printf(seq
, "remote credit: %d, ",
1841 self
->remote_credit
);
1842 seq_printf(seq
, "send credit: %d\n",
1844 seq_printf(seq
, " tx packets: %lu, ",
1845 self
->stats
.tx_packets
);
1846 seq_printf(seq
, "rx packets: %lu, ",
1847 self
->stats
.rx_packets
);
1848 seq_printf(seq
, "tx_queue len: %u ",
1849 skb_queue_len(&self
->tx_queue
));
1850 seq_printf(seq
, "rx_queue len: %u\n",
1851 skb_queue_len(&self
->rx_queue
));
1852 seq_printf(seq
, " tx_sdu_busy: %s, ",
1853 self
->tx_sdu_busy
? "TRUE" : "FALSE");
1854 seq_printf(seq
, "rx_sdu_busy: %s\n",
1855 self
->rx_sdu_busy
? "TRUE" : "FALSE");
1856 seq_printf(seq
, " max_seg_size: %u, ",
1857 self
->max_seg_size
);
1858 seq_printf(seq
, "tx_max_sdu_size: %u, ",
1859 self
->tx_max_sdu_size
);
1860 seq_printf(seq
, "rx_max_sdu_size: %u\n",
1861 self
->rx_max_sdu_size
);
1863 seq_printf(seq
, " Used by (%s)\n\n",
1868 static const struct seq_operations irttp_seq_ops
= {
1869 .start
= irttp_seq_start
,
1870 .next
= irttp_seq_next
,
1871 .stop
= irttp_seq_stop
,
1872 .show
= irttp_seq_show
,
1875 static int irttp_seq_open(struct inode
*inode
, struct file
*file
)
1877 return seq_open_private(file
, &irttp_seq_ops
,
1878 sizeof(struct irttp_iter_state
));
1881 const struct file_operations irttp_seq_fops
= {
1882 .owner
= THIS_MODULE
,
1883 .open
= irttp_seq_open
,
1885 .llseek
= seq_lseek
,
1886 .release
= seq_release_private
,
1889 #endif /* PROC_FS */