1 /* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ 2 /* Copyright (c) 2010-2012 Broadcom. All rights reserved. */ 3 4 #ifndef VCHIQ_CORE_H 5 #define VCHIQ_CORE_H 6 7 #include <linux/mutex.h> 8 #include <linux/completion.h> 9 #include <linux/kthread.h> 10 #include <linux/wait.h> 11 12 #include "vchiq_cfg.h" 13 14 #include "vchiq.h" 15 16 /* Run time control of log level, based on KERN_XXX level. */ 17 #define VCHIQ_LOG_DEFAULT 4 18 #define VCHIQ_LOG_ERROR 3 19 #define VCHIQ_LOG_WARNING 4 20 #define VCHIQ_LOG_INFO 6 21 #define VCHIQ_LOG_TRACE 7 22 23 #define VCHIQ_LOG_PREFIX KERN_INFO "vchiq: " 24 25 #ifndef vchiq_log_error 26 #define vchiq_log_error(cat, fmt, ...) \ 27 do { if (cat >= VCHIQ_LOG_ERROR) \ 28 printk(VCHIQ_LOG_PREFIX fmt "\n", ##__VA_ARGS__); } while (0) 29 #endif 30 #ifndef vchiq_log_warning 31 #define vchiq_log_warning(cat, fmt, ...) \ 32 do { if (cat >= VCHIQ_LOG_WARNING) \ 33 printk(VCHIQ_LOG_PREFIX fmt "\n", ##__VA_ARGS__); } while (0) 34 #endif 35 #ifndef vchiq_log_info 36 #define vchiq_log_info(cat, fmt, ...) \ 37 do { if (cat >= VCHIQ_LOG_INFO) \ 38 printk(VCHIQ_LOG_PREFIX fmt "\n", ##__VA_ARGS__); } while (0) 39 #endif 40 #ifndef vchiq_log_trace 41 #define vchiq_log_trace(cat, fmt, ...) \ 42 do { if (cat >= VCHIQ_LOG_TRACE) \ 43 printk(VCHIQ_LOG_PREFIX fmt "\n", ##__VA_ARGS__); } while (0) 44 #endif 45 46 #define vchiq_loud_error(...) \ 47 vchiq_log_error(vchiq_core_log_level, "===== " __VA_ARGS__) 48 49 #ifndef vchiq_static_assert 50 #define vchiq_static_assert(cond) __attribute__((unused)) \ 51 extern int vchiq_static_assert[(cond) ? 1 : -1] 52 #endif 53 54 #define IS_POW2(x) (x && ((x & (x - 1)) == 0)) 55 56 /* Ensure that the slot size and maximum number of slots are powers of 2 */ 57 vchiq_static_assert(IS_POW2(VCHIQ_SLOT_SIZE)); 58 vchiq_static_assert(IS_POW2(VCHIQ_MAX_SLOTS)); 59 vchiq_static_assert(IS_POW2(VCHIQ_MAX_SLOTS_PER_SIDE)); 60 61 #define VCHIQ_SLOT_MASK (VCHIQ_SLOT_SIZE - 1) 62 #define VCHIQ_SLOT_QUEUE_MASK (VCHIQ_MAX_SLOTS_PER_SIDE - 1) 63 #define VCHIQ_SLOT_ZERO_SLOTS ((sizeof(struct vchiq_slot_zero) + \ 64 VCHIQ_SLOT_SIZE - 1) / VCHIQ_SLOT_SIZE) 65 66 #define VCHIQ_MSG_PADDING 0 /* - */ 67 #define VCHIQ_MSG_CONNECT 1 /* - */ 68 #define VCHIQ_MSG_OPEN 2 /* + (srcport, -), fourcc, client_id */ 69 #define VCHIQ_MSG_OPENACK 3 /* + (srcport, dstport) */ 70 #define VCHIQ_MSG_CLOSE 4 /* + (srcport, dstport) */ 71 #define VCHIQ_MSG_DATA 5 /* + (srcport, dstport) */ 72 #define VCHIQ_MSG_BULK_RX 6 /* + (srcport, dstport), data, size */ 73 #define VCHIQ_MSG_BULK_TX 7 /* + (srcport, dstport), data, size */ 74 #define VCHIQ_MSG_BULK_RX_DONE 8 /* + (srcport, dstport), actual */ 75 #define VCHIQ_MSG_BULK_TX_DONE 9 /* + (srcport, dstport), actual */ 76 #define VCHIQ_MSG_PAUSE 10 /* - */ 77 #define VCHIQ_MSG_RESUME 11 /* - */ 78 #define VCHIQ_MSG_REMOTE_USE 12 /* - */ 79 #define VCHIQ_MSG_REMOTE_RELEASE 13 /* - */ 80 #define VCHIQ_MSG_REMOTE_USE_ACTIVE 14 /* - */ 81 82 #define VCHIQ_PORT_MAX (VCHIQ_MAX_SERVICES - 1) 83 #define VCHIQ_PORT_FREE 0x1000 84 #define VCHIQ_PORT_IS_VALID(port) (port < VCHIQ_PORT_FREE) 85 #define VCHIQ_MAKE_MSG(type, srcport, dstport) \ 86 ((type<<24) | (srcport<<12) | (dstport<<0)) 87 #define VCHIQ_MSG_TYPE(msgid) ((unsigned int)msgid >> 24) 88 #define VCHIQ_MSG_SRCPORT(msgid) \ 89 (unsigned short)(((unsigned int)msgid >> 12) & 0xfff) 90 #define VCHIQ_MSG_DSTPORT(msgid) \ 91 ((unsigned short)msgid & 0xfff) 92 93 #define VCHIQ_FOURCC_AS_4CHARS(fourcc) \ 94 ((fourcc) >> 24) & 0xff, \ 95 ((fourcc) >> 16) & 0xff, \ 96 ((fourcc) >> 8) & 0xff, \ 97 (fourcc) & 0xff 98 99 /* Ensure the fields are wide enough */ 100 vchiq_static_assert(VCHIQ_MSG_SRCPORT(VCHIQ_MAKE_MSG(0, 0, VCHIQ_PORT_MAX)) 101 == 0); 102 vchiq_static_assert(VCHIQ_MSG_TYPE(VCHIQ_MAKE_MSG(0, VCHIQ_PORT_MAX, 0)) == 0); 103 vchiq_static_assert((unsigned int)VCHIQ_PORT_MAX < 104 (unsigned int)VCHIQ_PORT_FREE); 105 106 #define VCHIQ_MSGID_PADDING VCHIQ_MAKE_MSG(VCHIQ_MSG_PADDING, 0, 0) 107 #define VCHIQ_MSGID_CLAIMED 0x40000000 108 109 #define VCHIQ_FOURCC_INVALID 0x00000000 110 #define VCHIQ_FOURCC_IS_LEGAL(fourcc) (fourcc != VCHIQ_FOURCC_INVALID) 111 112 #define VCHIQ_BULK_ACTUAL_ABORTED -1 113 114 typedef uint32_t BITSET_T; 115 116 vchiq_static_assert((sizeof(BITSET_T) * 8) == 32); 117 118 #define BITSET_SIZE(b) ((b + 31) >> 5) 119 #define BITSET_WORD(b) (b >> 5) 120 #define BITSET_BIT(b) (1 << (b & 31)) 121 #define BITSET_IS_SET(bs, b) (bs[BITSET_WORD(b)] & BITSET_BIT(b)) 122 #define BITSET_SET(bs, b) (bs[BITSET_WORD(b)] |= BITSET_BIT(b)) 123 #define BITSET_CLR(bs, b) (bs[BITSET_WORD(b)] &= ~BITSET_BIT(b)) 124 125 #if VCHIQ_ENABLE_STATS 126 #define VCHIQ_STATS_INC(state, stat) (state->stats. stat++) 127 #define VCHIQ_SERVICE_STATS_INC(service, stat) (service->stats. stat++) 128 #define VCHIQ_SERVICE_STATS_ADD(service, stat, addend) \ 129 (service->stats. stat += addend) 130 #else 131 #define VCHIQ_STATS_INC(state, stat) ((void)0) 132 #define VCHIQ_SERVICE_STATS_INC(service, stat) ((void)0) 133 #define VCHIQ_SERVICE_STATS_ADD(service, stat, addend) ((void)0) 134 #endif 135 136 enum { 137 DEBUG_ENTRIES, 138 #if VCHIQ_ENABLE_DEBUG 139 DEBUG_SLOT_HANDLER_COUNT, 140 DEBUG_SLOT_HANDLER_LINE, 141 DEBUG_PARSE_LINE, 142 DEBUG_PARSE_HEADER, 143 DEBUG_PARSE_MSGID, 144 DEBUG_AWAIT_COMPLETION_LINE, 145 DEBUG_DEQUEUE_MESSAGE_LINE, 146 DEBUG_SERVICE_CALLBACK_LINE, 147 DEBUG_MSG_QUEUE_FULL_COUNT, 148 DEBUG_COMPLETION_QUEUE_FULL_COUNT, 149 #endif 150 DEBUG_MAX 151 }; 152 153 #if VCHIQ_ENABLE_DEBUG 154 155 #define DEBUG_INITIALISE(local) int *debug_ptr = (local)->debug; 156 #define DEBUG_TRACE(d) \ 157 do { debug_ptr[DEBUG_ ## d] = __LINE__; dsb(sy); } while (0) 158 #define DEBUG_VALUE(d, v) \ 159 do { debug_ptr[DEBUG_ ## d] = (v); dsb(sy); } while (0) 160 #define DEBUG_COUNT(d) \ 161 do { debug_ptr[DEBUG_ ## d]++; dsb(sy); } while (0) 162 163 #else /* VCHIQ_ENABLE_DEBUG */ 164 165 #define DEBUG_INITIALISE(local) 166 #define DEBUG_TRACE(d) 167 #define DEBUG_VALUE(d, v) 168 #define DEBUG_COUNT(d) 169 170 #endif /* VCHIQ_ENABLE_DEBUG */ 171 172 typedef enum { 173 VCHIQ_CONNSTATE_DISCONNECTED, 174 VCHIQ_CONNSTATE_CONNECTING, 175 VCHIQ_CONNSTATE_CONNECTED, 176 VCHIQ_CONNSTATE_PAUSING, 177 VCHIQ_CONNSTATE_PAUSE_SENT, 178 VCHIQ_CONNSTATE_PAUSED, 179 VCHIQ_CONNSTATE_RESUMING, 180 VCHIQ_CONNSTATE_PAUSE_TIMEOUT, 181 VCHIQ_CONNSTATE_RESUME_TIMEOUT 182 } VCHIQ_CONNSTATE_T; 183 184 enum { 185 VCHIQ_SRVSTATE_FREE, 186 VCHIQ_SRVSTATE_HIDDEN, 187 VCHIQ_SRVSTATE_LISTENING, 188 VCHIQ_SRVSTATE_OPENING, 189 VCHIQ_SRVSTATE_OPEN, 190 VCHIQ_SRVSTATE_OPENSYNC, 191 VCHIQ_SRVSTATE_CLOSESENT, 192 VCHIQ_SRVSTATE_CLOSERECVD, 193 VCHIQ_SRVSTATE_CLOSEWAIT, 194 VCHIQ_SRVSTATE_CLOSED 195 }; 196 197 enum { 198 VCHIQ_POLL_TERMINATE, 199 VCHIQ_POLL_REMOVE, 200 VCHIQ_POLL_TXNOTIFY, 201 VCHIQ_POLL_RXNOTIFY, 202 VCHIQ_POLL_COUNT 203 }; 204 205 typedef enum { 206 VCHIQ_BULK_TRANSMIT, 207 VCHIQ_BULK_RECEIVE 208 } VCHIQ_BULK_DIR_T; 209 210 typedef void (*VCHIQ_USERDATA_TERM_T)(void *userdata); 211 212 struct vchiq_bulk { 213 short mode; 214 short dir; 215 void *userdata; 216 void *data; 217 int size; 218 void *remote_data; 219 int remote_size; 220 int actual; 221 }; 222 223 struct vchiq_bulk_queue { 224 int local_insert; /* Where to insert the next local bulk */ 225 int remote_insert; /* Where to insert the next remote bulk (master) */ 226 int process; /* Bulk to transfer next */ 227 int remote_notify; /* Bulk to notify the remote client of next (mstr) */ 228 int remove; /* Bulk to notify the local client of, and remove, 229 ** next */ 230 struct vchiq_bulk bulks[VCHIQ_NUM_SERVICE_BULKS]; 231 }; 232 233 struct remote_event { 234 int armed; 235 int fired; 236 u32 __unused; 237 }; 238 239 typedef struct opaque_platform_state_t *VCHIQ_PLATFORM_STATE_T; 240 241 struct vchiq_slot { 242 char data[VCHIQ_SLOT_SIZE]; 243 }; 244 245 struct vchiq_slot_info { 246 /* Use two counters rather than one to avoid the need for a mutex. */ 247 short use_count; 248 short release_count; 249 }; 250 251 struct vchiq_service { 252 struct vchiq_service_base base; 253 VCHIQ_SERVICE_HANDLE_T handle; 254 unsigned int ref_count; 255 int srvstate; 256 VCHIQ_USERDATA_TERM_T userdata_term; 257 unsigned int localport; 258 unsigned int remoteport; 259 int public_fourcc; 260 int client_id; 261 char auto_close; 262 char sync; 263 char closing; 264 char trace; 265 atomic_t poll_flags; 266 short version; 267 short version_min; 268 short peer_version; 269 270 struct vchiq_state *state; 271 VCHIQ_INSTANCE_T instance; 272 273 int service_use_count; 274 275 struct vchiq_bulk_queue bulk_tx; 276 struct vchiq_bulk_queue bulk_rx; 277 278 struct completion remove_event; 279 struct completion bulk_remove_event; 280 struct mutex bulk_mutex; 281 282 struct service_stats_struct { 283 int quota_stalls; 284 int slot_stalls; 285 int bulk_stalls; 286 int error_count; 287 int ctrl_tx_count; 288 int ctrl_rx_count; 289 int bulk_tx_count; 290 int bulk_rx_count; 291 int bulk_aborted_count; 292 uint64_t ctrl_tx_bytes; 293 uint64_t ctrl_rx_bytes; 294 uint64_t bulk_tx_bytes; 295 uint64_t bulk_rx_bytes; 296 } stats; 297 }; 298 299 /* The quota information is outside struct vchiq_service so that it can 300 * be statically allocated, since for accounting reasons a service's slot 301 * usage is carried over between users of the same port number. 302 */ 303 struct vchiq_service_quota { 304 unsigned short slot_quota; 305 unsigned short slot_use_count; 306 unsigned short message_quota; 307 unsigned short message_use_count; 308 struct completion quota_event; 309 int previous_tx_index; 310 }; 311 312 struct vchiq_shared_state { 313 314 /* A non-zero value here indicates that the content is valid. */ 315 int initialised; 316 317 /* The first and last (inclusive) slots allocated to the owner. */ 318 int slot_first; 319 int slot_last; 320 321 /* The slot allocated to synchronous messages from the owner. */ 322 int slot_sync; 323 324 /* Signalling this event indicates that owner's slot handler thread 325 ** should run. */ 326 struct remote_event trigger; 327 328 /* Indicates the byte position within the stream where the next message 329 ** will be written. The least significant bits are an index into the 330 ** slot. The next bits are the index of the slot in slot_queue. */ 331 int tx_pos; 332 333 /* This event should be signalled when a slot is recycled. */ 334 struct remote_event recycle; 335 336 /* The slot_queue index where the next recycled slot will be written. */ 337 int slot_queue_recycle; 338 339 /* This event should be signalled when a synchronous message is sent. */ 340 struct remote_event sync_trigger; 341 342 /* This event should be signalled when a synchronous message has been 343 ** released. */ 344 struct remote_event sync_release; 345 346 /* A circular buffer of slot indexes. */ 347 int slot_queue[VCHIQ_MAX_SLOTS_PER_SIDE]; 348 349 /* Debugging state */ 350 int debug[DEBUG_MAX]; 351 }; 352 353 struct vchiq_slot_zero { 354 int magic; 355 short version; 356 short version_min; 357 int slot_zero_size; 358 int slot_size; 359 int max_slots; 360 int max_slots_per_side; 361 int platform_data[2]; 362 struct vchiq_shared_state master; 363 struct vchiq_shared_state slave; 364 struct vchiq_slot_info slots[VCHIQ_MAX_SLOTS]; 365 }; 366 367 struct vchiq_state { 368 int id; 369 int initialised; 370 VCHIQ_CONNSTATE_T conn_state; 371 short version_common; 372 373 struct vchiq_shared_state *local; 374 struct vchiq_shared_state *remote; 375 struct vchiq_slot *slot_data; 376 377 unsigned short default_slot_quota; 378 unsigned short default_message_quota; 379 380 /* Event indicating connect message received */ 381 struct completion connect; 382 383 /* Mutex protecting services */ 384 struct mutex mutex; 385 VCHIQ_INSTANCE_T *instance; 386 387 /* Processes incoming messages */ 388 struct task_struct *slot_handler_thread; 389 390 /* Processes recycled slots */ 391 struct task_struct *recycle_thread; 392 393 /* Processes synchronous messages */ 394 struct task_struct *sync_thread; 395 396 /* Local implementation of the trigger remote event */ 397 wait_queue_head_t trigger_event; 398 399 /* Local implementation of the recycle remote event */ 400 wait_queue_head_t recycle_event; 401 402 /* Local implementation of the sync trigger remote event */ 403 wait_queue_head_t sync_trigger_event; 404 405 /* Local implementation of the sync release remote event */ 406 wait_queue_head_t sync_release_event; 407 408 char *tx_data; 409 char *rx_data; 410 struct vchiq_slot_info *rx_info; 411 412 struct mutex slot_mutex; 413 414 struct mutex recycle_mutex; 415 416 struct mutex sync_mutex; 417 418 struct mutex bulk_transfer_mutex; 419 420 /* Indicates the byte position within the stream from where the next 421 ** message will be read. The least significant bits are an index into 422 ** the slot.The next bits are the index of the slot in 423 ** remote->slot_queue. */ 424 int rx_pos; 425 426 /* A cached copy of local->tx_pos. Only write to local->tx_pos, and read 427 from remote->tx_pos. */ 428 int local_tx_pos; 429 430 /* The slot_queue index of the slot to become available next. */ 431 int slot_queue_available; 432 433 /* A flag to indicate if any poll has been requested */ 434 int poll_needed; 435 436 /* Ths index of the previous slot used for data messages. */ 437 int previous_data_index; 438 439 /* The number of slots occupied by data messages. */ 440 unsigned short data_use_count; 441 442 /* The maximum number of slots to be occupied by data messages. */ 443 unsigned short data_quota; 444 445 /* An array of bit sets indicating which services must be polled. */ 446 atomic_t poll_services[BITSET_SIZE(VCHIQ_MAX_SERVICES)]; 447 448 /* The number of the first unused service */ 449 int unused_service; 450 451 /* Signalled when a free slot becomes available. */ 452 struct completion slot_available_event; 453 454 struct completion slot_remove_event; 455 456 /* Signalled when a free data slot becomes available. */ 457 struct completion data_quota_event; 458 459 struct state_stats_struct { 460 int slot_stalls; 461 int data_stalls; 462 int ctrl_tx_count; 463 int ctrl_rx_count; 464 int error_count; 465 } stats; 466 467 struct vchiq_service *services[VCHIQ_MAX_SERVICES]; 468 struct vchiq_service_quota service_quotas[VCHIQ_MAX_SERVICES]; 469 struct vchiq_slot_info slot_info[VCHIQ_MAX_SLOTS]; 470 471 VCHIQ_PLATFORM_STATE_T platform_state; 472 }; 473 474 struct bulk_waiter { 475 struct vchiq_bulk *bulk; 476 struct completion event; 477 int actual; 478 }; 479 480 extern spinlock_t bulk_waiter_spinlock; 481 482 extern int vchiq_core_log_level; 483 extern int vchiq_core_msg_log_level; 484 extern int vchiq_sync_log_level; 485 486 extern struct vchiq_state *vchiq_states[VCHIQ_MAX_STATES]; 487 488 extern const char * 489 get_conn_state_name(VCHIQ_CONNSTATE_T conn_state); 490 491 extern struct vchiq_slot_zero * 492 vchiq_init_slots(void *mem_base, int mem_size); 493 494 extern VCHIQ_STATUS_T 495 vchiq_init_state(struct vchiq_state *state, struct vchiq_slot_zero *slot_zero); 496 497 extern VCHIQ_STATUS_T 498 vchiq_connect_internal(struct vchiq_state *state, VCHIQ_INSTANCE_T instance); 499 500 extern struct vchiq_service * 501 vchiq_add_service_internal(struct vchiq_state *state, 502 const struct vchiq_service_params *params, 503 int srvstate, VCHIQ_INSTANCE_T instance, 504 VCHIQ_USERDATA_TERM_T userdata_term); 505 506 extern VCHIQ_STATUS_T 507 vchiq_open_service_internal(struct vchiq_service *service, int client_id); 508 509 extern VCHIQ_STATUS_T 510 vchiq_close_service_internal(struct vchiq_service *service, int close_recvd); 511 512 extern void 513 vchiq_terminate_service_internal(struct vchiq_service *service); 514 515 extern void 516 vchiq_free_service_internal(struct vchiq_service *service); 517 518 extern VCHIQ_STATUS_T 519 vchiq_shutdown_internal(struct vchiq_state *state, VCHIQ_INSTANCE_T instance); 520 521 extern VCHIQ_STATUS_T 522 vchiq_pause_internal(struct vchiq_state *state); 523 524 extern VCHIQ_STATUS_T 525 vchiq_resume_internal(struct vchiq_state *state); 526 527 extern void 528 remote_event_pollall(struct vchiq_state *state); 529 530 extern VCHIQ_STATUS_T 531 vchiq_bulk_transfer(VCHIQ_SERVICE_HANDLE_T handle, void *offset, int size, 532 void *userdata, VCHIQ_BULK_MODE_T mode, 533 VCHIQ_BULK_DIR_T dir); 534 535 extern void 536 vchiq_dump_state(void *dump_context, struct vchiq_state *state); 537 538 extern void 539 vchiq_dump_service_state(void *dump_context, struct vchiq_service *service); 540 541 extern void 542 vchiq_loud_error_header(void); 543 544 extern void 545 vchiq_loud_error_footer(void); 546 547 extern void 548 request_poll(struct vchiq_state *state, struct vchiq_service *service, 549 int poll_type); 550 551 static inline struct vchiq_service * 552 handle_to_service(VCHIQ_SERVICE_HANDLE_T handle) 553 { 554 struct vchiq_state *state = vchiq_states[(handle / VCHIQ_MAX_SERVICES) & 555 (VCHIQ_MAX_STATES - 1)]; 556 if (!state) 557 return NULL; 558 559 return state->services[handle & (VCHIQ_MAX_SERVICES - 1)]; 560 } 561 562 extern struct vchiq_service * 563 find_service_by_handle(VCHIQ_SERVICE_HANDLE_T handle); 564 565 extern struct vchiq_service * 566 find_service_by_port(struct vchiq_state *state, int localport); 567 568 extern struct vchiq_service * 569 find_service_for_instance(VCHIQ_INSTANCE_T instance, 570 VCHIQ_SERVICE_HANDLE_T handle); 571 572 extern struct vchiq_service * 573 find_closed_service_for_instance(VCHIQ_INSTANCE_T instance, 574 VCHIQ_SERVICE_HANDLE_T handle); 575 576 extern struct vchiq_service * 577 next_service_by_instance(struct vchiq_state *state, VCHIQ_INSTANCE_T instance, 578 int *pidx); 579 580 extern void 581 lock_service(struct vchiq_service *service); 582 583 extern void 584 unlock_service(struct vchiq_service *service); 585 586 /* The following functions are called from vchiq_core, and external 587 ** implementations must be provided. */ 588 589 extern VCHIQ_STATUS_T 590 vchiq_prepare_bulk_data(struct vchiq_bulk *bulk, void *offset, int size, 591 int dir); 592 593 extern void 594 vchiq_complete_bulk(struct vchiq_bulk *bulk); 595 596 extern void 597 remote_event_signal(struct remote_event *event); 598 599 void 600 vchiq_platform_check_suspend(struct vchiq_state *state); 601 602 extern void 603 vchiq_platform_paused(struct vchiq_state *state); 604 605 extern VCHIQ_STATUS_T 606 vchiq_platform_resume(struct vchiq_state *state); 607 608 extern void 609 vchiq_platform_resumed(struct vchiq_state *state); 610 611 extern void 612 vchiq_dump(void *dump_context, const char *str, int len); 613 614 extern void 615 vchiq_dump_platform_state(void *dump_context); 616 617 extern void 618 vchiq_dump_platform_instances(void *dump_context); 619 620 extern void 621 vchiq_dump_platform_service_state(void *dump_context, 622 struct vchiq_service *service); 623 624 extern VCHIQ_STATUS_T 625 vchiq_use_service_internal(struct vchiq_service *service); 626 627 extern VCHIQ_STATUS_T 628 vchiq_release_service_internal(struct vchiq_service *service); 629 630 extern void 631 vchiq_on_remote_use(struct vchiq_state *state); 632 633 extern void 634 vchiq_on_remote_release(struct vchiq_state *state); 635 636 extern VCHIQ_STATUS_T 637 vchiq_platform_init_state(struct vchiq_state *state); 638 639 extern VCHIQ_STATUS_T 640 vchiq_check_service(struct vchiq_service *service); 641 642 extern void 643 vchiq_on_remote_use_active(struct vchiq_state *state); 644 645 extern VCHIQ_STATUS_T 646 vchiq_send_remote_use(struct vchiq_state *state); 647 648 extern VCHIQ_STATUS_T 649 vchiq_send_remote_release(struct vchiq_state *state); 650 651 extern VCHIQ_STATUS_T 652 vchiq_send_remote_use_active(struct vchiq_state *state); 653 654 extern void 655 vchiq_platform_conn_state_changed(struct vchiq_state *state, 656 VCHIQ_CONNSTATE_T oldstate, 657 VCHIQ_CONNSTATE_T newstate); 658 659 extern void 660 vchiq_platform_handle_timeout(struct vchiq_state *state); 661 662 extern void 663 vchiq_set_conn_state(struct vchiq_state *state, VCHIQ_CONNSTATE_T newstate); 664 665 extern void 666 vchiq_log_dump_mem(const char *label, uint32_t addr, const void *voidMem, 667 size_t numBytes); 668 669 #endif 670