
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 <exception_table>:
       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 <frame_dummy>:
      dc:	4b04      	ldr	r3, [pc, #16]	; (f0 <frame_dummy+0x14>)
      de:	b510      	push	{r4, lr}
      e0:	2b00      	cmp	r3, #0
      e2:	d003      	beq.n	ec <frame_dummy+0x10>
      e4:	4903      	ldr	r1, [pc, #12]	; (f4 <frame_dummy+0x18>)
      e6:	4804      	ldr	r0, [pc, #16]	; (f8 <frame_dummy+0x1c>)
      e8:	e000      	b.n	ec <frame_dummy+0x10>
      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 <Dummy_Handler>:
/**
 * \brief Default interrupt handler for unused IRQs.
 */
void Dummy_Handler(void)
{
	while (1) {
      fc:	e7fe      	b.n	fc <Dummy_Handler>
	...

00000100 <Reset_Handler>:
	if (pSrc != pDest) {
     100:	4925      	ldr	r1, [pc, #148]	; (198 <Reset_Handler+0x98>)
     102:	4826      	ldr	r0, [pc, #152]	; (19c <Reset_Handler+0x9c>)
{
     104:	b570      	push	{r4, r5, r6, lr}
	if (pSrc != pDest) {
     106:	4281      	cmp	r1, r0
     108:	d00a      	beq.n	120 <Reset_Handler+0x20>
			*pDest++ = *pSrc++;
     10a:	4b25      	ldr	r3, [pc, #148]	; (1a0 <Reset_Handler+0xa0>)
     10c:	1ec4      	subs	r4, r0, #3
     10e:	2200      	movs	r2, #0
     110:	42a3      	cmp	r3, r4
     112:	d303      	bcc.n	11c <Reset_Handler+0x1c>
     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 <Reset_Handler+0xa4>)
     11e:	4798      	blx	r3
		*pDest++ = 0;
     120:	4821      	ldr	r0, [pc, #132]	; (1a8 <Reset_Handler+0xa8>)
     122:	4b22      	ldr	r3, [pc, #136]	; (1ac <Reset_Handler+0xac>)
     124:	1ec1      	subs	r1, r0, #3
     126:	2200      	movs	r2, #0
     128:	4299      	cmp	r1, r3
     12a:	d803      	bhi.n	134 <Reset_Handler+0x34>
     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 <Reset_Handler+0xb0>)
     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 <Reset_Handler+0xb4>)
	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 <Reset_Handler+0xb8>)
	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 <Reset_Handler+0xbc>)
	USB->DEVICE.QOSCTRL.bit.CQOS = 2;
     150:	481b      	ldr	r0, [pc, #108]	; (1c0 <Reset_Handler+0xc0>)
	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 <Reset_Handler+0xc4>)
     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 <Reset_Handler+0xc8>)
     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 <Reset_Handler+0xcc>)
     18e:	4798      	blx	r3
	main();
     190:	4b0f      	ldr	r3, [pc, #60]	; (1d0 <Reset_Handler+0xd0>)
     192:	4798      	blx	r3
	while (1)
     194:	e7fe      	b.n	194 <Reset_Handler+0x94>
     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 <cdcdf_acm_req>:
 * \param[in] ep Endpoint address.
 * \param[in] req Pointer to the request.
 * \return Operation status.
 */
static int32_t cdcdf_acm_req(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage)
{
     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 <cdcdf_acm_req+0xba>
		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 <cdcdf_acm_req+0xc4>)
     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 <cdcdf_acm_req+0x2a>
     1f8:	7869      	ldrb	r1, [r5, #1]
     1fa:	4299      	cmp	r1, r3
     1fc:	d147      	bne.n	28e <cdcdf_acm_req+0xba>
	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 <cdcdf_acm_req+0x58>
		return ERR_NONE;
     20c:	2000      	movs	r0, #0
	if (USB_DATA_STAGE == stage) {
     20e:	2f01      	cmp	r7, #1
     210:	d00a      	beq.n	228 <cdcdf_acm_req+0x54>
	switch (req->bRequest) {
     212:	7863      	ldrb	r3, [r4, #1]
     214:	2b21      	cmp	r3, #33	; 0x21
     216:	d111      	bne.n	23c <cdcdf_acm_req+0x68>
		if (sizeof(struct usb_cdc_line_coding) != len) {
     218:	2e07      	cmp	r6, #7
     21a:	d13b      	bne.n	294 <cdcdf_acm_req+0xc0>
		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 <cdcdf_acm_req+0xc8>)
     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 <cdcdf_acm_req+0xcc>)
     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 <cdcdf_acm_req+0x6c>
     238:	2b22      	cmp	r3, #34	; 0x22
     23a:	d019      	beq.n	270 <cdcdf_acm_req+0x9c>
		return ERR_INVALID_ARG;
     23c:	200d      	movs	r0, #13
     23e:	e027      	b.n	290 <cdcdf_acm_req+0xbc>
		if (sizeof(struct usb_cdc_line_coding) != len) {
     240:	2e07      	cmp	r6, #7
     242:	d127      	bne.n	294 <cdcdf_acm_req+0xc0>
		if (USB_SETUP_STAGE == stage) {
     244:	2f00      	cmp	r7, #0
     246:	d101      	bne.n	24c <cdcdf_acm_req+0x78>
			return usbdc_xfer(ep, ctrl_buf, len, false);
     248:	003b      	movs	r3, r7
     24a:	e7e9      	b.n	220 <cdcdf_acm_req+0x4c>
			memcpy(&line_coding_tmp, ctrl_buf, sizeof(struct usb_cdc_line_coding));
     24c:	0032      	movs	r2, r6
     24e:	4c15      	ldr	r4, [pc, #84]	; (2a4 <cdcdf_acm_req+0xd0>)
     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 <cdcdf_acm_req+0x92>
				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 <cdcdf_acm_req+0x54>
			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 <cdcdf_acm_req+0x86>
     26e:	e7f8      	b.n	262 <cdcdf_acm_req+0x8e>
		usbdc_xfer(0, NULL, 0, 0);
     270:	2300      	movs	r3, #0
     272:	4e0a      	ldr	r6, [pc, #40]	; (29c <cdcdf_acm_req+0xc8>)
     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_req+0x8e>
			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 <cdcdf_acm_req+0x8e>
		return ERR_NOT_FOUND;
     28e:	200a      	movs	r0, #10
			return ERR_INVALID_DATA;
     290:	4240      	negs	r0, r0
     292:	e7c9      	b.n	228 <cdcdf_acm_req+0x54>
     294:	2001      	movs	r0, #1
     296:	e7fb      	b.n	290 <cdcdf_acm_req+0xbc>
     298:	20000084 	.word	0x20000084
     29c:	00001e81 	.word	0x00001e81
     2a0:	000022a9 	.word	0x000022a9
     2a4:	00002355 	.word	0x00002355

000002a8 <cdcdf_acm_ctrl>:
{
     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 <cdcdf_acm_ctrl+0xa8>
     2b0:	2902      	cmp	r1, #2
     2b2:	d100      	bne.n	2b6 <cdcdf_acm_ctrl+0xe>
     2b4:	e076      	b.n	3a4 <cdcdf_acm_ctrl+0xfc>
     2b6:	2900      	cmp	r1, #0
     2b8:	d000      	beq.n	2bc <cdcdf_acm_ctrl+0x14>
     2ba:	e075      	b.n	3a8 <cdcdf_acm_ctrl+0x100>
		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 <cdcdf_acm_ctrl+0x2a>
			return ERR_NOT_FOUND;
     2cc:	200a      	movs	r0, #10
				return ERR_NOT_INITIALIZED;
     2ce:	4240      	negs	r0, r0
     2d0:	e020      	b.n	314 <cdcdf_acm_ctrl+0x6c>
		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 <cdcdf_acm_ctrl+0x24>
			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 <cdcdf_acm_ctrl+0x104>
			} else if (func_data->func_iface[i] != 0xFF) { // Occupied
     2e4:	2bff      	cmp	r3, #255	; 0xff
     2e6:	d163      	bne.n	3b0 <cdcdf_acm_ctrl+0x108>
				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 <cdcdf_acm_ctrl+0x110>)
     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 <cdcdf_acm_ctrl+0x6e>
		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 <cdcdf_acm_ctrl+0x110>)
     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_ctrl+0x20>
	_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 <cdcdf_acm_ctrl+0x114>)
     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 <cdcdf_acm_ctrl+0x118>)
     326:	b292      	uxth	r2, r2
     328:	4798      	blx	r3
     32a:	2800      	cmp	r0, #0
     32c:	d142      	bne.n	3b4 <cdcdf_acm_ctrl+0x10c>
			if (ep_desc.bEndpointAddress & USB_EP_DIR_IN) {
     32e:	b27b      	sxtb	r3, r7
     330:	4a24      	ldr	r2, [pc, #144]	; (3c4 <cdcdf_acm_ctrl+0x11c>)
     332:	2b00      	cmp	r3, #0
     334:	da09      	bge.n	34a <cdcdf_acm_ctrl+0xa2>
				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 <cdcdf_acm_ctrl+0x120>)
     344:	1820      	adds	r0, r4, r0
     346:	4798      	blx	r3
     348:	e7d3      	b.n	2f2 <cdcdf_acm_ctrl+0x4a>
				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 <cdcdf_acm_ctrl+0x90>
		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 <cdcdf_acm_ctrl+0xba>
		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 <cdcdf_acm_ctrl+0x24>
		if (func_data->func_iface[i] == 0xFF) {
     362:	7823      	ldrb	r3, [r4, #0]
     364:	2bff      	cmp	r3, #255	; 0xff
     366:	d007      	beq.n	378 <cdcdf_acm_ctrl+0xd0>
			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 <cdcdf_acm_ctrl+0xd0>
				usb_d_ep_deinit(func_data->func_ep_in[i]);
     372:	4b16      	ldr	r3, [pc, #88]	; (3cc <cdcdf_acm_ctrl+0x124>)
     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 <cdcdf_acm_ctrl+0xe6>
			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 <cdcdf_acm_ctrl+0xe6>
				usb_d_ep_deinit(func_data->func_ep_in[i]);
     388:	4b10      	ldr	r3, [pc, #64]	; (3cc <cdcdf_acm_ctrl+0x124>)
     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 <cdcdf_acm_ctrl+0xf4>
		usb_d_ep_deinit(func_data->func_ep_out);
     394:	4b0d      	ldr	r3, [pc, #52]	; (3cc <cdcdf_acm_ctrl+0x124>)
     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 <cdcdf_acm_ctrl+0x114>)
     3a0:	7158      	strb	r0, [r3, #5]
	return ERR_NONE;
     3a2:	e7b7      	b.n	314 <cdcdf_acm_ctrl+0x6c>
		return ERR_UNSUPPORTED_OP;
     3a4:	201b      	movs	r0, #27
     3a6:	e792      	b.n	2ce <cdcdf_acm_ctrl+0x26>
	switch (ctrl) {
     3a8:	200d      	movs	r0, #13
     3aa:	e790      	b.n	2ce <cdcdf_acm_ctrl+0x26>
				return ERR_ALREADY_INITIALIZED;
     3ac:	2012      	movs	r0, #18
     3ae:	e78e      	b.n	2ce <cdcdf_acm_ctrl+0x26>
				return ERR_NO_RESOURCE;
     3b0:	201c      	movs	r0, #28
     3b2:	e78c      	b.n	2ce <cdcdf_acm_ctrl+0x26>
				return ERR_NOT_INITIALIZED;
     3b4:	2014      	movs	r0, #20
     3b6:	e78a      	b.n	2ce <cdcdf_acm_ctrl+0x26>
     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 <cdcdf_acm_init>:

/**
 * \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 <cdcdf_acm_init+0x2c>)
     3d4:	4798      	blx	r3
     3d6:	2801      	cmp	r0, #1
     3d8:	d80c      	bhi.n	3f4 <cdcdf_acm_init+0x24>
		return ERR_DENIED;
	}

	_cdcdf_acm.ctrl      = cdcdf_acm_ctrl;
     3da:	4809      	ldr	r0, [pc, #36]	; (400 <cdcdf_acm_init+0x30>)
     3dc:	4b09      	ldr	r3, [pc, #36]	; (404 <cdcdf_acm_init+0x34>)
	_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 <cdcdf_acm_init+0x38>)
     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 <cdcdf_acm_init+0x3c>)
     3ec:	4b08      	ldr	r3, [pc, #32]	; (410 <cdcdf_acm_init+0x40>)
     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 <cdcdf_acm_init+0x22>
     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 <USB_Handler>:

/**
 * \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 <USB_Handler+0x1b4>)
    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 <USB_Handler+0x10>
    1042:	e066      	b.n	1112 <USB_Handler+0xde>
	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_Handler+0x2a>
	((Usb *)hw)->DEVICE.INTFLAG.reg = mask;
    1054:	8398      	strh	r0, [r3, #28]
	dev_inst.callbacks.sof();
    1056:	4b65      	ldr	r3, [pc, #404]	; (11ec <USB_Handler+0x1b8>)
    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 <USB_Handler+0x72>
    106a:	4a61      	ldr	r2, [pc, #388]	; (11f0 <USB_Handler+0x1bc>)
    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 <USB_Handler+0x1c0>)
    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 <USB_Handler+0x5a>
    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 <USB_Handler+0x68>
		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 <USB_Handler+0x1b8>)
    10a0:	685b      	ldr	r3, [r3, #4]
	dev_inst.callbacks.event(USB_EV_SUSPEND, 0);
    10a2:	4798      	blx	r3
    10a4:	e7da      	b.n	105c <USB_Handler+0x28>
	} 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_Handler+0x88>
	((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 <USB_Handler+0x1b8>)
    10b4:	0031      	movs	r1, r6
    10b6:	2005      	movs	r0, #5
    10b8:	685b      	ldr	r3, [r3, #4]
    10ba:	e7f2      	b.n	10a2 <USB_Handler+0x6e>
	} 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_Handler+0xa8>
	((Usb *)hw)->DEVICE.INTENSET.reg = mask;
    10c6:	4a4a      	ldr	r2, [pc, #296]	; (11f0 <USB_Handler+0x1bc>)
	((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 <USB_Handler+0x1c4>)
    10d0:	4798      	blx	r3
	dev_inst.callbacks.event(USB_EV_WAKEUP, 0);
    10d2:	4b46      	ldr	r3, [pc, #280]	; (11ec <USB_Handler+0x1b8>)
    10d4:	0029      	movs	r1, r5
    10d6:	2002      	movs	r0, #2
    10d8:	685b      	ldr	r3, [r3, #4]
    10da:	e7e2      	b.n	10a2 <USB_Handler+0x6e>
	} 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 <USB_Handler+0xcc>
	((UsbDevice *)hw)->DeviceEndpoint[submodule_index].EPCFG.reg = data;
    10e6:	4a45      	ldr	r2, [pc, #276]	; (11fc <USB_Handler+0x1c8>)
    10e8:	7054      	strb	r4, [r2, #1]
	((Usb *)hw)->DEVICE.INTENSET.reg = mask;
    10ea:	4a41      	ldr	r2, [pc, #260]	; (11f0 <USB_Handler+0x1bc>)
	((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 <USB_Handler+0x1cc>)
    10f4:	4798      	blx	r3
	dev_inst.callbacks.event(USB_EV_RESET, 0);
    10f6:	4b3d      	ldr	r3, [pc, #244]	; (11ec <USB_Handler+0x1b8>)
    10f8:	0021      	movs	r1, r4
    10fa:	2001      	movs	r0, #1
    10fc:	685b      	ldr	r3, [r3, #4]
    10fe:	e7d0      	b.n	10a2 <USB_Handler+0x6e>
	} else if (flags & USB_DEVICE_INTFLAG_SUSPEND) {
    1100:	07d2      	lsls	r2, r2, #31
    1102:	d506      	bpl.n	1112 <USB_Handler+0xde>
	((Usb *)hw)->DEVICE.INTFLAG.reg = mask;
    1104:	4a3a      	ldr	r2, [pc, #232]	; (11f0 <USB_Handler+0x1bc>)
    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 <USB_Handler+0x1b8>)
    110e:	685b      	ldr	r3, [r3, #4]
    1110:	e7c7      	b.n	10a2 <USB_Handler+0x6e>
	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 <USB_Handler+0x1d0>)
		if (ept->ep == 0xFF) {
    111a:	7ca3      	ldrb	r3, [r4, #18]
    111c:	2bff      	cmp	r3, #255	; 0xff
    111e:	d038      	beq.n	1192 <USB_Handler+0x15e>
	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 <USB_Handler+0x15e>
	flags = hw->DEVICE.DeviceEndpoint[epn].EPINTFLAG.reg;
    112c:	4936      	ldr	r1, [pc, #216]	; (1208 <USB_Handler+0x1d4>)
    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 <USB_Handler+0x1c8>)
    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 <USB_Handler+0x15e>
		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 <USB_Handler+0x1b8>)
    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 <USB_Handler+0x148>
	if (flags & USB_DEVICE_EPINTFLAG_RXSTP) {
    1158:	06da      	lsls	r2, r3, #27
    115a:	d503      	bpl.n	1164 <USB_Handler+0x130>
			_usb_d_dev_handle_setup(ept);
    115c:	0020      	movs	r0, r4
    115e:	4b2b      	ldr	r3, [pc, #172]	; (120c <USB_Handler+0x1d8>)
    1160:	4798      	blx	r3
    1162:	e016      	b.n	1192 <USB_Handler+0x15e>
	} 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_Handler+0x13e>
		_usb_d_dev_handle_stall(ept, 1);
    116e:	0029      	movs	r1, r5
    1170:	e001      	b.n	1176 <USB_Handler+0x142>
	} else if (flags & USB_DEVICE_EPINTFLAG_STALL0) {
    1172:	069b      	lsls	r3, r3, #26
    1174:	d50d      	bpl.n	1192 <USB_Handler+0x15e>
		_usb_d_dev_handle_stall(ept, 0);
    1176:	0020      	movs	r0, r4
    1178:	4b25      	ldr	r3, [pc, #148]	; (1210 <USB_Handler+0x1dc>)
    117a:	e009      	b.n	1190 <USB_Handler+0x15c>
		} else if (_usb_d_dev_ep_is_in(ept)) {
    117c:	b251      	sxtb	r1, r2
    117e:	2900      	cmp	r1, #0
    1180:	da1c      	bge.n	11bc <USB_Handler+0x188>
	if (flags & USB_DEVICE_EPINTFLAG_STALL1) {
    1182:	0659      	lsls	r1, r3, #25
    1184:	d4f3      	bmi.n	116e <USB_Handler+0x13a>
	} else if (flags & USB_DEVICE_EPINTFLAG_TRFAIL1) {
    1186:	0719      	lsls	r1, r3, #28
    1188:	d508      	bpl.n	119c <USB_Handler+0x168>
		_usb_d_dev_handle_trfail(ept, 1);
    118a:	0029      	movs	r1, r5
    118c:	0020      	movs	r0, r4
    118e:	4b21      	ldr	r3, [pc, #132]	; (1214 <USB_Handler+0x1e0>)
    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 <USB_Handler+0xe6>
    119a:	e75f      	b.n	105c <USB_Handler+0x28>
	} else if (flags & USB_DEVICE_EPINTFLAG_TRCPT1) {
    119c:	0799      	lsls	r1, r3, #30
    119e:	d503      	bpl.n	11a8 <USB_Handler+0x174>
		_usb_d_dev_in_next(ept, true);
    11a0:	0029      	movs	r1, r5
    11a2:	0020      	movs	r0, r4
    11a4:	4b1c      	ldr	r3, [pc, #112]	; (1218 <USB_Handler+0x1e4>)
    11a6:	e7f3      	b.n	1190 <USB_Handler+0x15c>
	} 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_Handler+0x15e>
			_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 <USB_Handler+0x158>
		} else if (flags & USB_DEVICE_EPINTFLAG_RXSTP) {
    11b6:	06db      	lsls	r3, r3, #27
    11b8:	d5eb      	bpl.n	1192 <USB_Handler+0x15e>
    11ba:	e7cf      	b.n	115c <USB_Handler+0x128>
	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_Handler+0x196>
		_usb_d_dev_handle_stall(ept, 0);
    11c6:	2100      	movs	r1, #0
    11c8:	e7d5      	b.n	1176 <USB_Handler+0x142>
	} else if (flags & USB_DEVICE_EPINTFLAG_TRFAIL0) {
    11ca:	0758      	lsls	r0, r3, #29
    11cc:	d4de      	bmi.n	118c <USB_Handler+0x158>
	} else if (flags & USB_DEVICE_EPINTFLAG_TRCPT0) {
    11ce:	422b      	tst	r3, r5
    11d0:	d003      	beq.n	11da <USB_Handler+0x1a6>
		_usb_d_dev_out_next(ept, true);
    11d2:	0029      	movs	r1, r5
    11d4:	0020      	movs	r0, r4
    11d6:	4b11      	ldr	r3, [pc, #68]	; (121c <USB_Handler+0x1e8>)
    11d8:	e7da      	b.n	1190 <USB_Handler+0x15c>
	} 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 <USB_Handler+0x15e>
		if (flags & USB_DEVICE_EPINTFLAG_TRFAIL1) {
    11e2:	071a      	lsls	r2, r3, #28
    11e4:	d5e7      	bpl.n	11b6 <USB_Handler+0x182>
    11e6:	e7d0      	b.n	118a <USB_Handler+0x156>
    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 <is_list_element>:
 * \brief Check whether element belongs to list
 */
bool is_list_element(const struct list_descriptor *const list, const void *const element)
{
	struct list_element *it;
	for (it = list->head; it; it = it->next) {
    1274:	6800      	ldr	r0, [r0, #0]
    1276:	2800      	cmp	r0, #0
    1278:	d100      	bne.n	127c <is_list_element+0x8>
			return true;
		}
	}

	return false;
}
    127a:	4770      	bx	lr
		if (it == element) {
    127c:	4288      	cmp	r0, r1
    127e:	d1f9      	bne.n	1274 <is_list_element>
			return true;
    1280:	2001      	movs	r0, #1
    1282:	e7fa      	b.n	127a <is_list_element+0x6>

00001284 <list_insert_at_end>:

/**
 * \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 <list_insert_at_end+0x34>)
{
    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 <list_insert_at_end+0x38>)
    1298:	4909      	ldr	r1, [pc, #36]	; (12c0 <list_insert_at_end+0x3c>)
    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_insert_at_end+0x26>
		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 <list_insert_at_end+0x26>
	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 <list_insert_at_end+0x24>
    12b8:	00001275 	.word	0x00001275
    12bc:	000012c5 	.word	0x000012c5
    12c0:	0000239c 	.word	0x0000239c

000012c4 <assert>:
/**
 * \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 <assert+0x6>
		__asm("BKPT #0");
    12c8:	be00      	bkpt	0x0000
	}
	(void)file;
	(void)line;
}
    12ca:	4770      	bx	lr

000012cc <cdc_device_acm_init>:
 * \brief CDC ACM Init
 */
void cdc_device_acm_init(void)
{
	/* usb stack init */
	usbdc_init(ctrl_buffer);
    12cc:	4806      	ldr	r0, [pc, #24]	; (12e8 <cdc_device_acm_init+0x1c>)
{
    12ce:	b510      	push	{r4, lr}
	usbdc_init(ctrl_buffer);
    12d0:	4b06      	ldr	r3, [pc, #24]	; (12ec <cdc_device_acm_init+0x20>)
    12d2:	3040      	adds	r0, #64	; 0x40
    12d4:	4798      	blx	r3

	/* usbdc_register_funcion inside */
	cdcdf_acm_init();
    12d6:	4b06      	ldr	r3, [pc, #24]	; (12f0 <cdc_device_acm_init+0x24>)
    12d8:	4798      	blx	r3

	usbdc_start(single_desc);
    12da:	4b06      	ldr	r3, [pc, #24]	; (12f4 <cdc_device_acm_init+0x28>)
    12dc:	4806      	ldr	r0, [pc, #24]	; (12f8 <cdc_device_acm_init+0x2c>)
    12de:	4798      	blx	r3
	usbdc_attach();
    12e0:	4b06      	ldr	r3, [pc, #24]	; (12fc <cdc_device_acm_init+0x30>)
    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 <usb_init>:
	while (1) {
	}
}

void usb_init(void)
{
    1300:	b510      	push	{r4, lr}

	cdc_device_acm_init();
    1302:	4b01      	ldr	r3, [pc, #4]	; (1308 <usb_init+0x8>)
    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 <usart_sync_write>:
 * \param[in] length The number of bytes to write
 *
 * \return The number of bytes written.
 */
static int32_t usart_sync_write(struct io_descriptor *const io_descr, const uint8_t *const buf, const uint16_t length)
{
    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 <usart_sync_write+0x16>
    13a4:	1e08      	subs	r0, r1, #0
    13a6:	d002      	beq.n	13ae <usart_sync_write+0x16>
    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 <usart_sync_write+0x5c>)
    13b2:	4b11      	ldr	r3, [pc, #68]	; (13f8 <usart_sync_write+0x60>)
    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 <usart_sync_write+0x64>)
    13be:	4798      	blx	r3
    13c0:	2800      	cmp	r0, #0
    13c2:	d0f8      	beq.n	13b6 <usart_sync_write+0x1e>
	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 <usart_sync_write+0x68>)
    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 <usart_sync_write+0x64>)
    13d2:	4798      	blx	r3
    13d4:	2800      	cmp	r0, #0
    13d6:	d0fa      	beq.n	13ce <usart_sync_write+0x36>
			;
	} while (++offset < length);
    13d8:	3601      	adds	r6, #1
    13da:	42b4      	cmp	r4, r6
    13dc:	d8f3      	bhi.n	13c6 <usart_sync_write+0x2e>
    13de:	2501      	movs	r5, #1
    13e0:	2c00      	cmp	r4, #0
    13e2:	d000      	beq.n	13e6 <usart_sync_write+0x4e>
    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 <usart_sync_write+0x6c>)
    13ea:	4798      	blx	r3
    13ec:	2800      	cmp	r0, #0
    13ee:	d0fa      	beq.n	13e6 <usart_sync_write+0x4e>
		;
	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 <usart_sync_read>:
 * \param[in] length The size of a buffer
 *
 * \return The number of bytes read.
 */
static int32_t usart_sync_read(struct io_descriptor *const io_descr, uint8_t *const buf, const uint16_t length)
{
    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 <usart_sync_read+0x16>
    1414:	1e08      	subs	r0, r1, #0
    1416:	d002      	beq.n	141e <usart_sync_read+0x16>
    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 <usart_sync_read+0x4c>)
    1422:	4b0d      	ldr	r3, [pc, #52]	; (1458 <usart_sync_read+0x50>)
    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 <usart_sync_read+0x54>)
    1432:	4798      	blx	r3
    1434:	2800      	cmp	r0, #0
    1436:	d0f8      	beq.n	142a <usart_sync_read+0x22>
			;
		buf[offset] = _usart_sync_read_byte(&descr->device);
    1438:	4b09      	ldr	r3, [pc, #36]	; (1460 <usart_sync_read+0x58>)
    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 <usart_sync_read+0x22>
    1448:	2001      	movs	r0, #1
    144a:	2c00      	cmp	r4, #0
    144c:	d000      	beq.n	1450 <usart_sync_read+0x48>
    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 <usart_sync_init>:
{
    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 <usart_sync_init+0x10>
    146e:	0008      	movs	r0, r1
    1470:	1e43      	subs	r3, r0, #1
    1472:	4198      	sbcs	r0, r3
    1474:	4907      	ldr	r1, [pc, #28]	; (1494 <usart_sync_init+0x30>)
    1476:	4b08      	ldr	r3, [pc, #32]	; (1498 <usart_sync_init+0x34>)
    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 <usart_sync_init+0x38>)
    1482:	3008      	adds	r0, #8
    1484:	4798      	blx	r3
	if (init_status) {
    1486:	2800      	cmp	r0, #0
    1488:	d103      	bne.n	1492 <usart_sync_init+0x2e>
	descr->io.read  = usart_sync_read;
    148a:	4b05      	ldr	r3, [pc, #20]	; (14a0 <usart_sync_init+0x3c>)
    148c:	6063      	str	r3, [r4, #4]
	descr->io.write = usart_sync_write;
    148e:	4b05      	ldr	r3, [pc, #20]	; (14a4 <usart_sync_init+0x40>)
    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 <usb_find_desc>:
#define _param_error_check(cond) ASSERT(cond)
#define _desc_len_check() ASSERT(usb_desc_len(desc) >= 2)
#endif

uint8_t *usb_find_desc(uint8_t *desc, uint8_t *eof, uint8_t type)
{
    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 <usb_find_desc+0xa>
		_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 <usb_find_desc+0x6>
		if (type == usb_desc_type(desc)) {
    14f4:	7844      	ldrb	r4, [r0, #1]
    14f6:	4294      	cmp	r4, r2
    14f8:	d0f8      	beq.n	14ec <usb_find_desc+0x8>
	return (desc + usb_desc_len(desc));
    14fa:	18c0      	adds	r0, r0, r3
    14fc:	e7f3      	b.n	14e6 <usb_find_desc+0x2>

000014fe <usb_find_ep_desc>:

uint8_t *usb_find_ep_desc(uint8_t *desc, uint8_t *eof)
{
	_param_error_check(desc && eof && (desc < eof));

	while (desc < eof) {
    14fe:	4288      	cmp	r0, r1
    1500:	d301      	bcc.n	1506 <usb_find_ep_desc+0x8>
		_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 <usb_find_ep_desc+0x4>
	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 <usb_find_ep_desc+0x4>
		if (USB_DT_ENDPOINT == usb_desc_type(desc)) {
    1512:	2a05      	cmp	r2, #5
    1514:	d0f6      	beq.n	1504 <usb_find_ep_desc+0x6>
	return (desc + usb_desc_len(desc));
    1516:	18c0      	adds	r0, r0, r3
    1518:	e7f1      	b.n	14fe <usb_find_ep_desc>
	...

0000151c <usb_find_cfg_desc>:

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 <usb_find_cfg_desc+0x38>)
{
    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 <usb_find_cfg_desc+0x30>
			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 <usb_find_cfg_desc+0x34>
		if (desc[1] != USB_DT_CONFIG) {
    1534:	7843      	ldrb	r3, [r0, #1]
    1536:	2b02      	cmp	r3, #2
    1538:	d10a      	bne.n	1550 <usb_find_cfg_desc+0x34>
		if (desc[5] == cfg_value) {
    153a:	7943      	ldrb	r3, [r0, #5]
    153c:	42ab      	cmp	r3, r5
    153e:	d0f5      	beq.n	152c <usb_find_cfg_desc+0x10>
	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 <usb_find_cfg_desc+0x12>
		return NULL;
    1550:	2000      	movs	r0, #0
    1552:	e7eb      	b.n	152c <usb_find_cfg_desc+0x10>
    1554:	000014e5 	.word	0x000014e5

00001558 <usb_find_str_desc>:
	}
	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 <usb_find_str_desc+0x10>
				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 <usb_find_str_desc+0x2c>)
    156e:	4798      	blx	r3
		if (desc) {
    1570:	2800      	cmp	r0, #0
    1572:	d0f8      	beq.n	1566 <usb_find_str_desc+0xe>
	return desc[0];
    1574:	7803      	ldrb	r3, [r0, #0]
			_desc_len_check();
    1576:	2b01      	cmp	r3, #1
    1578:	d9f4      	bls.n	1564 <usb_find_str_desc+0xc>
			if (i == str_index) {
    157a:	42b5      	cmp	r5, r6
    157c:	d0f3      	beq.n	1566 <usb_find_str_desc+0xe>
	return (desc + usb_desc_len(desc));
    157e:	18c0      	adds	r0, r0, r3
    1580:	3501      	adds	r5, #1
    1582:	e7ed      	b.n	1560 <usb_find_str_desc+0x8>
    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 <usb_d_dummy_cb_false>:
{
	(void)unused0;
	(void)unused1;
	(void)unused2;
	return false;
}
    15bc:	2000      	movs	r0, #0
    15be:	4770      	bx	lr

000015c0 <usb_d_cb_trans_more>:
 * \brief Callback invoked when request more data
 * \param[in] ep Endpoint number with transfer direction on bit 8.
 * \param[in] transfered Number of bytes transfered.
 */
static bool usb_d_cb_trans_more(const uint8_t ep, const uint32_t transfered)
{
    15c0:	b570      	push	{r4, r5, r6, lr}
	int8_t           ep_index = _usb_d_find_ep(ep);
    15c2:	4b08      	ldr	r3, [pc, #32]	; (15e4 <usb_d_cb_trans_more+0x24>)
{
    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 <usb_d_cb_trans_more+0x28>)
    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 <usb_d_cb_trans_more+0x20>
		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 <usb_d_cb_trans_setup>:
{
    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 <usb_d_cb_trans_setup+0x64>)
{
    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 <usb_d_cb_trans_setup+0x68>)
    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 <usb_d_cb_trans_setup+0x6c>)
    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 <usb_d_cb_trans_setup+0x70>)
	if (n != 8) {
    170a:	2808      	cmp	r0, #8
    170c:	d006      	beq.n	171c <usb_d_cb_trans_setup+0x38>
		_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 <usb_d_cb_trans_setup+0x36>
		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 <usb_d_cb_trans_setup+0x32>
    1748:	00001589 	.word	0x00001589
    174c:	20000310 	.word	0x20000310
    1750:	00000e71 	.word	0x00000e71
    1754:	00000da9 	.word	0x00000da9

00001758 <usb_d_init>:

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 <usb_d_init+0x48>)
    175c:	4798      	blx	r3
	uint8_t i;
	if (rc < 0) {
    175e:	2800      	cmp	r0, #0
    1760:	db1d      	blt.n	179e <usb_d_init+0x46>
		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 <usb_d_init+0x4c>)
    1764:	2280      	movs	r2, #128	; 0x80
    1766:	2100      	movs	r1, #0
    1768:	0020      	movs	r0, r4
    176a:	4b0f      	ldr	r3, [pc, #60]	; (17a8 <usb_d_init+0x50>)
    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 <usb_d_init+0x54>)
	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 <usb_d_init+0x1e>
	}
	/* Handles device driver endpoint callbacks to build transfer. */
	_usb_d_dev_register_ep_callback(USB_D_DEV_EP_CB_SETUP, (FUNC_PTR)usb_d_cb_trans_setup);
    1788:	4d09      	ldr	r5, [pc, #36]	; (17b0 <usb_d_init+0x58>)
    178a:	0020      	movs	r0, r4
    178c:	4909      	ldr	r1, [pc, #36]	; (17b4 <usb_d_init+0x5c>)
    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 <usb_d_init+0x60>)
    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 <usb_d_init+0x64>)
    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_register_callback>:
{
	_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 <usb_d_register_callback+0x8>)
    17c4:	4798      	blx	r3
}
    17c6:	bd10      	pop	{r4, pc}
    17c8:	00000fe5 	.word	0x00000fe5

000017cc <usb_d_enable>:

int32_t usb_d_enable(void)
{
    17cc:	b510      	push	{r4, lr}
	return _usb_d_dev_enable();
    17ce:	4b01      	ldr	r3, [pc, #4]	; (17d4 <usb_d_enable+0x8>)
    17d0:	4798      	blx	r3
}
    17d2:	bd10      	pop	{r4, pc}
    17d4:	00000ac1 	.word	0x00000ac1

000017d8 <usb_d_attach>:
{
	_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 <usb_d_attach+0x8>)
    17dc:	4798      	blx	r3
}
    17de:	bd10      	pop	{r4, pc}
    17e0:	00000b09 	.word	0x00000b09

000017e4 <usb_d_set_address>:
{
	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 <usb_d_set_address+0x8>)
    17e8:	4798      	blx	r3
}
    17ea:	bd10      	pop	{r4, pc}
    17ec:	00000b19 	.word	0x00000b19

000017f0 <usb_d_ep_init>:
{
	return usb_d_ep_init(0, USB_EP_XTYPE_CTRL, max_pkt_size);
}

int32_t usb_d_ep_init(const uint8_t ep, const uint8_t attr, const uint16_t max_pkt_size)
{
    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 <usb_d_ep_init+0x44>)
{
    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 <usb_d_ep_init+0x38>
		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 <usb_d_ep_init+0x3e>
			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 <usb_d_ep_init+0x48>)
    1810:	4798      	blx	r3
	if (rc < 0) {
    1812:	2800      	cmp	r0, #0
    1814:	db07      	blt.n	1826 <usb_d_ep_init+0x36>
		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 <usb_d_ep_init+0x4c>)
    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 <usb_d_ep_init+0x36>
    182e:	2015      	movs	r0, #21
    1830:	e7fb      	b.n	182a <usb_d_ep_init+0x3a>
    1832:	46c0      	nop			; (mov r8, r8)
    1834:	00001589 	.word	0x00001589
    1838:	00000b29 	.word	0x00000b29
    183c:	20000310 	.word	0x20000310

00001840 <usb_d_ep0_init>:
	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 <usb_d_ep0_init+0x10>)
    184a:	4798      	blx	r3
}
    184c:	bd10      	pop	{r4, pc}
    184e:	46c0      	nop			; (mov r8, r8)
    1850:	000017f1 	.word	0x000017f1

00001854 <usb_d_ep_deinit>:

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 <usb_d_ep_deinit+0x20>)
{
    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 <usb_d_ep_deinit+0x1c>
		return;
	}
	_usb_d_dev_ep_deinit(ep);
    1860:	0028      	movs	r0, r5
    1862:	4b05      	ldr	r3, [pc, #20]	; (1878 <usb_d_ep_deinit+0x24>)
    1864:	4798      	blx	r3
	ept->xfer.hdr.ep = 0xFF;
    1866:	23ff      	movs	r3, #255	; 0xff
    1868:	4804      	ldr	r0, [pc, #16]	; (187c <usb_d_ep_deinit+0x28>)
    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 <usb_d_ep_enable>:

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 <usb_d_ep_enable+0x34>)
{
    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 <usb_d_ep_enable+0x2c>
		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 <usb_d_ep_enable+0x38>)
    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 <usb_d_ep_enable+0x3c>)
	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 <usb_d_ep_enable+0x2a>
		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 <usb_d_ep_enable+0x2a>
    18b2:	46c0      	nop			; (mov r8, r8)
    18b4:	00001589 	.word	0x00001589
    18b8:	20000310 	.word	0x20000310
    18bc:	00000c69 	.word	0x00000c69

000018c0 <usb_d_ep_transfer>:
	}
	return usb_d_inst.ep[ep_index].xfer.req;
}

int32_t usb_d_ep_transfer(const struct usb_d_transfer *xfer)
{
    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 <usb_d_ep_transfer+0xd8>)
    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 <usb_d_ep_transfer+0xd2>
		return -USB_ERR_PARAM;
	}

	atomic_enter_critical(&flags);
    18da:	4b30      	ldr	r3, [pc, #192]	; (199c <usb_d_ep_transfer+0xdc>)
    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 <usb_d_ep_transfer+0xe0>)
    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 <usb_d_ep_transfer+0xe4>)
    18fa:	2a01      	cmp	r2, #1
    18fc:	d11d      	bne.n	193a <usb_d_ep_transfer+0x7a>
		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 <usb_d_ep_transfer+0xe0>)
    1908:	9a00      	ldr	r2, [sp, #0]
    190a:	5cd3      	ldrb	r3, [r2, r3]
    190c:	2b00      	cmp	r3, #0
    190e:	d01f      	beq.n	1950 <usb_d_ep_transfer+0x90>
	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 <usb_d_ep_transfer+0xcc>
    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 <usb_d_ep_transfer+0xe8>)
    1934:	a807      	add	r0, sp, #28
    1936:	4798      	blx	r3
	return rc;
    1938:	e008      	b.n	194c <usb_d_ep_transfer+0x8c>
		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 <usb_d_ep_transfer+0x8c>
    1948:	4b18      	ldr	r3, [pc, #96]	; (19ac <usb_d_ep_transfer+0xec>)
    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 <usb_d_ep_transfer+0xaa>
			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 <usb_d_ep_transfer+0x5c>
			if (len > req_len) {
    196a:	429d      	cmp	r5, r3
    196c:	d900      	bls.n	1970 <usb_d_ep_transfer+0xb0>
    196e:	001d      	movs	r5, r3
			dir = (USB_GET_bmRequestType(ept->xfer.req) & USB_REQ_TYPE_IN);
    1970:	490b      	ldr	r1, [pc, #44]	; (19a0 <usb_d_ep_transfer+0xe0>)
				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 <usb_d_ep_transfer+0x5c>
				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 <usb_d_ep_transfer+0x5c>
	struct usb_d_transfer trans
    198c:	230f      	movs	r3, #15
    198e:	401a      	ands	r2, r3
    1990:	e7cc      	b.n	192c <usb_d_ep_transfer+0x6c>
		return -USB_ERR_PARAM;
    1992:	2012      	movs	r0, #18
    1994:	4240      	negs	r0, r0
    1996:	e7d9      	b.n	194c <usb_d_ep_transfer+0x8c>
    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 <usb_d_ep_halt>:
	}
	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 <usb_d_ep_halt+0x3e>
	int8_t           ep_index = _usb_d_find_ep(ep);
    19b8:	4b12      	ldr	r3, [pc, #72]	; (1a04 <usb_d_ep_halt+0x54>)
    19ba:	4798      	blx	r3
    19bc:	1e04      	subs	r4, r0, #0
	if (ep_index < 0) {
    19be:	db1d      	blt.n	19fc <usb_d_ep_halt+0x4c>
	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 <usb_d_ep_halt+0x58>)
    19c6:	47b8      	blx	r7
    19c8:	2800      	cmp	r0, #0
    19ca:	d00f      	beq.n	19ec <usb_d_ep_halt+0x3c>
		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 <usb_d_ep_halt+0x3c>
		ept->xfer.hdr.state  = USB_EP_S_IDLE;
    19d6:	480d      	ldr	r0, [pc, #52]	; (1a0c <usb_d_ep_halt+0x5c>)
    19d8:	4b0d      	ldr	r3, [pc, #52]	; (1a10 <usb_d_ep_halt+0x60>)
    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 <usb_d_ep_halt+0x58>)
    19f0:	2901      	cmp	r1, #1
    19f2:	d000      	beq.n	19f6 <usb_d_ep_halt+0x46>
		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 <usb_d_ep_halt+0x3c>
		return -USB_ERR_PARAM;
    19fc:	2012      	movs	r0, #18
    19fe:	4240      	negs	r0, r0
    1a00:	e7f4      	b.n	19ec <usb_d_ep_halt+0x3c>
    1a02:	46c0      	nop			; (mov r8, r8)
    1a04:	00001589 	.word	0x00001589
    1a08:	00000da9 	.word	0x00000da9
    1a0c:	20000310 	.word	0x20000310
    1a10:	00000301 	.word	0x00000301

00001a14 <usb_d_ep_register_callback>:

void usb_d_ep_register_callback(const uint8_t ep, const enum usb_d_ep_cb_type type, const FUNC_PTR func)
{
    1a14:	b570      	push	{r4, r5, r6, lr}
	int8_t           ep_index = _usb_d_find_ep(ep);
    1a16:	4b0f      	ldr	r3, [pc, #60]	; (1a54 <usb_d_ep_register_callback+0x40>)
{
    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 <usb_d_ep_register_callback+0x10>
    1a22:	4c0d      	ldr	r4, [pc, #52]	; (1a58 <usb_d_ep_register_callback+0x44>)
	if (ep_index < 0) {
    1a24:	2800      	cmp	r0, #0
    1a26:	db09      	blt.n	1a3c <usb_d_ep_register_callback+0x28>
		return;
	}
	switch (type) {
    1a28:	2d01      	cmp	r5, #1
    1a2a:	d008      	beq.n	1a3e <usb_d_ep_register_callback+0x2a>
    1a2c:	2d02      	cmp	r5, #2
    1a2e:	d00b      	beq.n	1a48 <usb_d_ep_register_callback+0x34>
    1a30:	2d00      	cmp	r5, #0
    1a32:	d103      	bne.n	1a3c <usb_d_ep_register_callback+0x28>
	case USB_D_EP_CB_SETUP:
		ept->callbacks.req = (usb_d_ep_cb_setup_t)f;
    1a34:	4b09      	ldr	r3, [pc, #36]	; (1a5c <usb_d_ep_register_callback+0x48>)
    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 <usb_d_ep_register_callback+0x48>)
    1a40:	0140      	lsls	r0, r0, #5
    1a42:	1818      	adds	r0, r3, r0
    1a44:	6184      	str	r4, [r0, #24]
		break;
    1a46:	e7f9      	b.n	1a3c <usb_d_ep_register_callback+0x28>
		ept->callbacks.xfer = (usb_d_ep_cb_xfer_t)f;
    1a48:	4b04      	ldr	r3, [pc, #16]	; (1a5c <usb_d_ep_register_callback+0x48>)
    1a4a:	0140      	lsls	r0, r0, #5
    1a4c:	1818      	adds	r0, r3, r0
    1a4e:	61c4      	str	r4, [r0, #28]
		break;
    1a50:	e7f4      	b.n	1a3c <usb_d_ep_register_callback+0x28>
    1a52:	46c0      	nop			; (mov r8, r8)
    1a54:	00001589 	.word	0x00001589
    1a58:	000015bd 	.word	0x000015bd
    1a5c:	20000310 	.word	0x20000310

00001a60 <main>:
#include <atmel_start.h>

int main(void)
{
    1a60:	b510      	push	{r4, lr}
	/* Initializes MCU, drivers and middleware */
	atmel_start_init();
    1a62:	4b01      	ldr	r3, [pc, #4]	; (1a68 <main+0x8>)
    1a64:	4798      	blx	r3

	/* Replace with your application code */
	while (1) {
    1a66:	e7fe      	b.n	1a66 <main+0x6>
    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 <USART_0_PORT_init>:
#include <hpl_pm_base.h>

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 <USART_0_PORT_init+0x14>)
    1ab2:	4904      	ldr	r1, [pc, #16]	; (1ac4 <USART_0_PORT_init+0x18>)
    1ab4:	47a0      	blx	r4
    1ab6:	2017      	movs	r0, #23
    1ab8:	4903      	ldr	r1, [pc, #12]	; (1ac8 <USART_0_PORT_init+0x1c>)
    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 <USART_0_CLOCK_init>:
			peripheral = (uint32_t)_pm_get_apbb_index(module);
			PM->APBBMASK.reg |= 1 << peripheral;
		}
		break;
	case PM_BUS_APBC:
		PM->APBCMASK.reg |= 1 << peripheral;
    1acc:	2320      	movs	r3, #32
    1ace:	4a04      	ldr	r2, [pc, #16]	; (1ae0 <USART_0_CLOCK_init+0x14>)
    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 <USART_0_CLOCK_init+0x18>)
    1ad8:	4a03      	ldr	r2, [pc, #12]	; (1ae8 <USART_0_CLOCK_init+0x1c>)
    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 <USART_0_init>:

void USART_0_init(void)
{
    1aec:	b510      	push	{r4, lr}
	USART_0_CLOCK_init();
    1aee:	4b05      	ldr	r3, [pc, #20]	; (1b04 <USART_0_init+0x18>)
    1af0:	4798      	blx	r3
	usart_sync_init(&USART_0, SERCOM3, (void *)NULL);
    1af2:	2200      	movs	r2, #0
    1af4:	4904      	ldr	r1, [pc, #16]	; (1b08 <USART_0_init+0x1c>)
    1af6:	4b05      	ldr	r3, [pc, #20]	; (1b0c <USART_0_init+0x20>)
    1af8:	4805      	ldr	r0, [pc, #20]	; (1b10 <USART_0_init+0x24>)
    1afa:	4798      	blx	r3
	USART_0_PORT_init();
    1afc:	4b05      	ldr	r3, [pc, #20]	; (1b14 <USART_0_init+0x28>)
    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 <USB_DEVICE_INSTANCE_PORT_init>:

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 <USB_DEVICE_INSTANCE_PORT_init+0x50>)
    1b22:	4a12      	ldr	r2, [pc, #72]	; (1b6c <USB_DEVICE_INSTANCE_PORT_init+0x54>)
	((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 <USB_DEVICE_INSTANCE_PORT_init+0x58>)
    1b42:	4b0c      	ldr	r3, [pc, #48]	; (1b74 <USB_DEVICE_INSTANCE_PORT_init+0x5c>)
    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 <USB_DEVICE_INSTANCE_PORT_init+0x60>)
	((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 <USB_DEVICE_INSTANCE_PORT_init+0x64>)
    1b60:	4b04      	ldr	r3, [pc, #16]	; (1b74 <USB_DEVICE_INSTANCE_PORT_init+0x5c>)
    1b62:	4798      	blx	r3
	                      // <GPIO_PIN_FUNCTION_E"> E
	                      // <GPIO_PIN_FUNCTION_F"> F
	                      // <GPIO_PIN_FUNCTION_G"> G
	                      // <GPIO_PIN_FUNCTION_H"> 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 <USB_DEVICE_INSTANCE_CLOCK_init>:
			PM->APBBMASK.reg |= 1 << peripheral;
    1b80:	2220      	movs	r2, #32
    1b82:	4b06      	ldr	r3, [pc, #24]	; (1b9c <USB_DEVICE_INSTANCE_CLOCK_init+0x1c>)
    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 <USB_DEVICE_INSTANCE_CLOCK_init+0x20>)
    1b94:	4a03      	ldr	r2, [pc, #12]	; (1ba4 <USB_DEVICE_INSTANCE_CLOCK_init+0x24>)
    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 <USB_DEVICE_INSTANCE_init>:

void USB_DEVICE_INSTANCE_init(void)
{
    1ba8:	b510      	push	{r4, lr}
	USB_DEVICE_INSTANCE_CLOCK_init();
    1baa:	4b03      	ldr	r3, [pc, #12]	; (1bb8 <USB_DEVICE_INSTANCE_init+0x10>)
    1bac:	4798      	blx	r3
	usb_d_init();
    1bae:	4b03      	ldr	r3, [pc, #12]	; (1bbc <USB_DEVICE_INSTANCE_init+0x14>)
    1bb0:	4798      	blx	r3
	USB_DEVICE_INSTANCE_PORT_init();
    1bb2:	4b03      	ldr	r3, [pc, #12]	; (1bc0 <USB_DEVICE_INSTANCE_init+0x18>)
    1bb4:	4798      	blx	r3
}
    1bb6:	bd10      	pop	{r4, pc}
    1bb8:	00001b81 	.word	0x00001b81
    1bbc:	00001759 	.word	0x00001759
    1bc0:	00001b19 	.word	0x00001b19

00001bc4 <system_init>:

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 <system_init+0x10>)
    1bc8:	4798      	blx	r3
	init_mcu();

	USART_0_init();
    1bca:	4b03      	ldr	r3, [pc, #12]	; (1bd8 <system_init+0x14>)
    1bcc:	4798      	blx	r3

	USB_DEVICE_INSTANCE_init();
    1bce:	4b03      	ldr	r3, [pc, #12]	; (1bdc <system_init+0x18>)
    1bd0:	4798      	blx	r3
}
    1bd2:	bd10      	pop	{r4, pc}
    1bd4:	00001241 	.word	0x00001241
    1bd8:	00001aed 	.word	0x00001aed
    1bdc:	00001ba9 	.word	0x00001ba9

00001be0 <hri_sercomusart_wait_for_sync>:
	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 <hri_sercomusart_wait_for_sync>
	};
}
    1be6:	4770      	bx	lr

00001be8 <hri_sercomusart_clear_CTRLA_ENABLE_bit>:
}

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 <hri_sercomusart_clear_CTRLA_ENABLE_bit+0x14>)
    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 <atmel_start_init>:

/**
 * 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 <atmel_start_init+0xc>)
    1cec:	4798      	blx	r3
	usb_init();
    1cee:	4b02      	ldr	r3, [pc, #8]	; (1cf8 <atmel_start_init+0x10>)
    1cf0:	4798      	blx	r3
}
    1cf2:	bd10      	pop	{r4, pc}
    1cf4:	00001bc5 	.word	0x00001bc5
    1cf8:	00001301 	.word	0x00001301

00001cfc <usbdc_unconfig>:
/**
 * \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 <usbdc_unconfig+0x1c>)
{
    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 <usbdc_unconfig+0xc>
		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 <usbdc_unconfig+0x6>
    1d16:	46c0      	nop			; (mov r8, r8)
    1d18:	2000039c 	.word	0x2000039c

00001d1c <usbdc_change_notify>:
	}
}

/** 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 <usbdc_change_notify+0x20>)
    1d24:	68dc      	ldr	r4, [r3, #12]

	while (cg != NULL) {
    1d26:	2c00      	cmp	r4, #0
    1d28:	d100      	bne.n	1d2c <usbdc_change_notify+0x10>
		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 <usbdc_change_notify+0x1c>
			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 <usbdc_change_notify+0xa>
    1d3c:	2000039c 	.word	0x2000039c

00001d40 <usbdc_request_handler>:

/** Invoke all registered request callbacks until request handled. */
static int32_t usbdc_request_handler(uint8_t ep, struct usb_req *req, enum usb_ctrl_stage stage)
{
    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 <usbdc_request_handler+0x38>)
    1d4a:	689c      	ldr	r4, [r3, #8]
	int32_t                   rc;

	while (h != NULL) {
    1d4c:	2c00      	cmp	r4, #0
    1d4e:	d101      	bne.n	1d54 <usbdc_request_handler+0x14>
				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 <usbdc_request_handler+0x1e>
		h = h->next;
    1d5a:	6824      	ldr	r4, [r4, #0]
    1d5c:	e7f6      	b.n	1d4c <usbdc_request_handler+0xc>
			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 <usbdc_request_handler+0x34>
			} else if (ERR_NOT_FOUND != rc) {
    1d6a:	300a      	adds	r0, #10
    1d6c:	d0f5      	beq.n	1d5a <usbdc_request_handler+0x1a>
				return -1;
    1d6e:	2001      	movs	r0, #1
    1d70:	4240      	negs	r0, r0
    1d72:	e7ee      	b.n	1d52 <usbdc_request_handler+0x12>
				return true;
    1d74:	2001      	movs	r0, #1
    1d76:	e7ec      	b.n	1d52 <usbdc_request_handler+0x12>
    1d78:	2000039c 	.word	0x2000039c

00001d7c <usbd_sof_cb>:
	struct usbdc_sof_handler *sof = (struct usbdc_sof_handler *)usbdc.handlers.sof_list.head;
    1d7c:	4b05      	ldr	r3, [pc, #20]	; (1d94 <usbd_sof_cb+0x18>)

/**
 * \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 <usbd_sof_cb+0xc>
	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 <usbd_sof_cb+0x14>
			sof->cb();
    1d8e:	4798      	blx	r3
		sof = sof->next;
    1d90:	6824      	ldr	r4, [r4, #0]
    1d92:	e7f6      	b.n	1d82 <usbd_sof_cb+0x6>
    1d94:	2000039c 	.word	0x2000039c

00001d98 <usbdc_cb_ctl_done>:
 * \return Data has error or not.
 * \retval true There is data error, protocol error.
 * \retval false There is no data error.
 */
static bool usbdc_cb_ctl_done(const uint8_t ep, const enum usb_xfer_code code, struct usb_req *req)
{
    1d98:	b510      	push	{r4, lr}
    1d9a:	0014      	movs	r4, r2
	(void)ep;

	switch (code) {
    1d9c:	2900      	cmp	r1, #0
    1d9e:	d003      	beq.n	1da8 <usbdc_cb_ctl_done+0x10>
    1da0:	2901      	cmp	r1, #1
    1da2:	d023      	beq.n	1dec <usbdc_cb_ctl_done+0x54>
		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 <usbdc_cb_ctl_done+0xc>
	switch (req->bRequest) {
    1dae:	7853      	ldrb	r3, [r2, #1]
    1db0:	2b05      	cmp	r3, #5
    1db2:	d00f      	beq.n	1dd4 <usbdc_cb_ctl_done+0x3c>
    1db4:	2b09      	cmp	r3, #9
    1db6:	d1f5      	bne.n	1da4 <usbdc_cb_ctl_done+0xc>
		usbdc.cfg_value = req->wValue;
    1db8:	78e1      	ldrb	r1, [r4, #3]
    1dba:	7892      	ldrb	r2, [r2, #2]
    1dbc:	4b0e      	ldr	r3, [pc, #56]	; (1df8 <usbdc_cb_ctl_done+0x60>)
    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 <usbdc_cb_ctl_done+0x64>)
    1dd0:	4798      	blx	r3
		break;
    1dd2:	e7e7      	b.n	1da4 <usbdc_cb_ctl_done+0xc>
	usb_d_set_address(addr);
    1dd4:	4b0a      	ldr	r3, [pc, #40]	; (1e00 <usbdc_cb_ctl_done+0x68>)
    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 <usbdc_cb_ctl_done+0x60>)
    1de8:	3102      	adds	r1, #2
    1dea:	e7ee      	b.n	1dca <usbdc_cb_ctl_done+0x32>
	usbdc_request_handler(0, req, USB_DATA_STAGE);
    1dec:	000a      	movs	r2, r1
    1dee:	4b05      	ldr	r3, [pc, #20]	; (1e04 <usbdc_cb_ctl_done+0x6c>)
    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 <usbdc_cb_ctl_done+0xc>
    1df8:	2000039c 	.word	0x2000039c
    1dfc:	00001d1d 	.word	0x00001d1d
    1e00:	000017e5 	.word	0x000017e5
    1e04:	00001d41 	.word	0x00001d41

00001e08 <usbdc_reset>:

/**
 * \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 <usbdc_reset+0x38>)
    1e10:	4798      	blx	r3
	usbdc.state       = USBD_S_DEFAULT;
    1e12:	4d0c      	ldr	r5, [pc, #48]	; (1e44 <usbdc_reset+0x3c>)

	// 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_reset+0x40>)
	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 <usbdc_reset+0x44>)
    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 <usbdc_reset+0x48>)
    1e26:	0021      	movs	r1, r4
    1e28:	0020      	movs	r0, r4
    1e2a:	4a0a      	ldr	r2, [pc, #40]	; (1e54 <usbdc_reset+0x4c>)
    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 <usbdc_reset+0x50>)
    1e34:	47a8      	blx	r5
	usb_d_ep_enable(0);
    1e36:	0020      	movs	r0, r4
    1e38:	4b08      	ldr	r3, [pc, #32]	; (1e5c <usbdc_reset+0x54>)
    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 <usbd_event_cb>:
 * \brief Callback invoked on USB device events
 * \param[in] ev Event code.
 * \param[in] param Event parameter for event handling.
 */
static void usbd_event_cb(const enum usb_event ev, const uint32_t param)
{
    1e60:	b510      	push	{r4, lr}
	(void)param;

	switch (ev) {
    1e62:	2800      	cmp	r0, #0
    1e64:	d002      	beq.n	1e6c <usbd_event_cb+0xc>
    1e66:	2801      	cmp	r0, #1
    1e68:	d003      	beq.n	1e72 <usbd_event_cb+0x12>
		break;

	default:
		break;
	}
}
    1e6a:	bd10      	pop	{r4, pc}
		usbdc_change_notify(USBDC_C_CONN, param);
    1e6c:	4b02      	ldr	r3, [pc, #8]	; (1e78 <usbd_event_cb+0x18>)
    1e6e:	4798      	blx	r3
		break;
    1e70:	e7fb      	b.n	1e6a <usbd_event_cb+0xa>
		usbdc_reset();
    1e72:	4b02      	ldr	r3, [pc, #8]	; (1e7c <usbd_event_cb+0x1c>)
    1e74:	4798      	blx	r3
}
    1e76:	e7f8      	b.n	1e6a <usbd_event_cb+0xa>
    1e78:	00001d1d 	.word	0x00001d1d
    1e7c:	00001e09 	.word	0x00001e09

00001e80 <usbdc_xfer>:

/**
 * \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 <usbdc_xfer+0x18>)
	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 <usbdc_cb_ctl_req>:
{
    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 <STACK_SIZE+0x17c>)
    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 <usbdc_cb_ctl_req+0x16>
    1eb0:	e0c1      	b.n	2036 <STACK_SIZE+0x36>
    1eb2:	3001      	adds	r0, #1
    1eb4:	4283      	cmp	r3, r0
    1eb6:	d100      	bne.n	1eba <usbdc_cb_ctl_req+0x1e>
    1eb8:	e0bd      	b.n	2036 <STACK_SIZE+0x36>
	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 <usbdc_cb_ctl_req+0x32>
    1ec4:	2980      	cmp	r1, #128	; 0x80
    1ec6:	d100      	bne.n	1eca <usbdc_cb_ctl_req+0x2e>
    1ec8:	e0b6      	b.n	2038 <STACK_SIZE+0x38>
	switch (req->bRequest) {
    1eca:	2000      	movs	r0, #0
    1ecc:	e0b3      	b.n	2036 <STACK_SIZE+0x36>
	switch (req->bRequest) {
    1ece:	7868      	ldrb	r0, [r5, #1]
    1ed0:	3801      	subs	r0, #1
    1ed2:	280a      	cmp	r0, #10
    1ed4:	d8f9      	bhi.n	1eca <usbdc_cb_ctl_req+0x2e>
    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_cb_ctl_req+0x68>
		usbdc_unconfig();
    1eec:	4ba4      	ldr	r3, [pc, #656]	; (2180 <STACK_SIZE+0x180>)
    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 <STACK_SIZE+0x184>)
    1efa:	47a0      	blx	r4
    1efc:	4243      	negs	r3, r0
    1efe:	4158      	adcs	r0, r3
    1f00:	b2c0      	uxtb	r0, r0
    1f02:	e098      	b.n	2036 <STACK_SIZE+0x36>
		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 <STACK_SIZE+0x188>)
    1f06:	682b      	ldr	r3, [r5, #0]
    1f08:	cb03      	ldmia	r3!, {r0, r1}
    1f0a:	4ba0      	ldr	r3, [pc, #640]	; (218c <STACK_SIZE+0x18c>)
    1f0c:	4798      	blx	r3
	if (NULL == cfg_desc) {
    1f0e:	2800      	cmp	r0, #0
    1f10:	d100      	bne.n	1f14 <usbdc_cb_ctl_req+0x78>
    1f12:	e090      	b.n	2036 <STACK_SIZE+0x36>
	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 <STACK_SIZE+0x190>)
	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 <usbdc_cb_ctl_req+0x54>
		if (last_iface != desc.sod[2] /* bInterfaceNumber */) {
    1f32:	789e      	ldrb	r6, [r3, #2]
    1f34:	4296      	cmp	r6, r2
    1f36:	d002      	beq.n	1f3e <usbdc_cb_ctl_req+0xa2>
			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 <usbdc_cb_ctl_req+0xb8>
		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 <STACK_SIZE+0x190>)
    1f4c:	4798      	blx	r3
    1f4e:	0032      	movs	r2, r6
    1f50:	9000      	str	r0, [sp, #0]
    1f52:	e7eb      	b.n	1f2c <usbdc_cb_ctl_req+0x90>
				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 <usbdc_cb_ctl_req+0xa2>
					func = func->next;
    1f62:	683f      	ldr	r7, [r7, #0]
    1f64:	e7e9      	b.n	1f3a <usbdc_cb_ctl_req+0x9e>
	switch (req->bmRequestType & USB_REQT_RECIP_MASK) {
    1f66:	2b02      	cmp	r3, #2
    1f68:	d1af      	bne.n	1eca <usbdc_cb_ctl_req+0x2e>
		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 <usbdc_cb_ctl_req+0x2e>
		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 <STACK_SIZE+0x194>)
    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 <STACK_SIZE+0x30>
	switch (req->bmRequestType & USB_REQT_RECIP_MASK) {
    1f86:	2b02      	cmp	r3, #2
    1f88:	d19f      	bne.n	1eca <usbdc_cb_ctl_req+0x2e>
		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 <usbdc_cb_ctl_req+0x2e>
		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 <usbdc_cb_ctl_req+0xdc>
		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 <STACK_SIZE+0x188>)
		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 <STACK_SIZE+0x18c>)
    1fb4:	4798      	blx	r3
	if (NULL == ifc) {
    1fb6:	2800      	cmp	r0, #0
    1fb8:	d087      	beq.n	1eca <usbdc_cb_ctl_req+0x2e>
	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 <STACK_SIZE+0x190>)
	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 <usbdc_cb_ctl_req+0x13a>
    1fd4:	e779      	b.n	1eca <usbdc_cb_ctl_req+0x2e>
	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 <usbdc_cb_ctl_req+0x162>
    1fdc:	78c3      	ldrb	r3, [r0, #3]
    1fde:	42a3      	cmp	r3, r4
    1fe0:	d10d      	bne.n	1ffe <usbdc_cb_ctl_req+0x162>
	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 <usbdc_cb_ctl_req+0x150>
    1fea:	e76e      	b.n	1eca <usbdc_cb_ctl_req+0x2e>
		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 <STACK_SIZE+0xc>
			func = func->next;
    1ffa:	683f      	ldr	r7, [r7, #0]
    1ffc:	e7f3      	b.n	1fe6 <usbdc_cb_ctl_req+0x14a>
		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 <usbdc_cb_ctl_req+0x132>
		} 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 <STACK_SIZE+0x1a>
    2018:	e757      	b.n	1eca <usbdc_cb_ctl_req+0x2e>
			if (alt_set) {
    201a:	2c00      	cmp	r4, #0
    201c:	d004      	beq.n	2028 <STACK_SIZE+0x28>
				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 <STACK_SIZE+0x184>)
    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 <STACK_SIZE+0x40>
    203e:	e744      	b.n	1eca <usbdc_cb_ctl_req+0x2e>
    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 <STACK_SIZE+0x9a>
    206a:	2a03      	cmp	r2, #3
    206c:	d034      	beq.n	20d8 <STACK_SIZE+0xd8>
    206e:	2000      	movs	r0, #0
    2070:	2a01      	cmp	r2, #1
    2072:	d1e0      	bne.n	2036 <STACK_SIZE+0x36>
	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 <STACK_SIZE+0x188>)
    207e:	681b      	ldr	r3, [r3, #0]
    2080:	cb03      	ldmia	r3!, {r0, r1}
    2082:	4b43      	ldr	r3, [pc, #268]	; (2190 <STACK_SIZE+0x190>)
    2084:	4798      	blx	r3
    2086:	1e01      	subs	r1, r0, #0
	if (!dev_desc) {
    2088:	d100      	bne.n	208c <STACK_SIZE+0x8c>
    208a:	e71e      	b.n	1eca <usbdc_cb_ctl_req+0x2e>
	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 <STACK_SIZE+0x94>
    2092:	2212      	movs	r2, #18
    2094:	2300      	movs	r3, #0
    2096:	b292      	uxth	r2, r2
    2098:	e72d      	b.n	1ef6 <usbdc_cb_ctl_req+0x5a>
	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 <STACK_SIZE+0x188>)
		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 <STACK_SIZE+0x18c>)
    20b0:	4798      	blx	r3
    20b2:	1e01      	subs	r1, r0, #0
	if (NULL == cfg_desc) {
    20b4:	d100      	bne.n	20b8 <STACK_SIZE+0xb8>
    20b6:	e708      	b.n	1eca <usbdc_cb_ctl_req+0x2e>
	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 <STACK_SIZE+0xd4>
	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 <usbdc_cb_ctl_req+0x5a>
	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 <STACK_SIZE+0x188>)
	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 <STACK_SIZE+0x198>)
    20ec:	4798      	blx	r3
    20ee:	1e01      	subs	r1, r0, #0
	if (NULL == str_desc) {
    20f0:	d100      	bne.n	20f4 <STACK_SIZE+0xf4>
    20f2:	e6ea      	b.n	1eca <usbdc_cb_ctl_req+0x2e>
	if (length <= str_desc[0]) {
    20f4:	7802      	ldrb	r2, [r0, #0]
    20f6:	e7e4      	b.n	20c2 <STACK_SIZE+0xc2>
		*(uint8_t *)usbdc.ctrl_buf = usbdc.cfg_value;
    20f8:	4923      	ldr	r1, [pc, #140]	; (2188 <STACK_SIZE+0x188>)
    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 <usbdc_cb_ctl_req+0xe6>
	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 <STACK_SIZE+0x134>
    2116:	2902      	cmp	r1, #2
    2118:	d000      	beq.n	211c <STACK_SIZE+0x11c>
    211a:	e6d6      	b.n	1eca <usbdc_cb_ctl_req+0x2e>
		st = usb_d_ep_halt(req->wIndex & 0xFF, USB_EP_HALT_GET);
    211c:	4b1d      	ldr	r3, [pc, #116]	; (2194 <STACK_SIZE+0x194>)
    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 <STACK_SIZE+0x12c>
    212a:	e784      	b.n	2036 <STACK_SIZE+0x36>
		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 <STACK_SIZE+0x136>
		st = 0;
    2134:	9000      	str	r0, [sp, #0]
	memcpy(usbdc.ctrl_buf, &st, 2);
    2136:	4d14      	ldr	r5, [pc, #80]	; (2188 <STACK_SIZE+0x188>)
    2138:	2202      	movs	r2, #2
    213a:	4669      	mov	r1, sp
    213c:	4b17      	ldr	r3, [pc, #92]	; (219c <STACK_SIZE+0x19c>)
    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 <usbdc_cb_ctl_req+0xe6>
	if (!(usbdc.ifc_alt_map & (1 << req->wIndex))) {
    214a:	4e0f      	ldr	r6, [pc, #60]	; (2188 <STACK_SIZE+0x188>)
    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 <STACK_SIZE+0x1a0>
	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 <STACK_SIZE+0x16a>
    2168:	e6af      	b.n	1eca <usbdc_cb_ctl_req+0x2e>
		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 <STACK_SIZE+0x1b0>
			func = func->next;
    2178:	6824      	ldr	r4, [r4, #0]
    217a:	e7f3      	b.n	2164 <STACK_SIZE+0x164>
    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 <STACK_SIZE+0x1c0>)
    21ac:	47a8      	blx	r5
		return true;
    21ae:	e741      	b.n	2034 <STACK_SIZE+0x34>
			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 <STACK_SIZE+0x30>
    21be:	46c0      	nop			; (mov r8, r8)
    21c0:	00001e81 	.word	0x00001e81

000021c4 <usbdc_register_handler>:

/**
 * \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 <usbdc_register_handler+0x18>
    21ca:	2802      	cmp	r0, #2
    21cc:	d009      	beq.n	21e2 <usbdc_register_handler+0x1e>
    21ce:	2800      	cmp	r0, #0
    21d0:	d103      	bne.n	21da <usbdc_register_handler+0x16>
	case USBDC_HDL_SOF:
		list_insert_at_end(&usbdc.handlers.sof_list, (void *)h);
    21d2:	4805      	ldr	r0, [pc, #20]	; (21e8 <usbdc_register_handler+0x24>)
    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 <usbdc_register_handler+0x28>)
    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 <usbdc_register_handler+0x24>)
    21de:	3008      	adds	r0, #8
    21e0:	e7f9      	b.n	21d6 <usbdc_register_handler+0x12>
		list_insert_at_end(&usbdc.handlers.change_list, (void *)h);
    21e2:	4801      	ldr	r0, [pc, #4]	; (21e8 <usbdc_register_handler+0x24>)
    21e4:	300c      	adds	r0, #12
    21e6:	e7f6      	b.n	21d6 <usbdc_register_handler+0x12>
    21e8:	2000039c 	.word	0x2000039c
    21ec:	00001285 	.word	0x00001285

000021f0 <usbdc_init>:

/**
 * \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 <usbdc_init+0x3c>)
    21fa:	4b0d      	ldr	r3, [pc, #52]	; (2230 <usbdc_init+0x40>)
    21fc:	490d      	ldr	r1, [pc, #52]	; (2234 <usbdc_init+0x44>)
    21fe:	b2c0      	uxtb	r0, r0
    2200:	4798      	blx	r3

	int32_t rc;

	rc = usb_d_init();
    2202:	4b0d      	ldr	r3, [pc, #52]	; (2238 <usbdc_init+0x48>)
    2204:	4798      	blx	r3
	if (rc < 0) {
    2206:	2800      	cmp	r0, #0
    2208:	db0e      	blt.n	2228 <usbdc_init+0x38>
		return rc;
	}

	memset(&usbdc, 0, sizeof(usbdc));
    220a:	4d0c      	ldr	r5, [pc, #48]	; (223c <usbdc_init+0x4c>)
    220c:	2220      	movs	r2, #32
    220e:	4b0c      	ldr	r3, [pc, #48]	; (2240 <usbdc_init+0x50>)
    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_init+0x54>)
	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 <usbdc_init+0x58>)
    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 <usbdc_init+0x5c>)
    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 <usbdc_register_function>:
 * \brief Register/unregister function support of a USB device function
 *
 * Must be invoked when USB device is stopped.
 */
void usbdc_register_function(struct usbdf_driver *func)
{
    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 <usbdc_register_function+0x10>)
    2256:	4b03      	ldr	r3, [pc, #12]	; (2264 <usbdc_register_function+0x14>)
    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 <usbdc_start>:

/**
 * \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 <usbdc_start+0x2c>)
    226c:	7e9c      	ldrb	r4, [r3, #26]
    226e:	2c00      	cmp	r4, #0
    2270:	d10b      	bne.n	228a <usbdc_start+0x22>
		return ERR_BUSY;
	}

	if (desces) {
    2272:	2800      	cmp	r0, #0
    2274:	d00c      	beq.n	2290 <usbdc_start+0x28>
#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 <usbdc_start+0x30>)
    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 <usbdc_start+0x20>
    2290:	2009      	movs	r0, #9
    2292:	e7fb      	b.n	228c <usbdc_start+0x24>
    2294:	2000039c 	.word	0x2000039c
    2298:	000017cd 	.word	0x000017cd

0000229c <usbdc_attach>:

/**
 * \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 <usbdc_attach+0x8>)
    22a0:	4798      	blx	r3
}
    22a2:	bd10      	pop	{r4, pc}
    22a4:	000017d9 	.word	0x000017d9

000022a8 <usbdc_get_ctrl_buffer>:
/**
 * \brief Return USB Device endpoint0 buffer
 */
uint8_t *usbdc_get_ctrl_buffer(void)
{
	return usbdc.ctrl_buf;
    22a8:	4b01      	ldr	r3, [pc, #4]	; (22b0 <usbdc_get_ctrl_buffer+0x8>)
    22aa:	6958      	ldr	r0, [r3, #20]
}
    22ac:	4770      	bx	lr
    22ae:	46c0      	nop			; (mov r8, r8)
    22b0:	2000039c 	.word	0x2000039c

000022b4 <usbdc_get_state>:
/**
 * \brief Return current USB state
 */
uint8_t usbdc_get_state(void)
{
	if (usbdc.state & USBD_S_SUSPEND) {
    22b4:	4b03      	ldr	r3, [pc, #12]	; (22c4 <usbdc_get_state+0x10>)
    22b6:	7e98      	ldrb	r0, [r3, #26]
    22b8:	2310      	movs	r3, #16
    22ba:	4218      	tst	r0, r3
    22bc:	d000      	beq.n	22c0 <usbdc_get_state+0xc>
		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 <atomic_enter_critical>:
 */
__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 <atomic_leave_critical>:
    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 <memcpy>:
    2354:	2300      	movs	r3, #0
    2356:	b510      	push	{r4, lr}
    2358:	429a      	cmp	r2, r3
    235a:	d100      	bne.n	235e <memcpy+0xa>
    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 <memcpy+0x4>

00002366 <memset>:
    2366:	0003      	movs	r3, r0
    2368:	1882      	adds	r2, r0, r2
    236a:	4293      	cmp	r3, r2
    236c:	d100      	bne.n	2370 <memset+0xa>
    236e:	4770      	bx	lr
    2370:	7019      	strb	r1, [r3, #0]
    2372:	3301      	adds	r3, #1
    2374:	e7f9      	b.n	236a <memset+0x4>
	...

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 <CSWTCH.37>:
    23d6:	01ed 0101 0201                               .......

000023dd <CSWTCH.40>:
    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                                   ....
