sprd_hwspinlock.c 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Spreadtrum hardware spinlock driver
  4. * Copyright (C) 2017 Spreadtrum - http://www.spreadtrum.com
  5. */
  6. #include <linux/bitops.h>
  7. #include <linux/clk.h>
  8. #include <linux/delay.h>
  9. #include <linux/device.h>
  10. #include <linux/hwspinlock.h>
  11. #include <linux/io.h>
  12. #include <linux/kernel.h>
  13. #include <linux/module.h>
  14. #include <linux/of.h>
  15. #include <linux/of_device.h>
  16. #include <linux/platform_device.h>
  17. #include <linux/slab.h>
  18. #include "hwspinlock_internal.h"
  19. /* hwspinlock registers definition */
  20. #define HWSPINLOCK_RECCTRL 0x4
  21. #define HWSPINLOCK_MASTERID(_X_) (0x80 + 0x4 * (_X_))
  22. #define HWSPINLOCK_TOKEN(_X_) (0x800 + 0x4 * (_X_))
  23. /* unlocked value */
  24. #define HWSPINLOCK_NOTTAKEN 0x55aa10c5
  25. /* bits definition of RECCTRL reg */
  26. #define HWSPINLOCK_USER_BITS 0x1
  27. /* hwspinlock number */
  28. #define SPRD_HWLOCKS_NUM 32
  29. struct sprd_hwspinlock_dev {
  30. void __iomem *base;
  31. struct clk *clk;
  32. struct hwspinlock_device bank;
  33. };
  34. /* try to lock the hardware spinlock */
  35. static int sprd_hwspinlock_trylock(struct hwspinlock *lock)
  36. {
  37. struct sprd_hwspinlock_dev *sprd_hwlock =
  38. dev_get_drvdata(lock->bank->dev);
  39. void __iomem *addr = lock->priv;
  40. int user_id, lock_id;
  41. if (!readl(addr))
  42. return 1;
  43. lock_id = hwlock_to_id(lock);
  44. /* get the hardware spinlock master/user id */
  45. user_id = readl(sprd_hwlock->base + HWSPINLOCK_MASTERID(lock_id));
  46. dev_warn(sprd_hwlock->bank.dev,
  47. "hwspinlock [%d] lock failed and master/user id = %d!\n",
  48. lock_id, user_id);
  49. return 0;
  50. }
  51. /* unlock the hardware spinlock */
  52. static void sprd_hwspinlock_unlock(struct hwspinlock *lock)
  53. {
  54. void __iomem *lock_addr = lock->priv;
  55. writel(HWSPINLOCK_NOTTAKEN, lock_addr);
  56. }
  57. /* The specs recommended below number as the retry delay time */
  58. static void sprd_hwspinlock_relax(struct hwspinlock *lock)
  59. {
  60. ndelay(10);
  61. }
  62. static const struct hwspinlock_ops sprd_hwspinlock_ops = {
  63. .trylock = sprd_hwspinlock_trylock,
  64. .unlock = sprd_hwspinlock_unlock,
  65. .relax = sprd_hwspinlock_relax,
  66. };
  67. static void sprd_hwspinlock_disable(void *data)
  68. {
  69. struct sprd_hwspinlock_dev *sprd_hwlock = data;
  70. clk_disable_unprepare(sprd_hwlock->clk);
  71. }
  72. static int sprd_hwspinlock_probe(struct platform_device *pdev)
  73. {
  74. struct sprd_hwspinlock_dev *sprd_hwlock;
  75. struct hwspinlock *lock;
  76. int i, ret;
  77. if (!pdev->dev.of_node)
  78. return -ENODEV;
  79. sprd_hwlock = devm_kzalloc(&pdev->dev,
  80. sizeof(struct sprd_hwspinlock_dev) +
  81. SPRD_HWLOCKS_NUM * sizeof(*lock),
  82. GFP_KERNEL);
  83. if (!sprd_hwlock)
  84. return -ENOMEM;
  85. sprd_hwlock->base = devm_platform_ioremap_resource(pdev, 0);
  86. if (IS_ERR(sprd_hwlock->base))
  87. return PTR_ERR(sprd_hwlock->base);
  88. sprd_hwlock->clk = devm_clk_get(&pdev->dev, "enable");
  89. if (IS_ERR(sprd_hwlock->clk)) {
  90. dev_err(&pdev->dev, "get hwspinlock clock failed!\n");
  91. return PTR_ERR(sprd_hwlock->clk);
  92. }
  93. ret = clk_prepare_enable(sprd_hwlock->clk);
  94. if (ret)
  95. return ret;
  96. ret = devm_add_action_or_reset(&pdev->dev, sprd_hwspinlock_disable,
  97. sprd_hwlock);
  98. if (ret) {
  99. dev_err(&pdev->dev,
  100. "Failed to add hwspinlock disable action\n");
  101. return ret;
  102. }
  103. /* set the hwspinlock to record user id to identify subsystems */
  104. writel(HWSPINLOCK_USER_BITS, sprd_hwlock->base + HWSPINLOCK_RECCTRL);
  105. for (i = 0; i < SPRD_HWLOCKS_NUM; i++) {
  106. lock = &sprd_hwlock->bank.lock[i];
  107. lock->priv = sprd_hwlock->base + HWSPINLOCK_TOKEN(i);
  108. }
  109. platform_set_drvdata(pdev, sprd_hwlock);
  110. return devm_hwspin_lock_register(&pdev->dev, &sprd_hwlock->bank,
  111. &sprd_hwspinlock_ops, 0,
  112. SPRD_HWLOCKS_NUM);
  113. }
  114. static const struct of_device_id sprd_hwspinlock_of_match[] = {
  115. { .compatible = "sprd,hwspinlock-r3p0", },
  116. { /* sentinel */ }
  117. };
  118. MODULE_DEVICE_TABLE(of, sprd_hwspinlock_of_match);
  119. static struct platform_driver sprd_hwspinlock_driver = {
  120. .probe = sprd_hwspinlock_probe,
  121. .driver = {
  122. .name = "sprd_hwspinlock",
  123. .of_match_table = of_match_ptr(sprd_hwspinlock_of_match),
  124. },
  125. };
  126. static int __init sprd_hwspinlock_init(void)
  127. {
  128. return platform_driver_register(&sprd_hwspinlock_driver);
  129. }
  130. postcore_initcall(sprd_hwspinlock_init);
  131. static void __exit sprd_hwspinlock_exit(void)
  132. {
  133. platform_driver_unregister(&sprd_hwspinlock_driver);
  134. }
  135. module_exit(sprd_hwspinlock_exit);
  136. MODULE_LICENSE("GPL v2");
  137. MODULE_DESCRIPTION("Hardware spinlock driver for Spreadtrum");
  138. MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");
  139. MODULE_AUTHOR("Lanqing Liu <lanqing.liu@spreadtrum.com>");
  140. MODULE_AUTHOR("Long Cheng <aiden.cheng@spreadtrum.com>");