[PATCH] 2.5.21 kill warnings 15/19

[Martin Dalecki <dalecki@evision-ventures.com>]

[-- Attachment #1: Type: text/plain, Size: 53 bytes --]

irlmp abused __FUNCTION__ and the space bar as well.

[-- Attachment #2: warn-2.5.21-15.diff --]
[-- Type: text/plain, Size: 33050 bytes --]

diff -urN linux-2.5.21/net/irda/irlmp.c linux/net/irda/irlmp.c
--- linux-2.5.21/net/irda/irlmp.c	2002-06-09 07:31:21.000000000 +0200
+++ linux/net/irda/irlmp.c	2002-06-09 21:46:26.000000000 +0200
@@ -1,25 +1,25 @@
 /*********************************************************************
- *                
+ *
  * Filename:      irlmp.c
  * Version:       1.0
- * Description:   IrDA Link Management Protocol (LMP) layer                 
+ * Description:   IrDA Link Management Protocol (LMP) layer
  * Status:        Stable.
  * Author:        Dag Brattli <dagb@cs.uit.no>
  * Created at:    Sun Aug 17 20:54:32 1997
  * Modified at:   Wed Jan  5 11:26:03 2000
  * Modified by:   Dag Brattli <dagb@cs.uit.no>
- * 
- *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>, 
+ *
+ *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
  *     All Rights Reserved.
  *     Copyright (c) 2000-2001 Jean Tourrilhes <jt@hpl.hp.com>
- *     
- *     This program is free software; you can redistribute it and/or 
- *     modify it under the terms of the GNU General Public License as 
- *     published by the Free Software Foundation; either version 2 of 
+ *
+ *     This program is free software; you can redistribute it 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 
+ *     provide warranty for any of this software. This material is
  *     provided "AS-IS" and at no charge.
  *
  ********************************************************************/
@@ -82,7 +82,7 @@
 	if (irlmp == NULL)
 		return -ENOMEM;
 	memset(irlmp, 0, sizeof(struct irlmp_cb));
-	
+
 	irlmp->magic = LMP_MAGIC;
 	spin_lock_init(&irlmp->log_lock);
 
@@ -91,13 +91,13 @@
 	irlmp->links = hashbin_new(HB_GLOBAL);
 	irlmp->unconnected_lsaps = hashbin_new(HB_GLOBAL);
 	irlmp->cachelog = hashbin_new(HB_GLOBAL);
-	
+
 	irlmp->free_lsap_sel = 0x10; /* Reserved 0x00-0x0f */
 	strcpy(sysctl_devname, "Linux");
-	
+
 	/* Do discovery every 3 seconds */
 	init_timer(&irlmp->discovery_timer);
-   	irlmp_start_discovery_timer(irlmp, sysctl_discovery_timeout*HZ);
+	irlmp_start_discovery_timer(irlmp, sysctl_discovery_timeout*HZ);
 
 	return 0;
 }
@@ -108,20 +108,20 @@
  *    Remove IrLMP layer
  *
  */
-void irlmp_cleanup(void) 
+void irlmp_cleanup(void)
 {
 	/* Check for main structure */
 	ASSERT(irlmp != NULL, return;);
 	ASSERT(irlmp->magic == LMP_MAGIC, return;);
 
 	del_timer(&irlmp->discovery_timer);
-	
+
 	hashbin_delete(irlmp->links, (FREE_FUNC) kfree);
 	hashbin_delete(irlmp->unconnected_lsaps, (FREE_FUNC) kfree);
 	hashbin_delete(irlmp->clients, (FREE_FUNC) kfree);
 	hashbin_delete(irlmp->services, (FREE_FUNC) kfree);
 	hashbin_delete(irlmp->cachelog, (FREE_FUNC) kfree);
-	
+
 	/* De-allocate main structure */
 	kfree(irlmp);
 	irlmp = NULL;
@@ -152,11 +152,11 @@
 	/* Allocate new instance of a LSAP connection */
 	self = kmalloc(sizeof(struct lsap_cb), GFP_ATOMIC);
 	if (self == NULL) {
-		ERROR(__FUNCTION__ "(), can't allocate memory");
+		ERROR("%s: can't allocate memory", __FUNCTION__);
 		return NULL;
 	}
 	memset(self, 0, sizeof(struct lsap_cb));
-	
+
 	self->magic = LMP_LSAP_MAGIC;
 	self->slsap_sel = slsap_sel;
 
@@ -176,11 +176,11 @@
 	self->notify = *notify;
 
 	self->lsap_state = LSAP_DISCONNECTED;
-	
+
 	/* Insert into queue of unconnected LSAPs */
 	hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self, (int) self, 
 		       NULL);
-	
+
 	return self;
 }
 
