device.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. // Copyright (c) 2018-2021 Intel Corporation
  3. #include <linux/bitfield.h>
  4. #include <linux/peci.h>
  5. #include <linux/peci-cpu.h>
  6. #include <linux/slab.h>
  7. #include "internal.h"
  8. /*
  9. * PECI device can be removed using sysfs, but the removal can also happen as
  10. * a result of controller being removed.
  11. * Mutex is used to protect PECI device from being double-deleted.
  12. */
  13. static DEFINE_MUTEX(peci_device_del_lock);
  14. #define REVISION_NUM_MASK GENMASK(15, 8)
  15. static int peci_get_revision(struct peci_device *device, u8 *revision)
  16. {
  17. struct peci_request *req;
  18. u64 dib;
  19. req = peci_xfer_get_dib(device);
  20. if (IS_ERR(req))
  21. return PTR_ERR(req);
  22. /*
  23. * PECI device may be in a state where it is unable to return a proper
  24. * DIB, in which case it returns 0 as DIB value.
  25. * Let's treat this as an error to avoid carrying on with the detection
  26. * using invalid revision.
  27. */
  28. dib = peci_request_dib_read(req);
  29. if (dib == 0) {
  30. peci_request_free(req);
  31. return -EIO;
  32. }
  33. *revision = FIELD_GET(REVISION_NUM_MASK, dib);
  34. peci_request_free(req);
  35. return 0;
  36. }
  37. static int peci_get_cpu_id(struct peci_device *device, u32 *cpu_id)
  38. {
  39. struct peci_request *req;
  40. int ret;
  41. req = peci_xfer_pkg_cfg_readl(device, PECI_PCS_PKG_ID, PECI_PKG_ID_CPU_ID);
  42. if (IS_ERR(req))
  43. return PTR_ERR(req);
  44. ret = peci_request_status(req);
  45. if (ret)
  46. goto out_req_free;
  47. *cpu_id = peci_request_data_readl(req);
  48. out_req_free:
  49. peci_request_free(req);
  50. return ret;
  51. }
  52. static unsigned int peci_x86_cpu_family(unsigned int sig)
  53. {
  54. unsigned int x86;
  55. x86 = (sig >> 8) & 0xf;
  56. if (x86 == 0xf)
  57. x86 += (sig >> 20) & 0xff;
  58. return x86;
  59. }
  60. static unsigned int peci_x86_cpu_model(unsigned int sig)
  61. {
  62. unsigned int fam, model;
  63. fam = peci_x86_cpu_family(sig);
  64. model = (sig >> 4) & 0xf;
  65. if (fam >= 0x6)
  66. model += ((sig >> 16) & 0xf) << 4;
  67. return model;
  68. }
  69. static int peci_device_info_init(struct peci_device *device)
  70. {
  71. u8 revision;
  72. u32 cpu_id;
  73. int ret;
  74. ret = peci_get_cpu_id(device, &cpu_id);
  75. if (ret)
  76. return ret;
  77. device->info.family = peci_x86_cpu_family(cpu_id);
  78. device->info.model = peci_x86_cpu_model(cpu_id);
  79. ret = peci_get_revision(device, &revision);
  80. if (ret)
  81. return ret;
  82. device->info.peci_revision = revision;
  83. device->info.socket_id = device->addr - PECI_BASE_ADDR;
  84. return 0;
  85. }
  86. static int peci_detect(struct peci_controller *controller, u8 addr)
  87. {
  88. /*
  89. * PECI Ping is a command encoded by tx_len = 0, rx_len = 0.
  90. * We expect correct Write FCS if the device at the target address
  91. * is able to respond.
  92. */
  93. struct peci_request req = { 0 };
  94. int ret;
  95. mutex_lock(&controller->bus_lock);
  96. ret = controller->ops->xfer(controller, addr, &req);
  97. mutex_unlock(&controller->bus_lock);
  98. return ret;
  99. }
  100. static bool peci_addr_valid(u8 addr)
  101. {
  102. return addr >= PECI_BASE_ADDR && addr < PECI_BASE_ADDR + PECI_DEVICE_NUM_MAX;
  103. }
  104. static int peci_dev_exists(struct device *dev, void *data)
  105. {
  106. struct peci_device *device = to_peci_device(dev);
  107. u8 *addr = data;
  108. if (device->addr == *addr)
  109. return -EBUSY;
  110. return 0;
  111. }
  112. int peci_device_create(struct peci_controller *controller, u8 addr)
  113. {
  114. struct peci_device *device;
  115. int ret;
  116. if (!peci_addr_valid(addr))
  117. return -EINVAL;
  118. /* Check if we have already detected this device before. */
  119. ret = device_for_each_child(&controller->dev, &addr, peci_dev_exists);
  120. if (ret)
  121. return 0;
  122. ret = peci_detect(controller, addr);
  123. if (ret) {
  124. /*
  125. * Device not present or host state doesn't allow successful
  126. * detection at this time.
  127. */
  128. if (ret == -EIO || ret == -ETIMEDOUT)
  129. return 0;
  130. return ret;
  131. }
  132. device = kzalloc(sizeof(*device), GFP_KERNEL);
  133. if (!device)
  134. return -ENOMEM;
  135. device_initialize(&device->dev);
  136. device->addr = addr;
  137. device->dev.parent = &controller->dev;
  138. device->dev.bus = &peci_bus_type;
  139. device->dev.type = &peci_device_type;
  140. ret = peci_device_info_init(device);
  141. if (ret)
  142. goto err_put;
  143. ret = dev_set_name(&device->dev, "%d-%02x", controller->id, device->addr);
  144. if (ret)
  145. goto err_put;
  146. ret = device_add(&device->dev);
  147. if (ret)
  148. goto err_put;
  149. return 0;
  150. err_put:
  151. put_device(&device->dev);
  152. return ret;
  153. }
  154. void peci_device_destroy(struct peci_device *device)
  155. {
  156. mutex_lock(&peci_device_del_lock);
  157. if (!device->deleted) {
  158. device_unregister(&device->dev);
  159. device->deleted = true;
  160. }
  161. mutex_unlock(&peci_device_del_lock);
  162. }
  163. int __peci_driver_register(struct peci_driver *driver, struct module *owner,
  164. const char *mod_name)
  165. {
  166. driver->driver.bus = &peci_bus_type;
  167. driver->driver.owner = owner;
  168. driver->driver.mod_name = mod_name;
  169. if (!driver->probe) {
  170. pr_err("peci: trying to register driver without probe callback\n");
  171. return -EINVAL;
  172. }
  173. if (!driver->id_table) {
  174. pr_err("peci: trying to register driver without device id table\n");
  175. return -EINVAL;
  176. }
  177. return driver_register(&driver->driver);
  178. }
  179. EXPORT_SYMBOL_NS_GPL(__peci_driver_register, PECI);
  180. void peci_driver_unregister(struct peci_driver *driver)
  181. {
  182. driver_unregister(&driver->driver);
  183. }
  184. EXPORT_SYMBOL_NS_GPL(peci_driver_unregister, PECI);
  185. static void peci_device_release(struct device *dev)
  186. {
  187. struct peci_device *device = to_peci_device(dev);
  188. kfree(device);
  189. }
  190. struct device_type peci_device_type = {
  191. .groups = peci_device_groups,
  192. .release = peci_device_release,
  193. };