Staging ced1401: cleanup coding style issues.

A basic Lindent run on the .c files, clean up the .h file by hand.

Cc: Alois Schlögl <alois.schloegl@ist.ac.at>
Cc: Greg P. Smith <greg@ced.co.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

drivers/staging/ced1401/ced_ioc.c

@@ -37,17 +37,18 @@
 **
 ** Empties the Output buffer and sets int lines. Used from user level only
 ****************************************************************************/
-void FlushOutBuff(DEVICE_EXTENSION *pdx)
+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;
+	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);
+	spin_lock_irq(&pdx->charOutLock);
+	pdx->dwNumOutput = 0;
+	pdx->dwOutBuffGet = 0;
+	pdx->dwOutBuffPut = 0;
+	spin_unlock_irq(&pdx->charOutLock);
 }
 
 /****************************************************************************
@@ -56,17 +57,18 @@ void FlushOutBuff(DEVICE_EXTENSION *pdx)
 **
 ** Empties the input buffer and sets int lines
 ****************************************************************************/
-void FlushInBuff(DEVICE_EXTENSION *pdx)
+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;
+	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);
+	spin_lock_irq(&pdx->charInLock);
+	pdx->dwNumInput = 0;
+	pdx->dwInBuffGet = 0;
+	pdx->dwInBuffPut = 0;
+	spin_unlock_irq(&pdx->charInLock);
 }
 
 /****************************************************************************
@@ -75,29 +77,26 @@ void FlushInBuff(DEVICE_EXTENSION *pdx)
 ** 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)
+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;
+	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;
 }
 
 /*****************************************************************************
@@ -105,27 +104,29 @@ static int PutChars(DEVICE_EXTENSION* pdx, const char* pCh, unsigned int uCount)
 ** 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 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 -ENOMEM;                     // could not copy
-    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;
+	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 -ENOMEM;	// could not copy
+	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;
 }
 
 /****************************************************************************
@@ -133,15 +134,15 @@ int SendString(DEVICE_EXTENSION* pdx, const char __user* pData, unsigned int n)
 **
 ** Sends a single character to the 1401. User mode, holds io_mutex.
 ****************************************************************************/
-int SendChar(DEVICE_EXTENSION *pdx, char c)
+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;
+	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;
 }
 
 /***************************************************************************
@@ -170,48 +171,47 @@ int SendChar(DEVICE_EXTENSION *pdx, char c)
 **
 ** return error code (U14ERR_NOERROR for OK)
 */
-int Get1401State(DEVICE_EXTENSION* pdx, __u32* state, __u32* error)
+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;
+	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;
 }
 
 /****************************************************************************
@@ -219,49 +219,53 @@ int Get1401State(DEVICE_EXTENSION* pdx, __u32* state, __u32* error)
 **
 ** Kills off staged read\write request from the USB if one is pending.
 ****************************************************************************/
-int ReadWrite_Cancel(DEVICE_EXTENSION *pdx)
+int ReadWrite_Cancel(DEVICE_EXTENSION * pdx)
 {
-    dev_dbg(&pdx->interface->dev, "ReadWrite_Cancel entry %d", pdx->bStagedUrbPending);
+	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;
+	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;
+	return U14ERR_NOERROR;
 #endif
 
 }
@@ -270,15 +274,15 @@ int ReadWrite_Cancel(DEVICE_EXTENSION *pdx)
 ** 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)
+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;
+	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;
 }
 
 /***************************************************************************
@@ -299,52 +303,50 @@ static int InSelfTest(DEVICE_EXTENSION* pdx, unsigned int* pState)
 **
 **  Returns TRUE if a 1401 detected and OK, else FALSE
 ****************************************************************************/
-bool Is1401(DEVICE_EXTENSION* pdx)
+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;
+	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;
 }
 
 /****************************************************************************
@@ -361,44 +363,48 @@ bool Is1401(DEVICE_EXTENSION* pdx)
 **
 ** The return value is TRUE if a useable 1401 is found, FALSE if not
 */
-bool QuickCheck(DEVICE_EXTENSION* pdx, bool bTestBuff, bool bCanReset)
+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;
+	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;
 }
 
 /****************************************************************************
@@ -406,13 +412,13 @@ bool QuickCheck(DEVICE_EXTENSION* pdx, bool bTestBuff, bool bCanReset)
 **
 ** Resets the 1401 and empties the i/o buffers
 *****************************************************************************/
-int Reset1401(DEVICE_EXTENSION *pdx)
+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;
+	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;
 }
 
 /****************************************************************************
@@ -420,32 +426,31 @@ int Reset1401(DEVICE_EXTENSION *pdx)
 **
 ** Gets a single character from the 1401
 ****************************************************************************/
-int GetChar(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
-
-    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;
+	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;
 }
 
 /****************************************************************************
@@ -459,78 +464,77 @@ int GetChar(DEVICE_EXTENSION *pdx)
 ** 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 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);
-        copy_to_user(pUser, buffer, nCopyToUser);
-
-        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;
+	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);
+		copy_to_user(pUser, buffer, nCopyToUser);
+
+		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 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;
+	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;
 }
 
 /****************************************************************************
@@ -540,34 +544,33 @@ int Stat1401(DEVICE_EXTENSION *pdx)
 ** 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 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;
+	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;
 }
 
 /****************************************************************************
@@ -575,15 +578,15 @@ int LineCount(DEVICE_EXTENSION *pdx)
 **
 ** Gets the space in the output buffer. Called from user code.
 *****************************************************************************/
-int GetOutBufSpace(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
-    dev_dbg(&pdx->interface->dev,"OutBufSpace %d", iReturn);
-    mutex_unlock(&pdx->io_mutex);           // Protect disconnect from new i/o
-    return iReturn;
+	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;
 }
 
 /****************************************************************************
@@ -593,74 +596,75 @@ int GetOutBufSpace(DEVICE_EXTENSION *pdx)
 ** 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 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;
+	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;
 }
 
 /****************************************************************************
@@ -669,78 +673,78 @@ int ClearArea(DEVICE_EXTENSION *pdx, int nArea)
 ** 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)
+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(&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
-    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;
+	// 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(&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
+	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;
+	kfree(pPages);
+	return iReturn;
 }
 
 /****************************************************************************
@@ -750,32 +754,36 @@ error:
 ** 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 SetTransfer(DEVICE_EXTENSION * pdx, TRANSFERDESC __user * pTD)
 {
-    int iReturn;
-    TRANSFERDESC td;
-    copy_from_user(&td, pTD, sizeof(td));
-    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;
+	int iReturn;
+	TRANSFERDESC td;
+	copy_from_user(&td, pTD, sizeof(td));
+	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 UnsetTransfer(DEVICE_EXTENSION * pdx, int nArea)
 {
-    int iReturn;
-    mutex_lock(&pdx->io_mutex);
-    iReturn = ClearArea(pdx, nArea);
-    mutex_unlock(&pdx->io_mutex);
-    return iReturn;
+	int iReturn;
+	mutex_lock(&pdx->io_mutex);
+	iReturn = ClearArea(pdx, nArea);
+	mutex_unlock(&pdx->io_mutex);
+	return iReturn;
 }
 
 /****************************************************************************
@@ -786,31 +794,30 @@ int UnsetTransfer(DEVICE_EXTENSION *pdx, int nArea)
 ** 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 SetEvent(DEVICE_EXTENSION * pdx, TRANSFEREVENT __user * pTE)
 {
-    int iReturn = U14ERR_NOERROR;
-    TRANSFEREVENT te;
-    copy_from_user(&te, pTE, sizeof(te));   // get a local copy of the data
-    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;
+	int iReturn = U14ERR_NOERROR;
+	TRANSFEREVENT te;
+	copy_from_user(&te, pTE, sizeof(te));	// get a local copy of the data
+	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;
 }
 
 /****************************************************************************
@@ -819,40 +826,45 @@ int SetEvent(DEVICE_EXTENSION *pdx, TRANSFEREVENT __user*pTE)
 ** 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 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;
+	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;
 }
 
 /****************************************************************************
@@ -861,52 +873,51 @@ int WaitEvent(DEVICE_EXTENSION *pdx, int nArea, int msTimeOut)
 ** 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 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;
+	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 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;
-        copy_to_user(pTX, &tx, sizeof(tx));
-    }
-    mutex_unlock(&pdx->io_mutex);
-    return iReturn;
+	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;
+		copy_to_user(pTX, &tx, sizeof(tx));
+	}
+	mutex_unlock(&pdx->io_mutex);
+	return iReturn;
 }
 
 /****************************************************************************
@@ -914,14 +925,14 @@ int GetTransfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user *pTX)
 **
 ** Empties the host i/o buffers
 ****************************************************************************/
-int KillIO1401(DEVICE_EXTENSION *pdx)
+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;
+	dev_dbg(&pdx->interface->dev, "%s", __func__);
+	mutex_lock(&pdx->io_mutex);
+	FlushOutBuff(pdx);
+	FlushInBuff(pdx);
+	mutex_unlock(&pdx->io_mutex);
+	return U14ERR_NOERROR;
 }
 
 /****************************************************************************
@@ -929,11 +940,11 @@ int KillIO1401(DEVICE_EXTENSION *pdx)
 ** 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 BlkTransState(DEVICE_EXTENSION * pdx)
 {
-    int iReturn = pdx->dwDMAFlag != MODE_CHAR;
-    dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn);
-    return iReturn;
+	int iReturn = pdx->dwDMAFlag != MODE_CHAR;
+	dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn);
+	return iReturn;
 }
 
 /****************************************************************************
@@ -941,121 +952,121 @@ int BlkTransState(DEVICE_EXTENSION *pdx)
 **
 ** Puts the current state of the 1401 in the Irp return buffer.
 *****************************************************************************/
-int StateOf1401(DEVICE_EXTENSION *pdx)
+int StateOf1401(DEVICE_EXTENSION * pdx)
 {
-    int iReturn;
-    mutex_lock(&pdx->io_mutex);
+	int iReturn;
+	mutex_lock(&pdx->io_mutex);
 
-    QuickCheck(pdx, false, false);    // get state up to date, no reset
-    iReturn = pdx->sCurrentState;
+	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);
+	mutex_unlock(&pdx->io_mutex);
+	dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn);
 
-    return 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 StartSelfTest(DEVICE_EXTENSION * pdx)
 {
-    int nGot;
-    mutex_lock(&pdx->io_mutex);
-    dev_dbg(&pdx->interface->dev, "%s", __func__);
+	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
+	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 */
+	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)
-        dev_err(&pdx->interface->dev, "%s err=%d", __func__, nGot);
-    return nGot < 0 ? U14ERR_FAIL : U14ERR_NOERROR;
+	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)
+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);
-
-    copy_to_user(pGST, &gst, sizeof(gst));  // copy result to user space
-    return iReturn;
+	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);
+
+	copy_to_user(pGST, &gst, sizeof(gst));	// copy result to user space
+	return iReturn;
 }
 
 /****************************************************************************
@@ -1063,28 +1074,32 @@ int CheckSelfTest(DEVICE_EXTENSION *pdx, TGET_SELFTEST __user *pGST)
 **
 ** Returns code for standard, plus, micro1401, power1401 or none
 ****************************************************************************/
-int TypeOf1401(DEVICE_EXTENSION *pdx)
+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;
+	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;
 }
 
 /****************************************************************************
@@ -1092,17 +1107,17 @@ int TypeOf1401(DEVICE_EXTENSION *pdx)
 **
 ** Returns flags on block transfer abilities
 ****************************************************************************/
-int TransferFlags(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
-    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;
+	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;
 }
 
 /***************************************************************************
@@ -1110,18 +1125,17 @@ int TransferFlags(DEVICE_EXTENSION *pdx)
 ** 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)
+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;
+	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;
 }
 
 /****************************************************************************
@@ -1129,146 +1143,141 @@ static int DbgCmd1401(DEVICE_EXTENSION *pdx, unsigned char cmd, unsigned int dat
 **
 ** Execute the diagnostic peek operation. Uses address, width and repeats.
 ****************************************************************************/
-int DbgPeek(DEVICE_EXTENSION *pdx, TDBGBLOCK __user* pDB)
+int DbgPeek(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
 {
-    int iReturn;
-    TDBGBLOCK db;
-    copy_from_user(&db, pDB, sizeof(db));   // get the data
-
-    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;
+	int iReturn;
+	TDBGBLOCK db;
+	copy_from_user(&db, pDB, sizeof(db));	// get the data
+
+	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 DbgPoke(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
 {
-    int iReturn;
-    TDBGBLOCK db;
-    copy_from_user(&db, pDB, sizeof(db));   // get the data
-
-    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;
+	int iReturn;
+	TDBGBLOCK db;
+	copy_from_user(&db, pDB, sizeof(db));	// get the data
+
+	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 DbgRampData(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
 {
-    int iReturn;
-    TDBGBLOCK db;
-    copy_from_user(&db, pDB, sizeof(db));   // get the data
-
-    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;
+	int iReturn;
+	TDBGBLOCK db;
+	copy_from_user(&db, pDB, sizeof(db));	// get the data
+
+	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 DbgRampAddr(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
 {
-    int iReturn;
-    TDBGBLOCK db;
-    copy_from_user(&db, pDB, sizeof(db));   // get the data
-
-    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;
+	int iReturn;
+	TDBGBLOCK db;
+	copy_from_user(&db, pDB, sizeof(db));	// get the data
+
+	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 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))
-    {
-        copy_to_user(pDB, &db, sizeof(db));
-        iReturn = U14ERR_NOERROR;
-    }
-    else
-        dev_err(&pdx->interface->dev, "%s failed, code %d", __func__, iReturn);
-
-    mutex_unlock(&pdx->io_mutex);
-
-    return iReturn;
+	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)) {
+		copy_to_user(pDB, &db, sizeof(db));
+		iReturn = U14ERR_NOERROR;
+	} else
+		dev_err(&pdx->interface->dev, "%s failed, code %d", __func__,
+			iReturn);
+
+	mutex_unlock(&pdx->io_mutex);
+
+	return iReturn;
 }
 
 /****************************************************************************
@@ -1277,20 +1286,19 @@ int DbgGetData(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB)
 ** Stop any never-ending debug loop, we just call Get1401State for USB
 **
 ****************************************************************************/
-int DbgStopLoop(DEVICE_EXTENSION *pdx)
+int DbgStopLoop(DEVICE_EXTENSION * pdx)
 {
-    int iReturn;
-    unsigned int uState, uErr;
+	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);
+	mutex_lock(&pdx->io_mutex);
+	dev_dbg(&pdx->interface->dev, "%s", __func__);
+	iReturn = Get1401State(pdx, &uState, &uErr);
+	mutex_unlock(&pdx->io_mutex);
 
-    return iReturn;
+	return iReturn;
 }
 
-
 /****************************************************************************
 ** SetCircular
 **
@@ -1299,22 +1307,26 @@ int DbgStopLoop(DEVICE_EXTENSION *pdx)
 ** 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 SetCircular(DEVICE_EXTENSION * pdx, TRANSFERDESC __user * pTD)
 {
-    int iReturn;
-    bool bToHost;
-    TRANSFERDESC td;
-    copy_from_user(&td, pTD, sizeof(td));
-    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;
+	int iReturn;
+	bool bToHost;
+	TRANSFERDESC td;
+	copy_from_user(&td, pTD, sizeof(td));
+	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;
 }
 
 /****************************************************************************
@@ -1322,140 +1334,145 @@ int SetCircular(DEVICE_EXTENSION *pdx, TRANSFERDESC __user *pTD)
 **
 ** Return the next available block of circularly-transferred data.
 ****************************************************************************/
-int GetCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user* pCB)
+int GetCircBlock(DEVICE_EXTENSION * pdx, TCIRCBLOCK __user * pCB)
 {
-    int iReturn = U14ERR_NOERROR;
-    unsigned int nArea;
-    TCIRCBLOCK cb;
-    dev_dbg(&pdx->interface->dev, "%s", __func__);
-    copy_from_user(&cb, pCB, sizeof(cb));
-    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;
-
-    copy_to_user(pCB, &cb, sizeof(cb));
-    mutex_unlock(&pdx->io_mutex);
-    return iReturn;
+	int iReturn = U14ERR_NOERROR;
+	unsigned int nArea;
+	TCIRCBLOCK cb;
+	dev_dbg(&pdx->interface->dev, "%s", __func__);
+	copy_from_user(&cb, pCB, sizeof(cb));
+	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;
+
+	copy_to_user(pCB, &cb, sizeof(cb));
+	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 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__);
-    copy_from_user(&cb, pCB, sizeof(cb));
-    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;
-
-    copy_to_user(pCB, &cb, sizeof(cb));
-    mutex_unlock(&pdx->io_mutex);
-    return iReturn;
+	int iReturn = U14ERR_NOERROR;
+	unsigned int nArea, uStart, uSize;
+	TCIRCBLOCK cb;
+	dev_dbg(&pdx->interface->dev, "%s", __func__);
+	copy_from_user(&cb, pCB, sizeof(cb));
+	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;
+
+	copy_to_user(pCB, &cb, sizeof(cb));
+	mutex_unlock(&pdx->io_mutex);
+	return iReturn;
 }
