V2Protocol.c 19.1 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
/*
             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
 *
 *  V2Protocol handler, to process V2 Protocol commands used in Atmel programmer devices.
 */

36
#define  INCLUDE_FROM_V2PROTOCOL_C
37
#include "V2Protocol.h"
38

39
/** Master V2 Protocol packet handler, for received V2 Protocol packets from a connected host.
40
41
42
 *  This routine decodes the issued command and passes off the handling of the command to the
 *  appropriate function.
 */
43
44
void V2Protocol_ProcessCommand(void)
{
45
	uint8_t V2Command = Endpoint_Read_Byte();
46
		  
47
48
49
	switch (V2Command)
	{
		case CMD_SIGN_ON:
50
			V2Protocol_SignOn();
51
52
53
			break;
		case CMD_SET_PARAMETER:
		case CMD_GET_PARAMETER:
54
			V2Protocol_GetSetParam(V2Command);
55
			break;
56
		case CMD_LOAD_ADDRESS:
57
			V2Protocol_LoadAddress();
58
			break;
59
		case CMD_RESET_PROTECTION:
60
			V2Protocol_ResetProtection();
61
			break;
62
		case CMD_ENTER_PROGMODE_ISP:
63
			V2Protocol_ISP_EnterISPMode();
64
65
			break;
		case CMD_LEAVE_PROGMODE_ISP:
66
			V2Protocol_ISP_LeaveISPMode();
67
			break;
68
69
		case CMD_PROGRAM_FLASH_ISP:
		case CMD_PROGRAM_EEPROM_ISP:
70
			V2Protocol_ISP_ProgramMemory(V2Command);			
71
72
73
			break;
		case CMD_READ_FLASH_ISP:
		case CMD_READ_EEPROM_ISP:
74
			V2Protocol_ISP_ReadMemory(V2Command);
75
			break;
76
		case CMD_CHIP_ERASE_ISP:
77
			V2Protocol_ISP_ChipErase();
78
79
80
81
82
			break;
		case CMD_READ_FUSE_ISP:
		case CMD_READ_LOCK_ISP:
		case CMD_READ_SIGNATURE_ISP:
		case CMD_READ_OSCCAL_ISP:
83
			V2Protocol_ISP_ReadFuseLockSigOSCCAL(V2Command);
84
85
86
			break;
		case CMD_PROGRAM_FUSE_ISP:
		case CMD_PROGRAM_LOCK_ISP:
87
			V2Protocol_ISP_WriteFuseLock(V2Command);
88
			break;
89
		case CMD_SPI_MULTI:
90
			V2Protocol_ISP_SPIMulti();
91
			break;
92
		default:
93
			V2Protocol_UnknownCommand(V2Command);
94
			break;
95
96
	}
	
97
	Endpoint_WaitUntilReady();
98
99
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_OUT);
}
100

101
102
103
/** Handler for unknown V2 protocol commands. This discards all sent data and returns a
 *  STATUS_CMD_UNKNOWN status back to the host.
 *
104
 *  \param[in] V2Command  Issued V2 Protocol command byte from the host
105
 */
106
static void V2Protocol_UnknownCommand(uint8_t V2Command)
107
{
108
	/* Discard all incoming data */
109
	while (Endpoint_BytesInEndpoint() == AVRISP_DATA_EPSIZE)
110
	{
111
		Endpoint_ClearOUT();
112
		Endpoint_WaitUntilReady();
113
	}
114
115
116
117
118
119
120
121

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

	Endpoint_Write_Byte(V2Command);
	Endpoint_Write_Byte(STATUS_CMD_UNKNOWN);
	Endpoint_ClearIN();
}
122

123
/** Handler for the CMD_SIGN_ON command, returning the programmer ID string to the host. */
124
static void V2Protocol_SignOn(void)
125
126
127
{
	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
128

129
130
	Endpoint_Write_Byte(CMD_SIGN_ON);
	Endpoint_Write_Byte(STATUS_CMD_OK);
131
132
	Endpoint_Write_Byte(sizeof(PROGRAMMER_ID) - 1);
	Endpoint_Write_Stream_LE(PROGRAMMER_ID, (sizeof(PROGRAMMER_ID) - 1));
133
134
135
	Endpoint_ClearIN();
}

