Add virtual lock for thread safe classes

Add a virtual lock for the classes which are thread safe.  This
allows the use of a mutex to be overridden.

Author: c1728p9

hal/api/AnalogIn.h

@@ -55,19 +55,19 @@ class AnalogIn {
      * @param name (optional) A string to identify the object
      */
     AnalogIn(PinName pin) {
-        _mutex.lock();
+        lock();
         analogin_init(&_adc, pin);
-        _mutex.unlock();
+        unlock();
     }
 
     /** Read the input voltage, represented as a float in the range [0.0, 1.0]
      *
      * @returns A floating-point value representing the current input voltage, measured as a percentage
      */
     float read() {
-        _mutex.lock();
+        lock();
         float ret = analogin_read(&_adc);
-        _mutex.unlock();
+        unlock();
         return ret;
     }
 
@@ -77,9 +77,9 @@ class AnalogIn {
      *   16-bit unsigned short representing the current input voltage, normalised to a 16-bit value
      */
     unsigned short read_u16() {
-        _mutex.lock();
+        lock();
         unsigned short ret = analogin_read_u16(&_adc);
-        _mutex.unlock();
+        unlock();
         return ret;
     }
 
@@ -104,6 +104,15 @@ class AnalogIn {
 #endif
 
 protected:
+
+    virtual void lock() {
+        _mutex.lock();
+    }
+
+    virtual void unlock() {
+        _mutex.unlock();
+    }
+
     analogin_t _adc;
     static rtos::Mutex _mutex;
 };

hal/api/AnalogOut.h

@@ -66,9 +66,9 @@ class AnalogOut {
      *    Values outside this range will be saturated to 0.0f or 1.0f.
      */
     void write(float value) {
-        _mutex.lock();
+        lock();
         analogout_write(&_dac, value);
-        _mutex.unlock();
+        unlock();
     }
 
     /** Set the output voltage, represented as an unsigned short in the range [0x0, 0xFFFF]
@@ -77,9 +77,9 @@ class AnalogOut {
      *            normalised to a 16-bit value (0x0000 = 0v, 0xFFFF = 3.3v)
      */
     void write_u16(unsigned short value) {
-        _mutex.lock();
+        lock();
         analogout_write_u16(&_dac, value);
-        _mutex.unlock();
+        unlock();
     }
 
     /** Return the current output voltage setting, measured as a percentage (float)
@@ -93,9 +93,9 @@ class AnalogOut {
      *    This value may not match exactly the value set by a previous write().
      */
     float read() {
-        _mutex.lock();
+        lock();
         float ret = analogout_read(&_dac);
-        _mutex.unlock();
+        unlock();
         return ret;
     }
 
@@ -123,6 +123,15 @@ class AnalogOut {
 #endif
 
 protected:
+
+    virtual void lock() {
+        _mutex.lock();
+    }
+
+    virtual void unlock() {
+        _mutex.unlock();
+    }
+
     dac_t _dac;
     rtos::Mutex _mutex;
 };

hal/api/BusIn.h

@@ -94,6 +94,8 @@ class BusIn {
 
     /* disallow copy constructor and assignment operators */
 private:
+    virtual void lock();
+    virtual void unlock();
     BusIn(const BusIn&);
     BusIn & operator = (const BusIn&);
 };

hal/api/BusInOut.h

@@ -101,6 +101,8 @@ class BusInOut {
 #endif
 
 protected:
+    virtual void lock();
+    virtual void unlock();
     DigitalInOut* _pin[16];
 
     /** Mask of bus's NC pins

hal/api/BusOut.h

@@ -85,6 +85,8 @@ class BusOut {
 #endif
 
 protected:
+    virtual void lock();
+    virtual void unlock();
     DigitalOut* _pin[16];
 
     /** Mask of bus's NC pins

hal/api/CAN.h

@@ -242,6 +242,8 @@ class CAN {
     static void _irq_handler(uint32_t id, CanIrqType type);
 
 protected:
+    virtual void lock();
+    virtual void unlock();
     can_t               _can;
     Callback<void()>    _irq[9];
     rtos::Mutex         _mutex;

hal/api/I2C.h

@@ -139,11 +139,11 @@ class I2C {
 
     /** Acquire exclusive access to this I2C bus
      */
-    void lock(void);
+    virtual void lock(void);
 
     /** Release exclusive access to this I2C bus
      */
-    void unlock(void);
+    virtual void unlock(void);
 
 #if DEVICE_I2C_ASYNCH
 

hal/api/InterruptManager.h

@@ -113,6 +113,10 @@ class InterruptManager {
      */
     bool remove_handler(pFunctionPointer_t handler, IRQn_Type irq);
 
+protected:
+    virtual void lock();
+    virtual void unlock();
+
 private:
     InterruptManager();
     ~InterruptManager();

hal/api/SPI.h

@@ -116,11 +116,11 @@ class SPI {
 
     /** Acquire exclusive access to this SPI bus
      */
-    void lock(void);
+    virtual void lock(void);
 
     /** Release exclusive access to this SPI bus
      */
-    void unlock(void);
+    virtual void unlock(void);
 
 #if DEVICE_SPI_ASYNCH
 

hal/common/BusIn.cpp

@@ -53,23 +53,31 @@ BusIn::~BusIn() {
 
 int BusIn::read() {
     int v = 0;
-    _mutex.lock();
+    lock();
     for (int i=0; i<16; i++) {
         if (_pin[i] != 0) {
             v |= _pin[i]->read() << i;
         }
     }
-    _mutex.unlock();
+    unlock();
     return v;
 }
 
 void BusIn::mode(PinMode pull) {
-    _mutex.lock();
+    lock();
     for (int i=0; i<16; i++) {
         if (_pin[i] != 0) {
             _pin[i]->mode(pull);
         }
     }
+    unlock();
+}
+
+void BusIn::lock() {
+    _mutex.lock();
+}
+
+void BusIn::unlock() {
     _mutex.unlock();
 }
 

hal/common/BusInOut.cpp

@@ -52,55 +52,55 @@ BusInOut::~BusInOut() {
 }
 
 void BusInOut::write(int value) {
-    _mutex.lock();
+    lock();
     for (int i=0; i<16; i++) {
         if (_pin[i] != 0) {
             _pin[i]->write((value >> i) & 1);
         }
     }
-    _mutex.unlock();
+    unlock();
 }
 
 int BusInOut::read() {
-    _mutex.lock();
+    lock();
     int v = 0;
     for (int i=0; i<16; i++) {
         if (_pin[i] != 0) {
             v |= _pin[i]->read() << i;
         }
     }
-    _mutex.unlock();
+    unlock();
     return v;
 }
 
 void BusInOut::output() {
-    _mutex.lock();
+    lock();
     for (int i=0; i<16; i++) {
         if (_pin[i] != 0) {
             _pin[i]->output();
         }
     }
-    _mutex.unlock();
+    unlock();
 }
 
 void BusInOut::input() {
-    _mutex.lock();
+    lock();
     for (int i=0; i<16; i++) {
         if (_pin[i] != 0) {
             _pin[i]->input();
         }
     }
-    _mutex.unlock();
+    unlock();
 }
 
 void BusInOut::mode(PinMode pull) {
-    _mutex.lock();
+    lock();
     for (int i=0; i<16; i++) {
         if (_pin[i] != 0) {
             _pin[i]->mode(pull);
         }
     }
-    _mutex.unlock();
+    unlock();
 }
 
 #ifdef MBED_OPERATORS
@@ -129,4 +129,12 @@ BusInOut::operator int() {
 }
 #endif
 
+void BusInOut::lock() {
+    _mutex.lock();
+}
+
+void BusInOut::unlock() {
+    _mutex.unlock();
+}
+
 } // namespace mbed

hal/common/BusOut.cpp

@@ -52,24 +52,24 @@ BusOut::~BusOut() {
 }
 
 void BusOut::write(int value) {
-    _mutex.lock();
+    lock();
     for (int i=0; i<16; i++) {
         if (_pin[i] != 0) {
             _pin[i]->write((value >> i) & 1);
         }
     }
-    _mutex.unlock();
+    unlock();
 }
 
 int BusOut::read() {
-    _mutex.lock();
+    lock();
     int v = 0;
     for (int i=0; i<16; i++) {
         if (_pin[i] != 0) {
             v |= _pin[i]->read() << i;
         }
     }
-    _mutex.unlock();
+    unlock();
     return v;
 }
 
@@ -99,4 +99,12 @@ BusOut::operator int() {
 }
 #endif
 
+void BusOut::lock() {
+    _mutex.lock();
+}
+
+void BusOut::unlock() {
+    _mutex.unlock();
+}
+
 } // namespace mbed