[NET] WANROUTER: Fix whitespace errors.

Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

3 files changed, 268 insertions, 268 deletions

diff --git a/net/wanrouter/af_wanpipe.c b/net/wanrouter/af_wanpipe.c
index c205973..41d7e32 100644
--- a/net/wanrouter/af_wanpipe.c
+++ b/net/wanrouter/af_wanpipe.c
@@ -11,11 +11,11 @@
 *		2 of the License, or (at your option) any later version.
 * ============================================================================
 * Due Credit:
-*               Wanpipe socket layer is based on Packet and 
-*               the X25 socket layers. The above sockets were 
-*               used for the specific use of Sangoma Technologies 
-*               API programs. 
-*               Packet socket Authors: Ross Biro, Fred N. van Kempen and 
+*               Wanpipe socket layer is based on Packet and
+*               the X25 socket layers. The above sockets were
+*               used for the specific use of Sangoma Technologies
+*               API programs.
+*               Packet socket Authors: Ross Biro, Fred N. van Kempen and
 *                                      Alan Cox.
 *               X25 socket Author: Jonathan Naylor.
 * ============================================================================
@@ -28,7 +28,7 @@
 * Feb 29, 2000  Nenad Corbic     o Added support for PVC protocols, such as
 *                                  CHDLC, Frame Relay and HDLC API.
 * Jan 17, 2000 	Nenad Corbic	 o Initial version, based on AF_PACKET socket.
-*			           X25API support only. 
+*			           X25API support only.
 *
 ******************************************************************************/
 
@@ -71,33 +71,33 @@
 	#define DBG_PRINTK(format, a...) printk(format, ## a)
 #else
 	#define DBG_PRINTK(format, a...)
-#endif      
+#endif
 
 
-/* SECURE SOCKET IMPLEMENTATION 
- * 
+/* SECURE SOCKET IMPLEMENTATION
+ *
  *   TRANSMIT:
  *
  *      When the user sends a packet via send() system call
- *      the wanpipe_sendmsg() function is executed.  
- *      
+ *      the wanpipe_sendmsg() function is executed.
+ *
  *      Each packet is enqueud into sk->sk_write_queue transmit
  *      queue. When the packet is enqueued, a delayed transmit
- *      timer is triggerd which acts as a Bottom Half hander. 
+ *      timer is triggerd which acts as a Bottom Half hander.
  *
  *      wanpipe_delay_transmit() function (BH), dequeues packets
- *      from the sk->sk_write_queue transmit queue and sends it 
- *      to the deriver via dev->hard_start_xmit(skb, dev) function.  
+ *      from the sk->sk_write_queue transmit queue and sends it
+ *      to the deriver via dev->hard_start_xmit(skb, dev) function.
  *      Note, this function is actual a function pointer of if_send()
  *      routine in the wanpipe driver.
  *
  *      X25API GUARANTEED DELIVERY:
  *
- *         In order to provide 100% guaranteed packet delivery, 
- *         an atomic 'packet_sent' counter is implemented.  Counter 
- *         is incremented for each packet enqueued 
+ *         In order to provide 100% guaranteed packet delivery,
+ *         an atomic 'packet_sent' counter is implemented.  Counter
+ *         is incremented for each packet enqueued
  *         into sk->sk_write_queue.  Counter is decremented each
- *         time wanpipe_delayed_transmit() function successfuly 
+ *         time wanpipe_delayed_transmit() function successfuly
  *         passes the packet to the driver. Before each send(), a poll
  *         routine checks the sock resources The maximum value of
  *         packet sent counter is 1, thus if one packet is queued, the
@@ -110,11 +110,11 @@
  *      function, wanpipe_rcv() to queue the incoming packets
  *      into an AF_WANPIPE socket queue.  Based on wanpipe_rcv()
  *      return code, the driver knows whether the packet was
- *      successfully queued.  If the socket queue is full, 
- *      protocol flow control is used by the driver, if any, 
+ *      successfully queued.  If the socket queue is full,
+ *      protocol flow control is used by the driver, if any,
  *      to slow down the traffic until the sock queue is free.
  *
- *      Every time a packet arrives into a socket queue the 
+ *      Every time a packet arrives into a socket queue the
  *      socket wakes up processes which are waiting to receive
  *      data.
  *
@@ -122,12 +122,12 @@
  *      bit which signals the socket to kick the wanpipe driver
  *      bottom half hander when the socket queue is partialy
  *      empty. wanpipe_recvmsg() function performs this action.
- * 
+ *
  *      In case of x25api, packets will never be dropped, since
- *      flow control is available. 
- *      
- *      In case of streaming protocols like CHDLC, packets will 
- *      be dropped but the statistics will be generated. 
+ *      flow control is available.
+ *
+ *      In case of streaming protocols like CHDLC, packets will
+ *      be dropped but the statistics will be generated.
  */
 
 
@@ -170,11 +170,11 @@ struct wanpipe_opt
 	struct net_device *dev;	/* Bounded device */
 	unsigned short lcn;	/* Binded LCN */
 	unsigned char  svc;	/* 0=pvc, 1=svc */
-	unsigned char  timer;   /* flag for delayed transmit*/	
+	unsigned char  timer;   /* flag for delayed transmit*/
 	struct timer_list tx_timer;
 	unsigned poll_cnt;
 	unsigned char force;	/* Used to force sock release */
-	atomic_t packet_sent;   
+	atomic_t packet_sent;
 };
 #endif
 
@@ -215,8 +215,8 @@ static int check_driver_busy (struct sock *);
  *
  *	Wanpipe socket bottom half handler.  This function
  *      is called by the WANPIPE device drivers to queue a
- *      incoming packet into the socket receive queue. 
- *      Once the packet is queued, all processes waiting to 
+ *      incoming packet into the socket receive queue.
+ *      Once the packet is queued, all processes waiting to
  *      read are woken up.
  *
  *      During socket bind, this function is bounded into
