Make core mbed API thread safe

hal/api/AnalogIn.h

@@ -25,6 +25,8 @@
 namespace mbed {
 
 /** An analog input, used for reading the voltage on a pin
+ *
+ * @Note Synchronization level: Thread safe
  *
  * Example:
  * @code
@@ -53,15 +55,20 @@ class AnalogIn {
      * @param name (optional) A string to identify the object
      */
     AnalogIn(PinName pin) {
+        lock();
         analogin_init(&_adc, pin);
+        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() {
-        return analogin_read(&_adc);
+        lock();
+        float ret = analogin_read(&_adc);
+        unlock();
+        return ret;
     }
 
     /** Read the input voltage, represented as an unsigned short in the range [0x0, 0xFFFF]
@@ -70,7 +77,10 @@ class AnalogIn {
      *   16-bit unsigned short representing the current input voltage, normalised to a 16-bit value
      */
     unsigned short read_u16() {
-        return analogin_read_u16(&_adc);
+        lock();
+        unsigned short ret = analogin_read_u16(&_adc);
+        unlock();
+        return ret;
     }
 
 #ifdef MBED_OPERATORS
@@ -88,12 +98,23 @@ class AnalogIn {
      * @endcode
      */
     operator float() {
+        // Underlying call is thread safe
         return read();
     }
 #endif
 
 protected:
+
+    virtual void lock() {
+        _mutex.lock();
+    }
+
+    virtual void unlock() {
+        _mutex.unlock();
+    }
+
     analogin_t _adc;
+    static PlatformMutex _mutex;
 };
 
 } // namespace mbed

hal/api/AnalogOut.h

@@ -25,6 +25,8 @@
 namespace mbed {
 
 /** An analog output, used for setting the voltage on a pin
+ *
+ * @Note Synchronization level: Thread safe
  *
  * Example:
  * @code
@@ -64,7 +66,9 @@ class AnalogOut {
      *    Values outside this range will be saturated to 0.0f or 1.0f.
      */
     void write(float value) {
+        lock();
         analogout_write(&_dac, value);
+        unlock();
     }
 
     /** Set the output voltage, represented as an unsigned short in the range [0x0, 0xFFFF]
@@ -73,7 +77,9 @@ class AnalogOut {
      *            normalised to a 16-bit value (0x0000 = 0v, 0xFFFF = 3.3v)
      */
     void write_u16(unsigned short value) {
+        lock();
         analogout_write_u16(&_dac, value);
+        unlock();
     }
 
     /** Return the current output voltage setting, measured as a percentage (float)
@@ -87,31 +93,47 @@ class AnalogOut {
      *    This value may not match exactly the value set by a previous write().
      */
     float read() {
-        return analogout_read(&_dac);
+        lock();
+        float ret = analogout_read(&_dac);
+        unlock();
+        return ret;
     }
 
 #ifdef MBED_OPERATORS
     /** An operator shorthand for write()
      */
     AnalogOut& operator= (float percent) {
+        // Underlying write call is thread safe
         write(percent);
         return *this;
     }
 
     AnalogOut& operator= (AnalogOut& rhs) {
+        // Underlying write call is thread safe
         write(rhs.read());
         return *this;
     }
 
     /** An operator shorthand for read()
      */
     operator float() {
+        // Underlying read call is thread safe
         return read();
     }
 #endif
 
 protected:
+
+    virtual void lock() {
+        _mutex.lock();
+    }
+
+    virtual void unlock() {
+        _mutex.unlock();
+    }
+
     dac_t _dac;
+    PlatformMutex _mutex;
 };
 
 } // namespace mbed

hal/api/BusIn.h

