V2Protocol.c 16.3 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
40
41
void V2Protocol_ProcessCommand(void)
{
	uint8_t V2Command = Endpoint_Read_Byte();
42
		  
43
44
45
	switch (V2Command)
	{
		case CMD_SIGN_ON:
46
			V2Protocol_Command_SignOn();
47
48
49
			break;
		case CMD_SET_PARAMETER:
		case CMD_GET_PARAMETER:
50
			V2Protocol_Command_GetSetParam(V2Command);
51
			break;
52
53
54
		case CMD_LOAD_ADDRESS:
			V2Protocol_Command_LoadAddress();
			break;
55
56
57
		case CMD_RESET_PROTECTION:
			V2Protocol_Command_ResetProtection();
			break;
58
59
60
61
62
63
		case CMD_ENTER_PROGMODE_ISP:
			V2Protocol_Command_EnterISPMode();
			break;
		case CMD_LEAVE_PROGMODE_ISP:
			V2Protocol_Command_LeaveISPMode();
			break;
64
65
66
67
68
69
70
71
		case CMD_PROGRAM_FLASH_ISP:
		case CMD_PROGRAM_EEPROM_ISP:
			V2Protocol_Command_ProgramMemory(V2Command);			
			break;
		case CMD_READ_FLASH_ISP:
		case CMD_READ_EEPROM_ISP:
			V2Protocol_Command_ReadMemory(V2Command);
			break;
72
73
74
75
76
77
78
79
80
81
82
83
84
		case CMD_CHIP_ERASE_ISP:
			V2Protocol_Command_ChipErase();
			break;
		case CMD_READ_FUSE_ISP:
		case CMD_READ_LOCK_ISP:
		case CMD_READ_SIGNATURE_ISP:
		case CMD_READ_OSCCAL_ISP:
			V2Protocol_Command_ReadFuseLockSigOSCCAL(V2Command);
			break;
		case CMD_PROGRAM_FUSE_ISP:
		case CMD_PROGRAM_LOCK_ISP:
			V2Protocol_Command_WriteFuseLock(V2Command);
			break;
85
		case CMD_SPI_MULTI:
86
			V2Protocol_Command_SPIMulti();
87
			break;
88
		default:
89
			V2Protocol_Command_Unknown(V2Command);
90
			break;
91
92
	}
	
93
94
	Endpoint_WaitUntilReady();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_OUT);
95
}
96

97
static void V2Protocol_Command_Unknown(uint8_t V2Command)
98
99
{
	/* Discard all incomming data */
100
	while (Endpoint_BytesInEndpoint() == AVRISP_DATA_EPSIZE)
101
	{
102
		Endpoint_ClearOUT();
103
		Endpoint_WaitUntilReady();
104
	}
105
106
107
108
109
110
111
112

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

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

114
static void V2Protocol_Command_SignOn(void)
115
116
117
{
	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
118

119
120
	Endpoint_Write_Byte(CMD_SIGN_ON);
	Endpoint_Write_Byte(STATUS_CMD_OK);
121
122
	Endpoint_Write_Byte(sizeof(PROGRAMMER_ID) - 1);
	Endpoint_Write_Stream_LE(PROGRAMMER_ID, (sizeof(PROGRAMMER_ID) - 1));
123
124
125
	Endpoint_ClearIN();
}

126
static void V2Protocol_Command_GetSetParam(uint8_t V2Command)
127
{
128
129
	uint8_t ParamID = Endpoint_Read_Byte();
	uint8_t ParamValue;
130
	
131
132
	if (V2Command == CMD_SET_PARAMETER)
	  ParamValue = Endpoint_Read_Byte();
133
134
135

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
136
	
137
	Endpoint_Write_Byte(V2Command);
138
	
139
140
	uint8_t ParamPrivs = V2Params_GetParameterPrivellages(ParamID);
	
141
142
143
	if ((V2Command == CMD_SET_PARAMETER) && (ParamPrivs & PARAM_PRIV_WRITE))
	{
		Endpoint_Write_Byte(STATUS_CMD_OK);
144
		V2Params_SetParameterValue(ParamID, ParamValue);
145
146
147
148
	}
	else if ((V2Command == CMD_GET_PARAMETER) && (ParamPrivs & PARAM_PRIV_READ))
	{
		Endpoint_Write_Byte(STATUS_CMD_OK);
149
		Endpoint_Write_Byte(V2Params_GetParameterValue(ParamID));
150
	}
151
	else
152
153
154
	{	
		Endpoint_Write_Byte(STATUS_CMD_FAILED);
	}
155

156
	Endpoint_ClearIN();
157
}
158

159
160
static void V2Protocol_Command_LoadAddress(void)
{
161
	Endpoint_Read_Stream_BE(&CurrentAddress, sizeof(CurrentAddress));
162
163
164

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
165
	
166
167
	if (CurrentAddress & (1UL << 31))
	  V2Protocol_LoadExtendedAddress();
168
169
170
171
172
173

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

174
175
176
177
178
179
180
181
182
183
static void V2Protocol_Command_ResetProtection(void)
{
	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
	
	Endpoint_Write_Byte(CMD_RESET_PROTECTION);
	Endpoint_Write_Byte(STATUS_CMD_OK);
	Endpoint_ClearIN();	
}

184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
static void V2Protocol_Command_EnterISPMode(void)
{
	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);	  
208
	SPI_Init(V2Protocol_GetSPIPrescalerMask() | SPI_SCK_LEAD_RISING | SPI_SAMPLE_LEADING | SPI_MODE_MASTER);
209
210
211
212
		
	while (Enter_ISP_Params.SynchLoops-- && (ResponseStatus == STATUS_CMD_FAILED))
	{
		uint8_t ResponseBytes[4];
213

214
215
216
		V2Protocol_ChangeTargetResetLine(true);
		V2Protocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);

217
218
219
		for (uint8_t RByte = 0; RByte < sizeof(ResponseBytes); RByte++)
		{
			V2Protocol_DelayMS(Enter_ISP_Params.ByteDelay);
220
			ResponseBytes[RByte] = SPI_TransferByte(Enter_ISP_Params.EnterProgBytes[RByte]);
221
222
		}
		
223
		/* Check if polling disabled, or if the polled value matches the expected value */
224
		if (!(Enter_ISP_Params.PollIndex) || (ResponseBytes[Enter_ISP_Params.PollIndex - 1] == Enter_ISP_Params.PollValue))
225
226
227
228
229
230
231
232
		{
			ResponseStatus = STATUS_CMD_OK;
		}
		else
		{
			V2Protocol_ChangeTargetResetLine(false);
			V2Protocol_DelayMS(Enter_ISP_Params.PinStabDelayMS);
		}
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
	}

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

static void V2Protocol_Command_LeaveISPMode(void)
{
	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();
}

263
264
265
266
267
268
269
270
271
272
static void V2Protocol_Command_ProgramMemory(uint8_t V2Command)
{
	struct
	{
		uint16_t BytesToWrite;
		uint8_t  ProgrammingMode;
		uint8_t  DelayMS;
		uint8_t  ProgrammingCommands[3];
		uint8_t  PollValue1;
		uint8_t  PollValue2;
273
		uint8_t  ProgData[256];
274
275
	} Write_Memory_Params;
	
276
277
278
	uint8_t* NextWriteByte = Write_Memory_Params.ProgData;

	Endpoint_Read_Stream_LE(&Write_Memory_Params, sizeof(Write_Memory_Params) - sizeof(Write_Memory_Params.ProgData));
279
	Write_Memory_Params.BytesToWrite = SwapEndian_16(Write_Memory_Params.BytesToWrite);
280
281
282
283
284
	Endpoint_Read_Stream_LE(&Write_Memory_Params.ProgData, Write_Memory_Params.BytesToWrite);

	Endpoint_ClearOUT();
	Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);

285
286
	uint8_t  ProgrammingStatus = STATUS_CMD_OK;	
	uint16_t PollAddress       = 0;
287
288
	uint8_t  PollValue         = (V2Command == CMD_PROGRAM_FLASH_ISP) ? Write_Memory_Params.PollValue1 :
	                                                                    Write_Memory_Params.PollValue2;
289
	if (Write_Memory_Params.ProgrammingMode & PROG_MODE_PAGED_WRITES_MASK)
290
	{
291
292
		uint16_t StartAddress = (CurrentAddress & 0xFFFF);
	
293
		/* Paged mode memory programming */
294
		for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)
295
		{
296
			bool    IsOddByte   = (CurrentByte & 0x01);
297
			uint8_t ByteToWrite = *(NextWriteByte++);
298
		
299
			if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))
300
			  Write_Memory_Params.ProgrammingCommands[0] |=  READ_WRITE_HIGH_BYTE_MASK;
301
302
			else
			  Write_Memory_Params.ProgrammingCommands[0] &= ~READ_WRITE_HIGH_BYTE_MASK;
303
304
305
306
			  
			SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);
			SPI_SendByte(CurrentAddress >> 8);
			SPI_SendByte(CurrentAddress & 0xFF);
307
			SPI_SendByte(ByteToWrite);
308
			
309
			if (!(PollAddress) && (ByteToWrite != PollValue))
310
			{
311
312
313
314
				if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))
				  Write_Memory_Params.ProgrammingCommands[2] |= READ_WRITE_HIGH_BYTE_MASK;
				  
				PollAddress = (CurrentAddress & 0xFFFF);				
315
			}		
316

317
			if (IsOddByte || (V2Command == CMD_PROGRAM_EEPROM_ISP))
318
319
320
321
322
323
324
			  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]);
325
326
			SPI_SendByte(StartAddress >> 8);
			SPI_SendByte(StartAddress & 0xFF);
327
			SPI_SendByte(0x00);
328
329
330
331
332
			
			/* Check if polling is possible, if not switch to timed delay mode */
			if (!(PollAddress))
			{
				Write_Memory_Params.ProgrammingMode &= ~PROG_MODE_PAGED_VALUE_MASK;
333
				Write_Memory_Params.ProgrammingMode |=  PROG_MODE_PAGED_TIMEDELAY_MASK;				
334
			}
335
336
337

			ProgrammingStatus = V2Protocol_WaitForProgComplete(Write_Memory_Params.ProgrammingMode, PollAddress, PollValue,
															   Write_Memory_Params.DelayMS, Write_Memory_Params.ProgrammingCommands[2]);
338
339
340
		}
	}
	else
341
342
343
344
345
	{
		/* Word/byte mode memory programming */
		for (uint16_t CurrentByte = 0; CurrentByte < Write_Memory_Params.BytesToWrite; CurrentByte++)
		{
			bool    IsOddByte   = (CurrentByte & 0x01);
346
			uint8_t ByteToWrite = *(NextWriteByte++);
347
		
348
			if (IsOddByte && (V2Command == CMD_READ_FLASH_ISP))
349
			  Write_Memory_Params.ProgrammingCommands[0] |=  READ_WRITE_HIGH_BYTE_MASK;
350
351
			else
			  Write_Memory_Params.ProgrammingCommands[0] &= ~READ_WRITE_HIGH_BYTE_MASK;			
352
353
354
355
356
357
			  
			SPI_SendByte(Write_Memory_Params.ProgrammingCommands[0]);
			SPI_SendByte(CurrentAddress >> 8);
			SPI_SendByte(CurrentAddress & 0xFF);
			SPI_SendByte(ByteToWrite);
			
358
359
			if (ByteToWrite != PollValue)
			{
360
361
362
363
				if (IsOddByte && (V2Command == CMD_PROGRAM_FLASH_ISP))
				  Write_Memory_Params.ProgrammingCommands[2] |= READ_WRITE_HIGH_BYTE_MASK;
				  
				PollAddress = (CurrentAddress & 0xFFFF);
364
			}
365

366
367
			if (IsOddByte || (V2Command == CMD_PROGRAM_EEPROM_ISP))
			  CurrentAddress++;
368
369
			
			ProgrammingStatus = V2Protocol_WaitForProgComplete(Write_Memory_Params.ProgrammingMode, PollAddress, PollValue,
370
			                                                   Write_Memory_Params.DelayMS, Write_Memory_Params.ProgrammingCommands[2]);
371
372
373
374
			  
			if (ProgrammingStatus != STATUS_CMD_OK)
			  break;
		}
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
	}

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

static void V2Protocol_Command_ReadMemory(uint8_t V2Command)
{
	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);
