sys/dev/dwc/dwc1000_dma.c

   1 /*-
   2  * Copyright (c) 2014 Ruslan Bukin <br@bsdpad.com>
   3  *
   4  * This software was developed by SRI International and the University of
   5  * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
   6  * ("CTSRD"), as part of the DARPA CRASH research programme.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/bus.h>
  33 #include <sys/kernel.h>
  34 #include <sys/lock.h>
  35 #include <sys/malloc.h>
  36 #include <sys/mbuf.h>
  37 #include <sys/module.h>
  38 #include <sys/mutex.h>
  39 #include <sys/rman.h>
  40 #include <sys/socket.h>
  41
  42 #include <net/bpf.h>
  43 #include <net/if.h>
  44 #include <net/ethernet.h>
  45 #include <net/if_dl.h>
  46 #include <net/if_media.h>
  47 #include <net/if_types.h>
  48 #include <net/if_var.h>
  49
  50 #include <machine/bus.h>
  51
  52 #include <dev/clk/clk.h>
  53 #include <dev/hwreset/hwreset.h>
  54
  55 #include <dev/ofw/ofw_bus.h>
  56 #include <dev/ofw/ofw_bus_subr.h>
  57
  58 #include <dev/dwc/if_dwcvar.h>
  59 #include <dev/dwc/dwc1000_reg.h>
  60 #include <dev/dwc/dwc1000_dma.h>
  61
  62 #define WATCHDOG_TIMEOUT_SECS   5
  63 #define DMA_RESET_TIMEOUT       100
  64
  65 /* TX descriptors - TDESC0 is almost unified */
  66 #define TDESC0_OWN              (1U << 31)
  67 #define TDESC0_IHE              (1U << 16)      /* IP Header Error */
  68 #define TDESC0_ES               (1U << 15)      /* Error Summary */
  69 #define TDESC0_JT               (1U << 14)      /* Jabber Timeout */
  70 #define TDESC0_FF               (1U << 13)      /* Frame Flushed */
  71 #define TDESC0_PCE              (1U << 12)      /* Payload Checksum Error */
  72 #define TDESC0_LOC              (1U << 11)      /* Loss of Carrier */
  73 #define TDESC0_NC               (1U << 10)      /* No Carrier */
  74 #define TDESC0_LC               (1U <<  9)      /* Late Collision */
  75 #define TDESC0_EC               (1U <<  8)      /* Excessive Collision */
  76 #define TDESC0_VF               (1U <<  7)      /* VLAN Frame */
  77 #define TDESC0_CC_MASK          0xf
  78 #define TDESC0_CC_SHIFT         3               /* Collision Count */
  79 #define TDESC0_ED               (1U <<  2)      /* Excessive Deferral */
  80 #define TDESC0_UF               (1U <<  1)      /* Underflow Error */
  81 #define TDESC0_DB               (1U <<  0)      /* Deferred Bit */
  82 /* TX descriptors - TDESC0 extended format only */
  83 #define ETDESC0_IC              (1U << 30)      /* Interrupt on Completion */
  84 #define ETDESC0_LS              (1U << 29)      /* Last Segment */
  85 #define ETDESC0_FS              (1U << 28)      /* First Segment */
  86 #define ETDESC0_DC              (1U << 27)      /* Disable CRC */
  87 #define ETDESC0_DP              (1U << 26)      /* Disable Padding */
  88 #define ETDESC0_CIC_NONE        (0U << 22)      /* Checksum Insertion Control */
  89 #define ETDESC0_CIC_HDR         (1U << 22)
  90 #define ETDESC0_CIC_SEG         (2U << 22)
  91 #define ETDESC0_CIC_FULL        (3U << 22)
  92 #define ETDESC0_TER             (1U << 21)      /* Transmit End of Ring */
  93 #define ETDESC0_TCH             (1U << 20)      /* Second Address Chained */
  94
  95 /* TX descriptors - TDESC1 normal format */
  96 #define NTDESC1_IC              (1U << 31)      /* Interrupt on Completion */
  97 #define NTDESC1_LS              (1U << 30)      /* Last Segment */
  98 #define NTDESC1_FS              (1U << 29)      /* First Segment */
  99 #define NTDESC1_CIC_NONE        (0U << 27)      /* Checksum Insertion Control */
 100 #define NTDESC1_CIC_HDR         (1U << 27)
 101 #define NTDESC1_CIC_SEG         (2U << 27)
 102 #define NTDESC1_CIC_FULL        (3U << 27)
 103 #define NTDESC1_DC              (1U << 26)      /* Disable CRC */
 104 #define NTDESC1_TER             (1U << 25)      /* Transmit End of Ring */
 105 #define NTDESC1_TCH             (1U << 24)      /* Second Address Chained */
 106 /* TX descriptors - TDESC1 extended format */
 107 #define ETDESC1_DP              (1U << 23)      /* Disable Padding */
 108 #define ETDESC1_TBS2_MASK       0x7ff
 109 #define ETDESC1_TBS2_SHIFT      11              /* Receive Buffer 2 Size */
 110 #define ETDESC1_TBS1_MASK       0x7ff
 111 #define ETDESC1_TBS1_SHIFT      0               /* Receive Buffer 1 Size */
 112
 113 /* RX descriptor - RDESC0 is unified */
 114 #define RDESC0_OWN              (1U << 31)
 115 #define RDESC0_AFM              (1U << 30)      /* Dest. Address Filter Fail */
 116 #define RDESC0_FL_MASK          0x3fff
 117 #define RDESC0_FL_SHIFT         16              /* Frame Length */
 118 #define RDESC0_ES               (1U << 15)      /* Error Summary */
 119 #define RDESC0_DE               (1U << 14)      /* Descriptor Error */
 120 #define RDESC0_SAF              (1U << 13)      /* Source Address Filter Fail */
 121 #define RDESC0_LE               (1U << 12)      /* Length Error */
 122 #define RDESC0_OE               (1U << 11)      /* Overflow Error */
 123 #define RDESC0_VLAN             (1U << 10)      /* VLAN Tag */
 124 #define RDESC0_FS               (1U <<  9)      /* First Descriptor */
 125 #define RDESC0_LS               (1U <<  8)      /* Last Descriptor */
 126 #define RDESC0_ICE              (1U <<  7)      /* IPC Checksum Error */
 127 #define RDESC0_LC               (1U <<  6)      /* Late Collision */
 128 #define RDESC0_FT               (1U <<  5)      /* Frame Type */
 129 #define RDESC0_RWT              (1U <<  4)      /* Receive Watchdog Timeout */
 130 #define RDESC0_RE               (1U <<  3)      /* Receive Error */
 131 #define RDESC0_DBE              (1U <<  2)      /* Dribble Bit Error */
 132 #define RDESC0_CE               (1U <<  1)      /* CRC Error */
 133 #define RDESC0_PCE              (1U <<  0)      /* Payload Checksum Error */
 134 #define RDESC0_RXMA             (1U <<  0)      /* Rx MAC Address */
 135
 136 /* RX descriptors - RDESC1 normal format */
 137 #define NRDESC1_DIC             (1U << 31)      /* Disable Intr on Completion */
 138 #define NRDESC1_RER             (1U << 25)      /* Receive End of Ring */
 139 #define NRDESC1_RCH             (1U << 24)      /* Second Address Chained */
 140 #define NRDESC1_RBS2_MASK       0x7ff
 141 #define NRDESC1_RBS2_SHIFT      11              /* Receive Buffer 2 Size */
 142 #define NRDESC1_RBS1_MASK       0x7ff
 143 #define NRDESC1_RBS1_SHIFT      0               /* Receive Buffer 1 Size */
 144
 145 /* RX descriptors - RDESC1 enhanced format */
 146 #define ERDESC1_DIC             (1U << 31)      /* Disable Intr on Completion */
 147 #define ERDESC1_RBS2_MASK       0x7ffff
 148 #define ERDESC1_RBS2_SHIFT      16              /* Receive Buffer 2 Size */
 149 #define ERDESC1_RER             (1U << 15)      /* Receive End of Ring */
 150 #define ERDESC1_RCH             (1U << 14)      /* Second Address Chained */
 151 #define ERDESC1_RBS1_MASK       0x7ffff
 152 #define ERDESC1_RBS1_SHIFT      0               /* Receive Buffer 1 Size */
 153
 154 /*
 155  * The hardware imposes alignment restrictions on various objects involved in
 156  * DMA transfers.  These values are expressed in bytes (not bits).
 157  */
 158 #define DWC_DESC_RING_ALIGN     2048
 159
 160 static inline uint32_t
 161 next_txidx(struct dwc_softc *sc, uint32_t curidx)
 162 {
 163
 164         return ((curidx + 1) % TX_DESC_COUNT);
 165 }
 166
 167 static inline uint32_t
 168 next_rxidx(struct dwc_softc *sc, uint32_t curidx)
 169 {
 170
 171         return ((curidx + 1) % RX_DESC_COUNT);
 172 }
 173
 174 static void
 175 dwc_get1paddr(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
 176 {
 177
 178         if (error != 0)
 179                 return;
 180         *(bus_addr_t *)arg = segs[0].ds_addr;
 181 }
 182
 183 inline static void
 184 txdesc_clear(struct dwc_softc *sc, int idx)
 185 {
 186
 187         sc->tx_desccount--;
 188         sc->txdesc_ring[idx].addr1 = (uint32_t)(0);
 189         sc->txdesc_ring[idx].desc0 = 0;
 190         sc->txdesc_ring[idx].desc1 = 0;
 191 }
 192
 193 inline static void
 194 txdesc_setup(struct dwc_softc *sc, int idx, bus_addr_t paddr,
 195   uint32_t len, uint32_t flags, bool first, bool last)
 196 {
 197         uint32_t desc0, desc1;
 198
 199         if (!sc->dma_ext_desc) {
 200                 desc0 = 0;
 201                 desc1 = NTDESC1_TCH | len | flags;
 202                 if (first)
 203                         desc1 |=  NTDESC1_FS;
 204                 if (last)
 205                         desc1 |= NTDESC1_LS | NTDESC1_IC;
 206         } else {
 207                 desc0 = ETDESC0_TCH | flags;
 208                 if (first)
 209                         desc0 |= ETDESC0_FS;
 210                 if (last)
 211                         desc0 |= ETDESC0_LS | ETDESC0_IC;
 212                 desc1 = len;
 213         }
 214         ++sc->tx_desccount;
 215         sc->txdesc_ring[idx].addr1 = (uint32_t)(paddr);
 216         sc->txdesc_ring[idx].desc0 = desc0;
 217         sc->txdesc_ring[idx].desc1 = desc1;
 218         wmb();
 219         sc->txdesc_ring[idx].desc0 |= TDESC0_OWN;
 220         wmb();
 221 }
 222
 223 inline static uint32_t
 224 rxdesc_setup(struct dwc_softc *sc, int idx, bus_addr_t paddr)
 225 {
 226         uint32_t nidx;
 227
 228         sc->rxdesc_ring[idx].addr1 = (uint32_t)paddr;
 229         nidx = next_rxidx(sc, idx);
 230         sc->rxdesc_ring[idx].addr2 = sc->rxdesc_ring_paddr +
 231             (nidx * sizeof(struct dwc_hwdesc));
 232         if (!sc->dma_ext_desc)
 233                 sc->rxdesc_ring[idx].desc1 = NRDESC1_RCH |
 234                     MIN(MCLBYTES, NRDESC1_RBS1_MASK);
 235         else
 236                 sc->rxdesc_ring[idx].desc1 = ERDESC1_RCH |
 237                     MIN(MCLBYTES, ERDESC1_RBS1_MASK);
 238
 239         wmb();
 240         sc->rxdesc_ring[idx].desc0 = RDESC0_OWN;
 241         wmb();
 242         return (nidx);
 243 }
 244
 245 int
 246 dma1000_setup_txbuf(struct dwc_softc *sc, int idx, struct mbuf **mp)
 247 {
 248         struct bus_dma_segment segs[TX_MAP_MAX_SEGS];
 249         int error, nsegs;
 250         struct mbuf * m;
 251         uint32_t flags = 0;
 252         int i;
 253         int last;
 254
 255         error = bus_dmamap_load_mbuf_sg(sc->txbuf_tag, sc->txbuf_map[idx].map,
 256             *mp, segs, &nsegs, 0);
 257         if (error == EFBIG) {
 258                 /*
 259                  * The map may be partially mapped from the first call.
 260                  * Make sure to reset it.
 261                  */
 262                 bus_dmamap_unload(sc->txbuf_tag, sc->txbuf_map[idx].map);
 263                 if ((m = m_defrag(*mp, M_NOWAIT)) == NULL)
 264                         return (ENOMEM);
 265                 *mp = m;
 266                 error = bus_dmamap_load_mbuf_sg(sc->txbuf_tag, sc->txbuf_map[idx].map,
 267                     *mp, segs, &nsegs, 0);
 268         }
 269         if (error != 0)
 270                 return (ENOMEM);
 271
 272         if (sc->tx_desccount + nsegs > TX_DESC_COUNT) {
 273                 bus_dmamap_unload(sc->txbuf_tag, sc->txbuf_map[idx].map);
 274                 return (ENOMEM);
 275         }
 276
 277         m = *mp;
 278
 279         if ((m->m_pkthdr.csum_flags & CSUM_IP) != 0) {
 280                 if ((m->m_pkthdr.csum_flags & (CSUM_TCP|CSUM_UDP)) != 0) {
 281                         if (!sc->dma_ext_desc)
 282                                 flags = NTDESC1_CIC_FULL;
 283                         else
 284                                 flags = ETDESC0_CIC_FULL;
 285                 } else {
 286                         if (!sc->dma_ext_desc)
 287                                 flags = NTDESC1_CIC_HDR;
 288                         else
 289                                 flags = ETDESC0_CIC_HDR;
 290                 }
 291         }
 292
 293         bus_dmamap_sync(sc->txbuf_tag, sc->txbuf_map[idx].map,
 294             BUS_DMASYNC_PREWRITE);
 295
 296         sc->txbuf_map[idx].mbuf = m;
 297
 298         for (i = 0; i < nsegs; i++) {
 299                 txdesc_setup(sc, sc->tx_desc_head,
 300                     segs[i].ds_addr, segs[i].ds_len,
 301                     (i == 0) ? flags : 0, /* only first desc needs flags */
 302                     (i == 0),
 303                     (i == nsegs - 1));
 304                 last = sc->tx_desc_head;
 305                 sc->tx_desc_head = next_txidx(sc, sc->tx_desc_head);
 306         }
 307
 308         sc->txbuf_map[idx].last_desc_idx = last;
 309
 310         return (0);
 311 }
 312
 313 static int
 314 dma1000_setup_rxbuf(struct dwc_softc *sc, int idx, struct mbuf *m)
 315 {
 316         struct bus_dma_segment seg;
 317         int error, nsegs;
 318
 319         m_adj(m, ETHER_ALIGN);
 320
 321         error = bus_dmamap_load_mbuf_sg(sc->rxbuf_tag, sc->rxbuf_map[idx].map,
 322             m, &seg, &nsegs, 0);
 323         if (error != 0)
 324                 return (error);
 325
 326         KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs));
 327
 328         bus_dmamap_sync(sc->rxbuf_tag, sc->rxbuf_map[idx].map,
 329             BUS_DMASYNC_PREREAD);
 330
 331         sc->rxbuf_map[idx].mbuf = m;
 332         rxdesc_setup(sc, idx, seg.ds_addr);
 333
 334         return (0);
 335 }
 336
 337 static struct mbuf *
 338 dwc_alloc_mbufcl(struct dwc_softc *sc)
 339 {
 340         struct mbuf *m;
 341
 342         m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
 343         if (m != NULL)
 344                 m->m_pkthdr.len = m->m_len = m->m_ext.ext_size;
 345
 346         return (m);
 347 }
 348
 349 static struct mbuf *
 350 dwc_rxfinish_one(struct dwc_softc *sc, struct dwc_hwdesc *desc,
 351     struct dwc_bufmap *map)
 352 {
 353         if_t ifp;
 354         struct mbuf *m, *m0;
 355         int len;
 356         uint32_t rdesc0;
 357
 358         m = map->mbuf;
 359         ifp = sc->ifp;
 360         rdesc0 = desc ->desc0;
 361
 362         if ((rdesc0 & (RDESC0_FS | RDESC0_LS)) !=
 363                     (RDESC0_FS | RDESC0_LS)) {
 364                 /*
 365                  * Something very wrong happens. The whole packet should be
 366                  * received in one descriptor. Report problem.
 367                  */
 368                 device_printf(sc->dev,
 369                     "%s: RX descriptor without FIRST and LAST bit set: 0x%08X",
 370                     __func__, rdesc0);
 371                 return (NULL);
 372         }
 373
 374         len = (rdesc0 >> RDESC0_FL_SHIFT) & RDESC0_FL_MASK;
 375         if (len < 64) {
 376                 /*
 377                  * Lenght is invalid, recycle old mbuf
 378                  * Probably impossible case
 379                  */
 380                 return (NULL);
 381         }
 382
 383         /* Allocate new buffer */
 384         m0 = dwc_alloc_mbufcl(sc);
 385         if (m0 == NULL) {
 386                 /* no new mbuf available, recycle old */
 387                 if_inc_counter(sc->ifp, IFCOUNTER_IQDROPS, 1);
 388                 return (NULL);
 389         }
 390         /* Do dmasync for newly received packet */
 391         bus_dmamap_sync(sc->rxbuf_tag, map->map, BUS_DMASYNC_POSTREAD);
 392         bus_dmamap_unload(sc->rxbuf_tag, map->map);
 393
 394         /* Received packet is valid, process it */
 395         m->m_pkthdr.rcvif = ifp;
 396         m->m_pkthdr.len = len;
 397         m->m_len = len;
 398         if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
 399
 400         if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0 &&
 401           (rdesc0 & RDESC0_FT) != 0) {
 402                 m->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
 403                 if ((rdesc0 & RDESC0_ICE) == 0)
 404                         m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
 405                 if ((rdesc0 & RDESC0_PCE) == 0) {
 406                         m->m_pkthdr.csum_flags |=
 407                                 CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
 408                         m->m_pkthdr.csum_data = 0xffff;
 409                 }
 410         }
 411
 412         /* Remove trailing FCS */
 413         m_adj(m, -ETHER_CRC_LEN);
 414
 415         DWC_UNLOCK(sc);
 416         if_input(ifp, m);
 417         DWC_LOCK(sc);
 418         return (m0);
 419 }
 420
 421 void
 422 dma1000_txfinish_locked(struct dwc_softc *sc)
 423 {
 424         struct dwc_bufmap *bmap;
 425         struct dwc_hwdesc *desc;
 426         if_t ifp;
 427         int idx, last_idx;
 428         bool map_finished;
 429
 430         DWC_ASSERT_LOCKED(sc);
 431
 432         ifp = sc->ifp;
 433         /* check if all descriptors of the map are done */
 434         while (sc->tx_map_tail != sc->tx_map_head) {
 435                 map_finished = true;
 436                 bmap = &sc->txbuf_map[sc->tx_map_tail];
 437                 idx = sc->tx_desc_tail;
 438                 last_idx = next_txidx(sc, bmap->last_desc_idx);
 439                 while (idx != last_idx) {
 440                         desc = &sc->txdesc_ring[idx];
 441                         if ((desc->desc0 & TDESC0_OWN) != 0) {
 442                                 map_finished = false;
 443                                 break;
 444                         }
 445                         idx = next_txidx(sc, idx);
 446                 }
 447
 448                 if (!map_finished)
 449                         break;
 450                 bus_dmamap_sync(sc->txbuf_tag, bmap->map,
 451                     BUS_DMASYNC_POSTWRITE);
 452                 bus_dmamap_unload(sc->txbuf_tag, bmap->map);
 453                 m_freem(bmap->mbuf);
 454                 bmap->mbuf = NULL;
 455                 sc->tx_mapcount--;
 456                 while (sc->tx_desc_tail != last_idx) {
 457                         txdesc_clear(sc, sc->tx_desc_tail);
 458                         sc->tx_desc_tail = next_txidx(sc, sc->tx_desc_tail);
 459                 }
 460                 sc->tx_map_tail = next_txidx(sc, sc->tx_map_tail);
 461                 if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
 462                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
 463         }
 464
 465         /* If there are no buffers outstanding, muzzle the watchdog. */
 466         if (sc->tx_desc_tail == sc->tx_desc_head) {
 467                 sc->tx_watchdog_count = 0;
 468         }
 469 }
 470
 471 void
 472 dma1000_txstart(struct dwc_softc *sc)
 473 {
 474         int enqueued;
 475         struct mbuf *m;
 476
 477         enqueued = 0;
 478
 479         for (;;) {
 480                 if (sc->tx_desccount > (TX_DESC_COUNT - TX_MAP_MAX_SEGS  + 1)) {
 481                         if_setdrvflagbits(sc->ifp, IFF_DRV_OACTIVE, 0);
 482                         break;
 483                 }
 484
 485                 if (sc->tx_mapcount == (TX_MAP_COUNT - 1)) {
 486                         if_setdrvflagbits(sc->ifp, IFF_DRV_OACTIVE, 0);
 487                         break;
 488                 }
 489
 490                 m = if_dequeue(sc->ifp);
 491                 if (m == NULL)
 492                         break;
 493                 if (dma1000_setup_txbuf(sc, sc->tx_map_head, &m) != 0) {
 494                         if_sendq_prepend(sc->ifp, m);
 495                         if_setdrvflagbits(sc->ifp, IFF_DRV_OACTIVE, 0);
 496                         break;
 497                 }
 498                 bpf_mtap_if(sc->ifp, m);
 499                 sc->tx_map_head = next_txidx(sc, sc->tx_map_head);
 500                 sc->tx_mapcount++;
 501                 ++enqueued;
 502         }
 503
 504         if (enqueued != 0) {
 505                 WRITE4(sc, TRANSMIT_POLL_DEMAND, 0x1);
 506                 sc->tx_watchdog_count = WATCHDOG_TIMEOUT_SECS;
 507         }
 508 }
 509
 510 void
 511 dma1000_rxfinish_locked(struct dwc_softc *sc)
 512 {
 513         struct mbuf *m;
 514         int error, idx;
 515         struct dwc_hwdesc *desc;
 516
 517         DWC_ASSERT_LOCKED(sc);
 518         for (;;) {
 519                 idx = sc->rx_idx;
 520                 desc = sc->rxdesc_ring + idx;
 521                 if ((desc->desc0 & RDESC0_OWN) != 0)
 522                         break;
 523
 524                 m = dwc_rxfinish_one(sc, desc, sc->rxbuf_map + idx);
 525                 if (m == NULL) {
 526                         wmb();
 527                         desc->desc0 = RDESC0_OWN;
 528                         wmb();
 529                 } else {
 530                         /* We cannot create hole in RX ring */
 531                         error = dma1000_setup_rxbuf(sc, idx, m);
 532                         if (error != 0)
 533                                 panic("dma1000_setup_rxbuf failed:  error %d\n",
 534                                     error);
 535
 536                 }
 537                 sc->rx_idx = next_rxidx(sc, sc->rx_idx);
 538         }
 539 }
 540
 541 /*
 542  * Start the DMA controller
 543  */
 544 void
 545 dma1000_start(struct dwc_softc *sc)
 546 {
 547         uint32_t reg;
 548
 549         DWC_ASSERT_LOCKED(sc);
 550
 551         /* Initializa DMA and enable transmitters */
 552         reg = READ4(sc, OPERATION_MODE);
 553         reg |= (MODE_TSF | MODE_OSF | MODE_FUF);
 554         reg &= ~(MODE_RSF);
 555         reg |= (MODE_RTC_LEV32 << MODE_RTC_SHIFT);
 556         WRITE4(sc, OPERATION_MODE, reg);
 557
 558         WRITE4(sc, INTERRUPT_ENABLE, INT_EN_DEFAULT);
 559
 560         /* Start DMA */
 561         reg = READ4(sc, OPERATION_MODE);
 562         reg |= (MODE_ST | MODE_SR);
 563         WRITE4(sc, OPERATION_MODE, reg);
 564 }
 565
 566 /*
 567  * Stop the DMA controller
 568  */
 569 void
 570 dma1000_stop(struct dwc_softc *sc)
 571 {
 572         uint32_t reg;
 573
 574         DWC_ASSERT_LOCKED(sc);
 575
 576         /* Stop DMA TX */
 577         reg = READ4(sc, OPERATION_MODE);
 578         reg &= ~(MODE_ST);
 579         WRITE4(sc, OPERATION_MODE, reg);
 580
 581         /* Flush TX */
 582         reg = READ4(sc, OPERATION_MODE);
 583         reg |= (MODE_FTF);
 584         WRITE4(sc, OPERATION_MODE, reg);
 585
 586         /* Stop DMA RX */
 587         reg = READ4(sc, OPERATION_MODE);
 588         reg &= ~(MODE_SR);
 589         WRITE4(sc, OPERATION_MODE, reg);
 590 }
 591
 592 int
 593 dma1000_reset(struct dwc_softc *sc)
 594 {
 595         uint32_t reg;
 596         int i;
 597
 598         reg = READ4(sc, BUS_MODE);
 599         reg |= (BUS_MODE_SWR);
 600         WRITE4(sc, BUS_MODE, reg);
 601
 602         for (i = 0; i < DMA_RESET_TIMEOUT; i++) {
 603                 if ((READ4(sc, BUS_MODE) & BUS_MODE_SWR) == 0)
 604                         break;
 605                 DELAY(10);
 606         }
 607         if (i >= DMA_RESET_TIMEOUT) {
 608                 return (ENXIO);
 609         }
 610
 611         return (0);
 612 }
 613
 614 /*
 615  * Create the bus_dma resources
 616  */
 617 int
 618 dma1000_init(struct dwc_softc *sc)
 619 {
 620         struct mbuf *m;
 621         uint32_t reg;
 622         int error;
 623         int nidx;
 624         int idx;
 625
 626         reg = BUS_MODE_USP;
 627         if (!sc->nopblx8)
 628                 reg |= BUS_MODE_EIGHTXPBL;
 629         reg |= (sc->txpbl << BUS_MODE_PBL_SHIFT);
 630         reg |= (sc->rxpbl << BUS_MODE_RPBL_SHIFT);
 631         if (sc->fixed_burst)
 632                 reg |= BUS_MODE_FIXEDBURST;
 633         if (sc->mixed_burst)
 634                 reg |= BUS_MODE_MIXEDBURST;
 635         if (sc->aal)
 636                 reg |= BUS_MODE_AAL;
 637
 638         WRITE4(sc, BUS_MODE, reg);
 639
 640         reg = READ4(sc, HW_FEATURE);
 641         if (reg & HW_FEATURE_EXT_DESCRIPTOR)
 642                 sc->dma_ext_desc = true;
 643
 644         /*
 645          * DMA must be stop while changing descriptor list addresses.
 646          */
 647         reg = READ4(sc, OPERATION_MODE);
 648         reg &= ~(MODE_ST | MODE_SR);
 649         WRITE4(sc, OPERATION_MODE, reg);
 650
 651         /*
 652          * Set up TX descriptor ring, descriptors, and dma maps.
 653          */
 654         error = bus_dma_tag_create(
 655             bus_get_dma_tag(sc->dev),   /* Parent tag. */
 656             DWC_DESC_RING_ALIGN, 0,     /* alignment, boundary */
 657             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 658             BUS_SPACE_MAXADDR,          /* highaddr */
 659             NULL, NULL,                 /* filter, filterarg */
 660             TX_DESC_SIZE, 1,            /* maxsize, nsegments */
 661             TX_DESC_SIZE,               /* maxsegsize */
 662             0,                          /* flags */
 663             NULL, NULL,                 /* lockfunc, lockarg */
 664             &sc->txdesc_tag);
 665         if (error != 0) {
 666                 device_printf(sc->dev,
 667                     "could not create TX ring DMA tag.\n");
 668                 goto out;
 669         }
 670
 671         error = bus_dmamem_alloc(sc->txdesc_tag, (void**)&sc->txdesc_ring,
 672             BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO,
 673             &sc->txdesc_map);
 674         if (error != 0) {
 675                 device_printf(sc->dev,
 676                     "could not allocate TX descriptor ring.\n");
 677                 goto out;
 678         }
 679
 680         error = bus_dmamap_load(sc->txdesc_tag, sc->txdesc_map,
 681             sc->txdesc_ring, TX_DESC_SIZE, dwc_get1paddr,
 682             &sc->txdesc_ring_paddr, 0);
 683         if (error != 0) {
 684                 device_printf(sc->dev,
 685                     "could not load TX descriptor ring map.\n");
 686                 goto out;
 687         }
 688
 689         for (idx = 0; idx < TX_DESC_COUNT; idx++) {
 690                 nidx = next_txidx(sc, idx);
 691                 sc->txdesc_ring[idx].addr2 = sc->txdesc_ring_paddr +
 692                     (nidx * sizeof(struct dwc_hwdesc));
 693         }
 694
 695         error = bus_dma_tag_create(
 696             bus_get_dma_tag(sc->dev),   /* Parent tag. */
 697             1, 0,                       /* alignment, boundary */
 698             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 699             BUS_SPACE_MAXADDR,          /* highaddr */
 700             NULL, NULL,                 /* filter, filterarg */
 701             MCLBYTES*TX_MAP_MAX_SEGS,   /* maxsize */
 702             TX_MAP_MAX_SEGS,            /* nsegments */
 703             MCLBYTES,                   /* maxsegsize */
 704             0,                          /* flags */
 705             NULL, NULL,                 /* lockfunc, lockarg */
 706             &sc->txbuf_tag);
 707         if (error != 0) {
 708                 device_printf(sc->dev,
 709                     "could not create TX ring DMA tag.\n");
 710                 goto out;
 711         }
 712
 713         for (idx = 0; idx < TX_MAP_COUNT; idx++) {
 714                 error = bus_dmamap_create(sc->txbuf_tag, BUS_DMA_COHERENT,
 715                     &sc->txbuf_map[idx].map);
 716                 if (error != 0) {
 717                         device_printf(sc->dev,
 718                             "could not create TX buffer DMA map.\n");
 719                         goto out;
 720                 }
 721         }
 722
 723         for (idx = 0; idx < TX_DESC_COUNT; idx++)
 724                 txdesc_clear(sc, idx);
 725
 726         WRITE4(sc, TX_DESCR_LIST_ADDR, sc->txdesc_ring_paddr);
 727
 728         /*
 729          * Set up RX descriptor ring, descriptors, dma maps, and mbufs.
 730          */
 731         error = bus_dma_tag_create(
 732             bus_get_dma_tag(sc->dev),   /* Parent tag. */
 733             DWC_DESC_RING_ALIGN, 0,     /* alignment, boundary */
 734             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 735             BUS_SPACE_MAXADDR,          /* highaddr */
 736             NULL, NULL,                 /* filter, filterarg */
 737             RX_DESC_SIZE, 1,            /* maxsize, nsegments */
 738             RX_DESC_SIZE,               /* maxsegsize */
 739             0,                          /* flags */
 740             NULL, NULL,                 /* lockfunc, lockarg */
 741             &sc->rxdesc_tag);
 742         if (error != 0) {
 743                 device_printf(sc->dev,
 744                     "could not create RX ring DMA tag.\n");
 745                 goto out;
 746         }
 747
 748         error = bus_dmamem_alloc(sc->rxdesc_tag, (void **)&sc->rxdesc_ring,
 749             BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO,
 750             &sc->rxdesc_map);
 751         if (error != 0) {
 752                 device_printf(sc->dev,
 753                     "could not allocate RX descriptor ring.\n");
 754                 goto out;
 755         }
 756
 757         error = bus_dmamap_load(sc->rxdesc_tag, sc->rxdesc_map,
 758             sc->rxdesc_ring, RX_DESC_SIZE, dwc_get1paddr,
 759             &sc->rxdesc_ring_paddr, 0);
 760         if (error != 0) {
 761                 device_printf(sc->dev,
 762                     "could not load RX descriptor ring map.\n");
 763                 goto out;
 764         }
 765
 766         error = bus_dma_tag_create(
 767             bus_get_dma_tag(sc->dev),   /* Parent tag. */
 768             1, 0,                       /* alignment, boundary */
 769             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
 770             BUS_SPACE_MAXADDR,          /* highaddr */
 771             NULL, NULL,                 /* filter, filterarg */
 772             MCLBYTES, 1,                /* maxsize, nsegments */
 773             MCLBYTES,                   /* maxsegsize */
 774             0,                          /* flags */
 775             NULL, NULL,                 /* lockfunc, lockarg */
 776             &sc->rxbuf_tag);
 777         if (error != 0) {
 778                 device_printf(sc->dev,
 779                     "could not create RX buf DMA tag.\n");
 780                 goto out;
 781         }
 782
 783         for (idx = 0; idx < RX_DESC_COUNT; idx++) {
 784                 error = bus_dmamap_create(sc->rxbuf_tag, BUS_DMA_COHERENT,
 785                     &sc->rxbuf_map[idx].map);
 786                 if (error != 0) {
 787                         device_printf(sc->dev,
 788                             "could not create RX buffer DMA map.\n");
 789                         goto out;
 790                 }
 791                 if ((m = dwc_alloc_mbufcl(sc)) == NULL) {
 792                         device_printf(sc->dev, "Could not alloc mbuf\n");
 793                         error = ENOMEM;
 794                         goto out;
 795                 }
 796                 if ((error = dma1000_setup_rxbuf(sc, idx, m)) != 0) {
 797                         device_printf(sc->dev,
 798                             "could not create new RX buffer.\n");
 799                         goto out;
 800                 }
 801         }
 802         WRITE4(sc, RX_DESCR_LIST_ADDR, sc->rxdesc_ring_paddr);
 803
 804 out:
 805         if (error != 0)
 806                 return (ENXIO);
 807
 808         return (0);
 809 }
 810
 811 /*
 812  * Free the bus_dma resources
 813  */
 814 void
 815 dma1000_free(struct dwc_softc *sc)
 816 {
 817         bus_dmamap_t map;
 818         int idx;
 819
 820         /* Clean up RX DMA resources and free mbufs. */
 821         for (idx = 0; idx < RX_DESC_COUNT; ++idx) {
 822                 if ((map = sc->rxbuf_map[idx].map) != NULL) {
 823                         bus_dmamap_unload(sc->rxbuf_tag, map);
 824                         bus_dmamap_destroy(sc->rxbuf_tag, map);
 825                         m_freem(sc->rxbuf_map[idx].mbuf);
 826                 }
 827         }
 828         if (sc->rxbuf_tag != NULL)
 829                 bus_dma_tag_destroy(sc->rxbuf_tag);
 830         if (sc->rxdesc_map != NULL) {
 831                 bus_dmamap_unload(sc->rxdesc_tag, sc->rxdesc_map);
 832                 bus_dmamem_free(sc->rxdesc_tag, sc->rxdesc_ring,
 833                     sc->rxdesc_map);
 834         }
 835         if (sc->rxdesc_tag != NULL)
 836                 bus_dma_tag_destroy(sc->rxdesc_tag);
 837
 838         /* Clean up TX DMA resources. */
 839         for (idx = 0; idx < TX_DESC_COUNT; ++idx) {
 840                 if ((map = sc->txbuf_map[idx].map) != NULL) {
 841                         /* TX maps are already unloaded. */
 842                         bus_dmamap_destroy(sc->txbuf_tag, map);
 843                 }
 844         }
 845         if (sc->txbuf_tag != NULL)
 846                 bus_dma_tag_destroy(sc->txbuf_tag);
 847         if (sc->txdesc_map != NULL) {
 848                 bus_dmamap_unload(sc->txdesc_tag, sc->txdesc_map);
 849                 bus_dmamem_free(sc->txdesc_tag, sc->txdesc_ring,
 850                     sc->txdesc_map);
 851         }
 852         if (sc->txdesc_tag != NULL)
 853                 bus_dma_tag_destroy(sc->txdesc_tag);
 854 }
 855
 856 /*
 857  * Interrupt function
 858  */
 859
 860 int
 861 dma1000_intr(struct dwc_softc *sc)
 862 {
 863         uint32_t reg;
 864         int rv;
 865
 866         DWC_ASSERT_LOCKED(sc);
 867
 868         rv = 0;
 869         reg = READ4(sc, DMA_STATUS);
 870         if (reg & DMA_STATUS_NIS) {
 871                 if (reg & DMA_STATUS_RI)
 872                         dma1000_rxfinish_locked(sc);
 873
 874                 if (reg & DMA_STATUS_TI) {
 875                         dma1000_txfinish_locked(sc);
 876                         dma1000_txstart(sc);
 877                 }
 878         }
 879
 880         if (reg & DMA_STATUS_AIS) {
 881                 if (reg & DMA_STATUS_FBI) {
 882                         /* Fatal bus error */
 883                         rv = EIO;
 884                 }
 885         }
 886
 887         WRITE4(sc, DMA_STATUS, reg & DMA_STATUS_INTR_MASK);
 888         return (rv);
 889 }