[PATCH] kill warnings 19/19

and now the final irda offender :-).

net/irda/wrapper.c

 /*********************************************************************
- *                
+ *
  * Filename:      wrapper.c
  * Version:       1.2
  * Description:   IrDA SIR async wrapper layer
@@ -10,17 +10,17 @@
  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  * Modified at:   Fri May 28  3:11 CST 1999
  * Modified by:   Horst von Brand <vonbrand@sleipnir.valparaiso.cl>
- * 
- *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>, 
+ *
+ *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
  *     All Rights Reserved.
- *     
- *     This program is free software; you can redistribute it and/or 
- *     modify it under the terms of the GNU General Public License as 
- *     published by the Free Software Foundation; either version 2 of 
+ *
+ *     This program is free software; you can redistribute it and/or
+ *     modify it under the terms of the GNU General Public License as
+ *     published by the Free Software Foundation; either version 2 of
  *     the License, or (at your option) any later version.
  *
  *     Neither Dag Brattli nor University of Troms admit liability nor
- *     provide warranty for any of this software. This material is 
+ *     provide warranty for any of this software. This material is
  *     provided "AS-IS" and at no charge.
  *
  ********************************************************************/
@@ -39,22 +39,22 @@
 
 static inline int stuff_byte(__u8 byte, __u8 *buf);
 
