1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright 2020 Linaro Limited
4 *
5 * Author: Daniel Lezcano <daniel.lezcano@linaro.org>
6 *
7 * Generic netlink for thermal management framework
8 */
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <net/genetlink.h>
12 #include <uapi/linux/thermal.h>
13
14 #include "thermal_core.h"
15
16 static const struct genl_multicast_group thermal_genl_mcgrps[] = {
17 { .name = THERMAL_GENL_SAMPLING_GROUP_NAME, },
18 { .name = THERMAL_GENL_EVENT_GROUP_NAME, },
19 };
20
21 static const struct nla_policy thermal_genl_policy[THERMAL_GENL_ATTR_MAX + 1] = {
22 /* Thermal zone */
23 [THERMAL_GENL_ATTR_TZ] = { .type = NLA_NESTED },
24 [THERMAL_GENL_ATTR_TZ_ID] = { .type = NLA_U32 },
25 [THERMAL_GENL_ATTR_TZ_TEMP] = { .type = NLA_U32 },
26 [THERMAL_GENL_ATTR_TZ_TRIP] = { .type = NLA_NESTED },
27 [THERMAL_GENL_ATTR_TZ_TRIP_ID] = { .type = NLA_U32 },
28 [THERMAL_GENL_ATTR_TZ_TRIP_TEMP] = { .type = NLA_U32 },
29 [THERMAL_GENL_ATTR_TZ_TRIP_TYPE] = { .type = NLA_U32 },
30 [THERMAL_GENL_ATTR_TZ_TRIP_HYST] = { .type = NLA_U32 },
31 [THERMAL_GENL_ATTR_TZ_MODE] = { .type = NLA_U32 },
32 [THERMAL_GENL_ATTR_TZ_CDEV_WEIGHT] = { .type = NLA_U32 },
33 [THERMAL_GENL_ATTR_TZ_NAME] = { .type = NLA_STRING,
34 .len = THERMAL_NAME_LENGTH },
35 /* Governor(s) */
36 [THERMAL_GENL_ATTR_TZ_GOV] = { .type = NLA_NESTED },
37 [THERMAL_GENL_ATTR_TZ_GOV_NAME] = { .type = NLA_STRING,
38 .len = THERMAL_NAME_LENGTH },
39 /* Cooling devices */
40 [THERMAL_GENL_ATTR_CDEV] = { .type = NLA_NESTED },
41 [THERMAL_GENL_ATTR_CDEV_ID] = { .type = NLA_U32 },
42 [THERMAL_GENL_ATTR_CDEV_CUR_STATE] = { .type = NLA_U32 },
43 [THERMAL_GENL_ATTR_CDEV_MAX_STATE] = { .type = NLA_U32 },
44 [THERMAL_GENL_ATTR_CDEV_NAME] = { .type = NLA_STRING,
45 .len = THERMAL_NAME_LENGTH },
46 /* CPU capabilities */
47 [THERMAL_GENL_ATTR_CPU_CAPABILITY] = { .type = NLA_NESTED },
48 [THERMAL_GENL_ATTR_CPU_CAPABILITY_ID] = { .type = NLA_U32 },
49 [THERMAL_GENL_ATTR_CPU_CAPABILITY_PERFORMANCE] = { .type = NLA_U32 },
50 [THERMAL_GENL_ATTR_CPU_CAPABILITY_EFFICIENCY] = { .type = NLA_U32 },
51 };
52
53 struct param {
54 struct nlattr **attrs;
55 struct sk_buff *msg;
56 const char *name;
57 int tz_id;
58 int cdev_id;
59 int trip_id;
60 int trip_temp;
61 int trip_type;
62 int trip_hyst;
63 int temp;
64 int cdev_state;
65 int cdev_max_state;
66 struct thermal_genl_cpu_caps *cpu_capabilities;
67 int cpu_capabilities_count;
68 };
69
70 typedef int (*cb_t)(struct param *);
71
72 static struct genl_family thermal_gnl_family;
73
74 /************************** Sampling encoding *******************************/
75
thermal_genl_sampling_temp(int id,int temp)76 int thermal_genl_sampling_temp(int id, int temp)
77 {
78 struct sk_buff *skb;
79 void *hdr;
80
81 skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
82 if (!skb)
83 return -ENOMEM;
84
85 hdr = genlmsg_put(skb, 0, 0, &thermal_gnl_family, 0,
86 THERMAL_GENL_SAMPLING_TEMP);
87 if (!hdr)
88 goto out_free;
89
90 if (nla_put_u32(skb, THERMAL_GENL_ATTR_TZ_ID, id))
91 goto out_cancel;
92
93 if (nla_put_u32(skb, THERMAL_GENL_ATTR_TZ_TEMP, temp))
94 goto out_cancel;
95
96 genlmsg_end(skb, hdr);
97
98 genlmsg_multicast(&thermal_gnl_family, skb, 0, 0, GFP_KERNEL);
99
100 return 0;
101 out_cancel:
102 genlmsg_cancel(skb, hdr);
103 out_free:
104 nlmsg_free(skb);
105
106 return -EMSGSIZE;
107 }
108
109 /**************************** Event encoding *********************************/
110
thermal_genl_event_tz_create(struct param * p)111 static int thermal_genl_event_tz_create(struct param *p)
112 {
113 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
114 nla_put_string(p->msg, THERMAL_GENL_ATTR_TZ_NAME, p->name))
115 return -EMSGSIZE;
116
117 return 0;
118 }
119
thermal_genl_event_tz(struct param * p)120 static int thermal_genl_event_tz(struct param *p)
121 {
122 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id))
123 return -EMSGSIZE;
124
125 return 0;
126 }
127
thermal_genl_event_tz_trip_up(struct param * p)128 static int thermal_genl_event_tz_trip_up(struct param *p)
129 {
130 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
131 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id) ||
132 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TEMP, p->temp))
133 return -EMSGSIZE;
134
135 return 0;
136 }
137
thermal_genl_event_tz_trip_add(struct param * p)138 static int thermal_genl_event_tz_trip_add(struct param *p)
139 {
140 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
141 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id) ||
142 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, p->trip_type) ||
143 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, p->trip_temp) ||
144 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, p->trip_hyst))
145 return -EMSGSIZE;
146
147 return 0;
148 }
149
thermal_genl_event_tz_trip_delete(struct param * p)150 static int thermal_genl_event_tz_trip_delete(struct param *p)
151 {
152 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
153 nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, p->trip_id))
154 return -EMSGSIZE;
155
156 return 0;
157 }
158
thermal_genl_event_cdev_add(struct param * p)159 static int thermal_genl_event_cdev_add(struct param *p)
160 {
161 if (nla_put_string(p->msg, THERMAL_GENL_ATTR_CDEV_NAME,
162 p->name) ||
163 nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID,
164 p->cdev_id) ||
165 nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_MAX_STATE,
166 p->cdev_max_state))
167 return -EMSGSIZE;
168
169 return 0;
170 }
171
thermal_genl_event_cdev_delete(struct param * p)172 static int thermal_genl_event_cdev_delete(struct param *p)
173 {
174 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID, p->cdev_id))
175 return -EMSGSIZE;
176
177 return 0;
178 }
179
thermal_genl_event_cdev_state_update(struct param * p)180 static int thermal_genl_event_cdev_state_update(struct param *p)
181 {
182 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_ID,
183 p->cdev_id) ||
184 nla_put_u32(p->msg, THERMAL_GENL_ATTR_CDEV_CUR_STATE,
185 p->cdev_state))
186 return -EMSGSIZE;
187
188 return 0;
189 }
190
thermal_genl_event_gov_change(struct param * p)191 static int thermal_genl_event_gov_change(struct param *p)
192 {
193 if (nla_put_u32(p->msg, THERMAL_GENL_ATTR_TZ_ID, p->tz_id) ||
194 nla_put_string(p->msg, THERMAL_GENL_ATTR_GOV_NAME, p->name))
195 return -EMSGSIZE;
196
197 return 0;
198 }
199
thermal_genl_event_cpu_capability_change(struct param * p)200 static int thermal_genl_event_cpu_capability_change(struct param *p)
201 {
202 struct thermal_genl_cpu_caps *cpu_cap = p->cpu_capabilities;
203 struct sk_buff *msg = p->msg;
204 struct nlattr *start_cap;
205 int i;
206
207 start_cap = nla_nest_start(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY);
208 if (!start_cap)
209 return -EMSGSIZE;
210
211 for (i = 0; i < p->cpu_capabilities_count; ++i) {
212 if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_ID,
213 cpu_cap->cpu))
214 goto out_cancel_nest;
215
216 if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_PERFORMANCE,
217 cpu_cap->performance))
218 goto out_cancel_nest;
219
220 if (nla_put_u32(msg, THERMAL_GENL_ATTR_CPU_CAPABILITY_EFFICIENCY,
221 cpu_cap->efficiency))
222 goto out_cancel_nest;
223
224 ++cpu_cap;
225 }
226
227 nla_nest_end(msg, start_cap);
228
229 return 0;
230 out_cancel_nest:
231 nla_nest_cancel(msg, start_cap);
232
233 return -EMSGSIZE;
234 }
235
236 int thermal_genl_event_tz_delete(struct param *p)
237 __attribute__((alias("thermal_genl_event_tz")));
238
239 int thermal_genl_event_tz_enable(struct param *p)
240 __attribute__((alias("thermal_genl_event_tz")));
241
242 int thermal_genl_event_tz_disable(struct param *p)
243 __attribute__((alias("thermal_genl_event_tz")));
244
245 int thermal_genl_event_tz_trip_down(struct param *p)
246 __attribute__((alias("thermal_genl_event_tz_trip_up")));
247
248 int thermal_genl_event_tz_trip_change(struct param *p)
249 __attribute__((alias("thermal_genl_event_tz_trip_add")));
250
251 static cb_t event_cb[] = {
252 [THERMAL_GENL_EVENT_TZ_CREATE] = thermal_genl_event_tz_create,
253 [THERMAL_GENL_EVENT_TZ_DELETE] = thermal_genl_event_tz_delete,
254 [THERMAL_GENL_EVENT_TZ_ENABLE] = thermal_genl_event_tz_enable,
255 [THERMAL_GENL_EVENT_TZ_DISABLE] = thermal_genl_event_tz_disable,
256 [THERMAL_GENL_EVENT_TZ_TRIP_UP] = thermal_genl_event_tz_trip_up,
257 [THERMAL_GENL_EVENT_TZ_TRIP_DOWN] = thermal_genl_event_tz_trip_down,
258 [THERMAL_GENL_EVENT_TZ_TRIP_CHANGE] = thermal_genl_event_tz_trip_change,
259 [THERMAL_GENL_EVENT_TZ_TRIP_ADD] = thermal_genl_event_tz_trip_add,
260 [THERMAL_GENL_EVENT_TZ_TRIP_DELETE] = thermal_genl_event_tz_trip_delete,
261 [THERMAL_GENL_EVENT_CDEV_ADD] = thermal_genl_event_cdev_add,
262 [THERMAL_GENL_EVENT_CDEV_DELETE] = thermal_genl_event_cdev_delete,
263 [THERMAL_GENL_EVENT_CDEV_STATE_UPDATE] = thermal_genl_event_cdev_state_update,
264 [THERMAL_GENL_EVENT_TZ_GOV_CHANGE] = thermal_genl_event_gov_change,
265 [THERMAL_GENL_EVENT_CPU_CAPABILITY_CHANGE] = thermal_genl_event_cpu_capability_change,
266 };
267
268 /*
269 * Generic netlink event encoding
270 */
thermal_genl_send_event(enum thermal_genl_event event,struct param * p)271 static int thermal_genl_send_event(enum thermal_genl_event event,
272 struct param *p)
273 {
274 struct sk_buff *msg;
275 int ret = -EMSGSIZE;
276 void *hdr;
277
278 msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
279 if (!msg)
280 return -ENOMEM;
281 p->msg = msg;
282
283 hdr = genlmsg_put(msg, 0, 0, &thermal_gnl_family, 0, event);
284 if (!hdr)
285 goto out_free_msg;
286
287 ret = event_cb[event](p);
288 if (ret)
289 goto out_cancel_msg;
290
291 genlmsg_end(msg, hdr);
292
293 genlmsg_multicast(&thermal_gnl_family, msg, 0, 1, GFP_KERNEL);
294
295 return 0;
296
297 out_cancel_msg:
298 genlmsg_cancel(msg, hdr);
299 out_free_msg:
300 nlmsg_free(msg);
301
302 return ret;
303 }
304
thermal_notify_tz_create(int tz_id,const char * name)305 int thermal_notify_tz_create(int tz_id, const char *name)
306 {
307 struct param p = { .tz_id = tz_id, .name = name };
308
309 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_CREATE, &p);
310 }
311
thermal_notify_tz_delete(int tz_id)312 int thermal_notify_tz_delete(int tz_id)
313 {
314 struct param p = { .tz_id = tz_id };
315
316 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DELETE, &p);
317 }
318
thermal_notify_tz_enable(int tz_id)319 int thermal_notify_tz_enable(int tz_id)
320 {
321 struct param p = { .tz_id = tz_id };
322
323 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_ENABLE, &p);
324 }
325
thermal_notify_tz_disable(int tz_id)326 int thermal_notify_tz_disable(int tz_id)
327 {
328 struct param p = { .tz_id = tz_id };
329
330 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_DISABLE, &p);
331 }
332
thermal_notify_tz_trip_down(int tz_id,int trip_id,int temp)333 int thermal_notify_tz_trip_down(int tz_id, int trip_id, int temp)
334 {
335 struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp };
336
337 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DOWN, &p);
338 }
339
thermal_notify_tz_trip_up(int tz_id,int trip_id,int temp)340 int thermal_notify_tz_trip_up(int tz_id, int trip_id, int temp)
341 {
342 struct param p = { .tz_id = tz_id, .trip_id = trip_id, .temp = temp };
343
344 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_UP, &p);
345 }
346
thermal_notify_tz_trip_add(int tz_id,int trip_id,int trip_type,int trip_temp,int trip_hyst)347 int thermal_notify_tz_trip_add(int tz_id, int trip_id, int trip_type,
348 int trip_temp, int trip_hyst)
349 {
350 struct param p = { .tz_id = tz_id, .trip_id = trip_id,
351 .trip_type = trip_type, .trip_temp = trip_temp,
352 .trip_hyst = trip_hyst };
353
354 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_ADD, &p);
355 }
356
thermal_notify_tz_trip_delete(int tz_id,int trip_id)357 int thermal_notify_tz_trip_delete(int tz_id, int trip_id)
358 {
359 struct param p = { .tz_id = tz_id, .trip_id = trip_id };
360
361 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_DELETE, &p);
362 }
363
thermal_notify_tz_trip_change(int tz_id,int trip_id,int trip_type,int trip_temp,int trip_hyst)364 int thermal_notify_tz_trip_change(int tz_id, int trip_id, int trip_type,
365 int trip_temp, int trip_hyst)
366 {
367 struct param p = { .tz_id = tz_id, .trip_id = trip_id,
368 .trip_type = trip_type, .trip_temp = trip_temp,
369 .trip_hyst = trip_hyst };
370
371 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_TRIP_CHANGE, &p);
372 }
373
thermal_notify_cdev_state_update(int cdev_id,int cdev_state)374 int thermal_notify_cdev_state_update(int cdev_id, int cdev_state)
375 {
376 struct param p = { .cdev_id = cdev_id, .cdev_state = cdev_state };
377
378 return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_STATE_UPDATE, &p);
379 }
380
thermal_notify_cdev_add(int cdev_id,const char * name,int cdev_max_state)381 int thermal_notify_cdev_add(int cdev_id, const char *name, int cdev_max_state)
382 {
383 struct param p = { .cdev_id = cdev_id, .name = name,
384 .cdev_max_state = cdev_max_state };
385
386 return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_ADD, &p);
387 }
388
thermal_notify_cdev_delete(int cdev_id)389 int thermal_notify_cdev_delete(int cdev_id)
390 {
391 struct param p = { .cdev_id = cdev_id };
392
393 return thermal_genl_send_event(THERMAL_GENL_EVENT_CDEV_DELETE, &p);
394 }
395
thermal_notify_tz_gov_change(int tz_id,const char * name)396 int thermal_notify_tz_gov_change(int tz_id, const char *name)
397 {
398 struct param p = { .tz_id = tz_id, .name = name };
399
400 return thermal_genl_send_event(THERMAL_GENL_EVENT_TZ_GOV_CHANGE, &p);
401 }
402
thermal_genl_cpu_capability_event(int count,struct thermal_genl_cpu_caps * caps)403 int thermal_genl_cpu_capability_event(int count,
404 struct thermal_genl_cpu_caps *caps)
405 {
406 struct param p = { .cpu_capabilities_count = count, .cpu_capabilities = caps };
407
408 return thermal_genl_send_event(THERMAL_GENL_EVENT_CPU_CAPABILITY_CHANGE, &p);
409 }
410 EXPORT_SYMBOL_GPL(thermal_genl_cpu_capability_event);
411
412 /*************************** Command encoding ********************************/
413
__thermal_genl_cmd_tz_get_id(struct thermal_zone_device * tz,void * data)414 static int __thermal_genl_cmd_tz_get_id(struct thermal_zone_device *tz,
415 void *data)
416 {
417 struct sk_buff *msg = data;
418
419 if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, tz->id) ||
420 nla_put_string(msg, THERMAL_GENL_ATTR_TZ_NAME, tz->type))
421 return -EMSGSIZE;
422
423 return 0;
424 }
425
thermal_genl_cmd_tz_get_id(struct param * p)426 static int thermal_genl_cmd_tz_get_id(struct param *p)
427 {
428 struct sk_buff *msg = p->msg;
429 struct nlattr *start_tz;
430 int ret;
431
432 start_tz = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ);
433 if (!start_tz)
434 return -EMSGSIZE;
435
436 ret = for_each_thermal_zone(__thermal_genl_cmd_tz_get_id, msg);
437 if (ret)
438 goto out_cancel_nest;
439
440 nla_nest_end(msg, start_tz);
441
442 return 0;
443
444 out_cancel_nest:
445 nla_nest_cancel(msg, start_tz);
446
447 return ret;
448 }
449
thermal_genl_cmd_tz_get_trip(struct param * p)450 static int thermal_genl_cmd_tz_get_trip(struct param *p)
451 {
452 struct sk_buff *msg = p->msg;
453 struct thermal_zone_device *tz;
454 struct nlattr *start_trip;
455 struct thermal_trip trip;
456 int ret, i, id;
457
458 if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
459 return -EINVAL;
460
461 id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
462
463 tz = thermal_zone_get_by_id(id);
464 if (!tz)
465 return -EINVAL;
466
467 start_trip = nla_nest_start(msg, THERMAL_GENL_ATTR_TZ_TRIP);
468 if (!start_trip)
469 return -EMSGSIZE;
470
471 mutex_lock(&tz->lock);
472
473 for (i = 0; i < tz->num_trips; i++) {
474
475 ret = __thermal_zone_get_trip(tz, i, &trip);
476 if (ret)
477 goto out_cancel_nest;
478
479 if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_ID, i) ||
480 nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TYPE, trip.type) ||
481 nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_TEMP, trip.temperature) ||
482 nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TRIP_HYST, trip.hysteresis))
483 goto out_cancel_nest;
484 }
485
486 mutex_unlock(&tz->lock);
487
488 nla_nest_end(msg, start_trip);
489
490 return 0;
491
492 out_cancel_nest:
493 mutex_unlock(&tz->lock);
494
495 return -EMSGSIZE;
496 }
497
thermal_genl_cmd_tz_get_temp(struct param * p)498 static int thermal_genl_cmd_tz_get_temp(struct param *p)
499 {
500 struct sk_buff *msg = p->msg;
501 struct thermal_zone_device *tz;
502 int temp, ret, id;
503
504 if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
505 return -EINVAL;
506
507 id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
508
509 tz = thermal_zone_get_by_id(id);
510 if (!tz)
511 return -EINVAL;
512
513 ret = thermal_zone_get_temp(tz, &temp);
514 if (ret)
515 return ret;
516
517 if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) ||
518 nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_TEMP, temp))
519 return -EMSGSIZE;
520
521 return 0;
522 }
523
thermal_genl_cmd_tz_get_gov(struct param * p)524 static int thermal_genl_cmd_tz_get_gov(struct param *p)
525 {
526 struct sk_buff *msg = p->msg;
527 struct thermal_zone_device *tz;
528 int id, ret = 0;
529
530 if (!p->attrs[THERMAL_GENL_ATTR_TZ_ID])
531 return -EINVAL;
532
533 id = nla_get_u32(p->attrs[THERMAL_GENL_ATTR_TZ_ID]);
534
535 tz = thermal_zone_get_by_id(id);
536 if (!tz)
537 return -EINVAL;
538
539 mutex_lock(&tz->lock);
540
541 if (nla_put_u32(msg, THERMAL_GENL_ATTR_TZ_ID, id) ||
542 nla_put_string(msg, THERMAL_GENL_ATTR_TZ_GOV_NAME,
543 tz->governor->name))
544 ret = -EMSGSIZE;
545
546 mutex_unlock(&tz->lock);
547
548 return ret;
549 }
550
__thermal_genl_cmd_cdev_get(struct thermal_cooling_device * cdev,void * data)551 static int __thermal_genl_cmd_cdev_get(struct thermal_cooling_device *cdev,
552 void *data)
553 {
554 struct sk_buff *msg = data;
555
556 if (nla_put_u32(msg, THERMAL_GENL_ATTR_CDEV_ID, cdev->id))
557 return -EMSGSIZE;
558
559 if (nla_put_string(msg, THERMAL_GENL_ATTR_CDEV_NAME, cdev->type))
560 return -EMSGSIZE;
561
562 return 0;
563 }
564
thermal_genl_cmd_cdev_get(struct param * p)565 static int thermal_genl_cmd_cdev_get(struct param *p)
566 {
567 struct sk_buff *msg = p->msg;
568 struct nlattr *start_cdev;
569 int ret;
570
571 start_cdev = nla_nest_start(msg, THERMAL_GENL_ATTR_CDEV);
572 if (!start_cdev)
573 return -EMSGSIZE;
574
575 ret = for_each_thermal_cooling_device(__thermal_genl_cmd_cdev_get, msg);
576 if (ret)
577 goto out_cancel_nest;
578
579 nla_nest_end(msg, start_cdev);
580
581 return 0;
582 out_cancel_nest:
583 nla_nest_cancel(msg, start_cdev);
584
585 return ret;
586 }
587
588 static cb_t cmd_cb[] = {
589 [THERMAL_GENL_CMD_TZ_GET_ID] = thermal_genl_cmd_tz_get_id,
590 [THERMAL_GENL_CMD_TZ_GET_TRIP] = thermal_genl_cmd_tz_get_trip,
591 [THERMAL_GENL_CMD_TZ_GET_TEMP] = thermal_genl_cmd_tz_get_temp,
592 [THERMAL_GENL_CMD_TZ_GET_GOV] = thermal_genl_cmd_tz_get_gov,
593 [THERMAL_GENL_CMD_CDEV_GET] = thermal_genl_cmd_cdev_get,
594 };
595
thermal_genl_cmd_dumpit(struct sk_buff * skb,struct netlink_callback * cb)596 static int thermal_genl_cmd_dumpit(struct sk_buff *skb,
597 struct netlink_callback *cb)
598 {
599 struct param p = { .msg = skb };
600 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
601 int cmd = info->op.cmd;
602 int ret;
603 void *hdr;
604
605 hdr = genlmsg_put(skb, 0, 0, &thermal_gnl_family, 0, cmd);
606 if (!hdr)
607 return -EMSGSIZE;
608
609 ret = cmd_cb[cmd](&p);
610 if (ret)
611 goto out_cancel_msg;
612
613 genlmsg_end(skb, hdr);
614
615 return 0;
616
617 out_cancel_msg:
618 genlmsg_cancel(skb, hdr);
619
620 return ret;
621 }
622
thermal_genl_cmd_doit(struct sk_buff * skb,struct genl_info * info)623 static int thermal_genl_cmd_doit(struct sk_buff *skb,
624 struct genl_info *info)
625 {
626 struct param p = { .attrs = info->attrs };
627 struct sk_buff *msg;
628 void *hdr;
629 int cmd = info->genlhdr->cmd;
630 int ret = -EMSGSIZE;
631
632 msg = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
633 if (!msg)
634 return -ENOMEM;
635 p.msg = msg;
636
637 hdr = genlmsg_put_reply(msg, info, &thermal_gnl_family, 0, cmd);
638 if (!hdr)
639 goto out_free_msg;
640
641 ret = cmd_cb[cmd](&p);
642 if (ret)
643 goto out_cancel_msg;
644
645 genlmsg_end(msg, hdr);
646
647 return genlmsg_reply(msg, info);
648
649 out_cancel_msg:
650 genlmsg_cancel(msg, hdr);
651 out_free_msg:
652 nlmsg_free(msg);
653
654 return ret;
655 }
656
657 static const struct genl_small_ops thermal_genl_ops[] = {
658 {
659 .cmd = THERMAL_GENL_CMD_TZ_GET_ID,
660 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
661 .dumpit = thermal_genl_cmd_dumpit,
662 },
663 {
664 .cmd = THERMAL_GENL_CMD_TZ_GET_TRIP,
665 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
666 .doit = thermal_genl_cmd_doit,
667 },
668 {
669 .cmd = THERMAL_GENL_CMD_TZ_GET_TEMP,
670 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
671 .doit = thermal_genl_cmd_doit,
672 },
673 {
674 .cmd = THERMAL_GENL_CMD_TZ_GET_GOV,
675 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
676 .doit = thermal_genl_cmd_doit,
677 },
678 {
679 .cmd = THERMAL_GENL_CMD_CDEV_GET,
680 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
681 .dumpit = thermal_genl_cmd_dumpit,
682 },
683 };
684
685 static struct genl_family thermal_gnl_family __ro_after_init = {
686 .hdrsize = 0,
687 .name = THERMAL_GENL_FAMILY_NAME,
688 .version = THERMAL_GENL_VERSION,
689 .maxattr = THERMAL_GENL_ATTR_MAX,
690 .policy = thermal_genl_policy,
691 .small_ops = thermal_genl_ops,
692 .n_small_ops = ARRAY_SIZE(thermal_genl_ops),
693 .resv_start_op = THERMAL_GENL_CMD_CDEV_GET + 1,
694 .mcgrps = thermal_genl_mcgrps,
695 .n_mcgrps = ARRAY_SIZE(thermal_genl_mcgrps),
696 };
697
thermal_netlink_init(void)698 int __init thermal_netlink_init(void)
699 {
700 return genl_register_family(&thermal_gnl_family);
701 }
702
thermal_netlink_exit(void)703 void __init thermal_netlink_exit(void)
704 {
705 genl_unregister_family(&thermal_gnl_family);
706 }
707