| /* SPDX-License-Identifier: GPL-2.0+ */ | |
| #ifndef _FDMA_API_H_ | |
| #define _FDMA_API_H_ | |
| #include <linux/bits.h> | |
| #include <linux/etherdevice.h> | |
| #include <linux/types.h> | |
| /* This provides a common set of functions and data structures for interacting | |
| * with the Frame DMA engine on multiple Microchip switchcores. | |
| * | |
| * Frame DMA DCB format: | |
| * | |
| * +---------------------------+ | |
| * | Next Ptr | | |
| * +---------------------------+ | |
| * | Reserved | Info | | |
| * +---------------------------+ | |
| * | Data0 Ptr | | |
| * +---------------------------+ | |
| * | Reserved | Status0 | | |
| * +---------------------------+ | |
| * | Data1 Ptr | | |
| * +---------------------------+ | |
| * | Reserved | Status1 | | |
| * +---------------------------+ | |
| * | Data2 Ptr | | |
| * +---------------------------+ | |
| * | Reserved | Status2 | | |
| * |-------------|-------------| | |
| * | | | |
| * | | | |
| * | | | |
| * | | | |
| * | | | |
| * |---------------------------| | |
| * | Data14 Ptr | | |
| * +-------------|-------------+ | |
| * | Reserved | Status14 | | |
| * +-------------|-------------+ | |
| * | |
| * The data pointers points to the actual frame data to be received or sent. The | |
| * addresses of the data pointers can, as of writing, be either a: DMA address, | |
| * physical address or mapped address. | |
| * | |
| */ | |
| #define FDMA_DCB_INFO_DATAL(x) ((x) & GENMASK(15, 0)) | |
| #define FDMA_DCB_INFO_TOKEN BIT(17) | |
| #define FDMA_DCB_INFO_INTR BIT(18) | |
| #define FDMA_DCB_INFO_SW(x) (((x) << 24) & GENMASK(31, 24)) | |
| #define FDMA_DCB_STATUS_BLOCKL(x) ((x) & GENMASK(15, 0)) | |
| #define FDMA_DCB_STATUS_SOF BIT(16) | |
| #define FDMA_DCB_STATUS_EOF BIT(17) | |
| #define FDMA_DCB_STATUS_INTR BIT(18) | |
| #define FDMA_DCB_STATUS_DONE BIT(19) | |
| #define FDMA_DCB_STATUS_BLOCKO(x) (((x) << 20) & GENMASK(31, 20)) | |
| #define FDMA_DCB_INVALID_DATA 0x1 | |
| #define FDMA_DB_MAX 15 /* Max number of DB's on Sparx5 */ | |
| struct fdma; | |
| struct fdma_db { | |
| u64 dataptr; | |
| u64 status; | |
| }; | |
| struct fdma_dcb { | |
| u64 nextptr; | |
| u64 info; | |
| struct fdma_db db[FDMA_DB_MAX]; | |
| }; | |
| struct fdma_ops { | |
| /* User-provided callback to set the dataptr */ | |
| int (*dataptr_cb)(struct fdma *fdma, int dcb_idx, int db_idx, u64 *ptr); | |
| /* User-provided callback to set the nextptr */ | |
| int (*nextptr_cb)(struct fdma *fdma, int dcb_idx, u64 *ptr); | |
| }; | |
| struct fdma { | |
| void *priv; | |
| /* Virtual addresses */ | |
| struct fdma_dcb *dcbs; | |
| struct fdma_dcb *last_dcb; | |
| /* DMA address */ | |
| dma_addr_t dma; | |
| /* Size of DCB + DB memory */ | |
| int size; | |
| /* Indexes used to access the next-to-be-used DCB or DB */ | |
| int db_index; | |
| int dcb_index; | |
| /* Number of DCB's and DB's */ | |
| u32 n_dcbs; | |
| u32 n_dbs; | |
| /* Size of DB's */ | |
| u32 db_size; | |
| /* Channel id this FDMA object operates on */ | |
| u32 channel_id; | |
| struct fdma_ops ops; | |
| }; | |
| /* Advance the DCB index and wrap if required. */ | |
| static inline void fdma_dcb_advance(struct fdma *fdma) | |
| { | |
| fdma->dcb_index++; | |
| if (fdma->dcb_index >= fdma->n_dcbs) | |
| fdma->dcb_index = 0; | |
| } | |
| /* Advance the DB index. */ | |
| static inline void fdma_db_advance(struct fdma *fdma) | |
| { | |
| fdma->db_index++; | |
| } | |
| /* Reset the db index to zero. */ | |
| static inline void fdma_db_reset(struct fdma *fdma) | |
| { | |
| fdma->db_index = 0; | |
| } | |
| /* Check if a DCB can be reused in case of multiple DB's per DCB. */ | |
| static inline bool fdma_dcb_is_reusable(struct fdma *fdma) | |
| { | |
| return fdma->db_index != fdma->n_dbs; | |
| } | |
| /* Check if the FDMA has marked this DB as done. */ | |
| static inline bool fdma_db_is_done(struct fdma_db *db) | |
| { | |
| return db->status & FDMA_DCB_STATUS_DONE; | |
| } | |
| /* Get the length of a DB. */ | |
| static inline int fdma_db_len_get(struct fdma_db *db) | |
| { | |
| return FDMA_DCB_STATUS_BLOCKL(db->status); | |
| } | |
| /* Set the length of a DB. */ | |
| static inline void fdma_dcb_len_set(struct fdma_dcb *dcb, u32 len) | |
| { | |
| dcb->info = FDMA_DCB_INFO_DATAL(len); | |
| } | |
| /* Get a DB by index. */ | |
| static inline struct fdma_db *fdma_db_get(struct fdma *fdma, int dcb_idx, | |
| int db_idx) | |
| { | |
| return &fdma->dcbs[dcb_idx].db[db_idx]; | |
| } | |
| /* Get the next DB. */ | |
| static inline struct fdma_db *fdma_db_next_get(struct fdma *fdma) | |
| { | |
| return fdma_db_get(fdma, fdma->dcb_index, fdma->db_index); | |
| } | |
| /* Get a DCB by index. */ | |
| static inline struct fdma_dcb *fdma_dcb_get(struct fdma *fdma, int dcb_idx) | |
| { | |
| return &fdma->dcbs[dcb_idx]; | |
| } | |
| /* Get the next DCB. */ | |
| static inline struct fdma_dcb *fdma_dcb_next_get(struct fdma *fdma) | |
| { | |
| return fdma_dcb_get(fdma, fdma->dcb_index); | |
| } | |
| /* Check if the FDMA has frames ready for extraction. */ | |
| static inline bool fdma_has_frames(struct fdma *fdma) | |
| { | |
| return fdma_db_is_done(fdma_db_next_get(fdma)); | |
| } | |
| /* Get a nextptr by index */ | |
| static inline int fdma_nextptr_cb(struct fdma *fdma, int dcb_idx, u64 *nextptr) | |
| { | |
| *nextptr = fdma->dma + (sizeof(struct fdma_dcb) * dcb_idx); | |
| return 0; | |
| } | |
| /* Get the DMA address of a dataptr, by index. This function is only applicable | |
| * if the dataptr addresses and DCB's are in contiguous memory and the driver | |
| * supports XDP. | |
| */ | |
| static inline u64 fdma_dataptr_get_contiguous(struct fdma *fdma, int dcb_idx, | |
| int db_idx) | |
| { | |
| return fdma->dma + (sizeof(struct fdma_dcb) * fdma->n_dcbs) + | |
| (dcb_idx * fdma->n_dbs + db_idx) * fdma->db_size + | |
| XDP_PACKET_HEADROOM; | |
| } | |
| /* Get the virtual address of a dataptr, by index. This function is only | |
| * applicable if the dataptr addresses and DCB's are in contiguous memory and | |
| * the driver supports XDP. | |
| */ | |
| static inline void *fdma_dataptr_virt_get_contiguous(struct fdma *fdma, | |
| int dcb_idx, int db_idx) | |
| { | |
| return (u8 *)fdma->dcbs + (sizeof(struct fdma_dcb) * fdma->n_dcbs) + | |
| (dcb_idx * fdma->n_dbs + db_idx) * fdma->db_size + | |
| XDP_PACKET_HEADROOM; | |
| } | |
| /* Check if this DCB is the last used DCB. */ | |
| static inline bool fdma_is_last(struct fdma *fdma, struct fdma_dcb *dcb) | |
| { | |
| return dcb == fdma->last_dcb; | |
| } | |
| int fdma_dcbs_init(struct fdma *fdma, u64 info, u64 status); | |
| int fdma_db_add(struct fdma *fdma, int dcb_idx, int db_idx, u64 status); | |
| int fdma_dcb_add(struct fdma *fdma, int dcb_idx, u64 info, u64 status); | |
| int __fdma_dcb_add(struct fdma *fdma, int dcb_idx, u64 info, u64 status, | |
| int (*dcb_cb)(struct fdma *fdma, int dcb_idx, u64 *nextptr), | |
| int (*db_cb)(struct fdma *fdma, int dcb_idx, int db_idx, | |
| u64 *dataptr)); | |
| int fdma_alloc_coherent(struct device *dev, struct fdma *fdma); | |
| int fdma_alloc_phys(struct fdma *fdma); | |
| void fdma_free_coherent(struct device *dev, struct fdma *fdma); | |
| void fdma_free_phys(struct fdma *fdma); | |
| u32 fdma_get_size(struct fdma *fdma); | |
| u32 fdma_get_size_contiguous(struct fdma *fdma); | |
| #endif |