12a: 0c 94 33 05 jmp 0xa66 ; 0xa66 <_exit> 0000012e <__bad_interrupt>: 12e: 0c 94 00 00 jmp 0 ; 0x0 <__vectors> 00000132 : /* ------------------------------------------------------------------------- */ #if !USB_CFG_SUPPRESS_INTR_CODE #if USB_CFG_HAVE_INTRIN_ENDPOINT static void usbGenericSetInterrupt(uchar *data, uchar len, usbTxStatus_t *txStatus) { 132: 1f 93 push r17 134: cf 93 push r28 136: df 93 push r29 138: 16 2f mov r17, r22 13a: ea 01 movw r28, r20 #if USB_CFG_IMPLEMENT_HALT if(usbTxLen1 == USBPID_STALL) return; #endif if(txStatus->len & 0x10){ /* packet buffer was empty */ 13c: 28 81 ld r18, Y 13e: 24 ff sbrs r18, 4 140: 17 c0 rjmp .+46 ; 0x170 txStatus->buffer[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* toggle token */ 142: 29 81 ldd r18, Y+1 ; 0x01 144: 38 e8 ldi r19, 0x88 ; 136 146: 23 27 eor r18, r19 148: 29 83 std Y+1, r18 ; 0x01 }else{ txStatus->len = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */ } p = txStatus->buffer + 1; i = len; 14a: 21 2f mov r18, r17 14c: fc 01 movw r30, r24 p = txStatus->buffer + 1; 14e: ce 01 movw r24, r28 150: 02 96 adiw r24, 0x02 ; 2 i = len; 152: dc 01 movw r26, r24 do{ /* if len == 0, we still copy 1 byte, but that's no problem */ *p++ = *data++; 154: 31 91 ld r19, Z+ 156: 3d 93 st X+, r19 158: 21 50 subi r18, 0x01 ; 1 }while(--i > 0); /* loop control at the end is 2 bytes shorter than at beginning */ 15a: 12 16 cp r1, r18 15c: dc f3 brlt .-10 ; 0x154 usbCrc16Append(&txStatus->buffer[1], len); 15e: 61 2f mov r22, r17 160: 0e 94 0e 02 call 0x41c ; 0x41c txStatus->len = len + 4; /* len must be given including sync byte */ 164: 1c 5f subi r17, 0xFC ; 252 166: 18 83 st Y, r17 DBG2(0x21 + (((int)txStatus >> 3) & 3), txStatus->buffer, len + 3); } 168: df 91 pop r29 16a: cf 91 pop r28 16c: 1f 91 pop r17 16e: 08 95 ret txStatus->len = USBPID_NAK; /* avoid sending outdated (overwritten) interrupt data */ 170: 2a e5 ldi r18, 0x5A ; 90 172: 28 83 st Y, r18 174: ea cf rjmp .-44 ; 0x14a 00000176 : USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len) { usbGenericSetInterrupt(data, len, &usbTxStatus1); 176: 40 e2 ldi r20, 0x20 ; 32 178: 51 e0 ldi r21, 0x01 ; 1 17a: 0c 94 99 00 jmp 0x132 ; 0x132 0000017e : #endif #if USB_CFG_HAVE_INTRIN_ENDPOINT3 USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len) { usbGenericSetInterrupt(data, len, &usbTxStatus3); 17e: 4b e4 ldi r20, 0x4B ; 75 180: 51 e0 ldi r21, 0x01 ; 1 182: 0c 94 99 00 jmp 0x132 ; 0x132 00000186 : } /* ------------------------------------------------------------------------- */ USB_PUBLIC void usbPoll(void) { 186: cf 93 push r28 188: df 93 push r29 schar len; uchar i; len = usbRxLen - 3; 18a: 60 91 31 01 lds r22, 0x0131 ; 0x800131 18e: 63 50 subi r22, 0x03 ; 3 if(len >= 0){ 190: 67 fd sbrc r22, 7 192: 16 c0 rjmp .+44 ; 0x1c0 * need data integrity checks with this driver, check the CRC in your app * code and report errors back to the host. Since the ACK was already sent, * retries must be handled on application level. * unsigned crc = usbCrc16(buffer + 1, usbRxLen - 3); */ usbProcessRx(usbRxBuf + USB_BUFSIZE + 1 - usbInputBufOffset, len); 194: 80 91 2e 01 lds r24, 0x012E ; 0x80012e 198: cc e0 ldi r28, 0x0C ; 12 19a: d0 e0 ldi r29, 0x00 ; 0 19c: c8 1b sub r28, r24 19e: d1 09 sbc r29, r1 1a0: cb 5c subi r28, 0xCB ; 203 1a2: de 4f sbci r29, 0xFE ; 254 if(usbRxToken < 0x10){ /* OUT to endpoint != 0: endpoint number in usbRxToken */ 1a4: 80 91 2d 01 lds r24, 0x012D ; 0x80012d 1a8: 80 31 cpi r24, 0x10 ; 16 1aa: 08 f0 brcs .+2 ; 0x1ae 1ac: 47 c0 rjmp .+142 ; 0x23c usbFunctionWriteOut(data, len); 1ae: ce 01 movw r24, r28 1b0: 0e 94 a1 04 call 0x942 ; 0x942 #if USB_CFG_HAVE_FLOWCONTROL if(usbRxLen > 0) /* only mark as available if not inactivated */ 1b4: 80 91 31 01 lds r24, 0x0131 ; 0x800131 1b8: 18 16 cp r1, r24 1ba: 14 f4 brge .+4 ; 0x1c0 usbRxLen = 0; 1bc: 10 92 31 01 sts 0x0131, r1 ; 0x800131 #else usbRxLen = 0; /* mark rx buffer as available */ #endif } if(usbTxLen & 0x10){ /* transmit system idle */ 1c0: 80 91 01 01 lds r24, 0x0101 ; 0x800101 1c4: 84 ff sbrs r24, 4 1c6: 2d c0 rjmp .+90 ; 0x222 if(usbMsgLen != USB_NO_MSG){ /* transmit data pending? */ 1c8: 80 91 00 01 lds r24, 0x0100 ; 0x800100 <__data_start> 1cc: 8f 3f cpi r24, 0xFF ; 255 1ce: 49 f1 breq .+82 ; 0x222 1d0: c8 2f mov r28, r24 1d2: 89 30 cpi r24, 0x09 ; 9 1d4: 08 f0 brcs .+2 ; 0x1d8 1d6: c8 e0 ldi r28, 0x08 ; 8 usbMsgLen -= wantLen; 1d8: 8c 1b sub r24, r28 1da: 80 93 00 01 sts 0x0100, r24 ; 0x800100 <__data_start> usbTxBuf[0] ^= USBPID_DATA0 ^ USBPID_DATA1; /* DATA toggling */ 1de: 80 91 15 01 lds r24, 0x0115 ; 0x800115 1e2: 98 e8 ldi r25, 0x88 ; 136 1e4: 89 27 eor r24, r25 1e6: 80 93 15 01 sts 0x0115, r24 ; 0x800115 if(len > 0){ /* don't bother app with 0 sized reads */ 1ea: cc 23 and r28, r28 1ec: 69 f0 breq .+26 ; 0x208 if(usbMsgFlags & USB_FLG_USE_USER_RW){ 1ee: 80 91 0c 01 lds r24, 0x010C ; 0x80010c <__data_end> 1f2: 87 ff sbrs r24, 7 1f4: c2 c0 rjmp .+388 ; 0x37a len = usbFunctionRead(data, len); 1f6: 6c 2f mov r22, r28 1f8: 86 e1 ldi r24, 0x16 ; 22 1fa: 91 e0 ldi r25, 0x01 ; 1 1fc: 0e 94 64 04 call 0x8c8 ; 0x8c8 200: c8 2f mov r28, r24 if(len <= 8){ /* valid data packet */ 202: 89 30 cpi r24, 0x09 ; 9 204: 08 f0 brcs .+2 ; 0x208 206: dd c0 rjmp .+442 ; 0x3c2 usbCrc16Append(&usbTxBuf[1], len); 208: 6c 2f mov r22, r28 20a: 86 e1 ldi r24, 0x16 ; 22 20c: 91 e0 ldi r25, 0x01 ; 1 20e: 0e 94 0e 02 call 0x41c ; 0x41c len += 4; /* length including sync byte */ 212: cc 5f subi r28, 0xFC ; 252 if(len < 12) /* a partial package identifies end of message */ 214: cc 30 cpi r28, 0x0C ; 12 216: 19 f0 breq .+6 ; 0x21e usbMsgLen = USB_NO_MSG; 218: 8f ef ldi r24, 0xFF ; 255 21a: 80 93 00 01 sts 0x0100, r24 ; 0x800100 <__data_start> usbTxLen = len; 21e: c0 93 01 01 sts 0x0101, r28 ; 0x800101 len = USBPID_STALL; /* stall the endpoint */ 222: 84 e1 ldi r24, 0x14 ; 20 usbBuildTxBlock(); } } for(i = 20; i > 0; i--){ uchar usbLineStatus = USBIN & USBMASK; 224: 99 b1 in r25, 0x09 ; 9 226: 94 78 andi r25, 0x84 ; 132 if(usbLineStatus != 0) /* SE0 has ended */ 228: 31 f4 brne .+12 ; 0x236 22a: 81 50 subi r24, 0x01 ; 1 for(i = 20; i > 0; i--){ 22c: d9 f7 brne .-10 ; 0x224 goto isNotReset; } /* RESET condition, called multiple times during reset */ usbNewDeviceAddr = 0; 22e: 10 92 32 01 sts 0x0132, r1 ; 0x800132 usbDeviceAddr = 0; 232: 10 92 2c 01 sts 0x012C, r1 ; 0x80012c usbResetStall(); DBG1(0xff, 0, 0); isNotReset: usbHandleResetHook(i); } 236: df 91 pop r29 238: cf 91 pop r28 23a: 08 95 ret if(usbRxToken == (uchar)USBPID_SETUP){ 23c: 8d 32 cpi r24, 0x2D ; 45 23e: 09 f0 breq .+2 ; 0x242 240: 89 c0 rjmp .+274 ; 0x354 if(len != 8) /* Setup size must be always 8 bytes. Ignore otherwise. */ 242: 68 30 cpi r22, 0x08 ; 8 244: 09 f0 breq .+2 ; 0x248 246: b6 cf rjmp .-148 ; 0x1b4 usbTxBuf[0] = USBPID_DATA0; /* initialize data toggling */ 248: 83 ec ldi r24, 0xC3 ; 195 24a: 80 93 15 01 sts 0x0115, r24 ; 0x800115 usbTxLen = USBPID_NAK; /* abort pending transmit */ 24e: 8a e5 ldi r24, 0x5A ; 90 250: 80 93 01 01 sts 0x0101, r24 ; 0x800101 usbMsgFlags = 0; 254: 10 92 0c 01 sts 0x010C, r1 ; 0x80010c <__data_end> uchar type = rq->bmRequestType & USBRQ_TYPE_MASK; 258: 88 81 ld r24, Y 25a: 80 76 andi r24, 0x60 ; 96 if(type != USBRQ_TYPE_STANDARD){ /* standard requests are handled by driver */ 25c: 71 f0 breq .+28 ; 0x27a replyLen = usbFunctionSetup(data); 25e: ce 01 movw r24, r28 260: 0e 94 41 04 call 0x882 ; 0x882 if(replyLen == USB_NO_MSG){ /* use user-supplied read/write function */ 264: 8f 3f cpi r24, 0xFF ; 255 266: c1 f4 brne .+48 ; 0x298 if((rq->bmRequestType & USBRQ_DIR_MASK) != USBRQ_DIR_HOST_TO_DEVICE){ 268: 98 81 ld r25, Y 26a: 97 fd sbrc r25, 7 replyLen = rq->wLength.bytes[0]; 26c: 8e 81 ldd r24, Y+6 ; 0x06 usbMsgFlags = USB_FLG_USE_USER_RW; 26e: 90 e8 ldi r25, 0x80 ; 128 270: 90 93 0c 01 sts 0x010C, r25 ; 0x80010c <__data_end> usbMsgLen = replyLen; 274: 80 93 00 01 sts 0x0100, r24 ; 0x800100 <__data_start> 278: 9d cf rjmp .-198 ; 0x1b4 uchar value = rq->wValue.bytes[0]; 27a: 2a 81 ldd r18, Y+2 ; 0x02 dataPtr[0] = 0; /* default reply common to USBRQ_GET_STATUS and USBRQ_GET_INTERFACE */ 27c: 10 92 1e 01 sts 0x011E, r1 ; 0x80011e SWITCH_START(rq->bRequest) 280: 99 81 ldd r25, Y+1 ; 0x01 SWITCH_CASE(USBRQ_GET_STATUS) /* 0 */ 282: 91 11 cpse r25, r1 284: 11 c0 rjmp .+34 ; 0x2a8 dataPtr[1] = 0; 286: 10 92 1f 01 sts 0x011F, r1 ; 0x80011f uchar *dataPtr = usbTxBuf + 9; /* there are 2 bytes free space at the end of the buffer */ 28a: 2e e1 ldi r18, 0x1E ; 30 28c: 31 e0 ldi r19, 0x01 ; 1 len = 2; 28e: 82 e0 ldi r24, 0x02 ; 2 usbMsgPtr = (usbMsgPtr_t)dataPtr; 290: 30 93 30 01 sts 0x0130, r19 ; 0x800130 294: 20 93 2f 01 sts 0x012F, r18 ; 0x80012f if(!rq->wLength.bytes[1] && replyLen > rq->wLength.bytes[0]) /* limit length to max */ 298: 9f 81 ldd r25, Y+7 ; 0x07 29a: 91 11 cpse r25, r1 29c: eb cf rjmp .-42 ; 0x274 29e: 9e 81 ldd r25, Y+6 ; 0x06 2a0: 98 17 cp r25, r24 2a2: 40 f7 brcc .-48 ; 0x274 2a4: 89 2f mov r24, r25 2a6: e6 cf rjmp .-52 ; 0x274 SWITCH_CASE(USBRQ_SET_ADDRESS) /* 5 */ 2a8: 95 30 cpi r25, 0x05 ; 5 2aa: 29 f4 brne .+10 ; 0x2b6 usbNewDeviceAddr = value; 2ac: 20 93 32 01 sts 0x0132, r18 ; 0x800132 uchar *dataPtr = usbTxBuf + 9; /* there are 2 bytes free space at the end of the buffer */ 2b0: 2e e1 ldi r18, 0x1E ; 30 2b2: 31 e0 ldi r19, 0x01 ; 1 2b4: ed cf rjmp .-38 ; 0x290 SWITCH_CASE(USBRQ_GET_DESCRIPTOR) /* 6 */ 2b6: 96 30 cpi r25, 0x06 ; 6 2b8: a1 f5 brne .+104 ; 0x322 SWITCH_START(rq->wValue.bytes[1]) 2ba: 9b 81 ldd r25, Y+3 ; 0x03 SWITCH_CASE(USBDESCR_DEVICE) /* 1 */ 2bc: 91 30 cpi r25, 0x01 ; 1 2be: 59 f4 brne .+22 ; 0x2d6 GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_DEVICE, usbDescriptorDevice) 2c0: 88 e6 ldi r24, 0x68 ; 104 2c2: 90 e0 ldi r25, 0x00 ; 0 2c4: 90 93 30 01 sts 0x0130, r25 ; 0x800130 2c8: 80 93 2f 01 sts 0x012F, r24 ; 0x80012f 2cc: 82 e1 ldi r24, 0x12 ; 18 usbMsgFlags = flags; 2ce: 90 e4 ldi r25, 0x40 ; 64 2d0: 90 93 0c 01 sts 0x010C, r25 ; 0x80010c <__data_end> 2d4: c7 cf rjmp .-114 ; 0x264 SWITCH_CASE(USBDESCR_CONFIG) /* 2 */ 2d6: 92 30 cpi r25, 0x02 ; 2 2d8: 21 f4 brne .+8 ; 0x2e2 GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_CONFIGURATION, usbDescriptorConfiguration) 2da: ce 01 movw r24, r28 2dc: 0e 94 2c 04 call 0x858 ; 0x858 2e0: f6 cf rjmp .-20 ; 0x2ce SWITCH_CASE(USBDESCR_STRING) /* 3 */ 2e2: 93 30 cpi r25, 0x03 ; 3 2e4: a1 f7 brne .-24 ; 0x2ce SWITCH_CASE(0) 2e6: 21 11 cpse r18, r1 2e8: 08 c0 rjmp .+16 ; 0x2fa GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_0, usbDescriptorString0) 2ea: 8c ea ldi r24, 0xAC ; 172 2ec: 90 e0 ldi r25, 0x00 ; 0 2ee: 90 93 30 01 sts 0x0130, r25 ; 0x800130 2f2: 80 93 2f 01 sts 0x012F, r24 ; 0x80012f 2f6: 84 e0 ldi r24, 0x04 ; 4 2f8: ea cf rjmp .-44 ; 0x2ce SWITCH_CASE(1) 2fa: 21 30 cpi r18, 0x01 ; 1 2fc: 41 f4 brne .+16 ; 0x30e GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_VENDOR, usbDescriptorStringVendor) 2fe: 8a e8 ldi r24, 0x8A ; 138 300: 90 e0 ldi r25, 0x00 ; 0 302: 90 93 30 01 sts 0x0130, r25 ; 0x800130 306: 80 93 2f 01 sts 0x012F, r24 ; 0x80012f 30a: 82 e2 ldi r24, 0x22 ; 34 30c: e0 cf rjmp .-64 ; 0x2ce SWITCH_CASE(2) 30e: 22 30 cpi r18, 0x02 ; 2 310: f1 f6 brne .-68 ; 0x2ce GET_DESCRIPTOR(USB_CFG_DESCR_PROPS_STRING_PRODUCT, usbDescriptorStringDevice) 312: 8a e7 ldi r24, 0x7A ; 122 314: 90 e0 ldi r25, 0x00 ; 0 316: 90 93 30 01 sts 0x0130, r25 ; 0x800130 31a: 80 93 2f 01 sts 0x012F, r24 ; 0x80012f 31e: 80 e1 ldi r24, 0x10 ; 16 320: d6 cf rjmp .-84 ; 0x2ce SWITCH_CASE(USBRQ_GET_CONFIGURATION) /* 8 */ 322: 98 30 cpi r25, 0x08 ; 8 324: 81 f0 breq .+32 ; 0x346 SWITCH_CASE(USBRQ_SET_CONFIGURATION) /* 9 */ 326: 99 30 cpi r25, 0x09 ; 9 328: 19 f4 brne .+6 ; 0x330 usbConfiguration = value; 32a: 20 93 34 01 sts 0x0134, r18 ; 0x800134 32e: c0 cf rjmp .-128 ; 0x2b0 SWITCH_CASE(USBRQ_GET_INTERFACE) /* 10 */ 330: 9a 30 cpi r25, 0x0A ; 10 332: 69 f0 breq .+26 ; 0x34e SWITCH_CASE(USBRQ_SET_INTERFACE) /* 11 */ 334: 9b 30 cpi r25, 0x0B ; 11 336: 09 f0 breq .+2 ; 0x33a 338: bb cf rjmp .-138 ; 0x2b0 USB_SET_DATATOKEN1(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */ 33a: 9b e4 ldi r25, 0x4B ; 75 33c: 90 93 21 01 sts 0x0121, r25 ; 0x800121 USB_SET_DATATOKEN3(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */ 340: 90 93 4c 01 sts 0x014C, r25 ; 0x80014c 344: b5 cf rjmp .-150 ; 0x2b0 dataPtr = &usbConfiguration; /* send current configuration value */ 346: 24 e3 ldi r18, 0x34 ; 52 348: 31 e0 ldi r19, 0x01 ; 1 len = 1; 34a: 81 e0 ldi r24, 0x01 ; 1 34c: a1 cf rjmp .-190 ; 0x290 uchar *dataPtr = usbTxBuf + 9; /* there are 2 bytes free space at the end of the buffer */ 34e: 2e e1 ldi r18, 0x1E ; 30 350: 31 e0 ldi r19, 0x01 ; 1 352: fb cf rjmp .-10 ; 0x34a if(usbMsgFlags & USB_FLG_USE_USER_RW){ 354: 80 91 0c 01 lds r24, 0x010C ; 0x80010c <__data_end> 358: 87 ff sbrs r24, 7 35a: 2c cf rjmp .-424 ; 0x1b4 uchar rval = usbFunctionWrite(data, len); 35c: ce 01 movw r24, r28 35e: 0e 94 7f 04 call 0x8fe ; 0x8fe if(rval == 0xff){ /* an error occurred */ 362: 8f 3f cpi r24, 0xFF ; 255 364: 21 f4 brne .+8 ; 0x36e usbTxLen = USBPID_STALL; 366: 8e e1 ldi r24, 0x1E ; 30 368: 80 93 01 01 sts 0x0101, r24 ; 0x800101 36c: 23 cf rjmp .-442 ; 0x1b4 }else if(rval != 0){ /* This was the final package */ 36e: 88 23 and r24, r24 370: 09 f4 brne .+2 ; 0x374 372: 20 cf rjmp .-448 ; 0x1b4 usbMsgLen = 0; /* answer with a zero-sized data packet */ 374: 10 92 00 01 sts 0x0100, r1 ; 0x800100 <__data_start> 378: 1d cf rjmp .-454 ; 0x1b4 usbMsgPtr_t r = usbMsgPtr; 37a: 40 91 2f 01 lds r20, 0x012F ; 0x80012f 37e: 50 91 30 01 lds r21, 0x0130 ; 0x800130 if(usbMsgFlags & USB_FLG_MSGPTR_IS_ROM){ /* ROM data */ 382: 86 ff sbrs r24, 6 384: 15 c0 rjmp .+42 ; 0x3b0 386: a6 e1 ldi r26, 0x16 ; 22 388: b1 e0 ldi r27, 0x01 ; 1 38a: fa 01 movw r30, r20 38c: 9c 2f mov r25, r28 uchar c = USB_READ_FLASH(r); /* assign to char size variable to enforce byte ops */ 38e: 84 91 lpm r24, Z *data++ = c; 390: 8d 93 st X+, r24 r++; 392: 31 96 adiw r30, 0x01 ; 1 }while(--i); 394: 91 50 subi r25, 0x01 ; 1 396: d9 f7 brne .-10 ; 0x38e 398: 2f ef ldi r18, 0xFF ; 255 39a: 2c 0f add r18, r28 39c: 30 e0 ldi r19, 0x00 ; 0 39e: 2f 5f subi r18, 0xFF ; 255 3a0: 3f 4f sbci r19, 0xFF ; 255 3a2: 24 0f add r18, r20 3a4: 35 1f adc r19, r21 usbMsgPtr = r; 3a6: 30 93 30 01 sts 0x0130, r19 ; 0x800130 3aa: 20 93 2f 01 sts 0x012F, r18 ; 0x80012f 3ae: 2c cf rjmp .-424 ; 0x208 3b0: da 01 movw r26, r20 3b2: e6 e1 ldi r30, 0x16 ; 22 3b4: f1 e0 ldi r31, 0x01 ; 1 if(usbMsgFlags & USB_FLG_MSGPTR_IS_ROM){ /* ROM data */ 3b6: 9c 2f mov r25, r28 *data++ = *((uchar *)r); 3b8: 8d 91 ld r24, X+ 3ba: 81 93 st Z+, r24 }while(--i); 3bc: 91 50 subi r25, 0x01 ; 1 3be: e1 f7 brne .-8 ; 0x3b8 3c0: eb cf rjmp .-42 ; 0x398 usbMsgLen = USB_NO_MSG; 3c2: 8f ef ldi r24, 0xFF ; 255 3c4: 80 93 00 01 sts 0x0100, r24 ; 0x800100 <__data_start> len = USBPID_STALL; /* stall the endpoint */ 3c8: ce e1 ldi r28, 0x1E ; 30 3ca: 29 cf rjmp .-430 ; 0x21e 000003cc : /* ------------------------------------------------------------------------- */ USB_PUBLIC void usbInit(void) { #if USB_INTR_CFG_SET != 0 USB_INTR_CFG |= USB_INTR_CFG_SET; 3cc: e9 e6 ldi r30, 0x69 ; 105 3ce: f0 e0 ldi r31, 0x00 ; 0 3d0: 80 81 ld r24, Z 3d2: 82 60 ori r24, 0x02 ; 2 3d4: 80 83 st Z, r24 #endif #if USB_INTR_CFG_CLR != 0 USB_INTR_CFG &= ~(USB_INTR_CFG_CLR); #endif USB_INTR_ENABLE |= (1 << USB_INTR_ENABLE_BIT); 3d6: e8 9a sbi 0x1d, 0 ; 29 USB_SET_DATATOKEN1(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */ 3d8: a0 e2 ldi r26, 0x20 ; 32 3da: b1 e0 ldi r27, 0x01 ; 1 3dc: 8b e4 ldi r24, 0x4B ; 75 3de: 11 96 adiw r26, 0x01 ; 1 3e0: 8c 93 st X, r24 3e2: 11 97 sbiw r26, 0x01 ; 1 USB_SET_DATATOKEN3(USB_INITIAL_DATATOKEN); /* reset data toggling for interrupt endpoint */ 3e4: eb e4 ldi r30, 0x4B ; 75 3e6: f1 e0 ldi r31, 0x01 ; 1 3e8: 81 83 std Z+1, r24 ; 0x01 usbResetDataToggling(); #if USB_CFG_HAVE_INTRIN_ENDPOINT && !USB_CFG_SUPPRESS_INTR_CODE usbTxLen1 = USBPID_NAK; 3ea: 8a e5 ldi r24, 0x5A ; 90 3ec: 8c 93 st X, r24 #if USB_CFG_HAVE_INTRIN_ENDPOINT3 usbTxLen3 = USBPID_NAK; 3ee: 80 83 st Z, r24 3f0: 08 95 ret 000003f2 : ; poly r20+r21 ; scratch r23 ; resCrc r24+r25 / r16+r17 ; ptr X / Z usbCrc16: mov ptrL, argPtrL 3f2: a8 2f mov r26, r24 mov ptrH, argPtrH 3f4: b9 2f mov r27, r25 ldi resCrcL, 0 3f6: 80 e0 ldi r24, 0x00 ; 0 ldi resCrcH, 0 3f8: 90 e0 ldi r25, 0x00 ; 0 ldi polyL, lo8(0xa001) 3fa: 41 e0 ldi r20, 0x01 ; 1 ldi polyH, hi8(0xa001) 3fc: 50 ea ldi r21, 0xA0 ; 160 com argLen ; argLen = -argLen - 1: modified loop to ensure that carry is set 3fe: 60 95 com r22 ldi bitCnt, 0 ; loop counter with starnd condition = end condition 400: 30 e0 ldi r19, 0x00 ; 0 rjmp usbCrcLoopEntry 402: 09 c0 rjmp .+18 ; 0x416 00000404 : usbCrcByteLoop: ld byte, ptr+ 404: 2d 91 ld r18, X+ eor resCrcL, byte 406: 82 27 eor r24, r18 00000408 : usbCrcBitLoop: ror resCrcH ; carry is always set here (see brcs jumps to here) 408: 97 95 ror r25 ror resCrcL 40a: 87 95 ror r24 brcs usbCrcNoXor 40c: 10 f0 brcs .+4 ; 0x412 eor resCrcL, polyL 40e: 84 27 eor r24, r20 eor resCrcH, polyH 410: 95 27 eor r25, r21 00000412 : usbCrcNoXor: subi bitCnt, 224 ; (8 * 224) % 256 = 0; this loop iterates 8 times 412: 30 5e subi r19, 0xE0 ; 224 brcs usbCrcBitLoop 414: c8 f3 brcs .-14 ; 0x408 00000416 : usbCrcLoopEntry: subi argLen, -1 416: 6f 5f subi r22, 0xFF ; 255 brcs usbCrcByteLoop 418: a8 f3 brcs .-22 ; 0x404 0000041a : usbCrcReady: ret 41a: 08 95 ret 0000041c : #endif /* USB_USE_FAST_CRC */ ; extern unsigned usbCrc16Append(unsigned char *data, unsigned char len); usbCrc16Append: rcall usbCrc16 41c: ea df rcall .-44 ; 0x3f2 st ptr+, resCrcL 41e: 8d 93 st X+, r24 st ptr+, resCrcH 420: 9d 93 st X+, r25 ret 422: 08 95 ret 00000424 <__vector_1>: ; Numbers in brackets are clocks counted from center of last sync bit ; when instruction starts USB_INTR_VECTOR: ;order of registers pushed: YL, SREG YH, [sofError], bitcnt, shift, x1, x2, x3, x4, cnt push YL ;[-25] push only what is necessary to sync with edge ASAP 424: cf 93 push r28 in YL, SREG ;[-23] 426: cf b7 in r28, 0x3f ; 63 push YL ;[-22] 428: cf 93 push r28 push YH ;[-20] 42a: df 93 push r29 0000042c : ;sync up with J to K edge during sync pattern -- use fastest possible loops ;The first part waits at most 1 bit long since we must be in sync pattern. ;YL is guarenteed to be < 0x80 because I flag is clear. When we jump to ;waitForJ, ensure that this prerequisite is met. waitForJ: inc YL 42c: c3 95 inc r28 sbis USBIN, USBMINUS 42e: 4f 9b sbis 0x09, 7 ; 9 brne waitForJ ; just make sure we have ANY timeout 430: e9 f7 brne .-6 ; 0x42c 00000432 : waitForK: ;The following code results in a sampling window of < 1/4 bit which meets the spec. sbis USBIN, USBMINUS ;[-15] 432: 4f 9b sbis 0x09, 7 ; 9 rjmp foundK ;[-14] 434: 0b c0 rjmp .+22 ; 0x44c sbis USBIN, USBMINUS 436: 4f 9b sbis 0x09, 7 ; 9 rjmp foundK 438: 09 c0 rjmp .+18 ; 0x44c sbis USBIN, USBMINUS 43a: 4f 9b sbis 0x09, 7 ; 9 rjmp foundK 43c: 07 c0 rjmp .+14 ; 0x44c sbis USBIN, USBMINUS 43e: 4f 9b sbis 0x09, 7 ; 9 rjmp foundK 440: 05 c0 rjmp .+10 ; 0x44c sbis USBIN, USBMINUS 442: 4f 9b sbis 0x09, 7 ; 9 rjmp foundK 444: 03 c0 rjmp .+6 ; 0x44c sbis USBIN, USBMINUS 446: 4f 9b sbis 0x09, 7 ; 9 rjmp foundK 448: 01 c0 rjmp .+2 ; 0x44c sts usbSofCount, YL #endif /* USB_COUNT_SOF */ #ifdef USB_SOF_HOOK USB_SOF_HOOK #endif rjmp sofError 44a: 8e c0 rjmp .+284 ; 0x568 0000044c : foundK: ;[-12] ;{3, 5} after falling D- edge, average delay: 4 cycles [we want 5 for center sampling] ;we have 1 bit time for setup purposes, then sample again. Numbers in brackets ;are cycles from center of first sync (double K) bit after the instruction push bitcnt ;[-12] 44c: 6f 93 push r22 ; [---] ;[-11] lds YL, usbInputBufOffset;[-10] 44e: c0 91 2e 01 lds r28, 0x012E ; 0x80012e ; [---] ;[-9] clr YH ;[-8] 452: dd 27 eor r29, r29 subi YL, lo8(-(usbRxBuf));[-7] [rx loop init] 454: cb 5c subi r28, 0xCB ; 203 sbci YH, hi8(-(usbRxBuf));[-6] [rx loop init] 456: de 4f sbci r29, 0xFE ; 254 push shift ;[-5] 458: 2f 93 push r18 ; [---] ;[-4] ldi bitcnt, 0x55 ;[-3] [rx loop init] 45a: 65 e5 ldi r22, 0x55 ; 85 sbis USBIN, USBMINUS ;[-2] we want two bits K (sample 2 cycles too early) 45c: 4f 9b sbis 0x09, 7 ; 9 rjmp haveTwoBitsK ;[-1] 45e: 03 c0 rjmp .+6 ; 0x466 pop shift ;[0] undo the push from before 460: 2f 91 pop r18 pop bitcnt ;[2] undo the push from before 462: 6f 91 pop r22 rjmp waitForK ;[4] this was not the end of sync, retry 464: e6 cf rjmp .-52 ; 0x432 00000466 : ;---------------------------------------------------------------------------- ; push more registers and initialize values while we sample the first bits: ;---------------------------------------------------------------------------- haveTwoBitsK: push x1 ;[1] 466: 0f 93 push r16 push x2 ;[3] 468: 1f 93 push r17 push x3 ;[5] 46a: 4f 93 push r20 ldi shift, 0 ;[7] 46c: 20 e0 ldi r18, 0x00 ; 0 ldi x3, 1<<4 ;[8] [rx loop init] first sample is inverse bit, compensate that 46e: 40 e1 ldi r20, 0x10 ; 16 push x4 ;[9] == leap 470: 5f 93 push r21 in x1, USBIN ;[11] <-- sample bit 0 472: 09 b1 in r16, 0x09 ; 9 andi x1, USBMASK ;[12] 474: 04 78 andi r16, 0x84 ; 132 bst x1, USBMINUS ;[13] 476: 07 fb bst r16, 7 bld shift, 7 ;[14] 478: 27 f9 bld r18, 7 push cnt ;[15] 47a: 3f 93 push r19 ldi leap, 0 ;[17] [rx loop init] 47c: 50 e0 ldi r21, 0x00 ; 0 ldi cnt, USB_BUFSIZE;[18] [rx loop init] 47e: 3b e0 ldi r19, 0x0B ; 11 rjmp rxbit1 ;[19] arrives at [21] 480: 39 c0 rjmp .+114 ; 0x4f4 00000482 : ; duration of unstuffing code should be 10.66666667 cycles. We adjust "leap" ; accordingly to approximate this value in the long run. unstuff6: andi x2, USBMASK ;[03] 482: 14 78 andi r17, 0x84 ; 132 ori x3, 1<<6 ;[04] will not be shifted any more 484: 40 64 ori r20, 0x40 ; 64 andi shift, ~0x80;[05] 486: 2f 77 andi r18, 0x7F ; 127 mov x1, x2 ;[06] sampled bit 7 is actually re-sampled bit 6 488: 01 2f mov r16, r17 subi leap, -1 ;[07] total duration = 11 bits -> subtract 1/3 48a: 5f 5f subi r21, 0xFF ; 255 rjmp didUnstuff6 ;[08] 48c: 1e c0 rjmp .+60 ; 0x4ca 0000048e : unstuff7: ori x3, 1<<7 ;[09] will not be shifted any more 48e: 40 68 ori r20, 0x80 ; 128 in x2, USBIN ;[00] [10] re-sample bit 7 490: 19 b1 in r17, 0x09 ; 9 andi x2, USBMASK ;[01] 492: 14 78 andi r17, 0x84 ; 132 andi shift, ~0x80;[02] 494: 2f 77 andi r18, 0x7F ; 127 subi leap, 2 ;[03] total duration = 10 bits -> add 1/3 496: 52 50 subi r21, 0x02 ; 2 rjmp didUnstuff7 ;[04] 498: 1f c0 rjmp .+62 ; 0x4d8 0000049a : unstuffEven: ori x3, 1<<6 ;[09] will be shifted right 6 times for bit 0 49a: 40 64 ori r20, 0x40 ; 64 in x1, USBIN ;[00] [10] 49c: 09 b1 in r16, 0x09 ; 9 andi shift, ~0x80;[01] 49e: 2f 77 andi r18, 0x7F ; 127 andi x1, USBMASK ;[02] 4a0: 04 78 andi r16, 0x84 ; 132 breq se0 ;[03] 4a2: d1 f1 breq .+116 ; 0x518 subi leap, -1 ;[04] total duration = 11 bits -> subtract 1/3 4a4: 5f 5f subi r21, 0xFF ; 255 nop2 ;[05] 4a6: 00 c0 rjmp .+0 ; 0x4a8 rjmp didUnstuffE ;[06] 4a8: 23 c0 rjmp .+70 ; 0x4f0 000004aa : unstuffOdd: ori x3, 1<<5 ;[09] will be shifted right 4 times for bit 1 4aa: 40 62 ori r20, 0x20 ; 32 in x2, USBIN ;[00] [10] 4ac: 19 b1 in r17, 0x09 ; 9 andi shift, ~0x80;[01] 4ae: 2f 77 andi r18, 0x7F ; 127 andi x2, USBMASK ;[02] 4b0: 14 78 andi r17, 0x84 ; 132 breq se0 ;[03] 4b2: 91 f1 breq .+100 ; 0x518 subi leap, -1 ;[04] total duration = 11 bits -> subtract 1/3 4b4: 5f 5f subi r21, 0xFF ; 255 nop2 ;[05] 4b6: 00 c0 rjmp .+0 ; 0x4b8 rjmp didUnstuffO ;[06] 4b8: 25 c0 rjmp .+74 ; 0x504 000004ba : rxByteLoop: andi x1, USBMASK ;[03] 4ba: 04 78 andi r16, 0x84 ; 132 eor x2, x1 ;[04] 4bc: 10 27 eor r17, r16 subi leap, 1 ;[05] 4be: 51 50 subi r21, 0x01 ; 1 brpl skipLeap ;[06] 4c0: 12 f4 brpl .+4 ; 0x4c6 subi leap, -3 ;1 one leap cycle every 3rd byte -> 85 + 1/3 cycles per byte 4c2: 5d 5f subi r21, 0xFD ; 253 ... 000004c6 : nop ;1 skipLeap: subi x2, 1 ;[08] 4c6: 11 50 subi r17, 0x01 ; 1 ror shift ;[09] 4c8: 27 95 ror r18 000004ca : didUnstuff6: cpi shift, 0xfc ;[10] 4ca: 2c 3f cpi r18, 0xFC ; 252 in x2, USBIN ;[00] [11] <-- sample bit 7 4cc: 19 b1 in r17, 0x09 ; 9 brcc unstuff6 ;[01] 4ce: c8 f6 brcc .-78 ; 0x482 andi x2, USBMASK ;[02] 4d0: 14 78 andi r17, 0x84 ; 132 eor x1, x2 ;[03] 4d2: 01 27 eor r16, r17 subi x1, 1 ;[04] 4d4: 01 50 subi r16, 0x01 ; 1 ror shift ;[05] 4d6: 27 95 ror r18 000004d8 : didUnstuff7: cpi shift, 0xfc ;[06] 4d8: 2c 3f cpi r18, 0xFC ; 252 brcc unstuff7 ;[07] 4da: c8 f6 brcc .-78 ; 0x48e eor x3, shift ;[08] reconstruct: x3 is 1 at bit locations we changed, 0 at others 4dc: 42 27 eor r20, r18 st y+, x3 ;[09] store data 4de: 49 93 st Y+, r20 000004e0 : rxBitLoop: in x1, USBIN ;[00] [11] <-- sample bit 0/2/4 4e0: 09 b1 in r16, 0x09 ; 9 andi x1, USBMASK ;[01] 4e2: 04 78 andi r16, 0x84 ; 132 eor x2, x1 ;[02] 4e4: 10 27 eor r17, r16 andi x3, 0x3f ;[03] topmost two bits reserved for 6 and 7 4e6: 4f 73 andi r20, 0x3F ; 63 subi x2, 1 ;[04] 4e8: 11 50 subi r17, 0x01 ; 1 ror shift ;[05] 4ea: 27 95 ror r18 cpi shift, 0xfc ;[06] 4ec: 2c 3f cpi r18, 0xFC ; 252 brcc unstuffEven ;[07] 4ee: a8 f6 brcc .-86 ; 0x49a 000004f0 : didUnstuffE: lsr x3 ;[08] 4f0: 46 95 lsr r20 lsr x3 ;[09] 4f2: 46 95 lsr r20 000004f4 : rxbit1: in x2, USBIN ;[00] [10] <-- sample bit 1/3/5 4f4: 19 b1 in r17, 0x09 ; 9 andi x2, USBMASK ;[01] 4f6: 14 78 andi r17, 0x84 ; 132 breq se0 ;[02] 4f8: 79 f0 breq .+30 ; 0x518 eor x1, x2 ;[03] 4fa: 01 27 eor r16, r17 subi x1, 1 ;[04] 4fc: 01 50 subi r16, 0x01 ; 1 ror shift ;[05] 4fe: 27 95 ror r18 cpi shift, 0xfc ;[06] 500: 2c 3f cpi r18, 0xFC ; 252 brcc unstuffOdd ;[07] 502: 98 f6 brcc .-90 ; 0x4aa 00000504 : didUnstuffO: subi bitcnt, 0xab;[08] == addi 0x55, 0x55 = 0x100/3 504: 6b 5a subi r22, 0xAB ; 171 brcs rxBitLoop ;[09] 506: 60 f3 brcs .-40 ; 0x4e0 subi cnt, 1 ;[10] 508: 31 50 subi r19, 0x01 ; 1 in x1, USBIN ;[00] [11] <-- sample bit 6 50a: 09 b1 in r16, 0x09 ; 9 brcc rxByteLoop ;[01] 50c: b0 f6 brcc .-84 ; 0x4ba rjmp overflow 50e: 00 c0 rjmp .+0 ; 0x510 00000510 : */ #define token x1 overflow: ldi x2, 1<: ignorePacket: clr token 514: 00 27 eor r16, r16 rjmp storeTokenAndReturn 516: 1c c0 rjmp .+56 ; 0x550 00000518 : ; Processing of received packet (numbers in brackets are cycles after center of SE0) ;---------------------------------------------------------------------------- ;This is the only non-error exit point for the software receiver loop ;we don't check any CRCs here because there is no time left. se0: subi cnt, USB_BUFSIZE ;[5] 518: 3b 50 subi r19, 0x0B ; 11 neg cnt ;[6] 51a: 31 95 neg r19 sub YL, cnt ;[7] 51c: c3 1b sub r28, r19 sbci YH, 0 ;[8] 51e: d0 40 sbci r29, 0x00 ; 0 ldi x2, 1< cpi token, USBPID_DATA1 ;[15] 52a: 0b 34 cpi r16, 0x4B ; 75 breq handleData ;[16] 52c: 11 f1 breq .+68 ; 0x572 lds shift, usbDeviceAddr;[17] 52e: 20 91 2c 01 lds r18, 0x012C ; 0x80012c ldd x2, y+1 ;[19] ADDR and 1 bit endpoint number 532: 19 81 ldd r17, Y+1 ; 0x01 lsl x2 ;[21] shift out 1 bit endpoint number 534: 11 0f add r17, r17 cpse x2, shift ;[22] 536: 12 13 cpse r17, r18 rjmp ignorePacket ;[23] 538: ed cf rjmp .-38 ; 0x514 /* only compute endpoint number in x3 if required later */ #if USB_CFG_HAVE_INTRIN_ENDPOINT || USB_CFG_IMPLEMENT_FN_WRITEOUT ldd x3, y+2 ;[24] endpoint number + crc 53a: 4a 81 ldd r20, Y+2 ; 0x02 rol x3 ;[26] shift in LSB of endpoint 53c: 44 1f adc r20, r20 #endif cpi token, USBPID_IN ;[27] 53e: 09 36 cpi r16, 0x69 ; 105 breq handleIn ;[28] 540: 69 f1 breq .+90 ; 0x59c cpi token, USBPID_SETUP ;[29] 542: 0d 32 cpi r16, 0x2D ; 45 breq handleSetupOrOut ;[30] 544: 11 f0 breq .+4 ; 0x54a cpi token, USBPID_OUT ;[31] 546: 01 3e cpi r16, 0xE1 ; 225 brne ignorePacket ;[32] must be ack, nak or whatever 548: 29 f7 brne .-54 ; 0x514 0000054a : ;Setup and Out are followed by a data packet two bit times (16 cycles) after ;the end of SE0. The sync code allows up to 40 cycles delay from the start of ;the sync pattern until the first bit is sampled. That's a total of 56 cycles. handleSetupOrOut: ;[32] #if USB_CFG_IMPLEMENT_FN_WRITEOUT /* if we have data for endpoint != 0, set usbCurrentTok to address */ andi x3, 0xf ;[32] 54a: 4f 70 andi r20, 0x0F ; 15 breq storeTokenAndReturn ;[33] 54c: 09 f0 breq .+2 ; 0x550 mov token, x3 ;[34] indicate that this is endpoint x OUT 54e: 04 2f mov r16, r20 00000550 : #endif storeTokenAndReturn: sts usbCurrentTok, token;[35] 550: 00 93 33 01 sts 0x0133, r16 ; 0x800133 00000554 : doReturn: POP_STANDARD ;[37] 12...16 cycles 554: 3f 91 pop r19 556: 5f 91 pop r21 558: 4f 91 pop r20 55a: 1f 91 pop r17 55c: 0f 91 pop r16 55e: 2f 91 pop r18 560: 6f 91 pop r22 USB_LOAD_PENDING(YL) ;[49] 562: cc b3 in r28, 0x1c ; 28 sbrc YL, USB_INTR_PENDING_BIT;[50] check whether data is already arriving 564: c0 fd sbrc r28, 0 rjmp waitForJ ;[51] save the pops and pushes -- a new interrupt is already pending 566: 62 cf rjmp .-316 ; 0x42c 00000568 : sofError: POP_RETI ;macro call 568: df 91 pop r29 56a: cf 91 pop r28 56c: cf bf out 0x3f, r28 ; 63 56e: cf 91 pop r28 reti 570: 18 95 reti 00000572 : handleData: #if USB_CFG_CHECK_CRC CRC_CLEANUP_AND_CHECK ; jumps to ignorePacket if CRC error #endif lds shift, usbCurrentTok;[18] 572: 20 91 33 01 lds r18, 0x0133 ; 0x800133 tst shift ;[20] 576: 22 23 and r18, r18 breq doReturn ;[21] 578: 69 f3 breq .-38 ; 0x554 lds x2, usbRxLen ;[22] 57a: 10 91 31 01 lds r17, 0x0131 ; 0x800131 tst x2 ;[24] 57e: 11 23 and r17, r17 brne sendNakAndReti ;[25] 580: e9 f5 brne .+122 ; 0x5fc ; 2006-03-11: The following two lines fix a problem where the device was not ; recognized if usbPoll() was called less frequently than once every 4 ms. cpi cnt, 4 ;[26] zero sized data packets are status phase only -- ignore and ack 582: 34 30 cpi r19, 0x04 ; 4 brmi sendAckAndReti ;[27] keep rx buffer clean -- we must not NAK next SETUP 584: ea f1 brmi .+122 ; 0x600 #if USB_CFG_CHECK_DATA_TOGGLING sts usbCurrentDataToken, token ; store for checking by C code #endif sts usbRxLen, cnt ;[28] store received data, swap buffers 586: 30 93 31 01 sts 0x0131, r19 ; 0x800131 sts usbRxToken, shift ;[30] 58a: 20 93 2d 01 sts 0x012D, r18 ; 0x80012d lds x2, usbInputBufOffset;[32] swap buffers 58e: 10 91 2e 01 lds r17, 0x012E ; 0x80012e ldi cnt, USB_BUFSIZE ;[34] 592: 3b e0 ldi r19, 0x0B ; 11 sub cnt, x2 ;[35] 594: 31 1b sub r19, r17 sts usbInputBufOffset, cnt;[36] buffers now swapped 596: 30 93 2e 01 sts 0x012E, r19 ; 0x80012e rjmp sendAckAndReti ;[38] 40 + 17 = 57 until SOP 59a: 32 c0 rjmp .+100 ; 0x600 0000059c : handleIn: ;We don't send any data as long as the C code has not processed the current ;input data and potentially updated the output data. That's more efficient ;in terms of code size than clearing the tx buffers when a packet is received. lds x1, usbRxLen ;[30] 59c: 00 91 31 01 lds r16, 0x0131 ; 0x800131 cpi x1, 1 ;[32] negative values are flow control, 0 means "buffer free" 5a0: 01 30 cpi r16, 0x01 ; 1 brge sendNakAndReti ;[33] unprocessed input packet? 5a2: 64 f5 brge .+88 ; 0x5fc ldi x1, USBPID_NAK ;[34] prepare value for usbTxLen 5a4: 0a e5 ldi r16, 0x5A ; 90 #if USB_CFG_HAVE_INTRIN_ENDPOINT andi x3, 0xf ;[35] x3 contains endpoint 5a6: 4f 70 andi r20, 0x0F ; 15 #if USB_CFG_SUPPRESS_INTR_CODE brne sendNakAndReti ;[36] #else brne handleIn1 ;[36] 5a8: 49 f4 brne .+18 ; 0x5bc #endif #endif lds cnt, usbTxLen ;[37] 5aa: 30 91 01 01 lds r19, 0x0101 ; 0x800101 sbrc cnt, 4 ;[39] all handshake tokens have bit 4 set 5ae: 34 fd sbrc r19, 4 rjmp sendCntAndReti ;[40] 42 + 16 = 58 until SOP 5b0: 28 c0 rjmp .+80 ; 0x602 sts usbTxLen, x1 ;[41] x1 == USBPID_NAK from above 5b2: 00 93 01 01 sts 0x0101, r16 ; 0x800101 ldi YL, lo8(usbTxBuf) ;[43] 5b6: c5 e1 ldi r28, 0x15 ; 21 ldi YH, hi8(usbTxBuf) ;[44] 5b8: d1 e0 ldi r29, 0x01 ; 1 rjmp usbSendAndReti ;[45] 57 + 12 = 59 until SOP 5ba: 27 c0 rjmp .+78 ; 0x60a 000005bc : #if !USB_CFG_SUPPRESS_INTR_CODE && USB_CFG_HAVE_INTRIN_ENDPOINT /* placed here due to relative jump range */ handleIn1: ;[38] #if USB_CFG_HAVE_INTRIN_ENDPOINT3 ; 2006-06-10 as suggested by O.Tamura: support second INTR IN / BULK IN endpoint cpi x3, USB_CFG_EP3_NUMBER;[38] 5bc: 43 30 cpi r20, 0x03 ; 3 breq handleIn3 ;[39] 5be: 49 f0 breq .+18 ; 0x5d2 #endif lds cnt, usbTxLen1 ;[40] 5c0: 30 91 20 01 lds r19, 0x0120 ; 0x800120 sbrc cnt, 4 ;[42] all handshake tokens have bit 4 set 5c4: 34 fd sbrc r19, 4 rjmp sendCntAndReti ;[43] 47 + 16 = 63 until SOP 5c6: 1d c0 rjmp .+58 ; 0x602 sts usbTxLen1, x1 ;[44] x1 == USBPID_NAK from above 5c8: 00 93 20 01 sts 0x0120, r16 ; 0x800120 ldi YL, lo8(usbTxBuf1) ;[46] 5cc: c1 e2 ldi r28, 0x21 ; 33 ldi YH, hi8(usbTxBuf1) ;[47] 5ce: d1 e0 ldi r29, 0x01 ; 1 rjmp usbSendAndReti ;[48] 50 + 12 = 62 until SOP 5d0: 1c c0 rjmp .+56 ; 0x60a 000005d2 : #if USB_CFG_HAVE_INTRIN_ENDPOINT3 handleIn3: lds cnt, usbTxLen3 ;[41] 5d2: 30 91 4b 01 lds r19, 0x014B ; 0x80014b sbrc cnt, 4 ;[43] 5d6: 34 fd sbrc r19, 4 rjmp sendCntAndReti ;[44] 49 + 16 = 65 until SOP 5d8: 14 c0 rjmp .+40 ; 0x602 sts usbTxLen3, x1 ;[45] x1 == USBPID_NAK from above 5da: 00 93 4b 01 sts 0x014B, r16 ; 0x80014b ldi YL, lo8(usbTxBuf3) ;[47] 5de: cc e4 ldi r28, 0x4C ; 76 ldi YH, hi8(usbTxBuf3) ;[48] 5e0: d1 e0 ldi r29, 0x01 ; 1 rjmp usbSendAndReti ;[49] 51 + 12 = 63 until SOP 5e2: 13 c0 rjmp .+38 ; 0x60a 000005e4 : ; J = (D+ = 0), (D- = 1) ; K = (D+ = 1), (D- = 0) ; Spec allows 7.5 bit times from EOP to SOP for replies bitstuffN: eor x1, x4 ;[5] 5e4: 05 27 eor r16, r21 ldi x2, 0 ;[6] 5e6: 10 e0 ldi r17, 0x00 ; 0 nop2 ;[7] 5e8: 00 c0 rjmp .+0 ; 0x5ea nop ;[9] 5ea: 00 00 nop out USBOUT, x1 ;[10] <-- out 5ec: 0b b9 out 0x0b, r16 ; 11 rjmp didStuffN ;[0] 5ee: 1a c0 rjmp .+52 ; 0x624 000005f0 : bitstuff6: eor x1, x4 ;[5] 5f0: 05 27 eor r16, r21 ldi x2, 0 ;[6] Carry is zero due to brcc 5f2: 10 e0 ldi r17, 0x00 ; 0 rol shift ;[7] compensate for ror shift at branch destination 5f4: 22 1f adc r18, r18 rjmp didStuff6 ;[8] 5f6: 1d c0 rjmp .+58 ; 0x632 000005f8 : bitstuff7: ldi x2, 0 ;[2] Carry is zero due to brcc 5f8: 10 e0 ldi r17, 0x00 ; 0 rjmp didStuff7 ;[3] 5fa: 21 c0 rjmp .+66 ; 0x63e 000005fc : sendNakAndReti: ldi x3, USBPID_NAK ;[-18] 5fc: 4a e5 ldi r20, 0x5A ; 90 rjmp sendX3AndReti ;[-17] 5fe: 02 c0 rjmp .+4 ; 0x604 00000600 : sendAckAndReti: ldi cnt, USBPID_ACK ;[-17] 600: 32 ed ldi r19, 0xD2 ; 210 00000602 : sendCntAndReti: mov x3, cnt ;[-16] 602: 43 2f mov r20, r19 00000604 : sendX3AndReti: ldi YL, 20 ;[-15] x3==r20 address is 20 604: c4 e1 ldi r28, 0x14 ; 20 ldi YH, 0 ;[-14] 606: d0 e0 ldi r29, 0x00 ; 0 ldi cnt, 2 ;[-13] 608: 32 e0 ldi r19, 0x02 ; 2 0000060a : ;uses: x1...x4, btcnt, shift, cnt, Y ;Numbers in brackets are time since first bit of sync pattern is sent ;We don't match the transfer rate exactly (don't insert leap cycles every third ;byte) because the spec demands only 1.5% precision anyway. usbSendAndReti: ; 12 cycles until SOP in x2, USBDDR ;[-12] 60a: 1a b1 in r17, 0x0a ; 10 ori x2, USBMASK ;[-11] 60c: 14 68 ori r17, 0x84 ; 132 sbi USBOUT, USBMINUS;[-10] prepare idle state; D+ and D- must have been 0 (no pullups) 60e: 5f 9a sbi 0x0b, 7 ; 11 in x1, USBOUT ;[-8] port mirror for tx loop 610: 0b b1 in r16, 0x0b ; 11 out USBDDR, x2 ;[-7] <- acquire bus 612: 1a b9 out 0x0a, r17 ; 10 ; need not init x2 (bitstuff history) because sync starts with 0 ldi x4, USBMASK ;[-6] exor mask 614: 54 e8 ldi r21, 0x84 ; 132 ldi shift, 0x80 ;[-5] sync byte is first byte sent 616: 20 e8 ldi r18, 0x80 ; 128 00000618 : txByteLoop: ldi bitcnt, 0x35 ;[-4] [6] binary 0011 0101 618: 65 e3 ldi r22, 0x35 ; 53 0000061a : txBitLoop: sbrs shift, 0 ;[-3] [7] 61a: 20 ff sbrs r18, 0 eor x1, x4 ;[-2] [8] 61c: 05 27 eor r16, r21 out USBOUT, x1 ;[-1] [9] <-- out N 61e: 0b b9 out 0x0b, r16 ; 11 ror shift ;[0] [10] 620: 27 95 ror r18 ror x2 ;[1] 622: 17 95 ror r17 00000624 : didStuffN: cpi x2, 0xfc ;[2] 624: 1c 3f cpi r17, 0xFC ; 252 brcc bitstuffN ;[3] 626: f0 f6 brcc .-68 ; 0x5e4 lsr bitcnt ;[4] 628: 66 95 lsr r22 brcc txBitLoop ;[5] 62a: b8 f7 brcc .-18 ; 0x61a brne txBitLoop ;[6] 62c: b1 f7 brne .-20 ; 0x61a sbrs shift, 0 ;[7] 62e: 20 ff sbrs r18, 0 eor x1, x4 ;[8] 630: 05 27 eor r16, r21 00000632 : didStuff6: out USBOUT, x1 ;[-1] [9] <-- out 6 632: 0b b9 out 0x0b, r16 ; 11 ror shift ;[0] [10] 634: 27 95 ror r18 ror x2 ;[1] 636: 17 95 ror r17 cpi x2, 0xfc ;[2] 638: 1c 3f cpi r17, 0xFC ; 252 brcc bitstuff6 ;[3] 63a: d0 f6 brcc .-76 ; 0x5f0 ror shift ;[4] 63c: 27 95 ror r18 0000063e : didStuff7: ror x2 ;[5] 63e: 17 95 ror r17 sbrs x2, 7 ;[6] 640: 17 ff sbrs r17, 7 eor x1, x4 ;[7] 642: 05 27 eor r16, r21 nop ;[8] 644: 00 00 nop cpi x2, 0xfc ;[9] 646: 1c 3f cpi r17, 0xFC ; 252 out USBOUT, x1 ;[-1][10] <-- out 7 648: 0b b9 out 0x0b, r16 ; 11 brcc bitstuff7 ;[0] [11] 64a: b0 f6 brcc .-84 ; 0x5f8 ld shift, y+ ;[1] 64c: 29 91 ld r18, Y+ dec cnt ;[3] 64e: 3a 95 dec r19 brne txByteLoop ;[4] 650: 19 f7 brne .-58 ; 0x618 ;make SE0: cbr x1, USBMASK ;[5] prepare SE0 [spec says EOP may be 21 to 25 cycles] 652: 0b 77 andi r16, 0x7B ; 123 lds x2, usbNewDeviceAddr;[6] 654: 10 91 32 01 lds r17, 0x0132 ; 0x800132 lsl x2 ;[8] we compare with left shifted address 658: 11 0f add r17, r17 subi YL, 20 + 2 ;[9] Only assign address on data packets, not ACK/NAK in x3 65a: c6 51 subi r28, 0x16 ; 22 sbci YH, 0 ;[10] 65c: d0 40 sbci r29, 0x00 ; 0 out USBOUT, x1 ;[11] <-- out SE0 -- from now 2 bits = 22 cycles until bus idle 65e: 0b b9 out 0x0b, r16 ; 11 ;2006-03-06: moved transfer of new address to usbDeviceAddr from C-Code to asm: ;set address only after data packet was sent, not after handshake breq skipAddrAssign ;[0] 660: 11 f0 breq .+4 ; 0x666 sts usbDeviceAddr, x2; if not skipped: SE0 is one cycle longer 662: 10 93 2c 01 sts 0x012C, r17 ; 0x80012c 00000666 : skipAddrAssign: ;end of usbDeviceAddress transfer ldi x2, 1<: se0Delay: dec x4 ;[10] [13] [16] [19] 676: 5a 95 dec r21 brne se0Delay ;[11] [14] [17] [20] 678: f1 f7 brne .-4 ; 0x676 out USBOUT, x1 ;[21] <-- out J (idle) -- end of SE0 (EOP signal) 67a: 0b b9 out 0x0b, r16 ; 11 out USBDDR, x2 ;[22] <-- release bus now 67c: 1a b9 out 0x0a, r17 ; 10 out USBOUT, x3 ;[23] <-- ensure no pull-up resistors are active 67e: 4b b9 out 0x0b, r20 ; 11 rjmp doReturn 680: 69 cf rjmp .-302 ; 0x554 00000682 : uchar urptr, uwptr, irptr, iwptr; uchar rx_buf[RX_SIZE+HW_CDC_BULK_IN_SIZE], tx_buf[TX_SIZE]; void uartInit(ulong baudrate, uchar parity, uchar stopbits, uchar databits) { 682: cf 92 push r12 684: df 92 push r13 686: ef 92 push r14 688: ff 92 push r15 68a: 0f 93 push r16 68c: 1f 93 push r17 68e: cf 93 push r28 690: 6b 01 movw r12, r22 692: 7c 01 movw r14, r24 694: 14 2f mov r17, r20 696: c2 2f mov r28, r18 usbDWord_t br; br.dword = ((F_CPU>>3)+(baudrate>>1)) / baudrate - 1; 698: 96 95 lsr r25 69a: 87 95 ror r24 69c: 77 95 ror r23 69e: 67 95 ror r22 6a0: 60 58 subi r22, 0x80 ; 128 6a2: 7b 47 sbci r23, 0x7B ; 123 6a4: 81 4e sbci r24, 0xE1 ; 225 6a6: 9f 4f sbci r25, 0xFF ; 255 6a8: a7 01 movw r20, r14 6aa: 96 01 movw r18, r12 6ac: 0e 94 11 05 call 0xa22 ; 0xa22 <__udivmodsi4> 6b0: 69 01 movw r12, r18 6b2: 7a 01 movw r14, r20 6b4: 81 e0 ldi r24, 0x01 ; 1 6b6: c8 1a sub r12, r24 6b8: d1 08 sbc r13, r1 6ba: e1 08 sbc r14, r1 6bc: f1 08 sbc r15, r1 UCSR0A |= (1< 6c2: 82 60 ori r24, 0x02 ; 2 6c4: 80 93 c0 00 sts 0x00C0, r24 ; 0x8000c0 <__TEXT_REGION_LENGTH__+0x7e00c0> #if DEBUG_LEVEL < 1 /* USART configuration */ UCSR0B = 0; 6c8: 10 92 c1 00 sts 0x00C1, r1 ; 0x8000c1 <__TEXT_REGION_LENGTH__+0x7e00c1> UCSR0C = URSEL_MASK | ((parity==1? 3:parity)<>1)< 6d0: 20 e1 ldi r18, 0x10 ; 16 6d2: 12 9f mul r17, r18 6d4: a0 01 movw r20, r0 6d6: 11 24 eor r1, r1 6d8: c6 95 lsr r28 6da: 28 e0 ldi r18, 0x08 ; 8 6dc: c2 9f mul r28, r18 6de: c0 01 movw r24, r0 6e0: 11 24 eor r1, r1 6e2: 10 e0 ldi r17, 0x00 ; 0 6e4: 05 50 subi r16, 0x05 ; 5 6e6: 11 09 sbc r17, r1 6e8: 00 0f add r16, r16 6ea: 11 1f adc r17, r17 6ec: 80 2b or r24, r16 6ee: 84 2b or r24, r20 6f0: 80 93 c2 00 sts 0x00C2, r24 ; 0x8000c2 <__TEXT_REGION_LENGTH__+0x7e00c2> UBRR0L = br.bytes[0]; 6f4: c0 92 c4 00 sts 0x00C4, r12 ; 0x8000c4 <__TEXT_REGION_LENGTH__+0x7e00c4> UBRR0H = br.bytes[1]; 6f8: d0 92 c5 00 sts 0x00C5, r13 ; 0x8000c5 <__TEXT_REGION_LENGTH__+0x7e00c5> #else DBG1(0xf0, br.bytes, 2); #endif /* DEBUG_LEVEL */ UCSR0B = (1< UART_CTRL_DDR = (1< 0000071e : void uartPoll(void) { 71e: cf 93 push r28 720: df 93 push r29 uchar next; /* device => RS-232C */ while( (UCSR0A&(1< 726: 85 ff sbrs r24, 5 728: 08 c0 rjmp .+16 ; 0x73a 72a: e0 91 e2 02 lds r30, 0x02E2 ; 0x8002e2 72e: 80 91 e1 02 lds r24, 0x02E1 ; 0x8002e1 732: 8e 17 cp r24, r30 734: 11 f0 breq .+4 ; 0x73a 736: 35 99 sbic 0x06, 5 ; 6 738: 03 c0 rjmp .+6 ; 0x740 } /* device <= RS-232C */ while( UCSR0A&(1< 73e: 26 c0 rjmp .+76 ; 0x78c UDR0 = tx_buf[irptr]; 740: f0 e0 ldi r31, 0x00 ; 0 742: e0 52 subi r30, 0x20 ; 32 744: fe 4f sbci r31, 0xFE ; 254 746: 80 81 ld r24, Z 748: 80 93 c6 00 sts 0x00C6, r24 ; 0x8000c6 <__TEXT_REGION_LENGTH__+0x7e00c6> irptr = (irptr+1) & TX_MASK; 74c: 80 91 e2 02 lds r24, 0x02E2 ; 0x8002e2 750: 8f 5f subi r24, 0xFF ; 255 752: 80 93 e2 02 sts 0x02E2, r24 ; 0x8002e2 if( usbAllRequestsAreDisabled() && uartTxBytesFree()>HW_CDC_BULK_OUT_SIZE ) { 756: 90 91 31 01 lds r25, 0x0131 ; 0x800131 75a: 97 ff sbrs r25, 7 75c: e2 cf rjmp .-60 ; 0x722 /* The following function returns the amount of bytes available in the TX * buffer before we have an overflow. */ static inline uchar uartTxBytesFree(void) { return (irptr - uwptr - 1) & TX_MASK; 75e: 90 91 e1 02 lds r25, 0x02E1 ; 0x8002e1 762: 89 1b sub r24, r25 764: 81 50 subi r24, 0x01 ; 1 766: 89 30 cpi r24, 0x09 ; 9 768: e0 f2 brcs .-72 ; 0x722 usbEnableAllRequests(); 76a: 10 92 31 01 sts 0x0131, r1 ; 0x800131 76e: d9 cf rjmp .-78 ; 0x722 if( next!=urptr ) { 770: 82 17 cp r24, r18 772: b1 f0 breq .+44 ; 0x7a0 uchar status, data; status = UCSR0A; 774: 90 91 c0 00 lds r25, 0x00C0 ; 0x8000c0 <__TEXT_REGION_LENGTH__+0x7e00c0> data = UDR0; 778: 30 91 c6 00 lds r19, 0x00C6 ; 0x8000c6 <__TEXT_REGION_LENGTH__+0x7e00c6> status &= (1< rx_buf[iwptr] = data; 780: f0 e0 ldi r31, 0x00 ; 0 782: e9 5a subi r30, 0xA9 ; 169 784: fe 4f sbci r31, 0xFE ; 254 786: 30 83 st Z, r19 iwptr = next; 788: 80 93 df 01 sts 0x01DF, r24 ; 0x8001df next = (iwptr+1) & RX_MASK; 78c: e0 91 df 01 lds r30, 0x01DF ; 0x8001df 790: 81 e0 ldi r24, 0x01 ; 1 792: 8e 0f add r24, r30 794: 8f 77 andi r24, 0x7F ; 127 while( UCSR0A&(1< 79a: 97 fd sbrc r25, 7 79c: e9 cf rjmp .-46 ; 0x770 79e: 01 c0 rjmp .+2 ; 0x7a2 } } else { UART_CTRL_PORT &= ~(1< 7a6: 84 ff sbrs r24, 4 7a8: 30 c0 rjmp .+96 ; 0x80a 7aa: c0 91 df 01 lds r28, 0x01DF ; 0x8001df 7ae: 80 91 e0 02 lds r24, 0x02E0 ; 0x8002e0 7b2: c8 13 cpse r28, r24 7b4: 04 c0 rjmp .+8 ; 0x7be 7b6: 90 91 e3 02 lds r25, 0x02E3 ; 0x8002e3 7ba: 99 23 and r25, r25 7bc: 31 f1 breq .+76 ; 0x80a uchar bytesRead, i; bytesRead = (iwptr-urptr) & RX_MASK; 7be: c8 1b sub r28, r24 7c0: cf 77 andi r28, 0x7F ; 127 7c2: c9 30 cpi r28, 0x09 ; 9 7c4: 08 f0 brcs .+2 ; 0x7c8 7c6: c8 e0 ldi r28, 0x08 ; 8 if(bytesRead>HW_CDC_BULK_IN_SIZE) bytesRead = HW_CDC_BULK_IN_SIZE; next = urptr + bytesRead; 7c8: dc 2f mov r29, r28 7ca: d8 0f add r29, r24 if( next>=RX_SIZE ) { 7cc: d7 ff sbrs r29, 7 7ce: 07 c0 rjmp .+14 ; 0x7de next &= RX_MASK; 7d0: 9d 2f mov r25, r29 7d2: 9f 77 andi r25, 0x7F ; 127 7d4: e7 e5 ldi r30, 0x57 ; 87 7d6: f1 e0 ldi r31, 0x01 ; 1 for( i=0; i rx_buf[RX_SIZE+i] = rx_buf[i]; } usbSetInterrupt(rx_buf+urptr, bytesRead); 7de: 90 e0 ldi r25, 0x00 ; 0 7e0: 6c 2f mov r22, r28 7e2: 89 5a subi r24, 0xA9 ; 169 7e4: 9e 4f sbci r25, 0xFE ; 254 7e6: 0e 94 bb 00 call 0x176 ; 0x176 urptr = next; 7ea: d0 93 e0 02 sts 0x02E0, r29 ; 0x8002e0 if( bytesRead ) 7ee: cc 23 and r28, r28 7f0: 49 f0 breq .+18 ; 0x804 UART_CTRL_PORT |= (1< 7f8: 90 91 df 01 lds r25, 0x01DF ; 0x8001df 7fc: 80 91 e0 02 lds r24, 0x02E0 ; 0x8002e0 800: 98 17 cp r25, r24 802: 69 f0 breq .+26 ; 0x81e 804: 80 e0 ldi r24, 0x00 ; 0 806: 80 93 e3 02 sts 0x02E3, r24 ; 0x8002e3 } } 80a: df 91 pop r29 80c: cf 91 pop r28 80e: 08 95 ret rx_buf[RX_SIZE+i] = rx_buf[i]; 810: 21 91 ld r18, Z+ 812: df 01 movw r26, r30 814: a1 58 subi r26, 0x81 ; 129 816: bf 4f sbci r27, 0xFF ; 255 818: 2c 93 st X, r18 for( i=0; i sendEmptyFrame = (bytesRead==HW_CDC_BULK_IN_SIZE && iwptr==urptr)? 1:0; 81e: 81 e0 ldi r24, 0x01 ; 1 820: f2 cf rjmp .-28 ; 0x806 00000822 : static uchar stopbit, parity, databit; static usbDWord_t baud; static void resetUart(void) { 822: 0f 93 push r16 uartInit(baud.dword, parity, stopbit, databit); 824: 60 91 0d 01 lds r22, 0x010D ; 0x80010d 828: 70 91 0e 01 lds r23, 0x010E ; 0x80010e 82c: 80 91 0f 01 lds r24, 0x010F ; 0x80010f 830: 90 91 10 01 lds r25, 0x0110 ; 0x800110 834: 00 91 11 01 lds r16, 0x0111 ; 0x800111 838: 20 91 13 01 lds r18, 0x0113 ; 0x800113 83c: 40 91 12 01 lds r20, 0x0112 ; 0x800112 840: 0e 94 41 03 call 0x682 ; 0x682 irptr = 0; 844: 10 92 e2 02 sts 0x02E2, r1 ; 0x8002e2 iwptr = 0; 848: 10 92 df 01 sts 0x01DF, r1 ; 0x8001df urptr = 0; 84c: 10 92 e0 02 sts 0x02E0, r1 ; 0x8002e0 uwptr = 0; 850: 10 92 e1 02 sts 0x02E1, r1 ; 0x8002e1 } 854: 0f 91 pop r16 856: 08 95 ret 00000858 : if(rq->wValue.bytes[1] == USBDESCR_DEVICE){ 858: fc 01 movw r30, r24 85a: 83 81 ldd r24, Z+3 ; 0x03 85c: 81 30 cpi r24, 0x01 ; 1 85e: 49 f4 brne .+18 ; 0x872 usbMsgPtr = (uchar *)usbDescriptorDevice; 860: 88 e6 ldi r24, 0x68 ; 104 862: 90 e0 ldi r25, 0x00 ; 0 864: 90 93 30 01 sts 0x0130, r25 ; 0x800130 868: 80 93 2f 01 sts 0x012F, r24 ; 0x80012f return usbDescriptorDevice[0]; 86c: 80 91 68 00 lds r24, 0x0068 ; 0x800068 <__TEXT_REGION_LENGTH__+0x7e0068> 870: 08 95 ret usbMsgPtr = (uchar *)configDescrCDC; 872: 80 eb ldi r24, 0xB0 ; 176 874: 90 e0 ldi r25, 0x00 ; 0 876: 90 93 30 01 sts 0x0130, r25 ; 0x800130 87a: 80 93 2f 01 sts 0x012F, r24 ; 0x80012f return sizeof(configDescrCDC); 87e: 83 e4 ldi r24, 0x43 ; 67 } 880: 08 95 ret 00000882 : /* ------------------------------------------------------------------------- */ /* ----------------------------- USB interface ----------------------------- */ /* ------------------------------------------------------------------------- */ uchar usbFunctionSetup(uchar data[8]) { 882: fc 01 movw r30, r24 usbRequest_t *rq = (void *)data; if((rq->bmRequestType & USBRQ_TYPE_MASK) == USBRQ_TYPE_CLASS){ /* class request type */ 884: 80 81 ld r24, Z 886: 80 76 andi r24, 0x60 ; 96 888: 80 32 cpi r24, 0x20 ; 32 88a: 11 f0 breq .+4 ; 0x890 if((rq->bmRequestType & USBRQ_DIR_MASK) == USBRQ_DIR_HOST_TO_DEVICE) sendEmptyFrame = 1; #endif } return 0; 88c: 80 e0 ldi r24, 0x00 ; 0 88e: 08 95 ret if( rq->bRequest==GET_LINE_CODING || rq->bRequest==SET_LINE_CODING ){ 890: 81 81 ldd r24, Z+1 ; 0x01 892: 90 ee ldi r25, 0xE0 ; 224 894: 98 0f add r25, r24 896: 92 30 cpi r25, 0x02 ; 2 898: a8 f0 brcs .+42 ; 0x8c4 if(rq->bRequest == SET_CONTROL_LINE_STATE){ 89a: 82 32 cpi r24, 0x22 ; 34 89c: 61 f4 brne .+24 ; 0x8b6 UART_CTRL_PORT = (UART_CTRL_PORT&~(1<wValue.word&1)< 8ac: 81 11 cpse r24, r1 8ae: 03 c0 rjmp .+6 ; 0x8b6 intr3Status = 2; 8b0: 82 e0 ldi r24, 0x02 ; 2 8b2: 80 93 14 01 sts 0x0114, r24 ; 0x800114 if((rq->bmRequestType & USBRQ_DIR_MASK) == USBRQ_DIR_HOST_TO_DEVICE) 8b6: 80 81 ld r24, Z 8b8: 87 fd sbrc r24, 7 8ba: e8 cf rjmp .-48 ; 0x88c sendEmptyFrame = 1; 8bc: 81 e0 ldi r24, 0x01 ; 1 8be: 80 93 e3 02 sts 0x02E3, r24 ; 0x8002e3 8c2: e4 cf rjmp .-56 ; 0x88c return 0xff; 8c4: 8f ef ldi r24, 0xFF ; 255 } 8c6: 08 95 ret 000008c8 : /*---------------------------------------------------------------------------*/ /* usbFunctionRead */ /*---------------------------------------------------------------------------*/ uchar usbFunctionRead( uchar *data, uchar len ) { 8c8: fc 01 movw r30, r24 data[0] = baud.bytes[0]; 8ca: ad e0 ldi r26, 0x0D ; 13 8cc: b1 e0 ldi r27, 0x01 ; 1 8ce: 8c 91 ld r24, X 8d0: 80 83 st Z, r24 data[1] = baud.bytes[1]; 8d2: 11 96 adiw r26, 0x01 ; 1 8d4: 8c 91 ld r24, X 8d6: 11 97 sbiw r26, 0x01 ; 1 8d8: 81 83 std Z+1, r24 ; 0x01 data[2] = baud.bytes[2]; 8da: 12 96 adiw r26, 0x02 ; 2 8dc: 8c 91 ld r24, X 8de: 12 97 sbiw r26, 0x02 ; 2 8e0: 82 83 std Z+2, r24 ; 0x02 data[3] = baud.bytes[3]; 8e2: 13 96 adiw r26, 0x03 ; 3 8e4: 8c 91 ld r24, X 8e6: 83 83 std Z+3, r24 ; 0x03 data[4] = stopbit; 8e8: 80 91 13 01 lds r24, 0x0113 ; 0x800113 8ec: 84 83 std Z+4, r24 ; 0x04 data[5] = parity; 8ee: 80 91 12 01 lds r24, 0x0112 ; 0x800112 8f2: 85 83 std Z+5, r24 ; 0x05 data[6] = databit; 8f4: 80 91 11 01 lds r24, 0x0111 ; 0x800111 8f8: 86 83 std Z+6, r24 ; 0x06 return 7; } 8fa: 87 e0 ldi r24, 0x07 ; 7 8fc: 08 95 ret 000008fe : /*---------------------------------------------------------------------------*/ /* usbFunctionWrite */ /*---------------------------------------------------------------------------*/ uchar usbFunctionWrite( uchar *data, uchar len ) { 8fe: fc 01 movw r30, r24 /* SET_LINE_CODING */ baud.bytes[0] = data[0]; 900: 80 81 ld r24, Z 902: 80 93 0d 01 sts 0x010D, r24 ; 0x80010d baud.bytes[1] = data[1]; 906: 81 81 ldd r24, Z+1 ; 0x01 908: 80 93 0e 01 sts 0x010E, r24 ; 0x80010e baud.bytes[2] = data[2]; 90c: 82 81 ldd r24, Z+2 ; 0x02 90e: 80 93 0f 01 sts 0x010F, r24 ; 0x80010f baud.bytes[3] = data[3]; 912: 83 81 ldd r24, Z+3 ; 0x03 914: 80 93 10 01 sts 0x0110, r24 ; 0x800110 stopbit = data[4]; 918: 84 81 ldd r24, Z+4 ; 0x04 91a: 80 93 13 01 sts 0x0113, r24 ; 0x800113 parity = data[5]; 91e: 95 81 ldd r25, Z+5 ; 0x05 920: 90 93 12 01 sts 0x0112, r25 ; 0x800112 databit = data[6]; 924: 26 81 ldd r18, Z+6 ; 0x06 926: 20 93 11 01 sts 0x0111, r18 ; 0x800111 if( parity>2 ) 92a: 93 30 cpi r25, 0x03 ; 3 92c: 10 f0 brcs .+4 ; 0x932 <__stack+0x33> parity = 0; 92e: 10 92 12 01 sts 0x0112, r1 ; 0x800112 if( stopbit==1 ) 932: 81 30 cpi r24, 0x01 ; 1 934: 11 f4 brne .+4 ; 0x93a <__stack+0x3b> stopbit = 0; 936: 10 92 13 01 sts 0x0113, r1 ; 0x800113 resetUart(); 93a: 0e 94 11 04 call 0x822 ; 0x822 return 1; } 93e: 81 e0 ldi r24, 0x01 ; 1 940: 08 95 ret 00000942 : void usbFunctionWriteOut( uchar *data, uchar len ) { 942: dc 01 movw r26, r24 /* usb -> rs232c: transmit char */ for( ; len; len-- ) { uchar uwnxt; uwnxt = (uwptr+1) & TX_MASK; if( uwnxt!=irptr ) { 944: 90 91 e2 02 lds r25, 0x02E2 ; 0x8002e2 948: e0 91 e1 02 lds r30, 0x02E1 ; 0x8002e1 for( ; len; len-- ) { 94c: 61 11 cpse r22, r1 94e: 08 c0 rjmp .+16 ; 0x960 950: 91 50 subi r25, 0x01 ; 1 952: 9e 1b sub r25, r30 uwptr = uwnxt; } } /* postpone receiving next data */ if( uartTxBytesFree()<=HW_CDC_BULK_OUT_SIZE ) 954: 99 30 cpi r25, 0x09 ; 9 956: 18 f4 brcc .+6 ; 0x95e usbDisableAllRequests(); 958: 8f ef ldi r24, 0xFF ; 255 95a: 80 93 31 01 sts 0x0131, r24 ; 0x800131 95e: 08 95 ret uwnxt = (uwptr+1) & TX_MASK; 960: 81 e0 ldi r24, 0x01 ; 1 962: 8e 0f add r24, r30 if( uwnxt!=irptr ) { 964: 89 17 cp r24, r25 966: 41 f0 breq .+16 ; 0x978 tx_buf[uwptr] = *data++; 968: 2c 91 ld r18, X 96a: f0 e0 ldi r31, 0x00 ; 0 96c: e0 52 subi r30, 0x20 ; 32 96e: fe 4f sbci r31, 0xFE ; 254 970: 20 83 st Z, r18 uwptr = uwnxt; 972: 80 93 e1 02 sts 0x02E1, r24 ; 0x8002e1 tx_buf[uwptr] = *data++; 976: 11 96 adiw r26, 0x01 ; 1 for( ; len; len-- ) { 978: 61 50 subi r22, 0x01 ; 1 97a: e6 cf rjmp .-52 ; 0x948 0000097c

