Rename struct target to struct pdbg_target

In preparation for a better defined libpdbg API rename "struct target" to
something less generic so that we can export the name.

Signed-off-by: Alistair Popple <alistair@popple.id.au>

16 files changed, 112 insertions, 112 deletions

diff --git a/libpdbg/adu.c b/libpdbg/adu.c
index 3d6f662..2a0b8d5 100644
--- a/libpdbg/adu.c
+++ b/libpdbg/adu.c
@@ -79,7 +79,7 @@
 #define FBC_ALTD_DATA_DONE	PPC_BIT(3)
 #define FBC_ALTD_PBINIT_MISSING PPC_BIT(18)
 
-int adu_getmem(struct target *adu_target, uint64_t start_addr, uint8_t *output, uint64_t size)
+int adu_getmem(struct pdbg_target *adu_target, uint64_t start_addr, uint8_t *output, uint64_t size)
 {
 	struct adu *adu;
 	int rc = 0;
@@ -112,7 +112,7 @@ int adu_getmem(struct target *adu_target, uint64_t start_addr, uint8_t *output,
 	return rc;
 }
 
-int adu_putmem(struct target *adu_target, uint64_t start_addr, uint8_t *input, uint64_t size)
+int adu_putmem(struct pdbg_target *adu_target, uint64_t start_addr, uint8_t *input, uint64_t size)
 {
 	struct adu *adu;
 	int rc = 0, tsize;
diff --git a/libpdbg/bmcfsi.c b/libpdbg/bmcfsi.c
index 12f3a5f..c8597a4 100644
--- a/libpdbg/bmcfsi.c
+++ b/libpdbg/bmcfsi.c
@@ -428,7 +428,7 @@ static void fsi_reset(struct fsi *fsi)
 	fsi_putcfam(fsi, 0x800, val);
 }
 
-void fsi_destroy(struct target *target)
+void fsi_destroy(struct pdbg_target *target)
 {
 	set_direction_out(FSI_CLK);
 	set_direction_out(FSI_DAT);
@@ -445,7 +445,7 @@ void fsi_destroy(struct target *target)
 	write_gpio(CRONUS_SEL, 0);
 }
 
-int bmcfsi_probe(struct target *target)
+int bmcfsi_probe(struct pdbg_target *target)
 {
 	struct fsi *fsi = target_to_fsi(target);
 
diff --git a/libpdbg/cfam.c b/libpdbg/cfam.c
index 65e5d48..3df0a06 100644
--- a/libpdbg/cfam.c
+++ b/libpdbg/cfam.c
@@ -255,7 +255,7 @@ static int p8_hmfsi_write(struct fsi *fsi, uint32_t addr, uint32_t data)
 	return opb_write(&fsi->target, addr, data);
 }
 
-static int p8_hmfsi_probe(struct target *target)
+static int p8_hmfsi_probe(struct pdbg_target *target)
 {
 	struct fsi *fsi = target_to_fsi(target);
 	uint32_t value;
@@ -287,7 +287,7 @@ DECLARE_HW_UNIT(p8_opb_hmfsi);
 
 static int cfam_hmfsi_read(struct fsi *fsi, uint32_t addr, uint32_t *data)
 {
-	struct target *parent_fsi = fsi->target.dn->parent->target;
+	struct pdbg_target *parent_fsi = fsi->target.dn->parent->target;
 
 	addr += dt_get_address(fsi->target.dn, 0, NULL);
 
@@ -296,17 +296,17 @@ static int cfam_hmfsi_read(struct fsi *fsi, uint32_t addr, uint32_t *data)
 
 static int cfam_hmfsi_write(struct fsi *fsi, uint32_t addr, uint32_t data)
 {
-	struct target *parent_fsi = fsi->target.dn->parent->target;
+	struct pdbg_target *parent_fsi = fsi->target.dn->parent->target;
 
 	addr += dt_get_address(fsi->target.dn, 0, NULL);
 
 	return fsi_write(parent_fsi, addr, data);
 }
 
-static int cfam_hmfsi_probe(struct target *target)
+static int cfam_hmfsi_probe(struct pdbg_target *target)
 {
 	struct fsi *fsi = target_to_fsi(target);
-	struct target *fsi_parent = target->dn->parent->target;
+	struct pdbg_target *fsi_parent = target->dn->parent->target;
 	uint32_t value, port;
 	int rc;
 
diff --git a/libpdbg/chip.c b/libpdbg/chip.c
index 0dd2363..03dcdc7 100644
--- a/libpdbg/chip.c
+++ b/libpdbg/chip.c
@@ -88,7 +88,7 @@ uint64_t thread_status(struct thread *thread)
 /*
  * Single step the thread count instructions.
  */
-int ram_step_thread(struct target *thread_target, int count)
+int ram_step_thread(struct pdbg_target *thread_target, int count)
 {
 	struct thread *thread;
 
@@ -97,7 +97,7 @@ int ram_step_thread(struct target *thread_target, int count)
 	return thread->step(thread, count);
 }
 
-int ram_start_thread(struct target *thread_target)
+int ram_start_thread(struct pdbg_target *thread_target)
 {
 	struct thread *thread;
 
@@ -106,7 +106,7 @@ int ram_start_thread(struct target *thread_target)
 	return thread->start(thread);
 }
 
-int ram_stop_thread(struct target *thread_target)
+int ram_stop_thread(struct pdbg_target *thread_target)
 {
 	struct thread *thread;
 
@@ -115,7 +115,7 @@ int ram_stop_thread(struct target *thread_target)
 	return thread->stop(thread);
 }
 
-int ram_sreset_thread(struct target *thread_target)
+int ram_sreset_thread(struct pdbg_target *thread_target)
 {
 	struct thread *thread;
 
diff --git a/libpdbg/device.h b/libpdbg/device.h
index c0650de..4bc60a7 100644
--- a/libpdbg/device.h
+++ b/libpdbg/device.h
@@ -45,7 +45,7 @@ struct dt_node {
 	struct list_head children;
 	struct dt_node *parent;
 	u32 phandle;
-	struct target *target;
+	struct pdbg_target *target;
 };
 
 /* This is shared with device_tree.c .. make it static when
diff --git a/libpdbg/fsi2pib.c b/libpdbg/fsi2pib.c
index 0c13724..e150e58 100644
--- a/libpdbg/fsi2pib.c
+++ b/libpdbg/fsi2pib.c
@@ -36,7 +36,7 @@
  * accesses. */
 #define FSI2PIB_RELAX	50
 
-static int fsi2pib_getscom(struct target *target, uint64_t addr, uint64_t *value)
+static int fsi2pib_getscom(struct pdbg_target *target, uint64_t addr, uint64_t *value)
 {
 	uint64_t result;
 
@@ -52,7 +52,7 @@ static int fsi2pib_getscom(struct target *target, uint64_t addr, uint64_t *value
 	return 0;
 }
 
-static int fsi2pib_putscom(struct target *target, uint64_t addr, uint64_t value)
+static int fsi2pib_putscom(struct pdbg_target *target, uint64_t addr, uint64_t value)
 {
 	usleep(FSI2PIB_RELAX);
 
@@ -64,7 +64,7 @@ static int fsi2pib_putscom(struct target *target, uint64_t addr, uint64_t value)
 	return 0;
 }
 
-int fsi2pib_target_init(struct target *target, const char *name, uint64_t base, struct target *next)
+int fsi2pib_target_init(struct pdbg_target *target, const char *name, uint64_t base, struct pdbg_target *next)
 {
 	target->name = name;
 	target->read = fsi2pib_getscom;
diff --git a/libpdbg/host.c b/libpdbg/host.c
index e799b96..5692d73 100644
--- a/libpdbg/host.c
+++ b/libpdbg/host.c
@@ -80,7 +80,7 @@ static int xscom_write(struct pib *pib, uint64_t addr, uint64_t val)
 	return 0;
 }
 
-static int host_pib_probe(struct target *target)
+static int host_pib_probe(struct pdbg_target *target)
 {
 	struct pib *pib = target_to_pib(target);
 	int *fd;
diff --git a/libpdbg/htm.c b/libpdbg/htm.c
index eb43a7e..6377699 100644
--- a/libpdbg/htm.c
+++ b/libpdbg/htm.c
@@ -166,7 +166,7 @@ struct htm_status {
 	uint64_t raw;
 };
 
-static struct htm *check_and_convert(struct target *target)
+static struct htm *check_and_convert(struct pdbg_target *target)
 {
 	if (strcmp(target->class,"htm"))
 		return NULL;
@@ -174,42 +174,42 @@ static struct htm *check_and_convert(struct target *target)
 	return target_to_htm(target);
 }
 
-int htm_start(struct target *target)
+int htm_start(struct pdbg_target *target)
 {
 	struct htm *htm = check_and_convert(target);
 
 	return htm ? htm->start(htm) : -1;
 }
 
-int htm_stop(struct target *target)
+int htm_stop(struct pdbg_target *target)
 {
 	struct htm *htm = check_and_convert(target);
 
 	return htm ? htm->stop(htm) : -1;
 }
 
-int htm_reset(struct target *target, uint64_t *base, uint64_t *size)
+int htm_reset(struct pdbg_target *target, uint64_t *base, uint64_t *size)
 {
 	struct htm *htm = check_and_convert(target);
 
 	return htm ? htm->reset(htm, base, size) : -1;
 }
 
-int htm_pause(struct target *target)
+int htm_pause(struct pdbg_target *target)
 {
 	struct htm *htm = check_and_convert(target);
 
 	return htm ? htm->pause(htm) : -1;
 }
 
-int htm_status(struct target *target)
+int htm_status(struct pdbg_target *target)
 {
 	struct htm *htm = check_and_convert(target);
 
 	return htm ? htm->status(htm) : -1;
 }
 
-int htm_dump(struct target *target, uint64_t size, const char *filename)
+int htm_dump(struct pdbg_target *target, uint64_t size, const char *filename)
 {
 	struct htm *htm = check_and_convert(target);
 
@@ -335,7 +335,7 @@ static int do_htm_stop(struct htm *htm)
  * clearly what is going on.
  */
 #if 0
-static int do_adu_magic(struct target *target, uint32_t index, uint64_t *arg1, uint64_t *arg2)
+static int do_adu_magic(struct pdbg_target *target, uint32_t index, uint64_t *arg1, uint64_t *arg2)
 {
 	uint64_t val;
 	int i = 0;
@@ -827,7 +827,7 @@ static int do_htm_dump(struct htm *htm, uint64_t size, const char *basename)
 	return 1;
 }
 
-static int htm_probe(struct target *target)
+static int htm_probe(struct pdbg_target *target)
 {
 	uint64_t val;
 
diff --git a/libpdbg/i2c.c b/libpdbg/i2c.c
index 6169e3c..62fc1d3 100644
--- a/libpdbg/i2c.c
+++ b/libpdbg/i2c.c
@@ -122,7 +122,7 @@ static void i2c_destroy(struct pib *pib)
 /*
  * Initialise a i2c backend on the given bus at the given bus address.
  */
-int i2c_target_probe(struct target *target)
+int i2c_target_probe(struct pdbg_target *target)
 {
 	struct pib *pib = target_to_pib(target);
 	struct i2c_data *i2c_data;
diff --git a/libpdbg/kernel.c b/libpdbg/kernel.c
index 08411b0..c35226f 100644
--- a/libpdbg/kernel.c
+++ b/libpdbg/kernel.c
@@ -85,7 +85,7 @@ static int kernel_fsi_putcfam(struct fsi *fsi, uint32_t addr64, uint32_t data)
 /* TODO: At present we don't have a generic destroy method as there aren't many
  * use cases for it. So for the moment we can just let the OS close the file
  * descriptor on exit. */
-static void kernel_fsi_destroy(struct target *target)
+static void kernel_fsi_destroy(struct pdbg_target *target)
 {
 	close(fsi_fd);
 }
@@ -107,7 +107,7 @@ static void kernel_fsi_scan_devices(void)
 	close(fd);
 }
 
-int kernel_fsi_probe(struct target *target)
+int kernel_fsi_probe(struct pdbg_target *target)
 {
 	if (!fsi_fd) {
 		int tries = 5;
diff --git a/libpdbg/operations.h b/libpdbg/operations.h
index b555fc6..e4a9411 100644
--- a/libpdbg/operations.h
+++ b/libpdbg/operations.h
@@ -33,8 +33,8 @@
 #define FSI2PIB_BASE	0x1000
 
 /* Alter display unit functions */
-int adu_getmem(struct target *target, uint64_t addr, uint8_t *output, uint64_t size);
-int adu_putmem(struct target *target, uint64_t start_addr, uint8_t *input, uint64_t size);
+int adu_getmem(struct pdbg_target *target, uint64_t addr, uint8_t *output, uint64_t size);
+int adu_putmem(struct pdbg_target *target, uint64_t start_addr, uint8_t *input, uint64_t size);
 
 /* Functions to ram instructions */
 #define THREAD_STATUS_DISABLED  PPC_BIT(0)
@@ -65,17 +65,17 @@ int ram_getmsr(struct thread *thread, uint64_t *value);
 int ram_putmsr(struct thread *thread, uint64_t value);
 int ram_getmem(struct thread *thread, uint64_t addr, uint64_t *value);
 uint64_t thread_status(struct thread *thread);
-int ram_stop_thread(struct target *thread);
-int ram_step_thread(struct target *thread, int count);
-int ram_start_thread(struct target *thread);
-int ram_sreset_thread(struct target *thread);
-void fsi_destroy(struct target *target);
+int ram_stop_thread(struct pdbg_target *thread);
+int ram_step_thread(struct pdbg_target *thread, int count);
+int ram_start_thread(struct pdbg_target *thread);
+int ram_sreset_thread(struct pdbg_target *thread);
+void fsi_destroy(struct pdbg_target *target);
 
-int htm_stop(struct target *target);
-int htm_start(struct target *target);
-int htm_status(struct target *target);
-int htm_reset(struct target *target, uint64_t *base, uint64_t *size);
-int htm_dump(struct target *target, uint64_t, const char *);
+int htm_stop(struct pdbg_target *target);
+int htm_start(struct pdbg_target *target);
+int htm_status(struct pdbg_target *target);
+int htm_reset(struct pdbg_target *target, uint64_t *base, uint64_t *size);
+int htm_dump(struct pdbg_target *target, uint64_t, const char *);
 
 /* GDB server functionality */
 int gdbserver_start(uint16_t port);
diff --git a/libpdbg/p8chip.c b/libpdbg/p8chip.c
index e882749..51de7b9 100644
--- a/libpdbg/p8chip.c
+++ b/libpdbg/p8chip.c
@@ -296,7 +296,7 @@ static int p8_ram_destroy(struct thread *thread)
 /*
  * Initialise all viable threads for ramming on the given chiplet.
  */
-static int p8_thread_probe(struct target *target)
+static int p8_thread_probe(struct pdbg_target *target)
 {
 	struct thread *thread = target_to_thread(target);
 
@@ -322,7 +322,7 @@ struct thread p8_thread = {
 };
 DECLARE_HW_UNIT(p8_thread);
 
-static int p8_chiplet_probe(struct target *target)
+static int p8_chiplet_probe(struct pdbg_target *target)
 {
 	uint64_t value;
 	struct chiplet *chiplet = target_to_chiplet(target);
diff --git a/libpdbg/p9chip.c b/libpdbg/p9chip.c
index 96ce067..037f03e 100644
--- a/libpdbg/p9chip.c
+++ b/libpdbg/p9chip.c
@@ -47,14 +47,14 @@
 
 static uint64_t thread_read(struct thread *thread, uint64_t addr, uint64_t *data)
 {
-	struct target *chip = require_target_parent(&thread->target);
+	struct pdbg_target *chip = require_target_parent(&thread->target);
 
 	return pib_read(chip, addr, data);
 }
 
 static uint64_t thread_write(struct thread *thread, uint64_t addr, uint64_t data)
 {
-	struct target *chip = require_target_parent(&thread->target);
+	struct pdbg_target *chip = require_target_parent(&thread->target);
 
 	return pib_write(chip, addr, data);
 }
@@ -70,7 +70,7 @@ static uint64_t p9_get_thread_status(struct thread *thread)
 	return status;
 }
 
-static int p9_thread_probe(struct target *target)
+static int p9_thread_probe(struct pdbg_target *target)
 {
 	struct thread *thread = target_to_thread(target);
 
@@ -215,7 +215,7 @@ struct thread p9_thread = {
 };
 DECLARE_HW_UNIT(p9_thread);
 
-static int p9_chiplet_probe(struct target *target)
+static int p9_chiplet_probe(struct pdbg_target *target)
 {
 	int i = 0;
 	uint64_t value;
diff --git a/libpdbg/target.c b/libpdbg/target.c
index 74ad0bc..e113e77 100644
--- a/libpdbg/target.c
+++ b/libpdbg/target.c
@@ -112,7 +112,7 @@ static int pib_indirect_write(struct pib *pib, uint64_t addr, uint64_t data)
 	return 0;
 }
 
-int pib_read(struct target *pib_dt, uint64_t addr, uint64_t *data)
+int pib_read(struct pdbg_target *pib_dt, uint64_t addr, uint64_t *data)
 {
 	struct pib *pib;
 	struct dt_node *dn = pib_dt->dn;
@@ -128,7 +128,7 @@ int pib_read(struct target *pib_dt, uint64_t addr, uint64_t *data)
 	return rc;
 }
 
-int pib_write(struct target *pib_dt, uint64_t addr, uint64_t data)
+int pib_write(struct pdbg_target *pib_dt, uint64_t addr, uint64_t data)
 {
 	struct pib *pib;
 	struct dt_node *dn = pib_dt->dn;
@@ -144,7 +144,7 @@ int pib_write(struct target *pib_dt, uint64_t addr, uint64_t data)
 	return rc;
 }
 
-int opb_read(struct target *opb_dt, uint32_t addr, uint32_t *data)
+int opb_read(struct pdbg_target *opb_dt, uint32_t addr, uint32_t *data)
 {
 	struct opb *opb;
 	struct dt_node *dn = opb_dt->dn;
@@ -156,7 +156,7 @@ int opb_read(struct target *opb_dt, uint32_t addr, uint32_t *data)
 	return opb->read(opb, addr64, data);
 }
 
-int opb_write(struct target *opb_dt, uint32_t addr, uint32_t data)
+int opb_write(struct pdbg_target *opb_dt, uint32_t addr, uint32_t data)
 {
 	struct opb *opb;
 	struct dt_node *dn = opb_dt->dn;
@@ -169,7 +169,7 @@ int opb_write(struct target *opb_dt, uint32_t addr, uint32_t data)
 	return opb->write(opb, addr64, data);
 }
 
-int fsi_read(struct target *fsi_dt, uint32_t addr, uint32_t *data)
+int fsi_read(struct pdbg_target *fsi_dt, uint32_t addr, uint32_t *data)
 {
 	struct fsi *fsi;
 	struct dt_node *dn = fsi_dt->dn;
@@ -181,7 +181,7 @@ int fsi_read(struct target *fsi_dt, uint32_t addr, uint32_t *data)
 	return fsi->read(fsi, addr64, data);
 }
 
-int fsi_write(struct target *fsi_dt, uint32_t addr, uint32_t data)
+int fsi_write(struct pdbg_target *fsi_dt, uint32_t addr, uint32_t data)
 {
 	struct fsi *fsi;
 	struct dt_node *dn = fsi_dt->dn;
@@ -194,7 +194,7 @@ int fsi_write(struct target *fsi_dt, uint32_t addr, uint32_t data)
 	return fsi->write(fsi, addr64, data);
 }
 
-struct target *require_target_parent(struct target *target)
+struct pdbg_target *require_target_parent(struct pdbg_target *target)
 {
 	struct dt_node *dn;
 
@@ -203,9 +203,9 @@ struct target *require_target_parent(struct target *target)
 }
 
 /* Finds the given class. Returns NULL if not found. */
-struct target_class *find_target_class(const char *name)
+struct pdbg_target_class *find_target_class(const char *name)
 {
-	struct target_class *target_class;
+	struct pdbg_target_class *target_class;
 
 	list_for_each(&target_classes, target_class, class_head_link)
 		if (!strcmp(target_class->name, name))
@@ -216,9 +216,9 @@ struct target_class *find_target_class(const char *name)
 
 /* Same as above but dies with an assert if the target class doesn't
  * exist */
-struct target_class *require_target_class(const char *name)
+struct pdbg_target_class *require_target_class(const char *name)
 {
-	struct target_class *target_class;
+	struct pdbg_target_class *target_class;
 
 	target_class = find_target_class(name);
 	if (!target_class) {
@@ -229,9 +229,9 @@ struct target_class *require_target_class(const char *name)
 }
 
 /* Returns the existing class or allocates space for a new one */
-static struct target_class *get_target_class(const char *name)
+static struct pdbg_target_class *get_target_class(const char *name)
 {
-	struct target_class *target_class;
+	struct pdbg_target_class *target_class;
 
 	if ((target_class = find_target_class(name)))
 		return target_class;
@@ -251,7 +251,7 @@ extern struct hw_init_info *__stop_hw_units;
 struct hw_unit_info *find_compatible_target(const char *compat)
 {
 	struct hw_unit_info **p;
-	struct target *target;
+	struct pdbg_target *target;
 
 	for (p = &__start_hw_units; p < (struct hw_unit_info **) &__stop_hw_units; p++) {
 		target = (*p)->hw_unit + (*p)->struct_target_offset;
@@ -266,16 +266,16 @@ void targets_init(void *fdt)
 {
 	struct dt_node *dn;
 	const struct dt_property *p;
-	struct target_class *target_class;
+	struct pdbg_target_class *target_class;
 	struct hw_unit_info *hw_unit_info;
 	void *new_hw_unit;
-	struct target *new_target;
+	struct pdbg_target *new_target;
 	uint32_t index;
 
 	dt_root = dt_new_root("");
 	dt_expand(fdt);
 
-	/* Now we need to walk the device-tree, assign struct targets
+	/* Now we need to walk the device-tree, assign struct pdbg_targets
 	 * to each of the nodes and add them to the appropriate target
 	 * classes */
 	dt_for_each_node(dt_root, dn) {
diff --git a/libpdbg/target.h b/libpdbg/target.h
index debe8b2..8540d0d 100644
--- a/libpdbg/target.h
+++ b/libpdbg/target.h
@@ -31,25 +31,25 @@
 
 enum chip_type {CHIP_UNKNOWN, CHIP_P8, CHIP_P8NV, CHIP_P9};
 
-struct target_class {
+struct pdbg_target_class {
 	char *name;
 	struct list_head targets;
 	struct list_node class_head_link;
 };
 
-struct target {
+struct pdbg_target {
 	char *name;
 	char *compatible;
 	char *class;
-	int (*probe)(struct target *target);
+	int (*probe)(struct pdbg_target *target);
 	int index;
 	struct dt_node *dn;
 	struct list_node class_link;
 };
 
-struct target *require_target_parent(struct target *target);
-struct target_class *find_target_class(const char *name);
-struct target_class *require_target_class(const char *name);
+struct pdbg_target *require_target_parent(struct pdbg_target *target);
+struct pdbg_target_class *find_target_class(const char *name);
+struct pdbg_target_class *require_target_class(const char *name);
 
 extern struct list_head empty_list;
 #define for_each_class_target(class_name, target)			\
@@ -71,7 +71,7 @@ struct hw_unit_info {
 	const struct hw_unit_info __used __section("hw_units") *name ##_hw_unit_p = &name ##_hw_unit
 
 struct htm {
-	struct target target;
+	struct pdbg_target target;
 	int (*start)(struct htm *);
 	int (*stop)(struct htm *);
 	int (*reset)(struct htm *, uint64_t *, uint64_t *);
@@ -82,14 +82,14 @@ struct htm {
 #define target_to_htm(x) container_of(x, struct htm, target)
 
 struct adu {
-	struct target target;
+	struct pdbg_target target;
 	int (*getmem)(struct adu *, uint64_t, uint64_t *);
 	int (*putmem)(struct adu *, uint64_t, uint64_t, int);
 };
 #define target_to_adu(x) container_of(x, struct adu, target)
 
 struct pib {
-	struct target target;
+	struct pdbg_target target;
 	int (*read)(struct pib *, uint64_t, uint64_t *);
 	int (*write)(struct pib *, uint64_t, uint64_t);
 	void *priv;
@@ -97,14 +97,14 @@ struct pib {
 #define target_to_pib(x) container_of(x, struct pib, target)
 
 struct opb {
-	struct target target;
+	struct pdbg_target target;
 	int (*read)(struct opb *, uint32_t, uint32_t *);
 	int (*write)(struct opb *, uint32_t, uint32_t);
 };
 #define target_to_opb(x) container_of(x, struct opb, target)
 
 struct fsi {
-	struct target target;
+	struct pdbg_target target;
 	int (*read)(struct fsi *, uint32_t, uint32_t *);
 	int (*write)(struct fsi *, uint32_t, uint32_t);
 	enum chip_type chip_type;
@@ -112,12 +112,12 @@ struct fsi {
 #define target_to_fsi(x) container_of(x, struct fsi, target)
 
 struct chiplet {
-	struct target target;
+	struct pdbg_target target;
 };
 #define target_to_chiplet(x) container_of(x, struct chiplet, target)
 
 struct thread {
-	struct target target;
+	struct pdbg_target target;
 	uint64_t status;
 	int id;
 	int (*step)(struct thread *, int);
@@ -137,11 +137,11 @@ struct thread {
 void targets_init(void *fdt);
 void target_probe(void);
 
-int pib_read(struct target *pib_dt, uint64_t addr, uint64_t *data);
-int pib_write(struct target *pib_dt, uint64_t addr, uint64_t data);
-int opb_read(struct target *opb_dt, uint32_t addr, uint32_t *data);
-int opb_write(struct target *opb_dt, uint32_t addr, uint32_t data);
-int fsi_read(struct target *fsi_dt, uint32_t addr, uint32_t *data);
-int fsi_write(struct target *fsi_dt, uint32_t addr, uint32_t data);
+int pib_read(struct pdbg_target *pib_dt, uint64_t addr, uint64_t *data);
+int pib_write(struct pdbg_target *pib_dt, uint64_t addr, uint64_t data);
+int opb_read(struct pdbg_target *opb_dt, uint32_t addr, uint32_t *data);
+int opb_write(struct pdbg_target *opb_dt, uint32_t addr, uint32_t data);
+int fsi_read(struct pdbg_target *fsi_dt, uint32_t addr, uint32_t *data);
+int fsi_write(struct pdbg_target *fsi_dt, uint32_t addr, uint32_t data);
 
 #endif
diff --git a/src/main.c b/src/main.c
index 07df78b..3b722e3 100644
--- a/src/main.c
+++ b/src/main.c
@@ -366,12 +366,12 @@ static bool parse_options(int argc, char *argv[])
 }
 
 /* Returns the sum of return codes. This can be used to count how many targets the callback was run on. */
-static int for_each_child_target(char *class, struct target *parent,
-				 int (*cb)(struct target *, uint32_t, uint64_t *, uint64_t *),
+static int for_each_child_target(char *class, struct pdbg_target *parent,
+				 int (*cb)(struct pdbg_target *, uint32_t, uint64_t *, uint64_t *),
 				 uint64_t *arg1, uint64_t *arg2)
 {
 	int rc = 0;
-	struct target *target;
+	struct pdbg_target *target;
 	uint32_t index;
 	struct dt_node *dn;
 
@@ -396,12 +396,12 @@ static int for_each_child_target(char *class, struct target *parent,
 	return rc;
 }
 
-static int for_each_target(char *class, int (*cb)(struct target *, uint32_t, uint64_t *, uint64_t *), uint64_t *arg1, uint64_t *arg2)
+static int for_each_target(char *class, int (*cb)(struct pdbg_target *, uint32_t, uint64_t *, uint64_t *), uint64_t *arg1, uint64_t *arg2)
 {
 	return for_each_child_target(class, NULL, cb, arg1, arg2);
 }
 
-static int getcfam(struct target *target, uint32_t index, uint64_t *addr, uint64_t *unused)
+static int getcfam(struct pdbg_target *target, uint32_t index, uint64_t *addr, uint64_t *unused)
 {
 	uint32_t value;
 
@@ -413,7 +413,7 @@ static int getcfam(struct target *target, uint32_t index, uint64_t *addr, uint64
 	return 1;
 }
 
-static int putcfam(struct target *target, uint32_t index, uint64_t *addr, uint64_t *data)
+static int putcfam(struct pdbg_target *target, uint32_t index, uint64_t *addr, uint64_t *data)
 {
 	if (fsi_write(target, *addr, *data))
 		return 0;
@@ -421,7 +421,7 @@ static int putcfam(struct target *target, uint32_t index, uint64_t *addr, uint64
 	return 1;
 }
 
-static int getscom(struct target *target, uint32_t index, uint64_t *addr, uint64_t *unused)
+static int getscom(struct pdbg_target *target, uint32_t index, uint64_t *addr, uint64_t *unused)
 {
 	uint64_t value;
 
@@ -433,7 +433,7 @@ static int getscom(struct target *target, uint32_t index, uint64_t *addr, uint64
 	return 1;
 }
 
-static int putscom(struct target *target, uint32_t index, uint64_t *addr, uint64_t *data)
+static int putscom(struct pdbg_target *target, uint32_t index, uint64_t *addr, uint64_t *data)
 {
 	if (pib_write(target, *addr, *data))
 		return 0;
@@ -441,7 +441,7 @@ static int putscom(struct target *target, uint32_t index, uint64_t *addr, uint64
 	return 1;
 }
 
-static int print_thread_status(struct target *thread_target, uint32_t index, uint64_t *status, uint64_t *unused1)
+static int print_thread_status(struct pdbg_target *thread_target, uint32_t index, uint64_t *status, uint64_t *unused1)
 {
 	struct thread *thread = target_to_thread(thread_target);
 
@@ -449,7 +449,7 @@ static int print_thread_status(struct target *thread_target, uint32_t index, uin
 	return 1;
 }
 
-static int print_chiplet_thread_status(struct target *chiplet_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
+static int print_chiplet_thread_status(struct pdbg_target *chiplet_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
 {
 	uint64_t status = -1UL;
 	int i, rc;
@@ -494,7 +494,7 @@ static int print_chiplet_thread_status(struct target *chiplet_target, uint32_t i
 	return rc;
 }
 
-static int print_proc_thread_status(struct target *pib_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
+static int print_proc_thread_status(struct pdbg_target *pib_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
 {
 	printf("\np%01dt: 0 1 2 3 4 5 6 7\n", index);
 	return for_each_child_target("chiplet", pib_target, print_chiplet_thread_status, NULL, NULL);
@@ -530,7 +530,7 @@ static void print_proc_reg(struct thread *thread, uint64_t reg, uint64_t value,
 		printf("0x%016" PRIx64 "\n", value);
 }
 
-static int putprocreg(struct target *thread_target, uint32_t index, uint64_t *reg, uint64_t *value)
+static int putprocreg(struct pdbg_target *thread_target, uint32_t index, uint64_t *reg, uint64_t *value)
 {
 	struct thread *thread = target_to_thread(thread_target);
 	int rc;
@@ -549,7 +549,7 @@ static int putprocreg(struct target *thread_target, uint32_t index, uint64_t *re
 	return 0;
 }
 
-static int getprocreg(struct target *thread_target, uint32_t index, uint64_t *reg, uint64_t *unused)
+static int getprocreg(struct pdbg_target *thread_target, uint32_t index, uint64_t *reg, uint64_t *unused)
 {
 	struct thread *thread = target_to_thread(thread_target);
 	int rc;
@@ -574,7 +574,7 @@ static int putmem(uint64_t addr)
 {
         uint8_t *buf;
         int read_size, rc = 0;
-        struct target *adu_target;
+        struct pdbg_target *adu_target;
 
 	for_each_class_target("adu", adu_target)
 		break;
@@ -595,22 +595,22 @@ static int putmem(uint64_t addr)
         return rc;
 }
 
-static int start_thread(struct target *thread_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
+static int start_thread(struct pdbg_target *thread_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
 {
 	return ram_start_thread(thread_target) ? 0 : 1;
 }
 
-static int step_thread(struct target *thread_target, uint32_t index, uint64_t *count, uint64_t *unused1)
+static int step_thread(struct pdbg_target *thread_target, uint32_t index, uint64_t *count, uint64_t *unused1)
 {
 	return ram_step_thread(thread_target, *count) ? 0 : 1;
 }
 
-static int stop_thread(struct target *thread_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
+static int stop_thread(struct pdbg_target *thread_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
 {
 	return ram_stop_thread(thread_target) ? 0 : 1;
 }
 
-static int sreset_thread(struct target *thread_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
+static int sreset_thread(struct pdbg_target *thread_target, uint32_t index, uint64_t *unused, uint64_t *unused1)
 {
 	return ram_sreset_thread(thread_target) ? 0 : 1;
 }
@@ -670,7 +670,7 @@ static char *get_htm_dump_filename(void)
 
 static int run_htm_start(void)
 {
-	struct target *target;
+	struct pdbg_target *target;
 	int rc = 0;
 
 	for_each_class_target("htm", target) {
@@ -687,7 +687,7 @@ static int run_htm_start(void)
 
 static int run_htm_stop(void)
 {
-	struct target *target;
+	struct pdbg_target *target;
 	int rc = 0;
 
 	for_each_class_target("htm", target) {
@@ -704,7 +704,7 @@ static int run_htm_stop(void)
 
 static int run_htm_status(void)
 {
-	struct target *target;
+	struct pdbg_target *target;
 	int rc = 0;
 
 	for_each_class_target("htm", target) {
@@ -723,7 +723,7 @@ static int run_htm_status(void)
 static int run_htm_reset(void)
 {
 	uint64_t old_base = 0, base, size;
-	struct target *target;
+	struct pdbg_target *target;
 	int rc = 0;
 
 	for_each_class_target("htm", target) {
@@ -748,7 +748,7 @@ static int run_htm_reset(void)
 
 static int run_htm_dump(void)
 {
-	struct target *target;
+	struct pdbg_target *target;
 	char *filename;
 	int rc = 0;
 
@@ -774,7 +774,7 @@ static int run_htm_dump(void)
 static int run_htm_trace(void)
 {
 	uint64_t old_base = 0, base, size;
-	struct target *target;
+	struct pdbg_target *target;
 	int rc = 0;
 
 	for_each_class_target("htm", target) {
@@ -812,7 +812,7 @@ static int run_htm_trace(void)
 
 static int run_htm_analyse(void)
 {
-	struct target *target;
+	struct pdbg_target *target;
 	char *filename;
 	int rc = 0;
 
@@ -858,7 +858,7 @@ extern unsigned char _binary_p9_host_dtb_o_start;
 extern unsigned char _binary_p9_host_dtb_o_end;
 static int target_select(void)
 {
-	struct target *fsi, *pib, *chip, *thread;
+	struct pdbg_target *fsi, *pib, *chip, *thread;
 
 	switch (backend) {
 	case I2C:
@@ -984,7 +984,7 @@ void print_target(struct dt_node *dn, int level)
 		return;
 
 	if (strcmp(status, "hidden")) {
-		struct target *target;
+		struct pdbg_target *target;
 
 		for (i = 0; i < level; i++)
 			printf("    ");
@@ -1014,7 +1014,7 @@ int main(int argc, char *argv[])
 {
 	int rc = 0;
 	uint8_t *buf;
-	struct target *target;
+	struct pdbg_target *target;
 
 	if (parse_options(argc, argv))
 		return 1;