**
** 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);
}
/****************************************************************************
**
** 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);
}
/****************************************************************************
** 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;
}
** 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 */
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;
}
**
** 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;
}
**
** 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;
}
/****************************************************************************
**
** 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;
}
("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;
** 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 */
**
** 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 */
}
}
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;
}
**
** 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;
**
** 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;
}
**
** 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;
}
** 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 */
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);
++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;
}
/*******************************************************************************
** 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;
}
** 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 */
} 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;
}
**
** 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;
}
** 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 {
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 {
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. */
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) {
}
kfree(pPages);
- dev_dbg(&pdx->interface->dev,
+ dev_dbg(&ced->interface->dev,
"%s: kfree(pPages) done\n", __func__);
}
}
** 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 */
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 */
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 */
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;
** 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;
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;
}
** 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;
}
** 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;
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) */
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;
** 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 =
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;
}
** 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;
}
** 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 {
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;
}
**
** 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;
}
**
** 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;
}
** 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;
}
**
** 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 */
}
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 */
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;
**
** 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 */
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;
}
**
** 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;
}
** 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;
**
** 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;
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;
}
** 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;
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;
}
** 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;
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;
}
**
** 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;
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;
}
**
** 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)) {
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;
}
** 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;
}
** 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;
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 */
/* 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;
}
**
** 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) */
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;
}
**
** 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;
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 */
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? */
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,
/* 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;
}
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
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 =
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;
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;
}
/***************************************************************************
** 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 */
}
/****************************************************************************
****************************************************************************/
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 */
}
}
** 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;
}
** 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;
}
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
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
**
*/
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,
} 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,
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,
}
} 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);
}
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. */
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 */
}
}
- 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__);
}
/****************************************************************************
** 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;
}
** 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;
}
/* 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);
}
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;
}
**
*****************************************************************************/
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 */
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 */
&& 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);
}
}
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;
** 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;
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;
}
****************************************************************************/
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 */
}
/****************************************************************************
** 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;
/*****************************************************************************
** 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 */
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;
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;
};
/* 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);
/* 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);
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);
}
/* 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;
}
/* 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 */
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
projects / GitHub / moto-9609 / android_kernel_motorola_exynos9610.git / commitdiff