diff options
author | LABBE Corentin <clabbe.montjoie@gmail.com> | 2015-10-12 13:47:04 -0400 |
---|---|---|
committer | Herbert Xu <herbert@gondor.apana.org.au> | 2015-10-14 10:23:38 -0400 |
commit | 5a4eea2658c933205cd014b87066f3faa2dbe7f7 (patch) | |
tree | 6f361e7dd1bcca064c5413f60f23125db1950a8b | |
parent | b0e8b3417a620e6e0a91fd526fbc6db78714198e (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.c | 70 | ||||
-rw-r--r-- | drivers/crypto/ux500/hash/hash_core.c | 49 |
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: | |||
1550 | out_clk_unprepare: | 1539 | out_clk_unprepare: |
1551 | clk_unprepare(device_data->clk); | 1540 | clk_unprepare(device_data->clk); |
1552 | 1541 | ||
1553 | out_clk: | ||
1554 | clk_put(device_data->clk); | ||
1555 | |||
1556 | out_regulator: | 1542 | out_regulator: |
1557 | regulator_put(device_data->pwr_regulator); | 1543 | regulator_put(device_data->pwr_regulator); |
1558 | 1544 | ||
1559 | out_unmap: | ||
1560 | iounmap(device_data->base); | ||
1561 | |||
1562 | out_free_mem: | ||
1563 | release_mem_region(res->start, resource_size(res)); | ||
1564 | |||
1565 | out_kfree: | ||
1566 | kfree(device_data); | ||
1567 | out: | 1545 | out: |
1568 | return ret; | 1546 | return ret; |
1569 | } | 1547 | } |
1570 | 1548 | ||
1571 | static int ux500_cryp_remove(struct platform_device *pdev) | 1549 | static 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 | ||
1638 | static void ux500_cryp_shutdown(struct platform_device *pdev) | 1596 | static 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: | |||
1752 | out_clk_unprepare: | 1745 | out_clk_unprepare: |
1753 | clk_unprepare(device_data->clk); | 1746 | clk_unprepare(device_data->clk); |
1754 | 1747 | ||
1755 | out_clk: | ||
1756 | clk_put(device_data->clk); | ||
1757 | |||
1758 | out_regulator: | 1748 | out_regulator: |
1759 | regulator_put(device_data->regulator); | 1749 | regulator_put(device_data->regulator); |
1760 | 1750 | ||
1761 | out_unmap: | ||
1762 | iounmap(device_data->base); | ||
1763 | |||
1764 | out_free_mem: | ||
1765 | release_mem_region(res->start, resource_size(res)); | ||
1766 | |||
1767 | out_kfree: | ||
1768 | kfree(device_data); | ||
1769 | out: | 1751 | out: |
1770 | return ret; | 1752 | return ret; |
1771 | } | 1753 | } |
@@ -1776,7 +1758,6 @@ out: | |||
1776 | */ | 1758 | */ |
1777 | static int ux500_hash_remove(struct platform_device *pdev) | 1759 | static 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 | */ |
1837 | static void ux500_hash_shutdown(struct platform_device *pdev) | 1809 | static 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__); |