patch-2.1.132 linux/net/irda/irlap.c
Next file: linux/net/irda/irlap_comp.c
Previous file: linux/net/irda/irlan/irlan_srv_event.c
Back to the patch index
Back to the overall index
- Lines: 1185
- Date:
Thu Dec 17 09:01:03 1998
- Orig file:
v2.1.131/linux/net/irda/irlap.c
- Orig date:
Wed Dec 31 16:00:00 1969
diff -u --recursive --new-file v2.1.131/linux/net/irda/irlap.c linux/net/irda/irlap.c
@@ -0,0 +1,1184 @@
+/*********************************************************************
+ *
+ * Filename: irlap.c
+ * Version: 0.3
+ * Description: An IrDA LAP driver for Linux
+ * Status: Experimental.
+ * Author: Dag Brattli <dagb@cs.uit.no>
+ * Created at: Mon Aug 4 20:40:53 1997
+ * Modified at: Mon Dec 14 11:54:42 1998
+ * Modified by: Dag Brattli <dagb@cs.uit.no>
+ *
+ * Copyright (c) 1998 Dag Brattli <dagb@cs.uit.no>,
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute iyt and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * Neither Dag Brattli nor University of Tromsų admit liability nor
+ * provide warranty for any of this software. This material is
+ * provided "AS-IS" and at no charge.
+ *
+ ********************************************************************/
+
+#include <linux/config.h>
+#include <linux/malloc.h>
+#include <linux/string.h>
+#include <linux/skbuff.h>
+#include <linux/delay.h>
+#include <linux/proc_fs.h>
+#include <linux/init.h>
+
+#include <net/irda/irda.h>
+#include <net/irda/irda_device.h>
+#include <net/irda/irqueue.h>
+#include <net/irda/irlmp.h>
+#include <net/irda/irlmp_frame.h>
+#include <net/irda/irlap_frame.h>
+#include <net/irda/irlap.h>
+#include <net/irda/timer.h>
+#include <net/irda/qos.h>
+#include <net/irda/irlap_comp.h>
+
+hashbin_t *irlap = NULL;
+
+static void __irlap_close( struct irlap_cb *self);
+
+#ifdef CONFIG_PROC_FS
+int irlap_proc_read( char *buf, char **start, off_t offset, int len,
+ int unused);
+
+#endif /* CONFIG_PROC_FS */
+
+__initfunc(int irlap_init( void))
+{
+ /* Allocate master array */
+ irlap = hashbin_new( HB_LOCAL);
+ if ( irlap == NULL) {
+ printk( KERN_WARNING "IrLAP: Can't allocate irlap hashbin!\n");
+ return -ENOMEM;
+ }
+
+#ifdef CONFIG_IRDA_COMPRESSION
+ irlap_compressors = hashbin_new( HB_LOCAL);
+ if ( irlap_compressors == NULL) {
+ printk( KERN_WARNING "IrLAP: Can't allocate compressors hashbin!\n");
+ return -ENOMEM;
+ }
+#endif
+
+ return 0;
+}
+
+void irlap_cleanup(void)
+{
+ ASSERT( irlap != NULL, return;);
+
+ hashbin_delete( irlap, (FREE_FUNC) __irlap_close);
+
+#ifdef CONFIG_IRDA_COMPRESSION
+ hashbin_delete( irlap_compressors, (FREE_FUNC) kfree);
+#endif
+}
+
+/*
+ * Function irlap_open (driver)
+ *
+ * Initialize IrLAP layer
+ *
+ */
+struct irlap_cb *irlap_open( struct irda_device *irdev)
+{
+ struct irlap_cb *self;
+
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( irdev != NULL, return NULL;);
+ ASSERT( irdev->magic == IRDA_DEVICE_MAGIC, return NULL;);
+
+ /* Initialize the irlap structure. */
+ self = kmalloc( sizeof( struct irlap_cb), GFP_KERNEL);
+ if ( self == NULL)
+ return NULL;
+
+ memset( self, 0, sizeof(struct irlap_cb));
+ self->magic = LAP_MAGIC;
+
+ /* Make a binding between the layers */
+ self->irdev = irdev;
+ self->netdev = &irdev->netdev;
+
+ irlap_next_state( self, LAP_OFFLINE);
+
+ /* Initialize transmitt queue */
+ skb_queue_head_init( &self->tx_list);
+ skb_queue_head_init( &self->wx_list);
+
+ /* My unique IrLAP device address! :-) */
+ self->saddr = jiffies;
+
+ /* Generate random connection address for this session */
+ self->caddr = jiffies & 0xfe;
+
+ init_timer( &self->slot_timer);
+ init_timer( &self->query_timer);
+ init_timer( &self->discovery_timer);
+ init_timer( &self->final_timer);
+ init_timer( &self->poll_timer);
+ init_timer( &self->wd_timer);
+ init_timer( &self->backoff_timer);
+
+ irlap_apply_default_connection_parameters( self);
+
+ irlap_next_state( self, LAP_NDM);
+
+ hashbin_insert( irlap, (QUEUE *) self, self->saddr, NULL);
+
+ irlmp_register_irlap( self, self->saddr, &self->notify);
+
+ DEBUG( 4, "irlap_open -->\n");
+
+ return self;
+}
+
+/*
+ * Function __irlap_close (self)
+ *
+ * Remove IrLAP and all allocated memory. Stop any pending timers.
+ *
+ */
+static void __irlap_close( struct irlap_cb *self)
+{
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ /* Stop timers */
+ del_timer( &self->slot_timer);
+ del_timer( &self->query_timer);
+ del_timer( &self->discovery_timer);
+ del_timer( &self->final_timer);
+ del_timer( &self->poll_timer);
+ del_timer( &self->wd_timer);
+ del_timer( &self->backoff_timer);
+
+ irlap_flush_all_queues( self);
+
+ self->irdev = NULL;
+ self->magic = ~LAP_MAGIC;
+
+ kfree( self);
+}
+
+/*
+ * Function irlap_close ()
+ *
+ *
+ *
+ */
+void irlap_close( struct irlap_cb *self)
+{
+ struct irlap_cb *lap;
+
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ irlap_disconnect_indication( self, LAP_DISC_INDICATION);
+
+ irlmp_unregister_irlap( self->saddr);
+ self->notify.instance = NULL;
+
+ /* Be sure that we manage to remove ourself from the hash */
+ lap = hashbin_remove( irlap, self->saddr, NULL);
+ if ( !lap) {
+ DEBUG( 0, __FUNCTION__ "(), Didn't find myself!\n");
+ return;
+ }
+ __irlap_close( lap);
+}
+
+/*
+ * Function irlap_connect_indication ()
+ *
+ * Another device is attempting to make a connection
+ *
+ */
+void irlap_connect_indication( struct irlap_cb *self, struct sk_buff *skb)
+{
+ DEBUG( 4, "irlap_connect_indication()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ irlap_init_qos_capabilities( self, NULL); /* No user QoS! */
+
+ irlmp_link_connect_indication( self->notify.instance, &self->qos_tx,
+ skb);
+}
+
+/*
+ * Function irlap_connect_response (void)
+ *
+ * Service user has accepted incomming connection
+ *
+ */
+void irlap_connect_response( struct irlap_cb *self, struct sk_buff *skb)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ irlap_do_event( self, CONNECT_RESPONSE, skb, NULL);
+}
+
+/*
+ * Function irlap_connect_request (daddr, qos, sniff)
+ *
+ * Request connection with another device, sniffing is not implemented
+ * yet.
+ */
+void irlap_connect_request( struct irlap_cb *self, __u32 daddr,
+ struct qos_info *qos_user, int sniff)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ self->daddr = daddr;
+
+ /*
+ * If the service user specifies QoS values for this connection,
+ * then use them
+ */
+ irlap_init_qos_capabilities( self, qos_user);
+
+ if ( self->state == LAP_NDM) {
+ irlap_do_event( self, CONNECT_REQUEST, NULL, NULL);
+ } else {
+ DEBUG( 0, "irlap_connect_request() Wrong state!\n");
+
+ irlap_disconnect_indication( self, LAP_MEDIA_BUSY);
+ }
+
+}
+
+/*
+ * Function irlap_connect_confirm (void)
+ *
+ * Connection request is accepted
+ *
+ */
+void irlap_connect_confirm( struct irlap_cb *self, struct sk_buff *skb)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ irlmp_link_connect_confirm( self->notify.instance, &self->qos_tx, skb);
+}
+
+/*
+ * Function irlap_data_indication (skb)
+ *
+ * Received data frames from IR-port, so we just pass them up to
+ * IrLMP for further processing
+ *
+ */
+inline void irlap_data_indication( struct irlap_cb *self, struct sk_buff *skb)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+ ASSERT( skb != NULL, return;);
+
+ IS_SKB( skb, return;);
+
+ /* Hide LAP header from IrLMP layer */
+ skb_pull( skb, LAP_ADDR_HEADER+LAP_CTRL_HEADER);
+
+#ifdef CONFIG_IRDA_COMPRESSION
+ if ( self->qos_tx.compression.value) {
+ skb = irlap_decompress_frame( self, skb);
+ if ( !skb) {
+ DEBUG( 0, __FUNCTION__ "(), Decompress error!\n");
+ return;
+ }
+ }
+#endif
+
+ irlmp_link_data_indication( self->notify.instance, LAP_RELIABLE, skb);
+}
+
+/*
+ * Function irlap_unit_data_indication (self, skb)
+ *
+ * Received some data that was sent unreliable
+ *
+ */
+void irlap_unit_data_indication( struct irlap_cb *self, struct sk_buff *skb)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+ ASSERT( skb != NULL, return;);
+
+ IS_SKB( skb, return;);
+
+ /* Hide LAP header from IrLMP layer */
+ skb_pull( skb, LAP_ADDR_HEADER+LAP_CTRL_HEADER);
+
+#ifdef CONFIG_IRDA_COMPRESSION
+ if ( self->qos_tx.compression.value) {
+
+ skb = irlap_decompress_frame( self, skb);
+ if ( !skb) {
+ DEBUG( 0, __FUNCTION__ "(), Decompress error!\n");
+ return;
+ }
+ }
+#endif
+
+ irlmp_link_data_indication( self->notify.instance, LAP_UNRELIABLE,
+ skb);
+}
+
+/*
+ * Function irlap_data_request (self, skb)
+ *
+ * Queue data for transmission, must wait until XMIT state
+ *
+ */
+inline void irlap_data_request( struct irlap_cb *self, struct sk_buff *skb,
+ int reliable)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+ ASSERT( skb != NULL, return;);
+
+ IS_SKB( skb, return;);
+
+ DEBUG( 4, "irlap_data_request: tx_list=%d\n",
+ skb_queue_len( &self->tx_list));
+
+#ifdef CONFIG_IRDA_COMPRESSION
+ if ( self->qos_tx.compression.value) {
+ skb = irlap_compress_frame( self, skb);
+ if ( !skb) {
+ DEBUG( 0, __FUNCTION__ "(), Compress error!\n");
+ return;
+ }
+ }
+#endif
+
+ ASSERT( skb_headroom( skb) >= (LAP_ADDR_HEADER+LAP_CTRL_HEADER),
+ return;);
+ skb_push( skb, LAP_ADDR_HEADER+LAP_CTRL_HEADER);
+
+ /*
+ * Must set frame format now so that the rest of the code knows
+ * if its dealing with an I or an UI frame
+ */
+ if ( reliable)
+ skb->data[1] = I_FRAME;
+ else {
+ DEBUG( 4, __FUNCTION__ "(), queueing unreliable frame\n");
+ skb->data[1] = UI_FRAME;
+ }
+
+ IS_SKB( skb, return;);
+
+ /*
+ * Send event if this frame only if we are in the right state
+ * FIXME: udata should be sent first! (skb_queue_head?)
+ */
+ if (( self->state == LAP_XMIT_P) || (self->state == LAP_XMIT_S)) {
+ /*
+ * Check if the transmit queue contains some unsent frames,
+ * and if so, make sure they are sent first
+ */
+ if ( !skb_queue_empty( &self->tx_list)) {
+ skb_queue_tail( &self->tx_list, skb);
+ skb = skb_dequeue( &self->tx_list);
+
+ ASSERT( skb != NULL, return;);
+ IS_SKB( skb, return;);
+ }
+ irlap_do_event( self, SEND_I_CMD, skb, NULL);
+ } else
+ skb_queue_tail( &self->tx_list, skb);
+
+}
+
+/*
+ * Function irlap_disconnect_request (void)
+ *
+ * Request to disconnect connection by service user
+ */
+void irlap_disconnect_request( struct irlap_cb *self)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ irlap_do_event( self, DISCONNECT_REQUEST, NULL, NULL);
+}
+
+/*
+ * Function irlap_disconnect_indication (void)
+ *
+ * Disconnect request from other device
+ *
+ */
+void irlap_disconnect_indication( struct irlap_cb *self, LAP_REASON reason)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+#ifdef CONFIG_IRDA_COMPRESSION
+ irda_free_compression( self);
+#endif
+
+ /* Flush queues */
+ irlap_flush_all_queues( self);
+
+ switch( reason) {
+ case LAP_RESET_INDICATION:
+ DEBUG( 0, "Sending reset request!\n");
+ irlap_do_event( self, RESET_REQUEST, NULL, NULL);
+ break;
+ case LAP_NO_RESPONSE:
+ case LAP_DISC_INDICATION:
+ case LAP_FOUND_NONE:
+ case LAP_MEDIA_BUSY:
+ irlmp_link_disconnect_indication( self->notify.instance,
+ self, reason, NULL);
+ break;
+ default:
+ DEBUG( 0, __FUNCTION__ "(), Reason %d not implemented!\n",
+ reason);
+ }
+}
+
+/*
+ * Function irlap_discovery_request (gen_addr_bit)
+ *
+ * Start one single discovery operation.
+ *
+ */
+void irlap_discovery_request( struct irlap_cb *self, DISCOVERY *discovery)
+{
+ struct irlap_info info;
+
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+ ASSERT( discovery != NULL, return;);
+
+ /*
+ * Discovery is only possible in NDM mode
+ */
+ if ( self->state == LAP_NDM) {
+ ASSERT( self->discovery_log == NULL, return;);
+ self->discovery_log= hashbin_new( HB_LOCAL);
+
+ info.S = 6; /* Number of slots */
+ info.s = 0; /* Current slot */
+
+ self->discovery_cmd = discovery;
+ info.discovery = discovery;
+
+ irlap_do_event( self, DISCOVERY_REQUEST, NULL, &info);
+ } else {
+ DEBUG( 4, __FUNCTION__
+ "(), discovery only possible in NDM mode\n");
+ irlap_discovery_confirm( self, NULL);
+ }
+}
+
+
+/*
+ * Function irlap_discovery_confirm (log)
+ *
+ * A device has been discovered in front of this station, we
+ * report directly to LMP.
+ */
+void irlap_discovery_confirm( struct irlap_cb *self,
+ hashbin_t *discovery_log)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ ASSERT( self->notify.instance != NULL, return;);
+
+ /* Inform IrLMP */
+ irlmp_link_discovery_confirm( self->notify.instance, discovery_log);
+
+ /*
+ * IrLMP has now the responsibilities for the discovery_log
+ */
+ self->discovery_log = NULL;
+}
+
+/*
+ * Function irlap_discovery_indication (log)
+ *
+ * Somebody is trying to discover us!
+ *
+ */
+inline void irlap_discovery_indication( struct irlap_cb *self,
+ DISCOVERY *discovery)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+ ASSERT( discovery != NULL, return;);
+
+ ASSERT( self->notify.instance != NULL, return;);
+
+ irlmp_discovery_indication( self->notify.instance, discovery);
+}
+
+/*
+ * Function irlap_status_indication (quality_of_link)
+ *
+ *
+ *
+ */
+void irlap_status_indication( int quality_of_link)
+{
+ switch( quality_of_link) {
+ case STATUS_NO_ACTIVITY:
+ printk( KERN_INFO "IrLAP, no activity on link!\n");
+ break;
+ case STATUS_NOISY:
+ printk( KERN_INFO "IrLAP, noisy link!\n");
+ break;
+ default:
+ break;
+ }
+ /* TODO: layering violation! */
+ irlmp_status_indication( quality_of_link, NO_CHANGE);
+}
+
+/*
+ * Function irlap_reset_indication (void)
+ *
+ *
+ *
+ */
+void irlap_reset_indication( struct irlap_cb *self)
+{
+ DEBUG( 0, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ irlap_do_event( self, RESET_REQUEST, NULL, NULL);
+}
+
+/*
+ * Function irlap_reset_confirm (void)
+ *
+ *
+ *
+ */
+void irlap_reset_confirm(void)
+{
+ DEBUG( 0, __FUNCTION__ "() Not implemented!\n");
+}
+
+/*
+ * Function irlap_generate_rand_time_slot (S, s)
+ *
+ * Generate a random time slot between s and S-1 where
+ * S = Number of slots (0 -> S-1)
+ * s = Current slot
+ */
+int irlap_generate_rand_time_slot( int S, int s)
+{
+ int slot;
+
+ ASSERT(( S - s) > 0, return 0;);
+
+ slot = s + jiffies % (S-s);
+
+ DEBUG( 4, "S=%d, s=%d, rnd=%d\n", S, s, slot);
+
+ ASSERT(( slot >= s) || ( slot < S), return 0;);
+
+ return slot;
+}
+
+/*
+ * Function irlap_update_nr_received (nr)
+ *
+ * Remove all acknowledged frames in current window queue. This code is
+ * not intuitive and you should not try to change it. If you think it
+ * contains bugs, please mail a patch to the author instead.
+ */
+void irlap_update_nr_received( struct irlap_cb *self, int nr)
+{
+ struct sk_buff *skb = NULL;
+ int count = 0;
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ /*
+ * Remove all the ack-ed frames from the window queue.
+ */
+
+ DEBUG( 4, "--> wx_list=%d, va=%d, nr=%d\n",
+ skb_queue_len( &self->wx_list), self->va, nr);
+
+ /*
+ * Optimize for the common case. It is most likely that the receiver
+ * will acknowledge all the frames we have sent! So in that case we
+ * delete all frames stored in window.
+ */
+ if ( nr == self->vs) {
+ while (( skb = skb_dequeue( &self->wx_list)) != NULL) {
+ dev_kfree_skb(skb);
+ }
+ /* The last acked frame is the next to send minus one */
+ self->va = nr - 1;
+ } else {
+ /* Remove all acknowledged frames in current window */
+ while (( skb_peek( &self->wx_list) != NULL) &&
+ ((( self->va+1) % 8) != nr))
+ {
+ skb = skb_dequeue( &self->wx_list);
+ dev_kfree_skb(skb);
+
+ self->va = (self->va + 1) % 8;
+ count++;
+ }
+
+ DEBUG( 4, "irlap_update_nr_received(), removed %d\n", count);
+ DEBUG( 4, "wx_list=%d, va=%d, nr=%d -->\n",
+ skb_queue_len( &self->wx_list), self->va, nr);
+ }
+
+ /* Advance window */
+ self->window = self->window_size - skb_queue_len( &self->wx_list);
+}
+
+/*
+ * Function irlap_validate_ns_received (ns)
+ *
+ * Validate the next to send (ns) field from received frame.
+ */
+int irlap_validate_ns_received( struct irlap_cb *self, int ns)
+{
+ ASSERT( self != NULL, return -ENODEV;);
+ ASSERT( self->magic == LAP_MAGIC, return -EBADR;);
+
+ /*
+ * ns as expected?
+ */
+ if ( ns == self->vr) {
+ DEBUG( 4, "*** irlap_validate_ns_received: expected!\n");
+ return NS_EXPECTED;
+ }
+ /*
+ * Stations are allowed to treat invalid NS as unexpected NS
+ * IrLAP, Recv ... with-invalid-Ns. p. 84
+ */
+ return NS_UNEXPECTED;
+
+ /* return NR_INVALID; */
+}
+/*
+ * Function irlap_validate_nr_received (nr)
+ *
+ * Validate the next to receive (nr) field from received frame.
+ *
+ */
+int irlap_validate_nr_received( struct irlap_cb *self, int nr)
+{
+ ASSERT( self != NULL, return -ENODEV;);
+ ASSERT( self->magic == LAP_MAGIC, return -EBADR;);
+
+ /*
+ * nr as expected?
+ */
+ if ( nr == self->vs) {
+ DEBUG( 4, "*** irlap_validate_nr_received: expected!\n");
+ return NR_EXPECTED;
+ }
+
+ /*
+ * unexpected nr? (but within current window), first we check if the
+ * ns numbers of the frames in the current window wrap.
+ */
+ if ( self->va < self->vs) {
+ if (( nr >= self->va) && ( nr <= self->vs)) {
+ DEBUG( 4, "*** irlap_validate_nr_received:"
+ " unexpected nr, no wrap\n");
+ return NR_UNEXPECTED;
+ }
+ } else {
+ if (( nr >= self->va) || ( nr <= self->vs)) {
+ DEBUG( 4, "*** irlap_validate_nr_received:"
+ " unexpected nr, wrapped\n");
+ return NR_UNEXPECTED;
+ }
+ }
+
+ /* Invalid nr! */
+ DEBUG( 4, "irlap_validate_nr_received: invalid nr!, "
+ " vs=%d, vr=%d, va=%d, nr=%d\n",
+ self->vs, self->vr, self->va, nr);
+
+ return NR_INVALID;
+}
+
+/*
+ * Function irlap_initiate_connection_state ()
+ *
+ * Initialize the connection state parameters
+ *
+ */
+void irlap_initiate_connection_state( struct irlap_cb *self)
+{
+ DEBUG( 4, "irlap_initiate_connection_state()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ /*
+ * Next to send and next to receive
+ */
+ self->vs = self->vr = 0;
+
+ /* Last frame which got acked (0 - 1) % 8 */
+ self->va = 7;
+
+ self->window = 1;
+
+ self->remote_busy = FALSE;
+ self->retry_count = 0;
+}
+
+/*
+ * Function irlap_wait_min_turn_around (self, qos)
+ *
+ * Wait negotiated minimum turn around time, this function actually sets
+ * the number of BOS's that must be sent before the next transmitted
+ * frame in order to delay for the specified amount of time. This is
+ * done to avoid using timers, and the forbidden udelay!
+ */
+void irlap_wait_min_turn_around( struct irlap_cb *self, struct qos_info *qos)
+{
+ int usecs;
+ int speed;
+ int bytes = 0;
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+ ASSERT( qos != NULL, return;);
+
+ /*
+ * Get QoS values.
+ */
+ speed = qos->baud_rate.value;
+ usecs = qos->min_turn_time.value;
+
+ /* No need to calculate XBOFs for speeds over 115200 bps */
+ if ( speed > 115200) {
+ self->mtt_required = usecs;
+ return;
+ }
+
+ DEBUG( 4, __FUNCTION__ "(), delay=%d usecs\n", usecs);
+
+ /*
+ * Send additional BOF's for the next frame for the requested
+ * min turn time, so now we must calculate how many chars (XBOF's) we
+ * must send for the requested time period (min turn time)
+ */
+ bytes = speed * usecs / 10000000;
+
+ DEBUG( 4, __FUNCTION__ "(), xbofs delay = %d\n", bytes);
+
+ self->xbofs_delay = bytes;
+}
+
+/*
+ * Function irlap_flush_all_queues (void)
+ *
+ * Flush all queues
+ *
+ */
+void irlap_flush_all_queues( struct irlap_cb *self)
+{
+ struct sk_buff* skb;
+
+ DEBUG( 4, "irlap_flush_all_queues()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ /*
+ * Free transmission queue
+ */
+ while (( skb = skb_dequeue( &self->tx_list)) != NULL) {
+ dev_kfree_skb( skb);
+ }
+
+ /*
+ * Free sliding window buffered packets
+ */
+ while (( skb = skb_dequeue( &self->wx_list)) != NULL) {
+ dev_kfree_skb( skb);
+ }
+}
+
+/*
+ * Function irlap_setspeed (self, speed)
+ *
+ * Change the speed of the IrDA port
+ *
+ */
+void irlap_change_speed( struct irlap_cb *self, int speed)
+{
+ DEBUG( 4, __FUNCTION__ "(), setting speed to %d\n", speed);
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ if ( !self->irdev) {
+ DEBUG( 0, __FUNCTION__ "(), driver missing!\n");
+ return;
+ }
+
+ irda_device_change_speed( self->irdev, speed);
+
+ self->qos_rx.baud_rate.value = speed;
+ self->qos_tx.baud_rate.value = speed;
+}
+
+#ifdef CONFIG_IRDA_COMPRESSION
+void irlap_init_comp_qos_capabilities( struct irlap_cb *self)
+{
+ struct irda_compressor *comp;
+ __u8 mask; /* Current bit tested */
+ int i;
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ /*
+ * Find out which compressors we support. We do this be checking that
+ * the corresponding compressor for each bit set in the QoS bits has
+ * actually been loaded. Ths is sort of hairy code but that is what
+ * you get when you do a little bit flicking :-)
+ */
+ DEBUG( 4, __FUNCTION__ "(), comp bits 0x%02x\n",
+ self->qos_rx.compression.bits);
+ mask = 0x80; /* Start with testing MSB */
+ for ( i=0;i<8;i++) {
+ DEBUG( 4, __FUNCTION__ "(), testing bit %d\n", 8-i);
+ if ( self->qos_rx.compression.bits & mask) {
+ DEBUG( 4, __FUNCTION__ "(), bit %d is set by defalt\n",
+ 8-i);
+ comp = hashbin_find( irlap_compressors,
+ compression[ msb_index(mask)],
+ NULL);
+ if ( !comp) {
+ /* Protocol not supported, so clear the bit */
+ DEBUG( 4, __FUNCTION__ "(), Compression "
+ "protocol %d has not been loaded!\n",
+ compression[msb_index(mask)]);
+ self->qos_rx.compression.bits &= ~mask;
+ DEBUG( 4, __FUNCTION__
+ "(), comp bits 0x%02x\n",
+ self->qos_rx.compression.bits);
+ }
+ }
+ /* Try the next bit */
+ mask >>= 1;
+ }
+}
+#endif
+
+/*
+ * Function irlap_init_qos_capabilities (self, qos)
+ *
+ * Initialize QoS for this IrLAP session, What we do is to compute the
+ * intersection of the QoS capabilities for the user, driver and for
+ * IrLAP itself. Normally, IrLAP will not specify any values, but it can
+ * be used to restrict certain values.
+ */
+void irlap_init_qos_capabilities( struct irlap_cb *self,
+ struct qos_info *qos_user)
+{
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+ ASSERT( self->irdev != NULL, return;);
+
+ /* Start out with the maximum QoS support possible */
+ irda_init_max_qos_capabilies( &self->qos_rx);
+
+#ifdef CONFIG_IRDA_COMPRESSION
+ irlap_init_comp_qos_capabilities( self);
+#endif
+
+ /* Apply drivers QoS capabilities */
+ irda_qos_compute_intersection( &self->qos_rx,
+ irda_device_get_qos( self->irdev));
+
+ /*
+ * Check for user supplied QoS parameters. The service user is only
+ * allowed to supply these values. We check each parameter since the
+ * user may not have set all of them.
+ */
+ if ( qos_user != NULL) {
+ DEBUG( 0, __FUNCTION__ "(), Found user specified QoS!\n");
+
+ if ( qos_user->baud_rate.bits)
+ self->qos_rx.baud_rate.bits &= qos_user->baud_rate.bits;
+
+ if ( qos_user->max_turn_time.bits)
+ self->qos_rx.max_turn_time.bits &= qos_user->max_turn_time.bits;
+ if ( qos_user->data_size.bits)
+ self->qos_rx.data_size.bits &= qos_user->data_size.bits;
+
+ if ( qos_user->link_disc_time.bits)
+ self->qos_rx.link_disc_time.bits &= qos_user->link_disc_time.bits;
+#ifdef CONFIG_IRDA_COMPRESSION
+ self->qos_rx.compression.bits &= qos_user->compression.bits;
+#endif
+ }
+
+ /*
+ * Make the intersection between IrLAP and drivers QoS
+ * capabilities
+ */
+
+ /* Use 500ms in IrLAP for now */
+ self->qos_rx.max_turn_time.bits &= 0x03;
+
+ /* Set data size */
+ /* self->qos_rx.data_size.bits &= 0x03; */
+
+ irda_qos_bits_to_value( &self->qos_rx);
+}
+
+/*
+ * Function irlap_apply_default_connection_parameters (void)
+ *
+ * Use the default connection and transmission parameters
+ *
+ */
+void irlap_apply_default_connection_parameters( struct irlap_cb *self)
+{
+ DEBUG( 4, "irlap_apply_default_connection_parameters()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ irlap_change_speed( self, 9600);
+
+ /* Default value in NDM */
+ self->bofs_count = 11;
+
+ /* Use these until connection has been made */
+ self->final_timeout = FINAL_TIMEOUT;
+ self->poll_timeout = POLL_TIMEOUT;
+ self->wd_timeout = WD_TIMEOUT;
+
+ self->qos_tx.data_size.value = 64;
+ self->qos_tx.additional_bofs.value = 11;
+
+ irlap_flush_all_queues( self);
+}
+
+/*
+ * Function irlap_apply_connection_parameters (qos)
+ *
+ * Initialize IrLAP with the negotiated QoS values
+ *
+ */
+void irlap_apply_connection_parameters( struct irlap_cb *self,
+ struct qos_info *qos)
+{
+ DEBUG( 4, __FUNCTION__ "()\n");
+
+ ASSERT( self != NULL, return;);
+ ASSERT( self->magic == LAP_MAGIC, return;);
+
+ irlap_change_speed( self, qos->baud_rate.value);
+
+ self->window_size = qos->window_size.value;
+ self->window = qos->window_size.value;
+ self->bofs_count = qos->additional_bofs.value;
+
+ /*
+ * Calculate how many bytes it is possible to transmit before the
+ * link must be turned around wb = baud * mtt/1000 * 1/2
+ */
+ self->window_bytes = qos->baud_rate.value
+ * qos->max_turn_time.value / 10000;
+ DEBUG( 4, "Setting window_bytes = %d\n", self->window_bytes);
+
+ /*
+ * Set N1 to 0 if Link Disconnect/Threshold Time = 3 and set it to
+ * 3 seconds otherwise. See page 71 in IrLAP for more details.
+ * TODO: these values should be calculated from the final timer
+ * as well
+ */
+ if ( qos->link_disc_time.value == 3)
+ self->N1 = 0;
+ else
+ /* self->N1 = 6; */
+ self->N1 = 3000 / qos->max_turn_time.value;
+
+ DEBUG( 4, "Setting N1 = %d\n", self->N1);
+
+ /* self->N2 = qos->link_disc_time.value * 2; */
+ self->N2 = qos->link_disc_time.value * 1000 / qos->max_turn_time.value;
+ DEBUG( 4, "Setting N2 = %d\n", self->N2);
+
+ /*
+ * Initialize timeout values, some of the rules are listed on
+ * page 92 in IrLAP. Divide by 10 since the kernel timers has a
+ * resolution of 10 ms.
+ */
+ self->poll_timeout = qos->max_turn_time.value / 10;
+ self->final_timeout = qos->max_turn_time.value / 10;
+ self->wd_timeout = self->poll_timeout * 2;
+
+ DEBUG( 4, __FUNCTION__ "(), Setting poll timeout = %d\n",
+ self->poll_timeout);
+ DEBUG( 4, __FUNCTION__ "(), Setting final timeout = %d\n",
+ self->final_timeout);
+ DEBUG( 4, __FUNCTION__ "(), Setting wd timeout = %d\n",
+ self->wd_timeout);
+
+#ifdef CONFIG_IRDA_COMPRESSION
+ if ( qos->compression.value) {
+ DEBUG( 0, __FUNCTION__ "(), Initializing compression\n");
+ irda_set_compression( self, qos->compression.value);
+
+ irlap_compressor_init( self, 0);
+ }
+#endif
+}
+
+#ifdef CONFIG_PROC_FS
+/*
+ * Function irlap_proc_read (buf, start, offset, len, unused)
+ *
+ * Give some info to the /proc file system
+ *
+ */
+int irlap_proc_read( char *buf, char **start, off_t offset, int len,
+ int unused)
+{
+ struct irlap_cb *self;
+ unsigned long flags;
+ int i = 0;
+
+ save_flags(flags);
+ cli();
+
+ len = 0;
+
+ self = (struct irlap_cb *) hashbin_get_first( irlap);
+ while ( self != NULL) {
+ ASSERT( self != NULL, return -ENODEV;);
+ ASSERT( self->magic == LAP_MAGIC, return -EBADR;);
+
+ len += sprintf( buf+len, "IrLAP[%d] <-> %s ",
+ i++, self->irdev->name);
+ len += sprintf( buf+len, "state: %s\n",
+ irlap_state[ self->state]);
+
+ len += sprintf( buf+len, " caddr: %#02x, ", self->caddr);
+ len += sprintf( buf+len, "saddr: %#08x, ", self->saddr);
+ len += sprintf( buf+len, "daddr: %#08x\n", self->daddr);
+
+ len += sprintf( buf+len, " win size: %d, ",
+ self->window_size);
+ len += sprintf( buf+len, "win: %d, ", self->window);
+ len += sprintf( buf+len, "win bytes: %d, ", self->window_bytes);
+ len += sprintf( buf+len, "bytes left: %d\n", self->bytes_left);
+
+ len += sprintf( buf+len, " tx queue len: %d ",
+ skb_queue_len( &self->tx_list));
+ len += sprintf( buf+len, "win queue len: %d ",
+ skb_queue_len( &self->wx_list));
+ len += sprintf( buf+len, "rbusy: %s\n", self->remote_busy ?
+ "TRUE" : "FALSE");
+
+ len += sprintf( buf+len, " retrans: %d ", self->retry_count);
+ len += sprintf( buf+len, "vs: %d ", self->vs);
+ len += sprintf( buf+len, "vr: %d ", self->vr);
+ len += sprintf( buf+len, "va: %d\n", self->va);
+
+ len += sprintf( buf+len, " qos\tbps\tmaxtt\tdsize\twinsize\taddbofs\tmintt\tldisc\tcomp\n");
+
+ len += sprintf( buf+len, " tx\t%d\t",
+ self->qos_tx.baud_rate.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_tx.max_turn_time.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_tx.data_size.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_tx.window_size.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_tx.additional_bofs.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_tx.min_turn_time.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_tx.link_disc_time.value);
+#ifdef CONFIG_IRDA_COMPRESSION
+ len += sprintf( buf+len, "%d",
+ self->qos_tx.compression.value);
+#endif
+ len += sprintf( buf+len, "\n");
+
+ len += sprintf( buf+len, " rx\t%d\t",
+ self->qos_rx.baud_rate.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_rx.max_turn_time.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_rx.data_size.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_rx.window_size.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_rx.additional_bofs.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_rx.min_turn_time.value);
+ len += sprintf( buf+len, "%d\t",
+ self->qos_rx.link_disc_time.value);
+#ifdef CONFIG_IRDA_COMPRESSION
+ len += sprintf( buf+len, "%d",
+ self->qos_rx.compression.value);
+#endif
+ len += sprintf( buf+len, "\n");
+
+ self = (struct irlap_cb *) hashbin_get_next( irlap);
+ }
+ restore_flags(flags);
+
+ return len;
+}
+
+#endif /* CONFIG_PROC_FS */
+
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov