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 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 }; 93 94 static ssize_t counter_comp_u8_show(struct device *dev, 95 struct device_attribute *attr, char *buf) 96 { 97 const struct counter_attribute *const a = to_counter_attribute(attr); 98 struct counter_device *const counter = counter_from_dev(dev); 99 int err; 100 u8 data = 0; 101 102 switch (a->scope) { 103 case COUNTER_SCOPE_DEVICE: 104 err = a->comp.device_u8_read(counter, &data); 105 break; 106 case COUNTER_SCOPE_SIGNAL: 107 err = a->comp.signal_u8_read(counter, a->parent, &data); 108 break; 109 case COUNTER_SCOPE_COUNT: 110 err = a->comp.count_u8_read(counter, a->parent, &data); 111 break; 112 default: 113 return -EINVAL; 114 } 115 if (err < 0) 116 return err; 117 118 if (a->comp.type == COUNTER_COMP_BOOL) 119 /* data should already be boolean but ensure just to be safe */ 120 data = !!data; 121 122 return sysfs_emit(buf, "%u\n", (unsigned int)data); 123 } 124 125 static ssize_t counter_comp_u8_store(struct device *dev, 126 struct device_attribute *attr, 127 const char *buf, size_t len) 128 { 129 const struct counter_attribute *const a = to_counter_attribute(attr); 130 struct counter_device *const counter = counter_from_dev(dev); 131 int err; 132 bool bool_data = 0; 133 u8 data = 0; 134 135 if (a->comp.type == COUNTER_COMP_BOOL) { 136 err = kstrtobool(buf, &bool_data); 137 data = bool_data; 138 } else 139 err = kstrtou8(buf, 0, &data); 140 if (err < 0) 141 return err; 142 143 switch (a->scope) { 144 case COUNTER_SCOPE_DEVICE: 145 err = a->comp.device_u8_write(counter, data); 146 break; 147 case COUNTER_SCOPE_SIGNAL: 148 err = a->comp.signal_u8_write(counter, a->parent, data); 149 break; 150 case COUNTER_SCOPE_COUNT: 151 err = a->comp.count_u8_write(counter, a->parent, data); 152 break; 153 default: 154 return -EINVAL; 155 } 156 if (err < 0) 157 return err; 158 159 return len; 160 } 161 162 static ssize_t counter_comp_u32_show(struct device *dev, 163 struct device_attribute *attr, char *buf) 164 { 165 const struct counter_attribute *const a = to_counter_attribute(attr); 166 struct counter_device *const counter = counter_from_dev(dev); 167 const struct counter_available *const avail = a->comp.priv; 168 int err; 169 u32 data = 0; 170 171 switch (a->scope) { 172 case COUNTER_SCOPE_DEVICE: 173 err = a->comp.device_u32_read(counter, &data); 174 break; 175 case COUNTER_SCOPE_SIGNAL: 176 err = a->comp.signal_u32_read(counter, a->parent, &data); 177 break; 178 case COUNTER_SCOPE_COUNT: 179 if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION) 180 err = a->comp.action_read(counter, a->parent, 181 a->comp.priv, &data); 182 else 183 err = a->comp.count_u32_read(counter, a->parent, &data); 184 break; 185 default: 186 return -EINVAL; 187 } 188 if (err < 0) 189 return err; 190 191 switch (a->comp.type) { 192 case COUNTER_COMP_FUNCTION: 193 return sysfs_emit(buf, "%s\n", counter_function_str[data]); 194 case COUNTER_COMP_SIGNAL_LEVEL: 195 return sysfs_emit(buf, "%s\n", counter_signal_value_str[data]); 196 case COUNTER_COMP_SYNAPSE_ACTION: 197 return sysfs_emit(buf, "%s\n", counter_synapse_action_str[data]); 198 case COUNTER_COMP_ENUM: 199 return sysfs_emit(buf, "%s\n", avail->strs[data]); 200 case COUNTER_COMP_COUNT_DIRECTION: 201 return sysfs_emit(buf, "%s\n", counter_count_direction_str[data]); 202 case COUNTER_COMP_COUNT_MODE: 203 return sysfs_emit(buf, "%s\n", counter_count_mode_str[data]); 204 default: 205 return sysfs_emit(buf, "%u\n", (unsigned int)data); 206 } 207 } 208 209 static int counter_find_enum(u32 *const enum_item, const u32 *const enums, 210 const size_t num_enums, const char *const buf, 211 const char *const string_array[]) 212 { 213 size_t index; 214 215 for (index = 0; index < num_enums; index++) { 216 *enum_item = enums[index]; 217 if (sysfs_streq(buf, string_array[*enum_item])) 218 return 0; 219 } 220 221 return -EINVAL; 222 } 223 224 static ssize_t counter_comp_u32_store(struct device *dev, 225 struct device_attribute *attr, 226 const char *buf, size_t len) 227 { 228 const struct counter_attribute *const a = to_counter_attribute(attr); 229 struct counter_device *const counter = counter_from_dev(dev); 230 struct counter_count *const count = a->parent; 231 struct counter_synapse *const synapse = a->comp.priv; 232 const struct counter_available *const avail = a->comp.priv; 233 int err; 234 u32 data = 0; 235 236 switch (a->comp.type) { 237 case COUNTER_COMP_FUNCTION: 238 err = counter_find_enum(&data, count->functions_list, 239 count->num_functions, buf, 240 counter_function_str); 241 break; 242 case COUNTER_COMP_SYNAPSE_ACTION: 243 err = counter_find_enum(&data, synapse->actions_list, 244 synapse->num_actions, buf, 245 counter_synapse_action_str); 246 break; 247 case COUNTER_COMP_ENUM: 248 err = __sysfs_match_string(avail->strs, avail->num_items, buf); 249 data = err; 250 break; 251 case COUNTER_COMP_COUNT_MODE: 252 err = counter_find_enum(&data, avail->enums, avail->num_items, 253 buf, counter_count_mode_str); 254 break; 255 default: 256 err = kstrtou32(buf, 0, &data); 257 break; 258 } 259 if (err < 0) 260 return err; 261 262 switch (a->scope) { 263 case COUNTER_SCOPE_DEVICE: 264 err = a->comp.device_u32_write(counter, data); 265 break; 266 case COUNTER_SCOPE_SIGNAL: 267 err = a->comp.signal_u32_write(counter, a->parent, data); 268 break; 269 case COUNTER_SCOPE_COUNT: 270 if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION) 271 err = a->comp.action_write(counter, count, synapse, 272 data); 273 else 274 err = a->comp.count_u32_write(counter, count, data); 275 break; 276 default: 277 return -EINVAL; 278 } 279 if (err < 0) 280 return err; 281 282 return len; 283 } 284 285 static ssize_t counter_comp_u64_show(struct device *dev, 286 struct device_attribute *attr, char *buf) 287 { 288 const struct counter_attribute *const a = to_counter_attribute(attr); 289 struct counter_device *const counter = counter_from_dev(dev); 290 int err; 291 u64 data = 0; 292 293 switch (a->scope) { 294 case COUNTER_SCOPE_DEVICE: 295 err = a->comp.device_u64_read(counter, &data); 296 break; 297 case COUNTER_SCOPE_SIGNAL: 298 err = a->comp.signal_u64_read(counter, a->parent, &data); 299 break; 300 case COUNTER_SCOPE_COUNT: 301 err = a->comp.count_u64_read(counter, a->parent, &data); 302 break; 303 default: 304 return -EINVAL; 305 } 306 if (err < 0) 307 return err; 308 309 return sysfs_emit(buf, "%llu\n", (unsigned long long)data); 310 } 311 312 static ssize_t counter_comp_u64_store(struct device *dev, 313 struct device_attribute *attr, 314 const char *buf, size_t len) 315 { 316 const struct counter_attribute *const a = to_counter_attribute(attr); 317 struct counter_device *const counter = counter_from_dev(dev); 318 int err; 319 u64 data = 0; 320 321 err = kstrtou64(buf, 0, &data); 322 if (err < 0) 323 return err; 324 325 switch (a->scope) { 326 case COUNTER_SCOPE_DEVICE: 327 err = a->comp.device_u64_write(counter, data); 328 break; 329 case COUNTER_SCOPE_SIGNAL: 330 err = a->comp.signal_u64_write(counter, a->parent, data); 331 break; 332 case COUNTER_SCOPE_COUNT: 333 err = a->comp.count_u64_write(counter, a->parent, data); 334 break; 335 default: 336 return -EINVAL; 337 } 338 if (err < 0) 339 return err; 340 341 return len; 342 } 343 344 static ssize_t enums_available_show(const u32 *const enums, 345 const size_t num_enums, 346 const char *const strs[], char *buf) 347 { 348 size_t len = 0; 349 size_t index; 350 351 for (index = 0; index < num_enums; index++) 352 len += sysfs_emit_at(buf, len, "%s\n", strs[enums[index]]); 353 354 return len; 355 } 356 357 static ssize_t strs_available_show(const struct counter_available *const avail, 358 char *buf) 359 { 360 size_t len = 0; 361 size_t index; 362 363 for (index = 0; index < avail->num_items; index++) 364 len += sysfs_emit_at(buf, len, "%s\n", avail->strs[index]); 365 366 return len; 367 } 368 369 static ssize_t counter_comp_available_show(struct device *dev, 370 struct device_attribute *attr, 371 char *buf) 372 { 373 const struct counter_attribute *const a = to_counter_attribute(attr); 374 const struct counter_count *const count = a->parent; 375 const struct counter_synapse *const synapse = a->comp.priv; 376 const struct counter_available *const avail = a->comp.priv; 377 378 switch (a->comp.type) { 379 case COUNTER_COMP_FUNCTION: 380 return enums_available_show(count->functions_list, 381 count->num_functions, 382 counter_function_str, buf); 383 case COUNTER_COMP_SYNAPSE_ACTION: 384 return enums_available_show(synapse->actions_list, 385 synapse->num_actions, 386 counter_synapse_action_str, buf); 387 case COUNTER_COMP_ENUM: 388 return strs_available_show(avail, buf); 389 case COUNTER_COMP_COUNT_MODE: 390 return enums_available_show(avail->enums, avail->num_items, 391 counter_count_mode_str, buf); 392 default: 393 return -EINVAL; 394 } 395 } 396 397 static int counter_avail_attr_create(struct device *const dev, 398 struct counter_attribute_group *const group, 399 const struct counter_comp *const comp, void *const parent) 400 { 401 struct counter_attribute *counter_attr; 402 struct device_attribute *dev_attr; 403 404 counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL); 405 if (!counter_attr) 406 return -ENOMEM; 407 408 /* Configure Counter attribute */ 409 counter_attr->comp.type = comp->type; 410 counter_attr->comp.priv = comp->priv; 411 counter_attr->parent = parent; 412 413 /* Initialize sysfs attribute */ 414 dev_attr = &counter_attr->dev_attr; 415 sysfs_attr_init(&dev_attr->attr); 416 417 /* Configure device attribute */ 418 dev_attr->attr.name = devm_kasprintf(dev, GFP_KERNEL, "%s_available", 419 comp->name); 420 if (!dev_attr->attr.name) 421 return -ENOMEM; 422 dev_attr->attr.mode = 0444; 423 dev_attr->show = counter_comp_available_show; 424 425 /* Store list node */ 426 list_add(&counter_attr->l, &group->attr_list); 427 group->num_attr++; 428 429 return 0; 430 } 431 432 static int counter_attr_create(struct device *const dev, 433 struct counter_attribute_group *const group, 434 const struct counter_comp *const comp, 435 const enum counter_scope scope, 436 void *const parent) 437 { 438 struct counter_attribute *counter_attr; 439 struct device_attribute *dev_attr; 440 441 counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL); 442 if (!counter_attr) 443 return -ENOMEM; 444 445 /* Configure Counter attribute */ 446 counter_attr->comp = *comp; 447 counter_attr->scope = scope; 448 counter_attr->parent = parent; 449 450 /* Configure device attribute */ 451 dev_attr = &counter_attr->dev_attr; 452 sysfs_attr_init(&dev_attr->attr); 453 dev_attr->attr.name = comp->name; 454 switch (comp->type) { 455 case COUNTER_COMP_U8: 456 case COUNTER_COMP_BOOL: 457 if (comp->device_u8_read) { 458 dev_attr->attr.mode |= 0444; 459 dev_attr->show = counter_comp_u8_show; 460 } 461 if (comp->device_u8_write) { 462 dev_attr->attr.mode |= 0200; 463 dev_attr->store = counter_comp_u8_store; 464 } 465 break; 466 case COUNTER_COMP_SIGNAL_LEVEL: 467 case COUNTER_COMP_FUNCTION: 468 case COUNTER_COMP_SYNAPSE_ACTION: 469 case COUNTER_COMP_ENUM: 470 case COUNTER_COMP_COUNT_DIRECTION: 471 case COUNTER_COMP_COUNT_MODE: 472 if (comp->device_u32_read) { 473 dev_attr->attr.mode |= 0444; 474 dev_attr->show = counter_comp_u32_show; 475 } 476 if (comp->device_u32_write) { 477 dev_attr->attr.mode |= 0200; 478 dev_attr->store = counter_comp_u32_store; 479 } 480 break; 481 case COUNTER_COMP_U64: 482 if (comp->device_u64_read) { 483 dev_attr->attr.mode |= 0444; 484 dev_attr->show = counter_comp_u64_show; 485 } 486 if (comp->device_u64_write) { 487 dev_attr->attr.mode |= 0200; 488 dev_attr->store = counter_comp_u64_store; 489 } 490 break; 491 default: 492 return -EINVAL; 493 } 494 495 /* Store list node */ 496 list_add(&counter_attr->l, &group->attr_list); 497 group->num_attr++; 498 499 /* Create "*_available" attribute if needed */ 500 switch (comp->type) { 501 case COUNTER_COMP_FUNCTION: 502 case COUNTER_COMP_SYNAPSE_ACTION: 503 case COUNTER_COMP_ENUM: 504 case COUNTER_COMP_COUNT_MODE: 505 return counter_avail_attr_create(dev, group, comp, parent); 506 default: 507 return 0; 508 } 509 } 510 511 static ssize_t counter_comp_name_show(struct device *dev, 512 struct device_attribute *attr, char *buf) 513 { 514 return sysfs_emit(buf, "%s\n", to_counter_attribute(attr)->comp.name); 515 } 516 517 static int counter_name_attr_create(struct device *const dev, 518 struct counter_attribute_group *const group, 519 const char *const name) 520 { 521 struct counter_attribute *counter_attr; 522 523 counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL); 524 if (!counter_attr) 525 return -ENOMEM; 526 527 /* Configure Counter attribute */ 528 counter_attr->comp.name = name; 529 530 /* Configure device attribute */ 531 sysfs_attr_init(&counter_attr->dev_attr.attr); 532 counter_attr->dev_attr.attr.name = "name"; 533 counter_attr->dev_attr.attr.mode = 0444; 534 counter_attr->dev_attr.show = counter_comp_name_show; 535 536 /* Store list node */ 537 list_add(&counter_attr->l, &group->attr_list); 538 group->num_attr++; 539 540 return 0; 541 } 542 543 static ssize_t counter_comp_id_show(struct device *dev, 544 struct device_attribute *attr, char *buf) 545 { 546 const size_t id = (size_t)to_counter_attribute(attr)->comp.priv; 547 548 return sysfs_emit(buf, "%zu\n", id); 549 } 550 551 static int counter_comp_id_attr_create(struct device *const dev, 552 struct counter_attribute_group *const group, 553 const char *name, const size_t id) 554 { 555 struct counter_attribute *counter_attr; 556 557 /* Allocate Counter attribute */ 558 counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL); 559 if (!counter_attr) 560 return -ENOMEM; 561 562 /* Generate component ID name */ 563 name = devm_kasprintf(dev, GFP_KERNEL, "%s_component_id", name); 564 if (!name) 565 return -ENOMEM; 566 567 /* Configure Counter attribute */ 568 counter_attr->comp.priv = (void *)id; 569 570 /* Configure device attribute */ 571 sysfs_attr_init(&counter_attr->dev_attr.attr); 572 counter_attr->dev_attr.attr.name = name; 573 counter_attr->dev_attr.attr.mode = 0444; 574 counter_attr->dev_attr.show = counter_comp_id_show; 575 576 /* Store list node */ 577 list_add(&counter_attr->l, &group->attr_list); 578 group->num_attr++; 579 580 return 0; 581 } 582 583 static struct counter_comp counter_signal_comp = { 584 .type = COUNTER_COMP_SIGNAL_LEVEL, 585 .name = "signal", 586 }; 587 588 static int counter_signal_attrs_create(struct counter_device *const counter, 589 struct counter_attribute_group *const cattr_group, 590 struct counter_signal *const signal) 591 { 592 const enum counter_scope scope = COUNTER_SCOPE_SIGNAL; 593 struct device *const dev = &counter->dev; 594 int err; 595 struct counter_comp comp; 596 size_t i; 597 struct counter_comp *ext; 598 599 /* Create main Signal attribute */ 600 comp = counter_signal_comp; 601 comp.signal_u32_read = counter->ops->signal_read; 602 err = counter_attr_create(dev, cattr_group, &comp, scope, signal); 603 if (err < 0) 604 return err; 605 606 /* Create Signal name attribute */ 607 err = counter_name_attr_create(dev, cattr_group, signal->name); 608 if (err < 0) 609 return err; 610 611 /* Create an attribute for each extension */ 612 for (i = 0; i < signal->num_ext; i++) { 613 ext = &signal->ext[i]; 614 615 err = counter_attr_create(dev, cattr_group, ext, scope, signal); 616 if (err < 0) 617 return err; 618 619 err = counter_comp_id_attr_create(dev, cattr_group, ext->name, 620 i); 621 if (err < 0) 622 return err; 623 } 624 625 return 0; 626 } 627 628 static int counter_sysfs_signals_add(struct counter_device *const counter, 629 struct counter_attribute_group *const groups) 630 { 631 size_t i; 632 int err; 633 634 /* Add each Signal */ 635 for (i = 0; i < counter->num_signals; i++) { 636 /* Generate Signal attribute directory name */ 637 groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL, 638 "signal%zu", i); 639 if (!groups[i].name) 640 return -ENOMEM; 641 642 /* Create all attributes associated with Signal */ 643 err = counter_signal_attrs_create(counter, groups + i, 644 counter->signals + i); 645 if (err < 0) 646 return err; 647 } 648 649 return 0; 650 } 651 652 static int counter_sysfs_synapses_add(struct counter_device *const counter, 653 struct counter_attribute_group *const group, 654 struct counter_count *const count) 655 { 656 size_t i; 657 658 /* Add each Synapse */ 659 for (i = 0; i < count->num_synapses; i++) { 660 struct device *const dev = &counter->dev; 661 struct counter_synapse *synapse; 662 size_t id; 663 struct counter_comp comp; 664 int err; 665 666 synapse = count->synapses + i; 667 668 /* Generate Synapse action name */ 669 id = synapse->signal - counter->signals; 670 comp.name = devm_kasprintf(dev, GFP_KERNEL, "signal%zu_action", 671 id); 672 if (!comp.name) 673 return -ENOMEM; 674 675 /* Create action attribute */ 676 comp.type = COUNTER_COMP_SYNAPSE_ACTION; 677 comp.action_read = counter->ops->action_read; 678 comp.action_write = counter->ops->action_write; 679 comp.priv = synapse; 680 err = counter_attr_create(dev, group, &comp, 681 COUNTER_SCOPE_COUNT, count); 682 if (err < 0) 683 return err; 684 685 /* Create Synapse component ID attribute */ 686 err = counter_comp_id_attr_create(dev, group, comp.name, i); 687 if (err < 0) 688 return err; 689 } 690 691 return 0; 692 } 693 694 static struct counter_comp counter_count_comp = 695 COUNTER_COMP_COUNT_U64("count", NULL, NULL); 696 697 static struct counter_comp counter_function_comp = { 698 .type = COUNTER_COMP_FUNCTION, 699 .name = "function", 700 }; 701 702 static int counter_count_attrs_create(struct counter_device *const counter, 703 struct counter_attribute_group *const cattr_group, 704 struct counter_count *const count) 705 { 706 const enum counter_scope scope = COUNTER_SCOPE_COUNT; 707 struct device *const dev = &counter->dev; 708 int err; 709 struct counter_comp comp; 710 size_t i; 711 struct counter_comp *ext; 712 713 /* Create main Count attribute */ 714 comp = counter_count_comp; 715 comp.count_u64_read = counter->ops->count_read; 716 comp.count_u64_write = counter->ops->count_write; 717 err = counter_attr_create(dev, cattr_group, &comp, scope, count); 718 if (err < 0) 719 return err; 720 721 /* Create Count name attribute */ 722 err = counter_name_attr_create(dev, cattr_group, count->name); 723 if (err < 0) 724 return err; 725 726 /* Create Count function attribute */ 727 comp = counter_function_comp; 728 comp.count_u32_read = counter->ops->function_read; 729 comp.count_u32_write = counter->ops->function_write; 730 err = counter_attr_create(dev, cattr_group, &comp, scope, count); 731 if (err < 0) 732 return err; 733 734 /* Create an attribute for each extension */ 735 for (i = 0; i < count->num_ext; i++) { 736 ext = &count->ext[i]; 737 738 err = counter_attr_create(dev, cattr_group, ext, scope, count); 739 if (err < 0) 740 return err; 741 742 err = counter_comp_id_attr_create(dev, cattr_group, ext->name, 743 i); 744 if (err < 0) 745 return err; 746 } 747 748 return 0; 749 } 750 751 static int counter_sysfs_counts_add(struct counter_device *const counter, 752 struct counter_attribute_group *const groups) 753 { 754 size_t i; 755 struct counter_count *count; 756 int err; 757 758 /* Add each Count */ 759 for (i = 0; i < counter->num_counts; i++) { 760 count = counter->counts + i; 761 762 /* Generate Count attribute directory name */ 763 groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL, 764 "count%zu", i); 765 if (!groups[i].name) 766 return -ENOMEM; 767 768 /* Add sysfs attributes of the Synapses */ 769 err = counter_sysfs_synapses_add(counter, groups + i, count); 770 if (err < 0) 771 return err; 772 773 /* Create all attributes associated with Count */ 774 err = counter_count_attrs_create(counter, groups + i, count); 775 if (err < 0) 776 return err; 777 } 778 779 return 0; 780 } 781 782 static int counter_num_signals_read(struct counter_device *counter, u8 *val) 783 { 784 *val = counter->num_signals; 785 return 0; 786 } 787 788 static int counter_num_counts_read(struct counter_device *counter, u8 *val) 789 { 790 *val = counter->num_counts; 791 return 0; 792 } 793 794 static int counter_events_queue_size_read(struct counter_device *counter, 795 u64 *val) 796 { 797 *val = kfifo_size(&counter->events); 798 return 0; 799 } 800 801 static int counter_events_queue_size_write(struct counter_device *counter, 802 u64 val) 803 { 804 DECLARE_KFIFO_PTR(events, struct counter_event); 805 int err; 806 unsigned long flags; 807 808 /* Allocate new events queue */ 809 err = kfifo_alloc(&events, val, GFP_KERNEL); 810 if (err) 811 return err; 812 813 /* Swap in new events queue */ 814 mutex_lock(&counter->events_out_lock); 815 spin_lock_irqsave(&counter->events_in_lock, flags); 816 kfifo_free(&counter->events); 817 counter->events.kfifo = events.kfifo; 818 spin_unlock_irqrestore(&counter->events_in_lock, flags); 819 mutex_unlock(&counter->events_out_lock); 820 821 return 0; 822 } 823 824 static struct counter_comp counter_num_signals_comp = 825 COUNTER_COMP_DEVICE_U8("num_signals", counter_num_signals_read, NULL); 826 827 static struct counter_comp counter_num_counts_comp = 828 COUNTER_COMP_DEVICE_U8("num_counts", counter_num_counts_read, NULL); 829 830 static struct counter_comp counter_events_queue_size_comp = 831 COUNTER_COMP_DEVICE_U64("events_queue_size", 832 counter_events_queue_size_read, 833 counter_events_queue_size_write); 834 835 static int counter_sysfs_attr_add(struct counter_device *const counter, 836 struct counter_attribute_group *cattr_group) 837 { 838 const enum counter_scope scope = COUNTER_SCOPE_DEVICE; 839 struct device *const dev = &counter->dev; 840 int err; 841 size_t i; 842 struct counter_comp *ext; 843 844 /* Add Signals sysfs attributes */ 845 err = counter_sysfs_signals_add(counter, cattr_group); 846 if (err < 0) 847 return err; 848 cattr_group += counter->num_signals; 849 850 /* Add Counts sysfs attributes */ 851 err = counter_sysfs_counts_add(counter, cattr_group); 852 if (err < 0) 853 return err; 854 cattr_group += counter->num_counts; 855 856 /* Create name attribute */ 857 err = counter_name_attr_create(dev, cattr_group, counter->name); 858 if (err < 0) 859 return err; 860 861 /* Create num_signals attribute */ 862 err = counter_attr_create(dev, cattr_group, &counter_num_signals_comp, 863 scope, NULL); 864 if (err < 0) 865 return err; 866 867 /* Create num_counts attribute */ 868 err = counter_attr_create(dev, cattr_group, &counter_num_counts_comp, 869 scope, NULL); 870 if (err < 0) 871 return err; 872 873 /* Create events_queue_size attribute */ 874 err = counter_attr_create(dev, cattr_group, 875 &counter_events_queue_size_comp, scope, NULL); 876 if (err < 0) 877 return err; 878 879 /* Create an attribute for each extension */ 880 for (i = 0; i < counter->num_ext; i++) { 881 ext = &counter->ext[i]; 882 883 err = counter_attr_create(dev, cattr_group, ext, scope, NULL); 884 if (err < 0) 885 return err; 886 887 err = counter_comp_id_attr_create(dev, cattr_group, ext->name, 888 i); 889 if (err < 0) 890 return err; 891 } 892 893 return 0; 894 } 895 896 /** 897 * counter_sysfs_add - Adds Counter sysfs attributes to the device structure 898 * @counter: Pointer to the Counter device structure 899 * 900 * Counter sysfs attributes are created and added to the respective device 901 * structure for later registration to the system. Resource-managed memory 902 * allocation is performed by this function, and this memory should be freed 903 * when no longer needed (automatically by a device_unregister call, or 904 * manually by a devres_release_all call). 905 */ 906 int counter_sysfs_add(struct counter_device *const counter) 907 { 908 struct device *const dev = &counter->dev; 909 const size_t num_groups = counter->num_signals + counter->num_counts + 1; 910 struct counter_attribute_group *cattr_groups; 911 size_t i, j; 912 int err; 913 struct attribute_group *groups; 914 struct counter_attribute *p; 915 916 /* Allocate space for attribute groups (signals, counts, and ext) */ 917 cattr_groups = devm_kcalloc(dev, num_groups, sizeof(*cattr_groups), 918 GFP_KERNEL); 919 if (!cattr_groups) 920 return -ENOMEM; 921 922 /* Initialize attribute lists */ 923 for (i = 0; i < num_groups; i++) 924 INIT_LIST_HEAD(&cattr_groups[i].attr_list); 925 926 /* Add Counter device sysfs attributes */ 927 err = counter_sysfs_attr_add(counter, cattr_groups); 928 if (err < 0) 929 return err; 930 931 /* Allocate attribute group pointers for association with device */ 932 dev->groups = devm_kcalloc(dev, num_groups + 1, sizeof(*dev->groups), 933 GFP_KERNEL); 934 if (!dev->groups) 935 return -ENOMEM; 936 937 /* Allocate space for attribute groups */ 938 groups = devm_kcalloc(dev, num_groups, sizeof(*groups), GFP_KERNEL); 939 if (!groups) 940 return -ENOMEM; 941 942 /* Prepare each group of attributes for association */ 943 for (i = 0; i < num_groups; i++) { 944 groups[i].name = cattr_groups[i].name; 945 946 /* Allocate space for attribute pointers */ 947 groups[i].attrs = devm_kcalloc(dev, 948 cattr_groups[i].num_attr + 1, 949 sizeof(*groups[i].attrs), 950 GFP_KERNEL); 951 if (!groups[i].attrs) 952 return -ENOMEM; 953 954 /* Add attribute pointers to attribute group */ 955 j = 0; 956 list_for_each_entry(p, &cattr_groups[i].attr_list, l) 957 groups[i].attrs[j++] = &p->dev_attr.attr; 958 959 /* Associate attribute group */ 960 dev->groups[i] = &groups[i]; 961 } 962 963 return 0; 964 } 965