aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLABBE Corentin <clabbe.montjoie@gmail.com>2015-10-12 13:47:04 -0400
committerHerbert Xu <herbert@gondor.apana.org.au>2015-10-14 10:23:38 -0400
commit5a4eea2658c933205cd014b87066f3faa2dbe7f7 (patch)
tree6f361e7dd1bcca064c5413f60f23125db1950a8b
parentb0e8b3417a620e6e0a91fd526fbc6db78714198e (diff)
crypto: ux500 - Use devm_xxx() managed function
Using the devm_xxx() managed function to stripdown the error and remove code. In the same time, we replace request_mem_region/ioremap by the unified devm_ioremap_resource() function. Signed-off-by: LABBE Corentin <clabbe.montjoie@gmail.com> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
-rw-r--r--drivers/crypto/ux500/cryp/cryp_core.c70
-rw-r--r--drivers/crypto/ux500/hash/hash_core.c49
2 files changed, 16 insertions, 103 deletions
diff --git a/drivers/crypto/ux500/cryp/cryp_core.c b/drivers/crypto/ux500/cryp/cryp_core.c
index 00f97d9750b0..4c243c1ffc7f 100644
--- a/drivers/crypto/ux500/cryp/cryp_core.c
+++ b/drivers/crypto/ux500/cryp/cryp_core.c
@@ -1414,7 +1414,7 @@ static int ux500_cryp_probe(struct platform_device *pdev)
1414 struct device *dev = &pdev->dev; 1414 struct device *dev = &pdev->dev;
1415 1415
1416 dev_dbg(dev, "[%s]", __func__); 1416 dev_dbg(dev, "[%s]", __func__);
1417 device_data = kzalloc(sizeof(struct cryp_device_data), GFP_ATOMIC); 1417 device_data = devm_kzalloc(dev, sizeof(*device_data), GFP_ATOMIC);
1418 if (!device_data) { 1418 if (!device_data) {
1419 dev_err(dev, "[%s]: kzalloc() failed!", __func__); 1419 dev_err(dev, "[%s]: kzalloc() failed!", __func__);
1420 ret = -ENOMEM; 1420 ret = -ENOMEM;
@@ -1435,23 +1435,15 @@ static int ux500_cryp_probe(struct platform_device *pdev)
1435 dev_err(dev, "[%s]: platform_get_resource() failed", 1435 dev_err(dev, "[%s]: platform_get_resource() failed",
1436 __func__); 1436 __func__);
1437 ret = -ENODEV; 1437 ret = -ENODEV;
1438 goto out_kfree; 1438 goto out;
1439 }
1440
1441 res = request_mem_region(res->start, resource_size(res), pdev->name);
1442 if (res == NULL) {
1443 dev_err(dev, "[%s]: request_mem_region() failed",
1444 __func__);
1445 ret = -EBUSY;
1446 goto out_kfree;
1447 } 1439 }
1448 1440
1449 device_data->phybase = res->start; 1441 device_data->phybase = res->start;
1450 device_data->base = ioremap(res->start, resource_size(res)); 1442 device_data->base = devm_ioremap_resource(dev, res);
1451 if (!device_data->base) { 1443 if (!device_data->base) {
1452 dev_err(dev, "[%s]: ioremap failed!", __func__); 1444 dev_err(dev, "[%s]: ioremap failed!", __func__);
1453 ret = -ENOMEM; 1445 ret = -ENOMEM;
1454 goto out_free_mem; 1446 goto out;
1455 } 1447 }
1456 1448
1457 spin_lock_init(&device_data->ctx_lock); 1449 spin_lock_init(&device_data->ctx_lock);
@@ -1463,11 +1455,11 @@ static int ux500_cryp_probe(struct platform_device *pdev)
1463 dev_err(dev, "[%s]: could not get cryp regulator", __func__); 1455 dev_err(dev, "[%s]: could not get cryp regulator", __func__);
1464 ret = PTR_ERR(device_data->pwr_regulator); 1456 ret = PTR_ERR(device_data->pwr_regulator);
1465 device_data->pwr_regulator = NULL; 1457 device_data->pwr_regulator = NULL;
1466 goto out_unmap; 1458 goto out;
1467 } 1459 }
1468 1460
1469 /* Enable the clk for CRYP hardware block */ 1461 /* Enable the clk for CRYP hardware block */
1470 device_data->clk = clk_get(&pdev->dev, NULL); 1462 device_data->clk = devm_clk_get(&pdev->dev, NULL);
1471 if (IS_ERR(device_data->clk)) { 1463 if (IS_ERR(device_data->clk)) {
1472 dev_err(dev, "[%s]: clk_get() failed!", __func__); 1464 dev_err(dev, "[%s]: clk_get() failed!", __func__);
1473 ret = PTR_ERR(device_data->clk); 1465 ret = PTR_ERR(device_data->clk);
@@ -1477,7 +1469,7 @@ static int ux500_cryp_probe(struct platform_device *pdev)
1477 ret = clk_prepare(device_data->clk); 1469 ret = clk_prepare(device_data->clk);
1478 if (ret) { 1470 if (ret) {
1479 dev_err(dev, "[%s]: clk_prepare() failed!", __func__); 1471 dev_err(dev, "[%s]: clk_prepare() failed!", __func__);
1480 goto out_clk; 1472 goto out_regulator;
1481 } 1473 }
1482 1474
1483 /* Enable device power (and clock) */ 1475 /* Enable device power (and clock) */
@@ -1510,11 +1502,8 @@ static int ux500_cryp_probe(struct platform_device *pdev)
1510 goto out_power; 1502 goto out_power;
1511 } 1503 }
1512 1504
1513 ret = request_irq(res_irq->start, 1505 ret = devm_request_irq(&pdev->dev, res_irq->start,
1514 cryp_interrupt_handler, 1506 cryp_interrupt_handler, 0, "cryp1", device_data);
1515 0,
1516 "cryp1",
1517 device_data);
1518 if (ret) { 1507 if (ret) {
1519 dev_err(dev, "[%s]: Unable to request IRQ", __func__); 1508 dev_err(dev, "[%s]: Unable to request IRQ", __func__);
1520 goto out_power; 1509 goto out_power;
@@ -1550,28 +1539,15 @@ out_power:
1550out_clk_unprepare: 1539out_clk_unprepare:
1551 clk_unprepare(device_data->clk); 1540 clk_unprepare(device_data->clk);
1552 1541
1553out_clk:
1554 clk_put(device_data->clk);
1555
1556out_regulator: 1542out_regulator:
1557 regulator_put(device_data->pwr_regulator); 1543 regulator_put(device_data->pwr_regulator);
1558 1544
1559out_unmap:
1560 iounmap(device_data->base);
1561
1562out_free_mem:
1563 release_mem_region(res->start, resource_size(res));
1564
1565out_kfree:
1566 kfree(device_data);
1567out: 1545out:
1568 return ret; 1546 return ret;
1569} 1547}
1570 1548
1571static int ux500_cryp_remove(struct platform_device *pdev) 1549static int ux500_cryp_remove(struct platform_device *pdev)
1572{ 1550{
1573 struct resource *res = NULL;
1574 struct resource *res_irq = NULL;
1575 struct cryp_device_data *device_data; 1551 struct cryp_device_data *device_data;
1576 1552
1577 dev_dbg(&pdev->dev, "[%s]", __func__); 1553 dev_dbg(&pdev->dev, "[%s]", __func__);
@@ -1607,37 +1583,18 @@ static int ux500_cryp_remove(struct platform_device *pdev)
1607 if (list_empty(&driver_data.device_list.k_list)) 1583 if (list_empty(&driver_data.device_list.k_list))
1608 cryp_algs_unregister_all(); 1584 cryp_algs_unregister_all();
1609 1585
1610 res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1611 if (!res_irq)
1612 dev_err(&pdev->dev, "[%s]: IORESOURCE_IRQ, unavailable",
1613 __func__);
1614 else {
1615 disable_irq(res_irq->start);
1616 free_irq(res_irq->start, device_data);
1617 }
1618
1619 if (cryp_disable_power(&pdev->dev, device_data, false)) 1586 if (cryp_disable_power(&pdev->dev, device_data, false))
1620 dev_err(&pdev->dev, "[%s]: cryp_disable_power() failed", 1587 dev_err(&pdev->dev, "[%s]: cryp_disable_power() failed",
1621 __func__); 1588 __func__);
1622 1589
1623 clk_unprepare(device_data->clk); 1590 clk_unprepare(device_data->clk);
1624 clk_put(device_data->clk);
1625 regulator_put(device_data->pwr_regulator); 1591 regulator_put(device_data->pwr_regulator);
1626 1592
1627 iounmap(device_data->base);
1628
1629 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1630 if (res)
1631 release_mem_region(res->start, resource_size(res));
1632
1633 kfree(device_data);
1634
1635 return 0; 1593 return 0;
1636} 1594}
1637 1595
1638static void ux500_cryp_shutdown(struct platform_device *pdev) 1596static void ux500_cryp_shutdown(struct platform_device *pdev)
1639{ 1597{
1640 struct resource *res_irq = NULL;
1641 struct cryp_device_data *device_data; 1598 struct cryp_device_data *device_data;
1642 1599
1643 dev_dbg(&pdev->dev, "[%s]", __func__); 1600 dev_dbg(&pdev->dev, "[%s]", __func__);
@@ -1673,15 +1630,6 @@ static void ux500_cryp_shutdown(struct platform_device *pdev)
1673 if (list_empty(&driver_data.device_list.k_list)) 1630 if (list_empty(&driver_data.device_list.k_list))
1674 cryp_algs_unregister_all(); 1631 cryp_algs_unregister_all();
1675 1632
1676 res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1677 if (!res_irq)
1678 dev_err(&pdev->dev, "[%s]: IORESOURCE_IRQ, unavailable",
1679 __func__);
1680 else {
1681 disable_irq(res_irq->start);
1682 free_irq(res_irq->start, device_data);
1683 }
1684
1685 if (cryp_disable_power(&pdev->dev, device_data, false)) 1633 if (cryp_disable_power(&pdev->dev, device_data, false))
1686 dev_err(&pdev->dev, "[%s]: cryp_disable_power() failed", 1634 dev_err(&pdev->dev, "[%s]: cryp_disable_power() failed",
1687 __func__); 1635 __func__);
diff --git a/drivers/crypto/ux500/hash/hash_core.c b/drivers/crypto/ux500/hash/hash_core.c
index e02bd000e750..f47d112041b2 100644
--- a/drivers/crypto/ux500/hash/hash_core.c
+++ b/drivers/crypto/ux500/hash/hash_core.c
@@ -1657,7 +1657,7 @@ static int ux500_hash_probe(struct platform_device *pdev)
1657 struct hash_device_data *device_data; 1657 struct hash_device_data *device_data;
1658 struct device *dev = &pdev->dev; 1658 struct device *dev = &pdev->dev;
1659 1659
1660 device_data = kzalloc(sizeof(*device_data), GFP_ATOMIC); 1660 device_data = devm_kzalloc(dev, sizeof(*device_data), GFP_ATOMIC);
1661 if (!device_data) { 1661 if (!device_data) {
1662 ret = -ENOMEM; 1662 ret = -ENOMEM;
1663 goto out; 1663 goto out;
@@ -1670,22 +1670,15 @@ static int ux500_hash_probe(struct platform_device *pdev)
1670 if (!res) { 1670 if (!res) {
1671 dev_dbg(dev, "%s: platform_get_resource() failed!\n", __func__); 1671 dev_dbg(dev, "%s: platform_get_resource() failed!\n", __func__);
1672 ret = -ENODEV; 1672 ret = -ENODEV;
1673 goto out_kfree; 1673 goto out;
1674 }
1675
1676 res = request_mem_region(res->start, resource_size(res), pdev->name);
1677 if (res == NULL) {
1678 dev_dbg(dev, "%s: request_mem_region() failed!\n", __func__);
1679 ret = -EBUSY;
1680 goto out_kfree;
1681 } 1674 }
1682 1675
1683 device_data->phybase = res->start; 1676 device_data->phybase = res->start;
1684 device_data->base = ioremap(res->start, resource_size(res)); 1677 device_data->base = devm_ioremap_resource(dev, res);
1685 if (!device_data->base) { 1678 if (!device_data->base) {
1686 dev_err(dev, "%s: ioremap() failed!\n", __func__); 1679 dev_err(dev, "%s: ioremap() failed!\n", __func__);
1687 ret = -ENOMEM; 1680 ret = -ENOMEM;
1688 goto out_free_mem; 1681 goto out;
1689 } 1682 }
1690 spin_lock_init(&device_data->ctx_lock); 1683 spin_lock_init(&device_data->ctx_lock);
1691 spin_lock_init(&device_data->power_state_lock); 1684 spin_lock_init(&device_data->power_state_lock);
@@ -1696,11 +1689,11 @@ static int ux500_hash_probe(struct platform_device *pdev)
1696 dev_err(dev, "%s: regulator_get() failed!\n", __func__); 1689 dev_err(dev, "%s: regulator_get() failed!\n", __func__);
1697 ret = PTR_ERR(device_data->regulator); 1690 ret = PTR_ERR(device_data->regulator);
1698 device_data->regulator = NULL; 1691 device_data->regulator = NULL;
1699 goto out_unmap; 1692 goto out;
1700 } 1693 }
1701 1694
1702 /* Enable the clock for HASH1 hardware block */ 1695 /* Enable the clock for HASH1 hardware block */
1703 device_data->clk = clk_get(dev, NULL); 1696 device_data->clk = devm_clk_get(dev, NULL);
1704 if (IS_ERR(device_data->clk)) { 1697 if (IS_ERR(device_data->clk)) {
1705 dev_err(dev, "%s: clk_get() failed!\n", __func__); 1698 dev_err(dev, "%s: clk_get() failed!\n", __func__);
1706 ret = PTR_ERR(device_data->clk); 1699 ret = PTR_ERR(device_data->clk);
@@ -1710,7 +1703,7 @@ static int ux500_hash_probe(struct platform_device *pdev)
1710 ret = clk_prepare(device_data->clk); 1703 ret = clk_prepare(device_data->clk);
1711 if (ret) { 1704 if (ret) {
1712 dev_err(dev, "%s: clk_prepare() failed!\n", __func__); 1705 dev_err(dev, "%s: clk_prepare() failed!\n", __func__);
1713 goto out_clk; 1706 goto out_regulator;
1714 } 1707 }
1715 1708
1716 /* Enable device power (and clock) */ 1709 /* Enable device power (and clock) */
@@ -1752,20 +1745,9 @@ out_power:
1752out_clk_unprepare: 1745out_clk_unprepare:
1753 clk_unprepare(device_data->clk); 1746 clk_unprepare(device_data->clk);
1754 1747
1755out_clk:
1756 clk_put(device_data->clk);
1757
1758out_regulator: 1748out_regulator:
1759 regulator_put(device_data->regulator); 1749 regulator_put(device_data->regulator);
1760 1750
1761out_unmap:
1762 iounmap(device_data->base);
1763
1764out_free_mem:
1765 release_mem_region(res->start, resource_size(res));
1766
1767out_kfree:
1768 kfree(device_data);
1769out: 1751out:
1770 return ret; 1752 return ret;
1771} 1753}
@@ -1776,7 +1758,6 @@ out:
1776 */ 1758 */
1777static int ux500_hash_remove(struct platform_device *pdev) 1759static int ux500_hash_remove(struct platform_device *pdev)
1778{ 1760{
1779 struct resource *res;
1780 struct hash_device_data *device_data; 1761 struct hash_device_data *device_data;
1781 struct device *dev = &pdev->dev; 1762 struct device *dev = &pdev->dev;
1782 1763
@@ -1816,17 +1797,8 @@ static int ux500_hash_remove(struct platform_device *pdev)
1816 __func__); 1797 __func__);
1817 1798
1818 clk_unprepare(device_data->clk); 1799 clk_unprepare(device_data->clk);
1819 clk_put(device_data->clk);
1820 regulator_put(device_data->regulator); 1800 regulator_put(device_data->regulator);
1821 1801
1822 iounmap(device_data->base);
1823
1824 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1825 if (res)
1826 release_mem_region(res->start, resource_size(res));
1827
1828 kfree(device_data);
1829
1830 return 0; 1802 return 0;
1831} 1803}
1832 1804
@@ -1836,7 +1808,6 @@ static int ux500_hash_remove(struct platform_device *pdev)
1836 */ 1808 */
1837static void ux500_hash_shutdown(struct platform_device *pdev) 1809static void ux500_hash_shutdown(struct platform_device *pdev)
1838{ 1810{
1839 struct resource *res = NULL;
1840 struct hash_device_data *device_data; 1811 struct hash_device_data *device_data;
1841 1812
1842 device_data = platform_get_drvdata(pdev); 1813 device_data = platform_get_drvdata(pdev);
@@ -1870,12 +1841,6 @@ static void ux500_hash_shutdown(struct platform_device *pdev)
1870 if (list_empty(&driver_data.device_list.k_list)) 1841 if (list_empty(&driver_data.device_list.k_list))
1871 ahash_algs_unregister_all(device_data); 1842 ahash_algs_unregister_all(device_data);
1872 1843
1873 iounmap(device_data->base);
1874
1875 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1876 if (res)
1877 release_mem_region(res->start, resource_size(res));
1878
1879 if (hash_disable_power(device_data, false)) 1844 if (hash_disable_power(device_data, false))
1880 dev_err(&pdev->dev, "%s: hash_disable_power() failed\n", 1845 dev_err(&pdev->dev, "%s: hash_disable_power() failed\n",
1881 __func__); 1846 __func__);