| /** |
| * Copyright (c) 2010-2012 Broadcom. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions, and the following disclaimer, |
| * without modification. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. The names of the above-listed copyright holders may not be used |
| * to endorse or promote products derived from this software without |
| * specific prior written permission. |
| * |
| * ALTERNATIVELY, this software may be distributed under the terms of the |
| * GNU General Public License ("GPL") version 2, as published by the Free |
| * Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS |
| * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #ifndef VCHI_CFG_H_ |
| #define VCHI_CFG_H_ |
| |
| /**************************************************************************************** |
| * Defines in this first section are part of the VCHI API and may be examined by VCHI |
| * services. |
| ***************************************************************************************/ |
| |
| /* Required alignment of base addresses for bulk transfer, if unaligned transfers are not enabled */ |
| /* Really determined by the message driver, and should be available from a run-time call. */ |
| #ifndef VCHI_BULK_ALIGN |
| # if __VCCOREVER__ >= 0x04000000 |
| # define VCHI_BULK_ALIGN 32 // Allows for the need to do cache cleans |
| # else |
| # define VCHI_BULK_ALIGN 16 |
| # endif |
| #endif |
| |
| /* Required length multiple for bulk transfers, if unaligned transfers are not enabled */ |
| /* May be less than or greater than VCHI_BULK_ALIGN */ |
| /* Really determined by the message driver, and should be available from a run-time call. */ |
| #ifndef VCHI_BULK_GRANULARITY |
| # if __VCCOREVER__ >= 0x04000000 |
| # define VCHI_BULK_GRANULARITY 32 // Allows for the need to do cache cleans |
| # else |
| # define VCHI_BULK_GRANULARITY 16 |
| # endif |
| #endif |
| |
| /* The largest possible message to be queued with vchi_msg_queue. */ |
| #ifndef VCHI_MAX_MSG_SIZE |
| # if defined VCHI_LOCAL_HOST_PORT |
| # define VCHI_MAX_MSG_SIZE 16384 // makes file transfers fast, but should they be using bulk? |
| # else |
| # define VCHI_MAX_MSG_SIZE 4096 // NOTE: THIS MUST BE LARGER THAN OR EQUAL TO THE SIZE OF THE KHRONOS MERGE BUFFER!! |
| # endif |
| #endif |
| |
| /****************************************************************************************** |
| * Defines below are system configuration options, and should not be used by VCHI services. |
| *****************************************************************************************/ |
| |
| /* How many connections can we support? A localhost implementation uses 2 connections, |
| * 1 for host-app, 1 for VMCS, and these are hooked together by a loopback MPHI VCFW |
| * driver. */ |
| #ifndef VCHI_MAX_NUM_CONNECTIONS |
| # define VCHI_MAX_NUM_CONNECTIONS 3 |
| #endif |
| |
| /* How many services can we open per connection? Extending this doesn't cost processing time, just a small |
| * amount of static memory. */ |
| #ifndef VCHI_MAX_SERVICES_PER_CONNECTION |
| # define VCHI_MAX_SERVICES_PER_CONNECTION 36 |
| #endif |
| |
| /* Adjust if using a message driver that supports more logical TX channels */ |
| #ifndef VCHI_MAX_BULK_TX_CHANNELS_PER_CONNECTION |
| # define VCHI_MAX_BULK_TX_CHANNELS_PER_CONNECTION 9 // 1 MPHI + 8 CCP2 logical channels |
| #endif |
| |
| /* Adjust if using a message driver that supports more logical RX channels */ |
| #ifndef VCHI_MAX_BULK_RX_CHANNELS_PER_CONNECTION |
| # define VCHI_MAX_BULK_RX_CHANNELS_PER_CONNECTION 1 // 1 MPHI |
| #endif |
| |
| /* How many receive slots do we use. This times VCHI_MAX_MSG_SIZE gives the effective |
| * receive queue space, less message headers. */ |
| #ifndef VCHI_NUM_READ_SLOTS |
| # if defined(VCHI_LOCAL_HOST_PORT) |
| # define VCHI_NUM_READ_SLOTS 4 |
| # else |
| # define VCHI_NUM_READ_SLOTS 48 |
| # endif |
| #endif |
| |
| /* Do we utilise overrun facility for receive message slots? Can aid peer transmit |
| * performance. Only define on VideoCore end, talking to host. |
| */ |
| //#define VCHI_MSG_RX_OVERRUN |
| |
| /* How many transmit slots do we use. Generally don't need many, as the hardware driver |
| * underneath VCHI will usually have its own buffering. */ |
| #ifndef VCHI_NUM_WRITE_SLOTS |
| # define VCHI_NUM_WRITE_SLOTS 4 |
| #endif |
| |
| /* If a service has held or queued received messages in VCHI_XOFF_THRESHOLD or more slots, |
| * then it's taking up too much buffer space, and the peer service will be told to stop |
| * transmitting with an XOFF message. For this to be effective, the VCHI_NUM_READ_SLOTS |
| * needs to be considerably bigger than VCHI_NUM_WRITE_SLOTS, or the transmit latency |
| * is too high. */ |
| #ifndef VCHI_XOFF_THRESHOLD |
| # define VCHI_XOFF_THRESHOLD (VCHI_NUM_READ_SLOTS / 2) |
| #endif |
| |
| /* After we've sent an XOFF, the peer will be told to resume transmission once the local |
| * service has dequeued/released enough messages that it's now occupying |
| * VCHI_XON_THRESHOLD slots or fewer. */ |
| #ifndef VCHI_XON_THRESHOLD |
| # define VCHI_XON_THRESHOLD (VCHI_NUM_READ_SLOTS / 4) |
| #endif |
| |
| /* A size below which a bulk transfer omits the handshake completely and always goes |
| * via the message channel, if bulk auxiliary is being sent on that service. (The user |
| * can guarantee this by enabling unaligned transmits). |
| * Not API. */ |
| #ifndef VCHI_MIN_BULK_SIZE |
| # define VCHI_MIN_BULK_SIZE ( VCHI_MAX_MSG_SIZE / 2 < 4096 ? VCHI_MAX_MSG_SIZE / 2 : 4096 ) |
| #endif |
| |
| /* Maximum size of bulk transmission chunks, for each interface type. A trade-off between |
| * speed and latency; the smaller the chunk size the better change of messages and other |
| * bulk transmissions getting in when big bulk transfers are happening. Set to 0 to not |
| * break transmissions into chunks. |
| */ |
| #ifndef VCHI_MAX_BULK_CHUNK_SIZE_MPHI |
| # define VCHI_MAX_BULK_CHUNK_SIZE_MPHI (16 * 1024) |
| #endif |
| |
| /* NB Chunked CCP2 transmissions violate the letter of the CCP2 spec by using "JPEG8" mode |
| * with multiple-line frames. Only use if the receiver can cope. */ |
| #ifndef VCHI_MAX_BULK_CHUNK_SIZE_CCP2 |
| # define VCHI_MAX_BULK_CHUNK_SIZE_CCP2 0 |
| #endif |
| |
| /* How many TX messages can we have pending in our transmit slots. Once exhausted, |
| * vchi_msg_queue will be blocked. */ |
| #ifndef VCHI_TX_MSG_QUEUE_SIZE |
| # define VCHI_TX_MSG_QUEUE_SIZE 256 |
| #endif |
| |
| /* How many RX messages can we have parsed in the receive slots. Once exhausted, parsing |
| * will be suspended until older messages are dequeued/released. */ |
| #ifndef VCHI_RX_MSG_QUEUE_SIZE |
| # define VCHI_RX_MSG_QUEUE_SIZE 256 |
| #endif |
| |
| /* Really should be able to cope if we run out of received message descriptors, by |
| * suspending parsing as the comment above says, but we don't. This sweeps the issue |
| * under the carpet. */ |
| #if VCHI_RX_MSG_QUEUE_SIZE < (VCHI_MAX_MSG_SIZE/16 + 1) * VCHI_NUM_READ_SLOTS |
| # undef VCHI_RX_MSG_QUEUE_SIZE |
| # define VCHI_RX_MSG_QUEUE_SIZE ((VCHI_MAX_MSG_SIZE/16 + 1) * VCHI_NUM_READ_SLOTS) |
| #endif |
| |
| /* How many bulk transmits can we have pending. Once exhausted, vchi_bulk_queue_transmit |
| * will be blocked. */ |
| #ifndef VCHI_TX_BULK_QUEUE_SIZE |
| # define VCHI_TX_BULK_QUEUE_SIZE 64 |
| #endif |
| |
| /* How many bulk receives can we have pending. Once exhausted, vchi_bulk_queue_receive |
| * will be blocked. */ |
| #ifndef VCHI_RX_BULK_QUEUE_SIZE |
| # define VCHI_RX_BULK_QUEUE_SIZE 64 |
| #endif |
| |
| /* A limit on how many outstanding bulk requests we expect the peer to give us. If |
| * the peer asks for more than this, VCHI will fail and assert. The number is determined |
| * by the peer's hardware - it's the number of outstanding requests that can be queued |
| * on all bulk channels. VC3's MPHI peripheral allows 16. */ |
| #ifndef VCHI_MAX_PEER_BULK_REQUESTS |
| # define VCHI_MAX_PEER_BULK_REQUESTS 32 |
| #endif |
| |
| /* Define VCHI_CCP2TX_MANUAL_POWER if the host tells us when to turn the CCP2 |
| * transmitter on and off. |
| */ |
| /*#define VCHI_CCP2TX_MANUAL_POWER*/ |
| |
| #ifndef VCHI_CCP2TX_MANUAL_POWER |
| |
| /* Timeout (in milliseconds) for putting the CCP2TX interface into IDLE state. Set |
| * negative for no IDLE. |
| */ |
| # ifndef VCHI_CCP2TX_IDLE_TIMEOUT |
| # define VCHI_CCP2TX_IDLE_TIMEOUT 5 |
| # endif |
| |
| /* Timeout (in milliseconds) for putting the CCP2TX interface into OFF state. Set |
| * negative for no OFF. |
| */ |
| # ifndef VCHI_CCP2TX_OFF_TIMEOUT |
| # define VCHI_CCP2TX_OFF_TIMEOUT 1000 |
| # endif |
| |
| #endif /* VCHI_CCP2TX_MANUAL_POWER */ |
| |
| #endif /* VCHI_CFG_H_ */ |
| |
| /****************************** End of file **********************************/ |
