Commit 50d487e3 authored by Ruslan Pisarev's avatar Ruslan Pisarev Committed by Greg Kroah-Hartman
Browse files

Staging: keucr: fix comments, braces, whitespaces coding style issue in tm6000.h 



This is a patch to the smilsub.c file that fixed up comment, braces,
whitespaces error found by the checkpatch.pl tools.

Signed-off-by: default avatarRuslan Pisarev <ruslan@rpisarev.org.ua>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 74a5e01e

drivers/staging/keucr/smilsub.c

+315 −317
Original line number Diff line number Diff line
@@ -46,60 +46,59 @@ extern WORD WriteBlock; 






#define EVEN                    0             // Even Page for 256byte/page

#define ODD                     1             // Odd Page for 256byte/page

#define EVEN                    0             /* Even Page for 256byte/page */

#define ODD                     1             /* Odd Page for 256byte/page */





//SmartMedia Redundant buffer data Control Subroutine

//----- Check_D_DataBlank() --------------------------------------------

/* SmartMedia Redundant buffer data Control Subroutine

 *----- Check_D_DataBlank() --------------------------------------------

 */

int Check_D_DataBlank(BYTE *redundant)

{

	char i;



	for (i = 0; i < REDTSIZE; i++)

		if (*redundant++ != 0xFF)

			return(ERROR);

			return  ERROR;



	return(SMSUCCESS);

	return SMSUCCESS;

}



//----- Check_D_FailBlock() --------------------------------------------

/* ----- Check_D_FailBlock() -------------------------------------------- */

int Check_D_FailBlock(BYTE *redundant)

{

	redundant += REDT_BLOCK;



	if (*redundant == 0xFF)

		return(SMSUCCESS);

		return SMSUCCESS;

	if (!*redundant)

		return(ERROR);

		return ERROR;

	if (hweight8(*redundant) < 7)

		return(ERROR);

		return ERROR;



	return(SMSUCCESS);

	return SMSUCCESS;

}



//----- Check_D_DataStatus() -------------------------------------------

/* ----- Check_D_DataStatus() ------------------------------------------- */

int Check_D_DataStatus(BYTE *redundant)

{

	redundant += REDT_DATA;



	if (*redundant == 0xFF)

		return(SMSUCCESS);

	if (!*redundant)

	{

		return SMSUCCESS;

	if (!*redundant) {

		ErrXDCode = ERR_DataStatus;

		return(ERROR);

	}

	else

		return ERROR;

	} else

		ErrXDCode = NO_ERROR;



	if (hweight8(*redundant) < 5)

		return(ERROR);

		return ERROR;



	return(SMSUCCESS);

	return SMSUCCESS;

}



//----- Load_D_LogBlockAddr() ------------------------------------------

/* ----- Load_D_LogBlockAddr() ------------------------------------------ */

int Load_D_LogBlockAddr(BYTE *redundant)

{

	WORD addr1, addr2;
@@ -108,23 +107,30 @@ int Load_D_LogBlockAddr(BYTE *redundant) 
	addr2 = (WORD)*(redundant + REDT_ADDR2H)*0x0100 + (WORD)*(redundant + REDT_ADDR2L);



	if (addr1 == addr2)

		if ((addr1 &0xF000)==0x1000)

		{ Media.LogBlock=(addr1 &0x0FFF)/2; return(SMSUCCESS); }

		if ((addr1 & 0xF000) == 0x1000) {

			Media.LogBlock = (addr1 & 0x0FFF) / 2;

			return SMSUCCESS;

		}



	if (hweight16((WORD)(addr1^addr2))!=0x01) return(ERROR);

	if (hweight16((WORD)(addr1^addr2)) != 0x01)

		return ERROR;



	if ((addr1 & 0xF000) == 0x1000)

		if (!(hweight16(addr1) &0x01))

		{ Media.LogBlock=(addr1 &0x0FFF)/2; return(SMSUCCESS); }

		if (!(hweight16(addr1) & 0x01)) {

			Media.LogBlock = (addr1 & 0x0FFF) / 2;

			return SMSUCCESS;

		}



	if ((addr2 & 0xF000) == 0x1000)

		if (!(hweight16(addr2) &0x01))

		{ Media.LogBlock=(addr2 &0x0FFF)/2; return(SMSUCCESS); }

		if (!(hweight16(addr2) & 0x01)) {

			Media.LogBlock = (addr2 & 0x0FFF) / 2;

			return SMSUCCESS;

		}



	return(ERROR);

	return ERROR;

}



