Subject: [PATCH 1b/6] IrDA: irnet_irda.c identation (was Re: [PATCH 1/6] IrDA: IrNET code indentation)

From: Samuel Ortiz <[email-masked]>
Date: Wed, 14 Mar 2007 22:24:38 +0200

This is a split of: "[PATCH 1/6] IrDA: IrNET code indentation" for fitting
with netdev mail size limit.

The IrNET code was not exactly following the kernel coding style...
No functional changes, just an indentation fix.

Signed-off-by: Samuel Ortiz <[email-masked]>
---
 net/irda/irnet/irnet_irda.c | 2572 +++++++++++++++++++++----------------------
 1 files changed, 1275 insertions(+), 1297 deletions(-)

diff --git a/net/irda/irnet/irnet_irda.c b/net/irda/irnet/irnet_irda.c
index c378e66..c9e01a3 100644
--- a/net/irda/irnet/irnet_irda.c
+++ b/net/irda/irnet/irnet_irda.c
@@ -24,56 +24,53 @@
  * so they can read the log...
  */
 static void
-irnet_post_event(irnet_socket *	ap,
-		 irnet_event	event,
-		 __u32		saddr,
-		 __u32		daddr,
-		 char *		name,
-		 __u16		hints)
+irnet_post_event(irnet_socket * ap,
+		 irnet_event event,
+		 __u32 saddr, __u32 daddr, char *name, __u16 hints)
 {
-  int			index;		/* In the log */
-
-  DENTER(CTRL_TRACE, "(ap=0x%p, event=%d, daddr=%08x, name=``%s'')\n",
-	 ap, event, daddr, name);
-
-  /* Protect this section via spinlock.
-   * Note : as we are the only event producer, we only need to exclude
-   * ourself when touching the log, which is nice and easy.
-   */
-  spin_lock_bh(&irnet_events.spinlock);
-
-  /* Copy the event in the log */
-  index = irnet_events.index;
-  irnet_events.log[index].event = event;
-  irnet_events.log[index].daddr = daddr;
-  irnet_events.log[index].saddr = saddr;
-  /* Try to copy IrDA nickname */
-  if(name)
-    strcpy(irnet_events.log[index].name, name);
-  else
-    irnet_events.log[index].name[0] = '\0';
-  /* Copy hints */
-  irnet_events.log[index].hints.word = hints;
-  /* Try to get ppp unit number */
-  if((ap != (irnet_socket *) NULL) && (ap->ppp_open))
-    irnet_events.log[index].unit = ppp_unit_number(&ap->chan);
-  else
-    irnet_events.log[index].unit = -1;
-
-  /* Increment the index
-   * Note that we increment the index only after the event is written,
-   * to make sure that the readers don't get garbage... */
-  irnet_events.index = (index + 1) % IRNET_MAX_EVENTS;
-
-  DEBUG(CTRL_INFO, "New event index is %d\n", irnet_events.index);
-
-  /* Spin lock end */
-  spin_unlock_bh(&irnet_events.spinlock);
-
-  /* Now : wake up everybody waiting for events... */
-  wake_up_interruptible_all(&irnet_events.rwait);
-
-  DEXIT(CTRL_TRACE, "\n");
+	int index;		/* In the log */
+
+	DENTER(CTRL_TRACE, "(ap=0x%p, event=%d, daddr=%08x, name=``%s'')\n",
+	       ap, event, daddr, name);
+
+	/* Protect this section via spinlock.
+	 * Note : as we are the only event producer, we only need to exclude
+	 * ourself when touching the log, which is nice and easy.
+	 */
+	spin_lock_bh(&irnet_events.spinlock);
+
+	/* Copy the event in the log */
+	index = irnet_events.index;
+	irnet_events.log[index].event = event;
+	irnet_events.log[index].daddr = daddr;
+	irnet_events.log[index].saddr = saddr;
+	/* Try to copy IrDA nickname */
+	if (name)
+		strcpy(irnet_events.log[index].name, name);
+	else
+		irnet_events.log[index].name[0] = '\0';
+	/* Copy hints */
+	irnet_events.log[index].hints.word = hints;
+	/* Try to get ppp unit number */
+	if ((ap != (irnet_socket *) NULL) && (ap->ppp_open))
+		irnet_events.log[index].unit = ppp_unit_number(&ap->chan);
+	else
+		irnet_events.log[index].unit = -1;
+
+	/* Increment the index
+	 * Note that we increment the index only after the event is written,
+	 * to make sure that the readers don't get garbage... */
+	irnet_events.index = (index + 1) % IRNET_MAX_EVENTS;
+
+	DEBUG(CTRL_INFO, "New event index is %d\n", irnet_events.index);
+
+	/* Spin lock end */
+	spin_unlock_bh(&irnet_events.spinlock);
+
+	/* Now : wake up everybody waiting for events... */
+	wake_up_interruptible_all(&irnet_events.rwait);
+
+	DEXIT(CTRL_TRACE, "\n");
 }
 
 /************************* IRDA SUBROUTINES *************************/
@@ -95,39 +92,38 @@ irnet_post_event(irnet_socket *	ap,
  *
  * Create a IrTTP instance for us and set all the IrTTP callbacks.
  */
-static inline int
-irnet_open_tsap(irnet_socket *	self)
+static inline int irnet_open_tsap(irnet_socket * self)
 {
-  notify_t	notify;		/* Callback structure */
-
-  DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
-
-  DABORT(self->tsap != NULL, -EBUSY, IRDA_SR_ERROR, "Already busy !\n");
-
-  /* Initialize IrTTP callbacks to be used by the IrDA stack */
-  irda_notify_init(&notify);
-  notify.connect_confirm	= irnet_connect_confirm;
-  notify.connect_indication	= irnet_connect_indication;
-  notify.disconnect_indication	= irnet_disconnect_indication;
-  notify.data_indication	= irnet_data_indication;
-  /*notify.udata_indication	= NULL;*/
-  notify.flow_indication	= irnet_flow_indication;
-  notify.status_indication	= irnet_status_indication;
-  notify.instance		= self;
-  strlcpy(notify.name, IRNET_NOTIFY_NAME, sizeof(notify.name));
-
-  /* Open an IrTTP instance */
-  self->tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT,
-			       &notify);
-  DABORT(self->tsap == NULL, -ENOMEM,
-	 IRDA_SR_ERROR, "Unable to allocate TSAP !\n");
-
-  /* Remember which TSAP selector we actually got */
-  self->stsap_sel = self->tsap->stsap_sel;
-
-  DEXIT(IRDA_SR_TRACE, " - tsap=0x%p, sel=0x%X\n",
-	self->tsap, self->stsap_sel);
-  return 0;
+	notify_t notify;	/* Callback structure */
+
+	DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
+
+	DABORT(self->tsap != NULL, -EBUSY, IRDA_SR_ERROR, "Already busy !\n");
+
+	/* Initialize IrTTP callbacks to be used by the IrDA stack */
+	irda_notify_init(&notify);
+	notify.connect_confirm = irnet_connect_confirm;
+	notify.connect_indication = irnet_connect_indication;
+	notify.disconnect_indication = irnet_disconnect_indication;
+	notify.data_indication = irnet_data_indication;
+	/*notify.udata_indication     = NULL; */
+	notify.flow_indication = irnet_flow_indication;
+	notify.status_indication = irnet_status_indication;
+	notify.instance = self;
+	strlcpy(notify.name, IRNET_NOTIFY_NAME, sizeof(notify.name));
+
+	/* Open an IrTTP instance */
+	self->tsap = irttp_open_tsap(LSAP_ANY,
+				     DEFAULT_INITIAL_CREDIT, &notify);
+	DABORT(self->tsap == NULL, -ENOMEM,
+	       IRDA_SR_ERROR, "Unable to allocate TSAP !\n");
+
+	/* Remember which TSAP selector we actually got */
+	self->stsap_sel = self->tsap->stsap_sel;
+
+	DEXIT(IRDA_SR_TRACE, " - tsap=0x%p, sel=0x%X\n",
+	      self->tsap, self->stsap_sel);
+	return 0;
 }
 
 /*------------------------------------------------------------------*/
@@ -145,75 +141,70 @@ irnet_open_tsap(irnet_socket *	self)
  * Return TSAP or -1
  */
 static inline __u8
-irnet_ias_to_tsap(irnet_socket *	self,
-		  int			result,
-		  struct ias_value *	value)
+irnet_ias_to_tsap(irnet_socket * self, int result, struct ias_value *value)
 {
-  __u8	dtsap_sel = 0;		/* TSAP we are looking for */
-
-  DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
-
-  /* By default, no error */
-  self->errno = 0;
-
-  /* Check if request succeeded */
-  switch(result)
-    {
-      /* Standard errors : service not available */
-    case IAS_CLASS_UNKNOWN:
-    case IAS_ATTRIB_UNKNOWN:
-      DEBUG(IRDA_SR_INFO, "IAS object doesn't exist ! (%d)\n", result);
-      self->errno = -EADDRNOTAVAIL;
-      break;
-
-      /* Other errors, most likely IrDA stack failure */
-    default :
-      DEBUG(IRDA_SR_INFO, "IAS query failed ! (%d)\n", result);
-      self->errno = -EHOSTUNREACH;
-      break;
-
-      /* Success : we got what we wanted */
-    case IAS_SUCCESS:
-      break;
-    }
-
-  /* Check what was returned to us */
-  if(value != NULL)
-    {
-      /* What type of argument have we got ? */
-      switch(value->type)
-	{
-	case IAS_INTEGER:
-	  DEBUG(IRDA_SR_INFO, "result=%d\n", value->t.integer);
-	  if(value->t.integer != -1)
-	    /* Get the remote TSAP selector */
-	    dtsap_sel = value->t.integer;
-	  else
-	    self->errno = -EADDRNOTAVAIL;
-	  break;
+	__u8 dtsap_sel = 0;	/* TSAP we are looking for */
+
+	DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
+
+	/* By default, no error */
+	self->errno = 0;
+
+	/* Check if request succeeded */
+	switch (result) {
+		/* Standard errors : service not available */
+	case IAS_CLASS_UNKNOWN:
+	case IAS_ATTRIB_UNKNOWN:
+		DEBUG(IRDA_SR_INFO, "IAS object doesn't exist ! (%d)\n",
+		      result);
+		self->errno = -EADDRNOTAVAIL;
+		break;
+
+		/* Other errors, most likely IrDA stack failure */
 	default:
-	  self->errno = -EADDRNOTAVAIL;
-	  DERROR(IRDA_SR_ERROR, "bad type ! (0x%X)\n", value->type);
-	  break;
+		DEBUG(IRDA_SR_INFO, "IAS query failed ! (%d)\n", result);
+		self->errno = -EHOSTUNREACH;
+		break;
+
+		/* Success : we got what we wanted */
+	case IAS_SUCCESS:
+		break;
 	}
 
-      /* Cleanup */
-      irias_delete_value(value);
-    }
-  else	/* value == NULL */
-    {
-      /* Nothing returned to us - usually result != SUCCESS */
-      if(!(self->errno))
-	{
-	  DERROR(IRDA_SR_ERROR,
-		 "IrDA bug : result == SUCCESS && value == NULL\n");
-	  self->errno = -EHOSTUNREACH;
+	/* Check what was returned to us */
+	if (value != NULL) {
+		/* What type of argument have we got ? */
+		switch (value->type) {
+		case IAS_INTEGER:
+			DEBUG(IRDA_SR_INFO, "result=%d\n", value->t.integer);
+			if (value->t.integer != -1)
+				/* Get the remote TSAP selector */
+				dtsap_sel = value->t.integer;
+			else
+				self->errno = -EADDRNOTAVAIL;
+			break;
+		default:
+			self->errno = -EADDRNOTAVAIL;
+			DERROR(IRDA_SR_ERROR, "bad type ! (0x%X)\n",
+			       value->type);
+			break;
+		}
+
+		/* Cleanup */
+		irias_delete_value(value);
+	} else {		/* value == NULL */
+
+		/* Nothing returned to us - usually result != SUCCESS */
+		if (!(self->errno)) {
+			DERROR(IRDA_SR_ERROR,
+			       "IrDA bug : result == SUCCESS && value == NULL\n");
+			self->errno = -EHOSTUNREACH;
+		}
 	}
-    }
-  DEXIT(IRDA_SR_TRACE, "\n");
+	DEXIT(IRDA_SR_TRACE, "\n");
 
-  /* Return the TSAP */
-  return(dtsap_sel);
+	/* Return the TSAP */
+	return (dtsap_sel);
 }
 
 /*------------------------------------------------------------------*/
@@ -228,32 +219,34 @@ irnet_ias_to_tsap(irnet_socket *	self,
  * Note that in some case, the query fail even before we go to sleep,
  * creating some races...
  */
-static inline int
-irnet_find_lsap_sel(irnet_socket *	self)
+static inline int irnet_find_lsap_sel(irnet_socket * self)
 {
-  DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
+	DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
 
-  /* This should not happen */
-  DABORT(self->iriap, -EBUSY, IRDA_SR_ERROR, "busy with a previous query.\n");
+	/* This should not happen */
+	DABORT(self->iriap, -EBUSY, IRDA_SR_ERROR,
+	       "busy with a previous query.\n");
 
-  /* Create an IAP instance, will be closed in irnet_getvalue_confirm() */
-  self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
-			   irnet_getvalue_confirm);
+	/*
+	 * Create an IAP instance, will be closed in irnet_getvalue_confirm()
+	 */
+	self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
+				 irnet_getvalue_confirm);
 
-  /* Treat unexpected signals as disconnect */
-  self->errno = -EHOSTUNREACH;
+	/* Treat unexpected signals as disconnect */
+	self->errno = -EHOSTUNREACH;
 
-  /* Query remote LM-IAS */
-  iriap_getvaluebyclass_request(self->iriap, self->rsaddr, self->daddr,
-				IRNET_SERVICE_NAME, IRNET_IAS_VALUE);
+	/* Query remote LM-IAS */
+	iriap_getvaluebyclass_request(self->iriap, self->rsaddr, self->daddr,
+				      IRNET_SERVICE_NAME, IRNET_IAS_VALUE);
 
-  /* The above request is non-blocking.
-   * After a while, IrDA will call us back in irnet_getvalue_confirm()
-   * We will then call irnet_ias_to_tsap() and finish the
-   * connection procedure */
+	/* The above request is non-blocking.
+	 * After a while, IrDA will call us back in irnet_getvalue_confirm()
+	 * We will then call irnet_ias_to_tsap() and finish the
+	 * connection procedure */
 
-  DEXIT(IRDA_SR_TRACE, "\n");
-  return 0;
+	DEXIT(IRDA_SR_TRACE, "\n");
+	return 0;
 }
 
 /*------------------------------------------------------------------*/
@@ -263,40 +256,37 @@ irnet_find_lsap_sel(irnet_socket *	self)
  *    Initialise the TTP socket and initiate TTP connection
  *
  */
-static inline int
-irnet_connect_tsap(irnet_socket *	self)
+static inline int irnet_connect_tsap(irnet_socket * self)
 {
-  int		err;
-
-  DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
-
-  /* Open a local TSAP (an IrTTP instance) */
-  err = irnet_open_tsap(self);
-  if(err != 0)
-    {
-      clear_bit(0, &self->ttp_connect);
-      DERROR(IRDA_SR_ERROR, "connect aborted!\n");
-      return(err);
-    }
-
-  /* Connect to remote device */
-  err = irttp_connect_request(self->tsap, self->dtsap_sel,
-			      self->rsaddr, self->daddr, NULL,
-			      self->max_sdu_size_rx, NULL);
-  if(err != 0)
-    {
-      clear_bit(0, &self->ttp_connect);
-      DERROR(IRDA_SR_ERROR, "connect aborted!\n");
-      return(err);
-    }
-
-  /* The above call is non-blocking.
-   * After a while, the IrDA stack will either call us back in
-   * irnet_connect_confirm() or irnet_disconnect_indication()
-   * See you there ;-) */
-
-  DEXIT(IRDA_SR_TRACE, "\n");
-  return(err);
+	int err;
+
+	DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
+
+	/* Open a local TSAP (an IrTTP instance) */
+	err = irnet_open_tsap(self);
+	if (err != 0) {
+		clear_bit(0, &self->ttp_connect);
+		DERROR(IRDA_SR_ERROR, "connect aborted!\n");
+		return (err);
+	}
+
+	/* Connect to remote device */
+	err = irttp_connect_request(self->tsap, self->dtsap_sel,
+				    self->rsaddr, self->daddr, NULL,
+				    self->max_sdu_size_rx, NULL);
+	if (err != 0) {
+		clear_bit(0, &self->ttp_connect);
+		DERROR(IRDA_SR_ERROR, "connect aborted!\n");
+		return (err);
+	}
+
+	/* The above call is non-blocking.
+	 * After a while, the IrDA stack will either call us back in
+	 * irnet_connect_confirm() or irnet_disconnect_indication()
+	 * See you there ;-) */
+
+	DEXIT(IRDA_SR_TRACE, "\n");
+	return (err);
 }
 
 /*------------------------------------------------------------------*/
@@ -307,40 +297,42 @@ irnet_connect_tsap(irnet_socket *	self)
  *
  * Used in the TSAP discovery procedure.
  */
-static inline int
-irnet_discover_next_daddr(irnet_socket *	self)
+static inline int irnet_discover_next_daddr(irnet_socket * self)
 {
-  /* Close the last instance of IrIAP, and open a new one.
-   * We can't reuse the IrIAP instance in the IrIAP callback */
-  if(self->iriap)
-    {
-      iriap_close(self->iriap);
-      self->iriap = NULL;
-    }
-  /* Create a new IAP instance */
-  self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
-			   irnet_discovervalue_confirm);
-  if(self->iriap == NULL)
-    return -ENOMEM;
-
-  /* Next discovery - before the call to avoid races */
-  self->disco_index++;
-
-  /* Check if we have one more address to try */
-  if(self->disco_index < self->disco_number)
-    {
-      /* Query remote LM-IAS */
-      iriap_getvaluebyclass_request(self->iriap,
-				    self->discoveries[self->disco_index].saddr,
-				    self->discoveries[self->disco_index].daddr,
-				    IRNET_SERVICE_NAME, IRNET_IAS_VALUE);
-      /* The above request is non-blocking.
-       * After a while, IrDA will call us back in irnet_discovervalue_confirm()
-       * We will then call irnet_ias_to_tsap() and come back here again... */
-      return(0);
-    }
-  else
-    return(1);
+	/* Close the last instance of IrIAP, and open a new one.
+	 * We can't reuse the IrIAP instance in the IrIAP callback */
+	if (self->iriap) {
+		iriap_close(self->iriap);
+		self->iriap = NULL;
+	}
+	/* Create a new IAP instance */
+	self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
+				 irnet_discovervalue_confirm);
+	if (self->iriap == NULL)
+		return -ENOMEM;
+
+	/* Next discovery - before the call to avoid races */
+	self->disco_index++;
+
+	/* Check if we have one more address to try */
+	if (self->disco_index < self->disco_number) {
+		/* Query remote LM-IAS */
+		iriap_getvaluebyclass_request(self->iriap,
+					      self->discoveries[self->
+								disco_index].
+					      saddr,
+					      self->discoveries[self->
+								disco_index].
+					      daddr, IRNET_SERVICE_NAME,
+					      IRNET_IAS_VALUE);
+		/* The above request is non-blocking.
+		 * After a while, IrDA will call us back in
+		 * irnet_discovervalue_confirm(). We will
+		 * then call irnet_ias_to_tsap() and come back here again...
+		 */
+		return (0);
+	} else
+		return (1);
 }
 
 /*------------------------------------------------------------------*/
