From 6276f405cd19d7ba72f24392121ba7ae6340be05 Mon Sep 17 00:00:00 2001 From: Stelios Tsampas Date: Tue, 24 Jul 2012 03:58:41 +0300 Subject: [PATCH] Changes in the NetEEPROM library. Custom tftp data port setup support. Renamed to Ariadne. Fuck Yeah --- README.md | 75 +- hardware/ariadne/boards.txt | 43 + .../bootloaders/ariadne}/Makefile | 42 +- .../bootloaders/ariadne}/Makefile.previous | 0 .../bootloaders/ariadne}/README.md | 2 +- .../bootloaders/ariadne}/announce.c | 0 .../bootloaders/ariadne}/announce.h | 0 .../bootloaders/ariadne}/app.c | 0 .../bootloaders/ariadne/ariadne_atmega328.hex | 164 ++ .../bootloaders/ariadne/ariadne_atmega328.lst | 2163 ++++++++++++++++ .../ariadne/ariadne_atmega328_ethernet.hex | 164 ++ .../ariadne/ariadne_atmega328_ethernet.lst | 2167 +++++++++++++++++ .../bootloaders/ariadne}/bigapp.c | 0 .../bootloaders/ariadne}/boot.h | 0 .../bootloaders/ariadne}/debug.c | 0 .../bootloaders/ariadne}/debug.h | 0 .../bootloaders/ariadne}/main.c | 0 .../bootloaders/ariadne}/makeall | 7 +- .../bootloaders/ariadne}/net.c | 20 +- .../bootloaders/ariadne}/net.h | 14 +- .../ariadne/bootloaders/ariadne/neteeprom.h | 21 + .../bootloaders/ariadne}/omake | 0 .../bootloaders/ariadne}/omake.bat | 0 .../bootloaders/ariadne}/optiboot.c | 0 .../bootloaders/ariadne}/optiboot.h | 0 .../bootloaders/ariadne}/pin_defs.h | 0 .../bootloaders/ariadne}/serial.c | 0 .../bootloaders/ariadne}/serial.h | 0 .../bootloaders/ariadne}/settings.c | 0 .../bootloaders/ariadne}/stk500.h | 0 .../bootloaders/ariadne}/tftp.c | 4 +- .../bootloaders/ariadne}/tftp.h | 15 +- .../bootloaders/ariadne}/util.c | 0 .../bootloaders/ariadne}/util.h | 0 .../bootloaders/ariadne}/validate.c | 0 .../bootloaders/ariadne}/validate.h | 0 .../bootloaders/ariadne}/w5100_reg.h | 0 .../bootloaders/ariadne}/watchdog.c | 0 .../bootloaders/ariadne}/watchdog.h | 0 .../{tftpboot => ariadne}/programmers.txt | 0 hardware/tftpboot/boards.txt | 43 - .../tftpboot/bootloaders/tftpboot/neteeprom.h | 16 - .../tftpboot/tftpboot_atmega328.hex | 161 -- .../tftpboot/tftpboot_atmega328.lst | 2138 ---------------- .../tftpboot/tftpboot_atmega328_ether.hex | 161 -- .../tftpboot/tftpboot_atmega328_ether.lst | 2142 ---------------- libraries/EthernetReset/EthernetReset.h | 3 + libraries/NetEEPROM/NetEEPROM.cpp | 178 +- libraries/NetEEPROM/NetEEPROM.h | 59 +- libraries/NetEEPROM/NetEEPROM_defs.h | 23 + .../ReadNetworkSettings.ino | 68 +- .../WriteNetworkSettings.ino | 42 +- libraries/NetEEPROM/keywords.txt | 10 + .../tftpboot/utils => utilities}/SConstruct | 0 .../tftpboot/utils => utilities}/callgraph.ps | Bin .../tftpboot/utils => utilities}/net-setup.sh | 2 +- .../tests/blink/blink.bin | Bin .../tests/blink/blink.hex | 0 .../tests/fade/bigapp.bin | Bin .../tests/led_display/led_display.bin | Bin .../tests/led_display/led_display.hex | 0 61 files changed, 5131 insertions(+), 4816 deletions(-) create mode 100755 hardware/ariadne/boards.txt rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/Makefile (94%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/Makefile.previous (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/README.md (99%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/announce.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/announce.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/app.c (100%) create mode 100644 hardware/ariadne/bootloaders/ariadne/ariadne_atmega328.hex create mode 100644 hardware/ariadne/bootloaders/ariadne/ariadne_atmega328.lst create mode 100644 hardware/ariadne/bootloaders/ariadne/ariadne_atmega328_ethernet.hex create mode 100644 hardware/ariadne/bootloaders/ariadne/ariadne_atmega328_ethernet.lst rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/bigapp.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/boot.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/debug.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/debug.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/main.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/makeall (75%) mode change 100644 => 100755 rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/net.c (91%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/net.h (77%) create mode 100644 hardware/ariadne/bootloaders/ariadne/neteeprom.h rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/omake (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/omake.bat (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/optiboot.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/optiboot.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/pin_defs.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/serial.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/serial.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/settings.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/stk500.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/tftp.c (98%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/tftp.h (88%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/util.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/util.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/validate.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/validate.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/w5100_reg.h (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/watchdog.c (100%) rename hardware/{tftpboot/bootloaders/tftpboot => ariadne/bootloaders/ariadne}/watchdog.h (100%) rename hardware/{tftpboot => ariadne}/programmers.txt (100%) delete mode 100755 hardware/tftpboot/boards.txt delete mode 100644 hardware/tftpboot/bootloaders/tftpboot/neteeprom.h delete mode 100644 hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328.hex delete mode 100644 hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328.lst delete mode 100644 hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328_ether.hex delete mode 100644 hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328_ether.lst create mode 100644 libraries/NetEEPROM/NetEEPROM_defs.h create mode 100644 libraries/NetEEPROM/keywords.txt rename {hardware/tftpboot/bootloaders/tftpboot/utils => utilities}/SConstruct (100%) rename {hardware/tftpboot/bootloaders/tftpboot/utils => utilities}/callgraph.ps (100%) rename {hardware/tftpboot/bootloaders/tftpboot/utils => utilities}/net-setup.sh (99%) rename {hardware/tftpboot/bootloaders/tftpboot => utilities}/tests/blink/blink.bin (100%) rename {hardware/tftpboot/bootloaders/tftpboot => utilities}/tests/blink/blink.hex (100%) rename {hardware/tftpboot/bootloaders/tftpboot => utilities}/tests/fade/bigapp.bin (100%) mode change 100755 => 100644 rename {hardware/tftpboot/bootloaders/tftpboot => utilities}/tests/led_display/led_display.bin (100%) rename {hardware/tftpboot/bootloaders/tftpboot => utilities}/tests/led_display/led_display.hex (100%) diff --git a/README.md b/README.md index a0ec8fd..3d3f995 100644 --- a/README.md +++ b/README.md @@ -1,14 +1,73 @@ -TFTP-Bootloader -=================== +Ariadne-Bootloader for Arduino and WizNet W5100 +=============================================== Bootloader for Arduino with Ethernet ------------------------------------ +This is a beta stage bootloader for Arduino Ethernet board and the regular +Arduino with Ethernet Shield. It is based on previous unfinished work by the Arduino +developers. The bootloader implements a TFTP server on the Arduino board and flashing works +using any regular TFTP client. -This is a work-in-progress bootloader for Arduino Ethernet board and the regular -Arduino with Ethernet Shield. -It is based on previous unfinished work by the Arduino developers as the -developer that was hired to write it never finished it. +The files and folders in this repository +---------------------------------------- +The structure of this repository is made to follow the standarts of the Arduino IDE. +This way you can simply copy the folders in your sketchbook and be ready -The bootloader implements a tftp server on the Arduino board and flashing works -using any regular tftp client. +* hardware: This is where the bootloader resides. +* java-client: Demo client for the bootloader. Inherited by the initial project. Untested and probably non-functional +* libraries: Helper libraries to support functions of the bootloader +* utilities: Various stuff used for development and debugging + + +Downloading and installing files +-------------------------------- +First of all, you need to clone or download the repository. To clone the repository +you need to have git installed, then you can run +```git clone https://github.com/codebendercc/Ariadne-Bootloader.git``` +in a directory. +This way you can later update your local repository by running +```git pull``` +inside the **Ariadne-Bootloader** directory. + +In case you want to avoid this hassle, you can use the **ZIP** button at the top of the page +to download the latest snapshot of the repository in a zip archive and extract it. + +After that you have to copy the **hardware** and **libraries** folders inside your sketchbook folder. +Take extra care during coping not to overwrite any other files. Restart the Arduino IDE to load +the new boards and libraries. + + +Burning of the bootloader +------------------------- +To burn the bootloader, you will need an [AVR-ISP](http://www.atmel.com/dyn/products/tools_card.asp?tool_id=2726) +(in-system programmer), [USBtinyISP](http://www.ladyada.net/make/usbtinyisp/) or you can build a +[ParallelProgrammer](http://arduino.cc/en/Hacking/ParallelProgrammer) or an +[ArduinoISP](http://arduino.cc/en/Tutorial/ArduinoISP). +The first three programmers should be connected to the ICSP pins (the 2 by 3 pin header) and make sure you plug +it in the right way. The board must be powered by an external power supply or the USB port. In the case of _ArduinoISP_ +you should consult the above link for further instructions on how to build and use. + +After you have connected the Arduino board and the programmer to your computer launch the Arduino IDE. +Navigate to the __Tools__ > __Board__ menu and select ```Arduino Duemilanove/Uno(ATmega328) w/ Ariadne Bootloader``` +if you have an Arduino Duemilanove or Uno with an Ethernet Shield or ```Arduino Ethernet w/ Ariadne Bootloader``` +for Arduino Ethernet. Then go to __Tools__ > __Programmer__ and select the programmer you are using. +In case you are using _ArduinoISP_, make sure that the selected port in the __Tools__ > __Serial Port__ menu refers to +the _ArduinoISP_ and not the board that you want to burn the bootloader on. Now, just launch the __Tools__ > __Burn Bootloader__ +command and wait for about 15 seconds for the operation to complete. + + +Serial Flashing +--------------- + + +Configuring Network Settings +---------------------------- + + +TFTP Flashing +------------- + + +Configuring your Router for Remote Flashing +------------------------------------------- \ No newline at end of file diff --git a/hardware/ariadne/boards.txt b/hardware/ariadne/boards.txt new file mode 100755 index 0000000..b263369 --- /dev/null +++ b/hardware/ariadne/boards.txt @@ -0,0 +1,43 @@ +############################################################## + +ariadne328.name=Arduino Duemilanove/Uno(ATmega328) w/ Ariadne Bootloader + +ariadne328.upload.protocol=arduino +ariadne328.upload.maximum_size=28672 +ariadne328.upload.speed=115200 + +ariadne328.bootloader.low_fuses=0xFF +ariadne328.bootloader.high_fuses=0xD8 +ariadne328.bootloader.extended_fuses=0x05 +ariadne328.bootloader.path=ariadne +ariadne328.bootloader.file=ariadne_atmega328.hex +ariadne328.bootloader.unlock_bits=0x3F +ariadne328.bootloader.lock_bits=0x2F + +ariadne328.build.mcu=atmega328p +ariadne328.build.f_cpu=16000000L +ariadne328.build.core=arduino:arduino +ariadne328.build.variant=arduino:standard + +############################################################## + +ariadne328eth.name=Arduino Ethernet w/ Ariadne Bootloader + +ariadne328eth.upload.protocol=arduino +ariadne328eth.upload.maximum_size=28672 +ariadne328eth.upload.speed=115200 + +ariadne328eth.bootloader.low_fuses=0xFF +ariadne328eth.bootloader.high_fuses=0xD8 +ariadne328eth.bootloader.extended_fuses=0x05 +ariadne328eth.bootloader.path=ariadne +ariadne328eth.bootloader.file=ariadne_atmega328_ethernet.hex +ariadne328eth.bootloader.unlock_bits=0x3F +ariadne328eth.bootloader.lock_bits=0x2F + +ariadne328eth.build.mcu=atmega328p +ariadne328eth.build.f_cpu=16000000L +ariadne328eth.build.core=arduino:arduino +ariadne328eth.build.variant=arduino:standard + +############################################################## diff --git a/hardware/tftpboot/bootloaders/tftpboot/Makefile b/hardware/ariadne/bootloaders/ariadne/Makefile similarity index 94% rename from hardware/tftpboot/bootloaders/tftpboot/Makefile rename to hardware/ariadne/bootloaders/ariadne/Makefile index d1ffc06..e770b9c 100644 --- a/hardware/tftpboot/bootloaders/tftpboot/Makefile +++ b/hardware/ariadne/bootloaders/ariadne/Makefile @@ -21,7 +21,7 @@ # etc... # program name should not be changed... -PROGRAM = tftpboot +PROGRAM = ariadne # The default behavior is to build using tools that are in the users # current path variables, but we can also build using an installed @@ -35,8 +35,8 @@ PROGRAM = tftpboot # enter the parameters for the avrdude isp tool # for now they default to the arduinoISP on linux -ISPTOOL = stk500v1 -ISPPORT = /dev/ttyACM0 +ISPTOOL = usbtiny +ISPPORT = usb ISPSPEED = -b19200 MCU_TARGET = atmega328p @@ -194,7 +194,7 @@ SIZE = $(GCCROOT)avr-size # # backward compatibility of makefile # atmega168: TARGET = atmega168 # atmega168: MCU_TARGET = atmega168 -# atmega168: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=115200' +# atmega168: CFLAGS += '-DBAUD_RATE=115200' # atmega168: AVR_FREQ = 16000000L # atmega168: $(PROGRAM)_atmega168.hex # atmega168: $(PROGRAM)_atmega168.lst @@ -210,7 +210,7 @@ SIZE = $(GCCROOT)avr-size # # diecimila: TARGET = diecimila # diecimila: MCU_TARGET = atmega168 -# diecimila: CFLAGS += '-DLED_START_FLASHES=3' '-DBAUD_RATE=115200' +# diecimila: CFLAGS += '-DBAUD_RATE=115200' # diecimila: AVR_FREQ = 16000000L # diecimila: $(PROGRAM)_diecimila.hex # diecimila: $(PROGRAM)_diecimila.lst @@ -236,7 +236,7 @@ atmega328: $(PROGRAM)_atmega328.lst atmega328_isp: atmega328 atmega328_isp: TARGET = atmega328 atmega328_isp: MCU_TARGET = atmega328p -# 512 byte boot, SPIEN +# 4096 byte boot, SPIEN atmega328_isp: HFUSE = D8 # Low power xtal (16MHz) 16KCK/14CK+65ms atmega328_isp: LFUSE = FF @@ -244,23 +244,23 @@ atmega328_isp: LFUSE = FF atmega328_isp: EFUSE = 05 atmega328_isp: isp -atmega328_ether: TARGET = atmega328_ether -atmega328_ether: MCU_TARGET = atmega328p -atmega328_ether: CFLAGS += '-D_ARDUINO_ETHERNET' '-DBAUD_RATE=115200' -atmega328_ether: AVR_FREQ = 16000000L -atmega328_ether: LDSECTIONS = -Wl,--section-start=.text=0x7000 -Wl,--section-start=.version=0x7ffe -atmega328_ether: $(PROGRAM)_atmega328_ether.hex -atmega328_ether: $(PROGRAM)_atmega328_ether.lst -atmega328_ether_isp: atmega328_ether -atmega328_ether_isp: TARGET = atmega328_ether -atmega328_ether_isp: MCU_TARGET = atmega328p -# 512 byte boot, SPIEN -atmega328_ether_isp: HFUSE = D8 +atmega328_ethernet: TARGET = atmega328_ethernet +atmega328_ethernet: MCU_TARGET = atmega328p +atmega328_ethernet: CFLAGS += '-D_ARDUINO_ETHERNET' '-DBAUD_RATE=115200' +atmega328_ethernet: AVR_FREQ = 16000000L +atmega328_ethernet: LDSECTIONS = -Wl,--section-start=.text=0x7000 -Wl,--section-start=.version=0x7ffe +atmega328_ethernet: $(PROGRAM)_atmega328_ethernet.hex +atmega328_ethernet: $(PROGRAM)_atmega328_ethernet.lst +atmega328_ethernet_isp: atmega328_ethernet +atmega328_ethernet_isp: TARGET = atmega328_ethernet +atmega328_ethernet_isp: MCU_TARGET = atmega328p +# 4096 byte boot, SPIEN +atmega328_ethernet_isp: HFUSE = D8 # Low power xtal (16MHz) 16KCK/14CK+65ms -atmega328_ether_isp: LFUSE = FF +atmega328_ethernet_isp: LFUSE = FF # 2.7V brownout -atmega328_ether_isp: EFUSE = 05 -atmega328_ether_isp: isp +atmega328_ethernet_isp: EFUSE = 05 +atmega328_ethernet_isp: isp # # Sanguino has a minimum boot size of 1024 bytes, so enable extra functions diff --git a/hardware/tftpboot/bootloaders/tftpboot/Makefile.previous b/hardware/ariadne/bootloaders/ariadne/Makefile.previous similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/Makefile.previous rename to hardware/ariadne/bootloaders/ariadne/Makefile.previous diff --git a/hardware/tftpboot/bootloaders/tftpboot/README.md b/hardware/ariadne/bootloaders/ariadne/README.md similarity index 99% rename from hardware/tftpboot/bootloaders/tftpboot/README.md rename to hardware/ariadne/bootloaders/ariadne/README.md index 16fa1e3..be9d18e 100644 --- a/hardware/tftpboot/bootloaders/tftpboot/README.md +++ b/hardware/ariadne/bootloaders/ariadne/README.md @@ -48,7 +48,7 @@ Uploading firmware manually: 1. Check the target board is powered, and connected to the computer ethernet. 2. Verify the computer network settings: Static IP of 192.168.1.1, Subnet of 255.255.255.0. 3. In a console window: tftp 192.168.1.250 -4. At the tftp> prompt: Make sure the tftp client is in octet mode using the +4. At the tftp> prompt: Make sure the tftp client is in octet mode using the mode octet" command. Here you can also put the "trace" and "verbose" commands for some more output. 5. Push reset button to start the bootloader. The LED will blink rapidly. diff --git a/hardware/tftpboot/bootloaders/tftpboot/announce.c b/hardware/ariadne/bootloaders/ariadne/announce.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/announce.c rename to hardware/ariadne/bootloaders/ariadne/announce.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/announce.h b/hardware/ariadne/bootloaders/ariadne/announce.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/announce.h rename to hardware/ariadne/bootloaders/ariadne/announce.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/app.c b/hardware/ariadne/bootloaders/ariadne/app.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/app.c rename to hardware/ariadne/bootloaders/ariadne/app.c diff --git a/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328.hex b/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328.hex new file mode 100644 index 0000000..b0cfa63 --- /dev/null +++ b/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328.hex @@ -0,0 +1,164 @@ +:1070000050C00000BEC00000BCC00000BAC00000FC +:10701000B8C00000B6C00000B4C00000B2C000009C +:10702000B0C00000AEC00000ACC00000AAC00000AC +:10703000A8C00000A6C00000A4C00000A2C00000BC +:10704000A0C000009EC000009CC000009AC00000CC +:1070500098C0000096C0000094C0000092C00000DC +:1070600090C000008EC000001300050000496E763D +:10707000616C696420696D6167652066696C650093 +:1070800008000500004572726F72000900050003D8 +:1070900046756C6C000A000500004F70636F6465F4 +:1070A0003F0011241FBECFEFD8E0DEBFCDBF11E0FF +:1070B000A0E0B1E0E6EFF9E702C005900D92AC3137 +:1070C000B107D9F711E0ACE1B1E001C01D92AB32DC +:1070D000B107E1F701D08DC405D32FEF85EA9EE01B +:1070E000215080409040E1F700C00000112485E06D +:1070F00080938100FDD39ED095D2EFEFF5EA2EE08C +:10710000E150F0402040E1F700C00000109226015D +:1071100010922701C3E0E12CF12C809126018823F5 +:1071200029F080912701882349F004C097D281116A +:10713000F8CF20C02FD4811105C01AC0CFD3811140 +:10714000F9CF18C080912701813069F4109227018E +:1071500007B600FCFDCFF999FECFF701C7BFE89550 +:1071600014D460D205C082E090E02DD48B3B11F0A6 +:10717000EAD3D3CFE0911C01F0911D01099580E085 +:1071800090E03ECF20E52CBD2A9820EF2EBD0DB417 +:1071900007FEFDCF292F33272EBD0DB407FEFDCFEF +:1071A0008EBD0DB407FEFDCF6EBD0DB407FEFDCF45 +:1071B0002A9A1CBC089520E52CBD2A982FE02EBDEC +:1071C0000DB407FEFDCF292F33272EBD0DB407FECA +:1071D000FDCF8EBD0DB407FEFDCF1EBC0DB407FE66 +:1071E000FDCF2A9A8EB51CBC0895EF92FF92CF93E3 +:1071F0007C01E1DFC82FC7010196DDDF2C2F30E0D5 +:10720000322F2227A901482BCA01CF91FF90EF907E +:107210000895CF92DF92EF92FF927C016B01672F6E +:107220007727B0DF6C2DC7010196FF90EF90DF90BC +:10723000CF90A8CFCF92DF92EF92FF928CE284B9E9 +:107240008CE385B981E08DBD89E797EB90932501AB +:107250008093240180E090E0B6D3853549F581E044 +:1072600090E0B1D38A3A21F5E1E0CE2EE1E0DE2EC6 +:10727000F3E0EF2EF12CC701A6D3F60181936F0145 +:10728000FFEFEF1AFF0A85E1E816F104A1F786E1A6 +:1072900090E099D3F82E85E190E095D32F2D30E042 +:1072A000322F2227280F311D3093250120932401EE +:1072B00060E0C62E61E0D62EE12CF12CF601619142 +:1072C0006F01C7015FDFFFEFEF1AFF0A8CE1E816DD +:1072D000F104A1F7FF90EF90DF90CF900895AF9267 +:1072E000BF92CF92DF92EF92FF92CF93DF93CDB711 +:1072F000DEB7CC50D240DEBFCDBF88E297E075DF6D +:10730000009711F480E098E7EE24E394F12CEC0E62 +:10731000FD1E5E0123EFA21A2DEFB20A6C01EFEF02 +:10732000CE1ADE0A48DFF70181937F01C114F0E82D +:10733000DF0611F0C60102C080E098E7EA14FB0402 +:1073400069F7BC0188E297E064DF60E481E097E0E0 +:1073500019DF81E097E02FDF8111FBCFCC24C394AC +:10736000D12CCC0EDD1E6CE0E62E67E0F62EF60189 +:1073700061916F01C70106DFFFEFEF1AFF0A22E1FB +:10738000E21627E0F20699F7EF802885CB843C854A +:10739000898590E0982F88274A85840F911D833036 +:1073A0009105D9F138F48130910539F0029709F04F +:1073B000A3C005C0069708F09FC080E0A4C06FEF8F +:1073C00082E090E008D360E481E097E0DBDE60E1FA +:1073D00081E097E0D7DE62E080E097E0D3DE61E015 +:1073E00081E097E0CFDE609124017091250184E077 +:1073F00097E00FDF83E097E0DEDE823221F060E18C +:1074000081E097E0BFDE83E097E0D5DE823219F7B6 +:1074100010921F0110921E0175C0D12CDC2CCC24BF +:10742000C30ED11CF12CFE2CEE24E20EF11C84E0E4 +:10743000E81AF108D0921F01C0921E01E1E0CE1AB5 +:10744000D108DC2CCC24DD0CC6018E0D9F1D8130B3 +:10745000904708F053C003C02FEFE21AF20AC701A9 +:107460008F779927892BC1F7C114D10431F4CE014C +:107470000D9624D1882309F443C0DE011D9680E0D7 +:1074800090E041E053E065E071E129C0E1E0F0E027 +:10749000EC0FFD1FE80FF91F258530E0322F222762 +:1074A000EC912E2BF601090147BFE89511240296B5 +:1074B0009C012F773327232B71F4EE57F10957BF27 +:1074C000E89507B600FCFDCF67BFE89507B600FC5E +:1074D000FDCF77BFE8951296F2E0CF0ED11C8E1546 +:1074E0009F05A0F2E11422E0F20660F46BEB82E06B +:1074F00090E071D284E007C081E005C083E003C062 +:1075000085E001C082E0C45FDD4FDEBFCDBFDF910B +:10751000CF91FF90EF90DF90CF90BF90AF90089504 +:10752000AF92BF92CF92DF92EF92FF921F93CF93D1 +:10753000DF93CDB7DEB7C456D109DEBFCDBF7C0126 +:1075400084E297E052DE985A6C0182E0E816F1047A +:1075500079F120F4EA94EF2849F418C083E0E816A2 +:10756000F104E9F0E4E0EE16F10411F14AE050E034 +:1075700060E870E7CE0101961DD28AE0EE24E39424 +:10758000F12CEC0EFD1E182F1E0D2EC04CE050E00D +:1075900065E970E7CE0101960DD28CE0EFCF49E0AE +:1075A00050E06BE870E7CE01019604D289E0E6CFA7 +:1075B000198284E08A8380911E0190911F019B8330 +:1075C0008C8384E0DBCFF70161917F015601FFEFEF +:1075D000AF1ABF0AC601D6DDA11480E6B80619F4B9 +:1075E000A12CE8E5BE2E65011E11EDCFB601785540 +:1075F00084E297E00EDE60E281E097E0C3DD81E0A7 +:1076000097E0D9DD8111FBCFCC59DF4FDEBFCDBF75 +:10761000DF91CF911F91FF90EF90DF90CF90BF90BF +:10762000AF90089565E470E084E097E0F2DD62E0F9 +:1076300080E097E0A7DD61E081E097E0A3DD83E0F3 +:1076400097E0B9DD823221F060E181E097E09ADDD8 +:1076500083E097E0B0DD823229F70895CF9386E288 +:1076600097E0C3DD892B11F481E026C080912701CA +:10767000811101C08AD181E08093270182E097E0E7 +:107680009ADD82FF0EC064E082E097E07BDD2FEFA1 +:1076900087E893E1215080409040E1F700C000006E +:1076A000EDCF1DDEC82F90E03BDFC430E9F660E18E +:1076B00081E097E067DD80E0CF91089520E030E041 +:1076C000FC01E20FF31F40814C3051F441814439F9 +:1076D00039F42C5F3F4F2433310591F781E0089551 +:1076E00080E0089584B714BE98E10FB6F8949093A3 +:1076F0006000109260000FBE0895A8950895E0E61E +:10770000F0E098E190838083089512D1803219F0DF +:1077100088E0F5DFFFCF84E1F8C0CF93C82F08D110 +:10772000C150E9F7CF91F1CFEF92FF92CF93DF9362 +:10773000CDB7DEB7C150D140DEBFCDBFF9D0813467 +:10774000A9F4F6D0CF5FDE4F8883C150D140DDDF92 +:10775000CF5FDE4F8881C150D140823811F483E081 +:1077600003C08138E1F780E0D0D0ACC0823411F49E +:1077700084E103C0853419F484E0CFDFA3C08535EC +:1077800069F4D6D0F82ED4D02F2D30E0382B220F2C +:10779000331F309321012093200193C0863519F4C3 +:1077A00084E0BBDFE0CF843609F05BC0C1D0C0D03D +:1077B00080932801BDD0E0912001F0912101E115D5 +:1077C00080E7F80718F483E087BFE895EE24E39498 +:1077D000F12CEC0EFD1EACD0F70181937F0180915E +:1077E00028018150809328018111F5CFE09120017B +:1077F000F0912101E11580E7F80718F083E087BFD9 +:10780000E89583DF07B600FCFDCF40912001509141 +:107810002101298180E090E061E0A1E0B0E0AC0FBF +:10782000BD1FA80FB91FFC01E40FF51F11967C9135 +:10783000119730E0372B090167BFE89511248E3787 +:10784000910521F012962C910296E7CF85E0FA017E +:1078500087BFE89507B600FCFDCF81E187BFE895BB +:1078600031C08437D1F464D063D08093280160D0D4 +:107870004CDFE0912001F0912101CF01019690931E +:10788000210180932001849140D080912801815072 +:10789000809328018111EDCF15C0853739F435DF8C +:1078A0008EE133D085E931D08FE05ECF813549F468 +:1078B0002CDF6BEB82E090E08ED080E126D080E080 +:1078C00004C023DF80E121D081E0CF5FDE4FDEBF47 +:1078D000CDBFDF91CF91FF90EF9008958091C000D0 +:1078E00087FF04C081E0809326011ECF81E00895C8 +:1078F00082E08093C00088E18093C10086E080939D +:10790000C20080E18093C40008959091C00095FF6B +:10791000FCCF8093C60008958F708A3008F0895F8D +:107920009091C00095FFFCCF805D8093C6000895C4 +:107930008091C00087FFFCCF8091C00084FFDDDE16 +:107940008091C6000895809184009091850092FFF7 +:1079500005C025B130E2232725B901C02D9820911B +:10796000290130912A018217930750F420912201B6 +:10797000309123012F5F3F4F309323012093220149 +:1079800090932A0180932901089510922301109267 +:1079900022010895E0E0F0E085919491019641F094 +:1079A00081E020912201309123012430310508F437 +:1079B00080E00895FB01DC0102C005900D9241506A +:1079C0005040D8F70895F999FECF92BD81BDF89A3D +:1079D000992780B50895262FF999FECF1FBA92BD39 +:1079E00081BD20BD0FB6F894FA9AF99A0FBE0196A0 +:0679F0000895F894FFCF9A +:1079F60080C0A80101FFFFFF00DEADBEEFFEEDC0B7 +:0C7A0600A801800000000007D08055554A +:040000030000700089 +:00000001FF diff --git a/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328.lst b/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328.lst new file mode 100644 index 0000000..5123fbb --- /dev/null +++ b/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328.lst @@ -0,0 +1,2163 @@ + +ariadne_atmega328.elf: file format elf32-avr + +Sections: +Idx Name Size VMA LMA File off Algn + 0 .data 0000001c 00800100 000079f6 00000a8a 2**0 + CONTENTS, ALLOC, LOAD, DATA + 1 .text 000009f6 00007000 00007000 00000094 2**1 + CONTENTS, ALLOC, LOAD, READONLY, CODE + 2 .bss 0000000f 0080011c 0080011c 00000aa6 2**0 + ALLOC + 3 .stab 00002fc4 00000000 00000000 00000aa8 2**2 + CONTENTS, READONLY, DEBUGGING + 4 .stabstr 000010e9 00000000 00000000 00003a6c 2**0 + CONTENTS, READONLY, DEBUGGING + 5 .comment 00000011 00000000 00000000 00004b55 2**0 + CONTENTS, READONLY + +Disassembly of section .text: + +00007000 <__vectors>: + 7000: 50 c0 rjmp .+160 ; 0x70a2 <__ctors_end> + 7002: 00 00 nop + 7004: be c0 rjmp .+380 ; 0x7182 <__bad_interrupt> + 7006: 00 00 nop + 7008: bc c0 rjmp .+376 ; 0x7182 <__bad_interrupt> + 700a: 00 00 nop + 700c: ba c0 rjmp .+372 ; 0x7182 <__bad_interrupt> + 700e: 00 00 nop + 7010: b8 c0 rjmp .+368 ; 0x7182 <__bad_interrupt> + 7012: 00 00 nop + 7014: b6 c0 rjmp .+364 ; 0x7182 <__bad_interrupt> + 7016: 00 00 nop + 7018: b4 c0 rjmp .+360 ; 0x7182 <__bad_interrupt> + 701a: 00 00 nop + 701c: b2 c0 rjmp .+356 ; 0x7182 <__bad_interrupt> + 701e: 00 00 nop + 7020: b0 c0 rjmp .+352 ; 0x7182 <__bad_interrupt> + 7022: 00 00 nop + 7024: ae c0 rjmp .+348 ; 0x7182 <__bad_interrupt> + 7026: 00 00 nop + 7028: ac c0 rjmp .+344 ; 0x7182 <__bad_interrupt> + 702a: 00 00 nop + 702c: aa c0 rjmp .+340 ; 0x7182 <__bad_interrupt> + 702e: 00 00 nop + 7030: a8 c0 rjmp .+336 ; 0x7182 <__bad_interrupt> + 7032: 00 00 nop + 7034: a6 c0 rjmp .+332 ; 0x7182 <__bad_interrupt> + 7036: 00 00 nop + 7038: a4 c0 rjmp .+328 ; 0x7182 <__bad_interrupt> + 703a: 00 00 nop + 703c: a2 c0 rjmp .+324 ; 0x7182 <__bad_interrupt> + 703e: 00 00 nop + 7040: a0 c0 rjmp .+320 ; 0x7182 <__bad_interrupt> + 7042: 00 00 nop + 7044: 9e c0 rjmp .+316 ; 0x7182 <__bad_interrupt> + 7046: 00 00 nop + 7048: 9c c0 rjmp .+312 ; 0x7182 <__bad_interrupt> + 704a: 00 00 nop + 704c: 9a c0 rjmp .+308 ; 0x7182 <__bad_interrupt> + 704e: 00 00 nop + 7050: 98 c0 rjmp .+304 ; 0x7182 <__bad_interrupt> + 7052: 00 00 nop + 7054: 96 c0 rjmp .+300 ; 0x7182 <__bad_interrupt> + 7056: 00 00 nop + 7058: 94 c0 rjmp .+296 ; 0x7182 <__bad_interrupt> + 705a: 00 00 nop + 705c: 92 c0 rjmp .+292 ; 0x7182 <__bad_interrupt> + 705e: 00 00 nop + 7060: 90 c0 rjmp .+288 ; 0x7182 <__bad_interrupt> + 7062: 00 00 nop + 7064: 8e c0 rjmp .+284 ; 0x7182 <__bad_interrupt> + ... + +00007068 : + 7068: 13 00 05 00 00 49 6e 76 61 6c 69 64 20 69 6d 61 .....Invalid ima + 7078: 67 65 20 66 69 6c 65 00 ge file. + +00007080 : + 7080: 08 00 05 00 00 45 72 72 6f 72 00 .....Error. + +0000708b : + 708b: 09 00 05 00 03 46 75 6c 6c 00 .....Full. + +00007095 : + 7095: 0a 00 05 00 00 4f 70 63 6f 64 65 3f 00 .....Opcode?. + +000070a2 <__ctors_end>: + 70a2: 11 24 eor r1, r1 + 70a4: 1f be out 0x3f, r1 ; 63 + 70a6: cf ef ldi r28, 0xFF ; 255 + 70a8: d8 e0 ldi r29, 0x08 ; 8 + 70aa: de bf out 0x3e, r29 ; 62 + 70ac: cd bf out 0x3d, r28 ; 61 + +000070ae <__do_copy_data>: + 70ae: 11 e0 ldi r17, 0x01 ; 1 + 70b0: a0 e0 ldi r26, 0x00 ; 0 + 70b2: b1 e0 ldi r27, 0x01 ; 1 + 70b4: e6 ef ldi r30, 0xF6 ; 246 + 70b6: f9 e7 ldi r31, 0x79 ; 121 + 70b8: 02 c0 rjmp .+4 ; 0x70be <__do_copy_data+0x10> + 70ba: 05 90 lpm r0, Z+ + 70bc: 0d 92 st X+, r0 + 70be: ac 31 cpi r26, 0x1C ; 28 + 70c0: b1 07 cpc r27, r17 + 70c2: d9 f7 brne .-10 ; 0x70ba <__do_copy_data+0xc> + +000070c4 <__do_clear_bss>: + 70c4: 11 e0 ldi r17, 0x01 ; 1 + 70c6: ac e1 ldi r26, 0x1C ; 28 + 70c8: b1 e0 ldi r27, 0x01 ; 1 + 70ca: 01 c0 rjmp .+2 ; 0x70ce <.do_clear_bss_start> + +000070cc <.do_clear_bss_loop>: + 70cc: 1d 92 st X+, r1 + +000070ce <.do_clear_bss_start>: + 70ce: ab 32 cpi r26, 0x2B ; 43 + 70d0: b1 07 cpc r27, r17 + 70d2: e1 f7 brne .-8 ; 0x70cc <.do_clear_bss_loop> + 70d4: 01 d0 rcall .+2 ; 0x70d8
+ 70d6: 8d c4 rjmp .+2330 ; 0x79f2 <_exit> + +000070d8
: + 70d8: 05 d3 rcall .+1546 ; 0x76e4 + 70da: 2f ef ldi r18, 0xFF ; 255 + 70dc: 85 ea ldi r24, 0xA5 ; 165 + 70de: 9e e0 ldi r25, 0x0E ; 14 + 70e0: 21 50 subi r18, 0x01 ; 1 + 70e2: 80 40 sbci r24, 0x00 ; 0 + 70e4: 90 40 sbci r25, 0x00 ; 0 + 70e6: e1 f7 brne .-8 ; 0x70e0 + 70e8: 00 c0 rjmp .+0 ; 0x70ea + 70ea: 00 00 nop + 70ec: 11 24 eor r1, r1 + 70ee: 85 e0 ldi r24, 0x05 ; 5 + 70f0: 80 93 81 00 sts 0x0081, r24 + 70f4: fd d3 rcall .+2042 ; 0x78f0 + 70f6: 9e d0 rcall .+316 ; 0x7234 + 70f8: 95 d2 rcall .+1322 ; 0x7624 + 70fa: ef ef ldi r30, 0xFF ; 255 + 70fc: f5 ea ldi r31, 0xA5 ; 165 + 70fe: 2e e0 ldi r18, 0x0E ; 14 + 7100: e1 50 subi r30, 0x01 ; 1 + 7102: f0 40 sbci r31, 0x00 ; 0 + 7104: 20 40 sbci r18, 0x00 ; 0 + 7106: e1 f7 brne .-8 ; 0x7100 + 7108: 00 c0 rjmp .+0 ; 0x710a + 710a: 00 00 nop + 710c: 10 92 26 01 sts 0x0126, r1 + 7110: 10 92 27 01 sts 0x0127, r1 + 7114: c3 e0 ldi r28, 0x03 ; 3 + 7116: e1 2c mov r14, r1 + 7118: f1 2c mov r15, r1 + 711a: 80 91 26 01 lds r24, 0x0126 + 711e: 88 23 and r24, r24 + 7120: 29 f0 breq .+10 ; 0x712c + 7122: 80 91 27 01 lds r24, 0x0127 + 7126: 88 23 and r24, r24 + 7128: 49 f0 breq .+18 ; 0x713c + 712a: 04 c0 rjmp .+8 ; 0x7134 + 712c: 97 d2 rcall .+1326 ; 0x765c + 712e: 81 11 cpse r24, r1 + 7130: f8 cf rjmp .-16 ; 0x7122 + 7132: 20 c0 rjmp .+64 ; 0x7174 + 7134: 2f d4 rcall .+2142 ; 0x7994 + 7136: 81 11 cpse r24, r1 + 7138: 05 c0 rjmp .+10 ; 0x7144 + 713a: 1a c0 rjmp .+52 ; 0x7170 + 713c: cf d3 rcall .+1950 ; 0x78dc + 713e: 81 11 cpse r24, r1 + 7140: f9 cf rjmp .-14 ; 0x7134 + 7142: 18 c0 rjmp .+48 ; 0x7174 + 7144: 80 91 27 01 lds r24, 0x0127 + 7148: 81 30 cpi r24, 0x01 ; 1 + 714a: 69 f4 brne .+26 ; 0x7166 + 714c: 10 92 27 01 sts 0x0127, r1 + 7150: 07 b6 in r0, 0x37 ; 55 + 7152: 00 fc sbrc r0, 0 + 7154: fd cf rjmp .-6 ; 0x7150 + 7156: f9 99 sbic 0x1f, 1 ; 31 + 7158: fe cf rjmp .-4 ; 0x7156 + 715a: f7 01 movw r30, r14 + 715c: c7 bf out 0x37, r28 ; 55 + 715e: e8 95 spm + 7160: 14 d4 rcall .+2088 ; 0x798a + 7162: 60 d2 rcall .+1216 ; 0x7624 + 7164: 05 c0 rjmp .+10 ; 0x7170 + 7166: 82 e0 ldi r24, 0x02 ; 2 + 7168: 90 e0 ldi r25, 0x00 ; 0 + 716a: 2d d4 rcall .+2138 ; 0x79c6 <__eerd_byte_m328p> + 716c: 8b 3b cpi r24, 0xBB ; 187 + 716e: 11 f0 breq .+4 ; 0x7174 + 7170: ea d3 rcall .+2004 ; 0x7946 + 7172: d3 cf rjmp .-90 ; 0x711a + 7174: e0 91 1c 01 lds r30, 0x011C + 7178: f0 91 1d 01 lds r31, 0x011D + 717c: 09 95 icall + 717e: 80 e0 ldi r24, 0x00 ; 0 + 7180: 90 e0 ldi r25, 0x00 ; 0 + +00007182 <__bad_interrupt>: + 7182: 3e cf rjmp .-388 ; 0x7000 <__vectors> + +00007184 : + trace(", "); + tracenum(value); +#endif + + // Send uint8_t to Ethernet controller + SPCR = _BV(SPE) | _BV(MSTR); // Set SPI as master + 7184: 20 e5 ldi r18, 0x50 ; 80 + 7186: 2c bd out 0x2c, r18 ; 44 + SS_LOW(); + 7188: 2a 98 cbi 0x05, 2 ; 5 + SPDR = SPI_WRITE; + 718a: 20 ef ldi r18, 0xF0 ; 240 + 718c: 2e bd out 0x2e, r18 ; 46 + while(!(SPSR & _BV(SPIF))); + 718e: 0d b4 in r0, 0x2d ; 45 + 7190: 07 fe sbrs r0, 7 + 7192: fd cf rjmp .-6 ; 0x718e + SPDR = address >> 8; + 7194: 29 2f mov r18, r25 + 7196: 33 27 eor r19, r19 + 7198: 2e bd out 0x2e, r18 ; 46 + while(!(SPSR & _BV(SPIF))); + 719a: 0d b4 in r0, 0x2d ; 45 + 719c: 07 fe sbrs r0, 7 + 719e: fd cf rjmp .-6 ; 0x719a + SPDR = address & 0xff; + 71a0: 8e bd out 0x2e, r24 ; 46 + while(!(SPSR & _BV(SPIF))); + 71a2: 0d b4 in r0, 0x2d ; 45 + 71a4: 07 fe sbrs r0, 7 + 71a6: fd cf rjmp .-6 ; 0x71a2 + SPDR = value; + 71a8: 6e bd out 0x2e, r22 ; 46 + while(!(SPSR & _BV(SPIF))); + 71aa: 0d b4 in r0, 0x2d ; 45 + 71ac: 07 fe sbrs r0, 7 + 71ae: fd cf rjmp .-6 ; 0x71aa + SS_HIGH(); + 71b0: 2a 9a sbi 0x05, 2 ; 5 + SPCR = 0; // Turn off SPI + 71b2: 1c bc out 0x2c, r1 ; 44 + 71b4: 08 95 ret + +000071b6 : +// tracenum(address); +//#endif + + // Read uint8_t from Ethernet controller + uint8_t returnValue; + SPCR = _BV(SPE) | _BV(MSTR); + 71b6: 20 e5 ldi r18, 0x50 ; 80 + 71b8: 2c bd out 0x2c, r18 ; 44 + SS_LOW(); + 71ba: 2a 98 cbi 0x05, 2 ; 5 + SPDR = SPI_READ; + 71bc: 2f e0 ldi r18, 0x0F ; 15 + 71be: 2e bd out 0x2e, r18 ; 46 + while(!(SPSR & _BV(SPIF))); + 71c0: 0d b4 in r0, 0x2d ; 45 + 71c2: 07 fe sbrs r0, 7 + 71c4: fd cf rjmp .-6 ; 0x71c0 + SPDR = address >> 8; + 71c6: 29 2f mov r18, r25 + 71c8: 33 27 eor r19, r19 + 71ca: 2e bd out 0x2e, r18 ; 46 + while(!(SPSR & _BV(SPIF))); + 71cc: 0d b4 in r0, 0x2d ; 45 + 71ce: 07 fe sbrs r0, 7 + 71d0: fd cf rjmp .-6 ; 0x71cc + SPDR = address & 0xff; + 71d2: 8e bd out 0x2e, r24 ; 46 + while(!(SPSR & _BV(SPIF))); + 71d4: 0d b4 in r0, 0x2d ; 45 + 71d6: 07 fe sbrs r0, 7 + 71d8: fd cf rjmp .-6 ; 0x71d4 + SPDR = 0; + 71da: 1e bc out 0x2e, r1 ; 46 + while(!(SPSR & _BV(SPIF))); + 71dc: 0d b4 in r0, 0x2d ; 45 + 71de: 07 fe sbrs r0, 7 + 71e0: fd cf rjmp .-6 ; 0x71dc + SS_HIGH(); + 71e2: 2a 9a sbi 0x05, 2 ; 5 + returnValue = SPDR; + 71e4: 8e b5 in r24, 0x2e ; 46 + SPCR = 0; + 71e6: 1c bc out 0x2c, r1 ; 44 + return(returnValue); +} + 71e8: 08 95 ret + +000071ea : + +uint16_t netReadWord(uint16_t address) +{ + 71ea: ef 92 push r14 + 71ec: ff 92 push r15 + 71ee: cf 93 push r28 + 71f0: 7c 01 movw r14, r24 + // Read uint16_t from Ethernet controller + return((netReadReg(address) << 8) | netReadReg(address + 1)); + 71f2: e1 df rcall .-62 ; 0x71b6 + 71f4: c8 2f mov r28, r24 + 71f6: c7 01 movw r24, r14 + 71f8: 01 96 adiw r24, 0x01 ; 1 + 71fa: dd df rcall .-70 ; 0x71b6 + 71fc: 2c 2f mov r18, r28 + 71fe: 30 e0 ldi r19, 0x00 ; 0 + 7200: 32 2f mov r19, r18 + 7202: 22 27 eor r18, r18 +} + 7204: a9 01 movw r20, r18 + 7206: 48 2b or r20, r24 + 7208: ca 01 movw r24, r20 + 720a: cf 91 pop r28 + 720c: ff 90 pop r15 + 720e: ef 90 pop r14 + 7210: 08 95 ret + +00007212 : + +void netWriteWord(uint16_t address, uint16_t value) +{ + 7212: cf 92 push r12 + 7214: df 92 push r13 + 7216: ef 92 push r14 + 7218: ff 92 push r15 + 721a: 7c 01 movw r14, r24 + 721c: 6b 01 movw r12, r22 + // Write uint16_t to Ethernet controller + netWriteReg(address++, value >> 8); + 721e: 67 2f mov r22, r23 + 7220: 77 27 eor r23, r23 + 7222: b0 df rcall .-160 ; 0x7184 + netWriteReg(address, value & 0xff); + 7224: 6c 2d mov r22, r12 + 7226: c7 01 movw r24, r14 + 7228: 01 96 adiw r24, 0x01 ; 1 +} + 722a: ff 90 pop r15 + 722c: ef 90 pop r14 + 722e: df 90 pop r13 + 7230: cf 90 pop r12 + +void netWriteWord(uint16_t address, uint16_t value) +{ + // Write uint16_t to Ethernet controller + netWriteReg(address++, value >> 8); + netWriteReg(address, value & 0xff); + 7232: a8 cf rjmp .-176 ; 0x7184 + +00007234 : +} + +void netInit() +{ + 7234: cf 92 push r12 + 7236: df 92 push r13 + 7238: ef 92 push r14 + 723a: ff 92 push r15 + uint8_t i; + + // Set up outputs to communicate with W5100 chip + // Set pins as output + DDRB = _BV(SCK) | _BV(MOSI) | _BV(SS); + 723c: 8c e2 ldi r24, 0x2C ; 44 + 723e: 84 b9 out 0x04, r24 ; 4 + // Set pins high + PORTB = _BV(SCK) | _BV(MISO) | _BV(MOSI) | _BV(SS); + 7240: 8c e3 ldi r24, 0x3C ; 60 + 7242: 85 b9 out 0x05, r24 ; 5 + PORTB |= _BV(LED); +#endif + + // Set up SPI + // Set the Double SPI Speed Bit + SPSR = (1 << SPI2X); + 7244: 81 e0 ldi r24, 0x01 ; 1 + 7246: 8d bd out 0x2d, r24 ; 45 + +#ifndef _TFTP_RANDOM_PORT + tftpPort = TFTP_STATIC_PORT; + 7248: 89 e7 ldi r24, 0x79 ; 121 + 724a: 97 eb ldi r25, 0xB7 ; 183 + 724c: 90 93 25 01 sts 0x0125, r25 + 7250: 80 93 24 01 sts 0x0124, r24 +#endif + /* Pull in altered presets + * if available from AVR EEPROM (if signature bytes are set)*/ + if((eeprom_read_byte(EEPROM_SIG_1) == EEPROM_SIG_1_VALUE) + 7254: 80 e0 ldi r24, 0x00 ; 0 + 7256: 90 e0 ldi r25, 0x00 ; 0 + 7258: b6 d3 rcall .+1900 ; 0x79c6 <__eerd_byte_m328p> + 725a: 85 35 cpi r24, 0x55 ; 85 + 725c: 49 f5 brne .+82 ; 0x72b0 + && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { + 725e: 81 e0 ldi r24, 0x01 ; 1 + 7260: 90 e0 ldi r25, 0x00 ; 0 + 7262: b1 d3 rcall .+1890 ; 0x79c6 <__eerd_byte_m328p> + 7264: 8a 3a cpi r24, 0xAA ; 170 + 7266: 21 f5 brne .+72 ; 0x72b0 + 7268: e1 e0 ldi r30, 0x01 ; 1 + 726a: ce 2e mov r12, r30 + 726c: e1 e0 ldi r30, 0x01 ; 1 + 726e: de 2e mov r13, r30 + 7270: f3 e0 ldi r31, 0x03 ; 3 + 7272: ef 2e mov r14, r31 + 7274: f1 2c mov r15, r1 + + for(i = 0; i < EEPROM_SETTINGS_SIZE; i++) + registerBuffer[i+1] = eeprom_read_byte(EEPROM_DATA+i); + 7276: c7 01 movw r24, r14 + 7278: a6 d3 rcall .+1868 ; 0x79c6 <__eerd_byte_m328p> + 727a: f6 01 movw r30, r12 + 727c: 81 93 st Z+, r24 + 727e: 6f 01 movw r12, r30 + 7280: ff ef ldi r31, 0xFF ; 255 + 7282: ef 1a sub r14, r31 + 7284: ff 0a sbc r15, r31 + /* Pull in altered presets + * if available from AVR EEPROM (if signature bytes are set)*/ + if((eeprom_read_byte(EEPROM_SIG_1) == EEPROM_SIG_1_VALUE) + && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { + + for(i = 0; i < EEPROM_SETTINGS_SIZE; i++) + 7286: 85 e1 ldi r24, 0x15 ; 21 + 7288: e8 16 cp r14, r24 + 728a: f1 04 cpc r15, r1 + 728c: a1 f7 brne .-24 ; 0x7276 + registerBuffer[i+1] = eeprom_read_byte(EEPROM_DATA+i); +#ifndef _TFTP_RANDOM_PORT + tftpPort = ((eeprom_read_byte(EEPROM_PORT+1)<<8) + eeprom_read_byte(EEPROM_PORT)); + 728e: 86 e1 ldi r24, 0x16 ; 22 + 7290: 90 e0 ldi r25, 0x00 ; 0 + 7292: 99 d3 rcall .+1842 ; 0x79c6 <__eerd_byte_m328p> + 7294: f8 2e mov r15, r24 + 7296: 85 e1 ldi r24, 0x15 ; 21 + 7298: 90 e0 ldi r25, 0x00 ; 0 + 729a: 95 d3 rcall .+1834 ; 0x79c6 <__eerd_byte_m328p> + 729c: 2f 2d mov r18, r15 + 729e: 30 e0 ldi r19, 0x00 ; 0 + 72a0: 32 2f mov r19, r18 + 72a2: 22 27 eor r18, r18 + 72a4: 28 0f add r18, r24 + 72a6: 31 1d adc r19, r1 + 72a8: 30 93 25 01 sts 0x0125, r19 + 72ac: 20 93 24 01 sts 0x0124, r18 + 72b0: 60 e0 ldi r22, 0x00 ; 0 + 72b2: c6 2e mov r12, r22 + 72b4: 61 e0 ldi r22, 0x01 ; 1 + 72b6: d6 2e mov r13, r22 + tftpPort = TFTP_STATIC_PORT; +#endif + /* Pull in altered presets + * if available from AVR EEPROM (if signature bytes are set)*/ + if((eeprom_read_byte(EEPROM_SIG_1) == EEPROM_SIG_1_VALUE) + && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { + 72b8: e1 2c mov r14, r1 + 72ba: f1 2c mov r15, r1 +#endif +#endif + + // Configure Wiznet chip + for(i = 0; i < REGISTER_BLOCK_SIZE; i++) + netWriteReg(i, registerBuffer[i]); + 72bc: f6 01 movw r30, r12 + 72be: 61 91 ld r22, Z+ + 72c0: 6f 01 movw r12, r30 + 72c2: c7 01 movw r24, r14 + 72c4: 5f df rcall .-322 ; 0x7184 + 72c6: ff ef ldi r31, 0xFF ; 255 + 72c8: ef 1a sub r14, r31 + 72ca: ff 0a sbc r15, r31 + tracenum(tftpPort); +#endif +#endif + + // Configure Wiznet chip + for(i = 0; i < REGISTER_BLOCK_SIZE; i++) + 72cc: 8c e1 ldi r24, 0x1C ; 28 + 72ce: e8 16 cp r14, r24 + 72d0: f1 04 cpc r15, r1 + 72d2: a1 f7 brne .-24 ; 0x72bc + netWriteReg(i, registerBuffer[i]); +#ifdef _VERBOSE + traceln(" Net: Network init done"); +#endif +} + 72d4: ff 90 pop r15 + 72d6: ef 90 pop r14 + 72d8: df 90 pop r13 + 72da: cf 90 pop r12 + 72dc: 08 95 ret + +000072de : +#ifdef _DEBUG_TFTP +uint8_t processPacket(uint16_t packetSize) +{ +#else +uint8_t processPacket() +{ + 72de: af 92 push r10 + 72e0: bf 92 push r11 + 72e2: cf 92 push r12 + 72e4: df 92 push r13 + 72e6: ef 92 push r14 + 72e8: ff 92 push r15 + 72ea: cf 93 push r28 + 72ec: df 93 push r29 + 72ee: cd b7 in r28, 0x3d ; 61 + 72f0: de b7 in r29, 0x3e ; 62 + 72f2: cc 50 subi r28, 0x0C ; 12 + 72f4: d2 40 sbci r29, 0x02 ; 2 + 72f6: de bf out 0x3e, r29 ; 62 + 72f8: cd bf out 0x3d, r28 ; 61 + tracenum(packetSize); + if(packetSize >= 0x800) traceln("Tftp: Overflow"); + // step(); +#endif + + readPointer = netReadWord(REG_S3_RX_RD0); + 72fa: 88 e2 ldi r24, 0x28 ; 40 + 72fc: 97 e0 ldi r25, 0x07 ; 7 + 72fe: 75 df rcall .-278 ; 0x71ea +#ifdef _DEBUG_TFTP + traceln("Tftp: readPointer at position "); + tracenum(readPointer); +#endif + if(readPointer == 0) readPointer += S3_RX_START; + 7300: 00 97 sbiw r24, 0x00 ; 0 + 7302: 11 f4 brne .+4 ; 0x7308 + 7304: 80 e0 ldi r24, 0x00 ; 0 + 7306: 98 e7 ldi r25, 0x78 ; 120 + 7308: ee 24 eor r14, r14 + 730a: e3 94 inc r14 + 730c: f1 2c mov r15, r1 + 730e: ec 0e add r14, r28 + 7310: fd 1e adc r15, r29 + +#ifdef _DEBUG_TFTP +uint8_t processPacket(uint16_t packetSize) +{ +#else +uint8_t processPacket() + 7312: 5e 01 movw r10, r28 + 7314: 23 ef ldi r18, 0xF3 ; 243 + 7316: a2 1a sub r10, r18 + 7318: 2d ef ldi r18, 0xFD ; 253 + 731a: b2 0a sbc r11, r18 + if((count == TFTP_PACKET_MAX_SIZE - 1) || (count == 0)) { + traceln("Tftp: Reading from position "); + tracenum(readPointer); + } +#endif + *bufPtr++ = netReadReg(readPointer++); + 731c: 6c 01 movw r12, r24 + 731e: ef ef ldi r30, 0xFF ; 255 + 7320: ce 1a sub r12, r30 + 7322: de 0a sbc r13, r30 + 7324: 48 df rcall .-368 ; 0x71b6 + 7326: f7 01 movw r30, r14 + 7328: 81 93 st Z+, r24 + 732a: 7f 01 movw r14, r30 + if(readPointer == S3_RX_END) readPointer = S3_RX_START; + 732c: c1 14 cp r12, r1 + 732e: f0 e8 ldi r31, 0x80 ; 128 + 7330: df 06 cpc r13, r31 + 7332: 11 f0 breq .+4 ; 0x7338 + 7334: c6 01 movw r24, r12 + 7336: 02 c0 rjmp .+4 ; 0x733c + 7338: 80 e0 ldi r24, 0x00 ; 0 + 733a: 98 e7 ldi r25, 0x78 ; 120 +#ifdef _DEBUG_TFTP + traceln("Tftp: readPointer at position "); + tracenum(readPointer); +#endif + if(readPointer == 0) readPointer += S3_RX_START; + for(count = TFTP_PACKET_MAX_SIZE; count--;) { + 733c: ea 14 cp r14, r10 + 733e: fb 04 cpc r15, r11 + 7340: 69 f7 brne .-38 ; 0x731c + } +#endif + *bufPtr++ = netReadReg(readPointer++); + if(readPointer == S3_RX_END) readPointer = S3_RX_START; + } + netWriteWord(REG_S3_RX_RD0, readPointer); // Write back new pointer + 7342: bc 01 movw r22, r24 + 7344: 88 e2 ldi r24, 0x28 ; 40 + 7346: 97 e0 ldi r25, 0x07 ; 7 + 7348: 64 df rcall .-312 ; 0x7212 + netWriteReg(REG_S3_CR, CR_RECV); + 734a: 60 e4 ldi r22, 0x40 ; 64 + 734c: 81 e0 ldi r24, 0x01 ; 1 + 734e: 97 e0 ldi r25, 0x07 ; 7 + 7350: 19 df rcall .-462 ; 0x7184 + while(netReadReg(REG_S3_CR)); + 7352: 81 e0 ldi r24, 0x01 ; 1 + 7354: 97 e0 ldi r25, 0x07 ; 7 + 7356: 2f df rcall .-418 ; 0x71b6 + 7358: 81 11 cpse r24, r1 + 735a: fb cf rjmp .-10 ; 0x7352 + 735c: cc 24 eor r12, r12 + 735e: c3 94 inc r12 + 7360: d1 2c mov r13, r1 + 7362: cc 0e add r12, r28 + 7364: dd 1e adc r13, r29 + 7366: 6c e0 ldi r22, 0x0C ; 12 + 7368: e6 2e mov r14, r22 + 736a: 67 e0 ldi r22, 0x07 ; 7 + 736c: f6 2e mov r15, r22 + traceln("Tftp: Setting return address"); +#endif + + // Set up return IP address and port + uint8_t i; + for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); + 736e: f6 01 movw r30, r12 + 7370: 61 91 ld r22, Z+ + 7372: 6f 01 movw r12, r30 + 7374: c7 01 movw r24, r14 + 7376: 06 df rcall .-500 ; 0x7184 + 7378: ff ef ldi r31, 0xFF ; 255 + 737a: ef 1a sub r14, r31 + 737c: ff 0a sbc r15, r31 + 737e: 22 e1 ldi r18, 0x12 ; 18 + 7380: e2 16 cp r14, r18 + 7382: 27 e0 ldi r18, 0x07 ; 7 + 7384: f2 06 cpc r15, r18 + 7386: 99 f7 brne .-26 ; 0x736e + + // Parse packet + uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; + 7388: ef 80 ldd r14, Y+7 ; 0x07 + 738a: 28 85 ldd r18, Y+8 ; 0x08 + uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; + uint16_t tftpBlock = (buffer[10] << 8) + buffer[11]; + 738c: cb 84 ldd r12, Y+11 ; 0x0b + 738e: 3c 85 ldd r19, Y+12 ; 0x0c + uint8_t i; + for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); + + // Parse packet + uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; + uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; + 7390: 89 85 ldd r24, Y+9 ; 0x09 + 7392: 90 e0 ldi r25, 0x00 ; 0 + 7394: 98 2f mov r25, r24 + 7396: 88 27 eor r24, r24 + 7398: 4a 85 ldd r20, Y+10 ; 0x0a + 739a: 84 0f add r24, r20 + 739c: 91 1d adc r25, r1 + + uint8_t returnCode = ERROR_UNKNOWN; + uint16_t packetLength; + + + switch(tftpOpcode) { + 739e: 83 30 cpi r24, 0x03 ; 3 + 73a0: 91 05 cpc r25, r1 + 73a2: d9 f1 breq .+118 ; 0x741a + 73a4: 38 f4 brcc .+14 ; 0x73b4 + 73a6: 81 30 cpi r24, 0x01 ; 1 + 73a8: 91 05 cpc r25, r1 + 73aa: 39 f0 breq .+14 ; 0x73ba + 73ac: 02 97 sbiw r24, 0x02 ; 2 + 73ae: 09 f0 breq .+2 ; 0x73b2 + 73b0: a3 c0 rjmp .+326 ; 0x74f8 + 73b2: 05 c0 rjmp .+10 ; 0x73be + 73b4: 06 97 sbiw r24, 0x06 ; 6 + 73b6: 08 f0 brcs .+2 ; 0x73ba + 73b8: 9f c0 rjmp .+318 ; 0x74f8 + tracenum(tftpOpcode); + trace(" and data length "); + tracenum(tftpDataLen - (TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE)); +#endif + + uint8_t returnCode = ERROR_UNKNOWN; + 73ba: 80 e0 ldi r24, 0x00 ; 0 + 73bc: a4 c0 rjmp .+328 ; 0x7506 + case TFTP_OPCODE_WRQ: // Write request +#ifdef _VERBOSE + traceln("Tftp: Write request"); +#endif + // Flagging image as invalid since the flashing process has started + eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_BAD_VALUE); + 73be: 6f ef ldi r22, 0xFF ; 255 + 73c0: 82 e0 ldi r24, 0x02 ; 2 + 73c2: 90 e0 ldi r25, 0x00 ; 0 + 73c4: 08 d3 rcall .+1552 ; 0x79d6 <__eewr_byte_m328p> + netWriteReg(REG_S3_CR, CR_RECV); + 73c6: 60 e4 ldi r22, 0x40 ; 64 + 73c8: 81 e0 ldi r24, 0x01 ; 1 + 73ca: 97 e0 ldi r25, 0x07 ; 7 + 73cc: db de rcall .-586 ; 0x7184 + netWriteReg(REG_S3_CR, CR_CLOSE); + 73ce: 60 e1 ldi r22, 0x10 ; 16 + 73d0: 81 e0 ldi r24, 0x01 ; 1 + 73d2: 97 e0 ldi r25, 0x07 ; 7 + 73d4: d7 de rcall .-594 ; 0x7184 + do { + netWriteReg(REG_S3_MR, MR_UDP); + 73d6: 62 e0 ldi r22, 0x02 ; 2 + 73d8: 80 e0 ldi r24, 0x00 ; 0 + 73da: 97 e0 ldi r25, 0x07 ; 7 + 73dc: d3 de rcall .-602 ; 0x7184 + netWriteReg(REG_S3_CR, CR_OPEN); + 73de: 61 e0 ldi r22, 0x01 ; 1 + 73e0: 81 e0 ldi r24, 0x01 ; 1 + 73e2: 97 e0 ldi r25, 0x07 ; 7 + 73e4: cf de rcall .-610 ; 0x7184 +#ifdef _TFTP_RANDOM_PORT + netWriteWord(REG_S3_PORT0, (buffer[4]<<8) | ~buffer[5]); // Generate a 'random' TID (RFC1350) +#else + netWriteWord(REG_S3_PORT0, tftpPort); + 73e6: 60 91 24 01 lds r22, 0x0124 + 73ea: 70 91 25 01 lds r23, 0x0125 + 73ee: 84 e0 ldi r24, 0x04 ; 4 + 73f0: 97 e0 ldi r25, 0x07 ; 7 + 73f2: 0f df rcall .-482 ; 0x7212 +#endif + if(netReadReg(REG_S3_SR) != SOCK_UDP) + 73f4: 83 e0 ldi r24, 0x03 ; 3 + 73f6: 97 e0 ldi r25, 0x07 ; 7 + 73f8: de de rcall .-580 ; 0x71b6 + 73fa: 82 32 cpi r24, 0x22 ; 34 + 73fc: 21 f0 breq .+8 ; 0x7406 + netWriteReg(REG_S3_CR, CR_CLOSE); + 73fe: 60 e1 ldi r22, 0x10 ; 16 + 7400: 81 e0 ldi r24, 0x01 ; 1 + 7402: 97 e0 ldi r25, 0x07 ; 7 + 7404: bf de rcall .-642 ; 0x7184 + } while(netReadReg(REG_S3_SR) != SOCK_UDP); + 7406: 83 e0 ldi r24, 0x03 ; 3 + 7408: 97 e0 ldi r25, 0x07 ; 7 + 740a: d5 de rcall .-598 ; 0x71b6 + 740c: 82 32 cpi r24, 0x22 ; 34 + 740e: 19 f7 brne .-58 ; 0x73d6 + tracenum((buffer[4]<<8) | (buffer[5]^0x55)); +#else + tracenum(tftpPort); +#endif +#endif + lastPacket = 0; + 7410: 10 92 1f 01 sts 0x011F, r1 + 7414: 10 92 1e 01 sts 0x011E, r1 + 7418: 75 c0 rjmp .+234 ; 0x7504 + for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); + + // Parse packet + uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; + uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; + uint16_t tftpBlock = (buffer[10] << 8) + buffer[11]; + 741a: d1 2c mov r13, r1 + 741c: dc 2c mov r13, r12 + 741e: cc 24 eor r12, r12 + 7420: c3 0e add r12, r19 + 7422: d1 1c adc r13, r1 + // Set up return IP address and port + uint8_t i; + for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); + + // Parse packet + uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; + 7424: f1 2c mov r15, r1 + 7426: fe 2c mov r15, r14 + 7428: ee 24 eor r14, r14 + 742a: e2 0e add r14, r18 + 742c: f1 1c adc r15, r1 + lastPacket = 0; + returnCode = ACK; // Send back acknowledge for packet 0 + break; + + case TFTP_OPCODE_DATA: + packetLength = tftpDataLen - (TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); + 742e: 84 e0 ldi r24, 0x04 ; 4 + 7430: e8 1a sub r14, r24 + 7432: f1 08 sbc r15, r1 + lastPacket = tftpBlock; + 7434: d0 92 1f 01 sts 0x011F, r13 + 7438: c0 92 1e 01 sts 0x011E, r12 + writeAddr = (tftpBlock - 1) << 9; // Flash write address for this block + 743c: e1 e0 ldi r30, 0x01 ; 1 + 743e: ce 1a sub r12, r30 + 7440: d1 08 sbc r13, r1 + 7442: dc 2c mov r13, r12 + 7444: cc 24 eor r12, r12 + 7446: dd 0c add r13, r13 +#ifdef _VERBOSE + traceln("Tftp: Data for block "); + tracenum(lastPacket); +#endif + + if((writeAddr + packetLength) > MAX_ADDR) { + 7448: c6 01 movw r24, r12 + 744a: 8e 0d add r24, r14 + 744c: 9f 1d adc r25, r15 + 744e: 81 30 cpi r24, 0x01 ; 1 + 7450: 90 47 sbci r25, 0x70 ; 112 + 7452: 08 f0 brcs .+2 ; 0x7456 + 7454: 53 c0 rjmp .+166 ; 0x74fc + 7456: 03 c0 rjmp .+6 ; 0x745e + + uint8_t *pageBase = buffer + (UDP_HEADER_SIZE + TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); // Start of block data + uint16_t offset = 0; // Block offset + + // Round up packet length to a full flash sector size + while(packetLength % SPM_PAGESIZE) packetLength++; + 7458: 2f ef ldi r18, 0xFF ; 255 + 745a: e2 1a sub r14, r18 + 745c: f2 0a sbc r15, r18 + 745e: c7 01 movw r24, r14 + 7460: 8f 77 andi r24, 0x7F ; 127 + 7462: 99 27 eor r25, r25 + 7464: 89 2b or r24, r25 + 7466: c1 f7 brne .-16 ; 0x7458 +#ifdef _DEBUG_TFTP + traceln("Tftp: Packet length adjusted to "); + tracenum(packetLength); +#endif + if(writeAddr == 0) { + 7468: c1 14 cp r12, r1 + 746a: d1 04 cpc r13, r1 + 746c: 31 f4 brne .+12 ; 0x747a + // First sector - validate + if(!validImage(pageBase)) { + 746e: ce 01 movw r24, r28 + 7470: 0d 96 adiw r24, 0x0d ; 13 + 7472: 24 d1 rcall .+584 ; 0x76bc + 7474: 88 23 and r24, r24 + 7476: 09 f4 brne .+2 ; 0x747a + 7478: 43 c0 rjmp .+134 ; 0x7500 +#ifdef _DEBUG_TFTP + traceln("Tftp: Writing data from address "); + tracenum(writeAddr); +#endif + + uint8_t *pageBase = buffer + (UDP_HEADER_SIZE + TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); // Start of block data + 747a: de 01 movw r26, r28 + 747c: 1d 96 adiw r26, 0x0d ; 13 +#endif + } + } + + // Flash packets + for(offset = 0; offset < packetLength;) { + 747e: 80 e0 ldi r24, 0x00 ; 0 + 7480: 90 e0 ldi r25, 0x00 ; 0 + uint16_t writeValue = (pageBase[offset]) | (pageBase[offset + 1] << 8); + boot_page_fill(writeAddr + offset, writeValue); + 7482: 41 e0 ldi r20, 0x01 ; 1 + tracenum(writeAddr + offset); + } +#endif + offset += 2; + if(offset % SPM_PAGESIZE == 0) { + boot_page_erase(writeAddr + offset - SPM_PAGESIZE); + 7484: 53 e0 ldi r21, 0x03 ; 3 + boot_spm_busy_wait(); + boot_page_write(writeAddr + offset - SPM_PAGESIZE); + 7486: 65 e0 ldi r22, 0x05 ; 5 + boot_spm_busy_wait(); + boot_rww_enable(); + 7488: 71 e1 ldi r23, 0x11 ; 17 +#endif + } + } + + // Flash packets + for(offset = 0; offset < packetLength;) { + 748a: 29 c0 rjmp .+82 ; 0x74de + +#ifdef _DEBUG_TFTP +uint8_t processPacket(uint16_t packetSize) +{ +#else +uint8_t processPacket() + 748c: e1 e0 ldi r30, 0x01 ; 1 + 748e: f0 e0 ldi r31, 0x00 ; 0 + 7490: ec 0f add r30, r28 + 7492: fd 1f adc r31, r29 + 7494: e8 0f add r30, r24 + 7496: f9 1f adc r31, r25 + } + } + + // Flash packets + for(offset = 0; offset < packetLength;) { + uint16_t writeValue = (pageBase[offset]) | (pageBase[offset + 1] << 8); + 7498: 25 85 ldd r18, Z+13 ; 0x0d + 749a: 30 e0 ldi r19, 0x00 ; 0 + 749c: 32 2f mov r19, r18 + 749e: 22 27 eor r18, r18 + 74a0: ec 91 ld r30, X + 74a2: 2e 2b or r18, r30 + boot_page_fill(writeAddr + offset, writeValue); + 74a4: f6 01 movw r30, r12 + 74a6: 09 01 movw r0, r18 + 74a8: 47 bf out 0x37, r20 ; 55 + 74aa: e8 95 spm + 74ac: 11 24 eor r1, r1 + tracenum(writeValue); + trace(" at offset "); + tracenum(writeAddr + offset); + } +#endif + offset += 2; + 74ae: 02 96 adiw r24, 0x02 ; 2 + if(offset % SPM_PAGESIZE == 0) { + 74b0: 9c 01 movw r18, r24 + 74b2: 2f 77 andi r18, 0x7F ; 127 + 74b4: 33 27 eor r19, r19 + 74b6: 23 2b or r18, r19 + 74b8: 71 f4 brne .+28 ; 0x74d6 + boot_page_erase(writeAddr + offset - SPM_PAGESIZE); + 74ba: ee 57 subi r30, 0x7E ; 126 + 74bc: f1 09 sbc r31, r1 + 74be: 57 bf out 0x37, r21 ; 55 + 74c0: e8 95 spm + boot_spm_busy_wait(); + 74c2: 07 b6 in r0, 0x37 ; 55 + 74c4: 00 fc sbrc r0, 0 + 74c6: fd cf rjmp .-6 ; 0x74c2 + boot_page_write(writeAddr + offset - SPM_PAGESIZE); + 74c8: 67 bf out 0x37, r22 ; 55 + 74ca: e8 95 spm + boot_spm_busy_wait(); + 74cc: 07 b6 in r0, 0x37 ; 55 + 74ce: 00 fc sbrc r0, 0 + 74d0: fd cf rjmp .-6 ; 0x74cc + boot_rww_enable(); + 74d2: 77 bf out 0x37, r23 ; 55 + 74d4: e8 95 spm + 74d6: 12 96 adiw r26, 0x02 ; 2 + 74d8: f2 e0 ldi r31, 0x02 ; 2 + 74da: cf 0e add r12, r31 + 74dc: d1 1c adc r13, r1 +#endif + } + } + + // Flash packets + for(offset = 0; offset < packetLength;) { + 74de: 8e 15 cp r24, r14 + 74e0: 9f 05 cpc r25, r15 + 74e2: a0 f2 brcs .-88 ; 0x748c + boot_spm_busy_wait(); + boot_rww_enable(); + } + } + + if(packetLength < TFTP_DATA_SIZE) { + 74e4: e1 14 cp r14, r1 + 74e6: 22 e0 ldi r18, 0x02 ; 2 + 74e8: f2 06 cpc r15, r18 + 74ea: 60 f4 brcc .+24 ; 0x7504 + // Hand over to application +#ifdef _VERBOSE + traceln("Tftp: Flash is complete"); +#endif + // Flag the image as valid since we received the last packet + eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); + 74ec: 6b eb ldi r22, 0xBB ; 187 + 74ee: 82 e0 ldi r24, 0x02 ; 2 + 74f0: 90 e0 ldi r25, 0x00 ; 0 + 74f2: 71 d2 rcall .+1250 ; 0x79d6 <__eewr_byte_m328p> + returnCode = FINAL_ACK; + 74f4: 84 e0 ldi r24, 0x04 ; 4 + 74f6: 07 c0 rjmp .+14 ; 0x7506 +#ifdef _DEBUG_TFTP + traceln("Tftp: Invalid opcode "); + tracenum(tftpOpcode); +#endif + // Invalid - return error + returnCode = ERROR_INVALID; + 74f8: 81 e0 ldi r24, 0x01 ; 1 + 74fa: 05 c0 rjmp .+10 ; 0x7506 + // Flash is full - abort with an error before a bootloader overwrite occurs + // Application is now corrupt, so do not hand over. +#ifdef _VERBOSE + traceln("Tftp: Flash is full"); +#endif + returnCode = ERROR_FULL; + 74fc: 83 e0 ldi r24, 0x03 ; 3 + 74fe: 03 c0 rjmp .+6 ; 0x7506 + tracenum(packetLength); +#endif + if(writeAddr == 0) { + // First sector - validate + if(!validImage(pageBase)) { + returnCode = INVALID_IMAGE; + 7500: 85 e0 ldi r24, 0x05 ; 5 + 7502: 01 c0 rjmp .+2 ; 0x7506 +#endif + // Flag the image as valid since we received the last packet + eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); + returnCode = FINAL_ACK; + } else { + returnCode = ACK; + 7504: 82 e0 ldi r24, 0x02 ; 2 + returnCode = ERROR_INVALID; + break; + + } + return(returnCode); +} + 7506: c4 5f subi r28, 0xF4 ; 244 + 7508: dd 4f sbci r29, 0xFD ; 253 + 750a: de bf out 0x3e, r29 ; 62 + 750c: cd bf out 0x3d, r28 ; 61 + 750e: df 91 pop r29 + 7510: cf 91 pop r28 + 7512: ff 90 pop r15 + 7514: ef 90 pop r14 + 7516: df 90 pop r13 + 7518: cf 90 pop r12 + 751a: bf 90 pop r11 + 751c: af 90 pop r10 + 751e: 08 95 ret + +00007520 : + + +void sendResponse(uint16_t response) +{ + 7520: af 92 push r10 + 7522: bf 92 push r11 + 7524: cf 92 push r12 + 7526: df 92 push r13 + 7528: ef 92 push r14 + 752a: ff 92 push r15 + 752c: 1f 93 push r17 + 752e: cf 93 push r28 + 7530: df 93 push r29 + 7532: cd b7 in r28, 0x3d ; 61 + 7534: de b7 in r29, 0x3e ; 62 + 7536: c4 56 subi r28, 0x64 ; 100 + 7538: d1 09 sbc r29, r1 + 753a: de bf out 0x3e, r29 ; 62 + 753c: cd bf out 0x3d, r28 ; 61 + 753e: 7c 01 movw r14, r24 + uint8_t txBuffer[100]; + uint8_t *txPtr = txBuffer; + uint8_t packetLength; + uint16_t writePointer; + + writePointer = netReadWord(REG_S3_TX_WR0) + S3_TX_START; + 7540: 84 e2 ldi r24, 0x24 ; 36 + 7542: 97 e0 ldi r25, 0x07 ; 7 + 7544: 52 de rcall .-860 ; 0x71ea + 7546: 98 5a subi r25, 0xA8 ; 168 + 7548: 6c 01 movw r12, r24 + switch(response) { + 754a: 82 e0 ldi r24, 0x02 ; 2 + 754c: e8 16 cp r14, r24 + 754e: f1 04 cpc r15, r1 + 7550: 79 f1 breq .+94 ; 0x75b0 + 7552: 20 f4 brcc .+8 ; 0x755c + 7554: ea 94 dec r14 + 7556: ef 28 or r14, r15 + 7558: 49 f4 brne .+18 ; 0x756c + 755a: 18 c0 rjmp .+48 ; 0x758c + 755c: 83 e0 ldi r24, 0x03 ; 3 + 755e: e8 16 cp r14, r24 + 7560: f1 04 cpc r15, r1 + 7562: e9 f0 breq .+58 ; 0x759e + 7564: e4 e0 ldi r30, 0x04 ; 4 + 7566: ee 16 cp r14, r30 + 7568: f1 04 cpc r15, r1 + 756a: 11 f1 breq .+68 ; 0x75b0 + default: + + case ERROR_UNKNOWN: + // Send unknown error packet + packetLength = TFTP_UNKNOWN_ERROR_LEN; + memcpy_P(txBuffer, tftp_unknown_error_packet, packetLength); + 756c: 4a e0 ldi r20, 0x0A ; 10 + 756e: 50 e0 ldi r21, 0x00 ; 0 + 7570: 60 e8 ldi r22, 0x80 ; 128 + 7572: 70 e7 ldi r23, 0x70 ; 112 + 7574: ce 01 movw r24, r28 + 7576: 01 96 adiw r24, 0x01 ; 1 + 7578: 1d d2 rcall .+1082 ; 0x79b4 + switch(response) { + default: + + case ERROR_UNKNOWN: + // Send unknown error packet + packetLength = TFTP_UNKNOWN_ERROR_LEN; + 757a: 8a e0 ldi r24, 0x0A ; 10 + } + + txPtr = txBuffer; + while(packetLength--) { + netWriteReg(writePointer++, *txPtr++); + if(writePointer == S3_TX_END) writePointer = S3_TX_START; + 757c: ee 24 eor r14, r14 + 757e: e3 94 inc r14 + 7580: f1 2c mov r15, r1 + 7582: ec 0e add r14, r28 + 7584: fd 1e adc r15, r29 + } + return(returnCode); +} + + +void sendResponse(uint16_t response) + 7586: 18 2f mov r17, r24 + 7588: 1e 0d add r17, r14 + 758a: 2e c0 rjmp .+92 ; 0x75e8 + break; + + case ERROR_INVALID: + // Send invalid opcode packet + packetLength = TFTP_OPCODE_ERROR_LEN; + memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); + 758c: 4c e0 ldi r20, 0x0C ; 12 + 758e: 50 e0 ldi r21, 0x00 ; 0 + 7590: 65 e9 ldi r22, 0x95 ; 149 + 7592: 70 e7 ldi r23, 0x70 ; 112 + 7594: ce 01 movw r24, r28 + 7596: 01 96 adiw r24, 0x01 ; 1 + 7598: 0d d2 rcall .+1050 ; 0x79b4 + memcpy_P(txBuffer, tftp_unknown_error_packet, packetLength); + break; + + case ERROR_INVALID: + // Send invalid opcode packet + packetLength = TFTP_OPCODE_ERROR_LEN; + 759a: 8c e0 ldi r24, 0x0C ; 12 + memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); + break; + 759c: ef cf rjmp .-34 ; 0x757c + + case ERROR_FULL: + // Send unknown error packet + packetLength = TFTP_FULL_ERROR_LEN; + memcpy_P(txBuffer, tftp_full_error_packet, packetLength); + 759e: 49 e0 ldi r20, 0x09 ; 9 + 75a0: 50 e0 ldi r21, 0x00 ; 0 + 75a2: 6b e8 ldi r22, 0x8B ; 139 + 75a4: 70 e7 ldi r23, 0x70 ; 112 + 75a6: ce 01 movw r24, r28 + 75a8: 01 96 adiw r24, 0x01 ; 1 + 75aa: 04 d2 rcall .+1032 ; 0x79b4 + memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); + break; + + case ERROR_FULL: + // Send unknown error packet + packetLength = TFTP_FULL_ERROR_LEN; + 75ac: 89 e0 ldi r24, 0x09 ; 9 + memcpy_P(txBuffer, tftp_full_error_packet, packetLength); + break; + 75ae: e6 cf rjmp .-52 ; 0x757c + traceln("Tftp: Sent Final ACK "); + tracenum(lastPacket); + } +#endif + packetLength = 4; + *txPtr++ = TFTP_OPCODE_ACK >> 8; + 75b0: 19 82 std Y+1, r1 ; 0x01 + *txPtr++ = TFTP_OPCODE_ACK & 0xff; + 75b2: 84 e0 ldi r24, 0x04 ; 4 + 75b4: 8a 83 std Y+2, r24 ; 0x02 + // lastPacket is block code + *txPtr++ = lastPacket >> 8; + 75b6: 80 91 1e 01 lds r24, 0x011E + 75ba: 90 91 1f 01 lds r25, 0x011F + 75be: 9b 83 std Y+3, r25 ; 0x03 + *txPtr = lastPacket & 0xff; + 75c0: 8c 83 std Y+4, r24 ; 0x04 + if(response == FINAL_ACK) { + traceln("Tftp: Sent Final ACK "); + tracenum(lastPacket); + } +#endif + packetLength = 4; + 75c2: 84 e0 ldi r24, 0x04 ; 4 + *txPtr++ = TFTP_OPCODE_ACK >> 8; + *txPtr++ = TFTP_OPCODE_ACK & 0xff; + // lastPacket is block code + *txPtr++ = lastPacket >> 8; + *txPtr = lastPacket & 0xff; + break; + 75c4: db cf rjmp .-74 ; 0x757c + } + + txPtr = txBuffer; + while(packetLength--) { + netWriteReg(writePointer++, *txPtr++); + 75c6: f7 01 movw r30, r14 + 75c8: 61 91 ld r22, Z+ + 75ca: 7f 01 movw r14, r30 + 75cc: 56 01 movw r10, r12 + 75ce: ff ef ldi r31, 0xFF ; 255 + 75d0: af 1a sub r10, r31 + 75d2: bf 0a sbc r11, r31 + 75d4: c6 01 movw r24, r12 + 75d6: d6 dd rcall .-1108 ; 0x7184 + if(writePointer == S3_TX_END) writePointer = S3_TX_START; + 75d8: a1 14 cp r10, r1 + 75da: 80 e6 ldi r24, 0x60 ; 96 + 75dc: b8 06 cpc r11, r24 + 75de: 19 f4 brne .+6 ; 0x75e6 + 75e0: a1 2c mov r10, r1 + 75e2: e8 e5 ldi r30, 0x58 ; 88 + 75e4: be 2e mov r11, r30 + 75e6: 65 01 movw r12, r10 + *txPtr = lastPacket & 0xff; + break; + } + + txPtr = txBuffer; + while(packetLength--) { + 75e8: 1e 11 cpse r17, r14 + 75ea: ed cf rjmp .-38 ; 0x75c6 + netWriteReg(writePointer++, *txPtr++); + if(writePointer == S3_TX_END) writePointer = S3_TX_START; + } + netWriteWord(REG_S3_TX_WR0, writePointer - S3_TX_START); + 75ec: b6 01 movw r22, r12 + 75ee: 78 55 subi r23, 0x58 ; 88 + 75f0: 84 e2 ldi r24, 0x24 ; 36 + 75f2: 97 e0 ldi r25, 0x07 ; 7 + 75f4: 0e de rcall .-996 ; 0x7212 + netWriteReg(REG_S3_CR, CR_SEND); + 75f6: 60 e2 ldi r22, 0x20 ; 32 + 75f8: 81 e0 ldi r24, 0x01 ; 1 + 75fa: 97 e0 ldi r25, 0x07 ; 7 + 75fc: c3 dd rcall .-1146 ; 0x7184 + while(netReadReg(REG_S3_CR)); + 75fe: 81 e0 ldi r24, 0x01 ; 1 + 7600: 97 e0 ldi r25, 0x07 ; 7 + 7602: d9 dd rcall .-1102 ; 0x71b6 + 7604: 81 11 cpse r24, r1 + 7606: fb cf rjmp .-10 ; 0x75fe +#ifdef _VERBOSE + traceln("Tftp: Response sent"); +#endif +} + 7608: cc 59 subi r28, 0x9C ; 156 + 760a: df 4f sbci r29, 0xFF ; 255 + 760c: de bf out 0x3e, r29 ; 62 + 760e: cd bf out 0x3d, r28 ; 61 + 7610: df 91 pop r29 + 7612: cf 91 pop r28 + 7614: 1f 91 pop r17 + 7616: ff 90 pop r15 + 7618: ef 90 pop r14 + 761a: df 90 pop r13 + 761c: cf 90 pop r12 + 761e: bf 90 pop r11 + 7620: af 90 pop r10 + 7622: 08 95 ret + +00007624 : +void tftpInit() +{ + // Open socket + do { + // Write TFTP Port + netWriteWord(REG_S3_PORT0, TFTP_PORT); + 7624: 65 e4 ldi r22, 0x45 ; 69 + 7626: 70 e0 ldi r23, 0x00 ; 0 + 7628: 84 e0 ldi r24, 0x04 ; 4 + 762a: 97 e0 ldi r25, 0x07 ; 7 + 762c: f2 dd rcall .-1052 ; 0x7212 + // Write mode + netWriteReg(REG_S3_MR, MR_UDP); + 762e: 62 e0 ldi r22, 0x02 ; 2 + 7630: 80 e0 ldi r24, 0x00 ; 0 + 7632: 97 e0 ldi r25, 0x07 ; 7 + 7634: a7 dd rcall .-1202 ; 0x7184 + // Open Socket + netWriteReg(REG_S3_CR, CR_OPEN); + 7636: 61 e0 ldi r22, 0x01 ; 1 + 7638: 81 e0 ldi r24, 0x01 ; 1 + 763a: 97 e0 ldi r25, 0x07 ; 7 + 763c: a3 dd rcall .-1210 ; 0x7184 + // Read Status + if(netReadReg(REG_S3_SR) != SOCK_UDP) + 763e: 83 e0 ldi r24, 0x03 ; 3 + 7640: 97 e0 ldi r25, 0x07 ; 7 + 7642: b9 dd rcall .-1166 ; 0x71b6 + 7644: 82 32 cpi r24, 0x22 ; 34 + 7646: 21 f0 breq .+8 ; 0x7650 + // Close Socket if it wasn't initialized correctly + netWriteReg(REG_S3_CR, CR_CLOSE); + 7648: 60 e1 ldi r22, 0x10 ; 16 + 764a: 81 e0 ldi r24, 0x01 ; 1 + 764c: 97 e0 ldi r25, 0x07 ; 7 + 764e: 9a dd rcall .-1228 ; 0x7184 + // If socket correctly opened continue + } while(netReadReg(REG_S3_SR) != SOCK_UDP); + 7650: 83 e0 ldi r24, 0x03 ; 3 + 7652: 97 e0 ldi r25, 0x07 ; 7 + 7654: b0 dd rcall .-1184 ; 0x71b6 + 7656: 82 32 cpi r24, 0x22 ; 34 + 7658: 29 f7 brne .-54 ; 0x7624 +#ifdef _VERBOSE + traceln("Tftp: TFTP server init done"); +#endif +} + 765a: 08 95 ret + +0000765c : + +/** + * Looks for a connection + */ +uint8_t tftpPoll() +{ + 765c: cf 93 push r28 + uint8_t response = ACK; + // Get the size of the recieved data + uint16_t packetSize = netReadWord(REG_S3_RX_RSR0); + 765e: 86 e2 ldi r24, 0x26 ; 38 + 7660: 97 e0 ldi r25, 0x07 ; 7 + 7662: c3 dd rcall .-1146 ; 0x71ea + + if(packetSize) { + 7664: 89 2b or r24, r25 + 7666: 11 f4 brne .+4 ; 0x766c + netWriteReg(REG_S3_CR, CR_CLOSE); + // Complete + return(0); + } + // Tftp continues + return(1); + 7668: 81 e0 ldi r24, 0x01 ; 1 + 766a: 26 c0 rjmp .+76 ; 0x76b8 + uint8_t response = ACK; + // Get the size of the recieved data + uint16_t packetSize = netReadWord(REG_S3_RX_RSR0); + + if(packetSize) { + if(!tftpFlashing) resetTick(); + 766c: 80 91 27 01 lds r24, 0x0127 + 7670: 81 11 cpse r24, r1 + 7672: 01 c0 rjmp .+2 ; 0x7676 + 7674: 8a d1 rcall .+788 ; 0x798a + tftpFlashing = TRUE; + 7676: 81 e0 ldi r24, 0x01 ; 1 + 7678: 80 93 27 01 sts 0x0127, r24 + + for(;;) { + if(!(netReadReg(REG_S3_IR) & IR_RECV)) break; + 767c: 82 e0 ldi r24, 0x02 ; 2 + 767e: 97 e0 ldi r25, 0x07 ; 7 + 7680: 9a dd rcall .-1228 ; 0x71b6 + 7682: 82 ff sbrs r24, 2 + 7684: 0e c0 rjmp .+28 ; 0x76a2 + + netWriteReg(REG_S3_IR, IR_RECV); + 7686: 64 e0 ldi r22, 0x04 ; 4 + 7688: 82 e0 ldi r24, 0x02 ; 2 + 768a: 97 e0 ldi r25, 0x07 ; 7 + 768c: 7b dd rcall .-1290 ; 0x7184 + #else + //round up by default + __ticks_dc = (uint32_t)(ceil(fabs(__tmp))); + #endif + + __builtin_avr_delay_cycles(__ticks_dc); + 768e: 2f ef ldi r18, 0xFF ; 255 + 7690: 87 e8 ldi r24, 0x87 ; 135 + 7692: 93 e1 ldi r25, 0x13 ; 19 + 7694: 21 50 subi r18, 0x01 ; 1 + 7696: 80 40 sbci r24, 0x00 ; 0 + 7698: 90 40 sbci r25, 0x00 ; 0 + 769a: e1 f7 brne .-8 ; 0x7694 + 769c: 00 c0 rjmp .+0 ; 0x769e + 769e: 00 00 nop + 76a0: ed cf rjmp .-38 ; 0x767c + } + // Process Packet and get TFTP response code +#ifdef _DEBUG_TFTP + response = processPacket(packetSize); +#else + response = processPacket(); + 76a2: 1d de rcall .-966 ; 0x72de + 76a4: c8 2f mov r28, r24 +#endif + // Send the response + sendResponse(response); + 76a6: 90 e0 ldi r25, 0x00 ; 0 + 76a8: 3b df rcall .-394 ; 0x7520 + } + if(response==FINAL_ACK) { + 76aa: c4 30 cpi r28, 0x04 ; 4 + 76ac: e9 f6 brne .-70 ; 0x7668 + netWriteReg(REG_S3_CR, CR_CLOSE); + 76ae: 60 e1 ldi r22, 0x10 ; 16 + 76b0: 81 e0 ldi r24, 0x01 ; 1 + 76b2: 97 e0 ldi r25, 0x07 ; 7 + 76b4: 67 dd rcall .-1330 ; 0x7184 + // Complete + return(0); + 76b6: 80 e0 ldi r24, 0x00 ; 0 + } + // Tftp continues + return(1); +} + 76b8: cf 91 pop r28 + 76ba: 08 95 ret + +000076bc : +#include "debug.h" +#include "serial.h" + + +uint8_t validImage(uint8_t *base) +{ + 76bc: 20 e0 ldi r18, 0x00 ; 0 + 76be: 30 e0 ldi r19, 0x00 ; 0 +#include "validate.h" +#include "debug.h" +#include "serial.h" + + +uint8_t validImage(uint8_t *base) + 76c0: fc 01 movw r30, r24 + 76c2: e2 0f add r30, r18 + 76c4: f3 1f adc r31, r19 + /* Check that a jump table is present in the first flash sector */ + uint8_t i; + for(i = 0; i < 0x34; i += 4) { + // For each vector, check it is of the form: + // 0x0C 0x94 0xWX 0xYZ ; JMP 0xWXYZ + if(base[i] != 0x0c) { + 76c6: 40 81 ld r20, Z + 76c8: 4c 30 cpi r20, 0x0C ; 12 + 76ca: 51 f4 brne .+20 ; 0x76e0 + tracenum(base[i]); + trace(" instead of 0x0C"); +#endif + return(0); + } + if(base[i + 1] != 0x94) { + 76cc: 41 81 ldd r20, Z+1 ; 0x01 + 76ce: 44 39 cpi r20, 0x94 ; 148 + 76d0: 39 f4 brne .+14 ; 0x76e0 + 76d2: 2c 5f subi r18, 0xFC ; 252 + 76d4: 3f 4f sbci r19, 0xFF ; 255 + +uint8_t validImage(uint8_t *base) +{ + /* Check that a jump table is present in the first flash sector */ + uint8_t i; + for(i = 0; i < 0x34; i += 4) { + 76d6: 24 33 cpi r18, 0x34 ; 52 + 76d8: 31 05 cpc r19, r1 + 76da: 91 f7 brne .-28 ; 0x76c0 + } + } +#ifdef _DEBUG_VALD + traceln("Vald: Valid image"); +#endif + return(1); + 76dc: 81 e0 ldi r24, 0x01 ; 1 + 76de: 08 95 ret + tracenum(i); + trace(" with "); + tracenum(base[i]); + trace(" instead of 0x0C"); +#endif + return(0); + 76e0: 80 e0 ldi r24, 0x00 ; 0 + } +#ifdef _DEBUG_VALD + traceln("Vald: Valid image"); +#endif + return(1); +} + 76e2: 08 95 ret + +000076e4 : + */ +uint8_t watchdogDisable(void) +{ + uint8_t mcusr_mirror; + + mcusr_mirror = MCUSR; + 76e4: 84 b7 in r24, 0x34 ; 52 + MCUSR = 0; + 76e6: 14 be out 0x34, r1 ; 52 + wdt_disable(); + 76e8: 98 e1 ldi r25, 0x18 ; 24 + 76ea: 0f b6 in r0, 0x3f ; 63 + 76ec: f8 94 cli + 76ee: 90 93 60 00 sts 0x0060, r25 + 76f2: 10 92 60 00 sts 0x0060, r1 + 76f6: 0f be out 0x3f, r0 ; 63 + + return(mcusr_mirror); +} + 76f8: 08 95 ret + +000076fa : + +void watchdogReset(void) +{ + wdt_reset(); + 76fa: a8 95 wdr + 76fc: 08 95 ret + +000076fe : +} + +void watchdogConfig(uint8_t x) +{ + WDTCSR = _BV(WDCE) | _BV(WDE); + 76fe: e0 e6 ldi r30, 0x60 ; 96 + 7700: f0 e0 ldi r31, 0x00 ; 0 + 7702: 98 e1 ldi r25, 0x18 ; 24 + 7704: 90 83 st Z, r25 + WDTCSR = x; + 7706: 80 83 st Z, r24 + 7708: 08 95 ret + +0000770a : +uint8_t length; + + +void verifySpace() +{ + if(getch() != CRC_EOP) { + 770a: 12 d1 rcall .+548 ; 0x7930 + 770c: 80 32 cpi r24, 0x20 ; 32 + 770e: 19 f0 breq .+6 ; 0x7716 + watchdogConfig(WATCHDOG_16MS); // shorten WD timeout + 7710: 88 e0 ldi r24, 0x08 ; 8 + 7712: f5 df rcall .-22 ; 0x76fe + 7714: ff cf rjmp .-2 ; 0x7714 + while(1) // and busy-loop so that WD causes + ; // a reset and app start. + } + putch(STK_INSYNC); + 7716: 84 e1 ldi r24, 0x14 ; 20 + 7718: f8 c0 rjmp .+496 ; 0x790a + +0000771a : +} + + +void getNch(uint8_t count) +{ + 771a: cf 93 push r28 + 771c: c8 2f mov r28, r24 + do getch(); + 771e: 08 d1 rcall .+528 ; 0x7930 + while(--count); + 7720: c1 50 subi r28, 0x01 ; 1 + 7722: e9 f7 brne .-6 ; 0x771e + verifySpace(); +} + 7724: cf 91 pop r28 + +void getNch(uint8_t count) +{ + do getch(); + while(--count); + verifySpace(); + 7726: f1 cf rjmp .-30 ; 0x770a + +00007728 : +} + + +uint8_t proccessCommand() +{ + 7728: ef 92 push r14 + 772a: ff 92 push r15 + 772c: cf 93 push r28 + 772e: df 93 push r29 + 7730: cd b7 in r28, 0x3d ; 61 + 7732: de b7 in r29, 0x3e ; 62 + 7734: c1 50 subi r28, 0x01 ; 1 + 7736: d1 40 sbci r29, 0x01 ; 1 + 7738: de bf out 0x3e, r29 ; 62 + 773a: cd bf out 0x3d, r28 ; 61 + uint8_t ch; + + ch = getch(); + 773c: f9 d0 rcall .+498 ; 0x7930 + + if(ch == STK_GET_PARAMETER) { + 773e: 81 34 cpi r24, 0x41 ; 65 + 7740: a9 f4 brne .+42 ; 0x776c + unsigned char which = getch(); + 7742: f6 d0 rcall .+492 ; 0x7930 + verifySpace(); + 7744: cf 5f subi r28, 0xFF ; 255 + 7746: de 4f sbci r29, 0xFE ; 254 + 7748: 88 83 st Y, r24 + 774a: c1 50 subi r28, 0x01 ; 1 + 774c: d1 40 sbci r29, 0x01 ; 1 + 774e: dd df rcall .-70 ; 0x770a + if(which == 0x82) { + 7750: cf 5f subi r28, 0xFF ; 255 + 7752: de 4f sbci r29, 0xFE ; 254 + 7754: 88 81 ld r24, Y + 7756: c1 50 subi r28, 0x01 ; 1 + 7758: d1 40 sbci r29, 0x01 ; 1 + 775a: 82 38 cpi r24, 0x82 ; 130 + 775c: 11 f4 brne .+4 ; 0x7762 + /* + * Send tftpboot version as "minor SW version" + */ + putch(TFTPBOOT_MINVER); + 775e: 83 e0 ldi r24, 0x03 ; 3 + 7760: 03 c0 rjmp .+6 ; 0x7768 + } else if(which == 0x81) { + 7762: 81 38 cpi r24, 0x81 ; 129 + 7764: e1 f7 brne .-8 ; 0x775e + putch(TFTPBOOT_MAJVER); + 7766: 80 e0 ldi r24, 0x00 ; 0 + 7768: d0 d0 rcall .+416 ; 0x790a + 776a: ac c0 rjmp .+344 ; 0x78c4 + * GET PARAMETER returns a generic 0x03 reply for + * other parameters - enough to keep Avrdude happy + */ + putch(0x03); + } + } else if(ch == STK_SET_DEVICE) { + 776c: 82 34 cpi r24, 0x42 ; 66 + 776e: 11 f4 brne .+4 ; 0x7774 + // SET DEVICE is ignored + getNch(20); + 7770: 84 e1 ldi r24, 0x14 ; 20 + 7772: 03 c0 rjmp .+6 ; 0x777a + } else if(ch == STK_SET_DEVICE_EXT) { + 7774: 85 34 cpi r24, 0x45 ; 69 + 7776: 19 f4 brne .+6 ; 0x777e + // SET DEVICE EXT is ignored + getNch(4); + 7778: 84 e0 ldi r24, 0x04 ; 4 + 777a: cf df rcall .-98 ; 0x771a + 777c: a3 c0 rjmp .+326 ; 0x78c4 + } else if(ch == STK_LOAD_ADDRESS) { + 777e: 85 35 cpi r24, 0x55 ; 85 + 7780: 69 f4 brne .+26 ; 0x779c + // LOAD ADDRESS + uint16_t newAddress; + newAddress = getch(); + 7782: d6 d0 rcall .+428 ; 0x7930 + 7784: f8 2e mov r15, r24 + newAddress = (newAddress & 0xff) | (getch() << 8); + 7786: d4 d0 rcall .+424 ; 0x7930 + 7788: 2f 2d mov r18, r15 + 778a: 30 e0 ldi r19, 0x00 ; 0 + 778c: 38 2b or r19, r24 +#ifdef RAMPZ + // Transfer top bit to RAMPZ + RAMPZ = (newAddress & 0x8000) ? 1 : 0; +#endif + + newAddress += newAddress; // Convert from word address to byte address + 778e: 22 0f add r18, r18 + 7790: 33 1f adc r19, r19 + address = newAddress; + 7792: 30 93 21 01 sts 0x0121, r19 + 7796: 20 93 20 01 sts 0x0120, r18 + 779a: 93 c0 rjmp .+294 ; 0x78c2 + verifySpace(); + } else if(ch == STK_UNIVERSAL) { + 779c: 86 35 cpi r24, 0x56 ; 86 + 779e: 19 f4 brne .+6 ; 0x77a6 + // UNIVERSAL command is ignored + getNch(4); + 77a0: 84 e0 ldi r24, 0x04 ; 4 + 77a2: bb df rcall .-138 ; 0x771a + 77a4: e0 cf rjmp .-64 ; 0x7766 + putch(0x00); + } + /* Write memory, length is big endian and is in bytes */ + else if(ch == STK_PROG_PAGE) { + 77a6: 84 36 cpi r24, 0x64 ; 100 + 77a8: 09 f0 breq .+2 ; 0x77ac + 77aa: 5b c0 rjmp .+182 ; 0x7862 + // PROGRAM PAGE - we support flash programming only, not EEPROM + uint8_t buff[256]; + uint8_t* bufPtr; + uint16_t addrPtr; + + getch(); /* getlen() */ + 77ac: c1 d0 rcall .+386 ; 0x7930 + length = getch(); + 77ae: c0 d0 rcall .+384 ; 0x7930 + 77b0: 80 93 28 01 sts 0x0128, r24 + getch(); + 77b4: bd d0 rcall .+378 ; 0x7930 + + // If we are in RWW section, immediately start page erase + if(address < NRWWSTART) boot_page_erase((uint16_t)(void *)address); + 77b6: e0 91 20 01 lds r30, 0x0120 + 77ba: f0 91 21 01 lds r31, 0x0121 + 77be: e1 15 cp r30, r1 + 77c0: 80 e7 ldi r24, 0x70 ; 112 + 77c2: f8 07 cpc r31, r24 + 77c4: 18 f4 brcc .+6 ; 0x77cc + 77c6: 83 e0 ldi r24, 0x03 ; 3 + 77c8: 87 bf out 0x37, r24 ; 55 + 77ca: e8 95 spm + 77cc: ee 24 eor r14, r14 + 77ce: e3 94 inc r14 + 77d0: f1 2c mov r15, r1 + 77d2: ec 0e add r14, r28 + 77d4: fd 1e adc r15, r29 + + // While that is going on, read in page contents + bufPtr = buff; + do *bufPtr++ = getch(); + 77d6: ac d0 rcall .+344 ; 0x7930 + 77d8: f7 01 movw r30, r14 + 77da: 81 93 st Z+, r24 + 77dc: 7f 01 movw r14, r30 + while(--length); + 77de: 80 91 28 01 lds r24, 0x0128 + 77e2: 81 50 subi r24, 0x01 ; 1 + 77e4: 80 93 28 01 sts 0x0128, r24 + 77e8: 81 11 cpse r24, r1 + 77ea: f5 cf rjmp .-22 ; 0x77d6 + + // If we are in NRWW section, page erase has to be delayed until now. + // Todo: Take RAMPZ into account + if(address >= NRWWSTART) boot_page_erase((uint16_t)(void *)address); + 77ec: e0 91 20 01 lds r30, 0x0120 + 77f0: f0 91 21 01 lds r31, 0x0121 + 77f4: e1 15 cp r30, r1 + 77f6: 80 e7 ldi r24, 0x70 ; 112 + 77f8: f8 07 cpc r31, r24 + 77fa: 18 f0 brcs .+6 ; 0x7802 + 77fc: 83 e0 ldi r24, 0x03 ; 3 + 77fe: 87 bf out 0x37, r24 ; 55 + 7800: e8 95 spm + + // Read command terminator, start reply + verifySpace(); + 7802: 83 df rcall .-250 ; 0x770a + + // If only a partial page is to be programmed, the erase might not be complete. + // So check that here + boot_spm_busy_wait(); + 7804: 07 b6 in r0, 0x37 ; 55 + 7806: 00 fc sbrc r0, 0 + 7808: fd cf rjmp .-6 ; 0x7804 + + // Copy buffer into programming buffer + bufPtr = buff; + addrPtr = (uint16_t)(void *)address; + 780a: 40 91 20 01 lds r20, 0x0120 + 780e: 50 91 21 01 lds r21, 0x0121 + // If only a partial page is to be programmed, the erase might not be complete. + // So check that here + boot_spm_busy_wait(); + + // Copy buffer into programming buffer + bufPtr = buff; + 7812: 29 81 ldd r18, Y+1 ; 0x01 + 7814: 80 e0 ldi r24, 0x00 ; 0 + 7816: 90 e0 ldi r25, 0x00 ; 0 + ch = SPM_PAGESIZE / 2; + do { + uint16_t a; + a = *bufPtr++; + a |= (*bufPtr++) << 8; + boot_page_fill((uint16_t)(void *)addrPtr, a); + 7818: 61 e0 ldi r22, 0x01 ; 1 + while(--count); + verifySpace(); +} + + +uint8_t proccessCommand() + 781a: a1 e0 ldi r26, 0x01 ; 1 + 781c: b0 e0 ldi r27, 0x00 ; 0 + 781e: ac 0f add r26, r28 + 7820: bd 1f adc r27, r29 + 7822: a8 0f add r26, r24 + 7824: b9 1f adc r27, r25 + 7826: fc 01 movw r30, r24 + 7828: e4 0f add r30, r20 + 782a: f5 1f adc r31, r21 + addrPtr = (uint16_t)(void *)address; + ch = SPM_PAGESIZE / 2; + do { + uint16_t a; + a = *bufPtr++; + a |= (*bufPtr++) << 8; + 782c: 11 96 adiw r26, 0x01 ; 1 + 782e: 7c 91 ld r23, X + 7830: 11 97 sbiw r26, 0x01 ; 1 + 7832: 30 e0 ldi r19, 0x00 ; 0 + 7834: 37 2b or r19, r23 + boot_page_fill((uint16_t)(void *)addrPtr, a); + 7836: 09 01 movw r0, r18 + 7838: 67 bf out 0x37, r22 ; 55 + 783a: e8 95 spm + 783c: 11 24 eor r1, r1 + addrPtr += 2; + } while(--ch); + 783e: 8e 37 cpi r24, 0x7E ; 126 + 7840: 91 05 cpc r25, r1 + 7842: 21 f0 breq .+8 ; 0x784c + addrPtr = (uint16_t)(void *)address; + ch = SPM_PAGESIZE / 2; + do { + uint16_t a; + a = *bufPtr++; + a |= (*bufPtr++) << 8; + 7844: 12 96 adiw r26, 0x02 ; 2 + 7846: 2c 91 ld r18, X + 7848: 02 96 adiw r24, 0x02 ; 2 + 784a: e7 cf rjmp .-50 ; 0x781a + boot_page_fill((uint16_t)(void *)addrPtr, a); + addrPtr += 2; + } while(--ch); + + // Write from programming buffer + boot_page_write((uint16_t)(void *)address); + 784c: 85 e0 ldi r24, 0x05 ; 5 + 784e: fa 01 movw r30, r20 + 7850: 87 bf out 0x37, r24 ; 55 + 7852: e8 95 spm + boot_spm_busy_wait(); + 7854: 07 b6 in r0, 0x37 ; 55 + 7856: 00 fc sbrc r0, 0 + 7858: fd cf rjmp .-6 ; 0x7854 + +#if defined(RWWSRE) + // Reenable read access to flash + boot_rww_enable(); + 785a: 81 e1 ldi r24, 0x11 ; 17 + 785c: 87 bf out 0x37, r24 ; 55 + 785e: e8 95 spm + 7860: 31 c0 rjmp .+98 ; 0x78c4 +#endif + } + /* Read memory block mode, length is big endian. */ + else if(ch == STK_READ_PAGE) { + 7862: 84 37 cpi r24, 0x74 ; 116 + 7864: d1 f4 brne .+52 ; 0x789a + // READ PAGE - we only read flash + getch(); /* getlen() */ + 7866: 64 d0 rcall .+200 ; 0x7930 + length = getch(); + 7868: 63 d0 rcall .+198 ; 0x7930 + 786a: 80 93 28 01 sts 0x0128, r24 + getch(); + 786e: 60 d0 rcall .+192 ; 0x7930 + + verifySpace(); + 7870: 4c df rcall .-360 ; 0x770a + __asm__("elpm %0,Z\n":"=r"(result):"z"(address)); + putch(result); + address++; + } while(--length); +#else + do putch(pgm_read_byte_near(address++)); + 7872: e0 91 20 01 lds r30, 0x0120 + 7876: f0 91 21 01 lds r31, 0x0121 + 787a: cf 01 movw r24, r30 + 787c: 01 96 adiw r24, 0x01 ; 1 + 787e: 90 93 21 01 sts 0x0121, r25 + 7882: 80 93 20 01 sts 0x0120, r24 + 7886: 84 91 lpm r24, Z + 7888: 40 d0 rcall .+128 ; 0x790a + while(--length); + 788a: 80 91 28 01 lds r24, 0x0128 + 788e: 81 50 subi r24, 0x01 ; 1 + 7890: 80 93 28 01 sts 0x0128, r24 + 7894: 81 11 cpse r24, r1 + 7896: ed cf rjmp .-38 ; 0x7872 + 7898: 15 c0 rjmp .+42 ; 0x78c4 +#endif + } + /* Get device signature bytes */ + else if(ch == STK_READ_SIGN) { + 789a: 85 37 cpi r24, 0x75 ; 117 + 789c: 39 f4 brne .+14 ; 0x78ac + // READ SIGN - return what Avrdude wants to hear + verifySpace(); + 789e: 35 df rcall .-406 ; 0x770a + putch(SIGNATURE_0); + 78a0: 8e e1 ldi r24, 0x1E ; 30 + 78a2: 33 d0 rcall .+102 ; 0x790a + putch(SIGNATURE_1); + 78a4: 85 e9 ldi r24, 0x95 ; 149 + 78a6: 31 d0 rcall .+98 ; 0x790a + putch(SIGNATURE_2); + 78a8: 8f e0 ldi r24, 0x0F ; 15 + 78aa: 5e cf rjmp .-324 ; 0x7768 + } else if(ch == STK_LEAVE_PROGMODE) { + 78ac: 81 35 cpi r24, 0x51 ; 81 + 78ae: 49 f4 brne .+18 ; 0x78c2 + // Adaboot no-wait mod + //watchdogConfig(WATCHDOG_16MS); + verifySpace(); + 78b0: 2c df rcall .-424 ; 0x770a + eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); + 78b2: 6b eb ldi r22, 0xBB ; 187 + 78b4: 82 e0 ldi r24, 0x02 ; 2 + 78b6: 90 e0 ldi r25, 0x00 ; 0 + 78b8: 8e d0 rcall .+284 ; 0x79d6 <__eewr_byte_m328p> + putch(STK_OK); + 78ba: 80 e1 ldi r24, 0x10 ; 16 + 78bc: 26 d0 rcall .+76 ; 0x790a + return(0); + 78be: 80 e0 ldi r24, 0x00 ; 0 + 78c0: 04 c0 rjmp .+8 ; 0x78ca + } else { + // This covers the response to commands like STK_ENTER_PROGMODE + verifySpace(); + 78c2: 23 df rcall .-442 ; 0x770a + } + putch(STK_OK); + 78c4: 80 e1 ldi r24, 0x10 ; 16 + 78c6: 21 d0 rcall .+66 ; 0x790a + return(1); + 78c8: 81 e0 ldi r24, 0x01 ; 1 +} + 78ca: cf 5f subi r28, 0xFF ; 255 + 78cc: de 4f sbci r29, 0xFE ; 254 + 78ce: de bf out 0x3e, r29 ; 62 + 78d0: cd bf out 0x3d, r28 ; 61 + 78d2: df 91 pop r29 + 78d4: cf 91 pop r28 + 78d6: ff 90 pop r15 + 78d8: ef 90 pop r14 + 78da: 08 95 ret + +000078dc : + + +uint8_t serialPoll() +{ + if(UCSR0A & _BV(RXC0)){ + 78dc: 80 91 c0 00 lds r24, 0x00C0 + 78e0: 87 ff sbrs r24, 7 + 78e2: 04 c0 rjmp .+8 ; 0x78ec + serialFlashing = TRUE; + 78e4: 81 e0 ldi r24, 0x01 ; 1 + 78e6: 80 93 26 01 sts 0x0126, r24 + return(proccessCommand()); + 78ea: 1e cf rjmp .-452 ; 0x7728 + } else return(1); +} + 78ec: 81 e0 ldi r24, 0x01 ; 1 + 78ee: 08 95 ret + +000078f0 : +#include "pin_defs.h" + + +void serialInit() +{ + UCSR0A = _BV(U2X0); //Double speed mode USART0 + 78f0: 82 e0 ldi r24, 0x02 ; 2 + 78f2: 80 93 c0 00 sts 0x00C0, r24 + UCSR0B = _BV(RXEN0) | _BV(TXEN0); + 78f6: 88 e1 ldi r24, 0x18 ; 24 + 78f8: 80 93 c1 00 sts 0x00C1, r24 + UCSR0C = _BV(UCSZ00) | _BV(UCSZ01); + 78fc: 86 e0 ldi r24, 0x06 ; 6 + 78fe: 80 93 c2 00 sts 0x00C2, r24 + UBRR0L = (uint8_t)((F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1); + 7902: 80 e1 ldi r24, 0x10 ; 16 + 7904: 80 93 c4 00 sts 0x00C4, r24 + 7908: 08 95 ret + +0000790a : +} + + +void putch(uint8_t c) +{ + while(!(UCSR0A & _BV(UDRE0))); + 790a: 90 91 c0 00 lds r25, 0x00C0 + 790e: 95 ff sbrs r25, 5 + 7910: fc cf rjmp .-8 ; 0x790a + UDR0 = c; + 7912: 80 93 c6 00 sts 0x00C6, r24 + 7916: 08 95 ret + +00007918 : +} + + +void puthex(uint8_t c) +{ + c &= 0xf; + 7918: 8f 70 andi r24, 0x0F ; 15 + if(c > 9) c += 7; + 791a: 8a 30 cpi r24, 0x0A ; 10 + 791c: 08 f0 brcs .+2 ; 0x7920 + 791e: 89 5f subi r24, 0xF9 ; 249 + while(!(UCSR0A & _BV(UDRE0))); + 7920: 90 91 c0 00 lds r25, 0x00C0 + 7924: 95 ff sbrs r25, 5 + 7926: fc cf rjmp .-8 ; 0x7920 + UDR0 = c + '0'; + 7928: 80 5d subi r24, 0xD0 ; 208 + 792a: 80 93 c6 00 sts 0x00C6, r24 + 792e: 08 95 ret + +00007930 : + +uint8_t getch(void) +{ + uint8_t ch; + + while(!(UCSR0A & _BV(RXC0))); + 7930: 80 91 c0 00 lds r24, 0x00C0 + 7934: 87 ff sbrs r24, 7 + 7936: fc cf rjmp .-8 ; 0x7930 + if(!(UCSR0A & _BV(FE0))) { + 7938: 80 91 c0 00 lds r24, 0x00C0 + 793c: 84 ff sbrs r24, 4 + * expects to be talking to the application, and DON'T reset the + * watchdog. This should cause the bootloader to abort and run + * the application "soon", if it keeps happening. (Note that we + * don't care that an invalid char is returned...) + */ + watchdogReset(); + 793e: dd de rcall .-582 ; 0x76fa + } + ch = UDR0; + 7940: 80 91 c6 00 lds r24, 0x00C6 + + return ch; +} + 7944: 08 95 ret + +00007946 : +uint16_t tick = 0; + + +void updateLed(void) +{ + uint16_t nextTimer1 = TCNT1; + 7946: 80 91 84 00 lds r24, 0x0084 + 794a: 90 91 85 00 lds r25, 0x0085 + if(nextTimer1 & 0x400) LED_PORT ^= _BV(LED); // Led pin high + 794e: 92 ff sbrs r25, 2 + 7950: 05 c0 rjmp .+10 ; 0x795c + 7952: 25 b1 in r18, 0x05 ; 5 + 7954: 30 e2 ldi r19, 0x20 ; 32 + 7956: 23 27 eor r18, r19 + 7958: 25 b9 out 0x05, r18 ; 5 + 795a: 01 c0 rjmp .+2 ; 0x795e + else LED_PORT &= ~_BV(LED); // Led pin low + 795c: 2d 98 cbi 0x05, 5 ; 5 + if(nextTimer1 < lastTimer1) tick++; + 795e: 20 91 29 01 lds r18, 0x0129 + 7962: 30 91 2a 01 lds r19, 0x012A + 7966: 82 17 cp r24, r18 + 7968: 93 07 cpc r25, r19 + 796a: 50 f4 brcc .+20 ; 0x7980 + 796c: 20 91 22 01 lds r18, 0x0122 + 7970: 30 91 23 01 lds r19, 0x0123 + 7974: 2f 5f subi r18, 0xFF ; 255 + 7976: 3f 4f sbci r19, 0xFF ; 255 + 7978: 30 93 23 01 sts 0x0123, r19 + 797c: 20 93 22 01 sts 0x0122, r18 + lastTimer1 = nextTimer1; + 7980: 90 93 2a 01 sts 0x012A, r25 + 7984: 80 93 29 01 sts 0x0129, r24 + 7988: 08 95 ret + +0000798a : +} + +void resetTick(void) +{ + tick = 0; + 798a: 10 92 23 01 sts 0x0123, r1 + 798e: 10 92 22 01 sts 0x0122, r1 + 7992: 08 95 ret + +00007994 : +} + +uint8_t timedOut(void) +{ + // Never timeout if there is no code in Flash + if(pgm_read_word(0x0000) == 0xFFFF) return(0); + 7994: e0 e0 ldi r30, 0x00 ; 0 + 7996: f0 e0 ldi r31, 0x00 ; 0 + 7998: 85 91 lpm r24, Z+ + 799a: 94 91 lpm r25, Z + 799c: 01 96 adiw r24, 0x01 ; 1 + 799e: 41 f0 breq .+16 ; 0x79b0 + if(tick > TIMEOUT) return(1); + 79a0: 81 e0 ldi r24, 0x01 ; 1 + 79a2: 20 91 22 01 lds r18, 0x0122 + 79a6: 30 91 23 01 lds r19, 0x0123 + 79aa: 24 30 cpi r18, 0x04 ; 4 + 79ac: 31 05 cpc r19, r1 + 79ae: 08 f4 brcc .+2 ; 0x79b2 +} + +uint8_t timedOut(void) +{ + // Never timeout if there is no code in Flash + if(pgm_read_word(0x0000) == 0xFFFF) return(0); + 79b0: 80 e0 ldi r24, 0x00 ; 0 + if(tick > TIMEOUT) return(1); + return(0); +} + 79b2: 08 95 ret + +000079b4 : + 79b4: fb 01 movw r30, r22 + 79b6: dc 01 movw r26, r24 + 79b8: 02 c0 rjmp .+4 ; 0x79be + 79ba: 05 90 lpm r0, Z+ + 79bc: 0d 92 st X+, r0 + 79be: 41 50 subi r20, 0x01 ; 1 + 79c0: 50 40 sbci r21, 0x00 ; 0 + 79c2: d8 f7 brcc .-10 ; 0x79ba + 79c4: 08 95 ret + +000079c6 <__eerd_byte_m328p>: + 79c6: f9 99 sbic 0x1f, 1 ; 31 + 79c8: fe cf rjmp .-4 ; 0x79c6 <__eerd_byte_m328p> + 79ca: 92 bd out 0x22, r25 ; 34 + 79cc: 81 bd out 0x21, r24 ; 33 + 79ce: f8 9a sbi 0x1f, 0 ; 31 + 79d0: 99 27 eor r25, r25 + 79d2: 80 b5 in r24, 0x20 ; 32 + 79d4: 08 95 ret + +000079d6 <__eewr_byte_m328p>: + 79d6: 26 2f mov r18, r22 + +000079d8 <__eewr_r18_m328p>: + 79d8: f9 99 sbic 0x1f, 1 ; 31 + 79da: fe cf rjmp .-4 ; 0x79d8 <__eewr_r18_m328p> + 79dc: 1f ba out 0x1f, r1 ; 31 + 79de: 92 bd out 0x22, r25 ; 34 + 79e0: 81 bd out 0x21, r24 ; 33 + 79e2: 20 bd out 0x20, r18 ; 32 + 79e4: 0f b6 in r0, 0x3f ; 63 + 79e6: f8 94 cli + 79e8: fa 9a sbi 0x1f, 2 ; 31 + 79ea: f9 9a sbi 0x1f, 1 ; 31 + 79ec: 0f be out 0x3f, r0 ; 63 + 79ee: 01 96 adiw r24, 0x01 ; 1 + 79f0: 08 95 ret + +000079f2 <_exit>: + 79f2: f8 94 cli + +000079f4 <__stop_program>: + 79f4: ff cf rjmp .-2 ; 0x79f4 <__stop_program> diff --git a/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328_ethernet.hex b/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328_ethernet.hex new file mode 100644 index 0000000..61e26b0 --- /dev/null +++ b/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328_ethernet.hex @@ -0,0 +1,164 @@ +:1070000050C00000BEC00000BCC00000BAC00000FC +:10701000B8C00000B6C00000B4C00000B2C000009C +:10702000B0C00000AEC00000ACC00000AAC00000AC +:10703000A8C00000A6C00000A4C00000A2C00000BC +:10704000A0C000009EC000009CC000009AC00000CC +:1070500098C0000096C0000094C0000092C00000DC +:1070600090C000008EC000001300050000496E763D +:10707000616C696420696D6167652066696C650093 +:1070800008000500004572726F72000900050003D8 +:1070900046756C6C000A000500004F70636F6465F4 +:1070A0003F0011241FBECFEFD8E0DEBFCDBF11E0FF +:1070B000A0E0B1E0EAEFF9E702C005900D92AC3133 +:1070C000B107D9F711E0ACE1B1E001C01D92AB32DC +:1070D000B107E1F701D08FC407D32FEF85EA9EE017 +:1070E000215080409040E1F700C00000112485E06D +:1070F00080938100FFD39ED097D2EFEFF5EA2EE088 +:10710000E150F0402040E1F700C00000109226015D +:1071100010922701C3E0E12CF12C809126018823F5 +:1071200029F080912701882349F004C099D2811168 +:10713000F8CF20C031D4811105C01AC0D1D381113C +:10714000F9CF18C080912701813069F4109227018E +:1071500007B600FCFDCFF999FECFF701C7BFE89550 +:1071600016D462D205C082E090E02FD48B3B11F0A0 +:10717000ECD3D3CFE0911C01F0911D01099580E083 +:1071800090E03ECF20E52CBD2A9820EF2EBD0DB417 +:1071900007FEFDCF292F33272EBD0DB407FEFDCFEF +:1071A0008EBD0DB407FEFDCF6EBD0DB407FEFDCF45 +:1071B0002A9A1CBC089520E52CBD2A982FE02EBDEC +:1071C0000DB407FEFDCF292F33272EBD0DB407FECA +:1071D000FDCF8EBD0DB407FEFDCF1EBC0DB407FE66 +:1071E000FDCF2A9A8EB51CBC0895EF92FF92CF93E3 +:1071F0007C01E1DFC82FC7010196DDDF2C2F30E0D5 +:10720000322F2227A901482BCA01CF91FF90EF907E +:107210000895CF92DF92EF92FF927C016B01672F6E +:107220007727B0DF6C2DC7010196FF90EF90DF90BC +:10723000CF90A8CFCF92DF92EF92FF928CE284B9E9 +:107240008CE385B9219A299A81E08DBD89E797EB76 +:10725000909325018093240180E090E0B6D385359A +:1072600049F581E090E0B1D38A3A21F5E1E0CE2EF4 +:10727000E1E0DE2EF3E0EF2EF12CC701A6D3F601FC +:1072800081936F01FFEFEF1AFF0A85E1E816F10421 +:10729000A1F786E190E099D3F82E85E190E095D3AF +:1072A0002F2D30E0322F2227280F311D309325015A +:1072B0002093240160E0C62E61E0D62EE12CF12C53 +:1072C000F60161916F01C7015DDFFFEFEF1AFF0A61 +:1072D0008CE1E816F104A1F7FF90EF90DF90CF90DA +:1072E0000895AF92BF92CF92DF92EF92FF92CF9329 +:1072F000DF93CDB7DEB7CC50D240DEBFCDBF88E242 +:1073000097E073DF009711F480E098E7EE24E394B0 +:10731000F12CEC0EFD1E5E0123EFA21A2DEFB20A36 +:107320006C01EFEFCE1ADE0A46DFF70181937F0191 +:10733000C114F0E8DF0611F0C60102C080E098E752 +:10734000EA14FB0469F7BC0188E297E062DF60E4BD +:1073500081E097E017DF81E097E02DDF8111FBCF1F +:10736000CC24C394D12CCC0EDD1E6CE0E62E67E05D +:10737000F62EF60161916F01C70104DFFFEFEF1AEE +:10738000FF0A22E1E21627E0F20699F7EF8028854E +:10739000CB843C85898590E0982F88274A85840F87 +:1073A000911D83309105D9F138F48130910539F080 +:1073B000029709F0A3C005C0069708F09FC080E0BF +:1073C000A4C06FEF82E090E008D360E481E097E032 +:1073D000D9DE60E181E097E0D5DE62E080E097E011 +:1073E000D1DE61E081E097E0CDDE60912401709113 +:1073F000250184E097E00DDF83E097E0DCDE823258 +:1074000021F060E181E097E0BDDE83E097E0D3DE2C +:10741000823219F710921F0110921E0175C0D12CF3 +:10742000DC2CCC24C30ED11CF12CFE2CEE24E20E5D +:10743000F11C84E0E81AF108D0921F01C0921E01ED +:10744000E1E0CE1AD108DC2CCC24DD0CC6018E0D77 +:107450009F1D8130904708F053C003C02FEFE21A00 +:10746000F20AC7018F779927892BC1F7C114D1047C +:1074700031F4CE010D9624D1882309F443C0DE01F6 +:107480001D9680E090E041E053E065E071E129C0A5 +:10749000E1E0F0E0EC0FFD1FE80FF91F258530E07B +:1074A000322F2227EC912E2BF601090147BFE895D8 +:1074B000112402969C012F773327232B71F4EE576A +:1074C000F10957BFE89507B600FCFDCF67BFE89507 +:1074D00007B600FCFDCF77BFE8951296F2E0CF0E1D +:1074E000D11C8E159F05A0F2E11422E0F20660F493 +:1074F0006BEB82E090E071D284E007C081E005C0D0 +:1075000083E003C085E001C082E0C45FDD4FDEBFE1 +:10751000CDBFDF91CF91FF90EF90DF90CF90BF90E4 +:10752000AF900895AF92BF92CF92DF92EF92FF9209 +:107530001F93CF93DF93CDB7DEB7C456D109DEBF1B +:10754000CDBF7C0184E297E050DE985A6C0182E066 +:10755000E816F10479F120F4EA94EF2849F418C010 +:1075600083E0E816F104E9F0E4E0EE16F10411F12D +:107570004AE050E060E870E7CE0101961DD28AE053 +:10758000EE24E394F12CEC0EFD1E182F1E0D2EC0E0 +:107590004CE050E065E970E7CE0101960DD28CE039 +:1075A000EFCF49E050E06BE870E7CE01019604D2DE +:1075B00089E0E6CF198284E08A8380911E01909150 +:1075C0001F019B838C8384E0DBCFF70161917F01F6 +:1075D0005601FFEFAF1ABF0AC601D4DDA11480E641 +:1075E000B80619F4A12CE8E5BE2E65011E11EDCFF9 +:1075F000B601785584E297E00CDE60E281E097E026 +:10760000C1DD81E097E0D7DD8111FBCFCC59DF4FA1 +:10761000DEBFCDBFDF91CF911F91FF90EF90DF9044 +:10762000CF90BF90AF90089565E470E084E097E05C +:10763000F0DD62E080E097E0A5DD61E081E097E0C9 +:10764000A1DD83E097E0B7DD823221F060E181E0E7 +:1076500097E098DD83E097E0AEDD823229F7089568 +:10766000CF9386E297E0C1DD892B11F481E026C03B +:1076700080912701811101C08AD181E08093270187 +:1076800082E097E098DD82FF0EC064E082E097E040 +:1076900079DD2FEF87E893E1215080409040E1F7BA +:1076A00000C00000EDCF1DDEC82F90E03BDFC430EE +:1076B000E9F660E181E097E065DD80E0CF91089533 +:1076C00020E030E0FC01E20FF31F40814C3051F428 +:1076D0004181443939F42C5F3F4F2433310591F710 +:1076E00081E0089580E0089584B714BE98E10FB654 +:1076F000F89490936000109260000FBE0895A895D2 +:107700000895E0E6F0E098E190838083089512D137 +:10771000803219F088E0F5DFFFCF84E1F8C0CF9325 +:10772000C82F08D1C150E9F7CF91F1CFEF92FF9266 +:10773000CF93DF93CDB7DEB7C150D140DEBFCDBF11 +:10774000F9D08134A9F4F6D0CF5FDE4F8883C150E1 +:10775000D140DDDFCF5FDE4F8881C150D14082381C +:1077600011F483E003C08138E1F780E0D0D0ACC0F1 +:10777000823411F484E103C0853419F484E0CFDF4E +:10778000A3C0853569F4D6D0F82ED4D02F2D30E0A3 +:10779000382B220F331F309321012093200193C0F7 +:1077A000863519F484E0BBDFE0CF843609F05BC096 +:1077B000C1D0C0D080932801BDD0E0912001F091CC +:1077C0002101E11580E7F80718F483E087BFE89509 +:1077D000EE24E394F12CEC0EFD1EACD0F701819366 +:1077E0007F01809128018150809328018111F5CF7C +:1077F000E0912001F0912101E11580E7F80718F0F0 +:1078000083E087BFE89583DF07B600FCFDCF40919A +:10781000200150912101298180E090E061E0A1E008 +:10782000B0E0AC0FBD1FA80FB91FFC01E40FF51F9E +:1078300011967C91119730E0372B090167BFE895CD +:1078400011248E37910521F012962C910296E7CFE4 +:1078500085E0FA0187BFE89507B600FCFDCF81E11E +:1078600087BFE89531C08437D1F464D063D080936A +:10787000280160D04CDFE0912001F0912101CF017F +:1078800001969093210180932001849140D08091B2 +:1078900028018150809328018111EDCF15C08537D3 +:1078A00039F435DF8EE133D085E931D08FE05ECF1A +:1078B000813549F42CDF6BEB82E090E08ED080E1E3 +:1078C00026D080E004C023DF80E121D081E0CF5FBB +:1078D000DE4FDEBFCDBFDF91CF91FF90EF900895D7 +:1078E0008091C00087FF04C081E0809326011ECFF5 +:1078F00081E0089582E08093C00088E18093C10018 +:1079000086E08093C20080E18093C4000895909146 +:10791000C00095FFFCCF8093C60008958F708A3019 +:1079200008F0895F9091C00095FFFCCF805D809347 +:10793000C60008958091C00087FFFCCF8091C000F1 +:1079400084FFDDDE8091C6000895809184009091CF +:10795000850092FF05C025B132E0232725B901C07B +:1079600029982091290130912A018217930750F418 +:1079700020912201309123012F5F3F4F309323014B +:107980002093220190932A01809329010895109257 +:107990002301109222010895E0E0F0E08591949196 +:1079A000019641F081E020912201309123012430A1 +:1079B000310508F480E00895FB01DC0102C0059068 +:1079C0000D9241505040D8F70895F999FECF92BDDD +:1079D00081BDF89A992780B50895262FF999FECF91 +:1079E0001FBA92BD81BD20BD0FB6F894FA9AF99ADC +:0A79F0000FBE01960895F894FFCF32 +:1079FA0080C0A80101FFFFFF00DEADBEEFFEEDC0B3 +:0C7A0A00A801800000000007D080555546 +:040000030000700089 +:00000001FF diff --git a/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328_ethernet.lst b/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328_ethernet.lst new file mode 100644 index 0000000..c65fbff --- /dev/null +++ b/hardware/ariadne/bootloaders/ariadne/ariadne_atmega328_ethernet.lst @@ -0,0 +1,2167 @@ + +ariadne_atmega328_ethernet.elf: file format elf32-avr + +Sections: +Idx Name Size VMA LMA File off Algn + 0 .data 0000001c 00800100 000079fa 00000a8e 2**0 + CONTENTS, ALLOC, LOAD, DATA + 1 .text 000009fa 00007000 00007000 00000094 2**1 + CONTENTS, ALLOC, LOAD, READONLY, CODE + 2 .bss 0000000f 0080011c 0080011c 00000aaa 2**0 + ALLOC + 3 .stab 00002fdc 00000000 00000000 00000aac 2**2 + CONTENTS, READONLY, DEBUGGING + 4 .stabstr 000010e9 00000000 00000000 00003a88 2**0 + CONTENTS, READONLY, DEBUGGING + 5 .comment 00000011 00000000 00000000 00004b71 2**0 + CONTENTS, READONLY + +Disassembly of section .text: + +00007000 <__vectors>: + 7000: 50 c0 rjmp .+160 ; 0x70a2 <__ctors_end> + 7002: 00 00 nop + 7004: be c0 rjmp .+380 ; 0x7182 <__bad_interrupt> + 7006: 00 00 nop + 7008: bc c0 rjmp .+376 ; 0x7182 <__bad_interrupt> + 700a: 00 00 nop + 700c: ba c0 rjmp .+372 ; 0x7182 <__bad_interrupt> + 700e: 00 00 nop + 7010: b8 c0 rjmp .+368 ; 0x7182 <__bad_interrupt> + 7012: 00 00 nop + 7014: b6 c0 rjmp .+364 ; 0x7182 <__bad_interrupt> + 7016: 00 00 nop + 7018: b4 c0 rjmp .+360 ; 0x7182 <__bad_interrupt> + 701a: 00 00 nop + 701c: b2 c0 rjmp .+356 ; 0x7182 <__bad_interrupt> + 701e: 00 00 nop + 7020: b0 c0 rjmp .+352 ; 0x7182 <__bad_interrupt> + 7022: 00 00 nop + 7024: ae c0 rjmp .+348 ; 0x7182 <__bad_interrupt> + 7026: 00 00 nop + 7028: ac c0 rjmp .+344 ; 0x7182 <__bad_interrupt> + 702a: 00 00 nop + 702c: aa c0 rjmp .+340 ; 0x7182 <__bad_interrupt> + 702e: 00 00 nop + 7030: a8 c0 rjmp .+336 ; 0x7182 <__bad_interrupt> + 7032: 00 00 nop + 7034: a6 c0 rjmp .+332 ; 0x7182 <__bad_interrupt> + 7036: 00 00 nop + 7038: a4 c0 rjmp .+328 ; 0x7182 <__bad_interrupt> + 703a: 00 00 nop + 703c: a2 c0 rjmp .+324 ; 0x7182 <__bad_interrupt> + 703e: 00 00 nop + 7040: a0 c0 rjmp .+320 ; 0x7182 <__bad_interrupt> + 7042: 00 00 nop + 7044: 9e c0 rjmp .+316 ; 0x7182 <__bad_interrupt> + 7046: 00 00 nop + 7048: 9c c0 rjmp .+312 ; 0x7182 <__bad_interrupt> + 704a: 00 00 nop + 704c: 9a c0 rjmp .+308 ; 0x7182 <__bad_interrupt> + 704e: 00 00 nop + 7050: 98 c0 rjmp .+304 ; 0x7182 <__bad_interrupt> + 7052: 00 00 nop + 7054: 96 c0 rjmp .+300 ; 0x7182 <__bad_interrupt> + 7056: 00 00 nop + 7058: 94 c0 rjmp .+296 ; 0x7182 <__bad_interrupt> + 705a: 00 00 nop + 705c: 92 c0 rjmp .+292 ; 0x7182 <__bad_interrupt> + 705e: 00 00 nop + 7060: 90 c0 rjmp .+288 ; 0x7182 <__bad_interrupt> + 7062: 00 00 nop + 7064: 8e c0 rjmp .+284 ; 0x7182 <__bad_interrupt> + ... + +00007068 : + 7068: 13 00 05 00 00 49 6e 76 61 6c 69 64 20 69 6d 61 .....Invalid ima + 7078: 67 65 20 66 69 6c 65 00 ge file. + +00007080 : + 7080: 08 00 05 00 00 45 72 72 6f 72 00 .....Error. + +0000708b : + 708b: 09 00 05 00 03 46 75 6c 6c 00 .....Full. + +00007095 : + 7095: 0a 00 05 00 00 4f 70 63 6f 64 65 3f 00 .....Opcode?. + +000070a2 <__ctors_end>: + 70a2: 11 24 eor r1, r1 + 70a4: 1f be out 0x3f, r1 ; 63 + 70a6: cf ef ldi r28, 0xFF ; 255 + 70a8: d8 e0 ldi r29, 0x08 ; 8 + 70aa: de bf out 0x3e, r29 ; 62 + 70ac: cd bf out 0x3d, r28 ; 61 + +000070ae <__do_copy_data>: + 70ae: 11 e0 ldi r17, 0x01 ; 1 + 70b0: a0 e0 ldi r26, 0x00 ; 0 + 70b2: b1 e0 ldi r27, 0x01 ; 1 + 70b4: ea ef ldi r30, 0xFA ; 250 + 70b6: f9 e7 ldi r31, 0x79 ; 121 + 70b8: 02 c0 rjmp .+4 ; 0x70be <__do_copy_data+0x10> + 70ba: 05 90 lpm r0, Z+ + 70bc: 0d 92 st X+, r0 + 70be: ac 31 cpi r26, 0x1C ; 28 + 70c0: b1 07 cpc r27, r17 + 70c2: d9 f7 brne .-10 ; 0x70ba <__do_copy_data+0xc> + +000070c4 <__do_clear_bss>: + 70c4: 11 e0 ldi r17, 0x01 ; 1 + 70c6: ac e1 ldi r26, 0x1C ; 28 + 70c8: b1 e0 ldi r27, 0x01 ; 1 + 70ca: 01 c0 rjmp .+2 ; 0x70ce <.do_clear_bss_start> + +000070cc <.do_clear_bss_loop>: + 70cc: 1d 92 st X+, r1 + +000070ce <.do_clear_bss_start>: + 70ce: ab 32 cpi r26, 0x2B ; 43 + 70d0: b1 07 cpc r27, r17 + 70d2: e1 f7 brne .-8 ; 0x70cc <.do_clear_bss_loop> + 70d4: 01 d0 rcall .+2 ; 0x70d8
+ 70d6: 8f c4 rjmp .+2334 ; 0x79f6 <_exit> + +000070d8
: + 70d8: 07 d3 rcall .+1550 ; 0x76e8 + 70da: 2f ef ldi r18, 0xFF ; 255 + 70dc: 85 ea ldi r24, 0xA5 ; 165 + 70de: 9e e0 ldi r25, 0x0E ; 14 + 70e0: 21 50 subi r18, 0x01 ; 1 + 70e2: 80 40 sbci r24, 0x00 ; 0 + 70e4: 90 40 sbci r25, 0x00 ; 0 + 70e6: e1 f7 brne .-8 ; 0x70e0 + 70e8: 00 c0 rjmp .+0 ; 0x70ea + 70ea: 00 00 nop + 70ec: 11 24 eor r1, r1 + 70ee: 85 e0 ldi r24, 0x05 ; 5 + 70f0: 80 93 81 00 sts 0x0081, r24 + 70f4: ff d3 rcall .+2046 ; 0x78f4 + 70f6: 9e d0 rcall .+316 ; 0x7234 + 70f8: 97 d2 rcall .+1326 ; 0x7628 + 70fa: ef ef ldi r30, 0xFF ; 255 + 70fc: f5 ea ldi r31, 0xA5 ; 165 + 70fe: 2e e0 ldi r18, 0x0E ; 14 + 7100: e1 50 subi r30, 0x01 ; 1 + 7102: f0 40 sbci r31, 0x00 ; 0 + 7104: 20 40 sbci r18, 0x00 ; 0 + 7106: e1 f7 brne .-8 ; 0x7100 + 7108: 00 c0 rjmp .+0 ; 0x710a + 710a: 00 00 nop + 710c: 10 92 26 01 sts 0x0126, r1 + 7110: 10 92 27 01 sts 0x0127, r1 + 7114: c3 e0 ldi r28, 0x03 ; 3 + 7116: e1 2c mov r14, r1 + 7118: f1 2c mov r15, r1 + 711a: 80 91 26 01 lds r24, 0x0126 + 711e: 88 23 and r24, r24 + 7120: 29 f0 breq .+10 ; 0x712c + 7122: 80 91 27 01 lds r24, 0x0127 + 7126: 88 23 and r24, r24 + 7128: 49 f0 breq .+18 ; 0x713c + 712a: 04 c0 rjmp .+8 ; 0x7134 + 712c: 99 d2 rcall .+1330 ; 0x7660 + 712e: 81 11 cpse r24, r1 + 7130: f8 cf rjmp .-16 ; 0x7122 + 7132: 20 c0 rjmp .+64 ; 0x7174 + 7134: 31 d4 rcall .+2146 ; 0x7998 + 7136: 81 11 cpse r24, r1 + 7138: 05 c0 rjmp .+10 ; 0x7144 + 713a: 1a c0 rjmp .+52 ; 0x7170 + 713c: d1 d3 rcall .+1954 ; 0x78e0 + 713e: 81 11 cpse r24, r1 + 7140: f9 cf rjmp .-14 ; 0x7134 + 7142: 18 c0 rjmp .+48 ; 0x7174 + 7144: 80 91 27 01 lds r24, 0x0127 + 7148: 81 30 cpi r24, 0x01 ; 1 + 714a: 69 f4 brne .+26 ; 0x7166 + 714c: 10 92 27 01 sts 0x0127, r1 + 7150: 07 b6 in r0, 0x37 ; 55 + 7152: 00 fc sbrc r0, 0 + 7154: fd cf rjmp .-6 ; 0x7150 + 7156: f9 99 sbic 0x1f, 1 ; 31 + 7158: fe cf rjmp .-4 ; 0x7156 + 715a: f7 01 movw r30, r14 + 715c: c7 bf out 0x37, r28 ; 55 + 715e: e8 95 spm + 7160: 16 d4 rcall .+2092 ; 0x798e + 7162: 62 d2 rcall .+1220 ; 0x7628 + 7164: 05 c0 rjmp .+10 ; 0x7170 + 7166: 82 e0 ldi r24, 0x02 ; 2 + 7168: 90 e0 ldi r25, 0x00 ; 0 + 716a: 2f d4 rcall .+2142 ; 0x79ca <__eerd_byte_m328p> + 716c: 8b 3b cpi r24, 0xBB ; 187 + 716e: 11 f0 breq .+4 ; 0x7174 + 7170: ec d3 rcall .+2008 ; 0x794a + 7172: d3 cf rjmp .-90 ; 0x711a + 7174: e0 91 1c 01 lds r30, 0x011C + 7178: f0 91 1d 01 lds r31, 0x011D + 717c: 09 95 icall + 717e: 80 e0 ldi r24, 0x00 ; 0 + 7180: 90 e0 ldi r25, 0x00 ; 0 + +00007182 <__bad_interrupt>: + 7182: 3e cf rjmp .-388 ; 0x7000 <__vectors> + +00007184 : + trace(", "); + tracenum(value); +#endif + + // Send uint8_t to Ethernet controller + SPCR = _BV(SPE) | _BV(MSTR); // Set SPI as master + 7184: 20 e5 ldi r18, 0x50 ; 80 + 7186: 2c bd out 0x2c, r18 ; 44 + SS_LOW(); + 7188: 2a 98 cbi 0x05, 2 ; 5 + SPDR = SPI_WRITE; + 718a: 20 ef ldi r18, 0xF0 ; 240 + 718c: 2e bd out 0x2e, r18 ; 46 + while(!(SPSR & _BV(SPIF))); + 718e: 0d b4 in r0, 0x2d ; 45 + 7190: 07 fe sbrs r0, 7 + 7192: fd cf rjmp .-6 ; 0x718e + SPDR = address >> 8; + 7194: 29 2f mov r18, r25 + 7196: 33 27 eor r19, r19 + 7198: 2e bd out 0x2e, r18 ; 46 + while(!(SPSR & _BV(SPIF))); + 719a: 0d b4 in r0, 0x2d ; 45 + 719c: 07 fe sbrs r0, 7 + 719e: fd cf rjmp .-6 ; 0x719a + SPDR = address & 0xff; + 71a0: 8e bd out 0x2e, r24 ; 46 + while(!(SPSR & _BV(SPIF))); + 71a2: 0d b4 in r0, 0x2d ; 45 + 71a4: 07 fe sbrs r0, 7 + 71a6: fd cf rjmp .-6 ; 0x71a2 + SPDR = value; + 71a8: 6e bd out 0x2e, r22 ; 46 + while(!(SPSR & _BV(SPIF))); + 71aa: 0d b4 in r0, 0x2d ; 45 + 71ac: 07 fe sbrs r0, 7 + 71ae: fd cf rjmp .-6 ; 0x71aa + SS_HIGH(); + 71b0: 2a 9a sbi 0x05, 2 ; 5 + SPCR = 0; // Turn off SPI + 71b2: 1c bc out 0x2c, r1 ; 44 + 71b4: 08 95 ret + +000071b6 : +// tracenum(address); +//#endif + + // Read uint8_t from Ethernet controller + uint8_t returnValue; + SPCR = _BV(SPE) | _BV(MSTR); + 71b6: 20 e5 ldi r18, 0x50 ; 80 + 71b8: 2c bd out 0x2c, r18 ; 44 + SS_LOW(); + 71ba: 2a 98 cbi 0x05, 2 ; 5 + SPDR = SPI_READ; + 71bc: 2f e0 ldi r18, 0x0F ; 15 + 71be: 2e bd out 0x2e, r18 ; 46 + while(!(SPSR & _BV(SPIF))); + 71c0: 0d b4 in r0, 0x2d ; 45 + 71c2: 07 fe sbrs r0, 7 + 71c4: fd cf rjmp .-6 ; 0x71c0 + SPDR = address >> 8; + 71c6: 29 2f mov r18, r25 + 71c8: 33 27 eor r19, r19 + 71ca: 2e bd out 0x2e, r18 ; 46 + while(!(SPSR & _BV(SPIF))); + 71cc: 0d b4 in r0, 0x2d ; 45 + 71ce: 07 fe sbrs r0, 7 + 71d0: fd cf rjmp .-6 ; 0x71cc + SPDR = address & 0xff; + 71d2: 8e bd out 0x2e, r24 ; 46 + while(!(SPSR & _BV(SPIF))); + 71d4: 0d b4 in r0, 0x2d ; 45 + 71d6: 07 fe sbrs r0, 7 + 71d8: fd cf rjmp .-6 ; 0x71d4 + SPDR = 0; + 71da: 1e bc out 0x2e, r1 ; 46 + while(!(SPSR & _BV(SPIF))); + 71dc: 0d b4 in r0, 0x2d ; 45 + 71de: 07 fe sbrs r0, 7 + 71e0: fd cf rjmp .-6 ; 0x71dc + SS_HIGH(); + 71e2: 2a 9a sbi 0x05, 2 ; 5 + returnValue = SPDR; + 71e4: 8e b5 in r24, 0x2e ; 46 + SPCR = 0; + 71e6: 1c bc out 0x2c, r1 ; 44 + return(returnValue); +} + 71e8: 08 95 ret + +000071ea : + +uint16_t netReadWord(uint16_t address) +{ + 71ea: ef 92 push r14 + 71ec: ff 92 push r15 + 71ee: cf 93 push r28 + 71f0: 7c 01 movw r14, r24 + // Read uint16_t from Ethernet controller + return((netReadReg(address) << 8) | netReadReg(address + 1)); + 71f2: e1 df rcall .-62 ; 0x71b6 + 71f4: c8 2f mov r28, r24 + 71f6: c7 01 movw r24, r14 + 71f8: 01 96 adiw r24, 0x01 ; 1 + 71fa: dd df rcall .-70 ; 0x71b6 + 71fc: 2c 2f mov r18, r28 + 71fe: 30 e0 ldi r19, 0x00 ; 0 + 7200: 32 2f mov r19, r18 + 7202: 22 27 eor r18, r18 +} + 7204: a9 01 movw r20, r18 + 7206: 48 2b or r20, r24 + 7208: ca 01 movw r24, r20 + 720a: cf 91 pop r28 + 720c: ff 90 pop r15 + 720e: ef 90 pop r14 + 7210: 08 95 ret + +00007212 : + +void netWriteWord(uint16_t address, uint16_t value) +{ + 7212: cf 92 push r12 + 7214: df 92 push r13 + 7216: ef 92 push r14 + 7218: ff 92 push r15 + 721a: 7c 01 movw r14, r24 + 721c: 6b 01 movw r12, r22 + // Write uint16_t to Ethernet controller + netWriteReg(address++, value >> 8); + 721e: 67 2f mov r22, r23 + 7220: 77 27 eor r23, r23 + 7222: b0 df rcall .-160 ; 0x7184 + netWriteReg(address, value & 0xff); + 7224: 6c 2d mov r22, r12 + 7226: c7 01 movw r24, r14 + 7228: 01 96 adiw r24, 0x01 ; 1 +} + 722a: ff 90 pop r15 + 722c: ef 90 pop r14 + 722e: df 90 pop r13 + 7230: cf 90 pop r12 + +void netWriteWord(uint16_t address, uint16_t value) +{ + // Write uint16_t to Ethernet controller + netWriteReg(address++, value >> 8); + netWriteReg(address, value & 0xff); + 7232: a8 cf rjmp .-176 ; 0x7184 + +00007234 : +} + +void netInit() +{ + 7234: cf 92 push r12 + 7236: df 92 push r13 + 7238: ef 92 push r14 + 723a: ff 92 push r15 + uint8_t i; + + // Set up outputs to communicate with W5100 chip + // Set pins as output + DDRB = _BV(SCK) | _BV(MOSI) | _BV(SS); + 723c: 8c e2 ldi r24, 0x2C ; 44 + 723e: 84 b9 out 0x04, r24 ; 4 + // Set pins high + PORTB = _BV(SCK) | _BV(MISO) | _BV(MOSI) | _BV(SS); + 7240: 8c e3 ldi r24, 0x3C ; 60 + 7242: 85 b9 out 0x05, r24 ; 5 +#ifdef _ARDUINO_ETHERNET + DDRB |= _BV(LED); + 7244: 21 9a sbi 0x04, 1 ; 4 + PORTB |= _BV(LED); + 7246: 29 9a sbi 0x05, 1 ; 5 +#endif + + // Set up SPI + // Set the Double SPI Speed Bit + SPSR = (1 << SPI2X); + 7248: 81 e0 ldi r24, 0x01 ; 1 + 724a: 8d bd out 0x2d, r24 ; 45 + +#ifndef _TFTP_RANDOM_PORT + tftpPort = TFTP_STATIC_PORT; + 724c: 89 e7 ldi r24, 0x79 ; 121 + 724e: 97 eb ldi r25, 0xB7 ; 183 + 7250: 90 93 25 01 sts 0x0125, r25 + 7254: 80 93 24 01 sts 0x0124, r24 +#endif + /* Pull in altered presets + * if available from AVR EEPROM (if signature bytes are set)*/ + if((eeprom_read_byte(EEPROM_SIG_1) == EEPROM_SIG_1_VALUE) + 7258: 80 e0 ldi r24, 0x00 ; 0 + 725a: 90 e0 ldi r25, 0x00 ; 0 + 725c: b6 d3 rcall .+1900 ; 0x79ca <__eerd_byte_m328p> + 725e: 85 35 cpi r24, 0x55 ; 85 + 7260: 49 f5 brne .+82 ; 0x72b4 + && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { + 7262: 81 e0 ldi r24, 0x01 ; 1 + 7264: 90 e0 ldi r25, 0x00 ; 0 + 7266: b1 d3 rcall .+1890 ; 0x79ca <__eerd_byte_m328p> + 7268: 8a 3a cpi r24, 0xAA ; 170 + 726a: 21 f5 brne .+72 ; 0x72b4 + 726c: e1 e0 ldi r30, 0x01 ; 1 + 726e: ce 2e mov r12, r30 + 7270: e1 e0 ldi r30, 0x01 ; 1 + 7272: de 2e mov r13, r30 + 7274: f3 e0 ldi r31, 0x03 ; 3 + 7276: ef 2e mov r14, r31 + 7278: f1 2c mov r15, r1 + + for(i = 0; i < EEPROM_SETTINGS_SIZE; i++) + registerBuffer[i+1] = eeprom_read_byte(EEPROM_DATA+i); + 727a: c7 01 movw r24, r14 + 727c: a6 d3 rcall .+1868 ; 0x79ca <__eerd_byte_m328p> + 727e: f6 01 movw r30, r12 + 7280: 81 93 st Z+, r24 + 7282: 6f 01 movw r12, r30 + 7284: ff ef ldi r31, 0xFF ; 255 + 7286: ef 1a sub r14, r31 + 7288: ff 0a sbc r15, r31 + /* Pull in altered presets + * if available from AVR EEPROM (if signature bytes are set)*/ + if((eeprom_read_byte(EEPROM_SIG_1) == EEPROM_SIG_1_VALUE) + && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { + + for(i = 0; i < EEPROM_SETTINGS_SIZE; i++) + 728a: 85 e1 ldi r24, 0x15 ; 21 + 728c: e8 16 cp r14, r24 + 728e: f1 04 cpc r15, r1 + 7290: a1 f7 brne .-24 ; 0x727a + registerBuffer[i+1] = eeprom_read_byte(EEPROM_DATA+i); +#ifndef _TFTP_RANDOM_PORT + tftpPort = ((eeprom_read_byte(EEPROM_PORT+1)<<8) + eeprom_read_byte(EEPROM_PORT)); + 7292: 86 e1 ldi r24, 0x16 ; 22 + 7294: 90 e0 ldi r25, 0x00 ; 0 + 7296: 99 d3 rcall .+1842 ; 0x79ca <__eerd_byte_m328p> + 7298: f8 2e mov r15, r24 + 729a: 85 e1 ldi r24, 0x15 ; 21 + 729c: 90 e0 ldi r25, 0x00 ; 0 + 729e: 95 d3 rcall .+1834 ; 0x79ca <__eerd_byte_m328p> + 72a0: 2f 2d mov r18, r15 + 72a2: 30 e0 ldi r19, 0x00 ; 0 + 72a4: 32 2f mov r19, r18 + 72a6: 22 27 eor r18, r18 + 72a8: 28 0f add r18, r24 + 72aa: 31 1d adc r19, r1 + 72ac: 30 93 25 01 sts 0x0125, r19 + 72b0: 20 93 24 01 sts 0x0124, r18 + 72b4: 60 e0 ldi r22, 0x00 ; 0 + 72b6: c6 2e mov r12, r22 + 72b8: 61 e0 ldi r22, 0x01 ; 1 + 72ba: d6 2e mov r13, r22 + tftpPort = TFTP_STATIC_PORT; +#endif + /* Pull in altered presets + * if available from AVR EEPROM (if signature bytes are set)*/ + if((eeprom_read_byte(EEPROM_SIG_1) == EEPROM_SIG_1_VALUE) + && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { + 72bc: e1 2c mov r14, r1 + 72be: f1 2c mov r15, r1 +#endif +#endif + + // Configure Wiznet chip + for(i = 0; i < REGISTER_BLOCK_SIZE; i++) + netWriteReg(i, registerBuffer[i]); + 72c0: f6 01 movw r30, r12 + 72c2: 61 91 ld r22, Z+ + 72c4: 6f 01 movw r12, r30 + 72c6: c7 01 movw r24, r14 + 72c8: 5d df rcall .-326 ; 0x7184 + 72ca: ff ef ldi r31, 0xFF ; 255 + 72cc: ef 1a sub r14, r31 + 72ce: ff 0a sbc r15, r31 + tracenum(tftpPort); +#endif +#endif + + // Configure Wiznet chip + for(i = 0; i < REGISTER_BLOCK_SIZE; i++) + 72d0: 8c e1 ldi r24, 0x1C ; 28 + 72d2: e8 16 cp r14, r24 + 72d4: f1 04 cpc r15, r1 + 72d6: a1 f7 brne .-24 ; 0x72c0 + netWriteReg(i, registerBuffer[i]); +#ifdef _VERBOSE + traceln(" Net: Network init done"); +#endif +} + 72d8: ff 90 pop r15 + 72da: ef 90 pop r14 + 72dc: df 90 pop r13 + 72de: cf 90 pop r12 + 72e0: 08 95 ret + +000072e2 : +#ifdef _DEBUG_TFTP +uint8_t processPacket(uint16_t packetSize) +{ +#else +uint8_t processPacket() +{ + 72e2: af 92 push r10 + 72e4: bf 92 push r11 + 72e6: cf 92 push r12 + 72e8: df 92 push r13 + 72ea: ef 92 push r14 + 72ec: ff 92 push r15 + 72ee: cf 93 push r28 + 72f0: df 93 push r29 + 72f2: cd b7 in r28, 0x3d ; 61 + 72f4: de b7 in r29, 0x3e ; 62 + 72f6: cc 50 subi r28, 0x0C ; 12 + 72f8: d2 40 sbci r29, 0x02 ; 2 + 72fa: de bf out 0x3e, r29 ; 62 + 72fc: cd bf out 0x3d, r28 ; 61 + tracenum(packetSize); + if(packetSize >= 0x800) traceln("Tftp: Overflow"); + // step(); +#endif + + readPointer = netReadWord(REG_S3_RX_RD0); + 72fe: 88 e2 ldi r24, 0x28 ; 40 + 7300: 97 e0 ldi r25, 0x07 ; 7 + 7302: 73 df rcall .-282 ; 0x71ea +#ifdef _DEBUG_TFTP + traceln("Tftp: readPointer at position "); + tracenum(readPointer); +#endif + if(readPointer == 0) readPointer += S3_RX_START; + 7304: 00 97 sbiw r24, 0x00 ; 0 + 7306: 11 f4 brne .+4 ; 0x730c + 7308: 80 e0 ldi r24, 0x00 ; 0 + 730a: 98 e7 ldi r25, 0x78 ; 120 + 730c: ee 24 eor r14, r14 + 730e: e3 94 inc r14 + 7310: f1 2c mov r15, r1 + 7312: ec 0e add r14, r28 + 7314: fd 1e adc r15, r29 + +#ifdef _DEBUG_TFTP +uint8_t processPacket(uint16_t packetSize) +{ +#else +uint8_t processPacket() + 7316: 5e 01 movw r10, r28 + 7318: 23 ef ldi r18, 0xF3 ; 243 + 731a: a2 1a sub r10, r18 + 731c: 2d ef ldi r18, 0xFD ; 253 + 731e: b2 0a sbc r11, r18 + if((count == TFTP_PACKET_MAX_SIZE - 1) || (count == 0)) { + traceln("Tftp: Reading from position "); + tracenum(readPointer); + } +#endif + *bufPtr++ = netReadReg(readPointer++); + 7320: 6c 01 movw r12, r24 + 7322: ef ef ldi r30, 0xFF ; 255 + 7324: ce 1a sub r12, r30 + 7326: de 0a sbc r13, r30 + 7328: 46 df rcall .-372 ; 0x71b6 + 732a: f7 01 movw r30, r14 + 732c: 81 93 st Z+, r24 + 732e: 7f 01 movw r14, r30 + if(readPointer == S3_RX_END) readPointer = S3_RX_START; + 7330: c1 14 cp r12, r1 + 7332: f0 e8 ldi r31, 0x80 ; 128 + 7334: df 06 cpc r13, r31 + 7336: 11 f0 breq .+4 ; 0x733c + 7338: c6 01 movw r24, r12 + 733a: 02 c0 rjmp .+4 ; 0x7340 + 733c: 80 e0 ldi r24, 0x00 ; 0 + 733e: 98 e7 ldi r25, 0x78 ; 120 +#ifdef _DEBUG_TFTP + traceln("Tftp: readPointer at position "); + tracenum(readPointer); +#endif + if(readPointer == 0) readPointer += S3_RX_START; + for(count = TFTP_PACKET_MAX_SIZE; count--;) { + 7340: ea 14 cp r14, r10 + 7342: fb 04 cpc r15, r11 + 7344: 69 f7 brne .-38 ; 0x7320 + } +#endif + *bufPtr++ = netReadReg(readPointer++); + if(readPointer == S3_RX_END) readPointer = S3_RX_START; + } + netWriteWord(REG_S3_RX_RD0, readPointer); // Write back new pointer + 7346: bc 01 movw r22, r24 + 7348: 88 e2 ldi r24, 0x28 ; 40 + 734a: 97 e0 ldi r25, 0x07 ; 7 + 734c: 62 df rcall .-316 ; 0x7212 + netWriteReg(REG_S3_CR, CR_RECV); + 734e: 60 e4 ldi r22, 0x40 ; 64 + 7350: 81 e0 ldi r24, 0x01 ; 1 + 7352: 97 e0 ldi r25, 0x07 ; 7 + 7354: 17 df rcall .-466 ; 0x7184 + while(netReadReg(REG_S3_CR)); + 7356: 81 e0 ldi r24, 0x01 ; 1 + 7358: 97 e0 ldi r25, 0x07 ; 7 + 735a: 2d df rcall .-422 ; 0x71b6 + 735c: 81 11 cpse r24, r1 + 735e: fb cf rjmp .-10 ; 0x7356 + 7360: cc 24 eor r12, r12 + 7362: c3 94 inc r12 + 7364: d1 2c mov r13, r1 + 7366: cc 0e add r12, r28 + 7368: dd 1e adc r13, r29 + 736a: 6c e0 ldi r22, 0x0C ; 12 + 736c: e6 2e mov r14, r22 + 736e: 67 e0 ldi r22, 0x07 ; 7 + 7370: f6 2e mov r15, r22 + traceln("Tftp: Setting return address"); +#endif + + // Set up return IP address and port + uint8_t i; + for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); + 7372: f6 01 movw r30, r12 + 7374: 61 91 ld r22, Z+ + 7376: 6f 01 movw r12, r30 + 7378: c7 01 movw r24, r14 + 737a: 04 df rcall .-504 ; 0x7184 + 737c: ff ef ldi r31, 0xFF ; 255 + 737e: ef 1a sub r14, r31 + 7380: ff 0a sbc r15, r31 + 7382: 22 e1 ldi r18, 0x12 ; 18 + 7384: e2 16 cp r14, r18 + 7386: 27 e0 ldi r18, 0x07 ; 7 + 7388: f2 06 cpc r15, r18 + 738a: 99 f7 brne .-26 ; 0x7372 + + // Parse packet + uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; + 738c: ef 80 ldd r14, Y+7 ; 0x07 + 738e: 28 85 ldd r18, Y+8 ; 0x08 + uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; + uint16_t tftpBlock = (buffer[10] << 8) + buffer[11]; + 7390: cb 84 ldd r12, Y+11 ; 0x0b + 7392: 3c 85 ldd r19, Y+12 ; 0x0c + uint8_t i; + for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); + + // Parse packet + uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; + uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; + 7394: 89 85 ldd r24, Y+9 ; 0x09 + 7396: 90 e0 ldi r25, 0x00 ; 0 + 7398: 98 2f mov r25, r24 + 739a: 88 27 eor r24, r24 + 739c: 4a 85 ldd r20, Y+10 ; 0x0a + 739e: 84 0f add r24, r20 + 73a0: 91 1d adc r25, r1 + + uint8_t returnCode = ERROR_UNKNOWN; + uint16_t packetLength; + + + switch(tftpOpcode) { + 73a2: 83 30 cpi r24, 0x03 ; 3 + 73a4: 91 05 cpc r25, r1 + 73a6: d9 f1 breq .+118 ; 0x741e + 73a8: 38 f4 brcc .+14 ; 0x73b8 + 73aa: 81 30 cpi r24, 0x01 ; 1 + 73ac: 91 05 cpc r25, r1 + 73ae: 39 f0 breq .+14 ; 0x73be + 73b0: 02 97 sbiw r24, 0x02 ; 2 + 73b2: 09 f0 breq .+2 ; 0x73b6 + 73b4: a3 c0 rjmp .+326 ; 0x74fc + 73b6: 05 c0 rjmp .+10 ; 0x73c2 + 73b8: 06 97 sbiw r24, 0x06 ; 6 + 73ba: 08 f0 brcs .+2 ; 0x73be + 73bc: 9f c0 rjmp .+318 ; 0x74fc + tracenum(tftpOpcode); + trace(" and data length "); + tracenum(tftpDataLen - (TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE)); +#endif + + uint8_t returnCode = ERROR_UNKNOWN; + 73be: 80 e0 ldi r24, 0x00 ; 0 + 73c0: a4 c0 rjmp .+328 ; 0x750a + case TFTP_OPCODE_WRQ: // Write request +#ifdef _VERBOSE + traceln("Tftp: Write request"); +#endif + // Flagging image as invalid since the flashing process has started + eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_BAD_VALUE); + 73c2: 6f ef ldi r22, 0xFF ; 255 + 73c4: 82 e0 ldi r24, 0x02 ; 2 + 73c6: 90 e0 ldi r25, 0x00 ; 0 + 73c8: 08 d3 rcall .+1552 ; 0x79da <__eewr_byte_m328p> + netWriteReg(REG_S3_CR, CR_RECV); + 73ca: 60 e4 ldi r22, 0x40 ; 64 + 73cc: 81 e0 ldi r24, 0x01 ; 1 + 73ce: 97 e0 ldi r25, 0x07 ; 7 + 73d0: d9 de rcall .-590 ; 0x7184 + netWriteReg(REG_S3_CR, CR_CLOSE); + 73d2: 60 e1 ldi r22, 0x10 ; 16 + 73d4: 81 e0 ldi r24, 0x01 ; 1 + 73d6: 97 e0 ldi r25, 0x07 ; 7 + 73d8: d5 de rcall .-598 ; 0x7184 + do { + netWriteReg(REG_S3_MR, MR_UDP); + 73da: 62 e0 ldi r22, 0x02 ; 2 + 73dc: 80 e0 ldi r24, 0x00 ; 0 + 73de: 97 e0 ldi r25, 0x07 ; 7 + 73e0: d1 de rcall .-606 ; 0x7184 + netWriteReg(REG_S3_CR, CR_OPEN); + 73e2: 61 e0 ldi r22, 0x01 ; 1 + 73e4: 81 e0 ldi r24, 0x01 ; 1 + 73e6: 97 e0 ldi r25, 0x07 ; 7 + 73e8: cd de rcall .-614 ; 0x7184 +#ifdef _TFTP_RANDOM_PORT + netWriteWord(REG_S3_PORT0, (buffer[4]<<8) | ~buffer[5]); // Generate a 'random' TID (RFC1350) +#else + netWriteWord(REG_S3_PORT0, tftpPort); + 73ea: 60 91 24 01 lds r22, 0x0124 + 73ee: 70 91 25 01 lds r23, 0x0125 + 73f2: 84 e0 ldi r24, 0x04 ; 4 + 73f4: 97 e0 ldi r25, 0x07 ; 7 + 73f6: 0d df rcall .-486 ; 0x7212 +#endif + if(netReadReg(REG_S3_SR) != SOCK_UDP) + 73f8: 83 e0 ldi r24, 0x03 ; 3 + 73fa: 97 e0 ldi r25, 0x07 ; 7 + 73fc: dc de rcall .-584 ; 0x71b6 + 73fe: 82 32 cpi r24, 0x22 ; 34 + 7400: 21 f0 breq .+8 ; 0x740a + netWriteReg(REG_S3_CR, CR_CLOSE); + 7402: 60 e1 ldi r22, 0x10 ; 16 + 7404: 81 e0 ldi r24, 0x01 ; 1 + 7406: 97 e0 ldi r25, 0x07 ; 7 + 7408: bd de rcall .-646 ; 0x7184 + } while(netReadReg(REG_S3_SR) != SOCK_UDP); + 740a: 83 e0 ldi r24, 0x03 ; 3 + 740c: 97 e0 ldi r25, 0x07 ; 7 + 740e: d3 de rcall .-602 ; 0x71b6 + 7410: 82 32 cpi r24, 0x22 ; 34 + 7412: 19 f7 brne .-58 ; 0x73da + tracenum((buffer[4]<<8) | (buffer[5]^0x55)); +#else + tracenum(tftpPort); +#endif +#endif + lastPacket = 0; + 7414: 10 92 1f 01 sts 0x011F, r1 + 7418: 10 92 1e 01 sts 0x011E, r1 + 741c: 75 c0 rjmp .+234 ; 0x7508 + for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); + + // Parse packet + uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; + uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; + uint16_t tftpBlock = (buffer[10] << 8) + buffer[11]; + 741e: d1 2c mov r13, r1 + 7420: dc 2c mov r13, r12 + 7422: cc 24 eor r12, r12 + 7424: c3 0e add r12, r19 + 7426: d1 1c adc r13, r1 + // Set up return IP address and port + uint8_t i; + for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); + + // Parse packet + uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; + 7428: f1 2c mov r15, r1 + 742a: fe 2c mov r15, r14 + 742c: ee 24 eor r14, r14 + 742e: e2 0e add r14, r18 + 7430: f1 1c adc r15, r1 + lastPacket = 0; + returnCode = ACK; // Send back acknowledge for packet 0 + break; + + case TFTP_OPCODE_DATA: + packetLength = tftpDataLen - (TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); + 7432: 84 e0 ldi r24, 0x04 ; 4 + 7434: e8 1a sub r14, r24 + 7436: f1 08 sbc r15, r1 + lastPacket = tftpBlock; + 7438: d0 92 1f 01 sts 0x011F, r13 + 743c: c0 92 1e 01 sts 0x011E, r12 + writeAddr = (tftpBlock - 1) << 9; // Flash write address for this block + 7440: e1 e0 ldi r30, 0x01 ; 1 + 7442: ce 1a sub r12, r30 + 7444: d1 08 sbc r13, r1 + 7446: dc 2c mov r13, r12 + 7448: cc 24 eor r12, r12 + 744a: dd 0c add r13, r13 +#ifdef _VERBOSE + traceln("Tftp: Data for block "); + tracenum(lastPacket); +#endif + + if((writeAddr + packetLength) > MAX_ADDR) { + 744c: c6 01 movw r24, r12 + 744e: 8e 0d add r24, r14 + 7450: 9f 1d adc r25, r15 + 7452: 81 30 cpi r24, 0x01 ; 1 + 7454: 90 47 sbci r25, 0x70 ; 112 + 7456: 08 f0 brcs .+2 ; 0x745a + 7458: 53 c0 rjmp .+166 ; 0x7500 + 745a: 03 c0 rjmp .+6 ; 0x7462 + + uint8_t *pageBase = buffer + (UDP_HEADER_SIZE + TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); // Start of block data + uint16_t offset = 0; // Block offset + + // Round up packet length to a full flash sector size + while(packetLength % SPM_PAGESIZE) packetLength++; + 745c: 2f ef ldi r18, 0xFF ; 255 + 745e: e2 1a sub r14, r18 + 7460: f2 0a sbc r15, r18 + 7462: c7 01 movw r24, r14 + 7464: 8f 77 andi r24, 0x7F ; 127 + 7466: 99 27 eor r25, r25 + 7468: 89 2b or r24, r25 + 746a: c1 f7 brne .-16 ; 0x745c +#ifdef _DEBUG_TFTP + traceln("Tftp: Packet length adjusted to "); + tracenum(packetLength); +#endif + if(writeAddr == 0) { + 746c: c1 14 cp r12, r1 + 746e: d1 04 cpc r13, r1 + 7470: 31 f4 brne .+12 ; 0x747e + // First sector - validate + if(!validImage(pageBase)) { + 7472: ce 01 movw r24, r28 + 7474: 0d 96 adiw r24, 0x0d ; 13 + 7476: 24 d1 rcall .+584 ; 0x76c0 + 7478: 88 23 and r24, r24 + 747a: 09 f4 brne .+2 ; 0x747e + 747c: 43 c0 rjmp .+134 ; 0x7504 +#ifdef _DEBUG_TFTP + traceln("Tftp: Writing data from address "); + tracenum(writeAddr); +#endif + + uint8_t *pageBase = buffer + (UDP_HEADER_SIZE + TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); // Start of block data + 747e: de 01 movw r26, r28 + 7480: 1d 96 adiw r26, 0x0d ; 13 +#endif + } + } + + // Flash packets + for(offset = 0; offset < packetLength;) { + 7482: 80 e0 ldi r24, 0x00 ; 0 + 7484: 90 e0 ldi r25, 0x00 ; 0 + uint16_t writeValue = (pageBase[offset]) | (pageBase[offset + 1] << 8); + boot_page_fill(writeAddr + offset, writeValue); + 7486: 41 e0 ldi r20, 0x01 ; 1 + tracenum(writeAddr + offset); + } +#endif + offset += 2; + if(offset % SPM_PAGESIZE == 0) { + boot_page_erase(writeAddr + offset - SPM_PAGESIZE); + 7488: 53 e0 ldi r21, 0x03 ; 3 + boot_spm_busy_wait(); + boot_page_write(writeAddr + offset - SPM_PAGESIZE); + 748a: 65 e0 ldi r22, 0x05 ; 5 + boot_spm_busy_wait(); + boot_rww_enable(); + 748c: 71 e1 ldi r23, 0x11 ; 17 +#endif + } + } + + // Flash packets + for(offset = 0; offset < packetLength;) { + 748e: 29 c0 rjmp .+82 ; 0x74e2 + +#ifdef _DEBUG_TFTP +uint8_t processPacket(uint16_t packetSize) +{ +#else +uint8_t processPacket() + 7490: e1 e0 ldi r30, 0x01 ; 1 + 7492: f0 e0 ldi r31, 0x00 ; 0 + 7494: ec 0f add r30, r28 + 7496: fd 1f adc r31, r29 + 7498: e8 0f add r30, r24 + 749a: f9 1f adc r31, r25 + } + } + + // Flash packets + for(offset = 0; offset < packetLength;) { + uint16_t writeValue = (pageBase[offset]) | (pageBase[offset + 1] << 8); + 749c: 25 85 ldd r18, Z+13 ; 0x0d + 749e: 30 e0 ldi r19, 0x00 ; 0 + 74a0: 32 2f mov r19, r18 + 74a2: 22 27 eor r18, r18 + 74a4: ec 91 ld r30, X + 74a6: 2e 2b or r18, r30 + boot_page_fill(writeAddr + offset, writeValue); + 74a8: f6 01 movw r30, r12 + 74aa: 09 01 movw r0, r18 + 74ac: 47 bf out 0x37, r20 ; 55 + 74ae: e8 95 spm + 74b0: 11 24 eor r1, r1 + tracenum(writeValue); + trace(" at offset "); + tracenum(writeAddr + offset); + } +#endif + offset += 2; + 74b2: 02 96 adiw r24, 0x02 ; 2 + if(offset % SPM_PAGESIZE == 0) { + 74b4: 9c 01 movw r18, r24 + 74b6: 2f 77 andi r18, 0x7F ; 127 + 74b8: 33 27 eor r19, r19 + 74ba: 23 2b or r18, r19 + 74bc: 71 f4 brne .+28 ; 0x74da + boot_page_erase(writeAddr + offset - SPM_PAGESIZE); + 74be: ee 57 subi r30, 0x7E ; 126 + 74c0: f1 09 sbc r31, r1 + 74c2: 57 bf out 0x37, r21 ; 55 + 74c4: e8 95 spm + boot_spm_busy_wait(); + 74c6: 07 b6 in r0, 0x37 ; 55 + 74c8: 00 fc sbrc r0, 0 + 74ca: fd cf rjmp .-6 ; 0x74c6 + boot_page_write(writeAddr + offset - SPM_PAGESIZE); + 74cc: 67 bf out 0x37, r22 ; 55 + 74ce: e8 95 spm + boot_spm_busy_wait(); + 74d0: 07 b6 in r0, 0x37 ; 55 + 74d2: 00 fc sbrc r0, 0 + 74d4: fd cf rjmp .-6 ; 0x74d0 + boot_rww_enable(); + 74d6: 77 bf out 0x37, r23 ; 55 + 74d8: e8 95 spm + 74da: 12 96 adiw r26, 0x02 ; 2 + 74dc: f2 e0 ldi r31, 0x02 ; 2 + 74de: cf 0e add r12, r31 + 74e0: d1 1c adc r13, r1 +#endif + } + } + + // Flash packets + for(offset = 0; offset < packetLength;) { + 74e2: 8e 15 cp r24, r14 + 74e4: 9f 05 cpc r25, r15 + 74e6: a0 f2 brcs .-88 ; 0x7490 + boot_spm_busy_wait(); + boot_rww_enable(); + } + } + + if(packetLength < TFTP_DATA_SIZE) { + 74e8: e1 14 cp r14, r1 + 74ea: 22 e0 ldi r18, 0x02 ; 2 + 74ec: f2 06 cpc r15, r18 + 74ee: 60 f4 brcc .+24 ; 0x7508 + // Hand over to application +#ifdef _VERBOSE + traceln("Tftp: Flash is complete"); +#endif + // Flag the image as valid since we received the last packet + eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); + 74f0: 6b eb ldi r22, 0xBB ; 187 + 74f2: 82 e0 ldi r24, 0x02 ; 2 + 74f4: 90 e0 ldi r25, 0x00 ; 0 + 74f6: 71 d2 rcall .+1250 ; 0x79da <__eewr_byte_m328p> + returnCode = FINAL_ACK; + 74f8: 84 e0 ldi r24, 0x04 ; 4 + 74fa: 07 c0 rjmp .+14 ; 0x750a +#ifdef _DEBUG_TFTP + traceln("Tftp: Invalid opcode "); + tracenum(tftpOpcode); +#endif + // Invalid - return error + returnCode = ERROR_INVALID; + 74fc: 81 e0 ldi r24, 0x01 ; 1 + 74fe: 05 c0 rjmp .+10 ; 0x750a + // Flash is full - abort with an error before a bootloader overwrite occurs + // Application is now corrupt, so do not hand over. +#ifdef _VERBOSE + traceln("Tftp: Flash is full"); +#endif + returnCode = ERROR_FULL; + 7500: 83 e0 ldi r24, 0x03 ; 3 + 7502: 03 c0 rjmp .+6 ; 0x750a + tracenum(packetLength); +#endif + if(writeAddr == 0) { + // First sector - validate + if(!validImage(pageBase)) { + returnCode = INVALID_IMAGE; + 7504: 85 e0 ldi r24, 0x05 ; 5 + 7506: 01 c0 rjmp .+2 ; 0x750a +#endif + // Flag the image as valid since we received the last packet + eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); + returnCode = FINAL_ACK; + } else { + returnCode = ACK; + 7508: 82 e0 ldi r24, 0x02 ; 2 + returnCode = ERROR_INVALID; + break; + + } + return(returnCode); +} + 750a: c4 5f subi r28, 0xF4 ; 244 + 750c: dd 4f sbci r29, 0xFD ; 253 + 750e: de bf out 0x3e, r29 ; 62 + 7510: cd bf out 0x3d, r28 ; 61 + 7512: df 91 pop r29 + 7514: cf 91 pop r28 + 7516: ff 90 pop r15 + 7518: ef 90 pop r14 + 751a: df 90 pop r13 + 751c: cf 90 pop r12 + 751e: bf 90 pop r11 + 7520: af 90 pop r10 + 7522: 08 95 ret + +00007524 : + + +void sendResponse(uint16_t response) +{ + 7524: af 92 push r10 + 7526: bf 92 push r11 + 7528: cf 92 push r12 + 752a: df 92 push r13 + 752c: ef 92 push r14 + 752e: ff 92 push r15 + 7530: 1f 93 push r17 + 7532: cf 93 push r28 + 7534: df 93 push r29 + 7536: cd b7 in r28, 0x3d ; 61 + 7538: de b7 in r29, 0x3e ; 62 + 753a: c4 56 subi r28, 0x64 ; 100 + 753c: d1 09 sbc r29, r1 + 753e: de bf out 0x3e, r29 ; 62 + 7540: cd bf out 0x3d, r28 ; 61 + 7542: 7c 01 movw r14, r24 + uint8_t txBuffer[100]; + uint8_t *txPtr = txBuffer; + uint8_t packetLength; + uint16_t writePointer; + + writePointer = netReadWord(REG_S3_TX_WR0) + S3_TX_START; + 7544: 84 e2 ldi r24, 0x24 ; 36 + 7546: 97 e0 ldi r25, 0x07 ; 7 + 7548: 50 de rcall .-864 ; 0x71ea + 754a: 98 5a subi r25, 0xA8 ; 168 + 754c: 6c 01 movw r12, r24 + switch(response) { + 754e: 82 e0 ldi r24, 0x02 ; 2 + 7550: e8 16 cp r14, r24 + 7552: f1 04 cpc r15, r1 + 7554: 79 f1 breq .+94 ; 0x75b4 + 7556: 20 f4 brcc .+8 ; 0x7560 + 7558: ea 94 dec r14 + 755a: ef 28 or r14, r15 + 755c: 49 f4 brne .+18 ; 0x7570 + 755e: 18 c0 rjmp .+48 ; 0x7590 + 7560: 83 e0 ldi r24, 0x03 ; 3 + 7562: e8 16 cp r14, r24 + 7564: f1 04 cpc r15, r1 + 7566: e9 f0 breq .+58 ; 0x75a2 + 7568: e4 e0 ldi r30, 0x04 ; 4 + 756a: ee 16 cp r14, r30 + 756c: f1 04 cpc r15, r1 + 756e: 11 f1 breq .+68 ; 0x75b4 + default: + + case ERROR_UNKNOWN: + // Send unknown error packet + packetLength = TFTP_UNKNOWN_ERROR_LEN; + memcpy_P(txBuffer, tftp_unknown_error_packet, packetLength); + 7570: 4a e0 ldi r20, 0x0A ; 10 + 7572: 50 e0 ldi r21, 0x00 ; 0 + 7574: 60 e8 ldi r22, 0x80 ; 128 + 7576: 70 e7 ldi r23, 0x70 ; 112 + 7578: ce 01 movw r24, r28 + 757a: 01 96 adiw r24, 0x01 ; 1 + 757c: 1d d2 rcall .+1082 ; 0x79b8 + switch(response) { + default: + + case ERROR_UNKNOWN: + // Send unknown error packet + packetLength = TFTP_UNKNOWN_ERROR_LEN; + 757e: 8a e0 ldi r24, 0x0A ; 10 + } + + txPtr = txBuffer; + while(packetLength--) { + netWriteReg(writePointer++, *txPtr++); + if(writePointer == S3_TX_END) writePointer = S3_TX_START; + 7580: ee 24 eor r14, r14 + 7582: e3 94 inc r14 + 7584: f1 2c mov r15, r1 + 7586: ec 0e add r14, r28 + 7588: fd 1e adc r15, r29 + } + return(returnCode); +} + + +void sendResponse(uint16_t response) + 758a: 18 2f mov r17, r24 + 758c: 1e 0d add r17, r14 + 758e: 2e c0 rjmp .+92 ; 0x75ec + break; + + case ERROR_INVALID: + // Send invalid opcode packet + packetLength = TFTP_OPCODE_ERROR_LEN; + memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); + 7590: 4c e0 ldi r20, 0x0C ; 12 + 7592: 50 e0 ldi r21, 0x00 ; 0 + 7594: 65 e9 ldi r22, 0x95 ; 149 + 7596: 70 e7 ldi r23, 0x70 ; 112 + 7598: ce 01 movw r24, r28 + 759a: 01 96 adiw r24, 0x01 ; 1 + 759c: 0d d2 rcall .+1050 ; 0x79b8 + memcpy_P(txBuffer, tftp_unknown_error_packet, packetLength); + break; + + case ERROR_INVALID: + // Send invalid opcode packet + packetLength = TFTP_OPCODE_ERROR_LEN; + 759e: 8c e0 ldi r24, 0x0C ; 12 + memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); + break; + 75a0: ef cf rjmp .-34 ; 0x7580 + + case ERROR_FULL: + // Send unknown error packet + packetLength = TFTP_FULL_ERROR_LEN; + memcpy_P(txBuffer, tftp_full_error_packet, packetLength); + 75a2: 49 e0 ldi r20, 0x09 ; 9 + 75a4: 50 e0 ldi r21, 0x00 ; 0 + 75a6: 6b e8 ldi r22, 0x8B ; 139 + 75a8: 70 e7 ldi r23, 0x70 ; 112 + 75aa: ce 01 movw r24, r28 + 75ac: 01 96 adiw r24, 0x01 ; 1 + 75ae: 04 d2 rcall .+1032 ; 0x79b8 + memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); + break; + + case ERROR_FULL: + // Send unknown error packet + packetLength = TFTP_FULL_ERROR_LEN; + 75b0: 89 e0 ldi r24, 0x09 ; 9 + memcpy_P(txBuffer, tftp_full_error_packet, packetLength); + break; + 75b2: e6 cf rjmp .-52 ; 0x7580 + traceln("Tftp: Sent Final ACK "); + tracenum(lastPacket); + } +#endif + packetLength = 4; + *txPtr++ = TFTP_OPCODE_ACK >> 8; + 75b4: 19 82 std Y+1, r1 ; 0x01 + *txPtr++ = TFTP_OPCODE_ACK & 0xff; + 75b6: 84 e0 ldi r24, 0x04 ; 4 + 75b8: 8a 83 std Y+2, r24 ; 0x02 + // lastPacket is block code + *txPtr++ = lastPacket >> 8; + 75ba: 80 91 1e 01 lds r24, 0x011E + 75be: 90 91 1f 01 lds r25, 0x011F + 75c2: 9b 83 std Y+3, r25 ; 0x03 + *txPtr = lastPacket & 0xff; + 75c4: 8c 83 std Y+4, r24 ; 0x04 + if(response == FINAL_ACK) { + traceln("Tftp: Sent Final ACK "); + tracenum(lastPacket); + } +#endif + packetLength = 4; + 75c6: 84 e0 ldi r24, 0x04 ; 4 + *txPtr++ = TFTP_OPCODE_ACK >> 8; + *txPtr++ = TFTP_OPCODE_ACK & 0xff; + // lastPacket is block code + *txPtr++ = lastPacket >> 8; + *txPtr = lastPacket & 0xff; + break; + 75c8: db cf rjmp .-74 ; 0x7580 + } + + txPtr = txBuffer; + while(packetLength--) { + netWriteReg(writePointer++, *txPtr++); + 75ca: f7 01 movw r30, r14 + 75cc: 61 91 ld r22, Z+ + 75ce: 7f 01 movw r14, r30 + 75d0: 56 01 movw r10, r12 + 75d2: ff ef ldi r31, 0xFF ; 255 + 75d4: af 1a sub r10, r31 + 75d6: bf 0a sbc r11, r31 + 75d8: c6 01 movw r24, r12 + 75da: d4 dd rcall .-1112 ; 0x7184 + if(writePointer == S3_TX_END) writePointer = S3_TX_START; + 75dc: a1 14 cp r10, r1 + 75de: 80 e6 ldi r24, 0x60 ; 96 + 75e0: b8 06 cpc r11, r24 + 75e2: 19 f4 brne .+6 ; 0x75ea + 75e4: a1 2c mov r10, r1 + 75e6: e8 e5 ldi r30, 0x58 ; 88 + 75e8: be 2e mov r11, r30 + 75ea: 65 01 movw r12, r10 + *txPtr = lastPacket & 0xff; + break; + } + + txPtr = txBuffer; + while(packetLength--) { + 75ec: 1e 11 cpse r17, r14 + 75ee: ed cf rjmp .-38 ; 0x75ca + netWriteReg(writePointer++, *txPtr++); + if(writePointer == S3_TX_END) writePointer = S3_TX_START; + } + netWriteWord(REG_S3_TX_WR0, writePointer - S3_TX_START); + 75f0: b6 01 movw r22, r12 + 75f2: 78 55 subi r23, 0x58 ; 88 + 75f4: 84 e2 ldi r24, 0x24 ; 36 + 75f6: 97 e0 ldi r25, 0x07 ; 7 + 75f8: 0c de rcall .-1000 ; 0x7212 + netWriteReg(REG_S3_CR, CR_SEND); + 75fa: 60 e2 ldi r22, 0x20 ; 32 + 75fc: 81 e0 ldi r24, 0x01 ; 1 + 75fe: 97 e0 ldi r25, 0x07 ; 7 + 7600: c1 dd rcall .-1150 ; 0x7184 + while(netReadReg(REG_S3_CR)); + 7602: 81 e0 ldi r24, 0x01 ; 1 + 7604: 97 e0 ldi r25, 0x07 ; 7 + 7606: d7 dd rcall .-1106 ; 0x71b6 + 7608: 81 11 cpse r24, r1 + 760a: fb cf rjmp .-10 ; 0x7602 +#ifdef _VERBOSE + traceln("Tftp: Response sent"); +#endif +} + 760c: cc 59 subi r28, 0x9C ; 156 + 760e: df 4f sbci r29, 0xFF ; 255 + 7610: de bf out 0x3e, r29 ; 62 + 7612: cd bf out 0x3d, r28 ; 61 + 7614: df 91 pop r29 + 7616: cf 91 pop r28 + 7618: 1f 91 pop r17 + 761a: ff 90 pop r15 + 761c: ef 90 pop r14 + 761e: df 90 pop r13 + 7620: cf 90 pop r12 + 7622: bf 90 pop r11 + 7624: af 90 pop r10 + 7626: 08 95 ret + +00007628 : +void tftpInit() +{ + // Open socket + do { + // Write TFTP Port + netWriteWord(REG_S3_PORT0, TFTP_PORT); + 7628: 65 e4 ldi r22, 0x45 ; 69 + 762a: 70 e0 ldi r23, 0x00 ; 0 + 762c: 84 e0 ldi r24, 0x04 ; 4 + 762e: 97 e0 ldi r25, 0x07 ; 7 + 7630: f0 dd rcall .-1056 ; 0x7212 + // Write mode + netWriteReg(REG_S3_MR, MR_UDP); + 7632: 62 e0 ldi r22, 0x02 ; 2 + 7634: 80 e0 ldi r24, 0x00 ; 0 + 7636: 97 e0 ldi r25, 0x07 ; 7 + 7638: a5 dd rcall .-1206 ; 0x7184 + // Open Socket + netWriteReg(REG_S3_CR, CR_OPEN); + 763a: 61 e0 ldi r22, 0x01 ; 1 + 763c: 81 e0 ldi r24, 0x01 ; 1 + 763e: 97 e0 ldi r25, 0x07 ; 7 + 7640: a1 dd rcall .-1214 ; 0x7184 + // Read Status + if(netReadReg(REG_S3_SR) != SOCK_UDP) + 7642: 83 e0 ldi r24, 0x03 ; 3 + 7644: 97 e0 ldi r25, 0x07 ; 7 + 7646: b7 dd rcall .-1170 ; 0x71b6 + 7648: 82 32 cpi r24, 0x22 ; 34 + 764a: 21 f0 breq .+8 ; 0x7654 + // Close Socket if it wasn't initialized correctly + netWriteReg(REG_S3_CR, CR_CLOSE); + 764c: 60 e1 ldi r22, 0x10 ; 16 + 764e: 81 e0 ldi r24, 0x01 ; 1 + 7650: 97 e0 ldi r25, 0x07 ; 7 + 7652: 98 dd rcall .-1232 ; 0x7184 + // If socket correctly opened continue + } while(netReadReg(REG_S3_SR) != SOCK_UDP); + 7654: 83 e0 ldi r24, 0x03 ; 3 + 7656: 97 e0 ldi r25, 0x07 ; 7 + 7658: ae dd rcall .-1188 ; 0x71b6 + 765a: 82 32 cpi r24, 0x22 ; 34 + 765c: 29 f7 brne .-54 ; 0x7628 +#ifdef _VERBOSE + traceln("Tftp: TFTP server init done"); +#endif +} + 765e: 08 95 ret + +00007660 : + +/** + * Looks for a connection + */ +uint8_t tftpPoll() +{ + 7660: cf 93 push r28 + uint8_t response = ACK; + // Get the size of the recieved data + uint16_t packetSize = netReadWord(REG_S3_RX_RSR0); + 7662: 86 e2 ldi r24, 0x26 ; 38 + 7664: 97 e0 ldi r25, 0x07 ; 7 + 7666: c1 dd rcall .-1150 ; 0x71ea + + if(packetSize) { + 7668: 89 2b or r24, r25 + 766a: 11 f4 brne .+4 ; 0x7670 + netWriteReg(REG_S3_CR, CR_CLOSE); + // Complete + return(0); + } + // Tftp continues + return(1); + 766c: 81 e0 ldi r24, 0x01 ; 1 + 766e: 26 c0 rjmp .+76 ; 0x76bc + uint8_t response = ACK; + // Get the size of the recieved data + uint16_t packetSize = netReadWord(REG_S3_RX_RSR0); + + if(packetSize) { + if(!tftpFlashing) resetTick(); + 7670: 80 91 27 01 lds r24, 0x0127 + 7674: 81 11 cpse r24, r1 + 7676: 01 c0 rjmp .+2 ; 0x767a + 7678: 8a d1 rcall .+788 ; 0x798e + tftpFlashing = TRUE; + 767a: 81 e0 ldi r24, 0x01 ; 1 + 767c: 80 93 27 01 sts 0x0127, r24 + + for(;;) { + if(!(netReadReg(REG_S3_IR) & IR_RECV)) break; + 7680: 82 e0 ldi r24, 0x02 ; 2 + 7682: 97 e0 ldi r25, 0x07 ; 7 + 7684: 98 dd rcall .-1232 ; 0x71b6 + 7686: 82 ff sbrs r24, 2 + 7688: 0e c0 rjmp .+28 ; 0x76a6 + + netWriteReg(REG_S3_IR, IR_RECV); + 768a: 64 e0 ldi r22, 0x04 ; 4 + 768c: 82 e0 ldi r24, 0x02 ; 2 + 768e: 97 e0 ldi r25, 0x07 ; 7 + 7690: 79 dd rcall .-1294 ; 0x7184 + #else + //round up by default + __ticks_dc = (uint32_t)(ceil(fabs(__tmp))); + #endif + + __builtin_avr_delay_cycles(__ticks_dc); + 7692: 2f ef ldi r18, 0xFF ; 255 + 7694: 87 e8 ldi r24, 0x87 ; 135 + 7696: 93 e1 ldi r25, 0x13 ; 19 + 7698: 21 50 subi r18, 0x01 ; 1 + 769a: 80 40 sbci r24, 0x00 ; 0 + 769c: 90 40 sbci r25, 0x00 ; 0 + 769e: e1 f7 brne .-8 ; 0x7698 + 76a0: 00 c0 rjmp .+0 ; 0x76a2 + 76a2: 00 00 nop + 76a4: ed cf rjmp .-38 ; 0x7680 + } + // Process Packet and get TFTP response code +#ifdef _DEBUG_TFTP + response = processPacket(packetSize); +#else + response = processPacket(); + 76a6: 1d de rcall .-966 ; 0x72e2 + 76a8: c8 2f mov r28, r24 +#endif + // Send the response + sendResponse(response); + 76aa: 90 e0 ldi r25, 0x00 ; 0 + 76ac: 3b df rcall .-394 ; 0x7524 + } + if(response==FINAL_ACK) { + 76ae: c4 30 cpi r28, 0x04 ; 4 + 76b0: e9 f6 brne .-70 ; 0x766c + netWriteReg(REG_S3_CR, CR_CLOSE); + 76b2: 60 e1 ldi r22, 0x10 ; 16 + 76b4: 81 e0 ldi r24, 0x01 ; 1 + 76b6: 97 e0 ldi r25, 0x07 ; 7 + 76b8: 65 dd rcall .-1334 ; 0x7184 + // Complete + return(0); + 76ba: 80 e0 ldi r24, 0x00 ; 0 + } + // Tftp continues + return(1); +} + 76bc: cf 91 pop r28 + 76be: 08 95 ret + +000076c0 : +#include "debug.h" +#include "serial.h" + + +uint8_t validImage(uint8_t *base) +{ + 76c0: 20 e0 ldi r18, 0x00 ; 0 + 76c2: 30 e0 ldi r19, 0x00 ; 0 +#include "validate.h" +#include "debug.h" +#include "serial.h" + + +uint8_t validImage(uint8_t *base) + 76c4: fc 01 movw r30, r24 + 76c6: e2 0f add r30, r18 + 76c8: f3 1f adc r31, r19 + /* Check that a jump table is present in the first flash sector */ + uint8_t i; + for(i = 0; i < 0x34; i += 4) { + // For each vector, check it is of the form: + // 0x0C 0x94 0xWX 0xYZ ; JMP 0xWXYZ + if(base[i] != 0x0c) { + 76ca: 40 81 ld r20, Z + 76cc: 4c 30 cpi r20, 0x0C ; 12 + 76ce: 51 f4 brne .+20 ; 0x76e4 + tracenum(base[i]); + trace(" instead of 0x0C"); +#endif + return(0); + } + if(base[i + 1] != 0x94) { + 76d0: 41 81 ldd r20, Z+1 ; 0x01 + 76d2: 44 39 cpi r20, 0x94 ; 148 + 76d4: 39 f4 brne .+14 ; 0x76e4 + 76d6: 2c 5f subi r18, 0xFC ; 252 + 76d8: 3f 4f sbci r19, 0xFF ; 255 + +uint8_t validImage(uint8_t *base) +{ + /* Check that a jump table is present in the first flash sector */ + uint8_t i; + for(i = 0; i < 0x34; i += 4) { + 76da: 24 33 cpi r18, 0x34 ; 52 + 76dc: 31 05 cpc r19, r1 + 76de: 91 f7 brne .-28 ; 0x76c4 + } + } +#ifdef _DEBUG_VALD + traceln("Vald: Valid image"); +#endif + return(1); + 76e0: 81 e0 ldi r24, 0x01 ; 1 + 76e2: 08 95 ret + tracenum(i); + trace(" with "); + tracenum(base[i]); + trace(" instead of 0x0C"); +#endif + return(0); + 76e4: 80 e0 ldi r24, 0x00 ; 0 + } +#ifdef _DEBUG_VALD + traceln("Vald: Valid image"); +#endif + return(1); +} + 76e6: 08 95 ret + +000076e8 : + */ +uint8_t watchdogDisable(void) +{ + uint8_t mcusr_mirror; + + mcusr_mirror = MCUSR; + 76e8: 84 b7 in r24, 0x34 ; 52 + MCUSR = 0; + 76ea: 14 be out 0x34, r1 ; 52 + wdt_disable(); + 76ec: 98 e1 ldi r25, 0x18 ; 24 + 76ee: 0f b6 in r0, 0x3f ; 63 + 76f0: f8 94 cli + 76f2: 90 93 60 00 sts 0x0060, r25 + 76f6: 10 92 60 00 sts 0x0060, r1 + 76fa: 0f be out 0x3f, r0 ; 63 + + return(mcusr_mirror); +} + 76fc: 08 95 ret + +000076fe : + +void watchdogReset(void) +{ + wdt_reset(); + 76fe: a8 95 wdr + 7700: 08 95 ret + +00007702 : +} + +void watchdogConfig(uint8_t x) +{ + WDTCSR = _BV(WDCE) | _BV(WDE); + 7702: e0 e6 ldi r30, 0x60 ; 96 + 7704: f0 e0 ldi r31, 0x00 ; 0 + 7706: 98 e1 ldi r25, 0x18 ; 24 + 7708: 90 83 st Z, r25 + WDTCSR = x; + 770a: 80 83 st Z, r24 + 770c: 08 95 ret + +0000770e : +uint8_t length; + + +void verifySpace() +{ + if(getch() != CRC_EOP) { + 770e: 12 d1 rcall .+548 ; 0x7934 + 7710: 80 32 cpi r24, 0x20 ; 32 + 7712: 19 f0 breq .+6 ; 0x771a + watchdogConfig(WATCHDOG_16MS); // shorten WD timeout + 7714: 88 e0 ldi r24, 0x08 ; 8 + 7716: f5 df rcall .-22 ; 0x7702 + 7718: ff cf rjmp .-2 ; 0x7718 + while(1) // and busy-loop so that WD causes + ; // a reset and app start. + } + putch(STK_INSYNC); + 771a: 84 e1 ldi r24, 0x14 ; 20 + 771c: f8 c0 rjmp .+496 ; 0x790e + +0000771e : +} + + +void getNch(uint8_t count) +{ + 771e: cf 93 push r28 + 7720: c8 2f mov r28, r24 + do getch(); + 7722: 08 d1 rcall .+528 ; 0x7934 + while(--count); + 7724: c1 50 subi r28, 0x01 ; 1 + 7726: e9 f7 brne .-6 ; 0x7722 + verifySpace(); +} + 7728: cf 91 pop r28 + +void getNch(uint8_t count) +{ + do getch(); + while(--count); + verifySpace(); + 772a: f1 cf rjmp .-30 ; 0x770e + +0000772c : +} + + +uint8_t proccessCommand() +{ + 772c: ef 92 push r14 + 772e: ff 92 push r15 + 7730: cf 93 push r28 + 7732: df 93 push r29 + 7734: cd b7 in r28, 0x3d ; 61 + 7736: de b7 in r29, 0x3e ; 62 + 7738: c1 50 subi r28, 0x01 ; 1 + 773a: d1 40 sbci r29, 0x01 ; 1 + 773c: de bf out 0x3e, r29 ; 62 + 773e: cd bf out 0x3d, r28 ; 61 + uint8_t ch; + + ch = getch(); + 7740: f9 d0 rcall .+498 ; 0x7934 + + if(ch == STK_GET_PARAMETER) { + 7742: 81 34 cpi r24, 0x41 ; 65 + 7744: a9 f4 brne .+42 ; 0x7770 + unsigned char which = getch(); + 7746: f6 d0 rcall .+492 ; 0x7934 + verifySpace(); + 7748: cf 5f subi r28, 0xFF ; 255 + 774a: de 4f sbci r29, 0xFE ; 254 + 774c: 88 83 st Y, r24 + 774e: c1 50 subi r28, 0x01 ; 1 + 7750: d1 40 sbci r29, 0x01 ; 1 + 7752: dd df rcall .-70 ; 0x770e + if(which == 0x82) { + 7754: cf 5f subi r28, 0xFF ; 255 + 7756: de 4f sbci r29, 0xFE ; 254 + 7758: 88 81 ld r24, Y + 775a: c1 50 subi r28, 0x01 ; 1 + 775c: d1 40 sbci r29, 0x01 ; 1 + 775e: 82 38 cpi r24, 0x82 ; 130 + 7760: 11 f4 brne .+4 ; 0x7766 + /* + * Send tftpboot version as "minor SW version" + */ + putch(TFTPBOOT_MINVER); + 7762: 83 e0 ldi r24, 0x03 ; 3 + 7764: 03 c0 rjmp .+6 ; 0x776c + } else if(which == 0x81) { + 7766: 81 38 cpi r24, 0x81 ; 129 + 7768: e1 f7 brne .-8 ; 0x7762 + putch(TFTPBOOT_MAJVER); + 776a: 80 e0 ldi r24, 0x00 ; 0 + 776c: d0 d0 rcall .+416 ; 0x790e + 776e: ac c0 rjmp .+344 ; 0x78c8 + * GET PARAMETER returns a generic 0x03 reply for + * other parameters - enough to keep Avrdude happy + */ + putch(0x03); + } + } else if(ch == STK_SET_DEVICE) { + 7770: 82 34 cpi r24, 0x42 ; 66 + 7772: 11 f4 brne .+4 ; 0x7778 + // SET DEVICE is ignored + getNch(20); + 7774: 84 e1 ldi r24, 0x14 ; 20 + 7776: 03 c0 rjmp .+6 ; 0x777e + } else if(ch == STK_SET_DEVICE_EXT) { + 7778: 85 34 cpi r24, 0x45 ; 69 + 777a: 19 f4 brne .+6 ; 0x7782 + // SET DEVICE EXT is ignored + getNch(4); + 777c: 84 e0 ldi r24, 0x04 ; 4 + 777e: cf df rcall .-98 ; 0x771e + 7780: a3 c0 rjmp .+326 ; 0x78c8 + } else if(ch == STK_LOAD_ADDRESS) { + 7782: 85 35 cpi r24, 0x55 ; 85 + 7784: 69 f4 brne .+26 ; 0x77a0 + // LOAD ADDRESS + uint16_t newAddress; + newAddress = getch(); + 7786: d6 d0 rcall .+428 ; 0x7934 + 7788: f8 2e mov r15, r24 + newAddress = (newAddress & 0xff) | (getch() << 8); + 778a: d4 d0 rcall .+424 ; 0x7934 + 778c: 2f 2d mov r18, r15 + 778e: 30 e0 ldi r19, 0x00 ; 0 + 7790: 38 2b or r19, r24 +#ifdef RAMPZ + // Transfer top bit to RAMPZ + RAMPZ = (newAddress & 0x8000) ? 1 : 0; +#endif + + newAddress += newAddress; // Convert from word address to byte address + 7792: 22 0f add r18, r18 + 7794: 33 1f adc r19, r19 + address = newAddress; + 7796: 30 93 21 01 sts 0x0121, r19 + 779a: 20 93 20 01 sts 0x0120, r18 + 779e: 93 c0 rjmp .+294 ; 0x78c6 + verifySpace(); + } else if(ch == STK_UNIVERSAL) { + 77a0: 86 35 cpi r24, 0x56 ; 86 + 77a2: 19 f4 brne .+6 ; 0x77aa + // UNIVERSAL command is ignored + getNch(4); + 77a4: 84 e0 ldi r24, 0x04 ; 4 + 77a6: bb df rcall .-138 ; 0x771e + 77a8: e0 cf rjmp .-64 ; 0x776a + putch(0x00); + } + /* Write memory, length is big endian and is in bytes */ + else if(ch == STK_PROG_PAGE) { + 77aa: 84 36 cpi r24, 0x64 ; 100 + 77ac: 09 f0 breq .+2 ; 0x77b0 + 77ae: 5b c0 rjmp .+182 ; 0x7866 + // PROGRAM PAGE - we support flash programming only, not EEPROM + uint8_t buff[256]; + uint8_t* bufPtr; + uint16_t addrPtr; + + getch(); /* getlen() */ + 77b0: c1 d0 rcall .+386 ; 0x7934 + length = getch(); + 77b2: c0 d0 rcall .+384 ; 0x7934 + 77b4: 80 93 28 01 sts 0x0128, r24 + getch(); + 77b8: bd d0 rcall .+378 ; 0x7934 + + // If we are in RWW section, immediately start page erase + if(address < NRWWSTART) boot_page_erase((uint16_t)(void *)address); + 77ba: e0 91 20 01 lds r30, 0x0120 + 77be: f0 91 21 01 lds r31, 0x0121 + 77c2: e1 15 cp r30, r1 + 77c4: 80 e7 ldi r24, 0x70 ; 112 + 77c6: f8 07 cpc r31, r24 + 77c8: 18 f4 brcc .+6 ; 0x77d0 + 77ca: 83 e0 ldi r24, 0x03 ; 3 + 77cc: 87 bf out 0x37, r24 ; 55 + 77ce: e8 95 spm + 77d0: ee 24 eor r14, r14 + 77d2: e3 94 inc r14 + 77d4: f1 2c mov r15, r1 + 77d6: ec 0e add r14, r28 + 77d8: fd 1e adc r15, r29 + + // While that is going on, read in page contents + bufPtr = buff; + do *bufPtr++ = getch(); + 77da: ac d0 rcall .+344 ; 0x7934 + 77dc: f7 01 movw r30, r14 + 77de: 81 93 st Z+, r24 + 77e0: 7f 01 movw r14, r30 + while(--length); + 77e2: 80 91 28 01 lds r24, 0x0128 + 77e6: 81 50 subi r24, 0x01 ; 1 + 77e8: 80 93 28 01 sts 0x0128, r24 + 77ec: 81 11 cpse r24, r1 + 77ee: f5 cf rjmp .-22 ; 0x77da + + // If we are in NRWW section, page erase has to be delayed until now. + // Todo: Take RAMPZ into account + if(address >= NRWWSTART) boot_page_erase((uint16_t)(void *)address); + 77f0: e0 91 20 01 lds r30, 0x0120 + 77f4: f0 91 21 01 lds r31, 0x0121 + 77f8: e1 15 cp r30, r1 + 77fa: 80 e7 ldi r24, 0x70 ; 112 + 77fc: f8 07 cpc r31, r24 + 77fe: 18 f0 brcs .+6 ; 0x7806 + 7800: 83 e0 ldi r24, 0x03 ; 3 + 7802: 87 bf out 0x37, r24 ; 55 + 7804: e8 95 spm + + // Read command terminator, start reply + verifySpace(); + 7806: 83 df rcall .-250 ; 0x770e + + // If only a partial page is to be programmed, the erase might not be complete. + // So check that here + boot_spm_busy_wait(); + 7808: 07 b6 in r0, 0x37 ; 55 + 780a: 00 fc sbrc r0, 0 + 780c: fd cf rjmp .-6 ; 0x7808 + + // Copy buffer into programming buffer + bufPtr = buff; + addrPtr = (uint16_t)(void *)address; + 780e: 40 91 20 01 lds r20, 0x0120 + 7812: 50 91 21 01 lds r21, 0x0121 + // If only a partial page is to be programmed, the erase might not be complete. + // So check that here + boot_spm_busy_wait(); + + // Copy buffer into programming buffer + bufPtr = buff; + 7816: 29 81 ldd r18, Y+1 ; 0x01 + 7818: 80 e0 ldi r24, 0x00 ; 0 + 781a: 90 e0 ldi r25, 0x00 ; 0 + ch = SPM_PAGESIZE / 2; + do { + uint16_t a; + a = *bufPtr++; + a |= (*bufPtr++) << 8; + boot_page_fill((uint16_t)(void *)addrPtr, a); + 781c: 61 e0 ldi r22, 0x01 ; 1 + while(--count); + verifySpace(); +} + + +uint8_t proccessCommand() + 781e: a1 e0 ldi r26, 0x01 ; 1 + 7820: b0 e0 ldi r27, 0x00 ; 0 + 7822: ac 0f add r26, r28 + 7824: bd 1f adc r27, r29 + 7826: a8 0f add r26, r24 + 7828: b9 1f adc r27, r25 + 782a: fc 01 movw r30, r24 + 782c: e4 0f add r30, r20 + 782e: f5 1f adc r31, r21 + addrPtr = (uint16_t)(void *)address; + ch = SPM_PAGESIZE / 2; + do { + uint16_t a; + a = *bufPtr++; + a |= (*bufPtr++) << 8; + 7830: 11 96 adiw r26, 0x01 ; 1 + 7832: 7c 91 ld r23, X + 7834: 11 97 sbiw r26, 0x01 ; 1 + 7836: 30 e0 ldi r19, 0x00 ; 0 + 7838: 37 2b or r19, r23 + boot_page_fill((uint16_t)(void *)addrPtr, a); + 783a: 09 01 movw r0, r18 + 783c: 67 bf out 0x37, r22 ; 55 + 783e: e8 95 spm + 7840: 11 24 eor r1, r1 + addrPtr += 2; + } while(--ch); + 7842: 8e 37 cpi r24, 0x7E ; 126 + 7844: 91 05 cpc r25, r1 + 7846: 21 f0 breq .+8 ; 0x7850 + addrPtr = (uint16_t)(void *)address; + ch = SPM_PAGESIZE / 2; + do { + uint16_t a; + a = *bufPtr++; + a |= (*bufPtr++) << 8; + 7848: 12 96 adiw r26, 0x02 ; 2 + 784a: 2c 91 ld r18, X + 784c: 02 96 adiw r24, 0x02 ; 2 + 784e: e7 cf rjmp .-50 ; 0x781e + boot_page_fill((uint16_t)(void *)addrPtr, a); + addrPtr += 2; + } while(--ch); + + // Write from programming buffer + boot_page_write((uint16_t)(void *)address); + 7850: 85 e0 ldi r24, 0x05 ; 5 + 7852: fa 01 movw r30, r20 + 7854: 87 bf out 0x37, r24 ; 55 + 7856: e8 95 spm + boot_spm_busy_wait(); + 7858: 07 b6 in r0, 0x37 ; 55 + 785a: 00 fc sbrc r0, 0 + 785c: fd cf rjmp .-6 ; 0x7858 + +#if defined(RWWSRE) + // Reenable read access to flash + boot_rww_enable(); + 785e: 81 e1 ldi r24, 0x11 ; 17 + 7860: 87 bf out 0x37, r24 ; 55 + 7862: e8 95 spm + 7864: 31 c0 rjmp .+98 ; 0x78c8 +#endif + } + /* Read memory block mode, length is big endian. */ + else if(ch == STK_READ_PAGE) { + 7866: 84 37 cpi r24, 0x74 ; 116 + 7868: d1 f4 brne .+52 ; 0x789e + // READ PAGE - we only read flash + getch(); /* getlen() */ + 786a: 64 d0 rcall .+200 ; 0x7934 + length = getch(); + 786c: 63 d0 rcall .+198 ; 0x7934 + 786e: 80 93 28 01 sts 0x0128, r24 + getch(); + 7872: 60 d0 rcall .+192 ; 0x7934 + + verifySpace(); + 7874: 4c df rcall .-360 ; 0x770e + __asm__("elpm %0,Z\n":"=r"(result):"z"(address)); + putch(result); + address++; + } while(--length); +#else + do putch(pgm_read_byte_near(address++)); + 7876: e0 91 20 01 lds r30, 0x0120 + 787a: f0 91 21 01 lds r31, 0x0121 + 787e: cf 01 movw r24, r30 + 7880: 01 96 adiw r24, 0x01 ; 1 + 7882: 90 93 21 01 sts 0x0121, r25 + 7886: 80 93 20 01 sts 0x0120, r24 + 788a: 84 91 lpm r24, Z + 788c: 40 d0 rcall .+128 ; 0x790e + while(--length); + 788e: 80 91 28 01 lds r24, 0x0128 + 7892: 81 50 subi r24, 0x01 ; 1 + 7894: 80 93 28 01 sts 0x0128, r24 + 7898: 81 11 cpse r24, r1 + 789a: ed cf rjmp .-38 ; 0x7876 + 789c: 15 c0 rjmp .+42 ; 0x78c8 +#endif + } + /* Get device signature bytes */ + else if(ch == STK_READ_SIGN) { + 789e: 85 37 cpi r24, 0x75 ; 117 + 78a0: 39 f4 brne .+14 ; 0x78b0 + // READ SIGN - return what Avrdude wants to hear + verifySpace(); + 78a2: 35 df rcall .-406 ; 0x770e + putch(SIGNATURE_0); + 78a4: 8e e1 ldi r24, 0x1E ; 30 + 78a6: 33 d0 rcall .+102 ; 0x790e + putch(SIGNATURE_1); + 78a8: 85 e9 ldi r24, 0x95 ; 149 + 78aa: 31 d0 rcall .+98 ; 0x790e + putch(SIGNATURE_2); + 78ac: 8f e0 ldi r24, 0x0F ; 15 + 78ae: 5e cf rjmp .-324 ; 0x776c + } else if(ch == STK_LEAVE_PROGMODE) { + 78b0: 81 35 cpi r24, 0x51 ; 81 + 78b2: 49 f4 brne .+18 ; 0x78c6 + // Adaboot no-wait mod + //watchdogConfig(WATCHDOG_16MS); + verifySpace(); + 78b4: 2c df rcall .-424 ; 0x770e + eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); + 78b6: 6b eb ldi r22, 0xBB ; 187 + 78b8: 82 e0 ldi r24, 0x02 ; 2 + 78ba: 90 e0 ldi r25, 0x00 ; 0 + 78bc: 8e d0 rcall .+284 ; 0x79da <__eewr_byte_m328p> + putch(STK_OK); + 78be: 80 e1 ldi r24, 0x10 ; 16 + 78c0: 26 d0 rcall .+76 ; 0x790e + return(0); + 78c2: 80 e0 ldi r24, 0x00 ; 0 + 78c4: 04 c0 rjmp .+8 ; 0x78ce + } else { + // This covers the response to commands like STK_ENTER_PROGMODE + verifySpace(); + 78c6: 23 df rcall .-442 ; 0x770e + } + putch(STK_OK); + 78c8: 80 e1 ldi r24, 0x10 ; 16 + 78ca: 21 d0 rcall .+66 ; 0x790e + return(1); + 78cc: 81 e0 ldi r24, 0x01 ; 1 +} + 78ce: cf 5f subi r28, 0xFF ; 255 + 78d0: de 4f sbci r29, 0xFE ; 254 + 78d2: de bf out 0x3e, r29 ; 62 + 78d4: cd bf out 0x3d, r28 ; 61 + 78d6: df 91 pop r29 + 78d8: cf 91 pop r28 + 78da: ff 90 pop r15 + 78dc: ef 90 pop r14 + 78de: 08 95 ret + +000078e0 : + + +uint8_t serialPoll() +{ + if(UCSR0A & _BV(RXC0)){ + 78e0: 80 91 c0 00 lds r24, 0x00C0 + 78e4: 87 ff sbrs r24, 7 + 78e6: 04 c0 rjmp .+8 ; 0x78f0 + serialFlashing = TRUE; + 78e8: 81 e0 ldi r24, 0x01 ; 1 + 78ea: 80 93 26 01 sts 0x0126, r24 + return(proccessCommand()); + 78ee: 1e cf rjmp .-452 ; 0x772c + } else return(1); +} + 78f0: 81 e0 ldi r24, 0x01 ; 1 + 78f2: 08 95 ret + +000078f4 : +#include "pin_defs.h" + + +void serialInit() +{ + UCSR0A = _BV(U2X0); //Double speed mode USART0 + 78f4: 82 e0 ldi r24, 0x02 ; 2 + 78f6: 80 93 c0 00 sts 0x00C0, r24 + UCSR0B = _BV(RXEN0) | _BV(TXEN0); + 78fa: 88 e1 ldi r24, 0x18 ; 24 + 78fc: 80 93 c1 00 sts 0x00C1, r24 + UCSR0C = _BV(UCSZ00) | _BV(UCSZ01); + 7900: 86 e0 ldi r24, 0x06 ; 6 + 7902: 80 93 c2 00 sts 0x00C2, r24 + UBRR0L = (uint8_t)((F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1); + 7906: 80 e1 ldi r24, 0x10 ; 16 + 7908: 80 93 c4 00 sts 0x00C4, r24 + 790c: 08 95 ret + +0000790e : +} + + +void putch(uint8_t c) +{ + while(!(UCSR0A & _BV(UDRE0))); + 790e: 90 91 c0 00 lds r25, 0x00C0 + 7912: 95 ff sbrs r25, 5 + 7914: fc cf rjmp .-8 ; 0x790e + UDR0 = c; + 7916: 80 93 c6 00 sts 0x00C6, r24 + 791a: 08 95 ret + +0000791c : +} + + +void puthex(uint8_t c) +{ + c &= 0xf; + 791c: 8f 70 andi r24, 0x0F ; 15 + if(c > 9) c += 7; + 791e: 8a 30 cpi r24, 0x0A ; 10 + 7920: 08 f0 brcs .+2 ; 0x7924 + 7922: 89 5f subi r24, 0xF9 ; 249 + while(!(UCSR0A & _BV(UDRE0))); + 7924: 90 91 c0 00 lds r25, 0x00C0 + 7928: 95 ff sbrs r25, 5 + 792a: fc cf rjmp .-8 ; 0x7924 + UDR0 = c + '0'; + 792c: 80 5d subi r24, 0xD0 ; 208 + 792e: 80 93 c6 00 sts 0x00C6, r24 + 7932: 08 95 ret + +00007934 : + +uint8_t getch(void) +{ + uint8_t ch; + + while(!(UCSR0A & _BV(RXC0))); + 7934: 80 91 c0 00 lds r24, 0x00C0 + 7938: 87 ff sbrs r24, 7 + 793a: fc cf rjmp .-8 ; 0x7934 + if(!(UCSR0A & _BV(FE0))) { + 793c: 80 91 c0 00 lds r24, 0x00C0 + 7940: 84 ff sbrs r24, 4 + * expects to be talking to the application, and DON'T reset the + * watchdog. This should cause the bootloader to abort and run + * the application "soon", if it keeps happening. (Note that we + * don't care that an invalid char is returned...) + */ + watchdogReset(); + 7942: dd de rcall .-582 ; 0x76fe + } + ch = UDR0; + 7944: 80 91 c6 00 lds r24, 0x00C6 + + return ch; +} + 7948: 08 95 ret + +0000794a : +uint16_t tick = 0; + + +void updateLed(void) +{ + uint16_t nextTimer1 = TCNT1; + 794a: 80 91 84 00 lds r24, 0x0084 + 794e: 90 91 85 00 lds r25, 0x0085 + if(nextTimer1 & 0x400) LED_PORT ^= _BV(LED); // Led pin high + 7952: 92 ff sbrs r25, 2 + 7954: 05 c0 rjmp .+10 ; 0x7960 + 7956: 25 b1 in r18, 0x05 ; 5 + 7958: 32 e0 ldi r19, 0x02 ; 2 + 795a: 23 27 eor r18, r19 + 795c: 25 b9 out 0x05, r18 ; 5 + 795e: 01 c0 rjmp .+2 ; 0x7962 + else LED_PORT &= ~_BV(LED); // Led pin low + 7960: 29 98 cbi 0x05, 1 ; 5 + if(nextTimer1 < lastTimer1) tick++; + 7962: 20 91 29 01 lds r18, 0x0129 + 7966: 30 91 2a 01 lds r19, 0x012A + 796a: 82 17 cp r24, r18 + 796c: 93 07 cpc r25, r19 + 796e: 50 f4 brcc .+20 ; 0x7984 + 7970: 20 91 22 01 lds r18, 0x0122 + 7974: 30 91 23 01 lds r19, 0x0123 + 7978: 2f 5f subi r18, 0xFF ; 255 + 797a: 3f 4f sbci r19, 0xFF ; 255 + 797c: 30 93 23 01 sts 0x0123, r19 + 7980: 20 93 22 01 sts 0x0122, r18 + lastTimer1 = nextTimer1; + 7984: 90 93 2a 01 sts 0x012A, r25 + 7988: 80 93 29 01 sts 0x0129, r24 + 798c: 08 95 ret + +0000798e : +} + +void resetTick(void) +{ + tick = 0; + 798e: 10 92 23 01 sts 0x0123, r1 + 7992: 10 92 22 01 sts 0x0122, r1 + 7996: 08 95 ret + +00007998 : +} + +uint8_t timedOut(void) +{ + // Never timeout if there is no code in Flash + if(pgm_read_word(0x0000) == 0xFFFF) return(0); + 7998: e0 e0 ldi r30, 0x00 ; 0 + 799a: f0 e0 ldi r31, 0x00 ; 0 + 799c: 85 91 lpm r24, Z+ + 799e: 94 91 lpm r25, Z + 79a0: 01 96 adiw r24, 0x01 ; 1 + 79a2: 41 f0 breq .+16 ; 0x79b4 + if(tick > TIMEOUT) return(1); + 79a4: 81 e0 ldi r24, 0x01 ; 1 + 79a6: 20 91 22 01 lds r18, 0x0122 + 79aa: 30 91 23 01 lds r19, 0x0123 + 79ae: 24 30 cpi r18, 0x04 ; 4 + 79b0: 31 05 cpc r19, r1 + 79b2: 08 f4 brcc .+2 ; 0x79b6 +} + +uint8_t timedOut(void) +{ + // Never timeout if there is no code in Flash + if(pgm_read_word(0x0000) == 0xFFFF) return(0); + 79b4: 80 e0 ldi r24, 0x00 ; 0 + if(tick > TIMEOUT) return(1); + return(0); +} + 79b6: 08 95 ret + +000079b8 : + 79b8: fb 01 movw r30, r22 + 79ba: dc 01 movw r26, r24 + 79bc: 02 c0 rjmp .+4 ; 0x79c2 + 79be: 05 90 lpm r0, Z+ + 79c0: 0d 92 st X+, r0 + 79c2: 41 50 subi r20, 0x01 ; 1 + 79c4: 50 40 sbci r21, 0x00 ; 0 + 79c6: d8 f7 brcc .-10 ; 0x79be + 79c8: 08 95 ret + +000079ca <__eerd_byte_m328p>: + 79ca: f9 99 sbic 0x1f, 1 ; 31 + 79cc: fe cf rjmp .-4 ; 0x79ca <__eerd_byte_m328p> + 79ce: 92 bd out 0x22, r25 ; 34 + 79d0: 81 bd out 0x21, r24 ; 33 + 79d2: f8 9a sbi 0x1f, 0 ; 31 + 79d4: 99 27 eor r25, r25 + 79d6: 80 b5 in r24, 0x20 ; 32 + 79d8: 08 95 ret + +000079da <__eewr_byte_m328p>: + 79da: 26 2f mov r18, r22 + +000079dc <__eewr_r18_m328p>: + 79dc: f9 99 sbic 0x1f, 1 ; 31 + 79de: fe cf rjmp .-4 ; 0x79dc <__eewr_r18_m328p> + 79e0: 1f ba out 0x1f, r1 ; 31 + 79e2: 92 bd out 0x22, r25 ; 34 + 79e4: 81 bd out 0x21, r24 ; 33 + 79e6: 20 bd out 0x20, r18 ; 32 + 79e8: 0f b6 in r0, 0x3f ; 63 + 79ea: f8 94 cli + 79ec: fa 9a sbi 0x1f, 2 ; 31 + 79ee: f9 9a sbi 0x1f, 1 ; 31 + 79f0: 0f be out 0x3f, r0 ; 63 + 79f2: 01 96 adiw r24, 0x01 ; 1 + 79f4: 08 95 ret + +000079f6 <_exit>: + 79f6: f8 94 cli + +000079f8 <__stop_program>: + 79f8: ff cf rjmp .-2 ; 0x79f8 <__stop_program> diff --git a/hardware/tftpboot/bootloaders/tftpboot/bigapp.c b/hardware/ariadne/bootloaders/ariadne/bigapp.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/bigapp.c rename to hardware/ariadne/bootloaders/ariadne/bigapp.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/boot.h b/hardware/ariadne/bootloaders/ariadne/boot.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/boot.h rename to hardware/ariadne/bootloaders/ariadne/boot.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/debug.c b/hardware/ariadne/bootloaders/ariadne/debug.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/debug.c rename to hardware/ariadne/bootloaders/ariadne/debug.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/debug.h b/hardware/ariadne/bootloaders/ariadne/debug.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/debug.h rename to hardware/ariadne/bootloaders/ariadne/debug.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/main.c b/hardware/ariadne/bootloaders/ariadne/main.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/main.c rename to hardware/ariadne/bootloaders/ariadne/main.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/makeall b/hardware/ariadne/bootloaders/ariadne/makeall old mode 100644 new mode 100755 similarity index 75% rename from hardware/tftpboot/bootloaders/tftpboot/makeall rename to hardware/ariadne/bootloaders/ariadne/makeall index 8838154..60c533e --- a/hardware/tftpboot/bootloaders/tftpboot/makeall +++ b/hardware/ariadne/bootloaders/ariadne/makeall @@ -1,11 +1,12 @@ #!/bin/bash make clean # -# The "big one" standard bootloaders. +# The "big two" standard bootloaders. +make atmega328 +make atmega328_ethernet #make atmega8 #make atmega168 -#make atmega328 -make debug328 +#make debug328 # # additional buildable platforms of # somewhat questionable support level diff --git a/hardware/tftpboot/bootloaders/tftpboot/net.c b/hardware/ariadne/bootloaders/ariadne/net.c similarity index 91% rename from hardware/tftpboot/bootloaders/tftpboot/net.c rename to hardware/ariadne/bootloaders/ariadne/net.c index 7631565..949caa9 100644 --- a/hardware/tftpboot/bootloaders/tftpboot/net.c +++ b/hardware/ariadne/bootloaders/ariadne/net.c @@ -11,6 +11,7 @@ #include "neteeprom.h" #include "pin_defs.h" #include "serial.h" +#include "tftp.h" #include "debug.h" #define SS_LOW() PORTB &= ~_BV(SS) @@ -35,6 +36,7 @@ uint8_t registerBuffer[REGISTER_BLOCK_SIZE] = { 0x55 // TMSR Tx Memory Size Register, 2K per socket }; + void netWriteReg(uint16_t address, uint8_t value) { #ifdef _DEBUGMORE_NET @@ -56,7 +58,7 @@ void netWriteReg(uint16_t address, uint8_t value) SPDR = value; while(!(SPSR & _BV(SPIF))); SS_HIGH(); - SPCR = 0; // Turn of SPI + SPCR = 0; // Turn off SPI } uint8_t netReadReg(uint16_t address) @@ -115,17 +117,23 @@ void netInit() // Set the Double SPI Speed Bit SPSR = (1 << SPI2X); - +#ifndef _TFTP_RANDOM_PORT + tftpPort = TFTP_STATIC_PORT; +#endif /* Pull in altered presets * if available from AVR EEPROM (if signature bytes are set)*/ if((eeprom_read_byte(EEPROM_SIG_1) == EEPROM_SIG_1_VALUE) && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { + for(i = 0; i < EEPROM_SETTINGS_SIZE; i++) + registerBuffer[i+1] = eeprom_read_byte(EEPROM_DATA+i); +#ifndef _TFTP_RANDOM_PORT + tftpPort = ((eeprom_read_byte(EEPROM_PORT+1)<<8) + eeprom_read_byte(EEPROM_PORT)); +#endif + #ifdef _VERBOSE traceln(" Net: Using EEPROM settings"); #endif - for(i = 0; i < 18; i++) - registerBuffer[i+1] = eeprom_read_byte(EEPROM_DATA+i); } #ifdef _VERBOSE else { @@ -154,6 +162,10 @@ void netInit() tracenet(registerBuffer[i]); if(i != 14) putch(0x2E); } +#ifndef _TFTP_RANDOM_PORT + traceln("\t Port: "); + tracenum(tftpPort); +#endif #endif // Configure Wiznet chip diff --git a/hardware/tftpboot/bootloaders/tftpboot/net.h b/hardware/ariadne/bootloaders/ariadne/net.h similarity index 77% rename from hardware/tftpboot/bootloaders/tftpboot/net.h rename to hardware/ariadne/bootloaders/ariadne/net.h index b80204c..e1417cb 100644 --- a/hardware/tftpboot/bootloaders/tftpboot/net.h +++ b/hardware/ariadne/bootloaders/ariadne/net.h @@ -1,21 +1,23 @@ +#ifndef net_h +#define net_h + #include #include -// Network settings +/* Network settings */ #define IP_ADDR 192,168,1,128 -#define SUB_MASK 255,255,255,0 +#define SUB_MASK 255,255,255,0 #define GW_ADDR 192,168,1,1 #define MAC_ADDR 0xDE,0xAD,0xBE,0xEF,0xFE,0xED #define SPI_WRITE (0xF0) -#define SPI_READ (0x0F) - -#define REGISTER_BLOCK_SIZE 28 +#define SPI_READ (0x0F) void netWriteReg(uint16_t address, uint8_t value); uint8_t netReadReg(uint16_t address); uint16_t netReadWord(uint16_t address); void netWriteWord(uint16_t address, uint16_t value); - void netInit(); + +#endif \ No newline at end of file diff --git a/hardware/ariadne/bootloaders/ariadne/neteeprom.h b/hardware/ariadne/bootloaders/ariadne/neteeprom.h new file mode 100644 index 0000000..76c3865 --- /dev/null +++ b/hardware/ariadne/bootloaders/ariadne/neteeprom.h @@ -0,0 +1,21 @@ +#include + +#define EEPROM_SIG_1 ((uint8_t*)0) +#define EEPROM_SIG_2 ((uint8_t*)1) +//#define EEPROM_SIG_3 ((uint8_t*)2) /* This is going to be the port signature byte */ +#define EEPROM_IMG_STAT ((uint8_t*)2) +#define EEPROM_DATA ((uint8_t*)3) +#define EEPROM_GW ((uint8_t*)3) +#define EEPROM_SN ((uint8_t*)7) +#define EEPROM_MAC ((uint8_t*)11) +#define EEPROM_IP ((uint8_t*)17) +#define EEPROM_PORT ((uint8_t*)21) + +#define EEPROM_SETTINGS_SIZE 18 +#define REGISTER_BLOCK_SIZE 28 + +#define EEPROM_SIG_1_VALUE (0x55) +#define EEPROM_SIG_2_VALUE (0xAA) +//#define EEPROM_SIG_3_VAL (0xCC) /* This is going to be the port signature value */ +#define EEPROM_IMG_OK_VALUE (0xBB) +#define EEPROM_IMG_BAD_VALUE (0xFF) diff --git a/hardware/tftpboot/bootloaders/tftpboot/omake b/hardware/ariadne/bootloaders/ariadne/omake similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/omake rename to hardware/ariadne/bootloaders/ariadne/omake diff --git a/hardware/tftpboot/bootloaders/tftpboot/omake.bat b/hardware/ariadne/bootloaders/ariadne/omake.bat similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/omake.bat rename to hardware/ariadne/bootloaders/ariadne/omake.bat diff --git a/hardware/tftpboot/bootloaders/tftpboot/optiboot.c b/hardware/ariadne/bootloaders/ariadne/optiboot.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/optiboot.c rename to hardware/ariadne/bootloaders/ariadne/optiboot.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/optiboot.h b/hardware/ariadne/bootloaders/ariadne/optiboot.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/optiboot.h rename to hardware/ariadne/bootloaders/ariadne/optiboot.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/pin_defs.h b/hardware/ariadne/bootloaders/ariadne/pin_defs.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/pin_defs.h rename to hardware/ariadne/bootloaders/ariadne/pin_defs.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/serial.c b/hardware/ariadne/bootloaders/ariadne/serial.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/serial.c rename to hardware/ariadne/bootloaders/ariadne/serial.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/serial.h b/hardware/ariadne/bootloaders/ariadne/serial.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/serial.h rename to hardware/ariadne/bootloaders/ariadne/serial.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/settings.c b/hardware/ariadne/bootloaders/ariadne/settings.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/settings.c rename to hardware/ariadne/bootloaders/ariadne/settings.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/stk500.h b/hardware/ariadne/bootloaders/ariadne/stk500.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/stk500.h rename to hardware/ariadne/bootloaders/ariadne/stk500.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/tftp.c b/hardware/ariadne/bootloaders/ariadne/tftp.c similarity index 98% rename from hardware/tftpboot/bootloaders/tftpboot/tftp.c rename to hardware/ariadne/bootloaders/ariadne/tftp.c index 3de4271..0f475f3 100644 --- a/hardware/tftpboot/bootloaders/tftpboot/tftp.c +++ b/hardware/ariadne/bootloaders/ariadne/tftp.c @@ -144,7 +144,7 @@ uint8_t processPacket() #ifdef _TFTP_RANDOM_PORT netWriteWord(REG_S3_PORT0, (buffer[4]<<8) | ~buffer[5]); // Generate a 'random' TID (RFC1350) #else - netWriteWord(REG_S3_PORT0, TFTP_STATIC_PORT); // Not random any more + netWriteWord(REG_S3_PORT0, tftpPort); #endif if(netReadReg(REG_S3_SR) != SOCK_UDP) netWriteReg(REG_S3_CR, CR_CLOSE); @@ -154,7 +154,7 @@ uint8_t processPacket() #ifdef _TFTP_RANDOM_PORT tracenum((buffer[4]<<8) | (buffer[5]^0x55)); #else - tracenum(TFTP_STATIC_PORT); + tracenum(tftpPort); #endif #endif lastPacket = 0; diff --git a/hardware/tftpboot/bootloaders/tftpboot/tftp.h b/hardware/ariadne/bootloaders/ariadne/tftp.h similarity index 88% rename from hardware/tftpboot/bootloaders/tftpboot/tftp.h rename to hardware/ariadne/bootloaders/ariadne/tftp.h index 3514a4b..c523e23 100644 --- a/hardware/tftpboot/bootloaders/tftpboot/tftp.h +++ b/hardware/ariadne/bootloaders/ariadne/tftp.h @@ -1,11 +1,13 @@ -#include +#ifndef tftp_h +#define tftp_h -/** Define this if you want random port generation */ -//#define _TFTP_RANDOM_PORT +#include -/** TFTP port settings */ +/* TFTP port settings */ #define TFTP_PORT 69 #define TFTP_STATIC_PORT 46969 +/* Define this if you want random port generation */ +//#define _TFTP_RANDOM_PORT /** TFTP Opcode values from RFC 1350 */ #define TFTP_OPCODE_RRQ 1 @@ -48,6 +50,11 @@ * tftp is currently active */ uint8_t tftpFlashing; +#ifndef _TFTP_RANDOM_PORT +uint16_t tftpPort; +#endif + void tftpInit(); uint8_t tftpPoll(); +#endif \ No newline at end of file diff --git a/hardware/tftpboot/bootloaders/tftpboot/util.c b/hardware/ariadne/bootloaders/ariadne/util.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/util.c rename to hardware/ariadne/bootloaders/ariadne/util.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/util.h b/hardware/ariadne/bootloaders/ariadne/util.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/util.h rename to hardware/ariadne/bootloaders/ariadne/util.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/validate.c b/hardware/ariadne/bootloaders/ariadne/validate.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/validate.c rename to hardware/ariadne/bootloaders/ariadne/validate.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/validate.h b/hardware/ariadne/bootloaders/ariadne/validate.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/validate.h rename to hardware/ariadne/bootloaders/ariadne/validate.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/w5100_reg.h b/hardware/ariadne/bootloaders/ariadne/w5100_reg.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/w5100_reg.h rename to hardware/ariadne/bootloaders/ariadne/w5100_reg.h diff --git a/hardware/tftpboot/bootloaders/tftpboot/watchdog.c b/hardware/ariadne/bootloaders/ariadne/watchdog.c similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/watchdog.c rename to hardware/ariadne/bootloaders/ariadne/watchdog.c diff --git a/hardware/tftpboot/bootloaders/tftpboot/watchdog.h b/hardware/ariadne/bootloaders/ariadne/watchdog.h similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/watchdog.h rename to hardware/ariadne/bootloaders/ariadne/watchdog.h diff --git a/hardware/tftpboot/programmers.txt b/hardware/ariadne/programmers.txt similarity index 100% rename from hardware/tftpboot/programmers.txt rename to hardware/ariadne/programmers.txt diff --git a/hardware/tftpboot/boards.txt b/hardware/tftpboot/boards.txt deleted file mode 100755 index b88b17a..0000000 --- a/hardware/tftpboot/boards.txt +++ /dev/null @@ -1,43 +0,0 @@ -############################################################## - -unotftp.name=Arduino Uno with tftpboot - -unotftp.upload.protocol=arduino -unotftp.upload.maximum_size=28672 -unotftp.upload.speed=115200 - -unotftp.bootloader.low_fuses=0xFF -unotftp.bootloader.high_fuses=0xD8 -unotftp.bootloader.extended_fuses=0x05 -unotftp.bootloader.path=tftpboot -unotftp.bootloader.file=tftpboot_atmega328.hex -unotftp.bootloader.unlock_bits=0x3F -unotftp.bootloader.lock_bits=0x2F - -unotftp.build.mcu=atmega328p -unotftp.build.f_cpu=16000000L -unotftp.build.core=arduino:arduino -unotftp.build.variant=arduino:standard - -############################################################## - -ethertftp.name=Arduino Ethernet with tftpboot - -ethertftp.upload.protocol=arduino -ethertftp.upload.maximum_size=28672 -ethertftp.upload.speed=115200 - -ethertftp.bootloader.low_fuses=0xFF -ethertftp.bootloader.high_fuses=0xD8 -ethertftp.bootloader.extended_fuses=0x05 -ethertftp.bootloader.path=tftpboot -ethertftp.bootloader.file=tftpboot_atmega328_ether.hex -ethertftp.bootloader.unlock_bits=0x3F -ethertftp.bootloader.lock_bits=0x2F - -ethertftp.build.mcu=atmega328p -ethertftp.build.f_cpu=16000000L -ethertftp.build.core=arduino:arduino -ethertftp.build.variant=arduino:standard - -############################################################## \ No newline at end of file diff --git a/hardware/tftpboot/bootloaders/tftpboot/neteeprom.h b/hardware/tftpboot/bootloaders/tftpboot/neteeprom.h deleted file mode 100644 index 6f0f908..0000000 --- a/hardware/tftpboot/bootloaders/tftpboot/neteeprom.h +++ /dev/null @@ -1,16 +0,0 @@ -#include - -#define EEPROM_SIG_1 ((uint8_t*)0) -#define EEPROM_SIG_2 ((uint8_t*)1) -#define EEPROM_IMG_STAT ((uint8_t*)2) -#define EEPROM_DATA ((uint8_t*)3) -#define EEPROM_GATEWAY ((uint8_t*)3) -#define EEPROM_SUB ((uint8_t*)7) -#define EEPROM_MAC ((uint8_t*)11) -#define EEPROM_IP ((uint8_t*)17) - - -#define EEPROM_SIG_1_VALUE (0x55) -#define EEPROM_SIG_2_VALUE (0xAA) -#define EEPROM_IMG_OK_VALUE (0xBB) -#define EEPROM_IMG_BAD_VALUE (0xFF) \ No newline at end of file diff --git a/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328.hex b/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328.hex deleted file mode 100644 index 5366b59..0000000 --- a/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328.hex +++ /dev/null @@ -1,161 +0,0 @@ -:1070000050C00000BEC00000BCC00000BAC00000FC -:10701000B8C00000B6C00000B4C00000B2C000009C -:10702000B0C00000AEC00000ACC00000AAC00000AC -:10703000A8C00000A6C00000A4C00000A2C00000BC -:10704000A0C000009EC000009CC000009AC00000CC -:1070500098C0000096C0000094C0000092C00000DC -:1070600090C000008EC000001300050000496E763D -:10707000616C696420696D6167652066696C650093 -:1070800008000500004572726F72000900050003D8 -:1070900046756C6C000A000500004F70636F6465F4 -:1070A0003F0011241FBECFEFD8E0DEBFCDBF11E0FF -:1070B000A0E0B1E0E8ECF9E702C005900D92AC3138 -:1070C000B107D9F711E0ACE1B1E001C01D92A932DE -:1070D000B107E1F701D076C4EED22FEF85EA9EE04A -:1070E000215080409040E1F700C00000112485E06D -:1070F00080938100E6D39ED07ED2EFEFF5EA2EE0BA -:10710000E150F0402040E1F700C00000109224015F -:1071100010922501C3E0E12CF12C809124018823F9 -:1071200029F080912501882349F004C080D2811183 -:10713000F8CF20C018D4811105C01AC0B8D381116E -:10714000F9CF18C080912501813069F41092250192 -:1071500007B600FCFDCFF999FECFF701C7BFE89550 -:10716000FDD349D205C082E090E016D48B3B11F0EC -:10717000D3D3D3CFE0911C01F0911D01099580E09C -:1071800090E03ECF20E52CBD2A9820EF2EBD0DB417 -:1071900007FEFDCF292F33272EBD0DB407FEFDCFEF -:1071A0008EBD0DB407FEFDCF6EBD0DB407FEFDCF45 -:1071B0002A9A1CBC089520E52CBD2A982FE02EBDEC -:1071C0000DB407FEFDCF292F33272EBD0DB407FECA -:1071D000FDCF8EBD0DB407FEFDCF1EBC0DB407FE66 -:1071E000FDCF2A9A8EB51CBC0895EF92FF92CF93E3 -:1071F0007C01E1DFC82FC7010196DDDF2C2F30E0D5 -:10720000322F2227A901482BCA01CF91FF90EF907E -:107210000895CF92DF92EF92FF927C016B01672F6E -:107220007727B0DF6C2DC7010196FF90EF90DF90BC -:10723000CF90A8CFCF92DF92EF92FF928CE284B9E9 -:107240008CE385B981E08DBD80E090E0A5D38535E4 -:1072500039F0E0E0CE2EE1E0DE2EE12CF12C19C079 -:1072600081E090E099D38A3AA1F761E0C62E61E00F -:10727000D62E73E0E72EF12CC7018ED3F601819351 -:107280006F01FFEFEF1AFF0A85E1E816F104A1F79D -:10729000E0CFF60161916F01C70174DFFFEFEF1AD4 -:1072A000FF0A8CE1E816F104A1F7FF90EF90DF9060 -:1072B000CF900895AF92BF92CF92DF92EF92FF925C -:1072C000CF93DF93CDB7DEB7CC50D240DEBFCDBF7A -:1072D00088E297E08ADF009711F480E098E7EE24D7 -:1072E000E394F12CEC0EFD1E5E0123EFA21A2DEFAC -:1072F000B20A6C01EFEFCE1ADE0A5DDFF70181936F -:107300007F01C114F0E8DF0611F0C60102C080E081 -:1073100098E7EA14FB0469F7BC0188E297E079DF9B -:1073200060E481E097E02EDF81E097E044DF8111A7 -:10733000FBCFCC24C394D12CCC0EDD1E6CE0E62E0A -:1073400067E0F62EF60161916F01C7011BDFFFEFC9 -:10735000EF1AFF0A22E1E21627E0F20699F7EF8022 -:107360002885CB843C85898590E0982F88274A859D -:10737000840F911D83309105C9F138F48130910556 -:1073800039F0029709F0A1C005C0069708F09DC02A -:1073900080E0A2C06FEF82E090E006D360E481E07D -:1073A00097E0F0DE60E181E097E0ECDE62E080E013 -:1073B00097E0E8DE61E081E097E0E4DE69E777EB03 -:1073C00084E097E026DF83E097E0F5DE823221F06B -:1073D00060E181E097E0D6DE83E097E0ECDE823288 -:1073E00029F710921F0110921E0175C0D12CDC2CC0 -:1073F000CC24C30ED11CF12CFE2CEE24E20EF11C89 -:1074000084E0E81AF108D0921F01C0921E01E1E069 -:10741000CE1AD108DC2CCC24DD0CC6018E0D9F1DAC -:107420008130904708F053C003C02FEFE21AF20AF0 -:10743000C7018F779927892BC1F7C114D10431F483 -:10744000CE010D9624D1882309F443C0DE011D9698 -:1074500080E090E041E053E065E071E129C0E1E0C7 -:10746000F0E0EC0FFD1FE80FF91F258530E0322F0B -:107470002227EC912E2BF601090147BFE895112434 -:1074800002969C012F773327232B71F4EE57F109D5 -:1074900057BFE89507B600FCFDCF67BFE89507B674 -:1074A00000FCFDCF77BFE8951296F2E0CF0ED11C1D -:1074B0008E159F05A0F2E11422E0F20660F46BEB5A -:1074C00082E090E071D284E007C081E005C083E0F3 -:1074D00003C085E001C082E0C45FDD4FDEBFCDBFE9 -:1074E000DF91CF91FF90EF90DF90CF90BF90AF9062 -:1074F0000895AF92BF92CF92DF92EF92FF921F93C7 -:10750000CF93DF93CDB7DEB7C456D109DEBFCDBF71 -:107510007C0184E297E069DE985A6C0182E0E8160B -:10752000F10479F120F4EA94EF2849F418C083E0DB -:10753000E816F104E9F0E4E0EE16F10411F14AE096 -:1075400050E060E870E7CE0101961DD28AE0EE249B -:10755000E394F12CEC0EFD1E182F1E0D2EC04CE0F6 -:1075600050E065E970E7CE0101960DD28CE0EFCFD7 -:1075700049E050E06BE870E7CE01019604D289E063 -:10758000E6CF198284E08A8380911E0190911F01C9 -:107590009B838C8384E0DBCFF70161917F015601EF -:1075A000FFEFAF1ABF0AC601EDDDA11480E6B806F1 -:1075B00019F4A12CE8E5BE2E65011E11EDCFB60130 -:1075C000785584E297E025DE60E281E097E0DADD3D -:1075D00081E097E0F0DD8111FBCFCC59DF4FDEBFBA -:1075E000CDBFDF91CF911F91FF90EF90DF90CF90B3 -:1075F000BF90AF90089565E470E084E097E009DE05 -:1076000062E080E097E0BEDD61E081E097E0BADD16 -:1076100083E097E0D0DD823221F060E181E097E005 -:10762000B1DD83E097E0C7DD823229F70895CF937B -:1076300086E297E0DADD892B11F481E026C08091A3 -:107640002501811101C08AD181E08093250182E06A -:1076500097E0B1DD82FF0EC064E082E097E092DD4A -:107660002FEF87E893E1215080409040E1F700C080 -:107670000000EDCF1FDEC82F90E03BDFC430E9F6FD -:1076800060E181E097E07EDD80E0CF91089520E029 -:1076900030E0FC01E20FF31F40814C3051F4418196 -:1076A000443939F42C5F3F4F2433310591F781E0A1 -:1076B000089580E0089584B714BE98E10FB6F89459 -:1076C00090936000109260000FBE0895A8950895F1 -:1076D000E0E6F0E098E190838083089512D1803253 -:1076E00019F088E0F5DFFFCF84E1F8C0CF93C82F11 -:1076F00008D1C150E9F7CF91F1CFEF92FF92CF932C -:10770000DF93CDB7DEB7C150D140DEBFCDBFF9D0DA -:107710008134A9F4F6D0CF5FDE4F8883C150D140C9 -:10772000DDDFCF5FDE4F8881C150D140823811F458 -:1077300083E003C08138E1F780E0D0D0ACC0823470 -:1077400011F484E103C0853419F484E0CFDFA3C0D1 -:10775000853569F4D6D0F82ED4D02F2D30E0382BD3 -:10776000220F331F309321012093200193C08635CF -:1077700019F484E0BBDFE0CF843609F05BC0C1D0F0 -:10778000C0D080932601BDD0E0912001F09121016D -:10779000E11580E7F80718F483E087BFE895EE2449 -:1077A000E394F12CEC0EFD1EACD0F70181937F0128 -:1077B000809126018150809326018111F5CFE091BF -:1077C0002001F0912101E11580E7F80718F083E02E -:1077D00087BFE89583DF07B600FCFDCF409120010D -:1077E00050912101298180E090E061E0A1E0B0E0CA -:1077F000AC0FBD1FA80FB91FFC01E40FF51F1196B8 -:107800007C91119730E0372B090167BFE89511246F -:107810008E37910521F012962C910296E7CF85E0E4 -:10782000FA0187BFE89507B600FCFDCF81E187BF6D -:10783000E89531C08437D1F464D063D080932601B9 -:1078400060D04CDFE0912001F0912101CF01019641 -:107850009093210180932001849140D08091260152 -:107860008150809326018111EDCF15C0853739F401 -:1078700035DF8EE133D085E931D08FE05ECF8135C1 -:1078800049F42CDF6BEB82E090E08ED080E126D0D3 -:1078900080E004C023DF80E121D081E0CF5FDE4FB4 -:1078A000DEBFCDBFDF91CF91FF90EF900895809123 -:1078B000C00087FF04C081E0809324011ECF81E0D7 -:1078C000089582E08093C00088E18093C10086E043 -:1078D0008093C20080E18093C40008959091C0001D -:1078E00095FFFCCF8093C60008958F708A3008F012 -:1078F000895F9091C00095FFFCCF805D8093C600AA -:1079000008958091C00087FFFCCF8091C00084FF64 -:10791000DDDE8091C60008958091840090918500FD -:1079200092FF05C025B130E2232725B901C02D986B -:1079300020912701309128018217930750F420915C -:107940002201309123012F5F3F4F30932301209379 -:10795000220190932801809327010895109223011A -:10796000109222010895E0E0F0E085919491019653 -:1079700041F081E020912201309123012430310532 -:1079800008F480E00895FB01DC0102C005900D922F -:1079900041505040D8F70895F999FECF92BD81BD6E -:1079A000F89A992780B50895262FF999FECF1FBA26 -:1079B00092BD81BD20BD0FB6F894FA9AF99A0FBE18 -:0879C00001960895F894FFCF31 -:1079C80080C0A80101FFFFFF00DEADBEEFFEEDC0E5 -:0C79D800A801800000000007D080555579 -:040000030000700089 -:00000001FF diff --git a/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328.lst b/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328.lst deleted file mode 100644 index 3635944..0000000 --- a/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328.lst +++ /dev/null @@ -1,2138 +0,0 @@ - -tftpboot_atmega328.elf: file format elf32-avr - -Sections: -Idx Name Size VMA LMA File off Algn - 0 .data 0000001c 00800100 000079c8 00000a5c 2**0 - CONTENTS, ALLOC, LOAD, DATA - 1 .text 000009c8 00007000 00007000 00000094 2**1 - CONTENTS, ALLOC, LOAD, READONLY, CODE - 2 .bss 0000000d 0080011c 0080011c 00000a78 2**0 - ALLOC - 3 .stab 00002f70 00000000 00000000 00000a78 2**2 - CONTENTS, READONLY, DEBUGGING - 4 .stabstr 000010b0 00000000 00000000 000039e8 2**0 - CONTENTS, READONLY, DEBUGGING - 5 .comment 00000011 00000000 00000000 00004a98 2**0 - CONTENTS, READONLY - -Disassembly of section .text: - -00007000 <__vectors>: - 7000: 50 c0 rjmp .+160 ; 0x70a2 <__ctors_end> - 7002: 00 00 nop - 7004: be c0 rjmp .+380 ; 0x7182 <__bad_interrupt> - 7006: 00 00 nop - 7008: bc c0 rjmp .+376 ; 0x7182 <__bad_interrupt> - 700a: 00 00 nop - 700c: ba c0 rjmp .+372 ; 0x7182 <__bad_interrupt> - 700e: 00 00 nop - 7010: b8 c0 rjmp .+368 ; 0x7182 <__bad_interrupt> - 7012: 00 00 nop - 7014: b6 c0 rjmp .+364 ; 0x7182 <__bad_interrupt> - 7016: 00 00 nop - 7018: b4 c0 rjmp .+360 ; 0x7182 <__bad_interrupt> - 701a: 00 00 nop - 701c: b2 c0 rjmp .+356 ; 0x7182 <__bad_interrupt> - 701e: 00 00 nop - 7020: b0 c0 rjmp .+352 ; 0x7182 <__bad_interrupt> - 7022: 00 00 nop - 7024: ae c0 rjmp .+348 ; 0x7182 <__bad_interrupt> - 7026: 00 00 nop - 7028: ac c0 rjmp .+344 ; 0x7182 <__bad_interrupt> - 702a: 00 00 nop - 702c: aa c0 rjmp .+340 ; 0x7182 <__bad_interrupt> - 702e: 00 00 nop - 7030: a8 c0 rjmp .+336 ; 0x7182 <__bad_interrupt> - 7032: 00 00 nop - 7034: a6 c0 rjmp .+332 ; 0x7182 <__bad_interrupt> - 7036: 00 00 nop - 7038: a4 c0 rjmp .+328 ; 0x7182 <__bad_interrupt> - 703a: 00 00 nop - 703c: a2 c0 rjmp .+324 ; 0x7182 <__bad_interrupt> - 703e: 00 00 nop - 7040: a0 c0 rjmp .+320 ; 0x7182 <__bad_interrupt> - 7042: 00 00 nop - 7044: 9e c0 rjmp .+316 ; 0x7182 <__bad_interrupt> - 7046: 00 00 nop - 7048: 9c c0 rjmp .+312 ; 0x7182 <__bad_interrupt> - 704a: 00 00 nop - 704c: 9a c0 rjmp .+308 ; 0x7182 <__bad_interrupt> - 704e: 00 00 nop - 7050: 98 c0 rjmp .+304 ; 0x7182 <__bad_interrupt> - 7052: 00 00 nop - 7054: 96 c0 rjmp .+300 ; 0x7182 <__bad_interrupt> - 7056: 00 00 nop - 7058: 94 c0 rjmp .+296 ; 0x7182 <__bad_interrupt> - 705a: 00 00 nop - 705c: 92 c0 rjmp .+292 ; 0x7182 <__bad_interrupt> - 705e: 00 00 nop - 7060: 90 c0 rjmp .+288 ; 0x7182 <__bad_interrupt> - 7062: 00 00 nop - 7064: 8e c0 rjmp .+284 ; 0x7182 <__bad_interrupt> - ... - -00007068 : - 7068: 13 00 05 00 00 49 6e 76 61 6c 69 64 20 69 6d 61 .....Invalid ima - 7078: 67 65 20 66 69 6c 65 00 ge file. - -00007080 : - 7080: 08 00 05 00 00 45 72 72 6f 72 00 .....Error. - -0000708b : - 708b: 09 00 05 00 03 46 75 6c 6c 00 .....Full. - -00007095 : - 7095: 0a 00 05 00 00 4f 70 63 6f 64 65 3f 00 .....Opcode?. - -000070a2 <__ctors_end>: - 70a2: 11 24 eor r1, r1 - 70a4: 1f be out 0x3f, r1 ; 63 - 70a6: cf ef ldi r28, 0xFF ; 255 - 70a8: d8 e0 ldi r29, 0x08 ; 8 - 70aa: de bf out 0x3e, r29 ; 62 - 70ac: cd bf out 0x3d, r28 ; 61 - -000070ae <__do_copy_data>: - 70ae: 11 e0 ldi r17, 0x01 ; 1 - 70b0: a0 e0 ldi r26, 0x00 ; 0 - 70b2: b1 e0 ldi r27, 0x01 ; 1 - 70b4: e8 ec ldi r30, 0xC8 ; 200 - 70b6: f9 e7 ldi r31, 0x79 ; 121 - 70b8: 02 c0 rjmp .+4 ; 0x70be <__do_copy_data+0x10> - 70ba: 05 90 lpm r0, Z+ - 70bc: 0d 92 st X+, r0 - 70be: ac 31 cpi r26, 0x1C ; 28 - 70c0: b1 07 cpc r27, r17 - 70c2: d9 f7 brne .-10 ; 0x70ba <__do_copy_data+0xc> - -000070c4 <__do_clear_bss>: - 70c4: 11 e0 ldi r17, 0x01 ; 1 - 70c6: ac e1 ldi r26, 0x1C ; 28 - 70c8: b1 e0 ldi r27, 0x01 ; 1 - 70ca: 01 c0 rjmp .+2 ; 0x70ce <.do_clear_bss_start> - -000070cc <.do_clear_bss_loop>: - 70cc: 1d 92 st X+, r1 - -000070ce <.do_clear_bss_start>: - 70ce: a9 32 cpi r26, 0x29 ; 41 - 70d0: b1 07 cpc r27, r17 - 70d2: e1 f7 brne .-8 ; 0x70cc <.do_clear_bss_loop> - 70d4: 01 d0 rcall .+2 ; 0x70d8
- 70d6: 76 c4 rjmp .+2284 ; 0x79c4 <_exit> - -000070d8
: - 70d8: ee d2 rcall .+1500 ; 0x76b6 - 70da: 2f ef ldi r18, 0xFF ; 255 - 70dc: 85 ea ldi r24, 0xA5 ; 165 - 70de: 9e e0 ldi r25, 0x0E ; 14 - 70e0: 21 50 subi r18, 0x01 ; 1 - 70e2: 80 40 sbci r24, 0x00 ; 0 - 70e4: 90 40 sbci r25, 0x00 ; 0 - 70e6: e1 f7 brne .-8 ; 0x70e0 - 70e8: 00 c0 rjmp .+0 ; 0x70ea - 70ea: 00 00 nop - 70ec: 11 24 eor r1, r1 - 70ee: 85 e0 ldi r24, 0x05 ; 5 - 70f0: 80 93 81 00 sts 0x0081, r24 - 70f4: e6 d3 rcall .+1996 ; 0x78c2 - 70f6: 9e d0 rcall .+316 ; 0x7234 - 70f8: 7e d2 rcall .+1276 ; 0x75f6 - 70fa: ef ef ldi r30, 0xFF ; 255 - 70fc: f5 ea ldi r31, 0xA5 ; 165 - 70fe: 2e e0 ldi r18, 0x0E ; 14 - 7100: e1 50 subi r30, 0x01 ; 1 - 7102: f0 40 sbci r31, 0x00 ; 0 - 7104: 20 40 sbci r18, 0x00 ; 0 - 7106: e1 f7 brne .-8 ; 0x7100 - 7108: 00 c0 rjmp .+0 ; 0x710a - 710a: 00 00 nop - 710c: 10 92 24 01 sts 0x0124, r1 - 7110: 10 92 25 01 sts 0x0125, r1 - 7114: c3 e0 ldi r28, 0x03 ; 3 - 7116: e1 2c mov r14, r1 - 7118: f1 2c mov r15, r1 - 711a: 80 91 24 01 lds r24, 0x0124 - 711e: 88 23 and r24, r24 - 7120: 29 f0 breq .+10 ; 0x712c - 7122: 80 91 25 01 lds r24, 0x0125 - 7126: 88 23 and r24, r24 - 7128: 49 f0 breq .+18 ; 0x713c - 712a: 04 c0 rjmp .+8 ; 0x7134 - 712c: 80 d2 rcall .+1280 ; 0x762e - 712e: 81 11 cpse r24, r1 - 7130: f8 cf rjmp .-16 ; 0x7122 - 7132: 20 c0 rjmp .+64 ; 0x7174 - 7134: 18 d4 rcall .+2096 ; 0x7966 - 7136: 81 11 cpse r24, r1 - 7138: 05 c0 rjmp .+10 ; 0x7144 - 713a: 1a c0 rjmp .+52 ; 0x7170 - 713c: b8 d3 rcall .+1904 ; 0x78ae - 713e: 81 11 cpse r24, r1 - 7140: f9 cf rjmp .-14 ; 0x7134 - 7142: 18 c0 rjmp .+48 ; 0x7174 - 7144: 80 91 25 01 lds r24, 0x0125 - 7148: 81 30 cpi r24, 0x01 ; 1 - 714a: 69 f4 brne .+26 ; 0x7166 - 714c: 10 92 25 01 sts 0x0125, r1 - 7150: 07 b6 in r0, 0x37 ; 55 - 7152: 00 fc sbrc r0, 0 - 7154: fd cf rjmp .-6 ; 0x7150 - 7156: f9 99 sbic 0x1f, 1 ; 31 - 7158: fe cf rjmp .-4 ; 0x7156 - 715a: f7 01 movw r30, r14 - 715c: c7 bf out 0x37, r28 ; 55 - 715e: e8 95 spm - 7160: fd d3 rcall .+2042 ; 0x795c - 7162: 49 d2 rcall .+1170 ; 0x75f6 - 7164: 05 c0 rjmp .+10 ; 0x7170 - 7166: 82 e0 ldi r24, 0x02 ; 2 - 7168: 90 e0 ldi r25, 0x00 ; 0 - 716a: 16 d4 rcall .+2092 ; 0x7998 <__eerd_byte_m328p> - 716c: 8b 3b cpi r24, 0xBB ; 187 - 716e: 11 f0 breq .+4 ; 0x7174 - 7170: d3 d3 rcall .+1958 ; 0x7918 - 7172: d3 cf rjmp .-90 ; 0x711a - 7174: e0 91 1c 01 lds r30, 0x011C - 7178: f0 91 1d 01 lds r31, 0x011D - 717c: 09 95 icall - 717e: 80 e0 ldi r24, 0x00 ; 0 - 7180: 90 e0 ldi r25, 0x00 ; 0 - -00007182 <__bad_interrupt>: - 7182: 3e cf rjmp .-388 ; 0x7000 <__vectors> - -00007184 : - trace(", "); - tracenum(value); -#endif - - // Send uint8_t to Ethernet controller - SPCR = _BV(SPE) | _BV(MSTR); // Set SPI as master - 7184: 20 e5 ldi r18, 0x50 ; 80 - 7186: 2c bd out 0x2c, r18 ; 44 - SS_LOW(); - 7188: 2a 98 cbi 0x05, 2 ; 5 - SPDR = SPI_WRITE; - 718a: 20 ef ldi r18, 0xF0 ; 240 - 718c: 2e bd out 0x2e, r18 ; 46 - while(!(SPSR & _BV(SPIF))); - 718e: 0d b4 in r0, 0x2d ; 45 - 7190: 07 fe sbrs r0, 7 - 7192: fd cf rjmp .-6 ; 0x718e - SPDR = address >> 8; - 7194: 29 2f mov r18, r25 - 7196: 33 27 eor r19, r19 - 7198: 2e bd out 0x2e, r18 ; 46 - while(!(SPSR & _BV(SPIF))); - 719a: 0d b4 in r0, 0x2d ; 45 - 719c: 07 fe sbrs r0, 7 - 719e: fd cf rjmp .-6 ; 0x719a - SPDR = address & 0xff; - 71a0: 8e bd out 0x2e, r24 ; 46 - while(!(SPSR & _BV(SPIF))); - 71a2: 0d b4 in r0, 0x2d ; 45 - 71a4: 07 fe sbrs r0, 7 - 71a6: fd cf rjmp .-6 ; 0x71a2 - SPDR = value; - 71a8: 6e bd out 0x2e, r22 ; 46 - while(!(SPSR & _BV(SPIF))); - 71aa: 0d b4 in r0, 0x2d ; 45 - 71ac: 07 fe sbrs r0, 7 - 71ae: fd cf rjmp .-6 ; 0x71aa - SS_HIGH(); - 71b0: 2a 9a sbi 0x05, 2 ; 5 - SPCR = 0; // Turn of SPI - 71b2: 1c bc out 0x2c, r1 ; 44 - 71b4: 08 95 ret - -000071b6 : -// tracenum(address); -//#endif - - // Read uint8_t from Ethernet controller - uint8_t returnValue; - SPCR = _BV(SPE) | _BV(MSTR); - 71b6: 20 e5 ldi r18, 0x50 ; 80 - 71b8: 2c bd out 0x2c, r18 ; 44 - SS_LOW(); - 71ba: 2a 98 cbi 0x05, 2 ; 5 - SPDR = SPI_READ; - 71bc: 2f e0 ldi r18, 0x0F ; 15 - 71be: 2e bd out 0x2e, r18 ; 46 - while(!(SPSR & _BV(SPIF))); - 71c0: 0d b4 in r0, 0x2d ; 45 - 71c2: 07 fe sbrs r0, 7 - 71c4: fd cf rjmp .-6 ; 0x71c0 - SPDR = address >> 8; - 71c6: 29 2f mov r18, r25 - 71c8: 33 27 eor r19, r19 - 71ca: 2e bd out 0x2e, r18 ; 46 - while(!(SPSR & _BV(SPIF))); - 71cc: 0d b4 in r0, 0x2d ; 45 - 71ce: 07 fe sbrs r0, 7 - 71d0: fd cf rjmp .-6 ; 0x71cc - SPDR = address & 0xff; - 71d2: 8e bd out 0x2e, r24 ; 46 - while(!(SPSR & _BV(SPIF))); - 71d4: 0d b4 in r0, 0x2d ; 45 - 71d6: 07 fe sbrs r0, 7 - 71d8: fd cf rjmp .-6 ; 0x71d4 - SPDR = 0; - 71da: 1e bc out 0x2e, r1 ; 46 - while(!(SPSR & _BV(SPIF))); - 71dc: 0d b4 in r0, 0x2d ; 45 - 71de: 07 fe sbrs r0, 7 - 71e0: fd cf rjmp .-6 ; 0x71dc - SS_HIGH(); - 71e2: 2a 9a sbi 0x05, 2 ; 5 - returnValue = SPDR; - 71e4: 8e b5 in r24, 0x2e ; 46 - SPCR = 0; - 71e6: 1c bc out 0x2c, r1 ; 44 - return(returnValue); -} - 71e8: 08 95 ret - -000071ea : - -uint16_t netReadWord(uint16_t address) -{ - 71ea: ef 92 push r14 - 71ec: ff 92 push r15 - 71ee: cf 93 push r28 - 71f0: 7c 01 movw r14, r24 - // Read uint16_t from Ethernet controller - return((netReadReg(address) << 8) | netReadReg(address + 1)); - 71f2: e1 df rcall .-62 ; 0x71b6 - 71f4: c8 2f mov r28, r24 - 71f6: c7 01 movw r24, r14 - 71f8: 01 96 adiw r24, 0x01 ; 1 - 71fa: dd df rcall .-70 ; 0x71b6 - 71fc: 2c 2f mov r18, r28 - 71fe: 30 e0 ldi r19, 0x00 ; 0 - 7200: 32 2f mov r19, r18 - 7202: 22 27 eor r18, r18 -} - 7204: a9 01 movw r20, r18 - 7206: 48 2b or r20, r24 - 7208: ca 01 movw r24, r20 - 720a: cf 91 pop r28 - 720c: ff 90 pop r15 - 720e: ef 90 pop r14 - 7210: 08 95 ret - -00007212 : - -void netWriteWord(uint16_t address, uint16_t value) -{ - 7212: cf 92 push r12 - 7214: df 92 push r13 - 7216: ef 92 push r14 - 7218: ff 92 push r15 - 721a: 7c 01 movw r14, r24 - 721c: 6b 01 movw r12, r22 - // Write uint16_t to Ethernet controller - netWriteReg(address++, value >> 8); - 721e: 67 2f mov r22, r23 - 7220: 77 27 eor r23, r23 - 7222: b0 df rcall .-160 ; 0x7184 - netWriteReg(address, value & 0xff); - 7224: 6c 2d mov r22, r12 - 7226: c7 01 movw r24, r14 - 7228: 01 96 adiw r24, 0x01 ; 1 -} - 722a: ff 90 pop r15 - 722c: ef 90 pop r14 - 722e: df 90 pop r13 - 7230: cf 90 pop r12 - -void netWriteWord(uint16_t address, uint16_t value) -{ - // Write uint16_t to Ethernet controller - netWriteReg(address++, value >> 8); - netWriteReg(address, value & 0xff); - 7232: a8 cf rjmp .-176 ; 0x7184 - -00007234 : -} - -void netInit() -{ - 7234: cf 92 push r12 - 7236: df 92 push r13 - 7238: ef 92 push r14 - 723a: ff 92 push r15 - uint8_t i; - - // Set up outputs to communicate with W5100 chip - // Set pins as output - DDRB = _BV(SCK) | _BV(MOSI) | _BV(SS); - 723c: 8c e2 ldi r24, 0x2C ; 44 - 723e: 84 b9 out 0x04, r24 ; 4 - // Set pins high - PORTB = _BV(SCK) | _BV(MISO) | _BV(MOSI) | _BV(SS); - 7240: 8c e3 ldi r24, 0x3C ; 60 - 7242: 85 b9 out 0x05, r24 ; 5 - PORTB |= _BV(LED); -#endif - - // Set up SPI - // Set the Double SPI Speed Bit - SPSR = (1 << SPI2X); - 7244: 81 e0 ldi r24, 0x01 ; 1 - 7246: 8d bd out 0x2d, r24 ; 45 - - - /* Pull in altered presets - * if available from AVR EEPROM (if signature bytes are set)*/ - if((eeprom_read_byte(EEPROM_SIG_1) == EEPROM_SIG_1_VALUE) - 7248: 80 e0 ldi r24, 0x00 ; 0 - 724a: 90 e0 ldi r25, 0x00 ; 0 - 724c: a5 d3 rcall .+1866 ; 0x7998 <__eerd_byte_m328p> - 724e: 85 35 cpi r24, 0x55 ; 85 - 7250: 39 f0 breq .+14 ; 0x7260 - 7252: e0 e0 ldi r30, 0x00 ; 0 - 7254: ce 2e mov r12, r30 - 7256: e1 e0 ldi r30, 0x01 ; 1 - 7258: de 2e mov r13, r30 - && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { - 725a: e1 2c mov r14, r1 - 725c: f1 2c mov r15, r1 - 725e: 19 c0 rjmp .+50 ; 0x7292 - 7260: 81 e0 ldi r24, 0x01 ; 1 - 7262: 90 e0 ldi r25, 0x00 ; 0 - 7264: 99 d3 rcall .+1842 ; 0x7998 <__eerd_byte_m328p> - 7266: 8a 3a cpi r24, 0xAA ; 170 - 7268: a1 f7 brne .-24 ; 0x7252 - 726a: 61 e0 ldi r22, 0x01 ; 1 - 726c: c6 2e mov r12, r22 - 726e: 61 e0 ldi r22, 0x01 ; 1 - 7270: d6 2e mov r13, r22 - 7272: 73 e0 ldi r23, 0x03 ; 3 - 7274: e7 2e mov r14, r23 - 7276: f1 2c mov r15, r1 - -#ifdef _VERBOSE - traceln(" Net: Using EEPROM settings"); -#endif - for(i = 0; i < 18; i++) - registerBuffer[i+1] = eeprom_read_byte(EEPROM_DATA+i); - 7278: c7 01 movw r24, r14 - 727a: 8e d3 rcall .+1820 ; 0x7998 <__eerd_byte_m328p> - 727c: f6 01 movw r30, r12 - 727e: 81 93 st Z+, r24 - 7280: 6f 01 movw r12, r30 - 7282: ff ef ldi r31, 0xFF ; 255 - 7284: ef 1a sub r14, r31 - 7286: ff 0a sbc r15, r31 - && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { - -#ifdef _VERBOSE - traceln(" Net: Using EEPROM settings"); -#endif - for(i = 0; i < 18; i++) - 7288: 85 e1 ldi r24, 0x15 ; 21 - 728a: e8 16 cp r14, r24 - 728c: f1 04 cpc r15, r1 - 728e: a1 f7 brne .-24 ; 0x7278 - 7290: e0 cf rjmp .-64 ; 0x7252 - } -#endif - - // Configure Wiznet chip - for(i = 0; i < REGISTER_BLOCK_SIZE; i++) - netWriteReg(i, registerBuffer[i]); - 7292: f6 01 movw r30, r12 - 7294: 61 91 ld r22, Z+ - 7296: 6f 01 movw r12, r30 - 7298: c7 01 movw r24, r14 - 729a: 74 df rcall .-280 ; 0x7184 - 729c: ff ef ldi r31, 0xFF ; 255 - 729e: ef 1a sub r14, r31 - 72a0: ff 0a sbc r15, r31 - if(i != 14) putch(0x2E); - } -#endif - - // Configure Wiznet chip - for(i = 0; i < REGISTER_BLOCK_SIZE; i++) - 72a2: 8c e1 ldi r24, 0x1C ; 28 - 72a4: e8 16 cp r14, r24 - 72a6: f1 04 cpc r15, r1 - 72a8: a1 f7 brne .-24 ; 0x7292 - netWriteReg(i, registerBuffer[i]); -#ifdef _VERBOSE - traceln(" Net: Network init done"); -#endif -} - 72aa: ff 90 pop r15 - 72ac: ef 90 pop r14 - 72ae: df 90 pop r13 - 72b0: cf 90 pop r12 - 72b2: 08 95 ret - -000072b4 : -#ifdef _DEBUG_TFTP -uint8_t processPacket(uint16_t packetSize) -{ -#else -uint8_t processPacket() -{ - 72b4: af 92 push r10 - 72b6: bf 92 push r11 - 72b8: cf 92 push r12 - 72ba: df 92 push r13 - 72bc: ef 92 push r14 - 72be: ff 92 push r15 - 72c0: cf 93 push r28 - 72c2: df 93 push r29 - 72c4: cd b7 in r28, 0x3d ; 61 - 72c6: de b7 in r29, 0x3e ; 62 - 72c8: cc 50 subi r28, 0x0C ; 12 - 72ca: d2 40 sbci r29, 0x02 ; 2 - 72cc: de bf out 0x3e, r29 ; 62 - 72ce: cd bf out 0x3d, r28 ; 61 - tracenum(packetSize); - if(packetSize >= 0x800) traceln("Tftp: Overflow"); - // step(); -#endif - - readPointer = netReadWord(REG_S3_RX_RD0); - 72d0: 88 e2 ldi r24, 0x28 ; 40 - 72d2: 97 e0 ldi r25, 0x07 ; 7 - 72d4: 8a df rcall .-236 ; 0x71ea -#ifdef _DEBUG_TFTP - traceln("Tftp: readPointer at position "); - tracenum(readPointer); -#endif - if(readPointer == 0) readPointer += S3_RX_START; - 72d6: 00 97 sbiw r24, 0x00 ; 0 - 72d8: 11 f4 brne .+4 ; 0x72de - 72da: 80 e0 ldi r24, 0x00 ; 0 - 72dc: 98 e7 ldi r25, 0x78 ; 120 - 72de: ee 24 eor r14, r14 - 72e0: e3 94 inc r14 - 72e2: f1 2c mov r15, r1 - 72e4: ec 0e add r14, r28 - 72e6: fd 1e adc r15, r29 - -#ifdef _DEBUG_TFTP -uint8_t processPacket(uint16_t packetSize) -{ -#else -uint8_t processPacket() - 72e8: 5e 01 movw r10, r28 - 72ea: 23 ef ldi r18, 0xF3 ; 243 - 72ec: a2 1a sub r10, r18 - 72ee: 2d ef ldi r18, 0xFD ; 253 - 72f0: b2 0a sbc r11, r18 - if((count == TFTP_PACKET_MAX_SIZE - 1) || (count == 0)) { - traceln("Tftp: Reading from position "); - tracenum(readPointer); - } -#endif - *bufPtr++ = netReadReg(readPointer++); - 72f2: 6c 01 movw r12, r24 - 72f4: ef ef ldi r30, 0xFF ; 255 - 72f6: ce 1a sub r12, r30 - 72f8: de 0a sbc r13, r30 - 72fa: 5d df rcall .-326 ; 0x71b6 - 72fc: f7 01 movw r30, r14 - 72fe: 81 93 st Z+, r24 - 7300: 7f 01 movw r14, r30 - if(readPointer == S3_RX_END) readPointer = S3_RX_START; - 7302: c1 14 cp r12, r1 - 7304: f0 e8 ldi r31, 0x80 ; 128 - 7306: df 06 cpc r13, r31 - 7308: 11 f0 breq .+4 ; 0x730e - 730a: c6 01 movw r24, r12 - 730c: 02 c0 rjmp .+4 ; 0x7312 - 730e: 80 e0 ldi r24, 0x00 ; 0 - 7310: 98 e7 ldi r25, 0x78 ; 120 -#ifdef _DEBUG_TFTP - traceln("Tftp: readPointer at position "); - tracenum(readPointer); -#endif - if(readPointer == 0) readPointer += S3_RX_START; - for(count = TFTP_PACKET_MAX_SIZE; count--;) { - 7312: ea 14 cp r14, r10 - 7314: fb 04 cpc r15, r11 - 7316: 69 f7 brne .-38 ; 0x72f2 - } -#endif - *bufPtr++ = netReadReg(readPointer++); - if(readPointer == S3_RX_END) readPointer = S3_RX_START; - } - netWriteWord(REG_S3_RX_RD0, readPointer); // Write back new pointer - 7318: bc 01 movw r22, r24 - 731a: 88 e2 ldi r24, 0x28 ; 40 - 731c: 97 e0 ldi r25, 0x07 ; 7 - 731e: 79 df rcall .-270 ; 0x7212 - netWriteReg(REG_S3_CR, CR_RECV); - 7320: 60 e4 ldi r22, 0x40 ; 64 - 7322: 81 e0 ldi r24, 0x01 ; 1 - 7324: 97 e0 ldi r25, 0x07 ; 7 - 7326: 2e df rcall .-420 ; 0x7184 - while(netReadReg(REG_S3_CR)); - 7328: 81 e0 ldi r24, 0x01 ; 1 - 732a: 97 e0 ldi r25, 0x07 ; 7 - 732c: 44 df rcall .-376 ; 0x71b6 - 732e: 81 11 cpse r24, r1 - 7330: fb cf rjmp .-10 ; 0x7328 - 7332: cc 24 eor r12, r12 - 7334: c3 94 inc r12 - 7336: d1 2c mov r13, r1 - 7338: cc 0e add r12, r28 - 733a: dd 1e adc r13, r29 - 733c: 6c e0 ldi r22, 0x0C ; 12 - 733e: e6 2e mov r14, r22 - 7340: 67 e0 ldi r22, 0x07 ; 7 - 7342: f6 2e mov r15, r22 - traceln("Tftp: Setting return address"); -#endif - - // Set up return IP address and port - uint8_t i; - for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); - 7344: f6 01 movw r30, r12 - 7346: 61 91 ld r22, Z+ - 7348: 6f 01 movw r12, r30 - 734a: c7 01 movw r24, r14 - 734c: 1b df rcall .-458 ; 0x7184 - 734e: ff ef ldi r31, 0xFF ; 255 - 7350: ef 1a sub r14, r31 - 7352: ff 0a sbc r15, r31 - 7354: 22 e1 ldi r18, 0x12 ; 18 - 7356: e2 16 cp r14, r18 - 7358: 27 e0 ldi r18, 0x07 ; 7 - 735a: f2 06 cpc r15, r18 - 735c: 99 f7 brne .-26 ; 0x7344 - - // Parse packet - uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; - 735e: ef 80 ldd r14, Y+7 ; 0x07 - 7360: 28 85 ldd r18, Y+8 ; 0x08 - uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; - uint16_t tftpBlock = (buffer[10] << 8) + buffer[11]; - 7362: cb 84 ldd r12, Y+11 ; 0x0b - 7364: 3c 85 ldd r19, Y+12 ; 0x0c - uint8_t i; - for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); - - // Parse packet - uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; - uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; - 7366: 89 85 ldd r24, Y+9 ; 0x09 - 7368: 90 e0 ldi r25, 0x00 ; 0 - 736a: 98 2f mov r25, r24 - 736c: 88 27 eor r24, r24 - 736e: 4a 85 ldd r20, Y+10 ; 0x0a - 7370: 84 0f add r24, r20 - 7372: 91 1d adc r25, r1 - - uint8_t returnCode = ERROR_UNKNOWN; - uint16_t packetLength; - - - switch(tftpOpcode) { - 7374: 83 30 cpi r24, 0x03 ; 3 - 7376: 91 05 cpc r25, r1 - 7378: c9 f1 breq .+114 ; 0x73ec - 737a: 38 f4 brcc .+14 ; 0x738a - 737c: 81 30 cpi r24, 0x01 ; 1 - 737e: 91 05 cpc r25, r1 - 7380: 39 f0 breq .+14 ; 0x7390 - 7382: 02 97 sbiw r24, 0x02 ; 2 - 7384: 09 f0 breq .+2 ; 0x7388 - 7386: a1 c0 rjmp .+322 ; 0x74ca - 7388: 05 c0 rjmp .+10 ; 0x7394 - 738a: 06 97 sbiw r24, 0x06 ; 6 - 738c: 08 f0 brcs .+2 ; 0x7390 - 738e: 9d c0 rjmp .+314 ; 0x74ca - tracenum(tftpOpcode); - trace(" and data length "); - tracenum(tftpDataLen - (TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE)); -#endif - - uint8_t returnCode = ERROR_UNKNOWN; - 7390: 80 e0 ldi r24, 0x00 ; 0 - 7392: a2 c0 rjmp .+324 ; 0x74d8 - case TFTP_OPCODE_WRQ: // Write request -#ifdef _VERBOSE - traceln("Tftp: Write request"); -#endif - // Flagging image as invalid since the flashing process has started - eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_BAD_VALUE); - 7394: 6f ef ldi r22, 0xFF ; 255 - 7396: 82 e0 ldi r24, 0x02 ; 2 - 7398: 90 e0 ldi r25, 0x00 ; 0 - 739a: 06 d3 rcall .+1548 ; 0x79a8 <__eewr_byte_m328p> - netWriteReg(REG_S3_CR, CR_RECV); - 739c: 60 e4 ldi r22, 0x40 ; 64 - 739e: 81 e0 ldi r24, 0x01 ; 1 - 73a0: 97 e0 ldi r25, 0x07 ; 7 - 73a2: f0 de rcall .-544 ; 0x7184 - netWriteReg(REG_S3_CR, CR_CLOSE); - 73a4: 60 e1 ldi r22, 0x10 ; 16 - 73a6: 81 e0 ldi r24, 0x01 ; 1 - 73a8: 97 e0 ldi r25, 0x07 ; 7 - 73aa: ec de rcall .-552 ; 0x7184 - do { - netWriteReg(REG_S3_MR, MR_UDP); - 73ac: 62 e0 ldi r22, 0x02 ; 2 - 73ae: 80 e0 ldi r24, 0x00 ; 0 - 73b0: 97 e0 ldi r25, 0x07 ; 7 - 73b2: e8 de rcall .-560 ; 0x7184 - netWriteReg(REG_S3_CR, CR_OPEN); - 73b4: 61 e0 ldi r22, 0x01 ; 1 - 73b6: 81 e0 ldi r24, 0x01 ; 1 - 73b8: 97 e0 ldi r25, 0x07 ; 7 - 73ba: e4 de rcall .-568 ; 0x7184 -#ifdef _TFTP_RANDOM_PORT - netWriteWord(REG_S3_PORT0, (buffer[4]<<8) | ~buffer[5]); // Generate a 'random' TID (RFC1350) -#else - netWriteWord(REG_S3_PORT0, TFTP_STATIC_PORT); // Not random any more - 73bc: 69 e7 ldi r22, 0x79 ; 121 - 73be: 77 eb ldi r23, 0xB7 ; 183 - 73c0: 84 e0 ldi r24, 0x04 ; 4 - 73c2: 97 e0 ldi r25, 0x07 ; 7 - 73c4: 26 df rcall .-436 ; 0x7212 -#endif - if(netReadReg(REG_S3_SR) != SOCK_UDP) - 73c6: 83 e0 ldi r24, 0x03 ; 3 - 73c8: 97 e0 ldi r25, 0x07 ; 7 - 73ca: f5 de rcall .-534 ; 0x71b6 - 73cc: 82 32 cpi r24, 0x22 ; 34 - 73ce: 21 f0 breq .+8 ; 0x73d8 - netWriteReg(REG_S3_CR, CR_CLOSE); - 73d0: 60 e1 ldi r22, 0x10 ; 16 - 73d2: 81 e0 ldi r24, 0x01 ; 1 - 73d4: 97 e0 ldi r25, 0x07 ; 7 - 73d6: d6 de rcall .-596 ; 0x7184 - } while(netReadReg(REG_S3_SR) != SOCK_UDP); - 73d8: 83 e0 ldi r24, 0x03 ; 3 - 73da: 97 e0 ldi r25, 0x07 ; 7 - 73dc: ec de rcall .-552 ; 0x71b6 - 73de: 82 32 cpi r24, 0x22 ; 34 - 73e0: 29 f7 brne .-54 ; 0x73ac - tracenum((buffer[4]<<8) | (buffer[5]^0x55)); -#else - tracenum(TFTP_STATIC_PORT); -#endif -#endif - lastPacket = 0; - 73e2: 10 92 1f 01 sts 0x011F, r1 - 73e6: 10 92 1e 01 sts 0x011E, r1 - 73ea: 75 c0 rjmp .+234 ; 0x74d6 - for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); - - // Parse packet - uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; - uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; - uint16_t tftpBlock = (buffer[10] << 8) + buffer[11]; - 73ec: d1 2c mov r13, r1 - 73ee: dc 2c mov r13, r12 - 73f0: cc 24 eor r12, r12 - 73f2: c3 0e add r12, r19 - 73f4: d1 1c adc r13, r1 - // Set up return IP address and port - uint8_t i; - for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); - - // Parse packet - uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; - 73f6: f1 2c mov r15, r1 - 73f8: fe 2c mov r15, r14 - 73fa: ee 24 eor r14, r14 - 73fc: e2 0e add r14, r18 - 73fe: f1 1c adc r15, r1 - lastPacket = 0; - returnCode = ACK; // Send back acknowledge for packet 0 - break; - - case TFTP_OPCODE_DATA: - packetLength = tftpDataLen - (TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); - 7400: 84 e0 ldi r24, 0x04 ; 4 - 7402: e8 1a sub r14, r24 - 7404: f1 08 sbc r15, r1 - lastPacket = tftpBlock; - 7406: d0 92 1f 01 sts 0x011F, r13 - 740a: c0 92 1e 01 sts 0x011E, r12 - writeAddr = (tftpBlock - 1) << 9; // Flash write address for this block - 740e: e1 e0 ldi r30, 0x01 ; 1 - 7410: ce 1a sub r12, r30 - 7412: d1 08 sbc r13, r1 - 7414: dc 2c mov r13, r12 - 7416: cc 24 eor r12, r12 - 7418: dd 0c add r13, r13 -#ifdef _VERBOSE - traceln("Tftp: Data for block "); - tracenum(lastPacket); -#endif - - if((writeAddr + packetLength) > MAX_ADDR) { - 741a: c6 01 movw r24, r12 - 741c: 8e 0d add r24, r14 - 741e: 9f 1d adc r25, r15 - 7420: 81 30 cpi r24, 0x01 ; 1 - 7422: 90 47 sbci r25, 0x70 ; 112 - 7424: 08 f0 brcs .+2 ; 0x7428 - 7426: 53 c0 rjmp .+166 ; 0x74ce - 7428: 03 c0 rjmp .+6 ; 0x7430 - - uint8_t *pageBase = buffer + (UDP_HEADER_SIZE + TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); // Start of block data - uint16_t offset = 0; // Block offset - - // Round up packet length to a full flash sector size - while(packetLength % SPM_PAGESIZE) packetLength++; - 742a: 2f ef ldi r18, 0xFF ; 255 - 742c: e2 1a sub r14, r18 - 742e: f2 0a sbc r15, r18 - 7430: c7 01 movw r24, r14 - 7432: 8f 77 andi r24, 0x7F ; 127 - 7434: 99 27 eor r25, r25 - 7436: 89 2b or r24, r25 - 7438: c1 f7 brne .-16 ; 0x742a -#ifdef _DEBUG_TFTP - traceln("Tftp: Packet length adjusted to "); - tracenum(packetLength); -#endif - if(writeAddr == 0) { - 743a: c1 14 cp r12, r1 - 743c: d1 04 cpc r13, r1 - 743e: 31 f4 brne .+12 ; 0x744c - // First sector - validate - if(!validImage(pageBase)) { - 7440: ce 01 movw r24, r28 - 7442: 0d 96 adiw r24, 0x0d ; 13 - 7444: 24 d1 rcall .+584 ; 0x768e - 7446: 88 23 and r24, r24 - 7448: 09 f4 brne .+2 ; 0x744c - 744a: 43 c0 rjmp .+134 ; 0x74d2 -#ifdef _DEBUG_TFTP - traceln("Tftp: Writing data from address "); - tracenum(writeAddr); -#endif - - uint8_t *pageBase = buffer + (UDP_HEADER_SIZE + TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); // Start of block data - 744c: de 01 movw r26, r28 - 744e: 1d 96 adiw r26, 0x0d ; 13 -#endif - } - } - - // Flash packets - for(offset = 0; offset < packetLength;) { - 7450: 80 e0 ldi r24, 0x00 ; 0 - 7452: 90 e0 ldi r25, 0x00 ; 0 - uint16_t writeValue = (pageBase[offset]) | (pageBase[offset + 1] << 8); - boot_page_fill(writeAddr + offset, writeValue); - 7454: 41 e0 ldi r20, 0x01 ; 1 - tracenum(writeAddr + offset); - } -#endif - offset += 2; - if(offset % SPM_PAGESIZE == 0) { - boot_page_erase(writeAddr + offset - SPM_PAGESIZE); - 7456: 53 e0 ldi r21, 0x03 ; 3 - boot_spm_busy_wait(); - boot_page_write(writeAddr + offset - SPM_PAGESIZE); - 7458: 65 e0 ldi r22, 0x05 ; 5 - boot_spm_busy_wait(); - boot_rww_enable(); - 745a: 71 e1 ldi r23, 0x11 ; 17 -#endif - } - } - - // Flash packets - for(offset = 0; offset < packetLength;) { - 745c: 29 c0 rjmp .+82 ; 0x74b0 - -#ifdef _DEBUG_TFTP -uint8_t processPacket(uint16_t packetSize) -{ -#else -uint8_t processPacket() - 745e: e1 e0 ldi r30, 0x01 ; 1 - 7460: f0 e0 ldi r31, 0x00 ; 0 - 7462: ec 0f add r30, r28 - 7464: fd 1f adc r31, r29 - 7466: e8 0f add r30, r24 - 7468: f9 1f adc r31, r25 - } - } - - // Flash packets - for(offset = 0; offset < packetLength;) { - uint16_t writeValue = (pageBase[offset]) | (pageBase[offset + 1] << 8); - 746a: 25 85 ldd r18, Z+13 ; 0x0d - 746c: 30 e0 ldi r19, 0x00 ; 0 - 746e: 32 2f mov r19, r18 - 7470: 22 27 eor r18, r18 - 7472: ec 91 ld r30, X - 7474: 2e 2b or r18, r30 - boot_page_fill(writeAddr + offset, writeValue); - 7476: f6 01 movw r30, r12 - 7478: 09 01 movw r0, r18 - 747a: 47 bf out 0x37, r20 ; 55 - 747c: e8 95 spm - 747e: 11 24 eor r1, r1 - tracenum(writeValue); - trace(" at offset "); - tracenum(writeAddr + offset); - } -#endif - offset += 2; - 7480: 02 96 adiw r24, 0x02 ; 2 - if(offset % SPM_PAGESIZE == 0) { - 7482: 9c 01 movw r18, r24 - 7484: 2f 77 andi r18, 0x7F ; 127 - 7486: 33 27 eor r19, r19 - 7488: 23 2b or r18, r19 - 748a: 71 f4 brne .+28 ; 0x74a8 - boot_page_erase(writeAddr + offset - SPM_PAGESIZE); - 748c: ee 57 subi r30, 0x7E ; 126 - 748e: f1 09 sbc r31, r1 - 7490: 57 bf out 0x37, r21 ; 55 - 7492: e8 95 spm - boot_spm_busy_wait(); - 7494: 07 b6 in r0, 0x37 ; 55 - 7496: 00 fc sbrc r0, 0 - 7498: fd cf rjmp .-6 ; 0x7494 - boot_page_write(writeAddr + offset - SPM_PAGESIZE); - 749a: 67 bf out 0x37, r22 ; 55 - 749c: e8 95 spm - boot_spm_busy_wait(); - 749e: 07 b6 in r0, 0x37 ; 55 - 74a0: 00 fc sbrc r0, 0 - 74a2: fd cf rjmp .-6 ; 0x749e - boot_rww_enable(); - 74a4: 77 bf out 0x37, r23 ; 55 - 74a6: e8 95 spm - 74a8: 12 96 adiw r26, 0x02 ; 2 - 74aa: f2 e0 ldi r31, 0x02 ; 2 - 74ac: cf 0e add r12, r31 - 74ae: d1 1c adc r13, r1 -#endif - } - } - - // Flash packets - for(offset = 0; offset < packetLength;) { - 74b0: 8e 15 cp r24, r14 - 74b2: 9f 05 cpc r25, r15 - 74b4: a0 f2 brcs .-88 ; 0x745e - boot_spm_busy_wait(); - boot_rww_enable(); - } - } - - if(packetLength < TFTP_DATA_SIZE) { - 74b6: e1 14 cp r14, r1 - 74b8: 22 e0 ldi r18, 0x02 ; 2 - 74ba: f2 06 cpc r15, r18 - 74bc: 60 f4 brcc .+24 ; 0x74d6 - // Hand over to application -#ifdef _VERBOSE - traceln("Tftp: Flash is complete"); -#endif - // Flag the image as valid since we received the last packet - eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); - 74be: 6b eb ldi r22, 0xBB ; 187 - 74c0: 82 e0 ldi r24, 0x02 ; 2 - 74c2: 90 e0 ldi r25, 0x00 ; 0 - 74c4: 71 d2 rcall .+1250 ; 0x79a8 <__eewr_byte_m328p> - returnCode = FINAL_ACK; - 74c6: 84 e0 ldi r24, 0x04 ; 4 - 74c8: 07 c0 rjmp .+14 ; 0x74d8 -#ifdef _DEBUG_TFTP - traceln("Tftp: Invalid opcode "); - tracenum(tftpOpcode); -#endif - // Invalid - return error - returnCode = ERROR_INVALID; - 74ca: 81 e0 ldi r24, 0x01 ; 1 - 74cc: 05 c0 rjmp .+10 ; 0x74d8 - // Flash is full - abort with an error before a bootloader overwrite occurs - // Application is now corrupt, so do not hand over. -#ifdef _VERBOSE - traceln("Tftp: Flash is full"); -#endif - returnCode = ERROR_FULL; - 74ce: 83 e0 ldi r24, 0x03 ; 3 - 74d0: 03 c0 rjmp .+6 ; 0x74d8 - tracenum(packetLength); -#endif - if(writeAddr == 0) { - // First sector - validate - if(!validImage(pageBase)) { - returnCode = INVALID_IMAGE; - 74d2: 85 e0 ldi r24, 0x05 ; 5 - 74d4: 01 c0 rjmp .+2 ; 0x74d8 -#endif - // Flag the image as valid since we received the last packet - eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); - returnCode = FINAL_ACK; - } else { - returnCode = ACK; - 74d6: 82 e0 ldi r24, 0x02 ; 2 - returnCode = ERROR_INVALID; - break; - - } - return(returnCode); -} - 74d8: c4 5f subi r28, 0xF4 ; 244 - 74da: dd 4f sbci r29, 0xFD ; 253 - 74dc: de bf out 0x3e, r29 ; 62 - 74de: cd bf out 0x3d, r28 ; 61 - 74e0: df 91 pop r29 - 74e2: cf 91 pop r28 - 74e4: ff 90 pop r15 - 74e6: ef 90 pop r14 - 74e8: df 90 pop r13 - 74ea: cf 90 pop r12 - 74ec: bf 90 pop r11 - 74ee: af 90 pop r10 - 74f0: 08 95 ret - -000074f2 : - - -void sendResponse(uint16_t response) -{ - 74f2: af 92 push r10 - 74f4: bf 92 push r11 - 74f6: cf 92 push r12 - 74f8: df 92 push r13 - 74fa: ef 92 push r14 - 74fc: ff 92 push r15 - 74fe: 1f 93 push r17 - 7500: cf 93 push r28 - 7502: df 93 push r29 - 7504: cd b7 in r28, 0x3d ; 61 - 7506: de b7 in r29, 0x3e ; 62 - 7508: c4 56 subi r28, 0x64 ; 100 - 750a: d1 09 sbc r29, r1 - 750c: de bf out 0x3e, r29 ; 62 - 750e: cd bf out 0x3d, r28 ; 61 - 7510: 7c 01 movw r14, r24 - uint8_t txBuffer[100]; - uint8_t *txPtr = txBuffer; - uint8_t packetLength; - uint16_t writePointer; - - writePointer = netReadWord(REG_S3_TX_WR0) + S3_TX_START; - 7512: 84 e2 ldi r24, 0x24 ; 36 - 7514: 97 e0 ldi r25, 0x07 ; 7 - 7516: 69 de rcall .-814 ; 0x71ea - 7518: 98 5a subi r25, 0xA8 ; 168 - 751a: 6c 01 movw r12, r24 - switch(response) { - 751c: 82 e0 ldi r24, 0x02 ; 2 - 751e: e8 16 cp r14, r24 - 7520: f1 04 cpc r15, r1 - 7522: 79 f1 breq .+94 ; 0x7582 - 7524: 20 f4 brcc .+8 ; 0x752e - 7526: ea 94 dec r14 - 7528: ef 28 or r14, r15 - 752a: 49 f4 brne .+18 ; 0x753e - 752c: 18 c0 rjmp .+48 ; 0x755e - 752e: 83 e0 ldi r24, 0x03 ; 3 - 7530: e8 16 cp r14, r24 - 7532: f1 04 cpc r15, r1 - 7534: e9 f0 breq .+58 ; 0x7570 - 7536: e4 e0 ldi r30, 0x04 ; 4 - 7538: ee 16 cp r14, r30 - 753a: f1 04 cpc r15, r1 - 753c: 11 f1 breq .+68 ; 0x7582 - default: - - case ERROR_UNKNOWN: - // Send unknown error packet - packetLength = TFTP_UNKNOWN_ERROR_LEN; - memcpy_P(txBuffer, tftp_unknown_error_packet, packetLength); - 753e: 4a e0 ldi r20, 0x0A ; 10 - 7540: 50 e0 ldi r21, 0x00 ; 0 - 7542: 60 e8 ldi r22, 0x80 ; 128 - 7544: 70 e7 ldi r23, 0x70 ; 112 - 7546: ce 01 movw r24, r28 - 7548: 01 96 adiw r24, 0x01 ; 1 - 754a: 1d d2 rcall .+1082 ; 0x7986 - switch(response) { - default: - - case ERROR_UNKNOWN: - // Send unknown error packet - packetLength = TFTP_UNKNOWN_ERROR_LEN; - 754c: 8a e0 ldi r24, 0x0A ; 10 - } - - txPtr = txBuffer; - while(packetLength--) { - netWriteReg(writePointer++, *txPtr++); - if(writePointer == S3_TX_END) writePointer = S3_TX_START; - 754e: ee 24 eor r14, r14 - 7550: e3 94 inc r14 - 7552: f1 2c mov r15, r1 - 7554: ec 0e add r14, r28 - 7556: fd 1e adc r15, r29 - } - return(returnCode); -} - - -void sendResponse(uint16_t response) - 7558: 18 2f mov r17, r24 - 755a: 1e 0d add r17, r14 - 755c: 2e c0 rjmp .+92 ; 0x75ba - break; - - case ERROR_INVALID: - // Send invalid opcode packet - packetLength = TFTP_OPCODE_ERROR_LEN; - memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); - 755e: 4c e0 ldi r20, 0x0C ; 12 - 7560: 50 e0 ldi r21, 0x00 ; 0 - 7562: 65 e9 ldi r22, 0x95 ; 149 - 7564: 70 e7 ldi r23, 0x70 ; 112 - 7566: ce 01 movw r24, r28 - 7568: 01 96 adiw r24, 0x01 ; 1 - 756a: 0d d2 rcall .+1050 ; 0x7986 - memcpy_P(txBuffer, tftp_unknown_error_packet, packetLength); - break; - - case ERROR_INVALID: - // Send invalid opcode packet - packetLength = TFTP_OPCODE_ERROR_LEN; - 756c: 8c e0 ldi r24, 0x0C ; 12 - memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); - break; - 756e: ef cf rjmp .-34 ; 0x754e - - case ERROR_FULL: - // Send unknown error packet - packetLength = TFTP_FULL_ERROR_LEN; - memcpy_P(txBuffer, tftp_full_error_packet, packetLength); - 7570: 49 e0 ldi r20, 0x09 ; 9 - 7572: 50 e0 ldi r21, 0x00 ; 0 - 7574: 6b e8 ldi r22, 0x8B ; 139 - 7576: 70 e7 ldi r23, 0x70 ; 112 - 7578: ce 01 movw r24, r28 - 757a: 01 96 adiw r24, 0x01 ; 1 - 757c: 04 d2 rcall .+1032 ; 0x7986 - memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); - break; - - case ERROR_FULL: - // Send unknown error packet - packetLength = TFTP_FULL_ERROR_LEN; - 757e: 89 e0 ldi r24, 0x09 ; 9 - memcpy_P(txBuffer, tftp_full_error_packet, packetLength); - break; - 7580: e6 cf rjmp .-52 ; 0x754e - traceln("Tftp: Sent Final ACK "); - tracenum(lastPacket); - } -#endif - packetLength = 4; - *txPtr++ = TFTP_OPCODE_ACK >> 8; - 7582: 19 82 std Y+1, r1 ; 0x01 - *txPtr++ = TFTP_OPCODE_ACK & 0xff; - 7584: 84 e0 ldi r24, 0x04 ; 4 - 7586: 8a 83 std Y+2, r24 ; 0x02 - // lastPacket is block code - *txPtr++ = lastPacket >> 8; - 7588: 80 91 1e 01 lds r24, 0x011E - 758c: 90 91 1f 01 lds r25, 0x011F - 7590: 9b 83 std Y+3, r25 ; 0x03 - *txPtr = lastPacket & 0xff; - 7592: 8c 83 std Y+4, r24 ; 0x04 - if(response == FINAL_ACK) { - traceln("Tftp: Sent Final ACK "); - tracenum(lastPacket); - } -#endif - packetLength = 4; - 7594: 84 e0 ldi r24, 0x04 ; 4 - *txPtr++ = TFTP_OPCODE_ACK >> 8; - *txPtr++ = TFTP_OPCODE_ACK & 0xff; - // lastPacket is block code - *txPtr++ = lastPacket >> 8; - *txPtr = lastPacket & 0xff; - break; - 7596: db cf rjmp .-74 ; 0x754e - } - - txPtr = txBuffer; - while(packetLength--) { - netWriteReg(writePointer++, *txPtr++); - 7598: f7 01 movw r30, r14 - 759a: 61 91 ld r22, Z+ - 759c: 7f 01 movw r14, r30 - 759e: 56 01 movw r10, r12 - 75a0: ff ef ldi r31, 0xFF ; 255 - 75a2: af 1a sub r10, r31 - 75a4: bf 0a sbc r11, r31 - 75a6: c6 01 movw r24, r12 - 75a8: ed dd rcall .-1062 ; 0x7184 - if(writePointer == S3_TX_END) writePointer = S3_TX_START; - 75aa: a1 14 cp r10, r1 - 75ac: 80 e6 ldi r24, 0x60 ; 96 - 75ae: b8 06 cpc r11, r24 - 75b0: 19 f4 brne .+6 ; 0x75b8 - 75b2: a1 2c mov r10, r1 - 75b4: e8 e5 ldi r30, 0x58 ; 88 - 75b6: be 2e mov r11, r30 - 75b8: 65 01 movw r12, r10 - *txPtr = lastPacket & 0xff; - break; - } - - txPtr = txBuffer; - while(packetLength--) { - 75ba: 1e 11 cpse r17, r14 - 75bc: ed cf rjmp .-38 ; 0x7598 - netWriteReg(writePointer++, *txPtr++); - if(writePointer == S3_TX_END) writePointer = S3_TX_START; - } - netWriteWord(REG_S3_TX_WR0, writePointer - S3_TX_START); - 75be: b6 01 movw r22, r12 - 75c0: 78 55 subi r23, 0x58 ; 88 - 75c2: 84 e2 ldi r24, 0x24 ; 36 - 75c4: 97 e0 ldi r25, 0x07 ; 7 - 75c6: 25 de rcall .-950 ; 0x7212 - netWriteReg(REG_S3_CR, CR_SEND); - 75c8: 60 e2 ldi r22, 0x20 ; 32 - 75ca: 81 e0 ldi r24, 0x01 ; 1 - 75cc: 97 e0 ldi r25, 0x07 ; 7 - 75ce: da dd rcall .-1100 ; 0x7184 - while(netReadReg(REG_S3_CR)); - 75d0: 81 e0 ldi r24, 0x01 ; 1 - 75d2: 97 e0 ldi r25, 0x07 ; 7 - 75d4: f0 dd rcall .-1056 ; 0x71b6 - 75d6: 81 11 cpse r24, r1 - 75d8: fb cf rjmp .-10 ; 0x75d0 -#ifdef _VERBOSE - traceln("Tftp: Response sent"); -#endif -} - 75da: cc 59 subi r28, 0x9C ; 156 - 75dc: df 4f sbci r29, 0xFF ; 255 - 75de: de bf out 0x3e, r29 ; 62 - 75e0: cd bf out 0x3d, r28 ; 61 - 75e2: df 91 pop r29 - 75e4: cf 91 pop r28 - 75e6: 1f 91 pop r17 - 75e8: ff 90 pop r15 - 75ea: ef 90 pop r14 - 75ec: df 90 pop r13 - 75ee: cf 90 pop r12 - 75f0: bf 90 pop r11 - 75f2: af 90 pop r10 - 75f4: 08 95 ret - -000075f6 : -void tftpInit() -{ - // Open socket - do { - // Write TFTP Port - netWriteWord(REG_S3_PORT0, TFTP_PORT); - 75f6: 65 e4 ldi r22, 0x45 ; 69 - 75f8: 70 e0 ldi r23, 0x00 ; 0 - 75fa: 84 e0 ldi r24, 0x04 ; 4 - 75fc: 97 e0 ldi r25, 0x07 ; 7 - 75fe: 09 de rcall .-1006 ; 0x7212 - // Write mode - netWriteReg(REG_S3_MR, MR_UDP); - 7600: 62 e0 ldi r22, 0x02 ; 2 - 7602: 80 e0 ldi r24, 0x00 ; 0 - 7604: 97 e0 ldi r25, 0x07 ; 7 - 7606: be dd rcall .-1156 ; 0x7184 - // Open Socket - netWriteReg(REG_S3_CR, CR_OPEN); - 7608: 61 e0 ldi r22, 0x01 ; 1 - 760a: 81 e0 ldi r24, 0x01 ; 1 - 760c: 97 e0 ldi r25, 0x07 ; 7 - 760e: ba dd rcall .-1164 ; 0x7184 - // Read Status - if(netReadReg(REG_S3_SR) != SOCK_UDP) - 7610: 83 e0 ldi r24, 0x03 ; 3 - 7612: 97 e0 ldi r25, 0x07 ; 7 - 7614: d0 dd rcall .-1120 ; 0x71b6 - 7616: 82 32 cpi r24, 0x22 ; 34 - 7618: 21 f0 breq .+8 ; 0x7622 - // Close Socket if it wasn't initialized correctly - netWriteReg(REG_S3_CR, CR_CLOSE); - 761a: 60 e1 ldi r22, 0x10 ; 16 - 761c: 81 e0 ldi r24, 0x01 ; 1 - 761e: 97 e0 ldi r25, 0x07 ; 7 - 7620: b1 dd rcall .-1182 ; 0x7184 - // If socket correctly opened continue - } while(netReadReg(REG_S3_SR) != SOCK_UDP); - 7622: 83 e0 ldi r24, 0x03 ; 3 - 7624: 97 e0 ldi r25, 0x07 ; 7 - 7626: c7 dd rcall .-1138 ; 0x71b6 - 7628: 82 32 cpi r24, 0x22 ; 34 - 762a: 29 f7 brne .-54 ; 0x75f6 -#ifdef _VERBOSE - traceln("Tftp: TFTP server init done"); -#endif -} - 762c: 08 95 ret - -0000762e : - -/** - * Looks for a connection - */ -uint8_t tftpPoll() -{ - 762e: cf 93 push r28 - uint8_t response = ACK; - // Get the size of the recieved data - uint16_t packetSize = netReadWord(REG_S3_RX_RSR0); - 7630: 86 e2 ldi r24, 0x26 ; 38 - 7632: 97 e0 ldi r25, 0x07 ; 7 - 7634: da dd rcall .-1100 ; 0x71ea - - if(packetSize) { - 7636: 89 2b or r24, r25 - 7638: 11 f4 brne .+4 ; 0x763e - netWriteReg(REG_S3_CR, CR_CLOSE); - // Complete - return(0); - } - // Tftp continues - return(1); - 763a: 81 e0 ldi r24, 0x01 ; 1 - 763c: 26 c0 rjmp .+76 ; 0x768a - uint8_t response = ACK; - // Get the size of the recieved data - uint16_t packetSize = netReadWord(REG_S3_RX_RSR0); - - if(packetSize) { - if(!tftpFlashing) resetTick(); - 763e: 80 91 25 01 lds r24, 0x0125 - 7642: 81 11 cpse r24, r1 - 7644: 01 c0 rjmp .+2 ; 0x7648 - 7646: 8a d1 rcall .+788 ; 0x795c - tftpFlashing = TRUE; - 7648: 81 e0 ldi r24, 0x01 ; 1 - 764a: 80 93 25 01 sts 0x0125, r24 - - for(;;) { - if(!(netReadReg(REG_S3_IR) & IR_RECV)) break; - 764e: 82 e0 ldi r24, 0x02 ; 2 - 7650: 97 e0 ldi r25, 0x07 ; 7 - 7652: b1 dd rcall .-1182 ; 0x71b6 - 7654: 82 ff sbrs r24, 2 - 7656: 0e c0 rjmp .+28 ; 0x7674 - - netWriteReg(REG_S3_IR, IR_RECV); - 7658: 64 e0 ldi r22, 0x04 ; 4 - 765a: 82 e0 ldi r24, 0x02 ; 2 - 765c: 97 e0 ldi r25, 0x07 ; 7 - 765e: 92 dd rcall .-1244 ; 0x7184 - #else - //round up by default - __ticks_dc = (uint32_t)(ceil(fabs(__tmp))); - #endif - - __builtin_avr_delay_cycles(__ticks_dc); - 7660: 2f ef ldi r18, 0xFF ; 255 - 7662: 87 e8 ldi r24, 0x87 ; 135 - 7664: 93 e1 ldi r25, 0x13 ; 19 - 7666: 21 50 subi r18, 0x01 ; 1 - 7668: 80 40 sbci r24, 0x00 ; 0 - 766a: 90 40 sbci r25, 0x00 ; 0 - 766c: e1 f7 brne .-8 ; 0x7666 - 766e: 00 c0 rjmp .+0 ; 0x7670 - 7670: 00 00 nop - 7672: ed cf rjmp .-38 ; 0x764e - } - // Process Packet and get TFTP response code -#ifdef _DEBUG_TFTP - response = processPacket(packetSize); -#else - response = processPacket(); - 7674: 1f de rcall .-962 ; 0x72b4 - 7676: c8 2f mov r28, r24 -#endif - // Send the response - sendResponse(response); - 7678: 90 e0 ldi r25, 0x00 ; 0 - 767a: 3b df rcall .-394 ; 0x74f2 - } - if(response==FINAL_ACK) { - 767c: c4 30 cpi r28, 0x04 ; 4 - 767e: e9 f6 brne .-70 ; 0x763a - netWriteReg(REG_S3_CR, CR_CLOSE); - 7680: 60 e1 ldi r22, 0x10 ; 16 - 7682: 81 e0 ldi r24, 0x01 ; 1 - 7684: 97 e0 ldi r25, 0x07 ; 7 - 7686: 7e dd rcall .-1284 ; 0x7184 - // Complete - return(0); - 7688: 80 e0 ldi r24, 0x00 ; 0 - } - // Tftp continues - return(1); -} - 768a: cf 91 pop r28 - 768c: 08 95 ret - -0000768e : -#include "debug.h" -#include "serial.h" - - -uint8_t validImage(uint8_t *base) -{ - 768e: 20 e0 ldi r18, 0x00 ; 0 - 7690: 30 e0 ldi r19, 0x00 ; 0 -#include "validate.h" -#include "debug.h" -#include "serial.h" - - -uint8_t validImage(uint8_t *base) - 7692: fc 01 movw r30, r24 - 7694: e2 0f add r30, r18 - 7696: f3 1f adc r31, r19 - /* Check that a jump table is present in the first flash sector */ - uint8_t i; - for(i = 0; i < 0x34; i += 4) { - // For each vector, check it is of the form: - // 0x0C 0x94 0xWX 0xYZ ; JMP 0xWXYZ - if(base[i] != 0x0c) { - 7698: 40 81 ld r20, Z - 769a: 4c 30 cpi r20, 0x0C ; 12 - 769c: 51 f4 brne .+20 ; 0x76b2 - tracenum(base[i]); - trace(" instead of 0x0C"); -#endif - return(0); - } - if(base[i + 1] != 0x94) { - 769e: 41 81 ldd r20, Z+1 ; 0x01 - 76a0: 44 39 cpi r20, 0x94 ; 148 - 76a2: 39 f4 brne .+14 ; 0x76b2 - 76a4: 2c 5f subi r18, 0xFC ; 252 - 76a6: 3f 4f sbci r19, 0xFF ; 255 - -uint8_t validImage(uint8_t *base) -{ - /* Check that a jump table is present in the first flash sector */ - uint8_t i; - for(i = 0; i < 0x34; i += 4) { - 76a8: 24 33 cpi r18, 0x34 ; 52 - 76aa: 31 05 cpc r19, r1 - 76ac: 91 f7 brne .-28 ; 0x7692 - } - } -#ifdef _DEBUG_VALD - traceln("Vald: Valid image"); -#endif - return(1); - 76ae: 81 e0 ldi r24, 0x01 ; 1 - 76b0: 08 95 ret - tracenum(i); - trace(" with "); - tracenum(base[i]); - trace(" instead of 0x0C"); -#endif - return(0); - 76b2: 80 e0 ldi r24, 0x00 ; 0 - } -#ifdef _DEBUG_VALD - traceln("Vald: Valid image"); -#endif - return(1); -} - 76b4: 08 95 ret - -000076b6 : - */ -uint8_t watchdogDisable(void) -{ - uint8_t mcusr_mirror; - - mcusr_mirror = MCUSR; - 76b6: 84 b7 in r24, 0x34 ; 52 - MCUSR = 0; - 76b8: 14 be out 0x34, r1 ; 52 - wdt_disable(); - 76ba: 98 e1 ldi r25, 0x18 ; 24 - 76bc: 0f b6 in r0, 0x3f ; 63 - 76be: f8 94 cli - 76c0: 90 93 60 00 sts 0x0060, r25 - 76c4: 10 92 60 00 sts 0x0060, r1 - 76c8: 0f be out 0x3f, r0 ; 63 - - return(mcusr_mirror); -} - 76ca: 08 95 ret - -000076cc : - -void watchdogReset(void) -{ - wdt_reset(); - 76cc: a8 95 wdr - 76ce: 08 95 ret - -000076d0 : -} - -void watchdogConfig(uint8_t x) -{ - WDTCSR = _BV(WDCE) | _BV(WDE); - 76d0: e0 e6 ldi r30, 0x60 ; 96 - 76d2: f0 e0 ldi r31, 0x00 ; 0 - 76d4: 98 e1 ldi r25, 0x18 ; 24 - 76d6: 90 83 st Z, r25 - WDTCSR = x; - 76d8: 80 83 st Z, r24 - 76da: 08 95 ret - -000076dc : -uint8_t length; - - -void verifySpace() -{ - if(getch() != CRC_EOP) { - 76dc: 12 d1 rcall .+548 ; 0x7902 - 76de: 80 32 cpi r24, 0x20 ; 32 - 76e0: 19 f0 breq .+6 ; 0x76e8 - watchdogConfig(WATCHDOG_16MS); // shorten WD timeout - 76e2: 88 e0 ldi r24, 0x08 ; 8 - 76e4: f5 df rcall .-22 ; 0x76d0 - 76e6: ff cf rjmp .-2 ; 0x76e6 - while(1) // and busy-loop so that WD causes - ; // a reset and app start. - } - putch(STK_INSYNC); - 76e8: 84 e1 ldi r24, 0x14 ; 20 - 76ea: f8 c0 rjmp .+496 ; 0x78dc - -000076ec : -} - - -void getNch(uint8_t count) -{ - 76ec: cf 93 push r28 - 76ee: c8 2f mov r28, r24 - do getch(); - 76f0: 08 d1 rcall .+528 ; 0x7902 - while(--count); - 76f2: c1 50 subi r28, 0x01 ; 1 - 76f4: e9 f7 brne .-6 ; 0x76f0 - verifySpace(); -} - 76f6: cf 91 pop r28 - -void getNch(uint8_t count) -{ - do getch(); - while(--count); - verifySpace(); - 76f8: f1 cf rjmp .-30 ; 0x76dc - -000076fa : -} - - -uint8_t proccessCommand() -{ - 76fa: ef 92 push r14 - 76fc: ff 92 push r15 - 76fe: cf 93 push r28 - 7700: df 93 push r29 - 7702: cd b7 in r28, 0x3d ; 61 - 7704: de b7 in r29, 0x3e ; 62 - 7706: c1 50 subi r28, 0x01 ; 1 - 7708: d1 40 sbci r29, 0x01 ; 1 - 770a: de bf out 0x3e, r29 ; 62 - 770c: cd bf out 0x3d, r28 ; 61 - uint8_t ch; - - ch = getch(); - 770e: f9 d0 rcall .+498 ; 0x7902 - - if(ch == STK_GET_PARAMETER) { - 7710: 81 34 cpi r24, 0x41 ; 65 - 7712: a9 f4 brne .+42 ; 0x773e - unsigned char which = getch(); - 7714: f6 d0 rcall .+492 ; 0x7902 - verifySpace(); - 7716: cf 5f subi r28, 0xFF ; 255 - 7718: de 4f sbci r29, 0xFE ; 254 - 771a: 88 83 st Y, r24 - 771c: c1 50 subi r28, 0x01 ; 1 - 771e: d1 40 sbci r29, 0x01 ; 1 - 7720: dd df rcall .-70 ; 0x76dc - if(which == 0x82) { - 7722: cf 5f subi r28, 0xFF ; 255 - 7724: de 4f sbci r29, 0xFE ; 254 - 7726: 88 81 ld r24, Y - 7728: c1 50 subi r28, 0x01 ; 1 - 772a: d1 40 sbci r29, 0x01 ; 1 - 772c: 82 38 cpi r24, 0x82 ; 130 - 772e: 11 f4 brne .+4 ; 0x7734 - /* - * Send tftpboot version as "minor SW version" - */ - putch(TFTPBOOT_MINVER); - 7730: 83 e0 ldi r24, 0x03 ; 3 - 7732: 03 c0 rjmp .+6 ; 0x773a - } else if(which == 0x81) { - 7734: 81 38 cpi r24, 0x81 ; 129 - 7736: e1 f7 brne .-8 ; 0x7730 - putch(TFTPBOOT_MAJVER); - 7738: 80 e0 ldi r24, 0x00 ; 0 - 773a: d0 d0 rcall .+416 ; 0x78dc - 773c: ac c0 rjmp .+344 ; 0x7896 - * GET PARAMETER returns a generic 0x03 reply for - * other parameters - enough to keep Avrdude happy - */ - putch(0x03); - } - } else if(ch == STK_SET_DEVICE) { - 773e: 82 34 cpi r24, 0x42 ; 66 - 7740: 11 f4 brne .+4 ; 0x7746 - // SET DEVICE is ignored - getNch(20); - 7742: 84 e1 ldi r24, 0x14 ; 20 - 7744: 03 c0 rjmp .+6 ; 0x774c - } else if(ch == STK_SET_DEVICE_EXT) { - 7746: 85 34 cpi r24, 0x45 ; 69 - 7748: 19 f4 brne .+6 ; 0x7750 - // SET DEVICE EXT is ignored - getNch(4); - 774a: 84 e0 ldi r24, 0x04 ; 4 - 774c: cf df rcall .-98 ; 0x76ec - 774e: a3 c0 rjmp .+326 ; 0x7896 - } else if(ch == STK_LOAD_ADDRESS) { - 7750: 85 35 cpi r24, 0x55 ; 85 - 7752: 69 f4 brne .+26 ; 0x776e - // LOAD ADDRESS - uint16_t newAddress; - newAddress = getch(); - 7754: d6 d0 rcall .+428 ; 0x7902 - 7756: f8 2e mov r15, r24 - newAddress = (newAddress & 0xff) | (getch() << 8); - 7758: d4 d0 rcall .+424 ; 0x7902 - 775a: 2f 2d mov r18, r15 - 775c: 30 e0 ldi r19, 0x00 ; 0 - 775e: 38 2b or r19, r24 -#ifdef RAMPZ - // Transfer top bit to RAMPZ - RAMPZ = (newAddress & 0x8000) ? 1 : 0; -#endif - - newAddress += newAddress; // Convert from word address to byte address - 7760: 22 0f add r18, r18 - 7762: 33 1f adc r19, r19 - address = newAddress; - 7764: 30 93 21 01 sts 0x0121, r19 - 7768: 20 93 20 01 sts 0x0120, r18 - 776c: 93 c0 rjmp .+294 ; 0x7894 - verifySpace(); - } else if(ch == STK_UNIVERSAL) { - 776e: 86 35 cpi r24, 0x56 ; 86 - 7770: 19 f4 brne .+6 ; 0x7778 - // UNIVERSAL command is ignored - getNch(4); - 7772: 84 e0 ldi r24, 0x04 ; 4 - 7774: bb df rcall .-138 ; 0x76ec - 7776: e0 cf rjmp .-64 ; 0x7738 - putch(0x00); - } - /* Write memory, length is big endian and is in bytes */ - else if(ch == STK_PROG_PAGE) { - 7778: 84 36 cpi r24, 0x64 ; 100 - 777a: 09 f0 breq .+2 ; 0x777e - 777c: 5b c0 rjmp .+182 ; 0x7834 - // PROGRAM PAGE - we support flash programming only, not EEPROM - uint8_t buff[256]; - uint8_t* bufPtr; - uint16_t addrPtr; - - getch(); /* getlen() */ - 777e: c1 d0 rcall .+386 ; 0x7902 - length = getch(); - 7780: c0 d0 rcall .+384 ; 0x7902 - 7782: 80 93 26 01 sts 0x0126, r24 - getch(); - 7786: bd d0 rcall .+378 ; 0x7902 - - // If we are in RWW section, immediately start page erase - if(address < NRWWSTART) boot_page_erase((uint16_t)(void *)address); - 7788: e0 91 20 01 lds r30, 0x0120 - 778c: f0 91 21 01 lds r31, 0x0121 - 7790: e1 15 cp r30, r1 - 7792: 80 e7 ldi r24, 0x70 ; 112 - 7794: f8 07 cpc r31, r24 - 7796: 18 f4 brcc .+6 ; 0x779e - 7798: 83 e0 ldi r24, 0x03 ; 3 - 779a: 87 bf out 0x37, r24 ; 55 - 779c: e8 95 spm - 779e: ee 24 eor r14, r14 - 77a0: e3 94 inc r14 - 77a2: f1 2c mov r15, r1 - 77a4: ec 0e add r14, r28 - 77a6: fd 1e adc r15, r29 - - // While that is going on, read in page contents - bufPtr = buff; - do *bufPtr++ = getch(); - 77a8: ac d0 rcall .+344 ; 0x7902 - 77aa: f7 01 movw r30, r14 - 77ac: 81 93 st Z+, r24 - 77ae: 7f 01 movw r14, r30 - while(--length); - 77b0: 80 91 26 01 lds r24, 0x0126 - 77b4: 81 50 subi r24, 0x01 ; 1 - 77b6: 80 93 26 01 sts 0x0126, r24 - 77ba: 81 11 cpse r24, r1 - 77bc: f5 cf rjmp .-22 ; 0x77a8 - - // If we are in NRWW section, page erase has to be delayed until now. - // Todo: Take RAMPZ into account - if(address >= NRWWSTART) boot_page_erase((uint16_t)(void *)address); - 77be: e0 91 20 01 lds r30, 0x0120 - 77c2: f0 91 21 01 lds r31, 0x0121 - 77c6: e1 15 cp r30, r1 - 77c8: 80 e7 ldi r24, 0x70 ; 112 - 77ca: f8 07 cpc r31, r24 - 77cc: 18 f0 brcs .+6 ; 0x77d4 - 77ce: 83 e0 ldi r24, 0x03 ; 3 - 77d0: 87 bf out 0x37, r24 ; 55 - 77d2: e8 95 spm - - // Read command terminator, start reply - verifySpace(); - 77d4: 83 df rcall .-250 ; 0x76dc - - // If only a partial page is to be programmed, the erase might not be complete. - // So check that here - boot_spm_busy_wait(); - 77d6: 07 b6 in r0, 0x37 ; 55 - 77d8: 00 fc sbrc r0, 0 - 77da: fd cf rjmp .-6 ; 0x77d6 - - // Copy buffer into programming buffer - bufPtr = buff; - addrPtr = (uint16_t)(void *)address; - 77dc: 40 91 20 01 lds r20, 0x0120 - 77e0: 50 91 21 01 lds r21, 0x0121 - // If only a partial page is to be programmed, the erase might not be complete. - // So check that here - boot_spm_busy_wait(); - - // Copy buffer into programming buffer - bufPtr = buff; - 77e4: 29 81 ldd r18, Y+1 ; 0x01 - 77e6: 80 e0 ldi r24, 0x00 ; 0 - 77e8: 90 e0 ldi r25, 0x00 ; 0 - ch = SPM_PAGESIZE / 2; - do { - uint16_t a; - a = *bufPtr++; - a |= (*bufPtr++) << 8; - boot_page_fill((uint16_t)(void *)addrPtr, a); - 77ea: 61 e0 ldi r22, 0x01 ; 1 - while(--count); - verifySpace(); -} - - -uint8_t proccessCommand() - 77ec: a1 e0 ldi r26, 0x01 ; 1 - 77ee: b0 e0 ldi r27, 0x00 ; 0 - 77f0: ac 0f add r26, r28 - 77f2: bd 1f adc r27, r29 - 77f4: a8 0f add r26, r24 - 77f6: b9 1f adc r27, r25 - 77f8: fc 01 movw r30, r24 - 77fa: e4 0f add r30, r20 - 77fc: f5 1f adc r31, r21 - addrPtr = (uint16_t)(void *)address; - ch = SPM_PAGESIZE / 2; - do { - uint16_t a; - a = *bufPtr++; - a |= (*bufPtr++) << 8; - 77fe: 11 96 adiw r26, 0x01 ; 1 - 7800: 7c 91 ld r23, X - 7802: 11 97 sbiw r26, 0x01 ; 1 - 7804: 30 e0 ldi r19, 0x00 ; 0 - 7806: 37 2b or r19, r23 - boot_page_fill((uint16_t)(void *)addrPtr, a); - 7808: 09 01 movw r0, r18 - 780a: 67 bf out 0x37, r22 ; 55 - 780c: e8 95 spm - 780e: 11 24 eor r1, r1 - addrPtr += 2; - } while(--ch); - 7810: 8e 37 cpi r24, 0x7E ; 126 - 7812: 91 05 cpc r25, r1 - 7814: 21 f0 breq .+8 ; 0x781e - addrPtr = (uint16_t)(void *)address; - ch = SPM_PAGESIZE / 2; - do { - uint16_t a; - a = *bufPtr++; - a |= (*bufPtr++) << 8; - 7816: 12 96 adiw r26, 0x02 ; 2 - 7818: 2c 91 ld r18, X - 781a: 02 96 adiw r24, 0x02 ; 2 - 781c: e7 cf rjmp .-50 ; 0x77ec - boot_page_fill((uint16_t)(void *)addrPtr, a); - addrPtr += 2; - } while(--ch); - - // Write from programming buffer - boot_page_write((uint16_t)(void *)address); - 781e: 85 e0 ldi r24, 0x05 ; 5 - 7820: fa 01 movw r30, r20 - 7822: 87 bf out 0x37, r24 ; 55 - 7824: e8 95 spm - boot_spm_busy_wait(); - 7826: 07 b6 in r0, 0x37 ; 55 - 7828: 00 fc sbrc r0, 0 - 782a: fd cf rjmp .-6 ; 0x7826 - -#if defined(RWWSRE) - // Reenable read access to flash - boot_rww_enable(); - 782c: 81 e1 ldi r24, 0x11 ; 17 - 782e: 87 bf out 0x37, r24 ; 55 - 7830: e8 95 spm - 7832: 31 c0 rjmp .+98 ; 0x7896 -#endif - } - /* Read memory block mode, length is big endian. */ - else if(ch == STK_READ_PAGE) { - 7834: 84 37 cpi r24, 0x74 ; 116 - 7836: d1 f4 brne .+52 ; 0x786c - // READ PAGE - we only read flash - getch(); /* getlen() */ - 7838: 64 d0 rcall .+200 ; 0x7902 - length = getch(); - 783a: 63 d0 rcall .+198 ; 0x7902 - 783c: 80 93 26 01 sts 0x0126, r24 - getch(); - 7840: 60 d0 rcall .+192 ; 0x7902 - - verifySpace(); - 7842: 4c df rcall .-360 ; 0x76dc - __asm__("elpm %0,Z\n":"=r"(result):"z"(address)); - putch(result); - address++; - } while(--length); -#else - do putch(pgm_read_byte_near(address++)); - 7844: e0 91 20 01 lds r30, 0x0120 - 7848: f0 91 21 01 lds r31, 0x0121 - 784c: cf 01 movw r24, r30 - 784e: 01 96 adiw r24, 0x01 ; 1 - 7850: 90 93 21 01 sts 0x0121, r25 - 7854: 80 93 20 01 sts 0x0120, r24 - 7858: 84 91 lpm r24, Z - 785a: 40 d0 rcall .+128 ; 0x78dc - while(--length); - 785c: 80 91 26 01 lds r24, 0x0126 - 7860: 81 50 subi r24, 0x01 ; 1 - 7862: 80 93 26 01 sts 0x0126, r24 - 7866: 81 11 cpse r24, r1 - 7868: ed cf rjmp .-38 ; 0x7844 - 786a: 15 c0 rjmp .+42 ; 0x7896 -#endif - } - /* Get device signature bytes */ - else if(ch == STK_READ_SIGN) { - 786c: 85 37 cpi r24, 0x75 ; 117 - 786e: 39 f4 brne .+14 ; 0x787e - // READ SIGN - return what Avrdude wants to hear - verifySpace(); - 7870: 35 df rcall .-406 ; 0x76dc - putch(SIGNATURE_0); - 7872: 8e e1 ldi r24, 0x1E ; 30 - 7874: 33 d0 rcall .+102 ; 0x78dc - putch(SIGNATURE_1); - 7876: 85 e9 ldi r24, 0x95 ; 149 - 7878: 31 d0 rcall .+98 ; 0x78dc - putch(SIGNATURE_2); - 787a: 8f e0 ldi r24, 0x0F ; 15 - 787c: 5e cf rjmp .-324 ; 0x773a - } else if(ch == STK_LEAVE_PROGMODE) { - 787e: 81 35 cpi r24, 0x51 ; 81 - 7880: 49 f4 brne .+18 ; 0x7894 - // Adaboot no-wait mod - //watchdogConfig(WATCHDOG_16MS); - verifySpace(); - 7882: 2c df rcall .-424 ; 0x76dc - eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); - 7884: 6b eb ldi r22, 0xBB ; 187 - 7886: 82 e0 ldi r24, 0x02 ; 2 - 7888: 90 e0 ldi r25, 0x00 ; 0 - 788a: 8e d0 rcall .+284 ; 0x79a8 <__eewr_byte_m328p> - putch(STK_OK); - 788c: 80 e1 ldi r24, 0x10 ; 16 - 788e: 26 d0 rcall .+76 ; 0x78dc - return(0); - 7890: 80 e0 ldi r24, 0x00 ; 0 - 7892: 04 c0 rjmp .+8 ; 0x789c - } else { - // This covers the response to commands like STK_ENTER_PROGMODE - verifySpace(); - 7894: 23 df rcall .-442 ; 0x76dc - } - putch(STK_OK); - 7896: 80 e1 ldi r24, 0x10 ; 16 - 7898: 21 d0 rcall .+66 ; 0x78dc - return(1); - 789a: 81 e0 ldi r24, 0x01 ; 1 -} - 789c: cf 5f subi r28, 0xFF ; 255 - 789e: de 4f sbci r29, 0xFE ; 254 - 78a0: de bf out 0x3e, r29 ; 62 - 78a2: cd bf out 0x3d, r28 ; 61 - 78a4: df 91 pop r29 - 78a6: cf 91 pop r28 - 78a8: ff 90 pop r15 - 78aa: ef 90 pop r14 - 78ac: 08 95 ret - -000078ae : - - -uint8_t serialPoll() -{ - if(UCSR0A & _BV(RXC0)){ - 78ae: 80 91 c0 00 lds r24, 0x00C0 - 78b2: 87 ff sbrs r24, 7 - 78b4: 04 c0 rjmp .+8 ; 0x78be - serialFlashing = TRUE; - 78b6: 81 e0 ldi r24, 0x01 ; 1 - 78b8: 80 93 24 01 sts 0x0124, r24 - return(proccessCommand()); - 78bc: 1e cf rjmp .-452 ; 0x76fa - } else return(1); -} - 78be: 81 e0 ldi r24, 0x01 ; 1 - 78c0: 08 95 ret - -000078c2 : -#include "pin_defs.h" - - -void serialInit() -{ - UCSR0A = _BV(U2X0); //Double speed mode USART0 - 78c2: 82 e0 ldi r24, 0x02 ; 2 - 78c4: 80 93 c0 00 sts 0x00C0, r24 - UCSR0B = _BV(RXEN0) | _BV(TXEN0); - 78c8: 88 e1 ldi r24, 0x18 ; 24 - 78ca: 80 93 c1 00 sts 0x00C1, r24 - UCSR0C = _BV(UCSZ00) | _BV(UCSZ01); - 78ce: 86 e0 ldi r24, 0x06 ; 6 - 78d0: 80 93 c2 00 sts 0x00C2, r24 - UBRR0L = (uint8_t)((F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1); - 78d4: 80 e1 ldi r24, 0x10 ; 16 - 78d6: 80 93 c4 00 sts 0x00C4, r24 - 78da: 08 95 ret - -000078dc : -} - - -void putch(uint8_t c) -{ - while(!(UCSR0A & _BV(UDRE0))); - 78dc: 90 91 c0 00 lds r25, 0x00C0 - 78e0: 95 ff sbrs r25, 5 - 78e2: fc cf rjmp .-8 ; 0x78dc - UDR0 = c; - 78e4: 80 93 c6 00 sts 0x00C6, r24 - 78e8: 08 95 ret - -000078ea : -} - - -void puthex(uint8_t c) -{ - c &= 0xf; - 78ea: 8f 70 andi r24, 0x0F ; 15 - if(c > 9) c += 7; - 78ec: 8a 30 cpi r24, 0x0A ; 10 - 78ee: 08 f0 brcs .+2 ; 0x78f2 - 78f0: 89 5f subi r24, 0xF9 ; 249 - while(!(UCSR0A & _BV(UDRE0))); - 78f2: 90 91 c0 00 lds r25, 0x00C0 - 78f6: 95 ff sbrs r25, 5 - 78f8: fc cf rjmp .-8 ; 0x78f2 - UDR0 = c + '0'; - 78fa: 80 5d subi r24, 0xD0 ; 208 - 78fc: 80 93 c6 00 sts 0x00C6, r24 - 7900: 08 95 ret - -00007902 : - -uint8_t getch(void) -{ - uint8_t ch; - - while(!(UCSR0A & _BV(RXC0))); - 7902: 80 91 c0 00 lds r24, 0x00C0 - 7906: 87 ff sbrs r24, 7 - 7908: fc cf rjmp .-8 ; 0x7902 - if(!(UCSR0A & _BV(FE0))) { - 790a: 80 91 c0 00 lds r24, 0x00C0 - 790e: 84 ff sbrs r24, 4 - * expects to be talking to the application, and DON'T reset the - * watchdog. This should cause the bootloader to abort and run - * the application "soon", if it keeps happening. (Note that we - * don't care that an invalid char is returned...) - */ - watchdogReset(); - 7910: dd de rcall .-582 ; 0x76cc - } - ch = UDR0; - 7912: 80 91 c6 00 lds r24, 0x00C6 - - return ch; -} - 7916: 08 95 ret - -00007918 : -uint16_t tick = 0; - - -void updateLed(void) -{ - uint16_t nextTimer1 = TCNT1; - 7918: 80 91 84 00 lds r24, 0x0084 - 791c: 90 91 85 00 lds r25, 0x0085 - if(nextTimer1 & 0x400) LED_PORT ^= _BV(LED); // Led pin high - 7920: 92 ff sbrs r25, 2 - 7922: 05 c0 rjmp .+10 ; 0x792e - 7924: 25 b1 in r18, 0x05 ; 5 - 7926: 30 e2 ldi r19, 0x20 ; 32 - 7928: 23 27 eor r18, r19 - 792a: 25 b9 out 0x05, r18 ; 5 - 792c: 01 c0 rjmp .+2 ; 0x7930 - else LED_PORT &= ~_BV(LED); // Led pin low - 792e: 2d 98 cbi 0x05, 5 ; 5 - if(nextTimer1 < lastTimer1) tick++; - 7930: 20 91 27 01 lds r18, 0x0127 - 7934: 30 91 28 01 lds r19, 0x0128 - 7938: 82 17 cp r24, r18 - 793a: 93 07 cpc r25, r19 - 793c: 50 f4 brcc .+20 ; 0x7952 - 793e: 20 91 22 01 lds r18, 0x0122 - 7942: 30 91 23 01 lds r19, 0x0123 - 7946: 2f 5f subi r18, 0xFF ; 255 - 7948: 3f 4f sbci r19, 0xFF ; 255 - 794a: 30 93 23 01 sts 0x0123, r19 - 794e: 20 93 22 01 sts 0x0122, r18 - lastTimer1 = nextTimer1; - 7952: 90 93 28 01 sts 0x0128, r25 - 7956: 80 93 27 01 sts 0x0127, r24 - 795a: 08 95 ret - -0000795c : -} - -void resetTick(void) -{ - tick = 0; - 795c: 10 92 23 01 sts 0x0123, r1 - 7960: 10 92 22 01 sts 0x0122, r1 - 7964: 08 95 ret - -00007966 : -} - -uint8_t timedOut(void) -{ - // Never timeout if there is no code in Flash - if(pgm_read_word(0x0000) == 0xFFFF) return(0); - 7966: e0 e0 ldi r30, 0x00 ; 0 - 7968: f0 e0 ldi r31, 0x00 ; 0 - 796a: 85 91 lpm r24, Z+ - 796c: 94 91 lpm r25, Z - 796e: 01 96 adiw r24, 0x01 ; 1 - 7970: 41 f0 breq .+16 ; 0x7982 - if(tick > TIMEOUT) return(1); - 7972: 81 e0 ldi r24, 0x01 ; 1 - 7974: 20 91 22 01 lds r18, 0x0122 - 7978: 30 91 23 01 lds r19, 0x0123 - 797c: 24 30 cpi r18, 0x04 ; 4 - 797e: 31 05 cpc r19, r1 - 7980: 08 f4 brcc .+2 ; 0x7984 -} - -uint8_t timedOut(void) -{ - // Never timeout if there is no code in Flash - if(pgm_read_word(0x0000) == 0xFFFF) return(0); - 7982: 80 e0 ldi r24, 0x00 ; 0 - if(tick > TIMEOUT) return(1); - return(0); -} - 7984: 08 95 ret - -00007986 : - 7986: fb 01 movw r30, r22 - 7988: dc 01 movw r26, r24 - 798a: 02 c0 rjmp .+4 ; 0x7990 - 798c: 05 90 lpm r0, Z+ - 798e: 0d 92 st X+, r0 - 7990: 41 50 subi r20, 0x01 ; 1 - 7992: 50 40 sbci r21, 0x00 ; 0 - 7994: d8 f7 brcc .-10 ; 0x798c - 7996: 08 95 ret - -00007998 <__eerd_byte_m328p>: - 7998: f9 99 sbic 0x1f, 1 ; 31 - 799a: fe cf rjmp .-4 ; 0x7998 <__eerd_byte_m328p> - 799c: 92 bd out 0x22, r25 ; 34 - 799e: 81 bd out 0x21, r24 ; 33 - 79a0: f8 9a sbi 0x1f, 0 ; 31 - 79a2: 99 27 eor r25, r25 - 79a4: 80 b5 in r24, 0x20 ; 32 - 79a6: 08 95 ret - -000079a8 <__eewr_byte_m328p>: - 79a8: 26 2f mov r18, r22 - -000079aa <__eewr_r18_m328p>: - 79aa: f9 99 sbic 0x1f, 1 ; 31 - 79ac: fe cf rjmp .-4 ; 0x79aa <__eewr_r18_m328p> - 79ae: 1f ba out 0x1f, r1 ; 31 - 79b0: 92 bd out 0x22, r25 ; 34 - 79b2: 81 bd out 0x21, r24 ; 33 - 79b4: 20 bd out 0x20, r18 ; 32 - 79b6: 0f b6 in r0, 0x3f ; 63 - 79b8: f8 94 cli - 79ba: fa 9a sbi 0x1f, 2 ; 31 - 79bc: f9 9a sbi 0x1f, 1 ; 31 - 79be: 0f be out 0x3f, r0 ; 63 - 79c0: 01 96 adiw r24, 0x01 ; 1 - 79c2: 08 95 ret - -000079c4 <_exit>: - 79c4: f8 94 cli - -000079c6 <__stop_program>: - 79c6: ff cf rjmp .-2 ; 0x79c6 <__stop_program> diff --git a/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328_ether.hex b/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328_ether.hex deleted file mode 100644 index 9e5981b..0000000 --- a/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328_ether.hex +++ /dev/null @@ -1,161 +0,0 @@ -:1070000050C00000BEC00000BCC00000BAC00000FC -:10701000B8C00000B6C00000B4C00000B2C000009C -:10702000B0C00000AEC00000ACC00000AAC00000AC -:10703000A8C00000A6C00000A4C00000A2C00000BC -:10704000A0C000009EC000009CC000009AC00000CC -:1070500098C0000096C0000094C0000092C00000DC -:1070600090C000008EC000001300050000496E763D -:10707000616C696420696D6167652066696C650093 -:1070800008000500004572726F72000900050003D8 -:1070900046756C6C000A000500004F70636F6465F4 -:1070A0003F0011241FBECFEFD8E0DEBFCDBF11E0FF -:1070B000A0E0B1E0ECECF9E702C005900D92AC3134 -:1070C000B107D9F711E0ACE1B1E001C01D92A932DE -:1070D000B107E1F701D078C4F0D22FEF85EA9EE046 -:1070E000215080409040E1F700C00000112485E06D -:1070F00080938100E8D39ED080D2EFEFF5EA2EE0B6 -:10710000E150F0402040E1F700C00000109224015F -:1071100010922501C3E0E12CF12C809124018823F9 -:1071200029F080912501882349F004C082D2811181 -:10713000F8CF20C01AD4811105C01AC0BAD381116A -:10714000F9CF18C080912501813069F41092250192 -:1071500007B600FCFDCFF999FECFF701C7BFE89550 -:10716000FFD34BD205C082E090E018D48B3B11F0E6 -:10717000D5D3D3CFE0911C01F0911D01099580E09A -:1071800090E03ECF20E52CBD2A9820EF2EBD0DB417 -:1071900007FEFDCF292F33272EBD0DB407FEFDCFEF -:1071A0008EBD0DB407FEFDCF6EBD0DB407FEFDCF45 -:1071B0002A9A1CBC089520E52CBD2A982FE02EBDEC -:1071C0000DB407FEFDCF292F33272EBD0DB407FECA -:1071D000FDCF8EBD0DB407FEFDCF1EBC0DB407FE66 -:1071E000FDCF2A9A8EB51CBC0895EF92FF92CF93E3 -:1071F0007C01E1DFC82FC7010196DDDF2C2F30E0D5 -:10720000322F2227A901482BCA01CF91FF90EF907E -:107210000895CF92DF92EF92FF927C016B01672F6E -:107220007727B0DF6C2DC7010196FF90EF90DF90BC -:10723000CF90A8CFCF92DF92EF92FF928CE284B9E9 -:107240008CE385B9219A299A81E08DBD80E090E098 -:10725000A5D3853539F0E0E0CE2EE1E0DE2EE12C3D -:10726000F12C19C081E090E099D38A3AA1F761E04E -:10727000C62E61E0D62E73E0E72EF12CC7018ED327 -:10728000F60181936F01FFEFEF1AFF0A85E1E8161F -:10729000F104A1F7E0CFF60161916F01C70172DF40 -:1072A000FFEFEF1AFF0A8CE1E816F104A1F7FF9057 -:1072B000EF90DF90CF900895AF92BF92CF92DF9280 -:1072C000EF92FF92CF93DF93CDB7DEB7CC50D24091 -:1072D000DEBFCDBF88E297E088DF009711F480E041 -:1072E00098E7EE24E394F12CEC0EFD1E5E0123EFF3 -:1072F000A21A2DEFB20A6C01EFEFCE1ADE0A5BDFA5 -:10730000F70181937F01C114F0E8DF0611F0C60197 -:1073100002C080E098E7EA14FB0469F7BC0188E248 -:1073200097E077DF60E481E097E02CDF81E097E091 -:1073300042DF8111FBCFCC24C394D12CCC0EDD1EB7 -:107340006CE0E62E67E0F62EF60161916F01C70151 -:1073500019DFFFEFEF1AFF0A22E1E21627E0F2063B -:1073600099F7EF802885CB843C85898590E0982F1C -:1073700088274A85840F911D83309105C9F138F41F -:107380008130910539F0029709F0A1C005C0069738 -:1073900008F09DC080E0A2C06FEF82E090E006D3CD -:1073A00060E481E097E0EEDE60E181E097E0EADE14 -:1073B00062E080E097E0E6DE61E081E097E0E2DE17 -:1073C00069E777EB84E097E024DF83E097E0F3DE82 -:1073D000823221F060E181E097E0D4DE83E097E043 -:1073E000EADE823229F710921F0110921E0175C049 -:1073F000D12CDC2CCC24C30ED11CF12CFE2CEE2481 -:10740000E20EF11C84E0E81AF108D0921F01C0924C -:107410001E01E1E0CE1AD108DC2CCC24DD0CC60123 -:107420008E0D9F1D8130904708F053C003C02FEF91 -:10743000E21AF20AC7018F779927892BC1F7C11485 -:10744000D10431F4CE010D9624D1882309F443C030 -:10745000DE011D9680E090E041E053E065E071E1DF -:1074600029C0E1E0F0E0EC0FFD1FE80FF91F2585D2 -:1074700030E0322F2227EC912E2BF601090147BF75 -:10748000E895112402969C012F773327232B71F462 -:10749000EE57F10957BFE89507B600FCFDCF67BF6F -:1074A000E89507B600FCFDCF77BFE8951296F2E0AD -:1074B000CF0ED11C8E159F05A0F2E11422E0F2063A -:1074C00060F46BEB82E090E071D284E007C081E071 -:1074D00005C083E003C085E001C082E0C45FDD4FEA -:1074E000DEBFCDBFDF91CF91FF90EF90DF90CF90C7 -:1074F000BF90AF900895AF92BF92CF92DF92EF927C -:10750000FF921F93CF93DF93CDB7DEB7C456D10957 -:10751000DEBFCDBF7C0184E297E067DE985A6C0144 -:1075200082E0E816F10479F120F4EA94EF2849F4B6 -:1075300018C083E0E816F104E9F0E4E0EE16F10487 -:1075400011F14AE050E060E870E7CE0101961DD2EB -:107550008AE0EE24E394F12CEC0EFD1E182F1E0D94 -:107560002EC04CE050E065E970E7CE0101960DD2E7 -:107570008CE0EFCF49E050E06BE870E7CE01019678 -:1075800004D289E0E6CF198284E08A8380911E01CB -:1075900090911F019B838C8384E0DBCFF701619185 -:1075A0007F015601FFEFAF1ABF0AC601EBDDA11440 -:1075B00080E6B80619F4A12CE8E5BE2E65011E117F -:1075C000EDCFB601785584E297E023DE60E281E0FA -:1075D00097E0D8DD81E097E0EEDD8111FBCFCC595B -:1075E000DF4FDEBFCDBFDF91CF911F91FF90EF90B6 -:1075F000DF90CF90BF90AF90089565E470E084E095 -:1076000097E007DE62E080E097E0BCDD61E081E0CA -:1076100097E0B8DD83E097E0CEDD823221F060E1D3 -:1076200081E097E0AFDD83E097E0C5DD823229F7A6 -:107630000895CF9386E297E0D8DD892B11F481E09D -:1076400026C080912501811101C08AD181E08093FB -:10765000250182E097E0AFDD82FF0EC064E082E0AA -:1076600097E090DD2FEF87E893E121508040904034 -:10767000E1F700C00000EDCF1FDEC82F90E03BDF38 -:10768000C430E9F660E181E097E07CDD80E0CF91F5 -:10769000089520E030E0FC01E20FF31F40814C3000 -:1076A00051F44181443939F42C5F3F4F2433310583 -:1076B00091F781E0089580E0089584B714BE98E1C1 -:1076C0000FB6F89490936000109260000FBE08957A -:1076D000A8950895E0E6F0E098E19083808308950E -:1076E00012D1803219F088E0F5DFFFCF84E1F8C0D5 -:1076F000CF93C82F08D1C150E9F7CF91F1CFEF92C6 -:10770000FF92CF93DF93CDB7DEB7C150D140DEBF3C -:10771000CDBFF9D08134A9F4F6D0CF5FDE4F888396 -:10772000C150D140DDDFCF5FDE4F8881C150D140F5 -:10773000823811F483E003C08138E1F780E0D0D0D3 -:10774000ACC0823411F484E103C0853419F484E0C0 -:10775000CFDFA3C0853569F4D6D0F82ED4D02F2D35 -:1077600030E0382B220F331F30932101209320016A -:1077700093C0863519F484E0BBDFE0CF843609F08E -:107780005BC0C1D0C0D080932601BDD0E091200164 -:10779000F0912101E11580E7F80718F483E087BF35 -:1077A000E895EE24E394F12CEC0EFD1EACD0F7012D -:1077B00081937F0180912601815080932601811160 -:1077C000F5CFE0912001F0912101E11580E7F80764 -:1077D00018F083E087BFE89583DF07B600FCFDCF94 -:1077E0004091200150912101298180E090E061E0E9 -:1077F000A1E0B0E0AC0FBD1FA80FB91FFC01E40F62 -:10780000F51F11967C91119730E0372B090167BF66 -:10781000E89511248E37910521F012962C9102964D -:10782000E7CF85E0FA0187BFE89507B600FCFDCFFA -:1078300081E187BFE89531C08437D1F464D063D04B -:107840008093260160D04CDFE0912001F09121016E -:10785000CF0101969093210180932001849140D023 -:10786000809126018150809326018111EDCF15C0B2 -:10787000853739F435DF8EE133D085E931D08FE0BB -:107880005ECF813549F42CDF6BEB82E090E08ED047 -:1078900080E126D080E004C023DF80E121D081E0B8 -:1078A000CF5FDE4FDEBFCDBFDF91CF91FF90EF9076 -:1078B00008958091C00087FF04C081E08093240177 -:1078C0001ECF81E0089582E08093C00088E180931C -:1078D000C10086E08093C20080E18093C4000895D7 -:1078E0009091C00095FFFCCF8093C60008958F70E3 -:1078F0008A3008F0895F9091C00095FFFCCF805DD1 -:107900008093C60008958091C00087FFFCCF8091CE -:10791000C00084FFDDDE8091C60008958091840060 -:107920009091850092FF05C025B132E0232725B94B -:1079300001C02998209127013091280182179307CF -:1079400050F420912201309123012F5F3F4F30935B -:107950002301209322019093280180932701089509 -:1079600010922301109222010895E0E0F0E0859149 -:107970009491019641F081E0209122013091230100 -:107980002430310508F480E00895FB01DC0102C0D9 -:1079900005900D9241505040D8F70895F999FECFC7 -:1079A00092BD81BDF89A992780B50895262FF9993F -:1079B000FECF1FBA92BD81BD20BD0FB6F894FA9AD2 -:0C79C000F99A0FBE01960895F894FFCFCD -:1079CC0080C0A80101FFFFFF00DEADBEEFFEEDC0E1 -:0C79DC00A801800000000007D080555575 -:040000030000700089 -:00000001FF diff --git a/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328_ether.lst b/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328_ether.lst deleted file mode 100644 index 91bc24c..0000000 --- a/hardware/tftpboot/bootloaders/tftpboot/tftpboot_atmega328_ether.lst +++ /dev/null @@ -1,2142 +0,0 @@ - -tftpboot_atmega328_ether.elf: file format elf32-avr - -Sections: -Idx Name Size VMA LMA File off Algn - 0 .data 0000001c 00800100 000079cc 00000a60 2**0 - CONTENTS, ALLOC, LOAD, DATA - 1 .text 000009cc 00007000 00007000 00000094 2**1 - CONTENTS, ALLOC, LOAD, READONLY, CODE - 2 .bss 0000000d 0080011c 0080011c 00000a7c 2**0 - ALLOC - 3 .stab 00002f88 00000000 00000000 00000a7c 2**2 - CONTENTS, READONLY, DEBUGGING - 4 .stabstr 000010b0 00000000 00000000 00003a04 2**0 - CONTENTS, READONLY, DEBUGGING - 5 .comment 00000011 00000000 00000000 00004ab4 2**0 - CONTENTS, READONLY - -Disassembly of section .text: - -00007000 <__vectors>: - 7000: 50 c0 rjmp .+160 ; 0x70a2 <__ctors_end> - 7002: 00 00 nop - 7004: be c0 rjmp .+380 ; 0x7182 <__bad_interrupt> - 7006: 00 00 nop - 7008: bc c0 rjmp .+376 ; 0x7182 <__bad_interrupt> - 700a: 00 00 nop - 700c: ba c0 rjmp .+372 ; 0x7182 <__bad_interrupt> - 700e: 00 00 nop - 7010: b8 c0 rjmp .+368 ; 0x7182 <__bad_interrupt> - 7012: 00 00 nop - 7014: b6 c0 rjmp .+364 ; 0x7182 <__bad_interrupt> - 7016: 00 00 nop - 7018: b4 c0 rjmp .+360 ; 0x7182 <__bad_interrupt> - 701a: 00 00 nop - 701c: b2 c0 rjmp .+356 ; 0x7182 <__bad_interrupt> - 701e: 00 00 nop - 7020: b0 c0 rjmp .+352 ; 0x7182 <__bad_interrupt> - 7022: 00 00 nop - 7024: ae c0 rjmp .+348 ; 0x7182 <__bad_interrupt> - 7026: 00 00 nop - 7028: ac c0 rjmp .+344 ; 0x7182 <__bad_interrupt> - 702a: 00 00 nop - 702c: aa c0 rjmp .+340 ; 0x7182 <__bad_interrupt> - 702e: 00 00 nop - 7030: a8 c0 rjmp .+336 ; 0x7182 <__bad_interrupt> - 7032: 00 00 nop - 7034: a6 c0 rjmp .+332 ; 0x7182 <__bad_interrupt> - 7036: 00 00 nop - 7038: a4 c0 rjmp .+328 ; 0x7182 <__bad_interrupt> - 703a: 00 00 nop - 703c: a2 c0 rjmp .+324 ; 0x7182 <__bad_interrupt> - 703e: 00 00 nop - 7040: a0 c0 rjmp .+320 ; 0x7182 <__bad_interrupt> - 7042: 00 00 nop - 7044: 9e c0 rjmp .+316 ; 0x7182 <__bad_interrupt> - 7046: 00 00 nop - 7048: 9c c0 rjmp .+312 ; 0x7182 <__bad_interrupt> - 704a: 00 00 nop - 704c: 9a c0 rjmp .+308 ; 0x7182 <__bad_interrupt> - 704e: 00 00 nop - 7050: 98 c0 rjmp .+304 ; 0x7182 <__bad_interrupt> - 7052: 00 00 nop - 7054: 96 c0 rjmp .+300 ; 0x7182 <__bad_interrupt> - 7056: 00 00 nop - 7058: 94 c0 rjmp .+296 ; 0x7182 <__bad_interrupt> - 705a: 00 00 nop - 705c: 92 c0 rjmp .+292 ; 0x7182 <__bad_interrupt> - 705e: 00 00 nop - 7060: 90 c0 rjmp .+288 ; 0x7182 <__bad_interrupt> - 7062: 00 00 nop - 7064: 8e c0 rjmp .+284 ; 0x7182 <__bad_interrupt> - ... - -00007068 : - 7068: 13 00 05 00 00 49 6e 76 61 6c 69 64 20 69 6d 61 .....Invalid ima - 7078: 67 65 20 66 69 6c 65 00 ge file. - -00007080 : - 7080: 08 00 05 00 00 45 72 72 6f 72 00 .....Error. - -0000708b : - 708b: 09 00 05 00 03 46 75 6c 6c 00 .....Full. - -00007095 : - 7095: 0a 00 05 00 00 4f 70 63 6f 64 65 3f 00 .....Opcode?. - -000070a2 <__ctors_end>: - 70a2: 11 24 eor r1, r1 - 70a4: 1f be out 0x3f, r1 ; 63 - 70a6: cf ef ldi r28, 0xFF ; 255 - 70a8: d8 e0 ldi r29, 0x08 ; 8 - 70aa: de bf out 0x3e, r29 ; 62 - 70ac: cd bf out 0x3d, r28 ; 61 - -000070ae <__do_copy_data>: - 70ae: 11 e0 ldi r17, 0x01 ; 1 - 70b0: a0 e0 ldi r26, 0x00 ; 0 - 70b2: b1 e0 ldi r27, 0x01 ; 1 - 70b4: ec ec ldi r30, 0xCC ; 204 - 70b6: f9 e7 ldi r31, 0x79 ; 121 - 70b8: 02 c0 rjmp .+4 ; 0x70be <__do_copy_data+0x10> - 70ba: 05 90 lpm r0, Z+ - 70bc: 0d 92 st X+, r0 - 70be: ac 31 cpi r26, 0x1C ; 28 - 70c0: b1 07 cpc r27, r17 - 70c2: d9 f7 brne .-10 ; 0x70ba <__do_copy_data+0xc> - -000070c4 <__do_clear_bss>: - 70c4: 11 e0 ldi r17, 0x01 ; 1 - 70c6: ac e1 ldi r26, 0x1C ; 28 - 70c8: b1 e0 ldi r27, 0x01 ; 1 - 70ca: 01 c0 rjmp .+2 ; 0x70ce <.do_clear_bss_start> - -000070cc <.do_clear_bss_loop>: - 70cc: 1d 92 st X+, r1 - -000070ce <.do_clear_bss_start>: - 70ce: a9 32 cpi r26, 0x29 ; 41 - 70d0: b1 07 cpc r27, r17 - 70d2: e1 f7 brne .-8 ; 0x70cc <.do_clear_bss_loop> - 70d4: 01 d0 rcall .+2 ; 0x70d8
- 70d6: 78 c4 rjmp .+2288 ; 0x79c8 <_exit> - -000070d8
: - 70d8: f0 d2 rcall .+1504 ; 0x76ba - 70da: 2f ef ldi r18, 0xFF ; 255 - 70dc: 85 ea ldi r24, 0xA5 ; 165 - 70de: 9e e0 ldi r25, 0x0E ; 14 - 70e0: 21 50 subi r18, 0x01 ; 1 - 70e2: 80 40 sbci r24, 0x00 ; 0 - 70e4: 90 40 sbci r25, 0x00 ; 0 - 70e6: e1 f7 brne .-8 ; 0x70e0 - 70e8: 00 c0 rjmp .+0 ; 0x70ea - 70ea: 00 00 nop - 70ec: 11 24 eor r1, r1 - 70ee: 85 e0 ldi r24, 0x05 ; 5 - 70f0: 80 93 81 00 sts 0x0081, r24 - 70f4: e8 d3 rcall .+2000 ; 0x78c6 - 70f6: 9e d0 rcall .+316 ; 0x7234 - 70f8: 80 d2 rcall .+1280 ; 0x75fa - 70fa: ef ef ldi r30, 0xFF ; 255 - 70fc: f5 ea ldi r31, 0xA5 ; 165 - 70fe: 2e e0 ldi r18, 0x0E ; 14 - 7100: e1 50 subi r30, 0x01 ; 1 - 7102: f0 40 sbci r31, 0x00 ; 0 - 7104: 20 40 sbci r18, 0x00 ; 0 - 7106: e1 f7 brne .-8 ; 0x7100 - 7108: 00 c0 rjmp .+0 ; 0x710a - 710a: 00 00 nop - 710c: 10 92 24 01 sts 0x0124, r1 - 7110: 10 92 25 01 sts 0x0125, r1 - 7114: c3 e0 ldi r28, 0x03 ; 3 - 7116: e1 2c mov r14, r1 - 7118: f1 2c mov r15, r1 - 711a: 80 91 24 01 lds r24, 0x0124 - 711e: 88 23 and r24, r24 - 7120: 29 f0 breq .+10 ; 0x712c - 7122: 80 91 25 01 lds r24, 0x0125 - 7126: 88 23 and r24, r24 - 7128: 49 f0 breq .+18 ; 0x713c - 712a: 04 c0 rjmp .+8 ; 0x7134 - 712c: 82 d2 rcall .+1284 ; 0x7632 - 712e: 81 11 cpse r24, r1 - 7130: f8 cf rjmp .-16 ; 0x7122 - 7132: 20 c0 rjmp .+64 ; 0x7174 - 7134: 1a d4 rcall .+2100 ; 0x796a - 7136: 81 11 cpse r24, r1 - 7138: 05 c0 rjmp .+10 ; 0x7144 - 713a: 1a c0 rjmp .+52 ; 0x7170 - 713c: ba d3 rcall .+1908 ; 0x78b2 - 713e: 81 11 cpse r24, r1 - 7140: f9 cf rjmp .-14 ; 0x7134 - 7142: 18 c0 rjmp .+48 ; 0x7174 - 7144: 80 91 25 01 lds r24, 0x0125 - 7148: 81 30 cpi r24, 0x01 ; 1 - 714a: 69 f4 brne .+26 ; 0x7166 - 714c: 10 92 25 01 sts 0x0125, r1 - 7150: 07 b6 in r0, 0x37 ; 55 - 7152: 00 fc sbrc r0, 0 - 7154: fd cf rjmp .-6 ; 0x7150 - 7156: f9 99 sbic 0x1f, 1 ; 31 - 7158: fe cf rjmp .-4 ; 0x7156 - 715a: f7 01 movw r30, r14 - 715c: c7 bf out 0x37, r28 ; 55 - 715e: e8 95 spm - 7160: ff d3 rcall .+2046 ; 0x7960 - 7162: 4b d2 rcall .+1174 ; 0x75fa - 7164: 05 c0 rjmp .+10 ; 0x7170 - 7166: 82 e0 ldi r24, 0x02 ; 2 - 7168: 90 e0 ldi r25, 0x00 ; 0 - 716a: 18 d4 rcall .+2096 ; 0x799c <__eerd_byte_m328p> - 716c: 8b 3b cpi r24, 0xBB ; 187 - 716e: 11 f0 breq .+4 ; 0x7174 - 7170: d5 d3 rcall .+1962 ; 0x791c - 7172: d3 cf rjmp .-90 ; 0x711a - 7174: e0 91 1c 01 lds r30, 0x011C - 7178: f0 91 1d 01 lds r31, 0x011D - 717c: 09 95 icall - 717e: 80 e0 ldi r24, 0x00 ; 0 - 7180: 90 e0 ldi r25, 0x00 ; 0 - -00007182 <__bad_interrupt>: - 7182: 3e cf rjmp .-388 ; 0x7000 <__vectors> - -00007184 : - trace(", "); - tracenum(value); -#endif - - // Send uint8_t to Ethernet controller - SPCR = _BV(SPE) | _BV(MSTR); // Set SPI as master - 7184: 20 e5 ldi r18, 0x50 ; 80 - 7186: 2c bd out 0x2c, r18 ; 44 - SS_LOW(); - 7188: 2a 98 cbi 0x05, 2 ; 5 - SPDR = SPI_WRITE; - 718a: 20 ef ldi r18, 0xF0 ; 240 - 718c: 2e bd out 0x2e, r18 ; 46 - while(!(SPSR & _BV(SPIF))); - 718e: 0d b4 in r0, 0x2d ; 45 - 7190: 07 fe sbrs r0, 7 - 7192: fd cf rjmp .-6 ; 0x718e - SPDR = address >> 8; - 7194: 29 2f mov r18, r25 - 7196: 33 27 eor r19, r19 - 7198: 2e bd out 0x2e, r18 ; 46 - while(!(SPSR & _BV(SPIF))); - 719a: 0d b4 in r0, 0x2d ; 45 - 719c: 07 fe sbrs r0, 7 - 719e: fd cf rjmp .-6 ; 0x719a - SPDR = address & 0xff; - 71a0: 8e bd out 0x2e, r24 ; 46 - while(!(SPSR & _BV(SPIF))); - 71a2: 0d b4 in r0, 0x2d ; 45 - 71a4: 07 fe sbrs r0, 7 - 71a6: fd cf rjmp .-6 ; 0x71a2 - SPDR = value; - 71a8: 6e bd out 0x2e, r22 ; 46 - while(!(SPSR & _BV(SPIF))); - 71aa: 0d b4 in r0, 0x2d ; 45 - 71ac: 07 fe sbrs r0, 7 - 71ae: fd cf rjmp .-6 ; 0x71aa - SS_HIGH(); - 71b0: 2a 9a sbi 0x05, 2 ; 5 - SPCR = 0; // Turn of SPI - 71b2: 1c bc out 0x2c, r1 ; 44 - 71b4: 08 95 ret - -000071b6 : -// tracenum(address); -//#endif - - // Read uint8_t from Ethernet controller - uint8_t returnValue; - SPCR = _BV(SPE) | _BV(MSTR); - 71b6: 20 e5 ldi r18, 0x50 ; 80 - 71b8: 2c bd out 0x2c, r18 ; 44 - SS_LOW(); - 71ba: 2a 98 cbi 0x05, 2 ; 5 - SPDR = SPI_READ; - 71bc: 2f e0 ldi r18, 0x0F ; 15 - 71be: 2e bd out 0x2e, r18 ; 46 - while(!(SPSR & _BV(SPIF))); - 71c0: 0d b4 in r0, 0x2d ; 45 - 71c2: 07 fe sbrs r0, 7 - 71c4: fd cf rjmp .-6 ; 0x71c0 - SPDR = address >> 8; - 71c6: 29 2f mov r18, r25 - 71c8: 33 27 eor r19, r19 - 71ca: 2e bd out 0x2e, r18 ; 46 - while(!(SPSR & _BV(SPIF))); - 71cc: 0d b4 in r0, 0x2d ; 45 - 71ce: 07 fe sbrs r0, 7 - 71d0: fd cf rjmp .-6 ; 0x71cc - SPDR = address & 0xff; - 71d2: 8e bd out 0x2e, r24 ; 46 - while(!(SPSR & _BV(SPIF))); - 71d4: 0d b4 in r0, 0x2d ; 45 - 71d6: 07 fe sbrs r0, 7 - 71d8: fd cf rjmp .-6 ; 0x71d4 - SPDR = 0; - 71da: 1e bc out 0x2e, r1 ; 46 - while(!(SPSR & _BV(SPIF))); - 71dc: 0d b4 in r0, 0x2d ; 45 - 71de: 07 fe sbrs r0, 7 - 71e0: fd cf rjmp .-6 ; 0x71dc - SS_HIGH(); - 71e2: 2a 9a sbi 0x05, 2 ; 5 - returnValue = SPDR; - 71e4: 8e b5 in r24, 0x2e ; 46 - SPCR = 0; - 71e6: 1c bc out 0x2c, r1 ; 44 - return(returnValue); -} - 71e8: 08 95 ret - -000071ea : - -uint16_t netReadWord(uint16_t address) -{ - 71ea: ef 92 push r14 - 71ec: ff 92 push r15 - 71ee: cf 93 push r28 - 71f0: 7c 01 movw r14, r24 - // Read uint16_t from Ethernet controller - return((netReadReg(address) << 8) | netReadReg(address + 1)); - 71f2: e1 df rcall .-62 ; 0x71b6 - 71f4: c8 2f mov r28, r24 - 71f6: c7 01 movw r24, r14 - 71f8: 01 96 adiw r24, 0x01 ; 1 - 71fa: dd df rcall .-70 ; 0x71b6 - 71fc: 2c 2f mov r18, r28 - 71fe: 30 e0 ldi r19, 0x00 ; 0 - 7200: 32 2f mov r19, r18 - 7202: 22 27 eor r18, r18 -} - 7204: a9 01 movw r20, r18 - 7206: 48 2b or r20, r24 - 7208: ca 01 movw r24, r20 - 720a: cf 91 pop r28 - 720c: ff 90 pop r15 - 720e: ef 90 pop r14 - 7210: 08 95 ret - -00007212 : - -void netWriteWord(uint16_t address, uint16_t value) -{ - 7212: cf 92 push r12 - 7214: df 92 push r13 - 7216: ef 92 push r14 - 7218: ff 92 push r15 - 721a: 7c 01 movw r14, r24 - 721c: 6b 01 movw r12, r22 - // Write uint16_t to Ethernet controller - netWriteReg(address++, value >> 8); - 721e: 67 2f mov r22, r23 - 7220: 77 27 eor r23, r23 - 7222: b0 df rcall .-160 ; 0x7184 - netWriteReg(address, value & 0xff); - 7224: 6c 2d mov r22, r12 - 7226: c7 01 movw r24, r14 - 7228: 01 96 adiw r24, 0x01 ; 1 -} - 722a: ff 90 pop r15 - 722c: ef 90 pop r14 - 722e: df 90 pop r13 - 7230: cf 90 pop r12 - -void netWriteWord(uint16_t address, uint16_t value) -{ - // Write uint16_t to Ethernet controller - netWriteReg(address++, value >> 8); - netWriteReg(address, value & 0xff); - 7232: a8 cf rjmp .-176 ; 0x7184 - -00007234 : -} - -void netInit() -{ - 7234: cf 92 push r12 - 7236: df 92 push r13 - 7238: ef 92 push r14 - 723a: ff 92 push r15 - uint8_t i; - - // Set up outputs to communicate with W5100 chip - // Set pins as output - DDRB = _BV(SCK) | _BV(MOSI) | _BV(SS); - 723c: 8c e2 ldi r24, 0x2C ; 44 - 723e: 84 b9 out 0x04, r24 ; 4 - // Set pins high - PORTB = _BV(SCK) | _BV(MISO) | _BV(MOSI) | _BV(SS); - 7240: 8c e3 ldi r24, 0x3C ; 60 - 7242: 85 b9 out 0x05, r24 ; 5 -#ifdef _ARDUINO_ETHERNET - DDRB |= _BV(LED); - 7244: 21 9a sbi 0x04, 1 ; 4 - PORTB |= _BV(LED); - 7246: 29 9a sbi 0x05, 1 ; 5 -#endif - - // Set up SPI - // Set the Double SPI Speed Bit - SPSR = (1 << SPI2X); - 7248: 81 e0 ldi r24, 0x01 ; 1 - 724a: 8d bd out 0x2d, r24 ; 45 - - - /* Pull in altered presets - * if available from AVR EEPROM (if signature bytes are set)*/ - if((eeprom_read_byte(EEPROM_SIG_1) == EEPROM_SIG_1_VALUE) - 724c: 80 e0 ldi r24, 0x00 ; 0 - 724e: 90 e0 ldi r25, 0x00 ; 0 - 7250: a5 d3 rcall .+1866 ; 0x799c <__eerd_byte_m328p> - 7252: 85 35 cpi r24, 0x55 ; 85 - 7254: 39 f0 breq .+14 ; 0x7264 - 7256: e0 e0 ldi r30, 0x00 ; 0 - 7258: ce 2e mov r12, r30 - 725a: e1 e0 ldi r30, 0x01 ; 1 - 725c: de 2e mov r13, r30 - && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { - 725e: e1 2c mov r14, r1 - 7260: f1 2c mov r15, r1 - 7262: 19 c0 rjmp .+50 ; 0x7296 - 7264: 81 e0 ldi r24, 0x01 ; 1 - 7266: 90 e0 ldi r25, 0x00 ; 0 - 7268: 99 d3 rcall .+1842 ; 0x799c <__eerd_byte_m328p> - 726a: 8a 3a cpi r24, 0xAA ; 170 - 726c: a1 f7 brne .-24 ; 0x7256 - 726e: 61 e0 ldi r22, 0x01 ; 1 - 7270: c6 2e mov r12, r22 - 7272: 61 e0 ldi r22, 0x01 ; 1 - 7274: d6 2e mov r13, r22 - 7276: 73 e0 ldi r23, 0x03 ; 3 - 7278: e7 2e mov r14, r23 - 727a: f1 2c mov r15, r1 - -#ifdef _VERBOSE - traceln(" Net: Using EEPROM settings"); -#endif - for(i = 0; i < 18; i++) - registerBuffer[i+1] = eeprom_read_byte(EEPROM_DATA+i); - 727c: c7 01 movw r24, r14 - 727e: 8e d3 rcall .+1820 ; 0x799c <__eerd_byte_m328p> - 7280: f6 01 movw r30, r12 - 7282: 81 93 st Z+, r24 - 7284: 6f 01 movw r12, r30 - 7286: ff ef ldi r31, 0xFF ; 255 - 7288: ef 1a sub r14, r31 - 728a: ff 0a sbc r15, r31 - && (eeprom_read_byte(EEPROM_SIG_2) == EEPROM_SIG_2_VALUE)) { - -#ifdef _VERBOSE - traceln(" Net: Using EEPROM settings"); -#endif - for(i = 0; i < 18; i++) - 728c: 85 e1 ldi r24, 0x15 ; 21 - 728e: e8 16 cp r14, r24 - 7290: f1 04 cpc r15, r1 - 7292: a1 f7 brne .-24 ; 0x727c - 7294: e0 cf rjmp .-64 ; 0x7256 - } -#endif - - // Configure Wiznet chip - for(i = 0; i < REGISTER_BLOCK_SIZE; i++) - netWriteReg(i, registerBuffer[i]); - 7296: f6 01 movw r30, r12 - 7298: 61 91 ld r22, Z+ - 729a: 6f 01 movw r12, r30 - 729c: c7 01 movw r24, r14 - 729e: 72 df rcall .-284 ; 0x7184 - 72a0: ff ef ldi r31, 0xFF ; 255 - 72a2: ef 1a sub r14, r31 - 72a4: ff 0a sbc r15, r31 - if(i != 14) putch(0x2E); - } -#endif - - // Configure Wiznet chip - for(i = 0; i < REGISTER_BLOCK_SIZE; i++) - 72a6: 8c e1 ldi r24, 0x1C ; 28 - 72a8: e8 16 cp r14, r24 - 72aa: f1 04 cpc r15, r1 - 72ac: a1 f7 brne .-24 ; 0x7296 - netWriteReg(i, registerBuffer[i]); -#ifdef _VERBOSE - traceln(" Net: Network init done"); -#endif -} - 72ae: ff 90 pop r15 - 72b0: ef 90 pop r14 - 72b2: df 90 pop r13 - 72b4: cf 90 pop r12 - 72b6: 08 95 ret - -000072b8 : -#ifdef _DEBUG_TFTP -uint8_t processPacket(uint16_t packetSize) -{ -#else -uint8_t processPacket() -{ - 72b8: af 92 push r10 - 72ba: bf 92 push r11 - 72bc: cf 92 push r12 - 72be: df 92 push r13 - 72c0: ef 92 push r14 - 72c2: ff 92 push r15 - 72c4: cf 93 push r28 - 72c6: df 93 push r29 - 72c8: cd b7 in r28, 0x3d ; 61 - 72ca: de b7 in r29, 0x3e ; 62 - 72cc: cc 50 subi r28, 0x0C ; 12 - 72ce: d2 40 sbci r29, 0x02 ; 2 - 72d0: de bf out 0x3e, r29 ; 62 - 72d2: cd bf out 0x3d, r28 ; 61 - tracenum(packetSize); - if(packetSize >= 0x800) traceln("Tftp: Overflow"); - // step(); -#endif - - readPointer = netReadWord(REG_S3_RX_RD0); - 72d4: 88 e2 ldi r24, 0x28 ; 40 - 72d6: 97 e0 ldi r25, 0x07 ; 7 - 72d8: 88 df rcall .-240 ; 0x71ea -#ifdef _DEBUG_TFTP - traceln("Tftp: readPointer at position "); - tracenum(readPointer); -#endif - if(readPointer == 0) readPointer += S3_RX_START; - 72da: 00 97 sbiw r24, 0x00 ; 0 - 72dc: 11 f4 brne .+4 ; 0x72e2 - 72de: 80 e0 ldi r24, 0x00 ; 0 - 72e0: 98 e7 ldi r25, 0x78 ; 120 - 72e2: ee 24 eor r14, r14 - 72e4: e3 94 inc r14 - 72e6: f1 2c mov r15, r1 - 72e8: ec 0e add r14, r28 - 72ea: fd 1e adc r15, r29 - -#ifdef _DEBUG_TFTP -uint8_t processPacket(uint16_t packetSize) -{ -#else -uint8_t processPacket() - 72ec: 5e 01 movw r10, r28 - 72ee: 23 ef ldi r18, 0xF3 ; 243 - 72f0: a2 1a sub r10, r18 - 72f2: 2d ef ldi r18, 0xFD ; 253 - 72f4: b2 0a sbc r11, r18 - if((count == TFTP_PACKET_MAX_SIZE - 1) || (count == 0)) { - traceln("Tftp: Reading from position "); - tracenum(readPointer); - } -#endif - *bufPtr++ = netReadReg(readPointer++); - 72f6: 6c 01 movw r12, r24 - 72f8: ef ef ldi r30, 0xFF ; 255 - 72fa: ce 1a sub r12, r30 - 72fc: de 0a sbc r13, r30 - 72fe: 5b df rcall .-330 ; 0x71b6 - 7300: f7 01 movw r30, r14 - 7302: 81 93 st Z+, r24 - 7304: 7f 01 movw r14, r30 - if(readPointer == S3_RX_END) readPointer = S3_RX_START; - 7306: c1 14 cp r12, r1 - 7308: f0 e8 ldi r31, 0x80 ; 128 - 730a: df 06 cpc r13, r31 - 730c: 11 f0 breq .+4 ; 0x7312 - 730e: c6 01 movw r24, r12 - 7310: 02 c0 rjmp .+4 ; 0x7316 - 7312: 80 e0 ldi r24, 0x00 ; 0 - 7314: 98 e7 ldi r25, 0x78 ; 120 -#ifdef _DEBUG_TFTP - traceln("Tftp: readPointer at position "); - tracenum(readPointer); -#endif - if(readPointer == 0) readPointer += S3_RX_START; - for(count = TFTP_PACKET_MAX_SIZE; count--;) { - 7316: ea 14 cp r14, r10 - 7318: fb 04 cpc r15, r11 - 731a: 69 f7 brne .-38 ; 0x72f6 - } -#endif - *bufPtr++ = netReadReg(readPointer++); - if(readPointer == S3_RX_END) readPointer = S3_RX_START; - } - netWriteWord(REG_S3_RX_RD0, readPointer); // Write back new pointer - 731c: bc 01 movw r22, r24 - 731e: 88 e2 ldi r24, 0x28 ; 40 - 7320: 97 e0 ldi r25, 0x07 ; 7 - 7322: 77 df rcall .-274 ; 0x7212 - netWriteReg(REG_S3_CR, CR_RECV); - 7324: 60 e4 ldi r22, 0x40 ; 64 - 7326: 81 e0 ldi r24, 0x01 ; 1 - 7328: 97 e0 ldi r25, 0x07 ; 7 - 732a: 2c df rcall .-424 ; 0x7184 - while(netReadReg(REG_S3_CR)); - 732c: 81 e0 ldi r24, 0x01 ; 1 - 732e: 97 e0 ldi r25, 0x07 ; 7 - 7330: 42 df rcall .-380 ; 0x71b6 - 7332: 81 11 cpse r24, r1 - 7334: fb cf rjmp .-10 ; 0x732c - 7336: cc 24 eor r12, r12 - 7338: c3 94 inc r12 - 733a: d1 2c mov r13, r1 - 733c: cc 0e add r12, r28 - 733e: dd 1e adc r13, r29 - 7340: 6c e0 ldi r22, 0x0C ; 12 - 7342: e6 2e mov r14, r22 - 7344: 67 e0 ldi r22, 0x07 ; 7 - 7346: f6 2e mov r15, r22 - traceln("Tftp: Setting return address"); -#endif - - // Set up return IP address and port - uint8_t i; - for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); - 7348: f6 01 movw r30, r12 - 734a: 61 91 ld r22, Z+ - 734c: 6f 01 movw r12, r30 - 734e: c7 01 movw r24, r14 - 7350: 19 df rcall .-462 ; 0x7184 - 7352: ff ef ldi r31, 0xFF ; 255 - 7354: ef 1a sub r14, r31 - 7356: ff 0a sbc r15, r31 - 7358: 22 e1 ldi r18, 0x12 ; 18 - 735a: e2 16 cp r14, r18 - 735c: 27 e0 ldi r18, 0x07 ; 7 - 735e: f2 06 cpc r15, r18 - 7360: 99 f7 brne .-26 ; 0x7348 - - // Parse packet - uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; - 7362: ef 80 ldd r14, Y+7 ; 0x07 - 7364: 28 85 ldd r18, Y+8 ; 0x08 - uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; - uint16_t tftpBlock = (buffer[10] << 8) + buffer[11]; - 7366: cb 84 ldd r12, Y+11 ; 0x0b - 7368: 3c 85 ldd r19, Y+12 ; 0x0c - uint8_t i; - for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); - - // Parse packet - uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; - uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; - 736a: 89 85 ldd r24, Y+9 ; 0x09 - 736c: 90 e0 ldi r25, 0x00 ; 0 - 736e: 98 2f mov r25, r24 - 7370: 88 27 eor r24, r24 - 7372: 4a 85 ldd r20, Y+10 ; 0x0a - 7374: 84 0f add r24, r20 - 7376: 91 1d adc r25, r1 - - uint8_t returnCode = ERROR_UNKNOWN; - uint16_t packetLength; - - - switch(tftpOpcode) { - 7378: 83 30 cpi r24, 0x03 ; 3 - 737a: 91 05 cpc r25, r1 - 737c: c9 f1 breq .+114 ; 0x73f0 - 737e: 38 f4 brcc .+14 ; 0x738e - 7380: 81 30 cpi r24, 0x01 ; 1 - 7382: 91 05 cpc r25, r1 - 7384: 39 f0 breq .+14 ; 0x7394 - 7386: 02 97 sbiw r24, 0x02 ; 2 - 7388: 09 f0 breq .+2 ; 0x738c - 738a: a1 c0 rjmp .+322 ; 0x74ce - 738c: 05 c0 rjmp .+10 ; 0x7398 - 738e: 06 97 sbiw r24, 0x06 ; 6 - 7390: 08 f0 brcs .+2 ; 0x7394 - 7392: 9d c0 rjmp .+314 ; 0x74ce - tracenum(tftpOpcode); - trace(" and data length "); - tracenum(tftpDataLen - (TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE)); -#endif - - uint8_t returnCode = ERROR_UNKNOWN; - 7394: 80 e0 ldi r24, 0x00 ; 0 - 7396: a2 c0 rjmp .+324 ; 0x74dc - case TFTP_OPCODE_WRQ: // Write request -#ifdef _VERBOSE - traceln("Tftp: Write request"); -#endif - // Flagging image as invalid since the flashing process has started - eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_BAD_VALUE); - 7398: 6f ef ldi r22, 0xFF ; 255 - 739a: 82 e0 ldi r24, 0x02 ; 2 - 739c: 90 e0 ldi r25, 0x00 ; 0 - 739e: 06 d3 rcall .+1548 ; 0x79ac <__eewr_byte_m328p> - netWriteReg(REG_S3_CR, CR_RECV); - 73a0: 60 e4 ldi r22, 0x40 ; 64 - 73a2: 81 e0 ldi r24, 0x01 ; 1 - 73a4: 97 e0 ldi r25, 0x07 ; 7 - 73a6: ee de rcall .-548 ; 0x7184 - netWriteReg(REG_S3_CR, CR_CLOSE); - 73a8: 60 e1 ldi r22, 0x10 ; 16 - 73aa: 81 e0 ldi r24, 0x01 ; 1 - 73ac: 97 e0 ldi r25, 0x07 ; 7 - 73ae: ea de rcall .-556 ; 0x7184 - do { - netWriteReg(REG_S3_MR, MR_UDP); - 73b0: 62 e0 ldi r22, 0x02 ; 2 - 73b2: 80 e0 ldi r24, 0x00 ; 0 - 73b4: 97 e0 ldi r25, 0x07 ; 7 - 73b6: e6 de rcall .-564 ; 0x7184 - netWriteReg(REG_S3_CR, CR_OPEN); - 73b8: 61 e0 ldi r22, 0x01 ; 1 - 73ba: 81 e0 ldi r24, 0x01 ; 1 - 73bc: 97 e0 ldi r25, 0x07 ; 7 - 73be: e2 de rcall .-572 ; 0x7184 -#ifdef _TFTP_RANDOM_PORT - netWriteWord(REG_S3_PORT0, (buffer[4]<<8) | ~buffer[5]); // Generate a 'random' TID (RFC1350) -#else - netWriteWord(REG_S3_PORT0, TFTP_STATIC_PORT); // Not random any more - 73c0: 69 e7 ldi r22, 0x79 ; 121 - 73c2: 77 eb ldi r23, 0xB7 ; 183 - 73c4: 84 e0 ldi r24, 0x04 ; 4 - 73c6: 97 e0 ldi r25, 0x07 ; 7 - 73c8: 24 df rcall .-440 ; 0x7212 -#endif - if(netReadReg(REG_S3_SR) != SOCK_UDP) - 73ca: 83 e0 ldi r24, 0x03 ; 3 - 73cc: 97 e0 ldi r25, 0x07 ; 7 - 73ce: f3 de rcall .-538 ; 0x71b6 - 73d0: 82 32 cpi r24, 0x22 ; 34 - 73d2: 21 f0 breq .+8 ; 0x73dc - netWriteReg(REG_S3_CR, CR_CLOSE); - 73d4: 60 e1 ldi r22, 0x10 ; 16 - 73d6: 81 e0 ldi r24, 0x01 ; 1 - 73d8: 97 e0 ldi r25, 0x07 ; 7 - 73da: d4 de rcall .-600 ; 0x7184 - } while(netReadReg(REG_S3_SR) != SOCK_UDP); - 73dc: 83 e0 ldi r24, 0x03 ; 3 - 73de: 97 e0 ldi r25, 0x07 ; 7 - 73e0: ea de rcall .-556 ; 0x71b6 - 73e2: 82 32 cpi r24, 0x22 ; 34 - 73e4: 29 f7 brne .-54 ; 0x73b0 - tracenum((buffer[4]<<8) | (buffer[5]^0x55)); -#else - tracenum(TFTP_STATIC_PORT); -#endif -#endif - lastPacket = 0; - 73e6: 10 92 1f 01 sts 0x011F, r1 - 73ea: 10 92 1e 01 sts 0x011E, r1 - 73ee: 75 c0 rjmp .+234 ; 0x74da - for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); - - // Parse packet - uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; - uint16_t tftpOpcode = (buffer[8] << 8) + buffer[9]; - uint16_t tftpBlock = (buffer[10] << 8) + buffer[11]; - 73f0: d1 2c mov r13, r1 - 73f2: dc 2c mov r13, r12 - 73f4: cc 24 eor r12, r12 - 73f6: c3 0e add r12, r19 - 73f8: d1 1c adc r13, r1 - // Set up return IP address and port - uint8_t i; - for(i = 0; i < 6; i++) netWriteReg(REG_S3_DIPR0 + i, buffer[i]); - - // Parse packet - uint16_t tftpDataLen = (buffer[6] << 8) + buffer[7]; - 73fa: f1 2c mov r15, r1 - 73fc: fe 2c mov r15, r14 - 73fe: ee 24 eor r14, r14 - 7400: e2 0e add r14, r18 - 7402: f1 1c adc r15, r1 - lastPacket = 0; - returnCode = ACK; // Send back acknowledge for packet 0 - break; - - case TFTP_OPCODE_DATA: - packetLength = tftpDataLen - (TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); - 7404: 84 e0 ldi r24, 0x04 ; 4 - 7406: e8 1a sub r14, r24 - 7408: f1 08 sbc r15, r1 - lastPacket = tftpBlock; - 740a: d0 92 1f 01 sts 0x011F, r13 - 740e: c0 92 1e 01 sts 0x011E, r12 - writeAddr = (tftpBlock - 1) << 9; // Flash write address for this block - 7412: e1 e0 ldi r30, 0x01 ; 1 - 7414: ce 1a sub r12, r30 - 7416: d1 08 sbc r13, r1 - 7418: dc 2c mov r13, r12 - 741a: cc 24 eor r12, r12 - 741c: dd 0c add r13, r13 -#ifdef _VERBOSE - traceln("Tftp: Data for block "); - tracenum(lastPacket); -#endif - - if((writeAddr + packetLength) > MAX_ADDR) { - 741e: c6 01 movw r24, r12 - 7420: 8e 0d add r24, r14 - 7422: 9f 1d adc r25, r15 - 7424: 81 30 cpi r24, 0x01 ; 1 - 7426: 90 47 sbci r25, 0x70 ; 112 - 7428: 08 f0 brcs .+2 ; 0x742c - 742a: 53 c0 rjmp .+166 ; 0x74d2 - 742c: 03 c0 rjmp .+6 ; 0x7434 - - uint8_t *pageBase = buffer + (UDP_HEADER_SIZE + TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); // Start of block data - uint16_t offset = 0; // Block offset - - // Round up packet length to a full flash sector size - while(packetLength % SPM_PAGESIZE) packetLength++; - 742e: 2f ef ldi r18, 0xFF ; 255 - 7430: e2 1a sub r14, r18 - 7432: f2 0a sbc r15, r18 - 7434: c7 01 movw r24, r14 - 7436: 8f 77 andi r24, 0x7F ; 127 - 7438: 99 27 eor r25, r25 - 743a: 89 2b or r24, r25 - 743c: c1 f7 brne .-16 ; 0x742e -#ifdef _DEBUG_TFTP - traceln("Tftp: Packet length adjusted to "); - tracenum(packetLength); -#endif - if(writeAddr == 0) { - 743e: c1 14 cp r12, r1 - 7440: d1 04 cpc r13, r1 - 7442: 31 f4 brne .+12 ; 0x7450 - // First sector - validate - if(!validImage(pageBase)) { - 7444: ce 01 movw r24, r28 - 7446: 0d 96 adiw r24, 0x0d ; 13 - 7448: 24 d1 rcall .+584 ; 0x7692 - 744a: 88 23 and r24, r24 - 744c: 09 f4 brne .+2 ; 0x7450 - 744e: 43 c0 rjmp .+134 ; 0x74d6 -#ifdef _DEBUG_TFTP - traceln("Tftp: Writing data from address "); - tracenum(writeAddr); -#endif - - uint8_t *pageBase = buffer + (UDP_HEADER_SIZE + TFTP_OPCODE_SIZE + TFTP_BLOCKNO_SIZE); // Start of block data - 7450: de 01 movw r26, r28 - 7452: 1d 96 adiw r26, 0x0d ; 13 -#endif - } - } - - // Flash packets - for(offset = 0; offset < packetLength;) { - 7454: 80 e0 ldi r24, 0x00 ; 0 - 7456: 90 e0 ldi r25, 0x00 ; 0 - uint16_t writeValue = (pageBase[offset]) | (pageBase[offset + 1] << 8); - boot_page_fill(writeAddr + offset, writeValue); - 7458: 41 e0 ldi r20, 0x01 ; 1 - tracenum(writeAddr + offset); - } -#endif - offset += 2; - if(offset % SPM_PAGESIZE == 0) { - boot_page_erase(writeAddr + offset - SPM_PAGESIZE); - 745a: 53 e0 ldi r21, 0x03 ; 3 - boot_spm_busy_wait(); - boot_page_write(writeAddr + offset - SPM_PAGESIZE); - 745c: 65 e0 ldi r22, 0x05 ; 5 - boot_spm_busy_wait(); - boot_rww_enable(); - 745e: 71 e1 ldi r23, 0x11 ; 17 -#endif - } - } - - // Flash packets - for(offset = 0; offset < packetLength;) { - 7460: 29 c0 rjmp .+82 ; 0x74b4 - -#ifdef _DEBUG_TFTP -uint8_t processPacket(uint16_t packetSize) -{ -#else -uint8_t processPacket() - 7462: e1 e0 ldi r30, 0x01 ; 1 - 7464: f0 e0 ldi r31, 0x00 ; 0 - 7466: ec 0f add r30, r28 - 7468: fd 1f adc r31, r29 - 746a: e8 0f add r30, r24 - 746c: f9 1f adc r31, r25 - } - } - - // Flash packets - for(offset = 0; offset < packetLength;) { - uint16_t writeValue = (pageBase[offset]) | (pageBase[offset + 1] << 8); - 746e: 25 85 ldd r18, Z+13 ; 0x0d - 7470: 30 e0 ldi r19, 0x00 ; 0 - 7472: 32 2f mov r19, r18 - 7474: 22 27 eor r18, r18 - 7476: ec 91 ld r30, X - 7478: 2e 2b or r18, r30 - boot_page_fill(writeAddr + offset, writeValue); - 747a: f6 01 movw r30, r12 - 747c: 09 01 movw r0, r18 - 747e: 47 bf out 0x37, r20 ; 55 - 7480: e8 95 spm - 7482: 11 24 eor r1, r1 - tracenum(writeValue); - trace(" at offset "); - tracenum(writeAddr + offset); - } -#endif - offset += 2; - 7484: 02 96 adiw r24, 0x02 ; 2 - if(offset % SPM_PAGESIZE == 0) { - 7486: 9c 01 movw r18, r24 - 7488: 2f 77 andi r18, 0x7F ; 127 - 748a: 33 27 eor r19, r19 - 748c: 23 2b or r18, r19 - 748e: 71 f4 brne .+28 ; 0x74ac - boot_page_erase(writeAddr + offset - SPM_PAGESIZE); - 7490: ee 57 subi r30, 0x7E ; 126 - 7492: f1 09 sbc r31, r1 - 7494: 57 bf out 0x37, r21 ; 55 - 7496: e8 95 spm - boot_spm_busy_wait(); - 7498: 07 b6 in r0, 0x37 ; 55 - 749a: 00 fc sbrc r0, 0 - 749c: fd cf rjmp .-6 ; 0x7498 - boot_page_write(writeAddr + offset - SPM_PAGESIZE); - 749e: 67 bf out 0x37, r22 ; 55 - 74a0: e8 95 spm - boot_spm_busy_wait(); - 74a2: 07 b6 in r0, 0x37 ; 55 - 74a4: 00 fc sbrc r0, 0 - 74a6: fd cf rjmp .-6 ; 0x74a2 - boot_rww_enable(); - 74a8: 77 bf out 0x37, r23 ; 55 - 74aa: e8 95 spm - 74ac: 12 96 adiw r26, 0x02 ; 2 - 74ae: f2 e0 ldi r31, 0x02 ; 2 - 74b0: cf 0e add r12, r31 - 74b2: d1 1c adc r13, r1 -#endif - } - } - - // Flash packets - for(offset = 0; offset < packetLength;) { - 74b4: 8e 15 cp r24, r14 - 74b6: 9f 05 cpc r25, r15 - 74b8: a0 f2 brcs .-88 ; 0x7462 - boot_spm_busy_wait(); - boot_rww_enable(); - } - } - - if(packetLength < TFTP_DATA_SIZE) { - 74ba: e1 14 cp r14, r1 - 74bc: 22 e0 ldi r18, 0x02 ; 2 - 74be: f2 06 cpc r15, r18 - 74c0: 60 f4 brcc .+24 ; 0x74da - // Hand over to application -#ifdef _VERBOSE - traceln("Tftp: Flash is complete"); -#endif - // Flag the image as valid since we received the last packet - eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); - 74c2: 6b eb ldi r22, 0xBB ; 187 - 74c4: 82 e0 ldi r24, 0x02 ; 2 - 74c6: 90 e0 ldi r25, 0x00 ; 0 - 74c8: 71 d2 rcall .+1250 ; 0x79ac <__eewr_byte_m328p> - returnCode = FINAL_ACK; - 74ca: 84 e0 ldi r24, 0x04 ; 4 - 74cc: 07 c0 rjmp .+14 ; 0x74dc -#ifdef _DEBUG_TFTP - traceln("Tftp: Invalid opcode "); - tracenum(tftpOpcode); -#endif - // Invalid - return error - returnCode = ERROR_INVALID; - 74ce: 81 e0 ldi r24, 0x01 ; 1 - 74d0: 05 c0 rjmp .+10 ; 0x74dc - // Flash is full - abort with an error before a bootloader overwrite occurs - // Application is now corrupt, so do not hand over. -#ifdef _VERBOSE - traceln("Tftp: Flash is full"); -#endif - returnCode = ERROR_FULL; - 74d2: 83 e0 ldi r24, 0x03 ; 3 - 74d4: 03 c0 rjmp .+6 ; 0x74dc - tracenum(packetLength); -#endif - if(writeAddr == 0) { - // First sector - validate - if(!validImage(pageBase)) { - returnCode = INVALID_IMAGE; - 74d6: 85 e0 ldi r24, 0x05 ; 5 - 74d8: 01 c0 rjmp .+2 ; 0x74dc -#endif - // Flag the image as valid since we received the last packet - eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); - returnCode = FINAL_ACK; - } else { - returnCode = ACK; - 74da: 82 e0 ldi r24, 0x02 ; 2 - returnCode = ERROR_INVALID; - break; - - } - return(returnCode); -} - 74dc: c4 5f subi r28, 0xF4 ; 244 - 74de: dd 4f sbci r29, 0xFD ; 253 - 74e0: de bf out 0x3e, r29 ; 62 - 74e2: cd bf out 0x3d, r28 ; 61 - 74e4: df 91 pop r29 - 74e6: cf 91 pop r28 - 74e8: ff 90 pop r15 - 74ea: ef 90 pop r14 - 74ec: df 90 pop r13 - 74ee: cf 90 pop r12 - 74f0: bf 90 pop r11 - 74f2: af 90 pop r10 - 74f4: 08 95 ret - -000074f6 : - - -void sendResponse(uint16_t response) -{ - 74f6: af 92 push r10 - 74f8: bf 92 push r11 - 74fa: cf 92 push r12 - 74fc: df 92 push r13 - 74fe: ef 92 push r14 - 7500: ff 92 push r15 - 7502: 1f 93 push r17 - 7504: cf 93 push r28 - 7506: df 93 push r29 - 7508: cd b7 in r28, 0x3d ; 61 - 750a: de b7 in r29, 0x3e ; 62 - 750c: c4 56 subi r28, 0x64 ; 100 - 750e: d1 09 sbc r29, r1 - 7510: de bf out 0x3e, r29 ; 62 - 7512: cd bf out 0x3d, r28 ; 61 - 7514: 7c 01 movw r14, r24 - uint8_t txBuffer[100]; - uint8_t *txPtr = txBuffer; - uint8_t packetLength; - uint16_t writePointer; - - writePointer = netReadWord(REG_S3_TX_WR0) + S3_TX_START; - 7516: 84 e2 ldi r24, 0x24 ; 36 - 7518: 97 e0 ldi r25, 0x07 ; 7 - 751a: 67 de rcall .-818 ; 0x71ea - 751c: 98 5a subi r25, 0xA8 ; 168 - 751e: 6c 01 movw r12, r24 - switch(response) { - 7520: 82 e0 ldi r24, 0x02 ; 2 - 7522: e8 16 cp r14, r24 - 7524: f1 04 cpc r15, r1 - 7526: 79 f1 breq .+94 ; 0x7586 - 7528: 20 f4 brcc .+8 ; 0x7532 - 752a: ea 94 dec r14 - 752c: ef 28 or r14, r15 - 752e: 49 f4 brne .+18 ; 0x7542 - 7530: 18 c0 rjmp .+48 ; 0x7562 - 7532: 83 e0 ldi r24, 0x03 ; 3 - 7534: e8 16 cp r14, r24 - 7536: f1 04 cpc r15, r1 - 7538: e9 f0 breq .+58 ; 0x7574 - 753a: e4 e0 ldi r30, 0x04 ; 4 - 753c: ee 16 cp r14, r30 - 753e: f1 04 cpc r15, r1 - 7540: 11 f1 breq .+68 ; 0x7586 - default: - - case ERROR_UNKNOWN: - // Send unknown error packet - packetLength = TFTP_UNKNOWN_ERROR_LEN; - memcpy_P(txBuffer, tftp_unknown_error_packet, packetLength); - 7542: 4a e0 ldi r20, 0x0A ; 10 - 7544: 50 e0 ldi r21, 0x00 ; 0 - 7546: 60 e8 ldi r22, 0x80 ; 128 - 7548: 70 e7 ldi r23, 0x70 ; 112 - 754a: ce 01 movw r24, r28 - 754c: 01 96 adiw r24, 0x01 ; 1 - 754e: 1d d2 rcall .+1082 ; 0x798a - switch(response) { - default: - - case ERROR_UNKNOWN: - // Send unknown error packet - packetLength = TFTP_UNKNOWN_ERROR_LEN; - 7550: 8a e0 ldi r24, 0x0A ; 10 - } - - txPtr = txBuffer; - while(packetLength--) { - netWriteReg(writePointer++, *txPtr++); - if(writePointer == S3_TX_END) writePointer = S3_TX_START; - 7552: ee 24 eor r14, r14 - 7554: e3 94 inc r14 - 7556: f1 2c mov r15, r1 - 7558: ec 0e add r14, r28 - 755a: fd 1e adc r15, r29 - } - return(returnCode); -} - - -void sendResponse(uint16_t response) - 755c: 18 2f mov r17, r24 - 755e: 1e 0d add r17, r14 - 7560: 2e c0 rjmp .+92 ; 0x75be - break; - - case ERROR_INVALID: - // Send invalid opcode packet - packetLength = TFTP_OPCODE_ERROR_LEN; - memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); - 7562: 4c e0 ldi r20, 0x0C ; 12 - 7564: 50 e0 ldi r21, 0x00 ; 0 - 7566: 65 e9 ldi r22, 0x95 ; 149 - 7568: 70 e7 ldi r23, 0x70 ; 112 - 756a: ce 01 movw r24, r28 - 756c: 01 96 adiw r24, 0x01 ; 1 - 756e: 0d d2 rcall .+1050 ; 0x798a - memcpy_P(txBuffer, tftp_unknown_error_packet, packetLength); - break; - - case ERROR_INVALID: - // Send invalid opcode packet - packetLength = TFTP_OPCODE_ERROR_LEN; - 7570: 8c e0 ldi r24, 0x0C ; 12 - memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); - break; - 7572: ef cf rjmp .-34 ; 0x7552 - - case ERROR_FULL: - // Send unknown error packet - packetLength = TFTP_FULL_ERROR_LEN; - memcpy_P(txBuffer, tftp_full_error_packet, packetLength); - 7574: 49 e0 ldi r20, 0x09 ; 9 - 7576: 50 e0 ldi r21, 0x00 ; 0 - 7578: 6b e8 ldi r22, 0x8B ; 139 - 757a: 70 e7 ldi r23, 0x70 ; 112 - 757c: ce 01 movw r24, r28 - 757e: 01 96 adiw r24, 0x01 ; 1 - 7580: 04 d2 rcall .+1032 ; 0x798a - memcpy_P(txBuffer, tftp_opcode_error_packet, packetLength); - break; - - case ERROR_FULL: - // Send unknown error packet - packetLength = TFTP_FULL_ERROR_LEN; - 7582: 89 e0 ldi r24, 0x09 ; 9 - memcpy_P(txBuffer, tftp_full_error_packet, packetLength); - break; - 7584: e6 cf rjmp .-52 ; 0x7552 - traceln("Tftp: Sent Final ACK "); - tracenum(lastPacket); - } -#endif - packetLength = 4; - *txPtr++ = TFTP_OPCODE_ACK >> 8; - 7586: 19 82 std Y+1, r1 ; 0x01 - *txPtr++ = TFTP_OPCODE_ACK & 0xff; - 7588: 84 e0 ldi r24, 0x04 ; 4 - 758a: 8a 83 std Y+2, r24 ; 0x02 - // lastPacket is block code - *txPtr++ = lastPacket >> 8; - 758c: 80 91 1e 01 lds r24, 0x011E - 7590: 90 91 1f 01 lds r25, 0x011F - 7594: 9b 83 std Y+3, r25 ; 0x03 - *txPtr = lastPacket & 0xff; - 7596: 8c 83 std Y+4, r24 ; 0x04 - if(response == FINAL_ACK) { - traceln("Tftp: Sent Final ACK "); - tracenum(lastPacket); - } -#endif - packetLength = 4; - 7598: 84 e0 ldi r24, 0x04 ; 4 - *txPtr++ = TFTP_OPCODE_ACK >> 8; - *txPtr++ = TFTP_OPCODE_ACK & 0xff; - // lastPacket is block code - *txPtr++ = lastPacket >> 8; - *txPtr = lastPacket & 0xff; - break; - 759a: db cf rjmp .-74 ; 0x7552 - } - - txPtr = txBuffer; - while(packetLength--) { - netWriteReg(writePointer++, *txPtr++); - 759c: f7 01 movw r30, r14 - 759e: 61 91 ld r22, Z+ - 75a0: 7f 01 movw r14, r30 - 75a2: 56 01 movw r10, r12 - 75a4: ff ef ldi r31, 0xFF ; 255 - 75a6: af 1a sub r10, r31 - 75a8: bf 0a sbc r11, r31 - 75aa: c6 01 movw r24, r12 - 75ac: eb dd rcall .-1066 ; 0x7184 - if(writePointer == S3_TX_END) writePointer = S3_TX_START; - 75ae: a1 14 cp r10, r1 - 75b0: 80 e6 ldi r24, 0x60 ; 96 - 75b2: b8 06 cpc r11, r24 - 75b4: 19 f4 brne .+6 ; 0x75bc - 75b6: a1 2c mov r10, r1 - 75b8: e8 e5 ldi r30, 0x58 ; 88 - 75ba: be 2e mov r11, r30 - 75bc: 65 01 movw r12, r10 - *txPtr = lastPacket & 0xff; - break; - } - - txPtr = txBuffer; - while(packetLength--) { - 75be: 1e 11 cpse r17, r14 - 75c0: ed cf rjmp .-38 ; 0x759c - netWriteReg(writePointer++, *txPtr++); - if(writePointer == S3_TX_END) writePointer = S3_TX_START; - } - netWriteWord(REG_S3_TX_WR0, writePointer - S3_TX_START); - 75c2: b6 01 movw r22, r12 - 75c4: 78 55 subi r23, 0x58 ; 88 - 75c6: 84 e2 ldi r24, 0x24 ; 36 - 75c8: 97 e0 ldi r25, 0x07 ; 7 - 75ca: 23 de rcall .-954 ; 0x7212 - netWriteReg(REG_S3_CR, CR_SEND); - 75cc: 60 e2 ldi r22, 0x20 ; 32 - 75ce: 81 e0 ldi r24, 0x01 ; 1 - 75d0: 97 e0 ldi r25, 0x07 ; 7 - 75d2: d8 dd rcall .-1104 ; 0x7184 - while(netReadReg(REG_S3_CR)); - 75d4: 81 e0 ldi r24, 0x01 ; 1 - 75d6: 97 e0 ldi r25, 0x07 ; 7 - 75d8: ee dd rcall .-1060 ; 0x71b6 - 75da: 81 11 cpse r24, r1 - 75dc: fb cf rjmp .-10 ; 0x75d4 -#ifdef _VERBOSE - traceln("Tftp: Response sent"); -#endif -} - 75de: cc 59 subi r28, 0x9C ; 156 - 75e0: df 4f sbci r29, 0xFF ; 255 - 75e2: de bf out 0x3e, r29 ; 62 - 75e4: cd bf out 0x3d, r28 ; 61 - 75e6: df 91 pop r29 - 75e8: cf 91 pop r28 - 75ea: 1f 91 pop r17 - 75ec: ff 90 pop r15 - 75ee: ef 90 pop r14 - 75f0: df 90 pop r13 - 75f2: cf 90 pop r12 - 75f4: bf 90 pop r11 - 75f6: af 90 pop r10 - 75f8: 08 95 ret - -000075fa : -void tftpInit() -{ - // Open socket - do { - // Write TFTP Port - netWriteWord(REG_S3_PORT0, TFTP_PORT); - 75fa: 65 e4 ldi r22, 0x45 ; 69 - 75fc: 70 e0 ldi r23, 0x00 ; 0 - 75fe: 84 e0 ldi r24, 0x04 ; 4 - 7600: 97 e0 ldi r25, 0x07 ; 7 - 7602: 07 de rcall .-1010 ; 0x7212 - // Write mode - netWriteReg(REG_S3_MR, MR_UDP); - 7604: 62 e0 ldi r22, 0x02 ; 2 - 7606: 80 e0 ldi r24, 0x00 ; 0 - 7608: 97 e0 ldi r25, 0x07 ; 7 - 760a: bc dd rcall .-1160 ; 0x7184 - // Open Socket - netWriteReg(REG_S3_CR, CR_OPEN); - 760c: 61 e0 ldi r22, 0x01 ; 1 - 760e: 81 e0 ldi r24, 0x01 ; 1 - 7610: 97 e0 ldi r25, 0x07 ; 7 - 7612: b8 dd rcall .-1168 ; 0x7184 - // Read Status - if(netReadReg(REG_S3_SR) != SOCK_UDP) - 7614: 83 e0 ldi r24, 0x03 ; 3 - 7616: 97 e0 ldi r25, 0x07 ; 7 - 7618: ce dd rcall .-1124 ; 0x71b6 - 761a: 82 32 cpi r24, 0x22 ; 34 - 761c: 21 f0 breq .+8 ; 0x7626 - // Close Socket if it wasn't initialized correctly - netWriteReg(REG_S3_CR, CR_CLOSE); - 761e: 60 e1 ldi r22, 0x10 ; 16 - 7620: 81 e0 ldi r24, 0x01 ; 1 - 7622: 97 e0 ldi r25, 0x07 ; 7 - 7624: af dd rcall .-1186 ; 0x7184 - // If socket correctly opened continue - } while(netReadReg(REG_S3_SR) != SOCK_UDP); - 7626: 83 e0 ldi r24, 0x03 ; 3 - 7628: 97 e0 ldi r25, 0x07 ; 7 - 762a: c5 dd rcall .-1142 ; 0x71b6 - 762c: 82 32 cpi r24, 0x22 ; 34 - 762e: 29 f7 brne .-54 ; 0x75fa -#ifdef _VERBOSE - traceln("Tftp: TFTP server init done"); -#endif -} - 7630: 08 95 ret - -00007632 : - -/** - * Looks for a connection - */ -uint8_t tftpPoll() -{ - 7632: cf 93 push r28 - uint8_t response = ACK; - // Get the size of the recieved data - uint16_t packetSize = netReadWord(REG_S3_RX_RSR0); - 7634: 86 e2 ldi r24, 0x26 ; 38 - 7636: 97 e0 ldi r25, 0x07 ; 7 - 7638: d8 dd rcall .-1104 ; 0x71ea - - if(packetSize) { - 763a: 89 2b or r24, r25 - 763c: 11 f4 brne .+4 ; 0x7642 - netWriteReg(REG_S3_CR, CR_CLOSE); - // Complete - return(0); - } - // Tftp continues - return(1); - 763e: 81 e0 ldi r24, 0x01 ; 1 - 7640: 26 c0 rjmp .+76 ; 0x768e - uint8_t response = ACK; - // Get the size of the recieved data - uint16_t packetSize = netReadWord(REG_S3_RX_RSR0); - - if(packetSize) { - if(!tftpFlashing) resetTick(); - 7642: 80 91 25 01 lds r24, 0x0125 - 7646: 81 11 cpse r24, r1 - 7648: 01 c0 rjmp .+2 ; 0x764c - 764a: 8a d1 rcall .+788 ; 0x7960 - tftpFlashing = TRUE; - 764c: 81 e0 ldi r24, 0x01 ; 1 - 764e: 80 93 25 01 sts 0x0125, r24 - - for(;;) { - if(!(netReadReg(REG_S3_IR) & IR_RECV)) break; - 7652: 82 e0 ldi r24, 0x02 ; 2 - 7654: 97 e0 ldi r25, 0x07 ; 7 - 7656: af dd rcall .-1186 ; 0x71b6 - 7658: 82 ff sbrs r24, 2 - 765a: 0e c0 rjmp .+28 ; 0x7678 - - netWriteReg(REG_S3_IR, IR_RECV); - 765c: 64 e0 ldi r22, 0x04 ; 4 - 765e: 82 e0 ldi r24, 0x02 ; 2 - 7660: 97 e0 ldi r25, 0x07 ; 7 - 7662: 90 dd rcall .-1248 ; 0x7184 - #else - //round up by default - __ticks_dc = (uint32_t)(ceil(fabs(__tmp))); - #endif - - __builtin_avr_delay_cycles(__ticks_dc); - 7664: 2f ef ldi r18, 0xFF ; 255 - 7666: 87 e8 ldi r24, 0x87 ; 135 - 7668: 93 e1 ldi r25, 0x13 ; 19 - 766a: 21 50 subi r18, 0x01 ; 1 - 766c: 80 40 sbci r24, 0x00 ; 0 - 766e: 90 40 sbci r25, 0x00 ; 0 - 7670: e1 f7 brne .-8 ; 0x766a - 7672: 00 c0 rjmp .+0 ; 0x7674 - 7674: 00 00 nop - 7676: ed cf rjmp .-38 ; 0x7652 - } - // Process Packet and get TFTP response code -#ifdef _DEBUG_TFTP - response = processPacket(packetSize); -#else - response = processPacket(); - 7678: 1f de rcall .-962 ; 0x72b8 - 767a: c8 2f mov r28, r24 -#endif - // Send the response - sendResponse(response); - 767c: 90 e0 ldi r25, 0x00 ; 0 - 767e: 3b df rcall .-394 ; 0x74f6 - } - if(response==FINAL_ACK) { - 7680: c4 30 cpi r28, 0x04 ; 4 - 7682: e9 f6 brne .-70 ; 0x763e - netWriteReg(REG_S3_CR, CR_CLOSE); - 7684: 60 e1 ldi r22, 0x10 ; 16 - 7686: 81 e0 ldi r24, 0x01 ; 1 - 7688: 97 e0 ldi r25, 0x07 ; 7 - 768a: 7c dd rcall .-1288 ; 0x7184 - // Complete - return(0); - 768c: 80 e0 ldi r24, 0x00 ; 0 - } - // Tftp continues - return(1); -} - 768e: cf 91 pop r28 - 7690: 08 95 ret - -00007692 : -#include "debug.h" -#include "serial.h" - - -uint8_t validImage(uint8_t *base) -{ - 7692: 20 e0 ldi r18, 0x00 ; 0 - 7694: 30 e0 ldi r19, 0x00 ; 0 -#include "validate.h" -#include "debug.h" -#include "serial.h" - - -uint8_t validImage(uint8_t *base) - 7696: fc 01 movw r30, r24 - 7698: e2 0f add r30, r18 - 769a: f3 1f adc r31, r19 - /* Check that a jump table is present in the first flash sector */ - uint8_t i; - for(i = 0; i < 0x34; i += 4) { - // For each vector, check it is of the form: - // 0x0C 0x94 0xWX 0xYZ ; JMP 0xWXYZ - if(base[i] != 0x0c) { - 769c: 40 81 ld r20, Z - 769e: 4c 30 cpi r20, 0x0C ; 12 - 76a0: 51 f4 brne .+20 ; 0x76b6 - tracenum(base[i]); - trace(" instead of 0x0C"); -#endif - return(0); - } - if(base[i + 1] != 0x94) { - 76a2: 41 81 ldd r20, Z+1 ; 0x01 - 76a4: 44 39 cpi r20, 0x94 ; 148 - 76a6: 39 f4 brne .+14 ; 0x76b6 - 76a8: 2c 5f subi r18, 0xFC ; 252 - 76aa: 3f 4f sbci r19, 0xFF ; 255 - -uint8_t validImage(uint8_t *base) -{ - /* Check that a jump table is present in the first flash sector */ - uint8_t i; - for(i = 0; i < 0x34; i += 4) { - 76ac: 24 33 cpi r18, 0x34 ; 52 - 76ae: 31 05 cpc r19, r1 - 76b0: 91 f7 brne .-28 ; 0x7696 - } - } -#ifdef _DEBUG_VALD - traceln("Vald: Valid image"); -#endif - return(1); - 76b2: 81 e0 ldi r24, 0x01 ; 1 - 76b4: 08 95 ret - tracenum(i); - trace(" with "); - tracenum(base[i]); - trace(" instead of 0x0C"); -#endif - return(0); - 76b6: 80 e0 ldi r24, 0x00 ; 0 - } -#ifdef _DEBUG_VALD - traceln("Vald: Valid image"); -#endif - return(1); -} - 76b8: 08 95 ret - -000076ba : - */ -uint8_t watchdogDisable(void) -{ - uint8_t mcusr_mirror; - - mcusr_mirror = MCUSR; - 76ba: 84 b7 in r24, 0x34 ; 52 - MCUSR = 0; - 76bc: 14 be out 0x34, r1 ; 52 - wdt_disable(); - 76be: 98 e1 ldi r25, 0x18 ; 24 - 76c0: 0f b6 in r0, 0x3f ; 63 - 76c2: f8 94 cli - 76c4: 90 93 60 00 sts 0x0060, r25 - 76c8: 10 92 60 00 sts 0x0060, r1 - 76cc: 0f be out 0x3f, r0 ; 63 - - return(mcusr_mirror); -} - 76ce: 08 95 ret - -000076d0 : - -void watchdogReset(void) -{ - wdt_reset(); - 76d0: a8 95 wdr - 76d2: 08 95 ret - -000076d4 : -} - -void watchdogConfig(uint8_t x) -{ - WDTCSR = _BV(WDCE) | _BV(WDE); - 76d4: e0 e6 ldi r30, 0x60 ; 96 - 76d6: f0 e0 ldi r31, 0x00 ; 0 - 76d8: 98 e1 ldi r25, 0x18 ; 24 - 76da: 90 83 st Z, r25 - WDTCSR = x; - 76dc: 80 83 st Z, r24 - 76de: 08 95 ret - -000076e0 : -uint8_t length; - - -void verifySpace() -{ - if(getch() != CRC_EOP) { - 76e0: 12 d1 rcall .+548 ; 0x7906 - 76e2: 80 32 cpi r24, 0x20 ; 32 - 76e4: 19 f0 breq .+6 ; 0x76ec - watchdogConfig(WATCHDOG_16MS); // shorten WD timeout - 76e6: 88 e0 ldi r24, 0x08 ; 8 - 76e8: f5 df rcall .-22 ; 0x76d4 - 76ea: ff cf rjmp .-2 ; 0x76ea - while(1) // and busy-loop so that WD causes - ; // a reset and app start. - } - putch(STK_INSYNC); - 76ec: 84 e1 ldi r24, 0x14 ; 20 - 76ee: f8 c0 rjmp .+496 ; 0x78e0 - -000076f0 : -} - - -void getNch(uint8_t count) -{ - 76f0: cf 93 push r28 - 76f2: c8 2f mov r28, r24 - do getch(); - 76f4: 08 d1 rcall .+528 ; 0x7906 - while(--count); - 76f6: c1 50 subi r28, 0x01 ; 1 - 76f8: e9 f7 brne .-6 ; 0x76f4 - verifySpace(); -} - 76fa: cf 91 pop r28 - -void getNch(uint8_t count) -{ - do getch(); - while(--count); - verifySpace(); - 76fc: f1 cf rjmp .-30 ; 0x76e0 - -000076fe : -} - - -uint8_t proccessCommand() -{ - 76fe: ef 92 push r14 - 7700: ff 92 push r15 - 7702: cf 93 push r28 - 7704: df 93 push r29 - 7706: cd b7 in r28, 0x3d ; 61 - 7708: de b7 in r29, 0x3e ; 62 - 770a: c1 50 subi r28, 0x01 ; 1 - 770c: d1 40 sbci r29, 0x01 ; 1 - 770e: de bf out 0x3e, r29 ; 62 - 7710: cd bf out 0x3d, r28 ; 61 - uint8_t ch; - - ch = getch(); - 7712: f9 d0 rcall .+498 ; 0x7906 - - if(ch == STK_GET_PARAMETER) { - 7714: 81 34 cpi r24, 0x41 ; 65 - 7716: a9 f4 brne .+42 ; 0x7742 - unsigned char which = getch(); - 7718: f6 d0 rcall .+492 ; 0x7906 - verifySpace(); - 771a: cf 5f subi r28, 0xFF ; 255 - 771c: de 4f sbci r29, 0xFE ; 254 - 771e: 88 83 st Y, r24 - 7720: c1 50 subi r28, 0x01 ; 1 - 7722: d1 40 sbci r29, 0x01 ; 1 - 7724: dd df rcall .-70 ; 0x76e0 - if(which == 0x82) { - 7726: cf 5f subi r28, 0xFF ; 255 - 7728: de 4f sbci r29, 0xFE ; 254 - 772a: 88 81 ld r24, Y - 772c: c1 50 subi r28, 0x01 ; 1 - 772e: d1 40 sbci r29, 0x01 ; 1 - 7730: 82 38 cpi r24, 0x82 ; 130 - 7732: 11 f4 brne .+4 ; 0x7738 - /* - * Send tftpboot version as "minor SW version" - */ - putch(TFTPBOOT_MINVER); - 7734: 83 e0 ldi r24, 0x03 ; 3 - 7736: 03 c0 rjmp .+6 ; 0x773e - } else if(which == 0x81) { - 7738: 81 38 cpi r24, 0x81 ; 129 - 773a: e1 f7 brne .-8 ; 0x7734 - putch(TFTPBOOT_MAJVER); - 773c: 80 e0 ldi r24, 0x00 ; 0 - 773e: d0 d0 rcall .+416 ; 0x78e0 - 7740: ac c0 rjmp .+344 ; 0x789a - * GET PARAMETER returns a generic 0x03 reply for - * other parameters - enough to keep Avrdude happy - */ - putch(0x03); - } - } else if(ch == STK_SET_DEVICE) { - 7742: 82 34 cpi r24, 0x42 ; 66 - 7744: 11 f4 brne .+4 ; 0x774a - // SET DEVICE is ignored - getNch(20); - 7746: 84 e1 ldi r24, 0x14 ; 20 - 7748: 03 c0 rjmp .+6 ; 0x7750 - } else if(ch == STK_SET_DEVICE_EXT) { - 774a: 85 34 cpi r24, 0x45 ; 69 - 774c: 19 f4 brne .+6 ; 0x7754 - // SET DEVICE EXT is ignored - getNch(4); - 774e: 84 e0 ldi r24, 0x04 ; 4 - 7750: cf df rcall .-98 ; 0x76f0 - 7752: a3 c0 rjmp .+326 ; 0x789a - } else if(ch == STK_LOAD_ADDRESS) { - 7754: 85 35 cpi r24, 0x55 ; 85 - 7756: 69 f4 brne .+26 ; 0x7772 - // LOAD ADDRESS - uint16_t newAddress; - newAddress = getch(); - 7758: d6 d0 rcall .+428 ; 0x7906 - 775a: f8 2e mov r15, r24 - newAddress = (newAddress & 0xff) | (getch() << 8); - 775c: d4 d0 rcall .+424 ; 0x7906 - 775e: 2f 2d mov r18, r15 - 7760: 30 e0 ldi r19, 0x00 ; 0 - 7762: 38 2b or r19, r24 -#ifdef RAMPZ - // Transfer top bit to RAMPZ - RAMPZ = (newAddress & 0x8000) ? 1 : 0; -#endif - - newAddress += newAddress; // Convert from word address to byte address - 7764: 22 0f add r18, r18 - 7766: 33 1f adc r19, r19 - address = newAddress; - 7768: 30 93 21 01 sts 0x0121, r19 - 776c: 20 93 20 01 sts 0x0120, r18 - 7770: 93 c0 rjmp .+294 ; 0x7898 - verifySpace(); - } else if(ch == STK_UNIVERSAL) { - 7772: 86 35 cpi r24, 0x56 ; 86 - 7774: 19 f4 brne .+6 ; 0x777c - // UNIVERSAL command is ignored - getNch(4); - 7776: 84 e0 ldi r24, 0x04 ; 4 - 7778: bb df rcall .-138 ; 0x76f0 - 777a: e0 cf rjmp .-64 ; 0x773c - putch(0x00); - } - /* Write memory, length is big endian and is in bytes */ - else if(ch == STK_PROG_PAGE) { - 777c: 84 36 cpi r24, 0x64 ; 100 - 777e: 09 f0 breq .+2 ; 0x7782 - 7780: 5b c0 rjmp .+182 ; 0x7838 - // PROGRAM PAGE - we support flash programming only, not EEPROM - uint8_t buff[256]; - uint8_t* bufPtr; - uint16_t addrPtr; - - getch(); /* getlen() */ - 7782: c1 d0 rcall .+386 ; 0x7906 - length = getch(); - 7784: c0 d0 rcall .+384 ; 0x7906 - 7786: 80 93 26 01 sts 0x0126, r24 - getch(); - 778a: bd d0 rcall .+378 ; 0x7906 - - // If we are in RWW section, immediately start page erase - if(address < NRWWSTART) boot_page_erase((uint16_t)(void *)address); - 778c: e0 91 20 01 lds r30, 0x0120 - 7790: f0 91 21 01 lds r31, 0x0121 - 7794: e1 15 cp r30, r1 - 7796: 80 e7 ldi r24, 0x70 ; 112 - 7798: f8 07 cpc r31, r24 - 779a: 18 f4 brcc .+6 ; 0x77a2 - 779c: 83 e0 ldi r24, 0x03 ; 3 - 779e: 87 bf out 0x37, r24 ; 55 - 77a0: e8 95 spm - 77a2: ee 24 eor r14, r14 - 77a4: e3 94 inc r14 - 77a6: f1 2c mov r15, r1 - 77a8: ec 0e add r14, r28 - 77aa: fd 1e adc r15, r29 - - // While that is going on, read in page contents - bufPtr = buff; - do *bufPtr++ = getch(); - 77ac: ac d0 rcall .+344 ; 0x7906 - 77ae: f7 01 movw r30, r14 - 77b0: 81 93 st Z+, r24 - 77b2: 7f 01 movw r14, r30 - while(--length); - 77b4: 80 91 26 01 lds r24, 0x0126 - 77b8: 81 50 subi r24, 0x01 ; 1 - 77ba: 80 93 26 01 sts 0x0126, r24 - 77be: 81 11 cpse r24, r1 - 77c0: f5 cf rjmp .-22 ; 0x77ac - - // If we are in NRWW section, page erase has to be delayed until now. - // Todo: Take RAMPZ into account - if(address >= NRWWSTART) boot_page_erase((uint16_t)(void *)address); - 77c2: e0 91 20 01 lds r30, 0x0120 - 77c6: f0 91 21 01 lds r31, 0x0121 - 77ca: e1 15 cp r30, r1 - 77cc: 80 e7 ldi r24, 0x70 ; 112 - 77ce: f8 07 cpc r31, r24 - 77d0: 18 f0 brcs .+6 ; 0x77d8 - 77d2: 83 e0 ldi r24, 0x03 ; 3 - 77d4: 87 bf out 0x37, r24 ; 55 - 77d6: e8 95 spm - - // Read command terminator, start reply - verifySpace(); - 77d8: 83 df rcall .-250 ; 0x76e0 - - // If only a partial page is to be programmed, the erase might not be complete. - // So check that here - boot_spm_busy_wait(); - 77da: 07 b6 in r0, 0x37 ; 55 - 77dc: 00 fc sbrc r0, 0 - 77de: fd cf rjmp .-6 ; 0x77da - - // Copy buffer into programming buffer - bufPtr = buff; - addrPtr = (uint16_t)(void *)address; - 77e0: 40 91 20 01 lds r20, 0x0120 - 77e4: 50 91 21 01 lds r21, 0x0121 - // If only a partial page is to be programmed, the erase might not be complete. - // So check that here - boot_spm_busy_wait(); - - // Copy buffer into programming buffer - bufPtr = buff; - 77e8: 29 81 ldd r18, Y+1 ; 0x01 - 77ea: 80 e0 ldi r24, 0x00 ; 0 - 77ec: 90 e0 ldi r25, 0x00 ; 0 - ch = SPM_PAGESIZE / 2; - do { - uint16_t a; - a = *bufPtr++; - a |= (*bufPtr++) << 8; - boot_page_fill((uint16_t)(void *)addrPtr, a); - 77ee: 61 e0 ldi r22, 0x01 ; 1 - while(--count); - verifySpace(); -} - - -uint8_t proccessCommand() - 77f0: a1 e0 ldi r26, 0x01 ; 1 - 77f2: b0 e0 ldi r27, 0x00 ; 0 - 77f4: ac 0f add r26, r28 - 77f6: bd 1f adc r27, r29 - 77f8: a8 0f add r26, r24 - 77fa: b9 1f adc r27, r25 - 77fc: fc 01 movw r30, r24 - 77fe: e4 0f add r30, r20 - 7800: f5 1f adc r31, r21 - addrPtr = (uint16_t)(void *)address; - ch = SPM_PAGESIZE / 2; - do { - uint16_t a; - a = *bufPtr++; - a |= (*bufPtr++) << 8; - 7802: 11 96 adiw r26, 0x01 ; 1 - 7804: 7c 91 ld r23, X - 7806: 11 97 sbiw r26, 0x01 ; 1 - 7808: 30 e0 ldi r19, 0x00 ; 0 - 780a: 37 2b or r19, r23 - boot_page_fill((uint16_t)(void *)addrPtr, a); - 780c: 09 01 movw r0, r18 - 780e: 67 bf out 0x37, r22 ; 55 - 7810: e8 95 spm - 7812: 11 24 eor r1, r1 - addrPtr += 2; - } while(--ch); - 7814: 8e 37 cpi r24, 0x7E ; 126 - 7816: 91 05 cpc r25, r1 - 7818: 21 f0 breq .+8 ; 0x7822 - addrPtr = (uint16_t)(void *)address; - ch = SPM_PAGESIZE / 2; - do { - uint16_t a; - a = *bufPtr++; - a |= (*bufPtr++) << 8; - 781a: 12 96 adiw r26, 0x02 ; 2 - 781c: 2c 91 ld r18, X - 781e: 02 96 adiw r24, 0x02 ; 2 - 7820: e7 cf rjmp .-50 ; 0x77f0 - boot_page_fill((uint16_t)(void *)addrPtr, a); - addrPtr += 2; - } while(--ch); - - // Write from programming buffer - boot_page_write((uint16_t)(void *)address); - 7822: 85 e0 ldi r24, 0x05 ; 5 - 7824: fa 01 movw r30, r20 - 7826: 87 bf out 0x37, r24 ; 55 - 7828: e8 95 spm - boot_spm_busy_wait(); - 782a: 07 b6 in r0, 0x37 ; 55 - 782c: 00 fc sbrc r0, 0 - 782e: fd cf rjmp .-6 ; 0x782a - -#if defined(RWWSRE) - // Reenable read access to flash - boot_rww_enable(); - 7830: 81 e1 ldi r24, 0x11 ; 17 - 7832: 87 bf out 0x37, r24 ; 55 - 7834: e8 95 spm - 7836: 31 c0 rjmp .+98 ; 0x789a -#endif - } - /* Read memory block mode, length is big endian. */ - else if(ch == STK_READ_PAGE) { - 7838: 84 37 cpi r24, 0x74 ; 116 - 783a: d1 f4 brne .+52 ; 0x7870 - // READ PAGE - we only read flash - getch(); /* getlen() */ - 783c: 64 d0 rcall .+200 ; 0x7906 - length = getch(); - 783e: 63 d0 rcall .+198 ; 0x7906 - 7840: 80 93 26 01 sts 0x0126, r24 - getch(); - 7844: 60 d0 rcall .+192 ; 0x7906 - - verifySpace(); - 7846: 4c df rcall .-360 ; 0x76e0 - __asm__("elpm %0,Z\n":"=r"(result):"z"(address)); - putch(result); - address++; - } while(--length); -#else - do putch(pgm_read_byte_near(address++)); - 7848: e0 91 20 01 lds r30, 0x0120 - 784c: f0 91 21 01 lds r31, 0x0121 - 7850: cf 01 movw r24, r30 - 7852: 01 96 adiw r24, 0x01 ; 1 - 7854: 90 93 21 01 sts 0x0121, r25 - 7858: 80 93 20 01 sts 0x0120, r24 - 785c: 84 91 lpm r24, Z - 785e: 40 d0 rcall .+128 ; 0x78e0 - while(--length); - 7860: 80 91 26 01 lds r24, 0x0126 - 7864: 81 50 subi r24, 0x01 ; 1 - 7866: 80 93 26 01 sts 0x0126, r24 - 786a: 81 11 cpse r24, r1 - 786c: ed cf rjmp .-38 ; 0x7848 - 786e: 15 c0 rjmp .+42 ; 0x789a -#endif - } - /* Get device signature bytes */ - else if(ch == STK_READ_SIGN) { - 7870: 85 37 cpi r24, 0x75 ; 117 - 7872: 39 f4 brne .+14 ; 0x7882 - // READ SIGN - return what Avrdude wants to hear - verifySpace(); - 7874: 35 df rcall .-406 ; 0x76e0 - putch(SIGNATURE_0); - 7876: 8e e1 ldi r24, 0x1E ; 30 - 7878: 33 d0 rcall .+102 ; 0x78e0 - putch(SIGNATURE_1); - 787a: 85 e9 ldi r24, 0x95 ; 149 - 787c: 31 d0 rcall .+98 ; 0x78e0 - putch(SIGNATURE_2); - 787e: 8f e0 ldi r24, 0x0F ; 15 - 7880: 5e cf rjmp .-324 ; 0x773e - } else if(ch == STK_LEAVE_PROGMODE) { - 7882: 81 35 cpi r24, 0x51 ; 81 - 7884: 49 f4 brne .+18 ; 0x7898 - // Adaboot no-wait mod - //watchdogConfig(WATCHDOG_16MS); - verifySpace(); - 7886: 2c df rcall .-424 ; 0x76e0 - eeprom_write_byte(EEPROM_IMG_STAT, EEPROM_IMG_OK_VALUE); - 7888: 6b eb ldi r22, 0xBB ; 187 - 788a: 82 e0 ldi r24, 0x02 ; 2 - 788c: 90 e0 ldi r25, 0x00 ; 0 - 788e: 8e d0 rcall .+284 ; 0x79ac <__eewr_byte_m328p> - putch(STK_OK); - 7890: 80 e1 ldi r24, 0x10 ; 16 - 7892: 26 d0 rcall .+76 ; 0x78e0 - return(0); - 7894: 80 e0 ldi r24, 0x00 ; 0 - 7896: 04 c0 rjmp .+8 ; 0x78a0 - } else { - // This covers the response to commands like STK_ENTER_PROGMODE - verifySpace(); - 7898: 23 df rcall .-442 ; 0x76e0 - } - putch(STK_OK); - 789a: 80 e1 ldi r24, 0x10 ; 16 - 789c: 21 d0 rcall .+66 ; 0x78e0 - return(1); - 789e: 81 e0 ldi r24, 0x01 ; 1 -} - 78a0: cf 5f subi r28, 0xFF ; 255 - 78a2: de 4f sbci r29, 0xFE ; 254 - 78a4: de bf out 0x3e, r29 ; 62 - 78a6: cd bf out 0x3d, r28 ; 61 - 78a8: df 91 pop r29 - 78aa: cf 91 pop r28 - 78ac: ff 90 pop r15 - 78ae: ef 90 pop r14 - 78b0: 08 95 ret - -000078b2 : - - -uint8_t serialPoll() -{ - if(UCSR0A & _BV(RXC0)){ - 78b2: 80 91 c0 00 lds r24, 0x00C0 - 78b6: 87 ff sbrs r24, 7 - 78b8: 04 c0 rjmp .+8 ; 0x78c2 - serialFlashing = TRUE; - 78ba: 81 e0 ldi r24, 0x01 ; 1 - 78bc: 80 93 24 01 sts 0x0124, r24 - return(proccessCommand()); - 78c0: 1e cf rjmp .-452 ; 0x76fe - } else return(1); -} - 78c2: 81 e0 ldi r24, 0x01 ; 1 - 78c4: 08 95 ret - -000078c6 : -#include "pin_defs.h" - - -void serialInit() -{ - UCSR0A = _BV(U2X0); //Double speed mode USART0 - 78c6: 82 e0 ldi r24, 0x02 ; 2 - 78c8: 80 93 c0 00 sts 0x00C0, r24 - UCSR0B = _BV(RXEN0) | _BV(TXEN0); - 78cc: 88 e1 ldi r24, 0x18 ; 24 - 78ce: 80 93 c1 00 sts 0x00C1, r24 - UCSR0C = _BV(UCSZ00) | _BV(UCSZ01); - 78d2: 86 e0 ldi r24, 0x06 ; 6 - 78d4: 80 93 c2 00 sts 0x00C2, r24 - UBRR0L = (uint8_t)((F_CPU + BAUD_RATE * 4L) / (BAUD_RATE * 8L) - 1); - 78d8: 80 e1 ldi r24, 0x10 ; 16 - 78da: 80 93 c4 00 sts 0x00C4, r24 - 78de: 08 95 ret - -000078e0 : -} - - -void putch(uint8_t c) -{ - while(!(UCSR0A & _BV(UDRE0))); - 78e0: 90 91 c0 00 lds r25, 0x00C0 - 78e4: 95 ff sbrs r25, 5 - 78e6: fc cf rjmp .-8 ; 0x78e0 - UDR0 = c; - 78e8: 80 93 c6 00 sts 0x00C6, r24 - 78ec: 08 95 ret - -000078ee : -} - - -void puthex(uint8_t c) -{ - c &= 0xf; - 78ee: 8f 70 andi r24, 0x0F ; 15 - if(c > 9) c += 7; - 78f0: 8a 30 cpi r24, 0x0A ; 10 - 78f2: 08 f0 brcs .+2 ; 0x78f6 - 78f4: 89 5f subi r24, 0xF9 ; 249 - while(!(UCSR0A & _BV(UDRE0))); - 78f6: 90 91 c0 00 lds r25, 0x00C0 - 78fa: 95 ff sbrs r25, 5 - 78fc: fc cf rjmp .-8 ; 0x78f6 - UDR0 = c + '0'; - 78fe: 80 5d subi r24, 0xD0 ; 208 - 7900: 80 93 c6 00 sts 0x00C6, r24 - 7904: 08 95 ret - -00007906 : - -uint8_t getch(void) -{ - uint8_t ch; - - while(!(UCSR0A & _BV(RXC0))); - 7906: 80 91 c0 00 lds r24, 0x00C0 - 790a: 87 ff sbrs r24, 7 - 790c: fc cf rjmp .-8 ; 0x7906 - if(!(UCSR0A & _BV(FE0))) { - 790e: 80 91 c0 00 lds r24, 0x00C0 - 7912: 84 ff sbrs r24, 4 - * expects to be talking to the application, and DON'T reset the - * watchdog. This should cause the bootloader to abort and run - * the application "soon", if it keeps happening. (Note that we - * don't care that an invalid char is returned...) - */ - watchdogReset(); - 7914: dd de rcall .-582 ; 0x76d0 - } - ch = UDR0; - 7916: 80 91 c6 00 lds r24, 0x00C6 - - return ch; -} - 791a: 08 95 ret - -0000791c : -uint16_t tick = 0; - - -void updateLed(void) -{ - uint16_t nextTimer1 = TCNT1; - 791c: 80 91 84 00 lds r24, 0x0084 - 7920: 90 91 85 00 lds r25, 0x0085 - if(nextTimer1 & 0x400) LED_PORT ^= _BV(LED); // Led pin high - 7924: 92 ff sbrs r25, 2 - 7926: 05 c0 rjmp .+10 ; 0x7932 - 7928: 25 b1 in r18, 0x05 ; 5 - 792a: 32 e0 ldi r19, 0x02 ; 2 - 792c: 23 27 eor r18, r19 - 792e: 25 b9 out 0x05, r18 ; 5 - 7930: 01 c0 rjmp .+2 ; 0x7934 - else LED_PORT &= ~_BV(LED); // Led pin low - 7932: 29 98 cbi 0x05, 1 ; 5 - if(nextTimer1 < lastTimer1) tick++; - 7934: 20 91 27 01 lds r18, 0x0127 - 7938: 30 91 28 01 lds r19, 0x0128 - 793c: 82 17 cp r24, r18 - 793e: 93 07 cpc r25, r19 - 7940: 50 f4 brcc .+20 ; 0x7956 - 7942: 20 91 22 01 lds r18, 0x0122 - 7946: 30 91 23 01 lds r19, 0x0123 - 794a: 2f 5f subi r18, 0xFF ; 255 - 794c: 3f 4f sbci r19, 0xFF ; 255 - 794e: 30 93 23 01 sts 0x0123, r19 - 7952: 20 93 22 01 sts 0x0122, r18 - lastTimer1 = nextTimer1; - 7956: 90 93 28 01 sts 0x0128, r25 - 795a: 80 93 27 01 sts 0x0127, r24 - 795e: 08 95 ret - -00007960 : -} - -void resetTick(void) -{ - tick = 0; - 7960: 10 92 23 01 sts 0x0123, r1 - 7964: 10 92 22 01 sts 0x0122, r1 - 7968: 08 95 ret - -0000796a : -} - -uint8_t timedOut(void) -{ - // Never timeout if there is no code in Flash - if(pgm_read_word(0x0000) == 0xFFFF) return(0); - 796a: e0 e0 ldi r30, 0x00 ; 0 - 796c: f0 e0 ldi r31, 0x00 ; 0 - 796e: 85 91 lpm r24, Z+ - 7970: 94 91 lpm r25, Z - 7972: 01 96 adiw r24, 0x01 ; 1 - 7974: 41 f0 breq .+16 ; 0x7986 - if(tick > TIMEOUT) return(1); - 7976: 81 e0 ldi r24, 0x01 ; 1 - 7978: 20 91 22 01 lds r18, 0x0122 - 797c: 30 91 23 01 lds r19, 0x0123 - 7980: 24 30 cpi r18, 0x04 ; 4 - 7982: 31 05 cpc r19, r1 - 7984: 08 f4 brcc .+2 ; 0x7988 -} - -uint8_t timedOut(void) -{ - // Never timeout if there is no code in Flash - if(pgm_read_word(0x0000) == 0xFFFF) return(0); - 7986: 80 e0 ldi r24, 0x00 ; 0 - if(tick > TIMEOUT) return(1); - return(0); -} - 7988: 08 95 ret - -0000798a : - 798a: fb 01 movw r30, r22 - 798c: dc 01 movw r26, r24 - 798e: 02 c0 rjmp .+4 ; 0x7994 - 7990: 05 90 lpm r0, Z+ - 7992: 0d 92 st X+, r0 - 7994: 41 50 subi r20, 0x01 ; 1 - 7996: 50 40 sbci r21, 0x00 ; 0 - 7998: d8 f7 brcc .-10 ; 0x7990 - 799a: 08 95 ret - -0000799c <__eerd_byte_m328p>: - 799c: f9 99 sbic 0x1f, 1 ; 31 - 799e: fe cf rjmp .-4 ; 0x799c <__eerd_byte_m328p> - 79a0: 92 bd out 0x22, r25 ; 34 - 79a2: 81 bd out 0x21, r24 ; 33 - 79a4: f8 9a sbi 0x1f, 0 ; 31 - 79a6: 99 27 eor r25, r25 - 79a8: 80 b5 in r24, 0x20 ; 32 - 79aa: 08 95 ret - -000079ac <__eewr_byte_m328p>: - 79ac: 26 2f mov r18, r22 - -000079ae <__eewr_r18_m328p>: - 79ae: f9 99 sbic 0x1f, 1 ; 31 - 79b0: fe cf rjmp .-4 ; 0x79ae <__eewr_r18_m328p> - 79b2: 1f ba out 0x1f, r1 ; 31 - 79b4: 92 bd out 0x22, r25 ; 34 - 79b6: 81 bd out 0x21, r24 ; 33 - 79b8: 20 bd out 0x20, r18 ; 32 - 79ba: 0f b6 in r0, 0x3f ; 63 - 79bc: f8 94 cli - 79be: fa 9a sbi 0x1f, 2 ; 31 - 79c0: f9 9a sbi 0x1f, 1 ; 31 - 79c2: 0f be out 0x3f, r0 ; 63 - 79c4: 01 96 adiw r24, 0x01 ; 1 - 79c6: 08 95 ret - -000079c8 <_exit>: - 79c8: f8 94 cli - -000079ca <__stop_program>: - 79ca: ff cf rjmp .-2 ; 0x79ca <__stop_program> diff --git a/libraries/EthernetReset/EthernetReset.h b/libraries/EthernetReset/EthernetReset.h index e69de29..ac45c18 100644 --- a/libraries/EthernetReset/EthernetReset.h +++ b/libraries/EthernetReset/EthernetReset.h @@ -0,0 +1,3 @@ +#include +#include +#include \ No newline at end of file diff --git a/libraries/NetEEPROM/NetEEPROM.cpp b/libraries/NetEEPROM/NetEEPROM.cpp index 38c516e..725745c 100644 --- a/libraries/NetEEPROM/NetEEPROM.cpp +++ b/libraries/NetEEPROM/NetEEPROM.cpp @@ -1,55 +1,179 @@ #include "NetEEPROM.h" +#include "NetEEPROM_defs.h" - -void NetEEPROM::WriteSig() +void NetEEPROMClass::writeSig() { - EEPROM.write(0, 0x55); // Set signature 1 to load eeprom settings - EEPROM.write(1, 0xAA); // Set signature 2 + write(NETEEPROM_SIG_1, NETEEPROM_SIG_1_VAL); // Set signature 1 to load eeprom settings + write(NETEEPROM_SIG_2, NETEEPROM_SIG_2_VAL); // Set signature 2 } -void NetEEPROM::EraseSig() +void NetEEPROMClass::eraseSig() { - EEPROM.write(0, 0xFF); // Unset signature 1 to load built-in settings - EEPROM.write(1, 0xFF); // Unset signature 2 + write(NETEEPROM_SIG_1, 0xFF); // Unset signature 1 to load built-in settings + write(NETEEPROM_SIG_2, 0xFF); // Unset signature 2 } -uint8_t NetEEPROM::SigIsSet() +uint8_t NetEEPROMClass::sigIsSet() { - if((EEPROM.read(0)==0x55) && (EEPROM.read(1)==0xAA)) return(1); + if((read(NETEEPROM_SIG_1)==NETEEPROM_SIG_1_VAL) + && (read(NETEEPROM_SIG_2)==NETEEPROM_SIG_2_VAL)) return(1); else return(0); } -void NetEEPROM::WriteImgBad() +void NetEEPROMClass::writeImgBad() { - EEPROM.write(2, 0xFF); // Image status set to invalid + write(NETEEPROM_IMG_STAT, NETEEPROM_IMG_BAD_VAL); // Image status set to invalid } -void NetEEPROM::WriteImgOk() +void NetEEPROMClass::writeImgOk() { - EEPROM.write(2, 0xBB); // Image status set to valid + write(NETEEPROM_IMG_STAT, NETEEPROM_IMG_OK_VAL); // Image status set to valid } -void NetEEPROM::Write(uint8_t table[]) +void NetEEPROMClass::writeNet(uint8_t settings[NETWORK_SETTINGS_SIZE], uint16_t port) { - for(int address = 0; address < EEPROM_SETTINGS_SIZE; address++) { - EEPROM.write(address+3, table[address]); + for(int address = 0; address < NETWORK_SETTINGS_SIZE; address++) { + write(address+NETEEPROM_SETTINGS_OFFSET, settings[address]); } + write(NETEEPROM_PORT, (port&0xFF)); + write(NETEEPROM_PORT+1, (port>>8)); + + writeSig(); } -void NetEEPROM::Write(uint8_t ip[4], uint8_t sb[4], uint8_t gw[4], uint8_t mac[6]) +void NetEEPROMClass::writeNet(uint8_t ip[4], uint8_t sn[4], uint8_t gw[4], uint8_t mac[6], uint16_t port) { - uint8_t table[18] = {gw[0], gw[1], gw[2], gw[3], - sb[0], sb[1], sb[2], sb[3], - mac[0], mac[1], mac[2], - mac[3], mac[4], mac[5], - ip[0], ip[1], ip[2], ip[3]}; + uint8_t settings[NETWORK_SETTINGS_SIZE] = + {gw[0], gw[1], gw[2], gw[3], + sn[0], sn[1], sn[2], sn[3], + mac[0], mac[1], mac[2], + mac[3], mac[4], mac[5], + ip[0], ip[1], ip[2], ip[3]}; - Write(table); + writeNet(settings, port); } -void NetEEPROM::Read(uint8_t *table) +void NetEEPROMClass::readIP(uint8_t ip[4]) { - for(int address = 0; address < EEPROM_SETTINGS_SIZE; address++) { - table[address] = EEPROM.read(address+3); - } + for(int address = NETEEPROM_IP; address < NETEEPROM_IP+4; address++) + ip[address-NETEEPROM_IP] = read(address); +} + +void NetEEPROMClass::readSN(uint8_t sn[4]) +{ + for(int address = NETEEPROM_SN; address < NETEEPROM_SN+4; address++) + sn[address-NETEEPROM_SN] = read(address); +} + +void NetEEPROMClass::readGW(uint8_t gw[4]) +{ + for(int address = NETEEPROM_GW; address < NETEEPROM_GW+4; address++) + gw[address-NETEEPROM_GW] = read(address); +} + +void NetEEPROMClass::readMAC(uint8_t mac[6]) +{ + for(int address = NETEEPROM_MAC; address < NETEEPROM_MAC+6; address++) + mac[address-NETEEPROM_MAC] = read(address); +} + +uint16_t NetEEPROMClass::readPort(void) +{ + uint8_t loByte = read(NETEEPROM_PORT); + uint8_t hiByte = read(NETEEPROM_PORT+1); + return((hiByte<<8) + loByte); +} + +void NetEEPROMClass::readNet(uint8_t settings[NETWORK_SETTINGS_SIZE], uint16_t* port) +{ + for(int address = 0; address < NETWORK_SETTINGS_SIZE; address++) + settings[address] = read(address+NETEEPROM_SETTINGS_OFFSET); + + *port = readPort(); +} + +void NetEEPROMClass::readNet(uint8_t ip[4], uint8_t sn[4], uint8_t gw[4], uint8_t mac[6], uint16_t* port) +{ + readIP(ip); + readSN(sn); + readGW(gw); + readMAC(mac); + *port = readPort(); +} + +void NetEEPROMClass::printNet(uint8_t settings[NETWORK_SETTINGS_SIZE], uint16_t* port) +{ + if(sigIsSet()) { + uint8_t i; + + for(i = 0; i < NETWORK_SETTINGS_SIZE; i++) { + if(i == 0) + Serial.print("Gateway: "); + else if(i == 4) { + Serial.println(); + Serial.print(" Subnet: "); + } else if(i == 8) { + Serial.println(); + Serial.print(" MAC: "); + } else if(i == 14) { + Serial.println(); + Serial.print("Address: "); + } else Serial.print("."); + if(i >= 8 && i < 14) { + Serial.print("0x"); + Serial.print(settings[i], HEX); + } else Serial.print(settings[i]); + } + Serial.println(); + Serial.print(" Port: "); + Serial.print(*port); + } else Serial.print("Using built in settings"); +} + +void NetEEPROMClass::printNet(uint8_t ip[4], uint8_t sn[4], uint8_t gw[4], uint8_t mac[6], uint16_t *port) +{ + if(sigIsSet()) { + uint8_t i; + + Serial.print("Address: "); + for(i=0; i<4; i++) { + Serial.print(ip[i]); + if(i!=3) Serial.print("."); + else Serial.println(); + } + Serial.print(" Subnet: "); + for(i=0; i<4; i++) { + Serial.print(sn[i]); + if(i!=3) Serial.print("."); + else Serial.println(); + } + Serial.print("Gateway: "); + for(i=0; i<4; i++) { + Serial.print(gw[i]); + if(i!=3) Serial.print("."); + else Serial.println(); + } + Serial.print(" MAC: "); + for(i=0; i<6; i++){ + Serial.print("0x"); + Serial.print(mac[i], HEX); + if(i!=5) Serial.print("."); + else Serial.println(); + } + Serial.print(" Port: "); + Serial.print(*port); + Serial.println(); + } else Serial.print("Using built in settings"); } + + +void NetEEPROMClass::print(void) +{ + uint8_t settings[NETWORK_SETTINGS_SIZE]; + uint16_t port; + + readNet(settings, &port); + printNet(settings, &port); +} + +NetEEPROMClass NetEEPROM; diff --git a/libraries/NetEEPROM/NetEEPROM.h b/libraries/NetEEPROM/NetEEPROM.h index 7db88a9..9b37c1e 100644 --- a/libraries/NetEEPROM/NetEEPROM.h +++ b/libraries/NetEEPROM/NetEEPROM.h @@ -1,17 +1,52 @@ -#include +#ifndef NetEEPROM_h +#define NetEEPROM_h + +#include #include -#include -#define EEPROM_SETTINGS_SIZE 18 +#define NETWORK_SETTINGS_SIZE 18 -class NetEEPROM { +class NetEEPROMClass: public EEPROMClass { + private: + /* Write signature bytes in eeprom, informing the bootloader that + * the network settings will be loaded from the eeprom */ + void writeSig(); + void readIP(uint8_t ip[4]); + void readSN(uint8_t sn[4]); + void readGW(uint8_t gw[4]); + void readMAC(uint8_t mac[4]); + uint16_t readPort(void); public: - void WriteSig(); - void EraseSig(); - uint8_t SigIsSet(); - void WriteImgBad(); - void WriteImgOk(); - void Write(uint8_t table[18]); - void Write(uint8_t ip[4], uint8_t sb[4], uint8_t gw[4], uint8_t mac[6]); - void Read(uint8_t* table); + /* Erase signature bytes in eeprom to revert the bootloader to + * built-in settings */ + void eraseSig(); + /* Check if the signature bytes are set, returning 1 if they are + * set or 0 if they are unset */ + uint8_t sigIsSet(); + /* Set the flashed image status to bad, to prevent the bootloader + * from timing out */ + void writeImgBad(); + /* Set the flashed image status to good, to allow the bootloader + * to load the program in memory */ + void writeImgOk(); + /* Write the network settings to EEPROM from a settings array */ + void writeNet(uint8_t settings[NETWORK_SETTINGS_SIZE], uint16_t port); + /* Write the network settings to EEPROM as individual arrays */ + void writeNet(uint8_t ip[4], uint8_t sn[4], uint8_t gw[4], uint8_t mac[6], uint16_t port); + /* Read the network settings to a table with size NETWORK_SETTINGS_SIZE + * that is given as the only argument */ + void readNet(uint8_t settings[NETWORK_SETTINGS_SIZE], uint16_t* port); + /* Read the network settings to EEPROM to individual arrays */ + void readNet(uint8_t ip[4], uint8_t sn[4], uint8_t gw[4], uint8_t mac[6], uint16_t* port); + /* Print the network settings previously loaded in the an array + * using the NetEEPROM::Read function */ + void printNet(uint8_t settings[NETWORK_SETTINGS_SIZE], uint16_t* port); + /* Print the network settings from previously loaded arrays */ + void printNet(uint8_t ip[4], uint8_t sn[4], uint8_t gw[4], uint8_t mac[6], uint16_t* port); + /* Print the network settings */ + void print(void); }; + +extern NetEEPROMClass NetEEPROM; + +#endif diff --git a/libraries/NetEEPROM/NetEEPROM_defs.h b/libraries/NetEEPROM/NetEEPROM_defs.h new file mode 100644 index 0000000..4abb0d6 --- /dev/null +++ b/libraries/NetEEPROM/NetEEPROM_defs.h @@ -0,0 +1,23 @@ +#ifndef NetEEPROM_defs_h +#define NetEEPROM_defs_h + +#define NETEEPROM_SETTINGS_OFFSET 3 +/* EEPROM partitioning */ +#define NETEEPROM_SIG_1 0 +#define NETEEPROM_SIG_2 1 +//#define SIG_3 2 /* This is going to be the port signature byte */ +#define NETEEPROM_IMG_STAT 2 +#define NETEEPROM_DATA 3 +#define NETEEPROM_GW 4 +#define NETEEPROM_SN 7 +#define NETEEPROM_MAC 11 +#define NETEEPROM_IP 17 +#define NETEEPROM_PORT 21 +/* EERPOM values */ +#define NETEEPROM_SIG_1_VAL (0x55) +#define NETEEPROM_SIG_2_VAL (0xAA) +//#define NETEEPROM_SIG_3_VAL (0xCC) /* This is going to be the port signature value */ +#define NETEEPROM_IMG_OK_VAL (0xBB) +#define NETEEPROM_IMG_BAD_VAL (0xFF) + +#endif \ No newline at end of file diff --git a/libraries/NetEEPROM/examples/ReadNetworkSettings/ReadNetworkSettings.ino b/libraries/NetEEPROM/examples/ReadNetworkSettings/ReadNetworkSettings.ino index 7e8da36..0e72463 100644 --- a/libraries/NetEEPROM/examples/ReadNetworkSettings/ReadNetworkSettings.ino +++ b/libraries/NetEEPROM/examples/ReadNetworkSettings/ReadNetworkSettings.ino @@ -4,69 +4,37 @@ * */ -#include -#include -#include #include #include -NetEEPROM neteeprom; -uint8_t settings[EEPROM_SETTINGS_SIZE]; - -// Preset for Arduino Uno with ethernet shield -// For Arduino Ethernet set this to 9 +/* Preset for Arduino Uno with Ethernet shield. + * For Arduino Ethernet set this to 9 */ int ledpin = 13; void setup() { - neteeprom.Read(settings); - - // initialize serial and wait for port to open: + // Initialize serial and wait for port to open: Serial.begin(9600); - while(!Serial) { - ; // wait for serial port to connect. Needed for Leonardo only - } - Serial.println(); - - if(neteeprom.SigIsSet()) { - uint8_t i; - - for(i = 0; i < EEPROM_SETTINGS_SIZE; i++) { - if(i == 0) - Serial.print("Gateway: "); - else if(i == 4) { - Serial.println(); - Serial.print(" Subnet: "); - } - else if(i == 8) { - Serial.println(); - Serial.print(" MAC: "); - } - else if(i == 14) { - Serial.println(); - Serial.print("Address: "); - } - else Serial.print("."); - - if (i >= 8 && i < 14) { - Serial.print("0x"); - Serial.print(settings[i], HEX); - } else Serial.print(settings[i]); - } - } else { - Serial.print("Using built in settings"); - } - + /* Wait for serial port to connect. Needed for Leonardo only + * but breaks compilation on Arduino 1.0. Leonardo is not + * supported by the bootloader yet */ + //while(!Serial) { + // ; + //} + + /* Print the network settings to serial. Baud rate is 9600 */ + NetEEPROM.print(); + /* If you want to invalidate the image after first run, uncomment this + * Because Duemilanove doesn't have auto-reset, don't uncomment this or + * you will invalidate the image before you open the serial console */ + //neteeprom.WriteImgBad(); pinMode(ledpin, OUTPUT); - // Timeout and reset after 4 seconds - wdt_enable(WDTO_4S); } - void loop() { - // Blink an LED on pin defined above rapidly if present - // to indicate the settings have been stored in EEPROM. + /* Blink an LED on pin defined above rapidly if present + * to indicate the settings have been read in EEPROM. */ digitalWrite(ledpin, HIGH); delay(500); digitalWrite(ledpin, LOW); diff --git a/libraries/NetEEPROM/examples/WriteNetworkSettings/WriteNetworkSettings.ino b/libraries/NetEEPROM/examples/WriteNetworkSettings/WriteNetworkSettings.ino index 258312a..9f3d812 100644 --- a/libraries/NetEEPROM/examples/WriteNetworkSettings/WriteNetworkSettings.ino +++ b/libraries/NetEEPROM/examples/WriteNetworkSettings/WriteNetworkSettings.ino @@ -13,7 +13,7 @@ * Arduino device IP address Once the settings have been written to EEPROM, an LED on pin 9 - (if connected) will flash rapdily. + (if connected) will flash rapdily. The arduino will reset after 4 seconds The default settings used by the bootloader: @@ -33,41 +33,51 @@ */ #include -#include #include #include -// TODO: Allow settings to be specified as individual variables. -// TODO: Wrap this all in a library. - -NetEEPROM neteeprom; -uint8_t settings[EEPROM_SETTINGS_SIZE] = { - 192,168,1,254, // Gateway IP address +//uint8_t ip[] = {192,168,1,20}; +//uint8_t subnet[] = {255,255,255,0}; +//uint8_t gateway[] = {192,168,1,1}; +//uint8_t mac[] = {0x12,0x34,0x45,0x78,0x9A,0xBC}; +uint8_t settings[NETWORK_SETTINGS_SIZE] = { + 192,168,1,1, // Gateway IP address 255,255,255,0, // Subnet mask 0x12,0x34,0x45,0x78,0x9A,0xBC, // MAC address 192,168,1,20, // Arduino device IP address }; +/* Because of limitations in the bootloader, if you set the network settings you have + * to set the pseudo-random port for the tftp data transfer. If you have more than one arduinos + * with ethernet behind your router that you want to program from outside your local + * network you need a unique value for each one value. The initial negotiation of tftp still + * happens at port [69]. You will also need to forwards these ports from your router. + * The value set below is the built-in default [46969]. */ +uint16_t port = 46969; + -// Preset for Arduino Uno with ethernet shield -// For Arduino Ethernet set this to 9 +/* Preset for Arduino Uno with Ethernet shield. + * For Arduino Ethernet set this to 9 */ int ledpin = 13; void setup() { - neteeprom.WriteSig(); - neteeprom.WriteImgBad(); - neteeprom.Write(settings); + /* Write the new settings values to EEPROM */ + NetEEPROM.writeNet(settings, port); + /* Or this way if you prefer it */ + //NetEEPROM.writeNet(ip, subnet, gateway, mac, port); + /* Set image status to bad, so upon reboot, the bootloader won't time out */ + NetEEPROM.writeImgBad(); pinMode(ledpin, OUTPUT); - // Timeout and reset after 4 seconds + /* Timeout and reset after 4 seconds */ wdt_enable(WDTO_4S); } void loop() { - // Blink an LED on pin defined above rapidly if present - // to indicate the settings have been stored in EEPROM. + /* Blink an LED on pin defined above rapidly if present + * to indicate the settings have been stored in EEPROM. */ digitalWrite(ledpin, HIGH); delay(500); digitalWrite(ledpin, LOW); diff --git a/libraries/NetEEPROM/keywords.txt b/libraries/NetEEPROM/keywords.txt new file mode 100644 index 0000000..109fd5c --- /dev/null +++ b/libraries/NetEEPROM/keywords.txt @@ -0,0 +1,10 @@ +NETWORK_SETTINGS_SIZE LITERAL1 +NetEEPROM KEYWORD1 +eraseSig KEYWORD2 +sigIsSet KEYWORD2 +writeImgBad KEYWORD2 +writeImgOk KEYWORD2 +writeNet KEYWORD2 +printNet KEYWORD2 +readNet KEYWORD2 +print KEYWORD2 \ No newline at end of file diff --git a/hardware/tftpboot/bootloaders/tftpboot/utils/SConstruct b/utilities/SConstruct similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/utils/SConstruct rename to utilities/SConstruct diff --git a/hardware/tftpboot/bootloaders/tftpboot/utils/callgraph.ps b/utilities/callgraph.ps similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/utils/callgraph.ps rename to utilities/callgraph.ps diff --git a/hardware/tftpboot/bootloaders/tftpboot/utils/net-setup.sh b/utilities/net-setup.sh similarity index 99% rename from hardware/tftpboot/bootloaders/tftpboot/utils/net-setup.sh rename to utilities/net-setup.sh index b099c93..bd2d7c0 100755 --- a/hardware/tftpboot/bootloaders/tftpboot/utils/net-setup.sh +++ b/utilities/net-setup.sh @@ -8,7 +8,7 @@ then sudo ifconfig ${eth_dev} down sudo ifconfig ${eth_dev} ${eth_ip} netmask 255.255.255.0 sudo route add ${ard_ip} gw ${eth_ip} dev ${eth_dev} - + echo "Network settings have been set" sleep 2 ping -c4 ${ard_ip} diff --git a/hardware/tftpboot/bootloaders/tftpboot/tests/blink/blink.bin b/utilities/tests/blink/blink.bin similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/tests/blink/blink.bin rename to utilities/tests/blink/blink.bin diff --git a/hardware/tftpboot/bootloaders/tftpboot/tests/blink/blink.hex b/utilities/tests/blink/blink.hex similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/tests/blink/blink.hex rename to utilities/tests/blink/blink.hex diff --git a/hardware/tftpboot/bootloaders/tftpboot/tests/fade/bigapp.bin b/utilities/tests/fade/bigapp.bin old mode 100755 new mode 100644 similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/tests/fade/bigapp.bin rename to utilities/tests/fade/bigapp.bin diff --git a/hardware/tftpboot/bootloaders/tftpboot/tests/led_display/led_display.bin b/utilities/tests/led_display/led_display.bin similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/tests/led_display/led_display.bin rename to utilities/tests/led_display/led_display.bin diff --git a/hardware/tftpboot/bootloaders/tftpboot/tests/led_display/led_display.hex b/utilities/tests/led_display/led_display.hex similarity index 100% rename from hardware/tftpboot/bootloaders/tftpboot/tests/led_display/led_display.hex rename to utilities/tests/led_display/led_display.hex