-
-
-

drivers/staging/ced1401/ced_ioctl.h

@@ -1,232 +1,345 @@
-/* ced_ioctl.h
- IOCTL calls for the CED1401 driver
- Copyright (C) 2010 Cambridge Electronic Design Ltd
- Author Greg P Smith (greg@ced.co.uk)
-
- 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.
-*/
+/*
+ * IOCTL calls for the CED1401 driver
+ * Copyright (C) 2010 Cambridge Electronic Design Ltd
+ * Author Greg P Smith (greg@ced.co.uk)
+ *
+ * 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.
+ */
 #ifndef __CED_IOCTL_H__
 #define __CED_IOCTL_H__
-#include <asm/ioctl.h>
 
-/// dma modes, only MODE_CHAR and MODE_LINEAR are used in this driver
-#define MODE_CHAR           0
-#define MODE_LINEAR         1
+#include <linux/ioctl.h>
+
+/* dma modes, only MODE_CHAR and MODE_LINEAR are used in this driver */
+#define MODE_CHAR		0
+#define MODE_LINEAR		1
 
 /****************************************************************************
 ** TypeDefs
 *****************************************************************************/
 
-typedef unsigned short TBLOCKENTRY; // index the blk transfer table 0-7
+typedef unsigned short TBLOCKENTRY;	/* index the blk transfer table 0-7 */
 