@@ -366,52 +358,50 @@ irnet_discover_next_daddr(irnet_socket *	self)
  * last LSAP is closed. Moreover, we would need to wait the LAP
  * disconnection...
  */
-static inline int
-irnet_discover_daddr_and_lsap_sel(irnet_socket *	self)
+static inline int irnet_discover_daddr_and_lsap_sel(irnet_socket * self)
 {
-  int	ret;
+	int ret;
 
-  DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
+	DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
 
-  /* Ask lmp for the current discovery log */
-  self->discoveries = irlmp_get_discoveries(&self->disco_number, self->mask,
-					    DISCOVERY_DEFAULT_SLOTS);
+	/* Ask lmp for the current discovery log */
+	self->discoveries =
+	    irlmp_get_discoveries(&self->disco_number, self->mask,
+				  DISCOVERY_DEFAULT_SLOTS);
 
-  /* Check if the we got some results */
-  if(self->discoveries == NULL)
-    {
-      self->disco_number = -1;
-      clear_bit(0, &self->ttp_connect);
-      DRETURN(-ENETUNREACH, IRDA_SR_INFO, "No Cachelog...\n");
-    }
-  DEBUG(IRDA_SR_INFO, "Got the log (0x%p), size is %d\n",
-	self->discoveries, self->disco_number);
-
-  /* Start with the first discovery */
-  self->disco_index = -1;
-  self->daddr = DEV_ADDR_ANY;
-
-  /* This will fail if the log is empty - this is non-blocking */
-  ret = irnet_discover_next_daddr(self);
-  if(ret)
-    {
-      /* Close IAP */
-      if(self->iriap)
-	iriap_close(self->iriap);
-      self->iriap = NULL;
-
-      /* Cleanup our copy of the discovery log */
-      kfree(self->discoveries);
-      self->discoveries = NULL;
-
-      clear_bit(0, &self->ttp_connect);
-      DRETURN(-ENETUNREACH, IRDA_SR_INFO, "Cachelog empty...\n");
-    }
+	/* Check if the we got some results */
+	if (self->discoveries == NULL) {
+		self->disco_number = -1;
+		clear_bit(0, &self->ttp_connect);
+		DRETURN(-ENETUNREACH, IRDA_SR_INFO, "No Cachelog...\n");
+	}
+	DEBUG(IRDA_SR_INFO, "Got the log (0x%p), size is %d\n",
+	      self->discoveries, self->disco_number);
+
+	/* Start with the first discovery */
+	self->disco_index = -1;
+	self->daddr = DEV_ADDR_ANY;
+
+	/* This will fail if the log is empty - this is non-blocking */
+	ret = irnet_discover_next_daddr(self);
+	if (ret) {
+		/* Close IAP */
+		if (self->iriap)
+			iriap_close(self->iriap);
+		self->iriap = NULL;
+
+		/* Cleanup our copy of the discovery log */
+		kfree(self->discoveries);
+		self->discoveries = NULL;
+
+		clear_bit(0, &self->ttp_connect);
+		DRETURN(-ENETUNREACH, IRDA_SR_INFO, "Cachelog empty...\n");
+	}
 
-  /* Follow me in irnet_discovervalue_confirm() */
+	/* Follow me in irnet_discovervalue_confirm() */
 
-  DEXIT(IRDA_SR_TRACE, "\n");
-  return(0);
+	DEXIT(IRDA_SR_TRACE, "\n");
+	return (0);
 }
 
 /*------------------------------------------------------------------*/
@@ -422,48 +412,47 @@ irnet_discover_daddr_and_lsap_sel(irnet_socket *	self)
  *
  * It basically look into the discovery log until there is a match.
  */
