Skip to content
Snippets Groups Projects
Commit 91f7ec63 authored by Sergi Hernandez's avatar Sergi Hernandez
Browse files

Added the device identifier to the firmware downloader.

parent d40d847b
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
trunk/src/fw_downloader.cpp
+ 45
− 21
View file @ 91f7ec63
...@@ -21,20 +21,21 @@ void show_help(char *name) { ...@@ -21,20 +21,21 @@ void show_help(char *name) {
" -v Verify writes\n" " -v Verify writes\n"
" -g address Start execution at specified address (0 = flash start)\n" " -g address Start execution at specified address (0 = flash start)\n"
" -h Show this help\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" "\n"
"Examples:\n" "Examples:\n"
" Get device information:\n" " Get device information:\n"
" %s /dev/ttyS0\n" " %s -s /dev/ttyS0\n"
"\n" "\n"
" Write with verify and then start execution:\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" "\n"
" Read flash to file:\n" " Read flash to file:\n"
" %s -r filename /dev/ttyS0\n" " %s -r filename -s /dev/ttyS0\n"
"\n" "\n"
" Start execution:\n" " Start execution:\n"
" %s -g 0x0 /dev/ttyS0\n", " %s -g 0x0 -s /dev/ttyS0\n",
name, name,
name, name,
name, name,
...@@ -50,10 +51,12 @@ int main(int argc,char *argv[]) ...@@ -50,10 +51,12 @@ int main(int argc,char *argv[])
unsigned short int erase_pages=0xFFFF,device_id; unsigned short int erase_pages=0xFFFF,device_id;
unsigned char bootloader_ver,buffer[256]; unsigned char bootloader_ver,buffer[256];
flash_op operation=flash_none; flash_op operation=flash_none;
const stm32_bl *bootloader_info;
const stm32_dev *device_info; const stm32_dev *device_info;
bool verify=false,done=false; bool verify=false,done=false;
bool start_exec=false; bool start_exec=false;
std::string device=""; std::string device="";
std::string device_name="";
std::string filename; std::string filename;
stm32_cmd commands; stm32_cmd commands;
off_t offset = 0; off_t offset = 0;
...@@ -62,7 +65,7 @@ int main(int argc,char *argv[]) ...@@ -62,7 +65,7 @@ int main(int argc,char *argv[])
int option; int option;
/* parse the input arguments */ /* 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) { switch(option) {
case 'b': case 'b':
baudrate=strtoul(optarg,NULL,10); baudrate=strtoul(optarg,NULL,10);
...@@ -102,21 +105,30 @@ int main(int argc,char *argv[]) ...@@ -102,21 +105,30 @@ int main(int argc,char *argv[])
start_exec = true; start_exec = true;
start_addr = strtoul(optarg, NULL, 0); start_addr = strtoul(optarg, NULL, 0);
break; break;
case 'd': case 's':
device=optarg; device=optarg;
break; break;
case 'd':
device_name=optarg;
break;
case 'h': case 'h':
show_help(argv[0]); show_help(argv[0]);
return 1; return 1;
} }
} }
if (device.size() == 0) { if (device.size() == 0)
std::cout << "ERROR: Device not specified\n" << std::endl; {
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]); show_help(argv[0]);
return 1; return 1;
} }
/* open and config the serial port */ /* open and config the serial port */
try{ try{
stm32_init(device,baudrate); stm32_init(device,baudrate);
...@@ -125,14 +137,26 @@ int main(int argc,char *argv[]) ...@@ -125,14 +137,26 @@ int main(int argc,char *argv[])
stm32_get_commands(&commands); stm32_get_commands(&commands);
stm32_get_bootloader_ver(&bootloader_ver); stm32_get_bootloader_ver(&bootloader_ver);
std::cout << "bootloader version: 0x" << std::hex << (int)bootloader_ver << std::endl; 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; std::cout << "product id: 0x" << std::hex << device_id << std::endl;
stm32_get_chip_info(&device_info); stm32_get_chip_info(&bootloader_info);
std::cout << "device name: " << device_info->name << std::endl; if(!stm32_get_device_info(device_name,&device_info))
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 << "Unknown device " << device_name << std::endl;
std::cout << "Option RAM : " << std::dec << device_info->opt_end - device_info->opt_start << "b" << std::endl; return 1;
std::cout << "System RAM : " << std::dec << (device_info->mem_end - device_info->mem_start) / 1024 << "KiB" << std::endl; }
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 // perform desired operation
switch(operation) switch(operation)
{ {
...@@ -172,13 +196,13 @@ int main(int argc,char *argv[]) ...@@ -172,13 +196,13 @@ int main(int argc,char *argv[])
done=hex_get_first_segment(hex_file,&base,&data_len); done=hex_get_first_segment(hex_file,&base,&data_len);
while(!done) while(!done)
{ {
if(base<device_info->fl_start) if(base<0x08000000)
{ {
std::cout << "Start address not in FLASH" << std::endl; std::cout << "Start address not in FLASH" << std::endl;
hex_close(hex_file); hex_close(hex_file);
return 1; 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; std::cout << "End address not in FLASH" << std::endl;
hex_close(hex_file); hex_close(hex_file);
...@@ -217,8 +241,8 @@ int main(int argc,char *argv[]) ...@@ -217,8 +241,8 @@ int main(int argc,char *argv[])
std::cout << std::endl; std::cout << std::endl;
if(start_exec) if(start_exec)
{ {
std::cout << "starting execution at 0x" << std::hex << start_addr+device_info->fl_start << std::endl; std::cout << "starting execution at 0x" << std::hex << start_addr+0x08000000 << std::endl;
stm32_start_exec(start_addr+device_info->fl_start); stm32_start_exec(start_addr+0x08000000);
} }
break; break;
......
trunk/src/stm32.cpp
+ 479
− 16
View file @ 91f7ec63
...@@ -5,24 +5,471 @@ ...@@ -5,24 +5,471 @@
#include "eventexceptions.h" #include "eventexceptions.h"
// private variables // private variables
/* device table */
const stm32_dev devices[] = { const stm32_dev devices[] = {
{0x412, "Low-density" , 0x20000200, 0x20002800, 0x08000000, 0x08008000, 4, 1024, 0x1FFFF800, 0x1FFFF80F, 0x1FFFF000, 0x1FFFF800}, {"STM32F030C6",0x444,32,4},
{0x410, "Medium-density" , 0x20000200, 0x20005000, 0x08000000, 0x08020000, 4, 1024, 0x1FFFF800, 0x1FFFF80F, 0x1FFFF000, 0x1FFFF800}, {"STM32F030C8",0x440,64,8},
{0x411, "STM32F2xx" , 0x20002000, 0x20020000, 0x08000000, 0x08100000, 4, 16384, 0x1FFFC000, 0x1FFFC00F, 0x1FFF0000, 0x1FFF77DF}, {"STM32F030CC",0x444,256,32},
{0x413, "STM32F4xx" , 0x20002000, 0x20020000, 0x08000000, 0x08100000, 4, 16384, 0x1FFFC000, 0x1FFFC00F, 0x1FFF0000, 0x1FFF77DF}, {"STM32F030F4",0x440,16,4},
{0x414, "High-density" , 0x20000200, 0x20010000, 0x08000000, 0x08080000, 2, 2048, 0x1FFFF800, 0x1FFFF80F, 0x1FFFF000, 0x1FFFF800}, {"STM32F030K6",0x444,32,4},
{0x418, "Connectivity line", 0x20001000, 0x20010000, 0x08000000, 0x08040000, 2, 2048, 0x1FFFF800, 0x1FFFF80F, 0x1FFFB000, 0x1FFFF800}, {"STM32F030R8",0x444,64,8},
{0x420, "Medium-density VL", 0x20000200, 0x20002000, 0x08000000, 0x08020000, 4, 1024, 0x1FFFF800, 0x1FFFF80F, 0x1FFFF000, 0x1FFFF800}, {"STM32F030RC",0x444,256,32},
{0x430, "XL-density" , 0x20000800, 0x20018000, 0x08000000, 0x08100000, 2, 2048, 0x1FFFF800, 0x1FFFF80F, 0x1FFFE000, 0x1FFFF800}, {"STM32F031C4",0x440,16,4},
{0x0} {"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(); CEventServer *event_server=CEventServer::instance();
std::list<std::string> events; std::list<std::string> events;
stm32_cmd commands; stm32_cmd commands;
const stm32_dev *current_device=NULL; const stm32_bl *current_device=NULL;
void stm32_init(std::string &dev,unsigned int baud) void stm32_init(std::string &dev,unsigned int baud)
{ {
...@@ -205,10 +652,10 @@ bool stm32_get_chip_id(unsigned short int *pid) ...@@ -205,10 +652,10 @@ bool stm32_get_chip_id(unsigned short int *pid)
return false; return false;
} }
*pid=(answer[2] << 8) | answer[3]; *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) if(bootloader[i].id==*pid)
current_device=&devices[i]; current_device=&bootloader[i];
} }
if(current_device==NULL) if(current_device==NULL)
{ {
...@@ -224,13 +671,29 @@ bool stm32_get_chip_id(unsigned short int *pid) ...@@ -224,13 +671,29 @@ bool stm32_get_chip_id(unsigned short int *pid)
return true; return true;
} }
bool stm32_get_chip_info(const stm32_dev **info) bool stm32_get_chip_info(const stm32_bl **info)
{ {
*info=current_device; *info=current_device;
return true; 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) bool stm32_read_memory(unsigned int address,unsigned int length,unsigned char *data)
{ {
return true; return true;
......
trunk/src/stm32.h
+ 11
− 6
View file @ 91f7ec63
...@@ -24,16 +24,20 @@ typedef struct { ...@@ -24,16 +24,20 @@ typedef struct {
uint8_t ur; uint8_t ur;
}stm32_cmd; }stm32_cmd;
typedef struct {
std::string name;
uint16_t pid;
uint16_t flash_size;
uint16_t ram_size;
}stm32_dev;
typedef struct { typedef struct {
uint16_t id; uint16_t id;
uint8_t bl_id;
std::string name; std::string name;
uint32_t ram_start, ram_end; 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; uint32_t mem_start, mem_end;
}stm32_dev; }stm32_bl;
// public functions // public functions
void stm32_init(std::string &dev,unsigned int baud); void stm32_init(std::string &dev,unsigned int baud);
...@@ -43,7 +47,8 @@ bool stm32_discovery(void); ...@@ -43,7 +47,8 @@ bool stm32_discovery(void);
bool stm32_get_commands(stm32_cmd *cmd); bool stm32_get_commands(stm32_cmd *cmd);
bool stm32_get_bootloader_ver(unsigned char *bl_ver); bool stm32_get_bootloader_ver(unsigned char *bl_ver);
bool stm32_get_chip_id(unsigned short int *pid); 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_read_memory(unsigned int address,unsigned int length,unsigned char *data);
bool stm32_start_exec(unsigned char address); bool stm32_start_exec(unsigned char address);
bool stm32_write_memory(unsigned int address, unsigned int length, unsigned char *data); bool stm32_write_memory(unsigned int address, unsigned int length, unsigned char *data);
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment