Subversion Repositories riscv_vhdl

/*

 *  Copyright 2018 Sergey Khabarov, sergeykhbr@gmail.com

 *

 *  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.

 */

#include "api_types.h"

#include "api_core.h"

#include "attribute.h"

#include "comport.h"

#include <winspool.h>

#include <cstdlib>

namespace debugger {

void ComPortService::getListOfPorts(AttributeType *list) {

    list->make_list(0);

    AttributeType portInfo;

    DWORD  Ports_MemSize = 0;

    DWORD  Ports_Count   = 0;

    BYTE*  lpPorts       = NULL;

    //Getting Ports_MemSize value...

    EnumPorts(NULL,

              1,

              lpPorts,

              0,

              &Ports_MemSize,

              &Ports_Count);

    //Getting lpPorts...

    lpPorts = new BYTE[Ports_MemSize];

    EnumPorts(NULL,

              1,

              lpPorts,

              Ports_MemSize,

              &Ports_MemSize,

              &Ports_Count);

    //Forming List Of Ports...

    DWORD dw;

    char temp[4] = {0};

    int port = -1;

    PORT_INFO_1 *pPortInfo;

    pPortInfo = (PORT_INFO_1 *)lpPorts;

    char comName[16];

    char chCom[20];

    size_t szComLen;

    for (dw = 0; dw < Ports_Count; dw++) {

        if (strstr(pPortInfo->pName, "com") == 0) {

            continue;

        }

        temp[0] = pPortInfo->pName[3];

                if (pPortInfo->pName[4] != ':' && pPortInfo->pName[4] != '\0') {

                        temp[1] = pPortInfo->pName[4];

        }

        if (pPortInfo->pName[5] != ':' && pPortInfo->pName[5] != '\0') {

                    temp[2] = pPortInfo->pName[5];

        }

                port = strtoul(temp, NULL, 0);;

        szComLen = RISCV_sprintf(chCom, sizeof(chCom),

                                 "\\\\.\\COM%d", port) + 1;

                HANDLE h = CreateFile(chCom, GENERIC_READ | GENERIC_WRITE,

                              0, NULL, OPEN_EXISTING,

                              FILE_ATTRIBUTE_NORMAL,NULL);

                if (h == INVALID_HANDLE_VALUE) {

            pPortInfo++;

                    continue;

                }

        portInfo.make_dict();

        RISCV_sprintf(comName, sizeof(comName), "'COM%d'", port);

        portInfo["id"].make_string(comName);

                list->add_to_list(&portInfo);

        CloseHandle(h);

        pPortInfo++;

    }

    delete [] lpPorts;

}

int ComPortService::openPort(const char *port, AttributeType settings) {

    char chCom[20];

    char chConfig[64];

    HANDLE hFile;

    COMMPROP CommProp;

    DCB dcb;

    COMMTIMEOUTS CommTimeOuts;

    DWORD dwStoredFlags;

    DWORD  Errors;

    COMSTAT  Stat;

    RISCV_sprintf(chCom, sizeof(chCom), "\\\\.\\%s", port);

    RISCV_sprintf(chConfig, sizeof(chConfig),

                  "baud=%d parity=N data=8 stop=1", settings[0u].to_int());

    hFile = CreateFile(chCom,

                        GENERIC_READ|GENERIC_WRITE,

                        0,//FILE_SHARE_READ|FILE_SHARE_WRITE,

                        NULL,

                            //OPEN_ALWAYS,

                        OPEN_EXISTING,

                        FILE_ATTRIBUTE_NORMAL,

                        NULL);

    prtHandler_ = hFile;

    if (hFile == INVALID_HANDLE_VALUE) {

        if (GetLastError() == ERROR_ACCESS_DENIED) {

            RISCV_error("%s is locked by another device", chCom);

        } else {

            RISCV_error("Can't open port %s", chCom);

        }

            return -1;

    }

    // Read capabilities:

    GetCommProperties(hFile, &CommProp);

    FillMemory(&dcb, sizeof(dcb), 0);

    dcb.DCBlength = sizeof(dcb);

    if (!BuildCommDCB(chConfig, &dcb)) {

        RISCV_error("Can't BuildCommDCB(%s,)", chConfig);

        CloseHandle(hFile);

        return -1;

    }

    dcb.fDtrControl = DTR_CONTROL_ENABLE;

    dcb.fRtsControl = RTS_CONTROL_ENABLE;

    Sleep(100);

    if (!SetCommState(hFile, &dcb)) {

        RISCV_error("Can't set port %s state", chCom);

        CloseHandle(hFile);

        return -1;

    }

#if 0

    /** ...A value of MAXDWORD , combined with zero values for both

     * the ReadTotalTimeoutConstant and ReadTotalTimeoutMultiplier members,

     * specifies that the read operation is to return immediately with the

     * characters that have already been received, even if no characters

     * have been received...

     **/

    CommTimeOuts.ReadIntervalTimeout             = MAXDWORD;

    CommTimeOuts.ReadTotalTimeoutMultiplier  = 0;

    CommTimeOuts.ReadTotalTimeoutConstant    = 0;

    CommTimeOuts.WriteTotalTimeoutMultiplier = 0;

    CommTimeOuts.WriteTotalTimeoutConstant   = 0;

#else

    CommTimeOuts.ReadIntervalTimeout             = MAXDWORD;

    CommTimeOuts.ReadTotalTimeoutMultiplier  = MAXDWORD;//0;

    CommTimeOuts.ReadTotalTimeoutConstant    = 100;

    CommTimeOuts.WriteTotalTimeoutMultiplier = 0;

    CommTimeOuts.WriteTotalTimeoutConstant   = 0;//1000;

#endif

    if(!SetCommTimeouts(hFile, &CommTimeOuts)) {

        RISCV_error("Can't set port %s timeouts", chCom);

        CloseHandle(hFile);

        return -1;

    }

    dwStoredFlags = EV_BREAK | EV_CTS  | EV_DSR | EV_ERR | EV_RING |

                EV_RLSD | EV_RXCHAR | EV_RXFLAG | EV_TXEMPTY;

    if(!SetCommMask(hFile, dwStoredFlags)) {

        RISCV_error("Can't set mask %s", chCom);

        CloseHandle(hFile);

        return -1;

    }

    RISCV_info("Serial port %s opened", chCom);

    RISCV_sleep_ms(100);

    ClearCommError(hFile, &Errors, &Stat);

    PurgeComm(hFile, PURGE_RXCLEAR | PURGE_TXCLEAR);

    PurgeComm(hFile, PURGE_RXABORT | PURGE_TXABORT);

    return 0;

}

void ComPortService::closePort() {

    if (prtHandler_) {

        CloseHandle(*static_cast<HANDLE *>(prtHandler_));

    }

    prtHandler_ = 0;

}

int ComPortService::readSerialPort(void *hdl, char *buf, int bufsz) {

    HANDLE hFile = *static_cast<HANDLE *>(hdl);

    DWORD dwBytesRead;

    BOOL success = ReadFile(hFile, buf, bufsz, &dwBytesRead, NULL);

    if (!success) {

        return -1;

    }

    buf[dwBytesRead] = 0;

    return static_cast<int>(dwBytesRead);

}

int ComPortService::writeSerialPort(void *hdl, char *buf, int bufsz) {

    DWORD lpdwBytesWrittens;

    WriteFile(*static_cast<HANDLE *>(hdl),

                buf, bufsz, &lpdwBytesWrittens, NULL);

    return (int)lpdwBytesWrittens;

}

void ComPortService::cleanSerialPort(void *hdl) {

    PurgeComm(*static_cast<HANDLE *>(hdl), PURGE_TXCLEAR|PURGE_RXCLEAR);

}

}  // namespace debugger