net/bnxt: check access denied for HWRM commands
[dpdk.git] / drivers / crypto / ccp / ccp_pci.c
1 /*   SPDX-License-Identifier: BSD-3-Clause
2  *   Copyright(c) 2018 Advanced Micro Devices, Inc. All rights reserved.
3  */
4
5 #include <dirent.h>
6 #include <fcntl.h>
7 #include <stdio.h>
8 #include <string.h>
9 #include <unistd.h>
10
11 #include <rte_string_fns.h>
12
13 #include "ccp_pci.h"
14
15 static const char * const uio_module_names[] = {
16         "igb_uio",
17         "uio_pci_generic",
18 };
19
20 int
21 ccp_check_pci_uio_module(void)
22 {
23         FILE *fp;
24         int i;
25         char buf[BUFSIZ];
26
27         fp = fopen(PROC_MODULES, "r");
28         if (fp == NULL)
29                 return -1;
30         i = 0;
31         while (uio_module_names[i] != NULL) {
32                 while (fgets(buf, sizeof(buf), fp) != NULL) {
33                         if (!strncmp(buf, uio_module_names[i],
34                                      strlen(uio_module_names[i])))
35                                 return i;
36                 }
37                 i++;
38                 rewind(fp);
39         }
40         printf("Insert igb_uio or uio_pci_generic kernel module(s)");
41         return -1;/* uio not inserted */
42 }
43
44 /*
45  * split up a pci address into its constituent parts.
46  */
47 int
48 ccp_parse_pci_addr_format(const char *buf, int bufsize, uint16_t *domain,
49                           uint8_t *bus, uint8_t *devid, uint8_t *function)
50 {
51         /* first split on ':' */
52         union splitaddr {
53                 struct {
54                         char *domain;
55                         char *bus;
56                         char *devid;
57                         char *function;
58                 };
59                 char *str[PCI_FMT_NVAL];
60                 /* last element-separator is "." not ":" */
61         } splitaddr;
62
63         char *buf_copy = strndup(buf, bufsize);
64
65         if (buf_copy == NULL)
66                 return -1;
67
68         if (rte_strsplit(buf_copy, bufsize, splitaddr.str, PCI_FMT_NVAL, ':')
69                         != PCI_FMT_NVAL - 1)
70                 goto error;
71         /* final split is on '.' between devid and function */
72         splitaddr.function = strchr(splitaddr.devid, '.');
73         if (splitaddr.function == NULL)
74                 goto error;
75         *splitaddr.function++ = '\0';
76
77         /* now convert to int values */
78         errno = 0;
79         *domain = (uint8_t)strtoul(splitaddr.domain, NULL, 16);
80         *bus = (uint8_t)strtoul(splitaddr.bus, NULL, 16);
81         *devid = (uint8_t)strtoul(splitaddr.devid, NULL, 16);
82         *function = (uint8_t)strtoul(splitaddr.function, NULL, 10);
83         if (errno != 0)
84                 goto error;
85
86         free(buf_copy); /* free the copy made with strdup */
87         return 0;
88 error:
89         free(buf_copy);
90         return -1;
91 }
92
93 int
94 ccp_pci_parse_sysfs_value(const char *filename, unsigned long *val)
95 {
96         FILE *f;
97         char buf[BUFSIZ];
98         char *end = NULL;
99
100         f = fopen(filename, "r");
101         if (f == NULL)
102                 return -1;
103         if (fgets(buf, sizeof(buf), f) == NULL) {
104                 fclose(f);
105                 return -1;
106         }
107         *val = strtoul(buf, &end, 0);
108         if ((buf[0] == '\0') || (end == NULL) || (*end != '\n')) {
109                 fclose(f);
110                 return -1;
111         }
112         fclose(f);
113         return 0;
114 }
115
116 /** IO resource type: */
117 #define IORESOURCE_IO         0x00000100
118 #define IORESOURCE_MEM        0x00000200
119
120 /* parse one line of the "resource" sysfs file (note that the 'line'
121  * string is modified)
122  */
123 static int
124 ccp_pci_parse_one_sysfs_resource(char *line, size_t len, uint64_t *phys_addr,
125                                  uint64_t *end_addr, uint64_t *flags)
126 {
127         union pci_resource_info {
128                 struct {
129                         char *phys_addr;
130                         char *end_addr;
131                         char *flags;
132                 };
133                 char *ptrs[PCI_RESOURCE_FMT_NVAL];
134         } res_info;
135
136         if (rte_strsplit(line, len, res_info.ptrs, 3, ' ') != 3)
137                 return -1;
138         errno = 0;
139         *phys_addr = strtoull(res_info.phys_addr, NULL, 16);
140         *end_addr = strtoull(res_info.end_addr, NULL, 16);
141         *flags = strtoull(res_info.flags, NULL, 16);
142         if (errno != 0)
143                 return -1;
144
145         return 0;
146 }
147
148 /* parse the "resource" sysfs file */
149 int
150 ccp_pci_parse_sysfs_resource(const char *filename, struct rte_pci_device *dev)
151 {
152         FILE *fp;
153         char buf[BUFSIZ];
154         int i;
155         uint64_t phys_addr, end_addr, flags;
156
157         fp = fopen(filename, "r");
158         if (fp == NULL)
159                 return -1;
160
161         for (i = 0; i < PCI_MAX_RESOURCE; i++) {
162                 if (fgets(buf, sizeof(buf), fp) == NULL)
163                         goto error;
164                 if (ccp_pci_parse_one_sysfs_resource(buf, sizeof(buf),
165                                 &phys_addr, &end_addr, &flags) < 0)
166                         goto error;
167
168                 if (flags & IORESOURCE_MEM) {
169                         dev->mem_resource[i].phys_addr = phys_addr;
170                         dev->mem_resource[i].len = end_addr - phys_addr + 1;
171                         /* not mapped for now */
172                         dev->mem_resource[i].addr = NULL;
173                 }
174         }
175         fclose(fp);
176         return 0;
177
178 error:
179         fclose(fp);
180         return -1;
181 }
182
183 int
184 ccp_find_uio_devname(const char *dirname)
185 {
186
187         DIR *dir;
188         struct dirent *e;
189         char dirname_uio[PATH_MAX];
190         unsigned int uio_num;
191         int ret = -1;
192
193         /* depending on kernel version, uio can be located in uio/uioX
194          * or uio:uioX
195          */
196         snprintf(dirname_uio, sizeof(dirname_uio), "%s/uio", dirname);
197         dir = opendir(dirname_uio);
198         if (dir == NULL) {
199         /* retry with the parent directory might be different kernel version*/
200                 dir = opendir(dirname);
201                 if (dir == NULL)
202                         return -1;
203         }
204
205         /* take the first file starting with "uio" */
206         while ((e = readdir(dir)) != NULL) {
207                 /* format could be uio%d ...*/
208                 int shortprefix_len = sizeof("uio") - 1;
209                 /* ... or uio:uio%d */
210                 int longprefix_len = sizeof("uio:uio") - 1;
211                 char *endptr;
212
213                 if (strncmp(e->d_name, "uio", 3) != 0)
214                         continue;
215
216                 /* first try uio%d */
217                 errno = 0;
218                 uio_num = strtoull(e->d_name + shortprefix_len, &endptr, 10);
219                 if (errno == 0 && endptr != (e->d_name + shortprefix_len)) {
220                         ret = uio_num;
221                         break;
222                 }
223
224                 /* then try uio:uio%d */
225                 errno = 0;
226                 uio_num = strtoull(e->d_name + longprefix_len, &endptr, 10);
227                 if (errno == 0 && endptr != (e->d_name + longprefix_len)) {
228                         ret = uio_num;
229                         break;
230                 }
231         }
232         closedir(dir);
233         return ret;
234
235
236 }