Differential D25793 Diff 76948 sys/dev/axgbe/xgbe-desc.c

Changeset View

Standalone View

sys/dev/axgbe/xgbe-desc.c

/*		/*
* AMD 10Gb Ethernet driver		* AMD 10Gb Ethernet driver
*		*
		* Copyright (c) 2014-2016,2020 Advanced Micro Devices, Inc.
		*
* This file is available to you under your choice of the following two		* This file is available to you under your choice of the following two
* licenses:		* licenses:
*		*
* License 1: GPLv2		* License 1: GPLv2
*		*
* Copyright (c) 2014 Advanced Micro Devices, Inc.
*
* This file is free software; you may copy, redistribute and/or modify		* This file is free software; you may copy, redistribute and/or modify
* it under the terms of the GNU General Public License as published by		* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or (at		* the Free Software Foundation, either version 2 of the License, or (at
* your option) any later version.		* your option) any later version.
*		*
* This file is distributed in the hope that it will be useful, but		* This file is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of		* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Show All 31 Lines
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS		* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN		* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)		* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.		* THE POSSIBILITY OF SUCH DAMAGE.
*		*
*		*
* License 2: Modified BSD		* License 2: Modified BSD
*		*
* Copyright (c) 2014 Advanced Micro Devices, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without		* Redistribution and use in source and binary forms, with or without
		rgrimesUnsubmitted Not Done Inline Actions Again the all rights reserved thing, yet it is not asserted in the GPLv2 license, copy paste repeat mistakes? rgrimes: Again the all rights reserved thing, yet it is not asserted in the GPLv2 license, copy paste…
		rajesh1.kumar_amd.comAuthorUnsubmitted Done Inline Actions Just moved the copyright above and retained "All rights reserved" text. Once I get the clarity about the text, will make appropriate changes. rajesh1.kumar_amd.com: Just moved the copyright above and retained "All rights reserved" text. Once I get the clarity…
* modification, are permitted provided that the following conditions are met:		* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright		* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.		* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright		* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the		* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.		* documentation and/or other materials provided with the distribution.
* * Neither the name of Advanced Micro Devices, Inc. nor the		* * Neither the name of Advanced Micro Devices, Inc. nor the
* names of its contributors may be used to endorse or promote products		* names of its contributors may be used to endorse or promote products
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
*/		*/

#include <sys/cdefs.h>		#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");		__FBSDID("$FreeBSD$");

#include "xgbe.h"		#include "xgbe.h"
#include "xgbe-common.h"		#include "xgbe-common.h"

static void xgbe_unmap_rdata(struct xgbe_prv_data , struct xgbe_ring_data );		static void
		xgbe_wrapper_tx_descriptor_init(struct xgbe_prv_data *pdata)