@@ -245,13 +245,13 @@ static int wanpipe_rcv(struct sk_buff *skb, struct net_device *dev,
 	if (dev->hard_header_parse)
 		sll->sll_halen = dev->hard_header_parse(skb, sll->sll_addr);
 
-	/* 
+	/*
 	 * WAN_PACKET_DATA : Data which should be passed up the receive queue.
-         * WAN_PACKET_ASYC : Asynchronous data like place call, which should
-         *                   be passed up the listening sock.
-         * WAN_PACKET_ERR  : Asynchronous data like clear call or restart 
-         *                   which should go into an error queue.
-         */
+	 * WAN_PACKET_ASYC : Asynchronous data like place call, which should
+	 *                   be passed up the listening sock.
+	 * WAN_PACKET_ERR  : Asynchronous data like clear call or restart
+	 *                   which should go into an error queue.
+	 */
 	switch (skb->pkt_type){
 
 		case WAN_PACKET_DATA:
@@ -261,10 +261,10 @@ static int wanpipe_rcv(struct sk_buff *skb, struct net_device *dev,
 			break;
 		case WAN_PACKET_CMD:
 			sk->sk_state = chan->state;
-			/* Bug fix: update Mar6. 
-                         * Do not set the sock lcn number here, since
-         		 * cmd is not guaranteed to be executed on the
-                         * board, thus Lcn could be wrong */
+			/* Bug fix: update Mar6.
+			 * Do not set the sock lcn number here, since
+			 * cmd is not guaranteed to be executed on the
+			 * board, thus Lcn could be wrong */
 			sk->sk_data_ready(sk, skb->len);
 			kfree_skb(skb);
 			break;
@@ -276,7 +276,7 @@ static int wanpipe_rcv(struct sk_buff *skb, struct net_device *dev,
 			break;
 		default:
 			printk(KERN_INFO "wansock: BH Illegal Packet Type Dropping\n");
-			kfree_skb(skb); 
+			kfree_skb(skb);
 			break;
 	}
 
@@ -297,20 +297,20 @@ static int wanpipe_rcv(struct sk_buff *skb, struct net_device *dev,
  *
  *	Wanpipe LISTEN socket bottom half handler.  This function
  *      is called by the WANPIPE device drivers to queue an
- *      incoming call into the socket listening queue. 
- *      Once the packet is queued, the waiting accept() process 
+ *      incoming call into the socket listening queue.
+ *      Once the packet is queued, the waiting accept() process
  *      is woken up.
  *
  *      During socket bind, this function is bounded into
- *      WANPIPE driver private. 
- * 
+ *      WANPIPE driver private.
+ *
  *      IMPORTANT NOTE:
  *          The accept call() is waiting for an skb packet
  *          which contains a pointer to a device structure.
  *
- *          When we do a bind to a device structre, we 
- *          bind a newly created socket into "chan->sk".  Thus, 
- *          when accept receives the skb packet, it will know 
+ *          When we do a bind to a device structre, we
+ *          bind a newly created socket into "chan->sk".  Thus,
+ *          when accept receives the skb packet, it will know
  *          from which dev it came form, and in turn it will know
  *          the address of the new sock.
  *
@@ -322,31 +322,31 @@ static int wanpipe_listen_rcv (struct sk_buff *skb,  struct sock *sk)
 	wanpipe_opt *wp = wp_sk(sk), *newwp;
 	struct wan_sockaddr_ll *sll = (struct wan_sockaddr_ll*)skb->cb;
 	struct sock *newsk;
-	struct net_device *dev; 
+	struct net_device *dev;
 	sdla_t *card;
 	mbox_cmd_t *mbox_ptr;
 	wanpipe_common_t *chan;
 
-	/* Find a free device, if none found, all svc's are busy 
-         */
+	/* Find a free device, if none found, all svc's are busy
+	 */
 
 	card = (sdla_t*)wp->card;
 	if (!card){
 		printk(KERN_INFO "wansock: LISTEN ERROR, No Card\n");
 		return -ENODEV;
 	}
-	
+
 	dev = wanpipe_find_free_dev(card);
 	if (!dev){
 		printk(KERN_INFO "wansock: LISTEN ERROR, No Free Device\n");
 		return -ENODEV;
 	}
 
-	chan=dev->priv;	
+	chan=dev->priv;
 	chan->state = WANSOCK_CONNECTING;
 
 	/* Allocate a new sock, which accept will bind
-         * and pass up to the user 
+	 * and pass up to the user
 	 */
 	if ((newsk = wanpipe_make_new(sk)) == NULL){
 		release_device(dev);
@@ -354,33 +354,33 @@ static int wanpipe_listen_rcv (struct sk_buff *skb,  struct sock *sk)
 	}
 
 
-	/* Initialize the new sock structure 
+	/* Initialize the new sock structure
 	 */
 	newsk->sk_bound_dev_if = dev->ifindex;
 	newwp = wp_sk(newsk);
 	newwp->card = wp->card;
 
 	/* Insert the sock into the main wanpipe
-         * sock list.
-         */
+	 * sock list.
+	 */
 	atomic_inc(&wanpipe_socks_nr);
 
 	/* Allocate and fill in the new Mail Box. Then
-         * bind the mail box to the sock. It will be 
-         * used by the ioctl call to read call information
-         * and to execute commands. 
-         */	
+	 * bind the mail box to the sock. It will be
+	 * used by the ioctl call to read call information
+	 * and to execute commands.
+	 */
 	if ((mbox_ptr = kzalloc(sizeof(mbox_cmd_t), GFP_ATOMIC)) == NULL) {
 		wanpipe_kill_sock_irq (newsk);
-		release_device(dev);		
+		release_device(dev);
 		return -ENOMEM;
 	}
 	memcpy(mbox_ptr,skb->data,skb->len);
 
 	/* Register the lcn on which incoming call came
-         * from. Thus, if we have to clear it, we know
-         * which lcn to clear
-	 */ 
+	 * from. Thus, if we have to clear it, we know
+	 * which lcn to clear
+	 */
 
 	newwp->lcn = mbox_ptr->cmd.lcn;
 	newwp->mbox = (void *)mbox_ptr;
@@ -416,20 +416,20 @@ static int wanpipe_listen_rcv (struct sk_buff *skb,  struct sock *sk)
 
 	/* We must do this manually, since the sock_queue_rcv_skb()
 	 * function sets the skb->dev to NULL.  However, we use
-	 * the dev field in the accept function.*/ 
-	if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >= 
+	 * the dev field in the accept function.*/
+	if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
 	    (unsigned)sk->sk_rcvbuf) {
 
-         	wanpipe_unlink_driver(newsk);
+		wanpipe_unlink_driver(newsk);
 		wanpipe_kill_sock_irq (newsk);
 		--sk->sk_ack_backlog;
 		return -ENOMEM;
-	}	
+	}
 
 	skb_set_owner_r(skb, sk);
 	skb_queue_tail(&sk->sk_receive_queue, skb);
 	sk->sk_data_ready(sk, skb->len);
-	
+
 	return 0;
 }
 
@@ -474,7 +474,7 @@ static struct sock *wanpipe_make_new(struct sock *osk)
 	return sk;
 }
 
-/* 
+/*
  * FIXME: wanpipe_opt has to include a sock in its definition and stop using
  * sk_protinfo, but this code is not even compilable now, so lets leave it for
  * later.
@@ -489,12 +489,12 @@ static struct proto wanpipe_proto = {
  * wanpipe_make_new
  *
  *	Allocate memory for the a new sock, and sock
- *      private data.  
- *	
+ *      private data.
+ *
  *	Increment the module use count.
- *       	
- *      This function is used by wanpipe_create() and 
- *      wanpipe_make_new() functions. 
+ *
+ *      This function is used by wanpipe_create() and
+ *      wanpipe_make_new() functions.
  *
  *===========================================================*/
 
@@ -514,7 +514,7 @@ static struct sock *wanpipe_alloc_socket(void)
 	wp_sk(sk) = wan_opt;
 
 	/* Use timer to send data to the driver. This will act
-         * as a BH handler for sendmsg functions */
+	 * as a BH handler for sendmsg functions */
 	init_timer(&wan_opt->tx_timer);
 	wan_opt->tx_timer.data	   = (unsigned long)sk;
 	wan_opt->tx_timer.function = wanpipe_delayed_transmit;
@@ -528,14 +528,14 @@ static struct sock *wanpipe_alloc_socket(void)
  * wanpipe_sendmsg
  *
  *	This function implements a sendto() system call,
- *      for AF_WANPIPE socket family. 
+ *      for AF_WANPIPE socket family.
  *      During socket bind() sk->sk_bound_dev_if is initialized
  *      to a correct network device. This number is used
  *      to find a network device to which the packet should
  *      be passed to.
  *
- *      Each packet is queued into sk->sk_write_queue and 
- *      delayed transmit bottom half handler is marked for 
+ *      Each packet is queued into sk->sk_write_queue and
+ *      delayed transmit bottom half handler is marked for
  *      execution.
  *
  *      A socket must be in WANSOCK_CONNECTED state before
