Staging: winbond: wb35reg.c Coding style fixes
authorLars Lindley <lindley@coyote.org>
Thu, 25 Mar 2010 13:44:53 +0000 (14:44 +0100)
committerGreg Kroah-Hartman <gregkh@suse.de>
Tue, 11 May 2010 18:35:49 +0000 (11:35 -0700)
I fixed the problems reported by checkpatch.pl excetp for
long lines, a couple of printks and some warnings about usb_free_urb(NULL).
I checked for regressions with Dan Carpenters strip_whitespace.pl
and diff and everything looks good.
Generated .o is identical to master.

This is a new patch against master where I fixed up a switch-statement
after comments from Pavel Machek.

Signed-off-by: Lars Lindley <lindley@coyote.org>
Acked-by: Pavel Machek <pavel@ucw.cz>
Acked-by: Dan Carpenter <error27@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
drivers/staging/winbond/wb35reg.c

index 1b93547..7707223 100644 (file)
@@ -6,60 +6,61 @@
 
 extern void phy_calibration_winbond(struct hw_data *phw_data, u32 frequency);
 
-// true  : read command process successfully
-// false : register not support
-// RegisterNo : start base
-// pRegisterData : data point
-// NumberOfData : number of register data
-// Flag : AUTO_INCREMENT - RegisterNo will auto increment 4
-//               NO_INCREMENT - Function will write data into the same register
-unsigned char
-Wb35Reg_BurstWrite(struct hw_data * pHwData, u16 RegisterNo, u32 * pRegisterData, u8 NumberOfData, u8 Flag)
+/*
+ * true  : read command process successfully
+ * false : register not support
+ * RegisterNo : start base
+ * pRegisterData : data point
+ * NumberOfData : number of register data
+ * Flag : AUTO_INCREMENT - RegisterNo will auto increment 4
+ *       NO_INCREMENT - Function will write data into the same register
+ */
+unsigned char Wb35Reg_BurstWrite(struct hw_data *pHwData, u16 RegisterNo, u32 *pRegisterData, u8 NumberOfData, u8 Flag)
 {
-       struct wb35_reg *reg = &pHwData->reg;
-       struct urb      *urb = NULL;
-       struct wb35_reg_queue *reg_queue = NULL;
-       u16             UrbSize;
-       struct      usb_ctrlrequest *dr;
-       u16             i, DataSize = NumberOfData*4;
-
-       // Module shutdown
+       struct wb35_reg         *reg = &pHwData->reg;
+       struct urb              *urb = NULL;
+       struct wb35_reg_queue   *reg_queue = NULL;
+       u16                     UrbSize;
+       struct usb_ctrlrequest  *dr;
+       u16                     i, DataSize = NumberOfData * 4;
+
+       /* Module shutdown */
        if (pHwData->SurpriseRemove)
                return false;
 
-       // Trying to use burst write function if use new hardware
+       /* Trying to use burst write function if use new hardware */
        UrbSize = sizeof(struct wb35_reg_queue) + DataSize + sizeof(struct usb_ctrlrequest);
        reg_queue = kzalloc(UrbSize, GFP_ATOMIC);
        urb = usb_alloc_urb(0, GFP_ATOMIC);
-       if( urb && reg_queue ) {
-               reg_queue->DIRECT = 2;// burst write register
+       if (urb && reg_queue) {
+               reg_queue->DIRECT = 2; /* burst write register */
                reg_queue->INDEX = RegisterNo;
                reg_queue->pBuffer = (u32 *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue));
-               memcpy( reg_queue->pBuffer, pRegisterData, DataSize );
-               //the function for reversing register data from little endian to big endian
-               for( i=0; i<NumberOfData ; i++ )
-                       reg_queue->pBuffer[i] = cpu_to_le32( reg_queue->pBuffer[i] );
+               memcpy(reg_queue->pBuffer, pRegisterData, DataSize);
+               /* the function for reversing register data from little endian to big endian */
+               for (i = 0; i < NumberOfData ; i++)
+                       reg_queue->pBuffer[i] = cpu_to_le32(reg_queue->pBuffer[i]);
 
                dr = (struct usb_ctrlrequest *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue) + DataSize);
                dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE;
-               dr->bRequest = 0x04; // USB or vendor-defined request code, burst mode
-               dr->wValue = cpu_to_le16( Flag ); // 0: Register number auto-increment, 1: No auto increment
-               dr->wIndex = cpu_to_le16( RegisterNo );
-               dr->wLength = cpu_to_le16( DataSize );
+               dr->bRequest = 0x04; /* USB or vendor-defined request code, burst mode */
+               dr->wValue = cpu_to_le16(Flag); /* 0: Register number auto-increment, 1: No auto increment */
+               dr->wIndex = cpu_to_le16(RegisterNo);
+               dr->wLength = cpu_to_le16(DataSize);
                reg_queue->Next = NULL;
                reg_queue->pUsbReq = dr;
                reg_queue->urb = urb;
 
-               spin_lock_irq( &reg->EP0VM_spin_lock );
+               spin_lock_irq(&reg->EP0VM_spin_lock);
                if (reg->reg_first == NULL)
                        reg->reg_first = reg_queue;
                else
                        reg->reg_last->Next = reg_queue;
                reg->reg_last = reg_queue;
 
-               spin_unlock_irq( &reg->EP0VM_spin_lock );
+               spin_unlock_irq(&reg->EP0VM_spin_lock);
 
-               // Start EP0VM
+               /* Start EP0VM */
                Wb35Reg_EP0VM_start(pHwData);
 
                return true;
@@ -73,8 +74,7 @@ Wb35Reg_BurstWrite(struct hw_data * pHwData, u16 RegisterNo, u32 * pRegisterData
    return false;
 }
 
-void
-Wb35Reg_Update(struct hw_data * pHwData,  u16 RegisterNo,  u32 RegisterValue)
+void Wb35Reg_Update(struct hw_data *pHwData,  u16 RegisterNo,  u32 RegisterValue)
 {
        struct wb35_reg *reg = &pHwData->reg;
        switch (RegisterNo) {
@@ -116,97 +116,96 @@ Wb35Reg_Update(struct hw_data * pHwData,  u16 RegisterNo,  u32 RegisterValue)
        }
 }
 
-// true  : read command process successfully
-// false : register not support
-unsigned char
-Wb35Reg_WriteSync(  struct hw_data * pHwData,  u16 RegisterNo,  u32 RegisterValue )
+/*
+ * true  : read command process successfully
+ * false : register not support
+ */
+unsigned char Wb35Reg_WriteSync(struct hw_data *pHwData, u16 RegisterNo, u32 RegisterValue)
 {
        struct wb35_reg *reg = &pHwData->reg;
        int ret = -1;
 
-       // Module shutdown
+       /* Module shutdown */
        if (pHwData->SurpriseRemove)
                return false;
 
        RegisterValue = cpu_to_le32(RegisterValue);
 
-       // update the register by send usb message------------------------------------
+       /* update the register by send usb message */
        reg->SyncIoPause = 1;
 
-       // 20060717.5 Wait until EP0VM stop
+       /* Wait until EP0VM stop */
        while (reg->EP0vm_state != VM_STOP)
                msleep(10);
 
-       // Sync IoCallDriver
+       /* Sync IoCallDriver */
        reg->EP0vm_state = VM_RUNNING;
-       ret = usb_control_msg( pHwData->WbUsb.udev,
-                              usb_sndctrlpipe( pHwData->WbUsb.udev, 0 ),
+       ret = usb_control_msg(pHwData->WbUsb.udev,
+                              usb_sndctrlpipe(pHwData->WbUsb.udev, 0),
                               0x03, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
-                              0x0,RegisterNo, &RegisterValue, 4, HZ*100 );
+                              0x0, RegisterNo, &RegisterValue, 4, HZ * 100);
        reg->EP0vm_state = VM_STOP;
        reg->SyncIoPause = 0;
 
        Wb35Reg_EP0VM_start(pHwData);
 
        if (ret < 0) {
-               #ifdef _PE_REG_DUMP_
+#ifdef _PE_REG_DUMP_
                printk("EP0 Write register usb message sending error\n");
-               #endif
-
-               pHwData->SurpriseRemove = 1; // 20060704.2
+#endif
+               pHwData->SurpriseRemove = 1;
                return false;
        }
-
        return true;
 }
 
-// true  : read command process successfully
-// false : register not support
-unsigned char
-Wb35Reg_Write(  struct hw_data * pHwData,  u16 RegisterNo,  u32 RegisterValue )
+/*
+ * true  : read command process successfully
+ * false : register not support
+ */
+unsigned char Wb35Reg_Write(struct hw_data *pHwData, u16 RegisterNo, u32 RegisterValue)
 {
-       struct wb35_reg *reg = &pHwData->reg;
-       struct usb_ctrlrequest *dr;
-       struct urb      *urb = NULL;
-       struct wb35_reg_queue *reg_queue = NULL;
-       u16             UrbSize;
-
+       struct wb35_reg         *reg = &pHwData->reg;
+       struct usb_ctrlrequest  *dr;
+       struct urb              *urb = NULL;
+       struct wb35_reg_queue   *reg_queue = NULL;
+       u16                     UrbSize;
 
-       // Module shutdown
+       /* Module shutdown */
        if (pHwData->SurpriseRemove)
                return false;
 
-       // update the register by send urb request------------------------------------
+       /* update the register by send urb request */
        UrbSize = sizeof(struct wb35_reg_queue) + sizeof(struct usb_ctrlrequest);
        reg_queue = kzalloc(UrbSize, GFP_ATOMIC);
        urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (urb && reg_queue) {
-               reg_queue->DIRECT = 1;// burst write register
+               reg_queue->DIRECT = 1; /* burst write register */
                reg_queue->INDEX = RegisterNo;
                reg_queue->VALUE = cpu_to_le32(RegisterValue);
                reg_queue->RESERVED_VALID = false;
                dr = (struct usb_ctrlrequest *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue));
-               dr->bRequestType = USB_TYPE_VENDOR|USB_DIR_OUT |USB_RECIP_DEVICE;
-               dr->bRequest = 0x03; // USB or vendor-defined request code, burst mode
+               dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE;
+               dr->bRequest = 0x03; /* USB or vendor-defined request code, burst mode */
                dr->wValue = cpu_to_le16(0x0);
                dr->wIndex = cpu_to_le16(RegisterNo);
                dr->wLength = cpu_to_le16(4);
 
-               // Enter the sending queue
+               /* Enter the sending queue */
                reg_queue->Next = NULL;
                reg_queue->pUsbReq = dr;
                reg_queue->urb = urb;
 
-               spin_lock_irq(&reg->EP0VM_spin_lock );
+               spin_lock_irq(&reg->EP0VM_spin_lock);
                if (reg->reg_first == NULL)
                        reg->reg_first = reg_queue;
                else
                        reg->reg_last->Next = reg_queue;
                reg->reg_last = reg_queue;
 
-               spin_unlock_irq( &reg->EP0VM_spin_lock );
+               spin_unlock_irq(&reg->EP0VM_spin_lock);
 
-               // Start EP0VM
+               /* Start EP0VM */
                Wb35Reg_EP0VM_start(pHwData);
 
                return true;
@@ -218,56 +217,60 @@ Wb35Reg_Write(  struct hw_data * pHwData,  u16 RegisterNo,  u32 RegisterValue )
        }
 }
 
