AVR Freaks

15 ms is by you forever?

 

After the 15 ms of waiting for the reset, the bus will be released, as all of the tiny's I/O pins go high-impedance immediately.  Reset will likely take in the neighbourhood of 65 ms, depending on clock source and SUT fuses, but as mentioned the bus is already released by then.

 

Since you're using the t85, you must be implementing I2C at least partly in software, since that device lacks a full I2C peripheral.  I would look to your implementation of I2C in your bootloader and compare that to the published standard.

 

I'm also not convinced that this is your problem in the first place, at least not your >>only<< problem.   If you're trying to solve the "after trying again to transmit-flash the application, it writes garbage on the first page of the flash" problem, I would look to your bootloader code.  There's nothing in the hardware which would inherently lead to that problem.  If your first flash page is 'garbage', i'd suggest that you're reloading the temporary buffer page after it has already been (at least partially) loaded with data during the previous (failed) bootload attempt.  The temporary buffer is erased only under certain conditions, including a page write, but not including a page erase, so if the buffer had some data in it before you encountered the I2C error which you then follow by a 'safety flash erase', that erasure is not sufficient for wiping the temporary buffer.  Simply overwriting the temporary buffer with new data is not sufficient.  It must be erased every time, just like a flash page.  You can deliberately clear the temporary buffer simply writing the CTPB bit in SPMCSR to 1.  Are you doing this?

 

I would work to determine exactly what is happening rather than using the blunt-force workaround of a device reset to circumvent what is surely a software bug in your own code.

I have looked at neither your code nor USI_TWI_Slave.c in any depth.  Have you tried calling UsiTwiSlaveInit() when I2C gets crowbarred, instead of resetting via the WDT?  If that doesn't work, then I'd start looking at the I2C library to see how it works, and why calling UsiTwiSlaveInit() leaves the crowbar in place.

Then it sounds like your I2C issue is actually a non-issue.  The only remaining problem is the flash page corruption.  Study <avr/boot.h>.

I do not see using the WDT timeout as a "workaround", but as the prefered way to generate a reset from within software.

It's a workaround because a reset shouldn't be necessary to begin with.  The only reason the OP is resetting the device is to work around the problem of a corrupted first flash page written after an I2C recovery.  I posit that this is due to the temporary page buffer containing previously inserted data.  I proposed the use of the CTPB bit in SPMCSR, but the OP claims to have tried that without success.

 

Another look at the datasheet reveals some conflicting information regarding the CTPB bit.  First:

 

 

... and:

 

 

Those two passages suggest that the only thing necessary to achieve the erasure of the temporary page buffer is the writing of CTPB to 1.  However:

 

 

That passage suggests that one must write CTPB to 1 at the same time that SPMEN is writting to 1, and that one must then execute an SPM instruction after setting CTPB (perhaps within 4 clock cycles, as with other SPM operations).  Although the passage "... will have a special meaning, as described elsewhere." suggests that this may not be so, since no such passage exists for CTPB, it is at least worth a shot I think.  There is, one way or another, a datasheet errata here.  Either clarity on the use of CTPB with SPMEN and the SPM instruction is lacking, or the suggesting that they be used together is incorrect.

 

In any event, I'd propose this instead of your call to wdt_enable().  First define these:

#define BOOT_TEMP_BUFF_ERASE         (_BV(__SPM_ENABLE) | _BV(CTPB))
#define boot_temp_buff_erase()                   \
(__extension__({                                 \
    __asm__ __volatile__                         \
    (                                            \
        "sts %0, %1\n\t"                         \
        "spm\n\t"                                \
        :                                        \
        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
          "r" ((uint8_t)(BOOT_TEMP_BUFF_ERASE))  \
    );                                           \
}))

And then call it:

boot_temp_buff_erase();

I've written the above macros to conform to the format and style used in <avr/boot.h>.

 

Note that you'll then need to handle a restart of your bootloader without relying on an actual device reset.  You could simply use break; to fall through your outer eternal for(;;) loop, and wrap the entire contents of main() in another loop, thereby rerunning your init code.

 

Something like:

#define BOOT_TEMP_BUFF_ERASE         (_BV(__SPM_ENABLE) | _BV(CTPB))
#define boot_temp_buff_erase()                   \
(__extension__({                                 \
    __asm__ __volatile__                         \
    (                                            \
        "sts %0, %1\n\t"                         \
        "spm\n\t"                                \
        :                                        \
        : "i" (_SFR_MEM_ADDR(__SPM_REG)),        \
          "r" ((uint8_t)(BOOT_TEMP_BUFF_ERASE))  \
    );                                           \
}))

