AtmelStart.elf: file format elf32-littlearm Sections: Idx Name Size VMA LMA File off Algn 0 .text 00002438 00000000 00000000 00010000 2**2 CONTENTS, ALLOC, LOAD, READONLY, CODE 1 .relocate 00000068 20000000 00002438 00020000 2**2 CONTENTS, ALLOC, LOAD, DATA 2 .bss 00000354 20000068 000024a0 00020068 2**2 ALLOC 3 .stack 00002004 200003bc 000027f4 00020068 2**0 ALLOC 4 .ARM.attributes 00000028 00000000 00000000 00020068 2**0 CONTENTS, READONLY 5 .comment 0000001e 00000000 00000000 00020090 2**0 CONTENTS, READONLY 6 .debug_info 00028175 00000000 00000000 000200ae 2**0 CONTENTS, READONLY, DEBUGGING, OCTETS 7 .debug_abbrev 0000332c 00000000 00000000 00048223 2**0 CONTENTS, READONLY, DEBUGGING, OCTETS 8 .debug_aranges 00000bc0 00000000 00000000 0004b54f 2**0 CONTENTS, READONLY, DEBUGGING, OCTETS 9 .debug_ranges 00002d80 00000000 00000000 0004c10f 2**0 CONTENTS, READONLY, DEBUGGING, OCTETS 10 .debug_macro 00007c8e 00000000 00000000 0004ee8f 2**0 CONTENTS, READONLY, DEBUGGING, OCTETS 11 .debug_line 000135a2 00000000 00000000 00056b1d 2**0 CONTENTS, READONLY, DEBUGGING, OCTETS 12 .debug_str 00085d73 00000000 00000000 0006a0bf 2**0 CONTENTS, READONLY, DEBUGGING, OCTETS 13 .debug_frame 000020a8 00000000 00000000 000efe34 2**2 CONTENTS, READONLY, DEBUGGING, OCTETS 14 .debug_loc 0000ec67 00000000 00000000 000f1edc 2**0 CONTENTS, READONLY, DEBUGGING, OCTETS Disassembly of section .text: 00000000 : 0: c0 23 00 20 01 01 00 00 fd 00 00 00 fd 00 00 00 .#. ............ ... 2c: fd 00 00 00 00 00 00 00 00 00 00 00 fd 00 00 00 ................ 3c: fd 00 00 00 fd 00 00 00 fd 00 00 00 fd 00 00 00 ................ 4c: fd 00 00 00 fd 00 00 00 fd 00 00 00 fd 00 00 00 ................ 5c: 35 10 00 00 fd 00 00 00 fd 00 00 00 fd 00 00 00 5............... 6c: fd 00 00 00 fd 00 00 00 00 00 00 00 00 00 00 00 ................ 7c: fd 00 00 00 fd 00 00 00 fd 00 00 00 fd 00 00 00 ................ 8c: fd 00 00 00 fd 00 00 00 00 00 00 00 00 00 00 00 ................ 9c: fd 00 00 00 fd 00 00 00 fd 00 00 00 fd 00 00 00 ................ ac: fd 00 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: 00002438 .word 0x00002438 000000dc : dc: 4b04 ldr r3, [pc, #16] ; (f0 ) de: b510 push {r4, lr} e0: 2b00 cmp r3, #0 e2: d003 beq.n ec e4: 4903 ldr r1, [pc, #12] ; (f4 ) e6: 4804 ldr r0, [pc, #16] ; (f8 ) e8: e000 b.n ec ea: bf00 nop ec: bd10 pop {r4, pc} ee: 46c0 nop ; (mov r8, r8) f0: 00000000 .word 0x00000000 f4: 2000006c .word 0x2000006c f8: 00002438 .word 0x00002438 000000fc : /** * \brief Default interrupt handler for unused IRQs. */ void Dummy_Handler(void) { while (1) { fc: e7fe b.n fc ... 00000100 : if (pSrc != pDest) { 100: 4925 ldr r1, [pc, #148] ; (198 ) 102: 4826 ldr r0, [pc, #152] ; (19c ) { 104: b570 push {r4, r5, r6, lr} if (pSrc != pDest) { 106: 4281 cmp r1, r0 108: d00a beq.n 120 *pDest++ = *pSrc++; 10a: 4b25 ldr r3, [pc, #148] ; (1a0 ) 10c: 1ec4 subs r4, r0, #3 10e: 2200 movs r2, #0 110: 42a3 cmp r3, r4 112: d303 bcc.n 11c 114: 3303 adds r3, #3 116: 1a1a subs r2, r3, r0 118: 0892 lsrs r2, r2, #2 11a: 0092 lsls r2, r2, #2 11c: 4b21 ldr r3, [pc, #132] ; (1a4 ) 11e: 4798 blx r3 *pDest++ = 0; 120: 4821 ldr r0, [pc, #132] ; (1a8 ) 122: 4b22 ldr r3, [pc, #136] ; (1ac ) 124: 1ec1 subs r1, r0, #3 126: 2200 movs r2, #0 128: 4299 cmp r1, r3 12a: d803 bhi.n 134 12c: 3303 adds r3, #3 12e: 1a1a subs r2, r3, r0 130: 0892 lsrs r2, r2, #2 132: 0092 lsls r2, r2, #2 134: 2100 movs r1, #0 136: 4b1e ldr r3, [pc, #120] ; (1b0 ) 138: 4798 blx r3 SCB->VTOR = ((uint32_t)pSrc & SCB_VTOR_TBLOFF_Msk); 13a: 22ff movs r2, #255 ; 0xff 13c: 4b1d ldr r3, [pc, #116] ; (1b4 ) USB->DEVICE.QOSCTRL.bit.CQOS = 2; 13e: 2103 movs r1, #3 SCB->VTOR = ((uint32_t)pSrc & SCB_VTOR_TBLOFF_Msk); 140: 4393 bics r3, r2 142: 4a1d ldr r2, [pc, #116] ; (1b8 ) USB->DEVICE.QOSCTRL.bit.DQOS = 2; 144: 250c movs r5, #12 SCB->VTOR = ((uint32_t)pSrc & SCB_VTOR_TBLOFF_Msk); 146: 6093 str r3, [r2, #8] SBMATRIX->SFR[SBMATRIX_SLAVE_HMCRAMC0].reg = 2; 148: 2202 movs r2, #2 USB->DEVICE.QOSCTRL.bit.DQOS = 2; 14a: 2408 movs r4, #8 DMAC->QOSCTRL.bit.DQOS = 2; 14c: 2630 movs r6, #48 ; 0x30 SBMATRIX->SFR[SBMATRIX_SLAVE_HMCRAMC0].reg = 2; 14e: 4b1b ldr r3, [pc, #108] ; (1bc ) USB->DEVICE.QOSCTRL.bit.CQOS = 2; 150: 481b ldr r0, [pc, #108] ; (1c0 ) SBMATRIX->SFR[SBMATRIX_SLAVE_HMCRAMC0].reg = 2; 152: 625a str r2, [r3, #36] ; 0x24 USB->DEVICE.QOSCTRL.bit.CQOS = 2; 154: 78c3 ldrb r3, [r0, #3] 156: 438b bics r3, r1 158: 4313 orrs r3, r2 15a: 70c3 strb r3, [r0, #3] USB->DEVICE.QOSCTRL.bit.DQOS = 2; 15c: 78c3 ldrb r3, [r0, #3] 15e: 43ab bics r3, r5 160: 4323 orrs r3, r4 162: 70c3 strb r3, [r0, #3] DMAC->QOSCTRL.bit.DQOS = 2; 164: 4b17 ldr r3, [pc, #92] ; (1c4 ) 166: 7b98 ldrb r0, [r3, #14] 168: 43b0 bics r0, r6 16a: 0006 movs r6, r0 16c: 2020 movs r0, #32 16e: 4330 orrs r0, r6 170: 7398 strb r0, [r3, #14] DMAC->QOSCTRL.bit.FQOS = 2; 172: 7b98 ldrb r0, [r3, #14] 174: 43a8 bics r0, r5 176: 4304 orrs r4, r0 178: 739c strb r4, [r3, #14] DMAC->QOSCTRL.bit.WRBQOS = 2; 17a: 7b98 ldrb r0, [r3, #14] 17c: 4388 bics r0, r1 17e: 4302 orrs r2, r0 180: 739a strb r2, [r3, #14] NVMCTRL->CTRLB.bit.MANW = 1; 182: 2380 movs r3, #128 ; 0x80 184: 4a10 ldr r2, [pc, #64] ; (1c8 ) 186: 6851 ldr r1, [r2, #4] 188: 430b orrs r3, r1 18a: 6053 str r3, [r2, #4] __libc_init_array(); 18c: 4b0f ldr r3, [pc, #60] ; (1cc ) 18e: 4798 blx r3 main(); 190: 4b0f ldr r3, [pc, #60] ; (1d0 ) 192: 4798 blx r3 while (1) 194: e7fe b.n 194 196: 46c0 nop ; (mov r8, r8) 198: 00002438 .word 0x00002438 19c: 20000000 .word 0x20000000 1a0: 20000068 .word 0x20000068 1a4: 00002355 .word 0x00002355 1a8: 20000068 .word 0x20000068 1ac: 200003bc .word 0x200003bc 1b0: 00002367 .word 0x00002367 1b4: 00000000 .word 0x00000000 1b8: e000ed00 .word 0xe000ed00 1bc: 410070fc .word 0x410070fc 1c0: 41005000 .word 0x41005000 1c4: 41004800 .word 0x41004800 1c8: 41004000 .word 0x41004000 1cc: 0000230d .word 0x0000230d 1d0: 00001a61 .word 0x00001a61 000001d4 : * \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) { 1d4: b5f0 push {r4, r5, r6, r7, lr} 1d6: 0017 movs r7, r2 if (0x01 != ((req->bmRequestType >> 5) & 0x03)) { // class request 1d8: 780a ldrb r2, [r1, #0] { 1da: b085 sub sp, #20 if (0x01 != ((req->bmRequestType >> 5) & 0x03)) { // class request 1dc: 0653 lsls r3, r2, #25 { 1de: 000c movs r4, r1 1e0: 9001 str r0, [sp, #4] if (0x01 != ((req->bmRequestType >> 5) & 0x03)) { // class request 1e2: 0f9b lsrs r3, r3, #30 1e4: 2b01 cmp r3, #1 1e6: d152 bne.n 28e return ERR_NOT_FOUND; } if ((req->wIndex == _cdcdf_acm_funcd.func_iface[0]) || (req->wIndex == _cdcdf_acm_funcd.func_iface[1])) { 1e8: 7963 ldrb r3, [r4, #5] 1ea: 7909 ldrb r1, [r1, #4] 1ec: 4d2a ldr r5, [pc, #168] ; (298 ) 1ee: 021b lsls r3, r3, #8 1f0: 430b orrs r3, r1 1f2: 7829 ldrb r1, [r5, #0] 1f4: 4299 cmp r1, r3 1f6: d002 beq.n 1fe 1f8: 7869 ldrb r1, [r5, #1] 1fa: 4299 cmp r1, r3 1fc: d147 bne.n 28e uint16_t len = req->wLength; 1fe: 79e6 ldrb r6, [r4, #7] 200: 79a3 ldrb r3, [r4, #6] 202: 0236 lsls r6, r6, #8 if (req->bmRequestType & USB_EP_DIR_IN) { 204: b252 sxtb r2, r2 uint16_t len = req->wLength; 206: 431e orrs r6, r3 if (req->bmRequestType & USB_EP_DIR_IN) { 208: 2a00 cmp r2, #0 20a: da0f bge.n 22c return ERR_NONE; 20c: 2000 movs r0, #0 if (USB_DATA_STAGE == stage) { 20e: 2f01 cmp r7, #1 210: d00a beq.n 228 switch (req->bRequest) { 212: 7863 ldrb r3, [r4, #1] 214: 2b21 cmp r3, #33 ; 0x21 216: d111 bne.n 23c if (sizeof(struct usb_cdc_line_coding) != len) { 218: 2e07 cmp r6, #7 21a: d13b bne.n 294 return usbdc_xfer(ep, (uint8_t *)&usbd_cdc_line_coding, len, false); 21c: 0003 movs r3, r0 21e: 1da9 adds r1, r5, #6 return usbdc_xfer(ep, ctrl_buf, len, false); 220: 0032 movs r2, r6 222: 9801 ldr r0, [sp, #4] 224: 4c1d ldr r4, [pc, #116] ; (29c ) 226: 47a0 blx r4 return cdcdf_acm_set_req(ep, req, stage); } } else { return ERR_NOT_FOUND; } } 228: b005 add sp, #20 22a: bdf0 pop {r4, r5, r6, r7, pc} uint8_t * ctrl_buf = usbdc_get_ctrl_buffer(); 22c: 4b1c ldr r3, [pc, #112] ; (2a0 ) 22e: 4798 blx r3 switch (req->bRequest) { 230: 7863 ldrb r3, [r4, #1] uint8_t * ctrl_buf = usbdc_get_ctrl_buffer(); 232: 0001 movs r1, r0 switch (req->bRequest) { 234: 2b20 cmp r3, #32 236: d003 beq.n 240 238: 2b22 cmp r3, #34 ; 0x22 23a: d019 beq.n 270 return ERR_INVALID_ARG; 23c: 200d movs r0, #13 23e: e027 b.n 290 if (sizeof(struct usb_cdc_line_coding) != len) { 240: 2e07 cmp r6, #7 242: d127 bne.n 294 if (USB_SETUP_STAGE == stage) { 244: 2f00 cmp r7, #0 246: d101 bne.n 24c return usbdc_xfer(ep, ctrl_buf, len, false); 248: 003b movs r3, r7 24a: e7e9 b.n 220 memcpy(&line_coding_tmp, ctrl_buf, sizeof(struct usb_cdc_line_coding)); 24c: 0032 movs r2, r6 24e: 4c15 ldr r4, [pc, #84] ; (2a4 ) 250: a802 add r0, sp, #8 252: 47a0 blx r4 if ((NULL == cdcdf_acm_set_line_coding) || (true == cdcdf_acm_set_line_coding(&line_coding_tmp))) { 254: 692b ldr r3, [r5, #16] 256: 2b00 cmp r3, #0 258: d105 bne.n 266 usbd_cdc_line_coding = line_coding_tmp; 25a: 2207 movs r2, #7 25c: 1da8 adds r0, r5, #6 25e: a902 add r1, sp, #8 260: 47a0 blx r4 return ERR_NONE; 262: 2000 movs r0, #0 264: e7e0 b.n 228 if ((NULL == cdcdf_acm_set_line_coding) || (true == cdcdf_acm_set_line_coding(&line_coding_tmp))) { 266: a802 add r0, sp, #8 268: 4798 blx r3 26a: 2800 cmp r0, #0 26c: d1f5 bne.n 25a 26e: e7f8 b.n 262 usbdc_xfer(0, NULL, 0, 0); 270: 2300 movs r3, #0 272: 4e0a ldr r6, [pc, #40] ; (29c ) 274: 001a movs r2, r3 276: 0019 movs r1, r3 278: 0018 movs r0, r3 27a: 47b0 blx r6 if (NULL != cdcdf_acm_notify_state) { 27c: 696b ldr r3, [r5, #20] 27e: 2b00 cmp r3, #0 280: d0ef beq.n 262 cdcdf_acm_notify_state(req->wValue); 282: 78e0 ldrb r0, [r4, #3] 284: 78a2 ldrb r2, [r4, #2] 286: 0200 lsls r0, r0, #8 288: 4310 orrs r0, r2 28a: 4798 blx r3 28c: e7e9 b.n 262 return ERR_NOT_FOUND; 28e: 200a movs r0, #10 return ERR_INVALID_DATA; 290: 4240 negs r0, r0 292: e7c9 b.n 228 294: 2001 movs r0, #1 296: e7fb b.n 290 298: 20000084 .word 0x20000084 29c: 00001e81 .word 0x00001e81 2a0: 000022a9 .word 0x000022a9 2a4: 00002355 .word 0x00002355 000002a8 : { 2a8: b5f7 push {r0, r1, r2, r4, r5, r6, r7, lr} 2aa: 0015 movs r5, r2 switch (ctrl) { 2ac: 2901 cmp r1, #1 2ae: d04f beq.n 350 2b0: 2902 cmp r1, #2 2b2: d100 bne.n 2b6 2b4: e076 b.n 3a4 2b6: 2900 cmp r1, #0 2b8: d000 beq.n 2bc 2ba: e075 b.n 3a8 return cdcdf_acm_enable(drv, (struct usbd_descriptors *)param); 2bc: 6883 ldr r3, [r0, #8] ifc = desc->sod; 2be: 6810 ldr r0, [r2, #0] 2c0: 001e movs r6, r3 2c2: 9300 str r3, [sp, #0] for (i = 0; i < 2; i++) { 2c4: 3302 adds r3, #2 2c6: 9301 str r3, [sp, #4] if (NULL == ifc) { 2c8: 2800 cmp r0, #0 2ca: d102 bne.n 2d2 return ERR_NOT_FOUND; 2cc: 200a movs r0, #10 return ERR_NOT_INITIALIZED; 2ce: 4240 negs r0, r0 2d0: e020 b.n 314 if ((CDC_CLASS_COMM == ifc_desc.bInterfaceClass) || (CDC_CLASS_DATA == ifc_desc.bInterfaceClass)) { 2d2: 2108 movs r1, #8 2d4: 7943 ldrb r3, [r0, #5] ifc_desc.bInterfaceNumber = ifc[2]; 2d6: 7882 ldrb r2, [r0, #2] if ((CDC_CLASS_COMM == ifc_desc.bInterfaceClass) || (CDC_CLASS_DATA == ifc_desc.bInterfaceClass)) { 2d8: 438b bics r3, r1 2da: 2b02 cmp r3, #2 2dc: d1f6 bne.n 2cc if (func_data->func_iface[i] == ifc_desc.bInterfaceNumber) { // Initialized 2de: 7833 ldrb r3, [r6, #0] 2e0: 429a cmp r2, r3 2e2: d063 beq.n 3ac } else if (func_data->func_iface[i] != 0xFF) { // Occupied 2e4: 2bff cmp r3, #255 ; 0xff 2e6: d163 bne.n 3b0 func_data->func_iface[i] = ifc_desc.bInterfaceNumber; 2e8: 7032 strb r2, [r6, #0] ep = usb_find_desc(ifc, desc->eod, USB_DT_ENDPOINT); 2ea: 6869 ldr r1, [r5, #4] 2ec: 2205 movs r2, #5 2ee: 4b32 ldr r3, [pc, #200] ; (3b8 ) 2f0: 4798 blx r3 ep = usb_find_ep_desc(usb_desc_next(desc->sod), desc->eod); 2f2: 1e04 subs r4, r0, #0 while (NULL != ep) { 2f4: d10f bne.n 316 ifc = usb_find_desc(usb_desc_next(desc->sod), desc->eod, USB_DT_INTERFACE); 2f6: 6828 ldr r0, [r5, #0] 2f8: 2204 movs r2, #4 * \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)); 2fa: 7803 ldrb r3, [r0, #0] 2fc: 6869 ldr r1, [r5, #4] 2fe: 18c0 adds r0, r0, r3 300: 4b2d ldr r3, [pc, #180] ; (3b8 ) 302: 4798 blx r3 for (i = 0; i < 2; i++) { 304: 9b01 ldr r3, [sp, #4] 306: 3601 adds r6, #1 308: 42b3 cmp r3, r6 30a: d1dd bne.n 2c8 _cdcdf_acm_funcd.enabled = true; 30c: 2201 movs r2, #1 return ERR_NONE; 30e: 0020 movs r0, r4 _cdcdf_acm_funcd.enabled = true; 310: 4b2a ldr r3, [pc, #168] ; (3bc ) 312: 715a strb r2, [r3, #5] } 314: bdfe pop {r1, r2, r3, r4, r5, r6, r7, pc} return (ptr[0] + (ptr[1] << 8)); 316: 7963 ldrb r3, [r4, #5] 318: 7922 ldrb r2, [r4, #4] 31a: 021b lsls r3, r3, #8 ep_desc.bEndpointAddress = ep[2]; 31c: 78a7 ldrb r7, [r4, #2] 31e: 18d2 adds r2, r2, r3 if (usb_d_ep_init(ep_desc.bEndpointAddress, ep_desc.bmAttributes, ep_desc.wMaxPacketSize)) { 320: 0038 movs r0, r7 322: 78e1 ldrb r1, [r4, #3] 324: 4b26 ldr r3, [pc, #152] ; (3c0 ) 326: b292 uxth r2, r2 328: 4798 blx r3 32a: 2800 cmp r0, #0 32c: d142 bne.n 3b4 if (ep_desc.bEndpointAddress & USB_EP_DIR_IN) { 32e: b27b sxtb r3, r7 330: 4a24 ldr r2, [pc, #144] ; (3c4 ) 332: 2b00 cmp r3, #0 334: da09 bge.n 34a func_data->func_ep_in[i] = ep_desc.bEndpointAddress; 336: 70b7 strb r7, [r6, #2] usb_d_ep_enable(func_data->func_ep_out); 338: 0038 movs r0, r7 33a: 4790 blx r2 desc->sod = ep; 33c: 602c str r4, [r5, #0] return (desc + usb_desc_len(desc)); 33e: 7820 ldrb r0, [r4, #0] ep = usb_find_ep_desc(usb_desc_next(desc->sod), desc->eod); 340: 6869 ldr r1, [r5, #4] 342: 4b21 ldr r3, [pc, #132] ; (3c8 ) 344: 1820 adds r0, r4, r0 346: 4798 blx r3 348: e7d3 b.n 2f2 func_data->func_ep_out = ep_desc.bEndpointAddress; 34a: 9b00 ldr r3, [sp, #0] 34c: 711f strb r7, [r3, #4] 34e: e7f3 b.n 338 return cdcdf_acm_disable(drv, (struct usbd_descriptors *)param); 350: 6884 ldr r4, [r0, #8] if (desc) { 352: 2a00 cmp r2, #0 354: d005 beq.n 362 ifc_desc.bInterfaceClass = desc->sod[5]; 356: 6813 ldr r3, [r2, #0] if ((ifc_desc.bInterfaceClass != CDC_CLASS_COMM) && (ifc_desc.bInterfaceClass != CDC_CLASS_DATA)) { 358: 2208 movs r2, #8 35a: 795b ldrb r3, [r3, #5] 35c: 4393 bics r3, r2 35e: 2b02 cmp r3, #2 360: d1b4 bne.n 2cc if (func_data->func_iface[i] == 0xFF) { 362: 7823 ldrb r3, [r4, #0] 364: 2bff cmp r3, #255 ; 0xff 366: d007 beq.n 378 func_data->func_iface[i] = 0xFF; 368: 25ff movs r5, #255 ; 0xff if (func_data->func_ep_in[i] != 0xFF) { 36a: 78a0 ldrb r0, [r4, #2] func_data->func_iface[i] = 0xFF; 36c: 7025 strb r5, [r4, #0] if (func_data->func_ep_in[i] != 0xFF) { 36e: 42a8 cmp r0, r5 370: d002 beq.n 378 usb_d_ep_deinit(func_data->func_ep_in[i]); 372: 4b16 ldr r3, [pc, #88] ; (3cc ) 374: 4798 blx r3 func_data->func_ep_in[i] = 0xFF; 376: 70a5 strb r5, [r4, #2] if (func_data->func_iface[i] == 0xFF) { 378: 7863 ldrb r3, [r4, #1] 37a: 2bff cmp r3, #255 ; 0xff 37c: d007 beq.n 38e func_data->func_iface[i] = 0xFF; 37e: 25ff movs r5, #255 ; 0xff if (func_data->func_ep_in[i] != 0xFF) { 380: 78e0 ldrb r0, [r4, #3] func_data->func_iface[i] = 0xFF; 382: 7065 strb r5, [r4, #1] if (func_data->func_ep_in[i] != 0xFF) { 384: 42a8 cmp r0, r5 386: d002 beq.n 38e usb_d_ep_deinit(func_data->func_ep_in[i]); 388: 4b10 ldr r3, [pc, #64] ; (3cc ) 38a: 4798 blx r3 func_data->func_ep_in[i] = 0xFF; 38c: 70e5 strb r5, [r4, #3] if (func_data->func_ep_out != 0xFF) { 38e: 7920 ldrb r0, [r4, #4] 390: 28ff cmp r0, #255 ; 0xff 392: d003 beq.n 39c usb_d_ep_deinit(func_data->func_ep_out); 394: 4b0d ldr r3, [pc, #52] ; (3cc ) 396: 4798 blx r3 func_data->func_ep_out = 0xFF; 398: 23ff movs r3, #255 ; 0xff 39a: 7123 strb r3, [r4, #4] _cdcdf_acm_funcd.enabled = false; 39c: 2000 movs r0, #0 39e: 4b07 ldr r3, [pc, #28] ; (3bc ) 3a0: 7158 strb r0, [r3, #5] return ERR_NONE; 3a2: e7b7 b.n 314 return ERR_UNSUPPORTED_OP; 3a4: 201b movs r0, #27 3a6: e792 b.n 2ce switch (ctrl) { 3a8: 200d movs r0, #13 3aa: e790 b.n 2ce return ERR_ALREADY_INITIALIZED; 3ac: 2012 movs r0, #18 3ae: e78e b.n 2ce return ERR_NO_RESOURCE; 3b0: 201c movs r0, #28 3b2: e78c b.n 2ce return ERR_NOT_INITIALIZED; 3b4: 2014 movs r0, #20 3b6: e78a b.n 2ce 3b8: 000014e5 .word 0x000014e5 3bc: 20000084 .word 0x20000084 3c0: 000017f1 .word 0x000017f1 3c4: 00001881 .word 0x00001881 3c8: 000014ff .word 0x000014ff 3cc: 00001855 .word 0x00001855 000003d0 : /** * \brief Initialize the USB CDC ACM Function Driver */ int32_t cdcdf_acm_init(void) { 3d0: b510 push {r4, lr} if (usbdc_get_state() > USBD_S_POWER) { 3d2: 4b0a ldr r3, [pc, #40] ; (3fc ) 3d4: 4798 blx r3 3d6: 2801 cmp r0, #1 3d8: d80c bhi.n 3f4 return ERR_DENIED; } _cdcdf_acm.ctrl = cdcdf_acm_ctrl; 3da: 4809 ldr r0, [pc, #36] ; (400 ) 3dc: 4b09 ldr r3, [pc, #36] ; (404 ) _cdcdf_acm.func_data = &_cdcdf_acm_funcd; 3de: 6200 str r0, [r0, #32] _cdcdf_acm.ctrl = cdcdf_acm_ctrl; 3e0: 61c3 str r3, [r0, #28] usbdc_register_function(&_cdcdf_acm); 3e2: 4b09 ldr r3, [pc, #36] ; (408 ) 3e4: 3018 adds r0, #24 3e6: 4798 blx r3 usbdc_register_handler(USBDC_HDL_REQ, &cdcdf_acm_req_h); 3e8: 2001 movs r0, #1 3ea: 4908 ldr r1, [pc, #32] ; (40c ) 3ec: 4b08 ldr r3, [pc, #32] ; (410 ) 3ee: 4798 blx r3 return ERR_NONE; 3f0: 2000 movs r0, #0 } 3f2: bd10 pop {r4, pc} return ERR_DENIED; 3f4: 2011 movs r0, #17 3f6: 4240 negs r0, r0 3f8: e7fb b.n 3f2 3fa: 46c0 nop ; (mov r8, r8) 3fc: 000022b5 .word 0x000022b5 400: 20000084 .word 0x20000084 404: 000002a9 .word 0x000002a9 408: 00002251 .word 0x00002251 40c: 20000000 .word 0x20000000 410: 000021c5 .word 0x000021c5 00000414 <_dummy_func_no_return>: static bool _dummy_func_no_return(uint32_t unused0, uint32_t unused1) { (void)unused0; (void)unused1; return false; } 414: 2000 movs r0, #0 416: 4770 bx lr 00000418 <_usb_d_dev_wait_dfll_rdy>: */ static inline void _usb_d_dev_wait_dfll_rdy(void) { #define DFLL_READY_FLAG (SYSCTRL_PCLKSR_DFLLRDY | SYSCTRL_PCLKSR_DFLLLCKF | SYSCTRL_PCLKSR_DFLLLCKC) /* In USB recovery mode the status is not checked */ if (!(SYSCTRL->DFLLCTRL.reg & SYSCTRL_DFLLCTRL_USBCRM)) { 418: 4b07 ldr r3, [pc, #28] ; (438 <_usb_d_dev_wait_dfll_rdy+0x20>) 41a: 8c9a ldrh r2, [r3, #36] ; 0x24 41c: 0692 lsls r2, r2, #26 41e: d504 bpl.n 42a <_usb_d_dev_wait_dfll_rdy+0x12> static inline hri_sysctrl_pclksr_reg_t hri_sysctrl_get_PCLKSR_reg(const void *const hw, hri_sysctrl_pclksr_reg_t mask) { uint32_t tmp; tmp = ((Sysctrl *)hw)->PCLKSR.reg; tmp &= mask; 420: 2210 movs r2, #16 tmp = ((Sysctrl *)hw)->PCLKSR.reg; 422: 68d9 ldr r1, [r3, #12] while (hri_sysctrl_get_PCLKSR_reg(SYSCTRL, DFLL_READY_FLAG) != DFLL_READY_FLAG) ; } else { while (hri_sysctrl_get_PCLKSR_reg(SYSCTRL, SYSCTRL_PCLKSR_DFLLRDY) != SYSCTRL_PCLKSR_DFLLRDY) 424: 4211 tst r1, r2 426: d0fc beq.n 422 <_usb_d_dev_wait_dfll_rdy+0xa> 428: e004 b.n 434 <_usb_d_dev_wait_dfll_rdy+0x1c> tmp &= mask; 42a: 21d0 movs r1, #208 ; 0xd0 tmp = ((Sysctrl *)hw)->PCLKSR.reg; 42c: 68da ldr r2, [r3, #12] tmp &= mask; 42e: 400a ands r2, r1 while (hri_sysctrl_get_PCLKSR_reg(SYSCTRL, DFLL_READY_FLAG) != DFLL_READY_FLAG) 430: 2ad0 cmp r2, #208 ; 0xd0 432: d1fb bne.n 42c <_usb_d_dev_wait_dfll_rdy+0x14> ; } } 434: 4770 bx lr 436: 46c0 nop ; (mov r8, r8) 438: 40000800 .word 0x40000800 0000043c <_usb_d_dev_ept>: * \param[in] epn Endpoint number. * \param[in] dir Endpoint direction. */ static inline struct _usb_d_dev_ep *_usb_d_dev_ept(uint8_t epn, bool dir) { uint8_t ep_index = (epn == 0) ? 0 : (dir ? (epn + CONF_USB_D_MAX_EP_N) : epn); 43c: 2800 cmp r0, #0 43e: d003 beq.n 448 <_usb_d_dev_ept+0xc> 440: 2900 cmp r1, #0 442: d001 beq.n 448 <_usb_d_dev_ept+0xc> 444: 3002 adds r0, #2 446: b2c0 uxtb r0, r0 return &dev_inst.ep[ep_index]; 448: 2314 movs r3, #20 44a: 3001 adds r0, #1 44c: 4358 muls r0, r3 44e: 4b01 ldr r3, [pc, #4] ; (454 <_usb_d_dev_ept+0x18>) 450: 18c0 adds r0, r0, r3 } 452: 4770 bx lr 454: 20000108 .word 0x20000108 00000458 <_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) { uint8_t epn = USB_EP_GET_N(ept->ep); 458: 230f movs r3, #15 { 45a: b570 push {r4, r5, r6, lr} 45c: 0001 movs r1, r0 uint8_t epn = USB_EP_GET_N(ept->ep); 45e: 7c80 ldrb r0, [r0, #18] bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept); if (!is_ctrl) { 460: 2507 movs r5, #7 uint8_t epn = USB_EP_GET_N(ept->ep); 462: 4003 ands r3, r0 bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept); 464: 001a movs r2, r3 466: 7ccc ldrb r4, [r1, #19] if (!is_ctrl) { 468: 3208 adds r2, #8 46a: 4025 ands r5, r4 46c: 015b lsls r3, r3, #5 46e: 2d01 cmp r5, #1 470: d008 beq.n 484 <_usb_d_dev_handle_setup+0x2c> } 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; 472: 4914 ldr r1, [pc, #80] ; (4c4 <_usb_d_dev_handle_setup+0x6c>) 474: 0152 lsls r2, r2, #5 476: 1852 adds r2, r2, r1 478: 2110 movs r1, #16 47a: 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; 47c: 4a12 ldr r2, [pc, #72] ; (4c8 <_usb_d_dev_handle_setup+0x70>) 47e: 189b adds r3, r3, r2 480: 7259 strb r1, [r3, #9] _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); } 482: bd70 pop {r4, r5, r6, pc} if (_usb_d_dev_ep_is_busy(ept)) { 484: 2540 movs r5, #64 ; 0x40 486: 422c tst r4, r5 488: d006 beq.n 498 <_usb_d_dev_handle_setup+0x40> ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask; 48a: 2680 movs r6, #128 ; 0x80 ept->flags.bits.is_busy = 0; 48c: 43ac bics r4, r5 48e: 74cc strb r4, [r1, #19] 490: 4c0d ldr r4, [pc, #52] ; (4c8 <_usb_d_dev_handle_setup+0x70>) 492: 191c adds r4, r3, r4 494: 7166 strb r6, [r4, #5] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask; 496: 71a5 strb r5, [r4, #6] ept->flags.bits.is_stalled = 0; 498: 2508 movs r5, #8 49a: 7ccc ldrb r4, [r1, #19] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; 49c: 0152 lsls r2, r2, #5 49e: 43ac bics r4, r5 4a0: 74cc strb r4, [r1, #19] bank->STATUS_BK.reg = 0; 4a2: 2400 movs r4, #0 4a4: 4909 ldr r1, [pc, #36] ; (4cc <_usb_d_dev_handle_setup+0x74>) 4a6: 18c9 adds r1, r1, r3 4a8: 728c strb r4, [r1, #10] 4aa: 768c strb r4, [r1, #26] 4ac: 4905 ldr r1, [pc, #20] ; (4c4 <_usb_d_dev_handle_setup+0x6c>) 4ae: 1852 adds r2, r2, r1 4b0: 216f movs r1, #111 ; 0x6f 4b2: 71d1 strb r1, [r2, #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; 4b4: 4a04 ldr r2, [pc, #16] ; (4c8 <_usb_d_dev_handle_setup+0x70>) 4b6: 189b adds r3, r3, r2 4b8: 7259 strb r1, [r3, #9] dev_inst.ep_callbacks.setup(ept->ep); 4ba: 4b05 ldr r3, [pc, #20] ; (4d0 <_usb_d_dev_handle_setup+0x78>) 4bc: 689b ldr r3, [r3, #8] 4be: 4798 blx r3 4c0: e7df b.n 482 <_usb_d_dev_handle_setup+0x2a> 4c2: 46c0 nop ; (mov r8, r8) 4c4: 41005000 .word 0x41005000 4c8: 410050ff .word 0x410050ff 4cc: 200000a8 .word 0x200000a8 4d0: 20000108 .word 0x20000108 000004d4 <_usb_d_dev_handle_stall>: _usbd_ep_int_dis(epn, USB_DEVICE_EPINTFLAG_STALL0 << bank_n); 4d4: 2320 movs r3, #32 4d6: 408b lsls r3, r1 hri_usbendpoint_clear_EPINTEN_reg(USB, epn, flags); 4d8: b2da uxtb r2, r3 4da: 230f movs r3, #15 * \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) { 4dc: b510 push {r4, lr} 4de: 0004 movs r4, r0 uint8_t epn = USB_EP_GET_N(ept->ep); 4e0: 7c80 ldrb r0, [r0, #18] 4e2: 4905 ldr r1, [pc, #20] ; (4f8 <_usb_d_dev_handle_stall+0x24>) 4e4: 4003 ands r3, r0 4e6: 015b lsls r3, r3, #5 4e8: 185b adds r3, r3, r1 4ea: 725a strb r2, [r3, #9] /* 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); 4ec: 4b03 ldr r3, [pc, #12] ; (4fc <_usb_d_dev_handle_stall+0x28>) 4ee: 2101 movs r1, #1 4f0: 691b ldr r3, [r3, #16] 4f2: 68a2 ldr r2, [r4, #8] 4f4: 4798 blx r3 } 4f6: bd10 pop {r4, pc} 4f8: 410050ff .word 0x410050ff 4fc: 20000108 .word 0x20000108 00000500 <_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) { 500: b510 push {r4, lr} 502: 0003 movs r3, r0 if (!(_usb_d_dev_ep_is_used(ept) && _usb_d_dev_ep_is_busy(ept))) { 504: 7c80 ldrb r0, [r0, #18] 506: 28ff cmp r0, #255 ; 0xff 508: d009 beq.n 51e <_usb_d_dev_trans_done+0x1e> 50a: 2440 movs r4, #64 ; 0x40 50c: 7cda ldrb r2, [r3, #19] 50e: 4222 tst r2, r4 510: d005 beq.n 51e <_usb_d_dev_trans_done+0x1e> return; } ept->flags.bits.is_busy = 0; 512: 43a2 bics r2, r4 514: 74da strb r2, [r3, #19] dev_inst.ep_callbacks.done(ept->ep, code, ept->trans_count); 516: 4a02 ldr r2, [pc, #8] ; (520 <_usb_d_dev_trans_done+0x20>) 518: 6914 ldr r4, [r2, #16] 51a: 689a ldr r2, [r3, #8] 51c: 47a0 blx r4 } 51e: bd10 pop {r4, pc} 520: 20000108 .word 0x20000108 00000524 <_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) { 524: b5f7 push {r0, r1, r2, r4, r5, r6, r7, lr} 526: 4694 mov ip, r2 uint8_t epn = USB_EP_GET_N(ept->ep); 528: 7c83 ldrb r3, [r0, #18] ; const uint8_t intflags[2] = {USB_D_BANK0_INT_FLAGS, USB_D_BANK1_INT_FLAGS}; 52a: 4a13 ldr r2, [pc, #76] ; (578 <_usb_d_dev_trans_stop+0x54>) 52c: ae01 add r6, sp, #4 { 52e: 000d movs r5, r1 const uint8_t intflags[2] = {USB_D_BANK0_INT_FLAGS, USB_D_BANK1_INT_FLAGS}; 530: 8032 strh r2, [r6, #0] if (!(_usb_d_dev_ep_is_used(ept) && _usb_d_dev_ep_is_busy(ept))) { 532: 2bff cmp r3, #255 ; 0xff 534: d01a beq.n 56c <_usb_d_dev_trans_stop+0x48> 536: 2740 movs r7, #64 ; 0x40 538: 7cc2 ldrb r2, [r0, #19] 53a: 423a tst r2, r7 53c: d016 beq.n 56c <_usb_d_dev_trans_stop+0x48> ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask; 53e: 220f movs r2, #15 540: 4013 ands r3, r2 542: 001c movs r4, r3 544: 3408 adds r4, #8 546: 0162 lsls r2, r4, #5 return; } /* Stop transfer */ if (dir) { 548: 2900 cmp r1, #0 54a: d010 beq.n 56e <_usb_d_dev_trans_stop+0x4a> 54c: 4f0b ldr r7, [pc, #44] ; (57c <_usb_d_dev_trans_stop+0x58>) 54e: 19d2 adds r2, r2, r7 550: 2780 movs r7, #128 ; 0x80 552: 7117 strb r7, [r2, #4] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; 554: 4909 ldr r1, [pc, #36] ; (57c <_usb_d_dev_trans_stop+0x58>) 556: 0164 lsls r4, r4, #5 558: 1864 adds r4, r4, r1 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask; 55a: 4909 ldr r1, [pc, #36] ; (580 <_usb_d_dev_trans_stop+0x5c>) _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]); 55c: 5d72 ldrb r2, [r6, r5] 55e: 015b lsls r3, r3, #5 560: 185b adds r3, r3, r1 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; 562: 71e2 strb r2, [r4, #7] _usbd_ep_int_dis(epn, intflags[dir]); _usb_d_dev_trans_done(ept, code); 564: 4661 mov r1, ip ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask; 566: 725a strb r2, [r3, #9] 568: 4b06 ldr r3, [pc, #24] ; (584 <_usb_d_dev_trans_stop+0x60>) 56a: 4798 blx r3 } 56c: bdf7 pop {r0, r1, r2, r4, r5, r6, r7, pc} ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask; 56e: 4903 ldr r1, [pc, #12] ; (57c <_usb_d_dev_trans_stop+0x58>) 570: 1852 adds r2, r2, r1 572: 7157 strb r7, [r2, #5] } 574: e7ee b.n 554 <_usb_d_dev_trans_stop+0x30> 576: 46c0 nop ; (mov r8, r8) 578: 00004a25 .word 0x00004a25 57c: 41005000 .word 0x41005000 580: 410050ff .word 0x410050ff 584: 00000501 .word 0x00000501 00000588 <_usb_d_dev_handle_trfail>: { 588: b5f0 push {r4, r5, r6, r7, lr} 58a: 000d movs r5, r1 uint8_t epn = USB_EP_GET_N(ept->ep); 58c: 210f movs r1, #15 58e: 7c83 ldrb r3, [r0, #18] { 590: b085 sub sp, #20 uint8_t epn = USB_EP_GET_N(ept->ep); 592: 400b ands r3, r1 594: 469c mov ip, r3 const uint8_t fail[2] = {USB_DEVICE_EPINTFLAG_TRFAIL0, USB_DEVICE_EPINTFLAG_TRFAIL1}; 596: 4b30 ldr r3, [pc, #192] ; (658 <_usb_d_dev_handle_trfail+0xd0>) 598: ae03 add r6, sp, #12 59a: 8033 strh r3, [r6, #0] UsbDeviceDescBank *bank = prvt_inst.desc_table[epn].DeviceDescBank; 59c: 4663 mov r3, ip 59e: 015b lsls r3, r3, #5 5a0: 9300 str r3, [sp, #0] uint8_t eptype 5a2: 4663 mov r3, ip 5a4: 3308 adds r3, #8 5a6: 492d ldr r1, [pc, #180] ; (65c <_usb_d_dev_handle_trfail+0xd4>) 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; 5a8: 015c lsls r4, r3, #5 5aa: 2d00 cmp r5, #0 5ac: d020 beq.n 5f0 <_usb_d_dev_handle_trfail+0x68> 5ae: 5d09 ldrb r1, [r1, r4] tmp = (tmp & USB_DEVICE_EPCFG_EPTYPE1_Msk) >> USB_DEVICE_EPCFG_EPTYPE1_Pos; 5b0: 0649 lsls r1, r1, #25 5b2: 0f49 lsrs r1, r1, #29 st.reg = bank[bank_n].STATUS_BK.reg; 5b4: 9a00 ldr r2, [sp, #0] 5b6: 012c lsls r4, r5, #4 5b8: 18a4 adds r4, r4, r2 5ba: 4a29 ldr r2, [pc, #164] ; (660 <_usb_d_dev_handle_trfail+0xd8>) hri_usbendpoint_clear_EPINTFLAG_reg(hw, epn, fail[bank_n]); 5bc: 5d76 ldrb r6, [r6, r5] st.reg = bank[bank_n].STATUS_BK.reg; 5be: 1914 adds r4, r2, r4 5c0: 7aa7 ldrb r7, [r4, #10] 5c2: b2ff uxtb r7, r7 if ((eptype == USB_D_EPTYPE_ISOCH) && st.bit.CRCERR) { 5c4: 2902 cmp r1, #2 5c6: d117 bne.n 5f8 <_usb_d_dev_handle_trfail+0x70> 5c8: 3901 subs r1, #1 5ca: 420f tst r7, r1 5cc: d014 beq.n 5f8 <_usb_d_dev_handle_trfail+0x70> bank[bank_n].STATUS_BK.bit.CRCERR = 0; 5ce: 7aa7 ldrb r7, [r4, #10] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; 5d0: 4a22 ldr r2, [pc, #136] ; (65c <_usb_d_dev_handle_trfail+0xd4>) 5d2: 015b lsls r3, r3, #5 5d4: 189b adds r3, r3, r2 5d6: 438f bics r7, r1 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask; 5d8: 9a00 ldr r2, [sp, #0] 5da: 72a7 strb r7, [r4, #10] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; 5dc: 71de strb r6, [r3, #7] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask; 5de: 4b21 ldr r3, [pc, #132] ; (664 <_usb_d_dev_handle_trfail+0xdc>) _usb_d_dev_trans_stop(ept, bank_n, USB_TRANS_ERROR); 5e0: 4029 ands r1, r5 5e2: 18d2 adds r2, r2, r3 5e4: 7256 strb r6, [r2, #9] 5e6: 2204 movs r2, #4 _usb_d_dev_trans_stop(ept, _usb_d_dev_ep_is_in(ept), USB_TRANS_DONE); 5e8: 4b1f ldr r3, [pc, #124] ; (668 <_usb_d_dev_handle_trfail+0xe0>) 5ea: 4798 blx r3 } 5ec: b005 add sp, #20 5ee: bdf0 pop {r4, r5, r6, r7, pc} tmp = ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg; 5f0: 5d0c ldrb r4, [r1, r4] tmp = (tmp & USB_DEVICE_EPCFG_EPTYPE0_Msk) >> USB_DEVICE_EPCFG_EPTYPE0_Pos; 5f2: 2107 movs r1, #7 5f4: 4021 ands r1, r4 return tmp; 5f6: e7dd b.n 5b4 <_usb_d_dev_handle_trfail+0x2c> } else if (st.bit.ERRORFLOW) { 5f8: 2102 movs r1, #2 5fa: 003a movs r2, r7 5fc: 400a ands r2, r1 5fe: 9201 str r2, [sp, #4] 600: 420f tst r7, r1 602: d017 beq.n 634 <_usb_d_dev_handle_trfail+0xac> bank[bank_n].STATUS_BK.bit.ERRORFLOW = 0; 604: 7aa2 ldrb r2, [r4, #10] bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept); 606: 7cc7 ldrb r7, [r0, #19] bank[bank_n].STATUS_BK.bit.ERRORFLOW = 0; 608: 438a bics r2, r1 60a: 72a2 strb r2, [r4, #10] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; 60c: 4a13 ldr r2, [pc, #76] ; (65c <_usb_d_dev_handle_trfail+0xd4>) 60e: 015b lsls r3, r3, #5 610: 189b adds r3, r3, r2 612: 71de strb r6, [r3, #7] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask; 614: 9a00 ldr r2, [sp, #0] 616: 4b13 ldr r3, [pc, #76] ; (664 <_usb_d_dev_handle_trfail+0xdc>) 618: 18d2 adds r2, r2, r3 if (is_ctrl && _usb_d_dev_ep_is_busy(ept)) { 61a: 2307 movs r3, #7 61c: 7256 strb r6, [r2, #9] 61e: 403b ands r3, r7 620: 2b01 cmp r3, #1 622: d1e3 bne.n 5ec <_usb_d_dev_handle_trfail+0x64> 624: 067b lsls r3, r7, #25 626: d5e1 bpl.n 5ec <_usb_d_dev_handle_trfail+0x64> if (bank_n != _usb_d_dev_ep_is_in(ept)) { 628: 7cc1 ldrb r1, [r0, #19] 62a: 09c9 lsrs r1, r1, #7 62c: 42a9 cmp r1, r5 62e: d0dd beq.n 5ec <_usb_d_dev_handle_trfail+0x64> _usb_d_dev_trans_stop(ept, _usb_d_dev_ep_is_in(ept), USB_TRANS_DONE); 630: 2200 movs r2, #0 632: e7d9 b.n 5e8 <_usb_d_dev_handle_trfail+0x60> bank->STATUS_BK.reg = 0; 634: 4662 mov r2, ip 636: 0051 lsls r1, r2, #1 638: 194d adds r5, r1, r5 63a: 4a09 ldr r2, [pc, #36] ; (660 <_usb_d_dev_handle_trfail+0xd8>) 63c: 012d lsls r5, r5, #4 63e: 1955 adds r5, r2, r5 640: 9a01 ldr r2, [sp, #4] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; 642: 015b lsls r3, r3, #5 644: 72aa strb r2, [r5, #10] 646: 4a05 ldr r2, [pc, #20] ; (65c <_usb_d_dev_handle_trfail+0xd4>) 648: 189b adds r3, r3, r2 64a: 71de strb r6, [r3, #7] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask; 64c: 9a00 ldr r2, [sp, #0] 64e: 4b05 ldr r3, [pc, #20] ; (664 <_usb_d_dev_handle_trfail+0xdc>) 650: 18d2 adds r2, r2, r3 652: 7256 strb r6, [r2, #9] } 654: e7ca b.n 5ec <_usb_d_dev_handle_trfail+0x64> 656: 46c0 nop ; (mov r8, r8) 658: 00000804 .word 0x00000804 65c: 41005000 .word 0x41005000 660: 200000a8 .word 0x200000a8 664: 410050ff .word 0x410050ff 668: 00000525 .word 0x00000525 0000066c <_usb_d_dev_reset_epts>: { 66c: b570 push {r4, r5, r6, lr} dev_inst.ep[i].ep = 0xFF; 66e: 26ff movs r6, #255 ; 0xff 670: 4d08 ldr r5, [pc, #32] ; (694 <_usb_d_dev_reset_epts+0x28>) 672: 4c09 ldr r4, [pc, #36] ; (698 <_usb_d_dev_reset_epts+0x2c>) 674: 35c8 adds r5, #200 ; 0xc8 _usb_d_dev_trans_done(&dev_inst.ep[i], USB_TRANS_RESET); 676: 2103 movs r1, #3 678: 0020 movs r0, r4 67a: 4b08 ldr r3, [pc, #32] ; (69c <_usb_d_dev_reset_epts+0x30>) 67c: 4798 blx r3 dev_inst.ep[i].flags.u8 = 0; 67e: 2100 movs r1, #0 dev_inst.ep[i].ep = 0xFF; 680: 74a6 strb r6, [r4, #18] dev_inst.ep[i].flags.u8 = 0; 682: 74e1 strb r1, [r4, #19] for (i = 0; i < USB_D_N_EP; i++) { 684: 3414 adds r4, #20 686: 42ac cmp r4, r5 688: d1f5 bne.n 676 <_usb_d_dev_reset_epts+0xa> memset(prvt_inst.desc_table, 0, sizeof(UsbDeviceDescriptor) * (CONF_USB_D_MAX_EP_N + 1)); 68a: 2260 movs r2, #96 ; 0x60 68c: 4b04 ldr r3, [pc, #16] ; (6a0 <_usb_d_dev_reset_epts+0x34>) 68e: 4805 ldr r0, [pc, #20] ; (6a4 <_usb_d_dev_reset_epts+0x38>) 690: 4798 blx r3 } 692: bd70 pop {r4, r5, r6, pc} 694: 20000108 .word 0x20000108 698: 2000011c .word 0x2000011c 69c: 00000501 .word 0x00000501 6a0: 00002367 .word 0x00002367 6a4: 200000a8 .word 0x200000a8 000006a8 <_usb_d_dev_in_next>: { 6a8: b5f0 push {r4, r5, r6, r7, lr} uint8_t epn = USB_EP_GET_N(ept->ep); 6aa: 270f movs r7, #15 { 6ac: b085 sub sp, #20 6ae: 9101 str r1, [sp, #4] uint8_t epn = USB_EP_GET_N(ept->ep); 6b0: 7c83 ldrb r3, [r0, #18] { 6b2: 0004 movs r4, r0 uint8_t epn = USB_EP_GET_N(ept->ep); 6b4: 9302 str r3, [sp, #8] 6b6: 401f ands r7, r3 uint16_t trans_count = isr ? bank[1].PCKSIZE.bit.BYTE_COUNT : 0; 6b8: 2300 movs r3, #0 6ba: 4299 cmp r1, r3 6bc: d005 beq.n 6ca <_usb_d_dev_in_next+0x22> UsbDeviceDescBank *bank = &prvt_inst.desc_table[epn].DeviceDescBank[0]; 6be: 4b4b ldr r3, [pc, #300] ; (7ec <_usb_d_dev_in_next+0x144>) 6c0: 017a lsls r2, r7, #5 6c2: 189b adds r3, r3, r2 uint16_t trans_count = isr ? bank[1].PCKSIZE.bit.BYTE_COUNT : 0; 6c4: 695b ldr r3, [r3, #20] 6c6: 049b lsls r3, r3, #18 6c8: 0c9b lsrs r3, r3, #18 uint16_t last_pkt = trans_count & ((ept->size == 1023) ? ept->size : (ept->size - 1)); 6ca: 8a25 ldrh r5, [r4, #16] 6cc: 4a48 ldr r2, [pc, #288] ; (7f0 <_usb_d_dev_in_next+0x148>) 6ce: 46ac mov ip, r5 6d0: 4295 cmp r5, r2 6d2: d002 beq.n 6da <_usb_d_dev_in_next+0x32> 6d4: 1e6a subs r2, r5, #1 6d6: b212 sxth r2, r2 6d8: 4694 mov ip, r2 bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept); 6da: 2207 movs r2, #7 6dc: 7ce0 ldrb r0, [r4, #19] 6de: 4002 ands r2, r0 6e0: 9203 str r2, [sp, #12] if (isr) { 6e2: 9a01 ldr r2, [sp, #4] 6e4: 2a00 cmp r2, #0 6e6: d004 beq.n 6f2 <_usb_d_dev_in_next+0x4a> ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; 6e8: 4942 ldr r1, [pc, #264] ; (7f4 <_usb_d_dev_in_next+0x14c>) 6ea: 017a lsls r2, r7, #5 6ec: 1852 adds r2, r2, r1 6ee: 2102 movs r1, #2 6f0: 71d1 strb r1, [r2, #7] ept->trans_count += trans_count; 6f2: 68a2 ldr r2, [r4, #8] 6f4: 1899 adds r1, r3, r2 if (ept->trans_count < ept->trans_size) { 6f6: 6862 ldr r2, [r4, #4] ept->trans_count += trans_count; 6f8: 60a1 str r1, [r4, #8] if (ept->trans_count < ept->trans_size) { 6fa: 4291 cmp r1, r2 6fc: d240 bcs.n 780 <_usb_d_dev_in_next+0xd8> memcpy(ept->cache, &ept->trans_buf[ept->trans_count], trans_next); 6fe: 6823 ldr r3, [r4, #0] trans_next = ept->trans_size - ept->trans_count; 700: 1a52 subs r2, r2, r1 memcpy(ept->cache, &ept->trans_buf[ept->trans_count], trans_next); 702: 1859 adds r1, r3, r1 704: 017b lsls r3, r7, #5 706: 4e39 ldr r6, [pc, #228] ; (7ec <_usb_d_dev_in_next+0x144>) trans_next = ept->trans_size - ept->trans_count; 708: b292 uxth r2, r2 if (ept->flags.bits.use_cache) { 70a: 9302 str r3, [sp, #8] 70c: 0683 lsls r3, r0, #26 70e: d52c bpl.n 76a <_usb_d_dev_in_next+0xc2> if (trans_next > ept->size) { 710: 1c2b adds r3, r5, #0 712: 4295 cmp r5, r2 714: d900 bls.n 718 <_usb_d_dev_in_next+0x70> 716: 1c13 adds r3, r2, #0 718: b29d uxth r5, r3 memcpy(ept->cache, &ept->trans_buf[ept->trans_count], trans_next); 71a: 002a movs r2, r5 71c: 4b36 ldr r3, [pc, #216] ; (7f8 <_usb_d_dev_in_next+0x150>) 71e: 68e0 ldr r0, [r4, #12] 720: 4798 blx r3 bank->ADDR.reg = addr; 722: 4b32 ldr r3, [pc, #200] ; (7ec <_usb_d_dev_in_next+0x144>) _usbd_ep_set_buf(epn, 1, (uint32_t)ept->cache); 724: 68e2 ldr r2, [r4, #12] bank->ADDR.reg = addr; 726: 0179 lsls r1, r7, #5 728: 185b adds r3, r3, r1 72a: 611a str r2, [r3, #16] bank->PCKSIZE.bit.BYTE_COUNT = size; 72c: 017b lsls r3, r7, #5 72e: 18f6 adds r6, r6, r3 730: 6973 ldr r3, [r6, #20] 732: 04ad lsls r5, r5, #18 734: 0b9b lsrs r3, r3, #14 736: 0caa lsrs r2, r5, #18 738: 039d lsls r5, r3, #14 73a: 4315 orrs r5, r2 73c: 6175 str r5, [r6, #20] bank->PCKSIZE.bit.MULTI_PACKET_SIZE = count; 73e: 6973 ldr r3, [r6, #20] 740: 4a2e ldr r2, [pc, #184] ; (7fc <_usb_d_dev_in_next+0x154>) 742: 4013 ands r3, r2 744: 6173 str r3, [r6, #20] if (!isr) { 746: 9b01 ldr r3, [sp, #4] 748: 2b00 cmp r3, #0 74a: d108 bne.n 75e <_usb_d_dev_in_next+0xb6> if (is_ctrl) { 74c: 9b03 ldr r3, [sp, #12] inten = USB_D_BANK1_INT_FLAGS | USB_DEVICE_EPINTFLAG_TRFAIL0; 74e: 224e movs r2, #78 ; 0x4e if (is_ctrl) { 750: 2b01 cmp r3, #1 752: d000 beq.n 756 <_usb_d_dev_in_next+0xae> inten = USB_D_BANK1_INT_FLAGS; 754: 3a04 subs r2, #4 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENSET.reg = mask; 756: 492a ldr r1, [pc, #168] ; (800 <_usb_d_dev_in_next+0x158>) 758: 017b lsls r3, r7, #5 75a: 185b adds r3, r3, r1 75c: 729a strb r2, [r3, #10] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask; 75e: 4a25 ldr r2, [pc, #148] ; (7f4 <_usb_d_dev_in_next+0x14c>) 760: 017b lsls r3, r7, #5 762: 189b adds r3, r3, r2 764: 2280 movs r2, #128 ; 0x80 766: 715a strb r2, [r3, #5] } 768: e039 b.n 7de <_usb_d_dev_in_next+0x136> if (trans_next > USB_D_DEV_TRANS_MAX) { 76a: 2380 movs r3, #128 ; 0x80 76c: 1c15 adds r5, r2, #0 76e: 019b lsls r3, r3, #6 770: 429a cmp r2, r3 772: d900 bls.n 776 <_usb_d_dev_in_next+0xce> 774: 1c1d adds r5, r3, #0 bank->ADDR.reg = addr; 776: 017b lsls r3, r7, #5 778: 18f3 adds r3, r6, r3 77a: b2ad uxth r5, r5 77c: 6119 str r1, [r3, #16] } 77e: e7d5 b.n 72c <_usb_d_dev_in_next+0x84> } else if (ept->flags.bits.need_zlp) { 780: 2610 movs r6, #16 782: 017a lsls r2, r7, #5 784: 4230 tst r0, r6 786: d00e beq.n 7a6 <_usb_d_dev_in_next+0xfe> ept->flags.bits.need_zlp = 0; 788: 7ce3 ldrb r3, [r4, #19] bank->PCKSIZE.bit.MULTI_PACKET_SIZE = count; 78a: 491c ldr r1, [pc, #112] ; (7fc <_usb_d_dev_in_next+0x154>) ept->flags.bits.need_zlp = 0; 78c: 43b3 bics r3, r6 78e: 74e3 strb r3, [r4, #19] bank->PCKSIZE.bit.BYTE_COUNT = size; 790: 4b16 ldr r3, [pc, #88] ; (7ec <_usb_d_dev_in_next+0x144>) 792: 189a adds r2, r3, r2 794: 1992 adds r2, r2, r6 796: 6853 ldr r3, [r2, #4] 798: 0b9b lsrs r3, r3, #14 79a: 039b lsls r3, r3, #14 79c: 6053 str r3, [r2, #4] bank->PCKSIZE.bit.MULTI_PACKET_SIZE = count; 79e: 6853 ldr r3, [r2, #4] 7a0: 400b ands r3, r1 7a2: 6053 str r3, [r2, #4] goto _in_tx_exec; 7a4: e7cf b.n 746 <_usb_d_dev_in_next+0x9e> if (is_ctrl) { 7a6: 9803 ldr r0, [sp, #12] 7a8: 2801 cmp r0, #1 7aa: d11a bne.n 7e2 <_usb_d_dev_in_next+0x13a> ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask; 7ac: 4814 ldr r0, [pc, #80] ; (800 <_usb_d_dev_in_next+0x158>) 7ae: 1812 adds r2, r2, r0 7b0: 204b movs r0, #75 ; 0x4b 7b2: 7250 strb r0, [r2, #9] if (last_pkt == ept->size) { 7b4: 4662 mov r2, ip 7b6: 4013 ands r3, r2 7b8: 429d cmp r5, r3 7ba: d10c bne.n 7d6 <_usb_d_dev_in_next+0x12e> ept->flags.bits.is_busy = 0; 7bc: 2540 movs r5, #64 ; 0x40 7be: 7ce3 ldrb r3, [r4, #19] if (dev_inst.ep_callbacks.more(ept->ep, ept->trans_count)) { 7c0: 9802 ldr r0, [sp, #8] ept->flags.bits.is_busy = 0; 7c2: 43ab bics r3, r5 7c4: 74e3 strb r3, [r4, #19] if (dev_inst.ep_callbacks.more(ept->ep, ept->trans_count)) { 7c6: 4b0f ldr r3, [pc, #60] ; (804 <_usb_d_dev_in_next+0x15c>) 7c8: 68db ldr r3, [r3, #12] 7ca: 4798 blx r3 7cc: 2800 cmp r0, #0 7ce: d106 bne.n 7de <_usb_d_dev_in_next+0x136> ept->flags.bits.is_busy = 1; 7d0: 7ce3 ldrb r3, [r4, #19] 7d2: 432b orrs r3, r5 7d4: 74e3 strb r3, [r4, #19] _usb_d_dev_trans_done(ept, USB_TRANS_DONE); 7d6: 2100 movs r1, #0 7d8: 0020 movs r0, r4 7da: 4b0b ldr r3, [pc, #44] ; (808 <_usb_d_dev_in_next+0x160>) 7dc: 4798 blx r3 } 7de: b005 add sp, #20 7e0: bdf0 pop {r4, r5, r6, r7, pc} 7e2: 4807 ldr r0, [pc, #28] ; (800 <_usb_d_dev_in_next+0x158>) 7e4: 1812 adds r2, r2, r0 7e6: 204a movs r0, #74 ; 0x4a 7e8: e7e3 b.n 7b2 <_usb_d_dev_in_next+0x10a> 7ea: 46c0 nop ; (mov r8, r8) 7ec: 200000a8 .word 0x200000a8 7f0: 000003ff .word 0x000003ff 7f4: 41005100 .word 0x41005100 7f8: 00002355 .word 0x00002355 7fc: f0003fff .word 0xf0003fff 800: 410050ff .word 0x410050ff 804: 20000108 .word 0x20000108 808: 00000501 .word 0x00000501 0000080c <_usb_d_dev_out_next>: uint8_t epn = USB_EP_GET_N(ept->ep); 80c: 230f movs r3, #15 { 80e: b5f0 push {r4, r5, r6, r7, lr} uint8_t epn = USB_EP_GET_N(ept->ep); 810: 7c85 ldrb r5, [r0, #18] { 812: b085 sub sp, #20 814: 0004 movs r4, r0 816: 000e movs r6, r1 uint8_t epn = USB_EP_GET_N(ept->ep); 818: 401d ands r5, r3 uint16_t trans_size = isr ? bank->PCKSIZE.bit.MULTI_PACKET_SIZE : 0; 81a: 9103 str r1, [sp, #12] uint16_t last_trans = isr ? bank->PCKSIZE.bit.BYTE_COUNT : 0; 81c: 9101 str r1, [sp, #4] uint16_t trans_size = isr ? bank->PCKSIZE.bit.MULTI_PACKET_SIZE : 0; 81e: 2900 cmp r1, #0 820: d00a beq.n 838 <_usb_d_dev_out_next+0x2c> 822: 4b61 ldr r3, [pc, #388] ; (9a8 <_usb_d_dev_out_next+0x19c>) 824: 016a lsls r2, r5, #5 826: 189b adds r3, r3, r2 828: 6859 ldr r1, [r3, #4] 82a: 0109 lsls r1, r1, #4 82c: 0c8a lsrs r2, r1, #18 82e: 9203 str r2, [sp, #12] uint16_t last_trans = isr ? bank->PCKSIZE.bit.BYTE_COUNT : 0; 830: 6859 ldr r1, [r3, #4] 832: 0489 lsls r1, r1, #18 834: 0c8b lsrs r3, r1, #18 836: 9301 str r3, [sp, #4] uint16_t size_mask = (ept->size == 1023) ? 1023 : (ept->size - 1); 838: 8a23 ldrh r3, [r4, #16] 83a: 9300 str r3, [sp, #0] 83c: 9a00 ldr r2, [sp, #0] 83e: 4b5b ldr r3, [pc, #364] ; (9ac <_usb_d_dev_out_next+0x1a0>) 840: 429a cmp r2, r3 842: d003 beq.n 84c <_usb_d_dev_out_next+0x40> 844: 0013 movs r3, r2 846: 3b01 subs r3, #1 848: b29b uxth r3, r3 84a: 9300 str r3, [sp, #0] uint16_t last_pkt = last_trans & size_mask; 84c: 9b01 ldr r3, [sp, #4] 84e: 9f00 ldr r7, [sp, #0] bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept); 850: 7ce2 ldrb r2, [r4, #19] uint16_t last_pkt = last_trans & size_mask; 852: 401f ands r7, r3 bool is_ctrl = _usb_d_dev_ep_is_ctrl(ept); 854: 2307 movs r3, #7 856: 4013 ands r3, r2 858: 9302 str r3, [sp, #8] if (isr) { 85a: 2e00 cmp r6, #0 85c: d004 beq.n 868 <_usb_d_dev_out_next+0x5c> ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; 85e: 4954 ldr r1, [pc, #336] ; (9b0 <_usb_d_dev_out_next+0x1a4>) 860: 016b lsls r3, r5, #5 862: 185b adds r3, r3, r1 864: 2101 movs r1, #1 866: 71d9 strb r1, [r3, #7] if (ept->flags.bits.use_cache && ept->trans_size) { 868: 0693 lsls r3, r2, #26 86a: d50f bpl.n 88c <_usb_d_dev_out_next+0x80> 86c: 6863 ldr r3, [r4, #4] 86e: 2b00 cmp r3, #0 870: d00c beq.n 88c <_usb_d_dev_out_next+0x80> uint16_t buf_remain = ept->trans_size - ept->trans_count; 872: 68a2 ldr r2, [r4, #8] memcpy(&ept->trans_buf[ept->trans_count], ept->cache, (buf_remain > last_pkt) ? last_pkt : buf_remain); 874: 6821 ldr r1, [r4, #0] uint16_t buf_remain = ept->trans_size - ept->trans_count; 876: 1a9b subs r3, r3, r2 memcpy(&ept->trans_buf[ept->trans_count], ept->cache, (buf_remain > last_pkt) ? last_pkt : buf_remain); 878: 1888 adds r0, r1, r2 87a: 1c1a adds r2, r3, #0 87c: b29b uxth r3, r3 87e: 42bb cmp r3, r7 880: d900 bls.n 884 <_usb_d_dev_out_next+0x78> 882: 1c3a adds r2, r7, #0 884: 68e1 ldr r1, [r4, #12] 886: 4b4b ldr r3, [pc, #300] ; (9b4 <_usb_d_dev_out_next+0x1a8>) 888: b292 uxth r2, r2 88a: 4798 blx r3 if (ept->trans_size == 0 && ept->flags.bits.need_zlp) { 88c: 6863 ldr r3, [r4, #4] 88e: 016a lsls r2, r5, #5 890: 4694 mov ip, r2 892: 2b00 cmp r3, #0 894: d12c bne.n 8f0 <_usb_d_dev_out_next+0xe4> 896: 7ce2 ldrb r2, [r4, #19] 898: 06d1 lsls r1, r2, #27 89a: d529 bpl.n 8f0 <_usb_d_dev_out_next+0xe4> ept->flags.bits.need_zlp = 0; 89c: 3330 adds r3, #48 ; 0x30 89e: 439a bics r2, r3 8a0: 3b10 subs r3, #16 8a2: 431a orrs r2, r3 8a4: 74e2 strb r2, [r4, #19] bank->ADDR.reg = addr; 8a6: 4662 mov r2, ip 8a8: 68e1 ldr r1, [r4, #12] 8aa: 4b3f ldr r3, [pc, #252] ; (9a8 <_usb_d_dev_out_next+0x19c>) bank->PCKSIZE.bit.MULTI_PACKET_SIZE = size; 8ac: 4842 ldr r0, [pc, #264] ; (9b8 <_usb_d_dev_out_next+0x1ac>) bank->ADDR.reg = addr; 8ae: 5099 str r1, [r3, r2] bank->PCKSIZE.bit.MULTI_PACKET_SIZE = size; 8b0: 8a21 ldrh r1, [r4, #16] 8b2: 4463 add r3, ip 8b4: 685a ldr r2, [r3, #4] 8b6: 0489 lsls r1, r1, #18 8b8: 0909 lsrs r1, r1, #4 8ba: 4002 ands r2, r0 8bc: 430a orrs r2, r1 8be: 605a str r2, [r3, #4] bank->PCKSIZE.bit.BYTE_COUNT = count; 8c0: 685a ldr r2, [r3, #4] 8c2: 0b92 lsrs r2, r2, #14 8c4: 0392 lsls r2, r2, #14 8c6: 605a str r2, [r3, #4] if (!isr) { 8c8: 2e00 cmp r6, #0 8ca: d10b bne.n 8e4 <_usb_d_dev_out_next+0xd8> if (is_ctrl) { 8cc: 9902 ldr r1, [sp, #8] inten = USB_D_BANK0_INT_FLAGS; 8ce: 2225 movs r2, #37 ; 0x25 8d0: 016b lsls r3, r5, #5 if (is_ctrl) { 8d2: 2901 cmp r1, #1 8d4: d103 bne.n 8de <_usb_d_dev_out_next+0xd2> bank->STATUS_BK.reg = 0; 8d6: 4a34 ldr r2, [pc, #208] ; (9a8 <_usb_d_dev_out_next+0x19c>) 8d8: 18d2 adds r2, r2, r3 8da: 7696 strb r6, [r2, #26] inten = USB_D_BANK0_INT_FLAGS | USB_DEVICE_EPINTFLAG_TRFAIL1; 8dc: 222d movs r2, #45 ; 0x2d ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENSET.reg = mask; 8de: 4937 ldr r1, [pc, #220] ; (9bc <_usb_d_dev_out_next+0x1b0>) 8e0: 185b adds r3, r3, r1 8e2: 729a strb r2, [r3, #10] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask; 8e4: 4b32 ldr r3, [pc, #200] ; (9b0 <_usb_d_dev_out_next+0x1a4>) 8e6: 016d lsls r5, r5, #5 8e8: 18ed adds r5, r5, r3 8ea: 2340 movs r3, #64 ; 0x40 8ec: 712b strb r3, [r5, #4] } 8ee: e01d b.n 92c <_usb_d_dev_out_next+0x120> ept->trans_count += last_trans; 8f0: 68a1 ldr r1, [r4, #8] } else if (isr && last_pkt < ept->size) { 8f2: 2e00 cmp r6, #0 8f4: d01c beq.n 930 <_usb_d_dev_out_next+0x124> 8f6: 8a22 ldrh r2, [r4, #16] 8f8: 42ba cmp r2, r7 8fa: d919 bls.n 930 <_usb_d_dev_out_next+0x124> ept->flags.bits.need_zlp = 0; 8fc: 2210 movs r2, #16 8fe: 7ce3 ldrb r3, [r4, #19] 900: 4393 bics r3, r2 902: 74e3 strb r3, [r4, #19] ept->trans_count += last_trans; 904: 9b01 ldr r3, [sp, #4] 906: 1859 adds r1, r3, r1 908: 60a1 str r1, [r4, #8] if (is_ctrl) { 90a: 9a02 ldr r2, [sp, #8] 90c: 016b lsls r3, r5, #5 90e: 2a01 cmp r2, #1 910: d146 bne.n 9a0 <_usb_d_dev_out_next+0x194> ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask; 912: 4a2a ldr r2, [pc, #168] ; (9bc <_usb_d_dev_out_next+0x1b0>) 914: 189b adds r3, r3, r2 916: 222d movs r2, #45 ; 0x2d 918: 725a strb r2, [r3, #9] if (0 == epn) { 91a: 2d00 cmp r5, #0 91c: d102 bne.n 924 <_usb_d_dev_out_next+0x118> bank->ADDR.reg = addr; 91e: 4b22 ldr r3, [pc, #136] ; (9a8 <_usb_d_dev_out_next+0x19c>) 920: 68e2 ldr r2, [r4, #12] 922: 601a str r2, [r3, #0] _usb_d_dev_trans_done(ept, USB_TRANS_DONE); 924: 2100 movs r1, #0 926: 0020 movs r0, r4 928: 4b25 ldr r3, [pc, #148] ; (9c0 <_usb_d_dev_out_next+0x1b4>) 92a: 4798 blx r3 } 92c: b005 add sp, #20 92e: bdf0 pop {r4, r5, r6, r7, pc} ept->trans_count += trans_size; 930: 9a03 ldr r2, [sp, #12] 932: 1851 adds r1, r2, r1 934: 60a1 str r1, [r4, #8] if (ept->trans_count < ept->trans_size) { 936: 428b cmp r3, r1 938: d9e7 bls.n 90a <_usb_d_dev_out_next+0xfe> if (ept->flags.bits.use_cache) { 93a: 2020 movs r0, #32 93c: 7ce2 ldrb r2, [r4, #19] trans_next = ept->trans_size - ept->trans_count; 93e: 1a5b subs r3, r3, r1 _usbd_ep_set_out_trans(epn, 0, ept->size, 0); 940: 8a27 ldrh r7, [r4, #16] trans_next = ept->trans_size - ept->trans_count; 942: b29b uxth r3, r3 if (ept->flags.bits.use_cache) { 944: 4202 tst r2, r0 946: d016 beq.n 976 <_usb_d_dev_out_next+0x16a> if (trans_next > ept->size) { 948: 1c39 adds r1, r7, #0 94a: 429f cmp r7, r3 94c: d900 bls.n 950 <_usb_d_dev_out_next+0x144> 94e: 1c19 adds r1, r3, #0 _usbd_ep_set_buf(epn, 0, (uint32_t)ept->cache); 950: 68e0 ldr r0, [r4, #12] bank->ADDR.reg = addr; 952: 4a15 ldr r2, [pc, #84] ; (9a8 <_usb_d_dev_out_next+0x19c>) 954: b28b uxth r3, r1 956: 0169 lsls r1, r5, #5 958: 5050 str r0, [r2, r1] bank->PCKSIZE.bit.MULTI_PACKET_SIZE = size; 95a: 4a13 ldr r2, [pc, #76] ; (9a8 <_usb_d_dev_out_next+0x19c>) 95c: 4816 ldr r0, [pc, #88] ; (9b8 <_usb_d_dev_out_next+0x1ac>) 95e: 4462 add r2, ip 960: 6851 ldr r1, [r2, #4] 962: 049b lsls r3, r3, #18 964: 091b lsrs r3, r3, #4 966: 4001 ands r1, r0 968: 430b orrs r3, r1 96a: 6053 str r3, [r2, #4] bank->PCKSIZE.bit.BYTE_COUNT = count; 96c: 6853 ldr r3, [r2, #4] 96e: 0b9b lsrs r3, r3, #14 970: 039b lsls r3, r3, #14 972: 6053 str r3, [r2, #4] goto _out_rx_exec; 974: e7a8 b.n 8c8 <_usb_d_dev_out_next+0xbc> if (trans_next > ept->size) { 976: 429f cmp r7, r3 978: d20b bcs.n 992 <_usb_d_dev_out_next+0x186> if (trans_next > USB_D_DEV_TRANS_MAX) { 97a: 2080 movs r0, #128 ; 0x80 97c: 0180 lsls r0, r0, #6 97e: 4283 cmp r3, r0 980: d80c bhi.n 99c <_usb_d_dev_out_next+0x190> trans_next -= trans_next & size_mask; 982: 9a00 ldr r2, [sp, #0] 984: 4393 bics r3, r2 _usbd_ep_set_buf(epn, 0, (uint32_t)&ept->trans_buf[ept->trans_count]); 986: 6820 ldr r0, [r4, #0] bank->ADDR.reg = addr; 988: 4a07 ldr r2, [pc, #28] ; (9a8 <_usb_d_dev_out_next+0x19c>) _usbd_ep_set_buf(epn, 0, (uint32_t)&ept->trans_buf[ept->trans_count]); 98a: 1841 adds r1, r0, r1 bank->ADDR.reg = addr; 98c: 0168 lsls r0, r5, #5 98e: 5011 str r1, [r2, r0] } 990: e7e3 b.n 95a <_usb_d_dev_out_next+0x14e> } else if (trans_next < ept->size) { 992: 429f cmp r7, r3 994: d9f7 bls.n 986 <_usb_d_dev_out_next+0x17a> ept->flags.bits.use_cache = 1; 996: 4310 orrs r0, r2 998: 74e0 strb r0, [r4, #19] 99a: e7f4 b.n 986 <_usb_d_dev_out_next+0x17a> trans_next = USB_D_DEV_TRANS_MAX; 99c: 0003 movs r3, r0 99e: e7f2 b.n 986 <_usb_d_dev_out_next+0x17a> 9a0: 4a06 ldr r2, [pc, #24] ; (9bc <_usb_d_dev_out_next+0x1b0>) 9a2: 189b adds r3, r3, r2 9a4: 2225 movs r2, #37 ; 0x25 9a6: e7b7 b.n 918 <_usb_d_dev_out_next+0x10c> 9a8: 200000a8 .word 0x200000a8 9ac: 000003ff .word 0x000003ff 9b0: 41005100 .word 0x41005100 9b4: 00002355 .word 0x00002355 9b8: f0003fff .word 0xf0003fff 9bc: 410050ff .word 0x410050ff 9c0: 00000501 .word 0x00000501 000009c4 <_usbd_ep_pcksize_size>: : ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0))))))); 9c4: 2380 movs r3, #128 ; 0x80 { 9c6: 0002 movs r2, r0 : ((n > 256) ? 6 : ((n > 128) ? 5 : ((n > 64) ? 4 : ((n > 32) ? 3 : ((n > 16) ? 2 : ((n > 8) ? 1 : 0))))))); 9c8: 009b lsls r3, r3, #2 9ca: 2007 movs r0, #7 9cc: 429a cmp r2, r3 9ce: d814 bhi.n 9fa <_usbd_ep_pcksize_size+0x36> 9d0: 3b01 subs r3, #1 9d2: 3bff subs r3, #255 ; 0xff 9d4: 3801 subs r0, #1 9d6: 429a cmp r2, r3 9d8: d80f bhi.n 9fa <_usbd_ep_pcksize_size+0x36> 9da: 3801 subs r0, #1 9dc: 2a80 cmp r2, #128 ; 0x80 9de: d80c bhi.n 9fa <_usbd_ep_pcksize_size+0x36> 9e0: 3801 subs r0, #1 9e2: 2a40 cmp r2, #64 ; 0x40 9e4: d809 bhi.n 9fa <_usbd_ep_pcksize_size+0x36> 9e6: 3801 subs r0, #1 9e8: 2a20 cmp r2, #32 9ea: d806 bhi.n 9fa <_usbd_ep_pcksize_size+0x36> 9ec: 3801 subs r0, #1 9ee: 2a10 cmp r2, #16 9f0: d803 bhi.n 9fa <_usbd_ep_pcksize_size+0x36> 9f2: 3006 adds r0, #6 9f4: 4290 cmp r0, r2 9f6: 4180 sbcs r0, r0 9f8: 4240 negs r0, r0 } 9fa: 4770 bx lr 000009fc <_usb_d_dev_init>: { 9fc: b510 push {r4, lr} return ((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg; 9fe: 4c2a ldr r4, [pc, #168] ; (aa8 <_usb_d_dev_init+0xac>) a00: 78a3 ldrb r3, [r4, #2] if (!hri_usbdevice_is_syncing(hw, USB_SYNCBUSY_SWRST)) { a02: 07db lsls r3, r3, #31 a04: d418 bmi.n a38 <_usb_d_dev_init+0x3c> while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) { a06: 2303 movs r3, #3 a08: 78a2 ldrb r2, [r4, #2] a0a: 421a tst r2, r3 a0c: d1fc bne.n a08 <_usb_d_dev_init+0xc> 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; tmp &= mask; a0e: 2202 movs r2, #2 tmp = ((Usb *)hw)->HOST.CTRLA.reg; a10: 7823 ldrb r3, [r4, #0] if (hri_usbdevice_get_CTRLA_reg(hw, USB_CTRLA_ENABLE)) { a12: 4213 tst r3, r2 a14: d00a beq.n a2c <_usb_d_dev_init+0x30> ((Usb *)hw)->HOST.CTRLA.reg &= ~USB_CTRLA_ENABLE; a16: 7823 ldrb r3, [r4, #0] a18: 4393 bics r3, r2 a1a: 7023 strb r3, [r4, #0] while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) { a1c: 2303 movs r3, #3 a1e: 78a2 ldrb r2, [r4, #2] a20: 421a tst r2, r3 a22: d1fc bne.n a1e <_usb_d_dev_init+0x22> a24: 2302 movs r3, #2 a26: 78a2 ldrb r2, [r4, #2] a28: 421a tst r2, r3 a2a: d1fc bne.n a26 <_usb_d_dev_init+0x2a> } 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; a2c: 2301 movs r3, #1 a2e: 7023 strb r3, [r4, #0] while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) { a30: 3302 adds r3, #2 a32: 78a2 ldrb r2, [r4, #2] a34: 421a tst r2, r3 a36: d1fc bne.n a32 <_usb_d_dev_init+0x36> a38: 2301 movs r3, #1 a3a: 78a2 ldrb r2, [r4, #2] a3c: 421a tst r2, r3 a3e: d1fc bne.n a3a <_usb_d_dev_init+0x3e> dev_inst.callbacks.sof = (_usb_d_dev_sof_cb_t)_dummy_func_no_return; a40: 4b1a ldr r3, [pc, #104] ; (aac <_usb_d_dev_init+0xb0>) a42: 4a1b ldr r2, [pc, #108] ; (ab0 <_usb_d_dev_init+0xb4>) a44: 601a str r2, [r3, #0] dev_inst.callbacks.event = (_usb_d_dev_event_cb_t)_dummy_func_no_return; a46: 605a str r2, [r3, #4] dev_inst.ep_callbacks.setup = (_usb_d_dev_ep_cb_setup_t)_dummy_func_no_return; a48: 609a str r2, [r3, #8] dev_inst.ep_callbacks.more = (_usb_d_dev_ep_cb_more_t)_dummy_func_no_return; a4a: 60da str r2, [r3, #12] dev_inst.ep_callbacks.done = (_usb_d_dev_ep_cb_done_t)_dummy_func_no_return; a4c: 611a str r2, [r3, #16] _usb_d_dev_reset_epts(); a4e: 4b19 ldr r3, [pc, #100] ; (ab4 <_usb_d_dev_init+0xb8>) a50: 4798 blx r3 uint32_t pad_transn a52: 201f movs r0, #31 = (*((uint32_t *)(NVMCTRL_OTP4) + (NVM_USB_PAD_TRANSN_POS / 32)) >> (NVM_USB_PAD_TRANSN_POS % 32)) a54: 4b18 ldr r3, [pc, #96] ; (ab8 <_usb_d_dev_init+0xbc>) a56: 681a ldr r2, [r3, #0] a58: 0b53 lsrs r3, r2, #13 = (*((uint32_t *)(NVMCTRL_OTP4) + (NVM_USB_PAD_TRANSP_POS / 32)) >> (NVM_USB_PAD_TRANSP_POS % 32)) a5a: 0c91 lsrs r1, r2, #18 uint32_t pad_trim = (*((uint32_t *)(NVMCTRL_OTP4) + (NVM_USB_PAD_TRIM_POS / 32)) >> (NVM_USB_PAD_TRIM_POS % 32)) a5c: 0192 lsls r2, r2, #6 uint32_t pad_transn a5e: 4003 ands r3, r0 uint32_t pad_transp a60: 4001 ands r1, r0 uint32_t pad_trim = (*((uint32_t *)(NVMCTRL_OTP4) + (NVM_USB_PAD_TRIM_POS / 32)) >> (NVM_USB_PAD_TRIM_POS % 32)) a62: 0f52 lsrs r2, r2, #29 if (pad_transn == 0x1F) { a64: 4283 cmp r3, r0 a66: d100 bne.n a6a <_usb_d_dev_init+0x6e> pad_transn = 5; a68: 2305 movs r3, #5 if (pad_transp == 0x1F) { a6a: 291f cmp r1, #31 a6c: d100 bne.n a70 <_usb_d_dev_init+0x74> pad_transp = 29; a6e: 3902 subs r1, #2 if (pad_trim == 0x7) { a70: 2a07 cmp r2, #7 a72: d100 bne.n a76 <_usb_d_dev_init+0x7a> pad_trim = 5; a74: 3a02 subs r2, #2 hw->DEVICE.PADCAL.reg = USB_PADCAL_TRANSN(pad_transn) | USB_PADCAL_TRANSP(pad_transp) | USB_PADCAL_TRIM(pad_trim); a76: 019b lsls r3, r3, #6 a78: 430b orrs r3, r1 a7a: 0312 lsls r2, r2, #12 a7c: 4313 orrs r3, r2 a7e: 8523 strh r3, [r4, #40] ; 0x28 hw->DEVICE.QOSCTRL.bit.CQOS = 3; a80: 2303 movs r3, #3 a82: 78e2 ldrb r2, [r4, #3] a84: 431a orrs r2, r3 a86: 70e2 strb r2, [r4, #3] hw->DEVICE.QOSCTRL.bit.DQOS = 3; a88: 220c movs r2, #12 a8a: 78e1 ldrb r1, [r4, #3] a8c: 430a orrs r2, r1 a8e: 70e2 strb r2, [r4, #3] ((Usb *)hw)->HOST.CTRLA.reg = data; a90: 2204 movs r2, #4 a92: 7022 strb r2, [r4, #0] while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) { a94: 78a2 ldrb r2, [r4, #2] a96: 0010 movs r0, r2 a98: 4018 ands r0, r3 a9a: 421a tst r2, r3 a9c: d1fa bne.n a94 <_usb_d_dev_init+0x98> hri_usbdevice_write_DESCADD_reg(hw, (uint32_t)prvt_inst.desc_table); a9e: 4b07 ldr r3, [pc, #28] ; (abc <_usb_d_dev_init+0xc0>) } 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; aa0: 6263 str r3, [r4, #36] ; 0x24 ((Usb *)hw)->DEVICE.CTRLB.reg = data; aa2: 2301 movs r3, #1 aa4: 8123 strh r3, [r4, #8] } aa6: bd10 pop {r4, pc} aa8: 41005000 .word 0x41005000 aac: 20000108 .word 0x20000108 ab0: 00000415 .word 0x00000415 ab4: 0000066d .word 0x0000066d ab8: 00806024 .word 0x00806024 abc: 200000a8 .word 0x200000a8 00000ac0 <_usb_d_dev_enable>: tmp &= mask; ac0: 2203 movs r2, #3 tmp = ((Usb *)hw)->HOST.SYNCBUSY.reg; ac2: 4b0e ldr r3, [pc, #56] ; (afc <_usb_d_dev_enable+0x3c>) ac4: 7899 ldrb r1, [r3, #2] if (hri_usbdevice_get_SYNCBUSY_reg(hw, (USB_SYNCBUSY_ENABLE | USB_SYNCBUSY_SWRST))) { ac6: 4211 tst r1, r2 ac8: d114 bne.n af4 <_usb_d_dev_enable+0x34> while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) { aca: 7899 ldrb r1, [r3, #2] acc: 4211 tst r1, r2 ace: d1fc bne.n aca <_usb_d_dev_enable+0xa> if ((ctrla & USB_CTRLA_ENABLE) == 0) { ad0: 2202 movs r2, #2 return ((Usb *)hw)->HOST.CTRLA.reg; ad2: 7819 ldrb r1, [r3, #0] ad4: b2c8 uxtb r0, r1 ad6: 4211 tst r1, r2 ad8: d105 bne.n ae6 <_usb_d_dev_enable+0x26> hri_usbdevice_write_CTRLA_reg(hw, ctrla | USB_CTRLA_ENABLE); ada: 4302 orrs r2, r0 ((Usb *)hw)->HOST.CTRLA.reg = data; adc: 701a strb r2, [r3, #0] while (((Usb *)hw)->DEVICE.SYNCBUSY.reg & reg) { ade: 2203 movs r2, #3 ae0: 7899 ldrb r1, [r3, #2] ae2: 4211 tst r1, r2 ae4: d1fc bne.n ae0 <_usb_d_dev_enable+0x20> */ __STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn) { if ((int32_t)(IRQn) >= 0) { NVIC->ISER[0U] = (uint32_t)(1UL << (((uint32_t)IRQn) & 0x1FUL)); ae6: 2180 movs r1, #128 ; 0x80 return ERR_NONE; ae8: 2000 movs r0, #0 aea: 4a05 ldr r2, [pc, #20] ; (b00 <_usb_d_dev_enable+0x40>) aec: 6011 str r1, [r2, #0] ((Usb *)hw)->DEVICE.INTENSET.reg = mask; aee: 4a05 ldr r2, [pc, #20] ; (b04 <_usb_d_dev_enable+0x44>) af0: 831a strh r2, [r3, #24] } af2: 4770 bx lr return -USB_ERR_DENIED; af4: 2011 movs r0, #17 af6: 4240 negs r0, r0 af8: e7fb b.n af2 <_usb_d_dev_enable+0x32> afa: 46c0 nop ; (mov r8, r8) afc: 41005000 .word 0x41005000 b00: e000e100 .word 0xe000e100 b04: 0000028d .word 0x0000028d 00000b08 <_usb_d_dev_attach>: ((Usb *)hw)->DEVICE.CTRLB.reg &= ~USB_DEVICE_CTRLB_DETACH; b08: 2101 movs r1, #1 b0a: 4a02 ldr r2, [pc, #8] ; (b14 <_usb_d_dev_attach+0xc>) b0c: 8913 ldrh r3, [r2, #8] b0e: 438b bics r3, r1 b10: 8113 strh r3, [r2, #8] } b12: 4770 bx lr b14: 41005000 .word 0x41005000 00000b18 <_usb_d_dev_set_address>: hri_usbdevice_write_DADD_reg(USB, USB_DEVICE_DADD_ADDEN | USB_DEVICE_DADD_DADD(addr)); b18: 2380 movs r3, #128 ; 0x80 b1a: 4318 orrs r0, r3 ((Usb *)hw)->DEVICE.DADD.reg = data; b1c: 4b01 ldr r3, [pc, #4] ; (b24 <_usb_d_dev_set_address+0xc>) b1e: 7298 strb r0, [r3, #10] } b20: 4770 bx lr b22: 46c0 nop ; (mov r8, r8) b24: 41005000 .word 0x41005000 00000b28 <_usb_d_dev_ep_init>: { b28: b5f7 push {r0, r1, r2, r4, r5, r6, r7, lr} uint8_t epn = USB_EP_GET_N(ep); b2a: 240f movs r4, #15 b2c: 4004 ands r4, r0 struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); b2e: 4b2e ldr r3, [pc, #184] ; (be8 <_usb_d_dev_ep_init+0xc0>) { b30: 9100 str r1, [sp, #0] b32: 0006 movs r6, r0 struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); b34: 09c1 lsrs r1, r0, #7 b36: b247 sxtb r7, r0 b38: 0020 movs r0, r4 { b3a: 9201 str r2, [sp, #4] struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); b3c: 4798 blx r3 uint8_t ep_type = attr & USB_EP_XTYPE_MASK; b3e: 2103 movs r1, #3 b40: 9b00 ldr r3, [sp, #0] struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); b42: 0005 movs r5, r0 uint8_t ep_type = attr & USB_EP_XTYPE_MASK; b44: 400b ands r3, r1 b46: 9300 str r3, [sp, #0] if (epn > CONF_USB_D_MAX_EP_N) { b48: 2c02 cmp r4, #2 b4a: d844 bhi.n bd6 <_usb_d_dev_ep_init+0xae> if (ept->ep != 0xFF) { b4c: 7c83 ldrb r3, [r0, #18] b4e: 2bff cmp r3, #255 ; 0xff b50: d144 bne.n bdc <_usb_d_dev_ep_init+0xb4> if (ep_type == USB_EP_XTYPE_CTRL) { b52: 9b00 ldr r3, [sp, #0] b54: 2b00 cmp r3, #0 b56: d110 bne.n b7a <_usb_d_dev_ep_init+0x52> struct _usb_d_dev_ep *ept_in = _usb_d_dev_ept(epn, !dir); b58: 43f9 mvns r1, r7 b5a: b2c9 uxtb r1, r1 b5c: 4b22 ldr r3, [pc, #136] ; (be8 <_usb_d_dev_ep_init+0xc0>) b5e: 0020 movs r0, r4 b60: 09c9 lsrs r1, r1, #7 b62: 4798 blx r3 if (ept_in->ep != 0xFF) { b64: 7c83 ldrb r3, [r0, #18] b66: 2bff cmp r3, #255 ; 0xff b68: d138 bne.n bdc <_usb_d_dev_ep_init+0xb4> if (pcfg->cache == NULL) { b6a: 3bf3 subs r3, #243 ; 0xf3 b6c: 4363 muls r3, r4 b6e: 4a1f ldr r2, [pc, #124] ; (bec <_usb_d_dev_ep_init+0xc4>) b70: 589b ldr r3, [r3, r2] b72: 2b00 cmp r3, #0 b74: d134 bne.n be0 <_usb_d_dev_ep_init+0xb8> return -USB_ERR_FUNC; b76: 2013 movs r0, #19 b78: e02e b.n bd8 <_usb_d_dev_ep_init+0xb0> if ((dir ? pcfg->i_cache : pcfg->cache) && ((dir ? pcfg->i_size : pcfg->size) < max_pkt_siz)) { b7a: 2f00 cmp r7, #0 b7c: da14 bge.n ba8 <_usb_d_dev_ep_init+0x80> b7e: 220c movs r2, #12 b80: 4362 muls r2, r4 b82: 4b1a ldr r3, [pc, #104] ; (bec <_usb_d_dev_ep_init+0xc4>) b84: 189b adds r3, r3, r2 b86: 685a ldr r2, [r3, #4] b88: 2a00 cmp r2, #0 b8a: d119 bne.n bc0 <_usb_d_dev_ep_init+0x98> ept->cache = (uint8_t *)(dir ? pcfg->i_cache : pcfg->cache); b8c: 230c movs r3, #12 b8e: 4363 muls r3, r4 b90: 4c16 ldr r4, [pc, #88] ; (bec <_usb_d_dev_ep_init+0xc4>) b92: 18e4 adds r4, r4, r3 b94: 6863 ldr r3, [r4, #4] return USB_OK; b96: 2000 movs r0, #0 ept->flags.u8 = (ep_type + 1); b98: 9900 ldr r1, [sp, #0] ept->cache = (uint8_t *)(dir ? pcfg->i_cache : pcfg->cache); b9a: 60eb str r3, [r5, #12] ept->size = max_pkt_siz; b9c: 9b01 ldr r3, [sp, #4] ept->flags.u8 = (ep_type + 1); b9e: 3101 adds r1, #1 ept->size = max_pkt_siz; ba0: 822b strh r3, [r5, #16] ept->flags.u8 = (ep_type + 1); ba2: 74e9 strb r1, [r5, #19] ept->ep = ep; ba4: 74ae strb r6, [r5, #18] } ba6: bdfe pop {r1, r2, r3, r4, r5, r6, r7, pc} if ((dir ? pcfg->i_cache : pcfg->cache) && ((dir ? pcfg->i_size : pcfg->size) < max_pkt_siz)) { ba8: 230c movs r3, #12 baa: 4363 muls r3, r4 bac: 4a0f ldr r2, [pc, #60] ; (bec <_usb_d_dev_ep_init+0xc4>) bae: 589b ldr r3, [r3, r2] bb0: 2b00 cmp r3, #0 bb2: d00b beq.n bcc <_usb_d_dev_ep_init+0xa4> bb4: 220c movs r2, #12 bb6: 4362 muls r2, r4 bb8: 4b0c ldr r3, [pc, #48] ; (bec <_usb_d_dev_ep_init+0xc4>) bba: 189b adds r3, r3, r2 bbc: 891b ldrh r3, [r3, #8] bbe: e000 b.n bc2 <_usb_d_dev_ep_init+0x9a> bc0: 895b ldrh r3, [r3, #10] bc2: 9a01 ldr r2, [sp, #4] bc4: 429a cmp r2, r3 bc6: dcd6 bgt.n b76 <_usb_d_dev_ep_init+0x4e> ept->cache = (uint8_t *)(dir ? pcfg->i_cache : pcfg->cache); bc8: 2f00 cmp r7, #0 bca: dbdf blt.n b8c <_usb_d_dev_ep_init+0x64> bcc: 230c movs r3, #12 bce: 435c muls r4, r3 bd0: 4b06 ldr r3, [pc, #24] ; (bec <_usb_d_dev_ep_init+0xc4>) bd2: 58e3 ldr r3, [r4, r3] bd4: e7df b.n b96 <_usb_d_dev_ep_init+0x6e> return -USB_ERR_PARAM; bd6: 2012 movs r0, #18 return -USB_ERR_FUNC; bd8: 4240 negs r0, r0 bda: e7e4 b.n ba6 <_usb_d_dev_ep_init+0x7e> return -USB_ERR_REDO; bdc: 2014 movs r0, #20 bde: e7fb b.n bd8 <_usb_d_dev_ep_init+0xb0> if ((dir ? pcfg->i_cache : pcfg->cache) && ((dir ? pcfg->i_size : pcfg->size) < max_pkt_siz)) { be0: 2f00 cmp r7, #0 be2: dae7 bge.n bb4 <_usb_d_dev_ep_init+0x8c> be4: e7cb b.n b7e <_usb_d_dev_ep_init+0x56> be6: 46c0 nop ; (mov r8, r8) be8: 0000043d .word 0x0000043d bec: 00002378 .word 0x00002378 00000bf0 <_usb_d_dev_ep_deinit>: { bf0: b5f7 push {r0, r1, r2, r4, r5, r6, r7, lr} uint8_t epn = USB_EP_GET_N(ep); bf2: 250f movs r5, #15 { bf4: 0004 movs r4, r0 uint8_t epn = USB_EP_GET_N(ep); bf6: 4005 ands r5, r0 if (epn > CONF_USB_D_MAX_EP_N || !_usb_d_dev_ep_is_used(ept)) { bf8: 2d02 cmp r5, #2 bfa: d81a bhi.n c32 <_usb_d_dev_ep_deinit+0x42> bfc: b243 sxtb r3, r0 bool dir = USB_EP_GET_DIR(ep); bfe: 09c7 lsrs r7, r0, #7 c00: 9301 str r3, [sp, #4] struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); c02: 0039 movs r1, r7 c04: 4b14 ldr r3, [pc, #80] ; (c58 <_usb_d_dev_ep_deinit+0x68>) c06: 0028 movs r0, r5 c08: 4798 blx r3 if (epn > CONF_USB_D_MAX_EP_N || !_usb_d_dev_ep_is_used(ept)) { c0a: 7c83 ldrb r3, [r0, #18] struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); c0c: 0006 movs r6, r0 if (epn > CONF_USB_D_MAX_EP_N || !_usb_d_dev_ep_is_used(ept)) { c0e: 2bff cmp r3, #255 ; 0xff c10: d00f beq.n c32 <_usb_d_dev_ep_deinit+0x42> _usb_d_dev_trans_stop(ept, dir, USB_TRANS_RESET); c12: 2203 movs r2, #3 c14: 4b11 ldr r3, [pc, #68] ; (c5c <_usb_d_dev_ep_deinit+0x6c>) c16: 0039 movs r1, r7 c18: 4798 blx r3 if (_usb_d_dev_ep_is_ctrl(ept)) { c1a: 2207 movs r2, #7 c1c: 7cf3 ldrb r3, [r6, #19] c1e: 4013 ands r3, r2 c20: 2b01 cmp r3, #1 c22: d107 bne.n c34 <_usb_d_dev_ep_deinit+0x44> hw->DEVICE.DeviceEndpoint[ep].EPCFG.reg = 0; c24: 2200 movs r2, #0 c26: 4b0e ldr r3, [pc, #56] ; (c60 <_usb_d_dev_ep_deinit+0x70>) c28: 3408 adds r4, #8 c2a: 0164 lsls r4, r4, #5 c2c: 54e2 strb r2, [r4, r3] ept->ep = 0xFF; c2e: 23ff movs r3, #255 ; 0xff c30: 8273 strh r3, [r6, #18] } c32: bdf7 pop {r0, r1, r2, r4, r5, r6, r7, pc} } else if (USB_EP_GET_DIR(ep)) { c34: b263 sxtb r3, r4 c36: 2b00 cmp r3, #0 c38: da07 bge.n c4a <_usb_d_dev_ep_deinit+0x5a> hw->DEVICE.DeviceEndpoint[USB_EP_GET_N(ep)].EPCFG.reg &= ~USB_DEVICE_EPCFG_EPTYPE1_Msk; c3a: 2270 movs r2, #112 ; 0x70 c3c: 4b09 ldr r3, [pc, #36] ; (c64 <_usb_d_dev_ep_deinit+0x74>) c3e: 016d lsls r5, r5, #5 c40: 18ed adds r5, r5, r3 c42: 786b ldrb r3, [r5, #1] c44: 4393 bics r3, r2 c46: 706b strb r3, [r5, #1] c48: e7f1 b.n c2e <_usb_d_dev_ep_deinit+0x3e> hw->DEVICE.DeviceEndpoint[ep].EPCFG.reg &= ~USB_DEVICE_EPCFG_EPTYPE0_Msk; c4a: 4b06 ldr r3, [pc, #24] ; (c64 <_usb_d_dev_ep_deinit+0x74>) c4c: 0164 lsls r4, r4, #5 c4e: 18e4 adds r4, r4, r3 c50: 7863 ldrb r3, [r4, #1] c52: 4393 bics r3, r2 c54: 7063 strb r3, [r4, #1] c56: e7ea b.n c2e <_usb_d_dev_ep_deinit+0x3e> c58: 0000043d .word 0x0000043d c5c: 00000525 .word 0x00000525 c60: 41005000 .word 0x41005000 c64: 410050ff .word 0x410050ff 00000c68 <_usb_d_dev_ep_enable>: { c68: b5f7 push {r0, r1, r2, r4, r5, r6, r7, lr} uint8_t epn = USB_EP_GET_N(ep); c6a: 240f movs r4, #15 c6c: 4004 ands r4, r0 struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); c6e: 09c1 lsrs r1, r0, #7 c70: 4b47 ldr r3, [pc, #284] ; (d90 <_usb_d_dev_ep_enable+0x128>) c72: b245 sxtb r5, r0 c74: 0020 movs r0, r4 c76: 4798 blx r3 return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg; c78: 4b46 ldr r3, [pc, #280] ; (d94 <_usb_d_dev_ep_enable+0x12c>) c7a: 0161 lsls r1, r4, #5 c7c: 18ce adds r6, r1, r3 c7e: 7872 ldrb r2, [r6, #1] c80: 0007 movs r7, r0 c82: b2d2 uxtb r2, r2 if (epn > CONF_USB_D_MAX_EP_N || !_usb_d_dev_ep_is_used(ept)) { c84: 2c02 cmp r4, #2 c86: d900 bls.n c8a <_usb_d_dev_ep_enable+0x22> c88: e07d b.n d86 <_usb_d_dev_ep_enable+0x11e> c8a: 7c83 ldrb r3, [r0, #18] c8c: 9301 str r3, [sp, #4] c8e: 2bff cmp r3, #255 ; 0xff c90: d100 bne.n c94 <_usb_d_dev_ep_enable+0x2c> c92: e078 b.n d86 <_usb_d_dev_ep_enable+0x11e> bank = prvt_inst.desc_table[epn].DeviceDescBank; c94: 4b40 ldr r3, [pc, #256] ; (d98 <_usb_d_dev_ep_enable+0x130>) c96: 185c adds r4, r3, r1 if (ept->flags.bits.eptype == USB_D_EPTYPE_CTRL) { c98: 7cc3 ldrb r3, [r0, #19] c9a: 2107 movs r1, #7 c9c: 0018 movs r0, r3 c9e: 4008 ands r0, r1 ca0: 2801 cmp r0, #1 ca2: d13b bne.n d1c <_usb_d_dev_ep_enable+0xb4> if (epcfg & (USB_DEVICE_EPCFG_EPTYPE1_Msk | USB_DEVICE_EPCFG_EPTYPE0_Msk)) { ca4: 2377 movs r3, #119 ; 0x77 ca6: 0011 movs r1, r2 ca8: 4019 ands r1, r3 caa: 9100 str r1, [sp, #0] cac: 421a tst r2, r3 cae: d000 beq.n cb2 <_usb_d_dev_ep_enable+0x4a> cb0: e06c b.n d8c <_usb_d_dev_ep_enable+0x124> ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg = data; cb2: 3b66 subs r3, #102 ; 0x66 cb4: 7073 strb r3, [r6, #1] bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size) cb6: 8a3d ldrh r5, [r7, #16] | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size)); cb8: 4b38 ldr r3, [pc, #224] ; (d9c <_usb_d_dev_ep_enable+0x134>) cba: 0028 movs r0, r5 cbc: 4798 blx r3 cbe: 23e0 movs r3, #224 ; 0xe0 bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size) cc0: 4a37 ldr r2, [pc, #220] ; (da0 <_usb_d_dev_ep_enable+0x138>) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size)); cc2: 05db lsls r3, r3, #23 cc4: 0700 lsls r0, r0, #28 cc6: 4018 ands r0, r3 bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size) cc8: 03ab lsls r3, r5, #14 cca: 4013 ands r3, r2 | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size)); ccc: 4303 orrs r3, r0 bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size) cce: 6063 str r3, [r4, #4] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask; cd0: 2140 movs r1, #64 ; 0x40 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask; cd2: 2380 movs r3, #128 ; 0x80 uint8_t epn = USB_EP_GET_N(ept->ep); cd4: 220f movs r2, #15 = USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size)); cd6: 04ad lsls r5, r5, #18 cd8: 0cad lsrs r5, r5, #18 cda: 4328 orrs r0, r5 cdc: 6160 str r0, [r4, #20] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask; cde: 71b1 strb r1, [r6, #6] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask; ce0: 7173 strb r3, [r6, #5] bank->STATUS_BK.reg = 0; ce2: 9b00 ldr r3, [sp, #0] bank->ADDR.reg = addr; ce4: 482c ldr r0, [pc, #176] ; (d98 <_usb_d_dev_ep_enable+0x130>) bank->STATUS_BK.reg = 0; ce6: 72a3 strb r3, [r4, #10] ce8: 76a3 strb r3, [r4, #26] uint8_t epn = USB_EP_GET_N(ept->ep); cea: 9b01 ldr r3, [sp, #4] bank->PCKSIZE.bit.MULTI_PACKET_SIZE = size; cec: 03ac lsls r4, r5, #14 uint8_t epn = USB_EP_GET_N(ept->ep); cee: 4013 ands r3, r2 _usbd_ep_set_buf(epn, 0, (uint32_t)ept->cache); cf0: 68fa ldr r2, [r7, #12] bank->ADDR.reg = addr; cf2: 015b lsls r3, r3, #5 cf4: 501a str r2, [r3, r0] bank->PCKSIZE.bit.MULTI_PACKET_SIZE = size; cf6: 18c0 adds r0, r0, r3 cf8: 6842 ldr r2, [r0, #4] cfa: 4d2a ldr r5, [pc, #168] ; (da4 <_usb_d_dev_ep_enable+0x13c>) cfc: 4015 ands r5, r2 cfe: 4325 orrs r5, r4 d00: 6045 str r5, [r0, #4] bank->PCKSIZE.bit.BYTE_COUNT = count; d02: 6842 ldr r2, [r0, #4] d04: 0b92 lsrs r2, r2, #14 d06: 0392 lsls r2, r2, #14 d08: 6042 str r2, [r0, #4] d0a: 4a22 ldr r2, [pc, #136] ; (d94 <_usb_d_dev_ep_enable+0x12c>) return USB_OK; d0c: 9800 ldr r0, [sp, #0] d0e: 189b adds r3, r3, r2 d10: 22b0 movs r2, #176 ; 0xb0 d12: 715a strb r2, [r3, #5] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENSET.reg = mask; d14: 3aa0 subs r2, #160 ; 0xa0 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask; d16: 7199 strb r1, [r3, #6] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENSET.reg = mask; d18: 729a strb r2, [r3, #10] } d1a: bdfe pop {r1, r2, r3, r4, r5, r6, r7, pc} } else if (dir) { d1c: 2d00 cmp r5, #0 d1e: da19 bge.n d54 <_usb_d_dev_ep_enable+0xec> if (epcfg & USB_DEVICE_EPCFG_EPTYPE1_Msk) { d20: 2170 movs r1, #112 ; 0x70 d22: 0015 movs r5, r2 d24: 400d ands r5, r1 d26: 420a tst r2, r1 d28: d130 bne.n d8c <_usb_d_dev_ep_enable+0x124> epcfg |= USB_DEVICE_EPCFG_EPTYPE1(ept->flags.bits.eptype); d2a: 075b lsls r3, r3, #29 d2c: 0e5b lsrs r3, r3, #25 d2e: 4313 orrs r3, r2 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg = data; d30: 7073 strb r3, [r6, #1] = USB_DEVICE_PCKSIZE_BYTE_COUNT(ept->size) | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size)); d32: 8a3f ldrh r7, [r7, #16] d34: 4b19 ldr r3, [pc, #100] ; (d9c <_usb_d_dev_ep_enable+0x134>) d36: 0038 movs r0, r7 d38: 4798 blx r3 d3a: 23e0 movs r3, #224 ; 0xe0 d3c: 0700 lsls r0, r0, #28 d3e: 05db lsls r3, r3, #23 d40: 4018 ands r0, r3 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask; d42: 2380 movs r3, #128 ; 0x80 d44: 04bf lsls r7, r7, #18 d46: 0cbf lsrs r7, r7, #18 d48: 4338 orrs r0, r7 d4a: 6160 str r0, [r4, #20] d4c: 7173 strb r3, [r6, #5] bank->STATUS_BK.reg = 0; d4e: 76a5 strb r5, [r4, #26] return USB_OK; d50: 0028 movs r0, r5 } d52: e7e2 b.n d1a <_usb_d_dev_ep_enable+0xb2> if (epcfg & USB_DEVICE_EPCFG_EPTYPE0_Msk) { d54: 0015 movs r5, r2 d56: 400d ands r5, r1 d58: 420a tst r2, r1 d5a: d117 bne.n d8c <_usb_d_dev_ep_enable+0x124> epcfg |= USB_DEVICE_EPCFG_EPTYPE0(ept->flags.bits.eptype); d5c: 075b lsls r3, r3, #29 d5e: 0f5b lsrs r3, r3, #29 d60: 4313 orrs r3, r2 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg = data; d62: 7073 strb r3, [r6, #1] bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size) d64: 8a3f ldrh r7, [r7, #16] | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size)); d66: 4b0d ldr r3, [pc, #52] ; (d9c <_usb_d_dev_ep_enable+0x134>) d68: 0038 movs r0, r7 d6a: 4798 blx r3 bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size) d6c: 4a0c ldr r2, [pc, #48] ; (da0 <_usb_d_dev_ep_enable+0x138>) d6e: 03bb lsls r3, r7, #14 d70: 4013 ands r3, r2 | USB_DEVICE_PCKSIZE_SIZE(_usbd_ep_pcksize_size(ept->size)); d72: 22e0 movs r2, #224 ; 0xe0 d74: 0700 lsls r0, r0, #28 d76: 05d2 lsls r2, r2, #23 d78: 4010 ands r0, r2 d7a: 4303 orrs r3, r0 bank[0].PCKSIZE.reg = USB_DEVICE_PCKSIZE_MULTI_PACKET_SIZE(ept->size) d7c: 6063 str r3, [r4, #4] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSSET.reg = mask; d7e: 2340 movs r3, #64 ; 0x40 d80: 71b3 strb r3, [r6, #6] bank->STATUS_BK.reg = 0; d82: 72a5 strb r5, [r4, #10] d84: e7e4 b.n d50 <_usb_d_dev_ep_enable+0xe8> return -USB_ERR_PARAM; d86: 2012 movs r0, #18 return -USB_ERR_REDO; d88: 4240 negs r0, r0 d8a: e7c6 b.n d1a <_usb_d_dev_ep_enable+0xb2> d8c: 2014 movs r0, #20 d8e: e7fb b.n d88 <_usb_d_dev_ep_enable+0x120> d90: 0000043d .word 0x0000043d d94: 410050ff .word 0x410050ff d98: 200000a8 .word 0x200000a8 d9c: 000009c5 .word 0x000009c5 da0: 0fffc000 .word 0x0fffc000 da4: f0003fff .word 0xf0003fff 00000da8 <_usb_d_dev_ep_stall>: { da8: b5f8 push {r3, r4, r5, r6, r7, lr} uint8_t epn = USB_EP_GET_N(ep); daa: 0007 movs r7, r0 dac: 260f movs r6, #15 bool dir = USB_EP_GET_DIR(ep); dae: 09c4 lsrs r4, r0, #7 uint8_t epn = USB_EP_GET_N(ep); db0: 4037 ands r7, r6 { db2: 000d movs r5, r1 struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); db4: 0038 movs r0, r7 db6: 0021 movs r1, r4 db8: 4b29 ldr r3, [pc, #164] ; (e60 <_usb_d_dev_ep_stall+0xb8>) dba: 4798 blx r3 dbc: 0002 movs r2, r0 if (epn > CONF_USB_D_MAX_EP_N) { dbe: 2f02 cmp r7, #2 dc0: d84a bhi.n e58 <_usb_d_dev_ep_stall+0xb0> uint8_t epn = USB_EP_GET_N(ept->ep); dc2: 7c83 ldrb r3, [r0, #18] hri_usbendpoint_set_EPSTATUS_reg(USB, epn, (USB_DEVICE_EPSTATUS_STALLRQ0 << bank_n)); dc4: 2010 movs r0, #16 uint8_t epn = USB_EP_GET_N(ept->ep); dc6: 4033 ands r3, r6 hri_usbendpoint_set_EPSTATUS_reg(USB, epn, (USB_DEVICE_EPSTATUS_STALLRQ0 << bank_n)); dc8: 40a0 lsls r0, r4 if (USB_EP_STALL_SET == ctrl) { dca: 2d01 cmp r5, #1 dcc: d110 bne.n df0 <_usb_d_dev_ep_stall+0x48> dce: 4d25 ldr r5, [pc, #148] ; (e64 <_usb_d_dev_ep_stall+0xbc>) dd0: 0159 lsls r1, r3, #5 hri_usbendpoint_set_EPSTATUS_reg(USB, epn, (USB_DEVICE_EPSTATUS_STALLRQ0 << bank_n)); dd2: b2c0 uxtb r0, r0 dd4: 1949 adds r1, r1, r5 dd6: 7148 strb r0, [r1, #5] _usbd_ep_int_en(epn, USB_DEVICE_EPINTFLAG_STALL0 << dir); dd8: 2120 movs r1, #32 dda: 40a1 lsls r1, r4 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENSET.reg = mask; ddc: 4822 ldr r0, [pc, #136] ; (e68 <_usb_d_dev_ep_stall+0xc0>) dde: 015b lsls r3, r3, #5 hri_usbendpoint_set_EPINTEN_reg(USB, epn, flags); de0: b2c9 uxtb r1, r1 de2: 181b adds r3, r3, r0 de4: 7299 strb r1, [r3, #10] ept->flags.bits.is_stalled = 1; de6: 2308 movs r3, #8 de8: 7cd1 ldrb r1, [r2, #19] dea: 430b orrs r3, r1 ept->flags.bits.is_stalled = 0; dec: 74d3 strb r3, [r2, #19] dee: e009 b.n e04 <_usb_d_dev_ep_stall+0x5c> } else if (USB_EP_STALL_CLR == ctrl) { df0: 015b lsls r3, r3, #5 df2: 2d00 cmp r5, #0 df4: d129 bne.n e4a <_usb_d_dev_ep_stall+0xa2> return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUS.reg; df6: 491d ldr r1, [pc, #116] ; (e6c <_usb_d_dev_ep_stall+0xc4>) df8: 185d adds r5, r3, r1 dfa: 491b ldr r1, [pc, #108] ; (e68 <_usb_d_dev_ep_stall+0xc0>) dfc: 185b adds r3, r3, r1 dfe: 79d9 ldrb r1, [r3, #7] if (!is_stalled) { e00: 4208 tst r0, r1 e02: d101 bne.n e08 <_usb_d_dev_ep_stall+0x60> rc = _usb_d_dev_ep_stall_clr(ept, dir); e04: 2000 movs r0, #0 e06: e01c b.n e42 <_usb_d_dev_ep_stall+0x9a> _usbd_ep_int_dis(epn, USB_DEVICE_EPINTFLAG_STALL0 << dir); e08: 2120 movs r1, #32 e0a: 40a1 lsls r1, r4 hri_usbendpoint_clear_EPSTATUS_reg(USB, epn, (USB_DEVICE_EPSTATUS_STALLRQ0 << bank_n)); e0c: b2c0 uxtb r0, r0 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask; e0e: 7158 strb r0, [r3, #5] hri_usbendpoint_clear_EPINTEN_reg(USB, epn, flags); e10: b2c8 uxtb r0, r1 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTENCLR.reg = mask; e12: 7258 strb r0, [r3, #9] return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg; e14: 7a1e ldrb r6, [r3, #8] if (_usbd_ep_is_stall_sent(epn, dir)) { e16: 4231 tst r1, r6 e18: d004 beq.n e24 <_usb_d_dev_ep_stall+0x7c> hri_usbendpoint_clear_EPSTATUS_reg(USB, epn, (USB_DEVICE_EPSTATUS_DTGLOUT << bank_n)); e1a: 2101 movs r1, #1 e1c: 40a1 lsls r1, r4 e1e: b2c9 uxtb r1, r1 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; e20: 7218 strb r0, [r3, #8] ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUSCLR.reg = mask; e22: 7159 strb r1, [r3, #5] if (_usb_d_dev_ep_is_ctrl(ept)) { e24: 2107 movs r1, #7 e26: 7cd3 ldrb r3, [r2, #19] e28: 4019 ands r1, r3 e2a: 2901 cmp r1, #1 e2c: d10a bne.n e44 <_usb_d_dev_ep_stall+0x9c> return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPSTATUS.reg; e2e: 35ff adds r5, #255 ; 0xff e30: 79ec ldrb r4, [r5, #7] if ((hri_usbendpoint_read_EPSTATUS_reg(USB, epn) & USB_DEVICE_EPSTATUS_STALLRQ_Msk) == 0) { e32: 312f adds r1, #47 ; 0x2f e34: 0020 movs r0, r4 e36: 4008 ands r0, r1 e38: 420c tst r4, r1 e3a: d1e3 bne.n e04 <_usb_d_dev_ep_stall+0x5c> ept->flags.bits.is_stalled = 0; e3c: 3928 subs r1, #40 ; 0x28 e3e: 438b bics r3, r1 e40: 74d3 strb r3, [r2, #19] } e42: bdf8 pop {r3, r4, r5, r6, r7, pc} ept->flags.bits.is_stalled = 0; e44: 2108 movs r1, #8 e46: 438b bics r3, r1 e48: e7d0 b.n dec <_usb_d_dev_ep_stall+0x44> e4a: 4a06 ldr r2, [pc, #24] ; (e64 <_usb_d_dev_ep_stall+0xbc>) e4c: 189b adds r3, r3, r2 e4e: 799b ldrb r3, [r3, #6] return (hri_usbendpoint_read_EPSTATUS_reg(hw, epn) & (USB_DEVICE_EPSTATUS_STALLRQ0 << bank_n)); e50: 4018 ands r0, r3 return _usbd_ep_is_stalled(epn, dir); e52: 1e43 subs r3, r0, #1 e54: 4198 sbcs r0, r3 e56: e7f4 b.n e42 <_usb_d_dev_ep_stall+0x9a> return -USB_ERR_PARAM; e58: 2012 movs r0, #18 e5a: 4240 negs r0, r0 e5c: e7f1 b.n e42 <_usb_d_dev_ep_stall+0x9a> e5e: 46c0 nop ; (mov r8, r8) e60: 0000043d .word 0x0000043d e64: 41005100 .word 0x41005100 e68: 410050ff .word 0x410050ff e6c: 41005000 .word 0x41005000 00000e70 <_usb_d_dev_ep_read_req>: int32_t _usb_d_dev_ep_read_req(const uint8_t ep, uint8_t *req_buf) { e70: b5f8 push {r3, r4, r5, r6, r7, lr} uint8_t epn = USB_EP_GET_N(ep); e72: 230f movs r3, #15 e74: 4018 ands r0, r3 UsbDeviceDescBank *bank = prvt_inst.desc_table[epn].DeviceDescBank; e76: 4b11 ldr r3, [pc, #68] ; (ebc <_usb_d_dev_ep_read_req+0x4c>) e78: 0144 lsls r4, r0, #5 e7a: 191b adds r3, r3, r4 { e7c: 000f movs r7, r1 uint32_t addr = bank[0].ADDR.reg; e7e: 6819 ldr r1, [r3, #0] uint16_t bytes = bank[0].PCKSIZE.bit.BYTE_COUNT; e80: 685d ldr r5, [r3, #4] e82: 04ad lsls r5, r5, #18 e84: 0cad lsrs r5, r5, #18 if (epn > CONF_USB_D_MAX_EP_N || !req_buf) { e86: 2802 cmp r0, #2 e88: d812 bhi.n eb0 <_usb_d_dev_ep_read_req+0x40> e8a: 2f00 cmp r7, #0 e8c: d010 beq.n eb0 <_usb_d_dev_ep_read_req+0x40> return ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg; e8e: 4b0c ldr r3, [pc, #48] ; (ec0 <_usb_d_dev_ep_read_req+0x50>) e90: 18e4 adds r4, r4, r3 e92: 7863 ldrb r3, [r4, #1] return -USB_ERR_PARAM; } if (!_usbd_ep_is_ctrl(epn)) { e94: 2b11 cmp r3, #17 e96: d10e bne.n eb6 <_usb_d_dev_ep_read_req+0x46> tmp &= mask; e98: 2610 movs r6, #16 tmp = ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg; e9a: 7a22 ldrb r2, [r4, #8] return -USB_ERR_FUNC; } if (!_usbd_ep_is_setup(epn)) { return ERR_NONE; e9c: 2000 movs r0, #0 if (!_usbd_ep_is_setup(epn)) { e9e: 4232 tst r2, r6 ea0: d005 beq.n eae <_usb_d_dev_ep_read_req+0x3e> } memcpy(req_buf, (void *)addr, 8); ea2: 2208 movs r2, #8 ea4: 0038 movs r0, r7 ea6: 4b07 ldr r3, [pc, #28] ; (ec4 <_usb_d_dev_ep_read_req+0x54>) ea8: 4798 blx r3 _usbd_ep_ack_setup(epn); return bytes; eaa: 0028 movs r0, r5 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPINTFLAG.reg = mask; eac: 7226 strb r6, [r4, #8] } eae: bdf8 pop {r3, r4, r5, r6, r7, pc} return -USB_ERR_PARAM; eb0: 2012 movs r0, #18 return -USB_ERR_FUNC; eb2: 4240 negs r0, r0 eb4: e7fb b.n eae <_usb_d_dev_ep_read_req+0x3e> eb6: 2013 movs r0, #19 eb8: e7fb b.n eb2 <_usb_d_dev_ep_read_req+0x42> eba: 46c0 nop ; (mov r8, r8) ebc: 200000a8 .word 0x200000a8 ec0: 410050ff .word 0x410050ff ec4: 00002355 .word 0x00002355 00000ec8 <_usb_d_dev_ep_trans>: int32_t _usb_d_dev_ep_trans(const struct usb_d_transfer *trans) { ec8: b5f0 push {r4, r5, r6, r7, lr} uint8_t epn = USB_EP_GET_N(trans->ep); eca: 250f movs r5, #15 ecc: 7a07 ldrb r7, [r0, #8] { ece: b087 sub sp, #28 ed0: b27b sxtb r3, r7 uint8_t epn = USB_EP_GET_N(trans->ep); ed2: 403d ands r5, r7 bool dir = USB_EP_GET_DIR(trans->ep); ed4: 09ff lsrs r7, r7, #7 struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); ed6: 0039 movs r1, r7 ed8: 9302 str r3, [sp, #8] { eda: 0006 movs r6, r0 struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); edc: 4b3a ldr r3, [pc, #232] ; (fc8 <_usb_d_dev_ep_trans+0x100>) ede: 0028 movs r0, r5 ee0: 4798 blx r3 uint16_t size_mask = (ept->size == 1023) ? 1023 : (ept->size - 1); ee2: 493a ldr r1, [pc, #232] ; (fcc <_usb_d_dev_ep_trans+0x104>) ee4: 8a03 ldrh r3, [r0, #16] struct _usb_d_dev_ep *ept = _usb_d_dev_ept(epn, dir); ee6: 0004 movs r4, r0 uint16_t size_mask = (ept->size == 1023) ? 1023 : (ept->size - 1); ee8: 001a movs r2, r3 eea: 428b cmp r3, r1 eec: d001 beq.n ef2 <_usb_d_dev_ep_trans+0x2a> eee: 1e5a subs r2, r3, #1 ef0: b292 uxth r2, r2 bool size_n_aligned = (trans->size & size_mask); ef2: 6871 ldr r1, [r6, #4] ef4: 400a ands r2, r1 ef6: 9201 str r2, [sp, #4] bool use_cache = false; volatile hal_atomic_t flags; if (epn > CONF_USB_D_MAX_EP_N) { ef8: 2d02 cmp r5, #2 efa: d862 bhi.n fc2 <_usb_d_dev_ep_trans+0xfa> * 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)) efc: 2080 movs r0, #128 ; 0x80 efe: 6832 ldr r2, [r6, #0] f00: 0580 lsls r0, r0, #22 f02: 4282 cmp r2, r0 f04: d30d bcc.n f22 <_usb_d_dev_ep_trans+0x5a> f06: 4d32 ldr r5, [pc, #200] ; (fd0 <_usb_d_dev_ep_trans+0x108>) f08: 1888 adds r0, r1, r2 f0a: 42a8 cmp r0, r5 f0c: d809 bhi.n f22 <_usb_d_dev_ep_trans+0x5a> f0e: 2003 movs r0, #3 f10: 0015 movs r5, r2 f12: 4005 ands r5, r0 f14: 4202 tst r2, r0 f16: d104 bne.n f22 <_usb_d_dev_ep_trans+0x5a> || (!dir && (trans->size < ept->size))) { f18: 9a02 ldr r2, [sp, #8] f1a: 2a00 cmp r2, #0 f1c: db0e blt.n f3c <_usb_d_dev_ep_trans+0x74> f1e: 4299 cmp r1, r3 f20: d206 bcs.n f30 <_usb_d_dev_ep_trans+0x68> if (!ept->cache) { f22: 68e3 ldr r3, [r4, #12] return -USB_ERR_FUNC; } /* Use cache all the time. */ use_cache = true; f24: 2501 movs r5, #1 if (!ept->cache) { f26: 2b00 cmp r3, #0 f28: d108 bne.n f3c <_usb_d_dev_ep_trans+0x74> return -USB_ERR_FUNC; f2a: 2013 movs r0, #19 return -USB_ERR_PARAM; f2c: 4240 negs r0, r0 f2e: e017 b.n f60 <_usb_d_dev_ep_trans+0x98> } if (!dir && size_n_aligned) { f30: 9b01 ldr r3, [sp, #4] f32: 2b00 cmp r3, #0 f34: d016 beq.n f64 <_usb_d_dev_ep_trans+0x9c> if (!ept->cache) { f36: 68e3 ldr r3, [r4, #12] f38: 2b00 cmp r3, #0 f3a: d042 beq.n fc2 <_usb_d_dev_ep_trans+0xfa> } /* Set 'use_cache' on last packet. */ } /* Check halt */ if (ept->flags.bits.is_stalled) { f3c: 7ce3 ldrb r3, [r4, #19] return USB_HALTED; f3e: 2002 movs r0, #2 if (ept->flags.bits.is_stalled) { f40: 071b lsls r3, r3, #28 f42: d40d bmi.n f60 <_usb_d_dev_ep_trans+0x98> } /* Try to start transactions. */ atomic_enter_critical(&flags); f44: 4b23 ldr r3, [pc, #140] ; (fd4 <_usb_d_dev_ep_trans+0x10c>) f46: a805 add r0, sp, #20 f48: 4798 blx r3 if (_usb_d_dev_ep_is_busy(ept)) { f4a: 7ce1 ldrb r1, [r4, #19] f4c: 2340 movs r3, #64 ; 0x40 f4e: 000a movs r2, r1 f50: 401a ands r2, r3 f52: 9203 str r2, [sp, #12] f54: 4a20 ldr r2, [pc, #128] ; (fd8 <_usb_d_dev_ep_trans+0x110>) f56: 4219 tst r1, r3 f58: d006 beq.n f68 <_usb_d_dev_ep_trans+0xa0> atomic_leave_critical(&flags); f5a: a805 add r0, sp, #20 f5c: 4790 blx r2 return USB_BUSY; f5e: 2001 movs r0, #1 } else { _usb_d_dev_out_next(ept, false); } return ERR_NONE; } f60: b007 add sp, #28 f62: bdf0 pop {r4, r5, r6, r7, pc} bool use_cache = false; f64: 9d01 ldr r5, [sp, #4] f66: e7e9 b.n f3c <_usb_d_dev_ep_trans+0x74> ept->flags.bits.is_busy = 1; f68: 430b orrs r3, r1 f6a: 74e3 strb r3, [r4, #19] atomic_leave_critical(&flags); f6c: a805 add r0, sp, #20 f6e: 4790 blx r2 ept->flags.bits.dir = dir; f70: 217f movs r1, #127 ; 0x7f ept->trans_buf = trans->buf; f72: 6833 ldr r3, [r6, #0] ept->flags.bits.dir = dir; f74: 01fa lsls r2, r7, #7 ept->trans_buf = trans->buf; f76: 6023 str r3, [r4, #0] ept->trans_size = trans->size; f78: 6873 ldr r3, [r6, #4] ept->flags.bits.need_zlp = (trans->zlp && (!size_n_aligned)); f7a: 9f03 ldr r7, [sp, #12] ept->trans_size = trans->size; f7c: 6063 str r3, [r4, #4] ept->trans_count = 0; f7e: 9b03 ldr r3, [sp, #12] f80: 60a3 str r3, [r4, #8] ept->flags.bits.dir = dir; f82: 7ce3 ldrb r3, [r4, #19] f84: 400b ands r3, r1 ept->flags.bits.use_cache = use_cache; f86: 4313 orrs r3, r2 f88: 0169 lsls r1, r5, #5 f8a: 001d movs r5, r3 f8c: 2320 movs r3, #32 f8e: 439d bics r5, r3 f90: 430d orrs r5, r1 f92: 74e5 strb r5, [r4, #19] ept->flags.bits.need_zlp = (trans->zlp && (!size_n_aligned)); f94: 7a73 ldrb r3, [r6, #9] f96: 2b00 cmp r3, #0 f98: d002 beq.n fa0 <_usb_d_dev_ep_trans+0xd8> f9a: 9f01 ldr r7, [sp, #4] f9c: 427b negs r3, r7 f9e: 415f adcs r7, r3 fa0: 2210 movs r2, #16 fa2: 7ce3 ldrb r3, [r4, #19] fa4: 013f lsls r7, r7, #4 fa6: 4393 bics r3, r2 fa8: 431f orrs r7, r3 if (dir) { faa: 9b02 ldr r3, [sp, #8] _usb_d_dev_in_next(ept, false); fac: 2100 movs r1, #0 fae: 0020 movs r0, r4 ept->flags.bits.need_zlp = (trans->zlp && (!size_n_aligned)); fb0: 74e7 strb r7, [r4, #19] if (dir) { fb2: 2b00 cmp r3, #0 fb4: da03 bge.n fbe <_usb_d_dev_ep_trans+0xf6> _usb_d_dev_in_next(ept, false); fb6: 4b09 ldr r3, [pc, #36] ; (fdc <_usb_d_dev_ep_trans+0x114>) _usb_d_dev_out_next(ept, false); fb8: 4798 blx r3 return ERR_NONE; fba: 2000 movs r0, #0 fbc: e7d0 b.n f60 <_usb_d_dev_ep_trans+0x98> _usb_d_dev_out_next(ept, false); fbe: 4b08 ldr r3, [pc, #32] ; (fe0 <_usb_d_dev_ep_trans+0x118>) fc0: e7fa b.n fb8 <_usb_d_dev_ep_trans+0xf0> return -USB_ERR_PARAM; fc2: 2012 movs r0, #18 fc4: e7b2 b.n f2c <_usb_d_dev_ep_trans+0x64> fc6: 46c0 nop ; (mov r8, r8) fc8: 0000043d .word 0x0000043d fcc: 000003ff .word 0x000003ff fd0: 20007fff .word 0x20007fff fd4: 000022c9 .word 0x000022c9 fd8: 000022d7 .word 0x000022d7 fdc: 000006a9 .word 0x000006a9 fe0: 0000080d .word 0x0000080d 00000fe4 <_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; fe4: 2900 cmp r1, #0 fe6: d100 bne.n fea <_usb_d_dev_register_callback+0x6> fe8: 4905 ldr r1, [pc, #20] ; (1000 <_usb_d_dev_register_callback+0x1c>) if (type == USB_D_CB_EVENT) { fea: 2801 cmp r0, #1 fec: d102 bne.n ff4 <_usb_d_dev_register_callback+0x10> dev_inst.callbacks.event = (_usb_d_dev_event_cb_t)f; fee: 4b05 ldr r3, [pc, #20] ; (1004 <_usb_d_dev_register_callback+0x20>) ff0: 6059 str r1, [r3, #4] } else if (type == USB_D_CB_SOF) { dev_inst.callbacks.sof = (_usb_d_dev_sof_cb_t)f; } } ff2: 4770 bx lr } else if (type == USB_D_CB_SOF) { ff4: 2800 cmp r0, #0 ff6: d1fc bne.n ff2 <_usb_d_dev_register_callback+0xe> dev_inst.callbacks.sof = (_usb_d_dev_sof_cb_t)f; ff8: 4b02 ldr r3, [pc, #8] ; (1004 <_usb_d_dev_register_callback+0x20>) ffa: 6019 str r1, [r3, #0] } ffc: e7f9 b.n ff2 <_usb_d_dev_register_callback+0xe> ffe: 46c0 nop ; (mov r8, r8) 1000: 00000415 .word 0x00000415 1004: 20000108 .word 0x20000108 00001008 <_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; 1008: 2900 cmp r1, #0 100a: d100 bne.n 100e <_usb_d_dev_register_ep_callback+0x6> 100c: 4907 ldr r1, [pc, #28] ; (102c <_usb_d_dev_register_ep_callback+0x24>) if (type == USB_D_DEV_EP_CB_SETUP) { 100e: 2800 cmp r0, #0 1010: d102 bne.n 1018 <_usb_d_dev_register_ep_callback+0x10> dev_inst.ep_callbacks.setup = (_usb_d_dev_ep_cb_setup_t)f; 1012: 4b07 ldr r3, [pc, #28] ; (1030 <_usb_d_dev_register_ep_callback+0x28>) 1014: 6099 str r1, [r3, #8] } else if (type == USB_D_DEV_EP_CB_MORE) { dev_inst.ep_callbacks.more = (_usb_d_dev_ep_cb_more_t)f; } else if (type == USB_D_DEV_EP_CB_DONE) { dev_inst.ep_callbacks.done = (_usb_d_dev_ep_cb_done_t)f; } } 1016: 4770 bx lr } else if (type == USB_D_DEV_EP_CB_MORE) { 1018: 2801 cmp r0, #1 101a: d102 bne.n 1022 <_usb_d_dev_register_ep_callback+0x1a> dev_inst.ep_callbacks.more = (_usb_d_dev_ep_cb_more_t)f; 101c: 4b04 ldr r3, [pc, #16] ; (1030 <_usb_d_dev_register_ep_callback+0x28>) 101e: 60d9 str r1, [r3, #12] 1020: e7f9 b.n 1016 <_usb_d_dev_register_ep_callback+0xe> } else if (type == USB_D_DEV_EP_CB_DONE) { 1022: 2802 cmp r0, #2 1024: d1f7 bne.n 1016 <_usb_d_dev_register_ep_callback+0xe> dev_inst.ep_callbacks.done = (_usb_d_dev_ep_cb_done_t)f; 1026: 4b02 ldr r3, [pc, #8] ; (1030 <_usb_d_dev_register_ep_callback+0x28>) 1028: 6119 str r1, [r3, #16] } 102a: e7f4 b.n 1016 <_usb_d_dev_register_ep_callback+0xe> 102c: 00000415 .word 0x00000415 1030: 20000108 .word 0x20000108 00001034 : /** * \brief USB interrupt handler */ void USB_Handler(void) { 1034: b5f7 push {r0, r1, r2, r4, r5, r6, r7, lr} uint16_t epint = hw->DEVICE.EPINTSMRY.reg; 1036: 4b6c ldr r3, [pc, #432] ; (11e8 ) 1038: 8c1a ldrh r2, [r3, #32] 103a: b291 uxth r1, r2 103c: 9101 str r1, [sp, #4] if (0 == epint) { 103e: 2a00 cmp r2, #0 1040: d000 beq.n 1044 1042: e066 b.n 1112 return ((Usb *)hw)->DEVICE.INTFLAG.reg; 1044: 8b9a ldrh r2, [r3, #28] return ((Usb *)hw)->DEVICE.INTENSET.reg; 1046: 8b19 ldrh r1, [r3, #24] if (flags & USB_DEVICE_INTFLAG_SOF) { 1048: 2004 movs r0, #4 flags &= hri_usbdevice_read_INTEN_reg(USB); 104a: 400a ands r2, r1 if (flags & USB_DEVICE_INTFLAG_SOF) { 104c: 0011 movs r1, r2 104e: 4001 ands r1, r0 1050: 4202 tst r2, r0 1052: d004 beq.n 105e ((Usb *)hw)->DEVICE.INTFLAG.reg = mask; 1054: 8398 strh r0, [r3, #28] dev_inst.callbacks.sof(); 1056: 4b65 ldr r3, [pc, #404] ; (11ec ) 1058: 681b ldr r3, [r3, #0] 105a: 4798 blx r3 _usb_d_dev_handler(); } 105c: bdf7 pop {r0, r1, r2, r4, r5, r6, r7, pc} if (flags & USB_DEVICE_INTFLAG_LPMSUSP) { 105e: 2480 movs r4, #128 ; 0x80 1060: 0016 movs r6, r2 1062: 00a4 lsls r4, r4, #2 1064: 4026 ands r6, r4 1066: 4222 tst r2, r4 1068: d01d beq.n 10a6 106a: 4a61 ldr r2, [pc, #388] ; (11f0 ) 106c: 839a strh r2, [r3, #28] ((Usb *)hw)->DEVICE.INTENCLR.reg = mask; 106e: 829a strh r2, [r3, #20] ((Usb *)hw)->DEVICE.INTENSET.reg = mask; 1070: 3a92 subs r2, #146 ; 0x92 1072: 3aff subs r2, #255 ; 0xff 1074: 831a strh r2, [r3, #24] if (bank->EXTREG.bit.SUBPID == 0x3) { 1076: 4b5f ldr r3, [pc, #380] ; (11f4 ) 1078: 891a ldrh r2, [r3, #8] 107a: 0712 lsls r2, r2, #28 107c: 0f12 lsrs r2, r2, #28 107e: 2a03 cmp r2, #3 1080: d005 beq.n 108e 1082: 8d1a ldrh r2, [r3, #40] ; 0x28 1084: 0712 lsls r2, r2, #28 1086: 0f12 lsrs r2, r2, #28 1088: 2a03 cmp r2, #3 108a: d107 bne.n 109c UsbDeviceDescBank *bank = &prvt_inst.desc_table[i].DeviceDescBank[0]; 108c: 2101 movs r1, #1 bank->EXTREG.reg = 0; 108e: 2200 movs r2, #0 lpm_variable = bank->EXTREG.bit.VARIABLE; 1090: 0149 lsls r1, r1, #5 1092: 185b adds r3, r3, r1 1094: 8919 ldrh r1, [r3, #8] bank->EXTREG.reg = 0; 1096: 811a strh r2, [r3, #8] lpm_variable = bank->EXTREG.bit.VARIABLE; 1098: 0449 lsls r1, r1, #17 109a: 0d49 lsrs r1, r1, #21 dev_inst.callbacks.event(USB_EV_LPM_SUSPEND, lpm_variable); 109c: 2003 movs r0, #3 109e: 4b53 ldr r3, [pc, #332] ; (11ec ) 10a0: 685b ldr r3, [r3, #4] dev_inst.callbacks.event(USB_EV_SUSPEND, 0); 10a2: 4798 blx r3 10a4: e7da b.n 105c } else if (flags & USB_DEVICE_INTFLAG_RAMACER) { 10a6: 2480 movs r4, #128 ; 0x80 10a8: 0015 movs r5, r2 10aa: 4025 ands r5, r4 10ac: 4222 tst r2, r4 10ae: d005 beq.n 10bc ((Usb *)hw)->DEVICE.INTFLAG.reg = mask; 10b0: 839c strh r4, [r3, #28] dev_inst.callbacks.event(USB_EV_ERROR, 0); 10b2: 4b4e ldr r3, [pc, #312] ; (11ec ) 10b4: 0031 movs r1, r6 10b6: 2005 movs r0, #5 10b8: 685b ldr r3, [r3, #4] 10ba: e7f2 b.n 10a2 } else if (flags & USB_D_WAKEUP_INT_FLAGS) { 10bc: 2670 movs r6, #112 ; 0x70 10be: 0014 movs r4, r2 10c0: 4034 ands r4, r6 10c2: 4232 tst r2, r6 10c4: d00a beq.n 10dc ((Usb *)hw)->DEVICE.INTENSET.reg = mask; 10c6: 4a4a ldr r2, [pc, #296] ; (11f0 ) ((Usb *)hw)->DEVICE.INTFLAG.reg = mask; 10c8: 839e strh r6, [r3, #28] ((Usb *)hw)->DEVICE.INTENCLR.reg = mask; 10ca: 829e strh r6, [r3, #20] ((Usb *)hw)->DEVICE.INTENSET.reg = mask; 10cc: 831a strh r2, [r3, #24] _usb_d_dev_wait_dfll_rdy(); 10ce: 4b4a ldr r3, [pc, #296] ; (11f8 ) 10d0: 4798 blx r3 dev_inst.callbacks.event(USB_EV_WAKEUP, 0); 10d2: 4b46 ldr r3, [pc, #280] ; (11ec ) 10d4: 0029 movs r1, r5 10d6: 2002 movs r0, #2 10d8: 685b ldr r3, [r3, #4] 10da: e7e2 b.n 10a2 } else if (flags & USB_DEVICE_INTFLAG_EORST) { 10dc: 2508 movs r5, #8 10de: 0011 movs r1, r2 10e0: 4029 ands r1, r5 10e2: 422a tst r2, r5 10e4: d00c beq.n 1100 ((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg = data; 10e6: 4a45 ldr r2, [pc, #276] ; (11fc ) 10e8: 7054 strb r4, [r2, #1] ((Usb *)hw)->DEVICE.INTENSET.reg = mask; 10ea: 4a41 ldr r2, [pc, #260] ; (11f0 ) ((Usb *)hw)->DEVICE.INTFLAG.reg = mask; 10ec: 839d strh r5, [r3, #28] ((Usb *)hw)->DEVICE.INTENCLR.reg = mask; 10ee: 829e strh r6, [r3, #20] ((Usb *)hw)->DEVICE.INTENSET.reg = mask; 10f0: 831a strh r2, [r3, #24] _usb_d_dev_reset_epts(); 10f2: 4b43 ldr r3, [pc, #268] ; (1200 ) 10f4: 4798 blx r3 dev_inst.callbacks.event(USB_EV_RESET, 0); 10f6: 4b3d ldr r3, [pc, #244] ; (11ec ) 10f8: 0021 movs r1, r4 10fa: 2001 movs r0, #1 10fc: 685b ldr r3, [r3, #4] 10fe: e7d0 b.n 10a2 } else if (flags & USB_DEVICE_INTFLAG_SUSPEND) { 1100: 07d2 lsls r2, r2, #31 1102: d506 bpl.n 1112 ((Usb *)hw)->DEVICE.INTFLAG.reg = mask; 1104: 4a3a ldr r2, [pc, #232] ; (11f0 ) 1106: 839a strh r2, [r3, #28] ((Usb *)hw)->DEVICE.INTENCLR.reg = mask; 1108: 829a strh r2, [r3, #20] ((Usb *)hw)->DEVICE.INTENSET.reg = mask; 110a: 831e strh r6, [r3, #24] dev_inst.callbacks.event(USB_EV_SUSPEND, 0); 110c: 4b37 ldr r3, [pc, #220] ; (11ec ) 110e: 685b ldr r3, [r3, #4] 1110: e7c7 b.n 10a2 uint32_t lpm_variable = 0; 1112: 2600 movs r6, #0 uint8_t epn = USB_EP_GET_N(ept->ep); 1114: 270f movs r7, #15 if (!(epint & (1u << epn))) { 1116: 2501 movs r5, #1 1118: 4c3a ldr r4, [pc, #232] ; (1204 ) if (ept->ep == 0xFF) { 111a: 7ca3 ldrb r3, [r4, #18] 111c: 2bff cmp r3, #255 ; 0xff 111e: d038 beq.n 1192 if (!(epint & (1u << epn))) { 1120: 002a movs r2, r5 1122: 403b ands r3, r7 1124: 409a lsls r2, r3 1126: 9901 ldr r1, [sp, #4] 1128: 4211 tst r1, r2 112a: d032 beq.n 1192 flags = hw->DEVICE.DeviceEndpoint[epn].EPINTFLAG.reg; 112c: 4936 ldr r1, [pc, #216] ; (1208 ) 112e: 015a lsls r2, r3, #5 1130: 1852 adds r2, r2, r1 mask = hw->DEVICE.DeviceEndpoint[epn].EPINTENSET.reg; 1132: 4932 ldr r1, [pc, #200] ; (11fc ) 1134: 015b lsls r3, r3, #5 1136: 185b adds r3, r3, r1 flags = hw->DEVICE.DeviceEndpoint[epn].EPINTFLAG.reg; 1138: 7812 ldrb r2, [r2, #0] mask = hw->DEVICE.DeviceEndpoint[epn].EPINTENSET.reg; 113a: 7a99 ldrb r1, [r3, #10] flags &= mask; 113c: 000b movs r3, r1 113e: 4013 ands r3, r2 if (flags) { 1140: 4211 tst r1, r2 1142: d026 beq.n 1192 if ((ept->flags.bits.eptype == 0x1) && !_usb_d_dev_ep_is_busy(ept)) { 1144: 2114 movs r1, #20 1146: 4371 muls r1, r6 1148: 4a28 ldr r2, [pc, #160] ; (11ec ) 114a: 1852 adds r2, r2, r1 114c: 2147 movs r1, #71 ; 0x47 114e: 3210 adds r2, #16 1150: 7dd2 ldrb r2, [r2, #23] 1152: 4011 ands r1, r2 1154: 2901 cmp r1, #1 1156: d111 bne.n 117c if (flags & USB_DEVICE_EPINTFLAG_RXSTP) { 1158: 06da lsls r2, r3, #27 115a: d503 bpl.n 1164 _usb_d_dev_handle_setup(ept); 115c: 0020 movs r0, r4 115e: 4b2b ldr r3, [pc, #172] ; (120c ) 1160: 4798 blx r3 1162: e016 b.n 1192 } else if (flags & USB_DEVICE_EPINTFLAG_STALL1) { 1164: 2240 movs r2, #64 ; 0x40 1166: 0019 movs r1, r3 1168: 4011 ands r1, r2 116a: 4213 tst r3, r2 116c: d001 beq.n 1172 _usb_d_dev_handle_stall(ept, 1); 116e: 0029 movs r1, r5 1170: e001 b.n 1176 } else if (flags & USB_DEVICE_EPINTFLAG_STALL0) { 1172: 069b lsls r3, r3, #26 1174: d50d bpl.n 1192 _usb_d_dev_handle_stall(ept, 0); 1176: 0020 movs r0, r4 1178: 4b25 ldr r3, [pc, #148] ; (1210 ) 117a: e009 b.n 1190 } else if (_usb_d_dev_ep_is_in(ept)) { 117c: b251 sxtb r1, r2 117e: 2900 cmp r1, #0 1180: da1c bge.n 11bc if (flags & USB_DEVICE_EPINTFLAG_STALL1) { 1182: 0659 lsls r1, r3, #25 1184: d4f3 bmi.n 116e } else if (flags & USB_DEVICE_EPINTFLAG_TRFAIL1) { 1186: 0719 lsls r1, r3, #28 1188: d508 bpl.n 119c _usb_d_dev_handle_trfail(ept, 1); 118a: 0029 movs r1, r5 118c: 0020 movs r0, r4 118e: 4b21 ldr r3, [pc, #132] ; (1214 ) 1190: 4798 blx r3 for (i = 0; i < USB_D_N_EP; i++) { 1192: 3601 adds r6, #1 1194: 3414 adds r4, #20 1196: 2e09 cmp r6, #9 1198: d1bf bne.n 111a 119a: e75f b.n 105c } else if (flags & USB_DEVICE_EPINTFLAG_TRCPT1) { 119c: 0799 lsls r1, r3, #30 119e: d503 bpl.n 11a8 _usb_d_dev_in_next(ept, true); 11a0: 0029 movs r1, r5 11a2: 0020 movs r0, r4 11a4: 4b1c ldr r3, [pc, #112] ; (1218 ) 11a6: e7f3 b.n 1190 } else if (_usb_d_dev_ep_is_ctrl(ept)) { 11a8: 2107 movs r1, #7 11aa: 400a ands r2, r1 11ac: 2a01 cmp r2, #1 11ae: d1f0 bne.n 1192 _usb_d_dev_handle_trfail(ept, 0); 11b0: 2100 movs r1, #0 if (flags & USB_DEVICE_EPINTFLAG_TRFAIL0) { 11b2: 075a lsls r2, r3, #29 11b4: d4ea bmi.n 118c } else if (flags & USB_DEVICE_EPINTFLAG_RXSTP) { 11b6: 06db lsls r3, r3, #27 11b8: d5eb bpl.n 1192 11ba: e7cf b.n 115c if (flags & USB_DEVICE_EPINTFLAG_STALL0) { 11bc: 2020 movs r0, #32 11be: 0019 movs r1, r3 11c0: 4001 ands r1, r0 11c2: 4203 tst r3, r0 11c4: d001 beq.n 11ca _usb_d_dev_handle_stall(ept, 0); 11c6: 2100 movs r1, #0 11c8: e7d5 b.n 1176 } else if (flags & USB_DEVICE_EPINTFLAG_TRFAIL0) { 11ca: 0758 lsls r0, r3, #29 11cc: d4de bmi.n 118c } else if (flags & USB_DEVICE_EPINTFLAG_TRCPT0) { 11ce: 422b tst r3, r5 11d0: d003 beq.n 11da _usb_d_dev_out_next(ept, true); 11d2: 0029 movs r1, r5 11d4: 0020 movs r0, r4 11d6: 4b11 ldr r3, [pc, #68] ; (121c ) 11d8: e7da b.n 1190 } else if (_usb_d_dev_ep_is_ctrl(ept)) { 11da: 2107 movs r1, #7 11dc: 400a ands r2, r1 11de: 2a01 cmp r2, #1 11e0: d1d7 bne.n 1192 if (flags & USB_DEVICE_EPINTFLAG_TRFAIL1) { 11e2: 071a lsls r2, r3, #28 11e4: d5e7 bpl.n 11b6 11e6: e7d0 b.n 118a 11e8: 41005000 .word 0x41005000 11ec: 20000108 .word 0x20000108 11f0: 00000201 .word 0x00000201 11f4: 200000a8 .word 0x200000a8 11f8: 00000419 .word 0x00000419 11fc: 410050ff .word 0x410050ff 1200: 0000066d .word 0x0000066d 1204: 2000011c .word 0x2000011c 1208: 41005107 .word 0x41005107 120c: 00000459 .word 0x00000459 1210: 000004d5 .word 0x000004d5 1214: 00000589 .word 0x00000589 1218: 000006a9 .word 0x000006a9 121c: 0000080d .word 0x0000080d 00001220 <_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); 1220: 4b06 ldr r3, [pc, #24] ; (123c <_pm_init+0x1c>) 1222: 7a1a ldrb r2, [r3, #8] 1224: b2d2 uxtb r2, r2 1226: 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); 1228: 7a5a ldrb r2, [r3, #9] 122a: b2d2 uxtb r2, r2 122c: 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); 122e: 7a9a ldrb r2, [r3, #10] 1230: b2d2 uxtb r2, r2 1232: 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); 1234: 7ada ldrb r2, [r3, #11] 1236: b2d2 uxtb r2, r2 1238: 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); } 123a: 4770 bx lr 123c: 40000400 .word 0x40000400 00001240 <_init_chip>: } 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); 1240: 2304 movs r3, #4 1242: 4a07 ldr r2, [pc, #28] ; (1260 <_init_chip+0x20>) /** * \brief Initialize the hardware abstraction layer */ void _init_chip(void) { 1244: b510 push {r4, lr} 1246: 6851 ldr r1, [r2, #4] 1248: 430b orrs r3, r1 124a: 6053 str r3, [r2, #4] hri_nvmctrl_set_CTRLB_RWS_bf(NVMCTRL, CONF_NVM_WAIT_STATE); _pm_init(); 124c: 4b05 ldr r3, [pc, #20] ; (1264 <_init_chip+0x24>) 124e: 4798 blx r3 _sysctrl_init_sources(); 1250: 4b05 ldr r3, [pc, #20] ; (1268 <_init_chip+0x28>) 1252: 4798 blx r3 #if _GCLK_INIT_1ST _gclk_init_generators_by_fref(_GCLK_INIT_1ST); #endif _sysctrl_init_referenced_generators(); 1254: 4b05 ldr r3, [pc, #20] ; (126c <_init_chip+0x2c>) 1256: 4798 blx r3 _gclk_init_generators_by_fref(_GCLK_INIT_LAST); 1258: 20ff movs r0, #255 ; 0xff 125a: 4b05 ldr r3, [pc, #20] ; (1270 <_init_chip+0x30>) 125c: 4798 blx r3 #if CONF_DMAC_ENABLE _pm_enable_bus_clock(PM_BUS_AHB, DMAC); _pm_enable_bus_clock(PM_BUS_APBB, DMAC); _dma_init(); #endif } 125e: bd10 pop {r4, pc} 1260: 41004000 .word 0x41004000 1264: 00001221 .word 0x00001221 1268: 0000130d .word 0x0000130d 126c: 00001335 .word 0x00001335 1270: 000014a9 .word 0x000014a9 00001274 : * \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) { 1274: 6800 ldr r0, [r0, #0] 1276: 2800 cmp r0, #0 1278: d100 bne.n 127c return true; } } return false; } 127a: 4770 bx lr if (it == element) { 127c: 4288 cmp r0, r1 127e: d1f9 bne.n 1274 return true; 1280: 2001 movs r0, #1 1282: e7fa b.n 127a 00001284 : /** * \brief Insert an element at list end */ void list_insert_at_end(struct list_descriptor *const list, void *const element) { 1284: b570 push {r4, r5, r6, lr} struct list_element *it = list->head; ASSERT(!is_list_element(list, element)); 1286: 4b0c ldr r3, [pc, #48] ; (12b8 ) { 1288: 0005 movs r5, r0 128a: 000c movs r4, r1 struct list_element *it = list->head; 128c: 6806 ldr r6, [r0, #0] ASSERT(!is_list_element(list, element)); 128e: 4798 blx r3 1290: 2301 movs r3, #1 1292: 4058 eors r0, r3 1294: 224f movs r2, #79 ; 0x4f 1296: 4b09 ldr r3, [pc, #36] ; (12bc ) 1298: 4909 ldr r1, [pc, #36] ; (12c0 ) 129a: b2c0 uxtb r0, r0 129c: 4798 blx r3 if (!list->head) { 129e: 682b ldr r3, [r5, #0] 12a0: 2b00 cmp r3, #0 12a2: d102 bne.n 12aa list->head = (struct list_element *)element; 12a4: 602c str r4, [r5, #0] ((struct list_element *)element)->next = NULL; 12a6: 6023 str r3, [r4, #0] while (it->next) { it = it->next; } it->next = (struct list_element *)element; ((struct list_element *)element)->next = NULL; } 12a8: bd70 pop {r4, r5, r6, pc} while (it->next) { 12aa: 0033 movs r3, r6 12ac: 6836 ldr r6, [r6, #0] 12ae: 2e00 cmp r6, #0 12b0: d1fb bne.n 12aa it->next = (struct list_element *)element; 12b2: 601c str r4, [r3, #0] ((struct list_element *)element)->next = NULL; 12b4: 6026 str r6, [r4, #0] 12b6: e7f7 b.n 12a8 12b8: 00001275 .word 0x00001275 12bc: 000012c5 .word 0x000012c5 12c0: 0000239c .word 0x0000239c 000012c4 : /** * \brief Assert function */ void assert(const bool condition, const char *const file, const int line) { if (!(condition)) { 12c4: 2800 cmp r0, #0 12c6: d100 bne.n 12ca __asm("BKPT #0"); 12c8: be00 bkpt 0x0000 } (void)file; (void)line; } 12ca: 4770 bx lr 000012cc : * \brief CDC ACM Init */ void cdc_device_acm_init(void) { /* usb stack init */ usbdc_init(ctrl_buffer); 12cc: 4806 ldr r0, [pc, #24] ; (12e8 ) { 12ce: b510 push {r4, lr} usbdc_init(ctrl_buffer); 12d0: 4b06 ldr r3, [pc, #24] ; (12ec ) 12d2: 3040 adds r0, #64 ; 0x40 12d4: 4798 blx r3 /* usbdc_register_funcion inside */ cdcdf_acm_init(); 12d6: 4b06 ldr r3, [pc, #24] ; (12f0 ) 12d8: 4798 blx r3 usbdc_start(single_desc); 12da: 4b06 ldr r3, [pc, #24] ; (12f4 ) 12dc: 4806 ldr r0, [pc, #24] ; (12f8 ) 12de: 4798 blx r3 usbdc_attach(); 12e0: 4b06 ldr r3, [pc, #24] ; (12fc ) 12e2: 4798 blx r3 } 12e4: bd10 pop {r4, pc} 12e6: 46c0 nop ; (mov r8, r8) 12e8: 20000290 .word 0x20000290 12ec: 000021f1 .word 0x000021f1 12f0: 000003d1 .word 0x000003d1 12f4: 00002269 .word 0x00002269 12f8: 20000008 .word 0x20000008 12fc: 0000229d .word 0x0000229d 00001300 : while (1) { } } void usb_init(void) { 1300: b510 push {r4, lr} cdc_device_acm_init(); 1302: 4b01 ldr r3, [pc, #4] ; (1308 ) 1304: 4798 blx r3 } 1306: bd10 pop {r4, pc} 1308: 000012cd .word 0x000012cd 0000130c <_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; 130c: 220e movs r2, #14 130e: 4b08 ldr r3, [pc, #32] ; (1330 <_sysctrl_init_sources+0x24>) 1310: 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; 1312: 6999 ldr r1, [r3, #24] 1314: 3a0c subs r2, #12 1316: 430a orrs r2, r1 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; tmp = (tmp & SYSCTRL_OSCULP32K_CALIB_Msk) >> SYSCTRL_OSCULP32K_CALIB_Pos; 1318: 211f movs r1, #31 ((Sysctrl *)hw)->OSC32K.reg |= SYSCTRL_OSC32K_ENABLE; 131a: 619a str r2, [r3, #24] tmp = ((Sysctrl *)hw)->OSCULP32K.reg; 131c: 7f1a ldrb r2, [r3, #28] tmp = (tmp & SYSCTRL_OSCULP32K_CALIB_Msk) >> SYSCTRL_OSCULP32K_CALIB_Pos; 131e: 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; 1320: 771a strb r2, [r3, #28] return (((Sysctrl *)hw)->PCLKSR.reg & SYSCTRL_PCLKSR_XOSC32KRDY) >> SYSCTRL_PCLKSR_XOSC32KRDY_Pos; 1322: 391e subs r1, #30 1324: 68da ldr r2, [r3, #12] 1326: 0852 lsrs r2, r2, #1 (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)) 1328: 420a tst r2, r1 132a: d0fb beq.n 1324 <_sysctrl_init_sources+0x18> hri_sysctrl_set_OSC8M_ONDEMAND_bit(hw); #endif #endif (void)calib, (void)hw; } 132c: 4770 bx lr 132e: 46c0 nop ; (mov r8, r8) 1330: 40000800 .word 0x40000800 00001334 <_sysctrl_init_referenced_generators>: } 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; 1334: 2202 movs r2, #2 return (((Sysctrl *)hw)->PCLKSR.reg & SYSCTRL_PCLKSR_DFLLRDY) >> SYSCTRL_PCLKSR_DFLLRDY_Pos; 1336: 2101 movs r1, #1 ((Sysctrl *)hw)->DFLLCTRL.reg = data; 1338: 4b14 ldr r3, [pc, #80] ; (138c <_sysctrl_init_referenced_generators+0x58>) 133a: 849a strh r2, [r3, #36] ; 0x24 return (((Sysctrl *)hw)->PCLKSR.reg & SYSCTRL_PCLKSR_DFLLRDY) >> SYSCTRL_PCLKSR_DFLLRDY_Pos; 133c: 68da ldr r2, [r3, #12] 133e: 0912 lsrs r2, r2, #4 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)) 1340: 420a tst r2, r1 1342: d0fb beq.n 133c <_sysctrl_init_referenced_generators+0x8> } 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; 1344: 4a12 ldr r2, [pc, #72] ; (1390 <_sysctrl_init_referenced_generators+0x5c>) 1346: 62da str r2, [r3, #44] ; 0x2c ((Sysctrl *)hw)->DFLLVAL.reg = data; 1348: 22fc movs r2, #252 ; 0xfc 134a: 01d2 lsls r2, r2, #7 134c: 629a str r2, [r3, #40] ; 0x28 ((Sysctrl *)hw)->DFLLCTRL.reg = data; 134e: 2297 movs r2, #151 ; 0x97 1350: 0052 lsls r2, r2, #1 1352: 849a strh r2, [r3, #36] ; 0x24 tmp = ((Sysctrl *)hw)->DFLLCTRL.reg; 1354: 8c9a ldrh r2, [r3, #36] ; 0x24 tmp = (tmp & SYSCTRL_DFLLCTRL_MODE) >> SYSCTRL_DFLLCTRL_MODE_Pos; 1356: 0892 lsrs r2, r2, #2 | 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)) { 1358: 420a tst r2, r1 135a: d010 beq.n 137e <_sysctrl_init_referenced_generators+0x4a> tmp &= mask; 135c: 2210 movs r2, #16 tmp = ((Sysctrl *)hw)->PCLKSR.reg; 135e: 68d9 ldr r1, [r3, #12] = 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) 1360: 4211 tst r1, r2 1362: d0fc beq.n 135e <_sysctrl_init_referenced_generators+0x2a> ((Sysctrl *)hw)->DFLLCTRL.reg |= SYSCTRL_DFLLCTRL_ONDEMAND; 1364: 2280 movs r2, #128 ; 0x80 1366: 8c99 ldrh r1, [r3, #36] ; 0x24 1368: 430a orrs r2, r1 return ((const Gclk *)hw)->STATUS.bit.SYNCBUSY; } static inline bool hri_gclk_get_STATUS_SYNCBUSY_bit(const void *const hw) { return (((Gclk *)hw)->STATUS.reg & GCLK_STATUS_SYNCBUSY) >> GCLK_STATUS_SYNCBUSY_Pos; 136a: 490a ldr r1, [pc, #40] ; (1394 <_sysctrl_init_referenced_generators+0x60>) 136c: 849a strh r2, [r3, #36] ; 0x24 136e: 784a ldrb r2, [r1, #1] 1370: 09d2 lsrs r2, r2, #7 hri_sysctrl_set_DPLLCTRLA_ONDEMAND_bit(hw); #endif #endif #if CONF_DFLL_CONFIG == 1 while (hri_gclk_get_STATUS_SYNCBUSY_bit(GCLK)) 1372: d1fc bne.n 136e <_sysctrl_init_referenced_generators+0x3a> ((Sysctrl *)hw)->OSC32K.reg &= ~SYSCTRL_OSC32K_ENABLE; 1374: 2102 movs r1, #2 1376: 699a ldr r2, [r3, #24] 1378: 438a bics r2, r1 137a: 619a str r2, [r3, #24] /* Disable after all possible configurations needs sync written. */ hri_sysctrl_clear_OSC32K_ENABLE_bit(hw); #endif (void)hw; } 137c: 4770 bx lr return (((Sysctrl *)hw)->PCLKSR.reg & SYSCTRL_PCLKSR_DFLLRDY) >> SYSCTRL_PCLKSR_DFLLRDY_Pos; 137e: 2101 movs r1, #1 1380: 68da ldr r2, [r3, #12] 1382: 0912 lsrs r2, r2, #4 while (!hri_sysctrl_get_PCLKSR_DFLLRDY_bit(hw)) 1384: 420a tst r2, r1 1386: d0fb beq.n 1380 <_sysctrl_init_referenced_generators+0x4c> 1388: e7ec b.n 1364 <_sysctrl_init_referenced_generators+0x30> 138a: 46c0 nop ; (mov r8, r8) 138c: 40000800 .word 0x40000800 1390: 0401bb80 .word 0x0401bb80 1394: 40000c00 .word 0x40000c00 00001398 : * \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) { 1398: b5f8 push {r3, r4, r5, r6, r7, lr} 139a: 0006 movs r6, r0 139c: 000d movs r5, r1 139e: 0014 movs r4, r2 uint32_t offset = 0; struct usart_sync_descriptor *descr = CONTAINER_OF(io_descr, struct usart_sync_descriptor, io); ASSERT(io_descr && buf && length); 13a0: 2800 cmp r0, #0 13a2: d004 beq.n 13ae 13a4: 1e08 subs r0, r1, #0 13a6: d002 beq.n 13ae 13a8: 0010 movs r0, r2 13aa: 1e43 subs r3, r0, #1 13ac: 4198 sbcs r0, r3 13ae: 22f1 movs r2, #241 ; 0xf1 13b0: 4910 ldr r1, [pc, #64] ; (13f4 ) 13b2: 4b11 ldr r3, [pc, #68] ; (13f8 ) 13b4: 4798 blx r3 while (!_usart_sync_is_ready_to_send(&descr->device)) 13b6: 0037 movs r7, r6 13b8: 3708 adds r7, #8 13ba: 0038 movs r0, r7 13bc: 4b0f ldr r3, [pc, #60] ; (13fc ) 13be: 4798 blx r3 13c0: 2800 cmp r0, #0 13c2: d0f8 beq.n 13b6 uint32_t offset = 0; 13c4: 2600 movs r6, #0 ; do { _usart_sync_write_byte(&descr->device, buf[offset]); 13c6: 0038 movs r0, r7 13c8: 5da9 ldrb r1, [r5, r6] 13ca: 4b0d ldr r3, [pc, #52] ; (1400 ) 13cc: 4798 blx r3 while (!_usart_sync_is_ready_to_send(&descr->device)) 13ce: 0038 movs r0, r7 13d0: 4b0a ldr r3, [pc, #40] ; (13fc ) 13d2: 4798 blx r3 13d4: 2800 cmp r0, #0 13d6: d0fa beq.n 13ce ; } while (++offset < length); 13d8: 3601 adds r6, #1 13da: 42b4 cmp r4, r6 13dc: d8f3 bhi.n 13c6 13de: 2501 movs r5, #1 13e0: 2c00 cmp r4, #0 13e2: d000 beq.n 13e6 13e4: 0025 movs r5, r4 while (!_usart_sync_is_transmit_done(&descr->device)) 13e6: 0038 movs r0, r7 13e8: 4b06 ldr r3, [pc, #24] ; (1404 ) 13ea: 4798 blx r3 13ec: 2800 cmp r0, #0 13ee: d0fa beq.n 13e6 ; return (int32_t)offset; } 13f0: 0028 movs r0, r5 13f2: bdf8 pop {r3, r4, r5, r6, r7, pc} 13f4: 000023ba .word 0x000023ba 13f8: 000012c5 .word 0x000012c5 13fc: 00001ccb .word 0x00001ccb 1400: 00001cbd .word 0x00001cbd 1404: 00001cd5 .word 0x00001cd5 00001408 : * \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) { 1408: b5f7 push {r0, r1, r2, r4, r5, r6, r7, lr} 140a: 0005 movs r5, r0 140c: 0014 movs r4, r2 140e: 9101 str r1, [sp, #4] uint32_t offset = 0; struct usart_sync_descriptor *descr = CONTAINER_OF(io_descr, struct usart_sync_descriptor, io); ASSERT(io_descr && buf && length); 1410: 2800 cmp r0, #0 1412: d004 beq.n 141e 1414: 1e08 subs r0, r1, #0 1416: d002 beq.n 141e 1418: 0010 movs r0, r2 141a: 1e43 subs r3, r0, #1 141c: 4198 sbcs r0, r3 141e: 2286 movs r2, #134 ; 0x86 1420: 490c ldr r1, [pc, #48] ; (1454 ) 1422: 4b0d ldr r3, [pc, #52] ; (1458 ) 1424: 0052 lsls r2, r2, #1 1426: 4798 blx r3 uint32_t offset = 0; 1428: 2600 movs r6, #0 do { while (!_usart_sync_is_byte_received(&descr->device)) 142a: 002f movs r7, r5 142c: 3708 adds r7, #8 142e: 0038 movs r0, r7 1430: 4b0a ldr r3, [pc, #40] ; (145c ) 1432: 4798 blx r3 1434: 2800 cmp r0, #0 1436: d0f8 beq.n 142a ; buf[offset] = _usart_sync_read_byte(&descr->device); 1438: 4b09 ldr r3, [pc, #36] ; (1460 ) 143a: 0038 movs r0, r7 143c: 4798 blx r3 143e: 9b01 ldr r3, [sp, #4] 1440: 5598 strb r0, [r3, r6] } while (++offset < length); 1442: 3601 adds r6, #1 1444: 42b4 cmp r4, r6 1446: d8f0 bhi.n 142a 1448: 2001 movs r0, #1 144a: 2c00 cmp r4, #0 144c: d000 beq.n 1450 144e: 0020 movs r0, r4 return (int32_t)offset; } 1450: bdfe pop {r1, r2, r3, r4, r5, r6, r7, pc} 1452: 46c0 nop ; (mov r8, r8) 1454: 000023ba .word 0x000023ba 1458: 000012c5 .word 0x000012c5 145c: 00001cdf .word 0x00001cdf 1460: 00001cc3 .word 0x00001cc3 00001464 : { 1464: b570 push {r4, r5, r6, lr} 1466: 0004 movs r4, r0 1468: 000d movs r5, r1 ASSERT(descr && hw); 146a: 2800 cmp r0, #0 146c: d002 beq.n 1474 146e: 0008 movs r0, r1 1470: 1e43 subs r3, r0, #1 1472: 4198 sbcs r0, r3 1474: 4907 ldr r1, [pc, #28] ; (1494 ) 1476: 4b08 ldr r3, [pc, #32] ; (1498 ) 1478: 2234 movs r2, #52 ; 0x34 147a: 4798 blx r3 init_status = _usart_sync_init(&descr->device, hw); 147c: 0020 movs r0, r4 147e: 0029 movs r1, r5 1480: 4b06 ldr r3, [pc, #24] ; (149c ) 1482: 3008 adds r0, #8 1484: 4798 blx r3 if (init_status) { 1486: 2800 cmp r0, #0 1488: d103 bne.n 1492 descr->io.read = usart_sync_read; 148a: 4b05 ldr r3, [pc, #20] ; (14a0 ) 148c: 6063 str r3, [r4, #4] descr->io.write = usart_sync_write; 148e: 4b05 ldr r3, [pc, #20] ; (14a4 ) 1490: 6023 str r3, [r4, #0] } 1492: bd70 pop {r4, r5, r6, pc} 1494: 000023ba .word 0x000023ba 1498: 000012c5 .word 0x000012c5 149c: 00001c91 .word 0x00001c91 14a0: 00001409 .word 0x00001409 14a4: 00001399 .word 0x00001399 000014a8 <_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)) { 14a8: 07c3 lsls r3, r0, #31 14aa: d508 bpl.n 14be <_gclk_init_generators_by_fref+0x16> } 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; 14ac: 2380 movs r3, #128 ; 0x80 14ae: 4a0a ldr r2, [pc, #40] ; (14d8 <_gclk_init_generators_by_fref+0x30>) 14b0: 005b lsls r3, r3, #1 14b2: 6093 str r3, [r2, #8] ((Gclk *)hw)->GENCTRL.reg = data; 14b4: 4b09 ldr r3, [pc, #36] ; (14dc <_gclk_init_generators_by_fref+0x34>) 14b6: 6053 str r3, [r2, #4] while (((const Gclk *)hw)->STATUS.bit.SYNCBUSY) 14b8: 7853 ldrb r3, [r2, #1] 14ba: 09db lsrs r3, r3, #7 14bc: d1fc bne.n 14b8 <_gclk_init_generators_by_fref+0x10> | (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)) { 14be: 0783 lsls r3, r0, #30 14c0: d508 bpl.n 14d4 <_gclk_init_generators_by_fref+0x2c> ((Gclk *)hw)->GENDIV.reg = data; 14c2: 2302 movs r3, #2 14c4: 4a04 ldr r2, [pc, #16] ; (14d8 <_gclk_init_generators_by_fref+0x30>) 14c6: 33ff adds r3, #255 ; 0xff 14c8: 6093 str r3, [r2, #8] ((Gclk *)hw)->GENCTRL.reg = data; 14ca: 4b05 ldr r3, [pc, #20] ; (14e0 <_gclk_init_generators_by_fref+0x38>) 14cc: 6053 str r3, [r2, #4] while (((const Gclk *)hw)->STATUS.bit.SYNCBUSY) 14ce: 7853 ldrb r3, [r2, #1] 14d0: 09db lsrs r3, r3, #7 14d2: d1fc bne.n 14ce <_gclk_init_generators_by_fref+0x26> | (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 } 14d4: 4770 bx lr 14d6: 46c0 nop ; (mov r8, r8) 14d8: 40000c00 .word 0x40000c00 14dc: 00010700 .word 0x00010700 14e0: 00010501 .word 0x00010501 000014e4 : #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) { 14e4: b510 push {r4, lr} _param_error_check(desc && eof && (desc < eof)); while (desc < eof) { 14e6: 4288 cmp r0, r1 14e8: d301 bcc.n 14ee _desc_len_check(); 14ea: 2000 movs r0, #0 return desc; } desc = usb_desc_next(desc); } return NULL; } 14ec: bd10 pop {r4, pc} return desc[0]; 14ee: 7803 ldrb r3, [r0, #0] _desc_len_check(); 14f0: 2b01 cmp r3, #1 14f2: d9fa bls.n 14ea if (type == usb_desc_type(desc)) { 14f4: 7844 ldrb r4, [r0, #1] 14f6: 4294 cmp r4, r2 14f8: d0f8 beq.n 14ec return (desc + usb_desc_len(desc)); 14fa: 18c0 adds r0, r0, r3 14fc: e7f3 b.n 14e6 000014fe : uint8_t *usb_find_ep_desc(uint8_t *desc, uint8_t *eof) { _param_error_check(desc && eof && (desc < eof)); while (desc < eof) { 14fe: 4288 cmp r0, r1 1500: d301 bcc.n 1506 _desc_len_check(); 1502: 2000 movs r0, #0 return desc; } desc = usb_desc_next(desc); } return NULL; } 1504: 4770 bx lr return desc[0]; 1506: 7803 ldrb r3, [r0, #0] _desc_len_check(); 1508: 2b01 cmp r3, #1 150a: d9fa bls.n 1502 return desc[1]; 150c: 7842 ldrb r2, [r0, #1] if (USB_DT_INTERFACE == usb_desc_type(desc)) { 150e: 2a04 cmp r2, #4 1510: d0f7 beq.n 1502 if (USB_DT_ENDPOINT == usb_desc_type(desc)) { 1512: 2a05 cmp r2, #5 1514: d0f6 beq.n 1504 return (desc + usb_desc_len(desc)); 1516: 18c0 adds r0, r0, r3 1518: e7f1 b.n 14fe ... 0000151c : uint8_t *usb_find_cfg_desc(uint8_t *desc, uint8_t *eof, uint8_t cfg_value) { 151c: b570 push {r4, r5, r6, lr} _param_error_check(desc && eof && (desc < eof)); desc = usb_find_desc(desc, eof, USB_DT_CONFIG); 151e: 4b0d ldr r3, [pc, #52] ; (1554 ) { 1520: 0015 movs r5, r2 desc = usb_find_desc(desc, eof, USB_DT_CONFIG); 1522: 2202 movs r2, #2 { 1524: 000c movs r4, r1 desc = usb_find_desc(desc, eof, USB_DT_CONFIG); 1526: 4798 blx r3 if (!desc) { 1528: 2800 cmp r0, #0 152a: d10f bne.n 154c return desc; } desc = usb_cfg_desc_next(desc); } return NULL; } 152c: bd70 pop {r4, r5, r6, pc} _desc_len_check(); 152e: 7803 ldrb r3, [r0, #0] 1530: 2b01 cmp r3, #1 1532: d90d bls.n 1550 if (desc[1] != USB_DT_CONFIG) { 1534: 7843 ldrb r3, [r0, #1] 1536: 2b02 cmp r3, #2 1538: d10a bne.n 1550 if (desc[5] == cfg_value) { 153a: 7943 ldrb r3, [r0, #5] 153c: 42ab cmp r3, r5 153e: d0f5 beq.n 152c return (ptr[0] + (ptr[1] << 8)); 1540: 78c2 ldrb r2, [r0, #3] 1542: 7883 ldrb r3, [r0, #2] 1544: 0212 lsls r2, r2, #8 1546: 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)); 1548: b29b uxth r3, r3 154a: 18c0 adds r0, r0, r3 while (desc < eof) { 154c: 42a0 cmp r0, r4 154e: d3ee bcc.n 152e return NULL; 1550: 2000 movs r0, #0 1552: e7eb b.n 152c 1554: 000014e5 .word 0x000014e5 00001558 : } return NULL; } uint8_t *usb_find_str_desc(uint8_t *desc, uint8_t *eof, uint8_t str_index) { 1558: b570 push {r4, r5, r6, lr} 155a: 000c movs r4, r1 155c: 0016 movs r6, r2 uint8_t i; _param_error_check(desc && eof && (desc < eof)); for (i = 0; desc < eof;) { 155e: 2500 movs r5, #0 1560: 42a0 cmp r0, r4 1562: d301 bcc.n 1568 return desc; } i++; desc = usb_desc_next(desc); } else { return NULL; 1564: 2000 movs r0, #0 } } return NULL; } 1566: bd70 pop {r4, r5, r6, pc} desc = usb_find_desc(desc, eof, USB_DT_STRING); 1568: 2203 movs r2, #3 156a: 0021 movs r1, r4 156c: 4b05 ldr r3, [pc, #20] ; (1584 ) 156e: 4798 blx r3 if (desc) { 1570: 2800 cmp r0, #0 1572: d0f8 beq.n 1566 return desc[0]; 1574: 7803 ldrb r3, [r0, #0] _desc_len_check(); 1576: 2b01 cmp r3, #1 1578: d9f4 bls.n 1564 if (i == str_index) { 157a: 42b5 cmp r5, r6 157c: d0f3 beq.n 1566 return (desc + usb_desc_len(desc)); 157e: 18c0 adds r0, r0, r3 1580: 3501 adds r5, #1 1582: e7ed b.n 1560 1584: 000014e5 .word 0x000014e5 00001588 <_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) { 1588: 0002 movs r2, r0 for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) { if (usb_d_inst.ep[i].xfer.hdr.ep == ep) { return i; } if (usb_d_inst.ep[i].xfer.hdr.type == USB_EP_XTYPE_CTRL && (ep & USB_EP_N_MASK) == usb_d_inst.ep[i].xfer.hdr.ep) { 158a: 210f movs r1, #15 for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) { 158c: 2000 movs r0, #0 { 158e: b530 push {r4, r5, lr} 1590: 4b09 ldr r3, [pc, #36] ; (15b8 <_usb_d_find_ep+0x30>) && (ep & USB_EP_N_MASK) == usb_d_inst.ep[i].xfer.hdr.ep) { 1592: 4011 ands r1, r2 if (usb_d_inst.ep[i].xfer.hdr.ep == ep) { 1594: 785c ldrb r4, [r3, #1] 1596: 4294 cmp r4, r2 1598: d00c beq.n 15b4 <_usb_d_find_ep+0x2c> if (usb_d_inst.ep[i].xfer.hdr.type == USB_EP_XTYPE_CTRL 159a: 781d ldrb r5, [r3, #0] 159c: 2d00 cmp r5, #0 159e: d101 bne.n 15a4 <_usb_d_find_ep+0x1c> && (ep & USB_EP_N_MASK) == usb_d_inst.ep[i].xfer.hdr.ep) { 15a0: 428c cmp r4, r1 15a2: d007 beq.n 15b4 <_usb_d_find_ep+0x2c> for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) { 15a4: 3001 adds r0, #1 15a6: b2c4 uxtb r4, r0 15a8: 3320 adds r3, #32 15aa: b240 sxtb r0, r0 15ac: 2c04 cmp r4, #4 15ae: d1f1 bne.n 1594 <_usb_d_find_ep+0xc> return i; } } return -1; 15b0: 2001 movs r0, #1 15b2: 4240 negs r0, r0 } 15b4: bd30 pop {r4, r5, pc} 15b6: 46c0 nop ; (mov r8, r8) 15b8: 20000310 .word 0x20000310 000015bc : { (void)unused0; (void)unused1; (void)unused2; return false; } 15bc: 2000 movs r0, #0 15be: 4770 bx lr 000015c0 : * \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) { 15c0: b570 push {r4, r5, r6, lr} int8_t ep_index = _usb_d_find_ep(ep); 15c2: 4b08 ldr r3, [pc, #32] ; (15e4 ) { 15c4: 0004 movs r4, r0 15c6: 000d movs r5, r1 int8_t ep_index = _usb_d_find_ep(ep); 15c8: 4798 blx r3 struct usb_d_ep *ept = &usb_d_inst.ep[ep_index]; if (ept->xfer.hdr.state == USB_EP_S_X_DATA) { 15ca: 4b07 ldr r3, [pc, #28] ; (15e8 ) 15cc: 0140 lsls r0, r0, #5 15ce: 181b adds r3, r3, r0 15d0: 789a ldrb r2, [r3, #2] return ept->callbacks.more(ep, transfered); } return false; 15d2: 2000 movs r0, #0 if (ept->xfer.hdr.state == USB_EP_S_X_DATA) { 15d4: 2a03 cmp r2, #3 15d6: d103 bne.n 15e0 return ept->callbacks.more(ep, transfered); 15d8: 0029 movs r1, r5 15da: 0020 movs r0, r4 15dc: 699b ldr r3, [r3, #24] 15de: 4798 blx r3 } 15e0: bd70 pop {r4, r5, r6, pc} 15e2: 46c0 nop ; (mov r8, r8) 15e4: 00001589 .word 0x00001589 15e8: 20000310 .word 0x20000310 000015ec <_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) { 15ec: b5f0 push {r4, r5, r6, r7, lr} int8_t ep_index = _usb_d_find_ep(ep); 15ee: 4b37 ldr r3, [pc, #220] ; (16cc <_usb_d_cb_trans_done+0xe0>) { 15f0: b087 sub sp, #28 15f2: 000f movs r7, r1 15f4: 9000 str r0, [sp, #0] 15f6: 9201 str r2, [sp, #4] int8_t ep_index = _usb_d_find_ep(ep); 15f8: 4798 blx r3 struct usb_d_ep *ept = &usb_d_inst.ep[ep_index]; if (code == USB_TRANS_DONE) { 15fa: 4d35 ldr r5, [pc, #212] ; (16d0 <_usb_d_cb_trans_done+0xe4>) 15fc: 0144 lsls r4, r0, #5 15fe: 2f00 cmp r7, #0 1600: d141 bne.n 1686 <_usb_d_cb_trans_done+0x9a> ept->xfer.hdr.status = USB_XFER_DONE; 1602: 192e adds r6, r5, r4 1604: 70f7 strb r7, [r6, #3] if (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) { 1606: 5d29 ldrb r1, [r5, r4] 1608: 2900 cmp r1, #0 160a: d133 bne.n 1674 <_usb_d_cb_trans_done+0x88> bool err = ept->callbacks.xfer(ept->xfer.hdr.ep, USB_XFER_DATA, ept->xfer.req); 160c: 0022 movs r2, r4 if (state == USB_EP_S_X_DATA) { 160e: 78b4 ldrb r4, [r6, #2] bool err = ept->callbacks.xfer(ept->xfer.hdr.ep, USB_XFER_DATA, ept->xfer.req); 1610: 320c adds r2, #12 1612: 7870 ldrb r0, [r6, #1] 1614: 69f3 ldr r3, [r6, #28] 1616: 18aa adds r2, r5, r2 if (state == USB_EP_S_X_DATA) { 1618: 2c03 cmp r4, #3 161a: d127 bne.n 166c <_usb_d_cb_trans_done+0x80> 161c: 270c movs r7, #12 bool err = ept->callbacks.xfer(ept->xfer.hdr.ep, USB_XFER_DATA, ept->xfer.req); 161e: 3101 adds r1, #1 1620: 57f7 ldrsb r7, [r6, r7] 1622: 4798 blx r3 1624: 0003 movs r3, r0 if (err) { 1626: 7870 ldrb r0, [r6, #1] 1628: 2b00 cmp r3, #0 162a: d00b beq.n 1644 <_usb_d_cb_trans_done+0x58> ept->xfer.hdr.state = USB_EP_S_HALTED; 162c: 4b29 ldr r3, [pc, #164] ; (16d4 <_usb_d_cb_trans_done+0xe8>) 162e: 8073 strh r3, [r6, #2] _usb_d_dev_ep_stall(req_dir ? ept->xfer.hdr.ep : (ept->xfer.hdr.ep | USB_EP_DIR), USB_EP_STALL_SET); 1630: 2f00 cmp r7, #0 1632: db02 blt.n 163a <_usb_d_cb_trans_done+0x4e> 1634: 3b86 subs r3, #134 ; 0x86 1636: 3bff subs r3, #255 ; 0xff 1638: 4318 orrs r0, r3 163a: 2101 movs r1, #1 163c: 4b26 ldr r3, [pc, #152] ; (16d8 <_usb_d_cb_trans_done+0xec>) 163e: 4798 blx r3 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); } 1640: b007 add sp, #28 1642: bdf0 pop {r4, r5, r6, r7, pc} ept->xfer.hdr.state = USB_EP_S_X_STATUS; 1644: 2204 movs r2, #4 struct usb_d_transfer trans 1646: 9303 str r3, [sp, #12] ept->xfer.hdr.state = USB_EP_S_X_STATUS; 1648: 70b2 strb r2, [r6, #2] struct usb_d_transfer trans 164a: 9304 str r3, [sp, #16] 164c: 2f00 cmp r7, #0 164e: db0a blt.n 1666 <_usb_d_cb_trans_done+0x7a> 1650: 2380 movs r3, #128 ; 0x80 1652: 4318 orrs r0, r3 1654: ab02 add r3, sp, #8 1656: 7318 strb r0, [r3, #12] 1658: 2301 movs r3, #1 165a: aa02 add r2, sp, #8 165c: 7353 strb r3, [r2, #13] return _usb_d_dev_ep_trans(&trans); 165e: a803 add r0, sp, #12 1660: 4b1e ldr r3, [pc, #120] ; (16dc <_usb_d_cb_trans_done+0xf0>) 1662: 4798 blx r3 1664: e7ec b.n 1640 <_usb_d_cb_trans_done+0x54> struct usb_d_transfer trans 1666: 230f movs r3, #15 1668: 4018 ands r0, r3 166a: e7f3 b.n 1654 <_usb_d_cb_trans_done+0x68> ept->callbacks.xfer(ept->xfer.hdr.ep, USB_XFER_DONE, ept->xfer.req); 166c: 4798 blx r3 ept->xfer.hdr.state = USB_EP_S_X_SETUP; 166e: 2302 movs r3, #2 1670: 70b3 strb r3, [r6, #2] 1672: e7e5 b.n 1640 <_usb_d_cb_trans_done+0x54> ept->xfer.hdr.state = USB_EP_S_IDLE; 1674: 2301 movs r3, #1 1676: 70b3 strb r3, [r6, #2] ept->callbacks.xfer(ep, (enum usb_xfer_code)ept->xfer.hdr.status, (void *)transferred); 1678: 192c adds r4, r5, r4 167a: 78e1 ldrb r1, [r4, #3] 167c: 69e3 ldr r3, [r4, #28] 167e: 9a01 ldr r2, [sp, #4] 1680: 9800 ldr r0, [sp, #0] 1682: 4798 blx r3 1684: e7dc b.n 1640 <_usb_d_cb_trans_done+0x54> ept->xfer.hdr.status = USB_XFER_HALT; 1686: 192b adds r3, r5, r4 } else if (code == USB_TRANS_STALL) { 1688: 2f01 cmp r7, #1 168a: d10c bne.n 16a6 <_usb_d_cb_trans_done+0xba> ept->xfer.hdr.status = USB_XFER_HALT; 168c: 2202 movs r2, #2 168e: 70da strb r2, [r3, #3] if (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) { 1690: 5d29 ldrb r1, [r5, r4] 1692: 2900 cmp r1, #0 1694: d104 bne.n 16a0 <_usb_d_cb_trans_done+0xb4> ept->xfer.hdr.state = USB_EP_S_X_SETUP; 1696: 709a strb r2, [r3, #2] _usb_d_dev_ep_stall(ep, USB_EP_STALL_CLR); 1698: 9800 ldr r0, [sp, #0] 169a: 4b0f ldr r3, [pc, #60] ; (16d8 <_usb_d_cb_trans_done+0xec>) 169c: 4798 blx r3 169e: e7eb b.n 1678 <_usb_d_cb_trans_done+0x8c> ept->xfer.hdr.state = USB_EP_S_HALTED; 16a0: 2205 movs r2, #5 ept->xfer.hdr.state = USB_EP_S_IDLE; 16a2: 709a strb r2, [r3, #2] 16a4: e7e8 b.n 1678 <_usb_d_cb_trans_done+0x8c> } else if (code == USB_TRANS_ABORT) { 16a6: 2f02 cmp r7, #2 16a8: d108 bne.n 16bc <_usb_d_cb_trans_done+0xd0> ept->xfer.hdr.status = USB_XFER_ABORT; 16aa: 2204 movs r2, #4 16ac: 70da strb r2, [r3, #3] if (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) { 16ae: 5d2a ldrb r2, [r5, r4] 16b0: 2a00 cmp r2, #0 16b2: d101 bne.n 16b8 <_usb_d_cb_trans_done+0xcc> ept->xfer.hdr.state = USB_EP_S_X_SETUP; 16b4: 709f strb r7, [r3, #2] return; 16b6: e7c3 b.n 1640 <_usb_d_cb_trans_done+0x54> ept->xfer.hdr.state = USB_EP_S_IDLE; 16b8: 2201 movs r2, #1 16ba: e7f2 b.n 16a2 <_usb_d_cb_trans_done+0xb6> } else if (code == USB_TRANS_RESET) { 16bc: 2f03 cmp r7, #3 16be: d103 bne.n 16c8 <_usb_d_cb_trans_done+0xdc> ept->xfer.hdr.state = USB_EP_S_DISABLED; 16c0: 22a0 movs r2, #160 ; 0xa0 16c2: 00d2 lsls r2, r2, #3 ept->xfer.hdr.state = USB_EP_S_ERROR; 16c4: 805a strh r2, [r3, #2] 16c6: e7d7 b.n 1678 <_usb_d_cb_trans_done+0x8c> 16c8: 4a05 ldr r2, [pc, #20] ; (16e0 <_usb_d_cb_trans_done+0xf4>) 16ca: e7fb b.n 16c4 <_usb_d_cb_trans_done+0xd8> 16cc: 00001589 .word 0x00001589 16d0: 20000310 .word 0x20000310 16d4: 00000205 .word 0x00000205 16d8: 00000da9 .word 0x00000da9 16dc: 00000ec9 .word 0x00000ec9 16e0: 00000606 .word 0x00000606 000016e4 : { 16e4: b5f7 push {r0, r1, r2, r4, r5, r6, r7, lr} int8_t ep_index = _usb_d_find_ep(ep); 16e6: 4b18 ldr r3, [pc, #96] ; (1748 ) { 16e8: 0004 movs r4, r0 int8_t ep_index = _usb_d_find_ep(ep); 16ea: 4798 blx r3 uint8_t * req = ept->xfer.req; 16ec: 0147 lsls r7, r0, #5 16ee: 003b movs r3, r7 16f0: 4d16 ldr r5, [pc, #88] ; (174c ) 16f2: 330c adds r3, #12 16f4: 195b adds r3, r3, r5 uint8_t n = _usb_d_dev_ep_read_req(ep, req); 16f6: 0019 movs r1, r3 uint8_t * req = ept->xfer.req; 16f8: 9301 str r3, [sp, #4] uint8_t n = _usb_d_dev_ep_read_req(ep, req); 16fa: 0020 movs r0, r4 16fc: 4b14 ldr r3, [pc, #80] ; (1750 ) 16fe: 4798 blx r3 _usb_d_dev_ep_stall(ep | USB_EP_DIR, USB_EP_STALL_SET); 1700: 2680 movs r6, #128 ; 0x80 if (n != 8) { 1702: b2c0 uxtb r0, r0 _usb_d_dev_ep_stall(ep | USB_EP_DIR, USB_EP_STALL_SET); 1704: 4326 orrs r6, r4 1706: 9600 str r6, [sp, #0] 1708: 4e12 ldr r6, [pc, #72] ; (1754 ) if (n != 8) { 170a: 2808 cmp r0, #8 170c: d006 beq.n 171c _usb_d_dev_ep_stall(ep, USB_EP_STALL_SET); 170e: 2101 movs r1, #1 1710: 0020 movs r0, r4 1712: 47b0 blx r6 _usb_d_dev_ep_stall(ep | USB_EP_DIR, USB_EP_STALL_SET); 1714: 2101 movs r1, #1 _usb_d_dev_ep_stall(ep | USB_EP_DIR, USB_EP_STALL_SET); 1716: 9800 ldr r0, [sp, #0] 1718: 47b0 blx r6 } 171a: bdf7 pop {r0, r1, r2, r4, r5, r6, r7, pc} ept->xfer.hdr.state = USB_EP_S_IDLE; 171c: 19ed adds r5, r5, r7 171e: 2701 movs r7, #1 _usb_d_dev_ep_stall(ep, USB_EP_STALL_CLR); 1720: 2100 movs r1, #0 1722: 0020 movs r0, r4 1724: 47b0 blx r6 _usb_d_dev_ep_stall(ep | USB_EP_DIR, USB_EP_STALL_CLR); 1726: 2100 movs r1, #0 1728: 9800 ldr r0, [sp, #0] 172a: 47b0 blx r6 if (!ept->callbacks.req(ep, req)) { 172c: 0020 movs r0, r4 172e: 9901 ldr r1, [sp, #4] 1730: 696b ldr r3, [r5, #20] ept->xfer.hdr.state = USB_EP_S_IDLE; 1732: 70af strb r7, [r5, #2] if (!ept->callbacks.req(ep, req)) { 1734: 4798 blx r3 1736: 2800 cmp r0, #0 1738: d1ef bne.n 171a ept->xfer.hdr.state = USB_EP_S_HALTED; 173a: 2305 movs r3, #5 _usb_d_dev_ep_stall(ep, USB_EP_STALL_SET); 173c: 0039 movs r1, r7 173e: 0020 movs r0, r4 ept->xfer.hdr.state = USB_EP_S_HALTED; 1740: 70ab strb r3, [r5, #2] _usb_d_dev_ep_stall(ep, USB_EP_STALL_SET); 1742: 47b0 blx r6 _usb_d_dev_ep_stall(ep | USB_EP_DIR, USB_EP_STALL_SET); 1744: 0039 movs r1, r7 1746: e7e6 b.n 1716 1748: 00001589 .word 0x00001589 174c: 20000310 .word 0x20000310 1750: 00000e71 .word 0x00000e71 1754: 00000da9 .word 0x00000da9 00001758 : int32_t usb_d_init(void) { 1758: b570 push {r4, r5, r6, lr} int32_t rc = _usb_d_dev_init(); 175a: 4b11 ldr r3, [pc, #68] ; (17a0 ) 175c: 4798 blx r3 uint8_t i; if (rc < 0) { 175e: 2800 cmp r0, #0 1760: db1d blt.n 179e return rc; } memset(usb_d_inst.ep, 0x00, sizeof(struct usb_d_ep) * CONF_USB_D_NUM_EP_SP); 1762: 4c10 ldr r4, [pc, #64] ; (17a4 ) 1764: 2280 movs r2, #128 ; 0x80 1766: 2100 movs r1, #0 1768: 0020 movs r0, r4 176a: 4b0f ldr r3, [pc, #60] ; (17a8 ) 176c: 4798 blx r3 for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) { 176e: 0023 movs r3, r4 usb_d_inst.ep[i].xfer.hdr.ep = 0xFF; 1770: 21ff movs r1, #255 ; 0xff memset(usb_d_inst.ep, 0x00, sizeof(struct usb_d_ep) * CONF_USB_D_NUM_EP_SP); 1772: 2404 movs r4, #4 usb_d_inst.ep[i].callbacks.req = (usb_d_ep_cb_setup_t)usb_d_dummy_cb_false; 1774: 4a0d ldr r2, [pc, #52] ; (17ac ) for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) { 1776: 3c01 subs r4, #1 1778: b2e4 uxtb r4, r4 usb_d_inst.ep[i].xfer.hdr.ep = 0xFF; 177a: 7059 strb r1, [r3, #1] usb_d_inst.ep[i].callbacks.req = (usb_d_ep_cb_setup_t)usb_d_dummy_cb_false; 177c: 615a str r2, [r3, #20] usb_d_inst.ep[i].callbacks.more = (usb_d_ep_cb_more_t)usb_d_dummy_cb_false; 177e: 619a str r2, [r3, #24] usb_d_inst.ep[i].callbacks.xfer = (usb_d_ep_cb_xfer_t)usb_d_dummy_cb_false; 1780: 61da str r2, [r3, #28] for (i = 0; i < CONF_USB_D_NUM_EP_SP; i++) { 1782: 3320 adds r3, #32 1784: 2c00 cmp r4, #0 1786: d1f6 bne.n 1776 } /* 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); 1788: 4d09 ldr r5, [pc, #36] ; (17b0 ) 178a: 0020 movs r0, r4 178c: 4909 ldr r1, [pc, #36] ; (17b4 ) 178e: 47a8 blx r5 _usb_d_dev_register_ep_callback(USB_D_DEV_EP_CB_MORE, (FUNC_PTR)usb_d_cb_trans_more); 1790: 2001 movs r0, #1 1792: 4909 ldr r1, [pc, #36] ; (17b8 ) 1794: 47a8 blx r5 _usb_d_dev_register_ep_callback(USB_D_DEV_EP_CB_DONE, (FUNC_PTR)_usb_d_cb_trans_done); 1796: 2002 movs r0, #2 1798: 4908 ldr r1, [pc, #32] ; (17bc ) 179a: 47a8 blx r5 return ERR_NONE; 179c: 0020 movs r0, r4 } 179e: bd70 pop {r4, r5, r6, pc} 17a0: 000009fd .word 0x000009fd 17a4: 20000310 .word 0x20000310 17a8: 00002367 .word 0x00002367 17ac: 000015bd .word 0x000015bd 17b0: 00001009 .word 0x00001009 17b4: 000016e5 .word 0x000016e5 17b8: 000015c1 .word 0x000015c1 17bc: 000015ed .word 0x000015ed 000017c0 : { _usb_d_dev_deinit(); } void usb_d_register_callback(const enum usb_d_cb_type type, const FUNC_PTR func) { 17c0: b510 push {r4, lr} /* Directly uses device driver callback. */ _usb_d_dev_register_callback(type, func); 17c2: 4b01 ldr r3, [pc, #4] ; (17c8 ) 17c4: 4798 blx r3 } 17c6: bd10 pop {r4, pc} 17c8: 00000fe5 .word 0x00000fe5 000017cc : int32_t usb_d_enable(void) { 17cc: b510 push {r4, lr} return _usb_d_dev_enable(); 17ce: 4b01 ldr r3, [pc, #4] ; (17d4 ) 17d0: 4798 blx r3 } 17d2: bd10 pop {r4, pc} 17d4: 00000ac1 .word 0x00000ac1 000017d8 : { _usb_d_dev_disable(); } void usb_d_attach(void) { 17d8: b510 push {r4, lr} _usb_d_dev_attach(); 17da: 4b01 ldr r3, [pc, #4] ; (17e0 ) 17dc: 4798 blx r3 } 17de: bd10 pop {r4, pc} 17e0: 00000b09 .word 0x00000b09 000017e4 : { return _usb_d_dev_get_uframe_n(); } void usb_d_set_address(const uint8_t addr) { 17e4: b510 push {r4, lr} _usb_d_dev_set_address(addr); 17e6: 4b01 ldr r3, [pc, #4] ; (17ec ) 17e8: 4798 blx r3 } 17ea: bd10 pop {r4, pc} 17ec: 00000b19 .word 0x00000b19 000017f0 : { 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) { 17f0: b5f8 push {r3, r4, r5, r6, r7, lr} int32_t rc; int8_t ep_index = _usb_d_find_ep(ep); 17f2: 4c10 ldr r4, [pc, #64] ; (1834 ) { 17f4: 0006 movs r6, r0 17f6: 000d movs r5, r1 17f8: 0017 movs r7, r2 int8_t ep_index = _usb_d_find_ep(ep); 17fa: 47a0 blx r4 struct usb_d_ep *ept = &usb_d_inst.ep[ep_index]; if (ep_index >= 0) { 17fc: 2800 cmp r0, #0 17fe: da13 bge.n 1828 return -USB_ERR_REDO; } else { ep_index = _usb_d_find_ep(0xFF); 1800: 20ff movs r0, #255 ; 0xff 1802: 47a0 blx r4 1804: 1e04 subs r4, r0, #0 if (ep_index < 0) { 1806: db12 blt.n 182e return -USB_ERR_ALLOC_FAIL; } ept = &usb_d_inst.ep[ep_index]; } rc = _usb_d_dev_ep_init(ep, attr, max_pkt_size); 1808: 003a movs r2, r7 180a: 0029 movs r1, r5 180c: 0030 movs r0, r6 180e: 4b0a ldr r3, [pc, #40] ; (1838 ) 1810: 4798 blx r3 if (rc < 0) { 1812: 2800 cmp r0, #0 1814: db07 blt.n 1826 return rc; } ept->xfer.hdr.ep = ep; ept->xfer.hdr.type = attr & USB_EP_XTYPE_MASK; 1816: 2103 movs r1, #3 return ERR_NONE; 1818: 2000 movs r0, #0 ept->xfer.hdr.ep = ep; 181a: 4b08 ldr r3, [pc, #32] ; (183c ) 181c: 0164 lsls r4, r4, #5 181e: 191a adds r2, r3, r4 ept->xfer.hdr.type = attr & USB_EP_XTYPE_MASK; 1820: 400d ands r5, r1 ept->xfer.hdr.ep = ep; 1822: 7056 strb r6, [r2, #1] ept->xfer.hdr.type = attr & USB_EP_XTYPE_MASK; 1824: 54e5 strb r5, [r4, r3] } 1826: bdf8 pop {r3, r4, r5, r6, r7, pc} return -USB_ERR_REDO; 1828: 2014 movs r0, #20 return -USB_ERR_ALLOC_FAIL; 182a: 4240 negs r0, r0 182c: e7fb b.n 1826 182e: 2015 movs r0, #21 1830: e7fb b.n 182a 1832: 46c0 nop ; (mov r8, r8) 1834: 00001589 .word 0x00001589 1838: 00000b29 .word 0x00000b29 183c: 20000310 .word 0x20000310 00001840 : return usb_d_ep_init(0, USB_EP_XTYPE_CTRL, max_pkt_size); 1840: 2100 movs r1, #0 { 1842: b510 push {r4, lr} return usb_d_ep_init(0, USB_EP_XTYPE_CTRL, max_pkt_size); 1844: 0002 movs r2, r0 1846: 0008 movs r0, r1 1848: 4b01 ldr r3, [pc, #4] ; (1850 ) 184a: 4798 blx r3 } 184c: bd10 pop {r4, pc} 184e: 46c0 nop ; (mov r8, r8) 1850: 000017f1 .word 0x000017f1 00001854 : void usb_d_ep_deinit(const uint8_t ep) { 1854: b570 push {r4, r5, r6, lr} int8_t ep_index = _usb_d_find_ep(ep); 1856: 4b07 ldr r3, [pc, #28] ; (1874 ) { 1858: 0005 movs r5, r0 int8_t ep_index = _usb_d_find_ep(ep); 185a: 4798 blx r3 185c: 1e04 subs r4, r0, #0 struct usb_d_ep *ept = &usb_d_inst.ep[ep_index]; if (ep_index < 0) { 185e: db07 blt.n 1870 return; } _usb_d_dev_ep_deinit(ep); 1860: 0028 movs r0, r5 1862: 4b05 ldr r3, [pc, #20] ; (1878 ) 1864: 4798 blx r3 ept->xfer.hdr.ep = 0xFF; 1866: 23ff movs r3, #255 ; 0xff 1868: 4804 ldr r0, [pc, #16] ; (187c ) 186a: 0164 lsls r4, r4, #5 186c: 1904 adds r4, r0, r4 186e: 7063 strb r3, [r4, #1] } 1870: bd70 pop {r4, r5, r6, pc} 1872: 46c0 nop ; (mov r8, r8) 1874: 00001589 .word 0x00001589 1878: 00000bf1 .word 0x00000bf1 187c: 20000310 .word 0x20000310 00001880 : int32_t usb_d_ep_enable(const uint8_t ep) { 1880: b570 push {r4, r5, r6, lr} int8_t ep_index = _usb_d_find_ep(ep); 1882: 4b0c ldr r3, [pc, #48] ; (18b4 ) { 1884: 0004 movs r4, r0 int8_t ep_index = _usb_d_find_ep(ep); 1886: 4798 blx r3 struct usb_d_ep *ept = &usb_d_inst.ep[ep_index]; int32_t rc; if (ep_index < 0) { 1888: 2800 cmp r0, #0 188a: db0f blt.n 18ac 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; 188c: 4d0a ldr r5, [pc, #40] ; (18b8 ) 188e: 0140 lsls r0, r0, #5 1890: 5d42 ldrb r2, [r0, r5] 1892: 182d adds r5, r5, r0 1894: 4251 negs r1, r2 1896: 414a adcs r2, r1 1898: 3201 adds r2, #1 rc = _usb_d_dev_ep_enable(ep); 189a: 0020 movs r0, r4 189c: 4b07 ldr r3, [pc, #28] ; (18bc ) ept->xfer.hdr.state = (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) ? USB_EP_S_X_SETUP : USB_EP_S_IDLE; 189e: 70aa strb r2, [r5, #2] rc = _usb_d_dev_ep_enable(ep); 18a0: 4798 blx r3 if (rc < 0) { 18a2: 2800 cmp r0, #0 18a4: da01 bge.n 18aa ept->xfer.hdr.state = USB_EP_S_DISABLED; 18a6: 2300 movs r3, #0 18a8: 70ab strb r3, [r5, #2] } return rc; } 18aa: bd70 pop {r4, r5, r6, pc} return -USB_ERR_PARAM; 18ac: 2012 movs r0, #18 18ae: 4240 negs r0, r0 18b0: e7fb b.n 18aa 18b2: 46c0 nop ; (mov r8, r8) 18b4: 00001589 .word 0x00001589 18b8: 20000310 .word 0x20000310 18bc: 00000c69 .word 0x00000c69 000018c0 : } return usb_d_inst.ep[ep_index].xfer.req; } int32_t usb_d_ep_transfer(const struct usb_d_transfer *xfer) { 18c0: b5f0 push {r4, r5, r6, r7, lr} int8_t ep_index = _usb_d_find_ep(xfer->ep); 18c2: 7a03 ldrb r3, [r0, #8] { 18c4: 0004 movs r4, r0 18c6: b08b sub sp, #44 ; 0x2c int8_t ep_index = _usb_d_find_ep(xfer->ep); 18c8: 0018 movs r0, r3 18ca: 9301 str r3, [sp, #4] 18cc: 4b32 ldr r3, [pc, #200] ; (1998 ) 18ce: 4798 blx r3 struct usb_d_ep * ept = &usb_d_inst.ep[ep_index]; bool dir = USB_EP_GET_DIR(xfer->ep), zlp = xfer->zlp; 18d0: 7a63 ldrb r3, [r4, #9] int8_t ep_index = _usb_d_find_ep(xfer->ep); 18d2: 1e06 subs r6, r0, #0 uint32_t len = xfer->size; 18d4: 6865 ldr r5, [r4, #4] bool dir = USB_EP_GET_DIR(xfer->ep), zlp = xfer->zlp; 18d6: 9302 str r3, [sp, #8] int32_t rc; volatile uint8_t state; volatile hal_atomic_t flags; if (ep_index < 0) { 18d8: db5b blt.n 1992 return -USB_ERR_PARAM; } atomic_enter_critical(&flags); 18da: 4b30 ldr r3, [pc, #192] ; (199c ) 18dc: a806 add r0, sp, #24 18de: 4798 blx r3 state = ept->xfer.hdr.state; 18e0: 0173 lsls r3, r6, #5 18e2: 9300 str r3, [sp, #0] 18e4: 9a00 ldr r2, [sp, #0] 18e6: 4b2e ldr r3, [pc, #184] ; (19a0 ) 18e8: 189e adds r6, r3, r2 18ea: 78b3 ldrb r3, [r6, #2] 18ec: aa04 add r2, sp, #16 18ee: 1dd7 adds r7, r2, #7 18f0: 703b strb r3, [r7, #0] if (state == USB_EP_S_IDLE) { 18f2: 783a ldrb r2, [r7, #0] 18f4: b2d3 uxtb r3, r2 18f6: 9303 str r3, [sp, #12] 18f8: 4b2a ldr r3, [pc, #168] ; (19a4 ) 18fa: 2a01 cmp r2, #1 18fc: d11d bne.n 193a ept->xfer.hdr.state = USB_EP_S_X_DATA; 18fe: 3202 adds r2, #2 1900: 70b2 strb r2, [r6, #2] atomic_leave_critical(&flags); 1902: a806 add r0, sp, #24 1904: 4798 blx r3 default: /* USB_EP_S_X_xxxx */ return USB_BUSY; } } if (ept->xfer.hdr.type == USB_EP_XTYPE_CTRL) { 1906: 4b26 ldr r3, [pc, #152] ; (19a0 ) 1908: 9a00 ldr r2, [sp, #0] 190a: 5cd3 ldrb r3, [r2, r3] 190c: 2b00 cmp r3, #0 190e: d01f beq.n 1950 bool dir = USB_EP_GET_DIR(xfer->ep), zlp = xfer->zlp; 1910: 9802 ldr r0, [sp, #8] 1912: 9b01 ldr r3, [sp, #4] 1914: 1e42 subs r2, r0, #1 1916: 4190 sbcs r0, r2 1918: 09d9 lsrs r1, r3, #7 191a: b2c0 uxtb r0, r0 struct usb_d_transfer trans 191c: 6823 ldr r3, [r4, #0] zlp = false; } } } rc = _usb_d_trans(xfer->ep, dir, xfer->buf, len, zlp); 191e: 7a22 ldrb r2, [r4, #8] struct usb_d_transfer trans 1920: 9307 str r3, [sp, #28] 1922: 9508 str r5, [sp, #32] 1924: 2900 cmp r1, #0 1926: d031 beq.n 198c 1928: 2380 movs r3, #128 ; 0x80 192a: 431a orrs r2, r3 192c: ab04 add r3, sp, #16 192e: 751a strb r2, [r3, #20] 1930: 7558 strb r0, [r3, #21] return _usb_d_dev_ep_trans(&trans); 1932: 4b1d ldr r3, [pc, #116] ; (19a8 ) 1934: a807 add r0, sp, #28 1936: 4798 blx r3 return rc; 1938: e008 b.n 194c atomic_leave_critical(&flags); 193a: a806 add r0, sp, #24 193c: 4798 blx r3 switch (state) { 193e: 783b ldrb r3, [r7, #0] 1940: 2001 movs r0, #1 1942: b2da uxtb r2, r3 1944: 2b06 cmp r3, #6 1946: d801 bhi.n 194c 1948: 4b18 ldr r3, [pc, #96] ; (19ac ) 194a: 5698 ldrsb r0, [r3, r2] } 194c: b00b add sp, #44 ; 0x2c 194e: bdf0 pop {r4, r5, r6, r7, pc} uint16_t req_len = USB_GET_wLength(ept->xfer.req); 1950: 7cf2 ldrb r2, [r6, #19] 1952: 7cb3 ldrb r3, [r6, #18] 1954: 0212 lsls r2, r2, #8 1956: 189b adds r3, r3, r2 1958: b29b uxth r3, r3 if (req_len == 0) { 195a: 2b00 cmp r3, #0 195c: d105 bne.n 196a ept->xfer.hdr.state = USB_EP_S_X_STATUS; 195e: 2204 movs r2, #4 zlp = true; 1960: 9803 ldr r0, [sp, #12] len = 0; 1962: 001d movs r5, r3 dir = true; 1964: 0001 movs r1, r0 ept->xfer.hdr.state = USB_EP_S_X_STATUS; 1966: 70b2 strb r2, [r6, #2] 1968: e7d8 b.n 191c if (len > req_len) { 196a: 429d cmp r5, r3 196c: d900 bls.n 1970 196e: 001d movs r5, r3 dir = (USB_GET_bmRequestType(ept->xfer.req) & USB_REQ_TYPE_IN); 1970: 490b ldr r1, [pc, #44] ; (19a0 ) zlp = false; 1972: 2000 movs r0, #0 dir = (USB_GET_bmRequestType(ept->xfer.req) & USB_REQ_TYPE_IN); 1974: 468c mov ip, r1 1976: 9a00 ldr r2, [sp, #0] 1978: 0001 movs r1, r0 197a: 4462 add r2, ip if (dir) { 197c: 7b12 ldrb r2, [r2, #12] 197e: 2a7f cmp r2, #127 ; 0x7f 1980: d9cc bls.n 191c zlp = (req_len > len); 1982: 429d cmp r5, r3 1984: 419b sbcs r3, r3 dir = (USB_GET_bmRequestType(ept->xfer.req) & USB_REQ_TYPE_IN); 1986: 3101 adds r1, #1 zlp = (req_len > len); 1988: 4258 negs r0, r3 198a: e7c7 b.n 191c struct usb_d_transfer trans 198c: 230f movs r3, #15 198e: 401a ands r2, r3 1990: e7cc b.n 192c return -USB_ERR_PARAM; 1992: 2012 movs r0, #18 1994: 4240 negs r0, r0 1996: e7d9 b.n 194c 1998: 00001589 .word 0x00001589 199c: 000022c9 .word 0x000022c9 19a0: 20000310 .word 0x20000310 19a4: 000022d7 .word 0x000022d7 19a8: 00000ec9 .word 0x00000ec9 19ac: 000023d6 .word 0x000023d6 000019b0 : } return ERR_NONE; } int32_t usb_d_ep_halt(const uint8_t ep, const enum usb_ep_halt_ctrl ctrl) { 19b0: b5f8 push {r3, r4, r5, r6, r7, lr} 19b2: 0005 movs r5, r0 19b4: 1e0e subs r6, r1, #0 if (ctrl == USB_EP_HALT_CLR) { 19b6: d11a bne.n 19ee int8_t ep_index = _usb_d_find_ep(ep); 19b8: 4b12 ldr r3, [pc, #72] ; (1a04 ) 19ba: 4798 blx r3 19bc: 1e04 subs r4, r0, #0 if (ep_index < 0) { 19be: db1d blt.n 19fc if (_usb_d_dev_ep_stall(ep, USB_EP_STALL_GET)) { 19c0: 2102 movs r1, #2 19c2: 0028 movs r0, r5 19c4: 4f10 ldr r7, [pc, #64] ; (1a08 ) 19c6: 47b8 blx r7 19c8: 2800 cmp r0, #0 19ca: d00f beq.n 19ec rc = _usb_d_dev_ep_stall(ep, USB_EP_STALL_CLR); 19cc: 0031 movs r1, r6 19ce: 0028 movs r0, r5 19d0: 47b8 blx r7 if (rc < 0) { 19d2: 2800 cmp r0, #0 19d4: db0a blt.n 19ec ept->xfer.hdr.state = USB_EP_S_IDLE; 19d6: 480d ldr r0, [pc, #52] ; (1a0c ) 19d8: 4b0d ldr r3, [pc, #52] ; (1a10 ) 19da: 0164 lsls r4, r4, #5 19dc: 1824 adds r4, r4, r0 19de: 8063 strh r3, [r4, #2] ept->callbacks.xfer(ep, USB_XFER_UNHALT, NULL); 19e0: 0032 movs r2, r6 19e2: 2103 movs r1, #3 19e4: 0028 movs r0, r5 19e6: 69e3 ldr r3, [r4, #28] 19e8: 4798 blx r3 return ERR_NONE; 19ea: 0030 movs r0, r6 } else if (ctrl == USB_EP_HALT_SET) { return _usb_d_dev_ep_stall(ep, USB_EP_STALL_SET); } else { return _usb_d_dev_ep_stall(ep, USB_EP_STALL_GET); } } 19ec: bdf8 pop {r3, r4, r5, r6, r7, pc} } else if (ctrl == USB_EP_HALT_SET) { 19ee: 4b06 ldr r3, [pc, #24] ; (1a08 ) 19f0: 2901 cmp r1, #1 19f2: d000 beq.n 19f6 return _usb_d_dev_ep_stall(ep, USB_EP_STALL_GET); 19f4: 2102 movs r1, #2 19f6: 0028 movs r0, r5 19f8: 4798 blx r3 19fa: e7f7 b.n 19ec return -USB_ERR_PARAM; 19fc: 2012 movs r0, #18 19fe: 4240 negs r0, r0 1a00: e7f4 b.n 19ec 1a02: 46c0 nop ; (mov r8, r8) 1a04: 00001589 .word 0x00001589 1a08: 00000da9 .word 0x00000da9 1a0c: 20000310 .word 0x20000310 1a10: 00000301 .word 0x00000301 00001a14 : void usb_d_ep_register_callback(const uint8_t ep, const enum usb_d_ep_cb_type type, const FUNC_PTR func) { 1a14: b570 push {r4, r5, r6, lr} int8_t ep_index = _usb_d_find_ep(ep); 1a16: 4b0f ldr r3, [pc, #60] ; (1a54 ) { 1a18: 0014 movs r4, r2 1a1a: 000d movs r5, r1 int8_t ep_index = _usb_d_find_ep(ep); 1a1c: 4798 blx r3 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; 1a1e: 2c00 cmp r4, #0 1a20: d100 bne.n 1a24 1a22: 4c0d ldr r4, [pc, #52] ; (1a58 ) if (ep_index < 0) { 1a24: 2800 cmp r0, #0 1a26: db09 blt.n 1a3c return; } switch (type) { 1a28: 2d01 cmp r5, #1 1a2a: d008 beq.n 1a3e 1a2c: 2d02 cmp r5, #2 1a2e: d00b beq.n 1a48 1a30: 2d00 cmp r5, #0 1a32: d103 bne.n 1a3c case USB_D_EP_CB_SETUP: ept->callbacks.req = (usb_d_ep_cb_setup_t)f; 1a34: 4b09 ldr r3, [pc, #36] ; (1a5c ) 1a36: 0140 lsls r0, r0, #5 1a38: 1818 adds r0, r3, r0 1a3a: 6144 str r4, [r0, #20] ept->callbacks.xfer = (usb_d_ep_cb_xfer_t)f; break; default: break; } } 1a3c: bd70 pop {r4, r5, r6, pc} ept->callbacks.more = (usb_d_ep_cb_more_t)f; 1a3e: 4b07 ldr r3, [pc, #28] ; (1a5c ) 1a40: 0140 lsls r0, r0, #5 1a42: 1818 adds r0, r3, r0 1a44: 6184 str r4, [r0, #24] break; 1a46: e7f9 b.n 1a3c ept->callbacks.xfer = (usb_d_ep_cb_xfer_t)f; 1a48: 4b04 ldr r3, [pc, #16] ; (1a5c ) 1a4a: 0140 lsls r0, r0, #5 1a4c: 1818 adds r0, r3, r0 1a4e: 61c4 str r4, [r0, #28] break; 1a50: e7f4 b.n 1a3c 1a52: 46c0 nop ; (mov r8, r8) 1a54: 00001589 .word 0x00001589 1a58: 000015bd .word 0x000015bd 1a5c: 20000310 .word 0x20000310 00001a60
: #include int main(void) { 1a60: b510 push {r4, lr} /* Initializes MCU, drivers and middleware */ atmel_start_init(); 1a62: 4b01 ldr r3, [pc, #4] ; (1a68 ) 1a64: 4798 blx r3 /* Replace with your application code */ while (1) { 1a66: e7fe b.n 1a66 1a68: 00001ce9 .word 0x00001ce9 00001a6c <_gpio_set_pin_function>: /** * \brief Set gpio pin function */ static inline void _gpio_set_pin_function(const uint32_t gpio, const uint32_t function) { 1a6c: b530 push {r4, r5, lr} bool value) { uint8_t tmp; PORT_CRITICAL_SECTION_ENTER(); tmp = ((Port *)hw)->Group[submodule_index].PINCFG[index].reg; tmp &= ~PORT_PINCFG_PMUXEN; 1a6e: 2401 movs r4, #1 tmp = ((Port *)hw)->Group[submodule_index].PINCFG[index].reg; 1a70: 4b0c ldr r3, [pc, #48] ; (1aa4 <_gpio_set_pin_function+0x38>) uint8_t port = GPIO_PORT(gpio); uint8_t pin = GPIO_PIN(gpio); 1a72: b2c5 uxtb r5, r0 1a74: 18c0 adds r0, r0, r3 1a76: 7803 ldrb r3, [r0, #0] } else { hri_port_write_PINCFG_PMUXEN_bit(PORT, port, pin, true); if (pin & 1) { // Odd numbered pin hri_port_write_PMUX_PMUXO_bf(PORT, port, pin >> 1, function & 0xffff); 1a78: b2ca uxtb r2, r1 tmp &= ~PORT_PINCFG_PMUXEN; 1a7a: 43a3 bics r3, r4 tmp = ((Port *)hw)->Group[submodule_index].PMUX[index].reg; 1a7c: 490a ldr r1, [pc, #40] ; (1aa8 <_gpio_set_pin_function+0x3c>) tmp |= value << PORT_PINCFG_PMUXEN_Pos; 1a7e: 4323 orrs r3, r4 ((Port *)hw)->Group[submodule_index].PINCFG[index].reg = tmp; 1a80: 7003 strb r3, [r0, #0] tmp = ((Port *)hw)->Group[submodule_index].PMUX[index].reg; 1a82: 086b lsrs r3, r5, #1 1a84: 185b adds r3, r3, r1 tmp &= ~PORT_PMUX_PMUXO_Msk; 1a86: 200f movs r0, #15 tmp = ((Port *)hw)->Group[submodule_index].PMUX[index].reg; 1a88: 7819 ldrb r1, [r3, #0] if (pin & 1) { 1a8a: 4225 tst r5, r4 1a8c: d005 beq.n 1a9a <_gpio_set_pin_function+0x2e> tmp &= ~PORT_PMUX_PMUXO_Msk; 1a8e: 4001 ands r1, r0 tmp |= PORT_PMUX_PMUXO(data); 1a90: 0112 lsls r2, r2, #4 1a92: 4311 orrs r1, r2 1a94: b2c9 uxtb r1, r1 ((Port *)hw)->Group[submodule_index].PMUX[index].reg = tmp; 1a96: 7019 strb r1, [r3, #0] } else { // Even numbered pin hri_port_write_PMUX_PMUXE_bf(PORT, port, pin >> 1, function & 0xffff); } } } 1a98: bd30 pop {r4, r5, pc} tmp &= ~PORT_PMUX_PMUXE_Msk; 1a9a: 4381 bics r1, r0 tmp |= PORT_PMUX_PMUXE(data); 1a9c: 430a orrs r2, r1 ((Port *)hw)->Group[submodule_index].PMUX[index].reg = tmp; 1a9e: 701a strb r2, [r3, #0] 1aa0: e7fa b.n 1a98 <_gpio_set_pin_function+0x2c> 1aa2: 46c0 nop ; (mov r8, r8) 1aa4: 41004440 .word 0x41004440 1aa8: 41004430 .word 0x41004430 00001aac : #include struct usart_sync_descriptor USART_0; void USART_0_PORT_init(void) { 1aac: b510 push {r4, lr} * found in the header files for the device * */ static inline void gpio_set_pin_function(const uint32_t pin, uint32_t function) { _gpio_set_pin_function(pin, function); 1aae: 2016 movs r0, #22 1ab0: 4c03 ldr r4, [pc, #12] ; (1ac0 ) 1ab2: 4904 ldr r1, [pc, #16] ; (1ac4 ) 1ab4: 47a0 blx r4 1ab6: 2017 movs r0, #23 1ab8: 4903 ldr r1, [pc, #12] ; (1ac8 ) 1aba: 47a0 blx r4 gpio_set_pin_function(PA22, PINMUX_PA22C_SERCOM3_PAD0); gpio_set_pin_function(PA23, PINMUX_PA23C_SERCOM3_PAD1); } 1abc: bd10 pop {r4, pc} 1abe: 46c0 nop ; (mov r8, r8) 1ac0: 00001a6d .word 0x00001a6d 1ac4: 00160002 .word 0x00160002 1ac8: 00170002 .word 0x00170002 00001acc : peripheral = (uint32_t)_pm_get_apbb_index(module); PM->APBBMASK.reg |= 1 << peripheral; } break; case PM_BUS_APBC: PM->APBCMASK.reg |= 1 << peripheral; 1acc: 2320 movs r3, #32 1ace: 4a04 ldr r2, [pc, #16] ; (1ae0 ) 1ad0: 6a11 ldr r1, [r2, #32] 1ad2: 430b orrs r3, r1 1ad4: 6213 str r3, [r2, #32] ((Gclk *)hw)->CLKCTRL.reg = data; 1ad6: 4b03 ldr r3, [pc, #12] ; (1ae4 ) 1ad8: 4a03 ldr r2, [pc, #12] ; (1ae8 ) 1ada: 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); } 1adc: 4770 bx lr 1ade: 46c0 nop ; (mov r8, r8) 1ae0: 40000400 .word 0x40000400 1ae4: 40000c00 .word 0x40000c00 1ae8: 00004017 .word 0x00004017 00001aec : void USART_0_init(void) { 1aec: b510 push {r4, lr} USART_0_CLOCK_init(); 1aee: 4b05 ldr r3, [pc, #20] ; (1b04 ) 1af0: 4798 blx r3 usart_sync_init(&USART_0, SERCOM3, (void *)NULL); 1af2: 2200 movs r2, #0 1af4: 4904 ldr r1, [pc, #16] ; (1b08 ) 1af6: 4b05 ldr r3, [pc, #20] ; (1b0c ) 1af8: 4805 ldr r0, [pc, #20] ; (1b10 ) 1afa: 4798 blx r3 USART_0_PORT_init(); 1afc: 4b05 ldr r3, [pc, #20] ; (1b14 ) 1afe: 4798 blx r3 } 1b00: bd10 pop {r4, pc} 1b02: 46c0 nop ; (mov r8, r8) 1b04: 00001acd .word 0x00001acd 1b08: 42001400 .word 0x42001400 1b0c: 00001465 .word 0x00001465 1b10: 20000390 .word 0x20000390 1b14: 00001aad .word 0x00001aad 00001b18 : void USB_DEVICE_INSTANCE_PORT_init(void) { 1b18: b5f8 push {r3, r4, r5, r6, r7, lr} ((Port *)hw)->Group[submodule_index].DIRSET.reg = mask; 1b1a: 25c0 movs r5, #192 ; 0xc0 1b1c: 2380 movs r3, #128 ; 0x80 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; 1b1e: 2780 movs r7, #128 ; 0x80 1b20: 4c11 ldr r4, [pc, #68] ; (1b68 ) 1b22: 4a12 ldr r2, [pc, #72] ; (1b6c ) ((Port *)hw)->Group[submodule_index].DIRSET.reg = mask; 1b24: 05ed lsls r5, r5, #23 ((Port *)hw)->Group[submodule_index].WRCONFIG.reg = data; 1b26: 05ff lsls r7, r7, #23 ((Port *)hw)->Group[submodule_index].DIRSET.reg = mask; 1b28: 045b lsls r3, r3, #17 1b2a: 60ab str r3, [r5, #8] ((Port *)hw)->Group[submodule_index].WRCONFIG.reg = data; 1b2c: 62a7 str r7, [r4, #40] ; 0x28 1b2e: 62a2 str r2, [r4, #40] ; 0x28 ((Port *)hw)->Group[submodule_index].PINCFG[index].reg &= ~PORT_PINCFG_PULLEN; 1b30: 0022 movs r2, r4 1b32: 2604 movs r6, #4 ((Port *)hw)->Group[submodule_index].OUTCLR.reg = mask; 1b34: 616b str r3, [r5, #20] ((Port *)hw)->Group[submodule_index].PINCFG[index].reg &= ~PORT_PINCFG_PULLEN; 1b36: 3258 adds r2, #88 ; 0x58 1b38: 7813 ldrb r3, [r2, #0] 1b3a: 2018 movs r0, #24 1b3c: 43b3 bics r3, r6 1b3e: 7013 strb r3, [r2, #0] 1b40: 490b ldr r1, [pc, #44] ; (1b70 ) 1b42: 4b0c ldr r3, [pc, #48] ; (1b74 ) 1b44: 4798 blx r3 ((Port *)hw)->Group[submodule_index].DIRSET.reg = mask; 1b46: 2380 movs r3, #128 ; 0x80 ((Port *)hw)->Group[submodule_index].WRCONFIG.reg = data; 1b48: 4a0b ldr r2, [pc, #44] ; (1b78 ) ((Port *)hw)->Group[submodule_index].DIRSET.reg = mask; 1b4a: 049b lsls r3, r3, #18 1b4c: 60ab str r3, [r5, #8] ((Port *)hw)->Group[submodule_index].WRCONFIG.reg = data; 1b4e: 62a7 str r7, [r4, #40] ; 0x28 1b50: 62a2 str r2, [r4, #40] ; 0x28 ((Port *)hw)->Group[submodule_index].OUTCLR.reg = mask; 1b52: 616b str r3, [r5, #20] ((Port *)hw)->Group[submodule_index].PINCFG[index].reg &= ~PORT_PINCFG_PULLEN; 1b54: 3459 adds r4, #89 ; 0x59 1b56: 7823 ldrb r3, [r4, #0] 1b58: 2019 movs r0, #25 1b5a: 43b3 bics r3, r6 1b5c: 7023 strb r3, [r4, #0] 1b5e: 4907 ldr r1, [pc, #28] ; (1b7c ) 1b60: 4b04 ldr r3, [pc, #16] ; (1b74 ) 1b62: 4798 blx r3 // E // F // G // H PINMUX_PA25G_USB_DP); } 1b64: bdf8 pop {r3, r4, r5, r6, r7, pc} 1b66: 46c0 nop ; (mov r8, r8) 1b68: 41004400 .word 0x41004400 1b6c: c0000100 .word 0xc0000100 1b70: 00180006 .word 0x00180006 1b74: 00001a6d .word 0x00001a6d 1b78: c0000200 .word 0xc0000200 1b7c: 00190006 .word 0x00190006 00001b80 : PM->APBBMASK.reg |= 1 << peripheral; 1b80: 2220 movs r2, #32 1b82: 4b06 ldr r3, [pc, #24] ; (1b9c ) 1b84: 69d9 ldr r1, [r3, #28] 1b86: 430a orrs r2, r1 1b88: 61da str r2, [r3, #28] PM->AHBMASK.reg |= 1 << peripheral; 1b8a: 2240 movs r2, #64 ; 0x40 1b8c: 6959 ldr r1, [r3, #20] 1b8e: 430a orrs r2, r1 1b90: 615a str r2, [r3, #20] 1b92: 4b03 ldr r3, [pc, #12] ; (1ba0 ) 1b94: 4a03 ldr r2, [pc, #12] ; (1ba4 ) 1b96: 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); } 1b98: 4770 bx lr 1b9a: 46c0 nop ; (mov r8, r8) 1b9c: 40000400 .word 0x40000400 1ba0: 40000c00 .word 0x40000c00 1ba4: 00004006 .word 0x00004006 00001ba8 : void USB_DEVICE_INSTANCE_init(void) { 1ba8: b510 push {r4, lr} USB_DEVICE_INSTANCE_CLOCK_init(); 1baa: 4b03 ldr r3, [pc, #12] ; (1bb8 ) 1bac: 4798 blx r3 usb_d_init(); 1bae: 4b03 ldr r3, [pc, #12] ; (1bbc ) 1bb0: 4798 blx r3 USB_DEVICE_INSTANCE_PORT_init(); 1bb2: 4b03 ldr r3, [pc, #12] ; (1bc0 ) 1bb4: 4798 blx r3 } 1bb6: bd10 pop {r4, pc} 1bb8: 00001b81 .word 0x00001b81 1bbc: 00001759 .word 0x00001759 1bc0: 00001b19 .word 0x00001b19 00001bc4 : void system_init(void) { 1bc4: b510 push {r4, lr} * Currently the following initialization functions are supported: * - System clock initialization */ static inline void init_mcu(void) { _init_chip(); 1bc6: 4b03 ldr r3, [pc, #12] ; (1bd4 ) 1bc8: 4798 blx r3 init_mcu(); USART_0_init(); 1bca: 4b03 ldr r3, [pc, #12] ; (1bd8 ) 1bcc: 4798 blx r3 USB_DEVICE_INSTANCE_init(); 1bce: 4b03 ldr r3, [pc, #12] ; (1bdc ) 1bd0: 4798 blx r3 } 1bd2: bd10 pop {r4, pc} 1bd4: 00001241 .word 0x00001241 1bd8: 00001aed .word 0x00001aed 1bdc: 00001ba9 .word 0x00001ba9 00001be0 : return ((Sercom *)hw)->SPI.SYNCBUSY.reg & reg; } static inline void hri_sercomusart_wait_for_sync(const void *const hw, hri_sercomusart_syncbusy_reg_t reg) { while (((Sercom *)hw)->USART.SYNCBUSY.reg & reg) { 1be0: 69c3 ldr r3, [r0, #28] 1be2: 4219 tst r1, r3 1be4: d1fc bne.n 1be0 }; } 1be6: 4770 bx lr 00001be8 : } static inline void hri_sercomusart_clear_CTRLA_ENABLE_bit(const void *const hw) { SERCOM_CRITICAL_SECTION_ENTER(); ((Sercom *)hw)->USART.CTRLA.reg &= ~SERCOM_USART_CTRLA_ENABLE; 1be8: 2202 movs r2, #2 { 1bea: b510 push {r4, lr} ((Sercom *)hw)->USART.CTRLA.reg &= ~SERCOM_USART_CTRLA_ENABLE; 1bec: 6803 ldr r3, [r0, #0] hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_SWRST | SERCOM_USART_SYNCBUSY_ENABLE); 1bee: 2103 movs r1, #3 ((Sercom *)hw)->USART.CTRLA.reg &= ~SERCOM_USART_CTRLA_ENABLE; 1bf0: 4393 bics r3, r2 1bf2: 6003 str r3, [r0, #0] hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_SWRST | SERCOM_USART_SYNCBUSY_ENABLE); 1bf4: 4b01 ldr r3, [pc, #4] ; (1bfc ) 1bf6: 4798 blx r3 SERCOM_CRITICAL_SECTION_LEAVE(); } 1bf8: bd10 pop {r4, pc} 1bfa: 46c0 nop ; (mov r8, r8) 1bfc: 00001be1 .word 0x00001be1 00001c00 <_usart_init>: { #ifdef _UNIT_TEST_ return ((uint32_t)hw - (uint32_t)SERCOM0) / sizeof(Sercom); #endif return ((uint32_t)hw - (uint32_t)SERCOM0) >> 10; 1c00: 4b1b ldr r3, [pc, #108] ; (1c70 <_usart_init+0x70>) * \param[in] hw The pointer to hardware instance * * \return The status of initialization */ static int32_t _usart_init(void *const hw) { 1c02: b570 push {r4, r5, r6, lr} return ((uint32_t)hw - (uint32_t)SERCOM0) >> 10; 1c04: 18c3 adds r3, r0, r3 1c06: 0a9b lsrs r3, r3, #10 if (_usarts[i].number == sercom_offset) { 1c08: b2db uxtb r3, r3 { 1c0a: 0004 movs r4, r0 if (_usarts[i].number == sercom_offset) { 1c0c: 2b03 cmp r3, #3 1c0e: d004 beq.n 1c1a <_usart_init+0x1a> ASSERT(false); 1c10: 2000 movs r0, #0 1c12: 4a18 ldr r2, [pc, #96] ; (1c74 <_usart_init+0x74>) 1c14: 4918 ldr r1, [pc, #96] ; (1c78 <_usart_init+0x78>) 1c16: 4b19 ldr r3, [pc, #100] ; (1c7c <_usart_init+0x7c>) 1c18: 4798 blx r3 return ((Sercom *)hw)->USART.SYNCBUSY.reg & reg; 1c1a: 69e3 ldr r3, [r4, #28] 1c1c: 4d18 ldr r5, [pc, #96] ; (1c80 <_usart_init+0x80>) uint8_t i = _get_sercom_index(hw); if (!hri_sercomusart_is_syncing(hw, SERCOM_USART_SYNCBUSY_SWRST)) { 1c1e: 07db lsls r3, r3, #31 1c20: d411 bmi.n 1c46 <_usart_init+0x46> 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; tmp &= mask; 1c22: 2602 movs r6, #2 hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_SWRST | SERCOM_USART_SYNCBUSY_ENABLE); 1c24: 2103 movs r1, #3 1c26: 0020 movs r0, r4 1c28: 47a8 blx r5 tmp = ((Sercom *)hw)->USART.CTRLA.reg; 1c2a: 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)) { 1c2c: 4233 tst r3, r6 1c2e: d005 beq.n 1c3c <_usart_init+0x3c> hri_sercomusart_clear_CTRLA_ENABLE_bit(hw); 1c30: 0020 movs r0, r4 1c32: 4b14 ldr r3, [pc, #80] ; (1c84 <_usart_init+0x84>) 1c34: 4798 blx r3 hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_ENABLE); 1c36: 0031 movs r1, r6 1c38: 0020 movs r0, r4 1c3a: 47a8 blx r5 } 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; 1c3c: 2305 movs r3, #5 hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_SWRST | SERCOM_USART_SYNCBUSY_ENABLE); 1c3e: 2103 movs r1, #3 1c40: 0020 movs r0, r4 ((Sercom *)hw)->USART.CTRLA.reg = data; 1c42: 6023 str r3, [r4, #0] hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_SWRST | SERCOM_USART_SYNCBUSY_ENABLE); 1c44: 47a8 blx r5 } hri_sercomusart_write_CTRLA_reg(hw, SERCOM_USART_CTRLA_SWRST | mode); } hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_SWRST); 1c46: 0020 movs r0, r4 1c48: 2101 movs r1, #1 1c4a: 47a8 blx r5 ((Sercom *)hw)->USART.CTRLA.reg = data; 1c4c: 4b0e ldr r3, [pc, #56] ; (1c88 <_usart_init+0x88>) hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_SWRST | SERCOM_USART_SYNCBUSY_ENABLE); 1c4e: 0020 movs r0, r4 ((Sercom *)hw)->USART.CTRLA.reg = data; 1c50: 6023 str r3, [r4, #0] hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_SWRST | SERCOM_USART_SYNCBUSY_ENABLE); 1c52: 2103 movs r1, #3 1c54: 47a8 blx r5 } 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; 1c56: 23c0 movs r3, #192 ; 0xc0 1c58: 029b lsls r3, r3, #10 hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_MASK); 1c5a: 0020 movs r0, r4 ((Sercom *)hw)->USART.CTRLB.reg = data; 1c5c: 6063 str r3, [r4, #4] hri_sercomusart_wait_for_sync(hw, SERCOM_USART_SYNCBUSY_MASK); 1c5e: 2107 movs r1, #7 1c60: 47a8 blx r5 } 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; 1c62: 2000 movs r0, #0 ((Sercom *)hw)->USART.BAUD.reg = data; 1c64: 4b09 ldr r3, [pc, #36] ; (1c8c <_usart_init+0x8c>) 1c66: 81a3 strh r3, [r4, #12] ((Sercom *)hw)->USART.RXPL.reg = data; 1c68: 73a0 strb r0, [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; 1c6a: 3430 adds r4, #48 ; 0x30 1c6c: 7020 strb r0, [r4, #0] hri_sercomusart_write_RXPL_reg(hw, _usarts[i].rxpl); hri_sercomusart_write_DBGCTRL_reg(hw, _usarts[i].debug_ctrl); return ERR_NONE; } 1c6e: bd70 pop {r4, r5, r6, pc} 1c70: bdfff800 .word 0xbdfff800 1c74: 0000023a .word 0x0000023a 1c78: 000023e4 .word 0x000023e4 1c7c: 000012c5 .word 0x000012c5 1c80: 00001be1 .word 0x00001be1 1c84: 00001be9 .word 0x00001be9 1c88: 40100004 .word 0x40100004 1c8c: fffff62b .word 0xfffff62b 00001c90 <_usart_sync_init>: { 1c90: b570 push {r4, r5, r6, lr} 1c92: 0005 movs r5, r0 ASSERT(device); 1c94: 1e43 subs r3, r0, #1 1c96: 4198 sbcs r0, r3 { 1c98: 000c movs r4, r1 ASSERT(device); 1c9a: 22b4 movs r2, #180 ; 0xb4 1c9c: 4904 ldr r1, [pc, #16] ; (1cb0 <_usart_sync_init+0x20>) 1c9e: 4b05 ldr r3, [pc, #20] ; (1cb4 <_usart_sync_init+0x24>) 1ca0: b2c0 uxtb r0, r0 1ca2: 4798 blx r3 device->hw = hw; 1ca4: 602c str r4, [r5, #0] return _usart_init(hw); 1ca6: 0020 movs r0, r4 1ca8: 4b03 ldr r3, [pc, #12] ; (1cb8 <_usart_sync_init+0x28>) 1caa: 4798 blx r3 } 1cac: bd70 pop {r4, r5, r6, pc} 1cae: 46c0 nop ; (mov r8, r8) 1cb0: 000023e4 .word 0x000023e4 1cb4: 000012c5 .word 0x000012c5 1cb8: 00001c01 .word 0x00001c01 00001cbc <_usart_sync_write_byte>: hri_sercomusart_write_DATA_reg(device->hw, data); 1cbc: 6803 ldr r3, [r0, #0] ((Sercom *)hw)->USART.DATA.reg = data; 1cbe: 8519 strh r1, [r3, #40] ; 0x28 } 1cc0: 4770 bx lr 00001cc2 <_usart_sync_read_byte>: return hri_sercomusart_read_DATA_reg(device->hw); 1cc2: 6803 ldr r3, [r0, #0] return ((Sercom *)hw)->USART.DATA.reg; 1cc4: 8d18 ldrh r0, [r3, #40] ; 0x28 1cc6: b2c0 uxtb r0, r0 } 1cc8: 4770 bx lr 00001cca <_usart_sync_is_ready_to_send>: return hri_sercomusart_get_interrupt_DRE_bit(device->hw); 1cca: 6803 ldr r3, [r0, #0] return (((Sercom *)hw)->USART.INTFLAG.reg & SERCOM_USART_INTFLAG_DRE) >> SERCOM_USART_INTFLAG_DRE_Pos; 1ccc: 7e18 ldrb r0, [r3, #24] 1cce: 2301 movs r3, #1 1cd0: 4018 ands r0, r3 } 1cd2: 4770 bx lr 00001cd4 <_usart_sync_is_transmit_done>: return hri_sercomusart_get_interrupt_TXC_bit(device->hw); 1cd4: 6803 ldr r3, [r0, #0] return (((Sercom *)hw)->USART.INTFLAG.reg & SERCOM_USART_INTFLAG_TXC) >> SERCOM_USART_INTFLAG_TXC_Pos; 1cd6: 7e18 ldrb r0, [r3, #24] 1cd8: 0780 lsls r0, r0, #30 1cda: 0fc0 lsrs r0, r0, #31 } 1cdc: 4770 bx lr 00001cde <_usart_sync_is_byte_received>: return hri_sercomusart_get_interrupt_RXC_bit(device->hw); 1cde: 6803 ldr r3, [r0, #0] return (((Sercom *)hw)->USART.INTFLAG.reg & SERCOM_USART_INTFLAG_RXC) >> SERCOM_USART_INTFLAG_RXC_Pos; 1ce0: 7e18 ldrb r0, [r3, #24] 1ce2: 0740 lsls r0, r0, #29 1ce4: 0fc0 lsrs r0, r0, #31 } 1ce6: 4770 bx lr 00001ce8 : /** * Initializes MCU, drivers and middleware in the project **/ void atmel_start_init(void) { 1ce8: b510 push {r4, lr} system_init(); 1cea: 4b02 ldr r3, [pc, #8] ; (1cf4 ) 1cec: 4798 blx r3 usb_init(); 1cee: 4b02 ldr r3, [pc, #8] ; (1cf8 ) 1cf0: 4798 blx r3 } 1cf2: bd10 pop {r4, pc} 1cf4: 00001bc5 .word 0x00001bc5 1cf8: 00001301 .word 0x00001301 00001cfc : /** * \brief Unconfig, close all interfaces */ static void usbdc_unconfig(void) { struct usbdf_driver *func = (struct usbdf_driver *)usbdc.func_list.head; 1cfc: 4b06 ldr r3, [pc, #24] ; (1d18 ) { 1cfe: b510 push {r4, lr} struct usbdf_driver *func = (struct usbdf_driver *)usbdc.func_list.head; 1d00: 691c ldr r4, [r3, #16] while (NULL != func) { 1d02: 2c00 cmp r4, #0 1d04: d100 bne.n 1d08 func->ctrl(func, USBDF_DISABLE, NULL); func = func->next; } } 1d06: bd10 pop {r4, pc} func->ctrl(func, USBDF_DISABLE, NULL); 1d08: 0020 movs r0, r4 1d0a: 6863 ldr r3, [r4, #4] 1d0c: 2200 movs r2, #0 1d0e: 2101 movs r1, #1 1d10: 4798 blx r3 func = func->next; 1d12: 6824 ldr r4, [r4, #0] 1d14: e7f5 b.n 1d02 1d16: 46c0 nop ; (mov r8, r8) 1d18: 2000039c .word 0x2000039c 00001d1c : } } /** Invoke all registered Change notification callbacks. */ static void usbdc_change_notify(enum usbdc_change_type change, uint32_t value) { 1d1c: b570 push {r4, r5, r6, lr} 1d1e: 0005 movs r5, r0 1d20: 000e movs r6, r1 struct usbdc_change_handler *cg = (struct usbdc_change_handler *)usbdc.handlers.change_list.head; 1d22: 4b06 ldr r3, [pc, #24] ; (1d3c ) 1d24: 68dc ldr r4, [r3, #12] while (cg != NULL) { 1d26: 2c00 cmp r4, #0 1d28: d100 bne.n 1d2c if (NULL != cg->cb) { cg->cb(change, value); } cg = cg->next; } } 1d2a: bd70 pop {r4, r5, r6, pc} if (NULL != cg->cb) { 1d2c: 6863 ldr r3, [r4, #4] 1d2e: 2b00 cmp r3, #0 1d30: d002 beq.n 1d38 cg->cb(change, value); 1d32: 0031 movs r1, r6 1d34: 0028 movs r0, r5 1d36: 4798 blx r3 cg = cg->next; 1d38: 6824 ldr r4, [r4, #0] 1d3a: e7f4 b.n 1d26 1d3c: 2000039c .word 0x2000039c 00001d40 : /** 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) { 1d40: b5f8 push {r3, r4, r5, r6, r7, lr} 1d42: 0005 movs r5, r0 1d44: 000e movs r6, r1 1d46: 0017 movs r7, r2 struct usbdc_req_handler *h = (struct usbdc_req_handler *)usbdc.handlers.req_list.head; 1d48: 4b0b ldr r3, [pc, #44] ; (1d78 ) 1d4a: 689c ldr r4, [r3, #8] int32_t rc; while (h != NULL) { 1d4c: 2c00 cmp r4, #0 1d4e: d101 bne.n 1d54 return -1; } } h = h->next; } return false; 1d50: 0020 movs r0, r4 } 1d52: bdf8 pop {r3, r4, r5, r6, r7, pc} if (NULL != h->cb) { 1d54: 6863 ldr r3, [r4, #4] 1d56: 2b00 cmp r3, #0 1d58: d101 bne.n 1d5e h = h->next; 1d5a: 6824 ldr r4, [r4, #0] 1d5c: e7f6 b.n 1d4c rc = h->cb(ep, req, stage); 1d5e: 003a movs r2, r7 1d60: 0031 movs r1, r6 1d62: 0028 movs r0, r5 1d64: 4798 blx r3 if (0 == rc) { 1d66: 2800 cmp r0, #0 1d68: d004 beq.n 1d74 } else if (ERR_NOT_FOUND != rc) { 1d6a: 300a adds r0, #10 1d6c: d0f5 beq.n 1d5a return -1; 1d6e: 2001 movs r0, #1 1d70: 4240 negs r0, r0 1d72: e7ee b.n 1d52 return true; 1d74: 2001 movs r0, #1 1d76: e7ec b.n 1d52 1d78: 2000039c .word 0x2000039c 00001d7c : struct usbdc_sof_handler *sof = (struct usbdc_sof_handler *)usbdc.handlers.sof_list.head; 1d7c: 4b05 ldr r3, [pc, #20] ; (1d94 ) /** * \brief Callback invoked on USB device SOF */ static void usbd_sof_cb(void) { 1d7e: b510 push {r4, lr} struct usbdc_sof_handler *sof = (struct usbdc_sof_handler *)usbdc.handlers.sof_list.head; 1d80: 685c ldr r4, [r3, #4] while (sof != NULL) { 1d82: 2c00 cmp r4, #0 1d84: d100 bne.n 1d88 usbdc_sof_notify(); } 1d86: bd10 pop {r4, pc} if (NULL != sof->cb) { 1d88: 6863 ldr r3, [r4, #4] 1d8a: 2b00 cmp r3, #0 1d8c: d000 beq.n 1d90 sof->cb(); 1d8e: 4798 blx r3 sof = sof->next; 1d90: 6824 ldr r4, [r4, #0] 1d92: e7f6 b.n 1d82 1d94: 2000039c .word 0x2000039c 00001d98 : * \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) { 1d98: b510 push {r4, lr} 1d9a: 0014 movs r4, r2 (void)ep; switch (code) { 1d9c: 2900 cmp r1, #0 1d9e: d003 beq.n 1da8 1da0: 2901 cmp r1, #1 1da2: d023 beq.n 1dec return usbdc_ctrl_data_end(req); default: break; } return false; } 1da4: 2000 movs r0, #0 1da6: bd10 pop {r4, pc} if (req->bmRequestType != USB_REQT_TYPE_STANDARD) { 1da8: 7813 ldrb r3, [r2, #0] 1daa: 2b00 cmp r3, #0 1dac: d1fa bne.n 1da4 switch (req->bRequest) { 1dae: 7853 ldrb r3, [r2, #1] 1db0: 2b05 cmp r3, #5 1db2: d00f beq.n 1dd4 1db4: 2b09 cmp r3, #9 1db6: d1f5 bne.n 1da4 usbdc.cfg_value = req->wValue; 1db8: 78e1 ldrb r1, [r4, #3] 1dba: 7892 ldrb r2, [r2, #2] 1dbc: 4b0e ldr r3, [pc, #56] ; (1df8 ) 1dbe: 0209 lsls r1, r1, #8 1dc0: 4311 orrs r1, r2 1dc2: 76d9 strb r1, [r3, #27] usbdc.state = req->wValue ? USBD_S_CONFIG : USBD_S_ADDRESS; 1dc4: 1e4a subs r2, r1, #1 1dc6: 4191 sbcs r1, r2 1dc8: 3103 adds r1, #3 usbdc.state = req->wValue ? USBD_S_ADDRESS : USBD_S_DEFAULT; 1dca: 7699 strb r1, [r3, #26] usbdc_change_notify(USBDC_C_STATE, usbdc.state); 1dcc: 2001 movs r0, #1 1dce: 4b0b ldr r3, [pc, #44] ; (1dfc ) 1dd0: 4798 blx r3 break; 1dd2: e7e7 b.n 1da4 usb_d_set_address(addr); 1dd4: 4b0a ldr r3, [pc, #40] ; (1e00 ) 1dd6: 7890 ldrb r0, [r2, #2] 1dd8: 4798 blx r3 usbdc.state = req->wValue ? USBD_S_ADDRESS : USBD_S_DEFAULT; 1dda: 78e1 ldrb r1, [r4, #3] 1ddc: 78a2 ldrb r2, [r4, #2] 1dde: 0209 lsls r1, r1, #8 1de0: 4311 orrs r1, r2 1de2: 1e4b subs r3, r1, #1 1de4: 4199 sbcs r1, r3 1de6: 4b04 ldr r3, [pc, #16] ; (1df8 ) 1de8: 3102 adds r1, #2 1dea: e7ee b.n 1dca usbdc_request_handler(0, req, USB_DATA_STAGE); 1dec: 000a movs r2, r1 1dee: 4b05 ldr r3, [pc, #20] ; (1e04 ) 1df0: 0021 movs r1, r4 1df2: 2000 movs r0, #0 1df4: 4798 blx r3 return usbdc_ctrl_data_end(req); 1df6: e7d5 b.n 1da4 1df8: 2000039c .word 0x2000039c 1dfc: 00001d1d .word 0x00001d1d 1e00: 000017e5 .word 0x000017e5 1e04: 00001d41 .word 0x00001d41 00001e08 : /** * \brief USB Device Core Reset */ void usbdc_reset(void) { 1e08: b570 push {r4, r5, r6, lr} usbdc_unconfig(); usbdc.state = USBD_S_DEFAULT; usbdc.cfg_value = 0; usbdc.ifc_alt_map = 0; 1e0a: 2400 movs r4, #0 usbdc.state = USBD_S_DEFAULT; 1e0c: 2602 movs r6, #2 usbdc_unconfig(); 1e0e: 4b0c ldr r3, [pc, #48] ; (1e40 ) 1e10: 4798 blx r3 usbdc.state = USBD_S_DEFAULT; 1e12: 4d0c ldr r5, [pc, #48] ; (1e44 ) // Setup EP0 usb_d_ep_deinit(0); 1e14: 0020 movs r0, r4 usbdc.state = USBD_S_DEFAULT; 1e16: 836e strh r6, [r5, #26] usb_d_ep_deinit(0); 1e18: 4b0b ldr r3, [pc, #44] ; (1e48 ) usbdc.ifc_alt_map = 0; 1e1a: 776c strb r4, [r5, #29] usb_d_ep_deinit(0); 1e1c: 4798 blx r3 usb_d_ep0_init(usbdc.ctrl_size); 1e1e: 4b0b ldr r3, [pc, #44] ; (1e4c ) 1e20: 7f28 ldrb r0, [r5, #28] 1e22: 4798 blx r3 usb_d_ep_register_callback(0, USB_D_EP_CB_SETUP, (FUNC_PTR)usbdc_cb_ctl_req); 1e24: 4d0a ldr r5, [pc, #40] ; (1e50 ) 1e26: 0021 movs r1, r4 1e28: 0020 movs r0, r4 1e2a: 4a0a ldr r2, [pc, #40] ; (1e54 ) 1e2c: 47a8 blx r5 usb_d_ep_register_callback(0, USB_D_EP_CB_XFER, (FUNC_PTR)usbdc_cb_ctl_done); 1e2e: 0031 movs r1, r6 1e30: 0020 movs r0, r4 1e32: 4a09 ldr r2, [pc, #36] ; (1e58 ) 1e34: 47a8 blx r5 usb_d_ep_enable(0); 1e36: 0020 movs r0, r4 1e38: 4b08 ldr r3, [pc, #32] ; (1e5c ) 1e3a: 4798 blx r3 } 1e3c: bd70 pop {r4, r5, r6, pc} 1e3e: 46c0 nop ; (mov r8, r8) 1e40: 00001cfd .word 0x00001cfd 1e44: 2000039c .word 0x2000039c 1e48: 00001855 .word 0x00001855 1e4c: 00001841 .word 0x00001841 1e50: 00001a15 .word 0x00001a15 1e54: 00001e9d .word 0x00001e9d 1e58: 00001d99 .word 0x00001d99 1e5c: 00001881 .word 0x00001881 00001e60 : * \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) { 1e60: b510 push {r4, lr} (void)param; switch (ev) { 1e62: 2800 cmp r0, #0 1e64: d002 beq.n 1e6c 1e66: 2801 cmp r0, #1 1e68: d003 beq.n 1e72 break; default: break; } } 1e6a: bd10 pop {r4, pc} usbdc_change_notify(USBDC_C_CONN, param); 1e6c: 4b02 ldr r3, [pc, #8] ; (1e78 ) 1e6e: 4798 blx r3 break; 1e70: e7fb b.n 1e6a usbdc_reset(); 1e72: 4b02 ldr r3, [pc, #8] ; (1e7c ) 1e74: 4798 blx r3 } 1e76: e7f8 b.n 1e6a 1e78: 00001d1d .word 0x00001d1d 1e7c: 00001e09 .word 0x00001e09 00001e80 : /** * \brief Issue USB device transfer */ int32_t usbdc_xfer(uint8_t ep, uint8_t *buf, uint32_t size, bool zlp) { 1e80: b51f push {r0, r1, r2, r3, r4, lr} struct usb_d_transfer xfer = {(uint8_t *)buf, size, ep, zlp}; 1e82: 9202 str r2, [sp, #8] 1e84: 466a mov r2, sp 1e86: 7310 strb r0, [r2, #12] 1e88: 7353 strb r3, [r2, #13] return usb_d_ep_transfer(&xfer); 1e8a: a801 add r0, sp, #4 1e8c: 4b02 ldr r3, [pc, #8] ; (1e98 ) struct usb_d_transfer xfer = {(uint8_t *)buf, size, ep, zlp}; 1e8e: 9101 str r1, [sp, #4] return usb_d_ep_transfer(&xfer); 1e90: 4798 blx r3 } 1e92: b005 add sp, #20 1e94: bd00 pop {pc} 1e96: 46c0 nop ; (mov r8, r8) 1e98: 000018c1 .word 0x000018c1 00001e9c : { 1e9c: b5f7 push {r0, r1, r2, r4, r5, r6, r7, lr} switch (usbdc_request_handler(ep, req, USB_SETUP_STAGE)) { 1e9e: 4bb7 ldr r3, [pc, #732] ; (217c ) 1ea0: 2200 movs r2, #0 { 1ea2: 0004 movs r4, r0 1ea4: 000d movs r5, r1 switch (usbdc_request_handler(ep, req, USB_SETUP_STAGE)) { 1ea6: 4798 blx r3 1ea8: 0003 movs r3, r0 return false; 1eaa: 2000 movs r0, #0 switch (usbdc_request_handler(ep, req, USB_SETUP_STAGE)) { 1eac: 1c5a adds r2, r3, #1 1eae: d100 bne.n 1eb2 1eb0: e0c1 b.n 2036 1eb2: 3001 adds r0, #1 1eb4: 4283 cmp r3, r0 1eb6: d100 bne.n 1eba 1eb8: e0bd b.n 2036 switch (req->bmRequestType & (USB_REQT_TYPE_MASK | USB_REQT_DIR_IN)) { 1eba: 782b ldrb r3, [r5, #0] 1ebc: 221f movs r2, #31 1ebe: 0019 movs r1, r3 1ec0: 4391 bics r1, r2 1ec2: d004 beq.n 1ece 1ec4: 2980 cmp r1, #128 ; 0x80 1ec6: d100 bne.n 1eca 1ec8: e0b6 b.n 2038 switch (req->bRequest) { 1eca: 2000 movs r0, #0 1ecc: e0b3 b.n 2036 switch (req->bRequest) { 1ece: 7868 ldrb r0, [r5, #1] 1ed0: 3801 subs r0, #1 1ed2: 280a cmp r0, #10 1ed4: d8f9 bhi.n 1eca 1ed6: f000 fa05 bl 22e4 <__gnu_thumb1_case_sqi> 1eda: f846 .short 0xf846 1edc: f80bf856 .word 0xf80bf856 1ee0: f806f8f8 .word 0xf806f8f8 1ee4: 60 .byte 0x60 1ee5: 00 .byte 0x00 if (!usbdc_set_config(req->wValue)) { 1ee6: 78aa ldrb r2, [r5, #2] if (cfg_value == 0) { 1ee8: 2a00 cmp r2, #0 1eea: d10b bne.n 1f04 usbdc_unconfig(); 1eec: 4ba4 ldr r3, [pc, #656] ; (2180 ) 1eee: 4798 blx r3 return (ERR_NONE == usbdc_xfer(ep, NULL, 0, true)); 1ef0: 2200 movs r2, #0 1ef2: 2301 movs r3, #1 1ef4: 0011 movs r1, r2 if (ERR_NONE != usbdc_xfer(ep, str_desc, length, need_zlp)) { 1ef6: 0020 movs r0, r4 1ef8: 4ca2 ldr r4, [pc, #648] ; (2184 ) 1efa: 47a0 blx r4 1efc: 4243 negs r3, r0 1efe: 4158 adcs r0, r3 1f00: b2c0 uxtb r0, r0 1f02: e098 b.n 2036 cfg_desc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, cfg_value); 1f04: 4da0 ldr r5, [pc, #640] ; (2188 ) 1f06: 682b ldr r3, [r5, #0] 1f08: cb03 ldmia r3!, {r0, r1} 1f0a: 4ba0 ldr r3, [pc, #640] ; (218c ) 1f0c: 4798 blx r3 if (NULL == cfg_desc) { 1f0e: 2800 cmp r0, #0 1f10: d100 bne.n 1f14 1f12: e090 b.n 2036 return (ptr[0] + (ptr[1] << 8)); 1f14: 78c3 ldrb r3, [r0, #3] 1f16: 7881 ldrb r1, [r0, #2] 1f18: 021b lsls r3, r3, #8 1f1a: 18c9 adds r1, r1, r3 desc.eod = cfg_desc + total_len; 1f1c: b289 uxth r1, r1 1f1e: 1841 adds r1, r0, r1 desc.sod = usb_find_desc(cfg_desc, desc.eod, USB_DT_INTERFACE); 1f20: 2204 movs r2, #4 1f22: 4b9b ldr r3, [pc, #620] ; (2190 ) desc.eod = cfg_desc + total_len; 1f24: 9101 str r1, [sp, #4] desc.sod = usb_find_desc(cfg_desc, desc.eod, USB_DT_INTERFACE); 1f26: 4798 blx r3 uint8_t last_iface = 0xFF; 1f28: 22ff movs r2, #255 ; 0xff desc.sod = usb_find_desc(cfg_desc, desc.eod, USB_DT_INTERFACE); 1f2a: 9000 str r0, [sp, #0] while (NULL != desc.sod) { 1f2c: 9b00 ldr r3, [sp, #0] 1f2e: 2b00 cmp r3, #0 1f30: d0de beq.n 1ef0 if (last_iface != desc.sod[2] /* bInterfaceNumber */) { 1f32: 789e ldrb r6, [r3, #2] 1f34: 4296 cmp r6, r2 1f36: d002 beq.n 1f3e func = (struct usbdf_driver *)usbdc.func_list.head; 1f38: 692f ldr r7, [r5, #16] while (NULL != func) { 1f3a: 2f00 cmp r7, #0 1f3c: d10a bne.n 1f54 desc.sod = usb_desc_next(desc.sod); 1f3e: 9800 ldr r0, [sp, #0] desc.sod = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE); 1f40: 2204 movs r2, #4 return (desc + usb_desc_len(desc)); 1f42: 7803 ldrb r3, [r0, #0] 1f44: 9901 ldr r1, [sp, #4] 1f46: 18c0 adds r0, r0, r3 desc.sod = usb_desc_next(desc.sod); 1f48: 9000 str r0, [sp, #0] desc.sod = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE); 1f4a: 4b91 ldr r3, [pc, #580] ; (2190 ) 1f4c: 4798 blx r3 1f4e: 0032 movs r2, r6 1f50: 9000 str r0, [sp, #0] 1f52: e7eb b.n 1f2c if (func->ctrl(func, USBDF_ENABLE, &desc)) { 1f54: 466a mov r2, sp 1f56: 2100 movs r1, #0 1f58: 0038 movs r0, r7 1f5a: 687b ldr r3, [r7, #4] 1f5c: 4798 blx r3 1f5e: 2800 cmp r0, #0 1f60: d0ed beq.n 1f3e func = func->next; 1f62: 683f ldr r7, [r7, #0] 1f64: e7e9 b.n 1f3a switch (req->bmRequestType & USB_REQT_RECIP_MASK) { 1f66: 2b02 cmp r3, #2 1f68: d1af bne.n 1eca if (req->wLength != 0) { 1f6a: 79ee ldrb r6, [r5, #7] 1f6c: 79ab ldrb r3, [r5, #6] 1f6e: 0236 lsls r6, r6, #8 1f70: 431e orrs r6, r3 1f72: d1aa bne.n 1eca usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_CLR); 1f74: 0031 movs r1, r6 1f76: 7928 ldrb r0, [r5, #4] usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_SET); 1f78: 4b86 ldr r3, [pc, #536] ; (2194 ) 1f7a: 4798 blx r3 usbdc_xfer(ep, NULL, 0, true); 1f7c: 2301 movs r3, #1 1f7e: 0032 movs r2, r6 1f80: 0031 movs r1, r6 usbdc_xfer(ep, usbdc.ctrl_buf, 1, false); 1f82: 0020 movs r0, r4 1f84: e054 b.n 2030 switch (req->bmRequestType & USB_REQT_RECIP_MASK) { 1f86: 2b02 cmp r3, #2 1f88: d19f bne.n 1eca if (req->wLength != 0) { 1f8a: 79eb ldrb r3, [r5, #7] 1f8c: 79ae ldrb r6, [r5, #6] 1f8e: 021b lsls r3, r3, #8 1f90: 431e orrs r6, r3 1f92: d19a bne.n 1eca usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_SET); 1f94: 2101 movs r1, #1 1f96: 7928 ldrb r0, [r5, #4] 1f98: e7ee b.n 1f78 return usbdc_set_interface(req->wValue, req->wIndex); 1f9a: 78ec ldrb r4, [r5, #3] 1f9c: 78ab ldrb r3, [r5, #2] 1f9e: 0224 lsls r4, r4, #8 1fa0: 431c orrs r4, r3 1fa2: 792b ldrb r3, [r5, #4] 1fa4: 796d ldrb r5, [r5, #5] ifc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, usbdc.cfg_value); 1fa6: 4e78 ldr r6, [pc, #480] ; (2188 ) return usbdc_set_interface(req->wValue, req->wIndex); 1fa8: 022d lsls r5, r5, #8 1faa: 431d orrs r5, r3 ifc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, usbdc.cfg_value); 1fac: 6833 ldr r3, [r6, #0] 1fae: 7ef2 ldrb r2, [r6, #27] 1fb0: cb03 ldmia r3!, {r0, r1} 1fb2: 4b76 ldr r3, [pc, #472] ; (218c ) 1fb4: 4798 blx r3 if (NULL == ifc) { 1fb6: 2800 cmp r0, #0 1fb8: d087 beq.n 1eca if (NULL == (ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE))) { 1fba: 2204 movs r2, #4 desc.sod = ifc; 1fbc: 9000 str r0, [sp, #0] return (ptr[0] + (ptr[1] << 8)); 1fbe: 78c3 ldrb r3, [r0, #3] 1fc0: 7881 ldrb r1, [r0, #2] 1fc2: 021b lsls r3, r3, #8 1fc4: 18c9 adds r1, r1, r3 desc.eod = ifc + usb_cfg_desc_total_len(ifc); 1fc6: b289 uxth r1, r1 1fc8: 1841 adds r1, r0, r1 if (NULL == (ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE))) { 1fca: 4f71 ldr r7, [pc, #452] ; (2190 ) desc.eod = ifc + usb_cfg_desc_total_len(ifc); 1fcc: 9101 str r1, [sp, #4] ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE); 1fce: 47b8 blx r7 if (NULL == ifc) { 1fd0: 2800 cmp r0, #0 1fd2: d100 bne.n 1fd6 1fd4: e779 b.n 1eca while (ifc[2] != ifc_id || ifc[3] != alt_set) { 1fd6: 7883 ldrb r3, [r0, #2] 1fd8: 42ab cmp r3, r5 1fda: d110 bne.n 1ffe 1fdc: 78c3 ldrb r3, [r0, #3] 1fde: 42a3 cmp r3, r4 1fe0: d10d bne.n 1ffe func = (struct usbdf_driver *)usbdc.func_list.head; 1fe2: 6937 ldr r7, [r6, #16] desc.sod = ifc; 1fe4: 9000 str r0, [sp, #0] while (NULL != func) { 1fe6: 2f00 cmp r7, #0 1fe8: d100 bne.n 1fec 1fea: e76e b.n 1eca if (func->ctrl(func, USBDF_DISABLE, &desc)) { 1fec: 2101 movs r1, #1 1fee: 466a mov r2, sp 1ff0: 0038 movs r0, r7 1ff2: 687b ldr r3, [r7, #4] 1ff4: 4798 blx r3 1ff6: 1e01 subs r1, r0, #0 1ff8: d008 beq.n 200c func = func->next; 1ffa: 683f ldr r7, [r7, #0] 1ffc: e7f3 b.n 1fe6 desc.sod = usb_desc_next(desc.sod); 1ffe: 9800 ldr r0, [sp, #0] ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE); 2000: 2204 movs r2, #4 return (desc + usb_desc_len(desc)); 2002: 7803 ldrb r3, [r0, #0] 2004: 9901 ldr r1, [sp, #4] 2006: 18c0 adds r0, r0, r3 desc.sod = usb_desc_next(desc.sod); 2008: 9000 str r0, [sp, #0] ifc = usb_find_desc(desc.sod, desc.eod, USB_DT_INTERFACE); 200a: e7e0 b.n 1fce } else if (ERR_NONE == func->ctrl(func, USBDF_ENABLE, &desc)) { 200c: 466a mov r2, sp 200e: 0038 movs r0, r7 2010: 687b ldr r3, [r7, #4] 2012: 4798 blx r3 2014: 2800 cmp r0, #0 2016: d000 beq.n 201a 2018: e757 b.n 1eca if (alt_set) { 201a: 2c00 cmp r4, #0 201c: d004 beq.n 2028 usbdc.ifc_alt_map |= 1 << ifc_id; 201e: 2201 movs r2, #1 2020: 40aa lsls r2, r5 2022: 7f73 ldrb r3, [r6, #29] 2024: 4313 orrs r3, r2 2026: 7773 strb r3, [r6, #29] usbdc_xfer(0, NULL, 0, 0); 2028: 2300 movs r3, #0 202a: 001a movs r2, r3 202c: 0019 movs r1, r3 202e: 0018 movs r0, r3 2030: 4c54 ldr r4, [pc, #336] ; (2184 ) 2032: 47a0 blx r4 return true; 2034: 2001 movs r0, #1 } 2036: bdfe pop {r1, r2, r3, r4, r5, r6, r7, pc} switch (req->bRequest) { 2038: 7868 ldrb r0, [r5, #1] 203a: 280a cmp r0, #10 203c: d900 bls.n 2040 203e: e744 b.n 1eca 2040: f000 f95a bl 22f8 <__gnu_thumb1_case_shi> 2044: ff430062 .word 0xff430062 2048: ff43ff43 .word 0xff43ff43 204c: ff43ff43 .word 0xff43ff43 2050: ff43000b .word 0xff43000b 2054: ff43005a .word 0xff43005a 2058: 0083 .short 0x0083 uint8_t type = (uint8_t)(req->wValue >> 8); 205a: 78e9 ldrb r1, [r5, #3] 205c: 78ab ldrb r3, [r5, #2] 205e: 0209 lsls r1, r1, #8 2060: 430b orrs r3, r1 2062: 0a09 lsrs r1, r1, #8 2064: b2ca uxtb r2, r1 switch (type) { 2066: 2902 cmp r1, #2 2068: d017 beq.n 209a 206a: 2a03 cmp r2, #3 206c: d034 beq.n 20d8 206e: 2000 movs r0, #0 2070: 2a01 cmp r2, #1 2072: d1e0 bne.n 2036 uint16_t length = req->wLength; 2074: 79ab ldrb r3, [r5, #6] 2076: 79ed ldrb r5, [r5, #7] 2078: 022d lsls r5, r5, #8 207a: 431d orrs r5, r3 dev_desc = usb_find_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, USB_DT_DEVICE); 207c: 4b42 ldr r3, [pc, #264] ; (2188 ) 207e: 681b ldr r3, [r3, #0] 2080: cb03 ldmia r3!, {r0, r1} 2082: 4b43 ldr r3, [pc, #268] ; (2190 ) 2084: 4798 blx r3 2086: 1e01 subs r1, r0, #0 if (!dev_desc) { 2088: d100 bne.n 208c 208a: e71e b.n 1eca if (ERR_NONE != usbdc_xfer(ep, dev_desc, length, false)) { 208c: 1c2a adds r2, r5, #0 208e: 2d12 cmp r5, #18 2090: d900 bls.n 2094 2092: 2212 movs r2, #18 2094: 2300 movs r3, #0 2096: b292 uxth r2, r2 2098: e72d b.n 1ef6 uint16_t length = req->wLength; 209a: 79aa ldrb r2, [r5, #6] 209c: 79ed ldrb r5, [r5, #7] cfg_desc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, index + 1); 209e: 3301 adds r3, #1 uint16_t length = req->wLength; 20a0: 022d lsls r5, r5, #8 20a2: 4315 orrs r5, r2 bool need_zlp = !(length & (usbdc.ctrl_size - 1)); 20a4: 4a38 ldr r2, [pc, #224] ; (2188 ) cfg_desc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, index + 1); 20a6: 6810 ldr r0, [r2, #0] bool need_zlp = !(length & (usbdc.ctrl_size - 1)); 20a8: 7f16 ldrb r6, [r2, #28] cfg_desc = usb_find_cfg_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, index + 1); 20aa: c803 ldmia r0, {r0, r1} 20ac: b2da uxtb r2, r3 20ae: 4b37 ldr r3, [pc, #220] ; (218c ) 20b0: 4798 blx r3 20b2: 1e01 subs r1, r0, #0 if (NULL == cfg_desc) { 20b4: d100 bne.n 20b8 20b6: e708 b.n 1eca return (ptr[0] + (ptr[1] << 8)); 20b8: 78c3 ldrb r3, [r0, #3] 20ba: 7882 ldrb r2, [r0, #2] 20bc: 021b lsls r3, r3, #8 20be: 18d2 adds r2, r2, r3 20c0: b292 uxth r2, r2 need_zlp = false; 20c2: 2300 movs r3, #0 if (length <= str_desc[0]) { 20c4: 4295 cmp r5, r2 20c6: d905 bls.n 20d4 bool need_zlp = !(length & (usbdc.ctrl_size - 1)); 20c8: 3e01 subs r6, #1 20ca: 4035 ands r5, r6 20cc: 426b negs r3, r5 20ce: 415d adcs r5, r3 20d0: b2eb uxtb r3, r5 20d2: 0015 movs r5, r2 if (ERR_NONE != usbdc_xfer(ep, str_desc, length, need_zlp)) { 20d4: 002a movs r2, r5 20d6: e70e b.n 1ef6 uint16_t length = req->wLength; 20d8: 79aa ldrb r2, [r5, #6] 20da: 79ed ldrb r5, [r5, #7] 20dc: 022d lsls r5, r5, #8 20de: 4315 orrs r5, r2 bool need_zlp = !(length & (usbdc.ctrl_size - 1)); 20e0: 4a29 ldr r2, [pc, #164] ; (2188 ) str_desc = usb_find_str_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, index); 20e2: 6810 ldr r0, [r2, #0] bool need_zlp = !(length & (usbdc.ctrl_size - 1)); 20e4: 7f16 ldrb r6, [r2, #28] str_desc = usb_find_str_desc(usbdc.desces.ls_fs->sod, usbdc.desces.ls_fs->eod, index); 20e6: c803 ldmia r0, {r0, r1} 20e8: b2da uxtb r2, r3 20ea: 4b2b ldr r3, [pc, #172] ; (2198 ) 20ec: 4798 blx r3 20ee: 1e01 subs r1, r0, #0 if (NULL == str_desc) { 20f0: d100 bne.n 20f4 20f2: e6ea b.n 1eca if (length <= str_desc[0]) { 20f4: 7802 ldrb r2, [r0, #0] 20f6: e7e4 b.n 20c2 *(uint8_t *)usbdc.ctrl_buf = usbdc.cfg_value; 20f8: 4923 ldr r1, [pc, #140] ; (2188 ) 20fa: 7ecb ldrb r3, [r1, #27] 20fc: 694a ldr r2, [r1, #20] 20fe: 7013 strb r3, [r2, #0] usbdc_xfer(ep, usbdc.ctrl_buf, 1, false); 2100: 6949 ldr r1, [r1, #20] 2102: 2300 movs r3, #0 2104: 2201 movs r2, #1 2106: e73c b.n 1f82 switch (req->bmRequestType & USB_REQT_RECIP_MASK) { 2108: 211f movs r1, #31 210a: 221e movs r2, #30 210c: 0018 movs r0, r3 210e: 4019 ands r1, r3 2110: 4010 ands r0, r2 2112: 4213 tst r3, r2 2114: d00e beq.n 2134 2116: 2902 cmp r1, #2 2118: d000 beq.n 211c 211a: e6d6 b.n 1eca st = usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_GET); 211c: 4b1d ldr r3, [pc, #116] ; (2194 ) 211e: 7928 ldrb r0, [r5, #4] 2120: 4798 blx r3 2122: 0003 movs r3, r0 return false; 2124: 2000 movs r0, #0 if (st < 0) { 2126: 4283 cmp r3, r0 2128: da00 bge.n 212c 212a: e784 b.n 2036 st = st & 0x1; 212c: 3001 adds r0, #1 212e: 4003 ands r3, r0 2130: 9300 str r3, [sp, #0] break; 2132: e000 b.n 2136 st = 0; 2134: 9000 str r0, [sp, #0] memcpy(usbdc.ctrl_buf, &st, 2); 2136: 4d14 ldr r5, [pc, #80] ; (2188 ) 2138: 2202 movs r2, #2 213a: 4669 mov r1, sp 213c: 4b17 ldr r3, [pc, #92] ; (219c ) 213e: 6968 ldr r0, [r5, #20] 2140: 4798 blx r3 usbdc_xfer(ep, usbdc.ctrl_buf, 2, false); 2142: 2300 movs r3, #0 2144: 2202 movs r2, #2 2146: 6969 ldr r1, [r5, #20] 2148: e71b b.n 1f82 if (!(usbdc.ifc_alt_map & (1 << req->wIndex))) { 214a: 4e0f ldr r6, [pc, #60] ; (2188 ) 214c: 796b ldrb r3, [r5, #5] 214e: 7929 ldrb r1, [r5, #4] 2150: 7f72 ldrb r2, [r6, #29] 2152: 021b lsls r3, r3, #8 2154: 430b orrs r3, r1 2156: 411a asrs r2, r3 2158: 2401 movs r4, #1 215a: 0010 movs r0, r2 215c: 4020 ands r0, r4 215e: 4222 tst r2, r4 2160: d01e beq.n 21a0 struct usbdf_driver *func = (struct usbdf_driver *)usbdc.func_list.head; 2162: 6934 ldr r4, [r6, #16] while (NULL != func) { 2164: 2c00 cmp r4, #0 2166: d100 bne.n 216a 2168: e6af b.n 1eca if (0 > (rc = func->ctrl(func, USBDF_GET_IFACE, req))) { 216a: 002a movs r2, r5 216c: 2102 movs r1, #2 216e: 0020 movs r0, r4 2170: 6863 ldr r3, [r4, #4] 2172: 4798 blx r3 2174: 2800 cmp r0, #0 2176: da1b bge.n 21b0 func = func->next; 2178: 6824 ldr r4, [r4, #0] 217a: e7f3 b.n 2164 217c: 00001d41 .word 0x00001d41 2180: 00001cfd .word 0x00001cfd 2184: 00001e81 .word 0x00001e81 2188: 2000039c .word 0x2000039c 218c: 0000151d .word 0x0000151d 2190: 000014e5 .word 0x000014e5 2194: 000019b1 .word 0x000019b1 2198: 00001559 .word 0x00001559 219c: 00002355 .word 0x00002355 usbdc.ctrl_buf[0] = 0; 21a0: 6973 ldr r3, [r6, #20] usbdc_xfer(0, usbdc.ctrl_buf, 1, false); 21a2: 0022 movs r2, r4 usbdc.ctrl_buf[0] = 0; 21a4: 7018 strb r0, [r3, #0] usbdc_xfer(0, usbdc.ctrl_buf, 1, false); 21a6: 6971 ldr r1, [r6, #20] 21a8: 0003 movs r3, r0 21aa: 4d05 ldr r5, [pc, #20] ; (21c0 ) 21ac: 47a8 blx r5 return true; 21ae: e741 b.n 2034 usbdc.ctrl_buf[0] = (uint8_t)rc; 21b0: 6973 ldr r3, [r6, #20] usbdc_xfer(0, usbdc.ctrl_buf, 1, false); 21b2: 2201 movs r2, #1 usbdc.ctrl_buf[0] = (uint8_t)rc; 21b4: 7018 strb r0, [r3, #0] usbdc_xfer(0, usbdc.ctrl_buf, 1, false); 21b6: 2300 movs r3, #0 21b8: 6971 ldr r1, [r6, #20] 21ba: 0018 movs r0, r3 21bc: e738 b.n 2030 21be: 46c0 nop ; (mov r8, r8) 21c0: 00001e81 .word 0x00001e81 000021c4 : /** * \brief Register the handler */ void usbdc_register_handler(enum usbdc_handler_type type, const struct usbdc_handler *h) { 21c4: b510 push {r4, lr} switch (type) { 21c6: 2801 cmp r0, #1 21c8: d008 beq.n 21dc 21ca: 2802 cmp r0, #2 21cc: d009 beq.n 21e2 21ce: 2800 cmp r0, #0 21d0: d103 bne.n 21da case USBDC_HDL_SOF: list_insert_at_end(&usbdc.handlers.sof_list, (void *)h); 21d2: 4805 ldr r0, [pc, #20] ; (21e8 ) 21d4: 3004 adds r0, #4 break; case USBDC_HDL_REQ: list_insert_at_end(&usbdc.handlers.req_list, (void *)h); break; case USBDC_HDL_CHANGE: list_insert_at_end(&usbdc.handlers.change_list, (void *)h); 21d6: 4b05 ldr r3, [pc, #20] ; (21ec ) 21d8: 4798 blx r3 break; default: break; } } 21da: bd10 pop {r4, pc} list_insert_at_end(&usbdc.handlers.req_list, (void *)h); 21dc: 4802 ldr r0, [pc, #8] ; (21e8 ) 21de: 3008 adds r0, #8 21e0: e7f9 b.n 21d6 list_insert_at_end(&usbdc.handlers.change_list, (void *)h); 21e2: 4801 ldr r0, [pc, #4] ; (21e8 ) 21e4: 300c adds r0, #12 21e6: e7f6 b.n 21d6 21e8: 2000039c .word 0x2000039c 21ec: 00001285 .word 0x00001285 000021f0 : /** * \brief Initialize the USB device core driver */ int32_t usbdc_init(uint8_t *ctrl_buf) { 21f0: b570 push {r4, r5, r6, lr} 21f2: 0004 movs r4, r0 ASSERT(ctrl_buf); 21f4: 1e43 subs r3, r0, #1 21f6: 4198 sbcs r0, r3 21f8: 4a0c ldr r2, [pc, #48] ; (222c ) 21fa: 4b0d ldr r3, [pc, #52] ; (2230 ) 21fc: 490d ldr r1, [pc, #52] ; (2234 ) 21fe: b2c0 uxtb r0, r0 2200: 4798 blx r3 int32_t rc; rc = usb_d_init(); 2202: 4b0d ldr r3, [pc, #52] ; (2238 ) 2204: 4798 blx r3 if (rc < 0) { 2206: 2800 cmp r0, #0 2208: db0e blt.n 2228 return rc; } memset(&usbdc, 0, sizeof(usbdc)); 220a: 4d0c ldr r5, [pc, #48] ; (223c ) 220c: 2220 movs r2, #32 220e: 4b0c ldr r3, [pc, #48] ; (2240 ) 2210: 2100 movs r1, #0 2212: 0028 movs r0, r5 2214: 4798 blx r3 usbdc.ctrl_buf = ctrl_buf; usb_d_register_callback(USB_D_CB_SOF, (FUNC_PTR)usbd_sof_cb); 2216: 2000 movs r0, #0 2218: 490a ldr r1, [pc, #40] ; (2244 ) usbdc.ctrl_buf = ctrl_buf; 221a: 616c str r4, [r5, #20] usb_d_register_callback(USB_D_CB_SOF, (FUNC_PTR)usbd_sof_cb); 221c: 4c0a ldr r4, [pc, #40] ; (2248 ) 221e: 47a0 blx r4 usb_d_register_callback(USB_D_CB_EVENT, (FUNC_PTR)usbd_event_cb); 2220: 2001 movs r0, #1 2222: 490a ldr r1, [pc, #40] ; (224c ) 2224: 47a0 blx r4 return 0; 2226: 2000 movs r0, #0 } 2228: bd70 pop {r4, r5, r6, pc} 222a: 46c0 nop ; (mov r8, r8) 222c: 00000355 .word 0x00000355 2230: 000012c5 .word 0x000012c5 2234: 000023ff .word 0x000023ff 2238: 00001759 .word 0x00001759 223c: 2000039c .word 0x2000039c 2240: 00002367 .word 0x00002367 2244: 00001d7d .word 0x00001d7d 2248: 000017c1 .word 0x000017c1 224c: 00001e61 .word 0x00001e61 00002250 : * \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) { 2250: b510 push {r4, lr} 2252: 0001 movs r1, r0 list_insert_at_end(&usbdc.func_list, func); 2254: 4802 ldr r0, [pc, #8] ; (2260 ) 2256: 4b03 ldr r3, [pc, #12] ; (2264 ) 2258: 3010 adds r0, #16 225a: 4798 blx r3 } 225c: bd10 pop {r4, pc} 225e: 46c0 nop ; (mov r8, r8) 2260: 2000039c .word 0x2000039c 2264: 00001285 .word 0x00001285 00002268 : /** * \brief Start the USB device driver with specific descriptors set */ int32_t usbdc_start(struct usbd_descriptors *desces) { 2268: b510 push {r4, lr} if (usbdc.state >= USBD_S_POWER) { 226a: 4b0a ldr r3, [pc, #40] ; (2294 ) 226c: 7e9c ldrb r4, [r3, #26] 226e: 2c00 cmp r4, #0 2270: d10b bne.n 228a return ERR_BUSY; } if (desces) { 2272: 2800 cmp r0, #0 2274: d00c beq.n 2290 #endif } else { return ERR_BAD_DATA; } usbdc.ctrl_size = desces->sod[7]; 2276: 6802 ldr r2, [r0, #0] usbdc.desces.ls_fs = desces; 2278: 6018 str r0, [r3, #0] usbdc.ctrl_size = desces->sod[7]; 227a: 79d2 ldrb r2, [r2, #7] 227c: 771a strb r2, [r3, #28] usbdc.state = USBD_S_POWER; 227e: 2201 movs r2, #1 2280: 769a strb r2, [r3, #26] usb_d_enable(); 2282: 4b05 ldr r3, [pc, #20] ; (2298 ) 2284: 4798 blx r3 return ERR_NONE; 2286: 0020 movs r0, r4 } 2288: bd10 pop {r4, pc} return ERR_BUSY; 228a: 2004 movs r0, #4 return ERR_BAD_DATA; 228c: 4240 negs r0, r0 228e: e7fb b.n 2288 2290: 2009 movs r0, #9 2292: e7fb b.n 228c 2294: 2000039c .word 0x2000039c 2298: 000017cd .word 0x000017cd 0000229c : /** * \brief Attach the USB device to host */ void usbdc_attach(void) { 229c: b510 push {r4, lr} usb_d_attach(); 229e: 4b01 ldr r3, [pc, #4] ; (22a4 ) 22a0: 4798 blx r3 } 22a2: bd10 pop {r4, pc} 22a4: 000017d9 .word 0x000017d9 000022a8 : /** * \brief Return USB Device endpoint0 buffer */ uint8_t *usbdc_get_ctrl_buffer(void) { return usbdc.ctrl_buf; 22a8: 4b01 ldr r3, [pc, #4] ; (22b0 ) 22aa: 6958 ldr r0, [r3, #20] } 22ac: 4770 bx lr 22ae: 46c0 nop ; (mov r8, r8) 22b0: 2000039c .word 0x2000039c 000022b4 : /** * \brief Return current USB state */ uint8_t usbdc_get_state(void) { if (usbdc.state & USBD_S_SUSPEND) { 22b4: 4b03 ldr r3, [pc, #12] ; (22c4 ) 22b6: 7e98 ldrb r0, [r3, #26] 22b8: 2310 movs r3, #16 22ba: 4218 tst r0, r3 22bc: d000 beq.n 22c0 return USBD_S_SUSPEND; 22be: 0018 movs r0, r3 } return usbdc.state; } 22c0: 4770 bx lr 22c2: 46c0 nop ; (mov r8, r8) 22c4: 2000039c .word 0x2000039c 000022c8 : */ __STATIC_FORCEINLINE uint32_t __get_PRIMASK(void) { uint32_t result; __ASM volatile ("MRS %0, primask" : "=r" (result) :: "memory"); 22c8: f3ef 8310 mrs r3, PRIMASK /** * \brief Disable interrupts, enter critical section */ void atomic_enter_critical(hal_atomic_t volatile *atomic) { *atomic = __get_PRIMASK(); 22cc: 6003 str r3, [r0, #0] __ASM volatile ("cpsid i" : : : "memory"); 22ce: 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"); 22d0: f3bf 8f5f dmb sy __disable_irq(); __DMB(); } 22d4: 4770 bx lr 000022d6 : 22d6: f3bf 8f5f dmb sy * \brief Exit atomic section */ void atomic_leave_critical(hal_atomic_t volatile *atomic) { __DMB(); __set_PRIMASK(*atomic); 22da: 6803 ldr r3, [r0, #0] __ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory"); 22dc: f383 8810 msr PRIMASK, r3 } 22e0: 4770 bx lr ... 000022e4 <__gnu_thumb1_case_sqi>: 22e4: b402 push {r1} 22e6: 4671 mov r1, lr 22e8: 0849 lsrs r1, r1, #1 22ea: 0049 lsls r1, r1, #1 22ec: 5609 ldrsb r1, [r1, r0] 22ee: 0049 lsls r1, r1, #1 22f0: 448e add lr, r1 22f2: bc02 pop {r1} 22f4: 4770 bx lr 22f6: 46c0 nop ; (mov r8, r8) 000022f8 <__gnu_thumb1_case_shi>: 22f8: b403 push {r0, r1} 22fa: 4671 mov r1, lr 22fc: 0849 lsrs r1, r1, #1 22fe: 0040 lsls r0, r0, #1 2300: 0049 lsls r1, r1, #1 2302: 5e09 ldrsh r1, [r1, r0] 2304: 0049 lsls r1, r1, #1 2306: 448e add lr, r1 2308: bc03 pop {r0, r1} 230a: 4770 bx lr 0000230c <__libc_init_array>: 230c: b570 push {r4, r5, r6, lr} 230e: 2600 movs r6, #0 2310: 4d0c ldr r5, [pc, #48] ; (2344 <__libc_init_array+0x38>) 2312: 4c0d ldr r4, [pc, #52] ; (2348 <__libc_init_array+0x3c>) 2314: 1b64 subs r4, r4, r5 2316: 10a4 asrs r4, r4, #2 2318: 42a6 cmp r6, r4 231a: d109 bne.n 2330 <__libc_init_array+0x24> 231c: 2600 movs r6, #0 231e: f000 f87b bl 2418 <_init> 2322: 4d0a ldr r5, [pc, #40] ; (234c <__libc_init_array+0x40>) 2324: 4c0a ldr r4, [pc, #40] ; (2350 <__libc_init_array+0x44>) 2326: 1b64 subs r4, r4, r5 2328: 10a4 asrs r4, r4, #2 232a: 42a6 cmp r6, r4 232c: d105 bne.n 233a <__libc_init_array+0x2e> 232e: bd70 pop {r4, r5, r6, pc} 2330: 00b3 lsls r3, r6, #2 2332: 58eb ldr r3, [r5, r3] 2334: 4798 blx r3 2336: 3601 adds r6, #1 2338: e7ee b.n 2318 <__libc_init_array+0xc> 233a: 00b3 lsls r3, r6, #2 233c: 58eb ldr r3, [r5, r3] 233e: 4798 blx r3 2340: 3601 adds r6, #1 2342: e7f2 b.n 232a <__libc_init_array+0x1e> 2344: 00002424 .word 0x00002424 2348: 00002424 .word 0x00002424 234c: 00002424 .word 0x00002424 2350: 00002428 .word 0x00002428 00002354 : 2354: 2300 movs r3, #0 2356: b510 push {r4, lr} 2358: 429a cmp r2, r3 235a: d100 bne.n 235e 235c: bd10 pop {r4, pc} 235e: 5ccc ldrb r4, [r1, r3] 2360: 54c4 strb r4, [r0, r3] 2362: 3301 adds r3, #1 2364: e7f8 b.n 2358 00002366 : 2366: 0003 movs r3, r0 2368: 1882 adds r2, r0, r2 236a: 4293 cmp r3, r2 236c: d100 bne.n 2370 236e: 4770 bx lr 2370: 7019 strb r1, [r3, #0] 2372: 3301 adds r3, #1 2374: e7f9 b.n 236a ... 00002378 <_usb_ep_cfgs>: 2378: 0250 2000 0000 0000 0040 0000 0210 2000 P.. ....@...... 2388: 0000 0000 0040 0000 01d0 2000 0000 0000 ....@...... .... 2398: 0040 0000 2e2e 682f 6c61 752f 6974 736c @...../hal/utils 23a8: 732f 6372 752f 6974 736c 6c5f 7369 2e74 /src/utils_list. 23b8: 0063 2e2e 682f 6c61 732f 6372 682f 6c61 c.../hal/src/hal 23c8: 755f 6173 7472 735f 6e79 2e63 0063 _usart_sync.c. 000023d6 : 23d6: 01ed 0101 0201 ....... 000023dd : 23dd: 00ed 0101 0201 2ef0 2f2e 7068 2f6c 6573 ........./hpl/se 23ed: 6372 6d6f 682f 6c70 735f 7265 6f63 2e6d rcom/hpl_sercom. 23fd: 0063 2e2e 752f 6273 642f 7665 6369 2f65 c.../usb/device/ 240d: 7375 6462 2e63 0063 0000 usbdc.c.... 00002418 <_init>: 2418: b5f8 push {r3, r4, r5, r6, r7, lr} 241a: 46c0 nop ; (mov r8, r8) 241c: bcf8 pop {r3, r4, r5, r6, r7} 241e: bc08 pop {r3} 2420: 469e mov lr, r3 2422: 4770 bx lr 00002424 <__frame_dummy_init_array_entry>: 2424: 00dd 0000 .... 00002428 <_fini>: 2428: b5f8 push {r3, r4, r5, r6, r7, lr} 242a: 46c0 nop ; (mov r8, r8) 242c: bcf8 pop {r3, r4, r5, r6, r7} 242e: bc08 pop {r3} 2430: 469e mov lr, r3 2432: 4770 bx lr 00002434 <__do_global_dtors_aux_fini_array_entry>: 2434: 00b5 0000 ....