diff --git a/trunk/src/fw_downloader.cpp b/trunk/src/fw_downloader.cpp
index ca8a6ce01acdcfae8c4b5e8975f1c7b92dbbe106..85ed7fee8e6d64ae4631867ec4b83cf996b51cad 100755
--- a/trunk/src/fw_downloader.cpp
+++ b/trunk/src/fw_downloader.cpp
@@ -21,20 +21,21 @@ void show_help(char *name) {
" -v Verify writes\n"
" -g address Start execution at specified address (0 = flash start)\n"
" -h Show this help\n"
- " -d device serial device name\n"
+ " -s serial_port serial device name\n"
+ " -d device STM32 device to program\n"
"\n"
"Examples:\n"
" Get device information:\n"
- " %s /dev/ttyS0\n"
+ " %s -s /dev/ttyS0\n"
"\n"
" Write with verify and then start execution:\n"
- " %s -w filename -v -g 0x0 /dev/ttyS0\n"
+ " %s -w filename -v -g 0x0 -s /dev/ttyS0\n"
"\n"
" Read flash to file:\n"
- " %s -r filename /dev/ttyS0\n"
+ " %s -r filename -s /dev/ttyS0\n"
"\n"
" Start execution:\n"
- " %s -g 0x0 /dev/ttyS0\n",
+ " %s -g 0x0 -s /dev/ttyS0\n",
name,
name,
name,
@@ -50,10 +51,12 @@ int main(int argc,char *argv[])
unsigned short int erase_pages=0xFFFF,device_id;
unsigned char bootloader_ver,buffer[256];
flash_op operation=flash_none;
+ const stm32_bl *bootloader_info;
const stm32_dev *device_info;
bool verify=false,done=false;
bool start_exec=false;
std::string device="";
+ std::string device_name="";
std::string filename;
stm32_cmd commands;
off_t offset = 0;
@@ -62,7 +65,7 @@ int main(int argc,char *argv[])
int option;
/* parse the input arguments */
- while((option = getopt(argc, argv, "b:r:w:e:vg:hd:")) != -1) {
+ while((option = getopt(argc, argv, "b:r:w:e:vg:hd:s:")) != -1) {
switch(option) {
case 'b':
baudrate=strtoul(optarg,NULL,10);
@@ -102,21 +105,30 @@ int main(int argc,char *argv[])
start_exec = true;
start_addr = strtoul(optarg, NULL, 0);
break;
- case 'd':
+ case 's':
device=optarg;
break;
+ case 'd':
+ device_name=optarg;
+ break;
case 'h':
show_help(argv[0]);
return 1;
}
}
- if (device.size() == 0) {
- std::cout << "ERROR: Device not specified\n" << std::endl;
+ if (device.size() == 0)
+ {
+ std::cout << "ERROR: Serial device not specified\n" << std::endl;
+ show_help(argv[0]);
+ return 1;
+ }
+ if (device_name.size() == 0)
+ {
+ std::cout << "ERROR: STM32 device not specified\n" << std::endl;
show_help(argv[0]);
return 1;
}
-
/* open and config the serial port */
try{
stm32_init(device,baudrate);
@@ -125,14 +137,26 @@ int main(int argc,char *argv[])
stm32_get_commands(&commands);
stm32_get_bootloader_ver(&bootloader_ver);
std::cout << "bootloader version: 0x" << std::hex << (int)bootloader_ver << std::endl;
- stm32_get_chip_id(&device_id);
+ if(!stm32_get_chip_id(&device_id))
+ {
+ std::cout << "Unknown device family product ID" << std::endl;
+ return 1;
+ }
std::cout << "product id: 0x" << std::hex << device_id << std::endl;
- stm32_get_chip_info(&device_info);
- std::cout << "device name: " << device_info->name << std::endl;
- std::cout << "RAM : " << std::dec << (device_info->ram_end - 0x20000000) / 1024 << "KiB (" << device_info->ram_start - 0x20000000 << "b reserved by bootloader)" << std::endl;
- std::cout << "Flash : " << std::dec << (device_info->fl_end - device_info->fl_start) / 1024 << "KiB (sector size: " << device_info->fl_pps << "x" << device_info->fl_ps << ")" << std::endl;
- std::cout << "Option RAM : " << std::dec << device_info->opt_end - device_info->opt_start << "b" << std::endl;
- std::cout << "System RAM : " << std::dec << (device_info->mem_end - device_info->mem_start) / 1024 << "KiB" << std::endl;
+ stm32_get_chip_info(&bootloader_info);
+ if(!stm32_get_device_info(device_name,&device_info))
+ {
+ std::cout << "Unknown device " << device_name << std::endl;
+ return 1;
+ }
+ if(device_info->pid!=device_id)
+ {
+ std::cout << "The desired device does not match the detected family" << std::endl;
+ return 1;
+ }
+ std::cout << "device name: " << bootloader_info->name << std::endl;
+ std::cout << "RAM : " << std::dec << (bootloader_info->ram_end+1 - 0x20000000) / 1024 << "KiB (" << bootloader_info->ram_start - 0x20000000 << "b reserved by bootloader)" << std::endl;
+ std::cout << "System RAM : " << std::dec << (bootloader_info->mem_end+1 - bootloader_info->mem_start) / 1024 << "KiB" << std::endl;
// perform desired operation
switch(operation)
{
@@ -172,13 +196,13 @@ int main(int argc,char *argv[])
done=hex_get_first_segment(hex_file,&base,&data_len);
while(!done)
{
- if(base<device_info->fl_start)
+ if(base<0x08000000)
{
std::cout << "Start address not in FLASH" << std::endl;
hex_close(hex_file);
return 1;
}
- if((base+data_len)>device_info->fl_end)
+ if((base+data_len)>0x08000000+device_info->flash_size*1024)
{
std::cout << "End address not in FLASH" << std::endl;
hex_close(hex_file);
@@ -217,8 +241,8 @@ int main(int argc,char *argv[])
std::cout << std::endl;
if(start_exec)
{
- std::cout << "starting execution at 0x" << std::hex << start_addr+device_info->fl_start << std::endl;
- stm32_start_exec(start_addr+device_info->fl_start);
+ std::cout << "starting execution at 0x" << std::hex << start_addr+0x08000000 << std::endl;
+ stm32_start_exec(start_addr+0x08000000);
}
break;
diff --git a/trunk/src/stm32.cpp b/trunk/src/stm32.cpp
index 90dba61aa408b524bb096bacbc9243904c4d0619..3489f31a66a76a4dbdd6968fc5b4dab091aaaec2 100755
--- a/trunk/src/stm32.cpp
+++ b/trunk/src/stm32.cpp
@@ -5,24 +5,471 @@
#include "eventexceptions.h"
// private variables
-/* device table */
const stm32_dev devices[] = {
- {0x412, "Low-density" , 0x20000200, 0x20002800, 0x08000000, 0x08008000, 4, 1024, 0x1FFFF800, 0x1FFFF80F, 0x1FFFF000, 0x1FFFF800},
- {0x410, "Medium-density" , 0x20000200, 0x20005000, 0x08000000, 0x08020000, 4, 1024, 0x1FFFF800, 0x1FFFF80F, 0x1FFFF000, 0x1FFFF800},
- {0x411, "STM32F2xx" , 0x20002000, 0x20020000, 0x08000000, 0x08100000, 4, 16384, 0x1FFFC000, 0x1FFFC00F, 0x1FFF0000, 0x1FFF77DF},
- {0x413, "STM32F4xx" , 0x20002000, 0x20020000, 0x08000000, 0x08100000, 4, 16384, 0x1FFFC000, 0x1FFFC00F, 0x1FFF0000, 0x1FFF77DF},
- {0x414, "High-density" , 0x20000200, 0x20010000, 0x08000000, 0x08080000, 2, 2048, 0x1FFFF800, 0x1FFFF80F, 0x1FFFF000, 0x1FFFF800},
- {0x418, "Connectivity line", 0x20001000, 0x20010000, 0x08000000, 0x08040000, 2, 2048, 0x1FFFF800, 0x1FFFF80F, 0x1FFFB000, 0x1FFFF800},
- {0x420, "Medium-density VL", 0x20000200, 0x20002000, 0x08000000, 0x08020000, 4, 1024, 0x1FFFF800, 0x1FFFF80F, 0x1FFFF000, 0x1FFFF800},
- {0x430, "XL-density" , 0x20000800, 0x20018000, 0x08000000, 0x08100000, 2, 2048, 0x1FFFF800, 0x1FFFF80F, 0x1FFFE000, 0x1FFFF800},
- {0x0}
+{"STM32F030C6",0x444,32,4},
+{"STM32F030C8",0x440,64,8},
+{"STM32F030CC",0x444,256,32},
+{"STM32F030F4",0x440,16,4},
+{"STM32F030K6",0x444,32,4},
+{"STM32F030R8",0x444,64,8},
+{"STM32F030RC",0x444,256,32},
+{"STM32F031C4",0x440,16,4},
+{"STM32F031C6",0x444,32,4},
+{"STM32F031F4",0x440,16,4},
+{"STM32F031F6",0x444,32,4},
+{"STM32F031G4",0x440,16,4},
+{"STM32F031G6",0x444,32,4},
+{"STM32F031K4",0x440,16,4},
+{"STM32F031K6",0x444,32,4},
+{"STM32F038C6",0x444,32,4},
+{"STM32F038F6",0x444,32,4},
+{"STM32F038G6",0x444,32,4},
+{"STM32F038K6",0x444,32,4},
+{"STM32F042C4",0x445,16,6},
+{"STM32F042C6",0x445,32,6},
+{"STM32F042F4",0x445,16,6},
+{"STM32F042F6",0x445,32,6},
+{"STM32F042G4",0x445,16,6},
+{"STM32F042G6",0x445,32,6},
+{"STM32F042K4",0x445,16,6},
+{"STM32F042K6",0x445,32,6},
+{"STM32F042T6",0x445,32,6},
+{"STM32F051C4",0x440,16,8},
+{"STM32F051C6",0x440,32,8},
+{"STM32F051C8",0x440,64,8},
+{"STM32F051K4",0x440,16,8},
+{"STM32F051K6",0x440,32,8},
+{"STM32F051K8",0x440,64,8},
+{"STM32F051R4",0x440,16,8},
+{"STM32F051R6",0x440,32,8},
+{"STM32F051R8",0x440,64,8},
+{"STM32F070C6",0x448,32,6},
+{"STM32F070CB",0x448,128,16},
+{"STM32F070F6",0x448,32,6},
+{"STM32F070RB",0x448,128,16},
+{"STM32F071CB",0x448,128,16},
+{"STM32F071RB",0x448,128,16},
+{"STM32F071V8",0x448,64,16},
+{"STM32F071VB",0x448,128,16},
+{"STM32F072C8",0x448,64,16},
+{"STM32F072CB",0x448,128,16},
+{"STM32F072R8",0x448,64,16},
+{"STM32F072RB",0x448,128,16},
+{"STM32F072V8",0x448,64,16},
+{"STM32F072VB",0x448,128,16},
+{"STM32F078CB",0x448,128,16},
+{"STM32F078RB",0x448,128,16},
+{"STM32F078VB",0x448,128,16},
+{"STM32F100C4",0x420,16,4},
+{"STM32F100C6",0x420,32,4},
+{"STM32F100C8",0x420,64,8},
+{"STM32F100CB",0x420,128,8},
+{"STM32F100R4",0x420,16,4},
+{"STM32F100R6",0x420,32,4},
+{"STM32F100R8",0x420,64,8},
+{"STM32F100RB",0x420,128,8},
+{"STM32F100RC",0x428,256,24},
+{"STM32F100RD",0x428,384,32},
+{"STM32F100RE",0x428,512,32},
+{"STM32F100V8",0x420,64,8},
+{"STM32F100VB",0x420,128,8},
+{"STM32F100VC",0x428,256,24},
+{"STM32F100VD",0x428,384,32},
+{"STM32F100VE",0x428,512,32},
+{"STM32F100ZC",0x428,256,24},
+{"STM32F100ZD",0x428,384,32},
+{"STM32F100ZE",0x428,512,32},
+{"STM32F101C6",0x412,32,6},
+{"STM32F101C8",0x410,64,10},
+{"STM32F101CB",0x410,128,16},
+{"STM32F101R4",0x412,16,4},
+{"STM32F101R6",0x412,32,6},
+{"STM32F101R8",0x410,64,10},
+{"STM32F101RB",0x410,128,16},
+{"STM32F101RC",0x414,256,32},
+{"STM32F101RD",0x414,384,48},
+{"STM32F101RE",0x414,512,48},
+{"STM32F101RF",0x430,768,80},
+{"STM32F101RG",0x430,1024,80},
+{"STM32F101T4",0x412,16,4},
+{"STM32F101T6",0x412,32,6},
+{"STM32F101T8",0x410,64,10},
+{"STM32F101TB",0x410,128,16},
+{"STM32F101V8",0x410,64,10},
+{"STM32F101VB",0x410,128,16},
+{"STM32F101VC",0x414,256,32},
+{"STM32F101VD",0x414,384,48},
+{"STM32F101VE",0x414,512,48},
+{"STM32F101VF",0x430,768,80},
+{"STM32F101VG",0x430,1024,80},
+{"STM32F101ZC",0x414,256,32},
+{"STM32F101ZD",0x414,384,48},
+{"STM32F101ZE",0x414,512,48},
+{"STM32F101ZF",0x430,768,80},
+{"STM32F101ZG",0x430,1024,80},
+{"STM32F102C4",0x412,16,4},
+{"STM32F102C6",0x412,32,6},
+{"STM32F102C8",0x410,64,10},
+{"STM32F102CB",0x410,128,16},
+{"STM32F102R4",0x412,16,4},
+{"STM32F102R6",0x412,32,6},
+{"STM32F102R8",0x410,64,10},
+{"STM32F102RB",0x410,128,16},
+{"STM32F103C4",0x412,16,6},
+{"STM32F103C6",0x412,32,10},
+{"STM32F103C8",0x410,64,20},
+{"STM32F103CB",0x410,128,20},
+{"STM32F103R4",0x412,16,6},
+{"STM32F103R6",0x412,32,10},
+{"STM32F103R8",0x410,64,20},
+{"STM32F103RB",0x410,128,20},
+{"STM32F103RC",0x414,256,48},
+{"STM32F103RD",0x414,384,64},
+{"STM32F103RE",0x414,512,64},
+{"STM32F103RF",0x430,768,96},
+{"STM32F103RG",0x430,1024,96},
+{"STM32F103T4",0x412,16,6},
+{"STM32F103T6",0x412,32,10},
+{"STM32F103T8",0x410,64,20},
+{"STM32F103TB",0x410,128,20},
+{"STM32F103V8",0x410,64,20},
+{"STM32F103VB",0x410,128,20},
+{"STM32F103VC",0x414,256,48},
+{"STM32F103VD",0x414,384,64},
+{"STM32F103VE",0x414,512,64},
+{"STM32F103VF",0x430,768,96},
+{"STM32F103VG",0x430,1024,96},
+{"STM32F103ZC",0x414,256,48},
+{"STM32F103ZD",0x414,384,64},
+{"STM32F103ZE",0x414,512,64},
+{"STM32F103ZF",0x430,768,96},
+{"STM32F103ZG",0x430,1024,96},
+{"STM32F105R8",0x418,64,64},
+{"STM32F105RB",0x418,128,64},
+{"STM32F105RC",0x418,256,64},
+{"STM32F105V8",0x418,64,64},
+{"STM32F105VB",0x418,128,64},
+{"STM32F105VC",0x418,256,64},
+{"STM32F107RB",0x418,128,64},
+{"STM32F107RC",0x418,256,64},
+{"STM32F107VB",0x418,128,64},
+{"STM32F107VC",0x418,256,64},
+{"STM32F205RB",0x411,128,64},
+{"STM32F205RC",0x411,256,96},
+{"STM32F205RE",0x411,512,128},
+{"STM32F205RF",0x411,768,128},
+{"STM32F205RG",0x411,1024,128},
+{"STM32F205VB",0x411,128,64},
+{"STM32F205VC",0x411,256,96},
+{"STM32F205VE",0x411,512,128},
+{"STM32F205VF",0x411,768,128},
+{"STM32F205VG",0x411,1024,128},
+{"STM32F205ZC",0x411,256,96},
+{"STM32F205ZE",0x411,512,128},
+{"STM32F205ZF",0x411,768,128},
+{"STM32F205ZG",0x411,1024,128},
+{"STM32F207IC",0x411,256,128},
+{"STM32F207IE",0x411,512,128},
+{"STM32F207IF",0x411,768,128},
+{"STM32F207IG",0x411,1024,128},
+{"STM32F207VC",0x411,256,128},
+{"STM32F207VE",0x411,512,128},
+{"STM32F207VF",0x411,768,128},
+{"STM32F207VG",0x411,1024,128},
+{"STM32F207ZC",0x411,256,128},
+{"STM32F207ZE",0x411,512,128},
+{"STM32F207ZF",0x411,768,128},
+{"STM32F207ZG",0x411,1024,128},
+{"STM32F215RE",0x411,512,128},
+{"STM32F215RG",0x411,1024,128},
+{"STM32F215VE",0x411,512,128},
+{"STM32F215VG",0x411,1024,128},
+{"STM32F215ZE",0x411,512,128},
+{"STM32F215ZG",0x411,1024,128},
+{"STM32F217IE",0x411,512,128},
+{"STM32F217IG",0x411,1024,128},
+{"STM32F217VE",0x411,512,128},
+{"STM32F217VG",0x411,1024,128},
+{"STM32F217ZE",0x411,512,128},
+{"STM32F217ZG",0x411,1024,128},
+{"STM32F301C6",0x439,32,16},
+{"STM32F301C8",0x439,64,16},
+{"STM32F301K6",0x439,32,16},
+{"STM32F301K8",0x439,64,16},
+{"STM32F301R6",0x439,32,16},
+{"STM32F301R8",0x439,64,16},
+{"STM32F302C6",0x439,32,16},
+{"STM32F302C8",0x439,64,16},
+{"STM32F302CB",0x422,128,32},
+{"STM32F302CC",0x422,256,40},
+{"STM32F302K6",0x439,32,16},
+{"STM32F302K8",0x439,64,16},
+{"STM32F302R6",0x439,32,16},
+{"STM32F302R8",0x439,64,16},
+{"STM32F302RB",0x422,128,32},
+{"STM32F302RC",0x422,256,40},
+{"STM32F302VB",0x422,128,32},
+{"STM32F302VC",0x422,256,40},
+{"STM32F303C6",0x438,32,16},
+{"STM32F303C8",0x438,64,16},
+{"STM32F303CB",0x422,128,40},
+{"STM32F303CC",0x422,256,48},
+{"STM32F303K6",0x438,32,16},
+{"STM32F303K8",0x438,64,16},
+{"STM32F303R6",0x438,32,16},
+{"STM32F303R8",0x438,64,16},
+{"STM32F303RB",0x422,128,40},
+{"STM32F303RC",0x422,256,48},
+{"STM32F303VB",0x422,128,40},
+{"STM32F303VC",0x422,256,48},
+{"STM32F318C8",0x439,64,16},
+{"STM32F318K8",0x439,64,16},
+{"STM32F328C8",0x438,64,16},
+{"STM32F334C4",0x438,16,16},
+{"STM32F334C6",0x438,32,10},
+{"STM32F334C8",0x438,64,16},
+{"STM32F334K4",0x438,16,16},
+{"STM32F334K6",0x438,32,10},
+{"STM32F334K8",0x438,64,12},
+{"STM32F334R6",0x438,32,10},
+{"STM32F334R8",0x438,64,16},
+{"STM32F358CC",0x422,256,48},
+{"STM32F358RC",0x422,256,48},
+{"STM32F358VC",0x422,256,48},
+{"STM32F373C8",0x432,64,16},
+{"STM32F373CB",0x432,128,24},
+{"STM32F373CC",0x432,256,32},
+{"STM32F373R8",0x432,64,16},
+{"STM32F373RB",0x432,128,24},
+{"STM32F373RC",0x432,256,32},
+{"STM32F373V8",0x432,64,16},
+{"STM32F373VB",0x432,128,24},
+{"STM32F373VC",0x432,256,32},
+{"STM32F378CC",0x432,256,32},
+{"STM32F378RC",0x432,256,32},
+{"STM32F378VC",0x432,256,32},
+{"STM32F401CB",0x423,128,64},
+{"STM32F401CC",0x423,256,64},
+{"STM32F401CD",0x433,384,96},
+{"STM32F401CE",0x433,512,96},
+{"STM32F401RB",0x423,128,64},
+{"STM32F401RC",0x423,256,64},
+{"STM32F401RD",0x433,384,96},
+{"STM32F401RE",0x433,512,96},
+{"STM32F401VB",0x423,128,64},
+{"STM32F401VC",0x423,256,64},
+{"STM32F401VD",0x433,384,96},
+{"STM32F401VE",0x433,512,96},
+{"STM32F405OE",0x413,512,192},
+{"STM32F405OG",0x413,1024,192},
+{"STM32F405RG",0x413,1024,192},
+{"STM32F405VG",0x413,1024,192},
+{"STM32F405ZG",0x413,1024,192},
+{"STM32F407IE",0x413,512,192},
+{"STM32F407IG",0x413,1024,192},
+{"STM32F407VE",0x413,512,192},
+{"STM32F407VG",0x413,1024,192},
+{"STM32F407ZE",0x413,512,192},
+{"STM32F407ZG",0x413,1024,192},
+{"STM32F411CC",0x413,256,128},
+{"STM32F411CE",0x431,512,128},
+{"STM32F411RC",0x413,256,128},
+{"STM32F411RE",0x431,512,128},
+{"STM32F411VC",0x413,256,128},
+{"STM32F411VE",0x431,512,128},
+{"STM32F415OG",0x413,1024,192},
+{"STM32F415RG",0x413,1024,192},
+{"STM32F415VG",0x413,1024,192},
+{"STM32F415ZG",0x413,1024,192},
+{"STM32F417IE",0x413,512,192},
+{"STM32F417IG",0x413,1024,192},
+{"STM32F417VE",0x413,512,192},
+{"STM32F417VG",0x413,1024,192},
+{"STM32F417ZE",0x413,512,192},
+{"STM32F417ZG",0x413,1024,192},
+{"STM32F427AG",0x413,1024,256},
+{"STM32F427AI",0x413,2048,256},
+{"STM32F427IG",0x413,1024,256},
+{"STM32F427II",0x413,2048,256},
+{"STM32F427VG",0x413,1024,256},
+{"STM32F427VI",0x413,2048,256},
+{"STM32F427ZG",0x413,1024,256},
+{"STM32F427ZI",0x413,2048,256},
+{"STM32F429AG",0x419,1024,256},
+{"STM32F429AI",0x419,2048,256},
+{"STM32F429BE",0x419,512,256},
+{"STM32F429BG",0x419,1024,256},
+{"STM32F429BI",0x419,2048,256},
+{"STM32F429IE",0x419,512,256},
+{"STM32F429IG",0x419,1024,256},
+{"STM32F429II",0x419,2048,256},
+{"STM32F429NE",0x419,512,256},
+{"STM32F429NI",0x419,2048,256},
+{"STM32F429VE",0x419,512,256},
+{"STM32F429VG",0x419,1024,256},
+{"STM32F429VI",0x419,2048,256},
+{"STM32F429ZE",0x419,512,256},
+{"STM32F429ZG",0x419,1024,256},
+{"STM32F429ZI",0x419,2048,256},
+{"STM32F439AI",0x419,2048,256},
+{"STM32F439BG",0x419,1024,256},
+{"STM32F439BI",0x419,2048,256},
+{"STM32F439IG",0x419,1024,256},
+{"STM32F439II",0x419,2048,256},
+{"STM32F439NG",0x419,1024,256},
+{"STM32F439NI",0x419,2048,256},
+{"STM32F439VG",0x419,1024,256},
+{"STM32F439VI",0x419,2048,256},
+{"STM32F439ZG",0x419,1024,256},
+{"STM32F439ZI",0x419,2048,256},
+{"STM32L051C6",0x417,32,8},
+{"STM32L051C8",0x417,64,8},
+{"STM32L051K6",0x417,32,8},
+{"STM32L051K8",0x417,64,8},
+{"STM32L051R6",0x417,32,8},
+{"STM32L051R8",0x417,64,8},
+{"STM32L051T6",0x417,32,8},
+{"STM32L051T8",0x417,64,8},
+{"STM32L052C6",0x417,32,8},
+{"STM32L052C8",0x417,64,8},
+{"STM32L052K6",0x417,32,8},
+{"STM32L052K8",0x417,64,8},
+{"STM32L052R6",0x417,32,8},
+{"STM32L052R8",0x417,64,8},
+{"STM32L052T6",0x417,32,8},
+{"STM32L052T8",0x417,64,8},
+{"STM32L053C6",0x417,32,8},
+{"STM32L053C8",0x417,64,8},
+{"STM32L053R6",0x417,32,8},
+{"STM32L053R8",0x417,64,8},
+{"STM32L062K8",0x417,64,8},
+{"STM32L063C8",0x417,64,8},
+{"STM32L063R8",0x417,64,8},
+{"STM32L100C6",0x416,32,4},
+{"STM32L100C6-A",0x429,32,4},
+{"STM32L100R8",0x416,64,8},
+{"STM32L100R8-A",0x429,64,8},
+{"STM32L100RB,0x416",128,10},
+{"STM32L100RB-A",0x429,128,10},
+{"STM32L100RC",0x427,256,16},
+{"STM32L151C6",0x416,32,10},
+{"STM32L151C6-A",0x429,32,10},
+{"STM32L151C8",0x416,64,10},
+{"STM32L151C8-A",0x429,64,10},
+{"STM32L151CB",0x416,128,16},
+{"STM32L151CB-A",0x429,128,16},
+{"STM32L151CC",0x427,256,32},
+{"STM32L151QC",0x427,256,32},
+{"STM32L151QD",0x436,384,48},
+{"STM32L151QE",0x437,512,80},
+{"STM32L151R6",0x416,32,10},
+{"STM32L151R6-A",0x429,32,10},
+{"STM32L151R8",0x416,64,10},
+{"STM32L151R8-A",0x429,64,10},
+{"STM32L151RB",0x416,128,16},
+{"STM32L151RB-A",0x429,128,16},
+{"STM32L151RC",0x427,256,32},
+{"STM32L151RC-A",0x429,256,32},
+{"STM32L151RD",0x436,384,48},
+{"STM32L151RE",0x437,512,80},
+{"STM32L151UC",0x427,256,32},
+{"STM32L151V8",0x416,64,10},
+{"STM32L151V8-A",0x429,64,10},
+{"STM32L151VB",0x416,128,16},
+{"STM32L151VB-A",0x429,128,16},
+{"STM32L151VC",0x427,256,32},
+{"STM32L151VC-A",0x429,256,32},
+{"STM32L151VD",0x436,384,48},
+{"STM32L151VE",0x437,512,80},
+{"STM32L151ZC",0x427,256,32},
+{"STM32L151ZD",0x436,384,48},
+{"STM32L151ZE",0x437,512,80},
+{"STM32L152C6",0x416,32,10},
+{"STM32L152C6-A",0x429,32,10},
+{"STM32L152C8",0x416,64,10},
+{"STM32L152C8-A",0x429,64,10},
+{"STM32L152CB",0x416,128,16},
+{"STM32L152CB-A",0x429,128,16},
+{"STM32L152CC",0x427,256,32},
+{"STM32L152QC",0x427,256,32},
+{"STM32L152QD",0x436,384,48},
+{"STM32L152QE",0x437,512,80},
+{"STM32L152R6",0x416,32,10},
+{"STM32L152R6-A",0x429,32,10},
+{"STM32L152R8",0x416,64,10},
+{"STM32L152R8-A",0x429,64,10},
+{"STM32L152RB",0x416,128,16},
+{"STM32L152RB-A",0x429,128,16},
+{"STM32L152RC",0x427,256,32},
+{"STM32L152RC-A",0x429,256,32},
+{"STM32L152RD",0x436,384,48},
+{"STM32L152RE",0x437,512,80},
+{"STM32L152V8",0x416,64,10},
+{"STM32L152V8-A",0x429,64,10},
+{"STM32L152VB",0x416,128,16},
+{"STM32L152VB-A",0x429,128,16},
+{"STM32L152VC",0x427,256,32},
+{"STM32L152VC-A",0x429,256,32},
+{"STM32L152VD",0x436,384,48},
+{"STM32L152VE",0x437,512,80},
+{"STM32L152ZC",0x427,256,32},
+{"STM32L152ZD",0x436,384,48},
+{"STM32L152ZE",0x437,512,80},
+{"STM32L162QD",0x436,384,48},
+{"STM32L162RC",0x427,256,32},
+{"STM32L162RC-A",0x429,256,32},
+{"STM32L162RD",0x436,384,48},
+{"STM32L162RE",0x437,512,80},
+{"STM32L162VC",0x427,256,32},
+{"STM32L162VC-A",0x429,256,32},
+{"STM32L162VD",0x436,384,48},
+{"STM32L162VE",0x437,512,80},
+{"STM32L162ZD",0x436,384,48},
+{"STM32L162ZE",0x437,512,80}};
+
+/* device table */
+const stm32_bl bootloader[] = {
+/* PID, device names, RAM start, RAM end, FLASH start,FLASH end, pages per sector , page size, OPT start, OPT end, system start, system end */
+ {0x440,0x21,"STM32F051/030x8",0x20000800,0x20001FFF,0x1FFFEC00,0x1FFFF7FF},
+ {0x444,0x10,"STM32F03xxx",0x20000800,0x20000FFF,0x1FFFEC00,0x1FFFF7FF},
+ {0x445,0xA0,"STM32F042xx",0x00000000,0x00000000,0x1FFFC400,0x1FFFF7FF},
+ {0x448,0xA1,"STM32F07xxx",0x20001800,0x20003FFF,0x1FFFC800,0x1FFFF7FF},
+ {0x412,0x00,"STM32F10xxx low density",0x20000200,0x200027FF,0x1FFFF000,0x1FFFF7FF},
+ {0x410,0x00,"STM32F10xxx medium density",0x20000200,0x200047FF,0x1FFFF000,0x1FFFF7FF},
+ {0x414,0x00,"STM32F10xxx high density",0x20000200,0x2000FFFF,0x1FFFF000,0x1FFFF7FF},
+ {0x420,0x10,"STM32F10xxx medium density vl",0x20000200,0x20001FFF,0x1FFFF000,0x1FFFF7FF},
+ {0x428,0x10,"STM32F10xxx high density vl",0x20000200,0x20007FFF,0x1FFFF000,0x1FFFF7FF},
+ {0x418,0x00,"STM32F105xx/107xx",0x20001000,0x2000FFFF,0x1FFFB000,0x1FFFF7FF},
+ {0x430,0x21,"STM32F10xxx XL density",0x20000800,0x20017FFF,0x1FFFE000,0x1FFFF7FF},
+ {0x411,0x20,"STM32F2xxxx",0x20002000,0x2001FFFF,0x1FFF0000,0x1FFF77FF},
+ {0x411,0x33,"STM32F2xxxx",0x20002000,0x2001FFFF,0x1FFF0000,0x1FFF77FF},
+ {0x432,0x41,"STM32F373xx",0x20001400,0x20007FFF,0x1FFFD800,0x1FFFF7FF},
+ {0x432,0x50,"STM32F378xx",0x20001000,0x20007FFF,0x1FFFD800,0x1FFFF7FF},
+ {0x422,0x41,"STM32F302xB/303xB",0x20001400,0x20009FFF,0x1FFFD800,0x1FFFF7FF},
+ {0x422,0x50,"STM32F358xx",0x20001400,0x20009FFF,0x1FFFD800,0x1FFFF7FF},
+ {0x439,0x40,"STM32F301xx/302x4",0x20001800,0x20003FFF,0x1FFFD800,0x1FFFF7FF},
+ {0x439,0x50,"STM32F318xx",0x20001800,0x20003FFF,0x1FFFD800,0x1FFFF7FF},
+ {0x438,0x50,"STM32F303x4/334xx/328xx",0x20001800,0x20002FFF,0x1FFFD800,0x1FFFF7FF},
+ {0x413,0x31,"STM32F40xx/41xxx",0x20002000,0x2001FFFF,0x1FFF0000,0x1FFF77FF},
+ {0x413,0x90,"STM32F40xx/41xxx",0x20003000,0x2001FFFF,0x1FFF0000,0x1FFF77FF},
+ {0x419,0x70,"STM32F40xx/41xxx",0x20003000,0x2002FFFF,0x1FFF0000,0x1FFF77FF},
+ {0x419,0x90,"STM32F40xx/41xxx",0x20003000,0x2002FFFF,0x1FFF0000,0x1FFF77FF},
+ {0x423,0xD1,"STM32F401xB",0x20003000,0x2000FFFF,0x1FFF0000,0x1FFF77FF},
+ {0x433,0xD1,"STM32F401xD",0x20003000,0x20017FFF,0x1FFF0000,0x1FFF77FF},
+ {0x431,0xD0,"STM32F411xE",0x20003000,0x2001FFFF,0x1FFF0000,0x1FFF77FF},
+ {0x417,0xC0,"STM32L05xxx/06xxx",0x20001000,0x20001FFF,0x1FF00000,0x1FF00FFF},
+ {0x416,0x20,"STM32L1xxx6",0x20000800,0x20003FFF,0x1FF00000,0x1FF00FFF},
+ {0x429,0x20,"STM32L1xxx6A",0x20001000,0x20007FFF,0x1FF00000,0x1FF00FFF},
+ {0x427,0x40,"STM32L1xxxC",0x20001000,0x20007FFF,0x1FF00000,0x1FF01FFF},
+ {0x436,0x45,"STM32L1xxxD",0x20001000,0x2000BFFF,0x1FF00000,0x1FF01FFF},
+ {0x437,0x40,"STM32L1xxxE",0x20001000,0x20013FFF,0x1FF00000,0x1FF01FFF}
};
-CRS232 serial("stm32_device");
+CRS232 serial("stm32_blice");
CEventServer *event_server=CEventServer::instance();
std::list<std::string> events;
stm32_cmd commands;
-const stm32_dev *current_device=NULL;
+const stm32_bl *current_device=NULL;
void stm32_init(std::string &dev,unsigned int baud)
{
@@ -205,10 +652,10 @@ bool stm32_get_chip_id(unsigned short int *pid)
return false;
}
*pid=(answer[2] << 8) | answer[3];
- for(i=0;i<8;i++)
+ for(i=0;i<sizeof(bootloader)/sizeof(stm32_bl);i++)
{
- if(devices[i].id==*pid)
- current_device=&devices[i];
+ if(bootloader[i].id==*pid)
+ current_device=&bootloader[i];
}
if(current_device==NULL)
{
@@ -224,13 +671,29 @@ bool stm32_get_chip_id(unsigned short int *pid)
return true;
}
-bool stm32_get_chip_info(const stm32_dev **info)
+bool stm32_get_chip_info(const stm32_bl **info)
{
*info=current_device;
return true;
}
+bool stm32_get_device_info(std::string &device_name,const stm32_dev **info)
+{
+ unsigned int i=0;
+
+ for(i=0;i<sizeof(devices)/sizeof(stm32_dev);i++)
+ {
+ if(devices[i].name==device_name)
+ {
+ *info=&devices[i];
+ return true;
+ }
+ }
+
+ return false;
+}
+
bool stm32_read_memory(unsigned int address,unsigned int length,unsigned char *data)
{
return true;
diff --git a/trunk/src/stm32.h b/trunk/src/stm32.h
index 0c9b990d57cc12f9147452002dface0f2b32389f..36b03f5d4757815e4e399636f952d4501ab46ded 100755
--- a/trunk/src/stm32.h
+++ b/trunk/src/stm32.h
@@ -24,16 +24,20 @@ typedef struct {
uint8_t ur;
}stm32_cmd;
+typedef struct {
+ std::string name;
+ uint16_t pid;
+ uint16_t flash_size;
+ uint16_t ram_size;
+}stm32_dev;
+
typedef struct {
uint16_t id;
+ uint8_t bl_id;
std::string name;
uint32_t ram_start, ram_end;
- uint32_t fl_start, fl_end;
- uint16_t fl_pps; // pages per sector
- uint16_t fl_ps; // page size
- uint32_t opt_start, opt_end;
uint32_t mem_start, mem_end;
-}stm32_dev;
+}stm32_bl;
// public functions
void stm32_init(std::string &dev,unsigned int baud);
@@ -43,7 +47,8 @@ bool stm32_discovery(void);
bool stm32_get_commands(stm32_cmd *cmd);
bool stm32_get_bootloader_ver(unsigned char *bl_ver);
bool stm32_get_chip_id(unsigned short int *pid);
-bool stm32_get_chip_info(const stm32_dev **info);
+bool stm32_get_chip_info(const stm32_bl **info);
+bool stm32_get_device_info(std::string &device_name,const stm32_dev **info);
bool stm32_read_memory(unsigned int address,unsigned int length,unsigned char *data);
bool stm32_start_exec(unsigned char address);
bool stm32_write_memory(unsigned int address, unsigned int length, unsigned char *data);