1 /* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ 2 /* Copyright (c) 2010-2012 Broadcom. All rights reserved. */ 3 4 #ifndef VCHI_CFG_H_ 5 #define VCHI_CFG_H_ 6 7 /**************************************************************************************** 8 * Defines in this first section are part of the VCHI API and may be examined by VCHI 9 * services. 10 ***************************************************************************************/ 11 12 /* Required alignment of base addresses for bulk transfer, if unaligned transfers are not enabled */ 13 /* Really determined by the message driver, and should be available from a run-time call. */ 14 #ifndef VCHI_BULK_ALIGN 15 # if __VCCOREVER__ >= 0x04000000 16 # define VCHI_BULK_ALIGN 32 // Allows for the need to do cache cleans 17 # else 18 # define VCHI_BULK_ALIGN 16 19 # endif 20 #endif 21 22 /* Required length multiple for bulk transfers, if unaligned transfers are not enabled */ 23 /* May be less than or greater than VCHI_BULK_ALIGN */ 24 /* Really determined by the message driver, and should be available from a run-time call. */ 25 #ifndef VCHI_BULK_GRANULARITY 26 # if __VCCOREVER__ >= 0x04000000 27 # define VCHI_BULK_GRANULARITY 32 // Allows for the need to do cache cleans 28 # else 29 # define VCHI_BULK_GRANULARITY 16 30 # endif 31 #endif 32 33 /* The largest possible message to be queued with vchi_msg_queue. */ 34 #ifndef VCHI_MAX_MSG_SIZE 35 # if defined VCHI_LOCAL_HOST_PORT 36 # define VCHI_MAX_MSG_SIZE 16384 // makes file transfers fast, but should they be using bulk? 37 # else 38 # define VCHI_MAX_MSG_SIZE 4096 // NOTE: THIS MUST BE LARGER THAN OR EQUAL TO THE SIZE OF THE KHRONOS MERGE BUFFER!! 39 # endif 40 #endif 41 42 /****************************************************************************************** 43 * Defines below are system configuration options, and should not be used by VCHI services. 44 *****************************************************************************************/ 45 46 /* How many connections can we support? A localhost implementation uses 2 connections, 47 * 1 for host-app, 1 for VMCS, and these are hooked together by a loopback MPHI VCFW 48 * driver. */ 49 #ifndef VCHI_MAX_NUM_CONNECTIONS 50 # define VCHI_MAX_NUM_CONNECTIONS 3 51 #endif 52 53 /* How many services can we open per connection? Extending this doesn't cost processing time, just a small 54 * amount of static memory. */ 55 #ifndef VCHI_MAX_SERVICES_PER_CONNECTION 56 # define VCHI_MAX_SERVICES_PER_CONNECTION 36 57 #endif 58 59 /* Adjust if using a message driver that supports more logical TX channels */ 60 #ifndef VCHI_MAX_BULK_TX_CHANNELS_PER_CONNECTION 61 # define VCHI_MAX_BULK_TX_CHANNELS_PER_CONNECTION 9 // 1 MPHI + 8 CCP2 logical channels 62 #endif 63 64 /* Adjust if using a message driver that supports more logical RX channels */ 65 #ifndef VCHI_MAX_BULK_RX_CHANNELS_PER_CONNECTION 66 # define VCHI_MAX_BULK_RX_CHANNELS_PER_CONNECTION 1 // 1 MPHI 67 #endif 68 69 /* How many receive slots do we use. This times VCHI_MAX_MSG_SIZE gives the effective 70 * receive queue space, less message headers. */ 71 #ifndef VCHI_NUM_READ_SLOTS 72 # if defined(VCHI_LOCAL_HOST_PORT) 73 # define VCHI_NUM_READ_SLOTS 4 74 # else 75 # define VCHI_NUM_READ_SLOTS 48 76 # endif 77 #endif 78 79 /* Do we utilise overrun facility for receive message slots? Can aid peer transmit 80 * performance. Only define on VideoCore end, talking to host. 81 */ 82 //#define VCHI_MSG_RX_OVERRUN 83 84 /* How many transmit slots do we use. Generally don't need many, as the hardware driver 85 * underneath VCHI will usually have its own buffering. */ 86 #ifndef VCHI_NUM_WRITE_SLOTS 87 # define VCHI_NUM_WRITE_SLOTS 4 88 #endif 89 90 /* If a service has held or queued received messages in VCHI_XOFF_THRESHOLD or more slots, 91 * then it's taking up too much buffer space, and the peer service will be told to stop 92 * transmitting with an XOFF message. For this to be effective, the VCHI_NUM_READ_SLOTS 93 * needs to be considerably bigger than VCHI_NUM_WRITE_SLOTS, or the transmit latency 94 * is too high. */ 95 #ifndef VCHI_XOFF_THRESHOLD 96 # define VCHI_XOFF_THRESHOLD (VCHI_NUM_READ_SLOTS / 2) 97 #endif 98 99 /* After we've sent an XOFF, the peer will be told to resume transmission once the local 100 * service has dequeued/released enough messages that it's now occupying 101 * VCHI_XON_THRESHOLD slots or fewer. */ 102 #ifndef VCHI_XON_THRESHOLD 103 # define VCHI_XON_THRESHOLD (VCHI_NUM_READ_SLOTS / 4) 104 #endif 105 106 /* A size below which a bulk transfer omits the handshake completely and always goes 107 * via the message channel, if bulk auxiliary is being sent on that service. (The user 108 * can guarantee this by enabling unaligned transmits). 109 * Not API. */ 110 #ifndef VCHI_MIN_BULK_SIZE 111 # define VCHI_MIN_BULK_SIZE (VCHI_MAX_MSG_SIZE / 2 < 4096 ? VCHI_MAX_MSG_SIZE / 2 : 4096) 112 #endif 113 114 /* Maximum size of bulk transmission chunks, for each interface type. A trade-off between 115 * speed and latency; the smaller the chunk size the better change of messages and other 116 * bulk transmissions getting in when big bulk transfers are happening. Set to 0 to not 117 * break transmissions into chunks. 118 */ 119 #ifndef VCHI_MAX_BULK_CHUNK_SIZE_MPHI 120 # define VCHI_MAX_BULK_CHUNK_SIZE_MPHI (16 * 1024) 121 #endif 122 123 /* NB Chunked CCP2 transmissions violate the letter of the CCP2 spec by using "JPEG8" mode 124 * with multiple-line frames. Only use if the receiver can cope. */ 125 #ifndef VCHI_MAX_BULK_CHUNK_SIZE_CCP2 126 # define VCHI_MAX_BULK_CHUNK_SIZE_CCP2 0 127 #endif 128 129 /* How many TX messages can we have pending in our transmit slots. Once exhausted, 130 * vchi_msg_queue will be blocked. */ 131 #ifndef VCHI_TX_MSG_QUEUE_SIZE 132 # define VCHI_TX_MSG_QUEUE_SIZE 256 133 #endif 134 135 /* How many RX messages can we have parsed in the receive slots. Once exhausted, parsing 136 * will be suspended until older messages are dequeued/released. */ 137 #ifndef VCHI_RX_MSG_QUEUE_SIZE 138 # define VCHI_RX_MSG_QUEUE_SIZE 256 139 #endif 140 141 /* Really should be able to cope if we run out of received message descriptors, by 142 * suspending parsing as the comment above says, but we don't. This sweeps the issue 143 * under the carpet. */ 144 #if VCHI_RX_MSG_QUEUE_SIZE < (VCHI_MAX_MSG_SIZE/16 + 1) * VCHI_NUM_READ_SLOTS 145 # undef VCHI_RX_MSG_QUEUE_SIZE 146 # define VCHI_RX_MSG_QUEUE_SIZE ((VCHI_MAX_MSG_SIZE/16 + 1) * VCHI_NUM_READ_SLOTS) 147 #endif 148 149 /* How many bulk transmits can we have pending. Once exhausted, vchi_bulk_queue_transmit 150 * will be blocked. */ 151 #ifndef VCHI_TX_BULK_QUEUE_SIZE 152 # define VCHI_TX_BULK_QUEUE_SIZE 64 153 #endif 154 155 /* How many bulk receives can we have pending. Once exhausted, vchi_bulk_queue_receive 156 * will be blocked. */ 157 #ifndef VCHI_RX_BULK_QUEUE_SIZE 158 # define VCHI_RX_BULK_QUEUE_SIZE 64 159 #endif 160 161 /* A limit on how many outstanding bulk requests we expect the peer to give us. If 162 * the peer asks for more than this, VCHI will fail and assert. The number is determined 163 * by the peer's hardware - it's the number of outstanding requests that can be queued 164 * on all bulk channels. VC3's MPHI peripheral allows 16. */ 165 #ifndef VCHI_MAX_PEER_BULK_REQUESTS 166 # define VCHI_MAX_PEER_BULK_REQUESTS 32 167 #endif 168 169 /* Define VCHI_CCP2TX_MANUAL_POWER if the host tells us when to turn the CCP2 170 * transmitter on and off. 171 */ 172 /*#define VCHI_CCP2TX_MANUAL_POWER*/ 173 174 #ifndef VCHI_CCP2TX_MANUAL_POWER 175 176 /* Timeout (in milliseconds) for putting the CCP2TX interface into IDLE state. Set 177 * negative for no IDLE. 178 */ 179 # ifndef VCHI_CCP2TX_IDLE_TIMEOUT 180 # define VCHI_CCP2TX_IDLE_TIMEOUT 5 181 # endif 182 183 /* Timeout (in milliseconds) for putting the CCP2TX interface into OFF state. Set 184 * negative for no OFF. 185 */ 186 # ifndef VCHI_CCP2TX_OFF_TIMEOUT 187 # define VCHI_CCP2TX_OFF_TIMEOUT 1000 188 # endif 189 190 #endif /* VCHI_CCP2TX_MANUAL_POWER */ 191 192 #endif /* VCHI_CFG_H_ */ 193 194 /****************************** End of file **********************************/