stge(4): Correct parameters passed to busdma(9) functions

et(4): Utilize bus_dmamap_load_mbuf_{segment,defrag}()

et(4): Split RX/TX mbuf busdma tag

et(4): Don't sync coherent memory

et(4): Utilize bus_dmamem_coherent_any()

busdma(9): Add bus_dmamem_coherent_any()

This function is a simplified version of bus_dmamem_coherent(),
see the comment in sys/bus_dma.h for details.

et(4): Utilize bus_dmamem_coherent()

et(4): Correct parameters passed to busdma(9) functions

msk(4): Align TX buffer to 64bytes boundary instead of 8bytes boundary

The correct alignment boundary is found out by using busdma(9)'s
alignment constraint.  However, it seems that using in-place copy
results in better performance than let busdma(9) to bounce misaligned
TX buffer, especially with tiny packets; probably due to the "in-place"

msk(4): Align TX buffer to 8bytes boundary to improve TX performance

The performance improvement is ~100Mbps (from 83xMbps to 93xMbps) for
bulk data.  This is accidentally found by forcing msk(4) to bounce TX
buffers to lower address during a busdma(4) test (bounce pages are
PAGE_SIZE aligned).

busdma(9): Obey alignment constraint by default

msk(4): Avoid busdma map leakage on error handling path

msk(4): Adjust TX path

- Utilize bus_dmamap_load_mbuf_defrag().
- Fix the IFF_OACTIVE setting in msk_start().  This restores the
  fragmented UDP output performance.
- Sync TX buffer before setup TX desc.
- Remove unnecessary bus_dmamap_sync().

msk(4): Utilize bus_dmamap_load_mbuf_segment()

msk(4): Utilize bus_dmamem_coherent() and don't sync coherent memory

msk(4): Correct parameters passed to busdma(9) functions

sk(4): Utilize bus_dmamap_load_mbuf_defrag()

sk(4): Adjust RX path a little bit

- Utilize bus_dmamap_load_mbuf_segment()
- Don't try m_devget(); it does not help much, if the NIC is quenched
  by the peer, e.g. by line rate fragmented UDP datagrams
- Move bus_dmamap_sync() from sk_rxeof() into sk_newbuf_std()

sk(4): Rework busdma(9) related bits

- According to data sheet, sk(4) does support 64bits address space.
  However, the RX/TX descriptors' high 32bits must be same, i.e.
  descriptors' can't spread above and below 4Gbytes boundary.  Since
  sk(4)'s RX/TX descriptors are in contiguous memory, this means we
  only need to make sure that the contiguous memory does not cross
  4Gbytes boundary.
- RX/TX descriptors' is 8bytes aligned not 64bytes aligned.
- Split RX/TX descriptor rings.
- Use bus_dmamem_coherent() to allocate RX/TX descriptor rings.
- Don't sync coherent memory.

sk(4): Adjust TX path a little bit.

rl(4): Don't use magic number

rl(4): Rework busdma(9) related bits

- Correct parameters passed to busdma(9) functions.
- Split RX/TX busdma tag.
- Use bus_dmamem_coherent() to allocate RX buffers.
- Create TX buffer busdma map at attach time and destroy them only
  at detach time.
- Rework rl_encap().
- Don't sync RX buffers, which is coherent memory.

bge(4): Remove unnecessary bus_dmamap_sync()

bge(4): Utilize bus_dmamap_load_mbuf_{defrag,segment}()

bge(4): Rework bge_newbuf_{std,jumbo}()

- Always fill the std RX ring, instead of leaving it half full.
  On modern system, 1MBytes non-contiguous memory will not be
  the source of trouble.
- Record RX buffer's physical address along with the RX mbuf.
- Factor out bge_setup_rxdesc_{std,jumbo}(); call them if RX errors
  happen.
- Move RX std buffer busdma map sync/unload into bge_newbuf_std()
- Use temporary busdma map to load RX std buffer, so that the busdma
  map loading failure will not be fatal.

bge(4): Split RX/TX mbuf busdma tags

bge(4): Don't sync coherent memory

bge(4): Utilize bus_dmamem_coherent()

bge(4): Correct busdma parameters