@@ -22,6 +22,8 @@
 namespace mbed {
 
 /** A digital input bus, used for reading the state of a collection of pins
+ *
+ * @Note Synchronization level: Thread safe
  */
 class BusIn {
 
@@ -65,6 +67,7 @@ class BusIn {
      *    Binary mask of connected pins
      */
     int mask() {
+        // No lock needed since _nc_mask is not modified outside the constructor
         return _nc_mask;
     }
 
@@ -87,8 +90,12 @@ class BusIn {
      */
     int _nc_mask;
 
+    PlatformMutex _mutex;
+
     /* disallow copy constructor and assignment operators */
 private:
+    virtual void lock();
+    virtual void unlock();
     BusIn(const BusIn&);
     BusIn & operator = (const BusIn&);
 };

hal/api/BusInOut.h

@@ -21,6 +21,8 @@
 namespace mbed {
 
 /** A digital input output bus, used for setting the state of a collection of pins
+ *
+ * @Note Synchronization level: Thread safe
  */
 class BusInOut {
 
@@ -79,6 +81,7 @@ class BusInOut {
      *    Binary mask of connected pins
      */
     int mask() {
+        // No lock needed since _nc_mask is not modified outside the constructor
         return _nc_mask;
     }
 
@@ -98,6 +101,8 @@ class BusInOut {
 #endif
 
 protected:
+    virtual void lock();
+    virtual void unlock();
     DigitalInOut* _pin[16];
 
     /** Mask of bus's NC pins
@@ -106,6 +111,8 @@ class BusInOut {
      */
     int _nc_mask;
 
+    PlatformMutex _mutex;
+
     /* disallow copy constructor and assignment operators */
 private:
     BusInOut(const BusInOut&);

hal/api/BusOut.h

@@ -30,6 +30,8 @@ class BusOut {
      *
      *  @param p<n> DigitalOut pin to connect to bus bit <n> (p5-p30, NC)
      *
+     *  @Note Synchronization level: Thread safe
+     *
      *  @note
      *  It is only required to specify as many pin variables as is required
      *  for the bus; the rest will default to NC (not connected)
@@ -63,6 +65,7 @@ class BusOut {
      *    Binary mask of connected pins
      */
     int mask() {
+        // No lock needed since _nc_mask is not modified outside the constructor
         return _nc_mask;
     }
 
@@ -82,6 +85,8 @@ class BusOut {
 #endif
 
 protected:
+    virtual void lock();
+    virtual void unlock();
     DigitalOut* _pin[16];
 
     /** Mask of bus's NC pins
@@ -90,6 +95,8 @@ class BusOut {
      */
     int _nc_mask;
 
+    PlatformMutex _mutex;
+
    /* disallow copy constructor and assignment operators */
 private:
     BusOut(const BusOut&);

hal/api/CAN.h

@@ -27,6 +27,8 @@
 namespace mbed {
 
 /** CANMessage class
+ *
+ * @Note Synchronization level: Thread safe
  */
 class CANMessage : public CAN_Message {
 
@@ -220,6 +222,7 @@ class CAN {
     */
     template<typename T>
     void attach(T* obj, void (T::*method)(), IrqType type=RxIrq) {
+        // Underlying call thread safe
         attach(Callback<void()>(obj, method), type);
     }
 
@@ -232,14 +235,18 @@ class CAN {
     */
     template<typename T>
     void attach(T* obj, void (*method)(T*), IrqType type=RxIrq) {
+        // Underlying call thread safe
         attach(Callback<void()>(obj, method), type);
     }
 
     static void _irq_handler(uint32_t id, CanIrqType type);
 
 protected:
+    virtual void lock();
+    virtual void unlock();
     can_t               _can;
     Callback<void()>    _irq[9];
+    PlatformMutex       _mutex;
 };
 
 } // namespace mbed

hal/api/CThunk.h

@@ -71,6 +71,11 @@
 /* IRQ/Exception compatible thunk entry function */
 typedef void (*CThunkEntry)(void);
 
+/**
+ * Class for created a pointer with data bound to it
+ *
+ * @Note Synchronization level: Not protected
+ */
 template<class T>
 class CThunk
 {

hal/api/CallChain.h

@@ -25,6 +25,8 @@ namespace mbed {
  * sequence using CallChain::call(). Used mostly by the interrupt chaining code,
  * but can be used for other purposes.
  *
+ * @Note Synchronization level: Not protected
+ *
  * Example:
  * @code
  * #include "mbed.h"
@@ -58,6 +60,7 @@ namespace mbed {
  */
 
 typedef Callback<void()> *pFunctionPointer_t;
+class CallChainLink;
 
 class CallChain {
 public:
@@ -160,17 +163,11 @@ class CallChain {
     }
 #endif
 
-private:
-    void _check_size();
-
-    pFunctionPointer_t* _chain;
-    int _size;
-    int _elements;
-
     /* disallow copy constructor and assignment operators */
 private:
     CallChain(const CallChain&);
     CallChain & operator = (const CallChain&);
+    CallChainLink *_chain;
 };
 
 } // namespace mbed

hal/api/Callback.h

@@ -23,6 +23,8 @@ namespace mbed {
 
 
 /** Callback class based on template specialization
+ *
+ * @Note Synchronization level: Not protected
  */
 template <typename F>
 class Callback;