hvapi.c 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* hvapi.c: Hypervisor API management.
  3. *
  4. * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
  5. */
  6. #include <linux/kernel.h>
  7. #include <linux/export.h>
  8. #include <linux/init.h>
  9. #include <asm/hypervisor.h>
  10. #include <asm/oplib.h>
  11. /* If the hypervisor indicates that the API setting
  12. * calls are unsupported, by returning HV_EBADTRAP or
  13. * HV_ENOTSUPPORTED, we assume that API groups with the
  14. * PRE_API flag set are major 1 minor 0.
  15. */
  16. struct api_info {
  17. unsigned long group;
  18. unsigned long major;
  19. unsigned long minor;
  20. unsigned int refcnt;
  21. unsigned int flags;
  22. #define FLAG_PRE_API 0x00000001
  23. };
  24. static struct api_info api_table[] = {
  25. { .group = HV_GRP_SUN4V, .flags = FLAG_PRE_API },
  26. { .group = HV_GRP_CORE, .flags = FLAG_PRE_API },
  27. { .group = HV_GRP_INTR, },
  28. { .group = HV_GRP_SOFT_STATE, },
  29. { .group = HV_GRP_TM, },
  30. { .group = HV_GRP_PCI, .flags = FLAG_PRE_API },
  31. { .group = HV_GRP_LDOM, },
  32. { .group = HV_GRP_SVC_CHAN, .flags = FLAG_PRE_API },
  33. { .group = HV_GRP_NCS, .flags = FLAG_PRE_API },
  34. { .group = HV_GRP_RNG, },
  35. { .group = HV_GRP_PBOOT, },
  36. { .group = HV_GRP_TPM, },
  37. { .group = HV_GRP_SDIO, },
  38. { .group = HV_GRP_SDIO_ERR, },
  39. { .group = HV_GRP_REBOOT_DATA, },
  40. { .group = HV_GRP_ATU, .flags = FLAG_PRE_API },
  41. { .group = HV_GRP_DAX, },
  42. { .group = HV_GRP_NIAG_PERF, .flags = FLAG_PRE_API },
  43. { .group = HV_GRP_FIRE_PERF, },
  44. { .group = HV_GRP_N2_CPU, },
  45. { .group = HV_GRP_NIU, },
  46. { .group = HV_GRP_VF_CPU, },
  47. { .group = HV_GRP_KT_CPU, },
  48. { .group = HV_GRP_VT_CPU, },
  49. { .group = HV_GRP_T5_CPU, },
  50. { .group = HV_GRP_DIAG, .flags = FLAG_PRE_API },
  51. { .group = HV_GRP_M7_PERF, },
  52. };
  53. static DEFINE_SPINLOCK(hvapi_lock);
  54. static struct api_info *__get_info(unsigned long group)
  55. {
  56. int i;
  57. for (i = 0; i < ARRAY_SIZE(api_table); i++) {
  58. if (api_table[i].group == group)
  59. return &api_table[i];
  60. }
  61. return NULL;
  62. }
  63. static void __get_ref(struct api_info *p)
  64. {
  65. p->refcnt++;
  66. }
  67. static void __put_ref(struct api_info *p)
  68. {
  69. if (--p->refcnt == 0) {
  70. unsigned long ignore;
  71. sun4v_set_version(p->group, 0, 0, &ignore);
  72. p->major = p->minor = 0;
  73. }
  74. }
  75. /* Register a hypervisor API specification. It indicates the
  76. * API group and desired major+minor.
  77. *
  78. * If an existing API registration exists '0' (success) will
  79. * be returned if it is compatible with the one being registered.
  80. * Otherwise a negative error code will be returned.
  81. *
  82. * Otherwise an attempt will be made to negotiate the requested
  83. * API group/major/minor with the hypervisor, and errors returned
  84. * if that does not succeed.
  85. */
  86. int sun4v_hvapi_register(unsigned long group, unsigned long major,
  87. unsigned long *minor)
  88. {
  89. struct api_info *p;
  90. unsigned long flags;
  91. int ret;
  92. spin_lock_irqsave(&hvapi_lock, flags);
  93. p = __get_info(group);
  94. ret = -EINVAL;
  95. if (p) {
  96. if (p->refcnt) {
  97. ret = -EINVAL;
  98. if (p->major == major) {
  99. *minor = p->minor;
  100. ret = 0;
  101. }
  102. } else {
  103. unsigned long actual_minor;
  104. unsigned long hv_ret;
  105. hv_ret = sun4v_set_version(group, major, *minor,
  106. &actual_minor);
  107. ret = -EINVAL;
  108. if (hv_ret == HV_EOK) {
  109. *minor = actual_minor;
  110. p->major = major;
  111. p->minor = actual_minor;
  112. ret = 0;
  113. } else if (hv_ret == HV_EBADTRAP ||
  114. hv_ret == HV_ENOTSUPPORTED) {
  115. if (p->flags & FLAG_PRE_API) {
  116. if (major == 1) {
  117. p->major = 1;
  118. p->minor = 0;
  119. *minor = 0;
  120. ret = 0;
  121. }
  122. }
  123. }
  124. }
  125. if (ret == 0)
  126. __get_ref(p);
  127. }
  128. spin_unlock_irqrestore(&hvapi_lock, flags);
  129. return ret;
  130. }
  131. EXPORT_SYMBOL(sun4v_hvapi_register);
  132. void sun4v_hvapi_unregister(unsigned long group)
  133. {
  134. struct api_info *p;
  135. unsigned long flags;
  136. spin_lock_irqsave(&hvapi_lock, flags);
  137. p = __get_info(group);
  138. if (p)
  139. __put_ref(p);
  140. spin_unlock_irqrestore(&hvapi_lock, flags);
  141. }
  142. EXPORT_SYMBOL(sun4v_hvapi_unregister);
  143. int sun4v_hvapi_get(unsigned long group,
  144. unsigned long *major,
  145. unsigned long *minor)
  146. {
  147. struct api_info *p;
  148. unsigned long flags;
  149. int ret;
  150. spin_lock_irqsave(&hvapi_lock, flags);
  151. ret = -EINVAL;
  152. p = __get_info(group);
  153. if (p && p->refcnt) {
  154. *major = p->major;
  155. *minor = p->minor;
  156. ret = 0;
  157. }
  158. spin_unlock_irqrestore(&hvapi_lock, flags);
  159. return ret;
  160. }
  161. EXPORT_SYMBOL(sun4v_hvapi_get);
  162. void __init sun4v_hvapi_init(void)
  163. {
  164. unsigned long group, major, minor;
  165. group = HV_GRP_SUN4V;
  166. major = 1;
  167. minor = 0;
  168. if (sun4v_hvapi_register(group, major, &minor))
  169. goto bad;
  170. group = HV_GRP_CORE;
  171. major = 1;
  172. minor = 6;
  173. if (sun4v_hvapi_register(group, major, &minor))
  174. goto bad;
  175. return;
  176. bad:
  177. prom_printf("HVAPI: Cannot register API group "
  178. "%lx with major(%lu) minor(%lu)\n",
  179. group, major, minor);
  180. prom_halt();
  181. }