-typedef struct TransferDesc
-{
-    long long   lpvBuff;            // address of transfer area (for 64 or 32 bit)
-    unsigned int dwLength;          // length of the area
-    TBLOCKENTRY wAreaNum;           // number of transfer area to set up
-    short       eSize;              // element size - is tohost flag for circular
+typedef struct TransferDesc {
+	long long lpvBuff;	/* address of transfer area (for 64 or 32 bit) */
+	unsigned int dwLength;	/* length of the area */
+	TBLOCKENTRY wAreaNum;	/* number of transfer area to set up */
+	short eSize;		/* element size - is tohost flag for circular */
 } TRANSFERDESC;
 
-typedef TRANSFERDESC*   LPTRANSFERDESC;
+typedef TRANSFERDESC * LPTRANSFERDESC;
 
-typedef struct TransferEvent
-{
-    unsigned int dwStart;           // offset into the area
-    unsigned int dwLength;          // length of the region
-    unsigned short wAreaNum;        // the area number
-    unsigned short wFlags;          // bit 0 set for toHost
-    int iSetEvent;                  // could be dummy in LINUX
+typedef struct TransferEvent {
+	unsigned int dwStart;		/* offset into the area */
+	unsigned int dwLength;		/* length of the region */
+	unsigned short wAreaNum;	/* the area number */
+	unsigned short wFlags;		/* bit 0 set for toHost */
+	int iSetEvent;			/* could be dummy in LINUX */
 } TRANSFEREVENT;
 
-#define MAX_TRANSFER_SIZE  0x4000       /* Maximum data bytes per IRP */
-#define MAX_AREA_LENGTH    0x100000     /* Maximum size of transfer area */
-#define MAX_TRANSAREAS 8                /* definitions for dma set up  */
+#define MAX_TRANSFER_SIZE	0x4000		/* Maximum data bytes per IRP */
+#define MAX_AREA_LENGTH		0x100000	/* Maximum size of transfer area */
+#define MAX_TRANSAREAS		8		/* definitions for dma set up  */
 
-typedef struct TGetSelfTest
-{
-    int code;                           // self-test error code
-    int x,y;                            // additional information
+typedef struct TGetSelfTest {
+	int code;			/* self-test error code */
+	int x, y;			/* additional information */
 } TGET_SELFTEST;
 
-/// Debug block used for several commands. Not all fields are used for all commands.
-typedef struct TDbgBlock
-{
-    int iAddr;                          // the address in the 1401
-    int iRepeats;                       // number of repeats
-    int iWidth;                         // width in bytes 1, 2, 4
-    int iDefault;                       // default value
-    int iMask;                          // mask to apply
-    int iData;                          // data for poke, result for peek
+/* Debug block used for several commands. Not all fields are used for all commands. */
+typedef struct TDbgBlock {
+	int iAddr;			/* the address in the 1401 */
+	int iRepeats;			/* number of repeats */
+	int iWidth;			/* width in bytes 1, 2, 4 */
+	int iDefault;			/* default value */
+	int iMask;			/* mask to apply */
+	int iData;			/* data for poke, result for peek */
 } TDBGBLOCK;
 
-/// Used to collect information about a circular block from the device driver
-typedef struct TCircBlock
-{
-    unsigned int nArea;                 // the area to collect information from
-    unsigned int dwOffset;              // offset into the area to the available block
-    unsigned int dwSize;                // size of the area
+/* Used to collect information about a circular block from the device driver */
+typedef struct TCircBlock {
+	unsigned int nArea;		/* the area to collect information from */
+	unsigned int dwOffset;		/* offset into the area to the available block */
+	unsigned int dwSize;		/* size of the area */
 } TCIRCBLOCK;
 
-/// Used to clollect the 1401 status
-typedef struct TCSBlock
-{
-    unsigned int uiState;
-    unsigned int uiError;
+/* Used to clollect the 1401 status */
+typedef struct TCSBlock {
+	unsigned int uiState;
+	unsigned int uiError;
 } TCSBLOCK;
 
-// As seen by the user, an ioctl call looks like:
-// int ioctl(int fd, unsigned long cmd, char* argp);
-// We will then have all sorts of variants on this that can be used
-// to pass stuff to our driver. We will generate macros for each type
-// of call so as to provide some sort of type safety in the calling:
+/*
+ * As seen by the user, an ioctl call looks like: int ioctl(int fd, unsigned
+ * long cmd, char* argp); We will then have all sorts of variants on this that
+ * can be used to pass stuff to our driver. We will generate macros for each
+ * type of call so as to provide some sort of type safety in the calling:
+ */
 #define CED_MAGIC_IOC 0xce
 
-// NBNB: READ and WRITE are from the point of view of the device, not user.
-typedef struct ced_ioc_string
-{
-    int nChars;
-    char buffer[256];
+/* NBNB: READ and WRITE are from the point of view of the device, not user. */
+typedef struct ced_ioc_string {
+	int nChars;
+	char buffer[256];
 } CED_IOC_STRING;
 
-#define  IOCTL_CED_SENDSTRING(n)        _IOC(_IOC_WRITE, CED_MAGIC_IOC, 2, n)
-
-#define  IOCTL_CED_RESET1401            _IO(CED_MAGIC_IOC, 3)
-#define  IOCTL_CED_GETCHAR              _IO(CED_MAGIC_IOC, 4)
-#define  IOCTL_CED_SENDCHAR             _IO(CED_MAGIC_IOC, 5)
-#define  IOCTL_CED_STAT1401             _IO(CED_MAGIC_IOC, 6)
-#define  IOCTL_CED_LINECOUNT            _IO(CED_MAGIC_IOC, 7)
-#define  IOCTL_CED_GETSTRING(nMax)      _IOC(_IOC_READ, CED_MAGIC_IOC, 8, nMax)
-
-#define  IOCTL_CED_SETTRANSFER          _IOW(CED_MAGIC_IOC, 11, TRANSFERDESC)
-#define  IOCTL_CED_UNSETTRANSFER        _IO(CED_MAGIC_IOC, 12)
-#define  IOCTL_CED_SETEVENT             _IOW(CED_MAGIC_IOC,13, TRANSFEREVENT)
-#define  IOCTL_CED_GETOUTBUFSPACE       _IO(CED_MAGIC_IOC, 14)
-#define  IOCTL_CED_GETBASEADDRESS       _IO(CED_MAGIC_IOC, 15)
-#define  IOCTL_CED_GETDRIVERREVISION    _IO(CED_MAGIC_IOC, 16)
-
-#define  IOCTL_CED_GETTRANSFER          _IOR(CED_MAGIC_IOC,17, TGET_TX_BLOCK)
-#define  IOCTL_CED_KILLIO1401           _IO(CED_MAGIC_IOC,18)
-#define  IOCTL_CED_BLKTRANSSTATE        _IO(CED_MAGIC_IOC,19)
-
-#define  IOCTL_CED_STATEOF1401          _IO(CED_MAGIC_IOC,23)
-#define  IOCTL_CED_GRAB1401             _IO(CED_MAGIC_IOC,25)
-#define  IOCTL_CED_FREE1401             _IO(CED_MAGIC_IOC,26)
-#define  IOCTL_CED_STARTSELFTEST        _IO(CED_MAGIC_IOC,31)
-#define  IOCTL_CED_CHECKSELFTEST        _IOR(CED_MAGIC_IOC,32, TGET_SELFTEST)
-#define  IOCTL_CED_TYPEOF1401           _IO(CED_MAGIC_IOC,33)
-#define  IOCTL_CED_TRANSFERFLAGS        _IO(CED_MAGIC_IOC,34)
-
-#define  IOCTL_CED_DBGPEEK              _IOW(CED_MAGIC_IOC,35, TDBGBLOCK)
-#define  IOCTL_CED_DBGPOKE              _IOW(CED_MAGIC_IOC,36, TDBGBLOCK)
-#define  IOCTL_CED_DBGRAMPDATA          _IOW(CED_MAGIC_IOC,37, TDBGBLOCK)
-#define  IOCTL_CED_DBGRAMPADDR          _IOW(CED_MAGIC_IOC,38, TDBGBLOCK)
-#define  IOCTL_CED_DBGGETDATA           _IOR(CED_MAGIC_IOC,39, TDBGBLOCK)
-#define  IOCTL_CED_DBGSTOPLOOP          _IO(CED_MAGIC_IOC,40)
-#define  IOCTL_CED_FULLRESET            _IO(CED_MAGIC_IOC,41)
-#define  IOCTL_CED_SETCIRCULAR          _IOW(CED_MAGIC_IOC,42, TRANSFERDESC)
-#define  IOCTL_CED_GETCIRCBLOCK         _IOWR(CED_MAGIC_IOC,43, TCIRCBLOCK)
-#define  IOCTL_CED_FREECIRCBLOCK        _IOWR(CED_MAGIC_IOC,44, TCIRCBLOCK)
-#define  IOCTL_CED_WAITEVENT            _IO(CED_MAGIC_IOC, 45)
-#define  IOCTL_CED_TESTEVENT            _IO(CED_MAGIC_IOC, 46)
+#define IOCTL_CED_SENDSTRING(n)		_IOC(_IOC_WRITE, CED_MAGIC_IOC, 2, n)
+
+#define IOCTL_CED_RESET1401		_IO(CED_MAGIC_IOC, 3)
+#define IOCTL_CED_GETCHAR		_IO(CED_MAGIC_IOC, 4)
+#define IOCTL_CED_SENDCHAR		_IO(CED_MAGIC_IOC, 5)
+#define IOCTL_CED_STAT1401		_IO(CED_MAGIC_IOC, 6)
+#define IOCTL_CED_LINECOUNT		_IO(CED_MAGIC_IOC, 7)
+#define IOCTL_CED_GETSTRING(nMax)	_IOC(_IOC_READ, CED_MAGIC_IOC, 8, nMax)
+
+#define IOCTL_CED_SETTRANSFER		_IOW(CED_MAGIC_IOC, 11, TRANSFERDESC)
+#define IOCTL_CED_UNSETTRANSFER		_IO(CED_MAGIC_IOC, 12)
+#define IOCTL_CED_SETEVENT		_IOW(CED_MAGIC_IOC, 13, TRANSFEREVENT)
+#define IOCTL_CED_GETOUTBUFSPACE	_IO(CED_MAGIC_IOC, 14)
+#define IOCTL_CED_GETBASEADDRESS	_IO(CED_MAGIC_IOC, 15)
+#define IOCTL_CED_GETDRIVERREVISION	_IO(CED_MAGIC_IOC, 16)
+
+#define IOCTL_CED_GETTRANSFER		_IOR(CED_MAGIC_IOC, 17, TGET_TX_BLOCK)
+#define IOCTL_CED_KILLIO1401		_IO(CED_MAGIC_IOC, 18)
+#define IOCTL_CED_BLKTRANSSTATE		_IO(CED_MAGIC_IOC, 19)
+
+#define IOCTL_CED_STATEOF1401		_IO(CED_MAGIC_IOC, 23)
+#define IOCTL_CED_GRAB1401		_IO(CED_MAGIC_IOC, 25)
+#define IOCTL_CED_FREE1401		_IO(CED_MAGIC_IOC, 26)
+#define IOCTL_CED_STARTSELFTEST		_IO(CED_MAGIC_IOC, 31)
+#define IOCTL_CED_CHECKSELFTEST		_IOR(CED_MAGIC_IOC, 32, TGET_SELFTEST)
+#define IOCTL_CED_TYPEOF1401		_IO(CED_MAGIC_IOC, 33)
+#define IOCTL_CED_TRANSFERFLAGS		_IO(CED_MAGIC_IOC, 34)
+
+#define IOCTL_CED_DBGPEEK		_IOW(CED_MAGIC_IOC, 35, TDBGBLOCK)
+#define IOCTL_CED_DBGPOKE		_IOW(CED_MAGIC_IOC, 36, TDBGBLOCK)
+#define IOCTL_CED_DBGRAMPDATA		_IOW(CED_MAGIC_IOC, 37, TDBGBLOCK)
+#define IOCTL_CED_DBGRAMPADDR		_IOW(CED_MAGIC_IOC, 38, TDBGBLOCK)
+#define IOCTL_CED_DBGGETDATA		_IOR(CED_MAGIC_IOC, 39, TDBGBLOCK)
+#define IOCTL_CED_DBGSTOPLOOP		_IO(CED_MAGIC_IOC, 40)
+#define IOCTL_CED_FULLRESET		_IO(CED_MAGIC_IOC, 41)
+#define IOCTL_CED_SETCIRCULAR		_IOW(CED_MAGIC_IOC, 42, TRANSFERDESC)
+#define IOCTL_CED_GETCIRCBLOCK		_IOWR(CED_MAGIC_IOC, 43, TCIRCBLOCK)
+#define IOCTL_CED_FREECIRCBLOCK		_IOWR(CED_MAGIC_IOC, 44, TCIRCBLOCK)
+#define IOCTL_CED_WAITEVENT		_IO(CED_MAGIC_IOC, 45)
+#define IOCTL_CED_TESTEVENT		_IO(CED_MAGIC_IOC, 46)
 
 #ifndef __KERNEL__
-// If nothing said about return value, it is a U14ERR_... error code (U14ERR_NOERROR for none)
-inline int CED_SendString(int fh, const char* szText, int n){return ioctl(fh, IOCTL_CED_SENDSTRING(n), szText);}
+/*
+ * If nothing said about return value, it is a U14ERR_... error code
+ * (U14ERR_NOERROR for none)
+ */
+inline int CED_SendString(int fh, const char *szText, int n)
+{
+	return ioctl(fh, IOCTL_CED_SENDSTRING(n), szText);
+}
 
-inline int CED_Reset1401(int fh){return ioctl(fh, IOCTL_CED_RESET1401);}
+inline int CED_Reset1401(int fh)
+{
+	return ioctl(fh, IOCTL_CED_RESET1401);
+}
 
-inline int CED_GetChar(int fh){return ioctl(fh, IOCTL_CED_GETCHAR);}
-// Return the singe character or a -ve error code.
+/* Return the singe character or a -ve error code. */
+inline int CED_GetChar(int fh)
+{
+	return ioctl(fh, IOCTL_CED_GETCHAR);
+}
 
-inline int CED_Stat1401(int fh){return ioctl(fh, IOCTL_CED_STAT1401);}
-// Return character count in input buffer
+/* Return character count in input buffer */
+inline int CED_Stat1401(int fh)
+{
+	return ioctl(fh, IOCTL_CED_STAT1401);
+}
 
-inline int CED_SendChar(int fh, char c){return ioctl(fh, IOCTL_CED_SENDCHAR, c);}
+inline int CED_SendChar(int fh, char c)
+{
+	return ioctl(fh, IOCTL_CED_SENDCHAR, c);
+}
 
-inline int CED_LineCount(int fh){return ioctl(fh, IOCTL_CED_LINECOUNT);}
+inline int CED_LineCount(int fh)
+{
+	return ioctl(fh, IOCTL_CED_LINECOUNT);
+}
+
+/*
+ * return the count of characters returned. If the string was terminated by CR
+ * or 0, then the 0 is part of the count. Otherwise, we will add a zero if
+ * there is room, but it is not included in the count.  The return value is 0
+ * if there was nothing to read.
+ */
+inline int CED_GetString(int fh, char *szText, int nMax)
+{
+	return ioctl(fh, IOCTL_CED_GETSTRING(nMax), szText);
+}
 
-inline int CED_GetString(int fh, char* szText, int nMax){return ioctl(fh, IOCTL_CED_GETSTRING(nMax), szText);}
-// return the count of characters returned. If the string was terminated by CR or 0, then the 0 is part
-// of the count. Otherwise, we will add a zero if there is room, but it is not included in the count.
-// The return value is 0 if there was nothing to read.
+/* returns space in the output buffer. */
+inline int CED_GetOutBufSpace(int fh)
+{
+	return ioctl(fh, IOCTL_CED_GETOUTBUFSPACE);
+}
 
-inline int CED_GetOutBufSpace(int fh){return ioctl(fh, IOCTL_CED_GETOUTBUFSPACE);}
-// returns space in the output buffer.
+/* This always returns -1 as not implemented. */
+inline int CED_GetBaseAddress(int fh)
+{
+	return ioctl(fh, IOCTL_CED_GETBASEADDRESS);
+}
 
-inline int CED_GetBaseAddress(int fh){return ioctl(fh, IOCTL_CED_GETBASEADDRESS);}
-// This always returns -1 as not implemented.
+/* returns the major revision <<16 | minor revision. */
+inline int CED_GetDriverRevision(int fh)
+{
+	return ioctl(fh, IOCTL_CED_GETDRIVERREVISION);
+}
 
-inline int CED_GetDriverRevision(int fh){return ioctl(fh, IOCTL_CED_GETDRIVERREVISION);}
-// returns the major revision <<16 | minor revision.
+inline int CED_SetTransfer(int fh, TRANSFERDESC *pTD)
+{
+	return ioctl(fh, IOCTL_CED_SETTRANSFER, pTD);
+}
 
-inline int CED_SetTransfer(int fh, TRANSFERDESC* pTD){return ioctl(fh, IOCTL_CED_SETTRANSFER, pTD);}
+inline int CED_UnsetTransfer(int fh, int nArea)
+{
+	return ioctl(fh, IOCTL_CED_UNSETTRANSFER, nArea);
+}
 
-inline int CED_UnsetTransfer(int fh, int nArea){return ioctl(fh, IOCTL_CED_UNSETTRANSFER, nArea);}
+inline int CED_SetEvent(int fh, TRANSFEREVENT *pTE)
+{
+	return ioctl(fh, IOCTL_CED_SETEVENT, pTE);
+}
 
-inline int CED_SetEvent(int fh, TRANSFEREVENT* pTE){return ioctl(fh, IOCTL_CED_SETEVENT, pTE);}
+inline int CED_GetTransfer(int fh, TGET_TX_BLOCK *pTX)
+{
+	return ioctl(fh, IOCTL_CED_GETTRANSFER, pTX);
+}
 
-inline int CED_GetTransfer(int fh, TGET_TX_BLOCK* pTX){return ioctl(fh, IOCTL_CED_GETTRANSFER, pTX);}
+inline int CED_KillIO1401(int fh)
+{
+	return ioctl(fh, IOCTL_CED_KILLIO1401);
+}
 
-inline int CED_KillIO1401(int fh){return ioctl(fh, IOCTL_CED_KILLIO1401);}
+/* returns 0 if no active DMA, 1 if active */
+inline int CED_BlkTransState(int fh)
+{
+	return ioctl(fh, IOCTL_CED_BLKTRANSSTATE);
+}
 
-inline int CED_BlkTransState(int fh){return ioctl(fh, IOCTL_CED_BLKTRANSSTATE);}
-// returns 0 if no active DMA, 1 if active
+inline int CED_StateOf1401(int fh)
+{
+	return ioctl(fh, IOCTL_CED_STATEOF1401);
+}
 
-inline int CED_StateOf1401(int fh){return ioctl(fh, IOCTL_CED_STATEOF1401);}
+inline int CED_Grab1401(int fh)
+{
+	return ioctl(fh, IOCTL_CED_GRAB1401);
+}
 
-inline int CED_Grab1401(int fh){return ioctl(fh, IOCTL_CED_GRAB1401);}
-inline int CED_Free1401(int fh){return ioctl(fh, IOCTL_CED_FREE1401);}
+inline int CED_Free1401(int fh)
+{
+	return ioctl(fh, IOCTL_CED_FREE1401);
+}
 
-inline int CED_StartSelfTest(int fh){return ioctl(fh, IOCTL_CED_STARTSELFTEST);}
-inline int CED_CheckSelfTest(int fh, TGET_SELFTEST* pGST){return ioctl(fh, IOCTL_CED_CHECKSELFTEST, pGST);}
+inline int CED_StartSelfTest(int fh)
+{
+	return ioctl(fh, IOCTL_CED_STARTSELFTEST);
+}
+
+inline int CED_CheckSelfTest(int fh, TGET_SELFTEST *pGST)
+{
+	return ioctl(fh, IOCTL_CED_CHECKSELFTEST, pGST);
+}
+
+inline int CED_TypeOf1401(int fh)
+{
+	return ioctl(fh, IOCTL_CED_TYPEOF1401);
+}
+
+inline int CED_TransferFlags(int fh)
+{
+	return ioctl(fh, IOCTL_CED_TRANSFERFLAGS);
+}
+
+inline int CED_DbgPeek(int fh, TDBGBLOCK *pDB)
+{
+	return ioctl(fh, IOCTL_CED_DBGPEEK, pDB);
+}
+
+inline int CED_DbgPoke(int fh, TDBGBLOCK *pDB)
+{
+	return ioctl(fh, IOCTL_CED_DBGPOKE, pDB);
+}
+
+inline int CED_DbgRampData(int fh, TDBGBLOCK *pDB)
+{
+	return ioctl(fh, IOCTL_CED_DBGRAMPDATA, pDB);
+}
 
-inline int CED_TypeOf1401(int fh){return ioctl(fh, IOCTL_CED_TYPEOF1401);}
-inline int CED_TransferFlags(int fh){return ioctl(fh, IOCTL_CED_TRANSFERFLAGS);}
+inline int CED_DbgRampAddr(int fh, TDBGBLOCK *pDB)
+{
+	return ioctl(fh, IOCTL_CED_DBGRAMPADDR, pDB);
+}
 
-inline int CED_DbgPeek(int fh, TDBGBLOCK* pDB){return ioctl(fh, IOCTL_CED_DBGPEEK, pDB);}
-inline int CED_DbgPoke(int fh, TDBGBLOCK* pDB){return ioctl(fh, IOCTL_CED_DBGPOKE, pDB);}
-inline int CED_DbgRampData(int fh, TDBGBLOCK* pDB){return ioctl(fh, IOCTL_CED_DBGRAMPDATA, pDB);}
-inline int CED_DbgRampAddr(int fh, TDBGBLOCK* pDB){return ioctl(fh, IOCTL_CED_DBGRAMPADDR, pDB);}
-inline int CED_DbgGetData(int fh, TDBGBLOCK* pDB){return ioctl(fh, IOCTL_CED_DBGGETDATA, pDB);}
-inline int CED_DbgStopLoop(int fh){return ioctl(fh, IOCTL_CED_DBGSTOPLOOP);}
+inline int CED_DbgGetData(int fh, TDBGBLOCK *pDB)
+{
+	return ioctl(fh, IOCTL_CED_DBGGETDATA, pDB);
+}
 
-inline int CED_FullReset(int fh){return ioctl(fh, IOCTL_CED_FULLRESET);}
+inline int CED_DbgStopLoop(int fh)
+{
+	return ioctl(fh, IOCTL_CED_DBGSTOPLOOP);
+}
 
-inline int CED_SetCircular(int fh, TRANSFERDESC* pTD){return ioctl(fh, IOCTL_CED_SETCIRCULAR, pTD);}
-inline int CED_GetCircBlock(int fh, TCIRCBLOCK* pCB){return ioctl(fh, IOCTL_CED_GETCIRCBLOCK, pCB);}
-inline int CED_FreeCircBlock(int fh, TCIRCBLOCK* pCB){return ioctl(fh, IOCTL_CED_FREECIRCBLOCK, pCB);}
+inline int CED_FullReset(int fh)
+{
+	return ioctl(fh, IOCTL_CED_FULLRESET);
+}
 
-inline int CED_WaitEvent(int fh, int nArea, int msTimeOut){return ioctl(fh, IOCTL_CED_WAITEVENT, (nArea & 0xff)|(msTimeOut << 8));}
-inline int CED_TestEvent(int fh, int nArea){return ioctl(fh, IOCTL_CED_TESTEVENT, nArea);}
+inline int CED_SetCircular(int fh, TRANSFERDESC *pTD)
+{
+	return ioctl(fh, IOCTL_CED_SETCIRCULAR, pTD);
+}
+
+inline int CED_GetCircBlock(int fh, TCIRCBLOCK *pCB)
+{
+	return ioctl(fh, IOCTL_CED_GETCIRCBLOCK, pCB);
+}
+
+inline int CED_FreeCircBlock(int fh, TCIRCBLOCK *pCB)
+{
+	return ioctl(fh, IOCTL_CED_FREECIRCBLOCK, pCB);
+}
+
+inline int CED_WaitEvent(int fh, int nArea, int msTimeOut)
+{
+	return ioctl(fh, IOCTL_CED_WAITEVENT, (nArea & 0xff)|(msTimeOut << 8));
+}
+
+inline int CED_TestEvent(int fh, int nArea)
+{
+	return ioctl(fh, IOCTL_CED_TESTEVENT, nArea);
+}
 #endif
 
 #ifdef NOTWANTEDYET
-#define  IOCTL_CED_REGCALLBACK          _IO(CED_MAGIC_IOC,9)    // Not used
-#define  IOCTL_CED_GETMONITORBUF        _IO(CED_MAGIC_IOC,10)   // Not used
+#define IOCTL_CED_REGCALLBACK		_IO(CED_MAGIC_IOC, 9)	/* Not used */
+#define IOCTL_CED_GETMONITORBUF		_IO(CED_MAGIC_IOC, 10)	/* Not used */
 
-#define  IOCTL_CED_BYTECOUNT            _IO(CED_MAGIC_IOC,20)   // Not used
-#define  IOCTL_CED_ZEROBLOCKCOUNT       _IO(CED_MAGIC_IOC,21)   // Not used
-#define  IOCTL_CED_STOPCIRCULAR         _IO(CED_MAGIC_IOC,22)   // Not used
+#define IOCTL_CED_BYTECOUNT		_IO(CED_MAGIC_IOC, 20)	/* Not used */
+#define IOCTL_CED_ZEROBLOCKCOUNT	_IO(CED_MAGIC_IOC, 21)	/* Not used */
+#define IOCTL_CED_STOPCIRCULAR		_IO(CED_MAGIC_IOC, 22)	/* Not used */
 
-#define  IOCTL_CED_REGISTERS1401        _IO(CED_MAGIC_IOC,24)   // Not used
-#define  IOCTL_CED_STEP1401             _IO(CED_MAGIC_IOC,27)   // Not used
-#define  IOCTL_CED_SET1401REGISTERS     _IO(CED_MAGIC_IOC,28)   // Not used
-#define  IOCTL_CED_STEPTILL1401         _IO(CED_MAGIC_IOC,29)   // Not used
-#define  IOCTL_CED_SETORIN              _IO(CED_MAGIC_IOC,30)   // Not used
+#define IOCTL_CED_REGISTERS1401		_IO(CED_MAGIC_IOC, 24)	/* Not used */
+#define IOCTL_CED_STEP1401		_IO(CED_MAGIC_IOC, 27)	/* Not used */
+#define IOCTL_CED_SET1401REGISTERS	_IO(CED_MAGIC_IOC, 28)	/* Not used */
+#define IOCTL_CED_STEPTILL1401		_IO(CED_MAGIC_IOC, 29)	/* Not used */
+#define IOCTL_CED_SETORIN		_IO(CED_MAGIC_IOC, 30)	/* Not used */
 
 #endif
 
-// __CED_IOCTL_H__
+/* __CED_IOCTL_H__ */
 #endif

drivers/staging/ced1401/usb1401.c

@@ -23,7 +23,6 @@
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
-
 Endpoints
 *********
 There are 4 endpoints plus the control endpoint in the standard interface
@@ -92,14 +91,13 @@ synchronous non-Urb based transfers.
 #include <linux/highmem.h>
 #include <linux/version.h>
 #if ( LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35) )
-  #include <linux/init.h>
-  #include <linux/slab.h>
-  #include <linux/module.h>
-  #include <linux/kref.h>
-  #include <linux/uaccess.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/kref.h>
+#include <linux/uaccess.h>
 #endif
 
-
 #include "usb1401.h"
 
 /* Define these values to match your devices */
@@ -107,13 +105,12 @@ synchronous non-Urb based transfers.
 #define USB_CED_PRODUCT_ID	0xa0f0
 
 /* table of devices that work with this driver */
-static const struct usb_device_id ced_table[] =
-{
-    { USB_DEVICE(USB_CED_VENDOR_ID, USB_CED_PRODUCT_ID) },
-    { }					/* Terminating entry */
+static const struct usb_device_id ced_table[] = {
+	{USB_DEVICE(USB_CED_VENDOR_ID, USB_CED_PRODUCT_ID)},
+	{}			/* Terminating entry */
 };
-MODULE_DEVICE_TABLE(usb, ced_table);
 
+MODULE_DEVICE_TABLE(usb, ced_table);
 
 /* Get a minor range for your devices from the usb maintainer */
 #define USB_CED_MINOR_BASE	192
@@ -134,151 +131,152 @@ The cause for these errors is that the driver makes use of the functions usb_buf
    This is needed on Debian 2.6.32-5-amd64
 */
 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) )
-  #define usb_alloc_coherent usb_buffer_alloc
-  #define usb_free_coherent  usb_buffer_free
-  #define noop_llseek NULL
+#define usb_alloc_coherent usb_buffer_alloc
+#define usb_free_coherent  usb_buffer_free
+#define noop_llseek NULL
 #endif
 
 static struct usb_driver ced_driver;
 
 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.
-    usb_free_coherent(pdx->udev, OUTBUF_SZ, pdx->pCoherCharOut, pdx->pUrbCharOut->transfer_dma);
-    usb_free_urb(pdx->pUrbCharOut);
-
-    // 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
-    usb_free_coherent(pdx->udev, STAGED_SZ, pdx->pCoherStagedIO, pdx->pStagedUrb->transfer_dma);
-    usb_free_urb(pdx->pStagedUrb);
-
-    usb_put_dev(pdx->udev);
-    kfree(pdx);
+	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.
+	usb_free_coherent(pdx->udev, OUTBUF_SZ, pdx->pCoherCharOut,
+			  pdx->pUrbCharOut->transfer_dma);
+	usb_free_urb(pdx->pUrbCharOut);
+
+	// 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
+	usb_free_coherent(pdx->udev, STAGED_SZ, pdx->pCoherStagedIO,
+			  pdx->pStagedUrb->transfer_dma);
+	usb_free_urb(pdx->pStagedUrb);
+
+	usb_put_dev(pdx->udev);
+	kfree(pdx);
 }
 
 // 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;
-    int retval = 0;
-    int subminor = iminor(inode);
-    struct usb_interface* interface = usb_find_interface(&ced_driver, subminor);
-    if (!interface)
-    {
-        pr_err("%s - error, can't find device for minor %d", __func__, subminor);
-        retval = -ENODEV;
-        goto exit;
-    }
-
-    pdx = usb_get_intfdata(interface);
-    if (!pdx)
-    {
-        retval = -ENODEV;
-        goto exit;
-    }
-
-    dev_dbg(&interface->dev, "%s got pdx", __func__);
-
-    /* increment our usage count for the device */
-    kref_get(&pdx->kref);
-
-    /* lock the device to allow correctly handling errors
-     * in resumption */
-    mutex_lock(&pdx->io_mutex);
-
-    if (!pdx->open_count++)
-    {
-        retval = usb_autopm_get_interface(interface);
-        if (retval)
-        {
-            pdx->open_count--;
-            mutex_unlock(&pdx->io_mutex);
-            kref_put(&pdx->kref, ced_delete);
-            goto exit;
-        }
-    }
-    else
-    {   //uncomment this block if you want exclusive open
-        dev_err(&interface->dev, "%s fail: already open", __func__);
+	DEVICE_EXTENSION *pdx;
+	int retval = 0;
+	int subminor = iminor(inode);
+	struct usb_interface *interface =
+	    usb_find_interface(&ced_driver, subminor);
+	if (!interface) {
+		pr_err("%s - error, can't find device for minor %d", __func__,
+		       subminor);
+		retval = -ENODEV;
+		goto exit;
+	}
+
+	pdx = usb_get_intfdata(interface);
+	if (!pdx) {
+		retval = -ENODEV;
+		goto exit;
+	}
+
+	dev_dbg(&interface->dev, "%s got pdx", __func__);
+
+	/* increment our usage count for the device */
+	kref_get(&pdx->kref);
+
+	/* lock the device to allow correctly handling errors
+	 * in resumption */
+	mutex_lock(&pdx->io_mutex);
+
+	if (!pdx->open_count++) {
+		retval = usb_autopm_get_interface(interface);
+		if (retval) {
+			pdx->open_count--;
+			mutex_unlock(&pdx->io_mutex);
+			kref_put(&pdx->kref, ced_delete);
+			goto exit;
+		}
+	} else {		//uncomment this block if you want exclusive open
+		dev_err(&interface->dev, "%s fail: already open", __func__);
 		retval = -EBUSY;
 		pdx->open_count--;
 		mutex_unlock(&pdx->io_mutex);
 		kref_put(&pdx->kref, ced_delete);
 		goto exit;
 	}
-    /* prevent the device from being autosuspended */
+	/* prevent the device from being autosuspended */
 
-    /* save our object in the file's private structure */
-    file->private_data = pdx;
-    mutex_unlock(&pdx->io_mutex);
+	/* save our object in the file's private structure */
+	file->private_data = pdx;
+	mutex_unlock(&pdx->io_mutex);
 
 exit:
-    return retval;
+	return retval;
 }
 
 static int ced_release(struct inode *inode, struct file *file)
 {
-    DEVICE_EXTENSION *pdx = file->private_data;
-    if (pdx == NULL)
-        return -ENODEV;
-
-    dev_dbg(&pdx->interface->dev,"%s called", __func__);
-    mutex_lock(&pdx->io_mutex);
-    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
-    return 0;
+	DEVICE_EXTENSION *pdx = file->private_data;
+	if (pdx == NULL)
+		return -ENODEV;
+
+	dev_dbg(&pdx->interface->dev, "%s called", __func__);
+	mutex_lock(&pdx->io_mutex);
+	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
+	return 0;
 }
 
 static int ced_flush(struct file *file, fl_owner_t id)
 {
-    int res;
-    DEVICE_EXTENSION *pdx = file->private_data;
-    if (pdx == NULL)
-        return -ENODEV;
+	int res;
+	DEVICE_EXTENSION *pdx = file->private_data;
+	if (pdx == NULL)
+		return -ENODEV;
 
-    dev_dbg(&pdx->interface->dev,"%s char in pend=%d", __func__, pdx->bReadCharsPending);
+	dev_dbg(&pdx->interface->dev, "%s char in pend=%d", __func__,
+		pdx->bReadCharsPending);
 
-    /* wait for io to stop */
-    mutex_lock(&pdx->io_mutex);
-    dev_dbg(&pdx->interface->dev,"%s got io_mutex", __func__);
-    ced_draw_down(pdx);
+	/* wait for io to stop */
+	mutex_lock(&pdx->io_mutex);
+	dev_dbg(&pdx->interface->dev, "%s got io_mutex", __func__);
+	ced_draw_down(pdx);
 
-    /* read out errors, leave subsequent opens a clean slate */
-    spin_lock_irq(&pdx->err_lock);
-    res = pdx->errors ? (pdx->errors == -EPIPE ? -EPIPE : -EIO) : 0;
-    pdx->errors = 0;
-    spin_unlock_irq(&pdx->err_lock);
+	/* read out errors, leave subsequent opens a clean slate */
+	spin_lock_irq(&pdx->err_lock);
+	res = pdx->errors ? (pdx->errors == -EPIPE ? -EPIPE : -EIO) : 0;
+	pdx->errors = 0;
+	spin_unlock_irq(&pdx->err_lock);
 
-    mutex_unlock(&pdx->io_mutex);
-    dev_dbg(&pdx->interface->dev,"%s exit reached", __func__);
+	mutex_unlock(&pdx->io_mutex);
+	dev_dbg(&pdx->interface->dev, "%s exit reached", __func__);
 
-    return res;
+	return res;
 }
 
-
 static ssize_t ced_read(struct file *file, char *buffer, size_t count,
-                        loff_t *ppos)
+			loff_t * ppos)
 {
-    DEVICE_EXTENSION *pdx = file->private_data;
-    dev_err(&pdx->interface->dev, "%s called: use ioctl for cedusb", __func__);
-    return 0;           // as we do not do reads this way
+	DEVICE_EXTENSION *pdx = file->private_data;
+	dev_err(&pdx->interface->dev, "%s called: use ioctl for cedusb",
+		__func__);
+	return 0;		// as we do not do reads this way
 }
 
 static ssize_t ced_write(struct file *file, const char *user_buffer,
-                         size_t count, loff_t *ppos)
+			 size_t count, loff_t * ppos)
 {
-    DEVICE_EXTENSION *pdx = file->private_data;
-    dev_err(&pdx->interface->dev, "%s called: use ioctl for cedusb", __func__);
-    return 0;
+	DEVICE_EXTENSION *pdx = file->private_data;
+	dev_err(&pdx->interface->dev, "%s called: use ioctl for cedusb",
+		__func__);
+	return 0;
 }
 
 /***************************************************************************
@@ -288,80 +286,86 @@ static ssize_t ced_write(struct file *file, const char *user_buffer,
 ** not help with a device extension held by a file.
 ** return true if can accept new io requests, else false
 */
-static bool CanAcceptIoRequests(DEVICE_EXTENSION* pdx)
+static bool CanAcceptIoRequests(DEVICE_EXTENSION * pdx)
 {
-    return pdx && pdx->interface;	        // Can we accept IO requests
+	return pdx && pdx->interface;	// Can we accept IO requests
 }
 
 /****************************************************************************
 ** Callback routine to complete writes. This may need to fire off another
 ** urb to complete the transfer.
 ****************************************************************************/
-static void ced_writechar_callback(struct urb* pUrb)
+static void ced_writechar_callback(struct urb *pUrb)
 {
-    DEVICE_EXTENSION *pdx = pUrb->context;
-    int nGot = pUrb->actual_length;             // what we transferred
-
-    if (pUrb->status)
-    {                                           // sync/async unlink faults aren't errors
-        if (!(pUrb->status == -ENOENT || pUrb->status == -ECONNRESET || pUrb->status == -ESHUTDOWN))
-        {
-            dev_err(&pdx->interface->dev, "%s - nonzero write bulk status received: %d", __func__, pUrb->status);
-        }
-
-        spin_lock(&pdx->err_lock);
-        pdx->errors = pUrb->status;
-        spin_unlock(&pdx->err_lock);
-        nGot = 0;                               //  and tidy up again if so
-
-        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
-        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
-            pdx->dwOutBuffGet = 0;
-
-        if (pdx->dwNumOutput > 0)               // if more to be done...
-        {
-            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?
-                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
-            usb_fill_bulk_urb(pdx->pUrbCharOut, pdx->udev,
-                              usb_sndbulkpipe(pdx->udev, pdx->epAddr[0]),
-                              pdx->pCoherCharOut, dwCount, 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
-            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
-            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);
-                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
-    }
+	DEVICE_EXTENSION *pdx = pUrb->context;
+	int nGot = pUrb->actual_length;	// what we transferred
+
+	if (pUrb->status) {	// sync/async unlink faults aren't errors
+		if (!
+		    (pUrb->status == -ENOENT || pUrb->status == -ECONNRESET
+		     || pUrb->status == -ESHUTDOWN)) {
+			dev_err(&pdx->interface->dev,
+				"%s - nonzero write bulk status received: %d",
+				__func__, pUrb->status);
+		}
+
+		spin_lock(&pdx->err_lock);
+		pdx->errors = pUrb->status;
+		spin_unlock(&pdx->err_lock);
+		nGot = 0;	//  and tidy up again if so
+
+		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
+		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
+			pdx->dwOutBuffGet = 0;
+
+		if (pdx->dwNumOutput > 0)	// if more to be done...
+		{
+			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?
+				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
+			usb_fill_bulk_urb(pdx->pUrbCharOut, pdx->udev,
+					  usb_sndbulkpipe(pdx->udev,
+							  pdx->epAddr[0]),
+					  pdx->pCoherCharOut, dwCount,
+					  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
+			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
+			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);
+				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
+	}
 }
 
 /****************************************************************************
@@ -369,93 +373,91 @@ static void ced_writechar_callback(struct urb* pUrb)
 ** Transmit the characters in the output buffer to the 1401. This may need
 ** breaking down into multiple transfers.
 ****************************************************************************/
-int SendChars(DEVICE_EXTENSION* pdx)
+int SendChars(DEVICE_EXTENSION * pdx)
 {
-    int iReturn = U14ERR_NOERROR;
-
-    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
-    {
-        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 (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
-
-            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
-                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
-                if (nSent <= 0)
-                {
-                    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);
-                }
-                else
-                {
-                    dev_dbg(&pdx->interface->dev, "Sent %d chars by EP0", n);
-                    count -= nSent;
-                    index += nSent;
-                }
-            }
-
-            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
-            char* pDat = &pdx->outputBuffer[pdx->dwOutBuffGet];
-
-            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
-            usb_fill_bulk_urb(pdx->pUrbCharOut, pdx->udev,
-                              usb_sndbulkpipe(pdx->udev, pdx->epAddr[0]),
-                              pdx->pCoherCharOut, dwCount, ced_writechar_callback, pdx);
-            pdx->pUrbCharOut->transfer_flags |= 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
-            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
-            }
-        }
-    }
-    else
-        if (pdx->bSendCharsPending && (pdx->dwNumOutput > 0))
-            dev_dbg(&pdx->interface->dev, "SendChars bSendCharsPending:true");
-
-
-    dev_dbg(&pdx->interface->dev, "SendChars exit code: %d", iReturn);
-    spin_unlock_irq(&pdx->charOutLock);             // Now let go of the spinlock
-    return iReturn;
+	int iReturn = U14ERR_NOERROR;
+
+	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
+	{
+		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 (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
+
+			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
+				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
+				if (nSent <= 0) {
+					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);
+				} else {
+					dev_dbg(&pdx->interface->dev,
+						"Sent %d chars by EP0", n);
+					count -= nSent;
+					index += nSent;
+				}
+			}
+
+			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
+			char *pDat = &pdx->outputBuffer[pdx->dwOutBuffGet];
+
+			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
+			usb_fill_bulk_urb(pdx->pUrbCharOut, pdx->udev,
+					  usb_sndbulkpipe(pdx->udev,
+							  pdx->epAddr[0]),
+					  pdx->pCoherCharOut, dwCount,
+					  ced_writechar_callback, pdx);
+			pdx->pUrbCharOut->transfer_flags |=
+			    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
+			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
+			}
+		}
+	} else if (pdx->bSendCharsPending && (pdx->dwNumOutput > 0))
+		dev_dbg(&pdx->interface->dev,
+			"SendChars bSendCharsPending:true");
+
+	dev_dbg(&pdx->interface->dev, "SendChars exit code: %d", iReturn);
+	spin_unlock_irq(&pdx->charOutLock);	// Now let go of the spinlock
+	return iReturn;
 }
 
 /***************************************************************************
@@ -472,228 +474,265 @@ int SendChars(DEVICE_EXTENSION* pdx)
 ** pdx  Is our device extension which holds all we know about the transfer.
 ** n    The number of bytes to move one way or the other.
 ***************************************************************************/
