pld: give devices a name for referencing in scripts

Change-Id: I05e8596ffacdb6cd8da4dd8a40bb460183f4930a
Signed-off-by: Daniel Anselmi <danselmi@gmx.ch>
Reviewed-on: https://review.openocd.org/c/openocd/+/7728
Tested-by: jenkins
Reviewed-by: Antonio Borneo <borneo.antonio@gmail.com>

9 files changed, 234 insertions, 189 deletions

diff --git a/src/jtag/startup.tcl b/src/jtag/startup.tcl
index b74775a..085c89b 100644
--- a/src/jtag/startup.tcl
+++ b/src/jtag/startup.tcl
@@ -1108,4 +1108,18 @@ proc "am335xgpio led_on_state" {state} {
 	}
 }
 
+lappend _telnet_autocomplete_skip "pld device"
+proc "pld device" {driver tap_name {opt 0}} {
+	echo "DEPRECATED! use 'pld create ...', not 'pld device ...'"
+	if {[string is integer -strict $opt]} {
+		if {$opt == 0} {
+			eval pld create [lindex [split $tap_name .] 0].pld $driver -chain-position $tap_name
+		} else {
+			eval pld create [lindex [split $tap_name .] 0].pld $driver -chain-position $tap_name -no_jstart
+		}
+	} else {
+		eval pld create [lindex [split $tap_name .] 0].pld $driver -chain-position $tap_name -family $opt
+	}
+}
+
 # END MIGRATION AIDS
diff --git a/src/pld/efinix.c b/src/pld/efinix.c
index f084394..370f184 100644
--- a/src/pld/efinix.c
+++ b/src/pld/efinix.c
@@ -188,14 +188,17 @@ static int efinix_load(struct pld_device *pld_device, const char *filename)
 	return retval;
 }
 
-PLD_DEVICE_COMMAND_HANDLER(efinix_pld_device_command)
+PLD_CREATE_COMMAND_HANDLER(efinix_pld_create_command)
 {
-	if (CMD_ARGC != 2)
+	if (CMD_ARGC != 4)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[1]);
+	if (strcmp(CMD_ARGV[2], "-chain-position") != 0)
+		return ERROR_COMMAND_SYNTAX_ERROR;
+
+	struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[3]);
 	if (!tap) {
-		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
+		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[3]);
 		return ERROR_FAIL;
 	}
 
@@ -213,6 +216,6 @@ PLD_DEVICE_COMMAND_HANDLER(efinix_pld_device_command)
 
 struct pld_driver efinix_pld = {
 	.name = "efinix",
-	.pld_device_command = &efinix_pld_device_command,
+	.pld_create_command = &efinix_pld_create_command,
 	.load = &efinix_load,
 };
diff --git a/src/pld/gatemate.c b/src/pld/gatemate.c
index 43b3f02..4ad2665 100644
--- a/src/pld/gatemate.c
+++ b/src/pld/gatemate.c
@@ -209,22 +209,21 @@ static int gatemate_load(struct pld_device *pld_device, const char *filename)
 	return retval;
 }
 
-PLD_DEVICE_COMMAND_HANDLER(gatemate_pld_device_command)
+PLD_CREATE_COMMAND_HANDLER(gatemate_pld_create_command)
 {
-	struct jtag_tap *tap;
-
-	struct gatemate_pld_device *gatemate_info;
+	if (CMD_ARGC != 4)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	if (CMD_ARGC != 2)
+	if (strcmp(CMD_ARGV[2], "-chain-position") != 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	tap = jtag_tap_by_string(CMD_ARGV[1]);
+	struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[3]);
 	if (!tap) {
-		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
+		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[3]);
 		return ERROR_FAIL;
 	}
 
-	gatemate_info = malloc(sizeof(struct gatemate_pld_device));
+	struct gatemate_pld_device *gatemate_info = malloc(sizeof(struct gatemate_pld_device));
 	if (!gatemate_info) {
 		LOG_ERROR("Out of memory");
 		return ERROR_FAIL;
@@ -238,6 +237,6 @@ PLD_DEVICE_COMMAND_HANDLER(gatemate_pld_device_command)
 
 struct pld_driver gatemate_pld = {
 	.name = "gatemate",
-	.pld_device_command = &gatemate_pld_device_command,
+	.pld_create_command = &gatemate_pld_create_command,
 	.load = &gatemate_load,
 };
diff --git a/src/pld/gowin.c b/src/pld/gowin.c
index 467b799..ab3582c 100644
--- a/src/pld/gowin.c
+++ b/src/pld/gowin.c
@@ -451,15 +451,12 @@ static int gowin_reload_command(struct pld_device *pld_device)
 
 COMMAND_HANDLER(gowin_read_status_command_handler)
 {
-	int dev_id;
-
 	if (CMD_ARGC != 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], dev_id);
-	struct pld_device *device = get_pld_device_by_num(dev_id);
+	struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -474,15 +471,12 @@ COMMAND_HANDLER(gowin_read_status_command_handler)
 
 COMMAND_HANDLER(gowin_read_user_register_command_handler)
 {
-	int dev_id;
-
 	if (CMD_ARGC != 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], dev_id);
-	struct pld_device *device = get_pld_device_by_num(dev_id);
+	struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -497,15 +491,12 @@ COMMAND_HANDLER(gowin_read_user_register_command_handler)
 
 COMMAND_HANDLER(gowin_reload_command_handler)
 {
-	int dev_id;
-
 	if (CMD_ARGC != 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], dev_id);
-	struct pld_device *device = get_pld_device_by_num(dev_id);
+	struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -518,19 +509,19 @@ static const struct command_registration gowin_exec_command_handlers[] = {
 		.mode = COMMAND_EXEC,
 		.handler = gowin_read_status_command_handler,
 		.help = "reading status register from FPGA",
-		.usage = "num_pld",
+		.usage = "pld_name",
 	}, {
 		.name = "read_user",
 		.mode = COMMAND_EXEC,
 		.handler = gowin_read_user_register_command_handler,
 		.help = "reading user register from FPGA",
-		.usage = "num_pld",
+		.usage = "pld_name",
 	}, {
 		.name = "reload",
 		.mode = COMMAND_EXEC,
 		.handler = gowin_reload_command_handler,
 		.help = "reloading bitstream from flash to SRAM",
-		.usage = "num_pld",
+		.usage = "pld_name",
 	},
 	COMMAND_REGISTRATION_DONE
 };
@@ -546,22 +537,21 @@ static const struct command_registration gowin_command_handler[] = {
 	COMMAND_REGISTRATION_DONE
 };
 
-PLD_DEVICE_COMMAND_HANDLER(gowin_pld_device_command)
+PLD_CREATE_COMMAND_HANDLER(gowin_pld_create_command)
 {
-	struct jtag_tap *tap;
-
-	struct gowin_pld_device *gowin_info;
+	if (CMD_ARGC != 4)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	if (CMD_ARGC != 2)
+	if (strcmp(CMD_ARGV[2], "-chain-position") != 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	tap = jtag_tap_by_string(CMD_ARGV[1]);
+	struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[3]);
 	if (!tap) {
-		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
+		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[3]);
 		return ERROR_FAIL;
 	}
 
-	gowin_info = malloc(sizeof(struct gowin_pld_device));
+	struct gowin_pld_device *gowin_info = malloc(sizeof(struct gowin_pld_device));
 	if (!gowin_info) {
 		LOG_ERROR("Out of memory");
 		return ERROR_FAIL;
@@ -576,6 +566,6 @@ PLD_DEVICE_COMMAND_HANDLER(gowin_pld_device_command)
 struct pld_driver gowin_pld = {
 	.name = "gowin",
 	.commands = gowin_command_handler,
-	.pld_device_command = &gowin_pld_device_command,
+	.pld_create_command = &gowin_pld_create_command,
 	.load = &gowin_load_to_sram,
 };
diff --git a/src/pld/intel.c b/src/pld/intel.c
index 119a569..92a790b 100644
--- a/src/pld/intel.c
+++ b/src/pld/intel.c
@@ -339,16 +339,14 @@ static int intel_load(struct pld_device *pld_device, const char *filename)
 
 COMMAND_HANDLER(intel_set_bscan_command_handler)
 {
-	int dev_id;
 	unsigned int boundary_scan_length;
 
 	if (CMD_ARGC != 2)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], dev_id);
