aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/crypto/talitos.c
diff options
context:
space:
mode:
authorLEROY Christophe <christophe.leroy@c-s.fr>2016-06-06 07:20:36 -0400
committerHerbert Xu <herbert@gondor.apana.org.au>2016-06-08 04:20:02 -0400
commit246a87cda070a708361cee4309748bcb2cb6121d (patch)
tree29b5656b53f3a26762124f939a834cfb9c0c661f /drivers/crypto/talitos.c
parentb096b544d6c3cb65c53551ddedd21180f9087ab9 (diff)
crypto: talitos - move mapping helpers before IPSEC functions
In order to be able to use the mapping/unmapping helpers for IPSEC it needs to be move upper in the file Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Diffstat (limited to 'drivers/crypto/talitos.c')
-rw-r--r--drivers/crypto/talitos.c244
1 files changed, 122 insertions, 122 deletions
diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c
index a92aa37f32a0..beb369e557b9 100644
--- a/drivers/crypto/talitos.c
+++ b/drivers/crypto/talitos.c
@@ -926,6 +926,33 @@ static void talitos_sg_unmap(struct device *dev,
926 dma_unmap_sg(dev, src, src_nents, DMA_BIDIRECTIONAL); 926 dma_unmap_sg(dev, src, src_nents, DMA_BIDIRECTIONAL);
927} 927}
928 928
929static void unmap_sg_talitos_ptr(struct device *dev, struct scatterlist *src,
930 struct scatterlist *dst, unsigned int len,
931 struct talitos_edesc *edesc)
932{
933 struct talitos_private *priv = dev_get_drvdata(dev);
934 bool is_sec1 = has_ftr_sec1(priv);
935
936 if (is_sec1) {
937 if (!edesc->src_nents) {
938 dma_unmap_sg(dev, src, 1,
939 dst != src ? DMA_TO_DEVICE
940 : DMA_BIDIRECTIONAL);
941 }
942 if (dst && edesc->dst_nents) {
943 dma_sync_single_for_device(dev,
944 edesc->dma_link_tbl + len,
945 len, DMA_FROM_DEVICE);
946 sg_copy_from_buffer(dst, edesc->dst_nents ? : 1,
947 edesc->buf + len, len);
948 } else if (dst && dst != src) {
949 dma_unmap_sg(dev, dst, 1, DMA_FROM_DEVICE);
950 }
951 } else {
952 talitos_sg_unmap(dev, edesc, src, dst);
953 }
954}
955
929static void ipsec_esp_unmap(struct device *dev, 956static void ipsec_esp_unmap(struct device *dev,
930 struct talitos_edesc *edesc, 957 struct talitos_edesc *edesc,
931 struct aead_request *areq) 958 struct aead_request *areq)
@@ -1083,6 +1110,101 @@ static inline int sg_to_link_tbl(struct scatterlist *sg, int sg_count,
1083 link_tbl_ptr); 1110 link_tbl_ptr);
1084} 1111}
1085 1112
1113int map_sg_in_talitos_ptr(struct device *dev, struct scatterlist *src,
1114 unsigned int len, struct talitos_edesc *edesc,
1115 enum dma_data_direction dir, struct talitos_ptr *ptr)
1116{
1117 int sg_count;
1118 struct talitos_private *priv = dev_get_drvdata(dev);
1119 bool is_sec1 = has_ftr_sec1(priv);
1120
1121 to_talitos_ptr_len(ptr, len, is_sec1);
1122
1123 if (is_sec1) {
1124 sg_count = edesc->src_nents ? : 1;
1125
1126 if (sg_count == 1) {
1127 dma_map_sg(dev, src, 1, dir);
1128 to_talitos_ptr(ptr, sg_dma_address(src), is_sec1);
1129 } else {
1130 sg_copy_to_buffer(src, sg_count, edesc->buf, len);
1131 to_talitos_ptr(ptr, edesc->dma_link_tbl, is_sec1);
1132 dma_sync_single_for_device(dev, edesc->dma_link_tbl,
1133 len, DMA_TO_DEVICE);
1134 }
1135 } else {
1136 to_talitos_ptr_ext_set(ptr, 0, is_sec1);
1137
1138 sg_count = dma_map_sg(dev, src, edesc->src_nents ? : 1, dir);
1139
1140 if (sg_count == 1) {
1141 to_talitos_ptr(ptr, sg_dma_address(src), is_sec1);
1142 } else {
1143 sg_count = sg_to_link_tbl(src, sg_count, len,
1144 &edesc->link_tbl[0]);
1145 if (sg_count > 1) {
1146 to_talitos_ptr(ptr, edesc->dma_link_tbl, 0);
1147 to_talitos_ptr_ext_or(ptr, DESC_PTR_LNKTBL_JUMP,
1148 0);
1149 dma_sync_single_for_device(dev,
1150 edesc->dma_link_tbl,
1151 edesc->dma_len,
1152 DMA_BIDIRECTIONAL);
1153 } else {
1154 /* Only one segment now, so no link tbl needed*/
1155 to_talitos_ptr(ptr, sg_dma_address(src),
1156 is_sec1);
1157 }
1158 }
1159 }
1160 return sg_count;
1161}
1162
1163void map_sg_out_talitos_ptr(struct device *dev, struct scatterlist *dst,
1164 unsigned int len, struct talitos_edesc *edesc,
1165 enum dma_data_direction dir,
1166 struct talitos_ptr *ptr, int sg_count)
1167{
1168 struct talitos_private *priv = dev_get_drvdata(dev);
1169 bool is_sec1 = has_ftr_sec1(priv);
1170
1171 if (dir != DMA_NONE)
1172 sg_count = dma_map_sg(dev, dst, edesc->dst_nents ? : 1, dir);
1173
1174 to_talitos_ptr_len(ptr, len, is_sec1);
1175
1176 if (is_sec1) {
1177 if (sg_count == 1) {
1178 if (dir != DMA_NONE)
1179 dma_map_sg(dev, dst, 1, dir);
1180 to_talitos_ptr(ptr, sg_dma_address(dst), is_sec1);
1181 } else {
1182 to_talitos_ptr(ptr, edesc->dma_link_tbl + len, is_sec1);
1183 dma_sync_single_for_device(dev,
1184 edesc->dma_link_tbl + len,
1185 len, DMA_FROM_DEVICE);
1186 }
1187 } else {
1188 to_talitos_ptr_ext_set(ptr, 0, is_sec1);
1189
1190 if (sg_count == 1) {
1191 to_talitos_ptr(ptr, sg_dma_address(dst), is_sec1);
1192 } else {
1193 struct talitos_ptr *link_tbl_ptr =
1194 &edesc->link_tbl[edesc->src_nents + 1];
1195
1196 to_talitos_ptr(ptr, edesc->dma_link_tbl +
1197 (edesc->src_nents + 1) *
1198 sizeof(struct talitos_ptr), 0);
1199 to_talitos_ptr_ext_or(ptr, DESC_PTR_LNKTBL_JUMP, 0);
1200 sg_to_link_tbl(dst, sg_count, len, link_tbl_ptr);
1201 dma_sync_single_for_device(dev, edesc->dma_link_tbl,
1202 edesc->dma_len,
1203 DMA_BIDIRECTIONAL);
1204 }
1205 }
1206}
1207
1086/* 1208/*
1087 * fill in and submit ipsec_esp descriptor 1209 * fill in and submit ipsec_esp descriptor
1088 */ 1210 */
@@ -1420,33 +1542,6 @@ static int ablkcipher_setkey(struct crypto_ablkcipher *cipher,
1420 return 0; 1542 return 0;
1421} 1543}
1422 1544
1423static void unmap_sg_talitos_ptr(struct device *dev, struct scatterlist *src,
1424 struct scatterlist *dst, unsigned int len,
1425 struct talitos_edesc *edesc)
1426{
1427 struct talitos_private *priv = dev_get_drvdata(dev);
1428 bool is_sec1 = has_ftr_sec1(priv);
1429
1430 if (is_sec1) {
1431 if (!edesc->src_nents) {
1432 dma_unmap_sg(dev, src, 1,
1433 dst != src ? DMA_TO_DEVICE
1434 : DMA_BIDIRECTIONAL);
1435 }
1436 if (dst && edesc->dst_nents) {
1437 dma_sync_single_for_device(dev,
1438 edesc->dma_link_tbl + len,
1439 len, DMA_FROM_DEVICE);
1440 sg_copy_from_buffer(dst, edesc->dst_nents ? : 1,
1441 edesc->buf + len, len);
1442 } else if (dst && dst != src) {
1443 dma_unmap_sg(dev, dst, 1, DMA_FROM_DEVICE);
1444 }
1445 } else {
1446 talitos_sg_unmap(dev, edesc, src, dst);
1447 }
1448}
1449
1450static void common_nonsnoop_unmap(struct device *dev, 1545static void common_nonsnoop_unmap(struct device *dev,
1451 struct talitos_edesc *edesc, 1546 struct talitos_edesc *edesc,
1452 struct ablkcipher_request *areq) 1547 struct ablkcipher_request *areq)
@@ -1478,101 +1573,6 @@ static void ablkcipher_done(struct device *dev,
1478 areq->base.complete(&areq->base, err); 1573 areq->base.complete(&areq->base, err);
1479} 1574}
1480 1575
1481int map_sg_in_talitos_ptr(struct device *dev, struct scatterlist *src,
1482 unsigned int len, struct talitos_edesc *edesc,
1483 enum dma_data_direction dir, struct talitos_ptr *ptr)
1484{
1485 int sg_count;
1486 struct talitos_private *priv = dev_get_drvdata(dev);
1487 bool is_sec1 = has_ftr_sec1(priv);
1488
1489 to_talitos_ptr_len(ptr, len, is_sec1);
1490
1491 if (is_sec1) {
1492 sg_count = edesc->src_nents ? : 1;
1493
1494 if (sg_count == 1) {
1495 dma_map_sg(dev, src, 1, dir);
1496 to_talitos_ptr(ptr, sg_dma_address(src), is_sec1);
1497 } else {
1498 sg_copy_to_buffer(src, sg_count, edesc->buf, len);
1499 to_talitos_ptr(ptr, edesc->dma_link_tbl, is_sec1);
1500 dma_sync_single_for_device(dev, edesc->dma_link_tbl,
1501 len, DMA_TO_DEVICE);
1502 }
1503 } else {
1504 to_talitos_ptr_ext_set(ptr, 0, is_sec1);
1505
1506 sg_count = dma_map_sg(dev, src, edesc->src_nents ? : 1, dir);
1507
1508 if (sg_count == 1) {
1509 to_talitos_ptr(ptr, sg_dma_address(src), is_sec1);
1510 } else {
1511 sg_count = sg_to_link_tbl(src, sg_count, len,
1512 &edesc->link_tbl[0]);
1513 if (sg_count > 1) {
1514 to_talitos_ptr(ptr, edesc->dma_link_tbl, 0);
1515 to_talitos_ptr_ext_or(ptr, DESC_PTR_LNKTBL_JUMP,
1516 0);
1517 dma_sync_single_for_device(dev,
1518 edesc->dma_link_tbl,
1519 edesc->dma_len,
1520 DMA_BIDIRECTIONAL);
1521 } else {
1522 /* Only one segment now, so no link tbl needed*/
1523 to_talitos_ptr(ptr, sg_dma_address(src),
1524 is_sec1);
1525 }
1526 }
1527 }
1528 return sg_count;
1529}
1530
1531void map_sg_out_talitos_ptr(struct device *dev, struct scatterlist *dst,
1532 unsigned int len, struct talitos_edesc *edesc,
1533 enum dma_data_direction dir,
1534 struct talitos_ptr *ptr, int sg_count)
1535{
1536 struct talitos_private *priv = dev_get_drvdata(dev);
1537 bool is_sec1 = has_ftr_sec1(priv);
1538
1539 if (dir != DMA_NONE)
1540 sg_count = dma_map_sg(dev, dst, edesc->dst_nents ? : 1, dir);
1541
1542 to_talitos_ptr_len(ptr, len, is_sec1);
1543
1544 if (is_sec1) {
1545 if (sg_count == 1) {
1546 if (dir != DMA_NONE)
1547 dma_map_sg(dev, dst, 1, dir);
1548 to_talitos_ptr(ptr, sg_dma_address(dst), is_sec1);
1549 } else {
1550 to_talitos_ptr(ptr, edesc->dma_link_tbl + len, is_sec1);
1551 dma_sync_single_for_device(dev,
1552 edesc->dma_link_tbl + len,
1553 len, DMA_FROM_DEVICE);
1554 }
1555 } else {
1556 to_talitos_ptr_ext_set(ptr, 0, is_sec1);
1557
1558 if (sg_count == 1) {
1559 to_talitos_ptr(ptr, sg_dma_address(dst), is_sec1);
1560 } else {
1561 struct talitos_ptr *link_tbl_ptr =
1562 &edesc->link_tbl[edesc->src_nents + 1];
1563
1564 to_talitos_ptr(ptr, edesc->dma_link_tbl +
1565 (edesc->src_nents + 1) *
1566 sizeof(struct talitos_ptr), 0);
1567 to_talitos_ptr_ext_or(ptr, DESC_PTR_LNKTBL_JUMP, 0);
1568 sg_to_link_tbl(dst, sg_count, len, link_tbl_ptr);
1569 dma_sync_single_for_device(dev, edesc->dma_link_tbl,
1570 edesc->dma_len,
1571 DMA_BIDIRECTIONAL);
1572 }
1573 }
1574}
1575
1576static int common_nonsnoop(struct talitos_edesc *edesc, 1576static int common_nonsnoop(struct talitos_edesc *edesc,
1577 struct ablkcipher_request *areq, 1577 struct ablkcipher_request *areq,
1578 void (*callback) (struct device *dev, 1578 void (*callback) (struct device *dev,
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-25 04:17:48 -0500