-static void CopyUserSpace(DEVICE_EXTENSION *pdx, int n)
+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
-        unsigned int dwOffset = pdx->StagedDone + pdx->StagedOffset + pArea->dwBaseOffset;
-        char* pCoherBuf = pdx->pCoherStagedIO;      // coherent buffer
-        if (!pArea->bUsed)
-        {
-            dev_err(&pdx->interface->dev, "%s area %d unused", __func__, nArea);
-            return;
-        }
-
-        while (n)
-        {
-            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
-                    if (pdx->StagedRead)
-                        memcpy(pvAddress+uiPageOff, pCoherBuf, uiXfer);
-                    else
-                        memcpy(pCoherBuf, pvAddress+uiPageOff, uiXfer);
-                    kunmap_atomic(pvAddress);
-                    dwOffset += uiXfer;
-                    pCoherBuf += uiXfer;
-                    n -= uiXfer;
-                }
-                else
-                {
-                    dev_err(&pdx->interface->dev, "%s did not map page %d", __func__, nPage);
-                    return;
-                }
-
-            }
-            else
-            {
-                dev_err(&pdx->interface->dev, "%s exceeded pages %d", __func__, nPage);
-                return;
-            }
-        }
-    }
-    else
-        dev_err(&pdx->interface->dev, "%s bad area %d", __func__, nArea);
+	unsigned int nArea = pdx->StagedId;
+	if (nArea < MAX_TRANSAREAS) {
+		TRANSAREA *pArea = &pdx->rTransDef[nArea];	// area to be used
+		unsigned int dwOffset =
+		    pdx->StagedDone + pdx->StagedOffset + pArea->dwBaseOffset;
+		char *pCoherBuf = pdx->pCoherStagedIO;	// coherent buffer
+		if (!pArea->bUsed) {
+			dev_err(&pdx->interface->dev, "%s area %d unused",
+				__func__, nArea);
+			return;
+		}
+
+		while (n) {
+			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
+					if (pdx->StagedRead)
+						memcpy(pvAddress + uiPageOff,
+						       pCoherBuf, uiXfer);
+					else
+						memcpy(pCoherBuf,
+						       pvAddress + uiPageOff,
+						       uiXfer);
+					kunmap_atomic(pvAddress);
+					dwOffset += uiXfer;
+					pCoherBuf += uiXfer;
+					n -= uiXfer;
+				} else {
+					dev_err(&pdx->interface->dev,
+						"%s did not map page %d",
+						__func__, nPage);
+					return;
+				}
+
+			} else {
+				dev_err(&pdx->interface->dev,
+					"%s exceeded pages %d", __func__,
+					nPage);
+				return;
+			}
+		}
+	} else
+		dev_err(&pdx->interface->dev, "%s bad area %d", __func__,
+			nArea);
 }
 
 // Forward declarations for stuff used circularly
