eqmk
/
qmk_firmware
forked from mfulz_github/qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fixed AVRISP programmer demo -- can now connect to a target and read/write Sig/Lock/Fuse/OSCCAL bytes successfully. 

Changed SPI_Init() to allow for the clock polarity and data sample modes to be set.

Changed Dataflash_Init() to no longer call SPI_Init() automatically.
This commit is contained in:
Dean Camera 2009-08-23 08:37:11 +00:00
parent 1e8df8951a
commit f229502d9a
9 changed files with 58 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Demos/Device/ClassDriver/MassStorage/MassStorage.c
View File

@ -84,7 +84,8 @@ void SetupHardware(void)
/* Hardware Initialization */ /* Hardware Initialization */
LEDs_Init(); LEDs_Init();
Dataflash_Init(SPI_SPEED_FCPU_DIV_2); SPI_Init(SPI_SPEED_FCPU_DIV_2 | SPI_SCK_LEAD_FALLING | SPI_SAMPLE_TRAILING | SPI_MODE_MASTER);
Dataflash_Init();
USB_Init(); USB_Init();
/* Clear Dataflash sector protections, if enabled */ /* Clear Dataflash sector protections, if enabled */

3
Demos/Device/LowLevel/MassStorage/MassStorage.c
View File

@ -75,7 +75,8 @@ void SetupHardware(void)
/* Hardware Initialization */ /* Hardware Initialization */
LEDs_Init(); LEDs_Init();
Dataflash_Init(SPI_SPEED_FCPU_DIV_2); SPI_Init(SPI_SPEED_FCPU_DIV_2 | SPI_SCK_LEAD_FALLING | SPI_SAMPLE_TRAILING | SPI_MODE_MASTER);
Dataflash_Init();
USB_Init(); USB_Init();
/* Clear Dataflash sector protections, if enabled */ /* Clear Dataflash sector protections, if enabled */

10
LUFA/Drivers/Board/Dataflash.h
View File

