From 9982440a5a54eb536c7efa87aedcd594cec8f449 Mon Sep 17 00:00:00 2001 From: Luca Ellero Date: Thu, 10 Jul 2014 11:01:51 +0200 Subject: [PATCH] staging: ced1401: rename members of struct ced_data Rename members with CamelCase and Hungarian notation Signed-off-by: Luca Ellero Signed-off-by: Greg Kroah-Hartman --- drivers/staging/ced1401/ced_ioc.c | 238 +++++++-------- drivers/staging/ced1401/usb1401.c | 485 ++++++++++++++++-------------- drivers/staging/ced1401/usb1401.h | 116 +++---- 3 files changed, 432 insertions(+), 407 deletions(-) diff --git a/drivers/staging/ced1401/ced_ioc.c b/drivers/staging/ced1401/ced_ioc.c index d9ec2000669..60a671edbb0 100644 --- a/drivers/staging/ced1401/ced_ioc.c +++ b/drivers/staging/ced1401/ced_ioc.c @@ -38,17 +38,19 @@ ****************************************************************************/ static void ced_flush_out_buff(struct ced_data *ced) { - dev_dbg(&ced->interface->dev, "%s: currentState=%d\n", - __func__, ced->sCurrentState); - if (ced->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ + dev_dbg(&ced->interface->dev, "%s: current_state=%d\n", + __func__, ced->current_state); + + /* Do nothing if hardware in trouble */ + if (ced->current_state == U14ERR_TIME) return; /* Kill off any pending I/O */ /* CharSend_Cancel(ced); */ - spin_lock_irq(&ced->charOutLock); - ced->dwNumOutput = 0; - ced->dwOutBuffGet = 0; - ced->dwOutBuffPut = 0; - spin_unlock_irq(&ced->charOutLock); + spin_lock_irq(&ced->char_out_lock); + ced->num_output = 0; + ced->out_buff_get = 0; + ced->out_buff_put = 0; + spin_unlock_irq(&ced->char_out_lock); } /**************************************************************************** @@ -59,17 +61,17 @@ static void ced_flush_out_buff(struct ced_data *ced) ****************************************************************************/ static void ced_flush_in_buff(struct ced_data *ced) { - dev_dbg(&ced->interface->dev, "%s: currentState=%d\n", - __func__, ced->sCurrentState); - if (ced->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ + dev_dbg(&ced->interface->dev, "%s: current_state=%d\n", + __func__, ced->current_state); + if (ced->current_state == U14ERR_TIME) /* Do nothing if hardware in trouble */ return; /* Kill off any pending I/O */ /* CharRead_Cancel(pDevObject); */ - spin_lock_irq(&ced->charInLock); - ced->dwNumInput = 0; - ced->dwInBuffGet = 0; - ced->dwInBuffPut = 0; - spin_unlock_irq(&ced->charInLock); + spin_lock_irq(&ced->char_in_lock); + ced->num_input = 0; + ced->in_buff_get = 0; + ced->in_buff_put = 0; + spin_unlock_irq(&ced->char_in_lock); } /**************************************************************************** @@ -82,20 +84,20 @@ static int ced_put_chars(struct ced_data *ced, const char *pCh, unsigned int uCount) { int iReturn; - spin_lock_irq(&ced->charOutLock); /* get the output spin lock */ - if ((OUTBUF_SZ - ced->dwNumOutput) >= uCount) { + spin_lock_irq(&ced->char_out_lock); /* get the output spin lock */ + if ((OUTBUF_SZ - ced->num_output) >= uCount) { unsigned int u; for (u = 0; u < uCount; u++) { - ced->outputBuffer[ced->dwOutBuffPut++] = pCh[u]; - if (ced->dwOutBuffPut >= OUTBUF_SZ) - ced->dwOutBuffPut = 0; + ced->output_buffer[ced->out_buff_put++] = pCh[u]; + if (ced->out_buff_put >= OUTBUF_SZ) + ced->out_buff_put = 0; } - ced->dwNumOutput += uCount; - spin_unlock_irq(&ced->charOutLock); + ced->num_output += uCount; + spin_unlock_irq(&ced->char_out_lock); 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(&ced->charOutLock); + spin_unlock_irq(&ced->char_out_lock); } return iReturn; } @@ -179,38 +181,38 @@ int ced_get_state(struct ced_data *ced, __u32 *state, __u32 *error) *state = 0xFFFFFFFF; /* Start off with invalid state */ nGot = usb_control_msg(ced->udev, usb_rcvctrlpipe(ced->udev, 0), GET_STATUS, (D_TO_H | VENDOR | DEVREQ), 0, 0, - ced->statBuf, sizeof(ced->statBuf), HZ); - if (nGot != sizeof(ced->statBuf)) { + ced->stat_buf, sizeof(ced->stat_buf), HZ); + if (nGot != sizeof(ced->stat_buf)) { dev_err(&ced->interface->dev, "%s: FAILED, return code %d\n", __func__, nGot); - ced->sCurrentState = U14ERR_TIME; /* Indicate that things are very wrong indeed */ + ced->current_state = 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(&ced->interface->dev, "%s: Success, state: 0x%x, 0x%x\n", - __func__, ced->statBuf[0], ced->statBuf[1]); + __func__, ced->stat_buf[0], ced->stat_buf[1]); - *state = ced->statBuf[0]; /* Return the state values to the calling code */ - *error = ced->statBuf[1]; + *state = ced->stat_buf[0]; /* Return the state values to the calling code */ + *error = ced->stat_buf[1]; nDevice = ced->udev->descriptor.bcdDevice >> 8; /* 1401 type code value */ switch (nDevice) { /* so we can clean up current state */ case 0: - ced->sCurrentState = U14ERR_U1401; + ced->current_state = U14ERR_U1401; break; default: /* allow lots of device codes for future 1401s */ if ((nDevice >= 1) && (nDevice <= 23)) - ced->sCurrentState = (short)(nDevice + 6); + ced->current_state = (short)(nDevice + 6); else - ced->sCurrentState = U14ERR_ILL; + ced->current_state = U14ERR_ILL; break; } } - return ced->sCurrentState >= 0 ? U14ERR_NOERROR : ced->sCurrentState; + return ced->current_state >= 0 ? U14ERR_NOERROR : ced->current_state; } /**************************************************************************** @@ -221,15 +223,15 @@ int ced_get_state(struct ced_data *ced, __u32 *state, __u32 *error) int ced_read_write_cancel(struct ced_data *ced) { dev_dbg(&ced->interface->dev, "%s: entry %d\n", - __func__, ced->bStagedUrbPending); + __func__, ced->staged_urb_pending); #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(&ced->stagedLock); + spin_lock_irq(&ced->staged_lock); - if (ced->bStagedUrbPending) { /* anything to be cancelled? May need more... */ + if (ced->staged_urb_pending) { /* 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 */ @@ -238,7 +240,7 @@ int ced_read_write_cancel(struct ced_data *ced) /* Release the spinlock first otherwise the completion routine may hang */ /* on the spinlock while this function hands waiting for the event. */ - spin_unlock_irq(&ced->stagedLock); + spin_unlock_irq(&ced->staged_lock); bResult = IoCancelIrp(ced->pStagedIrp); /* Actually do the cancel */ if (bResult) { LARGE_INTEGER timeout; @@ -258,7 +260,7 @@ int ced_read_write_cancel(struct ced_data *ced) ("ced_read_write_cancel ntStatus = 0x%x decimal %d\n", ntStatus, ntStatus)); } else - spin_unlock_irq(&ced->stagedLock); + spin_unlock_irq(&ced->staged_lock); dev_info(&ced->interface - dev, "%s: done\n", __func__); return ntStatus; @@ -286,7 +288,7 @@ static int ced_in_self_test(struct ced_data *ced, unsigned int *pState) /*************************************************************************** ** ced_is_1401 - ALWAYS CALLED HOLDING THE io_mutex ** -** Tests for the current state of the 1401. Sets sCurrentState: +** Tests for the current state of the 1401. Sets current_state: ** ** U14ERR_NOIF 1401 i/f card not installed (not done here) ** U14ERR_OFF 1401 apparently not switched on @@ -323,7 +325,7 @@ static bool ced_is_1401(struct ced_data *ced) } mutex_lock(&ced->io_mutex); /* hold stuff off while we wait */ - ced->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flag regardless! */ + ced->dma_flag = MODE_CHAR; /* Clear DMA mode flag regardless! */ if (iReturn == 0) { /* if all is OK still */ unsigned int state; iReturn = ced_in_self_test(ced, &state); /* see if likely in self test */ @@ -339,7 +341,7 @@ static bool ced_is_1401(struct ced_data *ced) iReturn = state == 0; /* then success is that the state is 0 */ } else iReturn = 0; /* we failed */ - ced->bForceReset = false; /* Clear forced reset flag now */ + ced->force_reset = false; /* Clear forced reset flag now */ return iReturn > 0; } @@ -363,17 +365,17 @@ 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 = ((ced->dwDMAFlag == MODE_CHAR) && /* no DMA running */ - (!ced->bForceReset) && /* Not had a real reset forced */ - (ced->sCurrentState >= U14ERR_STD)); /* No 1401 errors stored */ + bShortTest = ((ced->dma_flag == MODE_CHAR) && /* no DMA running */ + (!ced->force_reset) && /* Not had a real reset forced */ + (ced->current_state >= U14ERR_STD)); /* No 1401 errors stored */ dev_dbg(&ced->interface->dev, "%s: DMAFlag:%d, state:%d, force:%d, testBuff:%d, short:%d\n", - __func__, ced->dwDMAFlag, ced->sCurrentState, ced->bForceReset, + __func__, ced->dma_flag, ced->current_state, ced->force_reset, bTestBuff, bShortTest); if ((bTestBuff) && /* Buffer check requested, and... */ - (ced->dwNumInput || ced->dwNumOutput)) { /* ...characters were in the buffer? */ + (ced->num_input || ced->num_output)) { /* ...characters were in the buffer? */ bShortTest = false; /* Then do the full test */ dev_dbg(&ced->interface->dev, "%s: will reset as buffers not empty\n", __func__); @@ -391,8 +393,8 @@ static bool ced_quick_check(struct ced_data *ced, bool bTestBuff, bool bCanReset if (!bRet && bCanReset) { /* If all not OK, then */ dev_info(&ced->interface->dev, "%s: ced_is_1401 %d %d %d %d\n", - __func__, bShortTest, ced->sCurrentState, bTestBuff, - ced->bForceReset); + __func__, bShortTest, ced->current_state, bTestBuff, + ced->force_reset); bRet = ced_is_1401(ced); /* do full test */ } @@ -429,15 +431,15 @@ int ced_get_char(struct ced_data *ced) ced_allowi(ced); /* Make sure char reads are running */ ced_send_chars(ced); /* and send any buffered chars */ - 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--; + spin_lock_irq(&ced->char_in_lock); + if (ced->num_input > 0) { /* worth looking */ + iReturn = ced->input_buffer[ced->in_buff_get++]; + if (ced->in_buff_get >= INBUF_SZ) + ced->in_buff_get = 0; + ced->num_input--; } else iReturn = U14ERR_NOIN; /* no input data to read */ - spin_unlock_irq(&ced->charInLock); + spin_unlock_irq(&ced->char_in_lock); ced_allowi(ced); /* Make sure char reads are running */ @@ -467,8 +469,8 @@ int ced_get_string(struct ced_data *ced, char __user *pUser, int n) ced_allowi(ced); /* Make sure char reads are running */ ced_send_chars(ced); /* and send any buffered chars */ - spin_lock_irq(&ced->charInLock); - nAvailable = ced->dwNumInput; /* characters available now */ + spin_lock_irq(&ced->char_in_lock); + nAvailable = ced->num_input; /* characters available now */ if (nAvailable > n) /* read max of space in pUser... */ nAvailable = n; /* ...or input characters */ @@ -478,12 +480,12 @@ int ced_get_string(struct ced_data *ced, char __user *pUser, int n) int nCopyToUser; /* number to copy to user */ char cData; do { - cData = ced->inputBuffer[ced->dwInBuffGet++]; + cData = ced->input_buffer[ced->in_buff_get++]; if (cData == CR_CHAR) /* replace CR with zero */ cData = (char)0; - if (ced->dwInBuffGet >= INBUF_SZ) - ced->dwInBuffGet = 0; /* wrap buffer pointer */ + if (ced->in_buff_get >= INBUF_SZ) + ced->in_buff_get = 0; /* wrap buffer pointer */ buffer[nGot++] = cData; /* save the output */ } while ((nGot < nAvailable) && cData); @@ -495,8 +497,8 @@ int ced_get_string(struct ced_data *ced, char __user *pUser, int n) ++nCopyToUser; /* ...copy the 0 as well. */ } - ced->dwNumInput -= nGot; - spin_unlock_irq(&ced->charInLock); + ced->num_input -= nGot; + spin_unlock_irq(&ced->char_in_lock); dev_dbg(&ced->interface->dev, "%s: read %d characters >%s<\n", __func__, nGot, buffer); @@ -505,7 +507,7 @@ int ced_get_string(struct ced_data *ced, char __user *pUser, int n) else iReturn = nGot; /* report characters read */ } else - spin_unlock_irq(&ced->charInLock); + spin_unlock_irq(&ced->char_in_lock); ced_allowi(ced); /* Make sure char reads are running */ mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ @@ -522,7 +524,7 @@ int ced_stat_1401(struct ced_data *ced) 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 */ + iReturn = ced->num_input; /* no lock as single read */ mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ return iReturn; } @@ -541,13 +543,13 @@ int ced_line_count(struct ced_data *ced) 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 */ + spin_lock_irq(&ced->char_in_lock); /* Get protection */ - if (ced->dwNumInput > 0) { /* worth looking? */ - unsigned int dwIndex = ced->dwInBuffGet; /* start at first available */ - unsigned int dwEnd = ced->dwInBuffPut; /* Position for search end */ + if (ced->num_input > 0) { /* worth looking? */ + unsigned int dwIndex = ced->in_buff_get; /* start at first available */ + unsigned int dwEnd = ced->in_buff_put; /* Position for search end */ do { - if (ced->inputBuffer[dwIndex++] == CR_CHAR) + if (ced->input_buffer[dwIndex++] == CR_CHAR) ++iReturn; /* inc count if CR */ if (dwIndex >= INBUF_SZ) /* see if we fall off buff */ @@ -555,7 +557,7 @@ int ced_line_count(struct ced_data *ced) } while (dwIndex != dwEnd); /* go to last available */ } - spin_unlock_irq(&ced->charInLock); + spin_unlock_irq(&ced->char_in_lock); dev_dbg(&ced->interface->dev, "%s: returned %d\n", __func__, iReturn); mutex_unlock(&ced->io_mutex); /* Protect disconnect from new i/o */ return iReturn; @@ -571,7 +573,7 @@ int ced_get_out_buf_space(struct ced_data *ced) int iReturn; 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 */ + iReturn = (int)(OUTBUF_SZ - ced->num_output); /* 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; @@ -594,7 +596,7 @@ int ced_clear_area(struct ced_data *ced, int nArea) __func__, nArea); } else { /* to save typing */ - struct transarea *pTA = &ced->rTransDef[nArea]; + struct transarea *pTA = &ced->trans_def[nArea]; if (!pTA->used) /* if not used... */ iReturn = U14ERR_NOTSET; /* ...nothing to be done */ else { @@ -606,9 +608,9 @@ int ced_clear_area(struct ced_data *ced, int nArea) dev_dbg(&ced->interface->dev, "%s: area %d\n", __func__, nArea); - spin_lock_irq(&ced->stagedLock); - if ((ced->StagedId == nArea) - && (ced->dwDMAFlag > MODE_CHAR)) { + spin_lock_irq(&ced->staged_lock); + if ((ced->staged_id == nArea) + && (ced->dma_flag > MODE_CHAR)) { iReturn = U14ERR_UNLOCKFAIL; /* cannot delete as in use */ dev_err(&ced->interface->dev, "%s: call on area %d while active\n", @@ -619,9 +621,9 @@ int ced_clear_area(struct ced_data *ced, int nArea) if (pTA->event_sz) /* if events flagging in use */ wake_up_interruptible(&pTA->event); /* release anything that was waiting */ - if (ced->bXFerWaiting - && (ced->rDMAInfo.ident == nArea)) - ced->bXFerWaiting = false; /* Cannot have pending xfer if area cleared */ + if (ced->xfer_waiting + && (ced->dma_info.ident == nArea)) + ced->xfer_waiting = 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 used to false and event_sz to 0 to say area not used and no events. */ @@ -629,7 +631,7 @@ int ced_clear_area(struct ced_data *ced, int nArea) sizeof(struct transarea) - sizeof(wait_queue_head_t)); } - spin_unlock_irq(&ced->stagedLock); + spin_unlock_irq(&ced->staged_lock); 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 */ @@ -671,7 +673,7 @@ static int ced_set_area(struct ced_data *ced, int nArea, char __user *puBuf, unsigned int ulOffset = ((unsigned long)puBuf) & (PAGE_SIZE - 1); int len = (dwLength + ulOffset + PAGE_SIZE - 1) >> PAGE_SHIFT; - struct transarea *pTA = &ced->rTransDef[nArea]; /* to save typing */ + struct transarea *pTA = &ced->trans_def[nArea]; /* to save typing */ struct page **pPages = NULL; /* space for page tables */ int nPages = 0; /* and number of pages */ @@ -700,7 +702,7 @@ static int ced_set_area(struct ced_data *ced, int nArea, char __user *puBuf, /* 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(&ced->stagedLock); + spin_lock_irq(&ced->staged_lock); pTA->buff = puBuf; /* keep start of region (user address) */ pTA->base_offset = ulOffset; /* save offset in first page to start of xfer */ pTA->length = dwLength; /* Size if the region in bytes */ @@ -716,7 +718,7 @@ static int ced_set_area(struct ced_data *ced, int nArea, char __user *puBuf, pTA->blocks[1].size = 0; pTA->used = true; /* This is now a used block */ - spin_unlock_irq(&ced->stagedLock); + spin_unlock_irq(&ced->staged_lock); iReturn = U14ERR_NOERROR; /* say all was well */ } else { iReturn = U14ERR_LOCKFAIL; @@ -792,9 +794,9 @@ int ced_set_event(struct ced_data *ced, struct transfer_event __user *pTE) if (te.wAreaNum >= MAX_TRANSAREAS) /* the area must exist */ return U14ERR_BADAREA; else { - struct transarea *pTA = &ced->rTransDef[te.wAreaNum]; + struct transarea *pTA = &ced->trans_def[te.wAreaNum]; mutex_lock(&ced->io_mutex); /* make sure we have no competitor */ - spin_lock_irq(&ced->stagedLock); + spin_lock_irq(&ced->staged_lock); if (pTA->used) { /* area must be in use */ pTA->event_st = te.dwStart; /* set area regions */ pTA->event_sz = te.dwLength; /* set size (0 cancels it) */ @@ -802,7 +804,7 @@ int ced_set_event(struct ced_data *ced, struct transfer_event __user *pTE) pTA->wake_up = 0; /* zero the wake up count */ } else iReturn = U14ERR_NOTSET; - spin_unlock_irq(&ced->stagedLock); + spin_unlock_irq(&ced->staged_lock); mutex_unlock(&ced->io_mutex); } return iReturn == @@ -822,7 +824,7 @@ int ced_wait_event(struct ced_data *ced, int nArea, int msTimeOut) return U14ERR_BADAREA; else { int iWait; - struct transarea *pTA = &ced->rTransDef[nArea]; + struct transarea *pTA = &ced->trans_def[nArea]; msTimeOut = (msTimeOut * HZ + 999) / 1000; /* convert timeout to jiffies */ /* We cannot wait holding the mutex, but we check the flags while holding */ @@ -849,9 +851,9 @@ int ced_wait_event(struct ced_data *ced, int nArea, int msTimeOut) else iReturn = pTA->wake_up; /* else the wakeup count */ - spin_lock_irq(&ced->stagedLock); + spin_lock_irq(&ced->staged_lock); pTA->wake_up = 0; /* clear the flag */ - spin_unlock_irq(&ced->stagedLock); + spin_unlock_irq(&ced->staged_lock); } return iReturn; } @@ -868,12 +870,12 @@ int ced_test_event(struct ced_data *ced, int nArea) if ((unsigned)nArea >= MAX_TRANSAREAS) iReturn = U14ERR_BADAREA; else { - struct transarea *pTA = &ced->rTransDef[nArea]; + struct transarea *pTA = &ced->trans_def[nArea]; mutex_lock(&ced->io_mutex); /* make sure we have no competitor */ - spin_lock_irq(&ced->stagedLock); + spin_lock_irq(&ced->staged_lock); iReturn = pTA->wake_up; /* get wakeup count since last call */ pTA->wake_up = 0; /* clear the count */ - spin_unlock_irq(&ced->stagedLock); + spin_unlock_irq(&ced->staged_lock); mutex_unlock(&ced->io_mutex); } return iReturn; @@ -889,7 +891,7 @@ int ced_get_transfer(struct ced_data *ced, TGET_TX_BLOCK __user *pTX) unsigned int dwIdent; mutex_lock(&ced->io_mutex); - dwIdent = ced->StagedId; /* area ident for last xfer */ + dwIdent = ced->staged_id; /* area ident for last xfer */ if (dwIdent >= MAX_TRANSAREAS) iReturn = U14ERR_BADAREA; else { @@ -901,12 +903,12 @@ int ced_get_transfer(struct ced_data *ced, TGET_TX_BLOCK __user *pTX) mutex_unlock(&ced->io_mutex); return -ENOMEM; } - tx->size = ced->rTransDef[dwIdent].length; - tx->linear = (long long)((long)ced->rTransDef[dwIdent].buff); + tx->size = ced->trans_def[dwIdent].length; + tx->linear = (long long)((long)ced->trans_def[dwIdent].buff); 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 + ced->StagedOffset); + (long long)(tx->linear + ced->staged_offset); tx->entries[0].size = tx->size; if (copy_to_user(pTX, tx, sizeof(*tx))) @@ -943,7 +945,7 @@ int ced_state_of_1401(struct ced_data *ced) mutex_lock(&ced->io_mutex); ced_quick_check(ced, false, false); /* get state up to date, no reset */ - iReturn = ced->sCurrentState; + iReturn = ced->current_state; mutex_unlock(&ced->io_mutex); dev_dbg(&ced->interface->dev, "%s: %d\n", __func__, iReturn); @@ -968,12 +970,12 @@ int ced_start_self_test(struct ced_data *ced) ced_flush_out_buff(ced); /* Clear output buffer & pipe */ /* so things stay tidy */ /* ced_read_write_cancel(pDeviceObject); */ - ced->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flags here */ + ced->dma_flag = MODE_CHAR; /* Clear DMA mode flags here */ 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 */ - ced->ulSelfTestTime = jiffies + HZ * 30; /* 30 seconds into the future */ + ced->self_test_time = jiffies + HZ * 30; /* 30 seconds into the future */ mutex_unlock(&ced->io_mutex); if (nGot < 0) @@ -1027,7 +1029,7 @@ int ced_check_self_test(struct ced_data *ced, TGET_SELFTEST __user *pGST) "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, ced->ulSelfTestTime)) { + if (time_after(ulNow, ced->self_test_time)) { gst.code = -2; /* Flag the timeout */ dev_dbg(&ced->interface->dev, "Self-test timed-out\n"); @@ -1042,7 +1044,7 @@ int ced_check_self_test(struct ced_data *ced, TGET_SELFTEST __user *pGST) if (gst.code < 0) { /* If we have a problem or finished */ /* If using the 2890 we should reset properly */ - if ((ced->nPipes == 4) && (ced->s1401Type <= TYPEPOWER)) + if ((ced->n_pipes == 4) && (ced->type <= TYPEPOWER)) ced_is_1401(ced); /* Get 1401 reset and OK */ else ced_quick_check(ced, true, true); /* Otherwise check without reset unless problems */ @@ -1066,7 +1068,7 @@ int ced_type_of_1401(struct ced_data *ced) mutex_lock(&ced->io_mutex); dev_dbg(&ced->interface->dev, "%s\n", __func__); - switch (ced->s1401Type) { + switch (ced->type) { case TYPE1401: iReturn = U14ERR_STD; break; /* Handle these types directly */ @@ -1077,8 +1079,8 @@ int ced_type_of_1401(struct ced_data *ced) iReturn = U14ERR_U1401; break; default: - if ((ced->s1401Type >= TYPEPOWER) && (ced->s1401Type <= 25)) - iReturn = ced->s1401Type + 4; /* We can calculate types */ + if ((ced->type >= TYPEPOWER) && (ced->type <= 25)) + iReturn = ced->type + 4; /* We can calculate types */ else /* for up-coming 1401 designs */ iReturn = TYPEUNKNOWN; /* Don't know or not there */ } @@ -1099,7 +1101,7 @@ int ced_transfer_flags(struct ced_data *ced) U14TF_NOTIFY | U14TF_CIRCTH; /* diagnostics, notify and circular */ dev_dbg(&ced->interface->dev, "%s\n", __func__); mutex_lock(&ced->io_mutex); - if (ced->bIsUSB2) /* Set flag for USB2 if appropriate */ + if (ced->is_usb2) /* Set flag for USB2 if appropriate */ iReturn |= U14TF_USB2; mutex_unlock(&ced->io_mutex); @@ -1356,8 +1358,8 @@ int ced_get_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB) if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */ /* Pointer to relevant info */ - struct transarea *pArea = &ced->rTransDef[nArea]; - spin_lock_irq(&ced->stagedLock); /* Lock others out */ + struct transarea *pArea = &ced->trans_def[nArea]; + spin_lock_irq(&ced->staged_lock); /* Lock others out */ if ((pArea->used) && (pArea->circular) && /* Must be circular area */ (pArea->circ_to_host)) { /* For now at least must be to host */ @@ -1371,7 +1373,7 @@ int ced_get_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB) } else iReturn = U14ERR_NOTSET; - spin_unlock_irq(&ced->stagedLock); + spin_unlock_irq(&ced->staged_lock); } else iReturn = U14ERR_BADAREA; @@ -1408,8 +1410,8 @@ int ced_free_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB) if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */ /* Pointer to relevant info */ - struct transarea *pArea = &ced->rTransDef[nArea]; - spin_lock_irq(&ced->stagedLock); /* Lock others out */ + struct transarea *pArea = &ced->trans_def[nArea]; + spin_lock_irq(&ced->staged_lock); /* Lock others out */ if ((pArea->used) && (pArea->circular) && /* Must be circular area */ (pArea->circ_to_host)) { /* For now at least must be to host */ @@ -1433,7 +1435,7 @@ int ced_free_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB) __func__, uSize, uStart, pArea->blocks[0].size, pArea->blocks[0].offset, - ced->bXFerWaiting); + ced->xfer_waiting); /* Return the next available block of memory as well */ if (pArea->blocks[0].size > 0) { /* Got anything? */ @@ -1442,8 +1444,8 @@ int ced_free_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB) cb.dwSize = pArea->blocks[0].size; } - bWaiting = ced->bXFerWaiting; - if (bWaiting && ced->bStagedUrbPending) { + bWaiting = ced->xfer_waiting; + if (bWaiting && ced->staged_urb_pending) { dev_err(&ced->interface->dev, "%s: ERROR: waiting xfer and staged Urb pending!\n", __func__); @@ -1462,10 +1464,10 @@ int ced_free_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB) if (bWaiting) { /* Got a block xfer waiting? */ int RWMStat = ced_read_write_mem(ced, - !ced->rDMAInfo.outward, - ced->rDMAInfo.ident, - ced->rDMAInfo.offset, - ced->rDMAInfo.size); + !ced->dma_info.outward, + ced->dma_info.ident, + ced->dma_info.offset, + ced->dma_info.size); if (RWMStat != U14ERR_NOERROR) dev_err(&ced->interface->dev, "%s: rw setup failed %d\n", @@ -1474,7 +1476,7 @@ int ced_free_circ_block(struct ced_data *ced, TCIRCBLOCK __user *pCB) } else iReturn = U14ERR_NOTSET; - spin_unlock_irq(&ced->stagedLock); + spin_unlock_irq(&ced->staged_lock); } else iReturn = U14ERR_BADAREA; diff --git a/drivers/staging/ced1401/usb1401.c b/drivers/staging/ced1401/usb1401.c index 30d103cb106..7341da0f8ff 100644 --- a/drivers/staging/ced1401/usb1401.c +++ b/drivers/staging/ced1401/usb1401.c @@ -127,19 +127,19 @@ static void ced_delete(struct kref *kref) /* Free up the output buffer, then free the output urb. Note that the interface member */ /* 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); + usb_free_coherent(ced->udev, OUTBUF_SZ, ced->coher_char_out, + ced->urb_char_out->transfer_dma); + usb_free_urb(ced->urb_char_out); /* Do the same for chan input */ - usb_free_coherent(ced->udev, INBUF_SZ, ced->pCoherCharIn, - ced->pUrbCharIn->transfer_dma); - usb_free_urb(ced->pUrbCharIn); + usb_free_coherent(ced->udev, INBUF_SZ, ced->coher_char_in, + ced->urb_char_in->transfer_dma); + usb_free_urb(ced->urb_char_in); /* Do the same for the block transfers */ - usb_free_coherent(ced->udev, STAGED_SZ, ced->pCoherStagedIO, - ced->pStagedUrb->transfer_dma); - usb_free_urb(ced->pStagedUrb); + usb_free_coherent(ced->udev, STAGED_SZ, ced->coher_staged_io, + ced->staged_urb->transfer_dma); + usb_free_urb(ced->staged_urb); usb_put_dev(ced->udev); kfree(ced); @@ -225,7 +225,7 @@ static int ced_flush(struct file *file, fl_owner_t id) return -ENODEV; dev_dbg(&ced->interface->dev, "%s: char in pend=%d\n", - __func__, ced->bReadCharsPending); + __func__, ced->read_chars_pending); /* wait for io to stop */ mutex_lock(&ced->io_mutex); @@ -279,56 +279,61 @@ static void ced_writechar_callback(struct urb *pUrb) spin_unlock(&ced->err_lock); nGot = 0; /* and tidy up again if so */ - 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 */ + spin_lock(&ced->char_out_lock); /* already at irq level */ + ced->out_buff_get = 0; /* Reset the output buffer */ + ced->out_buff_put = 0; + ced->num_output = 0; /* Clear the char count */ + ced->pipe_error[0] = 1; /* Flag an error for later */ + ced->send_chars_pending = false; /* Allow other threads again */ + spin_unlock(&ced->char_out_lock); /* already at irq level */ dev_dbg(&ced->interface->dev, "%s: char out done, 0 chars sent\n", __func__); } else { dev_dbg(&ced->interface->dev, "%s: char out done, %d chars sent\n", __func__, nGot); - 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; + spin_lock(&ced->char_out_lock); /* already at irq level */ + ced->num_output -= nGot; /* Now adjust the char send buffer */ + ced->out_buff_get += nGot; /* to match what we did */ + if (ced->out_buff_get >= OUTBUF_SZ) /* Can't do this any earlier as data could be overwritten */ + ced->out_buff_get = 0; - if (ced->dwNumOutput > 0) { /* if more to be done... */ + if (ced->num_output > 0) { /* if more to be done... */ int nPipe = 0; /* The pipe number to use */ int iReturn; - 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, + char *pDat = &ced->output_buffer[ced->out_buff_get]; + unsigned int dwCount = ced->num_output; /* maximum to send */ + if ((ced->out_buff_get + dwCount) > OUTBUF_SZ) /* does it cross buffer end? */ + dwCount = OUTBUF_SZ - ced->out_buff_get; + + /* we are done with stuff that changes */ + spin_unlock(&ced->char_out_lock); + + memcpy(ced->coher_char_out, pDat, dwCount); /* copy output data to the buffer */ + usb_fill_bulk_urb(ced->urb_char_out, ced->udev, usb_sndbulkpipe(ced->udev, - ced->epAddr[0]), - ced->pCoherCharOut, dwCount, + ced->ep_addr[0]), + ced->coher_char_out, dwCount, ced_writechar_callback, ced); - ced->pUrbCharOut->transfer_flags |= + ced->urb_char_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - usb_anchor_urb(ced->pUrbCharOut, &ced->submitted); /* in case we need to kill it */ - iReturn = usb_submit_urb(ced->pUrbCharOut, GFP_ATOMIC); + usb_anchor_urb(ced->urb_char_out, &ced->submitted); /* in case we need to kill it */ + iReturn = usb_submit_urb(ced->urb_char_out, GFP_ATOMIC); dev_dbg(&ced->interface->dev, "%s: n=%d>%s<\n", __func__, dwCount, pDat); - spin_lock(&ced->charOutLock); /* grab lock for errors */ + spin_lock(&ced->char_out_lock); /* grab lock for errors */ if (iReturn) { - ced->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ - ced->bSendCharsPending = false; /* Allow other threads again */ - usb_unanchor_urb(ced->pUrbCharOut); + ced->pipe_error[nPipe] = 1; /* Flag an error to be handled later */ + ced->send_chars_pending = false; /* Allow other threads again */ + usb_unanchor_urb(ced->urb_char_out); dev_err(&ced->interface->dev, "%s: usb_submit_urb() returned %d\n", __func__, iReturn); } } else - ced->bSendCharsPending = false; /* Allow other threads again */ - spin_unlock(&ced->charOutLock); /* already at irq level */ + /* Allow other threads again */ + ced->send_chars_pending = false; + + spin_unlock(&ced->char_out_lock); /* already at irq level */ } } @@ -341,25 +346,26 @@ int ced_send_chars(struct ced_data *ced) { int iReturn = U14ERR_NOERROR; - spin_lock_irq(&ced->charOutLock); /* Protect ourselves */ + spin_lock_irq(&ced->char_out_lock); /* Protect ourselves */ - if ((!ced->bSendCharsPending) && /* Not currently sending */ - (ced->dwNumOutput > 0) && /* has characters to output */ + if ((!ced->send_chars_pending) && /* Not currently sending */ + (ced->num_output > 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 */ + unsigned int dwCount = ced->num_output; /* Get a copy of the */ + /* character count */ + ced->send_chars_pending = true; /* Set flag to lock out other threads */ dev_dbg(&ced->interface->dev, "Send %d chars to 1401, EP0 flag %d\n", - dwCount, ced->nPipes == 3); + dwCount, ced->n_pipes == 3); /* If we have only 3 end points we must send the characters to the 1401 using EP0. */ - if (ced->nPipes == 3) { + if (ced->n_pipes == 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(&ced->charOutLock); /* Free spinlock as we call USBD */ + spin_unlock_irq(&ced->char_out_lock); /* 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 */ @@ -369,7 +375,7 @@ int ced_send_chars(struct ced_data *ced) DB_CHARS, /* bRequest */ (H_TO_D | VENDOR | DEVREQ), /* to the device, vendor request to the device */ 0, 0, /* value and index are both 0 */ - &ced->outputBuffer[index], /* where to send from */ + &ced->output_buffer[index], /* where to send from */ n, /* how much to send */ 1000); /* timeout in jiffies */ if (nSent <= 0) { @@ -385,50 +391,53 @@ int ced_send_chars(struct ced_data *ced) } } - 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 */ + spin_lock_irq(&ced->char_out_lock); /* Protect ced changes, released by general code */ + ced->out_buff_get = 0; /* so reset the output buffer */ + ced->out_buff_put = 0; + ced->num_output = 0; /* and clear the buffer count */ + ced->send_chars_pending = 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 = &ced->outputBuffer[ced->dwOutBuffGet]; + char *pDat = &ced->output_buffer[ced->out_buff_get]; - 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, + if ((ced->out_buff_get + dwCount) > OUTBUF_SZ) /* does it cross buffer end? */ + dwCount = OUTBUF_SZ - ced->out_buff_get; + spin_unlock_irq(&ced->char_out_lock); /* we are done with stuff that changes */ + memcpy(ced->coher_char_out, pDat, dwCount); /* copy output data to the buffer */ + usb_fill_bulk_urb(ced->urb_char_out, ced->udev, usb_sndbulkpipe(ced->udev, - ced->epAddr[0]), - ced->pCoherCharOut, dwCount, + ced->ep_addr[0]), + ced->coher_char_out, dwCount, ced_writechar_callback, ced); - ced->pUrbCharOut->transfer_flags |= + ced->urb_char_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; - usb_anchor_urb(ced->pUrbCharOut, &ced->submitted); - iReturn = usb_submit_urb(ced->pUrbCharOut, GFP_KERNEL); - spin_lock_irq(&ced->charOutLock); /* grab lock for errors */ + usb_anchor_urb(ced->urb_char_out, &ced->submitted); + iReturn = usb_submit_urb(ced->urb_char_out, GFP_KERNEL); + + /* grab lock for errors */ + spin_lock_irq(&ced->char_out_lock); + if (iReturn) { - 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 */ + ced->pipe_error[nPipe] = 1; /* Flag an error to be handled later */ + ced->send_chars_pending = false; /* Allow other threads again */ + usb_unanchor_urb(ced->urb_char_out); /* remove from list of active urbs */ } } - } else if (ced->bSendCharsPending && (ced->dwNumOutput > 0)) + } else if (ced->send_chars_pending && (ced->num_output > 0)) dev_dbg(&ced->interface->dev, - "%s: bSendCharsPending:true\n", __func__); + "%s: send_chars_pending:true\n", __func__); dev_dbg(&ced->interface->dev, "%s: exit code: %d\n", __func__, iReturn); - spin_unlock_irq(&ced->charOutLock); /* Now let go of the spinlock */ + spin_unlock_irq(&ced->char_out_lock); /* Now let go of the spinlock */ return iReturn; } /*************************************************************************** ** ced_copy_user_space -** This moves memory between pinned down user space and the pCoherStagedIO +** This moves memory between pinned down user space and the coher_staged_io ** memory buffer we use for transfers. Copy n bytes in the directions that -** is defined by ced->StagedRead. The user space is determined by the area -** in ced->StagedId and the offset in ced->StagedDone. The user +** is defined by ced->staged_read. The user space is determined by the area +** in ced->staged_id and the offset in ced->staged_done. 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 @@ -439,13 +448,13 @@ int ced_send_chars(struct ced_data *ced) ***************************************************************************/ static void ced_copy_user_space(struct ced_data *ced, int n) { - unsigned int nArea = ced->StagedId; + unsigned int nArea = ced->staged_id; if (nArea < MAX_TRANSAREAS) { /* area to be used */ - struct transarea *pArea = &ced->rTransDef[nArea]; + struct transarea *pArea = &ced->trans_def[nArea]; unsigned int dwOffset = - ced->StagedDone + ced->StagedOffset + pArea->base_offset; - char *pCoherBuf = ced->pCoherStagedIO; /* coherent buffer */ + ced->staged_done + ced->staged_offset + pArea->base_offset; + char *pCoherBuf = ced->coher_staged_io; /* coherent buffer */ if (!pArea->used) { dev_err(&ced->interface->dev, "%s: area %d unused\n", __func__, nArea); @@ -462,7 +471,7 @@ static void ced_copy_user_space(struct ced_data *ced, int n) size_t uiXfer = PAGE_SIZE - uiPageOff; /* max to transfer on this page */ if (uiXfer > n) /* limit byte count if too much */ uiXfer = n; /* for the page */ - if (ced->StagedRead) + if (ced->staged_read) memcpy(pvAddress + uiPageOff, pCoherBuf, uiXfer); else @@ -506,8 +515,9 @@ static void staged_callback(struct urb *pUrb) bool bCancel = false; bool bRestartCharInput; /* used at the end */ - 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 */ + spin_lock(&ced->staged_lock); /* stop ced_read_write_mem() action */ + /* while this routine is running */ + ced->staged_urb_pending = false; /* clear the flag for staged IRP pending */ if (pUrb->status) { /* sync/async unlink faults aren't errors */ if (! @@ -528,38 +538,38 @@ static void staged_callback(struct urb *pUrb) } else { dev_dbg(&ced->interface->dev, "%s: %d chars xferred\n", __func__, nGot); - if (ced->StagedRead) /* if reading, save to user space */ + if (ced->staged_read) /* if reading, save to user space */ ced_copy_user_space(ced, nGot); /* copy from buffer to user */ if (nGot == 0) dev_dbg(&ced->interface->dev, "%s: ZLP\n", __func__); } /* Update the transfer length based on the TransferBufferLength value in the URB */ - ced->StagedDone += nGot; + ced->staged_done += nGot; dev_dbg(&ced->interface->dev, "%s: done %d bytes of %d\n", - __func__, ced->StagedDone, ced->StagedLength); + __func__, ced->staged_done, ced->staged_length); - if ((ced->StagedDone == ced->StagedLength) || /* If no more to do */ + if ((ced->staged_done == ced->staged_length) || /* If no more to do */ (bCancel)) { /* or this IRP was cancelled */ /* Transfer area info */ - struct transarea *pArea = &ced->rTransDef[ced->StagedId]; + struct transarea *pArea = &ced->trans_def[ced->staged_id]; dev_dbg(&ced->interface->dev, "%s: transfer done, bytes %d, cancel %d\n", - __func__, ced->StagedDone, bCancel); + __func__, ced->staged_done, 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->circular) && (pArea->circ_to_host) && (!bCancel) && /* Time to sort out circular buffer info? */ - (ced->StagedRead)) { /* Only for tohost transfers for now */ + (ced->staged_read)) {/* Only for tohost transfers for now */ if (pArea->blocks[1].size > 0) { /* If block 1 is in use we must append to it */ - if (ced->StagedOffset == + if (ced->staged_offset == (pArea->blocks[1].offset + pArea->blocks[1].size)) { pArea->blocks[1].size += - ced->StagedLength; + ced->staged_length; dev_dbg(&ced->interface->dev, "RWM_Complete, circ block 1 now %d bytes at %d\n", pArea->blocks[1].size, @@ -567,9 +577,9 @@ static void staged_callback(struct urb *pUrb) } else { /* Here things have gone very, very, wrong, but I cannot see how this can actually be achieved */ pArea->blocks[1].offset = - ced->StagedOffset; + ced->staged_offset; pArea->blocks[1].size = - ced->StagedLength; + ced->staged_length; dev_err(&ced->interface->dev, "%s: ERROR, circ block 1 re-started %d bytes at %d\n", __func__, @@ -579,10 +589,10 @@ static void staged_callback(struct urb *pUrb) } else { /* If block 1 is not used, we try to add to block 0 */ if (pArea->blocks[0].size > 0) { /* Got stored block 0 information? */ /* Must append onto the existing block 0 */ - if (ced->StagedOffset == + if (ced->staged_offset == (pArea->blocks[0].offset + pArea->blocks[0].size)) { - pArea->blocks[0].size += ced->StagedLength; /* Just add this transfer in */ + pArea->blocks[0].size += ced->staged_length; /* Just add this transfer in */ dev_dbg(&ced->interface->dev, "RWM_Complete, circ block 0 now %d bytes at %d\n", pArea->blocks[0]. @@ -591,9 +601,9 @@ static void staged_callback(struct urb *pUrb) offset); } else { /* If it doesn't append, put into new block 1 */ pArea->blocks[1].offset = - ced->StagedOffset; + ced->staged_offset; pArea->blocks[1].size = - ced->StagedLength; + ced->staged_length; dev_dbg(&ced->interface->dev, "RWM_Complete, circ block 1 started %d bytes at %d\n", pArea->blocks[1]. @@ -603,9 +613,9 @@ static void staged_callback(struct urb *pUrb) } } else { /* No info stored yet, just save in block 0 */ pArea->blocks[0].offset = - ced->StagedOffset; + ced->staged_offset; pArea->blocks[0].size = - ced->StagedLength; + ced->staged_length; dev_dbg(&ced->interface->dev, "RWM_Complete, circ block 0 started %d bytes at %d\n", pArea->blocks[0].size, @@ -620,7 +630,7 @@ static void staged_callback(struct urb *pUrb) pArea->circular, pArea->event_to_host, pArea->event_st, pArea->event_sz); if ((pArea->event_sz) && /* Set a user-mode event... */ - (ced->StagedRead == pArea->event_to_host)) { /* ...on transfers in this direction? */ + (ced->staged_read == pArea->event_to_host)) { /* ...on transfers in this direction? */ int iWakeUp = 0; /* assume */ /* If we have completed the right sort of DMA */ @@ -636,11 +646,11 @@ static void staged_callback(struct urb *pUrb) iWakeUp = (dwTotal >= pArea->event_sz); } else { unsigned int transEnd = - ced->StagedOffset + - ced->StagedLength; + ced->staged_offset + + ced->staged_length; unsigned int eventEnd = pArea->event_st + pArea->event_sz; - iWakeUp = (ced->StagedOffset < eventEnd) + iWakeUp = (ced->staged_offset < eventEnd) && (transEnd > pArea->event_st); } @@ -653,19 +663,19 @@ static void staged_callback(struct urb *pUrb) } } - ced->dwDMAFlag = MODE_CHAR; /* Switch back to char mode before ced_read_write_mem call */ + ced->dma_flag = 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 (ced->bXFerWaiting) { /* Got a block xfer waiting? */ + if (ced->xfer_waiting) {/* Got a block xfer waiting? */ int iReturn; dev_info(&ced->interface->dev, "*** RWM_Complete *** pending transfer will now be set up!!!\n"); iReturn = - ced_read_write_mem(ced, !ced->rDMAInfo.outward, - ced->rDMAInfo.ident, - ced->rDMAInfo.offset, - ced->rDMAInfo.size); + ced_read_write_mem(ced, !ced->dma_info.outward, + ced->dma_info.ident, + ced->dma_info.offset, + ced->dma_info.size); if (iReturn) dev_err(&ced->interface->dev, @@ -677,15 +687,15 @@ static void staged_callback(struct urb *pUrb) } else /* Here for more to do */ ced_stage_chunk(ced); /* fire off the next bit */ - /* While we hold the stagedLock, see if we should reallow character input ints */ + /* While we hold the staged_lock, 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 && (ced->dwDMAFlag == MODE_CHAR) - && !ced->bXFerWaiting; + /* This feels wrong as we should ask which spin lock protects dma_flag. */ + bRestartCharInput = !bCancel && (ced->dma_flag == MODE_CHAR) && + !ced->xfer_waiting; - spin_unlock(&ced->stagedLock); /* Finally release the lock again */ + spin_unlock(&ced->staged_lock); /* Finally release the lock again */ - /* This is not correct as dwDMAFlag is protected by the staged lock, but it is treated */ + /* This is not correct as dma_flag 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... */ @@ -705,8 +715,8 @@ static int ced_stage_chunk(struct ced_data *ced) { int iReturn = U14ERR_NOERROR; unsigned int ChunkSize; - int nPipe = ced->StagedRead ? 3 : 2; /* The pipe number to use for reads or writes */ - if (ced->nPipes == 3) + int nPipe = ced->staged_read ? 3 : 2; /* The pipe number to use for reads or writes */ + if (ced->n_pipes == 3) nPipe--; /* Adjust for the 3-pipe case */ if (nPipe < 0) /* and trap case that should never happen */ return U14ERR_FAIL; @@ -717,31 +727,32 @@ static int ced_stage_chunk(struct ced_data *ced) return U14ERR_FAIL; /* could do with a better error */ } - ChunkSize = (ced->StagedLength - ced->StagedDone); /* transfer length remaining */ + ChunkSize = (ced->staged_length - ced->staged_done); /* transfer length remaining */ if (ChunkSize > STAGED_SZ) /* make sure to keep legal */ ChunkSize = STAGED_SZ; /* limit to max allowed */ - if (!ced->StagedRead) /* if writing... */ + if (!ced->staged_read) /* if writing... */ ced_copy_user_space(ced, ChunkSize); /* ...copy data into the buffer */ - usb_fill_bulk_urb(ced->pStagedUrb, ced->udev, - ced->StagedRead ? usb_rcvbulkpipe(ced->udev, + usb_fill_bulk_urb(ced->staged_urb, ced->udev, + ced->staged_read ? usb_rcvbulkpipe(ced->udev, ced-> - epAddr[nPipe]) : - 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); + ep_addr[nPipe]) : + usb_sndbulkpipe(ced->udev, ced->ep_addr[nPipe]), + ced->coher_staged_io, ChunkSize, + staged_callback, ced); + ced->staged_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; + usb_anchor_urb(ced->staged_urb, &ced->submitted); /* in case we need to kill it */ + iReturn = usb_submit_urb(ced->staged_urb, GFP_ATOMIC); if (iReturn) { - usb_unanchor_urb(ced->pStagedUrb); /* kill it */ - ced->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ + usb_unanchor_urb(ced->staged_urb); /* kill it */ + ced->pipe_error[nPipe] = 1; /* Flag an error to be handled later */ dev_err(&ced->interface->dev, "%s: submit urb failed, code %d\n", __func__, iReturn); } else - ced->bStagedUrbPending = true; /* Set the flag for staged URB pending */ + ced->staged_urb_pending = 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); + __func__, ced->staged_done, ChunkSize); return iReturn; } @@ -753,7 +764,7 @@ static int ced_stage_chunk(struct ced_data *ced) ** Breaks up a read or write in to specified sized chunks, as specified by pipe ** information on maximum transfer size. ** -** Any code that calls this must be holding the stagedLock +** Any code that calls this must be holding the staged_lock ** ** Arguments: ** DeviceObject - pointer to our FDO (Functional Device Object) @@ -767,7 +778,7 @@ 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 = &ced->rTransDef[wIdent]; + struct transarea *pArea = &ced->trans_def[wIdent]; 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", @@ -781,8 +792,8 @@ int ced_read_write_mem(struct ced_data *ced, bool Read, unsigned short 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 (ced->bStagedUrbPending) { - ced->bXFerWaiting = true; /* Flag we are waiting */ + if (ced->staged_urb_pending) { + ced->xfer_waiting = true; /* Flag we are waiting */ dev_info(&ced->interface->dev, "%s: xfer is waiting, as previous staged pending\n", __func__); @@ -823,7 +834,7 @@ int ced_read_write_mem(struct ced_data *ced, bool Read, unsigned short wIdent, } if (bWait) { /* This transfer will have to wait? */ - ced->bXFerWaiting = true; /* Flag we are waiting */ + ced->xfer_waiting = true; /* Flag we are waiting */ dev_dbg(&ced->interface->dev, "%s: xfer waiting for circular buffer space\n", __func__); @@ -835,13 +846,13 @@ int ced_read_write_mem(struct ced_data *ced, bool Read, unsigned short wIdent, __func__, dwLen, dwOffs); } /* Save the parameters for the read\write transfer */ - 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 */ + ced->staged_read = Read; /* Save the parameters for this read */ + ced->staged_id = wIdent; /* ID allows us to get transfer area info */ + ced->staged_offset = dwOffs; /* The area within the transfer area */ + ced->staged_length = dwLen; + ced->staged_done = 0; /* Initialise the byte count */ + ced->dma_flag = MODE_LINEAR; /* Set DMA mode flag at this point */ + ced->xfer_waiting = false; /* Clearly not a transfer waiting now */ /* KeClearEvent(&ced->StagingDoneEvent); // Clear the transfer done event */ ced_stage_chunk(ced); /* fire off the first chunk */ @@ -988,21 +999,21 @@ static bool ced_read_dma_info(volatile struct dmadesc *pDmaDesc, pDmaDesc->size); if ((wIdent >= MAX_TRANSAREAS) || /* Illegal area number, or... */ - (!ced->rTransDef[wIdent].used) || /* area not set up, or... */ - (pDmaDesc->offset > ced->rTransDef[wIdent].length) || /* range/size */ + (!ced->trans_def[wIdent].used) || /* area not set up, or... */ + (pDmaDesc->offset > ced->trans_def[wIdent].length) || /* range/size */ ((pDmaDesc->offset + pDmaDesc->size) > - (ced->rTransDef[wIdent]. + (ced->trans_def[wIdent]. length))) { bResult = false; /* bad parameter(s) */ dev_dbg(&ced->interface->dev, "%s: bad param - id %d, bUsed %d, offset %d, size %d, area length %d\n", __func__, wIdent, - ced->rTransDef[wIdent]. + ced->trans_def[wIdent]. used, pDmaDesc->offset, pDmaDesc->size, - ced->rTransDef[wIdent]. + ced->trans_def[wIdent]. length); } } @@ -1046,18 +1057,19 @@ static int ced_handle_esc(struct ced_data *ced, char *pCh, if (pCh[0] == '?') { /* Is this an information response */ /* Parse and save the information */ } else { - spin_lock(&ced->stagedLock); /* Lock others out */ + spin_lock(&ced->staged_lock); /* Lock others out */ - if (ced_read_dma_info(&ced->rDMAInfo, ced, pCh, dwCount)) { /* Get DMA parameters */ - unsigned short wTransType = ced->rDMAInfo.trans_type; /* check transfer type */ + if (ced_read_dma_info(&ced->dma_info, ced, pCh, dwCount)) { /* Get DMA parameters */ + unsigned short wTransType = ced->dma_info.trans_type; /* check transfer type */ dev_dbg(&ced->interface->dev, "%s: xfer to %s, offset %d, length %d\n", __func__, - ced->rDMAInfo.outward ? "1401" : "host", - ced->rDMAInfo.offset, ced->rDMAInfo.size); + ced->dma_info.outward ? "1401" : "host", + ced->dma_info.offset, ced->dma_info.size); - if (ced->bXFerWaiting) { /* Check here for badly out of kilter... */ + /* Check here for badly out of kilter... */ + if (ced->xfer_waiting) { /* This can never happen, really */ dev_err(&ced->interface->dev, "ERROR: DMA setup while transfer still waiting\n"); @@ -1066,10 +1078,10 @@ static int ced_handle_esc(struct ced_data *ced, char *pCh, || (wTransType == TM_EXTTO1401)) { iReturn = ced_read_write_mem(ced, - !ced->rDMAInfo.outward, - ced->rDMAInfo.ident, - ced->rDMAInfo.offset, - ced->rDMAInfo.size); + !ced->dma_info.outward, + ced->dma_info.ident, + ced->dma_info.offset, + ced->dma_info.size); if (iReturn != U14ERR_NOERROR) dev_err(&ced->interface->dev, "%s: ced_read_write_mem() failed %d\n", @@ -1083,7 +1095,7 @@ static int ced_handle_esc(struct ced_data *ced, char *pCh, dev_err(&ced->interface->dev, "%s: ced_read_dma_info() fail\n", __func__); - spin_unlock(&ced->stagedLock); /* OK here */ + spin_unlock(&ced->staged_lock); /* OK here */ } dev_dbg(&ced->interface->dev, "%s: returns %d\n", __func__, iReturn); @@ -1100,7 +1112,7 @@ static void ced_readchar_callback(struct urb *pUrb) int nGot = pUrb->actual_length; /* what we transferred */ if (pUrb->status) { /* Do we have a problem to handle? */ - int nPipe = ced->nPipes == 4 ? 1 : 0; /* The pipe number to use for error */ + int nPipe = ced->n_pipes == 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 @@ -1118,41 +1130,41 @@ static void ced_readchar_callback(struct urb *pUrb) spin_unlock(&ced->err_lock); nGot = 0; /* and tidy up again if so */ - spin_lock(&ced->charInLock); /* already at irq level */ - ced->bPipeError[nPipe] = 1; /* Flag an error for later */ + spin_lock(&ced->char_in_lock); /* already at irq level */ + ced->pipe_error[nPipe] = 1; /* Flag an error for later */ } else { - 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 */ + if ((nGot > 1) && ((ced->coher_char_in[0] & 0x7f) == 0x1b)) { /* Esc sequence? */ + ced_handle_esc(ced, &ced->coher_char_in[1], nGot - 1); /* handle it */ + spin_lock(&ced->char_in_lock); /* already at irq level */ } else { - spin_lock(&ced->charInLock); /* already at irq level */ + spin_lock(&ced->char_in_lock); /* already at irq level */ if (nGot > 0) { unsigned int i; if (nGot < INBUF_SZ) { - ced->pCoherCharIn[nGot] = 0; /* tidy the string */ + ced->coher_char_in[nGot] = 0; /* tidy the string */ dev_dbg(&ced->interface->dev, "%s: got %d chars >%s<\n", __func__, nGot, - ced->pCoherCharIn); + ced->coher_char_in); } /* We know that whatever we read must fit in the input buffer */ for (i = 0; i < nGot; i++) { - ced->inputBuffer[ced->dwInBuffPut++] = - ced->pCoherCharIn[i] & 0x7F; - if (ced->dwInBuffPut >= INBUF_SZ) - ced->dwInBuffPut = 0; + ced->input_buffer[ced->in_buff_put++] = + ced->coher_char_in[i] & 0x7F; + if (ced->in_buff_put >= INBUF_SZ) + ced->in_buff_put = 0; } - if ((ced->dwNumInput + nGot) <= INBUF_SZ) - ced->dwNumInput += nGot; /* Adjust the buffer count accordingly */ + if ((ced->num_input + nGot) <= INBUF_SZ) + ced->num_input += nGot; /* Adjust the buffer count accordingly */ } else dev_dbg(&ced->interface->dev, "%s: read ZLP\n", __func__); } } - ced->bReadCharsPending = false; /* No longer have a pending read */ - spin_unlock(&ced->charInLock); /* already at irq level */ + ced->read_chars_pending = false; /* No longer have a pending read */ + spin_unlock(&ced->char_in_lock); /* already at irq level */ ced_allowi(ced); /* see if we can do the next one */ } @@ -1168,43 +1180,50 @@ int ced_allowi(struct ced_data *ced) { int iReturn = U14ERR_NOERROR; unsigned long flags; - spin_lock_irqsave(&ced->charInLock, flags); /* can be called in multiple contexts */ + + /* can be called in multiple contexts */ + spin_lock_irqsave(&ced->char_in_lock, flags); /* 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 (!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 */ + if (!ced->in_draw_down && /* stop input if */ + !ced->read_chars_pending && /* If no read request outstanding */ + (ced->num_input < (INBUF_SZ / 2)) && /* and there is some space */ + (ced->dma_flag == MODE_CHAR) && /* not doing any DMA */ + (!ced->xfer_waiting) && /* no xfer waiting to start */ (can_accept_io_requests(ced))) { /* and activity is generally OK */ /* then off we go */ - unsigned int nMax = INBUF_SZ - ced->dwNumInput; /* max we could read */ - int nPipe = ced->nPipes == 4 ? 1 : 0; /* The pipe number to use */ + unsigned int nMax = INBUF_SZ - ced->num_input; /* max we could read */ + int nPipe = ced->n_pipes == 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); + __func__, ced->num_input); + + usb_fill_int_urb(ced->urb_char_in, ced->udev, + usb_rcvintpipe(ced->udev, ced->ep_addr[nPipe]), + ced->coher_char_in, nMax, ced_readchar_callback, + ced, ced->interval); + + /* short xfers are OK by default */ + ced->urb_char_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; + + /* in case we need to kill it */ + usb_anchor_urb(ced->urb_char_in, &ced->submitted); + + iReturn = usb_submit_urb(ced->urb_char_in, GFP_ATOMIC); if (iReturn) { - usb_unanchor_urb(ced->pUrbCharIn); /* remove from list of active Urbs */ - ced->bPipeError[nPipe] = 1; /* Flag an error to be handled later */ + usb_unanchor_urb(ced->urb_char_in); /* remove from list of active Urbs */ + ced->pipe_error[nPipe] = 1; /* Flag an error to be handled later */ dev_err(&ced->interface->dev, "%s: submit urb failed: %d\n", __func__, iReturn); } else - ced->bReadCharsPending = true; /* Flag that we are active here */ + ced->read_chars_pending = true; /* Flag that we are active here */ } - spin_unlock_irqrestore(&ced->charInLock, flags); + spin_unlock_irqrestore(&ced->char_in_lock, flags); return iReturn; @@ -1318,7 +1337,7 @@ static long ced_ioctl(struct file *file, unsigned int cmd, unsigned long ulArg) return ced_dbg_stop_loop(ced); case _IOC_NR(IOCTL_CED_FULLRESET): - ced->bForceReset = true; /* Set a flag for a full reset */ + ced->force_reset = true; /* Set a flag for a full reset */ break; case _IOC_NR(IOCTL_CED_SETCIRCULAR): @@ -1378,14 +1397,14 @@ static int ced_probe(struct usb_interface *interface, goto error; for (i = 0; i < MAX_TRANSAREAS; ++i) { /* Initialise the wait queues */ - init_waitqueue_head(&ced->rTransDef[i].event); + init_waitqueue_head(&ced->trans_def[i].event); } /* Put initialises for our stuff here. Note that all of *ced is zero, so */ /* no need to explicitly zero it. */ - spin_lock_init(&ced->charOutLock); - spin_lock_init(&ced->charInLock); - spin_lock_init(&ced->stagedLock); + spin_lock_init(&ced->char_out_lock); + spin_lock_init(&ced->char_in_lock); + spin_lock_init(&ced->staged_lock); /* Initialises from the skeleton stuff */ kref_init(&ced->kref); @@ -1400,9 +1419,9 @@ static int ced_probe(struct usb_interface *interface, bcdDevice = ced->udev->descriptor.bcdDevice; i = (bcdDevice >> 8); if (i == 0) - ced->s1401Type = TYPEU1401; + ced->type = TYPEU1401; else if ((i >= 1) && (i <= 23)) - ced->s1401Type = i + 2; + ced->type = i + 2; else { dev_err(&interface->dev, "%s: Unknown device. bcdDevice = %d\n", __func__, bcdDevice); @@ -1411,53 +1430,55 @@ static int ced_probe(struct usb_interface *interface, /* set up the endpoint information. We only care about the number of EP as */ /* we know that we are dealing with a 1401 device. */ iface_desc = interface->cur_altsetting; - ced->nPipes = iface_desc->desc.bNumEndpoints; + ced->n_pipes = iface_desc->desc.bNumEndpoints; dev_info(&interface->dev, "1401Type=%d with %d End Points\n", - ced->s1401Type, ced->nPipes); - if ((ced->nPipes < 3) || (ced->nPipes > 4)) + ced->type, ced->n_pipes); + if ((ced->n_pipes < 3) || (ced->n_pipes > 4)) goto error; /* Allocate the URBs we hold for performing transfers */ - 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) { + ced->urb_char_out = usb_alloc_urb(0, GFP_KERNEL); /* character output URB */ + ced->urb_char_in = usb_alloc_urb(0, GFP_KERNEL); /* character input URB */ + ced->staged_urb = usb_alloc_urb(0, GFP_KERNEL); /* block transfer URB */ + if (!ced->urb_char_out || !ced->urb_char_in || !ced->staged_urb) { dev_err(&interface->dev, "%s: URB alloc failed\n", __func__); goto error; } - ced->pCoherStagedIO = + ced->coher_staged_io = usb_alloc_coherent(ced->udev, STAGED_SZ, GFP_KERNEL, - &ced->pStagedUrb->transfer_dma); - ced->pCoherCharOut = + &ced->staged_urb->transfer_dma); + ced->coher_char_out = usb_alloc_coherent(ced->udev, OUTBUF_SZ, GFP_KERNEL, - &ced->pUrbCharOut->transfer_dma); - ced->pCoherCharIn = + &ced->urb_char_out->transfer_dma); + ced->coher_char_in = usb_alloc_coherent(ced->udev, INBUF_SZ, GFP_KERNEL, - &ced->pUrbCharIn->transfer_dma); - if (!ced->pCoherCharOut || !ced->pCoherCharIn || !ced->pCoherStagedIO) { + &ced->urb_char_in->transfer_dma); + if (!ced->coher_char_out || !ced->coher_char_in || + !ced->coher_staged_io) { dev_err(&interface->dev, "%s: Coherent buffer alloc failed\n", __func__); goto error; } - for (i = 0; i < ced->nPipes; ++i) { + for (i = 0; i < ced->n_pipes; ++i) { endpoint = &iface_desc->endpoint[i].desc; - ced->epAddr[i] = endpoint->bEndpointAddress; + ced->ep_addr[i] = endpoint->bEndpointAddress; dev_info(&interface->dev, "Pipe %d, ep address %02x\n", - 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, ced->bInterval); + i, ced->ep_addr[i]); + if (((ced->n_pipes == 3) && (i == 0)) || /* if char input end point */ + ((ced->n_pipes == 4) && (i == 1))) { + /* save the endpoint interrupt interval */ + ced->interval = endpoint->bInterval; + dev_info(&interface->dev, "Pipe %d, interval = %d\n", + i, ced->interval); } /* Detect USB2 by checking last ep size (64 if USB1) */ - if (i == ced->nPipes - 1) { /* if this is the last ep (bulk) */ - ced->bIsUSB2 = + if (i == ced->n_pipes - 1) { /* if this is the last ep (bulk) */ + ced->is_usb2 = le16_to_cpu(endpoint->wMaxPacketSize) > 64; dev_info(&ced->interface->dev, "USB%d\n", - ced->bIsUSB2 + 1); + ced->is_usb2 + 1); } } @@ -1522,13 +1543,13 @@ void ced_draw_down(struct ced_data *ced) int time; dev_dbg(&ced->interface->dev, "%s: called\n", __func__); - ced->bInDrawDown = true; + ced->in_draw_down = true; time = usb_wait_anchor_empty_timeout(&ced->submitted, 3000); if (!time) { /* if we timed out we kill the urbs */ usb_kill_anchored_urbs(&ced->submitted); dev_err(&ced->interface->dev, "%s: timed out\n", __func__); } - ced->bInDrawDown = false; + ced->in_draw_down = false; } static int ced_suspend(struct usb_interface *intf, pm_message_t message) diff --git a/drivers/staging/ced1401/usb1401.h b/drivers/staging/ced1401/usb1401.h index cb4e452b5e2..812d0a34a34 100644 --- a/drivers/staging/ced1401/usb1401.h +++ b/drivers/staging/ced1401/usb1401.h @@ -136,65 +136,67 @@ struct dmadesc { bool outward; /* true when data is going TO 1401 */ }; -#define INBUF_SZ 256 /* input buffer size */ -#define OUTBUF_SZ 256 /* output buffer size */ -#define STAGED_SZ 0x10000 /* size of coherent buffer for staged transfers */ +#define INBUF_SZ 256 /* input buffer size */ +#define OUTBUF_SZ 256 /* output buffer size */ +#define STAGED_SZ 0x10000 /* size of coherent buffer for staged transfers */ -/* Structure to hold all of our device specific stuff. We are making this as similar as we */ -/* can to the Windows driver to help in our understanding of what is going on. */ +/* Structure to hold all of our device specific stuff. We are making this as */ +/* similar as we can to the Windows driver to help in our understanding of */ +/* what is going on. */ 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 */ - volatile unsigned int dwInBuffGet; /* where to get from input buffer */ - volatile unsigned int dwInBuffPut; /* where to put into input buffer */ - volatile unsigned int dwNumOutput; /* num of chars in output buffer */ - volatile unsigned int dwOutBuffGet; /* where to get from output buffer*/ - volatile unsigned int dwOutBuffPut; /* where to put into output buffer*/ - - volatile bool bSendCharsPending; /* Flag to indicate sendchar active */ - volatile bool bReadCharsPending; /* Flag to indicate a read is primed */ - char *pCoherCharOut; /* special aligned buffer for chars to 1401 */ - struct urb *pUrbCharOut; /* urb used for chars to 1401 */ - char *pCoherCharIn; /* special aligned buffer for chars to host */ - struct urb *pUrbCharIn; /* urb used for chars to host */ - - spinlock_t charOutLock; /* to protect the outputBuffer and outputting */ - spinlock_t charInLock; /* to protect the inputBuffer and char reads */ - __u8 bInterval; /* Interrupt end point interval */ - - volatile unsigned int dwDMAFlag; /* state of DMA */ - struct transarea rTransDef[MAX_TRANSAREAS]; /* transfer area info */ - volatile struct dmadesc rDMAInfo; /* info on current DMA transfer */ - volatile bool bXFerWaiting; /* Flag set if DMA transfer stalled */ - volatile bool bInDrawDown; /* Flag that we want to halt transfers */ - - /* Parameters relating to a block read\write that is in progress. Some of these values */ - /* are equivalent to values in rDMAInfo. The values here are those in use, while those */ - /* in rDMAInfo are those received from the 1401 via an escape sequence. If another */ - /* escape sequence arrives before the previous xfer ends, rDMAInfo values are updated while these */ - /* are used to finish off the current transfer. */ - volatile short StagedId; /* The transfer area id for this transfer */ - volatile bool StagedRead; /* Flag TRUE for read from 1401, FALSE for write */ - volatile unsigned int StagedLength; /* Total length of this transfer */ - volatile unsigned int StagedOffset; /* Offset within memory area for transfer start */ - volatile unsigned int StagedDone; /* Bytes transferred so far */ - volatile bool bStagedUrbPending; /* Flag to indicate active */ - char *pCoherStagedIO; /* buffer used for block transfers */ - struct urb *pStagedUrb; /* The URB to use */ - spinlock_t stagedLock; /* protects ReadWriteMem() and circular buffer stuff */ - - short s1401Type; /* type of 1401 attached */ - short sCurrentState; /* current error state */ - bool bIsUSB2; /* type of the interface we connect to */ - bool bForceReset; /* Flag to make sure we get a real reset */ - __u32 statBuf[2]; /* buffer for 1401 state info */ - - unsigned long ulSelfTestTime; /* used to timeout self test */ - - int nPipes; /* Should be 3 or 4 depending on 1401 usb chip */ - int bPipeError[4]; /* set non-zero if an error on one of the pipe */ - __u8 epAddr[4]; /* addresses of the 3/4 end points */ + char input_buffer[INBUF_SZ]; /* The two buffers */ + char output_buffer[OUTBUF_SZ]; /* accessed by the host functions */ + volatile unsigned int num_input; /* num of chars in input buffer */ + volatile unsigned int in_buff_get; /* where to get from input buffer */ + volatile unsigned int in_buff_put; /* where to put into input buffer */ + volatile unsigned int num_output; /* num of chars in output buffer */ + volatile unsigned int out_buff_get; /* where to get from output buffer*/ + volatile unsigned int out_buff_put; /* where to put into output buffer*/ + + volatile bool send_chars_pending; /* Flag to indicate sendchar active */ + volatile bool read_chars_pending; /* Flag to indicate a read is primed*/ + char *coher_char_out; /* special aligned buffer for chars to 1401 */ + struct urb *urb_char_out; /* urb used for chars to 1401 */ + char *coher_char_in; /* special aligned buffer for chars to host */ + struct urb *urb_char_in; /* urb used for chars to host */ + + spinlock_t char_out_lock; /* protect the output_buffer and outputting */ + spinlock_t char_in_lock; /* protect the input_buffer and char reads */ + __u8 interval; /* Interrupt end point interval */ + + volatile unsigned int dma_flag; /* state of DMA */ + struct transarea trans_def[MAX_TRANSAREAS]; /* transfer area info */ + volatile struct dmadesc dma_info; /* info on current DMA transfer */ + volatile bool xfer_waiting; /* Flag set if DMA transfer stalled */ + volatile bool in_draw_down; /* Flag that we want to halt transfers */ + + /* Parameters relating to a block read\write that is in progress. Some of these values */ + /* are equivalent to values in dma_info. The values here are those in use, while those */ + /* in dma_info are those received from the 1401 via an escape sequence. If another */ + /* escape sequence arrives before the previous xfer ends, dma_info values are updated while these */ + /* are used to finish off the current transfer. */ + volatile short staged_id; /* The transfer area id for this transfer */ + volatile bool staged_read; /* Flag TRUE for read from 1401, FALSE for write */ + volatile unsigned int staged_length; /* Total length of this transfer */ + volatile unsigned int staged_offset; /* Offset within memory area for transfer start */ + volatile unsigned int staged_done; /* Bytes transferred so far */ + volatile bool staged_urb_pending; /* Flag to indicate active */ + char *coher_staged_io; /* buffer used for block transfers */ + struct urb *staged_urb; /* The URB to use */ + spinlock_t staged_lock; /* protects ReadWriteMem() and */ + /* circular buffer stuff */ + + short type; /* type of 1401 attached */ + short current_state; /* current error state */ + bool is_usb2; /* type of the interface we connect to */ + bool force_reset; /* Flag to make sure we get a real reset */ + __u32 stat_buf[2]; /* buffer for 1401 state info */ + + unsigned long self_test_time; /* used to timeout self test */ + + int n_pipes; /* Should be 3 or 4 depending on 1401 usb chip */ + int pipe_error[4]; /* set non-zero if an error on one of the pipe */ + __u8 ep_addr[4]; /* addresses of the 3/4 end points */ struct usb_device *udev; /* the usb device for this device */ struct usb_interface *interface; /* the interface for this device, NULL if removed */ -- 2.46.0