vexpress-config.c 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277
  1. /*
  2. * This program is free software; you can redistribute it and/or modify
  3. * it under the terms of the GNU General Public License version 2 as
  4. * published by the Free Software Foundation.
  5. *
  6. * This program is distributed in the hope that it will be useful,
  7. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  8. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  9. * GNU General Public License for more details.
  10. *
  11. * Copyright (C) 2012 ARM Limited
  12. */
  13. #define pr_fmt(fmt) "vexpress-config: " fmt
  14. #include <linux/bitops.h>
  15. #include <linux/completion.h>
  16. #include <linux/export.h>
  17. #include <linux/init.h>
  18. #include <linux/list.h>
  19. #include <linux/of.h>
  20. #include <linux/of_device.h>
  21. #include <linux/slab.h>
  22. #include <linux/string.h>
  23. #include <linux/vexpress.h>
  24. #define VEXPRESS_CONFIG_MAX_BRIDGES 2
  25. struct vexpress_config_bridge {
  26. struct device_node *node;
  27. struct vexpress_config_bridge_info *info;
  28. struct list_head transactions;
  29. spinlock_t transactions_lock;
  30. } vexpress_config_bridges[VEXPRESS_CONFIG_MAX_BRIDGES];
  31. static DECLARE_BITMAP(vexpress_config_bridges_map,
  32. ARRAY_SIZE(vexpress_config_bridges));
  33. static DEFINE_MUTEX(vexpress_config_bridges_mutex);
  34. struct vexpress_config_bridge *vexpress_config_bridge_register(
  35. struct device_node *node,
  36. struct vexpress_config_bridge_info *info)
  37. {
  38. struct vexpress_config_bridge *bridge;
  39. int i;
  40. pr_debug("Registering bridge '%s'\n", info->name);
  41. mutex_lock(&vexpress_config_bridges_mutex);
  42. i = find_first_zero_bit(vexpress_config_bridges_map,
  43. ARRAY_SIZE(vexpress_config_bridges));
  44. if (i >= ARRAY_SIZE(vexpress_config_bridges)) {
  45. pr_err("Can't register more bridges!\n");
  46. mutex_unlock(&vexpress_config_bridges_mutex);
  47. return NULL;
  48. }
  49. __set_bit(i, vexpress_config_bridges_map);
  50. bridge = &vexpress_config_bridges[i];
  51. bridge->node = node;
  52. bridge->info = info;
  53. INIT_LIST_HEAD(&bridge->transactions);
  54. spin_lock_init(&bridge->transactions_lock);
  55. mutex_unlock(&vexpress_config_bridges_mutex);
  56. return bridge;
  57. }
  58. void vexpress_config_bridge_unregister(struct vexpress_config_bridge *bridge)
  59. {
  60. struct vexpress_config_bridge __bridge = *bridge;
  61. int i;
  62. mutex_lock(&vexpress_config_bridges_mutex);
  63. for (i = 0; i < ARRAY_SIZE(vexpress_config_bridges); i++)
  64. if (&vexpress_config_bridges[i] == bridge)
  65. __clear_bit(i, vexpress_config_bridges_map);
  66. mutex_unlock(&vexpress_config_bridges_mutex);
  67. WARN_ON(!list_empty(&__bridge.transactions));
  68. while (!list_empty(&__bridge.transactions))
  69. cpu_relax();
  70. }
  71. struct vexpress_config_func {
  72. struct vexpress_config_bridge *bridge;
  73. void *func;
  74. };
  75. struct vexpress_config_func *__vexpress_config_func_get(struct device *dev,
  76. struct device_node *node)
  77. {
  78. struct device_node *bridge_node;
  79. struct vexpress_config_func *func;
  80. int i;
  81. if (WARN_ON(dev && node && dev->of_node != node))
  82. return NULL;
  83. if (dev && !node)
  84. node = dev->of_node;
  85. func = kzalloc(sizeof(*func), GFP_KERNEL);
  86. if (!func)
  87. return NULL;
  88. bridge_node = of_node_get(node);
  89. while (bridge_node) {
  90. const __be32 *prop = of_get_property(bridge_node,
  91. "arm,vexpress,config-bridge", NULL);
  92. if (prop) {
  93. bridge_node = of_find_node_by_phandle(
  94. be32_to_cpup(prop));
  95. break;
  96. }
  97. bridge_node = of_get_next_parent(bridge_node);
  98. }
  99. mutex_lock(&vexpress_config_bridges_mutex);
  100. for (i = 0; i < ARRAY_SIZE(vexpress_config_bridges); i++) {
  101. struct vexpress_config_bridge *bridge =
  102. &vexpress_config_bridges[i];
  103. if (test_bit(i, vexpress_config_bridges_map) &&
  104. bridge->node == bridge_node) {
  105. func->bridge = bridge;
  106. func->func = bridge->info->func_get(dev, node);
  107. break;
  108. }
  109. }
  110. mutex_unlock(&vexpress_config_bridges_mutex);
  111. if (!func->func) {
  112. of_node_put(node);
  113. kfree(func);
  114. return NULL;
  115. }
  116. return func;
  117. }
  118. void vexpress_config_func_put(struct vexpress_config_func *func)
  119. {
  120. func->bridge->info->func_put(func->func);
  121. of_node_put(func->bridge->node);
  122. kfree(func);
  123. }
  124. struct vexpress_config_trans {
  125. struct vexpress_config_func *func;
  126. int offset;
  127. bool write;
  128. u32 *data;
  129. int status;
  130. struct completion completion;
  131. struct list_head list;
  132. };
  133. static void vexpress_config_dump_trans(const char *what,
  134. struct vexpress_config_trans *trans)
  135. {
  136. pr_debug("%s %s trans %p func 0x%p offset %d data 0x%x status %d\n",
  137. what, trans->write ? "write" : "read", trans,
  138. trans->func->func, trans->offset,
  139. trans->data ? *trans->data : 0, trans->status);
  140. }
  141. static int vexpress_config_schedule(struct vexpress_config_trans *trans)
  142. {
  143. int status;
  144. struct vexpress_config_bridge *bridge = trans->func->bridge;
  145. unsigned long flags;
  146. init_completion(&trans->completion);
  147. trans->status = -EFAULT;
  148. spin_lock_irqsave(&bridge->transactions_lock, flags);
  149. vexpress_config_dump_trans("Executing", trans);
  150. if (list_empty(&bridge->transactions))
  151. status = bridge->info->func_exec(trans->func->func,
  152. trans->offset, trans->write, trans->data);
  153. else
  154. status = VEXPRESS_CONFIG_STATUS_WAIT;
  155. switch (status) {
  156. case VEXPRESS_CONFIG_STATUS_DONE:
  157. vexpress_config_dump_trans("Finished", trans);
  158. trans->status = status;
  159. break;
  160. case VEXPRESS_CONFIG_STATUS_WAIT:
  161. list_add_tail(&trans->list, &bridge->transactions);
  162. break;
  163. }
  164. spin_unlock_irqrestore(&bridge->transactions_lock, flags);
  165. return status;
  166. }
  167. void vexpress_config_complete(struct vexpress_config_bridge *bridge,
  168. int status)
  169. {
  170. struct vexpress_config_trans *trans;
  171. unsigned long flags;
  172. spin_lock_irqsave(&bridge->transactions_lock, flags);
  173. trans = list_first_entry(&bridge->transactions,
  174. struct vexpress_config_trans, list);
  175. vexpress_config_dump_trans("Completed", trans);
  176. trans->status = status;
  177. list_del(&trans->list);
  178. if (!list_empty(&bridge->transactions)) {
  179. vexpress_config_dump_trans("Pending", trans);
  180. bridge->info->func_exec(trans->func->func, trans->offset,
  181. trans->write, trans->data);
  182. }
  183. spin_unlock_irqrestore(&bridge->transactions_lock, flags);
  184. complete(&trans->completion);
  185. }
  186. int vexpress_config_wait(struct vexpress_config_trans *trans)
  187. {
  188. wait_for_completion(&trans->completion);
  189. return trans->status;
  190. }
  191. int vexpress_config_read(struct vexpress_config_func *func, int offset,
  192. u32 *data)
  193. {
  194. struct vexpress_config_trans trans = {
  195. .func = func,
  196. .offset = offset,
  197. .write = false,
  198. .data = data,
  199. .status = 0,
  200. };
  201. int status = vexpress_config_schedule(&trans);
  202. if (status == VEXPRESS_CONFIG_STATUS_WAIT)
  203. status = vexpress_config_wait(&trans);
  204. return status;
  205. }
  206. EXPORT_SYMBOL(vexpress_config_read);
  207. int vexpress_config_write(struct vexpress_config_func *func, int offset,
  208. u32 data)
  209. {
  210. struct vexpress_config_trans trans = {
  211. .func = func,
  212. .offset = offset,
  213. .write = true,
  214. .data = &data,
  215. .status = 0,
  216. };
  217. int status = vexpress_config_schedule(&trans);
  218. if (status == VEXPRESS_CONFIG_STATUS_WAIT)
  219. status = vexpress_config_wait(&trans);
  220. return status;
  221. }
  222. EXPORT_SYMBOL(vexpress_config_write);