Implemented progress indication for erase command

Author: bbogush

firmware/nand_programmer.c

@@ -134,7 +134,8 @@ enum
     NP_STATUS_ERROR     = 0x01,
     NP_STATUS_BB        = 0x02,
     NP_STATUS_WRITE_ACK = 0x03,
-    NP_STATUS_BB_SKIP   = 0x04, 
+    NP_STATUS_BB_SKIP   = 0x04,
+    NP_STATUS_PROGRESS  = 0x05,
 };
 
 typedef struct __attribute__((__packed__))
@@ -162,6 +163,12 @@ typedef struct __attribute__((__packed__))
     uint8_t err_code;
 } np_resp_err_t;
 
+typedef struct __attribute__((__packed__))
+{
+    np_resp_t header;
+    uint32_t progress;
+} np_resp_progress_t;
+
 typedef struct __attribute__((__packed__))
 {
     uint8_t major;
@@ -250,6 +257,17 @@ static int np_send_bad_block_info(uint32_t addr, uint32_t size, bool is_skipped)
     return 0;
 }
 
+static int np_send_progress(uint32_t progress)
+{
+    np_resp_t resp_header = { NP_RESP_STATUS, NP_STATUS_PROGRESS };
+    np_resp_progress_t resp_progress = { resp_header, progress };
+
+    if (np_comm_cb->send((uint8_t *)&resp_progress, sizeof(resp_progress)))
+        return -1;
+
+    return 0;
+}
+
 static int _np_cmd_nand_read_id(np_prog_t *prog)
 {
     np_resp_id_t resp;
@@ -379,11 +397,11 @@ static int np_nand_erase(np_prog_t *prog, uint32_t page)
 static int _np_cmd_nand_erase(np_prog_t *prog)
 {
     int ret;
-    uint32_t addr, page, pages_in_block, len;
+    uint32_t addr, page, pages_in_block, len, total_len;
     np_erase_cmd_t *erase_cmd = (np_erase_cmd_t *)prog->rx_buf;
     bool is_bad = false, skip_bb = erase_cmd->flags.skip_bb;
 
-    len = erase_cmd->len;
+    total_len = len = erase_cmd->len;
     addr = erase_cmd->addr;
 
     DEBUG_PRINT("Erase at 0x%lx %lx bytes command\r\n", addr, len);
@@ -445,6 +463,8 @@ static int _np_cmd_nand_erase(np_prog_t *prog)
         /* On partial erase do not count bad blocks */
         if (!is_bad || (is_bad && erase_cmd->len == prog->chip_info.size))
             len -= prog->chip_info.block_size;
+
+        np_send_progress(total_len - len);
     }
 
     return np_send_ok_status();

qt/cmd.h

@@ -89,6 +89,7 @@ typedef enum
     STATUS_BB        = 0x02,
     STATUS_WRITE_ACK = 0x03,
     STATUS_BB_SKIP   = 0x04,
+    STATUS_PROGRESS  = 0x05,
 } StatusData;
 
 typedef struct __attribute__((__packed__))
@@ -144,5 +145,11 @@ typedef struct __attribute__((__packed__))
     uint8_t errCode;
 } RespError;
 
+typedef struct __attribute__((__packed__))
+{
+    RespHeader header;
+    uint32_t progress;
+} RespProgress;
+
 #endif // CMD_H
 

qt/main_window.cpp

@@ -253,11 +253,25 @@ void MainWindow::slotProgReadDeviceId()
 
 void MainWindow::slotProgEraseCompleted(int status)
 {
+    disconnect(prog, SIGNAL(eraseChipProgress(unsigned int)), this,
+        SLOT(slotProgEraseProgress(unsigned int)));
     disconnect(prog, SIGNAL(eraseChipCompleted(int)), this,
         SLOT(slotProgEraseCompleted(int)));
 
     if (!status)
         qInfo() << "Chip has been erased successfully";
+
+    setProgress(100);
+}
+
+void MainWindow::slotProgEraseProgress(unsigned int progress)
+{
+    uint32_t progressPercent;
+    int index = ui->chipSelectComboBox->currentIndex();
+    uint32_t eraseSize = chipDb.sizeGetById(CHIP_INDEX2ID(index));
+
+    progressPercent = progress * 100ULL / eraseSize;
+    setProgress(progressPercent);
 }
 
 void MainWindow::slotProgErase()
@@ -273,8 +287,12 @@ void MainWindow::slotProgErase()
 
     qInfo() << "Erasing chip ...";
 
+    setProgress(0);
+
     connect(prog, SIGNAL(eraseChipCompleted(int)), this,
         SLOT(slotProgEraseCompleted(int)));
