OpenCores
URL https://opencores.org/ocsvn/neorv32/neorv32/trunk

Subversion Repositories neorv32

[/] [neorv32/] [trunk/] [sw/] [bootloader/] [bootloader.c] - Blame information for rev 14

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 zero_gravi
// #################################################################################################
2
// # << NEORV32 - Bootloader >>                                                                    #
3
// # ********************************************************************************************* #
4
// # THE BOOTLOADER SHOULD BE COMPILED USING THE BASE ISA ONLY (rv32i or rv32e)!                   #
5
// # ********************************************************************************************* #
6
// # Boot from (internal) instruction memory, UART or SPI Flash.                                   #
7
// #                                                                                               #
8
// # UART configuration: 8N1 at 19200 baud                                                         #
9
// # Boot Flash: 8-bit SPI, 24-bit addresses (like Micron N25Q032A) @ neorv32.spi_csn_o(0)         #
10
// # neorv32.gpio_o(0) is used as high-active status LED.                                          #
11
// #                                                                                               #
12
// # Auto boot sequence after timeout:                                                             #
13
// #  -> Try booting from SPI flash at spi_csn_o(0).                                               #
14
// #  -> Permanently light up status led and freeze if SPI flash booting attempt fails.            #
15
// # ********************************************************************************************* #
16
// # BSD 3-Clause License                                                                          #
17
// #                                                                                               #
18
// # Copyright (c) 2020, Stephan Nolting. All rights reserved.                                     #
19
// #                                                                                               #
20
// # Redistribution and use in source and binary forms, with or without modification, are          #
21
// # permitted provided that the following conditions are met:                                     #
22
// #                                                                                               #
23
// # 1. Redistributions of source code must retain the above copyright notice, this list of        #
24
// #    conditions and the following disclaimer.                                                   #
25
// #                                                                                               #
26
// # 2. Redistributions in binary form must reproduce the above copyright notice, this list of     #
27
// #    conditions and the following disclaimer in the documentation and/or other materials        #
28
// #    provided with the distribution.                                                            #
29
// #                                                                                               #
30
// # 3. Neither the name of the copyright holder nor the names of its contributors may be used to  #
31
// #    endorse or promote products derived from this software without specific prior written      #
32
// #    permission.                                                                                #
33
// #                                                                                               #
34
// # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS   #
35
// # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF               #
36
// # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE    #
37
// # COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #
38
// # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #
39
// # GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    #
40
// # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING     #
41
// # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED  #
42
// # OF THE POSSIBILITY OF SUCH DAMAGE.                                                            #
43
// # ********************************************************************************************* #
44
// # The NEORV32 Processor - https://github.com/stnolting/neorv32              (c) Stephan Nolting #
45
// #################################################################################################
46
 
47
 
48
/**********************************************************************//**
49
 * @file bootloader.c
50
 * @author Stephan Nolting
51
 * @brief Default NEORV32 bootloader. Compile only for rv32i or rv32e (better).
52
 **************************************************************************/
53
 
54
// Libraries
55
#include <stdint.h>
56
#include <neorv32.h>
57
 
58
 
59
/**********************************************************************//**
60
 * @name User configuration
61
 **************************************************************************/
62
/**@{*/
63
/** UART BAUD rate */
64
#define BAUD_RATE              (19200)
65
/** Time until the auto-boot sequence starts (in seconds) */
66 9 zero_gravi
#define AUTOBOOT_TIMEOUT       8
67 2 zero_gravi
/** Bootloader status LED at GPIO output port (0..15) */
68
#define STATUS_LED             (0)
69
/** SPI flash boot image base address */
70 11 zero_gravi
#define SPI_FLASH_BOOT_ADR     (0x00800000)
71 2 zero_gravi
/** SPI flash chip select at spi_csn_o */
72
#define SPI_FLASH_CS           (0)
73
/** Default SPI flash clock prescaler for serial peripheral interface */
74
#define SPI_FLASH_CLK_PRSC     (CLK_PRSC_8)
75
/** SPI flash sector size in bytes */
76
#define SPI_FLASH_SECTOR_SIZE  (64*1024)
77
/**@}*/
78
 
79
 
80
/**********************************************************************//**
81
  Executable stream source select
82
 **************************************************************************/
83
enum EXE_STREAM_SOURCE {
84
  EXE_STREAM_UART  = 0, /**< Get executable via UART */
85
  EXE_STREAM_FLASH = 1  /**< Get executable via SPI flash */
86
};
87
 
88
 
89
/**********************************************************************//**
90
 * Error codes
91
 **************************************************************************/
92
enum ERROR_CODES {
93
  ERROR_SIGNATURE = 0, /**< 0: Wrong signature in executable */
94
  ERROR_SIZE      = 1, /**< 1: Insufficient instruction memory capacity */
95
  ERROR_CHECKSUM  = 2, /**< 2: Checksum error in executable */
96
  ERROR_FLASH     = 3, /**< 3: SPI flash access error */
97
  ERROR_ROM       = 4, /**< 4: Instruction memory is marked as read-only */
98
  ERROR_SYSTEM    = 5  /**< 5: System exception */
99
};
100
 
101
 
102
/**********************************************************************//**
103
 * SPI flash commands
104
 **************************************************************************/
105
enum SPI_FLASH_CMD {
106
  SPI_FLASH_CMD_PAGE_PROGRAM = 0x02, /**< Program page */
107
  SPI_FLASH_CMD_READ         = 0x03, /**< Read data */
108
  SPI_FLASH_CMD_READ_STATUS  = 0x05, /**< Get status register */
109
  SPI_FLASH_CMD_WRITE_ENABLE = 0x06, /**< Allow write access */
110
  SPI_FLASH_CMD_READ_ID      = 0x9E, /**< Read manufacturer ID */
111
  SPI_FLASH_CMD_SECTOR_ERASE = 0xD8  /**< Erase complete sector */
112
};
113
 
114
 
115
/**********************************************************************//**
116
 * NEORV32 executable
117
 **************************************************************************/
118
enum NEORV32_EXECUTABLE {
119
  EXE_OFFSET_SIGNATURE =  0, /**< Offset in bytes from start to signature (32-bit) */
120
  EXE_OFFSET_SIZE      =  4, /**< Offset in bytes from start to size (32-bit) */
121
  EXE_OFFSET_CHECKSUM  =  8, /**< Offset in bytes from start to checksum (32-bit) */
122
  EXE_OFFSET_DATA      = 12, /**< Offset in bytes from start to data (32-bit) */
123
};
124
 
125
 
126
/**********************************************************************//**
127
 * Valid executable identification signature.
128
 **************************************************************************/
129
#define EXE_SIGNATURE 0x4788CAFE
130
 
131
 
132
/**********************************************************************//**
133
 * String output helper macros.
134
 **************************************************************************/
135
/**@{*/
136
/* Actual define-to-string helper */
137
#define xstr(a) str(a)
138
/* Internal helper macro */
139
#define str(a) #a
140
/**@}*/
141
 
142
 
143
// Function prototypes
144
void __attribute__((__interrupt__)) mtime_irq_handler(void);
145
void print_help(void);
146
void start_app(void);
147
void get_exe(int src);
148
void save_exe(void);
149
uint32_t get_exe_word(int src, uint32_t addr);
150
void system_error(uint8_t err_code);
151
void print_hex_word(uint32_t num);
152
 
153
// SPI flash access
154
uint8_t spi_flash_read_byte(uint32_t addr);
155
void spi_flash_write_byte(uint32_t addr, uint8_t wdata);
156
void spi_flash_write_word(uint32_t addr, uint32_t wdata);
157
void spi_flash_erase_sector(uint32_t addr);
158
uint8_t spi_flash_read_status(void);
159
uint8_t spi_flash_read_1st_id(void);
160 4 zero_gravi
void spi_flash_write_enable(void);
161
void spi_flash_write_addr(uint32_t addr);
162 2 zero_gravi
 
163
 
164
/**********************************************************************//**
165
 * Bootloader main.
166
 **************************************************************************/