399
	
400
401
	for (uint16_t CurrentByte = 0; CurrentByte < Read_Memory_Params.BytesToRead; CurrentByte++)
	{
402
403
404
		bool IsOddByte = (CurrentByte & 0x01);

		if (IsOddByte && (V2Command == CMD_READ_FLASH_ISP))
405
		  Read_Memory_Params.ReadMemoryCommand |=  READ_WRITE_HIGH_BYTE_MASK;
406
407
		else
		  Read_Memory_Params.ReadMemoryCommand &= ~READ_WRITE_HIGH_BYTE_MASK;
408
409
410
411
412
413
414
415
416
417
418
419
420

		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();
		}
		
421
		if ((IsOddByte && (V2Command == CMD_READ_FLASH_ISP)) || (V2Command == CMD_READ_EEPROM_ISP))
422
		  CurrentAddress++;
423
424
425
	}

	Endpoint_Write_Byte(STATUS_CMD_OK);
426
427

	bool IsEndpointFull = !(Endpoint_IsReadWriteAllowed());
428
	Endpoint_ClearIN();
429
430
431
432
433
434
435
436
	
	/* Ensure last packet is a short packet to terminate the transfer */
	if (IsEndpointFull)
	{
		Endpoint_WaitUntilReady();	
		Endpoint_ClearIN();
		Endpoint_WaitUntilReady();	
	}
437
438
}

439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
static void V2Protocol_Command_ChipErase(void)
{
	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]);

458
	if (!(Erase_Chip_Params.PollMethod))
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
	  V2Protocol_DelayMS(Erase_Chip_Params.EraseDelayMS);
	else
	  ResponseStatus = V2Protocol_WaitWhileTargetBusy();
	  
	Endpoint_Write_Byte(CMD_CHIP_ERASE_ISP);
	Endpoint_Write_Byte(ResponseStatus);
	Endpoint_ClearIN();
}

static void V2Protocol_Command_ReadFuseLockSigOSCCAL(uint8_t V2Command)
{
	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);
488
	Endpoint_Write_Byte(ResponseBytes[Read_FuseLockSigOSCCAL_Params.RetByte - 1]);
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
	Endpoint_Write_Byte(STATUS_CMD_OK);
	Endpoint_ClearIN();
}

static void V2Protocol_Command_WriteFuseLock(uint8_t V2Command)
{
	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();
}

514
static void V2Protocol_Command_SPIMulti(void)
515
{
516
517
518
519
520
521
522
	struct
	{
		uint8_t TxBytes;
		uint8_t RxBytes;
		uint8_t RxStartAddr;
		uint8_t TxData[255];
	} SPI_Multi_Params;
523
	
524
	Endpoint_Read_Stream_LE(&SPI_Multi_Params, sizeof(SPI_Multi_Params) - sizeof(SPI_Multi_Params.TxData));
525
	Endpoint_Read_Stream_LE(&SPI_Multi_Params.TxData, SPI_Multi_Params.TxBytes);
526
527
528
529
530
531
532
533
534
535
	
	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;

536
	/* Write out bytes to transmit until the start of the bytes to receive is met */
537
	while (CurrTxPos < SPI_Multi_Params.RxStartAddr)
538
	{
539
540
		if (CurrTxPos < SPI_Multi_Params.TxBytes)
		  SPI_SendByte(SPI_Multi_Params.TxData[CurrTxPos]);
541
542
543
544
545
546
		else
		  SPI_SendByte(0);
		
		CurrTxPos++;
	}

547
	/* Transmit remaining bytes with padding as needed, read in response bytes */
548
	while (CurrRxPos < SPI_Multi_Params.RxBytes)
549
	{
550
551
		if (CurrTxPos < SPI_Multi_Params.TxBytes)
		  Endpoint_Write_Byte(SPI_TransferByte(SPI_Multi_Params.TxData[CurrTxPos++]));
552
		else
553
		  Endpoint_Write_Byte(SPI_ReceiveByte());
554
555
556
557
558
		
		CurrRxPos++;
	}	
	
	Endpoint_Write_Byte(STATUS_CMD_OK);
559
	Endpoint_ClearIN();
560
}