-//This command will be executed with a user defined value. When it completes,
-//this value is useful. For example, hal_set_current_channel will use it.
-// true  : read command process successfully
-// false : register not support
-unsigned char
-Wb35Reg_WriteWithCallbackValue( struct hw_data * pHwData, u16 RegisterNo, u32 RegisterValue,
-                               s8 *pValue, s8 Len)
+/*
+ * This command will be executed with a user defined value. When it completes,
+ * this value is useful. For example, hal_set_current_channel will use it.
+ * true  : read command process successfully
+ * false : register not support
+ */
+unsigned char Wb35Reg_WriteWithCallbackValue(struct hw_data *pHwData,
+                                               u16 RegisterNo,
+                                               u32 RegisterValue,
+                                               s8 *pValue,
+                                               s8 Len)
 {
-       struct wb35_reg *reg = &pHwData->reg;
-       struct usb_ctrlrequest *dr;
-       struct urb      *urb = NULL;
-       struct wb35_reg_queue *reg_queue = NULL;
-       u16             UrbSize;
+       struct wb35_reg         *reg = &pHwData->reg;
+       struct usb_ctrlrequest  *dr;
+       struct urb              *urb = NULL;
+       struct wb35_reg_queue   *reg_queue = NULL;
+       u16                     UrbSize;
 
-       // Module shutdown
+       /* Module shutdown */
        if (pHwData->SurpriseRemove)
                return false;
 
-       // update the register by send urb request------------------------------------
+       /* update the register by send urb request */
        UrbSize = sizeof(struct wb35_reg_queue) + sizeof(struct usb_ctrlrequest);
        reg_queue = kzalloc(UrbSize, GFP_ATOMIC);
        urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (urb && reg_queue) {
-               reg_queue->DIRECT = 1;// burst write register
+               reg_queue->DIRECT = 1; /* burst write register */
                reg_queue->INDEX = RegisterNo;
                reg_queue->VALUE = cpu_to_le32(RegisterValue);
-               //NOTE : Users must guarantee the size of value will not exceed the buffer size.
+               /* NOTE : Users must guarantee the size of value will not exceed the buffer size. */
                memcpy(reg_queue->RESERVED, pValue, Len);
                reg_queue->RESERVED_VALID = true;
                dr = (struct usb_ctrlrequest *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue));
-               dr->bRequestType = USB_TYPE_VENDOR|USB_DIR_OUT |USB_RECIP_DEVICE;
-               dr->bRequest = 0x03; // USB or vendor-defined request code, burst mode
+               dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE;
+               dr->bRequest = 0x03; /* USB or vendor-defined request code, burst mode */
                dr->wValue = cpu_to_le16(0x0);
                dr->wIndex = cpu_to_le16(RegisterNo);
                dr->wLength = cpu_to_le16(4);
 
-               // Enter the sending queue
+               /* Enter the sending queue */
                reg_queue->Next = NULL;
                reg_queue->pUsbReq = dr;
                reg_queue->urb = urb;
-               spin_lock_irq (&reg->EP0VM_spin_lock );
-               if( reg->reg_first == NULL )
+               spin_lock_irq(&reg->EP0VM_spin_lock);
+               if (reg->reg_first == NULL)
                        reg->reg_first = reg_queue;
                else
                        reg->reg_last->Next = reg_queue;
                reg->reg_last = reg_queue;
 
-               spin_unlock_irq ( &reg->EP0VM_spin_lock );
+               spin_unlock_irq(&reg->EP0VM_spin_lock);
 
-               // Start EP0VM
+               /* Start EP0VM */
                Wb35Reg_EP0VM_start(pHwData);
                return true;
        } else {
@@ -278,115 +281,114 @@ Wb35Reg_WriteWithCallbackValue( struct hw_data * pHwData, u16 RegisterNo, u32 Re
        }
 }
 
