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