dfu: Drop unused prototype of dfu_trigger_reset()
[platform/kernel/u-boot.git] / include / dfu.h
1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3  * dfu.h - DFU flashable area description
4  *
5  * Copyright (C) 2012 Samsung Electronics
6  * authors: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
7  *          Lukasz Majewski <l.majewski@samsung.com>
8  */
9
10 #ifndef __DFU_ENTITY_H_
11 #define __DFU_ENTITY_H_
12
13 #include <common.h>
14 #include <linux/list.h>
15 #include <mmc.h>
16 #include <spi_flash.h>
17 #include <linux/usb/composite.h>
18
19 enum dfu_device_type {
20         DFU_DEV_MMC = 1,
21         DFU_DEV_ONENAND,
22         DFU_DEV_NAND,
23         DFU_DEV_RAM,
24         DFU_DEV_SF,
25         DFU_DEV_MTD,
26         DFU_DEV_VIRT,
27 };
28
29 enum dfu_layout {
30         DFU_RAW_ADDR = 1,
31         DFU_FS_FAT,
32         DFU_FS_EXT2,
33         DFU_FS_EXT3,
34         DFU_FS_EXT4,
35         DFU_RAM_ADDR,
36 };
37
38 enum dfu_op {
39         DFU_OP_READ = 1,
40         DFU_OP_WRITE,
41         DFU_OP_SIZE,
42 };
43
44 struct mmc_internal_data {
45         int dev_num;
46
47         /* RAW programming */
48         unsigned int lba_start;
49         unsigned int lba_size;
50         unsigned int lba_blk_size;
51
52         /* eMMC HW partition access */
53         int hw_partition;
54
55         /* FAT/EXT */
56         unsigned int dev;
57         unsigned int part;
58 };
59
60 struct mtd_internal_data {
61         struct mtd_info *info;
62
63         /* RAW programming */
64         u64 start;
65         u64 size;
66         /* for ubi partition */
67         unsigned int ubi;
68 };
69
70 struct nand_internal_data {
71         /* RAW programming */
72         u64 start;
73         u64 size;
74
75         unsigned int dev;
76         unsigned int part;
77         /* for nand/ubi use */
78         unsigned int ubi;
79 };
80
81 struct ram_internal_data {
82         void            *start;
83         unsigned int    size;
84 };
85
86 struct sf_internal_data {
87         struct spi_flash *dev;
88
89         /* RAW programming */
90         u64 start;
91         u64 size;
92         /* for sf/ubi use */
93         unsigned int ubi;
94 };
95
96 struct virt_internal_data {
97         int dev_num;
98 };
99
100 #define DFU_NAME_SIZE                   32
101 #ifndef CONFIG_SYS_DFU_DATA_BUF_SIZE
102 #define CONFIG_SYS_DFU_DATA_BUF_SIZE            (1024*1024*8)   /* 8 MiB */
103 #endif
104 #ifndef CONFIG_SYS_DFU_MAX_FILE_SIZE
105 #define CONFIG_SYS_DFU_MAX_FILE_SIZE CONFIG_SYS_DFU_DATA_BUF_SIZE
106 #endif
107 #ifndef DFU_DEFAULT_POLL_TIMEOUT
108 #define DFU_DEFAULT_POLL_TIMEOUT 0
109 #endif
110 #ifndef DFU_MANIFEST_POLL_TIMEOUT
111 #define DFU_MANIFEST_POLL_TIMEOUT       DFU_DEFAULT_POLL_TIMEOUT
112 #endif
113
114 struct dfu_entity {
115         char                    name[DFU_NAME_SIZE];
116         int                     alt;
117         void                    *dev_private;
118         enum dfu_device_type    dev_type;
119         enum dfu_layout         layout;
120         unsigned long           max_buf_size;
121
122         union {
123                 struct mmc_internal_data mmc;
124                 struct mtd_internal_data mtd;
125                 struct nand_internal_data nand;
126                 struct ram_internal_data ram;
127                 struct sf_internal_data sf;
128                 struct virt_internal_data virt;
129         } data;
130
131         int (*get_medium_size)(struct dfu_entity *dfu, u64 *size);
132
133         int (*read_medium)(struct dfu_entity *dfu,
134                         u64 offset, void *buf, long *len);
135
136         int (*write_medium)(struct dfu_entity *dfu,
137                         u64 offset, void *buf, long *len);
138
139         int (*flush_medium)(struct dfu_entity *dfu);
140         unsigned int (*poll_timeout)(struct dfu_entity *dfu);
141
142         void (*free_entity)(struct dfu_entity *dfu);
143
144         struct list_head list;
145
146         /* on the fly state */
147         u32 crc;
148         u64 offset;
149         int i_blk_seq_num;
150         u8 *i_buf;
151         u8 *i_buf_start;
152         u8 *i_buf_end;
153         u64 r_left;
154         long b_left;
155
156         u32 bad_skip;   /* for nand use */
157
158         unsigned int inited:1;
159 };
160
161 #ifdef CONFIG_SET_DFU_ALT_INFO
162 void set_dfu_alt_info(char *interface, char *devstr);
163 #endif
164 int dfu_alt_init(int num, struct dfu_entity **dfu);
165 int dfu_alt_add(struct dfu_entity *dfu, char *interface, char *devstr, char *s);
166 int dfu_config_entities(char *s, char *interface, char *devstr);
167 void dfu_free_entities(void);
168 void dfu_show_entities(void);
169 int dfu_get_alt_number(void);
170 const char *dfu_get_dev_type(enum dfu_device_type t);
171 const char *dfu_get_layout(enum dfu_layout l);
172 struct dfu_entity *dfu_get_entity(int alt);
173 char *dfu_extract_token(char** e, int *n);
174 int dfu_get_alt(char *name);
175 int dfu_init_env_entities(char *interface, char *devstr);
176 unsigned char *dfu_get_buf(struct dfu_entity *dfu);
177 unsigned char *dfu_free_buf(void);
178 unsigned long dfu_get_buf_size(void);
179 bool dfu_usb_get_reset(void);
180
181 int dfu_read(struct dfu_entity *de, void *buf, int size, int blk_seq_num);
182 int dfu_write(struct dfu_entity *de, void *buf, int size, int blk_seq_num);
183 int dfu_flush(struct dfu_entity *de, void *buf, int size, int blk_seq_num);
184
185 /**
186  * dfu_initiated_callback - weak callback called on DFU transaction start
187  *
188  * It is a callback function called by DFU stack when a DFU transaction is
189  * initiated. This function allows to manage some board specific behavior on
190  * DFU targets.
191  *
192  * @param dfu - pointer to the dfu_entity, which should be initialized
193  *
194  */
195 void dfu_initiated_callback(struct dfu_entity *dfu);
196 /**
197  * dfu_flush_callback - weak callback called at the end of the DFU write
198  *
199  * It is a callback function called by DFU stack after DFU manifestation.
200  * This function allows to manage some board specific behavior on DFU targets
201  *
202  * @param dfu - pointer to the dfu_entity, which should be flushed
203  *
204  */
205 void dfu_flush_callback(struct dfu_entity *dfu);
206
207 /*
208  * dfu_defer_flush - pointer to store dfu_entity for deferred flashing.
209  *                   It should be NULL when not used.
210  */
211 extern struct dfu_entity *dfu_defer_flush;
212 /**
213  * dfu_get_defer_flush - get current value of dfu_defer_flush pointer
214  *
215  * @return - value of the dfu_defer_flush pointer
216  */
217 static inline struct dfu_entity *dfu_get_defer_flush(void)
218 {
219         return dfu_defer_flush;
220 }
221
222 /**
223  * dfu_set_defer_flush - set the dfu_defer_flush pointer
224  *
225  * @param dfu - pointer to the dfu_entity, which should be written
226  */
227 static inline void dfu_set_defer_flush(struct dfu_entity *dfu)
228 {
229         dfu_defer_flush = dfu;
230 }
231
232 /**
233  * dfu_write_from_mem_addr - write data from memory to DFU managed medium
234  *
235  * This function adds support for writing data starting from fixed memory
236  * address (like $loadaddr) to dfu managed medium (e.g. NAND, MMC, file system)
237  *
238  * @param dfu - dfu entity to which we want to store data
239  * @param buf - fixed memory addres from where data starts
240  * @param size - number of bytes to write
241  *
242  * @return - 0 on success, other value on failure
243  */
244 int dfu_write_from_mem_addr(struct dfu_entity *dfu, void *buf, int size);
245
246 /* Device specific */
247 #if CONFIG_IS_ENABLED(DFU_MMC)
248 extern int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s);
249 #else
250 static inline int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr,
251                                       char *s)
252 {
253         puts("MMC support not available!\n");
254         return -1;
255 }
256 #endif
257
258 #if CONFIG_IS_ENABLED(DFU_NAND)
259 extern int dfu_fill_entity_nand(struct dfu_entity *dfu, char *devstr, char *s);
260 #else
261 static inline int dfu_fill_entity_nand(struct dfu_entity *dfu, char *devstr,
262                                        char *s)
263 {
264         puts("NAND support not available!\n");
265         return -1;
266 }
267 #endif
268
269 #if CONFIG_IS_ENABLED(DFU_RAM)
270 extern int dfu_fill_entity_ram(struct dfu_entity *dfu, char *devstr, char *s);
271 #else
272 static inline int dfu_fill_entity_ram(struct dfu_entity *dfu, char *devstr,
273                                       char *s)
274 {
275         puts("RAM support not available!\n");
276         return -1;
277 }
278 #endif
279
280 #if CONFIG_IS_ENABLED(DFU_SF)
281 extern int dfu_fill_entity_sf(struct dfu_entity *dfu, char *devstr, char *s);
282 #else
283 static inline int dfu_fill_entity_sf(struct dfu_entity *dfu, char *devstr,
284                                      char *s)
285 {
286         puts("SF support not available!\n");
287         return -1;
288 }
289 #endif
290
291 #if CONFIG_IS_ENABLED(DFU_MTD)
292 int dfu_fill_entity_mtd(struct dfu_entity *dfu, char *devstr, char *s);
293 #else
294 static inline int dfu_fill_entity_mtd(struct dfu_entity *dfu, char *devstr,
295                                       char *s)
296 {
297         puts("MTD support not available!\n");
298         return -1;
299 }
300 #endif
301
302 #ifdef CONFIG_DFU_VIRT
303 int dfu_fill_entity_virt(struct dfu_entity *dfu, char *devstr, char *s);
304 int dfu_write_medium_virt(struct dfu_entity *dfu, u64 offset,
305                           void *buf, long *len);
306 int dfu_get_medium_size_virt(struct dfu_entity *dfu, u64 *size);
307 int dfu_read_medium_virt(struct dfu_entity *dfu, u64 offset,
308                          void *buf, long *len);
309 #else
310 static inline int dfu_fill_entity_virt(struct dfu_entity *dfu, char *devstr,
311                                        char *s)
312 {
313         puts("VIRT support not available!\n");
314         return -1;
315 }
316 #endif
317
318 /**
319  * dfu_tftp_write - Write TFTP data to DFU medium
320  *
321  * This function is storing data received via TFTP on DFU supported medium.
322  *
323  * @param dfu_entity_name - name of DFU entity to write
324  * @param addr - address of data buffer to write
325  * @param len - number of bytes
326  * @param interface - destination DFU medium (e.g. "mmc")
327  * @param devstring - instance number of destination DFU medium (e.g. "1")
328  *
329  * @return 0 on success, otherwise error code
330  */
331 #if CONFIG_IS_ENABLED(DFU_TFTP)
332 int dfu_tftp_write(char *dfu_entity_name, unsigned int addr, unsigned int len,
333                    char *interface, char *devstring);
334 #else
335 static inline int dfu_tftp_write(char *dfu_entity_name, unsigned int addr,
336                                  unsigned int len, char *interface,
337                                  char *devstring)
338 {
339         puts("TFTP write support for DFU not available!\n");
340         return -ENOSYS;
341 }
342 #endif
343
344 int dfu_add(struct usb_configuration *c);
345 #endif /* __DFU_ENTITY_H_ */