136
137
138
139
140
141
142
143
144
145
146
147
148
149
/** Handler for the CMD_RESET_PROTECTION command, currently implemented as a dummy ACK function
 *  as no ISP short-circuit protection is currently implemented.
 */
static void V2Protocol_ResetProtection(void)
{
	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
	
	Endpoint_Write_Byte(CMD_RESET_PROTECTION);
	Endpoint_Write_Byte(STATUS_CMD_OK);
	Endpoint_ClearIN();	
}


150
151
152
/** Handler for the CMD_SET_PARAMETER and CMD_GET_PARAMETER commands from the host, setting or
 *  getting a device parameter's value from the parameter table.
 *
153
 *  \param[in] V2Command  Issued V2 Protocol command byte from the host
154
 */
155
static void V2Protocol_GetSetParam(uint8_t V2Command)
156
{
157
158
	uint8_t ParamID = Endpoint_Read_Byte();
	uint8_t ParamValue;
159
	
160
161
	if (V2Command == CMD_SET_PARAMETER)
	  ParamValue = Endpoint_Read_Byte();
162
163
164

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
165
	
166
	Endpoint_Write_Byte(V2Command);
167
	
168
	uint8_t ParamPrivs = V2Params_GetParameterPrivileges(ParamID);
169
	
170
171
172
	if ((V2Command == CMD_SET_PARAMETER) && (ParamPrivs & PARAM_PRIV_WRITE))
	{
		Endpoint_Write_Byte(STATUS_CMD_OK);
173
		V2Params_SetParameterValue(ParamID, ParamValue);
174
175
176
177
	}
	else if ((V2Command == CMD_GET_PARAMETER) && (ParamPrivs & PARAM_PRIV_READ))
	{
		Endpoint_Write_Byte(STATUS_CMD_OK);
178
		Endpoint_Write_Byte(V2Params_GetParameterValue(ParamID));
179
	}
180
	else
181
182
183
	{	
		Endpoint_Write_Byte(STATUS_CMD_FAILED);
	}
184

185
	Endpoint_ClearIN();
186
}
187

188
189
190
191
/** Handler for the CMD_LOAD_ADDRESS command, loading the given device address into a
 *  global storage variable for later use, and issuing LOAD EXTENDED ADDRESS commands
 *  to the attached device as required.
 */
192
static void V2Protocol_LoadAddress(void)
193
{
194
	Endpoint_Read_Stream_BE(&CurrentAddress, sizeof(CurrentAddress));
195
196
197

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
198
	
199
200
	if (CurrentAddress & (1UL << 31))
	  V2Protocol_LoadExtendedAddress();
201
202
203
204
205
206

	Endpoint_Write_Byte(CMD_LOAD_ADDRESS);
	Endpoint_Write_Byte(STATUS_CMD_OK);
	Endpoint_ClearIN();
}

207
208
209
/** Handler for the CMD_ENTER_PROGMODE_ISP command, which attempts to enter programming mode on
 *  the attached device, returning success or failure back to the host.
 */
210
static void V2Protocol_ISP_EnterISPMode(void)
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
{
	struct
	{
		uint8_t TimeoutMS;
		uint8_t PinStabDelayMS;
		uint8_t ExecutionDelayMS;
		uint8_t SynchLoops;
		uint8_t ByteDelay;
		uint8_t PollValue;
		uint8_t PollIndex;
		uint8_t EnterProgBytes[4];
	} Enter_ISP_Params;
	
	Endpoint_Read_Stream_LE(&Enter_ISP_Params, sizeof(Enter_ISP_Params));

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

	uint8_t ResponseStatus = STATUS_CMD_FAILED;
	
	CurrentAddress = 0;

	V2Protocol_DelayMS(Enter_ISP_Params.ExecutionDelayMS);	  
234
	SPI_Init(V2Protocol_GetSPIPrescalerMask() | SPI_SCK_LEAD_RISING | SPI_SAMPLE_LEADING | SPI_MODE_MASTER);
235
236
237
238
		
	while (Enter_ISP_Params.SynchLoops-- && (ResponseStatus == STATUS_CMD_FAILED))
	{
		uint8_t ResponseBytes[4];
239

240
241
242
		V2Protocol_ChangeTargetResetLine(true);
		V2Protocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);

243
244
245
		for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
		{
			V2Protocol_DelayMS(Enter_ISP_Params.ByteDelay);
246
			ResponseBytes[RByte] = SPI_TransferByte(Enter_ISP_Params.EnterProgBytes[RByte]);
247
248
		}
		
249
		/* Check if polling disabled, or if the polled value matches the expected value */
250
		if (!(Enter_ISP_Params.PollIndex) || (ResponseBytes[Enter_ISP_Params.PollIndex - 1] == Enter_ISP_Params.PollValue))
251
252
253
254
255
256
257
258
		{
			ResponseStatus = STATUS_CMD_OK;
		}
		else
		{
			V2Protocol_ChangeTargetResetLine(false);
			V2Protocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);
		}
