14 files changed, 373 insertions(+), 8 deletions(-)

A module-bsp/board/linux/keypad_backlight/keypad_backlight.cpp
A module-bsp/board/rt1051/bsp/keypad_backlight/LP55281.hpp
A module-bsp/board/rt1051/bsp/keypad_backlight/keypad_backlight.cpp
M module-bsp/board/rt1051/common/pin_mux.c
M module-bsp/bsp/BoardDefinitions.hpp
A module-bsp/bsp/keypad_backlight/keypad_backlight.hpp
M module-bsp/targets/Target_Linux.cmake
M module-bsp/targets/Target_RT1051.cmake
M module-services/service-evtmgr/CMakeLists.txt
A module-services/service-evtmgr/EVMessages.cpp
M module-services/service-evtmgr/EventManager.cpp
M module-services/service-evtmgr/WorkerEvent.cpp
M module-services/service-evtmgr/service-evtmgr/EVMessages.hpp
M source/MessageType.hpp

@@ 0,0 1,54 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "bsp/keypad_backlight/keypad_backlight.hpp"
+#include "bsp/BoardDefinitions.hpp"
+
+using namespace drivers;
+
+namespace bsp::keypad_backlight
+{
+    namespace
+    {
+        bool diodesState = false;
+    }
+
+    std::int32_t init()
+    {
+        return 0;
+    }
+
+    void deinit()
+    {}
+
+    bool turnOnAll()
+    {
+        diodesState = true;
+        return true;
+    }
+
+    bool configureModule()
+    {
+        return true;
+    }
+
+    bool shutdown()
+    {
+        diodesState = false;
+        return true;
+    }
+
+    void wakeup()
+    {}
+
+    bool reset()
+    {
+        return true;
+    }
+
+    bool checkState()
+    {
+        return diodesState;
+    }
+
+} // namespace bsp::keypad_backlight

@@ 0,0 1,63 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <algorithm>
+
+namespace bsp::keypad_backlight
+{
+    constexpr inline auto LP55281_DEVICE_ADDR = 0x4C;
+
+    enum class LP55281_Registers
+    {
+        RED1       = 0x00,
+        GREEN1     = 0x01,
+        BLUE1      = 0x02,
+        RED2       = 0x03,
+        GREEN2     = 0x04,
+        BLUE2      = 0x05,
+        RED3       = 0x06,
+        GREEN3     = 0x07,
+        BLUE3      = 0x08,
+        RED4       = 0x09,
+        GREEN4     = 0x0a,
+        BLUE4      = 0x0b,
+        ALED       = 0x0c,
+        CTRL1      = 0x0d,
+        CTRL2      = 0x0e,
+        BOOST_CTRL = 0x0f,
+        FREQ_SEL   = 0x10,
+        ENABLES    = 0x11,
+        LED_TEST   = 0x12,
+        ADC_OUT    = 0x13,
+        RESET      = 0x60,
+    };
+
+    struct Diode_Reg
+    {
+        std::uint8_t max_current : 2;
+        std::uint8_t current : 6;
+    };
+
+    constexpr inline auto MAX_DIODE_CURRENT_LIMIT = 0b11;
+    constexpr inline auto MAX_BRIGHTNESS_INT      = 63;
+
+    constexpr inline auto BOOST_OUTPUT_4V = 0x00;
+
+    constexpr inline auto NSTDBY       = 0b10000000;
+    constexpr inline auto BOOST_EN     = 0b01000000;
+    constexpr inline auto LED_PORTS_EN = 0b00001110; // Only ports 2-4 active on board
+    constexpr inline auto WAKEUP       = NSTDBY | BOOST_EN | LED_PORTS_EN;
+
+    constexpr inline auto LED_TEST_THRESHOLD = 3; // 0.18mA = (15mA/255) * 3
+    constexpr inline auto EN_LED_TEST        = 0b00010000;
+
+    constexpr std::uint8_t encode_diode_brightness_to_6bits(float normalized_brightness)
+    {
+        return std::clamp(static_cast<std::uint8_t>(MAX_BRIGHTNESS_INT * normalized_brightness),
+                          static_cast<std::uint8_t>(0),
+                          static_cast<std::uint8_t>(MAX_BRIGHTNESS_INT));
+    }
+
+} // namespace bsp::keypad_backlight

