if_dtsec_im.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*-
    2  * Copyright (c) 2012 Semihalf.
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  */
   26 
   27 #include <sys/cdefs.h>
   28 __FBSDID("$FreeBSD$");
   29 
   30 #include <sys/param.h>
   31 #include <sys/systm.h>
   32 #include <sys/kernel.h>
   33 #include <sys/module.h>
   34 #include <sys/bus.h>
   35 #include <sys/rman.h>
   36 #include <sys/malloc.h>
   37 #include <sys/mbuf.h>
   38 #include <sys/socket.h>
   39 #include <sys/sysctl.h>
   40 #include <sys/sockio.h>
   41 
   42 #include <net/ethernet.h>
   43 #include <net/if.h>
   44 #include <net/if_dl.h>
   45 #include <net/if_media.h>
   46 #include <net/if_types.h>
   47 #include <net/if_arp.h>
   48 
   49 #include <dev/mii/mii.h>
   50 #include <dev/mii/miivar.h>
   51 
   52 #include "miibus_if.h"
   53 
   54 #include <contrib/ncsw/inc/integrations/dpaa_integration_ext.h>
   55 #include <contrib/ncsw/inc/Peripherals/fm_mac_ext.h>
   56 #include <contrib/ncsw/inc/Peripherals/fm_port_ext.h>
   57 #include <contrib/ncsw/inc/xx_ext.h>
   58 
   59 #include "fman.h"
   60 #include "if_dtsec.h"
   61 #include "if_dtsec_im.h"
   62 
   63 
   64 /**
   65  * @group dTSEC FMan PORT routines.
   66  * @{
   67  */
   68 static e_RxStoreResponse
   69 dtsec_im_fm_port_rx_callback(t_Handle app, uint8_t *data, uint16_t length,
   70     uint16_t status, uint8_t position, t_Handle buf_context)
   71 {
   72         struct dtsec_softc *sc;
   73         struct mbuf *m;
   74 
   75         /* TODO STATUS / Position checking */
   76         sc = app;
   77 
   78         m = m_devget(data, length, 0, sc->sc_ifnet, NULL);
   79         if (m)
   80                 (*sc->sc_ifnet->if_input)(sc->sc_ifnet, m);
   81 
   82         XX_FreeSmart(data);
   83 
   84         return (e_RX_STORE_RESPONSE_CONTINUE);
   85 }
   86 
   87 static void
   88 dtsec_im_fm_port_tx_conf_callback(t_Handle app, uint8_t *data, uint16_t status,
   89     t_Handle buf_context)
   90 {
   91 
   92         /* TODO: Check status */
   93         XX_FreeSmart(data);
   94 }
   95 
   96 static uint8_t *
   97 dtsec_im_fm_port_rx_get_buf(t_Handle buffer_pool, t_Handle *buf_context_handle)
   98 {
   99         struct dtsec_softc *sc;
  100         uint8_t *buffer;
  101 
  102         sc = buffer_pool;
  103 
  104         buffer = XX_MallocSmart(FM_PORT_BUFFER_SIZE, 0, sizeof(void *));
  105         if (!buffer)
  106                 device_printf(sc->sc_dev, "couldn't allocate RX buffer.\n");
  107 
  108         return (buffer);
  109 }
  110 
  111 static t_Error
  112 dtsec_im_fm_port_rx_put_buf(t_Handle buffer_pool, uint8_t *buffer,
  113     t_Handle buf_context)
  114 {
  115 
  116         XX_FreeSmart(buffer);
  117         return (E_OK);
  118 }
  119 
  120 int
  121 dtsec_im_fm_port_rx_init(struct dtsec_softc *sc, int unit)
  122 {
  123         t_FmPortParams params;
  124         t_BufferPoolInfo *pool_params;
  125         t_FmPortImRxTxParams *im_params;
  126         t_Error error;
  127 
  128         memset(&params, 0, sizeof(params));
  129 
  130         params.baseAddr = sc->sc_fm_base + sc->sc_port_rx_hw_id;
  131         params.h_Fm = sc->sc_fmh;
  132         params.portType = dtsec_fm_port_rx_type(sc->sc_eth_dev_type);
  133         params.portId = sc->sc_eth_id;
  134         params.independentModeEnable = TRUE;
  135         params.liodnBase = FM_PORT_LIODN_BASE;
  136         params.f_Exception = dtsec_fm_port_rx_exception_callback;
  137         params.h_App = sc;
  138 
  139         im_params = &params.specificParams.imRxTxParams;
  140         im_params->h_FmMuram = sc->sc_muramh;
  141         im_params->liodnOffset = FM_PORT_LIODN_OFFSET;
  142         im_params->dataMemId = FM_PORT_MEM_ID;
  143         im_params->dataMemAttributes = FM_PORT_MEM_ATTR;
  144         im_params->f_RxStore = dtsec_im_fm_port_rx_callback;
  145 
  146         pool_params = &params.specificParams.imRxTxParams.rxPoolParams;
  147         pool_params->h_BufferPool = sc;
  148         pool_params->f_GetBuf = dtsec_im_fm_port_rx_get_buf;
  149         pool_params->f_PutBuf = dtsec_im_fm_port_rx_put_buf;
  150         pool_params->bufferSize = FM_PORT_BUFFER_SIZE;
  151 
  152         sc->sc_rxph = FM_PORT_Config(&params);
  153         if (sc->sc_rxph == NULL) {
  154                 device_printf(sc->sc_dev, "couldn't configure FM Port RX.\n");
  155                 return (ENXIO);
  156         }
  157 
  158         error = FM_PORT_Init(sc->sc_rxph);
  159         if (error != E_OK) {
  160                 device_printf(sc->sc_dev, "couldn't initialize FM Port RX.\n");
  161                 FM_PORT_Free(sc->sc_rxph);
  162                 return (ENXIO);
  163         }
  164 
  165         if (bootverbose)
  166                 device_printf(sc->sc_dev, "RX hw port 0x%02x initialized.\n",
  167                     sc->sc_port_rx_hw_id);
  168 
  169         return (0);
  170 }
  171 
  172 int
  173 dtsec_im_fm_port_tx_init(struct dtsec_softc *sc, int unit)
  174 {
  175         t_FmPortParams params;
  176         t_FmPortImRxTxParams *im_params;
  177         t_Error error;
  178 
  179         memset(&params, 0, sizeof(params));
  180 
  181         params.baseAddr = sc->sc_fm_base + sc->sc_port_tx_hw_id;
  182         params.h_Fm = sc->sc_fmh;
  183         params.portType = dtsec_fm_port_tx_type(sc->sc_eth_dev_type);
  184         params.portId = unit;
  185         params.independentModeEnable = TRUE;
  186         params.liodnBase = FM_PORT_LIODN_BASE;
  187         params.f_Exception = dtsec_fm_port_tx_exception_callback;
  188         params.h_App = sc;
  189 
  190         im_params = &params.specificParams.imRxTxParams;
  191         im_params->h_FmMuram = sc->sc_muramh;
  192         im_params->liodnOffset = FM_PORT_LIODN_OFFSET;
  193         im_params->dataMemId = FM_PORT_MEM_ID;
  194         im_params->dataMemAttributes = FM_PORT_MEM_ATTR;
  195         im_params->f_TxConf = dtsec_im_fm_port_tx_conf_callback;
  196 
  197         sc->sc_txph = FM_PORT_Config(&params);
  198         if (sc->sc_txph == NULL) {
  199                 device_printf(sc->sc_dev, "couldn't configure FM Port TX.\n");
  200                 return (ENXIO);
  201         }
  202 
  203         error = FM_PORT_Init(sc->sc_txph);
  204         if (error != E_OK) {
  205                 device_printf(sc->sc_dev, "couldn't initialize FM Port TX.\n");
  206                 FM_PORT_Free(sc->sc_txph);
  207                 return (ENXIO);
  208         }
  209 
  210         if (bootverbose)
  211                 device_printf(sc->sc_dev, "TX hw port 0x%02x initialized.\n",
  212                     sc->sc_port_tx_hw_id);
  213 
  214         return (0);
  215 }
  216 /** @} */
  217 
  218 
  219 /**
  220  * @group dTSEC IFnet routines.
  221  * @{
  222  */
  223 void
  224 dtsec_im_if_start_locked(struct dtsec_softc *sc)
  225 {
  226         uint8_t *buffer;
  227         uint16_t length;
  228         struct mbuf *m;
  229         int error;
  230 
  231         DTSEC_LOCK_ASSERT(sc);
  232         /* TODO: IFF_DRV_OACTIVE */
  233 
  234         if ((sc->sc_mii->mii_media_status & IFM_ACTIVE) == 0)
  235                 return;
  236 
  237         if ((sc->sc_ifnet->if_drv_flags & IFF_DRV_RUNNING) != IFF_DRV_RUNNING)
  238                 return;
  239 
  240         while (!IFQ_DRV_IS_EMPTY(&sc->sc_ifnet->if_snd)) {
  241                 IFQ_DRV_DEQUEUE(&sc->sc_ifnet->if_snd, m);
  242                 if (m == NULL)
  243                         break;
  244 
  245                 length = m_length(m, NULL);
  246                 buffer = XX_MallocSmart(length, 0, sizeof(void *));
  247                 if (!buffer) {
  248                         m_freem(m);
  249                         break;
  250                 }
  251 
  252                 m_copydata(m, 0, length, buffer);
  253                 m_freem(m);
  254 
  255                 error = FM_PORT_ImTx(sc->sc_txph, buffer, length, TRUE, buffer);
  256                 if (error != E_OK) {
  257                         /* TODO: Ring full */
  258                         XX_FreeSmart(buffer);
  259                         break;
  260                 }
  261         }
  262 }
  263 /** @} */

Cache object: 723e33742d8d194d7045e58463a86698

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/dpaa/if_dtsec_im.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/dpaa/if_dtsec_im.c