From e4837704c5bcdade4773fd1cd32f5986a1efd544 Mon Sep 17 00:00:00 2001 From: Elena Ufimtseva Date: Wed, 15 May 2013 12:57:15 -0400 Subject: [PATCH] Staging: ced1401: Fixes C99 // comments. Patch fixes checkpatch warnings about C99 // comments. Signed-off-by: Elena Ufimtseva Signed-off-by: Greg Kroah-Hartman --- drivers/staging/ced1401/ced_ioc.c | 537 +++++++++++++++++----------------- drivers/staging/ced1401/machine.h | 2 +- drivers/staging/ced1401/usb1401.c | 568 ++++++++++++++++++------------------ drivers/staging/ced1401/usb1401.h | 185 ++++++------ drivers/staging/ced1401/use1401.h | 42 +-- drivers/staging/ced1401/use14_ioc.h | 4 +- 6 files changed, 671 insertions(+), 667 deletions(-) diff --git a/drivers/staging/ced1401/ced_ioc.c b/drivers/staging/ced1401/ced_ioc.c index 3ed378fb6ce3..9ad42578f0f8 100644 --- a/drivers/staging/ced1401/ced_ioc.c +++ b/drivers/staging/ced1401/ced_ioc.c @@ -43,7 +43,8 @@ void FlushOutBuff(DEVICE_EXTENSION *pdx) pdx->sCurrentState); if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ return; -// CharSend_Cancel(pdx); /* Kill off any pending I/O */ + /* Kill off any pending I/O */ + /* CharSend_Cancel(pdx); */ spin_lock_irq(&pdx->charOutLock); pdx->dwNumOutput = 0; pdx->dwOutBuffGet = 0; @@ -63,7 +64,8 @@ void FlushInBuff(DEVICE_EXTENSION *pdx) pdx->sCurrentState); if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ return; -// CharRead_Cancel(pDevObject); /* Kill off any pending I/O */ + /* Kill off any pending I/O */ + /* CharRead_Cancel(pDevObject); */ spin_lock_irq(&pdx->charInLock); pdx->dwNumInput = 0; pdx->dwInBuffGet = 0; @@ -81,7 +83,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++) { @@ -91,9 +93,9 @@ 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 + iReturn = SendChars(pdx); /* ...give a chance to transmit data */ } 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; @@ -107,23 +109,23 @@ 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; /* 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 */ if (copy_from_user(buffer, pData, n)) return -EFAULT; - 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 - if (n > 0) // do nothing if nowt to do! + mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + if (n > 0) /* do nothing if nowt to do! */ { dev_dbg(&pdx->interface->dev, "%s n=%d>%s<", __func__, n, buffer); iReturn = PutChars(pdx, buffer, n); } - Allowi(pdx); // make sure we have input int + Allowi(pdx); /* make sure we have input int */ mutex_unlock(&pdx->io_mutex); return iReturn; @@ -137,10 +139,10 @@ int SendString(DEVICE_EXTENSION *pdx, const char __user *pData, int SendChar(DEVICE_EXTENSION *pdx, char c) { int iReturn; - mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o + mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ iReturn = PutChars(pdx, &c, 1); dev_dbg(&pdx->interface->dev, "SendChar >%c< (0x%02x)", c, c); - Allowi(pdx); // Make sure char reads are running + Allowi(pdx); /* Make sure char reads are running */ mutex_unlock(&pdx->io_mutex); return iReturn; } @@ -176,15 +178,15 @@ int Get1401State(DEVICE_EXTENSION *pdx, __u32 *state, __u32 *error) int nGot; dev_dbg(&pdx->interface->dev, "Get1401State() entry"); - *state = 0xFFFFFFFF; // Start off with invalid state + *state = 0xFFFFFFFF; /* Start off with invalid state */ nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), GET_STATUS, (D_TO_H | VENDOR | DEVREQ), 0, 0, pdx->statBuf, sizeof(pdx->statBuf), HZ); 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 - *state = 0; // Force status values to a known state + pdx->sCurrentState = U14ERR_TIME; /* Indicate that things are very wrong indeed */ + *state = 0; /* Force status values to a known state */ *error = 0; } else { int nDevice; @@ -192,17 +194,17 @@ 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 + *state = pdx->statBuf[0]; /* Return the state values to the calling code */ *error = pdx->statBuf[1]; - nDevice = pdx->udev->descriptor.bcdDevice >> 8; // 1401 type code value - switch (nDevice) // so we can clean up current state + nDevice = pdx->udev->descriptor.bcdDevice >> 8; /* 1401 type code value */ + switch (nDevice) /* so we can clean up current state */ { 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 @@ -227,24 +229,24 @@ 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) /* anything to be cancelled? May need more... */ { dev_info(&pdx->interface - dev, "ReadWrite_Cancel about to cancel Urb"); - - // KeClearEvent(&pdx->StagingDoneEvent); // Clear the staging done flag + /* 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 + bResult = IoCancelIrp(pdx->pStagedIrp); /* Actually do the cancel */ if (bResult) { LARGE_INTEGER timeout; - timeout.QuadPart = -10000000; // Use a timeout of 1 second + timeout.QuadPart = -10000000; /* Use a timeout of 1 second */ dev_info(&pdx->interface - dev, "ReadWrite_Cancel about to wait till done"); ntStatus = @@ -277,11 +279,11 @@ 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 - *pState = state; // return actual state + 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 */ + *pState = state; /* return actual state */ return iReturn; } @@ -308,43 +310,43 @@ bool Is1401(DEVICE_EXTENSION *pdx) int iReturn; 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 + ced_draw_down(pdx); /* wait for, then kill outstanding Urbs */ + 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 + /* 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 - usb_unlock_device(pdx->udev); // undo the lock + iReturn = usb_reset_device(pdx->udev); /* try to do the reset */ + 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 + 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 */ { unsigned int state; - iReturn = InSelfTest(pdx, &state); // see if likely in self test - if (iReturn > 0) // do we need to wait for self-test? + 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 + unsigned long ulTimeOut = jiffies + 30 * HZ; /* when to give up */ while ((iReturn > 0) && time_before(jiffies, ulTimeOut)) { - schedule(); // let other stuff run - iReturn = InSelfTest(pdx, &state); // see if done yet + schedule(); /* let other stuff run */ + iReturn = InSelfTest(pdx, &state); /* see if done yet */ } } - if (iReturn == 0) // if all is OK... - iReturn = state == 0; // then success is that the state is 0 + if (iReturn == 0) /* if all is OK... */ + iReturn = state == 0; /* then success is that the state is 0 */ } else - iReturn = 0; // we failed - pdx->bForceReset = false; // Clear forced reset flag now + iReturn = 0; /* we failed */ + pdx->bForceReset = false; /* Clear forced reset flag now */ return iReturn > 0; } @@ -365,43 +367,43 @@ bool Is1401(DEVICE_EXTENSION *pdx) */ bool QuickCheck(DEVICE_EXTENSION *pdx, bool bTestBuff, bool bCanReset) { - bool bRet = false; // assume it will fail and we will reset + 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 + bShortTest = ((pdx->dwDMAFlag == MODE_CHAR) && /* no DMA running */ + (!pdx->bForceReset) && /* Not had a real reset forced */ + (pdx->sCurrentState >= U14ERR_STD)); /* No 1401 errors stored */ 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? + if ((bTestBuff) && /* Buffer check requested, and... */ + (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, "%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) /* Still OK to try the short test? */ + { /* Always test if no reset - we want 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 (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 ((state & 0xFF) == 0) /* If call worked, check the status value */ + 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", __func__, bShortTest, pdx->sCurrentState, bTestBuff, pdx->bForceReset); - bRet = Is1401(pdx); // do full test + bRet = Is1401(pdx); /* do full test */ } return bRet; @@ -414,9 +416,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); /* Protect disconnect from new i/o */ dev_dbg(&pdx->interface->dev, "ABout to call QuickCheck"); - QuickCheck(pdx, true, true); // Check 1401, reset if not OK + QuickCheck(pdx, true, true); /* Check 1401, reset if not OK */ mutex_unlock(&pdx->io_mutex); return U14ERR_NOERROR; } @@ -428,28 +430,28 @@ 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 + int iReturn = U14ERR_NOIN; /* assume we will get nothing */ + mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ dev_dbg(&pdx->interface->dev, "GetChar"); - Allowi(pdx); // Make sure char reads are running - SendChars(pdx); // and send any buffered chars + Allowi(pdx); /* Make sure char reads are running */ + SendChars(pdx); /* and send any buffered chars */ spin_lock_irq(&pdx->charInLock); - if (pdx->dwNumInput > 0) // worth looking + if (pdx->dwNumInput > 0) /* worth looking */ { iReturn = pdx->inputBuffer[pdx->dwInBuffGet++]; if (pdx->dwInBuffGet >= INBUF_SZ) pdx->dwInBuffGet = 0; pdx->dwNumInput--; } else - iReturn = U14ERR_NOIN; // no input data to read + iReturn = U14ERR_NOIN; /* no input data to read */ spin_unlock_irq(&pdx->charInLock); - Allowi(pdx); // Make sure char reads are running + Allowi(pdx); /* Make sure char reads are running */ - mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o + mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */ return iReturn; } @@ -466,44 +468,44 @@ int GetChar(DEVICE_EXTENSION *pdx) ****************************************************************************/ int GetString(DEVICE_EXTENSION *pdx, char __user *pUser, int n) { - int nAvailable; // character in the buffer + int nAvailable; /* character in the buffer */ int iReturn = U14ERR_NOIN; if (n <= 0) return -ENOMEM; - mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o - Allowi(pdx); // Make sure char reads are running - SendChars(pdx); // and send any buffered chars + mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + Allowi(pdx); /* Make sure char reads are running */ + 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; /* characters available now */ + if (nAvailable > n) /* read max of space in pUser... */ + 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 nCopyToUser; // number to copy to user + int nCopyToUser; /* number to copy to user */ char cData; do { cData = pdx->inputBuffer[pdx->dwInBuffGet++]; - if (cData == CR_CHAR) // replace CR with zero + if (cData == CR_CHAR) /* replace CR with zero */ cData = (char)0; if (pdx->dwInBuffGet >= INBUF_SZ) - 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); - nCopyToUser = nGot; // what to copy... - if (cData) // do we need null + nCopyToUser = nGot; /* what to copy... */ + if (cData) /* do we need null */ { - buffer[nGot] = (char)0; // make it tidy - if (nGot < n) // if space in user buffer... - ++nCopyToUser; // ...copy the 0 as well. + buffer[nGot] = (char)0; /* make it tidy */ + if (nGot < n) /* if space in user buffer... */ + ++nCopyToUser; /* ...copy the 0 as well. */ } pdx->dwNumInput -= nGot; @@ -514,12 +516,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; /* report characters read */ } 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 + Allowi(pdx); /* Make sure char reads are running */ + mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */ return iReturn; } @@ -530,11 +532,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 - 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_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + 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 */ return iReturn; } @@ -547,30 +549,30 @@ int Stat1401(DEVICE_EXTENSION *pdx) ****************************************************************************/ int LineCount(DEVICE_EXTENSION *pdx) { - int iReturn = 0; // will be count of line ends + int iReturn = 0; /* will be count of line ends */ - mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o - Allowi(pdx); // Make sure char reads are running - SendChars(pdx); // and send any buffered chars - spin_lock_irq(&pdx->charInLock); // Get protection + mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + 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? + 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; /* start at first available */ + unsigned int dwEnd = pdx->dwInBuffPut; /* Position for search end */ do { if (pdx->inputBuffer[dwIndex++] == CR_CHAR) - ++iReturn; // inc count if CR + ++iReturn; /* inc count if CR */ - if (dwIndex >= INBUF_SZ) // see if we fall off buff + if (dwIndex >= INBUF_SZ) /* see if we fall off buff */ dwIndex = 0; } - while (dwIndex != dwEnd); // go to last available + while (dwIndex != dwEnd); /* go to last available */ } 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); /* Protect disconnect from new i/o */ return iReturn; } @@ -582,11 +584,11 @@ int LineCount(DEVICE_EXTENSION *pdx) int GetOutBufSpace(DEVICE_EXTENSION *pdx) { int iReturn; - mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o - SendChars(pdx); // send any buffered chars - iReturn = (int)(OUTBUF_SZ - pdx->dwNumOutput); // no lock needed for single read + mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + SendChars(pdx); /* send any buffered chars */ + iReturn = (int)(OUTBUF_SZ - pdx->dwNumOutput); /* no lock needed for single read */ dev_dbg(&pdx->interface->dev, "OutBufSpace %d", iReturn); - mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o + mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */ return iReturn; } @@ -606,14 +608,14 @@ 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]; /* to save typing */ + if (!pTA->bUsed) /* if not used... */ + iReturn = U14ERR_NOTSET; /* ...nothing to be done */ else { - // We must save the memory we return as we shouldn't mess with memory while - // holding a spin lock. - struct page **pPages = 0; // save page address list - int nPages = 0; // and number of pages + /* We must save the memory we return as we shouldn't mess with memory while */ + /* holding a spin lock. */ + struct page **pPages = 0; /* save page address list */ + int nPages = 0; /* and number of pages */ int np; dev_dbg(&pdx->interface->dev, "%s area %d", __func__, @@ -621,33 +623,33 @@ 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; /* cannot delete as in use */ 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 + 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 */ if (pdx->bXFerWaiting && (pdx->rDMAInfo.wIdent == nArea)) - pdx->bXFerWaiting = false; // Cannot have pending xfer if area cleared + pdx->bXFerWaiting = false; /* Cannot have pending xfer if area cleared */ - // 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 + 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. + /* 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); @@ -677,26 +679,26 @@ 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 - struct page **pPages = 0; // space for page tables - int nPages = 0; // and number of pages + TRANSAREA *pTA = &pdx->rTransDef[nArea]; /* to save typing */ + struct page **pPages = 0; /* 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); /* 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 */ - 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)) /* if we cannot access the memory... */ + return -EFAULT; /* ...then we are done */ - // 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; @@ -705,24 +707,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. - down_read(¤t->mm->mmap_sem); // get memory map semaphore + /* To pin down user pages we must first acquire the mapping semaphore. */ + down_read(¤t->mm->mmap_sem); /* get memory map semaphore */ nPages = get_user_pages(current, current->mm, ulStart, len, 1, 0, pPages, 0); - up_read(¤t->mm->mmap_sem); // release the semaphore + up_read(¤t->mm->mmap_sem); /* release the semaphore */ 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 - // 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 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 - pTA->nPages = nPages; // number of pages + 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 */ + pTA->nPages = nPages; /* number of pages */ pTA->bCircular = bCircular; pTA->bCircToHost = bCircToHost; @@ -731,10 +733,10 @@ static int SetArea(DEVICE_EXTENSION *pdx, int nArea, char __user *puBuf, pTA->aBlocks[0].dwSize = 0; pTA->aBlocks[1].dwOffset = 0; pTA->aBlocks[1].dwSize = 0; - pTA->bUsed = true; // This is now a used block + pTA->bUsed = true; /* This is now a used block */ spin_unlock_irq(&pdx->stagedLock); - iReturn = U14ERR_NOERROR; // say all was well + iReturn = U14ERR_NOERROR; /* say all was well */ } else { iReturn = U14ERR_LOCKFAIL; goto error; @@ -765,9 +767,9 @@ 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, @@ -802,22 +804,22 @@ int SetEvent(DEVICE_EXTENSION *pdx, TRANSFEREVENT __user *pTE) int iReturn = U14ERR_NOERROR; TRANSFEREVENT te; - // get a local copy of the data + /* get a local copy of the data */ if (copy_from_user(&te, pTE, sizeof(te))) return -EFAULT; - if (te.wAreaNum >= MAX_TRANSAREAS) // the area must exist + if (te.wAreaNum >= MAX_TRANSAREAS) /* the area must exist */ 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); /* make sure we have no competitor */ 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->dwEventSz = te.dwLength; // set size (0 cancels it) - pTA->bEventToHost = te.wFlags & 1; // set the direction - pTA->iWakeUp = 0; // zero the wake up count + 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 */ } else iReturn = U14ERR_NOTSET; spin_unlock_irq(&pdx->stagedLock); @@ -841,15 +843,15 @@ 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 + 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 */ mutex_unlock(&pdx->io_mutex); if (msTimeOut) @@ -863,12 +865,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 have had a SIGNAL */ else - iReturn = pTA->iWakeUp; // else the wakeup count + iReturn = pTA->iWakeUp; /* else the wakeup count */ spin_lock_irq(&pdx->stagedLock); - pTA->iWakeUp = 0; // clear the flag + pTA->iWakeUp = 0; /* clear the flag */ spin_unlock_irq(&pdx->stagedLock); } return iReturn; @@ -887,10 +889,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); /* make sure we have no competitor */ spin_lock_irq(&pdx->stagedLock); - iReturn = pTA->iWakeUp; // get wakeup count since last call - pTA->iWakeUp = 0; // clear the count + iReturn = pTA->iWakeUp; /* get wakeup count since last call */ + pTA->iWakeUp = 0; /* clear the count */ spin_unlock_irq(&pdx->stagedLock); mutex_unlock(&pdx->io_mutex); } @@ -907,11 +909,11 @@ int GetTransfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user *pTX) unsigned int dwIdent; mutex_lock(&pdx->io_mutex); - dwIdent = pdx->StagedId; // area ident for last xfer + dwIdent = pdx->StagedId; /* area ident for last xfer */ 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); @@ -921,8 +923,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; /* how many blocks we could return */ + tx->used = 1; /* number we actually return */ tx->entries[0].physical = (long long)(tx->linear + pdx->StagedOffset); tx->entries[0].size = tx->size; @@ -972,7 +974,7 @@ int StateOf1401(DEVICE_EXTENSION *pdx) int iReturn; mutex_lock(&pdx->io_mutex); - QuickCheck(pdx, false, false); // get state up to date, no reset + QuickCheck(pdx, false, false); /* get state up to date, no reset */ iReturn = pdx->sCurrentState; mutex_unlock(&pdx->io_mutex); @@ -993,14 +995,15 @@ int StartSelfTest(DEVICE_EXTENSION *pdx) mutex_lock(&pdx->io_mutex); 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 -// ReadWrite_Cancel(pDeviceObject); /* so things stay tidy */ + ced_draw_down(pdx); /* wait for, then kill outstanding Urbs */ + FlushInBuff(pdx); /* Clear out input buffer & pipe */ + FlushOutBuff(pdx); /* Clear output buffer & pipe */ + /* so things stay tidy */ + /* ReadWrite_Cancel(pDeviceObject); */ pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flags here */ - nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), DB_SELFTEST, (H_TO_D | VENDOR | DEVREQ), 0, 0, 0, 0, HZ); // allow 1 second timeout - pdx->ulSelfTestTime = jiffies + HZ * 30; // 30 seconds into the future + nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), DB_SELFTEST, (H_TO_D | VENDOR | DEVREQ), 0, 0, 0, 0, HZ); /* allow 1 second timeout */ + pdx->ulSelfTestTime = jiffies + HZ * 30; /* 30 seconds into the future */ mutex_unlock(&pdx->io_mutex); if (nGot < 0) @@ -1017,49 +1020,49 @@ 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) + TGET_SELFTEST gst; /* local work space */ + memset(&gst, 0, sizeof(gst)); /* clear out the space (sets code 0) */ 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) /* Only accept zero if it happens twice */ 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 comms errors */ + { /* so we assume still testing */ dev_err(&pdx->interface->dev, "%s Get1401State=%d, assuming still testing", __func__, iReturn); - state = 0x80; // Force still-testing, no error + state = 0x80; /* Force still-testing, no error */ error = 0; 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; /* Force still-testing, no error */ 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.x = error & 0x0000FFFF; // Error data X - gst.y = (error & 0xFFFF0000) >> 16; // and data Y + gst.code = (state & 0x00FF0000) >> 16; /* read the error code */ + gst.x = error & 0x0000FFFF; /* Error data X */ + gst.y = (error & 0xFFFF0000) >> 16; /* and data Y */ dev_dbg(&pdx->interface->dev, "Self-test error code %d", 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)) { - gst.code = -2; // Flag the timeout + gst.code = -2; /* Flag the timeout */ dev_dbg(&pdx->interface->dev, "Self-test timed-out"); } else @@ -1067,16 +1070,16 @@ 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; /* Flag the test is done */ 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 (gst.code < 0) /* If we have a problem or finished */ + { /* If using the 2890 we should reset properly */ if ((pdx->nPipes == 4) && (pdx->s1401Type <= TYPEPOWER)) - Is1401(pdx); // Get 1401 reset and OK + Is1401(pdx); /* Get 1401 reset and OK */ else - QuickCheck(pdx, true, true); // Otherwise check without reset unless problems + QuickCheck(pdx, true, true); /* Otherwise check without reset unless problems */ } mutex_unlock(&pdx->io_mutex); @@ -1100,7 +1103,7 @@ int TypeOf1401(DEVICE_EXTENSION *pdx) switch (pdx->s1401Type) { case TYPE1401: iReturn = U14ERR_STD; - break; // Handle these types directly + break; /* Handle these types directly */ case TYPEPLUS: iReturn = U14ERR_PLUS; break; @@ -1109,9 +1112,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; /* We can calculate types */ + else /* for up-coming 1401 designs */ + iReturn = TYPEUNKNOWN; /* Don't know or not there */ } dev_dbg(&pdx->interface->dev, "%s %d", __func__, iReturn); mutex_unlock(&pdx->io_mutex); @@ -1126,11 +1129,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 | /* we always have multiple DMA area */ + U14TF_NOTIFY | U14TF_CIRCTH; /* diagnostics, notify and circular */ dev_dbg(&pdx->interface->dev, "%s", __func__); mutex_lock(&pdx->io_mutex); - if (pdx->bIsUSB2) // Set flag for USB2 if appropriate + if (pdx->bIsUSB2) /* Set flag for USB2 if appropriate */ iReturn |= U14TF_USB2; mutex_unlock(&pdx->io_mutex); @@ -1147,7 +1150,7 @@ static int DbgCmd1401(DEVICE_EXTENSION *pdx, unsigned char cmd, { int iReturn; dev_dbg(&pdx->interface->dev, "%s entry", __func__); - iReturn = usb_control_msg(pdx->udev, usb_sndctrlpipe(pdx->udev, 0), cmd, (H_TO_D | VENDOR | DEVREQ), (unsigned short)data, (unsigned short)(data >> 16), 0, 0, HZ); // allow 1 second timeout + iReturn = usb_control_msg(pdx->udev, usb_sndctrlpipe(pdx->udev, 0), cmd, (H_TO_D | VENDOR | DEVREQ), (unsigned short)data, (unsigned short)(data >> 16), 0, 0, HZ); /* allow 1 second timeout */ if (iReturn < 0) dev_err(&pdx->interface->dev, "%s fail code=%d", __func__, iReturn); @@ -1284,12 +1287,12 @@ 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)); /* fill returned block with 0s */ mutex_lock(&pdx->io_mutex); dev_dbg(&pdx->interface->dev, "%s", __func__); - // Read back the last peeked value from the 1401. + /* Read back the last peeked value from the 1401. */ iReturn = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), DB_DATA, (D_TO_H | VENDOR | DEVREQ), 0, 0, &db.iData, sizeof(db.iData), HZ); @@ -1346,11 +1349,11 @@ int SetCircular(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); - bToHost = td.eSize != 0; // this is used as the tohost flag + 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, @@ -1377,19 +1380,19 @@ int GetCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) mutex_lock(&pdx->io_mutex); - nArea = cb.nArea; // Retrieve parameters first - cb.dwOffset = 0; // set default result (nothing) + nArea = cb.nArea; /* Retrieve parameters first */ + cb.dwOffset = 0; /* set default result (nothing) */ 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 - spin_lock_irq(&pdx->stagedLock); // Lock others out + TRANSAREA *pArea = &pdx->rTransDef[nArea]; /* Pointer to relevant info */ + spin_lock_irq(&pdx->stagedLock); /* Lock others out */ - if ((pArea->bUsed) && (pArea->bCircular) && // Must be circular area - (pArea->bCircToHost)) // For now at least must be to host + 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->aBlocks[0].dwSize > 0) /* Got anything? */ { cb.dwOffset = pArea->aBlocks[0].dwOffset; cb.dwSize = pArea->aBlocks[0].dwSize; @@ -1429,33 +1432,33 @@ int FreeCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) mutex_lock(&pdx->io_mutex); - nArea = cb.nArea; // Retrieve parameters first + nArea = cb.nArea; /* Retrieve parameters first */ uStart = cb.dwOffset; uSize = cb.dwSize; - cb.dwOffset = 0; // then set default result (nothing) + cb.dwOffset = 0; /* then set default result (nothing) */ 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 - spin_lock_irq(&pdx->stagedLock); // Lock others out + TRANSAREA *pArea = &pdx->rTransDef[nArea]; /* Pointer to relevant info */ + spin_lock_irq(&pdx->stagedLock); /* Lock others out */ - if ((pArea->bUsed) && (pArea->bCircular) && // Must be circular area - (pArea->bCircToHost)) // For now at least must be to host + if ((pArea->bUsed) && (pArea->bCircular) && /* Must be circular area */ + (pArea->bCircToHost)) /* For now at least must be to host */ { 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) && /* Got anything? */ + (pArea->aBlocks[0].dwOffset == uStart)) /* Must be legal data */ { pArea->aBlocks[0].dwSize -= 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[1].dwSize = 0; // and mark the second block as unused + 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].dwOffset = 0; } else pArea->aBlocks[0].dwOffset = 0; @@ -1468,8 +1471,8 @@ 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) /* Got anything? */ { cb.dwOffset = pArea->aBlocks[0].dwOffset; @@ -1492,8 +1495,8 @@ 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, kick off pending transfer */ + if (bWaiting) /* Got a block xfer waiting? */ { int RWMStat = ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard, diff --git a/drivers/staging/ced1401/machine.h b/drivers/staging/ced1401/machine.h index af073790b942..9f38aa4c3092 100644 --- a/drivers/staging/ced1401/machine.h +++ b/drivers/staging/ced1401/machine.h @@ -79,7 +79,7 @@ #if defined(LINUX) || defined(MAXOSX) #define FAR - typedef int BOOL; // To match Windows + typedef int BOOL; /* To match Windows */ typedef char * LPSTR; typedef const char * LPCSTR; typedef unsigned short WORD; diff --git a/drivers/staging/ced1401/usb1401.c b/drivers/staging/ced1401/usb1401.c index 254131d8be5f..8a0876d88ac8 100644 --- a/drivers/staging/ced1401/usb1401.c +++ b/drivers/staging/ced1401/usb1401.c @@ -126,18 +126,18 @@ static void ced_delete(struct kref *kref) { DEVICE_EXTENSION *pdx = to_DEVICE_EXTENSION(kref); - // Free up the output buffer, then free the output urb. Note that the interface member - // of pdx will probably be NULL, so cannot be used to get to dev. + /* Free up the output buffer, then free the output urb. Note that the interface member */ + /* of pdx will probably be NULL, so cannot be used to get to dev. */ usb_free_coherent(pdx->udev, OUTBUF_SZ, pdx->pCoherCharOut, pdx->pUrbCharOut->transfer_dma); usb_free_urb(pdx->pUrbCharOut); - // Do the same for chan input + /* Do the same for chan input */ usb_free_coherent(pdx->udev, INBUF_SZ, pdx->pCoherCharIn, pdx->pUrbCharIn->transfer_dma); usb_free_urb(pdx->pUrbCharIn); - // Do the same for the block transfers + /* Do the same for the block transfers */ usb_free_coherent(pdx->udev, STAGED_SZ, pdx->pCoherStagedIO, pdx->pStagedUrb->transfer_dma); usb_free_urb(pdx->pStagedUrb); @@ -146,7 +146,7 @@ static void ced_delete(struct kref *kref) kfree(pdx); } -// This is the driver end of the open() call from user space. +/* This is the driver end of the open() call from user space. */ static int ced_open(struct inode *inode, struct file *file) { DEVICE_EXTENSION *pdx; @@ -184,7 +184,7 @@ static int ced_open(struct inode *inode, struct file *file) kref_put(&pdx->kref, ced_delete); goto exit; } - } else { //uncomment this block if you want exclusive open + } else { /* uncomment this block if you want exclusive open */ dev_err(&interface->dev, "%s fail: already open", __func__); retval = -EBUSY; pdx->open_count--; @@ -210,11 +210,11 @@ static int ced_release(struct inode *inode, struct file *file) dev_dbg(&pdx->interface->dev, "%s called", __func__); mutex_lock(&pdx->io_mutex); - if (!--pdx->open_count && pdx->interface) // Allow autosuspend + if (!--pdx->open_count && pdx->interface) /* Allow autosuspend */ usb_autopm_put_interface(pdx->interface); mutex_unlock(&pdx->io_mutex); - kref_put(&pdx->kref, ced_delete); // decrement the count on our device + kref_put(&pdx->kref, ced_delete); /* decrement the count on our device */ return 0; } @@ -254,7 +254,7 @@ static int ced_flush(struct file *file, fl_owner_t id) */ static bool CanAcceptIoRequests(DEVICE_EXTENSION * pdx) { - return pdx && pdx->interface; // Can we accept IO requests + return pdx && pdx->interface; /* Can we accept IO requests */ } /**************************************************************************** @@ -264,9 +264,9 @@ static bool CanAcceptIoRequests(DEVICE_EXTENSION * pdx) static void ced_writechar_callback(struct urb *pUrb) { DEVICE_EXTENSION *pdx = pUrb->context; - int nGot = pUrb->actual_length; // what we transferred + int nGot = pUrb->actual_length; /* what we transferred */ - if (pUrb->status) { // sync/async unlink faults aren't errors + if (pUrb->status) { /* sync/async unlink faults aren't errors */ if (! (pUrb->status == -ENOENT || pUrb->status == -ECONNRESET || pUrb->status == -ESHUTDOWN)) { @@ -278,36 +278,36 @@ static void ced_writechar_callback(struct urb *pUrb) spin_lock(&pdx->err_lock); pdx->errors = pUrb->status; spin_unlock(&pdx->err_lock); - nGot = 0; // and tidy up again if so + nGot = 0; /* and tidy up again if so */ - spin_lock(&pdx->charOutLock); // already at irq level - pdx->dwOutBuffGet = 0; // Reset the output buffer + spin_lock(&pdx->charOutLock); /* already at irq level */ + pdx->dwOutBuffGet = 0; /* Reset the output buffer */ pdx->dwOutBuffPut = 0; - pdx->dwNumOutput = 0; // Clear the char count - pdx->bPipeError[0] = 1; // Flag an error for later - pdx->bSendCharsPending = false; // Allow other threads again - spin_unlock(&pdx->charOutLock); // already at irq level + pdx->dwNumOutput = 0; /* Clear the char count */ + pdx->bPipeError[0] = 1; /* Flag an error for later */ + pdx->bSendCharsPending = false; /* Allow other threads again */ + spin_unlock(&pdx->charOutLock); /* already at irq level */ dev_dbg(&pdx->interface->dev, "%s - char out done, 0 chars sent", __func__); } else { dev_dbg(&pdx->interface->dev, "%s - char out done, %d chars sent", __func__, nGot); - spin_lock(&pdx->charOutLock); // already at irq level - pdx->dwNumOutput -= nGot; // Now adjust the char send buffer - pdx->dwOutBuffGet += nGot; // to match what we did - if (pdx->dwOutBuffGet >= OUTBUF_SZ) // Can't do this any earlier as data could be overwritten + spin_lock(&pdx->charOutLock); /* already at irq level */ + pdx->dwNumOutput -= nGot; /* Now adjust the char send buffer */ + pdx->dwOutBuffGet += nGot; /* to match what we did */ + if (pdx->dwOutBuffGet >= OUTBUF_SZ) /* Can't do this any earlier as data could be overwritten */ 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; char *pDat = &pdx->outputBuffer[pdx->dwOutBuffGet]; - unsigned int dwCount = pdx->dwNumOutput; // maximum to send - if ((pdx->dwOutBuffGet + dwCount) > OUTBUF_SZ) // does it cross buffer end? + unsigned int dwCount = pdx->dwNumOutput; /* maximum to send */ + if ((pdx->dwOutBuffGet + dwCount) > OUTBUF_SZ) /* does it cross buffer end? */ dwCount = OUTBUF_SZ - pdx->dwOutBuffGet; - spin_unlock(&pdx->charOutLock); // we are done with stuff that changes - memcpy(pdx->pCoherCharOut, pDat, dwCount); // copy output data to the buffer + spin_unlock(&pdx->charOutLock); /* we are done with stuff that changes */ + memcpy(pdx->pCoherCharOut, pDat, dwCount); /* copy output data to the buffer */ usb_fill_bulk_urb(pdx->pUrbCharOut, pdx->udev, usb_sndbulkpipe(pdx->udev, pdx->epAddr[0]), @@ -315,22 +315,22 @@ static void ced_writechar_callback(struct urb *pUrb) ced_writechar_callback, pdx); pdx->pUrbCharOut->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - usb_anchor_urb(pdx->pUrbCharOut, &pdx->submitted); // in case we need to kill it + usb_anchor_urb(pdx->pUrbCharOut, &pdx->submitted); /* in case we need to kill it */ iReturn = usb_submit_urb(pdx->pUrbCharOut, GFP_ATOMIC); dev_dbg(&pdx->interface->dev, "%s n=%d>%s<", __func__, dwCount, pDat); - spin_lock(&pdx->charOutLock); // grab lock for errors + spin_lock(&pdx->charOutLock); /* grab lock for errors */ if (iReturn) { - pdx->bPipeError[nPipe] = 1; // Flag an error to be handled later - pdx->bSendCharsPending = false; // Allow other threads again + pdx->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ + pdx->bSendCharsPending = false; /* Allow other threads again */ usb_unanchor_urb(pdx->pUrbCharOut); dev_err(&pdx->interface->dev, "%s usb_submit_urb() returned %d", __func__, iReturn); } } else - pdx->bSendCharsPending = false; // Allow other threads again - spin_unlock(&pdx->charOutLock); // already at irq level + pdx->bSendCharsPending = false; /* Allow other threads again */ + spin_unlock(&pdx->charOutLock); /* already at irq level */ } } @@ -343,40 +343,40 @@ int SendChars(DEVICE_EXTENSION * pdx) { int iReturn = U14ERR_NOERROR; - spin_lock_irq(&pdx->charOutLock); // Protect ourselves + spin_lock_irq(&pdx->charOutLock); /* Protect ourselves */ - if ((!pdx->bSendCharsPending) && // Not currently sending - (pdx->dwNumOutput > 0) && // has characters to output - (CanAcceptIoRequests(pdx))) // and current activity is OK + if ((!pdx->bSendCharsPending) && /* Not currently sending */ + (pdx->dwNumOutput > 0) && /* has characters to output */ + (CanAcceptIoRequests(pdx))) /* and current activity is OK */ { - unsigned int dwCount = pdx->dwNumOutput; // Get a copy of the character count - pdx->bSendCharsPending = true; // Set flag to lock out other threads + unsigned int dwCount = pdx->dwNumOutput; /* Get a copy of the character count */ + pdx->bSendCharsPending = true; /* Set flag to lock out other threads */ dev_dbg(&pdx->interface->dev, "Send %d chars to 1401, EP0 flag %d\n", dwCount, pdx->nPipes == 3); - // If we have only 3 end points we must send the characters to the 1401 using EP0. + /* If we have only 3 end points we must send the characters to the 1401 using EP0. */ if (pdx->nPipes == 3) { - // For EP0 character transmissions to the 1401, we have to hang about until they - // are gone, as otherwise without more character IO activity they will never go. - unsigned int count = dwCount; // Local char counter - unsigned int index = 0; // The index into the char buffer + /* For EP0 character transmissions to the 1401, we have to hang about until they */ + /* are gone, as otherwise without more character IO activity they will never go. */ + unsigned int count = dwCount; /* Local char counter */ + unsigned int index = 0; /* The index into the char buffer */ - spin_unlock_irq(&pdx->charOutLock); // Free spinlock as we call USBD + spin_unlock_irq(&pdx->charOutLock); /* Free spinlock as we call USBD */ while ((count > 0) && (iReturn == U14ERR_NOERROR)) { - // We have to break the transfer up into 64-byte chunks because of a 2270 problem - int n = count > 64 ? 64 : count; // Chars for this xfer, max of 64 + /* We have to break the transfer up into 64-byte chunks because of a 2270 problem */ + int n = count > 64 ? 64 : count; /* Chars for this xfer, max of 64 */ int nSent = usb_control_msg(pdx->udev, - usb_sndctrlpipe(pdx->udev, 0), // use end point 0 - DB_CHARS, // bRequest - (H_TO_D | VENDOR | DEVREQ), // to the device, vendor request to the device - 0, 0, // value and index are both 0 - &pdx->outputBuffer[index], // where to send from - n, // how much to send - 1000); // timeout in jiffies + usb_sndctrlpipe(pdx->udev, 0), /* use end point 0 */ + DB_CHARS, /* bRequest */ + (H_TO_D | VENDOR | DEVREQ), /* to the device, vendor request to the device */ + 0, 0, /* value and index are both 0 */ + &pdx->outputBuffer[index], /* where to send from */ + n, /* how much to send */ + 1000); /* timeout in jiffies */ if (nSent <= 0) { - iReturn = nSent ? nSent : -ETIMEDOUT; // if 0 chars says we timed out + iReturn = nSent ? nSent : -ETIMEDOUT; /* if 0 chars says we timed out */ dev_err(&pdx->interface->dev, "Send %d chars by EP0 failed: %d", n, iReturn); @@ -388,19 +388,19 @@ int SendChars(DEVICE_EXTENSION * pdx) } } - spin_lock_irq(&pdx->charOutLock); // Protect pdx changes, released by general code - pdx->dwOutBuffGet = 0; // so reset the output buffer + spin_lock_irq(&pdx->charOutLock); /* Protect pdx changes, released by general code */ + pdx->dwOutBuffGet = 0; /* so reset the output buffer */ pdx->dwOutBuffPut = 0; - pdx->dwNumOutput = 0; // and clear the buffer count - pdx->bSendCharsPending = false; // Allow other threads again - } else { // Here for sending chars normally - we hold the spin lock - int nPipe = 0; // The pipe number to use + pdx->dwNumOutput = 0; /* and clear the buffer count */ + pdx->bSendCharsPending = false; /* Allow other threads again */ + } else { /* Here for sending chars normally - we hold the spin lock */ + int nPipe = 0; /* The pipe number to use */ char *pDat = &pdx->outputBuffer[pdx->dwOutBuffGet]; - if ((pdx->dwOutBuffGet + dwCount) > OUTBUF_SZ) // does it cross buffer end? + if ((pdx->dwOutBuffGet + dwCount) > OUTBUF_SZ) /* does it cross buffer end? */ dwCount = OUTBUF_SZ - pdx->dwOutBuffGet; - spin_unlock_irq(&pdx->charOutLock); // we are done with stuff that changes - memcpy(pdx->pCoherCharOut, pDat, dwCount); // copy output data to the buffer + spin_unlock_irq(&pdx->charOutLock); /* we are done with stuff that changes */ + memcpy(pdx->pCoherCharOut, pDat, dwCount); /* copy output data to the buffer */ usb_fill_bulk_urb(pdx->pUrbCharOut, pdx->udev, usb_sndbulkpipe(pdx->udev, pdx->epAddr[0]), @@ -410,11 +410,11 @@ int SendChars(DEVICE_EXTENSION * pdx) URB_NO_TRANSFER_DMA_MAP; usb_anchor_urb(pdx->pUrbCharOut, &pdx->submitted); iReturn = usb_submit_urb(pdx->pUrbCharOut, GFP_KERNEL); - spin_lock_irq(&pdx->charOutLock); // grab lock for errors + spin_lock_irq(&pdx->charOutLock); /* grab lock for errors */ if (iReturn) { - pdx->bPipeError[nPipe] = 1; // Flag an error to be handled later - pdx->bSendCharsPending = false; // Allow other threads again - usb_unanchor_urb(pdx->pUrbCharOut); // remove from list of active urbs + pdx->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ + pdx->bSendCharsPending = false; /* Allow other threads again */ + usb_unanchor_urb(pdx->pUrbCharOut); /* remove from list of active urbs */ } } } else if (pdx->bSendCharsPending && (pdx->dwNumOutput > 0)) @@ -422,7 +422,7 @@ int SendChars(DEVICE_EXTENSION * pdx) "SendChars bSendCharsPending:true"); dev_dbg(&pdx->interface->dev, "SendChars exit code: %d", iReturn); - spin_unlock_irq(&pdx->charOutLock); // Now let go of the spinlock + spin_unlock_irq(&pdx->charOutLock); /* Now let go of the spinlock */ return iReturn; } @@ -444,10 +444,10 @@ static void CopyUserSpace(DEVICE_EXTENSION * pdx, int n) { unsigned int nArea = pdx->StagedId; if (nArea < MAX_TRANSAREAS) { - TRANSAREA *pArea = &pdx->rTransDef[nArea]; // area to be used + TRANSAREA *pArea = &pdx->rTransDef[nArea]; /* area to be used */ unsigned int dwOffset = pdx->StagedDone + pdx->StagedOffset + pArea->dwBaseOffset; - char *pCoherBuf = pdx->pCoherStagedIO; // coherent buffer + char *pCoherBuf = pdx->pCoherStagedIO; /* coherent buffer */ if (!pArea->bUsed) { dev_err(&pdx->interface->dev, "%s area %d unused", __func__, nArea); @@ -455,15 +455,15 @@ static void CopyUserSpace(DEVICE_EXTENSION * pdx, int n) } while (n) { - int nPage = dwOffset >> PAGE_SHIFT; // page number in table + int nPage = dwOffset >> PAGE_SHIFT; /* page number in table */ if (nPage < pArea->nPages) { char *pvAddress = (char *)kmap_atomic(pArea->pPages[nPage]); if (pvAddress) { - unsigned int uiPageOff = dwOffset & (PAGE_SIZE - 1); // offset into the page - size_t uiXfer = PAGE_SIZE - uiPageOff; // max to transfer on this page - if (uiXfer > n) // limit byte count if too much - uiXfer = n; // for the page + unsigned int uiPageOff = dwOffset & (PAGE_SIZE - 1); /* offset into the page */ + size_t uiXfer = PAGE_SIZE - uiPageOff; /* max to transfer on this page */ + if (uiXfer > n) /* limit byte count if too much */ + uiXfer = n; /* for the page */ if (pdx->StagedRead) memcpy(pvAddress + uiPageOff, pCoherBuf, uiXfer); @@ -494,7 +494,7 @@ static void CopyUserSpace(DEVICE_EXTENSION * pdx, int n) nArea); } -// Forward declarations for stuff used circularly +/* Forward declarations for stuff used circularly */ static int StageChunk(DEVICE_EXTENSION * pdx); /*************************************************************************** ** ReadWrite_Complete @@ -504,14 +504,14 @@ static int StageChunk(DEVICE_EXTENSION * pdx); static void staged_callback(struct urb *pUrb) { DEVICE_EXTENSION *pdx = pUrb->context; - unsigned int nGot = pUrb->actual_length; // what we transferred + unsigned int nGot = pUrb->actual_length; /* what we transferred */ bool bCancel = false; - bool bRestartCharInput; // used at the end + bool bRestartCharInput; /* used at the end */ - spin_lock(&pdx->stagedLock); // stop ReadWriteMem() action while this routine is running - pdx->bStagedUrbPending = false; // clear the flag for staged IRP pending + spin_lock(&pdx->stagedLock); /* stop ReadWriteMem() action while this routine is running */ + pdx->bStagedUrbPending = false; /* clear the flag for staged IRP pending */ - if (pUrb->status) { // sync/async unlink faults aren't errors + if (pUrb->status) { /* sync/async unlink faults aren't errors */ if (! (pUrb->status == -ENOENT || pUrb->status == -ECONNRESET || pUrb->status == -ESHUTDOWN)) { @@ -525,39 +525,39 @@ static void staged_callback(struct urb *pUrb) spin_lock(&pdx->err_lock); pdx->errors = pUrb->status; spin_unlock(&pdx->err_lock); - nGot = 0; // and tidy up again if so + nGot = 0; /* and tidy up again if so */ bCancel = true; } else { dev_dbg(&pdx->interface->dev, "%s %d chars xferred", __func__, nGot); - if (pdx->StagedRead) // if reading, save to user space - CopyUserSpace(pdx, nGot); // copy from buffer to user + if (pdx->StagedRead) /* if reading, save to user space */ + CopyUserSpace(pdx, nGot); /* copy from buffer to user */ if (nGot == 0) dev_dbg(&pdx->interface->dev, "%s ZLP", __func__); } - // Update the transfer length based on the TransferBufferLength value in the URB + /* Update the transfer length based on the TransferBufferLength value in the URB */ pdx->StagedDone += nGot; dev_dbg(&pdx->interface->dev, "%s, done %d bytes of %d", __func__, pdx->StagedDone, pdx->StagedLength); - if ((pdx->StagedDone == pdx->StagedLength) || // If no more to do - (bCancel)) // or this IRP was cancelled + if ((pdx->StagedDone == pdx->StagedLength) || /* If no more to do */ + (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, "%s transfer done, bytes %d, cancel %d", __func__, pdx->StagedDone, bCancel); - // Here is where we sort out what to do with this transfer if using a circular buffer. We have - // a completed transfer that can be assumed to fit into the transfer area. We should be able to - // 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. - if ((pArea->bCircular) && (pArea->bCircToHost) && (!bCancel) && // Time to sort out circular buffer info? - (pdx->StagedRead)) // Only for tohost transfers for now + /* Here is where we sort out what to do with this transfer if using a circular buffer. We have */ + /* a completed transfer that can be assumed to fit into the transfer area. We should be able to */ + /* 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. */ + if ((pArea->bCircular) && (pArea->bCircToHost) && (!bCancel) && /* Time to sort out circular buffer info? */ + (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 == (pArea->aBlocks[1].dwOffset + @@ -569,7 +569,7 @@ static void staged_callback(struct urb *pUrb) pArea->aBlocks[1].dwSize, pArea->aBlocks[1].dwOffset); } else { - // Here things have gone very, very, wrong, but I cannot see how this can actually be achieved + /* Here things have gone very, very, wrong, but I cannot see how this can actually be achieved */ pArea->aBlocks[1].dwOffset = pdx->StagedOffset; pArea->aBlocks[1].dwSize = @@ -580,21 +580,21 @@ static void staged_callback(struct urb *pUrb) pArea->aBlocks[1].dwSize, 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? - { // Must append onto the existing block 0 + if (pArea->aBlocks[0].dwSize > 0) /* Got stored block 0 information? */ + { /* Must append onto the existing block 0 */ if (pdx->StagedOffset == (pArea->aBlocks[0].dwOffset + pArea->aBlocks[0].dwSize)) { - pArea->aBlocks[0].dwSize += pdx->StagedLength; // Just add this transfer in + pArea->aBlocks[0].dwSize += pdx->StagedLength; /* Just add this transfer in */ dev_dbg(&pdx->interface->dev, "RWM_Complete, circ block 0 now %d bytes at %d", pArea->aBlocks[0]. dwSize, pArea->aBlocks[0]. 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 = pdx->StagedOffset; @@ -607,7 +607,7 @@ static void staged_callback(struct urb *pUrb) pArea->aBlocks[1]. 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 = pdx->StagedOffset; @@ -621,21 +621,21 @@ 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, "RWM_Complete, bCircular %d, bToHost %d, eStart %d, eSize %d", pArea->bCircular, pArea->bEventToHost, pArea->dwEventSt, pArea->dwEventSz); - if ((pArea->dwEventSz) && // Set a user-mode event... - (pdx->StagedRead == pArea->bEventToHost)) // ...on transfers in this direction? + if ((pArea->dwEventSz) && /* Set a user-mode event... */ + (pdx->StagedRead == pArea->bEventToHost)) /* ...on transfers in this direction? */ { - int iWakeUp = 0; // assume - // 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. - if ((pArea->bCircular) && // Circular areas use a simpler test - (pArea->bCircToHost)) // only in supported direction - { // Is total data waiting up to size limit? + int iWakeUp = 0; /* assume */ + /* 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. */ + if ((pArea->bCircular) && /* Circular areas use a simpler test */ + (pArea->bCircToHost)) /* only in supported direction */ + { /* Is total data waiting up to size limit? */ unsigned int dwTotal = pArea->aBlocks[0].dwSize + pArea->aBlocks[1].dwSize; @@ -653,18 +653,18 @@ static void staged_callback(struct urb *pUrb) if (iWakeUp) { dev_dbg(&pdx->interface->dev, "About to set event to notify app"); - wake_up_interruptible(&pArea->wqEvent); // wake up waiting processes - ++pArea->iWakeUp; // increment wakeup count + wake_up_interruptible(&pArea->wqEvent); /* wake up waiting processes */ + ++pArea->iWakeUp; /* increment wakeup count */ } } } - 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 (pdx->bXFerWaiting) // Got a block xfer waiting? + /* If we have a transfer waiting, kick it off */ + if (pdx->bXFerWaiting) /* Got a block xfer waiting? */ { int iReturn; dev_info(&pdx->interface->dev, @@ -682,22 +682,22 @@ static void staged_callback(struct urb *pUrb) } } - } else // Here for more to do - StageChunk(pdx); // fire off the next bit + } else /* Here for more to do */ + StageChunk(pdx); /* fire off the next bit */ - // While we hold the stagedLock, see if we should reallow character input ints - // Don't allow if cancelled, or if a new block has started or if there is a waiting block. - // This feels wrong as we should ask which spin lock protects dwDMAFlag. + /* While we hold the stagedLock, see if we should reallow character input ints */ + /* Don't allow if cancelled, or if a new block has started or if there is a waiting block. */ + /* This feels wrong as we should ask which spin lock protects dwDMAFlag. */ bRestartCharInput = !bCancel && (pdx->dwDMAFlag == MODE_CHAR) && !pdx->bXFerWaiting; - spin_unlock(&pdx->stagedLock); // Finally release the lock again + spin_unlock(&pdx->stagedLock); /* Finally release the lock again */ - // This is not correct as dwDMAFlag is protected by the staged lock, but it is treated - // in Allowi as if it were protected by the char lock. In any case, most systems will - // not be upset by char input during DMA... sigh. Needs sorting out. - if (bRestartCharInput) // may be out of date, but... - Allowi(pdx); // ...Allowi tests a lock too. + /* This is not correct as dwDMAFlag is protected by the staged lock, but it is treated */ + /* in Allowi as if it were protected by the char lock. In any case, most systems will */ + /* not be upset by char input during DMA... sigh. Needs sorting out. */ + if (bRestartCharInput) /* may be out of date, but... */ + Allowi(pdx); /* ...Allowi tests a lock too. */ dev_dbg(&pdx->interface->dev, "%s done", __func__); } @@ -713,25 +713,25 @@ static int StageChunk(DEVICE_EXTENSION * pdx) { int iReturn = U14ERR_NOERROR; unsigned int ChunkSize; - int nPipe = pdx->StagedRead ? 3 : 2; // The pipe number to use for reads or writes + int nPipe = pdx->StagedRead ? 3 : 2; /* The pipe number to use for reads or writes */ if (pdx->nPipes == 3) - nPipe--; // Adjust for the 3-pipe case - if (nPipe < 0) // and trap case that should never happen + nPipe--; /* Adjust for the 3-pipe case */ + if (nPipe < 0) /* and trap case that should never happen */ 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", __func__); - return U14ERR_FAIL; // could do with a better error + return U14ERR_FAIL; /* could do with a better error */ } - ChunkSize = (pdx->StagedLength - pdx->StagedDone); // transfer length remaining - if (ChunkSize > STAGED_SZ) // make sure to keep legal - ChunkSize = STAGED_SZ; // limit to max allowed + ChunkSize = (pdx->StagedLength - pdx->StagedDone); /* transfer length remaining */ + if (ChunkSize > STAGED_SZ) /* make sure to keep legal */ + ChunkSize = STAGED_SZ; /* limit to max allowed */ - if (!pdx->StagedRead) // if writing... - CopyUserSpace(pdx, ChunkSize); // ...copy data into the buffer + if (!pdx->StagedRead) /* if writing... */ + CopyUserSpace(pdx, ChunkSize); /* ...copy data into the buffer */ usb_fill_bulk_urb(pdx->pStagedUrb, pdx->udev, pdx->StagedRead ? usb_rcvbulkpipe(pdx->udev, @@ -740,15 +740,15 @@ static int StageChunk(DEVICE_EXTENSION * pdx) usb_sndbulkpipe(pdx->udev, pdx->epAddr[nPipe]), pdx->pCoherStagedIO, ChunkSize, staged_callback, pdx); pdx->pStagedUrb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - usb_anchor_urb(pdx->pStagedUrb, &pdx->submitted); // in case we need to kill it + usb_anchor_urb(pdx->pStagedUrb, &pdx->submitted); /* in case we need to kill it */ iReturn = usb_submit_urb(pdx->pStagedUrb, GFP_ATOMIC); if (iReturn) { - usb_unanchor_urb(pdx->pStagedUrb); // kill it - pdx->bPipeError[nPipe] = 1; // Flag an error to be handled later + usb_unanchor_urb(pdx->pStagedUrb); /* kill it */ + pdx->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ dev_err(&pdx->interface->dev, "%s submit urb failed, code %d", __func__, iReturn); } else - pdx->bStagedUrbPending = true; // Set the flag for staged URB pending + pdx->bStagedUrbPending = true; /* Set the flag for staged URB pending */ dev_dbg(&pdx->interface->dev, "%s done so far:%d, this size:%d", __func__, pdx->StagedDone, ChunkSize); @@ -775,9 +775,9 @@ static int StageChunk(DEVICE_EXTENSION * pdx) int ReadWriteMem(DEVICE_EXTENSION * pdx, bool Read, unsigned short wIdent, unsigned int dwOffs, unsigned int dwLen) { - 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", __func__); @@ -788,56 +788,56 @@ int ReadWriteMem(DEVICE_EXTENSION * pdx, bool Read, unsigned short wIdent, "%s xfer %d bytes to %s, offset %d, area %d", __func__, dwLen, Read ? "host" : "1401", dwOffs, wIdent); - // Amazingly, we can get an escape sequence back before the current staged Urb is done, so we - // have to check for this situation and, if so, wait until all is OK. + /* Amazingly, we can get an escape sequence back before the current staged Urb is done, so we */ + /* have to check for this situation and, if so, wait until all is OK. */ if (pdx->bStagedUrbPending) { - pdx->bXFerWaiting = true; // Flag we are waiting + pdx->bXFerWaiting = true; /* Flag we are waiting */ dev_info(&pdx->interface->dev, "%s xfer is waiting, as previous staged pending", __func__); 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, "%s OK; zero-len read/write request", __func__); return U14ERR_NOERROR; } - if ((pArea->bCircular) && // Circular transfer? - (pArea->bCircToHost) && (Read)) // In a supported direction - { // If so, we sort out offset ourself - bool bWait = false; // Flag for transfer having to wait + if ((pArea->bCircular) && /* Circular transfer? */ + (pArea->bCircToHost) && (Read)) /* In a supported direction */ + { /* If so, we sort out offset ourself */ + bool bWait = false; /* Flag for transfer having to wait */ dev_dbg(&pdx->interface->dev, "Circular buffers are %d at %d and %d at %d", pArea->aBlocks[0].dwSize, pArea->aBlocks[0].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 - bWait = (dwOffs + dwLen) > pArea->aBlocks[0].dwOffset; // Wait if will overwrite block 0? - bWait |= (dwOffs + dwLen) > pArea->dwLength; // or if it overflows the buffer - } else // Area 1 not in use, try to use area 0 + 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->dwLength; /* or if it overflows the buffer */ + } 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; dwOffs = pArea->aBlocks[0].dwOffset + 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; - 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->aBlocks[0].dwOffset; /* Wait if will overwrite block 0? */ + bWait |= (dwOffs + dwLen) > pArea->dwLength; /* or if it overflows the buffer */ } } - 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, "%s xfer waiting for circular buffer space", __func__); @@ -848,17 +848,17 @@ int ReadWriteMem(DEVICE_EXTENSION * pdx, bool Read, unsigned short wIdent, "%s circular xfer, %d bytes starting at %d", __func__, dwLen, dwOffs); } - // Save the parameters for the read\write transfer - pdx->StagedRead = Read; // Save the parameters for this read - pdx->StagedId = wIdent; // ID allows us to get transfer area info - pdx->StagedOffset = dwOffs; // The area within the transfer area + /* Save the parameters for the read\write transfer */ + pdx->StagedRead = Read; /* Save the parameters for this read */ + pdx->StagedId = wIdent; /* ID allows us to get transfer area info */ + pdx->StagedOffset = dwOffs; /* The area within the transfer area */ pdx->StagedLength = dwLen; - pdx->StagedDone = 0; // Initialise the byte count - pdx->dwDMAFlag = MODE_LINEAR; // Set DMA mode flag at this point - pdx->bXFerWaiting = false; // Clearly not a transfer waiting now + pdx->StagedDone = 0; /* Initialise the byte count */ + pdx->dwDMAFlag = MODE_LINEAR; /* Set DMA mode flag at this point */ + pdx->bXFerWaiting = false; /* Clearly not a transfer waiting now */ -// KeClearEvent(&pdx->StagingDoneEvent); // Clear the transfer done event - StageChunk(pdx); // fire off the first chunk +/* KeClearEvent(&pdx->StagingDoneEvent); // Clear the transfer done event */ + StageChunk(pdx); /* fire off the first chunk */ return U14ERR_NOERROR; } @@ -877,12 +877,12 @@ static bool ReadChar(unsigned char *pChar, char *pBuf, unsigned int *pdDone, bool bRead = false; 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 - dDone++; // Increment the done count + *pChar = (unsigned char)pBuf[dDone]; /* Extract the next char */ + dDone++; /* Increment the done count */ *pdDone = dDone; - bRead = true; // and flag success + bRead = true; /* and flag success */ } return bRead; @@ -965,29 +965,29 @@ static bool ReadHuff(volatile unsigned int *pDWord, char *pBuf, static bool ReadDMAInfo(volatile DMADESC * pDmaDesc, DEVICE_EXTENSION * pdx, char *pBuf, unsigned int dwCount) { - bool bResult = false; // assume we won't succeed + bool bResult = false; /* assume we won't succeed */ unsigned char ucData; - unsigned int dDone = 0; // We haven't parsed anything so far + unsigned int dDone = 0; /* We haven't parsed anything so far */ dev_dbg(&pdx->interface->dev, "%s", __func__); if (ReadChar(&ucData, pBuf, &dDone, dwCount)) { - unsigned char ucTransCode = (ucData & 0x0F); // get code for transfer type - unsigned short wIdent = ((ucData >> 4) & 0x07); // and area identifier + unsigned char ucTransCode = (ucData & 0x0F); /* get code for transfer type */ + unsigned short wIdent = ((ucData >> 4) & 0x07); /* and area identifier */ - // fill in the structure we were given - pDmaDesc->wTransType = ucTransCode; // type of transfer - pDmaDesc->wIdent = wIdent; // area to use - pDmaDesc->dwSize = 0; // initialise other bits + /* fill in the structure we were given */ + pDmaDesc->wTransType = ucTransCode; /* type of transfer */ + pDmaDesc->wIdent = wIdent; /* area to use */ + pDmaDesc->dwSize = 0; /* initialise other bits */ pDmaDesc->dwOffset = 0; dev_dbg(&pdx->interface->dev, "%s type: %d ident: %d", __func__, pDmaDesc->wTransType, pDmaDesc->wIdent); - pDmaDesc->bOutWard = (ucTransCode != TM_EXTTOHOST); // set transfer direction + pDmaDesc->bOutWard = (ucTransCode != TM_EXTTOHOST); /* set transfer direction */ switch (ucTransCode) { - case TM_EXTTOHOST: // Extended linear transfer modes (the only ones!) + case TM_EXTTOHOST: /* Extended linear transfer modes (the only ones!) */ case TM_EXTTO1401: { bResult = @@ -1001,14 +1001,14 @@ static bool ReadDMAInfo(volatile DMADESC * pDmaDesc, DEVICE_EXTENSION * pdx, __func__, pDmaDesc->dwOffset, pDmaDesc->dwSize); - if ((wIdent >= MAX_TRANSAREAS) || // Illegal area number, or... - (!pdx->rTransDef[wIdent].bUsed) || // area not set up, or... - (pDmaDesc->dwOffset > pdx->rTransDef[wIdent].dwLength) || // range/size + if ((wIdent >= MAX_TRANSAREAS) || /* Illegal area number, or... */ + (!pdx->rTransDef[wIdent].bUsed) || /* area not set up, or... */ + (pDmaDesc->dwOffset > pdx->rTransDef[wIdent].dwLength) || /* range/size */ ((pDmaDesc->dwOffset + pDmaDesc->dwSize) > (pdx->rTransDef[wIdent]. dwLength))) { - bResult = false; // bad parameter(s) + bResult = false; /* bad parameter(s) */ dev_dbg(&pdx->interface->dev, "%s bad param - id %d, bUsed %d, offset %d, size %d, area length %d", __func__, wIdent, @@ -1028,7 +1028,7 @@ static bool ReadDMAInfo(volatile DMADESC * pDmaDesc, DEVICE_EXTENSION * pdx, } else bResult = false; - if (!bResult) // now check parameters for validity + if (!bResult) /* now check parameters for validity */ dev_err(&pdx->interface->dev, "%s error reading Esc sequence", __func__); @@ -1054,25 +1054,25 @@ static int Handle1401Esc(DEVICE_EXTENSION * pdx, char *pCh, { int iReturn = U14ERR_FAIL; - // 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 - // tell me what this is for, it should be removed from this and the Windows driver. - if (pCh[0] == '?') // Is this an information response - { // Parse and save the information + /* 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 */ + /* tell me what this is for, it should be removed from this and the Windows driver. */ + if (pCh[0] == '?') /* Is this an information response */ + { /* Parse and save the information */ } 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, "%s xfer to %s, offset %d, length %d", __func__, pdx->rDMAInfo.bOutWard ? "1401" : "host", pdx->rDMAInfo.dwOffset, pdx->rDMAInfo.dwSize); - if (pdx->bXFerWaiting) // Check here for badly out of kilter... - { // This can never happen, really + if (pdx->bXFerWaiting) /* Check here for badly out of kilter... */ + { /* This can never happen, really */ dev_err(&pdx->interface->dev, "ERROR: DMA setup while transfer still waiting"); spin_unlock(&pdx->stagedLock); @@ -1090,16 +1090,16 @@ static int Handle1401Esc(DEVICE_EXTENSION * pdx, char *pCh, dev_err(&pdx->interface->dev, "%s ReadWriteMem() failed %d", __func__, iReturn); - } else // This covers non-linear transfer setup + } else /* This covers non-linear transfer setup */ dev_err(&pdx->interface->dev, "%s Unknown block xfer type %d", __func__, wTransType); } - } else // Failed to read parameters + } else /* Failed to read parameters */ dev_err(&pdx->interface->dev, "%s ReadDMAInfo() fail", __func__); - spin_unlock(&pdx->stagedLock); // OK here + spin_unlock(&pdx->stagedLock); /* OK here */ } dev_dbg(&pdx->interface->dev, "%s returns %d", __func__, iReturn); @@ -1113,12 +1113,12 @@ static int Handle1401Esc(DEVICE_EXTENSION * pdx, char *pCh, static void ced_readchar_callback(struct urb *pUrb) { 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 - // sync/async unlink faults aren't errors... just saying device removed or stopped + 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 */ if (! (pUrb->status == -ENOENT || pUrb->status == -ECONNRESET || pUrb->status == -ESHUTDOWN)) { @@ -1133,27 +1133,27 @@ static void ced_readchar_callback(struct urb *pUrb) spin_lock(&pdx->err_lock); pdx->errors = pUrb->status; spin_unlock(&pdx->err_lock); - nGot = 0; // and tidy up again if so + nGot = 0; /* and tidy up again if so */ - spin_lock(&pdx->charInLock); // already at irq level - pdx->bPipeError[nPipe] = 1; // Flag an error for later + spin_lock(&pdx->charInLock); /* already at irq level */ + pdx->bPipeError[nPipe] = 1; /* Flag an error for later */ } 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 - spin_lock(&pdx->charInLock); // already at irq level + Handle1401Esc(pdx, &pdx->pCoherCharIn[1], nGot - 1); /* handle it */ + spin_lock(&pdx->charInLock); /* already at irq level */ } else { - spin_lock(&pdx->charInLock); // already at irq level + spin_lock(&pdx->charInLock); /* already at irq level */ if (nGot > 0) { unsigned int i; if (nGot < INBUF_SZ) { - pdx->pCoherCharIn[nGot] = 0; // tidy the string + pdx->pCoherCharIn[nGot] = 0; /* tidy the string */ dev_dbg(&pdx->interface->dev, "%s got %d chars >%s<", __func__, nGot, pdx->pCoherCharIn); } - // We know that whatever we read must fit in the input buffer + /* We know that whatever we read must fit in the input buffer */ for (i = 0; i < nGot; i++) { pdx->inputBuffer[pdx->dwInBuffPut++] = pdx->pCoherCharIn[i] & 0x7F; @@ -1162,17 +1162,17 @@ static void ced_readchar_callback(struct urb *pUrb) } if ((pdx->dwNumInput + nGot) <= INBUF_SZ) - pdx->dwNumInput += nGot; // Adjust the buffer count accordingly + pdx->dwNumInput += nGot; /* Adjust the buffer count accordingly */ } else dev_dbg(&pdx->interface->dev, "%s read ZLP", __func__); } } - pdx->bReadCharsPending = false; // No longer have a pending read - spin_unlock(&pdx->charInLock); // already at irq level + pdx->bReadCharsPending = false; /* No longer have a pending read */ + spin_unlock(&pdx->charInLock); /* already at irq level */ - Allowi(pdx); // see if we can do the next one + Allowi(pdx); /* see if we can do the next one */ } /**************************************************************************** @@ -1186,21 +1186,21 @@ int Allowi(DEVICE_EXTENSION * pdx) { int iReturn = U14ERR_NOERROR; unsigned long flags; - spin_lock_irqsave(&pdx->charInLock, flags); // can be called in multiple contexts - - // We don't want char input running while DMA is in progress as we know that this - // can cause sequencing problems for the 2270. So don't. It will also allow the - // ERR response to get back to the host code too early on some PCs, even if there - // is no actual driver failure, so we don't allow this at all. - if (!pdx->bInDrawDown && // stop input if - !pdx->bReadCharsPending && // If no read request outstanding - (pdx->dwNumInput < (INBUF_SZ / 2)) && // and there is some space - (pdx->dwDMAFlag == MODE_CHAR) && // not doing any DMA - (!pdx->bXFerWaiting) && // no xfer waiting to start - (CanAcceptIoRequests(pdx))) // and activity is generally OK - { // then off we go - unsigned int nMax = INBUF_SZ - pdx->dwNumInput; // max we could read - int nPipe = pdx->nPipes == 4 ? 1 : 0; // The pipe number to use + spin_lock_irqsave(&pdx->charInLock, flags); /* can be called in multiple contexts */ + + /* We don't want char input running while DMA is in progress as we know that this */ + /* can cause sequencing problems for the 2270. So don't. It will also allow the */ + /* ERR response to get back to the host code too early on some PCs, even if there */ + /* is no actual driver failure, so we don't allow this at all. */ + if (!pdx->bInDrawDown && /* stop input if */ + !pdx->bReadCharsPending && /* If no read request outstanding */ + (pdx->dwNumInput < (INBUF_SZ / 2)) && /* and there is some space */ + (pdx->dwDMAFlag == MODE_CHAR) && /* not doing any DMA */ + (!pdx->bXFerWaiting) && /* no xfer waiting to start */ + (CanAcceptIoRequests(pdx))) /* and activity is generally OK */ + { /* then off we go */ + unsigned int nMax = INBUF_SZ - pdx->dwNumInput; /* max we could read */ + int nPipe = pdx->nPipes == 4 ? 1 : 0; /* The pipe number to use */ dev_dbg(&pdx->interface->dev, "%s %d chars in input buffer", __func__, pdx->dwNumInput); @@ -1209,16 +1209,16 @@ int Allowi(DEVICE_EXTENSION * pdx) usb_rcvintpipe(pdx->udev, pdx->epAddr[nPipe]), pdx->pCoherCharIn, nMax, ced_readchar_callback, pdx, pdx->bInterval); - pdx->pUrbCharIn->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; // short xfers are OK by default - usb_anchor_urb(pdx->pUrbCharIn, &pdx->submitted); // in case we need to kill it + pdx->pUrbCharIn->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; /* short xfers are OK by default */ + usb_anchor_urb(pdx->pUrbCharIn, &pdx->submitted); /* in case we need to kill it */ iReturn = usb_submit_urb(pdx->pUrbCharIn, GFP_ATOMIC); if (iReturn) { - usb_unanchor_urb(pdx->pUrbCharIn); // remove from list of active Urbs - pdx->bPipeError[nPipe] = 1; // Flag an error to be handled later + usb_unanchor_urb(pdx->pUrbCharIn); /* remove from list of active Urbs */ + pdx->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ dev_err(&pdx->interface->dev, "%s submit urb failed: %d", __func__, iReturn); } else - pdx->bReadCharsPending = true; // Flag that we are active here + pdx->bReadCharsPending = true; /* Flag that we are active here */ } spin_unlock_irqrestore(&pdx->charInLock, flags); @@ -1238,15 +1238,15 @@ static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long ulArg) { int err = 0; DEVICE_EXTENSION *pdx = file->private_data; - if (!CanAcceptIoRequests(pdx)) // check we still exist + if (!CanAcceptIoRequests(pdx)) /* check we still exist */ return -ENODEV; - // Check that access is allowed, where is is needed. Anything that would have an indeterminate - // size will be checked by the specific command. - if (_IOC_DIR(cmd) & _IOC_READ) // read from point of view of user... - err = !access_ok(VERIFY_WRITE, (void __user *)ulArg, _IOC_SIZE(cmd)); // is kernel write - else if (_IOC_DIR(cmd) & _IOC_WRITE) // and write from point of view of user... - err = !access_ok(VERIFY_READ, (void __user *)ulArg, _IOC_SIZE(cmd)); // is kernel read + /* Check that access is allowed, where is is needed. Anything that would have an indeterminate */ + /* size will be checked by the specific command. */ + if (_IOC_DIR(cmd) & _IOC_READ) /* read from point of view of user... */ + err = !access_ok(VERIFY_WRITE, (void __user *)ulArg, _IOC_SIZE(cmd)); /* is kernel write */ + else if (_IOC_DIR(cmd) & _IOC_WRITE) /* and write from point of view of user... */ + err = !access_ok(VERIFY_READ, (void __user *)ulArg, _IOC_SIZE(cmd)); /* is kernel read */ if (err) return -EFAULT; @@ -1289,7 +1289,7 @@ static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long ulArg) return -1; case _IOC_NR(IOCTL_CED_GETDRIVERREVISION): - return (2 << 24) | (DRIVERMAJREV << 16) | DRIVERMINREV; // USB | MAJOR | MINOR + return (2 << 24) | (DRIVERMAJREV << 16) | DRIVERMINREV; /* USB | MAJOR | MINOR */ case _IOC_NR(IOCTL_CED_GETTRANSFER): return GetTransfer(pdx, (TGET_TX_BLOCK __user *) ulArg); @@ -1335,7 +1335,7 @@ static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long ulArg) return DbgStopLoop(pdx); case _IOC_NR(IOCTL_CED_FULLRESET): - pdx->bForceReset = true; // Set a flag for a full reset + pdx->bForceReset = true; /* Set a flag for a full reset */ break; case _IOC_NR(IOCTL_CED_SETCIRCULAR): @@ -1378,8 +1378,8 @@ static struct usb_class_driver ced_class = { .minor_base = USB_CED_MINOR_BASE, }; -// Check that the device that matches a 1401 vendor and product ID is OK to use and -// initialise our DEVICE_EXTENSION. +/* Check that the device that matches a 1401 vendor and product ID is OK to use and */ +/* initialise our DEVICE_EXTENSION. */ static int ced_probe(struct usb_interface *interface, const struct usb_device_id *id) { @@ -1389,23 +1389,23 @@ static int ced_probe(struct usb_interface *interface, int i, bcdDevice; int retval = -ENOMEM; - // allocate memory for our device extension and initialize it + /* allocate memory for our device extension and initialize it */ pdx = kzalloc(sizeof(*pdx), GFP_KERNEL); if (!pdx) 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); } - // Put initialises for our stuff here. Note that all of *pdx is zero, so - // no need to explicitly zero it. + /* Put initialises for our stuff here. Note that all of *pdx is zero, so */ + /* no need to explicitly zero it. */ spin_lock_init(&pdx->charOutLock); spin_lock_init(&pdx->charInLock); spin_lock_init(&pdx->stagedLock); - // Initialises from the skeleton stuff + /* Initialises from the skeleton stuff */ kref_init(&pdx->kref); mutex_init(&pdx->io_mutex); spin_lock_init(&pdx->err_lock); @@ -1414,7 +1414,7 @@ static int ced_probe(struct usb_interface *interface, pdx->udev = usb_get_dev(interface_to_usbdev(interface)); pdx->interface = interface; - // Attempt to identify the device + /* Attempt to identify the device */ bcdDevice = pdx->udev->descriptor.bcdDevice; i = (bcdDevice >> 8); if (i == 0) @@ -1426,8 +1426,8 @@ static int ced_probe(struct usb_interface *interface, __func__, bcdDevice); goto error; } - // set up the endpoint information. We only care about the number of EP as - // we know that we are dealing with a 1401 device. + /* set up the endpoint information. We only care about the number of EP as */ + /* we know that we are dealing with a 1401 device. */ iface_desc = interface->cur_altsetting; pdx->nPipes = iface_desc->desc.bNumEndpoints; dev_info(&interface->dev, "1401Type=%d with %d End Points", @@ -1435,10 +1435,10 @@ static int ced_probe(struct usb_interface *interface, if ((pdx->nPipes < 3) || (pdx->nPipes > 4)) goto error; - // Allocate the URBs we hold for performing transfers - pdx->pUrbCharOut = usb_alloc_urb(0, GFP_KERNEL); // character output URB - pdx->pUrbCharIn = usb_alloc_urb(0, GFP_KERNEL); // character input URB - pdx->pStagedUrb = usb_alloc_urb(0, GFP_KERNEL); // block transfer URB + /* Allocate the URBs we hold for performing transfers */ + pdx->pUrbCharOut = usb_alloc_urb(0, GFP_KERNEL); /* character output URB */ + pdx->pUrbCharIn = usb_alloc_urb(0, GFP_KERNEL); /* character input URB */ + pdx->pStagedUrb = usb_alloc_urb(0, GFP_KERNEL); /* block transfer URB */ if (!pdx->pUrbCharOut || !pdx->pUrbCharIn || !pdx->pStagedUrb) { dev_err(&interface->dev, "%s URB alloc failed", __func__); goto error; @@ -1464,14 +1464,14 @@ static int ced_probe(struct usb_interface *interface, pdx->epAddr[i] = endpoint->bEndpointAddress; dev_info(&interface->dev, "Pipe %d, ep address %02x", i, pdx->epAddr[i]); - if (((pdx->nPipes == 3) && (i == 0)) || // if char input end point + if (((pdx->nPipes == 3) && (i == 0)) || /* if char input end point */ ((pdx->nPipes == 4) && (i == 1))) { - pdx->bInterval = endpoint->bInterval; // save the endpoint interrupt interval + pdx->bInterval = endpoint->bInterval; /* save the endpoint interrupt interval */ dev_info(&interface->dev, "Pipe %d, bInterval = %d", i, pdx->bInterval); } - // Detect USB2 by checking last ep size (64 if USB1) - if (i == pdx->nPipes - 1) // if this is the last ep (bulk) + /* Detect USB2 by checking last ep size (64 if USB1) */ + if (i == pdx->nPipes - 1) /* if this is the last ep (bulk) */ { pdx->bIsUSB2 = le16_to_cpu(endpoint->wMaxPacketSize) > 64; @@ -1501,7 +1501,7 @@ static int ced_probe(struct usb_interface *interface, error: if (pdx) - kref_put(&pdx->kref, ced_delete); // frees allocated memory + kref_put(&pdx->kref, ced_delete); /* frees allocated memory */ return retval; } @@ -1511,31 +1511,31 @@ static void ced_disconnect(struct usb_interface *interface) int minor = interface->minor; int i; - usb_set_intfdata(interface, NULL); // remove the pdx from the interface - usb_deregister_dev(interface, &ced_class); // give back our minor device number + usb_set_intfdata(interface, NULL); /* remove the pdx from the interface */ + usb_deregister_dev(interface, &ced_class); /* give back our minor device number */ - mutex_lock(&pdx->io_mutex); // stop more I/O starting while... - ced_draw_down(pdx); // ...wait for then kill any io + mutex_lock(&pdx->io_mutex); /* stop more I/O starting while... */ + ced_draw_down(pdx); /* ...wait for then kill any io */ for (i = 0; i < MAX_TRANSAREAS; ++i) { - int iErr = ClearArea(pdx, i); // ...release any used memory + int iErr = ClearArea(pdx, i); /* ...release any used memory */ if (iErr == U14ERR_UNLOCKFAIL) dev_err(&pdx->interface->dev, "%s Area %d was in used", __func__, i); } - pdx->interface = NULL; // ...we kill off link to interface + pdx->interface = NULL; /* ...we kill off link to interface */ mutex_unlock(&pdx->io_mutex); usb_kill_anchored_urbs(&pdx->submitted); - kref_put(&pdx->kref, ced_delete); // decrement our usage count + kref_put(&pdx->kref, ced_delete); /* decrement our usage count */ dev_info(&interface->dev, "USB cedusb #%d now disconnected", minor); } -// Wait for all the urbs we know of to be done with, then kill off any that -// are left. NBNB we will need to have a mechanism to stop circular xfers -// from trying to fire off more urbs. We will wait up to 3 seconds for Urbs -// to be done. +/* Wait for all the urbs we know of to be done with, then kill off any that */ +/* are left. NBNB we will need to have a mechanism to stop circular xfers */ +/* from trying to fire off more urbs. We will wait up to 3 seconds for Urbs */ +/* to be done. */ void ced_draw_down(DEVICE_EXTENSION * pdx) { int time; @@ -1543,7 +1543,7 @@ void ced_draw_down(DEVICE_EXTENSION * pdx) pdx->bInDrawDown = true; time = usb_wait_anchor_empty_timeout(&pdx->submitted, 3000); - if (!time) { // if we timed out we kill the urbs + if (!time) { /* if we timed out we kill the urbs */ usb_kill_anchored_urbs(&pdx->submitted); dev_err(&pdx->interface->dev, "%s timed out", __func__); } diff --git a/drivers/staging/ced1401/usb1401.h b/drivers/staging/ced1401/usb1401.h index 8fc6958b6f08..ed4c761ba42b 100644 --- a/drivers/staging/ced1401/usb1401.h +++ b/drivers/staging/ced1401/usb1401.h @@ -26,31 +26,32 @@ #define UINT unsigned int #endif -/// Device type codes, but these don't need to be extended - a succession is assumed -/// These are set for usb from the bcdDevice field (suitably mangled). Future devices -/// will be added in order of device creation to the list, so the names here are just -/// to help use remember which device is which. The U14ERR_... values follow the same -/// pattern for modern devices. -#define TYPEUNKNOWN -1 // dont know -#define TYPE1401 0 // standard 1401 -#define TYPEPLUS 1 // 1401 plus -#define TYPEU1401 2 // u1401 -#define TYPEPOWER 3 // Power1401 -#define TYPEU14012 4 // u1401 mkII -#define TYPEPOWER2 5 // Power1401 mk II -#define TYPEMICRO3 6 // Micro1401-3 -#define TYPEPOWER3 7 // Power1401-3 - -/// Some useful defines of constants. DONT FORGET to change the version in the -/// resources whenever you change it here!. -#define DRIVERMAJREV 2 // driver revision level major (match windows) -#define DRIVERMINREV 0 // driver revision level minor - -/// Definitions of the various block transfer command codes -#define TM_EXTTOHOST 8 // extended tohost -#define TM_EXTTO1401 9 // extended to1401 - -/// Definitions of values in usbReqtype. Used in sorting out setup actions +/** Device type codes, but these don't need to be extended - a succession is assumed +** These are set for usb from the bcdDevice field (suitably mangled). Future devices +** will be added in order of device creation to the list, so the names here are just +** to help use remember which device is which. The U14ERR_... values follow the same +** pattern for modern devices.a +**/ +#define TYPEUNKNOWN -1 /* dont know */ +#define TYPE1401 0 /* standard 1401 */ +#define TYPEPLUS 1 /* 1401 plus */ +#define TYPEU1401 2 /* u1401 */ +#define TYPEPOWER 3 /* Power1401 */ +#define TYPEU14012 4 /* u1401 mkII */ +#define TYPEPOWER2 5 /* Power1401 mk II */ +#define TYPEMICRO3 6 /* Micro1401-3 */ +#define TYPEPOWER3 7 /* Power1401-3 */ + +/* Some useful defines of constants. DONT FORGET to change the version in the */ +/* resources whenever you change it here!. */ +#define DRIVERMAJREV 2 /* driver revision level major (match windows) */ +#define DRIVERMINREV 0 /* driver revision level minor */ + +/* Definitions of the various block transfer command codes */ +#define TM_EXTTOHOST 8 /* extended tohost */ +#define TM_EXTTO1401 9 /* extended to1401 */ + +/* Definitions of values in usbReqtype. Used in sorting out setup actions */ #define H_TO_D 0x00 #define D_TO_H 0x80 #define VENDOR 0x40 @@ -58,7 +59,7 @@ #define INTREQ 0x01 #define ENDREQ 0x02 -/// Definition of values in usbRequest, again used to sort out setup +/* Definition of values in usbRequest, again used to sort out setup */ #define GET_STATUS 0x00 #define CLEAR_FEATURE 0x01 #define SET_FEATURE 0x03 @@ -71,8 +72,8 @@ #define SET_INTERFACE 0x0b #define SYNCH_FRAME 0x0c -/// Definitions of the various debug command codes understood by the 1401. These -/// are used in various vendor-specific commands to achieve the desired effect +/* Definitions of the various debug command codes understood by the 1401. These */ +/* are used in various vendor-specific commands to achieve the desired effect */ #define DB_GRAB 0x50 /* Grab is a NOP for USB */ #define DB_FREE 0x51 /* Free is a NOP for the USB */ #define DB_SETADD 0x52 /* Set debug address (double) */ @@ -91,35 +92,35 @@ #define CR_CHAR 0x0D /* The carriage return character */ #define CR_CHAR_80 0x8d /* and with bit 7 set */ -/// A structure holding information about a block of memory for use in circular transfers +/* A structure holding information about a block of memory for use in circular transfers */ typedef struct circBlk { volatile UINT dwOffset; /* Offset within area of block start */ volatile UINT dwSize; /* Size of the block, in bytes (0 = unused) */ } CIRCBLK; -/// A structure holding all of the information about a transfer area - an area of -/// memory set up for use either as a source or destination in DMA transfers. +/* A structure holding all of the information about a transfer area - an area of */ +/* memory set up for use either as a source or destination in DMA transfers. */ typedef struct transarea { - void* lpvBuff; // User address of xfer area saved for completeness - UINT dwBaseOffset; // offset to start of xfer area in first page - UINT dwLength; // Length of xfer area, in bytes - struct page **pPages; // Points at array of locked down pages - int nPages; // number of pages that are locked down - bool bUsed; // Is this structure in use? - bool bCircular; // Is this area for circular transfers? - bool bCircToHost; // Flag for direction of circular transfer - bool bEventToHost; // Set event on transfer to host? - int iWakeUp; // Set 1 on event, cleared by TestEvent() - UINT dwEventSt; // Defines section within xfer area for... - UINT dwEventSz; // ...notification by the event SZ is 0 if unset - CIRCBLK aBlocks[2]; // Info on a pair of circular blocks - wait_queue_head_t wqEvent; // The wait queue for events in this area MUST BE LAST + void* lpvBuff; /* User address of xfer area saved for completeness */ + UINT dwBaseOffset; /* offset to start of xfer area in first page */ + UINT dwLength; /* Length of xfer area, in bytes */ + struct page **pPages; /* Points at array of locked down pages */ + int nPages; /* number of pages that are locked down */ + bool bUsed; /* Is this structure in use? */ + bool bCircular; /* Is this area for circular transfers? */ + bool bCircToHost; /* Flag for direction of circular transfer */ + bool bEventToHost; /* Set event on transfer to host? */ + int iWakeUp; /* Set 1 on event, cleared by TestEvent() */ + UINT dwEventSt; /* Defines section within xfer area for... */ + UINT dwEventSz; /* ...notification by the event SZ is 0 if unset */ + CIRCBLK aBlocks[2]; /* Info on a pair of circular blocks */ + wait_queue_head_t wqEvent; /* The wait queue for events in this area MUST BE LAST */ } TRANSAREA; -/// The DMADESC structure is used to hold information on the transfer in progress. It -/// is set up by ReadDMAInfo, using information sent by the 1401 in an escape sequence. +/* The DMADESC structure is used to hold information on the transfer in progress. It */ +/* is set up by ReadDMAInfo, using information sent by the 1401 in an escape sequence. */ typedef struct dmadesc { unsigned short wTransType; /* transfer type as TM_xxx above */ @@ -131,10 +132,10 @@ typedef struct dmadesc #define INBUF_SZ 256 /* input buffer size */ #define OUTBUF_SZ 256 /* output buffer size */ -#define STAGED_SZ 0x10000 // size of coherent buffer for staged transfers +#define STAGED_SZ 0x10000 /* size of coherent buffer for staged transfers */ -/// Structure to hold all of our device specific stuff. We are making this as similar as we -/// can to the Windows driver to help in our understanding of what is going on. +/* Structure to hold all of our device specific stuff. We are making this as similar as we */ +/* can to the Windows driver to help in our understanding of what is going on. */ typedef struct _DEVICE_EXTENSION { char inputBuffer[INBUF_SZ]; /* The two buffers */ @@ -159,58 +160,58 @@ typedef struct _DEVICE_EXTENSION volatile unsigned int dwDMAFlag; /* state of DMA */ TRANSAREA rTransDef[MAX_TRANSAREAS];/* transfer area info */ - volatile DMADESC rDMAInfo; // info on current DMA transfer - volatile bool bXFerWaiting; // Flag set if DMA transfer stalled - volatile bool bInDrawDown; // Flag that we want to halt transfers - - // Parameters relating to a block read\write that is in progress. Some of these values - // are equivalent to values in rDMAInfo. The values here are those in use, while those - // in rDMAInfo are those received from the 1401 via an escape sequence. If another - // escape sequence arrives before the previous xfer ends, rDMAInfo values are updated while these - // are used to finish off the current transfer. - volatile short StagedId; // The transfer area id for this transfer - volatile bool StagedRead; // Flag TRUE for read from 1401, FALSE for write - volatile unsigned int StagedLength; // Total length of this transfer - volatile unsigned int StagedOffset; // Offset within memory area for transfer start - volatile unsigned int StagedDone; // Bytes transferred so far - volatile bool bStagedUrbPending; // Flag to indicate active - char* pCoherStagedIO; // buffer used for block transfers - struct urb* pStagedUrb; // The URB to use - spinlock_t stagedLock; // protects ReadWriteMem() and circular buffer stuff - - short s1401Type; // type of 1401 attached - short sCurrentState; // current error state - bool bIsUSB2; // type of the interface we connect to - bool bForceReset; // Flag to make sure we get a real reset - __u32 statBuf[2]; // buffer for 1401 state info - - unsigned long ulSelfTestTime; // used to timeout self test - - int nPipes; // Should be 3 or 4 depending on 1401 usb chip - int bPipeError[4]; // set non-zero if an error on one of the pipe - __u8 epAddr[4]; // addresses of the 3/4 end points - - struct usb_device *udev; // the usb device for this device - struct usb_interface *interface; // the interface for this device, NULL if removed - struct usb_anchor submitted; // in case we need to retract our submissions - struct mutex io_mutex; // synchronize I/O with disconnect, one user-mode caller at a time - - int errors; // the last request tanked - int open_count; // count the number of openers - spinlock_t err_lock; // lock for errors + volatile DMADESC rDMAInfo; /* info on current DMA transfer */ + volatile bool bXFerWaiting; /* Flag set if DMA transfer stalled */ + volatile bool bInDrawDown; /* Flag that we want to halt transfers */ + + /* Parameters relating to a block read\write that is in progress. Some of these values */ + /* are equivalent to values in rDMAInfo. The values here are those in use, while those */ + /* in rDMAInfo are those received from the 1401 via an escape sequence. If another */ + /* escape sequence arrives before the previous xfer ends, rDMAInfo values are updated while these */ + /* are used to finish off the current transfer. */ + volatile short StagedId; /* The transfer area id for this transfer */ + volatile bool StagedRead; /* Flag TRUE for read from 1401, FALSE for write */ + volatile unsigned int StagedLength; /* Total length of this transfer */ + volatile unsigned int StagedOffset; /* Offset within memory area for transfer start */ + volatile unsigned int StagedDone; /* Bytes transferred so far */ + volatile bool bStagedUrbPending; /* Flag to indicate active */ + char* pCoherStagedIO; /* buffer used for block transfers */ + struct urb* pStagedUrb; /* The URB to use */ + spinlock_t stagedLock; /* protects ReadWriteMem() and circular buffer stuff */ + + short s1401Type; /* type of 1401 attached */ + short sCurrentState; /* current error state */ + bool bIsUSB2; /* type of the interface we connect to */ + bool bForceReset; /* Flag to make sure we get a real reset */ + __u32 statBuf[2]; /* buffer for 1401 state info */ + + unsigned long ulSelfTestTime; /* used to timeout self test */ + + int nPipes; /* Should be 3 or 4 depending on 1401 usb chip */ + int bPipeError[4]; /* set non-zero if an error on one of the pipe */ + __u8 epAddr[4]; /* addresses of the 3/4 end points */ + + struct usb_device *udev; /* the usb device for this device */ + struct usb_interface *interface; /* the interface for this device, NULL if removed */ + struct usb_anchor submitted; /* in case we need to retract our submissions */ + struct mutex io_mutex; /* synchronize I/O with disconnect, one user-mode caller at a time */ + + int errors; /* the last request tanked */ + int open_count; /* count the number of openers */ + spinlock_t err_lock; /* lock for errors */ struct kref kref; }DEVICE_EXTENSION, *PDEVICE_EXTENSION; #define to_DEVICE_EXTENSION(d) container_of(d, DEVICE_EXTENSION, kref) -/// Definitions of routimes used between compilation object files -// in usb1401.c +/* Definitions of routimes used between compilation object files */ +/* in usb1401.c */ extern int Allowi(DEVICE_EXTENSION* pdx); extern int SendChars(DEVICE_EXTENSION* pdx); extern void ced_draw_down(DEVICE_EXTENSION *pdx); extern int ReadWriteMem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent, unsigned int dwOffs, unsigned int dwLen); -// in ced_ioc.c +/* in ced_ioc.c */ extern int ClearArea(DEVICE_EXTENSION *pdx, int nArea); extern int SendString(DEVICE_EXTENSION* pdx, const char __user* pData, unsigned int n); extern int SendChar(DEVICE_EXTENSION *pdx, char c); diff --git a/drivers/staging/ced1401/use1401.h b/drivers/staging/ced1401/use1401.h index 86294e21db0c..facba315cfd1 100644 --- a/drivers/staging/ced1401/use1401.h +++ b/drivers/staging/ced1401/use1401.h @@ -11,10 +11,10 @@ #define __USE1401_H__ #include "machine.h" -// Some definitions to make things compatible. If you want to use Use1401 directly -// from a Windows program you should define U14_NOT_DLL, in which case you also -// MUST make sure that your application startup code calls U14InitLib(). -// DLL_USE1401 is defined when you are building the Use1401 dll, not otherwise. +/* Some definitions to make things compatible. If you want to use Use1401 directly */ +/* from a Windows program you should define U14_NOT_DLL, in which case you also */ +/* MUST make sure that your application startup code calls U14InitLib(). */ +/* DLL_USE1401 is defined when you are building the Use1401 dll, not otherwise. */ #ifdef _IS_WINDOWS_ #ifndef U14_NOT_DLL #ifdef DLL_USE1401 @@ -50,20 +50,20 @@ #define U14LONG long #endif -/// Error codes: We need them here as user space can see them. -#define U14ERR_NOERROR 0 // no problems +/* Error codes: We need them here as user space can see them. */ +#define U14ERR_NOERROR 0 /* no problems */ -/// Device error codes, but these don't need to be extended - a succession is assumed -#define U14ERR_STD 4 // standard 1401 connected -#define U14ERR_U1401 5 // u1401 connected -#define U14ERR_PLUS 6 // 1401 plus connected -#define U14ERR_POWER 7 // Power1401 connected -#define U14ERR_U14012 8 // u1401 mkII connected +/* Device error codes, but these don't need to be extended - a succession is assumed */ +#define U14ERR_STD 4 /* standard 1401 connected */ +#define U14ERR_U1401 5 /* u1401 connected */ +#define U14ERR_PLUS 6 /* 1401 plus connected */ +#define U14ERR_POWER 7 /* Power1401 connected */ +#define U14ERR_U14012 8 /* u1401 mkII connected */ #define U14ERR_POWER2 9 #define U14ERR_U14013 10 #define U14ERR_POWER3 11 -/// NBNB Error numbers need shifting as some linux error codes start at 512 +/* NBNB Error numbers need shifting as some linux error codes start at 512 */ #define U14ERR(n) (n+U14ERRBASE) #define U14ERR_OFF U14ERR(0) /* 1401 there but switched off */ #define U14ERR_NC U14ERR(-1) /* 1401 not connected */ @@ -113,7 +113,7 @@ #define U14ERR_DRIVCOMMS U14ERR(-110) /* failed talking to driver */ #define U14ERR_OUTOFMEMORY U14ERR(-111) /* needed memory and couldnt get it*/ -/// 1401 type codes. +/* / 1401 type codes. */ #define U14TYPE1401 0 /* standard 1401 */ #define U14TYPEPLUS 1 /* 1401 plus */ #define U14TYPEU1401 2 /* u1401 */ @@ -124,9 +124,9 @@ #define U14TYPEPOWER3 7 /* power1401-3 */ #define U14TYPEUNKNOWN -1 /* dont know */ -/// Transfer flags to allow driver capabilities to be interrogated +/* Transfer flags to allow driver capabilities to be interrogated */ -/// Constants for transfer flags +/* Constants for transfer flags */ #define U14TF_USEDMA 1 /* Transfer flag for use DMA */ #define U14TF_MULTIA 2 /* Transfer flag for multi areas */ #define U14TF_FIFO 4 /* for FIFO interface card */ @@ -138,18 +138,18 @@ #define U14TF_DIAG 256 /* Diagnostics/debug functions */ #define U14TF_CIRC14 512 /* Circular-mode to 1401 */ -/// Definitions of element sizes for DMA transfers - to allow byte-swapping +/* Definitions of element sizes for DMA transfers - to allow byte-swapping */ #define ESZBYTES 0 /* BYTE element size value */ #define ESZWORDS 1 /* WORD element size value */ #define ESZLONGS 2 /* long element size value */ #define ESZUNKNOWN 0 /* unknown element size value */ -/// These define required access types for the debug/diagnostics function +/* These define required access types for the debug/diagnostics function */ #define BYTE_SIZE 1 /* 8-bit access */ #define WORD_SIZE 2 /* 16-bit access */ #define LONG_SIZE 3 /* 32-bit access */ -/// Stuff used by U14_GetTransfer +/* Stuff used by U14_GetTransfer */ #define GET_TX_MAXENTRIES 257 /* (max length / page size + 1) */ #ifdef _IS_WINDOWS_ @@ -200,8 +200,8 @@ typedef struct TGetTxBlock /* used for U14_GetTransfer results */ extern "C" { #endif -U14API(int) U14WhenToTimeOut(short hand); // when to timeout in ms -U14API(short) U14PassedTime(int iTime); // non-zero if iTime passed +U14API(int) U14WhenToTimeOut(short hand); /* when to timeout in ms */ +U14API(short) U14PassedTime(int iTime); /* non-zero if iTime passed */ U14API(short) U14LastErrCode(short hand); diff --git a/drivers/staging/ced1401/use14_ioc.h b/drivers/staging/ced1401/use14_ioc.h index 15ca63888380..7e9d587262bb 100644 --- a/drivers/staging/ced1401/use14_ioc.h +++ b/drivers/staging/ced1401/use14_ioc.h @@ -246,7 +246,7 @@ METHOD_BUFFERED, \ FILE_ANY_ACCESS) -//--------------- Structures that are shared with the driver ------------- +/*--------------- Structures that are shared with the driver ------------- */ #pragma pack(1) typedef struct /* used for get/set standard 1401 registers */ @@ -298,4 +298,4 @@ typedef struct VXTransferDesc /* use1401.c and use1432x.x use only */ #pragma pack() -#endif \ No newline at end of file +#endif -- 2.11.0