Fixed checkpatch.pl issues and removed redundant comment in ced_ioc.cs
Signed-off-by: Pol Eyschen <poleysc...@gmail.com>
---
drivers/staging/ced1401/ced_ioc.c | 483 +++++++++++++++++++++----------------
1 file changed, 271 insertions(+), 212 deletions(-)
diff --git a/drivers/staging/ced1401/ced_ioc.c
b/drivers/staging/ced1401/ced_ioc.c
index bf532b1..94a361d 100644
--- a/drivers/staging/ced1401/ced_ioc.c
+++ b/drivers/staging/ced1401/ced_ioc.c
@@ -40,8 +40,8 @@ static void FlushOutBuff(DEVICE_EXTENSION *pdx)
{
dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__,
pdx->sCurrentState);
- if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in
trouble */
- return;
+ if (pdx->sCurrentState == U14ERR_TIME)
+ return; /* Do nothing if hardware in trouble */
/* Kill off any pending I/O */
/* CharSend_Cancel(pdx); */
spin_lock_irq(&pdx->charOutLock);
@@ -61,8 +61,8 @@ static void FlushInBuff(DEVICE_EXTENSION *pdx)
{
dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__,
pdx->sCurrentState);
- if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in
trouble */
- return;
+ if (pdx->sCurrentState == U14ERR_TIME)
+ return; /* Do nothing if hardware in trouble */
/* Kill off any pending I/O */
/* CharRead_Cancel(pDevObject); */
spin_lock_irq(&pdx->charInLock);
@@ -82,7 +82,7 @@ static int PutChars(DEVICE_EXTENSION *pdx, const char *pCh,
unsigned int uCount)
{
int iReturn;
- spin_lock_irq(&pdx->charOutLock); /* get the output spin lock */
+ spin_lock_irq(&pdx->charOutLock); /* get the output spin lock */
if ((OUTBUF_SZ - pdx->dwNumOutput) >= uCount) {
unsigned int u;
for (u = 0; u < uCount; u++) {
@@ -92,9 +92,10 @@ static int PutChars(DEVICE_EXTENSION *pdx, const char *pCh,
}
pdx->dwNumOutput += uCount;
spin_unlock_irq(&pdx->charOutLock);
- iReturn = SendChars(pdx); /* ...give a chance to
transmit data */
+ /* give a chance to transmit data */
+ iReturn = SendChars(pdx);
} else {
- iReturn = U14ERR_NOOUT; /* no room at the out (ha-ha) */
+ iReturn = U14ERR_NOOUT; /* no room at the out (ha-ha) */
spin_unlock_irq(&pdx->charOutLock);
}
return iReturn;
@@ -108,16 +109,17 @@ static int PutChars(DEVICE_EXTENSION *pdx, const char
*pCh,
int SendString(DEVICE_EXTENSION *pdx, const char __user *pData,
unsigned int n)
{
- int iReturn = U14ERR_NOERROR; /* assume all will be well */
- char buffer[OUTBUF_SZ + 1]; /* space in our address space for
characters */
- if (n > OUTBUF_SZ) /* check space in local buffer... */
- return U14ERR_NOOUT; /* ...too many characters */
+ int iReturn = U14ERR_NOERROR;
+ /* space in our address space for characters */
+ char buffer[OUTBUF_SZ + 1];
+ if (n > OUTBUF_SZ)
+ return U14ERR_NOOUT;
if (copy_from_user(buffer, pData, n))
return -EFAULT;
buffer[n] = 0; /* terminate for debug purposes */
mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
- if (n > 0) { /* do nothing if nowt to do! */
+ if (n > 0) {
dev_dbg(&pdx->interface->dev, "%s n=%d>%s<", __func__, n,
buffer);
iReturn = PutChars(pdx, buffer, n);
@@ -183,7 +185,7 @@ int Get1401State(DEVICE_EXTENSION *pdx, __u32 *state, __u32
*error)
if (nGot != sizeof(pdx->statBuf)) {
dev_err(&pdx->interface->dev,
"Get1401State() FAILED, return code %d", nGot);
- pdx->sCurrentState = U14ERR_TIME; /* Indicate that
things are very wrong indeed */
+ pdx->sCurrentState = U14ERR_TIME;
*state = 0; /* Force status values to a known state */
*error = 0;
} else {
@@ -192,16 +194,20 @@ int Get1401State(DEVICE_EXTENSION *pdx, __u32 *state,
__u32 *error)
"Get1401State() Success, state: 0x%x, 0x%x",
pdx->statBuf[0], pdx->statBuf[1]);
- *state = pdx->statBuf[0]; /* Return the state values to
the calling code */
+ /* Return the state values to the calling code */
+ *state = pdx->statBuf[0];
*error = pdx->statBuf[1];
- nDevice = pdx->udev->descriptor.bcdDevice >> 8; /* 1401 type
code value */
- switch (nDevice) { /* so we can clean up current state */
+ /* 1401 type code value */
+ nDevice = pdx->udev->descriptor.bcdDevice >> 8;
+ /* so we can clean up current state */
+ switch (nDevice) {
case 0:
pdx->sCurrentState = U14ERR_U1401;
break;
- default: /* allow lots of device codes for future 1401s
*/
+ default:
+ /* allow lots of device codes for future 1401s */
if ((nDevice >= 1) && (nDevice <= 23))
pdx->sCurrentState = (short)(nDevice + 6);
else
@@ -226,23 +232,29 @@ int ReadWrite_Cancel(DEVICE_EXTENSION *pdx)
int ntStatus = STATUS_SUCCESS;
bool bResult = false;
unsigned int i;
- /* 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);
- if (pdx->bStagedUrbPending) { /* anything to be cancelled? May need
more... */
+ if (pdx->bStagedUrbPending) {
dev_info(&pdx->interface - dev,
"ReadWrite_Cancel about to cancel Urb");
/* Clear the staging done flag */
/* KeClearEvent(&pdx->StagingDoneEvent); */
USB_ASSERT(pdx->pStagedIrp != NULL);
- /* Release the spinlock first otherwise the completion routine
may hang */
- /* on the spinlock while this function hands waiting for the
event. */
+ /* Release the spinlock first otherwise the completion routine
+ * may hang on the spinlock while this function hands waiting
+ * for the event
+ */
spin_unlock_irq(&pdx->stagedLock);
- bResult = IoCancelIrp(pdx->pStagedIrp); /* Actually do the
cancel */
+ /* Actually do the cancel */
+ bResult = IoCancelIrp(pdx->pStagedIrp);
if (bResult) {
LARGE_INTEGER timeout;
- timeout.QuadPart = -10000000; /* Use a timeout of 1
second */
+ /* Use a timeout of 1 sec */
+ timeout.QuadPart = -10000000;
dev_info(&pdx->interface - dev,
"ReadWrite_Cancel about to wait till done");
ntStatus =
@@ -275,10 +287,10 @@ int ReadWrite_Cancel(DEVICE_EXTENSION *pdx)
static int InSelfTest(DEVICE_EXTENSION *pdx, unsigned int *pState)
{
unsigned int state, error;
- int iReturn = Get1401State(pdx, &state, &error); /* see if in
self-test */
- if (iReturn == U14ERR_NOERROR) /* if all still OK */
- iReturn = (state == (unsigned int)-1) || /* TX problem
or... */
- ((state & 0xff) == 0x80); /* ...self test */
+ int iReturn = Get1401State(pdx, &state, &error);
+ if (iReturn == U14ERR_NOERROR)
+ iReturn = (state == (unsigned int)-1) || /* TX Error */
+ ((state & 0xff) == 0x80);
*pState = state; /* return actual state */
return iReturn;
}
@@ -310,33 +322,36 @@ bool Is1401(DEVICE_EXTENSION *pdx)
FlushInBuff(pdx); /* Clear out input buffer & pipe */
FlushOutBuff(pdx); /* Clear output buffer & pipe */
- /* The next call returns 0 if OK, but has returned 1 in the past,
meaning that */
- /* usb_unlock_device() is needed... now it always is */
+ /* The next call returns 0 if OK, but has returned 1 in the past,
+ * meaning that usb_unlock_device() is needed... now it always is.
+ */
iReturn = usb_lock_device_for_reset(pdx->udev, pdx->interface);
- /* release the io_mutex because if we don't, we will deadlock due to
system */
- /* calls back into the driver. */
- mutex_unlock(&pdx->io_mutex); /* locked, so we will not get system
calls */
- if (iReturn >= 0) { /* if we failed */
- iReturn = usb_reset_device(pdx->udev); /* try to do the reset
*/
+ /* release the io_mutex because if we don't, we will deadlock due to
+ * system calls back into the driver.
+ */
+ mutex_unlock(&pdx->io_mutex); /* locked, to hold offt system calls */
+ if (iReturn >= 0) {
+ iReturn = usb_reset_device(pdx->udev);
usb_unlock_device(pdx->udev); /* undo the lock */
}
mutex_lock(&pdx->io_mutex); /* hold stuff off while we wait */
pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flag regardless! */
- if (iReturn == 0) { /* if all is OK still */
+ if (iReturn == 0) {
unsigned int state;
- iReturn = InSelfTest(pdx, &state); /* see if likely in
self test */
- if (iReturn > 0) { /* do we need to wait for self-test? */
- unsigned long ulTimeOut = jiffies + 30 * HZ; /*
when to give up */
- while ((iReturn > 0) && time_before(jiffies,
ulTimeOut)) {
+ iReturn = InSelfTest(pdx, &state);
+ if (iReturn > 0) {
+ unsigned long ulTimeOut = jiffies + 30 * HZ;
+ while ((iReturn > 0) &&
+ time_before(jiffies, ulTimeOut)) {
schedule(); /* let other stuff run */
- iReturn = InSelfTest(pdx, &state); /* see
if done yet */
+ iReturn = InSelfTest(pdx, &state);
}
}
- if (iReturn == 0) /* if all is OK... */
- iReturn = state == 0; /* then success is that the
state is 0 */
+ if (iReturn == 0)
+ iReturn = state == 0;
} else
iReturn = 0; /* we failed */
pdx->bForceReset = false; /* Clear forced reset flag now */
@@ -363,37 +378,38 @@ bool QuickCheck(DEVICE_EXTENSION *pdx, bool bTestBuff,
bool bCanReset)
bool bRet = false; /* assume it will fail and we will reset */
bool bShortTest;
- bShortTest = ((pdx->dwDMAFlag == MODE_CHAR) && /* no DMA running */
- (!pdx->bForceReset) && /* Not had a real reset forced
*/
- (pdx->sCurrentState >= U14ERR_STD)); /* No 1401
errors stored */
+ /* No DMA, no reset forced, no 1401 errors */
+ bShortTest = ((pdx->dwDMAFlag == MODE_CHAR) &&
+ (!pdx->bForceReset) &&
+ (pdx->sCurrentState >= U14ERR_STD));
dev_dbg(&pdx->interface->dev,
"%s DMAFlag:%d, state:%d, force:%d, testBuff:%d, short:%d",
__func__, pdx->dwDMAFlag, pdx->sCurrentState, pdx->bForceReset,
bTestBuff, bShortTest);
- if ((bTestBuff) && /* Buffer check requested, and... */
- (pdx->dwNumInput || pdx->dwNumOutput)) { /* ...characters were
in the buffer? */
- bShortTest = false; /* Then do the full test */
+ if ((bTestBuff) &&
+ (pdx->dwNumInput || pdx->dwNumOutput)) {
+ bShortTest = false;
dev_dbg(&pdx->interface->dev,
"%s will reset as buffers not empty", __func__);
}
- if (bShortTest || !bCanReset) { /* Still OK to try the short test? */
- /* Always test if no reset - we want state
update */
+ if (bShortTest || !bCanReset) {
+ /* If we cannot reset, get a state update */
unsigned int state, error;
dev_dbg(&pdx->interface->dev, "%s->Get1401State", __func__);
- if (Get1401State(pdx, &state, &error) == U14ERR_NOERROR) {
/* Check on the 1401 state */
- if ((state & 0xFF) == 0) /* If call worked,
check the status value */
- bRet = true; /* If that was zero, all is
OK, no reset needed */
+ if (Get1401State(pdx, &state, &error) == U14ERR_NOERROR) {
+ if ((state & 0xFF) == 0)
+ bRet = true;
}
}
- if (!bRet && bCanReset) { /* If all not OK, then */
+ if (!bRet && bCanReset) {
dev_info(&pdx->interface->dev, "%s->Is1401 %d %d %d %d",
__func__, bShortTest, pdx->sCurrentState, bTestBuff,
pdx->bForceReset);
- bRet = Is1401(pdx); /* do full test */
+ bRet = Is1401(pdx); /* do full test */
}
return bRet;
@@ -406,9 +422,9 @@ bool QuickCheck(DEVICE_EXTENSION *pdx, bool bTestBuff, bool
bCanReset)
*****************************************************************************/
int Reset1401(DEVICE_EXTENSION *pdx)
{
- mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "ABout to call QuickCheck");
- QuickCheck(pdx, true, true); /* Check 1401, reset if not OK */
+ QuickCheck(pdx, true, true);
mutex_unlock(&pdx->io_mutex);
return U14ERR_NOERROR;
}
@@ -421,7 +437,7 @@ int Reset1401(DEVICE_EXTENSION *pdx)
int GetChar(DEVICE_EXTENSION *pdx)
{
int iReturn = U14ERR_NOIN; /* assume we will get nothing */
- mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "GetChar");
@@ -429,7 +445,7 @@ int GetChar(DEVICE_EXTENSION *pdx)
SendChars(pdx); /* and send any buffered chars */
spin_lock_irq(&pdx->charInLock);
- if (pdx->dwNumInput > 0) { /* worth looking */
+ if (pdx->dwNumInput > 0) {
iReturn = pdx->inputBuffer[pdx->dwInBuffGet++];
if (pdx->dwInBuffGet >= INBUF_SZ)
pdx->dwInBuffGet = 0;
@@ -440,7 +456,7 @@ int GetChar(DEVICE_EXTENSION *pdx)
Allowi(pdx); /* Make sure char reads are running */
- mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_unlock(&pdx->io_mutex);
return iReturn;
}
@@ -462,19 +478,19 @@ int GetString(DEVICE_EXTENSION *pdx, char __user *pUser,
int n)
if (n <= 0)
return -ENOMEM;
- mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_lock(&pdx->io_mutex);
Allowi(pdx); /* Make sure char reads are running */
- SendChars(pdx); /* and send any buffered chars */
+ SendChars(pdx); /* and send any buffered chars */
spin_lock_irq(&pdx->charInLock);
- nAvailable = pdx->dwNumInput; /* characters available now */
- if (nAvailable > n) /* read max of space in pUser... */
- nAvailable = n; /* ...or input characters */
+ nAvailable = pdx->dwNumInput;
+ if (nAvailable > n)
+ nAvailable = n; /* read at most the space of pUser */
- if (nAvailable > 0) { /* worth looking? */
- char buffer[INBUF_SZ + 1]; /* space for a linear copy of
data */
+ if (nAvailable > 0) {
+ char buffer[INBUF_SZ + 1];
int nGot = 0;
- int nCopyToUser; /* number to copy to user */
+ int nCopyToUser; /* number to copy to user */
char cData;
do {
cData = pdx->inputBuffer[pdx->dwInBuffGet++];
@@ -482,16 +498,18 @@ int GetString(DEVICE_EXTENSION *pdx, char __user *pUser,
int n)
cData = (char)0;
if (pdx->dwInBuffGet >= INBUF_SZ)
- pdx->dwInBuffGet = 0; /* wrap buffer pointer
*/
+ pdx->dwInBuffGet = 0;
- buffer[nGot++] = cData; /* save the output */
+ buffer[nGot++] = cData;
} while ((nGot < nAvailable) && cData);
- nCopyToUser = nGot; /* what to copy... */
- if (cData) { /* do we need null */
+ nCopyToUser = nGot;
+ if (cData) {
buffer[nGot] = (char)0; /* make it tidy */
- if (nGot < n) /* if space in user buffer... */
- ++nCopyToUser; /* ...copy the 0 as well. */
+ if (nGot < n) {
+ /* if space in pUser, copy 0 as well */
+ ++nCopyToUser;
+ }
}
pdx->dwNumInput -= nGot;
@@ -502,12 +520,12 @@ int GetString(DEVICE_EXTENSION *pdx, char __user *pUser,
int n)
if (copy_to_user(pUser, buffer, nCopyToUser))
iReturn = -EFAULT;
else
- iReturn = nGot; /* report characters read */
+ iReturn = nGot;
} else
spin_unlock_irq(&pdx->charInLock);
Allowi(pdx); /* Make sure char reads are running */
- mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_unlock(&pdx->io_mutex);
return iReturn;
}
@@ -518,11 +536,11 @@ int GetString(DEVICE_EXTENSION *pdx, char __user *pUser,
int n)
int Stat1401(DEVICE_EXTENSION *pdx)
{
int iReturn;
- mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_lock(&pdx->io_mutex);
Allowi(pdx); /* make sure we allow pending chars */
SendChars(pdx); /* in both directions */
iReturn = pdx->dwNumInput; /* no lock as single read */
- mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_unlock(&pdx->io_mutex);
return iReturn;
}
@@ -535,28 +553,28 @@ int Stat1401(DEVICE_EXTENSION *pdx)
****************************************************************************/
int LineCount(DEVICE_EXTENSION *pdx)
{
- int iReturn = 0; /* will be count of line ends */
+ int iReturn = 0;
- mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_lock(&pdx->io_mutex);
Allowi(pdx); /* Make sure char reads are running */
SendChars(pdx); /* and send any buffered chars */
spin_lock_irq(&pdx->charInLock); /* Get protection */
if (pdx->dwNumInput > 0) { /* worth looking? */
- unsigned int dwIndex = pdx->dwInBuffGet; /* start at
first available */
- unsigned int dwEnd = pdx->dwInBuffPut; /* Position for search
end */
+ unsigned int dwIndex = pdx->dwInBuffGet;
+ unsigned int dwEnd = pdx->dwInBuffPut;
do {
if (pdx->inputBuffer[dwIndex++] == CR_CHAR)
- ++iReturn; /* inc count if CR */
+ ++iReturn;
- if (dwIndex >= INBUF_SZ) /* see if we fall off
buff */
+ if (dwIndex >= INBUF_SZ)
dwIndex = 0;
- } while (dwIndex != dwEnd); /* go to last available */
+ } while (dwIndex != dwEnd);
}
spin_unlock_irq(&pdx->charInLock);
dev_dbg(&pdx->interface->dev, "LineCount returned %d", iReturn);
- mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_unlock(&pdx->io_mutex);
return iReturn;
}
@@ -568,11 +586,11 @@ int LineCount(DEVICE_EXTENSION *pdx)
int GetOutBufSpace(DEVICE_EXTENSION *pdx)
{
int iReturn;
- mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_lock(&pdx->io_mutex);
SendChars(pdx); /* send any buffered chars */
- iReturn = (int)(OUTBUF_SZ - pdx->dwNumOutput); /* no lock needed for
single read */
+ iReturn = (int)(OUTBUF_SZ - pdx->dwNumOutput);
dev_dbg(&pdx->interface->dev, "OutBufSpace %d", iReturn);
- mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
+ mutex_unlock(&pdx->io_mutex);
return iReturn;
}
@@ -592,12 +610,13 @@ int ClearArea(DEVICE_EXTENSION *pdx, int nArea)
dev_err(&pdx->interface->dev, "%s Attempt to clear area %d",
__func__, nArea);
} else {
- TRANSAREA *pTA = &pdx->rTransDef[nArea]; /* to save
typing */
- if (!pTA->bUsed) /* if not used... */
- iReturn = U14ERR_NOTSET; /* ...nothing to be
done */
+ TRANSAREA *pTA = &pdx->rTransDef[nArea];
+ if (!pTA->bUsed)
+ iReturn = U14ERR_NOTSET;
else {
- /* We must save the memory we return as we shouldn't
mess with memory while */
- /* holding a spin lock. */
+ /* We must save the memory we return as we shouldn't
+ * mess with memory while holding a spin lock.
+ */
struct page **pPages = NULL; /*save page address list*/
int nPages = 0; /* and number of pages */
int np;
@@ -607,32 +626,42 @@ int ClearArea(DEVICE_EXTENSION *pdx, int nArea)
spin_lock_irq(&pdx->stagedLock);
if ((pdx->StagedId == nArea)
&& (pdx->dwDMAFlag > MODE_CHAR)) {
- iReturn = U14ERR_UNLOCKFAIL; /* cannot
delete as in use */
+ iReturn = U14ERR_UNLOCKFAIL;
dev_err(&pdx->interface->dev,
"%s call on area %d while active",
__func__, nArea);
} else {
- pPages = pTA->pPages; /* save page address
list */
- nPages = pTA->nPages; /* and page count */
- if (pTA->dwEventSz) /* if events flagging
in use */
- wake_up_interruptible(&pTA->wqEvent);
/* release anything that was waiting */
+ /* save page address list and page count */
+ pPages = pTA->pPages;
+ nPages = pTA->nPages;
+ if (pTA->dwEventSz)
+ wake_up_interruptible(&pTA->wqEvent);
if (pdx->bXFerWaiting
- && (pdx->rDMAInfo.wIdent == nArea))
- pdx->bXFerWaiting = false; /*
Cannot have pending xfer if area cleared */
+ && (pdx->rDMAInfo.wIdent == nArea)) {
+ /* no pending xfer if area cleared */
+ pdx->bXFerWaiting = false;
+ }
- /* Clean out the TRANSAREA except for the wait
queue, which is at the end */
- /* This sets bUsed to false and dwEventSz to 0
to say area not used and no events. */
+ /* Clean out the TRANSAREA except for the wait
+ * queue, which is at the end. This sets bUsed
+ * to false and dwEventSz to 0 to say area not
+ * used and no events.
+ */
memset(pTA, 0,
sizeof(TRANSAREA) -
sizeof(wait_queue_head_t));
}
spin_unlock_irq(&pdx->stagedLock);
- 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 */
- /* 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. */
+ if (pPages) {
+ /* 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
+ * holding a spin lock to do this stuff as it
+ * is not atomic.
+ */
dev_dbg(&pdx->interface->dev, "%s nPages=%d",
__func__, nPages);
@@ -662,26 +691,28 @@ int ClearArea(DEVICE_EXTENSION *pdx, int nArea)
static int SetArea(DEVICE_EXTENSION *pdx, int nArea, char __user *puBuf,
unsigned int dwLength, bool bCircular, bool bCircToHost)
{
- /* Start by working out the page aligned start of the area and the
size */
- /* of the area in pages, allowing for the start not being aligned and
the */
- /* end needing to be rounded up to a page boundary. */
+ /* Start by working out the page aligned start of the area and the size
+ * of the area in pages, allowing for the start not being aligned and
+ * the end needing to be rounded up to a page boundary.
+ */
unsigned long ulStart = ((unsigned long)puBuf) & PAGE_MASK;
unsigned int ulOffset = ((unsigned long)puBuf) & (PAGE_SIZE - 1);
int len = (dwLength + ulOffset + PAGE_SIZE - 1) >> PAGE_SHIFT;
- TRANSAREA *pTA = &pdx->rTransDef[nArea]; /* to save typing */
+ TRANSAREA *pTA = &pdx->rTransDef[nArea];
struct page **pPages = NULL; /* space for page tables */
int nPages = 0; /* and number of pages */
- int iReturn = ClearArea(pdx, nArea); /* see if OK to use this area
*/
- if ((iReturn != U14ERR_NOTSET) && /* if not area unused and... */
- (iReturn != U14ERR_NOERROR)) /* ...not all OK, then... */
- return iReturn; /* ...we cannot use this area */
+ int iReturn = ClearArea(pdx, nArea);
+ if ((iReturn != U14ERR_NOTSET) && (iReturn != U14ERR_NOERROR))
+ return iReturn; /* exit if area used and there was an error */
- if (!access_ok(VERIFY_WRITE, puBuf, dwLength)) /* if we cannot access
the memory... */
- return -EFAULT; /* ...then we are done */
+ if (!access_ok(VERIFY_WRITE, puBuf, dwLength))
+ return -EFAULT; /* exit if memory not accessible */
- /* Now allocate space to hold the page pointer and virtual address
pointer tables */
+ /* Now allocate space to hold the page pointer and virtual
+ * address pointer tables.
+ */
pPages = kmalloc(len * sizeof(struct page *), GFP_KERNEL);
if (!pPages) {
iReturn = U14ERR_NOMEMORY;
@@ -690,19 +721,24 @@ static int SetArea(DEVICE_EXTENSION *pdx, int nArea, char
__user *puBuf,
dev_dbg(&pdx->interface->dev, "%s %p, length=%06x, circular %d",
__func__, puBuf, dwLength, bCircular);
- /* To pin down user pages we must first acquire the mapping semaphore.
*/
+ /* To pin down user pages we must first acquire the mapping semaphore */
nPages = get_user_pages_fast(ulStart, len, 1, pPages);
dev_dbg(&pdx->interface->dev, "%s nPages = %d", __func__, nPages);
- if (nPages > 0) { /* if we succeeded */
- /* 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 */
- /* (null) or at least it does in this context with an x86
machine. */
+ if (nPages > 0) {
+ /* 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 (null) or at least it
+ * does in this context with an x86 machine.
+ */
spin_lock_irq(&pdx->stagedLock);
- pTA->lpvBuff = puBuf; /* keep start of region (user address)
*/
- pTA->dwBaseOffset = ulOffset; /* save offset in first page
to start of xfer */
- pTA->dwLength = dwLength; /* Size if the region in bytes
*/
- pTA->pPages = pPages; /* list of pages that are used by
buffer */
+ /* keep start of region (user address) */
+ pTA->lpvBuff = puBuf;
+ /* save offset in first page to start of xfer */
+ pTA->dwBaseOffset = ulOffset;
+ pTA->dwLength = dwLength;
+ /* list of pages that are used by buffer */
+ pTA->pPages = pPages;
pTA->nPages = nPages; /* number of pages */
pTA->bCircular = bCircular;
@@ -715,7 +751,7 @@ static int SetArea(DEVICE_EXTENSION *pdx, int nArea, char
__user *puBuf,
pTA->bUsed = true; /* This is now a used block */
spin_unlock_irq(&pdx->stagedLock);
- iReturn = U14ERR_NOERROR; /* say all was well */
+ iReturn = U14ERR_NOERROR;
} else {
iReturn = U14ERR_LOCKFAIL;
goto error;
@@ -746,9 +782,12 @@ int SetTransfer(DEVICE_EXTENSION *pdx, TRANSFERDESC __user
*pTD)
mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s area:%d, size:%08x", __func__,
td.wAreaNum, td.dwLength);
- /* The strange cast is done so that we don't get warnings in 32-bit
linux about the size of the */
- /* pointer. The pointer is always passed as a 64-bit object so that we
don't have problems using */
- /* a 32-bit program on a 64-bit system. unsigned long is 64-bits on a
64-bit system. */
+ /* The strange cast is done so that we don't get warnings in 32-bit
+ * linux about the size of the pointer. The pointer is always passed
+ * as a 64-bit object so that we don't have problems using a 32-bit
+ * program on a 64-bit system. unsigned long is 64-bits on a 64-bit
+ * system.
+ */
iReturn =
SetArea(pdx, td.wAreaNum,
(char __user *)((unsigned long)td.lpvBuff), td.dwLength,
@@ -787,17 +826,18 @@ int SetEvent(DEVICE_EXTENSION *pdx, TRANSFEREVENT __user
*pTE)
if (copy_from_user(&te, pTE, sizeof(te)))
return -EFAULT;
- if (te.wAreaNum >= MAX_TRANSAREAS) /* the area must exist */
+ /* the area must exist */
+ if (te.wAreaNum >= MAX_TRANSAREAS)
return U14ERR_BADAREA;
else {
TRANSAREA *pTA = &pdx->rTransDef[te.wAreaNum];
- mutex_lock(&pdx->io_mutex); /* make sure we have no
competitor */
+ mutex_lock(&pdx->io_mutex);
spin_lock_irq(&pdx->stagedLock);
- if (pTA->bUsed) { /* area must be in use */
- pTA->dwEventSt = te.dwStart; /* set area regions */
- pTA->dwEventSz = te.dwLength; /* set size (0 cancels
it) */
- pTA->bEventToHost = te.wFlags & 1; /* set the
direction */
- pTA->iWakeUp = 0; /* zero the wake up count */
+ if (pTA->bUsed) {
+ pTA->dwEventSt = te.dwStart;
+ pTA->dwEventSz = te.dwLength;
+ pTA->bEventToHost = te.wFlags & 1;
+ pTA->iWakeUp = 0;
} else
iReturn = U14ERR_NOTSET;
spin_unlock_irq(&pdx->stagedLock);
@@ -821,15 +861,18 @@ int WaitEvent(DEVICE_EXTENSION *pdx, int nArea, int
msTimeOut)
else {
int iWait;
TRANSAREA *pTA = &pdx->rTransDef[nArea];
- msTimeOut = (msTimeOut * HZ + 999) / 1000; /* convert
timeout to jiffies */
-
- /* We cannot wait holding the mutex, but we check the flags
while holding */
- /* it. This may well be pointless as another thread could get
in between */
- /* releasing it and the wait call. However, this would have to
clear the */
- /* iWakeUp flag. However, the !pTA-bUsed may help us in this
case. */
- mutex_lock(&pdx->io_mutex); /* make sure we have no
competitor */
- if (!pTA->bUsed || !pTA->dwEventSz) /* check something to
wait for... */
- return U14ERR_NOTSET; /* ...else we do nothing */
+ /* convert timeout to jiffies */
+ msTimeOut = (msTimeOut * HZ + 999) / 1000;
+
+ /* We cannot wait holding the mutex, but we check the flags
+ * while holding it. This may well be pointless as another
+ * thread could get in between releasing it and the wait call.
+ * However, this would have to clear the iWakeUp flag.
+ * However, the !pTA-bUsed may help us in this case.
+ */
+ mutex_lock(&pdx->io_mutex);
+ if (!pTA->bUsed || !pTA->dwEventSz)
+ return U14ERR_NOTSET;
mutex_unlock(&pdx->io_mutex);
if (msTimeOut)
@@ -843,12 +886,12 @@ int WaitEvent(DEVICE_EXTENSION *pdx, int nArea, int
msTimeOut)
wait_event_interruptible(pTA->wqEvent, pTA->iWakeUp
|| !pTA->bUsed);
if (iWait)
- iReturn = -ERESTARTSYS; /* oops - we have had a SIGNAL
*/
+ iReturn = -ERESTARTSYS; /* oops - we've had a SIGNAL */
else
- iReturn = pTA->iWakeUp; /* else the wakeup count */
+ iReturn = pTA->iWakeUp;
spin_lock_irq(&pdx->stagedLock);
- pTA->iWakeUp = 0; /* clear the flag */
+ pTA->iWakeUp = 0;
spin_unlock_irq(&pdx->stagedLock);
}
return iReturn;
@@ -867,10 +910,10 @@ int TestEvent(DEVICE_EXTENSION *pdx, int nArea)
iReturn = U14ERR_BADAREA;
else {
TRANSAREA *pTA = &pdx->rTransDef[nArea];
- mutex_lock(&pdx->io_mutex); /* make sure we have no
competitor */
+ mutex_lock(&pdx->io_mutex);
spin_lock_irq(&pdx->stagedLock);
- iReturn = pTA->iWakeUp; /* get wakeup count since last call */
- pTA->iWakeUp = 0; /* clear the count */
+ iReturn = pTA->iWakeUp;
+ pTA->iWakeUp = 0;
spin_unlock_irq(&pdx->stagedLock);
mutex_unlock(&pdx->io_mutex);
}
@@ -891,7 +934,9 @@ int GetTransfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user
*pTX)
if (dwIdent >= MAX_TRANSAREAS)
iReturn = U14ERR_BADAREA;
else {
- /* Return the best information we have - we don't have
physical addresses */
+ /* Return the best information we
+ * have - we don't have physical addresses.
+ */
TGET_TX_BLOCK *tx;
tx = kzalloc(sizeof(*tx), GFP_KERNEL);
@@ -901,8 +946,8 @@ int GetTransfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user
*pTX)
}
tx->size = pdx->rTransDef[dwIdent].dwLength;
tx->linear = (long long)((long)pdx->rTransDef[dwIdent].lpvBuff);
- tx->avail = GET_TX_MAXENTRIES; /* how many blocks we could
return */
- tx->used = 1; /* number we actually return */
+ tx->avail = GET_TX_MAXENTRIES;
+ tx->used = 1; /* number of blocks we actually return */
tx->entries[0].physical =
(long long)(tx->linear + pdx->StagedOffset);
tx->entries[0].size = tx->size;
@@ -974,8 +1019,8 @@ int StartSelfTest(DEVICE_EXTENSION *pdx)
dev_dbg(&pdx->interface->dev, "%s", __func__);
ced_draw_down(pdx); /* wait for, then kill outstanding Urbs */
- FlushInBuff(pdx); /* Clear out input buffer & pipe */
- FlushOutBuff(pdx); /* Clear output buffer & pipe */
+ FlushInBuff(pdx);
+ FlushOutBuff(pdx);
/* so things stay tidy */
/* ReadWrite_Cancel(pDeviceObject); */
pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flags here */
@@ -983,7 +1028,7 @@ int StartSelfTest(DEVICE_EXTENSION *pdx)
nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0),
DB_SELFTEST, (H_TO_D | VENDOR | DEVREQ),
0, 0, NULL, 0, HZ); /* allow 1 second timeout */
- pdx->ulSelfTestTime = jiffies + HZ * 30; /* 30 seconds into the
future */
+ pdx->ulSelfTestTime = jiffies + HZ * 30;
mutex_unlock(&pdx->io_mutex);
if (nGot < 0)
@@ -1001,17 +1046,19 @@ int CheckSelfTest(DEVICE_EXTENSION *pdx, TGET_SELFTEST
__user *pGST)
unsigned int state, error;
int iReturn;
TGET_SELFTEST gst; /* local work space */
- memset(&gst, 0, sizeof(gst)); /* clear out the space (sets code 0) */
+ memset(&gst, 0, sizeof(gst));
mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s", __func__);
iReturn = Get1401State(pdx, &state, &error);
- if (iReturn == U14ERR_NOERROR) /* Only accept zero if it happens
twice */
+ if (iReturn == U14ERR_NOERROR)
iReturn = Get1401State(pdx, &state, &error);
- if (iReturn != U14ERR_NOERROR) { /* Self-test can cause comms
errors */
- /* so we assume still testing */
+ if (iReturn != U14ERR_NOERROR) {
+ /* self test can cause communication errors so we assume
+ * still testing.
+ */
dev_err(&pdx->interface->dev,
"%s Get1401State=%d, assuming still testing", __func__,
iReturn);
@@ -1020,25 +1067,27 @@ int CheckSelfTest(DEVICE_EXTENSION *pdx, TGET_SELFTEST
__user *pGST)
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,
"%s Get1401State failed, assuming still testing",
__func__);
- state = 0x80; /* Force still-testing, no error */
+ state = 0x80;
error = 0;
}
- if ((state & 0xFF) == 0x80) { /* If we are still in self-test */
- if (state & 0x00FF0000) { /* Have we got an error? */
- gst.code = (state & 0x00FF0000) >> 16; /* read the
error code */
- gst.x = error & 0x0000FFFF; /* Error data X */
- gst.y = (error & 0xFFFF0000) >> 16; /* and data Y
*/
+ if ((state & 0xFF) == 0x80)
+ if (state & 0x00FF0000) {
+ /* read and set error code and data */
+ gst.code = (state & 0x00FF0000) >> 16;
+ gst.x = error & 0x0000FFFF;
+ gst.y = (error & 0xFFFF0000) >> 16;
dev_dbg(&pdx->interface->dev, "Self-test error code %d",
gst.code);
- } else { /* No error, check for timeout */
- unsigned long ulNow = jiffies; /* get current time */
+ } else {
+ unsigned long ulNow = jiffies;
if (time_after(ulNow, pdx->ulSelfTestTime)) {
- gst.code = -2; /* Flag the timeout */
+ gst.code = -2;
dev_dbg(&pdx->interface->dev,
"Self-test timed-out");
} else
@@ -1046,16 +1095,17 @@ int CheckSelfTest(DEVICE_EXTENSION *pdx, TGET_SELFTEST
__user *pGST)
"Self-test on-going");
}
} else {
- gst.code = -1; /* Flag the test is done */
+ gst.code = -1;
dev_dbg(&pdx->interface->dev, "Self-test done");
}
- if (gst.code < 0) { /* If we have a problem or finished */
- /* If using the 2890 we should reset properly
*/
+ /* If timeout or test done */
+ if (gst.code < 0) {
+ /* If using the 2890 we should reset properly */
if ((pdx->nPipes == 4) && (pdx->s1401Type <= TYPEPOWER))
- Is1401(pdx); /* Get 1401 reset and OK */
+ Is1401(pdx);
else
- QuickCheck(pdx, true, true); /* Otherwise check
without reset unless problems */
+ QuickCheck(pdx, true, true);
}
mutex_unlock(&pdx->io_mutex);
@@ -1079,7 +1129,7 @@ int TypeOf1401(DEVICE_EXTENSION *pdx)
switch (pdx->s1401Type) {
case TYPE1401:
iReturn = U14ERR_STD;
- break; /* Handle these types directly */
+ break;
case TYPEPLUS:
iReturn = U14ERR_PLUS;
break;
@@ -1088,9 +1138,9 @@ int TypeOf1401(DEVICE_EXTENSION *pdx)
break;
default:
if ((pdx->s1401Type >= TYPEPOWER) && (pdx->s1401Type <= 25))
- iReturn = pdx->s1401Type + 4; /* We can calculate
types */
- else /* for up-coming 1401 designs */
- iReturn = TYPEUNKNOWN; /* Don't know or not there */
+ iReturn = pdx->s1401Type + 4; /* calculate types */
+ else
+ iReturn = TYPEUNKNOWN;
}
dev_dbg(&pdx->interface->dev, "%s %d", __func__, iReturn);
mutex_unlock(&pdx->io_mutex);
@@ -1105,11 +1155,11 @@ int TypeOf1401(DEVICE_EXTENSION *pdx)
****************************************************************************/
int TransferFlags(DEVICE_EXTENSION *pdx)
{
- int iReturn = U14TF_MULTIA | U14TF_DIAG | /* we always have
multiple DMA area */
- U14TF_NOTIFY | U14TF_CIRCTH; /* diagnostics, notify and
circular */
+ int iReturn = U14TF_MULTIA | U14TF_DIAG |
+ U14TF_NOTIFY | U14TF_CIRCTH;
dev_dbg(&pdx->interface->dev, "%s", __func__);
mutex_lock(&pdx->io_mutex);
- if (pdx->bIsUSB2) /* Set flag for USB2 if appropriate */
+ if (pdx->bIsUSB2)
iReturn |= U14TF_USB2;
mutex_unlock(&pdx->io_mutex);
@@ -1198,8 +1248,9 @@ int DbgPoke(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB)
/****************************************************************************
** DbgRampData
**
-** Execute the diagnostic ramp data operation. Parameters are in the CSBLOCK
struct
-** in order address, default, enable mask, size and repeats.
+** Execute the diagnostic ramp data operation.
+** Parameters are in the CSBLOCK struct in order address, default, enable mask,
+** size and repeats.
****************************************************************************/
int DbgRampData(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB)
{
@@ -1267,7 +1318,7 @@ int DbgGetData(DEVICE_EXTENSION *pdx, TDBGBLOCK __user
*pDB)
{
int iReturn;
TDBGBLOCK db;
- memset(&db, 0, sizeof(db)); /* fill returned block with 0s */
+ memset(&db, 0, sizeof(db));
mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s", __func__);
@@ -1331,9 +1382,12 @@ int SetCircular(DEVICE_EXTENSION *pdx, TRANSFERDESC
__user *pTD)
td.wAreaNum, td.dwLength);
bToHost = td.eSize != 0; /* this is used as the tohost flag */
- /* The strange cast is done so that we don't get warnings in 32-bit
linux about the size of the */
- /* pointer. The pointer is always passed as a 64-bit object so that we
don't have problems using */
- /* a 32-bit program on a 64-bit system. unsigned long is 64-bits on a
64-bit system. */
+ /* The strange cast is done so that we don't get warnings in 32-bit
+ * linux about the size of the pointer. The pointer is always passed
+ * as a 64-bit object so that we don't have problems using a 32-bit
+ * program on a 64-bit system. unsigned long is 64-bits on a 64-bit
+ * system.
+ */
iReturn =
SetArea(pdx, td.wAreaNum,
(char __user *)((unsigned long)td.lpvBuff), td.dwLength,
@@ -1364,13 +1418,13 @@ int GetCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK
__user *pCB)
cb.dwOffset = 0; /* set default result (nothing) */
cb.dwSize = 0;
- if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */
- TRANSAREA *pArea = &pdx->rTransDef[nArea]; /* Pointer to
relevant info */
- spin_lock_irq(&pdx->stagedLock); /* Lock others out */
+ if (nArea < MAX_TRANSAREAS) {
+ TRANSAREA *pArea = &pdx->rTransDef[nArea];
+ spin_lock_irq(&pdx->stagedLock);
- if ((pArea->bUsed) && (pArea->bCircular) && /* Must be
circular area */
- (pArea->bCircToHost)) { /* For now at least must be to
host */
- if (pArea->aBlocks[0].dwSize > 0) { /* Got
anything? */
+ if ((pArea->bUsed) && (pArea->bCircular) &&
+ (pArea->bCircToHost)) {
+ if (pArea->aBlocks[0].dwSize > 0) {
cb.dwOffset = pArea->aBlocks[0].dwOffset;
cb.dwSize = pArea->aBlocks[0].dwSize;
dev_dbg(&pdx->interface->dev,
@@ -1415,22 +1469,23 @@ int FreeCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK
__user *pCB)
cb.dwOffset = 0; /* then set default result (nothing) */
cb.dwSize = 0;
- if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */
- TRANSAREA *pArea = &pdx->rTransDef[nArea]; /* Pointer to
relevant info */
- spin_lock_irq(&pdx->stagedLock); /* Lock others out */
+ if (nArea < MAX_TRANSAREAS) {
+ TRANSAREA *pArea = &pdx->rTransDef[nArea];
+ spin_lock_irq(&pdx->stagedLock);
- if ((pArea->bUsed) && (pArea->bCircular) && /* Must be
circular area */
- (pArea->bCircToHost)) { /* For now at least must be to
host */
+ if ((pArea->bUsed) && (pArea->bCircular) &&
+ (pArea->bCircToHost)) {
bool bWaiting = false;
- if ((pArea->aBlocks[0].dwSize >= uSize) && /* Got
anything? */
- (pArea->aBlocks[0].dwOffset == uStart)) { /*
Must be legal data */
+ if ((pArea->aBlocks[0].dwSize >= uSize) &&
+ (pArea->aBlocks[0].dwOffset == uStart)) {
pArea->aBlocks[0].dwSize -= uSize;
pArea->aBlocks[0].dwOffset += uSize;
- if (pArea->aBlocks[0].dwSize == 0) { /*
Have we emptied this block? */
- if (pArea->aBlocks[1].dwSize) { /* Is
there a second block? */
- pArea->aBlocks[0] =
pArea->aBlocks[1]; /* Copy down block 2 data */
- pArea->aBlocks[1].dwSize = 0;
/* and mark the second block as unused */
+ if (pArea->aBlocks[0].dwSize == 0) {
+ if (pArea->aBlocks[1].dwSize) {
+ pArea->aBlocks[0] =
+ pArea->aBlocks[1];
+ pArea->aBlocks[1].dwSize = 0;
pArea->aBlocks[1].dwOffset = 0;
} else
pArea->aBlocks[0].dwOffset = 0;
@@ -1443,8 +1498,10 @@ int FreeCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK
__user *pCB)
pArea->aBlocks[0].dwOffset,
pdx->bXFerWaiting);
- /* Return the next available block of memory
as well */
- if (pArea->aBlocks[0].dwSize > 0) { /* Got
anything? */
+ /* Return the next available block of
+ * memory as well
+ */
+ if (pArea->aBlocks[0].dwSize > 0) {
cb.dwOffset =
pArea->aBlocks[0].dwOffset;
cb.dwSize = pArea->aBlocks[0].dwSize;
@@ -1466,8 +1523,10 @@ int FreeCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK
__user *pCB)
iReturn = U14ERR_NOMEMORY;
}
- /* If we have one, kick off pending transfer */
- if (bWaiting) { /* Got a block xfer waiting? */
+ /* If we have one block xfer wating,
+ * kick off pending transfer
+ */
+ if (bWaiting) {
int RWMStat =
ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard,
pdx->rDMAInfo.wIdent,
--
1.7.10.4
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
