cxl/test/mock.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 //Copyright(c) 2021 Intel Corporation. All rights reserved.
0003
0004 #include <linux/libnvdimm.h>
0005 #include <linux/rculist.h>
0006 #include <linux/device.h>
0007 #include <linux/export.h>
0008 #include <linux/acpi.h>
0009 #include <linux/pci.h>
0010 #include <cxlmem.h>
0011 #include <cxlpci.h>
0012 #include "mock.h"
0013
0014 static LIST_HEAD(mock);
0015
0016 void register_cxl_mock_ops(struct cxl_mock_ops *ops)
0017 {
0018     list_add_rcu(&ops->list, &mock);
0019 }
0020 EXPORT_SYMBOL_GPL(register_cxl_mock_ops);
0021
0022 static DEFINE_SRCU(cxl_mock_srcu);
0023
0024 void unregister_cxl_mock_ops(struct cxl_mock_ops *ops)
0025 {
0026     list_del_rcu(&ops->list);
0027     synchronize_srcu(&cxl_mock_srcu);
0028 }
0029 EXPORT_SYMBOL_GPL(unregister_cxl_mock_ops);
0030
0031 struct cxl_mock_ops *get_cxl_mock_ops(int *index)
0032 {
0033     *index = srcu_read_lock(&cxl_mock_srcu);
0034     return list_first_or_null_rcu(&mock, struct cxl_mock_ops, list);
0035 }
0036 EXPORT_SYMBOL_GPL(get_cxl_mock_ops);
0037
0038 void put_cxl_mock_ops(int index)
0039 {
0040     srcu_read_unlock(&cxl_mock_srcu, index);
0041 }
0042 EXPORT_SYMBOL_GPL(put_cxl_mock_ops);
0043
0044 bool __wrap_is_acpi_device_node(const struct fwnode_handle *fwnode)
0045 {
0046     struct acpi_device *adev =
0047         container_of(fwnode, struct acpi_device, fwnode);
0048     int index;
0049     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0050     bool retval = false;
0051
0052     if (ops)
0053         retval = ops->is_mock_adev(adev);
0054
0055     if (!retval)
0056         retval = is_acpi_device_node(fwnode);
0057
0058     put_cxl_mock_ops(index);
0059     return retval;
0060 }
0061 EXPORT_SYMBOL(__wrap_is_acpi_device_node);
0062
0063 int __wrap_acpi_table_parse_cedt(enum acpi_cedt_type id,
0064                  acpi_tbl_entry_handler_arg handler_arg,
0065                  void *arg)
0066 {
0067     int index, rc;
0068     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0069
0070     if (ops)
0071         rc = ops->acpi_table_parse_cedt(id, handler_arg, arg);
0072     else
0073         rc = acpi_table_parse_cedt(id, handler_arg, arg);
0074
0075     put_cxl_mock_ops(index);
0076
0077     return rc;
0078 }
0079 EXPORT_SYMBOL_NS_GPL(__wrap_acpi_table_parse_cedt, ACPI);
0080
0081 acpi_status __wrap_acpi_evaluate_integer(acpi_handle handle,
0082                      acpi_string pathname,
0083                      struct acpi_object_list *arguments,
0084                      unsigned long long *data)
0085 {
0086     int index;
0087     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0088     acpi_status status;
0089
0090     if (ops)
0091         status = ops->acpi_evaluate_integer(handle, pathname, arguments,
0092                             data);
0093     else
0094         status = acpi_evaluate_integer(handle, pathname, arguments,
0095                            data);
0096     put_cxl_mock_ops(index);
0097
0098     return status;
0099 }
0100 EXPORT_SYMBOL(__wrap_acpi_evaluate_integer);
0101
0102 struct acpi_pci_root *__wrap_acpi_pci_find_root(acpi_handle handle)
0103 {
0104     int index;
0105     struct acpi_pci_root *root;
0106     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0107
0108     if (ops)
0109         root = ops->acpi_pci_find_root(handle);
0110     else
0111         root = acpi_pci_find_root(handle);
0112
0113     put_cxl_mock_ops(index);
0114
0115     return root;
0116 }
0117 EXPORT_SYMBOL_GPL(__wrap_acpi_pci_find_root);
0118
0119 struct nvdimm_bus *
0120 __wrap_nvdimm_bus_register(struct device *dev,
0121                struct nvdimm_bus_descriptor *nd_desc)
0122 {
0123     int index;
0124     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0125
0126     if (ops && ops->is_mock_dev(dev->parent->parent))
0127         nd_desc->provider_name = "cxl_test";
0128     put_cxl_mock_ops(index);
0129
0130     return nvdimm_bus_register(dev, nd_desc);
0131 }
0132 EXPORT_SYMBOL_GPL(__wrap_nvdimm_bus_register);
0133
0134 struct cxl_hdm *__wrap_devm_cxl_setup_hdm(struct cxl_port *port)
0135 {
0136     int index;
0137     struct cxl_hdm *cxlhdm;
0138     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0139
0140     if (ops && ops->is_mock_port(port->uport))
0141         cxlhdm = ops->devm_cxl_setup_hdm(port);
0142     else
0143         cxlhdm = devm_cxl_setup_hdm(port);
0144     put_cxl_mock_ops(index);
0145
0146     return cxlhdm;
0147 }
0148 EXPORT_SYMBOL_NS_GPL(__wrap_devm_cxl_setup_hdm, CXL);
0149
0150 int __wrap_devm_cxl_add_passthrough_decoder(struct cxl_port *port)
0151 {
0152     int rc, index;
0153     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0154
0155     if (ops && ops->is_mock_port(port->uport))
0156         rc = ops->devm_cxl_add_passthrough_decoder(port);
0157     else
0158         rc = devm_cxl_add_passthrough_decoder(port);
0159     put_cxl_mock_ops(index);
0160
0161     return rc;
0162 }
0163 EXPORT_SYMBOL_NS_GPL(__wrap_devm_cxl_add_passthrough_decoder, CXL);
0164
0165 int __wrap_devm_cxl_enumerate_decoders(struct cxl_hdm *cxlhdm)
0166 {
0167     int rc, index;
0168     struct cxl_port *port = cxlhdm->port;
0169     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0170
0171     if (ops && ops->is_mock_port(port->uport))
0172         rc = ops->devm_cxl_enumerate_decoders(cxlhdm);
0173     else
0174         rc = devm_cxl_enumerate_decoders(cxlhdm);
0175     put_cxl_mock_ops(index);
0176
0177     return rc;
0178 }
0179 EXPORT_SYMBOL_NS_GPL(__wrap_devm_cxl_enumerate_decoders, CXL);
0180
0181 int __wrap_devm_cxl_port_enumerate_dports(struct cxl_port *port)
0182 {
0183     int rc, index;
0184     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0185
0186     if (ops && ops->is_mock_port(port->uport))
0187         rc = ops->devm_cxl_port_enumerate_dports(port);
0188     else
0189         rc = devm_cxl_port_enumerate_dports(port);
0190     put_cxl_mock_ops(index);
0191
0192     return rc;
0193 }
0194 EXPORT_SYMBOL_NS_GPL(__wrap_devm_cxl_port_enumerate_dports, CXL);
0195
0196 int __wrap_cxl_await_media_ready(struct cxl_dev_state *cxlds)
0197 {
0198     int rc, index;
0199     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0200
0201     if (ops && ops->is_mock_dev(cxlds->dev))
0202         rc = 0;
0203     else
0204         rc = cxl_await_media_ready(cxlds);
0205     put_cxl_mock_ops(index);
0206
0207     return rc;
0208 }
0209 EXPORT_SYMBOL_NS_GPL(__wrap_cxl_await_media_ready, CXL);
0210
0211 int __wrap_cxl_hdm_decode_init(struct cxl_dev_state *cxlds,
0212                    struct cxl_hdm *cxlhdm)
0213 {
0214     int rc = 0, index;
0215     struct cxl_mock_ops *ops = get_cxl_mock_ops(&index);
0216
0217     if (ops && ops->is_mock_dev(cxlds->dev))
0218         rc = 0;
0219     else
0220         rc = cxl_hdm_decode_init(cxlds, cxlhdm);
0221     put_cxl_mock_ops(index);
0222
0223     return rc;
0224 }
0225 EXPORT_SYMBOL_NS_GPL(__wrap_cxl_hdm_decode_init, CXL);
0226
0227 MODULE_LICENSE("GPL v2");
0228 MODULE_IMPORT_NS(ACPI);
0229 MODULE_IMPORT_NS(CXL);