167
int main(void) {
168
 
169
  // ------------------------------------------------
170
  // Processor hardware initialization
171
  // ------------------------------------------------
172
 
173 11 zero_gravi
  // reset system time
174 12 zero_gravi
  MTIME_LO = 0;
175
  MTIME_HI = 0;
176 11 zero_gravi
 
177 2 zero_gravi
  // deactivate unused IO devices
178 12 zero_gravi
  neorv32_wdt_disable();
179 2 zero_gravi
  neorv32_pwm_disable();
180
  neorv32_spi_disable();
181
  neorv32_trng_disable();
182
  neorv32_twi_disable();
183
 
184
  // get clock speed (in Hz)
185 12 zero_gravi
  uint32_t clock_speed = SYSINFO_CLK;
186 2 zero_gravi
 
187
  // init SPI for 8-bit, clock-mode 0, MSB-first, no interrupt
188
  if (clock_speed < 40000000) {
189
    neorv32_spi_setup(SPI_FLASH_CLK_PRSC, 0, 0, 0, 0);
190
  }
191
  else {
192
    neorv32_spi_setup(CLK_PRSC_128, 0, 0, 0, 0);
193
  }
194
 
195
  // init UART (no interrupts)
196
  neorv32_uart_setup(BAUD_RATE, 0, 0);
197
 
198
  // Configure machine system timer interrupt for ~2Hz
199
  neorv32_mtime_set_timecmp(neorv32_mtime_get_time() + (clock_speed/4));
200
 
201
  // confiure interrupt vector (bare-metal, no neorv32 rte)
202
  neorv32_cpu_csr_write(CSR_MTVEC, (uint32_t)(&mtime_irq_handler));
203
  neorv32_cpu_csr_write(CSR_MIE, 1 << CPU_MIE_MTIE); // activate MTIME IRQ source
204
 
205
  neorv32_cpu_eint(); // enable global interrupts
206
 
207
  // init GPIO
208
  neorv32_gpio_port_set(1 << STATUS_LED); // activate status LED, clear all others
209
 
210
  // abuse mscratch CSR as global variable to store the size of the last uploaded executable
211
  // this CSR must not be used by the bootloader's crt0.S!
212
  neorv32_cpu_csr_write(CSR_MSCRATCH, 0);
213
 
214
 
215
  // ------------------------------------------------
216
  // Show bootloader intro and system info
217
  // ------------------------------------------------
218
  neorv32_uart_print("\n\n\n\n<< NEORV32 Bootloader >>\n\n"
219
                     "BLDV: "__DATE__"\nHWV:  ");
220 12 zero_gravi
  neorv32_rte_print_hw_version();
221 2 zero_gravi
  neorv32_uart_print("\nCLK:  ");
222 12 zero_gravi
  print_hex_word(SYSINFO_CLK);
223
  neorv32_uart_print(" Hz\nUSER: ");
224
  print_hex_word(SYSINFO_USER_CODE);
225 6 zero_gravi
  neorv32_uart_print("\nMISA: ");
226 2 zero_gravi
  print_hex_word(neorv32_cpu_csr_read(CSR_MISA));
227
  neorv32_uart_print("\nCONF: ");
228 12 zero_gravi
  print_hex_word(SYSINFO_FEATURES);
229 2 zero_gravi
  neorv32_uart_print("\nIMEM: ");
230 12 zero_gravi
  print_hex_word(SYSINFO_ISPACE_SIZE);
231 2 zero_gravi
  neorv32_uart_print(" bytes @ ");
232 12 zero_gravi
  print_hex_word(SYSINFO_ISPACE_BASE);
233 2 zero_gravi
  neorv32_uart_print("\nDMEM: ");
234 12 zero_gravi
  print_hex_word(SYSINFO_DSPACE_SIZE);
235 2 zero_gravi
  neorv32_uart_print(" bytes @ ");
236 12 zero_gravi
  print_hex_word(SYSINFO_DSPACE_BASE);
237 2 zero_gravi
 
238
 
239
  // ------------------------------------------------
240
  // Auto boot sequence
241
  // ------------------------------------------------
242
  neorv32_uart_print("\n\nAutoboot in "xstr(AUTOBOOT_TIMEOUT)"s. Press key to abort.\n");
243
 
244 13 zero_gravi
  uint64_t timeout_time = neorv32_mtime_get_time() + (uint64_t)(AUTOBOOT_TIMEOUT * clock_speed);
245
 
246 2 zero_gravi
  while ((UART_DATA & (1 << UART_DATA_AVAIL)) == 0) { // wait for any key to be pressed or timeout
247
 
248
    if (neorv32_mtime_get_time() >= timeout_time) { // timeout? start auto boot sequence
249
      get_exe(EXE_STREAM_FLASH); // try loading from spi flash
250
      neorv32_uart_print("\n");
251
      start_app();
252
    }
253
  }
254
  neorv32_uart_print("Aborted.\n\n");
255
  print_help();
256
 
257
 
258
  // ------------------------------------------------
259
  // Bootloader console
260
  // ------------------------------------------------
261
  while (1) {
262
 
263
    neorv32_uart_print("\nCMD:> ");
264
    char c = neorv32_uart_getc();
265
    neorv32_uart_putc(c); // echo
266
    neorv32_uart_print("\n");
267
 
268
    if (c == 'r') { // restart bootloader
269 12 zero_gravi
      neorv32_cpu_dint(); // disable global interrupts
270
      // jump to beginning of boot ROM
271
      asm volatile ("li t0, %[input_i]; jr t0" :  : [input_i] "i" (BOOTLOADER_BASE_ADDRESS));
272
      while(1); // just for the compiler
273 2 zero_gravi
    }
274
    else if (c == 'h') { // help menu
275
      print_help();
276
    }
277
    else if (c == 'u') { // get executable via UART
278
      get_exe(EXE_STREAM_UART);
279
    }
280
    else if (c == 's') { // program EEPROM from RAM
281
      save_exe();
282
    }
283
    else if (c == 'l') { // get executable from flash
284
      get_exe(EXE_STREAM_FLASH);
285
    }
286
    else if (c == 'e') { // start application program
287
      start_app();
288
    }
289
    else if (c == '?') { // credits
290
      neorv32_uart_print("by Stephan Nolting");
291
    }
292
    else { // unknown command
293
      neorv32_uart_print("Invalid CMD");
294
    }
295
  }
296
 
297 12 zero_gravi
  return 0; // bootloader should never return
298 2 zero_gravi
}
299
 
