dfu: add SF backend

This allows SPI Flash to be programmed using DFU. Signed-off-by: Stephen Warren <swarren@nvidia.com>

dfu: add SF backend
This allows SPI Flash to be programmed using DFU. Signed-off-by: Stephen Warren <swarren@nvidia.com>
Stephen Warren · Tom Rini
1 parent cb7bd2e07e
Showing 4 changed files with 165 additions and 0 deletions Side-by-side Diff
drivers/dfu/Makefile
drivers/dfu/dfu.c
drivers/dfu/dfu_sf.c
include/dfu.h
@@ -9,4 +9,5 @@
 obj-$(CONFIG_DFU_MMC) += dfu_mmc.o
 obj-$(CONFIG_DFU_NAND) += dfu_nand.o
 obj-$(CONFIG_DFU_RAM) += dfu_ram.o
+obj-$(CONFIG_DFU_SF) += dfu_sf.o
@@ -413,6 +413,9 @@
 	} else if (strcmp(interface, "ram") == 0) {
 		if (dfu_fill_entity_ram(dfu, devstr, s))
 			return -1;
+	} else if (strcmp(interface, "sf") == 0) {
+		if (dfu_fill_entity_sf(dfu, devstr, s))
+			return -1;
 	} else {
 		printf("%s: Device %s not (yet) supported!\n",
 		       __func__,  interface);
+/*
+ * Copyright (c) 2014, NVIDIA CORPORATION. All rights reserved.
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include <common.h>
+#include <malloc.h>
+#include <errno.h>
+#include <div64.h>
+#include <dfu.h>
+#include <spi_flash.h>
+
+static long dfu_get_medium_size_sf(struct dfu_entity *dfu)
+{
+	return dfu->data.sf.size;
+}
+
+static int dfu_read_medium_sf(struct dfu_entity *dfu, u64 offset, void *buf,
+		long *len)
+{
+	return spi_flash_read(dfu->data.sf.dev, offset, *len, buf);
+}
+
+static int dfu_write_medium_sf(struct dfu_entity *dfu,
+		u64 offset, void *buf, long *len)
+{
+	int ret;
+
+	ret = spi_flash_erase(dfu->data.sf.dev, offset, *len);
+	if (ret)
+		return ret;
+
+	ret = spi_flash_write(dfu->data.sf.dev, offset, *len, buf);
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+static int dfu_flush_medium_sf(struct dfu_entity *dfu)
+{
+	return 0;
+}
+
+static unsigned int dfu_polltimeout_sf(struct dfu_entity *dfu)
+{
+	return DFU_DEFAULT_POLL_TIMEOUT;
+}
+
+static void dfu_free_entity_sf(struct dfu_entity *dfu)
+{
+	spi_flash_free(dfu->data.sf.dev);
+}
+
+static struct spi_flash *parse_dev(char *devstr)
+{
+	unsigned int bus;
+	unsigned int cs;
+	unsigned int speed = CONFIG_SF_DEFAULT_SPEED;
+	unsigned int mode = CONFIG_SF_DEFAULT_MODE;
+	char *s, *endp;
+	struct spi_flash *dev;
+
+	s = strsep(&devstr, ":");
+	if (!s || !*s || (bus = simple_strtoul(s, &endp, 0), *endp)) {
+		printf("Invalid SPI bus %s\n", s);
+		return NULL;
+	}
+
+	s = strsep(&devstr, ":");
+	if (!s || !*s || (cs = simple_strtoul(s, &endp, 0), *endp)) {
+		printf("Invalid SPI chip-select %s\n", s);
+		return NULL;
+	}
+
+	s = strsep(&devstr, ":");
+	if (s && *s) {
+		speed = simple_strtoul(s, &endp, 0);
+		if (*endp || !speed) {
+			printf("Invalid SPI speed %s\n", s);
+			return NULL;
+		}
+	}
+
+	s = strsep(&devstr, ":");
+	if (s && *s) {
+		mode = simple_strtoul(s, &endp, 0);
+		if (*endp || mode > 3) {
+			printf("Invalid SPI mode %s\n", s);
+			return NULL;
+		}
+	}
+
+	dev = spi_flash_probe(bus, cs, speed, mode);
+	if (!dev) {
+		printf("Failed to create SPI flash at %d:%d:%d:%d\n",
+		       bus, cs, speed, mode);
+		return NULL;
+	}
+
+	return dev;
+}
+
+int dfu_fill_entity_sf(struct dfu_entity *dfu, char *devstr, char *s)
+{
+	char *st;
+
+	dfu->data.sf.dev = parse_dev(devstr);
+	if (!dfu->data.sf.dev)
+		return -ENODEV;
+
+	dfu->dev_type = DFU_DEV_SF;
+	dfu->max_buf_size = dfu->data.sf.dev->sector_size;
+
+	st = strsep(&s, " ");
+	if (!strcmp(st, "raw")) {
+		dfu->layout = DFU_RAW_ADDR;
+		dfu->data.sf.start = simple_strtoul(s, &s, 16);
+		s++;
+		dfu->data.sf.size = simple_strtoul(s, &s, 16);
+	} else {
+		printf("%s: Memory layout (%s) not supported!\n", __func__, st);
+		spi_flash_free(dfu->data.sf.dev);
+		return -1;
+	}
+
+	dfu->get_medium_size = dfu_get_medium_size_sf;
+	dfu->read_medium = dfu_read_medium_sf;
+	dfu->write_medium = dfu_write_medium_sf;
+	dfu->flush_medium = dfu_flush_medium_sf;
+	dfu->poll_timeout = dfu_polltimeout_sf;
+	dfu->free_entity = dfu_free_entity_sf;
+
+	/* initial state */
+	dfu->inited = 0;
+
+	return 0;
+}
@@ -14,6 +14,7 @@
 #include <common.h>
 #include <linux/list.h>
 #include <mmc.h>
