drivers/soundwire/mipi_disco.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
   2 // Copyright(c) 2015-17 Intel Corporation.
   3
   4 /*
   5  * MIPI Discovery And Configuration (DisCo) Specification for SoundWire
   6  * specifies properties to be implemented for SoundWire Masters and Slaves.
   7  * The DisCo spec doesn't mandate these properties. However, SDW bus cannot
   8  * work without knowing these values.
   9  *
  10  * The helper functions read the Master and Slave properties. Implementers
  11  * of Master or Slave drivers can use any of the below three mechanisms:
  12  *    a) Use these APIs here as .read_prop() callback for Master and Slave
  13  *    b) Implement own methods and set those as .read_prop(), but invoke
  14  *    APIs in this file for generic read and override the values with
  15  *    platform specific data
  16  *    c) Implement ones own methods which do not use anything provided
  17  *    here
  18  */
  19
  20 #include <linux/device.h>
  21 #include <linux/property.h>
  22 #include <linux/mod_devicetable.h>
  23 #include <linux/soundwire/sdw.h>
  24 #include "bus.h"
  25
  26 static bool mipi_fwnode_property_read_bool(const struct fwnode_handle *fwnode,
  27                                            const char *propname)
  28 {
  29         int ret;
  30         u8 val;
  31
  32         if (!fwnode_property_present(fwnode, propname))
  33                 return false;
  34         ret = fwnode_property_read_u8_array(fwnode, propname, &val, 1);
  35         if (ret < 0)
  36                 return false;
  37         return !!val;
  38 }
  39
  40 static bool mipi_device_property_read_bool(const struct device *dev,
  41                                            const char *propname)
  42 {
  43         return mipi_fwnode_property_read_bool(dev_fwnode(dev), propname);
  44 }
  45
  46 /**
  47  * sdw_master_read_prop() - Read Master properties
  48  * @bus: SDW bus instance
  49  */
  50 int sdw_master_read_prop(struct sdw_bus *bus)
  51 {
  52         struct sdw_master_prop *prop = &bus->prop;
  53         struct fwnode_handle *link;
  54         const char *scales_prop;
  55         char name[32];
  56         int nval;
  57         int ret;
  58         int i;
  59
  60         device_property_read_u32(bus->dev,
  61                                  "mipi-sdw-sw-interface-revision",
  62                                  &prop->revision);
  63
  64         /* Find master handle */
  65         snprintf(name, sizeof(name),
  66                  "mipi-sdw-link-%d-subproperties", bus->link_id);
  67
  68         link = device_get_named_child_node(bus->dev, name);
  69         if (!link) {
  70                 dev_err(bus->dev, "Master node %s not found\n", name);
  71                 return -EIO;
  72         }
  73
  74         if (mipi_fwnode_property_read_bool(link,
  75                                       "mipi-sdw-clock-stop-mode0-supported"))
  76                 prop->clk_stop_modes |= BIT(SDW_CLK_STOP_MODE0);
  77
  78         if (mipi_fwnode_property_read_bool(link,
  79                                       "mipi-sdw-clock-stop-mode1-supported"))
  80                 prop->clk_stop_modes |= BIT(SDW_CLK_STOP_MODE1);
  81
  82         fwnode_property_read_u32(link,
  83                                  "mipi-sdw-max-clock-frequency",
  84                                  &prop->max_clk_freq);
  85
  86         nval = fwnode_property_count_u32(link, "mipi-sdw-clock-frequencies-supported");
  87         if (nval > 0) {
  88                 prop->num_clk_freq = nval;
  89                 prop->clk_freq = devm_kcalloc(bus->dev, prop->num_clk_freq,
  90                                               sizeof(*prop->clk_freq),
  91                                               GFP_KERNEL);
  92                 if (!prop->clk_freq) {
  93                         fwnode_handle_put(link);
  94                         return -ENOMEM;
  95                 }
  96
  97                 ret = fwnode_property_read_u32_array(link,
  98                                 "mipi-sdw-clock-frequencies-supported",
  99                                 prop->clk_freq, prop->num_clk_freq);
 100                 if (ret < 0)
 101                         return ret;
 102         }
 103
 104         /*
 105          * Check the frequencies supported. If FW doesn't provide max
 106          * freq, then populate here by checking values.
 107          */
 108         if (!prop->max_clk_freq && prop->clk_freq) {
 109                 prop->max_clk_freq = prop->clk_freq[0];
 110                 for (i = 1; i < prop->num_clk_freq; i++) {
 111                         if (prop->clk_freq[i] > prop->max_clk_freq)
 112                                 prop->max_clk_freq = prop->clk_freq[i];
 113                 }
 114         }
 115
 116         scales_prop = "mipi-sdw-supported-clock-scales";
 117         nval = fwnode_property_count_u32(link, scales_prop);
 118         if (nval == 0) {
 119                 scales_prop = "mipi-sdw-supported-clock-gears";
 120                 nval = fwnode_property_count_u32(link, scales_prop);
 121         }
 122         if (nval > 0) {
 123                 prop->num_clk_gears = nval;
 124                 prop->clk_gears = devm_kcalloc(bus->dev, prop->num_clk_gears,
 125                                                sizeof(*prop->clk_gears),
 126                                                GFP_KERNEL);
 127                 if (!prop->clk_gears) {
 128                         fwnode_handle_put(link);
 129                         return -ENOMEM;
 130                 }
 131
 132                 ret = fwnode_property_read_u32_array(link,
 133                                                scales_prop,
 134                                                prop->clk_gears,
 135                                                prop->num_clk_gears);
 136                 if (ret < 0)
 137                         return ret;
 138         }
 139
 140         fwnode_property_read_u32(link, "mipi-sdw-default-frame-rate",
 141                                  &prop->default_frame_rate);
 142
 143         fwnode_property_read_u32(link, "mipi-sdw-default-frame-row-size",
 144                                  &prop->default_row);
 145
 146         fwnode_property_read_u32(link, "mipi-sdw-default-frame-col-size",
 147                                  &prop->default_col);
 148
 149         prop->dynamic_frame =  mipi_fwnode_property_read_bool(link,
 150                         "mipi-sdw-dynamic-frame-shape");
 151
 152         fwnode_property_read_u32(link, "mipi-sdw-command-error-threshold",
 153                                  &prop->err_threshold);
 154
 155         fwnode_handle_put(link);
 156
 157         return 0;
 158 }
 159 EXPORT_SYMBOL(sdw_master_read_prop);
 160
 161 static int sdw_slave_read_dp0(struct sdw_slave *slave,
 162                               struct fwnode_handle *port,
 163                               struct sdw_dp0_prop *dp0)
 164 {
 165         int nval;
 166         int ret;
 167
 168         fwnode_property_read_u32(port, "mipi-sdw-port-max-wordlength",
 169                                  &dp0->max_word);
 170
 171         fwnode_property_read_u32(port, "mipi-sdw-port-min-wordlength",
 172                                  &dp0->min_word);
 173
 174         nval = fwnode_property_count_u32(port, "mipi-sdw-port-wordlength-configs");
 175         if (nval > 0) {
 176
 177                 dp0->num_words = nval;
 178                 dp0->words = devm_kcalloc(&slave->dev,
 179                                           dp0->num_words, sizeof(*dp0->words),
 180                                           GFP_KERNEL);
 181                 if (!dp0->words)
 182                         return -ENOMEM;
 183
 184                 ret = fwnode_property_read_u32_array(port,
 185                                 "mipi-sdw-port-wordlength-configs",
 186                                 dp0->words, dp0->num_words);
 187                 if (ret < 0)
 188                         return ret;
 189         }
 190
 191         dp0->BRA_flow_controlled = mipi_fwnode_property_read_bool(port,
 192                                 "mipi-sdw-bra-flow-controlled");
 193
 194         dp0->simple_ch_prep_sm = mipi_fwnode_property_read_bool(port,
 195                                 "mipi-sdw-simplified-channel-prepare-sm");
 196
 197         dp0->imp_def_interrupts = mipi_fwnode_property_read_bool(port,
 198                                 "mipi-sdw-imp-def-dp0-interrupts-supported");
 199
 200         nval = fwnode_property_count_u32(port, "mipi-sdw-lane-list");
 201         if (nval > 0) {
 202                 dp0->num_lanes = nval;
 203                 dp0->lane_list = devm_kcalloc(&slave->dev,
 204                                               dp0->num_lanes, sizeof(*dp0->lane_list),
 205                                               GFP_KERNEL);
 206                 if (!dp0->lane_list)
 207                         return -ENOMEM;
 208
 209                 ret = fwnode_property_read_u32_array(port,
 210                                                "mipi-sdw-lane-list",
 211                                                dp0->lane_list, dp0->num_lanes);
 212                 if (ret < 0)
 213                         return ret;
 214         }
 215
 216         return 0;
 217 }
 218
 219 static int sdw_slave_read_dpn(struct sdw_slave *slave,
 220                               struct sdw_dpn_prop *dpn, int count, int ports,
 221                               char *type)
 222 {
 223         struct fwnode_handle *node;
 224         u32 bit, i = 0;
 225         unsigned long addr;
 226         char name[40];
 227         int nval;
 228         int ret;
 229
 230         addr = ports;
 231         /* valid ports are 1 to 14 so apply mask */
 232         addr &= GENMASK(14, 1);
 233
 234         for_each_set_bit(bit, &addr, 32) {
 235                 snprintf(name, sizeof(name),
 236                          "mipi-sdw-dp-%d-%s-subproperties", bit, type);
 237
 238                 dpn[i].num = bit;
 239
 240                 node = device_get_named_child_node(&slave->dev, name);
 241                 if (!node) {
 242                         dev_err(&slave->dev, "%s dpN not found\n", name);
 243                         return -EIO;
 244                 }
 245
 246                 fwnode_property_read_u32(node, "mipi-sdw-port-max-wordlength",
 247                                          &dpn[i].max_word);
 248                 fwnode_property_read_u32(node, "mipi-sdw-port-min-wordlength",
 249                                          &dpn[i].min_word);
 250
 251                 nval = fwnode_property_count_u32(node, "mipi-sdw-port-wordlength-configs");
 252                 if (nval > 0) {
 253                         dpn[i].num_words = nval;
 254                         dpn[i].words = devm_kcalloc(&slave->dev,
 255                                                     dpn[i].num_words,
 256                                                     sizeof(*dpn[i].words),
 257                                                     GFP_KERNEL);
 258                         if (!dpn[i].words) {
 259                                 fwnode_handle_put(node);
 260                                 return -ENOMEM;
 261                         }
 262
 263                         ret = fwnode_property_read_u32_array(node,
 264                                         "mipi-sdw-port-wordlength-configs",
 265                                         dpn[i].words, dpn[i].num_words);
 266                         if (ret < 0)
 267                                 return ret;
 268                 }
 269
 270                 fwnode_property_read_u32(node, "mipi-sdw-data-port-type",
 271                                          &dpn[i].type);
 272
 273                 fwnode_property_read_u32(node,
 274                                          "mipi-sdw-max-grouping-supported",
 275                                          &dpn[i].max_grouping);
 276
 277                 dpn[i].simple_ch_prep_sm = mipi_fwnode_property_read_bool(node,
 278                                 "mipi-sdw-simplified-channelprepare-sm");
 279
 280                 fwnode_property_read_u32(node,
 281                                          "mipi-sdw-port-channelprepare-timeout",
 282                                          &dpn[i].ch_prep_timeout);
 283
 284                 fwnode_property_read_u32(node,
 285                                 "mipi-sdw-imp-def-dpn-interrupts-supported",
 286                                 &dpn[i].imp_def_interrupts);
 287
 288                 fwnode_property_read_u32(node, "mipi-sdw-min-channel-number",
 289                                          &dpn[i].min_ch);
 290
 291                 fwnode_property_read_u32(node, "mipi-sdw-max-channel-number",
 292                                          &dpn[i].max_ch);
 293
 294                 nval = fwnode_property_count_u32(node, "mipi-sdw-channel-number-list");
 295                 if (nval > 0) {
 296                         dpn[i].num_channels = nval;
 297                         dpn[i].channels = devm_kcalloc(&slave->dev,
 298                                                        dpn[i].num_channels,
 299                                                        sizeof(*dpn[i].channels),
 300                                                  GFP_KERNEL);
 301                         if (!dpn[i].channels) {
 302                                 fwnode_handle_put(node);
 303                                 return -ENOMEM;
 304                         }
 305
 306                         ret = fwnode_property_read_u32_array(node,
 307                                         "mipi-sdw-channel-number-list",
 308                                         dpn[i].channels, dpn[i].num_channels);
 309                         if (ret < 0)
 310                                 return ret;
 311                 }
 312
 313                 nval = fwnode_property_count_u32(node, "mipi-sdw-channel-combination-list");
 314                 if (nval > 0) {
 315                         dpn[i].num_ch_combinations = nval;
 316                         dpn[i].ch_combinations = devm_kcalloc(&slave->dev,
 317                                         dpn[i].num_ch_combinations,
 318                                         sizeof(*dpn[i].ch_combinations),
 319                                         GFP_KERNEL);
 320                         if (!dpn[i].ch_combinations) {
 321                                 fwnode_handle_put(node);
 322                                 return -ENOMEM;
 323                         }
 324
 325                         ret = fwnode_property_read_u32_array(node,
 326                                         "mipi-sdw-channel-combination-list",
 327                                         dpn[i].ch_combinations,
 328                                         dpn[i].num_ch_combinations);
 329                         if (ret < 0)
 330                                 return ret;
 331                 }
 332
 333                 fwnode_property_read_u32(node,
 334                                 "mipi-sdw-modes-supported", &dpn[i].modes);
 335
 336                 fwnode_property_read_u32(node, "mipi-sdw-max-async-buffer",
 337                                          &dpn[i].max_async_buffer);
 338
 339                 dpn[i].block_pack_mode = mipi_fwnode_property_read_bool(node,
 340                                 "mipi-sdw-block-packing-mode");
 341
 342                 fwnode_property_read_u32(node, "mipi-sdw-port-encoding-type",
 343                                          &dpn[i].port_encoding);
 344
 345                 nval = fwnode_property_count_u32(node, "mipi-sdw-lane-list");
 346                 if (nval > 0) {
 347                         dpn[i].num_lanes = nval;
 348                         dpn[i].lane_list = devm_kcalloc(&slave->dev,
 349                                                         dpn[i].num_lanes, sizeof(*dpn[i].lane_list),
 350                                                         GFP_KERNEL);
 351                         if (!dpn[i].lane_list)
 352                                 return -ENOMEM;
 353
 354                         ret = fwnode_property_read_u32_array(node,
 355                                                        "mipi-sdw-lane-list",
 356                                                        dpn[i].lane_list, dpn[i].num_lanes);
 357                         if (ret < 0)
 358                                 return ret;
 359                 }
 360
 361                 fwnode_handle_put(node);
 362
 363                 i++;
 364         }
 365
 366         return 0;
 367 }
 368
 369 /*
 370  * In MIPI DisCo spec for SoundWire, lane mapping for a slave device is done with
 371  * mipi-sdw-lane-x-mapping properties, where x is 1..7, and the values for those
 372  * properties are mipi-sdw-manager-lane-x or mipi-sdw-peripheral-link-y, where x
 373  * is an integer between 1 to 7 if the lane is connected to a manager lane, y is a
 374  * character between A to E if the lane is connected to another peripheral lane.
 375  */
 376 int sdw_slave_read_lane_mapping(struct sdw_slave *slave)
 377 {
 378         struct sdw_slave_prop *prop = &slave->prop;
 379         struct device *dev = &slave->dev;
 380         char prop_name[30];
 381         const char *prop_val;
 382         size_t len;
 383         int ret, i;
 384         u8 lane;
 385
 386         for (i = 0; i < SDW_MAX_LANES; i++) {
 387                 snprintf(prop_name, sizeof(prop_name), "mipi-sdw-lane-%d-mapping", i);
 388                 ret = device_property_read_string(dev, prop_name, &prop_val);
 389                 if (ret)
 390                         continue;
 391
 392                 len = strlen(prop_val);
 393                 if (len < 1)
 394                         return -EINVAL;
 395
 396                 /* The last character is enough to identify the connection */
 397                 ret = kstrtou8(&prop_val[len - 1], 10, &lane);
 398                 if (ret)
 399                         return ret;
 400                 if (in_range(lane, 1, SDW_MAX_LANES - 1))
 401                         prop->lane_maps[i] = lane;
 402         }
 403         return 0;
 404 }
 405 EXPORT_SYMBOL(sdw_slave_read_lane_mapping);
 406
 407 /**
 408  * sdw_slave_read_prop() - Read Slave properties
 409  * @slave: SDW Slave
 410  */
 411 int sdw_slave_read_prop(struct sdw_slave *slave)
 412 {
 413         struct sdw_slave_prop *prop = &slave->prop;
 414         struct device *dev = &slave->dev;
 415         struct fwnode_handle *port;
 416         int nval;
 417         int ret;
 418
 419         device_property_read_u32(dev, "mipi-sdw-sw-interface-revision",
 420                                  &prop->mipi_revision);
 421
 422         prop->wake_capable = mipi_device_property_read_bool(dev,
 423                                 "mipi-sdw-wake-up-unavailable");
 424         prop->wake_capable = !prop->wake_capable;
 425
 426         prop->test_mode_capable = mipi_device_property_read_bool(dev,
 427                                 "mipi-sdw-test-mode-supported");
 428
 429         prop->clk_stop_mode1 = false;
 430         if (mipi_device_property_read_bool(dev,
 431                                 "mipi-sdw-clock-stop-mode1-supported"))
 432                 prop->clk_stop_mode1 = true;
 433
 434         prop->simple_clk_stop_capable = mipi_device_property_read_bool(dev,
 435                         "mipi-sdw-simplified-clockstopprepare-sm-supported");
 436
 437         device_property_read_u32(dev, "mipi-sdw-clockstopprepare-timeout",
 438                                  &prop->clk_stop_timeout);
 439
 440         ret = device_property_read_u32(dev, "mipi-sdw-peripheral-channelprepare-timeout",
 441                                        &prop->ch_prep_timeout);
 442         if (ret < 0)
 443                 device_property_read_u32(dev, "mipi-sdw-slave-channelprepare-timeout",
 444                                          &prop->ch_prep_timeout);
 445
 446         device_property_read_u32(dev,
 447                         "mipi-sdw-clockstopprepare-hard-reset-behavior",
 448                         &prop->reset_behave);
 449
 450         prop->high_PHY_capable = mipi_device_property_read_bool(dev,
 451                         "mipi-sdw-highPHY-capable");
 452
 453         prop->paging_support = mipi_device_property_read_bool(dev,
 454                         "mipi-sdw-paging-support");
 455
 456         prop->bank_delay_support = mipi_device_property_read_bool(dev,
 457                         "mipi-sdw-bank-delay-support");
 458
 459         device_property_read_u32(dev,
 460                         "mipi-sdw-port15-read-behavior", &prop->p15_behave);
 461
 462         device_property_read_u32(dev, "mipi-sdw-master-count",
 463                                  &prop->master_count);
 464
 465         device_property_read_u32(dev, "mipi-sdw-source-port-list",
 466                                  &prop->source_ports);
 467
 468         device_property_read_u32(dev, "mipi-sdw-sink-port-list",
 469                                  &prop->sink_ports);
 470
 471         device_property_read_u32(dev, "mipi-sdw-sdca-interrupt-register-list",
 472                                  &prop->sdca_interrupt_register_list);
 473
 474         prop->commit_register_supported = mipi_device_property_read_bool(dev,
 475                         "mipi-sdw-commit-register-supported");
 476
 477         /*
 478          * Read dp0 properties - we don't rely on the 'mipi-sdw-dp-0-supported'
 479          * property since the 'mipi-sdw-dp0-subproperties' property is logically
 480          * equivalent.
 481          */
 482         port = device_get_named_child_node(dev, "mipi-sdw-dp-0-subproperties");
 483         if (!port) {
 484                 dev_dbg(dev, "DP0 node not found!!\n");
 485         } else {
 486                 prop->dp0_prop = devm_kzalloc(&slave->dev,
 487                                               sizeof(*prop->dp0_prop),
 488                                               GFP_KERNEL);
 489                 if (!prop->dp0_prop) {
 490                         fwnode_handle_put(port);
 491                         return -ENOMEM;
 492                 }
 493
 494                 sdw_slave_read_dp0(slave, port, prop->dp0_prop);
 495
 496                 fwnode_handle_put(port);
 497         }
 498
 499         /*
 500          * Based on each DPn port, get source and sink dpn properties.
 501          * Also, some ports can operate as both source or sink.
 502          */
 503
 504         /* Allocate memory for set bits in port lists */
 505         nval = hweight32(prop->source_ports);
 506         prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval,
 507                                           sizeof(*prop->src_dpn_prop),
 508                                           GFP_KERNEL);
 509         if (!prop->src_dpn_prop)
 510                 return -ENOMEM;
 511
 512         /* Read dpn properties for source port(s) */
 513         sdw_slave_read_dpn(slave, prop->src_dpn_prop, nval,
 514                            prop->source_ports, "source");
 515
 516         nval = hweight32(prop->sink_ports);
 517         prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval,
 518                                            sizeof(*prop->sink_dpn_prop),
 519                                            GFP_KERNEL);
 520         if (!prop->sink_dpn_prop)
 521                 return -ENOMEM;
 522
 523         /* Read dpn properties for sink port(s) */
 524         sdw_slave_read_dpn(slave, prop->sink_dpn_prop, nval,
 525                            prop->sink_ports, "sink");
 526
 527         return sdw_slave_read_lane_mapping(slave);
 528 }
 529 EXPORT_SYMBOL(sdw_slave_read_prop);