-	struct pld_device *pld_device = get_pld_device_by_num(dev_id);
+	struct pld_device *pld_device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!pld_device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -366,16 +364,14 @@ COMMAND_HANDLER(intel_set_bscan_command_handler)
 
 COMMAND_HANDLER(intel_set_check_pos_command_handler)
 {
-	int dev_id;
 	int checkpos;
 
 	if (CMD_ARGC != 2)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], dev_id);
-	struct pld_device *pld_device = get_pld_device_by_num(dev_id);
+	struct pld_device *pld_device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!pld_device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -392,42 +388,47 @@ COMMAND_HANDLER(intel_set_check_pos_command_handler)
 }
 
 
-PLD_DEVICE_COMMAND_HANDLER(intel_pld_device_command)
+PLD_CREATE_COMMAND_HANDLER(intel_pld_create_command)
 {
-	if (CMD_ARGC < 2 || CMD_ARGC > 3)
+	if (CMD_ARGC != 4 && CMD_ARGC != 6)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[1]);
-	if (!tap) {
-		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
-		return ERROR_FAIL;
-	}
+	if (strcmp(CMD_ARGV[2], "-chain-position") != 0)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	struct intel_pld_device *intel_info = malloc(sizeof(struct intel_pld_device));
-	if (!intel_info) {
-		LOG_ERROR("Out of memory");
+	struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[3]);
+	if (!tap) {
+		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[3]);
 		return ERROR_FAIL;
 	}
 
 	enum intel_family_e family = INTEL_UNKNOWN;
+	if (CMD_ARGC == 6) {
+		if (strcmp(CMD_ARGV[4], "-family") != 0)
+			return ERROR_COMMAND_SYNTAX_ERROR;
 
-	if (CMD_ARGC == 3) {
-		if (strcmp(CMD_ARGV[2], "cycloneiii") == 0) {
+		if (strcmp(CMD_ARGV[5], "cycloneiii") == 0) {
 			family = INTEL_CYCLONEIII;
-		} else if (strcmp(CMD_ARGV[2], "cycloneiv") == 0) {
+		} else if (strcmp(CMD_ARGV[5], "cycloneiv") == 0) {
 			family = INTEL_CYCLONEIV;
-		} else if (strcmp(CMD_ARGV[2], "cyclonev") == 0) {
+		} else if (strcmp(CMD_ARGV[5], "cyclonev") == 0) {
 			family = INTEL_CYCLONEV;
-		} else if (strcmp(CMD_ARGV[2], "cyclone10") == 0) {
+		} else if (strcmp(CMD_ARGV[5], "cyclone10") == 0) {
 			family = INTEL_CYCLONE10;
-		} else if (strcmp(CMD_ARGV[2], "arriaii") == 0) {
+		} else if (strcmp(CMD_ARGV[5], "arriaii") == 0) {
 			family = INTEL_ARRIAII;
 		} else {
 			command_print(CMD, "unknown family");
-			free(intel_info);
 			return ERROR_FAIL;
 		}
 	}
+
+	struct intel_pld_device *intel_info = malloc(sizeof(struct intel_pld_device));
+	if (!intel_info) {
+		LOG_ERROR("Out of memory");
+		return ERROR_FAIL;
+	}
+
 	intel_info->tap = tap;
 	intel_info->boundary_scan_length = 0;
 	intel_info->checkpos = -1;
@@ -444,13 +445,13 @@ static const struct command_registration intel_exec_command_handlers[] = {
 		.mode = COMMAND_EXEC,
 		.handler = intel_set_bscan_command_handler,
 		.help = "set boundary scan register length of FPGA",
-		.usage = "num_pld len",
+		.usage = "pld_name len",
 	}, {
 		.name = "set_check_pos",
 		.mode = COMMAND_EXEC,
 		.handler = intel_set_check_pos_command_handler,
 		.help = "set check_pos of FPGA",
-		.usage = "num_pld pos",
+		.usage = "pld_name pos",
 	},
 	COMMAND_REGISTRATION_DONE
 };
@@ -469,6 +470,6 @@ static const struct command_registration intel_command_handler[] = {
 struct pld_driver intel_pld = {
 	.name = "intel",
 	.commands = intel_command_handler,
-	.pld_device_command = &intel_pld_device_command,
+	.pld_create_command = &intel_pld_create_command,
 	.load = &intel_load,
 };
diff --git a/src/pld/lattice.c b/src/pld/lattice.c
index 4ab5f63..63d7306 100644
--- a/src/pld/lattice.c
+++ b/src/pld/lattice.c
@@ -316,39 +316,46 @@ static int lattice_load_command(struct pld_device *pld_device, const char *filen
 	return retval;
 }
 
-PLD_DEVICE_COMMAND_HANDLER(lattice_pld_device_command)
+PLD_CREATE_COMMAND_HANDLER(lattice_pld_create_command)
 {
-	if (CMD_ARGC < 2 || CMD_ARGC > 3)
+	if (CMD_ARGC != 4 && CMD_ARGC != 6)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[1]);
+	if (strcmp(CMD_ARGV[2], "-chain-position") != 0)
+		return ERROR_COMMAND_SYNTAX_ERROR;
+
+	struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[3]);
 	if (!tap) {
-		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
+		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[3]);
 		return ERROR_FAIL;
 	}
 
