Using IO completion port for BIDIRECTIONAL data exchange ?

Hello, a while back I asked some question about using IO completion port to
exchange data between threads, and people here kindly helped me a lot
especially Mr.NewCommer that has a valuable essay about this
http://www.flounder.com/iocompletion.htm among other knowledge base essays.

Now that I'm actually getting my feet wet with this and starting writing
codes I find some more questions that I didn't figure it out earlier.
Basically my problem i that I want to send and receive data to a device that
is attached to a USB port, data rate can be as high as 100KB/Sec.
So I created two additional working threads one for read and one for writing.
read thread(Read from device) implement an IO completion routine to send
packages to the main UI processing thread.
This is the reading thread proc function

/****************************************************************************
* UINT ReadFT232Thread(LPVOID pParam)
* Inputs: LPVOID points to STRUCT_DEV_INFO device info structure
* Result: COMM_STATUS cast as UINT
* COMM_OK successful exit
* COMM_INVALID_DEVICE_HANDLE supplied device handle has invalid value
* COMM_NULL_DEVICE_HANDLE supplied device handle is null
* Effect:
* Read FT232 working thread for overlapped reading
****************************************************************************/

UINT ReadFT232Thread(LPVOID pParam)
{
    OVERLAPPED osReader = {0};
    DWORD dwRes;
    bool bWaitingOnRead = 0;
    bool bRun = true;

    CDataMessage* pMsg = NULL;
    STRUCT_DEV_INFO* pDevInfo = (STRUCT_DEV_INFO*) pParam;
    ASSERT(pDevInfo->hDev != NULL);
    if(pDevInfo->hDev == NULL)
        return COMM_NULL_DEVICE_HANDLE;
    if(pDevInfo->hDev == INVALID_HANDLE_VALUE)
        return COMM_INVALID_DEVICE_HANDLE;
    CSingleLock xLock((CCriticalSection*) pDevInfo->pCritical);

    osReader.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    while(bRun)
    {
        if(xLock.Lock(0))//if xCritical was availabe immediately then update bRun
value else continue reading
            bRun = pDevInfo->bRunThread;
        else
            bRun = true;
        if (!bWaitingOnRead)
        {
            pMsg = new CDataMessage(pDevInfo->pWnd,
MESSAGE_OVERLAP_READ_COMPLETED,NULL,NULL);//Derived from _OVERLAPPED struct

            if (!FT_W32_ReadFile(pDevInfo->hDev, &pMsg->m_cBuffer,
MAX_READ_BUFFER_SIZE, &pMsg->m_dwReadCount, pMsg))
            {
                dwRes = FT_W32_GetLastError(pDevInfo->hDev);
                if (dwRes != ERROR_IO_PENDING)
                {
                    dwRes = GetLastError();
                    delete pMsg;
                }
                else
                    bWaitingOnRead = TRUE; //Wait for overlapped read
            }
        }
        else
        {
            dwRes = WaitForSingleObject(osReader.hEvent,100);
            switch(dwRes)
            {
            case WAIT_OBJECT_0:
                bWaitingOnRead = false;
                // Read completed successfully.
                break;
            case WAIT_TIMEOUT:
                break;
            }//switch dwRes
        }//else fWaitingOnRead
    }//while
    CloseHandle(osReader.hEvent);

    return (UINT) COMM_OK;
}

as you see the read thread sends CDataMessage object that had derived from
overlap to completion port and main thread grabs it and process it.

Now in the process of creating IO Completion port I attached it to the
actual USB port handle so each read and write produces a completion packet
which I'm not sure is the right way. because main UI thread only needs IO
completion packets that is generated because of ReadFile activity not
WriteFile.

the Major problem that I'm facing now is how to send data from Main UI
thread to Write working thread. Should I create a separate IO Completion Port
for write operations then I probably should not attach the port handle to
IOCompletionPort. am I going at the right direction?
any help greatly appreciated.
thanks