Bootloader: The big rename

diff --git a/lib/dfu-bootloader.c b/lib/dfu-bootloader.c
index cb314d8673c2dee5b89d04235960d27328d5ca64..f768b40a079cef5ad8aeeb0317b012a6095e60bd 100644 (file)
--- a/lib/dfu-bootloader.c
+++ b/lib/dfu-bootloader.c
@@ -38,7 +38,7 @@
 
 byte usbd_control_buffer[1024];
 
-static enum dfu_state usbdfu_state = STATE_DFU_IDLE;
+static enum dfu_state dfu_state = STATE_DFU_IDLE;
 
 static struct {
        byte buf[sizeof(usbd_control_buffer)];
@@ -116,26 +116,25 @@ const struct usb_config_descriptor config = {
        .interface = ifaces,
 };
 
-// FIXME: Rename usbdfu_ to dfu_
-static byte usbdfu_getstatus(usbd_device *usbd_dev UNUSED, u32 *bwPollTimeout)
+static byte dfu_getstatus(usbd_device *usbd_dev UNUSED, u32 *bwPollTimeout)
 {
-       switch (usbdfu_state) {
+       switch (dfu_state) {
        case STATE_DFU_DNLOAD_SYNC:
-               usbdfu_state = STATE_DFU_DNBUSY;
+               dfu_state = STATE_DFU_DNBUSY;
                *bwPollTimeout = 100;
                return DFU_STATUS_OK;
        case STATE_DFU_MANIFEST_SYNC:
                /* Device will reset when read is complete. */
-               usbdfu_state = STATE_DFU_MANIFEST;
+               dfu_state = STATE_DFU_MANIFEST;
                return DFU_STATUS_OK;
        default:
                return DFU_STATUS_OK;
        }
 }
 
-static void usbdfu_getstatus_complete(usbd_device *usbd_dev UNUSED, struct usb_setup_data *req UNUSED)
+static void dfu_getstatus_complete(usbd_device *usbd_dev UNUSED, struct usb_setup_data *req UNUSED)
 {
-       switch (usbdfu_state) {
+       switch (dfu_state) {
        case STATE_DFU_DNBUSY:
                if (prog.blocknum == 0)
                        *(u16*)(prog.buf + HDR_FLASH_IN_PROGRESS) = 0xffff;
@@ -148,7 +147,7 @@ static void usbdfu_getstatus_complete(usbd_device *usbd_dev UNUSED, struct usb_s
                        flash_program_half_word(baseaddr + i, data);
                }
                flash_lock();
-               usbdfu_state = STATE_DFU_DNLOAD_IDLE;
+               dfu_state = STATE_DFU_DNLOAD_IDLE;
                return;
        case STATE_DFU_MANIFEST:
                // At the very end, program the first page
@@ -156,14 +155,14 @@ static void usbdfu_getstatus_complete(usbd_device *usbd_dev UNUSED, struct usb_s
                flash_unlock();
                flash_program_half_word(BOOTLOADER_APP_START + 0x20, 0);
                flash_lock();
-               usbdfu_state = STATE_DFU_MANIFEST_WAIT_RESET;
+               dfu_state = STATE_DFU_MANIFEST_WAIT_RESET;
                return;
        default:
                return;
        }
 }
 
-static enum usbd_request_return_codes usbdfu_control_request(usbd_device *usbd_dev,
+static enum usbd_request_return_codes dfu_control_request(usbd_device *usbd_dev,
        struct usb_setup_data *req,
        byte **buf,
        u16 *len,
@@ -172,47 +171,47 @@ static enum usbd_request_return_codes usbdfu_control_request(usbd_device *usbd_d
        if ((req->bmRequestType & 0x7F) != 0x21)
                return USBD_REQ_NOTSUPP; /* Only accept class request. */
 
-       DEBUG("DFU: Request %02x in state %d\n", req->bRequest, usbdfu_state);
+       DEBUG("DFU: Request %02x in state %d\n", req->bRequest, dfu_state);
 
        switch (req->bRequest) {
        case DFU_DNLOAD:
                if (len == NULL || *len == 0) {
-                       usbdfu_state = STATE_DFU_MANIFEST_SYNC;
+                       dfu_state = STATE_DFU_MANIFEST_SYNC;
                } else {
                        /* Copy download data for use on GET_STATUS. */
                        prog.blocknum = req->wValue;
                        prog.len = *len;
                        memcpy(prog.buf, *buf, *len);
-                       usbdfu_state = STATE_DFU_DNLOAD_SYNC;
+                       dfu_state = STATE_DFU_DNLOAD_SYNC;
                }
                return USBD_REQ_HANDLED;
        case DFU_CLRSTATUS:
                /* Clear error and return to dfuIDLE. */
-               if (usbdfu_state == STATE_DFU_ERROR)
-                       usbdfu_state = STATE_DFU_IDLE;
+               if (dfu_state == STATE_DFU_ERROR)
+                       dfu_state = STATE_DFU_IDLE;
                return USBD_REQ_HANDLED;
        case DFU_ABORT:
                /* Abort returns to dfuIDLE state. */
-               usbdfu_state = STATE_DFU_IDLE;
+               dfu_state = STATE_DFU_IDLE;
                return USBD_REQ_HANDLED;
        case DFU_UPLOAD:
                /* Upload not supported for now. */
                return USBD_REQ_NOTSUPP;
        case DFU_GETSTATUS: {
                u32 bwPollTimeout = 0; /* 24-bit number of milliseconds */
-               (*buf)[0] = usbdfu_getstatus(usbd_dev, &bwPollTimeout);
+               (*buf)[0] = dfu_getstatus(usbd_dev, &bwPollTimeout);
                (*buf)[1] = bwPollTimeout & 0xFF;
                (*buf)[2] = (bwPollTimeout >> 8) & 0xFF;
                (*buf)[3] = (bwPollTimeout >> 16) & 0xFF;
-               (*buf)[4] = usbdfu_state;
+               (*buf)[4] = dfu_state;
                (*buf)[5] = 0; /* iString not used here */
                *len = 6;
-               *complete = usbdfu_getstatus_complete;
+               *complete = dfu_getstatus_complete;
                return USBD_REQ_HANDLED;
                }
        case DFU_GETSTATE:
                /* Return state with no state transition. */
-               *buf[0] = usbdfu_state;
+               *buf[0] = dfu_state;
                *len = 1;
                return USBD_REQ_HANDLED;
        }
@@ -220,18 +219,18 @@ static enum usbd_request_return_codes usbdfu_control_request(usbd_device *usbd_d
        return USBD_REQ_NOTSUPP;
 }
 
-static void usbdfu_set_config(usbd_device *usbd_dev, u16 wValue UNUSED)
+static void dfu_set_config(usbd_device *usbd_dev, u16 wValue UNUSED)
 {
        usbd_register_control_callback(
                                usbd_dev,
                                USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE,
                                USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT,
-                               usbdfu_control_request);
+                               dfu_control_request);
 }
 
-static void usbdfu_reset(void)
+static void dfu_reset(void)
 {
-       usbdfu_state = STATE_DFU_IDLE;
+       dfu_state = STATE_DFU_IDLE;
 }
 
 /*
@@ -375,13 +374,13 @@ int main(void)
        debug_led(0);
 
        usbd_dev = usbd_init(&st_usbfs_v1_usb_driver, &dev, &config, usb_strings, ARRAY_SIZE(usb_strings), usbd_control_buffer, sizeof(usbd_control_buffer));
-       usbd_register_reset_callback(usbd_dev, usbdfu_reset);
-       usbd_register_set_config_callback(usbd_dev, usbdfu_set_config);
+       usbd_register_reset_callback(usbd_dev, dfu_reset);
+       usbd_register_set_config_callback(usbd_dev, dfu_set_config);
 
 restart: ;
 
        uint timeout = 5000;
-       while (timeout || (usbdfu_state != STATE_DFU_IDLE && usbdfu_state != STATE_DFU_MANIFEST_WAIT_RESET)) {
+       while (timeout || (dfu_state != STATE_DFU_IDLE && dfu_state != STATE_DFU_MANIFEST_WAIT_RESET)) {
                usbd_poll(usbd_dev);
                if (timeout && systick_get_countflag()) {
                        timeout--;