Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2024 HiSilicon Limited
3 : : */
4 : :
5 : : #include <dirent.h>
6 : : #include <errno.h>
7 : : #include <fcntl.h>
8 : : #include <unistd.h>
9 : : #include <stdlib.h>
10 : : #include <string.h>
11 : : #include <sys/ioctl.h>
12 : : #include <sys/mman.h>
13 : : #include <sys/stat.h>
14 : : #include <sys/types.h>
15 : :
16 : : #include <eal_export.h>
17 : : #include <rte_bitops.h>
18 : : #include <rte_common.h>
19 : : #include <rte_devargs.h>
20 : : #include <rte_eal_paging.h>
21 : : #include <rte_errno.h>
22 : : #include <rte_log.h>
23 : : #include <rte_kvargs.h>
24 : : #include <bus_driver.h>
25 : :
26 : : #include "bus_uacce_driver.h"
27 : :
28 : : #define UACCE_BUS_CLASS_PATH "/sys/class/uacce"
29 : :
30 : : /* UACCE device flag of SVA. */
31 : : #define UACCE_DEV_FLGA_SVA RTE_BIT32(0)
32 : :
33 : : /* Support -a uacce:device-name when start DPDK application. */
34 : : #define UACCE_DEV_PREFIX "uacce:"
35 : :
36 : : /*
37 : : * Structure describing the UACCE bus.
38 : : */
39 : : struct rte_uacce_bus {
40 : : struct rte_bus bus; /* Inherit the generic class. */
41 : : TAILQ_HEAD(, rte_uacce_device) device_list; /* List of devices. */
42 : : TAILQ_HEAD(, rte_uacce_driver) driver_list; /* List of drivers. */
43 : : };
44 : :
45 : : /* Forward declaration of UACCE bus. */
46 : : static struct rte_uacce_bus uacce_bus;
47 : :
48 : : enum uacce_params {
49 : : RTE_UACCE_PARAM_NAME,
50 : : };
51 : :
52 : : static const char *const uacce_params_keys[] = {
53 : : [RTE_UACCE_PARAM_NAME] = "name",
54 : : NULL,
55 : : };
56 : :
57 : : #define FOREACH_DEVICE_ON_UACCEBUS(p) \
58 : : RTE_TAILQ_FOREACH(p, &uacce_bus.device_list, next)
59 : : #define FOREACH_DRIVER_ON_UACCEBUS(p) \
60 : : RTE_TAILQ_FOREACH(p, &uacce_bus.driver_list, next)
61 : :
62 : : extern int uacce_bus_logtype;
63 : : #define RTE_LOGTYPE_UACCE_BUS uacce_bus_logtype
64 : : #define UACCE_BUS_LOG(level, ...) \
65 : : RTE_LOG_LINE(level, UACCE_BUS, __VA_ARGS__)
66 : : #define UACCE_BUS_ERR(fmt, ...) UACCE_BUS_LOG(ERR, fmt, ##__VA_ARGS__)
67 : : #define UACCE_BUS_WARN(fmt, ...) UACCE_BUS_LOG(WARNING, fmt, ##__VA_ARGS__)
68 : : #define UACCE_BUS_INFO(fmt, ...) UACCE_BUS_LOG(INFO, fmt, ##__VA_ARGS__)
69 : : #define UACCE_BUS_DEBUG(fmt, ...) UACCE_BUS_LOG(DEBUG, fmt, ##__VA_ARGS__)
70 : :
71 : :
72 : : static struct rte_devargs *
73 : 0 : uacce_devargs_lookup(const char *dev_name)
74 : : {
75 : 0 : char name[RTE_UACCE_DEV_PATH_SIZE] = {0};
76 : : struct rte_devargs *devargs;
77 : :
78 : : snprintf(name, sizeof(name), "%s%s", UACCE_DEV_PREFIX, dev_name);
79 [ # # ]: 0 : RTE_EAL_DEVARGS_FOREACH("uacce", devargs) {
80 [ # # ]: 0 : if (strcmp(devargs->name, name) == 0)
81 : 0 : return devargs;
82 : : }
83 : :
84 : : return NULL;
85 : : }
86 : :
87 : : static bool
88 : 0 : uacce_ignore_device(const char *dev_name)
89 : : {
90 : 0 : struct rte_devargs *devargs = uacce_devargs_lookup(dev_name);
91 : :
92 [ # # # ]: 0 : switch (uacce_bus.bus.conf.scan_mode) {
93 : 0 : case RTE_BUS_SCAN_ALLOWLIST:
94 [ # # # # ]: 0 : if (devargs && devargs->policy == RTE_DEV_ALLOWED)
95 : 0 : return false;
96 : : break;
97 : 0 : case RTE_BUS_SCAN_UNDEFINED:
98 : : case RTE_BUS_SCAN_BLOCKLIST:
99 [ # # # # ]: 0 : if (devargs == NULL || devargs->policy != RTE_DEV_BLOCKED)
100 : 0 : return false;
101 : : break;
102 : : }
103 : :
104 : : return true;
105 : : }
106 : :
107 : : /*
108 : : * Returns the number of bytes read (removed last newline) on success.
109 : : * Otherwise negative value is returned.
110 : : */
111 : : static int
112 : 0 : uacce_read_attr(const char *dev_root, const char *attr, char *buf, uint32_t sz)
113 : : {
114 : 0 : char filename[PATH_MAX] = {0};
115 : : int ret;
116 : : int fd;
117 : :
118 : : snprintf(filename, sizeof(filename), "%s/%s", dev_root, attr);
119 : : fd = open(filename, O_RDONLY, 0);
120 [ # # ]: 0 : if (fd < 0) {
121 : 0 : UACCE_BUS_ERR("failed to open %s", filename);
122 : 0 : return -EIO;
123 : : }
124 : :
125 [ # # ]: 0 : ret = read(fd, buf, sz);
126 [ # # ]: 0 : if (ret > 0) {
127 : : /* Remove the last new line character. */
128 [ # # ]: 0 : if (buf[ret - 1] == '\n') {
129 : 0 : buf[ret - 1] = '\0';
130 : 0 : ret--;
131 : : }
132 : : }
133 [ # # ]: 0 : if (ret <= 0) {
134 : 0 : UACCE_BUS_ERR("failed to read %s", filename);
135 : : ret = -EIO;
136 : : }
137 : :
138 : 0 : close(fd);
139 : :
140 : 0 : return ret;
141 : : }
142 : :
143 : : /* 0 on success. Otherwise negative value is returned. */
144 : : static int
145 : 0 : uacce_read_attr_int(const char *dev_root, const char *attr, int *val)
146 : : {
147 : 0 : char buf[RTE_UACCE_ATTR_MAX_SIZE] = {0};
148 : 0 : char *s = NULL;
149 : : int ret;
150 : :
151 : 0 : ret = uacce_read_attr(dev_root, attr, buf, sizeof(buf) - 1);
152 [ # # ]: 0 : if (ret < 0)
153 : : return ret;
154 : :
155 : 0 : *val = strtol(buf, &s, 0);
156 [ # # ]: 0 : if (s[0] != '\0') {
157 : 0 : UACCE_BUS_ERR("read attr %s/%s expect an integer value", dev_root, attr);
158 : 0 : return -EINVAL;
159 : : }
160 : :
161 : : return 0;
162 : : }
163 : :
164 : : /* 0 on success. Otherwise negative value is returned. */
165 : : static int
166 : 0 : uacce_read_attr_u32(const char *dev_root, const char *attr, uint32_t *val)
167 : : {
168 : 0 : char buf[RTE_UACCE_ATTR_MAX_SIZE] = {0};
169 : 0 : char *s = NULL;
170 : : int ret;
171 : :
172 : 0 : ret = uacce_read_attr(dev_root, attr, buf, sizeof(buf) - 1);
173 [ # # ]: 0 : if (ret < 0)
174 : : return ret;
175 : :
176 : 0 : *val = strtoul(buf, &s, 0);
177 [ # # ]: 0 : if (s[0] != '\0') {
178 : 0 : UACCE_BUS_ERR("read attr %s/%s expect an uint32 value", dev_root, attr);
179 : 0 : return -EINVAL;
180 : : }
181 : :
182 : : return 0;
183 : : }
184 : :
185 : : static int
186 : : uacce_read_api(struct rte_uacce_device *dev)
187 : : {
188 : 0 : int ret = uacce_read_attr(dev->dev_root, "api", dev->api, sizeof(dev->api) - 1);
189 : : if (ret < 0)
190 : : return ret;
191 : : return 0;
192 : : }
193 : :
194 : : static int
195 : : uacce_read_algs(struct rte_uacce_device *dev)
196 : : {
197 : 0 : int ret = uacce_read_attr(dev->dev_root, "algorithms", dev->algs, sizeof(dev->algs) - 1);
198 : : if (ret < 0)
199 : : return ret;
200 : : return 0;
201 : : }
202 : :
203 : : static int
204 : : uacce_read_flags(struct rte_uacce_device *dev)
205 : : {
206 : 0 : return uacce_read_attr_u32(dev->dev_root, "flags", &dev->flags);
207 : : }
208 : :
209 : : static void
210 : 0 : uacce_read_numa_node(struct rte_uacce_device *dev)
211 : : {
212 : 0 : int ret = uacce_read_attr_int(dev->dev_root, "device/numa_node", &dev->numa_node);
213 [ # # ]: 0 : if (ret != 0) {
214 : 0 : UACCE_BUS_WARN("read attr numa_node failed! set to default");
215 : 0 : dev->numa_node = -1;
216 : : }
217 : 0 : }
218 : :
219 : : static int
220 : 0 : uacce_read_qfrt_sz(struct rte_uacce_device *dev)
221 : : {
222 : 0 : int ret = uacce_read_attr_u32(dev->dev_root, "region_mmio_size",
223 : : &dev->qfrt_sz[RTE_UACCE_QFRT_MMIO]);
224 [ # # ]: 0 : if (ret != 0)
225 : : return ret;
226 : 0 : return uacce_read_attr_u32(dev->dev_root, "region_dus_size",
227 : : &dev->qfrt_sz[RTE_UACCE_QFRT_DUS]);
228 : : }
229 : :
230 : : static int
231 : 0 : uacce_verify(struct rte_uacce_device *dev)
232 : : {
233 [ # # ]: 0 : if (!(dev->flags & UACCE_DEV_FLGA_SVA)) {
234 : 0 : UACCE_BUS_WARN("device %s don't support SVA, skip it!", dev->name);
235 : 0 : return 1; /* >0 will skip this device. */
236 : : }
237 : :
238 : : return 0;
239 : : }
240 : :
241 : : /*
242 : : * Scan one UACCE sysfs entry, and fill the devices list from it.
243 : : * It reads api/algs/flags/numa_node/region-size (please refer Linux kernel:
244 : : * Documentation/ABI/testing/sysfs-driver-uacce) and stores them for later
245 : : * device-driver matching, driver init...
246 : : */
247 : : static int
248 : 0 : uacce_scan_one(const char *dev_name)
249 : : {
250 : : struct rte_uacce_device *dev;
251 : : int ret;
252 : :
253 : 0 : dev = calloc(1, sizeof(*dev));
254 [ # # ]: 0 : if (!dev)
255 : : return -ENOMEM;
256 : :
257 : 0 : dev->device.bus = &uacce_bus.bus;
258 : 0 : dev->device.name = dev->name;
259 : 0 : dev->device.devargs = uacce_devargs_lookup(dev_name);
260 : : snprintf(dev->name, sizeof(dev->name), "%s", dev_name);
261 : 0 : snprintf(dev->dev_root, sizeof(dev->dev_root), "%s/%s",
262 : : UACCE_BUS_CLASS_PATH, dev_name);
263 : 0 : snprintf(dev->cdev_path, sizeof(dev->cdev_path), "/dev/%s", dev_name);
264 : :
265 : : ret = uacce_read_api(dev);
266 [ # # ]: 0 : if (ret != 0)
267 : 0 : goto err;
268 : : ret = uacce_read_algs(dev);
269 [ # # ]: 0 : if (ret != 0)
270 : 0 : goto err;
271 : : ret = uacce_read_flags(dev);
272 [ # # ]: 0 : if (ret != 0)
273 : 0 : goto err;
274 : 0 : uacce_read_numa_node(dev);
275 : 0 : ret = uacce_read_qfrt_sz(dev);
276 [ # # ]: 0 : if (ret != 0)
277 : 0 : goto err;
278 : :
279 : 0 : ret = uacce_verify(dev);
280 [ # # ]: 0 : if (ret != 0)
281 : 0 : goto err;
282 : :
283 : 0 : TAILQ_INSERT_TAIL(&uacce_bus.device_list, dev, next);
284 : 0 : return 0;
285 : :
286 : 0 : err:
287 : 0 : free(dev);
288 : 0 : return ret;
289 : : }
290 : :
291 : : static int
292 : 185 : uacce_scan(void)
293 : : {
294 : : struct dirent *e;
295 : : DIR *dir;
296 : :
297 : 185 : dir = opendir(UACCE_BUS_CLASS_PATH);
298 [ + - ]: 185 : if (dir == NULL) {
299 : 185 : UACCE_BUS_LOG(INFO, "open %s failed!", UACCE_BUS_CLASS_PATH);
300 : 185 : return 0;
301 : : }
302 : :
303 [ # # ]: 0 : while ((e = readdir(dir)) != NULL) {
304 [ # # ]: 0 : if (e->d_name[0] == '.')
305 : 0 : continue;
306 : :
307 [ # # ]: 0 : if (strlen(e->d_name) >= RTE_DEV_NAME_MAX_LEN) {
308 : 0 : UACCE_BUS_LOG(WARNING, "uacce device name %s too long, skip it!",
309 : : e->d_name);
310 : 0 : continue;
311 : : }
312 : :
313 [ # # ]: 0 : if (uacce_ignore_device(e->d_name))
314 : 0 : continue;
315 : :
316 [ # # ]: 0 : if (uacce_scan_one(e->d_name) < 0)
317 : 0 : goto error;
318 : : }
319 : 0 : closedir(dir);
320 : 0 : return 0;
321 : :
322 : : error:
323 : 0 : closedir(dir);
324 : 0 : return -1;
325 : : }
326 : :
327 : : static bool
328 : 0 : uacce_match(const struct rte_uacce_driver *dr, const struct rte_uacce_device *dev)
329 : : {
330 : : const struct rte_uacce_id *id_table;
331 : : uint32_t len;
332 : : char *map;
333 : :
334 [ # # ]: 0 : for (id_table = dr->id_table; id_table->dev_api != NULL; id_table++) {
335 [ # # ]: 0 : if (strcmp(id_table->dev_api, dev->api) != 0)
336 : 0 : continue;
337 : :
338 [ # # ]: 0 : if (id_table->dev_alg == NULL)
339 : : return true;
340 : :
341 : : /* The dev->algs's algrothims is separated by new line, for
342 : : * example: dev->algs could be: aaa\nbbbb\ncc, which has three
343 : : * algorithms: aaa, bbbb and cc.
344 : : * The id_table->dev_alg should be a single algrithm, e.g. bbbb.
345 : : */
346 : 0 : map = strstr(dev->algs, id_table->dev_alg);
347 [ # # ]: 0 : if (map == NULL)
348 : 0 : continue;
349 [ # # # # ]: 0 : if (map != dev->algs && map[-1] != '\n')
350 : 0 : continue;
351 : 0 : len = strlen(id_table->dev_alg);
352 [ # # ]: 0 : if (map[len] != '\0' && map[len] != '\n')
353 : 0 : continue;
354 : :
355 : : return true;
356 : : }
357 : :
358 : : return false;
359 : : }
360 : :
361 : : static int
362 : 0 : uacce_probe_one_driver(struct rte_uacce_driver *dr, struct rte_uacce_device *dev)
363 : : {
364 : 0 : const char *dev_name = dev->name;
365 : : bool already_probed;
366 : : int ret;
367 : :
368 [ # # ]: 0 : if (!uacce_match(dr, dev))
369 : : /* Match of device and driver failed */
370 : : return 1;
371 : :
372 : 0 : already_probed = rte_dev_is_probed(&dev->device);
373 [ # # ]: 0 : if (already_probed) {
374 : 0 : UACCE_BUS_INFO("device %s is already probed", dev_name);
375 : 0 : return -EEXIST;
376 : : }
377 : :
378 : 0 : UACCE_BUS_DEBUG("probe device %s using driver %s", dev_name, dr->driver.name);
379 : :
380 : 0 : ret = dr->probe(dr, dev);
381 [ # # ]: 0 : if (ret != 0) {
382 : 0 : UACCE_BUS_ERR("probe device %s with driver %s failed %d",
383 : : dev_name, dr->driver.name, ret);
384 : : } else {
385 : 0 : dev->device.driver = &dr->driver;
386 : 0 : dev->driver = dr;
387 : 0 : UACCE_BUS_DEBUG("probe device %s with driver %s success",
388 : : dev_name, dr->driver.name);
389 : : }
390 : :
391 : : return ret;
392 : : }
393 : :
394 : : static int
395 : 0 : uacce_probe_all_drivers(struct rte_uacce_device *dev)
396 : : {
397 : : struct rte_uacce_driver *dr;
398 : : int rc;
399 : :
400 [ # # ]: 0 : FOREACH_DRIVER_ON_UACCEBUS(dr) {
401 : 0 : rc = uacce_probe_one_driver(dr, dev);
402 [ # # ]: 0 : if (rc < 0)
403 : : /* negative value is an error */
404 : 0 : return rc;
405 [ # # ]: 0 : if (rc > 0)
406 : : /* positive value means driver doesn't support it */
407 : : continue;
408 : : return 0;
409 : : }
410 : :
411 : : return 1;
412 : : }
413 : :
414 : : static int
415 : 180 : uacce_probe(void)
416 : : {
417 : : size_t probed = 0, failed = 0;
418 : : struct rte_uacce_device *dev;
419 : : int ret;
420 : :
421 [ - + ]: 180 : FOREACH_DEVICE_ON_UACCEBUS(dev) {
422 : 0 : probed++;
423 : :
424 : 0 : ret = uacce_probe_all_drivers(dev);
425 [ # # ]: 0 : if (ret < 0) {
426 : 0 : UACCE_BUS_LOG(ERR, "Requested device %s cannot be used",
427 : : dev->name);
428 : 0 : rte_errno = errno;
429 : 0 : failed++;
430 : : }
431 : : }
432 : :
433 [ + - ]: 180 : return (probed && probed == failed) ? -1 : 0;
434 : : }
435 : :
436 : : static int
437 : 252 : uacce_cleanup(void)
438 : : {
439 : : struct rte_uacce_device *dev, *tmp_dev;
440 : : int error = 0;
441 : :
442 [ - + ]: 252 : RTE_TAILQ_FOREACH_SAFE(dev, &uacce_bus.device_list, next, tmp_dev) {
443 : 0 : struct rte_uacce_driver *dr = dev->driver;
444 : : int ret = 0;
445 : :
446 [ # # # # ]: 0 : if (dr == NULL || dr->remove == NULL)
447 : 0 : goto free;
448 : :
449 : 0 : ret = dr->remove(dev);
450 [ # # ]: 0 : if (ret < 0) {
451 : 0 : rte_errno = errno;
452 : : error = -1;
453 : : }
454 : : dev->driver = NULL;
455 : : dev->device.driver = NULL;
456 : :
457 : 0 : free:
458 : : memset(dev, 0, sizeof(*dev));
459 : 0 : free(dev);
460 : : }
461 : :
462 : 252 : return error;
463 : : }
464 : :
465 : : static int
466 : 0 : uacce_plug(struct rte_device *dev)
467 : : {
468 : 0 : return uacce_probe_all_drivers(RTE_DEV_TO_UACCE_DEV(dev));
469 : : }
470 : :
471 : : static int
472 : 0 : uacce_detach_dev(struct rte_uacce_device *dev)
473 : : {
474 : : struct rte_uacce_driver *dr;
475 : : int ret = 0;
476 : :
477 : 0 : dr = dev->driver;
478 : :
479 : 0 : UACCE_BUS_DEBUG("detach device %s using driver: %s", dev->device.name, dr->driver.name);
480 : :
481 [ # # ]: 0 : if (dr->remove) {
482 : 0 : ret = dr->remove(dev);
483 [ # # ]: 0 : if (ret < 0)
484 : : return ret;
485 : : }
486 : :
487 : 0 : dev->driver = NULL;
488 : 0 : dev->device.driver = NULL;
489 : :
490 : 0 : return 0;
491 : : }
492 : :
493 : : static int
494 : 0 : uacce_unplug(struct rte_device *dev)
495 : : {
496 : : struct rte_uacce_device *uacce_dev;
497 : : int ret;
498 : :
499 : 0 : uacce_dev = RTE_DEV_TO_UACCE_DEV(dev);
500 : 0 : ret = uacce_detach_dev(uacce_dev);
501 [ # # ]: 0 : if (ret == 0) {
502 [ # # ]: 0 : TAILQ_REMOVE(&uacce_bus.device_list, uacce_dev, next);
503 : 0 : rte_devargs_remove(dev->devargs);
504 : 0 : free(uacce_dev);
505 : : }
506 : :
507 : 0 : return ret;
508 : : }
509 : :
510 : : static struct rte_device *
511 : 0 : uacce_find_device(const struct rte_device *start, rte_dev_cmp_t cmp, const void *data)
512 : : {
513 : : const struct rte_uacce_device *uacce_start;
514 : : struct rte_uacce_device *uacce_dev;
515 : :
516 [ # # ]: 0 : if (start != NULL) {
517 : 0 : uacce_start = RTE_DEV_TO_UACCE_DEV_CONST(start);
518 : 0 : uacce_dev = TAILQ_NEXT(uacce_start, next);
519 : : } else {
520 : 0 : uacce_dev = TAILQ_FIRST(&uacce_bus.device_list);
521 : : }
522 : :
523 [ # # ]: 0 : while (uacce_dev != NULL) {
524 [ # # ]: 0 : if (cmp(&uacce_dev->device, data) == 0)
525 : 0 : return &uacce_dev->device;
526 : 0 : uacce_dev = TAILQ_NEXT(uacce_dev, next);
527 : : }
528 : :
529 : : return NULL;
530 : : }
531 : :
532 : : static int
533 : 28 : uacce_parse(const char *name, void *addr)
534 : : {
535 : : const char **out = addr;
536 : : int ret;
537 : :
538 : 28 : ret = strncmp(name, UACCE_DEV_PREFIX, strlen(UACCE_DEV_PREFIX));
539 : :
540 [ - + ]: 28 : if (ret == 0 && addr)
541 : 0 : *out = name;
542 : :
543 : 28 : return ret;
544 : : }
545 : :
546 : : static int
547 : 0 : uacce_dev_match(const struct rte_device *dev, const void *_kvlist)
548 : : {
549 : : const char *key = uacce_params_keys[RTE_UACCE_PARAM_NAME];
550 : : const struct rte_kvargs *kvlist = _kvlist;
551 : : const char *name;
552 : :
553 : : /* no kvlist arg, all devices match. */
554 [ # # ]: 0 : if (kvlist == NULL)
555 : : return 0;
556 : :
557 : : /* if key is present in kvlist and does not match, filter device. */
558 : 0 : name = rte_kvargs_get(kvlist, key);
559 [ # # # # ]: 0 : if (name != NULL && strcmp(name, dev->name))
560 : 0 : return -1;
561 : :
562 : : return 0;
563 : : }
564 : :
565 : : static void *
566 : 0 : uacce_dev_iterate(const void *start, const char *str,
567 : : const struct rte_dev_iterator *it __rte_unused)
568 : : {
569 : : rte_bus_find_device_t find_device;
570 : : struct rte_kvargs *kvargs = NULL;
571 : : struct rte_device *dev;
572 : :
573 [ # # ]: 0 : if (str != NULL) {
574 : 0 : kvargs = rte_kvargs_parse(str, uacce_params_keys);
575 [ # # ]: 0 : if (kvargs == NULL) {
576 : 0 : UACCE_BUS_ERR("cannot parse argument list %s", str);
577 : 0 : return NULL;
578 : : }
579 : : }
580 : 0 : find_device = uacce_bus.bus.find_device;
581 : 0 : dev = find_device(start, uacce_dev_match, kvargs);
582 : 0 : rte_kvargs_free(kvargs);
583 : 0 : return dev;
584 : : }
585 : :
586 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_uacce_avail_queues)
587 : : int
588 : 0 : rte_uacce_avail_queues(struct rte_uacce_device *dev)
589 : : {
590 : 0 : int avails = 0;
591 : : int ret;
592 : :
593 : 0 : ret = uacce_read_attr_int(dev->dev_root, "available_instances", &avails);
594 [ # # ]: 0 : if (ret == 0)
595 : 0 : ret = avails;
596 : :
597 : 0 : return ret;
598 : : }
599 : :
600 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_uacce_queue_alloc)
601 : : int
602 : 0 : rte_uacce_queue_alloc(struct rte_uacce_device *dev, struct rte_uacce_qcontex *qctx)
603 : : {
604 : : memset(qctx, 0, sizeof(*qctx));
605 : :
606 : 0 : qctx->fd = open(dev->cdev_path, O_RDWR | O_CLOEXEC);
607 [ # # ]: 0 : if (qctx->fd >= 0) {
608 : 0 : qctx->dev = dev;
609 : 0 : return 0;
610 : : }
611 : :
612 : : return -EIO;
613 : : }
614 : :
615 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_uacce_queue_free)
616 : : void
617 : 0 : rte_uacce_queue_free(struct rte_uacce_qcontex *qctx)
618 : : {
619 [ # # ]: 0 : if (qctx->fd >= 0)
620 : 0 : close(qctx->fd);
621 : : memset(qctx, 0, sizeof(*qctx));
622 : 0 : qctx->fd = -1;
623 : 0 : }
624 : :
625 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_uacce_queue_start)
626 : : int
627 : 0 : rte_uacce_queue_start(struct rte_uacce_qcontex *qctx)
628 : : {
629 : : #define UACCE_CMD_START_Q _IO('W', 0)
630 : 0 : return ioctl(qctx->fd, UACCE_CMD_START_Q);
631 : : }
632 : :
633 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_uacce_queue_ioctl)
634 : : int
635 : 0 : rte_uacce_queue_ioctl(struct rte_uacce_qcontex *qctx, unsigned long cmd, void *arg)
636 : : {
637 [ # # ]: 0 : if (arg == NULL)
638 : 0 : return ioctl(qctx->fd, cmd);
639 : :
640 : 0 : return ioctl(qctx->fd, cmd, arg);
641 : : }
642 : :
643 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_uacce_queue_mmap)
644 : : void *
645 : 0 : rte_uacce_queue_mmap(struct rte_uacce_qcontex *qctx, enum rte_uacce_qfrt qfrt)
646 : : {
647 : 0 : size_t size = qctx->dev->qfrt_sz[qfrt];
648 : 0 : off_t off = qfrt * getpagesize();
649 : : void *addr;
650 : :
651 [ # # # # ]: 0 : if (size == 0 || qctx->qfrt_base[qfrt] != NULL) {
652 : 0 : UACCE_BUS_ERR("failed to mmap for %s, size is zero or already mmapped!",
653 : : qctx->dev->name);
654 : 0 : return NULL;
655 : : }
656 : :
657 : 0 : addr = rte_mem_map(NULL, size, RTE_PROT_READ | RTE_PROT_WRITE, RTE_MAP_SHARED,
658 : : qctx->fd, off);
659 [ # # ]: 0 : if (addr == NULL) {
660 : 0 : UACCE_BUS_ERR("failed to mmap for %s, qfrt %d err %s!",
661 : : qctx->dev->name, qfrt, rte_strerror(rte_errno));
662 : 0 : return NULL;
663 : : }
664 : 0 : qctx->qfrt_base[qfrt] = addr;
665 : :
666 : 0 : return addr;
667 : : }
668 : :
669 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_uacce_queue_unmap)
670 : : void
671 : 0 : rte_uacce_queue_unmap(struct rte_uacce_qcontex *qctx, enum rte_uacce_qfrt qfrt)
672 : : {
673 [ # # ]: 0 : if (qctx->qfrt_base[qfrt] != NULL) {
674 : 0 : rte_mem_unmap(qctx->qfrt_base[qfrt], qctx->dev->qfrt_sz[qfrt]);
675 : 0 : qctx->qfrt_base[qfrt] = NULL;
676 : : }
677 : 0 : }
678 : :
679 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_uacce_register)
680 : : void
681 : 0 : rte_uacce_register(struct rte_uacce_driver *driver)
682 : : {
683 : 0 : TAILQ_INSERT_TAIL(&uacce_bus.driver_list, driver, next);
684 : 0 : driver->bus = &uacce_bus;
685 : 0 : }
686 : :
687 : : RTE_EXPORT_INTERNAL_SYMBOL(rte_uacce_unregister)
688 : : void
689 : 0 : rte_uacce_unregister(struct rte_uacce_driver *driver)
690 : : {
691 [ # # ]: 0 : TAILQ_REMOVE(&uacce_bus.driver_list, driver, next);
692 : 0 : driver->bus = NULL;
693 : 0 : }
694 : :
695 : : static struct rte_uacce_bus uacce_bus = {
696 : : .bus = {
697 : : .scan = uacce_scan,
698 : : .probe = uacce_probe,
699 : : .cleanup = uacce_cleanup,
700 : : .plug = uacce_plug,
701 : : .unplug = uacce_unplug,
702 : : .find_device = uacce_find_device,
703 : : .parse = uacce_parse,
704 : : .dev_iterate = uacce_dev_iterate,
705 : : },
706 : : .device_list = TAILQ_HEAD_INITIALIZER(uacce_bus.device_list),
707 : : .driver_list = TAILQ_HEAD_INITIALIZER(uacce_bus.driver_list),
708 : : };
709 : :
710 : 252 : RTE_REGISTER_BUS(uacce, uacce_bus.bus);
711 [ - + ]: 252 : RTE_LOG_REGISTER_DEFAULT(uacce_bus_logtype, NOTICE);
|
