usb_to_232.lss

采用atmel公司的mega8芯片设计的USB cdc类

            converter_t appBuf;
            appBuf.ptr = (uchar *)usbRxBuf;
 798:	20 e7       	ldi	r18, 0x70	; 112
 79a:	30 e0       	ldi	r19, 0x00	; 0
            appBuf.bytes[0] = usbAppBuf;
            appBuf.bytes[0]++;
 79c:	90 91 04 01 	lds	r25, 0x0104
 7a0:	9f 5f       	subi	r25, 0xFF	; 255
    DBG2(0x10 + ((usbRxToken >> 6) & 3), data, len);
#else
    DBG1(0x10 + ((usbRxToken >> 6) & 3), data, 2);
#endif
#if USB_CFG_IMPLEMENT_FN_WRITEOUT
    if(usbRxToken & 0x80){
 7a2:	80 91 12 01 	lds	r24, 0x0112
 7a6:	87 ff       	sbrs	r24, 7
 7a8:	04 c0       	rjmp	.+8      	; 0x7b2 <usbPoll+0x32>
        usbFunctionWriteOut(data, len);
 7aa:	89 2f       	mov	r24, r25
 7ac:	93 2f       	mov	r25, r19
 7ae:	07 dd       	rcall	.-1522   	; 0x1be <usbFunctionWriteOut>
 7b0:	9c c0       	rjmp	.+312    	; 0x8ea <usbPoll+0x16a>
        return;
    }
    if(usbRxToken == (uchar)(USBPID_SETUP & 0x7f)){ /* MSb contains endpoint (== 0) */
 7b2:	8d 32       	cpi	r24, 0x2D	; 45
 7b4:	09 f0       	breq	.+2      	; 0x7b8 <usbPoll+0x38>
 7b6:	7a c0       	rjmp	.+244    	; 0x8ac <usbPoll+0x12c>
#else
    if(usbRxToken == (uchar)USBPID_SETUP){
#endif
        if(len == 8){   /* Setup size must be always 8 bytes. Ignore otherwise. */
 7b8:	68 30       	cpi	r22, 0x08	; 8
 7ba:	09 f0       	breq	.+2      	; 0x7be <usbPoll+0x3e>
 7bc:	8e c0       	rjmp	.+284    	; 0x8da <usbPoll+0x15a>
 * above was written, or other parts of the code have changed. We now get
 * better results with an inlined function. Test condition: PowerSwitch code.
 */
static void usbProcessRx(uchar *data, uchar len)
{
usbRequest_t    *rq = (void *)data;
 7be:	c9 2f       	mov	r28, r25
 7c0:	d3 2f       	mov	r29, r19
#else
    if(usbRxToken == (uchar)USBPID_SETUP){
#endif
        if(len == 8){   /* Setup size must be always 8 bytes. Ignore otherwise. */
            uchar type = rq->bmRequestType & USBRQ_TYPE_MASK;
            if(type == USBRQ_TYPE_STANDARD){
 7c2:	88 81       	ld	r24, Y
 7c4:	80 76       	andi	r24, 0x60	; 96
 7c6:	09 f0       	breq	.+2      	; 0x7ca <usbPoll+0x4a>
 7c8:	64 c0       	rjmp	.+200    	; 0x892 <usbPoll+0x112>
                uchar *replyData = usbTxBuf + 9; /* there is 3 bytes free space at the end of the buffer */
                replyData[0] = 0;   /* common to USBRQ_GET_STATUS and USBRQ_GET_INTERFACE */
 7ca:	10 92 f6 00 	sts	0x00F6, r1
                if(rq->bRequest == USBRQ_GET_STATUS){           /* 0 */
 7ce:	89 81       	ldd	r24, Y+1	; 0x01
 7d0:	88 23       	and	r24, r24
 7d2:	39 f4       	brne	.+14     	; 0x7e2 <usbPoll+0x62>
#endif
#if USB_CFG_HAVE_INTRIN_ENDPOINT && USB_CFG_IMPLEMENT_HALT
                    if(usbHalted1 && recipient == USBRQ_RCPT_ENDPOINT && rq->wIndex.bytes[0] == 0x81)   /* request status for endpoint 1 */
                        replyData[0] = 1;
#endif
                    replyData[1] = 0;
 7d4:	10 92 f7 00 	sts	0x00F7, r1
 7d8:	26 ef       	ldi	r18, 0xF6	; 246
 7da:	30 e0       	ldi	r19, 0x00	; 0
 7dc:	40 e8       	ldi	r20, 0x80	; 128
 7de:	92 e0       	ldi	r25, 0x02	; 2
 7e0:	4d c0       	rjmp	.+154    	; 0x87c <usbPoll+0xfc>
                    replyLen = 2;
                }else if(rq->bRequest == USBRQ_SET_ADDRESS){    /* 5 */
 7e2:	85 30       	cpi	r24, 0x05	; 5
 7e4:	21 f4       	brne	.+8      	; 0x7ee <usbPoll+0x6e>
                    usbNewDeviceAddr = rq->wValue.bytes[0];
 7e6:	8a 81       	ldd	r24, Y+2	; 0x02
 7e8:	80 93 17 01 	sts	0x0117, r24
 7ec:	43 c0       	rjmp	.+134    	; 0x874 <usbPoll+0xf4>
                }else if(rq->bRequest == USBRQ_GET_DESCRIPTOR){ /* 6 */
 7ee:	86 30       	cpi	r24, 0x06	; 6
 7f0:	59 f5       	brne	.+86     	; 0x848 <usbPoll+0xc8>
                    flags = USB_FLG_MSGPTR_IS_ROM | USB_FLG_USE_DEFAULT_RW;
                    if(rq->wValue.bytes[1] == 1){   /* descriptor type requested */
 7f2:	8b 81       	ldd	r24, Y+3	; 0x03
 7f4:	81 30       	cpi	r24, 0x01	; 1
 7f6:	29 f4       	brne	.+10     	; 0x802 <usbPoll+0x82>
 7f8:	29 e6       	ldi	r18, 0x69	; 105
 7fa:	30 e0       	ldi	r19, 0x00	; 0
 7fc:	40 ec       	ldi	r20, 0xC0	; 192
 7fe:	92 e1       	ldi	r25, 0x12	; 18
 800:	3d c0       	rjmp	.+122    	; 0x87c <usbPoll+0xfc>
                        replyLen = sizeof(usbDescrDevice);
                        replyData = (uchar *)usbDescrDevice;
                    }else if(rq->wValue.bytes[1] == 2){
 802:	82 30       	cpi	r24, 0x02	; 2
 804:	29 f4       	brne	.+10     	; 0x810 <usbPoll+0x90>
 806:	26 e2       	ldi	r18, 0x26	; 38
 808:	30 e0       	ldi	r19, 0x00	; 0
 80a:	40 ec       	ldi	r20, 0xC0	; 192
 80c:	93 e4       	ldi	r25, 0x43	; 67
 80e:	36 c0       	rjmp	.+108    	; 0x87c <usbPoll+0xfc>
                        replyLen = USB_CFG_EXTERNAL_CONFIG_DESCRIPTOR_LENGH;
                        replyData = (uchar *)usbDescrConfig;
                    }else if(rq->wValue.bytes[1] == 3){ /* string descriptor */
 810:	83 30       	cpi	r24, 0x03	; 3
 812:	89 f4       	brne	.+34     	; 0x836 <usbPoll+0xb6>
                        if(rq->wValue.bytes[0] == 0){   /* descriptor index */
 814:	8a 81       	ldd	r24, Y+2	; 0x02
 816:	88 23       	and	r24, r24
 818:	29 f4       	brne	.+10     	; 0x824 <usbPoll+0xa4>
 81a:	2b e7       	ldi	r18, 0x7B	; 123
 81c:	30 e0       	ldi	r19, 0x00	; 0
 81e:	40 ec       	ldi	r20, 0xC0	; 192
 820:	94 e0       	ldi	r25, 0x04	; 4
 822:	2c c0       	rjmp	.+88     	; 0x87c <usbPoll+0xfc>
                            replyLen = sizeof(usbDescrString0);
                            replyData = (uchar *)usbDescrString0;
#if USB_CFG_VENDOR_NAME_LEN
                        }else if(rq->wValue.bytes[0] == 1){
 824:	81 30       	cpi	r24, 0x01	; 1
 826:	29 f4       	brne	.+10     	; 0x832 <usbPoll+0xb2>
                            replyLen = sizeof(usbDescrString1);
                            replyData = (uchar *)usbDescrString1;
 828:	2f e7       	ldi	r18, 0x7F	; 127
 82a:	30 e0       	ldi	r19, 0x00	; 0
 82c:	40 ec       	ldi	r20, 0xC0	; 192
 82e:	92 e2       	ldi	r25, 0x22	; 34
 830:	25 c0       	rjmp	.+74     	; 0x87c <usbPoll+0xfc>
#endif
#if USB_CFG_DEVICE_NAME_LEN
                        }else if(rq->wValue.bytes[0] == 2){
 832:	82 30       	cpi	r24, 0x02	; 2
 834:	21 f0       	breq	.+8      	; 0x83e <usbPoll+0xbe>
 836:	26 ef       	ldi	r18, 0xF6	; 246
 838:	30 e0       	ldi	r19, 0x00	; 0
 83a:	40 ec       	ldi	r20, 0xC0	; 192
 83c:	1e c0       	rjmp	.+60     	; 0x87a <usbPoll+0xfa>
                            replyLen = sizeof(usbDescrString2);
                            replyData = (uchar *)usbDescrString2;
 83e:	21 ea       	ldi	r18, 0xA1	; 161
 840:	30 e0       	ldi	r19, 0x00	; 0
 842:	40 ec       	ldi	r20, 0xC0	; 192
 844:	90 e1       	ldi	r25, 0x10	; 16
 846:	1a c0       	rjmp	.+52     	; 0x87c <usbPoll+0xfc>
                    }else if(rq->wValue.bytes[1] == USBDESCR_HID_REPORT){   /* 0x22 */
                        replyLen = USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH;
                        replyData = (uchar *)usbHidReportDescriptor;
                    }
#endif
                }else if(rq->bRequest == USBRQ_GET_CONFIGURATION){  /* 8 */
 848:	88 30       	cpi	r24, 0x08	; 8
 84a:	19 f4       	brne	.+6      	; 0x852 <usbPoll+0xd2>
 84c:	29 e1       	ldi	r18, 0x19	; 25
 84e:	31 e0       	ldi	r19, 0x01	; 1
 850:	0a c0       	rjmp	.+20     	; 0x866 <usbPoll+0xe6>
                    replyLen = 1;
                    replyData = &usbConfiguration;  /* send current configuration value */
                }else if(rq->bRequest == USBRQ_SET_CONFIGURATION){  /* 9 */
 852:	89 30       	cpi	r24, 0x09	; 9
 854:	21 f4       	brne	.+8      	; 0x85e <usbPoll+0xde>
                    usbConfiguration = rq->wValue.bytes[0];
 856:	8a 81       	ldd	r24, Y+2	; 0x02
 858:	80 93 19 01 	sts	0x0119, r24
 85c:	0b c0       	rjmp	.+22     	; 0x874 <usbPoll+0xf4>
#if USB_CFG_IMPLEMENT_HALT
                    usbHalted1 = 0;
#endif
                }else if(rq->bRequest == USBRQ_GET_INTERFACE){      /* 10 */
 85e:	8a 30       	cpi	r24, 0x0A	; 10
 860:	29 f4       	brne	.+10     	; 0x86c <usbPoll+0xec>
 862:	26 ef       	ldi	r18, 0xF6	; 246
 864:	30 e0       	ldi	r19, 0x00	; 0
 866:	40 e8       	ldi	r20, 0x80	; 128
 868:	91 e0       	ldi	r25, 0x01	; 1
 86a:	08 c0       	rjmp	.+16     	; 0x87c <usbPoll+0xfc>
                            usbTxLen1 = 2;      /* length including sync byte */
                        }
                        usbTxPacketCnt1 = 0;    /* reset data toggling for interrupt endpoint */
                    }
#endif
                }else if(rq->bRequest == USBRQ_SET_INTERFACE){      /* 11 */
 86c:	8b 30       	cpi	r24, 0x0B	; 11
 86e:	11 f4       	brne	.+4      	; 0x874 <usbPoll+0xf4>
                    usbTxPacketCnt1 = 0;        /* reset data toggling for interrupt endpoint */
 870:	10 92 15 01 	sts	0x0115, r1
 874:	26 ef       	ldi	r18, 0xF6	; 246
 876:	30 e0       	ldi	r19, 0x00	; 0
 878:	40 e8       	ldi	r20, 0x80	; 128
 87a:	90 e0       	ldi	r25, 0x00	; 0
                }else{
                    /* the following requests can be ignored, send default reply */
                    /* 1: CLEAR_FEATURE, 3: SET_FEATURE, 7: SET_DESCRIPTOR */
                    /* 12: SYNCH_FRAME */
                }
                usbMsgPtr = replyData;
 87c:	30 93 14 01 	sts	0x0114, r19
 880:	20 93 13 01 	sts	0x0113, r18
                if(!rq->wLength.bytes[1] && replyLen > rq->wLength.bytes[0])  /* max length is in */
 884:	8f 81       	ldd	r24, Y+7	; 0x07
 886:	88 23       	and	r24, r24
 888:	59 f5       	brne	.+86     	; 0x8e0 <usbPoll+0x160>
 88a:	2e 81       	ldd	r18, Y+6	; 0x06
 88c:	29 17       	cp	r18, r25
 88e:	48 f1       	brcs	.+82     	; 0x8e2 <usbPoll+0x162>
 890:	27 c0       	rjmp	.+78     	; 0x8e0 <usbPoll+0x160>
                    replyLen = rq->wLength.bytes[0];
            }else{  /* not a standard request -- must be vendor or class request */
                replyLen = usbFunctionSetup(data);
 892:	89 2f       	mov	r24, r25
 894:	93 2f       	mov	r25, r19
 896:	7e dc       	rcall	.-1796   	; 0x194 <usbFunctionSetup>
 898:	28 2f       	mov	r18, r24
#if USB_CFG_IMPLEMENT_FN_READ || USB_CFG_IMPLEMENT_FN_WRITE
                if(replyLen == 0xff){   /* use user-supplied read/write function */
 89a:	8f 3f       	cpi	r24, 0xFF	; 255
 89c:	11 f0       	breq	.+4      	; 0x8a2 <usbPoll+0x122>
 89e:	40 e8       	ldi	r20, 0x80	; 128
 8a0:	20 c0       	rjmp	.+64     	; 0x8e2 <usbPoll+0x162>
                    if((rq->bmRequestType & USBRQ_DIR_MASK) == USBRQ_DIR_DEVICE_TO_HOST){
 8a2:	88 81       	ld	r24, Y
 8a4:	87 fd       	sbrc	r24, 7
                        replyLen = rq->wLength.bytes[0];    /* IN transfers only */
 8a6:	2e 81       	ldd	r18, Y+6	; 0x06
 8a8:	40 e0       	ldi	r20, 0x00	; 0
 8aa:	1b c0       	rjmp	.+54     	; 0x8e2 <usbPoll+0x162>
            }
        }
        /* make sure that data packets which are sent as ACK to an OUT transfer are always zero sized */
    }else{  /* DATA packet from out request */
#if USB_CFG_IMPLEMENT_FN_WRITE
        if(!(usbMsgFlags & USB_FLG_USE_DEFAULT_RW)){
 8ac:	80 91 86 00 	lds	r24, 0x0086
 8b0:	87 fd       	sbrc	r24, 7
 8b2:	13 c0       	rjmp	.+38     	; 0x8da <usbPoll+0x15a>
            uchar rval = usbFunctionWrite(data, len);
 8b4:	89 2f       	mov	r24, r25
 8b6:	93 2f       	mov	r25, r19
 8b8:	24 dd       	rcall	.-1464   	; 0x302 <usbFunctionWrite>
            replyLen = 0xff;
            if(rval == 0xff){       /* an error occurred */
 8ba:	8f 3f       	cpi	r24, 0xFF	; 255
 8bc:	39 f4       	brne	.+14     	; 0x8cc <usbPoll+0x14c>
                /* usbMsgLen = 0xff; cancel potentially pending ACK [has been done by ASM module when OUT token arrived] */
                usbTxBuf[0] = USBPID_STALL;
 8be:	8e e1       	ldi	r24, 0x1E	; 30
 8c0:	80 93 ed 00 	sts	0x00ED, r24
                usbTxLen = 2;       /* length including sync byte */
 8c4:	82 e0       	ldi	r24, 0x02	; 2
 8c6:	80 93 68 00 	sts	0x0068, r24
 8ca:	04 c0       	rjmp	.+8      	; 0x8d4 <usbPoll+0x154>
            }else if(rval != 0){    /* This was the final package */
 8cc:	88 23       	and	r24, r24
 8ce:	11 f0       	breq	.+4      	; 0x8d4 <usbPoll+0x154>
 8d0:	40 e0       	ldi	r20, 0x00	; 0
 8d2:	04 c0       	rjmp	.+8      	; 0x8dc <usbPoll+0x15c>
 8d4:	40 e0       	ldi	r20, 0x00	; 0
 8d6:	2f ef       	ldi	r18, 0xFF	; 255
 8d8:	04 c0       	rjmp	.+8      	; 0x8e2 <usbPoll+0x162>
 8da:	40 e8       	ldi	r20, 0x80	; 128
 8dc:	20 e0       	ldi	r18, 0x00	; 0
 8de:	01 c0       	rjmp	.+2      	; 0x8e2 <usbPoll+0x162>
 8e0:	29 2f       	mov	r18, r25
        }
#else
        replyLen = 0;      /* send zero-sized block as ACK */
#endif
    }
    usbMsgFlags = flags;
 8e2:	40 93 86 00 	sts	0x0086, r20
    usbMsgLen = replyLen;
 8e6:	20 93 67 00 	sts	0x0067, r18
            appBuf.bytes[0] = usbAppBuf;
            appBuf.bytes[0]++;
            usbProcessRx(appBuf.ptr, len);
        }
#if USB_CFG_HAVE_FLOWCONTROL
        if(usbRxLen > 0)    /* only mark as available if not inactivated */
 8ea:	80 91 16 01 	lds	r24, 0x0116
 8ee:	18 16       	cp	r1, r24
 8f0:	14 f4       	brge	.+4      	; 0x8f6 <usbPoll+0x176>
            usbRxLen = 0;
 8f2:	10 92 16 01 	sts	0x0116, r1
#else
        usbRxLen = 0;   /* mark rx buffer as available */
#endif
    }
    if(usbMsgLen != 0xff){  /* transmit data pending? */
 8f6:	90 91 67 00 	lds	r25, 0x0067
 8fa:	9f 3f       	cpi	r25, 0xFF	; 255
 8fc:	09 f4       	brne	.+2      	; 0x900 <usbPoll+0x180>
 8fe:	5b c0       	rjmp	.+182    	; 0x9b6 <usbPoll+0x236>
        if(usbTxLen < 0)    /* transmit system idle */
 900:	80 91 68 00 	lds	r24, 0x0068
 904:	87 ff       	sbrs	r24, 7
 906:	57 c0       	rjmp	.+174    	; 0x9b6 <usbPoll+0x236>
 908:	19 2f       	mov	r17, r25
 90a:	99 30       	cpi	r25, 0x09	; 9
 90c:	08 f0       	brcs	.+2      	; 0x910 <usbPoll+0x190>
 90e:	18 e0       	ldi	r17, 0x08	; 8
uchar       wantLen, len, txLen, token;

    wantLen = usbMsgLen;
    if(wantLen > 8)
        wantLen = 8;
    usbMsgLen -= wantLen;
 910:	91 1b       	sub	r25, r17
 912:	90 93 67 00 	sts	0x0067, r25
    token = USBPID_DATA1;
    if(usbMsgFlags & USB_FLG_TX_PACKET)
 916:	80 91 86 00 	lds	r24, 0x0086
 91a:	80 fd       	sbrc	r24, 0
 91c:	02 c0       	rjmp	.+4      	; 0x922 <usbPoll+0x1a2>
 91e:	0b e4       	ldi	r16, 0x4B	; 75
 920:	01 c0       	rjmp	.+2      	; 0x924 <usbPoll+0x1a4>
 922:	03 ec       	ldi	r16, 0xC3	; 195
        token = USBPID_DATA0;
    usbMsgFlags++;
 924:	8f 5f       	subi	r24, 0xFF	; 255
 926:	80 93 86 00 	sts	0x0086, r24


static uchar    usbRead(uchar *data, uchar len)
{
#if USB_CFG_IMPLEMENT_FN_READ
    if(usbMsgFlags & USB_FLG_USE_DEFAULT_RW){
 92a:	87 ff       	sbrs	r24, 7
 92c:	26 c0       	rjmp	.+76     	; 0x97a <usbPoll+0x1fa>
#endif
        uchar i = len, *r = usbMsgPtr;
 92e:	20 91 13 01 	lds	r18, 0x0113
 932:	30 91 14 01 	lds	r19, 0x0114
        if(usbMsgFlags & USB_FLG_MSGPTR_IS_ROM){    /* ROM data */
 936:	86 fd       	sbrc	r24, 6
 938:	05 c0       	rjmp	.+10     	; 0x944 <usbPoll+0x1c4>
 93a:	d9 01       	movw	r26, r18
 93c:	91 2f       	mov	r25, r17
 93e:	ee ee       	ldi	r30, 0xEE	; 238
 940:	f0 e0       	ldi	r31, 0x00	; 0
 942:	11 c0       	rjmp	.+34     	; 0x966 <usbPoll+0x1e6>
 944:	ae ee       	ldi	r26, 0xEE	; 238
 946:	b0 e0       	ldi	r27, 0x00	; 0
 948:	80 e0       	ldi	r24, 0x00	; 0
 94a:	90 e0       	ldi	r25, 0x00	; 0
 94c:	06 c0       	rjmp	.+12     	; 0x95a <usbPoll+0x1da>
            while(i--){
                uchar c = PRG_RDB(r);    /* assign to char size variable to enforce byte ops */
 94e:	f9 01       	movw	r30, r18
 950:	e8 0f       	add	r30, r24
 952:	f9 1f       	adc	r31, r25
 954:	e4 91       	lpm	r30, Z+
                *data++ = c;
 956:	ed 93       	st	X+, r30
 958:	01 96       	adiw	r24, 0x01	; 1
#if USB_CFG_IMPLEMENT_FN_READ
    if(usbMsgFlags & USB_FLG_USE_DEFAULT_RW){
#endif
        uchar i = len, *r = usbMsgPtr;
        if(usbMsgFlags & USB_FLG_MSGPTR_IS_ROM){    /* ROM data */
            while(i--){
 95a:	18 17       	cp	r17, r24
 95c:	c1 f7       	brne	.-16     	; 0x94e <usbPoll+0x1ce>
 95e:	05 c0       	rjmp	.+10     	; 0x96a <usbPoll+0x1ea>
                *data++ = c;
                r++;
            }
        }else{                  /* RAM data */
            while(i--)
                *data++ = *r++;
 960:	8d 91       	ld	r24, X+
 962:	81 93       	st	Z+, r24
 964:	91 50       	subi	r25, 0x01	; 1
                uchar c = PRG_RDB(r);    /* assign