Using GCC with the ATMEGA128

As of this writing (July 2002) there is an "experimental" release of GCC for the AVR available on the avrfreaks website that supports the ATMEGA128 and also allows the use of direct I/O register assignment (i.e. PORTA = x, x = PORTA). I have tested this release - it does have bugs, mostly relating to error message generation, but seems to work well otherwise. I would recommend using this version and ignoring the remainder of this document.

The following explanation for using earlier releases is retained in case the newer version is not available to you.

Until an official port of GCC for the 128 comes out, here is how you can be operational without having to use 103 compatibility mode.  I have not tested this exhaustively, but it does work with simple programs and I can use features not available in 103 compatibility mode.

1.  Add this line to your code before the <io.h> include:

#define __AVR_ATmega128__     1

2.  Modify your io-avr.h file by swapping the ATMEGA128 code (two lines) with the ATMEGA103 code.

3.  In your makefile, set MCU = atmega103

4.  In your makefile, add the following, just after the MCU define:

 #added this line for ATMEGA128
 LDFLAGS = -Tavrmega103.x

5.  In your makefile, change the linker flags operator from = to +=.  Here is the code from my file:

#linker flags
 LDFLAGS += -Wl,-Map=$(TRG).map,--cref

6.  In the same directory as your source files, copy the following code to a file named avrmega103.x (modified as noted from 103 to 128):

OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")
OUTPUT_ARCH(avr:5)    /* Modified for ATMEGA128 - Don Carveth */
MEMORY
{
  text   (rx)   : ORIGIN = 0,    LENGTH = 128K
  /* Modified for ATMEGA128 - Don Carveth */
  data   (rw!x) : ORIGIN = 0x800100, LENGTH = 3900
  eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 4K
}
SECTIONS
{
  /* Read-only sections, merged into text segment: */
  .hash          : { *(.hash)  }
  .dynsym        : { *(.dynsym)  }
  .dynstr        : { *(.dynstr)  }
  .gnu.version   : { *(.gnu.version) }
  .gnu.version_d   : { *(.gnu.version_d) }
  .gnu.version_r   : { *(.gnu.version_r) }
  .rel.init      : { *(.rel.init) }
  .rela.init     : { *(.rela.init) }
  .rel.text      :
    {
      *(.rel.text)
      *(.rel.text.*)
      *(.rel.gnu.linkonce.t*)
    }
  .rela.text     :
    {
      *(.rela.text)
      *(.rela.text.*)
      *(.rela.gnu.linkonce.t*)
    }
  .rel.fini      : { *(.rel.fini) }
  .rela.fini     : { *(.rela.fini) }
  .rel.rodata    :
    {
      *(.rel.rodata)
      *(.rel.rodata.*)
      *(.rel.gnu.linkonce.r*)
    }
  .rela.rodata   :
    {
      *(.rela.rodata)
      *(.rela.rodata.*)
      *(.rela.gnu.linkonce.r*)
    }
  .rel.data      :
    {
      *(.rel.data)
      *(.rel.data.*)
      *(.rel.gnu.linkonce.d*)
    }
  .rela.data     :
    {
      *(.rela.data)
      *(.rela.data.*)
      *(.rela.gnu.linkonce.d*)
    }
  .rel.ctors     : { *(.rel.ctors) }
  .rela.ctors    : { *(.rela.ctors) }
  .rel.dtors     : { *(.rel.dtors) }
  .rela.dtors    : { *(.rela.dtors) }
  .rel.got       : { *(.rel.got)  }
  .rela.got      : { *(.rela.got)  }
  .rel.bss       : { *(.rel.bss)  }
  .rela.bss      : { *(.rela.bss)  }
  .rel.plt       : { *(.rel.plt)  }
  .rela.plt      : { *(.rela.plt)  }
  /* Internal text space or external memory */
  .text :
  {
    *(.init)
    *(.progmem.gcc*)
    *(.progmem*)
    . = ALIGN(2);
    *(.text)
    . = ALIGN(2);
    *(.text.*)
    . = ALIGN(2);
    *(.fini)
     _etext = . ;
  }  > text
  .data   : AT (ADDR (.text) + SIZEOF (.text))
  {
     PROVIDE (__data_start = .) ;
    *(.data)
    *(.gnu.linkonce.d*)
    . = ALIGN(2);
     _edata = . ;
  }  > data
  .bss  SIZEOF(.data) + ADDR(.data) :
  {
     PROVIDE (__bss_start = .) ;
    *(.bss)
    *(COMMON)
     PROVIDE (__bss_end = .) ;
     _end = . ;
  }  > data
  .eeprom  :
 AT (ADDR (.text) + SIZEOF (.text) + SIZEOF (.data))
  {
    *(.eeprom*)
     __eeprom_end = . ;
  }  > eeprom
  /* Stabs debugging sections.  */
  .stab 0 : { *(.stab) }
  .stabstr 0 : { *(.stabstr) }
  .stab.excl 0 : { *(.stab.excl) }
  .stab.exclstr 0 : { *(.stab.exclstr) }
  .stab.index 0 : { *(.stab.index) }
  .stab.indexstr 0 : { *(.stab.indexstr) }
  .comment 0 : { *(.comment) }
  /* DWARF debug sections.
     Symbols in the DWARF debugging sections are relative to the beginning
     of the section so we begin them at 0.  */
  /* DWARF 1 */
  .debug          0 : { *(.debug) }
  .line           0 : { *(.line) }
  /* GNU DWARF 1 extensions */
  .debug_srcinfo  0 : { *(.debug_srcinfo) }
  .debug_sfnames  0 : { *(.debug_sfnames) }
  /* DWARF 1.1 and DWARF 2 */
  .debug_aranges  0 : { *(.debug_aranges) }
  .debug_pubnames 0 : { *(.debug_pubnames) }
  /* DWARF 2 */
  .debug_info     0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }
  .debug_abbrev   0 : { *(.debug_abbrev) }
  .debug_line     0 : { *(.debug_line) }
  .debug_frame    0 : { *(.debug_frame) }
  .debug_str      0 : { *(.debug_str) }
  .debug_loc      0 : { *(.debug_loc) }
  .debug_macinfo  0 : { *(.debug_macinfo) }
  PROVIDE (__stack = 0x0FFF) ;
}

Botgoodies Home