loic/pico-acm-cfw
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Init repository

Browse source
This commit is contained in:
Loïc Guégan 2025-03-24 09:33:49 +01:00
parent d3ecfe3498
commit 7741f01445
35 changed files with 2067 additions and 90 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
.gitignore vendored Normal file
View file

@ -0,0 +1,8 @@
/*.o
/*.S
*.bin
*.uf2
*.elf*
**/elf2uf2/elf2uf2
**/\#*
**/.\#*

41
Makefile Normal file
View file

@ -0,0 +1,41 @@
CPU=cortex-m0plus
TC=arm-none-eabi
CC_OPTS=-fno-builtin -fno-pie -no-pie -nolibc -nostartfiles -mcpu=$(CPU)
ELF2UF2=tools/elf2uf2/elf2uf2
PAD_CHECKSUM=tools/pad_checksum.py
all: firmware.uf2
firmware.uf2: firmware.elf
$(ELF2UF2) $^ $@
boot2.o: src/boot/boot2.S
$(TC)-gcc $(CC_OPTS) -c -o boot2.o $^
boot2_crc32.o: boot2.o
$(TC)-objcopy -O binary boot2.o boot2.bin
$(PAD_CHECKSUM) -p 256 -s 0xFFFFFFFF boot2.bin boot2_crc32.S
$(TC)-gcc -c -o boot2_crc32.o boot2_crc32.S
%.o: src/boot/%.S
$(TC)-gcc $(CC_OPTS) -c -o $@ $^
%.o: src/%.c
$(TC)-gcc $(CC_OPTS) -c -o $@ $^
%.o: src/libs/%.c
$(TC)-gcc $(CC_OPTS) -c -o $@ $^
%.o: src/libs/usb/%.c
$(TC)-gcc $(CC_OPTS) -c -o $@ $^
firmware.elf: boot2_crc32.o main.o crt0.o interrupts.o lock.o gpio.o utils.o clock.o cusb.o cdc-acm.o tty.o
$(TC)-ld -T linker.ld -Map=$@.map -o $@ $^
clean:
@rm -f ./*.o ./*crc32.S ./*.elf ./*.bin ./*.map
mrproper: clean
@rm -f firmware.uf2
.PHONY: clean mrproper

96
README.md
View file

@ -1,93 +1,9 @@
# pico-acm-cfw # pico-acm-cfw
This project is a Custom FirmWare for RP2040 written from scratch.
This CFW provides minimum hardware setup and support for USB CDC ACM.
Basic REPL code is given.
To test it, simply flash the RP2040 and connect to it with minicom.
# Requirements
## Getting started - gcc-arm-none-eabi
To make it easy for you to get started with GitLab, here's a list of recommended next steps.
Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
## Add your files
- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
- [ ] [Add files using the command line](https://docs.gitlab.com/topics/git/add_files/#add-files-to-a-git-repository) or push an existing Git repository with the following command:
```
cd existing_repo
git remote add origin https://gitlab.com/manzerbredes/pico-acm-cfw.git
git branch -M main
git push -uf origin main
```
## Integrate with your tools
- [ ] [Set up project integrations](https://gitlab.com/manzerbredes/pico-acm-cfw/-/settings/integrations)
## Collaborate with your team
- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
- [ ] [Set auto-merge](https://docs.gitlab.com/user/project/merge_requests/auto_merge/)
## Test and Deploy
Use the built-in continuous integration in GitLab.
- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/)
- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
***
# Editing this README
When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
## Suggestions for a good README
Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
## Name
Choose a self-explaining name for your project.
## Description
Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
## Badges
On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
## Visuals
Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
## Installation
Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
## Usage
Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
## Support
Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
## Roadmap
If you have ideas for releases in the future, it is a good idea to list them in the README.
## Contributing
State if you are open to contributions and what your requirements are for accepting them.
For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
## Authors and acknowledgment
Show your appreciation to those who have contributed to the project.
## License
For open source projects, say how it is licensed.
## Project status
If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.

37
linker.ld Normal file
View file

@ -0,0 +1,37 @@
MEMORY {
FLASH(rx) : ORIGIN = 0x10000000, LENGTH = 2048k
SRAM(rwx) : ORIGIN = 0x20000100, LENGTH = 256k - 256
}
SECTIONS {
.boot2 : {
*(.boot2);
} > FLASH
.crt0 : {
*(.crt0);
} > FLASH
__vector_table_start__ = .;
.vector_table : {
*(.vector_table);
} > FLASH
.text ALIGN(2) : {
*(.text)
} > FLASH
.data : {
*(.text)
} > SRAM AT> FLASH
__data_src__ = LOADADDR(.data);
__data_dst__ = ORIGIN(SRAM);
__data_size__ = SIZEOF(.data);
.bss : {
__bss_start__ = .;
*(.bss)
} > SRAM
__bss_size__ = SIZEOF(.bss);
}

38
src/boot/boot2.S Normal file
View file

@ -0,0 +1,38 @@
.thumb
.section .boot2, "ax"
// Disable SSI
ldr r0, =SSI_SSIENR
ldr r1, =0
str r1, [r0]
// Set baud rate
ldr r0, =SSI_BAUDR
ldr r1, =4
str r1, [r0]
// Enter XIP
ldr r0, =SSI_CTRLR0
ldr r1, =(3 << 8) | (31 << 16)
str r1, [r0]
// CTRLR0
ldr r0, =SSI_SPI_CTRLR0
ldr r1, =(6 << 2) | (2 << 8) | (0x03 << 24)
str r1, [r0]
// Enable back SSI
ldr r0, =SSI_SSIENR
ldr r1, =1
str r1, [r0]
// Jump to crt0.S
ldr r0, =0x10000101
bx r0
.set SSI_BASE, 0x18000000
.set SSI_CTRLR0, SSI_BASE + 0x00
.set SSI_SSIENR, SSI_BASE + 0x08
.set SSI_BAUDR, SSI_BASE + 0x14
.set SSI_SPI_CTRLR0, SSI_BASE + 0xF4

40
src/boot/crt0.S Normal file
View file

@ -0,0 +1,40 @@
.section .crt0, "ax"
// Load data segment to SRAM
ldr r0, =__data_src__
ldr r1, =__data_dst__
ldr r2, =__data_size__
mov r3, #0
data_seg_start:
cmp r2, #0
beq data_seg_end
ldrb r3, [r0]
strb r3, [r1]
add r0, #1
add r1, #1
sub r2, #1
b data_seg_start
data_seg_end:
// Init bss in SRAM
ldr r0, =__bss_start__
ldr r1, =__bss_size__
mov r2, #0
bss_init_start:
cmp r1, #0
beq bss_init_end
strb r2, [r0]
add r0, #1
sub r1, #1
b bss_init_start
bss_init_end:
// Setup stack
ldr r0, =SRAM_END
mov sp, r0
// Start kernel
ldr r0, =main
blx r0
.set SRAM_END, 0x20042000

87
src/libs/addrmap.h Normal file
View file

@ -0,0 +1,87 @@
#ifndef __ADDRMAP__
#define __ADDRMAP__
// ----- SIO -----
#define SIO_BASE 0xd0000000
#define SIO_CPUID SIO_BASE + 0x000
#define SIO_GPIO_OE SIO_BASE + 0x020
#define SIO_GPIO_OUT_XOR SIO_BASE + 0x01c
#define SIO_SPINLOCK0 SIO_BASE + 0x100
#define SIO_SPINLOCK31 SIO_BASE + 0x17c
// ----- RESET -----
#define RESETS_BASE 0x4000c000
#define RESETS_RESET RESETS_BASE + 0x0
#define RESETS_DONE RESETS_BASE + 0x8
// ----- Cortex M0+ -----
#define PPB_BASE 0xe0000000 // M0PLUS CPU registers
#define PPB_SYST_CSR PPB_BASE + 0xe010
#define PPB_SYST_RVR PPB_BASE + 0xe014
#define PPB_SYST_CVR PPB_BASE + 0xe018
#define PPB_SYST_CALIB PPB_BASE + 0xe01c
#define PPB_NVIC_ISER PPB_BASE + 0xe100
#define PPB_NVIC_ISPR PPB_BASE + 0xe200
#define PPB_NVIC_ICPR PPB_BASE + 0xe280
#define PPB_VTOR PPB_BASE + 0xed08
// ----- APB Peripherals -----
// IO_BANK0
#define IO_BANK0_BASE 0x40014000
#define IO_BANK0_GPIO25_STATUS IO_BANK0_BASE + 0x0C8
#define IO_BANK0_GPIO25_CTRL IO_BANK0_BASE + 0x0CC
// CLOCKS
#define CLOCKS_BASE 0x40008000
#define CLOCKS_SYS_CTRL CLOCKS_BASE + 0x03c
#define CLOCKS_SYS_DIV CLOCKS_BASE + 0x040
#define CLOCKS_SYS_SELECTED CLOCKS_BASE + 0x044
#define CLOCKS_REF_CTRL CLOCKS_BASE + 0x030
#define CLOCKS_PERI_CTRL CLOCKS_BASE + 0x048
#define CLOCKS_USB_CTRL CLOCKS_BASE + 0x054
// XOSC
#define XOSC_BASE 0x40024000
#define XOSC_CTRL XOSC_BASE + 0x000
#define XOSC_STATUS XOSC_BASE + 0x004
#define XOSC_DORMANT XOSC_BASE + 0x008
#define XOSC_STARTUP XOSC_BASE + 0x00c
#define XOSC_COUNT XOSC_BASE + 0x01c
// PLL_SYS
#define PLL_SYS_BASE 0x40028000
#define PLL_SYS_CS PLL_SYS_BASE + 0x000
#define PLL_SYS_PWR PLL_SYS_BASE + 0x004
#define PLL_SYS_FBDIV_INT PLL_SYS_BASE + 0x008
#define PLL_SYS_PRIM PLL_SYS_BASE + 0x00c
// PLL_USB
#define PLL_USB_BASE 0x4002c000
#define PLL_USB_CS PLL_USB_BASE + 0x000
#define PLL_USB_PWR PLL_USB_BASE + 0x004
#define PLL_USB_FBDIV_INT PLL_USB_BASE + 0x008
#define PLL_USB_PRIM PLL_USB_BASE + 0x00c
// SRAM
#define SRAM_BASE 0x20000000
#define SRAM_BANK4_BASE 0x20040000
#define SRAM_BANK5_BASE 0x20041000
#define SRAM_END SRAM_BASE + 0x42000
// USB Controller
#define USBCTRL_BASE 0x50100000
#define USBCTRL_DPSRAM_BASE USBCTRL_BASE + 0x000
#define USBCTRL_DPSRAM_SETUP_PACKET USBCTRL_DPSRAM_BASE + 0x000
#define USBCTRL_REGS_BASE 0x50110000
#define USBCTRL_EP0_BUFFER0 USBCTRL_DPSRAM_BASE + 0x100
#define USBCTRL_EP0_BUFFER_CTRL_IN USBCTRL_DPSRAM_BASE + 0x080
#define USBCTRL_EP0_BUFFER_CTRL_OUT USBCTRL_DPSRAM_BASE + 0x084
#define USBCTRL_EP1_ENDP_CTRL_IN USBCTRL_DPSRAM_BASE + 0x08
#define USBCTRL_EP1_BUFFER_CTRL_IN USBCTRL_DPSRAM_BASE + 0x88
#define USBCTRL_DATA_BUFFER_START USBCTRL_DPSRAM_BASE + 0x180
#define USBCTRL_ADDR_ENDP USBCTRL_REGS_BASE + 0x000
#define USBCTRL_MAINCTRL USBCTRL_REGS_BASE + 0x040
#define USBCTRL_SIE_CTRL USBCTRL_REGS_BASE + 0x04c
#define USBCTRL_SIE_STATUS USBCTRL_REGS_BASE + 0x050
#define USBCTRL_BUFF_STATUS USBCTRL_REGS_BASE + 0x058
#define USBCTRL_INTR USBCTRL_REGS_BASE + 0x08c
#define USBCTRL_INTE USBCTRL_REGS_BASE + 0x090
#define USBCTRL_INTS USBCTRL_REGS_BASE + 0x098
#define USBCTRL_MUXING USBCTRL_REGS_BASE + 0x074
#define USBCTRL_PWR USBCTRL_REGS_BASE + 0x078
#endif

42
src/libs/bitmap.h Normal file
View file

@ -0,0 +1,42 @@
#ifndef __BITMAP_H__
#define __BITMAP_H__
#define _BIT(BIT) (1u << (BIT))
// ----- USB Controller -----
// INTS
#define BIT_USBCTRL_INTS_SETUP_REQ _BIT(16)
#define BIT_USBCTRL_INTS_BUFFER_STATUS _BIT(4)
#define BIT_USBCTRL_INTS_TRANS_COMPLETE _BIT(3)
#define BIT_USBCTRL_INTS_BUS_RESET _BIT(12)
// SIE_STATUS
#define BIT_USBCTRL_SIE_STATUS_SETUP_REC _BIT(17)
#define BIT_USBCTRL_SIE_STATUS_BUS_RESET _BIT(19)
// Buffer control
#define BIT_USBCTRL_BUFFER0_PID _BIT(13)
#define BIT_USBCTRL_BUFFER0_FULL _BIT(15)
#define BIT_USBCTRL_BUFFER0_AVAILABLE _BIT(10)
#define MASK_USBCTRL_BUFFER0_LENGTH (0x3ff)
// Muxing
#define BIT_USBCTRL_MUXING_TO_PHY _BIT(0)
#define BIT_USBCTRL_MUXING_SOFTCON _BIT(3)
// Power
#define BIT_USBCTRL_PWR_VBUS_DETECT _BIT(2)
#define BIT_USBCTRL_PWR_VBUS_DETECT_OVERRIDE_EN _BIT(3)
// SIE_CTRL
#define BIT_USBCTRL_SIE_CTRL_PULLUP_EN _BIT(16)
#define BIT_USBCTRL_SIE_CTRL_PULLDOWN_EN _BIT(15)
#define BIT_USBCTRL_SIE_CTRL_EP0_INT_1BUF _BIT(29)
// MAIN_CTRL
#define BIT_USBCTRL_MAIN_CTRL_CONTROLLER_EN _BIT(0)
#define BIT_USBCTRL_MAIN_CTRL_HOST_NDEVICE _BIT(1)
// INTE
#define BIT_USBCTRL_INTE_SETUP_REQ _BIT(16)
#define BIT_USBCTRL_INTE_BUS_RESET _BIT(12)
#define BIT_USBCTRL_INTE_BUFF_STATUS _BIT(4)
// Endpoint Control
#define BIT_USBCTRL_ENDP_CTRL_ENABLE _BIT(31)
#define BIT_USBCTRL_ENDP_CTRL_INT_PER_BUFF1 _BIT(29)
#define BIT_USBCTRL_ENDP_CTRL_TYPE_LSB (26)
#endif

57
src/libs/clock.c Normal file
View file

@ -0,0 +1,57 @@
#include "clock.h"
#include "addrmap.h"
#include "types.h"
#include "utils.h"
// Updated at each systick interrupts, one for each core
__attribute__((aligned(4))) u32 cores_systick[2];
void wait(u32 ms){
u32 cpuid=REG_READ(SIO_CPUID);
cores_systick[cpuid]=0; // Init core counter
while(cores_systick[cpuid]<ms){} // Wait for correct amount of ticks
}
void xosc_init() {
// Starting xosc
REG_WRITE(XOSC_CTRL, 0xAA0); // Straight up from doc (to set it up to max (15MHz) => 12MHz in reality because of the xosc crystal)
REG_WRITE(XOSC_STARTUP, 0x00C4); // Startup delay (default value)
REG_WRITE_BITMAP_SET(XOSC_CTRL, 0xFAB << 12); // Enable clock
while(!(REG_READ(XOSC_STATUS) & 1<<31)){} // Wait for xosc to be stable
// Reset System PLL
REG_WRITE_BITMAP_CLEAR(RESETS_RESET, 1<<12); // Reset System PLL
while((REG_READ(RESETS_DONE) & 1<<12) == 0){} // Wait for System PLL reset to be done
// Setup and starts System PLL
// We use default config from (P232) which generate a 125MHz clock signal
REG_WRITE(PLL_SYS_FBDIV_INT, 125); // Multiply factor (we multply input frequency by 125 (so Fxosc * 10 = 125*12MHz = 1500MHz))
REG_WRITE(PLL_SYS_PRIM, 6<<16|2<<12); // Post divider divide output frequency by 6 then 2 (totally 12) thus Ffinal=1500MHz/12 = 125MHz
REG_WRITE_BITMAP_CLEAR(PLL_SYS_PWR, 1<<5|1<<3|1<<0); // Turn on VCO + PLL + fbdiv
while(!(REG_READ(PLL_SYS_CS) & 1<<31)){} // Wait for System PLL to be locked (Fin == Fout * Fact)
// By default System PLL is connected to sys_clk auxsrc
// So, just permute sys_clck to auxsrc (remember it is glitchless)
REG_WRITE(CLOCKS_SYS_CTRL, 0x1); // Now cores are using System PLL output
// Setup clock interrupt (1 every ms)
REG_WRITE(PPB_SYST_RVR, 125*1000); // We want 1tick per ms = 125MHz/125e3 = 1000Hz == 1 tick per ms, we can argue on accuracy here...
REG_WRITE(PPB_SYST_CSR, 0b111); // Clock source for Systick is core clock (PLL)/ Interrupt enable / Counter enable
// Now, setup USB PLL, reset USB PLL
REG_WRITE_BITMAP_CLEAR(RESETS_RESET, 1<<13); // Reset USB PLL
while((REG_READ(RESETS_DONE) & 1<<13) == 0){} // Wait for USB PLL reset to be done
// We use default config from (P232) which generate a 48MHz clock signal for USB
REG_WRITE(PLL_USB_FBDIV_INT, 100); // Multiply factor (we multply input frequency by 100 (so Fxosc * 100 = 100*12MHz = 1200MHz))
REG_WRITE(PLL_USB_PRIM, 5<<16|5<<12); // Post divider divide output frequency by 5 then 5 (totally 25) thus Ffinal=1200MHz/25 = 48MHz
REG_WRITE_BITMAP_CLEAR(PLL_USB_PWR, 1<<5|1<<3|1<<0); // Turn on VCO + PLL + fbdiv
while(!(REG_READ(PLL_USB_CS) & 1<<31)){} // Wait for USB PLL to be locked
// Enable USB clock generator
REG_WRITE(CLOCKS_USB_CTRL,1<<11);
// Last step, use XOSC for clock ref
REG_WRITE(CLOCKS_REF_CTRL, 2); // This is glitchless
}

9
src/libs/clock.h Normal file
View file

@ -0,0 +1,9 @@
#ifndef __CLOCK_H__
#define __CLOCK_H__
#include "types.h"
void xosc_init();
void wait(u32 ms); // Did not test much that one
#endif

39
src/libs/gpio.c Normal file
View file

@ -0,0 +1,39 @@
#include "addrmap.h"
#include "utils.h"
#include "gpio.h"
void gpio_init() { REG_WRITE_BITMAP_CLEAR(RESETS_BASE, 32);} // Reset bank0 (all gpios)
void gpio_set_function(u8 gpio, u8 fn){
REG_WRITE(IO_BANK0_GPIO25_CTRL, fn); // Set function as SIO
}
void gpio_output_enable(u8 gpio){
u32 r=REG_READ(SIO_GPIO_OE)|1<<gpio;
REG_WRITE(SIO_GPIO_OE, r);
}
void gpio_toggle_state(u8 gpio){
REG_WRITE(SIO_GPIO_OUT_XOR,1<<gpio);
}
void gpio_toggle_led(){
// Ensure led pin is configured
u32 fn=REG_READ(IO_BANK0_GPIO25_CTRL);
u32 oe=REG_READ(SIO_GPIO_OE)&1<<25;
if(fn!=GPIO_FN_SIO || !oe){
gpio_set_function(25, GPIO_FN_SIO);
gpio_output_enable(25);
}
gpio_toggle_state(25); // Switch between ON/OFF
}
void gpio_blink_led(int n){
for(int i=0;i<n;i++){
gpio_toggle_led();
for(int j=0;j<5000000;j++){} // These are disgusting but I am lazy..
gpio_toggle_led();
for(int j=0;j<5000000;j++){}
}
}

22
src/libs/gpio.h Normal file
View file

@ -0,0 +1,22 @@
#ifndef __GPIO_H__
#define __GPIO_H__
#include "types.h"
#define GPIO_FN_SPI 1
#define GPIO_FN_UART 2
#define GPIO_FN_I2C 3
#define GPIO_FN_PWM 4
#define GPIO_FN_SIO 5
#define GPIO_FN_PIO0 6
#define GPIO_FN_PIO1 7
#define GPIO_FN_USB 8
void gpio_init();
void gpio_set_function(u8 gpio, u8 fn);
void gpio_output_enable(u8 gpio);
void gpio_toggle_state(u8 gpio);
void gpio_toggle_led();
void gpio_blink_led(int n);
#endif

67
src/libs/interrupts.c Normal file
View file

@ -0,0 +1,67 @@
#include "interrupts.h"
#include "addrmap.h"
#include "bitmap.h"
#include "utils.h"
#include "gpio.h"
#include "usb/cusb.h"
extern u32 cores_systick[];
void isr_unbind(void){}
void isr_systick(void){
cores_systick[0]++; // Core 0
cores_systick[1]++; // Core 1
}
void isr_usb(){
if(cusb_check_interrupt(BIT_USBCTRL_INTS_SETUP_REQ)){
REG_WRITE_BITMAP_CLEAR(USBCTRL_SIE_STATUS, BIT_USBCTRL_SIE_STATUS_SETUP_REC);
cusb_handle_setup();
}
if(cusb_check_interrupt(BIT_USBCTRL_INTS_BUS_RESET)){
REG_WRITE_BITMAP_CLEAR(USBCTRL_SIE_STATUS, BIT_USBCTRL_SIE_STATUS_BUS_RESET);
cusb_handle_bus_reset();
}
if(cusb_check_interrupt(BIT_USBCTRL_INTS_BUFFER_STATUS)){
cusb_handle_buffer_status();
}
cusb_eoi();
}
__attribute__((used,aligned(4),section(".vector_table"))) void (*vtable[])(void) = {
(void (*)(void))SRAM_END,
// ----- Start of internal (to core) interrupts
isr_unbind, // 01-NMI
isr_unbind, // 02-HardFault
isr_unbind, // 03-Unused
isr_unbind, // 04-Unused
isr_unbind, // 05-Unused
isr_unbind, // 06-Unused
isr_unbind, // 07-Unused
isr_unbind, // 08-Unused
isr_unbind, // 09-Unused
isr_unbind, // 10-Unused
isr_unbind, // 11-SVCall
isr_unbind, // 12-Unused
isr_unbind, // 13-Unused
isr_unbind, // 14-PendSV
isr_systick, // 15-SysTick
// ----- Start of external (RP2040 ones) interrupts
isr_unbind, // 00-Unused
isr_unbind, // 01-Unused
isr_unbind, // 02-Unused
isr_unbind, // 03-Unused
isr_unbind, // 04-Unused
isr_usb // 05-Usb Controller
};
void interrupts_init(){
memcpy((void*)SRAM_BASE, (void*)vtable, 4*30);
REG_WRITE(PPB_VTOR, SRAM_BASE);
}
void interrupts_enable(int num){
REG_WRITE(PPB_NVIC_ICPR, 1<<num); // Clear pending interrupts
REG_WRITE(PPB_NVIC_ISER, 1<<num); // Enable num interrupts
}

7
src/libs/interrupts.h Normal file
View file

@ -0,0 +1,7 @@
#ifndef __INTERRUPT_H__
#define __INTERRUPT_H__
void interrupts_init();
void interrupts_enable(int num);
#endif

25
src/libs/lock.c Normal file
View file

@ -0,0 +1,25 @@
#include "lock.h"
#include "utils.h"
#include "addrmap.h"
#include "time.h"
char locks_pool[LOCKS_POOL_SIZE]; // Automatically zeroed (.bss)
void lock_acquire(int lockid) {
while(1){
while(locks_pool[lockid]) {} // Lurking stage
while(!REG_READ(HARDWARE_LOCK)){} // Acquire HW lock
if(!locks_pool[lockid]){
locks_pool[lockid]=1; // Acquire the lock
REG_WRITE(HARDWARE_LOCK,0); // Release HW lock
break;
}
REG_WRITE(HARDWARE_LOCK,0);
}
}
void lock_release(int lockid) {
while(!REG_READ(HARDWARE_LOCK)){}
locks_pool[lockid]=0;
REG_WRITE(HARDWARE_LOCK,0);
}

10
src/libs/lock.h Normal file
View file

@ -0,0 +1,10 @@
#ifndef __LOCK_H__
#define __LOCK_H__
#define LOCKS_POOL_SIZE 10
#define HARDWARE_LOCK SIO_SPINLOCK31
void lock_acquire(int lockid);
void lock_release(int lockid);
#endif

27
src/libs/tty.c Normal file
View file

@ -0,0 +1,27 @@
#include "tty.h"
#include "gpio.h"
#include "usb/cdc-acm.h"
#include "usb/cusb.h"
#include "utils.h"
#include "addrmap.h"
void tty_init(void){
usb_cdc_acm_init();
}
char tty_getchar(void){
char c;
usb_cdc_acm_recv(&c, 1);
return c;
}
void tty_putchar(char c){
char str[2]="";
str[0]=c;
usb_cdc_acm_send(str, 2);
}
void tty_putstr(char *str){
usb_cdc_acm_send(str, strlen(str)+1);
}

9
src/libs/tty.h Normal file
View file

@ -0,0 +1,9 @@
#ifndef __TTY_H__
#define __TTY_H__
void tty_init(void);
char tty_getchar(void);
void tty_putchar(char c);
void tty_putstr(char *str);
#endif

8
src/libs/types.h Normal file
View file

@ -0,0 +1,8 @@
#ifndef __TYPES_H__
#define __TYPES_H__
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
#endif

184
src/libs/usb/cdc-acm.c Normal file
View file

@ -0,0 +1,184 @@
#include "cdc-acm.h"
#include "cusb.h"
#include "proto.h"
#include "../gpio.h"
#include "../addrmap.h"
void cdc_acm_ep1_in_handler(u8 *buffer, int len);
void cdc_acm_ep2_in_handler(u8 *buffer, int len);
void cdc_acm_ep3_out_handler(u8 *buffer, int len);
void cdc_acm_setup_handler(UD_SETUP *pkt);
void cdc_acm_setup_ack_handler(void);
void cdc_acm_eoi(void);
u8 configuration_descriptor[128];
u8 *send_buffer;
u8 send_buffer_size=0;
u8 *recv_buffer;
u8 recv_buffer_size=0;
DeviceConfiguration CDC_ACM_CONFIG ={
.device_descriptor = {
.bDeviceClass = USB_DEVICE_CLASS_CDC,
.idProduct = 1,
.iManufacturer = 1, // String id 1
.iProduct = 2 // String id 2
},
.configuration_descriptor = {
.bNumInterfaces = 2
},
.interface_descriptors = {
{
.bInterfaceClass = USB_INTERFACE_CLASS_COMMUNICATION,
.bInterfaceSubClass = USB_INTERFACE_SUBCLASS_ACM,
.bInterfaceProtocol = USB_INTERFACE_COMMUNICATION_PROTOCOL_NOPROTO,
.bInterfaceNumber = 0,
.bNumEndpoints = 1 // SHOULD BE 1 (IT IS 0 BECAUSE GET_CONFIG DESCRIPTOR MUST BE UPDATED)
},
{
.bInterfaceClass = USB_INTERFACE_CLASS_DATA,
.bInterfaceProtocol = USB_INTERFACE_COMMUNICATION_PROTOCOL_NOPROTO,
.bInterfaceNumber = 1,
.bNumEndpoints = 2
}
},
.endpoints = {
{
.endpoint_descriptor = {
.bEndpointAddress = B_ENDPOINT_ADDRESS(1, USB_DIRECTION_IN),
.wMaxPacketSize=64,
.bmAttributes = USB_TRANSFERT_TYPE_INTERRUPT,
.bInterval = 0
},
.handler = cdc_acm_ep1_in_handler
},
{
.endpoint_descriptor = {
.bEndpointAddress = B_ENDPOINT_ADDRESS(2, USB_DIRECTION_IN),
.wMaxPacketSize=64,
.bmAttributes = USB_TRANSFERT_TYPE_BULK,
.bInterval = 0
},
.handler = cdc_acm_ep2_in_handler
},
{
.endpoint_descriptor = {
.bEndpointAddress = B_ENDPOINT_ADDRESS(3, USB_DIRECTION_OUT),
.wMaxPacketSize=64,
.bmAttributes = USB_TRANSFERT_TYPE_BULK,
.bInterval = 0
},
.handler = cdc_acm_ep3_out_handler
},
},
.descriptor_strings = {
"Raspberry Pi", // Vendor
"Pico RP2040" // Product
},
.supported_languages = {
.wLANGID0 = USB_LANG_ENGLISH_US
},
.setup_handler = cdc_acm_setup_handler,
.setup_ack_handler = cdc_acm_setup_ack_handler,
.eoi=cdc_acm_eoi
};
void usb_cdc_acm_init(void) {
cusb_init(&CDC_ACM_CONFIG);
USB_CDC_ACM_FUNCTIONAL_DESCRIPTOR f;
f.header_descriptor.bFunctionLength=sizeof(USB_CDC_HEADER_FUNCTIONAL_DESCRIPTOR);
f.header_descriptor.bDescriptorType=0x24;
f.header_descriptor.bcdCDC=0b0110;
f.acm_descriptor.bFunctionLength=sizeof(USB_ACM_FUNCTIONAL_DESCRIPTOR);
f.acm_descriptor.bDescriptorType=0x24;
f.acm_descriptor.bDescriptorSubtype=0x02;
f.acm_descriptor.bmCapabilities=0xf;
f.union_descriptor.bFunctionLength=sizeof(USB_UNION_INTERFACE_DESCRIPTOR);
f.union_descriptor.bDescriptorType=0x24;
f.union_descriptor.bDescriptorSubtype=0x06;
f.union_descriptor.bMasterInterface=0;
f.union_descriptor.bSlaveInterface0=1;
// ----- Setting-up full configuration descriptor -----
u8 *ptr=configuration_descriptor;
// Configuration descriptor
memcpy(ptr,(void*) &(CDC_ACM_CONFIG.configuration_descriptor), sizeof(USB_CONFIGURATION_DESCRIPTOR));
ptr+=sizeof(USB_CONFIGURATION_DESCRIPTOR);
// Communication interface descriptor
memcpy(ptr,(void*) &(CDC_ACM_CONFIG.interface_descriptors[0]), sizeof(USB_INTERFACE_DESCRIPTOR));
ptr+=sizeof(USB_INTERFACE_DESCRIPTOR);
memcpy(ptr,(void*) &f, sizeof(USB_CDC_ACM_FUNCTIONAL_DESCRIPTOR)); // Functional descriptor
ptr+=sizeof(USB_CDC_ACM_FUNCTIONAL_DESCRIPTOR);
memcpy(ptr,(void*) &(CDC_ACM_CONFIG.endpoints[0].endpoint_descriptor), sizeof(USB_ENDPOINT_DESCRIPTOR)); // Endpoint descriptor
ptr+=sizeof(USB_ENDPOINT_DESCRIPTOR);
// Data interface descriptor
memcpy(ptr,(void*) &(CDC_ACM_CONFIG.interface_descriptors[1]), sizeof(USB_INTERFACE_DESCRIPTOR));
ptr+=sizeof(USB_INTERFACE_DESCRIPTOR);
memcpy(ptr,(void*) &(CDC_ACM_CONFIG.endpoints[1].endpoint_descriptor), sizeof(USB_ENDPOINT_DESCRIPTOR));
ptr+=sizeof(USB_ENDPOINT_DESCRIPTOR);
memcpy(ptr,(void*) &(CDC_ACM_CONFIG.endpoints[2].endpoint_descriptor), sizeof(USB_ENDPOINT_DESCRIPTOR));
ptr+=sizeof(USB_ENDPOINT_DESCRIPTOR);
// Setup full descriptor length
USB_CONFIGURATION_DESCRIPTOR *conf=(USB_CONFIGURATION_DESCRIPTOR*)configuration_descriptor;
conf->wTotalLength=ptr-configuration_descriptor;
// Finalize
CDC_ACM_CONFIG.full_configuration_descriptor=configuration_descriptor;
// Start receiving from host
cusb_start_xfer(0,64,&(CDC_ACM_CONFIG.endpoints[2]));
}
void cdc_acm_ep1_in_handler(u8 *buffer, int len) {}
void cdc_acm_ep2_in_handler(u8 *buffer, int len) {
send_buffer_size=0;
}
void cdc_acm_ep3_out_handler(u8 *buffer, int len) {
if(recv_buffer_size){
memcpy(recv_buffer, buffer, len);
recv_buffer_size=0; // Prevent further receive until usb_cdc_acm_recv() is called again
cusb_start_xfer(0,64,&(CDC_ACM_CONFIG.endpoints[2]));
}
}
void cdc_acm_setup_handler(UD_SETUP *pkt){
u8 direction=pkt->bmRequestType & BM_REQUEST_TYPE_DIR_BIT;
if(pkt->bRequest == USB_REQUEST_CODE_SET_LINE_CODING){
// TODO
}
else if(pkt->bRequest == USB_REQUEST_CODE_SET_CONTROL_LINE_STATE){
// TODO
}
else if(pkt->bRequest == USB_REQUEST_CODE_SEND_BREAK){
// TODO
}
else {
// TODO
}
}
void cdc_acm_setup_ack_handler(void){
}
void cdc_acm_eoi(void){
if(send_buffer_size)
cusb_start_xfer(send_buffer,send_buffer_size,&(CDC_ACM_CONFIG.endpoints[1]));
}
void usb_cdc_acm_send(char *data, int size){
send_buffer=data;
send_buffer_size=size;
cusb_isr_trigger();
while(send_buffer_size){};
}
void usb_cdc_acm_recv(char *data, int size){
recv_buffer=data;
recv_buffer_size=size;
while(recv_buffer_size){}
}

10
src/libs/usb/cdc-acm.h Normal file
View file

@ -0,0 +1,10 @@
#ifndef __CDC_ACM_H__
#define __CDC_ACM_H__
#include "proto.h"
void usb_cdc_acm_init(void);
void usb_cdc_acm_send(char *data, int size);
void usb_cdc_acm_recv(char *data, int size);
#endif

309
src/libs/usb/cusb.c Normal file
View file

@ -0,0 +1,309 @@
#include "cusb.h"
#include "../addrmap.h"
#include "../bitmap.h"
#include "../interrupts.h"
#include "../gpio.h"
#include "proto.h"
u8 xferbuff[64]; // Free to use for transfer (IN)
u8 *xferptr;
u8 xferremain=0;
DeviceConfiguration *cusb_dc;
void cusb_init(DeviceConfiguration *dc){
// Reset USB controller
REG_WRITE_BITMAP_CLEAR(RESETS_RESET, 1<<24); // Reset USBCTRL
while((REG_READ(RESETS_DONE) & 1<<24) == 0){} // Wait controller reset
// Flush USB Controller DPSRAM
memset((void*)USBCTRL_DPSRAM_BASE, 0, USBCTRL_DPSRAM_SIZE);
// Enable usb controller interrupt
interrupts_enable(5);
// Setup controller
REG_WRITE(USBCTRL_MUXING, BIT_USBCTRL_MUXING_TO_PHY|BIT_USBCTRL_MUXING_SOFTCON);
REG_WRITE(USBCTRL_PWR, BIT_USBCTRL_PWR_VBUS_DETECT|BIT_USBCTRL_PWR_VBUS_DETECT_OVERRIDE_EN);
REG_WRITE(USBCTRL_MAINCTRL, BIT_USBCTRL_MAIN_CTRL_CONTROLLER_EN); // Set device mode + enable controller
REG_WRITE(USBCTRL_SIE_CTRL, BIT_USBCTRL_SIE_CTRL_EP0_INT_1BUF); // Enable usb interrupts on EP0
REG_WRITE(USBCTRL_INTE, BIT_USBCTRL_INTE_SETUP_REQ|BIT_USBCTRL_INTE_BUS_RESET|BIT_USBCTRL_INTE_BUFF_STATUS); // Setup interrupt granularity
// Initialize device configuration
cusb_dc=dc; // Store controller device config
cusb_init_device_configuration();
// Initialize endpoints
for(int i=0;i<USB_ENDPOINT_COUNT;i++){
EndPointConfiguration *ep=&(cusb_dc->endpoints[i]);
u32 dir=ep->endpoint_descriptor.bEndpointAddress & 0x80;
u32 id=ep->endpoint_descriptor.bEndpointAddress & 0xF;
// Endpoint and buffer control
u32 endpoint_control=USBCTRL_EP1_ENDP_CTRL_IN+0x8*(id-1); // -1 since start at 1 (ep0 already covered in cusb_init_device_configuration())
u32 buffer_control=USBCTRL_EP1_BUFFER_CTRL_IN+0x8*(id-1);
if(dir == USB_DIRECTION_OUT){
endpoint_control+=4;
buffer_control+=4;
}
ep->endpoint_control=(void*)(endpoint_control);
ep->buffer_control=(void*)(buffer_control);
// Init buffers
u32 buffer0=USBCTRL_DATA_BUFFER_START+(64*2)*(id-1); // 64 bits aligned warning see p388
u32 buffer1=buffer0+64;
ep->buffer0=(void*)buffer0;
ep->buffer1=(void*)buffer1;
// Init ep control
u32 epctrl=BIT_USBCTRL_ENDP_CTRL_ENABLE |
BIT_USBCTRL_ENDP_CTRL_INT_PER_BUFF1 |
ep->endpoint_descriptor.bmAttributes << BIT_USBCTRL_ENDP_CTRL_TYPE_LSB|
USB_BUFFER_OFFSET(buffer0);
*ep->endpoint_control=epctrl; // Apply buffer control setting
ep->next_pid=0; // Maybe that is good?
}
// Pull-up usb line! (for the host :)
REG_WRITE_BITMAP_SET(USBCTRL_SIE_CTRL, BIT_USBCTRL_SIE_CTRL_PULLUP_EN);
}
void cusb_init_device_configuration(){
// Init device descriptor
cusb_dc->device_descriptor.bLength=sizeof(USB_DEVICE_DESCRIPTOR);
cusb_dc->device_descriptor.bDescriptorType=USB_DESCRIPTOR_TYPE_DEVICE;
cusb_dc->device_descriptor.bNumConfigurations = 1; // We support only 1
cusb_dc->device_descriptor.bcdUSB=BCD_USB;
cusb_dc->device_descriptor.bMaxPacketSize0=64;
// Init configuration descriptor
cusb_dc->configuration_descriptor.bLength=sizeof(USB_CONFIGURATION_DESCRIPTOR);
cusb_dc->configuration_descriptor.bDescriptorType=USB_DESCRIPTOR_TYPE_CONFIGURATION;
cusb_dc->configuration_descriptor.bConfigurationValue = 1; // Configuration id
cusb_dc->configuration_descriptor.iConfiguration = 0; // No string
cusb_dc->configuration_descriptor.bmAttributes = 0xC0; // attributes: self powered, no remote wakeup
cusb_dc->configuration_descriptor.bMaxPower = 0x32; // 100ma
// Init device state
cusb_dc->devaddr=0; // Just in case
cusb_dc->setdevaddr=0; // Just in case
cusb_dc->setdevaddr=0; // Just in case
// Init string zero descriptor
cusb_dc->supported_languages.bLength = sizeof(USB_STRING_DESCRIPTOR_ZERO);
cusb_dc->supported_languages.bDescriptorType = USB_DESCRIPTOR_TYPE_STRING;
// Init ep0 in
EndPointConfiguration *ep0_in= &(cusb_dc->endpoints[USB_ENDPOINT_COUNT]);
ep0_in->buffer0=(void*)USBCTRL_EP0_BUFFER0;
ep0_in->buffer1=(void*)USBCTRL_EP0_BUFFER0+0x40;
ep0_in->buffer_control=(void*)USBCTRL_EP0_BUFFER_CTRL_IN;
ep0_in->handler=cusb_ep0_in_handler;
ep0_in->endpoint_descriptor.bEndpointAddress = B_ENDPOINT_ADDRESS(0, USB_DIRECTION_IN);
ep0_in->endpoint_descriptor.bmAttributes = USB_TRANSFERT_TYPE_CONTROL;
ep0_in->endpoint_descriptor.wMaxPacketSize=64;
// Init ep0 out
EndPointConfiguration *ep0_out= &(cusb_dc->endpoints[USB_ENDPOINT_COUNT+1]);
ep0_out->buffer0=(void*)USBCTRL_EP0_BUFFER0;
ep0_out->buffer1=(void*)USBCTRL_EP0_BUFFER0+0x40;
ep0_out->buffer_control=(void*)USBCTRL_EP0_BUFFER_CTRL_OUT;
ep0_out->handler=cusb_ep0_out_handler;
ep0_out->endpoint_descriptor.bEndpointAddress = B_ENDPOINT_ADDRESS(0, USB_DIRECTION_OUT);
ep0_out->endpoint_descriptor.bmAttributes = USB_TRANSFERT_TYPE_CONTROL;
ep0_out->endpoint_descriptor.wMaxPacketSize=64;
// Init bLength
for(char i=0;i<USB_ENDPOINT_COUNT+2;i++){
cusb_dc->endpoints[i].endpoint_descriptor.bLength=sizeof(USB_ENDPOINT_DESCRIPTOR);
cusb_dc->endpoints[i].endpoint_descriptor.bDescriptorType=USB_DESCRIPTOR_TYPE_ENDPOINT;
}
// Init interfaces
for(char i=0;i<USB_INTERFACE_COUNT;i++){
cusb_dc->interface_descriptors[i].bLength=sizeof(USB_INTERFACE_DESCRIPTOR);
cusb_dc->interface_descriptors[i].bDescriptorType=USB_DESCRIPTOR_TYPE_INTERFACE;
}
}
int cusb_check_interrupt(int int_bit){
if(REG_READ(USBCTRL_INTS) & int_bit)
return 1;
return 0;
}
void cusb_handle_bus_reset(void){
// https://github.com/raspberrypi/pico-examples/blob/master/usb/device/dev_lowlevel/dev_lowlevel.c#L469
REG_WRITE(USBCTRL_ADDR_ENDP, 0); // Remove device address from controller
cusb_dc->devaddr=0; // No more device address
cusb_dc->setdevaddr=0; // Ensure no device address will be set
cusb_dc->configured=0;
}
EndPointConfiguration* cusb_get_endpoint(char num, u32 direction){
EndPointConfiguration *ep;
for(char i=0;i<(USB_ENDPOINT_COUNT+2);i++){
ep=&(cusb_dc->endpoints[i]);
u32 bEndpointAddress=ep->endpoint_descriptor.bEndpointAddress;
// Bit 7 (mask 0x80) is IN or OUT and first 4 bits is addr (see p269)
if((bEndpointAddress & 0x80) == direction && (bEndpointAddress & 0xF) == num)
return ep;
}
return 0;
}
void cusb_handle_setup(void){
UD_SETUP *pkt=(UD_SETUP*)USBCTRL_DPSRAM_SETUP_PACKET;
// Always responds with DATA1 PID
EndPointConfiguration *ep=cusb_get_endpoint(0, USB_DIRECTION_IN);
ep->next_pid=1;
u8 direction=pkt->bmRequestType & BM_REQUEST_TYPE_DIR_BIT;
if(direction == USB_DIRECTION_OUT){
if (pkt->bRequest == USB_REQUEST_CODE_SET_ADDRESS){
cusb_dc->devaddr= pkt->wValue & 0xff;
cusb_dc->setdevaddr=1;
// Since we should acknowledge (status phase) before setting the address
// we use setdevaddr boolean. When status done, buffer_status interrupt will be triggered
// and ep0_in_handler will set the address
cusb_status_xfer(USB_DIRECTION_IN);
} else if (pkt->bRequest == USB_REQUEST_CODE_SET_CONFIGURATION) {
cusb_status_xfer(USB_DIRECTION_IN);
cusb_dc->configured=1;
} else {
if(cusb_dc->setup_handler){
cusb_dc->setup_handler(pkt);
}
// Acknowledge whatever other requests
cusb_status_xfer(USB_DIRECTION_IN);
}
} else if(direction == USB_DIRECTION_IN){
if(pkt->bRequest == USB_REQUEST_CODE_GET_DESCRIPTOR){
int desc_type=pkt->wValue>>8; // See USB SPecification (wValue contains descriptor type+index)
if(desc_type == USB_DESCRIPTOR_TYPE_DEVICE ){
// Send descriptor
cusb_start_xfer(&cusb_dc->device_descriptor, sizeof(USB_DEVICE_DESCRIPTOR), ep);
} else if(desc_type == USB_DESCRIPTOR_TYPE_CONFIGURATION ){
USB_CONFIGURATION_DESCRIPTOR *conf=cusb_dc->full_configuration_descriptor;
int size=conf->bLength;
if(pkt->wLength > size)
size=conf->wTotalLength;
// Send descriptors!!
cusb_start_xfer(conf, size, ep);
} else if(desc_type == USB_DESCRIPTOR_TYPE_STRING ){
u8 id = pkt->wValue & 0xff; // Get string id
if(id==0){ // This is the special string descriptor for supported language
cusb_start_xfer(&(cusb_dc->supported_languages), sizeof(USB_STRING_DESCRIPTOR_ZERO), ep);
}
else {
char *str=cusb_dc->descriptor_strings[id-1]; // Remember id 0 taken by ZERO DESCriptor
u8 *ptr=xferbuff;
USB_UNICODE_STRING_DESCRIPTOR *u=(USB_UNICODE_STRING_DESCRIPTOR*)ptr;
u->bLength = sizeof(USB_UNICODE_STRING_DESCRIPTOR);
u->bDescriptorType=USB_DESCRIPTOR_TYPE_STRING;
char c;
ptr+=sizeof(USB_UNICODE_STRING_DESCRIPTOR); // String first 2 descriptor entries
do {
c = *str++;
*ptr++ = c;
*ptr++ = 0; // Unicode
u->bLength+=2; // Unicode
} while(c != '\0');
cusb_start_xfer(xferbuff, u->bLength, ep);
}
}
else {
cusb_dc->setup_handler(pkt);
}
}
}
}
void cusb_handle_buffer_status(void){
u32 status=REG_READ(USBCTRL_BUFF_STATUS);
for(u8 num=0;num<16;num++){
for(u8 i=0;i<2;i++){
u32 bit=1u << (num*2+i); // Shift register for IN and OUT for endpoint num
if(status & bit){
u32 dir=i ? USB_DIRECTION_OUT : USB_DIRECTION_IN;
EndPointConfiguration *ep=cusb_get_endpoint(num,dir);
REG_WRITE_BITMAP_CLEAR(USBCTRL_BUFF_STATUS, bit); // Clear buffer status
ep->handler((u8*)ep->buffer0,*(ep->buffer_control)&MASK_USBCTRL_BUFFER0_LENGTH);
}
}
}
}
void cusb_status_xfer(u32 dir){
// If dir == USB_DIRECTION_OUT
// controller will receive the out token from host then send acknowledgement
// otherwise if we do not perform xfer when receiving out token, then controller do not send acknowledgement which do not complete the control transaction
// If dir == USB_DIRECTION_IN
// controller will receive the in token from host then send zlp and receive acknowledgement from host
EndPointConfiguration *ep=cusb_get_endpoint(0, dir);
cusb_start_xfer(0,0,ep);
}
void cusb_ep0_in_handler(u8 *buffer, int len) {
// This function is trigger when buff_status interrupt is handled
// it is called inside cusb_handle_buffer_status
if(cusb_dc->setdevaddr){
REG_WRITE(USBCTRL_ADDR_ENDP, cusb_dc->devaddr);
cusb_dc->setdevaddr=0;
}
else if(xferremain>0){
EndPointConfiguration *ep=cusb_get_endpoint(0, USB_DIRECTION_IN);
cusb_start_xfer(xferptr,xferremain,ep);
}
else {
cusb_status_xfer(USB_DIRECTION_OUT); // Acknowledge with zlp when setup transaction ends
}
}
void cusb_ep0_out_handler(u8 *buffer, int len) {
// This function is trigger when buff_status interrupt is handled
// it is called inside cusb_handle_buffer_status
}
void cusb_start_xfer(void* data, u32 size, EndPointConfiguration *ep){
u32 buffer_ctrl = size; // Set data size
buffer_ctrl|=ep->next_pid ? BIT_USBCTRL_BUFFER0_PID : 0; // Set DATA0 or DATA1
ep->next_pid ^= 1u; // For next transfert
// Move user data to usb buffer if needed
u32 direction=ep->endpoint_descriptor.bEndpointAddress & 0x80;
if(direction == USB_DIRECTION_IN){
memcpy((void *)ep->buffer0, data, size);
buffer_ctrl |= BIT_USBCTRL_BUFFER0_FULL; // Set buffer full for controller
// Support for data > 64 bytes (see also cusb_ep0_in_handler())
if(size>64){
xferremain=size-64;
xferptr=((u8*) data)+64;
}
else {
xferremain=0;
}
}
// Setup buffer (not available bit yet)
*(ep->buffer_control)=buffer_ctrl;
// Now do available bit (because USB and cores have different clock speed (race condition see p389)
asm volatile("nop;nop;nop;"); // ceil(125MHz/48MHz) Should wait 3 cycles see warning p392
*(ep->buffer_control)=buffer_ctrl| BIT_USBCTRL_BUFFER0_AVAILABLE; // Apply available bit
}
void cusb_eoi(){
if(cusb_dc->eoi)
cusb_dc->eoi();
}
void cusb_isr_trigger(){
REG_WRITE(PPB_NVIC_ISPR, 1u<<5); // Trigger interrupt 5 (USB Controller)
}

72
src/libs/usb/cusb.h Normal file
View file

@ -0,0 +1,72 @@
#ifndef __USB_H__
#define __USB_H__
#include "../types.h"
#include "../utils.h"
#include "proto.h"
#define USBCTRL_DPSRAM_SIZE (1024*4) // See p122
#define USBCTRL_BUFFER_SIZE 64 // See p385
#define USB_ENDPOINT_COUNT 3 // Number of endpoints for the device driver
#define USB_INTERFACE_COUNT 2 // Number of interfaces for the device driver
#define BCD_USB 0x0110
#define USB_BUFFER_OFFSET(ADDR) (ADDR ^ USBCTRL_DPSRAM_BASE) // See here https://github.com/raspberrypi/pico-examples/blob/master/usb/device/dev_lowlevel/dev_lowlevel.c#L141
typedef struct EndPoint {
void *buffer0;
void *buffer1;
void *rbc; // EP control register
volatile u32 *rbc_in; // EP buffer control in register
volatile u32 *rbc_out; // EP buffer control out register
int next_pid;
int is_in;
} EndPoint;
typedef struct EndPointConfiguration{
USB_ENDPOINT_DESCRIPTOR endpoint_descriptor;
volatile u32* buffer0;
volatile u32* buffer1;
volatile u32* buffer_control;
volatile u32* endpoint_control;
u32 next_pid; // Next usb pkt pid (DATA0/DATA1)
void (*handler)(u8*,int);
} EndPointConfiguration;
typedef struct FunctionalDescriptors {
int size;
void* descriptors;
} FunctionalDescriptors;
typedef struct DeviceConfiguration {
u8 devaddr; // Current device address
u8 setdevaddr; // Set to one when devaddr is available
u8 configured; // Set to true when host triggered SET_CONFIGURATION
USB_DEVICE_DESCRIPTOR device_descriptor;
USB_CONFIGURATION_DESCRIPTOR configuration_descriptor;
USB_INTERFACE_DESCRIPTOR interface_descriptors[USB_INTERFACE_COUNT];
EndPointConfiguration endpoints[2+USB_ENDPOINT_COUNT]; // Endpoint 0 in and out always required so +2
USB_STRING_DESCRIPTOR_ZERO supported_languages;
FunctionalDescriptors functional_descriptors;
void *full_configuration_descriptor;
void (*setup_handler)(UD_SETUP *pkt); // Notify the driver in case of unhandled setup packet
void (*setup_ack_handler)(void); // Notify the driver
void (*eoi)(void); // Notify the driver for End Of Interrupt
char *descriptor_strings[]; // All string like vendor and product id
} DeviceConfiguration;
void cusb_init(DeviceConfiguration *dc);
void cusb_init_device_configuration();
void cusb_ep0_in_handler(u8 *buffer, int len);
void cusb_ep0_out_handler(u8 *buffer, int len);
void cusb_handle_setup(void);
void cusb_handle_bus_reset(void);
void cusb_handle_buffer_status(void);
int cusb_check_interrupt(int int_bit);
void usb_start_xfer(void* data, u32 size, int ep);
void cusb_start_xfer(void *data, u32 size, EndPointConfiguration *ep);
void cusb_status_xfer(u32 dir);
void cusb_eoi(); // Trigger at end of each USB interrupt
void cusb_isr_trigger(); // Manually trigger an usb interrupt
#endif

227
src/libs/usb/proto.h Normal file
View file

@ -0,0 +1,227 @@
#ifndef __PROTO_H__
#define __PROTO_H__
#include "../types.h"
// ---------- USB Protocol ----------
#define USB_DATA typedef struct __attribute__((__packed__))
// USB token PIDs
#define USB_PID_OUT 0b0001
#define USB_PID_IN 0b1001
#define USB_PID_SOF 0b0101
#define USB_PID_SETUP 0b1101
// USB data PIDs
#define USB_PID_DATA0 0b0011
#define USB_PID_DATA1 0b1011
#define USB_PID_DATA2 0b0111
#define USB_PID_MDATA 0b1111
// Standard Requests Code (bRequest)
#define USB_REQUEST_CODE_GET_STATUS 0
#define USB_REQUEST_CODE_CLEAR_FEATURE 1
#define USB_REQUEST_CODE_SET_FEATURE 3
#define USB_REQUEST_CODE_SET_ADDRESS 5
#define USB_REQUEST_CODE_GET_DESCRIPTOR 6
#define USB_REQUEST_CODE_SET_DESCRIPTOR 7
#define USB_REQUEST_CODE_GET_CONFIGURATION 8
#define USB_REQUEST_CODE_SET_CONFIGURATION 9
#define USB_REQUEST_CODE_GET_INTERFACE 10
#define USB_REQUEST_CODE_SET_INTERFACE 11
#define USB_REQUEST_CODE_SYNCH_FRAME 12
// Descriptor Types (wValue)
#define USB_DESCRIPTOR_TYPE_DEVICE 1
#define USB_DESCRIPTOR_TYPE_CONFIGURATION 2
#define USB_DESCRIPTOR_TYPE_STRING 3
#define USB_DESCRIPTOR_TYPE_INTERFACE 4
#define USB_DESCRIPTOR_TYPE_ENDPOINT 5
#define USB_DESCRIPTOR_TYPE_DEVICE_QUALIFIER 6
#define USB_DESCRIPTOR_TYPE_OTHER_SPEED_CONFIGURATION 7
#define USB_DESCRIPTOR_TYPE_INTERFACE_POWER 8
// Feature Selector (wvalue)
#define USB_FEATURE_SELECTOR_DEVICE_REMOTE_WAKEUP 1
#define USB_FEATURE_SELECTOR_ENDPOINT_HALT 0
#define USB_FEATURE_SELECTOR_TEST_MODE 2
// Device class code https://developerhelp.microchip.com/xwiki/bin/view/applications/usb/how-it-works/device-classes/
#define USB_DEVICE_CLASS_DEVICE 0x00
#define USB_DEVICE_CLASS_AUDIO 0x01
#define USB_DEVICE_CLASS_CDC 0x02
#define USB_DEVICE_CLASS_HID 0x03
#define USB_DEVICE_CLASS_PHYSICAL 0x05
#define USB_TRANSFERT_TYPE_CONTROL 0b00
#define USB_TRANSFERT_TYPE_ISOCHRONOUS 0b01
#define USB_TRANSFERT_TYPE_BULK 0b10
#define USB_TRANSFERT_TYPE_INTERRUPT 0b11
#define USB_DIRECTION_OUT 0x00
#define USB_DIRECTION_IN 0x80
// Supported languages http://www.baiheee.com/Documents/090518/090518112619/USB_LANGIDs.pdf
#define USB_LANG_ENGLISH_US 0x0409
#define USB_LANG_ENGLISH_UNITED_KINGDOM 0x0809
#define B_ENDPOINT_ADDRESS(NUM, DIR) ((NUM)&0xF | (DIR))
#define BM_REQUEST_TYPE_DIR_BIT (USB_DIRECTION_IN)
#define USB_INTERFACE_CLASS_COMMUNICATION 0x02 // Communication interface class
#define USB_INTERFACE_CLASS_DATA 0x0a // Data interface class
#define USB_INTERFACE_SUBCLASS_ACM 0x02 // Abstract Control Mode
#define USB_INTERFACE_COMMUNICATION_PROTOCOL_NOPROTO 0x00 // No protocol
USB_DATA { // P250
u8 bmRequestType;
u8 bRequest;
u16 wValue;
u16 wIndex;
u16 wLength;
} UD_SETUP;
// ----- Descriptors -----
USB_DATA { // P262
u8 bLength;
u8 bDescriptorType;
u16 bcdUSB;
u8 bDeviceClass;
u8 bDeviceSubClass;
u8 bDeviceProtocol;
u8 bMaxPacketSize0;
u16 idVendor;
u16 idProduct;
u16 bcdDevice;
u8 iManufacturer;
u8 iProduct;
u8 iSerialNumber;
u8 bNumConfigurations;
} USB_DEVICE_DESCRIPTOR;
USB_DATA { // P264 (may not be used in this code)
u8 bLength;
u8 bDescriptorType;
u16 bcdUSB;
u8 bDeviceClass;
u8 bDeviceSubClass;
u8 bDeviceProtocol;
u8 bMaxPacketSize0;
u8 bNumConfigurations;
u8 bReserved;
} USB_DEVICE_QUALIFIER_DESCRIPTOR;
USB_DATA { // P265
u8 bLength;
u8 bDescriptorType;
u16 wTotalLength;
u8 bNumInterfaces;
u8 bConfigurationValue;
u8 iConfiguration;
u8 bmAttributes;
u8 bMaxPower;
} USB_CONFIGURATION_DESCRIPTOR;
USB_DATA {
u8 bLength;
u8 bDescriptorType;
u16 wTotalLength;
u8 bNumInterfaces;
u8 bConfigurationValue;
u8 iConfiguration;
u8 bmAttributes;
u8 bMaxPower;
} USB_OTHER_SPEED_CONFIGURATION_DESCRIPTOR;
USB_DATA {
u8 bLength;
u8 bDescriptorType;
u8 bInterfaceNumber;
u8 bAlternateSetting;
u8 bNumEndpoints;
u8 bInterfaceClass;
u8 bInterfaceSubClass;
u8 bInterfaceProtocol;
u8 iInterface;
} USB_INTERFACE_DESCRIPTOR;
USB_DATA {
u8 bLength;
u8 bDescriptorType;
u8 bEndpointAddress;
u8 bmAttributes;
u16 wMaxPacketSize;
u8 bInterval;
} USB_ENDPOINT_DESCRIPTOR;
USB_DATA {
u8 bLength;
u8 bDescriptorType;
u16 wLANGID0;
// Can be more wLANGIDX but stop here!
} USB_STRING_DESCRIPTOR_ZERO;
USB_DATA {
u8 bLength;
u8 bDescriptorType;
// You add your unicode string there
} USB_UNICODE_STRING_DESCRIPTOR;
// ----- CDC Device Class -----
// p10 PSTN120.pdf in CDC Specification
// p10-.. CDC120-20101103-track.pdf
// p10-.. usbcdc11.pdf
#define USB_INTERFACE_CLASS_COMMUNICATION 0x02 // Communication interface class
#define USB_INTERFACE_CLASS_DATA 0x0a // Data interface class
#define USB_INTERFACE_SUBCLASS_ACM 0x02 // Abstract Control Mode
#define USB_INTERFACE_COMMUNICATION_PROTOCOL_NOPROTO 0x00 // No protocol
#define USB_RS232_BMCAPABILITIES 0b10
#define USB_REQUEST_CODE_SET_LINE_CODING 0x20
#define USB_REQUEST_CODE_SET_CONTROL_LINE_STATE 0x22
#define USB_REQUEST_CODE_SEND_BREAK 0x23
// p34
USB_DATA {
u8 bFunctionLength;
u8 bDescriptorType;
u8 bDescriptorSubtype;
u16 bcdCDC;
} USB_CDC_HEADER_FUNCTIONAL_DESCRIPTOR;
// p35
USB_DATA {
u8 bFunctionLength;
u8 bDescriptorType;
u8 bDescriptorSubtype;
u8 bmCapabilities;
} USB_ACM_FUNCTIONAL_DESCRIPTOR;
// p40
USB_DATA {
u8 bFunctionLength;
u8 bDescriptorType;
u8 bDescriptorSubtype;
u8 bMasterInterface;
u8 bSlaveInterface0;
// Can be more! I guess for RS-232 it is enough
} USB_UNION_INTERFACE_DESCRIPTOR;
// SEE p49!!!! it is all there it seems
// the last descriptor on that page is the "Call management functional
// descriptor" (p34). It seems not required according to chatgpt for rs-232
USB_DATA {
USB_CDC_HEADER_FUNCTIONAL_DESCRIPTOR header_descriptor;
USB_ACM_FUNCTIONAL_DESCRIPTOR acm_descriptor;
USB_UNION_INTERFACE_DESCRIPTOR union_descriptor;
} USB_CDC_ACM_FUNCTIONAL_DESCRIPTOR;
#endif

53
src/libs/utils.c Normal file
View file

@ -0,0 +1,53 @@
#include "utils.h"
void memcpy(u8 *dst, u8 *src, u32 size){
for(u32 i=0;i<size;i++){
((u8*)(dst))[i]=((u8*)(src))[i];
}
}
void memset(u8 *start, u8 value, u32 size){
for(u32 i=0;i<size;i++){
((u8*)(start))[i]=value;
}
}
int modulo(int dividend, int divisor){
while((dividend-divisor)>0){dividend-=divisor;}
return dividend;
}
int strlen(char * cp)
{
int len=0;
while( cp[len++]) ;
return len - 1 ; //because it counted the zero which we don't want.
}
int wordlen(char *s)
{
int len=0;
while( *s!='\n' && *s!='\0' && *s!=' '){ s++; }
return len - 1 ; //because it counted the zero which we don't want.
}
u8 strcmp(char *str1, char*str2){
while( *str1!='\0' && *str2!='\0'){
if(*str1!=*str2)
return 1;
str1++;
str2++;
}
return *str1 == *str2; // Ensure both final char are \0
}
u8 strncmp(char *str1, char *str2, int n){
for(int i=0;i<n;i++){
if(str1[i] == '\0' || str2[i] == '\0')
break;
if(str1[i] != str2[i])
return 1;
}
return *str1 != *str2;
}

30
src/libs/utils.h Normal file
View file

@ -0,0 +1,30 @@
#ifndef __UTILS__
#define __UTILS__
#include "types.h"
// General operations
#define STR32(ADDR,VALUE) *((volatile unsigned int*) (ADDR))=(VALUE)
#define LDR32(ADDR) (*((volatile unsigned int*) (ADDR)))
// Registers operations
#define REG_WRITE(ADDR,VALUE) STR32(ADDR,VALUE)
#define REG_WRITE_XOR(ADDR,VALUE) STR32(ADDR+0x1000,VALUE)
#define REG_WRITE_BITMAP_SET(ADDR,VALUE) STR32(ADDR+0x2000,VALUE)
#define REG_WRITE_BITMAP_CLEAR(ADDR,VALUE) STR32(ADDR+0x3000,VALUE)
#define REG_READ(ADDR) LDR32(ADDR)
// Memory operations
void memcpy(u8 *dst, u8 *src, u32 size); // TODO: Improve perf with 32bits memory transactions
void memset(u8 *start, u8 value, u32 size); // TODO: Improve perf with 32bits memory transactions
// Computations
int modulo(int dividend, int divisor); // Assumes that both argument are positve (TODO improve this)
// Strings (not these functions do not follow libc standards and are buggy)
int strlen(char * cp);
int wordlen(char *s);
u8 strcmp(char *str1, char*str2);
u8 strncmp(char *str1, char*str2, int n);
#endif

60
src/main.c Normal file
View file

@ -0,0 +1,60 @@
#include "libs/tty.h"
#include "libs/utils.h"
#include "libs/gpio.h"
#include "libs/interrupts.h"
#include "libs/clock.h"
#define MOTD "WELCOME TO RP2040 TTY\n\n\r"
#define PROMPT "rp2040> "
#define HELP "\tblink\t\tmake led blink for almost 1s\n\r"
char cmd[64];
char *cmdptr=cmd;
// Execute command from cmd buffer
void exec(){
if(!strncmp(cmd, "blink", strlen("exit")))
gpio_blink_led(1);
else if(!strncmp(cmd, "help", strlen("help")))
tty_putstr(HELP);
else if(cmdptr != cmd)
tty_putstr("Unknown command (see help)\n\r");
}
void main(){
// Finishing boot
interrupts_init();
xosc_init();
gpio_init();
tty_init();
// REPL
char c=tty_getchar();
tty_putstr(MOTD);
tty_putstr(PROMPT);
while(1){
c=tty_getchar();
if(c=='\r'){
tty_putstr("\n\r");
exec();
tty_putstr(PROMPT);
cmdptr=cmd;
}
else if (c ==0x8){
if(cmdptr-cmd){
tty_putstr("\b \b"); // Erase last character
cmdptr--;
}
}
else{
*cmdptr=c;
cmdptr++;
tty_putchar(c);
}
}
return;
}

1
tools/elf2uf2/.gitignore vendored Normal file
View file

@ -0,0 +1 @@
elf2uf2

21
tools/elf2uf2/LICENSE.TXT Normal file
View file

@ -0,0 +1,21 @@
Copyright 220 (c) 2020 Raspberry Pi (Trading) Ltd.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.0

3
tools/elf2uf2/README.md Normal file
View file

@ -0,0 +1,3 @@
# Raspberry Pi Pico elf2uf2 Utility
THIS CODE COMES FROM THE FOLLOWING REPOSITORY: https://github.com/rej696/elf2uf2

60
tools/elf2uf2/elf.h Normal file
View file

@ -0,0 +1,60 @@
/*
* Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _ELF_H
#define _ELF_H
#include <stdint.h>
#define ELF_MAGIC 0x464c457fu
#define EM_ARM 0x28u
#define EF_ARM_ABI_FLOAT_HARD 0x00000400u
#define PT_LOAD 0x00000001u
#pragma pack(push, 1)
struct elf_header {
uint32_t magic;
uint8_t arch_class;
uint8_t endianness;
uint8_t version;
uint8_t abi;
uint8_t abi_version;
uint8_t _pad[7];
uint16_t type;
uint16_t machine;
uint32_t version2;
};
struct elf32_header {
struct elf_header common;
uint32_t entry;
uint32_t ph_offset;
uint32_t sh_offset;
uint32_t flags;
uint16_t eh_size;
uint16_t ph_entry_size;
uint16_t ph_num;
uint16_t sh_entry_size;
uint16_t sh_num;
uint16_t sh_str_index;
};
struct elf32_ph_entry {
uint32_t type;
uint32_t offset;
uint32_t vaddr;
uint32_t paddr;
uint32_t filez;
uint32_t memsz;
uint32_t flags;
uint32_t align;
};
#pragma pack(pop)
#endif

353
tools/elf2uf2/main.cpp Normal file
View file

@ -0,0 +1,353 @@
/*
* Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include <cstdio>
#include <map>
#include <vector>
#include <cstring>
#include <cstdarg>
#include <algorithm>
#include "uf2.h"
#include "elf.h"
typedef unsigned int uint;
#define ERROR_ARGS -1
#define ERROR_FORMAT -2
#define ERROR_INCOMPATIBLE -3
#define ERROR_READ_FAILED -4
#define ERROR_WRITE_FAILED -5
static char error_msg[512];
static bool verbose;
static int fail(int code, const char *format, ...) {
va_list args;
va_start(args, format);
vsnprintf(error_msg, sizeof(error_msg), format, args);
va_end(args);
return code;
}
static int fail_read_error() {
return fail(ERROR_READ_FAILED, "Failed to read input file");
}
static int fail_write_error() {
return fail(ERROR_WRITE_FAILED, "Failed to write output file");
}
// we require 256 (as this is the page size supported by the device)
#define LOG2_PAGE_SIZE 8u
#define PAGE_SIZE (1u << LOG2_PAGE_SIZE)
struct address_range {
enum type {
CONTENTS, // may have contents
NO_CONTENTS, // must be uninitialized
IGNORE // will be ignored
};
address_range(uint32_t from, uint32_t to, type type) : from(from), to(to), type(type) {}
address_range() : address_range(0, 0, IGNORE) {}
type type;
uint32_t to;
uint32_t from;
};
typedef std::vector<address_range> address_ranges;
#define MAIN_RAM_START 0x20000000u
#define MAIN_RAM_END 0x20042000u
#define FLASH_START 0x10000000u
#define FLASH_END 0x15000000u
#define XIP_SRAM_START 0x15000000u
#define XIP_SRAM_END 0x15004000u
#define MAIN_RAM_BANKED_START 0x21000000u
#define MAIN_RAM_BANKED_END 0x21040000u
const address_ranges rp2040_address_ranges_flash {
address_range(FLASH_START, FLASH_END, address_range::type::CONTENTS),
address_range(MAIN_RAM_START, MAIN_RAM_END, address_range::type::NO_CONTENTS),
address_range(MAIN_RAM_BANKED_START, MAIN_RAM_BANKED_END, address_range::type::NO_CONTENTS)
};
const address_ranges rp2040_address_ranges_ram {
address_range(MAIN_RAM_START, MAIN_RAM_END, address_range::type::CONTENTS),
address_range(XIP_SRAM_START, XIP_SRAM_END, address_range::type::CONTENTS),
address_range(0x00000000u, 0x00004000u, address_range::type::IGNORE) // for now we ignore the bootrom if present
};
struct page_fragment {
page_fragment(uint32_t file_offset, uint32_t page_offset, uint32_t bytes) : file_offset(file_offset), page_offset(page_offset), bytes(bytes) {}
uint32_t file_offset;
uint32_t page_offset;
uint32_t bytes;
};
static int usage() {
fprintf(stderr, "Usage: elf2uf2 (-v) <input ELF file> <output UF2 file>\n");
return ERROR_ARGS;
}
static int read_and_check_elf32_header(FILE *in, elf32_header& eh_out) {
if (1 != fread(&eh_out, sizeof(eh_out), 1, in)) {
return fail(ERROR_READ_FAILED, "Unable to read ELF header");
}
if (eh_out.common.magic != ELF_MAGIC) {
return fail(ERROR_FORMAT, "Not an ELF file");
}
if (eh_out.common.version != 1 || eh_out.common.version2 != 1) {
return fail(ERROR_FORMAT, "Unrecognized ELF version");
}
if (eh_out.common.arch_class != 1 || eh_out.common.endianness != 1) {
return fail(ERROR_INCOMPATIBLE, "Require 32 bit little-endian ELF");
}
if (eh_out.eh_size != sizeof(struct elf32_header)) {
return fail(ERROR_FORMAT, "Invalid ELF32 format");
}
if (eh_out.common.machine != EM_ARM) {
return fail(ERROR_FORMAT, "Not an ARM executable");
}
if (eh_out.common.abi != 0) {
return fail(ERROR_INCOMPATIBLE, "Unrecognized ABI");
}
if (eh_out.flags & EF_ARM_ABI_FLOAT_HARD) {
return fail(ERROR_INCOMPATIBLE, "HARD-FLOAT not supported");
}
return 0;
}
int check_address_range(const address_ranges& valid_ranges, uint32_t addr, uint32_t vaddr, uint32_t size, bool uninitialized, address_range &ar) {
for(const auto& range : valid_ranges) {
if (range.from <= addr && range.to >= addr + size) {
if (range.type == address_range::type::NO_CONTENTS && !uninitialized) {
return fail(ERROR_INCOMPATIBLE, "ELF contains memory contents for uninitialized memory");
}
ar = range;
if (verbose) {
printf("%s segment %08x->%08x (%08x->%08x)\n", uninitialized ? "Uninitialized" : "Mapped", addr,
addr + size, vaddr, vaddr+size);
}
return 0;
}
}
return fail(ERROR_INCOMPATIBLE, "Memory segment %08x->%08x is outside of valid address range for device", addr, addr+size);
}
int read_and_check_elf32_ph_entries(FILE *in, const elf32_header &eh, const address_ranges& valid_ranges, std::map<uint32_t, std::vector<page_fragment>>& pages) {
if (eh.ph_entry_size != sizeof(elf32_ph_entry)) {
return fail(ERROR_FORMAT, "Invalid ELF32 program header");
}
if (eh.ph_num) {
std::vector<elf32_ph_entry> entries(eh.ph_num);
if (fseek(in, eh.ph_offset, SEEK_SET)) {
return fail_read_error();
}
if (eh.ph_num != fread(&entries[0], sizeof(struct elf32_ph_entry), eh.ph_num, in)) {
return fail_read_error();
}
for(uint i=0;i<eh.ph_num;i++) {
elf32_ph_entry& entry = entries[i];
if (entry.type == PT_LOAD && entry.memsz) {
address_range ar;
int rc;
uint mapped_size = std::min(entry.filez, entry.memsz);
if (mapped_size) {
rc = check_address_range(valid_ranges, entry.paddr, entry.vaddr, mapped_size, false, ar);
if (rc) return rc;
// we don't download uninitialized, generally it is BSS and should be zero-ed by crt0.S, or it may be COPY areas which are undefined
if (ar.type != address_range::type::CONTENTS) {
if (verbose) printf(" ignored\n");
continue;
}
uint addr = entry.paddr;
uint remaining = mapped_size;
uint file_offset = entry.offset;
while (remaining) {
uint off = addr & (PAGE_SIZE - 1);
uint len = std::min(remaining, PAGE_SIZE - off);
auto &fragments = pages[addr - off]; // list of fragments
// note if filesz is zero, we want zero init which is handled because the
// statement above creates an empty page fragment list
// check overlap with any existing fragments
for (const auto &fragment : fragments) {
if ((off < fragment.page_offset + fragment.bytes) !=
((off + len) <= fragment.page_offset)) {
fail(ERROR_FORMAT, "In memory segments overlap");
}
}
fragments.push_back(
page_fragment{file_offset,off,len});
addr += len;
file_offset += len;
remaining -= len;
}
}
if (entry.memsz > entry.filez) {
// we have some uninitialized data too
rc = check_address_range(valid_ranges, entry.paddr + entry.filez, entry.vaddr + entry.filez, entry.memsz - entry.filez, true,
ar);
if (rc) return rc;
}
}
}
}
return 0;
}
int realize_page(FILE *in, const std::vector<page_fragment> &fragments, uint8_t *buf, uint buf_len) {
assert(buf_len >= PAGE_SIZE);
for(auto& frag : fragments) {
assert(frag.page_offset >= 0 && frag.page_offset < PAGE_SIZE && frag.page_offset + frag.bytes <= PAGE_SIZE);
if (fseek(in, frag.file_offset, SEEK_SET)) {
return fail_read_error();
}
if (1 != fread(buf + frag.page_offset, frag.bytes, 1, in)) {
return fail_read_error();
}
}
return 0;
}
static bool is_address_valid(const address_ranges& valid_ranges, uint32_t addr) {
for(const auto& range : valid_ranges) {
if (range.from <= addr && range.to > addr) {
return true;
}
}
return false;
}
static bool is_address_initialized(const address_ranges& valid_ranges, uint32_t addr) {
for(const auto& range : valid_ranges) {
if (range.from <= addr && range.to > addr) {
return address_range::type::CONTENTS == range.type;
}
}
return false;
}
static bool is_address_mapped(const std::map<uint32_t, std::vector<page_fragment>>& pages, uint32_t addr) {
uint32_t page = addr & ~(PAGE_SIZE - 1);
if (!pages.count(page)) return false;
// todo check actual address within page
return true;
}
int elf2uf2(FILE *in, FILE *out) {
elf32_header eh;
std::map<uint32_t, std::vector<page_fragment>> pages;
int rc = read_and_check_elf32_header(in, eh);
bool ram_style = false;
address_ranges valid_ranges = {};
if (!rc) {
ram_style = is_address_initialized(rp2040_address_ranges_ram, eh.entry);
if (verbose) {
if (ram_style) {
printf("Detected RAM binary\n");
} else {
printf("Detected FLASH binary\n");
}
}
valid_ranges = ram_style ? rp2040_address_ranges_ram : rp2040_address_ranges_flash;
rc = read_and_check_elf32_ph_entries(in, eh, valid_ranges, pages);
}
if (rc) return rc;
if (pages.empty()) {
return fail(ERROR_INCOMPATIBLE, "The input file has no memory pages");
}
uint page_num = 0;
if (ram_style) {
uint32_t expected_ep_main_ram = UINT32_MAX;
uint32_t expected_ep_xip_sram = UINT32_MAX;
for(auto& page_entry : pages) {
if ( ((page_entry.first >= MAIN_RAM_START) && (page_entry.first < MAIN_RAM_END)) && (page_entry.first < expected_ep_main_ram) ) {
expected_ep_main_ram = page_entry.first | 0x1;
} else if ( ((page_entry.first >= XIP_SRAM_START) && (page_entry.first < XIP_SRAM_END)) && (page_entry.first < expected_ep_xip_sram) ) {
expected_ep_xip_sram = page_entry.first | 0x1;
}
}
uint32_t expected_ep = (UINT32_MAX != expected_ep_main_ram) ? expected_ep_main_ram : expected_ep_xip_sram;
if (eh.entry == expected_ep_xip_sram) {
return fail(ERROR_INCOMPATIBLE, "B0/B1 Boot ROM does not support direct entry into XIP_SRAM\n");
} else if (eh.entry != expected_ep) {
return fail(ERROR_INCOMPATIBLE, "A RAM binary should have an entry point at the beginning: %08x (not %08x)\n", expected_ep, eh.entry);
}
static_assert(0 == (MAIN_RAM_START & (PAGE_SIZE - 1)), "");
// currently don't require this as entry point is now at the start, we don't know where reset vector is
#if 0
uint8_t buf[PAGE_SIZE];
rc = realize_page(in, pages[MAIN_RAM_START], buf, sizeof(buf));
if (rc) return rc;
uint32_t sp = ((uint32_t *)buf)[0];
uint32_t ip = ((uint32_t *)buf)[1];
if (!is_address_mapped(pages, ip)) {
return fail(ERROR_INCOMPATIBLE, "Vector table at %08x is invalid: reset vector %08x is not in mapped memory",
MAIN_RAM_START, ip);
}
if (!is_address_valid(valid_ranges, sp - 4)) {
return fail(ERROR_INCOMPATIBLE, "Vector table at %08x is invalid: stack pointer %08x is not in RAM",
MAIN_RAM_START, sp);
}
#endif
}
uf2_block block;
block.magic_start0 = UF2_MAGIC_START0;
block.magic_start1 = UF2_MAGIC_START1;
block.flags = UF2_FLAG_FAMILY_ID_PRESENT;
block.payload_size = PAGE_SIZE;
block.num_blocks = (uint32_t)pages.size();
block.file_size = RP2040_FAMILY_ID;
block.magic_end = UF2_MAGIC_END;
for(auto& page_entry : pages) {
block.target_addr = page_entry.first;
block.block_no = page_num++;
if (verbose) {
printf("Page %d / %d %08x\n", block.block_no, block.num_blocks, block.target_addr);
}
memset(block.data, 0, sizeof(block.data));
rc = realize_page(in, page_entry.second, block.data, sizeof(block.data));
if (rc) return rc;
if (1 != fwrite(&block, sizeof(uf2_block), 1, out)) {
return fail_write_error();
}
}
return 0;
}
int main(int argc, char **argv) {
int arg = 1;
if (arg < argc && !strcmp(argv[arg], "-v")) {
verbose = true;
arg++;
}
if (argc < arg + 2) {
return usage();
}
const char *in_filename = argv[arg++];
FILE *in = fopen(in_filename, "rb");
if (!in) {
fprintf(stderr, "Can't open input file '%s'\n", in_filename);
return ERROR_ARGS;
}
const char *out_filename = argv[arg++];
FILE *out = fopen(out_filename, "wb");
if (!out) {
fprintf(stderr, "Can't open output file '%s'\n", out_filename);
return ERROR_ARGS;
}
int rc = elf2uf2(in, out);
fclose(in);
fclose(out);
if (rc) {
remove(out_filename);
if (error_msg[0]) {
fprintf(stderr, "ERROR: %s\n", error_msg);
}
}
return rc;
}

4
tools/elf2uf2/makefile Normal file
View file

@ -0,0 +1,4 @@
all: build
build: main.cpp
g++ -o elf2uf2 main.cpp

46
tools/elf2uf2/uf2.h Normal file
View file

@ -0,0 +1,46 @@
/*
* Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _BOOT_UF2_H
#define _BOOT_UF2_H
#include <stdint.h>
#include <assert.h>
/** \file uf2.h
* \defgroup boot_uf2 boot_uf2
*
* Header file for the UF2 format supported by an RP2040 in BOOTSEL mode.
*/
#define UF2_MAGIC_START0 0x0A324655u
#define UF2_MAGIC_START1 0x9E5D5157u
#define UF2_MAGIC_END 0x0AB16F30u
#define UF2_FLAG_NOT_MAIN_FLASH 0x00000001u
#define UF2_FLAG_FILE_CONTAINER 0x00001000u
#define UF2_FLAG_FAMILY_ID_PRESENT 0x00002000u
#define UF2_FLAG_MD5_PRESENT 0x00004000u
#define RP2040_FAMILY_ID 0xe48bff56
struct uf2_block {
// 32 byte header
uint32_t magic_start0;
uint32_t magic_start1;
uint32_t flags;
uint32_t target_addr;
uint32_t payload_size;
uint32_t block_no;
uint32_t num_blocks;
uint32_t file_size; // or familyID;
uint8_t data[476];
uint32_t magic_end;
};
static_assert(sizeof(struct uf2_block) == 512, "uf2_block not sector sized");
#endif

