qt: changed read command to use async read/write

Author: bbogush

qt/main_window.cpp

@@ -198,34 +198,43 @@ void MainWindow::slotProgErase()
         chipInfo->size);
 }
 
-void MainWindow::slotProgRead()
+void MainWindow::readChipCb(int status)
 {
     uint32_t rowNum = HEADER_ROW_NUM, address = START_ADDRESS;
-    QByteArray ba = ui->chipSelectComboBox->currentText().toLatin1();
-    ChipInfo *chipInfo = getChipInfoByName(ba.data());
-    std::unique_ptr< uint8_t[] > buf = std::unique_ptr< uint8_t[] >
-        (new (std::nothrow) uint8_t[chipInfo->size]);
 
-    if (!buf.get())
+    if (!status)
     {
-        qCritical() << "Failed to allocate momory for read buffer";
-        return;
+        qInfo() << "Data has been successfully read";
+
+        /* Reset buffer table */
+        ui->bufferTableWidget->setRowCount(HEADER_ROW_NUM);
+
+        for (uint32_t i = 0; i < readBufSize; i += ROW_DATA_SIZE)
+        {
+            insertBufferRow(readBuf + i, ROW_DATA_SIZE, rowNum, address);
+            rowNum++;
+            address += ROW_DATA_SIZE;
+        }
     }
 
-    /* Reset buffer table */
-    ui->bufferTableWidget->setRowCount(HEADER_ROW_NUM);
+    delete readBuf;
+}
 
-    if (prog->readChip(buf.get(), START_ADDRESS, chipInfo->size))
-        return;
-    else
-        qInfo() << "Data has been successfully read";
+void MainWindow::slotProgRead()
+{
+    QByteArray ba = ui->chipSelectComboBox->currentText().toLatin1();
+    ChipInfo *chipInfo = getChipInfoByName(ba.data());
 
-    for (uint32_t i = 0; i < chipInfo->size; i += ROW_DATA_SIZE)
+    readBufSize = chipInfo->size;
+    readBuf = new (std::nothrow) uint8_t[readBufSize];
+    if (!readBuf)
     {
-        insertBufferRow(buf.get() + i, ROW_DATA_SIZE, rowNum, address);
-        rowNum++;
-        address += ROW_DATA_SIZE;
+        qCritical() << "Failed to allocate memory for read buffer";
+        return;
     }
+
+    prog->readChip(std::bind(&MainWindow::readChipCb, this,
+        std::placeholders::_1), readBuf, START_ADDRESS, readBufSize);
 }
 
 void MainWindow::slotProgWrite()

qt/main_window.h

@@ -24,12 +24,15 @@ class MainWindow : public QMainWindow
 
 private:
     Ui::MainWindow *ui;
+    uint8_t *readBuf;
+    uint32_t readBufSize;
 
     void insertBufferRow(quint8 *readBuf, quint32 size, quint32 rowNum,
         quint32 address);
     void readChipIdCb(ChipId id);
     void selectChipCb();
     void eraseChipCb();
+    void readChipCb(int status);
 
 public slots:
     void slotFileOpen();

qt/programmer.cpp

@@ -296,84 +296,82 @@ void Programmer::eraseChip(std::function<void(void)> callback, uint32_t addr,
         this, std::placeholders::_1), &writeData);
 }
 
