Do not connect unrequested.

Do not register for int/uint interrupts without need.

src/AsynDriverInterface.cc

@@ -203,7 +203,7 @@ class AsynDriverInterface : StreamBusInterface
 
     // local methods
     void timerExpired();
-    bool connectToBus(const char* busname, int addr);
+    bool connectToBus(const char* portname, int addr);
     void lockHandler();
     void writeHandler();
     void readHandler();
@@ -247,7 +247,7 @@ class AsynDriverInterface : StreamBusInterface
 public:
     // static creator method
     static StreamBusInterface* getBusInterface(Client* client,
-        const char* busname, int addr, const char* param);
+        const char* portname, int addr, const char* param);
 };
 
 RegisterStreamBusInterface(AsynDriverInterface);
@@ -331,19 +331,19 @@ AsynDriverInterface::
 }
 
 // interface function getBusInterface():
-// do we have this bus/addr ?
+// do we have this port/addr ?
 StreamBusInterface* AsynDriverInterface::
 getBusInterface(Client* client,
-    const char* busname, int addr, const char*)
+    const char* portname, int addr, const char*)
 {
     debug ("AsynDriverInterface::getBusInterface(%s, %s, %d)\n",
-        client->name(), busname, addr);
+        client->name(), portname, addr);
     AsynDriverInterface* interface = new AsynDriverInterface(client);
-    if (interface->connectToBus(busname, addr))
+    if (interface->connectToBus(portname, addr))
     {
         debug ("AsynDriverInterface::getBusInterface(%s, %d): "
-            "new Interface allocated\n",
+            "new interface allocated\n",
-            busname, addr);
+            portname, addr);
         return interface;
     }
     delete interface;
@@ -355,13 +355,11 @@ getBusInterface(Client* client,
 bool AsynDriverInterface::
 supportsEvent()
 {
-    if (intrPvtInt32 || intrPvtInt32) return true;
+    if (intrPvtInt32 || intrPvtUInt32) return true;
 
     // look for interfaces for events
     asynInterface* pasynInterface;
 
-    connectToAsynPort();
-    
     pasynInterface = pasynManager->findInterface(pasynUser,
         asynInt32Type, true);
     if (pasynInterface)
@@ -378,7 +376,7 @@ supportsEvent()
                 intrCallbackInt32, this, &intrPvtInt32);
             return true;
         }
-        error("%s: bus does not allow to register for "
+        error("%s: port does not allow to register for "
             "Int32 interrupts: %s\n",
             clientName(), pasynUser->errorMessage);
         pasynInt32 = NULL;
@@ -404,7 +402,7 @@ supportsEvent()
                 intrCallbackUInt32, this, 0xFFFFFFFF, &intrPvtInt32);
             return true;
         }
-        error("%s: bus does not allow to register for "
+        error("%s: port does not allow to register for "
             "UInt32 interrupts: %s\n",
             clientName(), pasynUser->errorMessage);
         pasynUInt32 = NULL;
@@ -424,24 +422,26 @@ supportsAsyncRead()
     if (pasynOctet->registerInterruptUser(pvtOctet, pasynUser,
         intrCallbackOctet, this, &intrPvtOctet) != asynSuccess)
     {
-        error("%s: bus does not support asynchronous input: %s\n",
+        const char *portname;
-            clientName(), pasynUser->errorMessage);
+        pasynManager->getPortName(pasynUser, &portname);
+        error("%s: asyn port %s does not support asynchronous input: %s\n",
+            clientName(), portname, pasynUser->errorMessage);
         return false;
     }
     return true;
 }
 
 bool AsynDriverInterface::
-connectToBus(const char* busname, int addr)
+connectToBus(const char* portname, int addr)
 {
-    asynStatus status = pasynManager->connectDevice(pasynUser, busname, addr);
+    asynStatus status = pasynManager->connectDevice(pasynUser, portname, addr);
     debug("%s: AsynDriverInterface::connectToBus(%s, %d): "
         "pasynManager->connectDevice(%p, %s, %d) = %s\n",
-        clientName(), busname, addr,  pasynUser,busname, addr,
+        clientName(), portname, addr,  pasynUser,portname, addr,
             asynStatusStr[status]);    
     if (status != asynSuccess)
     {
-        // asynDriver does not know this busname/address
+        // asynDriver does not know this portname/address
         return false;
     }
 
@@ -452,8 +452,8 @@ connectToBus(const char* busname, int addr)
         asynCommonType, true);
     if (!pasynInterface)
     {
-        error("%s: bus %s does not support asynCommon interface\n",
+        error("%s: asyn port %s does not support asynCommon interface\n",
-            clientName(), busname);
+            clientName(), portname);
         return false;
     }
     pasynCommon = static_cast<asynCommon*>(pasynInterface->pinterface);
@@ -464,8 +464,8 @@ connectToBus(const char* busname, int addr)
         asynOctetType, true);
     if (!pasynInterface)
     {
-        error("%s: bus %s does not support asynOctet interface\n",
+        error("%s: asyn port %s does not support asynOctet interface\n",
-            clientName(), busname);
+            clientName(), portname);
         return false;
     }
     pasynOctet = static_cast<asynOctet*>(pasynInterface->pinterface);
@@ -596,21 +596,49 @@ connectToAsynPort()
 void AsynDriverInterface::
 lockHandler()
 {
+    asynStatus status;
     int connected;
+
     debug("AsynDriverInterface::lockHandler(%s)\n",
         clientName());
-    pasynManager->blockProcessCallback(pasynUser, false);
+
-    connected = connectToAsynPort();
+    status = pasynManager->isConnected(pasynUser, &connected);
-    lockCallback(connected ? StreamIoSuccess : StreamIoFault);
+    if (status != asynSuccess)
+    {
+        error("%s: pasynManager->isConnected() failed: %s\n",
+            clientName(), pasynUser->errorMessage);
+        lockCallback(StreamIoFault);
+        return;
+    }
+    if (!connected) lockCallback(StreamIoFault);
+    
+    status = pasynManager->blockProcessCallback(pasynUser, false);
+    if (status != asynSuccess)
+    {
+        error("%s: pasynManager->blockProcessCallback() failed: %s\n",
+            clientName(), pasynUser->errorMessage);
+        lockCallback(StreamIoFault);
+        return;
+    }
+    lockCallback(StreamIoSuccess);
 }
 
 // interface function: we don't need exclusive access any more
 bool AsynDriverInterface::
 unlock()
 {
+    asynStatus status;
+
     debug("AsynDriverInterface::unlock(%s)\n",
         clientName());
-    pasynManager->unblockProcessCallback(pasynUser, false);
+    status = pasynManager->unblockProcessCallback(pasynUser, false);
+    if (status != asynSuccess)
+    {
+        error("%s: pasynManager->unblockProcessCallback() failed: %s\n",
+            clientName(), pasynUser->errorMessage);
+        lockCallback(StreamIoFault);
+        return false;
+    }
     return true;
 }
 
@@ -661,10 +689,10 @@ writeHandler()
     // thus do not use pasynOctet->flush()
     do {
         char buffer [256];
-        size_t received = sizeof(buffer);
+        size_t received = 0;
         int eomReason = 0;
         status = pasynOctet->read(pvtOctet, pasynUser,
-            buffer, received, &received, &eomReason);
+            buffer, sizeof(buffer), &received, &eomReason);
         if (received == 0) break;
 #ifndef NO_TEMPORARY
         if (received) debug("AsynDriverInterface::writeHandler(%s): flushing %ld bytes: \"%s\"\n",