- Heavily modified, not compatible with McHCK images - Uses 4k of Flash (rather than 3k) - LED turns on when in firmware flash mode - Changed the USB IDs - Added CMake build system - Updated linker script to be closer to what is used for the rest of the projects - Removed a lot of unnecessary code - Added a license header to each file (using the same license as the McHCK had) - Updated the USB Vendor, Product and Serial strings - Using the Kiibohd initialization sequence rather than the McHCK one - Using Kiibohd interrupt vector table and other misc mk20dx setupsimple
###| CMAKE Kiibohd Controller Bootloader |### | |||||
# | |||||
# Jacob Alexander 2011-2014 | |||||
# Due to this file's usefulness: | |||||
# | |||||
# Released into the Public Domain | |||||
# | |||||
# This bootloader is based upon the MCHCK dfu-usb bootloader. | |||||
# DO NOT USE with Teensy based microcontrollers. | |||||
# | |||||
### | |||||
### | |||||
# Chip Selection | |||||
# | |||||
#| You _MUST_ set this to match the microcontroller you are trying to compile for | |||||
#| You _MUST_ clean the build directory if you change this value | |||||
#| | |||||
set( CHIP | |||||
"mk20dx128vlf5" # McHCK mk20dx128vlf5 | |||||
) | |||||
### | |||||
# Bootloader Configuration | |||||
# | |||||
set ( BOOTLOADER 1 ) | |||||
### | |||||
# Compiler Intialization | |||||
# | |||||
set ( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/../Lib/CMake ) | |||||
include( initialize ) | |||||
## | |||||
# Source Defines | |||||
# | |||||
set( SRCS | |||||
main.c | |||||
dfu.c | |||||
dfu.desc.c | |||||
flash.c | |||||
kinetis.c | |||||
usb.c | |||||
) | |||||
message( STATUS "Bootloader Source Files:" ) | |||||
message( "${SRCS}" ) | |||||
#| Add Lib sources to main list | |||||
foreach( SRC_FILE ${COMPILER_SRCS} ) | |||||
set( SRCS ${SRCS} ${CMAKE_SOURCE_DIR}/../${SRC_FILE} ) | |||||
endforeach() | |||||
### | |||||
# Directory Includes | |||||
# | |||||
include_directories( ${CMAKE_SOURCE_DIR}/../Lib ) | |||||
### | |||||
# Project Description | |||||
# | |||||
#| Project | |||||
project( kiibohd_bootloader ) | |||||
#| Target Name (output name) | |||||
set( TARGET kiibohd_bootloader ) | |||||
#| General Settings | |||||
cmake_minimum_required( VERSION 2.8 ) | |||||
### | |||||
# Generate Header Files | |||||
# | |||||
configure_file( _buildvars.h buildvars.h ) | |||||
include_directories( ${CMAKE_BINARY_DIR} ) | |||||
### | |||||
# CMake Module Checking | |||||
# | |||||
find_package( Git REQUIRED ) | |||||
find_package( Ctags ) # Optional | |||||
### | |||||
# ctag Generation | |||||
# | |||||
if( CTAGS_EXECUTABLE ) | |||||
# Generate the ctags | |||||
execute_process( COMMAND ctags ${SRCS} | |||||
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} | |||||
) | |||||
endif() | |||||
### | |||||
# Build Targets | |||||
# | |||||
#| Create the .ELF file | |||||
set( TARGET_ELF ${TARGET}.elf ) | |||||
add_executable( ${TARGET_ELF} ${SRCS} ) | |||||
#| .ELF Properties | |||||
set_target_properties( ${TARGET_ELF} PROPERTIES | |||||
LINK_FLAGS ${LINKER_FLAGS} | |||||
SUFFIX "" # XXX Force Windows to keep the .exe off | |||||
) | |||||
#| Convert the .ELF into a .bin to load onto the McHCK | |||||
set( TARGET_BIN ${TARGET}.bin ) | |||||
add_custom_command( TARGET ${TARGET_ELF} POST_BUILD | |||||
COMMAND ${CMAKE_OBJCOPY} ${BIN_FLAGS} ${TARGET_ELF} ${TARGET_BIN} | |||||
COMMENT "Creating binary file to load: ${TARGET_BIN}" | |||||
) | |||||
#| Generate the Extended .LSS | |||||
set( TARGET_LSS ${TARGET}.lss ) | |||||
add_custom_command( TARGET ${TARGET_ELF} POST_BUILD | |||||
COMMAND ${CMAKE_OBJDUMP} ${LSS_FLAGS} ${TARGET_ELF} > ${TARGET_LSS} | |||||
COMMENT "Creating Extended Listing: ${TARGET_LSS}" | |||||
) | |||||
#| Generate the Symbol Table .SYM | |||||
set( TARGET_SYM ${TARGET}.sym ) | |||||
add_custom_command( TARGET ${TARGET_ELF} POST_BUILD | |||||
COMMAND ${CMAKE_NM} -n ${TARGET_ELF} > ${TARGET_SYM} | |||||
COMMENT "Creating Symbol Table: ${TARGET_SYM}" | |||||
) | |||||
#| Compiler Selection Record | |||||
add_custom_command( TARGET ${TARGET_ELF} POST_BUILD | |||||
COMMAND ${CMAKE_SOURCE_DIR}/../Lib/CMake/writer compiler ${COMPILER_FAMILY} | |||||
) | |||||
### | |||||
# Size Information | |||||
# | |||||
#| After Changes Size Information | |||||
add_custom_target( SizeAfter ALL | |||||
COMMAND ${CMAKE_SOURCE_DIR}/../Lib/CMake/sizeCalculator ${CMAKE_SIZE} ram ${TARGET_ELF} ${SIZE_RAM} " SRAM" | |||||
COMMAND ${CMAKE_SOURCE_DIR}/../Lib/CMake/sizeCalculator ${CMAKE_SIZE} flash ${TARGET_ELF} ${SIZE_FLASH} "Flash" | |||||
DEPENDS ${TARGET_ELF} | |||||
COMMENT "Chip usage for ${CHIP}" | |||||
) | |||||
/* Copyright (C) 2013-2014 by Jacob Alexander | |||||
* | |||||
* Permission is hereby granted, free of charge, to any person obtaining a copy | |||||
* of this software and associated documentation files (the "Software"), to deal | |||||
* in the Software without restriction, including without limitation the rights | |||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |||||
* copies of the Software, and to permit persons to whom the Software is | |||||
* furnished to do so, subject to the following conditions: | |||||
* | |||||
* The above copyright notice and this permission notice shall be included in | |||||
* all copies or substantial portions of the Software. | |||||
* | |||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |||||
* THE SOFTWARE. | |||||
*/ | |||||
#ifndef __buildvars_h | |||||
#define __buildvars_h | |||||
// ----- Includes ----- | |||||
// ----- Defines ----- | |||||
// You can change these to give your code its own name. | |||||
#define STR_MANUFACTURER u"@MANUFACTURER@" | |||||
#define STR_PRODUCT u"Kiibohd DFU Bootloader" | |||||
#define STR_SERIAL u"@CHIP@" | |||||
// Mac OS-X and Linux automatically load the correct drivers. On | |||||
// Windows, even though the driver is supplied by Microsoft, an | |||||
// INF file is needed to load the driver. These numbers need to | |||||
// match the INF file. | |||||
#define VENDOR_ID @BOOT_VENDOR_ID@ | |||||
#define PRODUCT_ID @BOOT_PRODUCT_ID@ | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
// ----- Local Includes ----- | |||||
#include "usb.h" | |||||
#include "dfu.h" | |||||
// ----- Functions ----- | |||||
void dfu_write_done( enum dfu_status err, struct dfu_ctx *ctx ) | |||||
{ | |||||
ctx->status = err; | |||||
if (ctx->status == DFU_STATUS_OK) { | |||||
switch (ctx->state) { | |||||
case DFU_STATE_dfuDNBUSY: | |||||
ctx->state = DFU_STATE_dfuDNLOAD_IDLE; | |||||
break; | |||||
default: | |||||
break; | |||||
} | |||||
} else { | |||||
ctx->state = DFU_STATE_dfuERROR; | |||||
} | |||||
} | |||||
static void dfu_dnload_complete( void *buf, ssize_t len, void *cbdata ) | |||||
{ | |||||
struct dfu_ctx *ctx = cbdata; | |||||
if (len > 0) | |||||
ctx->state = DFU_STATE_dfuDNBUSY; | |||||
else | |||||
ctx->state = DFU_STATE_dfuMANIFEST; | |||||
ctx->status = ctx->finish_write(buf, ctx->off, len); | |||||
ctx->off += len; | |||||
ctx->len = len; | |||||
if (ctx->status != DFU_STATUS_async) | |||||
dfu_write_done(ctx->status, ctx); | |||||
usb_handle_control_status(ctx->state == DFU_STATE_dfuERROR); | |||||
} | |||||
static void dfu_reset_system( void *buf, ssize_t len, void *cbdata ) | |||||
{ | |||||
SOFTWARE_RESET(); | |||||
} | |||||
static int dfu_handle_control( struct usb_ctrl_req_t *req, void *data ) | |||||
{ | |||||
struct dfu_ctx *ctx = data; | |||||
int fail = 1; | |||||
switch ((enum dfu_ctrl_req_code)req->bRequest) { | |||||
case USB_CTRL_REQ_DFU_DNLOAD: { | |||||
void *buf; | |||||
switch (ctx->state) { | |||||
case DFU_STATE_dfuIDLE: | |||||
ctx->off = 0; | |||||
break; | |||||
case DFU_STATE_dfuDNLOAD_IDLE: | |||||
break; | |||||
default: | |||||
goto err; | |||||
} | |||||
/** | |||||
* XXX we are not allowed to STALL here, and we need to eat all transferred data. | |||||
* better not allow setup_write to break the protocol. | |||||
*/ | |||||
ctx->status = ctx->setup_write(ctx->off, req->wLength, &buf); | |||||
if (ctx->status != DFU_STATUS_OK) { | |||||
ctx->state = DFU_STATE_dfuERROR; | |||||
goto err_have_status; | |||||
} | |||||
if (req->wLength > 0) | |||||
usb_ep0_rx(buf, req->wLength, dfu_dnload_complete, ctx); | |||||
else | |||||
dfu_dnload_complete(NULL, 0, ctx); | |||||
goto out_no_status; | |||||
} | |||||
case USB_CTRL_REQ_DFU_GETSTATUS: { | |||||
struct dfu_status_t st; | |||||
st.bState = ctx->state; | |||||
st.bStatus = ctx->status; | |||||
st.bwPollTimeout = 1000; /* XXX */ | |||||
/** | |||||
* If we're in DFU_STATE_dfuMANIFEST, we just finished | |||||
* the download, and we're just about to send our last | |||||
* status report. Once the report has been sent, go | |||||
* and reset the system to put the new firmware into | |||||
* effect. | |||||
*/ | |||||
usb_ep0_tx_cp(&st, sizeof(st), req->wLength, NULL, NULL); | |||||
if (ctx->state == DFU_STATE_dfuMANIFEST) { | |||||
usb_handle_control_status_cb(dfu_reset_system); | |||||
goto out_no_status; | |||||
} | |||||
break; | |||||
} | |||||
case USB_CTRL_REQ_DFU_CLRSTATUS: | |||||
ctx->state = DFU_STATE_dfuIDLE; | |||||
ctx->status = DFU_STATUS_OK; | |||||
break; | |||||
case USB_CTRL_REQ_DFU_GETSTATE: { | |||||
uint8_t st = ctx->state; | |||||
usb_ep0_tx_cp(&st, sizeof(st), req->wLength, NULL, NULL); | |||||
break; | |||||
} | |||||
case USB_CTRL_REQ_DFU_ABORT: | |||||
switch (ctx->state) { | |||||
case DFU_STATE_dfuIDLE: | |||||
case DFU_STATE_dfuDNLOAD_IDLE: | |||||
/* case DFU_STATE_dfuUPLOAD_IDLE: */ | |||||
ctx->state = DFU_STATE_dfuIDLE; | |||||
break; | |||||
default: | |||||
goto err; | |||||
} | |||||
break; | |||||
/* case USB_CTRL_REQ_DFU_UPLOAD: */ | |||||
default: | |||||
return (0); | |||||
} | |||||
fail = 0; | |||||
goto out; | |||||
err: | |||||
ctx->status = DFU_STATUS_errSTALLEDPKT; | |||||
err_have_status: | |||||
ctx->state = DFU_STATE_dfuERROR; | |||||
out: | |||||
usb_handle_control_status(fail); | |||||
out_no_status: | |||||
return (1); | |||||
} | |||||
void dfu_init( dfu_setup_write_t setup_write, dfu_finish_write_t finish_write, struct dfu_ctx *ctx ) | |||||
{ | |||||
ctx->state = DFU_STATE_dfuIDLE; | |||||
ctx->setup_write = setup_write; | |||||
ctx->finish_write = finish_write; | |||||
usb_attach_function(&dfu_function, &ctx->header); | |||||
} | |||||
const struct usbd_function dfu_function = { | |||||
.control = dfu_handle_control, | |||||
.interface_count = USB_FUNCTION_DFU_IFACE_COUNT, | |||||
}; | |||||
// Originally Generated from MCHCK Toolkit | |||||
/* Copyright (c) Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
// ----- Local Includes ----- | |||||
#include "dfu.desc.h" | |||||
// ----- Generated Includes ----- | |||||
#include <buildvars.h> | |||||
// ----- Structs ----- | |||||
static const struct usb_config_1 usb_config_1 = { | |||||
.config = { | |||||
.bLength = sizeof(struct usb_desc_config_t), | |||||
.bDescriptorType = USB_DESC_CONFIG, | |||||
.wTotalLength = sizeof(struct usb_config_1), | |||||
.bNumInterfaces = 1, | |||||
.bConfigurationValue = 1, | |||||
.iConfiguration = 0, | |||||
.one = 1, | |||||
.bMaxPower = 100 | |||||
}, | |||||
.usb_function_0 = { | |||||
.iface = { | |||||
.bLength = sizeof(struct usb_desc_iface_t), | |||||
.bDescriptorType = USB_DESC_IFACE, | |||||
.bInterfaceNumber = 0, | |||||
.bAlternateSetting = 0, | |||||
.bNumEndpoints = 0, | |||||
.bInterfaceClass = USB_DEV_CLASS_APP, | |||||
.bInterfaceSubClass = USB_DEV_SUBCLASS_APP_DFU, | |||||
.bInterfaceProtocol = USB_DEV_PROTO_DFU_DFU, | |||||
.iInterface = 0 | |||||
}, | |||||
.dfu = { | |||||
.bLength = sizeof(struct dfu_desc_functional), | |||||
.bDescriptorType = { | |||||
.id = 0x1, | |||||
.type_type = USB_DESC_TYPE_CLASS | |||||
}, | |||||
.will_detach = 1, | |||||
.manifestation_tolerant = 0, | |||||
.can_upload = 0, | |||||
.can_download = 1, | |||||
.wDetachTimeOut = 0, | |||||
.wTransferSize = USB_DFU_TRANSFER_SIZE, | |||||
.bcdDFUVersion = { .maj = 1, .min = 1 } | |||||
} | |||||
}, | |||||
}; | |||||
static const struct usbd_config usbd_config_1 = { | |||||
.init = init_usb_bootloader, | |||||
.suspend = NULL, | |||||
.resume = NULL, | |||||
.desc = &usb_config_1.config, | |||||
.function = {&dfu_function}, | |||||
}; | |||||
static const struct usb_desc_dev_t dfu_device_dev_desc = { | |||||
.bLength = sizeof(struct usb_desc_dev_t), | |||||
.bDescriptorType = USB_DESC_DEV, | |||||
.bcdUSB = { .maj = 2 }, | |||||
.bDeviceClass = USB_DEV_CLASS_SEE_IFACE, | |||||
.bDeviceSubClass = USB_DEV_SUBCLASS_SEE_IFACE, | |||||
.bDeviceProtocol = USB_DEV_PROTO_SEE_IFACE, | |||||
.bMaxPacketSize0 = EP0_BUFSIZE, | |||||
.idVendor = VENDOR_ID, | |||||
.idProduct = PRODUCT_ID, | |||||
.bcdDevice = { .raw = 0 }, | |||||
.iManufacturer = 1, | |||||
.iProduct = 2, | |||||
.iSerialNumber = 3, | |||||
.bNumConfigurations = 1, | |||||
}; | |||||
static const struct usb_desc_string_t * const dfu_device_str_desc[] = { | |||||
USB_DESC_STRING_LANG_ENUS, | |||||
USB_DESC_STRING(STR_MANUFACTURER), | |||||
USB_DESC_STRING(STR_PRODUCT), | |||||
USB_DESC_STRING(STR_SERIAL), | |||||
NULL | |||||
}; | |||||
const struct usbd_device dfu_device = { | |||||
.dev_desc = &dfu_device_dev_desc, | |||||
.string_descs = dfu_device_str_desc, | |||||
.configs = { | |||||
&usbd_config_1, | |||||
NULL | |||||
} | |||||
}; | |||||
// Originally Generated from MCHCK Toolkit | |||||
/* Copyright (c) Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef __DFU_DESC_H | |||||
#define __DFU_DESC_H | |||||
// ----- Local Includes ----- | |||||
#include "mchck.h" | |||||
// ----- Variables ----- | |||||
const struct usbd_device dfu_device; | |||||
usbd_init_fun_t init_usb_bootloader; | |||||
// ----- Structs ----- | |||||
struct usb_config_1 { | |||||
struct usb_desc_config_t config; | |||||
struct dfu_function_desc usb_function_0; | |||||
}; | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef _USB_DFU_H | |||||
#define _USB_DFU_H | |||||
// ----- Compiler Includes ----- | |||||
#include <sys/types.h> | |||||
// ----- Defines ----- | |||||
#define USB_FUNCTION_DFU_IFACE_COUNT 1 | |||||
#ifndef USB_DFU_TRANSFER_SIZE | |||||
#define USB_DFU_TRANSFER_SIZE FLASH_SECTOR_SIZE | |||||
#endif | |||||
#define USB_FUNCTION_DESC_DFU_DECL \ | |||||
struct dfu_function_desc | |||||
#define USB_FUNCTION_DFU_IFACE_COUNT 1 | |||||
#define USB_FUNCTION_DFU_RX_EP_COUNT 0 | |||||
#define USB_FUNCTION_DFU_TX_EP_COUNT 0 | |||||
// ----- Macros ----- | |||||
#define USB_FUNCTION_DESC_DFU(state...) \ | |||||
{ \ | |||||
.iface = { \ | |||||
.bLength = sizeof(struct usb_desc_iface_t), \ | |||||
.bDescriptorType = USB_DESC_IFACE, \ | |||||
.bInterfaceNumber = USB_FUNCTION_IFACE(0, state), \ | |||||
.bAlternateSetting = 0, \ | |||||
.bNumEndpoints = 0, \ | |||||
.bInterfaceClass = USB_DEV_CLASS_APP, \ | |||||
.bInterfaceSubClass = USB_DEV_SUBCLASS_APP_DFU, \ | |||||
.bInterfaceProtocol = USB_DEV_PROTO_DFU_DFU, \ | |||||
.iInterface = 0, \ | |||||
}, \ | |||||
.dfu = { \ | |||||
.bLength = sizeof(struct dfu_desc_functional), \ | |||||
.bDescriptorType = { \ | |||||
.id = 0x1, \ | |||||
.type_type = USB_DESC_TYPE_CLASS \ | |||||
}, \ | |||||
.will_detach = 1, \ | |||||
.manifestation_tolerant = 0, \ | |||||
.can_upload = 0, \ | |||||
.can_download = 1, \ | |||||
.wDetachTimeOut = 0, \ | |||||
.wTransferSize = USB_DFU_TRANSFER_SIZE, \ | |||||
.bcdDFUVersion = { .maj = 1, .min = 1 } \ | |||||
} \ | |||||
} | |||||
// ----- Enumerations ----- | |||||
enum dfu_dev_subclass { | |||||
USB_DEV_SUBCLASS_APP_DFU = 0x01 | |||||
}; | |||||
enum dfu_dev_proto { | |||||
USB_DEV_PROTO_DFU_APP = 0x01, | |||||
USB_DEV_PROTO_DFU_DFU = 0x02 | |||||
}; | |||||
enum dfu_ctrl_req_code { | |||||
USB_CTRL_REQ_DFU_DETACH = 0, | |||||
USB_CTRL_REQ_DFU_DNLOAD = 1, | |||||
USB_CTRL_REQ_DFU_UPLOAD = 2, | |||||
USB_CTRL_REQ_DFU_GETSTATUS = 3, | |||||
USB_CTRL_REQ_DFU_CLRSTATUS = 4, | |||||
USB_CTRL_REQ_DFU_GETSTATE = 5, | |||||
USB_CTRL_REQ_DFU_ABORT = 6 | |||||
}; | |||||
enum dfu_status { | |||||
DFU_STATUS_async = 0xff, | |||||
DFU_STATUS_OK = 0x00, | |||||
DFU_STATUS_errTARGET = 0x01, | |||||
DFU_STATUS_errFILE = 0x02, | |||||
DFU_STATUS_errWRITE = 0x03, | |||||
DFU_STATUS_errERASE = 0x04, | |||||
DFU_STATUS_errCHECK_ERASED = 0x05, | |||||
DFU_STATUS_errPROG = 0x06, | |||||
DFU_STATUS_errVERIFY = 0x07, | |||||
DFU_STATUS_errADDRESS = 0x08, | |||||
DFU_STATUS_errNOTDONE = 0x09, | |||||
DFU_STATUS_errFIRMWARE = 0x0a, | |||||
DFU_STATUS_errVENDOR = 0x0b, | |||||
DFU_STATUS_errUSBR = 0x0c, | |||||
DFU_STATUS_errPOR = 0x0d, | |||||
DFU_STATUS_errUNKNOWN = 0x0e, | |||||
DFU_STATUS_errSTALLEDPKT = 0x0f | |||||
}; | |||||
enum dfu_state { | |||||
DFU_STATE_appIDLE = 0, | |||||
DFU_STATE_appDETACH = 1, | |||||
DFU_STATE_dfuIDLE = 2, | |||||
DFU_STATE_dfuDNLOAD_SYNC = 3, | |||||
DFU_STATE_dfuDNBUSY = 4, | |||||
DFU_STATE_dfuDNLOAD_IDLE = 5, | |||||
DFU_STATE_dfuMANIFEST_SYNC = 6, | |||||
DFU_STATE_dfuMANIFEST = 7, | |||||
DFU_STATE_dfuMANIFEST_WAIT_RESET = 8, | |||||
DFU_STATE_dfuUPLOAD_IDLE = 9, | |||||
DFU_STATE_dfuERROR = 10 | |||||
}; | |||||
// ----- Structs ----- | |||||
struct dfu_status_t { | |||||
enum dfu_status bStatus : 8; | |||||
uint32_t bwPollTimeout : 24; | |||||
enum dfu_state bState : 8; | |||||
uint8_t iString; | |||||
} __packed; | |||||
CTASSERT_SIZE_BYTE(struct dfu_status_t, 6); | |||||
typedef enum dfu_status (*dfu_setup_write_t)(size_t off, size_t len, void **buf); | |||||
typedef enum dfu_status (*dfu_finish_write_t)(void *, size_t off, size_t len); | |||||
typedef void (*dfu_detach_t)(void); | |||||
struct dfu_ctx { | |||||
struct usbd_function_ctx_header header; | |||||
enum dfu_state state; | |||||
enum dfu_status status; | |||||
dfu_setup_write_t setup_write; | |||||
dfu_finish_write_t finish_write; | |||||
size_t off; | |||||
size_t len; | |||||
}; | |||||
struct dfu_desc_functional { | |||||
uint8_t bLength; | |||||
struct usb_desc_type_t bDescriptorType; /* = class DFU/0x1 FUNCTIONAL */ | |||||
union { | |||||
struct { | |||||
uint8_t can_download : 1; | |||||
uint8_t can_upload : 1; | |||||
uint8_t manifestation_tolerant : 1; | |||||
uint8_t will_detach : 1; | |||||
uint8_t _rsvd0 : 4; | |||||
}; | |||||
uint8_t bmAttributes; | |||||
}; | |||||
uint16_t wDetachTimeOut; | |||||
uint16_t wTransferSize; | |||||
struct usb_bcd_t bcdDFUVersion; | |||||
} __packed; | |||||
CTASSERT_SIZE_BYTE(struct dfu_desc_functional, 9); | |||||
struct dfu_function_desc { | |||||
struct usb_desc_iface_t iface; | |||||
struct dfu_desc_functional dfu; | |||||
}; | |||||
extern const struct usbd_function dfu_function; | |||||
extern const struct usbd_function dfu_app_function; | |||||
// ----- Functions ----- | |||||
void dfu_write_done(enum dfu_status, struct dfu_ctx *ctx); | |||||
void dfu_init(dfu_setup_write_t setup_write, dfu_finish_write_t finish_write, struct dfu_ctx *ctx); | |||||
void dfu_app_init(dfu_detach_t detachcb); | |||||
#endif |
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
// ----- Local Includes ----- | |||||
#include "mchck.h" | |||||
// ----- Variables ----- | |||||
uint32_t flash_ALLOW_BRICKABLE_ADDRESSES; | |||||
// ----- Functions ----- | |||||
/* This will have to live in SRAM. */ | |||||
__attribute__((section(".ramtext.ftfl_submit_cmd"), long_call)) | |||||
int ftfl_submit_cmd(void) | |||||
{ | |||||
FTFL.fstat.raw = ((struct FTFL_FSTAT_t){ | |||||
.ccif = 1, | |||||
.rdcolerr = 1, | |||||
.accerr = 1, | |||||
.fpviol = 1 | |||||
}).raw; | |||||
struct FTFL_FSTAT_t stat; | |||||
while (!(stat = FTFL.fstat).ccif) | |||||
/* NOTHING */; /* XXX maybe WFI? */ | |||||
return (!!stat.mgstat0); | |||||
} | |||||
int flash_prepare_flashing(void) | |||||
{ | |||||
/* switch to FlexRAM */ | |||||
if (!FTFL.fcnfg.ramrdy) { | |||||
FTFL.fccob.set_flexram.fcmd = FTFL_FCMD_SET_FLEXRAM; | |||||
FTFL.fccob.set_flexram.flexram_function = FTFL_FLEXRAM_RAM; | |||||
return (ftfl_submit_cmd()); | |||||
} | |||||
return (0); | |||||
} | |||||
int flash_erase_sector(uintptr_t addr) | |||||
{ | |||||
if (addr < (uintptr_t)&_app_rom && | |||||
flash_ALLOW_BRICKABLE_ADDRESSES != 0x00023420) | |||||
return (-1); | |||||
FTFL.fccob.erase.fcmd = FTFL_FCMD_ERASE_SECTOR; | |||||
FTFL.fccob.erase.addr = addr; | |||||
return (ftfl_submit_cmd()); | |||||
} | |||||
int flash_program_section(uintptr_t addr, size_t num_words) | |||||
{ | |||||
GPIOA_PSOR |= (1<<19); | |||||
FTFL.fccob.program_section.fcmd = FTFL_FCMD_PROGRAM_SECTION; | |||||
FTFL.fccob.program_section.addr = addr; | |||||
FTFL.fccob.program_section.num_words = num_words; | |||||
return (ftfl_submit_cmd()); | |||||
} | |||||
int flash_program_sector(uintptr_t addr, size_t len) | |||||
{ | |||||
return (len != FLASH_SECTOR_SIZE || | |||||
(addr & (FLASH_SECTOR_SIZE - 1)) != 0 || | |||||
flash_erase_sector(addr) || | |||||
flash_program_section(addr, FLASH_SECTOR_SIZE/4)); | |||||
} | |||||
void *flash_get_staging_area(uintptr_t addr, size_t len) | |||||
{ | |||||
if ((addr & (FLASH_SECTOR_SIZE - 1)) != 0 || | |||||
len != FLASH_SECTOR_SIZE) | |||||
return (NULL); | |||||
return (FlexRAM); | |||||
} | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef __FLASH_H | |||||
#define __FLASH_H | |||||
// ----- Defines ----- | |||||
#define FLASH_SECTOR_SIZE 1024 | |||||
// ----- Functions ----- | |||||
__attribute__((section(".ramtext.ftfl_submit_cmd"), long_call)) | |||||
int ftfl_submit_cmd(void); | |||||
int flash_prepare_flashing(void); | |||||
int flash_erase_sector(uintptr_t); | |||||
int flash_program_section(uintptr_t, size_t); | |||||
int flash_program_sector(uintptr_t, size_t); | |||||
void *flash_get_staging_area(uintptr_t, size_t); | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef __FTFL_H | |||||
#define __FTFL_H | |||||
// ----- Local Includes ----- | |||||
#include "mchck-cdefs.h" | |||||
// ----- Structs ----- | |||||
struct FTFL_FSTAT_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t mgstat0 : 1; | |||||
uint8_t _rsvd0 : 3; | |||||
uint8_t fpviol : 1; | |||||
uint8_t accerr : 1; | |||||
uint8_t rdcolerr : 1; | |||||
uint8_t ccif : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct FTFL_FSTAT_t, 8); | |||||
struct FTFL_FCNFG_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t eeerdy : 1; | |||||
uint8_t ramrdy : 1; | |||||
uint8_t pflsh : 1; | |||||
uint8_t _rsvd0 : 1; | |||||
uint8_t erssusp : 1; | |||||
uint8_t ersareq : 1; | |||||
uint8_t rdcollie : 1; | |||||
uint8_t ccie : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct FTFL_FCNFG_t, 8); | |||||
struct FTFL_FSEC_t { | |||||
UNION_STRUCT_START(8); | |||||
enum { | |||||
FTFL_FSEC_SEC_UNSECURE = 2, | |||||
FTFL_FSEC_SEC_SECURE = 3 | |||||
} sec : 2; | |||||
enum { | |||||
FTFL_FSEC_FSLACC_DENY = 1, | |||||
FTFL_FSEC_FSLACC_GRANT = 3 | |||||
} fslacc : 2; | |||||
enum { | |||||
FTFL_FSEC_MEEN_DISABLE = 2, | |||||
FTFL_FSEC_MEEN_ENABLE = 3 | |||||
} meen : 2; | |||||
enum { | |||||
FTFL_FSEC_KEYEN_DISABLE = 1, | |||||
FTFL_FSEC_KEYEN_ENABLE = 2 | |||||
} keyen : 2; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct FTFL_FSEC_t, 8); | |||||
struct FTFL_FOPT_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t lpboot : 1; | |||||
uint8_t ezport_dis : 1; | |||||
uint8_t nmi_dis : 1; | |||||
uint8_t _rsvd0 : 5; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct FTFL_FOPT_t, 8); | |||||
/** | |||||
* The FCOOB is a weird register file, because it is double big endian, | |||||
* which makes for odd gaps and for some data that is big endian, and for | |||||
* some that is little endian. | |||||
*/ | |||||
union FTFL_FCCOB_t { | |||||
struct ftfl_generic { | |||||
uint32_t addr : 24; | |||||
enum FTFL_FCMD { | |||||
FTFL_FCMD_READ_1s_BLOCK = 0x00, | |||||
FTFL_FCMD_READ_1s_SECTION = 0x01, | |||||
FTFL_FCMD_PROGRAM_CHECK = 0x02, | |||||
FTFL_FCMD_READ_RESOURCE = 0x03, | |||||
FTFL_FCMD_PROGRAM_LONGWORD = 0x06, | |||||
FTFL_FCMD_ERASE_BLOCK = 0x08, | |||||
FTFL_FCMD_ERASE_SECTOR = 0x09, | |||||
FTFL_FCMD_PROGRAM_SECTION = 0x0b, | |||||
FTFL_FCMD_READ_1s_ALL_BLOCKS = 0x40, | |||||
FTFL_FCMD_READ_ONCE = 0x41, | |||||
FTFL_FCMD_PROGRAM_ONCE = 0x43, | |||||
FTFL_FCMD_ERASE_ALL_BLOCKS = 0x44, | |||||
FTFL_FCMD_VERIFY_KEY = 0x45, | |||||
FTFL_FCMD_PROGRAM_PARTITION = 0x80, | |||||
FTFL_FCMD_SET_FLEXRAM = 0x81 | |||||
} fcmd : 8; | |||||
uint8_t data_be[8]; | |||||
} generic; | |||||
struct { | |||||
uint32_t addr : 24; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
uint8_t _rsvd0[3]; | |||||
enum FTFL_MARGIN_CHOICE { | |||||
FTFL_MARGIN_NORMAL = 0x00, | |||||
FTFL_MARGIN_USER = 0x01, | |||||
FTFL_MARGIN_FACTORY = 0x02 | |||||
} margin : 8; | |||||
} read_1s_block; | |||||
struct ftfl_data_num_words { | |||||
uint32_t addr : 24; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
uint8_t _rsvd0; | |||||
enum FTFL_MARGIN_CHOICE margin : 8; | |||||
uint16_t num_words; | |||||
} read_1s_section; | |||||
struct { | |||||
uint32_t addr : 24; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
uint8_t _rsvd0[3]; | |||||
enum FTFL_MARGIN_CHOICE margin : 8; | |||||
uint8_t data_be[4]; | |||||
} program_check; | |||||
struct { | |||||
uint32_t addr : 24; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
uint32_t data; | |||||
uint8_t _rsvd0[3]; | |||||
enum FTFL_RESOURCE_SELECT { | |||||
FTFL_RESOURCE_IFR = 0x00, | |||||
FTFL_RESOURCE_VERSION = 0x01 | |||||
} resource_select : 8; | |||||
} read_resource; | |||||
struct { | |||||
uint32_t addr : 24; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
uint8_t data_be[4]; | |||||
} program_longword; | |||||
struct { | |||||
uint32_t addr : 24; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
} erase; | |||||
struct ftfl_data_num_words program_section; | |||||
struct { | |||||
uint8_t _rsvd0[2]; | |||||
enum FTFL_MARGIN_CHOICE margin : 8; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
} read_1s_all_blocks; | |||||
struct ftfl_cmd_once { | |||||
uint8_t _rsvd0[2]; | |||||
uint8_t idx; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
uint8_t data_be[4]; | |||||
} read_once; | |||||
struct ftfl_cmd_once program_once; | |||||
struct { | |||||
uint8_t _rsvd0[3]; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
} erase_all; | |||||
struct { | |||||
uint8_t _rsvd0[3]; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
uint8_t key_be[8]; | |||||
} verify_key; | |||||
struct { | |||||
uint8_t _rsvd0[3]; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
uint8_t _rsvd1[2]; | |||||
/* the following enum is analogous to enum | |||||
* SIM_FLEXNVM_PARTITION in sim.h, but this one is padded | |||||
* with four 1-bits to make an 8-bit value. | |||||
*/ | |||||
enum FTFL_FLEXNVM_PARTITION { | |||||
FTFL_FLEXNVM_DATA_32_EEPROM_0 = 0xF0, | |||||
FTFL_FLEXNVM_DATA_24_EEPROM_8 = 0xF1, | |||||
FTFL_FLEXNVM_DATA_16_EEPROM_16 = 0xF2, | |||||
FTFL_FLEXNVM_DATA_8_EEPROM_24 = 0xF9, | |||||
FTFL_FLEXNVM_DATA_0_EEPROM_32 = 0xF3 | |||||
} flexnvm_partition : 8; | |||||
enum FTFL_EEPROM_SIZE { | |||||
FTFL_EEPROM_SIZE_0 = 0x3f, | |||||
FTFL_EEPROM_SIZE_32 = 0x39, | |||||
FTFL_EEPROM_SIZE_64 = 0x38, | |||||
FTFL_EEPROM_SIZE_128 = 0x37, | |||||
FTFL_EEPROM_SIZE_256 = 0x36, | |||||
FTFL_EEPROM_SIZE_512 = 0x35, | |||||
FTFL_EEPROM_SIZE_1024 = 0x34, | |||||
FTFL_EEPROM_SIZE_2048 = 0x33 | |||||
} eeprom_size : 8; | |||||
} program_partition; | |||||
struct { | |||||
uint8_t _rsvd0[2]; | |||||
enum FTFL_FLEXRAM_FUNCTION { | |||||
FTFL_FLEXRAM_EEPROM = 0x00, | |||||
FTFL_FLEXRAM_RAM = 0xff | |||||
} flexram_function : 8; | |||||
enum FTFL_FCMD fcmd : 8; | |||||
} set_flexram; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(union FTFL_FCCOB_t, 12); | |||||
struct FTFL_t { | |||||
struct FTFL_FSTAT_t fstat; | |||||
struct FTFL_FCNFG_t fcnfg; | |||||
struct FTFL_FSEC_t fsec; | |||||
struct FTFL_FOPT_t fopt; | |||||
union FTFL_FCCOB_t fccob; | |||||
uint8_t fprot_be[4]; | |||||
uint8_t feprot; | |||||
uint8_t fdprot; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct FTFL_t, 0x18); | |||||
/* Flash Configuration Field, see Sub-Family Reference Manual, section 28.3.1 */ | |||||
struct FTFL_CONFIG_t { | |||||
uint8_t key[8]; | |||||
uint8_t fprot[4]; | |||||
struct FTFL_FSEC_t fsec; | |||||
struct FTFL_FOPT_t fopt; | |||||
uint8_t feprot; | |||||
uint8_t fdprot; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct FTFL_CONFIG_t, 16); | |||||
extern volatile struct FTFL_t FTFL; | |||||
extern char FlexRAM[]; | |||||
extern struct FTFL_CONFIG_t FTFL_CONFIG; | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
// ----- Defines ----- | |||||
#define usb_xfer_info USB_STAT_t | |||||
// ----- Local Includes ----- | |||||
#include "mchck.h" | |||||
#include "usb-internal.h" | |||||
// ----- Functions ----- | |||||
/** | |||||
* Kinetis USB driver notes: | |||||
* We need to manually maintain the DATA0/1 toggling for the SIE. | |||||
* SETUP transactions always start with a DATA0. | |||||
* | |||||
* The SIE internally uses pingpong (double) buffering, which is | |||||
* easily confused with DATA0/DATA1 toggling, and I think even the | |||||
* Freescale docs confuse the two notions. When BD->DTS is set, | |||||
* BD->DATA01 will be used to verify/discard incoming DATAx and it | |||||
* will set the DATAx PID for outgoing tokens. This is not described | |||||
* as such in the Freescale Kinetis docs, but the Microchip PIC32 OTG | |||||
* docs are more clear on this; it seems that both Freescale and | |||||
* Microchip use different versions of the same USB OTG IP core. | |||||
* | |||||
* http://ww1.microchip.com/downloads/en/DeviceDoc/61126F.pdf | |||||
* | |||||
* Clear CTL->TOKEN_BUSY after SETUP tokens. | |||||
*/ | |||||
static struct USB_BD_t bdt[USB_MAX_EP * 2 *2] __attribute__((section(".usbdescriptortable"))); | |||||
static struct USB_BD_t * | |||||
usb_get_bd(struct usbd_ep_pipe_state_t *s) | |||||
{ | |||||
return (&bdt[(s->ep_num << 2) | (s->ep_dir << 1) | s->pingpong]); | |||||
} | |||||
static struct USB_BD_t * | |||||
usb_get_bd_stat(struct USB_STAT_t *stat) | |||||
{ | |||||
return (((void *)(uintptr_t)bdt + (stat->raw << 1))); | |||||
} | |||||
void *usb_get_xfer_data(struct usb_xfer_info *i) | |||||
{ | |||||
return (usb_get_bd_stat(i)->addr); | |||||
} | |||||
enum usb_tok_pid usb_get_xfer_pid(struct usb_xfer_info *i) | |||||
{ | |||||
return (usb_get_bd_stat(i)->tok_pid); | |||||
} | |||||
int usb_get_xfer_ep(struct usb_xfer_info *i) | |||||
{ | |||||
return (i->ep); | |||||
} | |||||
enum usb_ep_dir usb_get_xfer_dir(struct usb_xfer_info *i) | |||||
{ | |||||
return (i->dir); | |||||
} | |||||
void usb_enable_xfers(void) | |||||
{ | |||||
USB0.ctl.raw = ((struct USB_CTL_t){ | |||||
.txd_suspend = 0, | |||||
.usben = 1 | |||||
}).raw; | |||||
} | |||||
void usb_set_addr(int addr) | |||||
{ | |||||
USB0.addr.raw = addr; | |||||
} | |||||
void usb_pipe_stall(struct usbd_ep_pipe_state_t *s) | |||||
{ | |||||
volatile struct USB_BD_t *bd = usb_get_bd(s); | |||||
bd->raw = ((struct USB_BD_BITS_t){ | |||||
.stall = 1, | |||||
.own = 1 | |||||
}).raw; | |||||
} | |||||
void usb_pipe_unstall(struct usbd_ep_pipe_state_t *s) | |||||
{ | |||||
volatile struct USB_BD_t *bd = usb_get_bd(s); | |||||
struct USB_BD_BITS_t state = { .raw = bd->raw }; | |||||
if (state.own && state.stall) | |||||
bd->raw = 0; | |||||
} | |||||
void usb_pipe_enable(struct usbd_ep_pipe_state_t *s) | |||||
{ | |||||
USB0.endpt[s->ep_num].raw |= ((struct USB_ENDPT_t){ | |||||
.eptxen = s->ep_dir == USB_EP_TX, | |||||
.eprxen = s->ep_dir == USB_EP_RX, | |||||
.ephshk = 1, /* XXX ISO */ | |||||
.epctldis = s->ep_num != 0 | |||||
}).raw; | |||||
} | |||||
void usb_pipe_disable(struct usbd_ep_pipe_state_t *s) | |||||
{ | |||||
USB0.endpt[s->ep_num].raw &= ~((struct USB_ENDPT_t){ | |||||
.eptxen = s->ep_dir == USB_EP_TX, | |||||
.eprxen = s->ep_dir == USB_EP_RX, | |||||
.epctldis = 1 | |||||
}).raw; | |||||
} | |||||
size_t usb_ep_get_transfer_size(struct usbd_ep_pipe_state_t *s) | |||||
{ | |||||
struct USB_BD_t *bd = usb_get_bd(s); | |||||
return (bd->bc); | |||||
} | |||||
void usb_queue_next(struct usbd_ep_pipe_state_t *s, void *addr, size_t len) | |||||
{ | |||||
volatile struct USB_BD_t *bd = usb_get_bd(s); | |||||
bd->addr = addr; | |||||
/* damn you bitfield problems */ | |||||
bd->raw = ((struct USB_BD_BITS_t){ | |||||
.dts = 1, | |||||
.own = 1, | |||||
.data01 = s->data01, | |||||
.bc = len, | |||||
}).raw; | |||||
} | |||||
static void usb_reset(void) | |||||
{ | |||||
/* reset pingpong state */ | |||||
/* For some obscure reason, we need to use or here. */ | |||||
USB0.ctl.raw |= ((struct USB_CTL_t){ | |||||
.txd_suspend = 1, | |||||
.oddrst = 1, | |||||
}).raw; | |||||
/* clear all interrupt bits - not sure if needed */ | |||||
USB0.istat.raw = 0xff; | |||||
USB0.errstat.raw = 0xff; | |||||
USB0.otgistat.raw = 0xff; | |||||
/* zap also BDT pingpong & queued transactions */ | |||||
memset(bdt, 0, sizeof(bdt)); | |||||
USB0.addr.raw = 0; | |||||
usb_restart(); | |||||
USB0.ctl.raw = ((struct USB_CTL_t){ | |||||
.txd_suspend = 0, | |||||
.usben = 1 | |||||
}).raw; | |||||
/* we're only interested in reset and transfers */ | |||||
USB0.inten.raw = ((struct USB_ISTAT_t){ | |||||
.tokdne = 1, | |||||
.usbrst = 1, | |||||
.stall = 1, | |||||
.sleep = 1, | |||||
}).raw; | |||||
USB0.usbtrc0.usbresmen = 0; | |||||
USB0.usbctrl.susp = 0; | |||||
} | |||||
void usb_enable(void) | |||||
{ | |||||
SIM.sopt2.usbsrc = 1; /* usb from mcg */ | |||||
SIM.scgc4.usbotg = 1; /* enable usb clock */ | |||||
/* reset module - not sure if needed */ | |||||
USB0.usbtrc0.raw = ((struct USB_USBTRC0_t){ | |||||
.usbreset = 1, | |||||
.usbresmen = 1 | |||||
}).raw; | |||||
while (USB0.usbtrc0.usbreset) | |||||
/* NOTHING */; | |||||
USB0.bdtpage1 = (uintptr_t)bdt >> 8; | |||||
USB0.bdtpage2 = (uintptr_t)bdt >> 16; | |||||
USB0.bdtpage3 = (uintptr_t)bdt >> 24; | |||||
USB0.control.raw = ((struct USB_CONTROL_t){ | |||||
.dppullupnonotg = 1 /* enable pullup */ | |||||
}).raw; | |||||
USB0.usbctrl.raw = 0; /* resume peripheral & disable pulldowns */ | |||||
usb_reset(); /* this will start usb processing */ | |||||
/* really only one thing we want */ | |||||
USB0.inten.raw = ((struct USB_ISTAT_t){ | |||||
.usbrst = 1, | |||||
}).raw; | |||||
/** | |||||
* Suspend transceiver now - we'll wake up at reset again. | |||||
*/ | |||||
// TODO - Possible removal | |||||
USB0.usbctrl.susp = 1; | |||||
USB0.usbtrc0.usbresmen = 1; | |||||
} | |||||
void USB0_Handler(void) | |||||
{ | |||||
struct USB_ISTAT_t stat = {.raw = USB0.istat.raw }; | |||||
if (stat.usbrst) { | |||||
usb_reset(); | |||||
return; | |||||
} | |||||
if (stat.stall) { | |||||
/* XXX need more work for non-0 ep */ | |||||
volatile struct USB_BD_t *bd = usb_get_bd(&usb.ep_state[0].rx); | |||||
if (bd->stall) | |||||
usb_setup_control(); | |||||
} | |||||
if (stat.tokdne) { | |||||
struct usb_xfer_info stat = USB0.stat; | |||||
usb_handle_transaction(&stat); | |||||
} | |||||
if (stat.sleep) { | |||||
USB0.inten.sleep = 0; | |||||
USB0.inten.resume = 1; | |||||
USB0.usbctrl.susp = 1; | |||||
USB0.usbtrc0.usbresmen = 1; | |||||
/** | |||||
* Clear interrupts now so that we can detect a fresh | |||||
* resume later on. | |||||
*/ | |||||
USB0.istat.raw = stat.raw; | |||||
const struct usbd_config *c = usb_get_config_data(-1); | |||||
if (c && c->suspend) | |||||
c->suspend(); | |||||
} | |||||
/** | |||||
* XXX it is unclear whether we will receive a synchronous | |||||
* resume interrupt if we were in sleep. This code assumes we | |||||
* do. | |||||
*/ | |||||
if (stat.resume || USB0.usbtrc0.usb_resume_int) { | |||||
USB0.inten.resume = 0; | |||||
USB0.inten.sleep = 1; | |||||
USB0.usbtrc0.usbresmen = 0; | |||||
USB0.usbctrl.susp = 0; | |||||
const struct usbd_config *c = usb_get_config_data(-1); | |||||
if (c && c->resume) | |||||
c->resume(); | |||||
stat.resume = 1; /* always clear bit */ | |||||
} | |||||
USB0.istat.raw = stat.raw; | |||||
} | |||||
void usb_poll(void) | |||||
{ | |||||
USB0_Handler(); | |||||
} | |||||
int usb_tx_serialno(size_t reqlen) | |||||
{ | |||||
struct usb_desc_string_t *d; | |||||
const size_t nregs = 3; | |||||
/** | |||||
* actually 4, but UIDH is 0xffffffff. Also our output buffer | |||||
* is only 64 bytes, and 128 bit + desc header exceeds this by | |||||
* 2 bytes. | |||||
*/ | |||||
const size_t len = nregs * 4 * 2 * 2 + sizeof(*d); | |||||
d = usb_ep0_tx_inplace_prepare(len); | |||||
if (d == NULL) | |||||
return (-1); | |||||
d->bLength = len; | |||||
d->bDescriptorType = USB_DESC_STRING; | |||||
size_t bufpos = 0; | |||||
for (size_t reg = 0; reg < nregs; ++reg) { | |||||
/* registers run MSW first */ | |||||
uint32_t val = (&SIM.uidmh)[reg]; | |||||
for (size_t bits = 32; bits > 0; bits -= 4, val <<= 4) { | |||||
int nibble = val >> 28; | |||||
if (nibble > 9) | |||||
nibble += 'a' - '9' - 1; | |||||
((char16_t *)d->bString)[bufpos++] = nibble + '0'; | |||||
} | |||||
} | |||||
usb_ep0_tx(d, len, reqlen, NULL, NULL); | |||||
return (0); | |||||
} | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
// ----- Local Includes ----- | |||||
#include "mchck.h" | |||||
#include "dfu.desc.h" | |||||
// ----- Variables ----- | |||||
/** | |||||
* Unfortunately we can't DMA directly to FlexRAM, so we'll have to stage here. | |||||
*/ | |||||
static char staging[FLASH_SECTOR_SIZE]; | |||||
// ----- Functions ----- | |||||
static enum dfu_status setup_write(size_t off, size_t len, void **buf) | |||||
{ | |||||
static int last = 0; | |||||
if (len > sizeof(staging)) | |||||
return (DFU_STATUS_errADDRESS); | |||||
// We only allow the last write to be less than one sector size. | |||||
if (off == 0) | |||||
last = 0; | |||||
if (last && len != 0) | |||||
return (DFU_STATUS_errADDRESS); | |||||
if (len != FLASH_SECTOR_SIZE) { | |||||
last = 1; | |||||
memset(staging, 0xff, sizeof(staging)); | |||||
} | |||||
*buf = staging; | |||||
return (DFU_STATUS_OK); | |||||
} | |||||
static enum dfu_status finish_write( void *buf, size_t off, size_t len ) | |||||
{ | |||||
void *target; | |||||
if (len == 0) | |||||
return (DFU_STATUS_OK); | |||||
target = flash_get_staging_area(off + (uintptr_t)&_app_rom, FLASH_SECTOR_SIZE); | |||||
if (!target) | |||||
return (DFU_STATUS_errADDRESS); | |||||
memcpy(target, buf, len); | |||||
if (flash_program_sector(off + (uintptr_t)&_app_rom, FLASH_SECTOR_SIZE) != 0) | |||||
return (DFU_STATUS_errADDRESS); | |||||
return (DFU_STATUS_OK); | |||||
} | |||||
static struct dfu_ctx dfu_ctx; | |||||
void init_usb_bootloader( int config ) | |||||
{ | |||||
dfu_init(setup_write, finish_write, &dfu_ctx); | |||||
} | |||||
void main() | |||||
{ | |||||
// Enabling LED to indicate we are in the bootloader | |||||
GPIOA_PDDR |= (1<<19); | |||||
// Setup pin - A19 - See Lib/pin_map.mchck for more details on pins | |||||
PORTA_PCR19 = PORT_PCR_SRE | PORT_PCR_DSE | PORT_PCR_MUX(1); | |||||
GPIOA_PSOR |= (1<<19); | |||||
flash_prepare_flashing(); | |||||
usb_init( &dfu_device ); | |||||
for (;;) | |||||
{ | |||||
usb_poll(); | |||||
} | |||||
} | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef _MCHCK_CDEFS_H | |||||
#define _MCHCK_CDEFS_H | |||||
// ----- Compiler Includes ----- | |||||
#include <sys/param.h> | |||||
// ----- Defines & Macros ----- | |||||
#define _CONCAT(x,y) _CONCAT1(x,y) | |||||
#define _CONCAT1(x,y) x ## y | |||||
#define _STR(a) #a | |||||
typedef __CHAR16_TYPE__ char16_t; | |||||
#define __packed __attribute__((__packed__)) | |||||
/* From FreeBSD: compile-time asserts */ | |||||
#define CTASSERT(x) _Static_assert(x, _STR(x)) | |||||
#define CTASSERT_SIZE_BYTE(t, s) CTASSERT(sizeof(t) == (s)) | |||||
#define CTASSERT_SIZE_BIT(t, s) CTASSERT(sizeof(t) * 8 == (s)) | |||||
#define UNION_STRUCT_START(size) \ | |||||
union { \ | |||||
_CONCAT(_CONCAT(uint, size), _t) raw; \ | |||||
struct { \ | |||||
/* just to swallow the following semicolon */ \ | |||||
struct _CONCAT(_CONCAT(__dummy_, __COUNTER__), _t) {} | |||||
#define UNION_STRUCT_END \ | |||||
}; /* struct */ \ | |||||
}; /* union */ | |||||
/** | |||||
* From <news:[email protected]>, | |||||
* <https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s> | |||||
*/ | |||||
#define __PP_NARG(...) \ | |||||
__PP_NARG_(__0, ## __VA_ARGS__, __PP_RSEQ_N()) | |||||
#define __PP_NARG_(...) \ | |||||
__PP_ARG_N(__VA_ARGS__) | |||||
#define __PP_ARG_N( \ | |||||
_1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \ | |||||
_11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \ | |||||
_21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \ | |||||
_31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \ | |||||
_41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \ | |||||
_51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \ | |||||
_61,_62,_63,N,...) N | |||||
#define __PP_RSEQ_N() \ | |||||
62,61,60, \ | |||||
59,58,57,56,55,54,53,52,51,50, \ | |||||
49,48,47,46,45,44,43,42,41,40, \ | |||||
39,38,37,36,35,34,33,32,31,30, \ | |||||
29,28,27,26,25,24,23,22,21,20, \ | |||||
19,18,17,16,15,14,13,12,11,10, \ | |||||
9,8,7,6,5,4,3,2,1,0 | |||||
/** | |||||
* From <https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms> | |||||
*/ | |||||
#define __CAT(a, ...) __PRIMITIVE_CAT(a, __VA_ARGS__) | |||||
#define __PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__ | |||||
#define __IIF(c) __PRIMITIVE_CAT(__IIF_, c) | |||||
#define __IIF_0(t, ...) __VA_ARGS__ | |||||
#define __IIF_1(t, ...) t | |||||
#define __COMPL(b) __PRIMITIVE_CAT(__COMPL_, b) | |||||
#define __COMPL_0 1 | |||||
#define __COMPL_1 0 | |||||
#define __CHECK_N(x, n, ...) n | |||||
#define __CHECK(...) __CHECK_N(__VA_ARGS__, 0,) | |||||
#define __PROBE(x) x, 1, | |||||
#define __NOT(x) __CHECK(__PRIMITIVE_CAT(__NOT_, x)) | |||||
#define __NOT_0 __PROBE(~) | |||||
#define __BOOL(x) __COMPL(__NOT(x)) | |||||
#define __IF(c) __IIF(__BOOL(c)) | |||||
#define __EAT(...) | |||||
#define __EXPAND(...) __VA_ARGS__ | |||||
#define __WHEN(c) __IF(c)(__EXPAND, __EAT) | |||||
#define __HEAD(h, ...) h | |||||
#define __TAIL(h, ...) __VA_ARGS__ | |||||
#define __EVAL(...) __EVAL1(__EVAL1(__EVAL1(__VA_ARGS__))) | |||||
#define __EVAL1(...) __EVAL2(__EVAL2(__EVAL2(__VA_ARGS__))) | |||||
#define __EVAL2(...) __EVAL3(__EVAL3(__EVAL3(__VA_ARGS__))) | |||||
#define __EVAL3(...) __EVAL4(__EVAL4(__EVAL4(__VA_ARGS__))) | |||||
#define __EVAL4(...) __EVAL5(__EVAL5(__EVAL5(__VA_ARGS__))) | |||||
#define __EVAL5(...) __EVAL6(__EVAL6(__EVAL6(__VA_ARGS__))) | |||||
#define __EVAL6(...) __VA_ARGS__ | |||||
#define __EMPTY() | |||||
#define __DEFER(id) id __EMPTY() | |||||
#define __OBSTRUCT(...) __VA_ARGS__ __DEFER(__EMPTY)() | |||||
#define __CAT_ARG(f, a) __OBSTRUCT(f) a | |||||
#define __REPEAT(...) __EVAL(__REPEAT_(__VA_ARGS__)) | |||||
#define __REPEAT_INNER(...) __OBSTRUCT(__REPEAT_INDIRECT) () (__VA_ARGS__) | |||||
#define __REPEAT_INDIRECT() __REPEAT_ | |||||
#define __REPEAT_(iter, itermacro, macro, a, ...) \ | |||||
__OBSTRUCT(macro)(iter, a) \ | |||||
__WHEN(__PP_NARG(__VA_ARGS__)) \ | |||||
( \ | |||||
__OBSTRUCT(__REPEAT_INDIRECT) () ( \ | |||||
itermacro(iter, a), itermacro, macro, __VA_ARGS__ \ | |||||
) \ | |||||
) | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef __MCHCK_H | |||||
#define __MCHCK_H | |||||
// ----- Compiler Includes ----- | |||||
#include <sys/types.h> | |||||
#include <sys/cdefs.h> | |||||
#include <stdfix.h> | |||||
#include <stdarg.h> | |||||
// ----- Project Includes ----- | |||||
#include <mk20dx.h> | |||||
// ----- Local Includes ----- | |||||
#include "mchck-cdefs.h" | |||||
extern uint32_t _sidata, _sdata, _edata, _sbss, _ebss, _app_rom; | |||||
#include "ftfl.h" | |||||
#include "usbotg.h" | |||||
#include "sim.h" | |||||
#include "flash.h" | |||||
#include "usb.h" | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef __SIM_H | |||||
#define __SIM_H | |||||
// ----- Local Includes ----- | |||||
#include "mchck.h" | |||||
// ----- Structs ----- | |||||
struct SIM_t { | |||||
struct SIM_SOPT1_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t _rsvd0 : 12; | |||||
enum { | |||||
SIM_RAMSIZE_8KB = 1, | |||||
SIM_RAMSIZE_16KB = 3 | |||||
} ramsize : 4; | |||||
uint32_t _rsvd1 : 2; | |||||
enum { | |||||
SIM_OSC32KSEL_SYSTEM = 0, | |||||
SIM_OSC32KSEL_RTC = 2, | |||||
SIM_OSC32KSEL_LPO = 3 | |||||
} osc32ksel : 2; | |||||
uint32_t _rsvd2 : 9; | |||||
uint32_t usbvstby : 1; | |||||
uint32_t usbsstby : 1; | |||||
uint32_t usbregen : 1; | |||||
UNION_STRUCT_END; | |||||
} sopt1; | |||||
struct SIM_SOPT1CFG_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t _rsvd0 : 24; | |||||
uint32_t urwe : 1; | |||||
uint32_t uvswe : 1; | |||||
uint32_t usswe : 1; | |||||
uint32_t _rsvd1 : 5; | |||||
UNION_STRUCT_END; | |||||
} sopt1cfg; | |||||
uint32_t _pad0[(0x1004 - 0x8) / 4]; | |||||
struct SIM_SOPT2_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t _rsvd0 : 4; | |||||
enum { | |||||
SIM_RTCCLKOUTSEL_1HZ = 0, | |||||
SIM_RTCCLKOUTSEL_32KHZ = 1 | |||||
} rtcclkoutsel : 1; | |||||
enum { | |||||
SIM_CLKOUTSEL_FLASH = 2, | |||||
SIM_CLKOUTSEL_LPO = 3, | |||||
SIM_CLKOUTSEL_MCG = 4, | |||||
SIM_CLKOUTSEL_RTC = 5, | |||||
SIM_CLKOUTSEL_OSC = 6 | |||||
} clkoutsel : 3; | |||||
uint32_t _rsvd1 : 3; | |||||
enum { | |||||
SIM_PTD7PAD_SINGLE = 0, | |||||
SIM_PTD7PAD_DOUBLE = 1 | |||||
} ptd7pad : 1; | |||||
enum { | |||||
SIM_TRACECLKSEL_MCG = 0, | |||||
SIM_TRACECLKSEL_CORE = 1 | |||||
} traceclksel : 1; | |||||
uint32_t _rsvd2 : 3; | |||||
enum { | |||||
SIM_PLLFLLSEL_FLL = 0, | |||||
SIM_PLLFLLSEL_PLL = 1 | |||||
} pllfllsel : 1; | |||||
uint32_t _rsvd3 : 1; | |||||
enum { | |||||
SIM_USBSRC_EXTERNAL = 0, | |||||
SIM_USBSRC_MCG = 1 | |||||
} usbsrc : 1; | |||||
uint32_t _rsvd4 : 13; | |||||
UNION_STRUCT_END; | |||||
} sopt2; | |||||
uint32_t _pad1; | |||||
struct SIM_SOPT4_t { | |||||
UNION_STRUCT_START(32); | |||||
enum sim_ftmflt { | |||||
SIM_FTMFLT_FTM = 0, | |||||
SIM_FTMFLT_CMP = 1 | |||||
} ftm0flt0 : 1; | |||||
enum sim_ftmflt ftm0flt1 : 1; | |||||
uint32_t _rsvd0 : 2; | |||||
enum sim_ftmflt ftm1flt0 : 1; | |||||
uint32_t _rsvd1 : 13; | |||||
enum { | |||||
SIM_FTMCHSRC_FTM = 0, | |||||
SIM_FTMCHSRC_CMP0 = 1, | |||||
SIM_FTMCHSRC_CMP1 = 2, | |||||
SIM_FTMCHSRC_USBSOF = 3 | |||||
} ftm1ch0src : 2; | |||||
uint32_t _rsvd2 : 4; | |||||
enum sim_ftmclksel { | |||||
SIM_FTMCLKSEL_CLK0 = 0, | |||||
SIM_FTMCLKSEL_CLK1 = 1 | |||||
} ftm0clksel : 1; | |||||
enum sim_ftmclksel ftm1clksel : 1; | |||||
uint32_t _rsvd3 : 2; | |||||
enum { | |||||
SIM_FTMTRGSRC_HSCMP0 = 0, | |||||
SIM_FTMTRGSRC_FTM1 = 1 | |||||
} ftm0trg0src : 1; | |||||
uint32_t _rsvd4 : 3; | |||||
UNION_STRUCT_END; | |||||
} sopt4; | |||||
struct SIM_SOPT5_t { | |||||
UNION_STRUCT_START(32); | |||||
enum sim_uarttxsrc { | |||||
SIM_UARTTXSRC_UART = 0, | |||||
SIM_UARTTXSRC_FTM = 1 | |||||
} uart0txsrc : 1; | |||||
uint32_t _rsvd0 : 1; | |||||
enum sim_uartrxsrc { | |||||
SIM_UARTRXSRC_UART = 0, | |||||
SIM_UARTRXSRC_CMP0 = 1, | |||||
SIM_UARTRXSRC_CMP1 = 2 | |||||
} uart0rxsrc : 2; | |||||
enum sim_uarttxsrc uart1txsrc : 1; | |||||
uint32_t _rsvd1 : 1; | |||||
enum sim_uartrxsrc uart1rxsrc : 2; | |||||
uint32_t _rsvd2 : 24; | |||||
UNION_STRUCT_END; | |||||
} sopt5; | |||||
uint32_t _pad2; | |||||
struct SIM_SOPT7_t { | |||||
UNION_STRUCT_START(32); | |||||
enum { | |||||
SIM_ADCTRGSEL_PDB = 0, | |||||
SIM_ADCTRGSEL_HSCMP0 = 1, | |||||
SIM_ADCTRGSEL_HSCMP1 = 2, | |||||
SIM_ADCTRGSEL_PIT0 = 4, | |||||
SIM_ADCTRGSEL_PIT1 = 5, | |||||
SIM_ADCTRGSEL_PIT2 = 6, | |||||
SIM_ADCTRGSEL_PIT3 = 7, | |||||
SIM_ADCTRGSEL_FTM0 = 8, | |||||
SIM_ADCTRGSEL_FTM1 = 9, | |||||
SIM_ADCTRGSEL_RTCALARM = 12, | |||||
SIM_ADCTRGSEL_RTCSECS = 13, | |||||
SIM_ADCTRGSEL_LPTIMER = 14 | |||||
} adc0trgsel : 4; | |||||
enum { | |||||
SIM_ADCPRETRGSEL_A = 0, | |||||
SIM_ADCPRETRGSEL_B = 1 | |||||
} adc0pretrgsel : 1; | |||||
uint32_t _rsvd0 : 2; | |||||
enum { | |||||
SIM_ADCALTTRGEN_PDB = 0, | |||||
SIM_ADCALTTRGEN_ALT = 1 | |||||
} adc0alttrgen : 1; | |||||
uint32_t _rsvd1 : 24; | |||||
UNION_STRUCT_END; | |||||
} sopt7; | |||||
uint32_t _pad3[(0x1024 - 0x101c) / 4]; | |||||
struct SIM_SDID_t { | |||||
UNION_STRUCT_START(32); | |||||
enum { | |||||
SIM_PINID_32 = 2, | |||||
SIM_PINID_48 = 4, | |||||
SIM_PINID_64 = 5 | |||||
} pinid : 4; | |||||
enum { | |||||
SIM_FAMID_K10 = 0, | |||||
SIM_FAMID_K20 = 1 | |||||
} famid : 3; | |||||
uint32_t _rsvd1 : 5; | |||||
uint32_t revid : 4; | |||||
uint32_t _rsvd2 : 16; | |||||
UNION_STRUCT_END; | |||||
} sdid; | |||||
uint32_t _pad4[(0x1034 - 0x1028) / 4]; | |||||
struct SIM_SCGC4_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t _rsvd0 : 1; | |||||
uint32_t ewm : 1; | |||||
uint32_t cmt : 1; | |||||
uint32_t _rsvd1 : 3; | |||||
uint32_t i2c0 : 1; | |||||
uint32_t _rsvd2 : 3; | |||||
uint32_t uart0 : 1; | |||||
uint32_t uart1 : 1; | |||||
uint32_t uart2 : 1; | |||||
uint32_t _rsvd3 : 5; | |||||
uint32_t usbotg : 1; | |||||
uint32_t cmp : 1; | |||||
uint32_t vref : 1; | |||||
uint32_t _rsvd4 : 11; | |||||
UNION_STRUCT_END; | |||||
} scgc4; | |||||
struct SIM_SCGC5_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t lptimer : 1; | |||||
uint32_t _rsvd0 : 4; | |||||
uint32_t tsi : 1; | |||||
uint32_t _rsvd1 : 3; | |||||
uint32_t porta : 1; | |||||
uint32_t portb : 1; | |||||
uint32_t portc : 1; | |||||
uint32_t portd : 1; | |||||
uint32_t porte : 1; | |||||
uint32_t _rsvd2 : 18; | |||||
UNION_STRUCT_END; | |||||
} scgc5; | |||||
struct SIM_SCGC6_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t ftfl : 1; | |||||
uint32_t dmamux : 1; | |||||
uint32_t _rsvd0 : 10; | |||||
uint32_t spi0 : 1; | |||||
uint32_t _rsvd1 : 2; | |||||
uint32_t i2s : 1; | |||||
uint32_t _rsvd2 : 2; | |||||
uint32_t crc : 1; | |||||
uint32_t _rsvd3 : 2; | |||||
uint32_t usbdcd : 1; | |||||
uint32_t pdb : 1; | |||||
uint32_t pit : 1; | |||||
uint32_t ftm0 : 1; | |||||
uint32_t ftm1 : 1; | |||||
uint32_t _rsvd4 : 1; | |||||
uint32_t adc0 : 1; | |||||
uint32_t _rsvd5 : 1; | |||||
uint32_t rtc : 1; | |||||
uint32_t _rsvd6 : 2; | |||||
UNION_STRUCT_END; | |||||
} scgc6; | |||||
struct SIM_SCGC7_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t _rsvd0 : 1; | |||||
uint32_t dma : 1; | |||||
uint32_t _rsvd1 : 30; | |||||
UNION_STRUCT_END; | |||||
} scgc7; | |||||
struct SIM_CLKDIV1_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t _rsvd0 : 16; | |||||
uint32_t outdiv4 : 4; | |||||
uint32_t _rsvd1 : 4; | |||||
uint32_t outdiv2 : 4; | |||||
uint32_t outdiv1 : 4; | |||||
UNION_STRUCT_END; | |||||
} clkdiv1; | |||||
struct SIM_CLKDIV2_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t usbfrac : 1; | |||||
uint32_t usbdiv : 3; | |||||
uint32_t _rsvd0 : 28; | |||||
UNION_STRUCT_END; | |||||
} clkdiv2; | |||||
struct SIM_FCFG1_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t flashdis : 1; | |||||
uint32_t flashdoze : 1; | |||||
uint32_t _rsvd0 : 6; | |||||
/* the following enum is analogous to enum | |||||
* FTFL_FLEXNVM_PARTITION in ftfl.h, but that one is padded | |||||
* with four 1-bits to make an 8-bit value. | |||||
*/ | |||||
enum SIM_FLEXNVM_PARTITION { | |||||
SIM_FLEXNVM_DATA_32_EEPROM_0 = 0x0, | |||||
SIM_FLEXNVM_DATA_24_EEPROM_8 = 0x1, | |||||
SIM_FLEXNVM_DATA_16_EEPROM_16 = 0x2, | |||||
SIM_FLEXNVM_DATA_8_EEPROM_24 = 0x9, | |||||
SIM_FLEXNVM_DATA_0_EEPROM_32 = 0x3 | |||||
} depart : 4; | |||||
uint32_t _rsvd1 : 4; | |||||
enum { | |||||
SIM_EESIZE_2KB = 3, | |||||
SIM_EESIZE_1KB = 4, | |||||
SIM_EESIZE_512B = 5, | |||||
SIM_EESIZE_256B = 6, | |||||
SIM_EESIZE_128B = 7, | |||||
SIM_EESIZE_64B = 8, | |||||
SIM_EESIZE_32B = 9, | |||||
SIM_EESIZE_0B = 15 | |||||
} eesize : 4; | |||||
uint32_t _rsvd2 : 4; | |||||
enum { | |||||
SIM_PFSIZE_32KB = 3, | |||||
SIM_PFSIZE_64KB = 5, | |||||
SIM_PFSIZE_128KB = 7 | |||||
} pfsize : 4; | |||||
enum { | |||||
SIM_NVMSIZE_0KB = 0, | |||||
SIM_NVMSIZE_32KB = 3 | |||||
} nvmsize : 4; | |||||
UNION_STRUCT_END; | |||||
} fcfg1; | |||||
struct SIM_FCFG2_t { | |||||
UNION_STRUCT_START(32); | |||||
uint32_t _rsvd0 : 16; | |||||
uint32_t maxaddr1 : 7; | |||||
enum { | |||||
SIM_PFLSH_FLEXNVM = 0, | |||||
SIM_PFLSH_PROGRAM = 1 | |||||
} pflsh : 1; | |||||
uint32_t maxaddr0 : 7; | |||||
uint32_t _rsvd1 : 1; | |||||
UNION_STRUCT_END; | |||||
} fcfg2; | |||||
uint32_t uidh; | |||||
uint32_t uidmh; | |||||
uint32_t uidml; | |||||
uint32_t uidl; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct SIM_t, 0x1064); | |||||
extern volatile struct SIM_t SIM; | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef _USB_COMMON_H | |||||
#define _USB_COMMON_H | |||||
// ----- Enumerations ----- | |||||
/** | |||||
* USB request data structures. | |||||
*/ | |||||
enum usb_tok_pid { | |||||
USB_PID_TIMEOUT = 0, | |||||
USB_PID_OUT = 1, | |||||
USB_PID_ACK = 2, | |||||
USB_PID_DATA0 = 3, | |||||
USB_PID_IN = 9, | |||||
USB_PID_NAK = 10, | |||||
USB_PID_DATA1 = 11, | |||||
USB_PID_SETUP = 13, | |||||
USB_PID_STALL = 14, | |||||
USB_PID_DATAERR = 15 | |||||
}; | |||||
enum usb_ep_pingpong { | |||||
USB_EP_PINGPONG_EVEN = 0, | |||||
USB_EP_PINGPONG_ODD = 1 | |||||
}; | |||||
enum usb_ep_dir { | |||||
USB_EP_RX = 0, | |||||
USB_EP_TX = 1 | |||||
}; | |||||
enum usb_data01 { | |||||
USB_DATA01_DATA0 = 0, | |||||
USB_DATA01_DATA1 = 1 | |||||
}; | |||||
enum { | |||||
EP0_BUFSIZE = 64 | |||||
}; | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef __USB_INTERNAL_H | |||||
#define __USB_INTERNAL_H | |||||
/** | |||||
* Internal driver structures | |||||
*/ | |||||
/** | |||||
* USB state machine | |||||
* ================= | |||||
* | |||||
* Device configuration states: | |||||
* | |||||
* Attached <-> Powered | |||||
* Powered -(reset)-> Default | |||||
* Default -(SET_ADDRESS)-> Address | |||||
* Address -(SET_CONFIGURATION)-> Configured | |||||
* Configured -(SET_CONFIGURATION 0)-> Address | |||||
* Address -(SET_ADDRESS 0)-> Default | |||||
* [Default, Configured, Address] -(reset)-> Default | |||||
*/ | |||||
// ----- Defines ----- | |||||
#ifndef USB_MAX_EP | |||||
#define USB_MAX_EP 16 | |||||
#endif | |||||
// ----- Structs ----- | |||||
struct usbd_ep_pipe_state_t { | |||||
enum usb_ep_pingpong pingpong; /* next desc to use */ | |||||
enum usb_data01 data01; | |||||
size_t transfer_size; | |||||
size_t pos; | |||||
uint8_t *data_buf; | |||||
const uint8_t *copy_source; | |||||
int short_transfer; | |||||
ep_callback_t callback; | |||||
void *callback_data; | |||||
size_t ep_maxsize; | |||||
/* constant */ | |||||
int ep_num; | |||||
enum usb_ep_dir ep_dir; | |||||
}; | |||||
struct usbd_ep_state_t { | |||||
union { | |||||
struct usbd_ep_pipe_state_t pipe[2]; | |||||
struct { | |||||
struct usbd_ep_pipe_state_t rx; | |||||
struct usbd_ep_pipe_state_t tx; | |||||
}; | |||||
}; | |||||
}; | |||||
struct usbd_t { | |||||
struct usbd_function_ctx_header functions; | |||||
struct usbd_function control_function; | |||||
const struct usbd_device *identity; | |||||
int address; | |||||
int config; | |||||
enum usbd_dev_state { | |||||
USBD_STATE_DISABLED = 0, | |||||
USBD_STATE_DEFAULT, | |||||
USBD_STATE_SETTING_ADDRESS, | |||||
USBD_STATE_ADDRESS, | |||||
USBD_STATE_CONFIGURED | |||||
} state; | |||||
enum usb_ctrl_req_dir ctrl_dir; | |||||
struct usbd_ep_state_t ep_state[USB_MAX_EP]; | |||||
}; | |||||
extern struct usbd_t usb; | |||||
// ----- Functions ----- | |||||
void usb_restart(void); | |||||
void usb_enable(void); | |||||
const struct usbd_config *usb_get_config_data(int config); | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
// ----- Compiler Includes ----- | |||||
#include <sys/types.h> | |||||
#include <inttypes.h> | |||||
#include <string.h> | |||||
// ----- Local Includes ----- | |||||
#include "usb.h" | |||||
#include "usb-internal.h" | |||||
// ----- Variables ----- | |||||
static uint8_t ep0_buf[2][EP0_BUFSIZE] __attribute__((aligned(4))); | |||||
struct usbd_t usb; | |||||
// ----- Functions ----- | |||||
/** | |||||
* Returns: 0 when this is was the last transfer, 1 if there is still | |||||
* more to go. | |||||
*/ | |||||
/* Defaults to EP0 for now */ | |||||
static int usb_tx_next(struct usbd_ep_pipe_state_t *s) | |||||
{ | |||||
/** | |||||
* Us being here means the previous transfer just completed | |||||
* successfully. That means the host just toggled its data | |||||
* sync bit, and so do we. | |||||
*/ | |||||
s->data01 ^= 1; | |||||
if (s->transfer_size > 0) { | |||||
size_t thislen = s->transfer_size; | |||||
if (thislen > s->ep_maxsize) | |||||
thislen = s->ep_maxsize; | |||||
void *addr = s->data_buf + s->pos; | |||||
if (s->copy_source) { | |||||
/* Bounce buffer mode */ | |||||
addr = s->data_buf; | |||||
memcpy(addr, s->copy_source + s->pos, thislen); | |||||
} | |||||
s->pos += thislen; | |||||
s->transfer_size -= thislen; | |||||
usb_queue_next(s, addr, thislen); | |||||
s->pingpong ^= 1; | |||||
return (1); | |||||
} | |||||
/** | |||||
* All data has been shipped. Do we need to send a short | |||||
* packet? | |||||
*/ | |||||
if (s->short_transfer) { | |||||
s->short_transfer = 0; | |||||
usb_queue_next(s, NULL, 0); | |||||
s->pingpong ^= 1; | |||||
return (1); | |||||
} | |||||
if (s->callback) | |||||
s->callback(s->data_buf, s->pos, s->callback_data); | |||||
return (0); | |||||
} | |||||
static void setup_tx(struct usbd_ep_pipe_state_t *s, const void *buf, size_t len, size_t reqlen, ep_callback_t cb, void *cb_data) | |||||
{ | |||||
s->data_buf = (void *)buf; | |||||
s->copy_source = NULL; | |||||
s->transfer_size = len; | |||||
s->pos = 0; | |||||
s->callback = cb; | |||||
s->callback_data = cb_data; | |||||
if (s->transfer_size > reqlen) | |||||
s->transfer_size = reqlen; | |||||
if (s->transfer_size < reqlen && s->transfer_size % s->ep_maxsize == 0) | |||||
s->short_transfer = 1; | |||||
else | |||||
s->short_transfer = 0; | |||||
} | |||||
static void submit_tx(struct usbd_ep_pipe_state_t *s) | |||||
{ | |||||
/* usb_tx_next() flips the data toggle, so invert this here. */ | |||||
s->data01 ^= 1; | |||||
usb_tx_next(s); | |||||
} | |||||
/** | |||||
* send USB data (IN device transaction) | |||||
* | |||||
* So far this function is specialized for EP 0 only. | |||||
* | |||||
* Returns: size to be transfered, or -1 on error. | |||||
*/ | |||||
int usb_tx(struct usbd_ep_pipe_state_t *s, const void *buf, size_t len, size_t reqlen, ep_callback_t cb, void *cb_data) | |||||
{ | |||||
setup_tx(s, buf, len, reqlen, cb, cb_data); | |||||
submit_tx(s); | |||||
return (s->transfer_size); | |||||
} | |||||
/** | |||||
* Returns: 0 when this is was the last transfer, 1 if there is still | |||||
* more to go. | |||||
*/ | |||||
/* Defaults to EP0 for now */ | |||||
/* XXX pass usb_stat to validate pingpong */ | |||||
static int usb_rx_next(struct usbd_ep_pipe_state_t *s) | |||||
{ | |||||
/** | |||||
* Us being here means the previous transfer just completed | |||||
* successfully. That means the host just toggled its data | |||||
* sync bit, and so do we. | |||||
*/ | |||||
s->data01 ^= 1; | |||||
size_t thislen = usb_ep_get_transfer_size(s); | |||||
s->transfer_size -= thislen; | |||||
s->pos += thislen; | |||||
/** | |||||
* We're done with this buffer now. Switch the pingpong now | |||||
* before we might have to receive the next piece of data. | |||||
*/ | |||||
s->pingpong ^= 1; | |||||
/** | |||||
* If this is a short transfer, or we received what we | |||||
* expected, we're done. | |||||
*/ | |||||
if (thislen < s->ep_maxsize || s->transfer_size == 0) { | |||||
if (s->callback) | |||||
s->callback(s->data_buf, s->pos, s->callback_data); | |||||
return (0); | |||||
} | |||||
/** | |||||
* Otherwise we still need to receive more data. | |||||
*/ | |||||
size_t nextlen = s->transfer_size; | |||||
if (nextlen > s->ep_maxsize) | |||||
nextlen = s->ep_maxsize; | |||||
void *addr = s->data_buf + s->pos; | |||||
usb_queue_next(s, addr, nextlen); | |||||
return (1); | |||||
} | |||||
/** | |||||
* Receive USB data (OUT device transaction) | |||||
* | |||||
* Returns: size to be received, or -1 on error. | |||||
*/ | |||||
int usb_rx(struct usbd_ep_pipe_state_t *s, void *buf, size_t len, ep_callback_t cb, void *cb_data) | |||||
{ | |||||
s->data_buf = buf; | |||||
s->transfer_size = len; | |||||
s->pos = 0; | |||||
s->callback = cb; | |||||
s->callback_data = cb_data; | |||||
size_t thislen = s->transfer_size; | |||||
if (thislen > s->ep_maxsize) | |||||
thislen = s->ep_maxsize; | |||||
usb_queue_next(s, s->data_buf, thislen); | |||||
return (len); | |||||
} | |||||
int usb_ep0_tx_cp(const void *buf, size_t len, size_t reqlen, ep_callback_t cb, void *cb_data) | |||||
{ | |||||
struct usbd_ep_pipe_state_t *s = &usb.ep_state[0].tx; | |||||
enum usb_ep_pingpong pp = s->pingpong; | |||||
setup_tx(s, ep0_buf[pp], len, reqlen, cb, cb_data); | |||||
s->copy_source = buf; | |||||
submit_tx(s); | |||||
return (s->transfer_size); | |||||
} | |||||
void *usb_ep0_tx_inplace_prepare(size_t len) | |||||
{ | |||||
enum usb_ep_pingpong pp = usb.ep_state[0].tx.pingpong; | |||||
if (len > EP0_BUFSIZE) | |||||
return (NULL); | |||||
return (ep0_buf[pp]); | |||||
} | |||||
int usb_ep0_tx(void *buf, size_t len, size_t reqlen, ep_callback_t cb, void *cb_data) | |||||
{ | |||||
return (usb_tx(&usb.ep_state[0].tx, buf, len, reqlen, cb, cb_data)); | |||||
} | |||||
int usb_ep0_rx(void *buf, size_t len, ep_callback_t cb, void *cb_data) | |||||
{ | |||||
return (usb_rx(&usb.ep_state[0].rx, buf, len, cb, cb_data)); | |||||
} | |||||
const struct usbd_config * | |||||
usb_get_config_data(int config) | |||||
{ | |||||
if (config <= 0) | |||||
config = usb.config; | |||||
if (config != 0) | |||||
return (usb.identity->configs[config - 1]); | |||||
else | |||||
return (NULL); | |||||
} | |||||
static int usb_set_config(int config) | |||||
{ | |||||
const struct usbd_config *config_data; | |||||
if (usb.config != 0) { | |||||
config_data = usb_get_config_data(-1); | |||||
if (config_data != NULL && config_data->init != NULL) | |||||
config_data->init(0); | |||||
} | |||||
if (config != 0) { | |||||
/* XXX overflow */ | |||||
config_data = usb_get_config_data(config); | |||||
if (config_data != NULL && config_data->init != NULL) | |||||
config_data->init(1); | |||||
} | |||||
usb.config = config; | |||||
return (0); | |||||
} | |||||
static int usb_set_interface(int iface, int altsetting) | |||||
{ | |||||
int iface_count = 0; | |||||
for (struct usbd_function_ctx_header *fh = &usb.functions; | |||||
fh != NULL; | |||||
fh = fh->next, iface_count += fh->function->interface_count) { | |||||
if (iface - iface_count < fh->function->interface_count) { | |||||
if (fh->function->configure != NULL) | |||||
return (fh->function->configure(iface, | |||||
iface - iface_count, | |||||
altsetting, | |||||
fh)); | |||||
/* Default to a single altsetting */ | |||||
if (altsetting != 0) | |||||
return (-1); | |||||
else | |||||
return (0); | |||||
} | |||||
} | |||||
return (-1); | |||||
} | |||||
static int usb_tx_config_desc(int idx, int reqlen) | |||||
{ | |||||
const struct usb_desc_config_t *d = usb.identity->configs[idx]->desc; | |||||
usb_ep0_tx_cp(d, d->wTotalLength, reqlen, NULL, NULL); | |||||
return (0); | |||||
} | |||||
static int usb_tx_string_desc(int idx, int reqlen) | |||||
{ | |||||
const struct usb_desc_string_t * const *d; | |||||
for (d = usb.identity->string_descs; idx != 0 && *d != NULL; ++d) | |||||
--idx; | |||||
switch ((uintptr_t)*d) { | |||||
case (uintptr_t)NULL: | |||||
return (-1); | |||||
case (uintptr_t)USB_DESC_STRING_SERIALNO: | |||||
return (usb_tx_serialno(reqlen)); | |||||
default: | |||||
usb_ep0_tx_cp(*d, (*d)->bLength, reqlen, NULL, NULL); | |||||
return (0); | |||||
} | |||||
} | |||||
static void usb_handle_control_done(void *data, ssize_t len, void *cbdata) | |||||
{ | |||||
if (usb.state == USBD_STATE_SETTING_ADDRESS) { | |||||
usb.state = USBD_STATE_ADDRESS; | |||||
usb_set_addr(usb.address); | |||||
} | |||||
usb_setup_control(); | |||||
} | |||||
void usb_handle_control_status_cb(ep_callback_t cb) | |||||
{ | |||||
/* empty status transfer */ | |||||
switch (usb.ctrl_dir) { | |||||
case USB_CTRL_REQ_IN: | |||||
usb.ep_state[0].rx.data01 = USB_DATA01_DATA1; | |||||
usb_rx(&usb.ep_state[0].rx, NULL, 0, cb, NULL); | |||||
break; | |||||
default: | |||||
usb.ep_state[0].tx.data01 = USB_DATA01_DATA1; | |||||
usb_ep0_tx_cp(NULL, 0, 1 /* short packet */, cb, NULL); | |||||
break; | |||||
} | |||||
} | |||||
void usb_handle_control_status(int fail) | |||||
{ | |||||
if (fail) { | |||||
usb_pipe_stall(&usb.ep_state[0].rx); | |||||
usb_pipe_stall(&usb.ep_state[0].tx); | |||||
} else { | |||||
usb_handle_control_status_cb(usb_handle_control_done); | |||||
} | |||||
} | |||||
/** | |||||
* Dispatch non-standard request to registered USB functions. | |||||
*/ | |||||
static void usb_handle_control_nonstd(struct usb_ctrl_req_t *req) | |||||
{ | |||||
/* XXX filter by interface/endpoint? */ | |||||
for (struct usbd_function_ctx_header *fh = &usb.functions; fh != NULL; fh = fh->next) { | |||||
/* ->control() returns != 0 if it handled the request */ | |||||
if (fh->function->control != NULL && | |||||
fh->function->control(req, fh)) | |||||
return; | |||||
} | |||||
usb_handle_control_status(-1); | |||||
} | |||||
/** | |||||
* | |||||
* Great resource: http://wiki.osdev.org/Universal_Serial_Bus | |||||
* | |||||
* Control Transfers | |||||
* ----------------- | |||||
* | |||||
* A control transfer consists of a SETUP transaction (1), zero or | |||||
* more data transactions (IN or OUT) (2), and a final status | |||||
* transaction (3). | |||||
* | |||||
* Token sequence (data toggle): | |||||
* 1. SETUP (0) | |||||
* (2a. OUT (1) ... (toggling)) | |||||
* 3a. IN (1) | |||||
* | |||||
* or | |||||
* 1. SETUP (0) | |||||
* 2b. IN (1) ... (toggling) | |||||
* 3b. OUT (1) | |||||
* | |||||
* Report errors by STALLing the control EP after (1) or (2), so that | |||||
* (3) will STALL. Seems we need to clear the STALL after that so | |||||
* that the next SETUP can make it through. | |||||
* | |||||
* | |||||
*/ | |||||
/** | |||||
* The following code is not written defensively, but instead only | |||||
* asserts values that are essential for correct execution. It | |||||
* accepts a superset of the protocol defined by the standard. We do | |||||
* this to save space. | |||||
*/ | |||||
static void usb_handle_control(void *data, ssize_t len, void *cbdata) | |||||
{ | |||||
struct usb_ctrl_req_t *req = data; | |||||
uint16_t zero16 = 0; | |||||
int fail = 1; | |||||
usb.ctrl_dir = req->in; | |||||
if (req->type != USB_CTRL_REQ_STD) { | |||||
usb_handle_control_nonstd(req); | |||||
return; | |||||
} | |||||
/* Only STD requests here */ | |||||
switch (req->bRequest) { | |||||
case USB_CTRL_REQ_GET_STATUS: | |||||
/** | |||||
* Because we don't support remote wakeup or | |||||
* self-powered operation, and we are specialized to | |||||
* only EP 0 so far, all GET_STATUS replies are just | |||||
* empty. | |||||
*/ | |||||
usb_ep0_tx_cp(&zero16, sizeof(zero16), req->wLength, NULL, NULL); | |||||
break; | |||||
case USB_CTRL_REQ_CLEAR_FEATURE: | |||||
case USB_CTRL_REQ_SET_FEATURE: | |||||
/** | |||||
* Nothing to do. Maybe return STALLs on illegal | |||||
* accesses? | |||||
*/ | |||||
break; | |||||
case USB_CTRL_REQ_SET_ADDRESS: | |||||
/** | |||||
* We must keep our previous address until the end of | |||||
* the status stage; therefore we can't set the | |||||
* address right now. Since this is a special case, | |||||
* the EP 0 handler will take care of this later on. | |||||
*/ | |||||
usb.address = req->wValue & 0x7f; | |||||
usb.state = USBD_STATE_SETTING_ADDRESS; | |||||
break; | |||||
case USB_CTRL_REQ_GET_DESCRIPTOR: | |||||
switch (req->wValue >> 8) { | |||||
case USB_DESC_DEV: | |||||
usb_ep0_tx_cp(usb.identity->dev_desc, usb.identity->dev_desc->bLength, | |||||
req->wLength, NULL, NULL); | |||||
fail = 0; | |||||
break; | |||||
case USB_DESC_CONFIG: | |||||
fail = usb_tx_config_desc(req->wValue & 0xff, req->wLength); | |||||
break; | |||||
case USB_DESC_STRING: | |||||
fail = usb_tx_string_desc(req->wValue & 0xff, req->wLength); | |||||
break; | |||||
default: | |||||
fail = -1; | |||||
break; | |||||
} | |||||
/* we set fail already, so we can go directly to `err' */ | |||||
goto err; | |||||
case USB_CTRL_REQ_GET_CONFIGURATION: | |||||
usb_ep0_tx_cp(&usb.config, 1, req->wLength, NULL, NULL); /* XXX implicit LE */ | |||||
break; | |||||
case USB_CTRL_REQ_SET_CONFIGURATION: | |||||
if (usb_set_config(req->wValue) < 0) | |||||
goto err; | |||||
break; | |||||
case USB_CTRL_REQ_GET_INTERFACE: | |||||
/* We only support iface setting 0 */ | |||||
usb_ep0_tx_cp(&zero16, 1, req->wLength, NULL, NULL); | |||||
break; | |||||
case USB_CTRL_REQ_SET_INTERFACE: | |||||
if (usb_set_interface(req->wIndex, req->wValue) < 0) | |||||
goto err; | |||||
break; | |||||
default: | |||||
goto err; | |||||
} | |||||
fail = 0; | |||||
err: | |||||
usb_handle_control_status(fail); | |||||
} | |||||
void usb_setup_control(void) | |||||
{ | |||||
void *buf = ep0_buf[usb.ep_state[0].rx.pingpong]; | |||||
usb.ep_state[0].rx.data01 = USB_DATA01_DATA0; | |||||
usb.ep_state[0].tx.data01 = USB_DATA01_DATA1; | |||||
usb_rx(&usb.ep_state[0].rx, buf, EP0_BUFSIZE, usb_handle_control, NULL); | |||||
} | |||||
/** | |||||
* This is called by the interrupt handler | |||||
*/ | |||||
void usb_handle_transaction(struct usb_xfer_info *info) | |||||
{ | |||||
enum usb_tok_pid pid = usb_get_xfer_pid(info); | |||||
struct usbd_ep_state_t *eps = &usb.ep_state[usb_get_xfer_ep(info)]; | |||||
struct usbd_ep_pipe_state_t *s = &eps->pipe[usb_get_xfer_dir(info)]; | |||||
switch (pid) { | |||||
case USB_PID_SETUP: | |||||
case USB_PID_OUT: | |||||
/** | |||||
* If we receive a SETUP transaction, but don't expect | |||||
* it (callback set to somewhere else), stall the EP. | |||||
*/ | |||||
if (pid == USB_PID_SETUP && s->callback != usb_handle_control) | |||||
usb_handle_control_status(1); | |||||
else | |||||
usb_rx_next(s); | |||||
if (pid == USB_PID_SETUP) | |||||
usb_enable_xfers(); | |||||
break; | |||||
case USB_PID_IN: | |||||
usb_tx_next(s); | |||||
break; | |||||
default: | |||||
break; | |||||
} | |||||
} | |||||
struct usbd_ep_pipe_state_t *usb_init_ep(struct usbd_function_ctx_header *ctx, int ep, enum usb_ep_dir dir, size_t size) | |||||
{ | |||||
struct usbd_ep_pipe_state_t *s; | |||||
if (dir == USB_EP_RX) | |||||
s = &usb.ep_state[ctx->ep_rx_offset + ep].rx; | |||||
else | |||||
s = &usb.ep_state[ctx->ep_tx_offset + ep].tx; | |||||
memset(s, 0, sizeof(*s)); | |||||
s->ep_maxsize = size; | |||||
s->ep_num = ep; | |||||
s->ep_dir = dir; | |||||
usb_pipe_enable(s); | |||||
return (s); | |||||
} | |||||
void usb_restart(void) | |||||
{ | |||||
const struct usbd_device *identity = usb.identity; | |||||
/* XXX reset existing functions? */ | |||||
memset(&usb, 0, sizeof(usb)); | |||||
usb.functions.function = &usb.control_function; | |||||
usb.identity = identity; | |||||
usb_init_ep(&usb.functions, 0, USB_EP_RX, EP0_BUFSIZE); | |||||
usb_init_ep(&usb.functions, 0, USB_EP_TX, EP0_BUFSIZE); | |||||
usb_setup_control(); | |||||
} | |||||
void usb_attach_function(const struct usbd_function *function, struct usbd_function_ctx_header *ctx) | |||||
{ | |||||
/* XXX right now this requires a sequential initialization */ | |||||
struct usbd_function_ctx_header *prev = &usb.functions; | |||||
while (prev->next != NULL) | |||||
prev = prev->next; | |||||
ctx->next = NULL; | |||||
ctx->function = function; | |||||
ctx->interface_offset = prev->interface_offset + prev->function->interface_count; | |||||
ctx->ep_rx_offset = prev->ep_rx_offset + prev->function->ep_rx_count; | |||||
ctx->ep_tx_offset = prev->ep_tx_offset + prev->function->ep_tx_count; | |||||
prev->next = ctx; | |||||
} | |||||
void usb_init(const struct usbd_device *identity) | |||||
{ | |||||
usb.identity = identity; | |||||
usb_enable(); | |||||
} | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
#ifndef __USB_H | |||||
#define __USB_H | |||||
// ----- Compiler Includes ----- | |||||
#include <sys/types.h> | |||||
// ----- Local Includes ----- | |||||
#include "mchck.h" | |||||
#include "usb-common.h" | |||||
// ----- Defines ----- | |||||
#define USB_CTRL_REQ_DIR_SHIFT 0 | |||||
#define USB_CTRL_REQ_TYPE_SHIFT 1 | |||||
#define USB_CTRL_REQ_RECP_SHIFT 3 | |||||
#define USB_CTRL_REQ_CODE_SHIFT 8 | |||||
#define USB_CTRL_REQ(req_inout, req_type, req_code) \ | |||||
(uint16_t) \ | |||||
((USB_CTRL_REQ_##req_inout << USB_CTRL_REQ_DIR_SHIFT) \ | |||||
|(USB_CTRL_REQ_##req_type << USB_CTRL_REQ_TYPE_SHIFT) \ | |||||
|(USB_CTRL_REQ_##req_code << USB_CTRL_REQ_CODE_SHIFT)) | |||||
// ----- Macros ----- | |||||
#define USB_DESC_STRING(s) \ | |||||
(const void *)&(const struct { \ | |||||
struct usb_desc_string_t dsc; \ | |||||
char16_t str[sizeof(s) / 2 - 1]; \ | |||||
}) {{ \ | |||||
.bLength = sizeof(struct usb_desc_string_t) + \ | |||||
sizeof(s) - 2, \ | |||||
.bDescriptorType = USB_DESC_STRING, \ | |||||
}, \ | |||||
s \ | |||||
} | |||||
#define USB_DESC_STRING_LANG_ENUS USB_DESC_STRING(u"\x0409") | |||||
#define USB_DESC_STRING_SERIALNO ((const void *)1) | |||||
#define USB_FUNCTION_IFACE(iface, iface_off, tx_ep_off, rx_ep_off) \ | |||||
((iface_off) + (iface)) | |||||
#define USB_FUNCTION_TX_EP(ep, iface_off, tx_ep_off, rx_ep_off) \ | |||||
((tx_ep_off) + (ep)) | |||||
#define USB_FUNCTION_RX_EP(ep, iface_off, tx_ep_off, rx_ep_off) \ | |||||
((rx_ep_off) + (ep)) | |||||
#define USB__INCREMENT(i, _0) (i + 1) | |||||
#define USB__COUNT_IFACE_EP(i, e) \ | |||||
__DEFER(USB__COUNT_IFACE_EP_)(__EXPAND i, e) | |||||
#define USB__COUNT_IFACE_EP_(iface, tx_ep, rx_ep, func) \ | |||||
(iface + USB_FUNCTION_ ## func ## _IFACE_COUNT, \ | |||||
tx_ep + USB_FUNCTION_ ## func ## _TX_EP_COUNT, \ | |||||
rx_ep + USB_FUNCTION_ ## func ## _RX_EP_COUNT) | |||||
#define USB__GET_FUNCTION_IFACE_COUNT(iter, func) \ | |||||
USB_FUNCTION_ ## func ## _IFACE_COUNT + | |||||
#define USB__DEFINE_FUNCTION_DESC(iter, func) \ | |||||
USB_FUNCTION_DESC_ ## func ## _DECL __CAT(__usb_func_desc, __COUNTER__); | |||||
#define USB__INIT_FUNCTION_DESC(iter, func) \ | |||||
USB_FUNCTION_DESC_ ## func iter, | |||||
#define USB__DEFINE_CONFIG_DESC(confignum, name, ...) \ | |||||
&((const struct name { \ | |||||
struct usb_desc_config_t config; \ | |||||
__REPEAT_INNER(, __EAT, USB__DEFINE_FUNCTION_DESC, __VA_ARGS__) \ | |||||
}){ \ | |||||
.config = { \ | |||||
.bLength = sizeof(struct usb_desc_config_t), \ | |||||
.bDescriptorType = USB_DESC_CONFIG, \ | |||||
.wTotalLength = sizeof(struct name), \ | |||||
.bNumInterfaces = __REPEAT_INNER(, __EAT, USB__GET_FUNCTION_IFACE_COUNT, __VA_ARGS__) 0, \ | |||||
.bConfigurationValue = confignum, \ | |||||
.iConfiguration = 0, \ | |||||
.one = 1, \ | |||||
.bMaxPower = 50 \ | |||||
}, \ | |||||
__REPEAT_INNER((0, 0, 0), USB__COUNT_IFACE_EP, USB__INIT_FUNCTION_DESC, __VA_ARGS__) \ | |||||
}).config | |||||
#define USB__DEFINE_CONFIG(iter, args) \ | |||||
__DEFER(USB__DEFINE_CONFIG_)(iter, __EXPAND args) | |||||
#define USB__DEFINE_CONFIG_(confignum, initfun, ...) \ | |||||
&(const struct usbd_config){ \ | |||||
.init = initfun, \ | |||||
.desc = USB__DEFINE_CONFIG_DESC( \ | |||||
confignum, \ | |||||
__CAT(__usb_desc, __COUNTER__), \ | |||||
__VA_ARGS__) \ | |||||
}, | |||||
#define USB_INIT_DEVICE(vid, pid, manuf, product, ...) \ | |||||
{ \ | |||||
.dev_desc = &(const struct usb_desc_dev_t){ \ | |||||
.bLength = sizeof(struct usb_desc_dev_t), \ | |||||
.bDescriptorType = USB_DESC_DEV, \ | |||||
.bcdUSB = { .maj = 2 }, \ | |||||
.bDeviceClass = USB_DEV_CLASS_SEE_IFACE, \ | |||||
.bDeviceSubClass = USB_DEV_SUBCLASS_SEE_IFACE, \ | |||||
.bDeviceProtocol = USB_DEV_PROTO_SEE_IFACE, \ | |||||
.bMaxPacketSize0 = EP0_BUFSIZE, \ | |||||
.idVendor = vid, \ | |||||
.idProduct = pid, \ | |||||
.bcdDevice = { .raw = 0 }, \ | |||||
.iManufacturer = 1, \ | |||||
.iProduct = 2, \ | |||||
.iSerialNumber = 3, \ | |||||
.bNumConfigurations = __PP_NARG(__VA_ARGS__), \ | |||||
}, \ | |||||
.string_descs = (const struct usb_desc_string_t * const []){ \ | |||||
USB_DESC_STRING_LANG_ENUS, \ | |||||
USB_DESC_STRING(manuf), \ | |||||
USB_DESC_STRING(product), \ | |||||
USB_DESC_STRING_SERIALNO, \ | |||||
NULL \ | |||||
}, \ | |||||
.configs = { \ | |||||
__REPEAT(1, USB__INCREMENT, USB__DEFINE_CONFIG, __VA_ARGS__) \ | |||||
NULL \ | |||||
} \ | |||||
} | |||||
// ----- Structs & Enumerations ----- | |||||
/** | |||||
* Note: bitfields ahead. | |||||
* GCC fills the fields lsb-to-msb on little endian. | |||||
*/ | |||||
/** | |||||
* USB descriptors | |||||
*/ | |||||
enum usb_desc_type { | |||||
USB_DESC_DEV = 1, | |||||
USB_DESC_CONFIG = 2, | |||||
USB_DESC_STRING = 3, | |||||
USB_DESC_IFACE = 4, | |||||
USB_DESC_EP = 5, | |||||
USB_DESC_DEVQUAL = 6, | |||||
USB_DESC_OTHERSPEED = 7, | |||||
USB_DESC_POWER = 8 | |||||
}; | |||||
struct usb_desc_type_t { | |||||
UNION_STRUCT_START(8); | |||||
enum usb_desc_type id : 5; | |||||
enum usb_desc_type_type { | |||||
USB_DESC_TYPE_STD = 0, | |||||
USB_DESC_TYPE_CLASS = 1, | |||||
USB_DESC_TYPE_VENDOR = 2 | |||||
} type_type : 2; | |||||
uint8_t _rsvd0 : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct usb_desc_type_t, 1); | |||||
enum usb_dev_class { | |||||
USB_DEV_CLASS_SEE_IFACE = 0, | |||||
USB_DEV_CLASS_APP = 0xfe, | |||||
USB_DEV_CLASS_VENDOR = 0xff | |||||
}; | |||||
enum usb_dev_subclass { | |||||
USB_DEV_SUBCLASS_SEE_IFACE = 0, | |||||
USB_DEV_SUBCLASS_VENDOR = 0xff | |||||
}; | |||||
enum usb_dev_proto { | |||||
USB_DEV_PROTO_SEE_IFACE = 0, | |||||
USB_DEV_PROTO_VENDOR = 0xff | |||||
}; | |||||
struct usb_bcd_t { | |||||
UNION_STRUCT_START(16); | |||||
struct { | |||||
uint8_t sub : 4; | |||||
uint8_t min : 4; | |||||
uint16_t maj : 8; | |||||
}; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct usb_bcd_t, 2); | |||||
struct usb_desc_generic_t { | |||||
uint8_t bLength; | |||||
struct usb_desc_type_t bDescriptorType; | |||||
uint8_t data[]; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct usb_desc_generic_t, 2); | |||||
struct usb_desc_dev_t { | |||||
uint8_t bLength; | |||||
enum usb_desc_type bDescriptorType : 8; /* = USB_DESC_DEV */ | |||||
struct usb_bcd_t bcdUSB; /* = 0x0200 */ | |||||
enum usb_dev_class bDeviceClass : 8; | |||||
enum usb_dev_subclass bDeviceSubClass : 8; | |||||
enum usb_dev_proto bDeviceProtocol : 8; | |||||
uint8_t bMaxPacketSize0; | |||||
uint16_t idVendor; | |||||
uint16_t idProduct; | |||||
struct usb_bcd_t bcdDevice; | |||||
uint8_t iManufacturer; | |||||
uint8_t iProduct; | |||||
uint8_t iSerialNumber; | |||||
uint8_t bNumConfigurations; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct usb_desc_dev_t, 18); | |||||
struct usb_desc_ep_t { | |||||
uint8_t bLength; | |||||
enum usb_desc_type bDescriptorType : 8; /* = USB_DESC_EP */ | |||||
union { | |||||
struct { | |||||
uint8_t ep_num : 4; | |||||
uint8_t _rsvd0 : 3; | |||||
uint8_t in : 1; | |||||
}; | |||||
uint8_t bEndpointAddress; | |||||
}; | |||||
struct { | |||||
enum usb_ep_type { | |||||
USB_EP_CONTROL = 0, | |||||
USB_EP_ISO = 1, | |||||
USB_EP_BULK = 2, | |||||
USB_EP_INTR = 3 | |||||
} type : 2; | |||||
enum usb_ep_iso_synctype { | |||||
USB_EP_ISO_NOSYNC = 0, | |||||
USB_EP_ISO_ASYNC = 1, | |||||
USB_EP_ISO_ADAPTIVE = 2, | |||||
USB_EP_ISO_SYNC = 3 | |||||
} sync_type : 2; | |||||
enum usb_ep_iso_usagetype { | |||||
USB_EP_ISO_DATA = 0, | |||||
USB_EP_ISO_FEEDBACK = 1, | |||||
USB_EP_ISO_IMPLICIT = 2 | |||||
} usage_type : 2; | |||||
uint8_t _rsvd1 : 2; | |||||
}; | |||||
struct { | |||||
uint16_t wMaxPacketSize : 11; | |||||
uint16_t _rsvd2 : 5; | |||||
}; | |||||
uint8_t bInterval; | |||||
} __packed; | |||||
CTASSERT_SIZE_BYTE(struct usb_desc_ep_t, 7); | |||||
struct usb_desc_iface_t { | |||||
uint8_t bLength; | |||||
enum usb_desc_type bDescriptorType : 8; /* = USB_DESC_IFACE */ | |||||
uint8_t bInterfaceNumber; | |||||
uint8_t bAlternateSetting; | |||||
uint8_t bNumEndpoints; | |||||
enum usb_dev_class bInterfaceClass : 8; | |||||
enum usb_dev_subclass bInterfaceSubClass: 8; | |||||
enum usb_dev_proto bInterfaceProtocol : 8; | |||||
uint8_t iInterface; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct usb_desc_iface_t, 9); | |||||
struct usb_desc_config_t { | |||||
uint8_t bLength; | |||||
enum usb_desc_type bDescriptorType : 8; /* = USB_DESC_CONFIG */ | |||||
uint16_t wTotalLength; /* size of config, iface, ep */ | |||||
uint8_t bNumInterfaces; | |||||
uint8_t bConfigurationValue; | |||||
uint8_t iConfiguration; | |||||
struct { | |||||
uint8_t _rsvd0 : 5; | |||||
uint8_t remote_wakeup : 1; | |||||
uint8_t self_powered : 1; | |||||
uint8_t one : 1; /* = 1 for historical reasons */ | |||||
}; | |||||
uint8_t bMaxPower; /* units of 2mA */ | |||||
} __packed; | |||||
CTASSERT_SIZE_BYTE(struct usb_desc_config_t, 9); | |||||
struct usb_desc_string_t { | |||||
uint8_t bLength; | |||||
enum usb_desc_type bDescriptorType : 8; /* = USB_DESC_STRING */ | |||||
const char16_t bString[]; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct usb_desc_string_t, 2); | |||||
struct usb_ctrl_req_t { | |||||
union /* reqtype and request & u16 */ { | |||||
struct /* reqtype and request */ { | |||||
union /* reqtype in bitfield & u8 */ { | |||||
struct /* reqtype */ { | |||||
enum usb_ctrl_req_recp { | |||||
USB_CTRL_REQ_DEV = 0, | |||||
USB_CTRL_REQ_IFACE = 1, | |||||
USB_CTRL_REQ_EP = 2, | |||||
USB_CTRL_REQ_OTHER = 3 | |||||
} recp : 5; | |||||
enum usb_ctrl_req_type { | |||||
USB_CTRL_REQ_STD = 0, | |||||
USB_CTRL_REQ_CLASS = 1, | |||||
USB_CTRL_REQ_VENDOR = 2 | |||||
} type : 2; | |||||
enum usb_ctrl_req_dir { | |||||
USB_CTRL_REQ_OUT = 0, | |||||
USB_CTRL_REQ_IN = 1 | |||||
} in : 1; | |||||
}; | |||||
uint8_t bmRequestType; | |||||
}; /* union */ | |||||
enum usb_ctrl_req_code { | |||||
USB_CTRL_REQ_GET_STATUS = 0, | |||||
USB_CTRL_REQ_CLEAR_FEATURE = 1, | |||||
USB_CTRL_REQ_SET_FEATURE = 3, | |||||
USB_CTRL_REQ_SET_ADDRESS = 5, | |||||
USB_CTRL_REQ_GET_DESCRIPTOR = 6, | |||||
USB_CTRL_REQ_SET_DESCRIPTOR = 7, | |||||
USB_CTRL_REQ_GET_CONFIGURATION = 8, | |||||
USB_CTRL_REQ_SET_CONFIGURATION = 9, | |||||
USB_CTRL_REQ_GET_INTERFACE = 10, | |||||
USB_CTRL_REQ_SET_INTERFACE = 11, | |||||
USB_CTRL_REQ_SYNC_FRAME = 12 | |||||
} bRequest : 8; | |||||
}; /* struct */ | |||||
uint16_t type_and_req; | |||||
}; /* union */ | |||||
union { | |||||
uint16_t wValue; | |||||
struct { | |||||
uint8_t wValueLow; | |||||
uint8_t wValueHigh; | |||||
}; | |||||
}; | |||||
uint16_t wIndex; | |||||
uint16_t wLength; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct usb_ctrl_req_t, 8); | |||||
/** | |||||
* status replies for GET_STATUS. | |||||
*/ | |||||
struct usb_ctrl_req_status_dev_t { | |||||
uint16_t self_powered : 1; | |||||
uint16_t remote_wakeup : 1; | |||||
uint16_t _rsvd : 14; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct usb_ctrl_req_status_dev_t, 16); | |||||
struct usb_ctrl_req_status_iface_t { | |||||
uint16_t _rsvd; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct usb_ctrl_req_status_iface_t, 16); | |||||
struct usb_ctrl_req_status_ep_t { | |||||
uint16_t halt : 1; | |||||
uint16_t _rsvd : 15; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct usb_ctrl_req_status_ep_t, 16); | |||||
/** | |||||
* Descriptor type (in req->value) for GET_DESCRIPTOR. | |||||
*/ | |||||
struct usb_ctrl_req_desc_t { | |||||
uint8_t idx; | |||||
enum usb_desc_type type : 8; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct usb_ctrl_req_desc_t, 16); | |||||
/** | |||||
* Feature selector (in req->value) for CLEAR_FEATURE. | |||||
*/ | |||||
enum usb_ctrl_req_feature { | |||||
USB_CTRL_REQ_FEAT_EP_HALT = 0, | |||||
USB_CTRL_REQ_FEAT_DEV_REMOTE_WKUP = 1, | |||||
USB_CTRL_REQ_FEAT_TEST_MODE = 2 | |||||
}; | |||||
struct usb_xfer_info; | |||||
typedef void (*ep_callback_t)(void *buf, ssize_t len, void *data); | |||||
/** | |||||
* (Artificial) function. Aggregates one or more interfaces. | |||||
*/ | |||||
struct usbd_function { | |||||
int (*configure)(int orig_iface, int iface, int altsetting, void *data); | |||||
int (*control)(struct usb_ctrl_req_t *, void *); | |||||
int interface_count; | |||||
int ep_rx_count; | |||||
int ep_tx_count; | |||||
}; | |||||
struct usbd_function_ctx_header { | |||||
struct usbd_function_ctx_header *next; | |||||
const struct usbd_function *function; | |||||
int interface_offset; | |||||
int ep_rx_offset; | |||||
int ep_tx_offset; | |||||
}; | |||||
typedef void (usbd_init_fun_t)(int); | |||||
typedef void (usbd_suspend_resume_fun_t)(void); | |||||
/** | |||||
* Configuration. Contains one or more functions which all will be | |||||
* active concurrently. | |||||
*/ | |||||
struct usbd_config { | |||||
usbd_init_fun_t *init; | |||||
usbd_suspend_resume_fun_t *suspend; | |||||
usbd_suspend_resume_fun_t *resume; | |||||
/** | |||||
* We will not set a config for now, because there is not much to | |||||
* configure, except for power | |||||
* | |||||
* const struct usb_desc_config_t *config_desc; | |||||
*/ | |||||
const struct usb_desc_config_t *desc; | |||||
const struct usbd_function *function[]; | |||||
}; | |||||
/** | |||||
* Device. Contains one or more configurations, out of which only one | |||||
* is active at a time. | |||||
*/ | |||||
struct usbd_device { | |||||
const struct usb_desc_dev_t *dev_desc; | |||||
const struct usb_desc_string_t * const *string_descs; | |||||
const struct usbd_config *configs[]; | |||||
}; | |||||
/* Provided by MD code */ | |||||
struct usbd_ep_pipe_state_t; | |||||
// ----- Functions ----- | |||||
void *usb_get_xfer_data(struct usb_xfer_info *); | |||||
enum usb_tok_pid usb_get_xfer_pid(struct usb_xfer_info *); | |||||
int usb_get_xfer_ep(struct usb_xfer_info *); | |||||
enum usb_ep_dir usb_get_xfer_dir(struct usb_xfer_info *); | |||||
void usb_enable_xfers(void); | |||||
void usb_set_addr(int); | |||||
void usb_ep_stall(int); | |||||
size_t usb_ep_get_transfer_size(struct usbd_ep_pipe_state_t *); | |||||
void usb_queue_next(struct usbd_ep_pipe_state_t *, void *, size_t); | |||||
void usb_pipe_stall(struct usbd_ep_pipe_state_t *); | |||||
void usb_pipe_unstall(struct usbd_ep_pipe_state_t *); | |||||
void usb_pipe_enable(struct usbd_ep_pipe_state_t *s); | |||||
void usb_pipe_disable(struct usbd_ep_pipe_state_t *s); | |||||
#ifdef VUSB | |||||
void vusb_main_loop(void); | |||||
#else | |||||
void usb_poll(void); | |||||
#endif | |||||
int usb_tx_serialno(size_t reqlen); | |||||
/* Provided by MI code */ | |||||
void usb_init(const struct usbd_device *); | |||||
void usb_attach_function(const struct usbd_function *function, struct usbd_function_ctx_header *ctx); | |||||
void usb_handle_transaction(struct usb_xfer_info *); | |||||
void usb_setup_control(void); | |||||
void usb_handle_control_status_cb(ep_callback_t cb); | |||||
void usb_handle_control_status(int); | |||||
struct usbd_ep_pipe_state_t *usb_init_ep(struct usbd_function_ctx_header *ctx, int ep, enum usb_ep_dir dir, size_t size); | |||||
int usb_rx(struct usbd_ep_pipe_state_t *, void *, size_t, ep_callback_t, void *); | |||||
int usb_tx(struct usbd_ep_pipe_state_t *, const void *, size_t, size_t, ep_callback_t, void *); | |||||
int usb_ep0_rx(void *, size_t, ep_callback_t, void *); | |||||
void *usb_ep0_tx_inplace_prepare(size_t len); | |||||
int usb_ep0_tx(void *buf, size_t len, size_t reqlen, ep_callback_t cb, void *cb_data); | |||||
int usb_ep0_tx_cp(const void *, size_t, size_t, ep_callback_t, void *); | |||||
// ----- DFU USB Additional Includes ----- | |||||
#include "dfu.h" | |||||
#endif | |||||
/* Copyright (c) 2011,2012 Simon Schubert <[email protected]>. | |||||
* Modifications by Jacob Alexander 2014 <[email protected]> | |||||
* | |||||
* This program is free software: you can redistribute it and/or modify | |||||
* it under the terms of the GNU General Public License as published by | |||||
* the Free Software Foundation, either version 3 of the License, or | |||||
* (at your option) any later version. | |||||
* | |||||
* This program is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
* GNU General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU General Public License | |||||
* along with this program. If not, see <http://www.gnu.org/licenses/>. | |||||
*/ | |||||
// ----- Local Includes ----- | |||||
#include "mchck.h" | |||||
#include "usb-common.h" | |||||
// ----- Structs ----- | |||||
/** | |||||
* Hardware structures | |||||
*/ | |||||
struct USB_ADDINFO_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t iehost : 1; | |||||
uint8_t _rsvd0 : 2; | |||||
uint8_t irqnum : 5; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_ADDINFO_t, 8); | |||||
struct USB_OTGSTAT_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t avbus : 1; | |||||
uint8_t _rsvd0 : 1; | |||||
uint8_t b_sess : 1; | |||||
uint8_t sessvld : 1; | |||||
uint8_t _rsvd1 : 1; | |||||
uint8_t line_state : 1; | |||||
uint8_t onemsec : 1; | |||||
uint8_t idchg : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_OTGSTAT_t, 8); | |||||
struct USB_OTGCTL_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t _rsvd0 : 2; | |||||
uint8_t otgen : 1; | |||||
uint8_t _rsvd1 : 1; | |||||
uint8_t dmlow : 1; | |||||
uint8_t dplow : 1; | |||||
uint8_t _rsvd2 : 1; | |||||
uint8_t dphigh : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_OTGCTL_t, 8); | |||||
struct USB_ISTAT_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t usbrst : 1; | |||||
uint8_t error : 1; | |||||
uint8_t softok : 1; | |||||
uint8_t tokdne : 1; | |||||
uint8_t sleep : 1; | |||||
uint8_t resume : 1; | |||||
uint8_t attach : 1; | |||||
uint8_t stall : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_ISTAT_t, 8); | |||||
struct USB_ERRSTAT_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t piderr : 1; | |||||
uint8_t crc5eof : 1; | |||||
uint8_t crc16 : 1; | |||||
uint8_t dfn8 : 1; | |||||
uint8_t btoerr : 1; | |||||
uint8_t dmaerr : 1; | |||||
uint8_t _rsvd0 : 1; | |||||
uint8_t btserr : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_ERRSTAT_t, 8); | |||||
struct USB_STAT_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t _rsvd0 : 2; | |||||
enum usb_ep_pingpong pingpong : 1; | |||||
enum usb_ep_dir dir : 1; | |||||
uint8_t ep : 4; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_STAT_t, 8); | |||||
struct USB_CTL_t { | |||||
union { | |||||
struct /* common */ { | |||||
uint8_t _rsvd1 : 1; | |||||
uint8_t oddrst : 1; | |||||
uint8_t resume : 1; | |||||
uint8_t _rsvd2 : 3; | |||||
uint8_t se0 : 1; | |||||
uint8_t jstate : 1; | |||||
}; | |||||
struct /* host */ { | |||||
uint8_t sofen : 1; | |||||
uint8_t _rsvd3 : 2; | |||||
uint8_t hostmodeen : 1; | |||||
uint8_t reset : 1; | |||||
uint8_t token_busy : 1; | |||||
uint8_t _rsvd4 : 2; | |||||
}; | |||||
struct /* device */ { | |||||
uint8_t usben : 1; | |||||
uint8_t _rsvd5 : 4; | |||||
uint8_t txd_suspend : 1; | |||||
uint8_t _rsvd6 : 2; | |||||
}; | |||||
uint8_t raw; | |||||
}; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_CTL_t, 8); | |||||
struct USB_ADDR_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t addr : 7; | |||||
uint8_t lsen : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_ADDR_t, 8); | |||||
struct USB_TOKEN_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t endpt : 4; | |||||
enum usb_tok_pid pid : 4; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_TOKEN_t, 8); | |||||
struct USB_ENDPT_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t ephshk : 1; | |||||
uint8_t epstall : 1; | |||||
uint8_t eptxen : 1; | |||||
uint8_t eprxen : 1; | |||||
uint8_t epctldis : 1; | |||||
uint8_t _rsvd0 : 1; | |||||
uint8_t retrydis : 1; | |||||
uint8_t hostwohub : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_ENDPT_t, 8); | |||||
struct USB_USBCTRL_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t _rsvd0 : 6; | |||||
uint8_t pde : 1; | |||||
uint8_t susp : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_USBCTRL_t, 8); | |||||
struct USB_OBSERVE_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t _rsvd0 : 4; | |||||
uint8_t dmpd : 1; | |||||
uint8_t _rsvd1 : 1; | |||||
uint8_t dppd : 1; | |||||
uint8_t dppu : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_OBSERVE_t, 8); | |||||
struct USB_CONTROL_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t _rsvd0 : 4; | |||||
uint8_t dppullupnonotg : 1; | |||||
uint8_t _rsvd1 : 3; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_CONTROL_t, 8); | |||||
struct USB_USBTRC0_t { | |||||
UNION_STRUCT_START(8); | |||||
uint8_t usb_resume_int : 1; | |||||
uint8_t sync_det : 1; | |||||
uint8_t _rsvd0 : 3; | |||||
uint8_t usbresmen : 1; | |||||
uint8_t _rsvd1 : 1; | |||||
uint8_t usbreset : 1; | |||||
UNION_STRUCT_END; | |||||
}; | |||||
CTASSERT_SIZE_BIT(struct USB_USBTRC0_t, 8); | |||||
struct USB_t { | |||||
uint8_t perid; | |||||
uint8_t _pad0[3]; | |||||
uint8_t idcomp; | |||||
uint8_t _pad1[3]; | |||||
uint8_t rev; | |||||
uint8_t _pad2[3]; | |||||
struct USB_ADDINFO_t addinfo; | |||||
uint8_t _pad3[3]; | |||||
struct USB_OTGSTAT_t otgistat; | |||||
uint8_t _pad4[3]; | |||||
struct USB_OTGSTAT_t otgicr; | |||||
uint8_t _pad5[3]; | |||||
struct USB_OTGSTAT_t otgstat; | |||||
uint8_t _pad6[3]; | |||||
struct USB_OTGCTL_t otgctl; | |||||
uint8_t _pad7[3]; | |||||
uint8_t _pad8[0x80 - 0x20]; | |||||
struct USB_ISTAT_t istat; | |||||
uint8_t _pad9[3]; | |||||
struct USB_ISTAT_t inten; | |||||
uint8_t _pad10[3]; | |||||
struct USB_ERRSTAT_t errstat; | |||||
uint8_t _pad11[3]; | |||||
struct USB_ERRSTAT_t erren; | |||||
uint8_t _pad12[3]; | |||||
struct USB_STAT_t stat; | |||||
uint8_t _pad13[3]; | |||||
struct USB_CTL_t ctl; | |||||
uint8_t _pad14[3]; | |||||
struct USB_ADDR_t addr; | |||||
uint8_t _pad15[3]; | |||||
uint8_t bdtpage1; | |||||
uint8_t _pad16[3]; | |||||
uint8_t frmnuml; | |||||
uint8_t _pad17[3]; | |||||
struct { | |||||
uint8_t frmnumh : 3; | |||||
uint8_t _rsvd0 : 5; | |||||
}; | |||||
uint8_t _pad18[3]; | |||||
struct USB_TOKEN_t token; | |||||
uint8_t _pad19[3]; | |||||
uint8_t softhld; | |||||
uint8_t _pad20[3]; | |||||
uint8_t bdtpage2; | |||||
uint8_t _pad21[3]; | |||||
uint8_t bdtpage3; | |||||
uint8_t _pad22[3]; | |||||
uint8_t _pad23[0xc0 - 0xb8]; | |||||
struct { | |||||
struct USB_ENDPT_t; | |||||
uint8_t _pad24[3]; | |||||
} endpt[16]; | |||||
struct USB_USBCTRL_t usbctrl; | |||||
uint8_t _pad25[3]; | |||||
struct USB_OBSERVE_t observe; | |||||
uint8_t _pad26[3]; | |||||
struct USB_CONTROL_t control; | |||||
uint8_t _pad27[3]; | |||||
struct USB_USBTRC0_t usbtrc0; | |||||
uint8_t _pad28[3]; | |||||
uint8_t _pad29[4]; | |||||
uint8_t usbfrmadjust; | |||||
uint8_t _pad30[3]; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct USB_t, 0x118); | |||||
struct USB_BD_t { | |||||
struct USB_BD_BITS_t { | |||||
union { | |||||
struct { | |||||
uint32_t _rsvd0 : 2; | |||||
uint32_t stall : 1; | |||||
uint32_t dts : 1; | |||||
uint32_t ninc : 1; | |||||
uint32_t keep : 1; | |||||
enum usb_data01 data01 : 1; | |||||
uint32_t own : 1; | |||||
uint32_t _rsvd1 : 8; | |||||
uint32_t bc : 10; | |||||
uint32_t _rsvd2 : 6; | |||||
}; | |||||
struct /* processor */ { | |||||
uint32_t _rsvd5 : 2; | |||||
enum usb_tok_pid tok_pid : 4; | |||||
uint32_t _rsvd6 : 26; | |||||
}; | |||||
uint32_t raw; | |||||
}; | |||||
}; | |||||
void *addr; | |||||
}; | |||||
CTASSERT_SIZE_BYTE(struct USB_BD_t, 8); | |||||
extern volatile struct USB_t USB0; | |||||
/* Teensyduino Core Library | |||||
* http://www.pjrc.com/teensy/ | |||||
* Copyright (c) 2013 PJRC.COM, LLC. | |||||
* Modifications by Jacob Alexander 2014 for use with McHCK | |||||
* | |||||
* Permission is hereby granted, free of charge, to any person obtaining | |||||
* a copy of this software and associated documentation files (the | |||||
* "Software"), to deal in the Software without restriction, including | |||||
* without limitation the rights to use, copy, modify, merge, publish, | |||||
* distribute, sublicense, and/or sell copies of the Software, and to | |||||
* permit persons to whom the Software is furnished to do so, subject to | |||||
* the following conditions: | |||||
* | |||||
* 1. The above copyright notice and this permission notice shall be | |||||
* included in all copies or substantial portions of the Software. | |||||
* | |||||
* 2. If the Software is incorporated into a build system that allows | |||||
* selection among a list of target devices, then similar target | |||||
* devices manufactured by PJRC.COM must be included in the list of | |||||
* target devices and selectable in the same manner. | |||||
* | |||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |||||
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |||||
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |||||
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |||||
* SOFTWARE. | |||||
*/ | |||||
MEMORY | |||||
{ | |||||
FLASH (rx) : ORIGIN = 0x0, LENGTH = 128K | |||||
FLASH_APP (rx) : ORIGIN = 4K, LENGTH = 128K-4K | |||||
RAM (rwx) : ORIGIN = 0x20000000 - 16K / 2, LENGTH = 16K | |||||
} | |||||
/* Starting Address of the application ROM */ | |||||
_app_rom = ORIGIN( FLASH_APP ); | |||||
FlexRAM = 0x14000000; | |||||
FTFL = 0x40020000; | |||||
SCB = 0xe000ed00; | |||||
USB0 = 0x40072000; | |||||
SIM = 0x40047000; | |||||
/* Section Definitions */ | |||||
SECTIONS | |||||
{ | |||||
.text : | |||||
{ | |||||
. = 0; | |||||
KEEP(* (.vectors)) | |||||
*(.startup*) | |||||
*(.rodata*) | |||||
. = 0x400; | |||||
KEEP(* (.flashconfig)) | |||||
*(.text*) | |||||
. = ALIGN(4); | |||||
KEEP(*(.init)) | |||||
} > FLASH | |||||
.ARM.exidx : | |||||
{ | |||||
__exidx_start = .; | |||||
*(.ARM.exidx* .gnu.linkonce.armexidx.*) | |||||
__exidx_end = .; | |||||
} > FLASH | |||||
_etext = .; | |||||
.usbdescriptortable (NOLOAD) : { | |||||
. = ALIGN(512); | |||||
*(.usbdescriptortable*) | |||||
} > RAM | |||||
.dmabuffers (NOLOAD) : { | |||||
. = ALIGN(4); | |||||
*(.dmabuffers*) | |||||
} > RAM | |||||
.usbbuffers (NOLOAD) : { | |||||
. = ALIGN(4); | |||||
*(.usbbuffers*) | |||||
} > RAM | |||||
.data : AT (_etext) { | |||||
. = ALIGN(4); | |||||
_sdata = .; | |||||
*(SORT_BY_ALIGNMENT(.ramtext.*) SORT_BY_ALIGNMENT(.data*)) | |||||
*(.data*) | |||||
. = ALIGN(4); | |||||
_edata = .; | |||||
} > RAM | |||||
.noinit (NOLOAD) : { | |||||
*(.noinit*) | |||||
} > RAM | |||||
.bss : { | |||||
. = ALIGN(4); | |||||
_sbss = .; | |||||
*(.bss*) | |||||
*(COMMON) | |||||
. = ALIGN(4); | |||||
_ebss = .; | |||||
__bss_end = .; | |||||
} > RAM | |||||
_estack = ORIGIN(RAM) + LENGTH(RAM); | |||||
} | |||||