Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933719AbbFJPYn (ORCPT ); Wed, 10 Jun 2015 11:24:43 -0400 Received: from mail-by2on0137.outbound.protection.outlook.com ([207.46.100.137]:59577 "EHLO na01-by2-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S933382AbbFJPXf (ORCPT ); Wed, 10 Jun 2015 11:23:35 -0400 Authentication-Results: spf=fail (sender IP is 192.88.168.50) smtp.mailfrom=freescale.com; freescale.mail.onmicrosoft.com; dkim=none (message not signed) header.d=none; From: Madalin Bucur To: , , CC: , Igal Liberman Subject: [PATCH 11/12] fsl/fman: Add FMan Port Support Date: Wed, 10 Jun 2015 18:21:49 +0300 Message-ID: <1433949712-5648-10-git-send-email-madalin.bucur@freescale.com> X-Mailer: git-send-email 1.5.6.5 In-Reply-To: <1433949712-5648-9-git-send-email-madalin.bucur@freescale.com> References: <1433949712-5648-1-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-2-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-3-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-4-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-5-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-6-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-7-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-8-git-send-email-madalin.bucur@freescale.com> <1433949712-5648-9-git-send-email-madalin.bucur@freescale.com> Reply-To: X-EOPAttributedMessage: 0 X-Microsoft-Exchange-Diagnostics: 1;BN1AFFO11FD047;1:r6BOu0d6V4eo2HduFNMW0KSqjKPKEbU+2IwxqUiRT66GcoymnCf6RicCxUSC0tWSZjZvVEwC5rrXuT5b8XU3PypTCc37cbDAtCD4Cm8Hb+1jEwKdSMhkHQ2K91Qk0BocU24mns5dJDZnx1hzTKUaQJ5lpyUNZbPlfuAA+NiW+s+yPL6L2cvDpHrM7W9v4LAgTV69S94Te+PHvowTC1Y0FwvzKz5NOsPbiZN0KIlQK0Bcz7+D+ZRts5U2YQkQILX2P4ExzKZI0kTkG9OfQYLJMmsXO0H/iu2qFrZr0sWEVSyBx9pjxVppozCc/KgCTFgvhPNTfEgm5buHp1j0/Mas8g== X-Forefront-Antispam-Report: CIP:192.88.168.50;CTRY:US;IPV:NLI;EFV:NLI;SFV:NSPM;SFS:(10019020)(6009001)(339900001)(189002)(199003)(5001960100002)(85426001)(107886002)(5001920100001)(46102003)(6806004)(229853001)(47776003)(48376002)(105606002)(19580405001)(189998001)(49486002)(87936001)(19580395003)(50226001)(2201001)(86362001)(575784001)(62966003)(77156002)(2950100001)(104016003)(5001770100001)(36756003)(43066003)(50986999)(77096005)(33646002)(53806999)(76176999)(2004002)(4001430100001)(2101003)(559001)(579004);DIR:OUT;SFP:1102;SCL:1;SRVR:BLUPR03MB373;H:tx30smr01.am.freescale.net;FPR:;SPF:Fail;MLV:sfv;MX:1;A:1;LANG:; MIME-Version: 1.0 Content-Type: text/plain X-Microsoft-Exchange-Diagnostics: 1;BLUPR03MB373;2:bR8V8SLpxplFQ0KKJFpMfTmopgascMdRN/wNd6I4csQy/uiui88vGBxMOHrjtPDK;2:JXsiQBj01SZ/7X0x0RgWZJIPcyK22LQuUdzPBwBOrOVJb6focu41ego968UYUsDt67l3w/yv7WE4q7/8qGrQyBKMoC7UPvho6fU5+UvWZXonQ33ihQtzhmAXcWrQGYK/wMQZ1S2uOMVJOHaiJGd0rBftwuc7g2DDciH9zAXw1qmOFXGAiRejYX5F409/z8gLU6fwZhBNol6apjbh+TCLqHB/xiOKQAMZkAIq4bxrDHA=;6:XF09K/9D5q5Fz2XHmeZ4Pow8xiServnGiGDMwufzhEkuPeYBIYXbQJ5LFnJYg1lRVd0AftC0nMDfRKVkaT4vZxn/oZUoITgsfH8xc7bVRrlVi7NtrCzMDlAfg6Se2LYjMZ5phylxfWt/YuwKr0ahjVAh3f83nsQNSRqKj8b93rcwO10ColOOEg1AWvAIhf+U4GXn9s+CZTtfS+Yw+lxXCHNOXUOhqI8rCchiGtENLFwB8jCQDkRHfizhkj++4ktg5NXDhpPfEovSrvYQVpTyRrceUX0+zRVKIWmwVybpoSkaYQn0GW8t1AtpMIO+e3zKu4RljCu+8IM1Np1zC1nXgA==;3:DFyiHEqOtVD/gqXROsgN5DJqkmqf9ybovOP5YSYFxrbJtIbjqfauSKzSia0D/Mzwfu7x2ipv0Fm3HOvTeDTR2MYtqbVIqzgmyVQ0Ukht5gbx2YOfLbIhqQmkRednYSgV/OGEjPPdBhHeGXfBJLTOB/EjZOwGzHpZVoNqQcCIj7dqIf0YRYgSaRhE8R029WC6Lcs6TrJFo/ZpGpY1IjTbqnRahDSzweEFI7N/9+y3gfyO6V6F4E0bpiE0RfGSqyAssN+fOoLd0t3BVcWVB9mm+Ecw8s5Ih2PidMeXv6iW0CXqSKHW6AhHbhG1yW97KnB+ X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BLUPR03MB373; X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(601004)(520003)(5005006)(3002001);SRVR:BLUPR03MB373;BCL:0;PCL:0;RULEID:;SRVR:BLUPR03MB373; X-Forefront-PRVS: 06036BD506 X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1;BLUPR03MB373;9:/vw4ltn9IjJHtNRcLEKPVkZqjS2HObXDxz4ORdDC3OM?= =?us-ascii?Q?DRbApeF1yr5z+Fhj7grIIogxLE4zUxvkDwF4AoWkyr8fxGpzCXqYkGBD8rjA?= =?us-ascii?Q?e48FZicwTuPYfhBtbIY6QBoSRPSza+UVjSBGa/Wi4srycxfzlQgV16asAghT?= =?us-ascii?Q?BF9lVroZx4gJNedn8vM4W+12jQVu+91rwOAEY9BvkyPX6Hja3UPK0VzLFeP1?= =?us-ascii?Q?tds+GkeVaoLEISvtOHmjGzscu2uWIhxSzB99GhZkGtnQuIfwxRxQgMQwm7GL?= =?us-ascii?Q?DBU+J80aR8Umdg4wXk3dJBe76eLsh3EPzpaaXIP+/q6AYA+QvKxL+/xArsVK?= =?us-ascii?Q?O4AKiYrprFKlttXB2S4kX0uJP5wBjNWVRsnwBTFomWvXZlXPsNlVDysFGzI/?= =?us-ascii?Q?eMRrHNoxQ2pKlxjCzmbZJ94qUnS7HaXd7SGmmXAWCDKic8Xe30IkaQRy8USD?= =?us-ascii?Q?0w7+cAjkfPcRE+TWs/m+wxGOiAwl7jtdbSois+A+qs70zfvw8uzi3DquaJya?= =?us-ascii?Q?BH43DwpwfqQ4N9IyI9dbSMb0Y6jydR/FT1fa23oV2tnUUvnG8r4peiZ2xHpi?= =?us-ascii?Q?Tmsd0o2lwKZHJ5WCmFTn/86PoKLk9ua1bETRRgRRkw26nqqf+pqKn3yksVG+?= =?us-ascii?Q?5egg9M5/UnQK7Q1JTcCtJVepY0B54VUDphfJjzhdfYH53a48+Sd/r3Q72Q9/?= =?us-ascii?Q?A3doZ3/dXLTLw2ViivofsCJWwikNU6nG8VE07AzF54gHTUg08xwygmbRiYOI?= =?us-ascii?Q?S5B3dqUAY8qAWH4EvhzgZskfmAfmW/w06pL9sXkQDUKCSp7oN63/5CqNBRYF?= =?us-ascii?Q?/ZIWuEqx9t/coEjQb1qCsgzh+FXG/y0SudmiQaPXaSWhfpnVUjrI5Jsh6UoN?= =?us-ascii?Q?OrjJGU/FB+QiqSLFIS1r0t1owEpo3kFwc52Vg1vkKewRxdE3iOLjSr/oCgpP?= =?us-ascii?Q?rMFMjK4s+9v2b54OOEQn8d6cZf39/5YJyWYAfTBMG0h8M5i4YyYSbZogIVmc?= =?us-ascii?Q?tEy5bj674LygMdTiq2wGpmYESn0cNSaB4hzlW1fMjuw=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1;BLUPR03MB373;3:YQhmr7ZOEcWBIP1Wh+2ogwS+u8MyeGQjSQLqCxOCBK0YZXoAhSiVYgqmkDYRjYlrOefTmfanH68rwqRqfoO2mtpUhsXAjn2Fe0z0IiWus5MOCCjKo0g/fd6cFcGLJEg15H30eaz2cv6QvPDf3Qjczg==;10:90CVYBikKU3SXirt7WYmgYcPXwc1mR/Vb3si/4WBEkA4zZJYST5qmH+bQWpafeWffgPTAzPvOT0YMrTMhBZiKOdFQN6xWlrKMvNUgO1FRPE=;6:EeShmgjbeORFtIh4k/tT22oChUom/xYBJK6haZUbpGBOV6fWGIR3YZVzHYoTVO0T X-OriginatorOrg: freescale.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 10 Jun 2015 15:23:23.2106 (UTC) X-MS-Exchange-CrossTenant-Id: 710a03f5-10f6-4d38-9ff4-a80b81da590d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=710a03f5-10f6-4d38-9ff4-a80b81da590d;Ip=[192.88.168.50];Helo=[tx30smr01.am.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: BLUPR03MB373 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 135736 Lines: 3931 From: Igal Liberman This patch adds The FMan Port configuration, initialization and runtime control routines. Signed-off-by: Igal Liberman --- drivers/net/ethernet/freescale/fman/Makefile | 2 +- drivers/net/ethernet/freescale/fman/fm.c | 487 ++++++- drivers/net/ethernet/freescale/fman/fm_common.h | 168 +++ drivers/net/ethernet/freescale/fman/fm_drv.c | 108 +- drivers/net/ethernet/freescale/fman/fm_drv.h | 2 + drivers/net/ethernet/freescale/fman/fm_port_drv.c | 496 +++++++ .../net/ethernet/freescale/fman/inc/fm_port_ext.h | 376 +++++ .../net/ethernet/freescale/fman/inc/fsl_fman_drv.h | 101 ++ drivers/net/ethernet/freescale/fman/port/Makefile | 2 +- drivers/net/ethernet/freescale/fman/port/fm_port.c | 1435 ++++++++++++++++++++ drivers/net/ethernet/freescale/fman/port/fm_port.h | 527 +++++++ 11 files changed, 3700 insertions(+), 4 deletions(-) create mode 100644 drivers/net/ethernet/freescale/fman/fm_port_drv.c create mode 100644 drivers/net/ethernet/freescale/fman/inc/fm_port_ext.h create mode 100644 drivers/net/ethernet/freescale/fman/port/fm_port.c create mode 100644 drivers/net/ethernet/freescale/fman/port/fm_port.h diff --git a/drivers/net/ethernet/freescale/fman/Makefile b/drivers/net/ethernet/freescale/fman/Makefile index c6c3e24..8d637e2 100644 --- a/drivers/net/ethernet/freescale/fman/Makefile +++ b/drivers/net/ethernet/freescale/fman/Makefile @@ -4,7 +4,7 @@ subdir-ccflags-y += -I$(srctree)/drivers/net/ethernet/freescale/fman/flib \ obj-y += fsl_fman.o -fsl_fman-objs := fman.o fm_muram.o fm.o fm_drv.o +fsl_fman-objs := fman.o fm_muram.o fm.o fm_drv.o fm_port_drv.o obj-y += port/ obj-y += mac/ diff --git a/drivers/net/ethernet/freescale/fman/fm.c b/drivers/net/ethernet/freescale/fman/fm.c index fd6de5a..8bafab2 100644 --- a/drivers/net/ethernet/freescale/fman/fm.c +++ b/drivers/net/ethernet/freescale/fman/fm.c @@ -459,11 +459,36 @@ static void qmi_err_event(struct fm_t *p_fm) static void dma_err_event(struct fm_t *p_fm) { - uint32_t status; + uint32_t status, com_id; + uint8_t tnum; + uint8_t port_id; + uint8_t relative_port_id; + uint16_t liodn; struct fman_dma_regs __iomem *dma_rg = p_fm->p_fm_dma_regs; status = fman_get_dma_err_event(dma_rg); + if (status & DMA_STATUS_BUS_ERR) { + com_id = fman_get_dma_com_id(dma_rg); + port_id = (uint8_t)(((com_id & DMA_TRANSFER_PORTID_MASK) >> + DMA_TRANSFER_PORTID_SHIFT)); + HW_PORT_ID_TO_SW_PORT_ID(p_fm->p_fm_state_struct->rev_info. + major_rev, + relative_port_id, + port_id); + tnum = + (uint8_t)((com_id & DMA_TRANSFER_TNUM_MASK) >> + DMA_TRANSFER_TNUM_SHIFT); + liodn = (uint16_t)(com_id & DMA_TRANSFER_LIODN_MASK); + ASSERT(p_fm->p_fm_state_struct-> + ports_types[port_id] != + FM_PORT_TYPE_DUMMY); + p_fm->f_bus_error(p_fm->h_app, + p_fm->p_fm_state_struct-> + ports_types[port_id], + relative_port_id, + fman_get_dma_addr(dma_rg), tnum, liodn); + } if (status & DMA_STATUS_FM_SPDAT_ECC) p_fm->f_exception(p_fm->h_app, FM_EX_DMA_SINGLE_PORT_ECC); if (status & DMA_STATUS_READ_ECC) @@ -764,6 +789,462 @@ uint8_t fm_get_id(struct fm_t *p_fm) return p_fm->p_fm_state_struct->fm_id; } +int fm_get_set_port_params(struct fm_t *p_fm, + struct fm_inter_module_port_init_params_t + *p_port_params) +{ + int err; + unsigned long int_flags; + uint8_t port_id = p_port_params->port_id, mac_id; + struct fman_rg fman_rg; + + fman_rg.bmi_rg = p_fm->p_fm_bmi_regs; + fman_rg.qmi_rg = p_fm->p_fm_qmi_regs; + fman_rg.fpm_rg = p_fm->p_fm_fpm_regs; + fman_rg.dma_rg = p_fm->p_fm_dma_regs; + + ASSERT(IN_RANGE(1, port_id, 63)); + + spin_lock_irqsave(p_fm->spinlock, int_flags); + + p_fm->p_fm_state_struct->ports_types[port_id] = + p_port_params->port_type; + + err = + fm_set_num_of_tasks(p_fm, p_port_params->port_id, + &p_port_params->num_of_tasks, + &p_port_params->num_of_extra_tasks, true); + if (err) { + spin_unlock_irqrestore(p_fm->spinlock, int_flags); + return err; + } +#ifdef FM_QMI_NO_DEQ_OPTIONS_SUPPORT + if (p_fm->p_fm_state_struct->rev_info.major_rev != 4) +#endif /* FM_QMI_NO_DEQ_OPTIONS_SUPPORT */ + /* for transmit&O/H ports */ + if (p_port_params->port_type != FM_PORT_TYPE_RX) { + uint8_t enq_th; + uint8_t deq_th; + + /* update qmi ENQ/DEQ threshold */ + p_fm->p_fm_state_struct->accumulated_num_of_deq_tnums += + p_port_params->deq_pipeline_depth; + enq_th = fman_get_qmi_enq_th(fman_rg.qmi_rg); + /* if enq_th is too big, we reduce it to the max value + * that is still 0 + */ + if (enq_th >= + (p_fm->intg->qmi_max_num_of_tnums - + p_fm->p_fm_state_struct-> + accumulated_num_of_deq_tnums)) { + enq_th = (uint8_t)( + p_fm->intg-> + qmi_max_num_of_tnums - + p_fm->p_fm_state_struct-> + accumulated_num_of_deq_tnums - 1); + fman_set_qmi_enq_th(fman_rg.qmi_rg, enq_th); + } + + deq_th = fman_get_qmi_deq_th(fman_rg.qmi_rg); + /* if deq_th is too small, we enlarge it to the min + * value that is still 0. + * depTh may not be larger than 63 + * (p_fm->intg->qmi_max_num_of_tnums-1). + */ + if ((deq_th <= + p_fm->p_fm_state_struct-> + accumulated_num_of_deq_tnums) && + (deq_th < + p_fm->intg-> + qmi_max_num_of_tnums - 1)) { + deq_th = (uint8_t)(p_fm-> + p_fm_state_struct-> + accumulated_num_of_deq_tnums + + 1); + fman_set_qmi_deq_th(fman_rg.qmi_rg, deq_th); + } + } +#ifdef FM_LOW_END_RESTRICTION + if (p_fm->p_fm_state_struct->rev_info.major_rev == 0x4) { + if ((port_id == 0x1) || (port_id == 0x29)) { + if (p_fm->p_fm_state_struct->low_end_restriction) { + spin_unlock_irqrestore(p_fm->spinlock, + int_flags); + pr_err("OP#0 can't work with Tx Port1\n"); + return -EAGAIN; + } + p_fm->p_fm_state_struct->low_end_restriction = true; + } + } +#endif /* FM_LOW_END_RESTRICTION */ + + err = fm_set_size_of_fifo(p_fm, + p_port_params->port_id, + &p_port_params->size_of_fifo, + &p_port_params->extra_size_of_fifo, true); + if (err) { + spin_unlock_irqrestore(p_fm->spinlock, int_flags); + return err; + } + + err = fm_set_num_of_open_dmas(p_fm, + p_port_params->port_id, + &p_port_params->num_of_open_dmas, + &p_port_params->num_of_extra_open_dmas, + true); + if (err) { + spin_unlock_irqrestore(p_fm->spinlock, + (unsigned long)int_flags); + return err; + } + + fman_set_liodn_per_port(&fman_rg, + port_id, + p_port_params->liodn_base, + p_port_params->liodn_offset); + + if (p_fm->p_fm_state_struct->rev_info.major_rev < 6) + fman_set_order_restoration_per_port(fman_rg.fpm_rg, + port_id, + !!((p_port_params-> + port_type == + FM_PORT_TYPE_RX))); + + HW_PORT_ID_TO_SW_PORT_ID(p_fm->p_fm_state_struct->rev_info.major_rev, + mac_id, + port_id); + + if (p_port_params->max_frame_length >= + p_fm->p_fm_state_struct->mac_max_frame_lengths[mac_id]) { + p_fm->p_fm_state_struct->port_max_frame_lengths[mac_id] = + p_port_params->max_frame_length; + } else { + pr_warn("Port max_frame_length is smaller than MAC current MTU\n"); + spin_unlock_irqrestore(p_fm->spinlock, + (unsigned long)int_flags); + return -EDOM; + } + + spin_unlock_irqrestore(p_fm->spinlock, (unsigned long)int_flags); + + return 0; +} + +void fm_free_port_params(struct fm_t *p_fm, + struct fm_inter_module_port_free_params_t + *p_port_params) +{ + unsigned long int_flags; + uint8_t port_id = p_port_params->port_id; + uint8_t num_of_tasks, num_of_dmas, mac_id; + uint16_t size_of_fifo; + struct fman_qmi_regs __iomem *qmi_rg = p_fm->p_fm_qmi_regs; + struct fman_bmi_regs __iomem *bmi_rg = p_fm->p_fm_bmi_regs; + + ASSERT(IN_RANGE(1, port_id, 63)); + + spin_lock_irqsave(p_fm->spinlock, int_flags); + + p_fm->p_fm_state_struct->ports_types[port_id] = + FM_PORT_TYPE_DUMMY; + + /* free num_of_tasks */ + num_of_tasks = fman_get_num_of_tasks(bmi_rg, port_id); + ASSERT(p_fm->p_fm_state_struct->accumulated_num_of_tasks >= + num_of_tasks); + p_fm->p_fm_state_struct->accumulated_num_of_tasks -= num_of_tasks; + + /* free num_of_open_dmas */ + num_of_dmas = fman_get_num_of_dmas(bmi_rg, port_id); + ASSERT(p_fm->p_fm_state_struct->accumulated_num_of_open_dmas >= + num_of_dmas); + p_fm->p_fm_state_struct->accumulated_num_of_open_dmas -= num_of_dmas; + +#ifdef FM_HAS_TOTAL_DMAS + if (p_fm->p_fm_state_struct->rev_info.major_rev < 6) { + /* update total num of DMA's with committed number + * of open DMAS, and max uncommitted pool. + */ + fman_set_num_of_open_dmas(bmi_rg, + port_id, + 1, + 0, + (uint8_t) + (p_fm->p_fm_state_struct-> + accumulated_num_of_open_dmas + + p_fm->p_fm_state_struct-> + extra_open_dmas_pool_size + )); + } +#endif /* FM_HAS_TOTAL_DMAS */ + + /* free size_of_fifo */ + size_of_fifo = fman_get_size_of_fifo(bmi_rg, port_id); + ASSERT(p_fm->p_fm_state_struct->accumulated_fifo_size >= + (size_of_fifo * BMI_FIFO_UNITS)); + p_fm->p_fm_state_struct->accumulated_fifo_size -= + (size_of_fifo * BMI_FIFO_UNITS); + +#ifdef FM_QMI_NO_DEQ_OPTIONS_SUPPORT + if (p_fm->p_fm_state_struct->rev_info.major_rev != 4) +#endif /* FM_QMI_NO_DEQ_OPTIONS_SUPPORT */ + /* for transmit&O/H ports */ + if (p_port_params->port_type != FM_PORT_TYPE_RX) { + uint8_t enq_th; + uint8_t deq_th; + + /* update qmi ENQ/DEQ threshold */ + p_fm->p_fm_state_struct->accumulated_num_of_deq_tnums -= + p_port_params->deq_pipeline_depth; + + /* p_fm->p_fm_state_struct-> + * accumulated_num_of_deq_tnums is now smaller, + * so we can enlarge enq_th + */ + enq_th = + (uint8_t)(p_fm->intg->qmi_max_num_of_tnums - + p_fm->p_fm_state_struct-> + accumulated_num_of_deq_tnums - 1); + + /* p_fm->p_fm_state_struct-> + * accumulated_num_of_deq_tnums is now smaller, + * so we can reduce deq_th + */ + deq_th = + (uint8_t)(p_fm->p_fm_state_struct-> + accumulated_num_of_deq_tnums + 1); + + fman_set_qmi_enq_th(qmi_rg, enq_th); + fman_set_qmi_deq_th(qmi_rg, deq_th); + } + + HW_PORT_ID_TO_SW_PORT_ID(p_fm->p_fm_state_struct->rev_info.major_rev, + mac_id, + port_id); + + p_fm->p_fm_state_struct->port_max_frame_lengths[mac_id] = 0; + +#ifdef FM_LOW_END_RESTRICTION + if (p_fm->p_fm_state_struct->rev_info.major_rev == 0x4) { + if ((port_id == 0x1) || (port_id == 0x29)) + p_fm->p_fm_state_struct->low_end_restriction = false; + } +#endif /* FM_LOW_END_RESTRICTION */ + spin_unlock_irqrestore(p_fm->spinlock, int_flags); +} + +int fm_set_size_of_fifo(struct fm_t *p_fm, + uint8_t port_id, + uint32_t *p_size_of_fifo, + uint32_t *p_extra_size_of_fifo, + bool initial_config) +{ + struct fman_bmi_regs __iomem *bmi_rg = p_fm->p_fm_bmi_regs; + uint32_t size_of_fifo = *p_size_of_fifo, extra_size_of_fifo = + *p_extra_size_of_fifo; + uint16_t current_val = 0, current_extra_val = 0; + + ASSERT(IN_RANGE(1, port_id, 63)); + + if (!initial_config) { + /* !initial_config - runtime change of existing value. + * - read the current FIFO and extra FIFO size + */ + current_extra_val = + fman_get_size_of_extra_fifo(bmi_rg, port_id); + current_val = fman_get_size_of_fifo(bmi_rg, port_id); + } + + if (extra_size_of_fifo > current_extra_val) { + if (extra_size_of_fifo && + !p_fm->p_fm_state_struct->extra_fifo_pool_size) + /* if this is the first time a port + * requires extra_fifo_pool_size, + * the total extra_fifo_pool_size + * must be initialized to 1 buffer per port + */ + p_fm->p_fm_state_struct->extra_fifo_pool_size = + p_fm->intg->num_of_rx_ports * BMI_FIFO_UNITS; + + p_fm->p_fm_state_struct->extra_fifo_pool_size = + max(p_fm->p_fm_state_struct->extra_fifo_pool_size, + extra_size_of_fifo); + } + + /* check that there are enough uncommitted fifo size */ + if ((p_fm->p_fm_state_struct->accumulated_fifo_size - current_val + + size_of_fifo) > + (p_fm->p_fm_state_struct->total_fifo_size - + p_fm->p_fm_state_struct->extra_fifo_pool_size)) { + pr_err("Requested fifo size and extra size exceed total FIFO size.\n"); + return -EAGAIN; + } + /* update accumulated */ + ASSERT(p_fm->p_fm_state_struct->accumulated_fifo_size >= + current_val); + p_fm->p_fm_state_struct->accumulated_fifo_size -= current_val; + p_fm->p_fm_state_struct->accumulated_fifo_size += size_of_fifo; + fman_set_size_of_fifo(bmi_rg, port_id, size_of_fifo, + extra_size_of_fifo); + + return 0; +} + +int fm_set_num_of_tasks(struct fm_t *p_fm, + uint8_t port_id, + uint8_t *p_num_of_tasks, + uint8_t *p_num_of_extra_tasks, bool initial_config) +{ + struct fman_bmi_regs __iomem *bmi_rg = p_fm->p_fm_bmi_regs; + uint8_t current_val = 0, current_extra_val = 0, num_of_tasks = + *p_num_of_tasks, num_of_extra_tasks = *p_num_of_extra_tasks; + + ASSERT(IN_RANGE(1, port_id, 63)); + + if (!initial_config) { + /* !initial_config - runtime change of existing value. + * - read the current number of tasks + */ + current_val = fman_get_num_of_tasks(bmi_rg, port_id); + current_extra_val = + fman_get_num_extra_tasks(bmi_rg, port_id); + } + + if (num_of_extra_tasks > current_extra_val) + p_fm->p_fm_state_struct->extra_tasks_pool_size = + (uint8_t)max(p_fm->p_fm_state_struct->extra_tasks_pool_size, + num_of_extra_tasks); + + /* check that there are enough uncommitted tasks */ + if ((p_fm->p_fm_state_struct->accumulated_num_of_tasks - current_val + + num_of_tasks) > + (p_fm->p_fm_state_struct->total_num_of_tasks - + p_fm->p_fm_state_struct->extra_tasks_pool_size)) { + pr_err("Requested num_of_tasks and extra tasks pool for fm%d exceed total num_of_tasks.\n", + p_fm->p_fm_state_struct->fm_id); + return -EAGAIN; + } + ASSERT(p_fm->p_fm_state_struct-> + accumulated_num_of_tasks >= + current_val); + /* update accumulated */ + p_fm->p_fm_state_struct->accumulated_num_of_tasks -= + current_val; + p_fm->p_fm_state_struct->accumulated_num_of_tasks += + num_of_tasks; + fman_set_num_of_tasks(bmi_rg, port_id, num_of_tasks, + num_of_extra_tasks); + + return 0; +} + +int fm_set_num_of_open_dmas(struct fm_t *p_fm, + uint8_t port_id, + uint8_t *p_num_of_open_dmas, + uint8_t *p_num_of_extra_open_dmas, + bool initial_config) +{ + struct fman_bmi_regs __iomem *bmi_rg = p_fm->p_fm_bmi_regs; + uint8_t num_of_open_dmas = *p_num_of_open_dmas, + num_of_extra_open_dmas = *p_num_of_extra_open_dmas; + uint8_t total_num_dmas = 0, current_val = 0, current_extra_val = 0; + + ASSERT(IN_RANGE(1, port_id, 63)); + + if (!initial_config) { + /* !initial_config - runtime change of existing value. + * - read the current number of open Dma's + */ + current_extra_val = + fman_get_num_extra_dmas(bmi_rg, port_id); + current_val = fman_get_num_of_dmas(bmi_rg, port_id); + } + + /* it's illegal to be in a state where this is + * not the first set and no value is specified + */ + ASSERT(initial_config || num_of_open_dmas); + if (!num_of_open_dmas) { + /* !num_of_open_dmas - first configuration according + * to values in regs.- read the current number of + * open Dma's + */ + current_extra_val = + fman_get_num_extra_dmas(bmi_rg, port_id); + current_val = fman_get_num_of_dmas(bmi_rg, port_id); + /* This is the first configuration and user did not + * specify value (!num_of_open_dmas), reset values will be used + * and we just save these values for resource management + */ + p_fm->p_fm_state_struct->extra_open_dmas_pool_size = + (uint8_t)max(p_fm->p_fm_state_struct-> + extra_open_dmas_pool_size, + current_extra_val); + p_fm->p_fm_state_struct->accumulated_num_of_open_dmas += + current_val; + *p_num_of_open_dmas = current_val; + *p_num_of_extra_open_dmas = current_extra_val; + return 0; + } + + if (num_of_extra_open_dmas > current_extra_val) + p_fm->p_fm_state_struct->extra_open_dmas_pool_size = + (uint8_t)max(p_fm->p_fm_state_struct-> + extra_open_dmas_pool_size, + num_of_extra_open_dmas); + +#ifdef FM_HAS_TOTAL_DMAS + if ((p_fm->p_fm_state_struct->rev_info.major_rev < 6) && + (p_fm->p_fm_state_struct->accumulated_num_of_open_dmas - + current_val + num_of_open_dmas > + p_fm->p_fm_state_struct->max_num_of_open_dmas)) { + pr_err("Requested num_of_open_dmas for fm%d exceeds total num_of_open_dmas.\n", + p_fm->p_fm_state_struct->fm_id); + return -EAGAIN; + } +#else + if ((p_fm->p_fm_state_struct->rev_info.major_rev >= 6) && + #ifdef FM_HEAVY_TRAFFIC_SEQUENCER_HANG_ERRATA_FMAN_A006981 + !((p_fm->p_fm_state_struct->rev_info.major_rev == 6) && + (p_fm->p_fm_state_struct->rev_info.minor_rev == 0)) && +#endif /* FM_HEAVY_TRAFFIC_SEQUENCER_HANG_ERRATA_FMAN_A006981 */ + (p_fm->p_fm_state_struct->accumulated_num_of_open_dmas - + current_val + num_of_open_dmas > + p_fm->intg->dma_thresh_max_commq + 1)) { + pr_err("Requested num_of_open_dmas for fm%d exceeds DMA Command queue (%d)\n", + p_fm->p_fm_state_struct->fm_id, + p_fm->intg->dma_thresh_max_commq + 1); + return -EAGAIN; + } +#endif /* FM_HAS_TOTAL_DMAS */ + else { + ASSERT(p_fm->p_fm_state_struct-> + accumulated_num_of_open_dmas >= + current_val); + /* update acummulated */ + p_fm->p_fm_state_struct->accumulated_num_of_open_dmas -= + current_val; + p_fm->p_fm_state_struct->accumulated_num_of_open_dmas += + num_of_open_dmas; + +#ifdef FM_HAS_TOTAL_DMAS + if (p_fm->p_fm_state_struct->rev_info.major_rev < 6) + total_num_dmas = + (uint8_t)(p_fm->p_fm_state_struct-> + accumulated_num_of_open_dmas + + p_fm->p_fm_state_struct-> + extra_open_dmas_pool_size); +#endif /* FM_HAS_TOTAL_DMAS */ + fman_set_num_of_open_dmas(bmi_rg, + port_id, + num_of_open_dmas, + num_of_extra_open_dmas, + total_num_dmas); + } + + return 0; +} + int fm_reset_mac(struct fm_t *p_fm, uint8_t mac_id) { int err; @@ -908,6 +1389,7 @@ static int init_fm_qmi(struct fm_t *p_fm) void *fm_config(struct fm_params_t *p_fm_param) { struct fm_t *p_fm; + uint8_t i; uintptr_t base_addr; if (!((p_fm_param->firmware.p_code && p_fm_param->firmware.size) || @@ -932,6 +1414,9 @@ void *fm_config(struct fm_params_t *p_fm_param) /* Initialize FM parameters which will be kept by the driver */ p_fm->p_fm_state_struct->fm_id = p_fm_param->fm_id; + for (i = 0; i < FM_MAX_NUM_OF_HW_PORT_IDS; i++) + p_fm->p_fm_state_struct->ports_types[i] = FM_PORT_TYPE_DUMMY; + /* Allocate the FM driver's parameters structure */ p_fm->p_fm_drv_param = kzalloc(sizeof(*p_fm->p_fm_drv_param), GFP_KERNEL); diff --git a/drivers/net/ethernet/freescale/fman/fm_common.h b/drivers/net/ethernet/freescale/fman/fm_common.h index 45c450b..af9ba6a 100644 --- a/drivers/net/ethernet/freescale/fman/fm_common.h +++ b/drivers/net/ethernet/freescale/fman/fm_common.h @@ -82,6 +82,14 @@ #define CLS_PLAN_NUM_PER_GRP 8 +/* Defines used for manipulation CC and BMI */ +#define UPDATE_NIA_PNEN 0x80000000 +#define UPDATE_NIA_PNDN 0x20000000 +#define UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY 0x10000000 +#define UPDATE_NIA_FENE 0x04000000 +#define UPDATE_NIA_CMNE 0x02000000 +#define UPDATE_NIA_FPNE 0x01000000 + /* list_object * Macro to get the struct (object) for this entry. * type - The type of the struct (object) this list @@ -94,6 +102,12 @@ #define list_object(p_list, type, member) \ ((type *)((char *)(p_list) - member_offset(type, member))) +#define FM_LIODN_OFFSET_MASK 0x3FF + +/* NIA Description */ +/* V3 only */ +#define NIA_FM_CTL_AC_NO_IPACC_PRE_BMI_ENQ_FRAME 0x00000028 + /* Enum for inter-module interrupts registration */ enum fm_event_modules { FM_MOD_PRS = 0, /* Parser event */ @@ -209,6 +223,59 @@ static inline bool TRY_LOCK(spinlock_t *spinlock, volatile bool *p_flag) #define FM_LIODN_OFFSET_MASK 0x3FF +/* NIA Description */ +#define NIA_ENG_MASK 0x007C0000 +#define NIA_AC_MASK 0x0003ffff + +#define NIA_ORDER_RESTOR 0x00800000 +#define NIA_ENG_FM_CTL 0x00000000 +#define NIA_ENG_PRS 0x00440000 +#define NIA_ENG_BMI 0x00500000 +#define NIA_ENG_QMI_ENQ 0x00540000 +#define NIA_ENG_QMI_DEQ 0x00580000 + +#define NIA_FM_CTL_AC_HC 0x0000000C +#define NIA_FM_CTL_AC_IND_MODE_TX 0x00000008 +#define NIA_FM_CTL_AC_IND_MODE_RX 0x0000000A +#define NIA_FM_CTL_AC_POP_TO_N_STEP 0x0000000e +#define NIA_FM_CTL_AC_PRE_BMI_FETCH_HEADER 0x00000010 +#define NIA_FM_CTL_AC_PRE_BMI_FETCH_FULL_FRAME 0x00000018 +#define NIA_FM_CTL_AC_POST_BMI_FETCH 0x00000012 +#define NIA_FM_CTL_AC_PRE_BMI_ENQ_FRAME 0x0000001A +#define NIA_FM_CTL_AC_PRE_BMI_DISCARD_FRAME 0x0000001E +#define NIA_FM_CTL_AC_POST_BMI_ENQ_ORR 0x00000014 +#define NIA_FM_CTL_AC_POST_BMI_ENQ 0x00000022 +#define NIA_FM_CTL_AC_POST_TX 0x00000024 +/* V3 only */ +#define NIA_FM_CTL_AC_NO_IPACC_PRE_BMI_ENQ_FRAME 0x00000028 +#define NIA_FM_CTL_AC_NO_IPACC_PRE_BMI_DISCARD_FRAME 0x0000002A +#define NIA_FM_CTL_AC_NO_IPACC_POP_TO_N_STEP 0x0000002C + +#define NIA_BMI_AC_ENQ_FRAME 0x00000002 +#define NIA_BMI_AC_TX_RELEASE 0x000002C0 +#define NIA_BMI_AC_RELEASE 0x000000C0 +#define NIA_BMI_AC_DISCARD 0x000000C1 +#define NIA_BMI_AC_TX 0x00000274 +#define NIA_BMI_AC_FETCH 0x00000208 +#define NIA_BMI_AC_MASK 0x000003FF + +#define NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA 0x00000202 + +#define GET_NIA_BMI_AC_ENQ_FRAME(GET_NIA_BMI_AC_ENQ_FRAME, errata_A006675)\ + (errata_A006675 ? \ + ((uint32_t)(NIA_ENG_FM_CTL | \ + NIA_FM_CTL_AC_NO_IPACC_PRE_BMI_ENQ_FRAME)) : \ + ((uint32_t)(NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME))) +#define GET_NIA_BMI_AC_DISCARD_FRAME(h_fm_pcd, errata_A006675) \ + (errata_A006675 ? \ + ((uint32_t)(NIA_ENG_FM_CTL | \ + NIA_FM_CTL_AC_NO_IPACC_PRE_BMI_DISCARD_FRAME)) : \ + ((uint32_t)(NIA_ENG_BMI | NIA_BMI_AC_DISCARD))) +#define GET_NO_PCD_NIA_BMI_AC_ENQ_FRAME(errata_A006675) \ + (errata_A006675 ? \ + (NIA_ENG_FM_CTL | NIA_FM_CTL_AC_NO_IPACC_PRE_BMI_ENQ_FRAME) :\ + (NIA_ENG_BMI | NIA_BMI_AC_ENQ_FRAME)) + /* Description CTRL Parameters Page defines */ #define FM_CTL_PARAMS_PAGE_OP_FIX_EN 0x80000000 #define FM_CTL_PARAMS_PAGE_ALWAYS_ON 0x00000100 @@ -239,6 +306,20 @@ do { \ } \ } while (0) +#define HW_PORT_ID_TO_SW_PORT_ID(major, _mac_id, port_id) \ +do { \ + if (port_id >= BASE_TX_PORTID) \ + _mac_id = (uint8_t)(port_id - BASE_TX_PORTID); \ + else if (port_id >= BASE_RX_PORTID) \ + _mac_id = (uint8_t)(port_id - BASE_RX_PORTID); \ + else if (port_id >= BASE_OH_PORTID(major)) \ + _mac_id = (uint8_t)(port_id - BASE_OH_PORTID(major)); \ + else { \ + _mac_id = (uint8_t)DUMMY_PORT_ID; \ + ASSERT(true); \ + } \ +} while (0) + #define BMI_MAX_FIFO_SIZE (FM_MURAM_SIZE) #define BMI_FIFO_UNITS 0x100 @@ -337,6 +418,53 @@ enum fm_mac_type { FM_MAC_1G /* 1G MAC */ }; +/* Description Structure for port-FM communication + * during fm_port_init. Fields commented 'IN' are passed + * by the port module to be used by the FM module. + * Fields commented 'OUT' will be filled by FM before returning to port. + * Some fields are optional (depending on configuration) and + * will be analized by the port and FM modules accordingly. + */ +struct fm_inter_module_port_init_params_t { + uint8_t port_id; + /* IN. port Id */ + enum fm_port_type port_type; + /* IN. Port type */ + enum fm_port_speed port_speed; + /* IN. Port speed */ + /* IN. Port's requested resource*/ + uint16_t liodn_offset; + /* IN. Port's requested resource */ + uint8_t num_of_tasks; + /* IN. Port's requested resource */ + uint8_t num_of_extra_tasks; + /* IN. Port's requested resource */ + uint8_t num_of_open_dmas; + /* IN. Port's requested resource */ + uint8_t num_of_extra_open_dmas; + /* IN. Port's requested resource */ + uint32_t size_of_fifo; + /* IN. Port's requested resource */ + uint32_t extra_size_of_fifo; + /* IN. Port's requested resource */ + uint8_t deq_pipeline_depth; + /* IN. Port's max frame length. */ + uint16_t max_frame_length; + /* IN. Irrelevant for P4080 rev 1. + * LIODN base for this port, to be + * used together with LIODN offset. + */ + uint16_t liodn_base; +}; + +/* Description Structure for port-FM communication during fm_port_free.*/ +struct fm_inter_module_port_free_params_t { + uint8_t port_id; /* IN. port Id */ + enum fm_port_type port_type; /* IN. Port type */ + enum fm_port_speed port_speed; /* IN. Port speed */ + uint8_t deq_pipeline_depth; /* IN. Port's requested resource */ +}; + /* Function fm_get_muram_pointer * Description Get the pointer of the MURAM from the FM module * Param[in] h_fm A handle to an FM Module. @@ -379,6 +507,29 @@ uint16_t fm_get_clock_freq(struct fm_t *p_fm); */ uint8_t fm_get_id(struct fm_t *p_fm); +/* Function fm_get_set_port_params + * Description Used by FM-PORT driver to pass and receive parameters between + * PORT and FM modules. + * Param[in] h_fm A handle to an FM Module. + * Param[in,out] p_port_params A structure of FM Port parameters. + * Return 0 on success; Error code otherwise. + * Cautions Allowed only following fm_init(). + */ +int fm_get_set_port_params(struct fm_t *p_fm, + struct fm_inter_module_port_init_params_t + *p_port_params); + +/* Function fm_free_port_params + * Description Used by FM-PORT driver to free port's resources within the FM. + * Param[in] h_fm A handle to an FM Module. + * Param[in,out] p_port_params A structure of FM Port parameters. + * Return None. + * Cautions Allowed only following fm_init(). + */ +void fm_free_port_params(struct fm_t *p_fm, + struct fm_inter_module_port_free_params_t + *p_port_params); + #ifdef FM_TX_ECC_FRMS_ERRATA_10GMAC_A004 int fm_10g_tx_ecc_workaround(struct fm_t *p_fm, uint8_t mac_id); #endif /* FM_TX_ECC_FRMS_ERRATA_10GMAC_A004 */ @@ -404,5 +555,22 @@ struct num_of_ports_info_t *fm_get_num_of_ports(struct fm_t *p_fm); int fm_set_mac_max_frame(struct fm_t *p_fm, enum fm_mac_type type, uint8_t mac_id, uint16_t mtu); +int fm_set_num_of_open_dmas(struct fm_t *p_fm, + uint8_t port_id, + uint8_t *p_num_of_open_dmas, + uint8_t *p_num_of_extra_open_dmas, + bool initial_config); +int fm_set_num_of_tasks(struct fm_t *p_fm, + uint8_t port_id, + uint8_t *p_num_of_tasks, + uint8_t *p_num_of_extra_tasks, + bool initial_config); +int fm_set_size_of_fifo(struct fm_t *p_fm, + uint8_t port_id, + uint32_t *p_size_of_fifo, + uint32_t *p_extra_size_of_fifo, + bool initial_config); + +uint32_t fm_get_bmi_max_fifo_size(struct fm_t *p_fm); #endif /* __FM_COMMON_H */ diff --git a/drivers/net/ethernet/freescale/fman/fm_drv.c b/drivers/net/ethernet/freescale/fman/fm_drv.c index 2c78829..c0a2c70 100644 --- a/drivers/net/ethernet/freescale/fman/fm_drv.c +++ b/drivers/net/ethernet/freescale/fman/fm_drv.c @@ -217,6 +217,72 @@ static void destroy_fm_dev(struct fm_drv_t *p_fm_drv) kfree(p_fm_drv); } +static int fill_rest_fm_info(struct fm_drv_t *p_fm_drv) +{ +#define FM_BMI_PPIDS_OFFSET 0x00080304 +#define FM_DMA_PLR_OFFSET 0x000c2060 +#define FM_FPM_IP_REV_1_OFFSET 0x000c30c4 +#define DMA_HIGH_LIODN_MASK 0x0FFF0000 +#define DMA_LOW_LIODN_MASK 0x00000FFF +#define DMA_LIODN_SHIFT 16 + +/* These need to be moved to FLib: */ + struct plr_t { + uint32_t plr[32]; + } __attribute__((__packed__)); + + struct ppids_t { + volatile uint32_t fmbm_ppid[63]; + } __attribute__((__packed__)); + + struct plr_t *p_plr; + struct ppids_t *p_ppids; + int i; + uint32_t fm_rev; + + fm_rev = (uint32_t)(*((volatile uint32_t *) + UINT_TO_PTR(p_fm_drv->fm_base_addr + + FM_FPM_IP_REV_1_OFFSET))); + fm_rev &= 0xffff; + + p_plr = + (struct plr_t *)UINT_TO_PTR(p_fm_drv->fm_base_addr + + FM_DMA_PLR_OFFSET); +#ifdef MODULE + for (i = 0; i < FM_MAX_NUM_OF_PARTITIONS / 2; i++) + p_plr->plr[i] = 0; +#endif /* MODULE */ + + for (i = 0; i < FM_MAX_NUM_OF_PARTITIONS; i++) { + uint16_t liodn_base; + + liodn_base = (uint16_t)((i % 2) ? + (p_plr->plr[i / 2] & DMA_LOW_LIODN_MASK) : + ((p_plr->plr[i / 2] & DMA_HIGH_LIODN_MASK) >> + DMA_LIODN_SHIFT)); +#ifdef FM_PARTITION_ARRAY + p_fm_drv->params.liodn_base_per_port[i] = liodn_base; +#endif /* FM_PARTITION_ARRAY */ + + if (((i >= FIRST_RX_PORT) && (i <= LAST_RX_PORT)) || + ((i >= FIRST_TX_PORT) && (i <= LAST_TX_PORT)) || + ((i >= FIRST_OP_PORT( + p_fm_drv->fm_rev_info.major_rev)) && + (i <= LAST_OP_PORT))) + p_fm_drv->ports[i].port_params.liodn_base = + liodn_base; + } + + p_ppids = (struct ppids_t *) + UINT_TO_PTR(p_fm_drv->fm_base_addr + FM_BMI_PPIDS_OFFSET); + + for (i = FIRST_RX_PORT; i <= LAST_RX_PORT; i++) + p_fm_drv->ports[i].port_params.specific_params. + rx_params.liodn_offset = (u16)(p_ppids->fmbm_ppid[i - 1]); + + return 0; +} + /** *find_fman_microcode - find the Fman microcode * @@ -542,7 +608,7 @@ static int configure_fm_dev(struct fm_drv_t *p_fm_drv) p_fm_drv->params.f_bus_error = fm_drv_bus_error_cb; p_fm_drv->params.h_app = p_fm_drv; - return 0; + return fill_rest_fm_info(p_fm_drv); } static int init_fm_dev(struct fm_drv_t *p_fm_drv) @@ -791,6 +857,46 @@ void *fm_get_handle(struct fm *fm) EXPORT_SYMBOL(fm_get_handle); +struct fm_port_drv_t *fm_port_bind(struct device *fm_port_dev) +{ + return (struct fm_port_drv_t *) + (dev_get_drvdata(get_device(fm_port_dev))); +} +EXPORT_SYMBOL(fm_port_bind); + +void fm_port_unbind(struct fm_port_drv_t *p_port) +{ + put_device(p_port->dev); +} +EXPORT_SYMBOL(fm_port_unbind); + +struct fm_port_t *fm_port_drv_handle(const struct fm_port_drv_t *p_port) +{ + return p_port->h_dev; +} +EXPORT_SYMBOL(fm_port_drv_handle); + +void fm_port_get_base_addr(const struct fm_port_drv_t *p_port, + uint64_t *base_addr) +{ + *base_addr = p_port->port_params.base_addr; +} +EXPORT_SYMBOL(fm_port_get_base_addr); + +void fm_port_get_buff_layout_ext_params(struct fm_port_drv_t *p_port, + struct fm_port_params *params) +{ + /* TODO - Should this function be removed? */ + params->data_align = 0; +} +EXPORT_SYMBOL(fm_port_get_buff_layout_ext_params); + +int fm_get_tx_port_channel(struct fm_port_drv_t *p_port) +{ + return p_port->tx_ch; +} +EXPORT_SYMBOL(fm_get_tx_port_channel); + void fm_mutex_lock(void) { mutex_lock(&fm_drv_mutex); diff --git a/drivers/net/ethernet/freescale/fman/fm_drv.h b/drivers/net/ethernet/freescale/fman/fm_drv.h index 2acd77b..c26836f 100644 --- a/drivers/net/ethernet/freescale/fman/fm_drv.h +++ b/drivers/net/ethernet/freescale/fman/fm_drv.h @@ -35,6 +35,7 @@ #include "service.h" #include "fsl_fman_drv.h" +#include "fm_port_ext.h" /* FMan Driver Errata */ #define FM_BCB_ERRATA_BMI_SW001 /* T/B */ @@ -75,6 +76,7 @@ struct fm_port_drv_t { uint64_t phys_base_addr; uint64_t base_addr; /* Port's *virtual* address */ resource_size_t mem_size; + struct fm_port_params_t port_params; struct fm_buffer_prefix_content_t buff_prefix_content; struct fm_port_t *h_dev; struct fm_drv_t *p_fm; diff --git a/drivers/net/ethernet/freescale/fman/fm_port_drv.c b/drivers/net/ethernet/freescale/fman/fm_port_drv.c new file mode 100644 index 0000000..91a7353 --- /dev/null +++ b/drivers/net/ethernet/freescale/fman/fm_port_drv.c @@ -0,0 +1,496 @@ +/* + * Copyright 2008-2015 Freescale Semiconductor Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Freescale Semiconductor nor the + * names of its contributors may 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") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``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 Freescale Semiconductor 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. + */ + +/*File fm_port_drv.c + *Description FMan driver - FMan port functions. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "fm_common.h" +#include "fsl_fman_drv.h" +#include "fm_port_ext.h" +#include "fm_drv.h" + +static struct fm_port_drv_t +*read_fm_port_dev_tree_node(struct platform_device *of_dev) +{ + struct fm_drv_t *p_fm; + struct fm_port_drv_t *p_port; + struct device_node *fm_node, *port_node; + struct resource res; + const uint32_t *uint32_prop; + int _errno = 0, lenp; + enum fm_port_type port_type; + enum fm_port_speed port_speed; + u8 cell_index; + + port_node = of_node_get(of_dev->dev.of_node); + + /* Get the FM node */ + fm_node = of_get_parent(port_node); + if (unlikely(!fm_node)) { + pr_err("of_get_parent() = %d\n", _errno); + return NULL; + } + + p_fm = dev_get_drvdata(&of_find_device_by_node(fm_node)->dev); + of_node_put(fm_node); + + /* if fm_probe() failed, no point in going further with port probing */ + if (!p_fm) + return NULL; + + uint32_prop = + (uint32_t *)of_get_property(port_node, "cell-index", &lenp); + if (unlikely(!uint32_prop)) { + pr_err("of_get_property(%s, cell-index) failed\n", + port_node->full_name); + return NULL; + } + if (WARN_ON(lenp != sizeof(uint32_t))) + return NULL; + cell_index = (u8)*uint32_prop; + + p_port = &p_fm->ports[cell_index]; + p_port->id = cell_index; + p_port->port_params.port_id = p_port->id; + + if (of_device_is_compatible(port_node, "fsl,fman-v2-port-oh") || + of_device_is_compatible(port_node, "fsl,fman-v3-port-oh")) { + port_type = FM_PORT_TYPE_OP; + port_speed = FM_PORT_SPEED_OP; + + } else if (of_device_is_compatible(port_node, "fsl,fman-v3-port-tx")) { + port_type = FM_PORT_TYPE_TX; + port_speed = FM_PORT_SPEED_1G; + uint32_prop = (uint32_t *)of_get_property(port_node, + "fsl,fman-10g-port", + &lenp); + if (uint32_prop) + port_speed = FM_PORT_SPEED_10G; + + } else if (of_device_is_compatible(port_node, "fsl,fman-v2-port-tx")) { + if (cell_index >= TX_10G_PORT_BASE) + port_speed = FM_PORT_SPEED_10G; + else + port_speed = FM_PORT_SPEED_1G; + port_type = FM_PORT_TYPE_TX; + + } else if (of_device_is_compatible(port_node, "fsl,fman-v3-port-rx")) { + port_type = FM_PORT_TYPE_RX; + port_speed = FM_PORT_SPEED_1G; + uint32_prop = (uint32_t *)of_get_property(port_node, + "fsl,fman-10g-port", + &lenp); + if (uint32_prop) + port_speed = FM_PORT_SPEED_10G; + + } else if (of_device_is_compatible(port_node, "fsl,fman-v2-port-rx")) { + if (cell_index >= RX_10G_PORT_BASE) + port_speed = FM_PORT_SPEED_10G; + else + port_speed = FM_PORT_SPEED_1G; + port_type = FM_PORT_TYPE_RX; + + } else { + pr_err("Illegal port type\n"); + return NULL; + } + + p_port->port_params.port_type = port_type; + p_port->port_params.port_speed = port_speed; + + if (port_type == FM_PORT_TYPE_OP || port_type == FM_PORT_TYPE_TX) { + uint32_t qman_channel_id; + + qman_channel_id = get_qman_channel_id(p_fm, cell_index, + port_type, port_speed); + + if (qman_channel_id == 0) { + pr_err("incorrect qman-channel-id\n"); + return NULL; + } + p_port->tx_ch = qman_channel_id; + p_port->port_params.specific_params.non_rx_params.qm_channel = + qman_channel_id; + } + + _errno = of_address_to_resource(port_node, 0, &res); + if (unlikely(_errno < 0)) { + pr_err("of_address_to_resource() = %d\n", _errno); + return NULL; + } + + p_port->dev = &of_dev->dev; + p_port->base_addr = 0; + p_port->phys_base_addr = res.start; + p_port->mem_size = res.end + 1 - res.start; + p_port->port_params.h_fm = p_fm->h_dev; + p_port->p_fm = (void *)p_fm; + + of_node_put(port_node); + + p_port->active = true; + + return p_port; +} + +static int configure_fm_port_dev(struct fm_port_drv_t *p_port) +{ + struct fm_drv_t *p_fm = (struct fm_drv_t *)p_port->p_fm; + struct resource *dev_res; + + if (!p_port->active) { + pr_err("FM port not configured!!!\n"); + return -EINVAL; + } + + dev_res = __devm_request_region(p_fm->dev, p_fm->res, + p_port->phys_base_addr, + p_port->mem_size, + "fman-port-hc"); + if (unlikely(!dev_res)) { + pr_err("__devm_request_region() failed\n"); + return -EINVAL; + } + p_port->base_addr = PTR_TO_UINT(devm_ioremap(p_fm->dev, + p_port->phys_base_addr, + p_port->mem_size)); + if (unlikely(p_port->base_addr == 0)) + pr_err("devm_ioremap() failed\n"); + + p_port->port_params.base_addr = p_port->base_addr; + + return 0; +} + +static int init_fm_port_dev(struct fm_port_drv_t *p_port) +{ + struct fm_drv_t *p_fm = (struct fm_drv_t *)p_port->p_fm; + + if (!p_port->active || p_port->h_dev) + return -EINVAL; + + p_port->h_dev = fm_port_config(&p_port->port_params); + if (!p_port->h_dev) { + pr_err("FM-port\n"); + return -EINVAL; + } + + if (fm_get_revision(p_fm->h_dev, &p_port->fm_rev_info) != 0) { + pr_err("FM-port\n"); + return -EINVAL; + } + +#ifdef FM_QMI_NO_DEQ_OPTIONS_SUPPORT + if ((p_port->fm_rev_info.major_rev != 4) && + (p_port->port_params.port_type == FM_PORT_TYPE_TX)) { + int err_code = 0; + + err_code = fm_port_cfg_deq_high_priority(p_port->h_dev, true); + if (err_code != 0) + return -err_code; + err_code = + fm_port_cfg_deq_prefetch_option(p_port->h_dev, + FM_PORT_DEQ_FULL_PREFETCH); + if (err_code != 0) + return -err_code; + } +#endif /* !FM_QMI_NO_DEQ_OPTIONS_SUPPORT */ + +#ifdef FM_BCB_ERRATA_BMI_SW001 +/* Configure BCB workaround on Rx ports, only for B4860 rev1 */ +#define SVR_SECURITY_MASK 0x00080000 +#define SVR_PERSONALITY_MASK 0x0000FF00 +#define SVR_VER_IGNORE_MASK (SVR_SECURITY_MASK | SVR_PERSONALITY_MASK) +#define SVR_B4860_REV1_VALUE 0x86800010 + + if ((p_port->fm_rev_info.major_rev >= 6) && + (p_port->port_params.port_type == FM_PORT_TYPE_RX)) { + unsigned int svr; + + svr = mfspr(SPRN_SVR); + + if ((svr & ~SVR_VER_IGNORE_MASK) == SVR_B4860_REV1_VALUE) + fm_port_cfg_bcb_wa(p_port->h_dev); + } +#endif /* FM_BCB_ERRATA_BMI_SW001 */ + + fm_port_cfg_buf_prefix_content(p_port->h_dev, + &p_port->buff_prefix_content); + + if (fm_port_init(p_port->h_dev) != 0) + return -EINVAL; + +/** + * FMan Fifo sizes behind the scene": + * Using the following formulae (*), under a set of simplifying assumptions (.): + * . all ports are configured in Normal Mode (rather than Independent Mode) + * . the DPAA Eth driver allocates buffers of size: + * . MAXFRM + NET_IP_ALIGN + DPA_PRIV_DATA_SIZE + DPA_PARSE_RESULTS_SIZE + * + DPA_HASH_RESULTS_SIZE, i.e.: + * MAXFRM + 2 + 16 + sizeof(fm_prs_result_t) + 16, i.e.: + * MAXFRM + 66 + * . excessive buffer pools not accounted for + * + **for Rx ports on P4080: + * . IFSZ = ceil(max(FMBM_EBMPI[PBS]) / 256)*256 + 7*256 + * . no internal frame offset (FMBM_RIM[FOF] == 0) - otherwise, + * add up to 256 to the above + * + **for Rx ports on P1023: + * . IFSZ = ceil(second_largest(FMBM_EBMPI[PBS] / 256))*256 + 7*256, + * if at least 2 bpools are configured + * . IFSZ = 8*256, if only a single bpool is configured + * + **for Tx ports: + * . IFSZ = ceil(frame_size / 256)*256 + 3*256 + * + FMBM_TFP[DPDE]*256, i.e.: + * IFSZ = ceil(MAXFRM / 256)*256 + 3 x 256 + FMBM_TFP[DPDE]*256 + * + **for OH ports on P4080: + * . IFSZ = ceil(frame_size / 256)*256 + 1*256 + FMBM_PP[MXT]*256 + **for OH ports on P1023: + * . IFSZ = ceil(frame_size / 256)*256 + 3*256 + FMBM_TFP[DPDE]*256 + **for both P4080 and P1023: + * . (conservative decisions, assuming that BMI must bring the entire + * frame, not only the frame header) + * . no internal frame offset (FMBM_OIM[FOF] == 0) - otherwise, + * add up to 256 to the above + * + * . for P4080/P5020/P3041/P2040, DPDE is: + * > 0 or 1, for 1Gb ports, HW default: 0 + * > 2..7 (recommended: 3..7) for 10Gb ports, HW default: 3 + * . for P1023, DPDE should be 1 + * + * . for P1023, MXT is in range (0..31) + * . for P4080, MXT is in range (0..63) + * + */ + return 0; +} + +void fm_set_rx_port_params(struct fm_port_drv_t *p_port, + struct fm_port_params *params) +{ + int i; + + p_port->port_params.specific_params.rx_params.err_fqid = params->errq; + p_port->port_params.specific_params.rx_params.dflt_fqid = params->defq; + p_port->port_params.specific_params.rx_params. + ext_buf_pools.num_of_pools_used = params->num_pools; + for (i = 0; i < params->num_pools; i++) { + p_port->port_params.specific_params.rx_params.ext_buf_pools. + ext_buf_pool[i].id = params->pool_param[i].id; + p_port->port_params.specific_params.rx_params.ext_buf_pools. + ext_buf_pool[i].size = params->pool_param[i].size; + } + + p_port->buff_prefix_content.priv_data_size = params->priv_data_size; + p_port->buff_prefix_content.pass_prs_result = params->parse_results; + p_port->buff_prefix_content.pass_hash_result = params->hash_results; + p_port->buff_prefix_content.pass_time_stamp = params->time_stamp; + p_port->buff_prefix_content.data_align = params->data_align; + + init_fm_port_dev(p_port); +} +EXPORT_SYMBOL(fm_set_rx_port_params); + +/* this function is called from oh_probe as well, thus it contains oh port + * specific parameters (make sure everything is checked) + **/ +void fm_set_tx_port_params(struct fm_port_drv_t *p_port, + struct fm_port_params *params) +{ + p_port->port_params.specific_params.non_rx_params.err_fqid = + params->errq; + p_port->port_params.specific_params.non_rx_params.dflt_fqid = + params->defq; + + p_port->buff_prefix_content.priv_data_size = params->priv_data_size; + p_port->buff_prefix_content.pass_prs_result = params->parse_results; + p_port->buff_prefix_content.pass_hash_result = params->hash_results; + p_port->buff_prefix_content.pass_time_stamp = params->time_stamp; + p_port->buff_prefix_content.data_align = params->data_align; + + init_fm_port_dev(p_port); +} +EXPORT_SYMBOL(fm_set_tx_port_params); + +static void free_fm_port_dev(struct fm_port_drv_t *p_port) +{ + struct fm_drv_t *p_fm = (struct fm_drv_t *)p_port->p_fm; + + if (!p_port->active) + return; + + if (p_port->h_dev) + fm_port_free(p_port->h_dev); + + devm_iounmap(p_port->dev, UINT_TO_PTR(p_port->base_addr)); + __devm_release_region(p_fm->dev, p_fm->res, p_port->phys_base_addr, + p_port->mem_size); +} + +static int /*__devinit*/ fm_port_probe(struct platform_device *of_dev) +{ + struct fm_port_drv_t *p_port; + struct fm_drv_t *p_fm; + struct device *dev; + + dev = &of_dev->dev; + + p_port = read_fm_port_dev_tree_node(of_dev); + if (!p_port) + return -EIO; + /* Port can be inactive, thus will not be probed: + * - in performance mode, OH ports are disabled ... + **/ + if (!p_port->active) + return 0; + + if (configure_fm_port_dev(p_port) != 0) + return -EIO; + + dev_set_drvdata(dev, p_port); + + p_fm = (struct fm_drv_t *)p_port->p_fm; + + if (p_port->port_params.port_type == FM_PORT_TYPE_RX) { + snprintf(p_port->name, sizeof(p_port->name), + "%s-port-rx%d", p_fm->name, p_port->id); + } else if (p_port->port_params.port_type == FM_PORT_TYPE_TX) { + snprintf(p_port->name, sizeof(p_port->name), + "%s-port-tx%d", p_fm->name, p_port->id); + } else if (p_port->port_params.port_type == FM_PORT_TYPE_OP) { + snprintf(p_port->name, sizeof(p_port->name), + "%s-port-oh%d", p_fm->name, p_port->id + 1); + } +#ifdef FM_TX_INVALID_ECC_ERRATA_10GMAC_A009 + if (p_port->fm_rev_info.major_rev < 6 && + p_port->fm_rev_info.major_rev != 4) + fm_disable_rams_ecc(p_fm->h_dev); +#endif /* FM_TX_INVALID_ECC_ERRATA_10GMAC_A009 */ + + pr_debug("%s probed\n", p_port->name); + + return 0; +} + +static int fm_port_remove(struct platform_device *of_dev) +{ + struct fm_port_drv_t *p_port; + struct fm_drv_t *p_fm; + struct device *dev; + + dev = &of_dev->dev; + p_port = dev_get_drvdata(dev); + + p_fm = (struct fm_drv_t *)p_port->p_fm; + + free_fm_port_dev(p_port); + + dev_set_drvdata(dev, NULL); + + return 0; +} + +static const struct of_device_id fm_port_match[] = { + { + .compatible = "fsl,fman-v3-port-oh"}, + { + .compatible = "fsl,fman-v2-port-oh"}, + { + .compatible = "fsl,fman-v3-port-rx"}, + { + .compatible = "fsl,fman-v2-port-rx"}, + { + .compatible = "fsl,fman-v3-port-tx"}, + { + .compatible = "fsl,fman-v2-port-tx"}, + {} +}; + +#ifndef MODULE +MODULE_DEVICE_TABLE(of, fm_port_match); +#endif /* !MODULE */ + +static struct platform_driver fm_port_driver = { + .driver = { + .name = "fsl-fman-port", + .of_match_table = fm_port_match, + }, + .probe = fm_port_probe, + .remove = fm_port_remove +}; + +int fm_port_drv_init(void) +{ + /* Register to the DTB for basic FM port API */ + if (platform_driver_register(&fm_port_driver)) + return -ENODEV; + + return 0; +} + +void fm_port_drv_free(void) +{ + platform_driver_unregister(&fm_port_driver); +} + +static int __init __cold fm_port_load(void) +{ + if (fm_port_drv_init() != 0) { + pr_crit("Failed to init FM Ports wrapper!\n"); + return -ENODEV; + } + + pr_info("Freescale FM Ports module\n"); + + return 0; +} + +static void __exit __cold fm_port_unload(void) +{ + fm_port_drv_free(); +} + +module_init(fm_port_load); +module_exit(fm_port_unload); diff --git a/drivers/net/ethernet/freescale/fman/inc/fm_port_ext.h b/drivers/net/ethernet/freescale/fman/inc/fm_port_ext.h new file mode 100644 index 0000000..0de6801 --- /dev/null +++ b/drivers/net/ethernet/freescale/fman/inc/fm_port_ext.h @@ -0,0 +1,376 @@ +/* + * Copyright 2008-2015 Freescale Semiconductor Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Freescale Semiconductor nor the + * names of its contributors may 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") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``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 Freescale Semiconductor 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. + */ + +/*File fm_port_ext.h + *FM-Port Application Programming Interface. + */ +#ifndef __FM_PORT_EXT +#define __FM_PORT_EXT + +#include "service.h" +#include "fm_ext.h" +#include "net_ext.h" + +/* FMan Port Errata */ +#define FM_HEAVY_TRAFFIC_HANG_ERRATA_FMAN_A005669 /* T/B */ + +/* FM Port API + * The FM uses a general module called "port" to represent a Tx port (MAC), + * an Rx port (MAC) or Offline Parsing port. + * The number of ports in an FM varies between SOCs. + * The SW driver manages these ports as sub-modules of the FM,i.e. after an + * FM is initialized, its ports may be initialized and operated upon. + * The port is initialized aware of its type, but other functions on a port + * may be indifferent to its type. When necessary, the driver verifies + * coherence and returns error if applicable. + * On initialization, user specifies the port type and it's index (relative + * to the port's type) - always starting at 0. + */ + +/* General FM Port defines */ +/* Number of 4 bytes words in parser result */ +#define FM_PORT_PRS_RESULT_NUM_OF_WORDS 8 +/* @} */ + +/* FM Frame error */ +/* Frame Descriptor errors */ +/* Not for Rx-Port! Unsupported Format */ +#define FM_PORT_FRM_ERR_UNSUPPORTED_FORMAT FM_FD_ERR_UNSUPPORTED_FORMAT +/* Not for Rx-Port! Length Error */ +#define FM_PORT_FRM_ERR_LENGTH FM_FD_ERR_LENGTH +/* DMA Data error */ +#define FM_PORT_FRM_ERR_DMA FM_FD_ERR_DMA +/* non Frame-Manager error; probably come from SEC that was chained to FM */ +#define FM_PORT_FRM_ERR_NON_FM FM_FD_RX_STATUS_ERR_NON_FM + /* IPR error */ +#define FM_PORT_FRM_ERR_IPRE (FM_FD_ERR_IPR & ~FM_FD_IPR) +/* IPR non-consistent-sp */ +#define FM_PORT_FRM_ERR_IPR_NCSP (FM_FD_ERR_IPR_NCSP & \ + ~FM_FD_IPR) + +/* Obsolete; will be removed in the future */ +#define FM_PORT_FRM_ERR_IPFE 0 + +/* Rx FIFO overflow, FCS error, code error, running disparity + * error (SGMII and TBI modes), FIFO parity error. + * PHY Sequence error, PHY error control character detected. + **/ +#define FM_PORT_FRM_ERR_PHYSICAL FM_FD_ERR_PHYSICAL +/* Frame too long OR Frame size exceeds max_length_frame */ +#define FM_PORT_FRM_ERR_SIZE FM_FD_ERR_SIZE +/* indicates a classifier "drop" operation */ +#define FM_PORT_FRM_ERR_CLS_DISCARD FM_FD_ERR_CLS_DISCARD +/* Extract Out of Frame */ +#define FM_PORT_FRM_ERR_EXTRACTION FM_FD_ERR_EXTRACTION +/* No Scheme Selected */ +#define FM_PORT_FRM_ERR_NO_SCHEME FM_FD_ERR_NO_SCHEME +/* Keysize Overflow */ +#define FM_PORT_FRM_ERR_KEYSIZE_OVERFLOW FM_FD_ERR_KEYSIZE_OVERFLOW +/* Frame color is red */ +#define FM_PORT_FRM_ERR_COLOR_RED FM_FD_ERR_COLOR_RED +/* Frame color is yellow */ +#define FM_PORT_FRM_ERR_COLOR_YELLOW FM_FD_ERR_COLOR_YELLOW +/* Parser Time out Exceed */ +#define FM_PORT_FRM_ERR_PRS_TIMEOUT FM_FD_ERR_PRS_TIMEOUT +/* Invalid Soft Parser instruction */ +#define FM_PORT_FRM_ERR_PRS_ILL_INSTRUCT FM_FD_ERR_PRS_ILL_INSTRUCT +/* Header error was identified during parsing */ +#define FM_PORT_FRM_ERR_PRS_HDR_ERR FM_FD_ERR_PRS_HDR_ERR +/* Frame parsed beyind 256 first bytes */ +#define FM_PORT_FRM_ERR_BLOCK_LIMIT_EXCEEDED FM_FD_ERR_BLOCK_LIMIT_EXCEEDED +/* FPM Frame Processing Timeout Exceeded */ +#define FM_PORT_FRM_ERR_PROCESS_TIMEOUT 0x00000001 + +/* FM Port Initialization Unit */ +struct fm_port_t; + +/* A structure for additional Rx port parameters */ +struct fm_port_rx_params_t { + uint32_t err_fqid; /* Error Queue Id. */ + uint32_t dflt_fqid; /* Default Queue Id. */ + uint16_t liodn_offset; /* Port's LIODN offset. */ + /* Which external buffer pools are used + * (up to FM_PORT_MAX_NUM_OF_EXT_POOLS), and their sizes. + */ + struct fm_ext_pools_t ext_buf_pools; +}; + +/* A structure for additional non-Rx port parameters*/ +struct fm_port_non_rx_params_t { + /* Error Queue Id. */ + uint32_t err_fqid; + /* For Tx - Default Confirmation queue, 0 means no Tx confirmation + * for processed frames. For OP port - default Rx queue. + */ + uint32_t dflt_fqid; + /* QM-channel dedicated to this port; will be used + * by the FM for dequeue. + */ + uint32_t qm_channel; +}; + +/* A union for additional parameters depending on port type*/ +union fm_port_specific_params_u { + /* Rx port parameters structure */ + struct fm_port_rx_params_t rx_params; + /* Non-Rx port parameters structure */ + struct fm_port_non_rx_params_t non_rx_params; +}; + +/* A structure representing FM initialization parameters*/ +struct fm_port_params_t { + uintptr_t base_addr; + /* Virtual Address of memory mapped FM Port registers.*/ + void *h_fm; + /* A handle to the FM object this port related to */ + enum fm_port_type port_type; + /* Port type */ + enum fm_port_speed port_speed; + /* Port speed */ + uint8_t port_id; + /* Port Id - relative to type; + * NOTE: When configuring Offline Parsing port for FMANv3 devices, + * it is highly recommended NOT to use port_id=0 due to lack of HW + * resources on port_id=0. + */ + uint16_t liodn_base; + /* Irrelevant for P4080 rev 1. LIODN base for this port, to be + * used together with LIODN offset. + */ + union fm_port_specific_params_u specific_params; + /* Additional parameters depending on port type. */ +}; + +struct fm_port; + +/* Function fm_port_config + * Description Creates a descriptor for the FM PORT module. + * The routine returns a handle (descriptor) to the FM PORT object. + * This descriptor must be passed as first parameter to all other + * FM PORT function calls. + * No actual initialization or configuration of FM hardware is + * done by this routine. + * Param[in] p_fm_port_params - Pointer to data structure of parameters + * Retval Pointer to FM Port object, or NULL for Failure. + */ +struct fm_port_t *fm_port_config(struct fm_port_params_t *p_fm_port_params); + +/* Function fm_port_init + * Description Initializes the FM PORT module by defining the + * software structure + * and configuring the hardware registers. + * Param[in] port - A pointer to a FM Port module. + * Return 0 on success; Error code otherwise. + */ +int fm_port_init(struct fm_port_t *p_fm_port); + +/* Function fm_port_free + * Description Frees all resources that were assigned to FM PORT module. + * Calling this routine invalidates the descriptor. + * Param[in] port - A pointer to a FM Port module. + * Return 0 on success; Error code otherwise. + */ +int fm_port_free(struct fm_port_t *p_fm_port); + +/* Configuration functions used to change default values. */ + +/* enum for defining QM frame dequeue*/ +enum fm_port_deq_type { + /* Dequeue from the SP channel - with priority precedence, + * and Intra-Class Scheduling respected. + */ + FM_PORT_DEQ_TYPE1, + /* Dequeue from the SP channel - with active FQ precedence, + * and Intra-Class Scheduling respected. + */ + FM_PORT_DEQ_TYPE2, + /* Dequeue from the SP channel - with active FQ precedence, + * and override Intra-Class Scheduling + */ + FM_PORT_DEQ_TYPE3 +}; + +/* enum for defining QM frame dequeue*/ +enum fm_port_deq_prefetch_option { + /* QMI preforms a dequeue action for a single frame only + * when a dedicated portID Tnum is waiting. + */ + FM_PORT_DEQ_NO_PREFETCH, + /* QMI preforms a dequeue action for 3 frames when one + * dedicated port_id tnum is waiting. + */ + FM_PORT_DEQ_PARTIAL_PREFETCH, + /* QMI preforms a dequeue action for 3 frames when + * no dedicated port_id tnums are waiting. + */ + FM_PORT_DEQ_FULL_PREFETCH +}; + +/* enum for defining port default color*/ +enum fm_port_color { + FM_PORT_COLOR_GREEN, /* Default port color is green */ + FM_PORT_COLOR_YELLOW, /* Default port color is yellow */ + FM_PORT_COLOR_RED, /* Default port color is red */ + FM_PORT_COLOR_OVERRIDE /* Ignore color */ +}; + +/* A structure for defining FM port resources*/ +struct fm_port_rsrc_t { + uint32_t num; /* Committed required resource */ + uint32_t extra; /* Extra (not committed) required resource */ +}; + +/* Function fm_port_cfg_deq_high_priority + * Description Calling this routine changes the dequeue priority in the + * internal driver data base from its default configuration + * 1G: [DEFAULT_PORT_deq_high_priority_1G] + * 10G: [DEFAULT_PORT_deq_high_priority_10G] + * May be used for Non-Rx ports only + * Param[in] port - A pointer to a FM Port module. + * Param[in] high_pri - true to select high priority, false for + * normal operation. + * Return 0 on success; Error code otherwise. + * Cautions Allowed only following fm_port_config() and before + * fm_port_init(). + */ +int fm_port_cfg_deq_high_priority(struct fm_port_t *p_fm_port, bool high_pri); + +/* Function fm_port_cfg_deq_prefetch_option + * Description Calling this routine changes the dequeue prefetch option + * parameter in the + * internal driver data base from its default configuration + * [DEFAULT_PORT_deq_prefetch_option] + * Note: Available for some chips only + * May be used for Non-Rx ports only + * Param[in] port - A pointer to a FM Port module. + * Param[in] deq_prefetch_option - New option + * Return 0 on success; Error code otherwise. + * Cautions Allowed only following fm_port_config() and before + * fm_port_init(). + */ +int fm_port_cfg_deq_prefetch_option(struct fm_port_t *p_fm_port, + enum fm_port_deq_prefetch_option + deq_prefetch_option); + +/* Function fm_port_cfg_buf_prefix_content + * Description Defines the structure, size and content of the application + * buffer. + * The prefix will + * In Tx ports, if 'pass_prs_result', the application + * should set a value to their offsets in the prefix of + * the FM will save the first 'priv_data_size', than, + * depending on 'pass_prs_result' and 'pass_time_stamp', + * copy parse result and timeStamp, and the packet itself + * (in this order), to the application buffer, and to offset. + * Calling this routine changes the buffer margins definitions + * in the internal driver data base from its default + * configuration: + * Data size: [DEFAULT_PORT_BUFFER_PREFIX_CONTENT_PRIV_DATA_SIZE] + * Pass Parser result: [DEFAULT_PORT_BUFFER_PREFIX_CONTENT_ + * PASS_PRS_RESULT]. + * Pass timestamp: [DEFAULT_PORT_BUFFER_PREFIX_CONTENT_PASS_ + * TIME_STAMP]. + * May be used for all ports + * Param[in] port - A pointer to a FM Port module. + * Param[in,out] p_fm_buffer_prefix_content - + * A structure of parameters describing the + * structure of the buffer. + * Out parameter: + * Start margin - offset of data from start of external + * buffer. + * Return 0 on success; Error code otherwise. + * Cautions Allowed only following fm_port_config() and before + * fm_port_init(). + */ +int fm_port_cfg_buf_prefix_content(struct fm_port_t *p_fm_port, + struct fm_buffer_prefix_content_t + *p_fm_buffer_prefix_content); + +#ifdef FM_HEAVY_TRAFFIC_HANG_ERRATA_FMAN_A005669 +/* Function fm_port_cfg_bcb_wa + * Description Configures BCB errata workaround. + * When BCB errata is applicable, the workaround is always + * performed by FM Controller. Thus, this functions doesn't + * actually enable errata workaround but rather allows driver + * to perform adjustments required due to errata workaround + * execution in FM controller. + * Applying BCB workaround also configures FM_PORT_FRM_ERR_PHYSICAL + * errors to be discarded. Thus FM_PORT_FRM_ERR_PHYSICAL can't be + * set by FM_PORT_SetErrorsRoute() function. + * Param[in] port - A pointer to a FM Port module. + * Return 0 on success; Error code otherwise. + * Cautions Allowed only following fm_port_config() and before + * fm_port_init(). + */ +int fm_port_cfg_bcb_wa(struct fm_port_t *p_fm_port); +#endif /* FM_HEAVY_TRAFFIC_HANG_ERRATA_FMAN_A005669 */ + +/* FM Port Runtime control unit API functions, definitions and enums. */ + +/* Function fm_port_get_buffer_time_stamp + * Description Returns the time stamp in the data buffer. + * Relevant for Rx ports for getting the buffer time stamp. + * See fm_port_cfg_buf_prefix_content for data buffer prefix + * configuration. + * Param[in] port - A pointer to a FM Port module. + * Param[in] p_data - A pointer to the data buffer. + * Return A pointer to the hash result on success, NULL otherwise. + * Cautions Allowed only following fm_port_init(). + */ +u64 *fm_port_get_buffer_time_stamp(const struct fm_port_t *p_fm_port, + char *p_data); + +/* Function fm_port_disable + * Description Gracefully disable an FM port. The port will not start new + * tasks after all + * tasks associated with the port are terminated. + * Param[in] port - A pointer to a FM Port module. + * Return 0 on success; Error code otherwise. + * Cautions Allowed only following fm_port_init(). + * This is a blocking routine, it returns after port is + * gracefully stopped, i.e. the port will not except new frames, + * but it will finish all frames or tasks which were already began + */ +int fm_port_disable(struct fm_port_t *p_fm_port); + +int fm_port_suspend(struct fm_port_t *p_fm_port); +/* Function fm_port_enable + * Description A runtime routine provided to allow disable/enable of port. + * Param[in] port - A pointer to a FM Port module. + * Return 0 on success; Error code otherwise. + * Cautions Allowed only following fm_port_init(). + */ +int fm_port_enable(struct fm_port_t *p_fm_port); + +int fm_port_resume(struct fm_port_t *p_fm_port); + +#endif /* __FM_PORT_EXT */ diff --git a/drivers/net/ethernet/freescale/fman/inc/fsl_fman_drv.h b/drivers/net/ethernet/freescale/fman/inc/fsl_fman_drv.h index cfbf462..b0b47b8 100644 --- a/drivers/net/ethernet/freescale/fman/inc/fsl_fman_drv.h +++ b/drivers/net/ethernet/freescale/fman/inc/fsl_fman_drv.h @@ -37,10 +37,44 @@ #include #include /* struct device */ +#include "fm_ext.h" /* FM device opaque structure used for type checking */ struct fm; +/* A structure .., */ +struct fm_port_t; + +/* A structure of information about each of the external + * buffer pools used by the port, + */ +struct fm_port_pool_param { + uint8_t id; /* External buffer pool id */ + uint16_t size; /* External buffer pool buffer size*/ +}; + +/* structure for additional port parameters */ +struct fm_port_params { + uint32_t errq; /* Error Queue Id. */ + uint32_t defq; /* For Tx and HC - Default Confirmation queue, + * 0 means no Tx conf for processed frames. + * For Rx and OP - default Rx queue. + */ + uint8_t num_pools; /* Number of pools use by this port */ + struct fm_port_pool_param pool_param[FM_PORT_MAX_NUM_OF_EXT_POOLS]; + /* Parameters for each pool */ + uint16_t priv_data_size; /* Area that user may save for his own + * need (E.g. save the SKB) + */ + bool parse_results; /* Put the parser-results in the Rx/Tx buffer */ + bool hash_results; /* Put the hash-results in the Rx/Tx buffer */ + bool time_stamp; /* Put the time-stamp in the Rx/Tx buffer */ + uint16_t data_align; /* value for selecting a data alignment + * (must be a power of 2); + * if write optimization is used, must be >= 16. + */ +}; + /* fm_bind * Bind to a specific FM device. * @@ -60,6 +94,73 @@ void fm_unbind(struct fm *fm); void *fm_get_handle(struct fm *fm); struct resource *fm_get_mem_region(struct fm *fm); +/* fm_port_bind + * Bind to a specific FM-port device (may be Rx or Tx port). + * fm_port_dev - the OF handle of the FM port device. + * Return A handle of the FM port device. + * Allowed only after the port was created. + */ +struct fm_port_drv_t *fm_port_bind(struct device *fm_port_dev); + +/* fm_port_unbind + * Un-bind from a specific FM-port device (may be Rx or Tx port). + * port - A handle of the FM port device. + * Allowed only after the port was created. + */ +void fm_port_unbind(struct fm_port_drv_t *p_port); + +/* fm_set_rx_port_params + * Configure parameters for a specific Rx FM-port device. + * port - A handle of the FM port device. + * params - Rx port parameters + * Allowed only after the port is binded. + */ +void fm_set_rx_port_params(struct fm_port_drv_t *p_port, + struct fm_port_params *params); + +/* fm_port_get_buff_layout_ext_params + * Get data_align from the device tree chosen node if applied. + * This function will only update these two parameters. + * When this port has no such parameters in the device tree + * values will be set to 0. + * port - A handle of the FM port device. + * params - PCD port parameters + * Allowed only after the port is binded. + */ +void fm_port_get_buff_layout_ext_params(struct fm_port_drv_t *p_port, + struct fm_port_params *params); + +/* fm_get_tx_port_channel + * Get qman-channel number for this Tx port. + * port - A handle of the FM port device. + * Return qman-channel number for this Tx port. + * Allowed only after the port is binded. + */ +int fm_get_tx_port_channel(struct fm_port_drv_t *p_port); + +/* fm_set_tx_port_params + * Configure parameters for a specific Tx FM-port device + * port - A handle of the FM port device. + * params - Tx port parameters + * Allowed only after the port is binded. + */ +void fm_set_tx_port_params(struct fm_port_drv_t *p_port, + struct fm_port_params *params); + +struct fm_port_t *fm_port_drv_handle(const struct fm_port_drv_t *p_port); + +/* fm_port_get_base_address + * + * Get base address of this port. Useful for accessing + * port-specific registers (i.e., not common ones). + * + * port - A handle of the FM port device. + * + * base_addr - The port's base addr (virtual address). + */ +void fm_port_get_base_addr(const struct fm_port_drv_t *p_port, + uint64_t *base_addr); + /* fm_mutex_lock * * Lock function required before any FMD/LLD call. diff --git a/drivers/net/ethernet/freescale/fman/port/Makefile b/drivers/net/ethernet/freescale/fman/port/Makefile index 54b1fa4..55825e3 100644 --- a/drivers/net/ethernet/freescale/fman/port/Makefile +++ b/drivers/net/ethernet/freescale/fman/port/Makefile @@ -1,3 +1,3 @@ obj-y += fsl_fman_port.o -fsl_fman_port-objs := fman_port.o +fsl_fman_port-objs := fman_port.o fm_port.o diff --git a/drivers/net/ethernet/freescale/fman/port/fm_port.c b/drivers/net/ethernet/freescale/fman/port/fm_port.c new file mode 100644 index 0000000..6ac4e55 --- /dev/null +++ b/drivers/net/ethernet/freescale/fman/port/fm_port.c @@ -0,0 +1,1435 @@ +/* + * Copyright 2008 - 2015 Freescale Semiconductor Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Freescale Semiconductor nor the + * names of its contributors may 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") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``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 Freescale Semiconductor 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. + */ + +/* File fm_port.c + * Description FM driver routines implementation. + */ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include "service.h" +#include "fm_muram_ext.h" + +#include "fman_common.h" +#include "fm_port.h" + +#include +#include + +/* static functions */ + +static int check_init_parameters(struct fm_port_t *p_fm_port) +{ + struct fm_port_drv_param_t *p_params = p_fm_port->p_fm_port_drv_param; + struct fman_port_cfg *p_dflt_config = &p_params->dflt_cfg; + uint32_t unused_mask; + + /* Rx only */ + if (p_fm_port->port_type == FM_PORT_TYPE_RX) { + /* external buffer pools */ + if (!p_params->ext_buf_pools.num_of_pools_used) { + pr_err("ext_buf_pools.num_of_pools_used=0. At least one buffer pool must be defined\n"); + return -EDOM; + } + + if (fm_sp_check_buf_pools_params(&p_params->ext_buf_pools, + p_params->p_backup_bm_pools, + &p_params->buf_pool_depletion, + p_fm_port->port_intg->max_num_of_ext_pools, + p_fm_port->port_intg->bm_max_num_of_pools) != 0) + return -EDOM; + /* Check that part of IC that needs copying is small enough + * to enter start margin + */ + if (p_params->int_context.size && + (p_params->int_context.size + + p_params->int_context.ext_buf_offset > + p_params->buf_margins.start_margins)) { + pr_err("int_context.size is larger than start margins\n"); + return -EDOM; + } + + if ((p_params->liodn_offset != LIODN_DONT_OVERRIDE) && + (p_params->liodn_offset & ~FM_LIODN_OFFSET_MASK)) { + pr_err("liodn_offset is larger than %d\n", + FM_LIODN_OFFSET_MASK + 1); + } +#ifdef FM_NO_BACKUP_POOLS + if ((p_fm_port->fm_rev_info.major_rev != 4) && + (p_fm_port->fm_rev_info.major_rev < 6)) + if (p_fm_port->p_fm_port_drv_param-> + p_backup_bm_pools) { + pr_err("BackupBmPools\n"); + return -EINVAL; + } +#endif /* FM_NO_BACKUP_POOLS */ + } + + /* Non Rx ports */ + else { + if (p_params->deq_sub_portal >= + p_fm_port->port_intg->fm_max_num_of_sub_portals) { + pr_err("deq_sub_portal has to be in the range of 0 - %d\n", + p_fm_port->port_intg->fm_max_num_of_sub_portals); + return -EDOM; + } + + /* to protect HW internal-context from overwrite */ + if ((p_params->int_context.size) && + (p_params->int_context.int_context_offset < + MIN_TX_INT_OFFSET)) { + pr_err("non-Rx int_context.int_context_offset can't be smaller than %d\n", + MIN_TX_INT_OFFSET); + return -EDOM; + } + + if ((p_fm_port->port_type == FM_PORT_TYPE_TX) || + /* in O/H DEFAULT_NOT_SUPPORTED indicates that + * it is not supported and should not be checked + */ + (p_fm_port->p_fm_port_drv_param->dflt_cfg. + tx_fifo_deq_pipeline_depth != DEFAULT_NOT_SUPPORTED)) { + /* Check that not larger than 8 */ + if ((!p_fm_port->p_fm_port_drv_param->dflt_cfg. + tx_fifo_deq_pipeline_depth) || + (p_fm_port->p_fm_port_drv_param->dflt_cfg. + tx_fifo_deq_pipeline_depth > + MAX_FIFO_PIPELINE_DEPTH)) { + pr_err("fifoDeqPipelineDepth can't be larger than %d\n", + MAX_FIFO_PIPELINE_DEPTH); + return -EDOM; + } + } + } + + /* Rx Or Offline Parsing */ + if ((p_fm_port->port_type == FM_PORT_TYPE_RX) || + (p_fm_port->port_type == FM_PORT_TYPE_OP)) { + if (!p_params->dflt_fqid) { + pr_err("dflt_fqid must be between 1 and 2^24-1\n"); + return -EDOM; + } + } + + /* All ports */ + /* common BMI registers values */ + /* Check that Queue Id is not larger than 2^24, and is not 0 */ + if ((p_params->err_fqid & ~0x00FFFFFF) || !p_params->err_fqid) { + pr_err("err_fqid must be between 1 and 2^24-1\n"); + return -EDOM; + } + if (p_params->dflt_fqid & ~0x00FFFFFF) { + pr_err("dflt_fqid must be between 1 and 2^24-1\n"); + return -EDOM; + } + + /* Rx only */ + if (p_fm_port->port_type == FM_PORT_TYPE_RX) { + if (p_dflt_config->rx_pri_elevation % BMI_FIFO_UNITS) { + pr_err("rx_fifo_pri_elevation_level has to be divisible by %d\n", + BMI_FIFO_UNITS); + return -EDOM; + } + if ((p_dflt_config->rx_pri_elevation < BMI_FIFO_UNITS) || + (p_dflt_config->rx_pri_elevation > + p_fm_port->port_intg->max_port_fifo_size)) { + pr_err("rx_fifo_pri_elevation_level not in range of 256 - %d\n", + p_fm_port->port_intg->max_port_fifo_size); + return -EDOM; + } + if (p_dflt_config->rx_fifo_thr % BMI_FIFO_UNITS) { + pr_err("rx_fifo_threshold must be div by %d\n", + BMI_FIFO_UNITS); + return -EDOM; + } + if ((p_dflt_config->rx_fifo_thr < BMI_FIFO_UNITS) || + (p_dflt_config->rx_fifo_thr > + p_fm_port->port_intg->max_port_fifo_size)) { + pr_err("rx_fifo_threshold has to be in the range of 256 - %d\n", + p_fm_port->port_intg->max_port_fifo_size); + return -EDOM; + } + + /* Check that not larger than 16 */ + if (p_dflt_config->rx_cut_end_bytes > FRAME_END_DATA_SIZE) { + pr_err("cut_bytes_from_end can't be larger than %d\n", + FRAME_END_DATA_SIZE); + return -EDOM; + } + + if (fm_sp_check_buf_margins(&p_params->buf_margins) != 0) + return -EDOM; + + /* extra FIFO size (allowed only to Rx ports) */ + if (p_params->set_size_of_fifo && + (p_fm_port->fifo_bufs.extra % BMI_FIFO_UNITS)) { + pr_err("fifo_bufs.extra has to be divisible by %d\n", + BMI_FIFO_UNITS); + return -EDOM; + } + + if (p_params->buf_pool_depletion.pools_grp_mode_enable && + !p_params->buf_pool_depletion.num_of_pools) { + pr_err("buf_pool_depletion.num_of_pools can not be 0 when pools_grp_mode_enable=true\n"); + return -EDOM; + } +#ifdef FM_CSI_CFED_LIMIT + if (p_fm_port->fm_rev_info.major_rev == 4) { + /* Check that not larger than 16 */ + if (p_dflt_config->rx_cut_end_bytes + + p_dflt_config->checksum_bytes_ignore > + FRAME_END_DATA_SIZE) { + pr_err("cheksum_last_bytes_ignore + cut_bytes_from_end can't be larger than %d\n", + FRAME_END_DATA_SIZE); + return -EDOM; + } + } +#endif /* FM_CSI_CFED_LIMIT */ + } + + /* Non Rx ports */ + /* extra FIFO size (allowed only to Rx ports) */ + else if (p_fm_port->fifo_bufs.extra) { + pr_err(" No fifo_bufs.extra for non Rx ports\n"); + return -EDOM; + } + + /* Tx only */ + if (p_fm_port->port_type == FM_PORT_TYPE_TX) { + if (p_dflt_config->tx_fifo_min_level % BMI_FIFO_UNITS) { + pr_err("tx_fifo_min_fill_level has to be divisible by %d\n", + BMI_FIFO_UNITS); + return -EDOM; + } + if (p_dflt_config->tx_fifo_min_level > + (p_fm_port->port_intg->max_port_fifo_size - 256)) { + pr_err("tx_fifo_min_fill_level has to be in the range of 0 - %d\n", + (p_fm_port->port_intg->max_port_fifo_size - + 256)); + return -EDOM; + } + if (p_dflt_config->tx_fifo_low_comf_level % BMI_FIFO_UNITS) { + pr_err("tx_fifo_low_comf_level has to be divisible by %d\n", + BMI_FIFO_UNITS); + return -EDOM; + } + if ((p_dflt_config->tx_fifo_low_comf_level < BMI_FIFO_UNITS) || + (p_dflt_config->tx_fifo_low_comf_level > + p_fm_port->port_intg->max_port_fifo_size)) { + pr_err("tx_fifo_low_comf_level has to be in the range of 256 - %d\n", + p_fm_port->port_intg->max_port_fifo_size); + return -EDOM; + } + if (p_fm_port->port_speed == FM_PORT_SPEED_1G) + if (p_fm_port->p_fm_port_drv_param->dflt_cfg. + tx_fifo_deq_pipeline_depth > 2) { + pr_err("fifoDeqPipelineDepth for 1G can't be larger than 2\n"); + return -EDOM; + } + } + + /* Non Tx Ports */ + /* If discard override was selected , no frames may be discarded. */ + else if (p_dflt_config->discard_override && p_params-> + errors_to_discard) { + pr_err("errors_to_discard is not empty, but frm_discard_override selected (all discarded frames to be enqueued to error queue).\n"); + return -EINVAL; + } + + /* Rx and Offline parsing */ + if ((p_fm_port->port_type == FM_PORT_TYPE_RX) || + (p_fm_port->port_type == FM_PORT_TYPE_OP)) { + if (p_fm_port->port_type == FM_PORT_TYPE_OP) + unused_mask = BMI_STATUS_OP_MASK_UNUSED; + else + unused_mask = BMI_STATUS_RX_MASK_UNUSED; + + /* Check that no common bits with BMI_STATUS_MASK_UNUSED */ + if (p_params->errors_to_discard & unused_mask) { + pr_err("errors_to_discard contains undefined bits\n"); + return -EINVAL; + } + } + + /* Offline Ports */ +#ifdef FM_OP_OPEN_DMA_MIN_LIMIT + if ((p_fm_port->fm_rev_info.major_rev >= 6) && + (p_fm_port->port_type == FM_PORT_TYPE_OP) && + p_params->set_num_of_open_dmas && + (p_fm_port->open_dmas.num < MIN_NUM_OF_OP_DMAS)) { + pr_err("For Offline port, open_dmas.num can't be smaller than %d\n", + MIN_NUM_OF_OP_DMAS); + return -EDOM; + } +#endif /* FM_OP_OPEN_DMA_MIN_LIMIT */ + + /* Offline Ports */ + if (p_fm_port->port_type == FM_PORT_TYPE_OP) { +#ifndef FM_FRAME_END_PARAMS_FOR_OP + if ((p_fm_port->fm_rev_info.major_rev < 6) && + (p_fm_port->p_fm_port_drv_param-> + cheksum_last_bytes_ignore != + DEFAULT_NOT_SUPPORTED)) { + /* this is an indication that user called config + * for this mode which is not supported in this + * integration + */ + pr_err("cheksum_last_bytes_ignore is available for Rx&Tx ports only\n"); + return -EDOM; + } +#endif /* !FM_FRAME_END_PARAMS_FOR_OP */ + +#ifndef FM_DEQ_PIPELINE_PARAMS_FOR_OP + if ((!((p_fm_port->fm_rev_info.major_rev == 4) || + (p_fm_port->fm_rev_info.major_rev >= 6))) && + (p_fm_port->p_fm_port_drv_param->dflt_cfg. + tx_fifo_deq_pipeline_depth != DEFAULT_NOT_SUPPORTED)) { + /* this is an indication that user called config for + * this mode which is not supported in this integration + **/ + pr_err("fifoDeqPipelineDepth is available for Tx ports only\n"); + return -EINVAL; + } +#endif /* !FM_DEQ_PIPELINE_PARAMS_FOR_OP */ + } + + /* All ports */ + + /* Check that not larger than 16 */ + if ((p_params->cheksum_last_bytes_ignore > FRAME_END_DATA_SIZE) && + ((p_params->cheksum_last_bytes_ignore != DEFAULT_NOT_SUPPORTED))) { + pr_err("cheksum_last_bytes_ignore can't be larger than %d\n", + FRAME_END_DATA_SIZE); + return -EDOM; + } + + if (fm_sp_check_int_context_params(&p_params->int_context) != 0) + return -EDOM; + + /* common BMI registers values */ + if (p_params->set_num_of_tasks && + ((!p_fm_port->tasks.num) || + (p_fm_port->tasks.num > MAX_NUM_OF_TASKS))) { + pr_err("tasks.num can't be larger than %d\n", + MAX_NUM_OF_TASKS); + return -EDOM; + } + if (p_params->set_num_of_tasks && + (p_fm_port->tasks.extra > MAX_NUM_OF_EXTRA_TASKS)) { + pr_err("tasks.extra can't be larger than %d\n", + MAX_NUM_OF_EXTRA_TASKS); + return -EDOM; + } + if (p_params->set_num_of_open_dmas && + ((!p_fm_port->open_dmas.num) || + (p_fm_port->open_dmas.num > MAX_NUM_OF_DMAS))) { + pr_err("open_dmas.num can't be larger than %d\n", + MAX_NUM_OF_DMAS); + return -EDOM; + } + if (p_params->set_num_of_open_dmas && + (p_fm_port->open_dmas.extra > MAX_NUM_OF_EXTRA_DMAS)) { + pr_err("open_dmas.extra can't be larger than %d\n", + MAX_NUM_OF_EXTRA_DMAS); + return -EDOM; + } + if (p_params->set_size_of_fifo && + (!p_fm_port->fifo_bufs.num || (p_fm_port->fifo_bufs.num > + p_fm_port->port_intg->max_port_fifo_size))) { + pr_err("fifo_bufs.num has to be in the range of 256 - %d\n", + p_fm_port->port_intg->max_port_fifo_size); + return -EDOM; + } + if (p_params->set_size_of_fifo && + (p_fm_port->fifo_bufs.num % BMI_FIFO_UNITS)) { + pr_err("fifo_bufs.num has to be divisible by %d\n", + BMI_FIFO_UNITS); + return -EDOM; + } + +#ifdef FM_QMI_NO_DEQ_OPTIONS_SUPPORT + if (p_fm_port->fm_rev_info.major_rev == 4) + if (p_fm_port->p_fm_port_drv_param->deq_prefetch_option != + DEFAULT_NOT_SUPPORTED) { + /* this is an indication that user called config + * for this mode which is not supported in this + * integration + **/ + pr_err("deq_prefetch_option\n"); + return -EINVAL; + } +#endif /* FM_QMI_NO_DEQ_OPTIONS_SUPPORT */ + + return 0; +} + +/* Checks if p_fm_port driver parameters were initialized + * returns 0 if success else returns error code + */ +static int is_init_done(struct fm_port_drv_param_t *p_fm_port_drv_parameters) +{ + if (!p_fm_port_drv_parameters) + return 0; + return -EINVAL; +} + +static int verify_size_of_fifo(struct fm_port_t *p_fm_port) +{ + uint32_t min_fifo_size_required = 0, opt_fifo_size_for_b2b = 0; + + /* TX PORTS */ + if (p_fm_port->port_type == FM_PORT_TYPE_TX) { + min_fifo_size_required = (uint32_t) + (ROUND_UP(p_fm_port->max_frame_length, + BMI_FIFO_UNITS) + (3 * BMI_FIFO_UNITS)); + + min_fifo_size_required += + p_fm_port->p_fm_port_drv_param-> + dflt_cfg.tx_fifo_deq_pipeline_depth * BMI_FIFO_UNITS; + + opt_fifo_size_for_b2b = min_fifo_size_required; + + /* Add some margin for back-to-back capability to improve + * performance, allows the hardware to pipeline new frame dma + * while the previous frame not yet transmitted. + */ + if (p_fm_port->port_speed == FM_PORT_SPEED_10G) + opt_fifo_size_for_b2b += 3 * BMI_FIFO_UNITS; + else + opt_fifo_size_for_b2b += 2 * BMI_FIFO_UNITS; + } + + /* RX PORTS */ + else if (p_fm_port->port_type == FM_PORT_TYPE_RX) { + if (p_fm_port->fm_rev_info.major_rev == 4) { + if (p_fm_port->rx_pools_params.num_of_pools == 1) + min_fifo_size_required = 8 * BMI_FIFO_UNITS; + else + min_fifo_size_required = (uint32_t) + (ROUND_UP + (p_fm_port-> + rx_pools_params.second_largest_buf_size, + BMI_FIFO_UNITS) + (7 * BMI_FIFO_UNITS)); + } else { + if (p_fm_port->fm_rev_info.major_rev >= 6) + min_fifo_size_required = (uint32_t) + (ROUND_UP(p_fm_port->max_frame_length, + BMI_FIFO_UNITS) + (5 * BMI_FIFO_UNITS)); + /* 4 according to spec + 1 for FOF>0 */ + else + min_fifo_size_required = (uint32_t) + (ROUND_UP(min(p_fm_port->max_frame_length, + p_fm_port->rx_pools_params. + largest_buf_size), + BMI_FIFO_UNITS) + (7 * BMI_FIFO_UNITS)); + } + + opt_fifo_size_for_b2b = min_fifo_size_required; + + /* Add some margin for back-to-back capability to improve + * performance,allows the hardware to pipeline new frame dma + * while the previous frame not yet transmitted. + */ + if (p_fm_port->port_speed == FM_PORT_SPEED_10G) + opt_fifo_size_for_b2b += 8 * BMI_FIFO_UNITS; + else + opt_fifo_size_for_b2b += 3 * BMI_FIFO_UNITS; + } + + /* For O/H ports, check fifo size and update if necessary */ + else if (p_fm_port->port_type == FM_PORT_TYPE_OP) { + if (p_fm_port->fm_rev_info.major_rev >= 6) { + opt_fifo_size_for_b2b = (uint32_t)(ROUND_UP( + p_fm_port->max_frame_length, + BMI_FIFO_UNITS) + + ((p_fm_port->p_fm_port_drv_param->dflt_cfg. + tx_fifo_deq_pipeline_depth + 5) * + BMI_FIFO_UNITS)); + min_fifo_size_required = opt_fifo_size_for_b2b; + /* 4 according to spec + 1 for FOF>0 */ + } else { + opt_fifo_size_for_b2b = + (uint32_t)((p_fm_port->tasks.num + 2) * BMI_FIFO_UNITS); + min_fifo_size_required = opt_fifo_size_for_b2b; + } + } + + ASSERT(min_fifo_size_required > 0); + ASSERT(opt_fifo_size_for_b2b >= min_fifo_size_required); + + /* Verify the size */ + if (p_fm_port->fifo_bufs.num < min_fifo_size_required) + pr_debug("FIFO size should be enlarged to %d bytes\n", + min_fifo_size_required); + else if (p_fm_port->fifo_bufs.num < opt_fifo_size_for_b2b) + pr_debug("For b2b processing,FIFO may be enlarged to %d bytes\n", + opt_fifo_size_for_b2b); + + return 0; +} + +static void fm_port_drv_param_free(struct fm_port_t *p_fm_port) +{ + kfree(p_fm_port->p_fm_port_drv_param); + p_fm_port->p_fm_port_drv_param = NULL; +} + +static int set_ext_buffer_pools(struct fm_port_t *p_fm_port) +{ + struct fm_ext_pools_t *p_ext_buf_pools = + &p_fm_port->p_fm_port_drv_param->ext_buf_pools; + struct fm_buf_pool_depletion_t *p_buf_pool_depletion = + &p_fm_port->p_fm_port_drv_param->buf_pool_depletion; + uint8_t ordered_array[FM_PORT_MAX_NUM_OF_EXT_POOLS]; + uint16_t sizes_array[BM_MAX_NUM_OF_POOLS]; + int i = 0, j = 0, err; + struct fman_port_bpools bpools; + + memset(&ordered_array, 0, + sizeof(uint8_t) * FM_PORT_MAX_NUM_OF_EXT_POOLS); + memset(&sizes_array, 0, sizeof(uint16_t) * BM_MAX_NUM_OF_POOLS); + memcpy(&p_fm_port->ext_buf_pools, p_ext_buf_pools, + sizeof(struct fm_ext_pools_t)); + + fm_sp_set_buf_pools_in_asc_order_of_buf_sizes(p_ext_buf_pools, + ordered_array, + sizes_array); + + /* Prepare flibs bpools structure */ + memset(&bpools, 0, sizeof(struct fman_port_bpools)); + bpools.count = p_ext_buf_pools->num_of_pools_used; + bpools.counters_enable = true; + for (i = 0; i < p_ext_buf_pools->num_of_pools_used; i++) { + bpools.bpool[i].bpid = ordered_array[i]; + bpools.bpool[i].size = sizes_array[ordered_array[i]]; + /* functionality available only for some derivatives + * (limited by config) + */ + if (p_fm_port->p_fm_port_drv_param->p_backup_bm_pools) + for (j = 0; j < p_fm_port->p_fm_port_drv_param-> + p_backup_bm_pools->num_of_backup_pools; j++) + if (ordered_array[i] == + p_fm_port->p_fm_port_drv_param-> + p_backup_bm_pools->pool_ids[j]) { + bpools.bpool[i].is_backup = true; + break; + } + } + + /* save pools parameters for later use */ + p_fm_port->rx_pools_params.num_of_pools = + p_ext_buf_pools->num_of_pools_used; + p_fm_port->rx_pools_params.largest_buf_size = + sizes_array[ordered_array[p_ext_buf_pools-> + num_of_pools_used - 1]]; + p_fm_port->rx_pools_params.second_largest_buf_size = + sizes_array[ordered_array[p_ext_buf_pools-> + num_of_pools_used - 2]]; + + /* FMBM_RMPD reg. - pool depletion */ + if (p_buf_pool_depletion->pools_grp_mode_enable) { + bpools.grp_bp_depleted_num = p_buf_pool_depletion-> +num_of_pools; + for (i = 0; i < p_fm_port->port_intg->bm_max_num_of_pools; + i++) { + if (p_buf_pool_depletion->pools_to_consider[i]) { + for (j = 0; j < p_ext_buf_pools-> + num_of_pools_used; j++) { + if (i == ordered_array[j]) { + bpools.bpool[j]. + grp_bp_depleted = true; + break; + } + } + } + } + } + + if (p_buf_pool_depletion->single_pool_mode_enable) { + for (i = 0; i < p_fm_port->port_intg->bm_max_num_of_pools; + i++) { + if (p_buf_pool_depletion-> + pools_to_consider_for_single_mode[i]) { + for (j = 0; j < p_ext_buf_pools-> + num_of_pools_used; j++) { + if (i == ordered_array[j]) { + bpools.bpool[j]. + single_bp_depleted = true; + break; + } + } + } + } + } + + /* Issue flibs function */ + err = fman_port_set_bpools(&p_fm_port->port, &bpools); + if (err != 0) { + pr_err("fman_port_set_bpools\n"); + return -EDOM; + } + + kfree(p_fm_port->p_fm_port_drv_param->p_backup_bm_pools); + + return 0; +} + +static int init_low_level_driver(struct fm_port_t *p_fm_port) +{ + struct fm_port_drv_param_t *p_drv_params = p_fm_port-> + p_fm_port_drv_param; + struct fman_port_params port_params; + uint32_t tmp_val; + + /* Set up flibs parameters and issue init function */ + + memset(&port_params, 0, sizeof(struct fman_port_params)); + port_params.discard_mask = p_drv_params->errors_to_discard; + port_params.dflt_fqid = p_drv_params->dflt_fqid; + port_params.err_fqid = p_drv_params->err_fqid; + port_params.deq_sp = p_drv_params->deq_sub_portal; + port_params.dont_release_buf = p_drv_params->dont_release_buf; + switch (p_fm_port->port_type) { + case (FM_PORT_TYPE_RX): + port_params.err_mask = + (RX_ERRS_TO_ENQ & ~port_params.discard_mask); + if (p_drv_params->forward_reuse_int_context) + p_drv_params->dflt_cfg.rx_fd_bits = + (uint8_t)(BMI_PORT_RFNE_FRWD_RPD >> 24); + break; + + case (FM_PORT_TYPE_OP): + port_params.err_mask = + (OP_ERRS_TO_ENQ & ~port_params.discard_mask); + break; + break; + + default: + break; + } + + tmp_val = (uint32_t)((p_fm_port->internal_buf_offset % + OFFSET_UNITS) ? (p_fm_port-> + internal_buf_offset / OFFSET_UNITS + + 1) : (p_fm_port->internal_buf_offset / + OFFSET_UNITS)); + p_fm_port->internal_buf_offset = (uint8_t)(tmp_val * OFFSET_UNITS); + p_drv_params->dflt_cfg.int_buf_start_margin = + p_fm_port->internal_buf_offset; + + p_drv_params->dflt_cfg.ext_buf_start_margin = + p_drv_params->buf_margins.start_margins; + p_drv_params->dflt_cfg.ext_buf_end_margin = + p_drv_params->buf_margins.end_margins; + + p_drv_params->dflt_cfg.ic_ext_offset = + p_drv_params->int_context.ext_buf_offset; + p_drv_params->dflt_cfg.ic_int_offset = + p_drv_params->int_context.int_context_offset; + p_drv_params->dflt_cfg.ic_size = p_drv_params->int_context.size; + + if (0 != + fman_port_init(&p_fm_port->port, &p_drv_params->dflt_cfg, + &port_params)) { + pr_err("fman_port_init\n"); + return -ENODEV; + } + + /* The code bellow is a trick so the FM will not release the buffer + * to BM nor will try to enqueue the frame to QM + */ + if (p_fm_port->port_type == FM_PORT_TYPE_TX) { + if (!p_drv_params->dflt_fqid && p_drv_params-> + dont_release_buf) { + /* override fmbm_tcfqid 0 with a false non-0 value. + * This will force FM to act according to tfene. + * Otherwise, if fmbm_tcfqid is 0 the FM will release + * buffers to BM regardless of fmbm_tfene + */ + WRITE_UINT32(p_fm_port->port.bmi_regs->tx.fmbm_tcfqid, + 0xFFFFFF); + WRITE_UINT32(p_fm_port->port.bmi_regs->tx.fmbm_tfene, + NIA_ENG_BMI | NIA_BMI_AC_TX_RELEASE); + } + } + + return 0; +} + +static struct fm_port_intg_t *set_port_intg_params(struct fm_port_t *p_fm_port) +{ + struct fm_port_intg_t *intg; + uint32_t bmi_max_fifo_size; + + intg = kzalloc(sizeof(*intg), GFP_KERNEL); + if (!intg) + return NULL; + + bmi_max_fifo_size = fm_get_bmi_max_fifo_size(p_fm_port->h_fm); + + intg->max_port_fifo_size = + MAX_PORT_FIFO_SIZE(bmi_max_fifo_size); + + switch (p_fm_port->fm_rev_info.major_rev) { + case FM_IP_BLOCK_P2_P3_P5: + case FM_IP_BLOCK_P4: + intg->max_num_of_ext_pools = 4; + intg->fm_max_num_of_sub_portals = 12; + intg->bm_max_num_of_pools = 64; + break; + + case FM_IP_BLOCK_P1: + intg->max_num_of_ext_pools = 4; + intg->fm_max_num_of_sub_portals = 7; + intg->bm_max_num_of_pools = 8; + break; + + case FM_IP_BLOCK_B_T: + intg->max_num_of_ext_pools = 8; + intg->fm_max_num_of_sub_portals = 16; + intg->bm_max_num_of_pools = 64; + break; + + default: + pr_err("Unsupported FMan version\n"); + kfree(intg); + return NULL; + } + + return intg; +} + +/* API Init unit functions */ + +struct fm_port_t *fm_port_config(struct fm_port_params_t *p_fm_port_params) +{ + struct fm_port_t *p_fm_port; + uintptr_t base_addr = p_fm_port_params->base_addr; +#ifdef FM_WRONG_RESET_VALUES_ERRATA_FMAN_A005127 + uint32_t tmp_reg; +#endif /* FM_WRONG_RESET_VALUES_ERRATA_FMAN_A005127 */ + enum fman_port_type fman_port_type = E_FMAN_PORT_TYPE_DUMMY; + + /* Allocate FM structure */ + p_fm_port = kzalloc(sizeof(*p_fm_port), GFP_KERNEL); + if (!p_fm_port) + return NULL; + + /* Allocate the FM driver's parameters structure */ + p_fm_port->p_fm_port_drv_param = + kzalloc(sizeof(*p_fm_port->p_fm_port_drv_param), + GFP_KERNEL); + if (!p_fm_port->p_fm_port_drv_param) { + kfree(p_fm_port); + pr_err("FM Port driver parameters\n"); + return NULL; + } + + /* Initialize FM port parameters which will be kept by the driver */ + p_fm_port->port_type = p_fm_port_params->port_type; + p_fm_port->port_speed = p_fm_port_params->port_speed; + p_fm_port->port_id = p_fm_port_params->port_id; + p_fm_port->h_fm = p_fm_port_params->h_fm; + + /* get FM revision */ + fm_get_revision(p_fm_port->h_fm, &p_fm_port->fm_rev_info); + + p_fm_port->port_intg = set_port_intg_params(p_fm_port); + if (!p_fm_port->port_intg) { + kfree(p_fm_port->p_fm_port_drv_param); + kfree(p_fm_port); + return NULL; + } + + if (p_fm_port->fm_rev_info.major_rev >= 6) { + if ((p_fm_port->port_type == FM_PORT_TYPE_OP) && + (p_fm_port_params->port_id == FM_OH_PORT_ID)) + pr_debug("Use nonzero portid for OP port\n"); + } + + /* Set up FM port parameters for initialization phase only */ + + /* First, fill in flibs struct */ + /* In order to be aligned with flib port types, we need to translate + * the port type and speed to fman_port_type + */ + if (p_fm_port->port_type == FM_PORT_TYPE_OP) { + fman_port_type = E_FMAN_PORT_TYPE_OP; + } else if (p_fm_port->port_type == FM_PORT_TYPE_TX) { + if (p_fm_port->port_speed == FM_PORT_SPEED_10G) + fman_port_type = E_FMAN_PORT_TYPE_TX_10G; + else + fman_port_type = E_FMAN_PORT_TYPE_TX; + } else if (p_fm_port->port_type == FM_PORT_TYPE_RX) { + if (p_fm_port->port_speed == FM_PORT_SPEED_10G) + fman_port_type = E_FMAN_PORT_TYPE_RX_10G; + else + fman_port_type = E_FMAN_PORT_TYPE_RX; + } + fman_port_defconfig(&p_fm_port->p_fm_port_drv_param->dflt_cfg, + fman_port_type); + /* Overwrite some integration specific parameters */ + p_fm_port->p_fm_port_drv_param->dflt_cfg.rx_pri_elevation = + DFLT_PORT_RX_FIFO_PRI_ELEVATION_LEV( + p_fm_port->port_intg->max_port_fifo_size); + p_fm_port->p_fm_port_drv_param->dflt_cfg.rx_fifo_thr = + p_fm_port->p_fm_port_drv_param->rx_fifo_threshold = + DFLT_PORT_RX_FIFO_THRESHOLD( + p_fm_port->fm_rev_info.major_rev, + p_fm_port->port_intg->max_port_fifo_size); + + p_fm_port->p_fm_port_drv_param->dflt_cfg.errata_A006675 = false; + +#if defined(FM_OP_NO_VSP_NO_RELEASE_ERRATA_FMAN_A006675) || \ +defined(FM_ERROR_VSP_NO_MATCH_SW006) + if (p_fm_port->fm_rev_info.major_rev >= 6) + p_fm_port->p_fm_port_drv_param->dflt_cfg.errata_A006675 = + true; +#endif + if ((p_fm_port->fm_rev_info.major_rev == 6) && + ((p_fm_port->fm_rev_info.minor_rev == 0) || + (p_fm_port->fm_rev_info.minor_rev == 3))) + p_fm_port->p_fm_port_drv_param->dflt_cfg.errata_A006320 = + true; + else + p_fm_port->p_fm_port_drv_param->dflt_cfg.errata_A006320 = + false; + + /* Excessive Threshold register - exists for pre-FMv3 chips only */ + if (p_fm_port->fm_rev_info.major_rev < 6) { +#ifdef FM_NO_RESTRICT_ON_ACCESS_RSRC + p_fm_port->p_fm_port_drv_param->dflt_cfg. + excessive_threshold_register = true; +#endif /* FM_NO_RESTRICT_ON_ACCESS_RSRC */ + p_fm_port->p_fm_port_drv_param->dflt_cfg.fmbm_rebm_has_sgd = + false; + p_fm_port->p_fm_port_drv_param-> + dflt_cfg.fmbm_tfne_has_features = + false; + } else { + p_fm_port->p_fm_port_drv_param->dflt_cfg. + excessive_threshold_register = false; + p_fm_port->p_fm_port_drv_param->dflt_cfg.fmbm_rebm_has_sgd = + true; + p_fm_port->p_fm_port_drv_param-> + dflt_cfg.fmbm_tfne_has_features = true; + } + if (p_fm_port->fm_rev_info.major_rev == 4) + p_fm_port->p_fm_port_drv_param-> + dflt_cfg.qmi_deq_options_support = false; + else + p_fm_port->p_fm_port_drv_param-> + dflt_cfg.qmi_deq_options_support = true; + + /* Continue with other parameters */ + p_fm_port->p_fm_port_drv_param->base_addr = base_addr; + /* set memory map pointers */ + p_fm_port->p_fm_port_qmi_regs = + (struct fm_port_qmi_regs_t __iomem *)UINT_TO_PTR(base_addr + + QMI_PORT_REGS_OFFSET); + p_fm_port->p_fm_port_bmi_regs = + (union fm_port_bmi_regs_u __iomem *)UINT_TO_PTR(base_addr + + BMI_PORT_REGS_OFFSET); + + p_fm_port->p_fm_port_drv_param-> + buffer_prefix_content.priv_data_size = + DEFAULT_PORT_BUFFER_PREFIX_CONTENT_PRIV_DATA_SIZE; + p_fm_port->p_fm_port_drv_param-> + buffer_prefix_content.pass_prs_result = + DEFAULT_PORT_BUFFER_PREFIX_CONTENT_PASS_PRS_RESULT; + p_fm_port->p_fm_port_drv_param-> + buffer_prefix_content.pass_time_stamp = + DEFAULT_PORT_BUFFER_PREFIX_CONTENT_PASS_TIME_STAMP; + p_fm_port->p_fm_port_drv_param->buffer_prefix_content.data_align = + DEFAULT_PORT_BUFFER_PREFIX_CONTEXT_DATA_ALIGN; + p_fm_port->p_fm_port_drv_param->liodn_base = + p_fm_port_params->liodn_base; + p_fm_port->p_fm_port_drv_param->cheksum_last_bytes_ignore = + DEFAULT_PORT_CHECKSUM_LAST_BYTES_IGNORE; + + p_fm_port->max_frame_length = DEFAULT_PORT_MAX_FRAME_LENGTH; + /* resource distribution. */ + + p_fm_port->fifo_bufs.num = + DFLT_PORT_NUM_OF_FIFO_BUFS(p_fm_port->fm_rev_info.major_rev, + p_fm_port->port_type, + p_fm_port->port_speed) * BMI_FIFO_UNITS; + p_fm_port->fifo_bufs.extra = + DFLT_PORT_EXTRA_NUM_OF_FIFO_BUFS * BMI_FIFO_UNITS; + + p_fm_port->open_dmas.num = + DFLT_PORT_NUM_OF_OPEN_DMAS(p_fm_port->fm_rev_info.major_rev, + p_fm_port->port_type, + p_fm_port->port_speed); + p_fm_port->open_dmas.extra = + DFLT_PORT_EXTRA_NUM_OF_OPEN_DMAS(p_fm_port->fm_rev_info.major_rev, + p_fm_port->port_type, + p_fm_port->port_speed); + p_fm_port->tasks.num = + DFLT_PORT_NUM_OF_TASKS(p_fm_port->fm_rev_info.major_rev, + p_fm_port->port_type, + p_fm_port->port_speed); + p_fm_port->tasks.extra = + DFLT_PORT_EXTRA_NUM_OF_TASKS(p_fm_port->fm_rev_info.major_rev, + p_fm_port->port_type, + p_fm_port->port_speed); + +#ifdef FM_HEAVY_TRAFFIC_SEQUENCER_HANG_ERRATA_FMAN_A006981 + if ((p_fm_port->fm_rev_info.major_rev == 6) && + (p_fm_port->fm_rev_info.minor_rev == 0) && + ((p_fm_port->port_type == FM_PORT_TYPE_OP) || + ((p_fm_port->port_type == FM_PORT_TYPE_TX) && + (p_fm_port->port_speed == FM_PORT_SPEED_1G)))) { + p_fm_port->open_dmas.num = 16; + p_fm_port->open_dmas.extra = 0; + } +#endif /* FM_HEAVY_TRAFFIC_SEQUENCER_HANG_ERRATA_FMAN_A006981 */ + + /* Port type specific initialization: */ + switch (p_fm_port->port_type) { + case (FM_PORT_TYPE_RX): + /* Initialize FM port parameters for initialization phase only*/ + p_fm_port->p_fm_port_drv_param->cut_bytes_from_end = + DEFAULT_PORT_CUT_BYTES_FROM_END; + p_fm_port->p_fm_port_drv_param->en_buf_pool_depletion = false; + p_fm_port->p_fm_port_drv_param->frm_discard_override = + DEFAULT_PORT_FRM_DISCARD_OVERRIDE; + + p_fm_port->p_fm_port_drv_param->rx_fifo_pri_elevation_level = + DFLT_PORT_RX_FIFO_PRI_ELEVATION_LEV(p_fm_port->port_intg-> + max_port_fifo_size); + p_fm_port->p_fm_port_drv_param->rx_fifo_threshold = + DFLT_PORT_RX_FIFO_THRESHOLD(p_fm_port->fm_rev_info.major_rev, + p_fm_port->port_intg-> + max_port_fifo_size); + + p_fm_port->p_fm_port_drv_param->buf_margins.end_margins = + DEFAULT_PORT_BUF_MARGINS_END_MAARGINS; + p_fm_port->p_fm_port_drv_param->errors_to_discard = + DEFAULT_PORT_ERRORS_TO_DISCARD; + p_fm_port->p_fm_port_drv_param->forward_reuse_int_context = + DEFAULT_PORT_FORWARD_INT_CONTENT_REUSE; + break; + + case (FM_PORT_TYPE_TX): + if (p_fm_port->port_speed == FM_PORT_SPEED_1G) { + p_fm_port->p_fm_port_drv_param->dont_release_buf = + false; +#ifdef FM_WRONG_RESET_VALUES_ERRATA_FMAN_A005127 + if (p_fm_port->fm_rev_info.major_rev >= 6) { + tmp_reg = 0x00001013; + WRITE_UINT32(p_fm_port->p_fm_port_bmi_regs-> + tx_port_bmi_regs.fmbm_tfp, + tmp_reg); + } +#endif /* FM_WRONG_RESET_VALUES_ERRATA_FMAN_A005127 */ + } + if (p_fm_port->port_speed == FM_PORT_SPEED_10G) { + p_fm_port->p_fm_port_drv_param->tx_fifo_min_fill_level + = DFLT_PORT_TX_FIFO_MIN_FILL_LEVEL; + p_fm_port->p_fm_port_drv_param->tx_fifo_low_comf_level + = DFLT_PORT_TX_FIFO_LOW_COMF_LEVEL; + + p_fm_port->p_fm_port_drv_param->deq_type = + DEFAULT_PORT_DEQ_TYPE; + p_fm_port->p_fm_port_drv_param->deq_prefetch_option = + DEFAULT_PORT_DEQ_PREFETCH_OPT; + } + p_fm_port->p_fm_port_drv_param->deq_high_priority = + DFLT_PORT_DEQ_HIGH_PRIORITY(p_fm_port->port_speed); + p_fm_port->p_fm_port_drv_param->deq_byte_cnt = + DFLT_PORT_DEQ_BYTE_CNT(p_fm_port->port_speed); + p_fm_port->p_fm_port_drv_param->dflt_cfg. + tx_fifo_deq_pipeline_depth = (uint8_t) + DFLT_PORT_FIFO_DEQ_PIPELINE_DEPTH( + p_fm_port->fm_rev_info.major_rev, + p_fm_port->port_type, + p_fm_port->port_speed); + break; + case (FM_PORT_TYPE_OP): + p_fm_port->p_fm_port_drv_param->errors_to_discard = + DEFAULT_PORT_ERRORS_TO_DISCARD; + break; + + default: + kfree(p_fm_port->p_fm_port_drv_param); + kfree(p_fm_port); + pr_err("Invalid port type\n"); + return NULL; + } + +#ifdef FM_QMI_NO_DEQ_OPTIONS_SUPPORT + if (p_fm_port->fm_rev_info.major_rev == 4) + p_fm_port->p_fm_port_drv_param->deq_prefetch_option = + (enum fm_port_deq_prefetch_option)DEFAULT_NOT_SUPPORTED; +#endif /* FM_QMI_NO_DEQ_OPTIONS_SUPPORT */ + + switch (p_fm_port->port_type) { + case (FM_PORT_TYPE_RX): + /* Initialize FM port parameters for initialization phase only*/ + memcpy(&p_fm_port->p_fm_port_drv_param->ext_buf_pools, + &p_fm_port_params-> + specific_params.rx_params.ext_buf_pools, + sizeof(struct fm_ext_pools_t)); + p_fm_port->p_fm_port_drv_param->err_fqid + = p_fm_port_params->specific_params.rx_params.err_fqid; + p_fm_port->p_fm_port_drv_param->dflt_fqid + = p_fm_port_params->specific_params.rx_params.dflt_fqid; + p_fm_port->p_fm_port_drv_param->liodn_offset + = p_fm_port_params->specific_params.rx_params.liodn_offset; + break; + case (FM_PORT_TYPE_OP): + case (FM_PORT_TYPE_TX): + p_fm_port->p_fm_port_drv_param->err_fqid = + p_fm_port_params->specific_params.non_rx_params.err_fqid; + p_fm_port->p_fm_port_drv_param->deq_sub_portal = + (uint8_t)(p_fm_port_params->specific_params.non_rx_params. + qm_channel & QMI_DEQ_CFG_SUBPORTAL_MASK); + p_fm_port->p_fm_port_drv_param->dflt_fqid = + p_fm_port_params->specific_params.non_rx_params.dflt_fqid; + break; + default: + kfree(p_fm_port->p_fm_port_drv_param); + kfree(p_fm_port); + pr_err("Invalid port type\n"); + return NULL; + } + + memset(p_fm_port->name, 0, (sizeof(char)) * MODULE_NAME_SIZE); + if (snprintf(p_fm_port->name, MODULE_NAME_SIZE, "FM-%d-port-%s-%d", + fm_get_id(p_fm_port->h_fm), + ((p_fm_port->port_type == FM_PORT_TYPE_OP) ? "OP" : + ((p_fm_port->port_type == FM_PORT_TYPE_TX) ? + ((p_fm_port->port_speed == FM_PORT_SPEED_10G) ? "10g-TX" : + "1g-TX") : + ((p_fm_port->port_speed == FM_PORT_SPEED_10G) ? "10g-RX" : + "1g-RX"))), + p_fm_port->port_id) == 0) { + kfree(p_fm_port->p_fm_port_drv_param); + kfree(p_fm_port); + pr_err("sprintf failed\n"); + return NULL; + } + + p_fm_port->spinlock = kmalloc(sizeof(spinlock_t), GFP_KERNEL); + if (!p_fm_port->spinlock) { + kfree(p_fm_port->p_fm_port_drv_param); + kfree(p_fm_port); + pr_err("Spin lock init failed\n"); + return NULL; + } + + spin_lock_init(p_fm_port->spinlock); + + return p_fm_port; +} + +int fm_port_init(struct fm_port_t *p_fm_port) +{ + struct fm_port_drv_param_t *p_drv_params; + int err_code; + struct fm_inter_module_port_init_params_t fm_params; + struct fm_revision_info_t rev_info; + int ret, ret_err; + enum fman_port_type fman_port_type = E_FMAN_PORT_TYPE_DUMMY; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (!ret) + return -EINVAL; + + err_code = + fm_sp_build_buffer_structure(&p_fm_port->p_fm_port_drv_param-> + int_context, + &p_fm_port->p_fm_port_drv_param-> + buffer_prefix_content, + &p_fm_port->p_fm_port_drv_param-> + buf_margins, + &p_fm_port->buffer_offsets, + &p_fm_port->internal_buf_offset); + if (err_code != 0) + return -err_code; +#ifdef FM_HEAVY_TRAFFIC_HANG_ERRATA_FMAN_A005669 + if (p_fm_port->fm_rev_info.major_rev >= 6 && + (p_fm_port->p_fm_port_drv_param->bcb_workaround) && + ((p_fm_port->port_type == FM_PORT_TYPE_RX) && + (p_fm_port->port_speed == FM_PORT_SPEED_1G))) { + p_fm_port->p_fm_port_drv_param->errors_to_discard |= + FM_PORT_FRM_ERR_PHYSICAL; + if (!p_fm_port->fifo_bufs.num) + p_fm_port->fifo_bufs.num = + DFLT_PORT_NUM_OF_FIFO_BUFS( + p_fm_port->fm_rev_info.major_rev, + p_fm_port->port_type, + p_fm_port->port_speed) * + BMI_FIFO_UNITS; + p_fm_port->fifo_bufs.num += 4 * 1024; + } +#endif /* FM_HEAVY_TRAFFIC_HANG_ERRATA_FMAN_A005669 */ + + ret_err = check_init_parameters(p_fm_port); + if (ret_err) + return ret_err; + + p_drv_params = p_fm_port->p_fm_port_drv_param; + + /* Set up flibs port structure */ + memset(&p_fm_port->port, 0, sizeof(struct fman_port)); + /* In order to be aligned with flib port types, we need to translate + * the port type and speed to fman_port_type + */ + if (p_fm_port->port_type == FM_PORT_TYPE_OP) { + fman_port_type = E_FMAN_PORT_TYPE_OP; + } else if (p_fm_port->port_type == FM_PORT_TYPE_TX) { + if (p_fm_port->port_speed == FM_PORT_SPEED_10G) + fman_port_type = E_FMAN_PORT_TYPE_TX_10G; + else + fman_port_type = E_FMAN_PORT_TYPE_TX; + } else if (p_fm_port->port_type == FM_PORT_TYPE_RX) { + if (p_fm_port->port_speed == FM_PORT_SPEED_10G) + fman_port_type = E_FMAN_PORT_TYPE_RX_10G; + else + fman_port_type = E_FMAN_PORT_TYPE_RX; + } + p_fm_port->port.type = fman_port_type; + fm_get_revision(p_fm_port->h_fm, &rev_info); + p_fm_port->port.fm_rev_maj = rev_info.major_rev; + p_fm_port->port.fm_rev_min = rev_info.minor_rev; + p_fm_port->port.bmi_regs = (union fman_port_bmi_regs __iomem *) + UINT_TO_PTR(p_drv_params->base_addr + BMI_PORT_REGS_OFFSET); + p_fm_port->port.qmi_regs = (struct fman_port_qmi_regs __iomem *) + UINT_TO_PTR(p_drv_params->base_addr + QMI_PORT_REGS_OFFSET); + p_fm_port->port.ext_pools_num = + (uint8_t)((rev_info.major_rev == 4) ? 4 : 8); + + if (p_fm_port->port_type == FM_PORT_TYPE_RX) { + /* Call the external Buffer routine which also checks fifo + * size and updates it if necessary + */ + /* define external buffer pools and pool depletion */ + err_code = set_ext_buffer_pools(p_fm_port); + if (err_code) + return -err_code; + /* check if the largest external buffer pool is large enough */ + if (p_drv_params->buf_margins.start_margins + + MIN_EXT_BUF_SIZE + + p_drv_params->buf_margins.end_margins > + p_fm_port->rx_pools_params.largest_buf_size) { + pr_err("buf_margins.start_margins (%d) + minimum buf size (64) + buf_margins.end_margins (%d) is larger than maximum external buffer size (%d)\n", + p_drv_params->buf_margins.start_margins, + p_drv_params->buf_margins.end_margins, + p_fm_port->rx_pools_params.largest_buf_size); + return -EINVAL; + } + } + if (p_fm_port->port_type == FM_PORT_TYPE_OP) { + { +#ifdef FM_NO_OP_OBSERVED_POOLS + struct fm_revision_info_t rev_info; + + fm_get_revision(p_fm_port->h_fm, &rev_info); + if ((rev_info.major_rev == 4) && + (p_drv_params->en_buf_pool_depletion)) +#endif /* FM_NO_OP_OBSERVED_POOLS */ + { + /* define external buffer pools */ + err_code = set_ext_buffer_pools(p_fm_port); + if (err_code) + return -err_code; + } + } + } + + /* Call FM module routine for communicating parameters */ + + memset(&fm_params, 0, sizeof(fm_params)); + fm_params.port_id = p_fm_port->port_id; + fm_params.port_type = (enum fm_port_type)p_fm_port->port_type; + fm_params.port_speed = (enum fm_port_speed)p_fm_port->port_speed; + fm_params.num_of_tasks = (uint8_t)p_fm_port->tasks.num; + fm_params.num_of_extra_tasks = (uint8_t)p_fm_port->tasks.extra; + fm_params.num_of_open_dmas = (uint8_t)p_fm_port->open_dmas.num; + fm_params.num_of_extra_open_dmas = (uint8_t)p_fm_port->open_dmas.extra; + + if (p_fm_port->fifo_bufs.num) { + err_code = verify_size_of_fifo(p_fm_port); + if (err_code != 0) + return -err_code; + } + fm_params.size_of_fifo = p_fm_port->fifo_bufs.num; + fm_params.extra_size_of_fifo = p_fm_port->fifo_bufs.extra; + fm_params.liodn_offset = p_drv_params->liodn_offset; + fm_params.liodn_base = p_drv_params->liodn_base; + fm_params.deq_pipeline_depth = + p_fm_port->p_fm_port_drv_param-> + dflt_cfg.tx_fifo_deq_pipeline_depth; + fm_params.max_frame_length = p_fm_port->max_frame_length; +#ifndef FM_DEQ_PIPELINE_PARAMS_FOR_OP + if (p_fm_port->port_type == FM_PORT_TYPE_OP) { + if (!((p_fm_port->fm_rev_info.major_rev == 4) || + (p_fm_port->fm_rev_info.major_rev >= 6))) + /* OP ports do not have fifoDeqPipelineDepth, + * but it is needed only + *for deq threshold calculation. + */ + fm_params.deq_pipeline_depth = 2; + } +#endif /* !FM_DEQ_PIPELINE_PARAMS_FOR_OP */ + + err_code = fm_get_set_port_params(p_fm_port->h_fm, &fm_params); + if (err_code) + return -err_code; + + err_code = init_low_level_driver(p_fm_port); + if (err_code != 0) + return -err_code; + + fm_port_drv_param_free(p_fm_port); + + return 0; +} + +int fm_port_free(struct fm_port_t *p_fm_port) +{ + struct fm_inter_module_port_free_params_t fm_params; + + if (p_fm_port->enabled) { + if (fm_port_disable(p_fm_port) != 0) { + pr_err("fm_port_disable FAILED\n"); + return -EINVAL; + } + } + + fm_port_drv_param_free(p_fm_port); + + fm_params.port_id = p_fm_port->port_id; + fm_params.port_type = (enum fm_port_type)p_fm_port->port_type; + fm_params.deq_pipeline_depth = + p_fm_port->p_fm_port_drv_param-> + dflt_cfg.tx_fifo_deq_pipeline_depth; + + fm_free_port_params(p_fm_port->h_fm, &fm_params); + + kfree(p_fm_port->spinlock); + + kfree(p_fm_port); + + return 0; +} + +/* API Advanced Init unit functions */ + +int fm_port_cfg_deq_high_priority(struct fm_port_t *p_fm_port, bool high_pri) +{ + int ret; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (!ret) + return -EINVAL; + + if (p_fm_port->port_type == FM_PORT_TYPE_RX) { + pr_err("not available for Rx ports\n"); + return -ENOMEM; + } + + p_fm_port->p_fm_port_drv_param->dflt_cfg.deq_high_pri = high_pri; + + return 0; +} + +int fm_port_cfg_deq_prefetch_option(struct fm_port_t *p_fm_port, + enum fm_port_deq_prefetch_option + deq_prefetch_option) +{ + int ret; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (!ret) + return -EINVAL; + + if (p_fm_port->port_type == FM_PORT_TYPE_RX) { + pr_err("not available for Rx ports\n"); + return -ENODEV; + } + p_fm_port->p_fm_port_drv_param->dflt_cfg.deq_prefetch_opt = + (enum fman_port_deq_prefetch)deq_prefetch_option; + + return 0; +} + +int fm_port_cfg_buf_prefix_content(struct fm_port_t *p_fm_port, + struct fm_buffer_prefix_content_t * + p_fm_buffer_prefix_content) +{ + int ret; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (!ret) + return -EINVAL; + + memcpy(&p_fm_port->p_fm_port_drv_param->buffer_prefix_content, + p_fm_buffer_prefix_content, + sizeof(struct fm_buffer_prefix_content_t)); + /* if data_align was not initialized by user, + * we return to driver's default + **/ + if (!p_fm_port->p_fm_port_drv_param-> + buffer_prefix_content.data_align) + p_fm_port->p_fm_port_drv_param-> + buffer_prefix_content.data_align = + DEFAULT_PORT_BUFFER_PREFIX_CONTEXT_DATA_ALIGN; + + return 0; +} + +#ifdef FM_HEAVY_TRAFFIC_HANG_ERRATA_FMAN_A005669 +int fm_port_cfg_bcb_wa(struct fm_port_t *p_fm_port) +{ + int ret; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (!ret) + return -EINVAL; + + p_fm_port->p_fm_port_drv_param->bcb_workaround = true; + + return 0; +} +#endif /* FM_HEAVY_TRAFFIC_HANG_ERRATA_FMAN_A005669 */ + +/* API Run-time Control unit functions */ + +u64 *fm_port_get_buffer_time_stamp(const struct fm_port_t *p_fm_port, + char *p_data) +{ + int ret; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (ret) + return NULL; + + if (p_fm_port->buffer_offsets.time_stamp_offset == ILLEGAL_BASE) + return NULL; + + return (uint64_t *)PTR_MOVE(p_data, + p_fm_port-> + buffer_offsets.time_stamp_offset); +} +EXPORT_SYMBOL(fm_port_get_buffer_time_stamp); + +int fm_port_disable(struct fm_port_t *p_fm_port) +{ + int err, ret; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (ret) + return ret; + + err = fman_port_disable(&p_fm_port->port); + if (err == -EBUSY) { + pr_debug("%s: BMI or QMI is Busy. Port forced down\n", + p_fm_port->name); + err = 0; + } + + p_fm_port->enabled = false; + + return err; +} +EXPORT_SYMBOL(fm_port_disable); + +int fm_port_suspend(struct fm_port_t *p_fm_port) +{ + int err, ret; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (ret) + return ret; + + err = fman_port_disable(&p_fm_port->port); + if (err == -EBUSY) { + pr_debug("%s: BMI or QMI is Busy. Port forced down\n", + p_fm_port->name); + err = 0; + } + + p_fm_port->enabled = false; + + return err; +} +EXPORT_SYMBOL(fm_port_suspend); + +int fm_port_enable(struct fm_port_t *p_fm_port) +{ + int err, ret; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (ret) + return ret; + + /* Used by fm_port_free routine as indication + * if to disable port. Thus set it to true prior + * to enabling itself. This way if part of enable + * process fails there will be still things + * to disable during Free. For example, if BMI + * enable succeeded but QMI failed, still BMI + * needs to be disabled by Free. + */ + p_fm_port->enabled = true; + + err = fman_port_enable(&p_fm_port->port); + + return err; +} +EXPORT_SYMBOL(fm_port_enable); + +int fm_port_resume(struct fm_port_t *p_fm_port) +{ + int err, ret; + + ret = is_init_done(p_fm_port->p_fm_port_drv_param); + if (ret) + return ret; + + /* Used by fm_port_free routine as indication + * if to disable port. Thus set it to true prior + * to enabling itself. This way if part of enable + * process fails there will be still things + * to disable during Free. For example, if BMI + * enable succeeded but QMI failed, still BMI + * needs to be disabled by Free. + */ + p_fm_port->enabled = true; + + err = fman_port_enable(&p_fm_port->port); + + return err; +} +EXPORT_SYMBOL(fm_port_resume); diff --git a/drivers/net/ethernet/freescale/fman/port/fm_port.h b/drivers/net/ethernet/freescale/fman/port/fm_port.h new file mode 100644 index 0000000..449fce6 --- /dev/null +++ b/drivers/net/ethernet/freescale/fman/port/fm_port.h @@ -0,0 +1,527 @@ +/* + * Copyright 2008 - 2015 Freescale Semiconductor Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Freescale Semiconductor nor the + * names of its contributors may 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") as published by the Free Software + * Foundation, either version 2 of that License or (at your option) any + * later version. + * + * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``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 Freescale Semiconductor 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. + */ + +/* FM Port internal structures and definitions. */ +#ifndef __FM_PORT_H +#define __FM_PORT_H + +#include "service.h" + +#include "fm_common.h" +#include "fm_sp_common.h" +#include "fsl_fman_sp.h" +#include "fm_port_ext.h" +#include "fsl_fman_port.h" + +#define LIODN_DONT_OVERRIDE (-1) + +#define MIN_EXT_BUF_SIZE 64 + +#define MAX_PORT_FIFO_SIZE(bmi_max_fifo_size) \ + min((u32)bmi_max_fifo_size, (u32)1024 * BMI_FIFO_UNITS) + +/* Memory Map defines */ +#define BMI_PORT_REGS_OFFSET 0 +#define QMI_PORT_REGS_OFFSET 0x400 + +/* defaults */ +#define DFLT_PORT_DEQ_HIGH_PRIORITY(speed) \ + ((speed == FM_PORT_SPEED_10G) ? true : false) +#define DEFAULT_PORT_DEQ_TYPE FM_PORT_DEQ_TYPE1 +#define DEFAULT_PORT_DEQ_PREFETCH_OPT \ + FM_PORT_DEQ_FULL_PREFETCH +#define DFLT_PORT_DEQ_BYTE_CNT(speed) \ + ((speed == FM_PORT_SPEED_10G) ? 0x1400 : 0x400) +#define DEFAULT_PORT_BUFFER_PREFIX_CONTENT_PRIV_DATA_SIZE \ + DEFAULT_FM_SP_BUFFER_PREFIX_CONTENT_PRIV_DATA_SIZE +#define DEFAULT_PORT_BUFFER_PREFIX_CONTENT_PASS_PRS_RESULT \ + DEFAULT_FM_SP_BUFFER_PREFIX_CONTENT_PRIV_PASS_PRS_RESULT +#define DEFAULT_PORT_BUFFER_PREFIX_CONTENT_PASS_TIME_STAMP \ + DEFAULT_FM_SP_BUFFER_PREFIX_CONTEXT_PASS_TIME_STAMP +#define DEFAULT_PORT_BUFFER_PREFIX_CONTEXT_DATA_ALIGN \ + DEFAULT_FM_SP_BUFFER_PREFIX_CONTEXT_DATA_ALIGN +#define DEFAULT_PORT_CHECKSUM_LAST_BYTES_IGNORE 0 +#define DEFAULT_PORT_CUT_BYTES_FROM_END 4 + +#define DEFAULT_PORT_FRM_DISCARD_OVERRIDE false + +#define DEFAULT_PORT_FORWARD_INT_CONTENT_REUSE false +#define DEFAULT_PORT_BUF_MARGINS_END_MAARGINS 0 +#define DEFAULT_PORT_ERRORS_TO_DISCARD \ + FM_PORT_FRM_ERR_CLS_DISCARD +#define DEFAULT_PORT_MAX_FRAME_LENGTH 9600 + +#define DEFAULT_NOT_SUPPORTED 0xff + +#define DFLT_PORT_RX_FIFO_PRI_ELEVATION_LEV(bmi_max_fifo_size) \ + MAX_PORT_FIFO_SIZE(bmi_max_fifo_size) + +#define DFLT_PORT_RX_FIFO_THRESHOLD(major, bmi_max_fifo_size) \ + (major == 6 ? \ + MAX_PORT_FIFO_SIZE(bmi_max_fifo_size) : \ + (MAX_PORT_FIFO_SIZE(bmi_max_fifo_size) * 3 / 4)) \ + +#define DFLT_PORT_TX_FIFO_MIN_FILL_LEVEL 0 +#define DFLT_PORT_TX_FIFO_LOW_COMF_LEVEL (5 * 1024) + +/* OP - 2, 10G - 4, 1G (FMAN V3 - 2, FMAN V2 - 1) */ +#define DFLT_PORT_FIFO_DEQ_PIPELINE_DEPTH(major, type, speed) \ + ((type == FM_PORT_TYPE_OP) ? 2 : \ + ((speed == FM_PORT_SPEED_10G) ? 4 : \ + ((major >= 6) ? 2 : 1))) + +#define DFLT_PORT_EXTRA_NUM_OF_FIFO_BUFS 0 + +/* FMAN V3: OP - 6, 10G (RX/TX 16), 1G (RX/TX) 4 + * FMAN V2: OP - 3, 10G (TX/TX 16), 1G (RX/TX) 3 + */ +#define DFLT_PORT_NUM_OF_TASKS(major, type, speed) \ + ((major >= 6) ? \ + ((type == FM_PORT_TYPE_OP) ? 6 : \ + ((speed == FM_PORT_SPEED_10G) ? 16 : 4)) : \ + ((speed == FM_PORT_SPEED_10G) ? 16 : 3)) + +/* FMAN V3: 0 for all ports + * FMAN V2: RX 10G - 8, RX 1G 2, TX/OP - 0 + */ +#define DFLT_PORT_EXTRA_NUM_OF_TASKS(major, type, speed) \ + ((major >= 6) ? 0 : \ + ((type == FM_PORT_TYPE_RX) ? \ + ((speed == FM_PORT_SPEED_10G) ? 8 : 2) : 0)) + +/* FMAN V3: 10G RX - 8, 1G RX - 2, 10G TX - 12, 1G TX 3, OP - 6 + * FMAN V2: 10G RX/TX - 8, 1G(TX/RX)/OP - 1 + */ +#define DFLT_PORT_NUM_OF_OPEN_DMAS(major, type, speed) \ + ((major >= 6) ? \ + ((type == FM_PORT_TYPE_RX) ? \ + ((speed == FM_PORT_SPEED_10G) ? 8 : 2) : \ + ((type == FM_PORT_TYPE_TX) ? \ + ((speed == FM_PORT_SPEED_10G) ? 12 : 3) : 4)) : \ + ((speed == FM_PORT_SPEED_10G) ? 8 : 1)) + +/* FMAN V3: 0 for all ports + * FMAN V2: RX 10G - 8, 1G RX/TX & OP - 1 + */ +#define DFLT_PORT_EXTRA_NUM_OF_OPEN_DMAS(major, type, speed) \ + ((major >= 6) ? 0 : \ + ((speed == FM_PORT_SPEED_10G) ? 8 : 1)) + +/* FMAN V3: 10G RX - 96, 10G TX 64, 1G/OP 50 + * FMAN V2: 10G - 48, 1G RX 45, 1G TX 44, OP = 8 + */ +#define DFLT_PORT_NUM_OF_FIFO_BUFS(major, type, speed) \ + (major >= 6 ? \ + (((speed == FM_PORT_SPEED_10G) ? \ + ((type == FM_PORT_TYPE_RX) ? (96) : (64)) : (50))) : \ + ((speed == FM_PORT_SPEED_10G) ? 48 : \ + ((type == FM_PORT_TYPE_OP) ? 8 : \ + ((type == FM_PORT_TYPE_RX) ? 45 : 44)))) \ + +#define FM_PORT_MAX_NUM_OF_CONGESTION_GRPS_ALL_INTEGRATIONS 256 + +#define FM_OH_PORT_ID 1 + +/* Memory Mapped Registers */ + +struct fm_port_rx_bmi_regs_t { + uint32_t fmbm_rcfg; /* Rx Configuration */ + uint32_t fmbm_rst; /* Rx Status */ + uint32_t fmbm_rda; /* Rx DMA attributes*/ + uint32_t fmbm_rfp; /* Rx FIFO Parameters*/ + uint32_t fmbm_rfed; /* Rx Frame End Data*/ + uint32_t fmbm_ricp; /* Rx Internal Context Parameters*/ + uint32_t fmbm_rim; /* Rx Internal Buffer Margins*/ + uint32_t fmbm_rebm; /* Rx External Buffer Margins*/ + uint32_t fmbm_rfne; /* Rx Frame Next Engine*/ + uint32_t fmbm_rfca; /* Rx Frame Command Attributes.*/ + uint32_t fmbm_rfpne; /* Rx Frame Parser Next Engine*/ + uint32_t fmbm_rpso; /* Rx Parse Start Offset*/ + uint32_t fmbm_rpp; /* Rx Policer Profile */ + uint32_t fmbm_rccb; /* Rx Coarse Classification Base */ + uint32_t fmbm_reth; /* Rx Excessive Threshold */ + uint32_t reserved1[0x01]; + /* (0x03C) */ + uint32_t fmbm_rprai[FM_PORT_PRS_RESULT_NUM_OF_WORDS]; + /* Rx Parse Results Array Initialization*/ + uint32_t fmbm_rfqid; /* Rx Frame Queue ID*/ + uint32_t fmbm_refqid; /* Rx Error Frame Queue ID*/ + uint32_t fmbm_rfsdm; /* Rx Frame Status Discard Mask*/ + uint32_t fmbm_rfsem; /* Rx Frame Status Error Mask*/ + uint32_t fmbm_rfene; /* Rx Frame Enqueue Next Engine */ + uint32_t reserved2[0x02]; + /* (0x074-0x078) */ + /* Rx Frame Continuous Mode Next Engine */ + uint32_t fmbm_rcmne; + uint32_t reserved3[0x20]; + /* (0x080 0x0FF) */ + uint32_t fmbm_ebmpi[FM_PORT_MAX_NUM_OF_EXT_POOLS]; + /* Buffer Manager pool Information-*/ + uint32_t fmbm_acnt[FM_PORT_MAX_NUM_OF_EXT_POOLS]; + /* Allocate Counter-*/ + uint32_t reserved4[0x08]; + /* 0x130/0x140 - 0x15F reserved -*/ + uint32_t + fmbm_rcgm[FM_PORT_MAX_NUM_OF_CONGESTION_GRPS_ALL_INTEGRATIONS / 32]; + /* Congestion Group Map*/ + uint32_t fmbm_rmpd; /* BM Pool Depletion */ + uint32_t reserved5[0x1F]; + /* (0x184 0x1FF) */ + uint32_t fmbm_rstc; /* Rx Statistics Counters*/ + uint32_t fmbm_rfrc; /* Rx Frame Counter*/ + uint32_t fmbm_rfbc; /* Rx Bad Frames Counter*/ + uint32_t fmbm_rlfc; /* Rx Large Frames Counter*/ + uint32_t fmbm_rffc; /* Rx Filter Frames Counter*/ + uint32_t fmbm_rfcd; /* Rx Frame Discard Counter*/ + uint32_t fmbm_rfldec; /* Rx Frames List DMA Error Counter*/ + uint32_t fmbm_rodc;/* Rx Out of Buffers Discard Counter-*/ + uint32_t fmbm_rbdc; /* Rx Buffers Deallocate Counter-*/ + uint32_t fmbm_rpec; /* Rx RX Prepare to enqueue Counter-*/ + uint32_t reserved6[0x16]; + /* (0x228 0x27F) */ + uint32_t fmbm_rpc; /* Rx Performance Counters*/ + uint32_t fmbm_rpcp; /* Rx Performance Count Parameters*/ + uint32_t fmbm_rccn; /* Rx Cycle Counter*/ + uint32_t fmbm_rtuc; /* Rx Tasks Utilization Counter*/ + uint32_t fmbm_rrquc;/* Rx Receive Queue Utilization Counter*/ + uint32_t fmbm_rduc; /* Rx DMA Utilization Counter*/ + uint32_t fmbm_rfuc; /* Rx FIFO Utilization Counter*/ + uint32_t fmbm_rpac; /* Rx Pause Activation Counter*/ + uint32_t reserved7[0x18]; + /* (0x2A0-0x2FF) */ + uint32_t fmbm_rdcfg[0x3]; + /* Rx Debug-*/ + uint32_t fmbm_rgpr; /* Rx General Purpose Register. */ + uint32_t reserved8[0x3a]; + /* (0x310-0x3FF) */ +} __attribute__((__packed__)); + +struct fm_port_tx_bmi_regs_t { + uint32_t fmbm_tcfg; /* Tx Configuration */ + uint32_t fmbm_tst; /* Tx Status */ + uint32_t fmbm_tda; /* Tx DMA attributes */ + uint32_t fmbm_tfp; /* Tx FIFO Parameters */ + uint32_t fmbm_tfed; /* Tx Frame End Data */ + uint32_t fmbm_ticp; /* Tx Internal Context Parameters */ + uint32_t fmbm_tfdne; /* Tx Frame Dequeue Next Engine. */ + uint32_t fmbm_tfca; /* Tx Frame Command attribute. */ + uint32_t fmbm_tcfqid; /* Tx Confirmation Frame Queue ID. */ + uint32_t fmbm_tfeqid; /* Tx Frame Error Queue ID */ + uint32_t fmbm_tfene; /* Tx Frame Enqueue Next Engine */ + uint32_t fmbm_trlmts; /* Tx Rate Limiter Scale */ + uint32_t fmbm_trlmt; /* Tx Rate Limiter */ + uint32_t fmbm_tccb; /* Tx Coarse Classification Base */ + uint32_t reserved0[0x0e]; + /* (0x038-0x070) */ + uint32_t fmbm_tfne; /* Tx Frame Next Engine */ + uint32_t fmbm_tpfcm[0x02]; + /* Tx Priority based Flow Control (PFC) Mapping */ + /* Tx Frame Continuous Mode Next Engine */ + uint32_t fmbm_tcmne; + uint32_t reserved2[0x60]; + /* (0x080-0x200) */ + uint32_t fmbm_tstc; /* Tx Statistics Counters */ + uint32_t fmbm_tfrc; /* Tx Frame Counter */ + uint32_t fmbm_tfdc; /* Tx Frames Discard Counter */ + uint32_t fmbm_tfledc; /* Tx Frame Length error discard counter */ + /* Tx Frame unsupported format discard Counter */ + uint32_t fmbm_tfufdc; + uint32_t fmbm_tbdc; /* Tx Buffers Deallocate Counter */ + uint32_t reserved3[0x1A]; + /* (0x218-0x280) */ + uint32_t fmbm_tpc; /* Tx Performance Counters*/ + uint32_t fmbm_tpcp; /* Tx Performance Count Parameters*/ + uint32_t fmbm_tccn; /* Tx Cycle Counter*/ + uint32_t fmbm_ttuc; /* Tx Tasks Utilization Counter*/ + /* Tx Transmit Confirm Queue Utilization Counter*/ + uint32_t fmbm_ttcquc; + uint32_t fmbm_tduc; /* Tx DMA Utilization Counter*/ + uint32_t fmbm_tfuc; /* Tx FIFO Utilization Counter*/ + uint32_t reserved4[16];/* (0x29C-0x2FF) */ + uint32_t fmbm_tdcfg[0x3]; + /* Tx Debug-*/ + uint32_t fmbm_tgpr; /* O/H General Purpose Register */ + uint32_t reserved5[0x3a]; + /* (0x310-0x3FF) */ +} __attribute__((__packed__)); + +struct fm_port_oh_bmi_regs_t { + uint32_t fmbm_ocfg; /* O/H Configuration */ + uint32_t fmbm_ost; /* O/H Status */ + uint32_t fmbm_oda; /* O/H DMA attributes */ + uint32_t fmbm_oicp; /* O/H Internal Context Parameters*/ + uint32_t fmbm_ofdne; /* O/H Frame Dequeue Next Engine */ + uint32_t fmbm_ofne; /* O/H Frame Next Engine */ + uint32_t fmbm_ofca; /* O/H Frame Command Attributes. */ + uint32_t fmbm_ofpne; /* O/H Frame Parser Next Engine */ + uint32_t fmbm_opso; /* O/H Parse Start Offset */ + uint32_t fmbm_opp; /* O/H Policer Profile */ + uint32_t fmbm_occb; /* O/H Coarse Classification base */ + uint32_t fmbm_oim; /* O/H Internal margins*/ + uint32_t fmbm_ofp; /* O/H Fifo Parameters*/ + uint32_t fmbm_ofed; /* O/H Frame End Data*/ + uint32_t reserved0[2]; /* (0x038 - 0x03F) */ + uint32_t fmbm_oprai[FM_PORT_PRS_RESULT_NUM_OF_WORDS]; + /* O/H Parse Results Array Initialization */ + uint32_t fmbm_ofqid; /* O/H Frame Queue ID */ + uint32_t fmbm_oefqid; /* O/H Error Frame Queue ID */ + uint32_t fmbm_ofsdm; /* O/H Frame Status Discard Mask */ + uint32_t fmbm_ofsem; /* O/H Frame Status Error Mask */ + uint32_t fmbm_ofene; /* O/H Frame Enqueue Next Engine */ + uint32_t fmbm_orlmts; /* O/H Rate Limiter Scale */ + uint32_t fmbm_orlmt; /* O/H Rate Limiter */ + uint32_t fmbm_ocmne; /* O/H Continuous Mode Next Engine*/ + uint32_t reserved1[0x20]; + /* (0x080 - 0x0FF) */ + /* Buffer Manager Observed Pool Information */ + uint32_t fmbm_oebmpi[2]; + uint32_t reserved2[0x16]; + /* (0x108 - 0x15F) */ + uint32_t fmbm_ocgm; /* Observed Congestion Group Map */ + uint32_t reserved3[0x7]; + /* (0x164 - 0x17F) */ + uint32_t fmbm_ompd; /* Observed BMan Pool Depletion */ + uint32_t reserved4[0x1F]; + /* (0x184 - 0x1FF) */ + uint32_t fmbm_ostc; /* O/H Statistics Counters */ + uint32_t fmbm_ofrc; /* O/H Frame Counter */ + uint32_t fmbm_ofdc; /* O/H Frames Discard Counter */ + /* O/H Frames Length Error Discard Counter */ + uint32_t fmbm_ofledc; + /* O/H Frames Unsupported Format Discard Counter */ + uint32_t fmbm_ofufdc; + uint32_t fmbm_offc; /* O/H Filter Frames Counter */ + uint32_t fmbm_ofwdc; /* - Rx Frames WRED Discard Counter*/ + /* O/H Frames List DMA Error Counter */ + uint32_t fmbm_ofldec; + /* O/H Buffers Deallocate Counter */ + uint32_t fmbm_obdc; + /* O/H Out of Buffers Discard Counter */ + uint32_t fmbm_oodc; + /* O/H Prepare to enqueue Counter */ + uint32_t fmbm_opec; + uint32_t reserved5[0x15]; + /* ( - 0x27F) */ + uint32_t fmbm_opc; /* O/H Performance Counters */ + uint32_t fmbm_opcp; /* O/H Performance Count Parameters*/ + uint32_t fmbm_occn; /* O/H Cycle Counter */ + uint32_t fmbm_otuc; /* O/H Tasks Utilization Counter */ + uint32_t fmbm_oduc; /* O/H DMA Utilization Counter */ + uint32_t fmbm_ofuc; /* O/H FIFO Utilization Counter */ + uint32_t reserved6[26];/* (0x298-0x2FF) */ + uint32_t fmbm_odcfg[0x3]; + /* O/H Debug (only 1 in P1023) */ + uint32_t fmbm_ogpr; /* O/H General Purpose Register. */ + uint32_t reserved7[0x3a]; + /* (0x310 0x3FF) */ +} __attribute__((__packed__)); + +union fm_port_bmi_regs_u { + struct fm_port_rx_bmi_regs_t rx_port_bmi_regs; + struct fm_port_tx_bmi_regs_t tx_port_bmi_regs; + struct fm_port_oh_bmi_regs_t oh_port_bmi_regs; +} __attribute__((__packed__)); + +struct fm_port_non_rx_qmi_regs_t { + /* 0xn024 - 0x02B */ + uint32_t reserved1[2]; + /* PortID n Dequeue NIA Register */ + uint32_t fmqm_pndn; + /* PortID n Dequeue Config Register */ + uint32_t fmqm_pndc; + /* PortID n Dequeue Total Frame Counter */ + uint32_t fmqm_pndtfc; + /* PortID n Dequeue FQID from Default Counter */ + uint32_t fmqm_pndfdc; + /* PortID n Dequeue Confirm Counter */ + uint32_t fmqm_pndcc; +} __attribute__((__packed__)); + +struct fm_port_qmi_regs_t { + /* PortID n Configuration Register */ + uint32_t fmqm_pnc; + /* PortID n Status Register */ + uint32_t fmqm_pns; + /* PortID n Task Status Register */ + uint32_t fmqm_pnts; + /* 0xn00C - 0xn01B */ + uint32_t reserved0[4]; + /* PortID n Enqueue NIA Register */ + uint32_t fmqm_pnen; + /* PortID n Enqueue Total Frame Counter */ + uint32_t fmqm_pnetfc; + /* Registers for Tx Hc&Op ports */ + struct fm_port_non_rx_qmi_regs_t non_rx_qmi_regs; +} __attribute__((__packed__)); + +/* BMI defines */ +#define BMI_PORT_RFNE_FRWD_RPD 0x40000000 + +#define BMI_STATUS_RX_MASK_UNUSED \ +(uint32_t)(~(FM_PORT_FRM_ERR_DMA | \ +FM_PORT_FRM_ERR_PHYSICAL | \ +FM_PORT_FRM_ERR_SIZE | \ +FM_PORT_FRM_ERR_CLS_DISCARD | \ +FM_PORT_FRM_ERR_EXTRACTION | \ +FM_PORT_FRM_ERR_NO_SCHEME | \ +FM_PORT_FRM_ERR_COLOR_RED | \ +FM_PORT_FRM_ERR_COLOR_YELLOW | \ +FM_PORT_FRM_ERR_PRS_TIMEOUT | \ +FM_PORT_FRM_ERR_PRS_ILL_INSTRUCT | \ +FM_PORT_FRM_ERR_BLOCK_LIMIT_EXCEEDED | \ +FM_PORT_FRM_ERR_PRS_HDR_ERR | \ +FM_PORT_FRM_ERR_IPRE | \ +FM_PORT_FRM_ERR_IPR_NCSP | \ +FM_PORT_FRM_ERR_KEYSIZE_OVERFLOW)) + +#define BMI_STATUS_OP_MASK_UNUSED \ + (uint32_t)(BMI_STATUS_RX_MASK_UNUSED & \ + ~(FM_PORT_FRM_ERR_LENGTH | \ + FM_PORT_FRM_ERR_NON_FM | \ + FM_PORT_FRM_ERR_UNSUPPORTED_FORMAT)) + +#define RX_ERRS_TO_ENQ \ +(FM_PORT_FRM_ERR_DMA | \ +FM_PORT_FRM_ERR_PHYSICAL | \ +FM_PORT_FRM_ERR_SIZE | \ +FM_PORT_FRM_ERR_EXTRACTION | \ +FM_PORT_FRM_ERR_NO_SCHEME | \ +FM_PORT_FRM_ERR_PRS_TIMEOUT | \ +FM_PORT_FRM_ERR_PRS_ILL_INSTRUCT | \ +FM_PORT_FRM_ERR_BLOCK_LIMIT_EXCEEDED | \ +FM_PORT_FRM_ERR_PRS_HDR_ERR | \ +FM_PORT_FRM_ERR_KEYSIZE_OVERFLOW | \ +FM_PORT_FRM_ERR_IPRE) + +#define OP_ERRS_TO_ENQ \ +(RX_ERRS_TO_ENQ | \ +FM_PORT_FRM_ERR_LENGTH | \ +FM_PORT_FRM_ERR_NON_FM | \ +FM_PORT_FRM_ERR_UNSUPPORTED_FORMAT) + +/* sizes */ +#define FRAME_END_DATA_SIZE 16 +#define MIN_TX_INT_OFFSET 16 +#define MAX_FIFO_PIPELINE_DEPTH 8 +#define MAX_NUM_OF_TASKS 64 +#define MAX_NUM_OF_EXTRA_TASKS 8 +#define MAX_NUM_OF_DMAS 16 +#define MAX_NUM_OF_EXTRA_DMAS 8 +#define MIN_NUM_OF_OP_DMAS 2 + +/* QMI defines */ +#define QMI_DEQ_CFG_SUBPORTAL_MASK 0x1f + +struct fm_port_drv_param_t { + struct fman_port_cfg dflt_cfg; + uint32_t dflt_fqid; + uint32_t err_fqid; + uintptr_t base_addr; + uint8_t deq_sub_portal; + bool deq_high_priority; + enum fm_port_deq_type deq_type; + enum fm_port_deq_prefetch_option deq_prefetch_option; + uint16_t deq_byte_cnt; + uint8_t cheksum_last_bytes_ignore; + uint8_t cut_bytes_from_end; + struct fm_buf_pool_depletion_t buf_pool_depletion; + bool frm_discard_override; + bool en_buf_pool_depletion; + uint16_t liodn_offset; + uint16_t liodn_base; + struct fm_ext_pools_t ext_buf_pools; + uint32_t tx_fifo_min_fill_level; + uint32_t tx_fifo_low_comf_level; + uint32_t rx_fifo_pri_elevation_level; + uint32_t rx_fifo_threshold; + struct fm_sp_buf_margins_t buf_margins; + struct fm_sp_int_context_data_copy_t int_context; + uint32_t errors_to_discard; + bool forward_reuse_int_context; + struct fm_buffer_prefix_content_t buffer_prefix_content; + struct fm_backup_bm_pools_t *p_backup_bm_pools; + bool dont_release_buf; + bool set_num_of_tasks; + bool set_num_of_open_dmas; + bool set_size_of_fifo; + +#ifdef FM_HEAVY_TRAFFIC_HANG_ERRATA_FMAN_A005669 + bool bcb_workaround; +#endif /* FM_HEAVY_TRAFFIC_HANG_ERRATA_FMAN_A005669 */ +}; + +struct fm_port_rx_pools_params_t { + uint8_t num_of_pools; + uint16_t second_largest_buf_size; + uint16_t largest_buf_size; +}; + +struct fm_port_intg_t { + uint32_t max_port_fifo_size; + uint32_t max_num_of_ext_pools; + uint32_t fm_max_num_of_sub_portals; + uint32_t bm_max_num_of_pools; +}; + +/* No PCD Engine indicated */ +#define FM_PCD_NONE 0 +struct fm_port_t { + struct fman_port port; + void *h_fm; + struct fm_revision_info_t fm_rev_info; + uint8_t port_id; + enum fm_port_type port_type; + enum fm_port_speed port_speed; + int enabled; + char name[MODULE_NAME_SIZE]; + struct fm_port_qmi_regs_t __iomem *p_fm_port_qmi_regs; + + union fm_port_bmi_regs_u __iomem *p_fm_port_bmi_regs; + /* The optional engines are devined avobe */ + struct fm_sp_buffer_offsets_t buffer_offsets; + + /* Spinlock for port use */ + spinlock_t *spinlock; + uint8_t internal_buf_offset; + struct fm_ext_pools_t ext_buf_pools; + + uint16_t max_frame_length; + struct fm_port_rsrc_t open_dmas; + struct fm_port_rsrc_t tasks; + struct fm_port_rsrc_t fifo_bufs; + struct fm_port_rx_pools_params_t rx_pools_params; + + struct fm_port_drv_param_t *p_fm_port_drv_param; + struct fm_port_intg_t *port_intg; +}; + +#endif /* __FM_PORT_H */ -- 1.7.11.7 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/