| /* ced_ioc.c |
| ioctl part of the 1401 usb device driver for linux. |
| Copyright (C) 2010 Cambridge Electronic Design Ltd |
| Author Greg P Smith (greg@ced.co.uk) |
| |
| This program is free software; you can redistribute it and/or |
| modify it under the terms of the GNU General Public License |
| as published by the Free Software Foundation; either version 2 |
| of the License, or (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| */ |
| #include <linux/kernel.h> |
| #include <linux/errno.h> |
| #include <linux/init.h> |
| #include <linux/slab.h> |
| #include <linux/module.h> |
| #include <linux/kref.h> |
| #include <linux/uaccess.h> |
| #include <linux/usb.h> |
| #include <linux/mutex.h> |
| #include <linux/page-flags.h> |
| #include <linux/pagemap.h> |
| #include <linux/jiffies.h> |
| |
| #include "usb1401.h" |
| |
| /**************************************************************************** |
| ** FlushOutBuff |
| ** |
| ** Empties the Output buffer and sets int lines. Used from user level only |
| ****************************************************************************/ |
| void FlushOutBuff(DEVICE_EXTENSION *pdx) |
| { |
| dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__, pdx->sCurrentState); |
| if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ |
| return; |
| // CharSend_Cancel(pdx); /* Kill off any pending I/O */ |
| spin_lock_irq(&pdx->charOutLock); |
| pdx->dwNumOutput = 0; |
| pdx->dwOutBuffGet = 0; |
| pdx->dwOutBuffPut = 0; |
| spin_unlock_irq(&pdx->charOutLock); |
| } |
| |
| /**************************************************************************** |
| ** |
| ** FlushInBuff |
| ** |
| ** Empties the input buffer and sets int lines |
| ****************************************************************************/ |
| void FlushInBuff(DEVICE_EXTENSION *pdx) |
| { |
| dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__, pdx->sCurrentState); |
| if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */ |
| return; |
| // CharRead_Cancel(pDevObject); /* Kill off any pending I/O */ |
| spin_lock_irq(&pdx->charInLock); |
| pdx->dwNumInput = 0; |
| pdx->dwInBuffGet = 0; |
| pdx->dwInBuffPut = 0; |
| spin_unlock_irq(&pdx->charInLock); |
| } |
| |
| /**************************************************************************** |
| ** PutChars |
| ** |
| ** Utility routine to copy chars into the output buffer and fire them off. |
| ** called from user mode, holds charOutLock. |
| ****************************************************************************/ |
| static int PutChars(DEVICE_EXTENSION* pdx, const char* pCh, unsigned int uCount) |
| { |
| int iReturn; |
| spin_lock_irq(&pdx->charOutLock); // get the output spin lock |
| if ((OUTBUF_SZ - pdx->dwNumOutput) >= uCount) |
| { |
| unsigned int u; |
| for (u=0; u<uCount; u++) |
| { |
| pdx->outputBuffer[pdx->dwOutBuffPut++] = pCh[u]; |
| if (pdx->dwOutBuffPut >= OUTBUF_SZ) |
| pdx->dwOutBuffPut = 0; |
| } |
| pdx->dwNumOutput += uCount; |
| spin_unlock_irq(&pdx->charOutLock); |
| iReturn = SendChars(pdx); // ...give a chance to transmit data |
| } |
| else |
| { |
| iReturn = U14ERR_NOOUT; // no room at the out (ha-ha) |
| spin_unlock_irq(&pdx->charOutLock); |
| } |
| return iReturn; |
| } |
| |
| /***************************************************************************** |
| ** Add the data in pData (local pointer) of length n to the output buffer, and |
| ** trigger an output transfer if this is appropriate. User mode. |
| ** Holds the io_mutex |
| *****************************************************************************/ |
| int SendString(DEVICE_EXTENSION* pdx, const char __user* pData, unsigned int n) |
| { |
| int iReturn = U14ERR_NOERROR; // assume all will be well |
| char buffer[OUTBUF_SZ+1]; // space in our address space for characters |
| if (n > OUTBUF_SZ) // check space in local buffer... |
| return U14ERR_NOOUT; // ...too many characters |
| if (copy_from_user(buffer, pData, n)) |
| return -ENOMEM; // could not copy |
| buffer[n] = 0; // terminate for debug purposes |
| |
| mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o |
| if (n > 0) // do nothing if nowt to do! |
| { |
| dev_dbg(&pdx->interface->dev, "%s n=%d>%s<", __func__, n, buffer); |
| iReturn = PutChars(pdx, buffer, n); |
| } |
| |
| Allowi(pdx, false); // make sure we have input int |
| mutex_unlock(&pdx->io_mutex); |
| |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** SendChar |
| ** |
| ** Sends a single character to the 1401. User mode, holds io_mutex. |
| ****************************************************************************/ |
| int SendChar(DEVICE_EXTENSION *pdx, char c) |
| { |
| int iReturn; |
| mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o |
| iReturn = PutChars(pdx, &c, 1); |
| dev_dbg(&pdx->interface->dev,"SendChar >%c< (0x%02x)", c, c); |
| Allowi(pdx, false); // Make sure char reads are running |
| mutex_unlock(&pdx->io_mutex); |
| return iReturn; |
| } |
| |
| /*************************************************************************** |
| ** |
| ** Get1401State |
| ** |
| ** Retrieves state information from the 1401, adjusts the 1401 state held |
| ** in the device extension to indicate the current 1401 type. |
| ** |
| ** *state is updated with information about the 1401 state as returned by the |
| ** 1401. The low byte is a code for what 1401 is doing: |
| ** |
| ** 0 normal 1401 operation |
| ** 1 sending chars to host |
| ** 2 sending block data to host |
| ** 3 reading block data from host |
| ** 4 sending an escape sequence to the host |
| ** 0x80 1401 is executing self-test, in which case the upper word |
| ** is the last error code seen (or zero for no new error). |
| ** |
| ** *error is updated with error information if a self-test error code |
| ** is returned in the upper word of state. |
| ** |
| ** both state and error are set to -1 if there are comms problems, and |
| ** to zero if there is a simple failure. |
| ** |
| ** return error code (U14ERR_NOERROR for OK) |
| */ |
| int Get1401State(DEVICE_EXTENSION* pdx, __u32* state, __u32* error) |
| { |
| int nGot; |
| dev_dbg(&pdx->interface->dev, "Get1401State() entry"); |
| |
| *state = 0xFFFFFFFF; // Start off with invalid state |
| nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), |
| GET_STATUS, (D_TO_H|VENDOR|DEVREQ), 0,0, |
| pdx->statBuf, sizeof(pdx->statBuf), HZ); |
| if (nGot != sizeof(pdx->statBuf)) |
| { |
| dev_err(&pdx->interface->dev, "Get1401State() FAILED, return code %d", nGot); |
| pdx->sCurrentState = U14ERR_TIME; // Indicate that things are very wrong indeed |
| *state = 0; // Force status values to a known state |
| *error = 0; |
| } |
| else |
| { |
| int nDevice; |
| dev_dbg(&pdx->interface->dev, "Get1401State() Success, state: 0x%x, 0x%x", |
| pdx->statBuf[0], pdx->statBuf[1]); |
| |
| *state = pdx->statBuf[0]; // Return the state values to the calling code |
| *error = pdx->statBuf[1]; |
| |
| nDevice = pdx->udev->descriptor.bcdDevice >> 8; // 1401 type code value |
| switch (nDevice) // so we can clean up current state |
| { |
| case 0: |
| pdx->sCurrentState = U14ERR_U1401; |
| break; |
| |
| default: // allow lots of device codes for future 1401s |
| if ((nDevice >= 1) && (nDevice <= 23)) |
| pdx->sCurrentState = (short)(nDevice + 6); |
| else |
| pdx->sCurrentState = U14ERR_ILL; |
| break; |
| } |
| } |
| |
| return pdx->sCurrentState >= 0 ? U14ERR_NOERROR : pdx->sCurrentState; |
| } |
| |
| /**************************************************************************** |
| ** ReadWrite_Cancel |
| ** |
| ** Kills off staged read\write request from the USB if one is pending. |
| ****************************************************************************/ |
| int ReadWrite_Cancel(DEVICE_EXTENSION *pdx) |
| { |
| dev_dbg(&pdx->interface->dev, "ReadWrite_Cancel entry %d", pdx->bStagedUrbPending); |
| #ifdef NOT_WRITTEN_YET |
| int ntStatus = STATUS_SUCCESS; |
| bool bResult = false; |
| unsigned int i; |
| // We can fill this in when we know how we will implement the staged transfer stuff |
| spin_lock_irq(&pdx->stagedLock); |
| |
| if (pdx->bStagedUrbPending) // anything to be cancelled? May need more... |
| { |
| dev_info(&pdx->interface-dev, "ReadWrite_Cancel about to cancel Urb"); |
| |
| // KeClearEvent(&pdx->StagingDoneEvent); // Clear the staging done flag |
| USB_ASSERT(pdx->pStagedIrp != NULL); |
| |
| // Release the spinlock first otherwise the completion routine may hang |
| // on the spinlock while this function hands waiting for the event. |
| spin_unlock_irq(&pdx->stagedLock); |
| bResult = IoCancelIrp(pdx->pStagedIrp); // Actually do the cancel |
| if (bResult) |
| { |
| LARGE_INTEGER timeout; |
| timeout.QuadPart = -10000000; // Use a timeout of 1 second |
| dev_info(&pdx->interface-dev, "ReadWrite_Cancel about to wait till done"); |
| ntStatus = KeWaitForSingleObject(&pdx->StagingDoneEvent, Executive, |
| KernelMode, FALSE, &timeout); |
| } |
| else |
| { |
| dev_info(&pdx->interface-dev, "ReadWrite_Cancel, cancellation failed"); |
| ntStatus = U14ERR_FAIL; |
| } |
| USB_KdPrint(DBGLVL_DEFAULT, ("ReadWrite_Cancel ntStatus = 0x%x decimal %d\n", ntStatus, ntStatus)); |
| } |
| else |
| spin_unlock_irq(&pdx->stagedLock); |
| |
| dev_info(&pdx->interface-dev, "ReadWrite_Cancel done"); |
| return ntStatus; |
| #else |
| return U14ERR_NOERROR; |
| #endif |
| |
| } |
| |
| /*************************************************************************** |
| ** InSelfTest - utility to check in self test. Return 1 for ST, 0 for not or |
| ** a -ve error code if we failed for some reason. |
| ***************************************************************************/ |
| static int InSelfTest(DEVICE_EXTENSION* pdx, unsigned int* pState) |
| { |
| unsigned int state, error; |
| int iReturn = Get1401State(pdx, &state, &error); // see if in self-test |
| if (iReturn == U14ERR_NOERROR) // if all still OK |
| iReturn = (state == (unsigned int)-1) || // TX problem or... |
| ((state & 0xff) == 0x80); // ...self test |
| *pState = state; // return actual state |
| return iReturn; |
| } |
| |
| /*************************************************************************** |
| ** Is1401 - ALWAYS CALLED HOLDING THE io_mutex |
| ** |
| ** Tests for the current state of the 1401. Sets sCurrentState: |
| ** |
| ** U14ERR_NOIF 1401 i/f card not installed (not done here) |
| ** U14ERR_OFF 1401 apparently not switched on |
| ** U14ERR_NC 1401 appears to be not connected |
| ** U14ERR_ILL 1401 if it is there its not very well at all |
| ** U14ERR_TIME 1401 appears OK, but doesn't communicate - very bad |
| ** U14ERR_STD 1401 OK and ready for use |
| ** U14ERR_PLUS 1401+ OK and ready for use |
| ** U14ERR_U1401 Micro1401 OK and ready for use |
| ** U14ERR_POWER Power1401 OK and ready for use |
| ** U14ERR_U14012 Micro1401 mkII OK and ready for use |
| ** |
| ** Returns TRUE if a 1401 detected and OK, else FALSE |
| ****************************************************************************/ |
| bool Is1401(DEVICE_EXTENSION* pdx) |
| { |
| int iReturn; |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| |
| ced_draw_down(pdx); // wait for, then kill outstanding Urbs |
| FlushInBuff(pdx); // Clear out input buffer & pipe |
| FlushOutBuff(pdx); // Clear output buffer & pipe |
| |
| // The next call returns 0 if OK, but has returned 1 in the past, meaning that |
| // usb_unlock_device() is needed... now it always is |
| iReturn = usb_lock_device_for_reset(pdx->udev, pdx->interface); |
| |
| // release the io_mutex because if we don't, we will deadlock due to system |
| // calls back into the driver. |
| mutex_unlock(&pdx->io_mutex); // locked, so we will not get system calls |
| if (iReturn >= 0) // if we failed |
| { |
| iReturn = usb_reset_device(pdx->udev); // try to do the reset |
| usb_unlock_device(pdx->udev); // undo the lock |
| } |
| |
| mutex_lock(&pdx->io_mutex); // hold stuff off while we wait |
| pdx->dwDMAFlag = MODE_CHAR; // Clear DMA mode flag regardless! |
| if (iReturn == 0) // if all is OK still |
| { |
| unsigned int state; |
| iReturn = InSelfTest(pdx, &state); // see if likely in self test |
| if (iReturn > 0) // do we need to wait for self-test? |
| { |
| unsigned long ulTimeOut = jiffies + 30*HZ; // when to give up |
| while((iReturn > 0) && time_before(jiffies, ulTimeOut)) |
| { |
| schedule(); // let other stuff run |
| iReturn = InSelfTest(pdx, &state); // see if done yet |
| } |
| } |
| |
| if (iReturn == 0) // if all is OK... |
| iReturn = state == 0; // then sucess is that the state is 0 |
| } |
| else |
| iReturn = 0; // we failed |
| pdx->bForceReset = false; // Clear forced reset flag now |
| |
| return iReturn > 0; |
| } |
| |
| /**************************************************************************** |
| ** QuickCheck - ALWAYS CALLED HOLDING THE io_mutex |
| ** This is used to test for a 1401. It will try to do a quick check if all is |
| ** OK, that is the 1401 was OK the last time it was asked, and there is no DMA |
| ** in progress, and if the bTestBuff flag is set, the character buffers must be |
| ** empty too. If the quick check shows that the state is still the same, then |
| ** all is OK. |
| ** |
| ** If any of the above conditions are not met, or if the state or type of the |
| ** 1401 has changed since the previous test, the full Is1401 test is done, but |
| ** only if bCanReset is also TRUE. |
| ** |
| ** The return value is TRUE if a useable 1401 is found, FALSE if not |
| */ |
| bool QuickCheck(DEVICE_EXTENSION* pdx, bool bTestBuff, bool bCanReset) |
| { |
| bool bRet = false; // assume it will fail and we will reset |
| bool bShortTest; |
| |
| bShortTest = ((pdx->dwDMAFlag == MODE_CHAR) && // no DMA running |
| (!pdx->bForceReset) && // Not had a real reset forced |
| (pdx->sCurrentState >= U14ERR_STD)); // No 1401 errors stored |
| |
| dev_dbg(&pdx->interface->dev, "%s DMAFlag:%d, state:%d, force:%d, testBuff:%d, short:%d", |
| __func__, pdx->dwDMAFlag, pdx->sCurrentState, pdx->bForceReset, bTestBuff, bShortTest); |
| |
| if ((bTestBuff) && // Buffer check requested, and... |
| (pdx->dwNumInput || pdx->dwNumOutput)) // ...characters were in the buffer? |
| { |
| bShortTest = false; // Then do the full test |
| dev_dbg(&pdx->interface->dev, "%s will reset as buffers not empty", __func__); |
| } |
| |
| if (bShortTest || !bCanReset) // Still OK to try the short test? |
| { // Always test if no reset - we want state update |
| unsigned int state, error; |
| dev_dbg(&pdx->interface->dev, "%s->Get1401State", __func__); |
| if (Get1401State(pdx, &state, &error) == U14ERR_NOERROR) // Check on the 1401 state |
| { |
| if ((state & 0xFF) == 0) // If call worked, check the status value |
| bRet = true; // If that was zero, all is OK, no reset needed |
| } |
| } |
| |
| if (!bRet && bCanReset) // If all not OK, then |
| { |
| dev_info(&pdx->interface->dev, "%s->Is1401 %d %d %d %d", |
| __func__, bShortTest, pdx->sCurrentState, bTestBuff, pdx->bForceReset); |
| bRet = Is1401(pdx); // do full test |
| } |
| |
| return bRet; |
| } |
| |
| /**************************************************************************** |
| ** Reset1401 |
| ** |
| ** Resets the 1401 and empties the i/o buffers |
| *****************************************************************************/ |
| int Reset1401(DEVICE_EXTENSION *pdx) |
| { |
| mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o |
| dev_dbg(&pdx->interface->dev,"ABout to call QuickCheck"); |
| QuickCheck(pdx, true, true); // Check 1401, reset if not OK |
| mutex_unlock(&pdx->io_mutex); |
| return U14ERR_NOERROR; |
| } |
| |
| /**************************************************************************** |
| ** GetChar |
| ** |
| ** Gets a single character from the 1401 |
| ****************************************************************************/ |
| int GetChar(DEVICE_EXTENSION *pdx) |
| { |
| int iReturn = U14ERR_NOIN; // assume we will get nothing |
| mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o |
| |
| dev_dbg(&pdx->interface->dev, "GetChar"); |
| |
| Allowi(pdx, false); // Make sure char reads are running |
| SendChars(pdx); // and send any buffered chars |
| |
| spin_lock_irq(&pdx->charInLock); |
| if (pdx->dwNumInput > 0) // worth looking |
| { |
| iReturn = pdx->inputBuffer[pdx->dwInBuffGet++]; |
| if (pdx->dwInBuffGet >= INBUF_SZ) |
| pdx->dwInBuffGet = 0; |
| pdx->dwNumInput--; |
| } |
| else |
| iReturn = U14ERR_NOIN; // no input data to read |
| spin_unlock_irq(&pdx->charInLock); |
| |
| Allowi(pdx, false); // Make sure char reads are running |
| |
| mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** GetString |
| ** |
| ** Gets a string from the 1401. Returns chars up to the next CR or when |
| ** there are no more to read or nowhere to put them. CR is translated to |
| ** 0 and counted as a character. If the string does not end in a 0, we will |
| ** add one, if there is room, but it is not counted as a character. |
| ** |
| ** returns the count of characters (including the terminator, or 0 if none |
| ** or a negative error code. |
| ****************************************************************************/ |
| int GetString(DEVICE_EXTENSION *pdx, char __user* pUser, int n) |
| { |
| int nAvailable; // character in the buffer |
| int iReturn = U14ERR_NOIN; |
| if (n <= 0) |
| return -ENOMEM; |
| |
| mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o |
| Allowi(pdx, false); // Make sure char reads are running |
| SendChars(pdx); // and send any buffered chars |
| |
| spin_lock_irq(&pdx->charInLock); |
| nAvailable = pdx->dwNumInput; // characters available now |
| if (nAvailable > n) // read max of space in pUser... |
| nAvailable = n; // ...or input characters |
| |
| if (nAvailable > 0) // worth looking? |
| { |
| char buffer[INBUF_SZ+1]; // space for a linear copy of data |
| int nGot = 0; |
| int nCopyToUser; // number to copy to user |
| char cData; |
| do |
| { |
| cData = pdx->inputBuffer[pdx->dwInBuffGet++]; |
| if (cData == CR_CHAR) // replace CR with zero |
| cData = (char)0; |
| |
| if (pdx->dwInBuffGet >= INBUF_SZ) |
| pdx->dwInBuffGet = 0; // wrap buffer pointer |
| |
| buffer[nGot++] = cData; // save the output |
| } |
| while((nGot < nAvailable) && cData); |
| |
| nCopyToUser = nGot; // what to copy... |
| if (cData) // do we need null |
| { |
| buffer[nGot] = (char)0; // make it tidy |
| if (nGot < n) // if space in user buffer... |
| ++nCopyToUser; // ...copy the 0 as well. |
| } |
| |
| pdx->dwNumInput -= nGot; |
| spin_unlock_irq(&pdx->charInLock); |
| |
| dev_dbg(&pdx->interface->dev,"GetString read %d characters >%s<", nGot, buffer); |
| copy_to_user(pUser, buffer, nCopyToUser); |
| |
| iReturn = nGot; // report characters read |
| } |
| else |
| spin_unlock_irq(&pdx->charInLock); |
| |
| Allowi(pdx, false); // Make sure char reads are running |
| mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o |
| |
| return iReturn; |
| } |
| |
| /******************************************************************************* |
| ** Get count of characters in the inout buffer. |
| *******************************************************************************/ |
| int Stat1401(DEVICE_EXTENSION *pdx) |
| { |
| int iReturn; |
| mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o |
| Allowi(pdx, false); // make sure we allow pending chars |
| SendChars(pdx); // in both directions |
| iReturn = pdx->dwNumInput; // no lock as single read |
| mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** LineCount |
| ** |
| ** Returns the number of newline chars in the buffer. There is no need for |
| ** any fancy interlocks as we only read the interrupt routine data, and the |
| ** system is arranged so nothing can be destroyed. |
| ****************************************************************************/ |
| int LineCount(DEVICE_EXTENSION *pdx) |
| { |
| int iReturn = 0; // will be count of line ends |
| |
| mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o |
| Allowi(pdx, false); // Make sure char reads are running |
| SendChars(pdx); // and send any buffered chars |
| spin_lock_irq(&pdx->charInLock); // Get protection |
| |
| if (pdx->dwNumInput > 0) // worth looking? |
| { |
| unsigned int dwIndex = pdx->dwInBuffGet;// start at first available |
| unsigned int dwEnd = pdx->dwInBuffPut; // Position for search end |
| do |
| { |
| if (pdx->inputBuffer[dwIndex++] == CR_CHAR) |
| ++iReturn; // inc count if CR |
| |
| if (dwIndex >= INBUF_SZ) // see if we fall off buff |
| dwIndex = 0; |
| } |
| while (dwIndex != dwEnd); // go to last avaliable |
| } |
| |
| spin_unlock_irq(&pdx->charInLock); |
| dev_dbg(&pdx->interface->dev,"LineCount returned %d", iReturn); |
| mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** GetOutBufSpace |
| ** |
| ** Gets the space in the output buffer. Called from user code. |
| *****************************************************************************/ |
| int GetOutBufSpace(DEVICE_EXTENSION *pdx) |
| { |
| int iReturn; |
| mutex_lock(&pdx->io_mutex); // Protect disconnect from new i/o |
| SendChars(pdx); // send any buffered chars |
| iReturn = (int)(OUTBUF_SZ - pdx->dwNumOutput); // no lock needed for single read |
| dev_dbg(&pdx->interface->dev,"OutBufSpace %d", iReturn); |
| mutex_unlock(&pdx->io_mutex); // Protect disconnect from new i/o |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** |
| ** ClearArea |
| ** |
| ** Clears up a transfer area. This is always called in the context of a user |
| ** request, never from a call-back. |
| ****************************************************************************/ |
| int ClearArea(DEVICE_EXTENSION *pdx, int nArea) |
| { |
| int iReturn = U14ERR_NOERROR; |
| |
| if ((nArea < 0) || (nArea >= MAX_TRANSAREAS)) |
| { |
| iReturn = U14ERR_BADAREA; |
| dev_err(&pdx->interface->dev, "%s Attempt to clear area %d", __func__, nArea); |
| } |
| else |
| { |
| TRANSAREA *pTA = &pdx->rTransDef[nArea]; // to save typing |
| if (!pTA->bUsed) // if not used... |
| iReturn = U14ERR_NOTSET; // ...nothing to be done |
| else |
| { |
| // We must save the memory we return as we shouldn't mess with memory while |
| // holding a spin lock. |
| struct page **pPages = 0; // save page address list |
| int nPages = 0; // and number of pages |
| int np; |
| |
| dev_dbg(&pdx->interface->dev, "%s area %d", __func__, nArea); |
| spin_lock_irq(&pdx->stagedLock); |
| if ((pdx->StagedId == nArea) && (pdx->dwDMAFlag > MODE_CHAR)) |
| { |
| iReturn = U14ERR_UNLOCKFAIL; // cannot delete as in use |
| dev_err(&pdx->interface->dev, "%s call on area %d while active", __func__, nArea); |
| } |
| else |
| { |
| pPages = pTA->pPages; // save page address list |
| nPages = pTA->nPages; // and page count |
| if (pTA->dwEventSz) // if events flagging in use |
| wake_up_interruptible(&pTA->wqEvent); // release anything that was waiting |
| |
| if (pdx->bXFerWaiting && (pdx->rDMAInfo.wIdent == nArea)) |
| pdx->bXFerWaiting = false; // Cannot have pending xfer if area cleared |
| |
| // Clean out the TRANSAREA except for the wait queue, which is at the end |
| // This sets bUsed to false and dwEventSz to 0 to say area not used and no events. |
| memset(pTA, 0, sizeof(TRANSAREA)-sizeof(wait_queue_head_t)); |
| } |
| spin_unlock_irq(&pdx->stagedLock); |
| |
| if (pPages) // if we decided to release the memory |
| { |
| // Now we must undo the pinning down of the pages. We will assume the worst and mark |
| // all the pages as dirty. Don't be tempted to move this up above as you must not be |
| // holding a spin lock to do this stuff as it is not atomic. |
| dev_dbg(&pdx->interface->dev, "%s nPages=%d", __func__, nPages); |
| |
| for (np = 0; np < nPages; ++np) |
| { |
| if (pPages[np]) |
| { |
| SetPageDirty(pPages[np]); |
| page_cache_release(pPages[np]); |
| } |
| } |
| |
| kfree(pPages); |
| dev_dbg(&pdx->interface->dev, "%s kfree(pPages) done", __func__); |
| } |
| } |
| } |
| |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** SetArea |
| ** |
| ** Sets up a transfer area - the functional part. Called by both |
| ** SetTransfer and SetCircular. |
| ****************************************************************************/ |
| static int SetArea(DEVICE_EXTENSION *pdx, int nArea, char __user* puBuf, |
| unsigned int dwLength, bool bCircular, bool bCircToHost) |
| { |
| // Start by working out the page aligned start of the area and the size |
| // of the area in pages, allowing for the start not being aligned and the |
| // end needing to be rounded up to a page boundary. |
| unsigned long ulStart = ((unsigned long)puBuf) & PAGE_MASK; |
| unsigned int ulOffset = ((unsigned long)puBuf) & (PAGE_SIZE-1); |
| int len = (dwLength + ulOffset+PAGE_SIZE - 1) >> PAGE_SHIFT; |
| |
| TRANSAREA *pTA = &pdx->rTransDef[nArea]; // to save typing |
| struct page **pPages = 0; // space for page tables |
| int nPages = 0; // and number of pages |
| |
| int iReturn = ClearArea(pdx, nArea); // see if OK to use this area |
| if ((iReturn != U14ERR_NOTSET) && // if not area unused and... |
| (iReturn != U14ERR_NOERROR)) // ...not all OK, then... |
| return iReturn; // ...we cannot use this area |
| |
| if (!access_ok(VERIFY_WRITE, puBuf, dwLength)) // if we cannot access the memory... |
| return -EFAULT; // ...then we are done |
| |
| // Now allocate space to hold the page pointer and virtual address pointer tables |
| pPages = (struct page **)kmalloc(len*sizeof(struct page *), GFP_KERNEL); |
| if (!pPages) |
| { |
| iReturn = U14ERR_NOMEMORY; |
| goto error; |
| } |
| dev_dbg(&pdx->interface->dev, "%s %p, length=%06x, circular %d", __func__, puBuf, dwLength, bCircular); |
| |
| // To pin down user pages we must first acquire the mapping semaphore. |
| down_read(¤t->mm->mmap_sem); // get memory map semaphore |
| nPages = get_user_pages(current, current->mm, ulStart, len, 1, 0, pPages, 0); |
| up_read(¤t->mm->mmap_sem); // release the semaphore |
| dev_dbg(&pdx->interface->dev, "%s nPages = %d", __func__, nPages); |
| |
| if (nPages > 0) // if we succeeded |
| { |
| // If you are tempted to use page_address (form LDD3), forget it. You MUST use |
| // kmap() or kmap_atomic() to get a virtual address. page_address will give you |
| // (null) or at least it does in this context with an x86 machine. |
| spin_lock_irq(&pdx->stagedLock); |
| pTA->lpvBuff = puBuf; // keep start of region (user address) |
| pTA->dwBaseOffset = ulOffset; // save offset in first page to start of xfer |
| pTA->dwLength = dwLength; // Size if the region in bytes |
| pTA->pPages = pPages; // list of pages that are used by buffer |
| pTA->nPages = nPages; // number of pages |
| |
| pTA->bCircular = bCircular; |
| pTA->bCircToHost = bCircToHost; |
| |
| pTA->aBlocks[0].dwOffset = 0; |
| pTA->aBlocks[0].dwSize = 0; |
| pTA->aBlocks[1].dwOffset = 0; |
| pTA->aBlocks[1].dwSize = 0; |
| pTA->bUsed = true; // This is now a used block |
| |
| spin_unlock_irq(&pdx->stagedLock); |
| iReturn = U14ERR_NOERROR; // say all was well |
| } |
| else |
| { |
| iReturn = U14ERR_LOCKFAIL; |
| goto error; |
| } |
| |
| return iReturn; |
| |
| error: |
| kfree(pPages); |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** SetTransfer |
| ** |
| ** Sets up a transfer area record. If the area is already set, we attempt to |
| ** unset it. Unsetting will fail if the area is booked, and a transfer to that |
| ** area is in progress. Otherwise, we will release the area and re-assign it. |
| ****************************************************************************/ |
| int SetTransfer(DEVICE_EXTENSION *pdx, TRANSFERDESC __user *pTD) |
| { |
| int iReturn; |
| TRANSFERDESC td; |
| copy_from_user(&td, pTD, sizeof(td)); |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev,"%s area:%d, size:%08x", __func__, td.wAreaNum, td.dwLength); |
| // The strange cast is done so that we don't get warnings in 32-bit linux about the size of the |
| // pointer. The pointer is always passed as a 64-bit object so that we don't have problems using |
| // a 32-bit program on a 64-bit system. unsigned long is 64-bits on a 64-bit system. |
| iReturn = SetArea(pdx, td.wAreaNum, (char __user *)((unsigned long)td.lpvBuff), td.dwLength, false, false); |
| mutex_unlock(&pdx->io_mutex); |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** UnSetTransfer |
| ** Erases a transfer area record |
| ****************************************************************************/ |
| int UnsetTransfer(DEVICE_EXTENSION *pdx, int nArea) |
| { |
| int iReturn; |
| mutex_lock(&pdx->io_mutex); |
| iReturn = ClearArea(pdx, nArea); |
| mutex_unlock(&pdx->io_mutex); |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** SetEvent |
| ** Creates an event that we can test for based on a transfer to/from an area. |
| ** The area must be setup for a transfer. We attempt to simulate the Windows |
| ** driver behavior for events (as we don't actually use them), which is to |
| ** pretend that whatever the user asked for was achieved, so we return 1 if |
| ** try to create one, and 0 if they ask to remove (assuming all else was OK). |
| ****************************************************************************/ |
| int SetEvent(DEVICE_EXTENSION *pdx, TRANSFEREVENT __user*pTE) |
| { |
| int iReturn = U14ERR_NOERROR; |
| TRANSFEREVENT te; |
| copy_from_user(&te, pTE, sizeof(te)); // get a local copy of the data |
| if (te.wAreaNum >= MAX_TRANSAREAS) // the area must exist |
| return U14ERR_BADAREA; |
| else |
| { |
| TRANSAREA *pTA = &pdx->rTransDef[te.wAreaNum]; |
| mutex_lock(&pdx->io_mutex); // make sure we have no competitor |
| spin_lock_irq(&pdx->stagedLock); |
| if (pTA->bUsed) // area must be in use |
| { |
| pTA->dwEventSt = te.dwStart; // set area regions |
| pTA->dwEventSz = te.dwLength; // set size (0 cancels it) |
| pTA->bEventToHost = te.wFlags & 1; // set the direction |
| pTA->iWakeUp = 0; // zero the wake up count |
| } |
| else |
| iReturn = U14ERR_NOTSET; |
| spin_unlock_irq(&pdx->stagedLock); |
| mutex_unlock(&pdx->io_mutex); |
| } |
| return iReturn == U14ERR_NOERROR ? (te.iSetEvent ? 1 : U14ERR_NOERROR) : iReturn; |
| } |
| |
| /**************************************************************************** |
| ** WaitEvent |
| ** Sleep the process with a timeout waiting for an event. Returns the number |
| ** of times that a block met the event condition since we last cleared it or |
| ** 0 if timed out, or -ve error (bad area or not set, or signal). |
| ****************************************************************************/ |
| int WaitEvent(DEVICE_EXTENSION *pdx, int nArea, int msTimeOut) |
| { |
| int iReturn; |
| if ((unsigned)nArea > MAX_TRANSAREAS) |
| return U14ERR_BADAREA; |
| else |
| { |
| int iWait; |
| TRANSAREA *pTA = &pdx->rTransDef[nArea]; |
| msTimeOut = (msTimeOut * HZ + 999)/1000; // convert timeout to jiffies |
| |
| // We cannot wait holding the mutex, but we check the flags while holding |
| // it. This may well be pointless as another thread could get in between |
| // releasing it and the wait call. However, this would have to clear the |
| // iWakeUp flag. However, the !pTA-bUsed may help us in this case. |
| mutex_lock(&pdx->io_mutex); // make sure we have no competitor |
| if (!pTA->bUsed || !pTA->dwEventSz) // check something to wait for... |
| return U14ERR_NOTSET; // ...else we do nothing |
| mutex_unlock(&pdx->io_mutex); |
| |
| if (msTimeOut) |
| iWait = wait_event_interruptible_timeout(pTA->wqEvent, pTA->iWakeUp || !pTA->bUsed, msTimeOut); |
| else |
| iWait = wait_event_interruptible(pTA->wqEvent, pTA->iWakeUp || !pTA->bUsed); |
| if (iWait) |
| iReturn = -ERESTARTSYS; // oops - we have had a SIGNAL |
| else |
| iReturn = pTA->iWakeUp; // else the wakeup count |
| |
| spin_lock_irq(&pdx->stagedLock); |
| pTA->iWakeUp = 0; // clear the flag |
| spin_unlock_irq(&pdx->stagedLock); |
| } |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** TestEvent |
| ** Test the event to see if a WaitEvent would return immediately. Returns the |
| ** number of times a block completed since the last call, or 0 if none or a |
| ** negative error. |
| ****************************************************************************/ |
| int TestEvent(DEVICE_EXTENSION *pdx, int nArea) |
| { |
| int iReturn; |
| if ((unsigned)nArea > MAX_TRANSAREAS) |
| iReturn = U14ERR_BADAREA; |
| else |
| { |
| TRANSAREA *pTA = &pdx->rTransDef[nArea]; |
| mutex_lock(&pdx->io_mutex); // make sure we have no competitor |
| spin_lock_irq(&pdx->stagedLock); |
| iReturn = pTA->iWakeUp; // get wakeup count since last call |
| pTA->iWakeUp = 0; // clear the count |
| spin_unlock_irq(&pdx->stagedLock); |
| mutex_unlock(&pdx->io_mutex); |
| } |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** GetTransferInfo |
| ** Puts the current state of the 1401 in a TGET_TX_BLOCK. |
| *****************************************************************************/ |
| int GetTransfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user *pTX) |
| { |
| int iReturn = U14ERR_NOERROR; |
| unsigned int dwIdent; |
| |
| mutex_lock(&pdx->io_mutex); |
| dwIdent = pdx->StagedId; // area ident for last xfer |
| if (dwIdent >= MAX_TRANSAREAS) |
| iReturn = U14ERR_BADAREA; |
| else |
| { |
| // Return the best information we have - we don't have physical addresses |
| TGET_TX_BLOCK tx; |
| memset(&tx, 0, sizeof(tx)); // clean out local work structure |
| tx.size = pdx->rTransDef[dwIdent].dwLength; |
| tx.linear = (long long)((long)pdx->rTransDef[dwIdent].lpvBuff); |
| tx.avail = GET_TX_MAXENTRIES; // how many blocks we could return |
| tx.used = 1; // number we actually return |
| tx.entries[0].physical = (long long)(tx.linear+pdx->StagedOffset); |
| tx.entries[0].size = tx.size; |
| copy_to_user(pTX, &tx, sizeof(tx)); |
| } |
| mutex_unlock(&pdx->io_mutex); |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** KillIO1401 |
| ** |
| ** Empties the host i/o buffers |
| ****************************************************************************/ |
| int KillIO1401(DEVICE_EXTENSION *pdx) |
| { |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| mutex_lock(&pdx->io_mutex); |
| FlushOutBuff(pdx); |
| FlushInBuff(pdx); |
| mutex_unlock(&pdx->io_mutex); |
| return U14ERR_NOERROR; |
| } |
| |
| /**************************************************************************** |
| ** BlkTransState |
| ** Returns a 0 or a 1 for whether DMA is happening. No point holding a mutex |
| ** for this as it only does one read. |
| *****************************************************************************/ |
| int BlkTransState(DEVICE_EXTENSION *pdx) |
| { |
| int iReturn = pdx->dwDMAFlag != MODE_CHAR; |
| dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn); |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** StateOf1401 |
| ** |
| ** Puts the current state of the 1401 in the Irp return buffer. |
| *****************************************************************************/ |
| int StateOf1401(DEVICE_EXTENSION *pdx) |
| { |
| int iReturn; |
| mutex_lock(&pdx->io_mutex); |
| |
| QuickCheck(pdx, false, false); // get state up to date, no reset |
| iReturn = pdx->sCurrentState; |
| |
| mutex_unlock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn); |
| |
| return iReturn; |
| } |
| /**************************************************************************** |
| ** StartSelfTest |
| ** |
| ** Initiates a self-test cycle. The assumption is that we have no interrupts |
| ** active, so we should make sure that this is the case. |
| *****************************************************************************/ |
| int StartSelfTest(DEVICE_EXTENSION *pdx) |
| { |
| int nGot; |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| |
| ced_draw_down(pdx); // wait for, then kill outstanding Urbs |
| FlushInBuff(pdx); // Clear out input buffer & pipe |
| FlushOutBuff(pdx); // Clear output buffer & pipe |
| // ReadWrite_Cancel(pDeviceObject); /* so things stay tidy */ |
| pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flags here */ |
| |
| nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), |
| DB_SELFTEST, (H_TO_D|VENDOR|DEVREQ), 0, 0, |
| 0, 0, HZ); // allow 1 second timeout |
| pdx->ulSelfTestTime = jiffies + HZ*30; // 30 seconds into the future |
| |
| mutex_unlock(&pdx->io_mutex); |
| if (nGot < 0) |
| dev_err(&pdx->interface->dev, "%s err=%d", __func__, nGot); |
| return nGot < 0 ? U14ERR_FAIL : U14ERR_NOERROR; |
| } |
| |
| |
| /**************************************************************************** |
| ** CheckSelfTest |
| ** |
| ** Check progress of a self-test cycle |
| ****************************************************************************/ |
| int CheckSelfTest(DEVICE_EXTENSION *pdx, TGET_SELFTEST __user *pGST) |
| { |
| unsigned int state, error; |
| int iReturn; |
| TGET_SELFTEST gst; // local work space |
| memset(&gst, 0, sizeof(gst)); // clear out the space (sets code 0) |
| |
| mutex_lock(&pdx->io_mutex); |
| |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| iReturn = Get1401State(pdx, &state, &error); |
| if (iReturn == U14ERR_NOERROR) // Only accept zero if it happens twice |
| iReturn = Get1401State(pdx, &state, &error); |
| |
| if (iReturn != U14ERR_NOERROR) // Self-test can cause comms errors |
| { // so we assume still testing |
| dev_err(&pdx->interface->dev, "%s Get1401State=%d, assuming still testing", __func__, iReturn); |
| state = 0x80; // Force still-testing, no error |
| error = 0; |
| iReturn = U14ERR_NOERROR; |
| } |
| |
| if ((state == -1) && (error == -1)) // If Get1401State had problems |
| { |
| dev_err(&pdx->interface->dev, "%s Get1401State failed, assuming still testing", __func__); |
| state = 0x80; // Force still-testing, no error |
| error = 0; |
| } |
| |
| if ((state & 0xFF) == 0x80) // If we are still in self-test |
| { |
| if (state & 0x00FF0000) // Have we got an error? |
| { |
| gst.code = (state & 0x00FF0000) >> 16; // read the error code |
| gst.x = error & 0x0000FFFF; // Error data X |
| gst.y = (error & 0xFFFF0000) >> 16; // and data Y |
| dev_dbg(&pdx->interface->dev,"Self-test error code %d", gst.code); |
| } |
| else // No error, check for timeout |
| { |
| unsigned long ulNow = jiffies; // get current time |
| if (time_after(ulNow, pdx->ulSelfTestTime)) |
| { |
| gst.code = -2; // Flag the timeout |
| dev_dbg(&pdx->interface->dev, "Self-test timed-out"); |
| } |
| else |
| dev_dbg(&pdx->interface->dev, "Self-test on-going"); |
| } |
| } |
| else |
| { |
| gst.code = -1; // Flag the test is done |
| dev_dbg(&pdx->interface->dev, "Self-test done"); |
| } |
| |
| if (gst.code < 0) // If we have a problem or finished |
| { // If using the 2890 we should reset properly |
| if ((pdx->nPipes == 4) && (pdx->s1401Type <= TYPEPOWER)) |
| Is1401(pdx); // Get 1401 reset and OK |
| else |
| QuickCheck(pdx, true, true); // Otherwise check without reset unless problems |
| } |
| mutex_unlock(&pdx->io_mutex); |
| |
| copy_to_user(pGST, &gst, sizeof(gst)); // copy result to user space |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** TypeOf1401 |
| ** |
| ** Returns code for standard, plus, micro1401, power1401 or none |
| ****************************************************************************/ |
| int TypeOf1401(DEVICE_EXTENSION *pdx) |
| { |
| int iReturn = TYPEUNKNOWN; |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| |
| switch (pdx->s1401Type) |
| { |
| case TYPE1401: iReturn = U14ERR_STD; break; // Handle these types directly |
| case TYPEPLUS: iReturn = U14ERR_PLUS; break; |
| case TYPEU1401:iReturn = U14ERR_U1401;break; |
| default: |
| if ((pdx->s1401Type >= TYPEPOWER) && |
| (pdx->s1401Type <= 25)) |
| iReturn = pdx->s1401Type + 4; // We can calculate types |
| else // for up-coming 1401 designs |
| iReturn = TYPEUNKNOWN; // Don't know or not there |
| } |
| dev_dbg(&pdx->interface->dev, "%s %d", __func__, iReturn); |
| mutex_unlock(&pdx->io_mutex); |
| |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** TransferFlags |
| ** |
| ** Returns flags on block transfer abilities |
| ****************************************************************************/ |
| int TransferFlags(DEVICE_EXTENSION *pdx) |
| { |
| int iReturn = U14TF_MULTIA | U14TF_DIAG | // we always have multiple DMA area |
| U14TF_NOTIFY | U14TF_CIRCTH; // diagnostics, notify and circular |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| mutex_lock(&pdx->io_mutex); |
| if (pdx->bIsUSB2) // Set flag for USB2 if appropriate |
| iReturn |= U14TF_USB2; |
| mutex_unlock(&pdx->io_mutex); |
| |
| return iReturn; |
| } |
| |
| /*************************************************************************** |
| ** DbgCmd1401 |
| ** Issues a debug\diagnostic command to the 1401 along with a 32-bit datum |
| ** This is a utility command used for dbg operations. |
| */ |
| static int DbgCmd1401(DEVICE_EXTENSION *pdx, unsigned char cmd, unsigned int data) |
| { |
| int iReturn; |
| dev_dbg(&pdx->interface->dev, "%s entry", __func__); |
| iReturn = usb_control_msg(pdx->udev, usb_sndctrlpipe(pdx->udev, 0), |
| cmd, (H_TO_D|VENDOR|DEVREQ), |
| (unsigned short)data, (unsigned short)(data >> 16), |
| 0, 0, HZ); // allow 1 second timeout |
| if (iReturn < 0) |
| dev_err(&pdx->interface->dev, "%s fail code=%d", __func__, iReturn); |
| |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** DbgPeek |
| ** |
| ** Execute the diagnostic peek operation. Uses address, width and repeats. |
| ****************************************************************************/ |
| int DbgPeek(DEVICE_EXTENSION *pdx, TDBGBLOCK __user* pDB) |
| { |
| int iReturn; |
| TDBGBLOCK db; |
| copy_from_user(&db, pDB, sizeof(db)); // get the data |
| |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr); |
| |
| iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_PEEK, 0); |
| mutex_unlock(&pdx->io_mutex); |
| |
| return iReturn; |
| } |
| |
| |
| /**************************************************************************** |
| ** DbgPoke |
| ** |
| ** Execute the diagnostic poke operation. Parameters are in the CSBLOCK struct |
| ** in order address, size, repeats and value to poke. |
| ****************************************************************************/ |
| int DbgPoke(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) |
| { |
| int iReturn; |
| TDBGBLOCK db; |
| copy_from_user(&db, pDB, sizeof(db)); // get the data |
| |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr); |
| |
| iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_POKE, db.iData); |
| mutex_unlock(&pdx->io_mutex); |
| |
| return iReturn; |
| } |
| |
| |
| /**************************************************************************** |
| ** DbgRampData |
| ** |
| ** Execute the diagnostic ramp data operation. Parameters are in the CSBLOCK struct |
| ** in order address, default, enable mask, size and repeats. |
| ****************************************************************************/ |
| int DbgRampData(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) |
| { |
| int iReturn; |
| TDBGBLOCK db; |
| copy_from_user(&db, pDB, sizeof(db)); // get the data |
| |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr); |
| |
| iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_SETDEF, db.iDefault); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_SETMASK, db.iMask); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_RAMPD, 0); |
| mutex_unlock(&pdx->io_mutex); |
| |
| return iReturn; |
| } |
| |
| |
| /**************************************************************************** |
| ** DbgRampAddr |
| ** |
| ** Execute the diagnostic ramp address operation |
| ****************************************************************************/ |
| int DbgRampAddr(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) |
| { |
| int iReturn; |
| TDBGBLOCK db; |
| copy_from_user(&db, pDB, sizeof(db)); // get the data |
| |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| |
| iReturn = DbgCmd1401(pdx, DB_SETDEF, db.iDefault); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_SETMASK, db.iMask); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats); |
| if (iReturn == U14ERR_NOERROR) |
| iReturn = DbgCmd1401(pdx, DB_RAMPA, 0); |
| mutex_unlock(&pdx->io_mutex); |
| |
| return iReturn; |
| } |
| |
| |
| /**************************************************************************** |
| ** DbgGetData |
| ** |
| ** Retrieve the data resulting from the last debug Peek operation |
| ****************************************************************************/ |
| int DbgGetData(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB) |
| { |
| int iReturn; |
| TDBGBLOCK db; |
| memset(&db, 0, sizeof(db)); // fill returned block with 0s |
| |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| |
| // Read back the last peeked value from the 1401. |
| iReturn = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0), |
| DB_DATA, (D_TO_H|VENDOR|DEVREQ), 0,0, |
| &db.iData, sizeof(db.iData), HZ); |
| if (iReturn == sizeof(db.iData)) |
| { |
| copy_to_user(pDB, &db, sizeof(db)); |
| iReturn = U14ERR_NOERROR; |
| } |
| else |
| dev_err(&pdx->interface->dev, "%s failed, code %d", __func__, iReturn); |
| |
| mutex_unlock(&pdx->io_mutex); |
| |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** DbgStopLoop |
| ** |
| ** Stop any never-ending debug loop, we just call Get1401State for USB |
| ** |
| ****************************************************************************/ |
| int DbgStopLoop(DEVICE_EXTENSION *pdx) |
| { |
| int iReturn; |
| unsigned int uState, uErr; |
| |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| iReturn = Get1401State(pdx, &uState, &uErr); |
| mutex_unlock(&pdx->io_mutex); |
| |
| return iReturn; |
| } |
| |
| |
| /**************************************************************************** |
| ** SetCircular |
| ** |
| ** Sets up a transfer area record for circular transfers. If the area is |
| ** already set, we attempt to unset it. Unsetting will fail if the area is |
| ** booked and a transfer to that area is in progress. Otherwise, we will |
| ** release the area and re-assign it. |
| ****************************************************************************/ |
| int SetCircular(DEVICE_EXTENSION *pdx, TRANSFERDESC __user *pTD) |
| { |
| int iReturn; |
| bool bToHost; |
| TRANSFERDESC td; |
| copy_from_user(&td, pTD, sizeof(td)); |
| mutex_lock(&pdx->io_mutex); |
| dev_dbg(&pdx->interface->dev,"%s area:%d, size:%08x", __func__, td.wAreaNum, td.dwLength); |
| bToHost = td.eSize != 0; // this is used as the tohost flag |
| |
| // The strange cast is done so that we don't get warnings in 32-bit linux about the size of the |
| // pointer. The pointer is always passed as a 64-bit object so that we don't have problems using |
| // a 32-bit program on a 64-bit system. unsigned long is 64-bits on a 64-bit system. |
| iReturn = SetArea(pdx, td.wAreaNum, (char __user *)((unsigned long)td.lpvBuff), td.dwLength, true, bToHost); |
| mutex_unlock(&pdx->io_mutex); |
| return iReturn; |
| } |
| |
| /**************************************************************************** |
| ** GetCircBlock |
| ** |
| ** Return the next available block of circularly-transferred data. |
| ****************************************************************************/ |
| int GetCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user* pCB) |
| { |
| int iReturn = U14ERR_NOERROR; |
| unsigned int nArea; |
| TCIRCBLOCK cb; |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| copy_from_user(&cb, pCB, sizeof(cb)); |
| mutex_lock(&pdx->io_mutex); |
| |
| nArea = cb.nArea; // Retrieve parameters first |
| cb.dwOffset = 0; // set default result (nothing) |
| cb.dwSize = 0; |
| |
| if (nArea < MAX_TRANSAREAS) // The area number must be OK |
| { |
| TRANSAREA* pArea = &pdx->rTransDef[nArea]; // Pointer to relevant info |
| spin_lock_irq(&pdx->stagedLock); // Lock others out |
| |
| if ((pArea->bUsed) && (pArea->bCircular) && // Must be circular area |
| (pArea->bCircToHost)) // For now at least must be to host |
| { |
| if (pArea->aBlocks[0].dwSize > 0) // Got anything? |
| { |
| cb.dwOffset = pArea->aBlocks[0].dwOffset; |
| cb.dwSize = pArea->aBlocks[0].dwSize; |
| dev_dbg(&pdx->interface->dev, "%s return block 0: %d bytes at %d", __func__, cb.dwSize, cb.dwOffset); |
| } |
| } |
| else |
| iReturn = U14ERR_NOTSET; |
| |
| spin_unlock_irq(&pdx->stagedLock); |
| } |
| else |
| iReturn = U14ERR_BADAREA; |
| |
| copy_to_user(pCB, &cb, sizeof(cb)); |
| mutex_unlock(&pdx->io_mutex); |
| return iReturn; |
| } |
| |
| |
| /**************************************************************************** |
| ** FreeCircBlock |
| ** |
| ** Frees a block of circularly-transferred data and returns the next one. |
| ****************************************************************************/ |
| int FreeCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user* pCB) |
| { |
| int iReturn = U14ERR_NOERROR; |
| unsigned int nArea, uStart, uSize; |
| TCIRCBLOCK cb; |
| dev_dbg(&pdx->interface->dev, "%s", __func__); |
| copy_from_user(&cb, pCB, sizeof(cb)); |
| mutex_lock(&pdx->io_mutex); |
| |
| nArea = cb.nArea; // Retrieve parameters first |
| uStart = cb.dwOffset; |
| uSize = cb.dwSize; |
| cb.dwOffset = 0; // then set default result (nothing) |
| cb.dwSize = 0; |
| |
| if (nArea < MAX_TRANSAREAS) // The area number must be OK |
| { |
| TRANSAREA* pArea = &pdx->rTransDef[nArea]; // Pointer to relevant info |
| spin_lock_irq(&pdx->stagedLock); // Lock others out |
| |
| if ((pArea->bUsed) && (pArea->bCircular) && // Must be circular area |
| (pArea->bCircToHost)) // For now at least must be to host |
| { |
| bool bWaiting = false; |
| |
| if ((pArea->aBlocks[0].dwSize >= uSize) && // Got anything? |
| (pArea->aBlocks[0].dwOffset == uStart)) // Must be legal data |
| { |
| pArea->aBlocks[0].dwSize -= uSize; |
| pArea->aBlocks[0].dwOffset += uSize; |
| if (pArea->aBlocks[0].dwSize == 0) // Have we emptied this block? |
| { |
| if (pArea->aBlocks[1].dwSize) // Is there a second block? |
| { |
| pArea->aBlocks[0] = pArea->aBlocks[1]; // Copy down block 2 data |
| pArea->aBlocks[1].dwSize = 0; // and mark the second block as unused |
| pArea->aBlocks[1].dwOffset = 0; |
| } |
| else |
| pArea->aBlocks[0].dwOffset = 0; |
| } |
| |
| dev_dbg(&pdx->interface->dev, "%s free %d bytes at %d, return %d bytes at %d, wait=%d", |
| __func__, uSize, uStart, pArea->aBlocks[0].dwSize, pArea->aBlocks[0].dwOffset, pdx->bXFerWaiting); |
| |
| // Return the next available block of memory as well |
| if (pArea->aBlocks[0].dwSize > 0) // Got anything? |
| { |
| cb.dwOffset = pArea->aBlocks[0].dwOffset; |
| cb.dwSize = pArea->aBlocks[0].dwSize; |
| } |
| |
| bWaiting = pdx->bXFerWaiting; |
| if (bWaiting && pdx->bStagedUrbPending) |
| { |
| dev_err(&pdx->interface->dev, "%s ERROR: waiting xfer and staged Urb pending!", __func__); |
| bWaiting = false; |
| } |
| } |
| else |
| { |
| dev_err(&pdx->interface->dev, "%s ERROR: freeing %d bytes at %d, block 0 is %d bytes at %d", |
| __func__, uSize, uStart, pArea->aBlocks[0].dwSize, pArea->aBlocks[0].dwOffset); |
| iReturn = U14ERR_NOMEMORY; |
| } |
| |
| // If we have one, kick off pending transfer |
| if (bWaiting) // Got a block xfer waiting? |
| { |
| int RWMStat = ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard, |
| pdx->rDMAInfo.wIdent, pdx->rDMAInfo.dwOffset, pdx->rDMAInfo.dwSize); |
| if (RWMStat != U14ERR_NOERROR) |
| dev_err(&pdx->interface->dev, "%s rw setup failed %d", __func__, RWMStat); |
| } |
| } |
| else |
| iReturn = U14ERR_NOTSET; |
| |
| spin_unlock_irq(&pdx->stagedLock); |
| } |
| else |
| iReturn = U14ERR_BADAREA; |
| |
| copy_to_user(pCB, &cb, sizeof(cb)); |
| mutex_unlock(&pdx->io_mutex); |
| return iReturn; |
| } |
| |
| |
| |