259
260
261
262
263
264
265
	}

	Endpoint_Write_Byte(CMD_ENTER_PROGMODE_ISP);
	Endpoint_Write_Byte(ResponseStatus);
	Endpoint_ClearIN();
}

266
/** Handler for the CMD_LEAVE_ISP command, which releases the target from programming mode. */
267
static void V2Protocol_ISP_LeaveISPMode(void)
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
{
	struct
	{
		uint8_t PreDelayMS;
		uint8_t PostDelayMS;
	} Leave_ISP_Params;

	Endpoint_Read_Stream_LE(&Leave_ISP_Params, sizeof(Leave_ISP_Params));
	
	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

	V2Protocol_DelayMS(Leave_ISP_Params.PreDelayMS);
	V2Protocol_ChangeTargetResetLine(false);
	SPI_ShutDown();
	V2Protocol_DelayMS(Leave_ISP_Params.PostDelayMS);

	Endpoint_Write_Byte(CMD_LEAVE_PROGMODE_ISP);
	Endpoint_Write_Byte(STATUS_CMD_OK);
	Endpoint_ClearIN();
}

290
291
292
/** Handler for the CMD_PROGRAM_FLASH_ISP and CMD_PROGRAM_EEPROM_ISP commands, writing out bytes,
 *  words or pages of data to the attached device.
 *
293
 *  \param[in] V2Command  Issued V2 Protocol command byte from the host
294
 */
295
static void V2Protocol_ISP_ProgramMemory(uint8_t V2Command)
296
297
298
299
300
301
302
303
304
{
	struct
	{
		uint16_t BytesToWrite;
		uint8_t  ProgrammingMode;
		uint8_t  DelayMS;
		uint8_t  ProgrammingCommands[3];
		uint8_t  PollValue1;
		uint8_t  PollValue2;
305
306
		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
307
	
308
	Endpoint_Read_Stream_LE(&Write_Memory_Params, sizeof(Write_Memory_Params) - sizeof(Write_Memory_Params.ProgData));
309
	Write_Memory_Params.BytesToWrite = SwapEndian_16(Write_Memory_Params.BytesToWrite);
310
311
312
313
314
315
316
317
318
319
320
321
	
	if (Write_Memory_Params.BytesToWrite > sizeof(Write_Memory_Params.ProgData))
	{
		Endpoint_ClearOUT();
		Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

		Endpoint_Write_Byte(V2Command);
		Endpoint_Write_Byte(STATUS_CMD_FAILED);
		Endpoint_ClearIN();
		return;
	}
	
322
323
324
325
326
	Endpoint_Read_Stream_LE(&Write_Memory_Params.ProgData, Write_Memory_Params.BytesToWrite);

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

327
328
	uint8_t  ProgrammingStatus = STATUS_CMD_OK;	
	uint16_t PollAddress       = 0;
329
330
	uint8_t  PollValue         = (V2Command == CMD_PROGRAM_FLASH_ISP) ? Write_Memory_Params.PollValue1 :
	                                                                    Write_Memory_Params.PollValue2;
331
332
	uint8_t* NextWriteByte = Write_Memory_Params.ProgData;

333
	if (Write_Memory_Params.ProgrammingMode & PROG_MODE_PAGED_WRITES_MASK)
334
	{
335
336
		uint16_t StartAddress = (CurrentAddress & 0xFFFF);
	
337
		/* Paged mode memory programming */
338
		for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)
339
		{
340
			bool    IsOddByte   = (CurrentByte & 0x01);
341
			uint8_t ByteToWrite = *(NextWriteByte++);
342
		
343
			if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))
344
			  Write_Memory_Params.ProgrammingCommands[0] |=  READ_WRITE_HIGH_BYTE_MASK;
345
346
			else
			  Write_Memory_Params.ProgrammingCommands[0] &= ~READ_WRITE_HIGH_BYTE_MASK;
347
348
349
350
			  
			SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);
			SPI_SendByte(CurrentAddress >> 8);
			SPI_SendByte(CurrentAddress & 0xFF);
