]> git.proxmox.com Git - ceph.git/blob - ceph/src/spdk/dpdk/drivers/net/netvsc/hn_rndis.c
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update sources to ceph Nautilus 14.2.1
[ceph.git] / ceph / src / spdk / dpdk / drivers / net / netvsc / hn_rndis.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (c) 2009-2018 Microsoft Corp.
3 * Copyright (c) 2010-2012 Citrix Inc.
4 * Copyright (c) 2012 NetApp Inc.
5 * All rights reserved.
6 */
7
8 #include <stdint.h>
9 #include <string.h>
10 #include <stdio.h>
11 #include <errno.h>
12 #include <unistd.h>
13
14 #include <rte_ethdev.h>
15 #include <rte_string_fns.h>
16 #include <rte_memzone.h>
17 #include <rte_malloc.h>
18 #include <rte_atomic.h>
19 #include <rte_branch_prediction.h>
20 #include <rte_ether.h>
21 #include <rte_common.h>
22 #include <rte_errno.h>
23 #include <rte_cycles.h>
24 #include <rte_memory.h>
25 #include <rte_eal.h>
26 #include <rte_dev.h>
27 #include <rte_bus_vmbus.h>
28
29 #include "hn_logs.h"
30 #include "hn_var.h"
31 #include "hn_nvs.h"
32 #include "hn_rndis.h"
33 #include "ndis.h"
34
35 #define HN_RNDIS_XFER_SIZE 0x4000
36
37 #define HN_NDIS_TXCSUM_CAP_IP4 \
38 (NDIS_TXCSUM_CAP_IP4 | NDIS_TXCSUM_CAP_IP4OPT)
39 #define HN_NDIS_TXCSUM_CAP_TCP4 \
40 (NDIS_TXCSUM_CAP_TCP4 | NDIS_TXCSUM_CAP_TCP4OPT)
41 #define HN_NDIS_TXCSUM_CAP_TCP6 \
42 (NDIS_TXCSUM_CAP_TCP6 | NDIS_TXCSUM_CAP_TCP6OPT | \
43 NDIS_TXCSUM_CAP_IP6EXT)
44 #define HN_NDIS_TXCSUM_CAP_UDP6 \
45 (NDIS_TXCSUM_CAP_UDP6 | NDIS_TXCSUM_CAP_IP6EXT)
46 #define HN_NDIS_LSOV2_CAP_IP6 \
47 (NDIS_LSOV2_CAP_IP6EXT | NDIS_LSOV2_CAP_TCP6OPT)
48
49 /* Get unique request id */
50 static inline uint32_t
51 hn_rndis_rid(struct hn_data *hv)
52 {
53 uint32_t rid;
54
55 do {
56 rid = rte_atomic32_add_return(&hv->rndis_req_id, 1);
57 } while (rid == 0);
58
59 return rid;
60 }
61
62 static void *hn_rndis_alloc(struct hn_data *hv, size_t size)
63 {
64 return rte_zmalloc_socket("RNDIS", size, PAGE_SIZE,
65 hv->vmbus->device.numa_node);
66 }
67
68 #ifdef RTE_LIBRTE_NETVSC_DEBUG_DUMP
69 void hn_rndis_dump(const void *buf)
70 {
71 const union {
72 struct rndis_msghdr hdr;
73 struct rndis_packet_msg pkt;
74 struct rndis_init_req init_request;
75 struct rndis_init_comp init_complete;
76 struct rndis_halt_req halt;
77 struct rndis_query_req query_request;
78 struct rndis_query_comp query_complete;
79 struct rndis_set_req set_request;
80 struct rndis_set_comp set_complete;
81 struct rndis_reset_req reset_request;
82 struct rndis_reset_comp reset_complete;
83 struct rndis_keepalive_req keepalive_request;
84 struct rndis_keepalive_comp keepalive_complete;
85 struct rndis_status_msg indicate_status;
86 } *rndis_msg = buf;
87
88 switch (rndis_msg->hdr.type) {
89 case RNDIS_PACKET_MSG: {
90 const struct rndis_pktinfo *ppi;
91 unsigned int ppi_len;
92
93 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
94 "RNDIS_MSG_PACKET (len %u, data %u:%u, # oob %u %u:%u, pkt %u:%u)\n",
95 rndis_msg->pkt.len,
96 rndis_msg->pkt.dataoffset,
97 rndis_msg->pkt.datalen,
98 rndis_msg->pkt.oobdataelements,
99 rndis_msg->pkt.oobdataoffset,
100 rndis_msg->pkt.oobdatalen,
101 rndis_msg->pkt.pktinfooffset,
102 rndis_msg->pkt.pktinfolen);
103
104 ppi = (const struct rndis_pktinfo *)
105 ((const char *)buf
106 + RNDIS_PACKET_MSG_OFFSET_ABS(rndis_msg->pkt.pktinfooffset));
107
108 ppi_len = rndis_msg->pkt.pktinfolen;
109 while (ppi_len > 0) {
110 const void *ppi_data;
111
112 ppi_data = ppi->data;
113
114 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
115 " PPI (size %u, type %u, offs %u data %#x)\n",
116 ppi->size, ppi->type, ppi->offset,
117 *(const uint32_t *)ppi_data);
118 if (ppi->size == 0)
119 break;
120 ppi_len -= ppi->size;
121 ppi = (const struct rndis_pktinfo *)
122 ((const char *)ppi + ppi->size);
123 }
124 break;
125 }
126 case RNDIS_INITIALIZE_MSG:
127 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
128 "RNDIS_MSG_INIT (len %u id %#x, ver %u.%u max xfer %u)\n",
129 rndis_msg->init_request.len,
130 rndis_msg->init_request.rid,
131 rndis_msg->init_request.ver_major,
132 rndis_msg->init_request.ver_minor,
133 rndis_msg->init_request.max_xfersz);
134 break;
135
136 case RNDIS_INITIALIZE_CMPLT:
137 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
138 "RNDIS_MSG_INIT_C (len %u, id %#x, status 0x%x, vers %u.%u, "
139 "flags %d, max xfer %u, max pkts %u, aligned %u)\n",
140 rndis_msg->init_complete.len,
141 rndis_msg->init_complete.rid,
142 rndis_msg->init_complete.status,
143 rndis_msg->init_complete.ver_major,
144 rndis_msg->init_complete.ver_minor,
145 rndis_msg->init_complete.devflags,
146 rndis_msg->init_complete.pktmaxsz,
147 rndis_msg->init_complete.pktmaxcnt,
148 rndis_msg->init_complete.align);
149 break;
150
151 case RNDIS_HALT_MSG:
152 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
153 "RNDIS_HALT (len %u id %#x)\n",
154 rndis_msg->halt.len, rndis_msg->halt.rid);
155 break;
156
157 case RNDIS_QUERY_MSG:
158 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
159 "RNDIS_QUERY (len %u, id %#x, oid %#x, info %u:%u)\n",
160 rndis_msg->query_request.len,
161 rndis_msg->query_request.rid,
162 rndis_msg->query_request.oid,
163 rndis_msg->query_request.infobuflen,
164 rndis_msg->query_request.infobufoffset);
165 break;
166
167 case RNDIS_QUERY_CMPLT:
168 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
169 "RNDIS_MSG_QUERY_C (len %u, id %#x, status 0x%x, buf %u:%u)\n",
170 rndis_msg->query_complete.len,
171 rndis_msg->query_complete.rid,
172 rndis_msg->query_complete.status,
173 rndis_msg->query_complete.infobuflen,
174 rndis_msg->query_complete.infobufoffset);
175 break;
176
177 case RNDIS_SET_MSG:
178 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
179 "RNDIS_SET (len %u, id %#x, oid %#x, info %u:%u)\n",
180 rndis_msg->set_request.len,
181 rndis_msg->set_request.rid,
182 rndis_msg->set_request.oid,
183 rndis_msg->set_request.infobuflen,
184 rndis_msg->set_request.infobufoffset);
185 break;
186
187 case RNDIS_SET_CMPLT:
188 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
189 "RNDIS_MSG_SET_C (len %u, id 0x%x, status 0x%x)\n",
190 rndis_msg->set_complete.len,
191 rndis_msg->set_complete.rid,
192 rndis_msg->set_complete.status);
193 break;
194
195 case RNDIS_INDICATE_STATUS_MSG:
196 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
197 "RNDIS_MSG_INDICATE (len %u, status %#x, buf len %u, buf offset %u)\n",
198 rndis_msg->indicate_status.len,
199 rndis_msg->indicate_status.status,
200 rndis_msg->indicate_status.stbuflen,
201 rndis_msg->indicate_status.stbufoffset);
202 break;
203
204 case RNDIS_RESET_MSG:
205 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
206 "RNDIS_RESET (len %u, id %#x)\n",
207 rndis_msg->reset_request.len,
208 rndis_msg->reset_request.rid);
209 break;
210
211 case RNDIS_RESET_CMPLT:
212 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
213 "RNDIS_RESET_C (len %u, status %#x address %#x)\n",
214 rndis_msg->reset_complete.len,
215 rndis_msg->reset_complete.status,
216 rndis_msg->reset_complete.adrreset);
217 break;
218
219 case RNDIS_KEEPALIVE_MSG:
220 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
221 "RNDIS_KEEPALIVE (len %u, id %#x)\n",
222 rndis_msg->keepalive_request.len,
223 rndis_msg->keepalive_request.rid);
224 break;
225
226 case RNDIS_KEEPALIVE_CMPLT:
227 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
228 "RNDIS_KEEPALIVE_C (len %u, id %#x address %#x)\n",
229 rndis_msg->keepalive_complete.len,
230 rndis_msg->keepalive_complete.rid,
231 rndis_msg->keepalive_complete.status);
232 break;
233
234 default:
235 rte_log(RTE_LOG_DEBUG, hn_logtype_driver,
236 "RNDIS type %#x len %u\n",
237 rndis_msg->hdr.type,
238 rndis_msg->hdr.len);
239 break;
240 }
241 }
242 #endif
243
244 static int hn_nvs_send_rndis_ctrl(struct vmbus_channel *chan,
245 const void *req, uint32_t reqlen)
246
247 {
248 struct hn_nvs_rndis nvs_rndis = {
249 .type = NVS_TYPE_RNDIS,
250 .rndis_mtype = NVS_RNDIS_MTYPE_CTRL,
251 .chim_idx = NVS_CHIM_IDX_INVALID,
252 .chim_sz = 0
253 };
254 struct vmbus_gpa sg;
255 rte_iova_t addr;
256
257 addr = rte_malloc_virt2iova(req);
258 if (unlikely(addr == RTE_BAD_IOVA)) {
259 PMD_DRV_LOG(ERR, "RNDIS send request can not get iova");
260 return -EINVAL;
261 }
262
263 if (unlikely(reqlen > PAGE_SIZE)) {
264 PMD_DRV_LOG(ERR, "RNDIS request %u greater than page size",
265 reqlen);
266 return -EINVAL;
267 }
268
269 sg.page = addr / PAGE_SIZE;
270 sg.ofs = addr & PAGE_MASK;
271 sg.len = reqlen;
272
273 if (sg.ofs + reqlen > PAGE_SIZE) {
274 PMD_DRV_LOG(ERR, "RNDIS request crosses page bounary");
275 return -EINVAL;
276 }
277
278 hn_rndis_dump(req);
279
280 return hn_nvs_send_sglist(chan, &sg, 1,
281 &nvs_rndis, sizeof(nvs_rndis), 0U, NULL);
282 }
283
284 void hn_rndis_link_status(struct hn_data *hv __rte_unused, const void *msg)
285 {
286 const struct rndis_status_msg *indicate = msg;
287
288 hn_rndis_dump(msg);
289
290 PMD_DRV_LOG(DEBUG, "link status %#x", indicate->status);
291
292 switch (indicate->status) {
293 case RNDIS_STATUS_LINK_SPEED_CHANGE:
294 case RNDIS_STATUS_NETWORK_CHANGE:
295 case RNDIS_STATUS_TASK_OFFLOAD_CURRENT_CONFIG:
296 /* ignore not in DPDK API */
297 break;
298
299 case RNDIS_STATUS_MEDIA_CONNECT:
300 case RNDIS_STATUS_MEDIA_DISCONNECT:
301 /* TODO handle as LSC interrupt */
302 break;
303 default:
304 PMD_DRV_LOG(NOTICE, "unknown RNDIS indication: %#x",
305 indicate->status);
306 }
307 }
308
309 /* Callback from hn_process_events when response is visible */
310 void hn_rndis_receive_response(struct hn_data *hv,
311 const void *data, uint32_t len)
312 {
313 const struct rndis_init_comp *hdr = data;
314
315 hn_rndis_dump(data);
316
317 if (len < sizeof(3 * sizeof(uint32_t))) {
318 PMD_DRV_LOG(ERR,
319 "missing RNDIS header %u", len);
320 return;
321 }
322
323 if (len < hdr->len) {
324 PMD_DRV_LOG(ERR,
325 "truncated RNDIS response %u", len);
326 return;
327 }
328
329 if (len > sizeof(hv->rndis_resp)) {
330 PMD_DRV_LOG(NOTICE,
331 "RNDIS response exceeds buffer");
332 len = sizeof(hv->rndis_resp);
333 }
334
335 if (hdr->rid == 0) {
336 PMD_DRV_LOG(NOTICE,
337 "RNDIS response id zero!");
338 }
339
340 memcpy(hv->rndis_resp, data, len);
341
342 /* make sure response copied before update */
343 rte_smp_wmb();
344
345 if (rte_atomic32_cmpset(&hv->rndis_pending, hdr->rid, 0) == 0) {
346 PMD_DRV_LOG(ERR,
347 "received id %#x pending id %#x",
348 hdr->rid, (uint32_t)hv->rndis_pending);
349 }
350 }
351
352 /* Do request/response transaction */
353 static int hn_rndis_exec1(struct hn_data *hv,
354 const void *req, uint32_t reqlen,
355 void *comp, uint32_t comp_len)
356 {
357 const struct rndis_halt_req *hdr = req;
358 uint32_t rid = hdr->rid;
359 struct vmbus_channel *chan = hn_primary_chan(hv);
360 int error;
361
362 if (comp_len > sizeof(hv->rndis_resp)) {
363 PMD_DRV_LOG(ERR,
364 "Expected completion size %u exceeds buffer %zu",
365 comp_len, sizeof(hv->rndis_resp));
366 return -EIO;
367 }
368
369 if (comp != NULL &&
370 rte_atomic32_cmpset(&hv->rndis_pending, 0, rid) == 0) {
371 PMD_DRV_LOG(ERR,
372 "Request already pending");
373 return -EBUSY;
374 }
375
376 error = hn_nvs_send_rndis_ctrl(chan, req, reqlen);
377 if (error) {
378 PMD_DRV_LOG(ERR, "RNDIS ctrl send failed: %d", error);
379 return error;
380 }
381
382 if (comp) {
383 /* Poll primary channel until response received */
384 while (hv->rndis_pending == rid)
385 hn_process_events(hv, 0);
386
387 memcpy(comp, hv->rndis_resp, comp_len);
388 }
389
390 return 0;
391 }
392
393 /* Do transaction and validate response */
394 static int hn_rndis_execute(struct hn_data *hv, uint32_t rid,
395 const void *req, uint32_t reqlen,
396 void *comp, uint32_t comp_len, uint32_t comp_type)
397 {
398 const struct rndis_comp_hdr *hdr = comp;
399 int ret;
400
401 memset(comp, 0, comp_len);
402
403 ret = hn_rndis_exec1(hv, req, reqlen, comp, comp_len);
404 if (ret < 0)
405 return ret;
406 /*
407 * Check this RNDIS complete message.
408 */
409 if (unlikely(hdr->type != comp_type)) {
410 PMD_DRV_LOG(ERR,
411 "unexpected RNDIS response complete %#x expect %#x",
412 hdr->type, comp_type);
413
414 return -ENXIO;
415 }
416 if (unlikely(hdr->rid != rid)) {
417 PMD_DRV_LOG(ERR,
418 "RNDIS comp rid mismatch %#x, expect %#x",
419 hdr->rid, rid);
420 return -EINVAL;
421 }
422
423 /* All pass! */
424 return 0;
425 }
426
427 static int
428 hn_rndis_query(struct hn_data *hv, uint32_t oid,
429 const void *idata, uint32_t idlen,
430 void *odata, uint32_t odlen)
431 {
432 struct rndis_query_req *req;
433 struct rndis_query_comp *comp;
434 uint32_t reqlen, comp_len;
435 int error = -EIO;
436 unsigned int ofs;
437 uint32_t rid;
438
439 reqlen = sizeof(*req) + idlen;
440 req = hn_rndis_alloc(hv, reqlen);
441 if (req == NULL)
442 return -ENOMEM;
443
444 comp_len = sizeof(*comp) + odlen;
445 comp = rte_zmalloc("QUERY", comp_len, PAGE_SIZE);
446 if (!comp) {
447 error = -ENOMEM;
448 goto done;
449 }
450 comp->status = RNDIS_STATUS_PENDING;
451
452 rid = hn_rndis_rid(hv);
453
454 req->type = RNDIS_QUERY_MSG;
455 req->len = reqlen;
456 req->rid = rid;
457 req->oid = oid;
458 req->infobufoffset = RNDIS_QUERY_REQ_INFOBUFOFFSET;
459 req->infobuflen = idlen;
460
461 /* Input data immediately follows RNDIS query. */
462 memcpy(req + 1, idata, idlen);
463
464 error = hn_rndis_execute(hv, rid, req, reqlen,
465 comp, comp_len, RNDIS_QUERY_CMPLT);
466
467 if (error)
468 goto done;
469
470 if (comp->status != RNDIS_STATUS_SUCCESS) {
471 PMD_DRV_LOG(ERR, "RNDIS query 0x%08x failed: status 0x%08x",
472 oid, comp->status);
473 error = -EINVAL;
474 goto done;
475 }
476
477 if (comp->infobuflen == 0 || comp->infobufoffset == 0) {
478 /* No output data! */
479 PMD_DRV_LOG(ERR, "RNDIS query 0x%08x, no data", oid);
480 error = 0;
481 goto done;
482 }
483
484 /*
485 * Check output data length and offset.
486 */
487 /* ofs is the offset from the beginning of comp. */
488 ofs = RNDIS_QUERY_COMP_INFOBUFOFFSET_ABS(comp->infobufoffset);
489 if (ofs < sizeof(*comp) || ofs + comp->infobuflen > comp_len) {
490 PMD_DRV_LOG(ERR, "RNDIS query invalid comp ib off/len, %u/%u",
491 comp->infobufoffset, comp->infobuflen);
492 error = -EINVAL;
493 goto done;
494 }
495
496 /* Save output data. */
497 if (comp->infobuflen < odlen)
498 odlen = comp->infobuflen;
499
500 /* ofs is the offset from the beginning of comp. */
501 memcpy(odata, (const char *)comp + ofs, odlen);
502
503 error = 0;
504 done:
505 rte_free(comp);
506 rte_free(req);
507 return error;
508 }
509
510 static int
511 hn_rndis_halt(struct hn_data *hv)
512 {
513 struct rndis_halt_req *halt;
514
515 halt = hn_rndis_alloc(hv, sizeof(*halt));
516 if (halt == NULL)
517 return -ENOMEM;
518
519 halt->type = RNDIS_HALT_MSG;
520 halt->len = sizeof(*halt);
521 halt->rid = hn_rndis_rid(hv);
522
523 /* No RNDIS completion; rely on NVS message send completion */
524 hn_rndis_exec1(hv, halt, sizeof(*halt), NULL, 0);
525
526 rte_free(halt);
527
528 PMD_INIT_LOG(DEBUG, "RNDIS halt done");
529 return 0;
530 }
531
532 static int
533 hn_rndis_query_hwcaps(struct hn_data *hv, struct ndis_offload *caps)
534 {
535 struct ndis_offload in;
536 uint32_t caps_len, size;
537 int error;
538
539 memset(caps, 0, sizeof(*caps));
540 memset(&in, 0, sizeof(in));
541 in.ndis_hdr.ndis_type = NDIS_OBJTYPE_OFFLOAD;
542
543 if (hv->ndis_ver >= NDIS_VERSION_6_30) {
544 in.ndis_hdr.ndis_rev = NDIS_OFFLOAD_REV_3;
545 size = NDIS_OFFLOAD_SIZE;
546 } else if (hv->ndis_ver >= NDIS_VERSION_6_1) {
547 in.ndis_hdr.ndis_rev = NDIS_OFFLOAD_REV_2;
548 size = NDIS_OFFLOAD_SIZE_6_1;
549 } else {
550 in.ndis_hdr.ndis_rev = NDIS_OFFLOAD_REV_1;
551 size = NDIS_OFFLOAD_SIZE_6_0;
552 }
553 in.ndis_hdr.ndis_size = size;
554
555 caps_len = NDIS_OFFLOAD_SIZE;
556 error = hn_rndis_query(hv, OID_TCP_OFFLOAD_HARDWARE_CAPABILITIES,
557 &in, size, caps, caps_len);
558 if (error)
559 return error;
560
561 /* Preliminary verification. */
562 if (caps->ndis_hdr.ndis_type != NDIS_OBJTYPE_OFFLOAD) {
563 PMD_DRV_LOG(NOTICE, "invalid NDIS objtype 0x%02x",
564 caps->ndis_hdr.ndis_type);
565 return -EINVAL;
566 }
567 if (caps->ndis_hdr.ndis_rev < NDIS_OFFLOAD_REV_1) {
568 PMD_DRV_LOG(NOTICE, "invalid NDIS objrev 0x%02x",
569 caps->ndis_hdr.ndis_rev);
570 return -EINVAL;
571 }
572 if (caps->ndis_hdr.ndis_size > caps_len) {
573 PMD_DRV_LOG(NOTICE, "invalid NDIS objsize %u, data size %u",
574 caps->ndis_hdr.ndis_size, caps_len);
575 return -EINVAL;
576 } else if (caps->ndis_hdr.ndis_size < NDIS_OFFLOAD_SIZE_6_0) {
577 PMD_DRV_LOG(NOTICE, "invalid NDIS objsize %u",
578 caps->ndis_hdr.ndis_size);
579 return -EINVAL;
580 }
581
582 return 0;
583 }
584
585 int
586 hn_rndis_query_rsscaps(struct hn_data *hv,
587 unsigned int *rxr_cnt0)
588 {
589 struct ndis_rss_caps in, caps;
590 unsigned int indsz, rxr_cnt;
591 uint32_t caps_len;
592 int error;
593
594 *rxr_cnt0 = 0;
595
596 if (hv->ndis_ver < NDIS_VERSION_6_20) {
597 PMD_DRV_LOG(DEBUG, "RSS not supported on this host");
598 return -EOPNOTSUPP;
599 }
600
601 memset(&in, 0, sizeof(in));
602 in.ndis_hdr.ndis_type = NDIS_OBJTYPE_RSS_CAPS;
603 in.ndis_hdr.ndis_rev = NDIS_RSS_CAPS_REV_2;
604 in.ndis_hdr.ndis_size = NDIS_RSS_CAPS_SIZE;
605
606 caps_len = NDIS_RSS_CAPS_SIZE;
607 error = hn_rndis_query(hv, OID_GEN_RECEIVE_SCALE_CAPABILITIES,
608 &in, NDIS_RSS_CAPS_SIZE,
609 &caps, caps_len);
610 if (error)
611 return error;
612
613 PMD_INIT_LOG(DEBUG, "RX rings %u indirect %u caps %#x",
614 caps.ndis_nrxr, caps.ndis_nind, caps.ndis_caps);
615 /*
616 * Preliminary verification.
617 */
618 if (caps.ndis_hdr.ndis_type != NDIS_OBJTYPE_RSS_CAPS) {
619 PMD_DRV_LOG(ERR, "invalid NDIS objtype 0x%02x",
620 caps.ndis_hdr.ndis_type);
621 return -EINVAL;
622 }
623 if (caps.ndis_hdr.ndis_rev < NDIS_RSS_CAPS_REV_1) {
624 PMD_DRV_LOG(ERR, "invalid NDIS objrev 0x%02x",
625 caps.ndis_hdr.ndis_rev);
626 return -EINVAL;
627 }
628 if (caps.ndis_hdr.ndis_size > caps_len) {
629 PMD_DRV_LOG(ERR,
630 "invalid NDIS objsize %u, data size %u",
631 caps.ndis_hdr.ndis_size, caps_len);
632 return -EINVAL;
633 } else if (caps.ndis_hdr.ndis_size < NDIS_RSS_CAPS_SIZE_6_0) {
634 PMD_DRV_LOG(ERR, "invalid NDIS objsize %u",
635 caps.ndis_hdr.ndis_size);
636 return -EINVAL;
637 }
638
639 /*
640 * Save information for later RSS configuration.
641 */
642 if (caps.ndis_nrxr == 0) {
643 PMD_DRV_LOG(ERR, "0 RX rings!?");
644 return -EINVAL;
645 }
646 rxr_cnt = caps.ndis_nrxr;
647
648 if (caps.ndis_hdr.ndis_size == NDIS_RSS_CAPS_SIZE &&
649 caps.ndis_hdr.ndis_rev >= NDIS_RSS_CAPS_REV_2) {
650 if (caps.ndis_nind > NDIS_HASH_INDCNT) {
651 PMD_DRV_LOG(ERR,
652 "too many RSS indirect table entries %u",
653 caps.ndis_nind);
654 return -EOPNOTSUPP;
655 }
656 if (!rte_is_power_of_2(caps.ndis_nind)) {
657 PMD_DRV_LOG(ERR,
658 "RSS indirect table size is not power-of-2 %u",
659 caps.ndis_nind);
660 }
661
662 indsz = caps.ndis_nind;
663 } else {
664 indsz = NDIS_HASH_INDCNT;
665 }
666
667 if (indsz < rxr_cnt) {
668 PMD_DRV_LOG(NOTICE,
669 "# of RX rings (%d) > RSS indirect table size %d",
670 rxr_cnt, indsz);
671 rxr_cnt = indsz;
672 }
673
674 hv->rss_offloads = 0;
675 if (caps.ndis_caps & NDIS_RSS_CAP_IPV4)
676 hv->rss_offloads |= ETH_RSS_IPV4
677 | ETH_RSS_NONFRAG_IPV4_TCP
678 | ETH_RSS_NONFRAG_IPV4_UDP;
679 if (caps.ndis_caps & NDIS_RSS_CAP_IPV6)
680 hv->rss_offloads |= ETH_RSS_IPV6
681 | ETH_RSS_NONFRAG_IPV6_TCP;
682 if (caps.ndis_caps & NDIS_RSS_CAP_IPV6_EX)
683 hv->rss_offloads |= ETH_RSS_IPV6_EX
684 | ETH_RSS_IPV6_TCP_EX;
685
686 /* Commit! */
687 *rxr_cnt0 = rxr_cnt;
688
689 return 0;
690 }
691
692 static int
693 hn_rndis_set(struct hn_data *hv, uint32_t oid, const void *data, uint32_t dlen)
694 {
695 struct rndis_set_req *req;
696 struct rndis_set_comp comp;
697 uint32_t reqlen, comp_len;
698 uint32_t rid;
699 int error;
700
701 reqlen = sizeof(*req) + dlen;
702 req = rte_zmalloc("RNDIS_SET", reqlen, PAGE_SIZE);
703 if (!req)
704 return -ENOMEM;
705
706 rid = hn_rndis_rid(hv);
707 req->type = RNDIS_SET_MSG;
708 req->len = reqlen;
709 req->rid = rid;
710 req->oid = oid;
711 req->infobuflen = dlen;
712 req->infobufoffset = RNDIS_SET_REQ_INFOBUFOFFSET;
713
714 /* Data immediately follows RNDIS set. */
715 memcpy(req + 1, data, dlen);
716
717 comp_len = sizeof(comp);
718 error = hn_rndis_execute(hv, rid, req, reqlen,
719 &comp, comp_len,
720 RNDIS_SET_CMPLT);
721 if (error) {
722 PMD_DRV_LOG(ERR, "exec RNDIS set %#" PRIx32 " failed",
723 oid);
724 error = EIO;
725 goto done;
726 }
727
728 if (comp.status != RNDIS_STATUS_SUCCESS) {
729 PMD_DRV_LOG(ERR,
730 "RNDIS set %#" PRIx32 " failed: status %#" PRIx32,
731 oid, comp.status);
732 error = EIO;
733 goto done;
734 }
735
736 done:
737 rte_free(req);
738 return error;
739 }
740
741 int hn_rndis_conf_offload(struct hn_data *hv,
742 uint64_t tx_offloads, uint64_t rx_offloads)
743 {
744 struct ndis_offload_params params;
745 struct ndis_offload hwcaps;
746 int error;
747
748 error = hn_rndis_query_hwcaps(hv, &hwcaps);
749 if (error) {
750 PMD_DRV_LOG(ERR, "hwcaps query failed: %d", error);
751 return error;
752 }
753
754 /* NOTE: 0 means "no change" */
755 memset(&params, 0, sizeof(params));
756
757 params.ndis_hdr.ndis_type = NDIS_OBJTYPE_DEFAULT;
758 if (hv->ndis_ver < NDIS_VERSION_6_30) {
759 params.ndis_hdr.ndis_rev = NDIS_OFFLOAD_PARAMS_REV_2;
760 params.ndis_hdr.ndis_size = NDIS_OFFLOAD_PARAMS_SIZE_6_1;
761 } else {
762 params.ndis_hdr.ndis_rev = NDIS_OFFLOAD_PARAMS_REV_3;
763 params.ndis_hdr.ndis_size = NDIS_OFFLOAD_PARAMS_SIZE;
764 }
765
766 if (tx_offloads & DEV_TX_OFFLOAD_TCP_CKSUM) {
767 if (hwcaps.ndis_csum.ndis_ip4_txcsum & NDIS_TXCSUM_CAP_TCP4)
768 params.ndis_tcp4csum = NDIS_OFFLOAD_PARAM_TX;
769 else
770 goto unsupported;
771
772 if (hwcaps.ndis_csum.ndis_ip6_txcsum & NDIS_TXCSUM_CAP_TCP6)
773 params.ndis_tcp6csum = NDIS_OFFLOAD_PARAM_TX;
774 else
775 goto unsupported;
776 }
777
778 if (rx_offloads & DEV_RX_OFFLOAD_TCP_CKSUM) {
779 if ((hwcaps.ndis_csum.ndis_ip4_rxcsum & NDIS_RXCSUM_CAP_TCP4)
780 == NDIS_RXCSUM_CAP_TCP4)
781 params.ndis_tcp4csum |= NDIS_OFFLOAD_PARAM_RX;
782 else
783 goto unsupported;
784
785 if ((hwcaps.ndis_csum.ndis_ip6_rxcsum & NDIS_RXCSUM_CAP_TCP6)
786 == NDIS_RXCSUM_CAP_TCP6)
787 params.ndis_tcp6csum |= NDIS_OFFLOAD_PARAM_RX;
788 else
789 goto unsupported;
790 }
791
792 if (tx_offloads & DEV_TX_OFFLOAD_UDP_CKSUM) {
793 if (hwcaps.ndis_csum.ndis_ip4_txcsum & NDIS_TXCSUM_CAP_UDP4)
794 params.ndis_udp4csum = NDIS_OFFLOAD_PARAM_TX;
795 else
796 goto unsupported;
797
798 if ((hwcaps.ndis_csum.ndis_ip6_txcsum & NDIS_TXCSUM_CAP_UDP6)
799 == NDIS_TXCSUM_CAP_UDP6)
800 params.ndis_udp6csum = NDIS_OFFLOAD_PARAM_TX;
801 else
802 goto unsupported;
803 }
804
805 if (rx_offloads & DEV_TX_OFFLOAD_UDP_CKSUM) {
806 if (hwcaps.ndis_csum.ndis_ip4_rxcsum & NDIS_RXCSUM_CAP_UDP4)
807 params.ndis_udp4csum |= NDIS_OFFLOAD_PARAM_RX;
808 else
809 goto unsupported;
810
811 if (hwcaps.ndis_csum.ndis_ip6_rxcsum & NDIS_RXCSUM_CAP_UDP6)
812 params.ndis_udp6csum |= NDIS_OFFLOAD_PARAM_RX;
813 else
814 goto unsupported;
815 }
816
817 if (tx_offloads & DEV_TX_OFFLOAD_IPV4_CKSUM) {
818 if ((hwcaps.ndis_csum.ndis_ip4_txcsum & NDIS_TXCSUM_CAP_IP4)
819 == NDIS_TXCSUM_CAP_IP4)
820 params.ndis_ip4csum = NDIS_OFFLOAD_PARAM_TX;
821 else
822 goto unsupported;
823 }
824 if (rx_offloads & DEV_RX_OFFLOAD_IPV4_CKSUM) {
825 if (hwcaps.ndis_csum.ndis_ip4_rxcsum & NDIS_RXCSUM_CAP_IP4)
826 params.ndis_ip4csum |= NDIS_OFFLOAD_PARAM_RX;
827 else
828 goto unsupported;
829 }
830
831 if (tx_offloads & DEV_TX_OFFLOAD_TCP_TSO) {
832 if (hwcaps.ndis_lsov2.ndis_ip4_encap & NDIS_OFFLOAD_ENCAP_8023)
833 params.ndis_lsov2_ip4 = NDIS_OFFLOAD_LSOV2_ON;
834 else
835 goto unsupported;
836
837 if ((hwcaps.ndis_lsov2.ndis_ip6_opts & HN_NDIS_LSOV2_CAP_IP6)
838 == HN_NDIS_LSOV2_CAP_IP6)
839 params.ndis_lsov2_ip6 = NDIS_OFFLOAD_LSOV2_ON;
840 else
841 goto unsupported;
842 }
843
844 error = hn_rndis_set(hv, OID_TCP_OFFLOAD_PARAMETERS, &params,
845 params.ndis_hdr.ndis_size);
846 if (error) {
847 PMD_DRV_LOG(ERR, "offload config failed");
848 return error;
849 }
850
851 return 0;
852 unsupported:
853 PMD_DRV_LOG(NOTICE,
854 "offload tx:%" PRIx64 " rx:%" PRIx64 " not supported by this version",
855 tx_offloads, rx_offloads);
856 return -EINVAL;
857 }
858
859 int hn_rndis_get_offload(struct hn_data *hv,
860 struct rte_eth_dev_info *dev_info)
861 {
862 struct ndis_offload hwcaps;
863 int error;
864
865 memset(&hwcaps, 0, sizeof(hwcaps));
866
867 error = hn_rndis_query_hwcaps(hv, &hwcaps);
868 if (error) {
869 PMD_DRV_LOG(ERR, "hwcaps query failed: %d", error);
870 return error;
871 }
872
873 dev_info->tx_offload_capa = DEV_TX_OFFLOAD_MULTI_SEGS |
874 DEV_TX_OFFLOAD_VLAN_INSERT;
875
876 if ((hwcaps.ndis_csum.ndis_ip4_txcsum & HN_NDIS_TXCSUM_CAP_IP4)
877 == HN_NDIS_TXCSUM_CAP_IP4)
878 dev_info->tx_offload_capa |= DEV_TX_OFFLOAD_IPV4_CKSUM;
879
880 if ((hwcaps.ndis_csum.ndis_ip4_txcsum & HN_NDIS_TXCSUM_CAP_TCP4)
881 == HN_NDIS_TXCSUM_CAP_TCP4 &&
882 (hwcaps.ndis_csum.ndis_ip6_txcsum & HN_NDIS_TXCSUM_CAP_TCP6)
883 == HN_NDIS_TXCSUM_CAP_TCP6)
884 dev_info->tx_offload_capa |= DEV_TX_OFFLOAD_TCP_CKSUM;
885
886 if ((hwcaps.ndis_csum.ndis_ip4_txcsum & NDIS_TXCSUM_CAP_UDP4) &&
887 (hwcaps.ndis_csum.ndis_ip6_txcsum & NDIS_TXCSUM_CAP_UDP6))
888 dev_info->tx_offload_capa |= DEV_TX_OFFLOAD_UDP_CKSUM;
889
890 if ((hwcaps.ndis_lsov2.ndis_ip4_encap & NDIS_OFFLOAD_ENCAP_8023) &&
891 (hwcaps.ndis_lsov2.ndis_ip6_opts & HN_NDIS_LSOV2_CAP_IP6)
892 == HN_NDIS_LSOV2_CAP_IP6)
893 dev_info->tx_offload_capa |= DEV_TX_OFFLOAD_TCP_TSO;
894
895 dev_info->rx_offload_capa = DEV_RX_OFFLOAD_VLAN_STRIP |
896 DEV_RX_OFFLOAD_CRC_STRIP;
897
898 if (hwcaps.ndis_csum.ndis_ip4_rxcsum & NDIS_RXCSUM_CAP_IP4)
899 dev_info->rx_offload_capa |= DEV_RX_OFFLOAD_IPV4_CKSUM;
900
901 if ((hwcaps.ndis_csum.ndis_ip4_rxcsum & NDIS_RXCSUM_CAP_TCP4) &&
902 (hwcaps.ndis_csum.ndis_ip6_rxcsum & NDIS_RXCSUM_CAP_TCP6))
903 dev_info->rx_offload_capa |= DEV_RX_OFFLOAD_TCP_CKSUM;
904
905 if ((hwcaps.ndis_csum.ndis_ip4_rxcsum & NDIS_RXCSUM_CAP_UDP4) &&
906 (hwcaps.ndis_csum.ndis_ip6_rxcsum & NDIS_RXCSUM_CAP_UDP6))
907 dev_info->rx_offload_capa |= DEV_RX_OFFLOAD_UDP_CKSUM;
908
909 return 0;
910 }
911
912 int
913 hn_rndis_set_rxfilter(struct hn_data *hv, uint32_t filter)
914 {
915 int error;
916
917 error = hn_rndis_set(hv, OID_GEN_CURRENT_PACKET_FILTER,
918 &filter, sizeof(filter));
919 if (error) {
920 PMD_DRV_LOG(ERR, "set RX filter %#" PRIx32 " failed: %d",
921 filter, error);
922 } else {
923 PMD_DRV_LOG(DEBUG, "set RX filter %#" PRIx32 " done", filter);
924 }
925
926 return error;
927 }
928
929 /* The default RSS key.
930 * This value is the same as MLX5 so that flows will be
931 * received on same path for both VF ans synthetic NIC.
932 */
933 static const uint8_t rss_default_key[NDIS_HASH_KEYSIZE_TOEPLITZ] = {
934 0x2c, 0xc6, 0x81, 0xd1, 0x5b, 0xdb, 0xf4, 0xf7,
935 0xfc, 0xa2, 0x83, 0x19, 0xdb, 0x1a, 0x3e, 0x94,
936 0x6b, 0x9e, 0x38, 0xd9, 0x2c, 0x9c, 0x03, 0xd1,
937 0xad, 0x99, 0x44, 0xa7, 0xd9, 0x56, 0x3d, 0x59,
938 0x06, 0x3c, 0x25, 0xf3, 0xfc, 0x1f, 0xdc, 0x2a,
939 };
940
941 int hn_rndis_conf_rss(struct hn_data *hv,
942 const struct rte_eth_rss_conf *rss_conf)
943 {
944 struct ndis_rssprm_toeplitz rssp;
945 struct ndis_rss_params *prm = &rssp.rss_params;
946 const uint8_t *rss_key = rss_conf->rss_key ? : rss_default_key;
947 uint32_t rss_hash;
948 unsigned int i;
949 int error;
950
951 PMD_INIT_FUNC_TRACE();
952
953 memset(&rssp, 0, sizeof(rssp));
954
955 prm->ndis_hdr.ndis_type = NDIS_OBJTYPE_RSS_PARAMS;
956 prm->ndis_hdr.ndis_rev = NDIS_RSS_PARAMS_REV_2;
957 prm->ndis_hdr.ndis_size = sizeof(*prm);
958 prm->ndis_flags = 0;
959
960 rss_hash = NDIS_HASH_FUNCTION_TOEPLITZ;
961 if (rss_conf->rss_hf & ETH_RSS_IPV4)
962 rss_hash |= NDIS_HASH_IPV4;
963 if (rss_conf->rss_hf & ETH_RSS_NONFRAG_IPV4_TCP)
964 rss_hash |= NDIS_HASH_TCP_IPV4;
965 if (rss_conf->rss_hf & ETH_RSS_IPV6)
966 rss_hash |= NDIS_HASH_IPV6;
967 if (rss_conf->rss_hf & ETH_RSS_NONFRAG_IPV6_TCP)
968 rss_hash |= NDIS_HASH_TCP_IPV6;
969
970 prm->ndis_hash = rss_hash;
971 prm->ndis_indsize = sizeof(rssp.rss_ind[0]) * NDIS_HASH_INDCNT;
972 prm->ndis_indoffset = offsetof(struct ndis_rssprm_toeplitz, rss_ind[0]);
973 prm->ndis_keysize = NDIS_HASH_KEYSIZE_TOEPLITZ;
974 prm->ndis_keyoffset = offsetof(struct ndis_rssprm_toeplitz, rss_key[0]);
975
976 for (i = 0; i < NDIS_HASH_INDCNT; i++)
977 rssp.rss_ind[i] = i % hv->num_queues;
978
979 /* Set hask key values */
980 memcpy(&rssp.rss_key, rss_key, NDIS_HASH_KEYSIZE_TOEPLITZ);
981
982 error = hn_rndis_set(hv, OID_GEN_RECEIVE_SCALE_PARAMETERS,
983 &rssp, sizeof(rssp));
984 if (error) {
985 PMD_DRV_LOG(ERR,
986 "RSS config num queues=%u failed: %d",
987 hv->num_queues, error);
988 }
989 return error;
990 }
991
992 static int hn_rndis_init(struct hn_data *hv)
993 {
994 struct rndis_init_req *req;
995 struct rndis_init_comp comp;
996 uint32_t comp_len, rid;
997 int error;
998
999 req = hn_rndis_alloc(hv, sizeof(*req));
1000 if (!req) {
1001 PMD_DRV_LOG(ERR, "no memory for RNDIS init");
1002 return -ENXIO;
1003 }
1004
1005 rid = hn_rndis_rid(hv);
1006 req->type = RNDIS_INITIALIZE_MSG;
1007 req->len = sizeof(*req);
1008 req->rid = rid;
1009 req->ver_major = RNDIS_VERSION_MAJOR;
1010 req->ver_minor = RNDIS_VERSION_MINOR;
1011 req->max_xfersz = HN_RNDIS_XFER_SIZE;
1012
1013 comp_len = RNDIS_INIT_COMP_SIZE_MIN;
1014 error = hn_rndis_execute(hv, rid, req, sizeof(*req),
1015 &comp, comp_len,
1016 RNDIS_INITIALIZE_CMPLT);
1017 if (error)
1018 goto done;
1019
1020 if (comp.status != RNDIS_STATUS_SUCCESS) {
1021 PMD_DRV_LOG(ERR, "RNDIS init failed: status 0x%08x",
1022 comp.status);
1023 error = -EIO;
1024 goto done;
1025 }
1026
1027 hv->rndis_agg_size = comp.pktmaxsz;
1028 hv->rndis_agg_pkts = comp.pktmaxcnt;
1029 hv->rndis_agg_align = 1U << comp.align;
1030
1031 if (hv->rndis_agg_align < sizeof(uint32_t)) {
1032 /*
1033 * The RNDIS packet message encap assumes that the RNDIS
1034 * packet message is at least 4 bytes aligned. Fix up the
1035 * alignment here, if the remote side sets the alignment
1036 * too low.
1037 */
1038 PMD_DRV_LOG(NOTICE,
1039 "fixup RNDIS aggpkt align: %u -> %zu",
1040 hv->rndis_agg_align, sizeof(uint32_t));
1041 hv->rndis_agg_align = sizeof(uint32_t);
1042 }
1043
1044 PMD_INIT_LOG(INFO,
1045 "RNDIS ver %u.%u, aggpkt size %u, aggpkt cnt %u, aggpkt align %u",
1046 comp.ver_major, comp.ver_minor,
1047 hv->rndis_agg_size, hv->rndis_agg_pkts,
1048 hv->rndis_agg_align);
1049 error = 0;
1050 done:
1051 rte_free(req);
1052 return error;
1053 }
1054
1055 int
1056 hn_rndis_get_eaddr(struct hn_data *hv, uint8_t *eaddr)
1057 {
1058 uint32_t eaddr_len;
1059 int error;
1060
1061 eaddr_len = ETHER_ADDR_LEN;
1062 error = hn_rndis_query(hv, OID_802_3_PERMANENT_ADDRESS, NULL, 0,
1063 eaddr, eaddr_len);
1064 if (error)
1065 return error;
1066
1067 PMD_DRV_LOG(INFO, "MAC address %02x:%02x:%02x:%02x:%02x:%02x",
1068 eaddr[0], eaddr[1], eaddr[2],
1069 eaddr[3], eaddr[4], eaddr[5]);
1070 return 0;
1071 }
1072
1073 int
1074 hn_rndis_get_linkstatus(struct hn_data *hv)
1075 {
1076 return hn_rndis_query(hv, OID_GEN_MEDIA_CONNECT_STATUS, NULL, 0,
1077 &hv->link_status, sizeof(uint32_t));
1078 }
1079
1080 int
1081 hn_rndis_get_linkspeed(struct hn_data *hv)
1082 {
1083 return hn_rndis_query(hv, OID_GEN_LINK_SPEED, NULL, 0,
1084 &hv->link_speed, sizeof(uint32_t));
1085 }
1086
1087 int
1088 hn_rndis_attach(struct hn_data *hv)
1089 {
1090 /* Initialize RNDIS. */
1091 return hn_rndis_init(hv);
1092 }
1093
1094 void
1095 hn_rndis_detach(struct hn_data *hv)
1096 {
1097 /* Halt the RNDIS. */
1098 hn_rndis_halt(hv);
1099 }
Ceph