2 ioctl part of the 1401 usb device driver for linux.
3 Copyright (C) 2010 Cambridge Electronic Design Ltd
4 Author Greg P Smith (greg@ced.co.uk)
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation; either version 2
9 of the License, or (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/module.h>
25 #include <linux/kref.h>
26 #include <linux/uaccess.h>
27 #include <linux/usb.h>
28 #include <linux/mutex.h>
29 #include <linux/page-flags.h>
30 #include <linux/pagemap.h>
31 #include <linux/jiffies.h>
35 /****************************************************************************
38 ** Empties the Output buffer and sets int lines. Used from user level only
39 ****************************************************************************/
40 static void FlushOutBuff(DEVICE_EXTENSION *pdx)
42 dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__,
44 if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */
46 /* Kill off any pending I/O */
47 /* CharSend_Cancel(pdx); */
48 spin_lock_irq(&pdx->charOutLock);
50 pdx->dwOutBuffGet = 0;
51 pdx->dwOutBuffPut = 0;
52 spin_unlock_irq(&pdx->charOutLock);
55 /****************************************************************************
59 ** Empties the input buffer and sets int lines
60 ****************************************************************************/
61 static void FlushInBuff(DEVICE_EXTENSION *pdx)
63 dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__,
65 if (pdx->sCurrentState == U14ERR_TIME) /* Do nothing if hardware in trouble */
67 /* Kill off any pending I/O */
68 /* CharRead_Cancel(pDevObject); */
69 spin_lock_irq(&pdx->charInLock);
73 spin_unlock_irq(&pdx->charInLock);
76 /****************************************************************************
79 ** Utility routine to copy chars into the output buffer and fire them off.
80 ** called from user mode, holds charOutLock.
81 ****************************************************************************/
82 static int PutChars(DEVICE_EXTENSION *pdx, const char *pCh,
86 spin_lock_irq(&pdx->charOutLock); /* get the output spin lock */
87 if ((OUTBUF_SZ - pdx->dwNumOutput) >= uCount) {
89 for (u = 0; u < uCount; u++) {
90 pdx->outputBuffer[pdx->dwOutBuffPut++] = pCh[u];
91 if (pdx->dwOutBuffPut >= OUTBUF_SZ)
92 pdx->dwOutBuffPut = 0;
94 pdx->dwNumOutput += uCount;
95 spin_unlock_irq(&pdx->charOutLock);
96 iReturn = SendChars(pdx); /* ...give a chance to transmit data */
98 iReturn = U14ERR_NOOUT; /* no room at the out (ha-ha) */
99 spin_unlock_irq(&pdx->charOutLock);
104 /*****************************************************************************
105 ** Add the data in pData (local pointer) of length n to the output buffer, and
106 ** trigger an output transfer if this is appropriate. User mode.
107 ** Holds the io_mutex
108 *****************************************************************************/
109 int SendString(DEVICE_EXTENSION *pdx, const char __user *pData,
112 int iReturn = U14ERR_NOERROR; /* assume all will be well */
113 char buffer[OUTBUF_SZ + 1]; /* space in our address space for characters */
114 if (n > OUTBUF_SZ) /* check space in local buffer... */
115 return U14ERR_NOOUT; /* ...too many characters */
116 if (copy_from_user(buffer, pData, n))
118 buffer[n] = 0; /* terminate for debug purposes */
120 mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
121 if (n > 0) { /* do nothing if nowt to do! */
122 dev_dbg(&pdx->interface->dev, "%s n=%d>%s<", __func__, n,
124 iReturn = PutChars(pdx, buffer, n);
127 Allowi(pdx); /* make sure we have input int */
128 mutex_unlock(&pdx->io_mutex);
133 /****************************************************************************
136 ** Sends a single character to the 1401. User mode, holds io_mutex.
137 ****************************************************************************/
138 int SendChar(DEVICE_EXTENSION *pdx, char c)
141 mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
142 iReturn = PutChars(pdx, &c, 1);
143 dev_dbg(&pdx->interface->dev, "SendChar >%c< (0x%02x)", c, c);
144 Allowi(pdx); /* Make sure char reads are running */
145 mutex_unlock(&pdx->io_mutex);
149 /***************************************************************************
153 ** Retrieves state information from the 1401, adjusts the 1401 state held
154 ** in the device extension to indicate the current 1401 type.
156 ** *state is updated with information about the 1401 state as returned by the
157 ** 1401. The low byte is a code for what 1401 is doing:
159 ** 0 normal 1401 operation
160 ** 1 sending chars to host
161 ** 2 sending block data to host
162 ** 3 reading block data from host
163 ** 4 sending an escape sequence to the host
164 ** 0x80 1401 is executing self-test, in which case the upper word
165 ** is the last error code seen (or zero for no new error).
167 ** *error is updated with error information if a self-test error code
168 ** is returned in the upper word of state.
170 ** both state and error are set to -1 if there are comms problems, and
171 ** to zero if there is a simple failure.
173 ** return error code (U14ERR_NOERROR for OK)
175 int Get1401State(DEVICE_EXTENSION *pdx, __u32 *state, __u32 *error)
178 dev_dbg(&pdx->interface->dev, "Get1401State() entry");
180 *state = 0xFFFFFFFF; /* Start off with invalid state */
181 nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0),
182 GET_STATUS, (D_TO_H | VENDOR | DEVREQ), 0, 0,
183 pdx->statBuf, sizeof(pdx->statBuf), HZ);
184 if (nGot != sizeof(pdx->statBuf)) {
185 dev_err(&pdx->interface->dev,
186 "Get1401State() FAILED, return code %d", nGot);
187 pdx->sCurrentState = U14ERR_TIME; /* Indicate that things are very wrong indeed */
188 *state = 0; /* Force status values to a known state */
192 dev_dbg(&pdx->interface->dev,
193 "Get1401State() Success, state: 0x%x, 0x%x",
194 pdx->statBuf[0], pdx->statBuf[1]);
196 *state = pdx->statBuf[0]; /* Return the state values to the calling code */
197 *error = pdx->statBuf[1];
199 nDevice = pdx->udev->descriptor.bcdDevice >> 8; /* 1401 type code value */
200 switch (nDevice) { /* so we can clean up current state */
202 pdx->sCurrentState = U14ERR_U1401;
205 default: /* allow lots of device codes for future 1401s */
206 if ((nDevice >= 1) && (nDevice <= 23))
207 pdx->sCurrentState = (short)(nDevice + 6);
209 pdx->sCurrentState = U14ERR_ILL;
214 return pdx->sCurrentState >= 0 ? U14ERR_NOERROR : pdx->sCurrentState;
217 /****************************************************************************
220 ** Kills off staged read\write request from the USB if one is pending.
221 ****************************************************************************/
222 int ReadWrite_Cancel(DEVICE_EXTENSION *pdx)
224 dev_dbg(&pdx->interface->dev, "ReadWrite_Cancel entry %d",
225 pdx->bStagedUrbPending);
226 #ifdef NOT_WRITTEN_YET
227 int ntStatus = STATUS_SUCCESS;
228 bool bResult = false;
230 /* We can fill this in when we know how we will implement the staged transfer stuff */
231 spin_lock_irq(&pdx->stagedLock);
233 if (pdx->bStagedUrbPending) { /* anything to be cancelled? May need more... */
234 dev_info(&pdx->interface - dev,
235 "ReadWrite_Cancel about to cancel Urb");
236 /* Clear the staging done flag */
237 /* KeClearEvent(&pdx->StagingDoneEvent); */
238 USB_ASSERT(pdx->pStagedIrp != NULL);
240 /* Release the spinlock first otherwise the completion routine may hang */
241 /* on the spinlock while this function hands waiting for the event. */
242 spin_unlock_irq(&pdx->stagedLock);
243 bResult = IoCancelIrp(pdx->pStagedIrp); /* Actually do the cancel */
245 LARGE_INTEGER timeout;
246 timeout.QuadPart = -10000000; /* Use a timeout of 1 second */
247 dev_info(&pdx->interface - dev,
248 "ReadWrite_Cancel about to wait till done");
250 KeWaitForSingleObject(&pdx->StagingDoneEvent,
251 Executive, KernelMode, FALSE,
254 dev_info(&pdx->interface - dev,
255 "ReadWrite_Cancel, cancellation failed");
256 ntStatus = U14ERR_FAIL;
258 USB_KdPrint(DBGLVL_DEFAULT,
259 ("ReadWrite_Cancel ntStatus = 0x%x decimal %d\n",
260 ntStatus, ntStatus));
262 spin_unlock_irq(&pdx->stagedLock);
264 dev_info(&pdx->interface - dev, "ReadWrite_Cancel done");
267 return U14ERR_NOERROR;
272 /***************************************************************************
273 ** InSelfTest - utility to check in self test. Return 1 for ST, 0 for not or
274 ** a -ve error code if we failed for some reason.
275 ***************************************************************************/
276 static int InSelfTest(DEVICE_EXTENSION *pdx, unsigned int *pState)
278 unsigned int state, error;
279 int iReturn = Get1401State(pdx, &state, &error); /* see if in self-test */
280 if (iReturn == U14ERR_NOERROR) /* if all still OK */
281 iReturn = (state == (unsigned int)-1) || /* TX problem or... */
282 ((state & 0xff) == 0x80); /* ...self test */
283 *pState = state; /* return actual state */
287 /***************************************************************************
288 ** Is1401 - ALWAYS CALLED HOLDING THE io_mutex
290 ** Tests for the current state of the 1401. Sets sCurrentState:
292 ** U14ERR_NOIF 1401 i/f card not installed (not done here)
293 ** U14ERR_OFF 1401 apparently not switched on
294 ** U14ERR_NC 1401 appears to be not connected
295 ** U14ERR_ILL 1401 if it is there its not very well at all
296 ** U14ERR_TIME 1401 appears OK, but doesn't communicate - very bad
297 ** U14ERR_STD 1401 OK and ready for use
298 ** U14ERR_PLUS 1401+ OK and ready for use
299 ** U14ERR_U1401 Micro1401 OK and ready for use
300 ** U14ERR_POWER Power1401 OK and ready for use
301 ** U14ERR_U14012 Micro1401 mkII OK and ready for use
303 ** Returns TRUE if a 1401 detected and OK, else FALSE
304 ****************************************************************************/
305 bool Is1401(DEVICE_EXTENSION *pdx)
308 dev_dbg(&pdx->interface->dev, "%s", __func__);
310 ced_draw_down(pdx); /* wait for, then kill outstanding Urbs */
311 FlushInBuff(pdx); /* Clear out input buffer & pipe */
312 FlushOutBuff(pdx); /* Clear output buffer & pipe */
314 /* The next call returns 0 if OK, but has returned 1 in the past, meaning that */
315 /* usb_unlock_device() is needed... now it always is */
316 iReturn = usb_lock_device_for_reset(pdx->udev, pdx->interface);
318 /* release the io_mutex because if we don't, we will deadlock due to system */
319 /* calls back into the driver. */
320 mutex_unlock(&pdx->io_mutex); /* locked, so we will not get system calls */
321 if (iReturn >= 0) { /* if we failed */
322 iReturn = usb_reset_device(pdx->udev); /* try to do the reset */
323 usb_unlock_device(pdx->udev); /* undo the lock */
326 mutex_lock(&pdx->io_mutex); /* hold stuff off while we wait */
327 pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flag regardless! */
328 if (iReturn == 0) { /* if all is OK still */
330 iReturn = InSelfTest(pdx, &state); /* see if likely in self test */
331 if (iReturn > 0) { /* do we need to wait for self-test? */
332 unsigned long ulTimeOut = jiffies + 30 * HZ; /* when to give up */
333 while ((iReturn > 0) && time_before(jiffies, ulTimeOut)) {
334 schedule(); /* let other stuff run */
335 iReturn = InSelfTest(pdx, &state); /* see if done yet */
339 if (iReturn == 0) /* if all is OK... */
340 iReturn = state == 0; /* then success is that the state is 0 */
342 iReturn = 0; /* we failed */
343 pdx->bForceReset = false; /* Clear forced reset flag now */
348 /****************************************************************************
349 ** QuickCheck - ALWAYS CALLED HOLDING THE io_mutex
350 ** This is used to test for a 1401. It will try to do a quick check if all is
351 ** OK, that is the 1401 was OK the last time it was asked, and there is no DMA
352 ** in progress, and if the bTestBuff flag is set, the character buffers must be
353 ** empty too. If the quick check shows that the state is still the same, then
356 ** If any of the above conditions are not met, or if the state or type of the
357 ** 1401 has changed since the previous test, the full Is1401 test is done, but
358 ** only if bCanReset is also TRUE.
360 ** The return value is TRUE if a useable 1401 is found, FALSE if not
362 bool QuickCheck(DEVICE_EXTENSION *pdx, bool bTestBuff, bool bCanReset)
364 bool bRet = false; /* assume it will fail and we will reset */
367 bShortTest = ((pdx->dwDMAFlag == MODE_CHAR) && /* no DMA running */
368 (!pdx->bForceReset) && /* Not had a real reset forced */
369 (pdx->sCurrentState >= U14ERR_STD)); /* No 1401 errors stored */
371 dev_dbg(&pdx->interface->dev,
372 "%s DMAFlag:%d, state:%d, force:%d, testBuff:%d, short:%d",
373 __func__, pdx->dwDMAFlag, pdx->sCurrentState, pdx->bForceReset,
374 bTestBuff, bShortTest);
376 if ((bTestBuff) && /* Buffer check requested, and... */
377 (pdx->dwNumInput || pdx->dwNumOutput)) { /* ...characters were in the buffer? */
378 bShortTest = false; /* Then do the full test */
379 dev_dbg(&pdx->interface->dev,
380 "%s will reset as buffers not empty", __func__);
383 if (bShortTest || !bCanReset) { /* Still OK to try the short test? */
384 /* Always test if no reset - we want state update */
385 unsigned int state, error;
386 dev_dbg(&pdx->interface->dev, "%s->Get1401State", __func__);
387 if (Get1401State(pdx, &state, &error) == U14ERR_NOERROR) { /* Check on the 1401 state */
388 if ((state & 0xFF) == 0) /* If call worked, check the status value */
389 bRet = true; /* If that was zero, all is OK, no reset needed */
393 if (!bRet && bCanReset) { /* If all not OK, then */
394 dev_info(&pdx->interface->dev, "%s->Is1401 %d %d %d %d",
395 __func__, bShortTest, pdx->sCurrentState, bTestBuff,
397 bRet = Is1401(pdx); /* do full test */
403 /****************************************************************************
406 ** Resets the 1401 and empties the i/o buffers
407 *****************************************************************************/
408 int Reset1401(DEVICE_EXTENSION *pdx)
410 mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
411 dev_dbg(&pdx->interface->dev, "ABout to call QuickCheck");
412 QuickCheck(pdx, true, true); /* Check 1401, reset if not OK */
413 mutex_unlock(&pdx->io_mutex);
414 return U14ERR_NOERROR;
417 /****************************************************************************
420 ** Gets a single character from the 1401
421 ****************************************************************************/
422 int GetChar(DEVICE_EXTENSION *pdx)
424 int iReturn = U14ERR_NOIN; /* assume we will get nothing */
425 mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
427 dev_dbg(&pdx->interface->dev, "GetChar");
429 Allowi(pdx); /* Make sure char reads are running */
430 SendChars(pdx); /* and send any buffered chars */
432 spin_lock_irq(&pdx->charInLock);
433 if (pdx->dwNumInput > 0) { /* worth looking */
434 iReturn = pdx->inputBuffer[pdx->dwInBuffGet++];
435 if (pdx->dwInBuffGet >= INBUF_SZ)
436 pdx->dwInBuffGet = 0;
439 iReturn = U14ERR_NOIN; /* no input data to read */
440 spin_unlock_irq(&pdx->charInLock);
442 Allowi(pdx); /* Make sure char reads are running */
444 mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
448 /****************************************************************************
451 ** Gets a string from the 1401. Returns chars up to the next CR or when
452 ** there are no more to read or nowhere to put them. CR is translated to
453 ** 0 and counted as a character. If the string does not end in a 0, we will
454 ** add one, if there is room, but it is not counted as a character.
456 ** returns the count of characters (including the terminator, or 0 if none
457 ** or a negative error code.
458 ****************************************************************************/
459 int GetString(DEVICE_EXTENSION *pdx, char __user *pUser, int n)
461 int nAvailable; /* character in the buffer */
462 int iReturn = U14ERR_NOIN;
466 mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
467 Allowi(pdx); /* Make sure char reads are running */
468 SendChars(pdx); /* and send any buffered chars */
470 spin_lock_irq(&pdx->charInLock);
471 nAvailable = pdx->dwNumInput; /* characters available now */
472 if (nAvailable > n) /* read max of space in pUser... */
473 nAvailable = n; /* ...or input characters */
475 if (nAvailable > 0) { /* worth looking? */
476 char buffer[INBUF_SZ + 1]; /* space for a linear copy of data */
478 int nCopyToUser; /* number to copy to user */
481 cData = pdx->inputBuffer[pdx->dwInBuffGet++];
482 if (cData == CR_CHAR) /* replace CR with zero */
485 if (pdx->dwInBuffGet >= INBUF_SZ)
486 pdx->dwInBuffGet = 0; /* wrap buffer pointer */
488 buffer[nGot++] = cData; /* save the output */
489 } while ((nGot < nAvailable) && cData);
491 nCopyToUser = nGot; /* what to copy... */
492 if (cData) { /* do we need null */
493 buffer[nGot] = (char)0; /* make it tidy */
494 if (nGot < n) /* if space in user buffer... */
495 ++nCopyToUser; /* ...copy the 0 as well. */
498 pdx->dwNumInput -= nGot;
499 spin_unlock_irq(&pdx->charInLock);
501 dev_dbg(&pdx->interface->dev,
502 "GetString read %d characters >%s<", nGot, buffer);
503 if (copy_to_user(pUser, buffer, nCopyToUser))
506 iReturn = nGot; /* report characters read */
508 spin_unlock_irq(&pdx->charInLock);
510 Allowi(pdx); /* Make sure char reads are running */
511 mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
516 /*******************************************************************************
517 ** Get count of characters in the inout buffer.
518 *******************************************************************************/
519 int Stat1401(DEVICE_EXTENSION *pdx)
522 mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
523 Allowi(pdx); /* make sure we allow pending chars */
524 SendChars(pdx); /* in both directions */
525 iReturn = pdx->dwNumInput; /* no lock as single read */
526 mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
530 /****************************************************************************
533 ** Returns the number of newline chars in the buffer. There is no need for
534 ** any fancy interlocks as we only read the interrupt routine data, and the
535 ** system is arranged so nothing can be destroyed.
536 ****************************************************************************/
537 int LineCount(DEVICE_EXTENSION *pdx)
539 int iReturn = 0; /* will be count of line ends */
541 mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
542 Allowi(pdx); /* Make sure char reads are running */
543 SendChars(pdx); /* and send any buffered chars */
544 spin_lock_irq(&pdx->charInLock); /* Get protection */
546 if (pdx->dwNumInput > 0) { /* worth looking? */
547 unsigned int dwIndex = pdx->dwInBuffGet; /* start at first available */
548 unsigned int dwEnd = pdx->dwInBuffPut; /* Position for search end */
550 if (pdx->inputBuffer[dwIndex++] == CR_CHAR)
551 ++iReturn; /* inc count if CR */
553 if (dwIndex >= INBUF_SZ) /* see if we fall off buff */
555 } while (dwIndex != dwEnd); /* go to last available */
558 spin_unlock_irq(&pdx->charInLock);
559 dev_dbg(&pdx->interface->dev, "LineCount returned %d", iReturn);
560 mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
564 /****************************************************************************
567 ** Gets the space in the output buffer. Called from user code.
568 *****************************************************************************/
569 int GetOutBufSpace(DEVICE_EXTENSION *pdx)
572 mutex_lock(&pdx->io_mutex); /* Protect disconnect from new i/o */
573 SendChars(pdx); /* send any buffered chars */
574 iReturn = (int)(OUTBUF_SZ - pdx->dwNumOutput); /* no lock needed for single read */
575 dev_dbg(&pdx->interface->dev, "OutBufSpace %d", iReturn);
576 mutex_unlock(&pdx->io_mutex); /* Protect disconnect from new i/o */
580 /****************************************************************************
584 ** Clears up a transfer area. This is always called in the context of a user
585 ** request, never from a call-back.
586 ****************************************************************************/
587 int ClearArea(DEVICE_EXTENSION *pdx, int nArea)
589 int iReturn = U14ERR_NOERROR;
591 if ((nArea < 0) || (nArea >= MAX_TRANSAREAS)) {
592 iReturn = U14ERR_BADAREA;
593 dev_err(&pdx->interface->dev, "%s Attempt to clear area %d",
596 TRANSAREA *pTA = &pdx->rTransDef[nArea]; /* to save typing */
597 if (!pTA->bUsed) /* if not used... */
598 iReturn = U14ERR_NOTSET; /* ...nothing to be done */
600 /* We must save the memory we return as we shouldn't mess with memory while */
601 /* holding a spin lock. */
602 struct page **pPages = NULL; /*save page address list*/
603 int nPages = 0; /* and number of pages */
606 dev_dbg(&pdx->interface->dev, "%s area %d", __func__,
608 spin_lock_irq(&pdx->stagedLock);
609 if ((pdx->StagedId == nArea)
610 && (pdx->dwDMAFlag > MODE_CHAR)) {
611 iReturn = U14ERR_UNLOCKFAIL; /* cannot delete as in use */
612 dev_err(&pdx->interface->dev,
613 "%s call on area %d while active",
616 pPages = pTA->pPages; /* save page address list */
617 nPages = pTA->nPages; /* and page count */
618 if (pTA->dwEventSz) /* if events flagging in use */
619 wake_up_interruptible(&pTA->wqEvent); /* release anything that was waiting */
621 if (pdx->bXFerWaiting
622 && (pdx->rDMAInfo.wIdent == nArea))
623 pdx->bXFerWaiting = false; /* Cannot have pending xfer if area cleared */
625 /* Clean out the TRANSAREA except for the wait queue, which is at the end */
626 /* This sets bUsed to false and dwEventSz to 0 to say area not used and no events. */
629 sizeof(wait_queue_head_t));
631 spin_unlock_irq(&pdx->stagedLock);
633 if (pPages) { /* if we decided to release the memory */
634 /* Now we must undo the pinning down of the pages. We will assume the worst and mark */
635 /* all the pages as dirty. Don't be tempted to move this up above as you must not be */
636 /* holding a spin lock to do this stuff as it is not atomic. */
637 dev_dbg(&pdx->interface->dev, "%s nPages=%d",
640 for (np = 0; np < nPages; ++np) {
642 SetPageDirty(pPages[np]);
643 page_cache_release(pPages[np]);
648 dev_dbg(&pdx->interface->dev,
649 "%s kfree(pPages) done", __func__);
657 /****************************************************************************
660 ** Sets up a transfer area - the functional part. Called by both
661 ** SetTransfer and SetCircular.
662 ****************************************************************************/
663 static int SetArea(DEVICE_EXTENSION *pdx, int nArea, char __user *puBuf,
664 unsigned int dwLength, bool bCircular, bool bCircToHost)
666 /* Start by working out the page aligned start of the area and the size */
667 /* of the area in pages, allowing for the start not being aligned and the */
668 /* end needing to be rounded up to a page boundary. */
669 unsigned long ulStart = ((unsigned long)puBuf) & PAGE_MASK;
670 unsigned int ulOffset = ((unsigned long)puBuf) & (PAGE_SIZE - 1);
671 int len = (dwLength + ulOffset + PAGE_SIZE - 1) >> PAGE_SHIFT;
673 TRANSAREA *pTA = &pdx->rTransDef[nArea]; /* to save typing */
674 struct page **pPages = NULL; /* space for page tables */
675 int nPages = 0; /* and number of pages */
677 int iReturn = ClearArea(pdx, nArea); /* see if OK to use this area */
678 if ((iReturn != U14ERR_NOTSET) && /* if not area unused and... */
679 (iReturn != U14ERR_NOERROR)) /* ...not all OK, then... */
680 return iReturn; /* ...we cannot use this area */
682 if (!access_ok(VERIFY_WRITE, puBuf, dwLength)) /* if we cannot access the memory... */
683 return -EFAULT; /* ...then we are done */
685 /* Now allocate space to hold the page pointer and virtual address pointer tables */
686 pPages = kmalloc(len * sizeof(struct page *), GFP_KERNEL);
688 iReturn = U14ERR_NOMEMORY;
691 dev_dbg(&pdx->interface->dev, "%s %p, length=%06x, circular %d",
692 __func__, puBuf, dwLength, bCircular);
694 /* To pin down user pages we must first acquire the mapping semaphore. */
695 nPages = get_user_pages_fast(ulStart, len, 1, pPages);
696 dev_dbg(&pdx->interface->dev, "%s nPages = %d", __func__, nPages);
698 if (nPages > 0) { /* if we succeeded */
699 /* If you are tempted to use page_address (form LDD3), forget it. You MUST use */
700 /* kmap() or kmap_atomic() to get a virtual address. page_address will give you */
701 /* (null) or at least it does in this context with an x86 machine. */
702 spin_lock_irq(&pdx->stagedLock);
703 pTA->lpvBuff = puBuf; /* keep start of region (user address) */
704 pTA->dwBaseOffset = ulOffset; /* save offset in first page to start of xfer */
705 pTA->dwLength = dwLength; /* Size if the region in bytes */
706 pTA->pPages = pPages; /* list of pages that are used by buffer */
707 pTA->nPages = nPages; /* number of pages */
709 pTA->bCircular = bCircular;
710 pTA->bCircToHost = bCircToHost;
712 pTA->aBlocks[0].dwOffset = 0;
713 pTA->aBlocks[0].dwSize = 0;
714 pTA->aBlocks[1].dwOffset = 0;
715 pTA->aBlocks[1].dwSize = 0;
716 pTA->bUsed = true; /* This is now a used block */
718 spin_unlock_irq(&pdx->stagedLock);
719 iReturn = U14ERR_NOERROR; /* say all was well */
721 iReturn = U14ERR_LOCKFAIL;
732 /****************************************************************************
735 ** Sets up a transfer area record. If the area is already set, we attempt to
736 ** unset it. Unsetting will fail if the area is booked, and a transfer to that
737 ** area is in progress. Otherwise, we will release the area and re-assign it.
738 ****************************************************************************/
739 int SetTransfer(DEVICE_EXTENSION *pdx, TRANSFERDESC __user *pTD)
744 if (copy_from_user(&td, pTD, sizeof(td)))
747 mutex_lock(&pdx->io_mutex);
748 dev_dbg(&pdx->interface->dev, "%s area:%d, size:%08x", __func__,
749 td.wAreaNum, td.dwLength);
750 /* The strange cast is done so that we don't get warnings in 32-bit linux about the size of the */
751 /* pointer. The pointer is always passed as a 64-bit object so that we don't have problems using */
752 /* a 32-bit program on a 64-bit system. unsigned long is 64-bits on a 64-bit system. */
754 SetArea(pdx, td.wAreaNum,
755 (char __user *)((unsigned long)td.lpvBuff), td.dwLength,
757 mutex_unlock(&pdx->io_mutex);
761 /****************************************************************************
763 ** Erases a transfer area record
764 ****************************************************************************/
765 int UnsetTransfer(DEVICE_EXTENSION *pdx, int nArea)
768 mutex_lock(&pdx->io_mutex);
769 iReturn = ClearArea(pdx, nArea);
770 mutex_unlock(&pdx->io_mutex);
774 /****************************************************************************
776 ** Creates an event that we can test for based on a transfer to/from an area.
777 ** The area must be setup for a transfer. We attempt to simulate the Windows
778 ** driver behavior for events (as we don't actually use them), which is to
779 ** pretend that whatever the user asked for was achieved, so we return 1 if
780 ** try to create one, and 0 if they ask to remove (assuming all else was OK).
781 ****************************************************************************/
782 int SetEvent(DEVICE_EXTENSION *pdx, TRANSFEREVENT __user *pTE)
784 int iReturn = U14ERR_NOERROR;
787 /* get a local copy of the data */
788 if (copy_from_user(&te, pTE, sizeof(te)))
791 if (te.wAreaNum >= MAX_TRANSAREAS) /* the area must exist */
792 return U14ERR_BADAREA;
794 TRANSAREA *pTA = &pdx->rTransDef[te.wAreaNum];
795 mutex_lock(&pdx->io_mutex); /* make sure we have no competitor */
796 spin_lock_irq(&pdx->stagedLock);
797 if (pTA->bUsed) { /* area must be in use */
798 pTA->dwEventSt = te.dwStart; /* set area regions */
799 pTA->dwEventSz = te.dwLength; /* set size (0 cancels it) */
800 pTA->bEventToHost = te.wFlags & 1; /* set the direction */
801 pTA->iWakeUp = 0; /* zero the wake up count */
803 iReturn = U14ERR_NOTSET;
804 spin_unlock_irq(&pdx->stagedLock);
805 mutex_unlock(&pdx->io_mutex);
808 U14ERR_NOERROR ? (te.iSetEvent ? 1 : U14ERR_NOERROR) : iReturn;
811 /****************************************************************************
813 ** Sleep the process with a timeout waiting for an event. Returns the number
814 ** of times that a block met the event condition since we last cleared it or
815 ** 0 if timed out, or -ve error (bad area or not set, or signal).
816 ****************************************************************************/
817 int WaitEvent(DEVICE_EXTENSION *pdx, int nArea, int msTimeOut)
820 if ((unsigned)nArea >= MAX_TRANSAREAS)
821 return U14ERR_BADAREA;
824 TRANSAREA *pTA = &pdx->rTransDef[nArea];
825 msTimeOut = (msTimeOut * HZ + 999) / 1000; /* convert timeout to jiffies */
827 /* We cannot wait holding the mutex, but we check the flags while holding */
828 /* it. This may well be pointless as another thread could get in between */
829 /* releasing it and the wait call. However, this would have to clear the */
830 /* iWakeUp flag. However, the !pTA-bUsed may help us in this case. */
831 mutex_lock(&pdx->io_mutex); /* make sure we have no competitor */
832 if (!pTA->bUsed || !pTA->dwEventSz) /* check something to wait for... */
833 return U14ERR_NOTSET; /* ...else we do nothing */
834 mutex_unlock(&pdx->io_mutex);
838 wait_event_interruptible_timeout(pTA->wqEvent,
844 wait_event_interruptible(pTA->wqEvent, pTA->iWakeUp
847 iReturn = -ERESTARTSYS; /* oops - we have had a SIGNAL */
849 iReturn = pTA->iWakeUp; /* else the wakeup count */
851 spin_lock_irq(&pdx->stagedLock);
852 pTA->iWakeUp = 0; /* clear the flag */
853 spin_unlock_irq(&pdx->stagedLock);
858 /****************************************************************************
860 ** Test the event to see if a WaitEvent would return immediately. Returns the
861 ** number of times a block completed since the last call, or 0 if none or a
863 ****************************************************************************/
864 int TestEvent(DEVICE_EXTENSION *pdx, int nArea)
867 if ((unsigned)nArea >= MAX_TRANSAREAS)
868 iReturn = U14ERR_BADAREA;
870 TRANSAREA *pTA = &pdx->rTransDef[nArea];
871 mutex_lock(&pdx->io_mutex); /* make sure we have no competitor */
872 spin_lock_irq(&pdx->stagedLock);
873 iReturn = pTA->iWakeUp; /* get wakeup count since last call */
874 pTA->iWakeUp = 0; /* clear the count */
875 spin_unlock_irq(&pdx->stagedLock);
876 mutex_unlock(&pdx->io_mutex);
881 /****************************************************************************
883 ** Puts the current state of the 1401 in a TGET_TX_BLOCK.
884 *****************************************************************************/
885 int GetTransfer(DEVICE_EXTENSION *pdx, TGET_TX_BLOCK __user *pTX)
887 int iReturn = U14ERR_NOERROR;
888 unsigned int dwIdent;
890 mutex_lock(&pdx->io_mutex);
891 dwIdent = pdx->StagedId; /* area ident for last xfer */
892 if (dwIdent >= MAX_TRANSAREAS)
893 iReturn = U14ERR_BADAREA;
895 /* Return the best information we have - we don't have physical addresses */
898 tx = kzalloc(sizeof(*tx), GFP_KERNEL);
900 mutex_unlock(&pdx->io_mutex);
903 tx->size = pdx->rTransDef[dwIdent].dwLength;
904 tx->linear = (long long)((long)pdx->rTransDef[dwIdent].lpvBuff);
905 tx->avail = GET_TX_MAXENTRIES; /* how many blocks we could return */
906 tx->used = 1; /* number we actually return */
907 tx->entries[0].physical =
908 (long long)(tx->linear + pdx->StagedOffset);
909 tx->entries[0].size = tx->size;
911 if (copy_to_user(pTX, tx, sizeof(*tx)))
915 mutex_unlock(&pdx->io_mutex);
919 /****************************************************************************
922 ** Empties the host i/o buffers
923 ****************************************************************************/
924 int KillIO1401(DEVICE_EXTENSION *pdx)
926 dev_dbg(&pdx->interface->dev, "%s", __func__);
927 mutex_lock(&pdx->io_mutex);
930 mutex_unlock(&pdx->io_mutex);
931 return U14ERR_NOERROR;
934 /****************************************************************************
936 ** Returns a 0 or a 1 for whether DMA is happening. No point holding a mutex
937 ** for this as it only does one read.
938 *****************************************************************************/
939 int BlkTransState(DEVICE_EXTENSION *pdx)
941 int iReturn = pdx->dwDMAFlag != MODE_CHAR;
942 dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn);
946 /****************************************************************************
949 ** Puts the current state of the 1401 in the Irp return buffer.
950 *****************************************************************************/
951 int StateOf1401(DEVICE_EXTENSION *pdx)
954 mutex_lock(&pdx->io_mutex);
956 QuickCheck(pdx, false, false); /* get state up to date, no reset */
957 iReturn = pdx->sCurrentState;
959 mutex_unlock(&pdx->io_mutex);
960 dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn);
965 /****************************************************************************
968 ** Initiates a self-test cycle. The assumption is that we have no interrupts
969 ** active, so we should make sure that this is the case.
970 *****************************************************************************/
971 int StartSelfTest(DEVICE_EXTENSION *pdx)
974 mutex_lock(&pdx->io_mutex);
975 dev_dbg(&pdx->interface->dev, "%s", __func__);
977 ced_draw_down(pdx); /* wait for, then kill outstanding Urbs */
978 FlushInBuff(pdx); /* Clear out input buffer & pipe */
979 FlushOutBuff(pdx); /* Clear output buffer & pipe */
980 /* so things stay tidy */
981 /* ReadWrite_Cancel(pDeviceObject); */
982 pdx->dwDMAFlag = MODE_CHAR; /* Clear DMA mode flags here */
984 nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0),
985 DB_SELFTEST, (H_TO_D | VENDOR | DEVREQ),
986 0, 0, NULL, 0, HZ); /* allow 1 second timeout */
987 pdx->ulSelfTestTime = jiffies + HZ * 30; /* 30 seconds into the future */
989 mutex_unlock(&pdx->io_mutex);
991 dev_err(&pdx->interface->dev, "%s err=%d", __func__, nGot);
992 return nGot < 0 ? U14ERR_FAIL : U14ERR_NOERROR;
995 /****************************************************************************
998 ** Check progress of a self-test cycle
999 ****************************************************************************/
1000 int CheckSelfTest(DEVICE_EXTENSION *pdx, TGET_SELFTEST __user *pGST)
1002 unsigned int state, error;
1004 TGET_SELFTEST gst; /* local work space */
1005 memset(&gst, 0, sizeof(gst)); /* clear out the space (sets code 0) */
1007 mutex_lock(&pdx->io_mutex);
1009 dev_dbg(&pdx->interface->dev, "%s", __func__);
1010 iReturn = Get1401State(pdx, &state, &error);
1011 if (iReturn == U14ERR_NOERROR) /* Only accept zero if it happens twice */
1012 iReturn = Get1401State(pdx, &state, &error);
1014 if (iReturn != U14ERR_NOERROR) { /* Self-test can cause comms errors */
1015 /* so we assume still testing */
1016 dev_err(&pdx->interface->dev,
1017 "%s Get1401State=%d, assuming still testing", __func__,
1019 state = 0x80; /* Force still-testing, no error */
1021 iReturn = U14ERR_NOERROR;
1024 if ((state == -1) && (error == -1)) { /* If Get1401State had problems */
1025 dev_err(&pdx->interface->dev,
1026 "%s Get1401State failed, assuming still testing",
1028 state = 0x80; /* Force still-testing, no error */
1032 if ((state & 0xFF) == 0x80) { /* If we are still in self-test */
1033 if (state & 0x00FF0000) { /* Have we got an error? */
1034 gst.code = (state & 0x00FF0000) >> 16; /* read the error code */
1035 gst.x = error & 0x0000FFFF; /* Error data X */
1036 gst.y = (error & 0xFFFF0000) >> 16; /* and data Y */
1037 dev_dbg(&pdx->interface->dev, "Self-test error code %d",
1039 } else { /* No error, check for timeout */
1040 unsigned long ulNow = jiffies; /* get current time */
1041 if (time_after(ulNow, pdx->ulSelfTestTime)) {
1042 gst.code = -2; /* Flag the timeout */
1043 dev_dbg(&pdx->interface->dev,
1044 "Self-test timed-out");
1046 dev_dbg(&pdx->interface->dev,
1047 "Self-test on-going");
1050 gst.code = -1; /* Flag the test is done */
1051 dev_dbg(&pdx->interface->dev, "Self-test done");
1054 if (gst.code < 0) { /* If we have a problem or finished */
1055 /* If using the 2890 we should reset properly */
1056 if ((pdx->nPipes == 4) && (pdx->s1401Type <= TYPEPOWER))
1057 Is1401(pdx); /* Get 1401 reset and OK */
1059 QuickCheck(pdx, true, true); /* Otherwise check without reset unless problems */
1061 mutex_unlock(&pdx->io_mutex);
1063 if (copy_to_user(pGST, &gst, sizeof(gst)))
1069 /****************************************************************************
1072 ** Returns code for standard, plus, micro1401, power1401 or none
1073 ****************************************************************************/
1074 int TypeOf1401(DEVICE_EXTENSION *pdx)
1076 int iReturn = TYPEUNKNOWN;
1077 mutex_lock(&pdx->io_mutex);
1078 dev_dbg(&pdx->interface->dev, "%s", __func__);
1080 switch (pdx->s1401Type) {
1082 iReturn = U14ERR_STD;
1083 break; /* Handle these types directly */
1085 iReturn = U14ERR_PLUS;
1088 iReturn = U14ERR_U1401;
1091 if ((pdx->s1401Type >= TYPEPOWER) && (pdx->s1401Type <= 25))
1092 iReturn = pdx->s1401Type + 4; /* We can calculate types */
1093 else /* for up-coming 1401 designs */
1094 iReturn = TYPEUNKNOWN; /* Don't know or not there */
1096 dev_dbg(&pdx->interface->dev, "%s %d", __func__, iReturn);
1097 mutex_unlock(&pdx->io_mutex);
1102 /****************************************************************************
1105 ** Returns flags on block transfer abilities
1106 ****************************************************************************/
1107 int TransferFlags(DEVICE_EXTENSION *pdx)
1109 int iReturn = U14TF_MULTIA | U14TF_DIAG | /* we always have multiple DMA area */
1110 U14TF_NOTIFY | U14TF_CIRCTH; /* diagnostics, notify and circular */
1111 dev_dbg(&pdx->interface->dev, "%s", __func__);
1112 mutex_lock(&pdx->io_mutex);
1113 if (pdx->bIsUSB2) /* Set flag for USB2 if appropriate */
1114 iReturn |= U14TF_USB2;
1115 mutex_unlock(&pdx->io_mutex);
1120 /***************************************************************************
1122 ** Issues a debug\diagnostic command to the 1401 along with a 32-bit datum
1123 ** This is a utility command used for dbg operations.
1125 static int DbgCmd1401(DEVICE_EXTENSION *pdx, unsigned char cmd,
1129 dev_dbg(&pdx->interface->dev, "%s entry", __func__);
1130 iReturn = usb_control_msg(pdx->udev, usb_sndctrlpipe(pdx->udev, 0), cmd,
1131 (H_TO_D | VENDOR | DEVREQ),
1132 (unsigned short)data,
1133 (unsigned short)(data >> 16), NULL, 0, HZ);
1134 /* allow 1 second timeout */
1136 dev_err(&pdx->interface->dev, "%s fail code=%d", __func__,
1142 /****************************************************************************
1145 ** Execute the diagnostic peek operation. Uses address, width and repeats.
1146 ****************************************************************************/
1147 int DbgPeek(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB)
1152 if (copy_from_user(&db, pDB, sizeof(db)))
1155 mutex_lock(&pdx->io_mutex);
1156 dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr);
1158 iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr);
1159 if (iReturn == U14ERR_NOERROR)
1160 iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
1161 if (iReturn == U14ERR_NOERROR)
1162 iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
1163 if (iReturn == U14ERR_NOERROR)
1164 iReturn = DbgCmd1401(pdx, DB_PEEK, 0);
1165 mutex_unlock(&pdx->io_mutex);
1170 /****************************************************************************
1173 ** Execute the diagnostic poke operation. Parameters are in the CSBLOCK struct
1174 ** in order address, size, repeats and value to poke.
1175 ****************************************************************************/
1176 int DbgPoke(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB)
1181 if (copy_from_user(&db, pDB, sizeof(db)))
1184 mutex_lock(&pdx->io_mutex);
1185 dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr);
1187 iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr);
1188 if (iReturn == U14ERR_NOERROR)
1189 iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
1190 if (iReturn == U14ERR_NOERROR)
1191 iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
1192 if (iReturn == U14ERR_NOERROR)
1193 iReturn = DbgCmd1401(pdx, DB_POKE, db.iData);
1194 mutex_unlock(&pdx->io_mutex);
1199 /****************************************************************************
1202 ** Execute the diagnostic ramp data operation. Parameters are in the CSBLOCK struct
1203 ** in order address, default, enable mask, size and repeats.
1204 ****************************************************************************/
1205 int DbgRampData(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB)
1210 if (copy_from_user(&db, pDB, sizeof(db)))
1213 mutex_lock(&pdx->io_mutex);
1214 dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr);
1216 iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr);
1217 if (iReturn == U14ERR_NOERROR)
1218 iReturn = DbgCmd1401(pdx, DB_SETDEF, db.iDefault);
1219 if (iReturn == U14ERR_NOERROR)
1220 iReturn = DbgCmd1401(pdx, DB_SETMASK, db.iMask);
1221 if (iReturn == U14ERR_NOERROR)
1222 iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
1223 if (iReturn == U14ERR_NOERROR)
1224 iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
1225 if (iReturn == U14ERR_NOERROR)
1226 iReturn = DbgCmd1401(pdx, DB_RAMPD, 0);
1227 mutex_unlock(&pdx->io_mutex);
1232 /****************************************************************************
1235 ** Execute the diagnostic ramp address operation
1236 ****************************************************************************/
1237 int DbgRampAddr(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB)
1242 if (copy_from_user(&db, pDB, sizeof(db)))
1245 mutex_lock(&pdx->io_mutex);
1246 dev_dbg(&pdx->interface->dev, "%s", __func__);
1248 iReturn = DbgCmd1401(pdx, DB_SETDEF, db.iDefault);
1249 if (iReturn == U14ERR_NOERROR)
1250 iReturn = DbgCmd1401(pdx, DB_SETMASK, db.iMask);
1251 if (iReturn == U14ERR_NOERROR)
1252 iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
1253 if (iReturn == U14ERR_NOERROR)
1254 iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
1255 if (iReturn == U14ERR_NOERROR)
1256 iReturn = DbgCmd1401(pdx, DB_RAMPA, 0);
1257 mutex_unlock(&pdx->io_mutex);
1262 /****************************************************************************
1265 ** Retrieve the data resulting from the last debug Peek operation
1266 ****************************************************************************/
1267 int DbgGetData(DEVICE_EXTENSION *pdx, TDBGBLOCK __user *pDB)
1271 memset(&db, 0, sizeof(db)); /* fill returned block with 0s */
1273 mutex_lock(&pdx->io_mutex);
1274 dev_dbg(&pdx->interface->dev, "%s", __func__);
1276 /* Read back the last peeked value from the 1401. */
1277 iReturn = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0),
1278 DB_DATA, (D_TO_H | VENDOR | DEVREQ), 0, 0,
1279 &db.iData, sizeof(db.iData), HZ);
1280 if (iReturn == sizeof(db.iData)) {
1281 if (copy_to_user(pDB, &db, sizeof(db)))
1284 iReturn = U14ERR_NOERROR;
1286 dev_err(&pdx->interface->dev, "%s failed, code %d", __func__,
1289 mutex_unlock(&pdx->io_mutex);
1294 /****************************************************************************
1297 ** Stop any never-ending debug loop, we just call Get1401State for USB
1299 ****************************************************************************/
1300 int DbgStopLoop(DEVICE_EXTENSION *pdx)
1303 unsigned int uState, uErr;
1305 mutex_lock(&pdx->io_mutex);
1306 dev_dbg(&pdx->interface->dev, "%s", __func__);
1307 iReturn = Get1401State(pdx, &uState, &uErr);
1308 mutex_unlock(&pdx->io_mutex);
1313 /****************************************************************************
1316 ** Sets up a transfer area record for circular transfers. If the area is
1317 ** already set, we attempt to unset it. Unsetting will fail if the area is
1318 ** booked and a transfer to that area is in progress. Otherwise, we will
1319 ** release the area and re-assign it.
1320 ****************************************************************************/
1321 int SetCircular(DEVICE_EXTENSION *pdx, TRANSFERDESC __user *pTD)
1327 if (copy_from_user(&td, pTD, sizeof(td)))
1330 mutex_lock(&pdx->io_mutex);
1331 dev_dbg(&pdx->interface->dev, "%s area:%d, size:%08x", __func__,
1332 td.wAreaNum, td.dwLength);
1333 bToHost = td.eSize != 0; /* this is used as the tohost flag */
1335 /* The strange cast is done so that we don't get warnings in 32-bit linux about the size of the */
1336 /* pointer. The pointer is always passed as a 64-bit object so that we don't have problems using */
1337 /* a 32-bit program on a 64-bit system. unsigned long is 64-bits on a 64-bit system. */
1339 SetArea(pdx, td.wAreaNum,
1340 (char __user *)((unsigned long)td.lpvBuff), td.dwLength,
1342 mutex_unlock(&pdx->io_mutex);
1346 /****************************************************************************
1349 ** Return the next available block of circularly-transferred data.
1350 ****************************************************************************/
1351 int GetCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB)
1353 int iReturn = U14ERR_NOERROR;
1357 dev_dbg(&pdx->interface->dev, "%s", __func__);
1359 if (copy_from_user(&cb, pCB, sizeof(cb)))
1362 mutex_lock(&pdx->io_mutex);
1364 nArea = cb.nArea; /* Retrieve parameters first */
1365 cb.dwOffset = 0; /* set default result (nothing) */
1368 if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */
1369 TRANSAREA *pArea = &pdx->rTransDef[nArea]; /* Pointer to relevant info */
1370 spin_lock_irq(&pdx->stagedLock); /* Lock others out */
1372 if ((pArea->bUsed) && (pArea->bCircular) && /* Must be circular area */
1373 (pArea->bCircToHost)) { /* For now at least must be to host */
1374 if (pArea->aBlocks[0].dwSize > 0) { /* Got anything? */
1375 cb.dwOffset = pArea->aBlocks[0].dwOffset;
1376 cb.dwSize = pArea->aBlocks[0].dwSize;
1377 dev_dbg(&pdx->interface->dev,
1378 "%s return block 0: %d bytes at %d",
1379 __func__, cb.dwSize, cb.dwOffset);
1382 iReturn = U14ERR_NOTSET;
1384 spin_unlock_irq(&pdx->stagedLock);
1386 iReturn = U14ERR_BADAREA;
1388 if (copy_to_user(pCB, &cb, sizeof(cb)))
1391 mutex_unlock(&pdx->io_mutex);
1395 /****************************************************************************
1398 ** Frees a block of circularly-transferred data and returns the next one.
1399 ****************************************************************************/
1400 int FreeCircBlock(DEVICE_EXTENSION *pdx, TCIRCBLOCK __user *pCB)
1402 int iReturn = U14ERR_NOERROR;
1403 unsigned int nArea, uStart, uSize;
1406 dev_dbg(&pdx->interface->dev, "%s", __func__);
1408 if (copy_from_user(&cb, pCB, sizeof(cb)))
1411 mutex_lock(&pdx->io_mutex);
1413 nArea = cb.nArea; /* Retrieve parameters first */
1414 uStart = cb.dwOffset;
1416 cb.dwOffset = 0; /* then set default result (nothing) */
1419 if (nArea < MAX_TRANSAREAS) { /* The area number must be OK */
1420 TRANSAREA *pArea = &pdx->rTransDef[nArea]; /* Pointer to relevant info */
1421 spin_lock_irq(&pdx->stagedLock); /* Lock others out */
1423 if ((pArea->bUsed) && (pArea->bCircular) && /* Must be circular area */
1424 (pArea->bCircToHost)) { /* For now at least must be to host */
1425 bool bWaiting = false;
1427 if ((pArea->aBlocks[0].dwSize >= uSize) && /* Got anything? */
1428 (pArea->aBlocks[0].dwOffset == uStart)) { /* Must be legal data */
1429 pArea->aBlocks[0].dwSize -= uSize;
1430 pArea->aBlocks[0].dwOffset += uSize;
1431 if (pArea->aBlocks[0].dwSize == 0) { /* Have we emptied this block? */
1432 if (pArea->aBlocks[1].dwSize) { /* Is there a second block? */
1433 pArea->aBlocks[0] = pArea->aBlocks[1]; /* Copy down block 2 data */
1434 pArea->aBlocks[1].dwSize = 0; /* and mark the second block as unused */
1435 pArea->aBlocks[1].dwOffset = 0;
1437 pArea->aBlocks[0].dwOffset = 0;
1440 dev_dbg(&pdx->interface->dev,
1441 "%s free %d bytes at %d, return %d bytes at %d, wait=%d",
1442 __func__, uSize, uStart,
1443 pArea->aBlocks[0].dwSize,
1444 pArea->aBlocks[0].dwOffset,
1447 /* Return the next available block of memory as well */
1448 if (pArea->aBlocks[0].dwSize > 0) { /* Got anything? */
1450 pArea->aBlocks[0].dwOffset;
1451 cb.dwSize = pArea->aBlocks[0].dwSize;
1454 bWaiting = pdx->bXFerWaiting;
1455 if (bWaiting && pdx->bStagedUrbPending) {
1456 dev_err(&pdx->interface->dev,
1457 "%s ERROR: waiting xfer and staged Urb pending!",
1462 dev_err(&pdx->interface->dev,
1463 "%s ERROR: freeing %d bytes at %d, block 0 is %d bytes at %d",
1464 __func__, uSize, uStart,
1465 pArea->aBlocks[0].dwSize,
1466 pArea->aBlocks[0].dwOffset);
1467 iReturn = U14ERR_NOMEMORY;
1470 /* If we have one, kick off pending transfer */
1471 if (bWaiting) { /* Got a block xfer waiting? */
1473 ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard,
1474 pdx->rDMAInfo.wIdent,
1475 pdx->rDMAInfo.dwOffset,
1476 pdx->rDMAInfo.dwSize);
1477 if (RWMStat != U14ERR_NOERROR)
1478 dev_err(&pdx->interface->dev,
1479 "%s rw setup failed %d",
1483 iReturn = U14ERR_NOTSET;
1485 spin_unlock_irq(&pdx->stagedLock);
1487 iReturn = U14ERR_BADAREA;
1489 if (copy_to_user(pCB, &cb, sizeof(cb)))
1492 mutex_unlock(&pdx->io_mutex);