drivers/peci/device.c

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