if_bgereg.h: Remove extra white space

busdma(9): Update FreeBSD RSCID.

busdma(9): Don't record/use boundary in bounce zone

Bounce zone's boundary does not make any sense for PAGE_SIZE
contiguous allocation which also aligned on multiple or one
PAGE_SIZE.

busdma(9): Use the passed in 'flags' instead of hard coding BUS_DMA_NOWAIT

jme(4): Don't sync coherent memory

re(4): Don't sync coherent memory

nfe(4): Coherent memory does not need to be synced

xl(4): Coherent memory does not need to be synced

bfe(4): Coherent memory does not need to be synced

jme(4): Move TX buffer syncing before setting up TX desc

jme(4): Utilize bus_dmamap_load_mbuf_{segment,defrag}()

jme(4): Depend on parent busdma tag to apply lowaddr constraint

jme(4): jme_dma_free() is only called on detach path now

jme(4): Utilize bus_dmamem_coherent()

jme(4): Fix busdma(9) parameters

jme(4): Rely on busdma(9) to do the boundary check

busdma(9): Add sysctl node to show whether aligment constraint is obeyed or not

busdma(9): Obey alignment constraint, disabled by default

- Obey alignment constraint
  Obtained-from: FreeBSD
- Correct "cross page boundary" check in bus_dmamem_alloc()
- Make sure that after kmalloc() retry, memory will not cross page
  boundary and is properly aligned.  If not, print backtrace; should
  panic though.
- Factor out BUS_DMA_KMALLOC(), so we don't duplicate the conditions
  in bus_dmamem_alloc() and bus_dmamem_free()
- Assert the input memory is properly aligned, if caller told us so

busdma(9): get rid of bounce_lowaddr, which serves no purpose

xl(4): Remove unused bus_dmamap_sync()

xl(4): Rework xl_encap()

xl(4): Rework xl_newbuf()

- Utilize bus_dmamap_load_mbuf_segment()
- Move setting buffer address before clearing status
- Add init flag, so we could use M_WAIT during device initialization
- Move bus_dmamap_sync(POSTREAD) into xl_newbuf() and do busdma sync
  and unload iff we previously loaded a mbuf.

xl(4): Split RX and TX mbuf busdma tag

xl(4): Utilize bus_dmamem_coherent()

xl(4): Allocate parent busdma tag, which is used to constraint lowaddr

nfe(4): Utilize bus_dmamap_load_mbuf_{segment,defrag}()

re(4): Utilize bus_dmamap_load_mbuf_{segment,defrag}()

busdma(9): Add BUS_DMA_ALIGNED hint flag

This flag is used to give hint to busdma(9) that all to-be-loaded
memory is proper aligned, thus no bounce pages should be allocated.
This will be used when busdma obeys alignment requirement.

It could save us some bounce page memory under following situation:
Some NICs require RX buffer to be 4 or 8 bytes aligned while our mbuf
cluster allocation always promises 2048 bytes alignment.

Rename BUS_DMA_ONEPAGE to BUS_DMA_ONEBPAGE, should have done that
in the first place though ...

bfe(4): Utilize bus_dmamap_load_mbuf_defrag()

busdma(9): Add bus_dmamap_load_mbuf_defrag()

This function is mainly used to avoid code duplication in various
(should be many) NIC driver code.

bfe(4): Utilize bus_dmamap_load_mbuf_segment()

busdma(9): Add bus_dmamap_load_mbuf_segment()

See the comment in sys/bus_dma.h for detailed information
about this function.

Let bus_dmamap_load_mbuf() call this function with busdma tag's
segments and nsegments.

Inspired-by: FreeBSD's bus_dmamap_load_mbuf_sg()

nfe(4): busdma(9) fixes

On RX path:
- Unload busdma map iff the map has already been loaded
- Add missing bus_dmamap_sync()

On TX path:
- Reduce log verbosity
- Move buffer content's bus_dmamap_sync() to the proper place

Misc:
- Nuke unnecessary bus_dmamap_sync()

busdma(9): More bounce page bug fixing

Turn on BUS_DMA_MIN_ALLOC_COMP, iff we do allocate bounce pages for
the busdma tag.