+#include <spi_flash.h>
 #include <linux/usb/composite.h>
  
 enum dfu_device_type {
@@ -21,6 +22,7 @@
 	DFU_DEV_ONENAND,
 	DFU_DEV_NAND,
 	DFU_DEV_RAM,
+	DFU_DEV_SF,
 };
  
 enum dfu_layout {
@@ -70,6 +72,14 @@
 	unsigned int	size;
 };
  
+struct sf_internal_data {
+	struct spi_flash *dev;
+
+	/* RAW programming */
+	u64 start;
+	u64 size;
+};
+
 #define DFU_NAME_SIZE			32
 #define DFU_CMD_BUF_SIZE		128
 #ifndef CONFIG_SYS_DFU_DATA_BUF_SIZE
@@ -97,6 +107,7 @@
 		struct mmc_internal_data mmc;
 		struct nand_internal_data nand;
 		struct ram_internal_data ram;
+		struct sf_internal_data sf;
 	} data;
  
 	long (*get_medium_size)(struct dfu_entity *dfu);
@@ -178,6 +189,17 @@
 				      char *s)
 {
 	puts("RAM support not available!\n");
+	return -1;
+}
+#endif
+
+#ifdef CONFIG_DFU_SF
+extern int dfu_fill_entity_sf(struct dfu_entity *dfu, char *devstr, char *s);
+#else
+static inline int dfu_fill_entity_sf(struct dfu_entity *dfu, char *devstr,
+				     char *s)
+{
+	puts("SF support not available!\n");
 	return -1;
 }
 #endif
...	...	@@ -9,4 +9,5 @@
9	9	obj-$(CONFIG_DFU_MMC) += dfu_mmc.o
10	10	obj-$(CONFIG_DFU_NAND) += dfu_nand.o
11	11	obj-$(CONFIG_DFU_RAM) += dfu_ram.o
	12	+obj-$(CONFIG_DFU_SF) += dfu_sf.o
