git://git.onelab.eu / linux-2.6.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
vserver 2.0 rc7
[linux-2.6.git] / net / irda / irlmp.c
diff --git a/net/irda/irlmp.c b/net/irda/irlmp.c
index 26b22f4..7a4a4d7 100644 (file)
--- a/net/irda/irlmp.c
+++ b/net/irda/irlmp.c
@@ -121,8 +121,8 @@ int __init irlmp_init(void)
 void __exit irlmp_cleanup(void) 
 {
        /* Check for main structure */
-       ASSERT(irlmp != NULL, return;);
-       ASSERT(irlmp->magic == LMP_MAGIC, return;);
+       IRDA_ASSERT(irlmp != NULL, return;);
+       IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;);
 
        del_timer(&irlmp->discovery_timer);
 
@@ -147,10 +147,10 @@ struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid)
 {
        struct lsap_cb *self;
 
-       ASSERT(notify != NULL, return NULL;);
-       ASSERT(irlmp != NULL, return NULL;);
-       ASSERT(irlmp->magic == LMP_MAGIC, return NULL;);
-       ASSERT(notify->instance != NULL, return NULL;);
+       IRDA_ASSERT(notify != NULL, return NULL;);
+       IRDA_ASSERT(irlmp != NULL, return NULL;);
+       IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return NULL;);
+       IRDA_ASSERT(notify->instance != NULL, return NULL;);
 
        /*  Does the client care which Source LSAP selector it gets?  */
        if (slsap_sel == LSAP_ANY) {
@@ -163,7 +163,7 @@ struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid)
        /* Allocate new instance of a LSAP connection */
        self = kmalloc(sizeof(struct lsap_cb), GFP_ATOMIC);
        if (self == NULL) {
-               ERROR("%s: can't allocate memory\n", __FUNCTION__);
+               IRDA_ERROR("%s: can't allocate memory\n", __FUNCTION__);
                return NULL;
        }
        memset(self, 0, sizeof(struct lsap_cb));
@@ -204,8 +204,8 @@ static void __irlmp_close_lsap(struct lsap_cb *self)
 {
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 
        /*
         *  Set some of the variables to preset values
@@ -230,8 +230,8 @@ void irlmp_close_lsap(struct lsap_cb *self)
        struct lap_cb *lap;
        struct lsap_cb *lsap = NULL;
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 
        /*
         *  Find out if we should remove this LSAP from a link or from the
@@ -239,7 +239,7 @@ void irlmp_close_lsap(struct lsap_cb *self)
         */
        lap = self->lap;
        if (lap) {
-               ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
+               IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
                /* We might close a LSAP before it has completed the
                 * connection setup. In those case, higher layers won't
                 * send a proper disconnect request. Harmless, except
@@ -282,16 +282,16 @@ void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr, notify_t *notify)
 {
        struct lap_cb *lap;
 
-       ASSERT(irlmp != NULL, return;);
-       ASSERT(irlmp->magic == LMP_MAGIC, return;);
-       ASSERT(notify != NULL, return;);
+       IRDA_ASSERT(irlmp != NULL, return;);
+       IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;);
+       IRDA_ASSERT(notify != NULL, return;);
 
        /*
         *  Allocate new instance of a LSAP connection
         */
        lap = kmalloc(sizeof(struct lap_cb), GFP_KERNEL);
        if (lap == NULL) {
-               ERROR("%s: unable to kmalloc\n", __FUNCTION__);
+               IRDA_ERROR("%s: unable to kmalloc\n", __FUNCTION__);
                return;
        }
        memset(lap, 0, sizeof(struct lap_cb));
@@ -305,7 +305,7 @@ void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr, notify_t *notify)
 #endif
        lap->lsaps = hashbin_new(HB_LOCK);
        if (lap->lsaps == NULL) {
-               WARNING("%s(), unable to kmalloc lsaps\n", __FUNCTION__);
+               IRDA_WARNING("%s(), unable to kmalloc lsaps\n", __FUNCTION__);
                kfree(lap);
                return;
        }
@@ -344,7 +344,7 @@ void irlmp_unregister_link(__u32 saddr)
         * will be triggered anymore. Jean II */
        link = hashbin_remove(irlmp->links, saddr, NULL);
        if (link) {
-               ASSERT(link->magic == LMP_LAP_MAGIC, return;);
+               IRDA_ASSERT(link->magic == LMP_LAP_MAGIC, return;);
 
                /* Kill all the LSAPs on this link. Jean II */
                link->reason = LAP_DISC_INDICATION;
@@ -376,8 +376,8 @@ int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
        struct lsap_cb *lsap;
        int ret;
 
-       ASSERT(self != NULL, return -EBADR;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return -EBADR;);
+       IRDA_ASSERT(self != NULL, return -EBADR;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EBADR;);
 
        IRDA_DEBUG(2,
              "%s(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n",
@@ -404,7 +404,7 @@ int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
        }
 
        /* Make room for MUX control header (3 bytes) */
-       ASSERT(skb_headroom(tx_skb) >= LMP_CONTROL_HEADER, return -1;);
+       IRDA_ASSERT(skb_headroom(tx_skb) >= LMP_CONTROL_HEADER, return -1;);
        skb_push(tx_skb, LMP_CONTROL_HEADER);
 
        self->dlsap_sel = dlsap_sel;
@@ -473,10 +473,10 @@ int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
         */
        lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, NULL);
 
-       ASSERT(lsap != NULL, return -1;);
-       ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
-       ASSERT(lsap->lap != NULL, return -1;);
-       ASSERT(lsap->lap->magic == LMP_LAP_MAGIC, return -1;);
+       IRDA_ASSERT(lsap != NULL, return -1;);
+       IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
+       IRDA_ASSERT(lsap->lap != NULL, return -1;);
+       IRDA_ASSERT(lsap->lap->magic == LMP_LAP_MAGIC, return -1;);
 
        hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, (long) self,
                       NULL);
