Skip to contentSkip to conversation

dfu: ram support

PATCH Superseded Afzal Mohammed 4 participants 14 messages Sep 13, 2013 – Sep 14, 2013

v3 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

v3 cover dfu: ram support

Hi,

DFU spec mentions it as a method to upgrade firmware (software stored in writable non-volatile memory). It also says other potential uses of DFU is beyond scope of the spec.

Here such a beyond the scope use is being attempted - directly pumping binary images from host via USB to RAM. This facility is a developer centric one in that it gives advantage over upgrading non-volatile memory for testing new images every time during development and/or testing.

Directly putting image onto RAM would speed up upgrade process. This and convenience was the initial thoughts that led to doing this, speed improvement over MMC was only 1 second though - 6 sec on RAM as opposed to 7 sec on MMC in beagle bone, perhaps enabling cache and/or optimizing DFU framework to avoid multiple copy for ram (if worth) may help, and on other platforms and other boot media like NAND maybe improvement would be higher.

And for a platform that doesn't yet have proper DFU suppport for non-volatile media's, DFU to RAM can be used.

Another minor advantage would be to increase life of mmc/nand as it would be less used during development/testing.

usage: <image name> ram <start address> <size>
eg. kernel ram 0x81000000 0x1000000

Downloading images to RAM using DFU is not something new, this is acheived in openmoko also.

DFU on RAM can be used for extracting RAM contents to host using dfu upload. Perhaps this can be extended to io for squeezing out register

In addition to ram support, a minor unification of dfu read/write enum's currently duplicated in mmc/nand is done, helping ram support too.

Also dfu ram support is added for am335x SoC based boards.

Based on: usb master branch

Regards
Afzal

v3: collected tags, error used instead of printf
v2: unified read/write dfu ops enum, added am335x support

Afzal Mohammed (3):
dfu: unify mmc/nand read/write ops enum
dfu: ram support
am335x_evm: enable DFU RAM

 drivers/dfu/Makefile         |  1 +
 drivers/dfu/dfu.c            |  7 ++--
 drivers/dfu/dfu_mmc.c        |  9 ++----
 drivers/dfu/dfu_nand.c       |  7 +---
 drivers/dfu/dfu_ram.c        | 76 ++++++++++++++++++++++++++++++++++++++++++++
 include/configs/am335x_evm.h |  6 ++++
 include/dfu.h                | 23 ++++++++++++++
 7 files changed, 114 insertions(+), 15 deletions(-)
 create mode 100644 drivers/dfu/dfu_ram.c
Signature · 1 line
1.8.2.135.g7b592fa
#1 lore raw

PATCH v3 1/3 dfu: unify mmc/nand read/write ops enum

MMC and NAND independently defines same enumerators for read/write. Unify them by defining enum in dfu header. RAM support that is being added newly also can make use of it.

Cc Marek Vasut <[email protected]>
Cc Lukasz Majewski <[email protected]>
Cc Pantelis Antoniou <[email protected]>

---

v3: collected tag
v2: new

 drivers/dfu/dfu_mmc.c  | 9 ++-------
 drivers/dfu/dfu_nand.c | 7 +------
 include/dfu.h          | 5 +++++
 3 files changed, 8 insertions(+), 13 deletions(-)
drivers/dfu/dfu_mmc.c +2 -7
index 0871a77..f942758 100644
@@ -13,16 +13,11 @@
 #include <div64.h>
 #include <dfu.h>
 
-enum dfu_mmc_op {
-	DFU_OP_READ = 1,
-	DFU_OP_WRITE,
-};
-
 static unsigned char __aligned(CONFIG_SYS_CACHELINE_SIZE)
 				dfu_file_buf[CONFIG_SYS_DFU_MAX_FILE_SIZE];
 static long dfu_file_buf_len;
 
-static int mmc_block_op(enum dfu_mmc_op op, struct dfu_entity *dfu,
+static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
 			u64 offset, void *buf, long *len)
 {
 	char cmd_buf[DFU_CMD_BUF_SIZE];
@@ -65,7 +60,7 @@ static int mmc_file_buffer(struct dfu_entity *dfu, void *buf, long *len)
 	return 0;
 }
 
