| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <assert.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <threads.h> |
| #include <unistd.h> |
| |
| #include <ddk/binding.h> |
| #include <ddk/debug.h> |
| #include <ddk/device.h> |
| #include <ddk/driver.h> |
| #include <ddk/metadata.h> |
| #include <ddk/protocol/gpio.h> |
| #include <ddk/protocol/platform-defs.h> |
| #include <ddk/protocol/platform-device.h> |
| #include <ddk/protocol/scpi.h> |
| #include <soc/aml-common/aml-thermal.h> |
| #include <zircon/device/thermal.h> |
| #include <zircon/process.h> |
| #include <zircon/syscalls.h> |
| #include <zircon/syscalls/port.h> |
| |
| static void aml_set_fan_level(aml_thermal_t* dev, uint32_t level) { |
| switch (level) { |
| case 0: |
| gpio_write(&dev->gpio, FAN_CTL0, 0); |
| gpio_write(&dev->gpio, FAN_CTL1, 0); |
| break; |
| case 1: |
| gpio_write(&dev->gpio, FAN_CTL0, 1); |
| gpio_write(&dev->gpio, FAN_CTL1, 0); |
| break; |
| case 2: |
| gpio_write(&dev->gpio, FAN_CTL0, 0); |
| gpio_write(&dev->gpio, FAN_CTL1, 1); |
| break; |
| case 3: |
| gpio_write(&dev->gpio, FAN_CTL0, 1); |
| gpio_write(&dev->gpio, FAN_CTL1, 1); |
| break; |
| default: |
| break; |
| } |
| dev->current_fan_level = level; |
| } |
| |
| static zx_status_t aml_notify_thermal_deamon(zx_handle_t port, uint32_t trip_id) { |
| zx_port_packet_t thermal_port_packet; |
| thermal_port_packet.key = trip_id; |
| thermal_port_packet.type = ZX_PKT_TYPE_USER; |
| return zx_port_queue(port, &thermal_port_packet); |
| } |
| |
| static int aml_thermal_notify_thread(void* ctx) { |
| aml_thermal_t* dev = ctx; |
| uint32_t temperature; |
| bool critical_temp_measure_taken = false; |
| |
| // Notify the thermal deamon about the default settings |
| zx_status_t status = aml_notify_thermal_deamon(dev->port, dev->current_trip_idx); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Failed to send packet via port to Thermal Deamon: Thermal disabled"); |
| return status; |
| } |
| |
| while (true) { |
| status = scpi_get_sensor_value(&dev->scpi, |
| dev->temp_sensor_id, |
| &temperature); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Unable to get thermal sensor value: Thermal disabled\n"); |
| return status; |
| } |
| |
| // Update the temperature in our context |
| dev->current_temperature = temperature; |
| |
| uint32_t idx = dev->current_trip_idx; |
| bool signal = true; |
| |
| if ((idx != dev->device->num_trip_points - 1) && |
| (temperature >= dev->device->trip_point_info[idx + 1].up_temp)) { |
| // Triggered next trip point |
| dev->current_trip_idx = idx + 1; |
| } else if (idx != 0 && temperature < dev->device->trip_point_info[idx].down_temp) { |
| // Triggered prev trip point |
| dev->current_trip_idx = idx - 1; |
| if (idx == dev->device->num_trip_points - 1) { |
| // A prev trip point triggered, so the temperature |
| // is falling down below the critical temperature |
| // make a note of that |
| critical_temp_measure_taken = false; |
| } |
| } else if ((idx == dev->device->num_trip_points - 1) && |
| (temperature >= dev->device->critical_temp) && |
| critical_temp_measure_taken != true) { |
| // The device temperature is crossing the critical |
| // temperature, set the CPU freq to the lowest possible |
| // setting to ensure the temperature doesn't rise any further |
| signal = false; |
| critical_temp_measure_taken = true; |
| status = scpi_set_dvfs_idx(&dev->scpi, BIG_CLUSTER_POWER_DOMAIN, 0); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Unable to set DVFS OPP for Big cluster\n"); |
| return status; |
| } |
| status = scpi_set_dvfs_idx(&dev->scpi, LITTLE_CLUSTER_POWER_DOMAIN, 0); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Unable to set DVFS OPP for Little cluster\n"); |
| return status; |
| } |
| } else { |
| signal = false; |
| } |
| |
| if (signal) { |
| // Notify the thermal deamon about which trip point triggered |
| status = aml_notify_thermal_deamon(dev->port, dev->current_trip_idx); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Failed to send packet via port to Thermal Deamon: Thermal disabled"); |
| return status; |
| } |
| } |
| |
| sleep(5); |
| } |
| return ZX_OK; |
| } |
| |
| static zx_status_t aml_thermal_set_dvfs_opp(aml_thermal_t* dev, |
| dvfs_info_t* info) { |
| bool set_new_opp = false; |
| |
| if (info->power_domain == BIG_CLUSTER_POWER_DOMAIN) { |
| if (dev->current_big_cluster_opp_idx != info->op_idx) { |
| set_new_opp = true; |
| dev->current_big_cluster_opp_idx = info->op_idx; |
| } |
| } else { |
| if (dev->current_little_cluster_opp_idx != info->op_idx) { |
| set_new_opp = true; |
| dev->current_little_cluster_opp_idx = info->op_idx; |
| } |
| } |
| |
| if (set_new_opp) { |
| return scpi_set_dvfs_idx(&dev->scpi, info->power_domain, info->op_idx); |
| } else { |
| return ZX_OK; |
| } |
| } |
| |
| static void aml_thermal_get_device_info(aml_thermal_t* dev, |
| thermal_device_info_t* info) { |
| memcpy(info, dev->device, sizeof(thermal_device_info_t)); |
| } |
| |
| static zx_status_t aml_thermal_get_state_change_port(aml_thermal_t* dev, |
| zx_handle_t* port) { |
| return zx_handle_duplicate(dev->port, ZX_RIGHT_SAME_RIGHTS, port); |
| } |
| |
| static void aml_thermal_release(void* ctx) { |
| aml_thermal_t* thermal = ctx; |
| zx_handle_close(thermal->port); |
| int res; |
| thrd_join(thermal->notify_thread, &res); |
| free(thermal->device); |
| free(thermal); |
| } |
| |
| static zx_status_t aml_thermal_ioctl(void* ctx, uint32_t op, |
| const void* in_buf, size_t in_len, |
| void* out_buf, size_t out_len, |
| size_t* out_actual) { |
| aml_thermal_t* dev = ctx; |
| zx_status_t status = ZX_OK; |
| |
| switch (op) { |
| case IOCTL_THERMAL_GET_DEVICE_INFO: { |
| if (out_len != sizeof(thermal_device_info_t)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| thermal_device_info_t info; |
| aml_thermal_get_device_info(dev, &info); |
| memcpy(out_buf, &info, sizeof(thermal_device_info_t)); |
| *out_actual = sizeof(thermal_device_info_t); |
| return ZX_OK; |
| } |
| |
| case IOCTL_THERMAL_GET_STATE_CHANGE_PORT: { |
| if (out_len != sizeof(zx_handle_t)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| status = aml_thermal_get_state_change_port(dev, out_buf); |
| if (status != ZX_OK) { |
| return status; |
| } |
| *out_actual = sizeof(zx_handle_t); |
| return ZX_OK; |
| } |
| |
| case IOCTL_THERMAL_SET_FAN_LEVEL: { |
| if (in_len != sizeof(uint32_t)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| uint32_t* fan_level = (uint32_t*)in_buf; |
| aml_set_fan_level(dev, *fan_level); |
| return ZX_OK; |
| } |
| |
| case IOCTL_THERMAL_GET_FAN_LEVEL: { |
| if (out_len != sizeof(uint32_t)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| uint32_t* fan_level = (uint32_t*)out_buf; |
| *fan_level = dev->current_fan_level; |
| *out_actual = sizeof(uint32_t); |
| return ZX_OK; |
| } |
| |
| case IOCTL_THERMAL_SET_DVFS_OPP: { |
| if (in_len != sizeof(dvfs_info_t)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| dvfs_info_t* dvfs_info = (dvfs_info_t*)in_buf; |
| return aml_thermal_set_dvfs_opp(dev, dvfs_info); |
| } |
| |
| case IOCTL_THERMAL_GET_TEMPERATURE: { |
| if (out_len != sizeof(uint32_t)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| uint32_t* temperature = (uint32_t*)out_buf; |
| *temperature = dev->current_temperature; |
| *out_actual = sizeof(uint32_t); |
| return ZX_OK; |
| } |
| |
| case IOCTL_THERMAL_GET_DVFS_INFO: { |
| if (in_len != sizeof(uint32_t) || out_len != sizeof(scpi_opp_t)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| uint32_t* power_domain = (uint32_t*)in_buf; |
| if (*power_domain >= MAX_DVFS_DOMAINS) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| memcpy(out_buf, &dev->device->opps[*power_domain], |
| sizeof(scpi_opp_t)); |
| *out_actual = sizeof(scpi_opp_t); |
| return ZX_OK; |
| } |
| |
| case IOCTL_THERMAL_GET_DVFS_OPP: { |
| if (in_len != sizeof(uint32_t) || out_len != sizeof(uint32_t)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| uint32_t* power_domain = (uint32_t*)in_buf; |
| uint32_t* opp_idx = (uint32_t*)out_buf; |
| if (power_domain == BIG_CLUSTER_POWER_DOMAIN) { |
| *opp_idx = dev->current_big_cluster_opp_idx; |
| } else { |
| *opp_idx = dev->current_little_cluster_opp_idx; |
| } |
| *out_actual = sizeof(uint32_t); |
| return ZX_OK; |
| } |
| |
| default: |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| } |
| |
| static zx_protocol_device_t aml_thermal_device_protocol = { |
| .version = DEVICE_OPS_VERSION, |
| .release = aml_thermal_release, |
| .ioctl = aml_thermal_ioctl, |
| }; |
| |
| static zx_status_t aml_thermal_init(aml_thermal_t* thermal) { |
| pdev_device_info_t info; |
| zx_status_t status = pdev_get_device_info(&thermal->pdev, &info); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("pdev_get_device_info failed\n"); |
| return status; |
| } |
| |
| // Configure the GPIOs |
| for (uint32_t i = 0; i < info.gpio_count; i++) { |
| status = gpio_config(&thermal->gpio, i, GPIO_DIR_OUT); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("gpio_config failed\n"); |
| return status; |
| } |
| } |
| |
| // Create the thermal event |
| status = zx_port_create(0, &thermal->port); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Unable to create thermal port\n"); |
| return status; |
| } |
| |
| thermal->current_trip_idx = 0; |
| |
| // Populate DVFS info |
| status = scpi_get_dvfs_info(&thermal->scpi, BIG_CLUSTER_POWER_DOMAIN, |
| &thermal->device->opps[0]); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("scpi_get_dvfs_info for big cluster failed %d\n", status); |
| return status; |
| } |
| |
| status = scpi_get_dvfs_info(&thermal->scpi, LITTLE_CLUSTER_POWER_DOMAIN, |
| &thermal->device->opps[1]); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("scpi_get_dvfs_info for little cluster failed %d\n", status); |
| return status; |
| } |
| |
| // Populate thermal sensor info |
| status = scpi_get_sensor(&thermal->scpi, "aml_thermal", &thermal->temp_sensor_id); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Unable to get thermal sensor information: Thermal disabled\n"); |
| return status; |
| } |
| return ZX_OK; |
| } |
| |
| static zx_status_t aml_thermal_bind(void* ctx, zx_device_t* parent) { |
| zx_status_t status = ZX_OK; |
| printf("aml_thermal_bind 1\n"); |
| |
| aml_thermal_t* thermal = calloc(1, sizeof(aml_thermal_t)); |
| if (!thermal) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| status = device_get_protocol(parent, ZX_PROTOCOL_PLATFORM_DEV, &thermal->pdev); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Could not get parent protocol\n"); |
| goto fail; |
| } |
| printf("aml_thermal_bind 2\n"); |
| |
| status = device_get_protocol(parent, ZX_PROTOCOL_GPIO, &thermal->gpio); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Could not get GPIO protocol\n"); |
| goto fail; |
| } |
| |
| printf("aml_thermal_bind 3\n"); |
| status = device_get_protocol(parent, ZX_PROTOCOL_SCPI, &thermal->scpi); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Could not get SCPI protocol\n"); |
| goto fail; |
| } |
| |
| printf("aml_thermal_bind 4\n"); |
| // Populate board specific information |
| thermal_device_info_t* dev_config = calloc(1, sizeof(thermal_device_info_t)); |
| if (!dev_config) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| size_t actual; |
| status = device_get_metadata(parent, DEVICE_METADATA_PRIVATE, |
| dev_config, sizeof(thermal_device_info_t), &actual); |
| if (status != ZX_OK || actual != sizeof(thermal_device_info_t)) { |
| THERMAL_ERROR("Could not get metadata\n"); |
| goto fail; |
| } |
| |
| printf("aml_thermal_bind 5\n"); |
| |
| thermal->device = dev_config; |
| |
| status = aml_thermal_init(thermal); |
| if (status != ZX_OK) { |
| THERMAL_ERROR("Thermal init failed\n"); |
| goto fail; |
| } |
| |
| device_add_args_t args = { |
| .version = DEVICE_ADD_ARGS_VERSION, |
| .name = "vim-thermal", |
| .ctx = thermal, |
| .ops = &aml_thermal_device_protocol, |
| .proto_id = ZX_PROTOCOL_THERMAL, |
| }; |
| |
| status = device_add(parent, &args, &thermal->zxdev); |
| if (status != ZX_OK) { |
| goto fail; |
| } |
| |
| thrd_create_with_name(&thermal->notify_thread, aml_thermal_notify_thread, |
| thermal, "aml_thermal_notify_thread"); |
| |
| return ZX_OK; |
| fail: |
| zx_handle_close(thermal->port); |
| free(thermal->device); |
| free(thermal); |
| return status; |
| } |
| |
| static zx_driver_ops_t aml_thermal_driver_ops = { |
| .version = DRIVER_OPS_VERSION, |
| .bind = aml_thermal_bind, |
| }; |
| |
| ZIRCON_DRIVER_BEGIN(aml_thermal, aml_thermal_driver_ops, "zircon", "0.1", 4) |
| BI_ABORT_IF(NE, BIND_PROTOCOL, ZX_PROTOCOL_PLATFORM_DEV), |
| BI_ABORT_IF(NE, BIND_PLATFORM_DEV_VID, PDEV_VID_AMLOGIC), |
| BI_ABORT_IF(NE, BIND_PLATFORM_DEV_PID, PDEV_PID_GENERIC), |
| BI_MATCH_IF(EQ, BIND_PLATFORM_DEV_DID, PDEV_DID_AMLOGIC_THERMAL), |
| ZIRCON_DRIVER_END(aml_thermal) |
