drivers/platform/x86/gpd-pocket-fan.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * GPD Pocket fan controller driver
   4  *
   5  * Copyright (C) 2017 Hans de Goede <hdegoede@redhat.com>
   6  */
   7
   8 #include <linux/acpi.h>
   9 #include <linux/devm-helpers.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/module.h>
  12 #include <linux/moduleparam.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/power_supply.h>
  15 #include <linux/thermal.h>
  16 #include <linux/workqueue.h>
  17
  18 #define MAX_SPEED 3
  19
  20 #define TEMP_LIMIT0_DEFAULT     55000
  21 #define TEMP_LIMIT1_DEFAULT     60000
  22 #define TEMP_LIMIT2_DEFAULT     65000
  23
  24 #define HYSTERESIS_DEFAULT      3000
  25
  26 #define SPEED_ON_AC_DEFAULT     2
  27
  28 static int temp_limits[3] = {
  29         TEMP_LIMIT0_DEFAULT, TEMP_LIMIT1_DEFAULT, TEMP_LIMIT2_DEFAULT,
  30 };
  31 module_param_array(temp_limits, int, NULL, 0444);
  32 MODULE_PARM_DESC(temp_limits,
  33                  "Millicelsius values above which the fan speed increases");
  34
  35 static int hysteresis = HYSTERESIS_DEFAULT;
  36 module_param(hysteresis, int, 0444);
  37 MODULE_PARM_DESC(hysteresis,
  38                  "Hysteresis in millicelsius before lowering the fan speed");
  39
  40 static int speed_on_ac = SPEED_ON_AC_DEFAULT;
  41 module_param(speed_on_ac, int, 0444);
  42 MODULE_PARM_DESC(speed_on_ac,
  43                  "minimum fan speed to allow when system is powered by AC");
  44
  45 struct gpd_pocket_fan_data {
  46         struct device *dev;
  47         struct thermal_zone_device *dts0;
  48         struct thermal_zone_device *dts1;
  49         struct gpio_desc *gpio0;
  50         struct gpio_desc *gpio1;
  51         struct delayed_work work;
  52         int last_speed;
  53 };
  54
  55 static void gpd_pocket_fan_set_speed(struct gpd_pocket_fan_data *fan, int speed)
  56 {
  57         if (speed == fan->last_speed)
  58                 return;
  59
  60         gpiod_direction_output(fan->gpio0, !!(speed & 1));
  61         gpiod_direction_output(fan->gpio1, !!(speed & 2));
  62
  63         fan->last_speed = speed;
  64 }
  65
  66 static int gpd_pocket_fan_min_speed(void)
  67 {
  68         if (power_supply_is_system_supplied())
  69                 return speed_on_ac;
  70         else
  71                 return 0;
  72 }
  73
  74 static void gpd_pocket_fan_worker(struct work_struct *work)
  75 {
  76         struct gpd_pocket_fan_data *fan =
  77                 container_of(work, struct gpd_pocket_fan_data, work.work);
  78         int t0, t1, temp, speed, min_speed, i;
  79
  80         if (thermal_zone_get_temp(fan->dts0, &t0) ||
  81             thermal_zone_get_temp(fan->dts1, &t1)) {
  82                 dev_warn(fan->dev, "Error getting temperature\n");
  83                 speed = MAX_SPEED;
  84                 goto set_speed;
  85         }
  86
  87         temp = max(t0, t1);
  88
  89         speed = fan->last_speed;
  90         min_speed = gpd_pocket_fan_min_speed();
  91
  92         /* Determine minimum speed */
  93         for (i = min_speed; i < ARRAY_SIZE(temp_limits); i++) {
  94                 if (temp < temp_limits[i])
  95                         break;
  96         }
  97         if (speed < i)
  98                 speed = i;
  99
 100         /* Use hysteresis before lowering speed again */
 101         for (i = min_speed; i < ARRAY_SIZE(temp_limits); i++) {
 102                 if (temp <= (temp_limits[i] - hysteresis))
 103                         break;
 104         }
 105         if (speed > i)
 106                 speed = i;
 107
 108         if (fan->last_speed <= 0 && speed)
 109                 speed = MAX_SPEED; /* kick start motor */
 110
 111 set_speed:
 112         gpd_pocket_fan_set_speed(fan, speed);
 113
 114         /* When mostly idle (low temp/speed), slow down the poll interval. */
 115         queue_delayed_work(system_wq, &fan->work,
 116                            msecs_to_jiffies(4000 / (speed + 1)));
 117 }
 118
 119 static void gpd_pocket_fan_force_update(struct gpd_pocket_fan_data *fan)
 120 {
 121         fan->last_speed = -1;
 122         mod_delayed_work(system_wq, &fan->work, 0);
 123 }
 124
 125 static int gpd_pocket_fan_probe(struct platform_device *pdev)
 126 {
 127         struct gpd_pocket_fan_data *fan;
 128         int i, ret;
 129
 130         for (i = 0; i < ARRAY_SIZE(temp_limits); i++) {
 131                 if (temp_limits[i] < 20000 || temp_limits[i] > 90000) {
 132                         dev_err(&pdev->dev, "Invalid temp-limit %d (must be between 20000 and 90000)\n",
 133                                 temp_limits[i]);
 134                         temp_limits[0] = TEMP_LIMIT0_DEFAULT;
 135                         temp_limits[1] = TEMP_LIMIT1_DEFAULT;
 136                         temp_limits[2] = TEMP_LIMIT2_DEFAULT;
 137                         break;
 138                 }
 139         }
 140         if (hysteresis < 1000 || hysteresis > 10000) {
 141                 dev_err(&pdev->dev, "Invalid hysteresis %d (must be between 1000 and 10000)\n",
 142                         hysteresis);
 143                 hysteresis = HYSTERESIS_DEFAULT;
 144         }
 145         if (speed_on_ac < 0 || speed_on_ac > MAX_SPEED) {
 146                 dev_err(&pdev->dev, "Invalid speed_on_ac %d (must be between 0 and 3)\n",
 147                         speed_on_ac);
 148                 speed_on_ac = SPEED_ON_AC_DEFAULT;
 149         }
 150
 151         fan = devm_kzalloc(&pdev->dev, sizeof(*fan), GFP_KERNEL);
 152         if (!fan)
 153                 return -ENOMEM;
 154
 155         fan->dev = &pdev->dev;
 156         ret = devm_delayed_work_autocancel(&pdev->dev, &fan->work,
 157                                            gpd_pocket_fan_worker);
 158         if (ret)
 159                 return ret;
 160
 161         /* Note this returns a "weak" reference which we don't need to free */
 162         fan->dts0 = thermal_zone_get_zone_by_name("soc_dts0");
 163         if (IS_ERR(fan->dts0))
 164                 return -EPROBE_DEFER;
 165
 166         fan->dts1 = thermal_zone_get_zone_by_name("soc_dts1");
 167         if (IS_ERR(fan->dts1))
 168                 return -EPROBE_DEFER;
 169
 170         fan->gpio0 = devm_gpiod_get_index(fan->dev, NULL, 0, GPIOD_ASIS);
 171         if (IS_ERR(fan->gpio0))
 172                 return PTR_ERR(fan->gpio0);
 173
 174         fan->gpio1 = devm_gpiod_get_index(fan->dev, NULL, 1, GPIOD_ASIS);
 175         if (IS_ERR(fan->gpio1))
 176                 return PTR_ERR(fan->gpio1);
 177
 178         gpd_pocket_fan_force_update(fan);
 179
 180         platform_set_drvdata(pdev, fan);
 181         return 0;
 182 }
 183
 184 #ifdef CONFIG_PM_SLEEP
 185 static int gpd_pocket_fan_suspend(struct device *dev)
 186 {
 187         struct gpd_pocket_fan_data *fan = dev_get_drvdata(dev);
 188
 189         cancel_delayed_work_sync(&fan->work);
 190         gpd_pocket_fan_set_speed(fan, gpd_pocket_fan_min_speed());
 191         return 0;
 192 }
 193
 194 static int gpd_pocket_fan_resume(struct device *dev)
 195 {
 196         struct gpd_pocket_fan_data *fan = dev_get_drvdata(dev);
 197
 198         gpd_pocket_fan_force_update(fan);
 199         return 0;
 200 }
 201 #endif
 202 static SIMPLE_DEV_PM_OPS(gpd_pocket_fan_pm_ops,
 203                          gpd_pocket_fan_suspend,
 204                          gpd_pocket_fan_resume);
 205
 206 static struct acpi_device_id gpd_pocket_fan_acpi_match[] = {
 207         { "FAN02501" },
 208         {},
 209 };
 210 MODULE_DEVICE_TABLE(acpi, gpd_pocket_fan_acpi_match);
 211
 212 static struct platform_driver gpd_pocket_fan_driver = {
 213         .probe  = gpd_pocket_fan_probe,
 214         .driver = {
 215                 .name                   = "gpd_pocket_fan",
 216                 .acpi_match_table       = gpd_pocket_fan_acpi_match,
 217                 .pm                     = &gpd_pocket_fan_pm_ops,
 218          },
 219 };
 220
 221 module_platform_driver(gpd_pocket_fan_driver);
 222 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com");
 223 MODULE_DESCRIPTION("GPD pocket fan driver");
 224 MODULE_LICENSE("GPL");