: : "r0" ); } else { __asm__ __volatile__ ( 97c: 9e e0 ldi r25, 0x0E ; 14 97e: 88 e1 ldi r24, 0x18 ; 24 980: 0f b6 in r0, 0x3f ; 63 982: f8 94 cli 984: a8 95 wdr 986: 80 93 60 00 sts 0x0060, r24 ; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060> 98a: 0f be out 0x3f, r0 ; 63 98c: 90 93 60 00 sts 0x0060, r25 ; 0x800060 <__TEXT_REGION_LENGTH__+0x7e0060> static void hardwareInit(void) { /* activate pull-ups except on USB lines */ USB_CFG_IOPORT = (uchar)~((1< USB reset) */ #ifdef USB_CFG_PULLUP_IOPORT /* use usbDeviceConnect()/usbDeviceDisconnect() if available */ USBDDR = 0; /* we do RESET by deactivating pullup */ usbDeviceDisconnect(); #else USBDDR = (1< 9a8: 00 c0 rjmp .+0 ; 0x9aa 9aa: 00 00 nop _delay_ms(250); #ifdef USB_CFG_PULLUP_IOPORT usbDeviceConnect(); #else USBDDR = 0; /* remove USB reset condition */ 9ac: 1a b8 out 0x0a, r1 ; 10 #endif /* USART configuration */ baud.dword = UART_DEFAULT_BPS; 9ae: 80 e8 ldi r24, 0x80 ; 128 9b0: 95 e2 ldi r25, 0x25 ; 37 9b2: a0 e0 ldi r26, 0x00 ; 0 9b4: b0 e0 ldi r27, 0x00 ; 0 9b6: 80 93 0d 01 sts 0x010D, r24 ; 0x80010d 9ba: 90 93 0e 01 sts 0x010E, r25 ; 0x80010e 9be: a0 93 0f 01 sts 0x010F, r26 ; 0x80010f 9c2: b0 93 10 01 sts 0x0110, r27 ; 0x800110 stopbit = 0; 9c6: 10 92 13 01 sts 0x0113, r1 ; 0x800113 parity = 0; 9ca: 10 92 12 01 sts 0x0112, r1 ; 0x800112 databit = 8; 9ce: 88 e0 ldi r24, 0x08 ; 8 9d0: 80 93 11 01 sts 0x0111, r24 ; 0x800111 resetUart(); 9d4: 0e 94 11 04 call 0x822 ; 0x822 { wdt_enable(WDTO_1S); odDebugInit(); hardwareInit(); usbInit(); 9d8: 0e 94 e6 01 call 0x3cc ; 0x3cc intr3Status = 0; 9dc: 10 92 14 01 sts 0x0114, r1 ; 0x800114 sendEmptyFrame = 0; 9e0: 10 92 e3 02 sts 0x02E3, r1 ; 0x8002e3 sei(); 9e4: 78 94 sei for(;;){ /* main event loop */ wdt_reset(); 9e6: a8 95 wdr usbPoll(); 9e8: 0e 94 c3 00 call 0x186 ; 0x186 uartPoll(); 9ec: 0e 94 8f 03 call 0x71e ; 0x71e #if USB_CFG_HAVE_INTRIN_ENDPOINT3 /* We need to report rx and tx carrier after open attempt */ if(intr3Status != 0 && usbInterruptIsReady3()){ 9f0: 80 91 14 01 lds r24, 0x0114 ; 0x800114 9f4: 88 23 and r24, r24 9f6: b9 f3 breq .-18 ; 0x9e6 9f8: 90 91 4b 01 lds r25, 0x014B ; 0x80014b 9fc: 94 ff sbrs r25, 4 9fe: f3 cf rjmp .-26 ; 0x9e6 static uchar serialStateNotification[10] = {0xa1, 0x20, 0, 0, 0, 0, 2, 0, 3, 0}; if(intr3Status == 2){ a00: 82 30 cpi r24, 0x02 ; 2 a02: 59 f4 brne .+22 ; 0xa1a usbSetInterrupt3(serialStateNotification, 8); a04: 68 e0 ldi r22, 0x08 ; 8 a06: 82 e0 ldi r24, 0x02 ; 2 a08: 91 e0 ldi r25, 0x01 ; 1 }else{ usbSetInterrupt3(serialStateNotification+8, 2); a0a: 0e 94 bf 00 call 0x17e ; 0x17e } intr3Status--; a0e: 80 91 14 01 lds r24, 0x0114 ; 0x800114 a12: 81 50 subi r24, 0x01 ; 1 a14: 80 93 14 01 sts 0x0114, r24 ; 0x800114 a18: e6 cf rjmp .-52 ; 0x9e6 usbSetInterrupt3(serialStateNotification+8, 2); a1a: 62 e0 ldi r22, 0x02 ; 2 a1c: 8a e0 ldi r24, 0x0A ; 10 a1e: 91 e0 ldi r25, 0x01 ; 1 a20: f4 cf rjmp .-24 ; 0xa0a 00000a22 <__udivmodsi4>: a22: a1 e2 ldi r26, 0x21 ; 33 a24: 1a 2e mov r1, r26 a26: aa 1b sub r26, r26 a28: bb 1b sub r27, r27 a2a: fd 01 movw r30, r26 a2c: 0d c0 rjmp .+26 ; 0xa48 <__udivmodsi4_ep> 00000a2e <__udivmodsi4_loop>: a2e: aa 1f adc r26, r26 a30: bb 1f adc r27, r27 a32: ee 1f adc r30, r30 a34: ff 1f adc r31, r31 a36: a2 17 cp r26, r18 a38: b3 07 cpc r27, r19 a3a: e4 07 cpc r30, r20 a3c: f5 07 cpc r31, r21 a3e: 20 f0 brcs .+8 ; 0xa48 <__udivmodsi4_ep> a40: a2 1b sub r26, r18 a42: b3 0b sbc r27, r19 a44: e4 0b sbc r30, r20 a46: f5 0b sbc r31, r21 00000a48 <__udivmodsi4_ep>: a48: 66 1f adc r22, r22 a4a: 77 1f adc r23, r23 a4c: 88 1f adc r24, r24 a4e: 99 1f adc r25, r25 a50: 1a 94 dec r1 a52: 69 f7 brne .-38 ; 0xa2e <__udivmodsi4_loop> a54: 60 95 com r22 a56: 70 95 com r23 a58: 80 95 com r24 a5a: 90 95 com r25 a5c: 9b 01 movw r18, r22 a5e: ac 01 movw r20, r24 a60: bd 01 movw r22, r26 a62: cf 01 movw r24, r30 a64: 08 95 ret 00000a66 <_exit>: a66: f8 94 cli 00000a68 <__stop_program>: a68: ff cf rjmp .-2 ; 0xa68 <__stop_program>