git.gag.com Git - fw/altos/blob - src/stm-flash/ao_stm_flash.c

   1 /*
   2  * Copyright © 2011 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  16  */
  17
  18 #include "ao.h"
  19 #include <ao_exti.h>
  20 #include <ao_boot.h>
  21 #include <ao_flash_stm.h>
  22
  23 void
  24 ao_panic(uint8_t reason)
  25 {
  26         for (;;);
  27 }
  28
  29 void
  30 ao_application(void)
  31 {
  32         ao_boot_reboot(AO_BOOT_APPLICATION_BASE);
  33 }
  34
  35 static uint32_t
  36 ao_cmd_hex32(void)
  37 {
  38         __pdata uint8_t r = ao_cmd_lex_error;
  39         int8_t  n;
  40         uint32_t v = 0;
  41
  42         ao_cmd_white();
  43         for(;;) {
  44                 n = ao_cmd_hexchar(ao_cmd_lex_c);
  45                 if (n < 0)
  46                         break;
  47                 v = (v << 4) | n;
  48                 r = ao_cmd_success;
  49                 ao_cmd_lex();
  50         }
  51         if (r != ao_cmd_success)
  52                 ao_cmd_status = r;
  53         return v;
  54 }
  55
  56 void
  57 ao_block_erase(void)
  58 {
  59         uint32_t        addr = ao_cmd_hex32();
  60         uint32_t        *p = (uint32_t *) addr;
  61
  62         ao_flash_erase_page(p);
  63 }
  64
  65 void
  66 ao_block_write(void)
  67 {
  68         uint32_t        addr = ao_cmd_hex32();
  69         uint32_t        *p = (uint32_t *) addr;
  70         union {
  71                 uint8_t         data8[256];
  72                 uint32_t        data32[64];
  73         } u;
  74         uint16_t        i;
  75
  76         if (addr < 0x08002000 || 0x08200000 <= addr) {
  77                 puts("Invalid address");
  78                 return;
  79         }
  80         for (i = 0; i < 256; i++)
  81                 u.data8[i] = i;
  82         ao_flash_page(p, u.data32);
  83 }
  84
  85 static void
  86 puthex(uint8_t c)
  87 {
  88         c &= 0xf;
  89         if (c < 10)
  90                 c += '0';
  91         else
  92                 c += 'a' - 10;
  93         putchar (c);
  94 }
  95
  96 void
  97 ao_block_read(void)
  98 {
  99         uint32_t        addr = ao_cmd_hex32();
 100         uint8_t         *p = (uint8_t *) addr;
 101         uint16_t        i;
 102         uint8_t         c;
 103
 104         for (i = 0; i < 256; i++) {
 105                 c = *p++;
 106                 puthex(c);
 107                 puthex(c>>4);
 108                 if ((i & 0xf) == 0xf)
 109                         putchar('\n');
 110         }
 111 }
 112
 113 __code struct ao_cmds ao_flash_cmds[] = {
 114         { ao_application, "a\0Switch to application" },
 115         { ao_block_erase, "e <addr>\0Erase block." },
 116         { ao_block_write, "W <addr>\0Write block. 256 binary bytes follow newline" },
 117         { ao_block_read, "R <addr>\0Read block. Returns 256 bytes" },
 118         { 0, NULL },
 119 };
 120
 121
 122 int
 123 main(void)
 124 {
 125         ao_clock_init();
 126
 127         ao_task_init();
 128
 129         ao_timer_init();
 130 //      ao_dma_init();
 131         ao_cmd_init();
 132 //      ao_exti_init();
 133         ao_usb_init();
 134
 135         ao_cmd_register(&ao_flash_cmds[0]);
 136         ao_cmd_register(&ao_flash_cmds[0]);
 137         ao_start_scheduler();
 138         return 0;
 139 }