| 1 | |
| 2 | |
| 3 | * Generic Counter sysfs interface
|
| 4 | * Copyright (C) 2020 William Breathitt Gray
|
| 5 |
|
| 6 | #include <linux/counter.h>
|
| 7 | #include <linux/device.h>
|
| 8 | #include <linux/err.h>
|
| 9 | #include <linux/gfp.h>
|
| 10 | #include <linux/kernel.h>
|
| 11 | #include <linux/kfifo.h>
|
| 12 | #include <linux/kstrtox.h>
|
| 13 | #include <linux/list.h>
|
| 14 | #include <linux/mutex.h>
|
| 15 | #include <linux/spinlock.h>
|
| 16 | #include <linux/string.h>
|
| 17 | #include <linux/sysfs.h>
|
| 18 | #include <linux/types.h>
|
| 19 |
|
| 20 | #include "counter-sysfs.h"
|
| 21 |
|
| 22 | static inline struct counter_device *counter_from_dev(struct device *dev)
|
| 23 | {
|
| 24 | return container_of(dev, struct counter_device, dev);
|
| 25 | }
|
| 26 |
|
| 27 | |
| 28 | * struct counter_attribute - Counter sysfs attribute
|
| 29 | * @dev_attr: device attribute for sysfs
|
| 30 | * @l: node to add Counter attribute to attribute group list
|
| 31 | * @comp: Counter component callbacks and data
|
| 32 | * @scope: Counter scope of the attribute
|
| 33 | * @parent: pointer to the parent component
|
| 34 |
|
| 35 | struct counter_attribute {
|
| 36 | struct device_attribute dev_attr;
|
| 37 | struct list_head l;
|
| 38 |
|
| 39 | struct counter_comp comp;
|
| 40 | enum counter_scope scope;
|
| 41 | void *parent;
|
| 42 | };
|
| 43 |
|
| 44 | #define to_counter_attribute(_dev_attr) \
|
| 45 | container_of(_dev_attr, struct counter_attribute, dev_attr)
|
| 46 |
|
| 47 | |
| 48 | * struct counter_attribute_group - container for attribute group
|
| 49 | * @name: name of the attribute group
|
| 50 | * @attr_list: list to keep track of created attributes
|
| 51 | * @num_attr: number of attributes
|
| 52 |
|
| 53 | struct counter_attribute_group {
|
| 54 | const char *name;
|
| 55 | struct list_head attr_list;
|
| 56 | size_t num_attr;
|
| 57 | };
|
| 58 |
|
| 59 | static const char *const counter_function_str[] = {
|
| 60 | [COUNTER_FUNCTION_INCREASE] = "increase",
|
| 61 | [COUNTER_FUNCTION_DECREASE] = "decrease",
|
| 62 | [COUNTER_FUNCTION_PULSE_DIRECTION] = "pulse-direction",
|
| 63 | [COUNTER_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",
|
| 64 | [COUNTER_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",
|
| 65 | [COUNTER_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",
|
| 66 | [COUNTER_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",
|
| 67 | [COUNTER_FUNCTION_QUADRATURE_X4] = "quadrature x4"
|
| 68 | };
|
| 69 |
|
| 70 | static const char *const counter_signal_value_str[] = {
|
| 71 | [COUNTER_SIGNAL_LEVEL_LOW] = "low",
|
| 72 | [COUNTER_SIGNAL_LEVEL_HIGH] = "high"
|
| 73 | };
|
| 74 |
|
| 75 | static const char *const counter_synapse_action_str[] = {
|
| 76 | [COUNTER_SYNAPSE_ACTION_NONE] = "none",
|
| 77 | [COUNTER_SYNAPSE_ACTION_RISING_EDGE] = "rising edge",
|
| 78 | [COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = "falling edge",
|
| 79 | [COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = "both edges"
|
| 80 | };
|
| 81 |
|
| 82 | static const char *const counter_count_direction_str[] = {
|
| 83 | [COUNTER_COUNT_DIRECTION_FORWARD] = "forward",
|
| 84 | [COUNTER_COUNT_DIRECTION_BACKWARD] = "backward"
|
| 85 | };
|
| 86 |
|
| 87 | static const char *const counter_count_mode_str[] = {
|
| 88 | [COUNTER_COUNT_MODE_NORMAL] = "normal",
|
| 89 | [COUNTER_COUNT_MODE_RANGE_LIMIT] = "range limit",
|
| 90 | [COUNTER_COUNT_MODE_NON_RECYCLE] = "non-recycle",
|
| 91 | [COUNTER_COUNT_MODE_MODULO_N] = "modulo-n",
|
| 92 | [COUNTER_COUNT_MODE_INTERRUPT_ON_TERMINAL_COUNT] = "interrupt on terminal count",
|
| 93 | [COUNTER_COUNT_MODE_HARDWARE_RETRIGGERABLE_ONESHOT] = "hardware retriggerable one-shot",
|
| 94 | [COUNTER_COUNT_MODE_RATE_GENERATOR] = "rate generator",
|
| 95 | [COUNTER_COUNT_MODE_SQUARE_WAVE_MODE] = "square wave mode",
|
| 96 | [COUNTER_COUNT_MODE_SOFTWARE_TRIGGERED_STROBE] = "software triggered strobe",
|
| 97 | [COUNTER_COUNT_MODE_HARDWARE_TRIGGERED_STROBE] = "hardware triggered strobe",
|
| 98 | };
|
| 99 |
|
| 100 | static const char *const counter_signal_polarity_str[] = {
|
| 101 | [COUNTER_SIGNAL_POLARITY_POSITIVE] = "positive",
|
| 102 | [COUNTER_SIGNAL_POLARITY_NEGATIVE] = "negative"
|
| 103 | };
|
| 104 |
|
| 105 | static ssize_t counter_comp_u8_show(struct device *dev,
|
| 106 | struct device_attribute *attr, char *buf)
|
| 107 | {
|
| 108 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 109 | struct counter_device *const counter = counter_from_dev(dev);
|
| 110 | int err;
|
| 111 | u8 data = 0;
|
| 112 |
|
| 113 | switch (a->scope) {
|
| 114 | case COUNTER_SCOPE_DEVICE:
|
| 115 | err = a->comp.device_u8_read(counter, &data);
|
| 116 | break;
|
| 117 | case COUNTER_SCOPE_SIGNAL:
|
| 118 | err = a->comp.signal_u8_read(counter, a->parent, &data);
|
| 119 | break;
|
| 120 | case COUNTER_SCOPE_COUNT:
|
| 121 | err = a->comp.count_u8_read(counter, a->parent, &data);
|
| 122 | break;
|
| 123 | default:
|
| 124 | return -EINVAL;
|
| 125 | }
|
| 126 | if (err < 0)
|
| 127 | return err;
|
| 128 |
|
| 129 | if (a->comp.type == COUNTER_COMP_BOOL)
|
| 130 |
|
| 131 | data = !!data;
|
| 132 |
|
| 133 | return sysfs_emit(buf, "%u\n", (unsigned int)data);
|
| 134 | }
|
| 135 |
|
| 136 | static ssize_t counter_comp_u8_store(struct device *dev,
|
| 137 | struct device_attribute *attr,
|
| 138 | const char *buf, size_t len)
|
| 139 | {
|
| 140 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 141 | struct counter_device *const counter = counter_from_dev(dev);
|
| 142 | int err;
|
| 143 | bool bool_data = 0;
|
| 144 | u8 data = 0;
|
| 145 |
|
| 146 | if (a->comp.type == COUNTER_COMP_BOOL) {
|
| 147 | err = kstrtobool(buf, &bool_data);
|
| 148 | data = bool_data;
|
| 149 | } else
|
| 150 | err = kstrtou8(buf, 0, &data);
|
| 151 | if (err < 0)
|
| 152 | return err;
|
| 153 |
|
| 154 | switch (a->scope) {
|
| 155 | case COUNTER_SCOPE_DEVICE:
|
| 156 | err = a->comp.device_u8_write(counter, data);
|
| 157 | break;
|
| 158 | case COUNTER_SCOPE_SIGNAL:
|
| 159 | err = a->comp.signal_u8_write(counter, a->parent, data);
|
| 160 | break;
|
| 161 | case COUNTER_SCOPE_COUNT:
|
| 162 | err = a->comp.count_u8_write(counter, a->parent, data);
|
| 163 | break;
|
| 164 | default:
|
| 165 | return -EINVAL;
|
| 166 | }
|
| 167 | if (err < 0)
|
| 168 | return err;
|
| 169 |
|
| 170 | return len;
|
| 171 | }
|
| 172 |
|
| 173 | static ssize_t counter_comp_u32_show(struct device *dev,
|
| 174 | struct device_attribute *attr, char *buf)
|
| 175 | {
|
| 176 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 177 | struct counter_device *const counter = counter_from_dev(dev);
|
| 178 | const struct counter_available *const avail = a->comp.priv;
|
| 179 | int err;
|
| 180 | u32 data = 0;
|
| 181 |
|
| 182 | switch (a->scope) {
|
| 183 | case COUNTER_SCOPE_DEVICE:
|
| 184 | err = a->comp.device_u32_read(counter, &data);
|
| 185 | break;
|
| 186 | case COUNTER_SCOPE_SIGNAL:
|
| 187 | err = a->comp.signal_u32_read(counter, a->parent, &data);
|
| 188 | break;
|
| 189 | case COUNTER_SCOPE_COUNT:
|
| 190 | if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
|
| 191 | err = a->comp.action_read(counter, a->parent,
|
| 192 | a->comp.priv, &data);
|
| 193 | else
|
| 194 | err = a->comp.count_u32_read(counter, a->parent, &data);
|
| 195 | break;
|
| 196 | default:
|
| 197 | return -EINVAL;
|
| 198 | }
|
| 199 | if (err < 0)
|
| 200 | return err;
|
| 201 |
|
| 202 | switch (a->comp.type) {
|
| 203 | case COUNTER_COMP_FUNCTION:
|
| 204 | return sysfs_emit(buf, "%s\n", counter_function_str[data]);
|
| 205 | case COUNTER_COMP_SIGNAL_LEVEL:
|
| 206 | return sysfs_emit(buf, "%s\n", counter_signal_value_str[data]);
|
| 207 | case COUNTER_COMP_SYNAPSE_ACTION:
|
| 208 | return sysfs_emit(buf, "%s\n", counter_synapse_action_str[data]);
|
| 209 | case COUNTER_COMP_ENUM:
|
| 210 | return sysfs_emit(buf, "%s\n", avail->strs[data]);
|
| 211 | case COUNTER_COMP_COUNT_DIRECTION:
|
| 212 | return sysfs_emit(buf, "%s\n", counter_count_direction_str[data]);
|
| 213 | case COUNTER_COMP_COUNT_MODE:
|
| 214 | return sysfs_emit(buf, "%s\n", counter_count_mode_str[data]);
|
| 215 | case COUNTER_COMP_SIGNAL_POLARITY:
|
| 216 | return sysfs_emit(buf, "%s\n", counter_signal_polarity_str[data]);
|
| 217 | default:
|
| 218 | return sysfs_emit(buf, "%u\n", (unsigned int)data);
|
| 219 | }
|
| 220 | }
|
| 221 |
|
| 222 | static int counter_find_enum(u32 *const enum_item, const u32 *const enums,
|
| 223 | const size_t num_enums, const char *const buf,
|
| 224 | const char *const string_array[])
|
| 225 | {
|
| 226 | size_t index;
|
| 227 |
|
| 228 | for (index = 0; index < num_enums; index++) {
|
| 229 | *enum_item = enums[index];
|
| 230 | if (sysfs_streq(buf, string_array[*enum_item]))
|
| 231 | return 0;
|
| 232 | }
|
| 233 |
|
| 234 | return -EINVAL;
|
| 235 | }
|
| 236 |
|
| 237 | static ssize_t counter_comp_u32_store(struct device *dev,
|
| 238 | struct device_attribute *attr,
|
| 239 | const char *buf, size_t len)
|
| 240 | {
|
| 241 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 242 | struct counter_device *const counter = counter_from_dev(dev);
|
| 243 | struct counter_count *const count = a->parent;
|
| 244 | struct counter_synapse *const synapse = a->comp.priv;
|
| 245 | const struct counter_available *const avail = a->comp.priv;
|
| 246 | int err;
|
| 247 | u32 data = 0;
|
| 248 |
|
| 249 | switch (a->comp.type) {
|
| 250 | case COUNTER_COMP_FUNCTION:
|
| 251 | err = counter_find_enum(&data, count->functions_list,
|
| 252 | count->num_functions, buf,
|
| 253 | counter_function_str);
|
| 254 | break;
|
| 255 | case COUNTER_COMP_SYNAPSE_ACTION:
|
| 256 | err = counter_find_enum(&data, synapse->actions_list,
|
| 257 | synapse->num_actions, buf,
|
| 258 | counter_synapse_action_str);
|
| 259 | break;
|
| 260 | case COUNTER_COMP_ENUM:
|
| 261 | err = __sysfs_match_string(avail->strs, avail->num_items, buf);
|
| 262 | data = err;
|
| 263 | break;
|
| 264 | case COUNTER_COMP_COUNT_MODE:
|
| 265 | err = counter_find_enum(&data, avail->enums, avail->num_items,
|
| 266 | buf, counter_count_mode_str);
|
| 267 | break;
|
| 268 | case COUNTER_COMP_SIGNAL_POLARITY:
|
| 269 | err = counter_find_enum(&data, avail->enums, avail->num_items,
|
| 270 | buf, counter_signal_polarity_str);
|
| 271 | break;
|
| 272 | default:
|
| 273 | err = kstrtou32(buf, 0, &data);
|
| 274 | break;
|
| 275 | }
|
| 276 | if (err < 0)
|
| 277 | return err;
|
| 278 |
|
| 279 | switch (a->scope) {
|
| 280 | case COUNTER_SCOPE_DEVICE:
|
| 281 | err = a->comp.device_u32_write(counter, data);
|
| 282 | break;
|
| 283 | case COUNTER_SCOPE_SIGNAL:
|
| 284 | err = a->comp.signal_u32_write(counter, a->parent, data);
|
| 285 | break;
|
| 286 | case COUNTER_SCOPE_COUNT:
|
| 287 | if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
|
| 288 | err = a->comp.action_write(counter, count, synapse,
|
| 289 | data);
|
| 290 | else
|
| 291 | err = a->comp.count_u32_write(counter, count, data);
|
| 292 | break;
|
| 293 | default:
|
| 294 | return -EINVAL;
|
| 295 | }
|
| 296 | if (err < 0)
|
| 297 | return err;
|
| 298 |
|
| 299 | return len;
|
| 300 | }
|
| 301 |
|
| 302 | static ssize_t counter_comp_u64_show(struct device *dev,
|
| 303 | struct device_attribute *attr, char *buf)
|
| 304 | {
|
| 305 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 306 | struct counter_device *const counter = counter_from_dev(dev);
|
| 307 | int err;
|
| 308 | u64 data = 0;
|
| 309 |
|
| 310 | switch (a->scope) {
|
| 311 | case COUNTER_SCOPE_DEVICE:
|
| 312 | err = a->comp.device_u64_read(counter, &data);
|
| 313 | break;
|
| 314 | case COUNTER_SCOPE_SIGNAL:
|
| 315 | err = a->comp.signal_u64_read(counter, a->parent, &data);
|
| 316 | break;
|
| 317 | case COUNTER_SCOPE_COUNT:
|
| 318 | err = a->comp.count_u64_read(counter, a->parent, &data);
|
| 319 | break;
|
| 320 | default:
|
| 321 | return -EINVAL;
|
| 322 | }
|
| 323 | if (err < 0)
|
| 324 | return err;
|
| 325 |
|
| 326 | return sysfs_emit(buf, "%llu\n", (unsigned long long)data);
|
| 327 | }
|
| 328 |
|
| 329 | static ssize_t counter_comp_u64_store(struct device *dev,
|
| 330 | struct device_attribute *attr,
|
| 331 | const char *buf, size_t len)
|
| 332 | {
|
| 333 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 334 | struct counter_device *const counter = counter_from_dev(dev);
|
| 335 | int err;
|
| 336 | u64 data = 0;
|
| 337 |
|
| 338 | err = kstrtou64(buf, 0, &data);
|
| 339 | if (err < 0)
|
| 340 | return err;
|
| 341 |
|
| 342 | switch (a->scope) {
|
| 343 | case COUNTER_SCOPE_DEVICE:
|
| 344 | err = a->comp.device_u64_write(counter, data);
|
| 345 | break;
|
| 346 | case COUNTER_SCOPE_SIGNAL:
|
| 347 | err = a->comp.signal_u64_write(counter, a->parent, data);
|
| 348 | break;
|
| 349 | case COUNTER_SCOPE_COUNT:
|
| 350 | err = a->comp.count_u64_write(counter, a->parent, data);
|
| 351 | break;
|
| 352 | default:
|
| 353 | return -EINVAL;
|
| 354 | }
|
| 355 | if (err < 0)
|
| 356 | return err;
|
| 357 |
|
| 358 | return len;
|
| 359 | }
|
| 360 |
|
| 361 | static ssize_t counter_comp_array_u32_show(struct device *dev,
|
| 362 | struct device_attribute *attr,
|
| 363 | char *buf)
|
| 364 | {
|
| 365 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 366 | struct counter_device *const counter = counter_from_dev(dev);
|
| 367 | const struct counter_array *const element = a->comp.priv;
|
| 368 | int err;
|
| 369 | u32 data = 0;
|
| 370 |
|
| 371 | if (a->scope != COUNTER_SCOPE_SIGNAL ||
|
| 372 | element->type != COUNTER_COMP_SIGNAL_POLARITY)
|
| 373 | return -EINVAL;
|
| 374 |
|
| 375 | err = a->comp.signal_array_u32_read(counter, a->parent, element->idx,
|
| 376 | &data);
|
| 377 | if (err < 0)
|
| 378 | return err;
|
| 379 |
|
| 380 | return sysfs_emit(buf, "%s\n", counter_signal_polarity_str[data]);
|
| 381 | }
|
| 382 |
|
| 383 | static ssize_t counter_comp_array_u32_store(struct device *dev,
|
| 384 | struct device_attribute *attr,
|
| 385 | const char *buf, size_t len)
|
| 386 | {
|
| 387 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 388 | struct counter_device *const counter = counter_from_dev(dev);
|
| 389 | const struct counter_array *const element = a->comp.priv;
|
| 390 | int err;
|
| 391 | u32 data = 0;
|
| 392 |
|
| 393 | if (element->type != COUNTER_COMP_SIGNAL_POLARITY ||
|
| 394 | a->scope != COUNTER_SCOPE_SIGNAL)
|
| 395 | return -EINVAL;
|
| 396 |
|
| 397 | err = counter_find_enum(&data, element->avail->enums,
|
| 398 | element->avail->num_items, buf,
|
| 399 | counter_signal_polarity_str);
|
| 400 | if (err < 0)
|
| 401 | return err;
|
| 402 |
|
| 403 | err = a->comp.signal_array_u32_write(counter, a->parent, element->idx,
|
| 404 | data);
|
| 405 | if (err < 0)
|
| 406 | return err;
|
| 407 |
|
| 408 | return len;
|
| 409 | }
|
| 410 |
|
| 411 | static ssize_t counter_comp_array_u64_show(struct device *dev,
|
| 412 | struct device_attribute *attr,
|
| 413 | char *buf)
|
| 414 | {
|
| 415 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 416 | struct counter_device *const counter = counter_from_dev(dev);
|
| 417 | const struct counter_array *const element = a->comp.priv;
|
| 418 | int err;
|
| 419 | u64 data = 0;
|
| 420 |
|
| 421 | switch (a->scope) {
|
| 422 | case COUNTER_SCOPE_DEVICE:
|
| 423 | err = a->comp.device_array_u64_read(counter, element->idx,
|
| 424 | &data);
|
| 425 | break;
|
| 426 | case COUNTER_SCOPE_SIGNAL:
|
| 427 | err = a->comp.signal_array_u64_read(counter, a->parent,
|
| 428 | element->idx, &data);
|
| 429 | break;
|
| 430 | case COUNTER_SCOPE_COUNT:
|
| 431 | err = a->comp.count_array_u64_read(counter, a->parent,
|
| 432 | element->idx, &data);
|
| 433 | break;
|
| 434 | default:
|
| 435 | return -EINVAL;
|
| 436 | }
|
| 437 | if (err < 0)
|
| 438 | return err;
|
| 439 |
|
| 440 | return sysfs_emit(buf, "%llu\n", (unsigned long long)data);
|
| 441 | }
|
| 442 |
|
| 443 | static ssize_t counter_comp_array_u64_store(struct device *dev,
|
| 444 | struct device_attribute *attr,
|
| 445 | const char *buf, size_t len)
|
| 446 | {
|
| 447 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 448 | struct counter_device *const counter = counter_from_dev(dev);
|
| 449 | const struct counter_array *const element = a->comp.priv;
|
| 450 | int err;
|
| 451 | u64 data = 0;
|
| 452 |
|
| 453 | err = kstrtou64(buf, 0, &data);
|
| 454 | if (err < 0)
|
| 455 | return err;
|
| 456 |
|
| 457 | switch (a->scope) {
|
| 458 | case COUNTER_SCOPE_DEVICE:
|
| 459 | err = a->comp.device_array_u64_write(counter, element->idx,
|
| 460 | data);
|
| 461 | break;
|
| 462 | case COUNTER_SCOPE_SIGNAL:
|
| 463 | err = a->comp.signal_array_u64_write(counter, a->parent,
|
| 464 | element->idx, data);
|
| 465 | break;
|
| 466 | case COUNTER_SCOPE_COUNT:
|
| 467 | err = a->comp.count_array_u64_write(counter, a->parent,
|
| 468 | element->idx, data);
|
| 469 | break;
|
| 470 | default:
|
| 471 | return -EINVAL;
|
| 472 | }
|
| 473 | if (err < 0)
|
| 474 | return err;
|
| 475 |
|
| 476 | return len;
|
| 477 | }
|
| 478 |
|
| 479 | static ssize_t enums_available_show(const u32 *const enums,
|
| 480 | const size_t num_enums,
|
| 481 | const char *const strs[], char *buf)
|
| 482 | {
|
| 483 | size_t len = 0;
|
| 484 | size_t index;
|
| 485 |
|
| 486 | for (index = 0; index < num_enums; index++)
|
| 487 | len += sysfs_emit_at(buf, len, "%s\n", strs[enums[index]]);
|
| 488 |
|
| 489 | return len;
|
| 490 | }
|
| 491 |
|
| 492 | static ssize_t strs_available_show(const struct counter_available *const avail,
|
| 493 | char *buf)
|
| 494 | {
|
| 495 | size_t len = 0;
|
| 496 | size_t index;
|
| 497 |
|
| 498 | for (index = 0; index < avail->num_items; index++)
|
| 499 | len += sysfs_emit_at(buf, len, "%s\n", avail->strs[index]);
|
| 500 |
|
| 501 | return len;
|
| 502 | }
|
| 503 |
|
| 504 | static ssize_t counter_comp_available_show(struct device *dev,
|
| 505 | struct device_attribute *attr,
|
| 506 | char *buf)
|
| 507 | {
|
| 508 | const struct counter_attribute *const a = to_counter_attribute(attr);
|
| 509 | const struct counter_count *const count = a->parent;
|
| 510 | const struct counter_synapse *const synapse = a->comp.priv;
|
| 511 | const struct counter_available *const avail = a->comp.priv;
|
| 512 |
|
| 513 | switch (a->comp.type) {
|
| 514 | case COUNTER_COMP_FUNCTION:
|
| 515 | return enums_available_show(count->functions_list,
|
| 516 | count->num_functions,
|
| 517 | counter_function_str, buf);
|
| 518 | case COUNTER_COMP_SYNAPSE_ACTION:
|
| 519 | return enums_available_show(synapse->actions_list,
|
| 520 | synapse->num_actions,
|
| 521 | counter_synapse_action_str, buf);
|
| 522 | case COUNTER_COMP_ENUM:
|
| 523 | return strs_available_show(avail, buf);
|
| 524 | case COUNTER_COMP_COUNT_MODE:
|
| 525 | return enums_available_show(avail->enums, avail->num_items,
|
| 526 | counter_count_mode_str, buf);
|
| 527 | default:
|
| 528 | return -EINVAL;
|
| 529 | }
|
| 530 | }
|
| 531 |
|
| 532 | static int counter_avail_attr_create(struct device *const dev,
|
| 533 | struct counter_attribute_group *const group,
|
| 534 | const struct counter_comp *const comp, void *const parent)
|
| 535 | {
|
| 536 | struct counter_attribute *counter_attr;
|
| 537 | struct device_attribute *dev_attr;
|
| 538 |
|
| 539 | counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
|
| 540 | if (!counter_attr)
|
| 541 | return -ENOMEM;
|
| 542 |
|
| 543 |
|
| 544 | counter_attr->comp.type = comp->type;
|
| 545 | counter_attr->comp.priv = comp->priv;
|
| 546 | counter_attr->parent = parent;
|
| 547 |
|
| 548 |
|
| 549 | dev_attr = &counter_attr->dev_attr;
|
| 550 | sysfs_attr_init(&dev_attr->attr);
|
| 551 |
|
| 552 |
|
| 553 | dev_attr->attr.name = devm_kasprintf(dev, GFP_KERNEL, "%s_available",
|
| 554 | comp->name);
|
| 555 | if (!dev_attr->attr.name)
|
| 556 | return -ENOMEM;
|
| 557 | dev_attr->attr.mode = 0444;
|
| 558 | dev_attr->show = counter_comp_available_show;
|
| 559 |
|
| 560 |
|
| 561 | list_add(&counter_attr->l, &group->attr_list);
|
| 562 | group->num_attr++;
|
| 563 |
|
| 564 | return 0;
|
| 565 | }
|
| 566 |
|
| 567 | static int counter_attr_create(struct device *const dev,
|
| 568 | struct counter_attribute_group *const group,
|
| 569 | const struct counter_comp *const comp,
|
| 570 | const enum counter_scope scope,
|
| 571 | void *const parent)
|
| 572 | {
|
| 573 | const struct counter_array *const array = comp->priv;
|
| 574 | struct counter_attribute *counter_attr;
|
| 575 | struct device_attribute *dev_attr;
|
| 576 |
|
| 577 | counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
|
| 578 | if (!counter_attr)
|
| 579 | return -ENOMEM;
|
| 580 |
|
| 581 |
|
| 582 | counter_attr->comp = *comp;
|
| 583 | counter_attr->scope = scope;
|
| 584 | counter_attr->parent = parent;
|
| 585 |
|
| 586 |
|
| 587 | dev_attr = &counter_attr->dev_attr;
|
| 588 | sysfs_attr_init(&dev_attr->attr);
|
| 589 | dev_attr->attr.name = comp->name;
|
| 590 | switch (comp->type) {
|
| 591 | case COUNTER_COMP_U8:
|
| 592 | case COUNTER_COMP_BOOL:
|
| 593 | if (comp->device_u8_read) {
|
| 594 | dev_attr->attr.mode |= 0444;
|
| 595 | dev_attr->show = counter_comp_u8_show;
|
| 596 | }
|
| 597 | if (comp->device_u8_write) {
|
| 598 | dev_attr->attr.mode |= 0200;
|
| 599 | dev_attr->store = counter_comp_u8_store;
|
| 600 | }
|
| 601 | break;
|
| 602 | case COUNTER_COMP_SIGNAL_LEVEL:
|
| 603 | case COUNTER_COMP_FUNCTION:
|
| 604 | case COUNTER_COMP_SYNAPSE_ACTION:
|
| 605 | case COUNTER_COMP_ENUM:
|
| 606 | case COUNTER_COMP_COUNT_DIRECTION:
|
| 607 | case COUNTER_COMP_COUNT_MODE:
|
| 608 | case COUNTER_COMP_SIGNAL_POLARITY:
|
| 609 | if (comp->device_u32_read) {
|
| 610 | dev_attr->attr.mode |= 0444;
|
| 611 | dev_attr->show = counter_comp_u32_show;
|
| 612 | }
|
| 613 | if (comp->device_u32_write) {
|
| 614 | dev_attr->attr.mode |= 0200;
|
| 615 | dev_attr->store = counter_comp_u32_store;
|
| 616 | }
|
| 617 | break;
|
| 618 | case COUNTER_COMP_U64:
|
| 619 | if (comp->device_u64_read) {
|
| 620 | dev_attr->attr.mode |= 0444;
|
| 621 | dev_attr->show = counter_comp_u64_show;
|
| 622 | }
|
| 623 | if (comp->device_u64_write) {
|
| 624 | dev_attr->attr.mode |= 0200;
|
| 625 | dev_attr->store = counter_comp_u64_store;
|
| 626 | }
|
| 627 | break;
|
| 628 | case COUNTER_COMP_ARRAY:
|
| 629 | switch (array->type) {
|
| 630 | case COUNTER_COMP_SIGNAL_POLARITY:
|
| 631 | if (comp->signal_array_u32_read) {
|
| 632 | dev_attr->attr.mode |= 0444;
|
| 633 | dev_attr->show = counter_comp_array_u32_show;
|
| 634 | }
|
| 635 | if (comp->signal_array_u32_write) {
|
| 636 | dev_attr->attr.mode |= 0200;
|
| 637 | dev_attr->store = counter_comp_array_u32_store;
|
| 638 | }
|
| 639 | break;
|
| 640 | case COUNTER_COMP_U64:
|
| 641 | if (comp->device_array_u64_read) {
|
| 642 | dev_attr->attr.mode |= 0444;
|
| 643 | dev_attr->show = counter_comp_array_u64_show;
|
| 644 | }
|
| 645 | if (comp->device_array_u64_write) {
|
| 646 | dev_attr->attr.mode |= 0200;
|
| 647 | dev_attr->store = counter_comp_array_u64_store;
|
| 648 | }
|
| 649 | break;
|
| 650 | default:
|
| 651 | return -EINVAL;
|
| 652 | }
|
| 653 | break;
|
| 654 | default:
|
| 655 | return -EINVAL;
|
| 656 | }
|
| 657 |
|
| 658 |
|
| 659 | list_add(&counter_attr->l, &group->attr_list);
|
| 660 | group->num_attr++;
|
| 661 |
|
| 662 |
|
| 663 | switch (comp->type) {
|
| 664 | case COUNTER_COMP_FUNCTION:
|
| 665 | case COUNTER_COMP_SYNAPSE_ACTION:
|
| 666 | case COUNTER_COMP_ENUM:
|
| 667 | case COUNTER_COMP_COUNT_MODE:
|
| 668 | return counter_avail_attr_create(dev, group, comp, parent);
|
| 669 | default:
|
| 670 | return 0;
|
| 671 | }
|
| 672 | }
|
| 673 |
|
| 674 | static ssize_t counter_comp_name_show(struct device *dev,
|
| 675 | struct device_attribute *attr, char *buf)
|
| 676 | {
|
| 677 | return sysfs_emit(buf, "%s\n", to_counter_attribute(attr)->comp.name);
|
| 678 | }
|
| 679 |
|
| 680 | static int counter_name_attr_create(struct device *const dev,
|
| 681 | struct counter_attribute_group *const group,
|
| 682 | const char *const name)
|
| 683 | {
|
| 684 | struct counter_attribute *counter_attr;
|
| 685 |
|
| 686 | counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
|
| 687 | if (!counter_attr)
|
| 688 | return -ENOMEM;
|
| 689 |
|
| 690 |
|
| 691 | counter_attr->comp.name = name;
|
| 692 |
|
| 693 |
|
| 694 | sysfs_attr_init(&counter_attr->dev_attr.attr);
|
| 695 | counter_attr->dev_attr.attr.name = "name";
|
| 696 | counter_attr->dev_attr.attr.mode = 0444;
|
| 697 | counter_attr->dev_attr.show = counter_comp_name_show;
|
| 698 |
|
| 699 |
|
| 700 | list_add(&counter_attr->l, &group->attr_list);
|
| 701 | group->num_attr++;
|
| 702 |
|
| 703 | return 0;
|
| 704 | }
|
| 705 |
|
| 706 | static ssize_t counter_comp_id_show(struct device *dev,
|
| 707 | struct device_attribute *attr, char *buf)
|
| 708 | {
|
| 709 | const size_t id = (size_t)to_counter_attribute(attr)->comp.priv;
|
| 710 |
|
| 711 | return sysfs_emit(buf, "%zu\n", id);
|
| 712 | }
|
| 713 |
|
| 714 | static int counter_comp_id_attr_create(struct device *const dev,
|
| 715 | struct counter_attribute_group *const group,
|
| 716 | const char *name, const size_t id)
|
| 717 | {
|
| 718 | struct counter_attribute *counter_attr;
|
| 719 |
|
| 720 |
|
| 721 | counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
|
| 722 | if (!counter_attr)
|
| 723 | return -ENOMEM;
|
| 724 |
|
| 725 |
|
| 726 | name = devm_kasprintf(dev, GFP_KERNEL, "%s_component_id", name);
|
| 727 | if (!name)
|
| 728 | return -ENOMEM;
|
| 729 |
|
| 730 |
|
| 731 | counter_attr->comp.priv = (void *)id;
|
| 732 |
|
| 733 |
|
| 734 | sysfs_attr_init(&counter_attr->dev_attr.attr);
|
| 735 | counter_attr->dev_attr.attr.name = name;
|
| 736 | counter_attr->dev_attr.attr.mode = 0444;
|
| 737 | counter_attr->dev_attr.show = counter_comp_id_show;
|
| 738 |
|
| 739 |
|
| 740 | list_add(&counter_attr->l, &group->attr_list);
|
| 741 | group->num_attr++;
|
| 742 |
|
| 743 | return 0;
|
| 744 | }
|
| 745 |
|
| 746 | static int counter_ext_attrs_create(struct device *const dev,
|
| 747 | struct counter_attribute_group *const group,
|
| 748 | const struct counter_comp *const ext,
|
| 749 | const enum counter_scope scope,
|
| 750 | void *const parent, const size_t id)
|
| 751 | {
|
| 752 | int err;
|
| 753 |
|
| 754 |
|
| 755 | err = counter_attr_create(dev, group, ext, scope, parent);
|
| 756 | if (err < 0)
|
| 757 | return err;
|
| 758 |
|
| 759 |
|
| 760 | return counter_comp_id_attr_create(dev, group, ext->name, id);
|
| 761 | }
|
| 762 |
|
| 763 | static int counter_array_attrs_create(struct device *const dev,
|
| 764 | struct counter_attribute_group *const group,
|
| 765 | const struct counter_comp *const comp,
|
| 766 | const enum counter_scope scope,
|
| 767 | void *const parent, const size_t id)
|
| 768 | {
|
| 769 | const struct counter_array *const array = comp->priv;
|
| 770 | struct counter_comp ext = *comp;
|
| 771 | struct counter_array *element;
|
| 772 | size_t idx;
|
| 773 | int err;
|
| 774 |
|
| 775 |
|
| 776 | for (idx = 0; idx < array->length; idx++) {
|
| 777 |
|
| 778 | ext.name = devm_kasprintf(dev, GFP_KERNEL, "%s%zu", comp->name,
|
| 779 | idx);
|
| 780 | if (!ext.name)
|
| 781 | return -ENOMEM;
|
| 782 |
|
| 783 |
|
| 784 | element = devm_kzalloc(dev, sizeof(*element), GFP_KERNEL);
|
| 785 | if (!element)
|
| 786 | return -ENOMEM;
|
| 787 | element->type = array->type;
|
| 788 | element->avail = array->avail;
|
| 789 | element->idx = idx;
|
| 790 | ext.priv = element;
|
| 791 |
|
| 792 |
|
| 793 | err = counter_ext_attrs_create(dev, group, &ext, scope, parent,
|
| 794 | id + idx);
|
| 795 | if (err < 0)
|
| 796 | return err;
|
| 797 | }
|
| 798 |
|
| 799 | return 0;
|
| 800 | }
|
| 801 |
|
| 802 | static int counter_sysfs_exts_add(struct device *const dev,
|
| 803 | struct counter_attribute_group *const group,
|
| 804 | const struct counter_comp *const exts,
|
| 805 | const size_t num_ext,
|
| 806 | const enum counter_scope scope,
|
| 807 | void *const parent)
|
| 808 | {
|
| 809 | size_t i;
|
| 810 | const struct counter_comp *ext;
|
| 811 | int err;
|
| 812 | size_t id = 0;
|
| 813 | const struct counter_array *array;
|
| 814 |
|
| 815 |
|
| 816 | for (i = 0; i < num_ext; i++) {
|
| 817 | ext = &exts[i];
|
| 818 | if (ext->type == COUNTER_COMP_ARRAY) {
|
| 819 | err = counter_array_attrs_create(dev, group, ext, scope,
|
| 820 | parent, id);
|
| 821 | array = ext->priv;
|
| 822 | id += array->length;
|
| 823 | } else {
|
| 824 | err = counter_ext_attrs_create(dev, group, ext, scope,
|
| 825 | parent, id);
|
| 826 | id++;
|
| 827 | }
|
| 828 | if (err < 0)
|
| 829 | return err;
|
| 830 | }
|
| 831 |
|
| 832 | return 0;
|
| 833 | }
|
| 834 |
|
| 835 | static struct counter_comp counter_signal_comp = {
|
| 836 | .type = COUNTER_COMP_SIGNAL_LEVEL,
|
| 837 | .name = "signal",
|
| 838 | };
|
| 839 |
|
| 840 | static int counter_signal_attrs_create(struct counter_device *const counter,
|
| 841 | struct counter_attribute_group *const cattr_group,
|
| 842 | struct counter_signal *const signal)
|
| 843 | {
|
| 844 | const enum counter_scope scope = COUNTER_SCOPE_SIGNAL;
|
| 845 | struct device *const dev = &counter->dev;
|
| 846 | int err;
|
| 847 | struct counter_comp comp;
|
| 848 |
|
| 849 |
|
| 850 | comp = counter_signal_comp;
|
| 851 | comp.signal_u32_read = counter->ops->signal_read;
|
| 852 | err = counter_attr_create(dev, cattr_group, &comp, scope, signal);
|
| 853 | if (err < 0)
|
| 854 | return err;
|
| 855 |
|
| 856 |
|
| 857 | err = counter_name_attr_create(dev, cattr_group, signal->name);
|
| 858 | if (err < 0)
|
| 859 | return err;
|
| 860 |
|
| 861 |
|
| 862 | return counter_sysfs_exts_add(dev, cattr_group, signal->ext,
|
| 863 | signal->num_ext, scope, signal);
|
| 864 | }
|
| 865 |
|
| 866 | static int counter_sysfs_signals_add(struct counter_device *const counter,
|
| 867 | struct counter_attribute_group *const groups)
|
| 868 | {
|
| 869 | size_t i;
|
| 870 | int err;
|
| 871 |
|
| 872 |
|
| 873 | for (i = 0; i < counter->num_signals; i++) {
|
| 874 |
|
| 875 | groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL,
|
| 876 | "signal%zu", i);
|
| 877 | if (!groups[i].name)
|
| 878 | return -ENOMEM;
|
| 879 |
|
| 880 |
|
| 881 | err = counter_signal_attrs_create(counter, groups + i,
|
| 882 | counter->signals + i);
|
| 883 | if (err < 0)
|
| 884 | return err;
|
| 885 | }
|
| 886 |
|
| 887 | return 0;
|
| 888 | }
|
| 889 |
|
| 890 | static int counter_sysfs_synapses_add(struct counter_device *const counter,
|
| 891 | struct counter_attribute_group *const group,
|
| 892 | struct counter_count *const count)
|
| 893 | {
|
| 894 | size_t i;
|
| 895 |
|
| 896 |
|
| 897 | for (i = 0; i < count->num_synapses; i++) {
|
| 898 | struct device *const dev = &counter->dev;
|
| 899 | struct counter_synapse *synapse;
|
| 900 | size_t id;
|
| 901 | struct counter_comp comp;
|
| 902 | int err;
|
| 903 |
|
| 904 | synapse = count->synapses + i;
|
| 905 |
|
| 906 |
|
| 907 | id = synapse->signal - counter->signals;
|
| 908 | comp.name = devm_kasprintf(dev, GFP_KERNEL, "signal%zu_action",
|
| 909 | id);
|
| 910 | if (!comp.name)
|
| 911 | return -ENOMEM;
|
| 912 |
|
| 913 |
|
| 914 | comp.type = COUNTER_COMP_SYNAPSE_ACTION;
|
| 915 | comp.action_read = counter->ops->action_read;
|
| 916 | comp.action_write = counter->ops->action_write;
|
| 917 | comp.priv = synapse;
|
| 918 | err = counter_attr_create(dev, group, &comp,
|
| 919 | COUNTER_SCOPE_COUNT, count);
|
| 920 | if (err < 0)
|
| 921 | return err;
|
| 922 |
|
| 923 |
|
| 924 | err = counter_comp_id_attr_create(dev, group, comp.name, i);
|
| 925 | if (err < 0)
|
| 926 | return err;
|
| 927 | }
|
| 928 |
|
| 929 | return 0;
|
| 930 | }
|
| 931 |
|
| 932 | static struct counter_comp counter_count_comp =
|
| 933 | COUNTER_COMP_COUNT_U64("count", NULL, NULL);
|
| 934 |
|
| 935 | static struct counter_comp counter_function_comp = {
|
| 936 | .type = COUNTER_COMP_FUNCTION,
|
| 937 | .name = "function",
|
| 938 | };
|
| 939 |
|
| 940 | static int counter_count_attrs_create(struct counter_device *const counter,
|
| 941 | struct counter_attribute_group *const cattr_group,
|
| 942 | struct counter_count *const count)
|
| 943 | {
|
| 944 | const enum counter_scope scope = COUNTER_SCOPE_COUNT;
|
| 945 | struct device *const dev = &counter->dev;
|
| 946 | int err;
|
| 947 | struct counter_comp comp;
|
| 948 |
|
| 949 |
|
| 950 | comp = counter_count_comp;
|
| 951 | comp.count_u64_read = counter->ops->count_read;
|
| 952 | comp.count_u64_write = counter->ops->count_write;
|
| 953 | err = counter_attr_create(dev, cattr_group, &comp, scope, count);
|
| 954 | if (err < 0)
|
| 955 | return err;
|
| 956 |
|
| 957 |
|
| 958 | err = counter_name_attr_create(dev, cattr_group, count->name);
|
| 959 | if (err < 0)
|
| 960 | return err;
|
| 961 |
|
| 962 |
|
| 963 | comp = counter_function_comp;
|
| 964 | comp.count_u32_read = counter->ops->function_read;
|
| 965 | comp.count_u32_write = counter->ops->function_write;
|
| 966 | err = counter_attr_create(dev, cattr_group, &comp, scope, count);
|
| 967 | if (err < 0)
|
| 968 | return err;
|
| 969 |
|
| 970 |
|
| 971 | return counter_sysfs_exts_add(dev, cattr_group, count->ext,
|
| 972 | count->num_ext, scope, count);
|
| 973 | }
|
| 974 |
|
| 975 | static int counter_sysfs_counts_add(struct counter_device *const counter,
|
| 976 | struct counter_attribute_group *const groups)
|
| 977 | {
|
| 978 | size_t i;
|
| 979 | struct counter_count *count;
|
| 980 | int err;
|
| 981 |
|
| 982 |
|
| 983 | for (i = 0; i < counter->num_counts; i++) {
|
| 984 | count = counter->counts + i;
|
| 985 |
|
| 986 |
|
| 987 | groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL,
|
| 988 | "count%zu", i);
|
| 989 | if (!groups[i].name)
|
| 990 | return -ENOMEM;
|
| 991 |
|
| 992 |
|
| 993 | err = counter_sysfs_synapses_add(counter, groups + i, count);
|
| 994 | if (err < 0)
|
| 995 | return err;
|
| 996 |
|
| 997 |
|
| 998 | err = counter_count_attrs_create(counter, groups + i, count);
|
| 999 | if (err < 0)
|
| 1000 | return err;
|
| 1001 | }
|
| 1002 |
|
| 1003 | return 0;
|
| 1004 | }
|
| 1005 |
|
| 1006 | static int counter_num_signals_read(struct counter_device *counter, u8 *val)
|
| 1007 | {
|
| 1008 | *val = counter->num_signals;
|
| 1009 | return 0;
|
| 1010 | }
|
| 1011 |
|
| 1012 | static int counter_num_counts_read(struct counter_device *counter, u8 *val)
|
| 1013 | {
|
| 1014 | *val = counter->num_counts;
|
| 1015 | return 0;
|
| 1016 | }
|
| 1017 |
|
| 1018 | static int counter_events_queue_size_read(struct counter_device *counter,
|
| 1019 | u64 *val)
|
| 1020 | {
|
| 1021 | *val = kfifo_size(&counter->events);
|
| 1022 | return 0;
|
| 1023 | }
|
| 1024 |
|
| 1025 | static int counter_events_queue_size_write(struct counter_device *counter,
|
| 1026 | u64 val)
|
| 1027 | {
|
| 1028 | DECLARE_KFIFO_PTR(events, struct counter_event);
|
| 1029 | int err;
|
| 1030 | unsigned long flags;
|
| 1031 |
|
| 1032 |
|
| 1033 | err = kfifo_alloc(&events, val, GFP_KERNEL);
|
| 1034 | if (err)
|
| 1035 | return err;
|
| 1036 |
|
| 1037 |
|
| 1038 | mutex_lock(&counter->events_out_lock);
|
| 1039 | spin_lock_irqsave(&counter->events_in_lock, flags);
|
| 1040 | kfifo_free(&counter->events);
|
| 1041 | counter->events.kfifo = events.kfifo;
|
| 1042 | spin_unlock_irqrestore(&counter->events_in_lock, flags);
|
| 1043 | mutex_unlock(&counter->events_out_lock);
|
| 1044 |
|
| 1045 | return 0;
|
| 1046 | }
|
| 1047 |
|
| 1048 | static struct counter_comp counter_num_signals_comp =
|
| 1049 | COUNTER_COMP_DEVICE_U8("num_signals", counter_num_signals_read, NULL);
|
| 1050 |
|
| 1051 | static struct counter_comp counter_num_counts_comp =
|
| 1052 | COUNTER_COMP_DEVICE_U8("num_counts", counter_num_counts_read, NULL);
|
| 1053 |
|
| 1054 | static struct counter_comp counter_events_queue_size_comp =
|
| 1055 | COUNTER_COMP_DEVICE_U64("events_queue_size",
|
| 1056 | counter_events_queue_size_read,
|
| 1057 | counter_events_queue_size_write);
|
| 1058 |
|
| 1059 | static int counter_sysfs_attr_add(struct counter_device *const counter,
|
| 1060 | struct counter_attribute_group *cattr_group)
|
| 1061 | {
|
| 1062 | const enum counter_scope scope = COUNTER_SCOPE_DEVICE;
|
| 1063 | struct device *const dev = &counter->dev;
|
| 1064 | int err;
|
| 1065 |
|
| 1066 |
|
| 1067 | err = counter_sysfs_signals_add(counter, cattr_group);
|
| 1068 | if (err < 0)
|
| 1069 | return err;
|
| 1070 | cattr_group += counter->num_signals;
|
| 1071 |
|
| 1072 |
|
| 1073 | err = counter_sysfs_counts_add(counter, cattr_group);
|
| 1074 | if (err < 0)
|
| 1075 | return err;
|
| 1076 | cattr_group += counter->num_counts;
|
| 1077 |
|
| 1078 |
|
| 1079 | err = counter_name_attr_create(dev, cattr_group, counter->name);
|
| 1080 | if (err < 0)
|
| 1081 | return err;
|
| 1082 |
|
| 1083 |
|
| 1084 | err = counter_attr_create(dev, cattr_group, &counter_num_signals_comp,
|
| 1085 | scope, NULL);
|
| 1086 | if (err < 0)
|
| 1087 | return err;
|
| 1088 |
|
| 1089 |
|
| 1090 | err = counter_attr_create(dev, cattr_group, &counter_num_counts_comp,
|
| 1091 | scope, NULL);
|
| 1092 | if (err < 0)
|
| 1093 | return err;
|
| 1094 |
|
| 1095 |
|
| 1096 | err = counter_attr_create(dev, cattr_group,
|
| 1097 | &counter_events_queue_size_comp, scope, NULL);
|
| 1098 | if (err < 0)
|
| 1099 | return err;
|
| 1100 |
|
| 1101 |
|
| 1102 | return counter_sysfs_exts_add(dev, cattr_group, counter->ext,
|
| 1103 | counter->num_ext, scope, NULL);
|
| 1104 | }
|
| 1105 |
|
| 1106 | |
| 1107 | * counter_sysfs_add - Adds Counter sysfs attributes to the device structure
|
| 1108 | * @counter: Pointer to the Counter device structure
|
| 1109 | *
|
| 1110 | * Counter sysfs attributes are created and added to the respective device
|
| 1111 | * structure for later registration to the system. Resource-managed memory
|
| 1112 | * allocation is performed by this function, and this memory should be freed
|
| 1113 | * when no longer needed (automatically by a device_unregister call, or
|
| 1114 | * manually by a devres_release_all call).
|
| 1115 |
|
| 1116 | int counter_sysfs_add(struct counter_device *const counter)
|
| 1117 | {
|
| 1118 | struct device *const dev = &counter->dev;
|
| 1119 | const size_t num_groups = counter->num_signals + counter->num_counts + 1;
|
| 1120 | struct counter_attribute_group *cattr_groups;
|
| 1121 | size_t i, j;
|
| 1122 | int err;
|
| 1123 | struct attribute_group *groups;
|
| 1124 | struct counter_attribute *p;
|
| 1125 |
|
| 1126 |
|
| 1127 | cattr_groups = devm_kcalloc(dev, num_groups, sizeof(*cattr_groups),
|
| 1128 | GFP_KERNEL);
|
| 1129 | if (!cattr_groups)
|
| 1130 | return -ENOMEM;
|
| 1131 |
|
| 1132 |
|
| 1133 | for (i = 0; i < num_groups; i++)
|
| 1134 | INIT_LIST_HEAD(&cattr_groups[i].attr_list);
|
| 1135 |
|
| 1136 |
|
| 1137 | err = counter_sysfs_attr_add(counter, cattr_groups);
|
| 1138 | if (err < 0)
|
| 1139 | return err;
|
| 1140 |
|
| 1141 |
|
| 1142 | dev->groups = devm_kcalloc(dev, num_groups + 1, sizeof(*dev->groups),
|
| 1143 | GFP_KERNEL);
|
| 1144 | if (!dev->groups)
|
| 1145 | return -ENOMEM;
|
| 1146 |
|
| 1147 |
|
| 1148 | groups = devm_kcalloc(dev, num_groups, sizeof(*groups), GFP_KERNEL);
|
| 1149 | if (!groups)
|
| 1150 | return -ENOMEM;
|
| 1151 |
|
| 1152 |
|
| 1153 | for (i = 0; i < num_groups; i++) {
|
| 1154 | groups[i].name = cattr_groups[i].name;
|
| 1155 |
|
| 1156 |
|
| 1157 | groups[i].attrs = devm_kcalloc(dev,
|
| 1158 | cattr_groups[i].num_attr + 1,
|
| 1159 | sizeof(*groups[i].attrs),
|
| 1160 | GFP_KERNEL);
|
| 1161 | if (!groups[i].attrs)
|
| 1162 | return -ENOMEM;
|
| 1163 |
|
| 1164 |
|
| 1165 | j = 0;
|
| 1166 | list_for_each_entry(p, &cattr_groups[i].attr_list, l)
|
| 1167 | groups[i].attrs[j++] = &p->dev_attr.attr;
|
| 1168 |
|
| 1169 |
|
| 1170 | dev->groups[i] = &groups[i];
|
| 1171 | }
|
| 1172 |
|
| 1173 | return 0;
|
| 1174 | }
|