static void xgbe_free_ring(struct xgbe_prv_data *pdata,
struct xgbe_ring *ring)
{		{
struct xgbe_ring_data *rdata;
unsigned int i;

if (!ring)
return;

bus_dmamap_destroy(ring->mbuf_dmat, ring->mbuf_map);
bus_dma_tag_destroy(ring->mbuf_dmat);

ring->mbuf_map = NULL;
ring->mbuf_dmat = NULL;

if (ring->rdata) {
for (i = 0; i < ring->rdesc_count; i++) {
rdata = XGBE_GET_DESC_DATA(ring, i);
xgbe_unmap_rdata(pdata, rdata);
}

free(ring->rdata, M_AXGBE);
ring->rdata = NULL;
}

bus_dmamap_unload(ring->rdesc_dmat, ring->rdesc_map);
bus_dmamem_free(ring->rdesc_dmat, ring->rdesc, ring->rdesc_map);
bus_dma_tag_destroy(ring->rdesc_dmat);

ring->rdesc_map = NULL;
ring->rdesc_dmat = NULL;
ring->rdesc = NULL;
}

static void xgbe_free_ring_resources(struct xgbe_prv_data *pdata)
{
struct xgbe_channel *channel;
unsigned int i;

DBGPR("-->xgbe_free_ring_resources\n");

channel = pdata->channel;
for (i = 0; i < pdata->channel_count; i++, channel++) {
xgbe_free_ring(pdata, channel->tx_ring);
xgbe_free_ring(pdata, channel->rx_ring);
}

DBGPR("<--xgbe_free_ring_resources\n");
}

static void xgbe_ring_dmamap_cb(void arg, bus_dma_segment_t segs, int nseg,
int error)
{
if (error)
return;
(bus_addr_t ) arg = segs->ds_addr;
}

static int xgbe_init_ring(struct xgbe_prv_data *pdata,
struct xgbe_ring *ring, unsigned int rdesc_count)
{
bus_size_t len;
int err, flags;

DBGPR("-->xgbe_init_ring\n");

if (!ring)
return 0;

flags = 0;
if (pdata->coherent)
flags = BUS_DMA_COHERENT;

/* Descriptors */
ring->rdesc_count = rdesc_count;
len = sizeof(struct xgbe_ring_desc) * rdesc_count;
err = bus_dma_tag_create(pdata->dmat, 512, 0, BUS_SPACE_MAXADDR,
BUS_SPACE_MAXADDR, NULL, NULL, len, 1, len, flags, NULL, NULL,
&ring->rdesc_dmat);
if (err != 0) {
printf("Unable to create the DMA tag: %d\n", err);
return -err;
}

err = bus_dmamem_alloc(ring->rdesc_dmat, (void **)&ring->rdesc,
BUS_DMA_WAITOK \| BUS_DMA_COHERENT, &ring->rdesc_map);
if (err != 0) {
bus_dma_tag_destroy(ring->rdesc_dmat);
printf("Unable to allocate DMA memory: %d\n", err);
return -err;
}
err = bus_dmamap_load(ring->rdesc_dmat, ring->rdesc_map, ring->rdesc,
len, xgbe_ring_dmamap_cb, &ring->rdesc_paddr, 0);
if (err != 0) {
bus_dmamem_free(ring->rdesc_dmat, ring->rdesc, ring->rdesc_map);
bus_dma_tag_destroy(ring->rdesc_dmat);
printf("Unable to load DMA memory\n");
return -err;
}

/* Descriptor information */
ring->rdata = malloc(rdesc_count * sizeof(struct xgbe_ring_data),
M_AXGBE, M_WAITOK \| M_ZERO);

/* Create the space DMA tag for mbufs */
err = bus_dma_tag_create(pdata->dmat, 1, 0, BUS_SPACE_MAXADDR,
BUS_SPACE_MAXADDR, NULL, NULL, XGBE_TX_MAX_BUF_SIZE * rdesc_count,
rdesc_count, XGBE_TX_MAX_BUF_SIZE, flags, NULL, NULL,
&ring->mbuf_dmat);
if (err != 0)
return -err;

err = bus_dmamap_create(ring->mbuf_dmat, 0, &ring->mbuf_map);
if (err != 0)
return -err;

DBGPR("<--xgbe_init_ring\n");

return 0;
}

static int xgbe_alloc_ring_resources(struct xgbe_prv_data *pdata)
{
struct xgbe_channel *channel;
unsigned int i;
int ret;

DBGPR("-->xgbe_alloc_ring_resources\n");

channel = pdata->channel;
for (i = 0; i < pdata->channel_count; i++, channel++) {
ret = xgbe_init_ring(pdata, channel->tx_ring,
pdata->tx_desc_count);
if (ret) {
printf("error initializing Tx ring\n");
goto err_ring;
}

ret = xgbe_init_ring(pdata, channel->rx_ring,
pdata->rx_desc_count);
if (ret) {
printf("error initializing Rx ring\n");
goto err_ring;
}
}

DBGPR("<--xgbe_alloc_ring_resources\n");

return 0;

err_ring:
xgbe_free_ring_resources(pdata);

return ret;
}

static int xgbe_map_rx_buffer(struct xgbe_prv_data *pdata,
struct xgbe_ring *ring,
struct xgbe_ring_data *rdata)
{
bus_dmamap_t mbuf_map;
bus_dma_segment_t segs[2];
struct mbuf m0, m1;
int err, nsegs;

m0 = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MCLBYTES);
if (m0 == NULL)
return (-ENOBUFS);

m1 = m_getjcl(M_NOWAIT, MT_DATA, 0, MCLBYTES);
if (m1 == NULL) {
m_freem(m0);
return (-ENOBUFS);
}

m0->m_next = m1;
m0->m_flags \|= M_PKTHDR;
m0->m_len = MHLEN;
m0->m_pkthdr.len = MHLEN + MCLBYTES;

m1->m_len = MCLBYTES;
m1->m_next = NULL;
m1->m_pkthdr.len = MCLBYTES;

err = bus_dmamap_create(ring->mbuf_dmat, 0, &mbuf_map);
if (err != 0) {
m_freem(m0);
return (-err);
}

err = bus_dmamap_load_mbuf_sg(ring->mbuf_dmat, mbuf_map, m0, segs,
&nsegs, BUS_DMA_NOWAIT);
if (err != 0) {
m_freem(m0);
bus_dmamap_destroy(ring->mbuf_dmat, mbuf_map);
return (-err);
}

KASSERT(nsegs == 2,
("xgbe_map_rx_buffer: Unable to handle multiple segments %d",
nsegs));

rdata->mb = m0;
rdata->mbuf_free = 0;
rdata->mbuf_dmat = ring->mbuf_dmat;
rdata->mbuf_map = mbuf_map;
rdata->mbuf_hdr_paddr = segs[0].ds_addr;
rdata->mbuf_data_paddr = segs[1].ds_addr;

return 0;
}

