1// SPDX-License-Identifier: GPL-2.0 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 22static 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 */ 35struct 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 */ 53struct counter_attribute_group { 54 const char *name; 55 struct list_head attr_list; 56 size_t num_attr; 57}; 58 59static 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 70static const char *const counter_signal_value_str[] = { 71 [COUNTER_SIGNAL_LEVEL_LOW] = "low", 72 [COUNTER_SIGNAL_LEVEL_HIGH] = "high" 73}; 74 75static 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 82static const char *const counter_count_direction_str[] = { 83 [COUNTER_COUNT_DIRECTION_FORWARD] = "forward", 84 [COUNTER_COUNT_DIRECTION_BACKWARD] = "backward" 85}; 86 87static 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 100static const char *const counter_signal_polarity_str[] = { 101 [COUNTER_SIGNAL_POLARITY_POSITIVE] = "positive", 102 [COUNTER_SIGNAL_POLARITY_NEGATIVE] = "negative" 103}; 104 105static 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 /* data should already be boolean but ensure just to be safe */ 131 data = !!data; 132 133 return sysfs_emit(buf, "%u\n", (unsigned int)data); 134} 135 136static 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 173static 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 222static 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 237static 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 302static 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 329static 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 361static 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 383static 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 411static 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 443static 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 479static 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 492static 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 504static 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 532static 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 /* Configure Counter attribute */ 544 counter_attr->comp.type = comp->type; 545 counter_attr->comp.priv = comp->priv; 546 counter_attr->parent = parent; 547 548 /* Initialize sysfs attribute */ 549 dev_attr = &counter_attr->dev_attr; 550 sysfs_attr_init(&dev_attr->attr); 551 552 /* Configure device attribute */ 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 /* Store list node */ 561 list_add(&counter_attr->l, &group->attr_list); 562 group->num_attr++; 563 564 return 0; 565} 566 567static 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 /* Configure Counter attribute */ 582 counter_attr->comp = *comp; 583 counter_attr->scope = scope; 584 counter_attr->parent = parent; 585 586 /* Configure device attribute */ 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 /* Store list node */ 659 list_add(&counter_attr->l, &group->attr_list); 660 group->num_attr++; 661 662 /* Create "*_available" attribute if needed */ 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 674static 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 680static 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 /* Configure Counter attribute */ 691 counter_attr->comp.name = name; 692 693 /* Configure device attribute */ 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 /* Store list node */ 700 list_add(&counter_attr->l, &group->attr_list); 701 group->num_attr++; 702 703 return 0; 704} 705 706static 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 714static 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 /* Allocate Counter attribute */ 721 counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL); 722 if (!counter_attr) 723 return -ENOMEM; 724 725 /* Generate component ID name */ 726 name = devm_kasprintf(dev, GFP_KERNEL, "%s_component_id", name); 727 if (!name) 728 return -ENOMEM; 729 730 /* Configure Counter attribute */ 731 counter_attr->comp.priv = (void *)id; 732 733 /* Configure device attribute */ 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 /* Store list node */ 740 list_add(&counter_attr->l, &group->attr_list); 741 group->num_attr++; 742 743 return 0; 744} 745 746static 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 /* Create main extension attribute */ 755 err = counter_attr_create(dev, group, ext, scope, parent); 756 if (err < 0) 757 return err; 758 759 /* Create extension id attribute */ 760 return counter_comp_id_attr_create(dev, group, ext->name, id); 761} 762 763static 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 /* Create an attribute for each array element */ 776 for (idx = 0; idx < array->length; idx++) { 777 /* Generate array element attribute name */ 778 ext.name = devm_kasprintf(dev, GFP_KERNEL, "%s%zu", comp->name, 779 idx); 780 if (!ext.name) 781 return -ENOMEM; 782 783 /* Allocate and configure array element */ 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 /* Create all attributes associated with the array element */ 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 802static 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 /* Create attributes for each extension */ 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 835static struct counter_comp counter_signal_comp = { 836 .type = COUNTER_COMP_SIGNAL_LEVEL, 837 .name = "signal", 838}; 839 840static 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 /* Create main Signal attribute */ 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 /* Create Signal name attribute */ 857 err = counter_name_attr_create(dev, cattr_group, signal->name); 858 if (err < 0) 859 return err; 860 861 /* Add Signal extensions */ 862 return counter_sysfs_exts_add(dev, cattr_group, signal->ext, 863 signal->num_ext, scope, signal); 864} 865 866static 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 /* Add each Signal */ 873 for (i = 0; i < counter->num_signals; i++) { 874 /* Generate Signal attribute directory name */ 875 groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL, 876 "signal%zu", i); 877 if (!groups[i].name) 878 return -ENOMEM; 879 880 /* Create all attributes associated with Signal */ 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 890static 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 /* Add each Synapse */ 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 /* Generate Synapse action name */ 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 /* Create action attribute */ 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 /* Create Synapse component ID attribute */ 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 932static struct counter_comp counter_count_comp = 933 COUNTER_COMP_COUNT_U64("count", NULL, NULL); 934 935static struct counter_comp counter_function_comp = { 936 .type = COUNTER_COMP_FUNCTION, 937 .name = "function", 938}; 939 940static 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 /* Create main Count attribute */ 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 /* Create Count name attribute */ 958 err = counter_name_attr_create(dev, cattr_group, count->name); 959 if (err < 0) 960 return err; 961 962 /* Create Count function attribute */ 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 /* Add Count extensions */ 971 return counter_sysfs_exts_add(dev, cattr_group, count->ext, 972 count->num_ext, scope, count); 973} 974 975static 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 /* Add each Count */ 983 for (i = 0; i < counter->num_counts; i++) { 984 count = counter->counts + i; 985 986 /* Generate Count attribute directory name */ 987 groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL, 988 "count%zu", i); 989 if (!groups[i].name) 990 return -ENOMEM; 991 992 /* Add sysfs attributes of the Synapses */ 993 err = counter_sysfs_synapses_add(counter, groups + i, count); 994 if (err < 0) 995 return err; 996 997 /* Create all attributes associated with Count */ 998 err = counter_count_attrs_create(counter, groups + i, count); 999 if (err < 0) 1000 return err; 1001 } 1002 1003 return 0; 1004} 1005 1006static int counter_num_signals_read(struct counter_device *counter, u8 *val) 1007{ 1008 *val = counter->num_signals; 1009 return 0; 1010} 1011 1012static int counter_num_counts_read(struct counter_device *counter, u8 *val) 1013{ 1014 *val = counter->num_counts; 1015 return 0; 1016} 1017 1018static 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 1025static 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 /* Allocate new events queue */ 1033 err = kfifo_alloc(&events, val, GFP_KERNEL); 1034 if (err) 1035 return err; 1036 1037 /* Swap in new events queue */ 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 1048static struct counter_comp counter_num_signals_comp = 1049 COUNTER_COMP_DEVICE_U8("num_signals", counter_num_signals_read, NULL); 1050 1051static struct counter_comp counter_num_counts_comp = 1052 COUNTER_COMP_DEVICE_U8("num_counts", counter_num_counts_read, NULL); 1053 1054static 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 1059static 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 /* Add Signals sysfs attributes */ 1067 err = counter_sysfs_signals_add(counter, cattr_group); 1068 if (err < 0) 1069 return err; 1070 cattr_group += counter->num_signals; 1071 1072 /* Add Counts sysfs attributes */ 1073 err = counter_sysfs_counts_add(counter, cattr_group); 1074 if (err < 0) 1075 return err; 1076 cattr_group += counter->num_counts; 1077 1078 /* Create name attribute */ 1079 err = counter_name_attr_create(dev, cattr_group, counter->name); 1080 if (err < 0) 1081 return err; 1082 1083 /* Create num_signals attribute */ 1084 err = counter_attr_create(dev, cattr_group, &counter_num_signals_comp, 1085 scope, NULL); 1086 if (err < 0) 1087 return err; 1088 1089 /* Create num_counts attribute */ 1090 err = counter_attr_create(dev, cattr_group, &counter_num_counts_comp, 1091 scope, NULL); 1092 if (err < 0) 1093 return err; 1094 1095 /* Create events_queue_size attribute */ 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 /* Add device extensions */ 1102 return counter_sysfs_exts_add(dev, cattr_group, counter->ext, 1103 counter->num_ext, scope, NULL); 1104 1105 return 0; 1106} 1107 1108/** 1109 * counter_sysfs_add - Adds Counter sysfs attributes to the device structure 1110 * @counter: Pointer to the Counter device structure 1111 * 1112 * Counter sysfs attributes are created and added to the respective device 1113 * structure for later registration to the system. Resource-managed memory 1114 * allocation is performed by this function, and this memory should be freed 1115 * when no longer needed (automatically by a device_unregister call, or 1116 * manually by a devres_release_all call). 1117 */ 1118int counter_sysfs_add(struct counter_device *const counter) 1119{ 1120 struct device *const dev = &counter->dev; 1121 const size_t num_groups = counter->num_signals + counter->num_counts + 1; 1122 struct counter_attribute_group *cattr_groups; 1123 size_t i, j; 1124 int err; 1125 struct attribute_group *groups; 1126 struct counter_attribute *p; 1127 1128 /* Allocate space for attribute groups (signals, counts, and ext) */ 1129 cattr_groups = devm_kcalloc(dev, num_groups, sizeof(*cattr_groups), 1130 GFP_KERNEL); 1131 if (!cattr_groups) 1132 return -ENOMEM; 1133 1134 /* Initialize attribute lists */ 1135 for (i = 0; i < num_groups; i++) 1136 INIT_LIST_HEAD(&cattr_groups[i].attr_list); 1137 1138 /* Add Counter device sysfs attributes */ 1139 err = counter_sysfs_attr_add(counter, cattr_groups); 1140 if (err < 0) 1141 return err; 1142 1143 /* Allocate attribute group pointers for association with device */ 1144 dev->groups = devm_kcalloc(dev, num_groups + 1, sizeof(*dev->groups), 1145 GFP_KERNEL); 1146 if (!dev->groups) 1147 return -ENOMEM; 1148 1149 /* Allocate space for attribute groups */ 1150 groups = devm_kcalloc(dev, num_groups, sizeof(*groups), GFP_KERNEL); 1151 if (!groups) 1152 return -ENOMEM; 1153 1154 /* Prepare each group of attributes for association */ 1155 for (i = 0; i < num_groups; i++) { 1156 groups[i].name = cattr_groups[i].name; 1157 1158 /* Allocate space for attribute pointers */ 1159 groups[i].attrs = devm_kcalloc(dev, 1160 cattr_groups[i].num_attr + 1, 1161 sizeof(*groups[i].attrs), 1162 GFP_KERNEL); 1163 if (!groups[i].attrs) 1164 return -ENOMEM; 1165 1166 /* Add attribute pointers to attribute group */ 1167 j = 0; 1168 list_for_each_entry(p, &cattr_groups[i].attr_list, l) 1169 groups[i].attrs[j++] = &p->dev_attr.attr; 1170 1171 /* Associate attribute group */ 1172 dev->groups[i] = &groups[i]; 1173 } 1174 1175 return 0; 1176} 1177