drivers/firmware/arm_scmi/pinctrl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * System Control and Management Interface (SCMI) Pinctrl Protocol
   4  *
   5  * Copyright (C) 2024 EPAM
   6  * Copyright 2024 NXP
   7  */
   8
   9 #include <asm/byteorder.h>
  10 #include <linux/bits.h>
  11 #include <linux/bitfield.h>
  12 #include <linux/device.h>
  13 #include <linux/module.h>
  14 #include <linux/scmi_protocol.h>
  15 #include <linux/slab.h>
  16 #include <linux/string.h>
  17 #include <linux/types.h>
  18
  19 #include "common.h"
  20 #include "protocols.h"
  21
  22 /* Updated only after ALL the mandatory features for that version are merged */
  23 #define SCMI_PROTOCOL_SUPPORTED_VERSION         0x10000
  24
  25 #define GET_GROUPS_NR(x)        le32_get_bits((x), GENMASK(31, 16))
  26 #define GET_PINS_NR(x)          le32_get_bits((x), GENMASK(15, 0))
  27 #define GET_FUNCTIONS_NR(x)     le32_get_bits((x), GENMASK(15, 0))
  28
  29 #define EXT_NAME_FLAG(x)        le32_get_bits((x), BIT(31))
  30 #define NUM_ELEMS(x)            le32_get_bits((x), GENMASK(15, 0))
  31
  32 #define REMAINING(x)            le32_get_bits((x), GENMASK(31, 16))
  33 #define RETURNED(x)             le32_get_bits((x), GENMASK(11, 0))
  34
  35 #define CONFIG_FLAG_MASK        GENMASK(19, 18)
  36 #define SELECTOR_MASK           GENMASK(17, 16)
  37 #define SKIP_CONFIGS_MASK       GENMASK(15, 8)
  38 #define CONFIG_TYPE_MASK        GENMASK(7, 0)
  39
  40 enum scmi_pinctrl_protocol_cmd {
  41         PINCTRL_ATTRIBUTES = 0x3,
  42         PINCTRL_LIST_ASSOCIATIONS = 0x4,
  43         PINCTRL_SETTINGS_GET = 0x5,
  44         PINCTRL_SETTINGS_CONFIGURE = 0x6,
  45         PINCTRL_REQUEST = 0x7,
  46         PINCTRL_RELEASE = 0x8,
  47         PINCTRL_NAME_GET = 0x9,
  48         PINCTRL_SET_PERMISSIONS = 0xa,
  49 };
  50
  51 struct scmi_msg_settings_conf {
  52         __le32 identifier;
  53         __le32 function_id;
  54         __le32 attributes;
  55         __le32 configs[];
  56 };
  57
  58 struct scmi_msg_settings_get {
  59         __le32 identifier;
  60         __le32 attributes;
  61 };
  62
  63 struct scmi_resp_settings_get {
  64         __le32 function_selected;
  65         __le32 num_configs;
  66         __le32 configs[];
  67 };
  68
  69 struct scmi_msg_pinctrl_protocol_attributes {
  70         __le32 attributes_low;
  71         __le32 attributes_high;
  72 };
  73
  74 struct scmi_msg_pinctrl_attributes {
  75         __le32 identifier;
  76         __le32 flags;
  77 };
  78
  79 struct scmi_resp_pinctrl_attributes {
  80         __le32 attributes;
  81         u8 name[SCMI_SHORT_NAME_MAX_SIZE];
  82 };
  83
  84 struct scmi_msg_pinctrl_list_assoc {
  85         __le32 identifier;
  86         __le32 flags;
  87         __le32 index;
  88 };
  89
  90 struct scmi_resp_pinctrl_list_assoc {
  91         __le32 flags;
  92         __le16 array[];
  93 };
  94
  95 struct scmi_msg_request {
  96         __le32 identifier;
  97         __le32 flags;
  98 };
  99
 100 struct scmi_group_info {
 101         char name[SCMI_MAX_STR_SIZE];
 102         bool present;
 103         u32 *group_pins;
 104         u32 nr_pins;
 105 };
 106
 107 struct scmi_function_info {
 108         char name[SCMI_MAX_STR_SIZE];
 109         bool present;
 110         u32 *groups;
 111         u32 nr_groups;
 112 };
 113
 114 struct scmi_pin_info {
 115         char name[SCMI_MAX_STR_SIZE];
 116         bool present;
 117 };
 118
 119 struct scmi_pinctrl_info {
 120         u32 version;
 121         int nr_groups;
 122         int nr_functions;
 123         int nr_pins;
 124         struct scmi_group_info *groups;
 125         struct scmi_function_info *functions;
 126         struct scmi_pin_info *pins;
 127 };
 128
 129 static int scmi_pinctrl_attributes_get(const struct scmi_protocol_handle *ph,
 130                                        struct scmi_pinctrl_info *pi)
 131 {
 132         int ret;
 133         struct scmi_xfer *t;
 134         struct scmi_msg_pinctrl_protocol_attributes *attr;
 135
 136         ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0, sizeof(*attr), &t);
 137         if (ret)
 138                 return ret;
 139
 140         attr = t->rx.buf;
 141
 142         ret = ph->xops->do_xfer(ph, t);
 143         if (!ret) {
 144                 pi->nr_functions = GET_FUNCTIONS_NR(attr->attributes_high);
 145                 pi->nr_groups = GET_GROUPS_NR(attr->attributes_low);
 146                 pi->nr_pins = GET_PINS_NR(attr->attributes_low);
 147                 if (pi->nr_pins == 0) {
 148                         dev_warn(ph->dev, "returned zero pins\n");
 149                         ret = -EINVAL;
 150                 }
 151         }
 152
 153         ph->xops->xfer_put(ph, t);
 154         return ret;
 155 }
 156
 157 static int scmi_pinctrl_count_get(const struct scmi_protocol_handle *ph,
 158                                   enum scmi_pinctrl_selector_type type)
 159 {
 160         struct scmi_pinctrl_info *pi = ph->get_priv(ph);
 161
 162         switch (type) {
 163         case PIN_TYPE:
 164                 return pi->nr_pins;
 165         case GROUP_TYPE:
 166                 return pi->nr_groups;
 167         case FUNCTION_TYPE:
 168                 return pi->nr_functions;
 169         default:
 170                 return -EINVAL;
 171         }
 172 }
 173
 174 static int scmi_pinctrl_validate_id(const struct scmi_protocol_handle *ph,
 175                                     u32 selector,
 176                                     enum scmi_pinctrl_selector_type type)
 177 {
 178         int value;
 179
 180         value = scmi_pinctrl_count_get(ph, type);
 181         if (value < 0)
 182                 return value;
 183
 184         if (selector >= value || value == 0)
 185                 return -EINVAL;
 186
 187         return 0;
 188 }
 189
 190 static int scmi_pinctrl_attributes(const struct scmi_protocol_handle *ph,
 191                                    enum scmi_pinctrl_selector_type type,
 192                                    u32 selector, char *name,
 193                                    u32 *n_elems)
 194 {
 195         int ret;
 196         struct scmi_xfer *t;
 197         struct scmi_msg_pinctrl_attributes *tx;
 198         struct scmi_resp_pinctrl_attributes *rx;
 199         bool ext_name_flag;
 200
 201         if (!name)
 202                 return -EINVAL;
 203
 204         ret = scmi_pinctrl_validate_id(ph, selector, type);
 205         if (ret)
 206                 return ret;
 207
 208         ret = ph->xops->xfer_get_init(ph, PINCTRL_ATTRIBUTES, sizeof(*tx),
 209                                       sizeof(*rx), &t);
 210         if (ret)
 211                 return ret;
 212
 213         tx = t->tx.buf;
 214         rx = t->rx.buf;
 215         tx->identifier = cpu_to_le32(selector);
 216         tx->flags = cpu_to_le32(type);
 217
 218         ret = ph->xops->do_xfer(ph, t);
 219         if (!ret) {
 220                 if (n_elems)
 221                         *n_elems = NUM_ELEMS(rx->attributes);
 222
 223                 strscpy(name, rx->name, SCMI_SHORT_NAME_MAX_SIZE);
 224
 225                 ext_name_flag = !!EXT_NAME_FLAG(rx->attributes);
 226         }
 227
 228         ph->xops->xfer_put(ph, t);
 229
 230         if (ret)
 231                 return ret;
 232         /*
 233          * If supported overwrite short name with the extended one;
 234          * on error just carry on and use already provided short name.
 235          */
 236         if (ext_name_flag)
 237                 ret = ph->hops->extended_name_get(ph, PINCTRL_NAME_GET,
 238                                                   selector, (u32 *)&type, name,
 239                                                   SCMI_MAX_STR_SIZE);
 240         return ret;
 241 }
 242
 243 struct scmi_pinctrl_ipriv {
 244         u32 selector;
 245         enum scmi_pinctrl_selector_type type;
 246         u32 *array;
 247 };
 248
 249 static void iter_pinctrl_assoc_prepare_message(void *message,
 250                                                u32 desc_index,
 251                                                const void *priv)
 252 {
 253         struct scmi_msg_pinctrl_list_assoc *msg = message;
 254         const struct scmi_pinctrl_ipriv *p = priv;
 255
 256         msg->identifier = cpu_to_le32(p->selector);
 257         msg->flags = cpu_to_le32(p->type);
 258         msg->index = cpu_to_le32(desc_index);
 259 }
 260
 261 static int iter_pinctrl_assoc_update_state(struct scmi_iterator_state *st,
 262                                            const void *response, void *priv)
 263 {
 264         const struct scmi_resp_pinctrl_list_assoc *r = response;
 265
 266         st->num_returned = RETURNED(r->flags);
 267         st->num_remaining = REMAINING(r->flags);
 268
 269         return 0;
 270 }
 271
 272 static int
 273 iter_pinctrl_assoc_process_response(const struct scmi_protocol_handle *ph,
 274                                     const void *response,
 275                                     struct scmi_iterator_state *st, void *priv)
 276 {
 277         const struct scmi_resp_pinctrl_list_assoc *r = response;
 278         struct scmi_pinctrl_ipriv *p = priv;
 279
 280         p->array[st->desc_index + st->loop_idx] =
 281                 le16_to_cpu(r->array[st->loop_idx]);
 282
 283         return 0;
 284 }
 285
 286 static int scmi_pinctrl_list_associations(const struct scmi_protocol_handle *ph,
 287                                           u32 selector,
 288                                           enum scmi_pinctrl_selector_type type,
 289                                           u16 size, u32 *array)
 290 {
 291         int ret;
 292         void *iter;
 293         struct scmi_iterator_ops ops = {
 294                 .prepare_message = iter_pinctrl_assoc_prepare_message,
 295                 .update_state = iter_pinctrl_assoc_update_state,
 296                 .process_response = iter_pinctrl_assoc_process_response,
 297         };
 298         struct scmi_pinctrl_ipriv ipriv = {
 299                 .selector = selector,
 300                 .type = type,
 301                 .array = array,
 302         };
 303
 304         if (!array || !size || type == PIN_TYPE)
 305                 return -EINVAL;
 306
 307         ret = scmi_pinctrl_validate_id(ph, selector, type);
 308         if (ret)
 309                 return ret;
 310
 311         iter = ph->hops->iter_response_init(ph, &ops, size,
 312                                             PINCTRL_LIST_ASSOCIATIONS,
 313                                             sizeof(struct scmi_msg_pinctrl_list_assoc),
 314                                             &ipriv);
 315         if (IS_ERR(iter))
 316                 return PTR_ERR(iter);
 317
 318         return ph->hops->iter_response_run(iter);
 319 }
 320
 321 struct scmi_settings_get_ipriv {
 322         u32 selector;
 323         enum scmi_pinctrl_selector_type type;
 324         bool get_all;
 325         unsigned int *nr_configs;
 326         enum scmi_pinctrl_conf_type *config_types;
 327         u32 *config_values;
 328 };
 329
 330 static void
 331 iter_pinctrl_settings_get_prepare_message(void *message, u32 desc_index,
 332                                           const void *priv)
 333 {
 334         struct scmi_msg_settings_get *msg = message;
 335         const struct scmi_settings_get_ipriv *p = priv;
 336         u32 attributes;
 337
 338         attributes = FIELD_PREP(SELECTOR_MASK, p->type);
 339
 340         if (p->get_all) {
 341                 attributes |= FIELD_PREP(CONFIG_FLAG_MASK, 1) |
 342                         FIELD_PREP(SKIP_CONFIGS_MASK, desc_index);
 343         } else {
 344                 attributes |= FIELD_PREP(CONFIG_TYPE_MASK, p->config_types[0]);
 345         }
 346
 347         msg->attributes = cpu_to_le32(attributes);
 348         msg->identifier = cpu_to_le32(p->selector);
 349 }
 350
 351 static int
 352 iter_pinctrl_settings_get_update_state(struct scmi_iterator_state *st,
 353                                        const void *response, void *priv)
 354 {
 355         const struct scmi_resp_settings_get *r = response;
 356         struct scmi_settings_get_ipriv *p = priv;
 357
 358         if (p->get_all) {
 359                 st->num_returned = le32_get_bits(r->num_configs, GENMASK(7, 0));
 360                 st->num_remaining = le32_get_bits(r->num_configs, GENMASK(31, 24));
 361         } else {
 362                 st->num_returned = 1;
 363                 st->num_remaining = 0;
 364         }
 365
 366         return 0;
 367 }
 368
 369 static int
 370 iter_pinctrl_settings_get_process_response(const struct scmi_protocol_handle *ph,
 371                                            const void *response,
 372                                            struct scmi_iterator_state *st,
 373                                            void *priv)
 374 {
 375         const struct scmi_resp_settings_get *r = response;
 376         struct scmi_settings_get_ipriv *p = priv;
 377         u32 type = le32_get_bits(r->configs[st->loop_idx * 2], GENMASK(7, 0));
 378         u32 val = le32_to_cpu(r->configs[st->loop_idx * 2 + 1]);
 379
 380         if (p->get_all) {
 381                 p->config_types[st->desc_index + st->loop_idx] = type;
 382         } else {
 383                 if (p->config_types[0] != type)
 384                         return -EINVAL;
 385         }
 386
 387         p->config_values[st->desc_index + st->loop_idx] = val;
 388         ++*p->nr_configs;
 389
 390         return 0;
 391 }
 392
 393 static int
 394 scmi_pinctrl_settings_get(const struct scmi_protocol_handle *ph, u32 selector,
 395                           enum scmi_pinctrl_selector_type type,
 396                           unsigned int *nr_configs,
 397                           enum scmi_pinctrl_conf_type *config_types,
 398                           u32 *config_values)
 399 {
 400         int ret;
 401         void *iter;
 402         unsigned int max_configs = *nr_configs;
 403         struct scmi_iterator_ops ops = {
 404                 .prepare_message = iter_pinctrl_settings_get_prepare_message,
 405                 .update_state = iter_pinctrl_settings_get_update_state,
 406                 .process_response = iter_pinctrl_settings_get_process_response,
 407         };
 408         struct scmi_settings_get_ipriv ipriv = {
 409                 .selector = selector,
 410                 .type = type,
 411                 .get_all = (max_configs > 1),
 412                 .nr_configs = nr_configs,
 413                 .config_types = config_types,
 414                 .config_values = config_values,
 415         };
 416
 417         if (!config_types || !config_values || type == FUNCTION_TYPE)
 418                 return -EINVAL;
 419
 420         ret = scmi_pinctrl_validate_id(ph, selector, type);
 421         if (ret)
 422                 return ret;
 423
 424         /* Prepare to count returned configs */
 425         *nr_configs = 0;
 426         iter = ph->hops->iter_response_init(ph, &ops, max_configs,
 427                                             PINCTRL_SETTINGS_GET,
 428                                             sizeof(struct scmi_msg_settings_get),
 429                                             &ipriv);
 430         if (IS_ERR(iter))
 431                 return PTR_ERR(iter);
 432
 433         return ph->hops->iter_response_run(iter);
 434 }
 435
 436 static int scmi_pinctrl_settings_get_one(const struct scmi_protocol_handle *ph,
 437                                          u32 selector,
 438                                          enum scmi_pinctrl_selector_type type,
 439                                          enum scmi_pinctrl_conf_type config_type,
 440                                          u32 *config_value)
 441 {
 442         unsigned int nr_configs = 1;
 443
 444         return scmi_pinctrl_settings_get(ph, selector, type, &nr_configs,
 445                                          &config_type, config_value);
 446 }
 447
 448 static int scmi_pinctrl_settings_get_all(const struct scmi_protocol_handle *ph,
 449                                          u32 selector,
 450                                          enum scmi_pinctrl_selector_type type,
 451                                          unsigned int *nr_configs,
 452                                          enum scmi_pinctrl_conf_type *config_types,
 453                                          u32 *config_values)
 454 {
 455         if (!nr_configs || *nr_configs == 0)
 456                 return -EINVAL;
 457
 458         return scmi_pinctrl_settings_get(ph, selector, type, nr_configs,
 459                                          config_types, config_values);
 460 }
 461
 462 static int
 463 scmi_pinctrl_settings_conf(const struct scmi_protocol_handle *ph,
 464                            u32 selector,
 465                            enum scmi_pinctrl_selector_type type,
 466                            u32 nr_configs,
 467                            enum scmi_pinctrl_conf_type *config_type,
 468                            u32 *config_value)
 469 {
 470         struct scmi_xfer *t;
 471         struct scmi_msg_settings_conf *tx;
 472         u32 attributes;
 473         int ret, i;
 474         u32 configs_in_chunk, conf_num = 0;
 475         u32 chunk;
 476         int max_msg_size = ph->hops->get_max_msg_size(ph);
 477
 478         if (!config_type || !config_value || type == FUNCTION_TYPE)
 479                 return -EINVAL;
 480
 481         ret = scmi_pinctrl_validate_id(ph, selector, type);
 482         if (ret)
 483                 return ret;
 484
 485         configs_in_chunk = (max_msg_size - sizeof(*tx)) / (sizeof(__le32) * 2);
 486         while (conf_num < nr_configs) {
 487                 chunk = (nr_configs - conf_num > configs_in_chunk) ?
 488                         configs_in_chunk : nr_configs - conf_num;
 489
 490                 ret = ph->xops->xfer_get_init(ph, PINCTRL_SETTINGS_CONFIGURE,
 491                                               sizeof(*tx) +
 492                                               chunk * 2 * sizeof(__le32), 0, &t);
 493                 if (ret)
 494                         break;
 495
 496                 tx = t->tx.buf;
 497                 tx->identifier = cpu_to_le32(selector);
 498                 tx->function_id = cpu_to_le32(0xFFFFFFFF);
 499                 attributes = FIELD_PREP(GENMASK(1, 0), type) |
 500                         FIELD_PREP(GENMASK(9, 2), chunk);
 501                 tx->attributes = cpu_to_le32(attributes);
 502
 503                 for (i = 0; i < chunk; i++) {
 504                         tx->configs[i * 2] =
 505                                 cpu_to_le32(config_type[conf_num + i]);
 506                         tx->configs[i * 2 + 1] =
 507                                 cpu_to_le32(config_value[conf_num + i]);
 508                 }
 509
 510                 ret = ph->xops->do_xfer(ph, t);
 511
 512                 ph->xops->xfer_put(ph, t);
 513
 514                 if (ret)
 515                         break;
 516
 517                 conf_num += chunk;
 518         }
 519
 520         return ret;
 521 }
 522
 523 static int scmi_pinctrl_function_select(const struct scmi_protocol_handle *ph,
 524                                         u32 group,
 525                                         enum scmi_pinctrl_selector_type type,
 526                                         u32 function_id)
 527 {
 528         int ret;
 529         struct scmi_xfer *t;
 530         struct scmi_msg_settings_conf *tx;
 531         u32 attributes;
 532
 533         ret = scmi_pinctrl_validate_id(ph, group, type);
 534         if (ret)
 535                 return ret;
 536
 537         ret = ph->xops->xfer_get_init(ph, PINCTRL_SETTINGS_CONFIGURE,
 538                                       sizeof(*tx), 0, &t);
 539         if (ret)
 540                 return ret;
 541
 542         tx = t->tx.buf;
 543         tx->identifier = cpu_to_le32(group);
 544         tx->function_id = cpu_to_le32(function_id);
 545         attributes = FIELD_PREP(GENMASK(1, 0), type) | BIT(10);
 546         tx->attributes = cpu_to_le32(attributes);
 547
 548         ret = ph->xops->do_xfer(ph, t);
 549         ph->xops->xfer_put(ph, t);
 550
 551         return ret;
 552 }
 553
 554 static int scmi_pinctrl_request_free(const struct scmi_protocol_handle *ph,
 555                                      u32 identifier,
 556                                      enum scmi_pinctrl_selector_type type,
 557                                      enum scmi_pinctrl_protocol_cmd cmd)
 558 {
 559         int ret;
 560         struct scmi_xfer *t;
 561         struct scmi_msg_request *tx;
 562
 563         if (type == FUNCTION_TYPE)
 564                 return -EINVAL;
 565
 566         if (cmd != PINCTRL_REQUEST && cmd != PINCTRL_RELEASE)
 567                 return -EINVAL;
 568
 569         ret = scmi_pinctrl_validate_id(ph, identifier, type);
 570         if (ret)
 571                 return ret;
 572
 573         ret = ph->xops->xfer_get_init(ph, cmd, sizeof(*tx), 0, &t);
 574         if (ret)
 575                 return ret;
 576
 577         tx = t->tx.buf;
 578         tx->identifier = cpu_to_le32(identifier);
 579         tx->flags = cpu_to_le32(type);
 580
 581         ret = ph->xops->do_xfer(ph, t);
 582         ph->xops->xfer_put(ph, t);
 583
 584         return ret;
 585 }
 586
 587 static int scmi_pinctrl_pin_request(const struct scmi_protocol_handle *ph,
 588                                     u32 pin)
 589 {
 590         return scmi_pinctrl_request_free(ph, pin, PIN_TYPE, PINCTRL_REQUEST);
 591 }
 592
 593 static int scmi_pinctrl_pin_free(const struct scmi_protocol_handle *ph, u32 pin)
 594 {
 595         return scmi_pinctrl_request_free(ph, pin, PIN_TYPE, PINCTRL_RELEASE);
 596 }
 597
 598 static int scmi_pinctrl_get_group_info(const struct scmi_protocol_handle *ph,
 599                                        u32 selector,
 600                                        struct scmi_group_info *group)
 601 {
 602         int ret;
 603
 604         ret = scmi_pinctrl_attributes(ph, GROUP_TYPE, selector, group->name,
 605                                       &group->nr_pins);
 606         if (ret)
 607                 return ret;
 608
 609         if (!group->nr_pins) {
 610                 dev_err(ph->dev, "Group %d has 0 elements", selector);
 611                 return -ENODATA;
 612         }
 613
 614         group->group_pins = kmalloc_array(group->nr_pins,
 615                                           sizeof(*group->group_pins),
 616                                           GFP_KERNEL);
 617         if (!group->group_pins)
 618                 return -ENOMEM;
 619
 620         ret = scmi_pinctrl_list_associations(ph, selector, GROUP_TYPE,
 621                                              group->nr_pins, group->group_pins);
 622         if (ret) {
 623                 kfree(group->group_pins);
 624                 return ret;
 625         }
 626
 627         group->present = true;
 628         return 0;
 629 }
 630
 631 static int scmi_pinctrl_get_group_name(const struct scmi_protocol_handle *ph,
 632                                        u32 selector, const char **name)
 633 {
 634         struct scmi_pinctrl_info *pi = ph->get_priv(ph);
 635
 636         if (!name)
 637                 return -EINVAL;
 638
 639         if (selector >= pi->nr_groups || pi->nr_groups == 0)
 640                 return -EINVAL;
 641
 642         if (!pi->groups[selector].present) {
 643                 int ret;
 644
 645                 ret = scmi_pinctrl_get_group_info(ph, selector,
 646                                                   &pi->groups[selector]);
 647                 if (ret)
 648                         return ret;
 649         }
 650
 651         *name = pi->groups[selector].name;
 652
 653         return 0;
 654 }
 655
 656 static int scmi_pinctrl_group_pins_get(const struct scmi_protocol_handle *ph,
 657                                        u32 selector, const u32 **pins,
 658                                        u32 *nr_pins)
 659 {
 660         struct scmi_pinctrl_info *pi = ph->get_priv(ph);
 661
 662         if (!pins || !nr_pins)
 663                 return -EINVAL;
 664
 665         if (selector >= pi->nr_groups || pi->nr_groups == 0)
 666                 return -EINVAL;
 667
 668         if (!pi->groups[selector].present) {
 669                 int ret;
 670
 671                 ret = scmi_pinctrl_get_group_info(ph, selector,
 672                                                   &pi->groups[selector]);
 673                 if (ret)
 674                         return ret;
 675         }
 676
 677         *pins = pi->groups[selector].group_pins;
 678         *nr_pins = pi->groups[selector].nr_pins;
 679
 680         return 0;
 681 }
 682
 683 static int scmi_pinctrl_get_function_info(const struct scmi_protocol_handle *ph,
 684                                           u32 selector,
 685                                           struct scmi_function_info *func)
 686 {
 687         int ret;
 688
 689         ret = scmi_pinctrl_attributes(ph, FUNCTION_TYPE, selector, func->name,
 690                                       &func->nr_groups);
 691         if (ret)
 692                 return ret;
 693
 694         if (!func->nr_groups) {
 695                 dev_err(ph->dev, "Function %d has 0 elements", selector);
 696                 return -ENODATA;
 697         }
 698
 699         func->groups = kmalloc_array(func->nr_groups, sizeof(*func->groups),
 700                                      GFP_KERNEL);
 701         if (!func->groups)
 702                 return -ENOMEM;
 703
 704         ret = scmi_pinctrl_list_associations(ph, selector, FUNCTION_TYPE,
 705                                              func->nr_groups, func->groups);
 706         if (ret) {
 707                 kfree(func->groups);
 708                 return ret;
 709         }
 710
 711         func->present = true;
 712         return 0;
 713 }
 714
 715 static int scmi_pinctrl_get_function_name(const struct scmi_protocol_handle *ph,
 716                                           u32 selector, const char **name)
 717 {
 718         struct scmi_pinctrl_info *pi = ph->get_priv(ph);
 719
 720         if (!name)
 721                 return -EINVAL;
 722
 723         if (selector >= pi->nr_functions || pi->nr_functions == 0)
 724                 return -EINVAL;
 725
 726         if (!pi->functions[selector].present) {
 727                 int ret;
 728
 729                 ret = scmi_pinctrl_get_function_info(ph, selector,
 730                                                      &pi->functions[selector]);
 731                 if (ret)
 732                         return ret;
 733         }
 734
 735         *name = pi->functions[selector].name;
 736         return 0;
 737 }
 738
 739 static int
 740 scmi_pinctrl_function_groups_get(const struct scmi_protocol_handle *ph,
 741                                  u32 selector, u32 *nr_groups,
 742                                  const u32 **groups)
 743 {
 744         struct scmi_pinctrl_info *pi = ph->get_priv(ph);
 745
 746         if (!groups || !nr_groups)
 747                 return -EINVAL;
 748
 749         if (selector >= pi->nr_functions || pi->nr_functions == 0)
 750                 return -EINVAL;
 751
 752         if (!pi->functions[selector].present) {
 753                 int ret;
 754
 755                 ret = scmi_pinctrl_get_function_info(ph, selector,
 756                                                      &pi->functions[selector]);
 757                 if (ret)
 758                         return ret;
 759         }
 760
 761         *groups = pi->functions[selector].groups;
 762         *nr_groups = pi->functions[selector].nr_groups;
 763
 764         return 0;
 765 }
 766
 767 static int scmi_pinctrl_mux_set(const struct scmi_protocol_handle *ph,
 768                                 u32 selector, u32 group)
 769 {
 770         return scmi_pinctrl_function_select(ph, group, GROUP_TYPE, selector);
 771 }
 772
 773 static int scmi_pinctrl_get_pin_info(const struct scmi_protocol_handle *ph,
 774                                      u32 selector, struct scmi_pin_info *pin)
 775 {
 776         int ret;
 777
 778         if (!pin)
 779                 return -EINVAL;
 780
 781         ret = scmi_pinctrl_attributes(ph, PIN_TYPE, selector, pin->name, NULL);
 782         if (ret)
 783                 return ret;
 784
 785         pin->present = true;
 786         return 0;
 787 }
 788
 789 static int scmi_pinctrl_get_pin_name(const struct scmi_protocol_handle *ph,
 790                                      u32 selector, const char **name)
 791 {
 792         struct scmi_pinctrl_info *pi = ph->get_priv(ph);
 793
 794         if (!name)
 795                 return -EINVAL;
 796
 797         if (selector >= pi->nr_pins)
 798                 return -EINVAL;
 799
 800         if (!pi->pins[selector].present) {
 801                 int ret;
 802
 803                 ret = scmi_pinctrl_get_pin_info(ph, selector, &pi->pins[selector]);
 804                 if (ret)
 805                         return ret;
 806         }
 807
 808         *name = pi->pins[selector].name;
 809
 810         return 0;
 811 }
 812
 813 static int scmi_pinctrl_name_get(const struct scmi_protocol_handle *ph,
 814                                  u32 selector,
 815                                  enum scmi_pinctrl_selector_type type,
 816                                  const char **name)
 817 {
 818         switch (type) {
 819         case PIN_TYPE:
 820                 return scmi_pinctrl_get_pin_name(ph, selector, name);
 821         case GROUP_TYPE:
 822                 return scmi_pinctrl_get_group_name(ph, selector, name);
 823         case FUNCTION_TYPE:
 824                 return scmi_pinctrl_get_function_name(ph, selector, name);
 825         default:
 826                 return -EINVAL;
 827         }
 828 }
 829
 830 static const struct scmi_pinctrl_proto_ops pinctrl_proto_ops = {
 831         .count_get = scmi_pinctrl_count_get,
 832         .name_get = scmi_pinctrl_name_get,
 833         .group_pins_get = scmi_pinctrl_group_pins_get,
 834         .function_groups_get = scmi_pinctrl_function_groups_get,
 835         .mux_set = scmi_pinctrl_mux_set,
 836         .settings_get_one = scmi_pinctrl_settings_get_one,
 837         .settings_get_all = scmi_pinctrl_settings_get_all,
 838         .settings_conf = scmi_pinctrl_settings_conf,
 839         .pin_request = scmi_pinctrl_pin_request,
 840         .pin_free = scmi_pinctrl_pin_free,
 841 };
 842
 843 static int scmi_pinctrl_protocol_init(const struct scmi_protocol_handle *ph)
 844 {
 845         int ret;
 846         u32 version;
 847         struct scmi_pinctrl_info *pinfo;
 848
 849         ret = ph->xops->version_get(ph, &version);
 850         if (ret)
 851                 return ret;
 852
 853         dev_dbg(ph->dev, "Pinctrl Version %d.%d\n",
 854                 PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version));
 855
 856         pinfo = devm_kzalloc(ph->dev, sizeof(*pinfo), GFP_KERNEL);
 857         if (!pinfo)
 858                 return -ENOMEM;
 859
 860         ret = scmi_pinctrl_attributes_get(ph, pinfo);
 861         if (ret)
 862                 return ret;
 863
 864         pinfo->pins = devm_kcalloc(ph->dev, pinfo->nr_pins,
 865                                    sizeof(*pinfo->pins), GFP_KERNEL);
 866         if (!pinfo->pins)
 867                 return -ENOMEM;
 868
 869         pinfo->groups = devm_kcalloc(ph->dev, pinfo->nr_groups,
 870                                      sizeof(*pinfo->groups), GFP_KERNEL);
 871         if (!pinfo->groups)
 872                 return -ENOMEM;
 873
 874         pinfo->functions = devm_kcalloc(ph->dev, pinfo->nr_functions,
 875                                         sizeof(*pinfo->functions), GFP_KERNEL);
 876         if (!pinfo->functions)
 877                 return -ENOMEM;
 878
 879         pinfo->version = version;
 880
 881         return ph->set_priv(ph, pinfo, version);
 882 }
 883
 884 static int scmi_pinctrl_protocol_deinit(const struct scmi_protocol_handle *ph)
 885 {
 886         int i;
 887         struct scmi_pinctrl_info *pi = ph->get_priv(ph);
 888
 889         /* Free groups_pins allocated in scmi_pinctrl_get_group_info */
 890         for (i = 0; i < pi->nr_groups; i++) {
 891                 if (pi->groups[i].present) {
 892                         kfree(pi->groups[i].group_pins);
 893                         pi->groups[i].present = false;
 894                 }
 895         }
 896
 897         /* Free groups allocated in scmi_pinctrl_get_function_info */
 898         for (i = 0; i < pi->nr_functions; i++) {
 899                 if (pi->functions[i].present) {
 900                         kfree(pi->functions[i].groups);
 901                         pi->functions[i].present = false;
 902                 }
 903         }
 904
 905         return 0;
 906 }
 907
 908 static const struct scmi_protocol scmi_pinctrl = {
 909         .id = SCMI_PROTOCOL_PINCTRL,
 910         .owner = THIS_MODULE,
 911         .instance_init = &scmi_pinctrl_protocol_init,
 912         .instance_deinit = &scmi_pinctrl_protocol_deinit,
 913         .ops = &pinctrl_proto_ops,
 914         .supported_version = SCMI_PROTOCOL_SUPPORTED_VERSION,
 915 };
 916
 917 DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(pinctrl, scmi_pinctrl)