-static int mmc_file_op(enum dfu_mmc_op op, struct dfu_entity *dfu,
+static int mmc_file_op(enum dfu_op op, struct dfu_entity *dfu,
 			void *buf, long *len)
 {
 	char cmd_buf[DFU_CMD_BUF_SIZE];
drivers/dfu/dfu_nand.c +1 -6
index 0ec12cf..edbf5a9 100644
@@ -19,12 +19,7 @@
 #include <jffs2/load_kernel.h>
 #include <nand.h>
 
-enum dfu_nand_op {
-	DFU_OP_READ = 1,
-	DFU_OP_WRITE,
-};
-
-static int nand_block_op(enum dfu_nand_op op, struct dfu_entity *dfu,
+static int nand_block_op(enum dfu_op op, struct dfu_entity *dfu,
 			u64 offset, void *buf, long *len)
 {
 	loff_t start, lim;
include/dfu.h +5 -0
index 392cef1..6a3e253 100644
@@ -29,6 +29,11 @@ enum dfu_layout {
 	DFU_FS_EXT4,
 };
 
+enum dfu_op {
+	DFU_OP_READ = 1,
+	DFU_OP_WRITE,
+};
+
 struct mmc_internal_data {
 	/* RAW programming */
 	unsigned int lba_start;
Signature · 1 line
1.8.2.135.g7b592fa
#2 lore raw

PATCH v3 1/3 dfu: unify mmc/nand read/write ops enum

Dear Afzal Mohammed,

Quoted 10 lines

MMC and NAND independently defines same enumerators for read/write. Unify them by defining enum in dfu header. RAM support that is being added newly also can make use of it.

Cc Marek Vasut <[email protected]>
Cc Lukasz Majewski <[email protected]>
Cc Pantelis Antoniou <[email protected]>

---

Best regards,
Marek Vasut

#3 lore raw

PATCH v3 2/3 dfu: ram support

In reply to Afzal Mohammed

DFU spec mentions it as a method to upgrade firmware (software stored in writable non-volatile memory). It also says other potential uses of DFU is beyond scope of the spec.

Here such a beyond the scope use is being attempted - directly pumping binary images from host via USB to RAM. This facility is a developer centric one in that it gives advantage over upgrading non-volatile memory for testing new images every time during development and/or testing.

Directly putting image onto RAM would speed up upgrade process. This and convenience was the initial thoughts that led to doing this, speed improvement over MMC was only 1 second though - 6 sec on RAM as opposed to 7 sec on MMC in beagle bone, perhaps enabling cache and/or optimizing DFU framework to avoid multiple copy for ram (if worth) may help, and on other platforms and other boot media like NAND maybe improvement would be higher.

And for a platform that doesn't yet have proper DFU suppport for non-volatile media's, DFU to RAM can be used.

Another minor advantage would be to increase life of mmc/nand as it would be less used during development/testing.

usage: <image name> ram <start address> <size>
eg. kernel ram 0x81000000 0x1000000

Downloading images to RAM using DFU is not something new, this is acheived in openmoko also.

DFU on RAM can be used for extracting RAM contents to host using dfu upload. Perhaps this can be extended to io for squeezing out register dump through usb, if it is worth.

Cc Marek Vasut <[email protected]>
Cc Lukasz Majewski <[email protected]>
Cc Pantelis Antoniou <[email protected]>

---

v3: error used instead of printf
v2: remove read/write enumerator define's, instead use new common ones

 drivers/dfu/Makefile  |  1 +
 drivers/dfu/dfu.c     |  7 +++--
 drivers/dfu/dfu_ram.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++
 include/dfu.h         | 18 ++++++++++++
 4 files changed, 100 insertions(+), 2 deletions(-)
 create mode 100644 drivers/dfu/dfu_ram.c
drivers/dfu/Makefile +1 -0
index fca370a..de9e44e 100644
@@ -12,6 +12,7 @@ LIB	= $(obj)libdfu.o
 COBJS-$(CONFIG_DFU_FUNCTION) += dfu.o
 COBJS-$(CONFIG_DFU_MMC) += dfu_mmc.o
 COBJS-$(CONFIG_DFU_NAND) += dfu_nand.o
+COBJS-$(CONFIG_DFU_RAM) += dfu_ram.o
 
 SRCS    := $(COBJS-y:.o=.c)
 OBJS	:= $(addprefix $(obj),$(COBJS-y))
drivers/dfu/dfu.c +5 -2
index 689f5db..56b21c7 100644
@@ -348,6 +348,9 @@ static int dfu_fill_entity(struct dfu_entity *dfu, char *s, int alt,
 	} else if (strcmp(interface, "nand") == 0) {
 		if (dfu_fill_entity_nand(dfu, s))
 			return -1;
+	} else if (strcmp(interface, "ram") == 0) {
+		if (dfu_fill_entity_ram(dfu, s))
+			return -1;
 	} else {
 		printf("%s: Device %s not (yet) supported!\n",
 		       __func__,  interface);
@@ -397,14 +400,14 @@ int dfu_config_entities(char *env, char *interface, int num)
 
 const char *dfu_get_dev_type(enum dfu_device_type t)
 {
-	const char *dev_t[] = {NULL, "eMMC", "OneNAND", "NAND" };
+	const char *dev_t[] = {NULL, "eMMC", "OneNAND", "NAND", "RAM" };
 	return dev_t[t];
 }
 
 const char *dfu_get_layout(enum dfu_layout l)
 {
 	const char *dfu_layout[] = {NULL, "RAW_ADDR", "FAT", "EXT2",
-					   "EXT3", "EXT4" };
+					   "EXT3", "EXT4", "RAM_ADDR" };
 	return dfu_layout[l];
 }
 
drivers/dfu/dfu_ram.c new file +76 -0

76 lines not on this page · raw message

include/dfu.h +18 -0
index 6a3e253..6f4bba4 100644
@@ -19,6 +19,7 @@ enum dfu_device_type {
 	DFU_DEV_MMC = 1,
 	DFU_DEV_ONENAND,
 	DFU_DEV_NAND,
+	DFU_DEV_RAM,
 };
 
 enum dfu_layout {
@@ -27,6 +28,7 @@ enum dfu_layout {
 	DFU_FS_EXT2,
 	DFU_FS_EXT3,
 	DFU_FS_EXT4,
+	DFU_RAM_ADDR,
 };
 
 enum dfu_op {
@@ -56,6 +58,11 @@ struct nand_internal_data {
 	unsigned int ubi;
 };
 
+struct ram_internal_data {
+	void		*start;
+	unsigned int	size;
+};
+
 static inline unsigned int get_mmc_blk_size(int dev)
 {
 	return find_mmc_device(dev)->read_bl_len;
@@ -81,6 +88,7 @@ struct dfu_entity {
 	union {
 		struct mmc_internal_data mmc;
 		struct nand_internal_data nand;
+		struct ram_internal_data ram;
 	} data;
 
 	int (*read_medium)(struct dfu_entity *dfu,
@@ -143,4 +151,14 @@ static inline int dfu_fill_entity_nand(struct dfu_entity *dfu, char *s)
 }
 #endif
 
+#ifdef CONFIG_DFU_RAM
+extern int dfu_fill_entity_ram(struct dfu_entity *dfu, char *s);
+#else
+static inline int dfu_fill_entity_ram(struct dfu_entity *dfu, char *s)
+{
+	puts("RAM support not available!\n");
+	return -1;
+}
+#endif
+
 #endif /* __DFU_ENTITY_H_ */
Signature · 1 line
1.8.2.135.g7b592fa
#4 lore raw

PATCH v3 2/3 dfu: ram support

Hi Afzal,

Quoted 34 lines

DFU spec mentions it as a method to upgrade firmware (software stored in writable non-volatile memory). It also says other potential uses of DFU is beyond scope of the spec.

Here such a beyond the scope use is being attempted - directly pumping binary images from host via USB to RAM. This facility is a developer centric one in that it gives advantage over upgrading non-volatile memory for testing new images every time during development and/or testing.

Directly putting image onto RAM would speed up upgrade process. This and convenience was the initial thoughts that led to doing this, speed improvement over MMC was only 1 second though - 6 sec on RAM as opposed to 7 sec on MMC in beagle bone, perhaps enabling cache and/or optimizing DFU framework to avoid multiple copy for ram (if worth) may help, and on other platforms and other boot media like NAND maybe improvement would be higher.

And for a platform that doesn't yet have proper DFU suppport for non-volatile media's, DFU to RAM can be used.

Another minor advantage would be to increase life of mmc/nand as it would be less used during development/testing.

usage: <image name> ram <start address> <size>
eg. kernel ram 0x81000000 0x1000000

Downloading images to RAM using DFU is not something new, this is acheived in openmoko also.

DFU on RAM can be used for extracting RAM contents to host using dfu upload. Perhaps this can be extended to io for squeezing out register dump through usb, if it is worth.

Quoted 8 lines
Cc Marek Vasut <[email protected]>
Cc Lukasz Majewski <[email protected]>
Cc Pantelis Antoniou <[email protected]>

---

v3: error used instead of printf
v2: remove read/write enumerator define's, instead use new common ones

Signature · 5 lines
Best regards,

Lukasz Majewski

Samsung R&D Institute Poland (SRPOL) | Linux Platform Group
#5 lore raw

PATCH v3 2/3 dfu: ram support

In reply to Afzal Mohammed

Dear Afzal Mohammed,

[...]

Quoted 4 lines
drivers/dfu/dfu_ram.c new file +4 -0
+int dfu_fill_entity_ram(struct dfu_entity *dfu, char *s)
+{
+	char *st;
+

drivers/dfu/dfu_ram.c line 68

Quoted 10 lines
drivers/dfu/dfu_ram.c new file +10 -0
+	dfu->dev_type = DFU_DEV_RAM;
+	st = strsep(&s, " ");
+	if (strcmp(st, "ram")) {
+		error("unsupported device: %s\n", st);
+		return -ENODEV;
+	}
+
+	dfu->layout = DFU_RAM_ADDR;
+	dfu->data.ram.start = (void *)simple_strtoul(s, &s, 16);
+	dfu->data.ram.size = simple_strtoul(++s, &s, 16);

This ++s, &s is quite crazy ;-)

Otheriwse

Best regards,
Marek Vasut

#6 lore raw

PATCH v3 2/3 dfu: ram support

Quoted 5 lines · Marek Vasut

Dear Afzal Mohammed,

[...]

Quoted 16 lines
Quoted 4 lines
drivers/dfu/dfu_ram.c new file +4 -0
+int dfu_fill_entity_ram(struct dfu_entity *dfu, char *s)
+{
+	char *st;
+

drivers/dfu/dfu_ram.c line 68

Quoted 10 lines
drivers/dfu/dfu_ram.c new file +10 -0
+	dfu->dev_type = DFU_DEV_RAM;
+	st = strsep(&s, " ");
+	if (strcmp(st, "ram")) {
+		error("unsupported device: %s\n", st);
+		return -ENODEV;
+	}
+
+	dfu->layout = DFU_RAM_ADDR;
+	dfu->data.ram.start = (void *)simple_strtoul(s, &s, 16);
+	dfu->data.ram.size = simple_strtoul(++s, &s, 16);

This ++s, &s is quite crazy ;-)

Actually it's not just a neat trick, but instead it's not guaranteed to work. It's an inviation for problems that you don't need.

The order in which arguments for the call get evaluated isn't specified, so behaviour is uncertain here. Read: the construction happens to work by coincidence for individual setups, but isn't correct and need not work elsewhere, and may break in arbitrary ways at any occasion, and then is hard to track down since things may "seem to work" often enough or the bug won't show up when you are diagnosing the problem.

The code needs to get fixed before getting picked up. Doing the increment in a separate instruction is cheap and simple, the terse form is wrong.

virtually yours
Gerhard Sittig

Signature · 3 lines
DENX Software Engineering GmbH,     MD: Wolfgang Denk & Detlev Zundel
HRB 165235 Munich, Office: Kirchenstr. 5, D-82194 Groebenzell, Germany
Phone: +49-8142-66989-0 Fax: +49-8142-66989-80  Email: office at denx.de
#7 lore raw

PATCH v3 2/3 dfu: ram support

Hi Gerhard,

Quoted 35 lines · Marek Vasut
Quoted 5 lines

Dear Afzal Mohammed,

[...]

Quoted 16 lines
Quoted 4 lines
drivers/dfu/dfu_ram.c new file +4 -0
+int dfu_fill_entity_ram(struct dfu_entity *dfu, char *s)
+{
+	char *st;
+

drivers/dfu/dfu_ram.c line 68

Quoted 10 lines
drivers/dfu/dfu_ram.c new file +10 -0
+	dfu->dev_type = DFU_DEV_RAM;
+	st = strsep(&s, " ");
+	if (strcmp(st, "ram")) {
+		error("unsupported device: %s\n", st);
+		return -ENODEV;
+	}
+
+	dfu->layout = DFU_RAM_ADDR;
+	dfu->data.ram.start = (void *)simple_strtoul(s, &s, 16);
+	dfu->data.ram.size = simple_strtoul(++s, &s, 16);

This ++s, &s is quite crazy ;-)

Actually it's not just a neat trick, but instead it's not guaranteed to work. It's an inviation for problems that you don't need.

The order in which arguments for the call get evaluated isn't specified, so behaviour is uncertain here. Read: the construction happens to work by coincidence for individual setups, but isn't correct and need not work elsewhere, and may break in arbitrary ways at any occasion, and then is hard to track down since things may "seem to work" often enough or the bug won't show up when you are diagnosing the problem.

Quoted 3 lines

The code needs to get fixed before getting picked up. Doing the increment in a separate instruction is cheap and simple, the terse form is wrong.

It was me, who by some obscure reason introduced this faulty (non standard) code.

And probably Afzal copied it from dfu_mmc.c file.

So f...g embarrassing...

However the fix for that code at dfu_mmc.c file was already posted to ML.

Quoted 4 lines

virtually yours
Gerhard Sittig

Signature · 5 lines
Best regards,

Lukasz Majewski

Samsung R&D Institute Poland (SRPOL) | Linux Platform Group
#8 lore raw

PATCH v3 2/3 dfu: ram support

In reply to Gerhard Sittig

Dear Gerhard Sittig,

Quoted 34 lines · Marek Vasut
Quoted 4 lines

Dear Afzal Mohammed,

[...]

Quoted 16 lines
Quoted 4 lines
drivers/dfu/dfu_ram.c new file +4 -0
+int dfu_fill_entity_ram(struct dfu_entity *dfu, char *s)
+{
+	char *st;
+

drivers/dfu/dfu_ram.c line 68

Quoted 10 lines
drivers/dfu/dfu_ram.c new file +10 -0
+	dfu->dev_type = DFU_DEV_RAM;
+	st = strsep(&s, " ");
+	if (strcmp(st, "ram")) {
+		error("unsupported device: %s\n", st);
+		return -ENODEV;
+	}
+
+	dfu->layout = DFU_RAM_ADDR;
+	dfu->data.ram.start = (void *)simple_strtoul(s, &s, 16);
+	dfu->data.ram.size = simple_strtoul(++s, &s, 16);

This ++s, &s is quite crazy ;-)

Actually it's not just a neat trick, but instead it's not guaranteed to work. It's an inviation for problems that you don't need.

The order in which arguments for the call get evaluated isn't specified, so behaviour is uncertain here. Read: the construction happens to work by coincidence for individual setups, but isn't correct and need not work elsewhere, and may break in arbitrary ways at any occasion, and then is hard to track down since things may "seem to work" often enough or the bug won't show up when you are diagnosing the problem.

Quoted 3 lines

The code needs to get fixed before getting picked up. Doing the increment in a separate instruction is cheap and simple, the terse form is wrong.

Full ACK.

Best regards,
Marek Vasut

#9 lore raw

PATCH v3 2/3 dfu: ram support

In reply to Gerhard Sittig

Hi Gerhard, Marek,

Quoted 18 lines · Gerhard Sittig
Quoted 3 lines · Marek Vasut

drivers/dfu/dfu_ram.c line 68

Quoted 1 line
drivers/dfu/dfu_ram.c new file +1 -0
+	dfu->data.ram.size = simple_strtoul(++s, &s, 16);

This ++s, &s is quite crazy ;-)

Actually it's not just a neat trick, but instead it's not guaranteed to work. It's an inviation for problems that you don't need.

The order in which arguments for the call get evaluated isn't specified, so behaviour is uncertain here. Read: the construction happens to work by coincidence for individual setups, but isn't correct and need not work elsewhere, and may break in arbitrary ways at any occasion, and then is hard to track down since things may "seem to work" often enough or the bug won't show up when you are diagnosing the problem.

Quoted 3 lines

The code needs to get fixed before getting picked up. Doing the increment in a separate instruction is cheap and simple, the terse form is wrong.

Yes wrong me, I realize that result is compiler dependent and not guaranteed to work always, v4 posted taking care of the above.

Regards
Afzal

#10 lore raw

PATCH v3 2/3 dfu: ram support

+ Gerhard

Quoted 30 lines · Afzal Mohammed

Hi Gerhard, Marek,

Quoted 18 lines · Gerhard Sittig
Quoted 3 lines · Marek Vasut

drivers/dfu/dfu_ram.c line 68

Quoted 1 line
drivers/dfu/dfu_ram.c new file +1 -0
+	dfu->data.ram.size = simple_strtoul(++s, &s, 16);

This ++s, &s is quite crazy ;-)

Actually it's not just a neat trick, but instead it's not guaranteed to work. It's an inviation for problems that you don't need.

The order in which arguments for the call get evaluated isn't specified, so behaviour is uncertain here. Read: the construction happens to work by coincidence for individual setups, but isn't correct and need not work elsewhere, and may break in arbitrary ways at any occasion, and then is hard to track down since things may "seem to work" often enough or the bug won't show up when you are diagnosing the problem.

Quoted 3 lines

The code needs to get fixed before getting picked up. Doing the increment in a separate instruction is cheap and simple, the terse form is wrong.

Yes wrong me, I realize that result is compiler dependent and not guaranteed to work always, v4 posted taking care of the above.

Regards
Afzal

#11 lore raw

PATCH v3 3/3 am335x_evm: enable DFU RAM

In reply to Afzal Mohammed

Enable DFU for RAM, provide example dfu_alt_info

Cc Tom Rini <[email protected]>
Cc Marek Vasut <[email protected]>
Cc Lukasz Majewski <[email protected]>
Cc Pantelis Antoniou <[email protected]>

---

v3: collected tag
v2: new

 include/configs/am335x_evm.h | 6 ++++++
 1 file changed, 6 insertions(+)
include/configs/am335x_evm.h +6 -0
index 3de30fc..978fdf9 100644
@@ -100,6 +100,7 @@
 	"loadbootenv=load mmc ${mmcdev} ${loadaddr} ${bootenv}\0" \
 	"importbootenv=echo Importing environment from mmc ...; " \
 		"env import -t $loadaddr $filesize\0" \
+	"dfu_alt_info_ram=" DFU_ALT_INFO_RAM "\0" \
 	"ramargs=setenv bootargs console=${console} " \
 		"${optargs} " \
 		"root=${ramroot} " \
@@ -321,6 +322,11 @@
 	"kernel part 0 8;" \
 	"rootfs part 0 9"
 #endif
+#define CONFIG_DFU_RAM
+#define DFU_ALT_INFO_RAM \
+	"kernel ram 0x80200000 0xD80000;" \
+	"fdt ram 0x80F80000 0x80000;" \
+	"ramdisk ram 0x81000000 0x4000000"
 
 /*
  * Default to using SPI for environment, etc.
Signature · 1 line
1.8.2.135.g7b592fa
#12 lore raw

v3 cover dfu: ram support

In reply to Afzal Mohammed

Dear Afzal Mohammed,

Quoted 35 lines

Hi,

DFU spec mentions it as a method to upgrade firmware (software stored in writable non-volatile memory). It also says other potential uses of DFU is beyond scope of the spec.

Here such a beyond the scope use is being attempted - directly pumping binary images from host via USB to RAM. This facility is a developer centric one in that it gives advantage over upgrading non-volatile memory for testing new images every time during development and/or testing.

Directly putting image onto RAM would speed up upgrade process. This and convenience was the initial thoughts that led to doing this, speed improvement over MMC was only 1 second though - 6 sec on RAM as opposed to 7 sec on MMC in beagle bone, perhaps enabling cache and/or optimizing DFU framework to avoid multiple copy for ram (if worth) may help, and on other platforms and other boot media like NAND maybe improvement would be higher.

And for a platform that doesn't yet have proper DFU suppport for non-volatile media's, DFU to RAM can be used.

Another minor advantage would be to increase life of mmc/nand as it would be less used during development/testing.

usage: <image name> ram <start address> <size>
eg. kernel ram 0x81000000 0x1000000

Downloading images to RAM using DFU is not something new, this is acheived in openmoko also.

DFU on RAM can be used for extracting RAM contents to host using dfu upload. Perhaps this can be extended to io for squeezing out register

Quoted 7 lines

In addition to ram support, a minor unification of dfu read/write enum's currently duplicated in mmc/nand is done, helping ram support too.

Also dfu ram support is added for am335x SoC based boards.

Based on: usb master branch

CCing Heiko, can you please ACK/NAK ?

Best regards,
Marek Vasut

#13 lore raw

v3 cover dfu: ram support

Hi Heiko,

Quoted 1 line · Marek Vasut

CCing Heiko, can you please ACK/NAK ?

v4 has been posted fixing an issue in this series pointed out by Marek and Gerhard, please review v4 instead.

Regards
Afzal