C++ : Is it possible to pass a pointer of coroutine object to another function inside the coroutine itself?

Question

In case my phrasing wasn't clear, here's the code.

struct token {};

struct resumable {
    struct promise_type {
        auto get_return_object() {
            return coroutine_handle<promise_type>::from_promise(*this);
        }
        suspend_never initial_suspend() { return {}; }
        suspend_always final_suspend() { return {}; }

        auto await_transform(token)
        {
            struct awaiter {
                awaiter(promise_type& p) : m_promise(p) {}
                bool await_ready() { return false; }
                void await_suspend(coroutine_handle<>) {}
                int await_resume() {
                    int _result = 5;
                    return _result;
                }
                promise_type& m_promise;
            };
            return awaiter(*this);
        }
    };

    bool resume() {
        if (!m_handle.done()) {
            m_handle.resume();
        }
        return !m_handle.done();
    }

    resumable(coroutine_handle<promise_type> h) : m_handle(h) {}

private:
    coroutine_handle<promise_type> m_handle;
};

void someAsyncKernelApi(void* callbackContext)
{
    // When async work is done, enqueues callbackContext into the completion queue.
}

token WrappedAsyncKernelApi(void* callbackContext)
{
    someAsyncKernelApi(callbackContext);
    return token{};
}

resumable coro()
{
    int _async_result = co_await WrappedAsyncKernelApi(/* Is it possible to pass address of this own 
                                                          spawned coroutine to get called later on? 
                                                          Same address the pointer "r_ptr" at main 
                                                          is pointing to*/);
}

int main()
{
    resumable* r_ptr = new auto(coro());
}

Few solutions I can think of right now are either initial suspend when the coroutine is spawned and store the pointer in an arbitrary struct and pass from that stored struct, or awaiting a resumable pointer on first await. But I feel like there's much cleaner way to do this.. Is there any?