@@ -247,11 +247,11 @@
 	self->lap = NULL;
 	/* Check if we found the LSAP! If not then try the unconnected lsaps */
 	if (!lsap) {
-		lsap = hashbin_remove(irlmp->unconnected_lsaps, (int) self, 
+		lsap = hashbin_remove(irlmp->unconnected_lsaps, (int) self,
 				      NULL);
 	}
 	if (!lsap) {
-		IRDA_DEBUG(0, __FUNCTION__ 
+		IRDA_DEBUG(0, __FUNCTION__
 		     "(), Looks like somebody has removed me already!\n");
 		return;
 	}
@@ -278,11 +278,11 @@
 	 */
 	lap = kmalloc(sizeof(struct lap_cb), GFP_KERNEL);
 	if (lap == NULL) {
-		ERROR(__FUNCTION__ "(), unable to kmalloc\n");
+		ERROR("%s: unable to kmalloc\n", __FUNCTION__);
 		return;
 	}
 	memset(lap, 0, sizeof(struct lap_cb));
-	
+
 	lap->irlap = irlap;
 	lap->magic = LMP_LAP_MAGIC;
 	lap->saddr = saddr;
@@ -293,7 +293,7 @@
 #endif
 
 	lap->lap_state = LAP_STANDBY;
-	
+
 	init_timer(&lap->idle_timer);
 
 	/*
@@ -301,9 +301,9 @@
 	 */
 	hashbin_insert(irlmp->links, (irda_queue_t *) lap, lap->saddr, NULL);
 
-	/* 
+	/*
 	 *  We set only this variable so IrLAP can tell us on which link the
-	 *  different events happened on 
+	 *  different events happened on
 	 */
 	irda_notify_init(notify);
 	notify->instance = lap;
@@ -328,7 +328,7 @@
 		/* Remove all discoveries discovered at this link */
 		irlmp_expire_discoveries(irlmp->cachelog, link->saddr, TRUE);
 
-		del_timer(&link->idle_timer);	
+		del_timer(&link->idle_timer);
 
 		link->magic = 0;
 		kfree(link);
@@ -338,12 +338,12 @@
 /*
  * Function irlmp_connect_request (handle, dlsap, userdata)
  *
- *    Connect with a peer LSAP  
+ *    Connect with a peer LSAP
  *
  */
-int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel, 
-			  __u32 saddr, __u32 daddr, 
-			  struct qos_info *qos, struct sk_buff *userdata) 
+int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
+			  __u32 saddr, __u32 daddr,
+			  struct qos_info *qos, struct sk_buff *userdata)
 {
 	struct sk_buff *skb = NULL;
 	struct lap_cb *lap;
@@ -352,18 +352,18 @@
 
 	ASSERT(self != NULL, return -EBADR;);
 	ASSERT(self->magic == LMP_LSAP_MAGIC, return -EBADR;);
-	
-	IRDA_DEBUG(2, __FUNCTION__ 
-	      "(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n", 
+
+	IRDA_DEBUG(2, __FUNCTION__
+	      "(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n",
 	      self->slsap_sel, dlsap_sel, saddr, daddr);
-	
+
 	if (test_bit(0, &self->connected))
 		return -EISCONN;
-	
+
 	/* Client must supply destination device address */
 	if (!daddr)
 		return -EINVAL;
-	
+
 	/* Any userdata? */
 	if (userdata == NULL) {
 		skb = dev_alloc_skb(64);
@@ -373,27 +373,27 @@
 		skb_reserve(skb, LMP_MAX_HEADER);
 	} else
 		skb = userdata;
-	
+
 	/* Make room for MUX control header (3 bytes) */
 	ASSERT(skb_headroom(skb) >= LMP_CONTROL_HEADER, return -1;);
 	skb_push(skb, LMP_CONTROL_HEADER);
 
 	self->dlsap_sel = dlsap_sel;
-	
-	/*  
+
+	/*
 	 * Find the link to where we should try to connect since there may
 	 * be more than one IrDA port on this machine. If the client has
 	 * passed us the saddr (and already knows which link to use), then
 	 * we use that to find the link, if not then we have to look in the
 	 * discovery log and check if any of the links has discovered a
-	 * device with the given daddr 
+	 * device with the given daddr
 	 */
 	if ((!saddr) || (saddr == DEV_ADDR_ANY)) {
 		if (daddr != DEV_ADDR_ANY)
 			discovery = hashbin_find(irlmp->cachelog, daddr, NULL);
 		else {
 			IRDA_DEBUG(2, __FUNCTION__ "(), no daddr\n");
-			discovery = (discovery_t *) 
+			discovery = (discovery_t *)
 				hashbin_get_first(irlmp->cachelog);
 		}
 
@@ -402,7 +402,7 @@
 			daddr = discovery->daddr;
 		}
 	}
-	lap = hashbin_find(irlmp->links, saddr, NULL);	
+	lap = hashbin_find(irlmp->links, saddr, NULL);
 	if (lap == NULL) {
 		IRDA_DEBUG(1, __FUNCTION__ "(), Unable to find a usable link!\n");
 		return -EHOSTUNREACH;
@@ -433,9 +433,9 @@
 
 	self->lap = lap;
 
-	/* 
-	 *  Remove LSAP from list of unconnected LSAPs and insert it into the 
-	 *  list of connected LSAPs for the particular link 
+	/*
+	 *  Remove LSAP from list of unconnected LSAPs and insert it into the
+	 *  list of connected LSAPs for the particular link
 	 */
 	lsap = hashbin_remove(irlmp->unconnected_lsaps, (int) self, NULL);
 
@@ -447,13 +447,13 @@
 	hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, (int) self, NULL);
 
 	set_bit(0, &self->connected);	/* TRUE */
-	
+
 	/*
 	 *  User supplied qos specifications?
 	 */
 	if (qos)
 		self->qos = *qos;
-	
+
 	irlmp_do_lsap_event(self, LM_CONNECT_REQUEST, skb);
 
 	return 0;
@@ -465,18 +465,18 @@
  *    Incoming connection
  *
  */
-void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb) 
+void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb)
 {
 	int max_seg_size;
 	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_DEBUG(2, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n", 
+	IRDA_DEBUG(2, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n",
 		   self->slsap_sel, self->dlsap_sel);
 
 	/* Note : self->lap is set in irlmp_link_data_indication(),
@@ -492,10 +492,10 @@
 
 	/* Hide LMP_CONTROL_HEADER header from layer above */
 	skb_pull(skb, LMP_CONTROL_HEADER);
-	
+
 	if (self->notify.connect_indication)
-		self->notify.connect_indication(self->notify.instance, self, 
-						&self->qos, max_seg_size, 
+		self->notify.connect_indication(self->notify.instance, self,
+						&self->qos, max_seg_size,
 						max_header_size, skb);
 	else
 		dev_kfree_skb(skb);
@@ -507,7 +507,7 @@
  *    Service user is accepting connection
  *
  */
-int irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata) 
+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;);
@@ -515,13 +515,13 @@
 
 	set_bit(0, &self->connected);	/* TRUE */
 
-	IRDA_DEBUG(2, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n", 
+	IRDA_DEBUG(2, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n",
 		   self->slsap_sel, self->dlsap_sel);
 
 	/* Make room for MUX control header (3 bytes) */
 	ASSERT(skb_headroom(userdata) >= LMP_CONTROL_HEADER, return -1;);
 	skb_push(userdata, LMP_CONTROL_HEADER);
-	
+
 	irlmp_do_lsap_event(self, LM_CONNECT_RESPONSE, userdata);
 
 	return 0;
@@ -532,26 +532,26 @@
  *
  *    LSAP connection confirmed peer device!
  */
-void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb) 
+void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb)
 {
 	int max_header_size;
 	int lap_header_size;
 	int max_seg_size;
 
 	IRDA_DEBUG(3, __FUNCTION__ "()\n");
-	
+
 	ASSERT(skb != NULL, return;);
 	ASSERT(self != NULL, return;);
-	ASSERT(self->magic == LMP_LSAP_MAGIC, return;);	
+	ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 	ASSERT(self->lap != NULL, return;);
 
 	self->qos = *self->lap->qos;
 
 	max_seg_size    = self->lap->qos->data_size.value-LMP_HEADER;
-	lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap);	
+	lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap);
 	max_header_size = LMP_HEADER + lap_header_size;
 