-	struct lattice_pld_device *lattice_device = malloc(sizeof(struct lattice_pld_device));
-	if (!lattice_device) {
-		LOG_ERROR("Out of memory");
-		return ERROR_FAIL;
-	}
 	/* id is not known yet -> postpone lattice_check_device_family() */
 	enum lattice_family_e family = LATTICE_UNKNOWN;
-	if (CMD_ARGC == 3) {
-		if (strcasecmp(CMD_ARGV[2], "ecp2") == 0) {
+	if (CMD_ARGC == 6) {
+		if (strcmp(CMD_ARGV[4], "-family") != 0)
+			return ERROR_COMMAND_SYNTAX_ERROR;
+
+		if (strcasecmp(CMD_ARGV[5], "ecp2") == 0) {
 			family = LATTICE_ECP2;
-		} else if (strcasecmp(CMD_ARGV[2], "ecp3") == 0) {
+		} else if (strcasecmp(CMD_ARGV[5], "ecp3") == 0) {
 			family = LATTICE_ECP3;
-		} else if (strcasecmp(CMD_ARGV[2], "ecp5") == 0) {
+		} else if (strcasecmp(CMD_ARGV[5], "ecp5") == 0) {
 			family = LATTICE_ECP5;
-		} else if (strcasecmp(CMD_ARGV[2], "certus") == 0) {
+		} else if (strcasecmp(CMD_ARGV[5], "certus") == 0) {
 			family = LATTICE_CERTUS;
 		} else {
 			command_print(CMD, "unknown family");
-			free(lattice_device);
 			return ERROR_FAIL;
 		}
 	}
+
+	struct lattice_pld_device *lattice_device = malloc(sizeof(struct lattice_pld_device));
+	if (!lattice_device) {
+		LOG_ERROR("Out of memory");
+		return ERROR_FAIL;
+	}
+
 	lattice_device->tap = tap;
 	lattice_device->family = family;
 	lattice_device->preload_length = 0;
@@ -360,16 +367,14 @@ PLD_DEVICE_COMMAND_HANDLER(lattice_pld_device_command)
 
 COMMAND_HANDLER(lattice_read_usercode_register_command_handler)
 {
-	int dev_id;
 	uint32_t usercode;
 
 	if (CMD_ARGC != 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], dev_id);
-	struct pld_device *device = get_pld_device_by_num(dev_id);
+	struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -390,16 +395,14 @@ COMMAND_HANDLER(lattice_read_usercode_register_command_handler)
 
 COMMAND_HANDLER(lattice_set_preload_command_handler)
 {
-	int dev_id;
 	unsigned int preload_length;
 
 	if (CMD_ARGC != 2)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], dev_id);
-	struct pld_device *device = get_pld_device_by_num(dev_id);
+	struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -417,16 +420,14 @@ COMMAND_HANDLER(lattice_set_preload_command_handler)
 
 COMMAND_HANDLER(lattice_write_usercode_register_command_handler)
 {
-	int dev_id;
 	uint32_t usercode;
 
 	if (CMD_ARGC != 2)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], dev_id);