-// true  : read command process successfully
-// false : register not support
-// pRegisterValue : It must be a resident buffer due to asynchronous read register.
-unsigned char
-Wb35Reg_ReadSync(  struct hw_data * pHwData,  u16 RegisterNo,   u32 * pRegisterValue )
+/*
+ * true  : read command process successfully
+ * false : register not support
+ * pRegisterValue : It must be a resident buffer due to
+ *                 asynchronous read register.
+ */
+unsigned char Wb35Reg_ReadSync(struct hw_data *pHwData, u16 RegisterNo, u32 *pRegisterValue)
 {
        struct wb35_reg *reg = &pHwData->reg;
-       u32 *   pltmp = pRegisterValue;
-       int ret = -1;
+       u32             *pltmp = pRegisterValue;
+       int             ret = -1;
 
-       // Module shutdown
+       /* Module shutdown */
        if (pHwData->SurpriseRemove)
                return false;
 
-       // Read the register by send usb message------------------------------------
-
+       /* Read the register by send usb message */
        reg->SyncIoPause = 1;
 
-       // 20060717.5 Wait until EP0VM stop
+       /* Wait until EP0VM stop */
        while (reg->EP0vm_state != VM_STOP)
                msleep(10);
 
        reg->EP0vm_state = VM_RUNNING;
-       ret = usb_control_msg( pHwData->WbUsb.udev,
+       ret = usb_control_msg(pHwData->WbUsb.udev,
                               usb_rcvctrlpipe(pHwData->WbUsb.udev, 0),
-                              0x01, USB_TYPE_VENDOR|USB_RECIP_DEVICE|USB_DIR_IN,
-                              0x0, RegisterNo, pltmp, 4, HZ*100 );
+                              0x01, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
+                              0x0, RegisterNo, pltmp, 4, HZ * 100);
 
        *pRegisterValue = cpu_to_le32(*pltmp);
 
        reg->EP0vm_state = VM_STOP;
 
-       Wb35Reg_Update( pHwData, RegisterNo, *pRegisterValue );
+       Wb35Reg_Update(pHwData, RegisterNo, *pRegisterValue);
        reg->SyncIoPause = 0;
 
-       Wb35Reg_EP0VM_start( pHwData );
+       Wb35Reg_EP0VM_start(pHwData);
 
        if (ret < 0) {
-               #ifdef _PE_REG_DUMP_
+#ifdef _PE_REG_DUMP_
                printk("EP0 Read register usb message sending error\n");
-               #endif
-
-               pHwData->SurpriseRemove = 1; // 20060704.2
+#endif
+               pHwData->SurpriseRemove = 1;
                return false;
        }
-
        return true;
 }
 
