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 } 302