Re: [PATCH] staging: winbond: wb35reg.c Coding style fixes v2.

From: Dan Carpenter
Date: Thu Mar 25 2010 - 10:26:26 EST

On Thu, Mar 25, 2010 at 02:44:53PM +0100, Lars Lindley wrote:
> 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.
>

Acked-by: Dan Carpenter <error27@xxxxxxxxx>

Btw, you didn't introduce them, but there were several places which had
two blank lines in a row. You can delete those if you want, next time.

Thanks again for doing this. It's much cleaner.

regards,
dan carpenter

> 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@xxxxxxxxxx>
> ---
> drivers/staging/winbond/wb35reg.c | 618 ++++++++++++++++++-------------------
> 1 files changed, 305 insertions(+), 313 deletions(-)
>
> diff --git a/drivers/staging/winbond/wb35reg.c b/drivers/staging/winbond/wb35reg.c
> index f5608ad..6f47813 100644
> --- a/drivers/staging/winbond/wb35reg.c
> +++ b/drivers/staging/winbond/wb35reg.c
> @@ -5,60 +5,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;
> @@ -72,8 +73,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) {
> @@ -115,97 +115,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;
> @@ -217,56 +216,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 {
> @@ -277,115 +280,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;
>
> @@ -396,15 +398,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)
> @@ -413,27 +414,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;
>
> @@ -445,7 +446,6 @@ Wb35Reg_EP0VM(struct hw_data * pHwData )
> #endif
> goto cleanup;
> }
> -
> return;
>
> cleanup:
> @@ -454,29 +454,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_
> @@ -485,37 +484,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)
> @@ -523,84 +520,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;
> @@ -608,22 +609,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);
>
> @@ -633,113 +634,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);
> }
> }
>
> --
> 1.7.0.3
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at http://www.tux.org/lkml/
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/