-// true  : read command process successfully
-// false : register not support
-// pRegisterValue : It must be a resident buffer due to asynchronous read register.
-unsigned char
-Wb35Reg_Read(struct hw_data * pHwData, u16 RegisterNo,  u32 * pRegisterValue )
+/*
+ * true  : read command process successfully
+ * false : register not support
+ * pRegisterValue : It must be a resident buffer due to
+ *                 asynchronous read register.
+ */
+unsigned char Wb35Reg_Read(struct hw_data *pHwData, u16 RegisterNo, u32 *pRegisterValue)
 {
-       struct wb35_reg *reg = &pHwData->reg;
-       struct usb_ctrlrequest dr;
-       struct urb      *urb;
-       struct wb35_reg_queue *reg_queue;
-       u16             UrbSize;
+       struct wb35_reg         *reg = &pHwData->reg;
+       struct usb_ctrlrequest  *dr;
+       struct urb              *urb;
+       struct wb35_reg_queue   *reg_queue;
+       u16                     UrbSize;
 
-       // Module shutdown
+       /* Module shutdown */
        if (pHwData->SurpriseRemove)
                return false;
 
-       // update the variable by send Urb to read register ------------------------------------
+       /* update the variable by send Urb to read register */
        UrbSize = sizeof(struct wb35_reg_queue) + sizeof(struct usb_ctrlrequest);
        reg_queue = kzalloc(UrbSize, GFP_ATOMIC);
        urb = usb_alloc_urb(0, GFP_ATOMIC);
-       if( urb && reg_queue )
-       {
-               reg_queue->DIRECT = 0;// read register
+       if (urb && reg_queue) {
+               reg_queue->DIRECT = 0; /* read register */
                reg_queue->INDEX = RegisterNo;
                reg_queue->pBuffer = pRegisterValue;
                dr = (struct usb_ctrlrequest *)((u8 *)reg_queue + sizeof(struct wb35_reg_queue));
-               dr->bRequestType = USB_TYPE_VENDOR|USB_RECIP_DEVICE|USB_DIR_IN;
-               dr->bRequest = 0x01; // USB or vendor-defined request code, burst mode
+               dr->bRequestType = USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN;
+               dr->bRequest = 0x01; /* USB or vendor-defined request code, burst mode */
                dr->wValue = cpu_to_le16(0x0);
-               dr->wIndex = cpu_to_le16 (RegisterNo);
-               dr->wLength = cpu_to_le16 (4);
+               dr->wIndex = cpu_to_le16(RegisterNo);
+               dr->wLength = cpu_to_le16(4);
 
-               // Enter the sending queue
+               /* Enter the sending queue */
                reg_queue->Next = NULL;
                reg_queue->pUsbReq = dr;
                reg_queue->urb = urb;
-               spin_lock_irq ( &reg->EP0VM_spin_lock );
-               if( reg->reg_first == NULL )
+               spin_lock_irq(&reg->EP0VM_spin_lock);
+               if (reg->reg_first == NULL)
                        reg->reg_first = reg_queue;
                else
                        reg->reg_last->Next = reg_queue;
                reg->reg_last = reg_queue;
 
-               spin_unlock_irq( &reg->EP0VM_spin_lock );
+               spin_unlock_irq(&reg->EP0VM_spin_lock);
 
-               // Start EP0VM
-               Wb35Reg_EP0VM_start( pHwData );
+               /* Start EP0VM */
+               Wb35Reg_EP0VM_start(pHwData);
 
                return true;
        } else {
                if (urb)
-                       usb_free_urb( urb );
+                       usb_free_urb(urb);
                kfree(reg_queue);
                return false;
        }
 }
 
 
-void
-Wb35Reg_EP0VM_start(  struct hw_data * pHwData )
+void Wb35Reg_EP0VM_start(struct hw_data *pHwData)
 {
        struct wb35_reg *reg = &pHwData->reg;
 
@@ -397,15 +399,14 @@ Wb35Reg_EP0VM_start(  struct hw_data * pHwData )
                atomic_dec(&reg->RegFireCount);
 }
 
-void
-Wb35Reg_EP0VM(struct hw_data * pHwData )
+void Wb35Reg_EP0VM(struct hw_data *pHwData)
 {
-       struct wb35_reg *reg = &pHwData->reg;
-       struct urb      *urb;
-       struct usb_ctrlrequest *dr;
-       u32 *           pBuffer;
+       struct wb35_reg         *reg = &pHwData->reg;
+       struct urb              *urb;
+       struct usb_ctrlrequest  *dr;
+       u32                     *pBuffer;
        int                     ret = -1;
-       struct wb35_reg_queue *reg_queue;
+       struct wb35_reg_queue   *reg_queue;
 
 
        if (reg->SyncIoPause)
@@ -414,27 +415,27 @@ Wb35Reg_EP0VM(struct hw_data * pHwData )
        if (pHwData->SurpriseRemove)
                goto cleanup;
 
-       // Get the register data and send to USB through Irp
-       spin_lock_irq( &reg->EP0VM_spin_lock );
+       /* Get the register data and send to USB through Irp */
+       spin_lock_irq(&reg->EP0VM_spin_lock);
        reg_queue = reg->reg_first;
-       spin_unlock_irq( &reg->EP0VM_spin_lock );
+       spin_unlock_irq(&reg->EP0VM_spin_lock);
 
        if (!reg_queue)
                goto cleanup;
 
-       // Get an Urb, send it
+       /* Get an Urb, send it */
        urb = (struct urb *)reg_queue->urb;
 
        dr = reg_queue->pUsbReq;
        urb = reg_queue->urb;
        pBuffer = reg_queue->pBuffer;
-       if (reg_queue->DIRECT == 1) // output
+       if (reg_queue->DIRECT == 1) /* output */
                pBuffer = &reg_queue->VALUE;
 
-       usb_fill_control_urb( urb, pHwData->WbUsb.udev,
-                             REG_DIRECTION(pHwData->WbUsb.udev,reg_queue),
-                             (u8 *)dr,pBuffer,cpu_to_le16(dr->wLength),
-                             Wb35Reg_EP0VM_complete, (void*)pHwData);
+       usb_fill_control_urb(urb, pHwData->WbUsb.udev,
+                             REG_DIRECTION(pHwData->WbUsb.udev, reg_queue),
+                             (u8 *)dr, pBuffer, cpu_to_le16(dr->wLength),
+                             Wb35Reg_EP0VM_complete, (void *)pHwData);
 
        reg->EP0vm_state = VM_RUNNING;
 
@@ -446,7 +447,6 @@ Wb35Reg_EP0VM(struct hw_data * pHwData )
 #endif
                goto cleanup;
        }
-
        return;
 
  cleanup:
@@ -455,29 +455,28 @@ Wb35Reg_EP0VM(struct hw_data * pHwData )
 }
 
 
