Commit a5e4b81e authored by Kevin McKinney's avatar Kevin McKinney Committed by Greg Kroah-Hartman
Browse files

Staging: bcm: Fix coding style issues in InterfaceDld.c 



This patch fixes multiple coding style issues in file,
InterfaceDld.c, found by checkpatch.pl.

Signed-off-by: default avatarKevin McKinney <klmckinney1@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent a3e2940c

drivers/staging/bcm/InterfaceDld.c

+161 −213
Original line number Diff line number Diff line
@@ -35,8 +35,9 @@ int InterfaceFileDownload(PVOID arg, struct file *flp, unsigned int on_chip_loc) 
			break;

		}

		/* BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_INITEXIT, MP_INIT,

					  DBG_LVL_ALL, buff,

					  MAX_TRANSFER_CTRL_BYTE_USB);*/

		 *			  DBG_LVL_ALL, buff,

		 *			  MAX_TRANSFER_CTRL_BYTE_USB);

		 */

		errno = InterfaceWRM(psIntfAdapter, on_chip_loc, buff, len);

		if (errno) {

			BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,
@@ -51,8 +52,7 @@ int InterfaceFileDownload(PVOID arg, struct file *flp, unsigned int on_chip_loc) 
	return errno;

}



int InterfaceFileReadbackFromChip(PVOID arg, struct file *flp,

				  unsigned int on_chip_loc)

int InterfaceFileReadbackFromChip(PVOID arg, struct file *flp, unsigned int on_chip_loc)

