PDITarget.c 8.74 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/*
             LUFA Library
     Copyright (C) Dean Camera, 2009.
              
  dean [at] fourwalledcubicle [dot] com
      www.fourwalledcubicle.com
*/

/*
  Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)

  Permission to use, copy, modify, and distribute this software
  and its documentation for any purpose and without fee is hereby
  granted, provided that the above copyright notice appear in all
  copies and that both that the copyright notice and this
  permission notice and warranty disclaimer appear in supporting
  documentation, and that the name of the author not be used in
  advertising or publicity pertaining to distribution of the
  software without specific, written prior permission.

  The author disclaim all warranties with regard to this
  software, including all implied warranties of merchantability
  and fitness.  In no event shall the author be liable for any
  special, indirect or consequential damages or any damages
  whatsoever resulting from loss of use, data or profits, whether
  in an action of contract, negligence or other tortious action,
  arising out of or in connection with the use or performance of
  this software.
*/

/** \file
 *
 *  Target-related functions for the PDI Protocol decoder.
 */

#define  INCLUDE_FROM_PDITARGET_C
#include "PDITarget.h"

39
40
#if defined(ENABLE_PDI_PROTOCOL) || defined(__DOXYGEN__)

41
/** Flag to indicate if the USART is currently in Tx or Rx mode. */
42
volatile bool     IsSending;
43
44

#if !defined(PDI_VIA_HARDWARE_USART)
45
/** Software USART raw frame bits for transmission/reception. */
46
volatile uint16_t SoftUSART_Data;
47
48

/** Bits remaining to be sent or received via the software USART. */
49
volatile uint8_t  SoftUSART_BitCount;
50

51
52

/** ISR to manage the software USART when bit-banged USART mode is selected. */
53
ISR(TIMER1_COMPA_vect, ISR_BLOCK)
54
{
55
56
	/* Toggle CLOCK pin in a single cycle (see AVR datasheet) */
	BITBANG_PDICLOCK_PIN |= BITBANG_PDICLOCK_MASK;
57

58
	/* If not sending or receiving, just exit */
59
	if (!(SoftUSART_BitCount))
60
	  return;
61

62
63
64
65
	/* Check to see if the current clock state is on the rising or falling edge */
	bool IsRisingEdge = (BITBANG_PDICLOCK_PORT & BITBANG_PDICLOCK_MASK);

	if (IsSending && !IsRisingEdge)
66
	{
67
68
		if (SoftUSART_Data & 0x01)
		  BITBANG_PDIDATA_PORT |=  BITBANG_PDIDATA_MASK;
69
		else
70
		  BITBANG_PDIDATA_PORT &= ~BITBANG_PDIDATA_MASK;		  
71

72
73
		SoftUSART_Data >>= 1;
		SoftUSART_BitCount--;
74
	}
75
76
77
	else if (!IsSending && IsRisingEdge)
	{
		/* Wait for the start bit when receiving */
78
		if ((SoftUSART_BitCount == BITS_IN_FRAME) && (BITBANG_PDIDATA_PIN & BITBANG_PDIDATA_MASK))
79
80
		  return;
	
81
82
		if (BITBANG_PDIDATA_PIN & BITBANG_PDIDATA_MASK)
		  SoftUSART_Data |= (1 << BITS_IN_FRAME);
83

84
85
		SoftUSART_Data >>= 1;
		SoftUSART_BitCount--;
86
87
	}
}
88
#endif
89

