sdraw.lss

TFT-LCD Atmega128 Source Code

 40e:	59 f4       	brne	.+22     	; 0x426 <sdraw_init+0x8a>
        {
            unselect_card();
 410:	80 91 62 00 	lds	r24, 0x0062
 414:	80 68       	ori	r24, 0x80	; 128
 416:	80 93 62 00 	sts	0x0062, r24
			UART_puts("ERROR : RESET TIMEOVER\n");
 41a:	87 e2       	ldi	r24, 0x27	; 39
 41c:	91 e0       	ldi	r25, 0x01	; 1
 41e:	0e 94 c4 04 	call	0x988	; 0x988 <UART_puts>
 422:	80 e0       	ldi	r24, 0x00	; 0
 424:	43 c0       	rjmp	.+134    	; 0x4ac <sdraw_init+0x110>

    /* address card */
    select_card();

    /* reset card */
    for(j = 0; ; ++j)
 426:	21 96       	adiw	r28, 0x01	; 1
 428:	e6 cf       	rjmp	.-52     	; 0x3f6 <sdraw_init+0x5a>
            unselect_card();
			UART_puts("ERROR : RESET TIMEOVER\n");
            return 0;
        }
    }
    UART_puts("RESET OK\n");
 42a:	8f e3       	ldi	r24, 0x3F	; 63
 42c:	91 e0       	ldi	r25, 0x01	; 1
 42e:	0e 94 c4 04 	call	0x988	; 0x988 <UART_puts>
 432:	c0 e0       	ldi	r28, 0x00	; 0
 434:	d0 e0       	ldi	r29, 0x00	; 0
    /* wait for card to get ready */
    for(j = 0; ; ++j)
    {
        response = sdraw_send_command_r1(CMD_SEND_OP_COND, 0);
 436:	40 e0       	ldi	r20, 0x00	; 0
 438:	50 e0       	ldi	r21, 0x00	; 0
 43a:	60 e0       	ldi	r22, 0x00	; 0
 43c:	70 e0       	ldi	r23, 0x00	; 0
 43e:	81 e0       	ldi	r24, 0x01	; 1
 440:	0e 94 7b 00 	call	0xf6	; 0xf6 <sdraw_send_command_r1>
        if(!(response & (1 << R1_IDLE_STATE)))
 444:	80 ff       	sbrs	r24, 0
 446:	0e c0       	rjmp	.+28     	; 0x464 <sdraw_init+0xc8>
            break;

        if(j == 0x7fff)
 448:	8f e7       	ldi	r24, 0x7F	; 127
 44a:	cf 3f       	cpi	r28, 0xFF	; 255
 44c:	d8 07       	cpc	r29, r24
 44e:	41 f4       	brne	.+16     	; 0x460 <sdraw_init+0xc4>
        {
            unselect_card();
 450:	80 91 62 00 	lds	r24, 0x0062
 454:	80 68       	ori	r24, 0x80	; 128
 456:	80 93 62 00 	sts	0x0062, r24
			UART_puts("ERROR : CARD NOT READY\n");
 45a:	89 e4       	ldi	r24, 0x49	; 73
 45c:	91 e0       	ldi	r25, 0x01	; 1
 45e:	df cf       	rjmp	.-66     	; 0x41e <sdraw_init+0x82>
            return 0;
        }
    }
    UART_puts("RESET OK\n");
    /* wait for card to get ready */
    for(j = 0; ; ++j)
 460:	21 96       	adiw	r28, 0x01	; 1
 462:	e9 cf       	rjmp	.-46     	; 0x436 <sdraw_init+0x9a>
            unselect_card();
			UART_puts("ERROR : CARD NOT READY\n");
            return 0;
        }
    }
	UART_puts("CARD READY\n");
 464:	81 e6       	ldi	r24, 0x61	; 97
 466:	91 e0       	ldi	r25, 0x01	; 1
 468:	0e 94 c4 04 	call	0x988	; 0x988 <UART_puts>
    /* set block size to 512 bytes */
    if(sdraw_send_command_r1(CMD_SET_BLOCKLEN, 512))
 46c:	40 e0       	ldi	r20, 0x00	; 0
 46e:	52 e0       	ldi	r21, 0x02	; 2
 470:	60 e0       	ldi	r22, 0x00	; 0
 472:	70 e0       	ldi	r23, 0x00	; 0
 474:	80 e1       	ldi	r24, 0x10	; 16
 476:	0e 94 7b 00 	call	0xf6	; 0xf6 <sdraw_send_command_r1>
 47a:	88 23       	and	r24, r24
 47c:	41 f0       	breq	.+16     	; 0x48e <sdraw_init+0xf2>
    {
        unselect_card();
 47e:	80 91 62 00 	lds	r24, 0x0062
 482:	80 68       	ori	r24, 0x80	; 128
 484:	80 93 62 00 	sts	0x0062, r24
		UART_puts("ERROR : UNABLE TO BLOCK SIZE\n");
 488:	8d e6       	ldi	r24, 0x6D	; 109
 48a:	91 e0       	ldi	r25, 0x01	; 1
 48c:	c8 cf       	rjmp	.-112    	; 0x41e <sdraw_init+0x82>
        return 0;
    }
	UART_puts("SET BLOCK SIZE TO 512\n");
 48e:	8b e8       	ldi	r24, 0x8B	; 139
 490:	91 e0       	ldi	r25, 0x01	; 1
 492:	0e 94 c4 04 	call	0x988	; 0x988 <UART_puts>
    /* deaddress card */
    unselect_card();
 496:	80 91 62 00 	lds	r24, 0x0062
 49a:	80 68       	ori	r24, 0x80	; 128
 49c:	80 93 62 00 	sts	0x0062, r24

    /* switch to highest SPI frequency possible */
	SPI_set_speed(SPI_SPEED_FOSC_DIV_4, SPI_2X_ENABLE);
 4a0:	61 e0       	ldi	r22, 0x01	; 1
 4a2:	70 e0       	ldi	r23, 0x00	; 0
 4a4:	80 e0       	ldi	r24, 0x00	; 0
 4a6:	0e 94 c2 03 	call	0x784	; 0x784 <SPI_set_speed>
 4aa:	81 e0       	ldi	r24, 0x01	; 1

    return 1;
}
 4ac:	df 91       	pop	r29
 4ae:	cf 91       	pop	r28
 4b0:	1f 91       	pop	r17
 4b2:	08 95       	ret