@@ -516,10 +516,10 @@ void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb)
        int lap_header_size;
        int max_header_size;
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
-       ASSERT(skb != NULL, return;);
-       ASSERT(self->lap != NULL, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+       IRDA_ASSERT(skb != NULL, return;);
+       IRDA_ASSERT(self->lap != NULL, return;);
 
        IRDA_DEBUG(2, "%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
                   __FUNCTION__, self->slsap_sel, self->dlsap_sel);
@@ -555,9 +555,9 @@ void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb)
  */
 int irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata)
 {
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
-       ASSERT(userdata != NULL, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
+       IRDA_ASSERT(userdata != NULL, return -1;);
 
        /* We set the connected bit and move the lsap to the connected list
         * in the state machine itself. Jean II */
@@ -566,7 +566,7 @@ int irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata)
                   __FUNCTION__, self->slsap_sel, self->dlsap_sel);
 
        /* Make room for MUX control header (3 bytes) */
-       ASSERT(skb_headroom(userdata) >= LMP_CONTROL_HEADER, return -1;);
+       IRDA_ASSERT(skb_headroom(userdata) >= LMP_CONTROL_HEADER, return -1;);
        skb_push(userdata, LMP_CONTROL_HEADER);
 
        irlmp_do_lsap_event(self, LM_CONNECT_RESPONSE, userdata);
@@ -591,10 +591,10 @@ void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb)
 
        IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
 
-       ASSERT(skb != NULL, return;);
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
-       ASSERT(self->lap != NULL, return;);
+       IRDA_ASSERT(skb != NULL, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+       IRDA_ASSERT(self->lap != NULL, return;);
 
        self->qos = *self->lap->qos;
 
@@ -687,9 +687,9 @@ int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata)
 {
        struct lsap_cb *lsap;
 
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
-       ASSERT(userdata != NULL, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
+       IRDA_ASSERT(userdata != NULL, return -1;);
 
        /* Already disconnected ?
         * There is a race condition between irlmp_disconnect_indication()
@@ -716,18 +716,18 @@ int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata)
         *  Remove LSAP from list of connected LSAPs for the particular link
         *  and insert it into the list of unconnected LSAPs
         */
-       ASSERT(self->lap != NULL, return -1;);
-       ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
-       ASSERT(self->lap->lsaps != NULL, return -1;);
+       IRDA_ASSERT(self->lap != NULL, return -1;);
+       IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
+       IRDA_ASSERT(self->lap->lsaps != NULL, return -1;);
 
        lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL);
 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
        self->lap->cache.valid = FALSE;
 #endif
 
-       ASSERT(lsap != NULL, return -1;);
-       ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
-       ASSERT(lsap == self, return -1;);
+       IRDA_ASSERT(lsap != NULL, return -1;);
+       IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
+       IRDA_ASSERT(lsap == self, return -1;);
 
        hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self,
                       (long) self, NULL);