90
/** Enables the target's PDI interface, holding the target in reset until PDI mode is exited. */
91
92
void PDITarget_EnableTargetPDI(void)
{
93
#if defined(PDI_VIA_HARDWARE_USART)
94
95
96
	/* Set Tx and XCK as outputs, Rx as input */
	DDRD |=  (1 << 5) | (1 << 3);
	DDRD &= ~(1 << 2);
97
	
98
	/* Set DATA line high for at least 90ns to disable /RESET functionality */
99
100
101
	PORTD |= (1 << 3);
	asm volatile ("NOP"::);
	asm volatile ("NOP"::);
102
	
103
104
105
	/* Set up the synchronous USART for XMEGA communications - 
	   8 data bits, even parity, 2 stop bits */
	UBRR1  = 10;
106
	UCSR1B = (1 << TXEN1);
107
108
	UCSR1C = (1 << UMSEL10) | (1 << UPM11) | (1 << USBS1) | (1 << UCSZ11) | (1 << UCSZ10) | (1 << UCPOL1);

109
	/* Send two BREAKs of 12 bits each to enable PDI interface (need at least 16 idle bits) */
110
111
	PDITarget_SendBreak();
	PDITarget_SendBreak();
112
113
114
115
116
117
118
119
120
121
#else
	/* Set DATA and CLOCK lines to outputs */
	BITBANG_PDIDATA_DDR  |= BITBANG_PDIDATA_MASK;
	BITBANG_PDICLOCK_DDR |= BITBANG_PDICLOCK_MASK;
	
	/* Set DATA line high for at least 90ns to disable /RESET functionality */
	BITBANG_PDIDATA_PORT |= BITBANG_PDIDATA_MASK;
	asm volatile ("NOP"::);
	asm volatile ("NOP"::);

122
123
124
125
	/* Fire timer compare ISR every 100 cycles to manage the software USART */
	OCR1A   = 100;
	TCCR1B  = (1 << WGM12) | (1 << CS10);
	TIMSK1  = (1 << OCIE1A);
126
127
128
129
	
	PDITarget_SendBreak();
	PDITarget_SendBreak();
#endif
130
131
}

132
/** Disables the target's PDI interface, exits programming mode and starts the target's application. */
133
134
void PDITarget_DisableTargetPDI(void)
{
135
#if defined(PDI_VIA_HARDWARE_USART)
136
137
138
139
	/* Turn off receiver and transmitter of the USART, clear settings */
	UCSR1A |= (1 << TXC1) | (1 << RXC1);
	UCSR1B  = 0;
	UCSR1C  = 0;
140
141

	/* Set all USART lines as input, tristate */
142
	DDRD  &= ~((1 << 5) | (1 << 3));
143
	PORTD &= ~((1 << 5) | (1 << 3) | (1 << 2));
144
145
146
147
148
149
150
151
152
153
154
#else
	/* Set DATA and CLOCK lines to inputs */
	BITBANG_PDIDATA_DDR   &= ~BITBANG_PDIDATA_MASK;
	BITBANG_PDICLOCK_DDR  &= ~BITBANG_PDICLOCK_MASK;
	
	/* Tristate DATA and CLOCK lines */
	BITBANG_PDIDATA_PORT  &= ~BITBANG_PDIDATA_MASK;
	BITBANG_PDICLOCK_PORT &= ~BITBANG_PDICLOCK_MASK;

	TCCR0B  = 0;
#endif
155
156
}

157
158
159
160
/** Sends a byte via the USART.
 *
 *  \param[in] Byte  Byte to send through the USART
 */
161
162
void PDITarget_SendByte(uint8_t Byte)
{
163
#if defined(PDI_VIA_HARDWARE_USART)
164
165
166
167
168
	/* Switch to Tx mode if currently in Rx mode */
	if (!(IsSending))
	{
		PORTD  |=  (1 << 3);
		DDRD   |=  (1 << 3);
169

170
171
172
173
174
175
176
177
		UCSR1B &= ~(1 << RXEN1);
		UCSR1B |=  (1 << TXEN1);
		
		IsSending = true;
	}
	
	/* Wait until there is space in the hardware Tx buffer before writing */
	while (!(UCSR1A & (1 << UDRE1)));
178
	UDR1 = Byte;
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
#else
	/* Switch to Tx mode if currently in Rx mode */
	if (!(IsSending))
	{
		BITBANG_PDIDATA_PORT |= BITBANG_PDIDATA_MASK;
		BITBANG_PDIDATA_DDR  |= BITBANG_PDIDATA_MASK;

		IsSending = true;
	}

	bool    EvenParityBit = false;
	uint8_t ParityData    = Byte;

	/* Compute Even parity bit */
	for (uint8_t i = 0; i < 8; i++)
	{
		EvenParityBit ^= ParityData & 0x01;
		ParityData    >>= 1;
	}

	while (SoftUSART_BitCount);

	/* Data shifted out LSB first, START DATA PARITY STOP STOP */
	SoftUSART_Data     = ((uint16_t)EvenParityBit << 9) | ((uint16_t)Byte << 1) | (1 << 10) | (1 << 11);
	SoftUSART_BitCount = BITS_IN_FRAME;
#endif
205
206
}