000004b4 <sdraw_write>:

    return 1;
}

uint8_t sdraw_write(uint32_t offset, const uint8_t* buffer, uint16_t length)
{
 4b4:	2f 92       	push	r2
 4b6:	3f 92       	push	r3
 4b8:	4f 92       	push	r4
 4ba:	5f 92       	push	r5
 4bc:	6f 92       	push	r6
 4be:	7f 92       	push	r7
 4c0:	8f 92       	push	r8
 4c2:	9f 92       	push	r9
 4c4:	af 92       	push	r10
 4c6:	bf 92       	push	r11
 4c8:	cf 92       	push	r12
 4ca:	df 92       	push	r13
 4cc:	ef 92       	push	r14
 4ce:	ff 92       	push	r15
 4d0:	0f 93       	push	r16
 4d2:	1f 93       	push	r17
 4d4:	cf 93       	push	r28
 4d6:	df 93       	push	r29
 4d8:	4b 01       	movw	r8, r22
 4da:	5c 01       	movw	r10, r24
 4dc:	2a 01       	movw	r4, r20
 4de:	39 01       	movw	r6, r18
    uint16_t block_offset;
    uint16_t write_length;
	uint8_t* cache;
	uint16_t i;

    if(sdraw_card_wp())
 4e0:	b7 9b       	sbis	0x16, 7	; 22
 4e2:	9a c0       	rjmp	.+308    	; 0x618 <sdraw_write+0x164>
 4e4:	91 c0       	rjmp	.+290    	; 0x608 <sdraw_write+0x154>
        return 0;
    
    while(length > 0)
    {
        /* determine byte count to write at once */
        block_address = offset & 0xFFFFFE00;
 4e6:	e1 2c       	mov	r14, r1
 4e8:	ae ef       	ldi	r26, 0xFE	; 254
 4ea:	fa 2e       	mov	r15, r26
 4ec:	af ef       	ldi	r26, 0xFF	; 255
 4ee:	0a 2f       	mov	r16, r26
 4f0:	af ef       	ldi	r26, 0xFF	; 255
 4f2:	1a 2f       	mov	r17, r26
 4f4:	e8 20       	and	r14, r8
 4f6:	f9 20       	and	r15, r9
 4f8:	0a 21       	and	r16, r10
 4fa:	1b 21       	and	r17, r11
        block_offset = offset & 0x01FF;
 4fc:	e4 01       	movw	r28, r8
 4fe:	d1 70       	andi	r29, 0x01	; 1
        write_length = 512 - block_offset; /* write up to block border */
 500:	61 01       	movw	r12, r2
 502:	cc 1a       	sub	r12, r28
 504:	dd 0a       	sbc	r13, r29
 506:	6c 14       	cp	r6, r12
 508:	7d 04       	cpc	r7, r13
 50a:	08 f4       	brcc	.+2      	; 0x50e <sdraw_write+0x5a>
 50c:	63 01       	movw	r12, r6
            write_length = length;
        
        /* Merge the data to write with the content of the block.
         * Use the cached block if available.
         */
        if(block_address != raw_block_address)
 50e:	80 91 ff 04 	lds	r24, 0x04FF
 512:	90 91 00 05 	lds	r25, 0x0500
 516:	a0 91 01 05 	lds	r26, 0x0501
 51a:	b0 91 02 05 	lds	r27, 0x0502
 51e:	e8 16       	cp	r14, r24
 520:	f9 06       	cpc	r15, r25
 522:	0a 07       	cpc	r16, r26
 524:	1b 07       	cpc	r17, r27
 526:	f9 f0       	breq	.+62     	; 0x566 <sdraw_write+0xb2>
        {

            if(!sdraw_sync())
 528:	0e 94 22 03 	call	0x644	; 0x644 <sdraw_sync>
 52c:	88 23       	and	r24, r24
 52e:	09 f4       	brne	.+2      	; 0x532 <sdraw_write+0x7e>
 530:	73 c0       	rjmp	.+230    	; 0x618 <sdraw_write+0x164>
                return 0;

            if(block_offset || write_length < 512)
 532:	20 97       	sbiw	r28, 0x00	; 0
 534:	29 f4       	brne	.+10     	; 0x540 <sdraw_write+0x8c>
 536:	80 e0       	ldi	r24, 0x00	; 0
 538:	c8 16       	cp	r12, r24
 53a:	82 e0       	ldi	r24, 0x02	; 2
 53c:	d8 06       	cpc	r13, r24
 53e:	58 f4       	brcc	.+22     	; 0x556 <sdraw_write+0xa2>
            {
                if(!sdraw_read(block_address, raw_block, sizeof(raw_block)))
 540:	20 e0       	ldi	r18, 0x00	; 0
 542:	32 e0       	ldi	r19, 0x02	; 2
 544:	4e ef       	ldi	r20, 0xFE	; 254
 546:	52 e0       	ldi	r21, 0x02	; 2
 548:	c8 01       	movw	r24, r16
 54a:	b7 01       	movw	r22, r14
 54c:	0e 94 3c 03 	call	0x678	; 0x678 <sdraw_read>
 550:	88 23       	and	r24, r24
 552:	09 f4       	brne	.+2      	; 0x556 <sdraw_write+0xa2>
 554:	61 c0       	rjmp	.+194    	; 0x618 <sdraw_write+0x164>
                    return 0;
            }
            raw_block_address = block_address;
 556:	e0 92 ff 04 	sts	0x04FF, r14
 55a:	f0 92 00 05 	sts	0x0500, r15
 55e:	00 93 01 05 	sts	0x0501, r16
 562:	10 93 02 05 	sts	0x0502, r17
        }

        if(buffer != raw_block)
 566:	8e ef       	ldi	r24, 0xFE	; 254
 568:	48 16       	cp	r4, r24
 56a:	82 e0       	ldi	r24, 0x02	; 2
 56c:	58 06       	cpc	r5, r24
 56e:	71 f0       	breq	.+28     	; 0x58c <sdraw_write+0xd8>
        {
            memcpy(raw_block + block_offset, buffer, write_length);
 570:	9e 01       	movw	r18, r28
 572:	22 50       	subi	r18, 0x02	; 2
 574:	3d 4f       	sbci	r19, 0xFD	; 253
 576:	a6 01       	movw	r20, r12
 578:	b2 01       	movw	r22, r4
 57a:	c9 01       	movw	r24, r18
 57c:	0e 94 0b 05 	call	0xa16	; 0xa16 <memcpy>

            raw_block_written = 0;
 580:	10 92 fe 04 	sts	0x04FE, r1

            if(length == write_length)
 584:	6c 14       	cp	r6, r12
 586:	7d 04       	cpc	r7, r13
 588:	09 f4       	brne	.+2      	; 0x58c <sdraw_write+0xd8>
 58a:	48 c0       	rjmp	.+144    	; 0x61c <sdraw_write+0x168>
                return 1;

        }

        /* address card */
        select_card();
 58c:	80 91 62 00 	lds	r24, 0x0062
 590:	8f 77       	andi	r24, 0x7F	; 127
 592:	80 93 62 00 	sts	0x0062, r24

        /* send single block request */
        if(sdraw_send_command_r1(CMD_WRITE_SINGLE_BLOCK, block_address))
 596:	b8 01       	movw	r22, r16
 598:	a7 01       	movw	r20, r14
 59a:	88 e1       	ldi	r24, 0x18	; 24
 59c:	0e 94 7b 00 	call	0xf6	; 0xf6 <sdraw_send_command_r1>
 5a0:	88 23       	and	r24, r24
 5a2:	31 f0       	breq	.+12     	; 0x5b0 <sdraw_write+0xfc>
        {
            unselect_card();
 5a4:	80 91 62 00 	lds	r24, 0x0062
 5a8:	80 68       	ori	r24, 0x80	; 128
 5aa:	80 93 62 00 	sts	0x0062, r24
 5ae:	34 c0       	rjmp	.+104    	; 0x618 <sdraw_write+0x164>
    return SPI_recv_byte();
}

void sdraw_send_byte(uint8_t data)
{
	SPI_send_byte(data);
 5b0:	8e ef       	ldi	r24, 0xFE	; 254
 5b2:	0e 94 db 03 	call	0x7b6	; 0x7b6 <SPI_send_byte>
 5b6:	ce ef       	ldi	r28, 0xFE	; 254
 5b8:	d2 e0       	ldi	r29, 0x02	; 2
        /* send start byte */
        sdraw_send_byte(0xFE);

        /* write byte block */
        cache = raw_block;
        for(i = 0; i < 512; ++i)
 5ba:	89 91       	ld	r24, Y+
 5bc:	0e 94 db 03 	call	0x7b6	; 0x7b6 <SPI_send_byte>
 5c0:	84 e0       	ldi	r24, 0x04	; 4
 5c2:	ce 3f       	cpi	r28, 0xFE	; 254
 5c4:	d8 07       	cpc	r29, r24
 5c6:	c9 f7       	brne	.-14     	; 0x5ba <sdraw_write+0x106>
    return SPI_recv_byte();
}

void sdraw_send_byte(uint8_t data)
{
	SPI_send_byte(data);
 5c8:	8f ef       	ldi	r24, 0xFF	; 255
 5ca:	0e 94 db 03 	call	0x7b6	; 0x7b6 <SPI_send_byte>
}

uint8_t sdraw_recv_byte()
{
    /* send dummy data for receiving some */
    return SPI_recv_byte();
 5ce:	8f ef       	ldi	r24, 0xFF	; 255
 5d0:	0e 94 db 03 	call	0x7b6	; 0x7b6 <SPI_send_byte>
 5d4:	0e 94 e0 03 	call	0x7c0	; 0x7c0 <SPI_recv_byte>
        /* write dummy crc16 */
        sdraw_send_byte(0xFF);
        sdraw_send_byte(0xFF);

        /* wait while card is busy */
        while(sdraw_recv_byte() != 0xFF);
 5d8:	8f 3f       	cpi	r24, 0xFF	; 255
 5da:	e1 f7       	brne	.-8      	; 0x5d4 <sdraw_write+0x120>
}

uint8_t sdraw_recv_byte()
{
    /* send dummy data for receiving some */
    return SPI_recv_byte();
 5dc:	0e 94 e0 03 	call	0x7c0	; 0x7c0 <SPI_recv_byte>
        /* wait while card is busy */
        while(sdraw_recv_byte() != 0xFF);
        sdraw_recv_byte();

        /* deaddress card */
        unselect_card();
 5e0:	80 91 62 00 	lds	r24, 0x0062
 5e4:	80 68       	ori	r24, 0x80	; 128
 5e6:	80 93 62 00 	sts	0x0062, r24

        buffer += write_length;
 5ea:	4c 0c       	add	r4, r12
 5ec:	5d 1c       	adc	r5, r13
        offset += write_length;
 5ee:	c6 01       	movw	r24, r12
 5f0:	a0 e0       	ldi	r26, 0x00	; 0
 5f2:	b0 e0       	ldi	r27, 0x00	; 0
 5f4:	88 0e       	add	r8, r24
 5f6:	99 1e       	adc	r9, r25
 5f8:	aa 1e       	adc	r10, r26
 5fa:	bb 1e       	adc	r11, r27
        length -= write_length;
 5fc:	6c 18       	sub	r6, r12
 5fe:	7d 08       	sbc	r7, r13

        raw_block_written = 1;
 600:	81 e0       	ldi	r24, 0x01	; 1
 602:	80 93 fe 04 	sts	0x04FE, r24
 606:	03 c0       	rjmp	.+6      	; 0x60e <sdraw_write+0x15a>
    while(length > 0)
    {
        /* determine byte count to write at once */
        block_address = offset & 0xFFFFFE00;
        block_offset = offset & 0x01FF;
        write_length = 512 - block_offset; /* write up to block border */
 608:	21 2c       	mov	r2, r1
 60a:	f2 e0       	ldi	r31, 0x02	; 2
 60c:	3f 2e       	mov	r3, r31
	uint16_t i;

    if(sdraw_card_wp())
        return 0;
    
    while(length > 0)
 60e:	61 14       	cp	r6, r1
 610:	71 04       	cpc	r7, r1
 612:	09 f0       	breq	.+2      	; 0x616 <sdraw_write+0x162>
 614:	68 cf       	rjmp	.-304    	; 0x4e6 <sdraw_write+0x32>
 616:	02 c0       	rjmp	.+4      	; 0x61c <sdraw_write+0x168>
 618:	80 e0       	ldi	r24, 0x00	; 0
 61a:	01 c0       	rjmp	.+2      	; 0x61e <sdraw_write+0x16a>
 61c:	81 e0       	ldi	r24, 0x01	; 1

        raw_block_written = 1;
    }

    return 1;
}
 61e:	df 91       	pop	r29
 620:	cf 91       	pop	r28
 622:	1f 91       	pop	r17
 624:	0f 91       	pop	r16
 626:	ff 90       	pop	r15
 628:	ef 90       	pop	r14
 62a:	df 90       	pop	r13
 62c:	cf 90       	pop	r12
 62e:	bf 90       	pop	r11
 630:	af 90       	pop	r10
 632:	9f 90       	pop	r9
 634:	8f 90       	pop	r8
 636:	7f 90       	pop	r7