Lines Matching defs:cqe
3209 mcx_cmdq_poll(struct mcx_softc *sc, struct mcx_cmdq_entry *cqe,
3218 if ((cqe->cq_status & MCX_CQ_STATUS_OWN_MASK) ==
3290 mcx_cmdq_init(struct mcx_softc *sc, struct mcx_cmdq_entry *cqe,
3293 memset(cqe, 0, sc->sc_cmdq_size);
3295 cqe->cq_type = MCX_CMDQ_TYPE_PCIE;
3296 be32enc(&cqe->cq_input_length, ilen);
3297 be32enc(&cqe->cq_output_length, olen);
3298 cqe->cq_token = token;
3299 cqe->cq_status = MCX_CQ_STATUS_OWN_HW;
3303 mcx_cmdq_sign(struct mcx_cmdq_entry *cqe)
3305 cqe->cq_signature = ~mcx_xor(cqe, sizeof(*cqe));
3309 mcx_cmdq_verify(const struct mcx_cmdq_entry *cqe)
3311 /* return (mcx_xor(cqe, sizeof(*cqe)) ? -1 : 0); */
3316 mcx_cmdq_in(struct mcx_cmdq_entry *cqe)
3318 return (&cqe->cq_input_data);
3322 mcx_cmdq_out(struct mcx_cmdq_entry *cqe)
3324 return (&cqe->cq_output_data);
3328 mcx_cmdq_post(struct mcx_softc *sc, struct mcx_cmdq_entry *cqe,
3331 mcx_cmdq_sign(cqe);
3344 struct mcx_cmdq_entry *cqe;
3350 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
3351 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
3353 in = mcx_cmdq_in(cqe);
3358 mcx_cmdq_post(sc, cqe, 0);
3360 error = mcx_cmdq_poll(sc, cqe, 1000);
3365 if (mcx_cmdq_verify(cqe) != 0) {
3370 status = cqe->cq_output_data[0];
3382 struct mcx_cmdq_entry *cqe;
3388 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
3389 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
3391 in = mcx_cmdq_in(cqe);
3396 mcx_cmdq_post(sc, cqe, 0);
3398 error = mcx_cmdq_poll(sc, cqe, 1000);
3403 if (mcx_cmdq_verify(cqe) != 0) {
3408 status = cqe->cq_output_data[0];
3438 /* patch the cqe or mbox pointing at this one */
3585 mcx_cmdq_dump(const struct mcx_cmdq_entry *cqe)
3589 printf(" type %02x, ilen %u, iptr %016llx", cqe->cq_type,
3590 be32dec(&cqe->cq_input_length), be64dec(&cqe->cq_input_ptr));
3593 for (i = 0; i < sizeof(cqe->cq_input_data); i++)
3594 printf("%02x", cqe->cq_input_data[i]);
3597 for (i = 0; i < sizeof(cqe->cq_output_data); i++)
3598 printf("%02x", cqe->cq_output_data[i]);
3601 be64dec(&cqe->cq_output_ptr), be32dec(&cqe->cq_output_length),
3602 cqe->cq_token, cqe->cq_signature, cqe->cq_status);
3630 struct mcx_cmdq_entry *cqe;
3636 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
3637 mcx_cmdq_init(sc, cqe, sizeof(*in) + len, sizeof(*out) + len,
3640 in = mcx_cmdq_in(cqe);
3647 &cqe->cq_output_ptr, token) != 0) {
3651 cqe->cq_input_ptr = cqe->cq_output_ptr;
3656 mcx_cmdq_post(sc, cqe, 0);
3657 error = mcx_cmdq_poll(sc, cqe, 1000);
3665 error = mcx_cmdq_verify(cqe);
3673 out = mcx_cmdq_out(cqe);
3690 mcx_set_issi(struct mcx_softc *sc, struct mcx_cmdq_entry *cqe,
3697 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
3699 in = mcx_cmdq_in(cqe);
3704 mcx_cmdq_post(sc, cqe, slot);
3705 if (mcx_cmdq_poll(sc, cqe, 1000) != 0)
3707 if (mcx_cmdq_verify(cqe) != 0)
3710 status = cqe->cq_output_data[0];
3721 struct mcx_cmdq_entry *cqe;
3729 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
3730 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out) + sizeof(*mb), token);
3732 in = mcx_cmdq_in(cqe);
3738 &cqe->cq_output_ptr, token) != 0) {
3744 mcx_cmdq_post(sc, cqe, 0);
3745 error = mcx_cmdq_poll(sc, cqe, 1000);
3750 error = mcx_cmdq_verify(cqe);
3756 status = cqe->cq_output_data[0];
3769 out = mcx_cmdq_out(cqe);
3775 /* don't need to read cqe anymore, can be used for SET ISSI */
3785 if (mcx_set_issi(sc, cqe, 0) != 0) {
3800 struct mcx_cmdq_entry *cqe;
3804 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
3805 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
3807 in = mcx_cmdq_in(cqe);
3811 mcx_cmdq_post(sc, cqe, 0);
3812 if (mcx_cmdq_poll(sc, cqe, 1000) != 0) {
3816 if (mcx_cmdq_verify(cqe) != 0) {
3821 out = mcx_cmdq_out(cqe);
3879 struct mcx_cmdq_entry *cqe;
3894 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
3895 mcx_cmdq_init(sc, cqe, sizeof(*in) + paslen, sizeof(*out), token);
3897 in = mcx_cmdq_in(cqe);
3904 &cqe->cq_input_ptr, token) != 0) {
3926 mcx_cmdq_post(sc, cqe, 0);
3927 error = mcx_cmdq_poll(sc, cqe, 1000);
3932 error = mcx_cmdq_verify(cqe);
3938 status = cqe->cq_output_data[0];
3987 struct mcx_cmdq_entry *cqe;
3996 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
3997 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out) + MCX_HCA_CAP_LEN,
4000 in = mcx_cmdq_in(cqe);
4006 &cqe->cq_output_ptr, token) != 0) {
4013 mcx_cmdq_post(sc, cqe, 0);
4014 error = mcx_cmdq_poll(sc, cqe, 1000);
4021 error = mcx_cmdq_verify(cqe);
4027 status = cqe->cq_output_data[0];
4072 struct mcx_cmdq_entry *cqe;
4081 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4082 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out) + MCX_HCA_CAP_LEN,
4085 in = mcx_cmdq_in(cqe);
4091 &cqe->cq_output_ptr, token) != 0) {
4098 mcx_cmdq_post(sc, cqe, 0);
4099 error = mcx_cmdq_poll(sc, cqe, 1000);
4106 error = mcx_cmdq_verify(cqe);
4112 status = cqe->cq_output_data[0];
4134 struct mcx_cmdq_entry *cqe;
4140 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4141 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
4143 in = mcx_cmdq_in(cqe);
4147 mcx_cmdq_post(sc, cqe, 0);
4149 error = mcx_cmdq_poll(sc, cqe, 1000);
4154 if (mcx_cmdq_verify(cqe) != 0) {
4159 status = cqe->cq_output_data[0];
4172 struct mcx_cmdq_entry *cqe;
4179 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4181 mcx_cmdq_init(sc, cqe, sizeof(*in) +
4184 in = mcx_cmdq_in(cqe);
4189 &cqe->cq_input_ptr, token) != 0) {
4197 mcx_cmdq_post(sc, cqe, 0);
4199 error = mcx_cmdq_poll(sc, cqe, 1000);
4204 if (mcx_cmdq_verify(cqe) != 0) {
4209 status = cqe->cq_output_data[0];
4227 struct mcx_cmdq_entry *cqe;
4269 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4271 mcx_cmdq_init(sc, cqe, sizeof(*in) + insize, sizeof(*out), token);
4273 in = mcx_cmdq_in(cqe);
4280 if (mcx_cmdq_mboxes_alloc(sc, &mxm, 1, &cqe->cq_input_ptr, token) != 0) {
4296 mcx_cmdq_post(sc, cqe, 0);
4298 error = mcx_cmdq_poll(sc, cqe, 1000);
4303 if (mcx_cmdq_verify(cqe) != 0) {
4308 out = mcx_cmdq_out(cqe);
4325 struct mcx_cmdq_entry *cqe;
4330 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4331 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
4333 in = mcx_cmdq_in(cqe);
4337 mcx_cmdq_post(sc, cqe, 0);
4339 error = mcx_cmdq_poll(sc, cqe, 1000);
4344 if (mcx_cmdq_verify(cqe) != 0) {
4349 out = mcx_cmdq_out(cqe);
4363 struct mcx_cmdq_entry *cqe;
4391 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4393 mcx_cmdq_init(sc, cqe, sizeof(*in) + insize, sizeof(*out), token);
4395 in = mcx_cmdq_in(cqe);
4401 &cqe->cq_input_ptr, token) != 0) {
4417 mcx_cmdq_post(sc, cqe, 0);
4419 error = mcx_cmdq_poll(sc, cqe, 1000);
4424 if (mcx_cmdq_verify(cqe) != 0) {
4429 out = mcx_cmdq_out(cqe);
4456 struct mcx_cmdq_entry *cqe;
4461 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4462 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
4464 in = mcx_cmdq_in(cqe);
4468 mcx_cmdq_post(sc, cqe, 0);
4470 error = mcx_cmdq_poll(sc, cqe, 1000);
4475 if (mcx_cmdq_verify(cqe) != 0) {
4480 out = mcx_cmdq_out(cqe);
4493 struct mcx_cmdq_entry *cqe;
4498 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4499 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
4501 in = mcx_cmdq_in(cqe);
4505 mcx_cmdq_post(sc, cqe, 0);
4507 error = mcx_cmdq_poll(sc, cqe, 1000);
4512 if (mcx_cmdq_verify(cqe) != 0) {
4517 out = mcx_cmdq_out(cqe);
4532 struct mcx_cmdq_entry *cqe;
4539 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4541 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out) + sizeof(*ctx), token);
4543 in = mcx_cmdq_in(cqe);
4549 &cqe->cq_output_ptr, token) != 0) {
4555 mcx_cmdq_post(sc, cqe, 0);
4557 error = mcx_cmdq_poll(sc, cqe, 1000);
4562 if (mcx_cmdq_verify(cqe) != 0) {
4567 out = mcx_cmdq_out(cqe);
4590 struct mcx_cmdq_entry *cqe;
4595 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4596 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
4598 in = mcx_cmdq_in(cqe);
4602 mcx_cmdq_post(sc, cqe, 0);
4604 error = mcx_cmdq_poll(sc, cqe, 1000);
4609 if (mcx_cmdq_verify(cqe) != 0) {
4614 out = mcx_cmdq_out(cqe);
4659 struct mcx_cq_entry *cqe;
4681 cqe = MCX_DMA_KVA(&cq->cq_mem);
4683 cqe[i].cq_opcode_owner = MCX_CQ_ENTRY_FLAG_OWNER;
4761 struct mcx_cmdq_entry *cqe;
4767 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4769 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), token);
4771 in = mcx_cmdq_in(cqe);
4776 mcx_cmdq_post(sc, cqe, 0);
4777 error = mcx_cmdq_poll(sc, cqe, 1000);
4782 if (mcx_cmdq_verify(cqe) != 0) {
4787 out = mcx_cmdq_out(cqe);
4811 struct mcx_cmdq_entry *cqe;
4836 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4838 mcx_cmdq_init(sc, cqe, sizeof(*in) + insize, sizeof(*out), token);
4840 in = mcx_cmdq_in(cqe);
4846 &cqe->cq_input_ptr, token) != 0) {
4868 mcx_cmdq_post(sc, cqe, 0);
4870 error = mcx_cmdq_poll(sc, cqe, 1000);
4875 if (mcx_cmdq_verify(cqe) != 0) {
4880 out = mcx_cmdq_out(cqe);
4908 struct mcx_cmdq_entry *cqe;
4916 cqe
4918 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
4921 in = mcx_cmdq_in(cqe);
4927 &cqe->cq_input_ptr, token) != 0) {
4937 mcx_cmdq_post(sc, cqe, 0);
4938 error = mcx_cmdq_poll(sc, cqe, 1000);
4943 if (mcx_cmdq_verify(cqe) != 0) {
4948 out = mcx_cmdq_out(cqe);
4964 struct mcx_cmdq_entry *cqe;
4970 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
4972 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), token);
4974 in = mcx_cmdq_in(cqe);
4979 mcx_cmdq_post(sc, cqe, 0);
4980 error = mcx_cmdq_poll(sc, cqe, 1000);
4985 if (mcx_cmdq_verify(cqe) != 0) {
4990 out = mcx_cmdq_out(cqe);
5011 struct mcx_cmdq_entry *cqe;
5019 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5021 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
5024 in = mcx_cmdq_in(cqe);
5029 &cqe->cq_input_ptr, token) != 0) {
5039 mcx_cmdq_post(sc, cqe, 0);
5040 error = mcx_cmdq_poll(sc, cqe, 1000);
5045 if (mcx_cmdq_verify(cqe) != 0) {
5050 out = mcx_cmdq_out(cqe);
5068 struct mcx_cmdq_entry *cqe;
5076 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5078 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
5081 in = mcx_cmdq_in(cqe);
5086 &cqe->cq_input_ptr, token) != 0) {
5101 mcx_cmdq_post(sc, cqe, 0);
5102 error = mcx_cmdq_poll(sc, cqe, 1000);
5107 if (mcx_cmdq_verify(cqe) != 0) {
5112 out = mcx_cmdq_out(cqe);
5129 struct mcx_cmdq_entry *cqe;
5135 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5137 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), token);
5139 in = mcx_cmdq_in(cqe);
5144 mcx_cmdq_post(sc, cqe, 0);
5145 error = mcx_cmdq_poll(sc, cqe, 1000);
5150 if (mcx_cmdq_verify(cqe) != 0) {
5155 out = mcx_cmdq_out(cqe);
5169 struct mcx_cmdq_entry *cqe;
5193 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5195 mcx_cmdq_init(sc, cqe, sizeof(*in) + insize + paslen, sizeof(*out),
5198 in = mcx_cmdq_in(cqe);
5204 &cqe->cq_input_ptr, token) != 0) {
5230 mcx_cmdq_post(sc, cqe, 0);
5232 error = mcx_cmdq_poll(sc, cqe, 1000);
5237 if (mcx_cmdq_verify(cqe) != 0) {
5242 out = mcx_cmdq_out(cqe);
5271 struct mcx_cmdq_entry *cqe;
5277 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5279 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), token);
5281 in = mcx_cmdq_in(cqe);
5286 mcx_cmdq_post(sc, cqe, 0);
5287 error = mcx_cmdq_poll(sc, cqe, 1000);
5292 if (mcx_cmdq_verify(cqe) != 0) {
5297 out = mcx_cmdq_out(cqe);
5318 struct mcx_cmdq_entry *cqe;
5326 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5328 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
5331 in = mcx_cmdq_in(cqe);
5337 &cqe->cq_input_ptr, token) != 0) {
5347 mcx_cmdq_post(sc, cqe, 0);
5348 error = mcx_cmdq_poll(sc, cqe, 1000);
5353 if (mcx_cmdq_verify(cqe) != 0) {
5358 out = mcx_cmdq_out(cqe);
5374 struct mcx_cmdq_entry *cqe;
5382 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5384 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
5387 in = mcx_cmdq_in(cqe);
5392 &cqe->cq_input_ptr, token) != 0) {
5401 mcx_cmdq_post(sc, cqe, 0);
5402 error = mcx_cmdq_poll(sc, cqe, 1000);
5407 if (mcx_cmdq_verify(cqe) != 0) {
5412 out = mcx_cmdq_out(cqe);
5429 struct mcx_cmdq_entry *cqe;
5435 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5437 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), token);
5439 in = mcx_cmdq_in(cqe);
5444 mcx_cmdq_post(sc, cqe, 0);
5445 error = mcx_cmdq_poll(sc, cqe, 1000);
5450 if (mcx_cmdq_verify(cqe) != 0) {
5455 out = mcx_cmdq_out(cqe);
5468 struct mcx_cmdq_entry *cqe;
5479 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5481 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin) +
5484 in = mcx_cmdq_in(cqe);
5489 &cqe->cq_input_ptr, token) != 0) {
5506 mcx_cmdq_post(sc, cqe, 0);
5507 error = mcx_cmdq_poll(sc, cqe, 1000);
5512 if (mcx_cmdq_verify(cqe) != 0) {
5517 out = mcx_cmdq_out(cqe);
5535 struct mcx_cmdq_entry *cqe;
5541 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5543 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), token);
5545 in = mcx_cmdq_in(cqe);
5550 mcx_cmdq_post(sc, cqe, 0);
5551 error = mcx_cmdq_poll(sc, cqe, 1000);
5556 if (mcx_cmdq_verify(cqe) != 0) {
5561 out = mcx_cmdq_out(cqe);
5575 struct mcx_cmdq_entry *cqe;
5580 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5581 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out), mcx_cmdq_token(sc));
5583 in = mcx_cmdq_in(cqe);
5587 mcx_cmdq_post(sc, cqe, 0);
5589 error = mcx_cmdq_poll(sc, cqe, 1000);
5594 if (mcx_cmdq_verify(cqe) != 0) {
5599 out = (struct mcx_cmd_alloc_flow_counter_out *)cqe->cq_output_data;
5617 struct mcx_cmdq_entry *cqe;
5625 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5627 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
5630 in = mcx_cmdq_in(cqe);
5635 &cqe->cq_input_ptr, token) != 0) {
5646 mcx_cmdq_post(sc, cqe, 0);
5647 error = mcx_cmdq_poll(sc, cqe, 1000);
5652 if (mcx_cmdq_verify(cqe) != 0) {
5657 out = mcx_cmdq_out(cqe);
5674 struct mcx_cmdq_entry *cqe;
5682 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5684 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
5687 in = mcx_cmdq_in(cqe);
5692 &cqe->cq_input_ptr, token) != 0) {
5702 mcx_cmdq_post(sc, cqe, 0);
5703 error = mcx_cmdq_poll(sc, cqe, 1000);
5708 if (mcx_cmdq_verify(cqe) != 0) {
5714 out = mcx_cmdq_out(cqe);
5730 struct mcx_cmdq_entry *cqe;
5738 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5740 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mb), sizeof(*out), token);
5742 in = mcx_cmdq_in(cqe);
5747 &cqe->cq_input_ptr, token) != 0) {
5757 mcx_cmdq_post(sc, cqe, 0);
5758 error = mcx_cmdq_poll(sc, cqe, 1000);
5763 if (mcx_cmdq_verify(cqe) != 0) {
5769 out = mcx_cmdq_out(cqe);
5787 struct mcx_cmdq_entry *cqe;
5796 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5798 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin), sizeof(*out),
5801 in = mcx_cmdq_in(cqe);
5805 if (mcx_cmdq_mboxes_alloc(sc, &mxm, 2, &cqe->cq_input_ptr, token)
5821 mcx_cmdq_post(sc, cqe, 0);
5822 error = mcx_cmdq_poll(sc, cqe, 1000);
5827 if (mcx_cmdq_verify(cqe) != 0) {
5832 out = mcx_cmdq_out(cqe);
5854 struct mcx_cmdq_entry *cqe;
5863 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5865 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mb), sizeof(*out), token);
5867 in = mcx_cmdq_in(cqe);
5872 &cqe->cq_input_ptr, token) != 0) {
5884 mcx_cmdq_post(sc, cqe, 0);
5885 error = mcx_cmdq_poll(sc, cqe, 1000);
5890 if (mcx_cmdq_verify(cqe) != 0) {
5895 out = mcx_cmdq_out(cqe);
5916 struct mcx_cmdq_entry *cqe;
5926 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
5928 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin) + sizeof(*pdest),
5931 in = mcx_cmdq_in(cqe);
5935 if (mcx_cmdq_mboxes_alloc(sc, &mxm, 2, &cqe->cq_input_ptr, token)
5964 mcx_cmdq_post(sc, cqe, 0);
5965 error = mcx_cmdq_poll(sc, cqe, 1000);
5970 if (mcx_cmdq_verify(cqe) != 0) {
5976 out = mcx_cmdq_out(cqe);
5993 struct mcx_cmdq_entry *cqe;
6003 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6005 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin) + sizeof(*pdest),
6008 in = mcx_cmdq_in(cqe);
6012 if (mcx_cmdq_mboxes_alloc(sc, &mxm, 2, &cqe->cq_input_ptr, token)
6038 mcx_cmdq_post(sc, cqe, 0);
6039 error = mcx_cmdq_poll(sc, cqe, 1000);
6044 if (mcx_cmdq_verify(cqe) != 0) {
6050 out = mcx_cmdq_out(cqe);
6066 struct mcx_cmdq_entry *cqe;
6075 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6077 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin), sizeof(*out),
6080 in = mcx_cmdq_in(cqe);
6085 &cqe->cq_input_ptr, token) != 0) {
6098 mcx_cmdq_post(sc, cqe, 0);
6099 error = mcx_cmdq_poll(sc, cqe, 1000);
6104 if (mcx_cmdq_verify(cqe) != 0) {
6110 out = mcx_cmdq_out(cqe);
6129 struct mcx_cmdq_entry *cqe;
6139 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6140 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
6143 in = mcx_cmdq_in(cqe);
6150 &cqe->cq_output_ptr, token) != 0) {
6154 cqe->cq_input_ptr = cqe->cq_output_ptr;
6162 mcx_cmdq_post(sc, cqe, 0);
6163 error = mcx_cmdq_poll(sc, cqe, 1000);
6168 error = mcx_cmdq_verify(cqe);
6174 out = mcx_cmdq_out(cqe);
6201 struct mcx_cmdq_entry *cqe;
6211 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6212 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
6215 in = mcx_cmdq_in(cqe);
6222 &cqe->cq_output_ptr, token) != 0) {
6227 cqe->cq_input_ptr = cqe->cq_output_ptr;
6236 mcx_cmdq_post(sc, cqe, 0);
6237 error = mcx_cmdq_poll(sc, cqe, 1000);
6242 error = mcx_cmdq_verify(cqe);
6249 out = mcx_cmdq_out(cqe);
6278 struct mcx_cmdq_entry *cqe;
6288 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6289 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
6292 in = mcx_cmdq_in(cqe);
6299 &cqe->cq_output_ptr, token) != 0) {
6303 cqe->cq_input_ptr = cqe->cq_output_ptr;
6312 mcx_cmdq_post(sc, cqe, 0);
6313 error = mcx_cmdq_poll(sc, cqe, 1000);
6318 error = mcx_cmdq_verify(cqe);
6324 out = mcx_cmdq_out(cqe);
6359 struct mcx_cmdq_entry *cqe;
6366 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6368 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin),
6371 in = mcx_cmdq_in(cqe);
6376 &cqe->cq_output_ptr, token) != 0) {
6381 cqe->cq_input_ptr = cqe->cq_output_ptr;
6387 mcx_cmdq_post(sc, cqe, 0);
6389 error = mcx_cmdq_poll(sc, cqe, 1000);
6394 if (mcx_cmdq_verify(cqe) != 0) {
6400 out = mcx_cmdq_out(cqe);
6431 struct mcx_cmdq_entry *cqe;
6438 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6440 mcx_cmdq_init(sc, cqe, sizeof(*in) + sizeof(*mbin), sizeof(*out) +
6443 in = mcx_cmdq_in(cqe);
6448 &cqe->cq_output_ptr, token) != 0) {
6452 cqe->cq_input_ptr = cqe->cq_output_ptr;
6458 mcx_cmdq_post(sc, cqe, 0);
6460 error = mcx_cmdq_poll(sc, cqe, 1000);
6465 if (mcx_cmdq_verify(cqe) != 0) {
6470 out = mcx_cmdq_out(cqe);
6497 struct mcx_cmdq_entry *cqe;
6504 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6505 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out) + sizeof(*mbout) + 16,
6508 in = mcx_cmdq_in(cqe);
6515 &cqe->cq_output_ptr, token) != 0) {
6522 mcx_cmdq_post(sc, cqe, 0);
6523 error = mcx_cmdq_poll(sc, cqe, 1000);
6528 error = mcx_cmdq_verify(cqe);
6534 out = mcx_cmdq_out(cqe);
6558 struct mcx_cmdq_entry *cqe;
6565 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6566 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out) + sizeof(*mbout) + 16,
6569 in = mcx_cmdq_in(cqe);
6576 &cqe->cq_output_ptr, token) != 0) {
6583 mcx_cmdq_post(sc, cqe, 0);
6584 error = mcx_cmdq_poll(sc, cqe, 1000);
6589 error = mcx_cmdq_verify(cqe);
6595 out = mcx_cmdq_out(cqe);
6619 struct mcx_cmdq_entry *cqe;
6626 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6627 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out) + sizeof(*ctx) + 16,
6630 in = mcx_cmdq_in(cqe);
6637 &cqe->cq_output_ptr, token) != 0) {
6645 mcx_cmdq_post(sc, cqe, 0);
6646 error = mcx_cmdq_poll(sc, cqe, 1000);
6651 if (mcx_cmdq_verify(cqe) != 0) {
6656 out = mcx_cmdq_out(cqe);
6678 struct mcx_cmdq_entry *cqe;
6685 cqe = MCX_DMA_KVA(&sc->sc_cmdq_mem);
6686 mcx_cmdq_init(sc, cqe, sizeof(*in), sizeof(*out) + sizeof(*ctx) + 16,
6689 in = mcx_cmdq_in(cqe);
6696 &cqe->cq_output_ptr, token) != 0) {
6704 mcx_cmdq_post(sc, cqe, 0);
6705 error = mcx_cmdq_poll(sc, cqe, 1000);
6710 if (mcx_cmdq_verify(cqe) != 0) {
6715 out = mcx_cmdq_out(cqe);
6831 struct mcx_cq_entry *cqe)
6837 slot = be16toh(cqe->cq_wqe_count) % (1 << MCX_LOG_SQ_SIZE);
6933 struct mcx_cq_entry *cqe, struct mcx_mbufq *mq,
6942 len = be32dec(&cqe->cq_byte_cnt);
6943 slot = be16toh(cqe->cq_wqe_count) % (1 << MCX_LOG_RQ_SIZE);
6956 if (cqe->cq_rx_hash_type) {
6957 m->m_pkthdr.ph_flowid = be32toh(cqe->cq_rx_hash);
6962 flags = be32dec(&cqe->cq_flags);
6983 uint64_t t = be64dec(&cqe->cq_timestamp);
7002 struct mcx_cq_entry *cqe;
7005 cqe = (struct mcx_cq_entry *)MCX_DMA_KVA(&cq->cq_mem);
7008 if ((cqe[next].cq_opcode_owner & MCX_CQ_ENTRY_FLAG_OWNER) ==
7010 return (&cqe[next]);
7055 struct mcx_cq_entry *cqe;
7071 while ((cqe = mcx_next_cq_entry(sc, cq))) {
7073 opcode = (cqe->cq_opcode_owner >> MCX_CQ_ENTRY_OPCODE_SHIFT);
7076 txfree += mcx_process_txeof(sc, tx, cqe);
7079 rxfree += mcx_process_rx(sc, rx, cqe, &mq, c);
7083 /* uint8_t *cqp = (uint8_t *)cqe; */
Indexes created Wed Oct 01 07:09:59 GMT 2025