300
 
301
/**********************************************************************//**
302
 * Print help menu.
303
 **************************************************************************/
304
void print_help(void) {
305
 
306
  neorv32_uart_print("Available CMDs:\n"
307
                     " h: Help\n"
308
                     " r: Restart\n"
309
                     " u: Upload\n"
310
                     " s: Store to flash\n"
311
                     " l: Load from flash\n"
312
                     " e: Execute");
313
}
314
 
315
 
316
/**********************************************************************//**
317
 * Start application program at the beginning of instruction space.
318
 **************************************************************************/
319
void start_app(void) {
320
 
321 4 zero_gravi
  // executable available?
322
  if (neorv32_cpu_csr_read(CSR_MSCRATCH) == 0) {
323
    neorv32_uart_print("No executable available.");
324
    return;
325
  }
326
 
327 2 zero_gravi
  // no need to shutdown or reset the used peripherals
328
  // -> this will be done by application's crt0
329
 
330
  // deactivate IRQs and IRQ sources
331
  neorv32_cpu_dint();
332
  neorv32_cpu_csr_write(CSR_MIE, 0);
333
 
334
  neorv32_uart_print("Booting...\n\n");
335
 
336
  // wait for UART to finish transmitting
337
  while ((UART_CT & (1<<UART_CT_TX_BUSY)) != 0);
338
 
339 12 zero_gravi
  // reset performance counters (to benchmark actual application)
340 14 zero_gravi
  asm volatile ("csrw mcycle,    zero"); // will also clear 'cycle'
341
  asm volatile ("csrw mcycleh,   zero"); // will also clear 'cycleh'
342
  asm volatile ("csrw minstret,  zero"); // will also clear 'instret'
343
  asm volatile ("csrw minstreth, zero"); // will also clear 'instreth'
344 12 zero_gravi
 
345 2 zero_gravi
  // start app at instruction space base address
346 14 zero_gravi
  register uint32_t app_base = SYSINFO_ISPACE_BASE;
347
  asm volatile ("jalr zero, %0" : : "r" (app_base));
348
  while (1);
349 2 zero_gravi
}
350
 
