Implemented send of error codes in error message

bbogush · bbogush · commit e9774f271fff · 2018-10-01T19:34:25.000+03:00
diff --git a/firmware/main.c b/firmware/main.c
@@ -41,6 +41,19 @@ enum
     CMD_NAND_SELECT  = 0x06,
 };
 
+enum
+{
+    ERR_ADDR_EXCEEDED  = 0x00,
+    ERR_ADDR_INVALID   = 0x01,
+    ERR_NAND_WR        = 0x02,
+    ERR_NAND_RD        = 0x03,
+    ERR_NAND_ERASE     = 0x04,
+    ERR_CHIP_NOT_SEL   = 0x05,
+    ERR_CHIP_NOT_FOUND = 0x06,
+    ERR_CMD_DATA_SIZE  = 0x07,
+    ERR_BUF_OVERFLOW   = 0x08,
+};
+
 typedef struct __attribute__((__packed__))
 {
     uint8_t code;
@@ -123,6 +136,12 @@ typedef struct __attribute__((__packed__))
     uint32_t bytes_ack;
 } resp_write_ack_t;
 
+typedef struct __attribute__((__packed__))
+{
+    resp_t header;
+    uint8_t err_code;
+} resp_err_t;
+
 typedef struct
 {
     uint32_t addr;
@@ -221,9 +240,9 @@ static void usb_init(usb_t *usb)
     usb->rx_buf_size = USB_BUF_SIZE;
 }
 
-static int make_status(usb_t *usb, int is_ok)
+static int make_ok_status(usb_t *usb)
 {
-    resp_t status = { RESP_STATUS,  is_ok ? STATUS_OK : STATUS_ERROR };
+    resp_t status = { RESP_STATUS, STATUS_OK };
     size_t len = sizeof(status);
 
     if (len > usb->tx_buf_size)
@@ -238,6 +257,24 @@ static int make_status(usb_t *usb, int is_ok)
     return len;
 }
 
+static int make_error_status(usb_t *usb, uint8_t err_code)
+{
+    resp_t status = { RESP_STATUS, STATUS_ERROR };
+    resp_err_t err_status = { status, err_code };
+    size_t len = sizeof(err_status);
+
+    if (len > usb->tx_buf_size)
+    {
+        ERROR_PRINT("Status size %d is more then TX buffer size %d\r\n", len,
+            usb->tx_buf_size);
+        return -1;
+    }
+
+    memcpy(usb->tx_buf, &err_status, len);
+
+    return len;
+}
+
 static int send_bad_block_info(uint32_t addr)
 {
     resp_t resp_header = { RESP_STATUS, STATUS_BAD_BLOCK };
@@ -262,13 +299,13 @@ static int cmd_nand_read_id(prog_t *prog)
     if (!chip_is_selected())
     {
         ERROR_PRINT("Chip is not selected\r\n");
-        goto Error;
+        return make_error_status(&prog->usb, ERR_CHIP_NOT_SEL);
     }
 
     if (prog->usb.tx_buf_size < resp_len)
     {
         ERROR_PRINT("Response size is more then TX buffer size\r\n");
-        goto Error;
+        return make_error_status(&prog->usb, ERR_BUF_OVERFLOW);
     }
 
     resp.header.code = RESP_DATA;
@@ -278,9 +315,6 @@ static int cmd_nand_read_id(prog_t *prog)
     memcpy(prog->usb.tx_buf, &resp, resp_len);
 
     return resp_len;
-
-Error:
-    return make_status(&prog->usb, 0);
 }
 
 static int nand_erase(uint32_t page, uint32_t addr)
