qt: Erase operation refactored to use read thread

Author: bbogush

qt/main_window.cpp

@@ -175,18 +175,24 @@ void MainWindow::slotProgReadDeviceId()
     prog->readChipId(&chipId);
 }
 
-void MainWindow::eraseChipCb()
+void MainWindow::slotProgEraseCompleted(int status)
 {
-    qInfo() << "Chip has been erased successfully";
+    disconnect(prog, SIGNAL(eraseChipCompleted(int)), this,
+        SLOT(slotProgEraseCompleted(int)));
+
+    if (!status)
+        qInfo() << "Chip has been erased successfully";
 }
 
 void MainWindow::slotProgErase()
 {
     QByteArray ba = ui->chipSelectComboBox->currentText().toLatin1();
     ChipInfo *chipInfo = chipInfoGetByName(ba.data());
 
-    prog->eraseChip(std::bind(&MainWindow::eraseChipCb, this), START_ADDRESS,
-        chipInfo->size);
+    connect(prog, SIGNAL(eraseChipCompleted(int)), this,
+        SLOT(slotProgEraseCompleted(int)));
+
+    prog->eraseChip(START_ADDRESS, chipInfo->size);
 }
 
 void MainWindow::slotProgReadCompleted(int status)

qt/main_window.h

@@ -44,6 +44,7 @@ private slots:
     void slotProgReadDeviceIdCompleted(int status);
     void slotProgReadCompleted(int status);
     void slotProgWriteCompleted(int status);
+    void slotProgEraseCompleted(int status);
 
 public slots:
     void slotFileOpen();

qt/programmer.cpp

@@ -141,77 +141,29 @@ void Programmer::readChipId(ChipId *chipId)
     reader.start();
 }
 
-int Programmer::handleBadBlock(QByteArray *data, uint32_t offset)
+void Programmer::eraseChipCb(int ret)
 {
-    RespBadBlock *badBlock;
-    uint size = data->size();
-    uint bytes_left = size - offset;
-
-    if (bytes_left < sizeof(RespBadBlock))
-    {
-        qCritical() << "Header size of bad block response is wrong:"
-            << bytes_left;
-        return -1;
-    }
-
-    badBlock = (RespBadBlock *)(data->data() + offset);
-    qInfo() << QString("Bad block at 0x%1").arg(badBlock->addr, 8,
-        16, QLatin1Char( '0' ));
-
-    return 0;
-}
-
-void Programmer::readRespEraseChipCb(int status)
-{
-    RespHeader *header;
-
-    if (status == SerialPortReader::READ_ERROR)
-        return;
-
-    while (readData.size())
-    {
-        if (readRespHeader(&readData, 0, header))
-            return;
-        switch (header->code)
-        {
-        case RESP_STATUS:
-            if (header->info == STATUS_OK)
-                eraseChipCb();
-            else if (header->info == STATUS_BAD_BLOCK)
-            {
-                if (!handleBadBlock(&readData, 0))
-                {
-                    readData.remove(0, sizeof(RespBadBlock));
-                    continue;
-                }
-            }
-            else
-                qCritical() << "Programmer error: failed to erase chip";
-            break;
-        default:
-            handleWrongResp(header->code);
-            break;
-        }
-        readData.clear();
-    }
+    QObject::disconnect(&reader, SIGNAL(result(int)), this,
+        SLOT(eraseChipCb(int)));
+    serialPortConnect();
+    emit eraseChipCompleted(ret);
 }
 
-void Programmer::eraseChip(std::function<void(void)> callback, uint32_t addr,
-    uint32_t len)
+void Programmer::eraseChip(uint32_t addr, uint32_t len)
 {
     Cmd cmd = { .code = CMD_NAND_ERASE };
     EraseCmd eraseCmd = { .cmd = cmd, .addr = addr, .len = len };
 
-    readData.clear();
-    serialPortReader->read(std::bind(&Programmer::readRespEraseChipCb, this,
-        std::placeholders::_1), &readData, ERASE_TIMEOUT_MS,
-        sizeof(RespHeader));
+    QObject::connect(&reader, SIGNAL(result(int)), this,
+        SLOT(eraseChipCb(int)));
 
-    eraseChipCb = callback;
+    /* Serial port object cannot be used in other thread */
+    serialPortDisconnect();
     writeData.clear();
     writeData.append((const char *)&eraseCmd, sizeof(eraseCmd));
-    serialPortWriter->write(std::bind(&Programmer::sendCmdCb,
-        this, std::placeholders::_1), &writeData);
+    reader.init(CDC_DEV_NAME, SERIAL_PORT_SPEED, NULL, 0,
+        (uint8_t *)writeData.constData(), writeData.size());
+    reader.start();
 }
 
 void Programmer::readCb(int ret)

qt/programmer.h

@@ -30,7 +30,6 @@ class Programmer : public QObject
     QThread *currThread;
     bool isConn;
     std::function<void(void)> selectChipCb;
-    std::function<void(void)> eraseChipCb;
     uint8_t *readChipBuf;
     uint32_t readChipLen;
     uint8_t *writeChipBuf;
@@ -47,7 +46,6 @@ class Programmer : public QObject
     int readRespHeader(const QByteArray *data, uint32_t offset,
         RespHeader *&header);
     void readRespSelectChipCb(int status);
-    void readRespEraseChipCb(int status);
     int handleStatus(RespHeader *respHead);
     int handleWrongResp(uint8_t code);
     int handleBadBlock(QByteArray *data, uint32_t offset);
@@ -66,8 +64,7 @@ class Programmer : public QObject
     void disconnect();
     bool isConnected();
     void readChipId(ChipId *chipId);
-    void eraseChip(std::function<void(void)> callback, uint32_t addr,
-        uint32_t len);
+    void eraseChip(uint32_t addr, uint32_t len);
     void readChip(uint8_t *buf, uint32_t addr, uint32_t len);
     void writeChip(uint8_t *buf, uint32_t addr, uint32_t len,
         uint32_t pageSize);
@@ -77,11 +74,13 @@ class Programmer : public QObject
     void readChipIdCompleted(int ret);
     void writeChipCompleted(int ret);
     void readChipCompleted(int ret);
+    void eraseChipCompleted(int ret);
 
 private slots:
     void readChipIdCb(int ret);
     void writeCb(int ret);
     void readCb(int ret);
+    void eraseChipCb(int ret);
 };
 
 #endif // PROGRAMMER_H

qt/reader.cpp

@@ -98,7 +98,10 @@ int Reader::handleStatus(uint8_t *pbuf, uint32_t len)
     case STATUS_BAD_BLOCK:
         return handleBadBlock(pbuf, len);
     case STATUS_OK:
-        /* Not expected */
+        // Exit read loop
+        if (!rlen)
+            readOffset = 1;
+        break;
     default:
         qCritical() << "Wrong response header info " << header->info;
         return -1;
@@ -192,8 +195,11 @@ int Reader::readData()
 
         if ((offset = handlePackets(pbuf, len)) < 0)
             return -1;
+
+        if (!readOffset)
+            continue;
     }
-    while (readOffset != this->rlen);
+    while (rlen && rlen != readOffset);
 
     return 0;
 }