ble-light/components/ethermind/platforms/phy6200/mesh/mesh_clients.c

/**
 *  \file mesh_clients.c
 *
 *
 */

/*
 *  Copyright (C) 2018. Mindtree Limited.
 *  All rights reserved.
 */

/* --------------------------------------------- Header File Inclusion */
#include "mesh_clients.h"

/* --------------------------------------------- Global Definitions */
/* Compilation Switch to have this module print trace on console */
#define MESH_CLIENT_CONSOLE_DEBUG

/* --------------------------------------------- Macros */
#ifdef MESH_CLIENT_CONSOLE_DEBUG
#define MESH_CLIENT_TRC(...) printf(__VA_ARGS__)
#else /* MESH_CLIENT_CONSOLE_DEBUG */
#define MESH_CLIENT_TRC(...)
#endif /* MESH_CLIENT_CONSOLE_DEBUG */

/* --------------------------------------------- External Global Variables */

/* --------------------------------------------- Exported Global Variables */

/* --------------------------------------------- Static Global Variables */
/**
 * This Task ID is the identifier used by the GATT APIs to reference
 * the BLE Mesh Application Task.
 * The definition and usage of this is from the bleMesh.c application
 * file.
 */
extern uint8_t bleMesh_TaskID;

/* --------------------------------------------- Functions */

#define MESH_MAX_CLI_ENV             1

/* Global variable definition */
struct mesh_cli_env_tag mesh_cli_env[MESH_MAX_CLI_ENV];

/* Mesh Provisioning Service Client Related Callbacks */
static mesh_prov_client_cb   * prov_cli_cb;

/* Mesh Proxy Service Client Related Callbacks */
static mesh_proxy_client_cb  * proxy_cli_cb;

/* Track current UUID being Discovered */
static uint16_t mesh_client_curr_dis_uuid;

/* ----------------------------------------------------------------------------
 * Function      : void mesh_client_init(void)
 * ----------------------------------------------------------------------------
 * Description   : Initialize Mesh Client environment
 * Inputs        : None
 * Outputs       : None
 * Assumptions   : None
 * ------------------------------------------------------------------------- */
void mesh_client_init(void)
{
    for (unsigned int i = 0; i < MESH_MAX_CLI_ENV; i++)
    {
        /* Reset the application manager environment */
        memset(&mesh_cli_env[i], 0, sizeof(struct mesh_cli_env_tag));
    }

    mesh_client_curr_dis_uuid = 0x0000;

    prov_cli_cb  = NULL;
    proxy_cli_cb = NULL;
}

/**
 * Routine to update the connection identifier for Mesh.
 */
void mesh_client_update_conidx (uint16_t conidx)
{
    mesh_cli_env[0].conidx = conidx;
}

/**
 * \brief Register Mesh Provisioning Client instance
 *
 * Function registers new Mesh Provisioning Client instance.
 *
 * \param [in] cb               client application callbacks
 *
 * \return None
 *
 */
void mesh_prov_client_init(mesh_prov_client_cb * cb)
{
    /* Register the upper layer provided Provisioning Client Callbacks */
    if (NULL != cb)
    {
        prov_cli_cb = cb;
    }
}

/**
 * \brief Register Mesh Proxy Client instance
 *
 * Function registers new Mesh Proxy Client instance.
 *
 * \param [in] cb               client application callbacks
 *
 * \return None
 *
 */
void mesh_proxy_client_init(mesh_proxy_client_cb * cb)
{
    /* Register the upper layer provided Provisioning Client Callbacks */
    if (NULL != cb)
    {
        proxy_cli_cb = cb;
    }
}

