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