55
tools/pad_checksum.py Executable file
View file

@ -0,0 +1,55 @@
#!/usr/bin/env python3
import argparse
import binascii
import struct
import sys
def any_int(x):
try:
return int(x, 0)
except:
raise argparse.ArgumentTypeError("expected an integer, not '{!r}'".format(x))
def bitrev(x, width):
return int("{:0{w}b}".format(x, w=width)[::-1], 2)
parser = argparse.ArgumentParser()
parser.add_argument("ifile", help="Input file (binary)")
parser.add_argument("ofile", help="Output file (assembly)")
parser.add_argument("-p", "--pad", help="Padded size (bytes), including 4-byte checksum, default 256",
type=any_int, default=256)
parser.add_argument("-s", "--seed", help="Checksum seed value, default 0",
type=any_int, default=0)
args = parser.parse_args()
try:
idata = open(args.ifile, "rb").read()
except:
sys.exit("Could not open input file '{}'".format(args.ifile))
if len(idata) > args.pad - 4:
sys.exit("Input file size ({} bytes) too large for final size ({} bytes)".format(len(idata), args.pad))
idata_padded = idata + bytes(args.pad - 4 - len(idata))
# Our bootrom CRC32 is slightly bass-ackward but it's best to work around for now (FIXME)
# 100% worth it to save two Thumb instructions
checksum = bitrev(
(binascii.crc32(bytes(bitrev(b, 8) for b in idata_padded), args.seed ^ 0xffffffff) ^ 0xffffffff) & 0xffffffff, 32)
odata = idata_padded + struct.pack("<L", checksum)
try:
with open(args.ofile, "w") as ofile:
ofile.write("// Padded and checksummed version of: {}\n\n".format(args.ifile))
ofile.write(".cpu cortex-m0plus\n")
ofile.write(".thumb\n\n")
ofile.write(".section .boot2, \"ax\"\n\n")
for offs in range(0, len(odata), 16):
chunk = odata[offs:min(offs + 16, len(odata))]
ofile.write(".byte {}\n".format(", ".join("0x{:02x}".format(b) for b in chunk)))
except:
sys.exit("Could not open output file '{}'".format(args.ofile))