sdraw.lss

TFT-LCD Atmega128 Source Code

 638:	6f 90       	pop	r6
 63a:	5f 90       	pop	r5
 63c:	4f 90       	pop	r4
 63e:	3f 90       	pop	r3
 640:	2f 90       	pop	r2
 642:	08 95       	ret

00000644 <sdraw_sync>:

    return response;
}

uint8_t sdraw_sync()
{
 644:	80 91 fe 04 	lds	r24, 0x04FE
 648:	88 23       	and	r24, r24
 64a:	11 f0       	breq	.+4      	; 0x650 <sdraw_sync+0xc>
 64c:	81 e0       	ldi	r24, 0x01	; 1
 64e:	08 95       	ret
    if(raw_block_written)
        return 1;
    if(!sdraw_write(raw_block_address, raw_block, sizeof(raw_block)))
 650:	60 91 ff 04 	lds	r22, 0x04FF
 654:	70 91 00 05 	lds	r23, 0x0500
 658:	80 91 01 05 	lds	r24, 0x0501
 65c:	90 91 02 05 	lds	r25, 0x0502
 660:	20 e0       	ldi	r18, 0x00	; 0
 662:	32 e0       	ldi	r19, 0x02	; 2
 664:	4e ef       	ldi	r20, 0xFE	; 254
 666:	52 e0       	ldi	r21, 0x02	; 2
 668:	0e 94 5a 02 	call	0x4b4	; 0x4b4 <sdraw_write>
 66c:	88 23       	and	r24, r24
 66e:	19 f0       	breq	.+6      	; 0x676 <sdraw_sync+0x32>
        return 0;
    raw_block_written = 1;
 670:	81 e0       	ldi	r24, 0x01	; 1
 672:	80 93 fe 04 	sts	0x04FE, r24

    return 1;
}
 676:	08 95       	ret

00000678 <sdraw_read>:

uint8_t sdraw_read(uint32_t offset, uint8_t* buffer, uint16_t length)
{
 678:	2f 92       	push	r2
 67a:	3f 92       	push	r3
 67c:	4f 92       	push	r4
 67e:	5f 92       	push	r5
 680:	6f 92       	push	r6
 682:	7f 92       	push	r7
 684:	8f 92       	push	r8
 686:	9f 92       	push	r9
 688:	af 92       	push	r10
 68a:	bf 92       	push	r11
 68c:	cf 92       	push	r12
 68e:	df 92       	push	r13
 690:	ef 92       	push	r14
 692:	ff 92       	push	r15
 694:	0f 93       	push	r16
 696:	1f 93       	push	r17
 698:	cf 93       	push	r28
 69a:	df 93       	push	r29
 69c:	5b 01       	movw	r10, r22
 69e:	6c 01       	movw	r12, r24
 6a0:	2a 01       	movw	r4, r20
 6a2:	49 01       	movw	r8, r18
    while(length > 0)
    {
        /* determine byte count to read at once */
        block_address = offset & 0xFFFFFE00;
        block_offset = offset & 0x01FF;
        read_length = 512 - block_offset; /* read up to block border */
 6a4:	21 2c       	mov	r2, r1
 6a6:	12 e0       	ldi	r17, 0x02	; 2
 6a8:	31 2e       	mov	r3, r17
 6aa:	54 c0       	rjmp	.+168    	; 0x754 <sdraw_read+0xdc>
        if(read_length > length)
            read_length = length;
        
        if(!sdraw_sync())
 6ac:	0e 94 22 03 	call	0x644	; 0x644 <sdraw_sync>
 6b0:	88 23       	and	r24, r24
 6b2:	09 f4       	brne	.+2      	; 0x6b6 <sdraw_read+0x3e>
 6b4:	54 c0       	rjmp	.+168    	; 0x75e <sdraw_read+0xe6>
            return 0;


        /* address card */
        select_card();
 6b6:	80 91 62 00 	lds	r24, 0x0062
 6ba:	8f 77       	andi	r24, 0x7F	; 127
 6bc:	80 93 62 00 	sts	0x0062, r24

        /* send single block request */
        if(sdraw_send_command_r1(CMD_READ_SINGLE_BLOCK, block_address))
 6c0:	b6 01       	movw	r22, r12
 6c2:	a5 01       	movw	r20, r10
 6c4:	40 70       	andi	r20, 0x00	; 0
 6c6:	5e 7f       	andi	r21, 0xFE	; 254
 6c8:	81 e1       	ldi	r24, 0x11	; 17
 6ca:	0e 94 7b 00 	call	0xf6	; 0xf6 <sdraw_send_command_r1>
 6ce:	88 23       	and	r24, r24
 6d0:	39 f0       	breq	.+14     	; 0x6e0 <sdraw_read+0x68>
        {
            unselect_card();
 6d2:	80 91 62 00 	lds	r24, 0x0062
 6d6:	80 68       	ori	r24, 0x80	; 128
 6d8:	80 93 62 00 	sts	0x0062, r24
 6dc:	80 e0       	ldi	r24, 0x00	; 0
 6de:	3f c0       	rjmp	.+126    	; 0x75e <sdraw_read+0xe6>
}

uint8_t sdraw_recv_byte()
{
    /* send dummy data for receiving some */
    return SPI_recv_byte();
 6e0:	0e 94 e0 03 	call	0x7c0	; 0x7c0 <SPI_recv_byte>
            unselect_card();
            return 0;
        }

        /* wait for data block (start byte 0xfe) */
        while(sdraw_recv_byte() != 0xFE);
 6e4:	8e 3f       	cpi	r24, 0xFE	; 254
 6e6:	e1 f7       	brne	.-8      	; 0x6e0 <sdraw_read+0x68>

    while(length > 0)
    {
        /* determine byte count to read at once */
        block_address = offset & 0xFFFFFE00;
        block_offset = offset & 0x01FF;
 6e8:	bf ef       	ldi	r27, 0xFF	; 255
 6ea:	eb 2e       	mov	r14, r27
 6ec:	b1 e0       	ldi	r27, 0x01	; 1
 6ee:	fb 2e       	mov	r15, r27
 6f0:	ea 20       	and	r14, r10
 6f2:	fb 20       	and	r15, r11
        read_length = 512 - block_offset; /* read up to block border */
 6f4:	81 01       	movw	r16, r2
 6f6:	0e 19       	sub	r16, r14
 6f8:	1f 09       	sbc	r17, r15
 6fa:	80 16       	cp	r8, r16
 6fc:	91 06       	cpc	r9, r17
 6fe:	08 f4       	brcc	.+2      	; 0x702 <sdraw_read+0x8a>
 700:	84 01       	movw	r16, r8

        /* wait for data block (start byte 0xfe) */
        while(sdraw_recv_byte() != 0xFE);

        /* read byte block */
        read_to = block_offset + read_length;
 702:	38 01       	movw	r6, r16
 704:	6e 0c       	add	r6, r14
 706:	7f 1c       	adc	r7, r15
 708:	c0 e0       	ldi	r28, 0x00	; 0
 70a:	d0 e0       	ldi	r29, 0x00	; 0
}

uint8_t sdraw_recv_byte()
{
    /* send dummy data for receiving some */
    return SPI_recv_byte();
 70c:	0e 94 e0 03 	call	0x7c0	; 0x7c0 <SPI_recv_byte>
        read_to = block_offset + read_length;
        
		for(i = 0; i < 512; ++i)
        {
            uint8_t b = sdraw_recv_byte();
            if(i >= block_offset && i < read_to)
 710:	ce 15       	cp	r28, r14
 712:	df 05       	cpc	r29, r15
 714:	30 f0       	brcs	.+12     	; 0x722 <sdraw_read+0xaa>
 716:	c6 15       	cp	r28, r6
 718:	d7 05       	cpc	r29, r7
 71a:	18 f4       	brcc	.+6      	; 0x722 <sdraw_read+0xaa>
                *buffer++ = b;
 71c:	f2 01       	movw	r30, r4
 71e:	81 93       	st	Z+, r24
 720:	2f 01       	movw	r4, r30
        while(sdraw_recv_byte() != 0xFE);

        /* read byte block */
        read_to = block_offset + read_length;
        
		for(i = 0; i < 512; ++i)
 722:	21 96       	adiw	r28, 0x01	; 1
 724:	f2 e0       	ldi	r31, 0x02	; 2
 726:	c0 30       	cpi	r28, 0x00	; 0
 728:	df 07       	cpc	r29, r31
 72a:	81 f7       	brne	.-32     	; 0x70c <sdraw_read+0x94>
}

uint8_t sdraw_recv_byte()
{
    /* send dummy data for receiving some */
    return SPI_recv_byte();
 72c:	0e 94 e0 03 	call	0x7c0	; 0x7c0 <SPI_recv_byte>
        /* read crc16 */
        sdraw_recv_byte();
        sdraw_recv_byte();
        
        /* deaddress card */
        unselect_card();
 730:	0e 94 e0 03 	call	0x7c0	; 0x7c0 <SPI_recv_byte>
 734:	80 91 62 00 	lds	r24, 0x0062
 738:	80 68       	ori	r24, 0x80	; 128
 73a:	80 93 62 00 	sts	0x0062, r24
}

uint8_t sdraw_recv_byte()
{
    /* send dummy data for receiving some */
    return SPI_recv_byte();
 73e:	0e 94 e0 03 	call	0x7c0	; 0x7c0 <SPI_recv_byte>

        /* let card some time to finish */
        sdraw_recv_byte();
 

        length -= read_length;
 742:	80 1a       	sub	r8, r16
 744:	91 0a       	sbc	r9, r17
        offset += read_length;
 746:	c8 01       	movw	r24, r16
 748:	a0 e0       	ldi	r26, 0x00	; 0
 74a:	b0 e0       	ldi	r27, 0x00	; 0
 74c:	a8 0e       	add	r10, r24
 74e:	b9 1e       	adc	r11, r25
 750:	ca 1e       	adc	r12, r26
 752:	db 1e       	adc	r13, r27
    uint16_t block_offset;
    uint16_t read_length;
	uint16_t read_to;
	uint16_t i;

    while(length > 0)
 754:	81 14       	cp	r8, r1
 756:	91 04       	cpc	r9, r1
 758:	09 f0       	breq	.+2      	; 0x75c <sdraw_read+0xe4>
 75a:	a8 cf       	rjmp	.-176    	; 0x6ac <sdraw_read+0x34>
 75c:	81 e0       	ldi	r24, 0x01	; 1
        length -= read_length;
        offset += read_length;
    }

    return 1;
}
 75e:	df 91       	pop	r29
 760:	cf 91       	pop	r28
 762:	1f 91       	pop	r17
 764:	0f 91       	pop	r16
 766:	ff 90       	pop	r15
 768:	ef 90       	pop	r14
 76a:	df 90       	pop	r13
 76c:	cf 90       	pop	r12
 76e:	bf 90       	pop	r11
 770:	af 90       	pop	r10
 772:	9f 90       	pop	r9
 774:	8f 90       	pop	r8
 776:	7f 90       	pop	r7
 778:	6f 90       	pop	r6
 77a:	5f 90       	pop	r5
 77c:	4f 90       	pop	r4
 77e:	3f 90       	pop	r3
 780:	2f 90       	pop	r2
 782:	08 95       	ret

00000784 <SPI_set_speed>:
#define SPI_MODE1_CPOL0CPHA1		0x04
#define SPI_MODE2_CPOL1CPHA0		0x08
#define SPI_MODE3_CPOL1CPHA1		0x0C

void SPI_set_speed(unsigned char speed, unsigned option)
{
 784:	9d b1       	in	r25, 0x0d	; 13
 786:	9c 7f       	andi	r25, 0xFC	; 252
 788:	98 2b       	or	r25, r24
 78a:	9d b9       	out	0x0d, r25	; 13
	SPCR = (SPCR & 0xFC) | speed;
	SPSR = (SPSR & 0xFE) | option;
 78c:	8e b1       	in	r24, 0x0e	; 14
 78e:	8e 7f       	andi	r24, 0xFE	; 254
 790:	86 2b       	or	r24, r22
 792:	8e b9       	out	0x0e, r24	; 14
}
 794:	08 95       	ret

00000796 <SPI_set_mode>:

void SPI_set_mode(unsigned mode)
{
 796:	9d b1       	in	r25, 0x0d	; 13
 798:	93 7f       	andi	r25, 0xF3	; 243
 79a:	98 2b       	or	r25, r24
 79c:	9d b9       	out	0x0d, r25	; 13
	SPCR = (SPCR & 0xF3) | mode;
}
 79e:	08 95       	ret

000007a0 <SPI_init>:

void SPI_init()
{
 7a0:	8d b1       	in	r24, 0x0d	; 13
 7a2:	83 60       	ori	r24, 0x03	; 3
 7a4:	8d b9       	out	0x0d, r24	; 13
#define SPI_MODE3_CPOL1CPHA1		0x0C

void SPI_set_speed(unsigned char speed, unsigned option)
{
	SPCR = (SPCR & 0xFC) | speed;
	SPSR = (SPSR & 0xFE) | option;
 7a6:	70 98       	cbi	0x0e, 0	; 14
}

void SPI_set_mode(unsigned mode)
{
	SPCR = (SPCR & 0xF3) | mode;
 7a8:	8d b1       	in	r24, 0x0d	; 13
 7aa:	83 7f       	andi	r24, 0xF3	; 243
 7ac:	8d b9       	out	0x0d, r24	; 13
{
	// Setup SPI bus with the Lowest Speed & SPI MODE0
	SPI_set_speed(SPI_SPEED_FOSC_DIV_128, SPI_2X_DISABLE);
	SPI_set_mode(SPI_MODE0_CPOL0CPHA0);

	SPCR |= _BV(SPE) | _BV(MSTR); 
 7ae:	8d b1       	in	r24, 0x0d	; 13
 7b0:	80 65       	ori	r24, 0x50	; 80
 7b2:	8d b9       	out	0x0d, r24	; 13
}
 7b4:	08 95       	ret

000007b6 <SPI_send_byte>:

unsigned char SPI_send_byte(unsigned char data)
{
 7b6:	8f b9       	out	0x0f, r24	; 15
	SPDR = data;

	while(!(SPSR & _BV(SPIF)));
 7b8:	77 9b       	sbis	0x0e, 7	; 14
 7ba:	fe cf       	rjmp	.-4      	; 0x7b8 <SPI_send_byte+0x2>

	return SPDR;
 7bc:	8f b1       	in	r24, 0x0f	; 15
}
 7be:	08 95       	ret

000007c0 <SPI_recv_byte>:

unsigned char SPI_recv_byte()
{
 7c0:	8f ef       	ldi	r24, 0xFF	; 255
 7c2:	8f b9       	out	0x0f, r24	; 15

unsigned char SPI_send_byte(unsigned char data)
{
	SPDR = data;

	while(!(SPSR & _BV(SPIF)));
 7c4:	77 9b       	sbis	0x0e, 7	; 14
 7c6:	fe cf       	rjmp	.-4      	; 0x7c4 <SPI_recv_byte+0x4>

	return SPDR;
 7c8:	8f b1       	in	r24, 0x0f	; 15
}

unsigned char SPI_recv_byte()
{
	return SPI_send_byte(0xFF);	// Send dummy byte for recv operation
}
 7ca:	08 95       	ret

000007cc <SPI_stop>:

void SPI_stop()
{
 7cc:	1d b8       	out	0x0d, r1	; 13
	SPCR = 0;
}
 7ce:	08 95       	ret

000007d0 <board_init>:
#include "config.h"


void board_init()
{
 7d0:	8f ef       	ldi	r24, 0xFF	; 255
 7d2:	8a bb       	out	0x1a, r24	; 26
	DDRA = 0xFF;
	PORTA = 0x00;
 7d4:	1b ba       	out	0x1b, r1	; 27
	DDRC = 0xFF;
 7d6:	84 bb       	out	0x14, r24	; 20
	PORTC = 0x00;
 7d8:	15 ba       	out	0x15, r1	; 21
	
	DDRG = 0xFF;
 7da:	80 93 64 00 	sts	0x0064, r24
	PORTG = _BV(0) | _BV(1) | _BV(3) | _BV(4);
 7de:	8b e1       	ldi	r24, 0x1B	; 27
 7e0:	80 93 65 00 	sts	0x0065, r24

	DDRB = 0b00000111;
 7e4:	87 e0       	ldi	r24, 0x07	; 7
 7e6:	87 bb       	out	0x17, r24	; 23
	PORTB |= _BV(0);
 7e8:	c0 9a       	sbi	0x18, 0	; 24

	DDRD = 0b11011011;
 7ea:	8b ed       	ldi	r24, 0xDB	; 219