API_RESULT mesh_client_discover_services
           (
               uint16_t conidx,
               uint8_t serv_mode
           )
{
    uint8_t svc_uuid[2];
    bStatus_t ret;

    if (BLEBRR_GATT_PROV_MODE == serv_mode)
    {
        /* UUID is Provisioning Service */
        svc_uuid[0] = (uint8_t)(UUID_MESH_PROVISIONING_SERVICE);
        svc_uuid[1] = (uint8_t)(UUID_MESH_PROVISIONING_SERVICE >> 8);
        /* EM_mem_copy(svc_uuid, MESH_PROV_SERVICE_UUID128, 16); */
        mesh_client_curr_dis_uuid = UUID_MESH_PROVISIONING_SERVICE;
    }
    else
    {
        /* UUID is Proxy Service */
        svc_uuid[0] = (uint8_t)(UUID_MESH_PROXY_SERVICE);
        svc_uuid[1] = (uint8_t)(UUID_MESH_PROXY_SERVICE >> 8);
        /* EM_mem_copy(svc_uuid, MESH_PROXY_SERVICE_UUID128, 16); */
        mesh_client_curr_dis_uuid = UUID_MESH_PROVISIONING_SERVICE;
    }

    /* Discover service by UUID */
    ret = GATT_DiscPrimaryServiceByUUID
          (
              conidx,
              svc_uuid,
              ATT_BT_UUID_SIZE,
              bleMesh_TaskID
          );

    MESH_CLIENT_TRC(
    "Discovery Primiary Service UUID 0x%04X "
    "returned with retval 0x%04X\r\n",
    mesh_client_curr_dis_uuid, ret);

    return (0 == ret) ? API_SUCCESS : API_FAILURE;
}

/* ----------------------------------------------------------------------------
 * Function      : void mesh_client_send_wwr(uint8_t conidx, uint8_t *value,
 *                                                uint16_t handle, uint8_t offset,
 *                                                uint16_t length, uint8_t type)
 * ----------------------------------------------------------------------------
 * Description   : Send a write command or request to the client device
 * Inputs        : - conidx       - Connection index
 *                 - value        - Pointer to value
 *                 - handle       - Attribute handle
 *                 - length       - Length of value
 *                 - type         - Type of write message
 * Outputs       : None
 * Assumptions   : None
 * ------------------------------------------------------------------------- */
void mesh_client_send_wwr
     (
         uint16_t  conidx,
         uint8_t   * value,
         uint16_t  length,
         uint8_t   serv_pref
     )
{
    attWriteReq_t req;
    bStatus_t     ret;

    /* Assign the Handle Based on the Service Preference for Write */
    req.handle = (BLEBRR_GATT_PROV_MODE == serv_pref) ? \
                  mesh_cli_env[0].prov_data_in_hdl :    \
                  mesh_cli_env[0].proxy_data_in_hdl;

    req.len    = length;
    req.sig    = 0x00;
    req.cmd    = 0x01; /* Write witout response */

    osal_memcpy(req.value, value, length);

    ret = GATT_WriteNoRsp(conidx, &req);

     MESH_CLIENT_TRC(
     "Writing data : len 0x%04X : handle 0x%02X : ret 0x%04X\n",
     req.len, req.handle, ret);

    return;
}

/* ----------------------------------------------------------------------------
 * Function      : void mesh_client_config_ntf
 *                      (
 *                          uint16_t  conidx,
 *                          uint8_t   serv_pref,
 *                          uint8_t   flag
 *                      )
 * ----------------------------------------------------------------------------
 * Description   : Send a write command or request to the client device
 * Inputs        : - conidx    - Connection index
 *                 - serv_pref - Provisioning or Proxy Service
 *                 - flag      - enable or disable
 * Outputs       : None
 * Assumptions   : None
 * ------------------------------------------------------------------------- */
API_RESULT mesh_client_config_ntf
           (
               uint16_t  conidx,
               uint8_t   serv_pref,
               uint8_t   flag
           )
{
    attWriteReq_t req;
    bStatus_t     ret;

    /* Assign the Handle Based on the Service Preference for Write */
    /**
     * Increment the Handle by 1 as the CCCD is present in the handle next to
     * the Value handle
     */
    req.handle   =  (BLEBRR_GATT_PROV_MODE == serv_pref) ?    \
                   mesh_cli_env[0].prov_data_out_cccd_hdl : \
                   mesh_cli_env[0].proxy_data_out_cccd_hdl;
    req.len      = 0x02;
    req.sig      = 0x00;
    req.cmd      = 0x00;

    req.value[0] = (true == flag) ? 0x01 : 0x00;
    req.value[1] = 0x00;

    /* Store CCCD Mode and State in global */
    mesh_cli_env[0].curr_notif_state = flag;
    mesh_cli_env[0].curr_notif_mode  = (BLEBRR_GATT_PROV_MODE == serv_pref) ?    \
                                       BLEBRR_GATT_PROV_MODE :                   \
                                       BLEBRR_GATT_PROXY_MODE;

    ret = GATT_WriteCharValue(mesh_cli_env[0].conidx, &req, bleMesh_TaskID);

    MESH_CLIENT_TRC
    ("Writing %d to CCCD 0x%04X for Mode 0x%02X\n",
    flag, req.handle, serv_pref);

    return (0 == ret) ? API_SUCCESS : API_FAILURE;
}