...	...	@@ -413,6 +413,9 @@
413	413	} else if (strcmp(interface, "ram") == 0) {
414	414	if (dfu_fill_entity_ram(dfu, devstr, s))
415	415	return -1;
	416	+ } else if (strcmp(interface, "sf") == 0) {
	417	+ if (dfu_fill_entity_sf(dfu, devstr, s))
	418	+ return -1;
416	419	} else {
417	420	printf("%s: Device %s not (yet) supported!\n",
418	421	__func__, interface);
	1	+/*
	2	+ * Copyright (c) 2014, NVIDIA CORPORATION. All rights reserved.
	3	+ *
	4	+ * SPDX-License-Identifier: GPL-2.0+
	5	+ */
	6	+
	7	+#include <common.h>
	8	+#include <malloc.h>
	9	+#include <errno.h>
	10	+#include <div64.h>
	11	+#include <dfu.h>
	12	+#include <spi_flash.h>
	13	+
	14	+static long dfu_get_medium_size_sf(struct dfu_entity *dfu)
	15	+{
	16	+ return dfu->data.sf.size;
	17	+}
	18	+
	19	+static int dfu_read_medium_sf(struct dfu_entity dfu, u64 offset, void buf,
	20	+ long *len)
	21	+{
	22	+ return spi_flash_read(dfu->data.sf.dev, offset, *len, buf);
	23	+}
	24	+
	25	+static int dfu_write_medium_sf(struct dfu_entity *dfu,
	26	+ u64 offset, void buf, long len)
	27	+{
	28	+ int ret;
	29	+
	30	+ ret = spi_flash_erase(dfu->data.sf.dev, offset, *len);
	31	+ if (ret)
	32	+ return ret;
	33	+
	34	+ ret = spi_flash_write(dfu->data.sf.dev, offset, *len, buf);
	35	+ if (ret)
	36	+ return ret;
	37	+
	38	+ return 0;
	39	+}
	40	+
	41	+static int dfu_flush_medium_sf(struct dfu_entity *dfu)
	42	+{
	43	+ return 0;
	44	+}
	45	+
	46	+static unsigned int dfu_polltimeout_sf(struct dfu_entity *dfu)
	47	+{
	48	+ return DFU_DEFAULT_POLL_TIMEOUT;
	49	+}
	50	+
	51	+static void dfu_free_entity_sf(struct dfu_entity *dfu)
	52	+{
	53	+ spi_flash_free(dfu->data.sf.dev);
	54	+}
	55	+
	56	+static struct spi_flash parse_dev(char devstr)
	57	+{
	58	+ unsigned int bus;
	59	+ unsigned int cs;
	60	+ unsigned int speed = CONFIG_SF_DEFAULT_SPEED;
	61	+ unsigned int mode = CONFIG_SF_DEFAULT_MODE;
	62	+ char s, endp;
	63	+ struct spi_flash *dev;
	64	+
	65	+ s = strsep(&devstr, ":");
	66	+ if (!s \|\| !s \|\| (bus = simple_strtoul(s, &endp, 0), endp)) {
	67	+ printf("Invalid SPI bus %s\n", s);
	68	+ return NULL;
	69	+ }
	70	+
	71	+ s = strsep(&devstr, ":");
	72	+ if (!s \|\| !s \|\| (cs = simple_strtoul(s, &endp, 0), endp)) {
	73	+ printf("Invalid SPI chip-select %s\n", s);
	74	+ return NULL;
	75	+ }
	76	+
	77	+ s = strsep(&devstr, ":");
	78	+ if (s && *s) {
	79	+ speed = simple_strtoul(s, &endp, 0);
	80	+ if (*endp \|\| !speed) {
	81	+ printf("Invalid SPI speed %s\n", s);
	82	+ return NULL;
	83	+ }
	84	+ }
	85	+
	86	+ s = strsep(&devstr, ":");
	87	+ if (s && *s) {
	88	+ mode = simple_strtoul(s, &endp, 0);
	89	+ if (*endp \|\| mode > 3) {
	90	+ printf("Invalid SPI mode %s\n", s);
	91	+ return NULL;
	92	+ }
	93	+ }
	94	+
	95	+ dev = spi_flash_probe(bus, cs, speed, mode);
	96	+ if (!dev) {
	97	+ printf("Failed to create SPI flash at %d:%d:%d:%d\n",
	98	+ bus, cs, speed, mode);
	99	+ return NULL;
	100	+ }
	101	+
	102	+ return dev;
	103	+}
	104	+
	105	+int dfu_fill_entity_sf(struct dfu_entity dfu, char devstr, char *s)
	106	+{
	107	+ char *st;
	108	+
	109	+ dfu->data.sf.dev = parse_dev(devstr);
	110	+ if (!dfu->data.sf.dev)
	111	+ return -ENODEV;
	112	+
	113	+ dfu->dev_type = DFU_DEV_SF;
	114	+ dfu->max_buf_size = dfu->data.sf.dev->sector_size;
	115	+
	116	+ st = strsep(&s, " ");
	117	+ if (!strcmp(st, "raw")) {
	118	+ dfu->layout = DFU_RAW_ADDR;
	119	+ dfu->data.sf.start = simple_strtoul(s, &s, 16);
	120	+ s++;
	121	+ dfu->data.sf.size = simple_strtoul(s, &s, 16);
	122	+ } else {
	123	+ printf("%s: Memory layout (%s) not supported!\n", __func__, st);
	124	+ spi_flash_free(dfu->data.sf.dev);
	125	+ return -1;
	126	+ }
	127	+
	128	+ dfu->get_medium_size = dfu_get_medium_size_sf;
	129	+ dfu->read_medium = dfu_read_medium_sf;
	130	+ dfu->write_medium = dfu_write_medium_sf;
	131	+ dfu->flush_medium = dfu_flush_medium_sf;
	132	+ dfu->poll_timeout = dfu_polltimeout_sf;
	133	+ dfu->free_entity = dfu_free_entity_sf;
	134	+
	135	+ /* initial state */
	136	+ dfu->inited = 0;
	137	+
	138	+ return 0;
	139	+}
...	...	@@ -14,6 +14,7 @@
14	14	#include <common.h>
15	15	#include <linux/list.h>
16	16	#include <mmc.h>
	17	+#include <spi_flash.h>
17	18	#include <linux/usb/composite.h>
18	19
19	20	enum dfu_device_type {
...	...	@@ -21,6 +22,7 @@
21	22	DFU_DEV_ONENAND,
22	23	DFU_DEV_NAND,
23	24	DFU_DEV_RAM,
	25	+ DFU_DEV_SF,
24	26	};
25	27
26	28	enum dfu_layout {
...	...	@@ -70,6 +72,14 @@
70	72	unsigned int size;
71	73	};
72	74
	75	+struct sf_internal_data {
	76	+ struct spi_flash *dev;
	77	+
	78	+ /* RAW programming */
	79	+ u64 start;
	80	+ u64 size;
	81	+};
	82	+
73	83	#define DFU_NAME_SIZE 32
74	84	#define DFU_CMD_BUF_SIZE 128
75	85	#ifndef CONFIG_SYS_DFU_DATA_BUF_SIZE
...	...	@@ -97,6 +107,7 @@
97	107	struct mmc_internal_data mmc;
98	108	struct nand_internal_data nand;
99	109	struct ram_internal_data ram;
	110	+ struct sf_internal_data sf;
100	111	} data;
101	112
102	113	long (get_medium_size)(struct dfu_entity dfu);
...	...	@@ -178,6 +189,17 @@
178	189	char *s)
179	190	{
180	191	puts("RAM support not available!\n");
	192	+ return -1;
	193	+}
	194	+#endif
	195	+
	196	+#ifdef CONFIG_DFU_SF
	197	+extern int dfu_fill_entity_sf(struct dfu_entity dfu, char devstr, char *s);
	198	+#else
	199	+static inline int dfu_fill_entity_sf(struct dfu_entity dfu, char devstr,
	200	+ char *s)
	201	+{
	202	+ puts("SF support not available!\n");
181	203	return -1;
182	204	}
183	205	#endif