//----- Clr_D_RedundantData() ------------------------------------------

/* ----- Clr_D_RedundantData() ------------------------------------------ */

void Clr_D_RedundantData(BYTE *redundant)

{

	char i;
@@ -133,7 +139,7 @@ void Clr_D_RedundantData(BYTE *redundant) 
		*(redundant + i) = 0xFF;

}



//----- Set_D_LogBlockAddr() -------------------------------------------

/* ----- Set_D_LogBlockAddr() ------------------------------------------- */

void Set_D_LogBlockAddr(BYTE *redundant)

{

	WORD addr;
@@ -149,31 +155,31 @@ void Set_D_LogBlockAddr(BYTE *redundant) 
	*(redundant + REDT_ADDR1L) = *(redundant + REDT_ADDR2L) = (BYTE)addr;

}



//----- Set_D_FailBlock() ----------------------------------------------

/*----- Set_D_FailBlock() ---------------------------------------------- */

void Set_D_FailBlock(BYTE *redundant)

{

	char i;



	for (i = 0; i < REDTSIZE; i++)

		*redundant++ = (BYTE)((i == REDT_BLOCK) ? 0xF0 : 0xFF);

}



//----- Set_D_DataStaus() ----------------------------------------------

/* ----- Set_D_DataStaus() ---------------------------------------------- */

void Set_D_DataStaus(BYTE *redundant)

{

	redundant += REDT_DATA;

	*redundant = 0x00;

}



//SmartMedia Function Command Subroutine

// 6250 CMD 6

//----- Ssfdc_D_Reset() ------------------------------------------------

/* SmartMedia Function Command Subroutine

 * 6250 CMD 6

 */

/* ----- Ssfdc_D_Reset() ------------------------------------------------ */

void Ssfdc_D_Reset(struct us_data *us)

{

	return;

}



//----- Ssfdc_D_ReadCisSect() ------------------------------------------

/* ----- Ssfdc_D_ReadCisSect() ------------------------------------------ */

int Ssfdc_D_ReadCisSect(struct us_data *us, BYTE *buf, BYTE *redundant)

{

	BYTE zone, sector;
@@ -184,18 +190,17 @@ int Ssfdc_D_ReadCisSect(struct us_data *us, BYTE *buf,BYTE *redundant) 
	Media.PhyBlock = CisArea.PhyBlock;

	Media.Sector = CisArea.Sector;



	if (Ssfdc_D_ReadSect(us,buf,redundant))

	{

	if (Ssfdc_D_ReadSect(us, buf, redundant)) {

		Media.Zone = zone; Media.PhyBlock = block; Media.Sector = sector;

		return(ERROR);

		return ERROR;

	}



	Media.Zone = zone; Media.PhyBlock = block; Media.Sector = sector;

	return(SMSUCCESS);

	return SMSUCCESS;

}



// 6250 CMD 1

//----- Ssfdc_D_ReadSect() ---------------------------------------------

/* 6250 CMD 1 */

/* ----- Ssfdc_D_ReadSect() --------------------------------------------- */

int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf, BYTE *redundant)

{

	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
@@ -203,8 +208,7 @@ int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf,BYTE *redundant) 
	WORD	addr;



	result = ENE_LoadBinCode(us, SM_RW_PATTERN);

	if (result != USB_STOR_XFER_GOOD)

	{

	if (result != USB_STOR_XFER_GOOD) {

		printk("Load SM RW Code Fail !!\n");

		return USB_STOR_TRANSPORT_ERROR;

	}
@@ -212,7 +216,7 @@ int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf,BYTE *redundant) 
	addr = (WORD)Media.Zone*Ssfdc.MaxBlocks + Media.PhyBlock;

	addr = addr*(WORD)Ssfdc.MaxSectors + Media.Sector;



	// Read sect data

	/* Read sect data */

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));

	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);

	bcb->DataTransferLength	= 0x200;