busdma(9): Add tunable and read-only sysctl node for max # of bounce
pages per bounce zone.

nfe(4): Always set high part of the address if the NIC supports
40bits address space accessing.

nfe(4): busdma(9) correction

- Use bus_dmamem_coherent()
- Fix busdma(9) parameters

re(4): add missing BUS_DMA_WAITOK

bfe(4): Add missing BUS_DMA_WAITOK

bfe(4): use bus_dmamem_coherent()

Factor out bus_dmamem_coherent() to allocate busdma memory.
Mainly to avoid code duplication in various drivers.

Change bfe(4) according to recent busdma(9) bounce page fixes

Bounce page work

For NICs which support jumbo frame but need to allocate one TX
descriptor per segment, it does not make sense to allocate more
than one bounce page for a single TX mbuf busdma map.  Add
BUS_DMA_ONEPAGE, so callers of busdma(9) functions could give
hint that only one bounce page is needed for a busdma map.

Bounce page fix

- In bus_dma_tag_create(), make sure that:
  o  Alignment is power of 2
  o  Boundary is power of 2
  o  Max segment size is less than boundary
     Obtained-from: FreeBSD
- When counting the pages needed by maxsize, round up the maxsize to
  multiple page size first.
- For bounce zones, always round up its alignment and boundary to
  page size.
- Pass 'flags' to alloc_bounce_pages(), so we could assign 'mflags'
  to contigmalloc().

Bounce page fixes

- Free accumulated bounce pages in the bus dma map if we could not
  reserved enough bounce pages.
- In bus_dmamap_load_mbuf(), if _bus_dmamap_load_buffer() returns
  ENOMEM on non-first mbuf fragment, we adjust the error to EFBIG:
  o  There is at least one bounce page available, so we could expect
     that after mbuf defragmentation, enough bounce pages (normally
     one bounce page for non-jumbo frame) may be available.
  o  Most callers defragment the mbuf chain only if error is EFBIG.

Increase RE_TXDESC_SPARE to cooperate 9K jumbo frame.

Allocate at least one bounce page if the dma tag indicates bouncing
is needed.  Bug was found by forcing re(4) to bounce mbufs to lower
physical memory (re(4)'s TX and RX buffers use different bounce zones).

Split RX/TX bus dma tag.   RX buffers should to be aligned on 8 bytes.

Correct busdma(9) parameters

There should be no 2 bytes alignment requirement

Add assertion to make sure that the segment index is in valid range.

Add assertion to make sure that bounce zone is in sane state.

Free the bounce pages allocated and reserved by the busdma map,
if _bus_dmamap_load_buffer() fails because of too many segments.

- Use spinlock to protect bounce zone itself.
- Get MPLOCK and critical section for callback_waitinglist.

Use lwkt_token to protect bounce_zone_list

Move bounce_map_waitinglist into bounce page zone

_bus_dmamap_load_buffer2() -> _bus_dmamap_load_buffer()

Use _bus_dmamap_load_buffer2() in bus_dmamap_load_uio()

Count # of boune page reservation failure

Update if_oerrors if bfe_encap() failed and the mbuf was freed

Add bounce page zone.

It is used to group bounce pages with similar properties, i.e.
lowaddr, boundry and alignment.  A bounce page zone will be
reused, if a newly created dma tag has less strict requirements.

Obtained-from: FreeBSD

Rework bfe_encap()

Rework bfe_newbuf()

bfe_list_newbuf() -> bfe_newbuf()

Remove unused bfe_softc fields

- Split RX/TX mbuf dma tag.
- Create a tmp dma map for RX mbuf, which will be used when rework
  RX path.

Fix parameters passed to bus_dma_tag_create()

Fix warning about uninitialized variable (should be an error)

Use _bus_dmamap_load_buffer2() in bus_dmamap_load_mbuf()

Add BUS_DMA_NOWAIT support to _bus_dmamap_load_buffer2()

Obtained-from: FreeBSD

Factor out _bus_dmamap_load_buffer2() from bus_dmamap_load().
This is the first step toward replacing _bus_dmamap_load_buffer() with
_bus_dmamap_load_buffer2(), which has bounce page handling code.