ftdi: Add configurations for Digilent HS1 and HS2

Signed-off-by: Anton Kolesov <anton.kolesov@synopsys.com>
(cherry picked from commit 7669e76e2cf22fe8ab15e1922b79ed4e7a8db53c)

Conflicts:
	doc/openocd.texi
ft2232: Add Digilent HS2 support to ft2232 interface

Part of fix for STAR 9000606651.

Signed-off-by: Anton Kolesov <anton.kolesov@synopsys.com>
(cherry picked from commit d5f5289e8197d8a343500bbd841fc85521c91b12)
ARC: Remove claims that we don't support HS2

Signed-off-by: Anton Kolesov <anton.kolesov@synopsys.com>
ARC: Remove JTAG test function

This is a custom function that seems to be redundant nowdays as it
doesn't server any purpose from user-perspective.

Signed-off-by: Anton Kolesov <anton.kolesov@synopsys.com>
(cherry picked from commit d239d49ac565be0ca2604aec199ec3bf5afcb2fd)

Conflicts:
	src/target/arc_jtag.c
	src/target/arc_mntr.c
ARC: Optimize JTAG layer

OpenOCD used to be painfully slow when communicating with ARC. This was
caused by two reasons.

1) Functions to write memory used to ignore JTAG write_bulk functions
and were writing 4-bytes one by one. This was mostly affecting GDB's
"load" command, as in other cases writes are usually limited to 4 bytes.
This was increasing amount of JTAG traffic dramatically for "load".

2) Main reason that was affecting every GDB command, was that our JTAG
interface used to execute queue of JTAG commands after adding each
command to the queue. Bonus of that is that if there is an error then it
is clear what caused it, however the performance price was just too big.
Constant flushing of command queue causes unnecessary communication over
USB with the debug cable, instead of small amount of big packets, our
JTAG layer used to send hordes of small ones. USB is quite terrible at
small packets, so bigger packets are better. In fact much-much better.
As a consequence OpenOCD was spending most of the execution time waiting
for USB packets to travel between debug host and debug cable.

To fix this internal functions that are called by high-level JTAG
functions should not execute queue, they should just add commands to the
queue. Execution of queue is performed once per high-level function, at
the end. In case if write operations this is a "enqueue and forget"
approach, as no response is expected. It is a bit more complex in case
of reading, as the data returned from target should be parsed
appropriately. This can be done only after queue execution. So for
example to read registers, first it is required to add commands to
queue, then execute, then convert returned data to host representation.

I've also change API of JTAG layer significantly. Now "bulk" functions
are first-class citizens and the only choice for memory and code
register operations. Functions for AUX registers provide small
convenience wrapper to deal with operations on one register, which are
common throughout ARC OpenOCD code. In other cases if caller wants to
operate on one register/memory word, it should call function with
"count" equal to 1.

Functions for memory and core register support only sequential
addresses, if sequence is broken, two calls are required. AUX registers
functions accept an array of addresses to operate on, thus allowing to
deal with all AUX registers in one call, at the price of more complex
function API. This wasn't applied to memory and core register functions
because non-sequential request there are less common and simpler API was
chosen. This might change for core registers with the advent of proper
support for extension core registers and reduced core register set.

JTAG layer is the lowest level of ARC stack in OpenOCD and I've tried to
make it already acceptable for upstreaming.

Some numbers on performance:

1) Small application debugged with following sequence of GDB commands:
load, b main, b exit, si, c, s, c. Before patch this test was taking
around 20 seconds to finish, after the patch it takes around 1 seconds
(floats between 0.8-1.3 seconds).

2) Test suite consisting of 20 small application, was taking around 8:30
minutes to finish, but after the patch it reduced to 40 seconds.
Interesting that before patch OpenOCD used to spent 40 second in kernel
mode (probably cooking USB packets), while after the patch this time
reduced to 2.5 seconds.

Signed-off-by: Anton Kolesov <anton.kolesov@synopsys.com>
(cherry picked from commit 6441e34b2c3f0b8d635356f9373ba381a02b3ad6)

Conflicts:
	src/target/arc32.c
	src/target/arc_dbg.c
	src/target/arc_jtag.c
	src/target/arc_mntr.c
	src/target/arc_ocd.c
	src/target/arc_regs.c
ARC: Do not print JTAG STATUS register each time

It appeared to be a poor decision to print values of JTAG status
register each time after retrieving it, because it is retrieved
constantly in poll() and debug log was floodede with those messages.
This patch removes those annoying messages.

Signed-off-by: Anton Kolesov <anton.kolesov@synopsys.com>
(cherry picked from commit b622e54d4f9e349125f0381d6a332e31872b1f1d)