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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
|
/*
* Copyright (c) 2019-2022 Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ETHOSU_DRIVER_H
#define ETHOSU_DRIVER_H
/******************************************************************************
* Includes
******************************************************************************/
#include "ethosu_types.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/******************************************************************************
* Defines
******************************************************************************/
#define ETHOSU_DRIVER_VERSION_MAJOR 0 ///< Driver major version
#define ETHOSU_DRIVER_VERSION_MINOR 16 ///< Driver minor version
#define ETHOSU_DRIVER_VERSION_PATCH 0 ///< Driver patch version
/******************************************************************************
* Types
******************************************************************************/
// Forward declare
struct ethosu_device;
enum ethosu_job_state
{
ETHOSU_JOB_IDLE = 0,
ETHOSU_JOB_RUNNING,
ETHOSU_JOB_DONE
};
struct ethosu_job
{
volatile enum ethosu_job_state state;
const void *custom_data_ptr;
int custom_data_size;
const uint64_t *base_addr;
const size_t *base_addr_size;
int num_base_addr;
void *user_arg;
};
struct ethosu_driver
{
struct ethosu_device *dev;
struct ethosu_driver *next;
struct ethosu_job job;
void *semaphore;
uint64_t fast_memory;
size_t fast_memory_size;
bool status_error;
bool dev_power_always_on;
bool reserved;
uint8_t clock_request;
uint8_t power_request;
};
struct ethosu_driver_version
{
uint8_t major;
uint8_t minor;
uint8_t patch;
};
enum ethosu_request_clients
{
ETHOSU_PMU_REQUEST = 0,
ETHOSU_INFERENCE_REQUEST = 1,
};
/******************************************************************************
* Prototypes (weak functions in driver)
******************************************************************************/
/**
* Interrupt handler to be called on IRQ from Ethos-U
*/
void ethosu_irq_handler(struct ethosu_driver *drv);
/*
* Flush/clean the data cache by address and size. Passing NULL as p argument
* expects the whole cache to be flushed.
*/
void ethosu_flush_dcache(uint32_t *p, size_t bytes);
/*
* Invalidate the data cache by address and size. Passing NULL as p argument
* expects the whole cache to be invalidated.
*/
void ethosu_invalidate_dcache(uint32_t *p, size_t bytes);
/*
* Minimal sempahore and mutex implementation for baremetal applications. See
* ethosu_driver.c.
*/
void *ethosu_mutex_create(void);
void ethosu_mutex_lock(void *mutex);
void ethosu_mutex_unlock(void *mutex);
void *ethosu_semaphore_create(void);
void ethosu_semaphore_take(void *sem);
void ethosu_semaphore_give(void *sem);
/*
* Callbacks for begin/end of inference. user_data pointer is passed to the
* ethosu_invoke() call and forwarded to the callback functions.
*/
void ethosu_inference_begin(struct ethosu_driver *drv, void *user_arg);
void ethosu_inference_end(struct ethosu_driver *drv, void *user_arg);
/******************************************************************************
* Prototypes
******************************************************************************/
/**
* Initialize the Ethos-U driver.
*/
int ethosu_init(struct ethosu_driver *drv,
const void *base_address,
const void *fast_memory,
const size_t fast_memory_size,
uint32_t secure_enable,
uint32_t privilege_enable);
/**
* Deinitialize the Ethos-U driver.
*/
void ethosu_deinit(struct ethosu_driver *drv);
/**
* Get Ethos-U driver version.
*/
void ethosu_get_driver_version(struct ethosu_driver_version *ver);
/**
* Get Ethos-U hardware information.
*/
void ethosu_get_hw_info(struct ethosu_driver *drv, struct ethosu_hw_info *hw);
/**
* Invoke Vela command stream.
*/
int ethosu_invoke_v3(struct ethosu_driver *drv,
const void *custom_data_ptr,
const int custom_data_size,
const uint64_t *base_addr,
const size_t *base_addr_size,
const int num_base_addr,
void *user_arg);
#define ethosu_invoke(drv, custom_data_ptr, custom_data_size, base_addr, base_addr_size, num_base_addr) \
ethosu_invoke_v3(drv, custom_data_ptr, custom_data_size, base_addr, base_addr_size, num_base_addr, 0)
/**
* Invoke Vela command stream using async interface.
* Must be followed by call(s) to ethosu_wait() upon successful return.
* Returns
* -1 on error
* 0 on success
*/
int ethosu_invoke_async(struct ethosu_driver *drv,
const void *custom_data_ptr,
const int custom_data_size,
const uint64_t *base_addr,
const size_t *base_addr_size,
const int num_base_addr,
void *user_arg);
/**
* Wait for inference to complete (block=true)
* Poll status or finish up if inference is complete (block=false)
* (This function is only intended to be used in conjuction with ethosu_invoke_async)
* Returns
* 1 on inference running (only for block=false)
* 0 on inference success
* -1 on inference error
* -2 on inference not invoked
*/
int ethosu_wait(struct ethosu_driver *drv, bool block);
/**
* Set Ethos-U power mode.
*/
void ethosu_set_power_mode(struct ethosu_driver *drv, bool always_on);
/**
* Reserves a driver to execute inference with
*/
struct ethosu_driver *ethosu_reserve_driver(void);
/**
* Change driver status to available
*/
void ethosu_release_driver(struct ethosu_driver *drv);
/**
* Set clock and power request bits
*/
enum ethosu_error_codes set_clock_and_power_request(struct ethosu_driver *drv,
enum ethosu_request_clients client,
enum ethosu_clock_q_request clock_request,
enum ethosu_power_q_request power_request);
/**
* Static inline for backwards-compatibility
*/
static inline int ethosu_invoke_v2(const void *custom_data_ptr,
const int custom_data_size,
const uint64_t *base_addr,
const size_t *base_addr_size,
const int num_base_addr)
{
struct ethosu_driver *drv = ethosu_reserve_driver();
int result = ethosu_invoke_v3(drv, custom_data_ptr, custom_data_size, base_addr, base_addr_size, num_base_addr, 0);
ethosu_release_driver(drv);
return result;
}
#ifdef __cplusplus
}
#endif
#endif // ETHOSU_DRIVER_H
|
