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