src/platform/cc13xx_26xx/chipOBleProfile.c

/*
 *
 *    Copyright (c) 2020 Project CHIP Authors
 *    Copyright (c) 2020 Texas Instruments Incorporated
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *        @file  chipOBLeProfile.c
 *        This file contains the CHIPOBLE profile sample GATT service profile
 *        for use with the BLE Manager.
 */
/*********************************************************************
 * INCLUDES
 */
#include <string.h>

#include <icall.h>
#include <util.h>

#include "icall_ble_api.h"
#include "ti_ble_config.h"

#include "chipOBleProfile.h"

/*********************************************************************
 * GLOBAL VARIABLES
 */
// CHIPoBLE GATT Profile Service UUID
const uint8 chipOBleServUUID[ATT_BT_UUID_SIZE] = {
    // 0xF6, 0xFF
    LO_UINT16(CHIPOBLE_SERV_UUID), HI_UINT16(CHIPOBLE_SERV_UUID)
};

// CHIPoBLE Tx characteristic UUID
const uint8 chipOBleProfileTxCharUUID[ATT_UUID_SIZE] = {
    // 0x12, 0x9D, 0x9F, 0x42, 0x9C, 0x4F, 0x9F, 0x95, 0x59, 0x45, 0x3D, 0x26, 0xF5, 0x2E, 0xEE, 0x18
    CHIPOBLEPROFILE_CHAR_UUID_BASE128(CHIPOBLEPROFILE_TX_CHAR_UUID)
};

// CHIPoBLE Rx characteristic UUID
const uint8 chipOBleProfileRxCharUUID[ATT_UUID_SIZE] = {
    // 0x11, 0x9D, 0x9F, 0x42, 0x9C, 0x4F, 0x9F, 0x95, 0x59, 0x45, 0x3D, 0x26, 0xF5, 0x2E, 0xEE, 0x18
    CHIPOBLEPROFILE_CHAR_UUID_BASE128(CHIPOBLEPROFILE_RX_CHAR_UUID)
};

/*********************************************************************
 * Profile Attributes - variables
 */

// CHIPoBLE GATT Profile Service attribute
static const gattAttrType_t chipoBleProfile = { ATT_BT_UUID_SIZE, chipOBleServUUID };

// CHIPoBLE Tx Characteristic Properties
static uint8_t chipOBleProfileTxCharProps = GATT_PROP_READ | GATT_PROP_INDICATE;

// CHIPoBLE Tx Characteristic Value
static uint8_t chipOBleProfileTxCharVal[CHIPOBLEPROFILE_CHAR_LEN] = { 0x00 };

// CHIPoBLE Tx Characteristic User Description
static uint8_t chipOBleProfileTxdDataUserDesp[CHIPOBLEPROFILE_MAX_DESCRIPTION_LEN] = "ChipOBLE Tx Char";

static gattCharCfg_t * chipOBleProfileTxStateDataConfig;

// CHIPoBLE Rx Characteristic Properties
static uint8_t chipOBleProfileRxCharProps = GATT_PROP_WRITE;

// CHIPoBLE Rx Characteristic Value
static uint8_t chipOBleProfileRxCharVal[CHIPOBLEPROFILE_CHAR_LEN] = { 0x00 };

// CHIPoBLE Rx Characteristic User Description
static uint8_t chipOBleProfileRxdDataUserDesp[CHIPOBLEPROFILE_MAX_DESCRIPTION_LEN] = "ChipOBLE Rx Char";

/*********************************************************************
 * LOCAL VARIABLES
 */

static chipOBleProfileCBs_t * chipOBleProfile_AppCBs = NULL;

/*********************************************************************
 * Profile Attributes - Table
 */

static gattAttribute_t chipoBleProfileAttrTbl[] = {
    // CHIPoBLE Service
    {
        { ATT_BT_UUID_SIZE, primaryServiceUUID }, /* type */
        GATT_PERMIT_READ,                         /* permissions */
        0,                                        /* handle */
        (uint8 *) &chipoBleProfile                /* pValue */
    },
    // CHIPoBLE Tx Characteristic Declaration
    { { ATT_BT_UUID_SIZE, characterUUID }, GATT_PERMIT_READ, 0, &chipOBleProfileTxCharProps },
    // CHIPoBLE Tx Characteristic Value
    { { ATT_UUID_SIZE, chipOBleProfileTxCharUUID }, GATT_PERMIT_READ, 0, chipOBleProfileTxCharVal },

    // CHIPoBLE Tx Characteristic configuration
    { { ATT_BT_UUID_SIZE, clientCharCfgUUID },
      GATT_PERMIT_READ | GATT_PERMIT_WRITE,
      0,
      (uint8 *) &chipOBleProfileTxStateDataConfig },

    // CHIPoBLE Tx Characteristic User Description
    { { ATT_BT_UUID_SIZE, charUserDescUUID }, GATT_PERMIT_READ, 0, chipOBleProfileTxdDataUserDesp },

    // CHIPoBLE Rx Characteristic Declaration
    { { ATT_BT_UUID_SIZE, characterUUID }, GATT_PERMIT_READ, 0, &chipOBleProfileRxCharProps },
    // CHIPoBLE Rx Characteristic Value
    { { ATT_UUID_SIZE, chipOBleProfileRxCharUUID }, GATT_PERMIT_WRITE, 0, chipOBleProfileRxCharVal },

    // CHIPoBLE Rx Characteristic User Description
    { { ATT_BT_UUID_SIZE, charUserDescUUID }, GATT_PERMIT_READ, 0, chipOBleProfileRxdDataUserDesp },
};