-void
-Wb35Reg_EP0VM_complete(struct urb *urb)
+void Wb35Reg_EP0VM_complete(struct urb *urb)
 {
-       struct hw_data *  pHwData = (struct hw_data *)urb->context;
-       struct wb35_reg *reg = &pHwData->reg;
-       struct wb35_reg_queue *reg_queue;
+       struct hw_data          *pHwData = (struct hw_data *)urb->context;
+       struct wb35_reg         *reg = &pHwData->reg;
+       struct wb35_reg_queue   *reg_queue;
 
 
-       // Variable setting
+       /* Variable setting */
        reg->EP0vm_state = VM_COMPLETED;
        reg->EP0VM_status = urb->status;
 
-       if (pHwData->SurpriseRemove) { // Let WbWlanHalt to handle surprise remove
+       if (pHwData->SurpriseRemove) { /* Let WbWlanHalt to handle surprise remove */
                reg->EP0vm_state = VM_STOP;
                atomic_dec(&reg->RegFireCount);
        } else {
-               // Complete to send, remove the URB from the first
-               spin_lock_irq( &reg->EP0VM_spin_lock );
+               /* Complete to send, remove the URB from the first */
+               spin_lock_irq(&reg->EP0VM_spin_lock);
                reg_queue = reg->reg_first;
                if (reg_queue == reg->reg_last)
                        reg->reg_last = NULL;
                reg->reg_first = reg->reg_first->Next;
-               spin_unlock_irq( &reg->EP0VM_spin_lock );
+               spin_unlock_irq(&reg->EP0VM_spin_lock);
 
                if (reg->EP0VM_status) {
 #ifdef _PE_REG_DUMP_
@@ -486,37 +485,35 @@ Wb35Reg_EP0VM_complete(struct urb *urb)
                        reg->EP0vm_state = VM_STOP;
                        pHwData->SurpriseRemove = 1;
                } else {
-                       // Success. Update the result
+                       /* Success. Update the result */
 
-                       // Start the next send
+                       /* Start the next send */
                        Wb35Reg_EP0VM(pHwData);
                }
 
-               kfree(reg_queue);
+               kfree(reg_queue);
        }
 
        usb_free_urb(urb);
 }
 
 
-void
-Wb35Reg_destroy(struct hw_data * pHwData)
+void Wb35Reg_destroy(struct hw_data *pHwData)
 {
-       struct wb35_reg *reg = &pHwData->reg;
-       struct urb      *urb;
-       struct wb35_reg_queue *reg_queue;
-
+       struct wb35_reg         *reg = &pHwData->reg;
+       struct urb              *urb;
+       struct wb35_reg_queue   *reg_queue;
 
        Uxx_power_off_procedure(pHwData);
 
-       // Wait for Reg operation completed
+       /* Wait for Reg operation completed */
        do {
-               msleep(10); // Delay for waiting function enter 940623.1.a
+               msleep(10); /* Delay for waiting function enter */
        } while (reg->EP0vm_state != VM_STOP);
-       msleep(10);  // Delay for waiting function enter 940623.1.b
+       msleep(10);  /* Delay for waiting function enter */
 
-       // Release all the data in RegQueue
-       spin_lock_irq( &reg->EP0VM_spin_lock );
+       /* Release all the data in RegQueue */
+       spin_lock_irq(&reg->EP0VM_spin_lock);
        reg_queue = reg->reg_first;
        while (reg_queue) {
                if (reg_queue == reg->reg_last)
@@ -524,84 +521,88 @@ Wb35Reg_destroy(struct hw_data * pHwData)
                reg->reg_first = reg->reg_first->Next;
 
                urb = reg_queue->urb;
-               spin_unlock_irq( &reg->EP0VM_spin_lock );
+               spin_unlock_irq(&reg->EP0VM_spin_lock);
                if (urb) {
                        usb_free_urb(urb);
                        kfree(reg_queue);
                } else {
-                       #ifdef _PE_REG_DUMP_
+#ifdef _PE_REG_DUMP_
                        printk("EP0 queue release error\n");
-                       #endif
+#endif
                }
-               spin_lock_irq( &reg->EP0VM_spin_lock );
+               spin_lock_irq(&reg->EP0VM_spin_lock);
 
                reg_queue = reg->reg_first;
        }
-       spin_unlock_irq( &reg->EP0VM_spin_lock );
+       spin_unlock_irq(&reg->EP0VM_spin_lock);
 }
 
-//====================================================================================
-// The function can be run in passive-level only.
-//====================================================================================
-unsigned char Wb35Reg_initial(struct hw_data * pHwData)
+/*
+ * =======================================================================
+ * The function can be run in passive-level only.
+ * =========================================================================
+ */
+unsigned char Wb35Reg_initial(struct hw_data *pHwData)
 {
-       struct wb35_reg *reg=&pHwData->reg;
+       struct wb35_reg *reg = &pHwData->reg;
        u32 ltmp;
        u32 SoftwareSet, VCO_trim, TxVga, Region_ScanInterval;
 
-       // Spin lock is acquired for read and write IRP command
-       spin_lock_init( &reg->EP0VM_spin_lock );
-
-       // Getting RF module type from EEPROM ------------------------------------
-       Wb35Reg_WriteSync( pHwData, 0x03b4, 0x080d0000 ); // Start EEPROM access + Read + address(0x0d)
-       Wb35Reg_ReadSync( pHwData, 0x03b4, &ltmp );
-
-       //Update RF module type and determine the PHY type by inf or EEPROM
-       reg->EEPROMPhyType = (u8)( ltmp & 0xff );
-       // 0 V MAX2825, 1 V MAX2827, 2 V MAX2828, 3 V MAX2829
-       // 16V AL2230, 17 - AL7230, 18 - AL2230S
-       // 32 Reserved
-       // 33 - W89RF242(TxVGA 0~19), 34 - W89RF242(TxVGA 0~34)
+       /* Spin lock is acquired for read and write IRP command */
+       spin_lock_init(&reg->EP0VM_spin_lock);
+
+       /* Getting RF module type from EEPROM */
+       Wb35Reg_WriteSync(pHwData, 0x03b4, 0x080d0000); /* Start EEPROM access + Read + address(0x0d) */
+       Wb35Reg_ReadSync(pHwData, 0x03b4, &ltmp);
+
+       /* Update RF module type and determine the PHY type by inf or EEPROM */
+       reg->EEPROMPhyType = (u8)(ltmp & 0xff);
+       /*
+        * 0 V MAX2825, 1 V MAX2827, 2 V MAX2828, 3 V MAX2829
+        * 16V AL2230, 17 - AL7230, 18 - AL2230S
+        * 32 Reserved
+        * 33 - W89RF242(TxVGA 0~19), 34 - W89RF242(TxVGA 0~34)
+        */
        if (reg->EEPROMPhyType != RF_DECIDE_BY_INF) {
-               if(reg->EEPROMPhyType == RF_MAXIM_2825)       ||
+               if ((reg->EEPROMPhyType == RF_MAXIM_2825)       ||
                        (reg->EEPROMPhyType == RF_MAXIM_2827)   ||
                        (reg->EEPROMPhyType == RF_MAXIM_2828)   ||
                        (reg->EEPROMPhyType == RF_MAXIM_2829)   ||
                        (reg->EEPROMPhyType == RF_MAXIM_V1)     ||
                        (reg->EEPROMPhyType == RF_AIROHA_2230)  ||
-                       (reg->EEPROMPhyType == RF_AIROHA_2230S)    ||
+                       (reg->EEPROMPhyType == RF_AIROHA_2230S) ||
                        (reg->EEPROMPhyType == RF_AIROHA_7230)  ||
-                       (reg->EEPROMPhyType == RF_WB_242)               ||
+                       (reg->EEPROMPhyType == RF_WB_242)       ||
                        (reg->EEPROMPhyType == RF_WB_242_1))
                        pHwData->phy_type = reg->EEPROMPhyType;
        }
 
-       // Power On procedure running. The relative parameter will be set according to phy_type
-       Uxx_power_on_procedure( pHwData );
+       /* Power On procedure running. The relative parameter will be set according to phy_type */
+       Uxx_power_on_procedure(pHwData);
 
-       // Reading MAC address
-       Uxx_ReadEthernetAddress( pHwData );
+       /* Reading MAC address */
+       Uxx_ReadEthernetAddress(pHwData);
 
-       // Read VCO trim for RF parameter
-       Wb35Reg_WriteSync( pHwData, 0x03b4, 0x08200000 );
-       Wb35Reg_ReadSync( pHwData, 0x03b4, &VCO_trim );
+       /* Read VCO trim for RF parameter */
+       Wb35Reg_WriteSync(pHwData, 0x03b4, 0x08200000);
+       Wb35Reg_ReadSync(pHwData, 0x03b4, &VCO_trim);
 
-       // Read Antenna On/Off of software flag
-       Wb35Reg_WriteSync( pHwData, 0x03b4, 0x08210000 );
-       Wb35Reg_ReadSync( pHwData, 0x03b4, &SoftwareSet );
+       /* Read Antenna On/Off of software flag */
+       Wb35Reg_WriteSync(pHwData, 0x03b4, 0x08210000);
+       Wb35Reg_ReadSync(pHwData, 0x03b4, &SoftwareSet);
 
-       // Read TXVGA
-       Wb35Reg_WriteSync( pHwData, 0x03b4, 0x08100000 );
-       Wb35Reg_ReadSync( pHwData, 0x03b4, &TxVga );
+       /* Read TXVGA */
+       Wb35Reg_WriteSync(pHwData, 0x03b4, 0x08100000);
+       Wb35Reg_ReadSync(pHwData, 0x03b4, &TxVga);
 
-       // Get Scan interval setting from EEPROM offset 0x1c
-       Wb35Reg_WriteSync( pHwData, 0x03b4, 0x081d0000 );
-       Wb35Reg_ReadSync( pHwData, 0x03b4, &Region_ScanInterval );
+       /* Get Scan interval setting from EEPROM offset 0x1c */
+       Wb35Reg_WriteSync(pHwData, 0x03b4, 0x081d0000);
+       Wb35Reg_ReadSync(pHwData, 0x03b4, &Region_ScanInterval);
 
-       // Update Ethernet address
-       memcpy( pHwData->CurrentMacAddress, pHwData->PermanentMacAddress, ETH_ALEN );
+       /* Update Ethernet address */
+       memcpy(pHwData->CurrentMacAddress, pHwData->PermanentMacAddress, ETH_ALEN);
 
-       // Update software variable
+       /* Update software variable */
        pHwData->SoftwareSet = (u16)(SoftwareSet & 0xffff);
        TxVga &= 0x000000ff;
        pHwData->PowerIndexFromEEPROM = (u8)TxVga;
@@ -609,22 +610,22 @@ unsigned char Wb35Reg_initial(struct hw_data * pHwData)
        if (pHwData->VCO_trim == 0xff)
                pHwData->VCO_trim = 0x28;
 
-       reg->EEPROMRegion = (u8)(Region_ScanInterval>>8); // 20060720
-       if( reg->EEPROMRegion<1 || reg->EEPROMRegion>6 )
+       reg->EEPROMRegion = (u8)(Region_ScanInterval >> 8);
+       if (reg->EEPROMRegion < 1 || reg->EEPROMRegion > 6)
                reg->EEPROMRegion = REGION_AUTO;
 
-       //For Get Tx VGA from EEPROM 20060315.5 move here
-       GetTxVgaFromEEPROM( pHwData );
+       /* For Get Tx VGA from EEPROM */
+       GetTxVgaFromEEPROM(pHwData);
 
-       // Set Scan Interval
+       /* Set Scan Interval */
        pHwData->Scan_Interval = (u8)(Region_ScanInterval & 0xff) * 10;
-       if ((pHwData->Scan_Interval == 2550) || (pHwData->Scan_Interval < 10)) // Is default setting 0xff * 10
+       if ((pHwData->Scan_Interval == 2550) || (pHwData->Scan_Interval < 10)) /* Is default setting 0xff * 10 */
                pHwData->Scan_Interval = SCAN_MAX_CHNL_TIME;
 
-       // Initial register
+       /* Initial register */
        RFSynthesizer_initial(pHwData);
 
-       BBProcessor_initial(pHwData); // Async write, must wait until complete
+       BBProcessor_initial(pHwData); /* Async write, must wait until complete */
 
        Wb35Reg_phy_calibration(pHwData);
 
@@ -634,113 +635,104 @@ unsigned char Wb35Reg_initial(struct hw_data * pHwData)
        if (pHwData->SurpriseRemove)
                return false;
        else
-               return true; // Initial fail
+               return true; /* Initial fail */
 }
 
-//===================================================================================
-//  CardComputeCrc --
-//
-//  Description:
-//    Runs the AUTODIN II CRC algorithm on buffer Buffer of length, Length.
-//
-//  Arguments:
-//    Buffer - the input buffer
-//    Length - the length of Buffer
-//
-//  Return Value:
-//    The 32-bit CRC value.
-//
-//  Note:
-//    This is adapted from the comments in the assembly language
-//    version in _GENREQ.ASM of the DWB NE1000/2000 driver.
-//==================================================================================
-u32
-CardComputeCrc(u8 * Buffer, u32 Length)
+/*
+ * ================================================================
+ *  CardComputeCrc --
+ *
+ *  Description:
+ *    Runs the AUTODIN II CRC algorithm on buffer Buffer of length, Length.
+ *
+ *  Arguments:
+ *    Buffer - the input buffer
+ *    Length - the length of Buffer
+ *
+ *  Return Value:
+ *    The 32-bit CRC value.
+ * ===================================================================
+ */
+u32 CardComputeCrc(u8 *Buffer, u32 Length)
 {
-    u32 Crc, Carry;
-    u32  i, j;
-    u8 CurByte;
-
-    Crc = 0xffffffff;
-
-    for (i = 0; i < Length; i++) {
-
-        CurByte = Buffer[i];
-
-        for (j = 0; j < 8; j++) {
-
-            Carry     = ((Crc & 0x80000000) ? 1 : 0) ^ (CurByte & 0x01);
-            Crc     <<= 1;
-            CurByte >>= 1;
-
-            if (Carry) {
-                Crc =(Crc ^ 0x04c11db6) | Carry;
-            }
-        }
-    }
-
-    return Crc;
+       u32     Crc, Carry;
+       u32     i, j;
+       u8      CurByte;
+
+       Crc = 0xffffffff;
+
+       for (i = 0; i < Length; i++) {
+               CurByte = Buffer[i];
+               for (j = 0; j < 8; j++) {
+                       Carry = ((Crc & 0x80000000) ? 1 : 0) ^ (CurByte & 0x01);
+                       Crc <<= 1;
+                       CurByte >>= 1;
+                       if (Carry)
+                               Crc = (Crc ^ 0x04c11db6) | Carry;
+               }
+       }
+       return Crc;
 }
 
 
-//==================================================================
-// BitReverse --
-//   Reverse the bits in the input argument, dwData, which is
-//   regarded as a string of bits with the length, DataLength.
-//
-// Arguments:
-//   dwData     :
-//   DataLength :
-//
-// Return:
-//   The converted value.
-//==================================================================
-u32 BitReverse( u32 dwData, u32 DataLength)
+/*
+ * ==================================================================
+ * BitReverse --
+ *   Reverse the bits in the input argument, dwData, which is
+ *   regarded as a string of bits with the length, DataLength.
+ *
+ * Arguments:
+ *   dwData     :
+ *   DataLength :
+ *
+ * Return:
+ *   The converted value.
+ * ==================================================================
+ */
+u32 BitReverse(u32 dwData, u32 DataLength)
 {
-       u32   HalfLength, i, j;
-       u32   BitA, BitB;
+       u32     HalfLength, i, j;
+       u32     BitA, BitB;
 
-       if ( DataLength <= 0)       return 0;   // No conversion is done.
+       if (DataLength <= 0)
+               return 0;       /* No conversion is done. */
        dwData = dwData & (0xffffffff >> (32 - DataLength));
 
        HalfLength = DataLength / 2;
-       for ( i = 0, j = DataLength-1 ; i < HalfLength; i++, j--)
-       {
-               BitA = GetBit( dwData, i);
-               BitB = GetBit( dwData, j);
+       for (i = 0, j = DataLength - 1; i < HalfLength; i++, j--) {
+               BitA = GetBit(dwData, i);
+               BitB = GetBit(dwData, j);
                if (BitA && !BitB) {
-                       dwData = ClearBit( dwData, i);
-                       dwData = SetBit( dwData, j);
+                       dwData = ClearBit(dwData, i);
+                       dwData = SetBit(dwData, j);
                } else if (!BitA && BitB) {
-                       dwData = SetBit( dwData, i);
-                       dwData = ClearBit( dwData, j);
-               } else
-               {
-                       // Do nothing since these two bits are of the save values.
+                       dwData = SetBit(dwData, i);
+                       dwData = ClearBit(dwData, j);
+               } else {
+                       /* Do nothing since these two bits are of the save values. */
                }
        }
-
        return dwData;
 }
 
-void Wb35Reg_phy_calibration(  struct hw_data * pHwData )
+void Wb35Reg_phy_calibration(struct hw_data *pHwData)
 {
-       u32 BB3c, BB54;
+       u32     BB3c, BB54;
 
        if ((pHwData->phy_type == RF_WB_242) ||
                (pHwData->phy_type == RF_WB_242_1)) {
-               phy_calibration_winbond ( pHwData, 2412 ); // Sync operation
-               Wb35Reg_ReadSync( pHwData, 0x103c, &BB3c );
-               Wb35Reg_ReadSync( pHwData, 0x1054, &BB54 );
+               phy_calibration_winbond(pHwData, 2412); /* Sync operation */
+               Wb35Reg_ReadSync(pHwData, 0x103c, &BB3c);
+               Wb35Reg_ReadSync(pHwData, 0x1054, &BB54);
 
                pHwData->BB3c_cal = BB3c;
                pHwData->BB54_cal = BB54;
 
                RFSynthesizer_initial(pHwData);
-               BBProcessor_initial(pHwData); // Async operation
+               BBProcessor_initial(pHwData); /* Async operation */
 
-               Wb35Reg_WriteSync( pHwData, 0x103c, BB3c );
-               Wb35Reg_WriteSync( pHwData, 0x1054, BB54 );
+               Wb35Reg_WriteSync(pHwData, 0x103c, BB3c);
+               Wb35Reg_WriteSync(pHwData, 0x1054, BB54);
        }
 }