/* * regnual.c -- Firmware installation for STM32F103 Flash ROM * * Copyright (C) 2012, 2013, 2015 * Free Software Initiative of Japan * Author: NIIBE Yutaka * * This file is a part of Gnuk, a GnuPG USB Token implementation. * * Gnuk 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. * * Gnuk 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 . * */ /* * ReGNUal */ #include "types.h" #include "usb_lld.h" #include "sys.h" extern void *memset (void *s, int c, size_t n); extern void set_led (int); extern int flash_write (uint32_t dst_addr, const uint8_t *src, size_t len); extern int flash_protect (void); extern void nvic_system_reset (void); #define FLASH_START_ADDR 0x08000000 /* Fixed for all STM32F1. */ #define FLASH_OFFSET 0x1000 /* First pages are not-writable. */ #define FLASH_START (FLASH_START_ADDR+FLASH_OFFSET) #define FLASH_SIZE_REG ((uint16_t *)0x1ffff7e0) static uint32_t flash_end; #define ENDP0_RXADDR (0x40) #define ENDP0_TXADDR (0x80) /* USB Standard Device Descriptor */ static const uint8_t regnual_device_desc[] = { 18, /* bLength */ USB_DEVICE_DESCRIPTOR_TYPE, /* bDescriptorType */ 0x10, 0x01, /* bcdUSB = 1.1 */ 0xFF, /* bDeviceClass: VENDOR */ 0x00, /* bDeviceSubClass */ 0x00, /* bDeviceProtocol */ 0x40, /* bMaxPacketSize0 */ #include "../src/usb-vid-pid-ver.c.inc" 1, /* Index of string descriptor describing manufacturer */ 2, /* Index of string descriptor describing product */ 3, /* Index of string descriptor describing the device's serial number */ 0x01 /* bNumConfigurations */ }; static const uint8_t regnual_config_desc[] = { 9, USB_CONFIGURATION_DESCRIPTOR_TYPE, /* bDescriptorType: Configuration */ 18, 0, /* wTotalLength: no of returned bytes */ 1, /* bNumInterfaces: single vender interface */ 0x01, /* bConfigurationValue: Configuration value */ 0x00, /* iConfiguration: None */ #if defined(USB_SELF_POWERED) 0xC0, /* bmAttributes: self powered */ #else 0x80, /* bmAttributes: bus powered */ #endif 50, /* MaxPower 100 mA */ /* Interface Descriptor */ 9, USB_INTERFACE_DESCRIPTOR_TYPE, /* bDescriptorType: Interface */ 0, /* bInterfaceNumber: Index of this interface */ 0, /* Alternate setting for this interface */ 0, /* bNumEndpoints: None */ 0xFF, 0, 0, 0, /* string index for interface */ }; static const uint8_t regnual_string_lang_id[] = { 4, /* bLength */ USB_STRING_DESCRIPTOR_TYPE, 0x09, 0x04 /* LangID = 0x0409: US-English */ }; #include "../src/usb-strings.c.inc" static const uint8_t regnual_string_serial[] = { 8*2+2, USB_STRING_DESCRIPTOR_TYPE, /* FSIJ-0.0 */ 'F', 0, 'S', 0, 'I', 0, 'J', 0, '-', 0, '0', 0, '.', 0, '0', 0, }; void usb_cb_device_reset (void) { /* Set DEVICE as not configured */ usb_lld_set_configuration (0); /* Current Feature initialization */ usb_lld_set_feature (regnual_config_desc[7]); usb_lld_reset (); /* Initialize Endpoint 0 */ usb_lld_setup_endpoint (ENDP0, EP_CONTROL, 0, ENDP0_RXADDR, ENDP0_TXADDR, 64); } #define USB_REGNUAL_MEMINFO 0 #define USB_REGNUAL_SEND 1 #define USB_REGNUAL_RESULT 2 #define USB_REGNUAL_FLASH 3 #define USB_REGNUAL_PROTECT 4 #define USB_REGNUAL_FINISH 5 static uint32_t mem[256/4]; static uint32_t result; static uint32_t rbit (uint32_t v) { uint32_t r; asm ("rbit %0, %1" : "=r" (r) : "r" (v)); return r; } static uint32_t fetch (int i) { uint32_t v; v = mem[i]; return rbit (v); } struct CRC { __IO uint32_t DR; __IO uint8_t IDR; uint8_t RESERVED0; uint16_t RESERVED1; __IO uint32_t CR; }; #define CRC_CR_RESET 0x01 static uint32_t calc_crc32 (void) { struct CRC *CRC = (struct CRC *)0x40023000; int i; CRC->CR = CRC_CR_RESET; for (i = 0; i < 256/4; i++) CRC->DR = fetch (i); return rbit (CRC->DR); } void usb_cb_ctrl_write_finish (uint8_t req, uint8_t req_no, uint16_t value) { uint8_t type_rcp = req & (REQUEST_TYPE|RECIPIENT); if (type_rcp == (VENDOR_REQUEST | DEVICE_RECIPIENT) && USB_SETUP_SET (req)) { if (req_no == USB_REGNUAL_SEND && value == 0) result = calc_crc32 (); else if (req_no == USB_REGNUAL_FLASH) { uint32_t dst_addr = (0x08000000 + value * 0x100); result = flash_write (dst_addr, (const uint8_t *)mem, 256); } else if (req_no == USB_REGNUAL_PROTECT && value == 0) result = flash_protect (); else if (req_no == USB_REGNUAL_FINISH && value == 0) nvic_system_reset (); } } int usb_cb_setup (uint8_t req, uint8_t req_no, struct control_info *detail) { uint8_t type_rcp = req & (REQUEST_TYPE|RECIPIENT); if (type_rcp == (VENDOR_REQUEST | DEVICE_RECIPIENT)) { if (USB_SETUP_GET (req)) { if (req_no == USB_REGNUAL_MEMINFO) { const uint8_t *mem_info[2]; mem_info[0] = (const uint8_t *)FLASH_START; mem_info[1] = (const uint8_t *)flash_end; return usb_lld_reply_request (mem_info, sizeof (mem_info), detail); } else if (req_no == USB_REGNUAL_RESULT) return usb_lld_reply_request (&result, sizeof (uint32_t), detail); } else /* SETUP_SET */ { if (req_no == USB_REGNUAL_SEND) { if (detail->value != 0 || detail->index + detail->len > 256) return USB_UNSUPPORT; if (detail->index + detail->len < 256) memset ((uint8_t *)mem + detail->index + detail->len, 0xff, 256 - (detail->index + detail->len)); usb_lld_set_data_to_recv (mem + detail->index, detail->len); return USB_SUCCESS; } else if (req_no == USB_REGNUAL_FLASH && detail->len == 0 && detail->index == 0) { uint32_t dst_addr = (0x08000000 + detail->value * 0x100); if (dst_addr + 256 <= flash_end) return USB_SUCCESS; } else if (req_no == USB_REGNUAL_PROTECT && detail->len == 0 && detail->value == 0 && detail->index == 0) return USB_SUCCESS; else if (req_no == USB_REGNUAL_FINISH && detail->len == 0 && detail->value == 0 && detail->index == 0) return USB_SUCCESS; } } return USB_UNSUPPORT; } int usb_cb_get_descriptor (uint8_t rcp, uint8_t desc_type, uint8_t desc_index, struct control_info *detail) { if (rcp != DEVICE_RECIPIENT) return USB_UNSUPPORT; if (desc_type == DEVICE_DESCRIPTOR) return usb_lld_reply_request (regnual_device_desc, sizeof (regnual_device_desc), detail); else if (desc_type == CONFIG_DESCRIPTOR) return usb_lld_reply_request (regnual_config_desc, sizeof (regnual_config_desc), detail); else if (desc_type == STRING_DESCRIPTOR) { const uint8_t *str; int size; switch (desc_index) { case 0: str = regnual_string_lang_id; size = sizeof (regnual_string_lang_id); break; case 1: str = gnuk_string_vendor; size = sizeof (gnuk_string_vendor); break; case 2: str = gnuk_string_product; size = sizeof (gnuk_string_product); break; case 3: str = regnual_string_serial; size = sizeof (regnual_string_serial); break; default: return USB_UNSUPPORT; } return usb_lld_reply_request (str, size, detail); } return USB_UNSUPPORT; } int usb_cb_handle_event (uint8_t event_type, uint16_t value) { (void)value; switch (event_type) { case USB_EVENT_ADDRESS: case USB_EVENT_CONFIG: return USB_SUCCESS; default: break; } return USB_UNSUPPORT; } int usb_cb_interface (uint8_t cmd, struct control_info *detail) { (void)cmd; (void)detail; return USB_UNSUPPORT; } static void wait (int count) { int i; for (i = 0; i < count; i++) asm volatile ("" : : "r" (i) : "memory"); } #define WAIT 2400000 int main (int argc, char *argv[]) { (void)argc; (void)argv; set_led (0); flash_end = FLASH_START_ADDR + (*FLASH_SIZE_REG)*1024; usb_lld_init (regnual_config_desc[7]); while (1) { set_led (1); wait (WAIT); set_led (0); wait (WAIT); } }