207
208
209
210
/** Receives a byte via the software USART, blocking until data is received.
 *
 *  \return Received byte from the USART
 */
211
212
uint8_t PDITarget_ReceiveByte(void)
{
213
#if defined(PDI_VIA_HARDWARE_USART)
214
215
216
217
218
	/* Switch to Rx mode if currently in Tx mode */
	if (IsSending)
	{
		while (!(UCSR1A & (1 << TXC1)));
		UCSR1A |=  (1 << TXC1);
219

220
221
222
223
224
225
226
227
228
229
		UCSR1B &= ~(1 << TXEN1);
		UCSR1B |=  (1 << RXEN1);

		DDRD   &= ~(1 << 3);
		PORTD  &= ~(1 << 3);
		
		IsSending = false;
	}

	/* Wait until a byte has been received before reading */
230
231
	while (!(UCSR1A & (1 << RXC1)));
	return UDR1;
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
#else
	/* Switch to Rx mode if currently in Tx mode */
	if (IsSending)
	{
		while (SoftUSART_BitCount);

		BITBANG_PDIDATA_DDR  &= ~BITBANG_PDIDATA_MASK;
		BITBANG_PDIDATA_PORT &= ~BITBANG_PDIDATA_MASK;

		IsSending = false;
	}

	/* Wait until a byte has been received before reading */
	SoftUSART_BitCount = BITS_IN_FRAME;
	while (SoftUSART_BitCount);
	
	/* Throw away the start, parity and stop bits to leave only the data */
	return (uint8_t)(SoftUSART_Data >> 1);
#endif
251
252
}

253
/** Sends a BREAK via the USART to the attached target, consisting of a full frame of idle bits. */
254
255
void PDITarget_SendBreak(void)
{
256
#if defined(PDI_VIA_HARDWARE_USART)
257
258
259
260
261
262
263
264
265
266
267
	/* Switch to Tx mode if currently in Rx mode */
	if (!(IsSending))
	{
		PORTD  |=  (1 << 3);
		DDRD   |=  (1 << 3);

		UCSR1B &= ~(1 << RXEN1);
		UCSR1B |=  (1 << TXEN1);
		
		IsSending = true;
	}
268

269
	/* Need to do nothing for a full frame to send a BREAK */
270
	for (uint8_t i = 0; i <= BITS_IN_FRAME; i++)
271
	{
272
		/* Wait for a full cycle of the clock */
273
274
275
		while (PIND & (1 << 5));
		while (!(PIND & (1 << 5)));
	}
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
#else
	/* Switch to Tx mode if currently in Rx mode */
	if (!(IsSending))
	{
		BITBANG_PDIDATA_PORT |= BITBANG_PDIDATA_MASK;
		BITBANG_PDIDATA_DDR  |= BITBANG_PDIDATA_MASK;

		IsSending = true;
	}
	
	while (SoftUSART_BitCount);

	/* Need to do nothing for a full frame to send a BREAK */
	SoftUSART_Data     = 0x0FFF;
	SoftUSART_BitCount = BITS_IN_FRAME;
291
#endif
292
293
}

294
295
296
297
298
/** Busy-waits while the NVM controller is busy performing a NVM operation, such as a FLASH page read or CRC
 *  calculation.
 *
 *  \return Boolean true if the NVM controller became ready within the timeout period, false otherwise
 */
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
bool PDITarget_WaitWhileNVMBusBusy(void)
{
	TCNT0 = 0;

	/* Poll the STATUS register to check to see if NVM access has been enabled */
	while (TCNT0 < PDI_NVM_TIMEOUT_MS)
	{
		/* Send the LDCS command to read the PDI STATUS register to see the NVM bus is active */
		PDITarget_SendByte(PDI_CMD_LDCS | PDI_STATUS_REG);
		if (PDITarget_ReceiveByte() & PDI_STATUS_NVM)
		  return true;
	}
	
	return false;
}

315
#endif