Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: iaa - Remove dst_null support
Remove the unused dst_null support.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
+6
-130
+6
-130
drivers/crypto/intel/iaa/iaa_crypto_main.c
+6
-130
drivers/crypto/intel/iaa/iaa_crypto_main.c
···
1136
1136
struct idxd_wq *wq,
1137
1137
dma_addr_t src_addr, unsigned int slen,
1138
1138
dma_addr_t dst_addr, unsigned int *dlen,
1139
-
u32 *compression_crc,
1140
-
bool disable_async)
1139
+
u32 *compression_crc)
1141
1140
{
1142
1141
struct iaa_device_compression_mode *active_compression_mode;
1143
1142
struct iaa_compression_ctx *ctx = crypto_tfm_ctx(tfm);
···
1179
1180
desc->src2_size = sizeof(struct aecs_comp_table_record);
1180
1181
desc->completion_addr = idxd_desc->compl_dma;
1181
1182
1182
-
if (ctx->use_irq && !disable_async) {
1183
+
if (ctx->use_irq) {
1183
1184
desc->flags |= IDXD_OP_FLAG_RCI;
1184
1185
1185
1186
idxd_desc->crypto.req = req;
···
1192
1193
" src_addr %llx, dst_addr %llx\n", __func__,
1193
1194
active_compression_mode->name,
1194
1195
src_addr, dst_addr);
1195
-
} else if (ctx->async_mode && !disable_async)
1196
+
} else if (ctx->async_mode)
1196
1197
req->base.data = idxd_desc;
1197
1198
1198
1199
dev_dbg(dev, "%s: compression mode %s,"
···
1213
1214
update_total_comp_calls();
1214
1215
update_wq_comp_calls(wq);
1215
1216
1216
-
if (ctx->async_mode && !disable_async) {
1217
+
if (ctx->async_mode) {
1217
1218
ret = -EINPROGRESS;
1218
1219
dev_dbg(dev, "%s: returning -EINPROGRESS\n", __func__);
1219
1220
goto out;
···
1233
1234
1234
1235
*compression_crc = idxd_desc->iax_completion->crc;
1235
1236
1236
-
if (!ctx->async_mode || disable_async)
1237
+
if (!ctx->async_mode)
1237
1238
idxd_free_desc(wq, idxd_desc);
1238
1239
out:
1239
1240
return ret;
···
1499
1500
struct iaa_compression_ctx *compression_ctx;
1500
1501
struct crypto_tfm *tfm = req->base.tfm;
1501
1502
dma_addr_t src_addr, dst_addr;
1502
-
bool disable_async = false;
1503
1503
int nr_sgs, cpu, ret = 0;
1504
1504
struct iaa_wq *iaa_wq;
1505
1505
u32 compression_crc;
1506
1506
struct idxd_wq *wq;
1507
1507
struct device *dev;
1508
-
int order = -1;
1509
1508
1510
1509
compression_ctx = crypto_tfm_ctx(tfm);
1511
1510
···
1532
1535
}
1533
1536
1534
1537
iaa_wq = idxd_wq_get_private(wq);
1535
-
1536
-
if (!req->dst) {
1537
-
gfp_t flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL : GFP_ATOMIC;
1538
-
1539
-
/* incompressible data will always be < 2 * slen */
1540
-
req->dlen = 2 * req->slen;
1541
-
order = order_base_2(round_up(req->dlen, PAGE_SIZE) / PAGE_SIZE);
1542
-
req->dst = sgl_alloc_order(req->dlen, order, false, flags, NULL);
1543
-
if (!req->dst) {
1544
-
ret = -ENOMEM;
1545
-
order = -1;
1546
-
goto out;
1547
-
}
1548
-
disable_async = true;
1549
-
}
1550
1538
1551
1539
dev = &wq->idxd->pdev->dev;
1552
1540
···
1562
1580
req->dst, req->dlen, sg_dma_len(req->dst));
1563
1581
1564
1582
ret = iaa_compress(tfm, req, wq, src_addr, req->slen, dst_addr,
1565
-
&req->dlen, &compression_crc, disable_async);
1583
+
&req->dlen, &compression_crc);
1566
1584
if (ret == -EINPROGRESS)
1567
1585
return ret;
1568
1586
···
1593
1611
out:
1594
1612
iaa_wq_put(wq);
1595
1613
1596
-
if (order >= 0)
1597
-
sgl_free_order(req->dst, order);
1598
-
1599
-
return ret;
1600
-
}
1601
-
1602
-
static int iaa_comp_adecompress_alloc_dest(struct acomp_req *req)
1603
-
{
1604
-
gfp_t flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ?
1605
-
GFP_KERNEL : GFP_ATOMIC;
1606
-
struct crypto_tfm *tfm = req->base.tfm;
1607
-
dma_addr_t src_addr, dst_addr;
1608
-
int nr_sgs, cpu, ret = 0;
1609
-
struct iaa_wq *iaa_wq;
1610
-
struct device *dev;
1611
-
struct idxd_wq *wq;
1612
-
int order = -1;
1613
-
1614
-
cpu = get_cpu();
1615
-
wq = wq_table_next_wq(cpu);
1616
-
put_cpu();
1617
-
if (!wq) {
1618
-
pr_debug("no wq configured for cpu=%d\n", cpu);
1619
-
return -ENODEV;
1620
-
}
1621
-
1622
-
ret = iaa_wq_get(wq);
1623
-
if (ret) {
1624
-
pr_debug("no wq available for cpu=%d\n", cpu);
1625
-
return -ENODEV;
1626
-
}
1627
-
1628
-
iaa_wq = idxd_wq_get_private(wq);
1629
-
1630
-
dev = &wq->idxd->pdev->dev;
1631
-
1632
-
nr_sgs = dma_map_sg(dev, req->src, sg_nents(req->src), DMA_TO_DEVICE);
1633
-
if (nr_sgs <= 0 || nr_sgs > 1) {
1634
-
dev_dbg(dev, "couldn't map src sg for iaa device %d,"
1635
-
" wq %d: ret=%d\n", iaa_wq->iaa_device->idxd->id,
1636
-
iaa_wq->wq->id, ret);
1637
-
ret = -EIO;
1638
-
goto out;
1639
-
}
1640
-
src_addr = sg_dma_address(req->src);
1641
-
dev_dbg(dev, "dma_map_sg, src_addr %llx, nr_sgs %d, req->src %p,"
1642
-
" req->slen %d, sg_dma_len(sg) %d\n", src_addr, nr_sgs,
1643
-
req->src, req->slen, sg_dma_len(req->src));
1644
-
1645
-
req->dlen = 4 * req->slen; /* start with ~avg comp rato */
1646
-
alloc_dest:
1647
-
order = order_base_2(round_up(req->dlen, PAGE_SIZE) / PAGE_SIZE);
1648
-
req->dst = sgl_alloc_order(req->dlen, order, false, flags, NULL);
1649
-
if (!req->dst) {
1650
-
ret = -ENOMEM;
1651
-
order = -1;
1652
-
goto out;
1653
-
}
1654
-
1655
-
nr_sgs = dma_map_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);
1656
-
if (nr_sgs <= 0 || nr_sgs > 1) {
1657
-
dev_dbg(dev, "couldn't map dst sg for iaa device %d,"
1658
-
" wq %d: ret=%d\n", iaa_wq->iaa_device->idxd->id,
1659
-
iaa_wq->wq->id, ret);
1660
-
ret = -EIO;
1661
-
goto err_map_dst;
1662
-
}
1663
-
1664
-
dst_addr = sg_dma_address(req->dst);
1665
-
dev_dbg(dev, "dma_map_sg, dst_addr %llx, nr_sgs %d, req->dst %p,"
1666
-
" req->dlen %d, sg_dma_len(sg) %d\n", dst_addr, nr_sgs,
1667
-
req->dst, req->dlen, sg_dma_len(req->dst));
1668
-
ret = iaa_decompress(tfm, req, wq, src_addr, req->slen,
1669
-
dst_addr, &req->dlen, true);
1670
-
if (ret == -EOVERFLOW) {
1671
-
dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);
1672
-
req->dlen *= 2;
1673
-
if (req->dlen > CRYPTO_ACOMP_DST_MAX)
1674
-
goto err_map_dst;
1675
-
goto alloc_dest;
1676
-
}
1677
-
1678
-
if (ret != 0)
1679
-
dev_dbg(dev, "asynchronous decompress failed ret=%d\n", ret);
1680
-
1681
-
dma_unmap_sg(dev, req->dst, sg_nents(req->dst), DMA_FROM_DEVICE);
1682
-
err_map_dst:
1683
-
dma_unmap_sg(dev, req->src, sg_nents(req->src), DMA_TO_DEVICE);
1684
-
out:
1685
-
iaa_wq_put(wq);
1686
-
1687
-
if (order >= 0)
1688
-
sgl_free_order(req->dst, order);
1689
-
1690
1614
return ret;
1691
1615
}
1692
1616
···
1614
1726
pr_debug("invalid src, not decompressing\n");
1615
1727
return -EINVAL;
1616
1728
}
1617
-
1618
-
if (!req->dst)
1619
-
return iaa_comp_adecompress_alloc_dest(req);
1620
1729
1621
1730
cpu = get_cpu();
1622
1731
wq = wq_table_next_wq(cpu);
···
1695
1810
return 0;
1696
1811
}
1697
1812
1698
-
static void dst_free(struct scatterlist *sgl)
1699
-
{
1700
-
/*
1701
-
* Called for req->dst = NULL cases but we free elsewhere
1702
-
* using sgl_free_order().
1703
-
*/
1704
-
}
1705
-
1706
1813
static struct acomp_alg iaa_acomp_fixed_deflate = {
1707
1814
.init = iaa_comp_init_fixed,
1708
1815
.compress = iaa_comp_acompress,
1709
1816
.decompress = iaa_comp_adecompress,
1710
-
.dst_free = dst_free,
1711
1817
.base = {
1712
1818
.cra_name = "deflate",
1713
1819
.cra_driver_name = "deflate-iaa",