Skip to content

L
linux
Commit e4837704 authored by Elena Ufimtseva's avatar Elena Ufimtseva Committed by Greg Kroah-Hartman
Browse files
Options

Staging: ced1401: Fixes C99 // comments. 

Patch fixes checkpatch warnings about C99 // comments.
Signed-off-by: default avatarElena Ufimtseva <ufimtseva@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent d7e09d03
Hide whitespace changes
Inline Side-by-side
Showing with 671 additions and 667 deletions
drivers/staging/ced1401/ced_ioc.c
View file @ e4837704
......@@ -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(&current->mm->mmap_sem); // get memory map semaphore
/* To pin down user pages we must first acquire the mapping semaphore. */
down_read(&current->mm->mmap_sem); /* get memory map semaphore */
nPages =
get_user_pages(current, current->mm, ulStart, len, 1, 0, pPages, 0);
up_read(&current->mm->mmap_sem); // release the semaphore
up_read(&current->mm->mmap_sem); /* release the semaphore */
dev_dbg(&pdx->interface->dev, "%s nPages = %d", __func__, nPages);
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,
......
drivers/staging/ced1401/machine.h
View file @ e4837704
......@@ -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;
......
drivers/staging/ced1401/usb1401.c
View file @ e4837704
......@@ -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__);
}
......
drivers/staging/ced1401/usb1401.h
View file @ e4837704
......@@ -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);
......
drivers/staging/ced1401/use1401.h
View file @ e4837704
......@@ -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);
......
drivers/staging/ced1401/use14_ioc.h
View file @ e4837704
......@@ -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
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7