-	struct pld_device *device = get_pld_device_by_num(dev_id);
+	struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -445,15 +446,12 @@ COMMAND_HANDLER(lattice_write_usercode_register_command_handler)
 
 COMMAND_HANDLER(lattice_read_status_command_handler)
 {
-	int dev_id;
-
 	if (CMD_ARGC != 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], dev_id);
-	struct pld_device *device = get_pld_device_by_num(dev_id);
+	struct pld_device *device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -487,25 +485,25 @@ static const struct command_registration lattice_exec_command_handlers[] = {
 		.mode = COMMAND_EXEC,
 		.handler = lattice_read_status_command_handler,
 		.help = "reading status register from FPGA",
-		.usage = "num_pld",
+		.usage = "pld_name",
 	}, {
 		.name = "read_user",
 		.mode = COMMAND_EXEC,
 		.handler = lattice_read_usercode_register_command_handler,
 		.help = "reading usercode register from FPGA",
-		.usage = "num_pld",
+		.usage = "pld_name",
 	}, {
 		.name = "write_user",
 		.mode = COMMAND_EXEC,
 		.handler = lattice_write_usercode_register_command_handler,
 		.help = "writing usercode register to FPGA",
-		.usage = "num_pld value",
+		.usage = "pld_name value",
 	}, {
 		.name = "set_preload",
 		.mode = COMMAND_EXEC,
 		.handler = lattice_set_preload_command_handler,
 		.help = "set length for preload (device specific)",
-		.usage = "num_pld value",
+		.usage = "pld_name value",
 	},
 	COMMAND_REGISTRATION_DONE
 };
@@ -524,6 +522,6 @@ static const struct command_registration lattice_command_handler[] = {
 struct pld_driver lattice_pld = {
 	.name = "lattice",
 	.commands = lattice_command_handler,
-	.pld_device_command = &lattice_pld_device_command,
+	.pld_create_command = &lattice_pld_create_command,
 	.load = &lattice_load_command,
 };
diff --git a/src/pld/pld.c b/src/pld/pld.c
index 07b575f..c375418 100644
--- a/src/pld/pld.c
+++ b/src/pld/pld.c
@@ -34,68 +34,110 @@ struct pld_device *get_pld_device_by_num(int num)
 	int i = 0;
 
 	for (p = pld_devices; p; p = p->next) {
-		if (i++ == num)
+		if (i++ == num) {
+			LOG_WARNING("DEPRECATED: use pld name \"%s\" instead of number %d", p->name, num);
 			return p;
+		}
 	}
 
 	return NULL;
 }
 
-/* pld device <driver> [driver_options ...]
- */
-COMMAND_HANDLER(handle_pld_device_command)
+struct pld_device *get_pld_device_by_name(const char *name)
 {
-	int i;
-	int found = 0;
+	for (struct pld_device *p = pld_devices; p; p = p->next) {
+		if (strcmp(p->name, name) == 0)
+			return p;
+	}
+
+	return NULL;
+}
 