@@ -751,8 +751,8 @@ void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason,
        struct lsap_cb *lsap;
 
        IRDA_DEBUG(1, "%s(), reason=%s\n", __FUNCTION__, irlmp_reasons[reason]);
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 
        IRDA_DEBUG(3, "%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
                   __FUNCTION__, self->slsap_sel, self->dlsap_sel);
@@ -769,16 +769,16 @@ void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason,
        /*
         *  Remove association between this LSAP and the link it used
         */
-       ASSERT(self->lap != NULL, return;);
-       ASSERT(self->lap->lsaps != NULL, return;);
+       IRDA_ASSERT(self->lap != NULL, return;);
+       IRDA_ASSERT(self->lap->lsaps != NULL, return;);
 
        lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL);
 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
        self->lap->cache.valid = FALSE;
 #endif
 
-       ASSERT(lsap != NULL, return;);
-       ASSERT(lsap == self, return;);
+       IRDA_ASSERT(lsap != NULL, return;);
+       IRDA_ASSERT(lsap == self, return;);
        hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) lsap,
                       (long) lsap, NULL);
 
@@ -822,7 +822,7 @@ void irlmp_do_expiry(void)
         */
        lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
        while (lap != NULL) {
-               ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
+               IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
 
                if (lap->lap_state == LAP_STANDBY) {
                        /* Expire discoveries discovered on this link */
@@ -846,8 +846,8 @@ void irlmp_do_discovery(int nslots)
 
        /* Make sure the value is sane */
        if ((nslots != 1) && (nslots != 6) && (nslots != 8) && (nslots != 16)){
-               WARNING("%s: invalid value for number of slots!\n",
-                               __FUNCTION__);
+               IRDA_WARNING("%s: invalid value for number of slots!\n",
+                            __FUNCTION__);
                nslots = sysctl_discovery_slots = 8;
        }
 
@@ -870,7 +870,7 @@ void irlmp_do_discovery(int nslots)
         */
        lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
        while (lap != NULL) {
-               ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
+               IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
 
                if (lap->lap_state == LAP_STANDBY) {
                        /* Try to discover */
@@ -1017,7 +1017,7 @@ void irlmp_discovery_confirm(hashbin_t *log, DISCOVERY_MODE mode)
 
        IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
 
-       ASSERT(log != NULL, return;);
+       IRDA_ASSERT(log != NULL, return;);
 
        if (!(HASHBIN_GET_SIZE(log)))
                return;
@@ -1052,7 +1052,7 @@ void irlmp_discovery_expiry(discinfo_t *expiries, int number)
 
        IRDA_DEBUG(3, "%s()\n", __FUNCTION__);
 
-       ASSERT(expiries != NULL, return;);
+       IRDA_ASSERT(expiries != NULL, return;);
 
        /* For each client - notify callback may touch client list */
        client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
@@ -1085,7 +1085,7 @@ discovery_t *irlmp_get_discovery_response(void)
 {
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-       ASSERT(irlmp != NULL, return NULL;);
+       IRDA_ASSERT(irlmp != NULL, return NULL;);
 
        u16ho(irlmp->discovery_rsp.data.hints) = irlmp->hints.word;
 
@@ -1120,11 +1120,11 @@ int irlmp_data_request(struct lsap_cb *self, struct sk_buff *userdata)
 {
        int     ret;
 
-       ASSERT(self != NULL, return -1;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
+       IRDA_ASSERT(self != NULL, return -1;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
 
        /* Make room for MUX header */
-       ASSERT(skb_headroom(userdata) >= LMP_HEADER, return -1;);
+       IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER, return -1;);
        skb_push(userdata, LMP_HEADER);
 
        ret = irlmp_do_lsap_event(self, LM_DATA_REQUEST, userdata);
@@ -1163,10 +1163,10 @@ int irlmp_udata_request(struct lsap_cb *self, struct sk_buff *userdata)
 
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-       ASSERT(userdata != NULL, return -1;);
+       IRDA_ASSERT(userdata != NULL, return -1;);
 
        /* Make room for MUX header */
-       ASSERT(skb_headroom(userdata) >= LMP_HEADER, return -1;);
+       IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER, return -1;);
        skb_push(userdata, LMP_HEADER);
 
        ret = irlmp_do_lsap_event(self, LM_UDATA_REQUEST, userdata);
@@ -1187,9 +1187,9 @@ void irlmp_udata_indication(struct lsap_cb *self, struct sk_buff *skb)
 {
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
-       ASSERT(skb != NULL, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+       IRDA_ASSERT(skb != NULL, return;);
 
        /* Hide LMP header from layer above */
        skb_pull(skb, LMP_HEADER);
@@ -1214,11 +1214,11 @@ int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *userdata,
 
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-       ASSERT(userdata != NULL, return -1;);
+       IRDA_ASSERT(userdata != NULL, return -1;);
 
        /* Make room for MUX and PID header */
-       ASSERT(skb_headroom(userdata) >= LMP_HEADER+LMP_PID_HEADER,
-              return -1;);
+       IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER+LMP_PID_HEADER,
+                   return -1;);
 
        /* Insert protocol identifier */
        skb_push(userdata, LMP_PID_HEADER);
@@ -1234,7 +1234,7 @@ int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *userdata,
        /* Try to send Connectionless  packets out on all links */
        lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
        while (lap != NULL) {
-               ASSERT(lap->magic == LMP_LAP_MAGIC, return -1;);
+               IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return -1;);
 
                clone_skb = skb_clone(userdata, GFP_ATOMIC);
                if (!clone_skb) {
@@ -1265,9 +1265,9 @@ void irlmp_connless_data_indication(struct lsap_cb *self, struct sk_buff *skb)
 {
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
-       ASSERT(self != NULL, return;);
-       ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
-       ASSERT(skb != NULL, return;);
+       IRDA_ASSERT(self != NULL, return;);
+       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+       IRDA_ASSERT(skb != NULL, return;);
 
        /* Hide LMP and PID header from layer above */
        skb_pull(skb, LMP_HEADER+LMP_PID_HEADER);
@@ -1298,7 +1298,7 @@ void irlmp_status_indication(struct lap_cb *self,
        curr = (struct lsap_cb *) hashbin_get_first( self->lsaps);
        while (NULL != hashbin_find_next(self->lsaps, (long) curr, NULL,
                                         (void *) &next) ) {
-               ASSERT(curr->magic == LMP_LSAP_MAGIC, return;);
+               IRDA_ASSERT(curr->magic == LMP_LSAP_MAGIC, return;);
                /*
                 *  Inform service user if he has requested it
                 */
@@ -1328,8 +1328,8 @@ void irlmp_flow_indication(struct lap_cb *self, LOCAL_FLOW flow)
        struct lsap_cb *curr;
        int     lsap_todo;
 
-       ASSERT(self->magic == LMP_LAP_MAGIC, return;);
-       ASSERT(flow == FLOW_START, return;);
+       IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
+       IRDA_ASSERT(flow == FLOW_START, return;);
 
        /* Get the number of lsap. That's the only safe way to know
         * that we have looped around... - Jean II */
@@ -1559,7 +1559,7 @@ void *irlmp_register_client(__u16 hint_mask, DISCOVERY_CALLBACK1 disco_clb,
        irlmp_client_t *client;
 
        IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
-       ASSERT(irlmp != NULL, return NULL;);
+       IRDA_ASSERT(irlmp != NULL, return NULL;);
 
        /* Make a new registration */
        client = kmalloc(sizeof(irlmp_client_t), GFP_ATOMIC);
@@ -1660,9 +1660,9 @@ static int irlmp_slsap_inuse(__u8 slsap_sel)
        struct lap_cb *lap;
        unsigned long flags;
 
-       ASSERT(irlmp != NULL, return TRUE;);
-       ASSERT(irlmp->magic == LMP_MAGIC, return TRUE;);
-       ASSERT(slsap_sel != LSAP_ANY, return TRUE;);
+       IRDA_ASSERT(irlmp != NULL, return TRUE;);
+       IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return TRUE;);
+       IRDA_ASSERT(slsap_sel != LSAP_ANY, return TRUE;);
 
        IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
 
@@ -1684,7 +1684,7 @@ static int irlmp_slsap_inuse(__u8 slsap_sel)
        spin_lock_irqsave(&irlmp->links->hb_spinlock, flags);
        lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
        while (lap != NULL) {
-               ASSERT(lap->magic == LMP_LAP_MAGIC, goto errlap;);
+               IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, goto errlap;);
 
                /* Careful for priority inversions here !
                 * irlmp->links is never taken while another IrDA
@@ -1694,7 +1694,8 @@ static int irlmp_slsap_inuse(__u8 slsap_sel)
                /* For this IrLAP, check all the LSAPs */
                self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
                while (self != NULL) {
-                       ASSERT(self->magic == LMP_LSAP_MAGIC, goto errlsap;);
+                       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC,
+                                   goto errlsap;);
 
                        if ((self->slsap_sel == slsap_sel)) {
                                IRDA_DEBUG(4, "Source LSAP selector=%02x in use\n",
@@ -1720,7 +1721,7 @@ static int irlmp_slsap_inuse(__u8 slsap_sel)
 
        self = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
        while (self != NULL) {
-               ASSERT(self->magic == LMP_LSAP_MAGIC, goto erruncon;);
+               IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, goto erruncon;);
                if ((self->slsap_sel == slsap_sel)) {
                        IRDA_DEBUG(4, "Source LSAP selector=%02x in use (unconnected)\n",
                                   self->slsap_sel);
@@ -1737,7 +1738,7 @@ static int irlmp_slsap_inuse(__u8 slsap_sel)
         * Jean II */
 errlsap:
        spin_unlock(&lap->lsaps->hb_spinlock);
-errlap:
+IRDA_ASSERT_LABEL(errlap:)
        spin_unlock_irqrestore(&irlmp->links->hb_spinlock, flags);
        return TRUE;
 
@@ -1759,8 +1760,8 @@ static __u8 irlmp_find_free_slsap(void)
        __u8 lsap_sel;
        int wrapped = 0;
 
-       ASSERT(irlmp != NULL, return -1;);
-       ASSERT(irlmp->magic == LMP_MAGIC, return -1;);
+       IRDA_ASSERT(irlmp != NULL, return -1;);
+       IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return -1;);
 
        /* Most users don't really care which LSAPs they are given,
         * and therefore we automatically give them a free LSAP.
@@ -1788,8 +1789,8 @@ static __u8 irlmp_find_free_slsap(void)
 
                        /* Make sure we terminate the loop */
                        if (wrapped++) {
-                               ERROR("%s: no more free LSAPs !\n",
-                                     __FUNCTION__);
+                               IRDA_ERROR("%s: no more free LSAPs !\n",
+                                          __FUNCTION__);
                                return 0;
                        }
                }
@@ -1948,7 +1949,7 @@ static int irlmp_seq_show(struct seq_file *seq, void *v)
                seq_puts(seq, "\nRegistered Link Layers:\n");
        else if (iter->hashbin == irlmp->unconnected_lsaps) {
                self = v;
-               ASSERT(self->magic == LMP_LSAP_MAGIC, return -EINVAL; );
+               IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EINVAL; );
                seq_printf(seq, "lsap state: %s, ",
                           irlsap_state[ self->lsap_state]);
                seq_printf(seq,
@@ -1977,7 +1978,8 @@ static int irlmp_seq_show(struct seq_file *seq, void *v)
                for (self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
                     self != NULL;
                     self = (struct lsap_cb *)hashbin_get_next(lap->lsaps)) {
-                       ASSERT(self->magic == LMP_LSAP_MAGIC, break;);
+                       IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC,
+                                   goto outloop;);
                        seq_printf(seq, "  lsap state: %s, ",
                                   irlsap_state[ self->lsap_state]);
                        seq_printf(seq,
@@ -1987,6 +1989,7 @@ static int irlmp_seq_show(struct seq_file *seq, void *v)
                        seq_putc(seq, '\n');
 
                }
+       IRDA_ASSERT_LABEL(outloop:)
                spin_unlock(&lap->lsaps->hb_spinlock);
                seq_putc(seq, '\n');
        } else
@@ -2008,7 +2011,7 @@ static int irlmp_seq_open(struct inode *inode, struct file *file)
        int rc = -ENOMEM;
        struct irlmp_iter_state *s;
 
-       ASSERT(irlmp != NULL, return -EINVAL;);
+       IRDA_ASSERT(irlmp != NULL, return -EINVAL;);
 
        s = kmalloc(sizeof(*s), GFP_KERNEL);
        if (!s)
linux-2.6