351
			SPI_SendByte(ByteToWrite);
352
			
353
			if (!(PollAddress) && (ByteToWrite != PollValue))
354
			{
355
356
357
358
				if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))
				  Write_Memory_Params.ProgrammingCommands[2] |= READ_WRITE_HIGH_BYTE_MASK;
				  
				PollAddress = (CurrentAddress & 0xFFFF);				
359
			}		
360

361
			if (IsOddByte || (V2Command == CMD_PROGRAM_EEPROM_ISP))
362
363
364
365
366
367
368
			  CurrentAddress++;
		}
		
		/* If the current page must be committed, send the PROGRAM PAGE command to the target */
		if (Write_Memory_Params.ProgrammingMode & PROG_MODE_COMMIT_PAGE_MASK)
		{
			SPI_SendByte(Write_Memory_Params.ProgrammingCommands[1]);
369
370
			SPI_SendByte(StartAddress >> 8);
			SPI_SendByte(StartAddress & 0xFF);
371
			SPI_SendByte(0x00);
372
373
374
375
376
			
			/* Check if polling is possible, if not switch to timed delay mode */
			if (!(PollAddress))
			{
				Write_Memory_Params.ProgrammingMode &= ~PROG_MODE_PAGED_VALUE_MASK;
377
				Write_Memory_Params.ProgrammingMode |=  PROG_MODE_PAGED_TIMEDELAY_MASK;				
378
			}
379
380
381

			ProgrammingStatus = V2Protocol_WaitForProgComplete(Write_Memory_Params.ProgrammingMode, PollAddress, PollValue,
															   Write_Memory_Params.DelayMS, Write_Memory_Params.ProgrammingCommands[2]);
382
383
384
		}
	}
	else
385
386
387
388
389
	{
		/* Word/byte mode memory programming */
		for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)
		{
			bool    IsOddByte   = (CurrentByte & 0x01);
390
			uint8_t ByteToWrite = *(NextWriteByte++);
391
		
392
			if (IsOddByte && (V2Command == CMD_READ_FLASH_ISP))
393
			  Write_Memory_Params.ProgrammingCommands[0] |=  READ_WRITE_HIGH_BYTE_MASK;
394
395
			else
			  Write_Memory_Params.ProgrammingCommands[0] &= ~READ_WRITE_HIGH_BYTE_MASK;			
396
397
398
399
400
401
			  
			SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);
			SPI_SendByte(CurrentAddress >> 8);
			SPI_SendByte(CurrentAddress & 0xFF);
			SPI_SendByte(ByteToWrite);
			
402
403
			if (ByteToWrite != PollValue)
			{
404
405
406
407
				if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))
				  Write_Memory_Params.ProgrammingCommands[2] |= READ_WRITE_HIGH_BYTE_MASK;
				  
				PollAddress = (CurrentAddress & 0xFFFF);
408
			}
409

410
411
			if (IsOddByte || (V2Command == CMD_PROGRAM_EEPROM_ISP))
			  CurrentAddress++;
412
413
			
			ProgrammingStatus = V2Protocol_WaitForProgComplete(Write_Memory_Params.ProgrammingMode, PollAddress, PollValue,
414
			                                                   Write_Memory_Params.DelayMS, Write_Memory_Params.ProgrammingCommands[2]);
415
416
417
418
			  
			if (ProgrammingStatus != STATUS_CMD_OK)
			  break;
		}
419
420
421
422
423
424
425
	}

	Endpoint_Write_Byte(V2Command);
	Endpoint_Write_Byte(ProgrammingStatus);
	Endpoint_ClearIN();
}

426
427
428
/** Handler for the CMD_READ_FLASH_ISP and CMD_READ_EEPROM_ISP commands, reading in bytes,
 *  words or pages of data from the attached device.
 *
429
 *  \param[in] V2Command  Issued V2 Protocol command byte from the host
430
 */
431
static void V2Protocol_ISP_ReadMemory(uint8_t V2Command)
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
{
	struct
	{
		uint16_t BytesToRead;
		uint8_t  ReadMemoryCommand;
	} Read_Memory_Params;
	
	Endpoint_Read_Stream_LE(&Read_Memory_Params, sizeof(Read_Memory_Params));
	Read_Memory_Params.BytesToRead = SwapEndian_16(Read_Memory_Params.BytesToRead);
	
	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
	
	Endpoint_Write_Byte(V2Command);
	Endpoint_Write_Byte(STATUS_CMD_OK);
447
	
448
449
	for (uint16_t CurrentByte = 0; CurrentByte < Read_Memory_Params.BytesToRead; CurrentByte++)
	{
450
451
452
		bool IsOddByte = (CurrentByte & 0x01);

		if (IsOddByte && (V2Command == CMD_READ_FLASH_ISP))
453
		  Read_Memory_Params.ReadMemoryCommand |=  READ_WRITE_HIGH_BYTE_MASK;
454
455
		else
		  Read_Memory_Params.ReadMemoryCommand &= ~READ_WRITE_HIGH_BYTE_MASK;
456
457
458
459
460
461
462
463
464
465
466
467
468

		SPI_SendByte(Read_Memory_Params.ReadMemoryCommand);
		SPI_SendByte(CurrentAddress >> 8);
		SPI_SendByte(CurrentAddress & 0xFF);
		Endpoint_Write_Byte(SPI_ReceiveByte());
		
		/* Check if the endpoint bank is currently full */
		if (!(Endpoint_IsReadWriteAllowed()))
		{
			Endpoint_ClearIN();
			Endpoint_WaitUntilReady();
		}
		
469
		if ((IsOddByte && (V2Command == CMD_READ_FLASH_ISP)) || (V2Command == CMD_READ_EEPROM_ISP))
470
		  CurrentAddress++;
471
472
473
	}

	Endpoint_Write_Byte(STATUS_CMD_OK);
474
475

	bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
476
	Endpoint_ClearIN();
477
478
479
480
481
482
483
484
	
	/* Ensure last packet is a short packet to terminate the transfer */
	if (IsEndpointFull)
	{
		Endpoint_WaitUntilReady();	
		Endpoint_ClearIN();
		Endpoint_WaitUntilReady();	
	}
485
486
}

487
/** Handler for the CMD_CHI_ERASE_ISP command, clearing the target's FLASH memory. */
488
static void V2Protocol_ISP_ChipErase(void)
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
{
	struct
	{
		uint8_t EraseDelayMS;
		uint8_t PollMethod;
		uint8_t EraseCommandBytes[4];
	} Erase_Chip_Params;
	
	Endpoint_Read_Stream_LE(&Erase_Chip_Params, sizeof(Erase_Chip_Params));
	
	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
	
	uint8_t ResponseStatus = STATUS_CMD_OK;
	
	for (uint8_t SByte = 0; SByte < sizeof(Erase_Chip_Params.EraseCommandBytes); SByte++)
	  SPI_SendByte(Erase_Chip_Params.EraseCommandBytes[SByte]);

507
	if (!(Erase_Chip_Params.PollMethod))
508
509
510
511
512
513
514
515
516
	  V2Protocol_DelayMS(Erase_Chip_Params.EraseDelayMS);
	else
	  ResponseStatus = V2Protocol_WaitWhileTargetBusy();
	  
	Endpoint_Write_Byte(CMD_CHIP_ERASE_ISP);
	Endpoint_Write_Byte(ResponseStatus);
	Endpoint_ClearIN();
}

517
518
519
/** Handler for the CMD_READ_FUSE_ISP, CMD_READ_LOCK_ISP, CMD_READ_SIGNATURE_ISP and CMD_READ_OSCCAL commands,
 *  reading the requested configuration byte from the device.
 *
520
 *  \param[in] V2Command  Issued V2 Protocol command byte from the host
521
 */