@@ -227,7 +231,7 @@ int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf,BYTE *redundant) 
	if (result != USB_STOR_XFER_GOOD)

		return USB_STOR_TRANSPORT_ERROR;



	// Read redundant

	/* Read redundant */

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));

	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);

	bcb->DataTransferLength	= 0x10;
@@ -247,7 +251,7 @@ int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf,BYTE *redundant) 
	return USB_STOR_TRANSPORT_GOOD;

}



//----- Ssfdc_D_ReadBlock() ---------------------------------------------

/* ----- Ssfdc_D_ReadBlock() --------------------------------------------- */

int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf, BYTE *redundant)

{

	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
@@ -255,8 +259,7 @@ int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant) 
	WORD	addr;



	result = ENE_LoadBinCode(us, SM_RW_PATTERN);

	if (result != USB_STOR_XFER_GOOD)

	{

	if (result != USB_STOR_XFER_GOOD) {

		printk("Load SM RW Code Fail !!\n");

		return USB_STOR_TRANSPORT_ERROR;

	}
@@ -264,7 +267,7 @@ int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant) 
	addr = (WORD)Media.Zone*Ssfdc.MaxBlocks + Media.PhyBlock;

	addr = addr*(WORD)Ssfdc.MaxSectors + Media.Sector;



	// Read sect data

	/* Read sect data */

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));

	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);

	bcb->DataTransferLength	= 0x200*count;
@@ -279,7 +282,7 @@ int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant) 
	if (result != USB_STOR_XFER_GOOD)

		return USB_STOR_TRANSPORT_ERROR;



	// Read redundant

	/* Read redundant */

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));

	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);

	bcb->DataTransferLength	= 0x10;
@@ -300,7 +303,7 @@ int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant) 
}





//----- Ssfdc_D_CopyBlock() --------------------------------------------

/* ----- Ssfdc_D_CopyBlock() -------------------------------------------- */

int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf, BYTE *redundant)

{

	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
@@ -308,8 +311,7 @@ int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant) 
	WORD	ReadAddr, WriteAddr;



	result = ENE_LoadBinCode(us, SM_RW_PATTERN);

	if (result != USB_STOR_XFER_GOOD)

	{

	if (result != USB_STOR_XFER_GOOD) {

		printk("Load SM RW Code Fail !!\n");

		return USB_STOR_TRANSPORT_ERROR;

	}
@@ -319,7 +321,7 @@ int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant) 
	WriteAddr = (WORD)Media.Zone*Ssfdc.MaxBlocks + WriteBlock;

	WriteAddr = WriteAddr*(WORD)Ssfdc.MaxSectors;



	// Write sect data

	/* Write sect data */

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));

	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);

	bcb->DataTransferLength	= 0x200*count;
@@ -333,13 +335,11 @@ int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant) 
	bcb->CDB[9]			= *(redundant + REDT_ADDR1L);

	bcb->CDB[10]		= Media.Sector;



	if (ReadBlock != NO_ASSIGN)

	{

	if (ReadBlock != NO_ASSIGN) {

		bcb->CDB[4]		= (BYTE)ReadAddr;

		bcb->CDB[3]		= (BYTE)(ReadAddr / 0x0100);

		bcb->CDB[2]		= Media.Zone / 2;

	}

	else

	} else

		bcb->CDB[11]	= 1;



	result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
@@ -349,7 +349,7 @@ int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant) 
	return USB_STOR_TRANSPORT_GOOD;

}



//----- Ssfdc_D_WriteSectForCopy() -------------------------------------

/* ----- Ssfdc_D_WriteSectForCopy() ------------------------------------- */