void mesh_client_process_gattMsg
     (
         gattMsgEvent_t *pMsg,
         uint8_t        t_id
     )
{
    bStatus_t ret;
    uint16_t  serv_start_hndl, serv_end_hndl;

    MESH_CLIENT_TRC("Processing GATT Messages:\n");
    MESH_CLIENT_TRC("pMsg->method: 0x%X\n",pMsg->method);
    MESH_CLIENT_TRC("pMsg->hdr.status: 0x%X\n",pMsg->hdr.status);

    /* Cache the Task ID */
    bleMesh_TaskID = t_id;

    /* Process the GATT server message */
    switch ( pMsg->method )
    {
        case ATT_EXCHANGE_MTU_RSP:
            break;

        case ATT_FIND_BY_TYPE_VALUE_RSP:
            {
                if (bleProcedureComplete == pMsg->hdr.status)
                {
                    if (UUID_MESH_PROVISIONING_SERVICE == mesh_client_curr_dis_uuid)
                    {
                        serv_start_hndl = mesh_cli_env[0].prov_start_hdl;
                        serv_end_hndl   = mesh_cli_env[0].prov_end_hdl;
                    }
                    else if (UUID_MESH_PROXY_SERVICE == mesh_client_curr_dis_uuid)
                    {
                        serv_start_hndl = mesh_cli_env[0].proxy_start_hdl;
                        serv_end_hndl   = mesh_cli_env[0].proxy_end_hdl;
                    }
                    else
                    {
                        MESH_CLIENT_TRC( "Mesh Services not Present\r\n");
                    }

                    /* Start Charactertistic Discovery */
                    ret = GATT_DiscAllChars
                          (
                              mesh_cli_env[0].conidx,
                              serv_start_hndl,
                              serv_end_hndl,
                              bleMesh_TaskID
                          );

                    MESH_CLIENT_TRC(
                    "Disc Characteristics btw Handles 0x%04X :: 0x%04X"
                    "returned with retval 0x%04X\r\n",
                    serv_start_hndl, serv_end_hndl, ret);
                }
                else
                {
                    if (pMsg->msg.findByTypeValueRsp.numInfo > 0)
                    {
                        MESH_CLIENT_TRC(
                        "\nServices found :%d\n",
                        pMsg->msg.findByTypeValueRsp.numInfo);

                        MESH_CLIENT_TRC(
                        "Service Handles are 0x%04X :: 0x%04X",
                        pMsg->msg.findByTypeValueRsp.handlesInfo[0].handle,
                        pMsg->msg.findByTypeValueRsp.handlesInfo[0].grpEndHandle);
                        if (mesh_client_curr_dis_uuid == UUID_MESH_PROVISIONING_SERVICE)
                        {
                            mesh_cli_env[0].prov_start_hdl   = pMsg->msg.findByTypeValueRsp.handlesInfo[0].handle;
                            mesh_cli_env[0].prov_end_hdl     = pMsg->msg.findByTypeValueRsp.handlesInfo[0].grpEndHandle;
                            MESH_CLIENT_TRC(
                            "\r\n Prov Service Start Handle is 0x%04X\r\n",
                            mesh_cli_env[0].prov_start_hdl);
                            MESH_CLIENT_TRC(
                            "\r\n Prov Service End Handle is 0x%04X\r\n",
                            mesh_cli_env[0].prov_end_hdl);

                        }
                        else if (mesh_client_curr_dis_uuid == UUID_MESH_PROXY_SERVICE)
                        {
                            mesh_cli_env[0].proxy_start_hdl   = pMsg->msg.findByTypeValueRsp.handlesInfo[0].handle;
                            mesh_cli_env[0].proxy_end_hdl     = pMsg->msg.findByTypeValueRsp.handlesInfo[0].grpEndHandle;

                            MESH_CLIENT_TRC(
                            "\r\nProxy Service Start Handle is 0x%04X\r\n",
                            mesh_cli_env[0].proxy_start_hdl);
                            MESH_CLIENT_TRC(
                            "\r\nProxy Service End Handle is 0x%04X\r\n",
                            mesh_cli_env[0].proxy_end_hdl);
                        }
                    }
                    else
                    {
                        MESH_CLIENT_TRC("\n No Services Found!\n");

                        /**
                         * TODO: Provide Discovery completion Callback.
                         */
                    }
                }
            }
            break;

        case ATT_READ_BY_TYPE_RSP:
            {
                if (bleProcedureComplete == pMsg->hdr.status)
                {
                    uint16_t t_char_start_hndl;

                    if (UUID_MESH_PROVISIONING_SERVICE == mesh_client_curr_dis_uuid)
                    {
                        t_char_start_hndl = mesh_cli_env[0].prov_data_out_hdl;
                        serv_end_hndl     = mesh_cli_env[0].prov_end_hdl;
                    }
                    else if (UUID_MESH_PROXY_SERVICE == mesh_client_curr_dis_uuid)
                    {
                        t_char_start_hndl = mesh_cli_env[0].proxy_data_out_hdl;
                        serv_end_hndl   = mesh_cli_env[0].proxy_end_hdl;
                    }

                    ret = GATT_DiscAllCharDescs
                          (
                              mesh_cli_env[0].conidx,
                              t_char_start_hndl,
                              serv_end_hndl,
                              bleMesh_TaskID
                          );

                    MESH_CLIENT_TRC(
                    "Disc Char Desc btw Handles 0x%04X :: 0x%04X"
                    "returned with retval 0x%04X\r\n",
                    t_char_start_hndl, serv_end_hndl, ret);
                }
                else
                {
                    // Pointer to the pair list data in the GATT response.
                    uint8_t   *pCharPairList;
                    // Will store the start and end handles of the current pair.
                    uint16_t  charStartHandle;
                    // Stores to the UUID of the current pair.
                    uint16_t  charUuid;
                    // Stores what pair the loop is currently processing.
                    uint8_t   currentCharIndex;

                    // Set the pair pointer to the first pair.
                    pCharPairList = pMsg->msg.readByTypeRsp.dataList;

                    // Iterate through all three pairs found.
                    for(currentCharIndex = 0; currentCharIndex < pMsg->msg.readByTypeRsp.numPairs ; currentCharIndex++)
                    {
                      /* uint16_t* p_chars_hdl = pservie->chars_hdl; */

                      // Extract the starting handle, ending handle, and UUID of the current characteristic.
                      charStartHandle = BUILD_UINT16(pCharPairList[3], pCharPairList[4]);
                      charUuid        = BUILD_UINT16(pCharPairList[5], pCharPairList[6]);
                      MESH_CLIENT_TRC(
                      "Chars found handle is %d, uuid is %x\n",
                      charStartHandle, charUuid);

                      switch (charUuid)
                      {
                          /* "Mesh Provisioning Data IN" */
                          case UUID_MESH_PROVISIONING_DATA_IN:
                              mesh_cli_env[0].prov_data_in_hdl = charStartHandle;
                              break;
                          /* "Mesh Provisioning Data OUT" */
                          case UUID_MESH_PROVISIONING_DATA_OUT:
                              mesh_cli_env[0].prov_data_out_hdl = charStartHandle;
                              mesh_cli_env[0].prov_data_out_cccd_hdl = charStartHandle + 1;
                              break;
                          /* "Mesh Proxy Data IN" */
                          case UUID_MESH_PROXY_DATA_IN:
                              mesh_cli_env[0].proxy_data_in_hdl = charStartHandle;
                              break;
                          /* "Mesh Proxy Data OUT" */
                          case UUID_MESH_PROXY_DATA_OUT:
                              mesh_cli_env[0].proxy_data_out_hdl = charStartHandle;
                              mesh_cli_env[0].proxy_data_out_cccd_hdl = charStartHandle + 1;
                              break;
                      }

                      // Increment the pair pointer to the next pair.
                      pCharPairList += 5 + 2;
                    }
                }
            }
            break;

        case ATT_FIND_INFO_RSP:
            {
                if (bleProcedureComplete == pMsg->hdr.status)
                {
                    /**
                     * TODO: Provide Discovery completion Callback.
                     */
                }
                else
                {
                    if ( (pMsg->msg.findInfoRsp.numInfo > 0) &&
                      (pMsg->msg.findInfoRsp.format == ATT_HANDLE_BT_UUID_TYPE) )
                    {
                        // This will keep track of the current pair being processed.
                        uint8_t currentPair;

                        // Iterate through the pair list.
                        for(currentPair = 0; currentPair < pMsg->msg.findInfoRsp.numInfo; currentPair++)
                        {
                            // Check if the pair is a CCCD.
                            uint16_t uuid = BUILD_UINT16(pMsg->msg.findInfoRsp.info.btPair[currentPair].uuid[0], pMsg->msg.findInfoRsp.info.btPair[currentPair].uuid[1]);
                            if (uuid == GATT_CLIENT_CHAR_CFG_UUID)
                            {
                                MESH_CLIENT_TRC(
                                "CCCD is found at handle 0x%X for Mode %d\n",
                                pMsg->msg.findInfoRsp.info.btPair[currentPair].handle, blebrr_gatt_mode_get());
                                if (BLEBRR_GATT_PROV_MODE == blebrr_gatt_mode_get())
                                {
                                    mesh_cli_env[0].prov_data_out_cccd_hdl = pMsg->msg.findInfoRsp.info.btPair[currentPair].handle;
                                }
                                else
                                {
                                    mesh_cli_env[0].proxy_data_out_cccd_hdl = pMsg->msg.findInfoRsp.info.btPair[currentPair].handle;
                                }
                            }
                        }
                     }
                }
            }
            break;

        case ATT_HANDLE_VALUE_NOTI:
            {
                uint16_t notifHandle = pMsg->msg.handleValueNoti.handle;

                if (pMsg->msg.handleValueNoti.len > 0)
                {
                    /* Check the Attribute Handle:
                     * - If Provisioning Data Out Handle: then call the Prov Callback
                     * - If Proxy Data Out Handle: the ncall the Proxy Callback
                     */
                    if (mesh_cli_env[0].prov_data_out_hdl == notifHandle)
                    {
                        if (NULL != prov_cli_cb)
                        {
                            prov_cli_cb->mesh_prov_data_out_notif
                            (
                                mesh_cli_env[0].conidx,
                                pMsg->msg.handleValueNoti.len,
                                pMsg->msg.handleValueNoti.value
                            );
                        }
                    }
                    else if (mesh_cli_env[0].proxy_data_out_hdl == notifHandle)
                    {
                        if (NULL != proxy_cli_cb)
                        {
                            proxy_cli_cb->mesh_proxy_data_out_notif
                            (
                                mesh_cli_env[0].conidx,
                                pMsg->msg.handleValueNoti.len,
                                pMsg->msg.handleValueNoti.value
                            );
                        }
                    }
                }
            }
            break;

        case ATT_WRITE_RSP:
            {
                if (BLEBRR_GATT_PROV_MODE == mesh_cli_env[0].curr_notif_mode)
                {
                    /* Call the Prov CCCD ntf complete Callback */
                    if (NULL != prov_cli_cb)
                    {
                        prov_cli_cb->mesh_prov_ntf_status
                        (
                            mesh_cli_env[0].conidx,
                            mesh_cli_env[0].curr_notif_state,
                            0x00
                        );
                    }
                }
                else if (BLEBRR_GATT_PROXY_MODE == mesh_cli_env[0].curr_notif_mode)
                {
                    /* Call the Proxy CCCD ntf complete Callback */
                    if (NULL != proxy_cli_cb)
                    {
                        proxy_cli_cb->mesh_proxy_ntf_status
                        (
                            mesh_cli_env[0].conidx,
                            mesh_cli_env[0].curr_notif_state,
                            0x00
                        );
                    }
                }
                else
                {
                    /* DO Nothing ! */
                }
            }
            break;

        case ATT_ERROR_RSP:
            {
                attErrorRsp_t* perr = &(pMsg->msg.errorRsp);
                MESH_CLIENT_TRC(
                "\nATT_ERROR_RSP 0x%x, 0x%x, 0x%x\n",
                perr->errCode, perr->handle, perr->reqOpcode);
            }
            break;

        default:
            break;
    }

    (void)ret;
}