1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Xilinx Event Management Driver 4 * 5 * Copyright (C) 2021 Xilinx, Inc. 6 * 7 * Abhyuday Godhasara <abhyuday.godhasara@xilinx.com> 8 */ 9 10 #include <linux/cpuhotplug.h> 11 #include <linux/firmware/xlnx-event-manager.h> 12 #include <linux/firmware/xlnx-zynqmp.h> 13 #include <linux/hashtable.h> 14 #include <linux/interrupt.h> 15 #include <linux/irq.h> 16 #include <linux/irqdomain.h> 17 #include <linux/module.h> 18 #include <linux/of_irq.h> 19 #include <linux/platform_device.h> 20 #include <linux/slab.h> 21 22 static DEFINE_PER_CPU_READ_MOSTLY(int, cpu_number1); 23 24 static int virq_sgi; 25 static int event_manager_availability = -EACCES; 26 27 /* SGI number used for Event management driver */ 28 #define XLNX_EVENT_SGI_NUM (15) 29 30 /* Max number of driver can register for same event */ 31 #define MAX_DRIVER_PER_EVENT (10U) 32 33 /* Max HashMap Order for PM API feature check (1<<7 = 128) */ 34 #define REGISTERED_DRIVER_MAX_ORDER (7) 35 36 #define MAX_BITS (32U) /* Number of bits available for error mask */ 37 38 #define FIRMWARE_VERSION_MASK (0xFFFFU) 39 #define REGISTER_NOTIFIER_FIRMWARE_VERSION (2U) 40 41 static DEFINE_HASHTABLE(reg_driver_map, REGISTERED_DRIVER_MAX_ORDER); 42 static int sgi_num = XLNX_EVENT_SGI_NUM; 43 44 static bool is_need_to_unregister; 45 46 /** 47 * struct agent_cb - Registered callback function and private data. 48 * @agent_data: Data passed back to handler function. 49 * @eve_cb: Function pointer to store the callback function. 50 * @list: member to create list. 51 */ 52 struct agent_cb { 53 void *agent_data; 54 event_cb_func_t eve_cb; 55 struct list_head list; 56 }; 57 58 /** 59 * struct registered_event_data - Registered Event Data. 60 * @key: key is the combine id(Node-Id | Event-Id) of type u64 61 * where upper u32 for Node-Id and lower u32 for Event-Id, 62 * And this used as key to index into hashmap. 63 * @cb_type: Type of Api callback, like PM_NOTIFY_CB, etc. 64 * @wake: If this flag set, firmware will wake up processor if is 65 * in sleep or power down state. 66 * @cb_list_head: Head of call back data list which contain the information 67 * about registered handler and private data. 68 * @hentry: hlist_node that hooks this entry into hashtable. 69 */ 70 struct registered_event_data { 71 u64 key; 72 enum pm_api_cb_id cb_type; 73 bool wake; 74 struct list_head cb_list_head; 75 struct hlist_node hentry; 76 }; 77 78 static bool xlnx_is_error_event(const u32 node_id) 79 { 80 if (node_id == EVENT_ERROR_PMC_ERR1 || 81 node_id == EVENT_ERROR_PMC_ERR2 || 82 node_id == EVENT_ERROR_PSM_ERR1 || 83 node_id == EVENT_ERROR_PSM_ERR2) 84 return true; 85 86 return false; 87 } 88 89 static int xlnx_add_cb_for_notify_event(const u32 node_id, const u32 event, const bool wake, 90 event_cb_func_t cb_fun, void *data) 91 { 92 u64 key = 0; 93 bool present_in_hash = false; 94 struct registered_event_data *eve_data; 95 struct agent_cb *cb_data; 96 struct agent_cb *cb_pos; 97 struct agent_cb *cb_next; 98 99 key = ((u64)node_id << 32U) | (u64)event; 100 /* Check for existing entry in hash table for given key id */ 101 hash_for_each_possible(reg_driver_map, eve_data, hentry, key) { 102 if (eve_data->key == key) { 103 present_in_hash = true; 104 break; 105 } 106 } 107 108 if (!present_in_hash) { 109 /* Add new entry if not present in HASH table */ 110 eve_data = kmalloc(sizeof(*eve_data), GFP_KERNEL); 111 if (!eve_data) 112 return -ENOMEM; 113 eve_data->key = key; 114 eve_data->cb_type = PM_NOTIFY_CB; 115 eve_data->wake = wake; 116 INIT_LIST_HEAD(&eve_data->cb_list_head); 117 118 cb_data = kmalloc(sizeof(*cb_data), GFP_KERNEL); 119 if (!cb_data) 120 return -ENOMEM; 121 cb_data->eve_cb = cb_fun; 122 cb_data->agent_data = data; 123 124 /* Add into callback list */ 125 list_add(&cb_data->list, &eve_data->cb_list_head); 126 127 /* Add into HASH table */ 128 hash_add(reg_driver_map, &eve_data->hentry, key); 129 } else { 130 /* Search for callback function and private data in list */ 131 list_for_each_entry_safe(cb_pos, cb_next, &eve_data->cb_list_head, list) { 132 if (cb_pos->eve_cb == cb_fun && 133 cb_pos->agent_data == data) { 134 return 0; 135 } 136 } 137 138 /* Add multiple handler and private data in list */ 139 cb_data = kmalloc(sizeof(*cb_data), GFP_KERNEL); 140 if (!cb_data) 141 return -ENOMEM; 142 cb_data->eve_cb = cb_fun; 143 cb_data->agent_data = data; 144 145 list_add(&cb_data->list, &eve_data->cb_list_head); 146 } 147 148 return 0; 149 } 150 151 static int xlnx_add_cb_for_suspend(event_cb_func_t cb_fun, void *data) 152 { 153 struct registered_event_data *eve_data; 154 struct agent_cb *cb_data; 155 156 /* Check for existing entry in hash table for given cb_type */ 157 hash_for_each_possible(reg_driver_map, eve_data, hentry, PM_INIT_SUSPEND_CB) { 158 if (eve_data->cb_type == PM_INIT_SUSPEND_CB) { 159 pr_err("Found as already registered\n"); 160 return -EINVAL; 161 } 162 } 163 164 /* Add new entry if not present */ 165 eve_data = kmalloc(sizeof(*eve_data), GFP_KERNEL); 166 if (!eve_data) 167 return -ENOMEM; 168 169 eve_data->key = 0; 170 eve_data->cb_type = PM_INIT_SUSPEND_CB; 171 INIT_LIST_HEAD(&eve_data->cb_list_head); 172 173 cb_data = kmalloc(sizeof(*cb_data), GFP_KERNEL); 174 if (!cb_data) 175 return -ENOMEM; 176 cb_data->eve_cb = cb_fun; 177 cb_data->agent_data = data; 178 179 /* Add into callback list */ 180 list_add(&cb_data->list, &eve_data->cb_list_head); 181 182 hash_add(reg_driver_map, &eve_data->hentry, PM_INIT_SUSPEND_CB); 183 184 return 0; 185 } 186 187 static int xlnx_remove_cb_for_suspend(event_cb_func_t cb_fun) 188 { 189 bool is_callback_found = false; 190 struct registered_event_data *eve_data; 191 struct agent_cb *cb_pos; 192 struct agent_cb *cb_next; 193 194 is_need_to_unregister = false; 195 196 /* Check for existing entry in hash table for given cb_type */ 197 hash_for_each_possible(reg_driver_map, eve_data, hentry, PM_INIT_SUSPEND_CB) { 198 if (eve_data->cb_type == PM_INIT_SUSPEND_CB) { 199 /* Delete the list of callback */ 200 list_for_each_entry_safe(cb_pos, cb_next, &eve_data->cb_list_head, list) { 201 if (cb_pos->eve_cb == cb_fun) { 202 is_callback_found = true; 203 list_del_init(&cb_pos->list); 204 kfree(cb_pos); 205 } 206 } 207 /* remove an object from a hashtable */ 208 hash_del(&eve_data->hentry); 209 kfree(eve_data); 210 is_need_to_unregister = true; 211 } 212 } 213 if (!is_callback_found) { 214 pr_warn("Didn't find any registered callback for suspend event\n"); 215 return -EINVAL; 216 } 217 218 return 0; 219 } 220 221 static int xlnx_remove_cb_for_notify_event(const u32 node_id, const u32 event, 222 event_cb_func_t cb_fun, void *data) 223 { 224 bool is_callback_found = false; 225 struct registered_event_data *eve_data; 226 u64 key = ((u64)node_id << 32U) | (u64)event; 227 struct agent_cb *cb_pos; 228 struct agent_cb *cb_next; 229 230 is_need_to_unregister = false; 231 232 /* Check for existing entry in hash table for given key id */ 233 hash_for_each_possible(reg_driver_map, eve_data, hentry, key) { 234 if (eve_data->key == key) { 235 /* Delete the list of callback */ 236 list_for_each_entry_safe(cb_pos, cb_next, &eve_data->cb_list_head, list) { 237 if (cb_pos->eve_cb == cb_fun && 238 cb_pos->agent_data == data) { 239 is_callback_found = true; 240 list_del_init(&cb_pos->list); 241 kfree(cb_pos); 242 } 243 } 244 245 /* Remove HASH table if callback list is empty */ 246 if (list_empty(&eve_data->cb_list_head)) { 247 /* remove an object from a HASH table */ 248 hash_del(&eve_data->hentry); 249 kfree(eve_data); 250 is_need_to_unregister = true; 251 } 252 } 253 } 254 if (!is_callback_found) { 255 pr_warn("Didn't find any registered callback for 0x%x 0x%x\n", 256 node_id, event); 257 return -EINVAL; 258 } 259 260 return 0; 261 } 262 263 /** 264 * xlnx_register_event() - Register for the event. 265 * @cb_type: Type of callback from pm_api_cb_id, 266 * PM_NOTIFY_CB - for Error Events, 267 * PM_INIT_SUSPEND_CB - for suspend callback. 268 * @node_id: Node-Id related to event. 269 * @event: Event Mask for the Error Event. 270 * @wake: Flag specifying whether the subsystem should be woken upon 271 * event notification. 272 * @cb_fun: Function pointer to store the callback function. 273 * @data: Pointer for the driver instance. 274 * 275 * Return: Returns 0 on successful registration else error code. 276 */ 277 int xlnx_register_event(const enum pm_api_cb_id cb_type, const u32 node_id, const u32 event, 278 const bool wake, event_cb_func_t cb_fun, void *data) 279 { 280 int ret = 0; 281 u32 eve; 282 int pos; 283 284 if (event_manager_availability) 285 return event_manager_availability; 286 287 if (cb_type != PM_NOTIFY_CB && cb_type != PM_INIT_SUSPEND_CB) { 288 pr_err("%s() Unsupported Callback 0x%x\n", __func__, cb_type); 289 return -EINVAL; 290 } 291 292 if (!cb_fun) 293 return -EFAULT; 294 295 if (cb_type == PM_INIT_SUSPEND_CB) { 296 ret = xlnx_add_cb_for_suspend(cb_fun, data); 297 } else { 298 if (!xlnx_is_error_event(node_id)) { 299 /* Add entry for Node-Id/Event in hash table */ 300 ret = xlnx_add_cb_for_notify_event(node_id, event, wake, cb_fun, data); 301 } else { 302 /* Add into Hash table */ 303 for (pos = 0; pos < MAX_BITS; pos++) { 304 eve = event & (1 << pos); 305 if (!eve) 306 continue; 307 308 /* Add entry for Node-Id/Eve in hash table */ 309 ret = xlnx_add_cb_for_notify_event(node_id, eve, wake, cb_fun, 310 data); 311 /* Break the loop if got error */ 312 if (ret) 313 break; 314 } 315 if (ret) { 316 /* Skip the Event for which got the error */ 317 pos--; 318 /* Remove registered(during this call) event from hash table */ 319 for ( ; pos >= 0; pos--) { 320 eve = event & (1 << pos); 321 if (!eve) 322 continue; 323 xlnx_remove_cb_for_notify_event(node_id, eve, cb_fun, data); 324 } 325 } 326 } 327 328 if (ret) { 329 pr_err("%s() failed for 0x%x and 0x%x: %d\r\n", __func__, node_id, 330 event, ret); 331 return ret; 332 } 333 334 /* Register for Node-Id/Event combination in firmware */ 335 ret = zynqmp_pm_register_notifier(node_id, event, wake, true); 336 if (ret) { 337 pr_err("%s() failed for 0x%x and 0x%x: %d\r\n", __func__, node_id, 338 event, ret); 339 /* Remove already registered event from hash table */ 340 if (xlnx_is_error_event(node_id)) { 341 for (pos = 0; pos < MAX_BITS; pos++) { 342 eve = event & (1 << pos); 343 if (!eve) 344 continue; 345 xlnx_remove_cb_for_notify_event(node_id, eve, cb_fun, data); 346 } 347 } else { 348 xlnx_remove_cb_for_notify_event(node_id, event, cb_fun, data); 349 } 350 return ret; 351 } 352 } 353 354 return ret; 355 } 356 EXPORT_SYMBOL_GPL(xlnx_register_event); 357 358 /** 359 * xlnx_unregister_event() - Unregister for the event. 360 * @cb_type: Type of callback from pm_api_cb_id, 361 * PM_NOTIFY_CB - for Error Events, 362 * PM_INIT_SUSPEND_CB - for suspend callback. 363 * @node_id: Node-Id related to event. 364 * @event: Event Mask for the Error Event. 365 * @cb_fun: Function pointer of callback function. 366 * @data: Pointer of agent's private data. 367 * 368 * Return: Returns 0 on successful unregistration else error code. 369 */ 370 int xlnx_unregister_event(const enum pm_api_cb_id cb_type, const u32 node_id, const u32 event, 371 event_cb_func_t cb_fun, void *data) 372 { 373 int ret = 0; 374 u32 eve, pos; 375 376 is_need_to_unregister = false; 377 378 if (event_manager_availability) 379 return event_manager_availability; 380 381 if (cb_type != PM_NOTIFY_CB && cb_type != PM_INIT_SUSPEND_CB) { 382 pr_err("%s() Unsupported Callback 0x%x\n", __func__, cb_type); 383 return -EINVAL; 384 } 385 386 if (!cb_fun) 387 return -EFAULT; 388 389 if (cb_type == PM_INIT_SUSPEND_CB) { 390 ret = xlnx_remove_cb_for_suspend(cb_fun); 391 } else { 392 /* Remove Node-Id/Event from hash table */ 393 if (!xlnx_is_error_event(node_id)) { 394 xlnx_remove_cb_for_notify_event(node_id, event, cb_fun, data); 395 } else { 396 for (pos = 0; pos < MAX_BITS; pos++) { 397 eve = event & (1 << pos); 398 if (!eve) 399 continue; 400 401 xlnx_remove_cb_for_notify_event(node_id, eve, cb_fun, data); 402 } 403 } 404 405 /* Un-register if list is empty */ 406 if (is_need_to_unregister) { 407 /* Un-register for Node-Id/Event combination */ 408 ret = zynqmp_pm_register_notifier(node_id, event, false, false); 409 if (ret) { 410 pr_err("%s() failed for 0x%x and 0x%x: %d\n", 411 __func__, node_id, event, ret); 412 return ret; 413 } 414 } 415 } 416 417 return ret; 418 } 419 EXPORT_SYMBOL_GPL(xlnx_unregister_event); 420 421 static void xlnx_call_suspend_cb_handler(const u32 *payload) 422 { 423 bool is_callback_found = false; 424 struct registered_event_data *eve_data; 425 u32 cb_type = payload[0]; 426 struct agent_cb *cb_pos; 427 struct agent_cb *cb_next; 428 429 /* Check for existing entry in hash table for given cb_type */ 430 hash_for_each_possible(reg_driver_map, eve_data, hentry, cb_type) { 431 if (eve_data->cb_type == cb_type) { 432 list_for_each_entry_safe(cb_pos, cb_next, &eve_data->cb_list_head, list) { 433 cb_pos->eve_cb(&payload[0], cb_pos->agent_data); 434 is_callback_found = true; 435 } 436 } 437 } 438 if (!is_callback_found) 439 pr_warn("Didn't find any registered callback for suspend event\n"); 440 } 441 442 static void xlnx_call_notify_cb_handler(const u32 *payload) 443 { 444 bool is_callback_found = false; 445 struct registered_event_data *eve_data; 446 u64 key = ((u64)payload[1] << 32U) | (u64)payload[2]; 447 int ret; 448 struct agent_cb *cb_pos; 449 struct agent_cb *cb_next; 450 451 /* Check for existing entry in hash table for given key id */ 452 hash_for_each_possible(reg_driver_map, eve_data, hentry, key) { 453 if (eve_data->key == key) { 454 list_for_each_entry_safe(cb_pos, cb_next, &eve_data->cb_list_head, list) { 455 cb_pos->eve_cb(&payload[0], cb_pos->agent_data); 456 is_callback_found = true; 457 } 458 459 /* re register with firmware to get future events */ 460 ret = zynqmp_pm_register_notifier(payload[1], payload[2], 461 eve_data->wake, true); 462 if (ret) { 463 pr_err("%s() failed for 0x%x and 0x%x: %d\r\n", __func__, 464 payload[1], payload[2], ret); 465 list_for_each_entry_safe(cb_pos, cb_next, &eve_data->cb_list_head, 466 list) { 467 /* Remove already registered event from hash table */ 468 xlnx_remove_cb_for_notify_event(payload[1], payload[2], 469 cb_pos->eve_cb, 470 cb_pos->agent_data); 471 } 472 } 473 } 474 } 475 if (!is_callback_found) 476 pr_warn("Didn't find any registered callback for 0x%x 0x%x\n", 477 payload[1], payload[2]); 478 } 479 480 static void xlnx_get_event_callback_data(u32 *buf) 481 { 482 zynqmp_pm_invoke_fn(GET_CALLBACK_DATA, 0, 0, 0, 0, buf); 483 } 484 485 static irqreturn_t xlnx_event_handler(int irq, void *dev_id) 486 { 487 u32 cb_type, node_id, event, pos; 488 u32 payload[CB_MAX_PAYLOAD_SIZE] = {0}; 489 u32 event_data[CB_MAX_PAYLOAD_SIZE] = {0}; 490 491 /* Get event data */ 492 xlnx_get_event_callback_data(payload); 493 494 /* First element is callback type, others are callback arguments */ 495 cb_type = payload[0]; 496 497 if (cb_type == PM_NOTIFY_CB) { 498 node_id = payload[1]; 499 event = payload[2]; 500 if (!xlnx_is_error_event(node_id)) { 501 xlnx_call_notify_cb_handler(payload); 502 } else { 503 /* 504 * Each call back function expecting payload as an input arguments. 505 * We can get multiple error events as in one call back through error 506 * mask. So payload[2] may can contain multiple error events. 507 * In reg_driver_map database we store data in the combination of single 508 * node_id-error combination. 509 * So coping the payload message into event_data and update the 510 * event_data[2] with Error Mask for single error event and use 511 * event_data as input argument for registered call back function. 512 * 513 */ 514 memcpy(event_data, payload, (4 * CB_MAX_PAYLOAD_SIZE)); 515 /* Support Multiple Error Event */ 516 for (pos = 0; pos < MAX_BITS; pos++) { 517 if ((0 == (event & (1 << pos)))) 518 continue; 519 event_data[2] = (event & (1 << pos)); 520 xlnx_call_notify_cb_handler(event_data); 521 } 522 } 523 } else if (cb_type == PM_INIT_SUSPEND_CB) { 524 xlnx_call_suspend_cb_handler(payload); 525 } else { 526 pr_err("%s() Unsupported Callback %d\n", __func__, cb_type); 527 } 528 529 return IRQ_HANDLED; 530 } 531 532 static int xlnx_event_cpuhp_start(unsigned int cpu) 533 { 534 enable_percpu_irq(virq_sgi, IRQ_TYPE_NONE); 535 536 return 0; 537 } 538 539 static int xlnx_event_cpuhp_down(unsigned int cpu) 540 { 541 disable_percpu_irq(virq_sgi); 542 543 return 0; 544 } 545 546 static void xlnx_disable_percpu_irq(void *data) 547 { 548 disable_percpu_irq(virq_sgi); 549 } 550 551 static int xlnx_event_init_sgi(struct platform_device *pdev) 552 { 553 int ret = 0; 554 int cpu = smp_processor_id(); 555 /* 556 * IRQ related structures are used for the following: 557 * for each SGI interrupt ensure its mapped by GIC IRQ domain 558 * and that each corresponding linux IRQ for the HW IRQ has 559 * a handler for when receiving an interrupt from the remote 560 * processor. 561 */ 562 struct irq_domain *domain; 563 struct irq_fwspec sgi_fwspec; 564 struct device_node *interrupt_parent = NULL; 565 struct device *parent = pdev->dev.parent; 566 567 /* Find GIC controller to map SGIs. */ 568 interrupt_parent = of_irq_find_parent(parent->of_node); 569 if (!interrupt_parent) { 570 dev_err(&pdev->dev, "Failed to find property for Interrupt parent\n"); 571 return -EINVAL; 572 } 573 574 /* Each SGI needs to be associated with GIC's IRQ domain. */ 575 domain = irq_find_host(interrupt_parent); 576 of_node_put(interrupt_parent); 577 578 /* Each mapping needs GIC domain when finding IRQ mapping. */ 579 sgi_fwspec.fwnode = domain->fwnode; 580 581 /* 582 * When irq domain looks at mapping each arg is as follows: 583 * 3 args for: interrupt type (SGI), interrupt # (set later), type 584 */ 585 sgi_fwspec.param_count = 1; 586 587 /* Set SGI's hwirq */ 588 sgi_fwspec.param[0] = sgi_num; 589 virq_sgi = irq_create_fwspec_mapping(&sgi_fwspec); 590 591 per_cpu(cpu_number1, cpu) = cpu; 592 ret = request_percpu_irq(virq_sgi, xlnx_event_handler, "xlnx_event_mgmt", 593 &cpu_number1); 594 WARN_ON(ret); 595 if (ret) { 596 irq_dispose_mapping(virq_sgi); 597 return ret; 598 } 599 600 irq_to_desc(virq_sgi); 601 irq_set_status_flags(virq_sgi, IRQ_PER_CPU); 602 603 return ret; 604 } 605 606 static void xlnx_event_cleanup_sgi(struct platform_device *pdev) 607 { 608 int cpu = smp_processor_id(); 609 610 per_cpu(cpu_number1, cpu) = cpu; 611 612 cpuhp_remove_state(CPUHP_AP_ONLINE_DYN); 613 614 on_each_cpu(xlnx_disable_percpu_irq, NULL, 1); 615 616 irq_clear_status_flags(virq_sgi, IRQ_PER_CPU); 617 free_percpu_irq(virq_sgi, &cpu_number1); 618 irq_dispose_mapping(virq_sgi); 619 } 620 621 static int xlnx_event_manager_probe(struct platform_device *pdev) 622 { 623 int ret; 624 625 ret = zynqmp_pm_feature(PM_REGISTER_NOTIFIER); 626 if (ret < 0) { 627 dev_err(&pdev->dev, "Feature check failed with %d\n", ret); 628 return ret; 629 } 630 631 if ((ret & FIRMWARE_VERSION_MASK) < 632 REGISTER_NOTIFIER_FIRMWARE_VERSION) { 633 dev_err(&pdev->dev, "Register notifier version error. Expected Firmware: v%d - Found: v%d\n", 634 REGISTER_NOTIFIER_FIRMWARE_VERSION, 635 ret & FIRMWARE_VERSION_MASK); 636 return -EOPNOTSUPP; 637 } 638 639 /* Initialize the SGI */ 640 ret = xlnx_event_init_sgi(pdev); 641 if (ret) { 642 dev_err(&pdev->dev, "SGI Init has been failed with %d\n", ret); 643 return ret; 644 } 645 646 /* Setup function for the CPU hot-plug cases */ 647 cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "soc/event:starting", 648 xlnx_event_cpuhp_start, xlnx_event_cpuhp_down); 649 650 ret = zynqmp_pm_register_sgi(sgi_num, 0); 651 if (ret) { 652 dev_err(&pdev->dev, "SGI %d Registration over TF-A failed with %d\n", sgi_num, ret); 653 xlnx_event_cleanup_sgi(pdev); 654 return ret; 655 } 656 657 event_manager_availability = 0; 658 659 dev_info(&pdev->dev, "SGI %d Registered over TF-A\n", sgi_num); 660 dev_info(&pdev->dev, "Xilinx Event Management driver probed\n"); 661 662 return ret; 663 } 664 665 static int xlnx_event_manager_remove(struct platform_device *pdev) 666 { 667 int i; 668 struct registered_event_data *eve_data; 669 struct hlist_node *tmp; 670 int ret; 671 struct agent_cb *cb_pos; 672 struct agent_cb *cb_next; 673 674 hash_for_each_safe(reg_driver_map, i, tmp, eve_data, hentry) { 675 list_for_each_entry_safe(cb_pos, cb_next, &eve_data->cb_list_head, list) { 676 list_del_init(&cb_pos->list); 677 kfree(cb_pos); 678 } 679 hash_del(&eve_data->hentry); 680 kfree(eve_data); 681 } 682 683 ret = zynqmp_pm_register_sgi(0, 1); 684 if (ret) 685 dev_err(&pdev->dev, "SGI unregistration over TF-A failed with %d\n", ret); 686 687 xlnx_event_cleanup_sgi(pdev); 688 689 event_manager_availability = -EACCES; 690 691 return ret; 692 } 693 694 static struct platform_driver xlnx_event_manager_driver = { 695 .probe = xlnx_event_manager_probe, 696 .remove = xlnx_event_manager_remove, 697 .driver = { 698 .name = "xlnx_event_manager", 699 }, 700 }; 701 module_param(sgi_num, uint, 0); 702 module_platform_driver(xlnx_event_manager_driver); 703