| /* |
| <:copyright-BRCM:2016:DUAL/GPL:standard |
| |
| Broadcom Proprietary and Confidential.(c) 2016 Broadcom |
| All Rights Reserved |
| |
| Unless you and Broadcom execute a separate written software license |
| agreement governing use of this software, this software is licensed |
| to you under the terms of the GNU General Public License version 2 |
| (the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php, |
| with the following added to such license: |
| |
| As a special exception, the copyright holders of this software give |
| you permission to link this software with independent modules, and |
| to copy and distribute the resulting executable under terms of your |
| choice, provided that you also meet, for each linked independent |
| module, the terms and conditions of the license of that module. |
| An independent module is a module which is not derived from this |
| software. The special exception does not apply to any modifications |
| of the software. |
| |
| Not withstanding the above, under no circumstances may you combine |
| this software in any way with any other Broadcom software provided |
| under a license other than the GPL, without Broadcom's express prior |
| written consent. |
| |
| :> |
| */ |
| |
| #ifndef BCMTR_PCIE_H_ |
| #define BCMTR_PCIE_H_ |
| |
| #include "bcmos_system.h" |
| |
| #define DDR_PACKET_LOW_INDEX 0 |
| #define DDR_PACKET_HIGH_INDEX 7 |
| #define PCI_PACKET_LOW_INDEX 1 |
| #define PCI_PACKET_HIGH_INDEX 2 |
| |
| typedef struct |
| { |
| uint32_t rx_counter; |
| uint32_t tx_counter; |
| uint32_t rx_done_isr_counter; |
| uint32_t rx_err_isr_counter; |
| uint32_t tx_done_isr_counter; |
| uint32_t tx_err_isr_counter; |
| uint32_t rx_pcie_empty_counter; |
| uint32_t tx_pcie_full_counter; |
| } bcm_pcied_stat; |
| |
| typedef struct |
| { |
| unsigned long pcie_reg_base; |
| uint32_t rx_irq; |
| uint32_t device; |
| uint32_t rx_done_num; |
| uint32_t rx_err_num; |
| uint32_t tx_done_num; |
| uint32_t tx_err_num; |
| } bcm_pcied_isr_data; |
| |
| /** Initialize PCIe low level transport module |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| #ifdef IN_BAND |
| bcmos_errno bcmtr_pcie_init(uint8_t device, bcmos_ipv4_address ip_address, uint16_t udp_port); |
| #else |
| bcmos_errno bcmtr_pcie_init(uint8_t max_devices); |
| #endif |
| |
| /** Cleanup PCIe low level transport module |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| void bcmtr_pcie_exit(void); |
| |
| /** PCIe pre-connect configuration parameters */ |
| typedef struct |
| { |
| uint32_t txq_size; /**< Transmit queue size */ |
| uint32_t rxq_size; /**< Receive queue size */ |
| uint32_t max_mtu; /**< Max MTU size */ |
| uint32_t rx_irq; /**< Rx interrupt number */ |
| unsigned long pcie_reg_base; /**< Maple PCIe register block address in host addrss space */ |
| unsigned long ddr_win_base; /**< Maple DDR address in host addrss space */ |
| } bcmtr_pcie_pre_connect_cfg; |
| |
| /** PCIe pre-connect data - information returned by bcmtr_pcie_pre_connect(). |
| * Device control driver should store data from this structure |
| * in the boot record in Maple SRAM |
| */ |
| typedef struct bcmtr_pcie_opaque_data bcmtr_pcie_opaque_data; |
| |
| /** Prepare to connect |
| * On Maple returns into opaque_data pointers of the |
| * transmit and receive PacketDescriptors |
| * On Host opaque_data is NULL |
| * \param[in] device Maple device index |
| * \param[in] cfg Connection configuration |
| * \param[out] opaque_data Pointer to memory block |
| * where pcie driver put opaque data to be conveyed to the |
| * other side |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_pre_connect(uint8_t device, const bcmtr_pcie_pre_connect_cfg *cfg, |
| bcmtr_pcie_opaque_data *data); |
| |
| /** Connect |
| * On Maple opaque_data is NULL |
| * On Host opaque_data contains the pointers to PDs in |
| * Maple |
| * \param[in] device Maple device index |
| * \param[in] opaque_data Pointer to opaque data block |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_connect(uint8_t device, const bcmtr_pcie_opaque_data *data); |
| |
| /** Disconnect. All buffers are released |
| * \param[in] device Maple device index |
| * \param[in] opaque_data Pointer to opaque data block |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_disconnect(uint8_t device); |
| |
| /* |
| * Receive callback registration. |
| * Attention PCIe driver implementer!! |
| * Received packets must stay in the queue until receive callback is registered. |
| */ |
| |
| /** PCIe interface interrupt receive callback */ |
| typedef void (*f_bcmtr_int)(uint8_t device); |
| |
| /** Register receive callback |
| * \param[in] rx_isr Interrupt Receive callback |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_rx_irq_cblk_register(f_bcmtr_int user_rx_isr_clbk); |
| |
| /** Unregister receive callback. |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_rx_irq_cblk_unregister(void); |
| |
| /** Register transmit completion interrupt callback |
| * \param[in] tx_isr Transfer completed interrupt callback |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_tx_irq_cblk_register(f_bcmtr_int user_tx_isr_clbk); |
| |
| /** Unregister transmit completed interrupt callback. |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_tx_irq_cblk_unregister(void); |
| |
| /** Tx done callback */ |
| typedef void (*f_bcmtr_done)(uint8_t device, bcmos_buf *buf); |
| |
| /** Register buffer transmit completion callback |
| * \param[in] tx_done Transfer completed callback |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_tx_done_cblk_register(f_bcmtr_done tx_done_cb); |
| |
| /** Unregister buffer transmit completion callback |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_tx_done_cblk_unregister(void); |
| |
| /** Send buffer to the peer |
| * \param[in] device Maple device index |
| * \param[in] channel Channel id (opaque to the bcmtr_pcie driver) |
| * \param[in] buf Buffer to be transferred |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_send(uint8_t device, uint8_t channel, bcmos_buf *buf); |
| |
| /** Reclaim buffers that have already been transmitted |
| * \param[in] device Maple device index |
| * \returns: number of reclaimed TX buffers >= 0 or bcmos_errno error code <0 |
| */ |
| int bcmtr_pcie_tx_collect(uint8_t device); |
| |
| /** Fetch received buffer from h/w queue |
| * \param[in] device Maple device index |
| * \param[out] channel message channel from the BD |
| * \param[out] buf pointer to network buffer containing the received packet |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_receive(uint8_t device, uint8_t *channel, bcmos_buf **buf); |
| |
| /** Enable DMA_RX interrupt |
| * \param[in] device Maple device index |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_rxint_enable(uint8_t device); |
| |
| /** Disable DMA_RX interrupt |
| * \param[in] device Maple device index |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_rxint_disable(uint8_t device); |
| |
| /** Clear DMA_RX interrupt |
| * \param[in] device Maple device index |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_rxint_clear(uint8_t device); |
| |
| /** Enable "TX handled" interrupt |
| * \param[in] device Maple device index |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_txint_enable(uint8_t device); |
| |
| /** Disable "TX handled" interrupt |
| * \param[in] device Maple device index |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_txint_disable(uint8_t device); |
| |
| /** Clear "TX handled" interrupt |
| * \param[in] device Maple device index |
| * \returns: 0 in case of success or error code < 0 |
| */ |
| bcmos_errno bcmtr_pcie_txint_clear(uint8_t device); |
| |
| /** Returns statistics |
| * \param[in] device Maple device index |
| * \param[in] clear if set, clear statistics, otherwise |
| * accumulate |
| */ |
| bcmos_errno bcmtr_pcie_get_statistics(uint8_t device, uint32_t clear, bcm_pcied_stat *stat); |
| |
| /** Dump data base |
| * \param[in] output NULL(will print to stdout) or pointer to |
| * buffer |
| * \param[in] device Maple device index |
| * \param[in] start index of the start entry in ring, -1 |
| * means current |
| * \param[in] number_of_entries how many entries from the |
| * start |
| * \returns: 0 if output is NULL or buffer length |
| */ |
| bcmos_errno bcmtr_pcie_tx_dump(char *output, uint8_t device, int32_t start, int32_t number_of_entries); |
| bcmos_errno bcmtr_pcie_rx_dump(char *output, uint8_t device, int32_t start, int32_t number_of_entries); |
| |
| |
| #endif /* BCMTR_PCIE_H_ */ |