2 * acpi_fan.c - ACPI Fan Driver ($Revision: 29 $)
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or (at
12 * your option) any later version.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/types.h>
30 #include <linux/uaccess.h>
31 #include <linux/thermal.h>
32 #include <linux/acpi.h>
33 #include <linux/platform_device.h>
34 #include <linux/sort.h>
36 MODULE_AUTHOR("Paul Diefenbaugh");
37 MODULE_DESCRIPTION("ACPI Fan Driver");
38 MODULE_LICENSE("GPL");
40 static int acpi_fan_probe(struct platform_device
*pdev
);
41 static int acpi_fan_remove(struct platform_device
*pdev
);
43 static const struct acpi_device_id fan_device_ids
[] = {
48 MODULE_DEVICE_TABLE(acpi
, fan_device_ids
);
50 #ifdef CONFIG_PM_SLEEP
51 static int acpi_fan_suspend(struct device
*dev
);
52 static int acpi_fan_resume(struct device
*dev
);
53 static struct dev_pm_ops acpi_fan_pm
= {
54 .resume
= acpi_fan_resume
,
55 .freeze
= acpi_fan_suspend
,
56 .thaw
= acpi_fan_resume
,
57 .restore
= acpi_fan_resume
,
59 #define FAN_PM_OPS_PTR (&acpi_fan_pm)
61 #define FAN_PM_OPS_PTR NULL
76 u64 low_speed_notification
;
81 struct acpi_fan_fif fif
;
82 struct acpi_fan_fps
*fps
;
84 struct thermal_cooling_device
*cdev
;
87 static struct platform_driver acpi_fan_driver
= {
88 .probe
= acpi_fan_probe
,
89 .remove
= acpi_fan_remove
,
92 .acpi_match_table
= fan_device_ids
,
97 /* thermal cooling device callbacks */
98 static int fan_get_max_state(struct thermal_cooling_device
*cdev
, unsigned long
101 struct acpi_device
*device
= cdev
->devdata
;
102 struct acpi_fan
*fan
= acpi_driver_data(device
);
105 *state
= fan
->fps_count
- 1;
111 static int fan_get_state_acpi4(struct acpi_device
*device
, unsigned long *state
)
113 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
114 struct acpi_fan
*fan
= acpi_driver_data(device
);
115 union acpi_object
*obj
;
119 status
= acpi_evaluate_object(device
->handle
, "_FST", NULL
, &buffer
);
120 if (ACPI_FAILURE(status
)) {
121 dev_err(&device
->dev
, "Get fan state failed\n");
125 obj
= buffer
.pointer
;
126 if (!obj
|| obj
->type
!= ACPI_TYPE_PACKAGE
||
127 obj
->package
.count
!= 3 ||
128 obj
->package
.elements
[1].type
!= ACPI_TYPE_INTEGER
) {
129 dev_err(&device
->dev
, "Invalid _FST data\n");
134 control
= obj
->package
.elements
[1].integer
.value
;
135 for (i
= 0; i
< fan
->fps_count
; i
++) {
136 if (control
== fan
->fps
[i
].control
)
139 if (i
== fan
->fps_count
) {
140 dev_dbg(&device
->dev
, "Invalid control value returned\n");
152 static int fan_get_state(struct acpi_device
*device
, unsigned long *state
)
155 int acpi_state
= ACPI_STATE_D0
;
157 result
= acpi_device_update_power(device
, &acpi_state
);
161 *state
= acpi_state
== ACPI_STATE_D3_COLD
162 || acpi_state
== ACPI_STATE_D3_HOT
?
163 0 : (acpi_state
== ACPI_STATE_D0
? 1 : -1);
167 static int fan_get_cur_state(struct thermal_cooling_device
*cdev
, unsigned long
170 struct acpi_device
*device
= cdev
->devdata
;
171 struct acpi_fan
*fan
= acpi_driver_data(device
);
174 return fan_get_state_acpi4(device
, state
);
176 return fan_get_state(device
, state
);
179 static int fan_set_state(struct acpi_device
*device
, unsigned long state
)
181 if (state
!= 0 && state
!= 1)
184 return acpi_device_set_power(device
,
185 state
? ACPI_STATE_D0
: ACPI_STATE_D3_COLD
);
188 static int fan_set_state_acpi4(struct acpi_device
*device
, unsigned long state
)
190 struct acpi_fan
*fan
= acpi_driver_data(device
);
193 if (state
>= fan
->fps_count
)
196 status
= acpi_execute_simple_method(device
->handle
, "_FSL",
197 fan
->fps
[state
].control
);
198 if (ACPI_FAILURE(status
)) {
199 dev_dbg(&device
->dev
, "Failed to set state by _FSL\n");
207 fan_set_cur_state(struct thermal_cooling_device
*cdev
, unsigned long state
)
209 struct acpi_device
*device
= cdev
->devdata
;
210 struct acpi_fan
*fan
= acpi_driver_data(device
);
213 return fan_set_state_acpi4(device
, state
);
215 return fan_set_state(device
, state
);
218 static const struct thermal_cooling_device_ops fan_cooling_ops
= {
219 .get_max_state
= fan_get_max_state
,
220 .get_cur_state
= fan_get_cur_state
,
221 .set_cur_state
= fan_set_cur_state
,
224 /* --------------------------------------------------------------------------
226 * --------------------------------------------------------------------------
229 static bool acpi_fan_is_acpi4(struct acpi_device
*device
)
231 return acpi_has_method(device
->handle
, "_FIF") &&
232 acpi_has_method(device
->handle
, "_FPS") &&
233 acpi_has_method(device
->handle
, "_FSL") &&
234 acpi_has_method(device
->handle
, "_FST");
237 static int acpi_fan_get_fif(struct acpi_device
*device
)
239 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
240 struct acpi_fan
*fan
= acpi_driver_data(device
);
241 struct acpi_buffer format
= { sizeof("NNNN"), "NNNN" };
242 struct acpi_buffer fif
= { sizeof(fan
->fif
), &fan
->fif
};
243 union acpi_object
*obj
;
246 status
= acpi_evaluate_object(device
->handle
, "_FIF", NULL
, &buffer
);
247 if (ACPI_FAILURE(status
))
250 obj
= buffer
.pointer
;
251 if (!obj
|| obj
->type
!= ACPI_TYPE_PACKAGE
) {
252 dev_err(&device
->dev
, "Invalid _FIF data\n");
257 status
= acpi_extract_package(obj
, &format
, &fif
);
258 if (ACPI_FAILURE(status
)) {
259 dev_err(&device
->dev
, "Invalid _FIF element\n");
268 static int acpi_fan_speed_cmp(const void *a
, const void *b
)
270 const struct acpi_fan_fps
*fps1
= a
;
271 const struct acpi_fan_fps
*fps2
= b
;
272 return fps1
->speed
- fps2
->speed
;
275 static int acpi_fan_get_fps(struct acpi_device
*device
)
277 struct acpi_fan
*fan
= acpi_driver_data(device
);
278 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
279 union acpi_object
*obj
;
283 status
= acpi_evaluate_object(device
->handle
, "_FPS", NULL
, &buffer
);
284 if (ACPI_FAILURE(status
))
287 obj
= buffer
.pointer
;
288 if (!obj
|| obj
->type
!= ACPI_TYPE_PACKAGE
|| obj
->package
.count
< 2) {
289 dev_err(&device
->dev
, "Invalid _FPS data\n");
294 fan
->fps_count
= obj
->package
.count
- 1; /* minus revision field */
295 fan
->fps
= devm_kzalloc(&device
->dev
,
296 fan
->fps_count
* sizeof(struct acpi_fan_fps
),
299 dev_err(&device
->dev
, "Not enough memory\n");
303 for (i
= 0; i
< fan
->fps_count
; i
++) {
304 struct acpi_buffer format
= { sizeof("NNNNN"), "NNNNN" };
305 struct acpi_buffer fps
= { sizeof(fan
->fps
[i
]), &fan
->fps
[i
] };
306 status
= acpi_extract_package(&obj
->package
.elements
[i
+ 1],
308 if (ACPI_FAILURE(status
)) {
309 dev_err(&device
->dev
, "Invalid _FPS element\n");
314 /* sort the state array according to fan speed in increase order */
315 sort(fan
->fps
, fan
->fps_count
, sizeof(*fan
->fps
),
316 acpi_fan_speed_cmp
, NULL
);
323 static int acpi_fan_probe(struct platform_device
*pdev
)
326 struct thermal_cooling_device
*cdev
;
327 struct acpi_fan
*fan
;
328 struct acpi_device
*device
= ACPI_COMPANION(&pdev
->dev
);
331 fan
= devm_kzalloc(&pdev
->dev
, sizeof(*fan
), GFP_KERNEL
);
333 dev_err(&device
->dev
, "No memory for fan\n");
336 device
->driver_data
= fan
;
337 platform_set_drvdata(pdev
, fan
);
339 if (acpi_fan_is_acpi4(device
)) {
340 if (acpi_fan_get_fif(device
) || acpi_fan_get_fps(device
))
344 result
= acpi_device_update_power(device
, NULL
);
346 dev_err(&device
->dev
, "Setting initial power state\n");
351 if (!strncmp(pdev
->name
, "PNP0C0B", strlen("PNP0C0B")))
354 name
= acpi_device_bid(device
);
356 cdev
= thermal_cooling_device_register(name
, device
,
359 result
= PTR_ERR(cdev
);
363 dev_dbg(&pdev
->dev
, "registered as cooling_device%d\n", cdev
->id
);
366 result
= sysfs_create_link(&pdev
->dev
.kobj
,
370 dev_err(&pdev
->dev
, "Failed to create sysfs link 'thermal_cooling'\n");
372 result
= sysfs_create_link(&cdev
->device
.kobj
,
376 dev_err(&pdev
->dev
, "Failed to create sysfs link 'device'\n");
382 static int acpi_fan_remove(struct platform_device
*pdev
)
384 struct acpi_fan
*fan
= platform_get_drvdata(pdev
);
386 sysfs_remove_link(&pdev
->dev
.kobj
, "thermal_cooling");
387 sysfs_remove_link(&fan
->cdev
->device
.kobj
, "device");
388 thermal_cooling_device_unregister(fan
->cdev
);
393 #ifdef CONFIG_PM_SLEEP
394 static int acpi_fan_suspend(struct device
*dev
)
396 struct acpi_fan
*fan
= dev_get_drvdata(dev
);
400 acpi_device_set_power(ACPI_COMPANION(dev
), ACPI_STATE_D0
);
405 static int acpi_fan_resume(struct device
*dev
)
408 struct acpi_fan
*fan
= dev_get_drvdata(dev
);
413 result
= acpi_device_update_power(ACPI_COMPANION(dev
), NULL
);
415 dev_err(dev
, "Error updating fan power state\n");
421 module_platform_driver(acpi_fan_driver
);