Commit 5a012f67 authored by Alexis Lothoré's avatar Alexis Lothoré Committed by Greg Kroah-Hartman
Browse files

staging: emxx_udc: Update local variable names 



Ensure that any any local variable use snake_case (many mixed upper/lower case)

Signed-off-by: default avatarAlexis Lothoré <alexis.lothore@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 16047b10

drivers/staging/emxx_udc/emxx_udc.c

+124 −124
Original line number Diff line number Diff line
@@ -577,18 +577,18 @@ static int ep0_out_pio(struct nbu2ss_udc *udc, u8 *buf, u32 length) 
static int ep0_out_overbytes(struct nbu2ss_udc *udc, u8 *pBuf, u32 length)

{

	u32		i;

	u32		iReadSize = 0;

	union usb_reg_access  Temp32;

	union usb_reg_access  *pBuf32 = (union usb_reg_access *)pBuf;

	u32		i_read_size = 0;

	union usb_reg_access  temp_32;

	union usb_reg_access  *p_buf_32 = (union usb_reg_access *)pBuf;



	if ((length > 0) && (length < sizeof(u32))) {

		Temp32.dw = _nbu2ss_readl(&udc->p_regs->EP0_READ);

		temp_32.dw = _nbu2ss_readl(&udc->p_regs->EP0_READ);

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

			pBuf32->byte.DATA[i] = Temp32.byte.DATA[i];

		iReadSize += length;

			p_buf_32->byte.DATA[i] = temp_32.byte.DATA[i];

		i_read_size += length;

	}



	return iReadSize;

	return i_read_size;

}



/*-------------------------------------------------------------------------*/
@@ -596,43 +596,43 @@ static int ep0_out_overbytes(struct nbu2ss_udc *udc, u8 *pBuf, u32 length) 
static int EP0_in_PIO(struct nbu2ss_udc *udc, u8 *pBuf, u32 length)

{

	u32		i;

	u32		iMaxLength   = EP0_PACKETSIZE;

	u32		iWordLength  = 0;

	u32		iWriteLength = 0;

	union usb_reg_access  *pBuf32 = (union usb_reg_access *)pBuf;

	u32		i_max_length   = EP0_PACKETSIZE;

	u32		i_word_length  = 0;

	u32		i_write_length = 0;

	union usb_reg_access  *p_buf_32 = (union usb_reg_access *)pBuf;



	/*------------------------------------------------------------*/

	/* Transfer Length */

	if (iMaxLength < length)

		iWordLength = iMaxLength / sizeof(u32);

	if (i_max_length < length)

		i_word_length = i_max_length / sizeof(u32);

	else

		iWordLength = length / sizeof(u32);

		i_word_length = length / sizeof(u32);



	/*------------------------------------------------------------*/

	/* PIO */

	for (i = 0; i < iWordLength; i++) {

		_nbu2ss_writel(&udc->p_regs->EP0_WRITE, pBuf32->dw);

		pBuf32++;

		iWriteLength += sizeof(u32);

	for (i = 0; i < i_word_length; i++) {

		_nbu2ss_writel(&udc->p_regs->EP0_WRITE, p_buf_32->dw);

		p_buf_32++;

		i_write_length += sizeof(u32);

	}



	return iWriteLength;

	return i_write_length;

}



/*-------------------------------------------------------------------------*/

/* Endpoint 0 IN Transfer (PIO, OverBytes) */

static int ep0_in_overbytes(struct nbu2ss_udc *udc, u8 *pBuf, u32 iRemainSize)

static int ep0_in_overbytes(struct nbu2ss_udc *udc, u8 *pBuf, u32 i_remain_size)

{

	u32		i;

	union usb_reg_access  Temp32;

	union usb_reg_access  *pBuf32 = (union usb_reg_access *)pBuf;

	union usb_reg_access  temp_32;

	union usb_reg_access  *p_buf_32 = (union usb_reg_access *)pBuf;



	if ((iRemainSize > 0) && (iRemainSize < sizeof(u32))) {

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

			Temp32.byte.DATA[i] = pBuf32->byte.DATA[i];

		_nbu2ss_ep_in_end(udc, 0, Temp32.dw, iRemainSize);

	if ((i_remain_size > 0) && (i_remain_size < sizeof(u32))) {

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

			temp_32.byte.DATA[i] = p_buf_32->byte.DATA[i];

		_nbu2ss_ep_in_end(udc, 0, temp_32.dw, i_remain_size);



		return iRemainSize;

		return i_remain_size;

	}



	return 0;
@@ -680,9 +680,9 @@ static int _nbu2ss_ep0_in_transfer( 
	struct nbu2ss_req *req

)

{

	u8		*pBuffer;			/* IN Data Buffer */

	u8		*p_buffer;			/* IN Data Buffer */

	u32		data;

	u32		iRemainSize = 0;

	u32		i_remain_size = 0;

	int		result = 0;



	/*-------------------------------------------------------------*/
@@ -706,25 +706,25 @@ static int _nbu2ss_ep0_in_transfer( 
	data &= ~(u32)EP0_INAK;

	_nbu2ss_writel(&udc->p_regs->EP0_CONTROL, data);



	iRemainSize = req->req.length - req->req.actual;

	pBuffer = (u8 *)req->req.buf;

	pBuffer += req->req.actual;

	i_remain_size = req->req.length - req->req.actual;

	p_buffer = (u8 *)req->req.buf;

	p_buffer += req->req.actual;



	/*-------------------------------------------------------------*/

	/* Data transfer */

	result = EP0_in_PIO(udc, pBuffer, iRemainSize);

	result = EP0_in_PIO(udc, p_buffer, i_remain_size);



	req->div_len = result;

	iRemainSize -= result;

	i_remain_size -= result;



	if (iRemainSize == 0) {

	if (i_remain_size == 0) {

		EP0_send_NULL(udc, FALSE);

		return result;

	}



	if ((iRemainSize < sizeof(u32)) && (result != EP0_PACKETSIZE)) {

		pBuffer += result;

		result += ep0_in_overbytes(udc, pBuffer, iRemainSize);

	if ((i_remain_size < sizeof(u32)) && (result != EP0_PACKETSIZE)) {

		p_buffer += result;

		result += ep0_in_overbytes(udc, p_buffer, i_remain_size);

		req->div_len = result;

	}
@@ -737,40 +737,40 @@ static int _nbu2ss_ep0_out_transfer( 
	struct nbu2ss_req *req

)

{

	u8		*pBuffer;

	u32		iRemainSize;

	u32		iRecvLength;

	u8		*p_buffer;

	u32		i_remain_size;

	u32		i_recv_length;

	int		result = 0;

	int		fRcvZero;

	int		f_rcv_zero;



	/*-------------------------------------------------------------*/

	/* Receive data confirmation */

	iRecvLength = _nbu2ss_readl(&udc->p_regs->EP0_LENGTH) & EP0_LDATA;

	if (iRecvLength != 0) {

		fRcvZero = 0;

	i_recv_length = _nbu2ss_readl(&udc->p_regs->EP0_LENGTH) & EP0_LDATA;

	if (i_recv_length != 0) {

		f_rcv_zero = 0;



		iRemainSize = req->req.length - req->req.actual;

		pBuffer = (u8 *)req->req.buf;

		pBuffer += req->req.actual;

		i_remain_size = req->req.length - req->req.actual;

		p_buffer = (u8 *)req->req.buf;

		p_buffer += req->req.actual;



		result = ep0_out_pio(udc, pBuffer

					, min(iRemainSize, iRecvLength));

		result = ep0_out_pio(udc, p_buffer

					, min(i_remain_size, i_recv_length));

		if (result < 0)

			return result;



		req->req.actual += result;

		iRecvLength -= result;

		i_recv_length -= result;



		if ((iRecvLength > 0) && (iRecvLength < sizeof(u32))) {

			pBuffer += result;

			iRemainSize -= result;

		if ((i_recv_length > 0) && (i_recv_length < sizeof(u32))) {

			p_buffer += result;

			i_remain_size -= result;



			result = ep0_out_overbytes(udc, pBuffer

					, min(iRemainSize, iRecvLength));

			result = ep0_out_overbytes(udc, p_buffer

					, min(i_remain_size, i_recv_length));

			req->req.actual += result;

		}

	} else {

		fRcvZero = 1;

		f_rcv_zero = 1;

	}



	/*-------------------------------------------------------------*/
@@ -795,9 +795,9 @@ static int _nbu2ss_ep0_out_transfer( 
		return -EOVERFLOW;

	}



	if (fRcvZero != 0) {

		iRemainSize = _nbu2ss_readl(&udc->p_regs->EP0_CONTROL);

		if (iRemainSize & EP0_ONAK) {

	if (f_rcv_zero != 0) {

		i_remain_size = _nbu2ss_readl(&udc->p_regs->EP0_CONTROL);

		if (i_remain_size & EP0_ONAK) {

			/*---------------------------------------------------*/

			/* NACK release */

			_nbu2ss_bitclr(&udc->p_regs->EP0_CONTROL, EP0_ONAK);
@@ -816,7 +816,7 @@ static int _nbu2ss_out_dma( 
	u32		length

)

{

	dma_addr_t	pBuffer;

	dma_addr_t	p_buffer;

	u32		mpkt;

	u32		lmpkt;

	u32		dmacnt;
@@ -829,11 +829,11 @@ static int _nbu2ss_out_dma( 
		return 1;		/* DMA is forwarded */



	req->dma_flag = TRUE;

	pBuffer = req->req.dma;

	pBuffer += req->req.actual;

	p_buffer = req->req.dma;

	p_buffer += req->req.actual;



	/* DMA Address */

	_nbu2ss_writel(&preg->EP_DCR[num].EP_TADR, (u32)pBuffer);

	_nbu2ss_writel(&preg->EP_DCR[num].EP_TADR, (u32)p_buffer);



	/* Number of transfer packets */

	mpkt = _nbu2ss_readl(&preg->EP_REGS[num].EP_PCKT_ADRS) & EPN_MPKT;
@@ -879,12 +879,12 @@ static int _nbu2ss_epn_out_pio( 
	u32		length

)

{

	u8		*pBuffer;

	u8		*p_buffer;

	u32		i;

	u32		data;

	u32		iWordLength;

	union usb_reg_access	Temp32;

	union usb_reg_access	*pBuf32;

	u32		i_word_length;

	union usb_reg_access	temp_32;

	union usb_reg_access	*p_buf_32;

	int		result = 0;

	struct fc_regs	*preg = udc->p_regs;
@@ -894,28 +894,28 @@ static int _nbu2ss_epn_out_pio( 
	if (length == 0)

		return 0;



	pBuffer = (u8 *)req->req.buf;

	pBuf32 = (union usb_reg_access *)(pBuffer + req->req.actual);

	p_buffer = (u8 *)req->req.buf;

	p_buf_32 = (union usb_reg_access *)(p_buffer + req->req.actual);



	iWordLength = length / sizeof(u32);

	if (iWordLength > 0) {

	i_word_length = length / sizeof(u32);

	if (i_word_length > 0) {

		/*---------------------------------------------------------*/

		/* Copy of every four bytes */

		for (i = 0; i < iWordLength; i++) {

			pBuf32->dw =

		for (i = 0; i < i_word_length; i++) {

			p_buf_32->dw =

			_nbu2ss_readl(&preg->EP_REGS[ep->epnum - 1].EP_READ);

			pBuf32++;

			p_buf_32++;

		}

		result = iWordLength * sizeof(u32);

		result = i_word_length * sizeof(u32);

	}



	data = length - result;

	if (data > 0) {

		/*---------------------------------------------------------*/

		/* Copy of fraction byte */

		Temp32.dw = _nbu2ss_readl(&preg->EP_REGS[ep->epnum - 1].EP_READ);

		temp_32.dw = _nbu2ss_readl(&preg->EP_REGS[ep->epnum - 1].EP_READ);

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

			pBuf32->byte.DATA[i] = Temp32.byte.DATA[i];

			p_buf_32->byte.DATA[i] = temp_32.byte.DATA[i];

		result += data;

	}
@@ -938,7 +938,7 @@ static int _nbu2ss_epn_out_data( 
)

{

	u32		num;

	u32		iBufSize;

	u32		i_buf_size;

	int		nret = 1;



	if (ep->epnum == 0)
@@ -946,14 +946,14 @@ static int _nbu2ss_epn_out_data( 


	num = ep->epnum - 1;



	iBufSize = min((req->req.length - req->req.actual), data_size);

	i_buf_size = min((req->req.length - req->req.actual), data_size);



	if ((ep->ep_type != USB_ENDPOINT_XFER_INT) && (req->req.dma != 0) &&

	    (iBufSize  >= sizeof(u32))) {

		nret = _nbu2ss_out_dma(udc, req, num, iBufSize);

	    (i_buf_size  >= sizeof(u32))) {

		nret = _nbu2ss_out_dma(udc, req, num, i_buf_size);

	} else {

		iBufSize = min_t(u32, iBufSize, ep->ep.maxpacket);

		nret = _nbu2ss_epn_out_pio(udc, ep, req, iBufSize);

		i_buf_size = min_t(u32, i_buf_size, ep->ep.maxpacket);

		nret = _nbu2ss_epn_out_pio(udc, ep, req, i_buf_size);

	}



	return nret;
@@ -967,7 +967,7 @@ static int _nbu2ss_epn_out_transfer( 
)

{

	u32		num;

	u32		iRecvLength;

	u32		i_recv_length;

	int		result = 1;

	struct fc_regs	*preg = udc->p_regs;
@@ -978,13 +978,13 @@ static int _nbu2ss_epn_out_transfer( 


	/*-------------------------------------------------------------*/

	/* Receive Length */

	iRecvLength

	i_recv_length

		= _nbu2ss_readl(&preg->EP_REGS[num].EP_LEN_DCNT) & EPN_LDATA;



	if (iRecvLength != 0) {

		result = _nbu2ss_epn_out_data(udc, ep, req, iRecvLength);

		if (iRecvLength < ep->ep.maxpacket) {

			if (iRecvLength == result) {

	if (i_recv_length != 0) {

		result = _nbu2ss_epn_out_data(udc, ep, req, i_recv_length);

		if (i_recv_length < ep->ep.maxpacket) {

			if (i_recv_length == result) {

				req->req.actual += result;

				result = 0;

			}
@@ -1024,11 +1024,11 @@ static int _nbu2ss_in_dma( 
	u32		length

)

{

	dma_addr_t	pBuffer;

	dma_addr_t	p_buffer;

	u32		mpkt;		/* MaxPacketSize */

	u32		lmpkt;		/* Last Packet Data Size */

	u32		dmacnt;		/* IN Data Size */

	u32		iWriteLength;

	u32		i_write_length;

	u32		data;

	int		result = -EINVAL;

	struct fc_regs	*preg = udc->p_regs;
@@ -1046,15 +1046,15 @@ static int _nbu2ss_in_dma( 
	mpkt = _nbu2ss_readl(&preg->EP_REGS[num].EP_PCKT_ADRS) & EPN_MPKT;



	if ((DMA_MAX_COUNT * mpkt) < length)

		iWriteLength = DMA_MAX_COUNT * mpkt;

		i_write_length = DMA_MAX_COUNT * mpkt;

	else

		iWriteLength = length;

		i_write_length = length;



	/*------------------------------------------------------------*/

	/* Number of transmission packets */

	if (mpkt < iWriteLength) {

		dmacnt = iWriteLength / mpkt;

		lmpkt  = (iWriteLength % mpkt) & ~(u32)0x3;

	if (mpkt < i_write_length) {

		dmacnt = i_write_length / mpkt;

		lmpkt  = (i_write_length % mpkt) & ~(u32)0x3;

		if (lmpkt != 0)

			dmacnt++;

		else
@@ -1062,7 +1062,7 @@ static int _nbu2ss_in_dma( 


	} else {

		dmacnt = 1;

		lmpkt  = iWriteLength & ~(u32)0x3;

		lmpkt  = i_write_length & ~(u32)0x3;

	}



	/* Packet setting */
@@ -1070,9 +1070,9 @@ static int _nbu2ss_in_dma( 
	_nbu2ss_writel(&preg->EP_DCR[num].EP_DCR2, data);



	/* Address setting */

	pBuffer = req->req.dma;

	pBuffer += req->req.actual;

	_nbu2ss_writel(&preg->EP_DCR[num].EP_TADR, (u32)pBuffer);

	p_buffer = req->req.dma;

	p_buffer += req->req.actual;

	_nbu2ss_writel(&preg->EP_DCR[num].EP_TADR, (u32)p_buffer);



	/* Packet and DMA setting */

	data = ((dmacnt & 0xff) << 16) | DCR1_EPN_REQEN;
@@ -1085,7 +1085,7 @@ static int _nbu2ss_in_dma( 
	/*DMA setting of EPC */

	_nbu2ss_bitset(&preg->EP_REGS[num].EP_DMA_CTRL, EPN_DMA_EN);



	result = iWriteLength & ~(u32)0x3;

	result = i_write_length & ~(u32)0x3;

	req->div_len = result;



	return result;
@@ -1099,12 +1099,12 @@ static int _nbu2ss_epn_in_pio( 
	u32		length

)

{

	u8		*pBuffer;

	u8		*p_buffer;

	u32		i;

	u32		data;

	u32		iWordLength;

	union usb_reg_access	Temp32;

	union usb_reg_access	*pBuf32 = NULL;

	u32		i_word_length;

	union usb_reg_access	temp_32;

	union usb_reg_access	*p_buf_32 = NULL;

	int		result = 0;

	struct fc_regs	*preg = udc->p_regs;
@@ -1112,30 +1112,30 @@ static int _nbu2ss_epn_in_pio( 
		return 1;		/* DMA is forwarded */



	if (length > 0) {

		pBuffer = (u8 *)req->req.buf;

		pBuf32 = (union usb_reg_access *)(pBuffer + req->req.actual);

		p_buffer = (u8 *)req->req.buf;

		p_buf_32 = (union usb_reg_access *)(p_buffer + req->req.actual);



		iWordLength = length / sizeof(u32);

		if (iWordLength > 0) {

			for (i = 0; i < iWordLength; i++) {

		i_word_length = length / sizeof(u32);

		if (i_word_length > 0) {

			for (i = 0; i < i_word_length; i++) {

				_nbu2ss_writel(

					&preg->EP_REGS[ep->epnum - 1].EP_WRITE

					, pBuf32->dw

					, p_buf_32->dw

				);



				pBuf32++;

				p_buf_32++;

			}

			result = iWordLength * sizeof(u32);

			result = i_word_length * sizeof(u32);

		}

	}



	if (result != ep->ep.maxpacket) {

		data = length - result;

		Temp32.dw = 0;

		temp_32.dw = 0;

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

			Temp32.byte.DATA[i] = pBuf32->byte.DATA[i];

			temp_32.byte.DATA[i] = p_buf_32->byte.DATA[i];



		_nbu2ss_ep_in_end(udc, ep->epnum, Temp32.dw, data);

		_nbu2ss_ep_in_end(udc, ep->epnum, temp_32.dw, data);

		result += data;

	}
@@ -1179,7 +1179,7 @@ static int _nbu2ss_epn_in_transfer( 
)

{

	u32		num;

	u32		iBufSize;

	u32		i_buf_size;

	int		result = 0;

	u32		status;
@@ -1203,9 +1203,9 @@ static int _nbu2ss_epn_in_transfer( 


	/*-------------------------------------------------------------*/

	/* Start transfer */

	iBufSize = req->req.length - req->req.actual;

	if (iBufSize > 0)

		result = _nbu2ss_epn_in_data(udc, ep, req, iBufSize);

	i_buf_size = req->req.length - req->req.actual;

	if (i_buf_size > 0)

		result = _nbu2ss_epn_in_data(udc, ep, req, i_buf_size);

	else if (req->req.length == 0)

		_nbu2ss_zero_len_pkt(udc, ep->epnum);
@@ -1652,7 +1652,7 @@ static int std_req_set_address(struct nbu2ss_udc *udc) 
/*-------------------------------------------------------------------------*/

static int std_req_set_configuration(struct nbu2ss_udc *udc)

{

	u32 ConfigValue = (u32)(udc->ctrl.wValue & 0x00ff);

	u32 config_value = (u32)(udc->ctrl.wValue & 0x00ff);



	if ((udc->ctrl.wIndex != 0x0000)	||

	    (udc->ctrl.wLength != 0x0000)	||
@@ -1660,9 +1660,9 @@ static int std_req_set_configuration(struct nbu2ss_udc *udc) 
		return -EINVAL;

	}



	udc->curr_config = ConfigValue;

	udc->curr_config = config_value;



	if (ConfigValue > 0) {

	if (config_value > 0) {

		_nbu2ss_bitset(&udc->p_regs->USB_CONTROL, CONF);

		udc->devstate = USB_STATE_CONFIGURED;