1 files changed, 187 insertions, 187 deletions

diff --git a/drivers/isdn/i4l/isdn_bsdcomp.c b/drivers/isdn/i4l/isdn_bsdcomp.c
index aa0b6a6f5ef4..7f3c54d40474 100644
--- a/drivers/isdn/i4l/isdn_bsdcomp.c
+++ b/drivers/isdn/i4l/isdn_bsdcomp.c
@@ -7,7 +7,7 @@
  */
 
 /*
- * Update: The Berkeley copyright was changed, and the change 
+ * Update: The Berkeley copyright was changed, and the change
  * is retroactive to all "true" BSD software (ie everything
  * from UCB as opposed to other peoples code that just carried
  * the same license). The new copyright doesn't clash with the
@@ -121,7 +121,7 @@ struct bsd_db {
         unsigned char  maxbits;         /* maximum bits/code */
         unsigned char  debug;           /* non-zero if debug desired */
         unsigned char  unit;            /* ppp unit number */
-        u16 seqno;                      /* sequence # of next packet */
+        u16 seqno;                      /* sequence # of next packet */
         unsigned int   mru;             /* size of receive (decompress) bufr */
         unsigned int   maxmaxcode;      /* largest valid code */
         unsigned int   max_ent;         /* largest code in use */
@@ -157,16 +157,16 @@ struct bsd_db {
 #define MAXCODE(b)      ((1 << (b)) - 1)
 #define BADCODEM1       MAXCODE(MAX_BSD_BITS)
 
-#define BSD_HASH(prefix,suffix,hshift) ((((unsigned long)(suffix))<<(hshift)) \
-                                         ^ (unsigned long)(prefix))
-#define BSD_KEY(prefix,suffix)          ((((unsigned long)(suffix)) << 16) \
+#define BSD_HASH(prefix, suffix, hshift) ((((unsigned long)(suffix)) << (hshift)) \
+                                          ^ (unsigned long)(prefix))
+#define BSD_KEY(prefix, suffix)         ((((unsigned long)(suffix)) << 16) \
                                          + (unsigned long)(prefix))
 
 #define CHECK_GAP       10000           /* Ratio check interval */
 
 #define RATIO_SCALE_LOG 8
-#define RATIO_SCALE     (1<<RATIO_SCALE_LOG)
-#define RATIO_MAX       (0x7fffffff>>RATIO_SCALE_LOG)
+#define RATIO_SCALE     (1 << RATIO_SCALE_LOG)
+#define RATIO_MAX       (0x7fffffff >> RATIO_SCALE_LOG)
 
 /*
  * clear the dictionary
@@ -175,7 +175,7 @@ struct bsd_db {
 static void bsd_clear(struct bsd_db *db)
 {
         db->clear_count++;
-        db->max_ent      = FIRST-1;
+        db->max_ent      = FIRST - 1;
         db->n_bits       = BSD_INIT_BITS;
         db->bytes_out    = 0;
         db->in_count     = 0;
@@ -197,56 +197,56 @@ static void bsd_clear(struct bsd_db *db)
  * the absence of CLEAR codes (while packets are incompressible), they
  * must compute the same ratio.
  */
