1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2014, NVIDIA CORPORATION. All rights reserved.
*/
#include <common.h>
#include <malloc.h>
#include <errno.h>
#include <div64.h>
#include <dfu.h>
#include <spi.h>
#include <spi_flash.h>
static int dfu_get_medium_size_sf(struct dfu_entity *dfu, u64 *size)
{
*size = dfu->data.sf.size;
return 0;
}
static int dfu_read_medium_sf(struct dfu_entity *dfu, u64 offset, void *buf,
long *len)
{
return spi_flash_read(dfu->data.sf.dev, dfu->data.sf.start + offset,
*len, buf);
}
static u64 find_sector(struct dfu_entity *dfu, u64 start, u64 offset)
{
return (lldiv((start + offset), dfu->data.sf.dev->sector_size)) *
dfu->data.sf.dev->sector_size;
}
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,
find_sector(dfu, dfu->data.sf.start, offset),
dfu->data.sf.dev->sector_size);
if (ret)
return ret;
ret = spi_flash_write(dfu->data.sf.dev, dfu->data.sf.start + 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;
char *devstr_bkup = strdup(devstr);
dfu->data.sf.dev = parse_dev(devstr_bkup);
free(devstr_bkup);
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;
}
|
