12 files changed, 154 insertions(+), 50 deletions(-)

M module-audio/board/rt1051/CMakeLists.txt
M module-audio/board/rt1051/RT1051Platform.cpp
A module-audio/board/rt1051/bellpx/BellPxAudioDeviceFactory.cpp
R module-audio/board/rt1051/{RT1051DeviceFactory => bellpx/BellPxAudioDeviceFactory}.hpp
A module-audio/board/rt1051/bellpx/CMakeLists.txt
A module-audio/board/rt1051/puretx/CMakeLists.txt
R module-audio/board/rt1051/{RT1051AudioCodec => puretx/PureTxAudioCodec}.cpp
R module-audio/board/rt1051/{RT1051AudioCodec => puretx/PureTxAudioCodec}.hpp
R module-audio/board/rt1051/{RT1051DeviceFactory => puretx/PureTxAudioDeviceFactory}.cpp
A module-audio/board/rt1051/puretx/PureTxAudioDeviceFactory.hpp
R module-audio/board/rt1051/{ => puretx}/RT1051CellularAudio.cpp
R module-audio/board/rt1051/{ => puretx}/RT1051CellularAudio.hpp

@@ 1,18 1,35 @@
 # Copyright (c) 2021, Mudita Sp. z.o.o. All rights reserved.
 # For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