351
 
352
/**********************************************************************//**
353
 * Machine system timer (MTIME) interrupt handler.
354
 * @warning Since we have no runtime environment, we have to use the interrupt attribute here. Here, and only here!
355
 **************************************************************************/
356
void __attribute__((__interrupt__)) mtime_irq_handler(void) {
357
 
358
  // make sure this was caused by MTIME IRQ
359
  uint32_t cause = neorv32_cpu_csr_read(CSR_MCAUSE);
360 14 zero_gravi
  if (cause != TRAP_CODE_MTI) { // raw exception code for MTI
361 2 zero_gravi
    neorv32_uart_print("\n\nEXCEPTION: ");
362
    print_hex_word(cause);
363
    neorv32_uart_print(" @ 0x");
364
    print_hex_word(neorv32_cpu_csr_read(CSR_MEPC));
365
    system_error(ERROR_SYSTEM);
366
    while(1); // freeze
367
  }
368
  else {
369
    // toggle status LED
370
    neorv32_gpio_pin_toggle(STATUS_LED);
371
    // set time for next IRQ
372 12 zero_gravi
    neorv32_mtime_set_timecmp(neorv32_mtime_get_time() + (SYSINFO_CLK/4));
373 2 zero_gravi
  }
374
}
375
 
376
 
377
/**********************************************************************//**
378
 * Get executable stream.
379
 *
380
 * @param src Source of executable stream data. See #EXE_STREAM_SOURCE.
381
 **************************************************************************/
382
void get_exe(int src) {
383
 
384
  // is instruction memory (actually, the IMEM) read-only?
385 12 zero_gravi
  if (SYSINFO_FEATURES & (1 << SYSINFO_FEATURES_MEM_INT_IMEM_ROM)) {
386 2 zero_gravi
    system_error(ERROR_ROM);
387
  }
388
 
389
  // flash image base address
390
  uint32_t addr = SPI_FLASH_BOOT_ADR;
391
 
392
  // get image from flash?
393
  if (src == EXE_STREAM_UART) {
394
    neorv32_uart_print("Awaiting neorv32_exe.bin... ");
395
  }
396
  else {
397
    neorv32_uart_print("Loading... ");
398
 
399
    // check if flash ready (or available at all)
400
    if (spi_flash_read_1st_id() == 0x00) { // manufacturer ID
401
      system_error(ERROR_FLASH);
402
    }
403
  }
404
 
405
  // check if valid image
406
  uint32_t signature = get_exe_word(src, addr + EXE_OFFSET_SIGNATURE);
407
  if (signature != EXE_SIGNATURE) { // signature
408
    system_error(ERROR_SIGNATURE);
409
  }
410
 
411
  // image size and checksum
412
  uint32_t size  = get_exe_word(src, addr + EXE_OFFSET_SIZE); // size in bytes
413
  uint32_t check = get_exe_word(src, addr + EXE_OFFSET_CHECKSUM); // complement sum checksum
414
 
415
  // executable too large?
416 12 zero_gravi
  uint32_t imem_size = SYSINFO_ISPACE_SIZE;
417 2 zero_gravi
  if (size > imem_size) {
418
    system_error(ERROR_SIZE);
419
  }
420
 
421
  // transfer program data
422 12 zero_gravi
  uint32_t *pnt = (uint32_t*)SYSINFO_ISPACE_BASE;
423 2 zero_gravi
  uint32_t checksum = 0;
424
  uint32_t d = 0, i = 0;
425
  addr = addr + EXE_OFFSET_DATA;
426
  while (i < (size/4)) { // in words
427
    d = get_exe_word(src, addr);
428
    checksum += d;
429
    pnt[i++] = d;
430
    addr += 4;
431
  }
432
 
433
/*
434
  // Debugging stuff
435
  neorv32_uart_putc('.');
436
  print_hex_word(signature);
437
  neorv32_uart_putc('.');
438
  print_hex_word(imem_size);
439
  neorv32_uart_putc('.');
440
  print_hex_word(check);
441
  neorv32_uart_putc('.');
442
  print_hex_word(checksum);
443
  neorv32_uart_putc('.');
444
*/
445
 
446
  // error during transfer?
447
  if ((checksum + check) != 0) {
448
    system_error(ERROR_CHECKSUM);
449
  }
450
  else {
451
    neorv32_uart_print("OK");
452
    neorv32_cpu_csr_write(CSR_MSCRATCH, size); // store exe size in "global variable"
453
  }
454
}
455
 