-static inline int
-irnet_dname_to_daddr(irnet_socket *	self)
+static inline int irnet_dname_to_daddr(irnet_socket * self)
 {
-  struct irda_device_info *discoveries;	/* Copy of the discovery log */
-  int	number;			/* Number of nodes in the log */
-  int	i;
-
-  DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
-
-  /* Ask lmp for the current discovery log */
-  discoveries = irlmp_get_discoveries(&number, 0xffff,
-				      DISCOVERY_DEFAULT_SLOTS);
-  /* Check if the we got some results */
-  if(discoveries == NULL)
-    DRETURN(-ENETUNREACH, IRDA_SR_INFO, "Cachelog empty...\n");
-
-  /*
-   * Now, check all discovered devices (if any), and connect
-   * client only about the services that the client is
-   * interested in...
-   */
-  for(i = 0; i < number; i++)
-    {
-      /* Does the name match ? */
-      if(!strncmp(discoveries[i].info, self->rname, NICKNAME_MAX_LEN))
-	{
-	  /* Yes !!! Get it.. */
-	  self->daddr = discoveries[i].daddr;
-	  DEBUG(IRDA_SR_INFO, "discovered device ``%s'' at address 0x%08x.\n",
-		self->rname, self->daddr);
-	  kfree(discoveries);
-	  DEXIT(IRDA_SR_TRACE, "\n");
-	  return 0;
+	struct irda_device_info *discoveries;	/* Copy of the discovery log */
+	int number;		/* Number of nodes in the log */
+	int i;
+
+	DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
+
+	/* Ask lmp for the current discovery log */
+	discoveries = irlmp_get_discoveries(&number, 0xffff,
+					    DISCOVERY_DEFAULT_SLOTS);
+	/* Check if the we got some results */
+	if (discoveries == NULL)
+		DRETURN(-ENETUNREACH, IRDA_SR_INFO, "Cachelog empty...\n");
+
+	/*
+	 * Now, check all discovered devices (if any), and connect
+	 * client only about the services that the client is
+	 * interested in...
+	 */
+	for (i = 0; i < number; i++) {
+		/* Does the name match ? */
+		if (!strncmp
+		    (discoveries[i].info, self->rname, NICKNAME_MAX_LEN)) {
+			/* Yes !!! Get it.. */
+			self->daddr = discoveries[i].daddr;
+			DEBUG(IRDA_SR_INFO,
+			      "discovered device ``%s'' at address 0x%08x.\n",
+			      self->rname, self->daddr);
+			kfree(discoveries);
+			DEXIT(IRDA_SR_TRACE, "\n");
+			return 0;
+		}
 	}
-    }
-  /* No luck ! */
-  DEBUG(IRDA_SR_INFO, "cannot discover device ``%s'' !!!\n", self->rname);
-  kfree(discoveries);
-  return(-EADDRNOTAVAIL);
+	/* No luck ! */
+	DEBUG(IRDA_SR_INFO, "cannot discover device ``%s'' !!!\n",
+	      self->rname);
+	kfree(discoveries);
+	return (-EADDRNOTAVAIL);
 }
 
-
 /************************* SOCKET ROUTINES *************************/
 /*
  * This are the main operations on IrNET sockets, basically to create
@@ -474,33 +463,32 @@ irnet_dname_to_daddr(irnet_socket *	self)
 /*
  * Create a IrNET instance : just initialise some parameters...
  */
-int
-irda_irnet_create(irnet_socket *	self)
+int irda_irnet_create(irnet_socket * self)
 {
-  DENTER(IRDA_SOCK_TRACE, "(self=0x%p)\n", self);
+	DENTER(IRDA_SOCK_TRACE, "(self=0x%p)\n", self);
 
-  self->magic = IRNET_MAGIC;	/* Paranoia */
+	self->magic = IRNET_MAGIC;	/* Paranoia */
 
-  self->ttp_open = 0;		/* Prevent higher layer from accessing IrTTP */
-  self->ttp_connect = 0;	/* Not connecting yet */
-  self->rname[0] = '\0';	/* May be set via control channel */
-  self->rdaddr = DEV_ADDR_ANY;	/* May be set via control channel */
-  self->rsaddr = DEV_ADDR_ANY;	/* May be set via control channel */
-  self->daddr = DEV_ADDR_ANY;	/* Until we get connected */
-  self->saddr = DEV_ADDR_ANY;	/* Until we get connected */
-  self->max_sdu_size_rx = TTP_SAR_UNBOUND;
+	self->ttp_open = 0;	/* Prevent higher layer from accessing IrTTP */
+	self->ttp_connect = 0;	/* Not connecting yet */
+	self->rname[0] = '\0';	/* May be set via control channel */
+	self->rdaddr = DEV_ADDR_ANY;	/* May be set via control channel */
+	self->rsaddr = DEV_ADDR_ANY;	/* May be set via control channel */
+	self->daddr = DEV_ADDR_ANY;	/* Until we get connected */
+	self->saddr = DEV_ADDR_ANY;	/* Until we get connected */
+	self->max_sdu_size_rx = TTP_SAR_UNBOUND;
 
-  /* Register as a client with IrLMP */
-  self->ckey = irlmp_register_client(0, NULL, NULL, NULL);
+	/* Register as a client with IrLMP */
+	self->ckey = irlmp_register_client(0, NULL, NULL, NULL);
 #ifdef DISCOVERY_NOMASK
-  self->mask = 0xffff;		/* For W2k compatibility */
-#else /* DISCOVERY_NOMASK */
-  self->mask = irlmp_service_to_hint(S_LAN);
-#endif /* DISCOVERY_NOMASK */
-  self->tx_flow = FLOW_START;	/* Flow control from IrTTP */
-
-  DEXIT(IRDA_SOCK_TRACE, "\n");
-  return(0);
+	self->mask = 0xffff;	/* For W2k compatibility */
+#else				/* DISCOVERY_NOMASK */
+	self->mask = irlmp_service_to_hint(S_LAN);
+#endif				/* DISCOVERY_NOMASK */
+	self->tx_flow = FLOW_START;	/* Flow control from IrTTP */
+
+	DEXIT(IRDA_SOCK_TRACE, "\n");
+	return (0);
 }
 
 /*------------------------------------------------------------------*/
@@ -516,65 +504,69 @@ irda_irnet_create(irnet_socket *	self)
  * The downside is that following what's happening in there is tricky
  * because it involve various functions all over the place...
  */
-int
-irda_irnet_connect(irnet_socket *	self)
+int irda_irnet_connect(irnet_socket * self)
 {
-  int		err;
-
-  DENTER(IRDA_SOCK_TRACE, "(self=0x%p)\n", self);
-
-  /* Check if we are already trying to connect.
-   * Because irda_irnet_connect() can be called directly by pppd plus
-   * packet retries in ppp_generic and connect may take time, plus we may
-   * race with irnet_connect_indication(), we need to be careful there... */
-  if(test_and_set_bit(0, &self->ttp_connect))
-    DRETURN(-EBUSY, IRDA_SOCK_INFO, "Already connecting...\n");
-  if((self->iriap != NULL) || (self->tsap != NULL))
-    DERROR(IRDA_SOCK_ERROR, "Socket not cleaned up...\n");
-
-  /* Insert ourselves in the hashbin so that the IrNET server can find us.
-   * Notes : 4th arg is string of 32 char max and must be null terminated
-   *	     When 4th arg is used (string), 3rd arg isn't (int)
-   *	     Can't re-insert (MUST remove first) so check for that... */
-  if((irnet_server.running) && (self->q.q_next == NULL))
-    {
-      spin_lock_bh(&irnet_server.spinlock);
-      hashbin_insert(irnet_server.list, (irda_queue_t *) self, 0, self->rname);
-      spin_unlock_bh(&irnet_server.spinlock);
-      DEBUG(IRDA_SOCK_INFO, "Inserted ``%s'' in hashbin...\n", self->rname);
-    }
-
-  /* If we don't have anything (no address, no name) */
-  if((self->rdaddr == DEV_ADDR_ANY) && (self->rname[0] == '\0'))
-    {
-      /* Try to find a suitable address */
-      if((err = irnet_discover_daddr_and_lsap_sel(self)) != 0)
-	DRETURN(err, IRDA_SOCK_INFO, "auto-connect failed!\n");
-      /* In most cases, the call above is non-blocking */
-    }
-  else
-    {
-      /* If we have only the name (no address), try to get an address */
-      if(self->rdaddr == DEV_ADDR_ANY)
-	{
-	  if((err = irnet_dname_to_daddr(self)) != 0)
-	    DRETURN(err, IRDA_SOCK_INFO, "name connect failed!\n");
+	int err;
+
+	DENTER(IRDA_SOCK_TRACE, "(self=0x%p)\n", self);
+
+	/*
+	 * Check if we are already trying to connect.
+	 * Because irda_irnet_connect() can be called directly by pppd plus
+	 * packet retries in ppp_generic and connect may take time, plus we may
+	 * race with irnet_connect_indication(), we need to be careful
+	 * there...
+	 */
+	if (test_and_set_bit(0, &self->ttp_connect))
+		DRETURN(-EBUSY, IRDA_SOCK_INFO, "Already connecting...\n");
+	if ((self->iriap != NULL) || (self->tsap != NULL))
+		DERROR(IRDA_SOCK_ERROR, "Socket not cleaned up...\n");
+
+	/*
+	 * Insert ourselves in the hashbin so that the IrNET server
+	 * can find us.
+	 * Notes : 4th arg is string of 32 char max and must be null terminated
+	 *         When 4th arg is used (string), 3rd arg isn't (int)
+	 *         Can't re-insert (MUST remove first) so check for that...
+	 */
+	if ((irnet_server.running) && (self->q.q_next == NULL)) {
+		spin_lock_bh(&irnet_server.spinlock);
+		hashbin_insert(irnet_server.list, (irda_queue_t *) self, 0,
+			       self->rname);
+		spin_unlock_bh(&irnet_server.spinlock);
+		DEBUG(IRDA_SOCK_INFO, "Inserted ``%s'' in hashbin...\n",
+		      self->rname);
+	}
+
+	/* If we don't have anything (no address, no name) */
+	if ((self->rdaddr == DEV_ADDR_ANY) && (self->rname[0] == '\0')) {
+		/* Try to find a suitable address */
+		if ((err = irnet_discover_daddr_and_lsap_sel(self)) != 0)
+			DRETURN(err, IRDA_SOCK_INFO, "auto-connect failed!\n");
+		/* In most cases, the call above is non-blocking */
+	} else {
+		/* If we have only the name (no address),
+		 * try to get an address
+		 */
+		if (self->rdaddr == DEV_ADDR_ANY) {
+			if ((err = irnet_dname_to_daddr(self)) != 0)
+				DRETURN(err, IRDA_SOCK_INFO,
+					"name connect failed!\n");
+		} else
+			/* Use the requested destination address */
+			self->daddr = self->rdaddr;
+
+		/* Query remote LM-IAS to find LSAP selector */
+		irnet_find_lsap_sel(self);
+		/* The above call is non blocking */
 	}
-      else
-	/* Use the requested destination address */
-	self->daddr = self->rdaddr;
-
-      /* Query remote LM-IAS to find LSAP selector */
-      irnet_find_lsap_sel(self);
-      /* The above call is non blocking */
-    }
-
-  /* At this point, we are waiting for the IrDA stack to call us back,
-   * or we have already failed.
-   * We will finish the connection procedure in irnet_connect_tsap().
-   */
-  DEXIT(IRDA_SOCK_TRACE, "\n");
-  return(0);
+
+	/* At this point, we are waiting for the IrDA stack to call us back,
+	 * or we have already failed.
+	 * We will finish the connection procedure in irnet_connect_tsap().
+	 */
+	DEXIT(IRDA_SOCK_TRACE, "\n");
+	return (0);
 }
 
 /*------------------------------------------------------------------*/
@@ -585,75 +577,79 @@ irda_irnet_connect(irnet_socket *	self)
  *
  * Note : this need to be called from a process context.
  */
-void
-irda_irnet_destroy(irnet_socket *	self)
+void irda_irnet_destroy(irnet_socket * self)
 {
-  DENTER(IRDA_SOCK_TRACE, "(self=0x%p)\n", self);
-  if(self == NULL)
-    return;
-
-  /* Remove ourselves from hashbin (if we are queued in hashbin)
-   * Note : `irnet_server.running' protect us from calls in hashbin_delete() */
-  if((irnet_server.running) && (self->q.q_next != NULL))
-    {
-      struct irnet_socket *	entry;
-      DEBUG(IRDA_SOCK_INFO, "Removing from hash..\n");
-      spin_lock_bh(&irnet_server.spinlock);
-      entry = hashbin_remove_this(irnet_server.list, (irda_queue_t *) self);
-      self->q.q_next = NULL;
-      spin_unlock_bh(&irnet_server.spinlock);
-      DASSERT(entry == self, , IRDA_SOCK_ERROR, "Can't remove from hash.\n");
-    }
-
-  /* If we were connected, post a message */
-  if(test_bit(0, &self->ttp_open))
-    {
-      /* Note : as the disconnect comes from ppp_generic, the unit number
-       * doesn't exist anymore when we post the event, so we need to pass
-       * NULL as the first arg... */
-      irnet_post_event(NULL, IRNET_DISCONNECT_TO,
-		       self->saddr, self->daddr, self->rname, 0);
-    }
-
-  /* Prevent various IrDA callbacks from messing up things
-   * Need to be first */
-  clear_bit(0, &self->ttp_connect);
-
-  /* Prevent higher layer from accessing IrTTP */
-  clear_bit(0, &self->ttp_open);
-
-  /* Unregister with IrLMP */
-  irlmp_unregister_client(self->ckey);
-
-  /* Unregister with LM-IAS */
-  if(self->iriap)
-    {
-      iriap_close(self->iriap);
-      self->iriap = NULL;
-    }
-
-  /* Cleanup eventual discoveries from connection attempt or control channel */
-  if(self->discoveries != NULL)
-    {
-      /* Cleanup our copy of the discovery log */
-      kfree(self->discoveries);
-      self->discoveries = NULL;
-    }
-
-  /* Close our IrTTP connection */
-  if(self->tsap)
-    {
-      DEBUG(IRDA_SOCK_INFO, "Closing our TTP connection.\n");
-      irttp_disconnect_request(self->tsap, NULL, P_NORMAL);
-      irttp_close_tsap(self->tsap);
-      self->tsap = NULL;
-    }
-  self->stsap_sel = 0;
-
-  DEXIT(IRDA_SOCK_TRACE, "\n");
-  return;
-}
+	DENTER(IRDA_SOCK_TRACE, "(self=0x%p)\n", self);
+	if (self == NULL)
+		return;
+
+	/*
+	 * Remove ourselves from hashbin (if we are queued in hashbin)
+	 * Note : `irnet_server.running' protect us from calls in
+	 * hashbin_delete()
+	 */
+	if ((irnet_server.running) && (self->q.q_next != NULL)) {
+		struct irnet_socket *entry;
+		DEBUG(IRDA_SOCK_INFO, "Removing from hash..\n");
+		spin_lock_bh(&irnet_server.spinlock);
+		entry =
+		    hashbin_remove_this(irnet_server.list,
+					(irda_queue_t *) self);
+		self->q.q_next = NULL;
+		spin_unlock_bh(&irnet_server.spinlock);
+		DASSERT(entry == self,, IRDA_SOCK_ERROR,
+			"Can't remove from hash.\n");
+	}
+
+	/* If we were connected, post a message */
+	if (test_bit(0, &self->ttp_open)) {
+		/*
+		 * Note : as the disconnect comes from ppp_generic,
+		 * the unit number doesn't exist anymore when we post
+		 * the event, so we need to pas NULL as the first arg...
+		 */
+		irnet_post_event(NULL, IRNET_DISCONNECT_TO,
+				 self->saddr, self->daddr, self->rname, 0);
+	}
+
+	/* Prevent various IrDA callbacks from messing up things
+	 * Need to be first */
+	clear_bit(0, &self->ttp_connect);
+
+	/* Prevent higher layer from accessing IrTTP */
+	clear_bit(0, &self->ttp_open);
 
+	/* Unregister with IrLMP */
+	irlmp_unregister_client(self->ckey);
+
+	/* Unregister with LM-IAS */
+	if (self->iriap) {
+		iriap_close(self->iriap);
+		self->iriap = NULL;
+	}
+
+	/*
+	 * Cleanup eventual discoveries from connection attempt or
+	 * control channel.
+	 */
+	if (self->discoveries != NULL) {
+		/* Cleanup our copy of the discovery log */
+		kfree(self->discoveries);
+		self->discoveries = NULL;
+	}
+
+	/* Close our IrTTP connection */
+	if (self->tsap) {
+		DEBUG(IRDA_SOCK_INFO, "Closing our TTP connection.\n");
+		irttp_disconnect_request(self->tsap, NULL, P_NORMAL);
+		irttp_close_tsap(self->tsap);
+		self->tsap = NULL;
+	}
+	self->stsap_sel = 0;
+
+	DEXIT(IRDA_SOCK_TRACE, "\n");
+	return;
+}
 
 /************************** SERVER SOCKET **************************/
 /*
@@ -672,42 +668,42 @@ irda_irnet_destroy(irnet_socket *	self)
  *
  * It basically look into the discovery log until there is a match.
  */
-static inline int
-irnet_daddr_to_dname(irnet_socket *	self)
+static inline int irnet_daddr_to_dname(irnet_socket * self)
 {
-  struct irda_device_info *discoveries;	/* Copy of the discovery log */
-  int	number;			/* Number of nodes in the log */
-  int	i;
-
-  DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self);
-
-  /* Ask lmp for the current discovery log */
-  discoveries = irlmp_get_discoveries(&number, 0xffff,
-				      DISCOVERY_DEFAULT_SLOTS);
-  /* Check if the we got some results */
-  if (discoveries == NULL)
-    DRETURN(-ENETUNREACH, IRDA_SERV_INFO, "Cachelog empty...\n");
-
-  /* Now, check all discovered devices (if any) */
-  for(i = 0; i < number; i++)
-    {
-      /* Does the name match ? */
-      if(discoveries[i].daddr == self->daddr)
-	{
-	  /* Yes !!! Get it.. */
-	  strlcpy(self->rname, discoveries[i].info, sizeof(self->rname));
-	  self->rname[sizeof(self->rname) - 1] = '\0';
-	  DEBUG(IRDA_SERV_INFO, "Device 0x%08x is in fact ``%s''.\n",
-		self->daddr, self->rname);
-	  kfree(discoveries);
-	  DEXIT(IRDA_SERV_TRACE, "\n");
-	  return 0;
+	struct irda_device_info *discoveries;	/* Copy of the discovery log */
+	int number;		/* Number of nodes in the log */
+	int i;
+
+	DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self);
+
+	/* Ask lmp for the current discovery log */
+	discoveries = irlmp_get_discoveries(&number, 0xffff,
+					    DISCOVERY_DEFAULT_SLOTS);
+	/* Check if the we got some results */
+	if (discoveries == NULL)
+		DRETURN(-ENETUNREACH, IRDA_SERV_INFO, "Cachelog empty...\n");
+
+	/* Now, check all discovered devices (if any) */
+	for (i = 0; i < number; i++) {
+		/* Does the name match ? */
+		if (discoveries[i].daddr == self->daddr) {
+			/* Yes !!! Get it.. */
+			strlcpy(self->rname, discoveries[i].info,
+				sizeof(self->rname));
+			self->rname[sizeof(self->rname) - 1] = '\0';
+			DEBUG(IRDA_SERV_INFO,
+			      "Device 0x%08x is in fact ``%s''.\n",
+			      self->daddr, self->rname);
+			kfree(discoveries);
+			DEXIT(IRDA_SERV_TRACE, "\n");
+			return 0;
+		}
 	}
-    }
-  /* No luck ! */
-  DEXIT(IRDA_SERV_INFO, ": cannot discover device 0x%08x !!!\n", self->daddr);
-  kfree(discoveries);
-  return(-EADDRNOTAVAIL);
+	/* No luck ! */
+	DEXIT(IRDA_SERV_INFO, ": cannot discover device 0x%08x !!!\n",
+	      self->daddr);
+	kfree(discoveries);
+	return (-EADDRNOTAVAIL);
 }
 
 /*------------------------------------------------------------------*/
