#include "fpga_lte_fec.h"
-/* Turbo SW PMD logging ID */
-static int fpga_lte_fec_logtype;
+#ifdef RTE_LIBRTE_BBDEV_DEBUG
+RTE_LOG_REGISTER(fpga_lte_fec_logtype, pmd.bb.fpga_lte_fec, DEBUG);
+#else
+RTE_LOG_REGISTER(fpga_lte_fec_logtype, pmd.bb.fpga_lte_fec, NOTICE);
+#endif
/* Helper macro for logging */
#define rte_bbdev_log(level, fmt, ...) \
};
/* FPGA LTE FEC DMA Encoding Request Descriptor */
-struct __attribute__((__packed__)) fpga_dma_enc_desc {
+struct __rte_packed fpga_dma_enc_desc {
uint32_t done:1,
rsrvd0:11,
error:4,
};
/* FPGA LTE FEC DMA Decoding Request Descriptor */
-struct __attribute__((__packed__)) fpga_dma_dec_desc {
+struct __rte_packed fpga_dma_dec_desc {
uint32_t done:1,
iter:5,
rsrvd0:2,
};
/* FPGA LTE FEC Ring Control Register */
-struct __attribute__((__packed__)) fpga_ring_ctrl_reg {
+struct __rte_packed fpga_ring_ctrl_reg {
uint64_t ring_base_addr;
uint64_t ring_head_addr;
uint16_t ring_size:11;
RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP,
.max_llr_modulus = INT8_MAX,
.num_buffers_src =
- RTE_BBDEV_MAX_CODE_BLOCKS,
+ RTE_BBDEV_TURBO_MAX_CODE_BLOCKS,
.num_buffers_hard_out =
- RTE_BBDEV_MAX_CODE_BLOCKS,
+ RTE_BBDEV_TURBO_MAX_CODE_BLOCKS,
.num_buffers_soft_out = 0
}
},
RTE_BBDEV_TURBO_RATE_MATCH |
RTE_BBDEV_TURBO_ENC_INTERRUPTS,
.num_buffers_src =
- RTE_BBDEV_MAX_CODE_BLOCKS,
+ RTE_BBDEV_TURBO_MAX_CODE_BLOCKS,
.num_buffers_dst =
- RTE_BBDEV_MAX_CODE_BLOCKS
+ RTE_BBDEV_TURBO_MAX_CODE_BLOCKS
}
},
RTE_BBDEV_END_OF_CAPABILITIES_LIST()
* completed. If completion flag is not updated within 1ms it is
* considered as a failure.
*/
- while (!(*((uint8_t *)d->flush_queue_status + q->q_idx) & payload)) {
+ while (!(*((volatile uint8_t *)d->flush_queue_status + q->q_idx) & payload)) {
if (counter > timeout) {
rte_bbdev_log(ERR, "FPGA Queue Flush failed for queue %d",
queue_id);
desc->offset = desc_offset;
/* Set inbound data buffer address */
desc->in_addr_hi = (uint32_t)(
- rte_pktmbuf_mtophys_offset(input, in_offset) >> 32);
+ rte_pktmbuf_iova_offset(input, in_offset) >> 32);
desc->in_addr_lw = (uint32_t)(
- rte_pktmbuf_mtophys_offset(input, in_offset));
+ rte_pktmbuf_iova_offset(input, in_offset));
desc->out_addr_hi = (uint32_t)(
- rte_pktmbuf_mtophys_offset(output, out_offset) >> 32);
+ rte_pktmbuf_iova_offset(output, out_offset) >> 32);
desc->out_addr_lw = (uint32_t)(
- rte_pktmbuf_mtophys_offset(output, out_offset));
+ rte_pktmbuf_iova_offset(output, out_offset));
/* Save software context needed for dequeue */
desc->op_addr = op;
desc->done = 0;
/* Set inbound data buffer address */
desc->in_addr_hi = (uint32_t)(
- rte_pktmbuf_mtophys_offset(input, in_offset) >> 32);
+ rte_pktmbuf_iova_offset(input, in_offset) >> 32);
desc->in_addr_lw = (uint32_t)(
- rte_pktmbuf_mtophys_offset(input, in_offset));
+ rte_pktmbuf_iova_offset(input, in_offset));
desc->in_len = in_length;
desc->k = k;
desc->crc_type = !check_bit(op->turbo_dec.op_flags,
desc->max_iter = op->turbo_dec.iter_max * 2;
desc->offset = desc_offset;
desc->out_addr_hi = (uint32_t)(
- rte_pktmbuf_mtophys_offset(output, out_offset) >> 32);
+ rte_pktmbuf_iova_offset(output, out_offset) >> 32);
desc->out_addr_lw = (uint32_t)(
- rte_pktmbuf_mtophys_offset(output, out_offset));
+ rte_pktmbuf_iova_offset(output, out_offset));
/* Save software context needed for dequeue */
desc->op_addr = op;
validate_enc_op(struct rte_bbdev_enc_op *op)
{
struct rte_bbdev_op_turbo_enc *turbo_enc = &op->turbo_enc;
- struct rte_bbdev_op_enc_cb_params *cb = NULL;
- struct rte_bbdev_op_enc_tb_params *tb = NULL;
+ struct rte_bbdev_op_enc_turbo_cb_params *cb = NULL;
+ struct rte_bbdev_op_enc_turbo_tb_params *tb = NULL;
uint16_t kw, kw_neg, kw_pos;
if (turbo_enc->input.length >
- RTE_BBDEV_MAX_TB_SIZE >> 3) {
+ RTE_BBDEV_TURBO_MAX_TB_SIZE >> 3) {
rte_bbdev_log(ERR, "TB size (%u) is too big, max: %d",
- turbo_enc->input.length, RTE_BBDEV_MAX_TB_SIZE);
+ turbo_enc->input.length,
+ RTE_BBDEV_TURBO_MAX_TB_SIZE);
op->status = 1 << RTE_BBDEV_DATA_ERROR;
return -1;
}
if (turbo_enc->code_block_mode == 0) {
tb = &turbo_enc->tb_params;
- if ((tb->k_neg < RTE_BBDEV_MIN_CB_SIZE
- || tb->k_neg > RTE_BBDEV_MAX_CB_SIZE)
+ if ((tb->k_neg < RTE_BBDEV_TURBO_MIN_CB_SIZE
+ || tb->k_neg > RTE_BBDEV_TURBO_MAX_CB_SIZE)
&& tb->c_neg > 0) {
rte_bbdev_log(ERR,
"k_neg (%u) is out of range %u <= value <= %u",
- tb->k_neg, RTE_BBDEV_MIN_CB_SIZE,
- RTE_BBDEV_MAX_CB_SIZE);
+ tb->k_neg, RTE_BBDEV_TURBO_MIN_CB_SIZE,
+ RTE_BBDEV_TURBO_MAX_CB_SIZE);
return -1;
}
- if (tb->k_pos < RTE_BBDEV_MIN_CB_SIZE
- || tb->k_pos > RTE_BBDEV_MAX_CB_SIZE) {
+ if (tb->k_pos < RTE_BBDEV_TURBO_MIN_CB_SIZE
+ || tb->k_pos > RTE_BBDEV_TURBO_MAX_CB_SIZE) {
rte_bbdev_log(ERR,
"k_pos (%u) is out of range %u <= value <= %u",
- tb->k_pos, RTE_BBDEV_MIN_CB_SIZE,
- RTE_BBDEV_MAX_CB_SIZE);
+ tb->k_pos, RTE_BBDEV_TURBO_MIN_CB_SIZE,
+ RTE_BBDEV_TURBO_MAX_CB_SIZE);
return -1;
}
- if (tb->c_neg > (RTE_BBDEV_MAX_CODE_BLOCKS - 1))
+ if (tb->c_neg > (RTE_BBDEV_TURBO_MAX_CODE_BLOCKS - 1))
rte_bbdev_log(ERR,
"c_neg (%u) is out of range 0 <= value <= %u",
tb->c_neg,
- RTE_BBDEV_MAX_CODE_BLOCKS - 1);
- if (tb->c < 1 || tb->c > RTE_BBDEV_MAX_CODE_BLOCKS) {
+ RTE_BBDEV_TURBO_MAX_CODE_BLOCKS - 1);
+ if (tb->c < 1 || tb->c > RTE_BBDEV_TURBO_MAX_CODE_BLOCKS) {
rte_bbdev_log(ERR,
"c (%u) is out of range 1 <= value <= %u",
- tb->c, RTE_BBDEV_MAX_CODE_BLOCKS);
+ tb->c, RTE_BBDEV_TURBO_MAX_CODE_BLOCKS);
return -1;
}
if (tb->cab > tb->c) {
tb->cab, tb->c);
return -1;
}
- if ((tb->ea < RTE_BBDEV_MIN_CB_SIZE || (tb->ea % 2))
+ if ((tb->ea < RTE_BBDEV_TURBO_MIN_CB_SIZE || (tb->ea % 2))
&& tb->r < tb->cab) {
rte_bbdev_log(ERR,
"ea (%u) is less than %u or it is not even",
- tb->ea, RTE_BBDEV_MIN_CB_SIZE);
+ tb->ea, RTE_BBDEV_TURBO_MIN_CB_SIZE);
return -1;
}
- if ((tb->eb < RTE_BBDEV_MIN_CB_SIZE || (tb->eb % 2))
+ if ((tb->eb < RTE_BBDEV_TURBO_MIN_CB_SIZE || (tb->eb % 2))
&& tb->c > tb->cab) {
rte_bbdev_log(ERR,
"eb (%u) is less than %u or it is not even",
- tb->eb, RTE_BBDEV_MIN_CB_SIZE);
+ tb->eb, RTE_BBDEV_TURBO_MIN_CB_SIZE);
return -1;
}
kw_neg = 3 * RTE_ALIGN_CEIL(tb->k_neg + 4,
- RTE_BBDEV_C_SUBBLOCK);
+ RTE_BBDEV_TURBO_C_SUBBLOCK);
if (tb->ncb_neg < tb->k_neg || tb->ncb_neg > kw_neg) {
rte_bbdev_log(ERR,
"ncb_neg (%u) is out of range (%u) k_neg <= value <= (%u) kw_neg",
}
kw_pos = 3 * RTE_ALIGN_CEIL(tb->k_pos + 4,
- RTE_BBDEV_C_SUBBLOCK);
+ RTE_BBDEV_TURBO_C_SUBBLOCK);
if (tb->ncb_pos < tb->k_pos || tb->ncb_pos > kw_pos) {
rte_bbdev_log(ERR,
"ncb_pos (%u) is out of range (%u) k_pos <= value <= (%u) kw_pos",
}
} else {
cb = &turbo_enc->cb_params;
- if (cb->k < RTE_BBDEV_MIN_CB_SIZE
- || cb->k > RTE_BBDEV_MAX_CB_SIZE) {
+ if (cb->k < RTE_BBDEV_TURBO_MIN_CB_SIZE
+ || cb->k > RTE_BBDEV_TURBO_MAX_CB_SIZE) {
rte_bbdev_log(ERR,
"k (%u) is out of range %u <= value <= %u",
- cb->k, RTE_BBDEV_MIN_CB_SIZE,
- RTE_BBDEV_MAX_CB_SIZE);
+ cb->k, RTE_BBDEV_TURBO_MIN_CB_SIZE,
+ RTE_BBDEV_TURBO_MAX_CB_SIZE);
return -1;
}
- if (cb->e < RTE_BBDEV_MIN_CB_SIZE || (cb->e % 2)) {
+ if (cb->e < RTE_BBDEV_TURBO_MIN_CB_SIZE || (cb->e % 2)) {
rte_bbdev_log(ERR,
"e (%u) is less than %u or it is not even",
- cb->e, RTE_BBDEV_MIN_CB_SIZE);
+ cb->e, RTE_BBDEV_TURBO_MIN_CB_SIZE);
return -1;
}
- kw = RTE_ALIGN_CEIL(cb->k + 4, RTE_BBDEV_C_SUBBLOCK) * 3;
+ kw = RTE_ALIGN_CEIL(cb->k + 4, RTE_BBDEV_TURBO_C_SUBBLOCK) * 3;
if (cb->ncb < cb->k || cb->ncb > kw) {
rte_bbdev_log(ERR,
"ncb (%u) is out of range (%u) k <= value <= (%u) kw",
validate_dec_op(struct rte_bbdev_dec_op *op)
{
struct rte_bbdev_op_turbo_dec *turbo_dec = &op->turbo_dec;
- struct rte_bbdev_op_dec_cb_params *cb = NULL;
- struct rte_bbdev_op_dec_tb_params *tb = NULL;
+ struct rte_bbdev_op_dec_turbo_cb_params *cb = NULL;
+ struct rte_bbdev_op_dec_turbo_tb_params *tb = NULL;
if (op->mempool == NULL) {
rte_bbdev_log(ERR, "Invalid mempool pointer");
}
tb = &turbo_dec->tb_params;
- if ((tb->k_neg < RTE_BBDEV_MIN_CB_SIZE
- || tb->k_neg > RTE_BBDEV_MAX_CB_SIZE)
+ if ((tb->k_neg < RTE_BBDEV_TURBO_MIN_CB_SIZE
+ || tb->k_neg > RTE_BBDEV_TURBO_MAX_CB_SIZE)
&& tb->c_neg > 0) {
rte_bbdev_log(ERR,
"k_neg (%u) is out of range %u <= value <= %u",
- tb->k_neg, RTE_BBDEV_MIN_CB_SIZE,
- RTE_BBDEV_MAX_CB_SIZE);
+ tb->k_neg, RTE_BBDEV_TURBO_MIN_CB_SIZE,
+ RTE_BBDEV_TURBO_MAX_CB_SIZE);
return -1;
}
- if ((tb->k_pos < RTE_BBDEV_MIN_CB_SIZE
- || tb->k_pos > RTE_BBDEV_MAX_CB_SIZE)
+ if ((tb->k_pos < RTE_BBDEV_TURBO_MIN_CB_SIZE
+ || tb->k_pos > RTE_BBDEV_TURBO_MAX_CB_SIZE)
&& tb->c > tb->c_neg) {
rte_bbdev_log(ERR,
"k_pos (%u) is out of range %u <= value <= %u",
- tb->k_pos, RTE_BBDEV_MIN_CB_SIZE,
- RTE_BBDEV_MAX_CB_SIZE);
+ tb->k_pos, RTE_BBDEV_TURBO_MIN_CB_SIZE,
+ RTE_BBDEV_TURBO_MAX_CB_SIZE);
return -1;
}
- if (tb->c_neg > (RTE_BBDEV_MAX_CODE_BLOCKS - 1))
+ if (tb->c_neg > (RTE_BBDEV_TURBO_MAX_CODE_BLOCKS - 1))
rte_bbdev_log(ERR,
"c_neg (%u) is out of range 0 <= value <= %u",
tb->c_neg,
- RTE_BBDEV_MAX_CODE_BLOCKS - 1);
- if (tb->c < 1 || tb->c > RTE_BBDEV_MAX_CODE_BLOCKS) {
+ RTE_BBDEV_TURBO_MAX_CODE_BLOCKS - 1);
+ if (tb->c < 1 || tb->c > RTE_BBDEV_TURBO_MAX_CODE_BLOCKS) {
rte_bbdev_log(ERR,
"c (%u) is out of range 1 <= value <= %u",
- tb->c, RTE_BBDEV_MAX_CODE_BLOCKS);
+ tb->c, RTE_BBDEV_TURBO_MAX_CODE_BLOCKS);
return -1;
}
if (tb->cab > tb->c) {
}
cb = &turbo_dec->cb_params;
- if (cb->k < RTE_BBDEV_MIN_CB_SIZE
- || cb->k > RTE_BBDEV_MAX_CB_SIZE) {
+ if (cb->k < RTE_BBDEV_TURBO_MIN_CB_SIZE
+ || cb->k > RTE_BBDEV_TURBO_MAX_CB_SIZE) {
rte_bbdev_log(ERR,
"k (%u) is out of range %u <= value <= %u",
- cb->k, RTE_BBDEV_MIN_CB_SIZE,
- RTE_BBDEV_MAX_CB_SIZE);
+ cb->k, RTE_BBDEV_TURBO_MIN_CB_SIZE,
+ RTE_BBDEV_TURBO_MAX_CB_SIZE);
return -1;
}
}
/* Initialization Function */
static void
-fpga_lte_fec_init(struct rte_bbdev *dev)
+fpga_lte_fec_init(struct rte_bbdev *dev, struct rte_pci_driver *drv)
{
struct rte_pci_device *pci_dev = RTE_DEV_TO_PCI(dev->device);
dev->dequeue_dec_ops = fpga_dequeue_dec;
((struct fpga_lte_fec_device *) dev->data->dev_private)->pf_device =
- !strcmp(dev->device->driver->name,
+ !strcmp(drv->driver.name,
RTE_STR(FPGA_LTE_FEC_PF_DRIVER_NAME));
((struct fpga_lte_fec_device *) dev->data->dev_private)->mmio_base =
pci_dev->mem_resource[0].addr;
rte_bbdev_log_debug(
"Init device %s [%s] @ virtaddr %p phyaddr %#"PRIx64,
- dev->device->driver->name, dev->data->name,
+ drv->driver.name, dev->data->name,
(void *)pci_dev->mem_resource[0].addr,
pci_dev->mem_resource[0].phys_addr);
}
static int
-fpga_lte_fec_probe(struct rte_pci_driver *pci_drv __rte_unused,
+fpga_lte_fec_probe(struct rte_pci_driver *pci_drv,
struct rte_pci_device *pci_dev)
{
struct rte_bbdev *bbdev = NULL;
bbdev->data->socket_id = pci_dev->device.numa_node;
/* Invoke FEC FPGA device initialization function */
- fpga_lte_fec_init(bbdev);
+ fpga_lte_fec_init(bbdev, pci_drv);
rte_bbdev_log_debug("bbdev id = %u [%s]",
bbdev->data->dev_id, dev_name);
((uint16_t)(version_id >> 16)), ((uint16_t)version_id));
#ifdef RTE_LIBRTE_BBDEV_DEBUG
- if (!strcmp(bbdev->device->driver->name,
+ if (!strcmp(pci_drv->driver.name,
RTE_STR(FPGA_LTE_FEC_PF_DRIVER_NAME)))
print_static_reg_debug_info(d->mmio_base);
#endif
}
static inline void
-set_default_fpga_conf(struct fpga_lte_fec_conf *def_conf)
+set_default_fpga_conf(struct rte_fpga_lte_fec_conf *def_conf)
{
/* clear default configuration before initialization */
- memset(def_conf, 0, sizeof(struct fpga_lte_fec_conf));
+ memset(def_conf, 0, sizeof(struct rte_fpga_lte_fec_conf));
/* Set pf mode to true */
def_conf->pf_mode_en = true;
/* Initial configuration of FPGA LTE FEC device */
int
-fpga_lte_fec_configure(const char *dev_name,
- const struct fpga_lte_fec_conf *conf)
+rte_fpga_lte_fec_configure(const char *dev_name,
+ const struct rte_fpga_lte_fec_conf *conf)
{
uint32_t payload_32, address;
uint16_t payload_16;
uint8_t payload_8;
uint16_t q_id, vf_id, total_q_id, total_ul_q_id, total_dl_q_id;
struct rte_bbdev *bbdev = rte_bbdev_get_named_dev(dev_name);
- struct fpga_lte_fec_conf def_conf;
+ struct rte_fpga_lte_fec_conf def_conf;
if (bbdev == NULL) {
rte_bbdev_log(ERR,
RTE_PMD_REGISTER_PCI(FPGA_LTE_FEC_VF_DRIVER_NAME, fpga_lte_fec_pci_vf_driver);
RTE_PMD_REGISTER_PCI_TABLE(FPGA_LTE_FEC_VF_DRIVER_NAME,
pci_id_fpga_lte_fec_vf_map);
-
-RTE_INIT(fpga_lte_fec_init_log)
-{
- fpga_lte_fec_logtype = rte_log_register("pmd.bb.fpga_lte_fec");
- if (fpga_lte_fec_logtype >= 0)
-#ifdef RTE_LIBRTE_BBDEV_DEBUG
- rte_log_set_level(fpga_lte_fec_logtype, RTE_LOG_DEBUG);
-#else
- rte_log_set_level(fpga_lte_fec_logtype, RTE_LOG_NOTICE);
-#endif
-}
git.droids-corp.org / dpdk.git / blobdiff