does it work?

src/pmacAsynIPPort.cpp

@@ -0,0 +1,945 @@
+/*
+NOTES
+
+This driver is an asyn driver intended for use with turboPmacController
+to allow communication over ethernet to a PMAC.
+
+*** Ensure I3=2 and I6=1 on the PMAC before using this driver. ***
+
+This driver supports sending ascii commands to the PMAC over asyn IP and
+obtaining the response. The driver uses the PMAC ethernet packets
+VR_PMAC_GETRESPONSE, VR_PMAC_READREADY and VR_PMAC_GETBUFFER to send commands
+and get responses. The PMAC may send responses in several different formats.
+1) PMAC ascii command responses for single/multiple commands (e.g. I113 I114
+I130 I131 I133) are in an ACK terminated form as follows (CR seperates the
+cmd responses): data<CR(13)>data<CR(13)>data<CR(13)><ACK(6)> 2) PMAC error
+responses to ascii commands ARE NOT ACK terminated as follows:
+        <BELL(7)>ERRxxx<CR(13)>
+3) PMAC may also return the following:
+        <STX(2)>data<CR(13)>
+
+This driver can send ctrl commands (ctrl B/C/F/G/P/V) to the pmac (using
+VR_CTRL_REPONSE packet) however because the resulting response data is not
+terminated as above the driver does not know when all the response data has
+been received. The response data will therefore only be returned after the
+asynUser.timeout has expired.
+
+This driver does NOT support large buffer transfers (VR_PMAC_WRITEBUFFER,
+VR_FWDOWNLOAD) or set/get of DPRAM (VR_PMAC_SETMEM etc) or changing comms
+setup (VR_IPADDRESS, VR_PMAC_PORT)
+
+Unlike the original DLS driver, this is not an interpose layer on top of
+drvAsynIPPort anymore. Instead the driver inherits from the C++ asynPortDriver
+class, implements the socket handling itself and overrides the asynCommon,
+asynOctet and asynInt32 methods.
+
+REVISION HISTORY
+
+10 Aug 07 - Pete Leicester - Diamond Light Source
+Modified to handle responses other than those ending in <ACK> (e.g. errors) -
+No longer used asyn EOS.
+
+9 Aug 07 - Pete Leicester - Diamond Light Source
+Initial version reliant on asyn EOS to return <ACK> terminated responses.
+
+2 Feb 09 - Matthew Pearson - Diamond Light Source
+Ported to work with Asyn 4-10. Still compiles with pre Asyn4-10 versions but
+does not work. Also added new config function, pmacAsynIPPortConfigureEos(),
+to be used when disabling low level EOS handling in the Asyn IP layer. This
+new function should be used with Asyn 4-10 and above (it is not compatible
+with Asyn 4-9).
+
+10 Apr 25 - Stefan Mathis - Paul Scherrer Institut
+Adjusted the driver to the requirements of SINQ:
+- Added a lot of comments, removed the predecessor of
+pmacAsynIPPortConfigureEos() since SINQ doesn't need it (see comment above)
+- Removed the call to `pmacFlush` from `flushItOctet`: We want to flush the
+communication buffer on the IOC side before each communication, but we do not
+want to flush the PMAC controller itself, since this stalls the controller for
+10 ms everytime (see Turbo PMAC User Manual, p. 414). Instead, a PV was added in
+the higher level `turboPmac` driver to manually call the `pmacFlush` function.
+*/
+
+#include "pmacAsynIPPort.h"
+#include "asynDriver.h"
+#include "asynInterposeEos.h"
+#include "asynPortDriver.h"
+#include "epicsExport.h"
+#include <cstdio>
+#include <cstring>
+#include <epicsThread.h>
+#include <epicsTime.h>
+#include <exception>
+#include <fcntl.h>
+#include <iocsh.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <osiSock.h>
+#include <osiUnistd.h>
+#include <stdexcept>
+#include <string>
+#include <sys/poll.h>
+
+/* PMAC ethernet commands - RequestType field */
+constexpr uint8_t VR_UPLOAD = 0xC0;
+constexpr uint8_t VR_DOWNLOAD = 0x40;
+
+/* PMAC ethernet commands - Request field */
+constexpr uint8_t VR_PMAC_FLUSH = 0xB3;
+constexpr uint8_t VR_PMAC_GETRESPONSE = 0xBF;
+constexpr uint8_t VR_PMAC_READREADY = 0xC2;
+constexpr uint8_t VR_CTRL_RESPONSE = 0xC4;
+constexpr uint8_t VR_PMAC_GETBUFFER = 0xC5;
+
+constexpr size_t MAX_BUFFER_SIZE = 2097152;
+constexpr size_t INPUT_SIZE =
+    (ETHERNET_DATA_SIZE + 1) /* +1 to allow space to add terminating ACK */;
+
+/* Connect timeout in seconds, matching asyn's DEFAULT_AUTOCONNECT_TIMEOUT. */
+constexpr double AUTO_CONNECT_TIMEOUT = 0.5;
+
+constexpr char STX = '\2';
+constexpr char ACK = '\6';
+constexpr char BELL = '\7';
+
+/* PMAC control character commands (VR_CTRL_RESPONSE cmd): ctrl B/C/F/G/P/V */
+constexpr char ctrlCommands[] = "\002\003\006\007\016\022";
+
+/* This delay is how long to wait in seconds after a send fails with errno ==
+ * EAGAIN or EINTR before trying again */
+constexpr double SEND_RETRY_DELAY = 0.01;
+
+/*
+   Notes on asyn
+   use asynUser.timeout to specify I/O request timeouts in seconds
+   asynStatus may return asynSuccess(0),asynTimeout(1),asynOverflow(2) or
+   asynError(3) eomReason may return ASYN_EOM_CNT (1:Request count reached),
+   ASYN_EOM_EOS (2:End of String detected), ASYN_EOM_END (4:End indicator
+   detected) asynError indicates that asynUser.errorMessage has been populated
+   by epicsSnprintf().
+*/
+
+/*
+ * OSI function to control blocking/non-blocking I/O
+ */
+static int setNonBlock(SOCKET fd, int nonBlockFlag) {
+#if defined(vxWorks)
+    int flags;
+    flags = nonBlockFlag;
+    if (ioctl(fd, FIONBIO, (int)&flags) < 0)
+        return -1;
+#elif defined(_WIN32)
+    unsigned long int flags;
+    flags = nonBlockFlag;
+    if (socket_ioctl(fd, FIONBIO, &flags) < 0)
+        return -1;
+#else
+    int flags;
+    if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
+        return -1;
+    if (nonBlockFlag)
+        flags |= O_NONBLOCK;
+    else
+        flags &= ~O_NONBLOCK;
+    if (fcntl(fd, F_SETFL, flags) < 0)
+        return -1;
+#endif
+    return 0;
+}
+
+pmacAsynIPPort::pmacAsynIPPort(const char *portName, const char *hostInfo)
+    : asynPortDriver(
+          portName, 1 /* maxAddr */, asynOctetMask | asynInt32Mask,
+          0 /* interruptMask */, ASYN_CANBLOCK, 1 /* autoConnect */,
+          0 /* priority */, 0 /* stackSize */),
+      inBuf_(MAX_BUFFER_SIZE) {
+    // The base class constructor mirrors drvAsynIPPortConfigure(portName,
+    // hostInfo, priority, noAutoConnect) with ASYN_CANBLOCK and autoConnect
+    // enabled. We register the asynOctet, asynInt32 and asynCommon interfaces.
+    // The low level EOS processing is not enabled in the base class, since the
+    // EOS interpose layer added in pmacAsynIPPortConfigure handles the
+    // PMAC-specific message terminators instead.
+    parseHostInfo(hostInfo);
+}
+
+pmacAsynIPPort::~pmacAsynIPPort() {
+    if (fd_ != INVALID_SOCKET)
+        epicsSocketDestroy(fd_);
+}
+
+void pmacAsynIPPort::parseHostInfo(const char *hostInfo) {
+    std::string hostInfoString(hostInfo);
+    size_t colon = hostInfoString.find(':');
+    if (colon == std::string::npos) {
+        std::string msg("pmacAsynIPPort: \"");
+        msg += hostInfo;
+        msg += "\" is not of the form \"<host>:<port>\"";
+        throw std::runtime_error(msg);
+    }
+    IPHostName_ = hostInfoString.substr(0, colon);
+    std::string portString = hostInfoString.substr(colon + 1);
+    unsigned long port;
+    try {
+        port = std::stoul(portString);
+    } catch (const std::exception &) {
+        std::string msg("pmacAsynIPPort: invalid port \"");
+        msg += portString + "\" in \"" + hostInfo + "\"";
+        throw std::runtime_error(msg);
+    }
+    if (port == 0 || port > 65535) {
+        std::string msg("pmacAsynIPPort: port \"");
+        msg += portString + "\" out of range in \"" + hostInfo + "\"";
+        throw std::runtime_error(msg);
+    }
+    port_ = static_cast<unsigned short>(port);
+}
+
+asynStatus pmacAsynIPPort::connectIt(asynUser *pasynUser) {
+    SOCKET fd;
+    int i;
+    char sockerrmsg[256];
+    osiSockAddr farAddr;
+
+    asynPrint(pasynUser, ASYN_TRACE_FLOW,
+              "Attempting to connect to %s reason:%d fd:%lld\n",
+              IPHostName_.c_str(), pasynUser->reason, (long long)fd_);
+
+    if (fd_ != INVALID_SOCKET) {
+        epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                      "%s: Link already open!", IPHostName_.c_str());
+        return asynError;
+    }
+
+    /*
+     * Create the socket
+     */
+    if ((fd = epicsSocketCreate(AF_INET, SOCK_STREAM, 0)) < 0) {
+        epicsSocketConvertErrnoToString(sockerrmsg, sizeof(sockerrmsg));
+        epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                      "Can't create socket: %s", sockerrmsg);
+        return asynError;
+    }
+
+    /*
+     * Convert host name/number to IP address.
+     * We delay doing this until now in case a device
+     * has just appeared in a DNS database.
+     */
+    farAddr.ia.sin_family = AF_INET;
+    farAddr.ia.sin_port = htons(port_);
+    if (hostToIPAddr(IPHostName_.c_str(), &farAddr.ia.sin_addr) < 0) {
+        epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                      "Unknown host \"%s\"", IPHostName_.c_str());
+        epicsSocketDestroy(fd);
+        return asynError;
+    }
+
+    if (setNonBlock(fd, 1) < 0) {
+        epicsSocketConvertErrnoToString(sockerrmsg, sizeof(sockerrmsg));
+        epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                      "Can't set %s O_NONBLOCK option: %s",
+                      IPHostName_.c_str(), sockerrmsg);
+        epicsSocketDestroy(fd);
+        return asynError;
+    }
+
+    {
+        int connectResult =
+            ::connect(fd, &farAddr.sa, sizeof(farAddr.ia));
+        if (connectResult < 0 &&
+            (SOCKERRNO == SOCK_EWOULDBLOCK || SOCKERRNO == SOCK_EINPROGRESS)) {
+            int msConnectTimeout;
+            struct pollfd pollfd;
+
+            // Use asyn's default auto-connect timeout. Older asyn versions do
+            // not provide asynManager::getAutoConnectTimeout.
+            msConnectTimeout = (int)(1000 * AUTO_CONNECT_TIMEOUT);
+            pollfd.fd = fd;
+            pollfd.events = POLLOUT;
+
+            /*
+             * poll() returning 1 is the only case where connect might have
+             * been successful. Otherwise connectResult will remain -1.
+             */
+            if (poll(&pollfd, 1, msConnectTimeout) == 1) {
+                int so_error;
+                osiSocklen_t len = sizeof so_error;
+
+                /*
+                 * We must verify SO_ERROR to make sure the connection was
+                 * successful.
+                 */
+                int sockErrorStatus = getsockopt(fd, SOL_SOCKET, SO_ERROR,
+                                                 (void *)&so_error, &len);
+                if (sockErrorStatus == 0 && so_error == 0)
+                    connectResult = 0;
+            }
+        }
+        if (connectResult < 0) {
+            epicsSocketConvertErrnoToString(sockerrmsg, sizeof(sockerrmsg));
+            epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                          "Can't connect to %s: %s", IPHostName_.c_str(),
+                          sockerrmsg);
+            epicsSocketDestroy(fd);
+            return asynError;
+        }
+    }
+
+    i = 1;
+    if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void *)&i, sizeof i) < 0) {
+        epicsSocketConvertErrnoToString(sockerrmsg, sizeof(sockerrmsg));
+        epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                      "Can't set %s socket NODELAY option: %s",
+                      IPHostName_.c_str(), sockerrmsg);
+        epicsSocketDestroy(fd);
+        return asynError;
+    }
+
+    asynPrint(pasynUser, ASYN_TRACE_FLOW, "Opened connection OK to %s\n",
+              IPHostName_.c_str());
+    fd_ = fd;
+    return asynSuccess;
+}
+
+void pmacAsynIPPort::closeConnection(asynUser *pasynUser, const char *why) {
+    asynPrint(pasynUser, ASYN_TRACE_FLOW,
+              "Closing %s connection (fd %lld): %s\n", IPHostName_.c_str(),
+              (long long)fd_, why);
+    if (fd_ != INVALID_SOCKET) {
+        epicsSocketDestroy(fd_);
+        fd_ = INVALID_SOCKET;
+    }
+    pasynManager->exceptionDisconnect(pasynUser);
+}
+
+asynStatus pmacAsynIPPort::connect(asynUser *pasynUser) {
+    int addr;
+    asynStatus status = getAddress(pasynUser, &addr);
+    if (status != asynSuccess)
+        return status;
+    status = connectIt(pasynUser);
+    if (status == asynSuccess) {
+        /* Clear any stale response data left from a previous connection */
+        inBufTail_ = 0;
+        inBufHead_ = 0;
+        pasynManager->exceptionConnect(pasynUser);
+    }
+    return status;
+}
+
+asynStatus pmacAsynIPPort::disconnect(asynUser *pasynUser) {
+    int addr;
+    asynStatus status = getAddress(pasynUser, &addr);
+    if (status != asynSuccess)
+        return status;
+    closeConnection(pasynUser, "Disconnect request");
+    return asynSuccess;
+}
+
+asynStatus pmacAsynIPPort::socketRead(asynUser *pasynUser, char *data,
+                                      size_t maxchars, size_t *nbytesRead) {
+    int thisRead;
+    int readPollmsec;
+    asynStatus status = asynSuccess;
+    char sockerrmsg[256];
+    epicsTimeStamp startTime;
+    epicsTimeStamp endTime;
+
+    *nbytesRead = 0;
+    if (fd_ == INVALID_SOCKET) {
+        epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                      "%s disconnected", IPHostName_.c_str());
+        return asynError;
+    }
+    if (maxchars == 0) {
+        epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                      "%s maxchars %d. Why <=0?", IPHostName_.c_str(),
+                      (int)maxchars);
+        return asynError;
+    }
+    readPollmsec = (int)(pasynUser->timeout * 1000.0);
+    if (readPollmsec == 0)
+        readPollmsec = 1;
+    if (readPollmsec < 0)
+        readPollmsec = -1;
+
+    {
+        struct pollfd pollfd;
+        pollfd.fd = fd_;
+        pollfd.events = POLLIN;
+        epicsTimeGetCurrent(&startTime);
+        while (poll(&pollfd, 1, readPollmsec) < 0) {
+            if (SOCKERRNO != SOCK_EINTR) {
+                epicsSocketConvertErrnoToString(sockerrmsg, sizeof(sockerrmsg));
+                epicsSnprintf(pasynUser->errorMessage,
+                              pasynUser->errorMessageSize, "Poll() failed: %s",
+                              sockerrmsg);
+                return asynError;
+            }
+            epicsTimeGetCurrent(&endTime);
+            if (epicsTimeDiffInSeconds(&endTime, &startTime) * 1000. >
+                readPollmsec)
+                break;
+        }
+    }
+
+    thisRead = recv(fd_, data, (int)maxchars, 0);
+    if (thisRead < 0) {
+        epicsSocketConvertErrnoToString(sockerrmsg, sizeof(sockerrmsg));
+        if (SOCKERRNO == SOCK_EWOULDBLOCK || SOCKERRNO == SOCK_EINTR) {
+            epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                          "%s timeout: %s", IPHostName_.c_str(), sockerrmsg);
+            status = asynTimeout;
+        } else {
+            epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                          "%s read error: %s", IPHostName_.c_str(), sockerrmsg);
+            closeConnection(pasynUser, "Read error");
+            status = asynError;
+        }
+    }
+    /* If recv() returns 0 on a SOCK_STREAM (TCP) socket, the connection has
+     * closed */
+    if (thisRead == 0) {
+        epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                      "%s connection closed", IPHostName_.c_str());
+        closeConnection(pasynUser, "Read from broken connection");
+    }
+    if (thisRead < 0)
+        thisRead = 0;
+    *nbytesRead = thisRead;
+    /* If there is room add a null byte */
+    if (thisRead < (int)maxchars)
+        data[thisRead] = 0;
+    return status;
+}
+
+asynStatus pmacAsynIPPort::socketWrite(asynUser *pasynUser, const char *data,
+                                       size_t numchars,
+                                       size_t *nbytesTransferred) {
+    asynStatus status = asynSuccess;
+    int thisWrite;
+    int writePollmsec;
+    epicsTimeStamp startTime;
+    epicsTimeStamp endTime;
+    int haveStartTime = 0;
+    char sockerrmsg[256];
+
+    asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s write.\n", IPHostName_.c_str());
+    *nbytesTransferred = 0;
+    if (fd_ == INVALID_SOCKET) {
+        epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                      "%s disconnected", IPHostName_.c_str());
+        return asynError;
+    }
+    if (numchars == 0)
+        return asynSuccess;
+    writePollmsec = (int)(pasynUser->timeout * 1000.0);
+    if (writePollmsec == 0)
+        writePollmsec = 1;
+    if (writePollmsec < 0)
+        writePollmsec = -1;
+    for (;;) {
+        int pollstatus;
+        struct pollfd pollfd;
+        pollfd.fd = fd_;
+        pollfd.events = POLLOUT;
+        epicsTimeGetCurrent(&startTime);
+        while ((pollstatus = poll(&pollfd, 1, writePollmsec)) < 0) {
+            if (SOCKERRNO != SOCK_EINTR) {
+                epicsSocketConvertErrnoToString(sockerrmsg, sizeof(sockerrmsg));
+                epicsSnprintf(pasynUser->errorMessage,
+                              pasynUser->errorMessageSize,
+                              "%s poll() failed: %s", IPHostName_.c_str(),
+                              sockerrmsg);
+                return asynError;
+            }
+            epicsTimeGetCurrent(&endTime);
+            if (epicsTimeDiffInSeconds(&endTime, &startTime) * 1000 >
+                writePollmsec)
+                break;
+        }
+        if (pollstatus == 0) {
+            epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                          "%s poll() timed out", IPHostName_.c_str());
+            return asynTimeout;
+        }
+        for (;;) {
+            thisWrite = send(fd_, data, (int)numchars, 0);
+            if (thisWrite >= 0)
+                break;
+            if (SOCKERRNO == SOCK_EWOULDBLOCK || SOCKERRNO == SOCK_EINTR) {
+                if (!haveStartTime) {
+                    epicsTimeGetCurrent(&startTime);
+                    haveStartTime = 1;
+                } else if (pasynUser->timeout >= 0) {
+                    epicsTimeGetCurrent(&endTime);
+                    if (epicsTimeDiffInSeconds(&endTime, &startTime) >
+                        pasynUser->timeout) {
+                        thisWrite = 0;
+                        break;
+                    }
+                }
+                epicsThreadSleep(SEND_RETRY_DELAY);
+            } else
+                break;
+        }
+        if (thisWrite > 0) {
+            *nbytesTransferred += thisWrite;
+            numchars -= thisWrite;
+            if (numchars == 0)
+                break;
+            data += thisWrite;
+        } else if (thisWrite == 0) {
+            status = asynTimeout;
+            epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                          "%s send() returned 0", IPHostName_.c_str());
+            break;
+        } else {
+            epicsSocketConvertErrnoToString(sockerrmsg, sizeof(sockerrmsg));
+            epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
+                          "%s write error: %s", IPHostName_.c_str(),
+                          sockerrmsg);
+            closeConnection(pasynUser, "Write error");
+            status = asynError;
+            break;
+        }
+    }
+    asynPrint(pasynUser, ASYN_TRACE_FLOW,
+              "wrote %lu to %s, return %s.\n",
+              (unsigned long)*nbytesTransferred, IPHostName_.c_str(),
+              pasynManager->strStatus(status));
+    return status;
+}
+
+/*
+    Read reponse data from PMAC into buffer inBuf_. If there is no data in the
+   socket buffer then issue pmac GETBUFFER command to get any outstanding data
+   still on the PMAC.
+*/
+asynStatus pmacAsynIPPort::readResponse(asynUser *pasynUser, size_t maxchars,
+                                        size_t *nbytesTransfered,
+                                        int *eomReason) {
+    asynStatus status = asynSuccess;
+    size_t thisRead = 0;
+    *nbytesTransfered = 0;
+    if (maxchars > INPUT_SIZE)
+        maxchars = INPUT_SIZE;
+
+    asynPrint(pasynUser, ASYN_TRACE_FLOW,
+              "pmacAsynIPPort::readResponse. Performing socketRead().\n");
+
+    status = socketRead(pasynUser, inBuf_.data(), maxchars, &thisRead);
+
+    asynPrint(pasynUser, ASYN_TRACE_FLOW,
+              "%s readResponse1 maxchars=%zd, thisRead=%zd, eomReason=%d, "
+              "status=%u\n",
+              portName, maxchars, thisRead, *eomReason,
+              static_cast<unsigned>(status));
+    if (status == asynTimeout && thisRead == 0 && pasynUser->timeout > 0) {
+        /* failed to read as many characters as required into the input buffer,
+           check for more response data on the PMAC */
+        if (pmacReadReady(pasynUser)) {
+
+            status = sendPmacGetBuffer(pasynUser, maxchars, nbytesTransfered);
+            asynPrintIO(pasynUser, ASYN_TRACE_FLOW,
+                        reinterpret_cast<const char *>(&pinCmd_),
+                        ETHERNET_CMD_HEADER, "%s write GETBUFFER\n", portName);
+
+            /* We have nothing to return at the moment so read again */
+            status = socketRead(pasynUser, inBuf_.data(), maxchars, &thisRead);
+
+            asynPrint(pasynUser, ASYN_TRACE_FLOW,
+                      "%s readResponse2 maxchars=%zd, thisRead=%zd, "
+                      "eomReason=%d, status=%u\n",
+                      portName, maxchars, thisRead, *eomReason,
+                      static_cast<unsigned>(status));
+        }
+    }
+
+    if (thisRead > 0) {
+        if (status == asynTimeout)
+            status = asynSuccess;
+        *nbytesTransfered = thisRead;
+        inBufTail_ = 0;
+        inBufHead_ = thisRead;
+    }
+
+    asynPrint(pasynUser, ASYN_TRACE_FLOW,
+              "pmacAsynIPPort::readResponse. END\n");
+
+    return status;
+}
+
+/*
+   Send ReadReady command to PMAC to discover if there is any data to read from
+   it. Returns: 0 - no data available 1 - data available
+*/
+int pmacAsynIPPort::pmacReadReady(asynUser *pasynUser) {
+    EthernetCmd cmd{};
+    char data[2] = {0};
+    asynStatus status;
+    size_t thisRead = 0;
+    size_t nbytesTransfered = 0;
+    int retval = 0;
+
+    cmd.RequestType = VR_UPLOAD;
+    cmd.Request = VR_PMAC_READREADY;
+    cmd.wValue = 0;
+    cmd.wIndex = 0;
+    cmd.wLength = htons(2);
+
+    status = socketWrite(pasynUser, reinterpret_cast<const char *>(&cmd),
+                         ETHERNET_CMD_HEADER, &nbytesTransfered);
+
+    if (status != asynSuccess) {
+        asynPrintIO(pasynUser, ASYN_TRACE_ERROR,
+                    reinterpret_cast<const char *>(&cmd), ETHERNET_CMD_HEADER,
+                    "%s write pmacReadReady fail\n", portName);
+    }
+
+    status = socketRead(pasynUser, data, 2, &thisRead);
+
+    if (status == asynSuccess) {
+        if (thisRead == 2 && data[0] != 0) {
+            retval = 1;
+        }
+        asynPrintIO(pasynUser, ASYN_TRACE_FLOW, data, thisRead,
+                    "%s read pmacReadReady OK thisRead=%zd\n", portName,
+                    thisRead);
+    } else {
+        asynPrint(pasynUser, ASYN_TRACE_ERROR,
+                  "%s read pmacReadReady failed status=%d, retval=%d\n",
+                  portName, static_cast<int>(status), retval);
+    }
+    return retval;
+}
+
+/**
+ * @brief Flush the PMAC communication buffer
+ *
+ * Send a Flush command to PMAC and wait for confirmation ctrlX to be returned
+ * according to the Turbo PMAC user manual, p. 414.
+ *
+ * @return 0 - failed, 1 - success
+ */
+int pmacAsynIPPort::pmacFlush(asynUser *pasynUser) {
+    EthernetCmd cmd{};
+    char data[2] = {0};
+    asynStatus status = asynSuccess;
+    size_t thisRead = 0;
+    size_t nbytesTransfered = 0;
+    int retval = 0;
+
+    cmd.RequestType = VR_DOWNLOAD;
+    cmd.Request = VR_PMAC_FLUSH;
+    cmd.wValue = 0;
+    cmd.wIndex = 0;
+    cmd.wLength = 0;
+
+    status = socketWrite(pasynUser, reinterpret_cast<const char *>(&cmd),
+                         ETHERNET_CMD_HEADER, &nbytesTransfered);
+
+    if (status != asynSuccess) {
+        asynPrintIO(pasynUser, ASYN_TRACE_ERROR,
+                    reinterpret_cast<const char *>(&cmd), ETHERNET_CMD_HEADER,
+                    "%s write pmacFlush fail\n", portName);
+    }
+
+    /* read flush acknowledgement character */
+    /* NB we don't check what the character is (manual sais ctrlX, we get 0x40
+     * i.e.VR_DOWNLOAD) */
+    status = socketRead(pasynUser, data, 1, &thisRead);
+
+    if (status == asynSuccess) {
+        asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s read pmacFlush OK\n",
+                  portName);
+        retval = 1;
+    } else {
+        asynPrint(pasynUser, ASYN_TRACE_ERROR,
+                  "%s read pmacFlush failed - thisRead=%zd, status=%d\n",
+                  portName, thisRead, static_cast<int>(status));
+    }
+
+    inBufTail_ = 0;
+    inBufHead_ = 0;
+
+    return retval;
+}
+
+asynStatus pmacAsynIPPort::sendPmacGetBuffer(asynUser *pasynUser,
+                                             size_t maxchars,
+                                             size_t *nbytesTransfered) {
+    pinCmd_.RequestType = VR_UPLOAD;
+    pinCmd_.Request = VR_PMAC_GETBUFFER;
+    pinCmd_.wValue = 0;
+    pinCmd_.wIndex = 0;
+    pinCmd_.wLength = htons(maxchars);
+    return socketWrite(pasynUser, reinterpret_cast<const char *>(&pinCmd_),
+                       ETHERNET_CMD_HEADER, nbytesTransfered);
+}
+
+/*
+This function sends either a ascii string command to the PMAC using
+   VR_PMAC_GETRESPONSE or a single control character (ctrl B/C/F/G/P/V) using
+   VR_CTRL_RESPONSE
+*/
+asynStatus pmacAsynIPPort::writeOctet(asynUser *pasynUser, const char *data,
+                                      size_t numchars,
+                                      size_t *nbytesTransfered) {
+    asynStatus status;
+    size_t nbytesActual = 0;
+    asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::writeOctet\n");
+
+    /* NB currently we assume control characters arrive as individual
+       characters/calls to this routine. Idealy we should probably scan the data
+       buffer for control commands and do PMAC_GETRESPONSE and CTRL_RESPONSE
+       commands as necessary,  */
+    if (numchars == 1 && strchr(ctrlCommands, data[0])) {
+        poutCmd_.RequestType = VR_UPLOAD;
+        poutCmd_.Request = VR_CTRL_RESPONSE;
+        poutCmd_.wValue = data[0];
+        poutCmd_.wIndex = 0;
+        poutCmd_.wLength = htons(0);
+        status = socketWrite(pasynUser,
+                             reinterpret_cast<const char *>(&poutCmd_),
+                             ETHERNET_CMD_HEADER, &nbytesActual);
+        *nbytesTransfered = nbytesActual == ETHERNET_CMD_HEADER ? numchars : 0;
+    } else {
+        if (numchars > ETHERNET_DATA_SIZE) {
+            /* NB large data should probably be sent using PMAC_WRITEBUFFER
+             * which isnt implemented yet - for the moment just truncate */
+            numchars = ETHERNET_DATA_SIZE;
+            asynPrint(pasynUser, ASYN_TRACE_ERROR,
+                      "writeOctet - ERROR TRUNCATED\n");
+        }
+
+        /*
+        The message protocol of the turboPmac used at PSI looks as follows (all
+        characters immediately following each other without a newline):
+        0x40 (ASCII value of @) -> Request for download
+        0xBF (ASCII value of ¿) -> Select mode "get_response"
+        0x00 (ASCII value of 0)
+        0x00 (ASCII value of 0)
+        0x00 (ASCII value of 0)
+        0x00 (ASCII value of 0)
+        0x00 (ASCII value of 0)
+        [message length in network byte order] -> Use the htons function for
+        this value [Actual message] It is not necessary to append a terminator,
+        since this protocol encodes the message length at the beginning. See
+        Turbo PMAC User Manual, page 418 in VR_PMAC_GETRESPONSE x0D (ASCII value
+        of carriage return) -> The controller needs a carriage return at the end
+        of a "send" command (a command were we transmit data via
+        =). For "request" commands (e.g. read status or position), this is not
+        necessary, but it doesn't hurt either, therefore we always add a
+        carriage return.
+
+        The message has to be build manually into the buffer fullCommand, since
+        it contains NULL terminators in its middle, therefore the string
+        manipulation methods of C don't work.
+        */
+        poutCmd_.RequestType = VR_DOWNLOAD;
+        poutCmd_.Request = VR_PMAC_GETRESPONSE;
+        poutCmd_.wValue = 0;
+        poutCmd_.wIndex = 0;
+        poutCmd_.wLength = htons(numchars);
+        memcpy(poutCmd_.bData, data, numchars);
+        status = socketWrite(pasynUser,
+                             reinterpret_cast<const char *>(&poutCmd_),
+                             numchars + ETHERNET_CMD_HEADER, &nbytesActual);
+        if (nbytesActual > ETHERNET_CMD_HEADER)
+            *nbytesTransfered = nbytesActual - ETHERNET_CMD_HEADER;
+        else
+            *nbytesTransfered = 0;
+    }
+
+    asynPrintIO(pasynUser, ASYN_TRACE_FLOW,
+                reinterpret_cast<const char *>(&poutCmd_),
+                numchars + ETHERNET_CMD_HEADER, "%s writeOctet\n", portName);
+
+    return status;
+}
+
+/*
+This function reads data using read() into a local buffer and then look for
+message terminating characters and returns a complete response (or times
+out), adding on ACK if neccessary. The PMAC command response may be any of
+the following:- data<CR>data<CR>....data<CR><ACK> <BELL>data<CR> e.g. an
+error <BELL>ERRxxx<CR> <STX>data<CR> (NB asyn EOS only allows one message
+terminator to be specified. We add on ACK for the EOS layer above.)
+*/
+asynStatus pmacAsynIPPort::readOctet(asynUser *pasynUser, char *data,
+                                     size_t maxchars, size_t *nbytesTransfered,
+                                     int *eomReason) {
+    asynStatus status = asynSuccess;
+    size_t thisRead = 0;
+    size_t nRead = 0;
+    bool bell = false;
+    bool initialRead = true;
+
+    asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::readOctet. START\n");
+
+    if (maxchars > 0) {
+        for (;;) {
+            if (inBufTail_ != inBufHead_) {
+                *data = inBuf_[inBufTail_++];
+                if (*data == BELL || *data == STX)
+                    bell = true;
+                if (*data == '\r' && bell) {
+                    /* <BELL>xxxxxx<CR> or <STX>xxxxx<CR> received - its
+                     * probably an error response (<BELL>ERRxxx<CR>) - assume
+                     * there is no more response data to come */
+                    nRead++; /* make sure the <CR> is passed to the client app
+                              */
+                    /*Add on ACK, because that's what we expect to be EOS in EOS
+                     * interpose layer.*/
+                    if ((nRead + 1) > maxchars) {
+                        /*If maxchars is reached overwrite <CR> with ACK, so
+                         * that no more reads will be done from EOS layer.*/
+                        *data = ACK;
+                    } else {
+                        data++;
+                        nRead++;
+                        *data = ACK;
+                    }
+                    break;
+                }
+                if (*data == ACK || *data == '\n') {
+                    /* <ACK> or <LF> received - assume there is no more response
+                     * data to come */
+                    /* If <LF>, replace with an ACK.*/
+                    if (*data == '\n') {
+                        *data = ACK;
+                    }
+                    asynPrint(pasynUser, ASYN_TRACE_FLOW,
+                              "Message was terminated with ACK in "
+                              "pmacAsynIPPort::readOctet.\n");
+                    /*Pass ACK up to Asyn EOS handling layer.*/
+                    data++;
+                    nRead++;
+                    break;
+                }
+                data++;
+                nRead++;
+                if (nRead >= maxchars)
+                    break;
+                continue;
+            }
+
+            asynPrint(pasynUser, ASYN_TRACE_FLOW,
+                      "pmacAsynIPPort::readOctet. Calling readResponse().\n");
+            if (!initialRead) {
+                if (pmacReadReady(pasynUser)) {
+                    status = sendPmacGetBuffer(pasynUser, maxchars,
+                                               nbytesTransfered);
+                }
+            }
+            status = readResponse(pasynUser, maxchars - nRead, &thisRead,
+                                  eomReason);
+            initialRead = false;
+            if (status != asynSuccess || thisRead == 0)
+                break;
+        }
+    }
+    *nbytesTransfered = nRead;
+
+    asynPrintIO(pasynUser, ASYN_TRACE_FLOW, data, *nbytesTransfered,
+                "%s pmacAsynIPPort readOctet nbytesTransfered=%zd, "
+                "eomReason=%d, status=%d\n",
+                portName, *nbytesTransfered, *eomReason,
+                static_cast<int>(status));
+
+    asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::readOctet. END\n");
+
+    return status;
+}
+
+asynStatus pmacAsynIPPort::flushOctet(asynUser *pasynUser) {
+    int numRecv, numTotal = 0;
+    char cbuf[512];
+
+    asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::flushOctet\n");
+
+    if (fd_ != INVALID_SOCKET) {
+        /*
+         * Toss characters until there are none left
+         */
+        while (1) {
+            numRecv = recv(fd_, cbuf, sizeof cbuf, 0);
+            if (numRecv <= 0)
+                break;
+            numTotal += numRecv;
+        }
+    }
+    if (numTotal > 0) {
+        asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s flushed %d bytes\n",
+                  portName, numTotal);
+    }
+    return asynSuccess;
+}
+
+asynStatus pmacAsynIPPort::writeInt32(asynUser *pasynUser, epicsInt32 value) {
+    asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::writeInt32\n");
+
+    if (pasynUser->reason == FLUSH_HARDWARE) {
+        /*
+        According to the Turbo PMAC user manual, p. 414:
+        0 - failed 1 - success
+        */
+        if (pmacFlush(pasynUser) == 1) {
+            return asynSuccess;
+        } else {
+            return asynError;
+        }
+    } else {
+        return asynPortDriver::writeInt32(pasynUser, value);
+    }
+}
+
+// =============================================================================
+
+int pmacAsynIPPortConfigure(const char *portName, const char *hostInfo) {
+    /*
+    The port is registered with asynManager in the asynPortDriver base class
+    constructor. The object lives for the whole IOC lifetime and is therefore
+    intentionally never deleted (see turboPmacCreateAxis in turboPmacAxis.cpp
+    for a similar pattern).
+    */
+    try {
+        new pmacAsynIPPort(portName, hostInfo);
+    } catch (const std::exception &e) {
+        printf("pmacAsynIPPortConfigure: error from pmacAsynIPPort "
+               "constructor. ");
+        printf("Port: %s (%s)\n", portName, e.what());
+        return -1;
+    }
+
+    /* Interpose EOS handling layer, above the PMAC IP layer. */
+    asynInterposeEosConfig(portName, 0, 1, 1);
+
+    return asynSuccess;
+}
+
+// =============================================================================
+
+/* register pmacAsynIPPortConfigure*/
+static const iocshArg pmacAsynIPPortConfigureArg0 = {"portName",
+                                                     iocshArgString};
+static const iocshArg pmacAsynIPPortConfigureArg1 = {"hostInfo",
+                                                     iocshArgString};
+static const iocshArg *pmacAsynIPPortConfigureArgs[] = {
+    &pmacAsynIPPortConfigureArg0, &pmacAsynIPPortConfigureArg1};
+static const iocshFuncDef pmacAsynIPPortConfigFuncDef = {
+    "pmacAsynIPPortConfigure", 2, pmacAsynIPPortConfigureArgs, ""};
+static void pmacAsynIPPortConfigureCallFunc(const iocshArgBuf *args) {
+    pmacAsynIPPortConfigure(args[0].sval, args[1].sval);
+}
+
+static void pmacAsynIPPortRegister(void) {
+    static bool firstTime = true;
+    if (firstTime) {
+        firstTime = false;
+        iocshRegister(&pmacAsynIPPortConfigFuncDef,
+                      pmacAsynIPPortConfigureCallFunc);
+    }
+}
+epicsExportRegistrar(pmacAsynIPPortRegister);