/*********************************************************************
 * LOCAL FUNCTIONS
 */
static bStatus_t CHIPoBLEProfile_ReadAttrCB(uint16_t connHandle, gattAttribute_t * pAttr, uint8_t * pValue, uint16_t * pLen,
                                            uint16_t offset, uint16_t maxLen, uint8_t method);
static bStatus_t CHIPoBLEProfile_WriteAttrCB(uint16_t connHandle, gattAttribute_t * pAttr, uint8_t * pValue, uint16_t len,
                                             uint16_t offset, uint8_t method);

/*********************************************************************
 * PROFILE CALLBACKS
 */

// CHIPoBLE Service Callbacks
// Note: When an operation on a characteristic requires authorization and
// pfnAuthorizeAttrCB is not defined for that characteristic's service, the
// Stack will report a status of ATT_ERR_UNLIKELY to the client.  When an
// operation on a characteristic requires authorization the Stack will call
// pfnAuthorizeAttrCB to check a client's authorization prior to calling
// pfnReadAttrCB or pfnWriteAttrCB, so no checks for authorization need to be
// made within these functions.
const gattServiceCBs_t chipOBleProfileCBs = {
    CHIPoBLEProfile_ReadAttrCB,  // Read callback function pointer
    CHIPoBLEProfile_WriteAttrCB, // Write callback function pointer
    NULL                         // Authorization callback function pointer
};

/*********************************************************************
 * PUBLIC FUNCTIONS
 */

/*********************************************************************
 * @fn      CHIPoBLEProfile_AddService
 *
 * @brief   Initializes the Simple Profile service by registering
 *          GATT attributes with the GATT server.
 *
 * @param   services - services to add. This is a bit map and can
 *                     contain more than one service.
 *
 * @return  Success or Failure
 */
bStatus_t CHIPoBLEProfile_AddService(uint32 services)
{
    uint8 status;

    // Allocate Client Characteristic Configuration tables
    chipOBleProfileTxStateDataConfig = (gattCharCfg_t *) ICall_malloc((uint_least16_t) (sizeof(gattCharCfg_t) * MAX_NUM_BLE_CONNS));
    if (chipOBleProfileTxStateDataConfig == NULL)
    {
        return bleMemAllocError;
    }

    // Initialize Client Characteristic Configuration attributes
    GATTServApp_InitCharCfg(LL_CONNHANDLE_INVALID, chipOBleProfileTxStateDataConfig);

    if (services & CHIPOBLEPROFILE_SERVICE)
    {
        // Register GATT attribute list and CBs with GATT Server App
        status = GATTServApp_RegisterService(chipoBleProfileAttrTbl, GATT_NUM_ATTRS(chipoBleProfileAttrTbl),
                                             GATT_MAX_ENCRYPT_KEY_SIZE, &chipOBleProfileCBs);
    }
    else
    {
        status = SUCCESS;
    }

    return status;
}

/*********************************************************************
 * @fn      CHIPoBLEProfile_RegisterAppCBs
 *
 * @brief   Registers the application callback function. Only call
 *          this function once.
 *
 * @param   callbacks - pointer to application callbacks.
 *
 * @return  SUCCESS or bleAlreadyInRequestedMode
 */
bStatus_t CHIPoBLEProfile_RegisterAppCBs(chipOBleProfileCBs_t * appCallbacks)
{
    if (appCallbacks)
    {
        chipOBleProfile_AppCBs = appCallbacks;

        return SUCCESS;
    }
    else
    {
        return bleAlreadyInRequestedMode;
    }
}

/*********************************************************************
 * @fn      CHIPoBLEProfile_SetParameter
 *
 * @brief   Set a CHIPoBLE Characteristic value
 *
 * @param   param - Profile parameter ID
 * @param   len - length of data to write
 * @param   value - pointer to data to write.  This is dependent on
 *          the parameter ID and WILL be cast to the appropriate
 *          data type (example: data type of uint16 will be cast to
 *          uint16 pointer).
 *
 * @return  bStatus_t
 */
