1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 *  Intel menlow Driver for thermal management extension
  4 *
  5 *  Copyright (C) 2008 Intel Corp
  6 *  Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
  7 *  Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
  8 *
  9 *  This driver creates the sys I/F for programming the sensors.
 10 *  It also implements the driver for intel menlow memory controller (hardware
 11 *  id is INT0002) which makes use of the platform specific ACPI methods
 12 *  to get/set bandwidth.
 13 */
 14
 15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 16
 17#include <linux/acpi.h>
 18#include <linux/kernel.h>
 19#include <linux/module.h>
 20#include <linux/pci.h>
 21#include <linux/pm.h>
 22#include <linux/slab.h>
 23#include <linux/thermal.h>
 24#include <linux/types.h>
 25
 26MODULE_AUTHOR("Thomas Sujith");
 27MODULE_AUTHOR("Zhang Rui");
 28MODULE_DESCRIPTION("Intel Menlow platform specific driver");
 29MODULE_LICENSE("GPL v2");
 30
 31/*
 32 * Memory controller device control
 33 */
 34
 35#define MEMORY_GET_BANDWIDTH "GTHS"
 36#define MEMORY_SET_BANDWIDTH "STHS"
 37#define MEMORY_ARG_CUR_BANDWIDTH 1
 38#define MEMORY_ARG_MAX_BANDWIDTH 0
 39
 40static void intel_menlow_unregister_sensor(void);
 41
 42/*
 43 * GTHS returning 'n' would mean that [0,n-1] states are supported
 44 * In that case max_cstate would be n-1
 45 * GTHS returning '0' would mean that no bandwidth control states are supported
 46 */
 47static int memory_get_max_bandwidth(struct thermal_cooling_device *cdev,
 48				    unsigned long *max_state)
 49{
 50	struct acpi_device *device = cdev->devdata;
 51	acpi_handle handle = device->handle;
 52	unsigned long long value;
 53	struct acpi_object_list arg_list;
 54	union acpi_object arg;
 55	acpi_status status = AE_OK;
 56
 57	arg_list.count = 1;
 58	arg_list.pointer = &arg;
 59	arg.type = ACPI_TYPE_INTEGER;
 60	arg.integer.value = MEMORY_ARG_MAX_BANDWIDTH;
 61	status = acpi_evaluate_integer(handle, MEMORY_GET_BANDWIDTH,
 62				       &arg_list, &value);
 63	if (ACPI_FAILURE(status))
 64		return -EFAULT;
 65
 66	if (!value)
 67		return -EINVAL;
 68
 69	*max_state = value - 1;
 70	return 0;
 71}
 72
 73static int memory_get_cur_bandwidth(struct thermal_cooling_device *cdev,
 74				    unsigned long *value)
 75{
 76	struct acpi_device *device = cdev->devdata;
 77	acpi_handle handle = device->handle;
 78	unsigned long long result;
 79	struct acpi_object_list arg_list;
 80	union acpi_object arg;
 81	acpi_status status = AE_OK;
 82
 83	arg_list.count = 1;
 84	arg_list.pointer = &arg;
 85	arg.type = ACPI_TYPE_INTEGER;
 86	arg.integer.value = MEMORY_ARG_CUR_BANDWIDTH;
 87	status = acpi_evaluate_integer(handle, MEMORY_GET_BANDWIDTH,
 88				       &arg_list, &result);
 89	if (ACPI_FAILURE(status))
 90		return -EFAULT;
 91
 92	*value = result;
 93	return 0;
 94}
 95
 96static int memory_set_cur_bandwidth(struct thermal_cooling_device *cdev,
 97				    unsigned long state)
 98{
 99	struct acpi_device *device = cdev->devdata;
100	acpi_handle handle = device->handle;
101	struct acpi_object_list arg_list;
102	union acpi_object arg;
103	acpi_status status;
104	unsigned long long temp;
105	unsigned long max_state;
106
107	if (memory_get_max_bandwidth(cdev, &max_state))
108		return -EFAULT;
109
110	if (state > max_state)
111		return -EINVAL;
112
113	arg_list.count = 1;
114	arg_list.pointer = &arg;
115	arg.type = ACPI_TYPE_INTEGER;
116	arg.integer.value = state;
117
118	status =
119	    acpi_evaluate_integer(handle, MEMORY_SET_BANDWIDTH, &arg_list,
120				  &temp);
121
122	pr_info("Bandwidth value was %ld: status is %d\n", state, status);
123	if (ACPI_FAILURE(status))
124		return -EFAULT;
125
126	return 0;
127}
128
129static const struct thermal_cooling_device_ops memory_cooling_ops = {
130	.get_max_state = memory_get_max_bandwidth,
131	.get_cur_state = memory_get_cur_bandwidth,
132	.set_cur_state = memory_set_cur_bandwidth,
133};
134
135/*
136 * Memory Device Management
137 */
138static int intel_menlow_memory_add(struct acpi_device *device)
139{
140	int result = -ENODEV;
141	struct thermal_cooling_device *cdev;
142
143	if (!device)
144		return -EINVAL;
145
146	if (!acpi_has_method(device->handle, MEMORY_GET_BANDWIDTH))
147		goto end;
148
149	if (!acpi_has_method(device->handle, MEMORY_SET_BANDWIDTH))
150		goto end;
151
152	cdev = thermal_cooling_device_register("Memory controller", device,
153					       &memory_cooling_ops);
154	if (IS_ERR(cdev)) {
155		result = PTR_ERR(cdev);
156		goto end;
157	}
158
159	device->driver_data = cdev;
160	result = sysfs_create_link(&device->dev.kobj,
161				&cdev->device.kobj, "thermal_cooling");
162	if (result)
163		goto unregister;
164
165	result = sysfs_create_link(&cdev->device.kobj,
166				&device->dev.kobj, "device");
167	if (result) {
168		sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
169		goto unregister;
170	}
171
172 end:
173	return result;
174
175 unregister:
176	thermal_cooling_device_unregister(cdev);
177	return result;
178
179}
180
181static int intel_menlow_memory_remove(struct acpi_device *device)
182{
183	struct thermal_cooling_device *cdev;
184
185	if (!device)
186		return -EINVAL;
187
188	cdev = acpi_driver_data(device);
189	if (!cdev)
190		return -EINVAL;
191
192	sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
193	sysfs_remove_link(&cdev->device.kobj, "device");
194	thermal_cooling_device_unregister(cdev);
195
196	return 0;
197}
198
199static const struct acpi_device_id intel_menlow_memory_ids[] = {
200	{"INT0002", 0},
201	{"", 0},
202};
203
204static struct acpi_driver intel_menlow_memory_driver = {
205	.name = "intel_menlow_thermal_control",
206	.ids = intel_menlow_memory_ids,
207	.ops = {
208		.add = intel_menlow_memory_add,
209		.remove = intel_menlow_memory_remove,
210		},
211};
212
213/*
214 * Sensor control on menlow platform
215 */
216
217#define THERMAL_AUX0 0
218#define THERMAL_AUX1 1
219#define GET_AUX0 "GAX0"
220#define GET_AUX1 "GAX1"
221#define SET_AUX0 "SAX0"
222#define SET_AUX1 "SAX1"
223
224struct intel_menlow_attribute {
225	struct device_attribute attr;
226	struct device *device;
227	acpi_handle handle;
228	struct list_head node;
229};
230
231static LIST_HEAD(intel_menlow_attr_list);
232static DEFINE_MUTEX(intel_menlow_attr_lock);
233
234/*
235 * sensor_get_auxtrip - get the current auxtrip value from sensor
236 * @name: Thermalzone name
237 * @auxtype : AUX0/AUX1
238 * @buf: syfs buffer
239 */
240static int sensor_get_auxtrip(acpi_handle handle, int index,
241							unsigned long long *value)
242{
243	acpi_status status;
244
245	if ((index != 0 && index != 1) || !value)
246		return -EINVAL;
247
248	status = acpi_evaluate_integer(handle, index ? GET_AUX1 : GET_AUX0,
249				       NULL, value);
250	if (ACPI_FAILURE(status))
251		return -EIO;
252
253	return 0;
254}
255
256/*
257 * sensor_set_auxtrip - set the new auxtrip value to sensor
258 * @name: Thermalzone name
259 * @auxtype : AUX0/AUX1
260 * @buf: syfs buffer
261 */
262static int sensor_set_auxtrip(acpi_handle handle, int index, int value)
263{
264	acpi_status status;
265	union acpi_object arg = {
266		ACPI_TYPE_INTEGER
267	};
268	struct acpi_object_list args = {
269		1, &arg
270	};
271	unsigned long long temp;
272
273	if (index != 0 && index != 1)
274		return -EINVAL;
275
276	status = acpi_evaluate_integer(handle, index ? GET_AUX0 : GET_AUX1,
277				       NULL, &temp);
278	if (ACPI_FAILURE(status))
279		return -EIO;
280	if ((index && value < temp) || (!index && value > temp))
281		return -EINVAL;
282
283	arg.integer.value = value;
284	status = acpi_evaluate_integer(handle, index ? SET_AUX1 : SET_AUX0,
285				       &args, &temp);
286	if (ACPI_FAILURE(status))
287		return -EIO;
288
289	/* do we need to check the return value of SAX0/SAX1 ? */
290
291	return 0;
292}
293
294#define to_intel_menlow_attr(_attr)	\
295	container_of(_attr, struct intel_menlow_attribute, attr)
296
297static ssize_t aux_show(struct device *dev, struct device_attribute *dev_attr,
298			char *buf, int idx)
299{
300	struct intel_menlow_attribute *attr = to_intel_menlow_attr(dev_attr);
301	unsigned long long value;
302	int result;
303
304	result = sensor_get_auxtrip(attr->handle, idx, &value);
305
306	return result ? result : sprintf(buf, "%lu", DECI_KELVIN_TO_CELSIUS(value));
307}
308
309static ssize_t aux0_show(struct device *dev,
310			 struct device_attribute *dev_attr, char *buf)
311{
312	return aux_show(dev, dev_attr, buf, 0);
313}
314
315static ssize_t aux1_show(struct device *dev,
316			 struct device_attribute *dev_attr, char *buf)
317{
318	return aux_show(dev, dev_attr, buf, 1);
319}
320
321static ssize_t aux_store(struct device *dev, struct device_attribute *dev_attr,
322			 const char *buf, size_t count, int idx)
323{
324	struct intel_menlow_attribute *attr = to_intel_menlow_attr(dev_attr);
325	int value;
326	int result;
327
328	/*Sanity check; should be a positive integer */
329	if (!sscanf(buf, "%d", &value))
330		return -EINVAL;
331
332	if (value < 0)
333		return -EINVAL;
334
335	result = sensor_set_auxtrip(attr->handle, idx, 
336				    CELSIUS_TO_DECI_KELVIN(value));
337	return result ? result : count;
338}
339
340static ssize_t aux0_store(struct device *dev,
341			  struct device_attribute *dev_attr,
342			  const char *buf, size_t count)
343{
344	return aux_store(dev, dev_attr, buf, count, 0);
345}
346
347static ssize_t aux1_store(struct device *dev,
348			  struct device_attribute *dev_attr,
349			  const char *buf, size_t count)
350{
351	return aux_store(dev, dev_attr, buf, count, 1);
352}
353
354/* BIOS can enable/disable the thermal user application in dabney platform */
355#define BIOS_ENABLED "\\_TZ.GSTS"
356static ssize_t bios_enabled_show(struct device *dev,
357				 struct device_attribute *attr, char *buf)
358{
359	acpi_status status;
360	unsigned long long bios_enabled;
361
362	status = acpi_evaluate_integer(NULL, BIOS_ENABLED, NULL, &bios_enabled);
363	if (ACPI_FAILURE(status))
364		return -ENODEV;
365
366	return sprintf(buf, "%s\n", bios_enabled ? "enabled" : "disabled");
367}
368
369static int intel_menlow_add_one_attribute(char *name, umode_t mode, void *show,
370					  void *store, struct device *dev,
371					  acpi_handle handle)
372{
373	struct intel_menlow_attribute *attr;
374	int result;
375
376	attr = kzalloc(sizeof(struct intel_menlow_attribute), GFP_KERNEL);
377	if (!attr)
378		return -ENOMEM;
379
380	sysfs_attr_init(&attr->attr.attr); /* That is consistent naming :D */
381	attr->attr.attr.name = name;
382	attr->attr.attr.mode = mode;
383	attr->attr.show = show;
384	attr->attr.store = store;
385	attr->device = dev;
386	attr->handle = handle;
387
388	result = device_create_file(dev, &attr->attr);
389	if (result) {
390		kfree(attr);
391		return result;
392	}
393
394	mutex_lock(&intel_menlow_attr_lock);
395	list_add_tail(&attr->node, &intel_menlow_attr_list);
396	mutex_unlock(&intel_menlow_attr_lock);
397
398	return 0;
399}
400
401static acpi_status intel_menlow_register_sensor(acpi_handle handle, u32 lvl,
402						void *context, void **rv)
403{
404	acpi_status status;
405	acpi_handle dummy;
406	struct thermal_zone_device *thermal;
407	int result;
408
409	result = acpi_bus_get_private_data(handle, (void **)&thermal);
410	if (result)
411		return 0;
412
413	/* _TZ must have the AUX0/1 methods */
414	status = acpi_get_handle(handle, GET_AUX0, &dummy);
415	if (ACPI_FAILURE(status))
416		return (status == AE_NOT_FOUND) ? AE_OK : status;
417
418	status = acpi_get_handle(handle, SET_AUX0, &dummy);
419	if (ACPI_FAILURE(status))
420		return (status == AE_NOT_FOUND) ? AE_OK : status;
421
422	result = intel_menlow_add_one_attribute("aux0", 0644,
423						aux0_show, aux0_store,
424						&thermal->device, handle);
425	if (result)
426		return AE_ERROR;
427
428	status = acpi_get_handle(handle, GET_AUX1, &dummy);
429	if (ACPI_FAILURE(status))
430		goto aux1_not_found;
431
432	status = acpi_get_handle(handle, SET_AUX1, &dummy);
433	if (ACPI_FAILURE(status))
434		goto aux1_not_found;
435
436	result = intel_menlow_add_one_attribute("aux1", 0644,
437						aux1_show, aux1_store,
438						&thermal->device, handle);
439	if (result) {
440		intel_menlow_unregister_sensor();
441		return AE_ERROR;
442	}
443
444	/*
445	 * create the "dabney_enabled" attribute which means the user app
446	 * should be loaded or not
447	 */
448
449	result = intel_menlow_add_one_attribute("bios_enabled", 0444,
450						bios_enabled_show, NULL,
451						&thermal->device, handle);
452	if (result) {
453		intel_menlow_unregister_sensor();
454		return AE_ERROR;
455	}
456
457	return AE_OK;
458
459 aux1_not_found:
460	if (status == AE_NOT_FOUND)
461		return AE_OK;
462
463	intel_menlow_unregister_sensor();
464	return status;
465}
466
467static void intel_menlow_unregister_sensor(void)
468{
469	struct intel_menlow_attribute *pos, *next;
470
471	mutex_lock(&intel_menlow_attr_lock);
472	list_for_each_entry_safe(pos, next, &intel_menlow_attr_list, node) {
473		list_del(&pos->node);
474		device_remove_file(pos->device, &pos->attr);
475		kfree(pos);
476	}
477	mutex_unlock(&intel_menlow_attr_lock);
478
479	return;
480}
481
482static int __init intel_menlow_module_init(void)
483{
484	int result = -ENODEV;
485	acpi_status status;
486	unsigned long long enable;
487
488	if (acpi_disabled)
489		return result;
490
491	/* Looking for the \_TZ.GSTS method */
492	status = acpi_evaluate_integer(NULL, BIOS_ENABLED, NULL, &enable);
493	if (ACPI_FAILURE(status) || !enable)
494		return -ENODEV;
495
496	/* Looking for ACPI device MEM0 with hardware id INT0002 */
497	result = acpi_bus_register_driver(&intel_menlow_memory_driver);
498	if (result)
499		return result;
500
501	/* Looking for sensors in each ACPI thermal zone */
502	status = acpi_walk_namespace(ACPI_TYPE_THERMAL, ACPI_ROOT_OBJECT,
503				     ACPI_UINT32_MAX,
504				     intel_menlow_register_sensor, NULL, NULL, NULL);
505	if (ACPI_FAILURE(status)) {
506		acpi_bus_unregister_driver(&intel_menlow_memory_driver);
507		return -ENODEV;
508	}
509
510	return 0;
511}
512
513static void __exit intel_menlow_module_exit(void)
514{
515	acpi_bus_unregister_driver(&intel_menlow_memory_driver);
516	intel_menlow_unregister_sensor();
517}
518
519module_init(intel_menlow_module_init);
520module_exit(intel_menlow_module_exit);