| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Copyright (c) 2025, Linaro Limited | |
| * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. | |
| * | |
| * QMI Thermal Mitigation Device (TMD). | |
| * Provides cooling device support for remote subsystems | |
| * running the TMD service via QMI. | |
| */ | |
| #include <linux/cleanup.h> | |
| #include <linux/device.h> | |
| #include <linux/err.h> | |
| #include <linux/module.h> | |
| #include <linux/net.h> | |
| #include <linux/of.h> | |
| #include <linux/slab.h> | |
| #include <linux/soc/qcom/qmi.h> | |
| #include <linux/soc/qcom/qmi_tmd.h> | |
| #include <linux/thermal.h> | |
| #define QMI_TMD_SERVICE_VERS_V01 0x01 | |
| #define QMI_TMD_SET_LEVEL_REQ 0x0021 | |
| #define QMI_TMD_GET_DEV_LIST_REQ 0x0020 | |
| #define QMI_TMD_DEV_ID_LEN_MAX 32 | |
| #define QMI_TMD_DEV_LIST_MAX 32 | |
| #define QMI_TMD_RESP_TIMEOUT msecs_to_jiffies(100) | |
| #define TMD_GET_LEVEL_REQ_MAX_LEN 36 | |
| #define TMD_SET_LEVEL_REQ_MAX_LEN 40 | |
| #define TMD_GET_DEV_LIST_REQ_MAX_LEN 0 | |
| #define TMD_GET_DEV_LIST_RESP_MAX_LEN 1099 | |
| struct tmd_dev_id { | |
| char mitigation_dev_id[QMI_TMD_DEV_ID_LEN_MAX + 1]; | |
| }; | |
| static const struct qmi_elem_info tmd_dev_id_ei[] = { | |
| { | |
| .data_type = QMI_STRING, | |
| .elem_len = QMI_TMD_DEV_ID_LEN_MAX + 1, | |
| .elem_size = sizeof(char), | |
| .array_type = NO_ARRAY, | |
| .tlv_type = 0, | |
| .offset = offsetof(struct tmd_dev_id, | |
| mitigation_dev_id), | |
| }, | |
| { | |
| .data_type = QMI_EOTI, | |
| .array_type = NO_ARRAY, | |
| .tlv_type = QMI_COMMON_TLV_TYPE, | |
| }, | |
| }; | |
| struct tmd_dev_list { | |
| struct tmd_dev_id mitigation_dev_id; | |
| u8 max_mitigation_level; | |
| }; | |
| static const struct qmi_elem_info tmd_dev_list_ei[] = { | |
| { | |
| .data_type = QMI_STRUCT, | |
| .elem_len = 1, | |
| .elem_size = sizeof(struct tmd_dev_id), | |
| .array_type = NO_ARRAY, | |
| .tlv_type = 0, | |
| .offset = offsetof(struct tmd_dev_list, | |
| mitigation_dev_id), | |
| .ei_array = tmd_dev_id_ei, | |
| }, | |
| { | |
| .data_type = QMI_UNSIGNED_1_BYTE, | |
| .elem_len = 1, | |
| .elem_size = sizeof(uint8_t), | |
| .array_type = NO_ARRAY, | |
| .tlv_type = 0, | |
| .offset = offsetof(struct tmd_dev_list, | |
| max_mitigation_level), | |
| }, | |
| { | |
| .data_type = QMI_EOTI, | |
| .array_type = NO_ARRAY, | |
| .tlv_type = QMI_COMMON_TLV_TYPE, | |
| }, | |
| }; | |
| struct tmd_get_dev_list_req { | |
| char placeholder; | |
| }; | |
| static const struct qmi_elem_info tmd_get_dev_list_req_ei[] = { | |
| { | |
| .data_type = QMI_EOTI, | |
| .array_type = NO_ARRAY, | |
| .tlv_type = QMI_COMMON_TLV_TYPE, | |
| }, | |
| }; | |
| struct tmd_get_dev_list_resp { | |
| struct qmi_response_type_v01 resp; | |
| u8 mitigation_device_list_valid; | |
| u32 mitigation_device_list_len; | |
| struct tmd_dev_list | |
| mitigation_device_list[QMI_TMD_DEV_LIST_MAX]; | |
| }; | |
| static const struct qmi_elem_info tmd_get_dev_list_resp_ei[] = { | |
| { | |
| .data_type = QMI_STRUCT, | |
| .elem_len = 1, | |
| .elem_size = sizeof(struct qmi_response_type_v01), | |
| .array_type = NO_ARRAY, | |
| .tlv_type = 0x02, | |
| .offset = offsetof(struct tmd_get_dev_list_resp, | |
| resp), | |
| .ei_array = qmi_response_type_v01_ei, | |
| }, | |
| { | |
| .data_type = QMI_OPT_FLAG, | |
| .elem_len = 1, | |
| .elem_size = sizeof(uint8_t), | |
| .array_type = NO_ARRAY, | |
| .tlv_type = 0x10, | |
| .offset = offsetof(struct tmd_get_dev_list_resp, | |
| mitigation_device_list_valid), | |
| }, | |
| { | |
| .data_type = QMI_DATA_LEN, | |
| .elem_len = 1, | |
| .elem_size = sizeof(uint8_t), | |
| .array_type = NO_ARRAY, | |
| .tlv_type = 0x10, | |
| .offset = offsetof(struct tmd_get_dev_list_resp, | |
| mitigation_device_list_len), | |
| }, | |
| { | |
| .data_type = QMI_STRUCT, | |
| .elem_len = QMI_TMD_DEV_LIST_MAX, | |
| .elem_size = sizeof(struct tmd_dev_list), | |
| .array_type = VAR_LEN_ARRAY, | |
| .tlv_type = 0x10, | |
| .offset = offsetof(struct tmd_get_dev_list_resp, | |
| mitigation_device_list), | |
| .ei_array = tmd_dev_list_ei, | |
| }, | |
| { | |
| .data_type = QMI_EOTI, | |
| .array_type = NO_ARRAY, | |
| .tlv_type = QMI_COMMON_TLV_TYPE, | |
| }, | |
| }; | |
| struct tmd_set_level_req { | |
| struct tmd_dev_id mitigation_dev_id; | |
| u8 mitigation_level; | |
| }; | |
| static const struct qmi_elem_info tmd_set_level_req_ei[] = { | |
| { | |
| .data_type = QMI_STRUCT, | |
| .elem_len = 1, | |
| .elem_size = sizeof(struct tmd_dev_id), | |
| .array_type = NO_ARRAY, | |
| .tlv_type = 0x01, | |
| .offset = offsetof(struct tmd_set_level_req, | |
| mitigation_dev_id), | |
| .ei_array = tmd_dev_id_ei, | |
| }, | |
| { | |
| .data_type = QMI_UNSIGNED_1_BYTE, | |
| .elem_len = 1, | |
| .elem_size = sizeof(uint8_t), | |
| .array_type = NO_ARRAY, | |
| .tlv_type = 0x02, | |
| .offset = offsetof(struct tmd_set_level_req, | |
| mitigation_level), | |
| }, | |
| { | |
| .data_type = QMI_EOTI, | |
| .array_type = NO_ARRAY, | |
| .tlv_type = QMI_COMMON_TLV_TYPE, | |
| }, | |
| }; | |
| struct tmd_set_level_resp { | |
| struct qmi_response_type_v01 resp; | |
| }; | |
| static const struct qmi_elem_info tmd_set_level_resp_ei[] = { | |
| { | |
| .data_type = QMI_STRUCT, | |
| .elem_len = 1, | |
| .elem_size = sizeof(struct qmi_response_type_v01), | |
| .array_type = NO_ARRAY, | |
| .tlv_type = 0x02, | |
| .offset = offsetof(struct tmd_set_level_resp, resp), | |
| .ei_array = qmi_response_type_v01_ei, | |
| }, | |
| { | |
| .data_type = QMI_EOTI, | |
| .array_type = NO_ARRAY, | |
| .tlv_type = QMI_COMMON_TLV_TYPE, | |
| }, | |
| }; | |
| /** | |
| * struct qmi_tmd - A TMD cooling device | |
| * @name: The name of this tmd shared by the remote subsystem | |
| * @cdev: Thermal cooling device handle | |
| * @cur_state: The current mitigation state | |
| * @max_state: The maximum state | |
| * @qmi_tmd_cli: Parent QMI TMD client | |
| */ | |
| struct qmi_tmd { | |
| const char *name; | |
| struct thermal_cooling_device *cdev; | |
| unsigned int cur_state; | |
| unsigned int max_state; | |
| struct qmi_tmd_client *qmi_tmd_cli; | |
| }; | |
| /** | |
| * struct qmi_tmd_client - QMI TMD client state | |
| * @dev: Device associated with this instance | |
| * @handle: QMI connection handle | |
| * @mutex: Serializes QMI request/response sequences (qmi_txn_init, | |
| * qmi_send_request) during DSP subsystem restart and | |
| * protects @connection_active and @exiting | |
| * @connection_active: Whether or not we're connected to the QMI TMD service | |
| * @exiting: Whether or not teardown has started | |
| * @svc_arrive_work: Work item for initialising when the TMD service starts | |
| * @num_tmds: Number of tmds described in the device tree | |
| * @tmds: An array of tmd structures | |
| */ | |
| struct qmi_tmd_client { | |
| struct device *dev; | |
| struct qmi_handle handle; | |
| /* protects QMI transactions, connection_active and exiting */ | |
| struct mutex mutex; | |
| bool connection_active; | |
| bool exiting; | |
| struct work_struct svc_arrive_work; | |
| int num_tmds; | |
| struct qmi_tmd tmds[] __counted_by(num_tmds); | |
| }; | |
| /* Notify the remote subsystem of the requested cooling state */ | |
| static int qmi_tmd_send_state_request(struct qmi_tmd *tmd, int state) | |
| { | |
| struct tmd_set_level_resp resp = { 0 }; | |
| struct tmd_set_level_req req = { 0 }; | |
| struct qmi_tmd_client *qmi_tmd_cli = tmd->qmi_tmd_cli; | |
| struct qmi_txn txn; | |
| int ret = 0; | |
| if (!qmi_tmd_cli->connection_active) | |
| return -ENOTCONN; | |
| strscpy(req.mitigation_dev_id.mitigation_dev_id, tmd->name, | |
| QMI_TMD_DEV_ID_LEN_MAX + 1); | |
| req.mitigation_level = state; | |
| ret = qmi_txn_init(&qmi_tmd_cli->handle, &txn, | |
| tmd_set_level_resp_ei, &resp); | |
| if (ret < 0) { | |
| dev_err(qmi_tmd_cli->dev, "qmi set state %d txn init failed for %s ret %d\n", | |
| state, tmd->name, ret); | |
| return ret; | |
| } | |
| ret = qmi_send_request(&qmi_tmd_cli->handle, NULL, &txn, | |
| QMI_TMD_SET_LEVEL_REQ, | |
| TMD_SET_LEVEL_REQ_MAX_LEN, | |
| tmd_set_level_req_ei, &req); | |
| if (ret < 0) { | |
| dev_err(qmi_tmd_cli->dev, "qmi set state %d txn send failed for %s ret %d\n", | |
| state, tmd->name, ret); | |
| qmi_txn_cancel(&txn); | |
| return ret; | |
| } | |
| ret = qmi_txn_wait(&txn, QMI_TMD_RESP_TIMEOUT); | |
| if (ret < 0) { | |
| dev_err(qmi_tmd_cli->dev, "qmi set state %d txn wait failed for %s ret %d\n", | |
| state, tmd->name, ret); | |
| return ret; | |
| } | |
| if (resp.resp.result != QMI_RESULT_SUCCESS_V01) { | |
| dev_err(qmi_tmd_cli->dev, | |
| "qmi set state %d failed for %s result %#x error %#x\n", | |
| state, tmd->name, | |
| resp.resp.result, resp.resp.error); | |
| return -EREMOTEIO; | |
| } | |
| dev_dbg(qmi_tmd_cli->dev, "Requested state %d/%d for %s\n", state, | |
| tmd->max_state, tmd->name); | |
| tmd->cur_state = state; | |
| return 0; | |
| } | |
| static int qmi_tmd_get_max_state(struct thermal_cooling_device *cdev, | |
| unsigned long *state) | |
| { | |
| struct qmi_tmd *tmd = cdev->devdata; | |
| *state = tmd->max_state; | |
| return 0; | |
| } | |
| static int qmi_tmd_get_cur_state(struct thermal_cooling_device *cdev, | |
| unsigned long *state) | |
| { | |
| struct qmi_tmd *tmd = cdev->devdata; | |
| /* cur_state is protected by thermal core's cdev->lock */ | |
| *state = tmd->cur_state; | |
| return 0; | |
| } | |
| static int qmi_tmd_set_cur_state(struct thermal_cooling_device *cdev, | |
| unsigned long state) | |
| { | |
| struct qmi_tmd *tmd = cdev->devdata; | |
| if (state > tmd->max_state) | |
| return -EINVAL; | |
| /* cur_state is protected by thermal core's cdev->lock */ | |
| if (tmd->cur_state == state) | |
| return 0; | |
| guard(mutex)(&tmd->qmi_tmd_cli->mutex); | |
| return qmi_tmd_send_state_request(tmd, state); | |
| } | |
| static const struct thermal_cooling_device_ops qmi_tmd_cooling_ops = { | |
| .get_max_state = qmi_tmd_get_max_state, | |
| .get_cur_state = qmi_tmd_get_cur_state, | |
| .set_cur_state = qmi_tmd_set_cur_state, | |
| }; | |
| static int qmi_tmd_register(struct qmi_tmd_client *qmi_tmd_cli, | |
| const char *label, u8 max_state) | |
| { | |
| struct device *dev = qmi_tmd_cli->dev; | |
| struct qmi_tmd *tmd; | |
| int index; | |
| for (index = 0; index < qmi_tmd_cli->num_tmds; index++) { | |
| tmd = &qmi_tmd_cli->tmds[index]; | |
| if (!strncasecmp(tmd->name, label, | |
| QMI_TMD_DEV_ID_LEN_MAX + 1)) | |
| goto found; | |
| } | |
| dev_dbg(qmi_tmd_cli->dev, | |
| "TMD '%s' available in firmware but not specified in DT\n", | |
| label); | |
| return 0; | |
| found: | |
| tmd->max_state = max_state; | |
| /* | |
| * If the cooling device already exists then the QMI service went away and | |
| * came back. So just make sure the current cooling device state is | |
| * reflected on the remote side and then return. | |
| */ | |
| if (tmd->cdev) { | |
| guard(mutex)(&qmi_tmd_cli->mutex); | |
| return qmi_tmd_send_state_request(tmd, tmd->cur_state); | |
| } | |
| tmd->cdev = thermal_of_cooling_device_register(dev->of_node, index, | |
| label, tmd, &qmi_tmd_cooling_ops); | |
| if (IS_ERR(tmd->cdev)) { | |
| int ret = PTR_ERR(tmd->cdev); | |
| tmd->cdev = NULL; | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| static void qmi_tmd_unregister(struct qmi_tmd_client *qmi_tmd_cli) | |
| { | |
| struct qmi_tmd *tmd; | |
| int index; | |
| for (index = 0; index < qmi_tmd_cli->num_tmds; index++) { | |
| tmd = &qmi_tmd_cli->tmds[index]; | |
| if (!tmd->cdev) | |
| continue; | |
| thermal_cooling_device_unregister(tmd->cdev); | |
| tmd->cdev = NULL; | |
| } | |
| } | |
| static void qmi_tmd_svc_arrive(struct work_struct *work) | |
| { | |
| struct qmi_tmd_client *qmi_tmd_cli = | |
| container_of(work, struct qmi_tmd_client, svc_arrive_work); | |
| struct tmd_get_dev_list_req req = { 0 }; | |
| struct tmd_get_dev_list_resp *resp __free(kfree) = NULL; | |
| int ret, i; | |
| struct qmi_txn txn; | |
| resp = kzalloc_obj(*resp); | |
| if (!resp) { | |
| ret = -ENOMEM; | |
| goto out; | |
| } | |
| scoped_guard(mutex, &qmi_tmd_cli->mutex) { | |
| if (qmi_tmd_cli->exiting) | |
| return; | |
| ret = qmi_txn_init(&qmi_tmd_cli->handle, &txn, | |
| tmd_get_dev_list_resp_ei, resp); | |
| if (ret < 0) | |
| goto out; | |
| ret = qmi_send_request(&qmi_tmd_cli->handle, NULL, &txn, | |
| QMI_TMD_GET_DEV_LIST_REQ, | |
| TMD_GET_DEV_LIST_REQ_MAX_LEN, | |
| tmd_get_dev_list_req_ei, &req); | |
| if (ret < 0) { | |
| qmi_txn_cancel(&txn); | |
| goto out; | |
| } | |
| ret = qmi_txn_wait(&txn, QMI_TMD_RESP_TIMEOUT); | |
| if (ret < 0) | |
| goto out; | |
| if (resp->resp.result != QMI_RESULT_SUCCESS_V01) { | |
| ret = -EPROTO; | |
| goto out; | |
| } | |
| qmi_tmd_cli->connection_active = true; | |
| } | |
| for (i = 0; i < resp->mitigation_device_list_len; i++) { | |
| struct tmd_dev_list *device = | |
| &resp->mitigation_device_list[i]; | |
| ret = qmi_tmd_register(qmi_tmd_cli, | |
| device->mitigation_dev_id.mitigation_dev_id, | |
| device->max_mitigation_level); | |
| if (ret) | |
| break; | |
| } | |
| out: | |
| if (ret) | |
| dev_err(qmi_tmd_cli->dev, "Failed to initialize TMD service: %d\n", ret); | |
| } | |
| static void qmi_tmd_del_server(struct qmi_handle *qmi, struct qmi_service *service) | |
| { | |
| struct qmi_tmd_client *qmi_tmd_cli = | |
| container_of(qmi, struct qmi_tmd_client, handle); | |
| scoped_guard(mutex, &qmi_tmd_cli->mutex) { | |
| qmi_tmd_cli->connection_active = false; | |
| } | |
| } | |
| static int qmi_tmd_new_server(struct qmi_handle *qmi, struct qmi_service *service) | |
| { | |
| struct sockaddr_qrtr sq = { AF_QIPCRTR, service->node, service->port }; | |
| struct qmi_tmd_client *qmi_tmd_cli; | |
| int ret; | |
| qmi_tmd_cli = container_of(qmi, struct qmi_tmd_client, handle); | |
| scoped_guard(mutex, &qmi_tmd_cli->mutex) { | |
| if (qmi_tmd_cli->exiting) | |
| return 0; | |
| ret = kernel_connect(qmi->sock, (struct sockaddr_unsized *)&sq, | |
| sizeof(sq), 0); | |
| } | |
| if (ret < 0) { | |
| dev_err(qmi_tmd_cli->dev, "QMI connect failed for node %u port %u: %d\n", | |
| service->node, service->port, ret); | |
| return ret; | |
| } | |
| queue_work(system_highpri_wq, &qmi_tmd_cli->svc_arrive_work); | |
| return 0; | |
| } | |
| static const struct qmi_ops qmi_tmd_ops = { | |
| .new_server = qmi_tmd_new_server, | |
| .del_server = qmi_tmd_del_server, | |
| }; | |
| /** | |
| * qmi_tmd_init() - Initialize QMI TMD instance | |
| * @dev: Device pointer | |
| * @instance_id: QMI service instance ID for the remote subsystem | |
| * @tmd_names: Array of TMD names | |
| * @num_tmds: Number of TMD names | |
| * | |
| * Context: Must be called from probe context. | |
| * | |
| * Return: Pointer to qmi_tmd_client on success, ERR_PTR on failure | |
| */ | |
| struct qmi_tmd_client *qmi_tmd_init(struct device *dev, | |
| unsigned int instance_id, | |
| const char * const *tmd_names, | |
| int num_tmds) | |
| { | |
| struct qmi_tmd_client *qmi_tmd_cli; | |
| int ret, i; | |
| if (!dev || !tmd_names || num_tmds <= 0) | |
| return ERR_PTR(-EINVAL); | |
| qmi_tmd_cli = devm_kzalloc_flex(dev, *qmi_tmd_cli, tmds, num_tmds); | |
| if (!qmi_tmd_cli) | |
| return ERR_PTR(-ENOMEM); | |
| qmi_tmd_cli->dev = dev; | |
| qmi_tmd_cli->num_tmds = num_tmds; | |
| mutex_init(&qmi_tmd_cli->mutex); | |
| INIT_WORK(&qmi_tmd_cli->svc_arrive_work, qmi_tmd_svc_arrive); | |
| for (i = 0; i < num_tmds; i++) { | |
| qmi_tmd_cli->tmds[i].name = tmd_names[i]; | |
| qmi_tmd_cli->tmds[i].qmi_tmd_cli = qmi_tmd_cli; | |
| } | |
| ret = qmi_handle_init(&qmi_tmd_cli->handle, | |
| TMD_GET_DEV_LIST_RESP_MAX_LEN, | |
| &qmi_tmd_ops, NULL); | |
| if (ret < 0) | |
| return ERR_PTR(dev_err_probe(dev, ret, "QMI handle init failed\n")); | |
| ret = qmi_add_lookup(&qmi_tmd_cli->handle, QMI_SERVICE_ID_TMD, | |
| QMI_TMD_SERVICE_VERS_V01, instance_id); | |
| if (ret < 0) { | |
| dev_err_probe(dev, ret, "QMI add lookup failed\n"); | |
| goto err_release_handle; | |
| } | |
| return qmi_tmd_cli; | |
| err_release_handle: | |
| qmi_handle_release(&qmi_tmd_cli->handle); | |
| return ERR_PTR(ret); | |
| } | |
| EXPORT_SYMBOL_GPL(qmi_tmd_init); | |
| /** | |
| * qmi_tmd_exit() - Deinitialize QMI TMD instance | |
| * @qmi_tmd_cli: QMI TMD client to deinitialize | |
| */ | |
| void qmi_tmd_exit(struct qmi_tmd_client *qmi_tmd_cli) | |
| { | |
| if (!qmi_tmd_cli) | |
| return; | |
| scoped_guard(mutex, &qmi_tmd_cli->mutex) { | |
| qmi_tmd_cli->exiting = true; | |
| qmi_tmd_cli->connection_active = false; | |
| } | |
| qmi_handle_release(&qmi_tmd_cli->handle); | |
| cancel_work_sync(&qmi_tmd_cli->svc_arrive_work); | |
| qmi_tmd_unregister(qmi_tmd_cli); | |
| } | |
| EXPORT_SYMBOL_GPL(qmi_tmd_exit); | |
| MODULE_LICENSE("GPL"); | |
| MODULE_DESCRIPTION("Qualcomm QMI Thermal Mitigation support"); |