9953b2eac28a5edc1bd89e072968c57e19eb8b52
[dpdk.git] / drivers / mempool / octeontx / octeontx_ssovf.c
1 /*
2  *   BSD LICENSE
3  *
4  *   Copyright (C) Cavium, Inc. 2017.
5  *
6  *   Redistribution and use in source and binary forms, with or without
7  *   modification, are permitted provided that the following conditions
8  *   are met:
9  *
10  *     * Redistributions of source code must retain the above copyright
11  *       notice, this list of conditions and the following disclaimer.
12  *     * Redistributions in binary form must reproduce the above copyright
13  *       notice, this list of conditions and the following disclaimer in
14  *       the documentation and/or other materials provided with the
15  *       distribution.
16  *     * Neither the name of Cavium, Inc nor the names of its
17  *       contributors may be used to endorse or promote products derived
18  *       from this software without specific prior written permission.
19  *
20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #include <rte_atomic.h>
34 #include <rte_common.h>
35 #include <rte_eal.h>
36 #include <rte_io.h>
37 #include <rte_pci.h>
38
39 #include "octeontx_mbox.h"
40 #include "octeontx_pool_logs.h"
41
42 #define PCI_VENDOR_ID_CAVIUM              0x177D
43 #define PCI_DEVICE_ID_OCTEONTX_SSOGRP_VF  0xA04B
44 #define PCI_DEVICE_ID_OCTEONTX_SSOWS_VF   0xA04D
45
46 #define SSO_MAX_VHGRP                     (64)
47 #define SSO_MAX_VHWS                      (32)
48
49 #define SSO_VHGRP_AQ_THR                  (0x1E0ULL)
50
51 struct ssovf_res {
52         uint16_t domain;
53         uint16_t vfid;
54         void *bar0;
55         void *bar2;
56 };
57
58 struct ssowvf_res {
59         uint16_t domain;
60         uint16_t vfid;
61         void *bar0;
62         void *bar2;
63         void *bar4;
64 };
65
66 struct ssowvf_identify {
67         uint16_t domain;
68         uint16_t vfid;
69 };
70
71 struct ssodev {
72         uint8_t total_ssovfs;
73         uint8_t total_ssowvfs;
74         struct ssovf_res grp[SSO_MAX_VHGRP];
75         struct ssowvf_res hws[SSO_MAX_VHWS];
76 };
77
78 static struct ssodev sdev;
79
80 /* Interface functions */
81 int
82 octeontx_ssovf_info(struct octeontx_ssovf_info *info)
83 {
84         uint8_t i;
85         uint16_t domain;
86
87         if (rte_eal_process_type() != RTE_PROC_PRIMARY || info == NULL)
88                 return -EINVAL;
89
90         if (sdev.total_ssovfs == 0 || sdev.total_ssowvfs == 0)
91                 return -ENODEV;
92
93         domain = sdev.grp[0].domain;
94         for (i = 0; i < sdev.total_ssovfs; i++) {
95                 /* Check vfid's are contiguous and belong to same domain */
96                 if (sdev.grp[i].vfid != i ||
97                         sdev.grp[i].bar0 == NULL ||
98                         sdev.grp[i].domain != domain) {
99                         mbox_log_err("GRP error, vfid=%d/%d domain=%d/%d %p",
100                                 i, sdev.grp[i].vfid,
101                                 domain, sdev.grp[i].domain,
102                                 sdev.grp[i].bar0);
103                         return -EINVAL;
104                 }
105         }
106
107         for (i = 0; i < sdev.total_ssowvfs; i++) {
108                 /* Check vfid's are contiguous and belong to same domain */
109                 if (sdev.hws[i].vfid != i ||
110                         sdev.hws[i].bar0 == NULL ||
111                         sdev.hws[i].domain != domain) {
112                         mbox_log_err("HWS error, vfid=%d/%d domain=%d/%d %p",
113                                 i, sdev.hws[i].vfid,
114                                 domain, sdev.hws[i].domain,
115                                 sdev.hws[i].bar0);
116                         return -EINVAL;
117                 }
118         }
119
120         info->domain = domain;
121         info->total_ssovfs = sdev.total_ssovfs;
122         info->total_ssowvfs = sdev.total_ssowvfs;
123         return 0;
124 }
125
126 void*
127 octeontx_ssovf_bar(enum octeontx_ssovf_type type, uint8_t id, uint8_t bar)
128 {
129         if (rte_eal_process_type() != RTE_PROC_PRIMARY ||
130                         type > OCTEONTX_SSO_HWS)
131                 return NULL;
132
133         if (type == OCTEONTX_SSO_GROUP) {
134                 if (id >= sdev.total_ssovfs)
135                         return NULL;
136         } else {
137                 if (id >= sdev.total_ssowvfs)
138                         return NULL;
139         }
140
141         if (type == OCTEONTX_SSO_GROUP) {
142                 switch (bar) {
143                 case 0:
144                         return sdev.grp[id].bar0;
145                 case 2:
146                         return sdev.grp[id].bar2;
147                 default:
148                         return NULL;
149                 }
150         } else {
151                 switch (bar) {
152                 case 0:
153                         return sdev.hws[id].bar0;
154                 case 2:
155                         return sdev.hws[id].bar2;
156                 case 4:
157                         return sdev.hws[id].bar4;
158                 default:
159                         return NULL;
160                 }
161         }
162 }
163
164 /* SSOWVF pcie device aka event port probe */
165
166 static int
167 ssowvf_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
168 {
169         uint16_t vfid;
170         struct ssowvf_res *res;
171         struct ssowvf_identify *id;
172
173         RTE_SET_USED(pci_drv);
174
175         /* For secondary processes, the primary has done all the work */
176         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
177                 return 0;
178
179         if (pci_dev->mem_resource[0].addr == NULL ||
180                         pci_dev->mem_resource[2].addr == NULL ||
181                         pci_dev->mem_resource[4].addr == NULL) {
182                 mbox_log_err("Empty bars %p %p %p",
183                                 pci_dev->mem_resource[0].addr,
184                                 pci_dev->mem_resource[2].addr,
185                                 pci_dev->mem_resource[4].addr);
186                 return -ENODEV;
187         }
188
189         if (pci_dev->mem_resource[4].len != SSOW_BAR4_LEN) {
190                 mbox_log_err("Bar4 len mismatch %d != %d",
191                         SSOW_BAR4_LEN, (int)pci_dev->mem_resource[4].len);
192                 return -EINVAL;
193         }
194
195         id = pci_dev->mem_resource[4].addr;
196         vfid = id->vfid;
197         if (vfid >= SSO_MAX_VHWS) {
198                 mbox_log_err("Invalid vfid(%d/%d)", vfid, SSO_MAX_VHWS);
199                 return -EINVAL;
200         }
201
202         res = &sdev.hws[vfid];
203         res->vfid = vfid;
204         res->bar0 = pci_dev->mem_resource[0].addr;
205         res->bar2 = pci_dev->mem_resource[2].addr;
206         res->bar4 = pci_dev->mem_resource[4].addr;
207         res->domain = id->domain;
208
209         sdev.total_ssowvfs++;
210         rte_wmb();
211         mbox_log_dbg("Domain=%d hws=%d total_ssowvfs=%d", res->domain,
212                         res->vfid, sdev.total_ssowvfs);
213         return 0;
214 }
215
216 static const struct rte_pci_id pci_ssowvf_map[] = {
217         {
218                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
219                                 PCI_DEVICE_ID_OCTEONTX_SSOWS_VF)
220         },
221         {
222                 .vendor_id = 0,
223         },
224 };
225
226 static struct rte_pci_driver pci_ssowvf = {
227         .id_table = pci_ssowvf_map,
228         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
229         .probe = ssowvf_probe,
230 };
231
232 RTE_PMD_REGISTER_PCI(octeontx_ssowvf, pci_ssowvf);
233
234 /* SSOVF pcie device aka event queue probe */
235
236 static int
237 ssovf_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
238 {
239         uint64_t val;
240         uint16_t vfid;
241         uint8_t *idreg;
242         struct ssovf_res *res;
243
244         RTE_SET_USED(pci_drv);
245
246         /* For secondary processes, the primary has done all the work */
247         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
248                 return 0;
249
250         if (pci_dev->mem_resource[0].addr == NULL ||
251                         pci_dev->mem_resource[2].addr == NULL) {
252                 mbox_log_err("Empty bars %p %p",
253                         pci_dev->mem_resource[0].addr,
254                         pci_dev->mem_resource[2].addr);
255                 return -ENODEV;
256         }
257         idreg = pci_dev->mem_resource[0].addr;
258         idreg += SSO_VHGRP_AQ_THR;
259         val = rte_read64(idreg);
260
261         /* Write back the default value of aq_thr */
262         rte_write64((1ULL << 33) - 1, idreg);
263         vfid = (val >> 16) & 0xffff;
264         if (vfid >= SSO_MAX_VHGRP) {
265                 mbox_log_err("Invalid vfid (%d/%d)", vfid, SSO_MAX_VHGRP);
266                 return -EINVAL;
267         }
268
269         res = &sdev.grp[vfid];
270         res->vfid = vfid;
271         res->bar0 = pci_dev->mem_resource[0].addr;
272         res->bar2 = pci_dev->mem_resource[2].addr;
273         res->domain = val & 0xffff;
274
275         sdev.total_ssovfs++;
276         rte_wmb();
277         mbox_log_dbg("Domain=%d group=%d total_ssovfs=%d", res->domain,
278                         res->vfid, sdev.total_ssovfs);
279         return 0;
280 }
281
282 static const struct rte_pci_id pci_ssovf_map[] = {
283         {
284                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
285                                 PCI_DEVICE_ID_OCTEONTX_SSOGRP_VF)
286         },
287         {
288                 .vendor_id = 0,
289         },
290 };
291
292 static struct rte_pci_driver pci_ssovf = {
293         .id_table = pci_ssovf_map,
294         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
295         .probe = ssovf_probe,
296 };
297
298 RTE_PMD_REGISTER_PCI(octeontx_ssovf, pci_ssovf);