-static int bsd_check (struct bsd_db *db)        /* 1=output CLEAR */
+static int bsd_check(struct bsd_db *db) /* 1=output CLEAR */
 {
-    unsigned int new_ratio;
-
-    if (db->in_count >= db->checkpoint)
-      {
-        /* age the ratio by limiting the size of the counts */
-        if (db->in_count >= RATIO_MAX || db->bytes_out >= RATIO_MAX)
-          {
-            db->in_count  -= (db->in_count  >> 2);
-            db->bytes_out -= (db->bytes_out >> 2);
-          }
-        
-        db->checkpoint = db->in_count + CHECK_GAP;
-        
-        if (db->max_ent >= db->maxmaxcode)
-          {
-            /* Reset the dictionary only if the ratio is worse,
-             * or if it looks as if it has been poisoned
-             * by incompressible data.
-             *
-             * This does not overflow, because
-             *  db->in_count <= RATIO_MAX.
-             */
-
-            new_ratio = db->in_count << RATIO_SCALE_LOG;
-            if (db->bytes_out != 0)
-              {
-                new_ratio /= db->bytes_out;
-              }
-            
-            if (new_ratio < db->ratio || new_ratio < 1 * RATIO_SCALE)
-              {
-                bsd_clear (db);
-                return 1;
-              }
-            db->ratio = new_ratio;
-          }
-      }
-    return 0;
+        unsigned int new_ratio;
+
+        if (db->in_count >= db->checkpoint)
+        {
+                /* age the ratio by limiting the size of the counts */
+                if (db->in_count >= RATIO_MAX || db->bytes_out >= RATIO_MAX)
+                {
+                        db->in_count  -= (db->in_count  >> 2);
+                        db->bytes_out -= (db->bytes_out >> 2);
+                }
+
+                db->checkpoint = db->in_count + CHECK_GAP;
+
+                if (db->max_ent >= db->maxmaxcode)
+                {
+                        /* Reset the dictionary only if the ratio is worse,
+                         * or if it looks as if it has been poisoned
+                         * by incompressible data.
+                         *
+                         * This does not overflow, because
+                         *      db->in_count <= RATIO_MAX.
+                         */
+
+                        new_ratio = db->in_count << RATIO_SCALE_LOG;
+                        if (db->bytes_out != 0)
+                        {
+                                new_ratio /= db->bytes_out;
+                        }
+
+                        if (new_ratio < db->ratio || new_ratio < 1 * RATIO_SCALE)
+                        {
+                                bsd_clear(db);
+                                return 1;
+                        }
+                        db->ratio = new_ratio;
+                }
+        }
+        return 0;
 }
 
 /*
  * Return statistics.
  */
 
