drivers/thermal/thermal_netlink.c

   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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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  */
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 698 int __init thermal_netlink_init(void)
 699 {
 700         return genl_register_family(&thermal_gnl_family);
 701 }
 702
 703 void __init thermal_netlink_exit(void)
 704 {
 705         genl_unregister_family(&thermal_gnl_family);
 706 }