tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

{net,IB}/mlx5: MKey/PSV commands via mlx5 ifc

Remove old representation of manually created MKey/PSV commands layout,
and use mlx5_ifc canonical structures and defines.

Signed-off-by: Saeed Mahameed <saeedm@mellanox.com>
Signed-off-by: Leon Romanovsky <leon@kernel.org>

authored by

Saeed Mahameed and committed by
Leon Romanovsky ec22eb53 27827786

+235 -332
+1 -1
drivers/infiniband/hw/mlx5/mlx5_ib.h
··· 504 504 int umred; 505 505 int npages; 506 506 struct mlx5_ib_dev *dev; 507 - struct mlx5_create_mkey_mbox_out out; 507 + u32 out[MLX5_ST_SZ_DW(create_mkey_out)]; 508 508 struct mlx5_core_sig_ctx *sig; 509 509 int live; 510 510 void *descs_alloc;
+102 -80
drivers/infiniband/hw/mlx5/mr.c
··· 135 135 return; 136 136 } 137 137 138 - if (mr->out.hdr.status) { 139 - mlx5_ib_warn(dev, "failed - status %d, syndorme 0x%x\n", 140 - mr->out.hdr.status, 141 - be32_to_cpu(mr->out.hdr.syndrome)); 142 - kfree(mr); 143 - dev->fill_delay = 1; 144 - mod_timer(&dev->delay_timer, jiffies + HZ); 145 - return; 146 - } 147 - 148 138 spin_lock_irqsave(&dev->mdev->priv.mkey_lock, flags); 149 139 key = dev->mdev->priv.mkey_key++; 150 140 spin_unlock_irqrestore(&dev->mdev->priv.mkey_lock, flags); 151 - mr->mmkey.key = mlx5_idx_to_mkey(be32_to_cpu(mr->out.mkey) & 0xffffff) | key; 141 + mr->mmkey.key = mlx5_idx_to_mkey(MLX5_GET(create_mkey_out, mr->out, mkey_index)) | key; 152 142 153 143 cache->last_add = jiffies; 154 144 ··· 160 170 { 161 171 struct mlx5_mr_cache *cache = &dev->cache; 162 172 struct mlx5_cache_ent *ent = &cache->ent[c]; 163 - struct mlx5_create_mkey_mbox_in *in; 173 + int inlen = MLX5_ST_SZ_BYTES(create_mkey_in); 164 174 struct mlx5_ib_mr *mr; 165 175 int npages = 1 << ent->order; 176 + void *mkc; 177 + u32 *in; 166 178 int err = 0; 167 179 int i; 168 180 169 - in = kzalloc(sizeof(*in), GFP_KERNEL); 181 + in = kzalloc(inlen, GFP_KERNEL); 170 182 if (!in) 171 183 return -ENOMEM; 172 184 185 + mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry); 173 186 for (i = 0; i < num; i++) { 174 187 if (ent->pending >= MAX_PENDING_REG_MR) { 175 188 err = -EAGAIN; ··· 187 194 mr->order = ent->order; 188 195 mr->umred = 1; 189 196 mr->dev = dev; 190 - in->seg.status = MLX5_MKEY_STATUS_FREE; 191 - in->seg.xlt_oct_size = cpu_to_be32((npages + 1) / 2); 192 - in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); 193 - in->seg.flags = MLX5_ACCESS_MODE_MTT | MLX5_PERM_UMR_EN; 194 - in->seg.log2_page_size = 12; 197 + 198 + MLX5_SET(mkc, mkc, free, 1); 199 + MLX5_SET(mkc, mkc, umr_en, 1); 200 + MLX5_SET(mkc, mkc, access_mode, MLX5_MKC_ACCESS_MODE_MTT); 201 + 202 + MLX5_SET(mkc, mkc, qpn, 0xffffff); 203 + MLX5_SET(mkc, mkc, translations_octword_size, (npages + 1) / 2); 204 + MLX5_SET(mkc, mkc, log_page_size, 12); 195 205 196 206 spin_lock_irq(&ent->lock); 197 207 ent->pending++; 198 208 spin_unlock_irq(&ent->lock); 199 - err = mlx5_core_create_mkey(dev->mdev, &mr->mmkey, in, 200 - sizeof(*in), reg_mr_callback, 201 - mr, &mr->out); 209 + err = mlx5_core_create_mkey_cb(dev->mdev, &mr->mmkey, 210 + in, inlen, 211 + mr->out, sizeof(mr->out), 212 + reg_mr_callback, mr); 202 213 if (err) { 203 214 spin_lock_irq(&ent->lock); 204 215 ent->pending--; ··· 667 670 struct ib_mr *mlx5_ib_get_dma_mr(struct ib_pd *pd, int acc) 668 671 { 669 672 struct mlx5_ib_dev *dev = to_mdev(pd->device); 673 + int inlen = MLX5_ST_SZ_BYTES(create_mkey_in); 670 674 struct mlx5_core_dev *mdev = dev->mdev; 671 - struct mlx5_create_mkey_mbox_in *in; 672 - struct mlx5_mkey_seg *seg; 673 675 struct mlx5_ib_mr *mr; 676 + void *mkc; 677 + u32 *in; 674 678 int err; 675 679 676 680 mr = kzalloc(sizeof(*mr), GFP_KERNEL); 677 681 if (!mr) 678 682 return ERR_PTR(-ENOMEM); 679 683 680 - in = kzalloc(sizeof(*in), GFP_KERNEL); 684 + in = kzalloc(inlen, GFP_KERNEL); 681 685 if (!in) { 682 686 err = -ENOMEM; 683 687 goto err_free; 684 688 } 685 689 686 - seg = &in->seg; 687 - seg->flags = convert_access(acc) | MLX5_ACCESS_MODE_PA; 688 - seg->flags_pd = cpu_to_be32(to_mpd(pd)->pdn | MLX5_MKEY_LEN64); 689 - seg->qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); 690 - seg->start_addr = 0; 690 + mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry); 691 691 692 - err = mlx5_core_create_mkey(mdev, &mr->mmkey, in, sizeof(*in), NULL, NULL, 693 - NULL); 692 + MLX5_SET(mkc, mkc, access_mode, MLX5_MKC_ACCESS_MODE_PA); 693 + MLX5_SET(mkc, mkc, a, !!(acc & IB_ACCESS_REMOTE_ATOMIC)); 694 + MLX5_SET(mkc, mkc, rw, !!(acc & IB_ACCESS_REMOTE_WRITE)); 695 + MLX5_SET(mkc, mkc, rr, !!(acc & IB_ACCESS_REMOTE_READ)); 696 + MLX5_SET(mkc, mkc, lw, !!(acc & IB_ACCESS_LOCAL_WRITE)); 697 + MLX5_SET(mkc, mkc, lr, 1); 698 + 699 + MLX5_SET(mkc, mkc, length64, 1); 700 + MLX5_SET(mkc, mkc, pd, to_mpd(pd)->pdn); 701 + MLX5_SET(mkc, mkc, qpn, 0xffffff); 702 + MLX5_SET64(mkc, mkc, start_addr, 0); 703 + 704 + err = mlx5_core_create_mkey(mdev, &mr->mmkey, in, inlen); 694 705 if (err) 695 706 goto err_in; 696 707 ··· 1068 1063 int page_shift, int access_flags) 1069 1064 { 1070 1065 struct mlx5_ib_dev *dev = to_mdev(pd->device); 1071 - struct mlx5_create_mkey_mbox_in *in; 1072 1066 struct mlx5_ib_mr *mr; 1067 + __be64 *pas; 1068 + void *mkc; 1073 1069 int inlen; 1070 + u32 *in; 1074 1071 int err; 1075 1072 bool pg_cap = !!(MLX5_CAP_GEN(dev->mdev, pg)); 1076 1073 ··· 1080 1073 if (!mr) 1081 1074 return ERR_PTR(-ENOMEM); 1082 1075 1083 - inlen = sizeof(*in) + sizeof(*in->pas) * ((npages + 1) / 2) * 2; 1076 + inlen = MLX5_ST_SZ_BYTES(create_mkey_in) + 1077 + sizeof(*pas) * ((npages + 1) / 2) * 2; 1084 1078 in = mlx5_vzalloc(inlen); 1085 1079 if (!in) { 1086 1080 err = -ENOMEM; 1087 1081 goto err_1; 1088 1082 } 1089 - mlx5_ib_populate_pas(dev, umem, page_shift, in->pas, 1083 + pas = (__be64 *)MLX5_ADDR_OF(create_mkey_in, in, klm_pas_mtt); 1084 + mlx5_ib_populate_pas(dev, umem, page_shift, pas, 1090 1085 pg_cap ? MLX5_IB_MTT_PRESENT : 0); 1091 1086 1092 - /* The MLX5_MKEY_INBOX_PG_ACCESS bit allows setting the access flags 1087 + /* The pg_access bit allows setting the access flags 1093 1088 * in the page list submitted with the command. */ 1094 - in->flags = pg_cap ? cpu_to_be32(MLX5_MKEY_INBOX_PG_ACCESS) : 0; 1095 - in->seg.flags = convert_access(access_flags) | 1096 - MLX5_ACCESS_MODE_MTT; 1097 - in->seg.flags_pd = cpu_to_be32(to_mpd(pd)->pdn); 1098 - in->seg.start_addr = cpu_to_be64(virt_addr); 1099 - in->seg.len = cpu_to_be64(length); 1100 - in->seg.bsfs_octo_size = 0; 1101 - in->seg.xlt_oct_size = cpu_to_be32(get_octo_len(virt_addr, length, 1 << page_shift)); 1102 - in->seg.log2_page_size = page_shift; 1103 - in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); 1104 - in->xlat_oct_act_size = cpu_to_be32(get_octo_len(virt_addr, length, 1105 - 1 << page_shift)); 1106 - err = mlx5_core_create_mkey(dev->mdev, &mr->mmkey, in, inlen, NULL, 1107 - NULL, NULL); 1089 + MLX5_SET(create_mkey_in, in, pg_access, !!(pg_cap)); 1090 + 1091 + mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry); 1092 + MLX5_SET(mkc, mkc, access_mode, MLX5_MKC_ACCESS_MODE_MTT); 1093 + MLX5_SET(mkc, mkc, a, !!(access_flags & IB_ACCESS_REMOTE_ATOMIC)); 1094 + MLX5_SET(mkc, mkc, rw, !!(access_flags & IB_ACCESS_REMOTE_WRITE)); 1095 + MLX5_SET(mkc, mkc, rr, !!(access_flags & IB_ACCESS_REMOTE_READ)); 1096 + MLX5_SET(mkc, mkc, lw, !!(access_flags & IB_ACCESS_LOCAL_WRITE)); 1097 + MLX5_SET(mkc, mkc, lr, 1); 1098 + 1099 + MLX5_SET64(mkc, mkc, start_addr, virt_addr); 1100 + MLX5_SET64(mkc, mkc, len, length); 1101 + MLX5_SET(mkc, mkc, pd, to_mpd(pd)->pdn); 1102 + MLX5_SET(mkc, mkc, bsf_octword_size, 0); 1103 + MLX5_SET(mkc, mkc, translations_octword_size, 1104 + get_octo_len(virt_addr, length, 1 << page_shift)); 1105 + MLX5_SET(mkc, mkc, log_page_size, page_shift); 1106 + MLX5_SET(mkc, mkc, qpn, 0xffffff); 1107 + MLX5_SET(create_mkey_in, in, translations_octword_actual_size, 1108 + get_octo_len(virt_addr, length, 1 << page_shift)); 1109 + 1110 + err = mlx5_core_create_mkey(dev->mdev, &mr->mmkey, in, inlen); 1108 1111 if (err) { 1109 1112 mlx5_ib_warn(dev, "create mkey failed\n"); 1110 1113 goto err_2; ··· 1540 1523 u32 max_num_sg) 1541 1524 { 1542 1525 struct mlx5_ib_dev *dev = to_mdev(pd->device); 1543 - struct mlx5_create_mkey_mbox_in *in; 1544 - struct mlx5_ib_mr *mr; 1526 + int inlen = MLX5_ST_SZ_BYTES(create_mkey_in); 1545 1527 int ndescs = ALIGN(max_num_sg, 4); 1528 + struct mlx5_ib_mr *mr; 1529 + void *mkc; 1530 + u32 *in; 1546 1531 int err; 1547 1532 1548 1533 mr = kzalloc(sizeof(*mr), GFP_KERNEL); 1549 1534 if (!mr) 1550 1535 return ERR_PTR(-ENOMEM); 1551 1536 1552 - in = kzalloc(sizeof(*in), GFP_KERNEL); 1537 + in = kzalloc(inlen, GFP_KERNEL); 1553 1538 if (!in) { 1554 1539 err = -ENOMEM; 1555 1540 goto err_free; 1556 1541 } 1557 1542 1558 - in->seg.status = MLX5_MKEY_STATUS_FREE; 1559 - in->seg.xlt_oct_size = cpu_to_be32(ndescs); 1560 - in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); 1561 - in->seg.flags_pd = cpu_to_be32(to_mpd(pd)->pdn); 1543 + mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry); 1544 + MLX5_SET(mkc, mkc, free, 1); 1545 + MLX5_SET(mkc, mkc, translations_octword_size, ndescs); 1546 + MLX5_SET(mkc, mkc, qpn, 0xffffff); 1547 + MLX5_SET(mkc, mkc, pd, to_mpd(pd)->pdn); 1562 1548 1563 1549 if (mr_type == IB_MR_TYPE_MEM_REG) { 1564 - mr->access_mode = MLX5_ACCESS_MODE_MTT; 1565 - in->seg.log2_page_size = PAGE_SHIFT; 1566 - 1550 + mr->access_mode = MLX5_MKC_ACCESS_MODE_MTT; 1551 + MLX5_SET(mkc, mkc, log_page_size, PAGE_SHIFT); 1567 1552 err = mlx5_alloc_priv_descs(pd->device, mr, 1568 1553 ndescs, sizeof(u64)); 1569 1554 if (err) ··· 1574 1555 mr->desc_size = sizeof(u64); 1575 1556 mr->max_descs = ndescs; 1576 1557 } else if (mr_type == IB_MR_TYPE_SG_GAPS) { 1577 - mr->access_mode = MLX5_ACCESS_MODE_KLM; 1558 + mr->access_mode = MLX5_MKC_ACCESS_MODE_KLMS; 1578 1559 1579 1560 err = mlx5_alloc_priv_descs(pd->device, mr, 1580 1561 ndescs, sizeof(struct mlx5_klm)); ··· 1585 1566 } else if (mr_type == IB_MR_TYPE_SIGNATURE) { 1586 1567 u32 psv_index[2]; 1587 1568 1588 - in->seg.flags_pd = cpu_to_be32(be32_to_cpu(in->seg.flags_pd) | 1589 - MLX5_MKEY_BSF_EN); 1590 - in->seg.bsfs_octo_size = cpu_to_be32(MLX5_MKEY_BSF_OCTO_SIZE); 1569 + MLX5_SET(mkc, mkc, bsf_en, 1); 1570 + MLX5_SET(mkc, mkc, bsf_octword_size, MLX5_MKEY_BSF_OCTO_SIZE); 1591 1571 mr->sig = kzalloc(sizeof(*mr->sig), GFP_KERNEL); 1592 1572 if (!mr->sig) { 1593 1573 err = -ENOMEM; ··· 1599 1581 if (err) 1600 1582 goto err_free_sig; 1601 1583 1602 - mr->access_mode = MLX5_ACCESS_MODE_KLM; 1584 + mr->access_mode = MLX5_MKC_ACCESS_MODE_KLMS; 1603 1585 mr->sig->psv_memory.psv_idx = psv_index[0]; 1604 1586 mr->sig->psv_wire.psv_idx = psv_index[1]; 1605 1587 ··· 1613 1595 goto err_free_in; 1614 1596 } 1615 1597 1616 - in->seg.flags = MLX5_PERM_UMR_EN | mr->access_mode; 1617 - err = mlx5_core_create_mkey(dev->mdev, &mr->mmkey, in, sizeof(*in), 1618 - NULL, NULL, NULL); 1598 + MLX5_SET(mkc, mkc, access_mode, mr->access_mode); 1599 + MLX5_SET(mkc, mkc, umr_en, 1); 1600 + 1601 + err = mlx5_core_create_mkey(dev->mdev, &mr->mmkey, in, inlen); 1619 1602 if (err) 1620 1603 goto err_destroy_psv; 1621 1604 ··· 1652 1633 struct ib_udata *udata) 1653 1634 { 1654 1635 struct mlx5_ib_dev *dev = to_mdev(pd->device); 1655 - struct mlx5_create_mkey_mbox_in *in = NULL; 1636 + int inlen = MLX5_ST_SZ_BYTES(create_mkey_in); 1656 1637 struct mlx5_ib_mw *mw = NULL; 1638 + u32 *in = NULL; 1639 + void *mkc; 1657 1640 int ndescs; 1658 1641 int err; 1659 1642 struct mlx5_ib_alloc_mw req = {}; ··· 1679 1658 ndescs = req.num_klms ? roundup(req.num_klms, 4) : roundup(1, 4); 1680 1659 1681 1660 mw = kzalloc(sizeof(*mw), GFP_KERNEL); 1682 - in = kzalloc(sizeof(*in), GFP_KERNEL); 1661 + in = kzalloc(inlen, GFP_KERNEL); 1683 1662 if (!mw || !in) { 1684 1663 err = -ENOMEM; 1685 1664 goto free; 1686 1665 } 1687 1666 1688 - in->seg.status = MLX5_MKEY_STATUS_FREE; 1689 - in->seg.xlt_oct_size = cpu_to_be32(ndescs); 1690 - in->seg.flags_pd = cpu_to_be32(to_mpd(pd)->pdn); 1691 - in->seg.flags = MLX5_PERM_UMR_EN | MLX5_ACCESS_MODE_KLM | 1692 - MLX5_PERM_LOCAL_READ; 1693 - if (type == IB_MW_TYPE_2) 1694 - in->seg.flags_pd |= cpu_to_be32(MLX5_MKEY_REMOTE_INVAL); 1695 - in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); 1667 + mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry); 1696 1668 1697 - err = mlx5_core_create_mkey(dev->mdev, &mw->mmkey, in, sizeof(*in), 1698 - NULL, NULL, NULL); 1669 + MLX5_SET(mkc, mkc, free, 1); 1670 + MLX5_SET(mkc, mkc, translations_octword_size, ndescs); 1671 + MLX5_SET(mkc, mkc, pd, to_mpd(pd)->pdn); 1672 + MLX5_SET(mkc, mkc, umr_en, 1); 1673 + MLX5_SET(mkc, mkc, lr, 1); 1674 + MLX5_SET(mkc, mkc, access_mode, MLX5_MKC_ACCESS_MODE_KLMS); 1675 + MLX5_SET(mkc, mkc, en_rinval, !!((type == IB_MW_TYPE_2))); 1676 + MLX5_SET(mkc, mkc, qpn, 0xffffff); 1677 + 1678 + err = mlx5_core_create_mkey(dev->mdev, &mw->mmkey, in, inlen); 1699 1679 if (err) 1700 1680 goto free; 1701 1681 ··· 1833 1811 mr->desc_size * mr->max_descs, 1834 1812 DMA_TO_DEVICE); 1835 1813 1836 - if (mr->access_mode == MLX5_ACCESS_MODE_KLM) 1814 + if (mr->access_mode == MLX5_MKC_ACCESS_MODE_KLMS) 1837 1815 n = mlx5_ib_sg_to_klms(mr, sg, sg_nents, sg_offset); 1838 1816 else 1839 1817 n = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset,
+4 -4
drivers/infiniband/hw/mlx5/qp.c
··· 2968 2968 2969 2969 memset(umr, 0, sizeof(*umr)); 2970 2970 2971 - if (mr->access_mode == MLX5_ACCESS_MODE_KLM) 2971 + if (mr->access_mode == MLX5_MKC_ACCESS_MODE_KLMS) 2972 2972 /* KLMs take twice the size of MTTs */ 2973 2973 ndescs *= 2; 2974 2974 ··· 3111 3111 3112 3112 memset(seg, 0, sizeof(*seg)); 3113 3113 3114 - if (mr->access_mode == MLX5_ACCESS_MODE_MTT) 3114 + if (mr->access_mode == MLX5_MKC_ACCESS_MODE_MTT) 3115 3115 seg->log2_page_size = ilog2(mr->ibmr.page_size); 3116 - else if (mr->access_mode == MLX5_ACCESS_MODE_KLM) 3116 + else if (mr->access_mode == MLX5_MKC_ACCESS_MODE_KLMS) 3117 3117 /* KLMs take twice the size of MTTs */ 3118 3118 ndescs *= 2; 3119 3119 ··· 3454 3454 memset(seg, 0, sizeof(*seg)); 3455 3455 3456 3456 seg->flags = get_umr_flags(wr->access_flags) | 3457 - MLX5_ACCESS_MODE_KLM; 3457 + MLX5_MKC_ACCESS_MODE_KLMS; 3458 3458 seg->qpn_mkey7_0 = cpu_to_be32((sig_key & 0xff) | 0xffffff00); 3459 3459 seg->flags_pd = cpu_to_be32(MLX5_MKEY_REMOTE_INVAL | sigerr << 26 | 3460 3460 MLX5_MKEY_BSF_EN | pdn);
+3 -1
drivers/net/ethernet/mellanox/mlx5/core/cmd.c
··· 1301 1301 callback = ent->callback; 1302 1302 context = ent->context; 1303 1303 err = ent->ret; 1304 - if (!err) 1304 + if (!err) { 1305 1305 err = mlx5_copy_from_msg(ent->uout, 1306 1306 ent->out, 1307 1307 ent->uout_size); 1308 + err = err ? err : mlx5_cmd_status_to_err_v2(ent->uout); 1309 + } 1308 1310 1309 1311 mlx5_free_cmd_msg(dev, ent->out); 1310 1312 free_msg(dev, ent->in);
+13 -10
drivers/net/ethernet/mellanox/mlx5/core/en_common.c
··· 60 60 static int mlx5e_create_mkey(struct mlx5_core_dev *mdev, u32 pdn, 61 61 struct mlx5_core_mkey *mkey) 62 62 { 63 - struct mlx5_create_mkey_mbox_in *in; 63 + int inlen = MLX5_ST_SZ_BYTES(create_mkey_in); 64 + void *mkc; 65 + u32 *in; 64 66 int err; 65 67 66 - in = mlx5_vzalloc(sizeof(*in)); 68 + in = mlx5_vzalloc(inlen); 67 69 if (!in) 68 70 return -ENOMEM; 69 71 70 - in->seg.flags = MLX5_PERM_LOCAL_WRITE | 71 - MLX5_PERM_LOCAL_READ | 72 - MLX5_ACCESS_MODE_PA; 73 - in->seg.flags_pd = cpu_to_be32(pdn | MLX5_MKEY_LEN64); 74 - in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); 72 + mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry); 73 + MLX5_SET(mkc, mkc, access_mode, MLX5_MKC_ACCESS_MODE_PA); 74 + MLX5_SET(mkc, mkc, lw, 1); 75 + MLX5_SET(mkc, mkc, lr, 1); 75 76 76 - err = mlx5_core_create_mkey(mdev, mkey, in, sizeof(*in), NULL, NULL, 77 - NULL); 77 + MLX5_SET(mkc, mkc, pd, pdn); 78 + MLX5_SET(mkc, mkc, length64, 1); 79 + MLX5_SET(mkc, mkc, qpn, 0xffffff); 80 + 81 + err = mlx5_core_create_mkey(mdev, mkey, in, inlen); 78 82 79 83 kvfree(in); 80 - 81 84 return err; 82 85 } 83 86
+18 -19
drivers/net/ethernet/mellanox/mlx5/core/en_main.c
··· 3228 3228 static int mlx5e_create_umr_mkey(struct mlx5e_priv *priv) 3229 3229 { 3230 3230 struct mlx5_core_dev *mdev = priv->mdev; 3231 - struct mlx5_create_mkey_mbox_in *in; 3232 - struct mlx5_mkey_seg *mkc; 3233 - int inlen = sizeof(*in); 3234 - u64 npages = 3235 - priv->profile->max_nch(mdev) * MLX5_CHANNEL_MAX_NUM_MTTS; 3231 + u64 npages = priv->profile->max_nch(mdev) * MLX5_CHANNEL_MAX_NUM_MTTS; 3232 + int inlen = MLX5_ST_SZ_BYTES(create_mkey_in); 3233 + void *mkc; 3234 + u32 *in; 3236 3235 int err; 3237 3236 3238 3237 in = mlx5_vzalloc(inlen); 3239 3238 if (!in) 3240 3239 return -ENOMEM; 3241 3240 3242 - mkc = &in->seg; 3243 - mkc->status = MLX5_MKEY_STATUS_FREE; 3244 - mkc->flags = MLX5_PERM_UMR_EN | 3245 - MLX5_PERM_LOCAL_READ | 3246 - MLX5_PERM_LOCAL_WRITE | 3247 - MLX5_ACCESS_MODE_MTT; 3241 + mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry); 3248 3242 3249 - mkc->qpn_mkey7_0 = cpu_to_be32(0xffffff << 8); 3250 - mkc->flags_pd = cpu_to_be32(mdev->mlx5e_res.pdn); 3251 - mkc->len = cpu_to_be64(npages << PAGE_SHIFT); 3252 - mkc->xlt_oct_size = cpu_to_be32(mlx5e_get_mtt_octw(npages)); 3253 - mkc->log2_page_size = PAGE_SHIFT; 3243 + MLX5_SET(mkc, mkc, free, 1); 3244 + MLX5_SET(mkc, mkc, umr_en, 1); 3245 + MLX5_SET(mkc, mkc, lw, 1); 3246 + MLX5_SET(mkc, mkc, lr, 1); 3247 + MLX5_SET(mkc, mkc, access_mode, MLX5_MKC_ACCESS_MODE_MTT); 3254 3248 3255 - err = mlx5_core_create_mkey(mdev, &priv->umr_mkey, in, inlen, NULL, 3256 - NULL, NULL); 3249 + MLX5_SET(mkc, mkc, qpn, 0xffffff); 3250 + MLX5_SET(mkc, mkc, pd, mdev->mlx5e_res.pdn); 3251 + MLX5_SET64(mkc, mkc, len, npages << PAGE_SHIFT); 3252 + MLX5_SET(mkc, mkc, translations_octword_size, 3253 + mlx5e_get_mtt_octw(npages)); 3254 + MLX5_SET(mkc, mkc, log_page_size, PAGE_SHIFT); 3255 + 3256 + err = mlx5_core_create_mkey(mdev, &priv->umr_mkey, in, inlen); 3257 3257 3258 3258 kvfree(in); 3259 - 3260 3259 return err; 3261 3260 } 3262 3261
+79 -106
drivers/net/ethernet/mellanox/mlx5/core/mr.c
··· 49 49 { 50 50 } 51 51 52 - int mlx5_core_create_mkey(struct mlx5_core_dev *dev, 53 - struct mlx5_core_mkey *mkey, 54 - struct mlx5_create_mkey_mbox_in *in, int inlen, 55 - mlx5_cmd_cbk_t callback, void *context, 56 - struct mlx5_create_mkey_mbox_out *out) 52 + int mlx5_core_create_mkey_cb(struct mlx5_core_dev *dev, 53 + struct mlx5_core_mkey *mkey, 54 + u32 *in, int inlen, 55 + u32 *out, int outlen, 56 + mlx5_cmd_cbk_t callback, void *context) 57 57 { 58 58 struct mlx5_mkey_table *table = &dev->priv.mkey_table; 59 - struct mlx5_create_mkey_mbox_out lout; 59 + u32 lout[MLX5_ST_SZ_DW(create_mkey_out)] = {0}; 60 + u32 mkey_index; 61 + void *mkc; 60 62 int err; 61 63 u8 key; 62 64 63 - memset(&lout, 0, sizeof(lout)); 64 65 spin_lock_irq(&dev->priv.mkey_lock); 65 66 key = dev->priv.mkey_key++; 66 67 spin_unlock_irq(&dev->priv.mkey_lock); 67 - in->seg.qpn_mkey7_0 |= cpu_to_be32(key); 68 - in->hdr.opcode = cpu_to_be16(MLX5_CMD_OP_CREATE_MKEY); 69 - if (callback) { 70 - err = mlx5_cmd_exec_cb(dev, in, inlen, out, sizeof(*out), 71 - callback, context); 68 + mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry); 69 + 70 + MLX5_SET(create_mkey_in, in, opcode, MLX5_CMD_OP_CREATE_MKEY); 71 + MLX5_SET(mkc, mkc, mkey_7_0, key); 72 + 73 + if (callback) 74 + return mlx5_cmd_exec_cb(dev, in, inlen, out, outlen, 75 + callback, context); 76 + 77 + err = mlx5_cmd_exec(dev, in, inlen, lout, sizeof(lout)); 78 + err = err ? : mlx5_cmd_status_to_err_v2(lout); 79 + if (err) 72 80 return err; 73 - } else { 74 - err = mlx5_cmd_exec(dev, in, inlen, &lout, sizeof(lout)); 75 - } 76 81 77 - if (err) { 78 - mlx5_core_dbg(dev, "cmd exec failed %d\n", err); 79 - return err; 80 - } 81 - 82 - if (lout.hdr.status) { 83 - mlx5_core_dbg(dev, "status %d\n", lout.hdr.status); 84 - return mlx5_cmd_status_to_err(&lout.hdr); 85 - } 86 - 87 - mkey->iova = be64_to_cpu(in->seg.start_addr); 88 - mkey->size = be64_to_cpu(in->seg.len); 89 - mkey->key = mlx5_idx_to_mkey(be32_to_cpu(lout.mkey) & 0xffffff) | key; 90 - mkey->pd = be32_to_cpu(in->seg.flags_pd) & 0xffffff; 82 + mkey_index = MLX5_GET(create_mkey_out, lout, mkey_index); 83 + mkey->iova = MLX5_GET64(mkc, mkc, start_addr); 84 + mkey->size = MLX5_GET64(mkc, mkc, len); 85 + mkey->key = mlx5_idx_to_mkey(mkey_index) | key; 86 + mkey->pd = MLX5_GET(mkc, mkc, pd); 91 87 92 88 mlx5_core_dbg(dev, "out 0x%x, key 0x%x, mkey 0x%x\n", 93 - be32_to_cpu(lout.mkey), key, mkey->key); 89 + mkey_index, key, mkey->key); 94 90 95 91 /* connect to mkey tree */ 96 92 write_lock_irq(&table->lock); ··· 100 104 101 105 return err; 102 106 } 107 + EXPORT_SYMBOL(mlx5_core_create_mkey_cb); 108 + 109 + int mlx5_core_create_mkey(struct mlx5_core_dev *dev, 110 + struct mlx5_core_mkey *mkey, 111 + u32 *in, int inlen) 112 + { 113 + return mlx5_core_create_mkey_cb(dev, mkey, in, inlen, 114 + NULL, 0, NULL, NULL); 115 + } 103 116 EXPORT_SYMBOL(mlx5_core_create_mkey); 104 117 105 118 int mlx5_core_destroy_mkey(struct mlx5_core_dev *dev, 106 119 struct mlx5_core_mkey *mkey) 107 120 { 108 121 struct mlx5_mkey_table *table = &dev->priv.mkey_table; 109 - struct mlx5_destroy_mkey_mbox_in in; 110 - struct mlx5_destroy_mkey_mbox_out out; 122 + u32 out[MLX5_ST_SZ_DW(destroy_mkey_out)] = {0}; 123 + u32 in[MLX5_ST_SZ_DW(destroy_mkey_in)] = {0}; 111 124 struct mlx5_core_mkey *deleted_mkey; 112 125 unsigned long flags; 113 126 int err; 114 - 115 - memset(&in, 0, sizeof(in)); 116 - memset(&out, 0, sizeof(out)); 117 127 118 128 write_lock_irqsave(&table->lock, flags); 119 129 deleted_mkey = radix_tree_delete(&table->tree, mlx5_base_mkey(mkey->key)); ··· 130 128 return -ENOENT; 131 129 } 132 130 133 - in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_DESTROY_MKEY); 134 - in.mkey = cpu_to_be32(mlx5_mkey_to_idx(mkey->key)); 135 - err = mlx5_cmd_exec(dev, &in, sizeof(in), &out, sizeof(out)); 136 - if (err) 137 - return err; 131 + MLX5_SET(destroy_mkey_in, in, opcode, MLX5_CMD_OP_DESTROY_MKEY); 132 + MLX5_SET(destroy_mkey_in, in, mkey_index, mlx5_mkey_to_idx(mkey->key)); 138 133 139 - if (out.hdr.status) 140 - return mlx5_cmd_status_to_err(&out.hdr); 141 - 142 - return err; 134 + err = mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out)); 135 + return err ? : mlx5_cmd_status_to_err_v2(out); 143 136 } 144 137 EXPORT_SYMBOL(mlx5_core_destroy_mkey); 145 138 146 139 int mlx5_core_query_mkey(struct mlx5_core_dev *dev, struct mlx5_core_mkey *mkey, 147 - struct mlx5_query_mkey_mbox_out *out, int outlen) 140 + u32 *out, int outlen) 148 141 { 149 - struct mlx5_query_mkey_mbox_in in; 142 + u32 in[MLX5_ST_SZ_DW(query_mkey_in)] = {0}; 150 143 int err; 151 144 152 - memset(&in, 0, sizeof(in)); 153 145 memset(out, 0, outlen); 146 + MLX5_SET(query_mkey_in, in, opcode, MLX5_CMD_OP_QUERY_MKEY); 147 + MLX5_SET(query_mkey_in, in, mkey_index, mlx5_mkey_to_idx(mkey->key)); 154 148 155 - in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_QUERY_MKEY); 156 - in.mkey = cpu_to_be32(mlx5_mkey_to_idx(mkey->key)); 157 - err = mlx5_cmd_exec(dev, &in, sizeof(in), out, outlen); 158 - if (err) 159 - return err; 160 - 161 - if (out->hdr.status) 162 - return mlx5_cmd_status_to_err(&out->hdr); 163 - 164 - return err; 149 + err = mlx5_cmd_exec(dev, in, sizeof(in), out, outlen); 150 + return err ? : mlx5_cmd_status_to_err_v2(out); 165 151 } 166 152 EXPORT_SYMBOL(mlx5_core_query_mkey); 167 153 168 154 int mlx5_core_dump_fill_mkey(struct mlx5_core_dev *dev, struct mlx5_core_mkey *_mkey, 169 155 u32 *mkey) 170 156 { 171 - struct mlx5_query_special_ctxs_mbox_in in; 172 - struct mlx5_query_special_ctxs_mbox_out out; 157 + u32 out[MLX5_ST_SZ_DW(query_special_contexts_out)] = {0}; 158 + u32 in[MLX5_ST_SZ_DW(query_special_contexts_in)] = {0}; 173 159 int err; 174 160 175 - memset(&in, 0, sizeof(in)); 176 - memset(&out, 0, sizeof(out)); 177 - 178 - in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_QUERY_SPECIAL_CONTEXTS); 179 - err = mlx5_cmd_exec(dev, &in, sizeof(in), &out, sizeof(out)); 161 + MLX5_SET(query_special_contexts_in, in, opcode, 162 + MLX5_CMD_OP_QUERY_SPECIAL_CONTEXTS); 163 + err = mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out)); 164 + err = err ? : mlx5_cmd_status_to_err_v2(out); 180 165 if (err) 181 166 return err; 182 167 183 - if (out.hdr.status) 184 - return mlx5_cmd_status_to_err(&out.hdr); 185 - 186 - *mkey = be32_to_cpu(out.dump_fill_mkey); 187 - 168 + *mkey = MLX5_GET(query_special_contexts_out, out, dump_fill_mkey); 188 169 return err; 189 170 } 190 171 EXPORT_SYMBOL(mlx5_core_dump_fill_mkey); 191 172 173 + static inline u32 mlx5_get_psv(u32 *out, int psv_index) 174 + { 175 + switch (psv_index) { 176 + case 1: return MLX5_GET(create_psv_out, out, psv1_index); 177 + case 2: return MLX5_GET(create_psv_out, out, psv2_index); 178 + case 3: return MLX5_GET(create_psv_out, out, psv3_index); 179 + default: return MLX5_GET(create_psv_out, out, psv0_index); 180 + } 181 + } 182 + 192 183 int mlx5_core_create_psv(struct mlx5_core_dev *dev, u32 pdn, 193 184 int npsvs, u32 *sig_index) 194 185 { 195 - struct mlx5_allocate_psv_in in; 196 - struct mlx5_allocate_psv_out out; 186 + u32 out[MLX5_ST_SZ_DW(create_psv_out)] = {0}; 187 + u32 in[MLX5_ST_SZ_DW(create_psv_in)] = {0}; 197 188 int i, err; 198 189 199 190 if (npsvs > MLX5_MAX_PSVS) 200 191 return -EINVAL; 201 192 202 - memset(&in, 0, sizeof(in)); 203 - memset(&out, 0, sizeof(out)); 193 + MLX5_SET(create_psv_in, in, opcode, MLX5_CMD_OP_CREATE_PSV); 194 + MLX5_SET(create_psv_in, in, pd, pdn); 195 + MLX5_SET(create_psv_in, in, num_psv, npsvs); 204 196 205 - in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_CREATE_PSV); 206 - in.npsv_pd = cpu_to_be32((npsvs << 28) | pdn); 207 - err = mlx5_cmd_exec(dev, &in, sizeof(in), &out, sizeof(out)); 197 + err = mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out)); 198 + err = err ? : mlx5_cmd_status_to_err_v2(out); 208 199 if (err) { 209 - mlx5_core_err(dev, "cmd exec failed %d\n", err); 200 + mlx5_core_err(dev, "create_psv cmd exec failed %d\n", err); 210 201 return err; 211 202 } 212 203 213 - if (out.hdr.status) { 214 - mlx5_core_err(dev, "create_psv bad status %d\n", 215 - out.hdr.status); 216 - return mlx5_cmd_status_to_err(&out.hdr); 217 - } 218 - 219 204 for (i = 0; i < npsvs; i++) 220 - sig_index[i] = be32_to_cpu(out.psv_idx[i]) & 0xffffff; 205 + sig_index[i] = mlx5_get_psv(out, i); 221 206 222 207 return err; 223 208 } ··· 212 223 213 224 int mlx5_core_destroy_psv(struct mlx5_core_dev *dev, int psv_num) 214 225 { 215 - struct mlx5_destroy_psv_in in; 216 - struct mlx5_destroy_psv_out out; 226 + u32 out[MLX5_ST_SZ_DW(destroy_psv_out)] = {0}; 227 + u32 in[MLX5_ST_SZ_DW(destroy_psv_in)] = {0}; 217 228 int err; 218 229 219 - memset(&in, 0, sizeof(in)); 220 - memset(&out, 0, sizeof(out)); 221 - 222 - in.psv_number = cpu_to_be32(psv_num); 223 - in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_DESTROY_PSV); 224 - err = mlx5_cmd_exec(dev, &in, sizeof(in), &out, sizeof(out)); 225 - if (err) { 226 - mlx5_core_err(dev, "destroy_psv cmd exec failed %d\n", err); 227 - goto out; 228 - } 229 - 230 - if (out.hdr.status) { 231 - mlx5_core_err(dev, "destroy_psv bad status %d\n", 232 - out.hdr.status); 233 - err = mlx5_cmd_status_to_err(&out.hdr); 234 - goto out; 235 - } 236 - 237 - out: 238 - return err; 230 + MLX5_SET(destroy_psv_in, in, opcode, MLX5_CMD_OP_DESTROY_PSV); 231 + MLX5_SET(destroy_psv_in, in, psvn, psv_num); 232 + err = mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out)); 233 + return err ? : mlx5_cmd_status_to_err_v2(out); 239 234 } 240 235 EXPORT_SYMBOL(mlx5_core_destroy_psv);
+7 -106
include/linux/mlx5/device.h
··· 198 198 }; 199 199 200 200 enum { 201 - MLX5_ACCESS_MODE_PA = 0, 202 - MLX5_ACCESS_MODE_MTT = 1, 203 - MLX5_ACCESS_MODE_KLM = 2 204 - }; 205 - 206 - enum { 207 - MLX5_MKEY_REMOTE_INVAL = 1 << 24, 208 - MLX5_MKEY_FLAG_SYNC_UMR = 1 << 29, 209 - MLX5_MKEY_BSF_EN = 1 << 30, 210 - MLX5_MKEY_LEN64 = 1 << 31, 211 - }; 212 - 213 - enum { 214 201 MLX5_EN_RD = (u64)1, 215 202 MLX5_EN_WR = (u64)2 216 203 }; ··· 910 923 MLX5_MKEY_STATUS_FREE = 1 << 6, 911 924 }; 912 925 926 + enum { 927 + MLX5_MKEY_REMOTE_INVAL = 1 << 24, 928 + MLX5_MKEY_FLAG_SYNC_UMR = 1 << 29, 929 + MLX5_MKEY_BSF_EN = 1 << 30, 930 + MLX5_MKEY_LEN64 = 1 << 31, 931 + }; 932 + 913 933 struct mlx5_mkey_seg { 914 934 /* This is a two bit field occupying bits 31-30. 915 935 * bit 31 is always 0, ··· 939 945 u8 rsvd4[4]; 940 946 }; 941 947 942 - struct mlx5_query_special_ctxs_mbox_in { 943 - struct mlx5_inbox_hdr hdr; 944 - u8 rsvd[8]; 945 - }; 946 - 947 - struct mlx5_query_special_ctxs_mbox_out { 948 - struct mlx5_outbox_hdr hdr; 949 - __be32 dump_fill_mkey; 950 - __be32 reserved_lkey; 951 - }; 952 - 953 - struct mlx5_create_mkey_mbox_in { 954 - struct mlx5_inbox_hdr hdr; 955 - __be32 input_mkey_index; 956 - __be32 flags; 957 - struct mlx5_mkey_seg seg; 958 - u8 rsvd1[16]; 959 - __be32 xlat_oct_act_size; 960 - __be32 rsvd2; 961 - u8 rsvd3[168]; 962 - __be64 pas[0]; 963 - }; 964 - 965 - struct mlx5_create_mkey_mbox_out { 966 - struct mlx5_outbox_hdr hdr; 967 - __be32 mkey; 968 - u8 rsvd[4]; 969 - }; 970 - 971 - struct mlx5_destroy_mkey_mbox_in { 972 - struct mlx5_inbox_hdr hdr; 973 - __be32 mkey; 974 - u8 rsvd[4]; 975 - }; 976 - 977 - struct mlx5_destroy_mkey_mbox_out { 978 - struct mlx5_outbox_hdr hdr; 979 - u8 rsvd[8]; 980 - }; 981 - 982 - struct mlx5_query_mkey_mbox_in { 983 - struct mlx5_inbox_hdr hdr; 984 - __be32 mkey; 985 - }; 986 - 987 - struct mlx5_query_mkey_mbox_out { 988 - struct mlx5_outbox_hdr hdr; 989 - __be64 pas[0]; 990 - }; 991 - 992 - struct mlx5_modify_mkey_mbox_in { 993 - struct mlx5_inbox_hdr hdr; 994 - __be32 mkey; 995 - __be64 pas[0]; 996 - }; 997 - 998 - struct mlx5_modify_mkey_mbox_out { 999 - struct mlx5_outbox_hdr hdr; 1000 - u8 rsvd[8]; 1001 - }; 1002 - 1003 - struct mlx5_dump_mkey_mbox_in { 1004 - struct mlx5_inbox_hdr hdr; 1005 - }; 1006 - 1007 - struct mlx5_dump_mkey_mbox_out { 1008 - struct mlx5_outbox_hdr hdr; 1009 - __be32 mkey; 1010 - }; 1011 - 1012 948 #define MLX5_ATTR_EXTENDED_PORT_INFO cpu_to_be16(0xff90) 1013 949 1014 950 enum { 1015 951 MLX_EXT_PORT_CAP_FLAG_EXTENDED_PORT_INFO = 1 << 0 1016 - }; 1017 - 1018 - struct mlx5_allocate_psv_in { 1019 - struct mlx5_inbox_hdr hdr; 1020 - __be32 npsv_pd; 1021 - __be32 rsvd_psv0; 1022 - }; 1023 - 1024 - struct mlx5_allocate_psv_out { 1025 - struct mlx5_outbox_hdr hdr; 1026 - u8 rsvd[8]; 1027 - __be32 psv_idx[4]; 1028 - }; 1029 - 1030 - struct mlx5_destroy_psv_in { 1031 - struct mlx5_inbox_hdr hdr; 1032 - __be32 psv_number; 1033 - u8 rsvd[4]; 1034 - }; 1035 - 1036 - struct mlx5_destroy_psv_out { 1037 - struct mlx5_outbox_hdr hdr; 1038 - u8 rsvd[8]; 1039 952 }; 1040 953 1041 954 enum {
+7 -4
include/linux/mlx5/driver.h
··· 807 807 u16 lwm, int is_srq); 808 808 void mlx5_init_mkey_table(struct mlx5_core_dev *dev); 809 809 void mlx5_cleanup_mkey_table(struct mlx5_core_dev *dev); 810 + int mlx5_core_create_mkey_cb(struct mlx5_core_dev *dev, 811 + struct mlx5_core_mkey *mkey, 812 + u32 *in, int inlen, 813 + u32 *out, int outlen, 814 + mlx5_cmd_cbk_t callback, void *context); 810 815 int mlx5_core_create_mkey(struct mlx5_core_dev *dev, 811 816 struct mlx5_core_mkey *mkey, 812 - struct mlx5_create_mkey_mbox_in *in, int inlen, 813 - mlx5_cmd_cbk_t callback, void *context, 814 - struct mlx5_create_mkey_mbox_out *out); 817 + u32 *in, int inlen); 815 818 int mlx5_core_destroy_mkey(struct mlx5_core_dev *dev, 816 819 struct mlx5_core_mkey *mkey); 817 820 int mlx5_core_query_mkey(struct mlx5_core_dev *dev, struct mlx5_core_mkey *mkey, 818 - struct mlx5_query_mkey_mbox_out *out, int outlen); 821 + u32 *out, int outlen); 819 822 int mlx5_core_dump_fill_mkey(struct mlx5_core_dev *dev, struct mlx5_core_mkey *_mkey, 820 823 u32 *mkey); 821 824 int mlx5_core_alloc_pd(struct mlx5_core_dev *dev, u32 *pdn);
+1 -1
include/linux/mlx5/mlx5_ifc.h
··· 3489 3489 3490 3490 u8 syndrome[0x20]; 3491 3491 3492 - u8 reserved_at_40[0x20]; 3492 + u8 dump_fill_mkey[0x20]; 3493 3493 3494 3494 u8 resd_lkey[0x20]; 3495 3495 };