-static void bsd_stats (void *state, struct compstat *stats)
+static void bsd_stats(void *state, struct compstat *stats)
 {
         struct bsd_db *db = (struct bsd_db *) state;
-    
+
         stats->unc_bytes    = db->uncomp_bytes;
         stats->unc_packets  = db->uncomp_count;
         stats->comp_bytes   = db->comp_bytes;
@@ -260,9 +260,9 @@ static void bsd_stats (void *state, struct compstat *stats)
 /*
  * Reset state, as on a CCP ResetReq.
  */
-static void bsd_reset (void *state,unsigned char code, unsigned char id,
-                        unsigned char *data, unsigned len,
-                        struct isdn_ppp_resetparams *rsparm)
+static void bsd_reset(void *state, unsigned char code, unsigned char id,
+                      unsigned char *data, unsigned len,
+                      struct isdn_ppp_resetparams *rsparm)
 {
         struct bsd_db *db = (struct bsd_db *) state;
 
@@ -274,7 +274,7 @@ static void bsd_reset (void *state,unsigned char code, unsigned char id,
 /*
  * Release the compression structure
  */
-static void bsd_free (void *state)
+static void bsd_free(void *state)
 {
         struct bsd_db *db = (struct bsd_db *) state;
 
@@ -302,7 +302,7 @@ static void bsd_free (void *state)
 /*
  * Allocate space for a (de) compressor.
  */
-static void *bsd_alloc (struct isdn_ppp_comp_data *data)
+static void *bsd_alloc(struct isdn_ppp_comp_data *data)
 {
         int bits;
         unsigned int hsize, hshift, maxmaxcode;
@@ -310,27 +310,27 @@ static void *bsd_alloc (struct isdn_ppp_comp_data *data)
         int decomp;
 
         static unsigned int htab[][2] = {
-                { 5003 , 4 } , { 5003 , 4 } , { 5003 , 4 } , { 5003 , 4 } , 
-                { 9001 , 5 } , { 18013 , 6 } , { 35023 , 7 } , { 69001 , 8 } 
+                { 5003 , 4 } , { 5003 , 4 } , { 5003 , 4 } , { 5003 , 4 } ,
+                { 9001 , 5 } , { 18013 , 6 } , { 35023 , 7 } , { 69001 , 8 }
         };
-                
+
         if (data->optlen != 1 || data->num != CI_BSD_COMPRESS
-                || BSD_VERSION(data->options[0]) != BSD_CURRENT_VERSION)
+            || BSD_VERSION(data->options[0]) != BSD_CURRENT_VERSION)
                 return NULL;
 
         bits = BSD_NBITS(data->options[0]);
 
-        if(bits < 9 || bits > 15)
+        if (bits < 9 || bits > 15)
                 return NULL;
 
-        hsize = htab[bits-9][0];
-        hshift = htab[bits-9][1];
-        
+        hsize = htab[bits - 9][0];
+        hshift = htab[bits - 9][1];
+
         /*
          * Allocate the main control structure for this instance.
          */
         maxmaxcode = MAXCODE(bits);
-        db = kzalloc (sizeof (struct bsd_db),GFP_KERNEL);
+        db = kzalloc(sizeof(struct bsd_db), GFP_KERNEL);
         if (!db)
                 return NULL;
 
@@ -343,7 +343,7 @@ static void *bsd_alloc (struct isdn_ppp_comp_data *data)
          */
         db->dict = vmalloc(hsize * sizeof(struct bsd_dict));
         if (!db->dict) {
-                bsd_free (db);
+                bsd_free(db);
                 return NULL;
         }
 
@@ -356,7 +356,7 @@ static void *bsd_alloc (struct isdn_ppp_comp_data *data)
         else {
                 db->lens = vmalloc((maxmaxcode + 1) * sizeof(db->lens[0]));
                 if (!db->lens) {
-                        bsd_free (db);
+                        bsd_free(db);
                         return (NULL);
                 }
         }
@@ -364,41 +364,41 @@ static void *bsd_alloc (struct isdn_ppp_comp_data *data)
         /*
          * Initialize the data information for the compression code
          */
-        db->totlen     = sizeof (struct bsd_db) + (sizeof (struct bsd_dict) * hsize);
-        db->hsize      = hsize;
-        db->hshift     = hshift;
+        db->totlen = sizeof(struct bsd_db) + (sizeof(struct bsd_dict) * hsize);
+        db->hsize = hsize;
+        db->hshift = hshift;
         db->maxmaxcode = maxmaxcode;
-        db->maxbits    = bits;
+        db->maxbits = bits;
 
-        return (void *) db;
+        return (void *)db;
 }
 
 /*
  * Initialize the database.
  */
-static int bsd_init (void *state, struct isdn_ppp_comp_data *data, int unit, int debug)
+static int bsd_init(void *state, struct isdn_ppp_comp_data *data, int unit, int debug)
 {
         struct bsd_db *db = state;
         int indx;
         int decomp;
 
-        if(!state || !data) {
-                printk(KERN_ERR "isdn_bsd_init: [%d] ERR, state %lx data %lx\n",unit,(long)state,(long)data);
+        if (!state || !data) {
+                printk(KERN_ERR "isdn_bsd_init: [%d] ERR, state %lx data %lx\n", unit, (long)state, (long)data);
                 return 0;
         }
 
         decomp = db->xmit ? 0 : 1;
-    
+
         if (data->optlen != 1 || data->num != CI_BSD_COMPRESS
-                || (BSD_VERSION(data->options[0]) != BSD_CURRENT_VERSION)
-                || (BSD_NBITS(data->options[0]) != db->maxbits)
-                || (decomp && db->lens == NULL)) {
-                printk(KERN_ERR "isdn_bsd: %d %d %d %d %lx\n",data->optlen,data->num,data->options[0],decomp,(unsigned long)db->lens);
+            || (BSD_VERSION(data->options[0]) != BSD_CURRENT_VERSION)
+            || (BSD_NBITS(data->options[0]) != db->maxbits)
+            || (decomp && db->lens == NULL)) {
+                printk(KERN_ERR "isdn_bsd: %d %d %d %d %lx\n", data->optlen, data->num, data->options[0], decomp, (unsigned long)db->lens);
                 return 0;
         }
 
         if (decomp)
-                for(indx=LAST;indx>=0;indx--)
+                for (indx = LAST; indx >= 0; indx--)
                         db->lens[indx] = 1;
 
         indx = db->hsize;
@@ -411,9 +411,9 @@ static int bsd_init (void *state, struct isdn_ppp_comp_data *data, int unit, int
         db->mru  = 0;
 
         db->debug = 1;
-    
-        bsd_reset(db,0,0,NULL,0,NULL);
-    
+
+        bsd_reset(db, 0, 0, NULL, 0, NULL);
+
         return 1;
 }
 
@@ -421,37 +421,37 @@ static int bsd_init (void *state, struct isdn_ppp_comp_data *data, int unit, int
  * Obtain pointers to the various structures in the compression tables
  */
 
-#define dict_ptrx(p,idx) &(p->dict[idx])
-#define lens_ptrx(p,idx) &(p->lens[idx])
+#define dict_ptrx(p, idx) &(p->dict[idx])
+#define lens_ptrx(p, idx) &(p->lens[idx])
 
 #ifdef DEBUG
 static unsigned short *lens_ptr(struct bsd_db *db, int idx)
 {
         if ((unsigned int) idx > (unsigned int) db->maxmaxcode) {
-                printk (KERN_DEBUG "<9>ppp: lens_ptr(%d) > max\n", idx);
+                printk(KERN_DEBUG "<9>ppp: lens_ptr(%d) > max\n", idx);
                 idx = 0;
         }
-        return lens_ptrx (db, idx);
+        return lens_ptrx(db, idx);
 }
 
 static struct bsd_dict *dict_ptr(struct bsd_db *db, int idx)
 {
         if ((unsigned int) idx >= (unsigned int) db->hsize) {
-                printk (KERN_DEBUG "<9>ppp: dict_ptr(%d) > max\n", idx);
+                printk(KERN_DEBUG "<9>ppp: dict_ptr(%d) > max\n", idx);
                 idx = 0;
         }
-        return dict_ptrx (db, idx);
+        return dict_ptrx(db, idx);
 }
 
 #else
-#define lens_ptr(db,idx) lens_ptrx(db,idx)
-#define dict_ptr(db,idx) dict_ptrx(db,idx)
+#define lens_ptr(db, idx) lens_ptrx(db, idx)
+#define dict_ptr(db, idx) dict_ptrx(db, idx)
 #endif
 
 /*
  * compress a packet
  */
-static int bsd_compress (void *state, struct sk_buff *skb_in, struct sk_buff *skb_out,int proto)
+static int bsd_compress(void *state, struct sk_buff *skb_in, struct sk_buff *skb_out, int proto)
 {
         struct bsd_db *db;
         int hshift;
@@ -463,31 +463,31 @@ static int bsd_compress (void *state, struct sk_buff *skb_in, struct sk_buff *sk
         unsigned long fcode;
         struct bsd_dict *dictp;
         unsigned char c;
-        int hval,disp,ilen,mxcode;
+        int hval, disp, ilen, mxcode;
         unsigned char *rptr = skb_in->data;
         int isize = skb_in->len;
 
-#define OUTPUT(ent)                     \
-  {                                     \
-    bitno -= n_bits;                    \
-    accm |= ((ent) << bitno);           \
-    do  {                               \
-        if(skb_out && skb_tailroom(skb_out) > 0)        \
-                *(skb_put(skb_out,1)) = (unsigned char) (accm>>24); \
-        accm <<= 8;                     \
-        bitno += 8;                     \
-    } while (bitno <= 24);              \
-  }
+#define OUTPUT(ent)                                                     \
+        {                                                               \
+                bitno -= n_bits;                                        \
+                accm |= ((ent) << bitno);                               \
+                do      {                                               \
+                        if (skb_out && skb_tailroom(skb_out) > 0)       \
+                                *(skb_put(skb_out, 1)) = (unsigned char)(accm >> 24); \
+                        accm <<= 8;                                     \
+                        bitno += 8;                                     \
+                } while (bitno <= 24);                                  \
+        }
 
         /*
          * If the protocol is not in the range we're interested in,
          * just return without compressing the packet.  If it is,
          * the protocol becomes the first byte to compress.
          */
-        printk(KERN_DEBUG "bsd_compress called with %x\n",proto);
-        
+        printk(KERN_DEBUG "bsd_compress called with %x\n", proto);
+
         ent = proto;
-        if (proto < 0x21 || proto > 0xf9 || !(proto & 0x1) )
+        if (proto < 0x21 || proto > 0xf9 || !(proto & 0x1))
                 return 0;
 
         db      = (struct bsd_db *) state;
@@ -496,25 +496,25 @@ static int bsd_compress (void *state, struct sk_buff *skb_in, struct sk_buff *sk
         n_bits  = db->n_bits;
         bitno   = 32;
         accm    = 0;
-        mxcode  = MAXCODE (n_bits);
-        
+        mxcode  = MAXCODE(n_bits);
+
         /* This is the PPP header information */
-        if(skb_out && skb_tailroom(skb_out) >= 2) {
-                char *v = skb_put(skb_out,2);
+        if (skb_out && skb_tailroom(skb_out) >= 2) {
+                char *v = skb_put(skb_out, 2);
                 /* we only push our own data on the header,
-                  AC,PC and protos is pushed by caller  */
+                   AC,PC and protos is pushed by caller  */
                 v[0] = db->seqno >> 8;
                 v[1] = db->seqno;
         }
 
-        ilen   = ++isize; /* This is off by one, but that is what is in draft! */
+        ilen = ++isize; /* This is off by one, but that is what is in draft! */
 
         while (--ilen > 0) {
-                c     = *rptr++;
-                fcode = BSD_KEY  (ent, c);
-                hval  = BSD_HASH (ent, c, hshift);
-                dictp = dict_ptr (db, hval);
-        
+                c = *rptr++;
+                fcode = BSD_KEY(ent, c);
+                hval = BSD_HASH(ent, c, hshift);
+                dictp = dict_ptr(db, hval);
+
                 /* Validate and then check the entry. */
                 if (dictp->codem1 >= max_ent)
                         goto nomatch;
@@ -523,7 +523,7 @@ static int bsd_compress (void *state, struct sk_buff *skb_in, struct sk_buff *sk
                         ent = dictp->codem1 + 1;
                         continue;       /* found (prefix,suffix) */
                 }
-        
+
                 /* continue probing until a match or invalid entry */
                 disp = (hval == 0) ? 1 : hval;
 
@@ -531,17 +531,17 @@ static int bsd_compress (void *state, struct sk_buff *skb_in, struct sk_buff *sk
                         hval += disp;
                         if (hval >= db->hsize)
                                 hval -= db->hsize;
-                        dictp = dict_ptr (db, hval);
+                        dictp = dict_ptr(db, hval);
                         if (dictp->codem1 >= max_ent)
                                 goto nomatch;
                 } while (dictp->fcode != fcode);
 
                 ent = dictp->codem1 + 1;        /* finally found (prefix,suffix) */
                 continue;
-        
-nomatch:
+
+        nomatch:
                 OUTPUT(ent);            /* output the prefix */
-        
+
                 /* code -> hashtable */
                 if (max_ent < db->maxmaxcode) {
                         struct bsd_dict *dictp2;
@@ -551,16 +551,16 @@ nomatch:
                         /* expand code size if needed */
                         if (max_ent >= mxcode) {
                                 db->n_bits = ++n_bits;
-                                mxcode = MAXCODE (n_bits);
+                                mxcode = MAXCODE(n_bits);
                         }
-            
-                        /* 
+
+                        /*
                          * Invalidate old hash table entry using
                          * this code, and then take it over.
                          */
-                        dictp2 = dict_ptr (db, max_ent + 1);
+                        dictp2 = dict_ptr(db, max_ent + 1);
                         indx   = dictp2->cptr;
-                        dictp3 = dict_ptr (db, indx);
+                        dictp3 = dict_ptr(db, indx);
 
                         if (dictp3->codem1 == max_ent)
                                 dictp3->codem1 = BADCODEM1;
@@ -571,17 +571,17 @@ nomatch:
                         db->max_ent    = ++max_ent;
 
                         if (db->lens) {
-                                unsigned short *len1 = lens_ptr (db, max_ent);
-                                unsigned short *len2 = lens_ptr (db, ent);
+                                unsigned short *len1 = lens_ptr(db, max_ent);
+                                unsigned short *len2 = lens_ptr(db, ent);
                                 *len1 = *len2 + 1;
                         }
                 }
                 ent = c;
         }
-    
+
         OUTPUT(ent);            /* output the last code */
 
-        if(skb_out)
+        if (skb_out)
                 db->bytes_out    += skb_out->len; /* Do not count bytes from here */
         db->uncomp_bytes += isize;
         db->in_count     += isize;
@@ -596,15 +596,15 @@ nomatch:
          */
 
         if (bsd_check(db))
-                OUTPUT (CLEAR);
+                OUTPUT(CLEAR);
 
         /*
          * Pad dribble bits of last code with ones.
          * Do not emit a completely useless byte of ones.
          */
-        if (bitno < 32 && skb_out && skb_tailroom(skb_out) > 0) 
-                *(skb_put(skb_out,1)) = (unsigned char) ((accm | (0xff << (bitno-8))) >> 24);
-    
+        if (bitno < 32 && skb_out && skb_tailroom(skb_out) > 0)
+                *(skb_put(skb_out, 1)) = (unsigned char)((accm | (0xff << (bitno - 8))) >> 24);
+
         /*
          * Increase code size if we would have without the packet
          * boundary because the decompressor will do so.
@@ -613,7 +613,7 @@ nomatch:
                 db->n_bits++;
 
         /* If output length is too large then this is an incompressible frame. */
-        if (!skb_out || (skb_out && skb_out->len >= skb_in->len) ) {
+        if (!skb_out || (skb_out && skb_out->len >= skb_in->len)) {
                 ++db->incomp_count;
                 db->incomp_bytes += isize;
                 return 0;
@@ -631,16 +631,16 @@ nomatch:
  * Update the "BSD Compress" dictionary on the receiver for
  * incompressible data by pretending to compress the incoming data.
  */
-static void bsd_incomp (void *state, struct sk_buff *skb_in,int proto)
+static void bsd_incomp(void *state, struct sk_buff *skb_in, int proto)
 {
-        bsd_compress (state, skb_in, NULL, proto);
+        bsd_compress(state, skb_in, NULL, proto);
 }
 
 /*
  * Decompress "BSD Compress".
  */
-static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *skb_out,
-                           struct isdn_ppp_resetparams *rsparm)
+static int bsd_decompress(void *state, struct sk_buff *skb_in, struct sk_buff *skb_out,
+                          struct isdn_ppp_resetparams *rsparm)
 {
         struct bsd_db *db;
         unsigned int max_ent;
@@ -653,7 +653,7 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
         unsigned int incode;
         unsigned int oldcode;
         unsigned int finchar;
-        unsigned char *p,*ibuf;
+        unsigned char *p, *ibuf;
         int ilen;
         int codelen;
         int extra;
@@ -667,20 +667,20 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
 
         printk(KERN_DEBUG "bsd_decompress called\n");
 
-        if(!skb_in || !skb_out) {
+        if (!skb_in || !skb_out) {
                 printk(KERN_ERR "bsd_decompress called with NULL parameter\n");
                 return DECOMP_ERROR;
         }
-    
+
         /*
          * Get the sequence number.
          */
-        if( (p = skb_pull(skb_in,2)) == NULL) {
+        if ((p = skb_pull(skb_in, 2)) == NULL) {
                 return DECOMP_ERROR;
         }
-        p-=2;
-        seq   = (p[0] << 8) + p[1];
-        ilen  = skb_in->len;
+        p -= 2;
+        seq = (p[0] << 8) + p[1];
+        ilen = skb_in->len;
         ibuf = skb_in->data;
 
         /*
@@ -690,7 +690,7 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
         if (seq != db->seqno) {
                 if (db->debug) {
                         printk(KERN_DEBUG "bsd_decomp%d: bad sequence # %d, expected %d\n",
-                                db->unit, seq, db->seqno - 1);
+                               db->unit, seq, db->seqno - 1);
                 }
                 return DECOMP_ERROR;
         }
@@ -698,11 +698,11 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
         ++db->seqno;
         db->bytes_out += ilen;
 
-        if(skb_tailroom(skb_out) > 0)
-                *(skb_put(skb_out,1)) = 0;
+        if (skb_tailroom(skb_out) > 0)
+                *(skb_put(skb_out, 1)) = 0;
         else
                 return DECOMP_ERR_NOMEM;
-    
+
         oldcode = CLEAR;
 
         /*
@@ -734,7 +734,7 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
                 /*
                  * The dictionary must only be cleared at the end of a packet.
                  */
-        
+
                 if (incode == CLEAR) {
                         if (ilen > 0) {
                                 if (db->debug)
@@ -746,16 +746,16 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
                 }
 
                 if ((incode > max_ent + 2) || (incode > db->maxmaxcode)
-                        || (incode > max_ent && oldcode == CLEAR)) {
+                    || (incode > max_ent && oldcode == CLEAR)) {
                         if (db->debug) {
                                 printk(KERN_DEBUG "bsd_decomp%d: bad code 0x%x oldcode=0x%x ",
-                                        db->unit, incode, oldcode);
+                                       db->unit, incode, oldcode);
                                 printk(KERN_DEBUG "max_ent=0x%x skb->Len=%d seqno=%d\n",
-                                        max_ent, skb_out->len, db->seqno);
+                                       max_ent, skb_out->len, db->seqno);
                         }
                         return DECOMP_FATALERROR;       /* probably a bug */
                 }
-        
+
                 /* Special case for KwKwK string. */
                 if (incode > max_ent) {
                         finchar = oldcode;
@@ -765,13 +765,13 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
                         extra   = 0;
                 }
 
-                codelen = *(lens_ptr (db, finchar));
-                if( skb_tailroom(skb_out) < codelen + extra) {
+                codelen = *(lens_ptr(db, finchar));
+                if (skb_tailroom(skb_out) < codelen + extra) {
                         if (db->debug) {
                                 printk(KERN_DEBUG "bsd_decomp%d: ran out of mru\n", db->unit);
 #ifdef DEBUG
                                 printk(KERN_DEBUG "  len=%d, finchar=0x%x, codelen=%d,skblen=%d\n",
-                                        ilen, finchar, codelen, skb_out->len);
+                                       ilen, finchar, codelen, skb_out->len);
 #endif
                         }
                         return DECOMP_FATALERROR;
@@ -781,21 +781,21 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
                  * Decode this code and install it in the decompressed buffer.
                  */
 
-                p     = skb_put(skb_out,codelen);
+                p = skb_put(skb_out, codelen);
                 p += codelen;
                 while (finchar > LAST) {
-                        struct bsd_dict *dictp2 = dict_ptr (db, finchar);
-            
-                        dictp = dict_ptr (db, dictp2->cptr);
+                        struct bsd_dict *dictp2 = dict_ptr(db, finchar);
+
+                        dictp = dict_ptr(db, dictp2->cptr);
 
 #ifdef DEBUG
-                        if (--codelen <= 0 || dictp->codem1 != finchar-1) {
+                        if (--codelen <= 0 || dictp->codem1 != finchar - 1) {
                                 if (codelen <= 0) {
                                         printk(KERN_ERR "bsd_decomp%d: fell off end of chain ", db->unit);
                                         printk(KERN_ERR "0x%x at 0x%x by 0x%x, max_ent=0x%x\n", incode, finchar, dictp2->cptr, max_ent);
                                 } else {
-                                        if (dictp->codem1 != finchar-1) {
-                                                printk(KERN_ERR "bsd_decomp%d: bad code chain 0x%x finchar=0x%x ",db->unit, incode, finchar);
+                                        if (dictp->codem1 != finchar - 1) {
+                                                printk(KERN_ERR "bsd_decomp%d: bad code chain 0x%x finchar=0x%x ", db->unit, incode, finchar);
                                                 printk(KERN_ERR "oldcode=0x%x cptr=0x%x codem1=0x%x\n", oldcode, dictp2->cptr, dictp->codem1);
                                         }
                                 }
@@ -810,15 +810,15 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
                         }
                 }
                 *--p = finchar;
-        
+
 #ifdef DEBUG
                 if (--codelen != 0)
                         printk(KERN_ERR "bsd_decomp%d: short by %d after code 0x%x, max_ent=0x%x\n", db->unit, codelen, incode, max_ent);
 #endif
-        
+
                 if (extra)              /* the KwKwK case again */
-                        *(skb_put(skb_out,1)) = finchar;
-        
+                        *(skb_put(skb_out, 1)) = finchar;
+
                 /*
                  * If not first code in a packet, and
                  * if not out of code space, then allocate a new code.
@@ -828,14 +828,14 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
                  */
                 if (oldcode != CLEAR && max_ent < db->maxmaxcode) {
                         struct bsd_dict *dictp2, *dictp3;
-                        u16  *lens1,  *lens2;
+                        u16 *lens1, *lens2;
                         unsigned long fcode;
                         int hval, disp, indx;
-            
-                        fcode = BSD_KEY(oldcode,finchar);
-                        hval  = BSD_HASH(oldcode,finchar,db->hshift);
-                        dictp = dict_ptr (db, hval);
-            
+
+                        fcode = BSD_KEY(oldcode, finchar);
+                        hval  = BSD_HASH(oldcode, finchar, db->hshift);
+                        dictp = dict_ptr(db, hval);
+
                         /* look for a free hash table entry */
                         if (dictp->codem1 < max_ent) {
                                 disp = (hval == 0) ? 1 : hval;
@@ -843,18 +843,18 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
                                         hval += disp;
                                         if (hval >= db->hsize)
                                                 hval -= db->hsize;
-                                        dictp = dict_ptr (db, hval);
+                                        dictp = dict_ptr(db, hval);
                                 } while (dictp->codem1 < max_ent);
                         }
-            
+
                         /*
                          * Invalidate previous hash table entry
                          * assigned this code, and then take it over
                          */
 
-                        dictp2 = dict_ptr (db, max_ent + 1);
+                        dictp2 = dict_ptr(db, max_ent + 1);
                         indx   = dictp2->cptr;
-                        dictp3 = dict_ptr (db, indx);
+                        dictp3 = dict_ptr(db, indx);
 
                         if (dictp3->codem1 == max_ent)
                                 dictp3->codem1 = BADCODEM1;
@@ -865,10 +865,10 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
                         db->max_ent    = ++max_ent;
 
                         /* Update the length of this string. */
-                        lens1  = lens_ptr (db, max_ent);
-                        lens2  = lens_ptr (db, oldcode);
+                        lens1  = lens_ptr(db, max_ent);
+                        lens2  = lens_ptr(db, oldcode);
                         *lens1 = *lens2 + 1;
-            
+
                         /* Expand code size if needed. */
                         if (max_ent >= MAXCODE(n_bits) && max_ent < db->maxmaxcode) {
                                 db->n_bits = ++n_bits;
@@ -886,7 +886,7 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
         if (bsd_check(db)) {
                 if (db->debug)
                         printk(KERN_DEBUG "bsd_decomp%d: peer should have cleared dictionary on %d\n",
-                                db->unit, db->seqno - 1);
+                               db->unit, db->seqno - 1);
         }
         return skb_out->len;
 }
@@ -914,15 +914,15 @@ static struct isdn_ppp_compressor ippp_bsd_compress = {
 
 static int __init isdn_bsdcomp_init(void)
 {
-        int answer = isdn_ppp_register_compressor (&ippp_bsd_compress);
+        int answer = isdn_ppp_register_compressor(&ippp_bsd_compress);
         if (answer == 0)
-                printk (KERN_INFO "PPP BSD Compression module registered\n");
+                printk(KERN_INFO "PPP BSD Compression module registered\n");
         return answer;
 }
 
 static void __exit isdn_bsdcomp_exit(void)
 {
-        isdn_ppp_unregister_compressor (&ippp_bsd_compress);
+        isdn_ppp_unregister_compressor(&ippp_bsd_compress);
 }
 
 module_init(isdn_bsdcomp_init);