fedora core 6 1.2949 + vserver 2.2.0

[linux-2.6.git] / net / irda / irttp.c

diff --git a/net/irda/irttp.c b/net/irda/irttp.c
index 1a8d3b1..4703107 100644 (file)
--- a/net/irda/irttp.c
+++ b/net/irda/irttp.c
@@ -24,9 +24,9 @@
  *
  ********************************************************************/
 
-#include <linux/config.h>
 #include <linux/skbuff.h>
 #include <linux/init.h>
+#include <linux/fs.h>
 #include <linux/seq_file.h>
 
 #include <asm/byteorder.h>
@@ -38,7 +38,7 @@
 #include <net/irda/parameters.h>
 #include <net/irda/irttp.h>
 
-static struct irttp_cb *irttp = NULL;
+static struct irttp_cb *irttp;
 
 static void __irttp_close_tsap(struct tsap_cb *self);
 
@@ -86,19 +86,17 @@ static pi_param_info_t param_info = { pi_major_call_table, 1, 0x0f, 4 };
  */
 int __init irttp_init(void)
 {
-       /* Initialize the irttp structure. */
-       if (irttp == NULL) {
-               irttp = kmalloc(sizeof(struct irttp_cb), GFP_KERNEL);
-               if (irttp == NULL)
-                       return -ENOMEM;
-       }
-       memset(irttp, 0, sizeof(struct irttp_cb));
+       irttp = kzalloc(sizeof(struct irttp_cb), GFP_KERNEL);
+       if (irttp == NULL)
+               return -ENOMEM;
 
        irttp->magic = TTP_MAGIC;
 
        irttp->tsaps = hashbin_new(HB_LOCK);
        if (!irttp->tsaps) {
-               ERROR("%s: can't allocate IrTTP hashbin!\n", __FUNCTION__);
+               IRDA_ERROR("%s: can't allocate IrTTP hashbin!\n",
+                          __FUNCTION__);
+               kfree(irttp);
                return -ENOMEM;
        }
 
@@ -114,8 +112,7 @@ int __init irttp_init(void)
 void __exit irttp_cleanup(void) 
 {
        /* Check for main structure */
-       ASSERT(irttp != NULL, return;);
-       ASSERT(irttp->magic == TTP_MAGIC, return;);
+       IRDA_ASSERT(irttp->magic == TTP_MAGIC, return;);
 
        /*
         *  Delete hashbin and close all TSAP instances in it
@@ -210,8 +207,8 @@ void irttp_flush_queues(struct tsap_cb *self)
 
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
        /* Deallocate frames waiting to be sent */
        while ((skb = skb_dequeue(&self->tx_queue)) != NULL)
@@ -238,8 +235,8 @@ static struct sk_buff *irttp_reassemble_skb(struct tsap_cb *self)
        struct sk_buff *skb, *frag;
        int n = 0;  /* Fragment index */
 
-       ASSERT(self != NULL, return NULL;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return NULL;);
+       IRDA_ASSERT(self != NULL, return NULL;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return NULL;);
 
        IRDA_DEBUG(2, "%s(), self->rx_sdu_size=%d\n", __FUNCTION__,
                   self->rx_sdu_size);
@@ -274,7 +271,7 @@ static struct sk_buff *irttp_reassemble_skb(struct tsap_cb *self)
         * droped the last fragment (when self->rx_sdu_size exceed
         * self->rx_max_sdu_size), where n < self->rx_sdu_size.
         * Jean II */
-       ASSERT(n <= self->rx_sdu_size, n = self->rx_sdu_size;);
+       IRDA_ASSERT(n <= self->rx_sdu_size, n = self->rx_sdu_size;);
 
        /* Set the new length */
        skb_trim(skb, n);
@@ -298,9 +295,9 @@ static inline void irttp_fragment_skb(struct tsap_cb *self,
 
        IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
-       ASSERT(skb != NULL, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(skb != NULL, return;);
 
        /*
         *  Split frame into a number of segments
@@ -309,7 +306,8 @@ static inline void irttp_fragment_skb(struct tsap_cb *self,
                IRDA_DEBUG(2, "%s(), fragmenting ...\n", __FUNCTION__);
 
                /* Make new segment */
-               frag = dev_alloc_skb(self->max_seg_size+self->max_header_size);
+               frag = alloc_skb(self->max_seg_size+self->max_header_size,
+                                GFP_ATOMIC);
                if (!frag)
                        return;
 
@@ -353,8 +351,8 @@ static int irttp_param_max_sdu_size(void *instance, irda_param_t *param,
 
        self = (struct tsap_cb *) instance;
 
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
 
        if (get)
                param->pv.i = self->tx_max_sdu_size;
@@ -381,8 +379,7 @@ struct tsap_cb *irttp_open_tsap(__u8 stsap_sel, int credit, notify_t *notify)
        struct lsap_cb *lsap;
        notify_t ttp_notify;
 
-       ASSERT(irttp != NULL, return NULL;);
-       ASSERT(irttp->magic == TTP_MAGIC, return NULL;);
+       IRDA_ASSERT(irttp->magic == TTP_MAGIC, return NULL;);
 
        /* The IrLMP spec (IrLMP 1.1 p10) says that we have the right to
         * use only 0x01-0x6F. Of course, we can use LSAP_ANY as well.
@@ -393,12 +390,11 @@ struct tsap_cb *irttp_open_tsap(__u8 stsap_sel, int credit, notify_t *notify)
                return NULL;
        }
 
-       self = kmalloc(sizeof(struct tsap_cb), GFP_ATOMIC);
+       self = kzalloc(sizeof(struct tsap_cb), GFP_ATOMIC);
        if (self == NULL) {
                IRDA_DEBUG(0, "%s(), unable to kmalloc!\n", __FUNCTION__);
                return NULL;
        }
-       memset(self, 0, sizeof(struct tsap_cb));
        spin_lock_init(&self->lock);
 
        /* Initialise todo timer */
@@ -430,7 +426,7 @@ struct tsap_cb *irttp_open_tsap(__u8 stsap_sel, int credit, notify_t *notify)
         */
        lsap = irlmp_open_lsap(stsap_sel, &ttp_notify, 0);
        if (lsap == NULL) {
-               WARNING("%s: unable to allocate LSAP!!\n", __FUNCTION__);
+               IRDA_WARNING("%s: unable to allocate LSAP!!\n", __FUNCTION__);
                return NULL;
        }
 
@@ -466,8 +462,8 @@ EXPORT_SYMBOL(irttp_open_tsap);
 static void __irttp_close_tsap(struct tsap_cb *self)
 {
        /* First make sure we're connected. */
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
        irttp_flush_queues(self);
 
@@ -500,14 +496,15 @@ int irttp_close_tsap(struct tsap_cb *self)
 
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
 
        /* Make sure tsap has been disconnected */
        if (self->connected) {
                /* Check if disconnect is not pending */
                if (!test_bit(0, &self->disconnect_pend)) {
-                       WARNING("%s: TSAP still connected!\n", __FUNCTION__);
+                       IRDA_WARNING("%s: TSAP still connected!\n",
+                                    __FUNCTION__);
                        irttp_disconnect_request(self, NULL, P_NORMAL);
                }
                self->close_pend = TRUE;
@@ -518,7 +515,7 @@ int irttp_close_tsap(struct tsap_cb *self)
 
        tsap = hashbin_remove(irttp->tsaps, (long) self, NULL);
 
-       ASSERT(tsap == self, return -1;);
+       IRDA_ASSERT(tsap == self, return -1;);
 
        /* Close corresponding LSAP */
        if (self->lsap) {
@@ -540,9 +537,9 @@ EXPORT_SYMBOL(irttp_close_tsap);
  */
 int irttp_udata_request(struct tsap_cb *self, struct sk_buff *skb)
 {
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
-       ASSERT(skb != NULL, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
+       IRDA_ASSERT(skb != NULL, return -1;);
 
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
@@ -582,16 +579,16 @@ int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb)
        __u8 *frame;
        int ret;
 
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
-       ASSERT(skb != NULL, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
+       IRDA_ASSERT(skb != NULL, return -1;);
 
        IRDA_DEBUG(2, "%s() : queue len = %d\n", __FUNCTION__,
                   skb_queue_len(&self->tx_queue));
 
        /* Check that nothing bad happens */
        if ((skb->len == 0) || (!self->connected)) {
-               WARNING("%s: No data, or not connected\n", __FUNCTION__);
+               IRDA_WARNING("%s: No data, or not connected\n", __FUNCTION__);
                ret = -ENOTCONN;
                goto err;
        }
@@ -601,8 +598,8 @@ int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb)
         *  inside an IrLAP frame
         */
        if ((self->tx_max_sdu_size == 0) && (skb->len > self->max_seg_size)) {
-               ERROR("%s: SAR disabled, and data is to large for IrLAP!\n",
-                               __FUNCTION__);
+               IRDA_ERROR("%s: SAR disabled, and data is to large for IrLAP!\n",
+                          __FUNCTION__);
                ret = -EMSGSIZE;
                goto err;
        }
@@ -615,8 +612,8 @@ int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb)
            (self->tx_max_sdu_size != TTP_SAR_UNBOUND) &&
            (skb->len > self->tx_max_sdu_size))
        {
-               ERROR("%s: SAR enabled, but data is larger than TxMaxSduSize!\n",
-                     __FUNCTION__);
+               IRDA_ERROR("%s: SAR enabled, but data is larger than TxMaxSduSize!\n",
+                          __FUNCTION__);
                ret = -EMSGSIZE;
                goto err;
        }
@@ -638,7 +635,7 @@ int irttp_data_request(struct tsap_cb *self, struct sk_buff *skb)
        /* Queue frame, or queue frame segments */
        if ((self->tx_max_sdu_size == 0) || (skb->len < self->max_seg_size)) {
                /* Queue frame */
-               ASSERT(skb_headroom(skb) >= TTP_HEADER, return -1;);
+               IRDA_ASSERT(skb_headroom(skb) >= TTP_HEADER, return -1;);
                frame = skb_push(skb, TTP_HEADER);
                frame[0] = 0x00; /* Clear more bit */
 
@@ -800,20 +797,20 @@ static inline void irttp_give_credit(struct tsap_cb *self)
        unsigned long flags;
        int n;
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
        IRDA_DEBUG(4, "%s() send=%d,avail=%d,remote=%d\n",
                   __FUNCTION__,
                   self->send_credit, self->avail_credit, self->remote_credit);
 
        /* Give credit to peer */
-       tx_skb = dev_alloc_skb(64);
+       tx_skb = alloc_skb(TTP_MAX_HEADER, GFP_ATOMIC);
        if (!tx_skb)
                return;
 
        /* Reserve space for LMP, and LAP header */
-       skb_reserve(tx_skb, self->max_header_size);
+       skb_reserve(tx_skb, LMP_MAX_HEADER);
 
        /*
         *  Since we can transmit and receive frames concurrently,
@@ -857,9 +854,9 @@ static int irttp_udata_indication(void *instance, void *sap,
 
        self = (struct tsap_cb *) instance;
 
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
-       ASSERT(skb != NULL, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
+       IRDA_ASSERT(skb != NULL, return -1;);
 
        self->stats.rx_packets++;
 
@@ -974,8 +971,8 @@ static void irttp_status_indication(void *instance,
 
        self = (struct tsap_cb *) instance;
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
        /* Check if client has already closed the TSAP and gone away */
        if (self->close_pend)
@@ -1003,8 +1000,8 @@ static void irttp_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
 
        self = (struct tsap_cb *) instance;
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
        IRDA_DEBUG(4, "%s(instance=%p)\n", __FUNCTION__, self);
 
@@ -1046,8 +1043,8 @@ void irttp_flow_request(struct tsap_cb *self, LOCAL_FLOW flow)
 {
        IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
        switch (flow) {
        case FLOW_STOP:
@@ -1086,8 +1083,8 @@ int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel,
 
        IRDA_DEBUG(4, "%s(), max_sdu_size=%d\n", __FUNCTION__, max_sdu_size);
 
-       ASSERT(self != NULL, return -EBADR;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return -EBADR;);
+       IRDA_ASSERT(self != NULL, return -EBADR;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -EBADR;);
 
        if (self->connected) {
                if(userdata)
@@ -1097,20 +1094,21 @@ int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel,
 
        /* Any userdata supplied? */
        if (userdata == NULL) {
-               tx_skb = dev_alloc_skb(64);
+               tx_skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
+                                  GFP_ATOMIC);
                if (!tx_skb)
                        return -ENOMEM;
 
                /* Reserve space for MUX_CONTROL and LAP header */
-               skb_reserve(tx_skb, TTP_MAX_HEADER);
+               skb_reserve(tx_skb, TTP_MAX_HEADER + TTP_SAR_HEADER);
        } else {
                tx_skb = userdata;
                /*
                 *  Check that the client has reserved enough space for
                 *  headers
                 */
-               ASSERT(skb_headroom(userdata) >= TTP_MAX_HEADER,
-                      { dev_kfree_skb(userdata); return -1; } );
+               IRDA_ASSERT(skb_headroom(userdata) >= TTP_MAX_HEADER,
+                       { dev_kfree_skb(userdata); return -1; } );
        }
 
        /* Initialize connection parameters */
@@ -1138,8 +1136,8 @@ int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel,
 
        /* SAR enabled? */
        if (max_sdu_size > 0) {
-               ASSERT(skb_headroom(tx_skb) >= (TTP_MAX_HEADER + TTP_SAR_HEADER),
-                      { dev_kfree_skb(tx_skb); return -1; } );
+               IRDA_ASSERT(skb_headroom(tx_skb) >= (TTP_MAX_HEADER + TTP_SAR_HEADER),
+                       { dev_kfree_skb(tx_skb); return -1; } );
 
                /* Insert SAR parameters */
                frame = skb_push(tx_skb, TTP_HEADER+TTP_SAR_HEADER);
@@ -1150,7 +1148,7 @@ int irttp_connect_request(struct tsap_cb *self, __u8 dtsap_sel,
                frame[3] = 0x02; /* Value length */
 
                put_unaligned(cpu_to_be16((__u16) max_sdu_size),
-                             (__u16 *)(frame+4));
+                             (__be16 *)(frame+4));
        } else {
                /* Insert plain TTP header */
                frame = skb_push(tx_skb, TTP_HEADER);
@@ -1185,9 +1183,9 @@ static void irttp_connect_confirm(void *instance, void *sap,
 
        self = (struct tsap_cb *) instance;
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
-       ASSERT(skb != NULL, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(skb != NULL, return;);
 
        self->max_seg_size = max_seg_size - TTP_HEADER;
        self->max_header_size = max_header_size + TTP_HEADER;
@@ -1213,7 +1211,7 @@ static void irttp_connect_confirm(void *instance, void *sap,
 
        parameters = skb->data[0] & 0x80;
 
-       ASSERT(skb->len >= TTP_HEADER, return;);
+       IRDA_ASSERT(skb->len >= TTP_HEADER, return;);
        skb_pull(skb, TTP_HEADER);
 
        if (parameters) {
@@ -1225,8 +1223,8 @@ static void irttp_connect_confirm(void *instance, void *sap,
 
                /* Any errors in the parameter list? */
                if (ret < 0) {
-                       WARNING("%s: error extracting parameters\n",
-                                       __FUNCTION__);
+                       IRDA_WARNING("%s: error extracting parameters\n",
+                                    __FUNCTION__);
                        dev_kfree_skb(skb);
 
                        /* Do not accept this connection attempt */
@@ -1269,9 +1267,9 @@ void irttp_connect_indication(void *instance, void *sap, struct qos_info *qos,
 
        self = (struct tsap_cb *) instance;
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
-       ASSERT(skb != NULL, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(skb != NULL, return;);
 
        lsap = (struct lsap_cb *) sap;
 
@@ -1290,7 +1288,7 @@ void irttp_connect_indication(void *instance, void *sap, struct qos_info *qos,
 
        parameters = skb->data[0] & 0x80;
 
-       ASSERT(skb->len >= TTP_HEADER, return;);
+       IRDA_ASSERT(skb->len >= TTP_HEADER, return;);
        skb_pull(skb, TTP_HEADER);
 
        if (parameters) {
@@ -1302,8 +1300,8 @@ void irttp_connect_indication(void *instance, void *sap, struct qos_info *qos,
 
                /* Any errors in the parameter list? */
                if (ret < 0) {
-                       WARNING("%s: error extracting parameters\n",
-                                       __FUNCTION__);
+                       IRDA_WARNING("%s: error extracting parameters\n",
+                                    __FUNCTION__);
                        dev_kfree_skb(skb);
 
                        /* Do not accept this connection attempt */
@@ -1337,28 +1335,29 @@ int irttp_connect_response(struct tsap_cb *self, __u32 max_sdu_size,
        int ret;
        __u8 n;
 
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
 
        IRDA_DEBUG(4, "%s(), Source TSAP selector=%02x\n", __FUNCTION__,
                   self->stsap_sel);
 
        /* Any userdata supplied? */
        if (userdata == NULL) {
-               tx_skb = dev_alloc_skb(64);
+               tx_skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER,
+                                  GFP_ATOMIC);
                if (!tx_skb)
                        return -ENOMEM;
 
                /* Reserve space for MUX_CONTROL and LAP header */
-               skb_reserve(tx_skb, TTP_MAX_HEADER);
+               skb_reserve(tx_skb, TTP_MAX_HEADER + TTP_SAR_HEADER);
        } else {
                tx_skb = userdata;
                /*
                 *  Check that the client has reserved enough space for
                 *  headers
                 */
-               ASSERT(skb_headroom(userdata) >= TTP_MAX_HEADER,
-                      { dev_kfree_skb(userdata); return -1; } );
+               IRDA_ASSERT(skb_headroom(userdata) >= TTP_MAX_HEADER,
+                       { dev_kfree_skb(userdata); return -1; } );
        }
 
        self->avail_credit = 0;
@@ -1380,8 +1379,8 @@ int irttp_connect_response(struct tsap_cb *self, __u32 max_sdu_size,
 
        /* SAR enabled? */
        if (max_sdu_size > 0) {
-               ASSERT(skb_headroom(tx_skb) >= (TTP_MAX_HEADER + TTP_SAR_HEADER),
-                      { dev_kfree_skb(tx_skb); return -1; } );
+               IRDA_ASSERT(skb_headroom(tx_skb) >= (TTP_MAX_HEADER + TTP_SAR_HEADER),
+                       { dev_kfree_skb(tx_skb); return -1; } );
 
                /* Insert TTP header with SAR parameters */
                frame = skb_push(tx_skb, TTP_HEADER+TTP_SAR_HEADER);
@@ -1396,7 +1395,7 @@ int irttp_connect_response(struct tsap_cb *self, __u32 max_sdu_size,
                frame[3] = 0x02; /* Value length */
 
                put_unaligned(cpu_to_be16((__u16) max_sdu_size),
-                             (__u16 *)(frame+4));
+                             (__be16 *)(frame+4));
        } else {
                /* Insert TTP header */
                frame = skb_push(tx_skb, TTP_HEADER);
@@ -1456,6 +1455,7 @@ struct tsap_cb *irttp_dup(struct tsap_cb *orig, void *instance)
 
        /* Not everything should be copied */
        new->notify.instance = instance;
+       spin_lock_init(&new->lock);
        init_timer(&new->todo_timer);
 
        skb_queue_head_init(&new->rx_queue);
@@ -1481,8 +1481,8 @@ int irttp_disconnect_request(struct tsap_cb *self, struct sk_buff *userdata,
 {
        int ret;
 
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return -1;);
 
        /* Already disconnected? */
        if (!self->connected) {
@@ -1511,7 +1511,7 @@ int irttp_disconnect_request(struct tsap_cb *self, struct sk_buff *userdata,
        /*
         *  Check if there is still data segments in the transmit queue
         */
-       if (skb_queue_len(&self->tx_queue) > 0) {
+       if (!skb_queue_empty(&self->tx_queue)) {
                if (priority == P_HIGH) {
                        /*
                         *  No need to send the queued data, if we are
@@ -1544,14 +1544,14 @@ int irttp_disconnect_request(struct tsap_cb *self, struct sk_buff *userdata,
 
        if (!userdata) {
                struct sk_buff *tx_skb;
-               tx_skb = dev_alloc_skb(64);
+               tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
                if (!tx_skb)
                        return -ENOMEM;
 
                /*
                 *  Reserve space for MUX and LAP header
                 */
-               skb_reserve(tx_skb, TTP_MAX_HEADER);
+               skb_reserve(tx_skb, LMP_MAX_HEADER);
 
                userdata = tx_skb;
        }
@@ -1579,8 +1579,8 @@ void irttp_disconnect_indication(void *instance, void *sap, LM_REASON reason,
 
        self = (struct tsap_cb *) instance;
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
        /* Prevent higher layer to send more data */
        self->connected = FALSE;
@@ -1878,10 +1878,8 @@ static int irttp_seq_open(struct inode *inode, struct file *file)
        struct seq_file *seq;
        int rc = -ENOMEM;
        struct irttp_iter_state *s;
-       
-       ASSERT(irttp != NULL, return -EINVAL;);
 
-       s = kmalloc(sizeof(*s), GFP_KERNEL);
+       s = kzalloc(sizeof(*s), GFP_KERNEL);
        if (!s)
                goto out;
 
@@ -1891,7 +1889,6 @@ static int irttp_seq_open(struct inode *inode, struct file *file)
 
        seq          = file->private_data;
        seq->private = s;
-       memset(s, 0, sizeof(*s));
 out:
        return rc;
 out_kfree: