Staging: ced1401: Fixes 'open brace should be on the previous line'. (e035b590) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/staging/ced1401/ced_ioc.c

+38 −70

Original line number	Original line	Diff line number	Diff line
	@@ -118,8 +118,7 @@ int SendString(DEVICE_EXTENSION pdx, const char __user pData,
	buffer[n] = 0; /* terminate for debug purposes */		buffer[n] = 0; /* terminate for debug purposes */

	mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */		mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
	if (n > 0) /* do nothing if nowt to do! */		if (n > 0) { /* do nothing if nowt to do! */
	{
	dev_dbg(&pdx->interface->dev, "%s n=%d>%s<", __func__, n,		dev_dbg(&pdx->interface->dev, "%s n=%d>%s<", __func__, n,
	buffer);		buffer);
	iReturn = PutChars(pdx, buffer, n);		iReturn = PutChars(pdx, buffer, n);
	@@ -198,8 +197,7 @@ int Get1401State(DEVICE_EXTENSION pdx, __u32 state, __u32 *error)
	*error = pdx->statBuf[1];		*error = pdx->statBuf[1];

	nDevice = pdx->udev->descriptor.bcdDevice >> 8; /* 1401 type code value */		nDevice = pdx->udev->descriptor.bcdDevice >> 8; /* 1401 type code value */
	switch (nDevice) /* so we can clean up current state */		switch (nDevice) { /* so we can clean up current state */
	{
	case 0:		case 0:
	pdx->sCurrentState = U14ERR_U1401;		pdx->sCurrentState = U14ERR_U1401;
	break;		break;
	@@ -232,8 +230,7 @@ int ReadWrite_Cancel(DEVICE_EXTENSION *pdx)
	/* We can fill this in when we know how we will implement the staged transfer stuff */		/* We can fill this in when we know how we will implement the staged transfer stuff */
	spin_lock_irq(&pdx->stagedLock);		spin_lock_irq(&pdx->stagedLock);

	if (pdx->bStagedUrbPending) /* anything to be cancelled? May need more... */		if (pdx->bStagedUrbPending) { /* anything to be cancelled? May need more... */
	{
	dev_info(&pdx->interface - dev,		dev_info(&pdx->interface - dev,
	"ReadWrite_Cancel about to cancel Urb");		"ReadWrite_Cancel about to cancel Urb");
	/* Clear the staging done flag */		/* Clear the staging done flag */
	@@ -321,20 +318,17 @@ bool Is1401(DEVICE_EXTENSION *pdx)
	/* release the io_mutex because if we don't, we will deadlock due to system */		/* release the io_mutex because if we don't, we will deadlock due to system */
	/* calls back into the driver. */		/* calls back into the driver. */
	mutex_unlock(&pdx->io_mutex); /* locked, so we will not get system calls */		mutex_unlock(&pdx->io_mutex); /* locked, so we will not get system calls */
	if (iReturn >= 0) /* if we failed */		if (iReturn >= 0) { /* if we failed */
	{
	iReturn = usb_reset_device(pdx->udev); /* try to do the reset */		iReturn = usb_reset_device(pdx->udev); /* try to do the reset */
	usb_unlock_device(pdx->udev); /* undo the lock */		usb_unlock_device(pdx->udev); /* undo the lock */
	}		}

	mutex_lock(&pdx->io_mutex); /* hold stuff off while we wait */		mutex_lock(&pdx->io_mutex); /* hold stuff off while we wait */
	pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flag regardless! */		pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flag regardless! */
	if (iReturn == 0) /* if all is OK still */		if (iReturn == 0) { /* if all is OK still */
	{
	unsigned int state;		unsigned int state;
	iReturn = InSelfTest(pdx, &state); /* see if likely in self test */		iReturn = InSelfTest(pdx, &state); /* see if likely in self test */
	if (iReturn > 0) /* do we need to wait for self-test? */		if (iReturn > 0) { /* do we need to wait for self-test? */
	{
	unsigned long ulTimeOut = jiffies + 30 * HZ; /* when to give up */		unsigned long ulTimeOut = jiffies + 30 * HZ; /* when to give up */
	while ((iReturn > 0) && time_before(jiffies, ulTimeOut)) {		while ((iReturn > 0) && time_before(jiffies, ulTimeOut)) {
	schedule(); /* let other stuff run */		schedule(); /* let other stuff run */
	@@ -380,26 +374,23 @@ bool QuickCheck(DEVICE_EXTENSION *pdx, bool bTestBuff, bool bCanReset)
	bTestBuff, bShortTest);		bTestBuff, bShortTest);

	if ((bTestBuff) && /* Buffer check requested, and... */		if ((bTestBuff) && /* Buffer check requested, and... */
	(pdx->dwNumInput \|\| pdx->dwNumOutput)) /* ...characters were in the buffer? */		(pdx->dwNumInput \|\| pdx->dwNumOutput)) { /* ...characters were in the buffer? */
	{
	bShortTest = false; /* Then do the full test */		bShortTest = false; /* Then do the full test */
	dev_dbg(&pdx->interface->dev,		dev_dbg(&pdx->interface->dev,
	"%s will reset as buffers not empty", __func__);		"%s will reset as buffers not empty", __func__);
	}		}

	if (bShortTest \|\| !bCanReset) /* Still OK to try the short test? */		if (bShortTest \|\| !bCanReset) { /* Still OK to try the short test? */
	{ /* Always test if no reset - we want state update */		/* Always test if no reset - we want state update */
	unsigned int state, error;		unsigned int state, error;
	dev_dbg(&pdx->interface->dev, "%s->Get1401State", __func__);		dev_dbg(&pdx->interface->dev, "%s->Get1401State", __func__);
	if (Get1401State(pdx, &state, &error) == U14ERR_NOERROR) /* Check on the 1401 state */		if (Get1401State(pdx, &state, &error) == U14ERR_NOERROR) { /* Check on the 1401 state */
	{
	if ((state & 0xFF) == 0) /* If call worked, check the status value */		if ((state & 0xFF) == 0) /* If call worked, check the status value */
	bRet = true; /* If that was zero, all is OK, no reset needed */		bRet = true; /* If that was zero, all is OK, no reset needed */
	}		}
	}		}

	if (!bRet && bCanReset) /* If all not OK, then */		if (!bRet && bCanReset) { /* If all not OK, then */
	{
	dev_info(&pdx->interface->dev, "%s->Is1401 %d %d %d %d",		dev_info(&pdx->interface->dev, "%s->Is1401 %d %d %d %d",
	__func__, bShortTest, pdx->sCurrentState, bTestBuff,		__func__, bShortTest, pdx->sCurrentState, bTestBuff,
	pdx->bForceReset);		pdx->bForceReset);
	@@ -439,8 +430,7 @@ int GetChar(DEVICE_EXTENSION *pdx)
	SendChars(pdx); /* and send any buffered chars */		SendChars(pdx); /* and send any buffered chars */

	spin_lock_irq(&pdx->charInLock);		spin_lock_irq(&pdx->charInLock);
	if (pdx->dwNumInput > 0) /* worth looking */		if (pdx->dwNumInput > 0) { /* worth looking */
	{
	iReturn = pdx->inputBuffer[pdx->dwInBuffGet++];		iReturn = pdx->inputBuffer[pdx->dwInBuffGet++];
	if (pdx->dwInBuffGet >= INBUF_SZ)		if (pdx->dwInBuffGet >= INBUF_SZ)
	pdx->dwInBuffGet = 0;		pdx->dwInBuffGet = 0;
	@@ -482,8 +472,7 @@ int GetString(DEVICE_EXTENSION pdx, char __user pUser, int n)
	if (nAvailable > n) /* read max of space in pUser... */		if (nAvailable > n) /* read max of space in pUser... */
	nAvailable = n; /* ...or input characters */		nAvailable = n; /* ...or input characters */

	if (nAvailable > 0) /* worth looking? */		if (nAvailable > 0) { /* worth looking? */
	{
	char buffer[INBUF_SZ + 1]; /* space for a linear copy of data */		char buffer[INBUF_SZ + 1]; /* space for a linear copy of data */
	int nGot = 0;		int nGot = 0;
	int nCopyToUser; /* number to copy to user */		int nCopyToUser; /* number to copy to user */
	@@ -497,12 +486,10 @@ int GetString(DEVICE_EXTENSION pdx, char __user pUser, int n)
	pdx->dwInBuffGet = 0; /* wrap buffer pointer */		pdx->dwInBuffGet = 0; /* wrap buffer pointer */

	buffer[nGot++] = cData; /* save the output */		buffer[nGot++] = cData; /* save the output */
	}		} while ((nGot < nAvailable) && cData);
	while ((nGot < nAvailable) && cData);

	nCopyToUser = nGot; /* what to copy... */		nCopyToUser = nGot; /* what to copy... */
	if (cData) /* do we need null */		if (cData) { /* do we need null */
	{
	buffer[nGot] = (char)0; /* make it tidy */		buffer[nGot] = (char)0; /* make it tidy */
	if (nGot < n) /* if space in user buffer... */		if (nGot < n) /* if space in user buffer... */
	++nCopyToUser; /* ...copy the 0 as well. */		++nCopyToUser; /* ...copy the 0 as well. */
	@@ -556,8 +543,7 @@ int LineCount(DEVICE_EXTENSION *pdx)
	SendChars(pdx); /* and send any buffered chars */		SendChars(pdx); /* and send any buffered chars */
	spin_lock_irq(&pdx->charInLock); /* Get protection */		spin_lock_irq(&pdx->charInLock); /* Get protection */

	if (pdx->dwNumInput > 0) /* worth looking? */		if (pdx->dwNumInput > 0) { /* worth looking? */
	{
	unsigned int dwIndex = pdx->dwInBuffGet; /* start at first available */		unsigned int dwIndex = pdx->dwInBuffGet; /* start at first available */
	unsigned int dwEnd = pdx->dwInBuffPut; /* Position for search end */		unsigned int dwEnd = pdx->dwInBuffPut; /* Position for search end */
	do {		do {
	@@ -566,8 +552,7 @@ int LineCount(DEVICE_EXTENSION *pdx)

	if (dwIndex >= INBUF_SZ) /* see if we fall off buff */		if (dwIndex >= INBUF_SZ) /* see if we fall off buff */
	dwIndex = 0;		dwIndex = 0;
	}		} while (dwIndex != dwEnd); /* go to last available */
	while (dwIndex != dwEnd); /* go to last available */
	}		}

	spin_unlock_irq(&pdx->charInLock);		spin_unlock_irq(&pdx->charInLock);
	@@ -645,8 +630,7 @@ int ClearArea(DEVICE_EXTENSION *pdx, int nArea)
	}		}
	spin_unlock_irq(&pdx->stagedLock);		spin_unlock_irq(&pdx->stagedLock);

	if (pPages) /* if we decided to release the memory */		if (pPages) { /* if we decided to release the memory */
	{
	/* Now we must undo the pinning down of the pages. We will assume the worst and mark */		/* Now we must undo the pinning down of the pages. We will assume the worst and mark */
	/* all the pages as dirty. Don't be tempted to move this up above as you must not be */		/* all the pages as dirty. Don't be tempted to move this up above as you must not be */
	/* holding a spin lock to do this stuff as it is not atomic. */		/* holding a spin lock to do this stuff as it is not atomic. */
	@@ -714,8 +698,7 @@ static int SetArea(DEVICE_EXTENSION pdx, int nArea, char __user puBuf,
	up_read(&current->mm->mmap_sem); /* release the semaphore */		up_read(&current->mm->mmap_sem); /* release the semaphore */
	dev_dbg(&pdx->interface->dev, "%s nPages = %d", __func__, nPages);		dev_dbg(&pdx->interface->dev, "%s nPages = %d", __func__, nPages);

	if (nPages > 0) /* if we succeeded */		if (nPages > 0) { /* if we succeeded */
	{
	/* If you are tempted to use page_address (form LDD3), forget it. You MUST use */		/* If you are tempted to use page_address (form LDD3), forget it. You MUST use */
	/* kmap() or kmap_atomic() to get a virtual address. page_address will give you */		/* kmap() or kmap_atomic() to get a virtual address. page_address will give you */
	/* (null) or at least it does in this context with an x86 machine. */		/* (null) or at least it does in this context with an x86 machine. */
	@@ -814,8 +797,7 @@ int SetEvent(DEVICE_EXTENSION pdx, TRANSFEREVENT __user pTE)
	TRANSAREA *pTA = &pdx->rTransDef[te.wAreaNum];		TRANSAREA *pTA = &pdx->rTransDef[te.wAreaNum];
	mutex_lock(&pdx->io_mutex); /* make sure we have no competitor */		mutex_lock(&pdx->io_mutex); /* make sure we have no competitor */
	spin_lock_irq(&pdx->stagedLock);		spin_lock_irq(&pdx->stagedLock);
	if (pTA->bUsed) /* area must be in use */		if (pTA->bUsed) { /* area must be in use */
	{
	pTA->dwEventSt = te.dwStart; /* set area regions */		pTA->dwEventSt = te.dwStart; /* set area regions */
	pTA->dwEventSz = te.dwLength; /* set size (0 cancels it) */		pTA->dwEventSz = te.dwLength; /* set size (0 cancels it) */
	pTA->bEventToHost = te.wFlags & 1; /* set the direction */		pTA->bEventToHost = te.wFlags & 1; /* set the direction */
	@@ -1030,8 +1012,8 @@ int CheckSelfTest(DEVICE_EXTENSION pdx, TGET_SELFTEST __user pGST)
	if (iReturn == U14ERR_NOERROR) /* Only accept zero if it happens twice */		if (iReturn == U14ERR_NOERROR) /* Only accept zero if it happens twice */
	iReturn = Get1401State(pdx, &state, &error);		iReturn = Get1401State(pdx, &state, &error);

	if (iReturn != U14ERR_NOERROR) /* Self-test can cause comms errors */		if (iReturn != U14ERR_NOERROR) { /* Self-test can cause comms errors */
	{ /* so we assume still testing */		/* so we assume still testing */
	dev_err(&pdx->interface->dev,		dev_err(&pdx->interface->dev,
	"%s Get1401State=%d, assuming still testing", __func__,		"%s Get1401State=%d, assuming still testing", __func__,
	iReturn);		iReturn);
	@@ -1040,8 +1022,7 @@ int CheckSelfTest(DEVICE_EXTENSION pdx, TGET_SELFTEST __user pGST)
	iReturn = U14ERR_NOERROR;		iReturn = U14ERR_NOERROR;
	}		}

	if ((state == -1) && (error == -1)) /* If Get1401State had problems */		if ((state == -1) && (error == -1)) { /* If Get1401State had problems */
	{
	dev_err(&pdx->interface->dev,		dev_err(&pdx->interface->dev,
	"%s Get1401State failed, assuming still testing",		"%s Get1401State failed, assuming still testing",
	__func__);		__func__);
	@@ -1049,17 +1030,14 @@ int CheckSelfTest(DEVICE_EXTENSION pdx, TGET_SELFTEST __user pGST)
	error = 0;		error = 0;
	}		}

	if ((state & 0xFF) == 0x80) /* If we are still in self-test */		if ((state & 0xFF) == 0x80) { /* If we are still in self-test */
	{		if (state & 0x00FF0000) { /* Have we got an error? */
	if (state & 0x00FF0000) /* Have we got an error? */
	{
	gst.code = (state & 0x00FF0000) >> 16; /* read the error code */		gst.code = (state & 0x00FF0000) >> 16; /* read the error code */
	gst.x = error & 0x0000FFFF; /* Error data X */		gst.x = error & 0x0000FFFF; /* Error data X */
	gst.y = (error & 0xFFFF0000) >> 16; /* and data Y */		gst.y = (error & 0xFFFF0000) >> 16; /* and data Y */
	dev_dbg(&pdx->interface->dev, "Self-test error code %d",		dev_dbg(&pdx->interface->dev, "Self-test error code %d",
	gst.code);		gst.code);
	} else /* No error, check for timeout */		} else { /* No error, check for timeout */
	{
	unsigned long ulNow = jiffies; /* get current time */		unsigned long ulNow = jiffies; /* get current time */
	if (time_after(ulNow, pdx->ulSelfTestTime)) {		if (time_after(ulNow, pdx->ulSelfTestTime)) {
	gst.code = -2; /* Flag the timeout */		gst.code = -2; /* Flag the timeout */
	@@ -1074,8 +1052,8 @@ int CheckSelfTest(DEVICE_EXTENSION pdx, TGET_SELFTEST __user pGST)
	dev_dbg(&pdx->interface->dev, "Self-test done");		dev_dbg(&pdx->interface->dev, "Self-test done");
	}		}

	if (gst.code < 0) /* If we have a problem or finished */		if (gst.code < 0) { /* If we have a problem or finished */
	{ /* If using the 2890 we should reset properly */		/* If using the 2890 we should reset properly */
	if ((pdx->nPipes == 4) && (pdx->s1401Type <= TYPEPOWER))		if ((pdx->nPipes == 4) && (pdx->s1401Type <= TYPEPOWER))
	Is1401(pdx); /* Get 1401 reset and OK */		Is1401(pdx); /* Get 1401 reset and OK */
	else		else
	@@ -1384,16 +1362,13 @@ int GetCircBlock(DEVICE_EXTENSION pdx, TCIRCBLOCK __user pCB)
	cb.dwOffset = 0; /* set default result (nothing) */		cb.dwOffset = 0; /* set default result (nothing) */
	cb.dwSize = 0;		cb.dwSize = 0;

	if (nArea < MAX_TRANSAREAS) /* The area number must be OK */		if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */
	{
	TRANSAREA pArea = &pdx->rTransDef[nArea]; / Pointer to relevant info */		TRANSAREA pArea = &pdx->rTransDef[nArea]; / Pointer to relevant info */
	spin_lock_irq(&pdx->stagedLock); /* Lock others out */		spin_lock_irq(&pdx->stagedLock); /* Lock others out */

	if ((pArea->bUsed) && (pArea->bCircular) && /* Must be circular area */		if ((pArea->bUsed) && (pArea->bCircular) && /* Must be circular area */
	(pArea->bCircToHost)) /* For now at least must be to host */		(pArea->bCircToHost)) { /* For now at least must be to host */
	{		if (pArea->aBlocks[0].dwSize > 0) { /* Got anything? */
	if (pArea->aBlocks[0].dwSize > 0) /* Got anything? */
	{
	cb.dwOffset = pArea->aBlocks[0].dwOffset;		cb.dwOffset = pArea->aBlocks[0].dwOffset;
	cb.dwSize = pArea->aBlocks[0].dwSize;		cb.dwSize = pArea->aBlocks[0].dwSize;
	dev_dbg(&pdx->interface->dev,		dev_dbg(&pdx->interface->dev,
	@@ -1438,25 +1413,20 @@ int FreeCircBlock(DEVICE_EXTENSION pdx, TCIRCBLOCK __user pCB)
	cb.dwOffset = 0; /* then set default result (nothing) */		cb.dwOffset = 0; /* then set default result (nothing) */
	cb.dwSize = 0;		cb.dwSize = 0;

	if (nArea < MAX_TRANSAREAS) /* The area number must be OK */		if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */
	{
	TRANSAREA pArea = &pdx->rTransDef[nArea]; / Pointer to relevant info */		TRANSAREA pArea = &pdx->rTransDef[nArea]; / Pointer to relevant info */
	spin_lock_irq(&pdx->stagedLock); /* Lock others out */		spin_lock_irq(&pdx->stagedLock); /* Lock others out */

	if ((pArea->bUsed) && (pArea->bCircular) && /* Must be circular area */		if ((pArea->bUsed) && (pArea->bCircular) && /* Must be circular area */
	(pArea->bCircToHost)) /* For now at least must be to host */		(pArea->bCircToHost)) { /* For now at least must be to host */
	{
	bool bWaiting = false;		bool bWaiting = false;

	if ((pArea->aBlocks[0].dwSize >= uSize) && /* Got anything? */		if ((pArea->aBlocks[0].dwSize >= uSize) && /* Got anything? */
	(pArea->aBlocks[0].dwOffset == uStart)) /* Must be legal data */		(pArea->aBlocks[0].dwOffset == uStart)) { /* Must be legal data */
	{
	pArea->aBlocks[0].dwSize -= uSize;		pArea->aBlocks[0].dwSize -= uSize;
	pArea->aBlocks[0].dwOffset += uSize;		pArea->aBlocks[0].dwOffset += uSize;
	if (pArea->aBlocks[0].dwSize == 0) /* Have we emptied this block? */		if (pArea->aBlocks[0].dwSize == 0) { /* Have we emptied this block? */
	{		if (pArea->aBlocks[1].dwSize) { /* Is there a second block? */
	if (pArea->aBlocks[1].dwSize) /* Is there a second block? */
	{
	pArea->aBlocks[0] = pArea->aBlocks[1]; /* Copy down block 2 data */		pArea->aBlocks[0] = pArea->aBlocks[1]; /* Copy down block 2 data */
	pArea->aBlocks[1].dwSize = 0; /* and mark the second block as unused */		pArea->aBlocks[1].dwSize = 0; /* and mark the second block as unused */
	pArea->aBlocks[1].dwOffset = 0;		pArea->aBlocks[1].dwOffset = 0;
	@@ -1472,8 +1442,7 @@ int FreeCircBlock(DEVICE_EXTENSION pdx, TCIRCBLOCK __user pCB)
	pdx->bXFerWaiting);		pdx->bXFerWaiting);

	/* Return the next available block of memory as well */		/* Return the next available block of memory as well */
	if (pArea->aBlocks[0].dwSize > 0) /* Got anything? */		if (pArea->aBlocks[0].dwSize > 0) { /* Got anything? */
	{
	cb.dwOffset =		cb.dwOffset =
	pArea->aBlocks[0].dwOffset;		pArea->aBlocks[0].dwOffset;
	cb.dwSize = pArea->aBlocks[0].dwSize;		cb.dwSize = pArea->aBlocks[0].dwSize;
	@@ -1496,8 +1465,7 @@ int FreeCircBlock(DEVICE_EXTENSION pdx, TCIRCBLOCK __user pCB)
	}		}

	/* If we have one, kick off pending transfer */		/* If we have one, kick off pending transfer */
	if (bWaiting) /* Got a block xfer waiting? */		if (bWaiting) { /* Got a block xfer waiting? */
	{
	int RWMStat =		int RWMStat =
	ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard,		ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard,
	pdx->rDMAInfo.wIdent,		pdx->rDMAInfo.wIdent,

drivers/staging/ced1401/usb1401.c

+38 −63

Original line number	Original line	Diff line number	Diff line
	@@ -298,8 +298,7 @@ static void ced_writechar_callback(struct urb *pUrb)
	if (pdx->dwOutBuffGet >= OUTBUF_SZ) /* Can't do this any earlier as data could be overwritten */		if (pdx->dwOutBuffGet >= OUTBUF_SZ) /* Can't do this any earlier as data could be overwritten */
	pdx->dwOutBuffGet = 0;		pdx->dwOutBuffGet = 0;

	if (pdx->dwNumOutput > 0) /* if more to be done... */		if (pdx->dwNumOutput > 0) { /* if more to be done... */
	{
	int nPipe = 0; /* The pipe number to use */		int nPipe = 0; /* The pipe number to use */
	int iReturn;		int iReturn;
	char *pDat = &pdx->outputBuffer[pdx->dwOutBuffGet];		char *pDat = &pdx->outputBuffer[pdx->dwOutBuffGet];
	@@ -347,8 +346,7 @@ int SendChars(DEVICE_EXTENSION *pdx)

	if ((!pdx->bSendCharsPending) && /* Not currently sending */		if ((!pdx->bSendCharsPending) && /* Not currently sending */
	(pdx->dwNumOutput > 0) && /* has characters to output */		(pdx->dwNumOutput > 0) && /* has characters to output */
	(CanAcceptIoRequests(pdx))) /* and current activity is OK */		(CanAcceptIoRequests(pdx))) { /* and current activity is OK */
	{
	unsigned int dwCount = pdx->dwNumOutput; /* Get a copy of the character count */		unsigned int dwCount = pdx->dwNumOutput; /* Get a copy of the character count */
	pdx->bSendCharsPending = true; /* Set flag to lock out other threads */		pdx->bSendCharsPending = true; /* Set flag to lock out other threads */

	@@ -543,8 +541,7 @@ static void staged_callback(struct urb *pUrb)
	pdx->StagedDone, pdx->StagedLength);		pdx->StagedDone, pdx->StagedLength);

	if ((pdx->StagedDone == pdx->StagedLength) \|\| /* If no more to do */		if ((pdx->StagedDone == pdx->StagedLength) \|\| /* If no more to do */
	(bCancel)) /* or this IRP was cancelled */		(bCancel)) { /* or this IRP was cancelled */
	{
	TRANSAREA pArea = &pdx->rTransDef[pdx->StagedId]; / Transfer area info */		TRANSAREA pArea = &pdx->rTransDef[pdx->StagedId]; / Transfer area info */
	dev_dbg(&pdx->interface->dev,		dev_dbg(&pdx->interface->dev,
	"%s transfer done, bytes %d, cancel %d", __func__,		"%s transfer done, bytes %d, cancel %d", __func__,
	@@ -555,10 +552,8 @@ static void staged_callback(struct urb *pUrb)
	/* add this to the end of a growing block or to use it to start a new block unless the code */		/* add this to the end of a growing block or to use it to start a new block unless the code */
	/* that calculates the offset to use (in ReadWriteMem) is totally duff. */		/* that calculates the offset to use (in ReadWriteMem) is totally duff. */
	if ((pArea->bCircular) && (pArea->bCircToHost) && (!bCancel) && /* Time to sort out circular buffer info? */		if ((pArea->bCircular) && (pArea->bCircToHost) && (!bCancel) && /* Time to sort out circular buffer info? */
	(pdx->StagedRead)) /* Only for tohost transfers for now */		(pdx->StagedRead)) { /* Only for tohost transfers for now */
	{		if (pArea->aBlocks[1].dwSize > 0) { /* If block 1 is in use we must append to it */
	if (pArea->aBlocks[1].dwSize > 0) /* If block 1 is in use we must append to it */
	{
	if (pdx->StagedOffset ==		if (pdx->StagedOffset ==
	(pArea->aBlocks[1].dwOffset +		(pArea->aBlocks[1].dwOffset +
	pArea->aBlocks[1].dwSize)) {		pArea->aBlocks[1].dwSize)) {
	@@ -580,10 +575,9 @@ static void staged_callback(struct urb *pUrb)
	pArea->aBlocks[1].dwSize,		pArea->aBlocks[1].dwSize,
	pArea->aBlocks[1].dwOffset);		pArea->aBlocks[1].dwOffset);
	}		}
	} else /* If block 1 is not used, we try to add to block 0 */		} else { /* If block 1 is not used, we try to add to block 0 */
	{		if (pArea->aBlocks[0].dwSize > 0) { /* Got stored block 0 information? */
	if (pArea->aBlocks[0].dwSize > 0) /* Got stored block 0 information? */		/* Must append onto the existing block 0 */
	{ /* Must append onto the existing block 0 */
	if (pdx->StagedOffset ==		if (pdx->StagedOffset ==
	(pArea->aBlocks[0].dwOffset +		(pArea->aBlocks[0].dwOffset +
	pArea->aBlocks[0].dwSize)) {		pArea->aBlocks[0].dwSize)) {
	@@ -594,8 +588,7 @@ static void staged_callback(struct urb *pUrb)
	dwSize,		dwSize,
	pArea->aBlocks[0].		pArea->aBlocks[0].
	dwOffset);		dwOffset);
	} else /* If it doesn't append, put into new block 1 */		} else { /* If it doesn't append, put into new block 1 */
	{
	pArea->aBlocks[1].dwOffset =		pArea->aBlocks[1].dwOffset =
	pdx->StagedOffset;		pdx->StagedOffset;
	pArea->aBlocks[1].dwSize =		pArea->aBlocks[1].dwSize =
	@@ -607,8 +600,7 @@ static void staged_callback(struct urb *pUrb)
	pArea->aBlocks[1].		pArea->aBlocks[1].
	dwOffset);		dwOffset);
	}		}
	} else /* No info stored yet, just save in block 0 */		} else { /* No info stored yet, just save in block 0 */
	{
	pArea->aBlocks[0].dwOffset =		pArea->aBlocks[0].dwOffset =
	pdx->StagedOffset;		pdx->StagedOffset;
	pArea->aBlocks[0].dwSize =		pArea->aBlocks[0].dwSize =
	@@ -621,21 +613,19 @@ static void staged_callback(struct urb *pUrb)
	}		}
	}		}

	if (!bCancel) /* Don't generate an event if cancelled */		if (!bCancel) { /* Don't generate an event if cancelled */
	{
	dev_dbg(&pdx->interface->dev,		dev_dbg(&pdx->interface->dev,
	"RWM_Complete, bCircular %d, bToHost %d, eStart %d, eSize %d",		"RWM_Complete, bCircular %d, bToHost %d, eStart %d, eSize %d",
	pArea->bCircular, pArea->bEventToHost,		pArea->bCircular, pArea->bEventToHost,
	pArea->dwEventSt, pArea->dwEventSz);		pArea->dwEventSt, pArea->dwEventSz);
	if ((pArea->dwEventSz) && /* Set a user-mode event... */		if ((pArea->dwEventSz) && /* Set a user-mode event... */
	(pdx->StagedRead == pArea->bEventToHost)) /* ...on transfers in this direction? */		(pdx->StagedRead == pArea->bEventToHost)) { /* ...on transfers in this direction? */
	{
	int iWakeUp = 0; /* assume */		int iWakeUp = 0; /* assume */
	/* If we have completed the right sort of DMA transfer then set the event to notify */		/* If we have completed the right sort of DMA transfer then set the event to notify */
	/* the user code to wake up anyone that is waiting. */		/* the user code to wake up anyone that is waiting. */
	if ((pArea->bCircular) && /* Circular areas use a simpler test */		if ((pArea->bCircular) && /* Circular areas use a simpler test */
	(pArea->bCircToHost)) /* only in supported direction */		(pArea->bCircToHost)) { /* only in supported direction */
	{ /* Is total data waiting up to size limit? */		/* Is total data waiting up to size limit? */
	unsigned int dwTotal =		unsigned int dwTotal =
	pArea->aBlocks[0].dwSize +		pArea->aBlocks[0].dwSize +
	pArea->aBlocks[1].dwSize;		pArea->aBlocks[1].dwSize;
	@@ -661,11 +651,9 @@ static void staged_callback(struct urb *pUrb)

	pdx->dwDMAFlag = MODE_CHAR; /* Switch back to char mode before ReadWriteMem call */		pdx->dwDMAFlag = MODE_CHAR; /* Switch back to char mode before ReadWriteMem call */

	if (!bCancel) /* Don't look for waiting transfer if cancelled */		if (!bCancel) { /* Don't look for waiting transfer if cancelled */
	{
	/* If we have a transfer waiting, kick it off */		/* If we have a transfer waiting, kick it off */
	if (pdx->bXFerWaiting) /* Got a block xfer waiting? */		if (pdx->bXFerWaiting) { /* Got a block xfer waiting? */
	{
	int iReturn;		int iReturn;
	dev_info(&pdx->interface->dev,		dev_info(&pdx->interface->dev,
	"* RWM_Complete * pending transfer will now be set up!!!");		"* RWM_Complete * pending transfer will now be set up!!!");
	@@ -719,8 +707,7 @@ static int StageChunk(DEVICE_EXTENSION *pdx)
	if (nPipe < 0) /* and trap case that should never happen */		if (nPipe < 0) /* and trap case that should never happen */
	return U14ERR_FAIL;		return U14ERR_FAIL;

	if (!CanAcceptIoRequests(pdx)) /* got sudden remove? */		if (!CanAcceptIoRequests(pdx)) { /* got sudden remove? */
	{
	dev_info(&pdx->interface->dev, "%s sudden remove, giving up",		dev_info(&pdx->interface->dev, "%s sudden remove, giving up",
	__func__);		__func__);
	return U14ERR_FAIL; /* could do with a better error */		return U14ERR_FAIL; /* could do with a better error */
	@@ -777,8 +764,7 @@ int ReadWriteMem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent,
	{		{
	TRANSAREA pArea = &pdx->rTransDef[wIdent]; / Transfer area info */		TRANSAREA pArea = &pdx->rTransDef[wIdent]; / Transfer area info */

	if (!CanAcceptIoRequests(pdx)) /* Are we in a state to accept new requests? */		if (!CanAcceptIoRequests(pdx)) { /* Are we in a state to accept new requests? */
	{
	dev_err(&pdx->interface->dev, "%s can't accept requests",		dev_err(&pdx->interface->dev, "%s can't accept requests",
	__func__);		__func__);
	return U14ERR_FAIL;		return U14ERR_FAIL;
	@@ -798,36 +784,32 @@ int ReadWriteMem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent,
	return U14ERR_NOERROR;		return U14ERR_NOERROR;
	}		}

	if (dwLen == 0) /* allow 0-len read or write; just return success */		if (dwLen == 0) { /* allow 0-len read or write; just return success */
	{
	dev_dbg(&pdx->interface->dev,		dev_dbg(&pdx->interface->dev,
	"%s OK; zero-len read/write request", __func__);		"%s OK; zero-len read/write request", __func__);
	return U14ERR_NOERROR;		return U14ERR_NOERROR;
	}		}

	if ((pArea->bCircular) && /* Circular transfer? */		if ((pArea->bCircular) && /* Circular transfer? */
	(pArea->bCircToHost) && (Read)) /* In a supported direction */		(pArea->bCircToHost) && (Read)) { /* In a supported direction */
	{ /* If so, we sort out offset ourself */		/* If so, we sort out offset ourself */
	bool bWait = false; /* Flag for transfer having to wait */		bool bWait = false; /* Flag for transfer having to wait */

	dev_dbg(&pdx->interface->dev,		dev_dbg(&pdx->interface->dev,
	"Circular buffers are %d at %d and %d at %d",		"Circular buffers are %d at %d and %d at %d",
	pArea->aBlocks[0].dwSize, pArea->aBlocks[0].dwOffset,		pArea->aBlocks[0].dwSize, pArea->aBlocks[0].dwOffset,
	pArea->aBlocks[1].dwSize, pArea->aBlocks[1].dwOffset);		pArea->aBlocks[1].dwSize, pArea->aBlocks[1].dwOffset);
	if (pArea->aBlocks[1].dwSize > 0) /* Using the second block already? */		if (pArea->aBlocks[1].dwSize > 0) { /* Using the second block already? */
	{
	dwOffs = pArea->aBlocks[1].dwOffset + pArea->aBlocks[1].dwSize; /* take offset from that */		dwOffs = pArea->aBlocks[1].dwOffset + pArea->aBlocks[1].dwSize; /* take offset from that */
	bWait = (dwOffs + dwLen) > pArea->aBlocks[0].dwOffset; /* Wait if will overwrite block 0? */		bWait = (dwOffs + dwLen) > pArea->aBlocks[0].dwOffset; /* Wait if will overwrite block 0? */
	bWait \|= (dwOffs + dwLen) > pArea->dwLength; /* or if it overflows the buffer */		bWait \|= (dwOffs + dwLen) > pArea->dwLength; /* or if it overflows the buffer */
	} else /* Area 1 not in use, try to use area 0 */		} else { /* Area 1 not in use, try to use area 0 */
	{
	if (pArea->aBlocks[0].dwSize == 0) /* Reset block 0 if not in use */		if (pArea->aBlocks[0].dwSize == 0) /* Reset block 0 if not in use */
	pArea->aBlocks[0].dwOffset = 0;		pArea->aBlocks[0].dwOffset = 0;
	dwOffs =		dwOffs =
	pArea->aBlocks[0].dwOffset +		pArea->aBlocks[0].dwOffset +
	pArea->aBlocks[0].dwSize;		pArea->aBlocks[0].dwSize;
	if ((dwOffs + dwLen) > pArea->dwLength) /* Off the end of the buffer? */		if ((dwOffs + dwLen) > pArea->dwLength) { /* Off the end of the buffer? */
	{
	pArea->aBlocks[1].dwOffset = 0; /* Set up to use second block */		pArea->aBlocks[1].dwOffset = 0; /* Set up to use second block */
	dwOffs = 0;		dwOffs = 0;
	bWait = (dwOffs + dwLen) > pArea->aBlocks[0].dwOffset; /* Wait if will overwrite block 0? */		bWait = (dwOffs + dwLen) > pArea->aBlocks[0].dwOffset; /* Wait if will overwrite block 0? */
	@@ -835,8 +817,7 @@ int ReadWriteMem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent,
	}		}
	}		}

	if (bWait) /* This transfer will have to wait? */		if (bWait) { /* This transfer will have to wait? */
	{
	pdx->bXFerWaiting = true; /* Flag we are waiting */		pdx->bXFerWaiting = true; /* Flag we are waiting */
	dev_dbg(&pdx->interface->dev,		dev_dbg(&pdx->interface->dev,
	"%s xfer waiting for circular buffer space",		"%s xfer waiting for circular buffer space",
	@@ -877,8 +858,7 @@ static bool ReadChar(unsigned char pChar, char pBuf, unsigned int *pdDone,
	bool bRead = false;		bool bRead = false;
	unsigned int dDone = *pdDone;		unsigned int dDone = *pdDone;

	if (dDone < dGot) /* If there is more data */		if (dDone < dGot) { /* If there is more data */
	{
	pChar = (unsigned char)pBuf[dDone]; / Extract the next char */		pChar = (unsigned char)pBuf[dDone]; / Extract the next char */
	dDone++; /* Increment the done count */		dDone++; /* Increment the done count */
	*pdDone = dDone;		*pdDone = dDone;
	@@ -1057,13 +1037,12 @@ static int Handle1401Esc(DEVICE_EXTENSION pdx, char pCh,
	/* I have no idea what this next test is about. '?' is 0x3f, which is area 3, code */		/* I have no idea what this next test is about. '?' is 0x3f, which is area 3, code */
	/* 15. At the moment, this is not used, so it does no harm, but unless someone can */		/* 15. At the moment, this is not used, so it does no harm, but unless someone can */
	/* tell me what this is for, it should be removed from this and the Windows driver. */		/* tell me what this is for, it should be removed from this and the Windows driver. */
	if (pCh[0] == '?') /* Is this an information response */		if (pCh[0] == '?') { /* Is this an information response */
	{ /* Parse and save the information */		/* Parse and save the information */
	} else {		} else {
	spin_lock(&pdx->stagedLock); /* Lock others out */		spin_lock(&pdx->stagedLock); /* Lock others out */

	if (ReadDMAInfo(&pdx->rDMAInfo, pdx, pCh, dwCount)) /* Get DMA parameters */		if (ReadDMAInfo(&pdx->rDMAInfo, pdx, pCh, dwCount)) { /* Get DMA parameters */
	{
	unsigned short wTransType = pdx->rDMAInfo.wTransType; /* check transfer type */		unsigned short wTransType = pdx->rDMAInfo.wTransType; /* check transfer type */

	dev_dbg(&pdx->interface->dev,		dev_dbg(&pdx->interface->dev,
	@@ -1071,8 +1050,8 @@ static int Handle1401Esc(DEVICE_EXTENSION pdx, char pCh,
	pdx->rDMAInfo.bOutWard ? "1401" : "host",		pdx->rDMAInfo.bOutWard ? "1401" : "host",
	pdx->rDMAInfo.dwOffset, pdx->rDMAInfo.dwSize);		pdx->rDMAInfo.dwOffset, pdx->rDMAInfo.dwSize);

	if (pdx->bXFerWaiting) /* Check here for badly out of kilter... */		if (pdx->bXFerWaiting) { /* Check here for badly out of kilter... */
	{ /* This can never happen, really */		/* This can never happen, really */
	dev_err(&pdx->interface->dev,		dev_err(&pdx->interface->dev,
	"ERROR: DMA setup while transfer still waiting");		"ERROR: DMA setup while transfer still waiting");
	spin_unlock(&pdx->stagedLock);		spin_unlock(&pdx->stagedLock);
	@@ -1115,8 +1094,7 @@ static void ced_readchar_callback(struct urb *pUrb)
	DEVICE_EXTENSION *pdx = pUrb->context;		DEVICE_EXTENSION *pdx = pUrb->context;
	int nGot = pUrb->actual_length; /* what we transferred */		int nGot = pUrb->actual_length; /* what we transferred */

	if (pUrb->status) /* Do we have a problem to handle? */		if (pUrb->status) { /* Do we have a problem to handle? */
	{
	int nPipe = pdx->nPipes == 4 ? 1 : 0; /* The pipe number to use for error */		int nPipe = pdx->nPipes == 4 ? 1 : 0; /* The pipe number to use for error */
	/* sync/async unlink faults aren't errors... just saying device removed or stopped */		/* sync/async unlink faults aren't errors... just saying device removed or stopped */
	if (!		if (!
	@@ -1138,8 +1116,7 @@ static void ced_readchar_callback(struct urb *pUrb)
	spin_lock(&pdx->charInLock); /* already at irq level */		spin_lock(&pdx->charInLock); /* already at irq level */
	pdx->bPipeError[nPipe] = 1; /* Flag an error for later */		pdx->bPipeError[nPipe] = 1; /* Flag an error for later */
	} else {		} else {
	if ((nGot > 1) && ((pdx->pCoherCharIn[0] & 0x7f) == 0x1b)) /* Esc sequence? */		if ((nGot > 1) && ((pdx->pCoherCharIn[0] & 0x7f) == 0x1b)) { /* Esc sequence? */
	{
	Handle1401Esc(pdx, &pdx->pCoherCharIn[1], nGot - 1); /* handle it */		Handle1401Esc(pdx, &pdx->pCoherCharIn[1], nGot - 1); /* handle it */
	spin_lock(&pdx->charInLock); /* already at irq level */		spin_lock(&pdx->charInLock); /* already at irq level */
	} else {		} else {
	@@ -1197,8 +1174,8 @@ int Allowi(DEVICE_EXTENSION *pdx)
	(pdx->dwNumInput < (INBUF_SZ / 2)) && /* and there is some space */		(pdx->dwNumInput < (INBUF_SZ / 2)) && /* and there is some space */
	(pdx->dwDMAFlag == MODE_CHAR) && /* not doing any DMA */		(pdx->dwDMAFlag == MODE_CHAR) && /* not doing any DMA */
	(!pdx->bXFerWaiting) && /* no xfer waiting to start */		(!pdx->bXFerWaiting) && /* no xfer waiting to start */
	(CanAcceptIoRequests(pdx))) /* and activity is generally OK */		(CanAcceptIoRequests(pdx))) { /* and activity is generally OK */
	{ /* then off we go */		/* then off we go */
	unsigned int nMax = INBUF_SZ - pdx->dwNumInput; /* max we could read */		unsigned int nMax = INBUF_SZ - pdx->dwNumInput; /* max we could read */
	int nPipe = pdx->nPipes == 4 ? 1 : 0; /* The pipe number to use */		int nPipe = pdx->nPipes == 4 ? 1 : 0; /* The pipe number to use */

	@@ -1394,8 +1371,7 @@ static int ced_probe(struct usb_interface *interface,
	if (!pdx)		if (!pdx)
	goto error;		goto error;

	for (i = 0; i < MAX_TRANSAREAS; ++i) /* Initialise the wait queues */		for (i = 0; i < MAX_TRANSAREAS; ++i) { /* Initialise the wait queues */
	{
	init_waitqueue_head(&pdx->rTransDef[i].wqEvent);		init_waitqueue_head(&pdx->rTransDef[i].wqEvent);
	}		}

	@@ -1471,8 +1447,7 @@ static int ced_probe(struct usb_interface *interface,
	pdx->bInterval);		pdx->bInterval);
	}		}
	/* Detect USB2 by checking last ep size (64 if USB1) */		/* Detect USB2 by checking last ep size (64 if USB1) */
	if (i == pdx->nPipes - 1) /* if this is the last ep (bulk) */		if (i == pdx->nPipes - 1) { /* if this is the last ep (bulk) */
	{
	pdx->bIsUSB2 =		pdx->bIsUSB2 =
	le16_to_cpu(endpoint->wMaxPacketSize) > 64;		le16_to_cpu(endpoint->wMaxPacketSize) > 64;
	dev_info(&pdx->interface->dev, "USB%d",		dev_info(&pdx->interface->dev, "USB%d",

drivers/staging/ced1401/usb1401.h

+4 −8

drivers/staging/ced1401/use14_ioc.h

+1 −2

Original line number	Original line	Diff line number	Diff line
	@@ -269,8 +269,7 @@ typedef union /* to communicate with 1401 driver status & control funcs */

	typedef TCSBLOCK* LPTCSBLOCK;		typedef TCSBLOCK* LPTCSBLOCK;

	typedef struct paramBlk		typedef struct paramBlk {
	{
	short sState;		short sState;
	TCSBLOCK csBlock;		TCSBLOCK csBlock;
	} PARAMBLK;		} PARAMBLK;