// Function Main
int main() {
    /*  ___________________
       |                   |
       |    Restart Loop   |
       |___________________|
    */
    for (;;) {
        /*  ___________________
           |                   |
           |    Setup Block    |
           |___________________|
        */
        MCUSR = 0;                              /* Disable watchdog */
        WDTCR = ((1 << WDCE) | (1 << WDE));
        WDTCR = ((1 << WDP2) | (1 << WDP1) | (1 << WDP0));
        cli();                                  /* Disable Interrupts */
#if ENABLE_LED_UI
        LED_UI_DDR |= (1 << LED_UI_PIN);        /* Set led pin data direction register for output */
#endif
        CLKPR = (1 << CLKPCE);                  /* Set the CPU prescaler for 8 MHz */
        CLKPR = (0x00);
        UsiTwiSlaveInit(I2C_ADDR);              /* Initialize I2C */
        Usi_onReceiverPtr = ReceiveEvent;       /* I2C Receive Event */
        Usi_onRequestPtr = RequestEvent;        /* I2C Request Event */
        statusRegister = (1 << ST_APP_READY);   /* In principle, assume that there is a valid app in memory */
        word dlyCounter = TOGGLETIME;
        byte exitDly = CYCLESTOEXIT;            /* Delay to exit bootloader and run the application if not initialized */
        /*  ___________________
           |                   |
           |     Main Loop     |
           |___________________|
        */
        for (;;) {
            // Initialization check
            if ((statusRegister & ((1 << ST_INIT_1) + (1 << ST_INIT_2))) != \
            ((1 << ST_INIT_1) + (1 << ST_INIT_2))) {
                // ============================================
                // = Blink led until is initialized by master =
                // ============================================
                if (dlyCounter-- <= 0) {
#if ENABLE_LED_UI
                    LED_UI_PORT ^= (1 << LED_UI_PIN);   /* Blinks on each main loop pass at TOGGLETIME intervals */
#endif
                    dlyCounter = TOGGLETIME;
                    if (exitDly-- == 0) {
                        RunApplication();
                    }
                }
            }
            else {
                if (dlyCounter-- <= 0) {                /* Decrease dlyCounter on each main loop pass until it */
                    //                                  /* reaches 0 before running code to allow I2C replies  */
                    // =======================================
                    // = Exit bootloader and run application =
                    // =======================================
                    if ((statusRegister & ((1 << ST_EXIT_TML) + (1 << ST_APP_READY))) == \
                    ((1 << ST_EXIT_TML) + (1 << ST_APP_READY))) {
                        RunApplication();                       /* Launch application */
                    }
                    if ((statusRegister & ((1 << ST_EXIT_TML) + (1 << ST_APP_READY))) == \
                    (1 << ST_EXIT_TML)) {
                        statusRegister |= (1 << ST_DEL_FLASH);  /* Set Erase flash */
                    }
                    // ========================================
                    // = Delete application from flash memory =
                    // ========================================
                    if ((statusRegister & (1 << ST_DEL_FLASH)) == (1 << ST_DEL_FLASH)) {
#if ENABLE_LED_UI
                        LED_UI_PORT |= (1 << LED_UI_PIN);       /* Turn led on to indicate erasing ... */
#endif
                        word pageAddress = TIMONEL_START;       /* Erase flash ... */
                        while (pageAddress != RESET_PAGE) {
                            pageAddress -= PAGE_SIZE;
                            boot_page_erase(pageAddress);
                        }
                        //SPMCSR |= (1 << CTPB);                  /* Clear temporary buffer */
                        //SPMCSR &= ~(1 << CTPB);                 /* Is this necessary? */
                        boot_temp_buff_erase();
                        break;
                    }
                    // ========================================================================
                    // = Write received page to flash memory and prepare to receive a new one =
                    // ========================================================================
                    if ((pageIX == PAGE_SIZE) & (flashPageAddr < TIMONEL_START)) {
#if ENABLE_LED_UI
                        LED_UI_PORT ^= (1 << LED_UI_PIN);   /* Turn led on and off to indicate writing ... */
#endif
                        boot_page_erase(flashPageAddr);
                        boot_page_write(flashPageAddr);
                        word tpl = (((~((TIMONEL_START >> 1) - ((((appResetMSB << 8) | appResetLSB) + 1) & 0x0FFF)) + 1) & 0x0FFF) | 0xC000);
                        if (flashPageAddr == RESET_PAGE) {    /* Calculate and write trampoline */
                            for (int i = 0; i < PAGE_SIZE - 2; i += 2) {
                                boot_page_fill((TIMONEL_START - PAGE_SIZE) + i, 0xffff);
                            }
                            //boot_page_fill((TIMONEL_START - 2), (((~((TIMONEL_START >> 1) - ((((appResetMSB << 8) | appResetLSB) + 1) & 0x0FFF)) + 1) & 0x0FFF) | 0xC000));
                            boot_page_fill((TIMONEL_START - 2), tpl);
                            boot_page_write(TIMONEL_START - PAGE_SIZE);
                        }
                        if ((flashPageAddr) == (TIMONEL_START - PAGE_SIZE)) {
                            /*
                            Read the previous page to the bootloader start  - OK!
                            Write it to the temporary buffer                - OK!
                            Check if the last two bytes are 0xFF            - OK!
                            If yes, then the the application fits in memory, flash the trampoline again - OK!
                            If no, it means that the application is too big, erase it!                  - OK!
                            TODO: Implement ALLOW_USE_TPL_PG (allow use trampoline page).
                            TODO: Implement AUTO_TPL_CALC (auto-trampoline calculation & flash), if it is not
                                  selected, the i2c master has to calculate the trampoline jump and pass it,
                                  maybe with GETTMNLV.
                            TODO: Implement a GETTMNLV reply code that indicates the commands available.
                            */
                            const __flash unsigned char * flashAddr;
                            for (byte i = 0; i < PAGE_SIZE - 2; i += 2) {
                                flashAddr = (void *)((TIMONEL_START - PAGE_SIZE) + i);
                                word pgData = (*flashAddr & 0xFF);
                                pgData += ((*(++flashAddr) & 0xFF) << 8);
                                boot_page_fill((TIMONEL_START - PAGE_SIZE) + i, pgData);
                            }
                            flashAddr = (void *)(TIMONEL_START - 2);
                            word pgData = (*flashAddr & 0xFF);
                            pgData += ((*(++flashAddr) & 0xFF) << 8);
                            if (pgData == 0xFFFF) {
                                boot_page_fill(TIMONEL_START - 2, tpl);
                                boot_page_erase(TIMONEL_START - PAGE_SIZE);
                                boot_page_write(TIMONEL_START - PAGE_SIZE);
                            }
                            else {                                      /* Application too big to fit in memory! */
                                statusRegister |= (1 << ST_DEL_FLASH);  /* Set Erase flash */
                            }
                        }
                        flashPageAddr += PAGE_SIZE;
                        pageIX = 0;
                    }
                    //dlyCounter = I2CDLYTIME;
                }
            }
            /* ..................................................
               . I2C Interrupt Emulation ...................... .
               . Check the USI Status Register to verify        .
               . whether a USI start handler should be launched .
               ..................................................
            */
            if (USISR & (1 << USISIF)) {
                UsiStartHandler();      /* If so, run the USI start handler ... */
                USISR |= (1 << USISIF); /* Reset the USI start flag in USISR register to prepare for new ints */
            }
            /* .....................................................
               . I2C Interrupt Emulation ......................... .
               . Check the USI Status Register to verify           .
               . whether a USI counter overflow should be launched .
               .....................................................
            */
            if (USISR & (1 << USIOIF)) {
                UsiOverflowHandler();   /* If so, run the USI overflow handler ... */
                USISR |= (1 << USIOIF); /* Reset the USI overflow flag in USISR register to prepare for new ints */
            }
        }
    }
    return 0;
}