static void xgbe_wrapper_tx_descriptor_init(struct xgbe_prv_data *pdata)
{
struct xgbe_hw_if *hw_if = &pdata->hw_if;		struct xgbe_hw_if *hw_if = &pdata->hw_if;
struct xgbe_channel *channel;		struct xgbe_channel *channel;
struct xgbe_ring *ring;		struct xgbe_ring *ring;
struct xgbe_ring_data *rdata;		struct xgbe_ring_data *rdata;
struct xgbe_ring_desc *rdesc;		struct xgbe_ring_desc *rdesc;
bus_addr_t rdesc_paddr;		bus_addr_t rdesc_paddr;
unsigned int i, j;		unsigned int i, j;

DBGPR("-->xgbe_wrapper_tx_descriptor_init\n");		DBGPR("-->xgbe_wrapper_tx_descriptor_init\n");

channel = pdata->channel;		for (i = 0; i < pdata->channel_count; i++) {
for (i = 0; i < pdata->channel_count; i++, channel++) {
		channel = pdata->channel[i];

ring = channel->tx_ring;		ring = channel->tx_ring;
if (!ring)		if (!ring)
break;		break;

rdesc = ring->rdesc;		rdesc = ring->rdesc;
rdesc_paddr = ring->rdesc_paddr;		rdesc_paddr = ring->rdesc_paddr;

for (j = 0; j < ring->rdesc_count; j++) {		for (j = 0; j < ring->rdesc_count; j++) {
Show All 11 Lines	for (i = 0; i < pdata->channel_count; i++) {
memset(&ring->tx, 0, sizeof(ring->tx));		memset(&ring->tx, 0, sizeof(ring->tx));

hw_if->tx_desc_init(channel);		hw_if->tx_desc_init(channel);
}		}

DBGPR("<--xgbe_wrapper_tx_descriptor_init\n");		DBGPR("<--xgbe_wrapper_tx_descriptor_init\n");
}		}

static void xgbe_wrapper_rx_descriptor_init(struct xgbe_prv_data *pdata)		static void
		xgbe_wrapper_rx_descriptor_init(struct xgbe_prv_data *pdata)
{		{
struct xgbe_hw_if *hw_if = &pdata->hw_if;		struct xgbe_hw_if *hw_if = &pdata->hw_if;
struct xgbe_channel *channel;		struct xgbe_channel *channel;
struct xgbe_ring *ring;		struct xgbe_ring *ring;
struct xgbe_ring_desc *rdesc;		struct xgbe_ring_desc *rdesc;
struct xgbe_ring_data *rdata;		struct xgbe_ring_data *rdata;
bus_addr_t rdesc_paddr;		bus_addr_t rdesc_paddr;
unsigned int i, j;		unsigned int i, j;

DBGPR("-->xgbe_wrapper_rx_descriptor_init\n");		DBGPR("-->xgbe_wrapper_rx_descriptor_init\n");

channel = pdata->channel;		for (i = 0; i < pdata->channel_count; i++) {
for (i = 0; i < pdata->channel_count; i++, channel++) {
		channel = pdata->channel[i];

ring = channel->rx_ring;		ring = channel->rx_ring;
if (!ring)		if (!ring)
break;		break;

rdesc = ring->rdesc;		rdesc = ring->rdesc;
rdesc_paddr = ring->rdesc_paddr;		rdesc_paddr = ring->rdesc_paddr;

for (j = 0; j < ring->rdesc_count; j++) {		for (j = 0; j < ring->rdesc_count; j++) {
rdata = XGBE_GET_DESC_DATA(ring, j);		rdata = XGBE_GET_DESC_DATA(ring, j);

rdata->rdesc = rdesc;		rdata->rdesc = rdesc;
rdata->rdata_paddr = rdesc_paddr;		rdata->rdata_paddr = rdesc_paddr;

if (xgbe_map_rx_buffer(pdata, ring, rdata))
break;

rdesc++;		rdesc++;
rdesc_paddr += sizeof(struct xgbe_ring_desc);		rdesc_paddr += sizeof(struct xgbe_ring_desc);
}		}

ring->cur = 0;		ring->cur = 0;
ring->dirty = 0;		ring->dirty = 0;

hw_if->rx_desc_init(channel);		hw_if->rx_desc_init(channel);
}		}
}		}

static void xgbe_unmap_rdata(struct xgbe_prv_data *pdata,		void
struct xgbe_ring_data *rdata)		xgbe_init_function_ptrs_desc(struct xgbe_desc_if *desc_if)
{		{

if (rdata->mbuf_map != NULL)
bus_dmamap_destroy(rdata->mbuf_dmat, rdata->mbuf_map);

if (rdata->mbuf_free)
m_freem(rdata->mb);

rdata->mb = NULL;
rdata->mbuf_free = 0;
rdata->mbuf_hdr_paddr = 0;
rdata->mbuf_data_paddr = 0;
rdata->mbuf_len = 0;

memset(&rdata->tx, 0, sizeof(rdata->tx));
memset(&rdata->rx, 0, sizeof(rdata->rx));
}

struct xgbe_map_tx_skb_data {
struct xgbe_ring *ring;
struct xgbe_packet_data *packet;
unsigned int cur_index;
};

static void xgbe_map_tx_skb_cb(void callback_arg, bus_dma_segment_t segs,
int nseg, bus_size_t mapsize, int error)
{
struct xgbe_map_tx_skb_data *data;
struct xgbe_ring_data *rdata;
struct xgbe_ring *ring;
int i;

if (error != 0)
return;

data = callback_arg;
ring = data->ring;

for (i = 0; i < nseg; i++) {
rdata = XGBE_GET_DESC_DATA(ring, data->cur_index);

KASSERT(segs[i].ds_len <= XGBE_TX_MAX_BUF_SIZE,
("%s: Segment size is too large %ld > %d", __func__,
segs[i].ds_len, XGBE_TX_MAX_BUF_SIZE));

if (i == 0) {
rdata->mbuf_dmat = ring->mbuf_dmat;
bus_dmamap_create(ring->mbuf_dmat, 0, &ring->mbuf_map);
}

rdata->mbuf_hdr_paddr = 0;
rdata->mbuf_data_paddr = segs[i].ds_addr;
rdata->mbuf_len = segs[i].ds_len;

data->packet->length += rdata->mbuf_len;

data->cur_index++;
}
}

static int xgbe_map_tx_skb(struct xgbe_channel channel, struct mbuf m)
{
struct xgbe_ring *ring = channel->tx_ring;
struct xgbe_map_tx_skb_data cbdata;
struct xgbe_ring_data *rdata;
struct xgbe_packet_data *packet;
unsigned int start_index, cur_index;
int err;

DBGPR("-->xgbe_map_tx_skb: cur = %d\n", ring->cur);

start_index = ring->cur;
cur_index = ring->cur;

packet = &ring->packet_data;
packet->rdesc_count = 0;
packet->length = 0;

cbdata.ring = ring;
cbdata.packet = packet;
cbdata.cur_index = cur_index;

err = bus_dmamap_load_mbuf(ring->mbuf_dmat, ring->mbuf_map, m,
xgbe_map_tx_skb_cb, &cbdata, BUS_DMA_NOWAIT);
if (err != 0) /* TODO: Undo the mapping */
return (-err);

cur_index = cbdata.cur_index;

/* Save the mbuf address in the last entry. We always have some data
* that has been mapped so rdata is always advanced past the last
* piece of mapped data - use the entry pointed to by cur_index - 1.
*/
rdata = XGBE_GET_DESC_DATA(ring, cur_index - 1);
rdata->mb = m;
rdata->mbuf_free = 1;

/* Save the number of descriptor entries used */
packet->rdesc_count = cur_index - start_index;

DBGPR("<--xgbe_map_tx_skb: count=%u\n", packet->rdesc_count);

return packet->rdesc_count;
}

void xgbe_init_function_ptrs_desc(struct xgbe_desc_if *desc_if)
{
DBGPR("-->xgbe_init_function_ptrs_desc\n");

desc_if->alloc_ring_resources = xgbe_alloc_ring_resources;
desc_if->free_ring_resources = xgbe_free_ring_resources;
desc_if->map_tx_skb = xgbe_map_tx_skb;
desc_if->map_rx_buffer = xgbe_map_rx_buffer;
desc_if->unmap_rdata = xgbe_unmap_rdata;
desc_if->wrapper_tx_desc_init = xgbe_wrapper_tx_descriptor_init;		desc_if->wrapper_tx_desc_init = xgbe_wrapper_tx_descriptor_init;
desc_if->wrapper_rx_desc_init = xgbe_wrapper_rx_descriptor_init;		desc_if->wrapper_rx_desc_init = xgbe_wrapper_rx_descriptor_init;

DBGPR("<--xgbe_init_function_ptrs_desc\n");
}		}