-static int StageChunk(DEVICE_EXTENSION *pdx);
+static int StageChunk(DEVICE_EXTENSION * pdx);
 /***************************************************************************
 ** ReadWrite_Complete
 **
 **  Completion routine for our staged read/write Irps
 */
-static void staged_callback(struct urb* pUrb)
+static void staged_callback(struct urb *pUrb)
 {
-    DEVICE_EXTENSION *pdx = pUrb->context;
-    unsigned int nGot = pUrb->actual_length;     // what we transferred
-    bool bCancel = false;
-    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
-
-    if (pUrb->status)
-    {   // sync/async unlink faults aren't errors
-        if (!(pUrb->status == -ENOENT || pUrb->status == -ECONNRESET || pUrb->status == -ESHUTDOWN))
-        {
-            dev_err(&pdx->interface->dev, "%s - nonzero write bulk status received: %d", __func__, pUrb->status);
-        }
-        else
-            dev_info(&pdx->interface->dev, "%s - staged xfer cancelled", __func__);
-
-        spin_lock(&pdx->err_lock);
-        pdx->errors = pUrb->status;
-        spin_unlock(&pdx->err_lock);
-        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 (nGot == 0)
-            dev_dbg(&pdx->interface->dev, "%s ZLP", __func__);
-    }
-
-    // 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
-    {
-        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
-        {
-            if (pArea->aBlocks[1].dwSize > 0)           // If block 1 is in use we must append to it
-            {
-                if (pdx->StagedOffset == (pArea->aBlocks[1].dwOffset + pArea->aBlocks[1].dwSize))
-                {
-                    pArea->aBlocks[1].dwSize += pdx->StagedLength;
-                    dev_dbg(&pdx->interface->dev, "RWM_Complete, circ block 1 now %d bytes at %d",
-                                                   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
-                    pArea->aBlocks[1].dwOffset = pdx->StagedOffset;
-                    pArea->aBlocks[1].dwSize = pdx->StagedLength;
-                    dev_err(&pdx->interface->dev, "%s ERROR, circ block 1 re-started %d bytes at %d",
-                                                   __func__, pArea->aBlocks[1].dwSize, pArea->aBlocks[1].dwOffset);
-                }
-            }
-            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 (pdx->StagedOffset == (pArea->aBlocks[0].dwOffset + pArea->aBlocks[0].dwSize))
-                    {
-                        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
-                    {
-                        pArea->aBlocks[1].dwOffset = pdx->StagedOffset;
-                        pArea->aBlocks[1].dwSize = pdx->StagedLength;
-                        dev_dbg(&pdx->interface->dev, "RWM_Complete, circ block 1 started %d bytes at %d",
-                                                       pArea->aBlocks[1].dwSize, pArea->aBlocks[1].dwOffset);
-                    }
-                }
-                else                                    // No info stored yet, just save in block 0
-                {
-                    pArea->aBlocks[0].dwOffset = pdx->StagedOffset;
-                    pArea->aBlocks[0].dwSize = pdx->StagedLength;
-                    dev_dbg(&pdx->interface->dev, "RWM_Complete, circ block 0 started %d bytes at %d",
-                                                   pArea->aBlocks[0].dwSize, pArea->aBlocks[0].dwOffset);
-                }
-            }
-        }
-
-        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?
-            {
-                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;
-                    iWakeUp = (dwTotal >= pArea->dwEventSz);
-                }
-                else
-                {
-                    unsigned int transEnd = pdx->StagedOffset + pdx->StagedLength;
-                    unsigned int eventEnd = pArea->dwEventSt + pArea->dwEventSz;
-                    iWakeUp = (pdx->StagedOffset < eventEnd) && (transEnd > pArea->dwEventSt);
-                }
-
-                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
-                }
-            }
-        }
-
-        pdx->dwDMAFlag = MODE_CHAR;                     // Switch back to char mode before ReadWriteMem call
-
-        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?
-            {
-                int iReturn;
-                dev_info(&pdx->interface->dev, "*** RWM_Complete *** pending transfer will now be set up!!!");
-                iReturn = ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard, pdx->rDMAInfo.wIdent, pdx->rDMAInfo.dwOffset, pdx->rDMAInfo.dwSize);
-
-                if (iReturn)
-                    dev_err(&pdx->interface->dev, "RWM_Complete rw setup failed %d", iReturn);
-            }
-        }
-
-    }
-    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.
-    bRestartCharInput = !bCancel && (pdx->dwDMAFlag == MODE_CHAR) && !pdx->bXFerWaiting;
-
-    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, true);                              // ...Allowi tests a lock too.
-    dev_dbg(&pdx->interface->dev, "%s done", __func__);
+	DEVICE_EXTENSION *pdx = pUrb->context;
+	unsigned int nGot = pUrb->actual_length;	// what we transferred
+	bool bCancel = false;
+	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
+
+	if (pUrb->status) {	// sync/async unlink faults aren't errors
+		if (!
+		    (pUrb->status == -ENOENT || pUrb->status == -ECONNRESET
+		     || pUrb->status == -ESHUTDOWN)) {
+			dev_err(&pdx->interface->dev,
+				"%s - nonzero write bulk status received: %d",
+				__func__, pUrb->status);
+		} else
+			dev_info(&pdx->interface->dev,
+				 "%s - staged xfer cancelled", __func__);
+
+		spin_lock(&pdx->err_lock);
+		pdx->errors = pUrb->status;
+		spin_unlock(&pdx->err_lock);
+		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 (nGot == 0)
+			dev_dbg(&pdx->interface->dev, "%s ZLP", __func__);
+	}
+
+	// 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
+	{
+		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
+		{
+			if (pArea->aBlocks[1].dwSize > 0)	// If block 1 is in use we must append to it
+			{
+				if (pdx->StagedOffset ==
+				    (pArea->aBlocks[1].dwOffset +
+				     pArea->aBlocks[1].dwSize)) {
+					pArea->aBlocks[1].dwSize +=
+					    pdx->StagedLength;
+					dev_dbg(&pdx->interface->dev,
+						"RWM_Complete, circ block 1 now %d bytes at %d",
+						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
+					pArea->aBlocks[1].dwOffset =
+					    pdx->StagedOffset;
+					pArea->aBlocks[1].dwSize =
+					    pdx->StagedLength;
+					dev_err(&pdx->interface->dev,
+						"%s ERROR, circ block 1 re-started %d bytes at %d",
+						__func__,
+						pArea->aBlocks[1].dwSize,
+						pArea->aBlocks[1].dwOffset);
+				}
+			} 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 (pdx->StagedOffset ==
+					    (pArea->aBlocks[0].dwOffset +
+					     pArea->aBlocks[0].dwSize)) {
+						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
+					{
+						pArea->aBlocks[1].dwOffset =
+						    pdx->StagedOffset;
+						pArea->aBlocks[1].dwSize =
+						    pdx->StagedLength;
+						dev_dbg(&pdx->interface->dev,
+							"RWM_Complete, circ block 1 started %d bytes at %d",
+							pArea->aBlocks[1].
+							dwSize,
+							pArea->aBlocks[1].
+							dwOffset);
+					}
+				} else	// No info stored yet, just save in block 0
+				{
+					pArea->aBlocks[0].dwOffset =
+					    pdx->StagedOffset;
+					pArea->aBlocks[0].dwSize =
+					    pdx->StagedLength;
+					dev_dbg(&pdx->interface->dev,
+						"RWM_Complete, circ block 0 started %d bytes at %d",
+						pArea->aBlocks[0].dwSize,
+						pArea->aBlocks[0].dwOffset);
+				}
+			}
+		}
+
+		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?
+			{
+				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;
+					iWakeUp = (dwTotal >= pArea->dwEventSz);
+				} else {
+					unsigned int transEnd =
+					    pdx->StagedOffset +
+					    pdx->StagedLength;
+					unsigned int eventEnd =
+					    pArea->dwEventSt + pArea->dwEventSz;
+					iWakeUp = (pdx->StagedOffset < eventEnd)
+					    && (transEnd > pArea->dwEventSt);
+				}
+
+				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
+				}
+			}
+		}
+
+		pdx->dwDMAFlag = MODE_CHAR;	// Switch back to char mode before ReadWriteMem call
+
+		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?
+			{
+				int iReturn;
+				dev_info(&pdx->interface->dev,
+					 "*** RWM_Complete *** pending transfer will now be set up!!!");
+				iReturn =
+				    ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard,
+						 pdx->rDMAInfo.wIdent,
+						 pdx->rDMAInfo.dwOffset,
+						 pdx->rDMAInfo.dwSize);
+
+				if (iReturn)
+					dev_err(&pdx->interface->dev,
+						"RWM_Complete rw setup failed %d",
+						iReturn);
+			}
+		}
+
+	} 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.
+	bRestartCharInput = !bCancel && (pdx->dwDMAFlag == MODE_CHAR)
+	    && !pdx->bXFerWaiting;
+
+	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, true);	// ...Allowi tests a lock too.
+	dev_dbg(&pdx->interface->dev, "%s done", __func__);
 }
 
 /****************************************************************************
@@ -704,46 +743,50 @@ static void staged_callback(struct urb* pUrb)
 ** The calling code must have acquired the staging spinlock before calling
 **  this function, and is responsible for releasing it. We are at callback level.
 ****************************************************************************/
-static int StageChunk(DEVICE_EXTENSION *pdx)
+static int StageChunk(DEVICE_EXTENSION * pdx)
 {
-    int iReturn = U14ERR_NOERROR;
+	int iReturn = U14ERR_NOERROR;
 	unsigned int ChunkSize;
-    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
-        return U14ERR_FAIL;
-
-    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
-    }
-
-    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
-
-    usb_fill_bulk_urb(pdx->pStagedUrb, pdx->udev,
-                      pdx->StagedRead ? usb_rcvbulkpipe(pdx->udev, pdx->epAddr[nPipe]):
-                                        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
-    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
-        dev_err(&pdx->interface->dev, "%s submit urb failed, code %d", __func__, iReturn);
-    }
-    else
-        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);
-
-    return iReturn;
+	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
+		return U14ERR_FAIL;
+
+	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
+	}
+
+	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
+
+	usb_fill_bulk_urb(pdx->pStagedUrb, pdx->udev,
+			  pdx->StagedRead ? usb_rcvbulkpipe(pdx->udev,
+							    pdx->
+							    epAddr[nPipe]) :
+			  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
+	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
+		dev_err(&pdx->interface->dev, "%s submit urb failed, code %d",
+			__func__, iReturn);
+	} else
+		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);
+
+	return iReturn;
 }
 
 /***************************************************************************
@@ -763,85 +806,95 @@ static int StageChunk(DEVICE_EXTENSION *pdx)
 **             transfer.
 **    dwLen - the number of bytes to transfer.
 */