-int Programmer::readChip(uint8_t *buf, uint32_t addr, uint32_t len)
+void Programmer::readRespReadChipCb(int status)
 {
-    int ret;
-    uint8_t rx_buf[CDC_BUF_SIZE];
-    RespHeader *dataResp;
-    RespBadBlock badBlock;
+    uint size;
+    RespHeader *header;
     uint32_t offset = 0;
-    Cmd cmd = { .code = CMD_NAND_READ };
-    ReadCmd readCmd = { .cmd = cmd, .addr = addr, .len = len };
 
-    if (sendCmd(&readCmd.cmd, sizeof(readCmd)))
-        return -1;
+    if (status == SerialPortReader::READ_ERROR)
+        goto Error;
 
-    while (len)
+    while ((size = readData.size()))
     {
-        serialPort.waitForReadyRead(READ_WRITE_TIMEOUT_MS);
-        ret = serialPort.read((char *)rx_buf, sizeof(RespHeader));
-        if (ret < 0)
-        {
-            qCritical() << "Failed to read data " << serialPort.error()
-                << serialPort.errorString();
-            return -1;
-        }
+        if (readRespHeader(&readData, header))
+            goto Error;
 
-        if (ret < (int)sizeof(RespHeader))
-        {
-            qCritical() << "Failed to read response header: data was partially"
-                " received, length: " << ret;
-            return -1;
-        }
-
-        dataResp = (RespHeader *)rx_buf;
-        if (dataResp->code == RESP_STATUS)
+        switch (header->code)
         {
-            if (dataResp->info == STATUS_BAD_BLOCK)
+        case RESP_STATUS:
+            if (header->info == STATUS_OK && header->info == STATUS_BAD_BLOCK)
             {
-                if (readRespBadBlockAddress(&badBlock))
-                    return -1;
-                qInfo() << "Bad block at" << QString("0x%1").
-                    arg(badBlock.addr, 8, 16, QLatin1Char('0'));
+                if (handleBadBlock(&readData))
+                    goto Error;
+                readData.remove(0, sizeof(RespBadBlock));
             }
             else
-                return handleStatus(dataResp);
-        }
-
-        if (dataResp->code == RESP_DATA)
-        {
-            if (dataResp->info > sizeof(rx_buf) - sizeof(RespHeader))
-            {
-                qCritical() << "Programmer returns wrong data length";
-                return -1;
-            }
-
-            serialPort.waitForReadyRead(READ_WRITE_TIMEOUT_MS);
-            ret = serialPort.read((char *)dataResp->data, dataResp->info);
-            if (ret < 0)
             {
-                qCritical() << "Failed to read data " << serialPort.error()
-                    << serialPort.errorString();
-                return -1;
+                qCritical() << "Programmer error: failed to read chip";
+                goto Error;
             }
-
-            if (dataResp->info != ret)
+            break;
+        case RESP_DATA:
+            if (header->info > CDC_BUF_SIZE - sizeof(RespHeader) || header->info > size)
             {
-                qCritical() << "Programmer error: expected to receive " <<
-                    dataResp->info << "but received" << ret << "Bytes";
-                for (int i = 0; i < ret; i++)
-                    qInfo() << dataResp->data[i];
-                return -1;
+                qCritical() << "Wrong data length in response header:" << header->info;
+                goto Error;
             }
-
-            memcpy(buf + offset, dataResp->data, ret);
-            offset += ret;
-            len -= ret;
+            memcpy(readChipBuf + offset, header->data, header->info);
+            offset += header->info;
+            readData.remove(0, sizeof(RespHeader) + header->info);
+           break;
+        default:
+            handleWrongResp(header->code);
+            goto Error;
         }
     }
 
-    return 0;
+    if (readChipLen == offset)
+        readChipCb(0);
+    else
+    {
+        qCritical() << "Data was partialy received, size:" << offset;
+        goto Error;
+    }
+
+    return;
+
+Error:
+    readChipCb(-1);
+}
+
+void Programmer::readChip(std::function<void(int)> callback, uint8_t *buf,
+    uint32_t addr, uint32_t len)
+{
+    Cmd cmd = { .code = CMD_NAND_READ };
+    ReadCmd readCmd = { .cmd = cmd, .addr = addr, .len = len };
+
+    readData.clear();
+    serialPortReader->read(std::bind(&Programmer::readRespReadChipCb, this,
+        std::placeholders::_1), &readData, READ_TIMEOUT_MS);
+
+    readChipCb = callback;
+    readChipBuf = buf;
+    readChipLen = len;
+    writeData.clear();
+    writeData.append((const char *)&readCmd, sizeof(readCmd));
+    serialPortWriter->write(std::bind(&Programmer::sendCmdCb,
+        this, std::placeholders::_1), &writeData);
 }
 
 int Programmer::writeChip(uint8_t *buf, uint32_t addr, uint32_t len)

qt/programmer.h

@@ -119,6 +119,9 @@ class Programmer : public QObject
     std::function<void(ChipId)> readChipIdCb;
     std::function<void(void)> selectChipCb;
     std::function<void(void)> eraseChipCb;
+    std::function<void(int)> readChipCb;
+    uint8_t *readChipBuf;
+    uint32_t readChipLen;
 
     int sendCmd(Cmd *cmd, size_t size);
     void sendCmdCb(int status);
@@ -128,6 +131,7 @@ class Programmer : public QObject
     void readRespChipIdCb(int status);
     void readRespSelectChipCb(int status);
     void readRespEraseChipCb(int status);
+    void readRespReadChipCb(int status);
     int handleStatus(RespHeader *respHead);
     int handleWrongResp(uint8_t code);
     int handleBadBlock(QByteArray *data);
@@ -145,7 +149,8 @@ class Programmer : public QObject
     void readChipId(std::function<void(ChipId)> callback);
     void eraseChip(std::function<void(void)> callback, uint32_t addr,
         uint32_t len);
-    int readChip(uint8_t *buf, uint32_t addr, uint32_t len);
+    void readChip(std::function<void(int)> callback, uint8_t *buf,
+        uint32_t addr, uint32_t len);
     int writeChip(uint8_t *buf, uint32_t addr, uint32_t len);
     void selectChip(std::function<void(void)> callback, uint32_t chipNum);
 };