Bootloader/dfu.h

   1 /* Copyright (c) 2011,2012 Simon Schubert <2@0x2c.org>.
   2  * Modifications by Jacob Alexander 2014-2015 <haata@kiibohd.com>
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #pragma once
  19
  20 // ----- Compiler Includes -----
  21
  22 #include <sys/types.h>
  23
  24
  25
  26 // ----- Defines -----
  27
  28 #define USB_FUNCTION_DFU_IFACE_COUNT 1
  29
  30
  31 #ifndef USB_DFU_TRANSFER_SIZE
  32 // Sector size is the same as the program flash size
  33 #if defined(_mk20dx128vlf5_)
  34 #define USB_DFU_TRANSFER_SIZE FLASH_SECTOR_SIZE
  35
  36 // Sector size is double the program flash size
  37 #elif defined(_mk20dx256vlh7_ )
  38 #define USB_DFU_TRANSFER_SIZE FLASH_SECTOR_SIZE / 2
  39
  40 #endif
  41 #endif
  42
  43 #define USB_FUNCTION_DESC_DFU_DECL                         \
  44         struct dfu_function_desc
  45
  46 #define USB_FUNCTION_DFU_IFACE_COUNT    1
  47 #define USB_FUNCTION_DFU_RX_EP_COUNT    0
  48 #define USB_FUNCTION_DFU_TX_EP_COUNT    0
  49
  50
  51
  52 // ----- Enumerations -----
  53
  54 enum dfu_dev_subclass {
  55         USB_DEV_SUBCLASS_APP_DFU = 0x01
  56 };
  57
  58 enum dfu_dev_proto {
  59         USB_DEV_PROTO_DFU_APP = 0x01,
  60         USB_DEV_PROTO_DFU_DFU = 0x02
  61 };
  62
  63 enum dfu_ctrl_req_code {
  64         USB_CTRL_REQ_DFU_DETACH = 0,
  65         USB_CTRL_REQ_DFU_DNLOAD = 1,
  66         USB_CTRL_REQ_DFU_UPLOAD = 2,
  67         USB_CTRL_REQ_DFU_GETSTATUS = 3,
  68         USB_CTRL_REQ_DFU_CLRSTATUS = 4,
  69         USB_CTRL_REQ_DFU_GETSTATE = 5,
  70         USB_CTRL_REQ_DFU_ABORT = 6
  71 };
  72
  73 enum dfu_status {
  74         DFU_STATUS_async = 0xff,
  75         DFU_STATUS_OK = 0x00,
  76         DFU_STATUS_errTARGET = 0x01,
  77         DFU_STATUS_errFILE = 0x02,
  78         DFU_STATUS_errWRITE = 0x03,
  79         DFU_STATUS_errERASE = 0x04,
  80         DFU_STATUS_errCHECK_ERASED = 0x05,
  81         DFU_STATUS_errPROG = 0x06,
  82         DFU_STATUS_errVERIFY = 0x07,
  83         DFU_STATUS_errADDRESS = 0x08,
  84         DFU_STATUS_errNOTDONE = 0x09,
  85         DFU_STATUS_errFIRMWARE = 0x0a,
  86         DFU_STATUS_errVENDOR = 0x0b,
  87         DFU_STATUS_errUSBR = 0x0c,
  88         DFU_STATUS_errPOR = 0x0d,
  89         DFU_STATUS_errUNKNOWN = 0x0e,
  90         DFU_STATUS_errSTALLEDPKT = 0x0f
  91 };
  92
  93 enum dfu_state {
  94         DFU_STATE_appIDLE = 0,
  95         DFU_STATE_appDETACH = 1,
  96         DFU_STATE_dfuIDLE = 2,
  97         DFU_STATE_dfuDNLOAD_SYNC = 3,
  98         DFU_STATE_dfuDNBUSY = 4,
  99         DFU_STATE_dfuDNLOAD_IDLE = 5,
 100         DFU_STATE_dfuMANIFEST_SYNC = 6,
 101         DFU_STATE_dfuMANIFEST = 7,
 102         DFU_STATE_dfuMANIFEST_WAIT_RESET = 8,
 103         DFU_STATE_dfuUPLOAD_IDLE = 9,
 104         DFU_STATE_dfuERROR = 10
 105 };
 106
 107
 108
 109 // ----- Structs -----
 110
 111 struct dfu_status_t {
 112         enum dfu_status bStatus : 8;
 113         uint32_t bwPollTimeout : 24;
 114         enum dfu_state bState : 8;
 115         uint8_t iString;
 116 } __packed;
 117 CTASSERT_SIZE_BYTE(struct dfu_status_t, 6);
 118
 119
 120 typedef enum dfu_status (*dfu_setup_read_t)(size_t off, size_t *len, void **buf);
 121 typedef enum dfu_status (*dfu_setup_write_t)(size_t off, size_t len, void **buf);
 122 typedef enum dfu_status (*dfu_finish_write_t)(void *, size_t off, size_t len);
 123 typedef void (*dfu_detach_t)(void);
 124
 125 struct dfu_ctx {
 126         struct usbd_function_ctx_header header;
 127         enum dfu_state state;
 128         enum dfu_status status;
 129         dfu_setup_read_t setup_read;
 130         dfu_setup_write_t setup_write;
 131         dfu_finish_write_t finish_write;
 132         size_t off;
 133         size_t len;
 134 };
 135
 136
 137 struct dfu_desc_functional {
 138         uint8_t bLength;
 139         struct usb_desc_type_t bDescriptorType; /* = class DFU/0x1 FUNCTIONAL */
 140         union {
 141                 struct {
 142                         uint8_t can_download : 1;
 143                         uint8_t can_upload : 1;
 144                         uint8_t manifestation_tolerant : 1;
 145                         uint8_t will_detach : 1;
 146                         uint8_t _rsvd0 : 4;
 147                 };
 148                 uint8_t bmAttributes;
 149         };
 150         uint16_t wDetachTimeOut;
 151         uint16_t wTransferSize;
 152         struct usb_bcd_t bcdDFUVersion;
 153 } __packed;
 154 CTASSERT_SIZE_BYTE(struct dfu_desc_functional, 9);
 155
 156 struct dfu_function_desc {
 157         struct usb_desc_iface_t iface;
 158         struct dfu_desc_functional dfu;
 159 };
 160
 161
 162 extern const struct usbd_function dfu_function;
 163 extern const struct usbd_function dfu_app_function;
 164
 165
 166
 167 // ----- Functions -----
 168
 169 void dfu_write_done( enum dfu_status, struct dfu_ctx *ctx );
 170 void dfu_init( dfu_setup_read_t setup_read, dfu_setup_write_t setup_write, dfu_finish_write_t finish_write, struct dfu_ctx *ctx );
 171 void dfu_app_init( dfu_detach_t detachcb );
 172