extern uint8 gattAppTaskID;
bStatus_t CHIPoBLEProfile_SetParameter(uint8 param, uint8 len, void * value, uint8_t taskId)
{
    bStatus_t ret = SUCCESS;
    switch (param)
    {
    case CHIPOBLEPROFILE_TX_CHAR:

        VOID memcpy(chipOBleProfileTxCharVal, value, len);

        // See if Indications has been enabled
        ret = GATTServApp_ProcessCharCfg(chipOBleProfileTxStateDataConfig, chipOBleProfileTxCharVal, FALSE, chipoBleProfileAttrTbl,
                                         GATT_NUM_ATTRS(chipoBleProfileAttrTbl), taskId, CHIPoBLEProfile_ReadAttrCB);
        break;
    default:
        ret = INVALIDPARAMETER;
        break;
    }

    return ret;
}

/*********************************************************************
 * @fn      CHIPoBLEProfile_GetParameter
 *
 * @brief   Get a CHIPoBLE Characteristic value
 *
 * @param   param - Profile parameter ID
 * @param   value - pointer to data to put.  This is dependent on
 *          the parameter ID and WILL be cast to the appropriate
 *          data type (example: data type of uint16 will be cast to
 *          uint16 pointer).
 *
 * @return  bStatus_t
 */
bStatus_t CHIPoBLEProfile_GetParameter(uint8 param, void * value, uint16_t len)
{
    bStatus_t ret = SUCCESS;
    switch (param)
    {
    case CHIPOBLEPROFILE_RX_CHAR:
        if (len != 0)
        {
            VOID memcpy(value, chipOBleProfileRxCharVal, len);
        }
        else
        {
            VOID memcpy(value, chipOBleProfileRxCharVal, CHIPOBLEPROFILE_CHAR_LEN);
        }
        break;
    case CHIPOBLEPROFILE_CCCWrite:
        *((uint8 *) value) = chipOBleProfileTxStateDataConfig->value;
        break;
    default:
        ret = INVALIDPARAMETER;
        break;
    }

    return ret;
}

/*********************************************************************
 * @fn          CHIPoBLEProfile_ReadAttrCB
 *
 * @brief       Read an attribute.
 *
 * @param       connHandle - connection message was received on
 * @param       pAttr - pointer to attribute
 * @param       pValue - pointer to data to be read
 * @param       pLen - length of data to be read
 * @param       offset - offset of the first octet to be read
 * @param       maxLen - maximum length of data to be read
 * @param       method - type of read message
 *
 * @return      SUCCESS, blePending or Failure
 */
static bStatus_t CHIPoBLEProfile_ReadAttrCB(uint16_t connHandle, gattAttribute_t * pAttr, uint8_t * pValue, uint16_t * pLen,
                                            uint16_t offset, uint16_t maxLen, uint8_t method)
{
    bStatus_t status = SUCCESS;
    uint8 len        = maxLen;

    if (offset + maxLen > CHIPOBLEPROFILE_CHAR_LEN)
        len = CHIPOBLEPROFILE_CHAR_LEN - offset;

    *pLen = len;
    VOID osal_memcpy(pValue, (pAttr->pValue) + offset, len);

    return status;
}

/*********************************************************************
 * @fn      CHIPoBLEProfile_WriteAttrCB
 *
 * @brief   Validate attribute data prior to a write operation
 *
 * @param   connHandle - connection message was received on
 * @param   pAttr - pointer to attribute
 * @param   pValue - pointer to data to be written
 * @param   len - length of data
 * @param   offset - offset of the first octet to be written
 * @param   method - type of write message
 *
 * @return  SUCCESS, blePending or Failure
 */
static bStatus_t CHIPoBLEProfile_WriteAttrCB(uint16_t connHandle, gattAttribute_t * pAttr, uint8_t * pValue, uint16_t len,
                                             uint16_t offset, uint8_t method)
{
    bStatus_t status = SUCCESS;
    uint8 notifyApp  = 0xFF;

    if (pAttr->type.len == ATT_UUID_SIZE)
    {
        if (!memcmp(pAttr->type.uuid, chipOBleProfileRxCharUUID, pAttr->type.len))
        {
            VOID osal_memcpy((pAttr->pValue) + offset, pValue, len);

            // Send notification to BLE Event handler
            notifyApp = CHIPOBLEPROFILE_RX_CHAR;
        }
        else
        {
            status = ATT_ERR_ATTR_NOT_FOUND;
        }
    }

    else if ((pAttr->type.len == ATT_BT_UUID_SIZE) &&
             (BUILD_UINT16(pAttr->type.uuid[0], pAttr->type.uuid[1]) == GATT_CLIENT_CHAR_CFG_UUID))
    {

        notifyApp = CHIPOBLEPROFILE_CCCWrite;

        status = GATTServApp_ProcessCCCWriteReq(connHandle, pAttr, pValue, len, offset, GATT_CLIENT_CFG_INDICATE);
    }
    else
    {
        // unsupported length
        status = ATT_ERR_INVALID_HANDLE;
    }

    // If a characteristic value changed then callback function to notify application of change
    if ((notifyApp != 0xFF) && chipOBleProfile_AppCBs && chipOBleProfile_AppCBs->pfnchipOBleProfileChange)
    {
        chipOBleProfile_AppCBs->pfnchipOBleProfileChange(notifyApp, len, connHandle);
    }

    return status;
}