-set(AUDIO_RT1051_SOURCES
-    "SAIAudioDevice.cpp"
-    "RT1051AudioCodec.cpp"
-    "RT1051CellularAudio.cpp"
-    "RT1051DeviceFactory.cpp"
-    "RT1051Platform.cpp"
+add_library(${AUDIO_BOARD_LIBRARY} STATIC)
+
+target_sources(${AUDIO_BOARD_LIBRARY}
+    PRIVATE
+        RT1051Platform.cpp
+        SAIAudioDevice.cpp
+
+    PUBLIC
+        SAIAudioDevice.hpp
+)
+
+target_compile_definitions(${AUDIO_BOARD_LIBRARY}
+    PRIVATE
+        BOARD_${BOARD}=1
+)
+
+target_include_directories(${AUDIO_BOARD_LIBRARY}
+    PUBLIC
+        $<BUILD_INTERFACE:
+            ${CMAKE_CURRENT_SOURCE_DIR}
+            ${CMAKE_CURRENT_SOURCE_DIR}/${BOARD}
+        >
 )
 
-add_library(${AUDIO_BOARD_LIBRARY} STATIC ${AUDIO_RT1051_SOURCES})
-target_include_directories(${AUDIO_BOARD_LIBRARY} INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
 target_link_libraries(${AUDIO_BOARD_LIBRARY}
-    module-bsp
-    module-os
-    module-bluetooth
+    PRIVATE
+        module-bsp
+        module-os
+        module-bluetooth
 )
+
+add_subdirectory(${BOARD})

@@ 3,7 3,15 @@
 
 #include <Audio/AudioPlatform.hpp>
 
-#include "RT1051DeviceFactory.hpp"
+#if BOARD_puretx == 1
+#include <PureTxAudioDeviceFactory.hpp>
+using audio::PureTxAudioDeviceFactory;
+#elif BOARD_bellpx == 1
+#include <BellPxAudioDeviceFactory.hpp>
+using audio::BellPxAudioDeviceFactory;
+#else
+#error "Unsupported board type"
+#endif
 
 #include <utility>
 


@@ 12,5 20,11 @@ using audio::AudioPlatform;
 
 std::unique_ptr<AudioDeviceFactory> AudioPlatform::GetDeviceFactory()
 {
-    return std::make_unique<RT1051DeviceFactory>();
+#if BOARD_puretx == 1
+    return std::make_unique<PureTxAudioDeviceFactory>();
+#elif BOARD_bellpx == 1
+    return std::make_unique<BellPxAudioDeviceFactory>();
+#else
+#error "Unsupported board type"
+#endif
 }

@@ 0,0 1,34 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "BellPxAudioDeviceFactory.hpp"
+
+#include <Audio/Profiles/Profile.hpp>
+
+#include <log/log.hpp>
+
+#include <stdexcept>
+
+using audio::AudioDevice;
+using audio::BellPxAudioDeviceFactory;
+
+std::shared_ptr<AudioDevice> BellPxAudioDeviceFactory::getDevice(const audio::Profile &profile)
+{
+    std::shared_ptr<AudioDevice> device;
+
+    switch (profile.GetAudioDeviceType()) {
+    case AudioDevice::Type::Audiocodec: {
+        LOG_ERROR("Bell audio codec support is not yet implemented.");
+    } break;
+
+    default:
+        break;
+    };
+
+    return device;
+}
+
+std::shared_ptr<AudioDevice> BellPxAudioDeviceFactory::createCellularAudioDevice()
+{
+    throw std::runtime_error("Cellular audio device not valid for Bell platform.");
+}

@@ 9,7 9,7 @@
 namespace audio
 {
 
-    class RT1051DeviceFactory : public AudioDeviceFactory
+    class BellPxAudioDeviceFactory : public AudioDeviceFactory
     {
       public:
         std::shared_ptr<AudioDevice> createCellularAudioDevice() override final;

@@ 0,0 1,7 @@
+target_sources(${AUDIO_BOARD_LIBRARY}
+    PRIVATE
+        BellPxAudioDeviceFactory.cpp
+    
+    PUBLIC
+        BellPxAudioDeviceFactory.hpp
+)

@@ 0,0 1,11 @@
+target_sources(${AUDIO_BOARD_LIBRARY}
+    PRIVATE
+        PureTxAudioCodec.cpp
+        PureTxAudioDeviceFactory.cpp
+        RT1051CellularAudio.cpp
+    
+    PUBLIC
+        PureTxAudioCodec.hpp
+        PureTxAudioDeviceFactory.hpp
+        RT1051CellularAudio.hpp
+)

@@ 1,7 1,7 @@
 // Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
-#include "RT1051AudioCodec.hpp"
+#include "PureTxAudioCodec.hpp"
 #include "board.h"
 #include "dma_config.h"
 #include <log/log.hpp>


@@ 13,23 13,23 @@ using audio::codec::Configuration;
 
 namespace audio
 {
-    sai_edma_handle_t RT1051AudioCodec::txHandle = {};
-    sai_edma_handle_t RT1051AudioCodec::rxHandle = {};
+    sai_edma_handle_t PureTxAudioCodec::txHandle = {};
+    sai_edma_handle_t PureTxAudioCodec::rxHandle = {};
 
-    RT1051AudioCodec::RT1051AudioCodec(const Configuration &format)
+    PureTxAudioCodec::PureTxAudioCodec(const Configuration &format)
         : SAIAudioDevice(BOARD_AUDIOCODEC_SAIx, &rxHandle, &txHandle), saiInFormat{}, saiOutFormat{},
           codecParams{}, codec{},
           formats(audio::AudioFormat::makeMatrix(supportedSampleRates, supportedBitWidths, supportedChannelModes)),
           currentFormat(format)
     {}
 
-    RT1051AudioCodec::~RT1051AudioCodec()
+    PureTxAudioCodec::~PureTxAudioCodec()
     {
         Stop();
         DeinitBsp();
     }
 
-    CodecParamsMAX98090::InputPath RT1051AudioCodec::getCodecInputPath(const Configuration &format)
+    CodecParamsMAX98090::InputPath PureTxAudioCodec::getCodecInputPath(const Configuration &format)
     {
         switch (format.inputPath) {
         case audio::codec::InputPath::Headphones:


@@ 43,7 43,7 @@ namespace audio
         };
     }
 
-    CodecParamsMAX98090::OutputPath RT1051AudioCodec::getCodecOutputPath(const Configuration &format)
+    CodecParamsMAX98090::OutputPath PureTxAudioCodec::getCodecOutputPath(const Configuration &format)
     {
         const auto mono = (format.flags & static_cast<std::uint32_t>(audio::codec::Flags::OutputMono)) != 0;
 


@@ 63,7 63,7 @@ namespace audio
         }
     }
 
-    AudioDevice::RetCode RT1051AudioCodec::Start()
+    AudioDevice::RetCode PureTxAudioCodec::Start()
     {
         if (state == State::Running) {
             return AudioDevice::RetCode::Failure;


@@ 116,7 116,7 @@ namespace audio
         return AudioDevice::RetCode::Success;
     }
 
-    AudioDevice::RetCode RT1051AudioCodec::Stop()
+    AudioDevice::RetCode PureTxAudioCodec::Stop()
     {
         if (state == State::Stopped) {
             return AudioDevice::RetCode::Failure;


@@ 133,7 133,7 @@ namespace audio
         return AudioDevice::RetCode::Success;
     }
 
-    AudioDevice::RetCode RT1051AudioCodec::setOutputVolume(float vol)
+    AudioDevice::RetCode PureTxAudioCodec::setOutputVolume(float vol)
     {
         currentFormat.outputVolume = vol;
         CodecParamsMAX98090 params;


@@ 143,7 143,7 @@ namespace audio
         return AudioDevice::RetCode::Success;
     }
 
-    AudioDevice::RetCode RT1051AudioCodec::setInputGain(float gain)
+    AudioDevice::RetCode PureTxAudioCodec::setInputGain(float gain)
     {
         currentFormat.inputGain = gain;
         CodecParamsMAX98090 params;


@@ 153,7 153,7 @@ namespace audio
         return AudioDevice::RetCode::Success;
     }
 
-    AudioDevice::RetCode RT1051AudioCodec::InputPathCtrl(audio::codec::InputPath inputPath)
+    AudioDevice::RetCode PureTxAudioCodec::InputPathCtrl(audio::codec::InputPath inputPath)
     {
         currentFormat.inputPath = inputPath;
         CodecParamsMAX98090 params;


@@ 163,7 163,7 @@ namespace audio
         return AudioDevice::RetCode::Success;
     }
 
-    AudioDevice::RetCode RT1051AudioCodec::OutputPathCtrl(audio::codec::OutputPath outputPath)
+    AudioDevice::RetCode PureTxAudioCodec::OutputPathCtrl(audio::codec::OutputPath outputPath)
     {
         currentFormat.outputPath = outputPath;
         CodecParamsMAX98090 params;


@@ 173,17 173,17 @@ namespace audio
         return AudioDevice::RetCode::Success;
     }
 
-    void RT1051AudioCodec::InitBsp()
+    void PureTxAudioCodec::InitBsp()
     {
         bsp::audioInit();
     }
 
-    void RT1051AudioCodec::DeinitBsp()
+    void PureTxAudioCodec::DeinitBsp()
     {
         bsp::audioDeinit();
     }
 
-    void RT1051AudioCodec::InStart()
+    void PureTxAudioCodec::InStart()
     {
         sai_transfer_format_t sai_format;
         auto audioCfg = bsp::AudioConfig::get();


@@ 215,7 215,7 @@ namespace audio
         SAI_RxSoftwareReset(BOARD_AUDIOCODEC_SAIx, kSAI_ResetTypeSoftware);
     }
 
-    void RT1051AudioCodec::OutStart()
+    void PureTxAudioCodec::OutStart()
     {
         sai_transfer_format_t sai_format;
         auto audioCfg = bsp::AudioConfig::get();


@@ 246,7 246,7 @@ namespace audio
         SAI_TxSoftwareReset(BOARD_AUDIOCODEC_SAIx, kSAI_ResetTypeSoftware);
     }
 
-    void RT1051AudioCodec::OutStop()
+    void PureTxAudioCodec::OutStop()
     {
         SAI_TxDisableInterrupts(BOARD_AUDIOCODEC_SAIx, kSAI_FIFOErrorInterruptEnable);
         if (txHandle.dmaHandle) {


@@ 255,7 255,7 @@ namespace audio
         memset(&txHandle, 0, sizeof(txHandle));
     }
 
-    void RT1051AudioCodec::InStop()
+    void PureTxAudioCodec::InStop()
     {
         SAI_RxDisableInterrupts(BOARD_AUDIOCODEC_SAIx, kSAI_FIFOErrorInterruptEnable);
         if (rxHandle.dmaHandle) {


@@ 264,7 264,7 @@ namespace audio
         memset(&rxHandle, 0, sizeof(rxHandle));
     }
 
-    void RT1051AudioCodec::SetupEQ()
+    void PureTxAudioCodec::SetupEQ()
     {
         const auto bands = currentFormat.filterCoefficients.size();
         for (std::size_t band = 0; band < bands; band++) {


@@ 275,17 275,17 @@ namespace audio
         codec.EnableFilterBands(bands);
     }
 
-    auto RT1051AudioCodec::getSupportedFormats() -> std::vector<AudioFormat>
+    auto PureTxAudioCodec::getSupportedFormats() -> std::vector<AudioFormat>
     {
         return formats;
     }
 
-    auto RT1051AudioCodec::getTraits() const -> Traits
+    auto PureTxAudioCodec::getTraits() const -> Traits
     {
         return Traits{.usesDMA = true};
     }
 
-    auto RT1051AudioCodec::getSourceFormat() -> audio::AudioFormat
+    auto PureTxAudioCodec::getSourceFormat() -> audio::AudioFormat
     {
         if (currentFormat.flags == 0) {
             return audio::nullFormat;


@@ 297,13 297,13 @@ namespace audio
 
     void rxAudioCodecCallback(I2S_Type *base, sai_edma_handle_t *handle, status_t status, void *userData)
     {
-        auto self = static_cast<RT1051AudioCodec *>(userData);
+        auto self = static_cast<PureTxAudioCodec *>(userData);
         self->onDataReceive();
     }
 
     void txAudioCodecCallback(I2S_Type *base, sai_edma_handle_t *handle, status_t status, void *userData)
     {
-        auto self = static_cast<RT1051AudioCodec *>(userData);
+        auto self = static_cast<PureTxAudioCodec *>(userData);
         self->onDataSend();
     }
 

@@ 27,15 27,15 @@ namespace audio
     void txAudioCodecCallback(I2S_Type *base, sai_edma_handle_t *handle, status_t status, void *userData);
     void rxAudioCodecCallback(I2S_Type *base, sai_edma_handle_t *handle, status_t status, void *userData);
 
-    class RT1051AudioCodec : public SAIAudioDevice
+    class PureTxAudioCodec : public SAIAudioDevice
     {
 
       public:
         friend void txAudioCodecCallback(I2S_Type *base, sai_edma_handle_t *handle, status_t status, void *userData);
         friend void rxAudioCodecCallback(I2S_Type *base, sai_edma_handle_t *handle, status_t status, void *userData);
 
-        RT1051AudioCodec(const audio::codec::Configuration &format);
-        virtual ~RT1051AudioCodec();
+        PureTxAudioCodec(const audio::codec::Configuration &format);
+        virtual ~PureTxAudioCodec();
 
         AudioDevice::RetCode Start() override final;
         AudioDevice::RetCode Stop() override final;

@@ 1,24 1,24 @@
 // Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
-#include "RT1051DeviceFactory.hpp"
-#include "board/rt1051/RT1051AudioCodec.hpp"
-#include "board/rt1051/RT1051CellularAudio.hpp"
+#include "PureTxAudioDeviceFactory.hpp"
+#include "PureTxAudioCodec.hpp"
+#include "RT1051CellularAudio.hpp"
 #include "audio/BluetoothAudioDevice.hpp"
 
 #include <Audio/Profiles/Profile.hpp>
 
 using audio::AudioDevice;
-using audio::RT1051AudioCodec;
+using audio::PureTxAudioCodec;
+using audio::PureTxAudioDeviceFactory;
 using audio::RT1051CellularAudio;
-using audio::RT1051DeviceFactory;
 
-std::shared_ptr<AudioDevice> RT1051DeviceFactory::getDevice(const audio::Profile &profile)
+std::shared_ptr<AudioDevice> PureTxAudioDeviceFactory::getDevice(const audio::Profile &profile)
 {
     std::shared_ptr<AudioDevice> device;
     switch (profile.GetAudioDeviceType()) {
     case AudioDevice::Type::Audiocodec: {
-        device = std::make_shared<RT1051AudioCodec>(profile.GetAudioConfiguration());
+        device = std::make_shared<PureTxAudioCodec>(profile.GetAudioConfiguration());
     } break;
 
     case AudioDevice::Type::BluetoothA2DP: {


@@ 44,7 44,7 @@ std::shared_ptr<AudioDevice> RT1051DeviceFactory::getDevice(const audio::Profile
     return device;
 }
 
-std::shared_ptr<AudioDevice> RT1051DeviceFactory::createCellularAudioDevice()
+std::shared_ptr<AudioDevice> PureTxAudioDeviceFactory::createCellularAudioDevice()
 {
     return std::make_shared<RT1051CellularAudio>();
 }

@@ 0,0 1,21 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <Audio/AudioDeviceFactory.hpp>
+#include <Audio/Profiles/Profile.hpp>
+
+namespace audio
+{
+
+    class PureTxAudioDeviceFactory : public AudioDeviceFactory
+    {
+      public:
+        std::shared_ptr<AudioDevice> createCellularAudioDevice() override final;
+
+      protected:
+        std::shared_ptr<AudioDevice> getDevice(const Profile &audioProfile) override;
+    };
+
+}; // namespace audio