{

	char *buff, *buff_readback;

	unsigned int reg = 0;
@@ -65,8 +65,7 @@ int InterfaceFileReadbackFromChip(PVOID arg, struct file *flp, 


	buff = kmalloc(MAX_TRANSFER_CTRL_BYTE_USB, GFP_DMA);

	buff_readback = kmalloc(MAX_TRANSFER_CTRL_BYTE_USB , GFP_DMA);

    if(!buff || !buff_readback)

    {

	if (!buff || !buff_readback) {

		kfree(buff);

		kfree(buff_readback);
@@ -77,52 +76,42 @@ int InterfaceFileReadbackFromChip(PVOID arg, struct file *flp, 


	memset(buff_readback, 0, MAX_TRANSFER_CTRL_BYTE_USB);

	memset(buff, 0, MAX_TRANSFER_CTRL_BYTE_USB);

    while(1)

    {

        oldfs=get_fs(); set_fs(get_ds());

	while (1) {

		oldfs = get_fs();

		set_fs(get_ds());

		len = vfs_read(flp, (void __force __user *)buff, MAX_TRANSFER_CTRL_BYTE_USB, &pos);

		set_fs(oldfs);

		fw_down++;

        if(len<=0)

        {

            if(len<0)

            {



		if (len <= 0) {

			if (len < 0) {

				BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "len < 0");

				errno = len;

            }

            else

            {

			} else {

				errno = 0;

				BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Got end of file!");

			}

			break;

		}





		Status = InterfaceRDM(psIntfAdapter, on_chip_loc, buff_readback, len);

		if(Status)

		{

		if (Status) {

			BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "RDM of len %d Failed! %d", len, reg);

			goto exit;

		}

		reg++;

        if((len-sizeof(unsigned int))<4)

        {

            if(memcmp(buff_readback, buff, len))

            {

		if ((len-sizeof(unsigned int)) < 4) {

			if (memcmp(buff_readback, buff, len)) {

				BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Firmware Download is not proper %d", fw_down);

				BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Length is: %d", len);

				Status = -EIO;

				goto exit;

			}

        }

        else

        {

		} else {

			len -= 4;

            while(len)

            {

                if(*(unsigned int*)&buff_readback[len] != *(unsigned int *)&buff[len])

                {



			while (len) {

				if (*(unsigned int *)&buff_readback[len] != *(unsigned int *)&buff[len]) {

					BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Firmware Download is not proper %d", fw_down);

					BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Val from Binary %x, Val From Read Back %x ", *(unsigned int *)&buff[len], *(unsigned int*)&buff_readback[len]);

					BCM_DEBUG_PRINT(psIntfAdapter->psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "len =%x!!!", len);
@@ -134,69 +123,60 @@ int InterfaceFileReadbackFromChip(PVOID arg, struct file *flp, 
		}

		on_chip_loc += MAX_TRANSFER_CTRL_BYTE_USB;

	} /* End of while(1) */



exit:

	kfree(buff);

	kfree(buff_readback);

	return Status;

}



static int bcm_download_config_file(PMINI_ADAPTER Adapter,

								FIRMWARE_INFO *psFwInfo)

static int bcm_download_config_file(PMINI_ADAPTER Adapter, FIRMWARE_INFO *psFwInfo)

{

	int retval = STATUS_SUCCESS;

	B_UINT32 value = 0;



	if(Adapter->pstargetparams == NULL)

    {

        if((Adapter->pstargetparams =

            kmalloc(sizeof(STARGETPARAMS), GFP_KERNEL)) == NULL)

        {

	if (Adapter->pstargetparams == NULL) {

		if ((Adapter->pstargetparams = kmalloc(sizeof(STARGETPARAMS), GFP_KERNEL)) == NULL) {

			return -ENOMEM;

		}

	}



	if (psFwInfo->u32FirmwareLength != sizeof(STARGETPARAMS))

	{

		return -EIO;

	}

	retval = copy_from_user(Adapter->pstargetparams,

			psFwInfo->pvMappedFirmwareAddress, psFwInfo->u32FirmwareLength);

	if(retval)

	{



	retval = copy_from_user(Adapter->pstargetparams, psFwInfo->pvMappedFirmwareAddress, psFwInfo->u32FirmwareLength);

	if (retval) {

		kfree(Adapter->pstargetparams);

		Adapter->pstargetparams = NULL;

		return -EFAULT;

	}



	/* Parse the structure and then Download the Firmware */

	beceem_parse_target_struct(Adapter);



	//Initializing the NVM.

	/* Initializing the NVM. */

	BcmInitNVM(Adapter);



	retval = InitLedSettings(Adapter);



	if(retval)

	{

	if (retval) {

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "INIT LED Failed\n");

		return retval;

	}



	if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)

	{

	if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {

		Adapter->LEDInfo.bLedInitDone = FALSE;

		Adapter->DriverState = DRIVER_INIT;

		wake_up(&Adapter->LEDInfo.notify_led_event);

	}



	if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)

	{

	if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {

		Adapter->DriverState = FW_DOWNLOAD;

		wake_up(&Adapter->LEDInfo.notify_led_event);

	}



	/* Initialize the DDR Controller */

	retval = ddr_init(Adapter);

	if(retval)

	{

	if (retval) {

		BCM_DEBUG_PRINT (Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "DDR Init Failed\n");

		return retval;

	}
@@ -205,49 +185,36 @@ static int bcm_download_config_file(PMINI_ADAPTER Adapter, 
	wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));

	wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));



	if(Adapter->eNVMType == NVM_FLASH)

	{

	if (Adapter->eNVMType == NVM_FLASH) {

		retval = PropagateCalParamsFromFlashToMemory(Adapter);

		if(retval)

		{

		if (retval) {

			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "propagaion of cal param failed with status :%d", retval);

			return retval;

		}

	}





	retval = buffDnldVerify(Adapter, (PUCHAR)Adapter->pstargetparams, sizeof(STARGETPARAMS), CONFIG_BEGIN_ADDR);



	if (retval)

	{

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "configuration file not downloaded properly");

	}

	else

		Adapter->bCfgDownloaded = TRUE;





	return retval;

}

static int bcm_compare_buff_contents(unsigned char *readbackbuff,

	unsigned char *buff,unsigned int len)



static int bcm_compare_buff_contents(unsigned char *readbackbuff, unsigned char *buff, unsigned int len)

{

	int retval = STATUS_SUCCESS;

	PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);

    if((len-sizeof(unsigned int))<4)

	{

	if ((len-sizeof(unsigned int)) < 4) {

		if (memcmp(readbackbuff , buff, len))

		{

			retval = -EINVAL;

		}

	}

	else

	{

	} else {

		len -= 4;

		while(len)

		{

			if(*(unsigned int*)&readbackbuff[len] !=

					*(unsigned int *)&buff[len])

			{



		while (len) {

			if (*(unsigned int *)&readbackbuff[len] != *(unsigned int *)&buff[len]) {

				BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Firmware Download is not proper");

				BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Val from Binary %x, Val From Read Back %x ", *(unsigned int *)&buff[len], *(unsigned int*)&readbackbuff[len]);

				BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "len =%x!!!", len);
@@ -259,41 +226,35 @@ static int bcm_compare_buff_contents(unsigned char *readbackbuff, 
	}

	return retval;

}



int bcm_ioctl_fw_download(PMINI_ADAPTER Adapter, FIRMWARE_INFO *psFwInfo)

{

	int retval = STATUS_SUCCESS;

	PUCHAR buff = NULL;



	/* Config File is needed for the Driver to download the Config file and

		Firmware. Check for the Config file to be first to be sent from the

		Application

	 * Firmware. Check for the Config file to be first to be sent from the

	 * Application

	 */

	atomic_set(&Adapter->uiMBupdate, FALSE);

	if(!Adapter->bCfgDownloaded &&

		psFwInfo->u32StartingAddress != CONFIG_BEGIN_ADDR)

	{

	if (!Adapter->bCfgDownloaded && psFwInfo->u32StartingAddress != CONFIG_BEGIN_ADDR) {

		/* Can't Download Firmware. */

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Download the config File first\n");

		return -EINVAL;

	}



	/* If Config File, Finish the DDR Settings and then Download CFG File */

    if(psFwInfo->u32StartingAddress == CONFIG_BEGIN_ADDR)

    {

	if (psFwInfo->u32StartingAddress == CONFIG_BEGIN_ADDR) {

		retval = bcm_download_config_file(Adapter, psFwInfo);

	}

	else

	{



	} else {

		buff = kzalloc(psFwInfo->u32FirmwareLength, GFP_KERNEL);

		if(buff==NULL)

		{

		if (buff == NULL) {

			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Failed in allocation memory");

			return -ENOMEM;

		}



		retval = copy_from_user(buff, psFwInfo->pvMappedFirmwareAddress, psFwInfo->u32FirmwareLength);

		if(retval != STATUS_SUCCESS)

		{

		if (retval != STATUS_SUCCESS) {

			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "copying buffer from user space failed");

			retval = -EFAULT;

			goto error;
@@ -303,31 +264,29 @@ int bcm_ioctl_fw_download(PMINI_ADAPTER Adapter, FIRMWARE_INFO *psFwInfo) 
					buff,

					psFwInfo->u32FirmwareLength,

					psFwInfo->u32StartingAddress);

		if(retval != STATUS_SUCCESS)

		{



		if (retval != STATUS_SUCCESS) {

			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "f/w download failed status :%d", retval);

			goto error;

		}

	}



error:

	kfree(buff);

	return retval;

}



static INT buffDnld(PMINI_ADAPTER Adapter, PUCHAR mappedbuffer, UINT u32FirmwareLength,

		ULONG u32StartingAddress)

static INT buffDnld(PMINI_ADAPTER Adapter, PUCHAR mappedbuffer, UINT u32FirmwareLength, ULONG u32StartingAddress)

{



	unsigned int len = 0;

	int retval = STATUS_SUCCESS;

	len = u32FirmwareLength;



	while(u32FirmwareLength)

	{

	while (u32FirmwareLength) {

		len = MIN_VAL(u32FirmwareLength, MAX_TRANSFER_CTRL_BYTE_USB);

		retval = wrm(Adapter, u32StartingAddress, mappedbuffer, len);

		if(retval)

		{



		if (retval) {

			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "wrm failed with status :%d", retval);

			break;

		}
@@ -336,66 +295,55 @@ static INT buffDnld(PMINI_ADAPTER Adapter, PUCHAR mappedbuffer, UINT u32Firmware 
		mappedbuffer += len;

	}

	return retval;



}



static INT buffRdbkVerify(PMINI_ADAPTER Adapter,

			PUCHAR mappedbuffer, UINT u32FirmwareLength,

			ULONG u32StartingAddress)

static INT buffRdbkVerify(PMINI_ADAPTER Adapter, PUCHAR mappedbuffer, UINT u32FirmwareLength, ULONG u32StartingAddress)

{

	UINT len = u32FirmwareLength;

	INT retval = STATUS_SUCCESS;

	PUCHAR readbackbuff = kzalloc(MAX_TRANSFER_CTRL_BYTE_USB, GFP_KERNEL);



	if(NULL == readbackbuff)

	{

	if (NULL == readbackbuff) {

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "MEMORY ALLOCATION FAILED");

		return -ENOMEM;

	}

	while (u32FirmwareLength && !retval)

	{



	while (u32FirmwareLength && !retval) {

		len = MIN_VAL(u32FirmwareLength, MAX_TRANSFER_CTRL_BYTE_USB);



		retval = rdm(Adapter, u32StartingAddress, readbackbuff, len);

		if(retval)

		{



		if (retval) {

			BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "rdm failed with status %d", retval);

			break;

		}



		if (STATUS_SUCCESS != (retval = bcm_compare_buff_contents(readbackbuff, mappedbuffer, len)))

		{

			break;

		}



		u32StartingAddress += len;

		u32FirmwareLength -= len;

		mappedbuffer += len;



	} /* end of while (u32FirmwareLength && !retval) */

	kfree(readbackbuff);

	return retval;

}



INT buffDnldVerify(PMINI_ADAPTER Adapter, unsigned char *mappedbuffer, unsigned int u32FirmwareLength,

		unsigned long u32StartingAddress)

INT buffDnldVerify(PMINI_ADAPTER Adapter, unsigned char *mappedbuffer, unsigned int u32FirmwareLength, unsigned long u32StartingAddress)

{

	INT status = STATUS_SUCCESS;



	status = buffDnld(Adapter, mappedbuffer, u32FirmwareLength, u32StartingAddress);

	if(status != STATUS_SUCCESS)

	{

	if (status != STATUS_SUCCESS) {

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Buffer download failed");

		goto error;

	}



	status = buffRdbkVerify(Adapter, mappedbuffer, u32FirmwareLength, u32StartingAddress);

	if(status != STATUS_SUCCESS)

	{

	if (status != STATUS_SUCCESS) {

		BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Buffer readback verifier failed");

		goto error;

	}

error:

	return status;

}