V2Protocol_Init();
LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
- GlobalInterruptEnable();
-
+ sei();
+
for (;;)
{
#if (BOARD == BOARD_USBTINYMKII)
- /* On the USBTINY-MKII board target, there is a secondary LED which indicates the current selected
- power mode - either VBUS, or sourced from the VTARGET pin of the programming connectors */
- LEDs_ChangeLEDs(LEDS_LED3, (PIND & (1 << 0)) ? 0 : LEDS_LED3);
+ /* On the USBTINY-MKII target, there is a secondary LED which indicates the current selected power
+ mode - either VBUS, or sourced from the VTARGET pin of the programming connectors */
+ LEDs_ChangeLEDs(LEDMASK_VBUSPOWER, (PIND & (1 << 0)) ? 0 : LEDMASK_VBUSPOWER);
#endif
AVRISP_Task();
/** Configures the board hardware and chip peripherals for the demo's functionality. */
void SetupHardware(void)
{
- #if (ARCH == ARCH_AVR8)
- /* Disable watchdog if enabled by bootloader/fuses */
- MCUSR &= ~(1 << WDRF);
- wdt_disable();
-
- /* Disable clock division */
- clock_prescale_set(clock_div_1);
- #elif (ARCH == ARCH_UC3)
- /* Select slow startup, external high frequency crystal attached to OSC0 */
- AVR32_PM.OSCCTRL0.mode = 7;
- AVR32_PM.OSCCTRL0.startup = 6;
- AVR32_PM.MCCTRL.osc0en = true;
- while (!(AVR32_PM.POSCSR.osc0rdy));
-
- /* Switch CPU core to use OSC0 as the system clock */
- AVR32_PM.MCCTRL.mcsel = 1;
-
- /* Start PLL1 to feed into the USB generic clock module */
- AVR32_PM.PLL[1].pllmul = (F_USB / F_CPU) ? (((F_USB / F_CPU) - 1) / 2) : 0;
- AVR32_PM.PLL[1].plldiv = 0;
- AVR32_PM.PLL[1].pllosc = 0;
- AVR32_PM.PLL[1].pllen = true;
- while (!(AVR32_PM.POSCSR.lock1));
-
- /* Configure interrupt management peripheral */
-// INTC_Init();
- INTC_RegisterGroupHandler(AVR32_USBB_IRQ, AVR32_INTC_INT0, USB_GEN_vect);
- #endif
-
+ /* Disable watchdog if enabled by bootloader/fuses */
+ MCUSR &= ~(1 << WDRF);
+ wdt_disable();
+
+ /* Disable clock division */
+ clock_prescale_set(clock_div_1);
+
/* Hardware Initialization */
LEDs_Init();
USB_Init();
#define _AVRISP_H_
/* Includes: */
- #include <LUFA/Common/Common.h>
+ #include <avr/io.h>
+ #include <avr/wdt.h>
+ #include <avr/interrupt.h>
+ #include <avr/power.h>
+
#include <LUFA/Version.h>
#include <LUFA/Drivers/Board/LEDs.h>
#include <LUFA/Drivers/USB/USB.h>
#include <LUFA/Drivers/Peripheral/ADC.h>
#endif
- #if (ARCH == ARCH_AVR8)
- #include <avr/io.h>
- #include <avr/wdt.h>
- #include <avr/interrupt.h>
- #include <avr/power.h>
- #elif (ARCH == ARCH_UC3)
- #include <avr32/io.h>
-
- #include <LUFA/Platform/UC3/INTC_UC3.h> // TODO: FIXME
- #endif
-
#include "Descriptors.h"
#include "Lib/V2Protocol.h"
/** LED mask for the library LED driver, to indicate that the USB interface is busy. */
#define LEDMASK_BUSY (LEDS_LED1 | LEDS_LED2)
+ /** LED mask for the library LED driver, to indicate that the target is being powered by VBUS. */
+ #define LEDMASK_VBUSPOWER LEDS_LED3
+
/* Function Prototypes: */
void SetupHardware(void);
void AVRISP_Task(void);
.Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE,
- .VendorID = CPU_TO_LE16(0x03EB),
- .ProductID = CPU_TO_LE16(0x2104),
+ .VendorID = 0x03EB,
+ .ProductID = 0x2104,
.ReleaseNumber = VERSION_BCD(02.00),
.ManufacturerStrIndex = 0x01,
{
.Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
- .TotalConfigurationSize = CPU_TO_LE16(sizeof(USB_Descriptor_Configuration_t)),
+ .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
.TotalInterfaces = 1,
.ConfigurationNumber = 1,
.EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_IN | AVRISP_DATA_IN_EPNUM),
.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
- .EndpointSize = CPU_TO_LE16(AVRISP_DATA_EPSIZE),
+ .EndpointSize = AVRISP_DATA_EPSIZE,
.PollingIntervalMS = 0x0A
},
.EndpointAddress = (ENDPOINT_DESCRIPTOR_DIR_OUT | AVRISP_DATA_OUT_EPNUM),
.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
- .EndpointSize = CPU_TO_LE16(AVRISP_DATA_EPSIZE),
+ .EndpointSize = AVRISP_DATA_EPSIZE,
.PollingIntervalMS = 0x0A
},
};
{
.Header = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},
- .UnicodeString = {CPU_TO_LE16('D'),
- CPU_TO_LE16('e'),
- CPU_TO_LE16('a'),
- CPU_TO_LE16('n'),
- CPU_TO_LE16(' '),
- CPU_TO_LE16('C'),
- CPU_TO_LE16('a'),
- CPU_TO_LE16('m'),
- CPU_TO_LE16('e'),
- CPU_TO_LE16('r'),
- CPU_TO_LE16('a')}
+ .UnicodeString = L"Dean Camera"
};
/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,
{
.Header = {.Size = USB_STRING_LEN(22), .Type = DTYPE_String},
- .UnicodeString = {CPU_TO_LE16('L'),
- CPU_TO_LE16('U'),
- CPU_TO_LE16('F'),
- CPU_TO_LE16('A'),
- CPU_TO_LE16(' '),
- CPU_TO_LE16('A'),
- CPU_TO_LE16('V'),
- CPU_TO_LE16('R'),
- CPU_TO_LE16('I'),
- CPU_TO_LE16('S'),
- CPU_TO_LE16('P'),
- CPU_TO_LE16(' '),
- CPU_TO_LE16('M'),
- CPU_TO_LE16('k'),
- CPU_TO_LE16('I'),
- CPU_TO_LE16('I'),
- CPU_TO_LE16(' '),
- CPU_TO_LE16('C'),
- CPU_TO_LE16('l'),
- CPU_TO_LE16('o'),
- CPU_TO_LE16('n'),
- CPU_TO_LE16('e')}
+ .UnicodeString = L"LUFA AVRISP MkII Clone"
};
/** Serial number string. This is a Unicode string containing the device's unique serial number, expressed as a
{
.Header = {.Size = USB_STRING_LEN(13), .Type = DTYPE_String},
- .UnicodeString = {CPU_TO_LE16('0'),
- CPU_TO_LE16('0'),
- CPU_TO_LE16('0'),
- CPU_TO_LE16('0'),
- CPU_TO_LE16('A'),
- CPU_TO_LE16('0'),
- CPU_TO_LE16('0'),
- CPU_TO_LE16('1'),
- CPU_TO_LE16('2'),
- CPU_TO_LE16('8'),
- CPU_TO_LE16('2'),
- CPU_TO_LE16('5'),
- CPU_TO_LE16('5')}
+ .UnicodeString = L"0000A00128255"
};
/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
#define _DESCRIPTORS_H_
/* Includes: */
- #include <LUFA/Common/Common.h>
- #include <LUFA/Drivers/USB/USB.h>
+ #include <avr/pgmspace.h>
- #if (ARCH == ARCH_AVR8)
- #include <avr/pgmspace.h>
- #endif
+ #include <LUFA/Drivers/USB/USB.h>
/* Macros: */
- #if (ARCH == ARCH_UC3) // TODO: FIXME
- #define PROGMEM const
- #endif
-
#if !defined(LIBUSB_DRIVER_COMPAT)
/** Endpoint number of the AVRISP data OUT endpoint. */
#define AVRISP_DATA_OUT_EPNUM 2
USB_Descriptor_Interface_t AVRISP_Interface;
USB_Descriptor_Endpoint_t AVRISP_DataInEndpoint;
USB_Descriptor_Endpoint_t AVRISP_DataOutEndpoint;
- } ATTR_PACKED USB_Descriptor_Configuration_t;
+ } USB_Descriptor_Configuration_t;
/* Function Prototypes: */
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
uint8_t PollValue;
uint8_t PollIndex;
uint8_t EnterProgBytes[4];
- } ATTR_PACKED Enter_ISP_Params;
+ } Enter_ISP_Params;
Endpoint_Read_Stream_LE(&Enter_ISP_Params, sizeof(Enter_ISP_Params), NULL);
{
uint8_t PreDelayMS;
uint8_t PostDelayMS;
- } ATTR_PACKED Leave_ISP_Params;
+ } Leave_ISP_Params;
Endpoint_Read_Stream_LE(&Leave_ISP_Params, sizeof(Leave_ISP_Params), NULL);
uint8_t ProgrammingCommands[3];
uint8_t PollValue1;
uint8_t PollValue2;
- uint8_t ProgData[256]; // Note, the Jungo driver has a very short ACK timeout period, need to buffer the
- } ATTR_PACKED Write_Memory_Params; // whole page and ACK the packet as fast as possible to prevent it from aborting
+ uint8_t ProgData[256]; // Note, the Jungo driver has a very short ACK timeout period, need to buffer the
+ } Write_Memory_Params; // whole page and ACK the packet as fast as possible to prevent it from aborting
Endpoint_Read_Stream_LE(&Write_Memory_Params, (sizeof(Write_Memory_Params) -
sizeof(Write_Memory_Params.ProgData)), NULL);
- Write_Memory_Params.BytesToWrite = be16_to_cpu(Write_Memory_Params.BytesToWrite);
+ Write_Memory_Params.BytesToWrite = SwapEndian_16(Write_Memory_Params.BytesToWrite);
if (Write_Memory_Params.BytesToWrite > sizeof(Write_Memory_Params.ProgData))
{
{
uint16_t BytesToRead;
uint8_t ReadMemoryCommand;
- } ATTR_PACKED Read_Memory_Params;
+ } Read_Memory_Params;
Endpoint_Read_Stream_LE(&Read_Memory_Params, sizeof(Read_Memory_Params), NULL);
- Read_Memory_Params.BytesToRead = be16_to_cpu(Read_Memory_Params.BytesToRead);
+ Read_Memory_Params.BytesToRead = SwapEndian_16(Read_Memory_Params.BytesToRead);
Endpoint_ClearOUT();
Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
uint8_t EraseDelayMS;
uint8_t PollMethod;
uint8_t EraseCommandBytes[4];
- } ATTR_PACKED Erase_Chip_Params;
+ } Erase_Chip_Params;
Endpoint_Read_Stream_LE(&Erase_Chip_Params, sizeof(Erase_Chip_Params), NULL);
{
uint8_t RetByte;
uint8_t ReadCommandBytes[4];
- } ATTR_PACKED Read_FuseLockSigOSCCAL_Params;
+ } Read_FuseLockSigOSCCAL_Params;
Endpoint_Read_Stream_LE(&Read_FuseLockSigOSCCAL_Params, sizeof(Read_FuseLockSigOSCCAL_Params), NULL);
struct
{
uint8_t WriteCommandBytes[4];
- } ATTR_PACKED Write_FuseLockSig_Params;
+ } Write_FuseLockSig_Params;
Endpoint_Read_Stream_LE(&Write_FuseLockSig_Params, sizeof(Write_FuseLockSig_Params), NULL);
uint8_t RxBytes;
uint8_t RxStartAddr;
uint8_t TxData[255];
- } ATTR_PACKED SPI_Multi_Params;
+ } SPI_Multi_Params;
Endpoint_Read_Stream_LE(&SPI_Multi_Params, (sizeof(SPI_Multi_Params) - sizeof(SPI_Multi_Params.TxData)), NULL);
Endpoint_Read_Stream_LE(&SPI_Multi_Params.TxData, SPI_Multi_Params.TxBytes, NULL);
#define _ISP_PROTOCOL_
/* Includes: */
- #include <LUFA/Common/Common.h>
+ #include <avr/io.h>
+ #include <util/delay.h>
+
#include <LUFA/Drivers/USB/USB.h>
-
- #if (ARCH == ARCH_AVR8)
- #include <avr/io.h>
- #elif (ARCH == ARCH_UC3)
- #include <avr32/io.h>
- #endif
#include "../V2Protocol.h"
#define _ISP_TARGET_
/* Includes: */
- #include <LUFA/Common/Common.h>
+ #include <avr/io.h>
+ #include <avr/pgmspace.h>
+ #include <util/delay.h>
+
#include <LUFA/Drivers/USB/USB.h>
-
- #if defined(ENABLE_ISP_PROTOCOL) || defined(__DOXYGEN__)
- #include <LUFA/Drivers/Peripheral/SPI.h> // TODO: FIXME
- #endif
-
- #if (ARCH == ARCH_AVR8)
- #include <avr/io.h>
- #include <avr/pgmspace.h>
- #elif (ARCH == ARCH_UC3)
- #include <avr32/io.h>
- #endif
+ #include <LUFA/Drivers/Peripheral/SPI.h>
#include "../V2ProtocolParams.h"
const uint8_t ReadMemCommand);
/* Inline Functions: */
- #if defined(ENABLE_ISP_PROTOCOL) || defined(__DOXYGEN__)
/** Sends a byte of ISP data to the attached target, using the appropriate SPI hardware or
* software routines depending on the selected ISP speed.
*
else
return ISPTarget_TransferSoftSPIByte(Byte);
}
- #endif
#endif
/** Flag to indicate that the next read/write operation must update the device's current extended FLASH address */
bool MustLoadExtendedAddress;
-/** Command timeout expiration flag. */
-volatile bool TimeoutExpired;
-#if (ARCH == ARCH_AVR8) // TODO: FIXME
/** ISR to manage timeouts whilst processing a V2Protocol command */
ISR(WDT_vect, ISR_BLOCK)
{
TimeoutExpired = true;
wdt_disable();
}
-#endif
/** Initialises the hardware and software associated with the V2 protocol command handling. */
void V2Protocol_Init(void)
{
uint8_t V2Command = Endpoint_Read_8();
- #if (ARCH == ARCH_AVR8) // TODO: FIXME
/* Start the watchdog with timeout interrupt enabled to manage the timeout */
TimeoutExpired = false;
wdt_enable(WDTO_1S);
WDTCSR |= (1 << WDIE);
- #endif
switch (V2Command)
{
break;
}
- #if (ARCH == ARCH_AVR8) // TODO: FIXME
/* Disable the timeout management watchdog timer */
wdt_disable();
- #endif
Endpoint_WaitUntilReady();
Endpoint_SelectEndpoint(AVRISP_DATA_OUT_EPNUM);
#define _V2_PROTOCOL_
/* Includes: */
- #include <LUFA/Common/Common.h>
+ #include <avr/io.h>
+ #include <avr/interrupt.h>
+ #include <avr/wdt.h>
+
#include <LUFA/Drivers/USB/USB.h>
- #if (ARCH == ARCH_AVR8)
- #include <avr/io.h>
- #include <avr/interrupt.h>
- #include <avr/wdt.h>
- #elif (ARCH == ARCH_UC3)
- #include <avr32/io.h>
- #endif
-
#include "../Descriptors.h"
#include "V2ProtocolConstants.h"
#include "V2ProtocolParams.h"
/** Timeout period for each issued command from the host before it is aborted (in 10ms ticks). */
#define COMMAND_TIMEOUT_TICKS 100
+ /** Command timeout expiration flag, GPIOR for speed. */
+ #define TimeoutExpired GPIOR1
+
/** MUX mask for the VTARGET ADC channel number. */
#define VTARGET_ADC_CHANNEL_MASK ADC_GET_CHANNEL_MASK(VTARGET_ADC_CHANNEL)
/* External Variables: */
- extern uint32_t CurrentAddress;
- extern bool MustLoadExtendedAddress;
- extern volatile bool TimeoutExpired;
+ extern uint32_t CurrentAddress;
+ extern bool MustLoadExtendedAddress;
/* Function Prototypes: */
void V2Protocol_Init(void);
#define STATUS_CONN_FAIL_SCK 0x04
#define STATUS_TGT_NOT_DETECTED 0x10
#define STATUS_TGT_REVERSE_INSERTED 0x20
- #define STATUS_ANSWER_CKSUM_ERROR 0xB0
#define PARAM_BUILD_NUMBER_LOW 0x80
#define PARAM_BUILD_NUMBER_HIGH 0x81
#include "V2ProtocolParams.h"
/* Non-Volatile Parameter Values for EEPROM storage */
-static uint8_t EEMEM EEPROM_Reset_Polarity = 0x00;
+static uint8_t EEMEM EEPROM_Rest_Polarity = 0x00;
/* Volatile Parameter Values for RAM storage */
static ParameterItem_t ParameterTable[] =
void V2Params_LoadNonVolatileParamValues(void)
{
/* Target RESET line polarity is a non-volatile value, retrieve current parameter value from EEPROM */
- V2Params_GetParamFromTable(PARAM_RESET_POLARITY)->ParamValue = eeprom_read_byte(&EEPROM_Reset_Polarity);
+ V2Params_GetParamFromTable(PARAM_RESET_POLARITY)->ParamValue = eeprom_read_byte(&EEPROM_Rest_Polarity);
}
/** Updates any parameter values that are sourced from hardware rather than explicitly set by the host, such as
/* The target RESET line polarity is a non-volatile parameter, save to EEPROM when changed */
if (ParamID == PARAM_RESET_POLARITY)
- eeprom_update_byte(&EEPROM_Reset_Polarity, Value);
+ eeprom_update_byte(&EEPROM_Rest_Polarity, Value);
}
/** Retrieves a parameter entry (including ID, value and privileges) from the parameter table that matches the given
#define _V2_PROTOCOL_PARAMS_
/* Includes: */
- #include <LUFA/Common/Common.h>
+ #include <avr/io.h>
+ #include <avr/eeprom.h>
+
#include <LUFA/Version.h>
#if defined(ADC)
#include <LUFA/Drivers/Peripheral/ADC.h>
#endif
- #if (ARCH == ARCH_AVR8)
- #include <avr/io.h>
- #include <avr/eeprom.h>
- #elif (ARCH == ARCH_UC3)
- #include <avr32/io.h>
- #endif
-
#include "V2Protocol.h"
#include "V2ProtocolConstants.h"
#include "ISP/ISPTarget.h"
/** Total number of parameters in the parameter table */
#define TABLE_PARAM_COUNT (sizeof(ParameterTable) / sizeof(ParameterTable[0]))
-
- #if (ARCH == ARCH_UC3) // TODO: FIXME
- #define EEMEM
- #define eeprom_read_byte(x) *x
- #define eeprom_update_byte(x,y) *x=y
- #endif
/* Type Defines: */
/** Type define for a parameter table entry indicating a PC readable or writable device parameter. */
#define _TINY_NVM_
/* Includes: */
- #include <LUFA/Common/Common.h>
-
- #if (ARCH == ARCH_AVR8)
- #include <avr/io.h>
- #include <avr/interrupt.h>
- #elif (ARCH == ARCH_UC3)
- #include <avr32/io.h>
- #endif
-
+ #include <avr/io.h>
+ #include <avr/interrupt.h>
#include <stdbool.h>
+ #include <LUFA/Common/Common.h>
+
#include "XPROGProtocol.h"
#include "XPROGTarget.h"
#define _XMEGA_NVM_
/* Includes: */
- #include <LUFA/Common/Common.h>
-
- #if (ARCH == ARCH_AVR8)
- #include <avr/io.h>
- #include <avr/interrupt.h>
- #elif (ARCH == ARCH_UC3)
- #include <avr32/io.h>
- #endif
-
+ #include <avr/io.h>
+ #include <avr/interrupt.h>
#include <stdbool.h>
+ #include <LUFA/Common/Common.h>
+
#include "XPROGProtocol.h"
#include "XPROGTarget.h"
struct
{
uint8_t Protocol;
- } ATTR_PACKED SetMode_XPROG_Params;
+ } SetMode_XPROG_Params;
Endpoint_Read_Stream_LE(&SetMode_XPROG_Params, sizeof(SetMode_XPROG_Params), NULL);
{
uint8_t MemoryType;
uint32_t Address;
- } ATTR_PACKED Erase_XPROG_Params;
+ } Erase_XPROG_Params;
Endpoint_Read_Stream_LE(&Erase_XPROG_Params, sizeof(Erase_XPROG_Params), NULL);
- Erase_XPROG_Params.Address = be32_to_cpu(Erase_XPROG_Params.Address);
+ Erase_XPROG_Params.Address = SwapEndian_32(Erase_XPROG_Params.Address);
Endpoint_ClearOUT();
Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
uint32_t Address;
uint16_t Length;
uint8_t ProgData[256];
- } ATTR_PACKED WriteMemory_XPROG_Params;
+ } WriteMemory_XPROG_Params;
Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params, (sizeof(WriteMemory_XPROG_Params) -
sizeof(WriteMemory_XPROG_Params).ProgData), NULL);
- WriteMemory_XPROG_Params.Address = be32_to_cpu(WriteMemory_XPROG_Params.Address);
- WriteMemory_XPROG_Params.Length = be16_to_cpu(WriteMemory_XPROG_Params.Length);
+ WriteMemory_XPROG_Params.Address = SwapEndian_32(WriteMemory_XPROG_Params.Address);
+ WriteMemory_XPROG_Params.Length = SwapEndian_16(WriteMemory_XPROG_Params.Length);
Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length, NULL);
// The driver will terminate transfers that are a round multiple of the endpoint bank in size with a ZLP, need
uint8_t MemoryType;
uint32_t Address;
uint16_t Length;
- } ATTR_PACKED ReadMemory_XPROG_Params;
+ } ReadMemory_XPROG_Params;
Endpoint_Read_Stream_LE(&ReadMemory_XPROG_Params, sizeof(ReadMemory_XPROG_Params), NULL);
- ReadMemory_XPROG_Params.Address = be32_to_cpu(ReadMemory_XPROG_Params.Address);
- ReadMemory_XPROG_Params.Length = be16_to_cpu(ReadMemory_XPROG_Params.Length);
+ ReadMemory_XPROG_Params.Address = SwapEndian_32(ReadMemory_XPROG_Params.Address);
+ ReadMemory_XPROG_Params.Length = SwapEndian_16(ReadMemory_XPROG_Params.Length);
Endpoint_ClearOUT();
Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
struct
{
uint8_t CRCType;
- } ATTR_PACKED ReadCRC_XPROG_Params;
+ } ReadCRC_XPROG_Params;
Endpoint_Read_Stream_LE(&ReadCRC_XPROG_Params, sizeof(ReadCRC_XPROG_Params), NULL);
#define _XPROG_PROTOCOL_
/* Includes: */
- #include <LUFA/Common/Common.h>
- #include <LUFA/Drivers/USB/USB.h>
-
- #if (ARCH == ARCH_AVR8)
- #include <avr/io.h>
- #elif (ARCH == ARCH_UC3)
- #include <avr32/io.h>
- #endif
-
- #include <stdbool.h>
+ #include <avr/io.h>
+ #include <util/delay.h>
#include <stdio.h>
+ #include <LUFA/Drivers/USB/USB.h>
+
#include "../V2Protocol.h"
#include "XMEGANVM.h"
#include "TINYNVM.h"
{
IsSending = false;
- #if (ARCH == ARCH_AVR8)
- /* Set Tx and XCK as outputs, Rx as input */
- DDRD |= (1 << 5) | (1 << 3);
- DDRD &= ~(1 << 2);
-
- /* Set DATA line high for at least 90ns to disable /RESET functionality */
- PORTD |= (1 << 3);
- Delay_MS(1);
-
- /* Set up the synchronous USART for XMEGA communications - 8 data bits, even parity, 2 stop bits */
- UBRR1 = ((F_CPU / 2 / XPROG_HARDWARE_SPEED) - 1);
- UCSR1B = (1 << TXEN1);
- UCSR1C = (1 << UMSEL10) | (1 << UPM11) | (1 << USBS1) | (1 << UCSZ11) | (1 << UCSZ10) | (1 << UCPOL1);
- #elif (ARCH == ARCH_UC3)
- // TODO: FIXME
- #endif
+ /* Set Tx and XCK as outputs, Rx as input */
+ DDRD |= (1 << 5) | (1 << 3);
+ DDRD &= ~(1 << 2);
+
+ /* Set DATA line high for at least 90ns to disable /RESET functionality */
+ PORTD |= (1 << 3);
+ _delay_us(1);
+
+ /* Set up the synchronous USART for XMEGA communications - 8 data bits, even parity, 2 stop bits */
+ UBRR1 = ((F_CPU / 2 / XPROG_HARDWARE_SPEED) - 1);
+ UCSR1B = (1 << TXEN1);
+ UCSR1C = (1 << UMSEL10) | (1 << UPM11) | (1 << USBS1) | (1 << UCSZ11) | (1 << UCSZ10) | (1 << UCPOL1);
/* Send two IDLEs of 12 bits each to enable PDI interface (need at least 16 idle bits) */
XPROGTarget_SendIdle();
{
IsSending = false;
- #if (ARCH == ARCH_AVR8)
- /* Set /RESET line low for at least 400ns to enable TPI functionality */
- AUX_LINE_DDR |= AUX_LINE_MASK;
- AUX_LINE_PORT &= ~AUX_LINE_MASK;
- Delay_MS(1);
+ /* Set /RESET line low for at least 400ns to enable TPI functionality */
+ AUX_LINE_DDR |= AUX_LINE_MASK;
+ AUX_LINE_PORT &= ~AUX_LINE_MASK;
+ _delay_us(1);
- /* Set Tx and XCK as outputs, Rx as input */
- DDRD |= (1 << 5) | (1 << 3);
- DDRD &= ~(1 << 2);
+ /* Set Tx and XCK as outputs, Rx as input */
+ DDRD |= (1 << 5) | (1 << 3);
+ DDRD &= ~(1 << 2);
- /* Set up the synchronous USART for TINY communications - 8 data bits, even parity, 2 stop bits */
- UBRR1 = ((F_CPU / 2 / XPROG_HARDWARE_SPEED) - 1);
- UCSR1B = (1 << TXEN1);
- UCSR1C = (1 << UMSEL10) | (1 << UPM11) | (1 << USBS1) | (1 << UCSZ11) | (1 << UCSZ10) | (1 << UCPOL1);
- #elif (ARCH == ARCH_UC3)
- // TODO: FIXME
- #endif
+ /* Set up the synchronous USART for TINY communications - 8 data bits, even parity, 2 stop bits */
+ UBRR1 = ((F_CPU / 2 / XPROG_HARDWARE_SPEED) - 1);
+ UCSR1B = (1 << TXEN1);
+ UCSR1C = (1 << UMSEL10) | (1 << UPM11) | (1 << USBS1) | (1 << UCSZ11) | (1 << UCSZ10) | (1 << UCPOL1);
/* Send two IDLEs of 12 bits each to enable TPI interface (need at least 16 idle bits) */
XPROGTarget_SendIdle();
/* Switch to Rx mode to ensure that all pending transmissions are complete */
XPROGTarget_SetRxMode();
- #if (ARCH == ARCH_AVR8)
- /* Turn off receiver and transmitter of the USART, clear settings */
- UCSR1A = ((1 << TXC1) | (1 << RXC1));
- UCSR1B = 0;
- UCSR1C = 0;
-
- /* Tristate all pins */
- DDRD &= ~((1 << 5) | (1 << 3));
- PORTD &= ~((1 << 5) | (1 << 3) | (1 << 2));
- #elif (ARCH == ARCH_UC3)
- // TODO: FIXME
- #endif
+ /* Turn off receiver and transmitter of the USART, clear settings */
+ UCSR1A = ((1 << TXC1) | (1 << RXC1));
+ UCSR1B = 0;
+ UCSR1C = 0;
+
+ /* Tristate all pins */
+ DDRD &= ~((1 << 5) | (1 << 3));
+ PORTD &= ~((1 << 5) | (1 << 3) | (1 << 2));
}
/** Disables the target's TPI interface, exits programming mode and starts the target's application. */
/* Switch to Rx mode to ensure that all pending transmissions are complete */
XPROGTarget_SetRxMode();
- #if (ARCH == ARCH_AVR8)
- /* Turn off receiver and transmitter of the USART, clear settings */
- UCSR1A |= (1 << TXC1) | (1 << RXC1);
- UCSR1B = 0;
- UCSR1C = 0;
-
- /* Set all USART lines as inputs, tristate */
- DDRD &= ~((1 << 5) | (1 << 3));
- PORTD &= ~((1 << 5) | (1 << 3) | (1 << 2));
-
- /* Tristate target /RESET line */
- AUX_LINE_DDR &= ~AUX_LINE_MASK;
- AUX_LINE_PORT &= ~AUX_LINE_MASK;
- #elif (ARCH == ARCH_UC3)
- // TODO: FIXME
- #endif
+ /* Turn off receiver and transmitter of the USART, clear settings */
+ UCSR1A |= (1 << TXC1) | (1 << RXC1);
+ UCSR1B = 0;
+ UCSR1C = 0;
+
+ /* Set all USART lines as inputs, tristate */
+ DDRD &= ~((1 << 5) | (1 << 3));
+ PORTD &= ~((1 << 5) | (1 << 3) | (1 << 2));
+
+ /* Tristate target /RESET line */
+ AUX_LINE_DDR &= ~AUX_LINE_MASK;
+ AUX_LINE_PORT &= ~AUX_LINE_MASK;
}
/** Sends a byte via the USART.
if (!(IsSending))
XPROGTarget_SetTxMode();
- #if (ARCH == ARCH_AVR8)
- /* Wait until there is space in the hardware Tx buffer before writing */
- while (!(UCSR1A & (1 << UDRE1)));
- UCSR1A |= (1 << TXC1);
- UDR1 = Byte;
- #elif (ARCH == ARCH_UC3)
- // TODO: FIXME
- #endif
+ /* Wait until there is space in the hardware Tx buffer before writing */
+ while (!(UCSR1A & (1 << UDRE1)));
+ UCSR1A |= (1 << TXC1);
+ UDR1 = Byte;
}
/** Receives a byte via the software USART, blocking until data is received.
if (IsSending)
XPROGTarget_SetRxMode();
- #if (ARCH == ARCH_AVR8)
- /* Wait until a byte has been received before reading */
- while (!(UCSR1A & (1 << RXC1)) && !(TimeoutExpired));
+ /* Wait until a byte has been received before reading */
+ while (!(UCSR1A & (1 << RXC1)) && !(TimeoutExpired));
- return UDR1;
- #elif (ARCH == ARCH_UC3)
- // TODO: FIXME
- return 0;
- #endif
+ return UDR1;
}
/** Sends an IDLE via the USART to the attached target, consisting of a full frame of idle bits. */
if (!(IsSending))
XPROGTarget_SetTxMode();
- #if (ARCH == ARCH_AVR8)
- /* Need to do nothing for a full frame to send an IDLE */
- for (uint8_t i = 0; i < BITS_IN_USART_FRAME; i++)
- {
- /* Wait for a full cycle of the clock */
- while (PIND & (1 << 5));
- while (!(PIND & (1 << 5)));
- }
- #elif (ARCH == ARCH_UC3)
- // TODO: FIXME
- #endif
+ /* Need to do nothing for a full frame to send an IDLE */
+ for (uint8_t i = 0; i < BITS_IN_USART_FRAME; i++)
+ {
+ /* Wait for a full cycle of the clock */
+ while (PIND & (1 << 5));
+ while (!(PIND & (1 << 5)));
+ }
}
static void XPROGTarget_SetTxMode(void)
{
- #if (ARCH == ARCH_AVR8)
- /* Wait for a full cycle of the clock */
- while (PIND & (1 << 5));
- while (!(PIND & (1 << 5)));
+ /* Wait for a full cycle of the clock */
+ while (PIND & (1 << 5));
+ while (!(PIND & (1 << 5)));
- PORTD |= (1 << 3);
- DDRD |= (1 << 3);
+ PORTD |= (1 << 3);
+ DDRD |= (1 << 3);
- UCSR1B &= ~(1 << RXEN1);
- UCSR1B |= (1 << TXEN1);
- #elif (ARCH == ARCH_UC3)
- // TODO: FIXME
- #endif
+ UCSR1B &= ~(1 << RXEN1);
+ UCSR1B |= (1 << TXEN1);
IsSending = true;
}
static void XPROGTarget_SetRxMode(void)
{
- #if (ARCH == ARCH_AVR8)
- while (!(UCSR1A & (1 << TXC1)));
- UCSR1A |= (1 << TXC1);
-
- UCSR1B &= ~(1 << TXEN1);
- UCSR1B |= (1 << RXEN1);
-
- DDRD &= ~(1 << 3);
- PORTD &= ~(1 << 3);
- #elif (ARCH == ARCH_UC3)
- // TODO: FIXME
- #endif
+ while (!(UCSR1A & (1 << TXC1)));
+ UCSR1A |= (1 << TXC1);
+
+ UCSR1B &= ~(1 << TXEN1);
+ UCSR1B |= (1 << RXEN1);
+
+ DDRD &= ~(1 << 3);
+ PORTD &= ~(1 << 3);
IsSending = false;
}
#define _XPROG_TARGET_
/* Includes: */
- #include <LUFA/Common/Common.h>
+ #include <avr/io.h>
+ #include <avr/interrupt.h>
+ #include <stdbool.h>
- #if (ARCH == ARCH_AVR8)
- #include <avr/io.h>
- #include <avr/interrupt.h>
- #elif (ARCH == ARCH_UC3)
- #include <avr32/io.h>
- #endif
+ #include <LUFA/Common/Common.h>
#include "../V2Protocol.h"
#include "XPROGProtocol.h"
# Even though the DOS/Win* filesystem matches both .s and .S the same,
# it will preserve the spelling of the filenames, and gcc itself does
# care about how the name is spelled on its command-line.
-ASRC =
+ASRC =
# Optimization level, can be [0, 1, 2, 3, s].
projects / pub / lufa.git / commitdiff