@@ -719,80 +715,85 @@ irnet_daddr_to_dname(irnet_socket *	self)
  * Look into the list of IrNET sockets and finds one with the right
  * properties...
  */
-static inline irnet_socket *
-irnet_find_socket(irnet_socket *	self)
+static inline irnet_socket *irnet_find_socket(irnet_socket * self)
 {
-  irnet_socket *	new = (irnet_socket *) NULL;
-  int			err;
-
-  DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self);
-
-  /* Get the addresses of the requester */
-  self->daddr = irttp_get_daddr(self->tsap);
-  self->saddr = irttp_get_saddr(self->tsap);
-
-  /* Try to get the IrDA nickname of the requester */
-  err = irnet_daddr_to_dname(self);
-
-  /* Protect access to the instance list */
-  spin_lock_bh(&irnet_server.spinlock);
-
-  /* So now, try to get an socket having specifically
-   * requested that nickname */
-  if(err == 0)
-    {
-      new = (irnet_socket *) hashbin_find(irnet_server.list,
-					  0, self->rname);
-      if(new)
-	DEBUG(IRDA_SERV_INFO, "Socket 0x%p matches rname ``%s''.\n",
-	      new, new->rname);
-    }
-
-  /* If no name matches, try to find an socket by the destination address */
-  /* It can be either the requested destination address (set via the
-   * control channel), or the current destination address if the
-   * socket is in the middle of a connection request */
-  if(new == (irnet_socket *) NULL)
-    {
-      new = (irnet_socket *) hashbin_get_first(irnet_server.list);
-      while(new !=(irnet_socket *) NULL)
-	{
-	  /* Does it have the same address ? */
-	  if((new->rdaddr == self->daddr) || (new->daddr == self->daddr))
-	    {
-	      /* Yes !!! Get it.. */
-	      DEBUG(IRDA_SERV_INFO, "Socket 0x%p matches daddr %#08x.\n",
-		    new, self->daddr);
-	      break;
-	    }
-	  new = (irnet_socket *) hashbin_get_next(irnet_server.list);
+	irnet_socket *new = (irnet_socket *) NULL;
+	int err;
+
+	DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self);
+
+	/* Get the addresses of the requester */
+	self->daddr = irttp_get_daddr(self->tsap);
+	self->saddr = irttp_get_saddr(self->tsap);
+
+	/* Try to get the IrDA nickname of the requester */
+	err = irnet_daddr_to_dname(self);
+
+	/* Protect access to the instance list */
+	spin_lock_bh(&irnet_server.spinlock);
+
+	/* So now, try to get an socket having specifically
+	 * requested that nickname */
+	if (err == 0) {
+		new = (irnet_socket *) hashbin_find(irnet_server.list,
+						    0, self->rname);
+		if (new)
+			DEBUG(IRDA_SERV_INFO,
+			      "Socket 0x%p matches rname ``%s''.\n", new,
+			      new->rname);
 	}
-    }
-
-  /* If we don't have any socket, get the first unconnected socket */
-  if(new == (irnet_socket *) NULL)
-    {
-      new = (irnet_socket *) hashbin_get_first(irnet_server.list);
-      while(new !=(irnet_socket *) NULL)
-	{
-	  /* Is it available ? */
-	  if(!(test_bit(0, &new->ttp_open)) && (new->rdaddr == DEV_ADDR_ANY) &&
-	     (new->rname[0] == '\0') && (new->ppp_open))
-	    {
-	      /* Yes !!! Get it.. */
-	      DEBUG(IRDA_SERV_INFO, "Socket 0x%p is free.\n",
-		    new);
-	      break;
-	    }
-	  new = (irnet_socket *) hashbin_get_next(irnet_server.list);
+
+	/*
+	 * If no name matches, try to find an socket by the destination
+	 * address
+	 */
+	/*
+	 * It can be either the requested destination address (set via the
+	 * control channel), or the current destination address if the
+	 * socket is in the middle of a connection request
+	 */
+	if (new == (irnet_socket *) NULL) {
+		new = (irnet_socket *) hashbin_get_first(irnet_server.list);
+		while (new != (irnet_socket *) NULL) {
+			/* Does it have the same address ? */
+			if ((new->rdaddr == self->daddr)
+			    || (new->daddr == self->daddr)) {
+				/* Yes !!! Get it.. */
+				DEBUG(IRDA_SERV_INFO,
+				      "Socket 0x%p matches daddr %#08x.\n",
+				      new, self->daddr);
+				break;
+			}
+			new =
+			    (irnet_socket *) hashbin_get_next(irnet_server.
+							      list);
+		}
+	}
+
+	/* If we don't have any socket, get the first unconnected socket */
+	if (new == (irnet_socket *) NULL) {
+		new = (irnet_socket *) hashbin_get_first(irnet_server.list);
+		while (new != (irnet_socket *) NULL) {
+			/* Is it available ? */
+			if (!(test_bit(0, &new->ttp_open))
+			    && (new->rdaddr == DEV_ADDR_ANY)
+			    && (new->rname[0] == '\0') && (new->ppp_open)) {
+				/* Yes !!! Get it.. */
+				DEBUG(IRDA_SERV_INFO, "Socket 0x%p is free.\n",
+				      new);
+				break;
+			}
+			new =
+			    (irnet_socket *) hashbin_get_next(irnet_server.
+							      list);
+		}
 	}
-    }
 
-  /* Spin lock end */
-  spin_unlock_bh(&irnet_server.spinlock);
+	/* Spin lock end */
+	spin_unlock_bh(&irnet_server.spinlock);
 
-  DEXIT(IRDA_SERV_TRACE, " - new = 0x%p\n", new);
-  return new;
+	DEXIT(IRDA_SERV_TRACE, " - new = 0x%p\n", new);
+	return new;
 }
 
 /*------------------------------------------------------------------*/
@@ -803,71 +804,68 @@ irnet_find_socket(irnet_socket *	self)
  *
  */
 static inline int
-irnet_connect_socket(irnet_socket *	server,
-		     irnet_socket *	new,
-		     struct qos_info *	qos,
-		     __u32		max_sdu_size,
-		     __u8		max_header_size)
+irnet_connect_socket(irnet_socket * server,
+		     irnet_socket * new,
+		     struct qos_info *qos,
+		     __u32 max_sdu_size, __u8 max_header_size)
 {
-  DENTER(IRDA_SERV_TRACE, "(server=0x%p, new=0x%p)\n",
-	 server, new);
-
-  /* Now attach up the new socket */
-  new->tsap = irttp_dup(server->tsap, new);
-  DABORT(new->tsap == NULL, -1, IRDA_SERV_ERROR, "dup failed!\n");
-
-  /* Set up all the relevant parameters on the new socket */
-  new->stsap_sel = new->tsap->stsap_sel;
-  new->dtsap_sel = new->tsap->dtsap_sel;
-  new->saddr = irttp_get_saddr(new->tsap);
-  new->daddr = irttp_get_daddr(new->tsap);
-
-  new->max_header_size = max_header_size;
-  new->max_sdu_size_tx = max_sdu_size;
-  new->max_data_size   = max_sdu_size;
-#ifdef STREAM_COMPAT
-  /* If we want to receive "stream sockets" */
-  if(max_sdu_size == 0)
-    new->max_data_size = irttp_get_max_seg_size(new->tsap);
-#endif /* STREAM_COMPAT */
-
-  /* Clean up the original one to keep it in listen state */
-  irttp_listen(server->tsap);
-
-  /* Send a connection response on the new socket */
-  irttp_connect_response(new->tsap, new->max_sdu_size_rx, NULL);
-
-  /* Allow PPP to send its junk over the new socket... */
-  set_bit(0, &new->ttp_open);
-
-  /* Not connecting anymore, and clean up last possible remains
-   * of connection attempts on the socket */
-  clear_bit(0, &new->ttp_connect);
-  if(new->iriap)
-    {
-      iriap_close(new->iriap);
-      new->iriap = NULL;
-    }
-  if(new->discoveries != NULL)
-    {
-      kfree(new->discoveries);
-      new->discoveries = NULL;
-    }
+	DENTER(IRDA_SERV_TRACE, "(server=0x%p, new=0x%p)\n", server, new);
+
+	/* Now attach up the new socket */
+	new->tsap = irttp_dup(server->tsap, new);
+	DABORT(new->tsap == NULL, -1, IRDA_SERV_ERROR, "dup failed!\n");
 
+	/* Set up all the relevant parameters on the new socket */
+	new->stsap_sel = new->tsap->stsap_sel;
+	new->dtsap_sel = new->tsap->dtsap_sel;
+	new->saddr = irttp_get_saddr(new->tsap);
+	new->daddr = irttp_get_daddr(new->tsap);
+
+	new->max_header_size = max_header_size;
+	new->max_sdu_size_tx = max_sdu_size;
+	new->max_data_size = max_sdu_size;
+#ifdef STREAM_COMPAT
+	/* If we want to receive "stream sockets" */
+	if (max_sdu_size == 0)
+		new->max_data_size = irttp_get_max_seg_size(new->tsap);
+#endif				/* STREAM_COMPAT */
+
+	/* Clean up the original one to keep it in listen state */
+	irttp_listen(server->tsap);
+
+	/* Send a connection response on the new socket */
+	irttp_connect_response(new->tsap, new->max_sdu_size_rx, NULL);
+
+	/* Allow PPP to send its junk over the new socket... */
+	set_bit(0, &new->ttp_open);
+
+	/* Not connecting anymore, and clean up last possible remains
+	 * of connection attempts on the socket */
+	clear_bit(0, &new->ttp_connect);
+	if (new->iriap) {
+		iriap_close(new->iriap);
+		new->iriap = NULL;
+	}
+	if (new->discoveries != NULL) {
+		kfree(new->discoveries);
+		new->discoveries = NULL;
+	}
 #ifdef CONNECT_INDIC_KICK
-  /* As currently we don't block packets in ppp_irnet_send() while passive,
-   * this is not really needed...
-   * Also, not doing it give IrDA a chance to finish the setup properly
-   * before being swamped with packets... */
-  ppp_output_wakeup(&new->chan);
-#endif /* CONNECT_INDIC_KICK */
-
-  /* Notify the control channel */
-  irnet_post_event(new, IRNET_CONNECT_FROM,
-		   new->saddr, new->daddr, server->rname, 0);
-
-  DEXIT(IRDA_SERV_TRACE, "\n");
-  return 0;
+	/*
+	 * As currently we don't block packets in ppp_irnet_send()
+	 * while passive, this is not really needed...
+	 * Also, not doing it give IrDA a chance to finish the setup properly
+	 * before being swamped with packets...
+	 */
+	ppp_output_wakeup(&new->chan);
+#endif				/* CONNECT_INDIC_KICK */
+
+	/* Notify the control channel */
+	irnet_post_event(new, IRNET_CONNECT_FROM,
+			 new->saddr, new->daddr, server->rname, 0);
+
+	DEXIT(IRDA_SERV_TRACE, "\n");
+	return 0;
 }
 
 /*------------------------------------------------------------------*/
@@ -878,30 +876,29 @@ irnet_connect_socket(irnet_socket *	server,
  *
  */
 static inline void
-irnet_disconnect_server(irnet_socket *	self,
-			struct sk_buff *skb)
+irnet_disconnect_server(irnet_socket * self, struct sk_buff *skb)
 {
-  DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self);
+	DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self);
 
-  /* Put the received packet in the black hole */
-  kfree_skb(skb);
+	/* Put the received packet in the black hole */
+	kfree_skb(skb);
 
 #ifdef FAIL_SEND_DISCONNECT
-  /* Tell the other party we don't want to be connected */
-  /* Hum... Is it the right thing to do ? And do we need to send
-   * a connect response before ? It looks ok without this... */
-  irttp_disconnect_request(self->tsap, NULL, P_NORMAL);
-#endif /* FAIL_SEND_DISCONNECT */
+	/* Tell the other party we don't want to be connected */
+	/* Hum... Is it the right thing to do ? And do we need to send
+	 * a connect response before ? It looks ok without this... */
+	irttp_disconnect_request(self->tsap, NULL, P_NORMAL);
+#endif				/* FAIL_SEND_DISCONNECT */
 
-  /* Notify the control channel (see irnet_find_socket()) */
-  irnet_post_event(NULL, IRNET_REQUEST_FROM,
-		   self->saddr, self->daddr, self->rname, 0);
+	/* Notify the control channel (see irnet_find_socket()) */
+	irnet_post_event(NULL, IRNET_REQUEST_FROM,
+			 self->saddr, self->daddr, self->rname, 0);
 
-  /* Clean up the server to keep it in listen state */
-  irttp_listen(self->tsap);
+	/* Clean up the server to keep it in listen state */
+	irttp_listen(self->tsap);
 
-  DEXIT(IRDA_SERV_TRACE, "\n");
-  return;
+	DEXIT(IRDA_SERV_TRACE, "\n");
+	return;
 }
 
 /*------------------------------------------------------------------*/
