linux thermal framework(3)_thermal cooling device

struct thermal_cooling_device {

	int id;

	const char *type;

	unsigned long max_state;

	struct device device;

	struct device_node *np;

	void *devdata;

	void *stats;

	const struct thermal_cooling_device_ops *ops;

	bool updated; /* true if the cooling device does not need update */

	struct mutex lock; /* protect thermal_instances list */

	struct list_head thermal_instances;

	struct list_head node;

#ifdef CONFIG_THERMAL_DEBUGFS

	struct thermal_debugfs *debugfs;

#endif

};

/*

 * This structure is used to describe the behavior of

 * a certain cooling device on a certain trip point

 * in a certain thermal zone

 */

struct thermal_instance {

	int id;

	char name[THERMAL_NAME_LENGTH];

	struct thermal_cooling_device *cdev;

	const struct thermal_trip *trip;

	bool initialized;

	unsigned long upper;	/* Highest cooling state for this trip point */

	unsigned long lower;	/* Lowest cooling state for this trip point */

	unsigned long target;	/* expected cooling state */

	char attr_name[THERMAL_NAME_LENGTH];

	struct device_attribute attr;

	char weight_attr_name[THERMAL_NAME_LENGTH];

	struct device_attribute weight_attr;

	struct list_head trip_node; /* node in trip->thermal_instances */

	struct list_head cdev_node; /* node in cdev->thermal_instances */

	unsigned int weight; /* The weight of the cooling device */

	bool upper_no_limit;

};

thermal_zones: thermal-zones {

	cpu0-thermal {

  ...

		trips {

			cpu0_alert: trip-alert {

				temperature = <85000>;

				hysteresis = <2000>;

				type = "passive";

			};

		cpu0_crit: trip-crit {

			temperature = <100000>;

			hysteresis = <2000>;

			type = "critical";

		};

	};



	cooling-maps {

		map0 {

			trip = <&cpu0_alert>;

			cooling-device = <&cpu0 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,

					<&cpu1 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,

					<&cpu2 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>,

					<&cpu3 THERMAL_NO_LIMIT THERMAL_NO_LIMIT>;

			};

		};

	};



... other thermal zones



}

cpu0: cpu@0 {

  device_type = "cpu";

  compatible = "arm,cortex-a55";

  reg = <0x000>;

  enable-method = "psci";

  performance-domains = <&performance 0>;

  clock-frequency = <1701000000>;

  capacity-dmips-mhz = <308>;

  cpu-idle-states = <&cpu_ret_l &cpu_off_l>;

  i-cache-size = <32768>;

  i-cache-line-size = <64>;

  i-cache-sets = <128>;

  d-cache-size = <32768>;

  d-cache-line-size = <64>;

  d-cache-sets = <128>;

  next-level-cache = <&l2_0>;

  #cooling-cells = <2>;

};

/**

 * thermal_bind_cdev_to_trip - bind a cooling device to a thermal zone

 * @tz:		pointer to struct thermal_zone_device

 * @td:		descriptor of the trip point to bind @cdev to

 * @cdev:	pointer to struct thermal_cooling_device

 * @cool_spec:	cooling specification for the trip point and @cdev

 *

 * This interface function bind a thermal cooling device to the certain trip

 * point of a thermal zone device.

 * This function is usually called in the thermal zone device .bind callback.

 *

 * Return: 0 on success, the proper error value otherwise.

 */

static int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,

				     struct thermal_trip_desc *td,

				     struct thermal_cooling_device *cdev,

				     struct cooling_spec *cool_spec)

{

	struct thermal_instance *dev;

	bool upper_no_limit;

	int result;

/* lower default 0, upper default max_state */

if (cool_spec->lower == THERMAL_NO_LIMIT)

	cool_spec->lower = 0;



if (cool_spec->upper == THERMAL_NO_LIMIT) {

	cool_spec->upper = cdev->max_state;

	upper_no_limit = true;

} else {

	upper_no_limit = false;

}



if (cool_spec->lower > cool_spec->upper || cool_spec->upper > cdev->max_state)

	return -EINVAL;



dev = kzalloc(sizeof(*dev), GFP_KERNEL);

if (!dev)

	return -ENOMEM;



dev->cdev = cdev;

dev->trip = &td->trip;

dev->upper = cool_spec->upper;

dev->upper_no_limit = upper_no_limit;

dev->lower = cool_spec->lower;

dev->target = THERMAL_NO_TARGET;

dev->weight = cool_spec->weight;



result = ida_alloc(&tz->ida, GFP_KERNEL);

if (result < 0)

goto free_mem;

dev->id = result;

sprintf(dev->name, "cdev%d", dev->id);

result =

    sysfs_create_link(&tz->device.kobj, &cdev->device.kobj, dev->name);

if (result)

	goto release_ida;



snprintf(dev->attr_name, sizeof(dev->attr_name), "cdev%d_trip_point",

	 dev->id);

sysfs_attr_init(&dev->attr.attr);

dev->attr.attr.name = dev->attr_name;

dev->attr.attr.mode = 0444;

dev->attr.show = trip_point_show;

result = device_create_file(&tz->device, &dev->attr);

if (result)

	goto remove_symbol_link;



snprintf(dev->weight_attr_name, sizeof(dev->weight_attr_name),

	 "cdev%d_weight", dev->id);

sysfs_attr_init(&dev->weight_attr.attr);

dev->weight_attr.attr.name = dev->weight_attr_name;

dev->weight_attr.attr.mode = S_IWUSR | S_IRUGO;

dev->weight_attr.show = weight_show;

dev->weight_attr.store = weight_store;

result = device_create_file(&tz->device, &dev->weight_attr);

if (result)

	goto remove_trip_file;



result = thermal_instance_add(dev, cdev, td);

if (result)

goto remove_weight_file;

thermal_governor_update_tz(tz, THERMAL_TZ_BIND_CDEV);



return 0;



remove_weight_file:



device_remove_file(&tz->device, &dev->weight_attr);



remove_trip_file:



device_remove_file(&tz->device, &dev->attr);



remove_symbol_link:



sysfs_remove_link(&tz->device.kobj, dev->name);



release_ida:



ida_free(&tz->ida, dev->id);



free_mem:



kfree(dev);



return result;



}