522
static void V2Protocol_ISP_ReadFuseLockSigOSCCAL(uint8_t V2Command)
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
{
	struct
	{
		uint8_t RetByte;
		uint8_t ReadCommandBytes[4];
	} Read_FuseLockSigOSCCAL_Params;
	
	Endpoint_Read_Stream_LE(&Read_FuseLockSigOSCCAL_Params, sizeof(Read_FuseLockSigOSCCAL_Params));

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

	uint8_t ResponseBytes[4];
		
	for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
	  ResponseBytes[RByte] = SPI_TransferByte(Read_FuseLockSigOSCCAL_Params.ReadCommandBytes[RByte]);
		
	Endpoint_Write_Byte(V2Command);
	Endpoint_Write_Byte(STATUS_CMD_OK);
542
	Endpoint_Write_Byte(ResponseBytes[Read_FuseLockSigOSCCAL_Params.RetByte - 1]);
543
544
545
546
	Endpoint_Write_Byte(STATUS_CMD_OK);
	Endpoint_ClearIN();
}

547
548
549
/** Handler for the CMD_WRITE_FUSE_ISP and CMD_WRITE_LOCK_ISP commands, writing the requested configuration
 *  byte to the device.
 *
550
 *  \param[in] V2Command  Issued V2 Protocol command byte from the host
551
 */
552
static void V2Protocol_ISP_WriteFuseLock(uint8_t V2Command)
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
{
	struct
	{
		uint8_t WriteCommandBytes[4];
	} Write_FuseLockSig_Params;
	
	Endpoint_Read_Stream_LE(&Write_FuseLockSig_Params, sizeof(Write_FuseLockSig_Params));

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

	for (uint8_t SByte = 0; SByte < sizeof(Write_FuseLockSig_Params.WriteCommandBytes); SByte++)
	  SPI_SendByte(Write_FuseLockSig_Params.WriteCommandBytes[SByte]);
		
	Endpoint_Write_Byte(V2Command);
	Endpoint_Write_Byte(STATUS_CMD_OK);
	Endpoint_Write_Byte(STATUS_CMD_OK);
	Endpoint_ClearIN();
}

573
/** Handler for the CMD_SPI_MULTI command, writing and reading arbitrary SPI data to and from the attached device. */
574
static void V2Protocol_ISP_SPIMulti(void)
575
{
576
577
578
579
580
581
582
	struct
	{
		uint8_t TxBytes;
		uint8_t RxBytes;
		uint8_t RxStartAddr;
		uint8_t TxData[255];
	} SPI_Multi_Params;
583
	
584
	Endpoint_Read_Stream_LE(&SPI_Multi_Params, sizeof(SPI_Multi_Params) - sizeof(SPI_Multi_Params.TxData));
585
	Endpoint_Read_Stream_LE(&SPI_Multi_Params.TxData, SPI_Multi_Params.TxBytes);
586
587
588
589
590
591
592
593
594
595
	
	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
	
	Endpoint_Write_Byte(CMD_SPI_MULTI);
	Endpoint_Write_Byte(STATUS_CMD_OK);

	uint8_t CurrTxPos = 0;
	uint8_t CurrRxPos = 0;

596
	/* Write out bytes to transmit until the start of the bytes to receive is met */
597
	while (CurrTxPos < SPI_Multi_Params.RxStartAddr)
598
	{
599
600
		if (CurrTxPos < SPI_Multi_Params.TxBytes)
		  SPI_SendByte(SPI_Multi_Params.TxData[CurrTxPos]);
601
602
603
604
605
606
		else
		  SPI_SendByte(0);
		
		CurrTxPos++;
	}

607
	/* Transmit remaining bytes with padding as needed, read in response bytes */
608
	while (CurrRxPos < SPI_Multi_Params.RxBytes)
609
	{
610
611
		if (CurrTxPos < SPI_Multi_Params.TxBytes)
		  Endpoint_Write_Byte(SPI_TransferByte(SPI_Multi_Params.TxData[CurrTxPos++]));
612
		else
613
		  Endpoint_Write_Byte(SPI_ReceiveByte());
614
615
616
617
618
		
		CurrRxPos++;
	}	
	
	Endpoint_Write_Byte(STATUS_CMD_OK);
619
	Endpoint_ClearIN();
620
}