-	IRDA_DEBUG(2, __FUNCTION__ "(), max_header_size=%d\n", 
+	IRDA_DEBUG(2, __FUNCTION__ "(), max_header_size=%d\n",
 		   max_header_size);
 
 	/* Hide LMP_CONTROL_HEADER header from layer above */
@@ -572,7 +572,7 @@
  *    new LSAP so it can keep listening on the old one.
  *
  */
-struct lsap_cb *irlmp_dup(struct lsap_cb *orig, void *instance) 
+struct lsap_cb *irlmp_dup(struct lsap_cb *orig, void *instance)
 {
 	struct lsap_cb *new;
 
@@ -595,8 +595,8 @@
 	/* new->slsap_sel = orig->slsap_sel; => done in the memcpy() */
 
 	init_timer(&new->watchdog_timer);
-	
-	hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) new, (int) new, 
+
+	hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) new, (int) new,
 		       NULL);
 
 	/* Make sure that we invalidate the cache */
@@ -610,10 +610,10 @@
 /*
  * Function irlmp_disconnect_request (handle, userdata)
  *
- *    The service user is requesting disconnection, this will not remove the 
+ *    The service user is requesting disconnection, this will not remove the
  *    LSAP, but only mark it as disconnected
  */
-int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata) 
+int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata)
 {
 	struct lsap_cb *lsap;
 
@@ -633,13 +633,13 @@
 
 	skb_push(userdata, LMP_CONTROL_HEADER);
 
-	/* 
+	/*
 	 *  Do the event before the other stuff since we must know
 	 *  which lap layer that the frame should be transmitted on
 	 */
 	irlmp_do_lsap_event(self, LM_DISCONNECT_REQUEST, userdata);
 
-	/* 
+	/*
 	 *  Remove LSAP from list of connected LSAPs for the particular link
 	 *  and insert it into the list of unconnected LSAPs
 	 */
@@ -653,13 +653,13 @@
 	ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
 	ASSERT(lsap == self, return -1;);
 
-	hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self, (int) self, 
+	hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self, (int) self,
 		       NULL);