If this works, then you may want to submit it to the AVR Libc team, and submit a datasheet errata to Atmel.

 

If I have time I'll try a test myself on a t85.  Not sure when I'll have time though...

 

EDIT:  note that a break and an outer for(;;) loop may not be sufficient, as there are variables in .bss and .data which will not get reinitialised that way.  I haven't perused your code to see if this will be a problem.  I expect it will though.  Might be better to do a complete restart of your bootloader with an rjmp or an ijmp or the like, but this will require knowledge of the bootloader's start address.  There are a number of ways to do this.

 

Even that may not be sufficient, as that will still leave SFR registers uninitialised.  Again, I've not perused your code.  You're in a better position to do the analysis.

 

I expect that you've already experimented with non-wdt solutions to 'restarting' your bootloader before you abandoned attempts with CTPB.  I would return to whatever you had in place then, but use the macros I define above to attempt the temp buffer erase.

 

EDIT: extraneous comma removed from macro

That code will work of course, but it forces a pointer into SRAM.  A silly test:

#include <avr/io.h>

#define BOOTLOADER_START 0x1E00

typedef void (* fptr_t)(void);

fptr_t RunApplication = (fptr_t)((BOOTLOADER_START - 2) / 2);

int main(void) {

  RunApplication();
  while (1);

}

