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