+    connect(prog, SIGNAL(eraseChipProgress(unsigned int)), this,
+        SLOT(slotProgEraseProgress(unsigned int)));
 
     prog->eraseChip(START_ADDRESS, eraseSize);
 }
@@ -470,3 +488,8 @@ void MainWindow::slotAboutDialog()
 
     aboutDialog.exec();
 }
+
+void MainWindow::setProgress(unsigned int progress)
+{
+    statusBar()->showMessage(tr("Progress: %1%").arg(progress));
+}

qt/main_window.h

@@ -36,13 +36,15 @@ class MainWindow : public QMainWindow
     void setUiStateConnected(bool isConnected);
     void setUiStateSelected(bool isSelected);
     void updateChipList();
+    void setProgress(unsigned int progress);
 
 private slots:
     void slotProgConnectCompleted(int status);
     void slotProgReadDeviceIdCompleted(int status);
     void slotProgReadCompleted(int status);
     void slotProgWriteCompleted(int status);
     void slotProgEraseCompleted(int status);
+    void slotProgEraseProgress(unsigned int progress);
     void slotProgReadBadBlocksCompleted(int status);
     void slotProgSelectCompleted(int status);
 

qt/programmer.cpp

@@ -155,17 +155,26 @@ void Programmer::readChipId(ChipId *chipId)
 
 void Programmer::eraseChipCb(int ret)
 {
+    QObject::disconnect(&reader, SIGNAL(progress(unsigned int)), this,
+        SLOT(eraseProgressChipCb(unsigned int)));
     QObject::disconnect(&reader, SIGNAL(result(int)), this,
         SLOT(eraseChipCb(int)));
     emit eraseChipCompleted(ret);
 }
 
+void Programmer::eraseProgressChipCb(unsigned int progress)
+{
+    emit eraseChipProgress(progress);
+}
+
 void Programmer::eraseChip(uint32_t addr, uint32_t len)
 {
     EraseCmd eraseCmd;
 
     QObject::connect(&reader, SIGNAL(result(int)), this,
         SLOT(eraseChipCb(int)));
+    QObject::connect(&reader, SIGNAL(progress(unsigned int)), this,
+        SLOT(eraseProgressChipCb(unsigned int)));
 
     eraseCmd.cmd.code = CMD_NAND_ERASE;
     eraseCmd.addr = addr;

qt/programmer.h

@@ -59,6 +59,7 @@ class Programmer : public QObject
     void writeChipCompleted(int ret);
     void readChipCompleted(int ret);
     void eraseChipCompleted(int ret);
+    void eraseChipProgress(unsigned int progress);
     void readChipBadBlocksCompleted(int ret);
     void confChipCompleted(int ret);
 
@@ -67,6 +68,7 @@ private slots:
     void writeCb(int ret);
     void readCb(int ret);
     void eraseChipCb(int ret);
+    void eraseProgressChipCb(unsigned int progress);
     void readChipBadBlocksCb(int ret);
     void confChipCb(int ret);
     void logCb(QtMsgType msgType, QString msg);

qt/reader.cpp

@@ -114,6 +114,19 @@ int Reader::handleError(uint8_t *pbuf, uint32_t len)
     return -1;
 }
 
+int Reader::handleProgress(uint8_t *pbuf, uint32_t len)
+{
+    RespProgress *resp = reinterpret_cast<RespProgress *>(pbuf);
+    size_t size = sizeof(RespProgress);
+
+    if (len < size)
+        return 0;
+
+    emit progress(resp->progress);
+
+    return static_cast<int>(size);
+}
+
 int Reader::handleStatus(uint8_t *pbuf, uint32_t len)
 {
     RespHeader *header = reinterpret_cast<RespHeader *>(pbuf);
@@ -126,6 +139,8 @@ int Reader::handleStatus(uint8_t *pbuf, uint32_t len)
         return handleBadBlock(pbuf, len, false);
     case STATUS_BB_SKIP:
         return handleBadBlock(pbuf, len, true);
+    case STATUS_PROGRESS:
+        return handleProgress(pbuf, len);
     case STATUS_OK:
         // Exit read loop
         if (!rlen)

qt/reader.h

@@ -31,6 +31,7 @@ class Reader : public QThread
     int readStart();
     int read(uint8_t *pbuf, uint32_t len);
     int handleError(uint8_t *pbuf, uint32_t len);
+    int handleProgress(uint8_t *pbuf, uint32_t len);
     int handleBadBlock(uint8_t *pbuf, uint32_t len, bool isSkipped);
     int handleStatus(uint8_t *pbuf, uint32_t len);
     int handleData(uint8_t *pbuf, uint32_t len);
@@ -47,6 +48,7 @@ class Reader : public QThread
         bool isReadLess);
 signals:
     void result(int ret);
+    void progress(unsigned int progress);
     void log(QtMsgType msgType, QString msg);
 };