$ avr-gcc -Wall -O1 -g -Werror -mmcu=attiny85 foo.c -o foo.elf
$ avr-objdump -S foo.elf

foo.elf:     file format elf32-avr

Disassembly of section .text:

00000000 <__vectors>:
   0:	0e c0       	rjmp	.+28     	; 0x1e <__ctors_end>
   2:	20 c0       	rjmp	.+64     	; 0x44 <__bad_interrupt>
   4:	1f c0       	rjmp	.+62     	; 0x44 <__bad_interrupt>
   6:	1e c0       	rjmp	.+60     	; 0x44 <__bad_interrupt>
   8:	1d c0       	rjmp	.+58     	; 0x44 <__bad_interrupt>
   a:	1c c0       	rjmp	.+56     	; 0x44 <__bad_interrupt>
   c:	1b c0       	rjmp	.+54     	; 0x44 <__bad_interrupt>
   e:	1a c0       	rjmp	.+52     	; 0x44 <__bad_interrupt>
  10:	19 c0       	rjmp	.+50     	; 0x44 <__bad_interrupt>
  12:	18 c0       	rjmp	.+48     	; 0x44 <__bad_interrupt>
  14:	17 c0       	rjmp	.+46     	; 0x44 <__bad_interrupt>
  16:	16 c0       	rjmp	.+44     	; 0x44 <__bad_interrupt>
  18:	15 c0       	rjmp	.+42     	; 0x44 <__bad_interrupt>
  1a:	14 c0       	rjmp	.+40     	; 0x44 <__bad_interrupt>
  1c:	13 c0       	rjmp	.+38     	; 0x44 <__bad_interrupt>

0000001e <__ctors_end>:
  1e:	11 24       	eor	r1, r1
  20:	1f be       	out	0x3f, r1	; 63
  22:	cf e5       	ldi	r28, 0x5F	; 95
  24:	d2 e0       	ldi	r29, 0x02	; 2
  26:	de bf       	out	0x3e, r29	; 62
  28:	cd bf       	out	0x3d, r28	; 61

0000002a <__do_copy_data>:
  2a:	10 e0       	ldi	r17, 0x00	; 0
  2c:	a0 e6       	ldi	r26, 0x60	; 96
  2e:	b0 e0       	ldi	r27, 0x00	; 0
  30:	e6 e5       	ldi	r30, 0x56	; 86
  32:	f0 e0       	ldi	r31, 0x00	; 0
  34:	02 c0       	rjmp	.+4      	; 0x3a <__do_copy_data+0x10>
  36:	05 90       	lpm	r0, Z+
  38:	0d 92       	st	X+, r0
  3a:	a2 36       	cpi	r26, 0x62	; 98
  3c:	b1 07       	cpc	r27, r17
  3e:	d9 f7       	brne	.-10     	; 0x36 <__do_copy_data+0xc>
  40:	02 d0       	rcall	.+4      	; 0x46 <main>
  42:	07 c0       	rjmp	.+14     	; 0x52 <_exit>

00000044 <__bad_interrupt>:
  44:	dd cf       	rjmp	.-70     	; 0x0 <__vectors>

00000046 <main>:

fptr_t RunApplication = (fptr_t)((BOOTLOADER_START - 2) / 2);