456
 
457
/**********************************************************************//**
458
 * Store content of instruction memory to SPI flash.
459
 **************************************************************************/
460
void save_exe(void) {
461
 
462
  // size of last uploaded executable
463
  uint32_t size = neorv32_cpu_csr_read(CSR_MSCRATCH);
464
 
465
  if (size == 0) {
466
    neorv32_uart_print("No executable available.");
467
    return;
468
  }
469
 
470
  uint32_t addr = SPI_FLASH_BOOT_ADR;
471
 
472
  // info and prompt
473
  neorv32_uart_print("Write 0x");
474
  print_hex_word(size);
475
  neorv32_uart_print(" bytes to SPI flash @ 0x");
476
  print_hex_word(addr);
477
  neorv32_uart_print("? (y/n) ");
478
 
479
  char c = neorv32_uart_getc();
480
  neorv32_uart_putc(c);
481
  if (c != 'y') {
482
    return;
483
  }
484
 
485
  // check if flash ready (or available at all)
486
  if (spi_flash_read_1st_id() == 0x00) { // manufacturer ID
487
    system_error(ERROR_FLASH);
488
  }
489
 
490
  neorv32_uart_print("\nFlashing... ");
491
 
492
  // clear memory before writing
493
  uint32_t num_sectors = (size / SPI_FLASH_SECTOR_SIZE) + 1; // clear at least 1 sector
494
  uint32_t sector = SPI_FLASH_BOOT_ADR;
495
  while (num_sectors--) {
496
    spi_flash_erase_sector(sector);
497
    sector += SPI_FLASH_SECTOR_SIZE;
498
  }
499
 
500
  // write EXE signature
501
  spi_flash_write_word(addr + EXE_OFFSET_SIGNATURE, EXE_SIGNATURE);
502
 
503
  // write size
504
  spi_flash_write_word(addr + EXE_OFFSET_SIZE, size);
505
 
506
  // store data from instruction memory and update checksum
507
  uint32_t checksum = 0;
508 12 zero_gravi
  uint32_t *pnt = (uint32_t*)SYSINFO_ISPACE_BASE;
509 2 zero_gravi
  addr = addr + EXE_OFFSET_DATA;
510
  uint32_t i = 0;
511
  while (i < (size/4)) { // in words
512
    uint32_t d = (uint32_t)*pnt++;
513
    checksum += d;
514
    spi_flash_write_word(addr, d);
515
    addr += 4;
516
    i++;
517
//  if ((i & 0x000000FF) == 0) {
518
//    neorv32_uart_putc('.');
519
//  }
520
  }
521
 
522
  // write checksum (sum complement)
523
  checksum = (~checksum) + 1;
524
  spi_flash_write_word(SPI_FLASH_BOOT_ADR + EXE_OFFSET_CHECKSUM, checksum);
525
 
526
  neorv32_uart_print("OK");
527
}
528
 
529
 
530
/**********************************************************************//**
531
 * Get word from executable stream
532
 *
533
 * @param src Source of executable stream data. See #EXE_STREAM_SOURCE.
534
 * @param addr Address when accessing SPI flash.
535
 * @return 32-bit data word from stream.
536
 **************************************************************************/