@@ -312,7 +346,7 @@ static int nand_erase(uint32_t page, uint32_t addr)
 static int cmd_nand_erase(prog_t *prog)
 {
     chip_info_t *chip_info;
-    uint32_t addr, page, pages_in_block, ret = -1;
+    uint32_t addr, page, pages_in_block;
     erase_cmd_t *erase_cmd = (erase_cmd_t *)prog->usb.rx_buf;
 
     DEBUG_PRINT("Erase at 0x%lx %lx bytes command\r\n", erase_cmd->addr,
@@ -321,7 +355,7 @@ static int cmd_nand_erase(prog_t *prog)
     if (!chip_is_selected())
     {
         ERROR_PRINT("Chip is not selected\r\n");
-        goto Exit;
+        return make_error_status(&prog->usb, ERR_CHIP_NOT_SEL);
     }
     chip_info = chip_info_selected_get();
 
@@ -337,11 +371,11 @@ static int cmd_nand_erase(prog_t *prog)
         {
             ERROR_PRINT("Erase address 0x%lx is more then chip size 0x%lx\r\n",
                 addr, chip_info->size);
-            goto Exit;
+            return make_error_status(&prog->usb, ERR_ADDR_EXCEEDED);
         }
 
         if (nand_erase(page, addr))
-            goto Exit;
+            return make_error_status(&prog->usb, ERR_NAND_ERASE);
 
         if (erase_cmd->len >= chip_info->block_size)
             erase_cmd->len -= chip_info->block_size;
@@ -351,9 +385,7 @@ static int cmd_nand_erase(prog_t *prog)
         page += pages_in_block;
     }
 
-    ret = 0;
-Exit:
-    return make_status(&prog->usb, !ret);
+    return make_ok_status(&prog->usb);
 }
 
 static int send_write_ack(uint32_t bytes_ack)
@@ -381,7 +413,7 @@ static int cmd_nand_write_start(prog_t *prog)
     {
         ERROR_PRINT("Write address 0x%lx is more then chip size 0x%lx\r\n",
             write_start_cmd->addr, chip_info->size);
-        return -1;
+        return make_error_status(&prog->usb, ERR_ADDR_EXCEEDED);
     }
 
     prog->addr = write_start_cmd->addr;
@@ -394,7 +426,7 @@ static int cmd_nand_write_start(prog_t *prog)
     prog->bytes_written = 0;
     prog->bytes_ack = 0;
 
-    return 0;
+    return make_ok_status(&prog->usb);
 }
 
 static int nand_handle_status(prog_t *prog)
@@ -481,13 +513,13 @@ static int cmd_nand_write_data(prog_t *prog)
         prog->usb.rx_buf_size)
     {
         ERROR_PRINT("Data size is wrong %d\r\n", write_data_cmd->len);
-        return -1;
+        return make_error_status(&prog->usb, ERR_CMD_DATA_SIZE);
     }
 
     if (!prog->addr_is_valid)
     {
         ERROR_PRINT("Write address is not set\r\n");
-        return -1;
+        return make_error_status(&prog->usb, ERR_ADDR_INVALID);
     }
 
     if (prog->page.offset + write_data_cmd->len > chip_info->page_size)
@@ -501,7 +533,7 @@ static int cmd_nand_write_data(prog_t *prog)
     if (prog->page.offset == chip_info->page_size)
     {
         if (nand_write(prog, chip_info))
-            return -1;
+            return make_error_status(&prog->usb, ERR_NAND_WR);
 
         prog->addr += chip_info->page_size;
         if (prog->addr >= chip_info->size)
@@ -537,29 +569,30 @@ static int cmd_nand_write_end(prog_t *prog)
     if (!prog->addr_is_valid)
     {
         ERROR_PRINT("Write address is not set\r\n");
-        return -1;
+        return make_error_status(&prog->usb, ERR_ADDR_INVALID);
     }
 
     prog->addr_is_valid = 0;
 
     if (!prog->page.offset)
-        return 0;
+        goto Exit;
 
     if (nand_write(prog, chip_info))
-        return -1;
+        return make_error_status(&prog->usb, ERR_NAND_WR);
 
-    return 0;
+Exit:
+    return make_ok_status(&prog->usb);
 }
 
 static int cmd_nand_write(prog_t *prog)
 {
     cmd_t *cmd = (cmd_t *)prog->usb.rx_buf;
-    int ret = -1;
+    int ret = 0;
 
     if (!chip_is_selected())
     {
         ERROR_PRINT("Chip is not selected\r\n");
-        goto Exit;
+        return make_error_status(&prog->usb, ERR_CHIP_NOT_SEL);
     }
 
     switch (cmd->code)
@@ -569,8 +602,6 @@ static int cmd_nand_write(prog_t *prog)
         break;
     case CMD_NAND_WRITE_D:
         ret = cmd_nand_write_data(prog);
-        if (!ret)
-            return 0;
         break;
     case CMD_NAND_WRITE_E:
         ret = cmd_nand_write_end(prog);
@@ -579,8 +610,7 @@ static int cmd_nand_write(prog_t *prog)
         break;
     }
 
