drivers/staging/ced1401/ced_ioc.c

   1 /* ced_ioc.c
   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)
   5
   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.
  10
  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.
  15
  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.
  19 */
  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>
  32
  33 #include "usb1401.h"
  34
  35 /****************************************************************************
  36 ** FlushOutBuff
  37 **
  38 ** Empties the Output buffer and sets int lines. Used from user level only
  39 ****************************************************************************/
  40 void FlushOutBuff(DEVICE_EXTENSION * pdx)
  41 {
  42         dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__,
  43                 pdx->sCurrentState);
  44         if (pdx->sCurrentState == U14ERR_TIME)  /* Do nothing if hardware in trouble */
  45                 return;
  46 //    CharSend_Cancel(pdx);                   /* Kill off any pending I/O */
  47         spin_lock_irq(&pdx->charOutLock);
  48         pdx->dwNumOutput = 0;
  49         pdx->dwOutBuffGet = 0;
  50         pdx->dwOutBuffPut = 0;
  51         spin_unlock_irq(&pdx->charOutLock);
  52 }
  53
  54 /****************************************************************************
  55 **
  56 ** FlushInBuff
  57 **
  58 ** Empties the input buffer and sets int lines
  59 ****************************************************************************/
  60 void FlushInBuff(DEVICE_EXTENSION * pdx)
  61 {
  62         dev_dbg(&pdx->interface->dev, "%s currentState=%d", __func__,
  63                 pdx->sCurrentState);
  64         if (pdx->sCurrentState == U14ERR_TIME)  /* Do nothing if hardware in trouble */
  65                 return;
  66 //    CharRead_Cancel(pDevObject);            /* Kill off any pending I/O */
  67         spin_lock_irq(&pdx->charInLock);
  68         pdx->dwNumInput = 0;
  69         pdx->dwInBuffGet = 0;
  70         pdx->dwInBuffPut = 0;
  71         spin_unlock_irq(&pdx->charInLock);
  72 }
  73
  74 /****************************************************************************
  75 ** PutChars
  76 **
  77 ** Utility routine to copy chars into the output buffer and fire them off.
  78 ** called from user mode, holds charOutLock.
  79 ****************************************************************************/
  80 static int PutChars(DEVICE_EXTENSION * pdx, const char *pCh,
  81                     unsigned int uCount)
  82 {
  83         int iReturn;
  84         spin_lock_irq(&pdx->charOutLock);       // get the output spin lock
  85         if ((OUTBUF_SZ - pdx->dwNumOutput) >= uCount) {
  86                 unsigned int u;
  87                 for (u = 0; u < uCount; u++) {
  88                         pdx->outputBuffer[pdx->dwOutBuffPut++] = pCh[u];
  89                         if (pdx->dwOutBuffPut >= OUTBUF_SZ)
  90                                 pdx->dwOutBuffPut = 0;
  91                 }
  92                 pdx->dwNumOutput += uCount;
  93                 spin_unlock_irq(&pdx->charOutLock);
  94                 iReturn = SendChars(pdx);       // ...give a chance to transmit data
  95         } else {
  96                 iReturn = U14ERR_NOOUT; // no room at the out (ha-ha)
  97                 spin_unlock_irq(&pdx->charOutLock);
  98         }
  99         return iReturn;
 100 }
 101
 102 /*****************************************************************************
 103 ** Add the data in pData (local pointer) of length n to the output buffer, and
 104 ** trigger an output transfer if this is appropriate. User mode.
 105 ** Holds the io_mutex
 106 *****************************************************************************/
 107 int SendString(DEVICE_EXTENSION * pdx, const char __user * pData,
 108                unsigned int n)
 109 {
 110         int iReturn = U14ERR_NOERROR;   // assume all will be well
 111         char buffer[OUTBUF_SZ + 1];     // space in our address space for characters
 112         if (n > OUTBUF_SZ)      // check space in local buffer...
 113                 return U14ERR_NOOUT;    // ...too many characters
 114         if (copy_from_user(buffer, pData, n))
 115                 return -EFAULT;
 116         buffer[n] = 0;          // terminate for debug purposes
 117
 118         mutex_lock(&pdx->io_mutex);     // Protect disconnect from new i/o
 119         if (n > 0)              // do nothing if nowt to do!
 120         {
 121                 dev_dbg(&pdx->interface->dev, "%s n=%d>%s<", __func__, n,
 122                         buffer);
 123                 iReturn = PutChars(pdx, buffer, n);
 124         }
 125
 126         Allowi(pdx, false);     // make sure we have input int
 127         mutex_unlock(&pdx->io_mutex);
 128
 129         return iReturn;
 130 }
 131
 132 /****************************************************************************
 133 ** SendChar
 134 **
 135 ** Sends a single character to the 1401. User mode, holds io_mutex.
 136 ****************************************************************************/
 137 int SendChar(DEVICE_EXTENSION * pdx, char c)
 138 {
 139         int iReturn;
 140         mutex_lock(&pdx->io_mutex);     // Protect disconnect from new i/o
 141         iReturn = PutChars(pdx, &c, 1);
 142         dev_dbg(&pdx->interface->dev, "SendChar >%c< (0x%02x)", c, c);
 143         Allowi(pdx, false);     // Make sure char reads are running
 144         mutex_unlock(&pdx->io_mutex);
 145         return iReturn;
 146 }
 147
 148 /***************************************************************************
 149 **
 150 ** Get1401State
 151 **
 152 **  Retrieves state information from the 1401, adjusts the 1401 state held
 153 **  in the device extension to indicate the current 1401 type.
 154 **
 155 **  *state is updated with information about the 1401 state as returned by the
 156 **         1401. The low byte is a code for what 1401 is doing:
 157 **
 158 **  0       normal 1401 operation
 159 **  1       sending chars to host
 160 **  2       sending block data to host
 161 **  3       reading block data from host
 162 **  4       sending an escape sequence to the host
 163 **  0x80    1401 is executing self-test, in which case the upper word
 164 **          is the last error code seen (or zero for no new error).
 165 **
 166 ** *error is updated with error information if a self-test error code
 167 **          is returned in the upper word of state.
 168 **
 169 **  both state and error are set to -1 if there are comms problems, and
 170 **  to zero if there is a simple failure.
 171 **
 172 ** return error code (U14ERR_NOERROR for OK)
 173 */
 174 int Get1401State(DEVICE_EXTENSION * pdx, __u32 * state, __u32 * error)
 175 {
 176         int nGot;
 177         dev_dbg(&pdx->interface->dev, "Get1401State() entry");
 178
 179         *state = 0xFFFFFFFF;    // Start off with invalid state
 180         nGot = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0),
 181                                GET_STATUS, (D_TO_H | VENDOR | DEVREQ), 0, 0,
 182                                pdx->statBuf, sizeof(pdx->statBuf), HZ);
 183         if (nGot != sizeof(pdx->statBuf)) {
 184                 dev_err(&pdx->interface->dev,
 185                         "Get1401State() FAILED, return code %d", nGot);
 186                 pdx->sCurrentState = U14ERR_TIME;       // Indicate that things are very wrong indeed
 187                 *state = 0;     // Force status values to a known state
 188                 *error = 0;
 189         } else {
 190                 int nDevice;
 191                 dev_dbg(&pdx->interface->dev,
 192                         "Get1401State() Success, state: 0x%x, 0x%x",
 193                         pdx->statBuf[0], pdx->statBuf[1]);
 194
 195                 *state = pdx->statBuf[0];       // Return the state values to the calling code
 196                 *error = pdx->statBuf[1];
 197
 198                 nDevice = pdx->udev->descriptor.bcdDevice >> 8; // 1401 type code value
 199                 switch (nDevice)        // so we can clean up current state
 200                 {
 201                 case 0:
 202                         pdx->sCurrentState = U14ERR_U1401;
 203                         break;
 204
 205                 default:        // allow lots of device codes for future 1401s
 206                         if ((nDevice >= 1) && (nDevice <= 23))
 207                                 pdx->sCurrentState = (short)(nDevice + 6);
 208                         else
 209                                 pdx->sCurrentState = U14ERR_ILL;
 210                         break;
 211                 }
 212         }
 213
 214         return pdx->sCurrentState >= 0 ? U14ERR_NOERROR : pdx->sCurrentState;
 215 }
 216
 217 /****************************************************************************
 218 ** ReadWrite_Cancel
 219 **
 220 ** Kills off staged read\write request from the USB if one is pending.
 221 ****************************************************************************/
 222 int ReadWrite_Cancel(DEVICE_EXTENSION * pdx)
 223 {
 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;
 229         unsigned int i;
 230         // We can fill this in when we know how we will implement the staged transfer stuff
 231         spin_lock_irq(&pdx->stagedLock);
 232
 233         if (pdx->bStagedUrbPending)     // anything to be cancelled? May need more...
 234         {
 235                 dev_info(&pdx->interface - dev,
 236                          "ReadWrite_Cancel about to cancel Urb");
 237
 238                 //       KeClearEvent(&pdx->StagingDoneEvent);   // Clear the staging done flag
 239                 USB_ASSERT(pdx->pStagedIrp != NULL);
 240
 241                 // Release the spinlock first otherwise the completion routine may hang
 242                 //  on the spinlock while this function hands waiting for the event.
 243                 spin_unlock_irq(&pdx->stagedLock);
 244                 bResult = IoCancelIrp(pdx->pStagedIrp); // Actually do the cancel
 245                 if (bResult) {
 246                         LARGE_INTEGER timeout;
 247                         timeout.QuadPart = -10000000;   // Use a timeout of 1 second
 248                         dev_info(&pdx->interface - dev,
 249                                  "ReadWrite_Cancel about to wait till done");
 250                         ntStatus =
 251                             KeWaitForSingleObject(&pdx->StagingDoneEvent,
 252                                                   Executive, KernelMode, FALSE,
 253                                                   &timeout);
 254                 } else {
 255                         dev_info(&pdx->interface - dev,
 256                                  "ReadWrite_Cancel, cancellation failed");
 257                         ntStatus = U14ERR_FAIL;
 258                 }
 259                 USB_KdPrint(DBGLVL_DEFAULT,
 260                             ("ReadWrite_Cancel ntStatus = 0x%x decimal %d\n",
 261                              ntStatus, ntStatus));
 262         } else
 263                 spin_unlock_irq(&pdx->stagedLock);
 264
 265         dev_info(&pdx->interface - dev, "ReadWrite_Cancel  done");
 266         return ntStatus;
 267 #else
 268         return U14ERR_NOERROR;
 269 #endif
 270
 271 }
 272
 273 /***************************************************************************
 274 ** InSelfTest - utility to check in self test. Return 1 for ST, 0 for not or
 275 ** a -ve error code if we failed for some reason.
 276 ***************************************************************************/
 277 static int InSelfTest(DEVICE_EXTENSION * pdx, unsigned int *pState)
 278 {
 279         unsigned int state, error;
 280         int iReturn = Get1401State(pdx, &state, &error);        // see if in self-test
 281         if (iReturn == U14ERR_NOERROR)  // if all still OK
 282                 iReturn = (state == (unsigned int)-1) ||        // TX problem or...
 283                     ((state & 0xff) == 0x80);   // ...self test
 284         *pState = state;        // return actual state
 285         return iReturn;
 286 }
 287
 288 /***************************************************************************
 289 ** Is1401 - ALWAYS CALLED HOLDING THE io_mutex
 290 **
 291 ** Tests for the current state of the 1401. Sets sCurrentState:
 292 **
 293 **  U14ERR_NOIF  1401  i/f card not installed (not done here)
 294 **  U14ERR_OFF   1401  apparently not switched on
 295 **  U14ERR_NC    1401  appears to be not connected
 296 **  U14ERR_ILL   1401  if it is there its not very well at all
 297 **  U14ERR_TIME  1401  appears OK, but doesn't communicate - very bad
 298 **  U14ERR_STD   1401  OK and ready for use
 299 **  U14ERR_PLUS  1401+ OK and ready for use
 300 **  U14ERR_U1401 Micro1401 OK and ready for use
 301 **  U14ERR_POWER Power1401 OK and ready for use
 302 **  U14ERR_U14012 Micro1401 mkII OK and ready for use
 303 **
 304 **  Returns TRUE if a 1401 detected and OK, else FALSE
 305 ****************************************************************************/
 306 bool Is1401(DEVICE_EXTENSION * pdx)
 307 {
 308         int iReturn;
 309         dev_dbg(&pdx->interface->dev, "%s", __func__);
 310
 311         ced_draw_down(pdx);     // wait for, then kill outstanding Urbs
 312         FlushInBuff(pdx);       // Clear out input buffer & pipe
 313         FlushOutBuff(pdx);      // Clear output buffer & pipe
 314
 315         // The next call returns 0 if OK, but has returned 1 in the past, meaning that
 316         // usb_unlock_device() is needed... now it always is
 317         iReturn = usb_lock_device_for_reset(pdx->udev, pdx->interface);
 318
 319         // release the io_mutex because if we don't, we will deadlock due to system
 320         // calls back into the driver.
 321         mutex_unlock(&pdx->io_mutex);   // locked, so we will not get system calls
 322         if (iReturn >= 0)       // if we failed
 323         {
 324                 iReturn = usb_reset_device(pdx->udev);  // try to do the reset
 325                 usb_unlock_device(pdx->udev);   // undo the lock
 326         }
 327
 328         mutex_lock(&pdx->io_mutex);     // hold stuff off while we wait
 329         pdx->dwDMAFlag = MODE_CHAR;     // Clear DMA mode flag regardless!
 330         if (iReturn == 0)       // if all is OK still
 331         {
 332                 unsigned int state;
 333                 iReturn = InSelfTest(pdx, &state);      // see if likely in self test
 334                 if (iReturn > 0)        // do we need to wait for self-test?
 335                 {
 336                         unsigned long ulTimeOut = jiffies + 30 * HZ;    // when to give up
 337                         while ((iReturn > 0) && time_before(jiffies, ulTimeOut)) {
 338                                 schedule();     // let other stuff run
 339                                 iReturn = InSelfTest(pdx, &state);      // see if done yet
 340                         }
 341                 }
 342
 343                 if (iReturn == 0)       // if all is OK...
 344                         iReturn = state == 0;   // then success is that the state is 0
 345         } else
 346                 iReturn = 0;    // we failed
 347         pdx->bForceReset = false;       // Clear forced reset flag now
 348
 349         return iReturn > 0;
 350 }
 351
 352 /****************************************************************************
 353 ** QuickCheck  - ALWAYS CALLED HOLDING THE io_mutex
 354 ** This is used to test for a 1401. It will try to do a quick check if all is
 355 **  OK, that is the 1401 was OK the last time it was asked, and there is no DMA
 356 **  in progress, and if the bTestBuff flag is set, the character buffers must be
 357 **  empty too. If the quick check shows that the state is still the same, then
 358 **  all is OK.
 359 **
 360 ** If any of the above conditions are not met, or if the state or type of the
 361 **  1401 has changed since the previous test, the full Is1401 test is done, but
 362 **  only if bCanReset is also TRUE.
 363 **
 364 ** The return value is TRUE if a useable 1401 is found, FALSE if not
 365 */
 366 bool QuickCheck(DEVICE_EXTENSION * pdx, bool bTestBuff, bool bCanReset)
 367 {
 368         bool bRet = false;      // assume it will fail and we will reset
 369         bool bShortTest;
 370
 371         bShortTest = ((pdx->dwDMAFlag == MODE_CHAR) &&  // no DMA running
 372                       (!pdx->bForceReset) &&    // Not had a real reset forced
 373                       (pdx->sCurrentState >= U14ERR_STD));      // No 1401 errors stored
 374
 375         dev_dbg(&pdx->interface->dev,
 376                 "%s DMAFlag:%d, state:%d, force:%d, testBuff:%d, short:%d",
 377                 __func__, pdx->dwDMAFlag, pdx->sCurrentState, pdx->bForceReset,
 378                 bTestBuff, bShortTest);
 379
 380         if ((bTestBuff) &&      // Buffer check requested, and...
 381             (pdx->dwNumInput || pdx->dwNumOutput))      // ...characters were in the buffer?
 382         {
 383                 bShortTest = false;     // Then do the full test
 384                 dev_dbg(&pdx->interface->dev,
 385                         "%s will reset as buffers not empty", __func__);
 386         }
 387
 388         if (bShortTest || !bCanReset)   // Still OK to try the short test?
 389         {                       // Always test if no reset - we want state update
 390                 unsigned int state, error;
 391                 dev_dbg(&pdx->interface->dev, "%s->Get1401State", __func__);
 392                 if (Get1401State(pdx, &state, &error) == U14ERR_NOERROR)        // Check on the 1401 state
 393                 {
 394                         if ((state & 0xFF) == 0)        // If call worked, check the status value
 395                                 bRet = true;    // If that was zero, all is OK, no reset needed
 396                 }
 397         }
 398
 399         if (!bRet && bCanReset) // If all not OK, then
 400         {
 401                 dev_info(&pdx->interface->dev, "%s->Is1401 %d %d %d %d",
 402                          __func__, bShortTest, pdx->sCurrentState, bTestBuff,
 403                          pdx->bForceReset);
 404                 bRet = Is1401(pdx);     //  do full test
 405         }
 406
 407         return bRet;
 408 }
 409
 410 /****************************************************************************
 411 ** Reset1401
 412 **
 413 ** Resets the 1401 and empties the i/o buffers
 414 *****************************************************************************/
 415 int Reset1401(DEVICE_EXTENSION * pdx)
 416 {
 417         mutex_lock(&pdx->io_mutex);     // Protect disconnect from new i/o
 418         dev_dbg(&pdx->interface->dev, "ABout to call QuickCheck");
 419         QuickCheck(pdx, true, true);    // Check 1401, reset if not OK
 420         mutex_unlock(&pdx->io_mutex);
 421         return U14ERR_NOERROR;
 422 }
 423
 424 /****************************************************************************
 425 ** GetChar
 426 **
 427 ** Gets a single character from the 1401
 428 ****************************************************************************/
 429 int GetChar(DEVICE_EXTENSION * pdx)
 430 {
 431         int iReturn = U14ERR_NOIN;      // assume we will get  nothing
 432         mutex_lock(&pdx->io_mutex);     // Protect disconnect from new i/o
 433
 434         dev_dbg(&pdx->interface->dev, "GetChar");
 435
 436         Allowi(pdx, false);     // Make sure char reads are running
 437         SendChars(pdx);         // and send any buffered chars
 438
 439         spin_lock_irq(&pdx->charInLock);
 440         if (pdx->dwNumInput > 0)        // worth looking
 441         {
 442                 iReturn = pdx->inputBuffer[pdx->dwInBuffGet++];
 443                 if (pdx->dwInBuffGet >= INBUF_SZ)
 444                         pdx->dwInBuffGet = 0;
 445                 pdx->dwNumInput--;
 446         } else
 447                 iReturn = U14ERR_NOIN;  // no input data to read
 448         spin_unlock_irq(&pdx->charInLock);
 449
 450         Allowi(pdx, false);     // Make sure char reads are running
 451
 452         mutex_unlock(&pdx->io_mutex);   // Protect disconnect from new i/o
 453         return iReturn;
 454 }
 455
 456 /****************************************************************************
 457 ** GetString
 458 **
 459 ** Gets a string from the 1401. Returns chars up to the next CR or when
 460 ** there are no more to read or nowhere to put them. CR is translated to
 461 ** 0 and counted as a character. If the string does not end in a 0, we will
 462 ** add one, if there is room, but it is not counted as a character.
 463 **
 464 ** returns the count of characters (including the terminator, or 0 if none
 465 ** or a negative error code.
 466 ****************************************************************************/
 467 int GetString(DEVICE_EXTENSION * pdx, char __user * pUser, int n)
 468 {
 469         int nAvailable;         // character in the buffer
 470         int iReturn = U14ERR_NOIN;
 471         if (n <= 0)
 472                 return -ENOMEM;
 473
 474         mutex_lock(&pdx->io_mutex);     // Protect disconnect from new i/o
 475         Allowi(pdx, false);     // Make sure char reads are running
 476         SendChars(pdx);         // and send any buffered chars
 477
 478         spin_lock_irq(&pdx->charInLock);
 479         nAvailable = pdx->dwNumInput;   // characters available now
 480         if (nAvailable > n)     // read max of space in pUser...
 481                 nAvailable = n; // ...or input characters
 482
 483         if (nAvailable > 0)     // worth looking?
 484         {
 485                 char buffer[INBUF_SZ + 1];      // space for a linear copy of data
 486                 int nGot = 0;
 487                 int nCopyToUser;        // number to copy to user
 488                 char cData;
 489                 do {
 490                         cData = pdx->inputBuffer[pdx->dwInBuffGet++];
 491                         if (cData == CR_CHAR)   // replace CR with zero
 492                                 cData = (char)0;
 493
 494                         if (pdx->dwInBuffGet >= INBUF_SZ)
 495                                 pdx->dwInBuffGet = 0;   // wrap buffer pointer
 496
 497                         buffer[nGot++] = cData; // save the output
 498                 }
 499                 while ((nGot < nAvailable) && cData);
 500
 501                 nCopyToUser = nGot;     // what to copy...
 502                 if (cData)      // do we need null
 503                 {
 504                         buffer[nGot] = (char)0; // make it tidy
 505                         if (nGot < n)   // if space in user buffer...
 506                                 ++nCopyToUser;  // ...copy the 0 as well.
 507                 }
 508
 509                 pdx->dwNumInput -= nGot;
 510                 spin_unlock_irq(&pdx->charInLock);
 511
 512                 dev_dbg(&pdx->interface->dev,
 513                         "GetString read %d characters >%s<", nGot, buffer);
 514                 if (copy_to_user(pUser, buffer, nCopyToUser))
 515                         iReturn = -EFAULT;
 516                 else
 517                         iReturn = nGot;         // report characters read
 518         } else
 519                 spin_unlock_irq(&pdx->charInLock);
 520
 521         Allowi(pdx, false);     // Make sure char reads are running
 522         mutex_unlock(&pdx->io_mutex);   // Protect disconnect from new i/o
 523
 524         return iReturn;
 525 }
 526
 527 /*******************************************************************************
 528 ** Get count of characters in the inout buffer.
 529 *******************************************************************************/
 530 int Stat1401(DEVICE_EXTENSION * pdx)
 531 {
 532         int iReturn;
 533         mutex_lock(&pdx->io_mutex);     // Protect disconnect from new i/o
 534         Allowi(pdx, false);     // make sure we allow pending chars
 535         SendChars(pdx);         // in both directions
 536         iReturn = pdx->dwNumInput;      // no lock as single read
 537         mutex_unlock(&pdx->io_mutex);   // Protect disconnect from new i/o
 538         return iReturn;
 539 }
 540
 541 /****************************************************************************
 542 ** LineCount
 543 **
 544 ** Returns the number of newline chars in the buffer. There is no need for
 545 ** any fancy interlocks as we only read the interrupt routine data, and the
 546 ** system is arranged so nothing can be destroyed.
 547 ****************************************************************************/
 548 int LineCount(DEVICE_EXTENSION * pdx)
 549 {
 550         int iReturn = 0;        // will be count of line ends
 551
 552         mutex_lock(&pdx->io_mutex);     // Protect disconnect from new i/o
 553         Allowi(pdx, false);     // Make sure char reads are running
 554         SendChars(pdx);         // and send any buffered chars
 555         spin_lock_irq(&pdx->charInLock);        // Get protection
 556
 557         if (pdx->dwNumInput > 0)        // worth looking?
 558         {
 559                 unsigned int dwIndex = pdx->dwInBuffGet;        // start at first available
 560                 unsigned int dwEnd = pdx->dwInBuffPut;  // Position for search end
 561                 do {
 562                         if (pdx->inputBuffer[dwIndex++] == CR_CHAR)
 563                                 ++iReturn;      // inc count if CR
 564
 565                         if (dwIndex >= INBUF_SZ)        // see if we fall off buff
 566                                 dwIndex = 0;
 567                 }
 568                 while (dwIndex != dwEnd);       // go to last available
 569         }
 570
 571         spin_unlock_irq(&pdx->charInLock);
 572         dev_dbg(&pdx->interface->dev, "LineCount returned %d", iReturn);
 573         mutex_unlock(&pdx->io_mutex);   // Protect disconnect from new i/o
 574         return iReturn;
 575 }
 576
 577 /****************************************************************************
 578 ** GetOutBufSpace
 579 **
 580 ** Gets the space in the output buffer. Called from user code.
 581 *****************************************************************************/
 582 int GetOutBufSpace(DEVICE_EXTENSION * pdx)
 583 {
 584         int iReturn;
 585         mutex_lock(&pdx->io_mutex);     // Protect disconnect from new i/o
 586         SendChars(pdx);         // send any buffered chars
 587         iReturn = (int)(OUTBUF_SZ - pdx->dwNumOutput);  // no lock needed for single read
 588         dev_dbg(&pdx->interface->dev, "OutBufSpace %d", iReturn);
 589         mutex_unlock(&pdx->io_mutex);   // Protect disconnect from new i/o
 590         return iReturn;
 591 }
 592
 593 /****************************************************************************
 594 **
 595 ** ClearArea
 596 **
 597 ** Clears up a transfer area. This is always called in the context of a user
 598 ** request, never from a call-back.
 599 ****************************************************************************/
 600 int ClearArea(DEVICE_EXTENSION * pdx, int nArea)
 601 {
 602         int iReturn = U14ERR_NOERROR;
 603
 604         if ((nArea < 0) || (nArea >= MAX_TRANSAREAS)) {
 605                 iReturn = U14ERR_BADAREA;
 606                 dev_err(&pdx->interface->dev, "%s Attempt to clear area %d",
 607                         __func__, nArea);
 608         } else {
 609                 TRANSAREA *pTA = &pdx->rTransDef[nArea];        // to save typing
 610                 if (!pTA->bUsed)        // if not used...
 611                         iReturn = U14ERR_NOTSET;        // ...nothing to be done
 612                 else {
 613                         // We must save the memory we return as we shouldn't mess with memory while
 614                         // holding a spin lock.
 615                         struct page **pPages = 0;       // save page address list
 616                         int nPages = 0; // and number of pages
 617                         int np;
 618
 619                         dev_dbg(&pdx->interface->dev, "%s area %d", __func__,
 620                                 nArea);
 621                         spin_lock_irq(&pdx->stagedLock);
 622                         if ((pdx->StagedId == nArea)
 623                             && (pdx->dwDMAFlag > MODE_CHAR)) {
 624                                 iReturn = U14ERR_UNLOCKFAIL;    // cannot delete as in use
 625                                 dev_err(&pdx->interface->dev,
 626                                         "%s call on area %d while active",
 627                                         __func__, nArea);
 628                         } else {
 629                                 pPages = pTA->pPages;   // save page address list
 630                                 nPages = pTA->nPages;   // and page count
 631                                 if (pTA->dwEventSz)     // if events flagging in use
 632                                         wake_up_interruptible(&pTA->wqEvent);   // release anything that was waiting
 633
 634                                 if (pdx->bXFerWaiting
 635                                     && (pdx->rDMAInfo.wIdent == nArea))
 636                                         pdx->bXFerWaiting = false;      // Cannot have pending xfer if area cleared
 637
 638                                 // Clean out the TRANSAREA except for the wait queue, which is at the end
 639                                 // This sets bUsed to false and dwEventSz to 0 to say area not used and no events.
 640                                 memset(pTA, 0,
 641                                        sizeof(TRANSAREA) -
 642                                        sizeof(wait_queue_head_t));
 643                         }
 644                         spin_unlock_irq(&pdx->stagedLock);
 645
 646                         if (pPages)     // if we decided to release the memory
 647                         {
 648                                 // Now we must undo the pinning down of the pages. We will assume the worst and mark
 649                                 // all the pages as dirty. Don't be tempted to move this up above as you must not be
 650                                 // holding a spin lock to do this stuff as it is not atomic.
 651                                 dev_dbg(&pdx->interface->dev, "%s nPages=%d",
 652                                         __func__, nPages);
 653
 654                                 for (np = 0; np < nPages; ++np) {
 655                                         if (pPages[np]) {
 656                                                 SetPageDirty(pPages[np]);
 657                                                 page_cache_release(pPages[np]);
 658                                         }
 659                                 }
 660
 661                                 kfree(pPages);
 662                                 dev_dbg(&pdx->interface->dev,
 663                                         "%s kfree(pPages) done", __func__);
 664                         }
 665                 }
 666         }
 667
 668         return iReturn;
 669 }
 670
 671 /****************************************************************************
 672 ** SetArea
 673 **
 674 ** Sets up a transfer area - the functional part. Called by both
 675 ** SetTransfer and SetCircular.
 676 ****************************************************************************/
 677 static int SetArea(DEVICE_EXTENSION * pdx, int nArea, char __user * puBuf,
 678                    unsigned int dwLength, bool bCircular, bool bCircToHost)
 679 {
 680         // Start by working out the page aligned start of the area and the size
 681         // of the area in pages, allowing for the start not being aligned and the
 682         // end needing to be rounded up to a page boundary.
 683         unsigned long ulStart = ((unsigned long)puBuf) & PAGE_MASK;
 684         unsigned int ulOffset = ((unsigned long)puBuf) & (PAGE_SIZE - 1);
 685         int len = (dwLength + ulOffset + PAGE_SIZE - 1) >> PAGE_SHIFT;
 686
 687         TRANSAREA *pTA = &pdx->rTransDef[nArea];        // to save typing
 688         struct page **pPages = 0;       // space for page tables
 689         int nPages = 0;         // and number of pages
 690
 691         int iReturn = ClearArea(pdx, nArea);    // see if OK to use this area
 692         if ((iReturn != U14ERR_NOTSET) &&       // if not area unused and...
 693             (iReturn != U14ERR_NOERROR))        // ...not all OK, then...
 694                 return iReturn; // ...we cannot use this area
 695
 696         if (!access_ok(VERIFY_WRITE, puBuf, dwLength))  // if we cannot access the memory...
 697                 return -EFAULT; // ...then we are done
 698
 699         // Now allocate space to hold the page pointer and virtual address pointer tables
 700         pPages = kmalloc(len * sizeof(struct page *), GFP_KERNEL);
 701         if (!pPages) {
 702                 iReturn = U14ERR_NOMEMORY;
 703                 goto error;
 704         }
 705         dev_dbg(&pdx->interface->dev, "%s %p, length=%06x, circular %d",
 706                 __func__, puBuf, dwLength, bCircular);
 707
 708         // To pin down user pages we must first acquire the mapping semaphore.
 709         down_read(&current->mm->mmap_sem);      // get memory map semaphore
 710         nPages =
 711             get_user_pages(current, current->mm, ulStart, len, 1, 0, pPages, 0);
 712         up_read(&current->mm->mmap_sem);        // release the semaphore
 713         dev_dbg(&pdx->interface->dev, "%s nPages = %d", __func__, nPages);
 714
 715         if (nPages > 0)         // if we succeeded
 716         {
 717                 // If you are tempted to use page_address (form LDD3), forget it. You MUST use
 718                 // kmap() or kmap_atomic() to get a virtual address. page_address will give you
 719                 // (null) or at least it does in this context with an x86 machine.
 720                 spin_lock_irq(&pdx->stagedLock);
 721                 pTA->lpvBuff = puBuf;   // keep start of region (user address)
 722                 pTA->dwBaseOffset = ulOffset;   // save offset in first page to start of xfer
 723                 pTA->dwLength = dwLength;       // Size if the region in bytes
 724                 pTA->pPages = pPages;   // list of pages that are used by buffer
 725                 pTA->nPages = nPages;   // number of pages
 726
 727                 pTA->bCircular = bCircular;
 728                 pTA->bCircToHost = bCircToHost;
 729
 730                 pTA->aBlocks[0].dwOffset = 0;
 731                 pTA->aBlocks[0].dwSize = 0;
 732                 pTA->aBlocks[1].dwOffset = 0;
 733                 pTA->aBlocks[1].dwSize = 0;
 734                 pTA->bUsed = true;      // This is now a used block
 735
 736                 spin_unlock_irq(&pdx->stagedLock);
 737                 iReturn = U14ERR_NOERROR;       // say all was well
 738         } else {
 739                 iReturn = U14ERR_LOCKFAIL;
 740                 goto error;
 741         }
 742
 743         return iReturn;
 744
 745 error:
 746         kfree(pPages);
 747         return iReturn;
 748 }
 749
 750 /****************************************************************************
 751 ** SetTransfer
 752 **
 753 ** Sets up a transfer area record. If the area is already set, we attempt to
 754 ** unset it. Unsetting will fail if the area is booked, and a transfer to that
 755 ** area is in progress. Otherwise, we will release the area and re-assign it.
 756 ****************************************************************************/
 757 int SetTransfer(DEVICE_EXTENSION * pdx, TRANSFERDESC __user * pTD)
 758 {
 759         int iReturn;
 760         TRANSFERDESC td;
 761
 762         if (copy_from_user(&td, pTD, sizeof(td)))
 763                 return -EFAULT;
 764
 765         mutex_lock(&pdx->io_mutex);
 766         dev_dbg(&pdx->interface->dev, "%s area:%d, size:%08x", __func__,
 767                 td.wAreaNum, td.dwLength);
 768         // The strange cast is done so that we don't get warnings in 32-bit linux about the size of the
 769         // pointer. The pointer is always passed as a 64-bit object so that we don't have problems using
 770         // a 32-bit program on a 64-bit system. unsigned long is 64-bits on a 64-bit system.
 771         iReturn =
 772             SetArea(pdx, td.wAreaNum,
 773                     (char __user *)((unsigned long)td.lpvBuff), td.dwLength,
 774                     false, false);
 775         mutex_unlock(&pdx->io_mutex);
 776         return iReturn;
 777 }
 778
 779 /****************************************************************************
 780 ** UnSetTransfer
 781 ** Erases a transfer area record
 782 ****************************************************************************/
 783 int UnsetTransfer(DEVICE_EXTENSION * pdx, int nArea)
 784 {
 785         int iReturn;
 786         mutex_lock(&pdx->io_mutex);
 787         iReturn = ClearArea(pdx, nArea);
 788         mutex_unlock(&pdx->io_mutex);
 789         return iReturn;
 790 }
 791
 792 /****************************************************************************
 793 ** SetEvent
 794 ** Creates an event that we can test for based on a transfer to/from an area.
 795 ** The area must be setup for a transfer. We attempt to simulate the Windows
 796 ** driver behavior for events (as we don't actually use them), which is to
 797 ** pretend that whatever the user asked for was achieved, so we return 1 if
 798 ** try to create one, and 0 if they ask to remove (assuming all else was OK).
 799 ****************************************************************************/
 800 int SetEvent(DEVICE_EXTENSION * pdx, TRANSFEREVENT __user * pTE)
 801 {
 802         int iReturn = U14ERR_NOERROR;
 803         TRANSFEREVENT te;
 804
 805         // get a local copy of the data
 806         if (copy_from_user(&te, pTE, sizeof(te)))
 807                 return -EFAULT;
 808
 809         if (te.wAreaNum >= MAX_TRANSAREAS)      // the area must exist
 810                 return U14ERR_BADAREA;
 811         else {
 812                 TRANSAREA *pTA = &pdx->rTransDef[te.wAreaNum];
 813                 mutex_lock(&pdx->io_mutex);     // make sure we have no competitor
 814                 spin_lock_irq(&pdx->stagedLock);
 815                 if (pTA->bUsed) // area must be in use
 816                 {
 817                         pTA->dwEventSt = te.dwStart;    // set area regions
 818                         pTA->dwEventSz = te.dwLength;   // set size (0 cancels it)
 819                         pTA->bEventToHost = te.wFlags & 1;      // set the direction
 820                         pTA->iWakeUp = 0;       // zero the wake up count
 821                 } else
 822                         iReturn = U14ERR_NOTSET;
 823                 spin_unlock_irq(&pdx->stagedLock);
 824                 mutex_unlock(&pdx->io_mutex);
 825         }
 826         return iReturn ==
 827             U14ERR_NOERROR ? (te.iSetEvent ? 1 : U14ERR_NOERROR) : iReturn;
 828 }
 829
 830 /****************************************************************************
 831 ** WaitEvent
 832 ** Sleep the process with a timeout waiting for an event. Returns the number
 833 ** of times that a block met the event condition since we last cleared it or
 834 ** 0 if timed out, or -ve error (bad area or not set, or signal).
 835 ****************************************************************************/
 836 int WaitEvent(DEVICE_EXTENSION * pdx, int nArea, int msTimeOut)
 837 {
 838         int iReturn;
 839         if ((unsigned)nArea >= MAX_TRANSAREAS)
 840                 return U14ERR_BADAREA;
 841         else {
 842                 int iWait;
 843                 TRANSAREA *pTA = &pdx->rTransDef[nArea];
 844                 msTimeOut = (msTimeOut * HZ + 999) / 1000;      // convert timeout to jiffies
 845
 846                 // We cannot wait holding the mutex, but we check the flags while holding
 847                 // it. This may well be pointless as another thread could get in between
 848                 // releasing it and the wait call. However, this would have to clear the
 849                 // iWakeUp flag. However, the !pTA-bUsed may help us in this case.
 850                 mutex_lock(&pdx->io_mutex);     // make sure we have no competitor
 851                 if (!pTA->bUsed || !pTA->dwEventSz)     // check something to wait for...
 852                         return U14ERR_NOTSET;   // ...else we do nothing
 853                 mutex_unlock(&pdx->io_mutex);
 854
 855                 if (msTimeOut)
 856                         iWait =
 857                             wait_event_interruptible_timeout(pTA->wqEvent,
 858                                                              pTA->iWakeUp
 859                                                              || !pTA->bUsed,
 860                                                              msTimeOut);
 861                 else
 862                         iWait =
 863                             wait_event_interruptible(pTA->wqEvent, pTA->iWakeUp
 864                                                      || !pTA->bUsed);
 865                 if (iWait)
 866                         iReturn = -ERESTARTSYS; // oops - we have had a SIGNAL
 867                 else
 868                         iReturn = pTA->iWakeUp; // else the wakeup count
 869
 870                 spin_lock_irq(&pdx->stagedLock);
 871                 pTA->iWakeUp = 0;       // clear the flag
 872                 spin_unlock_irq(&pdx->stagedLock);
 873         }
 874         return iReturn;
 875 }
 876
 877 /****************************************************************************
 878 ** TestEvent
 879 ** Test the event to see if a WaitEvent would return immediately. Returns the
 880 ** number of times a block completed since the last call, or 0 if none or a
 881 ** negative error.
 882 ****************************************************************************/
 883 int TestEvent(DEVICE_EXTENSION * pdx, int nArea)
 884 {
 885         int iReturn;
 886         if ((unsigned)nArea >= MAX_TRANSAREAS)
 887                 iReturn = U14ERR_BADAREA;
 888         else {
 889                 TRANSAREA *pTA = &pdx->rTransDef[nArea];
 890                 mutex_lock(&pdx->io_mutex);     // make sure we have no competitor
 891                 spin_lock_irq(&pdx->stagedLock);
 892                 iReturn = pTA->iWakeUp; // get wakeup count since last call
 893                 pTA->iWakeUp = 0;       // clear the count
 894                 spin_unlock_irq(&pdx->stagedLock);
 895                 mutex_unlock(&pdx->io_mutex);
 896         }
 897         return iReturn;
 898 }
 899
 900 /****************************************************************************
 901 ** GetTransferInfo
 902 ** Puts the current state of the 1401 in a TGET_TX_BLOCK.
 903 *****************************************************************************/
 904 int GetTransfer(DEVICE_EXTENSION * pdx, TGET_TX_BLOCK __user * pTX)
 905 {
 906         int iReturn = U14ERR_NOERROR;
 907         unsigned int dwIdent;
 908
 909         mutex_lock(&pdx->io_mutex);
 910         dwIdent = pdx->StagedId;        // area ident for last xfer
 911         if (dwIdent >= MAX_TRANSAREAS)
 912                 iReturn = U14ERR_BADAREA;
 913         else {
 914                 // Return the best information we have - we don't have physical addresses
 915                 TGET_TX_BLOCK *tx;
 916
 917                 tx = kzalloc(sizeof(*tx), GFP_KERNEL);
 918                 if (!tx) {
 919                         mutex_unlock(&pdx->io_mutex);
 920                         return -ENOMEM;
 921                 }
 922                 tx->size = pdx->rTransDef[dwIdent].dwLength;
 923                 tx->linear = (long long)((long)pdx->rTransDef[dwIdent].lpvBuff);
 924                 tx->avail = GET_TX_MAXENTRIES;  // how many blocks we could return
 925                 tx->used = 1;   // number we actually return
 926                 tx->entries[0].physical =
 927                     (long long)(tx->linear + pdx->StagedOffset);
 928                 tx->entries[0].size = tx->size;
 929
 930                 if (copy_to_user(pTX, tx, sizeof(*tx)))
 931                         iReturn = -EFAULT;
 932                 kfree(tx);
 933         }
 934         mutex_unlock(&pdx->io_mutex);
 935         return iReturn;
 936 }
 937
 938 /****************************************************************************
 939 ** KillIO1401
 940 **
 941 ** Empties the host i/o buffers
 942 ****************************************************************************/
 943 int KillIO1401(DEVICE_EXTENSION * pdx)
 944 {
 945         dev_dbg(&pdx->interface->dev, "%s", __func__);
 946         mutex_lock(&pdx->io_mutex);
 947         FlushOutBuff(pdx);
 948         FlushInBuff(pdx);
 949         mutex_unlock(&pdx->io_mutex);
 950         return U14ERR_NOERROR;
 951 }
 952
 953 /****************************************************************************
 954 ** BlkTransState
 955 ** Returns a 0 or a 1 for whether DMA is happening. No point holding a mutex
 956 ** for this as it only does one read.
 957 *****************************************************************************/
 958 int BlkTransState(DEVICE_EXTENSION * pdx)
 959 {
 960         int iReturn = pdx->dwDMAFlag != MODE_CHAR;
 961         dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn);
 962         return iReturn;
 963 }
 964
 965 /****************************************************************************
 966 ** StateOf1401
 967 **
 968 ** Puts the current state of the 1401 in the Irp return buffer.
 969 *****************************************************************************/
 970 int StateOf1401(DEVICE_EXTENSION * pdx)
 971 {
 972         int iReturn;
 973         mutex_lock(&pdx->io_mutex);
 974
 975         QuickCheck(pdx, false, false);  // get state up to date, no reset
 976         iReturn = pdx->sCurrentState;
 977
 978         mutex_unlock(&pdx->io_mutex);
 979         dev_dbg(&pdx->interface->dev, "%s = %d", __func__, iReturn);
 980
 981         return iReturn;
 982 }
 983
 984 /****************************************************************************
 985 ** StartSelfTest
 986 **
 987 ** Initiates a self-test cycle. The assumption is that we have no interrupts
 988 ** active, so we should make sure that this is the case.
 989 *****************************************************************************/
 990 int StartSelfTest(DEVICE_EXTENSION * pdx)
 991 {
 992         int nGot;
 993         mutex_lock(&pdx->io_mutex);
 994         dev_dbg(&pdx->interface->dev, "%s", __func__);
 995
 996         ced_draw_down(pdx);     // wait for, then kill outstanding Urbs
 997         FlushInBuff(pdx);       // Clear out input buffer & pipe
 998         FlushOutBuff(pdx);      // Clear output buffer & pipe
 999 //    ReadWrite_Cancel(pDeviceObject);        /* so things stay tidy */
1000         pdx->dwDMAFlag = MODE_CHAR;     /* Clear DMA mode flags here */
1001
1002         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
1003         pdx->ulSelfTestTime = jiffies + HZ * 30;        // 30 seconds into the future
1004
1005         mutex_unlock(&pdx->io_mutex);
1006         if (nGot < 0)
1007                 dev_err(&pdx->interface->dev, "%s err=%d", __func__, nGot);
1008         return nGot < 0 ? U14ERR_FAIL : U14ERR_NOERROR;
1009 }
1010
1011 /****************************************************************************
1012 ** CheckSelfTest
1013 **
1014 ** Check progress of a self-test cycle
1015 ****************************************************************************/
1016 int CheckSelfTest(DEVICE_EXTENSION * pdx, TGET_SELFTEST __user * pGST)
1017 {
1018         unsigned int state, error;
1019         int iReturn;
1020         TGET_SELFTEST gst;      // local work space
1021         memset(&gst, 0, sizeof(gst));   // clear out the space (sets code 0)
1022
1023         mutex_lock(&pdx->io_mutex);
1024
1025         dev_dbg(&pdx->interface->dev, "%s", __func__);
1026         iReturn = Get1401State(pdx, &state, &error);
1027         if (iReturn == U14ERR_NOERROR)  // Only accept zero if it happens twice
1028                 iReturn = Get1401State(pdx, &state, &error);
1029
1030         if (iReturn != U14ERR_NOERROR)  // Self-test can cause comms errors
1031         {                       // so we assume still testing
1032                 dev_err(&pdx->interface->dev,
1033                         "%s Get1401State=%d, assuming still testing", __func__,
1034                         iReturn);
1035                 state = 0x80;   // Force still-testing, no error
1036                 error = 0;
1037                 iReturn = U14ERR_NOERROR;
1038         }
1039
1040         if ((state == -1) && (error == -1))     // If Get1401State had problems
1041         {
1042                 dev_err(&pdx->interface->dev,
1043                         "%s Get1401State failed, assuming still testing",
1044                         __func__);
1045                 state = 0x80;   // Force still-testing, no error
1046                 error = 0;
1047         }
1048
1049         if ((state & 0xFF) == 0x80)     // If we are still in self-test
1050         {
1051                 if (state & 0x00FF0000) // Have we got an error?
1052                 {
1053                         gst.code = (state & 0x00FF0000) >> 16;  // read the error code
1054                         gst.x = error & 0x0000FFFF;     // Error data X
1055                         gst.y = (error & 0xFFFF0000) >> 16;     // and data Y
1056                         dev_dbg(&pdx->interface->dev, "Self-test error code %d",
1057                                 gst.code);
1058                 } else          // No error, check for timeout
1059                 {
1060                         unsigned long ulNow = jiffies;  // get current time
1061                         if (time_after(ulNow, pdx->ulSelfTestTime)) {
1062                                 gst.code = -2;  // Flag the timeout
1063                                 dev_dbg(&pdx->interface->dev,
1064                                         "Self-test timed-out");
1065                         } else
1066                                 dev_dbg(&pdx->interface->dev,
1067                                         "Self-test on-going");
1068                 }
1069         } else {
1070                 gst.code = -1;  // Flag the test is done
1071                 dev_dbg(&pdx->interface->dev, "Self-test done");
1072         }
1073
1074         if (gst.code < 0)       // If we have a problem or finished
1075         {                       // If using the 2890 we should reset properly
1076                 if ((pdx->nPipes == 4) && (pdx->s1401Type <= TYPEPOWER))
1077                         Is1401(pdx);    // Get 1401 reset and OK
1078                 else
1079                         QuickCheck(pdx, true, true);    // Otherwise check without reset unless problems
1080         }
1081         mutex_unlock(&pdx->io_mutex);
1082
1083         if (copy_to_user(pGST, &gst, sizeof(gst)))
1084                 return -EFAULT;
1085
1086         return iReturn;
1087 }
1088
1089 /****************************************************************************
1090 ** TypeOf1401
1091 **
1092 ** Returns code for standard, plus, micro1401, power1401 or none
1093 ****************************************************************************/
1094 int TypeOf1401(DEVICE_EXTENSION * pdx)
1095 {
1096         int iReturn = TYPEUNKNOWN;
1097         mutex_lock(&pdx->io_mutex);
1098         dev_dbg(&pdx->interface->dev, "%s", __func__);
1099
1100         switch (pdx->s1401Type) {
1101         case TYPE1401:
1102                 iReturn = U14ERR_STD;
1103                 break;          // Handle these types directly
1104         case TYPEPLUS:
1105                 iReturn = U14ERR_PLUS;
1106                 break;
1107         case TYPEU1401:
1108                 iReturn = U14ERR_U1401;
1109                 break;
1110         default:
1111                 if ((pdx->s1401Type >= TYPEPOWER) && (pdx->s1401Type <= 25))
1112                         iReturn = pdx->s1401Type + 4;   // We can calculate types
1113                 else            //  for up-coming 1401 designs
1114                         iReturn = TYPEUNKNOWN;  // Don't know or not there
1115         }
1116         dev_dbg(&pdx->interface->dev, "%s %d", __func__, iReturn);
1117         mutex_unlock(&pdx->io_mutex);
1118
1119         return iReturn;
1120 }
1121
1122 /****************************************************************************
1123 ** TransferFlags
1124 **
1125 ** Returns flags on block transfer abilities
1126 ****************************************************************************/
1127 int TransferFlags(DEVICE_EXTENSION * pdx)
1128 {
1129         int iReturn = U14TF_MULTIA | U14TF_DIAG |       // we always have multiple DMA area
1130             U14TF_NOTIFY | U14TF_CIRCTH;        // diagnostics, notify and circular
1131         dev_dbg(&pdx->interface->dev, "%s", __func__);
1132         mutex_lock(&pdx->io_mutex);
1133         if (pdx->bIsUSB2)       // Set flag for USB2 if appropriate
1134                 iReturn |= U14TF_USB2;
1135         mutex_unlock(&pdx->io_mutex);
1136
1137         return iReturn;
1138 }
1139
1140 /***************************************************************************
1141 ** DbgCmd1401
1142 ** Issues a debug\diagnostic command to the 1401 along with a 32-bit datum
1143 ** This is a utility command used for dbg operations.
1144 */
1145 static int DbgCmd1401(DEVICE_EXTENSION * pdx, unsigned char cmd,
1146                       unsigned int data)
1147 {
1148         int iReturn;
1149         dev_dbg(&pdx->interface->dev, "%s entry", __func__);
1150         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
1151         if (iReturn < 0)
1152                 dev_err(&pdx->interface->dev, "%s fail code=%d", __func__,
1153                         iReturn);
1154
1155         return iReturn;
1156 }
1157
1158 /****************************************************************************
1159 ** DbgPeek
1160 **
1161 ** Execute the diagnostic peek operation. Uses address, width and repeats.
1162 ****************************************************************************/
1163 int DbgPeek(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
1164 {
1165         int iReturn;
1166         TDBGBLOCK db;
1167
1168         if (copy_from_user(&db, pDB, sizeof(db)))
1169                 return -EFAULT;
1170
1171         mutex_lock(&pdx->io_mutex);
1172         dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr);
1173
1174         iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr);
1175         if (iReturn == U14ERR_NOERROR)
1176                 iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
1177         if (iReturn == U14ERR_NOERROR)
1178                 iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
1179         if (iReturn == U14ERR_NOERROR)
1180                 iReturn = DbgCmd1401(pdx, DB_PEEK, 0);
1181         mutex_unlock(&pdx->io_mutex);
1182
1183         return iReturn;
1184 }
1185
1186 /****************************************************************************
1187 ** DbgPoke
1188 **
1189 ** Execute the diagnostic poke operation. Parameters are in the CSBLOCK struct
1190 ** in order address, size, repeats and value to poke.
1191 ****************************************************************************/
1192 int DbgPoke(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
1193 {
1194         int iReturn;
1195         TDBGBLOCK db;
1196
1197         if (copy_from_user(&db, pDB, sizeof(db)))
1198                 return -EFAULT;
1199
1200         mutex_lock(&pdx->io_mutex);
1201         dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr);
1202
1203         iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr);
1204         if (iReturn == U14ERR_NOERROR)
1205                 iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
1206         if (iReturn == U14ERR_NOERROR)
1207                 iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
1208         if (iReturn == U14ERR_NOERROR)
1209                 iReturn = DbgCmd1401(pdx, DB_POKE, db.iData);
1210         mutex_unlock(&pdx->io_mutex);
1211
1212         return iReturn;
1213 }
1214
1215 /****************************************************************************
1216 ** DbgRampData
1217 **
1218 ** Execute the diagnostic ramp data operation. Parameters are in the CSBLOCK struct
1219 ** in order address, default, enable mask, size and repeats.
1220 ****************************************************************************/
1221 int DbgRampData(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
1222 {
1223         int iReturn;
1224         TDBGBLOCK db;
1225
1226         if (copy_from_user(&db, pDB, sizeof(db)))
1227                 return -EFAULT;
1228
1229         mutex_lock(&pdx->io_mutex);
1230         dev_dbg(&pdx->interface->dev, "%s @ %08x", __func__, db.iAddr);
1231
1232         iReturn = DbgCmd1401(pdx, DB_SETADD, db.iAddr);
1233         if (iReturn == U14ERR_NOERROR)
1234                 iReturn = DbgCmd1401(pdx, DB_SETDEF, db.iDefault);
1235         if (iReturn == U14ERR_NOERROR)
1236                 iReturn = DbgCmd1401(pdx, DB_SETMASK, db.iMask);
1237         if (iReturn == U14ERR_NOERROR)
1238                 iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
1239         if (iReturn == U14ERR_NOERROR)
1240                 iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
1241         if (iReturn == U14ERR_NOERROR)
1242                 iReturn = DbgCmd1401(pdx, DB_RAMPD, 0);
1243         mutex_unlock(&pdx->io_mutex);
1244
1245         return iReturn;
1246 }
1247
1248 /****************************************************************************
1249 ** DbgRampAddr
1250 **
1251 ** Execute the diagnostic ramp address operation
1252 ****************************************************************************/
1253 int DbgRampAddr(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
1254 {
1255         int iReturn;
1256         TDBGBLOCK db;
1257
1258         if (copy_from_user(&db, pDB, sizeof(db)))
1259                 return -EFAULT;
1260
1261         mutex_lock(&pdx->io_mutex);
1262         dev_dbg(&pdx->interface->dev, "%s", __func__);
1263
1264         iReturn = DbgCmd1401(pdx, DB_SETDEF, db.iDefault);
1265         if (iReturn == U14ERR_NOERROR)
1266                 iReturn = DbgCmd1401(pdx, DB_SETMASK, db.iMask);
1267         if (iReturn == U14ERR_NOERROR)
1268                 iReturn = DbgCmd1401(pdx, DB_WIDTH, db.iWidth);
1269         if (iReturn == U14ERR_NOERROR)
1270                 iReturn = DbgCmd1401(pdx, DB_REPEATS, db.iRepeats);
1271         if (iReturn == U14ERR_NOERROR)
1272                 iReturn = DbgCmd1401(pdx, DB_RAMPA, 0);
1273         mutex_unlock(&pdx->io_mutex);
1274
1275         return iReturn;
1276 }
1277
1278 /****************************************************************************
1279 ** DbgGetData
1280 **
1281 ** Retrieve the data resulting from the last debug Peek operation
1282 ****************************************************************************/
1283 int DbgGetData(DEVICE_EXTENSION * pdx, TDBGBLOCK __user * pDB)
1284 {
1285         int iReturn;
1286         TDBGBLOCK db;
1287         memset(&db, 0, sizeof(db));     // fill returned block with 0s
1288
1289         mutex_lock(&pdx->io_mutex);
1290         dev_dbg(&pdx->interface->dev, "%s", __func__);
1291
1292         // Read back the last peeked value from the 1401.
1293         iReturn = usb_control_msg(pdx->udev, usb_rcvctrlpipe(pdx->udev, 0),
1294                                   DB_DATA, (D_TO_H | VENDOR | DEVREQ), 0, 0,
1295                                   &db.iData, sizeof(db.iData), HZ);
1296         if (iReturn == sizeof(db.iData)) {
1297                 if (copy_to_user(pDB, &db, sizeof(db)))
1298                         iReturn = -EFAULT;
1299                 else
1300                         iReturn = U14ERR_NOERROR;
1301         } else
1302                 dev_err(&pdx->interface->dev, "%s failed, code %d", __func__,
1303                         iReturn);
1304
1305         mutex_unlock(&pdx->io_mutex);
1306
1307         return iReturn;
1308 }
1309
1310 /****************************************************************************
1311 ** DbgStopLoop
1312 **
1313 ** Stop any never-ending debug loop, we just call Get1401State for USB
1314 **
1315 ****************************************************************************/
1316 int DbgStopLoop(DEVICE_EXTENSION * pdx)
1317 {
1318         int iReturn;
1319         unsigned int uState, uErr;
1320
1321         mutex_lock(&pdx->io_mutex);
1322         dev_dbg(&pdx->interface->dev, "%s", __func__);
1323         iReturn = Get1401State(pdx, &uState, &uErr);
1324         mutex_unlock(&pdx->io_mutex);
1325
1326         return iReturn;
1327 }
1328
1329 /****************************************************************************
1330 ** SetCircular
1331 **
1332 ** Sets up a transfer area record for circular transfers. If the area is
1333 ** already set, we attempt to unset it. Unsetting will fail if the area is
1334 ** booked and a transfer to that area is in progress. Otherwise, we will
1335 ** release the area and re-assign it.
1336 ****************************************************************************/
1337 int SetCircular(DEVICE_EXTENSION * pdx, TRANSFERDESC __user * pTD)
1338 {
1339         int iReturn;
1340         bool bToHost;
1341         TRANSFERDESC td;
1342
1343         if (copy_from_user(&td, pTD, sizeof(td)))
1344                 return -EFAULT;
1345
1346         mutex_lock(&pdx->io_mutex);
1347         dev_dbg(&pdx->interface->dev, "%s area:%d, size:%08x", __func__,
1348                 td.wAreaNum, td.dwLength);
1349         bToHost = td.eSize != 0;        // this is used as the tohost flag
1350
1351         // The strange cast is done so that we don't get warnings in 32-bit linux about the size of the
1352         // pointer. The pointer is always passed as a 64-bit object so that we don't have problems using
1353         // a 32-bit program on a 64-bit system. unsigned long is 64-bits on a 64-bit system.
1354         iReturn =
1355             SetArea(pdx, td.wAreaNum,
1356                     (char __user *)((unsigned long)td.lpvBuff), td.dwLength,
1357                     true, bToHost);
1358         mutex_unlock(&pdx->io_mutex);
1359         return iReturn;
1360 }
1361
1362 /****************************************************************************
1363 ** GetCircBlock
1364 **
1365 ** Return the next available block of circularly-transferred data.
1366 ****************************************************************************/
1367 int GetCircBlock(DEVICE_EXTENSION * pdx, TCIRCBLOCK __user * pCB)
1368 {
1369         int iReturn = U14ERR_NOERROR;
1370         unsigned int nArea;
1371         TCIRCBLOCK cb;
1372
1373         dev_dbg(&pdx->interface->dev, "%s", __func__);
1374
1375         if (copy_from_user(&cb, pCB, sizeof(cb)))
1376                 return -EFAULT;
1377
1378         mutex_lock(&pdx->io_mutex);
1379
1380         nArea = cb.nArea;       // Retrieve parameters first
1381         cb.dwOffset = 0;        // set default result (nothing)
1382         cb.dwSize = 0;
1383
1384         if (nArea < MAX_TRANSAREAS)     // The area number must be OK
1385         {
1386                 TRANSAREA *pArea = &pdx->rTransDef[nArea];      // Pointer to relevant info
1387                 spin_lock_irq(&pdx->stagedLock);        // Lock others out
1388
1389                 if ((pArea->bUsed) && (pArea->bCircular) &&     // Must be circular area
1390                     (pArea->bCircToHost))       // For now at least must be to host
1391                 {
1392                         if (pArea->aBlocks[0].dwSize > 0)       // Got anything?
1393                         {
1394                                 cb.dwOffset = pArea->aBlocks[0].dwOffset;
1395                                 cb.dwSize = pArea->aBlocks[0].dwSize;
1396                                 dev_dbg(&pdx->interface->dev,
1397                                         "%s return block 0: %d bytes at %d",
1398                                         __func__, cb.dwSize, cb.dwOffset);
1399                         }
1400                 } else
1401                         iReturn = U14ERR_NOTSET;
1402
1403                 spin_unlock_irq(&pdx->stagedLock);
1404         } else
1405                 iReturn = U14ERR_BADAREA;
1406
1407         if (copy_to_user(pCB, &cb, sizeof(cb)))
1408                 iReturn = -EFAULT;
1409
1410         mutex_unlock(&pdx->io_mutex);
1411         return iReturn;
1412 }
1413
1414 /****************************************************************************
1415 ** FreeCircBlock
1416 **
1417 ** Frees a block of circularly-transferred data and returns the next one.
1418 ****************************************************************************/
1419 int FreeCircBlock(DEVICE_EXTENSION * pdx, TCIRCBLOCK __user * pCB)
1420 {
1421         int iReturn = U14ERR_NOERROR;
1422         unsigned int nArea, uStart, uSize;
1423         TCIRCBLOCK cb;
1424
1425         dev_dbg(&pdx->interface->dev, "%s", __func__);
1426
1427         if (copy_from_user(&cb, pCB, sizeof(cb)))
1428                 return -EFAULT;
1429
1430         mutex_lock(&pdx->io_mutex);
1431
1432         nArea = cb.nArea;       // Retrieve parameters first
1433         uStart = cb.dwOffset;
1434         uSize = cb.dwSize;
1435         cb.dwOffset = 0;        // then set default result (nothing)
1436         cb.dwSize = 0;
1437
1438         if (nArea < MAX_TRANSAREAS)     // The area number must be OK
1439         {
1440                 TRANSAREA *pArea = &pdx->rTransDef[nArea];      // Pointer to relevant info
1441                 spin_lock_irq(&pdx->stagedLock);        // Lock others out
1442
1443                 if ((pArea->bUsed) && (pArea->bCircular) &&     // Must be circular area
1444                     (pArea->bCircToHost))       // For now at least must be to host
1445                 {
1446                         bool bWaiting = false;
1447
1448                         if ((pArea->aBlocks[0].dwSize >= uSize) &&      // Got anything?
1449                             (pArea->aBlocks[0].dwOffset == uStart))     // Must be legal data
1450                         {
1451                                 pArea->aBlocks[0].dwSize -= uSize;
1452                                 pArea->aBlocks[0].dwOffset += uSize;
1453                                 if (pArea->aBlocks[0].dwSize == 0)      // Have we emptied this block?
1454                                 {
1455                                         if (pArea->aBlocks[1].dwSize)   // Is there a second block?
1456                                         {
1457                                                 pArea->aBlocks[0] = pArea->aBlocks[1];  // Copy down block 2 data
1458                                                 pArea->aBlocks[1].dwSize = 0;   // and mark the second block as unused
1459                                                 pArea->aBlocks[1].dwOffset = 0;
1460                                         } else
1461                                                 pArea->aBlocks[0].dwOffset = 0;
1462                                 }
1463
1464                                 dev_dbg(&pdx->interface->dev,
1465                                         "%s free %d bytes at %d, return %d bytes at %d, wait=%d",
1466                                         __func__, uSize, uStart,
1467                                         pArea->aBlocks[0].dwSize,
1468                                         pArea->aBlocks[0].dwOffset,
1469                                         pdx->bXFerWaiting);
1470
1471                                 // Return the next available block of memory as well
1472                                 if (pArea->aBlocks[0].dwSize > 0)       // Got anything?
1473                                 {
1474                                         cb.dwOffset =
1475                                             pArea->aBlocks[0].dwOffset;
1476                                         cb.dwSize = pArea->aBlocks[0].dwSize;
1477                                 }
1478
1479                                 bWaiting = pdx->bXFerWaiting;
1480                                 if (bWaiting && pdx->bStagedUrbPending) {
1481                                         dev_err(&pdx->interface->dev,
1482                                                 "%s ERROR: waiting xfer and staged Urb pending!",
1483                                                 __func__);
1484                                         bWaiting = false;
1485                                 }
1486                         } else {
1487                                 dev_err(&pdx->interface->dev,
1488                                         "%s ERROR: freeing %d bytes at %d, block 0 is %d bytes at %d",
1489                                         __func__, uSize, uStart,
1490                                         pArea->aBlocks[0].dwSize,
1491                                         pArea->aBlocks[0].dwOffset);
1492                                 iReturn = U14ERR_NOMEMORY;
1493                         }
1494
1495                         // If we have one, kick off pending transfer
1496                         if (bWaiting)   // Got a block xfer waiting?
1497                         {
1498                                 int RWMStat =
1499                                     ReadWriteMem(pdx, !pdx->rDMAInfo.bOutWard,
1500                                                  pdx->rDMAInfo.wIdent,
1501                                                  pdx->rDMAInfo.dwOffset,
1502                                                  pdx->rDMAInfo.dwSize);
1503                                 if (RWMStat != U14ERR_NOERROR)
1504                                         dev_err(&pdx->interface->dev,
1505                                                 "%s rw setup failed %d",
1506                                                 __func__, RWMStat);
1507                         }
1508                 } else
1509                         iReturn = U14ERR_NOTSET;
1510
1511                 spin_unlock_irq(&pdx->stagedLock);
1512         } else
1513                 iReturn = U14ERR_BADAREA;
1514
1515         if (copy_to_user(pCB, &cb, sizeof(cb)))
1516                 iReturn = -EFAULT;
1517
1518         mutex_unlock(&pdx->io_mutex);
1519         return iReturn;
1520 }