2 * AMD 10Gb Ethernet driver
4 * This file is available to you under your choice of the following two
9 * Copyright (c) 2014 Advanced Micro Devices, Inc.
11 * This file is free software; you may copy, redistribute and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation, either version 2 of the License, or (at
14 * your option) any later version.
16 * This file is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program. If not, see <http://www.gnu.org/licenses/>.
24 * This file incorporates work covered by the following copyright and
26 * The Synopsys DWC ETHER XGMAC Software Driver and documentation
27 * (hereinafter "Software") is an unsupported proprietary work of Synopsys,
28 * Inc. unless otherwise expressly agreed to in writing between Synopsys
31 * The Software IS NOT an item of Licensed Software or Licensed Product
32 * under any End User Software License Agreement or Agreement for Licensed
33 * Product with Synopsys or any supplement thereto. Permission is hereby
34 * granted, free of charge, to any person obtaining a copy of this software
35 * annotated with this license and the Software, to deal in the Software
36 * without restriction, including without limitation the rights to use,
37 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies
38 * of the Software, and to permit persons to whom the Software is furnished
39 * to do so, subject to the following conditions:
41 * The above copyright notice and this permission notice shall be included
42 * in all copies or substantial portions of the Software.
44 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS"
45 * BASIS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
46 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
47 * PARTICULAR PURPOSE ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS
48 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
49 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
50 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
51 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
52 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
53 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
54 * THE POSSIBILITY OF SUCH DAMAGE.
57 * License 2: Modified BSD
59 * Copyright (c) 2014 Advanced Micro Devices, Inc.
60 * All rights reserved.
62 * Redistribution and use in source and binary forms, with or without
63 * modification, are permitted provided that the following conditions are met:
64 * * Redistributions of source code must retain the above copyright
65 * notice, this list of conditions and the following disclaimer.
66 * * Redistributions in binary form must reproduce the above copyright
67 * notice, this list of conditions and the following disclaimer in the
68 * documentation and/or other materials provided with the distribution.
69 * * Neither the name of Advanced Micro Devices, Inc. nor the
70 * names of its contributors may be used to endorse or promote products
71 * derived from this software without specific prior written permission.
73 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
74 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
75 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
76 * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
77 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
78 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
79 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
80 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
81 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
82 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
84 * This file incorporates work covered by the following copyright and
86 * The Synopsys DWC ETHER XGMAC Software Driver and documentation
87 * (hereinafter "Software") is an unsupported proprietary work of Synopsys,
88 * Inc. unless otherwise expressly agreed to in writing between Synopsys
91 * The Software IS NOT an item of Licensed Software or Licensed Product
92 * under any End User Software License Agreement or Agreement for Licensed
93 * Product with Synopsys or any supplement thereto. Permission is hereby
94 * granted, free of charge, to any person obtaining a copy of this software
95 * annotated with this license and the Software, to deal in the Software
96 * without restriction, including without limitation the rights to use,
97 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies
98 * of the Software, and to permit persons to whom the Software is furnished
99 * to do so, subject to the following conditions:
101 * The above copyright notice and this permission notice shall be included
102 * in all copies or substantial portions of the Software.
104 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS"
105 * BASIS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
106 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
107 * PARTICULAR PURPOSE ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS
108 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
109 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
110 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
111 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
112 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
113 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
114 * THE POSSIBILITY OF SUCH DAMAGE.
118 #include "xgbe-common.h"
120 static void xgbe_unmap_rdata(struct xgbe_prv_data *, struct xgbe_ring_data *);
122 static void xgbe_free_ring(struct xgbe_prv_data *pdata,
123 struct xgbe_ring *ring)
125 struct xgbe_ring_data *rdata;
132 for (i = 0; i < ring->rdesc_count; i++) {
133 rdata = XGBE_GET_DESC_DATA(ring, i);
134 xgbe_unmap_rdata(pdata, rdata);
141 if (ring->rx_hdr_pa.pages) {
142 dma_unmap_page(pdata->dev, ring->rx_hdr_pa.pages_dma,
143 ring->rx_hdr_pa.pages_len, DMA_FROM_DEVICE);
144 put_page(ring->rx_hdr_pa.pages);
146 ring->rx_hdr_pa.pages = NULL;
147 ring->rx_hdr_pa.pages_len = 0;
148 ring->rx_hdr_pa.pages_offset = 0;
149 ring->rx_hdr_pa.pages_dma = 0;
152 if (ring->rx_buf_pa.pages) {
153 dma_unmap_page(pdata->dev, ring->rx_buf_pa.pages_dma,
154 ring->rx_buf_pa.pages_len, DMA_FROM_DEVICE);
155 put_page(ring->rx_buf_pa.pages);
157 ring->rx_buf_pa.pages = NULL;
158 ring->rx_buf_pa.pages_len = 0;
159 ring->rx_buf_pa.pages_offset = 0;
160 ring->rx_buf_pa.pages_dma = 0;
164 dma_free_coherent(pdata->dev,
165 (sizeof(struct xgbe_ring_desc) *
167 ring->rdesc, ring->rdesc_dma);
172 static void xgbe_free_ring_resources(struct xgbe_prv_data *pdata)
174 struct xgbe_channel *channel;
177 DBGPR("-->xgbe_free_ring_resources\n");
179 channel = pdata->channel;
180 for (i = 0; i < pdata->channel_count; i++, channel++) {
181 xgbe_free_ring(pdata, channel->tx_ring);
182 xgbe_free_ring(pdata, channel->rx_ring);
185 DBGPR("<--xgbe_free_ring_resources\n");
188 static int xgbe_init_ring(struct xgbe_prv_data *pdata,
189 struct xgbe_ring *ring, unsigned int rdesc_count)
191 DBGPR("-->xgbe_init_ring\n");
197 ring->rdesc_count = rdesc_count;
198 ring->rdesc = dma_alloc_coherent(pdata->dev,
199 (sizeof(struct xgbe_ring_desc) *
200 rdesc_count), &ring->rdesc_dma,
205 /* Descriptor information */
206 ring->rdata = kcalloc(rdesc_count, sizeof(struct xgbe_ring_data),
211 DBGPR(" rdesc=0x%p, rdesc_dma=0x%llx, rdata=0x%p\n",
212 ring->rdesc, ring->rdesc_dma, ring->rdata);
214 DBGPR("<--xgbe_init_ring\n");
219 static int xgbe_alloc_ring_resources(struct xgbe_prv_data *pdata)
221 struct xgbe_channel *channel;
225 DBGPR("-->xgbe_alloc_ring_resources\n");
227 channel = pdata->channel;
228 for (i = 0; i < pdata->channel_count; i++, channel++) {
229 DBGPR(" %s - tx_ring:\n", channel->name);
230 ret = xgbe_init_ring(pdata, channel->tx_ring,
231 pdata->tx_desc_count);
233 netdev_alert(pdata->netdev,
234 "error initializing Tx ring\n");
238 DBGPR(" %s - rx_ring:\n", channel->name);
239 ret = xgbe_init_ring(pdata, channel->rx_ring,
240 pdata->rx_desc_count);
242 netdev_alert(pdata->netdev,
243 "error initializing Tx ring\n");
248 DBGPR("<--xgbe_alloc_ring_resources\n");
253 xgbe_free_ring_resources(pdata);
258 static int xgbe_alloc_pages(struct xgbe_prv_data *pdata,
259 struct xgbe_page_alloc *pa, gfp_t gfp, int order)
261 struct page *pages = NULL;
262 dma_addr_t pages_dma;
265 /* Try to obtain pages, decreasing order if necessary */
266 gfp |= __GFP_COLD | __GFP_COMP;
268 pages = alloc_pages(gfp, order);
278 pages_dma = dma_map_page(pdata->dev, pages, 0,
279 PAGE_SIZE << order, DMA_FROM_DEVICE);
280 ret = dma_mapping_error(pdata->dev, pages_dma);
287 pa->pages_len = PAGE_SIZE << order;
288 pa->pages_offset = 0;
289 pa->pages_dma = pages_dma;
294 static void xgbe_set_buffer_data(struct xgbe_buffer_data *bd,
295 struct xgbe_page_alloc *pa,
301 bd->dma = pa->pages_dma + pa->pages_offset;
304 pa->pages_offset += len;
305 if ((pa->pages_offset + len) > pa->pages_len) {
306 /* This data descriptor is responsible for unmapping page(s) */
309 /* Get a new allocation next time */
312 pa->pages_offset = 0;
317 static int xgbe_map_rx_buffer(struct xgbe_prv_data *pdata,
318 struct xgbe_ring *ring,
319 struct xgbe_ring_data *rdata)
323 if (!ring->rx_hdr_pa.pages) {
324 ret = xgbe_alloc_pages(pdata, &ring->rx_hdr_pa, GFP_ATOMIC, 0);
329 if (!ring->rx_buf_pa.pages) {
330 order = max_t(int, PAGE_ALLOC_COSTLY_ORDER - 1, 0);
331 ret = xgbe_alloc_pages(pdata, &ring->rx_buf_pa, GFP_ATOMIC,
337 /* Set up the header page info */
338 xgbe_set_buffer_data(&rdata->rx.hdr, &ring->rx_hdr_pa,
339 XGBE_SKB_ALLOC_SIZE);
341 /* Set up the buffer page info */
342 xgbe_set_buffer_data(&rdata->rx.buf, &ring->rx_buf_pa,
348 static void xgbe_wrapper_tx_descriptor_init(struct xgbe_prv_data *pdata)
350 struct xgbe_hw_if *hw_if = &pdata->hw_if;
351 struct xgbe_channel *channel;
352 struct xgbe_ring *ring;
353 struct xgbe_ring_data *rdata;
354 struct xgbe_ring_desc *rdesc;
355 dma_addr_t rdesc_dma;
358 DBGPR("-->xgbe_wrapper_tx_descriptor_init\n");
360 channel = pdata->channel;
361 for (i = 0; i < pdata->channel_count; i++, channel++) {
362 ring = channel->tx_ring;
367 rdesc_dma = ring->rdesc_dma;
369 for (j = 0; j < ring->rdesc_count; j++) {
370 rdata = XGBE_GET_DESC_DATA(ring, j);
372 rdata->rdesc = rdesc;
373 rdata->rdesc_dma = rdesc_dma;
376 rdesc_dma += sizeof(struct xgbe_ring_desc);
381 memset(&ring->tx, 0, sizeof(ring->tx));
383 hw_if->tx_desc_init(channel);
386 DBGPR("<--xgbe_wrapper_tx_descriptor_init\n");
389 static void xgbe_wrapper_rx_descriptor_init(struct xgbe_prv_data *pdata)
391 struct xgbe_hw_if *hw_if = &pdata->hw_if;
392 struct xgbe_channel *channel;
393 struct xgbe_ring *ring;
394 struct xgbe_ring_desc *rdesc;
395 struct xgbe_ring_data *rdata;
396 dma_addr_t rdesc_dma;
399 DBGPR("-->xgbe_wrapper_rx_descriptor_init\n");
401 channel = pdata->channel;
402 for (i = 0; i < pdata->channel_count; i++, channel++) {
403 ring = channel->rx_ring;
408 rdesc_dma = ring->rdesc_dma;
410 for (j = 0; j < ring->rdesc_count; j++) {
411 rdata = XGBE_GET_DESC_DATA(ring, j);
413 rdata->rdesc = rdesc;
414 rdata->rdesc_dma = rdesc_dma;
416 if (xgbe_map_rx_buffer(pdata, ring, rdata))
420 rdesc_dma += sizeof(struct xgbe_ring_desc);
426 hw_if->rx_desc_init(channel);
429 DBGPR("<--xgbe_wrapper_rx_descriptor_init\n");
432 static void xgbe_unmap_rdata(struct xgbe_prv_data *pdata,
433 struct xgbe_ring_data *rdata)
435 if (rdata->skb_dma) {
436 if (rdata->mapped_as_page) {
437 dma_unmap_page(pdata->dev, rdata->skb_dma,
438 rdata->skb_dma_len, DMA_TO_DEVICE);
440 dma_unmap_single(pdata->dev, rdata->skb_dma,
441 rdata->skb_dma_len, DMA_TO_DEVICE);
444 rdata->skb_dma_len = 0;
448 dev_kfree_skb_any(rdata->skb);
452 if (rdata->rx.hdr.pa.pages)
453 put_page(rdata->rx.hdr.pa.pages);
455 if (rdata->rx.hdr.pa_unmap.pages) {
456 dma_unmap_page(pdata->dev, rdata->rx.hdr.pa_unmap.pages_dma,
457 rdata->rx.hdr.pa_unmap.pages_len,
459 put_page(rdata->rx.hdr.pa_unmap.pages);
462 if (rdata->rx.buf.pa.pages)
463 put_page(rdata->rx.buf.pa.pages);
465 if (rdata->rx.buf.pa_unmap.pages) {
466 dma_unmap_page(pdata->dev, rdata->rx.buf.pa_unmap.pages_dma,
467 rdata->rx.buf.pa_unmap.pages_len,
469 put_page(rdata->rx.buf.pa_unmap.pages);
472 memset(&rdata->tx, 0, sizeof(rdata->tx));
473 memset(&rdata->rx, 0, sizeof(rdata->rx));
475 rdata->mapped_as_page = 0;
477 if (rdata->state_saved) {
478 rdata->state_saved = 0;
479 rdata->state.incomplete = 0;
480 rdata->state.context_next = 0;
481 rdata->state.skb = NULL;
482 rdata->state.len = 0;
483 rdata->state.error = 0;
487 static int xgbe_map_tx_skb(struct xgbe_channel *channel, struct sk_buff *skb)
489 struct xgbe_prv_data *pdata = channel->pdata;
490 struct xgbe_ring *ring = channel->tx_ring;
491 struct xgbe_ring_data *rdata;
492 struct xgbe_packet_data *packet;
493 struct skb_frag_struct *frag;
495 unsigned int start_index, cur_index;
496 unsigned int offset, tso, vlan, datalen, len;
499 DBGPR("-->xgbe_map_tx_skb: cur = %d\n", ring->cur);
502 start_index = ring->cur;
503 cur_index = ring->cur;
505 packet = &ring->packet_data;
506 packet->rdesc_count = 0;
509 tso = XGMAC_GET_BITS(packet->attributes, TX_PACKET_ATTRIBUTES,
511 vlan = XGMAC_GET_BITS(packet->attributes, TX_PACKET_ATTRIBUTES,
514 /* Save space for a context descriptor if needed */
515 if ((tso && (packet->mss != ring->tx.cur_mss)) ||
516 (vlan && (packet->vlan_ctag != ring->tx.cur_vlan_ctag)))
518 rdata = XGBE_GET_DESC_DATA(ring, cur_index);
521 DBGPR(" TSO packet\n");
523 /* Map the TSO header */
524 skb_dma = dma_map_single(pdata->dev, skb->data,
525 packet->header_len, DMA_TO_DEVICE);
526 if (dma_mapping_error(pdata->dev, skb_dma)) {
527 netdev_alert(pdata->netdev, "dma_map_single failed\n");
530 rdata->skb_dma = skb_dma;
531 rdata->skb_dma_len = packet->header_len;
533 offset = packet->header_len;
535 packet->length += packet->header_len;
538 rdata = XGBE_GET_DESC_DATA(ring, cur_index);
541 /* Map the (remainder of the) packet */
542 for (datalen = skb_headlen(skb) - offset; datalen; ) {
543 len = min_t(unsigned int, datalen, XGBE_TX_MAX_BUF_SIZE);
545 skb_dma = dma_map_single(pdata->dev, skb->data + offset, len,
547 if (dma_mapping_error(pdata->dev, skb_dma)) {
548 netdev_alert(pdata->netdev, "dma_map_single failed\n");
551 rdata->skb_dma = skb_dma;
552 rdata->skb_dma_len = len;
553 DBGPR(" skb data: index=%u, dma=0x%llx, len=%u\n",
554 cur_index, skb_dma, len);
559 packet->length += len;
562 rdata = XGBE_GET_DESC_DATA(ring, cur_index);
565 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
566 DBGPR(" mapping frag %u\n", i);
568 frag = &skb_shinfo(skb)->frags[i];
571 for (datalen = skb_frag_size(frag); datalen; ) {
572 len = min_t(unsigned int, datalen,
573 XGBE_TX_MAX_BUF_SIZE);
575 skb_dma = skb_frag_dma_map(pdata->dev, frag, offset,
577 if (dma_mapping_error(pdata->dev, skb_dma)) {
578 netdev_alert(pdata->netdev,
579 "skb_frag_dma_map failed\n");
582 rdata->skb_dma = skb_dma;
583 rdata->skb_dma_len = len;
584 rdata->mapped_as_page = 1;
585 DBGPR(" skb data: index=%u, dma=0x%llx, len=%u\n",
586 cur_index, skb_dma, len);
591 packet->length += len;
594 rdata = XGBE_GET_DESC_DATA(ring, cur_index);
598 /* Save the skb address in the last entry. We always have some data
599 * that has been mapped so rdata is always advanced past the last
600 * piece of mapped data - use the entry pointed to by cur_index - 1.
602 rdata = XGBE_GET_DESC_DATA(ring, cur_index - 1);
605 /* Save the number of descriptor entries used */
606 packet->rdesc_count = cur_index - start_index;
608 DBGPR("<--xgbe_map_tx_skb: count=%u\n", packet->rdesc_count);
610 return packet->rdesc_count;
613 while (start_index < cur_index) {
614 rdata = XGBE_GET_DESC_DATA(ring, start_index++);
615 xgbe_unmap_rdata(pdata, rdata);
618 DBGPR("<--xgbe_map_tx_skb: count=0\n");
623 void xgbe_init_function_ptrs_desc(struct xgbe_desc_if *desc_if)
625 DBGPR("-->xgbe_init_function_ptrs_desc\n");
627 desc_if->alloc_ring_resources = xgbe_alloc_ring_resources;
628 desc_if->free_ring_resources = xgbe_free_ring_resources;
629 desc_if->map_tx_skb = xgbe_map_tx_skb;
630 desc_if->map_rx_buffer = xgbe_map_rx_buffer;
631 desc_if->unmap_rdata = xgbe_unmap_rdata;
632 desc_if->wrapper_tx_desc_init = xgbe_wrapper_tx_descriptor_init;
633 desc_if->wrapper_rx_desc_init = xgbe_wrapper_rx_descriptor_init;
635 DBGPR("<--xgbe_init_function_ptrs_desc\n");