@@ -554,18 +554,18 @@ static int wanpipe_sendmsg(struct kiocb *iocb, struct socket *sock,
 	unsigned char *addr;
 	int ifindex, err, reserve = 0;
 
-	
+
 	if (!sock_flag(sk, SOCK_ZAPPED))
 		return -ENETDOWN;
 
 	if (sk->sk_state != WANSOCK_CONNECTED)
-		return -ENOTCONN;	
+		return -ENOTCONN;
 
-	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT)) 
+	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
 		return(-EINVAL);
 
 	/* it was <=, now one can send
-         * zero length packets */
+	 * zero length packets */
 	if (len < sizeof(x25api_hdr_t))
 		return -EINVAL;
 
@@ -577,7 +577,7 @@ static int wanpipe_sendmsg(struct kiocb *iocb, struct socket *sock,
 		addr	= NULL;
 
 	}else{
-		if (msg->msg_namelen < sizeof(struct wan_sockaddr_ll)){ 
+		if (msg->msg_namelen < sizeof(struct wan_sockaddr_ll)){
 			return -EINVAL;
 		}
 
@@ -592,12 +592,12 @@ static int wanpipe_sendmsg(struct kiocb *iocb, struct socket *sock,
 		return -ENXIO;
 	}
 	dev_put(dev);
-	
+
 	if (sock->type == SOCK_RAW)
 		reserve = dev->hard_header_len;
 
 	if (len > dev->mtu+reserve){
-  		return -EMSGSIZE;
+		return -EMSGSIZE;
 	}
 
 	skb = sock_alloc_send_skb(sk, len + LL_RESERVED_SPACE(dev),
@@ -606,7 +606,7 @@ static int wanpipe_sendmsg(struct kiocb *iocb, struct socket *sock,
 	if (skb==NULL){
 		goto out_unlock;
 	}
-		
+
 	skb_reserve(skb, LL_RESERVED_SPACE(dev));
 	skb->nh.raw = skb->data;
 
@@ -645,7 +645,7 @@ static int wanpipe_sendmsg(struct kiocb *iocb, struct socket *sock,
 
 	if (!(test_and_set_bit(0, &wp->timer)))
 		mod_timer(&wp->tx_timer, jiffies + 1);
-	
+
 	return(len);
 
 out_free:
@@ -658,12 +658,12 @@ out_unlock:
  * wanpipe_delayed_tarnsmit
  *
  *	Transmit bottom half handler. It dequeues packets
- *      from sk->sk_write_queue and passes them to the 
- *      driver.  If the driver is busy, the packet is 
- *      re-enqueued.  
+ *      from sk->sk_write_queue and passes them to the
+ *      driver.  If the driver is busy, the packet is
+ *      re-enqueued.
  *
  *      Packet Sent counter is decremented on successful
- *      transmission. 
+ *      transmission.
  *===========================================================*/
 
 
@@ -680,17 +680,17 @@ static void wanpipe_delayed_transmit (unsigned long data)
 		DBG_PRINTK(KERN_INFO "wansock: Transmit delay, no dev or card\n");
 		return;
 	}
-	
+
 	if (sk->sk_state != WANSOCK_CONNECTED || !sock_flag(sk, SOCK_ZAPPED)) {
 		clear_bit(0, &wp->timer);
 		DBG_PRINTK(KERN_INFO "wansock: Tx Timer, State not CONNECTED\n");
 		return;
 	}
-	
+
 	/* If driver is executing command, we must offload
-         * the board by not sending data. Otherwise a 
-         * pending command will never get a free buffer
-         * to execute */ 	
+	 * the board by not sending data. Otherwise a
+	 * pending command will never get a free buffer
+	 * to execute */
 	if (atomic_read(&card->u.x.command_busy)){
 		wp->tx_timer.expires = jiffies + SLOW_BACKOFF;
 		add_timer(&wp->tx_timer);
@@ -698,30 +698,30 @@ static void wanpipe_delayed_transmit (unsigned long data)
 		return;
 	}
 
-	
+
 	if (test_and_set_bit(0,&wanpipe_tx_critical)){
 		printk(KERN_INFO "WanSock: Tx timer critical %s\n",dev->name);
 		wp->tx_timer.expires = jiffies + SLOW_BACKOFF;
 		add_timer(&wp->tx_timer);
 		return;
-	}	
-	
+	}
+
 	/* Check for a packet in the fifo and send */
 	if ((skb = skb_dequeue(&sk->sk_write_queue)) != NULL){
 
-		if (dev->hard_start_xmit(skb, dev) != 0){			
+		if (dev->hard_start_xmit(skb, dev) != 0){
 
 			/* Driver failed to transmit, re-enqueue
-                         * the packet and retry again later */
+			 * the packet and retry again later */
 			skb_queue_head(&sk->sk_write_queue,skb);
 			clear_bit(0,&wanpipe_tx_critical);
 			return;
 		}else{
 
 			/* Packet Sent successful. Check for more packets
-                         * if more packets, re-trigger the transmit routine 
-                         * other wise exit
-                         */
+			 * if more packets, re-trigger the transmit routine
+			 * other wise exit
+			 */
 			atomic_dec(&wp->packet_sent);
 
 			if (skb_peek(&sk->sk_write_queue) == NULL) {
@@ -741,18 +741,18 @@ static void wanpipe_delayed_transmit (unsigned long data)
 }
 
 /*============================================================
- * execute_command 
+ * execute_command
  *
  *	Execute x25api commands.  The atomic variable
  *      chan->command is used to indicate to the driver that
  *      command is pending for execution.  The acutal command
- *      structure is placed into a sock mbox structure 
+ *      structure is placed into a sock mbox structure
  *      (wp_sk(sk)->mbox).
  *
  *      The sock private structure, mbox is
  *      used as shared memory between sock and the driver.
  *      Driver uses the sock mbox to execute the command
- *      and return the result.  
+ *      and return the result.
  *
  *      For all command except PLACE CALL, the function
  *      waits for the result.  PLACE CALL can be ether
@@ -768,7 +768,7 @@ static int execute_command(struct sock *sk,  unsigned char cmd, unsigned int fla
 	wanpipe_common_t *chan=NULL;
 	int err=0;
 	DECLARE_WAITQUEUE(wait, current);
-	
+
 	dev = dev_get_by_index(sk->sk_bound_dev_if);
 	if (dev == NULL){
 		printk(KERN_INFO "wansock: Exec failed no dev %i\n",
@@ -793,7 +793,7 @@ static int execute_command(struct sock *sk,  unsigned char cmd, unsigned int fla
 		return -EINVAL;
 	}
 
-	((mbox_cmd_t*)wp->mbox)->cmd.command = cmd;	
+	((mbox_cmd_t*)wp->mbox)->cmd.command = cmd;
 	((mbox_cmd_t*)wp->mbox)->cmd.lcn     = wp->lcn;
 	((mbox_cmd_t*)wp->mbox)->cmd.result  = 0x7F;
 
@@ -820,12 +820,12 @@ static int execute_command(struct sock *sk,  unsigned char cmd, unsigned int fla
 	}
 	current->state = TASK_RUNNING;
 	remove_wait_queue(sk->sk_sleep,&wait);
-	
+
 	return err;
 }
 
 /*============================================================
- * wanpipe_destroy_timer 
+ * wanpipe_destroy_timer
  *
  *	Used by wanpipe_release, to delay release of
  *      the socket.
@@ -846,7 +846,7 @@ static void wanpipe_destroy_timer(unsigned long data)
 
 		kfree(wp);
 		wp_sk(sk) = NULL;
-		
+
 		if (atomic_read(&sk->sk_refcnt) != 1) {
 			atomic_set(&sk->sk_refcnt, 1);
 			DBG_PRINTK(KERN_INFO "wansock: Error, wrong reference count: %i ! :delay.\n",
@@ -865,9 +865,9 @@ static void wanpipe_destroy_timer(unsigned long data)
 /*============================================================
  * wanpipe_unlink_driver
  *
- * 	When the socket is released, this function is 
+ * 	When the socket is released, this function is
  *      used to remove links that bind the sock and the
- *      driver together.  
+ *      driver together.
  *===========================================================*/
 static void wanpipe_unlink_driver (struct sock *sk)
 {
@@ -882,7 +882,7 @@ static void wanpipe_unlink_driver (struct sock *sk)
 	if (!dev){
 		printk(KERN_INFO "wansock: No dev on release\n");
 		return;
-	}			
+	}
 	dev_put(dev);
 
 	if ((chan = dev->priv) == NULL){
@@ -897,7 +897,7 @@ static void wanpipe_unlink_driver (struct sock *sk)
 	chan->tx_timer=NULL;
 	clear_bit(0,&chan->common_critical);
 	release_device(dev);
-	
+
 	return;
 }
 
@@ -931,7 +931,7 @@ static void wanpipe_link_driver(struct net_device *dev, struct sock *sk)
 /*============================================================
  * release_device
  *
- *   	During sock release, clear a critical bit, which 
+ *   	During sock release, clear a critical bit, which
  *      marks the device a being taken.
  *===========================================================*/
 
@@ -945,8 +945,8 @@ static void release_device(struct net_device *dev)
 /*============================================================
  * wanpipe_release
  *
- *	Close a PACKET socket. This is fairly simple. We 
- *      immediately go to 'closed' state and remove our 
+ *	Close a PACKET socket. This is fairly simple. We
+ *      immediately go to 'closed' state and remove our
  *      protocol entry in the device list.
  *===========================================================*/
 
@@ -954,7 +954,7 @@ static int wanpipe_release(struct socket *sock)
 {
 	wanpipe_opt *wp;
 	struct sock *sk = sock->sk;
-	
+
 	if (!sk)
 		return 0;
 
@@ -962,9 +962,9 @@ static int wanpipe_release(struct socket *sock)
 	check_write_queue(sk);
 
 	/* Kill the tx timer, if we don't kill it now, the timer
-         * will run after we kill the sock.  Timer code will 
-         * try to access the sock which has been killed and cause
-         * kernel panic */
+	 * will run after we kill the sock.  Timer code will
+	 * try to access the sock which has been killed and cause
+	 * kernel panic */
 
 	del_timer(&wp->tx_timer);
 
@@ -982,7 +982,7 @@ static int wanpipe_release(struct socket *sock)
 			DBG_PRINTK(KERN_INFO "wansock: Sending Clear Indication %i\n",
 					sk->sk_state);
 			dev_put(dev);
-		}	
+		}
 	}
 
 	set_bit(1,&wanpipe_tx_critical);
@@ -992,10 +992,10 @@ static int wanpipe_release(struct socket *sock)
 	clear_bit(1,&wanpipe_tx_critical);
 
 
-	
+
 	release_driver(sk);
 
-	
+
 	/*
 	 *	Now the socket is dead. No more input will appear.
 	 */
@@ -1040,9 +1040,9 @@ static int wanpipe_release(struct socket *sock)
 /*============================================================
  * check_write_queue
  *
- *  	During sock shutdown, if the sock state is 
- *      WANSOCK_CONNECTED and there is transmit data 
- *      pending. Wait until data is released 
+ *  	During sock shutdown, if the sock state is
+ *      WANSOCK_CONNECTED and there is transmit data
+ *      pending. Wait until data is released
  *      before proceeding.
  *===========================================================*/
 
@@ -1062,7 +1062,7 @@ static void check_write_queue(struct sock *sk)
 /*============================================================
  * release_driver
  *
- *	This function is called during sock shutdown, to 
+ *	This function is called during sock shutdown, to
  *      release any resources and links that bind the sock
  *      to the driver.  It also changes the state of the
  *      sock to WANSOCK_DISCONNECTED
@@ -1105,7 +1105,7 @@ static void release_driver(struct sock *sk)
  *  start_cleanup_timer
  *
  *  	If new incoming call's are pending but the socket
- *      is being released, start the timer which will 
+ *      is being released, start the timer which will
  *      envoke the kill routines for pending socks.
  *===========================================================*/
 
@@ -1125,7 +1125,7 @@ static void start_cleanup_timer (struct sock *sk)
  *
  *	This is a function which performs actual killing
  *      of the sock.  It releases socket resources,
- *      and unlinks the sock from the driver. 
+ *      and unlinks the sock from the driver.
  *===========================================================*/
 
 static void wanpipe_kill_sock_timer (unsigned long data)
@@ -1139,13 +1139,13 @@ static void wanpipe_kill_sock_timer (unsigned long data)
 
 	/* This function can be called from interrupt. We must use
 	 * appropriate locks */
-	
+
 	if (test_bit(1,&wanpipe_tx_critical)){
 		sk->sk_timer.expires = jiffies + 10;
 		add_timer(&sk->sk_timer);
 		return;
 	}
-	
+
 	write_lock(&wanpipe_sklist_lock);
 	sk_del_node_init(sk);
 	write_unlock(&wanpipe_sklist_lock);
@@ -1159,7 +1159,7 @@ static void wanpipe_kill_sock_timer (unsigned long data)
 			chan=dev->priv;
 			atomic_set(&chan->disconnect,1);
 			dev_put(dev);
-		}	
+		}
 	}
 
 	release_driver(sk);
@@ -1170,7 +1170,7 @@ static void wanpipe_kill_sock_timer (unsigned long data)
 	skb_queue_purge(&sk->sk_receive_queue);
 	skb_queue_purge(&sk->sk_write_queue);
 	skb_queue_purge(&sk->sk_error_queue);
-	
+
 	if (atomic_read(&sk->sk_rmem_alloc) ||
 	    atomic_read(&sk->sk_wmem_alloc)) {
 		del_timer(&sk->sk_timer);
@@ -1205,7 +1205,7 @@ static void wanpipe_kill_sock_accept (struct sock *sk)
 
 	/* This function can be called from interrupt. We must use
 	 * appropriate locks */
-	
+
 	write_lock(&wanpipe_sklist_lock);
 	sk_del_node_init(sk);
 	write_unlock(&wanpipe_sklist_lock);
@@ -1282,10 +1282,10 @@ static int wanpipe_do_bind(struct sock *sk, struct net_device *dev,
 			chan=dev->priv;
 			sk->sk_state = chan->state;
 
-			if (wp->num == htons(X25_PROT) && 
-			    sk->sk_state != WANSOCK_DISCONNECTED && 
+			if (wp->num == htons(X25_PROT) &&
+			    sk->sk_state != WANSOCK_DISCONNECTED &&
 			    sk->sk_state != WANSOCK_CONNECTING) {
-				DBG_PRINTK(KERN_INFO 
+				DBG_PRINTK(KERN_INFO
 					"wansock: Binding to Device not DISCONNECTED %i\n",
 						sk->sk_state);
 				release_device(dev);
@@ -1338,7 +1338,7 @@ static int wanpipe_bind(struct socket *sock, struct sockaddr *uaddr, int addr_le
 	/*
 	 *	Check legality
 	 */
-	 
+
 	if (addr_len < sizeof(struct wan_sockaddr_ll)){
 		printk(KERN_INFO "wansock: Address length error\n");
 		return -EINVAL;
@@ -1358,12 +1358,12 @@ static int wanpipe_bind(struct socket *sock, struct sockaddr *uaddr, int addr_le
 
 	if (!strcmp(sll->sll_device,"svc_listen")){
 
-		/* Bind a sock to a card structure for listening 
-		 */		
-		int err=0; 
+		/* Bind a sock to a card structure for listening
+		 */
+		int err=0;
 
 		/* This is x25 specific area if protocol doesn't
-                 * match, return error */
+		 * match, return error */
 		if (sll->sll_protocol != htons(X25_PROT))
 			return -EINVAL;
 
@@ -1376,14 +1376,14 @@ static int wanpipe_bind(struct socket *sock, struct sockaddr *uaddr, int addr_le
 		sk->sk_state = WANSOCK_BIND_LISTEN;
 		return 0;
 
-	}else if (!strcmp(sll->sll_device,"svc_connect")){ 
+	}else if (!strcmp(sll->sll_device,"svc_connect")){
 
 		/* This is x25 specific area if protocol doesn't
-                 * match, return error */
+		 * match, return error */
 		if (sll->sll_protocol != htons(X25_PROT))
 			return -EINVAL;
 
-		/* Find a free device 
+		/* Find a free device
 		 */
 		dev = wanpipe_find_free_dev(card);
 		if (dev == NULL){
@@ -1392,9 +1392,9 @@ static int wanpipe_bind(struct socket *sock, struct sockaddr *uaddr, int addr_le
 			return -EINVAL;
 		}
 	}else{
-		/* Bind a socket to a interface name 
-                 * This is used by PVC mostly
-                 */
+		/* Bind a socket to a interface name
+		 * This is used by PVC mostly
+		 */
 		strlcpy(name,sll->sll_device,sizeof(name));
 		dev = dev_get_by_name(name);
 		if (dev == NULL){
@@ -1419,8 +1419,8 @@ static int wanpipe_bind(struct socket *sock, struct sockaddr *uaddr, int addr_le
 
 /*============================================================
  * get_atomic_device
- *	
- *	Sets a bit atomically which indicates that 
+ *
+ *	Sets a bit atomically which indicates that
  *      the interface is taken. This avoids race conditions.
  *===========================================================*/
 
@@ -1436,7 +1436,7 @@ static inline int get_atomic_device(struct net_device *dev)
 
 /*============================================================
  * check_dev
- *	
+ *
  *  	Check that device name belongs to a particular card.
  *===========================================================*/
 
@@ -1446,8 +1446,8 @@ static int check_dev(struct net_device *dev, sdla_t *card)
 
 	for (tmp_dev = card->wandev.dev; tmp_dev;
 	     tmp_dev = *((struct net_device **)tmp_dev->priv)) {
-		if (tmp_dev->ifindex == dev->ifindex){ 
-			return 0;	
+		if (tmp_dev->ifindex == dev->ifindex){
+			return 0;
 		}
 	}
 	return 1;
@@ -1455,7 +1455,7 @@ static int check_dev(struct net_device *dev, sdla_t *card)
 
 /*============================================================
  *  wanpipe_find_free_dev
- *	
+ *
  *	Find a free network interface. If found set atomic
  *      bit indicating that the interface is taken.
  *      X25API Specific.
@@ -1468,12 +1468,12 @@ struct net_device *wanpipe_find_free_dev(sdla_t *card)
 
 	if (test_and_set_bit(0,&find_free_critical)){
 		printk(KERN_INFO "CRITICAL in Find Free\n");
-	}	
+	}
 
 	for (dev = card->wandev.dev; dev;
 	     dev = *((struct net_device **)dev->priv)) {
 		chan = dev->priv;
-		if (!chan) 
+		if (!chan)
 			continue;
 		if (chan->usedby == API && chan->svc){
 			if (!get_atomic_device (dev)){
@@ -1492,16 +1492,16 @@ struct net_device *wanpipe_find_free_dev(sdla_t *card)
 
 /*============================================================
  *  wanpipe_create
- *	
+ *
  * 	SOCKET() System call.  It allocates a sock structure
- *      and adds the socket to the wanpipe_sk_list. 
+ *      and adds the socket to the wanpipe_sk_list.
  *      Crates AF_WANPIPE socket.
  *===========================================================*/
 
 static int wanpipe_create(struct socket *sock, int protocol)
 {
 	struct sock *sk;
-	
+
 	//FIXME: This checks for root user, SECURITY ?
 	//if (!capable(CAP_NET_RAW))
 	//	return -EPERM;
@@ -1526,7 +1526,7 @@ static int wanpipe_create(struct socket *sock, int protocol)
 	sk->sk_bound_dev_if = 0;
 
 	atomic_inc(&wanpipe_socks_nr);
-	
+
 	/* We must disable interrupts because the ISR
 	 * can also change the list */
 	set_bit(1,&wanpipe_tx_critical);
@@ -1541,8 +1541,8 @@ static int wanpipe_create(struct socket *sock, int protocol)
 
 /*============================================================
  *  wanpipe_recvmsg
- *	
- *	Pull a packet from our receive queue and hand it 
+ *
+ *	Pull a packet from our receive queue and hand it
  *      to the user. If necessary we block.
  *===========================================================*/
 
@@ -1570,13 +1570,13 @@ static int wanpipe_recvmsg(struct kiocb *iocb, struct socket *sock,
 	 *	but then it will block.
 	 */
 
-	if (flags & MSG_OOB){	
+	if (flags & MSG_OOB){
 		skb = skb_dequeue(&sk->sk_error_queue);
 	}else{
 		skb=skb_recv_datagram(sk,flags,1,&err);
 	}
 	/*
-	 *	An error occurred so return it. Because skb_recv_datagram() 
+	 *	An error occurred so return it. Because skb_recv_datagram()
 	 *	handles the blocking we don't see and worry about blocking
 	 *	retries.
 	 */
@@ -1602,9 +1602,9 @@ static int wanpipe_recvmsg(struct kiocb *iocb, struct socket *sock,
 	err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
 	if (err)
 		goto out_free;
-	
+
 	sock_recv_timestamp(msg, sk, skb);
-	
+
 	if (msg->msg_name)
 		memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
 
@@ -1623,13 +1623,13 @@ out:
 
 /*============================================================
  *  wanpipe_wakeup_driver
- *	
+ *
  * 	If socket receive buffer is full and driver cannot
  *      pass data up the sock, it sets a packet_block flag.
- *      This function check that flag and if sock receive 
- *      queue has room it kicks the driver BH handler. 
+ *      This function check that flag and if sock receive
+ *      queue has room it kicks the driver BH handler.
  *
- * 	This way, driver doesn't have to poll the sock 
+ * 	This way, driver doesn't have to poll the sock
  *      receive queue.
  *===========================================================*/
 
@@ -1646,8 +1646,8 @@ static void wanpipe_wakeup_driver(struct sock *sk)
 
 	if ((chan = dev->priv) == NULL)
 		return;
-	
-	if (atomic_read(&chan->receive_block)){  
+
+	if (atomic_read(&chan->receive_block)){
 		if (atomic_read(&sk->sk_rmem_alloc) <
 		    ((unsigned)sk->sk_rcvbuf * 0.9)) {
 			printk(KERN_INFO "wansock: Queuing task for wanpipe\n");
@@ -1655,13 +1655,13 @@ static void wanpipe_wakeup_driver(struct sock *sk)
 			wanpipe_queue_tq(&chan->wanpipe_task);
 			wanpipe_mark_bh();
 		}
-	}	
-}	
+	}
+}
 
 /*============================================================
  *  wanpipe_getname
- *	
- * 	I don't know what to do with this yet. 
+ *
+ * 	I don't know what to do with this yet.
  *      User can use this function to get sock address
  *      information. Not very useful for Sangoma's purposes.
  *===========================================================*/
@@ -1687,17 +1687,17 @@ static int wanpipe_getname(struct socket *sock, struct sockaddr *uaddr,
 		sll->sll_halen = 0;
 	}
 	*uaddr_len = sizeof(*sll);
-	
+
 	dev_put(dev);
-	
+
 	return 0;
 }
 
 /*============================================================
  *  wanpipe_notifier
- *	
+ *
  *	If driver turns off network interface, this function
- *      will be envoked. Currently I treate it as a 
+ *      will be envoked. Currently I treate it as a
  *      call disconnect. More thought should go into this
  *      function.
  *
@@ -1718,7 +1718,7 @@ static int wanpipe_notifier(struct notifier_block *this, unsigned long msg, void
 			continue;
 		if (dev == NULL)
 			continue;
-		
+
 		switch (msg) {
 		case NETDEV_DOWN:
 		case NETDEV_UNREGISTER:
@@ -1732,7 +1732,7 @@ static int wanpipe_notifier(struct notifier_block *this, unsigned long msg, void
 
 				if (msg == NETDEV_UNREGISTER) {
 					printk(KERN_INFO "wansock: Unregistering Device: %s\n",
-						 	  dev->name);
+							  dev->name);
 					wanpipe_unlink_driver(sk);
 					sk->sk_bound_dev_if = 0;
 				}
@@ -1753,7 +1753,7 @@ static int wanpipe_notifier(struct notifier_block *this, unsigned long msg, void
 
 /*============================================================
  *  wanpipe_ioctl
- *	
+ *
  * 	Execute a user commands, and set socket options.
  *
  * FIXME: More thought should go into this function.
@@ -1765,7 +1765,7 @@ static int wanpipe_ioctl(struct socket *sock, unsigned int cmd, unsigned long ar
 	struct sock *sk = sock->sk;
 	int err;
 
-	switch(cmd) 
+	switch(cmd)
 	{
 		case SIOCGSTAMP:
 			return sock_get_timestamp(sk, (struct timeval __user *)arg);
@@ -1778,7 +1778,7 @@ static int wanpipe_ioctl(struct socket *sock, unsigned int cmd, unsigned long ar
 
 			if (sk->sk_state == WANSOCK_CONNECTED)
 				return 0;
-			
+
 			return 1;
 
 
@@ -1804,7 +1804,7 @@ static int wanpipe_ioctl(struct socket *sock, unsigned int cmd, unsigned long ar
 		case SIOC_WANPIPE_DEBUG:
 
 			return wanpipe_debug(sk,(void*)arg);
-	
+
 		case SIOC_WANPIPE_SET_NONBLOCK:
 
 			if (sk->sk_state != WANSOCK_DISCONNECTED)
@@ -1812,7 +1812,7 @@ static int wanpipe_ioctl(struct socket *sock, unsigned int cmd, unsigned long ar
 
 			sock->file->f_flags |= O_NONBLOCK;
 			return 0;
-	
+
 #ifdef CONFIG_INET
 		case SIOCADDRT:
 		case SIOCDELRT:
@@ -1842,7 +1842,7 @@ static int wanpipe_ioctl(struct socket *sock, unsigned int cmd, unsigned long ar
 
 /*============================================================
  *  wanpipe_debug
- *	
+ *
  *	This function will pass up information about all
  *      active sockets.
  *
@@ -1893,49 +1893,49 @@ static int wanpipe_debug (struct sock *origsk, void *arg)
 
 		if (sk->sk_bound_dev_if) {
 			dev = dev_get_by_index(sk->sk_bound_dev_if);
-			if (!dev)	
+			if (!dev)
 				continue;
 
 			chan=dev->priv;
 			dev_put(dev);
-	
+
 			if ((err=put_user(chan->state, &dbg_data->debug[cnt].d_state)))
 				return err;
 			if ((err=put_user(chan->svc, &dbg_data->debug[cnt].svc)))
 				return err;
 
-			if ((err=put_user(atomic_read(&chan->command), 
+			if ((err=put_user(atomic_read(&chan->command),
 						&dbg_data->debug[cnt].command)))
 				return err;
 
 
 			if (wp){
-				sdla_t *card = (sdla_t*)wp->card;			
-	
+				sdla_t *card = (sdla_t*)wp->card;
+
 				if (card){
-					if ((err=put_user(atomic_read(&card->u.x.command_busy), 
+					if ((err=put_user(atomic_read(&card->u.x.command_busy),
 								&dbg_data->debug[cnt].cmd_busy)))
 						return err;
 				}
 
-				if ((err=put_user(wp->lcn, 
+				if ((err=put_user(wp->lcn,
 						  &dbg_data->debug[cnt].lcn)))
 					return err;
-				
+
 				if (wp->mbox) {
 					if ((err=put_user(1, &dbg_data->debug[cnt].mbox)))
 						return err;
 				}
 			}
 
-			if ((err=put_user(atomic_read(&chan->receive_block), 
+			if ((err=put_user(atomic_read(&chan->receive_block),
 								&dbg_data->debug[cnt].rblock)))
 				return err;
 
 			if (copy_to_user(dbg_data->debug[cnt].name, dev->name, strlen(dev->name)))
 				return -EFAULT;
 		}
-	
+
 		if (++cnt == MAX_NUM_DEBUG)
 			break;
 	}
@@ -1944,7 +1944,7 @@ static int wanpipe_debug (struct sock *origsk, void *arg)
 
 /*============================================================
  *  get_ioctl_cmd
- *	
+ *
  *	Pass up the contents of socket MBOX to the user.
  *===========================================================*/
 
@@ -1974,7 +1974,7 @@ static int get_ioctl_cmd (struct sock *sk, void *arg)
 	if ((err=put_user(mbox_ptr->cmd.result, &usr_data->hdr.result)))
 		return err;
 	if ((err=put_user(mbox_ptr->cmd.lcn, &usr_data->hdr.lcn)))
-		return err;	
+		return err;
 
 	if (mbox_ptr->cmd.length > 0){
 		if (mbox_ptr->cmd.length > X25_MAX_DATA)
@@ -1986,13 +1986,13 @@ static int get_ioctl_cmd (struct sock *sk, void *arg)
 		}
 	}
 	return 0;
-} 
+}
 
 /*============================================================
  *  set_ioctl_cmd
- *	
+ *
  *	Before command can be execute, socket MBOX must
- *      be created, and initialized with user data.	
+ *      be created, and initialized with user data.
  *===========================================================*/
 
 static int set_ioctl_cmd (struct sock *sk, void *arg)
@@ -2008,7 +2008,7 @@ static int set_ioctl_cmd (struct sock *sk, void *arg)
 			return -ENODEV;
 
 		dev_put(dev);
-		
+
 		if ((mbox_ptr = kzalloc(sizeof(mbox_cmd_t), GFP_ATOMIC)) == NULL)
 			return -ENOMEM;
 
@@ -2092,12 +2092,12 @@ unsigned int wanpipe_poll(struct file * file, struct socket *sock, poll_table *w
 		return mask;
 	}
 
-	/* This check blocks the user process if there is   
+	/* This check blocks the user process if there is
 	 * a packet already queued in the socket write queue.
-         * This option is only for X25API protocol, for other
-         * protocol like chdlc enable streaming mode, 
-         * where multiple packets can be pending in the socket 
-         * transmit queue */
+	 * This option is only for X25API protocol, for other
+	 * protocol like chdlc enable streaming mode,
+	 * where multiple packets can be pending in the socket
+	 * transmit queue */
 
 	if (wp_sk(sk)->num == htons(X25_PROT)) {
 		if (atomic_read(&wp_sk(sk)->packet_sent))
@@ -2110,7 +2110,7 @@ unsigned int wanpipe_poll(struct file * file, struct socket *sock, poll_table *w
 	}else{
 		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 	}
-		
+
 	return mask;
 }
 
@@ -2125,8 +2125,8 @@ static int wanpipe_listen(struct socket *sock, int backlog)
 {
 	struct sock *sk = sock->sk;
 
- 	/* This is x25 specific area if protocol doesn't
-         * match, return error */
+	/* This is x25 specific area if protocol doesn't
+	 * match, return error */
 	if (wp_sk(sk)->num != htons(X25_PROT))
 		return -EINVAL;
 
@@ -2163,7 +2163,7 @@ static int wanpipe_link_card (struct sock *sk)
 	card->sk=sk;
 	card->func=wanpipe_listen_rcv;
 	sock_set_flag(sk, SOCK_ZAPPED);
- 
+
 	return 0;
 }
 
@@ -2176,7 +2176,7 @@ static int wanpipe_link_card (struct sock *sk)
 
 static void wanpipe_unlink_card (struct sock *sk)
 {
-	sdla_t *card = (sdla_t*)wp_sk(sk)->card; 
+	sdla_t *card = (sdla_t*)wp_sk(sk)->card;
 
 	if (card){
 		card->sk=NULL;
@@ -2202,9 +2202,9 @@ static int wanpipe_exec_cmd(struct sock *sk, int cmd, unsigned int flags)
 		printk(KERN_INFO "NO MBOX PTR !!!!!\n");
 		return -EINVAL;
 	}
-	
+
 	/* This is x25 specific area if protocol doesn't
-         * match, return error */
+	 * match, return error */
 	if (wp->num != htons(X25_PROT))
 		return -EINVAL;
 
@@ -2217,17 +2217,17 @@ static int wanpipe_exec_cmd(struct sock *sk, int cmd, unsigned int flags)
 				err = -EHOSTDOWN;
 				break;
 			}
-			
+
 			err = execute_command(sk,X25_ACCEPT_CALL,0);
 			if (err < 0)
 				break;
 
-			/* Update. Mar6 2000. 
-                         * Do not set the sock lcn number here, since
-                         * it is done in wanpipe_listen_rcv(). 
-                         */ 
-		 	if (sk->sk_state == WANSOCK_CONNECTED) {
-				wp->lcn = ((mbox_cmd_t*)wp->mbox)->cmd.lcn;	
+			/* Update. Mar6 2000.
+			 * Do not set the sock lcn number here, since
+			 * it is done in wanpipe_listen_rcv().
+			 */
+			if (sk->sk_state == WANSOCK_CONNECTED) {
+				wp->lcn = ((mbox_cmd_t*)wp->mbox)->cmd.lcn;
 				DBG_PRINTK(KERN_INFO "\nwansock: Accept OK %i\n",
 					wp->lcn);
 				err = 0;
@@ -2249,15 +2249,15 @@ static int wanpipe_exec_cmd(struct sock *sk, int cmd, unsigned int flags)
 
 
 			/* Check if data buffers are pending for transmission,
-                         * if so, check whether user wants to wait until data
-                         * is transmitted, or clear a call and drop packets */
-                          
+			 * if so, check whether user wants to wait until data
+			 * is transmitted, or clear a call and drop packets */
+
 			if (atomic_read(&sk->sk_wmem_alloc) ||
 			    check_driver_busy(sk)) {
-			  	mbox_cmd_t *mbox = wp->mbox;
+				mbox_cmd_t *mbox = wp->mbox;
 				if (mbox->cmd.qdm & 0x80){
 					mbox->cmd.result = 0x35;
-					err = -EAGAIN;	
+					err = -EAGAIN;
 					break;
 				}
 			}
@@ -2286,15 +2286,15 @@ static int wanpipe_exec_cmd(struct sock *sk, int cmd, unsigned int flags)
 
 
 			/* Check if data buffers are pending for transmission,
-                         * if so, check whether user wants to wait until data
-                         * is transmitted, or reset a call and drop packets */
-                          
+			 * if so, check whether user wants to wait until data
+			 * is transmitted, or reset a call and drop packets */
+
 			if (atomic_read(&sk->sk_wmem_alloc) ||
 			    check_driver_busy(sk)) {
-			  	mbox_cmd_t *mbox = wp->mbox;
+				mbox_cmd_t *mbox = wp->mbox;
 				if (mbox->cmd.qdm & 0x80){
 					mbox->cmd.result = 0x35;
-					err = -EAGAIN;	
+					err = -EAGAIN;
 					break;
 				}
 			}
@@ -2316,7 +2316,7 @@ static int wanpipe_exec_cmd(struct sock *sk, int cmd, unsigned int flags)
 
 			if (sk->sk_state == WANSOCK_CONNECTED) {
 
-				wp->lcn = ((mbox_cmd_t*)wp->mbox)->cmd.lcn;	
+				wp->lcn = ((mbox_cmd_t*)wp->mbox)->cmd.lcn;
 
 				DBG_PRINTK(KERN_INFO "\nwansock: PLACE CALL OK %i\n",
 					wp->lcn);
@@ -2337,7 +2337,7 @@ static int wanpipe_exec_cmd(struct sock *sk, int cmd, unsigned int flags)
 
 			break;
 
-		default: 
+		default:
 			return -EINVAL;
 	}
 
@@ -2364,9 +2364,9 @@ static int check_driver_busy (struct sock *sk)
 /*======================================================================
  * wanpipe_accept
  *
- *	ACCEPT() System call.	X25API Specific function. 
- *	For each incoming call, create a new socket and 
- *      return it to the user.	
+ *	ACCEPT() System call.	X25API Specific function.
+ *	For each incoming call, create a new socket and
+ *      return it to the user.
  *=====================================================================*/
 
 static int wanpipe_accept(struct socket *sock, struct socket *newsock, int flags)
@@ -2378,10 +2378,10 @@ static int wanpipe_accept(struct socket *sock, struct socket *newsock, int flags
 	int err=0;
 
 	if (newsock->sk != NULL){
-		wanpipe_kill_sock_accept(newsock->sk);	
+		wanpipe_kill_sock_accept(newsock->sk);
 		newsock->sk=NULL;
 	}
-	
+
 	if ((sk = sock->sk) == NULL)
 		return -EINVAL;
 
@@ -2410,10 +2410,10 @@ static int wanpipe_accept(struct socket *sock, struct socket *newsock, int flags
 	}
 	current->state = TASK_RUNNING;
 	remove_wait_queue(sk->sk_sleep,&wait);
-	
+
 	if (err != 0)
 		return err;
-	
+
 	newsk = get_newsk_from_skb(skb);
 	if (!newsk){
 		return -EINVAL;
@@ -2431,7 +2431,7 @@ static int wanpipe_accept(struct socket *sock, struct socket *newsock, int flags
 	/* Now attach up the new socket */
 	sk->sk_ack_backlog--;
 	newsock->sk = newsk;
-	
+
 	kfree_skb(skb);
 
 	DBG_PRINTK(KERN_INFO "\nwansock: ACCEPT Got LCN %i\n",
@@ -2449,16 +2449,16 @@ static int wanpipe_accept(struct socket *sock, struct socket *newsock, int flags
 struct sock * get_newsk_from_skb (struct sk_buff *skb)
 {
 	struct net_device *dev = skb->dev;
-	wanpipe_common_t *chan;	
+	wanpipe_common_t *chan;
 
 	if (!dev){
 		return NULL;
 	}
-		
+
 	if ((chan = dev->priv) == NULL){
 		return NULL;
 	}
-		
+
 	if (!chan->sk){
 		return NULL;
 	}
@@ -2470,7 +2470,7 @@ struct sock * get_newsk_from_skb (struct sk_buff *skb)
  *
  *  	CONNECT() System Call. X25API specific function
  * 	Check the state of the sock, and execute PLACE_CALL command.
- *      Connect can ether block or return without waiting for connection, 
+ *      Connect can ether block or return without waiting for connection,
  *      if specified by user.
  *=====================================================================*/
 
@@ -2492,7 +2492,7 @@ static int wanpipe_connect(struct socket *sock, struct sockaddr *uaddr, int addr
 		return -ECONNREFUSED;
 	}
 
-	sk->sk_state = WANSOCK_DISCONNECTED;	
+	sk->sk_state = WANSOCK_DISCONNECTED;
 	sock->state  = SS_UNCONNECTED;
 
 	if (addr_len != sizeof(struct wan_sockaddr_ll))
@@ -2505,7 +2505,7 @@ static int wanpipe_connect(struct socket *sock, struct sockaddr *uaddr, int addr
 		return -ENETUNREACH;
 
 	dev_put(dev);
-	
+
 	if (!sock_flag(sk, SOCK_ZAPPED)) /* Must bind first - autobinding does not work */
 		return -EINVAL;
 
@@ -2534,7 +2534,7 @@ static int wanpipe_connect(struct socket *sock, struct sockaddr *uaddr, int addr
 
 	if (sk->sk_state != WANSOCK_CONNECTED) {
 		sock->state = SS_UNCONNECTED;
-		return -ECONNREFUSED; 
+		return -ECONNREFUSED;
 	}
 
 	sock->state = SS_CONNECTED;
@@ -2549,10 +2549,10 @@ const struct proto_ops wanpipe_ops = {
 	.connect = 	wanpipe_connect,
 	.socketpair = 	sock_no_socketpair,
 	.accept = 	wanpipe_accept,
-	.getname = 	wanpipe_getname, 
+	.getname = 	wanpipe_getname,
 	.poll = 	wanpipe_poll,
 	.ioctl = 	wanpipe_ioctl,
-	.listen = 	wanpipe_listen, 
+	.listen = 	wanpipe_listen,
 	.shutdown = 	sock_no_shutdown,
 	.setsockopt = 	sock_no_setsockopt,
 	.getsockopt = 	sock_no_getsockopt,
diff --git a/net/wanrouter/wanmain.c b/net/wanrouter/wanmain.c
index 4d90a17..5d2d93d 100644
--- a/net/wanrouter/wanmain.c
+++ b/net/wanrouter/wanmain.c
@@ -314,10 +314,10 @@ __be16 wanrouter_type_trans(struct sk_buff *skb, struct net_device *dev)
 		cnt += 1;
 		break;
 
-        case NLPID_SNAP:	/* SNAP encapsulation */
+	case NLPID_SNAP:	/* SNAP encapsulation */
 		if (memcmp(&skb->data[cnt + 1], wanrouter_oui_ether,
 			   sizeof(wanrouter_oui_ether))){
-          		printk(KERN_INFO
+			printk(KERN_INFO
 				"%s: unsupported SNAP OUI %02X-%02X-%02X "
 				"on interface %s!\n", wanrouter_modname,
 				skb->data[cnt+1], skb->data[cnt+2],
@@ -450,7 +450,7 @@ static int wanrouter_device_setup(struct wan_device *wandev,
 		kfree(conf);
 		printk(KERN_INFO "%s: ERROR, Invalid MAGIC Number\n",
 				wandev->name);
-	        return -EINVAL;
+		return -EINVAL;
 	}
 
 	if (conf->data_size && conf->data) {
@@ -459,13 +459,13 @@ static int wanrouter_device_setup(struct wan_device *wandev,
 			    "%s: ERROR, Invalid firmware data size %i !\n",
 					wandev->name, conf->data_size);
 			kfree(conf);
-		        return -EINVAL;
+			return -EINVAL;
 		}
 
 		data = vmalloc(conf->data_size);
 		if (!data) {
 			printk(KERN_INFO
-			 	"%s: ERROR, Faild allocate kernel memory !\n",
+				"%s: ERROR, Faild allocate kernel memory !\n",
 				wandev->name);
 			kfree(conf);
 			return -ENOBUFS;
@@ -686,7 +686,7 @@ out:
 static int wanrouter_device_del_if(struct wan_device *wandev, char __user *u_name)
 {
 	char name[WAN_IFNAME_SZ + 1];
-        int err = 0;
+	int err = 0;
 
 	if (wandev->state == WAN_UNCONFIGURED)
 		return -ENODEV;
@@ -709,8 +709,8 @@ static int wanrouter_device_del_if(struct wan_device *wandev, char __user *u_nam
 	 * interfaces are deleted and the link irrecoverably disconnected.
 	 */
 
-        if (!wandev->ndev && wandev->shutdown)
-                err = wandev->shutdown(wandev);
+	if (!wandev->ndev && wandev->shutdown)
+		err = wandev->shutdown(wandev);
 
 	return err;
 }
@@ -804,7 +804,7 @@ static int wanrouter_delete_interface(struct wan_device *wandev, char *name)
 
 static void lock_adapter_irq(spinlock_t *lock, unsigned long *smp_flags)
 {
-       	spin_lock_irqsave(lock, *smp_flags);
+	spin_lock_irqsave(lock, *smp_flags);
 }
 
 
diff --git a/net/wanrouter/wanproc.c b/net/wanrouter/wanproc.c
index 930ea59..abce828 100644
--- a/net/wanrouter/wanproc.c
+++ b/net/wanrouter/wanproc.c
@@ -37,10 +37,10 @@
 
 #define PROT_DECODE(prot) ((prot == WANCONFIG_FR) ? " FR" :\
 			      (prot == WANCONFIG_X25) ? " X25" : \
-			         (prot == WANCONFIG_PPP) ? " PPP" : \
+				 (prot == WANCONFIG_PPP) ? " PPP" : \
 				    (prot == WANCONFIG_CHDLC) ? " CHDLC": \
 				       (prot == WANCONFIG_MPPP) ? " MPPP" : \
-				           " Unknown" )
+					   " Unknown" )
 
 /****** Function Prototypes *************************************************/