@@ -913,51 +910,53 @@ irnet_disconnect_server(irnet_socket *	self,
  * Register the IrLAN hint bit, create a IrTTP instance for us,
  * set all the IrTTP callbacks and create an IrIAS entry...
  */
-static inline int
-irnet_setup_server(void)
+static inline int irnet_setup_server(void)
 {
-  __u16		hints;
+	__u16 hints;
 
-  DENTER(IRDA_SERV_TRACE, "()\n");
+	DENTER(IRDA_SERV_TRACE, "()\n");
 
-  /* Initialise the regular socket part of the server */
-  irda_irnet_create(&irnet_server.s);
+	/* Initialise the regular socket part of the server */
+	irda_irnet_create(&irnet_server.s);
 
-  /* Open a local TSAP (an IrTTP instance) for the server */
-  irnet_open_tsap(&irnet_server.s);
+	/* Open a local TSAP (an IrTTP instance) for the server */
+	irnet_open_tsap(&irnet_server.s);
 
-  /* PPP part setup */
-  irnet_server.s.ppp_open = 0;
-  irnet_server.s.chan.private = NULL;
-  irnet_server.s.file = NULL;
+	/* PPP part setup */
+	irnet_server.s.ppp_open = 0;
+	irnet_server.s.chan.private = NULL;
+	irnet_server.s.file = NULL;
 
-  /* Get the hint bit corresponding to IrLAN */
-  /* Note : we overload the IrLAN hint bit. As it is only a "hint", and as
-   * we provide roughly the same functionality as IrLAN, this is ok.
-   * In fact, the situation is similar as JetSend overloading the Obex hint
-   */
-  hints = irlmp_service_to_hint(S_LAN);
+	/* Get the hint bit corresponding to IrLAN */
+	/*
+	 * Note : we overload the IrLAN hint bit. As it is only a "hint",
+	 * and as we provide roughly the same functionality as IrLAN,
+	 * this is ok. In fact, the situation is similar as JetSend
+	 * overloading the Obex hint
+	 */
+	hints = irlmp_service_to_hint(S_LAN);
 
 #ifdef ADVERTISE_HINT
-  /* Register with IrLMP as a service (advertise our hint bit) */
-  irnet_server.skey = irlmp_register_service(hints);
-#endif /* ADVERTISE_HINT */
+	/* Register with IrLMP as a service (advertise our hint bit) */
+	irnet_server.skey = irlmp_register_service(hints);
+#endif				/* ADVERTISE_HINT */
 
-  /* Register with LM-IAS (so that people can connect to us) */
-  irnet_server.ias_obj = irias_new_object(IRNET_SERVICE_NAME, jiffies);
-  irias_add_integer_attrib(irnet_server.ias_obj, IRNET_IAS_VALUE,
-			   irnet_server.s.stsap_sel, IAS_KERNEL_ATTR);
-  irias_insert_object(irnet_server.ias_obj);
+	/* Register with LM-IAS (so that people can connect to us) */
+	irnet_server.ias_obj = irias_new_object(IRNET_SERVICE_NAME, jiffies);
+	irias_add_integer_attrib(irnet_server.ias_obj, IRNET_IAS_VALUE,
+				 irnet_server.s.stsap_sel, IAS_KERNEL_ATTR);
+	irias_insert_object(irnet_server.ias_obj);
 
 #ifdef DISCOVERY_EVENTS
-  /* Tell IrLMP we want to be notified of newly discovered nodes */
-  irlmp_update_client(irnet_server.s.ckey, hints,
-		      irnet_discovery_indication, irnet_expiry_indication,
-		      (void *) &irnet_server.s);
+	/* Tell IrLMP we want to be notified of newly discovered nodes */
+	irlmp_update_client(irnet_server.s.ckey, hints,
+			    irnet_discovery_indication,
+			    irnet_expiry_indication,
+			    (void *)&irnet_server.s);
 #endif
 
-  DEXIT(IRDA_SERV_TRACE, " - self=0x%p\n", &irnet_server.s);
-  return 0;
+	DEXIT(IRDA_SERV_TRACE, " - self=0x%p\n", &irnet_server.s);
+	return 0;
 }
 
 /*------------------------------------------------------------------*/
@@ -968,28 +967,26 @@ irnet_setup_server(void)
  *
  * Reverse of the previous function...
  */
-static inline void
-irnet_destroy_server(void)
+static inline void irnet_destroy_server(void)
 {
-  DENTER(IRDA_SERV_TRACE, "()\n");
+	DENTER(IRDA_SERV_TRACE, "()\n");
 
 #ifdef ADVERTISE_HINT
-  /* Unregister with IrLMP */
-  irlmp_unregister_service(irnet_server.skey);
-#endif /* ADVERTISE_HINT */
+	/* Unregister with IrLMP */
+	irlmp_unregister_service(irnet_server.skey);
+#endif				/* ADVERTISE_HINT */
 
-  /* Unregister with LM-IAS */
-  if(irnet_server.ias_obj)
-    irias_delete_object(irnet_server.ias_obj);
+	/* Unregister with LM-IAS */
+	if (irnet_server.ias_obj)
+		irias_delete_object(irnet_server.ias_obj);
 
-  /* Cleanup the socket part */
-  irda_irnet_destroy(&irnet_server.s);
+	/* Cleanup the socket part */
+	irda_irnet_destroy(&irnet_server.s);
 
-  DEXIT(IRDA_SERV_TRACE, "\n");
-  return;
+	DEXIT(IRDA_SERV_TRACE, "\n");
+	return;
 }
 
-
 /************************ IRDA-TTP CALLBACKS ************************/
 /*
  * When we create a IrTTP instance, we pass to it a set of callbacks
@@ -1004,62 +1001,55 @@ irnet_destroy_server(void)
  *    Received some data from TinyTP. Just queue it on the receive queue
  *
  */
-static int
-irnet_data_indication(void *	instance,
-		      void *	sap,
-		      struct sk_buff *skb)
+static int irnet_data_indication(void *instance, void *sap,
+				 struct sk_buff *skb)
 {
-  irnet_socket *	ap = (irnet_socket *) instance;
-  unsigned char *	p;
-  int			code = 0;
-
-  DENTER(IRDA_TCB_TRACE, "(self/ap=0x%p, skb=0x%p)\n",
-	 ap, skb);
-  DASSERT(skb != NULL, 0, IRDA_CB_ERROR, "skb is NULL !!!\n");
-
-  /* Check is ppp is ready to receive our packet */
-  if(!ap->ppp_open)
-    {
-      DERROR(IRDA_CB_ERROR, "PPP not ready, dropping packet...\n");
-      /* When we return error, TTP will need to requeue the skb and
-       * will stop the sender. IrTTP will stall until we send it a
-       * flow control request... */
-      return -ENOMEM;
-    }
-
-  /* strip address/control field if present */
-  p = skb->data;
-  if((p[0] == PPP_ALLSTATIONS) && (p[1] == PPP_UI))
-    {
-      /* chop off address/control */
-      if(skb->len < 3)
-	goto err_exit;
-      p = skb_pull(skb, 2);
-    }
-
-  /* decompress protocol field if compressed */
-  if(p[0] & 1)
-    {
-      /* protocol is compressed */
-      skb_push(skb, 1)[0] = 0;
-    }
-  else
-    if(skb->len < 2)
-      goto err_exit;
-
-  /* pass to generic ppp layer */
-  /* Note : how do I know if ppp can accept or not the packet ? This is
-   * essential if I want to manage flow control smoothly... */
-  ppp_input(&ap->chan, skb);
-
-  DEXIT(IRDA_TCB_TRACE, "\n");
-  return 0;
-
- err_exit:
-  DERROR(IRDA_CB_ERROR, "Packet too small, dropping...\n");
-  kfree_skb(skb);
-  ppp_input_error(&ap->chan, code);
-  return 0;	/* Don't return an error code, only for flow control... */
+	irnet_socket *ap = (irnet_socket *) instance;
+	unsigned char *p;
+	int code = 0;
+
+	DENTER(IRDA_TCB_TRACE, "(self/ap=0x%p, skb=0x%p)\n", ap, skb);
+	DASSERT(skb != NULL, 0, IRDA_CB_ERROR, "skb is NULL !!!\n");
+
+	/* Check is ppp is ready to receive our packet */
+	if (!ap->ppp_open) {
+		DERROR(IRDA_CB_ERROR, "PPP not ready, dropping packet...\n");
+		/* When we return error, TTP will need to requeue the skb and
+		 * will stop the sender. IrTTP will stall until we send it a
+		 * flow control request... */
+		return -ENOMEM;
+	}
+
+	/* strip address/control field if present */
+	p = skb->data;
+	if ((p[0] == PPP_ALLSTATIONS) && (p[1] == PPP_UI)) {
+		/* chop off address/control */
+		if (skb->len < 3)
+			goto err_exit;
+		p = skb_pull(skb, 2);
+	}
+
+	/* decompress protocol field if compressed */
+	if (p[0] & 1) {
+		/* protocol is compressed */
+		skb_push(skb, 1)[0] = 0;
+	} else if (skb->len < 2)
+		goto err_exit;
+
+	/* pass to generic ppp layer */
+	/* Note : how do I know if ppp can accept or not the packet ? This is
+	 * essential if I want to manage flow control smoothly... */
+	ppp_input(&ap->chan, skb);
+
+	DEXIT(IRDA_TCB_TRACE, "\n");
+	return 0;
+
+      err_exit:
+	DERROR(IRDA_CB_ERROR, "Packet too small, dropping...\n");
+	kfree_skb(skb);
+	ppp_input_error(&ap->chan, code);
+	return 0:
+	/* Don't return an error code, only for flow control... */
 }
 
 /*------------------------------------------------------------------*/
@@ -1075,86 +1065,89 @@ irnet_data_indication(void *	instance,
  *	o connection request on the server not handled
  */
 static void
-irnet_disconnect_indication(void *	instance,
-			    void *	sap,
-			    LM_REASON	reason,
-			    struct sk_buff *skb)
+irnet_disconnect_indication(void *instance,
+			    void *sap, LM_REASON reason, struct sk_buff *skb)
 {
-  irnet_socket *	self = (irnet_socket *) instance;
-  int			test_open;
-  int			test_connect;
-
-  DENTER(IRDA_TCB_TRACE, "(self=0x%p)\n", self);
-  DASSERT(self != NULL, , IRDA_CB_ERROR, "Self is NULL !!!\n");
-
-  /* Don't care about it, but let's not leak it */
-  if(skb)
-    dev_kfree_skb(skb);
-
-  /* Prevent higher layer from accessing IrTTP */
-  test_open = test_and_clear_bit(0, &self->ttp_open);
-  /* Not connecting anymore...
-   * (note : TSAP is open, so IAP callbacks are no longer pending...) */
-  test_connect = test_and_clear_bit(0, &self->ttp_connect);
-
-  /* If both self->ttp_open and self->ttp_connect are NULL, it mean that we
-   * have a race condition with irda_irnet_destroy() or
-   * irnet_connect_indication(), so don't mess up tsap...
-   */
-  if(!(test_open || test_connect))
-    {
-      DERROR(IRDA_CB_ERROR, "Race condition detected...\n");
-      return;
-    }
-
-  /* If we were active, notify the control channel */
-  if(test_open)
-    irnet_post_event(self, IRNET_DISCONNECT_FROM,
-		     self->saddr, self->daddr, self->rname, 0);
-  else
-    /* If we were trying to connect, notify the control channel */
-    if((self->tsap) && (self != &irnet_server.s))
-      irnet_post_event(self, IRNET_NOANSWER_FROM,
-		       self->saddr, self->daddr, self->rname, 0);
-
-  /* Close our IrTTP connection, cleanup tsap */
-  if((self->tsap) && (self != &irnet_server.s))
-    {
-      DEBUG(IRDA_CB_INFO, "Closing our TTP connection.\n");
-      irttp_close_tsap(self->tsap);
-      self->tsap = NULL;
-    }
-  /* Cleanup the socket in case we want to reconnect in ppp_output_wakeup() */
-  self->stsap_sel = 0;
-  self->daddr = DEV_ADDR_ANY;
-  self->tx_flow = FLOW_START;
-
-  /* Deal with the ppp instance if it's still alive */
-  if(self->ppp_open)
-    {
-      if(test_open)
-	{
+	irnet_socket *self = (irnet_socket *) instance;
+	int test_open;
+	int test_connect;
+
+	DENTER(IRDA_TCB_TRACE, "(self=0x%p)\n", self);
+	DASSERT(self != NULL,, IRDA_CB_ERROR, "Self is NULL !!!\n");
+
+	/* Don't care about it, but let's not leak it */
+	if (skb)
+		dev_kfree_skb(skb);
+
+	/* Prevent higher layer from accessing IrTTP */
+	test_open = test_and_clear_bit(0, &self->ttp_open);
+	/* Not connecting anymore...
+	 * (note : TSAP is open, so IAP callbacks are no longer pending...) */
+	test_connect = test_and_clear_bit(0, &self->ttp_connect);
+
+	/*
+	 * If both self->ttp_open and self->ttp_connect are NULL,
+	 * it means that we
+	 * have a race condition with irda_irnet_destroy() or
+	 * irnet_connect_indication(), so don't mess up tsap...
+	 */
+	if (!(test_open || test_connect)) {
+		DERROR(IRDA_CB_ERROR, "Race condition detected...\n");
+		return;
+	}
+
+	/* If we were active, notify the control channel */
+	if (test_open)
+		irnet_post_event(self, IRNET_DISCONNECT_FROM,
+				 self->saddr, self->daddr, self->rname, 0);
+	else
+		/* If we were trying to connect, notify the control channel */
+	if ((self->tsap) && (self != &irnet_server.s))
+		irnet_post_event(self, IRNET_NOANSWER_FROM,
+				 self->saddr, self->daddr, self->rname, 0);
+
+	/* Close our IrTTP connection, cleanup tsap */
+	if ((self->tsap) && (self != &irnet_server.s)) {
+		DEBUG(IRDA_CB_INFO, "Closing our TTP connection.\n");
+		irttp_close_tsap(self->tsap);
+		self->tsap = NULL;
+	}
+	/*
+	 * Cleanup the socket in case we want to reconnect
+	 * in ppp_output_wakeup()
+	 */
+	self->stsap_sel = 0;
+	self->daddr = DEV_ADDR_ANY;
+	self->tx_flow = FLOW_START;
+
+	/* Deal with the ppp instance if it's still alive */
+	if (self->ppp_open) {
+		if (test_open) {
 #ifdef MISSING_PPP_API
-	  /* ppp_unregister_channel() wants a user context, which we
-	   * are guaranteed to NOT have here. What are we supposed
-	   * to do here ? Jean II */
-	  /* If we were connected, cleanup & close the PPP channel,
-	   * which will kill pppd (hangup) and the rest */
-	  ppp_unregister_channel(&self->chan);
-	  self->ppp_open = 0;
+			/*
+			 * ppp_unregister_channel() wants a user context,
+			 * which we are guaranteed to NOT have here.
+			 * What are we supposed to do here ? Jean II */
+			/*
+			 * If we were connected, cleanup & close the PPP
+			 * channel, which will kill pppd (hangup) and the rest.
+			 */
+			ppp_unregister_channel(&self->chan);
+			self->ppp_open = 0;
 #endif
+		} else {
+			/*
+			 * If we were trying to connect, flush (drain)
+			 * ppp_generic Tx queue (most often we have
+			 * blocked it), which will trigger an other attempt
+			 * to connect. If we are passive, this will empty
+			 * the Tx queue after last try.
+			 */
+			ppp_output_wakeup(&self->chan);
+		}
 	}
-      else
-	{
-	  /* If we were trying to connect, flush (drain) ppp_generic
-	   * Tx queue (most often we have blocked it), which will
-	   * trigger an other attempt to connect. If we are passive,
-	   * this will empty the Tx queue after last try. */
-	  ppp_output_wakeup(&self->chan);
-	}
-    }
 
-  DEXIT(IRDA_TCB_TRACE, "\n");
+	DEXIT(IRDA_TCB_TRACE, "\n");
 }
 
 /*------------------------------------------------------------------*/
@@ -1165,64 +1158,65 @@ irnet_disconnect_indication(void *	instance,
  *
  */
 static void
-irnet_connect_confirm(void *	instance,
-		      void *	sap,
+irnet_connect_confirm(void *instance,
+		      void *sap,
 		      struct qos_info *qos,
-		      __u32	max_sdu_size,
-		      __u8	max_header_size,
-		      struct sk_buff *skb)
+		      __u32 max_sdu_size,
+		      __u8 max_header_size, struct sk_buff *skb)
 {
-  irnet_socket *	self = (irnet_socket *) instance;
+	irnet_socket *self = (irnet_socket *) instance;
 
-  DENTER(IRDA_TCB_TRACE, "(self=0x%p)\n", self);
+	DENTER(IRDA_TCB_TRACE, "(self=0x%p)\n", self);
 
-  /* Check if socket is closing down (via irda_irnet_destroy()) */
-  if(! test_bit(0, &self->ttp_connect))
-    {
-      DERROR(IRDA_CB_ERROR, "Socket no longer connecting. Ouch !\n");
-      return;
-    }
+	/* Check if socket is closing down (via irda_irnet_destroy()) */
+	if (!test_bit(0, &self->ttp_connect)) {
+		DERROR(IRDA_CB_ERROR, "Socket no longer connecting. Ouch !\n");
+		return;
+	}
 
-  /* How much header space do we need to reserve */
-  self->max_header_size = max_header_size;
+	/* How much header space do we need to reserve */
+	self->max_header_size = max_header_size;
 
-  /* IrTTP max SDU size in transmit direction */
-  self->max_sdu_size_tx = max_sdu_size;
-  self->max_data_size = max_sdu_size;
+	/* IrTTP max SDU size in transmit direction */
+	self->max_sdu_size_tx = max_sdu_size;
+	self->max_data_size = max_sdu_size;
 #ifdef STREAM_COMPAT
-  if(max_sdu_size == 0)
-    self->max_data_size = irttp_get_max_seg_size(self->tsap);
-#endif /* STREAM_COMPAT */
-
-  /* At this point, IrLMP has assigned our source address */
-  self->saddr = irttp_get_saddr(self->tsap);
-
-  /* Allow higher layer to access IrTTP */
-  set_bit(0, &self->ttp_open);
-  clear_bit(0, &self->ttp_connect);	/* Not racy, IrDA traffic is serial */
-  /* Give a kick in the ass of ppp_generic so that he sends us some data */
-  ppp_output_wakeup(&self->chan);
-
-  /* Check size of received packet */
-  if(skb->len > 0)
-    {
-#ifdef PASS_CONNECT_PACKETS
-      DEBUG(IRDA_CB_INFO, "Passing connect packet to PPP.\n");
-      /* Try to pass it to PPP */
-      irnet_data_indication(instance, sap, skb);
-#else /* PASS_CONNECT_PACKETS */
-      DERROR(IRDA_CB_ERROR, "Dropping non empty packet.\n");
-      kfree_skb(skb);	/* Note : will be optimised with other kfree... */
-#endif /* PASS_CONNECT_PACKETS */
-    }
-  else
-    kfree_skb(skb);
-
-  /* Notify the control channel */
-  irnet_post_event(self, IRNET_CONNECT_TO,
-		   self->saddr, self->daddr, self->rname, 0);
+	if (max_sdu_size == 0)
+		self->max_data_size = irttp_get_max_seg_size(self->tsap);
+#endif				/* STREAM_COMPAT */
+
+	/* At this point, IrLMP has assigned our source address */
+	self->saddr = irttp_get_saddr(self->tsap);
+
+	/* Allow higher layer to access IrTTP */
+	set_bit(0, &self->ttp_open);
+	clear_bit(0, &self->ttp_connect);
+	/* Not racy, IrDA traffic is serial */
+	/*
+	 * Give a kick in the ass to ppp_generic so that he
+	 * sends us some data
+	 */
+	ppp_output_wakeup(&self->chan);
 
-  DEXIT(IRDA_TCB_TRACE, "\n");
+	/* Check size of received packet */
+	if (skb->len > 0) {
+#ifdef PASS_CONNECT_PACKETS
+		DEBUG(IRDA_CB_INFO, "Passing connect packet to PPP.\n");
+		/* Try to pass it to PPP */
+		irnet_data_indication(instance, sap, skb);
+#else				/* PASS_CONNECT_PACKETS */
+		DERROR(IRDA_CB_ERROR, "Dropping non empty packet.\n");
+		kfree_skb(skb);
+		/* Note : will be optimised with other kfree... */
+#endif		/* PASS_CONNECT_PACKETS */
+	} else
+		kfree_skb(skb);
+
+	/* Notify the control channel */
+	irnet_post_event(self, IRNET_CONNECT_TO,
+			 self->saddr, self->daddr, self->rname, 0);
+
+	DEXIT(IRDA_TCB_TRACE, "\n");
 }
 
 /*------------------------------------------------------------------*/
@@ -1232,39 +1226,36 @@ irnet_connect_confirm(void *	instance,
  *    Used by TinyTP to tell us if it can accept more data or not
  *
  */
-static void
-irnet_flow_indication(void *	instance,
-		      void *	sap,
-		      LOCAL_FLOW flow)
+static void irnet_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
 {
-  irnet_socket *	self = (irnet_socket *) instance;
-  LOCAL_FLOW		oldflow = self->tx_flow;
-
-  DENTER(IRDA_TCB_TRACE, "(self=0x%p, flow=%d)\n", self, flow);
-
-  /* Update our state */
-  self->tx_flow = flow;
+	irnet_socket *self = (irnet_socket *) instance;
+	LOCAL_FLOW oldflow = self->tx_flow;
+
+	DENTER(IRDA_TCB_TRACE, "(self=0x%p, flow=%d)\n", self, flow);
+
+	/* Update our state */
+	self->tx_flow = flow;
+
+	/* Check what IrTTP want us to do... */
+	switch (flow) {
+	case FLOW_START:
+		DEBUG(IRDA_CB_INFO, "IrTTP wants us to start again\n");
+		/* Check if we really need to wake up PPP */
+		if (oldflow == FLOW_STOP)
+			ppp_output_wakeup(&self->chan);
+		else
+			DEBUG(IRDA_CB_INFO,
+			      "But we were already transmitting !!!\n");
+		break;
+	case FLOW_STOP:
+		DEBUG(IRDA_CB_INFO, "IrTTP wants us to slow down\n");
+		break;
+	default:
+		DEBUG(IRDA_CB_INFO, "Unknown flow command!\n");
+		break;
+	}
 
-  /* Check what IrTTP want us to do... */
-  switch(flow)
-    {
-    case FLOW_START:
-      DEBUG(IRDA_CB_INFO, "IrTTP wants us to start again\n");
-      /* Check if we really need to wake up PPP */
-      if(oldflow == FLOW_STOP)
-	ppp_output_wakeup(&self->chan);
-      else
-	DEBUG(IRDA_CB_INFO, "But we were already transmitting !!!\n");
-      break;
-    case FLOW_STOP:
-      DEBUG(IRDA_CB_INFO, "IrTTP wants us to slow down\n");
-      break;
-    default:
-      DEBUG(IRDA_CB_INFO, "Unknown flow command!\n");
-      break;
-    }
-
-  DEXIT(IRDA_TCB_TRACE, "\n");
+	DEXIT(IRDA_TCB_TRACE, "\n");
 }
 
 /*------------------------------------------------------------------*/
@@ -1275,32 +1266,29 @@ irnet_flow_indication(void *	instance,
  *
  */
 static void
-irnet_status_indication(void *	instance,
-			LINK_STATUS link,
-			LOCK_STATUS lock)
+irnet_status_indication(void *instance, LINK_STATUS link, LOCK_STATUS lock)
 {
-  irnet_socket *	self = (irnet_socket *) instance;
-
-  DENTER(IRDA_TCB_TRACE, "(self=0x%p)\n", self);
-  DASSERT(self != NULL, , IRDA_CB_ERROR, "Self is NULL !!!\n");
-
-  /* We can only get this event if we are connected */
-  switch(link)
-    {
-    case STATUS_NO_ACTIVITY:
-      irnet_post_event(self, IRNET_BLOCKED_LINK,
-		       self->saddr, self->daddr, self->rname, 0);
-      break;
-    default:
-      DEBUG(IRDA_CB_INFO, "Unknown status...\n");
-    }
-
-  DEXIT(IRDA_TCB_TRACE, "\n");
+	irnet_socket *self = (irnet_socket *) instance;
+
+	DENTER(IRDA_TCB_TRACE, "(self=0x%p)\n", self);
+	DASSERT(self != NULL,, IRDA_CB_ERROR, "Self is NULL !!!\n");
+
+	/* We can only get this event if we are connected */
+	switch (link) {
+	case STATUS_NO_ACTIVITY:
+		irnet_post_event(self, IRNET_BLOCKED_LINK,
+				 self->saddr, self->daddr, self->rname, 0);
+		break;
+	default:
+		DEBUG(IRDA_CB_INFO, "Unknown status...\n");
+	}
+
+	DEXIT(IRDA_TCB_TRACE, "\n");
 }
 
 /*------------------------------------------------------------------*/
 /*
- * Function irnet_connect_indication(instance, sap, qos, max_sdu_size, userdata)
+ * Function irnet_connect_indication(instance,sap,qos,max_sdu_size,userdata)
  *
  *    Incoming connection
  *
@@ -1313,137 +1301,146 @@ irnet_status_indication(void *	instance,
  * exist only one irnet connection.
  */
 static void
-irnet_connect_indication(void *		instance,
-			 void *		sap,
+irnet_connect_indication(void *instance,
+			 void *sap,
 			 struct qos_info *qos,
-			 __u32		max_sdu_size,
-			 __u8		max_header_size,
-			 struct sk_buff *skb)
+			 __u32 max_sdu_size,
+			 __u8 max_header_size, struct sk_buff *skb)
 {
-  irnet_socket *	server = &irnet_server.s;
-  irnet_socket *	new = (irnet_socket *) NULL;
-
-  DENTER(IRDA_TCB_TRACE, "(server=0x%p)\n", server);
-  DASSERT(instance == &irnet_server, , IRDA_CB_ERROR,
-	  "Invalid instance (0x%p) !!!\n", instance);
-  DASSERT(sap == irnet_server.s.tsap, , IRDA_CB_ERROR, "Invalid sap !!!\n");
-
-  /* Try to find the most appropriate IrNET socket */
-  new = irnet_find_socket(server);
-
-  /* After all this hard work, do we have an socket ? */
-  if(new == (irnet_socket *) NULL)
-    {
-      DEXIT(IRDA_CB_INFO, ": No socket waiting for this connection.\n");
-      irnet_disconnect_server(server, skb);
-      return;
-    }
-
-  /* Is the socket already busy ? */
-  if(test_bit(0, &new->ttp_open))
-    {
-      DEXIT(IRDA_CB_INFO, ": Socket already connected.\n");
-      irnet_disconnect_server(server, skb);
-      return;
-    }
-
-  /* The following code is a bit tricky, so need comments ;-)
-   */
-  /* If ttp_connect is set, the socket is trying to connect to the other
-   * end and may have sent a IrTTP connection request and is waiting for
-   * a connection response (that may never come).
-   * Now, the pain is that the socket may have opened a tsap and is
-   * waiting on it, while the other end is trying to connect to it on
-   * another tsap.
-   * Because IrNET can be peer to peer, we need to workaround this.
-   * Furthermore, the way the irnetd script is implemented, the
-   * target will create a second IrNET connection back to the
-   * originator and expect the originator to bind this new connection
-   * to the original PPPD instance.
-   * And of course, if we don't use irnetd, we can have a race when
-   * both side try to connect simultaneously, which could leave both
-   * connections half closed (yuck).
-   * Conclusions :
-   *	1) The "originator" must accept the new connection and get rid
-   *	   of the old one so that irnetd works
-   *	2) One side must deny the new connection to avoid races,
-   *	   but both side must agree on which side it is...
-   * Most often, the originator is primary at the LAP layer.
-   * Jean II
-   */
-  /* Now, let's look at the way I wrote the test...
-   * We need to clear up the ttp_connect flag atomically to prevent
-   * irnet_disconnect_indication() to mess up the tsap we are going to close.
-   * We want to clear the ttp_connect flag only if we close the tsap,
-   * otherwise we will never close it, so we need to check for primary
-   * *before* doing the test on the flag.
-   * And of course, ALLOW_SIMULT_CONNECT can disable this entirely...
-   * Jean II
-   */
-
-  /* Socket already connecting ? On primary ? */
-  if(0
-#ifdef ALLOW_SIMULT_CONNECT
-     || ((irttp_is_primary(server->tsap) == 1)	/* primary */
-	 && (test_and_clear_bit(0, &new->ttp_connect)))
-#endif /* ALLOW_SIMULT_CONNECT */
-     )
-    {
-      DERROR(IRDA_CB_ERROR, "Socket already connecting, but going to reuse it !\n");
-
-      /* Cleanup the old TSAP if necessary - IrIAP will be cleaned up later */
-      if(new->tsap != NULL)
-	{
-	  /* Close the old connection the new socket was attempting,
-	   * so that we can hook it up to the new connection.
-	   * It's now safe to do it... */
-	  irttp_close_tsap(new->tsap);
-	  new->tsap = NULL;
+	irnet_socket *server = &irnet_server.s;
+	irnet_socket *new = (irnet_socket *) NULL;
+
+	DENTER(IRDA_TCB_TRACE, "(server=0x%p)\n", server);
+	DASSERT(instance == &irnet_server,, IRDA_CB_ERROR,
+		"Invalid instance (0x%p) !!!\n", instance);
+	DASSERT(sap == irnet_server.s.tsap,, IRDA_CB_ERROR,
+		"Invalid sap !!!\n");
+
+	/* Try to find the most appropriate IrNET socket */
+	new = irnet_find_socket(server);
+
+	/* After all this hard work, do we have an socket ? */
+	if (new == (irnet_socket *) NULL) {
+		DEXIT(IRDA_CB_INFO,
+		      ": No socket waiting for this connection.\n");
+		irnet_disconnect_server(server, skb);
+		return;
 	}
-    }
-  else
-    {
-      /* Three options :
-       * 1) socket was not connecting or connected : ttp_connect should be 0.
-       * 2) we don't want to connect the socket because we are secondary or
-       * ALLOW_SIMULT_CONNECT is undefined. ttp_connect should be 1.
-       * 3) we are half way in irnet_disconnect_indication(), and it's a
-       * nice race condition... Fortunately, we can detect that by checking
-       * if tsap is still alive. On the other hand, we can't be in
-       * irda_irnet_destroy() otherwise we would not have found this
-       * socket in the hashbin.
-       * Jean II */
-      if((test_bit(0, &new->ttp_connect)) || (new->tsap != NULL))
-	{
-	  /* Don't mess this socket, somebody else in in charge... */
-	  DERROR(IRDA_CB_ERROR, "Race condition detected, socket in use, abort connect...\n");
-	  irnet_disconnect_server(server, skb);
-	  return;
+
+	/* Is the socket already busy ? */
+	if (test_bit(0, &new->ttp_open)) {
+		DEXIT(IRDA_CB_INFO, ": Socket already connected.\n");
+		irnet_disconnect_server(server, skb);
+		return;
 	}
-    }
 
-  /* So : at this point, we have a socket, and it is idle. Good ! */
-  irnet_connect_socket(server, new, qos, max_sdu_size, max_header_size);
+	/* The following code is a bit tricky, so need comments ;-)
+	 */
+	/* If ttp_connect is set, the socket is trying to connect to the other
+	 * end and may have sent a IrTTP connection request and is waiting for
+	 * a connection response (that may never come).
+	 * Now, the pain is that the socket may have opened a tsap and is
+	 * waiting on it, while the other end is trying to connect to it on
+	 * another tsap.
+	 * Because IrNET can be peer to peer, we need to workaround this.
+	 * Furthermore, the way the irnetd script is implemented, the
+	 * target will create a second IrNET connection back to the
+	 * originator and expect the originator to bind this new connection
+	 * to the original PPPD instance.
+	 * And of course, if we don't use irnetd, we can have a race when
+	 * both side try to connect simultaneously, which could leave both
+	 * connections half closed (yuck).
+	 * Conclusions :
+	 *    1) The "originator" must accept the new connection and get rid
+	 *       of the old one so that irnetd works
+	 *    2) One side must deny the new connection to avoid races,
+	 *       but both side must agree on which side it is...
+	 * Most often, the originator is primary at the LAP layer.
+	 * Jean II
+	 */
+	/* Now, let's look at the way I wrote the test...
+	 * We need to clear up the ttp_connect flag atomically to prevent
+	 * irnet_disconnect_indication() to mess up the tsap we are going
+	 * to close.
+	 * We want to clear the ttp_connect flag only if we close the tsap,
+	 * otherwise we will never close it, so we need to check for primary
+	 * *before* doing the test on the flag.
+	 * And of course, ALLOW_SIMULT_CONNECT can disable this entirely...
+	 * Jean II
+	 */
+
+	/* Socket already connecting ? On primary ? */
+	if (0
+#ifdef ALLOW_SIMULT_CONNECT
+	    || ((irttp_is_primary(server->tsap) == 1)	/* primary */
+		&&(test_and_clear_bit(0, &new->ttp_connect)))
+#endif				/* ALLOW_SIMULT_CONNECT */
+	    ) {
+		DERROR(IRDA_CB_ERROR,
+		       "Socket already connecting, but going to reuse it !\n");
+
+		/*
+		 * Cleanup the old TSAP if necessary.
+		 * IrIAP will be cleaned up later.
+		 */
+		if (new->tsap != NULL) {
+			/*
+			 * Close the old connection the new socket was
+			 * attempting, so that we can hook it up to the
+			 * new connection.
+			 * It's now safe to do it...
+			 */
+			irttp_close_tsap(new->tsap);
+			new->tsap = NULL;
+		}
+	} else {
+		/*
+		 * Three options :
+		 * 1) socket was not connecting or connected : ttp_connect
+		 * should be 0.
+		 * 2) we don't want to connect the socket because we are
+		 * secondary or ALLOW_SIMULT_CONNECT is undefined.
+		 * ttp_connect should be 1.
+		 * 3) we are half way in irnet_disconnect_indication(), and
+		 * it's a nice race condition... Fortunately, we can detect
+		 * that by checking if tsap is still alive.
+		 * On the other hand, we can't be in irda_irnet_destroy()
+		 * otherwise we would not have found this socket in the
+		 * hashbin.
+		 * Jean II
+		 */
+		if ((test_bit(0, &new->ttp_connect)) || (new->tsap != NULL)) {
+			/*
+			 * Don't mess this socket,
+			 * somebody else in in charge...
+			 */
+			DERROR(IRDA_CB_ERROR,
+			       "Race condition detected, socket in use, abort connect...\n");
+			irnet_disconnect_server(server, skb);
+			return;
+		}
+	}
+
+	/* So : at this point, we have a socket, and it is idle. Good ! */
+	irnet_connect_socket(server, new, qos, max_sdu_size, max_header_size);
 
-  /* Check size of received packet */
-  if(skb->len > 0)
-    {
+	/* Check size of received packet */
+	if (skb->len > 0) {
 #ifdef PASS_CONNECT_PACKETS
-      DEBUG(IRDA_CB_INFO, "Passing connect packet to PPP.\n");
-      /* Try to pass it to PPP */
-      irnet_data_indication(new, new->tsap, skb);
-#else /* PASS_CONNECT_PACKETS */
-      DERROR(IRDA_CB_ERROR, "Dropping non empty packet.\n");
-      kfree_skb(skb);	/* Note : will be optimised with other kfree... */
+		DEBUG(IRDA_CB_INFO, "Passing connect packet to PPP.\n");
+		/* Try to pass it to PPP */
+		irnet_data_indication(new, new->tsap, skb);
+#else				/* PASS_CONNECT_PACKETS */
+		DERROR(IRDA_CB_ERROR, "Dropping non empty packet.\n");
+		kfree_skb(skb);
+		/* Note : will be optimised with other kfree... */
 #endif /* PASS_CONNECT_PACKETS */
-    }
-  else
-    kfree_skb(skb);
+	} else
+		kfree_skb(skb);
 
-  DEXIT(IRDA_TCB_TRACE, "\n");
+	DEXIT(IRDA_TCB_TRACE, "\n");
 }
 
-
 /********************** IRDA-IAS/LMP CALLBACKS **********************/
 /*
  * These are the callbacks called by other layers of the IrDA stack,
@@ -1462,46 +1459,45 @@ irnet_connect_indication(void *		instance,
  * on this TSAP.
  */
 static void
-irnet_getvalue_confirm(int	result,
-		       __u16	obj_id,
-		       struct ias_value *value,
-		       void *	priv)
+irnet_getvalue_confirm(int result,
+		       __u16 obj_id, struct ias_value *value, void *priv)
 {
-  irnet_socket *	self = (irnet_socket *) priv;
+	irnet_socket *self = (irnet_socket *) priv;
 
-  DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
-  DASSERT(self != NULL, , IRDA_OCB_ERROR, "Self is NULL !!!\n");
+	DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
+	DASSERT(self != NULL,, IRDA_OCB_ERROR, "Self is NULL !!!\n");
 
-  /* Check if already connected (via irnet_connect_socket())
-   * or socket is closing down (via irda_irnet_destroy()) */
-  if(! test_bit(0, &self->ttp_connect))
-    {
-      DERROR(IRDA_OCB_ERROR, "Socket no longer connecting. Ouch !\n");
-      return;
-    }
+	/* Check if already connected (via irnet_connect_socket())
+	 * or socket is closing down (via irda_irnet_destroy()) */
+	if (!test_bit(0, &self->ttp_connect)) {
+		DERROR(IRDA_OCB_ERROR,
+		       "Socket no longer connecting. Ouch !\n");
+		return;
+	}
 
-  /* We probably don't need to make any more queries */
-  iriap_close(self->iriap);
-  self->iriap = NULL;
+	/* We probably don't need to make any more queries */
+	iriap_close(self->iriap);
+	self->iriap = NULL;
 
-  /* Post process the IAS reply */
-  self->dtsap_sel = irnet_ias_to_tsap(self, result, value);
+	/* Post process the IAS reply */
+	self->dtsap_sel = irnet_ias_to_tsap(self, result, value);
 
-  /* If error, just go out */
-  if(self->errno)
-    {
-      clear_bit(0, &self->ttp_connect);
-      DERROR(IRDA_OCB_ERROR, "IAS connect failed ! (0x%X)\n", self->errno);
-      return;
-    }
+	/* If error, just go out */
+	if (self->errno) {
+		clear_bit(0, &self->ttp_connect);
+		DERROR(IRDA_OCB_ERROR, "IAS connect failed ! (0x%X)\n",
+		       self->errno);
+		return;
+	}
 
-  DEBUG(IRDA_OCB_INFO, "daddr = %08x, lsap = %d, starting IrTTP connection\n",
-	self->daddr, self->dtsap_sel);
+	DEBUG(IRDA_OCB_INFO,
+	      "daddr = %08x, lsap = %d, starting IrTTP connection\n",
+	      self->daddr, self->dtsap_sel);
 
-  /* Start up TTP - non blocking */
-  irnet_connect_tsap(self);
+	/* Start up TTP - non blocking */
+	irnet_connect_tsap(self);
 
-  DEXIT(IRDA_OCB_TRACE, "\n");
+	DEXIT(IRDA_OCB_TRACE, "\n");
 }
 
 /*------------------------------------------------------------------*/
@@ -1525,95 +1521,88 @@ irnet_getvalue_confirm(int	result,
  * any device and connect to it.
  */
 static void
-irnet_discovervalue_confirm(int		result,
-			    __u16	obj_id,
-			    struct ias_value *value,
-			    void *	priv)
+irnet_discovervalue_confirm(int result,
+			    __u16 obj_id, struct ias_value *value, void *priv)
 {
-  irnet_socket *	self = (irnet_socket *) priv;
-  __u8			dtsap_sel;		/* TSAP we are looking for */
-
-  DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
-  DASSERT(self != NULL, , IRDA_OCB_ERROR, "Self is NULL !!!\n");
-
-  /* Check if already connected (via irnet_connect_socket())
-   * or socket is closing down (via irda_irnet_destroy()) */
-  if(! test_bit(0, &self->ttp_connect))
-    {
-      DERROR(IRDA_OCB_ERROR, "Socket no longer connecting. Ouch !\n");
-      return;
-    }
-
-  /* Post process the IAS reply */
-  dtsap_sel = irnet_ias_to_tsap(self, result, value);
-
-  /* Have we got something ? */
-  if(self->errno == 0)
-    {
-      /* We found the requested service */
-      if(self->daddr != DEV_ADDR_ANY)
-	{
-	  DERROR(IRDA_OCB_ERROR, "More than one device in range supports IrNET...\n");
+	irnet_socket *self = (irnet_socket *) priv;
+	__u8 dtsap_sel;		/* TSAP we are looking for */
+
+	DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
+	DASSERT(self != NULL,, IRDA_OCB_ERROR, "Self is NULL !!!\n");
+
+	/* Check if already connected (via irnet_connect_socket())
+	 * or socket is closing down (via irda_irnet_destroy()) */
+	if (!test_bit(0, &self->ttp_connect)) {
+		DERROR(IRDA_OCB_ERROR,
+		       "Socket no longer connecting. Ouch !\n");
+		return;
 	}
-      else
-	{
-	  /* First time we found that one, save it ! */
-	  self->daddr = self->discoveries[self->disco_index].daddr;
-	  self->dtsap_sel = dtsap_sel;
+
+	/* Post process the IAS reply */
+	dtsap_sel = irnet_ias_to_tsap(self, result, value);
+
+	/* Have we got something ? */
+	if (self->errno == 0) {
+		/* We found the requested service */
+		if (self->daddr != DEV_ADDR_ANY) {
+			DERROR(IRDA_OCB_ERROR,
+			       "More than one device in range supports IrNET...\n");
+		} else {
+			/* First time we found that one, save it ! */
+			self->daddr =
+			    self->discoveries[self->disco_index].daddr;
+			self->dtsap_sel = dtsap_sel;
+		}
 	}
-    }
-
-  /* If no failure */
-  if((self->errno == -EADDRNOTAVAIL) || (self->errno == 0))
-    {
-      int	ret;
-
-      /* Search the next node */
-      ret = irnet_discover_next_daddr(self);
-      if(!ret)
-	{
-	  /* In this case, the above request was non-blocking.
-	   * We will return here after a while... */
-	  return;
+
+	/* If no failure */
+	if ((self->errno == -EADDRNOTAVAIL) || (self->errno == 0)) {
+		int ret;
+
+		/* Search the next node */
+		ret = irnet_discover_next_daddr(self);
+		if (!ret) {
+			/* In this case, the above request was non-blocking.
+			 * We will return here after a while... */
+			return;
+		}
+		/* In this case, we have processed the last discovery item */
 	}
-      /* In this case, we have processed the last discovery item */
-    }
-
-  /* No more queries to be done (failure or last one) */
-
-  /* We probably don't need to make any more queries */
-  iriap_close(self->iriap);
-  self->iriap = NULL;
-
-  /* No more items : remove the log and signal termination */
-  DEBUG(IRDA_OCB_INFO, "Cleaning up log (0x%p)\n",
-	self->discoveries);
-  if(self->discoveries != NULL)
-    {
-      /* Cleanup our copy of the discovery log */
-      kfree(self->discoveries);
-      self->discoveries = NULL;
-    }
-  self->disco_number = -1;
-
-  /* Check out what we found */
-  if(self->daddr == DEV_ADDR_ANY)
-    {
-      self->daddr = DEV_ADDR_ANY;
-      clear_bit(0, &self->ttp_connect);
-      DEXIT(IRDA_OCB_TRACE, ": cannot discover IrNET in any device !!!\n");
-      return;
-    }
-
-  /* We have a valid address - just connect */
-
-  DEBUG(IRDA_OCB_INFO, "daddr = %08x, lsap = %d, starting IrTTP connection\n",
-	self->daddr, self->dtsap_sel);
-
-  /* Start up TTP - non blocking */
-  irnet_connect_tsap(self);
-
-  DEXIT(IRDA_OCB_TRACE, "\n");
+
+	/* No more queries to be done (failure or last one) */
+
+	/* We probably don't need to make any more queries */
+	iriap_close(self->iriap);
+	self->iriap = NULL;
+
+	/* No more items : remove the log and signal termination */
+	DEBUG(IRDA_OCB_INFO, "Cleaning up log (0x%p)\n", self->discoveries);
+	if (self->discoveries != NULL) {
+		/* Cleanup our copy of the discovery log */
+		kfree(self->discoveries);
+		self->discoveries = NULL;
+	}
+	self->disco_number = -1;
+
+	/* Check out what we found */
+	if (self->daddr == DEV_ADDR_ANY) {
+		self->daddr = DEV_ADDR_ANY;
+		clear_bit(0, &self->ttp_connect);
+		DEXIT(IRDA_OCB_TRACE,
+		      ": cannot discover IrNET in any device !!!\n");
+		return;
+	}
+
+	/* We have a valid address - just connect */
+
+	DEBUG(IRDA_OCB_INFO,
+	      "daddr = %08x, lsap = %d, starting IrTTP connection\n",
+	      self->daddr, self->dtsap_sel);
+
+	/* Start up TTP - non blocking */
+	irnet_connect_tsap(self);
+
+	DEXIT(IRDA_OCB_TRACE, "\n");
 }
 
 #ifdef DISCOVERY_EVENTS
@@ -1640,25 +1629,24 @@ irnet_discovervalue_confirm(int		result,
  * is to messy, so we leave that to user space...
  */
 static void
-irnet_discovery_indication(discinfo_t *		discovery,
-			   DISCOVERY_MODE	mode,
-			   void *		priv)
+irnet_discovery_indication(discinfo_t * discovery,
+			   DISCOVERY_MODE mode, void *priv)
 {
-  irnet_socket *	self = &irnet_server.s;
+	irnet_socket *self = &irnet_server.s;
 
-  DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
-  DASSERT(priv == &irnet_server, , IRDA_OCB_ERROR,
-	  "Invalid instance (0x%p) !!!\n", priv);
+	DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
+	DASSERT(priv == &irnet_server,, IRDA_OCB_ERROR,
+		"Invalid instance (0x%p) !!!\n", priv);
 
-  DEBUG(IRDA_OCB_INFO, "Discovered new IrNET/IrLAN node %s...\n",
-	discovery->info);
+	DEBUG(IRDA_OCB_INFO, "Discovered new IrNET/IrLAN node %s...\n",
+	      discovery->info);
 
-  /* Notify the control channel */
-  irnet_post_event(NULL, IRNET_DISCOVER,
-		   discovery->saddr, discovery->daddr, discovery->info,
-		   u16ho(discovery->hints));
+	/* Notify the control channel */
+	irnet_post_event(NULL, IRNET_DISCOVER,
+			 discovery->saddr, discovery->daddr, discovery->info,
+			 u16ho(discovery->hints));
 
-  DEXIT(IRDA_OCB_TRACE, "\n");
+	DEXIT(IRDA_OCB_TRACE, "\n");
 }
 
 /*------------------------------------------------------------------*/
@@ -1671,28 +1659,24 @@ irnet_discovery_indication(discinfo_t *		discovery,
  * check if it is a "new" node...
  */
 static void
-irnet_expiry_indication(discinfo_t *	expiry,
-			DISCOVERY_MODE	mode,
-			void *		priv)
+irnet_expiry_indication(discinfo_t * expiry, DISCOVERY_MODE mode, void *priv)
 {
-  irnet_socket *	self = &irnet_server.s;
+	irnet_socket *self = &irnet_server.s;
 
-  DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
-  DASSERT(priv == &irnet_server, , IRDA_OCB_ERROR,
-	  "Invalid instance (0x%p) !!!\n", priv);
+	DENTER(IRDA_OCB_TRACE, "(self=0x%p)\n", self);
+	DASSERT(priv == &irnet_server,, IRDA_OCB_ERROR,
+		"Invalid instance (0x%p) !!!\n", priv);
 
-  DEBUG(IRDA_OCB_INFO, "IrNET/IrLAN node %s expired...\n",
-	expiry->info);
+	DEBUG(IRDA_OCB_INFO, "IrNET/IrLAN node %s expired...\n", expiry->info);
 
-  /* Notify the control channel */
-  irnet_post_event(NULL, IRNET_EXPIRE,
-		   expiry->saddr, expiry->daddr, expiry->info,
-		   u16ho(expiry->hints));
+	/* Notify the control channel */
+	irnet_post_event(NULL, IRNET_EXPIRE,
+			 expiry->saddr, expiry->daddr, expiry->info,
+			 u16ho(expiry->hints));
 
-  DEXIT(IRDA_OCB_TRACE, "\n");
+	DEXIT(IRDA_OCB_TRACE, "\n");
 }
-#endif /* DISCOVERY_EVENTS */
-
+#endif				/* DISCOVERY_EVENTS */
 
 /*********************** PROC ENTRY CALLBACKS ***********************/
 /*
@@ -1707,88 +1691,84 @@ irnet_expiry_indication(discinfo_t *	expiry,
  *
  *    Give some info to the /proc file system
  */
-static int
-irnet_proc_read(char *	buf,
-		char **	start,
-		off_t	offset,
-		int	len)
+static int irnet_proc_read(char *buf, char **start, off_t offset, int len)
 {
-  irnet_socket *	self;
-  char *		state;
-  int			i = 0;
-
-  len = 0;
-
-  /* Get the IrNET server information... */
-  len += sprintf(buf+len, "IrNET server - ");
-  len += sprintf(buf+len, "IrDA state: %s, ",
-		 (irnet_server.running ? "running" : "dead"));
-  len += sprintf(buf+len, "stsap_sel: %02x, ", irnet_server.s.stsap_sel);
-  len += sprintf(buf+len, "dtsap_sel: %02x\n", irnet_server.s.dtsap_sel);
-
-  /* Do we need to continue ? */
-  if(!irnet_server.running)
-    return len;
-
-  /* Protect access to the instance list */
-  spin_lock_bh(&irnet_server.spinlock);
-
-  /* Get the sockets one by one... */
-  self = (irnet_socket *) hashbin_get_first(irnet_server.list);
-  while(self != NULL)
-    {
-      /* Start printing info about the socket. */
-      len += sprintf(buf+len, "\nIrNET socket %d - ", i++);
-
-      /* First, get the requested configuration */
-      len += sprintf(buf+len, "Requested IrDA name: \"%s\", ", self->rname);
-      len += sprintf(buf+len, "daddr: %08x, ", self->rdaddr);
-      len += sprintf(buf+len, "saddr: %08x\n", self->rsaddr);
-
-      /* Second, get all the PPP info */
-      len += sprintf(buf+len, "	PPP state: %s",
-		 (self->ppp_open ? "registered" : "unregistered"));
-      if(self->ppp_open)
-	{
-	  len += sprintf(buf+len, ", unit: ppp%d",
-			 ppp_unit_number(&self->chan));
-	  len += sprintf(buf+len, ", channel: %d",
-			 ppp_channel_index(&self->chan));
-	  len += sprintf(buf+len, ", mru: %d",
-			 self->mru);
-	  /* Maybe add self->flags ? Later... */
+	irnet_socket *self;
+	char *state;
+	int i = 0;
+
+	len = 0;
+
+	/* Get the IrNET server information... */
+	len += sprintf(buf + len, "IrNET server - ");
+	len += sprintf(buf + len, "IrDA state: %s, ",
+		       (irnet_server.running ? "running" : "dead"));
+	len +=
+	    sprintf(buf + len, "stsap_sel: %02x, ", irnet_server.s.stsap_sel);
+	len +=
+	    sprintf(buf + len, "dtsap_sel: %02x\n", irnet_server.s.dtsap_sel);
+
+	/* Do we need to continue ? */
+	if (!irnet_server.running)
+		return len;
+
+	/* Protect access to the instance list */
+	spin_lock_bh(&irnet_server.spinlock);
+
+	/* Get the sockets one by one... */
+	self = (irnet_socket *) hashbin_get_first(irnet_server.list);
+	while (self != NULL) {
+		/* Start printing info about the socket. */
+		len += sprintf(buf + len, "\nIrNET socket %d - ", i++);
+
+		/* First, get the requested configuration */
+		len +=
+		    sprintf(buf + len, "Requested IrDA name: \"%s\", ",
+			    self->rname);
+		len += sprintf(buf + len, "daddr: %08x, ", self->rdaddr);
+		len += sprintf(buf + len, "saddr: %08x\n", self->rsaddr);
+
+		/* Second, get all the PPP info */
+		len += sprintf(buf + len, "	PPP state: %s",
+			       (self->
+				ppp_open ? "registered" : "unregistered"));
+		if (self->ppp_open) {
+			len += sprintf(buf + len, ", unit: ppp%d",
+				       ppp_unit_number(&self->chan));
+			len += sprintf(buf + len, ", channel: %d",
+				       ppp_channel_index(&self->chan));
+			len += sprintf(buf + len, ", mru: %d", self->mru);
+			/* Maybe add self->flags ? Later... */
+		}
+
+		/* Then, get all the IrDA specific info... */
+		if (self->ttp_open)
+			state = "connected";
+		else if (self->tsap != NULL)
+			state = "connecting";
+		else if (self->iriap != NULL)
+			state = "searching";
+		else if (self->ttp_connect)
+			state = "weird";
+		else
+			state = "idle";
+		len += sprintf(buf + len, "\n	IrDA state: %s, ", state);
+		len += sprintf(buf + len, "daddr: %08x, ", self->daddr);
+		len += sprintf(buf + len, "stsap_sel: %02x, ",
+			       self->stsap_sel);
+		len += sprintf(buf + len, "dtsap_sel: %02x\n",
+			       self->dtsap_sel);
+
+		/* Next socket, please... */
+		self = (irnet_socket *) hashbin_get_next(irnet_server.list);
 	}
 
-      /* Then, get all the IrDA specific info... */
-      if(self->ttp_open)
-	state = "connected";
-      else
-	if(self->tsap != NULL)
-	  state = "connecting";
-	else
-	  if(self->iriap != NULL)
-	    state = "searching";
-	  else
-	    if(self->ttp_connect)
-	      state = "weird";
-	    else
-	      state = "idle";
-      len += sprintf(buf+len, "\n	IrDA state: %s, ", state);
-      len += sprintf(buf+len, "daddr: %08x, ", self->daddr);
-      len += sprintf(buf+len, "stsap_sel: %02x, ", self->stsap_sel);
-      len += sprintf(buf+len, "dtsap_sel: %02x\n", self->dtsap_sel);
-
-      /* Next socket, please... */
-      self = (irnet_socket *) hashbin_get_next(irnet_server.list);
-    }
-
-  /* Spin lock end */
-  spin_unlock_bh(&irnet_server.spinlock);
-
-  return len;
-}
-#endif /* PROC_FS */
+	/* Spin lock end */
+	spin_unlock_bh(&irnet_server.spinlock);
 
+	return len;
+}
+#endif				/* PROC_FS */
 
 /********************** CONFIGURATION/CLEANUP **********************/
 /*
@@ -1800,67 +1780,65 @@ irnet_proc_read(char *	buf,
 /*
  * Prepare the IrNET layer for operation...
  */
-int __init
-irda_irnet_init(void)
+int __init irda_irnet_init(void)
 {
-  int		err = 0;
+	int err = 0;
 
-  DENTER(MODULE_TRACE, "()\n");
+	DENTER(MODULE_TRACE, "()\n");
 
-  /* Pure paranoia - should be redundant */
-  memset(&irnet_server, 0, sizeof(struct irnet_root));
+	/* Pure paranoia - should be redundant */
+	memset(&irnet_server, 0, sizeof(struct irnet_root));
 
-  /* Setup start of irnet instance list */
-  irnet_server.list = hashbin_new(HB_NOLOCK);
-  DABORT(irnet_server.list == NULL, -ENOMEM,
-	 MODULE_ERROR, "Can't allocate hashbin!\n");
-  /* Init spinlock for instance list */
-  spin_lock_init(&irnet_server.spinlock);
+	/* Setup start of irnet instance list */
+	irnet_server.list = hashbin_new(HB_NOLOCK);
+	DABORT(irnet_server.list == NULL, -ENOMEM,
+	       MODULE_ERROR, "Can't allocate hashbin!\n");
+	/* Init spinlock for instance list */
+	spin_lock_init(&irnet_server.spinlock);
 
-  /* Initialise control channel */
-  init_waitqueue_head(&irnet_events.rwait);
-  irnet_events.index = 0;
-  /* Init spinlock for event logging */
-  spin_lock_init(&irnet_events.spinlock);
+	/* Initialise control channel */
+	init_waitqueue_head(&irnet_events.rwait);
+	irnet_events.index = 0;
+	/* Init spinlock for event logging */
+	spin_lock_init(&irnet_events.spinlock);
 
 #ifdef CONFIG_PROC_FS
-  /* Add a /proc file for irnet infos */
-  create_proc_info_entry("irnet", 0, proc_irda, irnet_proc_read);
-#endif /* CONFIG_PROC_FS */
+	/* Add a /proc file for irnet infos */
+	create_proc_info_entry("irnet", 0, proc_irda, irnet_proc_read);
+#endif				/* CONFIG_PROC_FS */
 
-  /* Setup the IrNET server */
-  err = irnet_setup_server();
+	/* Setup the IrNET server */
+	err = irnet_setup_server();
 
-  if(!err)
-    /* We are no longer functional... */
-    irnet_server.running = 1;
+	if (!err)
+		/* We are no longer functional... */
+		irnet_server.running = 1;
 
-  DEXIT(MODULE_TRACE, "\n");
-  return err;
+	DEXIT(MODULE_TRACE, "\n");
+	return err;
 }
 
 /*------------------------------------------------------------------*/
 /*
  * Cleanup at exit...
  */
-void __exit
-irda_irnet_cleanup(void)
+void __exit irda_irnet_cleanup(void)
 {
-  DENTER(MODULE_TRACE, "()\n");
+	DENTER(MODULE_TRACE, "()\n");
 
-  /* We are no longer there... */
-  irnet_server.running = 0;
+	/* We are no longer there... */
+	irnet_server.running = 0;
 
 #ifdef CONFIG_PROC_FS
-  /* Remove our /proc file */
-  remove_proc_entry("irnet", proc_irda);
-#endif /* CONFIG_PROC_FS */
+	/* Remove our /proc file */
+	remove_proc_entry("irnet", proc_irda);
+#endif				/* CONFIG_PROC_FS */
 
-  /* Remove our IrNET server from existence */
-  irnet_destroy_server();
+	/* Remove our IrNET server from existence */
+	irnet_destroy_server();
 
-  /* Remove all instances of IrNET socket still present */
-  hashbin_delete(irnet_server.list, (FREE_FUNC) irda_irnet_destroy);
+	/* Remove all instances of IrNET socket still present */
+	hashbin_delete(irnet_server.list, (FREE_FUNC) irda_irnet_destroy);
 
-  DEXIT(MODULE_TRACE, "\n");
+	DEXIT(MODULE_TRACE, "\n");
 }
-- 
1.4.4.4

-------------------------------------------------------------------------
Take Surveys. Earn Cash. Influence the Future of IT
Join SourceForge.net's Techsay panel and you'll get the chance to share your
opinions on IT & business topics through brief surveys-and earn cash
http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV