1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2010
4 * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
5 *
6 * (C) Copyright 2002
7 * Rich Ireland, Enterasys Networks, rireland@enterasys.com.
8 *
9 * ispVM functions adapted from Lattice's ispmVMEmbedded code:
10 * Copyright 2009 Lattice Semiconductor Corp.
11 */
12
13 #include <common.h>
14 #include <malloc.h>
15 #include <fpga.h>
16 #include <lattice.h>
17
18 static lattice_board_specific_func *pfns;
19 static const char *fpga_image;
20 static unsigned long read_bytes;
21 static unsigned long bufsize;
22 static unsigned short expectedCRC;
23
24 /*
25 * External variables and functions declared in ivm_core.c module.
26 */
27 extern unsigned short g_usCalculatedCRC;
28 extern unsigned short g_usDataType;
29 extern unsigned char *g_pucIntelBuffer;
30 extern unsigned char *g_pucHeapMemory;
31 extern unsigned short g_iHeapCounter;
32 extern unsigned short g_iHEAPSize;
33 extern unsigned short g_usIntelDataIndex;
34 extern unsigned short g_usIntelBufferSize;
35 extern char *const g_szSupportedVersions[];
36
37
38 /*
39 * ispVMDelay
40 *
41 * Users must implement a delay to observe a_usTimeDelay, where
42 * bit 15 of the a_usTimeDelay defines the unit.
43 * 1 = milliseconds
44 * 0 = microseconds
45 * Example:
46 * a_usTimeDelay = 0x0001 = 1 microsecond delay.
47 * a_usTimeDelay = 0x8001 = 1 millisecond delay.
48 *
49 * This subroutine is called upon to provide a delay from 1 millisecond to a few
50 * hundreds milliseconds each time.
51 * It is understood that due to a_usTimeDelay is defined as unsigned short, a 16
52 * bits integer, this function is restricted to produce a delay to 64000
53 * micro-seconds or 32000 milli-second maximum. The VME file will never pass on
54 * to this function a delay time > those maximum number. If it needs more than
55 * those maximum, the VME file will launch the delay function several times to
56 * realize a larger delay time cummulatively.
57 * It is perfectly alright to provide a longer delay than required. It is not
58 * acceptable if the delay is shorter.
59 */
ispVMDelay(unsigned short delay)60 void ispVMDelay(unsigned short delay)
61 {
62 if (delay & 0x8000)
63 delay = (delay & ~0x8000) * 1000;
64 udelay(delay);
65 }
66
writePort(unsigned char a_ucPins,unsigned char a_ucValue)67 void writePort(unsigned char a_ucPins, unsigned char a_ucValue)
68 {
69 a_ucValue = a_ucValue ? 1 : 0;
70
71 switch (a_ucPins) {
72 case g_ucPinTDI:
73 pfns->jtag_set_tdi(a_ucValue);
74 break;
75 case g_ucPinTCK:
76 pfns->jtag_set_tck(a_ucValue);
77 break;
78 case g_ucPinTMS:
79 pfns->jtag_set_tms(a_ucValue);
80 break;
81 default:
82 printf("%s: requested unknown pin\n", __func__);
83 }
84 }
85
readPort(void)86 unsigned char readPort(void)
87 {
88 return pfns->jtag_get_tdo();
89 }
90
sclock(void)91 void sclock(void)
92 {
93 writePort(g_ucPinTCK, 0x01);
94 writePort(g_ucPinTCK, 0x00);
95 }
96
calibration(void)97 void calibration(void)
98 {
99 /* Apply 2 pulses to TCK. */
100 writePort(g_ucPinTCK, 0x00);
101 writePort(g_ucPinTCK, 0x01);
102 writePort(g_ucPinTCK, 0x00);
103 writePort(g_ucPinTCK, 0x01);
104 writePort(g_ucPinTCK, 0x00);
105
106 ispVMDelay(0x8001);
107
108 /* Apply 2 pulses to TCK. */
109 writePort(g_ucPinTCK, 0x01);
110 writePort(g_ucPinTCK, 0x00);
111 writePort(g_ucPinTCK, 0x01);
112 writePort(g_ucPinTCK, 0x00);
113 }
114
115 /*
116 * GetByte
117 *
118 * Returns a byte to the caller. The returned byte depends on the
119 * g_usDataType register. If the HEAP_IN bit is set, then the byte
120 * is returned from the HEAP. If the LHEAP_IN bit is set, then
121 * the byte is returned from the intelligent buffer. Otherwise,
122 * the byte is returned directly from the VME file.
123 */
GetByte(void)124 unsigned char GetByte(void)
125 {
126 unsigned char ucData;
127 unsigned int block_size = 4 * 1024;
128
129 if (g_usDataType & HEAP_IN) {
130
131 /*
132 * Get data from repeat buffer.
133 */
134
135 if (g_iHeapCounter > g_iHEAPSize) {
136
137 /*
138 * Data over-run.
139 */
140
141 return 0xFF;
142 }
143
144 ucData = g_pucHeapMemory[g_iHeapCounter++];
145 } else if (g_usDataType & LHEAP_IN) {
146
147 /*
148 * Get data from intel buffer.
149 */
150
151 if (g_usIntelDataIndex >= g_usIntelBufferSize) {
152 return 0xFF;
153 }
154
155 ucData = g_pucIntelBuffer[g_usIntelDataIndex++];
156 } else {
157 if (read_bytes == bufsize) {
158 return 0xFF;
159 }
160 ucData = *fpga_image++;
161 read_bytes++;
162
163 if (!(read_bytes % block_size)) {
164 printf("Downloading FPGA %ld/%ld completed\r",
165 read_bytes,
166 bufsize);
167 }
168
169 if (expectedCRC != 0) {
170 ispVMCalculateCRC32(ucData);
171 }
172 }
173
174 return ucData;
175 }
176
ispVM(void)177 signed char ispVM(void)
178 {
179 char szFileVersion[9] = { 0 };
180 signed char cRetCode = 0;
181 signed char cIndex = 0;
182 signed char cVersionIndex = 0;
183 unsigned char ucReadByte = 0;
184 unsigned short crc;
185
186 g_pucHeapMemory = NULL;
187 g_iHeapCounter = 0;
188 g_iHEAPSize = 0;
189 g_usIntelDataIndex = 0;
190 g_usIntelBufferSize = 0;
191 g_usCalculatedCRC = 0;
192 expectedCRC = 0;
193 ucReadByte = GetByte();
194 switch (ucReadByte) {
195 case FILE_CRC:
196 crc = (unsigned char)GetByte();
197 crc <<= 8;
198 crc |= GetByte();
199 expectedCRC = crc;
200
201 for (cIndex = 0; cIndex < 8; cIndex++)
202 szFileVersion[cIndex] = GetByte();
203
204 break;
205 default:
206 szFileVersion[0] = (signed char) ucReadByte;
207 for (cIndex = 1; cIndex < 8; cIndex++)
208 szFileVersion[cIndex] = GetByte();
209
210 break;
211 }
212
213 /*
214 *
215 * Compare the VME file version against the supported version.
216 *
217 */
218
219 for (cVersionIndex = 0; g_szSupportedVersions[cVersionIndex] != 0;
220 cVersionIndex++) {
221 for (cIndex = 0; cIndex < 8; cIndex++) {
222 if (szFileVersion[cIndex] !=
223 g_szSupportedVersions[cVersionIndex][cIndex]) {
224 cRetCode = VME_VERSION_FAILURE;
225 break;
226 }
227 cRetCode = 0;
228 }
229
230 if (cRetCode == 0) {
231 break;
232 }
233 }
234
235 if (cRetCode < 0) {
236 return VME_VERSION_FAILURE;
237 }
238
239 printf("VME file checked: starting downloading to FPGA\n");
240
241 ispVMStart();
242
243 cRetCode = ispVMCode();
244
245 ispVMEnd();
246 ispVMFreeMem();
247 puts("\n");
248
249 if (cRetCode == 0 && expectedCRC != 0 &&
250 (expectedCRC != g_usCalculatedCRC)) {
251 printf("Expected CRC: 0x%.4X\n", expectedCRC);
252 printf("Calculated CRC: 0x%.4X\n", g_usCalculatedCRC);
253 return VME_CRC_FAILURE;
254 }
255 return cRetCode;
256 }
257
lattice_validate(Lattice_desc * desc,const char * fn)258 static int lattice_validate(Lattice_desc *desc, const char *fn)
259 {
260 int ret_val = false;
261
262 if (desc) {
263 if ((desc->family > min_lattice_type) &&
264 (desc->family < max_lattice_type)) {
265 if ((desc->iface > min_lattice_iface_type) &&
266 (desc->iface < max_lattice_iface_type)) {
267 if (desc->size) {
268 ret_val = true;
269 } else {
270 printf("%s: NULL part size\n", fn);
271 }
272 } else {
273 printf("%s: Invalid Interface type, %d\n",
274 fn, desc->iface);
275 }
276 } else {
277 printf("%s: Invalid family type, %d\n",
278 fn, desc->family);
279 }
280 } else {
281 printf("%s: NULL descriptor!\n", fn);
282 }
283
284 return ret_val;
285 }
286
lattice_load(Lattice_desc * desc,const void * buf,size_t bsize)287 int lattice_load(Lattice_desc *desc, const void *buf, size_t bsize)
288 {
289 int ret_val = FPGA_FAIL;
290
291 if (!lattice_validate(desc, (char *)__func__)) {
292 printf("%s: Invalid device descriptor\n", __func__);
293 } else {
294 pfns = desc->iface_fns;
295
296 switch (desc->family) {
297 case Lattice_XP2:
298 fpga_image = buf;
299 read_bytes = 0;
300 bufsize = bsize;
301 debug("%s: Launching the Lattice ISPVME Loader:"
302 " addr %p size 0x%lx...\n",
303 __func__, fpga_image, bufsize);
304 ret_val = ispVM();
305 if (ret_val)
306 printf("%s: error %d downloading FPGA image\n",
307 __func__, ret_val);
308 else
309 puts("FPGA downloaded successfully\n");
310 break;
311 default:
312 printf("%s: Unsupported family type, %d\n",
313 __func__, desc->family);
314 }
315 }
316
317 return ret_val;
318 }
319
lattice_dump(Lattice_desc * desc,const void * buf,size_t bsize)320 int lattice_dump(Lattice_desc *desc, const void *buf, size_t bsize)
321 {
322 puts("Dump not supported for Lattice FPGA\n");
323
324 return FPGA_FAIL;
325
326 }
327
lattice_info(Lattice_desc * desc)328 int lattice_info(Lattice_desc *desc)
329 {
330 int ret_val = FPGA_FAIL;
331
332 if (lattice_validate(desc, (char *)__func__)) {
333 printf("Family: \t");
334 switch (desc->family) {
335 case Lattice_XP2:
336 puts("XP2\n");
337 break;
338 /* Add new family types here */
339 default:
340 printf("Unknown family type, %d\n", desc->family);
341 }
342
343 puts("Interface type:\t");
344 switch (desc->iface) {
345 case lattice_jtag_mode:
346 puts("JTAG Mode\n");
347 break;
348 /* Add new interface types here */
349 default:
350 printf("Unsupported interface type, %d\n", desc->iface);
351 }
352
353 printf("Device Size: \t%d bytes\n",
354 desc->size);
355
356 if (desc->iface_fns) {
357 printf("Device Function Table @ 0x%p\n",
358 desc->iface_fns);
359 switch (desc->family) {
360 case Lattice_XP2:
361 break;
362 /* Add new family types here */
363 default:
364 break;
365 }
366 } else {
367 puts("No Device Function Table.\n");
368 }
369
370 if (desc->desc)
371 printf("Model: \t%s\n", desc->desc);
372
373 ret_val = FPGA_SUCCESS;
374 } else {
375 printf("%s: Invalid device descriptor\n", __func__);
376 }
377
378 return ret_val;
379 }
380