#include <linux/acpi.h>
#include <linux/cleanup.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/hashtable.h>
#include <linux/io.h>
#include <linux/limits.h>
#include <linux/list.h>
#include <linux/mailbox_client.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <acpi/pcc.h>
#include "../common.h"
#define SCMI_TRANSPORT_PACKAGE_MAX_VERSION (1)
#define SCMI_PROTOCOL_PACKAGE_MAX_VERSION (1)
#define SCMI_TRANSPORT_SHARED_CHANNEL BIT_ULL(0)
#define SCMI_TRANSPORT_P2A_CHANNEL BIT_ULL(1)
#define SCMI_TRANSPORT_FLAGS_MASK (SCMI_TRANSPORT_SHARED_CHANNEL | \
SCMI_TRANSPORT_P2A_CHANNEL)
#define SCMI_DSD_GUID_ENTRY_COUNT 2
#define SCMI_PROTOCOL_MAX_TRANSPORTS 2
enum scmi_dsd_property_index {
SCMI_DSD_PROPERTY_NAME,
SCMI_DSD_PROPERTY_VALUE,
SCMI_DSD_PROPERTY_COUNT,
};
enum scmi_pcc_transport_index {
SCMI_PCC_TRANSPORT_REVISION,
SCMI_PCC_TRANSPORT_COUNT,
SCMI_PCC_TRANSPORT_DESCRIPTORS,
};
enum scmi_pcc_descriptor_index {
SCMI_PCC_DESCRIPTOR_PCCT_INDEX,
SCMI_PCC_DESCRIPTOR_TRANSPORT_UID,
SCMI_PCC_DESCRIPTOR_FLAGS,
SCMI_PCC_DESCRIPTOR_COUNT,
};
enum scmi_protocol_property_index {
SCMI_PROTOCOL_PROPERTY_REVISION,
SCMI_PROTOCOL_PROPERTY_TRANSPORTS,
SCMI_PROTOCOL_PROPERTY_ASSOCIATIONS,
SCMI_PROTOCOL_PROPERTY_COUNT,
};
enum scmi_protocol_transport_index {
SCMI_PROTOCOL_TRANSPORT_UID,
SCMI_PROTOCOL_TRANSPORT_FLAGS,
SCMI_PROTOCOL_TRANSPORT_COUNT,
};
struct pcc_shared_mem {
struct acpi_pcct_ext_pcc_shared_memory header;
u8 msg_payload[];
};
#define SCMI_PCC_MSG_HEADER_SIZE sizeof(u32)
#define SCMI_PCC_STATUS_SIZE sizeof(u32)
#define SCMI_PCC_RESPONSE_OVERHEAD (SCMI_PCC_MSG_HEADER_SIZE + \
SCMI_PCC_STATUS_SIZE)
#define SCMI_PCC_SHMEM_OVERHEAD (sizeof(struct pcc_shared_mem) + \
SCMI_PCC_STATUS_SIZE)
struct scmi_pcc {
struct mbox_client cl;
struct pcc_mbox_chan *pchan;
struct scmi_chan_info *cinfo;
};
struct pcc_transport {
u64 uid;
u64 flags;
u32 pcc_ss_id;
u32 protocol_id;
struct hlist_node hnode;
};
struct pcc_transport_map {
struct fwnode_handle *fwnode;
struct device *dev;
struct list_head node;
DECLARE_HASHTABLE(table, ilog2(MAX_PCC_SUBSPACES / 8));
};
#define client_to_scmi_pcc(c) container_of(c, struct scmi_pcc, cl)
static struct scmi_transport_core_operations *core;
static LIST_HEAD(pcc_transport_maps);
static DEFINE_MUTEX(pcc_transport_maps_lock);
static void acpi_scmi_clear_transport_map(struct pcc_transport_map *map)
{
struct pcc_transport *p;
struct hlist_node *tmp;
int idx;
hash_for_each_safe(map->table, idx, tmp, p, hnode) {
hash_del(&p->hnode);
kfree(p);
}
}
static void acpi_scmi_destroy_transport_map(struct pcc_transport_map *map)
{
acpi_scmi_clear_transport_map(map);
if (map->fwnode)
fwnode_handle_put(map->fwnode);
kfree(map);
}
static void pcc_transport_map_release(void *data)
{
struct pcc_transport_map *map = data;
guard(mutex)(&pcc_transport_maps_lock);
list_del(&map->node);
acpi_scmi_destroy_transport_map(map);
}
static void acpi_scmi_clear_transport_maps(void)
{
struct pcc_transport_map *map, *tmp;
guard(mutex)(&pcc_transport_maps_lock);
list_for_each_entry_safe(map, tmp, &pcc_transport_maps, node) {
list_del(&map->node);
acpi_scmi_destroy_transport_map(map);
}
}
static const union acpi_object *
acpi_scmi_pkg_elements(const union acpi_object *obj, unsigned int count)
{
if (obj->type != ACPI_TYPE_PACKAGE || obj->package.count != count)
return NULL;
return obj->package.elements;
}
static int
acpi_scmi_pkg_u64(const union acpi_object *pkg, unsigned int idx, u64 *val)
{
const union acpi_object *elem = &pkg->package.elements[idx];
if (elem->type != ACPI_TYPE_INTEGER)
return -EINVAL;
*val = elem->integer.value;
return 0;
}
static int acpi_scmi_property(const union acpi_object *properties,
unsigned int idx, const char **name,
const union acpi_object **value)
{
const union acpi_object *property;
const union acpi_object *elems;
property = &properties->package.elements[idx];
elems = acpi_scmi_pkg_elements(property, SCMI_DSD_PROPERTY_COUNT);
if (!elems)
return -EINVAL;
if (elems[SCMI_DSD_PROPERTY_NAME].type != ACPI_TYPE_STRING ||
!elems[SCMI_DSD_PROPERTY_NAME].string.pointer)
return -EINVAL;
*name = elems[SCMI_DSD_PROPERTY_NAME].string.pointer;
*value = &elems[SCMI_DSD_PROPERTY_VALUE];
return 0;
}
static int
acpi_scmi_dsd_parse_transport_package(struct pcc_transport_map *map,
const union acpi_object *obj)
{
u64 revision, pkg_cnt;
bool common_a2p = false, common_p2a = false;
if (obj->type != ACPI_TYPE_PACKAGE ||
obj->package.count < SCMI_PCC_TRANSPORT_DESCRIPTORS ||
acpi_scmi_pkg_u64(obj, SCMI_PCC_TRANSPORT_REVISION, &revision) ||
acpi_scmi_pkg_u64(obj, SCMI_PCC_TRANSPORT_COUNT, &pkg_cnt))
return -EINVAL;
if (revision != SCMI_TRANSPORT_PACKAGE_MAX_VERSION)
return -EINVAL;
if (pkg_cnt != obj->package.count - SCMI_PCC_TRANSPORT_DESCRIPTORS)
return -EINVAL;
for (u32 idx = 0; idx < pkg_cnt; idx++) {
struct pcc_transport *p, *tmp;
union acpi_object *pack;
u64 pcc_ss_id, uid, flags;
pack = &obj->package.elements[idx +
SCMI_PCC_TRANSPORT_DESCRIPTORS];
if (!acpi_scmi_pkg_elements(pack, SCMI_PCC_DESCRIPTOR_COUNT)) {
pr_info("Invalid transport properties pkg %u\n", idx);
return -EINVAL;
}
if (acpi_scmi_pkg_u64(pack, SCMI_PCC_DESCRIPTOR_PCCT_INDEX,
&pcc_ss_id) ||
acpi_scmi_pkg_u64(pack, SCMI_PCC_DESCRIPTOR_TRANSPORT_UID,
&uid) ||
acpi_scmi_pkg_u64(pack, SCMI_PCC_DESCRIPTOR_FLAGS, &flags))
return -EINVAL;
if (pcc_ss_id > INT_MAX ||
flags & ~SCMI_TRANSPORT_FLAGS_MASK)
return -EINVAL;
hash_for_each_possible(map->table, tmp, hnode, uid) {
if (tmp->uid == uid) {
pr_info("Duplicate UID %llu\n", uid);
return -EEXIST;
}
}
if (flags & SCMI_TRANSPORT_SHARED_CHANNEL) {
if (flags & SCMI_TRANSPORT_P2A_CHANNEL) {
if (common_p2a)
return -EINVAL;
common_p2a = true;
} else {
if (common_a2p)
return -EINVAL;
common_a2p = true;
}
}
p = kzalloc_obj(*p);
if (!p)
return -ENOMEM;
p->uid = uid;
p->pcc_ss_id = pcc_ss_id;
p->flags = flags;
if (p->flags & SCMI_TRANSPORT_SHARED_CHANNEL)
p->protocol_id = SCMI_PROTOCOL_BASE;
hash_add(map->table, &p->hnode, uid);
}
if (!common_a2p)
return -EINVAL;
return 0;
}
static int
acpi_scmi_dsd_parse_protocol_subpackage(struct pcc_transport_map *map,
const union acpi_object *obj,
int prot_id)
{
struct pcc_transport *p;
unsigned int pkg_cnt = obj->package.count;
bool found, tx_found = false, rx_found = false;
u64 uid;
if (pkg_cnt > SCMI_PROTOCOL_MAX_TRANSPORTS) {
pr_warn("Found %u protocol channels, at most %u allowed\n",
pkg_cnt, SCMI_PROTOCOL_MAX_TRANSPORTS);
return -EINVAL;
}
for (u32 idx = 0; idx < pkg_cnt; idx++) {
union acpi_object *pack = &obj->package.elements[idx];
u64 flags;
if (!acpi_scmi_pkg_elements(pack, SCMI_PROTOCOL_TRANSPORT_COUNT) ||
acpi_scmi_pkg_u64(pack, SCMI_PROTOCOL_TRANSPORT_UID, &uid) ||
acpi_scmi_pkg_u64(pack, SCMI_PROTOCOL_TRANSPORT_FLAGS,
&flags))
return -EINVAL;
if (flags)
return -EINVAL;
found = false;
hash_for_each_possible(map->table, p, hnode, uid) {
if (p->uid != uid)
continue;
found = true;
if (p->flags & SCMI_TRANSPORT_SHARED_CHANNEL) {
pr_info("Protocol package references common PCC subspace %u\n",
p->pcc_ss_id);
return -EINVAL;
}
if (p->protocol_id && p->protocol_id != prot_id)
return -EINVAL;
if (p->flags & SCMI_TRANSPORT_P2A_CHANNEL) {
if (rx_found)
return -EINVAL;
rx_found = true;
} else {
if (tx_found)
return -EINVAL;
tx_found = true;
}
p->protocol_id = prot_id;
break;
}
if (!found)
return -ENOENT;
}
return 0;
}
static int
acpi_scmi_dsd_parse_protocol_package(struct pcc_transport_map *map,
const union acpi_object *obj, int prot_id)
{
const union acpi_object *elems;
const union acpi_object *pack;
u64 revision;
int ret;
elems = acpi_scmi_pkg_elements(obj, SCMI_PROTOCOL_PROPERTY_COUNT);
if (!elems ||
acpi_scmi_pkg_u64(obj, SCMI_PROTOCOL_PROPERTY_REVISION, &revision))
return -EINVAL;
pack = &elems[SCMI_PROTOCOL_PROPERTY_TRANSPORTS];
if (revision != SCMI_PROTOCOL_PACKAGE_MAX_VERSION)
return -EINVAL;
if (pack->type != ACPI_TYPE_PACKAGE) {
pr_info("Invalid protocol transport package\n");
return -EINVAL;
}
if (pack->package.count != 0) {
ret = acpi_scmi_dsd_parse_protocol_subpackage(map, pack, prot_id);
if (ret)
return ret;
}
pack = &elems[SCMI_PROTOCOL_PROPERTY_ASSOCIATIONS];
if (pack->type != ACPI_TYPE_PACKAGE) {
pr_info("Invalid protocol transport association package\n");
return -EINVAL;
}
if (pack->package.count != 0) {
pr_info("Non-empty association package not supported\n");
return -EINVAL;
}
return 0;
}
static const guid_t acpi_scmi_uuid = GUID_INIT(0x84a2d1c6, 0x86b6, 0x4199,
0x8d, 0xac, 0x9c, 0x17,
0x44, 0x9d, 0x5e, 0x03);
static int acpi_scmi_lookup_protocol_id(const char *name)
{
for (size_t i = 0; i < ARRAY_SIZE(scmi_dsd_info_list); i++) {
if (!strcmp(name, scmi_dsd_info_list[i].property_name))
return scmi_dsd_info_list[i].protocol_id;
}
return -ENOENT;
}
static int acpi_scmi_parse_properties(struct pcc_transport_map *map,
const union acpi_object *properties)
{
bool transport_found = false;
if (properties->type != ACPI_TYPE_PACKAGE)
return -EINVAL;
for (u32 i = 0; i < properties->package.count; i++) {
const union acpi_object *v;
const char *name;
int prot_id, ret;
ret = acpi_scmi_property(properties, i, &name, &v);
if (ret)
return ret;
prot_id = acpi_scmi_lookup_protocol_id(name);
if (prot_id < 0)
continue;
if (prot_id != SCMI_PROTOCOL_BASE)
continue;
if (v->type != ACPI_TYPE_PACKAGE)
return -EINVAL;
if (transport_found)
return -EEXIST;
ret = acpi_scmi_dsd_parse_transport_package(map, v);
if (ret)
return ret;
transport_found = true;
}
if (!transport_found)
return -ENOENT;
for (u32 i = 0; i < properties->package.count; i++) {
const union acpi_object *v;
const char *name;
int prot_id, ret;
ret = acpi_scmi_property(properties, i, &name, &v);
if (ret)
return ret;
prot_id = acpi_scmi_lookup_protocol_id(name);
if (prot_id < 0 || prot_id == SCMI_PROTOCOL_BASE)
continue;
if (v->type != ACPI_TYPE_PACKAGE)
return -EINVAL;
ret = acpi_scmi_dsd_parse_protocol_package(map, v, prot_id);
if (ret)
return ret;
}
return 0;
}
static int acpi_scmi_namespace_fwnode_parse(struct fwnode_handle *fwnode,
struct pcc_transport_map *map)
{
struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER, NULL };
struct acpi_device *adev = to_acpi_device_node(fwnode);
union acpi_object *desc;
acpi_status status;
int ret = -ENOENT;
if (!adev || !adev->handle)
return -EINVAL;
status = acpi_evaluate_object_typed(adev->handle, "_DSD", NULL, &buf,
ACPI_TYPE_PACKAGE);
if (ACPI_FAILURE(status))
return -EINVAL;
desc = buf.pointer;
if (desc->package.count % SCMI_DSD_GUID_ENTRY_COUNT) {
ret = -EINVAL;
goto out_free;
}
for (u32 i = 0; i < desc->package.count;
i += SCMI_DSD_GUID_ENTRY_COUNT) {
const union acpi_object *guid;
const union acpi_object *properties;
guid = &desc->package.elements[i];
properties = &desc->package.elements[i + 1];
if (guid->type != ACPI_TYPE_BUFFER ||
guid->buffer.length != UUID_SIZE ||
properties->type != ACPI_TYPE_PACKAGE)
continue;
if (!guid_equal((guid_t *)guid->buffer.pointer,
&acpi_scmi_uuid))
continue;
ret = acpi_scmi_parse_properties(map, properties);
break;
}
out_free:
ACPI_FREE(buf.pointer);
return ret;
}
static bool
pcc_transport_map_has_ss_id(struct pcc_transport_map *map, u32 pcc_ss_id)
{
struct pcc_transport *p;
int idx;
hash_for_each(map->table, idx, p, hnode) {
if (p->pcc_ss_id == pcc_ss_id)
return true;
}
return false;
}
static int pcc_transport_map_validate(struct pcc_transport_map *map)
{
struct pcc_transport_map *iter;
struct pcc_transport *p;
int idx;
list_for_each_entry(iter, &pcc_transport_maps, node) {
hash_for_each(map->table, idx, p, hnode) {
if (pcc_transport_map_has_ss_id(iter, p->pcc_ss_id))
return -EEXIST;
}
}
return 0;
}
static
struct pcc_transport_map *pcc_transport_map_find(struct fwnode_handle *fwnode)
{
struct pcc_transport_map *map;
list_for_each_entry(map, &pcc_transport_maps, node) {
if (map->fwnode == fwnode)
return map;
}
return NULL;
}
static
struct pcc_transport_map *pcc_transport_map_get(struct fwnode_handle *fwnode)
{
struct pcc_transport_map *map;
int ret;
map = pcc_transport_map_find(fwnode);
if (map)
return map;
map = kzalloc_obj(*map);
if (!map)
return ERR_PTR(-ENOMEM);
hash_init(map->table);
ret = acpi_scmi_namespace_fwnode_parse(fwnode, map);
if (ret)
goto err_free_map;
ret = pcc_transport_map_validate(map);
if (ret)
goto err_free_map;
map->fwnode = fwnode_handle_get(fwnode);
list_add_tail(&map->node, &pcc_transport_maps);
return map;
err_free_map:
acpi_scmi_clear_transport_map(map);
kfree(map);
return ERR_PTR(ret);
}
static int pcc_transport_map_manage(struct pcc_transport_map *map,
struct device *dev)
{
int ret;
if (!dev || map->dev == dev)
return 0;
if (map->dev)
return -EBUSY;
ret = devm_add_action(dev, pcc_transport_map_release, map);
if (ret)
return ret;
map->dev = dev;
return 0;
}
static int pcc_lookup_ss_id(struct pcc_transport_map *map, u32 prot_id, bool tx)
{
struct pcc_transport *p;
int idx;
hash_for_each(map->table, idx, p, hnode) {
if (p->protocol_id != prot_id)
continue;
if ((!tx && (p->flags & SCMI_TRANSPORT_P2A_CHANNEL)) ||
(tx && !(p->flags & SCMI_TRANSPORT_P2A_CHANNEL)))
return p->pcc_ss_id;
}
return -ENOENT;
}
static int pcc_get_ss_id(struct fwnode_handle *fwnode, u32 prot_id, bool tx,
struct device *dev)
{
struct pcc_transport_map *map;
int ret;
if (!fwnode)
return -EINVAL;
guard(mutex)(&pcc_transport_maps_lock);
map = pcc_transport_map_get(fwnode);
if (IS_ERR(map))
return PTR_ERR(map);
ret = pcc_transport_map_manage(map, dev);
if (ret)
return ret;
return pcc_lookup_ss_id(map, prot_id, tx);
}
static bool
pcc_chan_available(struct fwnode_handle *fwnode, int prot_id, int idx)
{
return pcc_get_ss_id(fwnode, prot_id, !idx, NULL) >= 0;
}
static void tx_prepare(struct mbox_client *cl, void *m)
{
struct scmi_pcc *smbox = client_to_scmi_pcc(cl);
struct pcc_shared_mem __iomem *shmem = smbox->pchan->shmem;
struct scmi_xfer *xfer = m;
if (xfer->tx.buf)
memcpy_toio(shmem->msg_payload, xfer->tx.buf, xfer->tx.len);
iowrite32(SCMI_PCC_MSG_HEADER_SIZE + xfer->tx.len,
&shmem->header.length);
iowrite32(pack_scmi_header(&xfer->hdr), &shmem->header.command);
iowrite32(smbox->pchan->mchan->mbox->txdone_irq ?
PCC_CMD_COMPLETION_NOTIFY : 0, &shmem->header.flags);
}
static void rx_callback(struct mbox_client *cl, void *m)
{
struct scmi_pcc *smbox = client_to_scmi_pcc(cl);
struct pcc_shared_mem __iomem *shmem = smbox->pchan->shmem;
core->rx_callback(smbox->cinfo, ioread32(&shmem->header.command), NULL);
}
static int pcc_chan_validate_shmem(struct scmi_chan_info *cinfo,
struct scmi_pcc *smbox, int ss_id)
{
struct pcc_shared_mem __iomem *shmem = smbox->pchan->shmem;
u32 valid_signature = ss_id + PCC_SIGNATURE;
if (smbox->pchan->shmem_size < SCMI_PCC_SHMEM_OVERHEAD ||
smbox->pchan->shmem_size - SCMI_PCC_SHMEM_OVERHEAD <
cinfo->max_msg_size) {
dev_err(cinfo->dev, "misconfigured SCMI PCC shared memory\n");
return -ENOSPC;
}
if (ioread32(&shmem->header.signature) != valid_signature) {
dev_err(cinfo->dev, "invalid PCC shared memory signature\n");
return -EINVAL;
}
return 0;
}
static int pcc_chan_setup(struct scmi_chan_info *cinfo, struct device *dev,
bool tx)
{
const char *desc = tx ? "Tx" : "Rx";
struct device *cdev = cinfo->dev;
struct scmi_pcc *smbox;
struct mbox_client *cl;
int ret, ss_id;
smbox = devm_kzalloc_obj(dev, *smbox);
if (!smbox)
return -ENOMEM;
cl = &smbox->cl;
cl->dev = cdev;
cl->tx_prepare = tx ? tx_prepare : NULL;
cl->rx_callback = rx_callback;
cl->tx_block = false;
ss_id = pcc_get_ss_id(dev_fwnode(cinfo->dev), cinfo->id, tx, dev);
if (ss_id < 0)
return ss_id;
smbox->pchan = pcc_mbox_request_channel(cl, ss_id);
if (IS_ERR(smbox->pchan)) {
ret = PTR_ERR(smbox->pchan);
if (ret != -EPROBE_DEFER)
dev_err(cdev,
"failed to request SCMI %s mailbox\n", desc);
return ret;
}
ret = pcc_chan_validate_shmem(cinfo, smbox, ss_id);
if (ret) {
pcc_mbox_free_channel(smbox->pchan);
return ret;
}
cinfo->transport_info = smbox;
smbox->cinfo = cinfo;
return 0;
}
static int pcc_chan_free(int id, void *p, void *data)
{
struct scmi_chan_info *cinfo = p;
struct scmi_pcc *smbox = cinfo->transport_info;
if (!smbox || IS_ERR_OR_NULL(smbox->pchan))
return 0;
pcc_mbox_free_channel(smbox->pchan);
cinfo->transport_info = NULL;
smbox->pchan = NULL;
smbox->cinfo = NULL;
return 0;
}
static int
pcc_send_message(struct scmi_chan_info *cinfo, struct scmi_xfer *xfer)
{
struct scmi_pcc *smbox = cinfo->transport_info;
int ret;
ret = mbox_send_message(smbox->pchan->mchan, xfer);
if (ret < 0)
return ret;
return 0;
}
static void pcc_fetch_response(struct scmi_chan_info *cinfo,
struct scmi_xfer *xfer)
{
struct scmi_pcc *smbox = cinfo->transport_info;
struct pcc_shared_mem __iomem *shmem = smbox->pchan->shmem;
size_t len = ioread32(&shmem->header.length);
size_t payload_len;
xfer->hdr.status = ioread32(shmem->msg_payload);
payload_len = len > SCMI_PCC_RESPONSE_OVERHEAD ?
len - SCMI_PCC_RESPONSE_OVERHEAD : 0;
xfer->rx.len = min(xfer->rx.len, payload_len);
memcpy_fromio(xfer->rx.buf, shmem->msg_payload + SCMI_PCC_STATUS_SIZE,
xfer->rx.len);
}
static void pcc_fetch_notification(struct scmi_chan_info *cinfo, size_t max_len,
struct scmi_xfer *xfer)
{
struct scmi_pcc *smbox = cinfo->transport_info;
struct pcc_shared_mem __iomem *shmem = smbox->pchan->shmem;
size_t len = ioread32(&shmem->header.length);
size_t payload_len;
payload_len = len > SCMI_PCC_MSG_HEADER_SIZE ?
len - SCMI_PCC_MSG_HEADER_SIZE : 0;
xfer->rx.len = min(max_len, payload_len);
memcpy_fromio(xfer->rx.buf, shmem->msg_payload, xfer->rx.len);
}
static const struct scmi_transport_ops scmi_pcc_ops = {
.chan_available = pcc_chan_available,
.chan_setup = pcc_chan_setup,
.chan_free = pcc_chan_free,
.send_message = pcc_send_message,
.fetch_response = pcc_fetch_response,
.fetch_notification = pcc_fetch_notification,
};
static struct scmi_desc scmi_pcc_desc = {
.ops = &scmi_pcc_ops,
.max_rx_timeout_ms = 30,
.max_msg = MBOX_TX_QUEUE_LEN,
.max_msg_size = SCMI_SHMEM_MAX_PAYLOAD_SIZE,
};
static const struct acpi_device_id scmi_acpi_ids[] = {
{ .id = "ARML0001" },
{ }
};
MODULE_DEVICE_TABLE(acpi, scmi_acpi_ids);
DEFINE_SCMI_ACPI_TRANSPORT_DRIVER(scmi_pcc, scmi_pcc_driver,
scmi_pcc_desc, scmi_acpi_ids, core);
static int __init scmi_pcc_init(void)
{
return platform_driver_register(&scmi_pcc_driver);
}
static void __exit scmi_pcc_exit(void)
{
platform_driver_unregister(&scmi_pcc_driver);
acpi_scmi_clear_transport_maps();
}
module_init(scmi_pcc_init);
module_exit(scmi_pcc_exit);
MODULE_AUTHOR("Sudeep Holla <sudeep.holla@kernel.org>");
MODULE_DESCRIPTION("SCMI ACPI PCC Transport driver");
MODULE_LICENSE("GPL"