int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant)

{

	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
@@ -357,8 +357,7 @@ int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant) 
	WORD	addr;



	result = ENE_LoadBinCode(us, SM_RW_PATTERN);

	if (result != USB_STOR_XFER_GOOD)

	{

	if (result != USB_STOR_XFER_GOOD) {

		printk("Load SM RW Code Fail !!\n");

		return USB_STOR_TRANSPORT_ERROR;

	}
@@ -367,7 +366,7 @@ int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant) 
	addr = (WORD)Media.Zone*Ssfdc.MaxBlocks + Media.PhyBlock;

	addr = addr*(WORD)Ssfdc.MaxSectors + Media.Sector;



	// Write sect data

	/* Write sect data */

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));

	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);

	bcb->DataTransferLength	= 0x200;
@@ -387,8 +386,8 @@ int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant) 
	return USB_STOR_TRANSPORT_GOOD;

}



// 6250 CMD 5

//----- Ssfdc_D_EraseBlock() -------------------------------------------

/* 6250 CMD 5 */

/* ----- Ssfdc_D_EraseBlock() ------------------------------------------- */

int Ssfdc_D_EraseBlock(struct us_data *us)

{

	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
@@ -396,8 +395,7 @@ int Ssfdc_D_EraseBlock(struct us_data *us) 
	WORD	addr;



	result = ENE_LoadBinCode(us, SM_RW_PATTERN);

	if (result != USB_STOR_XFER_GOOD)

	{

	if (result != USB_STOR_XFER_GOOD) {

		printk("Load SM RW Code Fail !!\n");

		return USB_STOR_TRANSPORT_ERROR;

	}
@@ -422,8 +420,8 @@ int Ssfdc_D_EraseBlock(struct us_data *us) 
	return USB_STOR_TRANSPORT_GOOD;

}



// 6250 CMD 2

//----- Ssfdc_D_ReadRedtData() -----------------------------------------

/* 6250 CMD 2 */

/*----- Ssfdc_D_ReadRedtData() ----------------------------------------- */

int Ssfdc_D_ReadRedtData(struct us_data *us, BYTE *redundant)

{

	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
@@ -432,8 +430,7 @@ int Ssfdc_D_ReadRedtData(struct us_data *us, BYTE *redundant) 
	BYTE	*buf;



	result = ENE_LoadBinCode(us, SM_RW_PATTERN);

	if (result != USB_STOR_XFER_GOOD)

	{

	if (result != USB_STOR_XFER_GOOD) {

		printk("Load SM RW Code Fail !!\n");

		return USB_STOR_TRANSPORT_ERROR;

	}
@@ -463,8 +460,8 @@ int Ssfdc_D_ReadRedtData(struct us_data *us, BYTE *redundant) 
	return USB_STOR_TRANSPORT_GOOD;

}



// 6250 CMD 4

//----- Ssfdc_D_WriteRedtData() ----------------------------------------

/* 6250 CMD 4 */

/* ----- Ssfdc_D_WriteRedtData() ---------------------------------------- */

int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant)

{

	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
@@ -472,8 +469,7 @@ int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant) 
	WORD                    addr;



	result = ENE_LoadBinCode(us, SM_RW_PATTERN);

	if (result != USB_STOR_XFER_GOOD)

	{

	if (result != USB_STOR_XFER_GOOD) {

		printk("Load SM RW Code Fail !!\n");

		return USB_STOR_TRANSPORT_ERROR;

	}
@@ -500,16 +496,17 @@ int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant) 
	return USB_STOR_TRANSPORT_GOOD;

}



//----- Ssfdc_D_CheckStatus() ------------------------------------------

/* ----- Ssfdc_D_CheckStatus() ------------------------------------------ */

int Ssfdc_D_CheckStatus(void)

{

    return(SMSUCCESS);

	return SMSUCCESS;

}







//SmartMedia ID Code Check & Mode Set Subroutine

//----- Set_D_SsfdcModel() ---------------------------------------------