@ -164,17 +164,13 @@
#endif #endif
/* Inline Functions: */ /* Inline Functions: */
/** Initializes the dataflash driver (including the SPI driver) so that commands and data may be /** Initializes the dataflash driver so that commands and data may be sent to an attached dataflash IC.
* sent to an attached dataflash IC. * The AVR's SPI driver MUST be initialized before any of the dataflash commands are used.
*
* \param[in] PrescalerMask SPI prescaler mask, see SPI.h documentation
*/ */
static inline void Dataflash_Init(const uint8_t PrescalerMask) static inline void Dataflash_Init(void)
{ {
DATAFLASH_CHIPCS_DDR |= DATAFLASH_CHIPCS_MASK; DATAFLASH_CHIPCS_DDR |= DATAFLASH_CHIPCS_MASK;
DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK; DATAFLASH_CHIPCS_PORT |= DATAFLASH_CHIPCS_MASK;
SPI_Init(PrescalerMask, true);
} }
/** Toggles the select line of the currently selected dataflash IC, so that it is ready to receive /** Toggles the select line of the currently selected dataflash IC, so that it is ready to receive

31
LUFA/Drivers/Peripheral/SPI.h
View File

@ -61,7 +61,7 @@
/* Private Interface - For use in library only: */ /* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__) #if !defined(__DOXYGEN__)
/* Macros: */ /* Macros: */
#define SPI_USE_DOUBLESPEED (1 << 7) #define SPI_USE_DOUBLESPEED (1 << SPE)
#endif #endif
/* Public Interface - May be used in end-application: */ /* Public Interface - May be used in end-application: */
@ -87,22 +87,39 @@
/** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 128. */ /** SPI prescaler mask for SPI_Init(). Divides the system clock by a factor of 128. */
#define SPI_SPEED_FCPU_DIV_128 ((1 << SPR1) | (1 << SPR0)) #define SPI_SPEED_FCPU_DIV_128 ((1 << SPR1) | (1 << SPR0))
/** SPI clock polarity mask for SPI_Init(). Indicates that the SCK should lead on the rising edge. */
#define SPI_SCK_LEAD_RISING (0 << CPOL)
/** SPI clock polarity mask for SPI_Init(). Indicates that the SCK should lead on the falling edge. */
#define SPI_SCK_LEAD_FALLING (1 << CPOL)
/** SPI data sample mode mask for SPI_Init(). Indicates that the data should sampled on the leading edge. */
#define SPI_SAMPLE_LEADING (0 << CPHA)
/** SPI data sample mode mask for SPI_Init(). Indicates that the data should be sampled on the trailing edge. */
#define SPI_SAMPLE_TRAILING (1 << CPHA)
/** SPI mode mask for SPI_Init(). Indicates that the SPI interface should be initialized into slave mode. */
#define SPI_MODE_SLAVE (0 << MSTR)
/** SPI mode mask for SPI_Init(). Indicates that the SPI interface should be initialized into master mode. */
#define SPI_MODE_MASTER (1 << MSTR)
/* Inline Functions: */ /* Inline Functions: */
/** Initializes the SPI subsystem, ready for transfers. Must be called before calling any other /** Initializes the SPI subsystem, ready for transfers. Must be called before calling any other
* SPI routines. * SPI routines.
* *
* \param[in] PrescalerMask Prescaler mask to set the SPI clock speed * \param[in] SPIOptions SPI Options, a mask consisting of one of each of the SPI_SPEED_*,
* \param[in] Master If true, sets the SPI system to use master mode, slave if false * SPI_SCK_*, SPI_SAMPLE_* and SPI_MODE_* masks
*/ */
static inline void SPI_Init(const uint8_t PrescalerMask, const bool Master) static inline void SPI_Init(const uint8_t SPIOptions)
{ {
DDRB |= ((1 << 1) | (1 << 2)); DDRB |= ((1 << 1) | (1 << 2));
PORTB |= ((1 << 0) | (1 << 3)); PORTB |= ((1 << 0) | (1 << 3));
SPCR = ((1 << SPE) | (Master << MSTR) | (1 << CPOL) | (1 << CPHA) | SPCR = ((1 << SPE) | SPIOptions);
(PrescalerMask & ~SPI_USE_DOUBLESPEED));
if (PrescalerMask & SPI_USE_DOUBLESPEED) if (SPIOptions & SPI_USE_DOUBLESPEED)
SPSR |= (1 << SPI2X); SPSR |= (1 << SPI2X);
else else
SPSR &= ~(1 << SPI2X); SPSR &= ~(1 << SPI2X);

1
LUFA/ManPages/ChangeLog.txt
View File

@ -23,6 +23,7 @@
* - Added new CDC_Device_Flush() command to the device mode CDC Class driver * - Added new CDC_Device_Flush() command to the device mode CDC Class driver
* - Added explicit attribute masks to the device mode demos' descriptors * - Added explicit attribute masks to the device mode demos' descriptors
* - Added return values to the CDC and MIDI class driver transmit functions * - Added return values to the CDC and MIDI class driver transmit functions
* - Added extra masks to the SPI driver, changed SPI_Init() so that the clock polarity and sample modes can be set
* *
* <b>Fixed:</b> * <b>Fixed:</b>
* - Fixed possible lockup in the CDC device class driver, when the host sends data that is a multiple of the * - Fixed possible lockup in the CDC device class driver, when the host sends data that is a multiple of the

4
LUFA/ManPages/MigrationInformation.txt
View File

@ -14,6 +14,10 @@
* *
* <b>Non-USB Library Components</b> * <b>Non-USB Library Components</b>
* - The ADC_Off() function has been renamed to \ref ADC_ShutDown() to be consistent with the rest of the library. * - The ADC_Off() function has been renamed to \ref ADC_ShutDown() to be consistent with the rest of the library.
* - The Dataflash_Init() routine no longer initializes the SPI bus - the SPI bus should be initialized manually via a
* call to SPI_Init() before using the Dataflash driver
* - The SPI_Init() routine's parameters have changed, so that the clock polarity and data sampling modes can be set. See
* the SPI_Init() function documentation for more details
* *
* \section Sec_Migration090810 Migrating from 090605 to 090810 * \section Sec_Migration090810 Migrating from 090605 to 090810
* *

49
Projects/Incomplete/AVRISP/Lib/V2Protocol.c
View File

@ -150,8 +150,6 @@ void V2Protocol_ProcessCommand(void)
break; break;
} }
printf("COMMAND 0x%02x\r\n", V2Command);
Endpoint_WaitUntilReady(); Endpoint_WaitUntilReady();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_OUT); Endpoint_SetEndpointDirection(ENDPOINT_DIR_OUT);
} }
@ -167,7 +165,6 @@ static void V2Protocol_Command_Unknown(uint8_t V2Command)
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
Endpoint_Write_Byte(V2Command); Endpoint_Write_Byte(V2Command);
Endpoint_Write_Byte(STATUS_CMD_UNKNOWN); Endpoint_Write_Byte(STATUS_CMD_UNKNOWN);
@ -178,7 +175,6 @@ static void V2Protocol_Command_SignOn(void)
{ {
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
Endpoint_Write_Byte(CMD_SIGN_ON); Endpoint_Write_Byte(CMD_SIGN_ON);
Endpoint_Write_Byte(STATUS_CMD_OK); Endpoint_Write_Byte(STATUS_CMD_OK);
@ -189,31 +185,28 @@ static void V2Protocol_Command_SignOn(void)
static void V2Protocol_Command_GetSetParam(uint8_t V2Command) static void V2Protocol_Command_GetSetParam(uint8_t V2Command)
{ {
struct uint8_t ParamID = Endpoint_Read_Byte();
{ uint8_t ParamValue;
uint8_t ParamID;
uint8_t ParamValue;
} Get_Set_Param_Params;
Endpoint_Read_Stream_LE(&Get_Set_Param_Params, sizeof(Get_Set_Param_Params)); if (V2Command == CMD_SET_PARAMETER)
ParamValue = Endpoint_Read_Byte();
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
uint8_t ParamPrivs = V2Params_GetParameterPrivellages(Get_Set_Param_Params.ParamID);
Endpoint_Write_Byte(V2Command); Endpoint_Write_Byte(V2Command);
uint8_t ParamPrivs = V2Params_GetParameterPrivellages(ParamID);
if ((V2Command == CMD_SET_PARAMETER) && (ParamPrivs & PARAM_PRIV_WRITE)) if ((V2Command == CMD_SET_PARAMETER) && (ParamPrivs & PARAM_PRIV_WRITE))
{ {
Endpoint_Write_Byte(STATUS_CMD_OK); Endpoint_Write_Byte(STATUS_CMD_OK);
V2Params_SetParameterValue(Get_Set_Param_Params.ParamID, Get_Set_Param_Params.ParamValue); V2Params_SetParameterValue(ParamID, ParamValue);
} }
else if ((V2Command == CMD_GET_PARAMETER) && (ParamPrivs & PARAM_PRIV_READ)) else if ((V2Command == CMD_GET_PARAMETER) && (ParamPrivs & PARAM_PRIV_READ))
{ {
Endpoint_Write_Byte(STATUS_CMD_OK); Endpoint_Write_Byte(STATUS_CMD_OK);
Endpoint_Write_Byte(V2Params_GetParameterValue(Get_Set_Param_Params.ParamID)); Endpoint_Write_Byte(V2Params_GetParameterValue(ParamID));
} }
else else
{ {
@ -229,7 +222,6 @@ static void V2Protocol_Command_LoadAddress(void)
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
// TODO: Check for extended address // TODO: Check for extended address
@ -256,21 +248,13 @@ static void V2Protocol_Command_EnterISPMode(void)
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
uint8_t SCKDuration = V2Params_GetParameterValue(PARAM_SCK_DURATION);
uint8_t ResponseStatus = STATUS_CMD_FAILED; uint8_t ResponseStatus = STATUS_CMD_FAILED;
Enter_ISP_Params.TimeoutMS -= Enter_ISP_Params.ExecutionDelayMS +
Enter_ISP_Params.PinStabDelayMS;
CurrentAddress = 0; CurrentAddress = 0;
if (SCKDuration >= sizeof(SPIMaskFromSCKDuration))
SCKDuration = (sizeof(SPIMaskFromSCKDuration) - 1);
V2Protocol_DelayMS(Enter_ISP_Params.ExecutionDelayMS); V2Protocol_DelayMS(Enter_ISP_Params.ExecutionDelayMS);
SPI_Init(SPIMaskFromSCKDuration[SCKDuration], true); SPI_Init(V2Protocol_GetSPIPrescalerMask() | SPI_SCK_LEAD_RISING | SPI_SAMPLE_LEADING | SPI_MODE_MASTER);
V2Protocol_ChangeTargetResetLine(true); V2Protocol_ChangeTargetResetLine(true);
V2Protocol_DelayMS(Enter_ISP_Params.PinStabDelayMS); V2Protocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);
@ -280,16 +264,12 @@ static void V2Protocol_Command_EnterISPMode(void)
for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++) for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
{ {
ResponseBytes[RByte] = SPI_TransferByte(Enter_ISP_Params.EnterProgBytes[RByte]);
V2Protocol_DelayMS(Enter_ISP_Params.ByteDelay); V2Protocol_DelayMS(Enter_ISP_Params.ByteDelay);
ResponseBytes[RByte] = SPI_TransferByte(Enter_ISP_Params.EnterProgBytes[RByte]);
if (Enter_ISP_Params.TimeoutMS >= Enter_ISP_Params.ByteDelay)
Enter_ISP_Params.TimeoutMS -= Enter_ISP_Params.ByteDelay;
else
ResponseStatus = STATUS_CMD_TOUT;
} }
if (ResponseBytes[Enter_ISP_Params.PollIndex] == Enter_ISP_Params.PollValue) /* Check if polling disabled, or if the polled value matches the expected value */
if (!Enter_ISP_Params.PollIndex || (ResponseBytes[Enter_ISP_Params.PollIndex - 1] == Enter_ISP_Params.PollValue))
ResponseStatus = STATUS_CMD_OK; ResponseStatus = STATUS_CMD_OK;
} }
@ -310,7 +290,6 @@ static void V2Protocol_Command_LeaveISPMode(void)
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
V2Protocol_DelayMS(Leave_ISP_Params.PreDelayMS); V2Protocol_DelayMS(Leave_ISP_Params.PreDelayMS);
V2Protocol_ChangeTargetResetLine(false); V2Protocol_ChangeTargetResetLine(false);
@ -335,7 +314,6 @@ static void V2Protocol_Command_ChipErase(void)
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
uint8_t ResponseStatus = STATUS_CMD_OK; uint8_t ResponseStatus = STATUS_CMD_OK;
@ -364,7 +342,6 @@ static void V2Protocol_Command_ReadFuseLockSigOSCCAL(uint8_t V2Command)
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
uint8_t ResponseBytes[4]; uint8_t ResponseBytes[4];
@ -389,7 +366,6 @@ static void V2Protocol_Command_WriteFuseLock(uint8_t V2Command)
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
for (uint8_t SByte = 0; SByte < sizeof(Write_FuseLockSig_Params.WriteCommandBytes); SByte++) for (uint8_t SByte = 0; SByte < sizeof(Write_FuseLockSig_Params.WriteCommandBytes); SByte++)
SPI_SendByte(Write_FuseLockSig_Params.WriteCommandBytes[SByte]); SPI_SendByte(Write_FuseLockSig_Params.WriteCommandBytes[SByte]);
@ -416,7 +392,6 @@ static void V2Protocol_Command_SPIMulti(void)
Endpoint_ClearOUT(); Endpoint_ClearOUT();
Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN); Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
Endpoint_WaitUntilReady();
Endpoint_Write_Byte(CMD_SPI_MULTI); Endpoint_Write_Byte(CMD_SPI_MULTI);
Endpoint_Write_Byte(STATUS_CMD_OK); Endpoint_Write_Byte(STATUS_CMD_OK);

6
Projects/Incomplete/AVRISP/Lib/V2ProtocolParams.c
View File

@ -51,7 +51,7 @@ static ParameterItem_t ParameterTable[] =
.ParamPrivellages = PARAM_PRIV_READ }, .ParamPrivellages = PARAM_PRIV_READ },
{ .ParamID = PARAM_HW_VER, { .ParamID = PARAM_HW_VER,
.ParamValue = 0x01, .ParamValue = 0x00,
.ParamPrivellages = PARAM_PRIV_READ }, .ParamPrivellages = PARAM_PRIV_READ },
{ .ParamID = PARAM_SW_MAJOR, { .ParamID = PARAM_SW_MAJOR,
@ -59,7 +59,7 @@ static ParameterItem_t ParameterTable[] =
.ParamPrivellages = PARAM_PRIV_READ }, .ParamPrivellages = PARAM_PRIV_READ },
{ .ParamID = PARAM_SW_MINOR, { .ParamID = PARAM_SW_MINOR,
.ParamValue = 0x00, .ParamValue = 0x0C,
.ParamPrivellages = PARAM_PRIV_READ }, .ParamPrivellages = PARAM_PRIV_READ },
{ .ParamID = PARAM_VTARGET, { .ParamID = PARAM_VTARGET,
@ -67,7 +67,7 @@ static ParameterItem_t ParameterTable[] =
.ParamPrivellages = PARAM_PRIV_READ }, .ParamPrivellages = PARAM_PRIV_READ },
{ .ParamID = PARAM_SCK_DURATION, { .ParamID = PARAM_SCK_DURATION,
.ParamValue = 0, .ParamValue = 0xFF,
.ParamPrivellages = PARAM_PRIV_READ | PARAM_PRIV_WRITE }, .ParamPrivellages = PARAM_PRIV_READ | PARAM_PRIV_WRITE },
{ .ParamID = PARAM_RESET_POLARITY, { .ParamID = PARAM_RESET_POLARITY,

8
Projects/Incomplete/AVRISP/makefile
View File

@ -60,7 +60,7 @@
# MCU name # MCU name
MCU = at90usb1287 MCU = at90usb647
# Target board (see library "Board Types" documentation, USER or blank for projects not requiring # Target board (see library "Board Types" documentation, USER or blank for projects not requiring
@ -194,9 +194,9 @@ CSTANDARD = -std=gnu99
# Place -D or -U options here for C sources # Place -D or -U options here for C sources
CDEFS = -DF_CPU=$(F_CPU)UL -DF_CLOCK=$(F_CLOCK)UL -DBOARD=BOARD_$(BOARD) $(LUFA_OPTS) CDEFS = -DF_CPU=$(F_CPU)UL -DF_CLOCK=$(F_CLOCK)UL -DBOARD=BOARD_$(BOARD) $(LUFA_OPTS)
CDEFS += -DRESET_LINE_PORT=PORTA CDEFS += -DRESET_LINE_PORT=PORTB
CDEFS += -DRESET_LINE_DDR=DDRA CDEFS += -DRESET_LINE_DDR=DDRB
CDEFS += -DRESET_LINE_MASK="(1 << 0)" CDEFS += -DRESET_LINE_MASK="(1 << 4)"
# Place -D or -U options here for ASM sources # Place -D or -U options here for ASM sources