penguin
/
Aquatic-Robotic-Courier
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
unstable
stable
Release_v1
temp
Release_v1.1
Release_v1
Release_v0
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8d397d6c54'
${ noResults }
Aquatic-Robotic-Courier/software/Rev-0-fw/arc-fw/arc-fw/Debug/arc-fw.lss

7845 lines
307 KiB
Plaintext
Raw Blame History

arc-fw.elf: file format elf32-littlearm
Sections:
Idx Name Size VMA LMA File off Algn
0 .text 00002ce4 00000000 00000000 00010000 2**2
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 .relocate 00000068 20000000 00002ce4 00020000 2**2
CONTENTS, ALLOC, LOAD, DATA
2 .bss 00000354 20000068 00002d4c 00020068 2**2
ALLOC
3 .stack 00002004 200003bc 000030a0 00020068 2**0
ALLOC
4 .ARM.attributes 00000028 00000000 00000000 00020068 2**0
CONTENTS, READONLY
5 .comment 00000059 00000000 00000000 00020090 2**0
CONTENTS, READONLY
6 .debug_info 0002c313 00000000 00000000 000200e9 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_abbrev 000033c2 00000000 00000000 0004c3fc 2**0
CONTENTS, READONLY, DEBUGGING
8 .debug_loc 00011862 00000000 00000000 0004f7be 2**0
CONTENTS, READONLY, DEBUGGING
9 .debug_aranges 00000b68 00000000 00000000 00061020 2**0
CONTENTS, READONLY, DEBUGGING
10 .debug_ranges 000014c0 00000000 00000000 00061b88 2**0
CONTENTS, READONLY, DEBUGGING
11 .debug_macro 00018ae3 00000000 00000000 00063048 2**0
CONTENTS, READONLY, DEBUGGING
12 .debug_line 0000f5c7 00000000 00000000 0007bb2b 2**0
CONTENTS, READONLY, DEBUGGING
13 .debug_str 00085a24 00000000 00000000 0008b0f2 2**0
CONTENTS, READONLY, DEBUGGING
14 .debug_frame 00001eb8 00000000 00000000 00110b18 2**2
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <exception_table>:
0: c0 23 00 20 2d 01 00 00 29 01 00 00 29 01 00 00 .#. -...)...)...
...
2c: 29 01 00 00 00 00 00 00 00 00 00 00 29 01 00 00 )...........)...
3c: 29 01 00 00 29 01 00 00 29 01 00 00 29 01 00 00 )...)...)...)...
4c: 29 01 00 00 29 01 00 00 29 01 00 00 29 01 00 00 )...)...)...)...
5c: fd 1d 00 00 29 01 00 00 29 01 00 00 29 01 00 00 ....)...)...)...
6c: 29 01 00 00 29 01 00 00 00 00 00 00 00 00 00 00 )...)...........
7c: 29 01 00 00 29 01 00 00 29 01 00 00 29 01 00 00 )...)...)...)...
8c: 29 01 00 00 29 01 00 00 00 00 00 00 00 00 00 00 )...)...........
9c: 29 01 00 00 29 01 00 00 29 01 00 00 29 01 00 00 )...)...)...)...
ac: 29 01 00 00 00 00 00 00 ).......
000000b4 <__do_global_dtors_aux>:
b4: b510 push {r4, lr}
b6: 4c06 ldr r4, [pc, #24] ; (d0 <__do_global_dtors_aux+0x1c>)
b8: 7823 ldrb r3, [r4, #0]
ba: 2b00 cmp r3, #0
bc: d107 bne.n ce <__do_global_dtors_aux+0x1a>
be: 4b05 ldr r3, [pc, #20] ; (d4 <__do_global_dtors_aux+0x20>)
c0: 2b00 cmp r3, #0
c2: d002 beq.n ca <__do_global_dtors_aux+0x16>
c4: 4804 ldr r0, [pc, #16] ; (d8 <__do_global_dtors_aux+0x24>)
c6: e000 b.n ca <__do_global_dtors_aux+0x16>
c8: bf00 nop
ca: 2301 movs r3, #1
cc: 7023 strb r3, [r4, #0]
ce: bd10 pop {r4, pc}
d0: 20000068 .word 0x20000068
d4: 00000000 .word 0x00000000
d8: 00002ce4 .word 0x00002ce4
000000dc <frame_dummy>:
dc: 4b08 ldr r3, [pc, #32] ; (100 <frame_dummy+0x24>)
de: b510 push {r4, lr}
e0: 2b00 cmp r3, #0
e2: d003 beq.n ec <frame_dummy+0x10>
e4: 4907 ldr r1, [pc, #28] ; (104 <frame_dummy+0x28>)
e6: 4808 ldr r0, [pc, #32] ; (108 <frame_dummy+0x2c>)
e8: e000 b.n ec <frame_dummy+0x10>
ea: bf00 nop
ec: 4807 ldr r0, [pc, #28] ; (10c <frame_dummy+0x30>)
ee: 6803 ldr r3, [r0, #0]
f0: 2b00 cmp r3, #0
f2: d100 bne.n f6 <frame_dummy+0x1a>
f4: bd10 pop {r4, pc}
f6: 4b06 ldr r3, [pc, #24] ; (110 <frame_dummy+0x34>)
f8: 2b00 cmp r3, #0
fa: d0fb beq.n f4 <frame_dummy+0x18>
fc: 4798 blx r3
fe: e7f9 b.n f4 <frame_dummy+0x18>
100: 00000000 .word 0x00000000
104: 2000006c .word 0x2000006c
108: 00002ce4 .word 0x00002ce4
10c: 00002ce4 .word 0x00002ce4
110: 00000000 .word 0x00000000
00000114 <atmel_start_init>:
/**
* Initializes MCU, drivers and middleware in the project
**/
void atmel_start_init(void)
{
114: b510 push {r4, lr}
system_init();
116: 4b02 ldr r3, [pc, #8] ; (120 <atmel_start_init+0xc>)
118: 4798 blx r3
usb_init();
11a: 4b02 ldr r3, [pc, #8] ; (124 <atmel_start_init+0x10>)
11c: 4798 blx r3
}
11e: bd10 pop {r4, pc}
120: 00000369 .word 0x00000369
124: 00002b85 .word 0x00002b85
00000128 <Dummy_Handler>:
/**
* \brief Default interrupt handler for unused IRQs.
*/
void Dummy_Handler(void)
{
128: e7fe b.n 128 <Dummy_Handler>
...
0000012c <Reset_Handler>:
{
12c: b5f8 push {r3, r4, r5, r6, r7, lr}
if (pSrc != pDest) {
12e: 4a2a ldr r2, [pc, #168] ; (1d8 <Reset_Handler+0xac>)
130: 4b2a ldr r3, [pc, #168] ; (1dc <Reset_Handler+0xb0>)
132: 429a cmp r2, r3
134: d011 beq.n 15a <Reset_Handler+0x2e>
for (; pDest < &_erelocate;) {
136: 001a movs r2, r3
138: 4b29 ldr r3, [pc, #164] ; (1e0 <Reset_Handler+0xb4>)
13a: 429a cmp r2, r3
13c: d20d bcs.n 15a <Reset_Handler+0x2e>
13e: 4a29 ldr r2, [pc, #164] ; (1e4 <Reset_Handler+0xb8>)
140: 3303 adds r3, #3
142: 1a9b subs r3, r3, r2
144: 089b lsrs r3, r3, #2
146: 3301 adds r3, #1
148: 009b lsls r3, r3, #2
14a: 2200 movs r2, #0
*pDest++ = *pSrc++;
14c: 4823 ldr r0, [pc, #140] ; (1dc <Reset_Handler+0xb0>)
14e: 4922 ldr r1, [pc, #136] ; (1d8 <Reset_Handler+0xac>)
150: 588c ldr r4, [r1, r2]
152: 5084 str r4, [r0, r2]
154: 3204 adds r2, #4
for (; pDest < &_erelocate;) {
156: 429a cmp r2, r3
158: d1fa bne.n 150 <Reset_Handler+0x24>
for (pDest = &_szero; pDest < &_ezero;) {
15a: 4a23 ldr r2, [pc, #140] ; (1e8 <Reset_Handler+0xbc>)
15c: 4b23 ldr r3, [pc, #140] ; (1ec <Reset_Handler+0xc0>)
15e: 429a cmp r2, r3
160: d20a bcs.n 178 <Reset_Handler+0x4c>
162: 43d3 mvns r3, r2
164: 4921 ldr r1, [pc, #132] ; (1ec <Reset_Handler+0xc0>)
166: 185b adds r3, r3, r1
168: 2103 movs r1, #3
16a: 438b bics r3, r1
16c: 3304 adds r3, #4
16e: 189b adds r3, r3, r2
*pDest++ = 0;
170: 2100 movs r1, #0
172: c202 stmia r2!, {r1}
for (pDest = &_szero; pDest < &_ezero;) {
174: 4293 cmp r3, r2
176: d1fc bne.n 172 <Reset_Handler+0x46>
SCB->VTOR = ((uint32_t) pSrc & SCB_VTOR_TBLOFF_Msk);
178: 4a1d ldr r2, [pc, #116] ; (1f0 <Reset_Handler+0xc4>)
17a: 21ff movs r1, #255 ; 0xff
17c: 4b1d ldr r3, [pc, #116] ; (1f4 <Reset_Handler+0xc8>)
17e: 438b bics r3, r1
180: 6093 str r3, [r2, #8]
SBMATRIX->SFR[SBMATRIX_SLAVE_HMCRAMC0].reg = 2;
182: 39fd subs r1, #253 ; 0xfd
184: 2390 movs r3, #144 ; 0x90
186: 005b lsls r3, r3, #1
188: 4a1b ldr r2, [pc, #108] ; (1f8 <Reset_Handler+0xcc>)
18a: 50d1 str r1, [r2, r3]
USB->DEVICE.QOSCTRL.bit.CQOS = 2;
18c: 4a1b ldr r2, [pc, #108] ; (1fc <Reset_Handler+0xd0>)
18e: 78d3 ldrb r3, [r2, #3]
190: 2503 movs r5, #3
192: 43ab bics r3, r5
194: 2402 movs r4, #2
196: 4323 orrs r3, r4
198: 70d3 strb r3, [r2, #3]
USB->DEVICE.QOSCTRL.bit.DQOS = 2;
19a: 78d3 ldrb r3, [r2, #3]
19c: 270c movs r7, #12
19e: 43bb bics r3, r7
1a0: 2608 movs r6, #8
1a2: 4333 orrs r3, r6
1a4: 70d3 strb r3, [r2, #3]
DMAC->QOSCTRL.bit.DQOS = 2;
1a6: 4b16 ldr r3, [pc, #88] ; (200 <Reset_Handler+0xd4>)
1a8: 7b98 ldrb r0, [r3, #14]
1aa: 2230 movs r2, #48 ; 0x30
1ac: 4390 bics r0, r2
1ae: 2220 movs r2, #32
1b0: 4310 orrs r0, r2
1b2: 7398 strb r0, [r3, #14]
DMAC->QOSCTRL.bit.FQOS = 2;
1b4: 7b99 ldrb r1, [r3, #14]
1b6: 43b9 bics r1, r7
1b8: 4331 orrs r1, r6
1ba: 7399 strb r1, [r3, #14]
DMAC->QOSCTRL.bit.WRBQOS = 2;
1bc: 7b9a ldrb r2, [r3, #14]
1be: 43aa bics r2, r5
1c0: 4322 orrs r2, r4
1c2: 739a strb r2, [r3, #14]
NVMCTRL->CTRLB.bit.MANW = 1;
1c4: 4a0f ldr r2, [pc, #60] ; (204 <Reset_Handler+0xd8>)
1c6: 6853 ldr r3, [r2, #4]
1c8: 2180 movs r1, #128 ; 0x80
1ca: 430b orrs r3, r1
1cc: 6053 str r3, [r2, #4]
__libc_init_array();
1ce: 4b0e ldr r3, [pc, #56] ; (208 <Reset_Handler+0xdc>)
1d0: 4798 blx r3
main();
1d2: 4b0e ldr r3, [pc, #56] ; (20c <Reset_Handler+0xe0>)
1d4: 4798 blx r3
1d6: e7fe b.n 1d6 <Reset_Handler+0xaa>
1d8: 00002ce4 .word 0x00002ce4
1dc: 20000000 .word 0x20000000
1e0: 20000068 .word 0x20000068
1e4: 20000004 .word 0x20000004
1e8: 20000068 .word 0x20000068
1ec: 200003bc .word 0x200003bc
1f0: e000ed00 .word 0xe000ed00
1f4: 00000000 .word 0x00000000
1f8: 41007000 .word 0x41007000
1fc: 41005000 .word 0x41005000
200: 41004800 .word 0x41004800
204: 41004000 .word 0x41004000
208: 00002b91 .word 0x00002b91
20c: 00002039 .word 0x00002039
00000210 <USART_0_PORT_init>:
#include <hpl_pm_base.h>
struct usart_sync_descriptor USART_0;
void USART_0_PORT_init(void)
{
210: b530 push {r4, r5, lr}
static inline void hri_port_write_PINCFG_PMUXEN_bit(const void *const hw, uint8_t submodule_index, uint8_t index,
bool value)
{
uint8_t tmp;
PORT_CRITICAL_SECTION_ENTER();
tmp = ((Port *)hw)->Group[submodule_index].PINCFG[index].reg;
212: 4b0e ldr r3, [pc, #56] ; (24c <USART_0_PORT_init+0x3c>)
214: 2256 movs r2, #86 ; 0x56
216: 5c99 ldrb r1, [r3, r2]
tmp &= ~PORT_PINCFG_PMUXEN;
218: 2501 movs r5, #1
21a: 43a9 bics r1, r5
tmp |= value << PORT_PINCFG_PMUXEN_Pos;
21c: 2401 movs r4, #1
21e: 4321 orrs r1, r4
220: b2c9 uxtb r1, r1
((Port *)hw)->Group[submodule_index].PINCFG[index].reg = tmp;
222: 5499 strb r1, [r3, r2]
tmp = ((Port *)hw)->Group[submodule_index].PMUX[index].reg;
224: 203b movs r0, #59 ; 0x3b
226: 5c19 ldrb r1, [r3, r0]
tmp &= ~PORT_PMUX_PMUXE_Msk;
228: 3a47 subs r2, #71 ; 0x47
22a: 4391 bics r1, r2
tmp |= PORT_PMUX_PMUXE(data);
22c: 3a0d subs r2, #13
22e: 4311 orrs r1, r2
((Port *)hw)->Group[submodule_index].PMUX[index].reg = tmp;
230: 5419 strb r1, [r3, r0]
tmp = ((Port *)hw)->Group[submodule_index].PINCFG[index].reg;
232: 2157 movs r1, #87 ; 0x57
234: 5c5a ldrb r2, [r3, r1]
tmp &= ~PORT_PINCFG_PMUXEN;
236: 43aa bics r2, r5
tmp |= value << PORT_PINCFG_PMUXEN_Pos;
238: 4322 orrs r2, r4
23a: b2d2 uxtb r2, r2
((Port *)hw)->Group[submodule_index].PINCFG[index].reg = tmp;
23c: 545a strb r2, [r3, r1]
tmp = ((Port *)hw)->Group[submodule_index].PMUX[index].reg;
23e: 5c1a ldrb r2, [r3, r0]
tmp &= ~PORT_PMUX_PMUXO_Msk;
240: 3948 subs r1, #72 ; 0x48
242: 400a ands r2, r1
tmp |= PORT_PMUX_PMUXO(data);
244: 3111 adds r1, #17
246: 430a orrs r2, r1
((Port *)hw)->Group[submodule_index].PMUX[index].reg = tmp;
248: 541a strb r2, [r3, r0]
gpio_set_pin_function(PA22, PINMUX_PA22C_SERCOM3_PAD0);
gpio_set_pin_function(PA23, PINMUX_PA23C_SERCOM3_PAD1);
}
24a: bd30 pop {r4, r5, pc}
24c: 41004400 .word 0x41004400
00000250 <USART_0_CLOCK_init>:
peripheral = (uint32_t)_pm_get_apbb_index(module);
PM->APBBMASK.reg |= 1 << peripheral;
}
break;
case PM_BUS_APBC:
PM->APBCMASK.reg |= 1 << peripheral;
250: 4a04 ldr r2, [pc, #16] ; (264 <USART_0_CLOCK_init+0x14>)
252: 6a13 ldr r3, [r2, #32]
254: 2120 movs r1, #32
256: 430b orrs r3, r1
258: 6213 str r3, [r2, #32]
}
static inline void hri_gclk_write_CLKCTRL_reg(const void *const hw, hri_gclk_clkctrl_reg_t data)
{
GCLK_CRITICAL_SECTION_ENTER();
((Gclk *)hw)->CLKCTRL.reg = data;
25a: 4a03 ldr r2, [pc, #12] ; (268 <USART_0_CLOCK_init+0x18>)
25c: 4b03 ldr r3, [pc, #12] ; (26c <USART_0_CLOCK_init+0x1c>)
25e: 805a strh r2, [r3, #2]
void USART_0_CLOCK_init(void)
{
_pm_enable_bus_clock(PM_BUS_APBC, SERCOM3);
_gclk_enable_channel(SERCOM3_GCLK_ID_CORE, CONF_GCLK_SERCOM3_CORE_SRC);
}
260: 4770 bx lr
262: 46c0 nop ; (mov r8, r8)
264: 40000400 .word 0x40000400
268: 00004017 .word 0x00004017
26c: 40000c00 .word 0x40000c00
00000270 <USART_0_init>:
void USART_0_init(void)
{
270: b510 push {r4, lr}
USART_0_CLOCK_init();
272: 4b05 ldr r3, [pc, #20] ; (288 <USART_0_init+0x18>)
274: 4798 blx r3
usart_sync_init(&USART_0, SERCOM3, (void *)NULL);
276: 2200 movs r2, #0
278: 4904 ldr r1, [pc, #16] ; (28c <USART_0_init+0x1c>)
27a: 4805 ldr r0, [pc, #20] ; (290 <USART_0_init+0x20>)
27c: 4b05 ldr r3, [pc, #20] ; (294 <USART_0_init+0x24>)
27e: 4798 blx r3
USART_0_PORT_init();
280: 4b05 ldr r3, [pc, #20] ; (298 <USART_0_init+0x28>)
282: 4798 blx r3
}
284: bd10 pop {r4, pc}
286: 46c0 nop ; (mov r8, r8)
288: 00000251 .word 0x00000251
28c: 42001400 .word 0x42001400
290: 200003b0 .word 0x200003b0
294: 00000485 .word 0x00000485
298: 00000211 .word 0x00000211
0000029c <USB_DEVICE_INSTANCE_PORT_init>:
void USB_DEVICE_INSTANCE_PORT_init(void)
{
29c: b5f0 push {r4, r5, r6, r7, lr}
29e: 46c6 mov lr, r8
2a0: b500 push {lr}
((Port *)hw)->Group[submodule_index].DIRSET.reg = mask;
2a2: 24c0 movs r4, #192 ; 0xc0
2a4: 05e4 lsls r4, r4, #23
2a6: 2280 movs r2, #128 ; 0x80
2a8: 0452 lsls r2, r2, #17
2aa: 60a2 str r2, [r4, #8]
static inline void hri_port_write_WRCONFIG_reg(const void *const hw, uint8_t submodule_index,
hri_port_wrconfig_reg_t data)
{
PORT_CRITICAL_SECTION_ENTER();
((Port *)hw)->Group[submodule_index].WRCONFIG.reg = data;
2ac: 4b1a ldr r3, [pc, #104] ; (318 <USB_DEVICE_INSTANCE_PORT_init+0x7c>)
2ae: 2780 movs r7, #128 ; 0x80
2b0: 05ff lsls r7, r7, #23
2b2: 629f str r7, [r3, #40] ; 0x28
2b4: 4919 ldr r1, [pc, #100] ; (31c <USB_DEVICE_INSTANCE_PORT_init+0x80>)
2b6: 6299 str r1, [r3, #40] ; 0x28
((Port *)hw)->Group[submodule_index].OUTCLR.reg = mask;
2b8: 6162 str r2, [r4, #20]
((Port *)hw)->Group[submodule_index].PINCFG[index].reg &= ~PORT_PINCFG_PULLEN;
2ba: 2058 movs r0, #88 ; 0x58
2bc: 5c19 ldrb r1, [r3, r0]
2be: 2204 movs r2, #4
2c0: 4690 mov r8, r2
2c2: 4391 bics r1, r2
2c4: 5419 strb r1, [r3, r0]
tmp = ((Port *)hw)->Group[submodule_index].PINCFG[index].reg;
2c6: 5c19 ldrb r1, [r3, r0]
tmp &= ~PORT_PINCFG_PMUXEN;
2c8: 2601 movs r6, #1
2ca: 43b1 bics r1, r6
tmp |= value << PORT_PINCFG_PMUXEN_Pos;
2cc: 2501 movs r5, #1
2ce: 4329 orrs r1, r5
2d0: b2c9 uxtb r1, r1
((Port *)hw)->Group[submodule_index].PINCFG[index].reg = tmp;
2d2: 5419 strb r1, [r3, r0]
tmp = ((Port *)hw)->Group[submodule_index].PMUX[index].reg;
2d4: 381c subs r0, #28
2d6: 5c19 ldrb r1, [r3, r0]
tmp &= ~PORT_PMUX_PMUXE_Msk;
2d8: 320b adds r2, #11
2da: 4391 bics r1, r2
tmp |= PORT_PMUX_PMUXE(data);
2dc: 3a09 subs r2, #9
2de: 4311 orrs r1, r2
((Port *)hw)->Group[submodule_index].PMUX[index].reg = tmp;
2e0: 5419 strb r1, [r3, r0]
((Port *)hw)->Group[submodule_index].DIRSET.reg = mask;
2e2: 2180 movs r1, #128 ; 0x80
2e4: 0489 lsls r1, r1, #18
2e6: 60a1 str r1, [r4, #8]
((Port *)hw)->Group[submodule_index].WRCONFIG.reg = data;
2e8: 629f str r7, [r3, #40] ; 0x28
2ea: 4f0d ldr r7, [pc, #52] ; (320 <USB_DEVICE_INSTANCE_PORT_init+0x84>)
2ec: 629f str r7, [r3, #40] ; 0x28
((Port *)hw)->Group[submodule_index].OUTCLR.reg = mask;
2ee: 6161 str r1, [r4, #20]
((Port *)hw)->Group[submodule_index].PINCFG[index].reg &= ~PORT_PINCFG_PULLEN;
2f0: 2159 movs r1, #89 ; 0x59
2f2: 5c5c ldrb r4, [r3, r1]
2f4: 4642 mov r2, r8
2f6: 4394 bics r4, r2
2f8: 545c strb r4, [r3, r1]
tmp = ((Port *)hw)->Group[submodule_index].PINCFG[index].reg;
2fa: 5c5a ldrb r2, [r3, r1]
tmp &= ~PORT_PINCFG_PMUXEN;
2fc: 43b2 bics r2, r6
tmp |= value << PORT_PINCFG_PMUXEN_Pos;
2fe: 432a orrs r2, r5
300: b2d2 uxtb r2, r2
((Port *)hw)->Group[submodule_index].PINCFG[index].reg = tmp;
302: 545a strb r2, [r3, r1]
tmp = ((Port *)hw)->Group[submodule_index].PMUX[index].reg;
304: 5c1a ldrb r2, [r3, r0]
tmp &= ~PORT_PMUX_PMUXO_Msk;
306: 394a subs r1, #74 ; 0x4a
308: 400a ands r2, r1
tmp |= PORT_PMUX_PMUXO(data);
30a: 3151 adds r1, #81 ; 0x51
30c: 430a orrs r2, r1
((Port *)hw)->Group[submodule_index].PMUX[index].reg = tmp;
30e: 541a strb r2, [r3, r0]
// <GPIO_PIN_FUNCTION_E"> E
// <GPIO_PIN_FUNCTION_F"> F
// <GPIO_PIN_FUNCTION_G"> G
// <GPIO_PIN_FUNCTION_H"> H
PINMUX_PA25G_USB_DP);
}
310: bc04 pop {r2}
312: 4690 mov r8, r2
314: bdf0 pop {r4, r5, r6, r7, pc}
316: 46c0 nop ; (mov r8, r8)
318: 41004400 .word 0x41004400
31c: c0000100 .word 0xc0000100
320: c0000200 .word 0xc0000200
00000324 <USB_DEVICE_INSTANCE_CLOCK_init>:
PM->APBBMASK.reg |= 1 << peripheral;
324: 4b06 ldr r3, [pc, #24] ; (340 <USB_DEVICE_INSTANCE_CLOCK_init+0x1c>)
326: 69da ldr r2, [r3, #28]
328: 2120 movs r1, #32
32a: 430a orrs r2, r1
32c: 61da str r2, [r3, #28]
PM->AHBMASK.reg |= 1 << peripheral;
32e: 695a ldr r2, [r3, #20]
330: 3120 adds r1, #32
332: 430a orrs r2, r1
334: 615a str r2, [r3, #20]
336: 4a03 ldr r2, [pc, #12] ; (344 <USB_DEVICE_INSTANCE_CLOCK_init+0x20>)
338: 4b03 ldr r3, [pc, #12] ; (348 <USB_DEVICE_INSTANCE_CLOCK_init+0x24>)
33a: 805a strh r2, [r3, #2]
{
_pm_enable_bus_clock(PM_BUS_APBB, USB);
_pm_enable_bus_clock(PM_BUS_AHB, USB);
_gclk_enable_channel(USB_GCLK_ID, CONF_GCLK_USB_SRC);
}
33c: 4770 bx lr
33e: 46c0 nop ; (mov r8, r8)
340: 40000400 .word 0x40000400
344: 00004006 .word 0x00004006
348: 40000c00 .word 0x40000c00
0000034c <USB_DEVICE_INSTANCE_init>:
void USB_DEVICE_INSTANCE_init(void)
{
34c: b510 push {r4, lr}
USB_DEVICE_INSTANCE_CLOCK_init();
34e: 4b03 ldr r3, [pc, #12] ; (35c <USB_DEVICE_INSTANCE_init+0x10>)
350: 4798 blx r3
usb_d_init();
352: 4b03 ldr r3, [pc, #12] ; (360 <USB_DEVICE_INSTANCE_init+0x14>)
354: 4798 blx r3
USB_DEVICE_INSTANCE_PORT_init();
356: 4b03 ldr r3, [pc, #12] ; (364 <USB_DEVICE_INSTANCE_init+0x18>)
358: 4798 blx r3
}
35a: bd10 pop {r4, pc}
35c: 00000325 .word 0x00000325
360: 00000741 .word 0x00000741
364: 0000029d .word 0x0000029d
00000368 <system_init>:
void system_init(void)
{
368: b510 push {r4, lr}
* Currently the following initialization functions are supported:
* - System clock initialization
*/
static inline void init_mcu(void)
{
_init_chip();
36a: 4b03 ldr r3, [pc, #12] ; (378 <system_init+0x10>)
36c: 4798 blx r3
init_mcu();
USART_0_init();
36e: 4b03 ldr r3, [pc, #12] ; (37c <system_init+0x14>)
370: 4798 blx r3
USB_DEVICE_INSTANCE_init();
372: 4b03 ldr r3, [pc, #12] ; (380 <system_init+0x18>)
374: 4798 blx r3
}
376: bd10 pop {r4, pc}
378: 00000b01 .word 0x00000b01
37c: 00000271 .word 0x00000271
380: 0000034d .word 0x0000034d
00000384 <atomic_enter_critical>:
*/
__STATIC_FORCEINLINE uint32_t __get_PRIMASK(void)
{
uint32_t result;
__ASM volatile ("MRS %0, primask" : "=r" (result) :: "memory");
384: f3ef 8310 mrs r3, PRIMASK
/**
* \brief Disable interrupts, enter critical section
*/
void atomic_enter_critical(hal_atomic_t volatile *atomic)
{
*atomic = __get_PRIMASK();
388: 6003 str r3, [r0, #0]
__ASM volatile ("cpsid i" : : : "memory");
38a: b672 cpsid i
\details Ensures the apparent order of the explicit memory operations before
and after the instruction, without ensuring their completion.
*/
__STATIC_FORCEINLINE void __DMB(void)
{
__ASM volatile ("dmb 0xF":::"memory");
38c: f3bf 8f5f dmb sy
__disable_irq();
__DMB();
}
390: 4770 bx lr
00000392 <atomic_leave_critical>:
392: f3bf 8f5f dmb sy
* \brief Exit atomic section
*/
void atomic_leave_critical(hal_atomic_t volatile *atomic)
{
__DMB();
__set_PRIMASK(*atomic);
396: 6803 ldr r3, [r0, #0]
__ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory");
398: f383 8810 msr PRIMASK, r3
}
39c: 4770 bx lr
...
000003a0 <usart_sync_write>:
* \param[in] length The number of bytes to write
*
* \return The number of bytes written.
*/
static int32_t usart_sync_write(struct io_descriptor *const io_descr, const uint8_t *const buf, const uint16_t length)
{
3a0: b5f8 push {r3, r4, r5, r6, r7, lr}
3a2: 46ce mov lr, r9
3a4: 4647 mov r7, r8
3a6: b580 push {r7, lr}
3a8: 0004 movs r4, r0
3aa: 000f movs r7, r1
3ac: 4690 mov r8, r2
uint32_t offset = 0;
struct usart_sync_descriptor *descr = CONTAINER_OF(io_descr, struct usart_sync_descriptor, io);
ASSERT(io_descr && buf && length);
3ae: 2800 cmp r0, #0
3b0: d026 beq.n 400 <usart_sync_write+0x60>
3b2: 2900 cmp r1, #0
3b4: d026 beq.n 404 <usart_sync_write+0x64>
3b6: 0010 movs r0, r2
3b8: 1e43 subs r3, r0, #1
3ba: 4198 sbcs r0, r3
3bc: 22f1 movs r2, #241 ; 0xf1
3be: 4912 ldr r1, [pc, #72] ; (408 <usart_sync_write+0x68>)
3c0: 4b12 ldr r3, [pc, #72] ; (40c <usart_sync_write+0x6c>)
3c2: 4798 blx r3
while (!_usart_sync_is_ready_to_send(&descr->device))
3c4: 3408 adds r4, #8
3c6: 4d12 ldr r5, [pc, #72] ; (410 <usart_sync_write+0x70>)
3c8: 0020 movs r0, r4
3ca: 47a8 blx r5
3cc: 2800 cmp r0, #0
3ce: d0fb beq.n 3c8 <usart_sync_write+0x28>
3d0: 2600 movs r6, #0
;
do {
_usart_sync_write_byte(&descr->device, buf[offset]);
3d2: 4b10 ldr r3, [pc, #64] ; (414 <usart_sync_write+0x74>)
3d4: 4699 mov r9, r3
while (!_usart_sync_is_ready_to_send(&descr->device))
3d6: 4d0e ldr r5, [pc, #56] ; (410 <usart_sync_write+0x70>)
_usart_sync_write_byte(&descr->device, buf[offset]);
3d8: 5db9 ldrb r1, [r7, r6]
3da: 0020 movs r0, r4
3dc: 47c8 blx r9
while (!_usart_sync_is_ready_to_send(&descr->device))
3de: 0020 movs r0, r4
3e0: 47a8 blx r5
3e2: 2800 cmp r0, #0
3e4: d0fb beq.n 3de <usart_sync_write+0x3e>
;
} while (++offset < length);
3e6: 3601 adds r6, #1
3e8: 4546 cmp r6, r8
3ea: d3f5 bcc.n 3d8 <usart_sync_write+0x38>
while (!_usart_sync_is_transmit_done(&descr->device))
3ec: 4d0a ldr r5, [pc, #40] ; (418 <usart_sync_write+0x78>)
3ee: 0020 movs r0, r4
3f0: 47a8 blx r5
3f2: 2800 cmp r0, #0
3f4: d0fb beq.n 3ee <usart_sync_write+0x4e>
;
return (int32_t)offset;
}
3f6: 0030 movs r0, r6
3f8: bc0c pop {r2, r3}
3fa: 4690 mov r8, r2
3fc: 4699 mov r9, r3
3fe: bdf8 pop {r3, r4, r5, r6, r7, pc}
ASSERT(io_descr && buf && length);
400: 2000 movs r0, #0
402: e7db b.n 3bc <usart_sync_write+0x1c>
404: 2000 movs r0, #0
406: e7d9 b.n 3bc <usart_sync_write+0x1c>
408: 00002bfc .word 0x00002bfc
40c: 00000a95 .word 0x00000a95
410: 00000c71 .word 0x00000c71
414: 00000c61 .word 0x00000c61
418: 00000c7b .word 0x00000c7b
0000041c <usart_sync_read>:
* \param[in] length The size of a buffer
*
* \return The number of bytes read.
*/
static int32_t usart_sync_read(struct io_descriptor *const io_descr, uint8_t *const buf, const uint16_t length)
{
41c: b5f8 push {r3, r4, r5, r6, r7, lr}
41e: 46ce mov lr, r9
420: 4647 mov r7, r8
422: b580 push {r7, lr}
424: 0004 movs r4, r0
426: 000f movs r7, r1
428: 4690 mov r8, r2
uint32_t offset = 0;
struct usart_sync_descriptor *descr = CONTAINER_OF(io_descr, struct usart_sync_descriptor, io);
ASSERT(io_descr && buf && length);
42a: 2800 cmp r0, #0
42c: d01d beq.n 46a <usart_sync_read+0x4e>
42e: 2900 cmp r1, #0
430: d01d beq.n 46e <usart_sync_read+0x52>
432: 0010 movs r0, r2
434: 1e43 subs r3, r0, #1
436: 4198 sbcs r0, r3
438: 2286 movs r2, #134 ; 0x86
43a: 0052 lsls r2, r2, #1
43c: 490d ldr r1, [pc, #52] ; (474 <usart_sync_read+0x58>)
43e: 4b0e ldr r3, [pc, #56] ; (478 <usart_sync_read+0x5c>)
440: 4798 blx r3
uint32_t offset = 0;
442: 2600 movs r6, #0
do {
while (!_usart_sync_is_byte_received(&descr->device))
444: 3408 adds r4, #8
446: 4d0d ldr r5, [pc, #52] ; (47c <usart_sync_read+0x60>)
;
buf[offset] = _usart_sync_read_byte(&descr->device);
448: 4b0d ldr r3, [pc, #52] ; (480 <usart_sync_read+0x64>)
44a: 4699 mov r9, r3
while (!_usart_sync_is_byte_received(&descr->device))
44c: 0020 movs r0, r4
44e: 47a8 blx r5
450: 2800 cmp r0, #0
452: d0fb beq.n 44c <usart_sync_read+0x30>
buf[offset] = _usart_sync_read_byte(&descr->device);
454: 0020 movs r0, r4
456: 47c8 blx r9
458: 55b8 strb r0, [r7, r6]
} while (++offset < length);
45a: 3601 adds r6, #1
45c: 4546 cmp r6, r8
45e: d3f5 bcc.n 44c <usart_sync_read+0x30>
return (int32_t)offset;
}
460: 0030 movs r0, r6
462: bc0c pop {r2, r3}
464: 4690 mov r8, r2
466: 4699 mov r9, r3
468: bdf8 pop {r3, r4, r5, r6, r7, pc}
ASSERT(io_descr && buf && length);
46a: 2000 movs r0, #0
46c: e7e4 b.n 438 <usart_sync_read+0x1c>
46e: 2000 movs r0, #0
470: e7e2 b.n 438 <usart_sync_read+0x1c>
472: 46c0 nop ; (mov r8, r8)
474: 00002bfc .word 0x00002bfc
478: 00000a95 .word 0x00000a95
47c: 00000c85 .word 0x00000c85
480: 00000c69 .word 0x00000c69
00000484 <usart_sync_init>:
{
484: b570 push {r4, r5, r6, lr}
486: 0005 movs r5, r0
488: 000c movs r4, r1
ASSERT(descr && hw);
48a: 2800 cmp r0, #0
48c: d013 beq.n 4b6 <usart_sync_init+0x32>
48e: 0008 movs r0, r1
490: 1e43 subs r3, r0, #1
492: 4198 sbcs r0, r3
494: b2c0 uxtb r0, r0
496: 2234 movs r2, #52 ; 0x34
498: 4908 ldr r1, [pc, #32] ; (4bc <usart_sync_init+0x38>)
49a: 4b09 ldr r3, [pc, #36] ; (4c0 <usart_sync_init+0x3c>)
49c: 4798 blx r3
init_status = _usart_sync_init(&descr->device, hw);
49e: 0028 movs r0, r5
4a0: 3008 adds r0, #8
4a2: 0021 movs r1, r4
4a4: 4b07 ldr r3, [pc, #28] ; (4c4 <usart_sync_init+0x40>)
4a6: 4798 blx r3
if (init_status) {
4a8: 2800 cmp r0, #0
4aa: d103 bne.n 4b4 <usart_sync_init+0x30>
descr->io.read = usart_sync_read;
4ac: 4b06 ldr r3, [pc, #24] ; (4c8 <usart_sync_init+0x44>)
4ae: 606b str r3, [r5, #4]
descr->io.write = usart_sync_write;
4b0: 4b06 ldr r3, [pc, #24] ; (4cc <usart_sync_init+0x48>)
4b2: 602b str r3, [r5, #0]
}
4b4: bd70 pop {r4, r5, r6, pc}
4b6: 2000 movs r0, #0
4b8: e7ed b.n 496 <usart_sync_init+0x12>
4ba: 46c0 nop ; (mov r8, r8)
4bc: 00002bfc .word 0x00002bfc
4c0: 00000a95 .word 0x00000a95
4c4: 00000c35 .word 0x00000c35
4c8: 0000041d .word 0x0000041d
4cc: 000003a1 .word 0x000003a1
000004d0 <_usb_d_find_ep>:
* \return Index of endpoint descriptor.
* \retval >=0 The index.
* \retval <0 Not found (endpoint is not initialized).
*/
static int8_t _usb_d_find_ep(const uint8_t ep)
{
4d0: b5f0 push {r4, r5, r6, r7, lr}
4d2: 0004 movs r4, r0
int8_t i;
for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) {
if (usb_d_inst.ep[i].xfer.hdr.ep == ep) {
4d4: 4b0e ldr r3, [pc, #56] ; (510 <_usb_d_find_ep+0x40>)
4d6: 785a ldrb r2, [r3, #1]
4d8: 4290 cmp r0, r2
4da: d017 beq.n 50c <_usb_d_find_ep+0x3c>
4dc: 2300 movs r3, #0
4de: 2000 movs r0, #0
return i;
}
if (usb_d_inst.ep[i].xfer.hdr.type == USB_EP_XTYPE_CTRL
4e0: 4f0b ldr r7, [pc, #44] ; (510 <_usb_d_find_ep+0x40>)
&& (ep & USB_EP_N_MASK) == usb_d_inst.ep[i].xfer.hdr.ep) {
4e2: 260f movs r6, #15
4e4: 4026 ands r6, r4
if (usb_d_inst.ep[i].xfer.hdr.ep == ep) {
4e6: 003d movs r5, r7
4e8: e008 b.n 4fc <_usb_d_find_ep+0x2c>
4ea: 3001 adds r0, #1
4ec: b240 sxtb r0, r0
for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) {
4ee: 2804 cmp r0, #4
4f0: d00a beq.n 508 <_usb_d_find_ep+0x38>
4f2: 3320 adds r3, #32
if (usb_d_inst.ep[i].xfer.hdr.ep == ep) {
4f4: 18ea adds r2, r5, r3
4f6: 7852 ldrb r2, [r2, #1]
4f8: 42a2 cmp r2, r4
4fa: d006 beq.n 50a <_usb_d_find_ep+0x3a>
if (usb_d_inst.ep[i].xfer.hdr.type == USB_EP_XTYPE_CTRL
4fc: 5dd9 ldrb r1, [r3, r7]
4fe: 2900 cmp r1, #0
500: d1f3 bne.n 4ea <_usb_d_find_ep+0x1a>
&& (ep & USB_EP_N_MASK) == usb_d_inst.ep[i].xfer.hdr.ep) {
502: 4296 cmp r6, r2
504: d1f1 bne.n 4ea <_usb_d_find_ep+0x1a>
506: e000 b.n 50a <_usb_d_find_ep+0x3a>
return i;
}
}
return -1;
508: 3805 subs r0, #5
}
50a: bdf0 pop {r4, r5, r6, r7, pc}
for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) {
50c: 2000 movs r0, #0
50e: e7fc b.n 50a <_usb_d_find_ep+0x3a>
510: 20000084 .word 0x20000084
00000514 <usb_d_dummy_cb_false>:
{
(void)unused0;
(void)unused1;
(void)unused2;
return false;
}
514: 2000 movs r0, #0
516: 4770 bx lr
00000518 <usb_d_cb_trans_more>:
* \brief Callback invoked when request more data
* \param[in] ep Endpoint number with transfer direction on bit 8.
* \param[in] transfered Number of bytes transfered.
*/
static bool usb_d_cb_trans_more(const uint8_t ep, const uint32_t transfered)
{
518: b570 push {r4, r5, r6, lr}
51a: 0004 movs r4, r0
51c: 000d movs r5, r1
int8_t ep_index = _usb_d_find_ep(ep);
51e: 4b0a ldr r3, [pc, #40] ; (548 <usb_d_cb_trans_more+0x30>)
520: 4798 blx r3
struct usb_d_ep *ept = &usb_d_inst.ep[ep_index];
if (ept->xfer.hdr.state == USB_EP_S_X_DATA) {
522: 0142 lsls r2, r0, #5
524: 4b09 ldr r3, [pc, #36] ; (54c <usb_d_cb_trans_more+0x34>)
526: 189b adds r3, r3, r2
528: 789a ldrb r2, [r3, #2]
return ept->callbacks.more(ep, transfered);
}
return false;
52a: 2300 movs r3, #0
if (ept->xfer.hdr.state == USB_EP_S_X_DATA) {
52c: 2a03 cmp r2, #3
52e: d001 beq.n 534 <usb_d_cb_trans_more+0x1c>
}
530: 0018 movs r0, r3
532: bd70 pop {r4, r5, r6, pc}
return ept->callbacks.more(ep, transfered);
534: 0140 lsls r0, r0, #5
536: 4b05 ldr r3, [pc, #20] ; (54c <usb_d_cb_trans_more+0x34>)
538: 1818 adds r0, r3, r0
53a: 6983 ldr r3, [r0, #24]
53c: 0029 movs r1, r5
53e: 0020 movs r0, r4
540: 4798 blx r3
542: 0003 movs r3, r0
544: e7f4 b.n 530 <usb_d_cb_trans_more+0x18>
546: 46c0 nop ; (mov r8, r8)
548: 000004d1 .word 0x000004d1
54c: 20000084 .word 0x20000084
00000550 <_usb_d_cb_trans_done>:
/**
* Callback when USB transactions are finished.
*/
static void _usb_d_cb_trans_done(const uint8_t ep, const int32_t code, const uint32_t transferred)
{
550: b5f0 push {r4, r5, r6, r7, lr}
552: b085 sub sp, #20
554: 0005 movs r5, r0
556: 000f movs r7, r1
558: 0016 movs r6, r2
int8_t ep_index = _usb_d_find_ep(ep);
55a: 4b51 ldr r3, [pc, #324] ; (6a0 <_usb_d_cb_trans_done+0x150>)
55c: 4798 blx r3
55e: 0004 movs r4, r0
struct usb_d_ep *ept = &usb_d_inst.ep[ep_index];
if (code == USB_TRANS_DONE) {
560: 2f00 cmp r7, #0
562: d162 bne.n 62a <_usb_d_cb_trans_done+0xda>
ept->xfer.hdr.status = USB_XFER_DONE;
564: 4b4f ldr r3, [pc, #316] ; (6a4 <_usb_d_cb_trans_done+0x154>)
566: 0142 lsls r2, r0, #5
568: 1899 adds r1, r3, r2
56a: 2000 movs r0, #0
56c: 70c8 strb r0, [r1, #3]
if (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) {
56e: 5cd3 ldrb r3, [r2, r3]
570: 2b00 cmp r3, #0
572: d00e beq.n 592 <_usb_d_cb_trans_done+0x42>
usb_d_ctrl_trans_done(ept);
return;
}
ept->xfer.hdr.state = USB_EP_S_IDLE;
574: 0162 lsls r2, r4, #5
576: 4b4b ldr r3, [pc, #300] ; (6a4 <_usb_d_cb_trans_done+0x154>)
578: 189b adds r3, r3, r2
57a: 2201 movs r2, #1
57c: 709a strb r2, [r3, #2]
} else {
ept->xfer.hdr.state = USB_EP_S_ERROR;
ept->xfer.hdr.status = USB_XFER_ERROR;
}
ept->callbacks.xfer(ep, (enum usb_xfer_code)ept->xfer.hdr.status, (void *)transferred);
57e: 0164 lsls r4, r4, #5
580: 4b48 ldr r3, [pc, #288] ; (6a4 <_usb_d_cb_trans_done+0x154>)
582: 191c adds r4, r3, r4
584: 78e1 ldrb r1, [r4, #3]
586: 69e3 ldr r3, [r4, #28]
588: 0032 movs r2, r6
58a: 0028 movs r0, r5
58c: 4798 blx r3
}
58e: b005 add sp, #20
590: bdf0 pop {r4, r5, r6, r7, pc}
if (state == USB_EP_S_X_DATA) {
592: 788b ldrb r3, [r1, #2]
594: 2b03 cmp r3, #3
596: d00c beq.n 5b2 <_usb_d_cb_trans_done+0x62>
ept->callbacks.xfer(ept->xfer.hdr.ep, USB_XFER_DONE, ept->xfer.req);
598: 4b42 ldr r3, [pc, #264] ; (6a4 <_usb_d_cb_trans_done+0x154>)
59a: 0162 lsls r2, r4, #5
59c: 320c adds r2, #12
59e: 189a adds r2, r3, r2
5a0: 0164 lsls r4, r4, #5
5a2: 191c adds r4, r3, r4
5a4: 7860 ldrb r0, [r4, #1]
5a6: 2100 movs r1, #0
5a8: 69e3 ldr r3, [r4, #28]
5aa: 4798 blx r3
ept->xfer.hdr.state = USB_EP_S_X_SETUP;
5ac: 2302 movs r3, #2
5ae: 70a3 strb r3, [r4, #2]
5b0: e7ed b.n 58e <_usb_d_cb_trans_done+0x3e>
bool req_dir = USB_GET_bmRequestType(ept->xfer.req) & USB_REQ_TYPE_IN;
5b2: 4a3c ldr r2, [pc, #240] ; (6a4 <_usb_d_cb_trans_done+0x154>)
5b4: 000b movs r3, r1
5b6: 250c movs r5, #12
5b8: 574d ldrsb r5, [r1, r5]
bool err = ept->callbacks.xfer(ept->xfer.hdr.ep, USB_XFER_DATA, ept->xfer.req);
5ba: 0161 lsls r1, r4, #5
5bc: 310c adds r1, #12
5be: 1852 adds r2, r2, r1
5c0: 7858 ldrb r0, [r3, #1]
5c2: 69db ldr r3, [r3, #28]
5c4: 2101 movs r1, #1
5c6: 4798 blx r3
if (err) {
5c8: 2800 cmp r0, #0
5ca: d017 beq.n 5fc <_usb_d_cb_trans_done+0xac>
ept->xfer.hdr.state = USB_EP_S_HALTED;
5cc: 0162 lsls r2, r4, #5
5ce: 4b35 ldr r3, [pc, #212] ; (6a4 <_usb_d_cb_trans_done+0x154>)
5d0: 189b adds r3, r3, r2
5d2: 2205 movs r2, #5
5d4: 709a strb r2, [r3, #2]
ept->xfer.hdr.status = USB_XFER_HALT;
5d6: 3a03 subs r2, #3
5d8: 70da strb r2, [r3, #3]
_usb_d_dev_ep_stall(req_dir ? ept->xfer.hdr.ep : (ept->xfer.hdr.ep | USB_EP_DIR), USB_EP_STALL_SET);
5da: 2d00 cmp r5, #0
5dc: db09 blt.n 5f2 <_usb_d_cb_trans_done+0xa2>
5de: 0164 lsls r4, r4, #5
5e0: 4b30 ldr r3, [pc, #192] ; (6a4 <_usb_d_cb_trans_done+0x154>)
5e2: 191c adds r4, r3, r4
5e4: 7860 ldrb r0, [r4, #1]
5e6: 2380 movs r3, #128 ; 0x80
5e8: 4318 orrs r0, r3
5ea: 2101 movs r1, #1
5ec: 4b2e ldr r3, [pc, #184] ; (6a8 <_usb_d_cb_trans_done+0x158>)
5ee: 4798 blx r3
5f0: e7cd b.n 58e <_usb_d_cb_trans_done+0x3e>
5f2: 0164 lsls r4, r4, #5
5f4: 4b2b ldr r3, [pc, #172] ; (6a4 <_usb_d_cb_trans_done+0x154>)
5f6: 191c adds r4, r3, r4
5f8: 7860 ldrb r0, [r4, #1]
5fa: e7f6 b.n 5ea <_usb_d_cb_trans_done+0x9a>
ept->xfer.hdr.state = USB_EP_S_X_STATUS;
5fc: 0164 lsls r4, r4, #5
5fe: 4b29 ldr r3, [pc, #164] ; (6a4 <_usb_d_cb_trans_done+0x154>)
600: 191c adds r4, r3, r4
602: 2304 movs r3, #4
604: 70a3 strb r3, [r4, #2]
_usb_d_trans(ept->xfer.hdr.ep, !req_dir, NULL, 0, 1);
606: 7863 ldrb r3, [r4, #1]
struct usb_d_transfer trans
608: 2200 movs r2, #0
60a: 9201 str r2, [sp, #4]
60c: 9202 str r2, [sp, #8]
60e: 2d00 cmp r5, #0
610: db08 blt.n 624 <_usb_d_cb_trans_done+0xd4>
612: 3280 adds r2, #128 ; 0x80
614: 4313 orrs r3, r2
616: a801 add r0, sp, #4
618: 7203 strb r3, [r0, #8]
61a: 2301 movs r3, #1
61c: 7243 strb r3, [r0, #9]
return _usb_d_dev_ep_trans(&trans);
61e: 4b23 ldr r3, [pc, #140] ; (6ac <_usb_d_cb_trans_done+0x15c>)
620: 4798 blx r3
622: e7b4 b.n 58e <_usb_d_cb_trans_done+0x3e>
struct usb_d_transfer trans
624: 220f movs r2, #15
626: 4013 ands r3, r2
628: e7f5 b.n 616 <_usb_d_cb_trans_done+0xc6>
} else if (code == USB_TRANS_STALL) {
62a: 2f01 cmp r7, #1
62c: d00a beq.n 644 <_usb_d_cb_trans_done+0xf4>
} else if (code == USB_TRANS_ABORT) {
62e: 2f02 cmp r7, #2
630: d01d beq.n 66e <_usb_d_cb_trans_done+0x11e>
} else if (code == USB_TRANS_RESET) {
632: 2f03 cmp r7, #3
634: d02c beq.n 690 <_usb_d_cb_trans_done+0x140>
ept->xfer.hdr.state = USB_EP_S_ERROR;
636: 0142 lsls r2, r0, #5
638: 4b1a ldr r3, [pc, #104] ; (6a4 <_usb_d_cb_trans_done+0x154>)
63a: 189b adds r3, r3, r2
63c: 2206 movs r2, #6
63e: 709a strb r2, [r3, #2]
ept->xfer.hdr.status = USB_XFER_ERROR;
640: 70da strb r2, [r3, #3]
642: e79c b.n 57e <_usb_d_cb_trans_done+0x2e>
ept->xfer.hdr.status = USB_XFER_HALT;
644: 4b17 ldr r3, [pc, #92] ; (6a4 <_usb_d_cb_trans_done+0x154>)
646: 0142 lsls r2, r0, #5
648: 1899 adds r1, r3, r2
64a: 2002 movs r0, #2
64c: 70c8 strb r0, [r1, #3]
if (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) {
64e: 5cd3 ldrb r3, [r2, r3]
650: 2b00 cmp r3, #0
652: d005 beq.n 660 <_usb_d_cb_trans_done+0x110>
ept->xfer.hdr.state = USB_EP_S_HALTED;
654: 0162 lsls r2, r4, #5
656: 4b13 ldr r3, [pc, #76] ; (6a4 <_usb_d_cb_trans_done+0x154>)
658: 189b adds r3, r3, r2
65a: 2205 movs r2, #5
65c: 709a strb r2, [r3, #2]
65e: e78e b.n 57e <_usb_d_cb_trans_done+0x2e>
ept->xfer.hdr.state = USB_EP_S_X_SETUP;
660: 2202 movs r2, #2
662: 708a strb r2, [r1, #2]
_usb_d_dev_ep_stall(ep, USB_EP_STALL_CLR);
664: 2100 movs r1, #0
666: 0028 movs r0, r5
668: 4b0f ldr r3, [pc, #60] ; (6a8 <_usb_d_cb_trans_done+0x158>)
66a: 4798 blx r3
66c: e787 b.n 57e <_usb_d_cb_trans_done+0x2e>
ept->xfer.hdr.status = USB_XFER_ABORT;
66e: 4b0d ldr r3, [pc, #52] ; (6a4 <_usb_d_cb_trans_done+0x154>)
670: 0142 lsls r2, r0, #5
672: 1899 adds r1, r3, r2
674: 2004 movs r0, #4
676: 70c8 strb r0, [r1, #3]
if (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) {
678: 5cd3 ldrb r3, [r2, r3]
67a: 2b00 cmp r3, #0
67c: d005 beq.n 68a <_usb_d_cb_trans_done+0x13a>
ept->xfer.hdr.state = USB_EP_S_IDLE;
67e: 0162 lsls r2, r4, #5
680: 4b08 ldr r3, [pc, #32] ; (6a4 <_usb_d_cb_trans_done+0x154>)
682: 189b adds r3, r3, r2
684: 2201 movs r2, #1
686: 709a strb r2, [r3, #2]
688: e779 b.n 57e <_usb_d_cb_trans_done+0x2e>
ept->xfer.hdr.state = USB_EP_S_X_SETUP;
68a: 2302 movs r3, #2
68c: 708b strb r3, [r1, #2]
return;
68e: e77e b.n 58e <_usb_d_cb_trans_done+0x3e>
ept->xfer.hdr.state = USB_EP_S_DISABLED;
690: 0142 lsls r2, r0, #5
692: 4b04 ldr r3, [pc, #16] ; (6a4 <_usb_d_cb_trans_done+0x154>)
694: 189b adds r3, r3, r2
696: 2200 movs r2, #0
698: 709a strb r2, [r3, #2]
ept->xfer.hdr.status = USB_XFER_RESET;
69a: 3205 adds r2, #5
69c: 70da strb r2, [r3, #3]
69e: e76e b.n 57e <_usb_d_cb_trans_done+0x2e>
6a0: 000004d1 .word 0x000004d1
6a4: 20000084 .word 0x20000084
6a8: 000019c1 .word 0x000019c1
6ac: 00001b95 .word 0x00001b95
000006b0 <usb_d_cb_trans_setup>:
{
6b0: b5f0 push {r4, r5, r6, r7, lr}
6b2: 46c6 mov lr, r8
6b4: b500 push {lr}
6b6: 0004 movs r4, r0
int8_t ep_index = _usb_d_find_ep(ep);
6b8: 4b1d ldr r3, [pc, #116] ; (730 <usb_d_cb_trans_setup+0x80>)
6ba: 4798 blx r3
6bc: 0006 movs r6, r0
uint8_t * req = ept->xfer.req;
6be: 0145 lsls r5, r0, #5
6c0: 350c adds r5, #12
6c2: 4b1c ldr r3, [pc, #112] ; (734 <usb_d_cb_trans_setup+0x84>)
6c4: 195d adds r5, r3, r5
uint8_t n = _usb_d_dev_ep_read_req(ep, req);
6c6: 0029 movs r1, r5
6c8: 0020 movs r0, r4
6ca: 4b1b ldr r3, [pc, #108] ; (738 <usb_d_cb_trans_setup+0x88>)
6cc: 4798 blx r3
if (n != 8) {
6ce: b2c0 uxtb r0, r0
6d0: 2808 cmp r0, #8
6d2: d00a beq.n 6ea <usb_d_cb_trans_setup+0x3a>
_usb_d_dev_ep_stall(ep, USB_EP_STALL_SET);
6d4: 2101 movs r1, #1
6d6: 0020 movs r0, r4
6d8: 4d18 ldr r5, [pc, #96] ; (73c <usb_d_cb_trans_setup+0x8c>)
6da: 47a8 blx r5
_usb_d_dev_ep_stall(ep | USB_EP_DIR, USB_EP_STALL_SET);
6dc: 2080 movs r0, #128 ; 0x80
6de: 4320 orrs r0, r4
6e0: 2101 movs r1, #1
6e2: 47a8 blx r5
}
6e4: bc04 pop {r2}
6e6: 4690 mov r8, r2
6e8: bdf0 pop {r4, r5, r6, r7, pc}
_usb_d_dev_ep_stall(ep, USB_EP_STALL_CLR);
6ea: 2100 movs r1, #0
6ec: 0020 movs r0, r4
6ee: 4b13 ldr r3, [pc, #76] ; (73c <usb_d_cb_trans_setup+0x8c>)
6f0: 4698 mov r8, r3
6f2: 4798 blx r3
_usb_d_dev_ep_stall(ep | USB_EP_DIR, USB_EP_STALL_CLR);
6f4: 2780 movs r7, #128 ; 0x80
6f6: 4327 orrs r7, r4
6f8: 2100 movs r1, #0
6fa: 0038 movs r0, r7
6fc: 47c0 blx r8
ept->xfer.hdr.state = USB_EP_S_IDLE;
6fe: 0172 lsls r2, r6, #5
700: 4b0c ldr r3, [pc, #48] ; (734 <usb_d_cb_trans_setup+0x84>)
702: 189b adds r3, r3, r2
704: 2201 movs r2, #1
706: 709a strb r2, [r3, #2]
if (!ept->callbacks.req(ep, req)) {
708: 695b ldr r3, [r3, #20]
70a: 0029 movs r1, r5
70c: 0020 movs r0, r4
70e: 4798 blx r3
710: 2800 cmp r0, #0
712: d1e7 bne.n 6e4 <usb_d_cb_trans_setup+0x34>
ept->xfer.hdr.state = USB_EP_S_HALTED;
714: 0176 lsls r6, r6, #5
716: 4b07 ldr r3, [pc, #28] ; (734 <usb_d_cb_trans_setup+0x84>)
718: 199e adds r6, r3, r6
71a: 2305 movs r3, #5
71c: 70b3 strb r3, [r6, #2]
_usb_d_dev_ep_stall(ep, USB_EP_STALL_SET);
71e: 2101 movs r1, #1
720: 0020 movs r0, r4
722: 4c06 ldr r4, [pc, #24] ; (73c <usb_d_cb_trans_setup+0x8c>)
724: 47a0 blx r4
_usb_d_dev_ep_stall(ep | USB_EP_DIR, USB_EP_STALL_SET);
726: 2101 movs r1, #1
728: 0038 movs r0, r7
72a: 47a0 blx r4
72c: e7da b.n 6e4 <usb_d_cb_trans_setup+0x34>
72e: 46c0 nop ; (mov r8, r8)
730: 000004d1 .word 0x000004d1
734: 20000084 .word 0x20000084
738: 00001b25 .word 0x00001b25
73c: 000019c1 .word 0x000019c1
00000740 <usb_d_init>:
int32_t usb_d_init(void)
{
740: b510 push {r4, lr}
int32_t rc = _usb_d_dev_init();
742: 4b10 ldr r3, [pc, #64] ; (784 <usb_d_init+0x44>)
744: 4798 blx r3
uint8_t i;
if (rc < 0) {
746: 2800 cmp r0, #0
748: db1b blt.n 782 <usb_d_init+0x42>
return rc;
}
memset(usb_d_inst.ep, 0x00, sizeof(struct usb_d_ep) * CONF_USB_D_NUM_EP_SP);
74a: 4c0f ldr r4, [pc, #60] ; (788 <usb_d_init+0x48>)
74c: 2280 movs r2, #128 ; 0x80
74e: 2100 movs r1, #0
750: 0020 movs r0, r4
752: 4b0e ldr r3, [pc, #56] ; (78c <usb_d_init+0x4c>)
754: 4798 blx r3
756: 0023 movs r3, r4
758: 3480 adds r4, #128 ; 0x80
for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) {
usb_d_inst.ep[i].xfer.hdr.ep = 0xFF;
75a: 21ff movs r1, #255 ; 0xff
usb_d_inst.ep[i].callbacks.req = (usb_d_ep_cb_setup_t)usb_d_dummy_cb_false;
75c: 4a0c ldr r2, [pc, #48] ; (790 <usb_d_init+0x50>)
usb_d_inst.ep[i].xfer.hdr.ep = 0xFF;
75e: 7059 strb r1, [r3, #1]
usb_d_inst.ep[i].callbacks.req = (usb_d_ep_cb_setup_t)usb_d_dummy_cb_false;
760: 615a str r2, [r3, #20]
usb_d_inst.ep[i].callbacks.more = (usb_d_ep_cb_more_t)usb_d_dummy_cb_false;
762: 619a str r2, [r3, #24]
usb_d_inst.ep[i].callbacks.xfer = (usb_d_ep_cb_xfer_t)usb_d_dummy_cb_false;
764: 61da str r2, [r3, #28]
766: 3320 adds r3, #32
for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) {
768: 42a3 cmp r3, r4
76a: d1f8 bne.n 75e <usb_d_init+0x1e>
}
/* Handles device driver endpoint callbacks to build transfer. */
_usb_d_dev_register_ep_callback(USB_D_DEV_EP_CB_SETUP, (FUNC_PTR)usb_d_cb_trans_setup);
76c: 4909 ldr r1, [pc, #36] ; (794 <usb_d_init+0x54>)
76e: 2000 movs r0, #0
770: 4c09 ldr r4, [pc, #36] ; (798 <usb_d_init+0x58>)
772: 47a0 blx r4
_usb_d_dev_register_ep_callback(USB_D_DEV_EP_CB_MORE, (FUNC_PTR)usb_d_cb_trans_more);
774: 4909 ldr r1, [pc, #36] ; (79c <usb_d_init+0x5c>)
776: 2001 movs r0, #1
778: 47a0 blx r4
_usb_d_dev_register_ep_callback(USB_D_DEV_EP_CB_DONE, (FUNC_PTR)_usb_d_cb_trans_done);
77a: 4909 ldr r1, [pc, #36] ; (7a0 <usb_d_init+0x60>)
77c: 2002 movs r0, #2
77e: 47a0 blx r4
return ERR_NONE;
780: 2000 movs r0, #0
}
782: bd10 pop {r4, pc}
784: 000013a1 .word 0x000013a1
788: 20000084 .word 0x20000084
78c: 00002beb .word 0x00002beb
790: 00000515 .word 0x00000515
794: 000006b1 .word 0x000006b1
798: 00001dcd .word 0x00001dcd
79c: 00000519 .word 0x00000519
7a0: 00000551 .word 0x00000551
000007a4 <usb_d_register_callback>:
{
_usb_d_dev_deinit();
}
void usb_d_register_callback(const enum usb_d_cb_type type, const FUNC_PTR func)
{
7a4: b510 push {r4, lr}
/* Directly uses device driver callback. */
_usb_d_dev_register_callback(type, func);
7a6: 4b01 ldr r3, [pc, #4] ; (7ac <usb_d_register_callback+0x8>)
7a8: 4798 blx r3
}
7aa: bd10 pop {r4, pc}
7ac: 00001da9 .word 0x00001da9
000007b0 <usb_d_enable>:
int32_t usb_d_enable(void)
{
7b0: b510 push {r4, lr}
return _usb_d_dev_enable();
7b2: 4b01 ldr r3, [pc, #4] ; (7b8 <usb_d_enable+0x8>)
7b4: 4798 blx r3
}
7b6: bd10 pop {r4, pc}
7b8: 0000147d .word 0x0000147d
000007bc <usb_d_attach>:
{
_usb_d_dev_disable();
}
void usb_d_attach(void)
{
7bc: b510 push {r4, lr}
_usb_d_dev_attach();
7be: 4b01 ldr r3, [pc, #4] ; (7c4 <usb_d_attach+0x8>)
7c0: 4798 blx r3
}
7c2: bd10 pop {r4, pc}
7c4: 000014cd .word 0x000014cd
000007c8 <usb_d_set_address>:
{
return _usb_d_dev_get_uframe_n();
}
void usb_d_set_address(const uint8_t addr)
{
7c8: b510 push {r4, lr}
_usb_d_dev_set_address(addr);
7ca: 4b01 ldr r3, [pc, #4] ; (7d0 <usb_d_set_address+0x8>)
7cc: 4798 blx r3
}
7ce: bd10 pop {r4, pc}
7d0: 000014dd .word 0x000014dd
000007d4 <usb_d_ep_init>:
{
return usb_d_ep_init(0, USB_EP_XTYPE_CTRL, max_pkt_size);
}
int32_t usb_d_ep_init(const uint8_t ep, const uint8_t attr, const uint16_t max_pkt_size)
{
7d4: b5f8 push {r3, r4, r5, r6, r7, lr}
7d6: 0005 movs r5, r0
7d8: 000e movs r6, r1
7da: 0017 movs r7, r2
int32_t rc;
int8_t ep_index = _usb_d_find_ep(ep);
7dc: 4b0f ldr r3, [pc, #60] ; (81c <usb_d_ep_init+0x48>)
7de: 4798 blx r3
struct usb_d_ep *ept = &usb_d_inst.ep[ep_index];
if (ep_index >= 0) {
7e0: 2800 cmp r0, #0
7e2: da14 bge.n 80e <usb_d_ep_init+0x3a>
return -USB_ERR_REDO;
} else {
ep_index = _usb_d_find_ep(0xFF);
7e4: 20ff movs r0, #255 ; 0xff
7e6: 4b0d ldr r3, [pc, #52] ; (81c <usb_d_ep_init+0x48>)
7e8: 4798 blx r3
7ea: 1e04 subs r4, r0, #0
if (ep_index < 0) {
7ec: db12 blt.n 814 <usb_d_ep_init+0x40>
return -USB_ERR_ALLOC_FAIL;
}
ept = &usb_d_inst.ep[ep_index];
}
rc = _usb_d_dev_ep_init(ep, attr, max_pkt_size);
7ee: 003a movs r2, r7
7f0: 0031 movs r1, r6
7f2: 0028 movs r0, r5
7f4: 4b0a ldr r3, [pc, #40] ; (820 <usb_d_ep_init+0x4c>)
7f6: 4798 blx r3
if (rc < 0) {
7f8: 2800 cmp r0, #0
7fa: db07 blt.n 80c <usb_d_ep_init+0x38>
return rc;
}
ept->xfer.hdr.ep = ep;
7fc: 4a09 ldr r2, [pc, #36] ; (824 <usb_d_ep_init+0x50>)
7fe: 0164 lsls r4, r4, #5
800: 1913 adds r3, r2, r4
802: 705d strb r5, [r3, #1]
ept->xfer.hdr.type = attr & USB_EP_XTYPE_MASK;
804: 2303 movs r3, #3
806: 401e ands r6, r3
808: 54a6 strb r6, [r4, r2]
return ERR_NONE;
80a: 2000 movs r0, #0
}
80c: bdf8 pop {r3, r4, r5, r6, r7, pc}
return -USB_ERR_REDO;
80e: 2014 movs r0, #20
810: 4240 negs r0, r0
812: e7fb b.n 80c <usb_d_ep_init+0x38>
return -USB_ERR_ALLOC_FAIL;
814: 2015 movs r0, #21
816: 4240 negs r0, r0
818: e7f8 b.n 80c <usb_d_ep_init+0x38>
81a: 46c0 nop ; (mov r8, r8)
81c: 000004d1 .word 0x000004d1
820: 000014ed .word 0x000014ed
824: 20000084 .word 0x20000084
00000828 <usb_d_ep0_init>:
{
828: b510 push {r4, lr}
return usb_d_ep_init(0, USB_EP_XTYPE_CTRL, max_pkt_size);
82a: b282 uxth r2, r0
82c: 2100 movs r1, #0
82e: 2000 movs r0, #0
830: 4b01 ldr r3, [pc, #4] ; (838 <usb_d_ep0_init+0x10>)
832: 4798 blx r3
}
834: bd10 pop {r4, pc}
836: 46c0 nop ; (mov r8, r8)
838: 000007d5 .word 0x000007d5
0000083c <usb_d_ep_deinit>:
void usb_d_ep_deinit(const uint8_t ep)
{
83c: b570 push {r4, r5, r6, lr}
83e: 0005 movs r5, r0
int8_t ep_index = _usb_d_find_ep(ep);
840: 4b06 ldr r3, [pc, #24] ; (85c <usb_d_ep_deinit+0x20>)
842: 4798 blx r3
844: 1e04 subs r4, r0, #0
struct usb_d_ep *ept = &usb_d_inst.ep[ep_index];
if (ep_index < 0) {
846: db07 blt.n 858 <usb_d_ep_deinit+0x1c>
return;
}
_usb_d_dev_ep_deinit(ep);
848: 0028 movs r0, r5
84a: 4b05 ldr r3, [pc, #20] ; (860 <usb_d_ep_deinit+0x24>)
84c: 4798 blx r3
ept->xfer.hdr.ep = 0xFF;
84e: 0164 lsls r4, r4, #5
850: 4b04 ldr r3, [pc, #16] ; (864 <usb_d_ep_deinit+0x28>)
852: 191c adds r4, r3, r4
854: 23ff movs r3, #255 ; 0xff
856: 7063 strb r3, [r4, #1]
}
858: bd70 pop {r4, r5, r6, pc}
85a: 46c0 nop ; (mov r8, r8)
85c: 000004d1 .word 0x000004d1
860: 00001619 .word 0x00001619
864: 20000084 .word 0x20000084
00000868 <usb_d_ep_enable>:
int32_t usb_d_ep_enable(const uint8_t ep)
{
868: b570 push {r4, r5, r6, lr}
86a: 0004 movs r4, r0
int8_t ep_index = _usb_d_find_ep(ep);
86c: 4b0e ldr r3, [pc, #56] ; (8a8 <usb_d_ep_enable+0x40>)
86e: 4798 blx r3
870: 1e05 subs r5, r0, #0
struct usb_d_ep *ept = &usb_d_inst.ep[ep_index];
int32_t rc;
if (ep_index < 0) {
872: db15 blt.n 8a0 <usb_d_ep_enable+0x38>
return -USB_ERR_PARAM;
}
ept->xfer.hdr.state = (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) ? USB_EP_S_X_SETUP : USB_EP_S_IDLE;
874: 0143 lsls r3, r0, #5
876: 4a0d ldr r2, [pc, #52] ; (8ac <usb_d_ep_enable+0x44>)
878: 5c9b ldrb r3, [r3, r2]
87a: 425a negs r2, r3
87c: 4153 adcs r3, r2
87e: 3301 adds r3, #1
880: 0141 lsls r1, r0, #5
882: 4a0a ldr r2, [pc, #40] ; (8ac <usb_d_ep_enable+0x44>)
884: 1852 adds r2, r2, r1
886: 7093 strb r3, [r2, #2]
rc = _usb_d_dev_ep_enable(ep);
888: 0020 movs r0, r4
88a: 4b09 ldr r3, [pc, #36] ; (8b0 <usb_d_ep_enable+0x48>)
88c: 4798 blx r3
if (rc < 0) {
88e: 2800 cmp r0, #0
890: db00 blt.n 894 <usb_d_ep_enable+0x2c>
ept->xfer.hdr.state = USB_EP_S_DISABLED;
}
return rc;
}
892: bd70 pop {r4, r5, r6, pc}
ept->xfer.hdr.state = USB_EP_S_DISABLED;
894: 016d lsls r5, r5, #5
896: 4b05 ldr r3, [pc, #20] ; (8ac <usb_d_ep_enable+0x44>)
898: 195d adds r5, r3, r5
89a: 2300 movs r3, #0
89c: 70ab strb r3, [r5, #2]
89e: e7f8 b.n 892 <usb_d_ep_enable+0x2a>
return -USB_ERR_PARAM;
8a0: 2012 movs r0, #18
8a2: 4240 negs r0, r0
8a4: e7f5 b.n 892 <usb_d_ep_enable+0x2a>
8a6: 46c0 nop ; (mov r8, r8)
8a8: 000004d1 .word 0x000004d1
8ac: 20000084 .word 0x20000084
8b0: 000016e5 .word 0x000016e5
000008b4 <usb_d_ep_transfer>:
}
return usb_d_inst.ep[ep_index].xfer.req;
}
int32_t usb_d_ep_transfer(const struct usb_d_transfer *xfer)
{
8b4: b5f0 push {r4, r5, r6, r7, lr}
8b6: 46d6 mov lr, sl
8b8: 464f mov r7, r9
8ba: 4646 mov r6, r8
8bc: b5c0 push {r6, r7, lr}
8be: b086 sub sp, #24
8c0: 0004 movs r4, r0
int8_t ep_index = _usb_d_find_ep(xfer->ep);
8c2: 7a07 ldrb r7, [r0, #8]
8c4: 0038 movs r0, r7
8c6: 4b40 ldr r3, [pc, #256] ; (9c8 <usb_d_ep_transfer+0x114>)
8c8: 4798 blx r3
8ca: 0005 movs r5, r0
struct usb_d_ep * ept = &usb_d_inst.ep[ep_index];
bool dir = USB_EP_GET_DIR(xfer->ep), zlp = xfer->zlp;
8cc: 7a66 ldrb r6, [r4, #9]
uint32_t len = xfer->size;
8ce: 6863 ldr r3, [r4, #4]
8d0: 4698 mov r8, r3
int32_t rc;
volatile uint8_t state;
volatile hal_atomic_t flags;
if (ep_index < 0) {
8d2: 2800 cmp r0, #0
8d4: da00 bge.n 8d8 <usb_d_ep_transfer+0x24>
8d6: e071 b.n 9bc <usb_d_ep_transfer+0x108>
return -USB_ERR_PARAM;
}
atomic_enter_critical(&flags);
8d8: a804 add r0, sp, #16
8da: 4b3c ldr r3, [pc, #240] ; (9cc <usb_d_ep_transfer+0x118>)
8dc: 4798 blx r3
state = ept->xfer.hdr.state;
8de: 016a lsls r2, r5, #5
8e0: 4b3b ldr r3, [pc, #236] ; (9d0 <usb_d_ep_transfer+0x11c>)
8e2: 189b adds r3, r3, r2
8e4: 789a ldrb r2, [r3, #2]
8e6: 2317 movs r3, #23
8e8: 446b add r3, sp
8ea: 701a strb r2, [r3, #0]
if (state == USB_EP_S_IDLE) {
8ec: 781b ldrb r3, [r3, #0]
8ee: 2b01 cmp r3, #1
8f0: d010 beq.n 914 <usb_d_ep_transfer+0x60>
ept->xfer.hdr.state = USB_EP_S_X_DATA;
atomic_leave_critical(&flags);
} else {
atomic_leave_critical(&flags);
8f2: a804 add r0, sp, #16
8f4: 4b37 ldr r3, [pc, #220] ; (9d4 <usb_d_ep_transfer+0x120>)
8f6: 4798 blx r3
switch (state) {
8f8: 2317 movs r3, #23
8fa: 446b add r3, sp
8fc: 781b ldrb r3, [r3, #0]
8fe: b2db uxtb r3, r3
900: 2b05 cmp r3, #5
902: d05e beq.n 9c2 <usb_d_ep_transfer+0x10e>
904: 2b06 cmp r3, #6
906: d023 beq.n 950 <usb_d_ep_transfer+0x9c>
case USB_EP_S_ERROR:
return -USB_ERROR;
case USB_EP_S_DISABLED:
return -USB_ERR_FUNC;
default: /* USB_EP_S_X_xxxx */
return USB_BUSY;
908: 2001 movs r0, #1
switch (state) {
90a: 2b00 cmp r3, #0
90c: d13c bne.n 988 <usb_d_ep_transfer+0xd4>
return -USB_ERR_FUNC;
90e: 2013 movs r0, #19
910: 4240 negs r0, r0
912: e039 b.n 988 <usb_d_ep_transfer+0xd4>
ept->xfer.hdr.state = USB_EP_S_X_DATA;
914: 4b2e ldr r3, [pc, #184] ; (9d0 <usb_d_ep_transfer+0x11c>)
916: 4699 mov r9, r3
918: 016b lsls r3, r5, #5
91a: 469a mov sl, r3
91c: 464b mov r3, r9
91e: 4453 add r3, sl
920: 2203 movs r2, #3
922: 709a strb r2, [r3, #2]
atomic_leave_critical(&flags);
924: a804 add r0, sp, #16
926: 4b2b ldr r3, [pc, #172] ; (9d4 <usb_d_ep_transfer+0x120>)
928: 4798 blx r3
}
}
if (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) {
92a: 464b mov r3, r9
92c: 4652 mov r2, sl
92e: 5cd3 ldrb r3, [r2, r3]
930: 2b00 cmp r3, #0
932: d010 beq.n 956 <usb_d_ep_transfer+0xa2>
zlp = false;
}
}
}
rc = _usb_d_trans(xfer->ep, dir, xfer->buf, len, zlp);
934: 7a23 ldrb r3, [r4, #8]
bool dir = USB_EP_GET_DIR(xfer->ep), zlp = xfer->zlp;
936: 1e72 subs r2, r6, #1
938: 4196 sbcs r6, r2
rc = _usb_d_trans(xfer->ep, dir, xfer->buf, len, zlp);
93a: b2f6 uxtb r6, r6
struct usb_d_transfer trans
93c: 6822 ldr r2, [r4, #0]
93e: 9201 str r2, [sp, #4]
940: 4642 mov r2, r8
942: 9202 str r2, [sp, #8]
944: b27f sxtb r7, r7
946: 2f00 cmp r7, #0
948: db17 blt.n 97a <usb_d_ep_transfer+0xc6>
94a: 220f movs r2, #15
94c: 4013 ands r3, r2
94e: e016 b.n 97e <usb_d_ep_transfer+0xca>
return -USB_ERROR;
950: 2010 movs r0, #16
952: 4240 negs r0, r0
954: e018 b.n 988 <usb_d_ep_transfer+0xd4>
uint16_t req_len = USB_GET_wLength(ept->xfer.req);
956: 016b lsls r3, r5, #5
958: 4a1d ldr r2, [pc, #116] ; (9d0 <usb_d_ep_transfer+0x11c>)
95a: 18d2 adds r2, r2, r3
95c: 7cd1 ldrb r1, [r2, #19]
95e: 0209 lsls r1, r1, #8
960: 7c93 ldrb r3, [r2, #18]
962: 185b adds r3, r3, r1
964: b29b uxth r3, r3
if (req_len == 0) {
966: 2b00 cmp r3, #0
968: d114 bne.n 994 <usb_d_ep_transfer+0xe0>
ept->xfer.hdr.state = USB_EP_S_X_STATUS;
96a: 2304 movs r3, #4
96c: 7093 strb r3, [r2, #2]
len = 0;
96e: 2200 movs r2, #0
zlp = true;
970: 2601 movs r6, #1
rc = _usb_d_trans(xfer->ep, dir, xfer->buf, len, zlp);
972: 7a23 ldrb r3, [r4, #8]
struct usb_d_transfer trans
974: 6821 ldr r1, [r4, #0]
976: 9101 str r1, [sp, #4]
978: 9202 str r2, [sp, #8]
97a: 2280 movs r2, #128 ; 0x80
97c: 4313 orrs r3, r2
97e: a801 add r0, sp, #4
980: 7203 strb r3, [r0, #8]
982: 7246 strb r6, [r0, #9]
return _usb_d_dev_ep_trans(&trans);
984: 4b14 ldr r3, [pc, #80] ; (9d8 <usb_d_ep_transfer+0x124>)
986: 4798 blx r3
return rc;
}
988: b006 add sp, #24
98a: bc1c pop {r2, r3, r4}
98c: 4690 mov r8, r2
98e: 4699 mov r9, r3
990: 46a2 mov sl, r4
992: bdf0 pop {r4, r5, r6, r7, pc}
994: 4642 mov r2, r8
996: 429a cmp r2, r3
998: d900 bls.n 99c <usb_d_ep_transfer+0xe8>
99a: 001a movs r2, r3
dir = (USB_GET_bmRequestType(ept->xfer.req) & USB_REQ_TYPE_IN);
99c: 016d lsls r5, r5, #5
99e: 490c ldr r1, [pc, #48] ; (9d0 <usb_d_ep_transfer+0x11c>)
9a0: 194d adds r5, r1, r5
if (dir) {
9a2: 7b29 ldrb r1, [r5, #12]
9a4: 297f cmp r1, #127 ; 0x7f
9a6: d805 bhi.n 9b4 <usb_d_ep_transfer+0x100>
rc = _usb_d_trans(xfer->ep, dir, xfer->buf, len, zlp);
9a8: 7a23 ldrb r3, [r4, #8]
struct usb_d_transfer trans
9aa: 6821 ldr r1, [r4, #0]
9ac: 9101 str r1, [sp, #4]
9ae: 9202 str r2, [sp, #8]
rc = _usb_d_trans(xfer->ep, dir, xfer->buf, len, zlp);
9b0: 2600 movs r6, #0
9b2: e7ca b.n 94a <usb_d_ep_transfer+0x96>
zlp = (req_len > len);
9b4: 429a cmp r2, r3
9b6: 41b6 sbcs r6, r6
9b8: 4276 negs r6, r6
9ba: e7da b.n 972 <usb_d_ep_transfer+0xbe>
return -USB_ERR_PARAM;
9bc: 2012 movs r0, #18
9be: 4240 negs r0, r0
9c0: e7e2 b.n 988 <usb_d_ep_transfer+0xd4>
return USB_HALTED;
9c2: 2002 movs r0, #2
9c4: e7e0 b.n 988 <usb_d_ep_transfer+0xd4>
9c6: 46c0 nop ; (mov r8, r8)
9c8: 000004d1 .word 0x000004d1
9cc: 00000385 .word 0x00000385
9d0: 20000084 .word 0x20000084
9d4: 00000393 .word 0x00000393
9d8: 00001b95 .word 0x00001b95
000009dc <usb_d_ep_halt>:
}
return ERR_NONE;
}
int32_t usb_d_ep_halt(const uint8_t ep, const enum usb_ep_halt_ctrl ctrl)
{
9dc: b570 push {r4, r5, r6, lr}
9de: 0004 movs r4, r0
if (ctrl == USB_EP_HALT_CLR) {
9e0: 2900 cmp r1, #0
9e2: d005 beq.n 9f0 <usb_d_ep_halt+0x14>
return _usb_d_ep_halt_clr(ep);
} else if (ctrl == USB_EP_HALT_SET) {
9e4: 2901 cmp r1, #1
9e6: d021 beq.n a2c <usb_d_ep_halt+0x50>
return _usb_d_dev_ep_stall(ep, USB_EP_STALL_SET);
} else {
return _usb_d_dev_ep_stall(ep, USB_EP_STALL_GET);
9e8: 2102 movs r1, #2
9ea: 4b13 ldr r3, [pc, #76] ; (a38 <usb_d_ep_halt+0x5c>)
9ec: 4798 blx r3
}
}
9ee: bd70 pop {r4, r5, r6, pc}
int8_t ep_index = _usb_d_find_ep(ep);
9f0: 4b12 ldr r3, [pc, #72] ; (a3c <usb_d_ep_halt+0x60>)
9f2: 4798 blx r3
9f4: 1e05 subs r5, r0, #0
if (ep_index < 0) {
9f6: db1c blt.n a32 <usb_d_ep_halt+0x56>
if (_usb_d_dev_ep_stall(ep, USB_EP_STALL_GET)) {
9f8: 2102 movs r1, #2
9fa: 0020 movs r0, r4
9fc: 4b0e ldr r3, [pc, #56] ; (a38 <usb_d_ep_halt+0x5c>)
9fe: 4798 blx r3
a00: 2800 cmp r0, #0
a02: d0f4 beq.n 9ee <usb_d_ep_halt+0x12>
rc = _usb_d_dev_ep_stall(ep, USB_EP_STALL_CLR);
a04: 2100 movs r1, #0
a06: 0020 movs r0, r4
a08: 4b0b ldr r3, [pc, #44] ; (a38 <usb_d_ep_halt+0x5c>)
a0a: 4798 blx r3
if (rc < 0) {
a0c: 2800 cmp r0, #0
a0e: dbee blt.n 9ee <usb_d_ep_halt+0x12>
ept->xfer.hdr.state = USB_EP_S_IDLE;
a10: 016d lsls r5, r5, #5
a12: 4b0b ldr r3, [pc, #44] ; (a40 <usb_d_ep_halt+0x64>)
a14: 195d adds r5, r3, r5
a16: 2301 movs r3, #1
a18: 70ab strb r3, [r5, #2]
ept->xfer.hdr.status = USB_XFER_UNHALT;
a1a: 3302 adds r3, #2
a1c: 70eb strb r3, [r5, #3]
ept->callbacks.xfer(ep, USB_XFER_UNHALT, NULL);
a1e: 69eb ldr r3, [r5, #28]
a20: 2200 movs r2, #0
a22: 2103 movs r1, #3
a24: 0020 movs r0, r4
a26: 4798 blx r3
return ERR_NONE;
a28: 2000 movs r0, #0
a2a: e7e0 b.n 9ee <usb_d_ep_halt+0x12>
return _usb_d_dev_ep_stall(ep, USB_EP_STALL_SET);
a2c: 4b02 ldr r3, [pc, #8] ; (a38 <usb_d_ep_halt+0x5c>)
a2e: 4798 blx r3
a30: e7dd b.n 9ee <usb_d_ep_halt+0x12>
return -USB_ERR_PARAM;
a32: 2012 movs r0, #18
a34: 4240 negs r0, r0
a36: e7da b.n 9ee <usb_d_ep_halt+0x12>
a38: 000019c1 .word 0x000019c1
a3c: 000004d1 .word 0x000004d1
a40: 20000084 .word 0x20000084
00000a44 <usb_d_ep_register_callback>:
void usb_d_ep_register_callback(const uint8_t ep, const enum usb_d_ep_cb_type type, const FUNC_PTR func)
{
a44: b570 push {r4, r5, r6, lr}
a46: 000d movs r5, r1
a48: 0014 movs r4, r2
int8_t ep_index = _usb_d_find_ep(ep);
a4a: 4b0f ldr r3, [pc, #60] ; (a88 <usb_d_ep_register_callback+0x44>)
a4c: 4798 blx r3
a4e: 0003 movs r3, r0
struct usb_d_ep *ept = &usb_d_inst.ep[ep_index];
FUNC_PTR f = func ? (FUNC_PTR)func : (FUNC_PTR)usb_d_dummy_cb_false;
a50: 1e22 subs r2, r4, #0
a52: d008 beq.n a66 <usb_d_ep_register_callback+0x22>
if (ep_index < 0) {
a54: 2b00 cmp r3, #0
a56: db05 blt.n a64 <usb_d_ep_register_callback+0x20>
return;
}
switch (type) {
a58: 2d01 cmp r5, #1
a5a: d00b beq.n a74 <usb_d_ep_register_callback+0x30>
a5c: 2d00 cmp r5, #0
a5e: d004 beq.n a6a <usb_d_ep_register_callback+0x26>
a60: 2d02 cmp r5, #2
a62: d00c beq.n a7e <usb_d_ep_register_callback+0x3a>
ept->callbacks.xfer = (usb_d_ep_cb_xfer_t)f;
break;
default:
break;
}
}
a64: bd70 pop {r4, r5, r6, pc}
FUNC_PTR f = func ? (FUNC_PTR)func : (FUNC_PTR)usb_d_dummy_cb_false;
a66: 4a09 ldr r2, [pc, #36] ; (a8c <usb_d_ep_register_callback+0x48>)
a68: e7f4 b.n a54 <usb_d_ep_register_callback+0x10>
ept->callbacks.req = (usb_d_ep_cb_setup_t)f;
a6a: 0140 lsls r0, r0, #5
a6c: 4b08 ldr r3, [pc, #32] ; (a90 <usb_d_ep_register_callback+0x4c>)
a6e: 1818 adds r0, r3, r0
a70: 6142 str r2, [r0, #20]
break;
a72: e7f7 b.n a64 <usb_d_ep_register_callback+0x20>
ept->callbacks.more = (usb_d_ep_cb_more_t)f;
a74: 0140 lsls r0, r0, #5
a76: 4b06 ldr r3, [pc, #24] ; (a90 <usb_d_ep_register_callback+0x4c>)
a78: 1818 adds r0, r3, r0
a7a: 6182 str r2, [r0, #24]
break;
a7c: e7f2 b.n a64 <usb_d_ep_register_callback+0x20>
ept->callbacks.xfer = (usb_d_ep_cb_xfer_t)f;
a7e: 0140 lsls r0, r0, #5
a80: 4b03 ldr r3, [pc, #12] ; (a90 <usb_d_ep_register_callback+0x4c>)
a82: 1818 adds r0, r3, r0
a84: 61c2 str r2, [r0, #28]
break;
a86: e7ed b.n a64 <usb_d_ep_register_callback+0x20>
a88: 000004d1 .word 0x000004d1
a8c: 00000515 .word 0x00000515
a90: 20000084 .word 0x20000084
00000a94 <assert>:
/**
* \brief Assert function
*/
void assert(const bool condition, const char *const file, const int line)
{
if (!(condition)) {
a94: 2800 cmp r0, #0
a96: d100 bne.n a9a <assert+0x6>
__asm("BKPT #0");
a98: be00 bkpt 0x0000
}
(void)file;
(void)line;
}
a9a: 4770 bx lr
00000a9c <is_list_element>:
* \brief Check whether element belongs to list
*/
bool is_list_element(const struct list_descriptor *const list, const void *const element)
{
struct list_element *it;
for (it = list->head; it; it = it->next) {
a9c: 6803 ldr r3, [r0, #0]
a9e: 2b00 cmp r3, #0
aa0: d00a beq.n ab8 <is_list_element+0x1c>
if (it == element) {
aa2: 428b cmp r3, r1
aa4: d00a beq.n abc <is_list_element+0x20>
for (it = list->head; it; it = it->next) {
aa6: 681b ldr r3, [r3, #0]
aa8: 2b00 cmp r3, #0
aaa: d003 beq.n ab4 <is_list_element+0x18>
if (it == element) {
aac: 4299 cmp r1, r3
aae: d1fa bne.n aa6 <is_list_element+0xa>
return true;
ab0: 2001 movs r0, #1
ab2: e000 b.n ab6 <is_list_element+0x1a>
}
}
return false;
ab4: 2000 movs r0, #0
}
ab6: 4770 bx lr
return false;
ab8: 2000 movs r0, #0
aba: e7fc b.n ab6 <is_list_element+0x1a>
return true;
abc: 2001 movs r0, #1
abe: e7fa b.n ab6 <is_list_element+0x1a>
00000ac0 <list_insert_at_end>:
/**
* \brief Insert an element at list end
*/
void list_insert_at_end(struct list_descriptor *const list, void *const element)
{
ac0: b570 push {r4, r5, r6, lr}
ac2: 0005 movs r5, r0
ac4: 000e movs r6, r1
struct list_element *it = list->head;
ac6: 6804 ldr r4, [r0, #0]
ASSERT(!is_list_element(list, element));
ac8: 4b0a ldr r3, [pc, #40] ; (af4 <list_insert_at_end+0x34>)
aca: 4798 blx r3
acc: 2301 movs r3, #1
ace: 4058 eors r0, r3
ad0: b2c0 uxtb r0, r0
ad2: 224f movs r2, #79 ; 0x4f
ad4: 4908 ldr r1, [pc, #32] ; (af8 <list_insert_at_end+0x38>)
ad6: 4b09 ldr r3, [pc, #36] ; (afc <list_insert_at_end+0x3c>)
ad8: 4798 blx r3
if (!list->head) {
ada: 682b ldr r3, [r5, #0]
adc: 2b00 cmp r3, #0
ade: d103 bne.n ae8 <list_insert_at_end+0x28>
list->head = (struct list_element *)element;
ae0: 602e str r6, [r5, #0]
((struct list_element *)element)->next = NULL;
ae2: 6033 str r3, [r6, #0]
return;
ae4: e005 b.n af2 <list_insert_at_end+0x32>
}
while (it->next) {
it = it->next;
ae6: 001c movs r4, r3
while (it->next) {
ae8: 6823 ldr r3, [r4, #0]
aea: 2b00 cmp r3, #0
aec: d1fb bne.n ae6 <list_insert_at_end+0x26>
}
it->next = (struct list_element *)element;
aee: 6026 str r6, [r4, #0]
((struct list_element *)element)->next = NULL;
af0: 6033 str r3, [r6, #0]
}
af2: bd70 pop {r4, r5, r6, pc}
af4: 00000a9d .word 0x00000a9d
af8: 00002c18 .word 0x00002c18
afc: 00000a95 .word 0x00000a95
00000b00 <_init_chip>:
/**
* \brief Initialize the hardware abstraction layer
*/
void _init_chip(void)
{
b00: b510 push {r4, lr}
}
static inline void hri_nvmctrl_set_CTRLB_RWS_bf(const void *const hw, hri_nvmctrl_ctrlb_reg_t mask)
{
NVMCTRL_CRITICAL_SECTION_ENTER();
((Nvmctrl *)hw)->CTRLB.reg |= NVMCTRL_CTRLB_RWS(mask);
b02: 4a08 ldr r2, [pc, #32] ; (b24 <_init_chip+0x24>)
b04: 6853 ldr r3, [r2, #4]
b06: 2104 movs r1, #4
b08: 430b orrs r3, r1
b0a: 6053 str r3, [r2, #4]
hri_nvmctrl_set_CTRLB_RWS_bf(NVMCTRL, CONF_NVM_WAIT_STATE);
_pm_init();
b0c: 4b06 ldr r3, [pc, #24] ; (b28 <_init_chip+0x28>)
b0e: 4798 blx r3
_sysctrl_init_sources();
b10: 4b06 ldr r3, [pc, #24] ; (b2c <_init_chip+0x2c>)
b12: 4798 blx r3
#if _GCLK_INIT_1ST
_gclk_init_generators_by_fref(_GCLK_INIT_1ST);
b14: 2002 movs r0, #2
b16: 4c06 ldr r4, [pc, #24] ; (b30 <_init_chip+0x30>)
b18: 47a0 blx r4
#endif
_sysctrl_init_referenced_generators();
b1a: 4b06 ldr r3, [pc, #24] ; (b34 <_init_chip+0x34>)
b1c: 4798 blx r3
_gclk_init_generators_by_fref(_GCLK_INIT_LAST);
b1e: 20fd movs r0, #253 ; 0xfd
b20: 47a0 blx r4
#if CONF_DMAC_ENABLE
_pm_enable_bus_clock(PM_BUS_AHB, DMAC);
_pm_enable_bus_clock(PM_BUS_APBB, DMAC);
_dma_init();
#endif
}
b22: bd10 pop {r4, pc}
b24: 41004000 .word 0x41004000
b28: 00000b79 .word 0x00000b79
b2c: 00000c91 .word 0x00000c91
b30: 00000b39 .word 0x00000b39
b34: 00000cb9 .word 0x00000cb9
00000b38 <_gclk_init_generators_by_fref>:
void _gclk_init_generators_by_fref(uint32_t bm)
{
#if CONF_GCLK_GENERATOR_0_CONFIG == 1
if (bm & (1ul << 0)) {
b38: 07c3 lsls r3, r0, #31
b3a: d509 bpl.n b50 <_gclk_init_generators_by_fref+0x18>
}
static inline void hri_gclk_write_GENDIV_reg(const void *const hw, hri_gclk_gendiv_reg_t data)
{
GCLK_CRITICAL_SECTION_ENTER();
((Gclk *)hw)->GENDIV.reg = data;
b3c: 4b0b ldr r3, [pc, #44] ; (b6c <_gclk_init_generators_by_fref+0x34>)
b3e: 2280 movs r2, #128 ; 0x80
b40: 0052 lsls r2, r2, #1
b42: 609a str r2, [r3, #8]
((Gclk *)hw)->GENCTRL.reg = data;
b44: 4a0a ldr r2, [pc, #40] ; (b70 <_gclk_init_generators_by_fref+0x38>)
b46: 605a str r2, [r3, #4]
while (((const Gclk *)hw)->STATUS.bit.SYNCBUSY)
b48: 001a movs r2, r3
b4a: 7853 ldrb r3, [r2, #1]
b4c: 09db lsrs r3, r3, #7
b4e: d1fc bne.n b4a <_gclk_init_generators_by_fref+0x12>
| (CONF_GCLK_GENERATOR_0_CONFIG << GCLK_GENCTRL_GENEN_Pos) | CONF_GCLK_GEN_0_SRC | GCLK_GENCTRL_ID(0));
}
#endif
#if CONF_GCLK_GENERATOR_1_CONFIG == 1
if (bm & (1ul << 1)) {
b50: 0783 lsls r3, r0, #30
b52: d509 bpl.n b68 <_gclk_init_generators_by_fref+0x30>
((Gclk *)hw)->GENDIV.reg = data;
b54: 4b05 ldr r3, [pc, #20] ; (b6c <_gclk_init_generators_by_fref+0x34>)
b56: 2202 movs r2, #2
b58: 32ff adds r2, #255 ; 0xff
b5a: 609a str r2, [r3, #8]
((Gclk *)hw)->GENCTRL.reg = data;
b5c: 4a05 ldr r2, [pc, #20] ; (b74 <_gclk_init_generators_by_fref+0x3c>)
b5e: 605a str r2, [r3, #4]
while (((const Gclk *)hw)->STATUS.bit.SYNCBUSY)
b60: 001a movs r2, r3
b62: 7853 ldrb r3, [r2, #1]
b64: 09db lsrs r3, r3, #7
b66: d1fc bne.n b62 <_gclk_init_generators_by_fref+0x2a>
| (CONF_GCLK_GEN_8_DIVSEL << GCLK_GENCTRL_DIVSEL_Pos) | (CONF_GCLK_GEN_8_OE << GCLK_GENCTRL_OE_Pos)
| (CONF_GCLK_GEN_8_OOV << GCLK_GENCTRL_OOV_Pos) | (CONF_GCLK_GEN_8_IDC << GCLK_GENCTRL_IDC_Pos)
| (CONF_GCLK_GENERATOR_8_CONFIG << GCLK_GENCTRL_GENEN_Pos) | CONF_GCLK_GEN_8_SRC | GCLK_GENCTRL_ID(8));
}
#endif
}
b68: 4770 bx lr
b6a: 46c0 nop ; (mov r8, r8)
b6c: 40000c00 .word 0x40000c00
b70: 00010700 .word 0x00010700
b74: 00010501 .word 0x00010501
00000b78 <_pm_init>:
}
static inline void hri_pm_set_CPUSEL_CPUDIV_bf(const void *const hw, hri_pm_cpusel_reg_t mask)
{
PM_CRITICAL_SECTION_ENTER();
((Pm *)hw)->CPUSEL.reg |= PM_CPUSEL_CPUDIV(mask);
b78: 4b06 ldr r3, [pc, #24] ; (b94 <_pm_init+0x1c>)
b7a: 7a1a ldrb r2, [r3, #8]
b7c: b2d2 uxtb r2, r2
b7e: 721a strb r2, [r3, #8]
}
static inline void hri_pm_set_APBASEL_APBADIV_bf(const void *const hw, hri_pm_apbasel_reg_t mask)
{
PM_CRITICAL_SECTION_ENTER();
((Pm *)hw)->APBASEL.reg |= PM_APBASEL_APBADIV(mask);
b80: 7a5a ldrb r2, [r3, #9]
b82: b2d2 uxtb r2, r2
b84: 725a strb r2, [r3, #9]
}
static inline void hri_pm_set_APBBSEL_APBBDIV_bf(const void *const hw, hri_pm_apbbsel_reg_t mask)
{
PM_CRITICAL_SECTION_ENTER();
((Pm *)hw)->APBBSEL.reg |= PM_APBBSEL_APBBDIV(mask);
b86: 7a9a ldrb r2, [r3, #10]
b88: b2d2 uxtb r2, r2
b8a: 729a strb r2, [r3, #10]
}
static inline void hri_pm_set_APBCSEL_APBCDIV_bf(const void *const hw, hri_pm_apbcsel_reg_t mask)
{
PM_CRITICAL_SECTION_ENTER();
((Pm *)hw)->APBCSEL.reg |= PM_APBCSEL_APBCDIV(mask);
b8c: 7ada ldrb r2, [r3, #11]
b8e: b2d2 uxtb r2, r2
b90: 72da strb r2, [r3, #11]
{
hri_pm_set_CPUSEL_CPUDIV_bf(PM, CONF_CPU_DIV);
hri_pm_set_APBASEL_APBADIV_bf(PM, CONF_APBA_DIV);
hri_pm_set_APBBSEL_APBBDIV_bf(PM, CONF_APBB_DIV);
hri_pm_set_APBCSEL_APBCDIV_bf(PM, CONF_APBC_DIV);
}
b92: 4770 bx lr
b94: 40000400 .word 0x40000400
00000b98 <_usart_init>:
* \param[in] hw The pointer to hardware instance
*
* \return The status of initialization
*/
static int32_t _usart_init(void *const hw)
{
b98: b510 push {r4, lr}
b9a: 0004 movs r4, r0
return ((uint32_t)hw - (uint32_t)SERCOM0) >> 10;
b9c: 4b1f ldr r3, [pc, #124] ; (c1c <_usart_init+0x84>)
b9e: 18c3 adds r3, r0, r3
ba0: 0a9b lsrs r3, r3, #10
if (_usarts[i].number == sercom_offset) {
ba2: b2db uxtb r3, r3
ba4: 2b03 cmp r3, #3
ba6: d004 beq.n bb2 <_usart_init+0x1a>
ASSERT(false);
ba8: 4a1d ldr r2, [pc, #116] ; (c20 <_usart_init+0x88>)
baa: 491e ldr r1, [pc, #120] ; (c24 <_usart_init+0x8c>)
bac: 2000 movs r0, #0
bae: 4b1e ldr r3, [pc, #120] ; (c28 <_usart_init+0x90>)
bb0: 4798 blx r3
};
}
static inline bool hri_sercomusart_is_syncing(const void *const hw, hri_sercomusart_syncbusy_reg_t reg)
{
return ((Sercom *)hw)->USART.SYNCBUSY.reg & reg;
bb2: 69e3 ldr r3, [r4, #28]
uint8_t i = _get_sercom_index(hw);
if (!hri_sercomusart_is_syncing(hw, SERCOM_USART_SYNCBUSY_SWRST)) {
bb4: 07db lsls r3, r3, #31
bb6: d418 bmi.n bea <_usart_init+0x52>
while (((Sercom *)hw)->USART.SYNCBUSY.reg & reg) {
bb8: 2203 movs r2, #3
bba: 69e3 ldr r3, [r4, #28]
bbc: 421a tst r2, r3
bbe: d1fc bne.n bba <_usart_init+0x22>
static inline hri_sercomusart_ctrla_reg_t hri_sercomusart_get_CTRLA_reg(const void *const hw,
hri_sercomusart_ctrla_reg_t mask)
{
uint32_t tmp;
hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_SWRST | SERCOM_USART_SYNCBUSY_ENABLE);
tmp = ((Sercom *)hw)->USART.CTRLA.reg;
bc0: 6823 ldr r3, [r4, #0]
uint32_t mode = _usarts[i].ctrl_a & SERCOM_USART_CTRLA_MODE_Msk;
if (hri_sercomusart_get_CTRLA_reg(hw, SERCOM_USART_CTRLA_ENABLE)) {
bc2: 079b lsls r3, r3, #30
bc4: d50b bpl.n bde <_usart_init+0x46>
((Sercom *)hw)->USART.CTRLA.reg &= ~SERCOM_USART_CTRLA_ENABLE;
bc6: 6823 ldr r3, [r4, #0]
bc8: 2202 movs r2, #2
bca: 4393 bics r3, r2
bcc: 6023 str r3, [r4, #0]
while (((Sercom *)hw)->USART.SYNCBUSY.reg & reg) {
bce: 3201 adds r2, #1
bd0: 69e3 ldr r3, [r4, #28]
bd2: 421a tst r2, r3
bd4: d1fc bne.n bd0 <_usart_init+0x38>
bd6: 2202 movs r2, #2
bd8: 69e3 ldr r3, [r4, #28]
bda: 421a tst r2, r3
bdc: d1fc bne.n bd8 <_usart_init+0x40>
}
static inline void hri_sercomusart_write_CTRLA_reg(const void *const hw, hri_sercomusart_ctrla_reg_t data)
{
SERCOM_CRITICAL_SECTION_ENTER();
((Sercom *)hw)->USART.CTRLA.reg = data;
bde: 2305 movs r3, #5
be0: 6023 str r3, [r4, #0]
while (((Sercom *)hw)->USART.SYNCBUSY.reg & reg) {
be2: 2203 movs r2, #3
be4: 69e3 ldr r3, [r4, #28]
be6: 421a tst r2, r3
be8: d1fc bne.n be4 <_usart_init+0x4c>
bea: 2201 movs r2, #1
bec: 69e3 ldr r3, [r4, #28]
bee: 421a tst r2, r3
bf0: d1fc bne.n bec <_usart_init+0x54>
((Sercom *)hw)->USART.CTRLA.reg = data;
bf2: 4b0e ldr r3, [pc, #56] ; (c2c <_usart_init+0x94>)
bf4: 6023 str r3, [r4, #0]
while (((Sercom *)hw)->USART.SYNCBUSY.reg & reg) {
bf6: 2203 movs r2, #3
bf8: 69e3 ldr r3, [r4, #28]
bfa: 421a tst r2, r3
bfc: d1fc bne.n bf8 <_usart_init+0x60>
}
static inline void hri_sercomusart_write_CTRLB_reg(const void *const hw, hri_sercomusart_ctrlb_reg_t data)
{
SERCOM_CRITICAL_SECTION_ENTER();
((Sercom *)hw)->USART.CTRLB.reg = data;
bfe: 23c0 movs r3, #192 ; 0xc0
c00: 029b lsls r3, r3, #10
c02: 6063 str r3, [r4, #4]
while (((Sercom *)hw)->USART.SYNCBUSY.reg & reg) {
c04: 2207 movs r2, #7
c06: 69e3 ldr r3, [r4, #28]
c08: 421a tst r2, r3
c0a: d1fc bne.n c06 <_usart_init+0x6e>
}
static inline void hri_sercomusart_write_BAUD_reg(const void *const hw, hri_sercomusart_baud_reg_t data)
{
SERCOM_CRITICAL_SECTION_ENTER();
((Sercom *)hw)->USART.BAUD.reg = data;
c0c: 4b08 ldr r3, [pc, #32] ; (c30 <_usart_init+0x98>)
c0e: 81a3 strh r3, [r4, #12]
}
static inline void hri_sercomusart_write_RXPL_reg(const void *const hw, hri_sercomusart_rxpl_reg_t data)
{
SERCOM_CRITICAL_SECTION_ENTER();
((Sercom *)hw)->USART.RXPL.reg = data;
c10: 2300 movs r3, #0
c12: 73a3 strb r3, [r4, #14]
}
static inline void hri_sercomusart_write_DBGCTRL_reg(const void *const hw, hri_sercomusart_dbgctrl_reg_t data)
{
SERCOM_CRITICAL_SECTION_ENTER();
((Sercom *)hw)->USART.DBGCTRL.reg = data;
c14: 2230 movs r2, #48 ; 0x30
c16: 54a3 strb r3, [r4, r2]
hri_sercomusart_write_RXPL_reg(hw, _usarts[i].rxpl);
hri_sercomusart_write_DBGCTRL_reg(hw, _usarts[i].debug_ctrl);
return ERR_NONE;
}
c18: 2000 movs r0, #0
c1a: bd10 pop {r4, pc}
c1c: bdfff800 .word 0xbdfff800
c20: 0000023a .word 0x0000023a
c24: 00002c38 .word 0x00002c38
c28: 00000a95 .word 0x00000a95
c2c: 40100004 .word 0x40100004
c30: fffff62b .word 0xfffff62b
00000c34 <_usart_sync_init>:
{
c34: b570 push {r4, r5, r6, lr}
c36: 0005 movs r5, r0
c38: 000c movs r4, r1
ASSERT(device);
c3a: 1e43 subs r3, r0, #1
c3c: 4198 sbcs r0, r3
c3e: b2c0 uxtb r0, r0
c40: 22b4 movs r2, #180 ; 0xb4
c42: 4904 ldr r1, [pc, #16] ; (c54 <_usart_sync_init+0x20>)
c44: 4b04 ldr r3, [pc, #16] ; (c58 <_usart_sync_init+0x24>)
c46: 4798 blx r3
device->hw = hw;
c48: 602c str r4, [r5, #0]
return _usart_init(hw);
c4a: 0020 movs r0, r4
c4c: 4b03 ldr r3, [pc, #12] ; (c5c <_usart_sync_init+0x28>)
c4e: 4798 blx r3
}
c50: bd70 pop {r4, r5, r6, pc}
c52: 46c0 nop ; (mov r8, r8)
c54: 00002c38 .word 0x00002c38
c58: 00000a95 .word 0x00000a95
c5c: 00000b99 .word 0x00000b99
00000c60 <_usart_sync_write_byte>:
hri_sercomusart_write_DATA_reg(device->hw, data);
c60: 6803 ldr r3, [r0, #0]
c62: b289 uxth r1, r1
((Sercom *)hw)->USART.DATA.reg = data;
c64: 8519 strh r1, [r3, #40] ; 0x28
}
c66: 4770 bx lr
00000c68 <_usart_sync_read_byte>:
return hri_sercomusart_read_DATA_reg(device->hw);
c68: 6803 ldr r3, [r0, #0]
return ((Sercom *)hw)->USART.DATA.reg;
c6a: 8d18 ldrh r0, [r3, #40] ; 0x28
c6c: b2c0 uxtb r0, r0
}
c6e: 4770 bx lr
00000c70 <_usart_sync_is_ready_to_send>:
return hri_sercomusart_get_interrupt_DRE_bit(device->hw);
c70: 6803 ldr r3, [r0, #0]
return (((Sercom *)hw)->USART.INTFLAG.reg & SERCOM_USART_INTFLAG_DRE) >> SERCOM_USART_INTFLAG_DRE_Pos;
c72: 7e18 ldrb r0, [r3, #24]
c74: 2301 movs r3, #1
c76: 4018 ands r0, r3
}
c78: 4770 bx lr
00000c7a <_usart_sync_is_transmit_done>:
return hri_sercomusart_get_interrupt_TXC_bit(device->hw);
c7a: 6803 ldr r3, [r0, #0]
return (((Sercom *)hw)->USART.INTFLAG.reg & SERCOM_USART_INTFLAG_TXC) >> SERCOM_USART_INTFLAG_TXC_Pos;
c7c: 7e18 ldrb r0, [r3, #24]
c7e: 0780 lsls r0, r0, #30
c80: 0fc0 lsrs r0, r0, #31
}
c82: 4770 bx lr
00000c84 <_usart_sync_is_byte_received>:
return hri_sercomusart_get_interrupt_RXC_bit(device->hw);
c84: 6803 ldr r3, [r0, #0]
return (((Sercom *)hw)->USART.INTFLAG.reg & SERCOM_USART_INTFLAG_RXC) >> SERCOM_USART_INTFLAG_RXC_Pos;
c86: 7e18 ldrb r0, [r3, #24]
c88: 0740 lsls r0, r0, #29
c8a: 0fc0 lsrs r0, r0, #31
}
c8c: 4770 bx lr
...
00000c90 <_sysctrl_init_sources>:
}
static inline void hri_sysctrl_write_XOSC32K_reg(const void *const hw, hri_sysctrl_xosc32k_reg_t data)
{
SYSCTRL_CRITICAL_SECTION_ENTER();
((Sysctrl *)hw)->XOSC32K.reg = data;
c90: 4b08 ldr r3, [pc, #32] ; (cb4 <_sysctrl_init_sources+0x24>)
c92: 220e movs r2, #14
c94: 829a strh r2, [r3, #20]
}
static inline void hri_sysctrl_set_OSC32K_ENABLE_bit(const void *const hw)
{
SYSCTRL_CRITICAL_SECTION_ENTER();
((Sysctrl *)hw)->OSC32K.reg |= SYSCTRL_OSC32K_ENABLE;
c96: 699a ldr r2, [r3, #24]
c98: 2102 movs r1, #2
c9a: 430a orrs r2, r1
c9c: 619a str r2, [r3, #24]
}
static inline hri_sysctrl_osculp32k_reg_t hri_sysctrl_read_OSCULP32K_CALIB_bf(const void *const hw)
{
uint8_t tmp;
tmp = ((Sysctrl *)hw)->OSCULP32K.reg;
c9e: 7f1a ldrb r2, [r3, #28]
tmp = (tmp & SYSCTRL_OSCULP32K_CALIB_Msk) >> SYSCTRL_OSCULP32K_CALIB_Pos;
ca0: 311d adds r1, #29
ca2: 400a ands r2, r1
}
static inline void hri_sysctrl_write_OSCULP32K_reg(const void *const hw, hri_sysctrl_osculp32k_reg_t data)
{
SYSCTRL_CRITICAL_SECTION_ENTER();
((Sysctrl *)hw)->OSCULP32K.reg = data;
ca4: 771a strb r2, [r3, #28]
return (((Sysctrl *)hw)->PCLKSR.reg & SYSCTRL_PCLKSR_XOSC32KRDY) >> SYSCTRL_PCLKSR_XOSC32KRDY_Pos;
ca6: 0019 movs r1, r3
(CONF_OSC32K_WRTLOCK << SYSCTRL_OSCULP32K_WRTLOCK_Pos));
#endif
#if CONF_XOSC32K_CONFIG == 1
#if CONF_XOSC32K_ENABLE == 1
while (!hri_sysctrl_get_PCLKSR_XOSC32KRDY_bit(hw))
ca8: 2202 movs r2, #2
caa: 68cb ldr r3, [r1, #12]
cac: 421a tst r2, r3
cae: d0fc beq.n caa <_sysctrl_init_sources+0x1a>
hri_sysctrl_set_OSC8M_ONDEMAND_bit(hw);
#endif
#endif
(void)calib, (void)hw;
}
cb0: 4770 bx lr
cb2: 46c0 nop ; (mov r8, r8)
cb4: 40000800 .word 0x40000800
00000cb8 <_sysctrl_init_referenced_generators>:
((Gclk *)hw)->CLKCTRL.reg = data;
cb8: 2282 movs r2, #130 ; 0x82
cba: 01d2 lsls r2, r2, #7
cbc: 4b17 ldr r3, [pc, #92] ; (d1c <_sysctrl_init_referenced_generators+0x64>)
cbe: 805a strh r2, [r3, #2]
}
static inline void hri_sysctrl_write_DFLLCTRL_reg(const void *const hw, hri_sysctrl_dfllctrl_reg_t data)
{
SYSCTRL_CRITICAL_SECTION_ENTER();
((Sysctrl *)hw)->DFLLCTRL.reg = data;
cc0: 2202 movs r2, #2
cc2: 4b17 ldr r3, [pc, #92] ; (d20 <_sysctrl_init_referenced_generators+0x68>)
cc4: 849a strh r2, [r3, #36] ; 0x24
return (((Sysctrl *)hw)->PCLKSR.reg & SYSCTRL_PCLKSR_DFLLRDY) >> SYSCTRL_PCLKSR_DFLLRDY_Pos;
cc6: 0019 movs r1, r3
hri_gclk_write_CLKCTRL_reg(GCLK,
GCLK_CLKCTRL_ID(0) | GCLK_CLKCTRL_GEN(CONF_DFLL_GCLK) | (1 << GCLK_CLKCTRL_CLKEN_Pos));
#endif
hri_sysctrl_write_DFLLCTRL_reg(hw, SYSCTRL_DFLLCTRL_ENABLE);
while (!hri_sysctrl_get_PCLKSR_DFLLRDY_bit(hw))
cc8: 320e adds r2, #14
cca: 68cb ldr r3, [r1, #12]
ccc: 421a tst r2, r3
cce: d0fc beq.n cca <_sysctrl_init_referenced_generators+0x12>
}
static inline void hri_sysctrl_write_DFLLMUL_reg(const void *const hw, hri_sysctrl_dfllmul_reg_t data)
{
SYSCTRL_CRITICAL_SECTION_ENTER();
((Sysctrl *)hw)->DFLLMUL.reg = data;
cd0: 4b13 ldr r3, [pc, #76] ; (d20 <_sysctrl_init_referenced_generators+0x68>)
cd2: 4a14 ldr r2, [pc, #80] ; (d24 <_sysctrl_init_referenced_generators+0x6c>)
cd4: 62da str r2, [r3, #44] ; 0x2c
((Sysctrl *)hw)->DFLLVAL.reg = data;
cd6: 22fc movs r2, #252 ; 0xfc
cd8: 01d2 lsls r2, r2, #7
cda: 629a str r2, [r3, #40] ; 0x28
((Sysctrl *)hw)->DFLLCTRL.reg = data;
cdc: 4a12 ldr r2, [pc, #72] ; (d28 <_sysctrl_init_referenced_generators+0x70>)
cde: 849a strh r2, [r3, #36] ; 0x24
tmp = ((Sysctrl *)hw)->DFLLCTRL.reg;
ce0: 8c9b ldrh r3, [r3, #36] ; 0x24
| SYSCTRL_DPLLCTRLB_FILTER(CONF_DPLL_FILTER));
#endif
#if CONF_DFLL_CONFIG == 1
#if CONF_DFLL_ENABLE == 1
if (hri_sysctrl_get_DFLLCTRL_MODE_bit(hw)) {
ce2: 075b lsls r3, r3, #29
ce4: d514 bpl.n d10 <_sysctrl_init_referenced_generators+0x58>
tmp = ((Sysctrl *)hw)->PCLKSR.reg;
ce6: 490e ldr r1, [pc, #56] ; (d20 <_sysctrl_init_referenced_generators+0x68>)
tmp &= mask;
ce8: 22d0 movs r2, #208 ; 0xd0
tmp = ((Sysctrl *)hw)->PCLKSR.reg;
cea: 68cb ldr r3, [r1, #12]
tmp &= mask;
cec: 4013 ands r3, r2
= SYSCTRL_PCLKSR_DFLLRDY | SYSCTRL_PCLKSR_DFLLLCKF | SYSCTRL_PCLKSR_DFLLLCKC;
#else
hri_sysctrl_pclksr_reg_t status_mask = SYSCTRL_PCLKSR_DFLLRDY;
#endif
while (hri_sysctrl_get_PCLKSR_reg(hw, status_mask) != status_mask)
cee: 2bd0 cmp r3, #208 ; 0xd0
cf0: d1fb bne.n cea <_sysctrl_init_referenced_generators+0x32>
((Sysctrl *)hw)->DFLLCTRL.reg |= SYSCTRL_DFLLCTRL_ONDEMAND;
cf2: 4a0b ldr r2, [pc, #44] ; (d20 <_sysctrl_init_referenced_generators+0x68>)
cf4: 8c93 ldrh r3, [r2, #36] ; 0x24
cf6: 2180 movs r1, #128 ; 0x80
cf8: 430b orrs r3, r1
cfa: 8493 strh r3, [r2, #36] ; 0x24
return (((Gclk *)hw)->STATUS.reg & GCLK_STATUS_SYNCBUSY) >> GCLK_STATUS_SYNCBUSY_Pos;
cfc: 4a07 ldr r2, [pc, #28] ; (d1c <_sysctrl_init_referenced_generators+0x64>)
cfe: 7853 ldrb r3, [r2, #1]
hri_sysctrl_set_DPLLCTRLA_ONDEMAND_bit(hw);
#endif
#endif
#if CONF_DFLL_CONFIG == 1
while (hri_gclk_get_STATUS_SYNCBUSY_bit(GCLK))
d00: 09db lsrs r3, r3, #7
d02: d1fc bne.n cfe <_sysctrl_init_referenced_generators+0x46>
((Sysctrl *)hw)->OSC32K.reg &= ~SYSCTRL_OSC32K_ENABLE;
d04: 4a06 ldr r2, [pc, #24] ; (d20 <_sysctrl_init_referenced_generators+0x68>)
d06: 6993 ldr r3, [r2, #24]
d08: 2102 movs r1, #2
d0a: 438b bics r3, r1
d0c: 6193 str r3, [r2, #24]
/* Disable after all possible configurations needs sync written. */
hri_sysctrl_clear_OSC32K_ENABLE_bit(hw);
#endif
(void)hw;
}
d0e: 4770 bx lr
return (((Sysctrl *)hw)->PCLKSR.reg & SYSCTRL_PCLKSR_DFLLRDY) >> SYSCTRL_PCLKSR_DFLLRDY_Pos;
d10: 4903 ldr r1, [pc, #12] ; (d20 <_sysctrl_init_referenced_generators+0x68>)
while (!hri_sysctrl_get_PCLKSR_DFLLRDY_bit(hw))
d12: 2210 movs r2, #16
d14: 68cb ldr r3, [r1, #12]
d16: 421a tst r2, r3
d18: d0fc beq.n d14 <_sysctrl_init_referenced_generators+0x5c>
d1a: e7ea b.n cf2 <_sysctrl_init_referenced_generators+0x3a>
d1c: 40000c00 .word 0x40000c00
d20: 40000800 .word 0x40000800
d24: 040105b9 .word 0x040105b9
d28: 00000806 .word 0x00000806
00000d2c <_dummy_func_no_return>:
static bool _dummy_func_no_return(uint32_t unused0, uint32_t unused1)
{
(void)unused0;
(void)unused1;
return false;
}
d2c: 2000 movs r0, #0
d2e: 4770 bx lr
00000d30 <_usb_d_dev_handle_setup>:
/**
* \brief Handles setup received interrupt
* \param[in] ept Pointer to endpoint information.
*/
static void _usb_d_dev_handle_setup(struct _usb_d_dev_ep *ept)
{
d30: b570 push {r4, r5, r6, lr}
uint8_t epn = USB_EP_GET_N(ept->ep);
d32: 7c83 ldrb r3, [r0, #18]
d34: 220f movs r2, #15
d36: 4013 ands r3, r2
bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept);
d38: 7cc1 ldrb r1, [r0, #19]
if (!is_ctrl) {
d3a: 3a08 subs r2, #8
d3c: 400a ands r2, r1
d3e: 2a01 cmp r2, #1
d40: d00b beq.n d5a <_usb_d_dev_handle_setup+0x2a>
}
static inline void hri_usbendpoint_clear_EPINTFLAG_reg(const void *const hw, uint8_t submodule_index,
hri_usbendpoint_epintflag_reg_t mask)
{
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
d42: 015a lsls r2, r3, #5
d44: 4919 ldr r1, [pc, #100] ; (dac <_usb_d_dev_handle_setup+0x7c>)
d46: 468c mov ip, r1
d48: 4462 add r2, ip
d4a: 2110 movs r1, #16
d4c: 71d1 strb r1, [r2, #7]
}
}
static inline void hri_usbendpoint_clear_EPINTEN_RXSTP_bit(const void *const hw, uint8_t submodule_index)
{
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = USB_DEVICE_EPINTENSET_RXSTP;
d4e: 015b lsls r3, r3, #5
d50: 4a17 ldr r2, [pc, #92] ; (db0 <_usb_d_dev_handle_setup+0x80>)
d52: 4694 mov ip, r2
d54: 4463 add r3, ip
d56: 7019 strb r1, [r3, #0]
_usbd_ep_clear_bank_status(epn, 1);
_usbd_ep_int_ack(epn, USB_D_BANK0_INT_FLAGS | USB_D_BANK1_INT_FLAGS);
_usbd_ep_int_dis(epn, USB_D_BANK0_INT_FLAGS | USB_D_BANK1_INT_FLAGS);
/* Invoke callback. */
dev_inst.ep_callbacks.setup(ept->ep);
}
d58: bd70 pop {r4, r5, r6, pc}
if (_usb_d_dev_ep_is_busy(ept)) {
d5a: 064a lsls r2, r1, #25
d5c: d50e bpl.n d7c <_usb_d_dev_handle_setup+0x4c>
ept->flags.bits.is_busy = 0;
d5e: 7cc2 ldrb r2, [r0, #19]
d60: 2140 movs r1, #64 ; 0x40
d62: 438a bics r2, r1
d64: 74c2 strb r2, [r0, #19]
d66: 015a lsls r2, r3, #5
d68: 4c12 ldr r4, [pc, #72] ; (db4 <_usb_d_dev_handle_setup+0x84>)
d6a: 46a4 mov ip, r4
d6c: 4462 add r2, ip
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask;
d6e: 2580 movs r5, #128 ; 0x80
d70: 2482 movs r4, #130 ; 0x82
d72: 0064 lsls r4, r4, #1
d74: 5515 strb r5, [r2, r4]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask;
d76: 2406 movs r4, #6
d78: 34ff adds r4, #255 ; 0xff
d7a: 5511 strb r1, [r2, r4]
ept->flags.bits.is_stalled = 0;
d7c: 7cc2 ldrb r2, [r0, #19]
d7e: 2108 movs r1, #8
d80: 438a bics r2, r1
d82: 74c2 strb r2, [r0, #19]
bank->STATUS_BK.reg = 0;
d84: 490c ldr r1, [pc, #48] ; (db8 <_usb_d_dev_handle_setup+0x88>)
d86: 015a lsls r2, r3, #5
d88: 188c adds r4, r1, r2
d8a: 2500 movs r5, #0
d8c: 72a5 strb r5, [r4, #10]
d8e: 76a5 strb r5, [r4, #26]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
d90: 0013 movs r3, r2
d92: 4c06 ldr r4, [pc, #24] ; (dac <_usb_d_dev_handle_setup+0x7c>)
d94: 46a4 mov ip, r4
d96: 4463 add r3, ip
d98: 246f movs r4, #111 ; 0x6f
d9a: 71dc strb r4, [r3, #7]
}
static inline void hri_usbendpoint_clear_EPINTEN_reg(const void *const hw, uint8_t submodule_index,
hri_usbendpoint_epintenset_reg_t mask)
{
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask;
d9c: 4b04 ldr r3, [pc, #16] ; (db0 <_usb_d_dev_handle_setup+0x80>)
d9e: 469c mov ip, r3
da0: 4462 add r2, ip
da2: 7014 strb r4, [r2, #0]
dev_inst.ep_callbacks.setup(ept->ep);
da4: 7c80 ldrb r0, [r0, #18]
da6: 6e8b ldr r3, [r1, #104] ; 0x68
da8: 4798 blx r3
daa: e7d5 b.n d58 <_usb_d_dev_handle_setup+0x28>
dac: 41005100 .word 0x41005100
db0: 41005108 .word 0x41005108
db4: 41005000 .word 0x41005000
db8: 20000104 .word 0x20000104
00000dbc <_usb_d_dev_handle_stall>:
* \brief Handles stall sent interrupt
* \param[in] ept Pointer to endpoint information.
* \param[in] bank_n Bank number.
*/
static void _usb_d_dev_handle_stall(struct _usb_d_dev_ep *ept, const uint8_t bank_n)
{
dbc: b510 push {r4, lr}
_usbd_ep_int_dis(epn, USB_DEVICE_EPINTFLAG_STALL0 << bank_n);
dbe: 2220 movs r2, #32
dc0: 408a lsls r2, r1
hri_usbendpoint_clear_EPINTEN_reg(USB, epn, flags);
dc2: b2d2 uxtb r2, r2
uint8_t epn = USB_EP_GET_N(ept->ep);
dc4: 7c81 ldrb r1, [r0, #18]
dc6: 230f movs r3, #15
dc8: 400b ands r3, r1
dca: 015b lsls r3, r3, #5
dcc: 4905 ldr r1, [pc, #20] ; (de4 <_usb_d_dev_handle_stall+0x28>)
dce: 468c mov ip, r1
dd0: 4463 add r3, ip
dd2: 701a strb r2, [r3, #0]
/* Clear interrupt enable. Leave status there for status check. */
_usbd_ep_int_stall_en(epn, bank_n, false);
dev_inst.ep_callbacks.done(ept->ep, USB_TRANS_STALL, ept->trans_count);
dd4: 6882 ldr r2, [r0, #8]
dd6: 7c80 ldrb r0, [r0, #18]
dd8: 4b03 ldr r3, [pc, #12] ; (de8 <_usb_d_dev_handle_stall+0x2c>)
dda: 6f1b ldr r3, [r3, #112] ; 0x70
ddc: 2101 movs r1, #1
dde: 4798 blx r3
}
de0: bd10 pop {r4, pc}
de2: 46c0 nop ; (mov r8, r8)
de4: 41005108 .word 0x41005108
de8: 20000104 .word 0x20000104
00000dec <_usb_d_dev_trans_done>:
* \brief Finish the transaction and invoke callback
* \param[in, out] ept Pointer to endpoint information.
* \param[in] code Information code passed.
*/
static void _usb_d_dev_trans_done(struct _usb_d_dev_ep *ept, const int32_t code)
{
dec: b510 push {r4, lr}
if (!(_usb_d_dev_ep_is_used(ept) && _usb_d_dev_ep_is_busy(ept))) {
dee: 7c83 ldrb r3, [r0, #18]
df0: 2bff cmp r3, #255 ; 0xff
df2: d002 beq.n dfa <_usb_d_dev_trans_done+0xe>
df4: 7cc2 ldrb r2, [r0, #19]
df6: 0652 lsls r2, r2, #25
df8: d400 bmi.n dfc <_usb_d_dev_trans_done+0x10>
return;
}
ept->flags.bits.is_busy = 0;
dev_inst.ep_callbacks.done(ept->ep, code, ept->trans_count);
}
dfa: bd10 pop {r4, pc}
ept->flags.bits.is_busy = 0;
dfc: 7cc2 ldrb r2, [r0, #19]
dfe: 2440 movs r4, #64 ; 0x40
e00: 43a2 bics r2, r4
e02: 74c2 strb r2, [r0, #19]
dev_inst.ep_callbacks.done(ept->ep, code, ept->trans_count);
e04: 6882 ldr r2, [r0, #8]
e06: 4802 ldr r0, [pc, #8] ; (e10 <_usb_d_dev_trans_done+0x24>)
e08: 6f04 ldr r4, [r0, #112] ; 0x70
e0a: 0018 movs r0, r3
e0c: 47a0 blx r4
e0e: e7f4 b.n dfa <_usb_d_dev_trans_done+0xe>
e10: 20000104 .word 0x20000104
00000e14 <_usb_d_dev_trans_stop>:
* \param[in, out] ept Pointer to endpoint information.
* \param[in] dir Endpoint direction.
* \param[in] code Information code passed.
*/
static void _usb_d_dev_trans_stop(struct _usb_d_dev_ep *ept, bool dir, const int32_t code)
{
e14: b530 push {r4, r5, lr}
e16: b083 sub sp, #12
uint8_t epn = USB_EP_GET_N(ept->ep);
e18: 7c83 ldrb r3, [r0, #18]
;
const uint8_t intflags[2] = {USB_D_BANK0_INT_FLAGS, USB_D_BANK1_INT_FLAGS};
e1a: ac01 add r4, sp, #4
e1c: 2525 movs r5, #37 ; 0x25
e1e: 7025 strb r5, [r4, #0]
e20: 3525 adds r5, #37 ; 0x25
e22: 7065 strb r5, [r4, #1]
if (!(_usb_d_dev_ep_is_used(ept) && _usb_d_dev_ep_is_busy(ept))) {
e24: 2bff cmp r3, #255 ; 0xff
e26: d01b beq.n e60 <_usb_d_dev_trans_stop+0x4c>
e28: 7cc4 ldrb r4, [r0, #19]
e2a: 0664 lsls r4, r4, #25
e2c: d518 bpl.n e60 <_usb_d_dev_trans_stop+0x4c>
uint8_t epn = USB_EP_GET_N(ept->ep);
e2e: 240f movs r4, #15
e30: 4023 ands r3, r4
return;
}
/* Stop transfer */
if (dir) {
e32: 2900 cmp r1, #0
e34: d016 beq.n e64 <_usb_d_dev_trans_stop+0x50>
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask;
e36: 015c lsls r4, r3, #5
e38: 4d0e ldr r5, [pc, #56] ; (e74 <_usb_d_dev_trans_stop+0x60>)
e3a: 46ac mov ip, r5
e3c: 4464 add r4, ip
e3e: 2580 movs r5, #128 ; 0x80
e40: 7125 strb r5, [r4, #4]
_usbd_ep_set_in_rdy(epn, 1, false);
} else {
/* NAK OUT */
_usbd_ep_set_out_rdy(epn, 0, false);
}
_usbd_ep_int_ack(epn, intflags[dir]);
e42: ac01 add r4, sp, #4
e44: 5c64 ldrb r4, [r4, r1]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
e46: 0159 lsls r1, r3, #5
e48: 4d0a ldr r5, [pc, #40] ; (e74 <_usb_d_dev_trans_stop+0x60>)
e4a: 46ac mov ip, r5
e4c: 4461 add r1, ip
e4e: 71cc strb r4, [r1, #7]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask;
e50: 015b lsls r3, r3, #5
e52: 4909 ldr r1, [pc, #36] ; (e78 <_usb_d_dev_trans_stop+0x64>)
e54: 468c mov ip, r1
e56: 4463 add r3, ip
e58: 701c strb r4, [r3, #0]
_usbd_ep_int_dis(epn, intflags[dir]);
_usb_d_dev_trans_done(ept, code);
e5a: 0011 movs r1, r2
e5c: 4b07 ldr r3, [pc, #28] ; (e7c <_usb_d_dev_trans_stop+0x68>)
e5e: 4798 blx r3
}
e60: b003 add sp, #12
e62: bd30 pop {r4, r5, pc}
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask;
e64: 015c lsls r4, r3, #5
e66: 4d03 ldr r5, [pc, #12] ; (e74 <_usb_d_dev_trans_stop+0x60>)
e68: 46ac mov ip, r5
e6a: 4464 add r4, ip
e6c: 2540 movs r5, #64 ; 0x40
e6e: 7165 strb r5, [r4, #5]
e70: e7e7 b.n e42 <_usb_d_dev_trans_stop+0x2e>
e72: 46c0 nop ; (mov r8, r8)
e74: 41005100 .word 0x41005100
e78: 41005108 .word 0x41005108
e7c: 00000ded .word 0x00000ded
00000e80 <_usb_d_dev_handle_trfail>:
{
e80: b570 push {r4, r5, r6, lr}
e82: b082 sub sp, #8
uint8_t epn = USB_EP_GET_N(ept->ep);
e84: 7c83 ldrb r3, [r0, #18]
e86: 220f movs r2, #15
e88: 4013 ands r3, r2
const uint8_t fail[2] = {USB_DEVICE_EPINTFLAG_TRFAIL0, USB_DEVICE_EPINTFLAG_TRFAIL1};
e8a: aa01 add r2, sp, #4
e8c: 2404 movs r4, #4
e8e: 7014 strb r4, [r2, #0]
e90: 3404 adds r4, #4
e92: 7054 strb r4, [r2, #1]
e94: 015d lsls r5, r3, #5
uint8_t eptype
e96: 2900 cmp r1, #0
e98: d031 beq.n efe <_usb_d_dev_handle_trfail+0x7e>
static inline hri_usbendpoint_epcfg_reg_t hri_usbendpoint_read_EPCFG_EPTYPE1_bf(const void *const hw,
uint8_t submodule_index)
{
uint8_t tmp;
tmp = ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg;
e9a: 001a movs r2, r3
e9c: 3208 adds r2, #8
e9e: 0152 lsls r2, r2, #5
ea0: 4c32 ldr r4, [pc, #200] ; (f6c <_usb_d_dev_handle_trfail+0xec>)
ea2: 5d14 ldrb r4, [r2, r4]
tmp = (tmp & USB_DEVICE_EPCFG_EPTYPE1_Msk) >> USB_DEVICE_EPCFG_EPTYPE1_Pos;
ea4: 0664 lsls r4, r4, #25
ea6: 0f64 lsrs r4, r4, #29
st.reg = bank[bank_n].STATUS_BK.reg;
ea8: 010a lsls r2, r1, #4
eaa: 1952 adds r2, r2, r5
eac: 4d30 ldr r5, [pc, #192] ; (f70 <_usb_d_dev_handle_trfail+0xf0>)
eae: 18aa adds r2, r5, r2
eb0: 7a95 ldrb r5, [r2, #10]
eb2: b2ed uxtb r5, r5
if ((eptype == USB_D_EPTYPE_ISOCH) && st.bit.CRCERR) {
eb4: 2c02 cmp r4, #2
eb6: d02a beq.n f0e <_usb_d_dev_handle_trfail+0x8e>
} else if (st.bit.ERRORFLOW) {
eb8: 07ac lsls r4, r5, #30
eba: d541 bpl.n f40 <_usb_d_dev_handle_trfail+0xc0>
bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept);
ebc: 7cc5 ldrb r5, [r0, #19]
bank[bank_n].STATUS_BK.bit.ERRORFLOW = 0;
ebe: 7a94 ldrb r4, [r2, #10]
ec0: 2602 movs r6, #2
ec2: 43b4 bics r4, r6
ec4: 7294 strb r4, [r2, #10]
hri_usbendpoint_clear_EPINTFLAG_reg(hw, epn, fail[bank_n]);
ec6: aa01 add r2, sp, #4
ec8: 5c54 ldrb r4, [r2, r1]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
eca: 015a lsls r2, r3, #5
ecc: 4e29 ldr r6, [pc, #164] ; (f74 <_usb_d_dev_handle_trfail+0xf4>)
ece: 46b4 mov ip, r6
ed0: 4462 add r2, ip
ed2: 71d4 strb r4, [r2, #7]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask;
ed4: 015b lsls r3, r3, #5
ed6: 4a28 ldr r2, [pc, #160] ; (f78 <_usb_d_dev_handle_trfail+0xf8>)
ed8: 4694 mov ip, r2
eda: 4463 add r3, ip
edc: 701c strb r4, [r3, #0]
if (is_ctrl && _usb_d_dev_ep_is_busy(ept)) {
ede: 2307 movs r3, #7
ee0: 402b ands r3, r5
ee2: 2b01 cmp r3, #1
ee4: d13f bne.n f66 <_usb_d_dev_handle_trfail+0xe6>
ee6: 7cc3 ldrb r3, [r0, #19]
ee8: 065b lsls r3, r3, #25
eea: d53c bpl.n f66 <_usb_d_dev_handle_trfail+0xe6>
if (bank_n != _usb_d_dev_ep_is_in(ept)) {
eec: 7cc3 ldrb r3, [r0, #19]
eee: 09db lsrs r3, r3, #7
ef0: 4299 cmp r1, r3
ef2: d038 beq.n f66 <_usb_d_dev_handle_trfail+0xe6>
_usb_d_dev_trans_stop(ept, _usb_d_dev_ep_is_in(ept), USB_TRANS_DONE);
ef4: 2200 movs r2, #0
ef6: 0019 movs r1, r3
ef8: 4b20 ldr r3, [pc, #128] ; (f7c <_usb_d_dev_handle_trfail+0xfc>)
efa: 4798 blx r3
efc: e033 b.n f66 <_usb_d_dev_handle_trfail+0xe6>
tmp = ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg;
efe: 001a movs r2, r3
f00: 3208 adds r2, #8
f02: 0152 lsls r2, r2, #5
f04: 4c19 ldr r4, [pc, #100] ; (f6c <_usb_d_dev_handle_trfail+0xec>)
f06: 5d14 ldrb r4, [r2, r4]
tmp = (tmp & USB_DEVICE_EPCFG_EPTYPE0_Msk) >> USB_DEVICE_EPCFG_EPTYPE0_Pos;
f08: 2207 movs r2, #7
f0a: 4014 ands r4, r2
f0c: e7cc b.n ea8 <_usb_d_dev_handle_trfail+0x28>
if ((eptype == USB_D_EPTYPE_ISOCH) && st.bit.CRCERR) {
f0e: 07ec lsls r4, r5, #31
f10: d5d2 bpl.n eb8 <_usb_d_dev_handle_trfail+0x38>
bank[bank_n].STATUS_BK.bit.CRCERR = 0;
f12: 7a94 ldrb r4, [r2, #10]
f14: 2501 movs r5, #1
f16: 43ac bics r4, r5
f18: 7294 strb r4, [r2, #10]
hri_usbendpoint_clear_EPINTFLAG_reg(hw, epn, fail[bank_n]);
f1a: aa01 add r2, sp, #4
f1c: 5c54 ldrb r4, [r2, r1]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
f1e: 015a lsls r2, r3, #5
f20: 4d14 ldr r5, [pc, #80] ; (f74 <_usb_d_dev_handle_trfail+0xf4>)
f22: 46ac mov ip, r5
f24: 4462 add r2, ip
f26: 71d4 strb r4, [r2, #7]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask;
f28: 015b lsls r3, r3, #5
f2a: 4a13 ldr r2, [pc, #76] ; (f78 <_usb_d_dev_handle_trfail+0xf8>)
f2c: 4694 mov ip, r2
f2e: 4463 add r3, ip
f30: 701c strb r4, [r3, #0]
_usb_d_dev_trans_stop(ept, bank_n, USB_TRANS_ERROR);
f32: 1e4b subs r3, r1, #1
f34: 4199 sbcs r1, r3
f36: b2c9 uxtb r1, r1
f38: 2204 movs r2, #4
f3a: 4b10 ldr r3, [pc, #64] ; (f7c <_usb_d_dev_handle_trfail+0xfc>)
f3c: 4798 blx r3
f3e: e012 b.n f66 <_usb_d_dev_handle_trfail+0xe6>
bank->STATUS_BK.reg = 0;
f40: 005a lsls r2, r3, #1
f42: 1852 adds r2, r2, r1
f44: 0112 lsls r2, r2, #4
f46: 480a ldr r0, [pc, #40] ; (f70 <_usb_d_dev_handle_trfail+0xf0>)
f48: 1882 adds r2, r0, r2
f4a: 2000 movs r0, #0
f4c: 7290 strb r0, [r2, #10]
hri_usbendpoint_clear_EPINTFLAG_reg(hw, epn, fail[bank_n]);
f4e: aa01 add r2, sp, #4
f50: 5c51 ldrb r1, [r2, r1]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
f52: 015a lsls r2, r3, #5
f54: 4807 ldr r0, [pc, #28] ; (f74 <_usb_d_dev_handle_trfail+0xf4>)
f56: 4684 mov ip, r0
f58: 4462 add r2, ip
f5a: 71d1 strb r1, [r2, #7]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask;
f5c: 015b lsls r3, r3, #5
f5e: 4a06 ldr r2, [pc, #24] ; (f78 <_usb_d_dev_handle_trfail+0xf8>)
f60: 4694 mov ip, r2
f62: 4463 add r3, ip
f64: 7019 strb r1, [r3, #0]
}
f66: b002 add sp, #8
f68: bd70 pop {r4, r5, r6, pc}
f6a: 46c0 nop ; (mov r8, r8)
f6c: 41005000 .word 0x41005000
f70: 20000104 .word 0x20000104
f74: 41005100 .word 0x41005100
f78: 41005108 .word 0x41005108
f7c: 00000e15 .word 0x00000e15
00000f80 <_usb_d_dev_reset_epts>:
{
f80: b5f0 push {r4, r5, r6, r7, lr}
f82: 46c6 mov lr, r8
f84: b500 push {lr}
f86: 4d0c ldr r5, [pc, #48] ; (fb8 <_usb_d_dev_reset_epts+0x38>)
f88: 002c movs r4, r5
f8a: 3474 adds r4, #116 ; 0x74
f8c: 3529 adds r5, #41 ; 0x29
f8e: 35ff adds r5, #255 ; 0xff
_usb_d_dev_trans_done(&dev_inst.ep[i], USB_TRANS_RESET);
f90: 4b0a ldr r3, [pc, #40] ; (fbc <_usb_d_dev_reset_epts+0x3c>)
f92: 4698 mov r8, r3
dev_inst.ep[i].ep = 0xFF;
f94: 27ff movs r7, #255 ; 0xff
dev_inst.ep[i].flags.u8 = 0;
f96: 2600 movs r6, #0
_usb_d_dev_trans_done(&dev_inst.ep[i], USB_TRANS_RESET);
f98: 2103 movs r1, #3
f9a: 0020 movs r0, r4
f9c: 47c0 blx r8
dev_inst.ep[i].ep = 0xFF;
f9e: 74a7 strb r7, [r4, #18]
dev_inst.ep[i].flags.u8 = 0;
fa0: 74e6 strb r6, [r4, #19]
fa2: 3414 adds r4, #20
for (i = 0; i < USB_D_N_EP; i++) {
fa4: 42ac cmp r4, r5
fa6: d1f7 bne.n f98 <_usb_d_dev_reset_epts+0x18>
memset(prvt_inst.desc_table, 0, sizeof(UsbDeviceDescriptor) * (CONF_USB_D_MAX_EP_N + 1));
fa8: 2260 movs r2, #96 ; 0x60
faa: 2100 movs r1, #0
fac: 4802 ldr r0, [pc, #8] ; (fb8 <_usb_d_dev_reset_epts+0x38>)
fae: 4b04 ldr r3, [pc, #16] ; (fc0 <_usb_d_dev_reset_epts+0x40>)
fb0: 4798 blx r3
}
fb2: bc04 pop {r2}
fb4: 4690 mov r8, r2
fb6: bdf0 pop {r4, r5, r6, r7, pc}
fb8: 20000104 .word 0x20000104
fbc: 00000ded .word 0x00000ded
fc0: 00002beb .word 0x00002beb
00000fc4 <_usb_d_dev_in_next>:
{
fc4: b5f0 push {r4, r5, r6, r7, lr}
fc6: 46c6 mov lr, r8
fc8: b500 push {lr}
fca: 0004 movs r4, r0
fcc: 000e movs r6, r1
uint8_t epn = USB_EP_GET_N(ept->ep);
fce: 7c83 ldrb r3, [r0, #18]
fd0: 250f movs r5, #15
fd2: 401d ands r5, r3
uint16_t trans_count = isr ? bank[1].PCKSIZE.bit.BYTE_COUNT : 0;
fd4: 2900 cmp r1, #0
fd6: d100 bne.n fda <_usb_d_dev_in_next+0x16>
fd8: e0aa b.n 1130 <_usb_d_dev_in_next+0x16c>
UsbDeviceDescBank *bank = &prvt_inst.desc_table[epn].DeviceDescBank[0];
fda: 016a lsls r2, r5, #5
fdc: 4b5a ldr r3, [pc, #360] ; (1148 <_usb_d_dev_in_next+0x184>)
fde: 189b adds r3, r3, r2
uint16_t trans_count = isr ? bank[1].PCKSIZE.bit.BYTE_COUNT : 0;
fe0: 6958 ldr r0, [r3, #20]
fe2: 0480 lsls r0, r0, #18
fe4: 0c80 lsrs r0, r0, #18
uint16_t last_pkt = trans_count & ((ept->size == 1023) ? ept->size : (ept->size - 1));
fe6: 8a23 ldrh r3, [r4, #16]
fe8: 4a58 ldr r2, [pc, #352] ; (114c <_usb_d_dev_in_next+0x188>)
fea: 4293 cmp r3, r2
fec: d100 bne.n ff0 <_usb_d_dev_in_next+0x2c>
fee: e09a b.n 1126 <_usb_d_dev_in_next+0x162>
ff0: 3b01 subs r3, #1
ff2: b29a uxth r2, r3
bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept);
ff4: 7ce3 ldrb r3, [r4, #19]
ff6: 2707 movs r7, #7
ff8: 401f ands r7, r3
if (isr) {
ffa: 2e00 cmp r6, #0
ffc: d005 beq.n 100a <_usb_d_dev_in_next+0x46>
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
ffe: 016b lsls r3, r5, #5
1000: 4953 ldr r1, [pc, #332] ; (1150 <_usb_d_dev_in_next+0x18c>)
1002: 468c mov ip, r1
1004: 4463 add r3, ip
1006: 2102 movs r1, #2
1008: 71d9 strb r1, [r3, #7]
ept->trans_count += trans_count;
100a: 68a3 ldr r3, [r4, #8]
100c: 18c1 adds r1, r0, r3
100e: 60a1 str r1, [r4, #8]
if (ept->trans_count < ept->trans_size) {
1010: 6863 ldr r3, [r4, #4]
1012: 4299 cmp r1, r3
1014: d24a bcs.n 10ac <_usb_d_dev_in_next+0xe8>
trans_next = ept->trans_size - ept->trans_count;
1016: 1a5b subs r3, r3, r1
1018: b29b uxth r3, r3
if (ept->flags.bits.use_cache) {
101a: 7ce2 ldrb r2, [r4, #19]
101c: 0692 lsls r2, r2, #26
101e: d535 bpl.n 108c <_usb_d_dev_in_next+0xc8>
1020: 8a22 ldrh r2, [r4, #16]
1022: 1c10 adds r0, r2, #0
1024: b292 uxth r2, r2
1026: 429a cmp r2, r3
1028: d900 bls.n 102c <_usb_d_dev_in_next+0x68>
102a: 1c18 adds r0, r3, #0
102c: b283 uxth r3, r0
102e: 4698 mov r8, r3
memcpy(ept->cache, &ept->trans_buf[ept->trans_count], trans_next);
1030: 6823 ldr r3, [r4, #0]
1032: 469c mov ip, r3
1034: 4461 add r1, ip
1036: 4642 mov r2, r8
1038: 68e0 ldr r0, [r4, #12]
103a: 4b46 ldr r3, [pc, #280] ; (1154 <_usb_d_dev_in_next+0x190>)
103c: 4798 blx r3
_usbd_ep_set_buf(epn, 1, (uint32_t)ept->cache);
103e: 68e1 ldr r1, [r4, #12]
bank->ADDR.reg = addr;
1040: 016a lsls r2, r5, #5
1042: 4b41 ldr r3, [pc, #260] ; (1148 <_usb_d_dev_in_next+0x184>)
1044: 189b adds r3, r3, r2
1046: 6119 str r1, [r3, #16]
bank->PCKSIZE.bit.BYTE_COUNT = size;
1048: 016a lsls r2, r5, #5
104a: 4b3f ldr r3, [pc, #252] ; (1148 <_usb_d_dev_in_next+0x184>)
104c: 189b adds r3, r3, r2
104e: 695a ldr r2, [r3, #20]
1050: 4641 mov r1, r8
1052: 0489 lsls r1, r1, #18
1054: 0c89 lsrs r1, r1, #18
1056: 0b92 lsrs r2, r2, #14
1058: 0392 lsls r2, r2, #14
105a: 430a orrs r2, r1
105c: 615a str r2, [r3, #20]
bank->PCKSIZE.bit.MULTI_PACKET_SIZE = count;
105e: 695a ldr r2, [r3, #20]
1060: 493d ldr r1, [pc, #244] ; (1158 <_usb_d_dev_in_next+0x194>)
1062: 400a ands r2, r1
1064: 615a str r2, [r3, #20]
if (!isr) {
1066: 2e00 cmp r6, #0
1068: d107 bne.n 107a <_usb_d_dev_in_next+0xb6>
if (is_ctrl) {
106a: 2f01 cmp r7, #1
106c: d059 beq.n 1122 <_usb_d_dev_in_next+0x15e>
inten = USB_D_BANK1_INT_FLAGS;
106e: 224a movs r2, #74 ; 0x4a
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENSET.reg = mask;
1070: 016b lsls r3, r5, #5
1072: 493a ldr r1, [pc, #232] ; (115c <_usb_d_dev_in_next+0x198>)
1074: 468c mov ip, r1
1076: 4463 add r3, ip
1078: 701a strb r2, [r3, #0]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask;
107a: 016d lsls r5, r5, #5
107c: 4b34 ldr r3, [pc, #208] ; (1150 <_usb_d_dev_in_next+0x18c>)
107e: 469c mov ip, r3
1080: 4465 add r5, ip
1082: 2380 movs r3, #128 ; 0x80
1084: 716b strb r3, [r5, #5]
}
1086: bc04 pop {r2}
1088: 4690 mov r8, r2
108a: bdf0 pop {r4, r5, r6, r7, pc}
108c: 1c1a adds r2, r3, #0
108e: 2080 movs r0, #128 ; 0x80
1090: 0180 lsls r0, r0, #6
1092: 4283 cmp r3, r0
1094: d901 bls.n 109a <_usb_d_dev_in_next+0xd6>
1096: 4b32 ldr r3, [pc, #200] ; (1160 <_usb_d_dev_in_next+0x19c>)
1098: 881a ldrh r2, [r3, #0]
109a: b293 uxth r3, r2
109c: 4698 mov r8, r3
_usbd_ep_set_buf(epn, 1, (uint32_t)&ept->trans_buf[ept->trans_count]);
109e: 6823 ldr r3, [r4, #0]
10a0: 1859 adds r1, r3, r1
bank->ADDR.reg = addr;
10a2: 016a lsls r2, r5, #5
10a4: 4b28 ldr r3, [pc, #160] ; (1148 <_usb_d_dev_in_next+0x184>)
10a6: 189b adds r3, r3, r2
10a8: 6119 str r1, [r3, #16]
10aa: e7cd b.n 1048 <_usb_d_dev_in_next+0x84>
} else if (ept->flags.bits.need_zlp) {
10ac: 7ce3 ldrb r3, [r4, #19]
10ae: 06db lsls r3, r3, #27
10b0: d50f bpl.n 10d2 <_usb_d_dev_in_next+0x10e>
ept->flags.bits.need_zlp = 0;
10b2: 7ce3 ldrb r3, [r4, #19]
10b4: 2210 movs r2, #16
10b6: 4393 bics r3, r2
10b8: 74e3 strb r3, [r4, #19]
bank->PCKSIZE.bit.BYTE_COUNT = size;
10ba: 016a lsls r2, r5, #5
10bc: 4b22 ldr r3, [pc, #136] ; (1148 <_usb_d_dev_in_next+0x184>)
10be: 189b adds r3, r3, r2
10c0: 695a ldr r2, [r3, #20]
10c2: 0b92 lsrs r2, r2, #14
10c4: 0392 lsls r2, r2, #14
10c6: 615a str r2, [r3, #20]
bank->PCKSIZE.bit.MULTI_PACKET_SIZE = count;
10c8: 695a ldr r2, [r3, #20]
10ca: 4923 ldr r1, [pc, #140] ; (1158 <_usb_d_dev_in_next+0x194>)
10cc: 400a ands r2, r1
10ce: 615a str r2, [r3, #20]
10d0: e7c9 b.n 1066 <_usb_d_dev_in_next+0xa2>
if (is_ctrl) {
10d2: 2f01 cmp r7, #1
10d4: d00e beq.n 10f4 <_usb_d_dev_in_next+0x130>
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask;
10d6: 016d lsls r5, r5, #5
10d8: 4b22 ldr r3, [pc, #136] ; (1164 <_usb_d_dev_in_next+0x1a0>)
10da: 469c mov ip, r3
10dc: 4465 add r5, ip
10de: 234a movs r3, #74 ; 0x4a
10e0: 702b strb r3, [r5, #0]
if (last_pkt == ept->size) {
10e2: 8a21 ldrh r1, [r4, #16]
10e4: 4002 ands r2, r0
10e6: 4291 cmp r1, r2
10e8: d00b beq.n 1102 <_usb_d_dev_in_next+0x13e>
_usb_d_dev_trans_done(ept, USB_TRANS_DONE);
10ea: 2100 movs r1, #0
10ec: 0020 movs r0, r4
10ee: 4b1e ldr r3, [pc, #120] ; (1168 <_usb_d_dev_in_next+0x1a4>)
10f0: 4798 blx r3
return;
10f2: e7c8 b.n 1086 <_usb_d_dev_in_next+0xc2>
10f4: 016d lsls r5, r5, #5
10f6: 4b1b ldr r3, [pc, #108] ; (1164 <_usb_d_dev_in_next+0x1a0>)
10f8: 469c mov ip, r3
10fa: 4465 add r5, ip
10fc: 234b movs r3, #75 ; 0x4b
10fe: 702b strb r3, [r5, #0]
1100: e7ef b.n 10e2 <_usb_d_dev_in_next+0x11e>
ept->flags.bits.is_busy = 0;
1102: 7ce3 ldrb r3, [r4, #19]
1104: 2240 movs r2, #64 ; 0x40
1106: 4393 bics r3, r2
1108: 74e3 strb r3, [r4, #19]
if (dev_inst.ep_callbacks.more(ept->ep, ept->trans_count)) {
110a: 7ca0 ldrb r0, [r4, #18]
110c: 4b0e ldr r3, [pc, #56] ; (1148 <_usb_d_dev_in_next+0x184>)
110e: 6edb ldr r3, [r3, #108] ; 0x6c
1110: 68a1 ldr r1, [r4, #8]
1112: 4798 blx r3
1114: 2800 cmp r0, #0
1116: d1b6 bne.n 1086 <_usb_d_dev_in_next+0xc2>
ept->flags.bits.is_busy = 1;
1118: 7ce3 ldrb r3, [r4, #19]
111a: 2240 movs r2, #64 ; 0x40
111c: 4313 orrs r3, r2
111e: 74e3 strb r3, [r4, #19]
1120: e7e3 b.n 10ea <_usb_d_dev_in_next+0x126>
inten = USB_D_BANK1_INT_FLAGS | USB_DEVICE_EPINTFLAG_TRFAIL0;
1122: 224e movs r2, #78 ; 0x4e
1124: e7a4 b.n 1070 <_usb_d_dev_in_next+0xac>
bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept);
1126: 7ce7 ldrb r7, [r4, #19]
1128: 2307 movs r3, #7
112a: 401f ands r7, r3
112c: 4a07 ldr r2, [pc, #28] ; (114c <_usb_d_dev_in_next+0x188>)
112e: e766 b.n ffe <_usb_d_dev_in_next+0x3a>
uint16_t last_pkt = trans_count & ((ept->size == 1023) ? ept->size : (ept->size - 1));
1130: 8a03 ldrh r3, [r0, #16]
1132: 4a06 ldr r2, [pc, #24] ; (114c <_usb_d_dev_in_next+0x188>)
1134: 2000 movs r0, #0
1136: 4293 cmp r3, r2
1138: d000 beq.n 113c <_usb_d_dev_in_next+0x178>
113a: e759 b.n ff0 <_usb_d_dev_in_next+0x2c>
bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept);
113c: 7ce3 ldrb r3, [r4, #19]
113e: 2707 movs r7, #7
1140: 401f ands r7, r3
1142: 2000 movs r0, #0
1144: 4a01 ldr r2, [pc, #4] ; (114c <_usb_d_dev_in_next+0x188>)
1146: e760 b.n 100a <_usb_d_dev_in_next+0x46>
1148: 20000104 .word 0x20000104
114c: 000003ff .word 0x000003ff
1150: 41005100 .word 0x41005100
1154: 00002bd9 .word 0x00002bd9
1158: f0003fff .word 0xf0003fff
115c: 41005109 .word 0x41005109
1160: 00002c54 .word 0x00002c54
1164: 41005108 .word 0x41005108
1168: 00000ded .word 0x00000ded
0000116c <_usb_d_dev_out_next>:
{
116c: b5f8 push {r3, r4, r5, r6, r7, lr}
116e: 46de mov lr, fp
1170: 4657 mov r7, sl
1172: 464e mov r6, r9
1174: 4645 mov r5, r8
1176: b5e0 push {r5, r6, r7, lr}
1178: 0004 movs r4, r0
117a: 4688 mov r8, r1
uint8_t epn = USB_EP_GET_N(ept->ep);
117c: 7c83 ldrb r3, [r0, #18]
117e: 250f movs r5, #15
1180: 401d ands r5, r3
uint16_t trans_size = isr ? bank->PCKSIZE.bit.MULTI_PACKET_SIZE : 0;
1182: 2900 cmp r1, #0
1184: d057 beq.n 1236 <_usb_d_dev_out_next+0xca>
1186: 016a lsls r2, r5, #5
1188: 4b7d ldr r3, [pc, #500] ; (1380 <_usb_d_dev_out_next+0x214>)
118a: 189b adds r3, r3, r2
118c: 685a ldr r2, [r3, #4]
118e: 0112 lsls r2, r2, #4
1190: 0c92 lsrs r2, r2, #18
1192: 4692 mov sl, r2
uint16_t last_trans = isr ? bank->PCKSIZE.bit.BYTE_COUNT : 0;
1194: 685f ldr r7, [r3, #4]
1196: 04bf lsls r7, r7, #18
1198: 0cbf lsrs r7, r7, #18
119a: 46bb mov fp, r7
uint16_t size_mask = (ept->size == 1023) ? 1023 : (ept->size - 1);
119c: 8a06 ldrh r6, [r0, #16]
119e: 4b79 ldr r3, [pc, #484] ; (1384 <_usb_d_dev_out_next+0x218>)
11a0: 429e cmp r6, r3
11a2: d100 bne.n 11a6 <_usb_d_dev_out_next+0x3a>
11a4: e0cd b.n 1342 <_usb_d_dev_out_next+0x1d6>
11a6: 3e01 subs r6, #1
11a8: b2b6 uxth r6, r6
uint16_t last_pkt = last_trans & size_mask;
11aa: 465f mov r7, fp
11ac: 4037 ands r7, r6
bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept);
11ae: 7ce3 ldrb r3, [r4, #19]
11b0: 2207 movs r2, #7
11b2: 401a ands r2, r3
11b4: 4691 mov r9, r2
if (isr) {
11b6: 4643 mov r3, r8
11b8: 2b00 cmp r3, #0
11ba: d005 beq.n 11c8 <_usb_d_dev_out_next+0x5c>
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
11bc: 016b lsls r3, r5, #5
11be: 4a72 ldr r2, [pc, #456] ; (1388 <_usb_d_dev_out_next+0x21c>)
11c0: 4694 mov ip, r2
11c2: 4463 add r3, ip
11c4: 2201 movs r2, #1
11c6: 71da strb r2, [r3, #7]
if (ept->flags.bits.use_cache && ept->trans_size) {
11c8: 7ce3 ldrb r3, [r4, #19]
11ca: 069b lsls r3, r3, #26
11cc: d50f bpl.n 11ee <_usb_d_dev_out_next+0x82>
11ce: 6863 ldr r3, [r4, #4]
11d0: 2b00 cmp r3, #0
11d2: d039 beq.n 1248 <_usb_d_dev_out_next+0xdc>
uint16_t buf_remain = ept->trans_size - ept->trans_count;
11d4: 68a0 ldr r0, [r4, #8]
11d6: 1a1b subs r3, r3, r0
11d8: b29b uxth r3, r3
memcpy(&ept->trans_buf[ept->trans_count], ept->cache, (buf_remain > last_pkt) ? last_pkt : buf_remain);
11da: 6822 ldr r2, [r4, #0]
11dc: 4694 mov ip, r2
11de: 4460 add r0, ip
11e0: 68e1 ldr r1, [r4, #12]
11e2: 001a movs r2, r3
11e4: 42bb cmp r3, r7
11e6: d900 bls.n 11ea <_usb_d_dev_out_next+0x7e>
11e8: 003a movs r2, r7
11ea: 4b68 ldr r3, [pc, #416] ; (138c <_usb_d_dev_out_next+0x220>)
11ec: 4798 blx r3
if (ept->trans_size == 0 && ept->flags.bits.need_zlp) {
11ee: 6863 ldr r3, [r4, #4]
11f0: 2b00 cmp r3, #0
11f2: d029 beq.n 1248 <_usb_d_dev_out_next+0xdc>
} else if (isr && last_pkt < ept->size) {
11f4: 4642 mov r2, r8
11f6: 2a00 cmp r2, #0
11f8: d042 beq.n 1280 <_usb_d_dev_out_next+0x114>
11fa: 8a22 ldrh r2, [r4, #16]
11fc: 42ba cmp r2, r7
11fe: d93f bls.n 1280 <_usb_d_dev_out_next+0x114>
ept->flags.bits.need_zlp = 0;
1200: 7ce3 ldrb r3, [r4, #19]
1202: 2210 movs r2, #16
1204: 4393 bics r3, r2
1206: 74e3 strb r3, [r4, #19]
ept->trans_count += last_trans;
1208: 68a3 ldr r3, [r4, #8]
120a: 445b add r3, fp
120c: 60a3 str r3, [r4, #8]
if (is_ctrl) {
120e: 464b mov r3, r9
1210: 2b01 cmp r3, #1
1212: d100 bne.n 1216 <_usb_d_dev_out_next+0xaa>
1214: e087 b.n 1326 <_usb_d_dev_out_next+0x1ba>
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask;
1216: 016b lsls r3, r5, #5
1218: 4a5d ldr r2, [pc, #372] ; (1390 <_usb_d_dev_out_next+0x224>)
121a: 4694 mov ip, r2
121c: 4463 add r3, ip
121e: 2225 movs r2, #37 ; 0x25
1220: 701a strb r2, [r3, #0]
if (0 == epn) {
1222: 2d00 cmp r5, #0
1224: d102 bne.n 122c <_usb_d_dev_out_next+0xc0>
bank->ADDR.reg = addr;
1226: 4b56 ldr r3, [pc, #344] ; (1380 <_usb_d_dev_out_next+0x214>)
1228: 68e2 ldr r2, [r4, #12]
122a: 601a str r2, [r3, #0]
_usb_d_dev_trans_done(ept, USB_TRANS_DONE);
122c: 2100 movs r1, #0
122e: 0020 movs r0, r4
1230: 4b58 ldr r3, [pc, #352] ; (1394 <_usb_d_dev_out_next+0x228>)
1232: 4798 blx r3
return;
1234: e059 b.n 12ea <_usb_d_dev_out_next+0x17e>
uint16_t size_mask = (ept->size == 1023) ? 1023 : (ept->size - 1);
1236: 8a06 ldrh r6, [r0, #16]
1238: 4b52 ldr r3, [pc, #328] ; (1384 <_usb_d_dev_out_next+0x218>)
123a: 429e cmp r6, r3
123c: d100 bne.n 1240 <_usb_d_dev_out_next+0xd4>
123e: e08e b.n 135e <_usb_d_dev_out_next+0x1f2>
1240: 2300 movs r3, #0
1242: 469b mov fp, r3
1244: 469a mov sl, r3
1246: e7ae b.n 11a6 <_usb_d_dev_out_next+0x3a>
if (ept->trans_size == 0 && ept->flags.bits.need_zlp) {
1248: 7ce3 ldrb r3, [r4, #19]
124a: 06db lsls r3, r3, #27
124c: d400 bmi.n 1250 <_usb_d_dev_out_next+0xe4>
124e: e07f b.n 1350 <_usb_d_dev_out_next+0x1e4>
ept->flags.bits.need_zlp = 0;
1250: 7ce3 ldrb r3, [r4, #19]
ept->flags.bits.use_cache = 1;
1252: 2210 movs r2, #16
1254: 4393 bics r3, r2
1256: 2220 movs r2, #32
1258: 4313 orrs r3, r2
125a: 74e3 strb r3, [r4, #19]
bank->ADDR.reg = addr;
125c: 4a48 ldr r2, [pc, #288] ; (1380 <_usb_d_dev_out_next+0x214>)
125e: 016b lsls r3, r5, #5
1260: 68e1 ldr r1, [r4, #12]
1262: 5099 str r1, [r3, r2]
bank->PCKSIZE.bit.MULTI_PACKET_SIZE = size;
1264: 8a21 ldrh r1, [r4, #16]
1266: 18d3 adds r3, r2, r3
1268: 685a ldr r2, [r3, #4]
126a: 0489 lsls r1, r1, #18
126c: 0909 lsrs r1, r1, #4
126e: 484a ldr r0, [pc, #296] ; (1398 <_usb_d_dev_out_next+0x22c>)
1270: 4002 ands r2, r0
1272: 430a orrs r2, r1
1274: 605a str r2, [r3, #4]
bank->PCKSIZE.bit.BYTE_COUNT = count;
1276: 685a ldr r2, [r3, #4]
1278: 0b92 lsrs r2, r2, #14
127a: 0392 lsls r2, r2, #14
127c: 605a str r2, [r3, #4]
127e: e022 b.n 12c6 <_usb_d_dev_out_next+0x15a>
ept->trans_count += trans_size;
1280: 68a2 ldr r2, [r4, #8]
1282: 4452 add r2, sl
1284: 60a2 str r2, [r4, #8]
if (ept->trans_count < ept->trans_size) {
1286: 4293 cmp r3, r2
1288: d9c1 bls.n 120e <_usb_d_dev_out_next+0xa2>
trans_next = ept->trans_size - ept->trans_count;
128a: 1a9b subs r3, r3, r2
128c: b29b uxth r3, r3
if (ept->flags.bits.use_cache) {
128e: 7ce1 ldrb r1, [r4, #19]
1290: 0689 lsls r1, r1, #26
1292: d530 bpl.n 12f6 <_usb_d_dev_out_next+0x18a>
1294: 8a22 ldrh r2, [r4, #16]
1296: 1c11 adds r1, r2, #0
1298: b292 uxth r2, r2
129a: 429a cmp r2, r3
129c: d900 bls.n 12a0 <_usb_d_dev_out_next+0x134>
129e: 1c19 adds r1, r3, #0
12a0: b28b uxth r3, r1
_usbd_ep_set_buf(epn, 0, (uint32_t)ept->cache);
12a2: 68e0 ldr r0, [r4, #12]
bank->ADDR.reg = addr;
12a4: 016a lsls r2, r5, #5
12a6: 4936 ldr r1, [pc, #216] ; (1380 <_usb_d_dev_out_next+0x214>)
12a8: 5050 str r0, [r2, r1]
bank->PCKSIZE.bit.MULTI_PACKET_SIZE = size;
12aa: 016a lsls r2, r5, #5
12ac: 4934 ldr r1, [pc, #208] ; (1380 <_usb_d_dev_out_next+0x214>)
12ae: 1889 adds r1, r1, r2
12b0: 684a ldr r2, [r1, #4]
12b2: 049b lsls r3, r3, #18
12b4: 091b lsrs r3, r3, #4
12b6: 4838 ldr r0, [pc, #224] ; (1398 <_usb_d_dev_out_next+0x22c>)
12b8: 4002 ands r2, r0
12ba: 4313 orrs r3, r2
12bc: 604b str r3, [r1, #4]
bank->PCKSIZE.bit.BYTE_COUNT = count;
12be: 684b ldr r3, [r1, #4]
12c0: 0b9b lsrs r3, r3, #14
12c2: 039b lsls r3, r3, #14
12c4: 604b str r3, [r1, #4]
if (!isr) {
12c6: 4643 mov r3, r8
12c8: 2b00 cmp r3, #0
12ca: d108 bne.n 12de <_usb_d_dev_out_next+0x172>
inten = USB_D_BANK0_INT_FLAGS;
12cc: 2225 movs r2, #37 ; 0x25
if (is_ctrl) {
12ce: 464b mov r3, r9
12d0: 2b01 cmp r3, #1
12d2: d02f beq.n 1334 <_usb_d_dev_out_next+0x1c8>
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENSET.reg = mask;
12d4: 016b lsls r3, r5, #5
12d6: 4931 ldr r1, [pc, #196] ; (139c <_usb_d_dev_out_next+0x230>)
12d8: 468c mov ip, r1
12da: 4463 add r3, ip
12dc: 701a strb r2, [r3, #0]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask;
12de: 016d lsls r5, r5, #5
12e0: 4b29 ldr r3, [pc, #164] ; (1388 <_usb_d_dev_out_next+0x21c>)
12e2: 469c mov ip, r3
12e4: 4465 add r5, ip
12e6: 2340 movs r3, #64 ; 0x40
12e8: 712b strb r3, [r5, #4]
}
12ea: bc3c pop {r2, r3, r4, r5}
12ec: 4690 mov r8, r2
12ee: 4699 mov r9, r3
12f0: 46a2 mov sl, r4
12f2: 46ab mov fp, r5
12f4: bdf8 pop {r3, r4, r5, r6, r7, pc}
if (trans_next > ept->size) {
12f6: 8a21 ldrh r1, [r4, #16]
12f8: 428b cmp r3, r1
12fa: d90a bls.n 1312 <_usb_d_dev_out_next+0x1a6>
if (trans_next > USB_D_DEV_TRANS_MAX) {
12fc: 2180 movs r1, #128 ; 0x80
12fe: 0189 lsls r1, r1, #6
1300: 428b cmp r3, r1
1302: d80d bhi.n 1320 <_usb_d_dev_out_next+0x1b4>
1304: 43b3 bics r3, r6
_usbd_ep_set_buf(epn, 0, (uint32_t)&ept->trans_buf[ept->trans_count]);
1306: 6821 ldr r1, [r4, #0]
1308: 188a adds r2, r1, r2
bank->ADDR.reg = addr;
130a: 0169 lsls r1, r5, #5
130c: 481c ldr r0, [pc, #112] ; (1380 <_usb_d_dev_out_next+0x214>)
130e: 500a str r2, [r1, r0]
1310: e7cb b.n 12aa <_usb_d_dev_out_next+0x13e>
} else if (trans_next < ept->size) {
1312: 428b cmp r3, r1
1314: d2f7 bcs.n 1306 <_usb_d_dev_out_next+0x19a>
ept->flags.bits.use_cache = 1;
1316: 7ce1 ldrb r1, [r4, #19]
1318: 2020 movs r0, #32
131a: 4301 orrs r1, r0
131c: 74e1 strb r1, [r4, #19]
131e: e7f2 b.n 1306 <_usb_d_dev_out_next+0x19a>
trans_next = USB_D_DEV_TRANS_MAX;
1320: 2380 movs r3, #128 ; 0x80
1322: 019b lsls r3, r3, #6
1324: e7ef b.n 1306 <_usb_d_dev_out_next+0x19a>
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask;
1326: 016b lsls r3, r5, #5
1328: 4a19 ldr r2, [pc, #100] ; (1390 <_usb_d_dev_out_next+0x224>)
132a: 4694 mov ip, r2
132c: 4463 add r3, ip
132e: 222d movs r2, #45 ; 0x2d
1330: 701a strb r2, [r3, #0]
1332: e776 b.n 1222 <_usb_d_dev_out_next+0xb6>
bank->STATUS_BK.reg = 0;
1334: 016a lsls r2, r5, #5
1336: 4b12 ldr r3, [pc, #72] ; (1380 <_usb_d_dev_out_next+0x214>)
1338: 189b adds r3, r3, r2
133a: 2200 movs r2, #0
133c: 769a strb r2, [r3, #26]
inten = USB_D_BANK0_INT_FLAGS | USB_DEVICE_EPINTFLAG_TRFAIL1;
133e: 322d adds r2, #45 ; 0x2d
1340: e7c8 b.n 12d4 <_usb_d_dev_out_next+0x168>
uint16_t last_pkt = last_trans & size_mask;
1342: 05bf lsls r7, r7, #22
1344: 0dbf lsrs r7, r7, #22
bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept);
1346: 7cc3 ldrb r3, [r0, #19]
1348: 2207 movs r2, #7
134a: 401a ands r2, r3
134c: 4691 mov r9, r2
134e: e735 b.n 11bc <_usb_d_dev_out_next+0x50>
} else if (isr && last_pkt < ept->size) {
1350: 4643 mov r3, r8
1352: 2b00 cmp r3, #0
1354: d10c bne.n 1370 <_usb_d_dev_out_next+0x204>
ept->trans_count += trans_size;
1356: 68a3 ldr r3, [r4, #8]
1358: 4453 add r3, sl
135a: 60a3 str r3, [r4, #8]
135c: e757 b.n 120e <_usb_d_dev_out_next+0xa2>
bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept);
135e: 7cc3 ldrb r3, [r0, #19]
1360: 2207 movs r2, #7
1362: 401a ands r2, r3
1364: 4691 mov r9, r2
uint16_t last_pkt = last_trans & size_mask;
1366: 2700 movs r7, #0
bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept);
1368: 2300 movs r3, #0
136a: 469b mov fp, r3
136c: 469a mov sl, r3
136e: e72b b.n 11c8 <_usb_d_dev_out_next+0x5c>
} else if (isr && last_pkt < ept->size) {
1370: 8a23 ldrh r3, [r4, #16]
1372: 42bb cmp r3, r7
1374: d900 bls.n 1378 <_usb_d_dev_out_next+0x20c>
1376: e743 b.n 1200 <_usb_d_dev_out_next+0x94>
ept->trans_count += trans_size;
1378: 68a3 ldr r3, [r4, #8]
137a: 4453 add r3, sl
137c: 60a3 str r3, [r4, #8]
137e: e746 b.n 120e <_usb_d_dev_out_next+0xa2>
1380: 20000104 .word 0x20000104
1384: 000003ff .word 0x000003ff
1388: 41005100 .word 0x41005100
138c: 00002bd9 .word 0x00002bd9
1390: 41005108 .word 0x41005108
1394: 00000ded .word 0x00000ded
1398: f0003fff .word 0xf0003fff
139c: 41005109 .word 0x41005109
000013a0 <_usb_d_dev_init>:
{
13a0: b510 push {r4, lr}
return ((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg;
13a2: 4b31 ldr r3, [pc, #196] ; (1468 <_usb_d_dev_init+0xc8>)
13a4: 789b ldrb r3, [r3, #2]
if (!hri_usbdevice_is_syncing(hw, USB_SYNCBUSY_SWRST)) {
13a6: 07db lsls r3, r3, #31
13a8: d41f bmi.n 13ea <_usb_d_dev_init+0x4a>
while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) {
13aa: 492f ldr r1, [pc, #188] ; (1468 <_usb_d_dev_init+0xc8>)
13ac: 2203 movs r2, #3
13ae: 788b ldrb r3, [r1, #2]
13b0: 4213 tst r3, r2
13b2: d1fc bne.n 13ae <_usb_d_dev_init+0xe>
static inline hri_usb_ctrla_reg_t hri_usb_get_CTRLA_reg(const void *const hw, hri_usb_ctrla_reg_t mask)
{
uint8_t tmp;
hri_usb_wait_for_sync(hw, USB_SYNCBUSY_MASK);
tmp = ((Usb *)hw)->HOST.CTRLA.reg;
13b4: 4b2c ldr r3, [pc, #176] ; (1468 <_usb_d_dev_init+0xc8>)
13b6: 781b ldrb r3, [r3, #0]
if (hri_usbdevice_get_CTRLA_reg(hw, USB_CTRLA_ENABLE)) {
13b8: 079b lsls r3, r3, #30
13ba: d50e bpl.n 13da <_usb_d_dev_init+0x3a>
((Usb *)hw)->HOST.CTRLA.reg &= ~USB_CTRLA_ENABLE;
13bc: 4a2a ldr r2, [pc, #168] ; (1468 <_usb_d_dev_init+0xc8>)
13be: 7813 ldrb r3, [r2, #0]
13c0: 2102 movs r1, #2
13c2: 438b bics r3, r1
13c4: 7013 strb r3, [r2, #0]
while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) {
13c6: 0011 movs r1, r2
13c8: 2203 movs r2, #3
13ca: 788b ldrb r3, [r1, #2]
13cc: 4213 tst r3, r2
13ce: d1fc bne.n 13ca <_usb_d_dev_init+0x2a>
13d0: 4925 ldr r1, [pc, #148] ; (1468 <_usb_d_dev_init+0xc8>)
13d2: 2202 movs r2, #2
13d4: 788b ldrb r3, [r1, #2]
13d6: 4213 tst r3, r2
13d8: d1fc bne.n 13d4 <_usb_d_dev_init+0x34>
}
static inline void hri_usb_write_CTRLA_reg(const void *const hw, hri_usb_ctrla_reg_t data)
{
USB_CRITICAL_SECTION_ENTER();
((Usb *)hw)->HOST.CTRLA.reg = data;
13da: 2201 movs r2, #1
13dc: 4b22 ldr r3, [pc, #136] ; (1468 <_usb_d_dev_init+0xc8>)
13de: 701a strb r2, [r3, #0]
while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) {
13e0: 0019 movs r1, r3
13e2: 3202 adds r2, #2
13e4: 788b ldrb r3, [r1, #2]
13e6: 4213 tst r3, r2
13e8: d1fc bne.n 13e4 <_usb_d_dev_init+0x44>
13ea: 491f ldr r1, [pc, #124] ; (1468 <_usb_d_dev_init+0xc8>)
13ec: 2201 movs r2, #1
13ee: 788b ldrb r3, [r1, #2]
13f0: 4213 tst r3, r2
13f2: d1fc bne.n 13ee <_usb_d_dev_init+0x4e>
dev_inst.callbacks.sof = (_usb_d_dev_sof_cb_t)_dummy_func_no_return;
13f4: 4b1d ldr r3, [pc, #116] ; (146c <_usb_d_dev_init+0xcc>)
13f6: 4a1e ldr r2, [pc, #120] ; (1470 <_usb_d_dev_init+0xd0>)
13f8: 661a str r2, [r3, #96] ; 0x60
dev_inst.callbacks.event = (_usb_d_dev_event_cb_t)_dummy_func_no_return;
13fa: 665a str r2, [r3, #100] ; 0x64
dev_inst.ep_callbacks.setup = (_usb_d_dev_ep_cb_setup_t)_dummy_func_no_return;
13fc: 669a str r2, [r3, #104] ; 0x68
dev_inst.ep_callbacks.more = (_usb_d_dev_ep_cb_more_t)_dummy_func_no_return;
13fe: 66da str r2, [r3, #108] ; 0x6c
dev_inst.ep_callbacks.done = (_usb_d_dev_ep_cb_done_t)_dummy_func_no_return;
1400: 671a str r2, [r3, #112] ; 0x70
_usb_d_dev_reset_epts();
1402: 4b1c ldr r3, [pc, #112] ; (1474 <_usb_d_dev_init+0xd4>)
1404: 4798 blx r3
= (*((uint32_t *)(NVMCTRL_OTP4) + (NVM_USB_PAD_TRANSN_POS / 32)) >> (NVM_USB_PAD_TRANSN_POS % 32))
1406: 4b1c ldr r3, [pc, #112] ; (1478 <_usb_d_dev_init+0xd8>)
1408: 681b ldr r3, [r3, #0]
140a: 0b5a lsrs r2, r3, #13
uint32_t pad_transn
140c: 211f movs r1, #31
140e: 400a ands r2, r1
= (*((uint32_t *)(NVMCTRL_OTP4) + (NVM_USB_PAD_TRANSP_POS / 32)) >> (NVM_USB_PAD_TRANSP_POS % 32))
1410: 0c98 lsrs r0, r3, #18
uint32_t pad_transp
1412: 4001 ands r1, r0
uint32_t pad_trim = (*((uint32_t *)(NVMCTRL_OTP4) + (NVM_USB_PAD_TRIM_POS / 32)) >> (NVM_USB_PAD_TRIM_POS % 32))
1414: 019b lsls r3, r3, #6
1416: 0f5b lsrs r3, r3, #29
if (pad_transn == 0x1F) {
1418: 2a1f cmp r2, #31
141a: d01f beq.n 145c <_usb_d_dev_init+0xbc>
if (pad_transp == 0x1F) {
141c: 291f cmp r1, #31
141e: d01f beq.n 1460 <_usb_d_dev_init+0xc0>
if (pad_trim == 0x7) {
1420: 2b07 cmp r3, #7
1422: d01f beq.n 1464 <_usb_d_dev_init+0xc4>
hw->DEVICE.PADCAL.reg = USB_PADCAL_TRANSN(pad_transn) | USB_PADCAL_TRANSP(pad_transp) | USB_PADCAL_TRIM(pad_trim);
1424: 0192 lsls r2, r2, #6
1426: 430a orrs r2, r1
1428: 031b lsls r3, r3, #12
142a: 4313 orrs r3, r2
142c: 4a0e ldr r2, [pc, #56] ; (1468 <_usb_d_dev_init+0xc8>)
142e: 8513 strh r3, [r2, #40] ; 0x28
hw->DEVICE.QOSCTRL.bit.CQOS = 3;
1430: 78d3 ldrb r3, [r2, #3]
1432: 2103 movs r1, #3
1434: 430b orrs r3, r1
1436: 70d3 strb r3, [r2, #3]
hw->DEVICE.QOSCTRL.bit.DQOS = 3;
1438: 78d3 ldrb r3, [r2, #3]
143a: 210c movs r1, #12
143c: 430b orrs r3, r1
143e: 70d3 strb r3, [r2, #3]
((Usb *)hw)->HOST.CTRLA.reg = data;
1440: 2304 movs r3, #4
1442: 7013 strb r3, [r2, #0]
while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) {
1444: 0011 movs r1, r2
1446: 2203 movs r2, #3
1448: 788b ldrb r3, [r1, #2]
144a: 4213 tst r3, r2
144c: d1fc bne.n 1448 <_usb_d_dev_init+0xa8>
}
static inline void hri_usb_write_DESCADD_reg(const void *const hw, hri_usb_descadd_reg_t data)
{
USB_CRITICAL_SECTION_ENTER();
((Usb *)hw)->HOST.DESCADD.reg = data;
144e: 4b06 ldr r3, [pc, #24] ; (1468 <_usb_d_dev_init+0xc8>)
1450: 4a06 ldr r2, [pc, #24] ; (146c <_usb_d_dev_init+0xcc>)
1452: 625a str r2, [r3, #36] ; 0x24
((Usb *)hw)->DEVICE.CTRLB.reg = data;
1454: 2201 movs r2, #1
1456: 811a strh r2, [r3, #8]
}
1458: 2000 movs r0, #0
145a: bd10 pop {r4, pc}
pad_transn = 5;
145c: 3a1a subs r2, #26
145e: e7dd b.n 141c <_usb_d_dev_init+0x7c>
pad_transp = 29;
1460: 3902 subs r1, #2
1462: e7dd b.n 1420 <_usb_d_dev_init+0x80>
pad_trim = 5;
1464: 3b02 subs r3, #2
1466: e7dd b.n 1424 <_usb_d_dev_init+0x84>
1468: 41005000 .word 0x41005000
146c: 20000104 .word 0x20000104
1470: 00000d2d .word 0x00000d2d
1474: 00000f81 .word 0x00000f81
1478: 00806024 .word 0x00806024
0000147c <_usb_d_dev_enable>:
tmp = ((Usb *)hw)->HOST.SYNCBUSY.reg;
147c: 4b10 ldr r3, [pc, #64] ; (14c0 <_usb_d_dev_enable+0x44>)
147e: 789b ldrb r3, [r3, #2]
if (hri_usbdevice_get_SYNCBUSY_reg(hw, (USB_SYNCBUSY_ENABLE | USB_SYNCBUSY_SWRST))) {
1480: 079b lsls r3, r3, #30
1482: d11a bne.n 14ba <_usb_d_dev_enable+0x3e>
while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) {
1484: 490e ldr r1, [pc, #56] ; (14c0 <_usb_d_dev_enable+0x44>)
1486: 2203 movs r2, #3
1488: 788b ldrb r3, [r1, #2]
148a: 4213 tst r3, r2
148c: d1fc bne.n 1488 <_usb_d_dev_enable+0xc>
return ((Usb *)hw)->HOST.CTRLA.reg;
148e: 4b0c ldr r3, [pc, #48] ; (14c0 <_usb_d_dev_enable+0x44>)
1490: 781b ldrb r3, [r3, #0]
1492: b2db uxtb r3, r3
if ((ctrla & USB_CTRLA_ENABLE) == 0) {
1494: 079a lsls r2, r3, #30
1496: d408 bmi.n 14aa <_usb_d_dev_enable+0x2e>
hri_usbdevice_write_CTRLA_reg(hw, ctrla | USB_CTRLA_ENABLE);
1498: 2202 movs r2, #2
149a: 4313 orrs r3, r2
((Usb *)hw)->HOST.CTRLA.reg = data;
149c: 4a08 ldr r2, [pc, #32] ; (14c0 <_usb_d_dev_enable+0x44>)
149e: 7013 strb r3, [r2, #0]
while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) {
14a0: 0011 movs r1, r2
14a2: 2203 movs r2, #3
14a4: 788b ldrb r3, [r1, #2]
14a6: 4213 tst r3, r2
14a8: d1fc bne.n 14a4 <_usb_d_dev_enable+0x28>
*/
__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
{
if ((int32_t)(IRQn) >= 0)
{
NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL));
14aa: 2280 movs r2, #128 ; 0x80
14ac: 4b05 ldr r3, [pc, #20] ; (14c4 <_usb_d_dev_enable+0x48>)
14ae: 601a str r2, [r3, #0]
((Usb *)hw)->DEVICE.INTENSET.reg = mask;
14b0: 4a05 ldr r2, [pc, #20] ; (14c8 <_usb_d_dev_enable+0x4c>)
14b2: 4b03 ldr r3, [pc, #12] ; (14c0 <_usb_d_dev_enable+0x44>)
14b4: 831a strh r2, [r3, #24]
return ERR_NONE;
14b6: 2000 movs r0, #0
}
14b8: 4770 bx lr
return -USB_ERR_DENIED;
14ba: 2011 movs r0, #17
14bc: 4240 negs r0, r0
14be: e7fb b.n 14b8 <_usb_d_dev_enable+0x3c>
14c0: 41005000 .word 0x41005000
14c4: e000e100 .word 0xe000e100
14c8: 0000028d .word 0x0000028d
000014cc <_usb_d_dev_attach>:
((Usb *)hw)->DEVICE.CTRLB.reg &= ~USB_DEVICE_CTRLB_DETACH;
14cc: 4a02 ldr r2, [pc, #8] ; (14d8 <_usb_d_dev_attach+0xc>)
14ce: 8913 ldrh r3, [r2, #8]
14d0: 2101 movs r1, #1
14d2: 438b bics r3, r1
14d4: 8113 strh r3, [r2, #8]
}
14d6: 4770 bx lr
14d8: 41005000 .word 0x41005000
000014dc <_usb_d_dev_set_address>:
hri_usbdevice_write_DADD_reg(USB, USB_DEVICE_DADD_ADDEN | USB_DEVICE_DADD_DADD(addr));
14dc: 2380 movs r3, #128 ; 0x80
14de: 4318 orrs r0, r3
((Usb *)hw)->DEVICE.DADD.reg = data;
14e0: 4b01 ldr r3, [pc, #4] ; (14e8 <_usb_d_dev_set_address+0xc>)
14e2: 7298 strb r0, [r3, #10]
}
14e4: 4770 bx lr
14e6: 46c0 nop ; (mov r8, r8)
14e8: 41005000 .word 0x41005000
000014ec <_usb_d_dev_ep_init>:
{
14ec: b5f0 push {r4, r5, r6, r7, lr}
uint8_t epn = USB_EP_GET_N(ep);
14ee: 240f movs r4, #15
14f0: 4004 ands r4, r0
14f2: b243 sxtb r3, r0
14f4: 469c mov ip, r3
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
14f6: 2c00 cmp r4, #0
14f8: d054 beq.n 15a4 <_usb_d_dev_ep_init+0xb8>
14fa: 0025 movs r5, r4
14fc: 2b00 cmp r3, #0
14fe: db07 blt.n 1510 <_usb_d_dev_ep_init+0x24>
uint8_t ep_type = attr & USB_EP_XTYPE_MASK;
1500: 2303 movs r3, #3
1502: 4019 ands r1, r3
const struct _usb_ep_cfg_item *pcfg = &_usb_ep_cfgs[epn];
1504: 0027 movs r7, r4
if (epn > CONF_USB_D_MAX_EP_N) {
1506: 2c02 cmp r4, #2
1508: d950 bls.n 15ac <_usb_d_dev_ep_init+0xc0>
return -USB_ERR_PARAM;
150a: 2012 movs r0, #18
150c: 4240 negs r0, r0
150e: e025 b.n 155c <_usb_d_dev_ep_init+0x70>
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
1510: 1ca5 adds r5, r4, #2
1512: e7f5 b.n 1500 <_usb_d_dev_ep_init+0x14>
if ((dir ? pcfg->i_cache : pcfg->cache) && ((dir ? pcfg->i_size : pcfg->size) < max_pkt_siz)) {
1514: 4663 mov r3, ip
1516: 2b00 cmp r3, #0
1518: db21 blt.n 155e <_usb_d_dev_ep_init+0x72>
151a: 007b lsls r3, r7, #1
151c: 19db adds r3, r3, r7
151e: 009b lsls r3, r3, #2
1520: 4c3b ldr r4, [pc, #236] ; (1610 <_usb_d_dev_ep_init+0x124>)
1522: 591b ldr r3, [r3, r4]
1524: 2b00 cmp r3, #0
1526: d166 bne.n 15f6 <_usb_d_dev_ep_init+0x10a>
ept->cache = (uint8_t *)(dir ? pcfg->i_cache : pcfg->cache);
1528: 007b lsls r3, r7, #1
152a: 19df adds r7, r3, r7
152c: 00bf lsls r7, r7, #2
152e: 4b38 ldr r3, [pc, #224] ; (1610 <_usb_d_dev_ep_init+0x124>)
1530: 58ff ldr r7, [r7, r3]
1532: 4b38 ldr r3, [pc, #224] ; (1614 <_usb_d_dev_ep_init+0x128>)
1534: 00ae lsls r6, r5, #2
1536: 1974 adds r4, r6, r5
1538: 00a4 lsls r4, r4, #2
153a: 191c adds r4, r3, r4
153c: 3480 adds r4, #128 ; 0x80
153e: 6027 str r7, [r4, #0]
ept->size = max_pkt_siz;
1540: 3360 adds r3, #96 ; 0x60
1542: 1974 adds r4, r6, r5
1544: 00a4 lsls r4, r4, #2
1546: 191c adds r4, r3, r4
1548: 84a2 strh r2, [r4, #36] ; 0x24
ept->flags.u8 = (ep_type + 1);
154a: 3427 adds r4, #39 ; 0x27
154c: 3101 adds r1, #1
154e: 7021 strb r1, [r4, #0]
ept->ep = ep;
1550: 1975 adds r5, r6, r5
1552: 00ad lsls r5, r5, #2
1554: 195b adds r3, r3, r5
1556: 3326 adds r3, #38 ; 0x26
1558: 7018 strb r0, [r3, #0]
return USB_OK;
155a: 2000 movs r0, #0
}
155c: bdf0 pop {r4, r5, r6, r7, pc}
if ((dir ? pcfg->i_cache : pcfg->cache) && ((dir ? pcfg->i_size : pcfg->size) < max_pkt_siz)) {
155e: 007b lsls r3, r7, #1
1560: 19db adds r3, r3, r7
1562: 009b lsls r3, r3, #2
1564: 4c2a ldr r4, [pc, #168] ; (1610 <_usb_d_dev_ep_init+0x124>)
1566: 18e3 adds r3, r4, r3
1568: 685b ldr r3, [r3, #4]
156a: 2b00 cmp r3, #0
156c: d106 bne.n 157c <_usb_d_dev_ep_init+0x90>
ept->cache = (uint8_t *)(dir ? pcfg->i_cache : pcfg->cache);
156e: 007b lsls r3, r7, #1
1570: 19df adds r7, r3, r7
1572: 00bf lsls r7, r7, #2
1574: 4b26 ldr r3, [pc, #152] ; (1610 <_usb_d_dev_ep_init+0x124>)
1576: 19df adds r7, r3, r7
1578: 687f ldr r7, [r7, #4]
157a: e7da b.n 1532 <_usb_d_dev_ep_init+0x46>
if ((dir ? pcfg->i_cache : pcfg->cache) && ((dir ? pcfg->i_size : pcfg->size) < max_pkt_siz)) {
157c: 007b lsls r3, r7, #1
157e: 19db adds r3, r3, r7
1580: 009b lsls r3, r3, #2
1582: 4c23 ldr r4, [pc, #140] ; (1610 <_usb_d_dev_ep_init+0x124>)
1584: 18e3 adds r3, r4, r3
1586: 895b ldrh r3, [r3, #10]
1588: 4293 cmp r3, r2
158a: daf0 bge.n 156e <_usb_d_dev_ep_init+0x82>
return -USB_ERR_FUNC;
158c: 2013 movs r0, #19
158e: 4240 negs r0, r0
1590: e7e4 b.n 155c <_usb_d_dev_ep_init+0x70>
return -USB_ERR_REDO;
1592: 2014 movs r0, #20
1594: 4240 negs r0, r0
1596: e7e1 b.n 155c <_usb_d_dev_ep_init+0x70>
return -USB_ERR_REDO;
1598: 2014 movs r0, #20
159a: 4240 negs r0, r0
159c: e7de b.n 155c <_usb_d_dev_ep_init+0x70>
return -USB_ERR_FUNC;
159e: 2013 movs r0, #19
15a0: 4240 negs r0, r0
15a2: e7db b.n 155c <_usb_d_dev_ep_init+0x70>
uint8_t ep_type = attr & USB_EP_XTYPE_MASK;
15a4: 2303 movs r3, #3
15a6: 4019 ands r1, r3
return &dev_inst.ep[ep_index];
15a8: 2500 movs r5, #0
const struct _usb_ep_cfg_item *pcfg = &_usb_ep_cfgs[epn];
15aa: 2700 movs r7, #0
if (ept->ep != 0xFF) {
15ac: 00ab lsls r3, r5, #2
15ae: 195b adds r3, r3, r5
15b0: 009e lsls r6, r3, #2
15b2: 4b18 ldr r3, [pc, #96] ; (1614 <_usb_d_dev_ep_init+0x128>)
15b4: 199b adds r3, r3, r6
15b6: 3386 adds r3, #134 ; 0x86
15b8: 781b ldrb r3, [r3, #0]
15ba: 2bff cmp r3, #255 ; 0xff
15bc: d1e9 bne.n 1592 <_usb_d_dev_ep_init+0xa6>
if (ep_type == USB_EP_XTYPE_CTRL) {
15be: 2900 cmp r1, #0
15c0: d1a8 bne.n 1514 <_usb_d_dev_ep_init+0x28>
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
15c2: 2c00 cmp r4, #0
15c4: d004 beq.n 15d0 <_usb_d_dev_ep_init+0xe4>
15c6: 4663 mov r3, ip
15c8: 2b00 cmp r3, #0
15ca: db01 blt.n 15d0 <_usb_d_dev_ep_init+0xe4>
15cc: 3402 adds r4, #2
15ce: b2e4 uxtb r4, r4
if (ept_in->ep != 0xFF) {
15d0: 00a3 lsls r3, r4, #2
15d2: 191b adds r3, r3, r4
15d4: 009b lsls r3, r3, #2
15d6: 4c0f ldr r4, [pc, #60] ; (1614 <_usb_d_dev_ep_init+0x128>)
15d8: 18e4 adds r4, r4, r3
15da: 3486 adds r4, #134 ; 0x86
15dc: 7823 ldrb r3, [r4, #0]
15de: 2bff cmp r3, #255 ; 0xff
15e0: d1da bne.n 1598 <_usb_d_dev_ep_init+0xac>
if (pcfg->cache == NULL) {
15e2: 007b lsls r3, r7, #1
15e4: 19db adds r3, r3, r7
15e6: 009b lsls r3, r3, #2
15e8: 4c09 ldr r4, [pc, #36] ; (1610 <_usb_d_dev_ep_init+0x124>)
15ea: 591b ldr r3, [r3, r4]
15ec: 2b00 cmp r3, #0
15ee: d0d6 beq.n 159e <_usb_d_dev_ep_init+0xb2>
if ((dir ? pcfg->i_cache : pcfg->cache) && ((dir ? pcfg->i_size : pcfg->size) < max_pkt_siz)) {
15f0: 4663 mov r3, ip
15f2: 2b00 cmp r3, #0
15f4: dbb3 blt.n 155e <_usb_d_dev_ep_init+0x72>
15f6: 007b lsls r3, r7, #1
15f8: 19db adds r3, r3, r7
15fa: 009b lsls r3, r3, #2
15fc: 4c04 ldr r4, [pc, #16] ; (1610 <_usb_d_dev_ep_init+0x124>)
15fe: 18e3 adds r3, r4, r3
1600: 891b ldrh r3, [r3, #8]
1602: 4293 cmp r3, r2
1604: db00 blt.n 1608 <_usb_d_dev_ep_init+0x11c>
1606: e78f b.n 1528 <_usb_d_dev_ep_init+0x3c>
return -USB_ERR_FUNC;
1608: 2013 movs r0, #19
160a: 4240 negs r0, r0
160c: e7a6 b.n 155c <_usb_d_dev_ep_init+0x70>
160e: 46c0 nop ; (mov r8, r8)
1610: 00002c58 .word 0x00002c58
1614: 20000104 .word 0x20000104
00001618 <_usb_d_dev_ep_deinit>:
{
1618: b5f8 push {r3, r4, r5, r6, r7, lr}
161a: 0005 movs r5, r0
uint8_t epn = USB_EP_GET_N(ep);
161c: 240f movs r4, #15
161e: 4004 ands r4, r0
1620: b247 sxtb r7, r0
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
1622: 2c00 cmp r4, #0
1624: d010 beq.n 1648 <_usb_d_dev_ep_deinit+0x30>
1626: 0020 movs r0, r4
1628: 2f00 cmp r7, #0
162a: db02 blt.n 1632 <_usb_d_dev_ep_deinit+0x1a>
if (epn > CONF_USB_D_MAX_EP_N || !_usb_d_dev_ep_is_used(ept)) {
162c: 2c02 cmp r4, #2
162e: d902 bls.n 1636 <_usb_d_dev_ep_deinit+0x1e>
}
1630: bdf8 pop {r3, r4, r5, r6, r7, pc}
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
1632: 1ca0 adds r0, r4, #2
1634: e7fa b.n 162c <_usb_d_dev_ep_deinit+0x14>
return &dev_inst.ep[ep_index];
1636: 0006 movs r6, r0
1638: 3001 adds r0, #1
163a: 0083 lsls r3, r0, #2
163c: 1818 adds r0, r3, r0
163e: 0080 lsls r0, r0, #2
1640: 4b25 ldr r3, [pc, #148] ; (16d8 <_usb_d_dev_ep_deinit+0xc0>)
1642: 3360 adds r3, #96 ; 0x60
1644: 1818 adds r0, r3, r0
1646: e002 b.n 164e <_usb_d_dev_ep_deinit+0x36>
1648: 4823 ldr r0, [pc, #140] ; (16d8 <_usb_d_dev_ep_deinit+0xc0>)
164a: 3074 adds r0, #116 ; 0x74
164c: 2600 movs r6, #0
if (epn > CONF_USB_D_MAX_EP_N || !_usb_d_dev_ep_is_used(ept)) {
164e: 00b3 lsls r3, r6, #2
1650: 199b adds r3, r3, r6
1652: 009a lsls r2, r3, #2
1654: 4b20 ldr r3, [pc, #128] ; (16d8 <_usb_d_dev_ep_deinit+0xc0>)
1656: 189b adds r3, r3, r2
1658: 3386 adds r3, #134 ; 0x86
165a: 781b ldrb r3, [r3, #0]
165c: 2bff cmp r3, #255 ; 0xff
165e: d0e7 beq.n 1630 <_usb_d_dev_ep_deinit+0x18>
_usb_d_dev_trans_stop(ept, dir, USB_TRANS_RESET);
1660: 0ff9 lsrs r1, r7, #31
1662: 2203 movs r2, #3
1664: 4b1d ldr r3, [pc, #116] ; (16dc <_usb_d_dev_ep_deinit+0xc4>)
1666: 4798 blx r3
if (_usb_d_dev_ep_is_ctrl(ept)) {
1668: 00b3 lsls r3, r6, #2
166a: 199b adds r3, r3, r6
166c: 009a lsls r2, r3, #2
166e: 4b1a ldr r3, [pc, #104] ; (16d8 <_usb_d_dev_ep_deinit+0xc0>)
1670: 189b adds r3, r3, r2
1672: 3380 adds r3, #128 ; 0x80
1674: 79da ldrb r2, [r3, #7]
1676: 2307 movs r3, #7
1678: 4013 ands r3, r2
167a: 2b01 cmp r3, #1
167c: d01b beq.n 16b6 <_usb_d_dev_ep_deinit+0x9e>
} else if (USB_EP_GET_DIR(ep)) {
167e: 2f00 cmp r7, #0
1680: db1f blt.n 16c2 <_usb_d_dev_ep_deinit+0xaa>
1682: 016d lsls r5, r5, #5
1684: 4b16 ldr r3, [pc, #88] ; (16e0 <_usb_d_dev_ep_deinit+0xc8>)
1686: 469c mov ip, r3
1688: 4465 add r5, ip
hw->DEVICE.DeviceEndpoint[ep].EPCFG.reg &= ~USB_DEVICE_EPCFG_EPTYPE0_Msk;
168a: 2280 movs r2, #128 ; 0x80
168c: 0052 lsls r2, r2, #1
168e: 5cab ldrb r3, [r5, r2]
1690: 2107 movs r1, #7
1692: 438b bics r3, r1
1694: 54ab strb r3, [r5, r2]
ept->flags.u8 = 0;
1696: 4b10 ldr r3, [pc, #64] ; (16d8 <_usb_d_dev_ep_deinit+0xc0>)
1698: 3360 adds r3, #96 ; 0x60
169a: 00b1 lsls r1, r6, #2
169c: 198a adds r2, r1, r6
169e: 0092 lsls r2, r2, #2
16a0: 189a adds r2, r3, r2
16a2: 3227 adds r2, #39 ; 0x27
16a4: 2000 movs r0, #0
16a6: 7010 strb r0, [r2, #0]
ept->ep = 0xFF;
16a8: 198e adds r6, r1, r6
16aa: 00b6 lsls r6, r6, #2
16ac: 199b adds r3, r3, r6
16ae: 3326 adds r3, #38 ; 0x26
16b0: 22ff movs r2, #255 ; 0xff
16b2: 701a strb r2, [r3, #0]
16b4: e7bc b.n 1630 <_usb_d_dev_ep_deinit+0x18>
hw->DEVICE.DeviceEndpoint[ep].EPCFG.reg = 0;
16b6: 3508 adds r5, #8
16b8: 016d lsls r5, r5, #5
16ba: 2200 movs r2, #0
16bc: 4b08 ldr r3, [pc, #32] ; (16e0 <_usb_d_dev_ep_deinit+0xc8>)
16be: 54ea strb r2, [r5, r3]
16c0: e7e9 b.n 1696 <_usb_d_dev_ep_deinit+0x7e>
16c2: 0164 lsls r4, r4, #5
16c4: 4b06 ldr r3, [pc, #24] ; (16e0 <_usb_d_dev_ep_deinit+0xc8>)
16c6: 469c mov ip, r3
16c8: 4464 add r4, ip
hw->DEVICE.DeviceEndpoint[USB_EP_GET_N(ep)].EPCFG.reg &= ~USB_DEVICE_EPCFG_EPTYPE1_Msk;
16ca: 2280 movs r2, #128 ; 0x80
16cc: 0052 lsls r2, r2, #1
16ce: 5ca3 ldrb r3, [r4, r2]
16d0: 2170 movs r1, #112 ; 0x70
16d2: 438b bics r3, r1
16d4: 54a3 strb r3, [r4, r2]
16d6: e7de b.n 1696 <_usb_d_dev_ep_deinit+0x7e>
16d8: 20000104 .word 0x20000104
16dc: 00000e15 .word 0x00000e15
16e0: 41005000 .word 0x41005000
000016e4 <_usb_d_dev_ep_enable>:
{
16e4: b5f0 push {r4, r5, r6, r7, lr}
16e6: 46c6 mov lr, r8
16e8: b500 push {lr}
uint8_t epn = USB_EP_GET_N(ep);
16ea: 220f movs r2, #15
16ec: 4002 ands r2, r0
16ee: b240 sxtb r0, r0
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
16f0: 2a00 cmp r2, #0
16f2: d100 bne.n 16f6 <_usb_d_dev_ep_enable+0x12>
16f4: e092 b.n 181c <_usb_d_dev_ep_enable+0x138>
16f6: 0013 movs r3, r2
16f8: 2800 cmp r0, #0
16fa: db0b blt.n 1714 <_usb_d_dev_ep_enable+0x30>
return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg;
16fc: 0011 movs r1, r2
16fe: 3208 adds r2, #8
1700: 0152 lsls r2, r2, #5
1702: 4caa ldr r4, [pc, #680] ; (19ac <_usb_d_dev_ep_enable+0x2c8>)
1704: 5d15 ldrb r5, [r2, r4]
1706: b2ed uxtb r5, r5
if (epn > CONF_USB_D_MAX_EP_N || !_usb_d_dev_ep_is_used(ept)) {
1708: 2902 cmp r1, #2
170a: d800 bhi.n 170e <_usb_d_dev_ep_enable+0x2a>
170c: e08d b.n 182a <_usb_d_dev_ep_enable+0x146>
return -USB_ERR_PARAM;
170e: 2012 movs r0, #18
1710: 4240 negs r0, r0
1712: e0e5 b.n 18e0 <_usb_d_dev_ep_enable+0x1fc>
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
1714: 1c93 adds r3, r2, #2
1716: e7f1 b.n 16fc <_usb_d_dev_ep_enable+0x18>
if (epcfg & (USB_DEVICE_EPCFG_EPTYPE1_Msk | USB_DEVICE_EPCFG_EPTYPE0_Msk)) {
1718: 3276 adds r2, #118 ; 0x76
171a: 422a tst r2, r5
171c: d175 bne.n 180a <_usb_d_dev_ep_enable+0x126>
171e: 4aa3 ldr r2, [pc, #652] ; (19ac <_usb_d_dev_ep_enable+0x2c8>)
1720: 4690 mov r8, r2
1722: 4444 add r4, r8
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg = data;
1724: 2011 movs r0, #17
1726: 2280 movs r2, #128 ; 0x80
1728: 0052 lsls r2, r2, #1
172a: 54a0 strb r0, [r4, r2]
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
172c: 009a lsls r2, r3, #2
172e: 18d2 adds r2, r2, r3
1730: 0095 lsls r5, r2, #2
1732: 4a9f ldr r2, [pc, #636] ; (19b0 <_usb_d_dev_ep_enable+0x2cc>)
1734: 3260 adds r2, #96 ; 0x60
1736: 1952 adds r2, r2, r5
1738: 8c92 ldrh r2, [r2, #36] ; 0x24
173a: 0395 lsls r5, r2, #14
173c: 489d ldr r0, [pc, #628] ; (19b4 <_usb_d_dev_ep_enable+0x2d0>)
173e: 4005 ands r5, r0
: ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0)))))));
1740: 2080 movs r0, #128 ; 0x80
1742: 0080 lsls r0, r0, #2
1744: 4282 cmp r2, r0
1746: d900 bls.n 174a <_usb_d_dev_ep_enable+0x66>
1748: e0cd b.n 18e6 <_usb_d_dev_ep_enable+0x202>
174a: 3801 subs r0, #1
174c: 38ff subs r0, #255 ; 0xff
174e: 4282 cmp r2, r0
1750: d900 bls.n 1754 <_usb_d_dev_ep_enable+0x70>
1752: e113 b.n 197c <_usb_d_dev_ep_enable+0x298>
1754: 2a80 cmp r2, #128 ; 0x80
1756: d900 bls.n 175a <_usb_d_dev_ep_enable+0x76>
1758: e100 b.n 195c <_usb_d_dev_ep_enable+0x278>
175a: 2a40 cmp r2, #64 ; 0x40
175c: d900 bls.n 1760 <_usb_d_dev_ep_enable+0x7c>
175e: e115 b.n 198c <_usb_d_dev_ep_enable+0x2a8>
1760: 2a20 cmp r2, #32
1762: d900 bls.n 1766 <_usb_d_dev_ep_enable+0x82>
1764: e102 b.n 196c <_usb_d_dev_ep_enable+0x288>
1766: 2a10 cmp r2, #16
1768: d900 bls.n 176c <_usb_d_dev_ep_enable+0x88>
176a: e117 b.n 199c <_usb_d_dev_ep_enable+0x2b8>
176c: 38f8 subs r0, #248 ; 0xf8
176e: 4290 cmp r0, r2
1770: 4180 sbcs r0, r0
1772: 4240 negs r0, r0
| USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
1774: 0706 lsls r6, r0, #28
1776: 4335 orrs r5, r6
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
1778: 607d str r5, [r7, #4]
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
177a: 0495 lsls r5, r2, #18
177c: 0cad lsrs r5, r5, #18
177e: e0b9 b.n 18f4 <_usb_d_dev_ep_enable+0x210>
if (epcfg & USB_DEVICE_EPCFG_EPTYPE1_Msk) {
1780: 2270 movs r2, #112 ; 0x70
1782: 422a tst r2, r5
1784: d144 bne.n 1810 <_usb_d_dev_ep_enable+0x12c>
epcfg |= USB_DEVICE_EPCFG_EPTYPE1(ept->flags.bits.eptype);
1786: 488a ldr r0, [pc, #552] ; (19b0 <_usb_d_dev_ep_enable+0x2cc>)
1788: 009e lsls r6, r3, #2
178a: 18f2 adds r2, r6, r3
178c: 0092 lsls r2, r2, #2
178e: 1882 adds r2, r0, r2
1790: 3280 adds r2, #128 ; 0x80
1792: 79d2 ldrb r2, [r2, #7]
1794: 0752 lsls r2, r2, #29
1796: 0e52 lsrs r2, r2, #25
1798: 4315 orrs r5, r2
179a: 4a84 ldr r2, [pc, #528] ; (19ac <_usb_d_dev_ep_enable+0x2c8>)
179c: 4694 mov ip, r2
179e: 4464 add r4, ip
17a0: 2280 movs r2, #128 ; 0x80
17a2: 0052 lsls r2, r2, #1
17a4: 54a5 strb r5, [r4, r2]
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
17a6: 3060 adds r0, #96 ; 0x60
17a8: 18f6 adds r6, r6, r3
17aa: 00b6 lsls r6, r6, #2
17ac: 1980 adds r0, r0, r6
17ae: 8c80 ldrh r0, [r0, #36] ; 0x24
17b0: 0485 lsls r5, r0, #18
17b2: 0cad lsrs r5, r5, #18
: ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0)))))));
17b4: 3201 adds r2, #1
17b6: 32ff adds r2, #255 ; 0xff
17b8: 2307 movs r3, #7
17ba: 4290 cmp r0, r2
17bc: d814 bhi.n 17e8 <_usb_d_dev_ep_enable+0x104>
17be: 3a01 subs r2, #1
17c0: 3aff subs r2, #255 ; 0xff
17c2: 3b01 subs r3, #1
17c4: 4290 cmp r0, r2
17c6: d80f bhi.n 17e8 <_usb_d_dev_ep_enable+0x104>
17c8: 3b01 subs r3, #1
17ca: 2880 cmp r0, #128 ; 0x80
17cc: d80c bhi.n 17e8 <_usb_d_dev_ep_enable+0x104>
17ce: 3b01 subs r3, #1
17d0: 2840 cmp r0, #64 ; 0x40
17d2: d809 bhi.n 17e8 <_usb_d_dev_ep_enable+0x104>
17d4: 3b01 subs r3, #1
17d6: 2820 cmp r0, #32
17d8: d806 bhi.n 17e8 <_usb_d_dev_ep_enable+0x104>
17da: 3b01 subs r3, #1
17dc: 2810 cmp r0, #16
17de: d803 bhi.n 17e8 <_usb_d_dev_ep_enable+0x104>
17e0: 3af8 subs r2, #248 ; 0xf8
17e2: 4282 cmp r2, r0
17e4: 4192 sbcs r2, r2
17e6: 4253 negs r3, r2
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
17e8: 071b lsls r3, r3, #28
17ea: 432b orrs r3, r5
17ec: 617b str r3, [r7, #20]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask;
17ee: 2280 movs r2, #128 ; 0x80
17f0: 2382 movs r3, #130 ; 0x82
17f2: 005b lsls r3, r3, #1
17f4: 54e2 strb r2, [r4, r3]
bank->STATUS_BK.reg = 0;
17f6: 0149 lsls r1, r1, #5
17f8: 4b6d ldr r3, [pc, #436] ; (19b0 <_usb_d_dev_ep_enable+0x2cc>)
17fa: 1859 adds r1, r3, r1
17fc: 2300 movs r3, #0
17fe: 768b strb r3, [r1, #26]
return USB_OK;
1800: 2000 movs r0, #0
1802: e06d b.n 18e0 <_usb_d_dev_ep_enable+0x1fc>
return -USB_ERR_PARAM;
1804: 2012 movs r0, #18
1806: 4240 negs r0, r0
1808: e06a b.n 18e0 <_usb_d_dev_ep_enable+0x1fc>
return -USB_ERR_REDO;
180a: 2014 movs r0, #20
180c: 4240 negs r0, r0
180e: e067 b.n 18e0 <_usb_d_dev_ep_enable+0x1fc>
return -USB_ERR_REDO;
1810: 2014 movs r0, #20
1812: 4240 negs r0, r0
1814: e064 b.n 18e0 <_usb_d_dev_ep_enable+0x1fc>
return -USB_ERR_REDO;
1816: 2014 movs r0, #20
1818: 4240 negs r0, r0
181a: e061 b.n 18e0 <_usb_d_dev_ep_enable+0x1fc>
return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg;
181c: 2380 movs r3, #128 ; 0x80
181e: 005b lsls r3, r3, #1
1820: 4a62 ldr r2, [pc, #392] ; (19ac <_usb_d_dev_ep_enable+0x2c8>)
1822: 5cd5 ldrb r5, [r2, r3]
1824: b2ed uxtb r5, r5
1826: 2100 movs r1, #0
return &dev_inst.ep[ep_index];
1828: 2300 movs r3, #0
if (epn > CONF_USB_D_MAX_EP_N || !_usb_d_dev_ep_is_used(ept)) {
182a: 009a lsls r2, r3, #2
182c: 18d2 adds r2, r2, r3
182e: 0094 lsls r4, r2, #2
1830: 4a5f ldr r2, [pc, #380] ; (19b0 <_usb_d_dev_ep_enable+0x2cc>)
1832: 1912 adds r2, r2, r4
1834: 3286 adds r2, #134 ; 0x86
1836: 7812 ldrb r2, [r2, #0]
1838: 4694 mov ip, r2
183a: 2aff cmp r2, #255 ; 0xff
183c: d0e2 beq.n 1804 <_usb_d_dev_ep_enable+0x120>
183e: 014c lsls r4, r1, #5
bank = prvt_inst.desc_table[epn].DeviceDescBank;
1840: 4a5b ldr r2, [pc, #364] ; (19b0 <_usb_d_dev_ep_enable+0x2cc>)
1842: 1917 adds r7, r2, r4
if (ept->flags.bits.eptype == USB_D_EPTYPE_CTRL) {
1844: 009e lsls r6, r3, #2
1846: 18f6 adds r6, r6, r3
1848: 00b6 lsls r6, r6, #2
184a: 1992 adds r2, r2, r6
184c: 3280 adds r2, #128 ; 0x80
184e: 79d6 ldrb r6, [r2, #7]
1850: 2207 movs r2, #7
1852: 4032 ands r2, r6
1854: 2a01 cmp r2, #1
1856: d100 bne.n 185a <_usb_d_dev_ep_enable+0x176>
1858: e75e b.n 1718 <_usb_d_dev_ep_enable+0x34>
} else if (dir) {
185a: 2800 cmp r0, #0
185c: db90 blt.n 1780 <_usb_d_dev_ep_enable+0x9c>
if (epcfg & USB_DEVICE_EPCFG_EPTYPE0_Msk) {
185e: 076a lsls r2, r5, #29
1860: d1d9 bne.n 1816 <_usb_d_dev_ep_enable+0x132>
epcfg |= USB_DEVICE_EPCFG_EPTYPE0(ept->flags.bits.eptype);
1862: 4853 ldr r0, [pc, #332] ; (19b0 <_usb_d_dev_ep_enable+0x2cc>)
1864: 009e lsls r6, r3, #2
1866: 18f2 adds r2, r6, r3
1868: 0092 lsls r2, r2, #2
186a: 1882 adds r2, r0, r2
186c: 3280 adds r2, #128 ; 0x80
186e: 79d2 ldrb r2, [r2, #7]
1870: 0752 lsls r2, r2, #29
1872: 0f52 lsrs r2, r2, #29
1874: 4315 orrs r5, r2
1876: 4a4d ldr r2, [pc, #308] ; (19ac <_usb_d_dev_ep_enable+0x2c8>)
1878: 4694 mov ip, r2
187a: 4464 add r4, ip
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg = data;
187c: 2280 movs r2, #128 ; 0x80
187e: 0052 lsls r2, r2, #1
1880: 54a5 strb r5, [r4, r2]
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
1882: 3060 adds r0, #96 ; 0x60
1884: 18f6 adds r6, r6, r3
1886: 00b6 lsls r6, r6, #2
1888: 1980 adds r0, r0, r6
188a: 8c85 ldrh r5, [r0, #36] ; 0x24
188c: 03ab lsls r3, r5, #14
188e: 4849 ldr r0, [pc, #292] ; (19b4 <_usb_d_dev_ep_enable+0x2d0>)
1890: 4018 ands r0, r3
: ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0)))))));
1892: 3201 adds r2, #1
1894: 32ff adds r2, #255 ; 0xff
1896: 2307 movs r3, #7
1898: 4295 cmp r5, r2
189a: d814 bhi.n 18c6 <_usb_d_dev_ep_enable+0x1e2>
189c: 3a01 subs r2, #1
189e: 3aff subs r2, #255 ; 0xff
18a0: 3b01 subs r3, #1
18a2: 4295 cmp r5, r2
18a4: d80f bhi.n 18c6 <_usb_d_dev_ep_enable+0x1e2>
18a6: 3b01 subs r3, #1
18a8: 2d80 cmp r5, #128 ; 0x80
18aa: d80c bhi.n 18c6 <_usb_d_dev_ep_enable+0x1e2>
18ac: 3b01 subs r3, #1
18ae: 2d40 cmp r5, #64 ; 0x40
18b0: d809 bhi.n 18c6 <_usb_d_dev_ep_enable+0x1e2>
18b2: 3b01 subs r3, #1
18b4: 2d20 cmp r5, #32
18b6: d806 bhi.n 18c6 <_usb_d_dev_ep_enable+0x1e2>
18b8: 3b01 subs r3, #1
18ba: 2d10 cmp r5, #16
18bc: d803 bhi.n 18c6 <_usb_d_dev_ep_enable+0x1e2>
18be: 3af8 subs r2, #248 ; 0xf8
18c0: 42aa cmp r2, r5
18c2: 4192 sbcs r2, r2
18c4: 4253 negs r3, r2
| USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
18c6: 071b lsls r3, r3, #28
18c8: 4303 orrs r3, r0
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
18ca: 607b str r3, [r7, #4]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask;
18cc: 2240 movs r2, #64 ; 0x40
18ce: 2306 movs r3, #6
18d0: 33ff adds r3, #255 ; 0xff
18d2: 54e2 strb r2, [r4, r3]
bank->STATUS_BK.reg = 0;
18d4: 0149 lsls r1, r1, #5
18d6: 4b36 ldr r3, [pc, #216] ; (19b0 <_usb_d_dev_ep_enable+0x2cc>)
18d8: 1859 adds r1, r3, r1
18da: 2300 movs r3, #0
18dc: 728b strb r3, [r1, #10]
return USB_OK;
18de: 2000 movs r0, #0
}
18e0: bc04 pop {r2}
18e2: 4690 mov r8, r2
18e4: bdf0 pop {r4, r5, r6, r7, pc}
| USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
18e6: 20e0 movs r0, #224 ; 0xe0
18e8: 05c0 lsls r0, r0, #23
18ea: 4305 orrs r5, r0
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
18ec: 607d str r5, [r7, #4]
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
18ee: 0495 lsls r5, r2, #18
18f0: 0cad lsrs r5, r5, #18
: ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0)))))));
18f2: 2007 movs r0, #7
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
18f4: 0700 lsls r0, r0, #28
18f6: 4328 orrs r0, r5
18f8: 6178 str r0, [r7, #20]
18fa: 2506 movs r5, #6
18fc: 35ff adds r5, #255 ; 0xff
18fe: 2640 movs r6, #64 ; 0x40
1900: 5566 strb r6, [r4, r5]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask;
1902: 2782 movs r7, #130 ; 0x82
1904: 007f lsls r7, r7, #1
1906: 2080 movs r0, #128 ; 0x80
1908: 55e0 strb r0, [r4, r7]
bank->STATUS_BK.reg = 0;
190a: 4829 ldr r0, [pc, #164] ; (19b0 <_usb_d_dev_ep_enable+0x2cc>)
190c: 0149 lsls r1, r1, #5
190e: 1841 adds r1, r0, r1
1910: 2400 movs r4, #0
1912: 728c strb r4, [r1, #10]
1914: 768c strb r4, [r1, #26]
uint8_t epn = USB_EP_GET_N(ept->ep);
1916: 340f adds r4, #15
1918: 4661 mov r1, ip
191a: 400c ands r4, r1
_usbd_ep_set_buf(epn, 0, (uint32_t)ept->cache);
191c: 0099 lsls r1, r3, #2
191e: 18c9 adds r1, r1, r3
1920: 0089 lsls r1, r1, #2
1922: 1841 adds r1, r0, r1
1924: 3180 adds r1, #128 ; 0x80
1926: 6809 ldr r1, [r1, #0]
bank->ADDR.reg = addr;
1928: 0163 lsls r3, r4, #5
192a: 5019 str r1, [r3, r0]
bank->PCKSIZE.bit.MULTI_PACKET_SIZE = size;
192c: 18c0 adds r0, r0, r3
192e: 6841 ldr r1, [r0, #4]
1930: 0492 lsls r2, r2, #18
1932: 0914 lsrs r4, r2, #4
1934: 4a20 ldr r2, [pc, #128] ; (19b8 <_usb_d_dev_ep_enable+0x2d4>)
1936: 400a ands r2, r1
1938: 4322 orrs r2, r4
193a: 6042 str r2, [r0, #4]
bank->PCKSIZE.bit.BYTE_COUNT = count;
193c: 6842 ldr r2, [r0, #4]
193e: 0b92 lsrs r2, r2, #14
1940: 0392 lsls r2, r2, #14
1942: 6042 str r2, [r0, #4]
1944: 4a19 ldr r2, [pc, #100] ; (19ac <_usb_d_dev_ep_enable+0x2c8>)
1946: 189a adds r2, r3, r2
1948: 21b0 movs r1, #176 ; 0xb0
194a: 55d1 strb r1, [r2, r7]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask;
194c: 5556 strb r6, [r2, r5]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENSET.reg = mask;
194e: 4a1b ldr r2, [pc, #108] ; (19bc <_usb_d_dev_ep_enable+0x2d8>)
1950: 4694 mov ip, r2
1952: 4463 add r3, ip
1954: 2210 movs r2, #16
1956: 701a strb r2, [r3, #0]
return USB_OK;
1958: 2000 movs r0, #0
195a: e7c1 b.n 18e0 <_usb_d_dev_ep_enable+0x1fc>
| USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
195c: 20a0 movs r0, #160 ; 0xa0
195e: 05c0 lsls r0, r0, #23
1960: 4305 orrs r5, r0
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
1962: 607d str r5, [r7, #4]
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
1964: 0495 lsls r5, r2, #18
1966: 0cad lsrs r5, r5, #18
: ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0)))))));
1968: 2005 movs r0, #5
196a: e7c3 b.n 18f4 <_usb_d_dev_ep_enable+0x210>
| USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
196c: 20c0 movs r0, #192 ; 0xc0
196e: 0580 lsls r0, r0, #22
1970: 4305 orrs r5, r0
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
1972: 607d str r5, [r7, #4]
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
1974: 0495 lsls r5, r2, #18
1976: 0cad lsrs r5, r5, #18
: ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0)))))));
1978: 2003 movs r0, #3
197a: e7bb b.n 18f4 <_usb_d_dev_ep_enable+0x210>
| USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
197c: 20c0 movs r0, #192 ; 0xc0
197e: 05c0 lsls r0, r0, #23
1980: 4305 orrs r5, r0
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
1982: 607d str r5, [r7, #4]
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
1984: 0495 lsls r5, r2, #18
1986: 0cad lsrs r5, r5, #18
: ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0)))))));
1988: 2006 movs r0, #6
198a: e7b3 b.n 18f4 <_usb_d_dev_ep_enable+0x210>
| USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
198c: 2080 movs r0, #128 ; 0x80
198e: 05c0 lsls r0, r0, #23
1990: 4305 orrs r5, r0
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
1992: 607d str r5, [r7, #4]
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
1994: 0495 lsls r5, r2, #18
1996: 0cad lsrs r5, r5, #18
: ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0)))))));
1998: 2004 movs r0, #4
199a: e7ab b.n 18f4 <_usb_d_dev_ep_enable+0x210>
| USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
199c: 2080 movs r0, #128 ; 0x80
199e: 0580 lsls r0, r0, #22
19a0: 4305 orrs r5, r0
bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size)
19a2: 607d str r5, [r7, #4]
= USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size));
19a4: 0495 lsls r5, r2, #18
19a6: 0cad lsrs r5, r5, #18
: ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0)))))));
19a8: 2002 movs r0, #2
19aa: e7a3 b.n 18f4 <_usb_d_dev_ep_enable+0x210>
19ac: 41005000 .word 0x41005000
19b0: 20000104 .word 0x20000104
19b4: 0fffc000 .word 0x0fffc000
19b8: f0003fff .word 0xf0003fff
19bc: 41005109 .word 0x41005109
000019c0 <_usb_d_dev_ep_stall>:
{
19c0: b5f0 push {r4, r5, r6, r7, lr}
uint8_t epn = USB_EP_GET_N(ep);
19c2: 230f movs r3, #15
19c4: 4003 ands r3, r0
19c6: b240 sxtb r0, r0
bool dir = USB_EP_GET_DIR(ep);
19c8: 0fc4 lsrs r4, r0, #31
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
19ca: 2b00 cmp r3, #0
19cc: d009 beq.n 19e2 <_usb_d_dev_ep_stall+0x22>
19ce: 001a movs r2, r3
19d0: 2800 cmp r0, #0
19d2: db04 blt.n 19de <_usb_d_dev_ep_stall+0x1e>
if (epn > CONF_USB_D_MAX_EP_N) {
19d4: 2b02 cmp r3, #2
19d6: d905 bls.n 19e4 <_usb_d_dev_ep_stall+0x24>
return -USB_ERR_PARAM;
19d8: 2012 movs r0, #18
19da: 4240 negs r0, r0
19dc: e019 b.n 1a12 <_usb_d_dev_ep_stall+0x52>
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
19de: 1c9a adds r2, r3, #2
19e0: e7f8 b.n 19d4 <_usb_d_dev_ep_stall+0x14>
return &dev_inst.ep[ep_index];
19e2: 2200 movs r2, #0
if (USB_EP_STALL_SET == ctrl) {
19e4: 2901 cmp r1, #1
19e6: d015 beq.n 1a14 <_usb_d_dev_ep_stall+0x54>
} else if (USB_EP_STALL_CLR == ctrl) {
19e8: 2900 cmp r1, #0
19ea: d036 beq.n 1a5a <_usb_d_dev_ep_stall+0x9a>
uint8_t epn = USB_EP_GET_N(ept->ep);
19ec: 0093 lsls r3, r2, #2
19ee: 189b adds r3, r3, r2
19f0: 009b lsls r3, r3, #2
19f2: 4a47 ldr r2, [pc, #284] ; (1b10 <_usb_d_dev_ep_stall+0x150>)
19f4: 18d2 adds r2, r2, r3
19f6: 3286 adds r2, #134 ; 0x86
19f8: 7812 ldrb r2, [r2, #0]
return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUS.reg;
19fa: 230f movs r3, #15
19fc: 4013 ands r3, r2
19fe: 015b lsls r3, r3, #5
1a00: 4a44 ldr r2, [pc, #272] ; (1b14 <_usb_d_dev_ep_stall+0x154>)
1a02: 4694 mov ip, r2
1a04: 4463 add r3, ip
1a06: 7998 ldrb r0, [r3, #6]
return (hri_usbendpoint_read_EPSTATUS_reg(hw, epn) & (USB_DEVICE_EPSTATUS_STALLRQ0 << bank_n));
1a08: 2310 movs r3, #16
1a0a: 40a3 lsls r3, r4
1a0c: 4018 ands r0, r3
return _usbd_ep_is_stalled(epn, dir);
1a0e: 1e43 subs r3, r0, #1
1a10: 4198 sbcs r0, r3
}
1a12: bdf0 pop {r4, r5, r6, r7, pc}
hri_usbendpoint_set_EPSTATUS_reg(USB, epn, (USB_DEVICE_EPSTATUS_STALLRQ0 << bank_n));
1a14: 2510 movs r5, #16
1a16: 40a5 lsls r5, r4
1a18: b2ed uxtb r5, r5
uint8_t epn = USB_EP_GET_N(ept->ep);
1a1a: 493d ldr r1, [pc, #244] ; (1b10 <_usb_d_dev_ep_stall+0x150>)
1a1c: 0090 lsls r0, r2, #2
1a1e: 1883 adds r3, r0, r2
1a20: 009b lsls r3, r3, #2
1a22: 18cb adds r3, r1, r3
1a24: 3386 adds r3, #134 ; 0x86
1a26: 781e ldrb r6, [r3, #0]
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask;
1a28: 230f movs r3, #15
1a2a: 4033 ands r3, r6
1a2c: 015e lsls r6, r3, #5
1a2e: 4f39 ldr r7, [pc, #228] ; (1b14 <_usb_d_dev_ep_stall+0x154>)
1a30: 46bc mov ip, r7
1a32: 4466 add r6, ip
1a34: 7175 strb r5, [r6, #5]
_usbd_ep_int_en(epn, USB_DEVICE_EPINTFLAG_STALL0 << dir);
1a36: 2520 movs r5, #32
1a38: 40a5 lsls r5, r4
hri_usbendpoint_set_EPINTEN_reg(USB, epn, flags);
1a3a: b2ec uxtb r4, r5
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENSET.reg = mask;
1a3c: 015b lsls r3, r3, #5
1a3e: 4d36 ldr r5, [pc, #216] ; (1b18 <_usb_d_dev_ep_stall+0x158>)
1a40: 46ac mov ip, r5
1a42: 4463 add r3, ip
1a44: 701c strb r4, [r3, #0]
ept->flags.bits.is_stalled = 1;
1a46: 1882 adds r2, r0, r2
1a48: 0092 lsls r2, r2, #2
1a4a: 188a adds r2, r1, r2
1a4c: 3280 adds r2, #128 ; 0x80
1a4e: 79d3 ldrb r3, [r2, #7]
1a50: 2108 movs r1, #8
1a52: 430b orrs r3, r1
1a54: 71d3 strb r3, [r2, #7]
rc = _usb_d_dev_ep_stall_set(ept, dir);
1a56: 2000 movs r0, #0
1a58: e7db b.n 1a12 <_usb_d_dev_ep_stall+0x52>
uint8_t epn = USB_EP_GET_N(ept->ep);
1a5a: 0093 lsls r3, r2, #2
1a5c: 189b adds r3, r3, r2
1a5e: 0099 lsls r1, r3, #2
1a60: 4b2b ldr r3, [pc, #172] ; (1b10 <_usb_d_dev_ep_stall+0x150>)
1a62: 185b adds r3, r3, r1
1a64: 3386 adds r3, #134 ; 0x86
1a66: 781b ldrb r3, [r3, #0]
1a68: 210f movs r1, #15
1a6a: 400b ands r3, r1
1a6c: 015d lsls r5, r3, #5
1a6e: 492b ldr r1, [pc, #172] ; (1b1c <_usb_d_dev_ep_stall+0x15c>)
1a70: 468c mov ip, r1
1a72: 4465 add r5, ip
return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUS.reg;
1a74: 2183 movs r1, #131 ; 0x83
1a76: 0049 lsls r1, r1, #1
1a78: 5c6e ldrb r6, [r5, r1]
return (hri_usbendpoint_read_EPSTATUS_reg(hw, epn) & (USB_DEVICE_EPSTATUS_STALLRQ0 << bank_n));
1a7a: 39f6 subs r1, #246 ; 0xf6
1a7c: 40a1 lsls r1, r4
rc = _usb_d_dev_ep_stall_clr(ept, dir);
1a7e: 2000 movs r0, #0
if (!is_stalled) {
1a80: 420e tst r6, r1
1a82: d0c6 beq.n 1a12 <_usb_d_dev_ep_stall+0x52>
hri_usbendpoint_clear_EPSTATUS_reg(USB, epn, (USB_DEVICE_EPSTATUS_STALLRQ0 << bank_n));
1a84: b2c9 uxtb r1, r1
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask;
1a86: 3005 adds r0, #5
1a88: 30ff adds r0, #255 ; 0xff
1a8a: 5429 strb r1, [r5, r0]
_usbd_ep_int_dis(epn, USB_DEVICE_EPINTFLAG_STALL0 << dir);
1a8c: 2120 movs r1, #32
1a8e: 40a1 lsls r1, r4
hri_usbendpoint_clear_EPINTEN_reg(USB, epn, flags);
1a90: b2c8 uxtb r0, r1
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask;
1a92: 015b lsls r3, r3, #5
1a94: 4e22 ldr r6, [pc, #136] ; (1b20 <_usb_d_dev_ep_stall+0x160>)
1a96: 46b4 mov ip, r6
1a98: 4463 add r3, ip
1a9a: 7018 strb r0, [r3, #0]
return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg;
1a9c: 2308 movs r3, #8
1a9e: 33ff adds r3, #255 ; 0xff
1aa0: 5ceb ldrb r3, [r5, r3]
if (_usbd_ep_is_stall_sent(epn, dir)) {
1aa2: 420b tst r3, r1
1aa4: d009 beq.n 1aba <_usb_d_dev_ep_stall+0xfa>
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
1aa6: 2308 movs r3, #8
1aa8: 33ff adds r3, #255 ; 0xff
1aaa: 54e8 strb r0, [r5, r3]
hri_usbendpoint_clear_EPSTATUS_reg(USB, epn, (USB_DEVICE_EPSTATUS_DTGLOUT << bank_n));
1aac: 3b07 subs r3, #7
1aae: 3bff subs r3, #255 ; 0xff
1ab0: 40a3 lsls r3, r4
1ab2: b2db uxtb r3, r3
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask;
1ab4: 2182 movs r1, #130 ; 0x82
1ab6: 0049 lsls r1, r1, #1
1ab8: 546b strb r3, [r5, r1]
if (_usb_d_dev_ep_is_ctrl(ept)) {
1aba: 0093 lsls r3, r2, #2
1abc: 189b adds r3, r3, r2
1abe: 0099 lsls r1, r3, #2
1ac0: 4b13 ldr r3, [pc, #76] ; (1b10 <_usb_d_dev_ep_stall+0x150>)
1ac2: 185b adds r3, r3, r1
1ac4: 3380 adds r3, #128 ; 0x80
1ac6: 79d9 ldrb r1, [r3, #7]
1ac8: 2307 movs r3, #7
1aca: 400b ands r3, r1
1acc: 2b01 cmp r3, #1
1ace: d00b beq.n 1ae8 <_usb_d_dev_ep_stall+0x128>
ept->flags.bits.is_stalled = 0;
1ad0: 0093 lsls r3, r2, #2
1ad2: 189a adds r2, r3, r2
1ad4: 0092 lsls r2, r2, #2
1ad6: 4b0e ldr r3, [pc, #56] ; (1b10 <_usb_d_dev_ep_stall+0x150>)
1ad8: 189b adds r3, r3, r2
1ada: 3380 adds r3, #128 ; 0x80
1adc: 79da ldrb r2, [r3, #7]
1ade: 2108 movs r1, #8
1ae0: 438a bics r2, r1
1ae2: 71da strb r2, [r3, #7]
rc = _usb_d_dev_ep_stall_clr(ept, dir);
1ae4: 2000 movs r0, #0
1ae6: e794 b.n 1a12 <_usb_d_dev_ep_stall+0x52>
return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUS.reg;
1ae8: 3306 adds r3, #6
1aea: 33ff adds r3, #255 ; 0xff
1aec: 5ce9 ldrb r1, [r5, r3]
if ((hri_usbendpoint_read_EPSTATUS_reg(USB, epn) & USB_DEVICE_EPSTATUS_STALLRQ_Msk) == 0) {
1aee: 3bd6 subs r3, #214 ; 0xd6
rc = _usb_d_dev_ep_stall_clr(ept, dir);
1af0: 2000 movs r0, #0
if ((hri_usbendpoint_read_EPSTATUS_reg(USB, epn) & USB_DEVICE_EPSTATUS_STALLRQ_Msk) == 0) {
1af2: 4219 tst r1, r3
1af4: d000 beq.n 1af8 <_usb_d_dev_ep_stall+0x138>
1af6: e78c b.n 1a12 <_usb_d_dev_ep_stall+0x52>
ept->flags.bits.is_stalled = 0;
1af8: 0093 lsls r3, r2, #2
1afa: 189a adds r2, r3, r2
1afc: 0092 lsls r2, r2, #2
1afe: 4b04 ldr r3, [pc, #16] ; (1b10 <_usb_d_dev_ep_stall+0x150>)
1b00: 189b adds r3, r3, r2
1b02: 3380 adds r3, #128 ; 0x80
1b04: 79da ldrb r2, [r3, #7]
1b06: 2108 movs r1, #8
1b08: 438a bics r2, r1
1b0a: 71da strb r2, [r3, #7]
1b0c: e781 b.n 1a12 <_usb_d_dev_ep_stall+0x52>
1b0e: 46c0 nop ; (mov r8, r8)
1b10: 20000104 .word 0x20000104
1b14: 41005100 .word 0x41005100
1b18: 41005109 .word 0x41005109
1b1c: 41005000 .word 0x41005000
1b20: 41005108 .word 0x41005108
00001b24 <_usb_d_dev_ep_read_req>:
int32_t _usb_d_dev_ep_read_req(const uint8_t ep, uint8_t *req_buf)
{
1b24: b570 push {r4, r5, r6, lr}
1b26: 000d movs r5, r1
uint8_t epn = USB_EP_GET_N(ep);
1b28: 230f movs r3, #15
1b2a: 4018 ands r0, r3
1b2c: 0144 lsls r4, r0, #5
UsbDeviceDescBank *bank = prvt_inst.desc_table[epn].DeviceDescBank;
1b2e: 4b16 ldr r3, [pc, #88] ; (1b88 <_usb_d_dev_ep_read_req+0x64>)
1b30: 191b adds r3, r3, r4
uint32_t addr = bank[0].ADDR.reg;
1b32: 6819 ldr r1, [r3, #0]
uint16_t bytes = bank[0].PCKSIZE.bit.BYTE_COUNT;
1b34: 685b ldr r3, [r3, #4]
1b36: 049b lsls r3, r3, #18
1b38: 0c9e lsrs r6, r3, #18
if (epn > CONF_USB_D_MAX_EP_N || !req_buf) {
1b3a: 2802 cmp r0, #2
1b3c: d81a bhi.n 1b74 <_usb_d_dev_ep_read_req+0x50>
1b3e: 2d00 cmp r5, #0
1b40: d01b beq.n 1b7a <_usb_d_dev_ep_read_req+0x56>
1b42: 4b12 ldr r3, [pc, #72] ; (1b8c <_usb_d_dev_ep_read_req+0x68>)
1b44: 469c mov ip, r3
1b46: 4464 add r4, ip
return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg;
1b48: 2380 movs r3, #128 ; 0x80
1b4a: 005b lsls r3, r3, #1
1b4c: 5ce3 ldrb r3, [r4, r3]
return -USB_ERR_PARAM;
}
if (!_usbd_ep_is_ctrl(epn)) {
1b4e: 2b11 cmp r3, #17
1b50: d116 bne.n 1b80 <_usb_d_dev_ep_read_req+0x5c>
tmp = ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg;
1b52: 2308 movs r3, #8
1b54: 33ff adds r3, #255 ; 0xff
1b56: 5ce3 ldrb r3, [r4, r3]
return -USB_ERR_FUNC;
}
if (!_usbd_ep_is_setup(epn)) {
return ERR_NONE;
1b58: 2000 movs r0, #0
if (!_usbd_ep_is_setup(epn)) {
1b5a: 06db lsls r3, r3, #27
1b5c: d400 bmi.n 1b60 <_usb_d_dev_ep_read_req+0x3c>
}
memcpy(req_buf, (void *)addr, 8);
_usbd_ep_ack_setup(epn);
return bytes;
}
1b5e: bd70 pop {r4, r5, r6, pc}
memcpy(req_buf, (void *)addr, 8);
1b60: 2208 movs r2, #8
1b62: 0028 movs r0, r5
1b64: 4b0a ldr r3, [pc, #40] ; (1b90 <_usb_d_dev_ep_read_req+0x6c>)
1b66: 4798 blx r3
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask;
1b68: 2210 movs r2, #16
1b6a: 2308 movs r3, #8
1b6c: 33ff adds r3, #255 ; 0xff
1b6e: 54e2 strb r2, [r4, r3]
return bytes;
1b70: 0030 movs r0, r6
1b72: e7f4 b.n 1b5e <_usb_d_dev_ep_read_req+0x3a>
return -USB_ERR_PARAM;
1b74: 2012 movs r0, #18
1b76: 4240 negs r0, r0
1b78: e7f1 b.n 1b5e <_usb_d_dev_ep_read_req+0x3a>
1b7a: 2012 movs r0, #18
1b7c: 4240 negs r0, r0
1b7e: e7ee b.n 1b5e <_usb_d_dev_ep_read_req+0x3a>
return -USB_ERR_FUNC;
1b80: 2013 movs r0, #19
1b82: 4240 negs r0, r0
1b84: e7eb b.n 1b5e <_usb_d_dev_ep_read_req+0x3a>
1b86: 46c0 nop ; (mov r8, r8)
1b88: 20000104 .word 0x20000104
1b8c: 41005000 .word 0x41005000
1b90: 00002bd9 .word 0x00002bd9
00001b94 <_usb_d_dev_ep_trans>:
int32_t _usb_d_dev_ep_trans(const struct usb_d_transfer *trans)
{
1b94: b5f0 push {r4, r5, r6, r7, lr}
1b96: 46de mov lr, fp
1b98: 4657 mov r7, sl
1b9a: 464e mov r6, r9
1b9c: 4645 mov r5, r8
1b9e: b5e0 push {r5, r6, r7, lr}
1ba0: b085 sub sp, #20
1ba2: 4680 mov r8, r0
uint8_t epn = USB_EP_GET_N(trans->ep);
1ba4: 7a06 ldrb r6, [r0, #8]
1ba6: 230f movs r3, #15
1ba8: 4033 ands r3, r6
1baa: b276 sxtb r6, r6
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
1bac: 2b00 cmp r3, #0
1bae: d100 bne.n 1bb2 <_usb_d_dev_ep_trans+0x1e>
1bb0: e0d3 b.n 1d5a <_usb_d_dev_ep_trans+0x1c6>
1bb2: 0018 movs r0, r3
1bb4: 2e00 cmp r6, #0
1bb6: db39 blt.n 1c2c <_usb_d_dev_ep_trans+0x98>
return &dev_inst.ep[ep_index];
1bb8: 0004 movs r4, r0
1bba: 4a73 ldr r2, [pc, #460] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1bbc: 3260 adds r2, #96 ; 0x60
1bbe: 1c41 adds r1, r0, #1
1bc0: 008d lsls r5, r1, #2
1bc2: 186d adds r5, r5, r1
1bc4: 00ad lsls r5, r5, #2
1bc6: 1955 adds r5, r2, r5
bool dir = USB_EP_GET_DIR(trans->ep);
struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir);
uint16_t size_mask = (ept->size == 1023) ? 1023 : (ept->size - 1);
1bc8: 0081 lsls r1, r0, #2
1bca: 1809 adds r1, r1, r0
1bcc: 0089 lsls r1, r1, #2
1bce: 1852 adds r2, r2, r1
1bd0: 8c91 ldrh r1, [r2, #36] ; 0x24
1bd2: 4a6e ldr r2, [pc, #440] ; (1d8c <_usb_d_dev_ep_trans+0x1f8>)
1bd4: 4291 cmp r1, r2
1bd6: d02b beq.n 1c30 <_usb_d_dev_ep_trans+0x9c>
1bd8: 1e4f subs r7, r1, #1
1bda: b2bf uxth r7, r7
bool size_n_aligned = (trans->size & size_mask);
1bdc: 4642 mov r2, r8
1bde: 6852 ldr r2, [r2, #4]
1be0: 4017 ands r7, r2
bool use_cache = false;
volatile hal_atomic_t flags;
if (epn > CONF_USB_D_MAX_EP_N) {
1be2: 2b02 cmp r3, #2
1be4: d900 bls.n 1be8 <_usb_d_dev_ep_trans+0x54>
1be6: e0a4 b.n 1d32 <_usb_d_dev_ep_trans+0x19e>
* 1. Buffer not in RAM (cache all).
* 2. IN/OUT with unaligned buffer (cache all).
* 3. OUT with unaligned packet size (cache last packet).
* 4. OUT size < 8 (sub-case for 3).
*/
if (!_usb_is_addr4dma(trans->buf, trans->size) || (!_usb_is_aligned(trans->buf))
1be8: 4643 mov r3, r8
1bea: 681b ldr r3, [r3, #0]
1bec: 4868 ldr r0, [pc, #416] ; (1d90 <_usb_d_dev_ep_trans+0x1fc>)
1bee: 4283 cmp r3, r0
1bf0: d920 bls.n 1c34 <_usb_d_dev_ep_trans+0xa0>
1bf2: 1898 adds r0, r3, r2
1bf4: 9001 str r0, [sp, #4]
1bf6: 4867 ldr r0, [pc, #412] ; (1d94 <_usb_d_dev_ep_trans+0x200>)
1bf8: 4684 mov ip, r0
1bfa: 9801 ldr r0, [sp, #4]
1bfc: 4560 cmp r0, ip
1bfe: d819 bhi.n 1c34 <_usb_d_dev_ep_trans+0xa0>
1c00: 079b lsls r3, r3, #30
1c02: d117 bne.n 1c34 <_usb_d_dev_ep_trans+0xa0>
|| (!dir && (trans->size < ept->size))) {
1c04: 2e00 cmp r6, #0
1c06: db32 blt.n 1c6e <_usb_d_dev_ep_trans+0xda>
1c08: 4291 cmp r1, r2
1c0a: d900 bls.n 1c0e <_usb_d_dev_ep_trans+0x7a>
1c0c: e0af b.n 1d6e <_usb_d_dev_ep_trans+0x1da>
return -USB_ERR_FUNC;
}
/* Use cache all the time. */
use_cache = true;
}
if (!dir && size_n_aligned) {
1c0e: 2f00 cmp r7, #0
1c10: d030 beq.n 1c74 <_usb_d_dev_ep_trans+0xe0>
if (!ept->cache) {
1c12: 00a3 lsls r3, r4, #2
1c14: 191b adds r3, r3, r4
1c16: 009a lsls r2, r3, #2
1c18: 4b5b ldr r3, [pc, #364] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1c1a: 189b adds r3, r3, r2
1c1c: 3380 adds r3, #128 ; 0x80
1c1e: 681b ldr r3, [r3, #0]
1c20: 2b00 cmp r3, #0
1c22: d100 bne.n 1c26 <_usb_d_dev_ep_trans+0x92>
1c24: e08b b.n 1d3e <_usb_d_dev_ep_trans+0x1aa>
bool use_cache = false;
1c26: 2300 movs r3, #0
1c28: 4699 mov r9, r3
1c2a: e00f b.n 1c4c <_usb_d_dev_ep_trans+0xb8>
uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn);
1c2c: 1c98 adds r0, r3, #2
1c2e: e7c3 b.n 1bb8 <_usb_d_dev_ep_trans+0x24>
uint16_t size_mask = (ept->size == 1023) ? 1023 : (ept->size - 1);
1c30: 000f movs r7, r1
1c32: e7d3 b.n 1bdc <_usb_d_dev_ep_trans+0x48>
if (!ept->cache) {
1c34: 00a3 lsls r3, r4, #2
1c36: 191b adds r3, r3, r4
1c38: 009a lsls r2, r3, #2
1c3a: 4b53 ldr r3, [pc, #332] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1c3c: 189b adds r3, r3, r2
1c3e: 3380 adds r3, #128 ; 0x80
1c40: 681b ldr r3, [r3, #0]
1c42: 2b00 cmp r3, #0
1c44: d100 bne.n 1c48 <_usb_d_dev_ep_trans+0xb4>
1c46: e077 b.n 1d38 <_usb_d_dev_ep_trans+0x1a4>
use_cache = true;
1c48: 2301 movs r3, #1
1c4a: 4699 mov r9, r3
}
/* Set 'use_cache' on last packet. */
}
/* Check halt */
if (ept->flags.bits.is_stalled) {
1c4c: 00a3 lsls r3, r4, #2
1c4e: 191b adds r3, r3, r4
1c50: 009a lsls r2, r3, #2
1c52: 4b4d ldr r3, [pc, #308] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1c54: 189b adds r3, r3, r2
1c56: 3380 adds r3, #128 ; 0x80
1c58: 79db ldrb r3, [r3, #7]
return USB_HALTED;
1c5a: 2002 movs r0, #2
if (ept->flags.bits.is_stalled) {
1c5c: 071b lsls r3, r3, #28
1c5e: d50c bpl.n 1c7a <_usb_d_dev_ep_trans+0xe6>
} else {
_usb_d_dev_out_next(ept, false);
}
return ERR_NONE;
}
1c60: b005 add sp, #20
1c62: bc3c pop {r2, r3, r4, r5}
1c64: 4690 mov r8, r2
1c66: 4699 mov r9, r3
1c68: 46a2 mov sl, r4
1c6a: 46ab mov fp, r5
1c6c: bdf0 pop {r4, r5, r6, r7, pc}
bool use_cache = false;
1c6e: 2300 movs r3, #0
1c70: 4699 mov r9, r3
1c72: e7eb b.n 1c4c <_usb_d_dev_ep_trans+0xb8>
1c74: 2300 movs r3, #0
1c76: 4699 mov r9, r3
1c78: e7e8 b.n 1c4c <_usb_d_dev_ep_trans+0xb8>
atomic_enter_critical(&flags);
1c7a: a803 add r0, sp, #12
1c7c: 4b46 ldr r3, [pc, #280] ; (1d98 <_usb_d_dev_ep_trans+0x204>)
1c7e: 4798 blx r3
if (_usb_d_dev_ep_is_busy(ept)) {
1c80: 00a3 lsls r3, r4, #2
1c82: 191b adds r3, r3, r4
1c84: 009a lsls r2, r3, #2
1c86: 4b40 ldr r3, [pc, #256] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1c88: 189b adds r3, r3, r2
1c8a: 3380 adds r3, #128 ; 0x80
1c8c: 79db ldrb r3, [r3, #7]
1c8e: 065b lsls r3, r3, #25
1c90: d444 bmi.n 1d1c <_usb_d_dev_ep_trans+0x188>
ept->flags.bits.is_busy = 1;
1c92: 00a3 lsls r3, r4, #2
1c94: 191b adds r3, r3, r4
1c96: 009b lsls r3, r3, #2
1c98: 4a3b ldr r2, [pc, #236] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1c9a: 4693 mov fp, r2
1c9c: 449b add fp, r3
1c9e: 2380 movs r3, #128 ; 0x80
1ca0: 445b add r3, fp
1ca2: 469a mov sl, r3
1ca4: 79db ldrb r3, [r3, #7]
1ca6: 2240 movs r2, #64 ; 0x40
1ca8: 4313 orrs r3, r2
1caa: 4652 mov r2, sl
1cac: 71d3 strb r3, [r2, #7]
atomic_leave_critical(&flags);
1cae: a803 add r0, sp, #12
1cb0: 4b3a ldr r3, [pc, #232] ; (1d9c <_usb_d_dev_ep_trans+0x208>)
1cb2: 4798 blx r3
ept->trans_buf = trans->buf;
1cb4: 465b mov r3, fp
1cb6: 4642 mov r2, r8
1cb8: 6812 ldr r2, [r2, #0]
1cba: 675a str r2, [r3, #116] ; 0x74
ept->trans_size = trans->size;
1cbc: 4642 mov r2, r8
1cbe: 6852 ldr r2, [r2, #4]
1cc0: 679a str r2, [r3, #120] ; 0x78
ept->trans_count = 0;
1cc2: 2300 movs r3, #0
1cc4: 465a mov r2, fp
1cc6: 67d3 str r3, [r2, #124] ; 0x7c
bool dir = USB_EP_GET_DIR(trans->ep);
1cc8: 0ff2 lsrs r2, r6, #31
ept->flags.bits.dir = dir;
1cca: 01d2 lsls r2, r2, #7
1ccc: 4653 mov r3, sl
1cce: 79d9 ldrb r1, [r3, #7]
1cd0: 237f movs r3, #127 ; 0x7f
1cd2: 400b ands r3, r1
ept->flags.bits.use_cache = use_cache;
1cd4: 4649 mov r1, r9
1cd6: 0149 lsls r1, r1, #5
1cd8: 4313 orrs r3, r2
1cda: 2220 movs r2, #32
1cdc: 4393 bics r3, r2
1cde: 430b orrs r3, r1
1ce0: 4652 mov r2, sl
1ce2: 71d3 strb r3, [r2, #7]
ept->flags.bits.need_zlp = (trans->zlp && (!size_n_aligned));
1ce4: 4643 mov r3, r8
1ce6: 7a5b ldrb r3, [r3, #9]
1ce8: 2200 movs r2, #0
1cea: 2b00 cmp r3, #0
1cec: d002 beq.n 1cf4 <_usb_d_dev_ep_trans+0x160>
1cee: 427a negs r2, r7
1cf0: 417a adcs r2, r7
1cf2: b2d2 uxtb r2, r2
1cf4: 00a3 lsls r3, r4, #2
1cf6: 191c adds r4, r3, r4
1cf8: 00a4 lsls r4, r4, #2
1cfa: 4b23 ldr r3, [pc, #140] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1cfc: 191b adds r3, r3, r4
1cfe: 3380 adds r3, #128 ; 0x80
1d00: 0112 lsls r2, r2, #4
1d02: 79df ldrb r7, [r3, #7]
1d04: 2110 movs r1, #16
1d06: 438f bics r7, r1
1d08: 4317 orrs r7, r2
1d0a: 71df strb r7, [r3, #7]
if (dir) {
1d0c: 2e00 cmp r6, #0
1d0e: db0a blt.n 1d26 <_usb_d_dev_ep_trans+0x192>
_usb_d_dev_out_next(ept, false);
1d10: 2100 movs r1, #0
1d12: 0028 movs r0, r5
1d14: 4b22 ldr r3, [pc, #136] ; (1da0 <_usb_d_dev_ep_trans+0x20c>)
1d16: 4798 blx r3
return ERR_NONE;
1d18: 2000 movs r0, #0
1d1a: e7a1 b.n 1c60 <_usb_d_dev_ep_trans+0xcc>
atomic_leave_critical(&flags);
1d1c: a803 add r0, sp, #12
1d1e: 4b1f ldr r3, [pc, #124] ; (1d9c <_usb_d_dev_ep_trans+0x208>)
1d20: 4798 blx r3
return USB_BUSY;
1d22: 2001 movs r0, #1
1d24: e79c b.n 1c60 <_usb_d_dev_ep_trans+0xcc>
_usb_d_dev_in_next(ept, false);
1d26: 2100 movs r1, #0
1d28: 0028 movs r0, r5
1d2a: 4b1e ldr r3, [pc, #120] ; (1da4 <_usb_d_dev_ep_trans+0x210>)
1d2c: 4798 blx r3
return ERR_NONE;
1d2e: 2000 movs r0, #0
1d30: e796 b.n 1c60 <_usb_d_dev_ep_trans+0xcc>
return -USB_ERR_PARAM;
1d32: 2012 movs r0, #18
1d34: 4240 negs r0, r0
1d36: e793 b.n 1c60 <_usb_d_dev_ep_trans+0xcc>
return -USB_ERR_FUNC;
1d38: 2013 movs r0, #19
1d3a: 4240 negs r0, r0
1d3c: e790 b.n 1c60 <_usb_d_dev_ep_trans+0xcc>
return -USB_ERR_PARAM;
1d3e: 2012 movs r0, #18
1d40: 4240 negs r0, r0
1d42: e78d b.n 1c60 <_usb_d_dev_ep_trans+0xcc>
return -USB_ERR_FUNC;
1d44: 2013 movs r0, #19
1d46: 4240 negs r0, r0
1d48: e78a b.n 1c60 <_usb_d_dev_ep_trans+0xcc>
bool size_n_aligned = (trans->size & size_mask);
1d4a: 4643 mov r3, r8
1d4c: 685a ldr r2, [r3, #4]
1d4e: 0597 lsls r7, r2, #22
1d50: 0dbf lsrs r7, r7, #22
return &dev_inst.ep[ep_index];
1d52: 4d0d ldr r5, [pc, #52] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1d54: 3574 adds r5, #116 ; 0x74
1d56: 2400 movs r4, #0
1d58: e746 b.n 1be8 <_usb_d_dev_ep_trans+0x54>
uint16_t size_mask = (ept->size == 1023) ? 1023 : (ept->size - 1);
1d5a: 4a0b ldr r2, [pc, #44] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1d5c: 3260 adds r2, #96 ; 0x60
1d5e: 8c91 ldrh r1, [r2, #36] ; 0x24
1d60: 4a0a ldr r2, [pc, #40] ; (1d8c <_usb_d_dev_ep_trans+0x1f8>)
1d62: 4291 cmp r1, r2
1d64: d0f1 beq.n 1d4a <_usb_d_dev_ep_trans+0x1b6>
return &dev_inst.ep[ep_index];
1d66: 4d08 ldr r5, [pc, #32] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1d68: 3574 adds r5, #116 ; 0x74
1d6a: 2400 movs r4, #0
1d6c: e734 b.n 1bd8 <_usb_d_dev_ep_trans+0x44>
if (!ept->cache) {
1d6e: 00a3 lsls r3, r4, #2
1d70: 191b adds r3, r3, r4
1d72: 009a lsls r2, r3, #2
1d74: 4b04 ldr r3, [pc, #16] ; (1d88 <_usb_d_dev_ep_trans+0x1f4>)
1d76: 189b adds r3, r3, r2
1d78: 3380 adds r3, #128 ; 0x80
1d7a: 681b ldr r3, [r3, #0]
1d7c: 2b00 cmp r3, #0
1d7e: d0e1 beq.n 1d44 <_usb_d_dev_ep_trans+0x1b0>
1d80: 2301 movs r3, #1
1d82: 4699 mov r9, r3
1d84: e762 b.n 1c4c <_usb_d_dev_ep_trans+0xb8>
1d86: 46c0 nop ; (mov r8, r8)
1d88: 20000104 .word 0x20000104
1d8c: 000003ff .word 0x000003ff
1d90: 1fffffff .word 0x1fffffff
1d94: 20007fff .word 0x20007fff
1d98: 00000385 .word 0x00000385
1d9c: 00000393 .word 0x00000393
1da0: 0000116d .word 0x0000116d
1da4: 00000fc5 .word 0x00000fc5
00001da8 <_usb_d_dev_register_callback>:
return USB_OK;
}
void _usb_d_dev_register_callback(const enum usb_d_cb_type type, const FUNC_PTR func)
{
FUNC_PTR f = (func == NULL) ? (FUNC_PTR)_dummy_func_no_return : (FUNC_PTR)func;
1da8: 1e0b subs r3, r1, #0
1daa: d006 beq.n 1dba <_usb_d_dev_register_callback+0x12>
if (type == USB_D_CB_EVENT) {
1dac: 2801 cmp r0, #1
1dae: d006 beq.n 1dbe <_usb_d_dev_register_callback+0x16>
dev_inst.callbacks.event = (_usb_d_dev_event_cb_t)f;
} else if (type == USB_D_CB_SOF) {
1db0: 2800 cmp r0, #0
1db2: d101 bne.n 1db8 <_usb_d_dev_register_callback+0x10>
dev_inst.callbacks.sof = (_usb_d_dev_sof_cb_t)f;
1db4: 4a03 ldr r2, [pc, #12] ; (1dc4 <_usb_d_dev_register_callback+0x1c>)
1db6: 6613 str r3, [r2, #96] ; 0x60
}
}
1db8: 4770 bx lr
FUNC_PTR f = (func == NULL) ? (FUNC_PTR)_dummy_func_no_return : (FUNC_PTR)func;
1dba: 4b03 ldr r3, [pc, #12] ; (1dc8 <_usb_d_dev_register_callback+0x20>)
1dbc: e7f6 b.n 1dac <_usb_d_dev_register_callback+0x4>
dev_inst.callbacks.event = (_usb_d_dev_event_cb_t)f;
1dbe: 4a01 ldr r2, [pc, #4] ; (1dc4 <_usb_d_dev_register_callback+0x1c>)
1dc0: 6653 str r3, [r2, #100] ; 0x64
1dc2: e7f9 b.n 1db8 <_usb_d_dev_register_callback+0x10>
1dc4: 20000104 .word 0x20000104
1dc8: 00000d2d .word 0x00000d2d
00001dcc <_usb_d_dev_register_ep_callback>:
void _usb_d_dev_register_ep_callback(const enum usb_d_dev_ep_cb_type type, const FUNC_PTR func)
{
FUNC_PTR f = (func == NULL) ? (FUNC_PTR)_dummy_func_no_return : (FUNC_PTR)func;
1dcc: 1e0b subs r3, r1, #0
1dce: d008 beq.n 1de2 <_usb_d_dev_register_ep_callback+0x16>
if (type == USB_D_DEV_EP_CB_SETUP) {
1dd0: 2800 cmp r0, #0
1dd2: d008 beq.n 1de6 <_usb_d_dev_register_ep_callback+0x1a>
dev_inst.ep_callbacks.setup = (_usb_d_dev_ep_cb_setup_t)f;
} else if (type == USB_D_DEV_EP_CB_MORE) {
1dd4: 2801 cmp r0, #1
1dd6: d009 beq.n 1dec <_usb_d_dev_register_ep_callback+0x20>
dev_inst.ep_callbacks.more = (_usb_d_dev_ep_cb_more_t)f;
} else if (type == USB_D_DEV_EP_CB_DONE) {
1dd8: 2802 cmp r0, #2
1dda: d106 bne.n 1dea <_usb_d_dev_register_ep_callback+0x1e>
dev_inst.ep_callbacks.done = (_usb_d_dev_ep_cb_done_t)f;
1ddc: 4a05 ldr r2, [pc, #20] ; (1df4 <_usb_d_dev_register_ep_callback+0x28>)
1dde: 6713 str r3, [r2, #112] ; 0x70
}
}
1de0: e003 b.n 1dea <_usb_d_dev_register_ep_callback+0x1e>
FUNC_PTR f = (func == NULL) ? (FUNC_PTR)_dummy_func_no_return : (FUNC_PTR)func;
1de2: 4b05 ldr r3, [pc, #20] ; (1df8 <_usb_d_dev_register_ep_callback+0x2c>)
1de4: e7f4 b.n 1dd0 <_usb_d_dev_register_ep_callback+0x4>
dev_inst.ep_callbacks.setup = (_usb_d_dev_ep_cb_setup_t)f;
1de6: 4a03 ldr r2, [pc, #12] ; (1df4 <_usb_d_dev_register_ep_callback+0x28>)
1de8: 6693 str r3, [r2, #104] ; 0x68
}
1dea: 4770 bx lr
dev_inst.ep_callbacks.more = (_usb_d_dev_ep_cb_more_t)f;
1dec: 4a01 ldr r2, [pc, #4] ; (1df4 <_usb_d_dev_register_ep_callback+0x28>)
1dee: 66d3 str r3, [r2, #108] ; 0x6c
1df0: e7fb b.n 1dea <_usb_d_dev_register_ep_callback+0x1e>
1df2: 46c0 nop ; (mov r8, r8)
1df4: 20000104 .word 0x20000104
1df8: 00000d2d .word 0x00000d2d
00001dfc <USB_Handler>:
/**
* \brief USB interrupt handler
*/
void USB_Handler(void)
{
1dfc: b5f8 push {r3, r4, r5, r6, r7, lr}
uint16_t epint = hw->DEVICE.EPINTSMRY.reg;
1dfe: 4b82 ldr r3, [pc, #520] ; (2008 <STACK_SIZE+0x8>)
1e00: 8c1e ldrh r6, [r3, #32]
1e02: b2b6 uxth r6, r6
if (0 == epint) {
1e04: 2e00 cmp r6, #0
1e06: d003 beq.n 1e10 <USB_Handler+0x14>
1e08: 4c80 ldr r4, [pc, #512] ; (200c <STACK_SIZE+0xc>)
1e0a: 3474 adds r4, #116 ; 0x74
uint32_t lpm_variable = 0;
1e0c: 2500 movs r5, #0
1e0e: e0b9 b.n 1f84 <USB_Handler+0x188>
return ((Usb *)hw)->DEVICE.INTFLAG.reg;
1e10: 8b99 ldrh r1, [r3, #28]
return ((Usb *)hw)->DEVICE.INTENSET.reg;
1e12: 8b1b ldrh r3, [r3, #24]
flags &= hri_usbdevice_read_INTEN_reg(USB);
1e14: 400b ands r3, r1
if (flags & USB_DEVICE_INTFLAG_SOF) {
1e16: 075a lsls r2, r3, #29
1e18: d417 bmi.n 1e4a <USB_Handler+0x4e>
if (flags & USB_DEVICE_INTFLAG_LPMSUSP) {
1e1a: 059a lsls r2, r3, #22
1e1c: d41c bmi.n 1e58 <USB_Handler+0x5c>
} else if (flags & USB_DEVICE_INTFLAG_RAMACER) {
1e1e: 061a lsls r2, r3, #24
1e20: d43e bmi.n 1ea0 <USB_Handler+0xa4>
} else if (flags & USB_D_WAKEUP_INT_FLAGS) {
1e22: 2270 movs r2, #112 ; 0x70
1e24: 421a tst r2, r3
1e26: d144 bne.n 1eb2 <USB_Handler+0xb6>
} else if (flags & USB_DEVICE_INTFLAG_EORST) {
1e28: 071a lsls r2, r3, #28
1e2a: d45e bmi.n 1eea <USB_Handler+0xee>
} else if (flags & USB_DEVICE_INTFLAG_SUSPEND) {
1e2c: 07db lsls r3, r3, #31
1e2e: d5eb bpl.n 1e08 <USB_Handler+0xc>
((Usb *)hw)->DEVICE.INTFLAG.reg = mask;
1e30: 4b75 ldr r3, [pc, #468] ; (2008 <STACK_SIZE+0x8>)
1e32: 4a77 ldr r2, [pc, #476] ; (2010 <STACK_SIZE+0x10>)
1e34: 839a strh r2, [r3, #28]
((Usb *)hw)->DEVICE.INTENCLR.reg = mask;
1e36: 829a strh r2, [r3, #20]
((Usb *)hw)->DEVICE.INTENSET.reg = mask;
1e38: 3a92 subs r2, #146 ; 0x92
1e3a: 3aff subs r2, #255 ; 0xff
1e3c: 831a strh r2, [r3, #24]
dev_inst.callbacks.event(USB_EV_SUSPEND, 0);
1e3e: 4b73 ldr r3, [pc, #460] ; (200c <STACK_SIZE+0xc>)
1e40: 6e5b ldr r3, [r3, #100] ; 0x64
1e42: 2100 movs r1, #0
1e44: 2004 movs r0, #4
1e46: 4798 blx r3
1e48: e005 b.n 1e56 <USB_Handler+0x5a>
((Usb *)hw)->DEVICE.INTFLAG.reg = mask;
1e4a: 2204 movs r2, #4
1e4c: 4b6e ldr r3, [pc, #440] ; (2008 <STACK_SIZE+0x8>)
1e4e: 839a strh r2, [r3, #28]
dev_inst.callbacks.sof();
1e50: 4b6e ldr r3, [pc, #440] ; (200c <STACK_SIZE+0xc>)
1e52: 6e1b ldr r3, [r3, #96] ; 0x60
1e54: 4798 blx r3
_usb_d_dev_handler();
}
1e56: bdf8 pop {r3, r4, r5, r6, r7, pc}
1e58: 4b6b ldr r3, [pc, #428] ; (2008 <STACK_SIZE+0x8>)
1e5a: 4a6d ldr r2, [pc, #436] ; (2010 <STACK_SIZE+0x10>)
1e5c: 839a strh r2, [r3, #28]
((Usb *)hw)->DEVICE.INTENCLR.reg = mask;
1e5e: 829a strh r2, [r3, #20]
((Usb *)hw)->DEVICE.INTENSET.reg = mask;
1e60: 3a92 subs r2, #146 ; 0x92
1e62: 3aff subs r2, #255 ; 0xff
1e64: 831a strh r2, [r3, #24]
if (bank->EXTREG.bit.SUBPID == 0x3) {
1e66: 4b69 ldr r3, [pc, #420] ; (200c <STACK_SIZE+0xc>)
1e68: 891b ldrh r3, [r3, #8]
1e6a: 071b lsls r3, r3, #28
1e6c: 0f1b lsrs r3, r3, #28
1e6e: 2b03 cmp r3, #3
1e70: d00c beq.n 1e8c <USB_Handler+0x90>
1e72: 4b66 ldr r3, [pc, #408] ; (200c <STACK_SIZE+0xc>)
1e74: 8d1b ldrh r3, [r3, #40] ; 0x28
1e76: 071b lsls r3, r3, #28
1e78: 0f1b lsrs r3, r3, #28
uint32_t lpm_variable = 0;
1e7a: 2100 movs r1, #0
UsbDeviceDescBank *bank = &prvt_inst.desc_table[i].DeviceDescBank[0];
1e7c: 3a6f subs r2, #111 ; 0x6f
if (bank->EXTREG.bit.SUBPID == 0x3) {
1e7e: 2b03 cmp r3, #3
1e80: d005 beq.n 1e8e <USB_Handler+0x92>
dev_inst.callbacks.event(USB_EV_LPM_SUSPEND, lpm_variable);
1e82: 4b62 ldr r3, [pc, #392] ; (200c <STACK_SIZE+0xc>)
1e84: 6e5b ldr r3, [r3, #100] ; 0x64
1e86: 2003 movs r0, #3
1e88: 4798 blx r3
1e8a: e7e4 b.n 1e56 <USB_Handler+0x5a>
UsbDeviceDescBank *bank = &prvt_inst.desc_table[i].DeviceDescBank[0];
1e8c: 2200 movs r2, #0
lpm_variable = bank->EXTREG.bit.VARIABLE;
1e8e: 0152 lsls r2, r2, #5
1e90: 4b5e ldr r3, [pc, #376] ; (200c <STACK_SIZE+0xc>)
1e92: 189b adds r3, r3, r2
1e94: 8919 ldrh r1, [r3, #8]
1e96: 0449 lsls r1, r1, #17
1e98: 0d49 lsrs r1, r1, #21
bank->EXTREG.reg = 0;
1e9a: 2200 movs r2, #0
1e9c: 811a strh r2, [r3, #8]
1e9e: e7f0 b.n 1e82 <USB_Handler+0x86>
((Usb *)hw)->DEVICE.INTFLAG.reg = mask;
1ea0: 2280 movs r2, #128 ; 0x80
1ea2: 4b59 ldr r3, [pc, #356] ; (2008 <STACK_SIZE+0x8>)
1ea4: 839a strh r2, [r3, #28]
dev_inst.callbacks.event(USB_EV_ERROR, 0);
1ea6: 4b59 ldr r3, [pc, #356] ; (200c <STACK_SIZE+0xc>)
1ea8: 6e5b ldr r3, [r3, #100] ; 0x64
1eaa: 2100 movs r1, #0
1eac: 2005 movs r0, #5
1eae: 4798 blx r3
1eb0: e7d1 b.n 1e56 <USB_Handler+0x5a>
1eb2: 4b55 ldr r3, [pc, #340] ; (2008 <STACK_SIZE+0x8>)
1eb4: 839a strh r2, [r3, #28]
((Usb *)hw)->DEVICE.INTENCLR.reg = mask;
1eb6: 829a strh r2, [r3, #20]
((Usb *)hw)->DEVICE.INTENSET.reg = mask;
1eb8: 4a55 ldr r2, [pc, #340] ; (2010 <STACK_SIZE+0x10>)
1eba: 831a strh r2, [r3, #24]
if (!(SYSCTRL->DFLLCTRL.reg & SYSCTRL_DFLLCTRL_USBCRM)) {
1ebc: 4b55 ldr r3, [pc, #340] ; (2014 <STACK_SIZE+0x14>)
1ebe: 8c9b ldrh r3, [r3, #36] ; 0x24
1ec0: 069b lsls r3, r3, #26
1ec2: d40c bmi.n 1ede <USB_Handler+0xe2>
tmp = ((Sysctrl *)hw)->PCLKSR.reg;
1ec4: 4953 ldr r1, [pc, #332] ; (2014 <STACK_SIZE+0x14>)
tmp &= mask;
1ec6: 3a32 subs r2, #50 ; 0x32
1ec8: 3aff subs r2, #255 ; 0xff
tmp = ((Sysctrl *)hw)->PCLKSR.reg;
1eca: 68cb ldr r3, [r1, #12]
tmp &= mask;
1ecc: 4013 ands r3, r2
while (hri_sysctrl_get_PCLKSR_reg(SYSCTRL, DFLL_READY_FLAG) != DFLL_READY_FLAG)
1ece: 2bd0 cmp r3, #208 ; 0xd0
1ed0: d1fb bne.n 1eca <USB_Handler+0xce>
dev_inst.callbacks.event(USB_EV_WAKEUP, 0);
1ed2: 4b4e ldr r3, [pc, #312] ; (200c <STACK_SIZE+0xc>)
1ed4: 6e5b ldr r3, [r3, #100] ; 0x64
1ed6: 2100 movs r1, #0
1ed8: 2002 movs r0, #2
1eda: 4798 blx r3
1edc: e7bb b.n 1e56 <USB_Handler+0x5a>
tmp = ((Sysctrl *)hw)->PCLKSR.reg;
1ede: 494d ldr r1, [pc, #308] ; (2014 <STACK_SIZE+0x14>)
tmp &= mask;
1ee0: 2210 movs r2, #16
tmp = ((Sysctrl *)hw)->PCLKSR.reg;
1ee2: 68cb ldr r3, [r1, #12]
while (hri_sysctrl_get_PCLKSR_reg(SYSCTRL, SYSCTRL_PCLKSR_DFLLRDY) != SYSCTRL_PCLKSR_DFLLRDY)
1ee4: 421a tst r2, r3
1ee6: d0fc beq.n 1ee2 <USB_Handler+0xe6>
1ee8: e7f3 b.n 1ed2 <USB_Handler+0xd6>
((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg = data;
1eea: 4b47 ldr r3, [pc, #284] ; (2008 <STACK_SIZE+0x8>)
1eec: 2100 movs r1, #0
1eee: 2280 movs r2, #128 ; 0x80
1ef0: 0052 lsls r2, r2, #1
1ef2: 5499 strb r1, [r3, r2]
((Usb *)hw)->DEVICE.INTFLAG.reg = mask;
1ef4: 3af8 subs r2, #248 ; 0xf8
1ef6: 839a strh r2, [r3, #28]
((Usb *)hw)->DEVICE.INTENCLR.reg = mask;
1ef8: 3268 adds r2, #104 ; 0x68
1efa: 829a strh r2, [r3, #20]
((Usb *)hw)->DEVICE.INTENSET.reg = mask;
1efc: 4a44 ldr r2, [pc, #272] ; (2010 <STACK_SIZE+0x10>)
1efe: 831a strh r2, [r3, #24]
_usb_d_dev_reset_epts();
1f00: 4b45 ldr r3, [pc, #276] ; (2018 <STACK_SIZE+0x18>)
1f02: 4798 blx r3
dev_inst.callbacks.event(USB_EV_RESET, 0);
1f04: 4b41 ldr r3, [pc, #260] ; (200c <STACK_SIZE+0xc>)
1f06: 6e5b ldr r3, [r3, #100] ; 0x64
1f08: 2100 movs r1, #0
1f0a: 2001 movs r0, #1
1f0c: 4798 blx r3
1f0e: e7a2 b.n 1e56 <USB_Handler+0x5a>
if (flags & USB_DEVICE_EPINTFLAG_RXSTP) {
1f10: 06cb lsls r3, r1, #27
1f12: d407 bmi.n 1f24 <USB_Handler+0x128>
} else if (flags & USB_DEVICE_EPINTFLAG_STALL1) {
1f14: 064b lsls r3, r1, #25
1f16: d408 bmi.n 1f2a <USB_Handler+0x12e>
} else if (flags & USB_DEVICE_EPINTFLAG_STALL0) {
1f18: 068b lsls r3, r1, #26
1f1a: d52e bpl.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_stall(ept, 0);
1f1c: 2100 movs r1, #0
1f1e: 4b3f ldr r3, [pc, #252] ; (201c <STACK_SIZE+0x1c>)
1f20: 4798 blx r3
1f22: e02a b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_setup(ept);
1f24: 4b3e ldr r3, [pc, #248] ; (2020 <STACK_SIZE+0x20>)
1f26: 4798 blx r3
1f28: e027 b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_stall(ept, 1);
1f2a: 2101 movs r1, #1
1f2c: 4b3b ldr r3, [pc, #236] ; (201c <STACK_SIZE+0x1c>)
1f2e: 4798 blx r3
1f30: e023 b.n 1f7a <USB_Handler+0x17e>
if (flags & USB_DEVICE_EPINTFLAG_STALL1) {
1f32: 064b lsls r3, r1, #25
1f34: d40e bmi.n 1f54 <USB_Handler+0x158>
} else if (flags & USB_DEVICE_EPINTFLAG_TRFAIL1) {
1f36: 070b lsls r3, r1, #28
1f38: d410 bmi.n 1f5c <USB_Handler+0x160>
} else if (flags & USB_DEVICE_EPINTFLAG_TRCPT1) {
1f3a: 078b lsls r3, r1, #30
1f3c: d412 bmi.n 1f64 <USB_Handler+0x168>
} else if (_usb_d_dev_ep_is_ctrl(ept)) {
1f3e: 2307 movs r3, #7
1f40: 401a ands r2, r3
1f42: 2a01 cmp r2, #1
1f44: d119 bne.n 1f7a <USB_Handler+0x17e>
if (flags & USB_DEVICE_EPINTFLAG_TRFAIL0) {
1f46: 074b lsls r3, r1, #29
1f48: d410 bmi.n 1f6c <USB_Handler+0x170>
} else if (flags & USB_DEVICE_EPINTFLAG_RXSTP) {
1f4a: 06cb lsls r3, r1, #27
1f4c: d515 bpl.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_setup(ept);
1f4e: 4b34 ldr r3, [pc, #208] ; (2020 <STACK_SIZE+0x20>)
1f50: 4798 blx r3
1f52: e012 b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_stall(ept, 1);
1f54: 2101 movs r1, #1
1f56: 4b31 ldr r3, [pc, #196] ; (201c <STACK_SIZE+0x1c>)
1f58: 4798 blx r3
1f5a: e00e b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_trfail(ept, 1);
1f5c: 2101 movs r1, #1
1f5e: 4b31 ldr r3, [pc, #196] ; (2024 <STACK_SIZE+0x24>)
1f60: 4798 blx r3
1f62: e00a b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_in_next(ept, true);
1f64: 2101 movs r1, #1
1f66: 4b30 ldr r3, [pc, #192] ; (2028 <STACK_SIZE+0x28>)
1f68: 4798 blx r3
1f6a: e006 b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_trfail(ept, 0);
1f6c: 2100 movs r1, #0
1f6e: 4b2d ldr r3, [pc, #180] ; (2024 <STACK_SIZE+0x24>)
1f70: 4798 blx r3
1f72: e002 b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_stall(ept, 0);
1f74: 2100 movs r1, #0
1f76: 4b29 ldr r3, [pc, #164] ; (201c <STACK_SIZE+0x1c>)
1f78: 4798 blx r3
1f7a: 3501 adds r5, #1
1f7c: 3414 adds r4, #20
for (i = 0; i < USB_D_N_EP; i++) {
1f7e: 2d09 cmp r5, #9
1f80: d100 bne.n 1f84 <USB_Handler+0x188>
1f82: e768 b.n 1e56 <USB_Handler+0x5a>
1f84: 0020 movs r0, r4
if (ept->ep == 0xFF) {
1f86: 7ca1 ldrb r1, [r4, #18]
1f88: 29ff cmp r1, #255 ; 0xff
1f8a: d0f6 beq.n 1f7a <USB_Handler+0x17e>
if (!(epint & (1u << epn))) {
1f8c: 230f movs r3, #15
1f8e: 400b ands r3, r1
1f90: 2101 movs r1, #1
1f92: 4099 lsls r1, r3
1f94: 420e tst r6, r1
1f96: d0f0 beq.n 1f7a <USB_Handler+0x17e>
flags = hw->DEVICE.DeviceEndpoint[epn].EPINTFLAG.reg;
1f98: 0159 lsls r1, r3, #5
1f9a: 4f24 ldr r7, [pc, #144] ; (202c <STACK_SIZE+0x2c>)
1f9c: 46bc mov ip, r7
1f9e: 4461 add r1, ip
1fa0: 79c9 ldrb r1, [r1, #7]
mask = hw->DEVICE.DeviceEndpoint[epn].EPINTENSET.reg;
1fa2: 015b lsls r3, r3, #5
1fa4: 4f22 ldr r7, [pc, #136] ; (2030 <STACK_SIZE+0x30>)
1fa6: 46bc mov ip, r7
1fa8: 4463 add r3, ip
1faa: 781b ldrb r3, [r3, #0]
flags &= mask;
1fac: 4019 ands r1, r3
if (flags) {
1fae: d0e4 beq.n 1f7a <USB_Handler+0x17e>
if ((ept->flags.bits.eptype == 0x1) && !_usb_d_dev_ep_is_busy(ept)) {
1fb0: 00ab lsls r3, r5, #2
1fb2: 195a adds r2, r3, r5
1fb4: 0092 lsls r2, r2, #2
1fb6: 4b15 ldr r3, [pc, #84] ; (200c <STACK_SIZE+0xc>)
1fb8: 469c mov ip, r3
1fba: 4462 add r2, ip
1fbc: 3270 adds r2, #112 ; 0x70
1fbe: 7dd2 ldrb r2, [r2, #23]
1fc0: 2347 movs r3, #71 ; 0x47
1fc2: 4013 ands r3, r2
1fc4: 2b01 cmp r3, #1
1fc6: d0a3 beq.n 1f10 <USB_Handler+0x114>
} else if (_usb_d_dev_ep_is_in(ept)) {
1fc8: b253 sxtb r3, r2
1fca: 2b00 cmp r3, #0
1fcc: dbb1 blt.n 1f32 <USB_Handler+0x136>
if (flags & USB_DEVICE_EPINTFLAG_STALL0) {
1fce: 068b lsls r3, r1, #26
1fd0: d4d0 bmi.n 1f74 <USB_Handler+0x178>
} else if (flags & USB_DEVICE_EPINTFLAG_TRFAIL0) {
1fd2: 074b lsls r3, r1, #29
1fd4: d40c bmi.n 1ff0 <USB_Handler+0x1f4>
} else if (flags & USB_DEVICE_EPINTFLAG_TRCPT0) {
1fd6: 07cb lsls r3, r1, #31
1fd8: d40e bmi.n 1ff8 <USB_Handler+0x1fc>
} else if (_usb_d_dev_ep_is_ctrl(ept)) {
1fda: 2307 movs r3, #7
1fdc: 401a ands r2, r3
1fde: 2a01 cmp r2, #1
1fe0: d1cb bne.n 1f7a <USB_Handler+0x17e>
if (flags & USB_DEVICE_EPINTFLAG_TRFAIL1) {
1fe2: 070b lsls r3, r1, #28
1fe4: d40c bmi.n 2000 <STACK_SIZE>
} else if (flags & USB_DEVICE_EPINTFLAG_RXSTP) {
1fe6: 06cb lsls r3, r1, #27
1fe8: d5c7 bpl.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_setup(ept);
1fea: 4b0d ldr r3, [pc, #52] ; (2020 <STACK_SIZE+0x20>)
1fec: 4798 blx r3
1fee: e7c4 b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_trfail(ept, 0);
1ff0: 2100 movs r1, #0
1ff2: 4b0c ldr r3, [pc, #48] ; (2024 <STACK_SIZE+0x24>)
1ff4: 4798 blx r3
1ff6: e7c0 b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_out_next(ept, true);
1ff8: 2101 movs r1, #1
1ffa: 4b0e ldr r3, [pc, #56] ; (2034 <STACK_SIZE+0x34>)
1ffc: 4798 blx r3
1ffe: e7bc b.n 1f7a <USB_Handler+0x17e>
_usb_d_dev_handle_trfail(ept, 1);
2000: 2101 movs r1, #1
2002: 4b08 ldr r3, [pc, #32] ; (2024 <STACK_SIZE+0x24>)
2004: 4798 blx r3
2006: e7b8 b.n 1f7a <USB_Handler+0x17e>
2008: 41005000 .word 0x41005000
200c: 20000104 .word 0x20000104
2010: 00000201 .word 0x00000201
2014: 40000800 .word 0x40000800
2018: 00000f81 .word 0x00000f81
201c: 00000dbd .word 0x00000dbd
2020: 00000d31 .word 0x00000d31
2024: 00000e81 .word 0x00000e81
2028: 00000fc5 .word 0x00000fc5
202c: 41005100 .word 0x41005100
2030: 41005109 .word 0x41005109
2034: 0000116d .word 0x0000116d
00002038 <main>:
#include <atmel_start.h>
#include "driver_examples.h"
int main(void)
{
2038: b510 push {r4, lr}
/* Initializes MCU, drivers and middleware */
atmel_start_init();
203a: 4b01 ldr r3, [pc, #4] ; (2040 <main+0x8>)
203c: 4798 blx r3
203e: e7fe b.n 203e <main+0x6>
2040: 00000115 .word 0x00000115
00002044 <cdcdf_acm_req>:
* \param[in] ep Endpoint address.
* \param[in] req Pointer to the request.
* \return Operation status.
*/
static int32_t cdcdf_acm_req(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage)
{
2044: b5f0 push {r4, r5, r6, r7, lr}
2046: b083 sub sp, #12
2048: 0006 movs r6, r0
204a: 000c movs r4, r1
204c: 0015 movs r5, r2
if (0x01 != ((req->bmRequestType >> 5) & 0x03)) { // class request
204e: 780a ldrb r2, [r1, #0]
2050: 0653 lsls r3, r2, #25
2052: 0f9b lsrs r3, r3, #30
2054: 2b01 cmp r3, #1
2056: d000 beq.n 205a <cdcdf_acm_req+0x16>
2058: e06c b.n 2134 <cdcdf_acm_req+0xf0>
return ERR_NOT_FOUND;
}
if ((req->wIndex == _cdcdf_acm_funcd.func_iface[0]) || (req->wIndex == _cdcdf_acm_funcd.func_iface[1])) {
205a: 7909 ldrb r1, [r1, #4]
205c: 7963 ldrb r3, [r4, #5]
205e: 021b lsls r3, r3, #8
2060: 430b orrs r3, r1
2062: 493b ldr r1, [pc, #236] ; (2150 <cdcdf_acm_req+0x10c>)
2064: 7809 ldrb r1, [r1, #0]
2066: 4299 cmp r1, r3
2068: d003 beq.n 2072 <cdcdf_acm_req+0x2e>
206a: 4939 ldr r1, [pc, #228] ; (2150 <cdcdf_acm_req+0x10c>)
206c: 7849 ldrb r1, [r1, #1]
206e: 4299 cmp r1, r3
2070: d163 bne.n 213a <cdcdf_acm_req+0xf6>
if (req->bmRequestType & USB_EP_DIR_IN) {
2072: b252 sxtb r2, r2
2074: 2a00 cmp r2, #0
2076: db0e blt.n 2096 <cdcdf_acm_req+0x52>
uint16_t len = req->wLength;
2078: 79a7 ldrb r7, [r4, #6]
207a: 79e3 ldrb r3, [r4, #7]
207c: 021b lsls r3, r3, #8
207e: 431f orrs r7, r3
uint8_t * ctrl_buf = usbdc_get_ctrl_buffer();
2080: 4b34 ldr r3, [pc, #208] ; (2154 <cdcdf_acm_req+0x110>)
2082: 4798 blx r3
switch (req->bRequest) {
2084: 7863 ldrb r3, [r4, #1]
2086: 2b20 cmp r3, #32
2088: d018 beq.n 20bc <cdcdf_acm_req+0x78>
208a: 2b22 cmp r3, #34 ; 0x22
208c: d03c beq.n 2108 <cdcdf_acm_req+0xc4>
return ERR_INVALID_ARG;
208e: 200d movs r0, #13
2090: 4240 negs r0, r0
return cdcdf_acm_set_req(ep, req, stage);
}
} else {
return ERR_NOT_FOUND;
}
}
2092: b003 add sp, #12
2094: bdf0 pop {r4, r5, r6, r7, pc}
if (USB_DATA_STAGE == stage) {
2096: 2d01 cmp r5, #1
2098: d052 beq.n 2140 <cdcdf_acm_req+0xfc>
switch (req->bRequest) {
209a: 7863 ldrb r3, [r4, #1]
209c: 2b21 cmp r3, #33 ; 0x21
209e: d151 bne.n 2144 <cdcdf_acm_req+0x100>
uint16_t len = req->wLength;
20a0: 79a2 ldrb r2, [r4, #6]
20a2: 79e3 ldrb r3, [r4, #7]
20a4: 021b lsls r3, r3, #8
if (sizeof(struct usb_cdc_line_coding) != len) {
20a6: 4313 orrs r3, r2
20a8: 2b07 cmp r3, #7
20aa: d14e bne.n 214a <cdcdf_acm_req+0x106>
return usbdc_xfer(ep, (uint8_t *)&usbd_cdc_line_coding, len, false);
20ac: 2300 movs r3, #0
20ae: 2207 movs r2, #7
20b0: 4927 ldr r1, [pc, #156] ; (2150 <cdcdf_acm_req+0x10c>)
20b2: 3108 adds r1, #8
20b4: 0030 movs r0, r6
20b6: 4c28 ldr r4, [pc, #160] ; (2158 <cdcdf_acm_req+0x114>)
20b8: 47a0 blx r4
20ba: e7ea b.n 2092 <cdcdf_acm_req+0x4e>
if (sizeof(struct usb_cdc_line_coding) != len) {
20bc: 2f07 cmp r7, #7
20be: d134 bne.n 212a <cdcdf_acm_req+0xe6>
if (USB_SETUP_STAGE == stage) {
20c0: 2d00 cmp r5, #0
20c2: d01a beq.n 20fa <cdcdf_acm_req+0xb6>
memcpy(&line_coding_tmp, ctrl_buf, sizeof(struct usb_cdc_line_coding));
20c4: 2207 movs r2, #7
20c6: 0001 movs r1, r0
20c8: 4668 mov r0, sp
20ca: 4b24 ldr r3, [pc, #144] ; (215c <cdcdf_acm_req+0x118>)
20cc: 4798 blx r3
if ((NULL == cdcdf_acm_set_line_coding) || (true == cdcdf_acm_set_line_coding(&line_coding_tmp))) {
20ce: 4b20 ldr r3, [pc, #128] ; (2150 <cdcdf_acm_req+0x10c>)
20d0: 691b ldr r3, [r3, #16]
20d2: 2b00 cmp r3, #0
20d4: d005 beq.n 20e2 <cdcdf_acm_req+0x9e>
20d6: 4668 mov r0, sp
20d8: 4798 blx r3
20da: 0003 movs r3, r0
return ERR_NONE;
20dc: 2000 movs r0, #0
if ((NULL == cdcdf_acm_set_line_coding) || (true == cdcdf_acm_set_line_coding(&line_coding_tmp))) {
20de: 2b00 cmp r3, #0
20e0: d0d7 beq.n 2092 <cdcdf_acm_req+0x4e>
usbd_cdc_line_coding = line_coding_tmp;
20e2: 4a1b ldr r2, [pc, #108] ; (2150 <cdcdf_acm_req+0x10c>)
20e4: 0013 movs r3, r2
20e6: 9900 ldr r1, [sp, #0]
20e8: 6091 str r1, [r2, #8]
20ea: 466a mov r2, sp
20ec: 8892 ldrh r2, [r2, #4]
20ee: 819a strh r2, [r3, #12]
20f0: 466a mov r2, sp
20f2: 7992 ldrb r2, [r2, #6]
20f4: 739a strb r2, [r3, #14]
return ERR_NONE;
20f6: 2000 movs r0, #0
20f8: e7cb b.n 2092 <cdcdf_acm_req+0x4e>
return usbdc_xfer(ep, ctrl_buf, len, false);
20fa: 2300 movs r3, #0
20fc: 2207 movs r2, #7
20fe: 0001 movs r1, r0
2100: 0030 movs r0, r6
2102: 4c15 ldr r4, [pc, #84] ; (2158 <cdcdf_acm_req+0x114>)
2104: 47a0 blx r4
2106: e7c4 b.n 2092 <cdcdf_acm_req+0x4e>
usbdc_xfer(0, NULL, 0, 0);
2108: 2300 movs r3, #0
210a: 2200 movs r2, #0
210c: 2100 movs r1, #0
210e: 2000 movs r0, #0
2110: 4d11 ldr r5, [pc, #68] ; (2158 <cdcdf_acm_req+0x114>)
2112: 47a8 blx r5
if (NULL != cdcdf_acm_notify_state) {
2114: 4b0e ldr r3, [pc, #56] ; (2150 <cdcdf_acm_req+0x10c>)
2116: 695b ldr r3, [r3, #20]
2118: 2b00 cmp r3, #0
211a: d009 beq.n 2130 <cdcdf_acm_req+0xec>
cdcdf_acm_notify_state(req->wValue);
211c: 78a2 ldrb r2, [r4, #2]
211e: 78e0 ldrb r0, [r4, #3]
2120: 0200 lsls r0, r0, #8
2122: 4310 orrs r0, r2
2124: 4798 blx r3
return ERR_NONE;
2126: 2000 movs r0, #0
2128: e7b3 b.n 2092 <cdcdf_acm_req+0x4e>
return ERR_INVALID_DATA;
212a: 2001 movs r0, #1
212c: 4240 negs r0, r0
212e: e7b0 b.n 2092 <cdcdf_acm_req+0x4e>
return ERR_NONE;
2130: 2000 movs r0, #0
return cdcdf_acm_set_req(ep, req, stage);
2132: e7ae b.n 2092 <cdcdf_acm_req+0x4e>
return ERR_NOT_FOUND;
2134: 200a movs r0, #10
2136: 4240 negs r0, r0
2138: e7ab b.n 2092 <cdcdf_acm_req+0x4e>
return ERR_NOT_FOUND;
213a: 200a movs r0, #10
213c: 4240 negs r0, r0
213e: e7a8 b.n 2092 <cdcdf_acm_req+0x4e>
return ERR_NONE;
2140: 2000 movs r0, #0
2142: e7a6 b.n 2092 <cdcdf_acm_req+0x4e>
return ERR_INVALID_ARG;
2144: 200d movs r0, #13
2146: 4240 negs r0, r0
2148: e7a3 b.n 2092 <cdcdf_acm_req+0x4e>
return ERR_INVALID_DATA;
214a: 2001 movs r0, #1
214c: 4240 negs r0, r0
214e: e7a0 b.n 2092 <cdcdf_acm_req+0x4e>
2150: 200002ec .word 0x200002ec
2154: 00002a15 .word 0x00002a15
2158: 000024c5 .word 0x000024c5
215c: 00002bd9 .word 0x00002bd9
00002160 <cdcdf_acm_ctrl>:
{
2160: b5f0 push {r4, r5, r6, r7, lr}
2162: 46de mov lr, fp
2164: 4657 mov r7, sl
2166: 464e mov r6, r9
2168: 4645 mov r5, r8
216a: b5e0 push {r5, r6, r7, lr}
216c: b083 sub sp, #12
216e: 0016 movs r6, r2
switch (ctrl) {
2170: 2901 cmp r1, #1
2172: d068 beq.n 2246 <cdcdf_acm_ctrl+0xe6>
2174: 2900 cmp r1, #0
2176: d00b beq.n 2190 <cdcdf_acm_ctrl+0x30>
2178: 2902 cmp r1, #2
217a: d100 bne.n 217e <cdcdf_acm_ctrl+0x1e>
217c: e093 b.n 22a6 <cdcdf_acm_ctrl+0x146>
return ERR_INVALID_ARG;
217e: 200d movs r0, #13
2180: 4240 negs r0, r0
}
2182: b003 add sp, #12
2184: bc3c pop {r2, r3, r4, r5}
2186: 4690 mov r8, r2
2188: 4699 mov r9, r3
218a: 46a2 mov sl, r4
218c: 46ab mov fp, r5
218e: bdf0 pop {r4, r5, r6, r7, pc}
struct cdcdf_acm_func_data *func_data = (struct cdcdf_acm_func_data *)(drv->func_data);
2190: 6883 ldr r3, [r0, #8]
2192: 4698 mov r8, r3
ifc = desc->sod;
2194: 6810 ldr r0, [r2, #0]
if (NULL == ifc) {
2196: 2800 cmp r0, #0
2198: d100 bne.n 219c <cdcdf_acm_ctrl+0x3c>
219a: e087 b.n 22ac <cdcdf_acm_ctrl+0x14c>
219c: 9301 str r3, [sp, #4]
219e: 2301 movs r3, #1
21a0: 4443 add r3, r8
21a2: 469b mov fp, r3
if (usb_d_ep_init(ep_desc.bEndpointAddress, ep_desc.bmAttributes, ep_desc.wMaxPacketSize)) {
21a4: 4f47 ldr r7, [pc, #284] ; (22c4 <cdcdf_acm_ctrl+0x164>)
usb_d_ep_enable(func_data->func_ep_out);
21a6: 4b48 ldr r3, [pc, #288] ; (22c8 <cdcdf_acm_ctrl+0x168>)
21a8: 4699 mov r9, r3
ifc_desc.bInterfaceNumber = ifc[2];
21aa: 7882 ldrb r2, [r0, #2]
if ((CDC_CLASS_COMM == ifc_desc.bInterfaceClass) || (CDC_CLASS_DATA == ifc_desc.bInterfaceClass)) {
21ac: 7943 ldrb r3, [r0, #5]
21ae: 2108 movs r1, #8
21b0: 438b bics r3, r1
21b2: 2b02 cmp r3, #2
21b4: d002 beq.n 21bc <cdcdf_acm_ctrl+0x5c>
return ERR_NOT_FOUND;
21b6: 200a movs r0, #10
21b8: 4240 negs r0, r0
21ba: e7e2 b.n 2182 <cdcdf_acm_ctrl+0x22>
21bc: 9901 ldr r1, [sp, #4]
21be: 468a mov sl, r1
if (func_data->func_iface[i] == ifc_desc.bInterfaceNumber) { // Initialized
21c0: 780b ldrb r3, [r1, #0]
21c2: 429a cmp r2, r3
21c4: d075 beq.n 22b2 <cdcdf_acm_ctrl+0x152>
} else if (func_data->func_iface[i] != 0xFF) { // Occupied
21c6: 2bff cmp r3, #255 ; 0xff
21c8: d176 bne.n 22b8 <cdcdf_acm_ctrl+0x158>
func_data->func_iface[i] = ifc_desc.bInterfaceNumber;
21ca: 700a strb r2, [r1, #0]
ep = usb_find_desc(ifc, desc->eod, USB_DT_ENDPOINT);
21cc: 2205 movs r2, #5
21ce: 6871 ldr r1, [r6, #4]
21d0: 4b3e ldr r3, [pc, #248] ; (22cc <cdcdf_acm_ctrl+0x16c>)
21d2: 4798 blx r3
21d4: 1e04 subs r4, r0, #0
while (NULL != ep) {
21d6: d11e bne.n 2216 <cdcdf_acm_ctrl+0xb6>
ifc = usb_find_desc(usb_desc_next(desc->sod), desc->eod, USB_DT_INTERFACE);
21d8: 6830 ldr r0, [r6, #0]
* \param[in] desc Byte pointer to the descriptor start address
* \return Byte pointer to the next descriptor
*/
static inline uint8_t *usb_desc_next(uint8_t *desc)
{
return (desc + usb_desc_len(desc));
21da: 7803 ldrb r3, [r0, #0]
21dc: 18c0 adds r0, r0, r3
21de: 2204 movs r2, #4
21e0: 6871 ldr r1, [r6, #4]
21e2: 4b3a ldr r3, [pc, #232] ; (22cc <cdcdf_acm_ctrl+0x16c>)
21e4: 4798 blx r3
for (i = 0; i < 2; i++) {
21e6: 9b01 ldr r3, [sp, #4]
21e8: 455b cmp r3, fp
21ea: d027 beq.n 223c <cdcdf_acm_ctrl+0xdc>
21ec: 9b01 ldr r3, [sp, #4]
21ee: 3301 adds r3, #1
21f0: 9301 str r3, [sp, #4]
if (NULL == ifc) {
21f2: 2800 cmp r0, #0
21f4: d1d9 bne.n 21aa <cdcdf_acm_ctrl+0x4a>
return ERR_NOT_FOUND;
21f6: 200a movs r0, #10
21f8: 4240 negs r0, r0
21fa: e7c2 b.n 2182 <cdcdf_acm_ctrl+0x22>
func_data->func_ep_in[i] = ep_desc.bEndpointAddress;
21fc: 4653 mov r3, sl
21fe: 709d strb r5, [r3, #2]
usb_d_ep_enable(func_data->func_ep_in[i]);
2200: 0028 movs r0, r5
2202: 4b31 ldr r3, [pc, #196] ; (22c8 <cdcdf_acm_ctrl+0x168>)
2204: 4798 blx r3
desc->sod = ep;
2206: 6034 str r4, [r6, #0]
2208: 7820 ldrb r0, [r4, #0]
220a: 1820 adds r0, r4, r0
ep = usb_find_ep_desc(usb_desc_next(desc->sod), desc->eod);
220c: 6871 ldr r1, [r6, #4]
220e: 4b30 ldr r3, [pc, #192] ; (22d0 <cdcdf_acm_ctrl+0x170>)
2210: 4798 blx r3
2212: 1e04 subs r4, r0, #0
while (NULL != ep) {
2214: d0e0 beq.n 21d8 <cdcdf_acm_ctrl+0x78>
ep_desc.bEndpointAddress = ep[2];
2216: 78a5 ldrb r5, [r4, #2]
return (ptr[0] + (ptr[1] << 8));
2218: 7963 ldrb r3, [r4, #5]
221a: 021b lsls r3, r3, #8
221c: 7922 ldrb r2, [r4, #4]
221e: 18d2 adds r2, r2, r3
if (usb_d_ep_init(ep_desc.bEndpointAddress, ep_desc.bmAttributes, ep_desc.wMaxPacketSize)) {
2220: b292 uxth r2, r2
2222: 78e1 ldrb r1, [r4, #3]
2224: 0028 movs r0, r5
2226: 47b8 blx r7
2228: 2800 cmp r0, #0
222a: d148 bne.n 22be <cdcdf_acm_ctrl+0x15e>
if (ep_desc.bEndpointAddress & USB_EP_DIR_IN) {
222c: b26b sxtb r3, r5
222e: 2b00 cmp r3, #0
2230: dbe4 blt.n 21fc <cdcdf_acm_ctrl+0x9c>
func_data->func_ep_out = ep_desc.bEndpointAddress;
2232: 4643 mov r3, r8
2234: 711d strb r5, [r3, #4]
usb_d_ep_enable(func_data->func_ep_out);
2236: 0028 movs r0, r5
2238: 47c8 blx r9
223a: e7e4 b.n 2206 <cdcdf_acm_ctrl+0xa6>
_cdcdf_acm_funcd.enabled = true;
223c: 2201 movs r2, #1
223e: 4b25 ldr r3, [pc, #148] ; (22d4 <cdcdf_acm_ctrl+0x174>)
2240: 715a strb r2, [r3, #5]
return ERR_NONE;
2242: 2000 movs r0, #0
2244: e79d b.n 2182 <cdcdf_acm_ctrl+0x22>
struct cdcdf_acm_func_data *func_data = (struct cdcdf_acm_func_data *)(drv->func_data);
2246: 6884 ldr r4, [r0, #8]
if (desc) {
2248: 2a00 cmp r2, #0
224a: d008 beq.n 225e <cdcdf_acm_ctrl+0xfe>
ifc_desc.bInterfaceClass = desc->sod[5];
224c: 6813 ldr r3, [r2, #0]
if ((ifc_desc.bInterfaceClass != CDC_CLASS_COMM) && (ifc_desc.bInterfaceClass != CDC_CLASS_DATA)) {
224e: 795b ldrb r3, [r3, #5]
2250: 2208 movs r2, #8
2252: 4393 bics r3, r2
2254: 2b02 cmp r3, #2
2256: d002 beq.n 225e <cdcdf_acm_ctrl+0xfe>
return ERR_NOT_FOUND;
2258: 200a movs r0, #10
225a: 4240 negs r0, r0
225c: e791 b.n 2182 <cdcdf_acm_ctrl+0x22>
if (func_data->func_iface[i] == 0xFF) {
225e: 7823 ldrb r3, [r4, #0]
2260: 2bff cmp r3, #255 ; 0xff
2262: d008 beq.n 2276 <cdcdf_acm_ctrl+0x116>
func_data->func_iface[i] = 0xFF;
2264: 23ff movs r3, #255 ; 0xff
2266: 7023 strb r3, [r4, #0]
if (func_data->func_ep_in[i] != 0xFF) {
2268: 78a0 ldrb r0, [r4, #2]
226a: 28ff cmp r0, #255 ; 0xff
226c: d003 beq.n 2276 <cdcdf_acm_ctrl+0x116>
usb_d_ep_deinit(func_data->func_ep_in[i]);
226e: 4b1a ldr r3, [pc, #104] ; (22d8 <cdcdf_acm_ctrl+0x178>)
2270: 4798 blx r3
func_data->func_ep_in[i] = 0xFF;
2272: 23ff movs r3, #255 ; 0xff
2274: 70a3 strb r3, [r4, #2]
if (func_data->func_iface[i] == 0xFF) {
2276: 7863 ldrb r3, [r4, #1]
2278: 2bff cmp r3, #255 ; 0xff
227a: d008 beq.n 228e <cdcdf_acm_ctrl+0x12e>
func_data->func_iface[i] = 0xFF;
227c: 23ff movs r3, #255 ; 0xff
227e: 7063 strb r3, [r4, #1]
if (func_data->func_ep_in[i] != 0xFF) {
2280: 78e0 ldrb r0, [r4, #3]
2282: 28ff cmp r0, #255 ; 0xff
2284: d003 beq.n 228e <cdcdf_acm_ctrl+0x12e>
usb_d_ep_deinit(func_data->func_ep_in[i]);
2286: 4b14 ldr r3, [pc, #80] ; (22d8 <cdcdf_acm_ctrl+0x178>)
2288: 4798 blx r3
func_data->func_ep_in[i] = 0xFF;
228a: 23ff movs r3, #255 ; 0xff
228c: 70e3 strb r3, [r4, #3]
if (func_data->func_ep_out != 0xFF) {
228e: 7920 ldrb r0, [r4, #4]
2290: 28ff cmp r0, #255 ; 0xff
2292: d003 beq.n 229c <cdcdf_acm_ctrl+0x13c>
usb_d_ep_deinit(func_data->func_ep_out);
2294: 4b10 ldr r3, [pc, #64] ; (22d8 <cdcdf_acm_ctrl+0x178>)
2296: 4798 blx r3
func_data->func_ep_out = 0xFF;
2298: 23ff movs r3, #255 ; 0xff
229a: 7123 strb r3, [r4, #4]
_cdcdf_acm_funcd.enabled = false;
229c: 2200 movs r2, #0
229e: 4b0d ldr r3, [pc, #52] ; (22d4 <cdcdf_acm_ctrl+0x174>)
22a0: 715a strb r2, [r3, #5]
return ERR_NONE;
22a2: 2000 movs r0, #0
22a4: e76d b.n 2182 <cdcdf_acm_ctrl+0x22>
return ERR_UNSUPPORTED_OP;
22a6: 201b movs r0, #27
22a8: 4240 negs r0, r0
22aa: e76a b.n 2182 <cdcdf_acm_ctrl+0x22>
return ERR_NOT_FOUND;
22ac: 200a movs r0, #10
22ae: 4240 negs r0, r0
22b0: e767 b.n 2182 <cdcdf_acm_ctrl+0x22>
return ERR_ALREADY_INITIALIZED;
22b2: 2012 movs r0, #18
22b4: 4240 negs r0, r0
22b6: e764 b.n 2182 <cdcdf_acm_ctrl+0x22>
return ERR_NO_RESOURCE;
22b8: 201c movs r0, #28
22ba: 4240 negs r0, r0
22bc: e761 b.n 2182 <cdcdf_acm_ctrl+0x22>
return ERR_NOT_INITIALIZED;
22be: 2014 movs r0, #20
22c0: 4240 negs r0, r0
22c2: e75e b.n 2182 <cdcdf_acm_ctrl+0x22>
22c4: 000007d5 .word 0x000007d5
22c8: 00000869 .word 0x00000869
22cc: 00002a31 .word 0x00002a31
22d0: 00002a67 .word 0x00002a67
22d4: 200002ec .word 0x200002ec
22d8: 0000083d .word 0x0000083d
000022dc <cdcdf_acm_init>:
/**
* \brief Initialize the USB CDC ACM Function Driver
*/
int32_t cdcdf_acm_init(void)
{
22dc: b510 push {r4, lr}
if (usbdc_get_state() > USBD_S_POWER) {
22de: 4b0a ldr r3, [pc, #40] ; (2308 <cdcdf_acm_init+0x2c>)
22e0: 4798 blx r3
22e2: 2801 cmp r0, #1
22e4: d80c bhi.n 2300 <cdcdf_acm_init+0x24>
return ERR_DENIED;
}
_cdcdf_acm.ctrl = cdcdf_acm_ctrl;
22e6: 4809 ldr r0, [pc, #36] ; (230c <cdcdf_acm_init+0x30>)
22e8: 4b09 ldr r3, [pc, #36] ; (2310 <cdcdf_acm_init+0x34>)
22ea: 61c3 str r3, [r0, #28]
_cdcdf_acm.func_data = &_cdcdf_acm_funcd;
22ec: 6200 str r0, [r0, #32]
usbdc_register_function(&_cdcdf_acm);
22ee: 3018 adds r0, #24
22f0: 4b08 ldr r3, [pc, #32] ; (2314 <cdcdf_acm_init+0x38>)
22f2: 4798 blx r3
usbdc_register_handler(USBDC_HDL_REQ, &cdcdf_acm_req_h);
22f4: 4908 ldr r1, [pc, #32] ; (2318 <cdcdf_acm_init+0x3c>)
22f6: 2001 movs r0, #1
22f8: 4b08 ldr r3, [pc, #32] ; (231c <cdcdf_acm_init+0x40>)
22fa: 4798 blx r3
return ERR_NONE;
22fc: 2000 movs r0, #0
}
22fe: bd10 pop {r4, pc}
return ERR_DENIED;
2300: 2011 movs r0, #17
2302: 4240 negs r0, r0
2304: e7fb b.n 22fe <cdcdf_acm_init+0x22>
2306: 46c0 nop ; (mov r8, r8)
2308: 00002a21 .word 0x00002a21
230c: 200002ec .word 0x200002ec
2310: 00002161 .word 0x00002161
2314: 000029b9 .word 0x000029b9
2318: 20000000 .word 0x20000000
231c: 00002921 .word 0x00002921
00002320 <usbdc_unconfig>:
/**
* \brief Unconfig, close all interfaces
*/
static void usbdc_unconfig(void)
{
2320: b510 push {r4, lr}
struct usbdf_driver *func = (struct usbdf_driver *)usbdc.func_list.head;
2322: 4b06 ldr r3, [pc, #24] ; (233c <usbdc_unconfig+0x1c>)
2324: 691c ldr r4, [r3, #16]
while (NULL != func) {
2326: 2c00 cmp r4, #0
2328: d007 beq.n 233a <usbdc_unconfig+0x1a>
func->ctrl(func, USBDF_DISABLE, NULL);
232a: 2200 movs r2, #0
232c: 2101 movs r1, #1
232e: 0020 movs r0, r4
2330: 6863 ldr r3, [r4, #4]
2332: 4798 blx r3
func = func->next;
2334: 6824 ldr r4, [r4, #0]
while (NULL != func) {
2336: 2c00 cmp r4, #0
2338: d1f7 bne.n 232a <usbdc_unconfig+0xa>
}
}
233a: bd10 pop {r4, pc}
233c: 20000310 .word 0x20000310
00002340 <usbdc_change_notify>:
}
}
/** Invoke all registered Change notification callbacks. */
static void usbdc_change_notify(enum usbdc_change_type change, uint32_t value)
{
2340: b570 push {r4, r5, r6, lr}
2342: 0006 movs r6, r0
2344: 000d movs r5, r1
struct usbdc_change_handler *cg = (struct usbdc_change_handler *)usbdc.handlers.change_list.head;
2346: 4b07 ldr r3, [pc, #28] ; (2364 <usbdc_change_notify+0x24>)
2348: 68dc ldr r4, [r3, #12]
while (cg != NULL) {
234a: 2c00 cmp r4, #0
234c: d103 bne.n 2356 <usbdc_change_notify+0x16>
if (NULL != cg->cb) {
cg->cb(change, value);
}
cg = cg->next;
}
}
234e: bd70 pop {r4, r5, r6, pc}
cg = cg->next;
2350: 6824 ldr r4, [r4, #0]
while (cg != NULL) {
2352: 2c00 cmp r4, #0
2354: d0fb beq.n 234e <usbdc_change_notify+0xe>
if (NULL != cg->cb) {
2356: 6863 ldr r3, [r4, #4]
2358: 2b00 cmp r3, #0
235a: d0f9 beq.n 2350 <usbdc_change_notify+0x10>
cg->cb(change, value);
235c: 0029 movs r1, r5
235e: 0030 movs r0, r6
2360: 4798 blx r3
2362: e7f5 b.n 2350 <usbdc_change_notify+0x10>
2364: 20000310 .word 0x20000310
00002368 <usbdc_request_handler>:
/** Invoke all registered request callbacks until request handled. */
static int32_t usbdc_request_handler(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage)
{
2368: b5f8 push {r3, r4, r5, r6, r7, lr}
236a: 0007 movs r7, r0
236c: 000e movs r6, r1
236e: 0015 movs r5, r2
struct usbdc_req_handler *h = (struct usbdc_req_handler *)usbdc.handlers.req_list.head;
2370: 4b0d ldr r3, [pc, #52] ; (23a8 <usbdc_request_handler+0x40>)
2372: 689c ldr r4, [r3, #8]
int32_t rc;
while (h != NULL) {
2374: 2c00 cmp r4, #0
2376: d104 bne.n 2382 <usbdc_request_handler+0x1a>
return -1;
}
}
h = h->next;
}
return false;
2378: 2000 movs r0, #0
237a: e011 b.n 23a0 <usbdc_request_handler+0x38>
h = h->next;
237c: 6824 ldr r4, [r4, #0]
while (h != NULL) {
237e: 2c00 cmp r4, #0
2380: d00d beq.n 239e <usbdc_request_handler+0x36>
if (NULL != h->cb) {
2382: 6863 ldr r3, [r4, #4]
2384: 2b00 cmp r3, #0
2386: d0f9 beq.n 237c <usbdc_request_handler+0x14>
rc = h->cb(ep, req, stage);
2388: 002a movs r2, r5
238a: 0031 movs r1, r6
238c: 0038 movs r0, r7
238e: 4798 blx r3
if (0 == rc) {
2390: 2800 cmp r0, #0
2392: d006 beq.n 23a2 <usbdc_request_handler+0x3a>
} else if (ERR_NOT_FOUND != rc) {
2394: 300a adds r0, #10
2396: d0f1 beq.n 237c <usbdc_request_handler+0x14>
return -1;
2398: 2001 movs r0, #1
239a: 4240 negs r0, r0
239c: e000 b.n 23a0 <usbdc_request_handler+0x38>
return false;
239e: 2000 movs r0, #0
}
23a0: bdf8 pop {r3, r4, r5, r6, r7, pc}
return true;
23a2: 2001 movs r0, #1
23a4: e7fc b.n 23a0 <usbdc_request_handler+0x38>
23a6: 46c0 nop ; (mov r8, r8)
23a8: 20000310 .word 0x20000310
000023ac <usbd_sof_cb>:
/**
* \brief Callback invoked on USB device SOF
*/
static void usbd_sof_cb(void)
{
23ac: b510 push {r4, lr}
struct usbdc_sof_handler *sof = (struct usbdc_sof_handler *)usbdc.handlers.sof_list.head;
23ae: 4b06 ldr r3, [pc, #24] ; (23c8 <usbd_sof_cb+0x1c>)
23b0: 685c ldr r4, [r3, #4]
while (sof != NULL) {
23b2: 2c00 cmp r4, #0
23b4: d103 bne.n 23be <usbd_sof_cb+0x12>
usbdc_sof_notify();
}
23b6: bd10 pop {r4, pc}
sof = sof->next;
23b8: 6824 ldr r4, [r4, #0]
while (sof != NULL) {
23ba: 2c00 cmp r4, #0
23bc: d0fb beq.n 23b6 <usbd_sof_cb+0xa>
if (NULL != sof->cb) {
23be: 6863 ldr r3, [r4, #4]
23c0: 2b00 cmp r3, #0
23c2: d0f9 beq.n 23b8 <usbd_sof_cb+0xc>
sof->cb();
23c4: 4798 blx r3
23c6: e7f7 b.n 23b8 <usbd_sof_cb+0xc>
23c8: 20000310 .word 0x20000310
000023cc <usbdc_cb_ctl_done>:
* \return Data has error or not.
* \retval true There is data error, protocol error.
* \retval false There is no data error.
*/
static bool usbdc_cb_ctl_done(const uint8_t ep, const enum usb_xfer_code code, struct usb_req *req)
{
23cc: b510 push {r4, lr}
23ce: 0014 movs r4, r2
(void)ep;
switch (code) {
23d0: 2900 cmp r1, #0
23d2: d003 beq.n 23dc <usbdc_cb_ctl_done+0x10>
23d4: 2901 cmp r1, #1
23d6: d029 beq.n 242c <usbdc_cb_ctl_done+0x60>
return usbdc_ctrl_data_end(req);
default:
break;
}
return false;
}
23d8: 2000 movs r0, #0
23da: bd10 pop {r4, pc}
if (req->bmRequestType != USB_REQT_TYPE_STANDARD) {
23dc: 7813 ldrb r3, [r2, #0]
23de: 2b00 cmp r3, #0
23e0: d1fa bne.n 23d8 <usbdc_cb_ctl_done+0xc>
switch (req->bRequest) {
23e2: 7853 ldrb r3, [r2, #1]
23e4: 2b05 cmp r3, #5
23e6: d011 beq.n 240c <usbdc_cb_ctl_done+0x40>
23e8: 2b09 cmp r3, #9
23ea: d1f5 bne.n 23d8 <usbdc_cb_ctl_done+0xc>
usbdc.cfg_value = req->wValue;
23ec: 7892 ldrb r2, [r2, #2]
23ee: 4b12 ldr r3, [pc, #72] ; (2438 <usbdc_cb_ctl_done+0x6c>)
23f0: 76da strb r2, [r3, #27]
usbdc.state = req->wValue ? USBD_S_CONFIG : USBD_S_ADDRESS;
23f2: 78a3 ldrb r3, [r4, #2]
23f4: 78e1 ldrb r1, [r4, #3]
23f6: 0209 lsls r1, r1, #8
23f8: 4319 orrs r1, r3
23fa: 1e4b subs r3, r1, #1
23fc: 4199 sbcs r1, r3
23fe: 3103 adds r1, #3
2400: 4b0d ldr r3, [pc, #52] ; (2438 <usbdc_cb_ctl_done+0x6c>)
2402: 7699 strb r1, [r3, #26]
usbdc_change_notify(USBDC_C_STATE, usbdc.state);
2404: 2001 movs r0, #1
2406: 4b0d ldr r3, [pc, #52] ; (243c <usbdc_cb_ctl_done+0x70>)
2408: 4798 blx r3
240a: e7e5 b.n 23d8 <usbdc_cb_ctl_done+0xc>
usb_d_set_address(addr);
240c: 7890 ldrb r0, [r2, #2]
240e: 4b0c ldr r3, [pc, #48] ; (2440 <usbdc_cb_ctl_done+0x74>)
2410: 4798 blx r3
usbdc.state = req->wValue ? USBD_S_ADDRESS : USBD_S_DEFAULT;
2412: 78a3 ldrb r3, [r4, #2]
2414: 78e1 ldrb r1, [r4, #3]
2416: 0209 lsls r1, r1, #8
2418: 4319 orrs r1, r3
241a: 1e4b subs r3, r1, #1
241c: 4199 sbcs r1, r3
241e: 3102 adds r1, #2
2420: 4b05 ldr r3, [pc, #20] ; (2438 <usbdc_cb_ctl_done+0x6c>)
2422: 7699 strb r1, [r3, #26]
usbdc_change_notify(USBDC_C_STATE, usbdc.state);
2424: 2001 movs r0, #1
2426: 4b05 ldr r3, [pc, #20] ; (243c <usbdc_cb_ctl_done+0x70>)
2428: 4798 blx r3
242a: e7d5 b.n 23d8 <usbdc_cb_ctl_done+0xc>
usbdc_request_handler(0, req, USB_DATA_STAGE);
242c: 2201 movs r2, #1
242e: 0021 movs r1, r4
2430: 2000 movs r0, #0
2432: 4b04 ldr r3, [pc, #16] ; (2444 <usbdc_cb_ctl_done+0x78>)
2434: 4798 blx r3
return usbdc_ctrl_data_end(req);
2436: e7cf b.n 23d8 <usbdc_cb_ctl_done+0xc>
2438: 20000310 .word 0x20000310
243c: 00002341 .word 0x00002341
2440: 000007c9 .word 0x000007c9
2444: 00002369 .word 0x00002369
00002448 <usbdc_reset>:
/**
* \brief USB Device Core Reset
*/
void usbdc_reset(void)
{
2448: b510 push {r4, lr}
usbdc_unconfig();
244a: 4b0d ldr r3, [pc, #52] ; (2480 <usbdc_reset+0x38>)
244c: 4798 blx r3
usbdc.state = USBD_S_DEFAULT;
244e: 4c0d ldr r4, [pc, #52] ; (2484 <usbdc_reset+0x3c>)
2450: 2302 movs r3, #2
2452: 76a3 strb r3, [r4, #26]
usbdc.cfg_value = 0;
2454: 2300 movs r3, #0
2456: 76e3 strb r3, [r4, #27]
usbdc.ifc_alt_map = 0;
2458: 7763 strb r3, [r4, #29]
// Setup EP0
usb_d_ep_deinit(0);
245a: 2000 movs r0, #0
245c: 4b0a ldr r3, [pc, #40] ; (2488 <usbdc_reset+0x40>)
245e: 4798 blx r3
usb_d_ep0_init(usbdc.ctrl_size);
2460: 7f20 ldrb r0, [r4, #28]
2462: 4b0a ldr r3, [pc, #40] ; (248c <usbdc_reset+0x44>)
2464: 4798 blx r3
usb_d_ep_register_callback(0, USB_D_EP_CB_SETUP, (FUNC_PTR)usbdc_cb_ctl_req);
2466: 4a0a ldr r2, [pc, #40] ; (2490 <usbdc_reset+0x48>)
2468: 2100 movs r1, #0
246a: 2000 movs r0, #0
246c: 4c09 ldr r4, [pc, #36] ; (2494 <usbdc_reset+0x4c>)
246e: 47a0 blx r4
usb_d_ep_register_callback(0, USB_D_EP_CB_XFER, (FUNC_PTR)usbdc_cb_ctl_done);
2470: 4a09 ldr r2, [pc, #36] ; (2498 <usbdc_reset+0x50>)
2472: 2102 movs r1, #2
2474: 2000 movs r0, #0
2476: 47a0 blx r4
usb_d_ep_enable(0);
2478: 2000 movs r0, #0
247a: 4b08 ldr r3, [pc, #32] ; (249c <usbdc_reset+0x54>)
247c: 4798 blx r3
}
247e: bd10 pop {r4, pc}
2480: 00002321 .word 0x00002321
2484: 20000310 .word 0x20000310
2488: 0000083d .word 0x0000083d
248c: 00000829 .word 0x00000829
2490: 000024e1 .word 0x000024e1
2494: 00000a45 .word 0x00000a45
2498: 000023cd .word 0x000023cd
249c: 00000869 .word 0x00000869
000024a0 <usbd_event_cb>:
* \brief Callback invoked on USB device events
* \param[in] ev Event code.
* \param[in] param Event parameter for event handling.
*/
static void usbd_event_cb(const enum usb_event ev, const uint32_t param)
{
24a0: b510 push {r4, lr}
(void)param;
switch (ev) {
24a2: 2800 cmp r0, #0
24a4: d002 beq.n 24ac <usbd_event_cb+0xc>
24a6: 2801 cmp r0, #1
24a8: d004 beq.n 24b4 <usbd_event_cb+0x14>
break;
default:
break;
}
}
24aa: bd10 pop {r4, pc}
usbdc_change_notify(USBDC_C_CONN, param);
24ac: 2000 movs r0, #0
24ae: 4b03 ldr r3, [pc, #12] ; (24bc <usbd_event_cb+0x1c>)
24b0: 4798 blx r3
break;
24b2: e7fa b.n 24aa <usbd_event_cb+0xa>
usbdc_reset();
24b4: 4b02 ldr r3, [pc, #8] ; (24c0 <usbd_event_cb+0x20>)
24b6: 4798 blx r3
}
24b8: e7f7 b.n 24aa <usbd_event_cb+0xa>
24ba: 46c0 nop ; (mov r8, r8)
24bc: 00002341 .word 0x00002341
24c0: 00002449 .word 0x00002449
000024c4 <usbdc_xfer>:
/**
* \brief Issue USB device transfer
*/
int32_t usbdc_xfer(uint8_t ep, uint8_t *buf, uint32_t size, bool zlp)
{
24c4: b510 push {r4, lr}
24c6: b084 sub sp, #16
struct usb_d_transfer xfer = {(uint8_t *)buf, size, ep, zlp};
24c8: ac01 add r4, sp, #4
24ca: 9101 str r1, [sp, #4]
24cc: 9202 str r2, [sp, #8]
24ce: 7220 strb r0, [r4, #8]
24d0: 7263 strb r3, [r4, #9]
return usb_d_ep_transfer(&xfer);
24d2: 0020 movs r0, r4
24d4: 4b01 ldr r3, [pc, #4] ; (24dc <usbdc_xfer+0x18>)
24d6: 4798 blx r3
}
24d8: b004 add sp, #16
24da: bd10 pop {r4, pc}
24dc: 000008b5 .word 0x000008b5
000024e0 <usbdc_cb_ctl_req>:
{
24e0: b5f0 push {r4, r5, r6, r7, lr}
24e2: 46c6 mov lr, r8
24e4: b500 push {lr}
24e6: b084 sub sp, #16
24e8: 0005 movs r5, r0
24ea: 000c movs r4, r1
switch (usbdc_request_handler(ep, req, USB_SETUP_STAGE)) {
24ec: 2200 movs r2, #0
24ee: 4bb5 ldr r3, [pc, #724] ; (27c4 <usbdc_cb_ctl_req+0x2e4>)
24f0: 4798 blx r3
24f2: 1c43 adds r3, r0, #1
24f4: d00d beq.n 2512 <usbdc_cb_ctl_req+0x32>
return true;
24f6: 2301 movs r3, #1
switch (usbdc_request_handler(ep, req, USB_SETUP_STAGE)) {
24f8: 2801 cmp r0, #1
24fa: d00b beq.n 2514 <usbdc_cb_ctl_req+0x34>
switch (req->bmRequestType & (USB_REQT_TYPE_MASK | USB_REQT_DIR_IN)) {
24fc: 7822 ldrb r2, [r4, #0]
24fe: 231f movs r3, #31
2500: 0011 movs r1, r2
2502: 4399 bics r1, r3
2504: d00b beq.n 251e <usbdc_cb_ctl_req+0x3e>
2506: b2cb uxtb r3, r1
2508: 2b80 cmp r3, #128 ; 0x80
250a: d100 bne.n 250e <usbdc_cb_ctl_req+0x2e>
250c: e0f8 b.n 2700 <usbdc_cb_ctl_req+0x220>
return false;
250e: 2300 movs r3, #0
2510: e000 b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
2512: 2300 movs r3, #0
}
2514: 0018 movs r0, r3
2516: b004 add sp, #16
2518: bc04 pop {r2}
251a: 4690 mov r8, r2
251c: bdf0 pop {r4, r5, r6, r7, pc}
switch (req->bRequest) {
251e: 7863 ldrb r3, [r4, #1]
2520: 2b0b cmp r3, #11
2522: d900 bls.n 2526 <usbdc_cb_ctl_req+0x46>
2524: e1e4 b.n 28f0 <usbdc_cb_ctl_req+0x410>
2526: 009b lsls r3, r3, #2
2528: 49a7 ldr r1, [pc, #668] ; (27c8 <usbdc_cb_ctl_req+0x2e8>)
252a: 58cb ldr r3, [r1, r3]
252c: 469f mov pc, r3
return (ERR_NONE == usbdc_xfer(ep, NULL, 0, true));
252e: 2301 movs r3, #1
2530: 2200 movs r2, #0
2532: 2100 movs r1, #0
2534: 0028 movs r0, r5
2536: 4ca5 ldr r4, [pc, #660] ; (27cc <usbdc_cb_ctl_req+0x2ec>)
2538: 47a0 blx r4
253a: 4243 negs r3, r0
253c: 4143 adcs r3, r0
253e: b2db uxtb r3, r3
2540: e7e8 b.n 2514 <usbdc_cb_ctl_req+0x34>
if (!usbdc_set_config(req->wValue)) {
2542: 78a2 ldrb r2, [r4, #2]
if (cfg_value == 0) {
2544: 2a00 cmp r2, #0
2546: d01a beq.n 257e <usbdc_cb_ctl_req+0x9e>
cfg_desc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, cfg_value);
2548: 4ba1 ldr r3, [pc, #644] ; (27d0 <usbdc_cb_ctl_req+0x2f0>)
254a: 681b ldr r3, [r3, #0]
254c: 6859 ldr r1, [r3, #4]
254e: 6818 ldr r0, [r3, #0]
2550: 4ba0 ldr r3, [pc, #640] ; (27d4 <usbdc_cb_ctl_req+0x2f4>)
2552: 4798 blx r3
if (NULL == cfg_desc) {
2554: 2800 cmp r0, #0
2556: d100 bne.n 255a <usbdc_cb_ctl_req+0x7a>
2558: e1d4 b.n 2904 <usbdc_cb_ctl_req+0x424>
255a: 78c3 ldrb r3, [r0, #3]
255c: 021b lsls r3, r3, #8
255e: 7881 ldrb r1, [r0, #2]
2560: 18c9 adds r1, r1, r3
desc.eod = cfg_desc + total_len;
2562: b289 uxth r1, r1
2564: 1841 adds r1, r0, r1
2566: 9103 str r1, [sp, #12]
desc.sod = usb_find_desc(cfg_desc, desc.eod, USB_DT_INTERFACE);
2568: 2204 movs r2, #4
256a: 4b9b ldr r3, [pc, #620] ; (27d8 <usbdc_cb_ctl_req+0x2f8>)
256c: 4798 blx r3
256e: 9002 str r0, [sp, #8]
while (NULL != desc.sod) {
2570: 2800 cmp r0, #0
2572: d006 beq.n 2582 <usbdc_cb_ctl_req+0xa2>
2574: 24ff movs r4, #255 ; 0xff
func = (struct usbdf_driver *)usbdc.func_list.head;
2576: 4f96 ldr r7, [pc, #600] ; (27d0 <usbdc_cb_ctl_req+0x2f0>)
desc.sod = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE);
2578: 4b97 ldr r3, [pc, #604] ; (27d8 <usbdc_cb_ctl_req+0x2f8>)
257a: 4698 mov r8, r3
257c: e01a b.n 25b4 <usbdc_cb_ctl_req+0xd4>
usbdc_unconfig();
257e: 4b97 ldr r3, [pc, #604] ; (27dc <usbdc_cb_ctl_req+0x2fc>)
2580: 4798 blx r3
return (ERR_NONE == usbdc_xfer(ep, NULL, 0, true));
2582: 2301 movs r3, #1
2584: 2200 movs r2, #0
2586: 2100 movs r1, #0
2588: 0028 movs r0, r5
258a: 4c90 ldr r4, [pc, #576] ; (27cc <usbdc_cb_ctl_req+0x2ec>)
258c: 47a0 blx r4
258e: 4243 negs r3, r0
2590: 4143 adcs r3, r0
2592: b2db uxtb r3, r3
2594: e7be b.n 2514 <usbdc_cb_ctl_req+0x34>
last_iface = desc.sod[2];
2596: 0034 movs r4, r6
2598: e000 b.n 259c <usbdc_cb_ctl_req+0xbc>
259a: 0034 movs r4, r6
desc.sod = usb_desc_next(desc.sod);
259c: 9802 ldr r0, [sp, #8]
return (desc + usb_desc_len(desc));
259e: 7803 ldrb r3, [r0, #0]
25a0: 18c0 adds r0, r0, r3
25a2: 9002 str r0, [sp, #8]
desc.sod = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE);
25a4: 9b03 ldr r3, [sp, #12]
25a6: 9301 str r3, [sp, #4]
25a8: 2204 movs r2, #4
25aa: 0019 movs r1, r3
25ac: 47c0 blx r8
25ae: 9002 str r0, [sp, #8]
while (NULL != desc.sod) {
25b0: 2800 cmp r0, #0
25b2: d0e6 beq.n 2582 <usbdc_cb_ctl_req+0xa2>
if (last_iface != desc.sod[2] /* bInterfaceNumber */) {
25b4: 7886 ldrb r6, [r0, #2]
25b6: 42a6 cmp r6, r4
25b8: d0f0 beq.n 259c <usbdc_cb_ctl_req+0xbc>
func = (struct usbdf_driver *)usbdc.func_list.head;
25ba: 693c ldr r4, [r7, #16]
while (NULL != func) {
25bc: 2c00 cmp r4, #0
25be: d0ea beq.n 2596 <usbdc_cb_ctl_req+0xb6>
if (func->ctrl(func, USBDF_ENABLE, &desc)) {
25c0: aa02 add r2, sp, #8
25c2: 2100 movs r1, #0
25c4: 0020 movs r0, r4
25c6: 6863 ldr r3, [r4, #4]
25c8: 4798 blx r3
25ca: 2800 cmp r0, #0
25cc: d0e5 beq.n 259a <usbdc_cb_ctl_req+0xba>
func = func->next;
25ce: 6824 ldr r4, [r4, #0]
while (NULL != func) {
25d0: 2c00 cmp r4, #0
25d2: d1f5 bne.n 25c0 <usbdc_cb_ctl_req+0xe0>
last_iface = desc.sod[2];
25d4: 0034 movs r4, r6
25d6: e7e1 b.n 259c <usbdc_cb_ctl_req+0xbc>
switch (req->bmRequestType & USB_REQT_RECIP_MASK) {
25d8: 231f movs r3, #31
25da: 401a ands r2, r3
return false;
25dc: 2300 movs r3, #0
switch (req->bmRequestType & USB_REQT_RECIP_MASK) {
25de: 2a02 cmp r2, #2
25e0: d198 bne.n 2514 <usbdc_cb_ctl_req+0x34>
if (req->wLength != 0) {
25e2: 79a3 ldrb r3, [r4, #6]
25e4: 79e2 ldrb r2, [r4, #7]
25e6: 0212 lsls r2, r2, #8
25e8: 431a orrs r2, r3
return false;
25ea: 2300 movs r3, #0
if (req->wLength != 0) {
25ec: 2a00 cmp r2, #0
25ee: d000 beq.n 25f2 <usbdc_cb_ctl_req+0x112>
25f0: e790 b.n 2514 <usbdc_cb_ctl_req+0x34>
usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_CLR);
25f2: 7920 ldrb r0, [r4, #4]
25f4: 2100 movs r1, #0
25f6: 4b7a ldr r3, [pc, #488] ; (27e0 <usbdc_cb_ctl_req+0x300>)
25f8: 4798 blx r3
usbdc_xfer(ep, NULL, 0, true);
25fa: 2301 movs r3, #1
25fc: 2200 movs r2, #0
25fe: 2100 movs r1, #0
2600: 0028 movs r0, r5
2602: 4c72 ldr r4, [pc, #456] ; (27cc <usbdc_cb_ctl_req+0x2ec>)
2604: 47a0 blx r4
return true;
2606: 2301 movs r3, #1
2608: e784 b.n 2514 <usbdc_cb_ctl_req+0x34>
switch (req->bmRequestType & USB_REQT_RECIP_MASK) {
260a: 231f movs r3, #31
260c: 401a ands r2, r3
return false;
260e: 2300 movs r3, #0
switch (req->bmRequestType & USB_REQT_RECIP_MASK) {
2610: 2a02 cmp r2, #2
2612: d000 beq.n 2616 <usbdc_cb_ctl_req+0x136>
2614: e77e b.n 2514 <usbdc_cb_ctl_req+0x34>
if (req->wLength != 0) {
2616: 79a3 ldrb r3, [r4, #6]
2618: 79e2 ldrb r2, [r4, #7]
261a: 0212 lsls r2, r2, #8
261c: 431a orrs r2, r3
return false;
261e: 2300 movs r3, #0
if (req->wLength != 0) {
2620: 2a00 cmp r2, #0
2622: d000 beq.n 2626 <usbdc_cb_ctl_req+0x146>
2624: e776 b.n 2514 <usbdc_cb_ctl_req+0x34>
usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_SET);
2626: 7920 ldrb r0, [r4, #4]
2628: 2101 movs r1, #1
262a: 4b6d ldr r3, [pc, #436] ; (27e0 <usbdc_cb_ctl_req+0x300>)
262c: 4798 blx r3
usbdc_xfer(ep, NULL, 0, true);
262e: 2301 movs r3, #1
2630: 2200 movs r2, #0
2632: 2100 movs r1, #0
2634: 0028 movs r0, r5
2636: 4c65 ldr r4, [pc, #404] ; (27cc <usbdc_cb_ctl_req+0x2ec>)
2638: 47a0 blx r4
return true;
263a: 2301 movs r3, #1
263c: e76a b.n 2514 <usbdc_cb_ctl_req+0x34>
return usbdc_set_interface(req->wValue, req->wIndex);
263e: 78a3 ldrb r3, [r4, #2]
2640: 78e5 ldrb r5, [r4, #3]
2642: 022d lsls r5, r5, #8
2644: 431d orrs r5, r3
2646: 7923 ldrb r3, [r4, #4]
2648: 7964 ldrb r4, [r4, #5]
264a: 0224 lsls r4, r4, #8
264c: 431c orrs r4, r3
ifc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, usbdc.cfg_value);
264e: 4a60 ldr r2, [pc, #384] ; (27d0 <usbdc_cb_ctl_req+0x2f0>)
2650: 6813 ldr r3, [r2, #0]
2652: 7ed2 ldrb r2, [r2, #27]
2654: 6859 ldr r1, [r3, #4]
2656: 6818 ldr r0, [r3, #0]
2658: 4b5e ldr r3, [pc, #376] ; (27d4 <usbdc_cb_ctl_req+0x2f4>)
265a: 4798 blx r3
if (NULL == ifc) {
265c: 2800 cmp r0, #0
265e: d047 beq.n 26f0 <usbdc_cb_ctl_req+0x210>
desc.sod = ifc;
2660: 9002 str r0, [sp, #8]
return (ptr[0] + (ptr[1] << 8));
2662: 78c3 ldrb r3, [r0, #3]
2664: 021b lsls r3, r3, #8
2666: 7881 ldrb r1, [r0, #2]
2668: 18c9 adds r1, r1, r3
desc.eod = ifc + usb_cfg_desc_total_len(ifc);
266a: b289 uxth r1, r1
266c: 1841 adds r1, r0, r1
266e: 9103 str r1, [sp, #12]
if (NULL == (ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE))) {
2670: 2204 movs r2, #4
2672: 4b59 ldr r3, [pc, #356] ; (27d8 <usbdc_cb_ctl_req+0x2f8>)
2674: 4798 blx r3
2676: 2800 cmp r0, #0
2678: d03c beq.n 26f4 <usbdc_cb_ctl_req+0x214>
ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE);
267a: 4e57 ldr r6, [pc, #348] ; (27d8 <usbdc_cb_ctl_req+0x2f8>)
267c: e008 b.n 2690 <usbdc_cb_ctl_req+0x1b0>
desc.sod = usb_desc_next(desc.sod);
267e: 9802 ldr r0, [sp, #8]
return (desc + usb_desc_len(desc));
2680: 7803 ldrb r3, [r0, #0]
2682: 18c0 adds r0, r0, r3
2684: 9002 str r0, [sp, #8]
ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE);
2686: 2204 movs r2, #4
2688: 9903 ldr r1, [sp, #12]
268a: 47b0 blx r6
if (NULL == ifc) {
268c: 2800 cmp r0, #0
268e: d033 beq.n 26f8 <usbdc_cb_ctl_req+0x218>
while (ifc[2] != ifc_id || ifc[3] != alt_set) {
2690: 7883 ldrb r3, [r0, #2]
2692: 42a3 cmp r3, r4
2694: d1f3 bne.n 267e <usbdc_cb_ctl_req+0x19e>
2696: 78c3 ldrb r3, [r0, #3]
2698: 42ab cmp r3, r5
269a: d1f0 bne.n 267e <usbdc_cb_ctl_req+0x19e>
desc.sod = ifc;
269c: 9002 str r0, [sp, #8]
func = (struct usbdf_driver *)usbdc.func_list.head;
269e: 4b4c ldr r3, [pc, #304] ; (27d0 <usbdc_cb_ctl_req+0x2f0>)
26a0: 691e ldr r6, [r3, #16]
while (NULL != func) {
26a2: 2e00 cmp r6, #0
26a4: d02a beq.n 26fc <usbdc_cb_ctl_req+0x21c>
if (func->ctrl(func, USBDF_DISABLE, &desc)) {
26a6: aa02 add r2, sp, #8
26a8: 2101 movs r1, #1
26aa: 0030 movs r0, r6
26ac: 6873 ldr r3, [r6, #4]
26ae: 4798 blx r3
26b0: 2800 cmp r0, #0
26b2: d004 beq.n 26be <usbdc_cb_ctl_req+0x1de>
func = func->next;
26b4: 6836 ldr r6, [r6, #0]
while (NULL != func) {
26b6: 2e00 cmp r6, #0
26b8: d1f5 bne.n 26a6 <usbdc_cb_ctl_req+0x1c6>
return false;
26ba: 2300 movs r3, #0
26bc: e72a b.n 2514 <usbdc_cb_ctl_req+0x34>
} else if (ERR_NONE == func->ctrl(func, USBDF_ENABLE, &desc)) {
26be: 6873 ldr r3, [r6, #4]
26c0: aa02 add r2, sp, #8
26c2: 2100 movs r1, #0
26c4: 0030 movs r0, r6
26c6: 4798 blx r3
return false;
26c8: 2300 movs r3, #0
} else if (ERR_NONE == func->ctrl(func, USBDF_ENABLE, &desc)) {
26ca: 2800 cmp r0, #0
26cc: d000 beq.n 26d0 <usbdc_cb_ctl_req+0x1f0>
26ce: e721 b.n 2514 <usbdc_cb_ctl_req+0x34>
if (alt_set) {
26d0: 2d00 cmp r5, #0
26d2: d005 beq.n 26e0 <usbdc_cb_ctl_req+0x200>
usbdc.ifc_alt_map |= 1 << ifc_id;
26d4: 493e ldr r1, [pc, #248] ; (27d0 <usbdc_cb_ctl_req+0x2f0>)
26d6: 2201 movs r2, #1
26d8: 40a2 lsls r2, r4
26da: 7f4b ldrb r3, [r1, #29]
26dc: 4313 orrs r3, r2
26de: 774b strb r3, [r1, #29]
usbdc_xfer(0, NULL, 0, 0);
26e0: 2300 movs r3, #0
26e2: 2200 movs r2, #0
26e4: 2100 movs r1, #0
26e6: 2000 movs r0, #0
26e8: 4c38 ldr r4, [pc, #224] ; (27cc <usbdc_cb_ctl_req+0x2ec>)
26ea: 47a0 blx r4
return true;
26ec: 2301 movs r3, #1
26ee: e711 b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
26f0: 2300 movs r3, #0
26f2: e70f b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
26f4: 2300 movs r3, #0
26f6: e70d b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
26f8: 2300 movs r3, #0
26fa: e70b b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
26fc: 2300 movs r3, #0
26fe: e709 b.n 2514 <usbdc_cb_ctl_req+0x34>
switch (req->bRequest) {
2700: 7863 ldrb r3, [r4, #1]
2702: 2b06 cmp r3, #6
2704: d033 beq.n 276e <usbdc_cb_ctl_req+0x28e>
2706: b2d9 uxtb r1, r3
2708: 2906 cmp r1, #6
270a: d922 bls.n 2752 <usbdc_cb_ctl_req+0x272>
270c: 2b08 cmp r3, #8
270e: d100 bne.n 2712 <usbdc_cb_ctl_req+0x232>
2710: e0af b.n 2872 <usbdc_cb_ctl_req+0x392>
2712: 2b0a cmp r3, #10
2714: d000 beq.n 2718 <usbdc_cb_ctl_req+0x238>
2716: e0ed b.n 28f4 <usbdc_cb_ctl_req+0x414>
if (!(usbdc.ifc_alt_map & (1 << req->wIndex))) {
2718: 4b2d ldr r3, [pc, #180] ; (27d0 <usbdc_cb_ctl_req+0x2f0>)
271a: 7f5a ldrb r2, [r3, #29]
271c: 7921 ldrb r1, [r4, #4]
271e: 7963 ldrb r3, [r4, #5]
2720: 021b lsls r3, r3, #8
2722: 430b orrs r3, r1
2724: 411a asrs r2, r3
2726: 07d3 lsls r3, r2, #31
2728: d400 bmi.n 272c <usbdc_cb_ctl_req+0x24c>
272a: e0ca b.n 28c2 <usbdc_cb_ctl_req+0x3e2>
struct usbdf_driver *func = (struct usbdf_driver *)usbdc.func_list.head;
272c: 4b28 ldr r3, [pc, #160] ; (27d0 <usbdc_cb_ctl_req+0x2f0>)
272e: 691d ldr r5, [r3, #16]
return false;
2730: 2300 movs r3, #0
while (NULL != func) {
2732: 2d00 cmp r5, #0
2734: d100 bne.n 2738 <usbdc_cb_ctl_req+0x258>
2736: e6ed b.n 2514 <usbdc_cb_ctl_req+0x34>
if (0 > (rc = func->ctrl(func, USBDF_GET_IFACE, req))) {
2738: 0022 movs r2, r4
273a: 2102 movs r1, #2
273c: 0028 movs r0, r5
273e: 686b ldr r3, [r5, #4]
2740: 4798 blx r3
2742: 2800 cmp r0, #0
2744: db00 blt.n 2748 <usbdc_cb_ctl_req+0x268>
2746: e0c8 b.n 28da <usbdc_cb_ctl_req+0x3fa>
func = func->next;
2748: 682d ldr r5, [r5, #0]
while (NULL != func) {
274a: 2d00 cmp r5, #0
274c: d1f4 bne.n 2738 <usbdc_cb_ctl_req+0x258>
return false;
274e: 2300 movs r3, #0
2750: e6e0 b.n 2514 <usbdc_cb_ctl_req+0x34>
switch (req->bRequest) {
2752: 2b00 cmp r3, #0
2754: d000 beq.n 2758 <usbdc_cb_ctl_req+0x278>
2756: e0cd b.n 28f4 <usbdc_cb_ctl_req+0x414>
switch (req->bmRequestType & USB_REQT_RECIP_MASK) {
2758: 231f movs r3, #31
275a: 401a ands r2, r3
275c: b2d3 uxtb r3, r2
275e: 2b01 cmp r3, #1
2760: d800 bhi.n 2764 <usbdc_cb_ctl_req+0x284>
2762: e092 b.n 288a <usbdc_cb_ctl_req+0x3aa>
2764: 2a02 cmp r2, #2
2766: d100 bne.n 276a <usbdc_cb_ctl_req+0x28a>
2768: e09f b.n 28aa <usbdc_cb_ctl_req+0x3ca>
return false;
276a: 2300 movs r3, #0
276c: e6d2 b.n 2514 <usbdc_cb_ctl_req+0x34>
uint8_t type = (uint8_t)(req->wValue >> 8);
276e: 78a3 ldrb r3, [r4, #2]
2770: 78e2 ldrb r2, [r4, #3]
2772: 0212 lsls r2, r2, #8
2774: 431a orrs r2, r3
2776: 0a13 lsrs r3, r2, #8
switch (type) {
2778: 2b02 cmp r3, #2
277a: d033 beq.n 27e4 <usbdc_cb_ctl_req+0x304>
277c: 2b03 cmp r3, #3
277e: d056 beq.n 282e <usbdc_cb_ctl_req+0x34e>
2780: 2b01 cmp r3, #1
2782: d001 beq.n 2788 <usbdc_cb_ctl_req+0x2a8>
return false;
2784: 2300 movs r3, #0
2786: e6c5 b.n 2514 <usbdc_cb_ctl_req+0x34>
uint16_t length = req->wLength;
2788: 79a2 ldrb r2, [r4, #6]
278a: 79e3 ldrb r3, [r4, #7]
278c: 021b lsls r3, r3, #8
278e: 4313 orrs r3, r2
2790: 1c1a adds r2, r3, #0
2792: 2b12 cmp r3, #18
2794: d900 bls.n 2798 <usbdc_cb_ctl_req+0x2b8>
2796: 2212 movs r2, #18
2798: b294 uxth r4, r2
dev_desc = usb_find_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, USB_DT_DEVICE);
279a: 4b0d ldr r3, [pc, #52] ; (27d0 <usbdc_cb_ctl_req+0x2f0>)
279c: 681b ldr r3, [r3, #0]
279e: 6859 ldr r1, [r3, #4]
27a0: 6818 ldr r0, [r3, #0]
27a2: 2201 movs r2, #1
27a4: 4b0c ldr r3, [pc, #48] ; (27d8 <usbdc_cb_ctl_req+0x2f8>)
27a6: 4798 blx r3
if (!dev_desc) {
27a8: 2800 cmp r0, #0
27aa: d100 bne.n 27ae <usbdc_cb_ctl_req+0x2ce>
27ac: e0a4 b.n 28f8 <usbdc_cb_ctl_req+0x418>
if (ERR_NONE != usbdc_xfer(ep, dev_desc, length, false)) {
27ae: 2300 movs r3, #0
27b0: 0022 movs r2, r4
27b2: 0001 movs r1, r0
27b4: 0028 movs r0, r5
27b6: 4c05 ldr r4, [pc, #20] ; (27cc <usbdc_cb_ctl_req+0x2ec>)
27b8: 47a0 blx r4
27ba: 4243 negs r3, r0
27bc: 4143 adcs r3, r0
27be: b2db uxtb r3, r3
27c0: e6a8 b.n 2514 <usbdc_cb_ctl_req+0x34>
27c2: 46c0 nop ; (mov r8, r8)
27c4: 00002369 .word 0x00002369
27c8: 00002c7c .word 0x00002c7c
27cc: 000024c5 .word 0x000024c5
27d0: 20000310 .word 0x20000310
27d4: 00002aad .word 0x00002aad
27d8: 00002a31 .word 0x00002a31
27dc: 00002321 .word 0x00002321
27e0: 000009dd .word 0x000009dd
uint16_t length = req->wLength;
27e4: 79a3 ldrb r3, [r4, #6]
27e6: 79e6 ldrb r6, [r4, #7]
27e8: 0236 lsls r6, r6, #8
27ea: 431e orrs r6, r3
bool need_zlp = !(length & (usbdc.ctrl_size - 1));
27ec: 4b46 ldr r3, [pc, #280] ; (2908 <usbdc_cb_ctl_req+0x428>)
27ee: 7f1f ldrb r7, [r3, #28]
cfg_desc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, index + 1);
27f0: 681b ldr r3, [r3, #0]
27f2: 3201 adds r2, #1
27f4: b2d2 uxtb r2, r2
27f6: 6859 ldr r1, [r3, #4]
27f8: 6818 ldr r0, [r3, #0]
27fa: 4b44 ldr r3, [pc, #272] ; (290c <usbdc_cb_ctl_req+0x42c>)
27fc: 4798 blx r3
27fe: 1e01 subs r1, r0, #0
if (NULL == cfg_desc) {
2800: d07c beq.n 28fc <usbdc_cb_ctl_req+0x41c>
return (ptr[0] + (ptr[1] << 8));
2802: 78c3 ldrb r3, [r0, #3]
2804: 021b lsls r3, r3, #8
2806: 7884 ldrb r4, [r0, #2]
2808: 18e4 adds r4, r4, r3
280a: b2a4 uxth r4, r4
need_zlp = false;
280c: 2300 movs r3, #0
if (length <= total_len) {
280e: 42a6 cmp r6, r4
2810: d905 bls.n 281e <usbdc_cb_ctl_req+0x33e>
bool need_zlp = !(length & (usbdc.ctrl_size - 1));
2812: 3f01 subs r7, #1
2814: 403e ands r6, r7
2816: 4273 negs r3, r6
2818: 4173 adcs r3, r6
281a: b2db uxtb r3, r3
length = total_len;
281c: 0026 movs r6, r4
if (ERR_NONE != usbdc_xfer(ep, cfg_desc, length, need_zlp)) {
281e: 0032 movs r2, r6
2820: 0028 movs r0, r5
2822: 4c3b ldr r4, [pc, #236] ; (2910 <usbdc_cb_ctl_req+0x430>)
2824: 47a0 blx r4
2826: 4243 negs r3, r0
2828: 4143 adcs r3, r0
282a: b2db uxtb r3, r3
282c: e672 b.n 2514 <usbdc_cb_ctl_req+0x34>
uint16_t length = req->wLength;
282e: 79a3 ldrb r3, [r4, #6]
2830: 79e1 ldrb r1, [r4, #7]
2832: 0209 lsls r1, r1, #8
2834: 4319 orrs r1, r3
2836: 000c movs r4, r1
bool need_zlp = !(length & (usbdc.ctrl_size - 1));
2838: 4b33 ldr r3, [pc, #204] ; (2908 <usbdc_cb_ctl_req+0x428>)
283a: 7f1e ldrb r6, [r3, #28]
str_desc = usb_find_str_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, index);
283c: 681b ldr r3, [r3, #0]
283e: b2d2 uxtb r2, r2
2840: 6859 ldr r1, [r3, #4]
2842: 6818 ldr r0, [r3, #0]
2844: 4b33 ldr r3, [pc, #204] ; (2914 <usbdc_cb_ctl_req+0x434>)
2846: 4798 blx r3
2848: 1e01 subs r1, r0, #0
if (NULL == str_desc) {
284a: d059 beq.n 2900 <usbdc_cb_ctl_req+0x420>
if (length <= str_desc[0]) {
284c: 7802 ldrb r2, [r0, #0]
need_zlp = false;
284e: 2300 movs r3, #0
if (length <= str_desc[0]) {
2850: 4294 cmp r4, r2
2852: d906 bls.n 2862 <usbdc_cb_ctl_req+0x382>
bool need_zlp = !(length & (usbdc.ctrl_size - 1));
2854: 1e73 subs r3, r6, #1
2856: 4023 ands r3, r4
2858: 0018 movs r0, r3
285a: 4243 negs r3, r0
285c: 4143 adcs r3, r0
285e: b2db uxtb r3, r3
length = str_desc[0];
2860: 0014 movs r4, r2
if (ERR_NONE != usbdc_xfer(ep, str_desc, length, need_zlp)) {
2862: 0022 movs r2, r4
2864: 0028 movs r0, r5
2866: 4c2a ldr r4, [pc, #168] ; (2910 <usbdc_cb_ctl_req+0x430>)
2868: 47a0 blx r4
286a: 4243 negs r3, r0
286c: 4143 adcs r3, r0
286e: b2db uxtb r3, r3
2870: e650 b.n 2514 <usbdc_cb_ctl_req+0x34>
*(uint8_t *)usbdc.ctrl_buf = usbdc.cfg_value;
2872: 4b25 ldr r3, [pc, #148] ; (2908 <usbdc_cb_ctl_req+0x428>)
2874: 7eda ldrb r2, [r3, #27]
2876: 6959 ldr r1, [r3, #20]
2878: 700a strb r2, [r1, #0]
usbdc_xfer(ep, usbdc.ctrl_buf, 1, false);
287a: 6959 ldr r1, [r3, #20]
287c: 2300 movs r3, #0
287e: 2201 movs r2, #1
2880: 0028 movs r0, r5
2882: 4c23 ldr r4, [pc, #140] ; (2910 <usbdc_cb_ctl_req+0x430>)
2884: 47a0 blx r4
return true;
2886: 2301 movs r3, #1
2888: e644 b.n 2514 <usbdc_cb_ctl_req+0x34>
st = 0;
288a: 2300 movs r3, #0
288c: 9302 str r3, [sp, #8]
memcpy(usbdc.ctrl_buf, &st, 2);
288e: 4c1e ldr r4, [pc, #120] ; (2908 <usbdc_cb_ctl_req+0x428>)
2890: 2202 movs r2, #2
2892: a902 add r1, sp, #8
2894: 6960 ldr r0, [r4, #20]
2896: 4b20 ldr r3, [pc, #128] ; (2918 <usbdc_cb_ctl_req+0x438>)
2898: 4798 blx r3
usbdc_xfer(ep, usbdc.ctrl_buf, 2, false);
289a: 6961 ldr r1, [r4, #20]
289c: 2300 movs r3, #0
289e: 2202 movs r2, #2
28a0: 0028 movs r0, r5
28a2: 4c1b ldr r4, [pc, #108] ; (2910 <usbdc_cb_ctl_req+0x430>)
28a4: 47a0 blx r4
return true;
28a6: 2301 movs r3, #1
28a8: e634 b.n 2514 <usbdc_cb_ctl_req+0x34>
st = usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_GET);
28aa: 7920 ldrb r0, [r4, #4]
28ac: 2102 movs r1, #2
28ae: 4b1b ldr r3, [pc, #108] ; (291c <usbdc_cb_ctl_req+0x43c>)
28b0: 4798 blx r3
if (st < 0) {
28b2: 2800 cmp r0, #0
28b4: db03 blt.n 28be <usbdc_cb_ctl_req+0x3de>
st = st & 0x1;
28b6: 2301 movs r3, #1
28b8: 4018 ands r0, r3
28ba: 9002 str r0, [sp, #8]
28bc: e7e7 b.n 288e <usbdc_cb_ctl_req+0x3ae>
return false;
28be: 2300 movs r3, #0
28c0: e628 b.n 2514 <usbdc_cb_ctl_req+0x34>
usbdc.ctrl_buf[0] = 0;
28c2: 4b11 ldr r3, [pc, #68] ; (2908 <usbdc_cb_ctl_req+0x428>)
28c4: 2200 movs r2, #0
28c6: 6959 ldr r1, [r3, #20]
28c8: 700a strb r2, [r1, #0]
usbdc_xfer(0, usbdc.ctrl_buf, 1, false);
28ca: 6959 ldr r1, [r3, #20]
28cc: 2300 movs r3, #0
28ce: 3201 adds r2, #1
28d0: 2000 movs r0, #0
28d2: 4c0f ldr r4, [pc, #60] ; (2910 <usbdc_cb_ctl_req+0x430>)
28d4: 47a0 blx r4
return true;
28d6: 2301 movs r3, #1
28d8: e61c b.n 2514 <usbdc_cb_ctl_req+0x34>
usbdc.ctrl_buf[0] = (uint8_t)rc;
28da: 4b0b ldr r3, [pc, #44] ; (2908 <usbdc_cb_ctl_req+0x428>)
28dc: 695a ldr r2, [r3, #20]
28de: 7010 strb r0, [r2, #0]
usbdc_xfer(0, usbdc.ctrl_buf, 1, false);
28e0: 6959 ldr r1, [r3, #20]
28e2: 2300 movs r3, #0
28e4: 2201 movs r2, #1
28e6: 2000 movs r0, #0
28e8: 4c09 ldr r4, [pc, #36] ; (2910 <usbdc_cb_ctl_req+0x430>)
28ea: 47a0 blx r4
return true;
28ec: 2301 movs r3, #1
28ee: e611 b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
28f0: 2300 movs r3, #0
28f2: e60f b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
28f4: 2300 movs r3, #0
28f6: e60d b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
28f8: 2300 movs r3, #0
28fa: e60b b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
28fc: 2300 movs r3, #0
28fe: e609 b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
2900: 2300 movs r3, #0
2902: e607 b.n 2514 <usbdc_cb_ctl_req+0x34>
return false;
2904: 2300 movs r3, #0
2906: e605 b.n 2514 <usbdc_cb_ctl_req+0x34>
2908: 20000310 .word 0x20000310
290c: 00002aad .word 0x00002aad
2910: 000024c5 .word 0x000024c5
2914: 00002b15 .word 0x00002b15
2918: 00002bd9 .word 0x00002bd9
291c: 000009dd .word 0x000009dd
00002920 <usbdc_register_handler>:
/**
* \brief Register the handler
*/
void usbdc_register_handler(enum usbdc_handler_type type, const struct usbdc_handler *h)
{
2920: b510 push {r4, lr}
switch (type) {
2922: 2801 cmp r0, #1
2924: d009 beq.n 293a <usbdc_register_handler+0x1a>
2926: 2800 cmp r0, #0
2928: d002 beq.n 2930 <usbdc_register_handler+0x10>
292a: 2802 cmp r0, #2
292c: d00a beq.n 2944 <usbdc_register_handler+0x24>
list_insert_at_end(&usbdc.handlers.change_list, (void *)h);
break;
default:
break;
}
}
292e: bd10 pop {r4, pc}
list_insert_at_end(&usbdc.handlers.sof_list, (void *)h);
2930: 4807 ldr r0, [pc, #28] ; (2950 <usbdc_register_handler+0x30>)
2932: 3004 adds r0, #4
2934: 4b07 ldr r3, [pc, #28] ; (2954 <usbdc_register_handler+0x34>)
2936: 4798 blx r3
break;
2938: e7f9 b.n 292e <usbdc_register_handler+0xe>
list_insert_at_end(&usbdc.handlers.req_list, (void *)h);
293a: 4805 ldr r0, [pc, #20] ; (2950 <usbdc_register_handler+0x30>)
293c: 3008 adds r0, #8
293e: 4b05 ldr r3, [pc, #20] ; (2954 <usbdc_register_handler+0x34>)
2940: 4798 blx r3
break;
2942: e7f4 b.n 292e <usbdc_register_handler+0xe>
list_insert_at_end(&usbdc.handlers.change_list, (void *)h);
2944: 4802 ldr r0, [pc, #8] ; (2950 <usbdc_register_handler+0x30>)
2946: 300c adds r0, #12
2948: 4b02 ldr r3, [pc, #8] ; (2954 <usbdc_register_handler+0x34>)
294a: 4798 blx r3
}
294c: e7ef b.n 292e <usbdc_register_handler+0xe>
294e: 46c0 nop ; (mov r8, r8)
2950: 20000310 .word 0x20000310
2954: 00000ac1 .word 0x00000ac1
00002958 <usbdc_init>:
/**
* \brief Initialize the USB device core driver
*/
int32_t usbdc_init(uint8_t *ctrl_buf)
{
2958: b570 push {r4, r5, r6, lr}
295a: 0004 movs r4, r0
ASSERT(ctrl_buf);
295c: 1e43 subs r3, r0, #1
295e: 4198 sbcs r0, r3
2960: b2c0 uxtb r0, r0
2962: 4a0c ldr r2, [pc, #48] ; (2994 <usbdc_init+0x3c>)
2964: 490c ldr r1, [pc, #48] ; (2998 <usbdc_init+0x40>)
2966: 4b0d ldr r3, [pc, #52] ; (299c <usbdc_init+0x44>)
2968: 4798 blx r3
int32_t rc;
rc = usb_d_init();
296a: 4b0d ldr r3, [pc, #52] ; (29a0 <usbdc_init+0x48>)
296c: 4798 blx r3
if (rc < 0) {
296e: 2800 cmp r0, #0
2970: db0e blt.n 2990 <usbdc_init+0x38>
return rc;
}
memset(&usbdc, 0, sizeof(usbdc));
2972: 4d0c ldr r5, [pc, #48] ; (29a4 <usbdc_init+0x4c>)
2974: 2220 movs r2, #32
2976: 2100 movs r1, #0
2978: 0028 movs r0, r5
297a: 4b0b ldr r3, [pc, #44] ; (29a8 <usbdc_init+0x50>)
297c: 4798 blx r3
usbdc.ctrl_buf = ctrl_buf;
297e: 616c str r4, [r5, #20]
usb_d_register_callback(USB_D_CB_SOF, (FUNC_PTR)usbd_sof_cb);
2980: 490a ldr r1, [pc, #40] ; (29ac <usbdc_init+0x54>)
2982: 2000 movs r0, #0
2984: 4c0a ldr r4, [pc, #40] ; (29b0 <usbdc_init+0x58>)
2986: 47a0 blx r4
usb_d_register_callback(USB_D_CB_EVENT, (FUNC_PTR)usbd_event_cb);
2988: 490a ldr r1, [pc, #40] ; (29b4 <usbdc_init+0x5c>)
298a: 2001 movs r0, #1
298c: 47a0 blx r4
return 0;
298e: 2000 movs r0, #0
}
2990: bd70 pop {r4, r5, r6, pc}
2992: 46c0 nop ; (mov r8, r8)
2994: 00000355 .word 0x00000355
2998: 00002cac .word 0x00002cac
299c: 00000a95 .word 0x00000a95
29a0: 00000741 .word 0x00000741
29a4: 20000310 .word 0x20000310
29a8: 00002beb .word 0x00002beb
29ac: 000023ad .word 0x000023ad
29b0: 000007a5 .word 0x000007a5
29b4: 000024a1 .word 0x000024a1
000029b8 <usbdc_register_function>:
* \brief Register/unregister function support of a USB device function
*
* Must be invoked when USB device is stopped.
*/
void usbdc_register_function(struct usbdf_driver *func)
{
29b8: b510 push {r4, lr}
29ba: 0001 movs r1, r0
list_insert_at_end(&usbdc.func_list, func);
29bc: 4802 ldr r0, [pc, #8] ; (29c8 <usbdc_register_function+0x10>)
29be: 3010 adds r0, #16
29c0: 4b02 ldr r3, [pc, #8] ; (29cc <usbdc_register_function+0x14>)
29c2: 4798 blx r3
}
29c4: bd10 pop {r4, pc}
29c6: 46c0 nop ; (mov r8, r8)
29c8: 20000310 .word 0x20000310
29cc: 00000ac1 .word 0x00000ac1
000029d0 <usbdc_start>:
/**
* \brief Start the USB device driver with specific descriptors set
*/
int32_t usbdc_start(struct usbd_descriptors *desces)
{
29d0: b510 push {r4, lr}
if (usbdc.state >= USBD_S_POWER) {
29d2: 4b0b ldr r3, [pc, #44] ; (2a00 <usbdc_start+0x30>)
29d4: 7e9b ldrb r3, [r3, #26]
29d6: 2b00 cmp r3, #0
29d8: d10c bne.n 29f4 <usbdc_start+0x24>
return ERR_BUSY;
}
if (desces) {
29da: 2800 cmp r0, #0
29dc: d00d beq.n 29fa <usbdc_start+0x2a>
usbdc.desces.ls_fs = desces;
29de: 4b08 ldr r3, [pc, #32] ; (2a00 <usbdc_start+0x30>)
29e0: 6018 str r0, [r3, #0]
#endif
} else {
return ERR_BAD_DATA;
}
usbdc.ctrl_size = desces->sod[7];
29e2: 6802 ldr r2, [r0, #0]
29e4: 79d2 ldrb r2, [r2, #7]
29e6: 771a strb r2, [r3, #28]
usbdc.state = USBD_S_POWER;
29e8: 2201 movs r2, #1
29ea: 769a strb r2, [r3, #26]
usb_d_enable();
29ec: 4b05 ldr r3, [pc, #20] ; (2a04 <usbdc_start+0x34>)
29ee: 4798 blx r3
return ERR_NONE;
29f0: 2000 movs r0, #0
}
29f2: bd10 pop {r4, pc}
return ERR_BUSY;
29f4: 2004 movs r0, #4
29f6: 4240 negs r0, r0
29f8: e7fb b.n 29f2 <usbdc_start+0x22>
return ERR_BAD_DATA;
29fa: 2009 movs r0, #9
29fc: 4240 negs r0, r0
29fe: e7f8 b.n 29f2 <usbdc_start+0x22>
2a00: 20000310 .word 0x20000310
2a04: 000007b1 .word 0x000007b1
00002a08 <usbdc_attach>:
/**
* \brief Attach the USB device to host
*/
void usbdc_attach(void)
{
2a08: b510 push {r4, lr}
usb_d_attach();
2a0a: 4b01 ldr r3, [pc, #4] ; (2a10 <usbdc_attach+0x8>)
2a0c: 4798 blx r3
}
2a0e: bd10 pop {r4, pc}
2a10: 000007bd .word 0x000007bd
00002a14 <usbdc_get_ctrl_buffer>:
/**
* \brief Return USB Device endpoint0 buffer
*/
uint8_t *usbdc_get_ctrl_buffer(void)
{
return usbdc.ctrl_buf;
2a14: 4b01 ldr r3, [pc, #4] ; (2a1c <usbdc_get_ctrl_buffer+0x8>)
2a16: 6958 ldr r0, [r3, #20]
}
2a18: 4770 bx lr
2a1a: 46c0 nop ; (mov r8, r8)
2a1c: 20000310 .word 0x20000310
00002a20 <usbdc_get_state>:
/**
* \brief Return current USB state
*/
uint8_t usbdc_get_state(void)
{
if (usbdc.state & USBD_S_SUSPEND) {
2a20: 4b02 ldr r3, [pc, #8] ; (2a2c <usbdc_get_state+0xc>)
2a22: 7e98 ldrb r0, [r3, #26]
2a24: 06c3 lsls r3, r0, #27
2a26: d500 bpl.n 2a2a <usbdc_get_state+0xa>
return USBD_S_SUSPEND;
2a28: 2010 movs r0, #16
}
return usbdc.state;
}
2a2a: 4770 bx lr
2a2c: 20000310 .word 0x20000310
00002a30 <usb_find_desc>:
#define _param_error_check(cond) ASSERT(cond)
#define _desc_len_check() ASSERT(usb_desc_len(desc) >= 2)
#endif
uint8_t *usb_find_desc(uint8_t *desc, uint8_t *eof, uint8_t type)
{
2a30: b510 push {r4, lr}
_param_error_check(desc && eof && (desc < eof));
while (desc < eof) {
2a32: 4288 cmp r0, r1
2a34: d211 bcs.n 2a5a <usb_find_desc+0x2a>
return desc[0];
2a36: 7803 ldrb r3, [r0, #0]
_desc_len_check();
2a38: 2b01 cmp r3, #1
2a3a: d910 bls.n 2a5e <usb_find_desc+0x2e>
if (type == usb_desc_type(desc)) {
2a3c: 7844 ldrb r4, [r0, #1]
2a3e: 4294 cmp r4, r2
2a40: d00a beq.n 2a58 <usb_find_desc+0x28>
return (desc + usb_desc_len(desc));
2a42: 18c0 adds r0, r0, r3
while (desc < eof) {
2a44: 4281 cmp r1, r0
2a46: d906 bls.n 2a56 <usb_find_desc+0x26>
return desc[0];
2a48: 7803 ldrb r3, [r0, #0]
_desc_len_check();
2a4a: 2b01 cmp r3, #1
2a4c: d909 bls.n 2a62 <usb_find_desc+0x32>
return desc[1];
2a4e: 7844 ldrb r4, [r0, #1]
if (type == usb_desc_type(desc)) {
2a50: 4294 cmp r4, r2
2a52: d1f6 bne.n 2a42 <usb_find_desc+0x12>
2a54: e000 b.n 2a58 <usb_find_desc+0x28>
return desc;
}
desc = usb_desc_next(desc);
}
return NULL;
2a56: 2000 movs r0, #0
}
2a58: bd10 pop {r4, pc}
return NULL;
2a5a: 2000 movs r0, #0
2a5c: e7fc b.n 2a58 <usb_find_desc+0x28>
_desc_len_check();
2a5e: 2000 movs r0, #0
2a60: e7fa b.n 2a58 <usb_find_desc+0x28>
2a62: 2000 movs r0, #0
2a64: e7f8 b.n 2a58 <usb_find_desc+0x28>
00002a66 <usb_find_ep_desc>:
uint8_t *usb_find_ep_desc(uint8_t *desc, uint8_t *eof)
{
_param_error_check(desc && eof && (desc < eof));
while (desc < eof) {
2a66: 4288 cmp r0, r1
2a68: d215 bcs.n 2a96 <usb_find_ep_desc+0x30>
return desc[0];
2a6a: 7803 ldrb r3, [r0, #0]
_desc_len_check();
2a6c: 2b01 cmp r3, #1
2a6e: d914 bls.n 2a9a <usb_find_ep_desc+0x34>
return desc[1];
2a70: 7842 ldrb r2, [r0, #1]
if (USB_DT_INTERFACE == usb_desc_type(desc)) {
2a72: 2a04 cmp r2, #4
2a74: d013 beq.n 2a9e <usb_find_ep_desc+0x38>
break;
}
if (USB_DT_ENDPOINT == usb_desc_type(desc)) {
2a76: 2a05 cmp r2, #5
2a78: d00c beq.n 2a94 <usb_find_ep_desc+0x2e>
return (desc + usb_desc_len(desc));
2a7a: 18c0 adds r0, r0, r3
while (desc < eof) {
2a7c: 4281 cmp r1, r0
2a7e: d908 bls.n 2a92 <usb_find_ep_desc+0x2c>
return desc[0];
2a80: 7803 ldrb r3, [r0, #0]
_desc_len_check();
2a82: 2b01 cmp r3, #1
2a84: d90d bls.n 2aa2 <usb_find_ep_desc+0x3c>
return desc[1];
2a86: 7842 ldrb r2, [r0, #1]
if (USB_DT_INTERFACE == usb_desc_type(desc)) {
2a88: 2a04 cmp r2, #4
2a8a: d00c beq.n 2aa6 <usb_find_ep_desc+0x40>
if (USB_DT_ENDPOINT == usb_desc_type(desc)) {
2a8c: 2a05 cmp r2, #5
2a8e: d1f4 bne.n 2a7a <usb_find_ep_desc+0x14>
2a90: e000 b.n 2a94 <usb_find_ep_desc+0x2e>
return desc;
}
desc = usb_desc_next(desc);
}
return NULL;
2a92: 2000 movs r0, #0
}
2a94: 4770 bx lr
return NULL;
2a96: 2000 movs r0, #0
2a98: e7fc b.n 2a94 <usb_find_ep_desc+0x2e>
_desc_len_check();
2a9a: 2000 movs r0, #0
2a9c: e7fa b.n 2a94 <usb_find_ep_desc+0x2e>
return NULL;
2a9e: 2000 movs r0, #0
2aa0: e7f8 b.n 2a94 <usb_find_ep_desc+0x2e>
_desc_len_check();
2aa2: 2000 movs r0, #0
2aa4: e7f6 b.n 2a94 <usb_find_ep_desc+0x2e>
return NULL;
2aa6: 2000 movs r0, #0
2aa8: e7f4 b.n 2a94 <usb_find_ep_desc+0x2e>
...
00002aac <usb_find_cfg_desc>:
uint8_t *usb_find_cfg_desc(uint8_t *desc, uint8_t *eof, uint8_t cfg_value)
{
2aac: b570 push {r4, r5, r6, lr}
2aae: 000c movs r4, r1
2ab0: 0015 movs r5, r2
_param_error_check(desc && eof && (desc < eof));
desc = usb_find_desc(desc, eof, USB_DT_CONFIG);
2ab2: 2202 movs r2, #2
2ab4: 4b16 ldr r3, [pc, #88] ; (2b10 <usb_find_cfg_desc+0x64>)
2ab6: 4798 blx r3
if (!desc) {
2ab8: 2800 cmp r0, #0
2aba: d01d beq.n 2af8 <usb_find_cfg_desc+0x4c>
return NULL;
}
while (desc < eof) {
2abc: 4284 cmp r4, r0
2abe: d91c bls.n 2afa <usb_find_cfg_desc+0x4e>
_desc_len_check();
2ac0: 7803 ldrb r3, [r0, #0]
2ac2: 2b01 cmp r3, #1
2ac4: d91b bls.n 2afe <usb_find_cfg_desc+0x52>
if (desc[1] != USB_DT_CONFIG) {
2ac6: 7843 ldrb r3, [r0, #1]
2ac8: 2b02 cmp r3, #2
2aca: d11a bne.n 2b02 <usb_find_cfg_desc+0x56>
break;
}
if (desc[5] == cfg_value) {
2acc: 7943 ldrb r3, [r0, #5]
2ace: 42ab cmp r3, r5
2ad0: d012 beq.n 2af8 <usb_find_cfg_desc+0x4c>
return (ptr[0] + (ptr[1] << 8));
2ad2: 78c2 ldrb r2, [r0, #3]
2ad4: 0212 lsls r2, r2, #8
2ad6: 7883 ldrb r3, [r0, #2]
2ad8: 189b adds r3, r3, r2
* \param[in] cfg_desc Byte pointer to the descriptor start address
* \return Byte pointer to descriptor after configuration end
*/
static inline uint8_t *usb_cfg_desc_next(uint8_t *cfg_desc)
{
return (cfg_desc + usb_cfg_desc_total_len(cfg_desc));
2ada: b29b uxth r3, r3
2adc: 18c0 adds r0, r0, r3
while (desc < eof) {
2ade: 4284 cmp r4, r0
2ae0: d909 bls.n 2af6 <usb_find_cfg_desc+0x4a>
_desc_len_check();
2ae2: 7803 ldrb r3, [r0, #0]
2ae4: 2b01 cmp r3, #1
2ae6: d90e bls.n 2b06 <usb_find_cfg_desc+0x5a>
if (desc[1] != USB_DT_CONFIG) {
2ae8: 7843 ldrb r3, [r0, #1]
2aea: 2b02 cmp r3, #2
2aec: d10d bne.n 2b0a <usb_find_cfg_desc+0x5e>
if (desc[5] == cfg_value) {
2aee: 7943 ldrb r3, [r0, #5]
2af0: 42ab cmp r3, r5
2af2: d1ee bne.n 2ad2 <usb_find_cfg_desc+0x26>
2af4: e000 b.n 2af8 <usb_find_cfg_desc+0x4c>
return desc;
}
desc = usb_cfg_desc_next(desc);
}
return NULL;
2af6: 2000 movs r0, #0
}
2af8: bd70 pop {r4, r5, r6, pc}
return NULL;
2afa: 2000 movs r0, #0
2afc: e7fc b.n 2af8 <usb_find_cfg_desc+0x4c>
_desc_len_check();
2afe: 2000 movs r0, #0
2b00: e7fa b.n 2af8 <usb_find_cfg_desc+0x4c>
return NULL;
2b02: 2000 movs r0, #0
2b04: e7f8 b.n 2af8 <usb_find_cfg_desc+0x4c>
_desc_len_check();
2b06: 2000 movs r0, #0
2b08: e7f6 b.n 2af8 <usb_find_cfg_desc+0x4c>
return NULL;
2b0a: 2000 movs r0, #0
2b0c: e7f4 b.n 2af8 <usb_find_cfg_desc+0x4c>
2b0e: 46c0 nop ; (mov r8, r8)
2b10: 00002a31 .word 0x00002a31
00002b14 <usb_find_str_desc>:
}
return NULL;
}
uint8_t *usb_find_str_desc(uint8_t *desc, uint8_t *eof, uint8_t str_index)
{
2b14: b5f8 push {r3, r4, r5, r6, r7, lr}
2b16: 000d movs r5, r1
2b18: 0017 movs r7, r2
uint8_t i;
_param_error_check(desc && eof && (desc < eof));
for (i = 0; desc < eof;) {
2b1a: 4288 cmp r0, r1
2b1c: d212 bcs.n 2b44 <usb_find_str_desc+0x30>
2b1e: 2400 movs r4, #0
desc = usb_find_desc(desc, eof, USB_DT_STRING);
2b20: 4e0a ldr r6, [pc, #40] ; (2b4c <usb_find_str_desc+0x38>)
2b22: 2203 movs r2, #3
2b24: 0029 movs r1, r5
2b26: 47b0 blx r6
if (desc) {
2b28: 2800 cmp r0, #0
2b2a: d00e beq.n 2b4a <usb_find_str_desc+0x36>
return desc[0];
2b2c: 7803 ldrb r3, [r0, #0]
_desc_len_check();
2b2e: 2b01 cmp r3, #1
2b30: d90a bls.n 2b48 <usb_find_str_desc+0x34>
if (i == str_index) {
2b32: 42a7 cmp r7, r4
2b34: d009 beq.n 2b4a <usb_find_str_desc+0x36>
return desc;
}
i++;
2b36: 3401 adds r4, #1
2b38: b2e4 uxtb r4, r4
return (desc + usb_desc_len(desc));
2b3a: 18c0 adds r0, r0, r3
for (i = 0; desc < eof;) {
2b3c: 4285 cmp r5, r0
2b3e: d8f0 bhi.n 2b22 <usb_find_str_desc+0xe>
desc = usb_desc_next(desc);
} else {
return NULL;
}
}
return NULL;
2b40: 2000 movs r0, #0
2b42: e002 b.n 2b4a <usb_find_str_desc+0x36>
2b44: 2000 movs r0, #0
2b46: e000 b.n 2b4a <usb_find_str_desc+0x36>
_desc_len_check();
2b48: 2000 movs r0, #0
}
2b4a: bdf8 pop {r3, r4, r5, r6, r7, pc}
2b4c: 00002a31 .word 0x00002a31
00002b50 <cdc_device_acm_init>:
/**
* \brief CDC ACM Init
*/
void cdc_device_acm_init(void)
{
2b50: b510 push {r4, lr}
/* usb stack init */
usbdc_init(ctrl_buffer);
2b52: 4806 ldr r0, [pc, #24] ; (2b6c <cdc_device_acm_init+0x1c>)
2b54: 3040 adds r0, #64 ; 0x40
2b56: 4b06 ldr r3, [pc, #24] ; (2b70 <cdc_device_acm_init+0x20>)
2b58: 4798 blx r3
/* usbdc_register_funcion inside */
cdcdf_acm_init();
2b5a: 4b06 ldr r3, [pc, #24] ; (2b74 <cdc_device_acm_init+0x24>)
2b5c: 4798 blx r3
usbdc_start(single_desc);
2b5e: 4806 ldr r0, [pc, #24] ; (2b78 <cdc_device_acm_init+0x28>)
2b60: 4b06 ldr r3, [pc, #24] ; (2b7c <cdc_device_acm_init+0x2c>)
2b62: 4798 blx r3
usbdc_attach();
2b64: 4b06 ldr r3, [pc, #24] ; (2b80 <cdc_device_acm_init+0x30>)
2b66: 4798 blx r3
}
2b68: bd10 pop {r4, pc}
2b6a: 46c0 nop ; (mov r8, r8)
2b6c: 20000330 .word 0x20000330
2b70: 00002959 .word 0x00002959
2b74: 000022dd .word 0x000022dd
2b78: 20000008 .word 0x20000008
2b7c: 000029d1 .word 0x000029d1
2b80: 00002a09 .word 0x00002a09
00002b84 <usb_init>:
while (1) {
}
}
void usb_init(void)
{
2b84: b510 push {r4, lr}
cdc_device_acm_init();
2b86: 4b01 ldr r3, [pc, #4] ; (2b8c <usb_init+0x8>)
2b88: 4798 blx r3
}
2b8a: bd10 pop {r4, pc}
2b8c: 00002b51 .word 0x00002b51
00002b90 <__libc_init_array>:
2b90: b570 push {r4, r5, r6, lr}
2b92: 2600 movs r6, #0
2b94: 4d0c ldr r5, [pc, #48] ; (2bc8 <__libc_init_array+0x38>)
2b96: 4c0d ldr r4, [pc, #52] ; (2bcc <__libc_init_array+0x3c>)
2b98: 1b64 subs r4, r4, r5
2b9a: 10a4 asrs r4, r4, #2
2b9c: 42a6 cmp r6, r4
2b9e: d109 bne.n 2bb4 <__libc_init_array+0x24>
2ba0: 2600 movs r6, #0
2ba2: f000 f88f bl 2cc4 <_init>
2ba6: 4d0a ldr r5, [pc, #40] ; (2bd0 <__libc_init_array+0x40>)
2ba8: 4c0a ldr r4, [pc, #40] ; (2bd4 <__libc_init_array+0x44>)
2baa: 1b64 subs r4, r4, r5
2bac: 10a4 asrs r4, r4, #2
2bae: 42a6 cmp r6, r4
2bb0: d105 bne.n 2bbe <__libc_init_array+0x2e>
2bb2: bd70 pop {r4, r5, r6, pc}
2bb4: 00b3 lsls r3, r6, #2
2bb6: 58eb ldr r3, [r5, r3]
2bb8: 4798 blx r3
2bba: 3601 adds r6, #1
2bbc: e7ee b.n 2b9c <__libc_init_array+0xc>
2bbe: 00b3 lsls r3, r6, #2
2bc0: 58eb ldr r3, [r5, r3]
2bc2: 4798 blx r3
2bc4: 3601 adds r6, #1
2bc6: e7f2 b.n 2bae <__libc_init_array+0x1e>
2bc8: 00002cd0 .word 0x00002cd0
2bcc: 00002cd0 .word 0x00002cd0
2bd0: 00002cd0 .word 0x00002cd0
2bd4: 00002cd4 .word 0x00002cd4
00002bd8 <memcpy>:
2bd8: 2300 movs r3, #0
2bda: b510 push {r4, lr}
2bdc: 429a cmp r2, r3
2bde: d100 bne.n 2be2 <memcpy+0xa>
2be0: bd10 pop {r4, pc}
2be2: 5ccc ldrb r4, [r1, r3]
2be4: 54c4 strb r4, [r0, r3]
2be6: 3301 adds r3, #1
2be8: e7f8 b.n 2bdc <memcpy+0x4>
00002bea <memset>:
2bea: 0003 movs r3, r0
2bec: 1882 adds r2, r0, r2
2bee: 4293 cmp r3, r2
2bf0: d100 bne.n 2bf4 <memset+0xa>
2bf2: 4770 bx lr
2bf4: 7019 strb r1, [r3, #0]
2bf6: 3301 adds r3, #1
2bf8: e7f9 b.n 2bee <memset+0x4>
2bfa: 0000 movs r0, r0
2bfc: 682f2e2e .word 0x682f2e2e
2c00: 732f6c61 .word 0x732f6c61
2c04: 682f6372 .word 0x682f6372
2c08: 755f6c61 .word 0x755f6c61
2c0c: 74726173 .word 0x74726173
2c10: 6e79735f .word 0x6e79735f
2c14: 00632e63 .word 0x00632e63
2c18: 682f2e2e .word 0x682f2e2e
2c1c: 752f6c61 .word 0x752f6c61
2c20: 736c6974 .word 0x736c6974
2c24: 6372732f .word 0x6372732f
2c28: 6974752f .word 0x6974752f
2c2c: 6c5f736c .word 0x6c5f736c
2c30: 2e747369 .word 0x2e747369
2c34: 00000063 .word 0x00000063
2c38: 682f2e2e .word 0x682f2e2e
2c3c: 732f6c70 .word 0x732f6c70
2c40: 6f637265 .word 0x6f637265
2c44: 70682f6d .word 0x70682f6d
2c48: 65735f6c .word 0x65735f6c
2c4c: 6d6f6372 .word 0x6d6f6372
2c50: 0000632e .word 0x0000632e
2c54: 00002000 .word 0x00002000
00002c58 <_usb_ep_cfgs>:
2c58: 200002ac 00000000 00000040 2000026c ... ....@...l..
2c68: 00000000 00000040 2000022c 00000000 ....@...,.. ....
2c78: 00000040 000028f0 000025d8 000028f0 @....(...%...(..
2c88: 0000260a 000028f0 0000252e 000028f0 .&...(...%...(..
2c98: 000028f0 000028f0 00002542 000028f0 .(...(..B%...(..
2ca8: 0000263e 752f2e2e 642f6273 63697665 >&..../usb/devic
2cb8: 73752f65 2e636462 00000063 e/usbdc.c...
00002cc4 <_init>:
2cc4: b5f8 push {r3, r4, r5, r6, r7, lr}
2cc6: 46c0 nop ; (mov r8, r8)
2cc8: bcf8 pop {r3, r4, r5, r6, r7}
2cca: bc08 pop {r3}
2ccc: 469e mov lr, r3
2cce: 4770 bx lr
00002cd0 <__init_array_start>:
2cd0: 000000dd .word 0x000000dd
00002cd4 <_fini>:
2cd4: b5f8 push {r3, r4, r5, r6, r7, lr}
2cd6: 46c0 nop ; (mov r8, r8)
2cd8: bcf8 pop {r3, r4, r5, r6, r7}
2cda: bc08 pop {r3}
2cdc: 469e mov lr, r3
2cde: 4770 bx lr
00002ce0 <__fini_array_start>:
2ce0: 000000b5 .word 0x000000b5
Reference in New Issue View Git Blame Copy Permalink