-	
+
 	/* Reset some values */
 	self->dlsap_sel = LSAP_ANY;
 	self->lap = NULL;
-	
+
 	return 0;
 }
 
@@ -668,8 +668,8 @@
  *
  *    LSAP is being closed!
  */
-void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason, 
-				 struct sk_buff *userdata) 
+void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason,
+				 struct sk_buff *userdata)
 {
 	struct lsap_cb *lsap;
 
@@ -677,7 +677,7 @@
 	ASSERT(self != NULL, return;);
 	ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 
-	IRDA_DEBUG(3, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n", 
+	IRDA_DEBUG(3, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n",
 		   self->slsap_sel, self->dlsap_sel);
 
 	/* Already disconnected ?
@@ -691,12 +691,12 @@
 		return;
 	}
 
-	/* 
-	 *  Remove association between this LSAP and the link it used 
+	/*
+	 *  Remove association between this LSAP and the link it used
 	 */
 	ASSERT(self->lap != NULL, return;);
 	ASSERT(self->lap->lsaps != NULL, return;);
-	
+
 	lsap = hashbin_remove(self->lap->lsaps, (int) self, NULL);
 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
 	self->lap->cache.valid = FALSE;
@@ -704,17 +704,17 @@
 
 	ASSERT(lsap != NULL, return;);
 	ASSERT(lsap == self, return;);
-	hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) lsap, (int) lsap, 
+	hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) lsap, (int) lsap,
 		       NULL);
 
 	self->dlsap_sel = LSAP_ANY;
 	self->lap = NULL;
-	
+
 	/*
 	 *  Inform service user
 	 */
 	if (self->notify.disconnect_indication)