-Exit:
-    return make_status(&prog->usb, !ret);
+    return ret;
 }
 
 static int nand_read(uint32_t addr, page_t *page, chip_info_t *chip_info)
@@ -626,15 +656,15 @@ static int cmd_nand_read(prog_t *prog)
     if (!chip_is_selected())
     {
         ERROR_PRINT("Chip is not selected\r\n");
-        goto Error;
+        return make_error_status(&prog->usb, ERR_CHIP_NOT_SEL);
     }
     chip_info = chip_info_selected_get();
 
     if (read_cmd->addr >= chip_info->size)
     {
         ERROR_PRINT("Read address 0x%lx is more then chip size 0x%lx\r\n",
             read_cmd->addr, chip_info->size);
-        goto Error;
+        return make_error_status(&prog->usb, ERR_ADDR_EXCEEDED);
     }
 
     addr = read_cmd->addr;
@@ -646,7 +676,7 @@ static int cmd_nand_read(prog_t *prog)
     while (read_cmd->len)
     {
         if (nand_read(addr, &page, chip_info))
-            goto Error;
+            return make_error_status(&prog->usb, ERR_NAND_RD);
 
         while (page.offset < chip_info->page_size && read_cmd->len)
         {
@@ -676,23 +706,19 @@ static int cmd_nand_read(prog_t *prog)
             {
                 ERROR_PRINT("Read address 0x%lx is more then chip size 0x%lx",
                     addr, chip_info->page_size);
-                goto Error;
+                return make_error_status(&prog->usb, ERR_ADDR_EXCEEDED);
             }
             page.page++;
             page.offset = 0;
         }
     }
 
     return 0;
-
-Error:
-    return make_status(&prog->usb, 0);
 }
 
 static int cmd_nand_select(prog_t *prog)
 {
     select_cmd_t *select_cmd = (select_cmd_t *)prog->usb.rx_buf;
-    int ret = 0;
 
     DEBUG_PRINT("Chip select ID %lu command\r\n", select_cmd->chip_num);
 
@@ -701,10 +727,10 @@ static int cmd_nand_select(prog_t *prog)
     else
     {
         ERROR_PRINT("Chip ID %lu not found\r\n", select_cmd->chip_num);
-        ret = -1;
+        return make_error_status(&prog->usb, ERR_CHIP_NOT_FOUND);
     }
 
-    return make_status(&prog->usb, !ret);
+    return make_ok_status(&prog->usb);
 }
 
 static int usb_cmd_handler(prog_t *prog)
@@ -760,7 +786,7 @@ static void nand_handler(prog_t *prog)
     if (prog->nand_wr_in_progress)
     {
         if (nand_handle_status(prog))
-            send_status(prog, make_status(&prog->usb, 0));
+            send_status(prog, make_error_status(&prog->usb, ERR_NAND_WR));
     }
 }
 
diff --git a/qt/cmd.h b/qt/cmd.h
@@ -106,5 +106,11 @@ typedef struct __attribute__((__packed__))
     uint32_t ackBytes;
 } RespWriteAck;
 
+typedef struct __attribute__((__packed__))
+{
+    RespHeader header;
+    uint8_t errCode;
+} RespError;
+
 #endif // CMD_H
 