-	if (CMD_ARGC < 1)
+struct pld_device *get_pld_device_by_name_or_numstr(const char *str)
+{
+	struct pld_device *dev = get_pld_device_by_name(str);
+	if (dev)
+		return dev;
+
+	char *end;
+	unsigned long dev_num = strtoul(str, &end, 0);
+	if (*end || dev_num > INT_MAX) {
+		LOG_ERROR("Invalid argument");
+		return NULL;
+	}
+
+	return get_pld_device_by_num(dev_num);
+}
+
+/* @deffn {Config Command} {pld create} pld_name driver -chain-position tap_name [options]
+*/
+COMMAND_HANDLER(handle_pld_create_command)
+{
+	if (CMD_ARGC < 2)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	for (i = 0; pld_drivers[i]; i++) {
-		if (strcmp(CMD_ARGV[0], pld_drivers[i]->name) == 0) {
-			struct pld_device *p, *c;
-
-			/* register pld specific commands */
-			int retval;
-			if (pld_drivers[i]->commands) {
-				retval = register_commands(CMD_CTX, NULL, pld_drivers[i]->commands);
-				if (retval != ERROR_OK) {
-					LOG_ERROR("couldn't register '%s' commands", CMD_ARGV[0]);
-					return ERROR_FAIL;
-				}
-			}
-
-			c = malloc(sizeof(struct pld_device));
-			c->driver = pld_drivers[i];
-			c->next = NULL;
-
-			retval = CALL_COMMAND_HANDLER(
-					pld_drivers[i]->pld_device_command, c);
-			if (retval != ERROR_OK) {
-				LOG_ERROR("'%s' driver rejected pld device",
-					CMD_ARGV[0]);
-				free(c);
-				return ERROR_OK;
-			}
-
-			/* put pld device in linked list */
-			if (pld_devices) {
-				/* find last pld device */
-				for (p = pld_devices; p && p->next; p = p->next)
-					;
-				if (p)
-					p->next = c;
-			} else
-				pld_devices = c;
-
-			found = 1;
+	struct pld_driver *pld_driver = NULL;
+
+	for (int i = 0; pld_drivers[i]; i++) {
+		if (strcmp(CMD_ARGV[1], pld_drivers[i]->name) == 0) {
+			pld_driver = pld_drivers[i];
+			break;
+		}
+	}
+
+	if (!pld_driver) {
+		LOG_ERROR("pld driver '%s' not found", CMD_ARGV[1]);
+		return ERROR_FAIL; /* exit(-1); */
+	}
+
+	if (get_pld_device_by_name(CMD_ARGV[0])) {
+		LOG_ERROR("pld device with name '%s' already exists", CMD_ARGV[0]);
+		return ERROR_FAIL;
+	}
+
+	struct pld_device *pld_device = malloc(sizeof(struct pld_device));
+	if (!pld_device) {
+		LOG_ERROR("Out of memory");
+		return ERROR_FAIL;
+	}
+
+	pld_device->driver = pld_driver;
+	pld_device->next = NULL;
+
+	int retval = CALL_COMMAND_HANDLER(pld_driver->pld_create_command, pld_device);
+	if (retval != ERROR_OK) {
+		LOG_ERROR("'%s' driver rejected pld device",
+			CMD_ARGV[1]);
+		free(pld_device);
+		return ERROR_OK;
+	}
+	pld_device->name = strdup(CMD_ARGV[0]);
+	if (!pld_device->name) {
+		LOG_ERROR("Out of memory");
+		free(pld_device);
+		return ERROR_FAIL;
+	}
+
+	/* register pld specific commands */
+	if (pld_driver->commands) {
+		retval = register_commands(CMD_CTX, NULL, pld_driver->commands);
+		if (retval != ERROR_OK) {
+			LOG_ERROR("couldn't register '%s' commands", CMD_ARGV[1]);
+			free(pld_device->name);
+			free(pld_device);
+			return ERROR_FAIL;
 		}
 	}
 
-	/* no matching pld driver found */
-	if (!found) {
-		LOG_ERROR("pld driver '%s' not found", CMD_ARGV[0]);
-		exit(-1);
+	if (pld_devices) {
+		/* find last pld device */
+		struct pld_device *p = pld_devices;
+		for (; p && p->next; p = p->next)
+			;
+		if (p)
+			p->next = pld_device;
+	} else {
+		pld_devices = pld_device;
 	}
 
 	return ERROR_OK;
@@ -112,7 +154,7 @@ COMMAND_HANDLER(handle_pld_devices_command)
 	}
 
 	for (p = pld_devices; p; p = p->next)
-		command_print(CMD, "#%i: %s", i++, p->driver->name);
+		command_print(CMD, "#%i: %s (driver: %s)", i++, p->name, p->driver->name);
 
 	return ERROR_OK;
 }
@@ -128,11 +170,9 @@ COMMAND_HANDLER(handle_pld_load_command)
 	if (CMD_ARGC < 2)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	unsigned dev_id;
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
-	p = get_pld_device_by_num(dev_id);
+	p = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!p) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_OK;
 	}
 