537
uint32_t get_exe_word(int src, uint32_t addr) {
538
 
539
  union {
540
    uint32_t uint32;
541
    uint8_t  uint8[sizeof(uint32_t)];
542
  } data;
543
 
544
  uint32_t i;
545
  for (i=0; i<4; i++) {
546
    if (src == EXE_STREAM_UART) {
547
      data.uint8[3-i] = (uint8_t)neorv32_uart_getc();
548
    }
549
    else {
550
      data.uint8[3-i] = spi_flash_read_byte(addr + i);
551
    }
552
  }
553
 
554
  return data.uint32;
555
}
556
 
557
 
558
/**********************************************************************//**
559
 * Output system error ID and stall.
560
 *
561
 * @param[in] err_code Error code. See #ERROR_CODES.
562
 **************************************************************************/
563
void system_error(uint8_t err_code) {
564
 
565
  neorv32_uart_print("\a\nERR_"); // output error code with annoying bell sound
566
  if (err_code <= ERROR_SYSTEM) {
567
    neorv32_uart_putc('0' + ((char)err_code));
568
  }
569
  else {
570
    neorv32_uart_print("unknown");
571
  }
572
 
573
  neorv32_cpu_dint(); // deactivate IRQs
574
  neorv32_gpio_port_set(1 << STATUS_LED); // permanently light up status LED
575
 
576 13 zero_gravi
  asm volatile ("wfi"); // power-down
577 2 zero_gravi
  while(1); // freeze
578
}
579
 
580
 
581
/**********************************************************************//**
582
 * Print 32-bit number as 8-digit hexadecimal value (with "0x" suffix).
583
 *
584
 * @param[in] num Number to print as hexadecimal.
585
 **************************************************************************/
586
void print_hex_word(uint32_t num) {
587
 
588
  static const char hex_symbols[16] = "0123456789ABCDEF";
589
 
590
  neorv32_uart_print("0x");
591
 
592
  int i;
593
  for (i=0; i<8; i++) {
594
    uint32_t index = (num >> (28 - 4*i)) & 0xF;
595
    neorv32_uart_putc(hex_symbols[index]);
596
  }
597
}
598
 
599
 
600
 
601
// -------------------------------------------------------------------------------------
602
// SPI flash functions
603
// -------------------------------------------------------------------------------------
604
 
605
/**********************************************************************//**
606
 * Read byte from SPI flash.
607
 *
608
 * @param[in] addr Flash read address.
609
 * @return Read byte from SPI flash.
610
 **************************************************************************/
611
uint8_t spi_flash_read_byte(uint32_t addr) {
612
 
613
  neorv32_spi_cs_en(SPI_FLASH_CS);
614
 
615
  neorv32_spi_trans(SPI_FLASH_CMD_READ);
616 4 zero_gravi
  spi_flash_write_addr(addr);
617 2 zero_gravi
  uint8_t rdata = (uint8_t)neorv32_spi_trans(0);
618
 
619
  neorv32_spi_cs_dis(SPI_FLASH_CS);
620
 
621
  return rdata;
622
}
623
 
624
 
625
/**********************************************************************//**
626
 * Write byte to SPI flash.
627
 *
628
 * @param[in] addr SPI flash read address.
629
 * @param[in] wdata SPI flash read data.
630
 **************************************************************************/
631
void spi_flash_write_byte(uint32_t addr, uint8_t wdata) {
632
 
633 4 zero_gravi
  spi_flash_write_enable(); // allow write-access
634 2 zero_gravi
 
635
  neorv32_spi_cs_en(SPI_FLASH_CS);
636
 
637
  neorv32_spi_trans(SPI_FLASH_CMD_PAGE_PROGRAM);
638 4 zero_gravi
  spi_flash_write_addr(addr);
639 2 zero_gravi
  neorv32_spi_trans(wdata);
640
 
641
  neorv32_spi_cs_dis(SPI_FLASH_CS);
642
 
643
  while (1) {
644
    uint8_t tmp = spi_flash_read_status();
645
    if ((tmp & 0x01) == 0) { // write in progress flag cleared?
646
      break;
647
    }
648
  }
649
}
650
 
651
 
652
/**********************************************************************//**
653
 * Write word to SPI flash.
654
 *
655
 * @param addr SPI flash write address.
656
 * @param wdata SPI flash write data.
657
 **************************************************************************/
658
void spi_flash_write_word(uint32_t addr, uint32_t wdata) {
659
 
660
  union {
661
    uint32_t uint32;
662
    uint8_t  uint8[sizeof(uint32_t)];
663
  } data;
664
 
665
  data.uint32 = wdata;
666
 
667
  uint32_t i;
668
  for (i=0; i<4; i++) {
669
    spi_flash_write_byte(addr + i, data.uint8[3-i]);
670
  }
671
}
672
 
673
 
674
/**********************************************************************//**
675
 * Erase sector (64kB) at base adress.
676
 *
677
 * @param[in] addr Base address of sector to erase.
678
 **************************************************************************/
679
void spi_flash_erase_sector(uint32_t addr) {
680
 
681 4 zero_gravi
  spi_flash_write_enable(); // allow write-access
682 2 zero_gravi
 
683
  neorv32_spi_cs_en(SPI_FLASH_CS);
684
 
685
  neorv32_spi_trans(SPI_FLASH_CMD_SECTOR_ERASE);
686 4 zero_gravi
  spi_flash_write_addr(addr);
687 2 zero_gravi
 
688
  neorv32_spi_cs_dis(SPI_FLASH_CS);
689
 
690
  while (1) {
691
    uint8_t tmp = spi_flash_read_status();
692
    if ((tmp & 0x01) == 0) { // write in progress flag cleared?
693
      break;
694
    }
695
  }
696
}
697
 
698
 
699
/**********************************************************************//**
700
 * Read status register.
701
 *
702
 * @return Status register.
703
 **************************************************************************/
704
uint8_t spi_flash_read_status(void) {
705
 
706
  neorv32_spi_cs_en(SPI_FLASH_CS);
707
 
708
  neorv32_spi_trans(SPI_FLASH_CMD_READ_STATUS);
709
  uint8_t status = (uint8_t)neorv32_spi_trans(0);
710
 
711
  neorv32_spi_cs_dis(SPI_FLASH_CS);
712
 
713
  return status;
714
}
715
 
716
 
717
/**********************************************************************//**
718
 * Read first byte of ID (manufacturer ID), should be != 0x00.
719
 *
720
 * @note The first bit of the manufacturer ID is used to detect if a Flash is connected at all.
721
 *
722
 * @return First byte of ID.
723
 **************************************************************************/
724
uint8_t spi_flash_read_1st_id(void) {
725
 
726
  neorv32_spi_cs_en(SPI_FLASH_CS);
727
 
728
  neorv32_spi_trans(SPI_FLASH_CMD_READ_ID);
729
  uint8_t id = (uint8_t)neorv32_spi_trans(0);
730
 
731
  neorv32_spi_cs_dis(SPI_FLASH_CS);
732
 
733
  return id;
734
}
735
 
736
 
737
/**********************************************************************//**
738 4 zero_gravi
 * Enable flash write access.
739 2 zero_gravi
 **************************************************************************/
740 4 zero_gravi
void spi_flash_write_enable(void) {
741 2 zero_gravi
 
742
  neorv32_spi_cs_en(SPI_FLASH_CS);
743 4 zero_gravi
  neorv32_spi_trans(SPI_FLASH_CMD_WRITE_ENABLE);
744
  neorv32_spi_cs_dis(SPI_FLASH_CS);
745
}
746 2 zero_gravi
 
747
 
748 4 zero_gravi
/**********************************************************************//**
749
 * Send address word to flash.
750
 *
751
 * @param[in] addr Address word.
752
 **************************************************************************/
753
void spi_flash_write_addr(uint32_t addr) {
754
 
755
  union {
756
    uint32_t uint32;
757
    uint8_t  uint8[sizeof(uint32_t)];
758
  } address;
759
 
760
  address.uint32 = addr;
761
 
762
  neorv32_spi_trans(address.uint8[2]);
763
  neorv32_spi_trans(address.uint8[1]);
764
  neorv32_spi_trans(address.uint8[0]);
765 2 zero_gravi
}
766
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.