From 1cc7b53c62fca85ab36cb85167216cb8b2b224e3 Mon Sep 17 00:00:00 2001 From: Luca Ellero Date: Thu, 10 Jul 2014 11:01:47 +0200 Subject: [PATCH] staging: ced1401: remove typedef DEVICE_EXTENSION Signed-off-by: Luca Ellero Signed-off-by: Greg Kroah-Hartman --- drivers/staging/ced1401/ced_ioc.c | 698 +++++++++++------------ drivers/staging/ced1401/usb1401.c | 894 +++++++++++++++--------------- drivers/staging/ced1401/usb1401.h | 79 +-- 3 files changed, 836 insertions(+), 835 deletions(-) diff --git a/drivers/staging/ced1401/ced_ioc.c b/drivers/staging/ced1401/ced_ioc.c index f6f681f2b9b7..982112155279 100644 --- a/drivers/staging/ced1401/ced_ioc.c +++ b/drivers/staging/ced1401/ced_ioc.c @@ -36,19 +36,19 @@ ** ** Empties the Output buffer and sets int lines. Used from user level only ****************************************************************************/ -static void ced_flush_out_buff(DEVICE_EXTENSION *pdx) +static void ced_flush_out_buff(struct ced_data *ced) { - dev_dbg(&pdx->interface->dev, "%s: currentState=%d\n", - __func__, pdx->sCurrentState); - if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ + dev_dbg(&ced->interface->dev, "%s: currentState=%d\n", + __func__, ced->sCurrentState); + if (ced->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ return; /* Kill off any pending I/O */ - /* CharSend_Cancel(pdx); */ - spin_lock_irq(&pdx->charOutLock); - pdx->dwNumOutput = 0; - pdx->dwOutBuffGet = 0; - pdx->dwOutBuffPut = 0; - spin_unlock_irq(&pdx->charOutLock); + /* CharSend_Cancel(ced); */ + spin_lock_irq(&ced->charOutLock); + ced->dwNumOutput = 0; + ced->dwOutBuffGet = 0; + ced->dwOutBuffPut = 0; + spin_unlock_irq(&ced->charOutLock); } /**************************************************************************** @@ -57,19 +57,19 @@ static void ced_flush_out_buff(DEVICE_EXTENSION *pdx) ** ** Empties the input buffer and sets int lines ****************************************************************************/ -static void ced_flush_in_buff(DEVICE_EXTENSION *pdx) +static void ced_flush_in_buff(struct ced_data *ced) { - dev_dbg(&pdx->interface->dev, "%s: currentState=%d\n", - __func__, pdx->sCurrentState); - if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ + dev_dbg(&ced->interface->dev, "%s: currentState=%d\n", + __func__, ced->sCurrentState); + if (ced->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ return; /* Kill off any pending I/O */ /* CharRead_Cancel(pDevObject); */ - spin_lock_irq(&pdx->charInLock); - pdx->dwNumInput = 0; - pdx->dwInBuffGet = 0; - pdx->dwInBuffPut = 0; - spin_unlock_irq(&pdx->charInLock); + spin_lock_irq(&ced->charInLock); + ced->dwNumInput = 0; + ced->dwInBuffGet = 0; + ced->dwInBuffPut = 0; + spin_unlock_irq(&ced->charInLock); } /**************************************************************************** @@ -78,24 +78,24 @@ static void ced_flush_in_buff(DEVICE_EXTENSION *pdx) ** Utility routine to copy chars into the output buffer and fire them off. ** called from user mode, holds charOutLock. ****************************************************************************/ -static int ced_put_chars(DEVICE_EXTENSION *pdx, const char *pCh, +static int ced_put_chars(struct ced_data *ced, const char *pCh, unsigned int uCount) { int iReturn; - spin_lock_irq(&pdx->charOutLock); /* get the output spin lock */ - if ((OUTBUF_SZ - pdx->dwNumOutput) >= uCount) { + spin_lock_irq(&ced->charOutLock); /* get the output spin lock */ + if ((OUTBUF_SZ - ced->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; + ced->outputBuffer[ced->dwOutBuffPut++] = pCh[u]; + if (ced->dwOutBuffPut >= OUTBUF_SZ) + ced->dwOutBuffPut = 0; } - pdx->dwNumOutput += uCount; - spin_unlock_irq(&pdx->charOutLock); - iReturn = ced_send_chars(pdx); /* ...give a chance to transmit data */ + ced->dwNumOutput += uCount; + spin_unlock_irq(&ced->charOutLock); + iReturn = ced_send_chars(ced); /* ...give a chance to transmit data */ } else { iReturn = U14ERR_NOOUT; /* no room at the out (ha-ha) */ - spin_unlock_irq(&pdx->charOutLock); + spin_unlock_irq(&ced->charOutLock); } return iReturn; } @@ -105,7 +105,7 @@ static int ced_put_chars(DEVICE_EXTENSION *pdx, const char *pCh, ** trigger an output transfer if this is appropriate. User mode. ** Holds the io_mutex *****************************************************************************/ -int ced_send_string(DEVICE_EXTENSION *pdx, const char __user *pData, +int ced_send_string(struct ced_data *ced, const char __user *pData, unsigned int n) { int iReturn = U14ERR_NOERROR; /* assume all will be well */ @@ -116,15 +116,15 @@ int ced_send_string(DEVICE_EXTENSION *pdx, const char __user *pData, return -EFAULT; buffer[n] = 0; /* terminate for debug purposes */ - mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + mutex_lock(&ced->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<\n", + dev_dbg(&ced->interface->dev, "%s: n=%d>%s<\n", __func__, n, buffer); - iReturn = ced_put_chars(pdx, buffer, n); + iReturn = ced_put_chars(ced, buffer, n); } - ced_allowi(pdx); /* make sure we have input int */ - mutex_unlock(&pdx->io_mutex); + ced_allowi(ced); /* make sure we have input int */ + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -134,14 +134,14 @@ int ced_send_string(DEVICE_EXTENSION *pdx, const char __user *pData, ** ** Sends a single character to the 1401. User mode, holds io_mutex. ****************************************************************************/ -int ced_send_char(DEVICE_EXTENSION *pdx, char c) +int ced_send_char(struct ced_data *ced, char c) { int iReturn; - mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ - iReturn = ced_put_chars(pdx, &c, 1); - dev_dbg(&pdx->interface->dev, "ced_send_char >%c< (0x%02x)\n", c, c); - ced_allowi(pdx); /* Make sure char reads are running */ - mutex_unlock(&pdx->io_mutex); + mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ + iReturn = ced_put_chars(ced, &c, 1); + dev_dbg(&ced->interface->dev, "ced_send_char >%c< (0x%02x)\n", c, c); + ced_allowi(ced); /* Make sure char reads are running */ + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -171,46 +171,46 @@ int ced_send_char(DEVICE_EXTENSION *pdx, char c) ** ** return error code (U14ERR_NOERROR for OK) */ -int ced_get_state(DEVICE_EXTENSION *pdx, __u32 *state, __u32 *error) +int ced_get_state(struct ced_data *ced, __u32 *state, __u32 *error) { int nGot; - dev_dbg(&pdx->interface->dev, "%s: entry\n", __func__); + dev_dbg(&ced->interface->dev, "%s: entry\n", __func__); *state = 0xFFFFFFFF; /* Start off with invalid state */ - nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), + nGot = usb_control_msg(ced->udev, usb_rcvctrlpipe(ced->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, + ced->statBuf, sizeof(ced->statBuf), HZ); + if (nGot != sizeof(ced->statBuf)) { + dev_err(&ced->interface->dev, "%s: FAILED, return code %d\n", __func__, nGot); - pdx->sCurrentState = U14ERR_TIME; /* Indicate that things are very wrong indeed */ + ced->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, + dev_dbg(&ced->interface->dev, "%s: Success, state: 0x%x, 0x%x\n", - __func__, pdx->statBuf[0], pdx->statBuf[1]); + __func__, ced->statBuf[0], ced->statBuf[1]); - *state = pdx->statBuf[0]; /* Return the state values to the calling code */ - *error = pdx->statBuf[1]; + *state = ced->statBuf[0]; /* Return the state values to the calling code */ + *error = ced->statBuf[1]; - nDevice = pdx->udev->descriptor.bcdDevice >> 8; /* 1401 type code value */ + nDevice = ced->udev->descriptor.bcdDevice >> 8; /* 1401 type code value */ switch (nDevice) { /* so we can clean up current state */ case 0: - pdx->sCurrentState = U14ERR_U1401; + ced->sCurrentState = U14ERR_U1401; break; default: /* allow lots of device codes for future 1401s */ if ((nDevice >= 1) && (nDevice <= 23)) - pdx->sCurrentState = (short)(nDevice + 6); + ced->sCurrentState = (short)(nDevice + 6); else - pdx->sCurrentState = U14ERR_ILL; + ced->sCurrentState = U14ERR_ILL; break; } } - return pdx->sCurrentState >= 0 ? U14ERR_NOERROR : pdx->sCurrentState; + return ced->sCurrentState >= 0 ? U14ERR_NOERROR : ced->sCurrentState; } /**************************************************************************** @@ -218,39 +218,39 @@ int ced_get_state(DEVICE_EXTENSION *pdx, __u32 *state, __u32 *error) ** ** Kills off staged read\write request from the USB if one is pending. ****************************************************************************/ -int ced_read_write_cancel(DEVICE_EXTENSION *pdx) +int ced_read_write_cancel(struct ced_data *ced) { - dev_dbg(&pdx->interface->dev, "%s: entry %d\n", - __func__, pdx->bStagedUrbPending); + dev_dbg(&ced->interface->dev, "%s: entry %d\n", + __func__, ced->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); + spin_lock_irq(&ced->stagedLock); - if (pdx->bStagedUrbPending) { /* anything to be cancelled? May need more... */ - dev_info(&pdx->interface - dev, + if (ced->bStagedUrbPending) { /* anything to be cancelled? May need more... */ + dev_info(&ced->interface - dev, "ced_read_write_cancel about to cancel Urb\n"); /* Clear the staging done flag */ - /* KeClearEvent(&pdx->StagingDoneEvent); */ - USB_ASSERT(pdx->pStagedIrp != NULL); + /* KeClearEvent(&ced->StagingDoneEvent); */ + USB_ASSERT(ced->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 */ + spin_unlock_irq(&ced->stagedLock); + bResult = IoCancelIrp(ced->pStagedIrp); /* Actually do the cancel */ if (bResult) { LARGE_INTEGER timeout; timeout.QuadPart = -10000000; /* Use a timeout of 1 second */ - dev_info(&pdx->interface - dev, + dev_info(&ced->interface - dev, "%s: about to wait till done\n", __func__); ntStatus = - KeWaitForSingleObject(&pdx->StagingDoneEvent, + KeWaitForSingleObject(&ced->StagingDoneEvent, Executive, KernelMode, FALSE, &timeout); } else { - dev_info(&pdx->interface - dev, + dev_info(&ced->interface - dev, "%s: cancellation failed\n", __func__); ntStatus = U14ERR_FAIL; } @@ -258,9 +258,9 @@ int ced_read_write_cancel(DEVICE_EXTENSION *pdx) ("ced_read_write_cancel ntStatus = 0x%x decimal %d\n", ntStatus, ntStatus)); } else - spin_unlock_irq(&pdx->stagedLock); + spin_unlock_irq(&ced->stagedLock); - dev_info(&pdx->interface - dev, "%s: done\n", __func__); + dev_info(&ced->interface - dev, "%s: done\n", __func__); return ntStatus; #else return U14ERR_NOERROR; @@ -272,10 +272,10 @@ int ced_read_write_cancel(DEVICE_EXTENSION *pdx) ** ced_in_self_test - 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 ced_in_self_test(DEVICE_EXTENSION *pdx, unsigned int *pState) +static int ced_in_self_test(struct ced_data *ced, unsigned int *pState) { unsigned int state, error; - int iReturn = ced_get_state(pdx, &state, &error); /* see if in self-test */ + int iReturn = ced_get_state(ced, &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 */ @@ -301,37 +301,37 @@ static int ced_in_self_test(DEVICE_EXTENSION *pdx, unsigned int *pState) ** ** Returns TRUE if a 1401 detected and OK, else FALSE ****************************************************************************/ -static bool ced_is_1401(DEVICE_EXTENSION *pdx) +static bool ced_is_1401(struct ced_data *ced) { int iReturn; - dev_dbg(&pdx->interface->dev, "%s\n", __func__); + dev_dbg(&ced->interface->dev, "%s\n", __func__); - ced_draw_down(pdx); /* wait for, then kill outstanding Urbs */ - ced_flush_in_buff(pdx); /* Clear out input buffer & pipe */ - ced_flush_out_buff(pdx); /* Clear output buffer & pipe */ + ced_draw_down(ced); /* wait for, then kill outstanding Urbs */ + ced_flush_in_buff(ced); /* Clear out input buffer & pipe */ + ced_flush_out_buff(ced); /* 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); + iReturn = usb_lock_device_for_reset(ced->udev, ced->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 */ + mutex_unlock(&ced->io_mutex); /* locked, so we will not get system calls */ if (iReturn >= 0) { /* if we failed */ - iReturn = usb_reset_device(pdx->udev); /* try to do the reset */ - usb_unlock_device(pdx->udev); /* undo the lock */ + iReturn = usb_reset_device(ced->udev); /* try to do the reset */ + usb_unlock_device(ced->udev); /* undo the lock */ } - mutex_lock(&pdx->io_mutex); /* hold stuff off while we wait */ - pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flag regardless! */ + mutex_lock(&ced->io_mutex); /* hold stuff off while we wait */ + ced->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flag regardless! */ if (iReturn == 0) { /* if all is OK still */ unsigned int state; - iReturn = ced_in_self_test(pdx, &state); /* see if likely in self test */ + iReturn = ced_in_self_test(ced, &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 = ced_in_self_test(pdx, &state); /* see if done yet */ + iReturn = ced_in_self_test(ced, &state); /* see if done yet */ } } @@ -339,7 +339,7 @@ static bool ced_is_1401(DEVICE_EXTENSION *pdx) iReturn = state == 0; /* then success is that the state is 0 */ } else iReturn = 0; /* we failed */ - pdx->bForceReset = false; /* Clear forced reset flag now */ + ced->bForceReset = false; /* Clear forced reset flag now */ return iReturn > 0; } @@ -358,42 +358,42 @@ static bool ced_is_1401(DEVICE_EXTENSION *pdx) ** ** The return value is TRUE if a useable 1401 is found, FALSE if not */ -static bool ced_quick_check(DEVICE_EXTENSION *pdx, bool bTestBuff, bool bCanReset) +static bool ced_quick_check(struct ced_data *ced, 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 */ + bShortTest = ((ced->dwDMAFlag == MODE_CHAR) && /* no DMA running */ + (!ced->bForceReset) && /* Not had a real reset forced */ + (ced->sCurrentState >= U14ERR_STD)); /* No 1401 errors stored */ - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: DMAFlag:%d, state:%d, force:%d, testBuff:%d, short:%d\n", - __func__, pdx->dwDMAFlag, pdx->sCurrentState, pdx->bForceReset, + __func__, ced->dwDMAFlag, ced->sCurrentState, ced->bForceReset, bTestBuff, bShortTest); if ((bTestBuff) && /* Buffer check requested, and... */ - (pdx->dwNumInput || pdx->dwNumOutput)) { /* ...characters were in the buffer? */ + (ced->dwNumInput || ced->dwNumOutput)) { /* ...characters were in the buffer? */ bShortTest = false; /* Then do the full test */ - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: will reset as buffers not empty\n", __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: ced_get_state\n", __func__); - if (ced_get_state(pdx, &state, &error) == U14ERR_NOERROR) { /* Check on the 1401 state */ + dev_dbg(&ced->interface->dev, "%s: ced_get_state\n", __func__); + if (ced_get_state(ced, &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: ced_is_1401 %d %d %d %d\n", - __func__, bShortTest, pdx->sCurrentState, bTestBuff, - pdx->bForceReset); - bRet = ced_is_1401(pdx); /* do full test */ + dev_info(&ced->interface->dev, "%s: ced_is_1401 %d %d %d %d\n", + __func__, bShortTest, ced->sCurrentState, bTestBuff, + ced->bForceReset); + bRet = ced_is_1401(ced); /* do full test */ } return bRet; @@ -404,13 +404,13 @@ static bool ced_quick_check(DEVICE_EXTENSION *pdx, bool bTestBuff, bool bCanRese ** ** Resets the 1401 and empties the i/o buffers *****************************************************************************/ -int ced_reset(DEVICE_EXTENSION *pdx) +int ced_reset(struct ced_data *ced) { - mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ - dev_dbg(&pdx->interface->dev, "%s: About to call ced_quick_check\n", + mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ + dev_dbg(&ced->interface->dev, "%s: About to call ced_quick_check\n", __func__); - ced_quick_check(pdx, true, true); /* Check 1401, reset if not OK */ - mutex_unlock(&pdx->io_mutex); + ced_quick_check(ced, true, true); /* Check 1401, reset if not OK */ + mutex_unlock(&ced->io_mutex); return U14ERR_NOERROR; } @@ -419,29 +419,29 @@ int ced_reset(DEVICE_EXTENSION *pdx) ** ** Gets a single character from the 1401 ****************************************************************************/ -int ced_get_char(DEVICE_EXTENSION *pdx) +int ced_get_char(struct ced_data *ced) { int iReturn = U14ERR_NOIN; /* assume we will get nothing */ - mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ - dev_dbg(&pdx->interface->dev, "%s\n", __func__); + dev_dbg(&ced->interface->dev, "%s\n", __func__); - ced_allowi(pdx); /* Make sure char reads are running */ - ced_send_chars(pdx); /* and send any buffered chars */ + ced_allowi(ced); /* Make sure char reads are running */ + ced_send_chars(ced); /* 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--; + spin_lock_irq(&ced->charInLock); + if (ced->dwNumInput > 0) { /* worth looking */ + iReturn = ced->inputBuffer[ced->dwInBuffGet++]; + if (ced->dwInBuffGet >= INBUF_SZ) + ced->dwInBuffGet = 0; + ced->dwNumInput--; } else iReturn = U14ERR_NOIN; /* no input data to read */ - spin_unlock_irq(&pdx->charInLock); + spin_unlock_irq(&ced->charInLock); - ced_allowi(pdx); /* Make sure char reads are running */ + ced_allowi(ced); /* Make sure char reads are running */ - mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ return iReturn; } @@ -456,19 +456,19 @@ int ced_get_char(DEVICE_EXTENSION *pdx) ** returns the count of characters (including the terminator, or 0 if none ** or a negative error code. ****************************************************************************/ -int ced_get_string(DEVICE_EXTENSION *pdx, char __user *pUser, int n) +int ced_get_string(struct ced_data *ced, 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 */ - ced_allowi(pdx); /* Make sure char reads are running */ - ced_send_chars(pdx); /* and send any buffered chars */ + mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ + ced_allowi(ced); /* Make sure char reads are running */ + ced_send_chars(ced); /* and send any buffered chars */ - spin_lock_irq(&pdx->charInLock); - nAvailable = pdx->dwNumInput; /* characters available now */ + spin_lock_irq(&ced->charInLock); + nAvailable = ced->dwNumInput; /* characters available now */ if (nAvailable > n) /* read max of space in pUser... */ nAvailable = n; /* ...or input characters */ @@ -478,12 +478,12 @@ int ced_get_string(DEVICE_EXTENSION *pdx, char __user *pUser, int n) int nCopyToUser; /* number to copy to user */ char cData; do { - cData = pdx->inputBuffer[pdx->dwInBuffGet++]; + cData = ced->inputBuffer[ced->dwInBuffGet++]; if (cData == CR_CHAR) /* replace CR with zero */ cData = (char)0; - if (pdx->dwInBuffGet >= INBUF_SZ) - pdx->dwInBuffGet = 0; /* wrap buffer pointer */ + if (ced->dwInBuffGet >= INBUF_SZ) + ced->dwInBuffGet = 0; /* wrap buffer pointer */ buffer[nGot++] = cData; /* save the output */ } while ((nGot < nAvailable) && cData); @@ -495,20 +495,20 @@ int ced_get_string(DEVICE_EXTENSION *pdx, char __user *pUser, int n) ++nCopyToUser; /* ...copy the 0 as well. */ } - pdx->dwNumInput -= nGot; - spin_unlock_irq(&pdx->charInLock); + ced->dwNumInput -= nGot; + spin_unlock_irq(&ced->charInLock); - dev_dbg(&pdx->interface->dev, "%s: read %d characters >%s<\n", + dev_dbg(&ced->interface->dev, "%s: read %d characters >%s<\n", __func__, nGot, buffer); if (copy_to_user(pUser, buffer, nCopyToUser)) iReturn = -EFAULT; else iReturn = nGot; /* report characters read */ } else - spin_unlock_irq(&pdx->charInLock); + spin_unlock_irq(&ced->charInLock); - ced_allowi(pdx); /* Make sure char reads are running */ - mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + ced_allowi(ced); /* Make sure char reads are running */ + mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ return iReturn; } @@ -516,14 +516,14 @@ int ced_get_string(DEVICE_EXTENSION *pdx, char __user *pUser, int n) /******************************************************************************* ** Get count of characters in the inout buffer. *******************************************************************************/ -int ced_stat_1401(DEVICE_EXTENSION *pdx) +int ced_stat_1401(struct ced_data *ced) { int iReturn; - mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ - ced_allowi(pdx); /* make sure we allow pending chars */ - ced_send_chars(pdx); /* in both directions */ - iReturn = pdx->dwNumInput; /* no lock as single read */ - mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ + ced_allowi(ced); /* make sure we allow pending chars */ + ced_send_chars(ced); /* in both directions */ + iReturn = ced->dwNumInput; /* no lock as single read */ + mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ return iReturn; } @@ -534,20 +534,20 @@ int ced_stat_1401(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 ced_line_count(DEVICE_EXTENSION *pdx) +int ced_line_count(struct ced_data *ced) { int iReturn = 0; /* will be count of line ends */ - mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ - ced_allowi(pdx); /* Make sure char reads are running */ - ced_send_chars(pdx); /* and send any buffered chars */ - spin_lock_irq(&pdx->charInLock); /* Get protection */ + mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ + ced_allowi(ced); /* Make sure char reads are running */ + ced_send_chars(ced); /* and send any buffered chars */ + spin_lock_irq(&ced->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 */ + if (ced->dwNumInput > 0) { /* worth looking? */ + unsigned int dwIndex = ced->dwInBuffGet; /* start at first available */ + unsigned int dwEnd = ced->dwInBuffPut; /* Position for search end */ do { - if (pdx->inputBuffer[dwIndex++] == CR_CHAR) + if (ced->inputBuffer[dwIndex++] == CR_CHAR) ++iReturn; /* inc count if CR */ if (dwIndex >= INBUF_SZ) /* see if we fall off buff */ @@ -555,9 +555,9 @@ int ced_line_count(DEVICE_EXTENSION *pdx) } while (dwIndex != dwEnd); /* go to last available */ } - spin_unlock_irq(&pdx->charInLock); - dev_dbg(&pdx->interface->dev, "%s: returned %d\n", __func__, iReturn); - mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + spin_unlock_irq(&ced->charInLock); + dev_dbg(&ced->interface->dev, "%s: returned %d\n", __func__, iReturn); + mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ return iReturn; } @@ -566,14 +566,14 @@ int ced_line_count(DEVICE_EXTENSION *pdx) ** ** Gets the space in the output buffer. Called from user code. *****************************************************************************/ -int ced_get_out_buf_space(DEVICE_EXTENSION *pdx) +int ced_get_out_buf_space(struct ced_data *ced) { int iReturn; - mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */ - ced_send_chars(pdx); /* send any buffered chars */ - iReturn = (int)(OUTBUF_SZ - pdx->dwNumOutput); /* no lock needed for single read */ - dev_dbg(&pdx->interface->dev, "%s: %d\n", __func__, iReturn); - mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */ + mutex_lock(&ced->io_mutex); /* Protect disconnect from new i/o */ + ced_send_chars(ced); /* send any buffered chars */ + iReturn = (int)(OUTBUF_SZ - ced->dwNumOutput); /* no lock needed for single read */ + dev_dbg(&ced->interface->dev, "%s: %d\n", __func__, iReturn); + mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ return iReturn; } @@ -584,17 +584,17 @@ int ced_get_out_buf_space(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 ced_clear_area(DEVICE_EXTENSION *pdx, int nArea) +int ced_clear_area(struct ced_data *ced, 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\n", + dev_err(&ced->interface->dev, "%s: Attempt to clear area %d\n", __func__, nArea); } else { /* to save typing */ - struct transarea *pTA = &pdx->rTransDef[nArea]; + struct transarea *pTA = &ced->rTransDef[nArea]; if (!pTA->bUsed) /* if not used... */ iReturn = U14ERR_NOTSET; /* ...nothing to be done */ else { @@ -604,13 +604,13 @@ int ced_clear_area(DEVICE_EXTENSION *pdx, int nArea) int nPages = 0; /* and number of pages */ int np; - dev_dbg(&pdx->interface->dev, "%s: area %d\n", + dev_dbg(&ced->interface->dev, "%s: area %d\n", __func__, nArea); - spin_lock_irq(&pdx->stagedLock); - if ((pdx->StagedId == nArea) - && (pdx->dwDMAFlag > MODE_CHAR)) { + spin_lock_irq(&ced->stagedLock); + if ((ced->StagedId == nArea) + && (ced->dwDMAFlag > MODE_CHAR)) { iReturn = U14ERR_UNLOCKFAIL; /* cannot delete as in use */ - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "%s: call on area %d while active\n", __func__, nArea); } else { @@ -619,9 +619,9 @@ int ced_clear_area(DEVICE_EXTENSION *pdx, int nArea) 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 */ + if (ced->bXFerWaiting + && (ced->rDMAInfo.wIdent == nArea)) + ced->bXFerWaiting = false; /* Cannot have pending xfer if area cleared */ /* Clean out the struct 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. */ @@ -629,13 +629,13 @@ int ced_clear_area(DEVICE_EXTENSION *pdx, int nArea) sizeof(struct transarea) - sizeof(wait_queue_head_t)); } - spin_unlock_irq(&pdx->stagedLock); + spin_unlock_irq(&ced->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\n", + dev_dbg(&ced->interface->dev, "%s: nPages=%d\n", __func__, nPages); for (np = 0; np < nPages; ++np) { @@ -646,7 +646,7 @@ int ced_clear_area(DEVICE_EXTENSION *pdx, int nArea) } kfree(pPages); - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: kfree(pPages) done\n", __func__); } } @@ -661,7 +661,7 @@ int ced_clear_area(DEVICE_EXTENSION *pdx, int nArea) ** Sets up a transfer area - the functional part. Called by both ** ced_set_transfer and ced_set_circular. ****************************************************************************/ -static int ced_set_area(DEVICE_EXTENSION *pdx, int nArea, char __user *puBuf, +static int ced_set_area(struct ced_data *ced, 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 */ @@ -671,11 +671,11 @@ static int ced_set_area(DEVICE_EXTENSION *pdx, int nArea, char __user *puBuf, unsigned int ulOffset = ((unsigned long)puBuf) & (PAGE_SIZE - 1); int len = (dwLength + ulOffset + PAGE_SIZE - 1) >> PAGE_SHIFT; - struct transarea *pTA = &pdx->rTransDef[nArea]; /* to save typing */ + struct transarea *pTA = &ced->rTransDef[nArea]; /* to save typing */ struct page **pPages = NULL; /* space for page tables */ int nPages = 0; /* and number of pages */ - int iReturn = ced_clear_area(pdx, nArea); /* see if OK to use this area */ + int iReturn = ced_clear_area(ced, 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 */ @@ -689,18 +689,18 @@ static int ced_set_area(DEVICE_EXTENSION *pdx, int nArea, char __user *puBuf, iReturn = U14ERR_NOMEMORY; goto error; } - dev_dbg(&pdx->interface->dev, "%s: %p, length=%06x, circular %d\n", + dev_dbg(&ced->interface->dev, "%s: %p, length=%06x, circular %d\n", __func__, puBuf, dwLength, bCircular); /* To pin down user pages we must first acquire the mapping semaphore. */ nPages = get_user_pages_fast(ulStart, len, 1, pPages); - dev_dbg(&pdx->interface->dev, "%s: nPages = %d\n", __func__, nPages); + dev_dbg(&ced->interface->dev, "%s: nPages = %d\n", __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); + spin_lock_irq(&ced->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 */ @@ -716,7 +716,7 @@ static int ced_set_area(DEVICE_EXTENSION *pdx, int nArea, char __user *puBuf, pTA->aBlocks[1].dwSize = 0; pTA->bUsed = true; /* This is now a used block */ - spin_unlock_irq(&pdx->stagedLock); + spin_unlock_irq(&ced->stagedLock); iReturn = U14ERR_NOERROR; /* say all was well */ } else { iReturn = U14ERR_LOCKFAIL; @@ -737,7 +737,7 @@ 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 ced_set_transfer(DEVICE_EXTENSION *pdx, struct transfer_area_desc __user *pTD) +int ced_set_transfer(struct ced_data *ced, struct transfer_area_desc __user *pTD) { int iReturn; struct transfer_area_desc td; @@ -745,17 +745,17 @@ int ced_set_transfer(DEVICE_EXTENSION *pdx, struct transfer_area_desc __user *pT if (copy_from_user(&td, pTD, sizeof(td))) return -EFAULT; - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s: area:%d, size:%08x\n", + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s: area:%d, size:%08x\n", __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 = - ced_set_area(pdx, td.wAreaNum, + ced_set_area(ced, td.wAreaNum, (char __user *)((unsigned long)td.lpvBuff), td.dwLength, false, false); - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -763,12 +763,12 @@ int ced_set_transfer(DEVICE_EXTENSION *pdx, struct transfer_area_desc __user *pT ** UnSetTransfer ** Erases a transfer area record ****************************************************************************/ -int ced_unset_transfer(DEVICE_EXTENSION *pdx, int nArea) +int ced_unset_transfer(struct ced_data *ced, int nArea) { int iReturn; - mutex_lock(&pdx->io_mutex); - iReturn = ced_clear_area(pdx, nArea); - mutex_unlock(&pdx->io_mutex); + mutex_lock(&ced->io_mutex); + iReturn = ced_clear_area(ced, nArea); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -780,7 +780,7 @@ int ced_unset_transfer(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 ced_set_event(DEVICE_EXTENSION *pdx, struct transfer_event __user *pTE) +int ced_set_event(struct ced_data *ced, struct transfer_event __user *pTE) { int iReturn = U14ERR_NOERROR; struct transfer_event te; @@ -792,9 +792,9 @@ int ced_set_event(DEVICE_EXTENSION *pdx, struct transfer_event __user *pTE) if (te.wAreaNum >= MAX_TRANSAREAS) /* the area must exist */ return U14ERR_BADAREA; else { - struct transarea *pTA = &pdx->rTransDef[te.wAreaNum]; - mutex_lock(&pdx->io_mutex); /* make sure we have no competitor */ - spin_lock_irq(&pdx->stagedLock); + struct transarea *pTA = &ced->rTransDef[te.wAreaNum]; + mutex_lock(&ced->io_mutex); /* make sure we have no competitor */ + spin_lock_irq(&ced->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) */ @@ -802,8 +802,8 @@ int ced_set_event(DEVICE_EXTENSION *pdx, struct transfer_event __user *pTE) pTA->iWakeUp = 0; /* zero the wake up count */ } else iReturn = U14ERR_NOTSET; - spin_unlock_irq(&pdx->stagedLock); - mutex_unlock(&pdx->io_mutex); + spin_unlock_irq(&ced->stagedLock); + mutex_unlock(&ced->io_mutex); } return iReturn == U14ERR_NOERROR ? (te.iSetEvent ? 1 : U14ERR_NOERROR) : iReturn; @@ -815,24 +815,24 @@ int ced_set_event(DEVICE_EXTENSION *pdx, struct transfer_event __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 ced_wait_event(DEVICE_EXTENSION *pdx, int nArea, int msTimeOut) +int ced_wait_event(struct ced_data *ced, int nArea, int msTimeOut) { int iReturn; if ((unsigned)nArea >= MAX_TRANSAREAS) return U14ERR_BADAREA; else { int iWait; - struct transarea *pTA = &pdx->rTransDef[nArea]; + struct transarea *pTA = &ced->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 */ + mutex_lock(&ced->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); + mutex_unlock(&ced->io_mutex); if (msTimeOut) iWait = @@ -849,9 +849,9 @@ int ced_wait_event(DEVICE_EXTENSION *pdx, int nArea, int msTimeOut) else iReturn = pTA->iWakeUp; /* else the wakeup count */ - spin_lock_irq(&pdx->stagedLock); + spin_lock_irq(&ced->stagedLock); pTA->iWakeUp = 0; /* clear the flag */ - spin_unlock_irq(&pdx->stagedLock); + spin_unlock_irq(&ced->stagedLock); } return iReturn; } @@ -862,19 +862,19 @@ int ced_wait_event(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 ced_test_event(DEVICE_EXTENSION *pdx, int nArea) +int ced_test_event(struct ced_data *ced, int nArea) { int iReturn; if ((unsigned)nArea >= MAX_TRANSAREAS) iReturn = U14ERR_BADAREA; else { - struct transarea *pTA = &pdx->rTransDef[nArea]; - mutex_lock(&pdx->io_mutex); /* make sure we have no competitor */ - spin_lock_irq(&pdx->stagedLock); + struct transarea *pTA = &ced->rTransDef[nArea]; + mutex_lock(&ced->io_mutex); /* make sure we have no competitor */ + spin_lock_irq(&ced->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); + spin_unlock_irq(&ced->stagedLock); + mutex_unlock(&ced->io_mutex); } return iReturn; } @@ -883,13 +883,13 @@ int ced_test_event(DEVICE_EXTENSION *pdx, int nArea) ** ced_get_transferInfo ** Puts the current state of the 1401 in a TGET_TX_BLOCK. *****************************************************************************/ -int ced_get_transfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user *pTX) +int ced_get_transfer(struct ced_data *ced, 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 */ + mutex_lock(&ced->io_mutex); + dwIdent = ced->StagedId; /* area ident for last xfer */ if (dwIdent >= MAX_TRANSAREAS) iReturn = U14ERR_BADAREA; else { @@ -898,22 +898,22 @@ int ced_get_transfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user *pTX) tx = kzalloc(sizeof(*tx), GFP_KERNEL); if (!tx) { - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); return -ENOMEM; } - tx->size = pdx->rTransDef[dwIdent].dwLength; - tx->linear = (long long)((long)pdx->rTransDef[dwIdent].lpvBuff); + tx->size = ced->rTransDef[dwIdent].dwLength; + tx->linear = (long long)((long)ced->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); + (long long)(tx->linear + ced->StagedOffset); tx->entries[0].size = tx->size; if (copy_to_user(pTX, tx, sizeof(*tx))) iReturn = -EFAULT; kfree(tx); } - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -922,13 +922,13 @@ int ced_get_transfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user *pTX) ** ** Empties the host i/o buffers ****************************************************************************/ -int ced_kill_io(DEVICE_EXTENSION *pdx) +int ced_kill_io(struct ced_data *ced) { - dev_dbg(&pdx->interface->dev, "%s\n", __func__); - mutex_lock(&pdx->io_mutex); - ced_flush_out_buff(pdx); - ced_flush_in_buff(pdx); - mutex_unlock(&pdx->io_mutex); + dev_dbg(&ced->interface->dev, "%s\n", __func__); + mutex_lock(&ced->io_mutex); + ced_flush_out_buff(ced); + ced_flush_in_buff(ced); + mutex_unlock(&ced->io_mutex); return U14ERR_NOERROR; } @@ -937,16 +937,16 @@ int ced_kill_io(DEVICE_EXTENSION *pdx) ** ** Puts the current state of the 1401 in the Irp return buffer. *****************************************************************************/ -int ced_state_of_1401(DEVICE_EXTENSION *pdx) +int ced_state_of_1401(struct ced_data *ced) { int iReturn; - mutex_lock(&pdx->io_mutex); + mutex_lock(&ced->io_mutex); - ced_quick_check(pdx, false, false); /* get state up to date, no reset */ - iReturn = pdx->sCurrentState; + ced_quick_check(ced, false, false); /* get state up to date, no reset */ + iReturn = ced->sCurrentState; - mutex_unlock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s: %d\n", __func__, iReturn); + mutex_unlock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s: %d\n", __func__, iReturn); return iReturn; } @@ -957,27 +957,27 @@ int ced_state_of_1401(DEVICE_EXTENSION *pdx) ** 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 ced_start_self_test(DEVICE_EXTENSION *pdx) +int ced_start_self_test(struct ced_data *ced) { int nGot; - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s\n", __func__); + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s\n", __func__); - ced_draw_down(pdx); /* wait for, then kill outstanding Urbs */ - ced_flush_in_buff(pdx); /* Clear out input buffer & pipe */ - ced_flush_out_buff(pdx); /* Clear output buffer & pipe */ + ced_draw_down(ced); /* wait for, then kill outstanding Urbs */ + ced_flush_in_buff(ced); /* Clear out input buffer & pipe */ + ced_flush_out_buff(ced); /* Clear output buffer & pipe */ /* so things stay tidy */ /* ced_read_write_cancel(pDeviceObject); */ - pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flags here */ + ced->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flags here */ - nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), + nGot = usb_control_msg(ced->udev, usb_rcvctrlpipe(ced->udev, 0), DB_SELFTEST, (H_TO_D | VENDOR | DEVREQ), 0, 0, NULL, 0, HZ); /* allow 1 second timeout */ - pdx->ulSelfTestTime = jiffies + HZ * 30; /* 30 seconds into the future */ + ced->ulSelfTestTime = jiffies + HZ * 30; /* 30 seconds into the future */ - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); if (nGot < 0) - dev_err(&pdx->interface->dev, "%s: err=%d\n", __func__, nGot); + dev_err(&ced->interface->dev, "%s: err=%d\n", __func__, nGot); return nGot < 0 ? U14ERR_FAIL : U14ERR_NOERROR; } @@ -986,23 +986,23 @@ int ced_start_self_test(DEVICE_EXTENSION *pdx) ** ** Check progress of a self-test cycle ****************************************************************************/ -int ced_check_self_test(DEVICE_EXTENSION *pdx, TGET_SELFTEST __user *pGST) +int ced_check_self_test(struct ced_data *ced, 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); + mutex_lock(&ced->io_mutex); - dev_dbg(&pdx->interface->dev, "%s\n", __func__); - iReturn = ced_get_state(pdx, &state, &error); + dev_dbg(&ced->interface->dev, "%s\n", __func__); + iReturn = ced_get_state(ced, &state, &error); if (iReturn == U14ERR_NOERROR) /* Only accept zero if it happens twice */ - iReturn = ced_get_state(pdx, &state, &error); + iReturn = ced_get_state(ced, &state, &error); if (iReturn != U14ERR_NOERROR) { /* Self-test can cause comms errors */ /* so we assume still testing */ - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "%s: ced_get_state=%d, assuming still testing\n", __func__, iReturn); state = 0x80; /* Force still-testing, no error */ @@ -1011,7 +1011,7 @@ int ced_check_self_test(DEVICE_EXTENSION *pdx, TGET_SELFTEST __user *pGST) } if ((state == -1) && (error == -1)) { /* If ced_get_state had problems */ - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "%s: ced_get_state failed, assuming still testing\n", __func__); state = 0x80; /* Force still-testing, no error */ @@ -1023,31 +1023,31 @@ int ced_check_self_test(DEVICE_EXTENSION *pdx, TGET_SELFTEST __user *pGST) 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, + dev_dbg(&ced->interface->dev, "Self-test error code %d\n", gst.code); } else { /* No error, check for timeout */ unsigned long ulNow = jiffies; /* get current time */ - if (time_after(ulNow, pdx->ulSelfTestTime)) { + if (time_after(ulNow, ced->ulSelfTestTime)) { gst.code = -2; /* Flag the timeout */ - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "Self-test timed-out\n"); } else - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "Self-test on-going\n"); } } else { gst.code = -1; /* Flag the test is done */ - dev_dbg(&pdx->interface->dev, "Self-test done\n"); + dev_dbg(&ced->interface->dev, "Self-test done\n"); } 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)) - ced_is_1401(pdx); /* Get 1401 reset and OK */ + if ((ced->nPipes == 4) && (ced->s1401Type <= TYPEPOWER)) + ced_is_1401(ced); /* Get 1401 reset and OK */ else - ced_quick_check(pdx, true, true); /* Otherwise check without reset unless problems */ + ced_quick_check(ced, true, true); /* Otherwise check without reset unless problems */ } - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); if (copy_to_user(pGST, &gst, sizeof(gst))) return -EFAULT; @@ -1060,13 +1060,13 @@ int ced_check_self_test(DEVICE_EXTENSION *pdx, TGET_SELFTEST __user *pGST) ** ** Returns code for standard, plus, micro1401, power1401 or none ****************************************************************************/ -int ced_type_of_1401(DEVICE_EXTENSION *pdx) +int ced_type_of_1401(struct ced_data *ced) { int iReturn = TYPEUNKNOWN; - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s\n", __func__); + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s\n", __func__); - switch (pdx->s1401Type) { + switch (ced->s1401Type) { case TYPE1401: iReturn = U14ERR_STD; break; /* Handle these types directly */ @@ -1077,13 +1077,13 @@ int ced_type_of_1401(DEVICE_EXTENSION *pdx) iReturn = U14ERR_U1401; break; default: - if ((pdx->s1401Type >= TYPEPOWER) && (pdx->s1401Type <= 25)) - iReturn = pdx->s1401Type + 4; /* We can calculate types */ + if ((ced->s1401Type >= TYPEPOWER) && (ced->s1401Type <= 25)) + iReturn = ced->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\n", __func__, iReturn); - mutex_unlock(&pdx->io_mutex); + dev_dbg(&ced->interface->dev, "%s %d\n", __func__, iReturn); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1093,15 +1093,15 @@ int ced_type_of_1401(DEVICE_EXTENSION *pdx) ** ** Returns flags on block transfer abilities ****************************************************************************/ -int ced_transfer_flags(DEVICE_EXTENSION *pdx) +int ced_transfer_flags(struct ced_data *ced) { 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\n", __func__); - mutex_lock(&pdx->io_mutex); - if (pdx->bIsUSB2) /* Set flag for USB2 if appropriate */ + dev_dbg(&ced->interface->dev, "%s\n", __func__); + mutex_lock(&ced->io_mutex); + if (ced->bIsUSB2) /* Set flag for USB2 if appropriate */ iReturn |= U14TF_USB2; - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1111,18 +1111,18 @@ int ced_transfer_flags(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 ced_dbg_cmd(DEVICE_EXTENSION *pdx, unsigned char cmd, +static int ced_dbg_cmd(struct ced_data *ced, unsigned char cmd, unsigned int data) { int iReturn; - dev_dbg(&pdx->interface->dev, "%s: entry\n", __func__); - iReturn = usb_control_msg(pdx->udev, usb_sndctrlpipe(pdx->udev, 0), cmd, + dev_dbg(&ced->interface->dev, "%s: entry\n", __func__); + iReturn = usb_control_msg(ced->udev, usb_sndctrlpipe(ced->udev, 0), cmd, (H_TO_D | VENDOR | DEVREQ), (unsigned short)data, (unsigned short)(data >> 16), NULL, 0, HZ); /* allow 1 second timeout */ if (iReturn < 0) - dev_err(&pdx->interface->dev, "%s: fail code=%d\n", + dev_err(&ced->interface->dev, "%s: fail code=%d\n", __func__, iReturn); return iReturn; @@ -1133,7 +1133,7 @@ static int ced_dbg_cmd(DEVICE_EXTENSION *pdx, unsigned char cmd, ** ** Execute the diagnostic peek operation. Uses address, width and repeats. ****************************************************************************/ -int ced_dbg_peek(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) +int ced_dbg_peek(struct ced_data *ced, TDBGBLOCK __user *pDB) { int iReturn; TDBGBLOCK db; @@ -1141,17 +1141,17 @@ int ced_dbg_peek(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) if (copy_from_user(&db, pDB, sizeof(db))) return -EFAULT; - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s: @ %08x\n", __func__, db.iAddr); + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s: @ %08x\n", __func__, db.iAddr); - iReturn = ced_dbg_cmd(pdx, DB_SETADD, db.iAddr); + iReturn = ced_dbg_cmd(ced, DB_SETADD, db.iAddr); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_WIDTH, db.iWidth); + iReturn = ced_dbg_cmd(ced, DB_WIDTH, db.iWidth); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_REPEATS, db.iRepeats); + iReturn = ced_dbg_cmd(ced, DB_REPEATS, db.iRepeats); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_PEEK, 0); - mutex_unlock(&pdx->io_mutex); + iReturn = ced_dbg_cmd(ced, DB_PEEK, 0); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1162,7 +1162,7 @@ int ced_dbg_peek(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) ** Execute the diagnostic poke operation. Parameters are in the CSBLOCK struct ** in order address, size, repeats and value to poke. ****************************************************************************/ -int ced_dbg_poke(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) +int ced_dbg_poke(struct ced_data *ced, TDBGBLOCK __user *pDB) { int iReturn; TDBGBLOCK db; @@ -1170,17 +1170,17 @@ int ced_dbg_poke(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) if (copy_from_user(&db, pDB, sizeof(db))) return -EFAULT; - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s: @ %08x\n", __func__, db.iAddr); + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s: @ %08x\n", __func__, db.iAddr); - iReturn = ced_dbg_cmd(pdx, DB_SETADD, db.iAddr); + iReturn = ced_dbg_cmd(ced, DB_SETADD, db.iAddr); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_WIDTH, db.iWidth); + iReturn = ced_dbg_cmd(ced, DB_WIDTH, db.iWidth); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_REPEATS, db.iRepeats); + iReturn = ced_dbg_cmd(ced, DB_REPEATS, db.iRepeats); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_POKE, db.iData); - mutex_unlock(&pdx->io_mutex); + iReturn = ced_dbg_cmd(ced, DB_POKE, db.iData); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1191,7 +1191,7 @@ int ced_dbg_poke(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) ** Execute the diagnostic ramp data operation. Parameters are in the CSBLOCK struct ** in order address, default, enable mask, size and repeats. ****************************************************************************/ -int ced_dbg_ramp_data(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) +int ced_dbg_ramp_data(struct ced_data *ced, TDBGBLOCK __user *pDB) { int iReturn; TDBGBLOCK db; @@ -1199,21 +1199,21 @@ int ced_dbg_ramp_data(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) if (copy_from_user(&db, pDB, sizeof(db))) return -EFAULT; - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s: @ %08x\n", __func__, db.iAddr); + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s: @ %08x\n", __func__, db.iAddr); - iReturn = ced_dbg_cmd(pdx, DB_SETADD, db.iAddr); + iReturn = ced_dbg_cmd(ced, DB_SETADD, db.iAddr); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_SETDEF, db.iDefault); + iReturn = ced_dbg_cmd(ced, DB_SETDEF, db.iDefault); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_SETMASK, db.iMask); + iReturn = ced_dbg_cmd(ced, DB_SETMASK, db.iMask); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_WIDTH, db.iWidth); + iReturn = ced_dbg_cmd(ced, DB_WIDTH, db.iWidth); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_REPEATS, db.iRepeats); + iReturn = ced_dbg_cmd(ced, DB_REPEATS, db.iRepeats); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_RAMPD, 0); - mutex_unlock(&pdx->io_mutex); + iReturn = ced_dbg_cmd(ced, DB_RAMPD, 0); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1223,7 +1223,7 @@ int ced_dbg_ramp_data(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) ** ** Execute the diagnostic ramp address operation ****************************************************************************/ -int ced_dbg_ramp_addr(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) +int ced_dbg_ramp_addr(struct ced_data *ced, TDBGBLOCK __user *pDB) { int iReturn; TDBGBLOCK db; @@ -1231,19 +1231,19 @@ int ced_dbg_ramp_addr(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) if (copy_from_user(&db, pDB, sizeof(db))) return -EFAULT; - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s\n", __func__); + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s\n", __func__); - iReturn = ced_dbg_cmd(pdx, DB_SETDEF, db.iDefault); + iReturn = ced_dbg_cmd(ced, DB_SETDEF, db.iDefault); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_SETMASK, db.iMask); + iReturn = ced_dbg_cmd(ced, DB_SETMASK, db.iMask); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_WIDTH, db.iWidth); + iReturn = ced_dbg_cmd(ced, DB_WIDTH, db.iWidth); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_REPEATS, db.iRepeats); + iReturn = ced_dbg_cmd(ced, DB_REPEATS, db.iRepeats); if (iReturn == U14ERR_NOERROR) - iReturn = ced_dbg_cmd(pdx, DB_RAMPA, 0); - mutex_unlock(&pdx->io_mutex); + iReturn = ced_dbg_cmd(ced, DB_RAMPA, 0); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1253,17 +1253,17 @@ int ced_dbg_ramp_addr(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) ** ** Retrieve the data resulting from the last debug Peek operation ****************************************************************************/ -int ced_dbg_get_data(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) +int ced_dbg_get_data(struct ced_data *ced, 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\n", __func__); + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s\n", __func__); /* Read back the last peeked value from the 1401. */ - iReturn = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), + iReturn = usb_control_msg(ced->udev, usb_rcvctrlpipe(ced->udev, 0), DB_DATA, (D_TO_H | VENDOR | DEVREQ), 0, 0, &db.iData, sizeof(db.iData), HZ); if (iReturn == sizeof(db.iData)) { @@ -1272,10 +1272,10 @@ int ced_dbg_get_data(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) else iReturn = U14ERR_NOERROR; } else - dev_err(&pdx->interface->dev, "%s: failed, code %d\n", + dev_err(&ced->interface->dev, "%s: failed, code %d\n", __func__, iReturn); - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1286,15 +1286,15 @@ int ced_dbg_get_data(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) ** Stop any never-ending debug loop, we just call ced_get_state for USB ** ****************************************************************************/ -int ced_dbg_stop_loop(DEVICE_EXTENSION *pdx) +int ced_dbg_stop_loop(struct ced_data *ced) { int iReturn; unsigned int uState, uErr; - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s\n", __func__); - iReturn = ced_get_state(pdx, &uState, &uErr); - mutex_unlock(&pdx->io_mutex); + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s\n", __func__); + iReturn = ced_get_state(ced, &uState, &uErr); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1307,7 +1307,7 @@ int ced_dbg_stop_loop(DEVICE_EXTENSION *pdx) ** booked and a transfer to that area is in progress. Otherwise, we will ** release the area and re-assign it. ****************************************************************************/ -int ced_set_circular(DEVICE_EXTENSION *pdx, struct transfer_area_desc __user *pTD) +int ced_set_circular(struct ced_data *ced, struct transfer_area_desc __user *pTD) { int iReturn; bool bToHost; @@ -1316,8 +1316,8 @@ int ced_set_circular(DEVICE_EXTENSION *pdx, struct transfer_area_desc __user *pT if (copy_from_user(&td, pTD, sizeof(td))) return -EFAULT; - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s: area:%d, size:%08x\n", + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s: area:%d, size:%08x\n", __func__, td.wAreaNum, td.dwLength); bToHost = td.eSize != 0; /* this is used as the tohost flag */ @@ -1325,10 +1325,10 @@ int ced_set_circular(DEVICE_EXTENSION *pdx, struct transfer_area_desc __user *pT /* 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 = - ced_set_area(pdx, td.wAreaNum, + ced_set_area(ced, td.wAreaNum, (char __user *)((unsigned long)td.lpvBuff), td.dwLength, true, bToHost); - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1337,18 +1337,18 @@ int ced_set_circular(DEVICE_EXTENSION *pdx, struct transfer_area_desc __user *pT ** ** Return the next available block of circularly-transferred data. ****************************************************************************/ -int ced_get_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) +int ced_get_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB) { int iReturn = U14ERR_NOERROR; unsigned int nArea; TCIRCBLOCK cb; - dev_dbg(&pdx->interface->dev, "%s\n", __func__); + dev_dbg(&ced->interface->dev, "%s\n", __func__); if (copy_from_user(&cb, pCB, sizeof(cb))) return -EFAULT; - mutex_lock(&pdx->io_mutex); + mutex_lock(&ced->io_mutex); nArea = cb.nArea; /* Retrieve parameters first */ cb.dwOffset = 0; /* set default result (nothing) */ @@ -1356,29 +1356,29 @@ int ced_get_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */ /* Pointer to relevant info */ - struct transarea *pArea = &pdx->rTransDef[nArea]; - spin_lock_irq(&pdx->stagedLock); /* Lock others out */ + struct transarea *pArea = &ced->rTransDef[nArea]; + spin_lock_irq(&ced->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, + dev_dbg(&ced->interface->dev, "%s: return block 0: %d bytes at %d\n", __func__, cb.dwSize, cb.dwOffset); } } else iReturn = U14ERR_NOTSET; - spin_unlock_irq(&pdx->stagedLock); + spin_unlock_irq(&ced->stagedLock); } else iReturn = U14ERR_BADAREA; if (copy_to_user(pCB, &cb, sizeof(cb))) iReturn = -EFAULT; - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); return iReturn; } @@ -1387,18 +1387,18 @@ int ced_get_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) ** ** Frees a block of circularly-transferred data and returns the next one. ****************************************************************************/ -int ced_free_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) +int ced_free_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB) { int iReturn = U14ERR_NOERROR; unsigned int nArea, uStart, uSize; TCIRCBLOCK cb; - dev_dbg(&pdx->interface->dev, "%s\n", __func__); + dev_dbg(&ced->interface->dev, "%s\n", __func__); if (copy_from_user(&cb, pCB, sizeof(cb))) return -EFAULT; - mutex_lock(&pdx->io_mutex); + mutex_lock(&ced->io_mutex); nArea = cb.nArea; /* Retrieve parameters first */ uStart = cb.dwOffset; @@ -1408,8 +1408,8 @@ int ced_free_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */ /* Pointer to relevant info */ - struct transarea *pArea = &pdx->rTransDef[nArea]; - spin_lock_irq(&pdx->stagedLock); /* Lock others out */ + struct transarea *pArea = &ced->rTransDef[nArea]; + spin_lock_irq(&ced->stagedLock); /* Lock others out */ if ((pArea->bUsed) && (pArea->bCircular) && /* Must be circular area */ (pArea->bCircToHost)) { /* For now at least must be to host */ @@ -1428,12 +1428,12 @@ int ced_free_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) pArea->aBlocks[0].dwOffset = 0; } - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: free %d bytes at %d, return %d bytes at %d, wait=%d\n", __func__, uSize, uStart, pArea->aBlocks[0].dwSize, pArea->aBlocks[0].dwOffset, - pdx->bXFerWaiting); + ced->bXFerWaiting); /* Return the next available block of memory as well */ if (pArea->aBlocks[0].dwSize > 0) { /* Got anything? */ @@ -1442,15 +1442,15 @@ int ced_free_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) cb.dwSize = pArea->aBlocks[0].dwSize; } - bWaiting = pdx->bXFerWaiting; - if (bWaiting && pdx->bStagedUrbPending) { - dev_err(&pdx->interface->dev, + bWaiting = ced->bXFerWaiting; + if (bWaiting && ced->bStagedUrbPending) { + dev_err(&ced->interface->dev, "%s: ERROR: waiting xfer and staged Urb pending!\n", __func__); bWaiting = false; } } else { - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "%s: ERROR: freeing %d bytes at %d, block 0 is %d bytes at %d\n", __func__, uSize, uStart, pArea->aBlocks[0].dwSize, @@ -1461,25 +1461,25 @@ int ced_free_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB) /* If we have one, kick off pending transfer */ if (bWaiting) { /* Got a block xfer waiting? */ int RWMStat = - ced_read_write_mem(pdx, !pdx->rDMAInfo.bOutWard, - pdx->rDMAInfo.wIdent, - pdx->rDMAInfo.dwOffset, - pdx->rDMAInfo.dwSize); + ced_read_write_mem(ced, !ced->rDMAInfo.bOutWard, + ced->rDMAInfo.wIdent, + ced->rDMAInfo.dwOffset, + ced->rDMAInfo.dwSize); if (RWMStat != U14ERR_NOERROR) - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "%s: rw setup failed %d\n", __func__, RWMStat); } } else iReturn = U14ERR_NOTSET; - spin_unlock_irq(&pdx->stagedLock); + spin_unlock_irq(&ced->stagedLock); } else iReturn = U14ERR_BADAREA; if (copy_to_user(pCB, &cb, sizeof(cb))) iReturn = -EFAULT; - mutex_unlock(&pdx->io_mutex); + mutex_unlock(&ced->io_mutex); return iReturn; } diff --git a/drivers/staging/ced1401/usb1401.c b/drivers/staging/ced1401/usb1401.c index 9cc79a8090d6..83c608c2b748 100644 --- a/drivers/staging/ced1401/usb1401.c +++ b/drivers/staging/ced1401/usb1401.c @@ -70,7 +70,7 @@ it is very out of date. A lot of information was gleaned from the latest usb_skeleton.c code (you need to download the kernel sources to get this). To match the Windows version, everything is done using ioctl calls. All the -device state is held in the DEVICE_EXTENSION (named to match Windows use). +device state is held in the struct ced_data. Block transfers are done by using get_user_pages() to pin down a list of pages that we hold a pointer to in the device driver. We also allocate a coherent transfer buffer of size STAGED_SZ (this must be a multiple of the @@ -123,32 +123,32 @@ static struct usb_driver ced_driver; static void ced_delete(struct kref *kref) { - DEVICE_EXTENSION *pdx = to_DEVICE_EXTENSION(kref); + struct ced_data *ced = to_ced_data(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); + /* of ced will probably be NULL, so cannot be used to get to dev. */ + usb_free_coherent(ced->udev, OUTBUF_SZ, ced->pCoherCharOut, + ced->pUrbCharOut->transfer_dma); + usb_free_urb(ced->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); + usb_free_coherent(ced->udev, INBUF_SZ, ced->pCoherCharIn, + ced->pUrbCharIn->transfer_dma); + usb_free_urb(ced->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_free_coherent(ced->udev, STAGED_SZ, ced->pCoherStagedIO, + ced->pStagedUrb->transfer_dma); + usb_free_urb(ced->pStagedUrb); - usb_put_dev(pdx->udev); - kfree(pdx); + usb_put_dev(ced->udev); + kfree(ced); } /* 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; + struct ced_data *ced; int retval = 0; int subminor = iminor(inode); struct usb_interface *interface = @@ -160,42 +160,42 @@ static int ced_open(struct inode *inode, struct file *file) goto exit; } - pdx = usb_get_intfdata(interface); - if (!pdx) { + ced = usb_get_intfdata(interface); + if (!ced) { retval = -ENODEV; goto exit; } - dev_dbg(&interface->dev, "%s: got pdx\n", __func__); + dev_dbg(&interface->dev, "%s: got ced\n", __func__); /* increment our usage count for the device */ - kref_get(&pdx->kref); + kref_get(&ced->kref); /* lock the device to allow correctly handling errors * in resumption */ - mutex_lock(&pdx->io_mutex); + mutex_lock(&ced->io_mutex); - if (!pdx->open_count++) { + if (!ced->open_count++) { retval = usb_autopm_get_interface(interface); if (retval) { - pdx->open_count--; - mutex_unlock(&pdx->io_mutex); - kref_put(&pdx->kref, ced_delete); + ced->open_count--; + mutex_unlock(&ced->io_mutex); + kref_put(&ced->kref, ced_delete); goto exit; } } else { /* uncomment this block if you want exclusive open */ dev_err(&interface->dev, "%s: fail: already open\n", __func__); retval = -EBUSY; - pdx->open_count--; - mutex_unlock(&pdx->io_mutex); - kref_put(&pdx->kref, ced_delete); + ced->open_count--; + mutex_unlock(&ced->io_mutex); + kref_put(&ced->kref, ced_delete); goto exit; } /* prevent the device from being autosuspended */ /* save our object in the file's private structure */ - file->private_data = pdx; - mutex_unlock(&pdx->io_mutex); + file->private_data = ced; + mutex_unlock(&ced->io_mutex); exit: return retval; @@ -203,43 +203,43 @@ exit: static int ced_release(struct inode *inode, struct file *file) { - DEVICE_EXTENSION *pdx = file->private_data; - if (pdx == NULL) + struct ced_data *ced = file->private_data; + if (ced == NULL) return -ENODEV; - dev_dbg(&pdx->interface->dev, "%s: called\n", __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); + dev_dbg(&ced->interface->dev, "%s: called\n", __func__); + mutex_lock(&ced->io_mutex); + if (!--ced->open_count && ced->interface) /* Allow autosuspend */ + usb_autopm_put_interface(ced->interface); + mutex_unlock(&ced->io_mutex); - kref_put(&pdx->kref, ced_delete); /* decrement the count on our device */ + kref_put(&ced->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) + struct ced_data *ced = file->private_data; + if (ced == NULL) return -ENODEV; - dev_dbg(&pdx->interface->dev, "%s: char in pend=%d\n", - __func__, pdx->bReadCharsPending); + dev_dbg(&ced->interface->dev, "%s: char in pend=%d\n", + __func__, ced->bReadCharsPending); /* wait for io to stop */ - mutex_lock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s: got io_mutex\n", __func__); - ced_draw_down(pdx); + mutex_lock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s: got io_mutex\n", __func__); + ced_draw_down(ced); /* 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); + spin_lock_irq(&ced->err_lock); + res = ced->errors ? (ced->errors == -EPIPE ? -EPIPE : -EIO) : 0; + ced->errors = 0; + spin_unlock_irq(&ced->err_lock); - mutex_unlock(&pdx->io_mutex); - dev_dbg(&pdx->interface->dev, "%s: exit reached\n", __func__); + mutex_unlock(&ced->io_mutex); + dev_dbg(&ced->interface->dev, "%s: exit reached\n", __func__); return res; } @@ -247,13 +247,13 @@ static int ced_flush(struct file *file, fl_owner_t id) /*************************************************************************** ** can_accept_io_requests ** If the device is removed, interface is set NULL. We also clear our pointer -** from the interface, so we should make sure that pdx is not NULL. This will +** from the interface, so we should make sure that ced is not NULL. This will ** not help with a device extension held by a file. ** return true if can accept new io requests, else false */ -static bool can_accept_io_requests(DEVICE_EXTENSION *pdx) +static bool can_accept_io_requests(struct ced_data *ced) { - return pdx && pdx->interface; /* Can we accept IO requests */ + return ced && ced->interface; /* Can we accept IO requests */ } /**************************************************************************** @@ -262,73 +262,73 @@ static bool can_accept_io_requests(DEVICE_EXTENSION *pdx) ****************************************************************************/ static void ced_writechar_callback(struct urb *pUrb) { - DEVICE_EXTENSION *pdx = pUrb->context; + struct ced_data *ced = 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, + dev_err(&ced->interface->dev, "%s: nonzero write bulk status received: %d\n", __func__, pUrb->status); } - spin_lock(&pdx->err_lock); - pdx->errors = pUrb->status; - spin_unlock(&pdx->err_lock); + spin_lock(&ced->err_lock); + ced->errors = pUrb->status; + spin_unlock(&ced->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, + spin_lock(&ced->charOutLock); /* already at irq level */ + ced->dwOutBuffGet = 0; /* Reset the output buffer */ + ced->dwOutBuffPut = 0; + ced->dwNumOutput = 0; /* Clear the char count */ + ced->bPipeError[0] = 1; /* Flag an error for later */ + ced->bSendCharsPending = false; /* Allow other threads again */ + spin_unlock(&ced->charOutLock); /* already at irq level */ + dev_dbg(&ced->interface->dev, "%s: char out done, 0 chars sent\n", __func__); } else { - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: char out done, %d chars sent\n", __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; + spin_lock(&ced->charOutLock); /* already at irq level */ + ced->dwNumOutput -= nGot; /* Now adjust the char send buffer */ + ced->dwOutBuffGet += nGot; /* to match what we did */ + if (ced->dwOutBuffGet >= OUTBUF_SZ) /* Can't do this any earlier as data could be overwritten */ + ced->dwOutBuffGet = 0; - if (pdx->dwNumOutput > 0) { /* if more to be done... */ + if (ced->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 |= + char *pDat = &ced->outputBuffer[ced->dwOutBuffGet]; + unsigned int dwCount = ced->dwNumOutput; /* maximum to send */ + if ((ced->dwOutBuffGet + dwCount) > OUTBUF_SZ) /* does it cross buffer end? */ + dwCount = OUTBUF_SZ - ced->dwOutBuffGet; + spin_unlock(&ced->charOutLock); /* we are done with stuff that changes */ + memcpy(ced->pCoherCharOut, pDat, dwCount); /* copy output data to the buffer */ + usb_fill_bulk_urb(ced->pUrbCharOut, ced->udev, + usb_sndbulkpipe(ced->udev, + ced->epAddr[0]), + ced->pCoherCharOut, dwCount, + ced_writechar_callback, ced); + ced->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<\n", + usb_anchor_urb(ced->pUrbCharOut, &ced->submitted); /* in case we need to kill it */ + iReturn = usb_submit_urb(ced->pUrbCharOut, GFP_ATOMIC); + dev_dbg(&ced->interface->dev, "%s: n=%d>%s<\n", __func__, dwCount, pDat); - spin_lock(&pdx->charOutLock); /* grab lock for errors */ + spin_lock(&ced->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, + ced->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ + ced->bSendCharsPending = false; /* Allow other threads again */ + usb_unanchor_urb(ced->pUrbCharOut); + dev_err(&ced->interface->dev, "%s: usb_submit_urb() returned %d\n", __func__, iReturn); } } else - pdx->bSendCharsPending = false; /* Allow other threads again */ - spin_unlock(&pdx->charOutLock); /* already at irq level */ + ced->bSendCharsPending = false; /* Allow other threads again */ + spin_unlock(&ced->charOutLock); /* already at irq level */ } } @@ -337,89 +337,89 @@ 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 ced_send_chars(DEVICE_EXTENSION *pdx) +int ced_send_chars(struct ced_data *ced) { int iReturn = U14ERR_NOERROR; - spin_lock_irq(&pdx->charOutLock); /* Protect ourselves */ + spin_lock_irq(&ced->charOutLock); /* Protect ourselves */ - if ((!pdx->bSendCharsPending) && /* Not currently sending */ - (pdx->dwNumOutput > 0) && /* has characters to output */ - (can_accept_io_requests(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 */ + if ((!ced->bSendCharsPending) && /* Not currently sending */ + (ced->dwNumOutput > 0) && /* has characters to output */ + (can_accept_io_requests(ced))) { /* and current activity is OK */ + unsigned int dwCount = ced->dwNumOutput; /* Get a copy of the character count */ + ced->bSendCharsPending = true; /* Set flag to lock out other threads */ - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "Send %d chars to 1401, EP0 flag %d\n", - dwCount, pdx->nPipes == 3); + dwCount, ced->nPipes == 3); /* If we have only 3 end points we must send the characters to the 1401 using EP0. */ - if (pdx->nPipes == 3) { + if (ced->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 */ + spin_unlock_irq(&ced->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 */ + int nSent = usb_control_msg(ced->udev, + usb_sndctrlpipe(ced->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 */ + &ced->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, + dev_err(&ced->interface->dev, "Send %d chars by EP0 failed: %d\n", n, iReturn); } else { - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "Sent %d chars by EP0\n", 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 */ + spin_lock_irq(&ced->charOutLock); /* Protect ced changes, released by general code */ + ced->dwOutBuffGet = 0; /* so reset the output buffer */ + ced->dwOutBuffPut = 0; + ced->dwNumOutput = 0; /* and clear the buffer count */ + ced->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 |= + char *pDat = &ced->outputBuffer[ced->dwOutBuffGet]; + + if ((ced->dwOutBuffGet + dwCount) > OUTBUF_SZ) /* does it cross buffer end? */ + dwCount = OUTBUF_SZ - ced->dwOutBuffGet; + spin_unlock_irq(&ced->charOutLock); /* we are done with stuff that changes */ + memcpy(ced->pCoherCharOut, pDat, dwCount); /* copy output data to the buffer */ + usb_fill_bulk_urb(ced->pUrbCharOut, ced->udev, + usb_sndbulkpipe(ced->udev, + ced->epAddr[0]), + ced->pCoherCharOut, dwCount, + ced_writechar_callback, ced); + ced->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 */ + usb_anchor_urb(ced->pUrbCharOut, &ced->submitted); + iReturn = usb_submit_urb(ced->pUrbCharOut, GFP_KERNEL); + spin_lock_irq(&ced->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 */ + ced->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ + ced->bSendCharsPending = false; /* Allow other threads again */ + usb_unanchor_urb(ced->pUrbCharOut); /* remove from list of active urbs */ } } - } else if (pdx->bSendCharsPending && (pdx->dwNumOutput > 0)) - dev_dbg(&pdx->interface->dev, + } else if (ced->bSendCharsPending && (ced->dwNumOutput > 0)) + dev_dbg(&ced->interface->dev, "%s: bSendCharsPending:true\n", __func__); - dev_dbg(&pdx->interface->dev, "%s: exit code: %d\n", __func__, iReturn); - spin_unlock_irq(&pdx->charOutLock); /* Now let go of the spinlock */ + dev_dbg(&ced->interface->dev, "%s: exit code: %d\n", __func__, iReturn); + spin_unlock_irq(&ced->charOutLock); /* Now let go of the spinlock */ return iReturn; } @@ -427,27 +427,27 @@ int ced_send_chars(DEVICE_EXTENSION *pdx) ** ced_copy_user_space ** This moves memory between pinned down user space and the pCoherStagedIO ** memory buffer we use for transfers. Copy n bytes in the directions that -** is defined by pdx->StagedRead. The user space is determined by the area -** in pdx->StagedId and the offset in pdx->StagedDone. The user +** is defined by ced->StagedRead. The user space is determined by the area +** in ced->StagedId and the offset in ced->StagedDone. The user ** area may well not start on a page boundary, so allow for that. ** ** We have a table of physical pages that describe the area, so we can use ** this to get a virtual address that the kernel can use. ** -** pdx Is our device extension which holds all we know about the transfer. +** ced 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 ced_copy_user_space(DEVICE_EXTENSION *pdx, int n) +static void ced_copy_user_space(struct ced_data *ced, int n) { - unsigned int nArea = pdx->StagedId; + unsigned int nArea = ced->StagedId; if (nArea < MAX_TRANSAREAS) { /* area to be used */ - struct transarea *pArea = &pdx->rTransDef[nArea]; + struct transarea *pArea = &ced->rTransDef[nArea]; unsigned int dwOffset = - pdx->StagedDone + pdx->StagedOffset + pArea->dwBaseOffset; - char *pCoherBuf = pdx->pCoherStagedIO; /* coherent buffer */ + ced->StagedDone + ced->StagedOffset + pArea->dwBaseOffset; + char *pCoherBuf = ced->pCoherStagedIO; /* coherent buffer */ if (!pArea->bUsed) { - dev_err(&pdx->interface->dev, "%s: area %d unused\n", + dev_err(&ced->interface->dev, "%s: area %d unused\n", __func__, nArea); return; } @@ -462,7 +462,7 @@ static void ced_copy_user_space(DEVICE_EXTENSION *pdx, int n) 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) + if (ced->StagedRead) memcpy(pvAddress + uiPageOff, pCoherBuf, uiXfer); else @@ -474,26 +474,26 @@ static void ced_copy_user_space(DEVICE_EXTENSION *pdx, int n) pCoherBuf += uiXfer; n -= uiXfer; } else { - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "%s: did not map page %d\n", __func__, nPage); return; } } else { - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "%s: exceeded pages %d\n", __func__, nPage); return; } } } else - dev_err(&pdx->interface->dev, "%s: bad area %d\n", + dev_err(&ced->interface->dev, "%s: bad area %d\n", __func__, nArea); } /* Forward declarations for stuff used circularly */ -static int ced_stage_chunk(DEVICE_EXTENSION *pdx); +static int ced_stage_chunk(struct ced_data *ced); /*************************************************************************** ** ReadWrite_Complete ** @@ -501,76 +501,76 @@ static int ced_stage_chunk(DEVICE_EXTENSION *pdx); */ static void staged_callback(struct urb *pUrb) { - DEVICE_EXTENSION *pdx = pUrb->context; + struct ced_data *ced = 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 ced_read_write_mem() action while this routine is running */ - pdx->bStagedUrbPending = false; /* clear the flag for staged IRP pending */ + spin_lock(&ced->stagedLock); /* stop ced_read_write_mem() action while this routine is running */ + ced->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, + dev_err(&ced->interface->dev, "%s: nonzero write bulk status received: %d\n", __func__, pUrb->status); } else - dev_info(&pdx->interface->dev, + dev_info(&ced->interface->dev, "%s: staged xfer cancelled\n", __func__); - spin_lock(&pdx->err_lock); - pdx->errors = pUrb->status; - spin_unlock(&pdx->err_lock); + spin_lock(&ced->err_lock); + ced->errors = pUrb->status; + spin_unlock(&ced->err_lock); nGot = 0; /* and tidy up again if so */ bCancel = true; } else { - dev_dbg(&pdx->interface->dev, "%s: %d chars xferred\n", + dev_dbg(&ced->interface->dev, "%s: %d chars xferred\n", __func__, nGot); - if (pdx->StagedRead) /* if reading, save to user space */ - ced_copy_user_space(pdx, nGot); /* copy from buffer to user */ + if (ced->StagedRead) /* if reading, save to user space */ + ced_copy_user_space(ced, nGot); /* copy from buffer to user */ if (nGot == 0) - dev_dbg(&pdx->interface->dev, "%s: ZLP\n", __func__); + dev_dbg(&ced->interface->dev, "%s: ZLP\n", __func__); } /* Update the transfer length based on the TransferBufferLength value in the URB */ - pdx->StagedDone += nGot; + ced->StagedDone += nGot; - dev_dbg(&pdx->interface->dev, "%s: done %d bytes of %d\n", - __func__, pdx->StagedDone, pdx->StagedLength); + dev_dbg(&ced->interface->dev, "%s: done %d bytes of %d\n", + __func__, ced->StagedDone, ced->StagedLength); - if ((pdx->StagedDone == pdx->StagedLength) || /* If no more to do */ + if ((ced->StagedDone == ced->StagedLength) || /* If no more to do */ (bCancel)) { /* or this IRP was cancelled */ /* Transfer area info */ - struct transarea *pArea = &pdx->rTransDef[pdx->StagedId]; - dev_dbg(&pdx->interface->dev, + struct transarea *pArea = &ced->rTransDef[ced->StagedId]; + dev_dbg(&ced->interface->dev, "%s: transfer done, bytes %d, cancel %d\n", - __func__, pdx->StagedDone, bCancel); + __func__, ced->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 ced_read_write_mem) is totally duff. */ if ((pArea->bCircular) && (pArea->bCircToHost) && (!bCancel) && /* Time to sort out circular buffer info? */ - (pdx->StagedRead)) { /* Only for tohost transfers for now */ + (ced->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 == + if (ced->StagedOffset == (pArea->aBlocks[1].dwOffset + pArea->aBlocks[1].dwSize)) { pArea->aBlocks[1].dwSize += - pdx->StagedLength; - dev_dbg(&pdx->interface->dev, + ced->StagedLength; + dev_dbg(&ced->interface->dev, "RWM_Complete, circ block 1 now %d bytes at %d\n", 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; + ced->StagedOffset; pArea->aBlocks[1].dwSize = - pdx->StagedLength; - dev_err(&pdx->interface->dev, + ced->StagedLength; + dev_err(&ced->interface->dev, "%s: ERROR, circ block 1 re-started %d bytes at %d\n", __func__, pArea->aBlocks[1].dwSize, @@ -579,11 +579,11 @@ static void staged_callback(struct urb *pUrb) } 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 == + if (ced->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, + pArea->aBlocks[0].dwSize += ced->StagedLength; /* Just add this transfer in */ + dev_dbg(&ced->interface->dev, "RWM_Complete, circ block 0 now %d bytes at %d\n", pArea->aBlocks[0]. dwSize, @@ -591,10 +591,10 @@ static void staged_callback(struct urb *pUrb) dwOffset); } else { /* If it doesn't append, put into new block 1 */ pArea->aBlocks[1].dwOffset = - pdx->StagedOffset; + ced->StagedOffset; pArea->aBlocks[1].dwSize = - pdx->StagedLength; - dev_dbg(&pdx->interface->dev, + ced->StagedLength; + dev_dbg(&ced->interface->dev, "RWM_Complete, circ block 1 started %d bytes at %d\n", pArea->aBlocks[1]. dwSize, @@ -603,10 +603,10 @@ static void staged_callback(struct urb *pUrb) } } else { /* No info stored yet, just save in block 0 */ pArea->aBlocks[0].dwOffset = - pdx->StagedOffset; + ced->StagedOffset; pArea->aBlocks[0].dwSize = - pdx->StagedLength; - dev_dbg(&pdx->interface->dev, + ced->StagedLength; + dev_dbg(&ced->interface->dev, "RWM_Complete, circ block 0 started %d bytes at %d\n", pArea->aBlocks[0].dwSize, pArea->aBlocks[0].dwOffset); @@ -615,12 +615,12 @@ static void staged_callback(struct urb *pUrb) } if (!bCancel) { /* Don't generate an event if cancelled */ - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "RWM_Complete, bCircular %d, bToHost %d, eStart %d, eSize %d\n", 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? */ + (ced->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. */ @@ -633,16 +633,16 @@ static void staged_callback(struct urb *pUrb) iWakeUp = (dwTotal >= pArea->dwEventSz); } else { unsigned int transEnd = - pdx->StagedOffset + - pdx->StagedLength; + ced->StagedOffset + + ced->StagedLength; unsigned int eventEnd = pArea->dwEventSt + pArea->dwEventSz; - iWakeUp = (pdx->StagedOffset < eventEnd) + iWakeUp = (ced->StagedOffset < eventEnd) && (transEnd > pArea->dwEventSt); } if (iWakeUp) { - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "About to set event to notify app\n"); wake_up_interruptible(&pArea->wqEvent); /* wake up waiting processes */ ++pArea->iWakeUp; /* increment wakeup count */ @@ -650,44 +650,44 @@ static void staged_callback(struct urb *pUrb) } } - pdx->dwDMAFlag = MODE_CHAR; /* Switch back to char mode before ced_read_write_mem call */ + ced->dwDMAFlag = MODE_CHAR; /* Switch back to char mode before ced_read_write_mem 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? */ + if (ced->bXFerWaiting) { /* Got a block xfer waiting? */ int iReturn; - dev_info(&pdx->interface->dev, + dev_info(&ced->interface->dev, "*** RWM_Complete *** pending transfer will now be set up!!!\n"); iReturn = - ced_read_write_mem(pdx, !pdx->rDMAInfo.bOutWard, - pdx->rDMAInfo.wIdent, - pdx->rDMAInfo.dwOffset, - pdx->rDMAInfo.dwSize); + ced_read_write_mem(ced, !ced->rDMAInfo.bOutWard, + ced->rDMAInfo.wIdent, + ced->rDMAInfo.dwOffset, + ced->rDMAInfo.dwSize); if (iReturn) - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "RWM_Complete rw setup failed %d\n", iReturn); } } } else /* Here for more to do */ - ced_stage_chunk(pdx); /* fire off the next bit */ + ced_stage_chunk(ced); /* 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; + bRestartCharInput = !bCancel && (ced->dwDMAFlag == MODE_CHAR) + && !ced->bXFerWaiting; - spin_unlock(&pdx->stagedLock); /* Finally release the lock again */ + spin_unlock(&ced->stagedLock); /* Finally release the lock again */ /* This is not correct as dwDMAFlag is protected by the staged lock, but it is treated */ /* in ced_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... */ - ced_allowi(pdx); /* ...ced_allowi tests a lock too. */ - dev_dbg(&pdx->interface->dev, "%s: done\n", __func__); + ced_allowi(ced); /* ...ced_allowi tests a lock too. */ + dev_dbg(&ced->interface->dev, "%s: done\n", __func__); } /**************************************************************************** @@ -698,47 +698,47 @@ 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 ced_stage_chunk(DEVICE_EXTENSION *pdx) +static int ced_stage_chunk(struct ced_data *ced) { 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) + int nPipe = ced->StagedRead ? 3 : 2; /* The pipe number to use for reads or writes */ + if (ced->nPipes == 3) nPipe--; /* Adjust for the 3-pipe case */ if (nPipe < 0) /* and trap case that should never happen */ return U14ERR_FAIL; - if (!can_accept_io_requests(pdx)) { /* got sudden remove? */ - dev_info(&pdx->interface->dev, "%s: sudden remove, giving up\n", + if (!can_accept_io_requests(ced)) { /* got sudden remove? */ + dev_info(&ced->interface->dev, "%s: sudden remove, giving up\n", __func__); return U14ERR_FAIL; /* could do with a better error */ } - ChunkSize = (pdx->StagedLength - pdx->StagedDone); /* transfer length remaining */ + ChunkSize = (ced->StagedLength - ced->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... */ - ced_copy_user_space(pdx, ChunkSize); /* ...copy data into the buffer */ + if (!ced->StagedRead) /* if writing... */ + ced_copy_user_space(ced, ChunkSize); /* ...copy data into the buffer */ - usb_fill_bulk_urb(pdx->pStagedUrb, pdx->udev, - pdx->StagedRead ? usb_rcvbulkpipe(pdx->udev, - pdx-> + usb_fill_bulk_urb(ced->pStagedUrb, ced->udev, + ced->StagedRead ? usb_rcvbulkpipe(ced->udev, + ced-> 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); + usb_sndbulkpipe(ced->udev, ced->epAddr[nPipe]), + ced->pCoherStagedIO, ChunkSize, staged_callback, ced); + ced->pStagedUrb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; + usb_anchor_urb(ced->pStagedUrb, &ced->submitted); /* in case we need to kill it */ + iReturn = usb_submit_urb(ced->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\n", + usb_unanchor_urb(ced->pStagedUrb); /* kill it */ + ced->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ + dev_err(&ced->interface->dev, "%s: submit urb failed, code %d\n", __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\n", - __func__, pdx->StagedDone, ChunkSize); + ced->bStagedUrbPending = true; /* Set the flag for staged URB pending */ + dev_dbg(&ced->interface->dev, "%s: done so far:%d, this size:%d\n", + __func__, ced->StagedDone, ChunkSize); return iReturn; } @@ -760,34 +760,34 @@ static int ced_stage_chunk(DEVICE_EXTENSION *pdx) ** transfer. ** dwLen - the number of bytes to transfer. */ -int ced_read_write_mem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent, +int ced_read_write_mem(struct ced_data *ced, bool Read, unsigned short wIdent, unsigned int dwOffs, unsigned int dwLen) { /* Transfer area info */ - struct transarea *pArea = &pdx->rTransDef[wIdent]; + struct transarea *pArea = &ced->rTransDef[wIdent]; - if (!can_accept_io_requests(pdx)) { /* Are we in a state to accept new requests? */ - dev_err(&pdx->interface->dev, "%s: can't accept requests\n", + if (!can_accept_io_requests(ced)) { /* Are we in a state to accept new requests? */ + dev_err(&ced->interface->dev, "%s: can't accept requests\n", __func__); return U14ERR_FAIL; } - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: xfer %d bytes to %s, offset %d, area %d\n", __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, + if (ced->bStagedUrbPending) { + ced->bXFerWaiting = true; /* Flag we are waiting */ + dev_info(&ced->interface->dev, "%s: xfer is waiting, as previous staged pending\n", __func__); return U14ERR_NOERROR; } if (dwLen == 0) { /* allow 0-len read or write; just return success */ - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: OK; zero-len read/write request\n", __func__); return U14ERR_NOERROR; } @@ -797,7 +797,7 @@ int ced_read_write_mem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent, /* If so, we sort out offset ourself */ bool bWait = false; /* Flag for transfer having to wait */ - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "Circular buffers are %d at %d and %d at %d\n", pArea->aBlocks[0].dwSize, pArea->aBlocks[0].dwOffset, pArea->aBlocks[1].dwSize, pArea->aBlocks[1].dwOffset); @@ -820,28 +820,28 @@ int ced_read_write_mem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent, } if (bWait) { /* This transfer will have to wait? */ - pdx->bXFerWaiting = true; /* Flag we are waiting */ - dev_dbg(&pdx->interface->dev, + ced->bXFerWaiting = true; /* Flag we are waiting */ + dev_dbg(&ced->interface->dev, "%s: xfer waiting for circular buffer space\n", __func__); return U14ERR_NOERROR; } - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: circular xfer, %d bytes starting at %d\n", __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 */ + ced->StagedRead = Read; /* Save the parameters for this read */ + ced->StagedId = wIdent; /* ID allows us to get transfer area info */ + ced->StagedOffset = dwOffs; /* The area within the transfer area */ + ced->StagedLength = dwLen; + ced->StagedDone = 0; /* Initialise the byte count */ + ced->dwDMAFlag = MODE_LINEAR; /* Set DMA mode flag at this point */ + ced->bXFerWaiting = false; /* Clearly not a transfer waiting now */ -/* KeClearEvent(&pdx->StagingDoneEvent); // Clear the transfer done event */ - ced_stage_chunk(pdx); /* fire off the first chunk */ +/* KeClearEvent(&ced->StagingDoneEvent); // Clear the transfer done event */ + ced_stage_chunk(ced); /* fire off the first chunk */ return U14ERR_NOERROR; } @@ -945,14 +945,14 @@ static bool ced_read_huff(volatile unsigned int *pDWord, char *pBuf, ** *****************************************************************************/ static bool ced_read_dma_info(volatile struct dmadesc *pDmaDesc, - DEVICE_EXTENSION *pdx, + struct ced_data *ced, 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\n", __func__); + dev_dbg(&ced->interface->dev, "%s\n", __func__); if (ced_read_char(&ucData, pBuf, &dDone, dwCount)) { unsigned char ucTransCode = (ucData & 0x0F); /* get code for transfer type */ @@ -964,7 +964,7 @@ static bool ced_read_dma_info(volatile struct dmadesc *pDmaDesc, pDmaDesc->dwSize = 0; /* initialise other bits */ pDmaDesc->dwOffset = 0; - dev_dbg(&pdx->interface->dev, "%s: type: %d ident: %d\n", + dev_dbg(&ced->interface->dev, "%s: type: %d ident: %d\n", __func__, pDmaDesc->wTransType, pDmaDesc->wIdent); pDmaDesc->bOutWard = (ucTransCode != TM_EXTTOHOST); /* set transfer direction */ @@ -979,27 +979,27 @@ static bool ced_read_dma_info(volatile struct dmadesc *pDmaDesc, && ced_read_huff(&(pDmaDesc->dwSize), pBuf, &dDone, dwCount); if (bResult) { - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: xfer offset & size %d %d\n", __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 */ + (!ced->rTransDef[wIdent].bUsed) || /* area not set up, or... */ + (pDmaDesc->dwOffset > ced->rTransDef[wIdent].dwLength) || /* range/size */ ((pDmaDesc->dwOffset + pDmaDesc->dwSize) > - (pdx->rTransDef[wIdent]. + (ced->rTransDef[wIdent]. dwLength))) { bResult = false; /* bad parameter(s) */ - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: bad param - id %d, bUsed %d, offset %d, size %d, area length %d\n", __func__, wIdent, - pdx->rTransDef[wIdent]. + ced->rTransDef[wIdent]. bUsed, pDmaDesc->dwOffset, pDmaDesc->dwSize, - pdx->rTransDef[wIdent]. + ced->rTransDef[wIdent]. dwLength); } } @@ -1012,7 +1012,7 @@ static bool ced_read_dma_info(volatile struct dmadesc *pDmaDesc, bResult = false; if (!bResult) /* now check parameters for validity */ - dev_err(&pdx->interface->dev, "%s: error reading Esc sequence\n", + dev_err(&ced->interface->dev, "%s: error reading Esc sequence\n", __func__); return bResult; @@ -1032,7 +1032,7 @@ static bool ced_read_dma_info(volatile struct dmadesc *pDmaDesc, ** this is known to be at least 2 or we will not be called. ** ****************************************************************************/ -static int ced_handle_esc(DEVICE_EXTENSION *pdx, char *pCh, +static int ced_handle_esc(struct ced_data *ced, char *pCh, unsigned int dwCount) { int iReturn = U14ERR_FAIL; @@ -1043,48 +1043,48 @@ static int ced_handle_esc(DEVICE_EXTENSION *pdx, char *pCh, if (pCh[0] == '?') { /* Is this an information response */ /* Parse and save the information */ } else { - spin_lock(&pdx->stagedLock); /* Lock others out */ + spin_lock(&ced->stagedLock); /* Lock others out */ - if (ced_read_dma_info(&pdx->rDMAInfo, pdx, pCh, dwCount)) { /* Get DMA parameters */ - unsigned short wTransType = pdx->rDMAInfo.wTransType; /* check transfer type */ + if (ced_read_dma_info(&ced->rDMAInfo, ced, pCh, dwCount)) { /* Get DMA parameters */ + unsigned short wTransType = ced->rDMAInfo.wTransType; /* check transfer type */ - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: xfer to %s, offset %d, length %d\n", __func__, - pdx->rDMAInfo.bOutWard ? "1401" : "host", - pdx->rDMAInfo.dwOffset, pdx->rDMAInfo.dwSize); + ced->rDMAInfo.bOutWard ? "1401" : "host", + ced->rDMAInfo.dwOffset, ced->rDMAInfo.dwSize); - if (pdx->bXFerWaiting) { /* Check here for badly out of kilter... */ + if (ced->bXFerWaiting) { /* Check here for badly out of kilter... */ /* This can never happen, really */ - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "ERROR: DMA setup while transfer still waiting\n"); } else { if ((wTransType == TM_EXTTOHOST) || (wTransType == TM_EXTTO1401)) { iReturn = - ced_read_write_mem(pdx, - !pdx->rDMAInfo. + ced_read_write_mem(ced, + !ced->rDMAInfo. bOutWard, - pdx->rDMAInfo.wIdent, - pdx->rDMAInfo.dwOffset, - pdx->rDMAInfo.dwSize); + ced->rDMAInfo.wIdent, + ced->rDMAInfo.dwOffset, + ced->rDMAInfo.dwSize); if (iReturn != U14ERR_NOERROR) - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "%s: ced_read_write_mem() failed %d\n", __func__, iReturn); } else /* This covers non-linear transfer setup */ - dev_err(&pdx->interface->dev, + dev_err(&ced->interface->dev, "%s: Unknown block xfer type %d\n", __func__, wTransType); } } else /* Failed to read parameters */ - dev_err(&pdx->interface->dev, "%s: ced_read_dma_info() fail\n", + dev_err(&ced->interface->dev, "%s: ced_read_dma_info() fail\n", __func__); - spin_unlock(&pdx->stagedLock); /* OK here */ + spin_unlock(&ced->stagedLock); /* OK here */ } - dev_dbg(&pdx->interface->dev, "%s: returns %d\n", __func__, iReturn); + dev_dbg(&ced->interface->dev, "%s: returns %d\n", __func__, iReturn); return iReturn; } @@ -1094,65 +1094,65 @@ static int ced_handle_esc(DEVICE_EXTENSION *pdx, char *pCh, ****************************************************************************/ static void ced_readchar_callback(struct urb *pUrb) { - DEVICE_EXTENSION *pdx = pUrb->context; + struct ced_data *ced = 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 */ + int nPipe = ced->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, + dev_err(&ced->interface->dev, "%s: nonzero write bulk status received: %d\n", __func__, pUrb->status); } else - dev_dbg(&pdx->interface->dev, + dev_dbg(&ced->interface->dev, "%s: 0 chars pUrb->status=%d (shutdown?)\n", __func__, pUrb->status); - spin_lock(&pdx->err_lock); - pdx->errors = pUrb->status; - spin_unlock(&pdx->err_lock); + spin_lock(&ced->err_lock); + ced->errors = pUrb->status; + spin_unlock(&ced->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 */ + spin_lock(&ced->charInLock); /* already at irq level */ + ced->bPipeError[nPipe] = 1; /* Flag an error for later */ } else { - if ((nGot > 1) && ((pdx->pCoherCharIn[0] & 0x7f) == 0x1b)) { /* Esc sequence? */ - ced_handle_esc(pdx, &pdx->pCoherCharIn[1], nGot - 1); /* handle it */ - spin_lock(&pdx->charInLock); /* already at irq level */ + if ((nGot > 1) && ((ced->pCoherCharIn[0] & 0x7f) == 0x1b)) { /* Esc sequence? */ + ced_handle_esc(ced, &ced->pCoherCharIn[1], nGot - 1); /* handle it */ + spin_lock(&ced->charInLock); /* already at irq level */ } else { - spin_lock(&pdx->charInLock); /* already at irq level */ + spin_lock(&ced->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, + ced->pCoherCharIn[nGot] = 0; /* tidy the string */ + dev_dbg(&ced->interface->dev, "%s: got %d chars >%s<\n", __func__, nGot, - pdx->pCoherCharIn); + ced->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; + ced->inputBuffer[ced->dwInBuffPut++] = + ced->pCoherCharIn[i] & 0x7F; + if (ced->dwInBuffPut >= INBUF_SZ) + ced->dwInBuffPut = 0; } - if ((pdx->dwNumInput + nGot) <= INBUF_SZ) - pdx->dwNumInput += nGot; /* Adjust the buffer count accordingly */ + if ((ced->dwNumInput + nGot) <= INBUF_SZ) + ced->dwNumInput += nGot; /* Adjust the buffer count accordingly */ } else - dev_dbg(&pdx->interface->dev, "%s: read ZLP\n", + dev_dbg(&ced->interface->dev, "%s: read ZLP\n", __func__); } } - pdx->bReadCharsPending = false; /* No longer have a pending read */ - spin_unlock(&pdx->charInLock); /* already at irq level */ + ced->bReadCharsPending = false; /* No longer have a pending read */ + spin_unlock(&ced->charInLock); /* already at irq level */ - ced_allowi(pdx); /* see if we can do the next one */ + ced_allowi(ced); /* see if we can do the next one */ } /**************************************************************************** @@ -1162,47 +1162,47 @@ 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 ced_allowi(DEVICE_EXTENSION *pdx) +int ced_allowi(struct ced_data *ced) { int iReturn = U14ERR_NOERROR; unsigned long flags; - spin_lock_irqsave(&pdx->charInLock, flags); /* can be called in multiple contexts */ + spin_lock_irqsave(&ced->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 */ - (can_accept_io_requests(pdx))) { /* and activity is generally OK */ + if (!ced->bInDrawDown && /* stop input if */ + !ced->bReadCharsPending && /* If no read request outstanding */ + (ced->dwNumInput < (INBUF_SZ / 2)) && /* and there is some space */ + (ced->dwDMAFlag == MODE_CHAR) && /* not doing any DMA */ + (!ced->bXFerWaiting) && /* no xfer waiting to start */ + (can_accept_io_requests(ced))) { /* 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\n", - __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, GFP_ATOMIC); + unsigned int nMax = INBUF_SZ - ced->dwNumInput; /* max we could read */ + int nPipe = ced->nPipes == 4 ? 1 : 0; /* The pipe number to use */ + + dev_dbg(&ced->interface->dev, "%s: %d chars in input buffer\n", + __func__, ced->dwNumInput); + + usb_fill_int_urb(ced->pUrbCharIn, ced->udev, + usb_rcvintpipe(ced->udev, ced->epAddr[nPipe]), + ced->pCoherCharIn, nMax, ced_readchar_callback, + ced, ced->bInterval); + ced->pUrbCharIn->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; /* short xfers are OK by default */ + usb_anchor_urb(ced->pUrbCharIn, &ced->submitted); /* in case we need to kill it */ + iReturn = usb_submit_urb(ced->pUrbCharIn, GFP_ATOMIC); if (iReturn) { - usb_unanchor_urb(pdx->pUrbCharIn); /* remove from list of active Urbs */ - pdx->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ - dev_err(&pdx->interface->dev, + usb_unanchor_urb(ced->pUrbCharIn); /* remove from list of active Urbs */ + ced->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ + dev_err(&ced->interface->dev, "%s: submit urb failed: %d\n", __func__, iReturn); } else - pdx->bReadCharsPending = true; /* Flag that we are active here */ + ced->bReadCharsPending = true; /* Flag that we are active here */ } - spin_unlock_irqrestore(&pdx->charInLock, flags); + spin_unlock_irqrestore(&ced->charInLock, flags); return iReturn; @@ -1211,15 +1211,15 @@ int ced_allowi(DEVICE_EXTENSION *pdx) /***************************************************************************** ** The ioctl entry point to the driver that is used by us to talk to it. ** inode The device node (no longer in 3.0.0 kernels) -** file The file that is open, which holds our pdx pointer +** file The file that is open, which holds our ced pointer ** ulArg The argument passed in. Note that long is 64-bits in 64-bit system, i.e. it is big ** enough for a 64-bit pointer. *****************************************************************************/ static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long ulArg) { int err = 0; - DEVICE_EXTENSION *pdx = file->private_data; - if (!can_accept_io_requests(pdx)) /* check we still exist */ + struct ced_data *ced = file->private_data; + if (!can_accept_io_requests(ced)) /* check we still exist */ return -ENODEV; /* Check that access is allowed, where is is needed. Anything that would have an indeterminate */ @@ -1233,38 +1233,38 @@ static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long ulArg) switch (_IOC_NR(cmd)) { case _IOC_NR(IOCTL_CED_SENDSTRING(0)): - return ced_send_string(pdx, (const char __user *)ulArg, + return ced_send_string(ced, (const char __user *)ulArg, _IOC_SIZE(cmd)); case _IOC_NR(IOCTL_CED_RESET1401): - return ced_reset(pdx); + return ced_reset(ced); case _IOC_NR(IOCTL_CED_GETCHAR): - return ced_get_char(pdx); + return ced_get_char(ced); case _IOC_NR(IOCTL_CED_SENDCHAR): - return ced_send_char(pdx, (char)ulArg); + return ced_send_char(ced, (char)ulArg); case _IOC_NR(IOCTL_CED_STAT1401): - return ced_stat_1401(pdx); + return ced_stat_1401(ced); case _IOC_NR(IOCTL_CED_LINECOUNT): - return ced_line_count(pdx); + return ced_line_count(ced); case _IOC_NR(IOCTL_CED_GETSTRING(0)): - return ced_get_string(pdx, (char __user *)ulArg, _IOC_SIZE(cmd)); + return ced_get_string(ced, (char __user *)ulArg, _IOC_SIZE(cmd)); case _IOC_NR(IOCTL_CED_SETTRANSFER): - return ced_set_transfer(pdx, (struct transfer_area_desc __user *) ulArg); + return ced_set_transfer(ced, (struct transfer_area_desc __user *) ulArg); case _IOC_NR(IOCTL_CED_UNSETTRANSFER): - return ced_unset_transfer(pdx, (int)ulArg); + return ced_unset_transfer(ced, (int)ulArg); case _IOC_NR(IOCTL_CED_SETEVENT): - return ced_set_event(pdx, (struct transfer_event __user *) ulArg); + return ced_set_event(ced, (struct transfer_event __user *) ulArg); case _IOC_NR(IOCTL_CED_GETOUTBUFSPACE): - return ced_get_out_buf_space(pdx); + return ced_get_out_buf_space(ced); case _IOC_NR(IOCTL_CED_GETBASEADDRESS): return -1; @@ -1273,66 +1273,66 @@ static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long ulArg) return (2 << 24) | (DRIVERMAJREV << 16) | DRIVERMINREV; /* USB | MAJOR | MINOR */ case _IOC_NR(IOCTL_CED_GETTRANSFER): - return ced_get_transfer(pdx, (TGET_TX_BLOCK __user *) ulArg); + return ced_get_transfer(ced, (TGET_TX_BLOCK __user *) ulArg); case _IOC_NR(IOCTL_CED_KILLIO1401): - return ced_kill_io(pdx); + return ced_kill_io(ced); case _IOC_NR(IOCTL_CED_STATEOF1401): - return ced_state_of_1401(pdx); + return ced_state_of_1401(ced); case _IOC_NR(IOCTL_CED_GRAB1401): case _IOC_NR(IOCTL_CED_FREE1401): return U14ERR_NOERROR; case _IOC_NR(IOCTL_CED_STARTSELFTEST): - return ced_start_self_test(pdx); + return ced_start_self_test(ced); case _IOC_NR(IOCTL_CED_CHECKSELFTEST): - return ced_check_self_test(pdx, (TGET_SELFTEST __user *) ulArg); + return ced_check_self_test(ced, (TGET_SELFTEST __user *) ulArg); case _IOC_NR(IOCTL_CED_TYPEOF1401): - return ced_type_of_1401(pdx); + return ced_type_of_1401(ced); case _IOC_NR(IOCTL_CED_TRANSFERFLAGS): - return ced_transfer_flags(pdx); + return ced_transfer_flags(ced); case _IOC_NR(IOCTL_CED_DBGPEEK): - return ced_dbg_peek(pdx, (TDBGBLOCK __user *) ulArg); + return ced_dbg_peek(ced, (TDBGBLOCK __user *) ulArg); case _IOC_NR(IOCTL_CED_DBGPOKE): - return ced_dbg_poke(pdx, (TDBGBLOCK __user *) ulArg); + return ced_dbg_poke(ced, (TDBGBLOCK __user *) ulArg); case _IOC_NR(IOCTL_CED_DBGRAMPDATA): - return ced_dbg_ramp_data(pdx, (TDBGBLOCK __user *) ulArg); + return ced_dbg_ramp_data(ced, (TDBGBLOCK __user *) ulArg); case _IOC_NR(IOCTL_CED_DBGRAMPADDR): - return ced_dbg_ramp_addr(pdx, (TDBGBLOCK __user *) ulArg); + return ced_dbg_ramp_addr(ced, (TDBGBLOCK __user *) ulArg); case _IOC_NR(IOCTL_CED_DBGGETDATA): - return ced_dbg_get_data(pdx, (TDBGBLOCK __user *) ulArg); + return ced_dbg_get_data(ced, (TDBGBLOCK __user *) ulArg); case _IOC_NR(IOCTL_CED_DBGSTOPLOOP): - return ced_dbg_stop_loop(pdx); + return ced_dbg_stop_loop(ced); case _IOC_NR(IOCTL_CED_FULLRESET): - pdx->bForceReset = true; /* Set a flag for a full reset */ + ced->bForceReset = true; /* Set a flag for a full reset */ break; case _IOC_NR(IOCTL_CED_SETCIRCULAR): - return ced_set_circular(pdx, (struct transfer_area_desc __user *) ulArg); + return ced_set_circular(ced, (struct transfer_area_desc __user *) ulArg); case _IOC_NR(IOCTL_CED_GETCIRCBLOCK): - return ced_get_circ_block(pdx, (TCIRCBLOCK __user *) ulArg); + return ced_get_circ_block(ced, (TCIRCBLOCK __user *) ulArg); case _IOC_NR(IOCTL_CED_FREECIRCBLOCK): - return ced_free_circ_block(pdx, (TCIRCBLOCK __user *) ulArg); + return ced_free_circ_block(ced, (TCIRCBLOCK __user *) ulArg); case _IOC_NR(IOCTL_CED_WAITEVENT): - return ced_wait_event(pdx, (int)(ulArg & 0xff), (int)(ulArg >> 8)); + return ced_wait_event(ced, (int)(ulArg & 0xff), (int)(ulArg >> 8)); case _IOC_NR(IOCTL_CED_TESTEVENT): - return ced_test_event(pdx, (int)ulArg); + return ced_test_event(ced, (int)ulArg); default: return U14ERR_NO_SUCH_FN; @@ -1360,47 +1360,47 @@ static struct usb_class_driver ced_class = { }; /* Check that the device that matches a 1401 vendor and product ID is OK to use and */ -/* initialise our DEVICE_EXTENSION. */ +/* initialise our struct ced_data. */ static int ced_probe(struct usb_interface *interface, const struct usb_device_id *id) { - DEVICE_EXTENSION *pdx; + struct ced_data *ced; 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) + ced = kzalloc(sizeof(*ced), GFP_KERNEL); + if (!ced) goto error; for (i = 0; i < MAX_TRANSAREAS; ++i) { /* Initialise the wait queues */ - init_waitqueue_head(&pdx->rTransDef[i].wqEvent); + init_waitqueue_head(&ced->rTransDef[i].wqEvent); } - /* Put initialises for our stuff here. Note that all of *pdx is zero, so */ + /* Put initialises for our stuff here. Note that all of *ced is zero, so */ /* no need to explicitly zero it. */ - spin_lock_init(&pdx->charOutLock); - spin_lock_init(&pdx->charInLock); - spin_lock_init(&pdx->stagedLock); + spin_lock_init(&ced->charOutLock); + spin_lock_init(&ced->charInLock); + spin_lock_init(&ced->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); + kref_init(&ced->kref); + mutex_init(&ced->io_mutex); + spin_lock_init(&ced->err_lock); + init_usb_anchor(&ced->submitted); - pdx->udev = usb_get_dev(interface_to_usbdev(interface)); - pdx->interface = interface; + ced->udev = usb_get_dev(interface_to_usbdev(interface)); + ced->interface = interface; /* Attempt to identify the device */ - bcdDevice = pdx->udev->descriptor.bcdDevice; + bcdDevice = ced->udev->descriptor.bcdDevice; i = (bcdDevice >> 8); if (i == 0) - pdx->s1401Type = TYPEU1401; + ced->s1401Type = TYPEU1401; else if ((i >= 1) && (i <= 23)) - pdx->s1401Type = i + 2; + ced->s1401Type = i + 2; else { dev_err(&interface->dev, "%s: Unknown device. bcdDevice = %d\n", __func__, bcdDevice); @@ -1409,58 +1409,58 @@ static int ced_probe(struct usb_interface *interface, /* 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; + ced->nPipes = iface_desc->desc.bNumEndpoints; dev_info(&interface->dev, "1401Type=%d with %d End Points\n", - pdx->s1401Type, pdx->nPipes); - if ((pdx->nPipes < 3) || (pdx->nPipes > 4)) + ced->s1401Type, ced->nPipes); + if ((ced->nPipes < 3) || (ced->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) { + ced->pUrbCharOut = usb_alloc_urb(0, GFP_KERNEL); /* character output URB */ + ced->pUrbCharIn = usb_alloc_urb(0, GFP_KERNEL); /* character input URB */ + ced->pStagedUrb = usb_alloc_urb(0, GFP_KERNEL); /* block transfer URB */ + if (!ced->pUrbCharOut || !ced->pUrbCharIn || !ced->pStagedUrb) { dev_err(&interface->dev, "%s: URB alloc failed\n", __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) { + ced->pCoherStagedIO = + usb_alloc_coherent(ced->udev, STAGED_SZ, GFP_KERNEL, + &ced->pStagedUrb->transfer_dma); + ced->pCoherCharOut = + usb_alloc_coherent(ced->udev, OUTBUF_SZ, GFP_KERNEL, + &ced->pUrbCharOut->transfer_dma); + ced->pCoherCharIn = + usb_alloc_coherent(ced->udev, INBUF_SZ, GFP_KERNEL, + &ced->pUrbCharIn->transfer_dma); + if (!ced->pCoherCharOut || !ced->pCoherCharIn || !ced->pCoherStagedIO) { dev_err(&interface->dev, "%s: Coherent buffer alloc failed\n", __func__); goto error; } - for (i = 0; i < pdx->nPipes; ++i) { + for (i = 0; i < ced->nPipes; ++i) { endpoint = &iface_desc->endpoint[i].desc; - pdx->epAddr[i] = endpoint->bEndpointAddress; + ced->epAddr[i] = endpoint->bEndpointAddress; dev_info(&interface->dev, "Pipe %d, ep address %02x\n", - 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 */ + i, ced->epAddr[i]); + if (((ced->nPipes == 3) && (i == 0)) || /* if char input end point */ + ((ced->nPipes == 4) && (i == 1))) { + ced->bInterval = endpoint->bInterval; /* save the endpoint interrupt interval */ dev_info(&interface->dev, "Pipe %d, bInterval = %d\n", - i, pdx->bInterval); + i, ced->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 = + if (i == ced->nPipes - 1) { /* if this is the last ep (bulk) */ + ced->bIsUSB2 = le16_to_cpu(endpoint->wMaxPacketSize) > 64; - dev_info(&pdx->interface->dev, "USB%d\n", - pdx->bIsUSB2 + 1); + dev_info(&ced->interface->dev, "USB%d\n", + ced->bIsUSB2 + 1); } } /* save our data pointer in this interface device */ - usb_set_intfdata(interface, pdx); + usb_set_intfdata(interface, ced); /* we can register the device now, as it is ready */ retval = usb_register_dev(interface, &ced_class); @@ -1479,34 +1479,34 @@ static int ced_probe(struct usb_interface *interface, return 0; error: - if (pdx) - kref_put(&pdx->kref, ced_delete); /* frees allocated memory */ + if (ced) + kref_put(&ced->kref, ced_delete); /* frees allocated memory */ return retval; } static void ced_disconnect(struct usb_interface *interface) { - DEVICE_EXTENSION *pdx = usb_get_intfdata(interface); + struct ced_data *ced = usb_get_intfdata(interface); int minor = interface->minor; int i; - usb_set_intfdata(interface, NULL); /* remove the pdx from the interface */ + usb_set_intfdata(interface, NULL); /* remove the ced from the interface */ usb_deregister_dev(interface, &ced_class); /* give back our minor device number */ - mutex_lock(&pdx->io_mutex); /* stop more I/O starting while... */ - ced_draw_down(pdx); /* ...wait for then kill any io */ + mutex_lock(&ced->io_mutex); /* stop more I/O starting while... */ + ced_draw_down(ced); /* ...wait for then kill any io */ for (i = 0; i < MAX_TRANSAREAS; ++i) { - int iErr = ced_clear_area(pdx, i); /* ...release any used memory */ + int iErr = ced_clear_area(ced, i); /* ...release any used memory */ if (iErr == U14ERR_UNLOCKFAIL) - dev_err(&pdx->interface->dev, "%s: Area %d was in used\n", + dev_err(&ced->interface->dev, "%s: Area %d was in used\n", __func__, i); } - pdx->interface = NULL; /* ...we kill off link to interface */ - mutex_unlock(&pdx->io_mutex); + ced->interface = NULL; /* ...we kill off link to interface */ + mutex_unlock(&ced->io_mutex); - usb_kill_anchored_urbs(&pdx->submitted); + usb_kill_anchored_urbs(&ced->submitted); - kref_put(&pdx->kref, ced_delete); /* decrement our usage count */ + kref_put(&ced->kref, ced_delete); /* decrement our usage count */ dev_info(&interface->dev, "USB cedusb #%d now disconnected\n", minor); } @@ -1515,57 +1515,57 @@ static void ced_disconnect(struct usb_interface *interface) /* 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(struct ced_data *ced) { int time; - dev_dbg(&pdx->interface->dev, "%s: called\n", __func__); + dev_dbg(&ced->interface->dev, "%s: called\n", __func__); - pdx->bInDrawDown = true; - time = usb_wait_anchor_empty_timeout(&pdx->submitted, 3000); + ced->bInDrawDown = true; + time = usb_wait_anchor_empty_timeout(&ced->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\n", __func__); + usb_kill_anchored_urbs(&ced->submitted); + dev_err(&ced->interface->dev, "%s: timed out\n", __func__); } - pdx->bInDrawDown = false; + ced->bInDrawDown = false; } static int ced_suspend(struct usb_interface *intf, pm_message_t message) { - DEVICE_EXTENSION *pdx = usb_get_intfdata(intf); - if (!pdx) + struct ced_data *ced = usb_get_intfdata(intf); + if (!ced) return 0; - ced_draw_down(pdx); + ced_draw_down(ced); - dev_dbg(&pdx->interface->dev, "%s: called\n", __func__); + dev_dbg(&ced->interface->dev, "%s: called\n", __func__); return 0; } static int ced_resume(struct usb_interface *intf) { - DEVICE_EXTENSION *pdx = usb_get_intfdata(intf); - if (!pdx) + struct ced_data *ced = usb_get_intfdata(intf); + if (!ced) return 0; - dev_dbg(&pdx->interface->dev, "%s: called\n", __func__); + dev_dbg(&ced->interface->dev, "%s: called\n", __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\n", __func__); - mutex_lock(&pdx->io_mutex); - ced_draw_down(pdx); + struct ced_data *ced = usb_get_intfdata(intf); + dev_dbg(&ced->interface->dev, "%s\n", __func__); + mutex_lock(&ced->io_mutex); + ced_draw_down(ced); return 0; } static int ced_post_reset(struct usb_interface *intf) { - DEVICE_EXTENSION *pdx = usb_get_intfdata(intf); - dev_dbg(&pdx->interface->dev, "%s\n", __func__); + struct ced_data *ced = usb_get_intfdata(intf); + dev_dbg(&ced->interface->dev, "%s\n", __func__); /* we are sure no URBs are active - no locking needed */ - pdx->errors = -EPIPE; - mutex_unlock(&pdx->io_mutex); + ced->errors = -EPIPE; + mutex_unlock(&ced->io_mutex); return 0; } diff --git a/drivers/staging/ced1401/usb1401.h b/drivers/staging/ced1401/usb1401.h index d269d83c3fc3..c4b562fa6e09 100644 --- a/drivers/staging/ced1401/usb1401.h +++ b/drivers/staging/ced1401/usb1401.h @@ -134,7 +134,7 @@ struct dmadesc { /* Structure to hold all of our device specific stuff. We are making this as similar as we */ /* can to the Windows driver to help in our understanding of what is going on. */ -typedef struct _DEVICE_EXTENSION { +struct ced_data { char inputBuffer[INBUF_SZ]; /* The two buffers */ char outputBuffer[OUTBUF_SZ]; /* accessed by the host functions */ volatile unsigned int dwNumInput; /* num of chars in input buffer */ @@ -197,48 +197,49 @@ typedef struct _DEVICE_EXTENSION { int open_count; /* count the number of openers */ spinlock_t err_lock; /* lock for errors */ struct kref kref; -} DEVICE_EXTENSION, *PDEVICE_EXTENSION; -#define to_DEVICE_EXTENSION(d) container_of(d, DEVICE_EXTENSION, kref) +}; + +#define to_ced_data(d) container_of(d, struct ced_data, kref) /* Definitions of routimes used between compilation object files */ /* in usb1401.c */ -extern int ced_allowi(DEVICE_EXTENSION *pdx); -extern int ced_send_chars(DEVICE_EXTENSION *pdx); -extern void ced_draw_down(DEVICE_EXTENSION *pdx); -extern int ced_read_write_mem(DEVICE_EXTENSION *pdx, bool Read, unsigned short wIdent, +extern int ced_allowi(struct ced_data * ced); +extern int ced_send_chars(struct ced_data *ced); +extern void ced_draw_down(struct ced_data *ced); +extern int ced_read_write_mem(struct ced_data *ced, bool Read, unsigned short wIdent, unsigned int dwOffs, unsigned int dwLen); /* in ced_ioc.c */ -extern int ced_clear_area(DEVICE_EXTENSION *pdx, int nArea); -extern int ced_send_string(DEVICE_EXTENSION *pdx, const char __user *pData, unsigned int n); -extern int ced_send_char(DEVICE_EXTENSION *pdx, char c); -extern int ced_get_state(DEVICE_EXTENSION *pdx, __u32 *state, __u32 *error); -extern int ced_read_write_cancel(DEVICE_EXTENSION *pdx); -extern int ced_reset(DEVICE_EXTENSION *pdx); -extern int ced_get_char(DEVICE_EXTENSION *pdx); -extern int ced_get_string(DEVICE_EXTENSION *pdx, char __user *pUser, int n); -extern int ced_set_transfer(DEVICE_EXTENSION *pdx, struct transfer_area_desc __user *pTD); -extern int ced_unset_transfer(DEVICE_EXTENSION *pdx, int nArea); -extern int ced_set_event(DEVICE_EXTENSION *pdx, struct transfer_event __user *pTE); -extern int ced_stat_1401(DEVICE_EXTENSION *pdx); -extern int ced_line_count(DEVICE_EXTENSION *pdx); -extern int ced_get_out_buf_space(DEVICE_EXTENSION *pdx); -extern int ced_get_transfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user *pGTB); -extern int ced_kill_io(DEVICE_EXTENSION *pdx); -extern int ced_state_of_1401(DEVICE_EXTENSION *pdx); -extern int ced_start_self_test(DEVICE_EXTENSION *pdx); -extern int ced_check_self_test(DEVICE_EXTENSION *pdx, TGET_SELFTEST __user *pGST); -extern int ced_type_of_1401(DEVICE_EXTENSION *pdx); -extern int ced_transfer_flags(DEVICE_EXTENSION *pdx); -extern int ced_dbg_peek(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB); -extern int ced_dbg_poke(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB); -extern int ced_dbg_ramp_data(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB); -extern int ced_dbg_ramp_addr(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB); -extern int ced_dbg_get_data(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB); -extern int ced_dbg_stop_loop(DEVICE_EXTENSION *pdx); -extern int ced_set_circular(DEVICE_EXTENSION *pdx, struct transfer_area_desc __user *pTD); -extern int ced_get_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB); -extern int ced_free_circ_block(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB); -extern int ced_wait_event(DEVICE_EXTENSION *pdx, int nArea, int msTimeOut); -extern int ced_test_event(DEVICE_EXTENSION *pdx, int nArea); +extern int ced_clear_area(struct ced_data *ced, int nArea); +extern int ced_send_string(struct ced_data *ced, const char __user *pData, unsigned int n); +extern int ced_send_char(struct ced_data *ced, char c); +extern int ced_get_state(struct ced_data *ced, __u32 *state, __u32 *error); +extern int ced_read_write_cancel(struct ced_data *ced); +extern int ced_reset(struct ced_data *ced); +extern int ced_get_char(struct ced_data *ced); +extern int ced_get_string(struct ced_data *ced, char __user *pUser, int n); +extern int ced_set_transfer(struct ced_data *ced, struct transfer_area_desc __user *pTD); +extern int ced_unset_transfer(struct ced_data *ced, int nArea); +extern int ced_set_event(struct ced_data *ced, struct transfer_event __user *pTE); +extern int ced_stat_1401(struct ced_data *ced); +extern int ced_line_count(struct ced_data *ced); +extern int ced_get_out_buf_space(struct ced_data *ced); +extern int ced_get_transfer(struct ced_data *ced, TGET_TX_BLOCK __user *pGTB); +extern int ced_kill_io(struct ced_data *ced); +extern int ced_state_of_1401(struct ced_data *ced); +extern int ced_start_self_test(struct ced_data *ced); +extern int ced_check_self_test(struct ced_data *ced, TGET_SELFTEST __user *pGST); +extern int ced_type_of_1401(struct ced_data *ced); +extern int ced_transfer_flags(struct ced_data *ced); +extern int ced_dbg_peek(struct ced_data *ced, TDBGBLOCK __user *pDB); +extern int ced_dbg_poke(struct ced_data *ced, TDBGBLOCK __user *pDB); +extern int ced_dbg_ramp_data(struct ced_data *ced, TDBGBLOCK __user *pDB); +extern int ced_dbg_ramp_addr(struct ced_data *ced, TDBGBLOCK __user *pDB); +extern int ced_dbg_get_data(struct ced_data *ced, TDBGBLOCK __user *pDB); +extern int ced_dbg_stop_loop(struct ced_data *ced); +extern int ced_set_circular(struct ced_data *ced, struct transfer_area_desc __user *pTD); +extern int ced_get_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB); +extern int ced_free_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB); +extern int ced_wait_event(struct ced_data *ced, int nArea, int msTimeOut); +extern int ced_test_event(struct ced_data *ced, int nArea); #endif -- 2.39.5