@@ -154,15 +194,15 @@ COMMAND_HANDLER(handle_pld_load_command)
 
 	retval = p->driver->load(p, CMD_ARGV[1]);
 	if (retval != ERROR_OK) {
-		command_print(CMD, "failed loading file %s to pld device %u",
-			CMD_ARGV[1], dev_id);
+		command_print(CMD, "failed loading file %s to pld device %s",
+			CMD_ARGV[1], CMD_ARGV[0]);
 		return retval;
 	} else {
 		gettimeofday(&end, NULL);
 		timeval_subtract(&duration, &end, &start);
 
-		command_print(CMD, "loaded file %s to pld device %u in %jis %jius",
-			CMD_ARGV[1], dev_id,
+		command_print(CMD, "loaded file %s to pld device %s in %jis %jius",
+			CMD_ARGV[1], CMD_ARGV[0],
 			(intmax_t)duration.tv_sec, (intmax_t)duration.tv_usec);
 	}
 
@@ -182,7 +222,7 @@ static const struct command_registration pld_exec_command_handlers[] = {
 		.handler = handle_pld_load_command,
 		.mode = COMMAND_EXEC,
 		.help = "load configuration file into PLD",
-		.usage = "pld_num filename",
+		.usage = "pld_name filename",
 	},
 	COMMAND_REGISTRATION_DONE
 };