int main(void) {

  RunApplication();
  46:	e0 91 60 00 	lds	r30, 0x0060	; 0x800060 <RunApplication>
  4a:	f0 91 61 00 	lds	r31, 0x0061	; 0x800061 <RunApplication+0x1>
  4e:	09 95       	icall
  50:	ff cf       	rjmp	.-2      	; 0x50 <main+0xa>

00000052 <_exit>:
  52:	f8 94       	cli

00000054 <__stop_program>:
  54:	ff cf       	rjmp	.-2      	; 0x54 <__stop_program>

Note how the pointer in SRAM must be initialised at runtime by the CRT, and how two two-word lds instructions are required to load that value into Z before the icall.

 

Making that pointer static allows the compiler to recognise that its value never changes:

static fptr_t RunApplication = (fptr_t)((BOOTLOADER_START - 2) / 2);

... yielding:

foo.elf:     file format elf32-avr

Disassembly of section .text:

00000000 <__vectors>:
   0:	0e c0       	rjmp	.+28     	; 0x1e <__ctors_end>
   2:	15 c0       	rjmp	.+42     	; 0x2e <__bad_interrupt>
   4:	14 c0       	rjmp	.+40     	; 0x2e <__bad_interrupt>
   6:	13 c0       	rjmp	.+38     	; 0x2e <__bad_interrupt>
   8:	12 c0       	rjmp	.+36     	; 0x2e <__bad_interrupt>
   a:	11 c0       	rjmp	.+34     	; 0x2e <__bad_interrupt>
   c:	10 c0       	rjmp	.+32     	; 0x2e <__bad_interrupt>
   e:	0f c0       	rjmp	.+30     	; 0x2e <__bad_interrupt>
  10:	0e c0       	rjmp	.+28     	; 0x2e <__bad_interrupt>
  12:	0d c0       	rjmp	.+26     	; 0x2e <__bad_interrupt>
  14:	0c c0       	rjmp	.+24     	; 0x2e <__bad_interrupt>
  16:	0b c0       	rjmp	.+22     	; 0x2e <__bad_interrupt>
  18:	0a c0       	rjmp	.+20     	; 0x2e <__bad_interrupt>
  1a:	09 c0       	rjmp	.+18     	; 0x2e <__bad_interrupt>
  1c:	08 c0       	rjmp	.+16     	; 0x2e <__bad_interrupt>

0000001e <__ctors_end>:
  1e:	11 24       	eor	r1, r1
  20:	1f be       	out	0x3f, r1	; 63
  22:	cf e5       	ldi	r28, 0x5F	; 95
  24:	d2 e0       	ldi	r29, 0x02	; 2
  26:	de bf       	out	0x3e, r29	; 62
  28:	cd bf       	out	0x3d, r28	; 61
  2a:	02 d0       	rcall	.+4      	; 0x30 <main>
  2c:	05 c0       	rjmp	.+10     	; 0x38 <_exit>

0000002e <__bad_interrupt>:
  2e:	e8 cf       	rjmp	.-48     	; 0x0 <__vectors>

00000030 <main>:

static fptr_t RunApplication = (fptr_t)((BOOTLOADER_START - 2) / 2);

int main(void) {

  RunApplication();
  30:	ef ef       	ldi	r30, 0xFF	; 255
  32:	fe e0       	ldi	r31, 0x0E	; 14
  34:	09 95       	icall
  36:	ff cf       	rjmp	.-2      	; 0x36 <main+0x6>

00000038 <_exit>:
  38:	f8 94       	cli

0000003a <__stop_program>:
  3a:	ff cf       	rjmp	.-2      	; 0x3a <__stop_program>

The two two-word lds instructions have been replaced with two one-word ldi instructions, and there is no longer a pointer in SRAM.  Note also how __do_copy_data is now eliminated, since there are no other initialised variables in static storage.  Additionally (although not shown in the .lss), the two bytes tacked onto the end of the image (constituting the pointer initialisation value copied by __do_copy_data) are eliminated.  Even if __do_copy_data remains due to other still-extant objects in SRAM, using static eliminates 3 words (6 bytes) from flash.

 

For completeness sake, you should also use const to indicate to the compiler that these are in fact unchanging values, but static appears to be sufficient, and the addition of const results in no different behaviour:

typedef void (* const fptr_t)(void);

static const fptr_t RunApplication = (const fptr_t)((BOOTLOADER_START - 2) / 2);

Using const without static is not enough, as that still forces the pointer into SRAM, and __do_copy_data to reappear.

 

I would have thought the compiler could go one better and replace the ldi/ldi/icall with a straight rcall (saving 2/4 more words/bytes), but I haven't been able to elicit that behaviour.