-		self->notify.disconnect_indication(self->notify.instance, 
+		self->notify.disconnect_indication(self->notify.instance,
 						   self, reason, userdata);
 	else {
 		IRDA_DEBUG(0, __FUNCTION__ "(), no handler\n");
@@ -747,7 +747,7 @@
 	lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
 	while (lap != NULL) {
 		ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
-		
+
 		if (lap->lap_state == LAP_STANDBY) {
 			/* Expire discoveries discovered on this link */
 			irlmp_expire_discoveries(irlmp->cachelog, lap->saddr,
@@ -770,35 +770,35 @@
 
 	/* Make sure the value is sane */
 	if ((nslots != 1) && (nslots != 6) && (nslots != 8) && (nslots != 16)){
-		WARNING(__FUNCTION__ 
-		       "(), invalid value for number of slots!\n");
+		WARNING("%s: invalid value for number of slots!\n",
+				__FUNCTION__);
 		nslots = sysctl_discovery_slots = 8;
 	}
 
 	/* Construct new discovery info to be used by IrLAP, */
 	irlmp->discovery_cmd.hints.word = irlmp->hints.word;
-	
-	/* 
-	 *  Set character set for device name (we use ASCII), and 
-	 *  copy device name. Remember to make room for a \0 at the 
+
+	/*
+	 *  Set character set for device name (we use ASCII), and
+	 *  copy device name. Remember to make room for a \0 at the
 	 *  end
 	 */
 	irlmp->discovery_cmd.charset = CS_ASCII;
-	strncpy(irlmp->discovery_cmd.nickname, sysctl_devname, 
+	strncpy(irlmp->discovery_cmd.nickname, sysctl_devname,
 		NICKNAME_MAX_LEN);
 	irlmp->discovery_cmd.name_len = strlen(irlmp->discovery_cmd.nickname);
 	irlmp->discovery_cmd.nslots = nslots;
-	
+
 	/*
 	 * Try to send discovery packets on all links
 	 */
 	lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
 	while (lap != NULL) {
 		ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
-		
+
 		if (lap->lap_state == LAP_STANDBY) {
 			/* Try to discover */
-			irlmp_do_lap_event(lap, LM_LAP_DISCOVERY_REQUEST, 
+			irlmp_do_lap_event(lap, LM_LAP_DISCOVERY_REQUEST,
 					   NULL);
 		}
 		lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
@@ -816,9 +816,9 @@
 	/* Return current cached discovery log */
 	irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_LOG);
 
-	/* 
+	/*
 	 * Start a single discovery operation if discovery is not already
-         * running 
+         * running
 	 */
 	if (!sysctl_discovery) {
 		/* Check if user wants to override the default */
@@ -864,9 +864,6 @@
 #if 0
 /*
  * Function irlmp_check_services (discovery)
- *
- *    
- *
  */
 void irlmp_check_services(discovery_t *discovery)
 {
@@ -896,7 +893,7 @@
 			/* Don't notify about the ANY service */
 			if (service == S_ANY)
 				continue;
-			/*  
+			/*
 			 * Found no clients for dealing with this service,
 			 */
 		}
@@ -923,20 +920,20 @@
 	discovery_t *discovery;
 
 	IRDA_DEBUG(3, __FUNCTION__ "()\n");
-	
+
 	/* Check if client wants or not partial/selective log (optimisation) */
 	if (!client->disco_callback)
 		return;
 
-	/* 
-	 * Now, check all discovered devices (if any), and notify client 
-	 * only about the services that the client is interested in 
+	/*
+	 * Now, check all discovered devices (if any), and notify client
+	 * only about the services that the client is interested in
 	 */
 	discovery = (discovery_t *) hashbin_get_first(log);
 	while (discovery != NULL) {
-		IRDA_DEBUG(3, "discovery->daddr = 0x%08x\n", discovery->daddr); 
-		
-		/* 
+		IRDA_DEBUG(3, "discovery->daddr = 0x%08x\n", discovery->daddr);
+
+		/*
 		 * Any common hint bits? Remember to mask away the extension
 		 * bits ;-)
 		 */
@@ -952,24 +949,24 @@
  *
  *    Some device(s) answered to our discovery request! Check to see which
  *    device it is, and give indication to the client(s)
- * 
+ *
  */
-void irlmp_discovery_confirm(hashbin_t *log, DISCOVERY_MODE mode) 
+void irlmp_discovery_confirm(hashbin_t *log, DISCOVERY_MODE mode)
 {
 	irlmp_client_t *client;
-	
+
 	IRDA_DEBUG(3, __FUNCTION__ "()\n");
-	
+
 	ASSERT(log != NULL, return;);
-	
+
 	if (!(HASHBIN_GET_SIZE(log)))
 		return;
-	
+
 	client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
 	while (client != NULL) {
 		/* Check if we should notify client */
 		irlmp_notify_client(client, log, mode);
-			
+
 		client = (irlmp_client_t *) hashbin_get_next(irlmp->clients);
 	}
 }
@@ -980,19 +977,19 @@
  *	This device is no longer been discovered, and therefore it is beeing
  *	purged from the discovery log. Inform all clients who have
  *	registered for this event...
- * 
+ *
  *	Note : called exclusively from discovery.c
  *	Note : as we are currently processing the log, the clients callback
  *	should *NOT* attempt to touch the log now.
  */
-void irlmp_discovery_expiry(discovery_t *expiry) 
+void irlmp_discovery_expiry(discovery_t *expiry)
 {
 	irlmp_client_t *client;
-	
+
 	IRDA_DEBUG(3, __FUNCTION__ "()\n");
 
 	ASSERT(expiry != NULL, return;);
-	
+
 	client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
 	while (client != NULL) {
 		/* Check if we should notify client */
@@ -1020,14 +1017,14 @@
 
 	irlmp->discovery_rsp.hints.word = irlmp->hints.word;
 
-	/* 
-	 *  Set character set for device name (we use ASCII), and 
-	 *  copy device name. Remember to make room for a \0 at the 
+	/*
+	 *  Set character set for device name (we use ASCII), and
+	 *  copy device name. Remember to make room for a \0 at the
 	 *  end
 	 */
 	irlmp->discovery_rsp.charset = CS_ASCII;
 
-	strncpy(irlmp->discovery_rsp.nickname, sysctl_devname, 
+	strncpy(irlmp->discovery_rsp.nickname, sysctl_devname,
 		NICKNAME_MAX_LEN);
 	irlmp->discovery_rsp.name_len = strlen(irlmp->discovery_rsp.nickname);
 
@@ -1040,15 +1037,15 @@
  *    Send some data to peer device
  *
  */
-int irlmp_data_request(struct lsap_cb *self, struct sk_buff *skb) 
+int irlmp_data_request(struct lsap_cb *self, struct sk_buff *skb)
 {
 	ASSERT(self != NULL, return -1;);
 	ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
-	
+
 	/* Make room for MUX header */
 	ASSERT(skb_headroom(skb) >= LMP_HEADER, return -1;);
 	skb_push(skb, LMP_HEADER);
-	
+
 	return irlmp_do_lsap_event(self, LM_DATA_REQUEST, skb);
 }
 
@@ -1058,7 +1055,7 @@
  *    Got data from LAP layer so pass it up to upper layer
  *
  */
-void irlmp_data_indication(struct lsap_cb *self, struct sk_buff *skb) 
+void irlmp_data_indication(struct lsap_cb *self, struct sk_buff *skb)
 {
 	/* Hide LMP header from layer above */
 	skb_pull(skb, LMP_HEADER);
@@ -1071,16 +1068,13 @@
 
 /*
  * Function irlmp_udata_request (self, skb)
- *
- *    
- *
  */
-int irlmp_udata_request(struct lsap_cb *self, struct sk_buff *skb) 
+int irlmp_udata_request(struct lsap_cb *self, struct sk_buff *skb)
 {
- 	IRDA_DEBUG(4, __FUNCTION__ "()\n"); 
+	IRDA_DEBUG(4, __FUNCTION__ "()\n");
 
 	ASSERT(skb != NULL, return -1;);
-	
+
 	/* Make room for MUX header */
 	ASSERT(skb_headroom(skb) >= LMP_HEADER, return -1;);
 	skb_push(skb, LMP_HEADER);
@@ -1094,9 +1088,9 @@
  *    Send unreliable data (but still within the connection)
  *
  */
-void irlmp_udata_indication(struct lsap_cb *self, struct sk_buff *skb) 
+void irlmp_udata_indication(struct lsap_cb *self, struct sk_buff *skb)
 {
- 	IRDA_DEBUG(4, __FUNCTION__ "()\n"); 
+	IRDA_DEBUG(4, __FUNCTION__ "()\n");
 
 	ASSERT(self != NULL, return;);
 	ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
@@ -1106,7 +1100,7 @@
 	skb_pull(skb, LMP_HEADER);
 
 	if (self->notify.udata_indication)
-		self->notify.udata_indication(self->notify.instance, self, 
+		self->notify.udata_indication(self->notify.instance, self,
 					      skb);
 	else
 		dev_kfree_skb(skb);
@@ -1114,23 +1108,20 @@
 
 /*
  * Function irlmp_connless_data_request (self, skb)
- *
- *    
- *
  */
 #ifdef CONFIG_IRDA_ULTRA
-int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *skb) 
+int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *skb)
 {
 	struct sk_buff *clone_skb;
 	struct lap_cb *lap;
 
- 	IRDA_DEBUG(4, __FUNCTION__ "()\n"); 
+	IRDA_DEBUG(4, __FUNCTION__ "()\n");
 
 	ASSERT(skb != NULL, return -1;);
-	
+
 	/* Make room for MUX and PID header */
 	ASSERT(skb_headroom(skb) >= LMP_HEADER+LMP_PID_HEADER, return -1;);
-	
+
 	/* Insert protocol identifier */
 	skb_push(skb, LMP_PID_HEADER);
 	skb->data[0] = self->pid;
@@ -1149,7 +1140,7 @@
 			return -ENOMEM;
 
 		irlap_unitdata_request(lap->irlap, clone_skb);
-		
+
 		lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
 	}
 	dev_kfree_skb(skb);
@@ -1165,9 +1156,9 @@
  *
  */
 #ifdef CONFIG_IRDA_ULTRA
-void irlmp_connless_data_indication(struct lsap_cb *self, struct sk_buff *skb) 
+void irlmp_connless_data_indication(struct lsap_cb *self, struct sk_buff *skb)
 {
- 	IRDA_DEBUG(4, __FUNCTION__ "()\n"); 
+	IRDA_DEBUG(4, __FUNCTION__ "()\n");
 
 	ASSERT(self != NULL, return;);
 	ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
@@ -1184,7 +1175,7 @@
 }
 #endif /* CONFIG_IRDA_ULTRA */
 
-void irlmp_status_request(void) 
+void irlmp_status_request(void)
 {
 	IRDA_DEBUG(0, __FUNCTION__ "(), Not implemented\n");
 }
@@ -1197,7 +1188,7 @@
  * Jean II
  */
 void irlmp_status_indication(struct lap_cb *self,
-			     LINK_STATUS link, LOCK_STATUS lock) 
+			     LINK_STATUS link, LOCK_STATUS lock)
 {
 	struct lsap_cb *next;
 	struct lsap_cb *curr;
@@ -1213,7 +1204,7 @@
 		 *  Inform service user if he has requested it
 		 */
 		if (curr->notify.status_indication != NULL)
-			curr->notify.status_indication(curr->notify.instance, 
+			curr->notify.status_indication(curr->notify.instance,
 						       link, lock);
 		else
 			IRDA_DEBUG(2, __FUNCTION__ "(), no handler\n");
@@ -1279,7 +1270,7 @@
 
 		/* Inform lsap user that it can send one more packet. */
 		if (curr->notify.flow_indication != NULL)
-			curr->notify.flow_indication(curr->notify.instance, 
+			curr->notify.flow_indication(curr->notify.instance,
 						     curr, flow);
 		else
 			IRDA_DEBUG(1, __FUNCTION__ "(), no handler\n");
@@ -1297,8 +1288,8 @@
 	__u8 *service;
 	int i = 0;
 
-	/* 
-	 * Allocate array to store services in. 16 entries should be safe 
+	/*
+	 * Allocate array to store services in. 16 entries should be safe
 	 * since we currently only support 2 hint bytes
 	 */
 	service = kmalloc(16, GFP_ATOMIC);
@@ -1327,10 +1318,10 @@
 	if (hint[0] & HINT_FAX)
 		IRDA_DEBUG(1, "Fax ");
 	if (hint[0] & HINT_LAN) {
-		IRDA_DEBUG(1, "LAN Access ");		
+		IRDA_DEBUG(1, "LAN Access ");
 		service[i++] = S_LAN;
 	}
-	/* 
+	/*
 	 *  Test if extension byte exists. This byte will usually be
 	 *  there, but this is not really required by the standard.
 	 *  (IrLMP p. 29)
@@ -1341,7 +1332,7 @@
 			service[i++] = S_TELEPHONY;
 		} if (hint[1] & HINT_FILE_SERVER)
 			IRDA_DEBUG(1, "File Server ");
-		
+
 		if (hint[1] & HINT_COMM) {
 			IRDA_DEBUG(1, "IrCOMM ");
 			service[i++] = S_COMM;
@@ -1357,7 +1348,7 @@
 	service[i++] = S_ANY;
 
 	service[i] = S_END;
-	
+
 	return service;
 }
 
@@ -1436,7 +1427,7 @@
 	irlmp->hints.word |= hints;
 
 	/* Make a new registration */
- 	service = kmalloc(sizeof(irlmp_service_t), GFP_ATOMIC);
+	service = kmalloc(sizeof(irlmp_service_t), GFP_ATOMIC);
 	if (!service) {
 		IRDA_DEBUG(1, __FUNCTION__ "(), Unable to kmalloc!\n");
 		return 0;
@@ -1450,19 +1441,19 @@
 /*
  * Function irlmp_unregister_service (handle)
  *
- *    Unregister service with IrLMP. 
+ *    Unregister service with IrLMP.
  *
  *    Returns: 0 on success, -1 on error
  */
 int irlmp_unregister_service(__u32 handle)
 {
 	irlmp_service_t *service;
-		
- 	IRDA_DEBUG(4, __FUNCTION__ "()\n");
+
+	IRDA_DEBUG(4, __FUNCTION__ "()\n");
 
 	if (!handle)
 		return -1;
- 
+
 	service = hashbin_find(irlmp->services, handle, NULL);
 	if (!service) {
 		IRDA_DEBUG(1, __FUNCTION__ "(), Unknown service!\n");
@@ -1503,14 +1494,14 @@
 
 	IRDA_DEBUG(1, __FUNCTION__ "()\n");
 	ASSERT(irlmp != NULL, return 0;);
-	
+
 	/* Get a unique handle for this client */
 	get_random_bytes(&handle, sizeof(handle));
 	while (hashbin_find(irlmp->clients, handle, NULL) || !handle)
 		get_random_bytes(&handle, sizeof(handle));
 
 	/* Make a new registration */
- 	client = kmalloc(sizeof(irlmp_client_t), GFP_ATOMIC);
+	client = kmalloc(sizeof(irlmp_client_t), GFP_ATOMIC);
 	if (!client) {
 		IRDA_DEBUG( 1, __FUNCTION__ "(), Unable to kmalloc!\n");
 		return 0;
@@ -1522,7 +1513,7 @@
 	client->expir_callback = expir_clb;
 	client->priv = priv;
 
- 	hashbin_insert(irlmp->clients, (irda_queue_t *) client, handle, NULL);
+	hashbin_insert(irlmp->clients, (irda_queue_t *) client, handle, NULL);
 
 	return handle;
 }
@@ -1535,8 +1526,8 @@
  *
  *    Returns: 0 on success, -1 on error
  */
-int irlmp_update_client(__u32 handle, __u16 hint_mask, 
-			DISCOVERY_CALLBACK1 disco_clb, 
+int irlmp_update_client(__u32 handle, __u16 hint_mask,
+			DISCOVERY_CALLBACK1 disco_clb,
 			DISCOVERY_CALLBACK1 expir_clb, void *priv)
 {
 	irlmp_client_t *client;
@@ -1554,7 +1545,7 @@
 	client->disco_callback = disco_clb;
 	client->expir_callback = expir_clb;
 	client->priv = priv;
-	
+
 	return 0;
 }
 
@@ -1566,13 +1557,13 @@
  */
 int irlmp_unregister_client(__u32 handle)
 {
- 	struct irlmp_client *client;
- 
- 	IRDA_DEBUG(4, __FUNCTION__ "()\n");
+	struct irlmp_client *client;
+
+	IRDA_DEBUG(4, __FUNCTION__ "()\n");
 
 	if (!handle)
 		return -1;
- 
+
 	client = hashbin_find(irlmp->clients, handle, NULL);
 	if (!client) {
 		IRDA_DEBUG(1, __FUNCTION__ "(), Unknown client!\n");
@@ -1583,7 +1574,7 @@
 	client = hashbin_remove( irlmp->clients, handle, NULL);
 	if (client)
 		kfree(client);
-	
+
 	return 0;
 }
 
@@ -1628,13 +1619,13 @@
 
 			if ((self->slsap_sel == slsap_sel)) {
 				IRDA_DEBUG(4, "Source LSAP selector=%02x in use\n",
-				      self->slsap_sel); 
+				      self->slsap_sel);
 				return TRUE;
 			}
 			self = (struct lsap_cb*) hashbin_get_next(lap->lsaps);
 		}
 		lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
-	}     
+	}
 	return FALSE;
 }
 
@@ -1644,16 +1635,16 @@
  *    Find a free source LSAP to use. This function is called if the service
  *    user has requested a source LSAP equal to LM_ANY
  */
-__u8 irlmp_find_free_slsap(void) 
+__u8 irlmp_find_free_slsap(void)
 {
 	__u8 lsap_sel;
 	int wrapped = 0;
 
 	ASSERT(irlmp != NULL, return -1;);
 	ASSERT(irlmp->magic == LMP_MAGIC, return -1;);
-      
+
 	lsap_sel = irlmp->free_lsap_sel++;
-	
+
 	/* Check if the new free lsap is really free */
 	while (irlmp_slsap_inuse(irlmp->free_lsap_sel)) {
 		irlmp->free_lsap_sel++;
@@ -1668,7 +1659,7 @@
 		}
 	}
 	IRDA_DEBUG(4, __FUNCTION__ "(), next free lsap_sel=%02x\n", lsap_sel);
-	
+
 	return lsap_sel;
 }
 
@@ -1683,7 +1674,7 @@
 {
 	int reason = LM_LAP_DISCONNECT;
 
-	switch (lap_reason) {		
+	switch (lap_reason) {
 	case LAP_DISC_INDICATION: /* Received a disconnect request from peer */
 		IRDA_DEBUG( 1, __FUNCTION__ "(), LAP_DISC_INDICATION\n");
 		reason = LM_USER_REQUEST;
@@ -1703,14 +1694,14 @@
 		reason = LM_CONNECT_FAILURE;
 		break;
 	default:
-		IRDA_DEBUG(1, __FUNCTION__ 
+		IRDA_DEBUG(1, __FUNCTION__
 		      "(), Unknow IrLAP disconnect reason %d!\n", lap_reason);
 		reason = LM_LAP_DISCONNECT;
 		break;
 	}
 
 	return reason;
-}	
+}
 
 __u32 irlmp_get_saddr(struct lsap_cb *self)
 {
@@ -1724,7 +1715,7 @@
 {
 	ASSERT(self != NULL, return 0;);
 	ASSERT(self->lap != NULL, return 0;);
-	
+
 	return self->lap->daddr;
 }
 
@@ -1742,37 +1733,37 @@
 	unsigned long flags;
 
 	ASSERT(irlmp != NULL, return 0;);
-	
+
 	save_flags( flags);
 	cli();
 
 	len = 0;
-	
+
 	len += sprintf( buf+len, "Unconnected LSAPs:\n");
 	self = (struct lsap_cb *) hashbin_get_first( irlmp->unconnected_lsaps);
 	while (self != NULL) {
 		ASSERT(self->magic == LMP_LSAP_MAGIC, return 0;);
-		len += sprintf(buf+len, "lsap state: %s, ", 
+		len += sprintf(buf+len, "lsap state: %s, ",
 			       irlsap_state[ self->lsap_state]);
-		len += sprintf(buf+len, 
+		len += sprintf(buf+len,
 			       "slsap_sel: %#02x, dlsap_sel: %#02x, ",
-			       self->slsap_sel, self->dlsap_sel); 
+			       self->slsap_sel, self->dlsap_sel);
 		len += sprintf(buf+len, "(%s)", self->notify.name);
 		len += sprintf(buf+len, "\n");
 
 		self = (struct lsap_cb *) hashbin_get_next(
 			irlmp->unconnected_lsaps);
- 	} 
+	}
 
 	len += sprintf(buf+len, "\nRegistred Link Layers:\n");
 
 	lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
 	while (lap != NULL) {
-		len += sprintf(buf+len, "lap state: %s, ", 
+		len += sprintf(buf+len, "lap state: %s, ",
 			       irlmp_state[lap->lap_state]);
 
 		len += sprintf(buf+len, "saddr: %#08x, daddr: %#08x, ",
-			       lap->saddr, lap->daddr); 
+			       lap->saddr, lap->daddr);
 		len += sprintf(buf+len, "num lsaps: %d",
 			       HASHBIN_GET_SIZE(lap->lsaps));
 		len += sprintf(buf+len, "\n");
@@ -1781,27 +1772,24 @@
 		self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
 		while (self != NULL) {
 			ASSERT(self->magic == LMP_LSAP_MAGIC, return 0;);
-			len += sprintf(buf+len, "  lsap state: %s, ", 
+			len += sprintf(buf+len, "  lsap state: %s, ",
 				       irlsap_state[ self->lsap_state]);
-			len += sprintf(buf+len, 
+			len += sprintf(buf+len,
 				       "slsap_sel: %#02x, dlsap_sel: %#02x, ",
 				       self->slsap_sel, self->dlsap_sel);
 			len += sprintf(buf+len, "(%s)", self->notify.name);
 			len += sprintf(buf+len, "\n");
-			
-			self = (struct lsap_cb *) hashbin_get_next( 
+
+			self = (struct lsap_cb *) hashbin_get_next(
 				lap->lsaps);
-		} 
+		}
 		len += sprintf(buf+len, "\n");
 
 		lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
- 	} 
+	}
 	restore_flags(flags);
-	
+
 	return len;
 }
 
 #endif /* PROC_FS */
-
-
-