@@ 0,0 1,156 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "bsp/keypad_backlight/keypad_backlight.hpp"
+#include "LP55281.hpp"
+
+#include "bsp/BoardDefinitions.hpp"
+#include "drivers/i2c/DriverI2C.hpp"
+
+#include "fsl_common.h"
+#include <array>
+
+extern "C"
+{
+#include "FreeRTOS.h"
+#include "task.h"
+}
+
+namespace bsp::keypad_backlight
+{
+    namespace
+    {
+        std::shared_ptr<drivers::DriverGPIO> gpio;
+
+        std::shared_ptr<drivers::DriverI2C> i2c;
+
+        drivers::I2CAddress addr = {.deviceAddress = static_cast<uint32_t>(LP55281_DEVICE_ADDR), .subAddressSize = 1};
+
+        constexpr std::array<LP55281_Registers, 4> usedOutputs = {LP55281_Registers::RED2,    // Red right button
+                                                                  LP55281_Registers::GREEN3,  // Green left button
+                                                                  LP55281_Registers::RED4,    // Keypad right side
+                                                                  LP55281_Registers::GREEN4}; // Keypad left side
+
+        bool writeSingleRegister(std::uint32_t address, std::uint8_t *to_send)
+        {
+            addr.subAddress    = address;
+            auto write_success = i2c->Write(addr, to_send, 1);
+
+            return write_success == 1;
+        }
+
+        ssize_t readSingleRegister(std::uint32_t address, std::uint8_t *readout)
+        {
+            addr.subAddress = address;
+            return i2c->Read(addr, readout, 1);
+        }
+    } // namespace
+
+    std::int32_t init()
+    {
+        i2c = drivers::DriverI2C::Create(
+            static_cast<drivers::I2CInstances>(BoardDefinitions::KEYPAD_BACKLIGHT_DRIVER_I2C),
+            drivers::DriverI2CParams{
+                .baudrate = static_cast<std::uint32_t>(BoardDefinitions::KEYPAD_BACKLIGHT_DRIVER_I2C_BAUDRATE)});
+
+        gpio = drivers::DriverGPIO::Create(
+            static_cast<drivers::GPIOInstances>(BoardDefinitions::KEYPAD_BACKLIGHT_DRIVER_GPIO),
+            drivers::DriverGPIOParams{});
+
+        gpio->ConfPin(drivers::DriverGPIOPinParams{
+            .dir      = drivers::DriverGPIOPinParams::Direction::Output,
+            .irqMode  = drivers::DriverGPIOPinParams::InterruptMode::NoIntmode,
+            .defLogic = 1,
+            .pin      = static_cast<std::uint32_t>(BoardDefinitions::KEYPAD_BACKLIGHT_DRIVER_NRST)});
+
+        wakeup();
+        bool status = reset();
+        shutdown();
+
+        return status ? kStatus_Success : kStatus_Fail;
+    }
+
+    void deinit()
+    {
+        shutdown();
+    }
+
+    bool turnOnAll()
+    {
+        constexpr DiodeIntensity intensity = 1.0f; // Maximum brightness
+        Diode_Reg diode_reg                = {.max_current = MAX_DIODE_CURRENT_LIMIT,
+                               .current     = encode_diode_brightness_to_6bits(intensity)};
+
+        wakeup();
+        configureModule();
+
+        for (auto &diode : usedOutputs) {
+            std::uint32_t address = static_cast<std::uint32_t>(diode);
+            if (!writeSingleRegister(address, reinterpret_cast<std::uint8_t *>(&diode_reg))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    bool configureModule()
+    {
+        std::uint8_t reg_val = BOOST_OUTPUT_4V;
+        if (!writeSingleRegister(static_cast<std::uint32_t>(LP55281_Registers::BOOST_CTRL), &reg_val)) {
+            return false;
+        }
+
+        reg_val = WAKEUP;
+        if (!writeSingleRegister(static_cast<std::uint32_t>(LP55281_Registers::ENABLES), &reg_val)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    bool shutdown()
+    {
+        gpio->WritePin(static_cast<std::uint32_t>(BoardDefinitions::KEYPAD_BACKLIGHT_DRIVER_NRST), 0);
+        return true;
+    }
+
+    void wakeup()
+    {
+        gpio->WritePin(static_cast<std::uint32_t>(BoardDefinitions::KEYPAD_BACKLIGHT_DRIVER_NRST), 1);
+    }
+
+    bool reset()
+    {
+        std::uint8_t reset_value = 0xff;
+        return writeSingleRegister(static_cast<std::uint32_t>(LP55281_Registers::RESET), &reset_value);
+    }
+
+    // Must be run at least 20ms after leds startup
+    bool checkState()
+    {
+        std::uint8_t value = 0;
+        for (const auto diode : usedOutputs) {
+            value = static_cast<std::uint8_t>(diode) | EN_LED_TEST;
+
+            if (!writeSingleRegister(static_cast<std::uint32_t>(LP55281_Registers::LED_TEST), &value)) {
+                return false;
+            }
+
+            vTaskDelay(pdMS_TO_TICKS(2));
+
+            if (readSingleRegister(static_cast<std::uint32_t>(LP55281_Registers::ADC_OUT), &value) != 1) {
+                return false;
+            }
+
+            if (value < LED_TEST_THRESHOLD) {
+                return false;
+            }
+        }
+
+        value = 0;
+        writeSingleRegister(static_cast<std::uint32_t>(LP55281_Registers::LED_TEST), &value);
+
+        return true;
+    }
+
+} // namespace bsp::keypad_backlight

@@ 1181,10 1181,9 @@ void PINMUX_InitLEDDRIVER(void)
     IOMUXC_SetPinMux(PINMUX_LEDDRIVER_NRST, /* GPIO_AD_B0_00 is configured as LPSPI1_SCK */
                      0U);                   /* Software Input On Field: Input Path is determined by functionality */
 
-    IOMUXC_SetPinConfig(PINMUX_LEDDRIVER_NRST, /* GPIO_AD_B0_02 PAD functional properties : */
-                        PAD_CONFIG_SLEW_RATE_SLOW | PAD_CONFIG_DRIVER_STRENGTH_LVL_1 | PAD_CONFIG_SPEED_SLOW_50MHz |
-                            PAD_CONFIG_PULL_KEEPER_ENABLED | PAD_CONFIG_SELECT_PULL | PAD_CONFIG_PULL_UP_100kOhm |
-                            PAD_CONFIG_HYSTERESIS_DISABLED);
+    IOMUXC_SetPinConfig(PINMUX_LEDDRIVER_NRST, /* GPIO_AD_B0_03 PAD functional properties : */
+                        PAD_CONFIG_PULL_UP_22kOhm | PAD_CONFIG_SELECT_PULL | PAD_CONFIG_PULL_KEEPER_DISABLED |
+                            PAD_CONFIG_DRIVER_STRENGTH_LVL_4 | PAD_CONFIG_SLEW_RATE_SLOW | PAD_CONFIG_SPEED_SLOW_50MHz);
 }
 
 void PINMUX_InitCellular(void)

@@ 104,6 104,11 @@ enum class BoardDefinitions
     TORCH_DRIVER_GPIO = static_cast<int>(drivers::GPIOInstances::GPIO_1),
     TORCH_DRIVER_EN = 21, // GPIO_AD_B1_05 Active HIGH. Internal pulldown resistor of 300kΩ between HWEN and GND.
 
+    KEYPAD_BACKLIGHT_DRIVER_I2C_BAUDRATE = AUDIOCODEC_I2C_BAUDRATE,
+    KEYPAD_BACKLIGHT_DRIVER_I2C = AUDIOCODEC_I2C,
+    KEYPAD_BACKLIGHT_DRIVER_GPIO = static_cast<int>(drivers::GPIOInstances::GPIO_1),
+    KEYPAD_BACKLIGHT_DRIVER_NRST = 3, // GPIO_AD_B0_03 Active LOW. External pulldown resistor of 10Ω between NRST and GND.
+
 };
 
 #endif //PUREPHONE_BOARDDEFINITIONS_HPP

@@ 0,0 1,35 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <cstdint>
+
+namespace bsp::keypad_backlight
+{
+    enum class Action
+    {
+        turnOn,
+        turnOff,
+        checkState,
+    };
+
+    using DiodeIntensity = float;
+
+    std::int32_t init();
+
+    void deinit();
+
+    bool turnOnAll();
+
+    bool configureModule();
+
+    bool shutdown();
+
+    void wakeup();
+
+    bool reset();
+
+    bool checkState();
+
+} // namespace bsp::keypad_backlight

@@ 29,6 29,8 @@ set(BOARD_SOURCES
 
         "${CMAKE_CURRENT_SOURCE_DIR}/board/linux/torch/torch.cpp"
 
+        "${CMAKE_CURRENT_SOURCE_DIR}/board/linux/keypad_backlight/keypad_backlight.cpp"
+
         "${CMAKE_CURRENT_SOURCE_DIR}/board/linux/watchdog/watchdog.cpp"
 
         CACHE INTERNAL "")

@@ 65,10 65,11 @@ set(BOARD_SOURCES ${BOARD_SOURCES}
 	"${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/drivers/RT1051DriverDMAMux.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/drivers/RT1051DriverDMA.cpp"
 	"${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/drivers/RT1051DriverGPIO.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/bsp/magnetometer/magnetometer.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/bsp/magnetometer/ALS31300.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/bsp/torch/torch.cpp"
-
+   	"${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/bsp/magnetometer/magnetometer.cpp"
+	"${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/bsp/magnetometer/ALS31300.cpp"
+	"${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/bsp/torch/torch.cpp"
+	"${CMAKE_CURRENT_SOURCE_DIR}/board/rt1051/bsp/keypad_backlight/keypad_backlight.cpp"
+	
 	CACHE INTERNAL ""
 )
 

@@ 3,6 3,7 @@ message( "${PROJECT_NAME}  ${CMAKE_CURRENT_LIST_DIR}" )
 
 set(SOURCES
         EventManager.cpp
+        EVMessages.cpp
         WorkerEvent.cpp
         alarm/EventManagerAlarm.cpp
         api/EventManagerServiceAPI.cpp

@@ 0,0 1,24 @@
+// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "service-evtmgr/EVMessages.hpp"
+
+namespace sevm
+{
+    bool KeypadBacklightMessage::processAction(bsp::keypad_backlight::Action act)
+    {
+        bool response = false;
+        switch (act) {
+        case bsp::keypad_backlight::Action::turnOn:
+            response = bsp::keypad_backlight::turnOnAll();
+            break;
+        case bsp::keypad_backlight::Action::turnOff:
+            response = bsp::keypad_backlight::shutdown();
+            break;
+        case bsp::keypad_backlight::Action::checkState:
+            response = bsp::keypad_backlight::checkState();
+            break;
+        }
+        return response;
+    }
+} // namespace sevm

@@ 19,6 19,7 @@
 #include <bsp/magnetometer/magnetometer.hpp>
 #include <bsp/rtc/rtc.hpp>
 #include <bsp/torch/torch.hpp>
+#include <bsp/keypad_backlight/keypad_backlight.hpp>
 #include <common_data/RawKey.hpp>
 #include <log/log.hpp>
 #include <module-utils/time/time_conversion.hpp>


@@ 272,6 273,13 @@ sys::ReturnCodes EventManager::InitHandler()
         return std::make_shared<sys::ResponseMessage>();
     });
 
+    connect(sevm::KeypadBacklightMessage(), [&](sys::Message *msgl) {
+        auto msg         = static_cast<sevm::KeypadBacklightMessage *>(msgl);
+        auto message     = std::make_shared<sevm::KeypadBacklightMessage>();
+        message->success = msg->processAction(msg->action);
+        return message;
+    });
+
     // initialize keyboard worker
     EventWorker = std::make_unique<WorkerEvent>(this);
 

@@ 17,6 17,7 @@
 #include <bsp/magnetometer/magnetometer.hpp>
 #include <bsp/rtc/rtc.hpp>
 #include <bsp/torch/torch.hpp>
+#include <bsp/keypad_backlight/keypad_backlight.hpp>
 #include <bsp/vibrator/vibrator.hpp>
 #include <common_data/EventStore.hpp>
 #include <common_data/RawKey.hpp>


@@ 179,6 180,7 @@ bool WorkerEvent::init(std::list<sys::WorkerQueueInfo> queues)
     bsp::cellular::init(qhandles[static_cast<int32_t>(WorkerEventQueues::queueCellular)]);
     bsp::magnetometer::init(qhandles[static_cast<int32_t>(WorkerEventQueues::queueMagnetometerIRQ)]);
     bsp::torch::init(qhandles[static_cast<int32_t>(WorkerEventQueues::queueTorch)]);
+    bsp::keypad_backlight::init();
 
     time_t timestamp;
     bsp::rtc_GetCurrentTimestamp(&timestamp);


@@ 194,6 196,7 @@ bool WorkerEvent::deinit(void)
     bsp::headset::Deinit();
     bsp::battery_Deinit();
     bsp::torch::deinit();
+    bsp::keypad_backlight::deinit();
 
     return true;
 }

@@ 14,6 14,7 @@
 #include <bsp/common.hpp>
 #include <bsp/keyboard/key_codes.hpp>
 #include <bsp/torch/torch.hpp>
+#include <bsp/keypad_backlight/keypad_backlight.hpp>
 
 #include <string>
 


@@ 123,5 124,16 @@ namespace sevm
         {}
         bool success = false;
     };
+    class KeypadBacklightMessage : public Message
+    {
+      public:
+        explicit KeypadBacklightMessage() : Message(MessageType::EVMKeypadBacklightMessage)
+        {}
+
+        bool processAction(bsp::keypad_backlight::Action act);
+
+        bsp::keypad_backlight::Action action;
+        bool success;
+    };
 
 } /* namespace sevm*/

@@ 171,6 171,8 @@ enum class MessageType
     EVMTimeUpdated,   ///< This message is send on every time update.
     // Torch messages
     EVMTorchStateMessage,
+    // Keypad backlight messages
+    EVMKeypadBacklightMessage,
 
     // cellular messages
     EVMGetBoard,