modules/swcore: bugfix, make sure that IB does not request force_free before start page is written to the LL

If frame is to be dropped while only one page (start page) was used, then the
start page is written two times to the Linked List. First time, with the inter
page as the next_page; second time with next_page set to 0, and EOF high. That's
because inter page was not yet used so only start_page should be force-freed.
It happened once in a while that IB was requesting force_free of a received
frame before start_page with EOF was written to the linked list. Therefore
freeing module was making a mess by trying to force free the start_page, then
the inter page (which was not used in fact) and then trying to read next inter
page (which was not there...).
With this commit I try to make sure that start page is always written to the LL
before force-free request goes from IB to the freeing module.

modules/swcore: bugfix in allocator, read new free page sooner when there are again some pages available

This one fixes the situation when allocFSM in one of the input blocks requests
usecount set and new allocation (S_PCKSTART_SET_AND_REQ state) while out_nomem
is just before the transition from high to low. In that case arbiter grants
access to this Input Block request (because setting usecount does not require
out_nomem to be '0'). Then, we expect first allocation immediatelly after
out_nomem is 0, but reading next page happens only when out_nomem_d1 is '0'.
That's too late and the same page address was given to two subsequent allocation
requests.
The fix forces q_read aligned to out_nomem_d0 to read earlier next allocation
address. In addition, _done_ for allocation is now generated only if there was a
valid page address read in advance from the memory (to prevent double
allocations of the same page).

The problem occured in swc_page_alloc_ram_bug.vhd when there were no more free
pages (out_nomem_d1='1') and input block was requesting allocation and setting
usecnt (alloc FSM in S_PCKSTART_SET_AND_REQ). The operation was _done_ because
there is always one free page read in advance, prepared to be allocated to a
requesting input block and set usecnt does not depend on out_nomem_d1.
However, reading of the next free page from the memory was done only on
alloc_req, only if there were still some free pages (q_read_p0 <= alloc_req &
!out_nomem_d1).
That means allocator was holding address of the page just allocated to one of
the input blocks, and was giving the same address to the next one requesting
allocation (if in the meantime out_nomem_d1 went to '0').
To fix that I've added one register keeping information if the page read from
the memory was already given to any requestor. If it was then I do _read_ of the
new page imediately after there are some new pages (out_nomem_d1 = '0') so that
it is ready when next time somebody asks.

When it turns out we have to drop frame (e.g. because memory is full) and we get
this information on page boundary, next inter page is already being requested.
However, we do not use previously allocated inter page, that means we lose
previously allocated page forever.
In most of the cases, the conditional statement prevents such situation by
checking mpm_dlast = '0'. But mpm_dlast is delayed by 1 clock cycle, that's why
I added checking for tp_drop. Now, if we get in the same cycle mpm_pg_req and
tp_drop, then we don't make a new inter page request.

In the situation when RCV fsm was dropping the whole frame (no pages were used)
it was not raising force_free request. However, transfer fsm always waits for
force free to be done once it gets to DROP state. This commit adds rp_drop_no_ff
signal which is asserted by RCV fsm when it goes to DROP, but does not request
force free.

Without this fix, when previous frame was whole dropped, transfer fsm was still
in DROP state, while RCV fsm was going to S_IDLE. In that case, RCV fsm saw
tp_drop high and it was doing force_free of a correctly received frame (the one
before dropped frame).
The conditional statement is needed, but it had to be fixed to work according to
description in the comment - i.e. dropping frame when RTU decision is very late.

Fix for the issue 1063. In short, we need to keep in reset clock alignment fifo
in the endpoint (native Virtex-6 FIFO) until GTX is locked and produces rx
clock. That's what Xilinx document _ug363_ says. Otherwise, if this FIFO is not
reset correctly I get strange behavior like asserting empty_o and almost_full_o
in the same time.

You have to execute gen_sdbsyn.py before the synthesis. I hope later we can
automatize this by using hdlmake. Gitignore doesn't allow to commit
synthesis_descriptor.vhd because eveyone has to generate his/her own with the
script.

This way one Tx OOB word may be lost, and tx timestamp won't be generated
causing _wrn_start_xmit: descriptor overflow: tx timestamp pending_ message from
wr-nic driver

It reports the pstats version, number of counters stored in a single memory word
and the number of counters per each port. Information is then used by pstats
driver to create sysfs file used by SNMP for exporting counters values.