Hi Greg,
FYI, there are new smatch warnings show up in
tree: git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git staging-next
head: e1878957b4676a17cf398f7f5723b365e9a2ca48
commit: 74f5671442c6e9b2b54137d20fd7789078265897 [120/274] Staging: ced1401: fix copy_from/to_user warning messages
drivers/staging/ced1401/ced_ioc.c:844 WaitEvent() warn: buffer overflow 'pdx->rTransDef' 8 <= 8
drivers/staging/ced1401/ced_ioc.c:875 WaitEvent() warn: inconsistent returns mutex:&pdx->io_mutex: locked (853) unlocked (841,875)
drivers/staging/ced1401/ced_ioc.c:890 TestEvent() warn: buffer overflow 'pdx->rTransDef' 8 <= 8
drivers/staging/ced1401/ced_ioc.c:916 GetTransfer() warn: 'tx' puts 3104 bytes on stack
drivers/staging/ced1401/ced_ioc.c:926 GetTransfer() warn: check that 'tx.seg' doesn't leak information
drivers/staging/ced1401/ced_ioc.c:1078 CheckSelfTest() warn: check that 'gst.code' doesn't leak information
+ drivers/staging/ced1401/ced_ioc.c:1514 FreeCircBlock() warn: inconsistent returns mutex:&pdx->io_mutex: locked (1511) unlocked (1423,1514)
vim +1514 drivers/staging/ced1401/ced_ioc.c
cd915200 Greg Kroah-Hartman 2012-09-17 1417 unsigned int nArea, uStart, uSize;
cd915200 Greg Kroah-Hartman 2012-09-17 1418 TCIRCBLOCK cb;
74f56714 Greg Kroah-Hartman 2012-09-17 1419
cd915200 Greg Kroah-Hartman 2012-09-17 1420 dev_dbg(&pdx->interface->dev, "%s", __func__);
74f56714 Greg Kroah-Hartman 2012-09-17 1421
74f56714 Greg Kroah-Hartman 2012-09-17 1422 if (copy_from_user(&cb, pCB, sizeof(cb)))
74f56714 Greg Kroah-Hartman 2012-09-17 @1423 return -EFAULT;
74f56714 Greg Kroah-Hartman 2012-09-17 1424
cd915200 Greg Kroah-Hartman 2012-09-17 1425 mutex_lock(&pdx->io_mutex);
cd915200 Greg Kroah-Hartman 2012-09-17 1426
cd915200 Greg Kroah-Hartman 2012-09-17 1427 nArea = cb.nArea; // Retrieve parameters first
cd915200 Greg Kroah-Hartman 2012-09-17 1428 uStart = cb.dwOffset;
cd915200 Greg Kroah-Hartman 2012-09-17 1429 uSize = cb.dwSize;
cd915200 Greg Kroah-Hartman 2012-09-17 1430 cb.dwOffset = 0; // then set default result (nothing)
cd915200 Greg Kroah-Hartman 2012-09-17 1431 cb.dwSize = 0;
cd915200 Greg Kroah-Hartman 2012-09-17 1432
cd915200 Greg Kroah-Hartman 2012-09-17 1433 if (nArea < MAX_TRANSAREAS) // The area number must be OK
cd915200 Greg Kroah-Hartman 2012-09-17 1434 {
cd915200 Greg Kroah-Hartman 2012-09-17 1435 TRANSAREA *pArea = &pdx->rTransDef[nArea]; // Pointer to relevant info
cd915200 Greg Kroah-Hartman 2012-09-17 1436 spin_lock_irq(&pdx->stagedLock); // Lock others out
cd915200 Greg Kroah-Hartman 2012-09-17 1437
cd915200 Greg Kroah-Hartman 2012-09-17 1438 if ((pArea->bUsed) && (pArea->bCircular) && // Must be circular area
cd915200 Greg Kroah-Hartman 2012-09-17 1439 (pArea->bCircToHost)) // For now at least must be to host
cd915200 Greg Kroah-Hartman 2012-09-17 1440 {
cd915200 Greg Kroah-Hartman 2012-09-17 1441 bool bWaiting = false;
cd915200 Greg Kroah-Hartman 2012-09-17 1442
cd915200 Greg Kroah-Hartman 2012-09-17 1443 if ((pArea->aBlocks[0].dwSize >= uSize) && // Got anything?
cd915200 Greg Kroah-Hartman 2012-09-17 1444 (pArea->aBlocks[0].dwOffset == uStart)) // Must be legal data
cd915200 Greg Kroah-Hartman 2012-09-17 1445 {
cd915200 Greg Kroah-Hartman 2012-09-17 1446 pArea->aBlocks[0].dwSize -= uSize;
cd915200 Greg Kroah-Hartman 2012-09-17 1447 pArea->aBlocks[0].dwOffset += uSize;
cd915200 Greg Kroah-Hartman 2012-09-17 1448 if (pArea->aBlocks[0].dwSize == 0) // Have we emptied this block?
cd915200 Greg Kroah-Hartman 2012-09-17 1449 {
cd915200 Greg Kroah-Hartman 2012-09-17 1450 if (pArea->aBlocks[1].dwSize) // Is there a second block?
cd915200 Greg Kroah-Hartman 2012-09-17 1451 {
cd915200 Greg Kroah-Hartman 2012-09-17 1452 pArea->aBlocks[0] = pArea->aBlocks[1]; // Copy down block 2 data
cd915200 Greg Kroah-Hartman 2012-09-17 1453 pArea->aBlocks[1].dwSize = 0; // and mark the second block as unused
cd915200 Greg Kroah-Hartman 2012-09-17 1454 pArea->aBlocks[1].dwOffset = 0;
cd915200 Greg Kroah-Hartman 2012-09-17 1455 } else
cd915200 Greg Kroah-Hartman 2012-09-17 1456 pArea->aBlocks[0].dwOffset = 0;
cd915200 Greg Kroah-Hartman 2012-09-17 1457 }
cd915200 Greg Kroah-Hartman 2012-09-17 1458
cd915200 Greg Kroah-Hartman 2012-09-17 1459 dev_dbg(&pdx->interface->dev,
cd915200 Greg Kroah-Hartman 2012-09-17 1460 "%s free %d bytes at %d, return %d bytes at %d, wait=%d",
cd915200 Greg Kroah-Hartman 2012-09-17 1461 __func__, uSize, uStart,
cd915200 Greg Kroah-Hartman 2012-09-17 1462 pArea->aBlocks[0].dwSize,
cd915200 Greg Kroah-Hartman 2012-09-17 1463 pArea->aBlocks[0].dwOffset,
cd915200 Greg Kroah-Hartman 2012-09-17 1464 pdx->bXFerWaiting);
cd915200 Greg Kroah-Hartman 2012-09-17 1465
cd915200 Greg Kroah-Hartman 2012-09-17 1466 // Return the next available block of memory as well
cd915200 Greg Kroah-Hartman 2012-09-17 1467 if (pArea->aBlocks[0].dwSize > 0) // Got anything?
cd915200 Greg Kroah-Hartman 2012-09-17 1468 {
cd915200 Greg Kroah-Hartman 2012-09-17 1469 cb.dwOffset =
cd915200 Greg Kroah-Hartman 2012-09-17 1470 pArea->aBlocks[0].dwOffset;
cd915200 Greg Kroah-Hartman 2012-09-17 1471 cb.dwSize = pArea->aBlocks[0].dwSize;
cd915200 Greg Kroah-Hartman 2012-09-17 1472 }
cd915200 Greg Kroah-Hartman 2012-09-17 1473
cd915200 Greg Kroah-Hartman 2012-09-17 1474 bWaiting = pdx->bXFerWaiting;
cd915200 Greg Kroah-Hartman 2012-09-17 1475 if (bWaiting && pdx->bStagedUrbPending) {
cd915200 Greg Kroah-Hartman 2012-09-17 1476 dev_err(&pdx->interface->dev,
cd915200 Greg Kroah-Hartman 2012-09-17 1477 "%s ERROR: waiting xfer and staged Urb pending!",
cd915200 Greg Kroah-Hartman 2012-09-17 1478 __func__);
cd915200 Greg Kroah-Hartman 2012-09-17 1479 bWaiting = false;
cd915200 Greg Kroah-Hartman 2012-09-17 1480 }
cd915200 Greg Kroah-Hartman 2012-09-17 1481 } else {
cd915200 Greg Kroah-Hartman 2012-09-17 1482 dev_err(&pdx->interface->dev,
cd915200 Greg Kroah-Hartman 2012-09-17 1483 "%s ERROR: freeing %d bytes at %d, block 0 is %d bytes at %d",
cd915200 Greg Kroah-Hartman 2012-09-17 1484 __func__, uSize, uStart,
cd915200 Greg Kroah-Hartman 2012-09-17 1485 pArea->aBlocks[0].dwSize,
cd915200 Greg Kroah-Hartman 2012-09-17 1486 pArea->aBlocks[0].dwOffset);
cd915200 Greg Kroah-Hartman 2012-09-17 1487 iReturn = U14ERR_NOMEMORY;
cd915200 Greg Kroah-Hartman 2012-09-17 1488 }
cd915200 Greg Kroah-Hartman 2012-09-17 1489
cd915200 Greg Kroah-Hartman 2012-09-17 1490 // If we have one, kick off pending transfer
cd915200 Greg Kroah-Hartman 2012-09-17 1491 if (bWaiting) // Got a block xfer waiting?
cd915200 Greg Kroah-Hartman 2012-09-17 1492 {
cd915200 Greg Kroah-Hartman 2012-09-17 1493 int RWMStat =
cd915200 Greg Kroah-Hartman 2012-09-17 1494 ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard,
cd915200 Greg Kroah-Hartman 2012-09-17 1495 pdx->rDMAInfo.wIdent,
cd915200 Greg Kroah-Hartman 2012-09-17 1496 pdx->rDMAInfo.dwOffset,
cd915200 Greg Kroah-Hartman 2012-09-17 1497 pdx->rDMAInfo.dwSize);
cd915200 Greg Kroah-Hartman 2012-09-17 1498 if (RWMStat != U14ERR_NOERROR)
cd915200 Greg Kroah-Hartman 2012-09-17 1499 dev_err(&pdx->interface->dev,
cd915200 Greg Kroah-Hartman 2012-09-17 1500 "%s rw setup failed %d",
cd915200 Greg Kroah-Hartman 2012-09-17 1501 __func__, RWMStat);
cd915200 Greg Kroah-Hartman 2012-09-17 1502 }
cd915200 Greg Kroah-Hartman 2012-09-17 1503 } else
cd915200 Greg Kroah-Hartman 2012-09-17 1504 iReturn = U14ERR_NOTSET;
cd915200 Greg Kroah-Hartman 2012-09-17 1505
cd915200 Greg Kroah-Hartman 2012-09-17 1506 spin_unlock_irq(&pdx->stagedLock);
cd915200 Greg Kroah-Hartman 2012-09-17 1507 } else
cd915200 Greg Kroah-Hartman 2012-09-17 1508 iReturn = U14ERR_BADAREA;
cd915200 Greg Kroah-Hartman 2012-09-17 1509
74f56714 Greg Kroah-Hartman 2012-09-17 1510 if (copy_to_user(pCB, &cb, sizeof(cb)))
74f56714 Greg Kroah-Hartman 2012-09-17 @1511 return -EFAULT;
74f56714 Greg Kroah-Hartman 2012-09-17 1512
cd915200 Greg Kroah-Hartman 2012-09-17 1513 mutex_unlock(&pdx->io_mutex);
cd915200 Greg Kroah-Hartman 2012-09-17 @1514 return iReturn;
2eae6bdc Alois Schlögl 2012-09-17 1515 }
---
0-DAY kernel build testing backend Open Source Technology Center
Fengguang Wu, Yuanhan Liu Intel Corporation
/* ced_ioc.c
ioctl part of the 1401 usb device driver for linux.
Copyright (C) 2010 Cambridge Electronic Design Ltd
Author Greg P Smith (greg@xxxxxxxxx)
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/uaccess.h>
#include <linux/usb.h>
#include <linux/mutex.h>
#include <linux/page-flags.h>
#include <linux/pagemap.h>
#include <linux/jiffies.h>
#include "usb1401.h"
/****************************************************************************
** FlushOutBuff
**
** Empties the Output buffer and sets int lines. Used from user level only
****************************************************************************/
void FlushOutBuff(DEVICE_EXTENSION * pdx)
{
dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__,
pdx->sCurrentState);
if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */
return;
// CharSend_Cancel(pdx); /* Kill off any pending I/O */
spin_lock_irq(&pdx->charOutLock);
pdx->dwNumOutput = 0;
pdx->dwOutBuffGet = 0;
pdx->dwOutBuffPut = 0;
spin_unlock_irq(&pdx->charOutLock);
}
/****************************************************************************
**
** FlushInBuff
**
** Empties the input buffer and sets int lines
****************************************************************************/
void FlushInBuff(DEVICE_EXTENSION * pdx)
{
dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__,
pdx->sCurrentState);
if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */
return;
// CharRead_Cancel(pDevObject); /* Kill off any pending I/O */
spin_lock_irq(&pdx->charInLock);
pdx->dwNumInput = 0;
pdx->dwInBuffGet = 0;
pdx->dwInBuffPut = 0;
spin_unlock_irq(&pdx->charInLock);
}
/****************************************************************************
** PutChars
**
** Utility routine to copy chars into the output buffer and fire them off.
** called from user mode, holds charOutLock.
****************************************************************************/
static int PutChars(DEVICE_EXTENSION * pdx, const char *pCh,
unsigned int uCount)
{
int iReturn;
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++) {
pdx->outputBuffer[pdx->dwOutBuffPut++] = pCh[u];
if (pdx->dwOutBuffPut >= OUTBUF_SZ)
pdx->dwOutBuffPut = 0;
}
pdx->dwNumOutput += uCount;
spin_unlock_irq(&pdx->charOutLock);
iReturn = SendChars(pdx); // ...give a chance to transmit data
} else {
iReturn = U14ERR_NOOUT; // no room at the out (ha-ha)
spin_unlock_irq(&pdx->charOutLock);
}
return iReturn;
}
/*****************************************************************************
** Add the data in pData (local pointer) of length n to the output buffer, and
** trigger an output transfer if this is appropriate. User mode.
** Holds the io_mutex
*****************************************************************************/
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
if (copy_from_user(buffer, pData, n))
return -EFAULT;
buffer[n] = 0; // terminate for debug purposes
mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o
if (n > 0) // do nothing if nowt to do!
{
dev_dbg(&pdx->interface->dev, "%s n=%d>%s<", __func__, n,
buffer);
iReturn = PutChars(pdx, buffer, n);
}
Allowi(pdx, false); // make sure we have input int
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** SendChar
**
** Sends a single character to the 1401. User mode, holds io_mutex.
****************************************************************************/
int SendChar(DEVICE_EXTENSION * pdx, char c)
{
int iReturn;
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, false); // Make sure char reads are running
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/***************************************************************************
**
** Get1401State
**
** Retrieves state information from the 1401, adjusts the 1401 state held
** in the device extension to indicate the current 1401 type.
**
** *state is updated with information about the 1401 state as returned by the
** 1401. The low byte is a code for what 1401 is doing:
**
** 0 normal 1401 operation
** 1 sending chars to host
** 2 sending block data to host
** 3 reading block data from host
** 4 sending an escape sequence to the host
** 0x80 1401 is executing self-test, in which case the upper word
** is the last error code seen (or zero for no new error).
**
** *error is updated with error information if a self-test error code
** is returned in the upper word of state.
**
** both state and error are set to -1 if there are comms problems, and
** to zero if there is a simple failure.
**
** return error code (U14ERR_NOERROR for OK)
*/
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
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
*error = 0;
} else {
int nDevice;
dev_dbg(&pdx->interface->dev,
"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
*error = pdx->statBuf[1];
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
if ((nDevice >= 1) && (nDevice <= 23))
pdx->sCurrentState = (short)(nDevice + 6);
else
pdx->sCurrentState = U14ERR_ILL;
break;
}
}
return pdx->sCurrentState >= 0 ? U14ERR_NOERROR : pdx->sCurrentState;
}
/****************************************************************************
** ReadWrite_Cancel
**
** Kills off staged read\write request from the USB if one is pending.
****************************************************************************/
int ReadWrite_Cancel(DEVICE_EXTENSION * pdx)
{
dev_dbg(&pdx->interface->dev, "ReadWrite_Cancel entry %d",
pdx->bStagedUrbPending);
#ifdef NOT_WRITTEN_YET
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
spin_lock_irq(&pdx->stagedLock);
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
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.
spin_unlock_irq(&pdx->stagedLock);
bResult = IoCancelIrp(pdx->pStagedIrp); // Actually do the cancel
if (bResult) {
LARGE_INTEGER timeout;
timeout.QuadPart = -10000000; // Use a timeout of 1 second
dev_info(&pdx->interface - dev,
"ReadWrite_Cancel about to wait till done");
ntStatus =
KeWaitForSingleObject(&pdx->StagingDoneEvent,
Executive, KernelMode, FALSE,
&timeout);
} else {
dev_info(&pdx->interface - dev,
"ReadWrite_Cancel, cancellation failed");
ntStatus = U14ERR_FAIL;
}
USB_KdPrint(DBGLVL_DEFAULT,
("ReadWrite_Cancel ntStatus = 0x%x decimal %d\n",
ntStatus, ntStatus));
} else
spin_unlock_irq(&pdx->stagedLock);
dev_info(&pdx->interface - dev, "ReadWrite_Cancel done");
return ntStatus;
#else
return U14ERR_NOERROR;
#endif
}
/***************************************************************************
** InSelfTest - utility to check in self test. Return 1 for ST, 0 for not or
** a -ve error code if we failed for some reason.
***************************************************************************/
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
return iReturn;
}
/***************************************************************************
** Is1401 - ALWAYS CALLED HOLDING THE io_mutex
**
** Tests for the current state of the 1401. Sets sCurrentState:
**
** U14ERR_NOIF 1401 i/f card not installed (not done here)
** U14ERR_OFF 1401 apparently not switched on
** U14ERR_NC 1401 appears to be not connected
** U14ERR_ILL 1401 if it is there its not very well at all
** U14ERR_TIME 1401 appears OK, but doesn't communicate - very bad
** U14ERR_STD 1401 OK and ready for use
** U14ERR_PLUS 1401+ OK and ready for use
** U14ERR_U1401 Micro1401 OK and ready for use
** U14ERR_POWER Power1401 OK and ready for use
** U14ERR_U14012 Micro1401 mkII OK and ready for use
**
** Returns TRUE if a 1401 detected and OK, else FALSE
****************************************************************************/
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
// The next call returns 0 if OK, but has returned 1 in the past, meaning that
// usb_unlock_device() is needed... now it always is
iReturn = usb_lock_device_for_reset(pdx->udev, pdx->interface);
// release the io_mutex because if we don't, we will deadlock due to system
// calls back into the driver.
mutex_unlock(&pdx->io_mutex); // locked, so we will not get system calls
if (iReturn >= 0) // if we failed
{
iReturn = usb_reset_device(pdx->udev); // try to do the reset
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
{
unsigned int state;
iReturn = InSelfTest(pdx, &state); // see if likely in self test
if (iReturn > 0) // do we need to wait for self-test?
{
unsigned long ulTimeOut = jiffies + 30 * HZ; // when to give up
while ((iReturn > 0) && time_before(jiffies, ulTimeOut)) {
schedule(); // let other stuff run
iReturn = InSelfTest(pdx, &state); // see if done yet
}
}
if (iReturn == 0) // if all is OK...
iReturn = state == 0; // then sucess is that the state is 0
} else
iReturn = 0; // we failed
pdx->bForceReset = false; // Clear forced reset flag now
return iReturn > 0;
}
/****************************************************************************
** QuickCheck - ALWAYS CALLED HOLDING THE io_mutex
** This is used to test for a 1401. It will try to do a quick check if all is
** OK, that is the 1401 was OK the last time it was asked, and there is no DMA
** in progress, and if the bTestBuff flag is set, the character buffers must be
** empty too. If the quick check shows that the state is still the same, then
** all is OK.
**
** If any of the above conditions are not met, or if the state or type of the
** 1401 has changed since the previous test, the full Is1401 test is done, but
** only if bCanReset is also TRUE.
**
** The return value is TRUE if a useable 1401 is found, FALSE if not
*/
bool QuickCheck(DEVICE_EXTENSION * pdx, bool bTestBuff, bool bCanReset)
{
bool bRet = false; // assume it will fail and we will reset
bool bShortTest;
bShortTest = ((pdx->dwDMAFlag == MODE_CHAR) && // no DMA running
(!pdx->bForceReset) && // Not had a real reset forced
(pdx->sCurrentState >= U14ERR_STD)); // No 1401 errors stored
dev_dbg(&pdx->interface->dev,
"%s DMAFlag:%d, state:%d, force:%d, testBuff:%d, short:%d",
__func__, pdx->dwDMAFlag, pdx->sCurrentState, pdx->bForceReset,
bTestBuff, bShortTest);
if ((bTestBuff) && // Buffer check requested, and...
(pdx->dwNumInput || pdx->dwNumOutput)) // ...characters were in the buffer?
{
bShortTest = false; // Then do the full test
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
unsigned int state, error;
dev_dbg(&pdx->interface->dev, "%s->Get1401State", __func__);
if (Get1401State(pdx, &state, &error) == U14ERR_NOERROR) // Check on the 1401 state
{
if ((state & 0xFF) == 0) // If call worked, check the status value
bRet = true; // If that was zero, all is OK, no reset needed
}
}
if (!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
}
return bRet;
}
/****************************************************************************
** Reset1401
**
** Resets the 1401 and empties the i/o buffers
*****************************************************************************/
int Reset1401(DEVICE_EXTENSION * pdx)
{
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
mutex_unlock(&pdx->io_mutex);
return U14ERR_NOERROR;
}
/****************************************************************************
** GetChar
**
** Gets a single character from the 1401
****************************************************************************/
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
dev_dbg(&pdx->interface->dev, "GetChar");
Allowi(pdx, false); // Make sure char reads are running
SendChars(pdx); // and send any buffered chars
spin_lock_irq(&pdx->charInLock);
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
spin_unlock_irq(&pdx->charInLock);
Allowi(pdx, false); // Make sure char reads are running
mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o
return iReturn;
}
/****************************************************************************
** GetString
**
** Gets a string from the 1401. Returns chars up to the next CR or when
** there are no more to read or nowhere to put them. CR is translated to
** 0 and counted as a character. If the string does not end in a 0, we will
** add one, if there is room, but it is not counted as a character.
**
** returns the count of characters (including the terminator, or 0 if none
** or a negative error code.
****************************************************************************/
int GetString(DEVICE_EXTENSION * pdx, char __user * pUser, int n)
{
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, false); // 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
if (nAvailable > 0) // worth looking?
{
char buffer[INBUF_SZ + 1]; // space for a linear copy of data
int nGot = 0;
int nCopyToUser; // number to copy to user
char cData;
do {
cData = pdx->inputBuffer[pdx->dwInBuffGet++];
if (cData == CR_CHAR) // replace CR with zero
cData = (char)0;
if (pdx->dwInBuffGet >= INBUF_SZ)
pdx->dwInBuffGet = 0; // wrap buffer pointer
buffer[nGot++] = cData; // save the output
}
while ((nGot < nAvailable) && cData);
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.
}
pdx->dwNumInput -= nGot;
spin_unlock_irq(&pdx->charInLock);
dev_dbg(&pdx->interface->dev,
"GetString read %d characters >%s<", nGot, buffer);
if (copy_to_user(pUser, buffer, nCopyToUser))
iReturn = -EFAULT;
else
iReturn = nGot; // report characters read
} else
spin_unlock_irq(&pdx->charInLock);
Allowi(pdx, false); // Make sure char reads are running
mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o
return iReturn;
}
/*******************************************************************************
** Get count of characters in the inout buffer.
*******************************************************************************/
int Stat1401(DEVICE_EXTENSION * pdx)
{
int iReturn;
mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o
Allowi(pdx, false); // 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;
}
/****************************************************************************
** LineCount
**
** Returns the number of newline chars in the buffer. There is no need for
** any fancy interlocks as we only read the interrupt routine data, and the
** system is arranged so nothing can be destroyed.
****************************************************************************/
int LineCount(DEVICE_EXTENSION * pdx)
{
int iReturn = 0; // will be count of line ends
mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o
Allowi(pdx, false); // Make sure char reads are running
SendChars(pdx); // and send any buffered chars
spin_lock_irq(&pdx->charInLock); // Get protection
if (pdx->dwNumInput > 0) // worth looking?
{
unsigned int dwIndex = pdx->dwInBuffGet; // start at first available
unsigned int dwEnd = pdx->dwInBuffPut; // Position for search end
do {
if (pdx->inputBuffer[dwIndex++] == CR_CHAR)
++iReturn; // inc count if CR
if (dwIndex >= INBUF_SZ) // see if we fall off buff
dwIndex = 0;
}
while (dwIndex != dwEnd); // go to last avaliable
}
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
return iReturn;
}
/****************************************************************************
** GetOutBufSpace
**
** Gets the space in the output buffer. Called from user code.
*****************************************************************************/
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
dev_dbg(&pdx->interface->dev, "OutBufSpace %d", iReturn);
mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o
return iReturn;
}
/****************************************************************************
**
** ClearArea
**
** Clears up a transfer area. This is always called in the context of a user
** request, never from a call-back.
****************************************************************************/
int ClearArea(DEVICE_EXTENSION * pdx, int nArea)
{
int iReturn = U14ERR_NOERROR;
if ((nArea < 0) || (nArea >= MAX_TRANSAREAS)) {
iReturn = U14ERR_BADAREA;
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
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
int np;
dev_dbg(&pdx->interface->dev, "%s area %d", __func__,
nArea);
spin_lock_irq(&pdx->stagedLock);
if ((pdx->StagedId == nArea)
&& (pdx->dwDMAFlag > MODE_CHAR)) {
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
if (pdx->bXFerWaiting
&& (pdx->rDMAInfo.wIdent == nArea))
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.
memset(pTA, 0,
sizeof(TRANSAREA) -
sizeof(wait_queue_head_t));
}
spin_unlock_irq(&pdx->stagedLock);
if (pPages) // if we decided to release the memory
{
// Now we must undo the pinning down of the pages. We will assume the worst and mark
// all the pages as dirty. Don't be tempted to move this up above as you must not be
// holding a spin lock to do this stuff as it is not atomic.
dev_dbg(&pdx->interface->dev, "%s nPages=%d",
__func__, nPages);
for (np = 0; np < nPages; ++np) {
if (pPages[np]) {
SetPageDirty(pPages[np]);
page_cache_release(pPages[np]);
}
}
kfree(pPages);
dev_dbg(&pdx->interface->dev,
"%s kfree(pPages) done", __func__);
}
}
}
return iReturn;
}
/****************************************************************************
** SetArea
**
** Sets up a transfer area - the functional part. Called by both
** SetTransfer and SetCircular.
****************************************************************************/
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.
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
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
// Now allocate space to hold the page pointer and virtual address pointer tables
pPages =
(struct page **)kmalloc(len * sizeof(struct page *), GFP_KERNEL);
if (!pPages) {
iReturn = U14ERR_NOMEMORY;
goto error;
}
dev_dbg(&pdx->interface->dev, "%s %p, length=%06x, circular %d",
__func__, puBuf, dwLength, bCircular);
// To pin down user pages we must first acquire the mapping semaphore.
down_read(¤t->mm->mmap_sem); // get memory map semaphore
nPages =
get_user_pages(current, current->mm, ulStart, len, 1, 0, pPages, 0);
up_read(¤t->mm->mmap_sem); // release the semaphore
dev_dbg(&pdx->interface->dev, "%s nPages = %d", __func__, nPages);
if (nPages > 0) // if we succeeded
{
// If 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->bCircular = bCircular;
pTA->bCircToHost = bCircToHost;
pTA->aBlocks[0].dwOffset = 0;
pTA->aBlocks[0].dwSize = 0;
pTA->aBlocks[1].dwOffset = 0;
pTA->aBlocks[1].dwSize = 0;
pTA->bUsed = true; // This is now a used block
spin_unlock_irq(&pdx->stagedLock);
iReturn = U14ERR_NOERROR; // say all was well
} else {
iReturn = U14ERR_LOCKFAIL;
goto error;
}
return iReturn;
error:
kfree(pPages);
return iReturn;
}
/****************************************************************************
** SetTransfer
**
** Sets up a transfer area record. If the area is already set, we attempt to
** unset it. Unsetting will fail if the area is booked, and a transfer to that
** area is in progress. Otherwise, we will release the area and re-assign it.
****************************************************************************/
int SetTransfer(DEVICE_EXTENSION * pdx, TRANSFERDESC __user * pTD)
{
int iReturn;
TRANSFERDESC td;
if (copy_from_user(&td, pTD, sizeof(td)))
return -EFAULT;
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.
iReturn =
SetArea(pdx, td.wAreaNum,
(char __user *)((unsigned long)td.lpvBuff), td.dwLength,
false, false);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** UnSetTransfer
** Erases a transfer area record
****************************************************************************/
int UnsetTransfer(DEVICE_EXTENSION * pdx, int nArea)
{
int iReturn;
mutex_lock(&pdx->io_mutex);
iReturn = ClearArea(pdx, nArea);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** SetEvent
** Creates an event that we can test for based on a transfer to/from an area.
** The area must be setup for a transfer. We attempt to simulate the Windows
** driver behavior for events (as we don't actually use them), which is to
** pretend that whatever the user asked for was achieved, so we return 1 if
** try to create one, and 0 if they ask to remove (assuming all else was OK).
****************************************************************************/
int SetEvent(DEVICE_EXTENSION * pdx, TRANSFEREVENT __user * pTE)
{
int iReturn = U14ERR_NOERROR;
TRANSFEREVENT te;
// 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
return U14ERR_BADAREA;
else {
TRANSAREA *pTA = &pdx->rTransDef[te.wAreaNum];
mutex_lock(&pdx->io_mutex); // make sure we have no competitor
spin_lock_irq(&pdx->stagedLock);
if (pTA->bUsed) // area must be in use
{
pTA->dwEventSt = te.dwStart; // set area regions
pTA->dwEventSz = te.dwLength; // set size (0 cancels it)
pTA->bEventToHost = te.wFlags & 1; // set the direction
pTA->iWakeUp = 0; // zero the wake up count
} else
iReturn = U14ERR_NOTSET;
spin_unlock_irq(&pdx->stagedLock);
mutex_unlock(&pdx->io_mutex);
}
return iReturn ==
U14ERR_NOERROR ? (te.iSetEvent ? 1 : U14ERR_NOERROR) : iReturn;
}
/****************************************************************************
** WaitEvent
** Sleep the process with a timeout waiting for an event. Returns the number
** of times that a block met the event condition since we last cleared it or
** 0 if timed out, or -ve error (bad area or not set, or signal).
****************************************************************************/
int WaitEvent(DEVICE_EXTENSION * pdx, int nArea, int msTimeOut)
{
int iReturn;
if ((unsigned)nArea > MAX_TRANSAREAS)
return U14ERR_BADAREA;
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
mutex_unlock(&pdx->io_mutex);
if (msTimeOut)
iWait =
wait_event_interruptible_timeout(pTA->wqEvent,
pTA->iWakeUp
|| !pTA->bUsed,
msTimeOut);
else
iWait =
wait_event_interruptible(pTA->wqEvent, pTA->iWakeUp
|| !pTA->bUsed);
if (iWait)
iReturn = -ERESTARTSYS; // oops - we have had a SIGNAL
else
iReturn = pTA->iWakeUp; // else the wakeup count
spin_lock_irq(&pdx->stagedLock);
pTA->iWakeUp = 0; // clear the flag
spin_unlock_irq(&pdx->stagedLock);
}
return iReturn;
}
/****************************************************************************
** TestEvent
** Test the event to see if a WaitEvent would return immediately. Returns the
** number of times a block completed since the last call, or 0 if none or a
** negative error.
****************************************************************************/
int TestEvent(DEVICE_EXTENSION * pdx, int nArea)
{
int iReturn;
if ((unsigned)nArea > MAX_TRANSAREAS)
iReturn = U14ERR_BADAREA;
else {
TRANSAREA *pTA = &pdx->rTransDef[nArea];
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
spin_unlock_irq(&pdx->stagedLock);
mutex_unlock(&pdx->io_mutex);
}
return iReturn;
}
/****************************************************************************
** GetTransferInfo
** Puts the current state of the 1401 in a TGET_TX_BLOCK.
*****************************************************************************/
int GetTransfer(DEVICE_EXTENSION * pdx, TGET_TX_BLOCK __user * pTX)
{
int iReturn = U14ERR_NOERROR;
unsigned int dwIdent;
mutex_lock(&pdx->io_mutex);
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
TGET_TX_BLOCK tx;
memset(&tx, 0, sizeof(tx)); // clean out local work structure
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.entries[0].physical =
(long long)(tx.linear + pdx->StagedOffset);
tx.entries[0].size = tx.size;
if (copy_to_user(pTX, &tx, sizeof(tx)))
iReturn = -EFAULT;
}
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** KillIO1401
**
** Empties the host i/o buffers
****************************************************************************/
int KillIO1401(DEVICE_EXTENSION * pdx)
{
dev_dbg(&pdx->interface->dev, "%s", __func__);
mutex_lock(&pdx->io_mutex);
FlushOutBuff(pdx);
FlushInBuff(pdx);
mutex_unlock(&pdx->io_mutex);
return U14ERR_NOERROR;
}
/****************************************************************************
** BlkTransState
** Returns a 0 or a 1 for whether DMA is happening. No point holding a mutex
** for this as it only does one read.
*****************************************************************************/
int BlkTransState(DEVICE_EXTENSION * pdx)
{
int iReturn = pdx->dwDMAFlag != MODE_CHAR;
dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn);
return iReturn;
}
/****************************************************************************
** StateOf1401
**
** Puts the current state of the 1401 in the Irp return buffer.
*****************************************************************************/
int StateOf1401(DEVICE_EXTENSION * pdx)
{
int iReturn;
mutex_lock(&pdx->io_mutex);
QuickCheck(pdx, false, false); // get state up to date, no reset
iReturn = pdx->sCurrentState;
mutex_unlock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn);
return iReturn;
}
/****************************************************************************
** StartSelfTest
**
** Initiates a self-test cycle. The assumption is that we have no interrupts
** active, so we should make sure that this is the case.
*****************************************************************************/
int StartSelfTest(DEVICE_EXTENSION * pdx)
{
int nGot;
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 */
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
mutex_unlock(&pdx->io_mutex);
if (nGot < 0)
dev_err(&pdx->interface->dev, "%s err=%d", __func__, nGot);
return nGot < 0 ? U14ERR_FAIL : U14ERR_NOERROR;
}
/****************************************************************************
** CheckSelfTest
**
** Check progress of a self-test cycle
****************************************************************************/
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)
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
iReturn = Get1401State(pdx, &state, &error);
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
error = 0;
iReturn = U14ERR_NOERROR;
}
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
error = 0;
}
if ((state & 0xFF) == 0x80) // If we are still in self-test
{
if (state & 0x00FF0000) // Have we got an error?
{
gst.code = (state & 0x00FF0000) >> 16; // read the error code
gst.x = error & 0x0000FFFF; // Error data X
gst.y = (error & 0xFFFF0000) >> 16; // and data Y
dev_dbg(&pdx->interface->dev, "Self-test error code %d",
gst.code);
} else // No error, check for timeout
{
unsigned long ulNow = jiffies; // get current time
if (time_after(ulNow, pdx->ulSelfTestTime)) {
gst.code = -2; // Flag the timeout
dev_dbg(&pdx->interface->dev,
"Self-test timed-out");
} else
dev_dbg(&pdx->interface->dev,
"Self-test on-going");
}
} else {
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 ((pdx->nPipes == 4) && (pdx->s1401Type <= TYPEPOWER))
Is1401(pdx); // Get 1401 reset and OK
else
QuickCheck(pdx, true, true); // Otherwise check without reset unless problems
}
mutex_unlock(&pdx->io_mutex);
if (copy_to_user(pGST, &gst, sizeof(gst)))
return -EFAULT;
return iReturn;
}
/****************************************************************************
** TypeOf1401
**
** Returns code for standard, plus, micro1401, power1401 or none
****************************************************************************/
int TypeOf1401(DEVICE_EXTENSION * pdx)
{
int iReturn = TYPEUNKNOWN;
mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s", __func__);
switch (pdx->s1401Type) {
case TYPE1401:
iReturn = U14ERR_STD;
break; // Handle these types directly
case TYPEPLUS:
iReturn = U14ERR_PLUS;
break;
case TYPEU1401:
iReturn = U14ERR_U1401;
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
}
dev_dbg(&pdx->interface->dev, "%s %d", __func__, iReturn);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** TransferFlags
**
** Returns flags on block transfer abilities
****************************************************************************/
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
dev_dbg(&pdx->interface->dev, "%s", __func__);
mutex_lock(&pdx->io_mutex);
if (pdx->bIsUSB2) // Set flag for USB2 if appropriate
iReturn |= U14TF_USB2;
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/***************************************************************************
** DbgCmd1401
** Issues a debug\diagnostic command to the 1401 along with a 32-bit datum
** This is a utility command used for dbg operations.
*/
static int DbgCmd1401(DEVICE_EXTENSION * pdx, unsigned char cmd,
unsigned int data)
{
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
if (iReturn < 0)
dev_err(&pdx->interface->dev, "%s fail code=%d", __func__,
iReturn);
return iReturn;
}
/****************************************************************************
** DbgPeek
**
** Execute the diagnostic peek operation. Uses address, width and repeats.
****************************************************************************/
int DbgPeek(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
{
int iReturn;
TDBGBLOCK db;
if (copy_from_user(&db, pDB, sizeof(db)))
return -EFAULT;
mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr);
iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_PEEK, 0);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** DbgPoke
**
** Execute the diagnostic poke operation. Parameters are in the CSBLOCK struct
** in order address, size, repeats and value to poke.
****************************************************************************/
int DbgPoke(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
{
int iReturn;
TDBGBLOCK db;
if (copy_from_user(&db, pDB, sizeof(db)))
return -EFAULT;
mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr);
iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_POKE, db.iData);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** DbgRampData
**
** Execute the diagnostic ramp data operation. Parameters are in the CSBLOCK struct
** in order address, default, enable mask, size and repeats.
****************************************************************************/
int DbgRampData(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
{
int iReturn;
TDBGBLOCK db;
if (copy_from_user(&db, pDB, sizeof(db)))
return -EFAULT;
mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr);
iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_SETDEF, db.iDefault);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_SETMASK, db.iMask);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_RAMPD, 0);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** DbgRampAddr
**
** Execute the diagnostic ramp address operation
****************************************************************************/
int DbgRampAddr(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
{
int iReturn;
TDBGBLOCK db;
if (copy_from_user(&db, pDB, sizeof(db)))
return -EFAULT;
mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s", __func__);
iReturn = DbgCmd1401(pdx, DB_SETDEF, db.iDefault);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_SETMASK, db.iMask);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
if (iReturn == U14ERR_NOERROR)
iReturn = DbgCmd1401(pdx, DB_RAMPA, 0);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** DbgGetData
**
** Retrieve the data resulting from the last debug Peek operation
****************************************************************************/
int DbgGetData(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
{
int iReturn;
TDBGBLOCK db;
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.
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);
if (iReturn == sizeof(db.iData)) {
if (copy_to_user(pDB, &db, sizeof(db)))
iReturn = -EFAULT;
else
iReturn = U14ERR_NOERROR;
} else
dev_err(&pdx->interface->dev, "%s failed, code %d", __func__,
iReturn);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** DbgStopLoop
**
** Stop any never-ending debug loop, we just call Get1401State for USB
**
****************************************************************************/
int DbgStopLoop(DEVICE_EXTENSION * pdx)
{
int iReturn;
unsigned int uState, uErr;
mutex_lock(&pdx->io_mutex);
dev_dbg(&pdx->interface->dev, "%s", __func__);
iReturn = Get1401State(pdx, &uState, &uErr);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** SetCircular
**
** Sets up a transfer area record for circular transfers. If the area is
** already set, we attempt to unset it. Unsetting will fail if the area is
** booked and a transfer to that area is in progress. Otherwise, we will
** release the area and re-assign it.
****************************************************************************/
int SetCircular(DEVICE_EXTENSION * pdx, TRANSFERDESC __user * pTD)
{
int iReturn;
bool bToHost;
TRANSFERDESC td;
if (copy_from_user(&td, pTD, sizeof(td)))
return -EFAULT;
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
// 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,
true, bToHost);
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** GetCircBlock
**
** Return the next available block of circularly-transferred data.
****************************************************************************/
int GetCircBlock(DEVICE_EXTENSION * pdx, TCIRCBLOCK __user * pCB)
{
int iReturn = U14ERR_NOERROR;
unsigned int nArea;
TCIRCBLOCK cb;
dev_dbg(&pdx->interface->dev, "%s", __func__);
if (copy_from_user(&cb, pCB, sizeof(cb)))
return -EFAULT;
mutex_lock(&pdx->io_mutex);
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
{
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->aBlocks[0].dwSize > 0) // Got anything?
{
cb.dwOffset = pArea->aBlocks[0].dwOffset;
cb.dwSize = pArea->aBlocks[0].dwSize;
dev_dbg(&pdx->interface->dev,
"%s return block 0: %d bytes at %d",
__func__, cb.dwSize, cb.dwOffset);
}
} else
iReturn = U14ERR_NOTSET;
spin_unlock_irq(&pdx->stagedLock);
} else
iReturn = U14ERR_BADAREA;
if (copy_to_user(pCB, &cb, sizeof(cb)))
iReturn = -EFAULT;
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
/****************************************************************************
** FreeCircBlock
**
** Frees a block of circularly-transferred data and returns the next one.
****************************************************************************/
int FreeCircBlock(DEVICE_EXTENSION * pdx, TCIRCBLOCK __user * pCB)
{
int iReturn = U14ERR_NOERROR;
unsigned int nArea, uStart, uSize;
TCIRCBLOCK cb;
dev_dbg(&pdx->interface->dev, "%s", __func__);
if (copy_from_user(&cb, pCB, sizeof(cb)))
return -EFAULT;
mutex_lock(&pdx->io_mutex);
nArea = cb.nArea; // Retrieve parameters first
uStart = cb.dwOffset;
uSize = cb.dwSize;
cb.dwOffset = 0; // then set default result (nothing)
cb.dwSize = 0;
if (nArea < MAX_TRANSAREAS) // The area number must be OK
{
TRANSAREA *pArea = &pdx->rTransDef[nArea]; // Pointer to relevant info
spin_lock_irq(&pdx->stagedLock); // Lock others out
if ((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
{
pArea->aBlocks[0].dwSize -= uSize;
pArea->aBlocks[0].dwOffset += uSize;
if (pArea->aBlocks[0].dwSize == 0) // Have we emptied this block?
{
if (pArea->aBlocks[1].dwSize) // Is there a second block?
{
pArea->aBlocks[0] = pArea->aBlocks[1]; // Copy down block 2 data
pArea->aBlocks[1].dwSize = 0; // and mark the second block as unused
pArea->aBlocks[1].dwOffset = 0;
} else
pArea->aBlocks[0].dwOffset = 0;
}
dev_dbg(&pdx->interface->dev,
"%s free %d bytes at %d, return %d bytes at %d, wait=%d",
__func__, uSize, uStart,
pArea->aBlocks[0].dwSize,
pArea->aBlocks[0].dwOffset,
pdx->bXFerWaiting);
// Return the next available block of memory as well
if (pArea->aBlocks[0].dwSize > 0) // Got anything?
{
cb.dwOffset =
pArea->aBlocks[0].dwOffset;
cb.dwSize = pArea->aBlocks[0].dwSize;
}
bWaiting = pdx->bXFerWaiting;
if (bWaiting && pdx->bStagedUrbPending) {
dev_err(&pdx->interface->dev,
"%s ERROR: waiting xfer and staged Urb pending!",
__func__);
bWaiting = false;
}
} else {
dev_err(&pdx->interface->dev,
"%s ERROR: freeing %d bytes at %d, block 0 is %d bytes at %d",
__func__, uSize, uStart,
pArea->aBlocks[0].dwSize,
pArea->aBlocks[0].dwOffset);
iReturn = U14ERR_NOMEMORY;
}
// If we have one, kick off pending transfer
if (bWaiting) // Got a block xfer waiting?
{
int RWMStat =
ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard,
pdx->rDMAInfo.wIdent,
pdx->rDMAInfo.dwOffset,
pdx->rDMAInfo.dwSize);
if (RWMStat != U14ERR_NOERROR)
dev_err(&pdx->interface->dev,
"%s rw setup failed %d",
__func__, RWMStat);
}
} else
iReturn = U14ERR_NOTSET;
spin_unlock_irq(&pdx->stagedLock);
} else
iReturn = U14ERR_BADAREA;
if (copy_to_user(pCB, &cb, sizeof(cb)))
return -EFAULT;
mutex_unlock(&pdx->io_mutex);
return iReturn;
}
_______________________________________________
devel mailing list
devel@xxxxxxxxxxxxxxxxxxxxxx
http://driverdev.linuxdriverproject.org/mailman/listinfo/devel