@@ -213,11 +253,11 @@ COMMAND_HANDLER(handle_pld_init_command)
 
 static const struct command_registration pld_config_command_handlers[] = {
 	{
-		.name = "device",
+		.name = "create",
 		.mode = COMMAND_CONFIG,
-		.handler = handle_pld_device_command,
-		.help = "configure a PLD device",
-		.usage = "driver_name [driver_args ... ]",
+		.handler = handle_pld_create_command,
+		.help = "create a PLD device",
+		.usage = "name.pld driver_name [driver_args ... ]",
 	},
 	{
 		.name = "init",
diff --git a/src/pld/pld.h b/src/pld/pld.h
index 322b96e..8a2a118 100644
--- a/src/pld/pld.h
+++ b/src/pld/pld.h
@@ -12,28 +12,31 @@
 
 struct pld_device;
 
-#define __PLD_DEVICE_COMMAND(name) \
+#define __PLD_CREATE_COMMAND(name) \
 	COMMAND_HELPER(name, struct pld_device *pld)
 
 struct pld_driver {
 	const char *name;
-	__PLD_DEVICE_COMMAND((*pld_device_command));
+	__PLD_CREATE_COMMAND((*pld_create_command));
 	const struct command_registration *commands;
 	int (*load)(struct pld_device *pld_device, const char *filename);
 };
 
-#define PLD_DEVICE_COMMAND_HANDLER(name) \
-	static __PLD_DEVICE_COMMAND(name)
+#define PLD_CREATE_COMMAND_HANDLER(name) \
+	static __PLD_CREATE_COMMAND(name)
 
 struct pld_device {
 	struct pld_driver *driver;
 	void *driver_priv;
 	struct pld_device *next;
+	char *name;
 };
 
 int pld_register_commands(struct command_context *cmd_ctx);
 
 struct pld_device *get_pld_device_by_num(int num);
+struct pld_device *get_pld_device_by_name(const char *name);
+struct pld_device *get_pld_device_by_name_or_numstr(const char *str);
 
 #define ERROR_PLD_DEVICE_INVALID        (-1000)
 #define ERROR_PLD_FILE_LOAD_FAILED      (-1001)
diff --git a/src/pld/virtex2.c b/src/pld/virtex2.c
index fd0725a..f044bda 100644
--- a/src/pld/virtex2.c
+++ b/src/pld/virtex2.c
@@ -233,11 +233,9 @@ COMMAND_HANDLER(virtex2_handle_read_stat_command)
 	if (CMD_ARGC < 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	unsigned dev_id;
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
-	device = get_pld_device_by_num(dev_id);
+	device = get_pld_device_by_name_or_numstr(CMD_ARGV[0]);
 	if (!device) {
-		command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+		command_print(CMD, "pld device '#%s' is out of bounds or unknown", CMD_ARGV[0]);
 		return ERROR_FAIL;
 	}
 
@@ -252,22 +250,21 @@ COMMAND_HANDLER(virtex2_handle_read_stat_command)
 	return ERROR_OK;
 }
 
-PLD_DEVICE_COMMAND_HANDLER(virtex2_pld_device_command)
+PLD_CREATE_COMMAND_HANDLER(virtex2_pld_create_command)
 {
-	struct jtag_tap *tap;
-
-	struct virtex2_pld_device *virtex2_info;
+	if (CMD_ARGC < 4)
+		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	if (CMD_ARGC < 2)
+	if (strcmp(CMD_ARGV[2], "-chain-position") != 0)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	tap = jtag_tap_by_string(CMD_ARGV[1]);
+	struct jtag_tap *tap = jtag_tap_by_string(CMD_ARGV[3]);
 	if (!tap) {
-		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
+		command_print(CMD, "Tap: %s does not exist", CMD_ARGV[3]);
 		return ERROR_FAIL;
 	}
 
-	virtex2_info = malloc(sizeof(struct virtex2_pld_device));
+	struct virtex2_pld_device *virtex2_info = malloc(sizeof(struct virtex2_pld_device));
 	if (!virtex2_info) {
 		LOG_ERROR("Out of memory");
 		return ERROR_FAIL;
@@ -275,8 +272,8 @@ PLD_DEVICE_COMMAND_HANDLER(virtex2_pld_device_command)
 	virtex2_info->tap = tap;
 
 	virtex2_info->no_jstart = 0;
-	if (CMD_ARGC >= 3)
-		COMMAND_PARSE_NUMBER(int, CMD_ARGV[2], virtex2_info->no_jstart);
+	if (CMD_ARGC >= 5 && strcmp(CMD_ARGV[4], "-no_jstart") == 0)
+		virtex2_info->no_jstart = 1;
 
 	pld->driver_priv = virtex2_info;
 
@@ -289,7 +286,7 @@ static const struct command_registration virtex2_exec_command_handlers[] = {
 		.mode = COMMAND_EXEC,
 		.handler = virtex2_handle_read_stat_command,
 		.help = "read status register",
-		.usage = "pld_num",
+		.usage = "pld_name",
 	},
 	COMMAND_REGISTRATION_DONE
 };
@@ -307,6 +304,6 @@ static const struct command_registration virtex2_command_handler[] = {
 struct pld_driver virtex2_pld = {
 	.name = "virtex2",
 	.commands = virtex2_command_handler,
-	.pld_device_command = &virtex2_pld_device_command,
+	.pld_create_command = &virtex2_pld_create_command,
 	.load = &virtex2_load,
 };