RTOS/CC2640: Pin Interrupt not working as expected.

1. look into the source code, the PIN_Handle variable is a pointer to the PIN_State, which holds the callback pointer. so those 2 variable must live steadily for the callback to work, . so those 2 variable can not be a function local variable living in stack which will be overwritten when the stack is always changing for calling context switching. otherwise, the program would jump to nowhere and go dead when interrupt calls the callback if the callback has been overwritten pointing to anywhere other than the intended callback. so those 2 variable must live in heap, so global or static.

PIN_Status PIN_registerIntCb(PIN_Handle handle, PIN_IntCb pCb) {
    if (handle) {
        handle->callbackFxn = pCb;
        return PIN_SUCCESS;
    } else {
        return PIN_NO_ACCESS;
    }
}

PIN_Handle PIN_open(PIN_State* state, const PIN_Config pinList[]) {
    uint32_t i;
    bool pinsAllocated;
    uint32_t portMask;
    PIN_Id pinId;

    // Ensure that only one client at a time can call PIN_open() or PIN_add()
    SemaphoreP_pend(&pinSemaphore, SemaphoreP_WAIT_FOREVER);

    // Check whether all pins in pinList are valid and available first
    for (i = 0, pinsAllocated = true, portMask = 0; pinList && (pinId = PIN_ID(pinList[i])) != PIN_TERMINATE; i++) {
        /* Unassigned pins is allowed, but cannot generate a bitmask. */
        if (pinId != PIN_UNASSIGNED) {
            if (pinId > pinUpperBound || pinHandleTable[pinId]) {
                pinsAllocated = false;
                break;
            } else {
                // Generate bitmask for port operations (always one port on CC26xx)
                portMask |= (1 << pinId);
            }
        }
    }

    if (!pinsAllocated) {
        // Indicate that the pins were not allocatable
        state = NULL;
    } else {
        // Setup state object
        state->callbackFxn = NULL;
        state->portMask = 0;
        state->userArg = 0;

        // Configure I/O pins according to pinList
        for (i = 0; pinList && (pinId = PIN_ID(pinList[i])) != PIN_TERMINATE; i++) {
            if (pinId != PIN_UNASSIGNED) {
                pinHandleTable[pinId] = state;
                                                                                                            365,5         58%
                state->portMask |= (1 << pinId);
                PIN_setConfig(state, PIN_BM_ALL, pinList[i]);
            }
        }
    }

    SemaphoreP_post(&pinSemaphore);
    return state;
}

2. The callback is called from HWI context with handle and pin ID as arguments. the callback could just use them, if there's only one interrupt registered for the handle, directly use it, if more pins registered for interrupt for the handle,  swich/case by pinId could be used to do the work.

/** @brief I/O Interrupt callback function pointer type
 *  One PIN Interrupt callback can be registered by each PIN client and it
 *  will be called when one of the pins allocated by the client has an interrupt
 *  event. The callback is called from HWI context with handle and pin ID as
 *  arguments.
 * @remark The callback must, as it runs in HWI context, execute and return
 *         quickly. Any lengthy operations should be performed in SWIs or tasks
 *         triggered by the callback
 */
typedef void (*PIN_IntCb)(PIN_Handle handle, PIN_Id pinId);