-static void state_outside_frame(struct net_device *dev, 
-				struct net_device_stats *stats, 
+static void state_outside_frame(struct net_device *dev,
+				struct net_device_stats *stats,
 				iobuff_t *rx_buff, __u8 byte);
-static void state_begin_frame(struct net_device *dev, 
-			      struct net_device_stats *stats, 
+static void state_begin_frame(struct net_device *dev,
+			      struct net_device_stats *stats,
 			      iobuff_t *rx_buff, __u8 byte);
-static void state_link_escape(struct net_device *dev, 
-			      struct net_device_stats *stats, 
+static void state_link_escape(struct net_device *dev,
+			      struct net_device_stats *stats,
 			      iobuff_t *rx_buff, __u8 byte);
-static void state_inside_frame(struct net_device *dev, 
-			       struct net_device_stats *stats, 
+static void state_inside_frame(struct net_device *dev,
+			       struct net_device_stats *stats,
 			       iobuff_t *rx_buff, __u8 byte);
 
-static void (*state[])(struct net_device *dev, struct net_device_stats *stats, 
-		       iobuff_t *rx_buff, __u8 byte) = 
-{ 
+static void (*state[])(struct net_device *dev, struct net_device_stats *stats,
+		       iobuff_t *rx_buff, __u8 byte) =
+{
 	state_outside_frame,
 	state_begin_frame,
 	state_link_escape,
@@ -64,14 +64,14 @@ static void (*state[])(struct net_device *dev, struct net_device_stats *stats,
 /*
  * Function async_wrap (skb, *tx_buff, buffsize)
  *
- *    Makes a new buffer with wrapping and stuffing, should check that 
+ *    Makes a new buffer with wrapping and stuffing, should check that
  *    we don't get tx buffer overflow.
  */
 int async_wrap_skb(struct sk_buff *skb, __u8 *tx_buff, int buffsize)
 {
 	struct irda_skb_cb *cb = (struct irda_skb_cb *) skb->cb;
 	int xbofs;
- 	int i;
+	int i;
 	int n;
 	union {
 		__u16 value;
@@ -86,11 +86,11 @@ int async_wrap_skb(struct sk_buff *skb, __u8 *tx_buff, int buffsize)
 	 *  Send  XBOF's for required min. turn time and for the negotiated
 	 *  additional XBOFS
 	 */
-	
+
 	if (cb->magic != LAP_MAGIC) {
-		/* 
+		/*
 		 * This will happen for all frames sent from user-space.
-		 * Nothing to worry about, but we set the default number of 
+		 * Nothing to worry about, but we set the default number of
 		 * BOF's
 		 */
 		IRDA_DEBUG(1, __FUNCTION__ "(), wrong magic in skb!\n");
@@ -116,7 +116,7 @@ int async_wrap_skb(struct sk_buff *skb, __u8 *tx_buff, int buffsize)
 	for (i=0; i < skb->len; i++) {
 		/*
 		 *  Check for the possibility of tx buffer overflow. We use
-		 *  bufsize-5 since the maximum number of bytes that can be 
+		 *  bufsize-5 since the maximum number of bytes that can be
 		 *  transmitted after this point is 5.
 		 */
 		ASSERT(n < (buffsize-5), return n;);
@@ -124,7 +124,7 @@ int async_wrap_skb(struct sk_buff *skb, __u8 *tx_buff, int buffsize)
 		n += stuff_byte(skb->data[i], tx_buff+n);
 		fcs.value = irda_fcs(fcs.value, skb->data[i]);
 	}
-	
+
 	/* Insert CRC in little endian format (LSB first) */
 	fcs.value = ~fcs.value;
 #ifdef __LITTLE_ENDIAN
@@ -144,9 +144,9 @@ int async_wrap_skb(struct sk_buff *skb, __u8 *tx_buff, int buffsize)
  *
  *    Byte stuff one single byte and put the result in buffer pointed to by
  *    buf. The buffer must at all times be able to have two bytes inserted.
- * 
+ *
  */
-static inline int stuff_byte(__u8 byte, __u8 *buf) 
+static inline int stuff_byte(__u8 byte, __u8 *buf)
 {
 	switch (byte) {
 	case BOF: /* FALLTHROUGH */
@@ -174,7 +174,7 @@ static inline int stuff_byte(__u8 byte, __u8 *buf)
 inline void async_bump(struct net_device *dev, struct net_device_stats *stats,
 		       __u8 *buf, int len)
 {
-       	struct sk_buff *skb;
+	struct sk_buff *skb;
 
 	skb = dev_alloc_skb(len+1);
 	if (!skb)  {
@@ -184,10 +184,10 @@ inline void async_bump(struct net_device *dev, struct net_device_stats *stats,
 
 	/* Align IP header to 20 bytes */
 	skb_reserve(skb, 1);
-	
+
         /* Copy data without CRC */
-	memcpy(skb_put(skb, len-2), buf, len-2); 
-	
+	memcpy(skb_put(skb, len-2), buf, len-2);
+
 	/* Feed it to IrLAP layer */
 	skb->dev = dev;
 	skb->mac.raw  = skb->data;
@@ -196,7 +196,7 @@ inline void async_bump(struct net_device *dev, struct net_device_stats *stats,
 	netif_rx(skb);
 
 	stats->rx_packets++;
-	stats->rx_bytes += len;	
+	stats->rx_bytes += len;
 }
 
 /*
@@ -205,21 +205,21 @@ inline void async_bump(struct net_device *dev, struct net_device_stats *stats,
  *    Parse and de-stuff frame received from the IrDA-port
  *
  */
-inline void async_unwrap_char(struct net_device *dev, 
-			      struct net_device_stats *stats, 
+inline void async_unwrap_char(struct net_device *dev,
+			      struct net_device_stats *stats,
 			      iobuff_t *rx_buff, __u8 byte)
 {
 	(*state[rx_buff->state])(dev, stats, rx_buff, byte);
 }
-	 
+
 /*
  * Function state_outside_frame (dev, rx_buff, byte)
  *
  *    Not receiving any frame (or just bogus data)
  *
  */
-static void state_outside_frame(struct net_device *dev, 
-				struct net_device_stats *stats, 
+static void state_outside_frame(struct net_device *dev,
+				struct net_device_stats *stats,
 				iobuff_t *rx_buff, __u8 byte)
 {
 	switch (byte) {
@@ -245,8 +245,8 @@ static void state_outside_frame(struct net_device *dev,
  *    Begin of frame detected
  *
  */
-static void state_begin_frame(struct net_device *dev, 
-			      struct net_device_stats *stats, 
+static void state_begin_frame(struct net_device *dev,
+			      struct net_device_stats *stats,
 			      iobuff_t *rx_buff, __u8 byte)
 {
 	/* Time to initialize receive buffer */
@@ -283,27 +283,27 @@ static void state_begin_frame(struct net_device *dev,
  *    Found link escape character
  *
  */
-static void state_link_escape(struct net_device *dev, 
-			      struct net_device_stats *stats, 
+static void state_link_escape(struct net_device *dev,
+			      struct net_device_stats *stats,
 			      iobuff_t *rx_buff, __u8 byte)
 {
 	switch (byte) {
 	case BOF: /* New frame? */
-		IRDA_DEBUG(1, __FUNCTION__ 
+		IRDA_DEBUG(1, __FUNCTION__
 			   "(), Discarding incomplete frame\n");
 		rx_buff->state = BEGIN_FRAME;
 		irda_device_set_media_busy(dev, TRUE);
 		break;
 	case CE:
-		WARNING(__FUNCTION__ "(), state not defined\n");
+		WARNING("%s: state not defined\n", __FUNCTION__);
 		break;
 	case EOF: /* Abort frame */
 		rx_buff->state = OUTSIDE_FRAME;
 		break;
 	default:
-		/* 
-		 *  Stuffed char, complement bit 5 of byte 
-		 *  following CE, IrLAP p.114 
+		/*
+		 *  Stuffed char, complement bit 5 of byte
+		 *  following CE, IrLAP p.114
 		 */
 		byte ^= IRDA_TRANS;
 		if (rx_buff->len < rx_buff->truesize)  {
@@ -324,15 +324,15 @@ static void state_link_escape(struct net_device *dev,
  *    Handle bytes received within a frame
  *
  */
-static void state_inside_frame(struct net_device *dev, 
+static void state_inside_frame(struct net_device *dev,
 			       struct net_device_stats *stats,
 			       iobuff_t *rx_buff, __u8 byte)
 {
-	int ret = 0; 
+	int ret = 0;
 
 	switch (byte) {
 	case BOF: /* New frame? */
-		IRDA_DEBUG(1, __FUNCTION__ 
+		IRDA_DEBUG(1, __FUNCTION__
 			   "(), Discarding incomplete frame\n");
 		rx_buff->state = BEGIN_FRAME;
 		irda_device_set_media_busy(dev, TRUE);
@@ -343,7 +343,7 @@ static void state_inside_frame(struct net_device *dev,
 	case EOF: /* End of frame */
 		rx_buff->state = OUTSIDE_FRAME;
 		rx_buff->in_frame = FALSE;
-		
+
 		/* Test FCS and signal success if the frame is good */
 		if (rx_buff->fcs == GOOD_FCS) {
 			/* Deliver frame */
@@ -352,24 +352,22 @@ static void state_inside_frame(struct net_device *dev,
 			break;
 		} else {
 			/* Wrong CRC, discard frame!  */
-			irda_device_set_media_busy(dev, TRUE); 
+			irda_device_set_media_busy(dev, TRUE);
 
 			IRDA_DEBUG(1, __FUNCTION__ "(), crc error\n");
 			stats->rx_errors++;
 			stats->rx_crc_errors++;
-		}			
+		}
 		break;
 	default: /* Must be the next byte of the frame */
 		if (rx_buff->len < rx_buff->truesize)  {
 			rx_buff->data[rx_buff->len++] = byte;
 			rx_buff->fcs = irda_fcs(rx_buff->fcs, byte);
 		} else {
-			IRDA_DEBUG(1, __FUNCTION__ 
+			IRDA_DEBUG(1, __FUNCTION__
 			      "(), Rx buffer overflow, aborting\n");
 			rx_buff->state = OUTSIDE_FRAME;
 		}
 		break;
 	}
 }
-
-