// SPDX-License-Identifier: GPL-2.0-only /* * Intel ECLite opregion driver for talking to ECLite firmware running on * Intel Integrated Sensor Hub (ISH) using ISH Transport Protocol (ISHTP) * * Copyright (c) 2021, Intel Corporation. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #define ECLITE_DATA_OPREGION_ID 0x9E #define ECLITE_CMD_OPREGION_ID 0x9F #define ECL_MSG_DATA 0x1 #define ECL_MSG_EVENT 0x2 #define ECL_ISH_READ 0x1 #define ECL_ISH_WRITE 0x2 #define ECL_ISH_HEADER_VERSION 0 #define ECL_CL_RX_RING_SIZE 16 #define ECL_CL_TX_RING_SIZE 8 #define ECL_DATA_OPR_BUFLEN 384 #define ECL_EVENTS_NOTIFY 333 #define cmd_opr_offsetof(element) offsetof(struct opregion_cmd, element) #define cl_data_to_dev(opr_dev) ishtp_device((opr_dev)->cl_device) #ifndef BITS_TO_BYTES #define BITS_TO_BYTES(x) ((x) / 8) #endif struct opregion_cmd { unsigned int command; unsigned int offset; unsigned int length; unsigned int event_id; }; struct opregion_data { char data[ECL_DATA_OPR_BUFLEN]; }; struct opregion_context { struct opregion_cmd cmd_area; struct opregion_data data_area; }; struct ecl_message_header { unsigned int version:2; unsigned int data_type:2; unsigned int request_type:2; unsigned int offset:9; unsigned int data_len:9; unsigned int event:8; }; struct ecl_message { struct ecl_message_header header; char payload[ECL_DATA_OPR_BUFLEN]; }; struct ishtp_opregion_dev { struct opregion_context opr_context; struct ishtp_cl *ecl_ishtp_cl; struct ishtp_cl_device *cl_device; struct ishtp_fw_client *fw_client; struct ishtp_cl_rb *rb; struct acpi_device *adev; unsigned int dsm_event_id; unsigned int ish_link_ready; unsigned int ish_read_done; unsigned int acpi_init_done; wait_queue_head_t read_wait; struct work_struct event_work; struct work_struct reset_work; /* lock for opregion context */ struct mutex lock; }; /* eclite ishtp client UUID: 6a19cc4b-d760-4de3-b14d-f25ebd0fbcd9 */ static const struct ishtp_device_id ecl_ishtp_id_table[] = { { .guid = GUID_INIT(0x6a19cc4b, 0xd760, 0x4de3, 0xb1, 0x4d, 0xf2, 0x5e, 0xbd, 0xf, 0xbc, 0xd9), }, { } }; MODULE_DEVICE_TABLE(ishtp, ecl_ishtp_id_table); /* ACPI DSM UUID: 91d936a7-1f01-49c6-a6b4-72f00ad8d8a5 */ static const guid_t ecl_acpi_guid = GUID_INIT(0x91d936a7, 0x1f01, 0x49c6, 0xa6, 0xb4, 0x72, 0xf0, 0x0a, 0xd8, 0xd8, 0xa5); /** * ecl_ish_cl_read() - Read data from eclite FW * * @opr_dev: pointer to opregion device * * This function issues a read request to eclite FW and waits until it * receives a response. When response is received the read data is copied to * opregion buffer. */ static int ecl_ish_cl_read(struct ishtp_opregion_dev *opr_dev) { struct ecl_message_header header; int len, rv; if (!opr_dev->ish_link_ready) return -EIO; if ((opr_dev->opr_context.cmd_area.offset + opr_dev->opr_context.cmd_area.length) > ECL_DATA_OPR_BUFLEN) { return -EINVAL; } header.version = ECL_ISH_HEADER_VERSION; header.data_type = ECL_MSG_DATA; header.request_type = ECL_ISH_READ; header.offset = opr_dev->opr_context.cmd_area.offset; header.data_len = opr_dev->opr_context.cmd_area.length; header.event = opr_dev->opr_context.cmd_area.event_id; len = sizeof(header); opr_dev->ish_read_done = false; rv = ishtp_cl_send(opr_dev->ecl_ishtp_cl, (uint8_t *)&header, len); if (rv) { dev_err(cl_data_to_dev(opr_dev), "ish-read : send failed\n"); return -EIO; } dev_dbg(cl_data_to_dev(opr_dev), "[ish_rd] Req: off : %x, len : %x\n", header.offset, header.data_len); rv = wait_event_interruptible_timeout(opr_dev->read_wait, opr_dev->ish_read_done, 2 * HZ); if (!rv) { dev_err(cl_data_to_dev(opr_dev), "[ish_rd] No response from firmware\n"); return -EIO; } return 0; } /** * ecl_ish_cl_write() - This function writes data to eclite FW. * * @opr_dev: pointer to opregion device * * This function writes data to eclite FW. */ static int ecl_ish_cl_write(struct ishtp_opregion_dev *opr_dev) { struct ecl_message message; int len; if (!opr_dev->ish_link_ready) return -EIO; if ((opr_dev->opr_context.cmd_area.offset + opr_dev->opr_context.cmd_area.length) > ECL_DATA_OPR_BUFLEN) { return -EINVAL; } message.header.version = ECL_ISH_HEADER_VERSION; message.header.data_type = ECL_MSG_DATA; message.header.request_type = ECL_ISH_WRITE; message.header.offset = opr_dev->opr_context.cmd_area.offset; message.header.data_len = opr_dev->opr_context.cmd_area.length; message.header.event = opr_dev->opr_context.cmd_area.event_id; len = sizeof(struct ecl_message_header) + message.header.data_len; memcpy(message.payload, opr_dev->opr_context.data_area.data + message.header.offset, message.header.data_len); dev_dbg(cl_data_to_dev(opr_dev), "[ish_wr] off : %x, len : %x\n", message.header.offset, message.header.data_len); return ishtp_cl_send(opr_dev->ecl_ishtp_cl, (uint8_t *)&message, len); } static acpi_status ecl_opregion_cmd_handler(u32 function, acpi_physical_address address, u32 bits, u64 *value64, void *handler_context, void *region_context) { struct ishtp_opregion_dev *opr_dev; struct opregion_cmd *cmd; acpi_status status = AE_OK; if (!region_context || !value64) return AE_BAD_PARAMETER; if (function == ACPI_READ) return AE_ERROR; opr_dev = (struct ishtp_opregion_dev *)region_context; mutex_lock(&opr_dev->lock); cmd = &opr_dev->opr_context.cmd_area; switch (address) { case cmd_opr_offsetof(command): cmd->command = (u32)*value64; if (cmd->command == ECL_ISH_READ) status = ecl_ish_cl_read(opr_dev); else if (cmd->command == ECL_ISH_WRITE) status = ecl_ish_cl_write(opr_dev); else status = AE_ERROR; break; case cmd_opr_offsetof(offset): cmd->offset = (u32)*value64; break; case cmd_opr_offsetof(length): cmd->length = (u32)*value64; break; case cmd_opr_offsetof(event_id): cmd->event_id = (u32)*value64; break; default: status = AE_ERROR; } mutex_unlock(&opr_dev->lock); return status; } static acpi_status ecl_opregion_data_handler(u32 function, acpi_physical_address address, u32 bits, u64 *value64, void *handler_context, void *region_context) { struct ishtp_opregion_dev *opr_dev; unsigned int bytes = BITS_TO_BYTES(bits); void *data_addr; if (!region_context || !value64) return AE_BAD_PARAMETER; if (address + bytes > ECL_DATA_OPR_BUFLEN) return AE_BAD_PARAMETER; opr_dev = (struct ishtp_opregion_dev *)region_context; mutex_lock(&opr_dev->lock); data_addr = &opr_dev->opr_context.data_area.data[address]; if (function == ACPI_READ) { memcpy(value64, data_addr, bytes); } else if (function == ACPI_WRITE) { memcpy(data_addr, value64, bytes); } else { mutex_unlock(&opr_dev->lock); return AE_BAD_PARAMETER; } mutex_unlock(&opr_dev->lock); return AE_OK; } static int acpi_find_eclite_device(struct ishtp_opregion_dev *opr_dev) { struct acpi_device *adev; /* Find ECLite device and save reference */ adev = acpi_dev_get_first_match_dev("INTC1035", NULL, -1); if (!adev) { dev_err(cl_data_to_dev(opr_dev), "eclite ACPI device not found\n"); return -ENODEV; } opr_dev->adev = adev; return 0; } static int acpi_opregion_init(struct ishtp_opregion_dev *opr_dev) { acpi_status status; status = acpi_install_address_space_handler(opr_dev->adev->handle, ECLITE_CMD_OPREGION_ID, ecl_opregion_cmd_handler, NULL, opr_dev); if (ACPI_FAILURE(status)) { dev_err(cl_data_to_dev(opr_dev), "cmd space handler install failed\n"); return -ENODEV; } status = acpi_install_address_space_handler(opr_dev->adev->handle, ECLITE_DATA_OPREGION_ID, ecl_opregion_data_handler, NULL, opr_dev); if (ACPI_FAILURE(status)) { dev_err(cl_data_to_dev(opr_dev), "data space handler install failed\n"); acpi_remove_address_space_handler(opr_dev->adev->handle, ECLITE_CMD_OPREGION_ID, ecl_opregion_cmd_handler); return -ENODEV; } opr_dev->acpi_init_done = true; dev_dbg(cl_data_to_dev(opr_dev), "Opregion handlers are installed\n"); return 0; } static void acpi_opregion_deinit(struct ishtp_opregion_dev *opr_dev) { acpi_remove_address_space_handler(opr_dev->adev->handle, ECLITE_CMD_OPREGION_ID, ecl_opregion_cmd_handler); acpi_remove_address_space_handler(opr_dev->adev->handle, ECLITE_DATA_OPREGION_ID, ecl_opregion_data_handler); opr_dev->acpi_init_done = false; } static void ecl_acpi_invoke_dsm(struct work_struct *work) { struct ishtp_opregion_dev *opr_dev; union acpi_object *obj; opr_dev = container_of(work, struct ishtp_opregion_dev, event_work); if (!opr_dev->acpi_init_done) return; obj = acpi_evaluate_dsm(opr_dev->adev->handle, &ecl_acpi_guid, 0, opr_dev->dsm_event_id, NULL); if (!obj) { dev_warn(cl_data_to_dev(opr_dev), "_DSM fn call failed\n"); return; } dev_dbg(cl_data_to_dev(opr_dev), "Exec DSM function code: %d success\n", opr_dev->dsm_event_id); ACPI_FREE(obj); } static void ecl_ish_process_rx_data(struct ishtp_opregion_dev *opr_dev) { struct ecl_message *message = (struct ecl_message *)opr_dev->rb->buffer.data; dev_dbg(cl_data_to_dev(opr_dev), "[ish_rd] Resp: off : %x, len : %x\n", message->header.offset, message->header.data_len); if ((message->header.offset + message->header.data_len) > ECL_DATA_OPR_BUFLEN) { return; } memcpy(opr_dev->opr_context.data_area.data + message->header.offset, message->payload, message->header.data_len); opr_dev->ish_read_done = true; wake_up_interruptible(&opr_dev->read_wait); } static void ecl_ish_process_rx_event(struct ishtp_opregion_dev *opr_dev) { struct ecl_message_header *header = (struct ecl_message_header *)opr_dev->rb->buffer.data; dev_dbg(cl_data_to_dev(opr_dev), "[ish_ev] Evt received: %8x\n", header->event); opr_dev->dsm_event_id = header->event; schedule_work(&opr_dev->event_work); } static int ecl_ish_cl_enable_events(struct ishtp_opregion_dev *opr_dev, bool config_enable) { struct ecl_message message; int len; message.header.version = ECL_ISH_HEADER_VERSION; message.header.data_type = ECL_MSG_DATA; message.header.request_type = ECL_ISH_WRITE; message.header.offset = ECL_EVENTS_NOTIFY; message.header.data_len = 1; message.payload[0] = config_enable; len = sizeof(struct ecl_message_header) + message.header.data_len; return ishtp_cl_send(opr_dev->ecl_ishtp_cl, (uint8_t *)&message, len); } static void ecl_ishtp_cl_event_cb(struct ishtp_cl_device *cl_device) { struct ishtp_cl *ecl_ishtp_cl = ishtp_get_drvdata(cl_device); struct ishtp_opregion_dev *opr_dev; struct ecl_message_header *header; struct ishtp_cl_rb *rb; opr_dev = ishtp_get_client_data(ecl_ishtp_cl); while ((rb = ishtp_cl_rx_get_rb(opr_dev->ecl_ishtp_cl)) != NULL) { opr_dev->rb = rb; header = (struct ecl_message_header *)rb->buffer.data; if (header->data_type == ECL_MSG_DATA) ecl_ish_process_rx_data(opr_dev); else if (header->data_type == ECL_MSG_EVENT) ecl_ish_process_rx_event(opr_dev); else /* Got an event with wrong data_type, ignore it */ dev_err(cl_data_to_dev(opr_dev), "[ish_cb] Received wrong data_type\n"); ishtp_cl_io_rb_recycle(rb); } } static int ecl_ishtp_cl_init(struct ishtp_cl *ecl_ishtp_cl) { struct ishtp_opregion_dev *opr_dev = ishtp_get_client_data(ecl_ishtp_cl); struct ishtp_fw_client *fw_client; struct ishtp_device *dev; int rv; rv = ishtp_cl_link(ecl_ishtp_cl); if (rv) { dev_err(cl_data_to_dev(opr_dev), "ishtp_cl_link failed\n"); return rv; } dev = ishtp_get_ishtp_device(ecl_ishtp_cl); /* Connect to FW client */ ishtp_set_tx_ring_size(ecl_ishtp_cl, ECL_CL_TX_RING_SIZE); ishtp_set_rx_ring_size(ecl_ishtp_cl, ECL_CL_RX_RING_SIZE); fw_client = ishtp_fw_cl_get_client(dev, &ecl_ishtp_id_table[0].guid); if (!fw_client) { dev_err(cl_data_to_dev(opr_dev), "fw client not found\n"); return -ENOENT; } ishtp_cl_set_fw_client_id(ecl_ishtp_cl, ishtp_get_fw_client_id(fw_client)); ishtp_set_connection_state(ecl_ishtp_cl, ISHTP_CL_CONNECTING); rv = ishtp_cl_connect(ecl_ishtp_cl); if (rv) { dev_err(cl_data_to_dev(opr_dev), "client connect failed\n"); ishtp_cl_unlink(ecl_ishtp_cl); return rv; } dev_dbg(cl_data_to_dev(opr_dev), "Host connected to fw client\n"); return 0; } static void ecl_ishtp_cl_deinit(struct ishtp_cl *ecl_ishtp_cl) { ishtp_cl_unlink(ecl_ishtp_cl); ishtp_cl_flush_queues(ecl_ishtp_cl); ishtp_cl_free(ecl_ishtp_cl); } static void ecl_ishtp_cl_reset_handler(struct work_struct *work) { struct ishtp_opregion_dev *opr_dev; struct ishtp_cl_device *cl_device; struct ishtp_cl *ecl_ishtp_cl; int rv; int retry; opr_dev = container_of(work, struct ishtp_opregion_dev, reset_work); opr_dev->ish_link_ready = false; cl_device = opr_dev->cl_device; ecl_ishtp_cl = opr_dev->ecl_ishtp_cl; ecl_ishtp_cl_deinit(ecl_ishtp_cl); ecl_ishtp_cl = ishtp_cl_allocate(cl_device); if (!ecl_ishtp_cl) return; ishtp_set_drvdata(cl_device, ecl_ishtp_cl); ishtp_set_client_data(ecl_ishtp_cl, opr_dev); opr_dev->ecl_ishtp_cl = ecl_ishtp_cl; for (retry = 0; retry < 3; ++retry) { rv = ecl_ishtp_cl_init(ecl_ishtp_cl); if (!rv) break; } if (rv) { ishtp_cl_free(ecl_ishtp_cl); opr_dev->ecl_ishtp_cl = NULL; dev_err(cl_data_to_dev(opr_dev), "[ish_rst] Reset failed. Link not ready.\n"); return; } ishtp_register_event_cb(cl_device, ecl_ishtp_cl_event_cb); dev_info(cl_data_to_dev(opr_dev), "[ish_rst] Reset Success. Link ready.\n"); opr_dev->ish_link_ready = true; if (opr_dev->acpi_init_done) return; rv = acpi_opregion_init(opr_dev); if (rv) { dev_err(cl_data_to_dev(opr_dev), "ACPI opregion init failed\n"); } } static int ecl_ishtp_cl_probe(struct ishtp_cl_device *cl_device) { struct ishtp_cl *ecl_ishtp_cl; struct ishtp_opregion_dev *opr_dev; int rv; opr_dev = devm_kzalloc(ishtp_device(cl_device), sizeof(*opr_dev), GFP_KERNEL); if (!opr_dev) return -ENOMEM; ecl_ishtp_cl = ishtp_cl_allocate(cl_device); if (!ecl_ishtp_cl) return -ENOMEM; ishtp_set_drvdata(cl_device, ecl_ishtp_cl); ishtp_set_client_data(ecl_ishtp_cl, opr_dev); opr_dev->ecl_ishtp_cl = ecl_ishtp_cl; opr_dev->cl_device = cl_device; init_waitqueue_head(&opr_dev->read_wait); INIT_WORK(&opr_dev->event_work, ecl_acpi_invoke_dsm); INIT_WORK(&opr_dev->reset_work, ecl_ishtp_cl_reset_handler); /* Initialize ish client device */ rv = ecl_ishtp_cl_init(ecl_ishtp_cl); if (rv) { dev_err(cl_data_to_dev(opr_dev), "Client init failed\n"); goto err_exit; } dev_dbg(cl_data_to_dev(opr_dev), "eclite-ishtp client initialised\n"); opr_dev->ish_link_ready = true; mutex_init(&opr_dev->lock); rv = acpi_find_eclite_device(opr_dev); if (rv) { dev_err(cl_data_to_dev(opr_dev), "ECLite ACPI ID not found\n"); goto err_exit; } /* Register a handler for eclite fw events */ ishtp_register_event_cb(cl_device, ecl_ishtp_cl_event_cb); /* Now init opregion handlers */ rv = acpi_opregion_init(opr_dev); if (rv) { dev_err(cl_data_to_dev(opr_dev), "ACPI opregion init failed\n"); goto err_exit; } /* Reprobe devices depending on ECLite - battery, fan, etc. */ acpi_dev_clear_dependencies(opr_dev->adev); return 0; err_exit: ishtp_set_connection_state(ecl_ishtp_cl, ISHTP_CL_DISCONNECTING); ishtp_cl_disconnect(ecl_ishtp_cl); ecl_ishtp_cl_deinit(ecl_ishtp_cl); return rv; } static void ecl_ishtp_cl_remove(struct ishtp_cl_device *cl_device) { struct ishtp_cl *ecl_ishtp_cl = ishtp_get_drvdata(cl_device); struct ishtp_opregion_dev *opr_dev = ishtp_get_client_data(ecl_ishtp_cl); if (opr_dev->acpi_init_done) acpi_opregion_deinit(opr_dev); acpi_dev_put(opr_dev->adev); ishtp_set_connection_state(ecl_ishtp_cl, ISHTP_CL_DISCONNECTING); ishtp_cl_disconnect(ecl_ishtp_cl); ecl_ishtp_cl_deinit(ecl_ishtp_cl); cancel_work_sync(&opr_dev->reset_work); cancel_work_sync(&opr_dev->event_work); } static int ecl_ishtp_cl_reset(struct ishtp_cl_device *cl_device) { struct ishtp_cl *ecl_ishtp_cl = ishtp_get_drvdata(cl_device); struct ishtp_opregion_dev *opr_dev = ishtp_get_client_data(ecl_ishtp_cl); schedule_work(&opr_dev->reset_work); return 0; } static int ecl_ishtp_cl_suspend(struct device *device) { struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device); struct ishtp_cl *ecl_ishtp_cl = ishtp_get_drvdata(cl_device); struct ishtp_opregion_dev *opr_dev = ishtp_get_client_data(ecl_ishtp_cl); if (acpi_target_system_state() == ACPI_STATE_S0) return 0; acpi_opregion_deinit(opr_dev); ecl_ish_cl_enable_events(opr_dev, false); return 0; } static int ecl_ishtp_cl_resume(struct device *device) { /* A reset is expected to call after an Sx. At this point * we are not sure if the link is up or not to restore anything, * so do nothing in resume path */ return 0; } static const struct dev_pm_ops ecl_ishtp_pm_ops = { .suspend = ecl_ishtp_cl_suspend, .resume = ecl_ishtp_cl_resume, }; static struct ishtp_cl_driver ecl_ishtp_cl_driver = { .name = "ishtp-eclite", .id = ecl_ishtp_id_table, .probe = ecl_ishtp_cl_probe, .remove = ecl_ishtp_cl_remove, .reset = ecl_ishtp_cl_reset, .driver.pm = &ecl_ishtp_pm_ops, }; static int __init ecl_ishtp_init(void) { return ishtp_cl_driver_register(&ecl_ishtp_cl_driver, THIS_MODULE); } static void __exit ecl_ishtp_exit(void) { return ishtp_cl_driver_unregister(&ecl_ishtp_cl_driver); } late_initcall(ecl_ishtp_init); module_exit(ecl_ishtp_exit); MODULE_DESCRIPTION("ISH ISHTP eclite client opregion driver"); MODULE_AUTHOR("K Naduvalath, Sumesh "); MODULE_LICENSE("GPL v2");