-int ReadWriteMem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent,
-                      unsigned int dwOffs, unsigned int dwLen)
+int ReadWriteMem(DEVICE_EXTENSION * pdx, bool Read, unsigned short wIdent,
+		 unsigned int dwOffs, unsigned int dwLen)
 {
-    TRANSAREA* pArea = &pdx->rTransDef[wIdent];     // Transfer area info
-
-    if (!CanAcceptIoRequests(pdx))         // Are we in a state to accept new requests?
-    {
-		dev_err(&pdx->interface->dev, "%s can't accept requests", __func__);
-        return U14ERR_FAIL;
-    }
-
-    dev_dbg(&pdx->interface->dev, "%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.
-    if (pdx->bStagedUrbPending)
-    {
-        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
-    {
-		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
-
-	    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?
-        {
-            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
-                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?
-            {
-                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
-            }
-        }
-
-        if (bWait)                                  // This transfer will have to wait?
-        {
-            pdx->bXFerWaiting = true;               // Flag we are waiting
-    		dev_dbg(&pdx->interface->dev, "%s xfer waiting for circular buffer space", __func__);
-            return U14ERR_NOERROR;
-        }
-
-  		dev_dbg(&pdx->interface->dev, "%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
-    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
+	TRANSAREA *pArea = &pdx->rTransDef[wIdent];	// Transfer area info
+
+	if (!CanAcceptIoRequests(pdx))	// Are we in a state to accept new requests?
+	{
+		dev_err(&pdx->interface->dev, "%s can't accept requests",
+			__func__);
+		return U14ERR_FAIL;
+	}
+
+	dev_dbg(&pdx->interface->dev,
+		"%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.
+	if (pdx->bStagedUrbPending) {
+		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
+	{
+		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
+
+		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?
+		{
+			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
+				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?
+			{
+				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
+			}
+		}
+
+		if (bWait)	// This transfer will have to wait?
+		{
+			pdx->bXFerWaiting = true;	// Flag we are waiting
+			dev_dbg(&pdx->interface->dev,
+				"%s xfer waiting for circular buffer space",
+				__func__);
+			return U14ERR_NOERROR;
+		}
+
+		dev_dbg(&pdx->interface->dev,
+			"%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
+	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
 
 //    KeClearEvent(&pdx->StagingDoneEvent);           // Clear the transfer done event
-    StageChunk(pdx);                                // fire off the first chunk
+	StageChunk(pdx);	// fire off the first chunk
 
-    return U14ERR_NOERROR;
+	return U14ERR_NOERROR;
 }
 
 /****************************************************************************
@@ -852,20 +905,21 @@ int ReadWriteMem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent,
 **  data we return FALSE. Used as part of decoding a DMA request.
 **
 ****************************************************************************/
-static bool ReadChar(unsigned char* pChar, char* pBuf, unsigned int* pdDone, unsigned int dGot)
+static bool ReadChar(unsigned char *pChar, char *pBuf, unsigned int *pdDone,
+		     unsigned int dGot)
 {
-    bool bRead = false;
-    unsigned int dDone = *pdDone;
-
-    if (dDone < dGot)                       // If there is more data
-    {
-        *pChar = (unsigned char)pBuf[dDone];// Extract the next char
-        dDone++;                            // Increment the done count
-        *pdDone = dDone;
-        bRead = true;                       // and flag success
-    }
-
-    return bRead;
+	bool bRead = false;
+	unsigned int dDone = *pdDone;
+
+	if (dDone < dGot)	// If there is more data
+	{
+		*pChar = (unsigned char)pBuf[dDone];	// Extract the next char
+		dDone++;	// Increment the done count
+		*pdDone = dDone;
+		bRead = true;	// and flag success
+	}
+
+	return bRead;
 }
 
 #ifdef NOTUSED
@@ -876,12 +930,14 @@ static bool ReadChar(unsigned char* pChar, char* pBuf, unsigned int* pdDone, uns
 ** Reads a word from the 1401, just uses ReadChar twice; passes on any error
 **
 *****************************************************************************/
-static bool ReadWord(unsigned short* pWord, char* pBuf, unsigned int* pdDone, unsigned int dGot)
+static bool ReadWord(unsigned short *pWord, char *pBuf, unsigned int *pdDone,
+		     unsigned int dGot)
 {
-    if (ReadChar((unsigned char*)pWord, pBuf, pdDone, dGot))
-        return ReadChar(((unsigned char*)pWord)+1, pBuf, pdDone, dGot);
-    else
-        return false;
+	if (ReadChar((unsigned char *)pWord, pBuf, pdDone, dGot))
+		return ReadChar(((unsigned char *)pWord) + 1, pBuf, pdDone,
+				dGot);
+	else
+		return false;
 }
 #endif
 
@@ -895,39 +951,35 @@ static bool ReadWord(unsigned short* pWord, char* pBuf, unsigned int* pdDone, un
 ** to indicate three byte total.
 **
 *****************************************************************************/
-static bool ReadHuff(volatile unsigned int* pDWord, char* pBuf, unsigned int* pdDone, unsigned int dGot)
+static bool ReadHuff(volatile unsigned int *pDWord, char *pBuf,
+		     unsigned int *pdDone, unsigned int dGot)
 {
-    unsigned char ucData;                /* for each read to ReadChar */
-    bool bReturn = true;                 /* assume we will succeed */
-    unsigned int dwData = 0;             /* Accumulator for the data */
-
-    if (ReadChar(&ucData, pBuf, pdDone, dGot))
-    {
-        dwData = ucData;                        /* copy the data */
-        if ((dwData & 0x00000080) != 0)         /* Bit set for more data ? */
-        {
-            dwData &= 0x0000007F;               /* Clear the relevant bit */
-            if (ReadChar(&ucData, pBuf, pdDone, dGot))
-            {
-                dwData = (dwData << 8) | ucData;
-                if ((dwData & 0x00004000) != 0) /* three byte sequence ? */
-                {
-                    dwData &= 0x00003FFF;       /* Clear the relevant bit */
-                    if (ReadChar(&ucData, pBuf, pdDone, dGot))
-                        dwData = (dwData << 8) | ucData;
-                    else
-                        bReturn = false;
-                }
-            }
-            else
-                bReturn = false;                /* couldn't read data */
-        }
-    }
-    else
-        bReturn = false;
-
-    *pDWord = dwData;                           /* return the data */
-    return bReturn;
+	unsigned char ucData;	/* for each read to ReadChar */
+	bool bReturn = true;	/* assume we will succeed */
+	unsigned int dwData = 0;	/* Accumulator for the data */
+
+	if (ReadChar(&ucData, pBuf, pdDone, dGot)) {
+		dwData = ucData;	/* copy the data */
+		if ((dwData & 0x00000080) != 0) {	/* Bit set for more data ? */
+			dwData &= 0x0000007F;	/* Clear the relevant bit */
+			if (ReadChar(&ucData, pBuf, pdDone, dGot)) {
+				dwData = (dwData << 8) | ucData;
+				if ((dwData & 0x00004000) != 0) {	/* three byte sequence ? */
+					dwData &= 0x00003FFF;	/* Clear the relevant bit */
+					if (ReadChar
+					    (&ucData, pBuf, pdDone, dGot))
+						dwData = (dwData << 8) | ucData;
+					else
+						bReturn = false;
+				}
+			} else
+				bReturn = false;	/* couldn't read data */
+		}
+	} else
+		bReturn = false;
+
+	*pDWord = dwData;	/* return the data */
+	return bReturn;
 }
 
 /***************************************************************************
@@ -944,66 +996,77 @@ static bool ReadHuff(volatile unsigned int* pDWord, char* pBuf, unsigned int* pd
 **  we start handling the data at offset zero.
 **
 *****************************************************************************/
-static bool ReadDMAInfo(volatile DMADESC* pDmaDesc, DEVICE_EXTENSION *pdx,
-                           char* pBuf, unsigned int dwCount)
+static bool ReadDMAInfo(volatile DMADESC * pDmaDesc, DEVICE_EXTENSION * pdx,
+			char *pBuf, unsigned int dwCount)
 {
-    bool bResult = false;       // assume we won't succeed
-    unsigned char ucData;
-    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
-
-        // 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
-
-        switch (ucTransCode)
-        {
-            case TM_EXTTOHOST:              // Extended linear transfer modes (the only ones!)
-            case TM_EXTTO1401:
-            {
-                bResult = ReadHuff(&(pDmaDesc->dwOffset), pBuf, &dDone, dwCount) &&
-                          ReadHuff(&(pDmaDesc->dwSize), pBuf, &dDone, dwCount);
-                if (bResult)
-                {
-                    dev_dbg(&pdx->interface->dev, "%s xfer offset & size %d %d",
-                            __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
-                        ((pDmaDesc->dwOffset + pDmaDesc->dwSize) > (pdx->rTransDef[wIdent].dwLength)))
-                    {
-                        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, pdx->rTransDef[wIdent].bUsed, pDmaDesc->dwOffset, pDmaDesc->dwSize,
-                                  pdx->rTransDef[wIdent].dwLength);
-                    }
-                }
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    else
-        bResult = false;
-
-    if (!bResult)                            // now check parameters for validity
-        dev_err(&pdx->interface->dev, "%s error reading Esc sequence", __func__);
-
-    return bResult;
+	bool bResult = false;	// assume we won't succeed
+	unsigned char ucData;
+	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
+
+		// 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
+
+		switch (ucTransCode) {
+		case TM_EXTTOHOST:	// Extended linear transfer modes (the only ones!)
+		case TM_EXTTO1401:
+			{
+				bResult =
+				    ReadHuff(&(pDmaDesc->dwOffset), pBuf,
+					     &dDone, dwCount)
+				    && ReadHuff(&(pDmaDesc->dwSize), pBuf,
+						&dDone, dwCount);
+				if (bResult) {
+					dev_dbg(&pdx->interface->dev,
+						"%s xfer offset & size %d %d",
+						__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
+					    ((pDmaDesc->dwOffset +
+					      pDmaDesc->dwSize) >
+					     (pdx->rTransDef[wIdent].
+					      dwLength))) {
+						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,
+							pdx->rTransDef[wIdent].
+							bUsed,
+							pDmaDesc->dwOffset,
+							pDmaDesc->dwSize,
+							pdx->rTransDef[wIdent].
+							dwLength);
+					}
+				}
+				break;
+			}
+		default:
+			break;
+		}
+	} else
+		bResult = false;
+
+	if (!bResult)		// now check parameters for validity
+		dev_err(&pdx->interface->dev, "%s error reading Esc sequence",
+			__func__);
+
+	return bResult;
 }
 
 /****************************************************************************
@@ -1020,122 +1083,130 @@ static bool ReadDMAInfo(volatile DMADESC* pDmaDesc, DEVICE_EXTENSION *pdx,
 **           this is known to be at least 2 or we will not be called.
 **
 ****************************************************************************/
-static int Handle1401Esc(DEVICE_EXTENSION* pdx, char* pCh, unsigned int dwCount)
+static int Handle1401Esc(DEVICE_EXTENSION * pdx, char *pCh,
+			 unsigned int dwCount)
 {
-    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
-    }
-    else
-    {
-        spin_lock(&pdx->stagedLock);                // Lock others out
-
-        if (ReadDMAInfo(&pdx->rDMAInfo, pdx, pCh, dwCount))    // Get DMA parameters
-        {
-            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
-                dev_err(&pdx->interface->dev, "ERROR: DMA setup while transfer still waiting");
-                spin_unlock(&pdx->stagedLock);
-            }
-            else
-            {
-                if ((wTransType == TM_EXTTOHOST) || (wTransType == TM_EXTTO1401))
-                {
-                    iReturn = ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard, pdx->rDMAInfo.wIdent, pdx->rDMAInfo.dwOffset, pdx->rDMAInfo.dwSize);
-                    if (iReturn != U14ERR_NOERROR)
-                        dev_err(&pdx->interface->dev, "%s ReadWriteMem() failed %d", __func__, iReturn);
-                }
-                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
-            dev_err(&pdx->interface->dev, "%s ReadDMAInfo() fail", __func__);
-
-        spin_unlock(&pdx->stagedLock);   // OK here
-    }
-
-    dev_dbg(&pdx->interface->dev, "%s returns %d", __func__, iReturn);
-
-    return iReturn;
+	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
+	} else {
+		spin_lock(&pdx->stagedLock);	// Lock others out
+
+		if (ReadDMAInfo(&pdx->rDMAInfo, pdx, pCh, dwCount))	// Get DMA parameters
+		{
+			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
+				dev_err(&pdx->interface->dev,
+					"ERROR: DMA setup while transfer still waiting");
+				spin_unlock(&pdx->stagedLock);
+			} else {
+				if ((wTransType == TM_EXTTOHOST)
+				    || (wTransType == TM_EXTTO1401)) {
+					iReturn =
+					    ReadWriteMem(pdx,
+							 !pdx->rDMAInfo.
+							 bOutWard,
+							 pdx->rDMAInfo.wIdent,
+							 pdx->rDMAInfo.dwOffset,
+							 pdx->rDMAInfo.dwSize);
+					if (iReturn != U14ERR_NOERROR)
+						dev_err(&pdx->interface->dev,
+							"%s ReadWriteMem() failed %d",
+							__func__, iReturn);
+				} 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
+			dev_err(&pdx->interface->dev, "%s ReadDMAInfo() fail",
+				__func__);
+
+		spin_unlock(&pdx->stagedLock);	// OK here
+	}
+
+	dev_dbg(&pdx->interface->dev, "%s returns %d", __func__, iReturn);
+
+	return iReturn;
 }
 
 /****************************************************************************
 ** Callback for the character read complete or error
 ****************************************************************************/
-static void ced_readchar_callback(struct urb* pUrb)
+static void ced_readchar_callback(struct urb *pUrb)
 {
-    DEVICE_EXTENSION *pdx = pUrb->context;
-    int nGot = pUrb->actual_length;             // what we transferred
-
-    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
-        if (!(pUrb->status == -ENOENT || pUrb->status == -ECONNRESET || pUrb->status == -ESHUTDOWN))
-        {
-            dev_err(&pdx->interface->dev, "%s - nonzero write bulk status received: %d", __func__, pUrb->status);
-        }
-        else
-            dev_dbg(&pdx->interface->dev, "%s - 0 chars pUrb->status=%d (shutdown?)", __func__, pUrb->status);
-
-        spin_lock(&pdx->err_lock);
-        pdx->errors = pUrb->status;
-        spin_unlock(&pdx->err_lock);
-        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
-    }
-    else
-    {
-        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
-        }
-        else
-        {
-            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
-                    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
-                for (i = 0; i < nGot; i++)
-                {
-                    pdx->inputBuffer[pdx->dwInBuffPut++] = pdx->pCoherCharIn[i] & 0x7F;
-                    if (pdx->dwInBuffPut >= INBUF_SZ)
-                        pdx->dwInBuffPut = 0;
-                }
-
-                if ((pdx->dwNumInput + nGot) <= INBUF_SZ)
-                    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
-
-    Allowi(pdx, true);                      // see if we can do the next one
+	DEVICE_EXTENSION *pdx = pUrb->context;
+	int nGot = pUrb->actual_length;	// what we transferred
+
+	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
+		if (!
+		    (pUrb->status == -ENOENT || pUrb->status == -ECONNRESET
+		     || pUrb->status == -ESHUTDOWN)) {
+			dev_err(&pdx->interface->dev,
+				"%s - nonzero write bulk status received: %d",
+				__func__, pUrb->status);
+		} else
+			dev_dbg(&pdx->interface->dev,
+				"%s - 0 chars pUrb->status=%d (shutdown?)",
+				__func__, pUrb->status);
+
+		spin_lock(&pdx->err_lock);
+		pdx->errors = pUrb->status;
+		spin_unlock(&pdx->err_lock);
+		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
+	} else {
+		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
+		} else {
+			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
+					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
+				for (i = 0; i < nGot; i++) {
+					pdx->inputBuffer[pdx->dwInBuffPut++] =
+					    pdx->pCoherCharIn[i] & 0x7F;
+					if (pdx->dwInBuffPut >= INBUF_SZ)
+						pdx->dwInBuffPut = 0;
+				}
+
+				if ((pdx->dwNumInput + nGot) <= INBUF_SZ)
+					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
+
+	Allowi(pdx, true);	// see if we can do the next one
 }
 
 /****************************************************************************
@@ -1145,48 +1216,50 @@ static void ced_readchar_callback(struct urb* pUrb)
 ** we can pick up any inward transfers. This can be called in multiple contexts
 ** so we use the irqsave version of the spinlock.
 ****************************************************************************/
-int Allowi(DEVICE_EXTENSION* pdx, bool bInCallback)
+int Allowi(DEVICE_EXTENSION * pdx, bool bInCallback)
 {
-    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
-
-        dev_dbg(&pdx->interface->dev, "%s %d chars in input buffer", __func__, pdx->dwNumInput);
-
-        usb_fill_int_urb(pdx->pUrbCharIn, pdx->udev,
-                         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
-        iReturn = usb_submit_urb(pdx->pUrbCharIn, bInCallback ? GFP_ATOMIC : GFP_KERNEL);
-        if (iReturn)
-        {
-            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
-    }
-
-    spin_unlock_irqrestore(&pdx->charInLock, flags);
-
-    return iReturn;
+	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
+
+		dev_dbg(&pdx->interface->dev, "%s %d chars in input buffer",
+			__func__, pdx->dwNumInput);
+
+		usb_fill_int_urb(pdx->pUrbCharIn, pdx->udev,
+				 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
+		iReturn =
+		    usb_submit_urb(pdx->pUrbCharIn,
+				   bInCallback ? GFP_ATOMIC : GFP_KERNEL);
+		if (iReturn) {
+			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
+	}
+
+	spin_unlock_irqrestore(&pdx->charInLock, flags);
+
+	return iReturn;
 
 }
 
@@ -1198,147 +1271,147 @@ int Allowi(DEVICE_EXTENSION* pdx, bool bInCallback)
 **          enough for a 64-bit pointer.
 *****************************************************************************/
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
-static long ced_ioctl(struct file * file, unsigned int cmd, unsigned long ulArg)
+static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long ulArg)
 #else
-static int ced_ioctl(struct inode * node, struct file * file, unsigned int cmd, unsigned long ulArg)
+static int ced_ioctl(struct inode *node, struct file *file, unsigned int cmd,
+		     unsigned long ulArg)
 #endif
 {
-    int err = 0;
-    DEVICE_EXTENSION *pdx = file->private_data;
-    if (!CanAcceptIoRequests(pdx))          // check we still exist
-        return -ENODEV;
+	int err = 0;
+	DEVICE_EXTENSION *pdx = file->private_data;
+	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
-    if (err)
-        return -EFAULT;
+	// 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;
 
-    switch (_IOC_NR(cmd))
-    {
-    case _IOC_NR(IOCTL_CED_SENDSTRING(0)):
-        return SendString(pdx, (const char __user*)ulArg, _IOC_SIZE(cmd));
+	switch (_IOC_NR(cmd)) {
+	case _IOC_NR(IOCTL_CED_SENDSTRING(0)):
+		return SendString(pdx, (const char __user *)ulArg,
+				  _IOC_SIZE(cmd));
 
-    case _IOC_NR(IOCTL_CED_RESET1401):
-        return Reset1401(pdx);
+	case _IOC_NR(IOCTL_CED_RESET1401):
+		return Reset1401(pdx);
 
-    case _IOC_NR(IOCTL_CED_GETCHAR):
-        return GetChar(pdx);
+	case _IOC_NR(IOCTL_CED_GETCHAR):
+		return GetChar(pdx);
 
-    case _IOC_NR(IOCTL_CED_SENDCHAR):
-        return SendChar(pdx, (char)ulArg);
+	case _IOC_NR(IOCTL_CED_SENDCHAR):
+		return SendChar(pdx, (char)ulArg);
 
-    case _IOC_NR(IOCTL_CED_STAT1401):
-        return Stat1401(pdx);
+	case _IOC_NR(IOCTL_CED_STAT1401):
+		return Stat1401(pdx);
 
-    case _IOC_NR(IOCTL_CED_LINECOUNT):
-        return LineCount(pdx);
+	case _IOC_NR(IOCTL_CED_LINECOUNT):
+		return LineCount(pdx);
 
-    case _IOC_NR(IOCTL_CED_GETSTRING(0)):
-        return GetString(pdx, (char __user*)ulArg, _IOC_SIZE(cmd));
+	case _IOC_NR(IOCTL_CED_GETSTRING(0)):
+		return GetString(pdx, (char __user *)ulArg, _IOC_SIZE(cmd));
 
-    case _IOC_NR(IOCTL_CED_SETTRANSFER):
-        return SetTransfer(pdx, (TRANSFERDESC __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_SETTRANSFER):
+		return SetTransfer(pdx, (TRANSFERDESC __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_UNSETTRANSFER):
-        return UnsetTransfer(pdx, (int)ulArg);
+	case _IOC_NR(IOCTL_CED_UNSETTRANSFER):
+		return UnsetTransfer(pdx, (int)ulArg);
 
-    case _IOC_NR(IOCTL_CED_SETEVENT):
-        return SetEvent(pdx, (TRANSFEREVENT __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_SETEVENT):
+		return SetEvent(pdx, (TRANSFEREVENT __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_GETOUTBUFSPACE):
-        return GetOutBufSpace(pdx);
+	case _IOC_NR(IOCTL_CED_GETOUTBUFSPACE):
+		return GetOutBufSpace(pdx);
 
-    case _IOC_NR(IOCTL_CED_GETBASEADDRESS):
-        return -1;
+	case _IOC_NR(IOCTL_CED_GETBASEADDRESS):
+		return -1;
 
-    case _IOC_NR(IOCTL_CED_GETDRIVERREVISION):
-        return (2<<24)|(DRIVERMAJREV<<16) | DRIVERMINREV;   // USB | MAJOR | MINOR
+	case _IOC_NR(IOCTL_CED_GETDRIVERREVISION):
+		return (2 << 24) | (DRIVERMAJREV << 16) | DRIVERMINREV;	// USB | MAJOR | MINOR
 
-    case _IOC_NR(IOCTL_CED_GETTRANSFER):
-        return GetTransfer(pdx, (TGET_TX_BLOCK __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_GETTRANSFER):
+		return GetTransfer(pdx, (TGET_TX_BLOCK __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_KILLIO1401):
-        return KillIO1401(pdx);
+	case _IOC_NR(IOCTL_CED_KILLIO1401):
+		return KillIO1401(pdx);
 
-    case _IOC_NR(IOCTL_CED_STATEOF1401):
-        return StateOf1401(pdx);
+	case _IOC_NR(IOCTL_CED_STATEOF1401):
+		return StateOf1401(pdx);
 
-    case _IOC_NR(IOCTL_CED_GRAB1401):
-    case _IOC_NR(IOCTL_CED_FREE1401):
-        return U14ERR_NOERROR;
+	case _IOC_NR(IOCTL_CED_GRAB1401):
+	case _IOC_NR(IOCTL_CED_FREE1401):
+		return U14ERR_NOERROR;
 
-    case _IOC_NR(IOCTL_CED_STARTSELFTEST):
-        return StartSelfTest(pdx);
+	case _IOC_NR(IOCTL_CED_STARTSELFTEST):
+		return StartSelfTest(pdx);
 
-    case _IOC_NR(IOCTL_CED_CHECKSELFTEST):
-        return CheckSelfTest(pdx, (TGET_SELFTEST __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_CHECKSELFTEST):
+		return CheckSelfTest(pdx, (TGET_SELFTEST __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_TYPEOF1401):
-        return TypeOf1401(pdx);
+	case _IOC_NR(IOCTL_CED_TYPEOF1401):
+		return TypeOf1401(pdx);
 
-    case _IOC_NR(IOCTL_CED_TRANSFERFLAGS):
-        return TransferFlags(pdx);
+	case _IOC_NR(IOCTL_CED_TRANSFERFLAGS):
+		return TransferFlags(pdx);
 
-    case _IOC_NR(IOCTL_CED_DBGPEEK):
-        return DbgPeek(pdx, (TDBGBLOCK __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_DBGPEEK):
+		return DbgPeek(pdx, (TDBGBLOCK __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_DBGPOKE):
-        return DbgPoke(pdx, (TDBGBLOCK __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_DBGPOKE):
+		return DbgPoke(pdx, (TDBGBLOCK __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_DBGRAMPDATA):
-        return DbgRampData(pdx, (TDBGBLOCK __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_DBGRAMPDATA):
+		return DbgRampData(pdx, (TDBGBLOCK __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_DBGRAMPADDR):
-        return DbgRampAddr(pdx, (TDBGBLOCK __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_DBGRAMPADDR):
+		return DbgRampAddr(pdx, (TDBGBLOCK __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_DBGGETDATA):
-        return DbgGetData(pdx, (TDBGBLOCK __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_DBGGETDATA):
+		return DbgGetData(pdx, (TDBGBLOCK __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_DBGSTOPLOOP):
-        return DbgStopLoop(pdx);
+	case _IOC_NR(IOCTL_CED_DBGSTOPLOOP):
+		return DbgStopLoop(pdx);
 
-    case _IOC_NR(IOCTL_CED_FULLRESET):
-          pdx->bForceReset = true;              // Set a flag for a full reset
-          break;
+	case _IOC_NR(IOCTL_CED_FULLRESET):
+		pdx->bForceReset = true;	// Set a flag for a full reset
+		break;
 
-    case _IOC_NR(IOCTL_CED_SETCIRCULAR):
-        return SetCircular(pdx, (TRANSFERDESC __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_SETCIRCULAR):
+		return SetCircular(pdx, (TRANSFERDESC __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_GETCIRCBLOCK):
-        return GetCircBlock(pdx, (TCIRCBLOCK __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_GETCIRCBLOCK):
+		return GetCircBlock(pdx, (TCIRCBLOCK __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_FREECIRCBLOCK):
-        return FreeCircBlock(pdx, (TCIRCBLOCK __user*)ulArg);
+	case _IOC_NR(IOCTL_CED_FREECIRCBLOCK):
+		return FreeCircBlock(pdx, (TCIRCBLOCK __user *) ulArg);
 
-    case _IOC_NR(IOCTL_CED_WAITEVENT):
-        return WaitEvent(pdx, (int)(ulArg & 0xff), (int)(ulArg >> 8));
+	case _IOC_NR(IOCTL_CED_WAITEVENT):
+		return WaitEvent(pdx, (int)(ulArg & 0xff), (int)(ulArg >> 8));
 
-    case _IOC_NR(IOCTL_CED_TESTEVENT):
-        return TestEvent(pdx, (int)ulArg);
+	case _IOC_NR(IOCTL_CED_TESTEVENT):
+		return TestEvent(pdx, (int)ulArg);
 
-    default:
-        return U14ERR_NO_SUCH_FN;
-    }
-    return U14ERR_NOERROR;
+	default:
+		return U14ERR_NO_SUCH_FN;
+	}
+	return U14ERR_NOERROR;
 }
 
-static const struct file_operations ced_fops =
-{
-    .owner =	THIS_MODULE,
-    .read =		ced_read,
-    .write =	ced_write,
-    .open =		ced_open,
-    .release =	ced_release,
-    .flush =	ced_flush,
-    .llseek =	noop_llseek,
+static const struct file_operations ced_fops = {
+	.owner = THIS_MODULE,
+	.read = ced_read,
+	.write = ced_write,
+	.open = ced_open,
+	.release = ced_release,
+	.flush = ced_flush,
+	.llseek = noop_llseek,
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
-    .unlocked_ioctl =    ced_ioctl,
+	.unlocked_ioctl = ced_ioctl,
 #else
-    .ioctl =    ced_ioctl,
+	.ioctl = ced_ioctl,
 #endif
 };
 
@@ -1346,245 +1419,250 @@ static const struct file_operations ced_fops =
  * usb class driver info in order to get a minor number from the usb core,
  * and to have the device registered with the driver core
  */
-static struct usb_class_driver ced_class =
-{
-    .name =		"cedusb%d",
-    .fops =		&ced_fops,
-    .minor_base =	USB_CED_MINOR_BASE,
+static struct usb_class_driver ced_class = {
+	.name = "cedusb%d",
+	.fops = &ced_fops,
+	.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.
-static int ced_probe(struct usb_interface *interface, const struct usb_device_id *id)
+static int ced_probe(struct usb_interface *interface,
+		     const struct usb_device_id *id)
 {
-    DEVICE_EXTENSION *pdx;
-    struct usb_host_interface *iface_desc;
-    struct usb_endpoint_descriptor *endpoint;
-    int i, bcdDevice;
-    int retval = -ENOMEM;
-
-    // allocate memory for our device extension and initialize it
-    pdx = kzalloc(sizeof(*pdx), GFP_KERNEL);
-    if (!pdx)
-    {
-        dev_err(&interface->dev, "Out of memory\n");
-        goto error;
-    }
-
-    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.
-    spin_lock_init(&pdx->charOutLock);
-    spin_lock_init(&pdx->charInLock);
-    spin_lock_init(&pdx->stagedLock);
-
-    // Initialises from the skeleton stuff
-    kref_init(&pdx->kref);
-    mutex_init(&pdx->io_mutex);
-    spin_lock_init(&pdx->err_lock);
-    init_usb_anchor(&pdx->submitted);
-
-    pdx->udev = usb_get_dev(interface_to_usbdev(interface));
-    pdx->interface = interface;
-
-    // Attempt to identify the device
-    bcdDevice = pdx->udev->descriptor.bcdDevice;
-    i = (bcdDevice >> 8);
-    if (i == 0)
-        pdx->s1401Type = TYPEU1401;
-    else if ((i>=1) && (i<=23))
-        pdx->s1401Type = i+2;
-    else
-    {
-        dev_err(&interface->dev, "%s Unknown device. bcdDevice = %d", __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.
-    iface_desc = interface->cur_altsetting;
-    pdx->nPipes = iface_desc->desc.bNumEndpoints;
-    dev_info(&interface->dev, "1401Type=%d with %d End Points", pdx->s1401Type, pdx->nPipes);
-    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
-    if (!pdx->pUrbCharOut || !pdx->pUrbCharIn || !pdx->pStagedUrb)
-    {
-        dev_err(&interface->dev, "%s URB alloc failed", __func__);
-        goto error;
-    }
-
-    pdx->pCoherStagedIO = usb_alloc_coherent(pdx->udev, STAGED_SZ, GFP_KERNEL, &pdx->pStagedUrb->transfer_dma);
-    pdx->pCoherCharOut = usb_alloc_coherent(pdx->udev, OUTBUF_SZ, GFP_KERNEL, &pdx->pUrbCharOut->transfer_dma);
-    pdx->pCoherCharIn = usb_alloc_coherent(pdx->udev, INBUF_SZ, GFP_KERNEL, &pdx->pUrbCharIn->transfer_dma);
-    if (!pdx->pCoherCharOut || !pdx->pCoherCharIn || !pdx->pCoherStagedIO)
-    {
-        dev_err(&interface->dev, "%s Coherent buffer alloc failed", __func__);
-        goto error;
-    }
-
-    for (i = 0; i < pdx->nPipes; ++i)
-    {
-        endpoint = &iface_desc->endpoint[i].desc;
-        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
-            ((pdx->nPipes==4) && (i==1)))
-        {
-            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)
-        {
-            pdx->bIsUSB2 = le16_to_cpu(endpoint->wMaxPacketSize) > 64;
-            dev_info(&pdx->interface->dev, "USB%d", pdx->bIsUSB2 + 1);
-        }
-    }
-
-    /* save our data pointer in this interface device */
-    usb_set_intfdata(interface, pdx);
-
-    /* we can register the device now, as it is ready */
-    retval = usb_register_dev(interface, &ced_class);
-    if (retval)
-    {
-        /* something prevented us from registering this driver */
-        dev_err(&interface->dev, "Not able to get a minor for this device.\n");
-        usb_set_intfdata(interface, NULL);
-        goto error;
-    }
-
-    /* let the user know what node this device is now attached to */
-    dev_info(&interface->dev,
-             "USB CEDUSB device now attached to cedusb #%d",
-             interface->minor);
-    return 0;
+	DEVICE_EXTENSION *pdx;
+	struct usb_host_interface *iface_desc;
+	struct usb_endpoint_descriptor *endpoint;
+	int i, bcdDevice;
+	int retval = -ENOMEM;
+
+	// allocate memory for our device extension and initialize it
+	pdx = kzalloc(sizeof(*pdx), GFP_KERNEL);
+	if (!pdx) {
+		dev_err(&interface->dev, "Out of memory\n");
+		goto error;
+	}
+
+	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.
+	spin_lock_init(&pdx->charOutLock);
+	spin_lock_init(&pdx->charInLock);
+	spin_lock_init(&pdx->stagedLock);
+
+	// Initialises from the skeleton stuff
+	kref_init(&pdx->kref);
+	mutex_init(&pdx->io_mutex);
+	spin_lock_init(&pdx->err_lock);
+	init_usb_anchor(&pdx->submitted);
+
+	pdx->udev = usb_get_dev(interface_to_usbdev(interface));
+	pdx->interface = interface;
+
+	// Attempt to identify the device
+	bcdDevice = pdx->udev->descriptor.bcdDevice;
+	i = (bcdDevice >> 8);
+	if (i == 0)
+		pdx->s1401Type = TYPEU1401;
+	else if ((i >= 1) && (i <= 23))
+		pdx->s1401Type = i + 2;
+	else {
+		dev_err(&interface->dev, "%s Unknown device. bcdDevice = %d",
+			__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.
+	iface_desc = interface->cur_altsetting;
+	pdx->nPipes = iface_desc->desc.bNumEndpoints;
+	dev_info(&interface->dev, "1401Type=%d with %d End Points",
+		 pdx->s1401Type, pdx->nPipes);
+	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
+	if (!pdx->pUrbCharOut || !pdx->pUrbCharIn || !pdx->pStagedUrb) {
+		dev_err(&interface->dev, "%s URB alloc failed", __func__);
+		goto error;
+	}
+
+	pdx->pCoherStagedIO =
+	    usb_alloc_coherent(pdx->udev, STAGED_SZ, GFP_KERNEL,
+			       &pdx->pStagedUrb->transfer_dma);
+	pdx->pCoherCharOut =
+	    usb_alloc_coherent(pdx->udev, OUTBUF_SZ, GFP_KERNEL,
+			       &pdx->pUrbCharOut->transfer_dma);
+	pdx->pCoherCharIn =
+	    usb_alloc_coherent(pdx->udev, INBUF_SZ, GFP_KERNEL,
+			       &pdx->pUrbCharIn->transfer_dma);
+	if (!pdx->pCoherCharOut || !pdx->pCoherCharIn || !pdx->pCoherStagedIO) {
+		dev_err(&interface->dev, "%s Coherent buffer alloc failed",
+			__func__);
+		goto error;
+	}
+
+	for (i = 0; i < pdx->nPipes; ++i) {
+		endpoint = &iface_desc->endpoint[i].desc;
+		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
+		    ((pdx->nPipes == 4) && (i == 1))) {
+			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)
+		{
+			pdx->bIsUSB2 =
+			    le16_to_cpu(endpoint->wMaxPacketSize) > 64;
+			dev_info(&pdx->interface->dev, "USB%d",
+				 pdx->bIsUSB2 + 1);
+		}
+	}
+
+	/* save our data pointer in this interface device */
+	usb_set_intfdata(interface, pdx);
+
+	/* we can register the device now, as it is ready */
+	retval = usb_register_dev(interface, &ced_class);
+	if (retval) {
+		/* something prevented us from registering this driver */
+		dev_err(&interface->dev,
+			"Not able to get a minor for this device.\n");
+		usb_set_intfdata(interface, NULL);
+		goto error;
+	}
+
+	/* let the user know what node this device is now attached to */
+	dev_info(&interface->dev,
+		 "USB CEDUSB device now attached to cedusb #%d",
+		 interface->minor);
+	return 0;
 
 error:
-    if (pdx)
-        kref_put(&pdx->kref, ced_delete);   // frees allocated memory
-    return retval;
+	if (pdx)
+		kref_put(&pdx->kref, ced_delete);	// frees allocated memory
+	return retval;
 }
 
 static void ced_disconnect(struct usb_interface *interface)
 {
-    DEVICE_EXTENSION *pdx = usb_get_intfdata(interface);
-    int minor = interface->minor;               // save for message at the end
-    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
-
-    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
-        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
-    mutex_unlock(&pdx->io_mutex);
+	DEVICE_EXTENSION *pdx = usb_get_intfdata(interface);
+	int minor = interface->minor;	// save for message at the end
+	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
+
+	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
+		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
+	mutex_unlock(&pdx->io_mutex);
 
-    usb_kill_anchored_urbs(&pdx->submitted);
+	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);
+	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.
-void ced_draw_down(DEVICE_EXTENSION *pdx)
+void ced_draw_down(DEVICE_EXTENSION * pdx)
 {
-    int time;
-    dev_dbg(&pdx->interface->dev,"%s called", __func__);
-
-    pdx->bInDrawDown = true;
-    time = usb_wait_anchor_empty_timeout(&pdx->submitted, 3000);
-    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__);
-    }
-    pdx->bInDrawDown = false;
- }
+	int time;
+	dev_dbg(&pdx->interface->dev, "%s called", __func__);
+
+	pdx->bInDrawDown = true;
+	time = usb_wait_anchor_empty_timeout(&pdx->submitted, 3000);
+	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__);
+	}
+	pdx->bInDrawDown = false;
+}
 
 static int ced_suspend(struct usb_interface *intf, pm_message_t message)
 {
-    DEVICE_EXTENSION *pdx = usb_get_intfdata(intf);
-    if (!pdx)
-        return 0;
-    ced_draw_down(pdx);
+	DEVICE_EXTENSION *pdx = usb_get_intfdata(intf);
+	if (!pdx)
+		return 0;
+	ced_draw_down(pdx);
 
-    dev_dbg(&pdx->interface->dev,"%s called", __func__);
-    return 0;
+	dev_dbg(&pdx->interface->dev, "%s called", __func__);
+	return 0;
 }
 
 static int ced_resume(struct usb_interface *intf)
 {
-    DEVICE_EXTENSION *pdx = usb_get_intfdata(intf);
-    if (!pdx)
-        return 0;
-    dev_dbg(&pdx->interface->dev,"%s called", __func__);
-    return 0;
+	DEVICE_EXTENSION *pdx = usb_get_intfdata(intf);
+	if (!pdx)
+		return 0;
+	dev_dbg(&pdx->interface->dev, "%s called", __func__);
+	return 0;
 }
 
 static int ced_pre_reset(struct usb_interface *intf)
 {
-    DEVICE_EXTENSION *pdx = usb_get_intfdata(intf);
-    dev_dbg(&pdx->interface->dev, "%s", __func__);
-    mutex_lock(&pdx->io_mutex);
-    ced_draw_down(pdx);
-    return 0;
+	DEVICE_EXTENSION *pdx = usb_get_intfdata(intf);
+	dev_dbg(&pdx->interface->dev, "%s", __func__);
+	mutex_lock(&pdx->io_mutex);
+	ced_draw_down(pdx);
+	return 0;
 }
 
 static int ced_post_reset(struct usb_interface *intf)
 {
-    DEVICE_EXTENSION *pdx = usb_get_intfdata(intf);
-    dev_dbg(&pdx->interface->dev, "%s", __func__);
+	DEVICE_EXTENSION *pdx = usb_get_intfdata(intf);
+	dev_dbg(&pdx->interface->dev, "%s", __func__);
 
-    /* we are sure no URBs are active - no locking needed */
-    pdx->errors = -EPIPE;
-    mutex_unlock(&pdx->io_mutex);
+	/* we are sure no URBs are active - no locking needed */
+	pdx->errors = -EPIPE;
+	mutex_unlock(&pdx->io_mutex);
 
-    return 0;
+	return 0;
 }
 
-static struct usb_driver ced_driver =
-{
-    .name =		    "cedusb",
-    .probe =	    ced_probe,
-    .disconnect =	ced_disconnect,
-    .suspend =	    ced_suspend,
-    .resume =	    ced_resume,
-    .pre_reset =	ced_pre_reset,
-    .post_reset =	ced_post_reset,
-    .id_table =	    ced_table,
-    .supports_autosuspend = 1,
+static struct usb_driver ced_driver = {
+	.name = "cedusb",
+	.probe = ced_probe,
+	.disconnect = ced_disconnect,
+	.suspend = ced_suspend,
+	.resume = ced_resume,
+	.pre_reset = ced_pre_reset,
+	.post_reset = ced_post_reset,
+	.id_table = ced_table,
+	.supports_autosuspend = 1,
 };
 
 static int __init usb_skel_init(void)
 {
-    /* register this driver with the USB subsystem */
-    return usb_register(&ced_driver);
+	/* register this driver with the USB subsystem */
+	return usb_register(&ced_driver);
 }
 
 static void __exit usb_skel_exit(void)
 {
-    /* deregister this driver with the USB subsystem */
-    usb_deregister(&ced_driver);
+	/* deregister this driver with the USB subsystem */
+	usb_deregister(&ced_driver);
 }
 
 module_init(usb_skel_init);