/* SmartMedia ID Code Check & Mode Set Subroutine

 * ----- Set_D_SsfdcModel() ---------------------------------------------

 */

int Set_D_SsfdcModel(BYTE dcode)

{

	switch (_Check_D_DevCode(dcode)) {
@@ -611,54 +608,55 @@ int Set_D_SsfdcModel(BYTE dcode) 
		break;

	default:

		Ssfdc.Model = NOSSFDC;

            return(ERROR);

		return ERROR;

	}



    return(SMSUCCESS);

    return SMSUCCESS;

}



//----- _Check_D_DevCode() ---------------------------------------------

/* ----- _Check_D_DevCode() --------------------------------------------- */

BYTE _Check_D_DevCode(BYTE dcode)

{

	switch (dcode) {

	case 0x6E:

	case 0xE8:

        case 0xEC: return(SSFDC1MB);   // 8Mbit (1M) NAND

	case 0xEC: return SSFDC1MB;   /* 8Mbit (1M) NAND */

	case 0x64:

        case 0xEA: return(SSFDC2MB);   // 16Mbit (2M) NAND

	case 0xEA: return SSFDC2MB;   /* 16Mbit (2M) NAND */

	case 0x6B:

	case 0xE3:

        case 0xE5: return(SSFDC4MB);   // 32Mbit (4M) NAND

        case 0xE6: return(SSFDC8MB);   // 64Mbit (8M) NAND

        case 0x73: return(SSFDC16MB);  // 128Mbit (16M)NAND

        case 0x75: return(SSFDC32MB);  // 256Mbit (32M)NAND

        case 0x76: return(SSFDC64MB);  // 512Mbit (64M)NAND

        case 0x79: return(SSFDC128MB); // 1Gbit(128M)NAND

        case 0x71: return(SSFDC256MB);

        case 0xDC: return(SSFDC512MB);

        case 0xD3: return(SSFDC1GB);

        case 0xD5: return(SSFDC2GB);

        default: return(NOSSFDC);

	case 0xE5: return SSFDC4MB;   /* 32Mbit (4M) NAND */

	case 0xE6: return SSFDC8MB;   /* 64Mbit (8M) NAND */

	case 0x73: return SSFDC16MB;  /* 128Mbit (16M)NAND */

	case 0x75: return SSFDC32MB;  /* 256Mbit (32M)NAND */

	case 0x76: return SSFDC64MB;  /* 512Mbit (64M)NAND */

	case 0x79: return SSFDC128MB; /* 1Gbit(128M)NAND */

	case 0x71: return SSFDC256MB;

	case 0xDC: return SSFDC512MB;

	case 0xD3: return SSFDC1GB;

	case 0xD5: return SSFDC2GB;

	default: return NOSSFDC;

	}

}









//SmartMedia ECC Control Subroutine

//----- Check_D_ReadError() ----------------------------------------------

/* SmartMedia ECC Control Subroutine

 * ----- Check_D_ReadError() ----------------------------------------------

 */

int Check_D_ReadError(BYTE *redundant)

{

	return SMSUCCESS;

}



//----- Check_D_Correct() ----------------------------------------------

/* ----- Check_D_Correct() ---------------------------------------------- */

int Check_D_Correct(BYTE *buf, BYTE *redundant)

{

	return SMSUCCESS;

}



//----- Check_D_CISdata() ----------------------------------------------

/* ----- Check_D_CISdata() ---------------------------------------------- */

int Check_D_CISdata(BYTE *buf, BYTE *redundant)

{

	BYTE cis[] = {0x01, 0x03, 0xD9, 0x01, 0xFF, 0x18, 0x02,
@@ -685,10 +683,10 @@ int Check_D_CISdata(BYTE *buf, BYTE *redundant) 
	return ERROR;

}



//----- Set_D_RightECC() ----------------------------------------------

/* ----- Set_D_RightECC() ---------------------------------------------- */

void Set_D_RightECC(BYTE *redundant)

{

    // Driver  ECC Check

    /* Driver ECC Check */

    return;

}