projects / pub / USBasp.git / blob
? search:


ab4d4262a0b0249d0c897d924f294e4d0b579d29
[pub/USBasp.git] / Projects / AVRISP-MKII / Lib / XPROG / XPROGProtocol.c
1 /*
2 LUFA Library
3 Copyright (C) Dean Camera, 2010.
4
5 dean [at] fourwalledcubicle [dot] com
6 www.fourwalledcubicle.com
7 */
8
9 /*
10 Copyright 2010 Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
12 Permission to use, copy, modify, distribute, and sell this
13 software and its documentation for any purpose is hereby granted
14 without fee, provided that the above copyright notice appear in
15 all copies and that both that the copyright notice and this
16 permission notice and warranty disclaimer appear in supporting
17 documentation, and that the name of the author not be used in
18 advertising or publicity pertaining to distribution of the
19 software without specific, written prior permission.
20
21 The author disclaim all warranties with regard to this
22 software, including all implied warranties of merchantability
23 and fitness. In no event shall the author be liable for any
24 special, indirect or consequential damages or any damages
25 whatsoever resulting from loss of use, data or profits, whether
26 in an action of contract, negligence or other tortious action,
27 arising out of or in connection with the use or performance of
28 this software.
29 */
30
31 /** \file
32 *
33 * XPROG Protocol handler, to process V2 Protocol wrapped XPROG commands used in Atmel programmer devices.
34 */
35
36 #define INCLUDE_FROM_XPROGPROTOCOL_C
37 #include "XPROGProtocol.h"
38
39 #if defined(ENABLE_XPROG_PROTOCOL) || defined(__DOXYGEN__)
40 /** Base absolute address for the target's NVM controller for PDI programming */
41 uint32_t XPROG_Param_NVMBase = 0x010001C0;
42
43 /** Size in bytes of the target's EEPROM page */
44 uint16_t XPROG_Param_EEPageSize;
45
46 /** Address of the TPI device's NVMCMD register for TPI programming */
47 uint8_t XPROG_Param_NVMCMDRegAddr;
48
49 /** Address of the TPI device's NVMCSR register for TPI programming */
50 uint8_t XPROG_Param_NVMCSRRegAddr;
51
52 /** Currently selected XPROG programming protocol */
53 uint8_t XPROG_SelectedProtocol = XPRG_PROTOCOL_PDI;
54
55 /** Handler for the CMD_XPROG_SETMODE command, which sets the programmer-to-target protocol used for PDI/TPI
56 * programming.
57 */
58 void XPROGProtocol_SetMode(void)
59 {
60 struct
61 {
62 uint8_t Protocol;
63 } SetMode_XPROG_Params;
64
65 Endpoint_Read_Stream_LE(&SetMode_XPROG_Params, sizeof(SetMode_XPROG_Params), NO_STREAM_CALLBACK);
66
67 Endpoint_ClearOUT();
68 Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
69 Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
70
71 XPROG_SelectedProtocol = SetMode_XPROG_Params.Protocol;
72
73 Endpoint_Write_Byte(CMD_XPROG_SETMODE);
74 Endpoint_Write_Byte((SetMode_XPROG_Params.Protocol != XPRG_PROTOCOL_JTAG) ? STATUS_CMD_OK : STATUS_CMD_FAILED);
75 Endpoint_ClearIN();
76 }
77
78 /** Handler for the CMD_XPROG command, which wraps up XPROG commands in a V2 wrapper which need to be
79 * removed and processed so that the underlying XPROG command can be handled.
80 */
81 void XPROGProtocol_Command(void)
82 {
83 uint8_t XPROGCommand = Endpoint_Read_Byte();
84
85 switch (XPROGCommand)
86 {
87 case XPRG_CMD_ENTER_PROGMODE:
88 XPROGProtocol_EnterXPROGMode();
89 break;
90 case XPRG_CMD_LEAVE_PROGMODE:
91 XPROGProtocol_LeaveXPROGMode();
92 break;
93 case XPRG_CMD_ERASE:
94 XPROGProtocol_Erase();
95 break;
96 case XPRG_CMD_WRITE_MEM:
97 XPROGProtocol_WriteMemory();
98 break;
99 case XPRG_CMD_READ_MEM:
100 XPROGProtocol_ReadMemory();
101 break;
102 case XPRG_CMD_CRC:
103 XPROGProtocol_ReadCRC();
104 break;
105 case XPRG_CMD_SET_PARAM:
106 XPROGProtocol_SetParam();
107 break;
108 }
109 }
110
111 /** Handler for the XPROG ENTER_PROGMODE command to establish a connection with the attached device. */
112 static void XPROGProtocol_EnterXPROGMode(void)
113 {
114 Endpoint_ClearOUT();
115 Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
116 Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
117
118 bool NVMBusEnabled;
119
120 if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
121 {
122 /* Enable PDI programming mode with the attached target */
123 XPROGTarget_EnableTargetPDI();
124
125 /* Store the RESET key into the RESET PDI register to keep the XMEGA in reset */
126 XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);
127 XPROGTarget_SendByte(PDI_RESET_KEY);
128
129 /* Lower direction change guard time to 0 USART bits */
130 XPROGTarget_SendByte(PDI_CMD_STCS | PDI_CTRL_REG);
131 XPROGTarget_SendByte(0x07);
132
133 /* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */
134 XPROGTarget_SendByte(PDI_CMD_KEY);
135 for (uint8_t i = sizeof(PDI_NVMENABLE_KEY); i > 0; i--)
136 XPROGTarget_SendByte(PDI_NVMENABLE_KEY[i - 1]);
137
138 /* Wait until the NVM bus becomes active */
139 NVMBusEnabled = XMEGANVM_WaitWhileNVMBusBusy();
140 }
141 else
142 {
143 /* Enable TPI programming mode with the attached target */
144 XPROGTarget_EnableTargetTPI();
145
146 /* Lower direction change guard time to 0 USART bits */
147 XPROGTarget_SendByte(TPI_CMD_SSTCS | TPI_CTRL_REG);
148 XPROGTarget_SendByte(0x07);
149
150 /* Enable access to the XPROG NVM bus by sending the documented NVM access key to the device */
151 XPROGTarget_SendByte(TPI_CMD_SKEY);
152 for (uint8_t i = sizeof(TPI_NVMENABLE_KEY); i > 0; i--)
153 XPROGTarget_SendByte(TPI_NVMENABLE_KEY[i - 1]);
154
155 /* Wait until the NVM bus becomes active */
156 NVMBusEnabled = TINYNVM_WaitWhileNVMBusBusy();
157 }
158
159 Endpoint_Write_Byte(CMD_XPROG);
160 Endpoint_Write_Byte(XPRG_CMD_ENTER_PROGMODE);
161 Endpoint_Write_Byte(NVMBusEnabled ? XPRG_ERR_OK : XPRG_ERR_FAILED);
162 Endpoint_ClearIN();
163 }
164
165 /** Handler for the XPROG LEAVE_PROGMODE command to terminate the PDI programming connection with
166 * the attached device.
167 */
168 static void XPROGProtocol_LeaveXPROGMode(void)
169 {
170 Endpoint_ClearOUT();
171 Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
172 Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
173
174 if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
175 {
176 XMEGANVM_WaitWhileNVMBusBusy();
177
178 /* Clear the RESET key in the RESET PDI register to allow the XMEGA to run */
179 XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);
180 XPROGTarget_SendByte(0x00);
181
182 /* Do it twice to make sure it takes affect (silicon bug?) */
183 XPROGTarget_SendByte(PDI_CMD_STCS | PDI_RESET_REG);
184 XPROGTarget_SendByte(0x00);
185
186 XPROGTarget_DisableTargetPDI();
187 }
188 else
189 {
190 TINYNVM_WaitWhileNVMBusBusy();
191
192 /* Clear the NVMEN bit in the TPI CONTROL register to disable TPI mode */
193 XPROGTarget_SendByte(TPI_CMD_SSTCS | TPI_CTRL_REG);
194 XPROGTarget_SendByte(0x00);
195
196 XPROGTarget_DisableTargetTPI();
197 }
198
199 Endpoint_Write_Byte(CMD_XPROG);
200 Endpoint_Write_Byte(XPRG_CMD_LEAVE_PROGMODE);
201 Endpoint_Write_Byte(XPRG_ERR_OK);
202 Endpoint_ClearIN();
203 }
204
205 /** Handler for the XPRG ERASE command to erase a specific memory address space in the attached device. */
206 static void XPROGProtocol_Erase(void)
207 {
208 uint8_t ReturnStatus = XPRG_ERR_OK;
209
210 struct
211 {
212 uint8_t MemoryType;
213 uint32_t Address;
214 } Erase_XPROG_Params;
215
216 Endpoint_Read_Stream_LE(&Erase_XPROG_Params, sizeof(Erase_XPROG_Params), NO_STREAM_CALLBACK);
217 Erase_XPROG_Params.Address = SwapEndian_32(Erase_XPROG_Params.Address);
218
219 Endpoint_ClearOUT();
220 Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
221 Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
222
223 uint8_t EraseCommand;
224
225 if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
226 {
227 /* Determine which NVM command to send to the device depending on the memory to erase */
228 switch (Erase_XPROG_Params.MemoryType)
229 {
230 case XPRG_ERASE_CHIP:
231 EraseCommand = XMEGA_NVM_CMD_CHIPERASE;
232 break;
233 case XPRG_ERASE_APP:
234 EraseCommand = XMEGA_NVM_CMD_ERASEAPPSEC;
235 break;
236 case XPRG_ERASE_BOOT:
237 EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSEC;
238 break;
239 case XPRG_ERASE_EEPROM:
240 EraseCommand = XMEGA_NVM_CMD_ERASEEEPROM;
241 break;
242 case XPRG_ERASE_APP_PAGE:
243 EraseCommand = XMEGA_NVM_CMD_ERASEAPPSECPAGE;
244 break;
245 case XPRG_ERASE_BOOT_PAGE:
246 EraseCommand = XMEGA_NVM_CMD_ERASEBOOTSECPAGE;
247 break;
248 case XPRG_ERASE_EEPROM_PAGE:
249 EraseCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGE;
250 break;
251 case XPRG_ERASE_USERSIG:
252 EraseCommand = XMEGA_NVM_CMD_ERASEUSERSIG;
253 break;
254 default:
255 EraseCommand = XMEGA_NVM_CMD_NOOP;
256 break;
257 }
258
259 /* Erase the target memory, indicate timeout if ocurred */
260 if (!(XMEGANVM_EraseMemory(EraseCommand, Erase_XPROG_Params.Address)))
261 ReturnStatus = XPRG_ERR_TIMEOUT;
262 }
263 else
264 {
265 if (Erase_XPROG_Params.MemoryType == XPRG_ERASE_CHIP)
266 EraseCommand = TINY_NVM_CMD_CHIPERASE;
267 else
268 EraseCommand = TINY_NVM_CMD_SECTIONERASE;
269
270 /* Erase the target memory, indicate timeout if ocurred */
271 if (!(TINYNVM_EraseMemory(EraseCommand, Erase_XPROG_Params.Address)))
272 ReturnStatus = XPRG_ERR_TIMEOUT;
273 }
274
275 Endpoint_Write_Byte(CMD_XPROG);
276 Endpoint_Write_Byte(XPRG_CMD_ERASE);
277 Endpoint_Write_Byte(ReturnStatus);
278 Endpoint_ClearIN();
279 }
280
281 /** Handler for the XPROG WRITE_MEMORY command to write to a specific memory space within the attached device. */
282 static void XPROGProtocol_WriteMemory(void)
283 {
284 uint8_t ReturnStatus = XPRG_ERR_OK;
285
286 struct
287 {
288 uint8_t MemoryType;
289 uint8_t PageMode;
290 uint32_t Address;
291 uint16_t Length;
292 uint8_t ProgData[256];
293 } WriteMemory_XPROG_Params;
294
295 Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params, (sizeof(WriteMemory_XPROG_Params) -
296 sizeof(WriteMemory_XPROG_Params).ProgData), NO_STREAM_CALLBACK);
297 WriteMemory_XPROG_Params.Address = SwapEndian_32(WriteMemory_XPROG_Params.Address);
298 WriteMemory_XPROG_Params.Length = SwapEndian_16(WriteMemory_XPROG_Params.Length);
299 Endpoint_Read_Stream_LE(&WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length, NO_STREAM_CALLBACK);
300
301 Endpoint_ClearOUT();
302 Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
303 Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
304
305 if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
306 {
307 /* Assume FLASH page programming by default, as it is the common case */
308 uint8_t WriteCommand = XMEGA_NVM_CMD_WRITEFLASHPAGE;
309 uint8_t WriteBuffCommand = XMEGA_NVM_CMD_LOADFLASHPAGEBUFF;
310 uint8_t EraseBuffCommand = XMEGA_NVM_CMD_ERASEFLASHPAGEBUFF;
311 bool PagedMemory = true;
312
313 switch (WriteMemory_XPROG_Params.MemoryType)
314 {
315 case XPRG_MEM_TYPE_APPL:
316 WriteCommand = XMEGA_NVM_CMD_WRITEAPPSECPAGE;
317 break;
318 case XPRG_MEM_TYPE_BOOT:
319 WriteCommand = XMEGA_NVM_CMD_WRITEBOOTSECPAGE;
320 break;
321 case XPRG_MEM_TYPE_EEPROM:
322 WriteCommand = XMEGA_NVM_CMD_ERASEWRITEEEPROMPAGE;
323 WriteBuffCommand = XMEGA_NVM_CMD_LOADEEPROMPAGEBUFF;
324 EraseBuffCommand = XMEGA_NVM_CMD_ERASEEEPROMPAGEBUFF;
325 break;
326 case XPRG_MEM_TYPE_USERSIG:
327 /* User signature is paged, but needs us to manually indicate the mode bits since the host doesn't set them */
328 WriteMemory_XPROG_Params.PageMode = (XPRG_PAGEMODE_ERASE | XPRG_PAGEMODE_WRITE);
329 WriteCommand = XMEGA_NVM_CMD_WRITEUSERSIG;
330 break;
331 case XPRG_MEM_TYPE_FUSE:
332 WriteCommand = XMEGA_NVM_CMD_WRITEFUSE;
333 PagedMemory = false;
334 break;
335 case XPRG_MEM_TYPE_LOCKBITS:
336 WriteCommand = XMEGA_NVM_CMD_WRITELOCK;
337 PagedMemory = false;
338 break;
339 }
340
341 /* Send the appropriate memory write commands to the device, indicate timeout if occurred */
342 if ((PagedMemory && !(XMEGANVM_WritePageMemory(WriteBuffCommand, EraseBuffCommand, WriteCommand,
343 WriteMemory_XPROG_Params.PageMode, WriteMemory_XPROG_Params.Address,
344 WriteMemory_XPROG_Params.ProgData, WriteMemory_XPROG_Params.Length))) ||
345 (!PagedMemory && !(XMEGANVM_WriteByteMemory(WriteCommand, WriteMemory_XPROG_Params.Address,
346 WriteMemory_XPROG_Params.ProgData[0]))))
347 {
348 ReturnStatus = XPRG_ERR_TIMEOUT;
349 }
350 }
351 else
352 {
353 /* Send write command to the TPI device, indicate timeout if occurred */
354 if (!(TINYNVM_WriteMemory(WriteMemory_XPROG_Params.Address, WriteMemory_XPROG_Params.ProgData,
355 WriteMemory_XPROG_Params.Length)))
356 {
357 ReturnStatus = XPRG_ERR_TIMEOUT;
358 }
359 }
360
361 Endpoint_Write_Byte(CMD_XPROG);
362 Endpoint_Write_Byte(XPRG_CMD_WRITE_MEM);
363 Endpoint_Write_Byte(ReturnStatus);
364 Endpoint_ClearIN();
365 }
366
367 /** Handler for the XPROG READ_MEMORY command to read data from a specific address space within the
368 * attached device.
369 */
370 static void XPROGProtocol_ReadMemory(void)
371 {
372 uint8_t ReturnStatus = XPRG_ERR_OK;
373
374 struct
375 {
376 uint8_t MemoryType;
377 uint32_t Address;
378 uint16_t Length;
379 } ReadMemory_XPROG_Params;
380
381 Endpoint_Read_Stream_LE(&ReadMemory_XPROG_Params, sizeof(ReadMemory_XPROG_Params), NO_STREAM_CALLBACK);
382 ReadMemory_XPROG_Params.Address = SwapEndian_32(ReadMemory_XPROG_Params.Address);
383 ReadMemory_XPROG_Params.Length = SwapEndian_16(ReadMemory_XPROG_Params.Length);
384
385 Endpoint_ClearOUT();
386 Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
387 Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
388
389 uint8_t ReadBuffer[256];
390
391 if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
392 {
393 /* Read the PDI target's memory, indicate timeout if occurred */
394 if (!(XMEGANVM_ReadMemory(ReadMemory_XPROG_Params.Address, ReadBuffer, ReadMemory_XPROG_Params.Length)))
395 ReturnStatus = XPRG_ERR_TIMEOUT;
396 }
397 else
398 {
399 /* Read the TPI target's memory, indicate timeout if occurred */
400 if (!(TINYNVM_ReadMemory(ReadMemory_XPROG_Params.Address, ReadBuffer, ReadMemory_XPROG_Params.Length)))
401 ReturnStatus = XPRG_ERR_TIMEOUT;
402 }
403
404 Endpoint_Write_Byte(CMD_XPROG);
405 Endpoint_Write_Byte(XPRG_CMD_READ_MEM);
406 Endpoint_Write_Byte(ReturnStatus);
407
408 if (ReturnStatus == XPRG_ERR_OK)
409 Endpoint_Write_Stream_LE(ReadBuffer, ReadMemory_XPROG_Params.Length, NO_STREAM_CALLBACK);
410
411 Endpoint_ClearIN();
412 }
413
414 /** Handler for the XPROG CRC command to read a specific memory space's CRC value for comparison between the
415 * attached device's memory and a data set on the host.
416 */
417 static void XPROGProtocol_ReadCRC(void)
418 {
419 uint8_t ReturnStatus = XPRG_ERR_OK;
420
421 struct
422 {
423 uint8_t CRCType;
424 } ReadCRC_XPROG_Params;
425
426 Endpoint_Read_Stream_LE(&ReadCRC_XPROG_Params, sizeof(ReadCRC_XPROG_Params), NO_STREAM_CALLBACK);
427
428 Endpoint_ClearOUT();
429 Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
430 Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
431
432 uint32_t MemoryCRC;
433
434 if (XPROG_SelectedProtocol == XPRG_PROTOCOL_PDI)
435 {
436 uint8_t CRCCommand;
437
438 /* Determine which NVM command to send to the device depending on the memory to CRC */
439 switch (ReadCRC_XPROG_Params.CRCType)
440 {
441 case XPRG_CRC_APP:
442 CRCCommand = XMEGA_NVM_CMD_APPCRC;
443 break;
444 case XPRG_CRC_BOOT:
445 CRCCommand = XMEGA_NVM_CMD_BOOTCRC;
446 break;
447 default:
448 CRCCommand = XMEGA_NVM_CMD_FLASHCRC;
449 break;
450 }
451
452 /* Perform and retrieve the memory CRC, indicate timeout if occurred */
453 if (!(XMEGANVM_GetMemoryCRC(CRCCommand, &MemoryCRC)))
454 ReturnStatus = XPRG_ERR_TIMEOUT;
455 }
456 else
457 {
458 /* TPI does not support memory CRC */
459 ReturnStatus = XPRG_ERR_FAILED;
460 }
461
462 Endpoint_Write_Byte(CMD_XPROG);
463 Endpoint_Write_Byte(XPRG_CMD_CRC);
464 Endpoint_Write_Byte(ReturnStatus);
465
466 if (ReturnStatus == XPRG_ERR_OK)
467 {
468 Endpoint_Write_Byte(MemoryCRC >> 16);
469 Endpoint_Write_Word_LE(MemoryCRC & 0xFFFF);
470 }
471
472 Endpoint_ClearIN();
473 }
474
475 /** Handler for the XPROG SET_PARAM command to set a XPROG parameter for use when communicating with the
476 * attached device.
477 */
478 static void XPROGProtocol_SetParam(void)
479 {
480 uint8_t ReturnStatus = XPRG_ERR_OK;
481
482 uint8_t XPROGParam = Endpoint_Read_Byte();
483
484 /* Determine which parameter is being set, store the new parameter value */
485 switch (XPROGParam)
486 {
487 case XPRG_PARAM_NVMBASE:
488 XPROG_Param_NVMBase = Endpoint_Read_DWord_BE();
489 break;
490 case XPRG_PARAM_EEPPAGESIZE:
491 XPROG_Param_EEPageSize = Endpoint_Read_Word_BE();
492 break;
493 case XPRG_PARAM_NVMCMD_REG:
494 XPROG_Param_NVMCMDRegAddr = Endpoint_Read_Byte();
495 break;
496 case XPRG_PARAM_NVMCSR_REG:
497 XPROG_Param_NVMCSRRegAddr = Endpoint_Read_Byte();
498 break;
499 default:
500 ReturnStatus = XPRG_ERR_FAILED;
501 break;
502 }
503
504 Endpoint_ClearOUT();
505 Endpoint_SelectEndpoint(AVRISP_DATA_IN_EPNUM);
506 Endpoint_SetEndpointDirection(ENDPOINT_DIR_IN);
507
508 Endpoint_Write_Byte(CMD_XPROG);
509 Endpoint_Write_Byte(XPRG_CMD_SET_PARAM);
510 Endpoint_Write_Byte(ReturnStatus);
511 Endpoint_ClearIN();
512 }
513
514 #endif
USB isp AVR programmer