diff --git a/qt/reader.cpp b/qt/reader.cpp
@@ -85,15 +85,27 @@ int Reader::handleBadBlock(uint8_t *pbuf, uint32_t len)
     return size;
 }
 
+int Reader::handleError(uint8_t *pbuf, uint32_t len)
+{
+    RespError *err = (RespError *)pbuf;
+    size_t size = sizeof(RespError);
+
+    if (len < size)
+        return 0;
+
+    logErr(QString("Programmer sent error: %1").arg(err->errCode));
+
+    return -1;
+}
+
 int Reader::handleStatus(uint8_t *pbuf, uint32_t len)
 {
     RespHeader *header = (RespHeader *)pbuf;
 
     switch (header->info)
     {
     case STATUS_ERROR:
-        logErr("Programmer sent error");
-        return -1;
+        return handleError(pbuf, len);
     case STATUS_BAD_BLOCK:
         return handleBadBlock(pbuf, len);
     case STATUS_OK:
diff --git a/qt/reader.h b/qt/reader.h
@@ -27,6 +27,7 @@ class Reader : public QThread
     int write(uint8_t *data, uint32_t len);
     int readStart();
     int read(uint8_t *pbuf, uint32_t len);
+    int handleError(uint8_t *pbuf, uint32_t len);
     int handleBadBlock(uint8_t *pbuf, uint32_t len);
     int handleStatus(uint8_t *pbuf, uint32_t len);
     int handleData(uint8_t *pbuf, uint32_t len);
diff --git a/qt/writer.cpp b/qt/writer.cpp
@@ -73,6 +73,19 @@ int Writer::handleBadBlock(RespHeader *header, uint32_t len)
     return 0;
 }
 
+int Writer::handleError(RespHeader *header, uint32_t len)
+{
+    RespError *err = (RespError *)header;
+    size_t size = sizeof(RespError);
+
+    if (len < size)
+        return 0;
+
+    logErr(QString("Programmer sent error: %1").arg(err->errCode));
+
+    return -1;
+}
+
 int Writer::handleStatus(RespHeader *header, uint32_t len, void *ackData)
 {
     uint8_t status = header->info;
@@ -82,8 +95,7 @@ int Writer::handleStatus(RespHeader *header, uint32_t len, void *ackData)
     case STATUS_OK:
         break;
     case STATUS_ERROR:
-        logErr("Programmer send error");
-        return -1;
+        return handleError(header, len);
     case STATUS_BAD_BLOCK:
         handleBadBlock(header, len);
         return -1;
diff --git a/qt/writer.h b/qt/writer.h
@@ -24,6 +24,7 @@ class Writer : public QThread
     int write(uint8_t *data, uint32_t dataLen);
     int handleWriteAck(RespHeader *header, uint32_t len, void *ackData);
     int handleBadBlock(RespHeader *header, uint32_t len);
+    int handleError(RespHeader *header, uint32_t len);
     int handleStatus(RespHeader *header, uint32_t len, void *ackData);
     int handleAck(RespHeader *header, uint32_t len, void *ackData);
     int readAck(void *ackData);

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,19 @@ enum`
`41`	`41`	`CMD_NAND_SELECT = 0x06,`
`42`	`42`	`};`
`43`	`43`
	`44`	`+enum`
	`45`	`+{`
	`46`	`+ ERR_ADDR_EXCEEDED = 0x00,`
	`47`	`+ ERR_ADDR_INVALID = 0x01,`
	`48`	`+ ERR_NAND_WR = 0x02,`
	`49`	`+ ERR_NAND_RD = 0x03,`
	`50`	`+ ERR_NAND_ERASE = 0x04,`
	`51`	`+ ERR_CHIP_NOT_SEL = 0x05,`
	`52`	`+ ERR_CHIP_NOT_FOUND = 0x06,`
	`53`	`+ ERR_CMD_DATA_SIZE = 0x07,`
	`54`	`+ ERR_BUF_OVERFLOW = 0x08,`
	`55`	`+};`
	`56`	`+`
`44`	`57`	`typedef struct __attribute__((__packed__))`
`45`	`58`	`{`
`46`	`59`	`uint8_t code;`
`@@ -123,6 +136,12 @@ typedef struct __attribute__((__packed__))`
`123`	`136`	`uint32_t bytes_ack;`
`124`	`137`	`} resp_write_ack_t;`
`125`	`138`
	`139`	`+typedef struct __attribute__((__packed__))`
	`140`	`+{`
	`141`	`+ resp_t header;`
	`142`	`+ uint8_t err_code;`
	`143`	`+} resp_err_t;`
	`144`	`+`
`126`	`145`	`typedef struct`
`127`	`146`	`{`
`128`	`147`	`uint32_t addr;`
`@@ -221,9 +240,9 @@ static void usb_init(usb_t *usb)`
`221`	`240`	`usb->rx_buf_size = USB_BUF_SIZE;`
`222`	`241`	`}`
`223`	`242`
`224`		`-static int make_status(usb_t *usb, int is_ok)`
	`243`	`+static int make_ok_status(usb_t *usb)`
`225`	`244`	`{`
`226`		`- resp_t status = { RESP_STATUS, is_ok ? STATUS_OK : STATUS_ERROR };`
	`245`	`+ resp_t status = { RESP_STATUS, STATUS_OK };`
`227`	`246`	`size_t len = sizeof(status);`
`228`	`247`
`229`	`248`	`if (len > usb->tx_buf_size)`
`@@ -238,6 +257,24 @@ static int make_status(usb_t *usb, int is_ok)`
`238`	`257`	`return len;`
`239`	`258`	`}`
`240`	`259`
	`260`	`+static int make_error_status(usb_t *usb, uint8_t err_code)`
	`261`	`+{`
	`262`	`+ resp_t status = { RESP_STATUS, STATUS_ERROR };`
	`263`	`+ resp_err_t err_status = { status, err_code };`
	`264`	`+ size_t len = sizeof(err_status);`
	`265`	`+`
	`266`	`+ if (len > usb->tx_buf_size)`
	`267`	`+ {`
	`268`	`+ ERROR_PRINT("Status size %d is more then TX buffer size %d\r\n", len,`
	`269`	`+ usb->tx_buf_size);`
	`270`	`+ return -1;`
	`271`	`+ }`
	`272`	`+`
	`273`	`+ memcpy(usb->tx_buf, &err_status, len);`
	`274`	`+`
	`275`	`+ return len;`
	`276`	`+}`
	`277`	`+`
`241`	`278`	`static int send_bad_block_info(uint32_t addr)`
`242`	`279`	`{`
`243`	`280`	`resp_t resp_header = { RESP_STATUS, STATUS_BAD_BLOCK };`
`@@ -262,13 +299,13 @@ static int cmd_nand_read_id(prog_t *prog)`
`262`	`299`	`if (!chip_is_selected())`
`263`	`300`	`{`
`264`	`301`	`ERROR_PRINT("Chip is not selected\r\n");`
`265`		`- goto Error;`
	`302`	`+ return make_error_status(&prog->usb, ERR_CHIP_NOT_SEL);`
`266`	`303`	`}`
`267`	`304`
`268`	`305`	`if (prog->usb.tx_buf_size < resp_len)`
`269`	`306`	`{`
`270`	`307`	`ERROR_PRINT("Response size is more then TX buffer size\r\n");`
`271`		`- goto Error;`
	`308`	`+ return make_error_status(&prog->usb, ERR_BUF_OVERFLOW);`
`272`	`309`	`}`
`273`	`310`
`274`	`311`	`resp.header.code = RESP_DATA;`
`@@ -278,9 +315,6 @@ static int cmd_nand_read_id(prog_t *prog)`
`278`	`315`	`memcpy(prog->usb.tx_buf, &resp, resp_len);`
`279`	`316`
`280`	`317`	`return resp_len;`
`281`		`-`
`282`		`-Error:`
`283`		`- return make_status(&prog->usb, 0);`
`284`	`318`	`}`
`285`	`319`
`286`	`320`	`static int nand_erase(uint32_t page, uint32_t addr)`
`@@ -312,7 +346,7 @@ static int nand_erase(uint32_t page, uint32_t addr)`
`312`	`346`	`static int cmd_nand_erase(prog_t *prog)`
`313`	`347`	`{`
`314`	`348`	`chip_info_t *chip_info;`
`315`		`- uint32_t addr, page, pages_in_block, ret = -1;`
	`349`	`+ uint32_t addr, page, pages_in_block;`
`316`	`350`	`erase_cmd_t erase_cmd = (erase_cmd_t )prog->usb.rx_buf;`
`317`	`351`
`318`	`352`	`DEBUG_PRINT("Erase at 0x%lx %lx bytes command\r\n", erase_cmd->addr,`
`@@ -321,7 +355,7 @@ static int cmd_nand_erase(prog_t *prog)`
`321`	`355`	`if (!chip_is_selected())`
`322`	`356`	`{`
`323`	`357`	`ERROR_PRINT("Chip is not selected\r\n");`
`324`		`- goto Exit;`
	`358`	`+ return make_error_status(&prog->usb, ERR_CHIP_NOT_SEL);`
`325`	`359`	`}`
`326`	`360`	`chip_info = chip_info_selected_get();`
`327`	`361`
`@@ -337,11 +371,11 @@ static int cmd_nand_erase(prog_t *prog)`
`337`	`371`	`{`
`338`	`372`	`ERROR_PRINT("Erase address 0x%lx is more then chip size 0x%lx\r\n",`
`339`	`373`	`addr, chip_info->size);`
`340`		`- goto Exit;`
	`374`	`+ return make_error_status(&prog->usb, ERR_ADDR_EXCEEDED);`
`341`	`375`	`}`
`342`	`376`
`343`	`377`	`if (nand_erase(page, addr))`
`344`		`- goto Exit;`
	`378`	`+ return make_error_status(&prog->usb, ERR_NAND_ERASE);`
`345`	`379`
`346`	`380`	`if (erase_cmd->len >= chip_info->block_size)`
`347`	`381`	`erase_cmd->len -= chip_info->block_size;`
`@@ -351,9 +385,7 @@ static int cmd_nand_erase(prog_t *prog)`
`351`	`385`	`page += pages_in_block;`
`352`	`386`	`}`
`353`	`387`
`354`		`- ret = 0;`
`355`		`-Exit:`
`356`		`- return make_status(&prog->usb, !ret);`
	`388`	`+ return make_ok_status(&prog->usb);`
`357`	`389`	`}`
`358`	`390`
`359`	`391`	`static int send_write_ack(uint32_t bytes_ack)`
`@@ -381,7 +413,7 @@ static int cmd_nand_write_start(prog_t *prog)`
`381`	`413`	`{`
`382`	`414`	`ERROR_PRINT("Write address 0x%lx is more then chip size 0x%lx\r\n",`
`383`	`415`	`write_start_cmd->addr, chip_info->size);`
`384`		`- return -1;`
	`416`	`+ return make_error_status(&prog->usb, ERR_ADDR_EXCEEDED);`
`385`	`417`	`}`
`386`	`418`
`387`	`419`	`prog->addr = write_start_cmd->addr;`
`@@ -394,7 +426,7 @@ static int cmd_nand_write_start(prog_t *prog)`
`394`	`426`	`prog->bytes_written = 0;`
`395`	`427`	`prog->bytes_ack = 0;`
`396`	`428`
`397`		`- return 0;`
	`429`	`+ return make_ok_status(&prog->usb);`
`398`	`430`	`}`
`399`	`431`
`400`	`432`	`static int nand_handle_status(prog_t *prog)`
`@@ -481,13 +513,13 @@ static int cmd_nand_write_data(prog_t *prog)`
`481`	`513`	`prog->usb.rx_buf_size)`
`482`	`514`	`{`
`483`	`515`	`ERROR_PRINT("Data size is wrong %d\r\n", write_data_cmd->len);`
`484`		`- return -1;`
	`516`	`+ return make_error_status(&prog->usb, ERR_CMD_DATA_SIZE);`
`485`	`517`	`}`
`486`	`518`
`487`	`519`	`if (!prog->addr_is_valid)`
`488`	`520`	`{`
`489`	`521`	`ERROR_PRINT("Write address is not set\r\n");`
`490`		`- return -1;`
	`522`	`+ return make_error_status(&prog->usb, ERR_ADDR_INVALID);`
`491`	`523`	`}`
`492`	`524`
`493`	`525`	`if (prog->page.offset + write_data_cmd->len > chip_info->page_size)`
`@@ -501,7 +533,7 @@ static int cmd_nand_write_data(prog_t *prog)`
`501`	`533`	`if (prog->page.offset == chip_info->page_size)`
`502`	`534`	`{`
`503`	`535`	`if (nand_write(prog, chip_info))`
`504`		`- return -1;`
	`536`	`+ return make_error_status(&prog->usb, ERR_NAND_WR);`
`505`	`537`
`506`	`538`	`prog->addr += chip_info->page_size;`
`507`	`539`	`if (prog->addr >= chip_info->size)`
`@@ -537,29 +569,30 @@ static int cmd_nand_write_end(prog_t *prog)`
`537`	`569`	`if (!prog->addr_is_valid)`
`538`	`570`	`{`
`539`	`571`	`ERROR_PRINT("Write address is not set\r\n");`
`540`		`- return -1;`
	`572`	`+ return make_error_status(&prog->usb, ERR_ADDR_INVALID);`
`541`	`573`	`}`
`542`	`574`
`543`	`575`	`prog->addr_is_valid = 0;`
`544`	`576`
`545`	`577`	`if (!prog->page.offset)`
`546`		`- return 0;`
	`578`	`+ goto Exit;`
`547`	`579`
`548`	`580`	`if (nand_write(prog, chip_info))`
`549`		`- return -1;`
	`581`	`+ return make_error_status(&prog->usb, ERR_NAND_WR);`
`550`	`582`
`551`		`- return 0;`
	`583`	`+Exit:`
	`584`	`+ return make_ok_status(&prog->usb);`
`552`	`585`	`}`
`553`	`586`
`554`	`587`	`static int cmd_nand_write(prog_t *prog)`
`555`	`588`	`{`
`556`	`589`	`cmd_t cmd = (cmd_t )prog->usb.rx_buf;`
`557`		`- int ret = -1;`
	`590`	`+ int ret = 0;`
`558`	`591`
`559`	`592`	`if (!chip_is_selected())`
`560`	`593`	`{`
`561`	`594`	`ERROR_PRINT("Chip is not selected\r\n");`
`562`		`- goto Exit;`
	`595`	`+ return make_error_status(&prog->usb, ERR_CHIP_NOT_SEL);`
`563`	`596`	`}`
`564`	`597`
`565`	`598`	`switch (cmd->code)`
`@@ -569,8 +602,6 @@ static int cmd_nand_write(prog_t *prog)`
`569`	`602`	`break;`
`570`	`603`	`case CMD_NAND_WRITE_D:`
`571`	`604`	`ret = cmd_nand_write_data(prog);`
`572`		`- if (!ret)`
`573`		`- return 0;`
`574`	`605`	`break;`
`575`	`606`	`case CMD_NAND_WRITE_E:`
`576`	`607`	`ret = cmd_nand_write_end(prog);`
`@@ -579,8 +610,7 @@ static int cmd_nand_write(prog_t *prog)`
`579`	`610`	`break;`
`580`	`611`	`}`
`581`	`612`
`582`		`-Exit:`
`583`		`- return make_status(&prog->usb, !ret);`
	`613`	`+ return ret;`
`584`	`614`	`}`
`585`	`615`
`586`	`616`	`static int nand_read(uint32_t addr, page_t page, chip_info_t chip_info)`
`@@ -626,15 +656,15 @@ static int cmd_nand_read(prog_t *prog)`
`626`	`656`	`if (!chip_is_selected())`
`627`	`657`	`{`
`628`	`658`	`ERROR_PRINT("Chip is not selected\r\n");`
`629`		`- goto Error;`
	`659`	`+ return make_error_status(&prog->usb, ERR_CHIP_NOT_SEL);`
`630`	`660`	`}`
`631`	`661`	`chip_info = chip_info_selected_get();`
`632`	`662`
`633`	`663`	`if (read_cmd->addr >= chip_info->size)`
`634`	`664`	`{`
`635`	`665`	`ERROR_PRINT("Read address 0x%lx is more then chip size 0x%lx\r\n",`
`636`	`666`	`read_cmd->addr, chip_info->size);`
`637`		`- goto Error;`
	`667`	`+ return make_error_status(&prog->usb, ERR_ADDR_EXCEEDED);`
`638`	`668`	`}`
`639`	`669`
`640`	`670`	`addr = read_cmd->addr;`
`@@ -646,7 +676,7 @@ static int cmd_nand_read(prog_t *prog)`
`646`	`676`	`while (read_cmd->len)`
`647`	`677`	`{`
`648`	`678`	`if (nand_read(addr, &page, chip_info))`
`649`		`- goto Error;`
	`679`	`+ return make_error_status(&prog->usb, ERR_NAND_RD);`
`650`	`680`
`651`	`681`	`while (page.offset < chip_info->page_size && read_cmd->len)`
`652`	`682`	`{`
`@@ -676,23 +706,19 @@ static int cmd_nand_read(prog_t *prog)`
`676`	`706`	`{`
`677`	`707`	`ERROR_PRINT("Read address 0x%lx is more then chip size 0x%lx",`
`678`	`708`	`addr, chip_info->page_size);`
`679`		`- goto Error;`
	`709`	`+ return make_error_status(&prog->usb, ERR_ADDR_EXCEEDED);`
`680`	`710`	`}`
`681`	`711`	`page.page++;`
`682`	`712`	`page.offset = 0;`
`683`	`713`	`}`
`684`	`714`	`}`
`685`	`715`
`686`	`716`	`return 0;`
`687`		`-`
`688`		`-Error:`
`689`		`- return make_status(&prog->usb, 0);`
`690`	`717`	`}`
`691`	`718`
`692`	`719`	`static int cmd_nand_select(prog_t *prog)`
`693`	`720`	`{`
`694`	`721`	`select_cmd_t select_cmd = (select_cmd_t )prog->usb.rx_buf;`
`695`		`- int ret = 0;`
`696`	`722`
`697`	`723`	`DEBUG_PRINT("Chip select ID %lu command\r\n", select_cmd->chip_num);`
`698`	`724`
`@@ -701,10 +727,10 @@ static int cmd_nand_select(prog_t *prog)`
`701`	`727`	`else`
`702`	`728`	`{`
`703`	`729`	`ERROR_PRINT("Chip ID %lu not found\r\n", select_cmd->chip_num);`
`704`		`- ret = -1;`
	`730`	`+ return make_error_status(&prog->usb, ERR_CHIP_NOT_FOUND);`
`705`	`731`	`}`
`706`	`732`
`707`		`- return make_status(&prog->usb, !ret);`
	`733`	`+ return make_ok_status(&prog->usb);`
`708`	`734`	`}`
`709`	`735`
`710`	`736`	`static int usb_cmd_handler(prog_t *prog)`
`@@ -760,7 +786,7 @@ static void nand_handler(prog_t *prog)`
`760`	`786`	`if (prog->nand_wr_in_progress)`
`761`	`787`	`{`
`762`	`788`	`if (nand_handle_status(prog))`
`763`		`- send_status(prog, make_status(&prog->usb, 0));`
	`789`	`+ send_status(prog, make_error_status(&prog->usb, ERR_NAND_WR));`
`764`	`790`	`}`
`765`	`791`	`}`
`766`	`792`