1 /* Synopsys DesignWare Core Enterprise Ethernet (XLGMAC) Driver 2 * 3 * Copyright (c) 2017 Synopsys, Inc. (www.synopsys.com) 4 * 5 * This program is dual-licensed; you may select either version 2 of 6 * the GNU General Public License ("GPL") or BSD license ("BSD"). 7 * 8 * This Synopsys DWC XLGMAC software driver and associated documentation 9 * (hereinafter the "Software") is an unsupported proprietary work of 10 * Synopsys, Inc. unless otherwise expressly agreed to in writing between 11 * Synopsys and you. The Software IS NOT an item of Licensed Software or a 12 * Licensed Product under any End User Software License Agreement or 13 * Agreement for Licensed Products with Synopsys or any supplement thereto. 14 * Synopsys is a registered trademark of Synopsys, Inc. Other names included 15 * in the SOFTWARE may be the trademarks of their respective owners. 16 */ 17 18 #include "dwc-xlgmac.h" 19 #include "dwc-xlgmac-reg.h" 20 21 static void xlgmac_unmap_desc_data(struct xlgmac_pdata *pdata, 22 struct xlgmac_desc_data *desc_data) 23 { 24 if (desc_data->skb_dma) { 25 if (desc_data->mapped_as_page) { 26 dma_unmap_page(pdata->dev, desc_data->skb_dma, 27 desc_data->skb_dma_len, DMA_TO_DEVICE); 28 } else { 29 dma_unmap_single(pdata->dev, desc_data->skb_dma, 30 desc_data->skb_dma_len, DMA_TO_DEVICE); 31 } 32 desc_data->skb_dma = 0; 33 desc_data->skb_dma_len = 0; 34 } 35 36 if (desc_data->skb) { 37 dev_kfree_skb_any(desc_data->skb); 38 desc_data->skb = NULL; 39 } 40 41 if (desc_data->rx.hdr.pa.pages) 42 put_page(desc_data->rx.hdr.pa.pages); 43 44 if (desc_data->rx.hdr.pa_unmap.pages) { 45 dma_unmap_page(pdata->dev, desc_data->rx.hdr.pa_unmap.pages_dma, 46 desc_data->rx.hdr.pa_unmap.pages_len, 47 DMA_FROM_DEVICE); 48 put_page(desc_data->rx.hdr.pa_unmap.pages); 49 } 50 51 if (desc_data->rx.buf.pa.pages) 52 put_page(desc_data->rx.buf.pa.pages); 53 54 if (desc_data->rx.buf.pa_unmap.pages) { 55 dma_unmap_page(pdata->dev, desc_data->rx.buf.pa_unmap.pages_dma, 56 desc_data->rx.buf.pa_unmap.pages_len, 57 DMA_FROM_DEVICE); 58 put_page(desc_data->rx.buf.pa_unmap.pages); 59 } 60 61 memset(&desc_data->tx, 0, sizeof(desc_data->tx)); 62 memset(&desc_data->rx, 0, sizeof(desc_data->rx)); 63 64 desc_data->mapped_as_page = 0; 65 66 if (desc_data->state_saved) { 67 desc_data->state_saved = 0; 68 desc_data->state.skb = NULL; 69 desc_data->state.len = 0; 70 desc_data->state.error = 0; 71 } 72 } 73 74 static void xlgmac_free_ring(struct xlgmac_pdata *pdata, 75 struct xlgmac_ring *ring) 76 { 77 struct xlgmac_desc_data *desc_data; 78 unsigned int i; 79 80 if (!ring) 81 return; 82 83 if (ring->desc_data_head) { 84 for (i = 0; i < ring->dma_desc_count; i++) { 85 desc_data = XLGMAC_GET_DESC_DATA(ring, i); 86 xlgmac_unmap_desc_data(pdata, desc_data); 87 } 88 89 kfree(ring->desc_data_head); 90 ring->desc_data_head = NULL; 91 } 92 93 if (ring->rx_hdr_pa.pages) { 94 dma_unmap_page(pdata->dev, ring->rx_hdr_pa.pages_dma, 95 ring->rx_hdr_pa.pages_len, DMA_FROM_DEVICE); 96 put_page(ring->rx_hdr_pa.pages); 97 98 ring->rx_hdr_pa.pages = NULL; 99 ring->rx_hdr_pa.pages_len = 0; 100 ring->rx_hdr_pa.pages_offset = 0; 101 ring->rx_hdr_pa.pages_dma = 0; 102 } 103 104 if (ring->rx_buf_pa.pages) { 105 dma_unmap_page(pdata->dev, ring->rx_buf_pa.pages_dma, 106 ring->rx_buf_pa.pages_len, DMA_FROM_DEVICE); 107 put_page(ring->rx_buf_pa.pages); 108 109 ring->rx_buf_pa.pages = NULL; 110 ring->rx_buf_pa.pages_len = 0; 111 ring->rx_buf_pa.pages_offset = 0; 112 ring->rx_buf_pa.pages_dma = 0; 113 } 114 115 if (ring->dma_desc_head) { 116 dma_free_coherent(pdata->dev, 117 (sizeof(struct xlgmac_dma_desc) * 118 ring->dma_desc_count), 119 ring->dma_desc_head, 120 ring->dma_desc_head_addr); 121 ring->dma_desc_head = NULL; 122 } 123 } 124 125 static int xlgmac_init_ring(struct xlgmac_pdata *pdata, 126 struct xlgmac_ring *ring, 127 unsigned int dma_desc_count) 128 { 129 if (!ring) 130 return 0; 131 132 /* Descriptors */ 133 ring->dma_desc_count = dma_desc_count; 134 ring->dma_desc_head = dma_alloc_coherent(pdata->dev, 135 (sizeof(struct xlgmac_dma_desc) * 136 dma_desc_count), 137 &ring->dma_desc_head_addr, 138 GFP_KERNEL); 139 if (!ring->dma_desc_head) 140 return -ENOMEM; 141 142 /* Array of descriptor data */ 143 ring->desc_data_head = kcalloc(dma_desc_count, 144 sizeof(struct xlgmac_desc_data), 145 GFP_KERNEL); 146 if (!ring->desc_data_head) 147 return -ENOMEM; 148 149 netif_dbg(pdata, drv, pdata->netdev, 150 "dma_desc_head=%p, dma_desc_head_addr=%pad, desc_data_head=%p\n", 151 ring->dma_desc_head, 152 &ring->dma_desc_head_addr, 153 ring->desc_data_head); 154 155 return 0; 156 } 157 158 static void xlgmac_free_rings(struct xlgmac_pdata *pdata) 159 { 160 struct xlgmac_channel *channel; 161 unsigned int i; 162 163 if (!pdata->channel_head) 164 return; 165 166 channel = pdata->channel_head; 167 for (i = 0; i < pdata->channel_count; i++, channel++) { 168 xlgmac_free_ring(pdata, channel->tx_ring); 169 xlgmac_free_ring(pdata, channel->rx_ring); 170 } 171 } 172 173 static int xlgmac_alloc_rings(struct xlgmac_pdata *pdata) 174 { 175 struct xlgmac_channel *channel; 176 unsigned int i; 177 int ret; 178 179 channel = pdata->channel_head; 180 for (i = 0; i < pdata->channel_count; i++, channel++) { 181 netif_dbg(pdata, drv, pdata->netdev, "%s - Tx ring:\n", 182 channel->name); 183 184 ret = xlgmac_init_ring(pdata, channel->tx_ring, 185 pdata->tx_desc_count); 186 187 if (ret) { 188 netdev_alert(pdata->netdev, 189 "error initializing Tx ring"); 190 goto err_init_ring; 191 } 192 193 netif_dbg(pdata, drv, pdata->netdev, "%s - Rx ring:\n", 194 channel->name); 195 196 ret = xlgmac_init_ring(pdata, channel->rx_ring, 197 pdata->rx_desc_count); 198 if (ret) { 199 netdev_alert(pdata->netdev, 200 "error initializing Rx ring\n"); 201 goto err_init_ring; 202 } 203 } 204 205 return 0; 206 207 err_init_ring: 208 xlgmac_free_rings(pdata); 209 210 return ret; 211 } 212 213 static void xlgmac_free_channels(struct xlgmac_pdata *pdata) 214 { 215 if (!pdata->channel_head) 216 return; 217 218 kfree(pdata->channel_head->tx_ring); 219 pdata->channel_head->tx_ring = NULL; 220 221 kfree(pdata->channel_head->rx_ring); 222 pdata->channel_head->rx_ring = NULL; 223 224 kfree(pdata->channel_head); 225 226 pdata->channel_head = NULL; 227 pdata->channel_count = 0; 228 } 229 230 static int xlgmac_alloc_channels(struct xlgmac_pdata *pdata) 231 { 232 struct xlgmac_channel *channel_head, *channel; 233 struct xlgmac_ring *tx_ring, *rx_ring; 234 int ret = -ENOMEM; 235 unsigned int i; 236 237 channel_head = kcalloc(pdata->channel_count, 238 sizeof(struct xlgmac_channel), GFP_KERNEL); 239 if (!channel_head) 240 return ret; 241 242 netif_dbg(pdata, drv, pdata->netdev, 243 "channel_head=%p\n", channel_head); 244 245 tx_ring = kcalloc(pdata->tx_ring_count, sizeof(struct xlgmac_ring), 246 GFP_KERNEL); 247 if (!tx_ring) 248 goto err_tx_ring; 249 250 rx_ring = kcalloc(pdata->rx_ring_count, sizeof(struct xlgmac_ring), 251 GFP_KERNEL); 252 if (!rx_ring) 253 goto err_rx_ring; 254 255 for (i = 0, channel = channel_head; i < pdata->channel_count; 256 i++, channel++) { 257 snprintf(channel->name, sizeof(channel->name), "channel-%u", i); 258 channel->pdata = pdata; 259 channel->queue_index = i; 260 channel->dma_regs = pdata->mac_regs + DMA_CH_BASE + 261 (DMA_CH_INC * i); 262 263 if (pdata->per_channel_irq) { 264 /* Get the per DMA interrupt */ 265 ret = pdata->channel_irq[i]; 266 if (ret < 0) { 267 netdev_err(pdata->netdev, 268 "get_irq %u failed\n", 269 i + 1); 270 goto err_irq; 271 } 272 channel->dma_irq = ret; 273 } 274 275 if (i < pdata->tx_ring_count) 276 channel->tx_ring = tx_ring++; 277 278 if (i < pdata->rx_ring_count) 279 channel->rx_ring = rx_ring++; 280 281 netif_dbg(pdata, drv, pdata->netdev, 282 "%s: dma_regs=%p, tx_ring=%p, rx_ring=%p\n", 283 channel->name, channel->dma_regs, 284 channel->tx_ring, channel->rx_ring); 285 } 286 287 pdata->channel_head = channel_head; 288 289 return 0; 290 291 err_irq: 292 kfree(rx_ring); 293 294 err_rx_ring: 295 kfree(tx_ring); 296 297 err_tx_ring: 298 kfree(channel_head); 299 300 return ret; 301 } 302 303 static void xlgmac_free_channels_and_rings(struct xlgmac_pdata *pdata) 304 { 305 xlgmac_free_rings(pdata); 306 307 xlgmac_free_channels(pdata); 308 } 309 310 static int xlgmac_alloc_channels_and_rings(struct xlgmac_pdata *pdata) 311 { 312 int ret; 313 314 ret = xlgmac_alloc_channels(pdata); 315 if (ret) 316 goto err_alloc; 317 318 ret = xlgmac_alloc_rings(pdata); 319 if (ret) 320 goto err_alloc; 321 322 return 0; 323 324 err_alloc: 325 xlgmac_free_channels_and_rings(pdata); 326 327 return ret; 328 } 329 330 static int xlgmac_alloc_pages(struct xlgmac_pdata *pdata, 331 struct xlgmac_page_alloc *pa, 332 gfp_t gfp, int order) 333 { 334 struct page *pages = NULL; 335 dma_addr_t pages_dma; 336 337 /* Try to obtain pages, decreasing order if necessary */ 338 gfp |= __GFP_COMP | __GFP_NOWARN; 339 while (order >= 0) { 340 pages = alloc_pages(gfp, order); 341 if (pages) 342 break; 343 344 order--; 345 } 346 if (!pages) 347 return -ENOMEM; 348 349 /* Map the pages */ 350 pages_dma = dma_map_page(pdata->dev, pages, 0, 351 PAGE_SIZE << order, DMA_FROM_DEVICE); 352 if (dma_mapping_error(pdata->dev, pages_dma)) { 353 put_page(pages); 354 return -ENOMEM; 355 } 356 357 pa->pages = pages; 358 pa->pages_len = PAGE_SIZE << order; 359 pa->pages_offset = 0; 360 pa->pages_dma = pages_dma; 361 362 return 0; 363 } 364 365 static void xlgmac_set_buffer_data(struct xlgmac_buffer_data *bd, 366 struct xlgmac_page_alloc *pa, 367 unsigned int len) 368 { 369 get_page(pa->pages); 370 bd->pa = *pa; 371 372 bd->dma_base = pa->pages_dma; 373 bd->dma_off = pa->pages_offset; 374 bd->dma_len = len; 375 376 pa->pages_offset += len; 377 if ((pa->pages_offset + len) > pa->pages_len) { 378 /* This data descriptor is responsible for unmapping page(s) */ 379 bd->pa_unmap = *pa; 380 381 /* Get a new allocation next time */ 382 pa->pages = NULL; 383 pa->pages_len = 0; 384 pa->pages_offset = 0; 385 pa->pages_dma = 0; 386 } 387 } 388 389 static int xlgmac_map_rx_buffer(struct xlgmac_pdata *pdata, 390 struct xlgmac_ring *ring, 391 struct xlgmac_desc_data *desc_data) 392 { 393 int order, ret; 394 395 if (!ring->rx_hdr_pa.pages) { 396 ret = xlgmac_alloc_pages(pdata, &ring->rx_hdr_pa, 397 GFP_ATOMIC, 0); 398 if (ret) 399 return ret; 400 } 401 402 if (!ring->rx_buf_pa.pages) { 403 order = max_t(int, PAGE_ALLOC_COSTLY_ORDER - 1, 0); 404 ret = xlgmac_alloc_pages(pdata, &ring->rx_buf_pa, 405 GFP_ATOMIC, order); 406 if (ret) 407 return ret; 408 } 409 410 /* Set up the header page info */ 411 xlgmac_set_buffer_data(&desc_data->rx.hdr, &ring->rx_hdr_pa, 412 XLGMAC_SKB_ALLOC_SIZE); 413 414 /* Set up the buffer page info */ 415 xlgmac_set_buffer_data(&desc_data->rx.buf, &ring->rx_buf_pa, 416 pdata->rx_buf_size); 417 418 return 0; 419 } 420 421 static void xlgmac_tx_desc_init(struct xlgmac_pdata *pdata) 422 { 423 struct xlgmac_hw_ops *hw_ops = &pdata->hw_ops; 424 struct xlgmac_desc_data *desc_data; 425 struct xlgmac_dma_desc *dma_desc; 426 struct xlgmac_channel *channel; 427 struct xlgmac_ring *ring; 428 dma_addr_t dma_desc_addr; 429 unsigned int i, j; 430 431 channel = pdata->channel_head; 432 for (i = 0; i < pdata->channel_count; i++, channel++) { 433 ring = channel->tx_ring; 434 if (!ring) 435 break; 436 437 dma_desc = ring->dma_desc_head; 438 dma_desc_addr = ring->dma_desc_head_addr; 439 440 for (j = 0; j < ring->dma_desc_count; j++) { 441 desc_data = XLGMAC_GET_DESC_DATA(ring, j); 442 443 desc_data->dma_desc = dma_desc; 444 desc_data->dma_desc_addr = dma_desc_addr; 445 446 dma_desc++; 447 dma_desc_addr += sizeof(struct xlgmac_dma_desc); 448 } 449 450 ring->cur = 0; 451 ring->dirty = 0; 452 memset(&ring->tx, 0, sizeof(ring->tx)); 453 454 hw_ops->tx_desc_init(channel); 455 } 456 } 457 458 static void xlgmac_rx_desc_init(struct xlgmac_pdata *pdata) 459 { 460 struct xlgmac_hw_ops *hw_ops = &pdata->hw_ops; 461 struct xlgmac_desc_data *desc_data; 462 struct xlgmac_dma_desc *dma_desc; 463 struct xlgmac_channel *channel; 464 struct xlgmac_ring *ring; 465 dma_addr_t dma_desc_addr; 466 unsigned int i, j; 467 468 channel = pdata->channel_head; 469 for (i = 0; i < pdata->channel_count; i++, channel++) { 470 ring = channel->rx_ring; 471 if (!ring) 472 break; 473 474 dma_desc = ring->dma_desc_head; 475 dma_desc_addr = ring->dma_desc_head_addr; 476 477 for (j = 0; j < ring->dma_desc_count; j++) { 478 desc_data = XLGMAC_GET_DESC_DATA(ring, j); 479 480 desc_data->dma_desc = dma_desc; 481 desc_data->dma_desc_addr = dma_desc_addr; 482 483 if (xlgmac_map_rx_buffer(pdata, ring, desc_data)) 484 break; 485 486 dma_desc++; 487 dma_desc_addr += sizeof(struct xlgmac_dma_desc); 488 } 489 490 ring->cur = 0; 491 ring->dirty = 0; 492 493 hw_ops->rx_desc_init(channel); 494 } 495 } 496 497 static int xlgmac_map_tx_skb(struct xlgmac_channel *channel, 498 struct sk_buff *skb) 499 { 500 struct xlgmac_pdata *pdata = channel->pdata; 501 struct xlgmac_ring *ring = channel->tx_ring; 502 unsigned int start_index, cur_index; 503 struct xlgmac_desc_data *desc_data; 504 unsigned int offset, datalen, len; 505 struct xlgmac_pkt_info *pkt_info; 506 skb_frag_t *frag; 507 unsigned int tso, vlan; 508 dma_addr_t skb_dma; 509 unsigned int i; 510 511 offset = 0; 512 start_index = ring->cur; 513 cur_index = ring->cur; 514 515 pkt_info = &ring->pkt_info; 516 pkt_info->desc_count = 0; 517 pkt_info->length = 0; 518 519 tso = XLGMAC_GET_REG_BITS(pkt_info->attributes, 520 TX_PACKET_ATTRIBUTES_TSO_ENABLE_POS, 521 TX_PACKET_ATTRIBUTES_TSO_ENABLE_LEN); 522 vlan = XLGMAC_GET_REG_BITS(pkt_info->attributes, 523 TX_PACKET_ATTRIBUTES_VLAN_CTAG_POS, 524 TX_PACKET_ATTRIBUTES_VLAN_CTAG_LEN); 525 526 /* Save space for a context descriptor if needed */ 527 if ((tso && (pkt_info->mss != ring->tx.cur_mss)) || 528 (vlan && (pkt_info->vlan_ctag != ring->tx.cur_vlan_ctag))) 529 cur_index++; 530 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index); 531 532 if (tso) { 533 /* Map the TSO header */ 534 skb_dma = dma_map_single(pdata->dev, skb->data, 535 pkt_info->header_len, DMA_TO_DEVICE); 536 if (dma_mapping_error(pdata->dev, skb_dma)) { 537 netdev_alert(pdata->netdev, "dma_map_single failed\n"); 538 goto err_out; 539 } 540 desc_data->skb_dma = skb_dma; 541 desc_data->skb_dma_len = pkt_info->header_len; 542 netif_dbg(pdata, tx_queued, pdata->netdev, 543 "skb header: index=%u, dma=%pad, len=%u\n", 544 cur_index, &skb_dma, pkt_info->header_len); 545 546 offset = pkt_info->header_len; 547 548 pkt_info->length += pkt_info->header_len; 549 550 cur_index++; 551 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index); 552 } 553 554 /* Map the (remainder of the) packet */ 555 for (datalen = skb_headlen(skb) - offset; datalen; ) { 556 len = min_t(unsigned int, datalen, XLGMAC_TX_MAX_BUF_SIZE); 557 558 skb_dma = dma_map_single(pdata->dev, skb->data + offset, len, 559 DMA_TO_DEVICE); 560 if (dma_mapping_error(pdata->dev, skb_dma)) { 561 netdev_alert(pdata->netdev, "dma_map_single failed\n"); 562 goto err_out; 563 } 564 desc_data->skb_dma = skb_dma; 565 desc_data->skb_dma_len = len; 566 netif_dbg(pdata, tx_queued, pdata->netdev, 567 "skb data: index=%u, dma=%pad, len=%u\n", 568 cur_index, &skb_dma, len); 569 570 datalen -= len; 571 offset += len; 572 573 pkt_info->length += len; 574 575 cur_index++; 576 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index); 577 } 578 579 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 580 netif_dbg(pdata, tx_queued, pdata->netdev, 581 "mapping frag %u\n", i); 582 583 frag = &skb_shinfo(skb)->frags[i]; 584 offset = 0; 585 586 for (datalen = skb_frag_size(frag); datalen; ) { 587 len = min_t(unsigned int, datalen, 588 XLGMAC_TX_MAX_BUF_SIZE); 589 590 skb_dma = skb_frag_dma_map(pdata->dev, frag, offset, 591 len, DMA_TO_DEVICE); 592 if (dma_mapping_error(pdata->dev, skb_dma)) { 593 netdev_alert(pdata->netdev, 594 "skb_frag_dma_map failed\n"); 595 goto err_out; 596 } 597 desc_data->skb_dma = skb_dma; 598 desc_data->skb_dma_len = len; 599 desc_data->mapped_as_page = 1; 600 netif_dbg(pdata, tx_queued, pdata->netdev, 601 "skb frag: index=%u, dma=%pad, len=%u\n", 602 cur_index, &skb_dma, len); 603 604 datalen -= len; 605 offset += len; 606 607 pkt_info->length += len; 608 609 cur_index++; 610 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index); 611 } 612 } 613 614 /* Save the skb address in the last entry. We always have some data 615 * that has been mapped so desc_data is always advanced past the last 616 * piece of mapped data - use the entry pointed to by cur_index - 1. 617 */ 618 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index - 1); 619 desc_data->skb = skb; 620 621 /* Save the number of descriptor entries used */ 622 pkt_info->desc_count = cur_index - start_index; 623 624 return pkt_info->desc_count; 625 626 err_out: 627 while (start_index < cur_index) { 628 desc_data = XLGMAC_GET_DESC_DATA(ring, start_index++); 629 xlgmac_unmap_desc_data(pdata, desc_data); 630 } 631 632 return 0; 633 } 634 635 void xlgmac_init_desc_ops(struct xlgmac_desc_ops *desc_ops) 636 { 637 desc_ops->alloc_channels_and_rings = xlgmac_alloc_channels_and_rings; 638 desc_ops->free_channels_and_rings = xlgmac_free_channels_and_rings; 639 desc_ops->map_tx_skb = xlgmac_map_tx_skb; 640 desc_ops->map_rx_buffer = xlgmac_map_rx_buffer; 641 desc_ops->unmap_desc_data = xlgmac_unmap_desc_data; 642 desc_ops->tx_desc_init = xlgmac_tx_desc_init; 643 desc_ops->rx_desc_init = xlgmac_rx_desc_init; 644 } 645