drivers/soundwire/sysfs_slave_dpn.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright(c) 2015-2020 Intel Corporation.
   3
   4 #include <linux/device.h>
   5 #include <linux/mod_devicetable.h>
   6 #include <linux/slab.h>
   7 #include <linux/sysfs.h>
   8 #include <linux/soundwire/sdw.h>
   9 #include <linux/soundwire/sdw_type.h>
  10 #include "bus.h"
  11 #include "sysfs_local.h"
  12
  13 struct dpn_attribute {
  14         struct device_attribute dev_attr;
  15         int N;
  16         int dir;
  17         const char *format_string;
  18 };
  19
  20 /*
  21  * Since we can't use ARRAY_SIZE, hard-code number of dpN attributes.
  22  * This needs to be updated when adding new attributes - an error will be
  23  * flagged on a mismatch.
  24  */
  25 #define SDW_DPN_ATTRIBUTES 15
  26
  27 #define sdw_dpn_attribute_alloc(field)                                  \
  28 static int field##_attribute_alloc(struct device *dev,                  \
  29                                 struct attribute **res,                 \
  30                                 int N, int dir,                         \
  31                                 const char *format_string)              \
  32 {                                                                       \
  33         struct dpn_attribute *dpn_attr;                                 \
  34                                                                         \
  35         dpn_attr = devm_kzalloc(dev, sizeof(*dpn_attr), GFP_KERNEL);    \
  36         if (!dpn_attr)                                                  \
  37                 return -ENOMEM;                                         \
  38         dpn_attr->N = N;                                                \
  39         dpn_attr->dir = dir;                                            \
  40         sysfs_attr_init(&dpn_attr->dev_attr.attr);                      \
  41         dpn_attr->format_string = format_string;                        \
  42         dpn_attr->dev_attr.attr.name = __stringify(field);              \
  43         dpn_attr->dev_attr.attr.mode = 0444;                            \
  44         dpn_attr->dev_attr.show = field##_show;                         \
  45                                                                         \
  46         *res = &dpn_attr->dev_attr.attr;                                \
  47                                                                         \
  48         return 0;                                                       \
  49 }
  50
  51 #define sdw_dpn_attr(field)                                             \
  52                                                                         \
  53 static ssize_t field##_dpn_show(struct sdw_slave *slave,                \
  54                                 int N,                                  \
  55                                 int dir,                                \
  56                                 const char *format_string,              \
  57                                 char *buf)                              \
  58 {                                                                       \
  59         struct sdw_dpn_prop *dpn;                                       \
  60         unsigned long mask;                                             \
  61         int bit;                                                        \
  62         int i;                                                          \
  63                                                                         \
  64         if (dir) {                                                      \
  65                 dpn = slave->prop.src_dpn_prop;                         \
  66                 mask = slave->prop.source_ports;                        \
  67         } else {                                                        \
  68                 dpn = slave->prop.sink_dpn_prop;                        \
  69                 mask = slave->prop.sink_ports;                          \
  70         }                                                               \
  71                                                                         \
  72         i = 0;                                                          \
  73         for_each_set_bit(bit, &mask, 32) {                              \
  74                 if (bit == N) {                                         \
  75                         return sprintf(buf, format_string,              \
  76                                        dpn[i].field);                   \
  77                 }                                                       \
  78                 i++;                                                    \
  79         }                                                               \
  80         return -EINVAL;                                                 \
  81 }                                                                       \
  82                                                                         \
  83 static ssize_t field##_show(struct device *dev,                         \
  84                             struct device_attribute *attr,              \
  85                             char *buf)                                  \
  86 {                                                                       \
  87         struct sdw_slave *slave = dev_to_sdw_dev(dev);                  \
  88         struct dpn_attribute *dpn_attr =                                \
  89                 container_of(attr, struct dpn_attribute, dev_attr);     \
  90                                                                         \
  91         return field##_dpn_show(slave,                                  \
  92                                 dpn_attr->N, dpn_attr->dir,             \
  93                                 dpn_attr->format_string,                \
  94                                 buf);                                   \
  95 }                                                                       \
  96 sdw_dpn_attribute_alloc(field)
  97
  98 sdw_dpn_attr(imp_def_interrupts);
  99 sdw_dpn_attr(max_word);
 100 sdw_dpn_attr(min_word);
 101 sdw_dpn_attr(type);
 102 sdw_dpn_attr(max_grouping);
 103 sdw_dpn_attr(simple_ch_prep_sm);
 104 sdw_dpn_attr(ch_prep_timeout);
 105 sdw_dpn_attr(max_ch);
 106 sdw_dpn_attr(min_ch);
 107 sdw_dpn_attr(max_async_buffer);
 108 sdw_dpn_attr(block_pack_mode);
 109 sdw_dpn_attr(port_encoding);
 110
 111 #define sdw_dpn_array_attr(field)                                       \
 112                                                                         \
 113 static ssize_t field##_dpn_show(struct sdw_slave *slave,                \
 114                                 int N,                                  \
 115                                 int dir,                                \
 116                                 const char *format_string,              \
 117                                 char *buf)                              \
 118 {                                                                       \
 119         struct sdw_dpn_prop *dpn;                                       \
 120         unsigned long mask;                                             \
 121         ssize_t size = 0;                                               \
 122         int bit;                                                        \
 123         int i;                                                          \
 124         int j;                                                          \
 125                                                                         \
 126         if (dir) {                                                      \
 127                 dpn = slave->prop.src_dpn_prop;                         \
 128                 mask = slave->prop.source_ports;                        \
 129         } else {                                                        \
 130                 dpn = slave->prop.sink_dpn_prop;                        \
 131                 mask = slave->prop.sink_ports;                          \
 132         }                                                               \
 133                                                                         \
 134         i = 0;                                                          \
 135         for_each_set_bit(bit, &mask, 32) {                              \
 136                 if (bit == N) {                                         \
 137                         for (j = 0; j < dpn[i].num_##field; j++)        \
 138                                 size += sprintf(buf + size,             \
 139                                                 format_string,          \
 140                                                 dpn[i].field[j]);       \
 141                         size += sprintf(buf + size, "\n");              \
 142                         return size;                                    \
 143                 }                                                       \
 144                 i++;                                                    \
 145         }                                                               \
 146         return -EINVAL;                                                 \
 147 }                                                                       \
 148 static ssize_t field##_show(struct device *dev,                         \
 149                             struct device_attribute *attr,              \
 150                             char *buf)                                  \
 151 {                                                                       \
 152         struct sdw_slave *slave = dev_to_sdw_dev(dev);                  \
 153         struct dpn_attribute *dpn_attr =                                \
 154                 container_of(attr, struct dpn_attribute, dev_attr);     \
 155                                                                         \
 156         return field##_dpn_show(slave,                                  \
 157                                 dpn_attr->N, dpn_attr->dir,             \
 158                                 dpn_attr->format_string,                \
 159                                 buf);                                   \
 160 }                                                                       \
 161 sdw_dpn_attribute_alloc(field)
 162
 163 sdw_dpn_array_attr(words);
 164 sdw_dpn_array_attr(ch_combinations);
 165 sdw_dpn_array_attr(channels);
 166
 167 static int add_all_attributes(struct device *dev, int N, int dir)
 168 {
 169         struct attribute **dpn_attrs;
 170         struct attribute_group *dpn_group;
 171         int i = 0;
 172         int ret;
 173
 174         /* allocate attributes, last one is NULL */
 175         dpn_attrs = devm_kcalloc(dev, SDW_DPN_ATTRIBUTES + 1,
 176                                  sizeof(struct attribute *),
 177                                  GFP_KERNEL);
 178         if (!dpn_attrs)
 179                 return -ENOMEM;
 180
 181         ret = max_word_attribute_alloc(dev, &dpn_attrs[i++],
 182                                        N, dir, "%d\n");
 183         if (ret < 0)
 184                 return ret;
 185
 186         ret = min_word_attribute_alloc(dev, &dpn_attrs[i++],
 187                                        N, dir, "%d\n");
 188         if (ret < 0)
 189                 return ret;
 190
 191         ret = words_attribute_alloc(dev, &dpn_attrs[i++],
 192                                     N, dir, "%d\n");
 193         if (ret < 0)
 194                 return ret;
 195
 196         ret = type_attribute_alloc(dev, &dpn_attrs[i++],
 197                                    N, dir, "%d\n");
 198         if (ret < 0)
 199                 return ret;
 200
 201         ret = max_grouping_attribute_alloc(dev, &dpn_attrs[i++],
 202                                            N, dir, "%d\n");
 203         if (ret < 0)
 204                 return ret;
 205
 206         ret = simple_ch_prep_sm_attribute_alloc(dev, &dpn_attrs[i++],
 207                                                 N, dir, "%d\n");
 208         if (ret < 0)
 209                 return ret;
 210
 211         ret = ch_prep_timeout_attribute_alloc(dev, &dpn_attrs[i++],
 212                                               N, dir, "%d\n");
 213         if (ret < 0)
 214                 return ret;
 215
 216         ret = imp_def_interrupts_attribute_alloc(dev, &dpn_attrs[i++],
 217                                                  N, dir, "0x%x\n");
 218         if (ret < 0)
 219                 return ret;
 220
 221         ret = min_ch_attribute_alloc(dev, &dpn_attrs[i++],
 222                                      N, dir, "%d\n");
 223         if (ret < 0)
 224                 return ret;
 225
 226         ret = max_ch_attribute_alloc(dev, &dpn_attrs[i++],
 227                                      N, dir, "%d\n");
 228         if (ret < 0)
 229                 return ret;
 230
 231         ret = channels_attribute_alloc(dev, &dpn_attrs[i++],
 232                                        N, dir, "%d\n");
 233         if (ret < 0)
 234                 return ret;
 235
 236         ret = ch_combinations_attribute_alloc(dev, &dpn_attrs[i++],
 237                                               N, dir, "%d\n");
 238         if (ret < 0)
 239                 return ret;
 240
 241         ret = max_async_buffer_attribute_alloc(dev, &dpn_attrs[i++],
 242                                                N, dir, "%d\n");
 243         if (ret < 0)
 244                 return ret;
 245
 246         ret = block_pack_mode_attribute_alloc(dev, &dpn_attrs[i++],
 247                                               N, dir, "%d\n");
 248         if (ret < 0)
 249                 return ret;
 250
 251         ret = port_encoding_attribute_alloc(dev, &dpn_attrs[i++],
 252                                             N, dir, "%d\n");
 253         if (ret < 0)
 254                 return ret;
 255
 256         /* paranoia check for editing mistakes */
 257         if (i != SDW_DPN_ATTRIBUTES) {
 258                 dev_err(dev, "mismatch in attributes, allocated %d got %d\n",
 259                         SDW_DPN_ATTRIBUTES, i);
 260                 return -EINVAL;
 261         }
 262
 263         dpn_group = devm_kzalloc(dev, sizeof(*dpn_group), GFP_KERNEL);
 264         if (!dpn_group)
 265                 return -ENOMEM;
 266
 267         dpn_group->attrs = dpn_attrs;
 268         dpn_group->name = devm_kasprintf(dev, GFP_KERNEL, "dp%d_%s",
 269                                          N, dir ? "src" : "sink");
 270         if (!dpn_group->name)
 271                 return -ENOMEM;
 272
 273         ret = devm_device_add_group(dev, dpn_group);
 274         if (ret < 0)
 275                 return ret;
 276
 277         return 0;
 278 }
 279
 280 int sdw_slave_sysfs_dpn_init(struct sdw_slave *slave)
 281 {
 282         unsigned long mask;
 283         int ret;
 284         int i;
 285
 286         mask = slave->prop.source_ports;
 287         for_each_set_bit(i, &mask, 32) {
 288                 ret = add_all_attributes(&slave->dev, i, 1);
 289                 if (ret < 0)
 290                         return ret;
 291         }
 292
 293         mask = slave->prop.sink_ports;
 294         for_each_set_bit(i, &mask, 32) {
 295                 ret = add_all_attributes(&slave->dev, i, 0);
 296                 if (ret < 0)
 297                         return ret;
 298         }
 299
 300         return 0;
 301 }