1/*-
2 *   BSD LICENSE
3 *
4 *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
5 *   All rights reserved.
6 *
7 *   Redistribution and use in source and binary forms, with or without
8 *   modification, are permitted provided that the following conditions
9 *   are met:
10 *
11 *     * Redistributions of source code must retain the above copyright
12 *       notice, this list of conditions and the following disclaimer.
13 *     * Redistributions in binary form must reproduce the above copyright
14 *       notice, this list of conditions and the following disclaimer in
15 *       the documentation and/or other materials provided with the
16 *       distribution.
17 *     * Neither the name of Intel Corporation nor the names of its
18 *       contributors may be used to endorse or promote products derived
19 *       from this software without specific prior written permission.
20 *
21 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34#include <fcntl.h>
35#include <string.h>
36#include <unistd.h>
37#include <sys/types.h>
38#include <sys/stat.h>
39#include <sys/mman.h>
40
41#include <rte_eal.h>
42#include <rte_tailq.h>
43#include <rte_log.h>
44#include <rte_malloc.h>
45
46#include "eal_private.h"
47
48static struct rte_tailq_elem rte_uio_tailq = {
49	.name = "UIO_RESOURCE_LIST",
50};
51EAL_REGISTER_TAILQ(rte_uio_tailq)
52
53static int
54pci_uio_map_secondary(struct rte_pci_device *dev)
55{
56	int fd, i, j;
57	struct mapped_pci_resource *uio_res;
58	struct mapped_pci_res_list *uio_res_list =
59			RTE_TAILQ_CAST(rte_uio_tailq.head, mapped_pci_res_list);
60
61	TAILQ_FOREACH(uio_res, uio_res_list, next) {
62
63		/* skip this element if it doesn't match our PCI address */
64		if (rte_eal_compare_pci_addr(&uio_res->pci_addr, &dev->addr))
65			continue;
66
67		for (i = 0; i != uio_res->nb_maps; i++) {
68			/*
69			 * open devname, to mmap it
70			 */
71			fd = open(uio_res->maps[i].path, O_RDWR);
72			if (fd < 0) {
73				RTE_LOG(ERR, EAL, "Cannot open %s: %s\n",
74					uio_res->maps[i].path, strerror(errno));
75				return -1;
76			}
77
78			void *mapaddr = pci_map_resource(uio_res->maps[i].addr,
79					fd, (off_t)uio_res->maps[i].offset,
80					(size_t)uio_res->maps[i].size, 0);
81			/* fd is not needed in slave process, close it */
82			close(fd);
83			if (mapaddr != uio_res->maps[i].addr) {
84				RTE_LOG(ERR, EAL,
85					"Cannot mmap device resource file %s to address: %p\n",
86					uio_res->maps[i].path,
87					uio_res->maps[i].addr);
88				if (mapaddr != MAP_FAILED) {
89					/* unmap addrs correctly mapped */
90					for (j = 0; j < i; j++)
91						pci_unmap_resource(
92							uio_res->maps[j].addr,
93							(size_t)uio_res->maps[j].size);
94					/* unmap addr wrongly mapped */
95					pci_unmap_resource(mapaddr,
96						(size_t)uio_res->maps[i].size);
97				}
98				return -1;
99			}
100		}
101		return 0;
102	}
103
104	RTE_LOG(ERR, EAL, "Cannot find resource for device\n");
105	return 1;
106}
107
108/* map the PCI resource of a PCI device in virtual memory */
109int
110pci_uio_map_resource(struct rte_pci_device *dev)
111{
112	int i, map_idx = 0, ret;
113	uint64_t phaddr;
114	struct mapped_pci_resource *uio_res = NULL;
115	struct mapped_pci_res_list *uio_res_list =
116		RTE_TAILQ_CAST(rte_uio_tailq.head, mapped_pci_res_list);
117
118	dev->intr_handle.fd = -1;
119	dev->intr_handle.uio_cfg_fd = -1;
120
121	/* secondary processes - use already recorded details */
122	if (rte_eal_process_type() != RTE_PROC_PRIMARY)
123		return pci_uio_map_secondary(dev);
124
125	/* allocate uio resource */
126	ret = pci_uio_alloc_resource(dev, &uio_res);
127	if (ret)
128		return ret;
129
130	/* Map all BARs */
131	for (i = 0; i != PCI_MAX_RESOURCE; i++) {
132		/* skip empty BAR */
133		phaddr = dev->mem_resource[i].phys_addr;
134		if (phaddr == 0)
135			continue;
136
137		ret = pci_uio_map_resource_by_index(dev, i,
138				uio_res, map_idx);
139		if (ret)
140			goto error;
141
142		map_idx++;
143	}
144
145	uio_res->nb_maps = map_idx;
146
147	TAILQ_INSERT_TAIL(uio_res_list, uio_res, next);
148
149	return 0;
150error:
151	for (i = 0; i < map_idx; i++) {
152		pci_unmap_resource(uio_res->maps[i].addr,
153				(size_t)uio_res->maps[i].size);
154		rte_free(uio_res->maps[i].path);
155	}
156	pci_uio_free_resource(dev, uio_res);
157	return -1;
158}
159
160static void
161pci_uio_unmap(struct mapped_pci_resource *uio_res)
162{
163	int i;
164
165	if (uio_res == NULL)
166		return;
167
168	for (i = 0; i != uio_res->nb_maps; i++) {
169		pci_unmap_resource(uio_res->maps[i].addr,
170				(size_t)uio_res->maps[i].size);
171		if (rte_eal_process_type() == RTE_PROC_PRIMARY)
172			rte_free(uio_res->maps[i].path);
173	}
174}
175
176static struct mapped_pci_resource *
177pci_uio_find_resource(struct rte_pci_device *dev)
178{
179	struct mapped_pci_resource *uio_res;
180	struct mapped_pci_res_list *uio_res_list =
181			RTE_TAILQ_CAST(rte_uio_tailq.head, mapped_pci_res_list);
182
183	if (dev == NULL)
184		return NULL;
185
186	TAILQ_FOREACH(uio_res, uio_res_list, next) {
187
188		/* skip this element if it doesn't match our PCI address */
189		if (!rte_eal_compare_pci_addr(&uio_res->pci_addr, &dev->addr))
190			return uio_res;
191	}
192	return NULL;
193}
194
195/* unmap the PCI resource of a PCI device in virtual memory */
196void
197pci_uio_unmap_resource(struct rte_pci_device *dev)
198{
199	struct mapped_pci_resource *uio_res;
200	struct mapped_pci_res_list *uio_res_list =
201			RTE_TAILQ_CAST(rte_uio_tailq.head, mapped_pci_res_list);
202
203	if (dev == NULL)
204		return;
205
206	/* find an entry for the device */
207	uio_res = pci_uio_find_resource(dev);
208	if (uio_res == NULL)
209		return;
210
211	/* secondary processes - just free maps */
212	if (rte_eal_process_type() != RTE_PROC_PRIMARY)
213		return pci_uio_unmap(uio_res);
214
215	TAILQ_REMOVE(uio_res_list, uio_res, next);
216
217	/* unmap all resources */
218	pci_uio_unmap(uio_res);
219
220	/* free uio resource */
221	rte_free(uio_res);
222
223	/* close fd if in primary process */
224	close(dev->intr_handle.fd);
225	if (dev->intr_handle.uio_cfg_fd >= 0) {
226		close(dev->intr_handle.uio_cfg_fd);
227		dev->intr_handle.uio_cfg_fd = -1;
228	}
229
230	dev->intr_handle.fd = -1;
231	dev->intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
232}
233