E.Noorlander/Cmake_C_Project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Start point

Browse Source
This commit is contained in:
Edwin Noorlander
2025-02-19 16:17:08 +01:00
commit 8bc6932e36
223 changed files with 63668 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
lib/libftdi/.gitignore vendored Normal file
View File

@@ -0,0 +1,51 @@
# Normal stuff
*.o
*.a
*.so
*.lo
*.la
*.pc
.deps/
.libs/
.kdev4/
build/
# kdevelop
*.kdevelop.pcs
*.kdevses
# Doxygen documentation
Doxyfile
doc/Doxyfile
doc/html
doc/man
# examples
examples/baud_test
examples/bitbang
examples/bitbang2
examples/bitbang_cbus
examples/bitbang_ft2232
examples/find_all
examples/find_all_pp
examples/serial_test
examples/simple
# Backup files and stuff from patches
*.orig
*.rej
*~
.*.swp
# libftdi specific
libftdi-config
libftdi.spec
# CMake
CMakeCache.txt
cmake_install.cmake
CMakeFiles
# Misc. binaries
*.dylib
opt

47
lib/libftdi/AUTHORS Normal file
View File

@@ -0,0 +1,47 @@
Main developers:
Intra2net AG <opensource@intra2net.com>
Contributors in alphabetical order,
see Changelog for full details:
Alain Abbas <aa@libertech.fr>
Alex Harford <harford@gmail.com>
Anders Larsen <al@alarsen.net>
Andrew John Rogers <andrew@rogerstech.co.uk>
Arnim Läuger <arnim.laeuger@gmx.net>
Aurelien Jarno <aurelien@aurel32.net>
Chris Zeh <chris.w.zeh@gmail.com>
Clifford Wolf <clifford@clifford.at>
Daniel Kirkham <d.kirkham@telstra.com>
David Challis <dchallis@qsimaging.com>
Emil <emil@datel.co.uk>
Evan Nemerson <evan@coeus-group.com>
Evgeny Sinelnikov <sin@geoft.ru>
Ian Abbott <abbotti@mev.co.uk>
Jean-Daniel Merkli <jdmerkli@computerscience.ch>
Juergen Beisert <juergen.beisert@weihenstephan.org>
Lorenz Moesenlechner <lorenz@hcilab.org>
Mark Hämmerling <mail@markh.de>
Marek Vavruša <marek@vavrusa.com>
Marius Kintel <kintel@sim.no>
Matthias Kranz <matthias@hcilab.org>
Matthias Richter <mail.to.mr@gmx.de>
Matthijs ten Berge <m.h.tenberge@alumnus.utwente.nl>
Max <max@koeln.ccc.de>
Michel Zou <xantares09@hotmail.com>
Mike Frysinger <vapier.adi@gmail.com>
Nathan Fraser <ndf@undershorts.org>
Oleg Seiljus <oseiljus@xverve.com>
Peter Holik <peter@holik.at>
Rogier Wolff <R.E.Wolff@harddisk-recovery.nl>
Steven Turner <steven.turner@ftdichip.com>
Tarek Heiland <tarek@illimitable.com>
Thimo Eichstaedt <abc@digithi.de>
Thomas Fischl <fischl@fundf.net>
Tim Ansell <mithro@mithis.com>
Tom Saunders <trsaunders@gmail.com>
Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>
Vladimir Yakovlev <nagos@inbox.ru>
Wilfried Holzke <libftdi@holzke.net>
Yi-Shin Li <ysli@araisrobo.com>

180
lib/libftdi/CMakeLists.txt Normal file
View File

@@ -0,0 +1,180 @@
# Project
project(libftdi)
set(MAJOR_VERSION 1)
set(MINOR_VERSION 0)
set(VERSION_STRING ${MAJOR_VERSION}.${MINOR_VERSION})
SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}")
# CMake
if("${CMAKE_BUILD_TYPE}" STREQUAL "")
set(CMAKE_BUILD_TYPE Debug)
endif("${CMAKE_BUILD_TYPE}" STREQUAL "")
set(CMAKE_COLOR_MAKEFILE ON)
cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
add_definitions(-Wall)
# Debug build
message("-- Build type: ${CMAKE_BUILD_TYPE}")
if(${CMAKE_BUILD_TYPE} STREQUAL Debug)
add_definitions(-DDEBUG)
endif(${CMAKE_BUILD_TYPE} STREQUAL Debug)
FIND_PACKAGE(USB1 REQUIRED)
INCLUDE_DIRECTORIES(${LIBUSB_INCLUDE_DIR})
# Find Boost (optional package)
find_package(Boost)
# Set components
set(CPACK_COMPONENTS_ALL sharedlibs staticlibs headers)
set(CPACK_COMPONENT_SHAREDLIBS_DISPLAY_NAME "Shared libraries")
set(CPACK_COMPONENT_STATICLIBS_DISPLAY_NAME "Static libraries")
set(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ Headers")
set(CPACK_COMPONENT_SHAREDLIBS_DESCRIPTION
"Shared library for general use.")
set(CPACK_COMPONENT_STATICLIBS_DESCRIPTION
"Static library, good if you want to embed libftdi in your application.")
set(CPACK_COMPONENT_HEADERS_DESCRIPTION
"C/C++ header files.")
set(CPACK_COMPONENT_SHAREDLIBS_GROUP "Development")
set(CPACK_COMPONENT_STATICLIBS_GROUP "Development")
set(CPACK_COMPONENT_HEADERS_GROUP "Development")
# automatically set lib suffix
if ( UNIX AND NOT APPLE AND NOT CMAKE_CROSSCOMPILING AND NOT EXISTS "/etc/debian_version" )
if ( CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT LIB_SUFFIX )
set ( LIB_SUFFIX 64 )
endif ()
endif ()
if(NOT APPLE)
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
SET(PACK_ARCH "")
else(CMAKE_SIZEOF_VOID_P EQUAL 8)
SET(PACK_ARCH .x86_64)
endif(CMAKE_SIZEOF_VOID_P EQUAL 4)
else(NOT APPLE)
SET(PACK_ARCH "")
endif(NOT APPLE)
# Package information
set(CPACK_PACKAGE_VERSION ${VERSION_STRING})
set(CPACK_PACKAGE_CONTACT "Intra2net AG <libftdi@developer.intra2net.com>")
set(CPACK_PACKAGE_DESCRIPTION "libftdi library.")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY ${CPACK_PACKAGE_DESCRIPTION}
)
# Package settings
if(${UNIX})
set(CPACK_GENERATOR "DEB;RPM")
set(CPACK_CMAKE_GENERATOR "Unix Makefiles")
set(CPACK_PACKAGE_NAME ${PROJECT_NAME})
set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}${PACK_ARCH})
endif(${UNIX})
if(${WIN32})
set(CPACK_GENERATOR "NSIS")
set(CPACK_CMAKE_GENERATOR "MinGW Makefiles")
set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
set(CPACK_PACKAGE_VENDOR "")
set(CPACK_PACKAGE_INSTALL_DIRECTORY "libftdi")
set(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${VERSION_STRING}-win32")
set(CPACK_NSIS_DISPLAY_NAME "libftdi")
set(CPACK_NSIS_MODIFY_PATH "ON")
endif(${WIN32})
set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/LICENSE)
set(CPACK_SOURCE_GENERATOR TGZ)
set(CPACK_SOURCE_IGNORE_FILES "\\\\.git")
set(CPACK_SOURCE_PACKAGE_FILE_NAME ${CPACK_PACKAGE_FILE_NAME})
# Subdirectories
if(${UNIX})
set(CPACK_SET_DESTDIR "ON")
endif(${UNIX})
add_subdirectory(src)
add_subdirectory(ftdipp)
add_subdirectory(bindings)
add_subdirectory(ftdi_eeprom)
add_subdirectory(examples)
add_subdirectory(packages)
add_subdirectory(test)
# "make dist" target
set(ARCHIVE_NAME ${CMAKE_PROJECT_NAME}-${VERSION_STRING})
add_custom_target(dist
COMMAND git archive --prefix=${ARCHIVE_NAME}/ HEAD
| bzip2 > ${CMAKE_BINARY_DIR}/${ARCHIVE_NAME}.tar.bz2
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
# Documentation
option(DOCUMENTATION "Generate API documentation with Doxygen" ON)
find_package(Doxygen)
if(DOCUMENTATION AND DOXYGEN_FOUND)
# Set variables
set(PACKAGE libftdi)
set(VERSION ${VERSION_STRING})
set(top_srcdir ${CMAKE_SOURCE_DIR})
# Find doxy config
message(STATUS "Doxygen found.")
set(DOXY_DIR "${CMAKE_SOURCE_DIR}/doc")
set(DOXY_CONFIG "${DOXY_DIR}/Doxyfile.in")
# Copy doxy.config.in
configure_file("${DOXY_CONFIG}" "${CMAKE_BINARY_DIR}/doxy.config")
# Create doc directory
add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/doc
COMMAND rm -rf ${CMAKE_BINARY_DIR}/doc/{html,man}
COMMAND mkdir -p ${CMAKE_BINARY_DIR}/doc
DEPENDS ftdi ftdipp
)
# Run doxygen
add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/doc/html/index.html
COMMAND ${DOXYGEN_EXECUTABLE} "${CMAKE_BINARY_DIR}/doxy.config"
DEPENDS "${CMAKE_BINARY_DIR}/doxy.config" "${CMAKE_BINARY_DIR}/doc"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/doc
)
add_custom_target(docs ALL DEPENDS ${CMAKE_BINARY_DIR}/doc/html/index.html)
message(STATUS "Generating API documentation with Doxygen")
else(DOCUMENTATION AND DOXYGEN_FOUND)
message(STATUS "Not generating API documentation")
endif(DOCUMENTATION AND DOXYGEN_FOUND)
# PkgConfig
set(prefix ${CMAKE_INSTALL_PREFIX})
set(exec_prefix ${CMAKE_INSTALL_PREFIX}/bin)
set(includedir ${CMAKE_INSTALL_PREFIX}/include/${PROJECT_NAME})
if(${UNIX})
set(libdir ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX})
endif(${UNIX})
if(${WIN32})
set(libdir ${CMAKE_INSTALL_PREFIX}/bin)
endif(${WIN32})
configure_file(${CMAKE_SOURCE_DIR}/libftdi.pc.in ${CMAKE_BINARY_DIR}/libftdi.pc @ONLY)
configure_file(${CMAKE_SOURCE_DIR}/libftdipp.pc.in ${CMAKE_BINARY_DIR}/libftdipp.pc @ONLY)
install(FILES ${CMAKE_BINARY_DIR}/libftdi.pc ${CMAKE_BINARY_DIR}/libftdipp.pc
DESTINATION lib${LIB_SUFFIX}/pkgconfig)
if(${UNIX})
configure_file(${CMAKE_SOURCE_DIR}/libftdi-config.in ${CMAKE_BINARY_DIR}/libftdi-config @ONLY)
install(PROGRAMS ${CMAKE_BINARY_DIR}/libftdi-config DESTINATION bin)
endif(${UNIX})
include(CPack)

22
lib/libftdi/COPYING-CMAKE-SCRIPTS Normal file
View File

@@ -0,0 +1,22 @@
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

339
lib/libftdi/COPYING.GPL Normal file
View File

@@ -0,0 +1,339 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License.

481
lib/libftdi/COPYING.LIB Normal file
View File

@@ -0,0 +1,481 @@
GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1991 Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
c) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
d) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

144
lib/libftdi/ChangeLog Normal file
View File

@@ -0,0 +1,144 @@
New in 0.17 - 2009-12-19
------------------------
* C++ wrapper: Reduced code duplication and small other changes (Intra2net)
* Deprecated old ftdi_enable_bitbang() function (Intra2net)
* New ftdi_usb_open_desc_index() function (Intra2net)
* Added baud rate test example code (Intra2net)
* New serial input example code (Jim Paris)
* Fix modem status byte filtering for USB high speed chips (Intra2net and Jim Paris)
* Add bitmode for synchronous fifo in FT2232H (Uwe Bonnes)
* Fix usb_set_configuration() call on Windows 64 (NIL)
* Fix usb index in ftdi_convert_baudrate() for FT2232H/FT4232H chips (Thimo Eichstaedt)
* Set initial baudrate on correct interface instead of always the first one (Thimo Eichstaedt)
* Call usb_set_configuration() on Windows only (Uwe Bonnes)
* 64 bit and other buildsystem fixes (Uwe Bonnes)
* Don't build --with-async-mode w/ libusb-compat-0.1 (Clifford Wolf)
* Functions for read/write of a single eeprom location (Oleg Seiljus)
* Protect against double close of usb device (Nathan Fraser)
* Fix out-of-tree-build in python wrapper (Aurelien Jarno)
* Autoconf and doxygen cleanup (Jim Paris)
New in 0.16 - 2009-05-08
------------------------
* C++ wrapper: Reopen the device after calling get_strings() in Context::open() (Marek Vavruša and Intra2net)
* C++ wrapper: Fixed an inheritance problem (Marek Vavruša and Intra2net)
* C++ wrapper: Relicensed under GPLv2 + linking exception (Marek Vavruša and Intra2net)
* Support for FT2232H and FT4232H (David Challis, Alex Harford and Intra2net)
* Support for mingw cross compile (Uwe Bonnes)
* Python bindings and minor autoconf cleanup (Tarek Heiland)
* Code cleanup in various places (Intra2net)
* Fixed ftdi_read_chipid in some cases (Matthias Richter)
* eeprom decode function and small cleanups (Marius Kintel)
* cmake system improvements (Marius Kintel and Intra2net)
* Fix compilation in -ansi -pedantic mode (Matthias Janke)
New in 0.15 - 2008-12-19
------------------------
* Full C++ wrapper. Needs boost (Marek Vavruša and Intra2net)
* cmake rules (Marek Vavruša)
New in 0.14 - 2008-09-09
------------------------
* Fixed flow control code for second FT2232 interface (Marek Vavruša)
* Ability to set flow control via one USB call (Marek Vavruša)
* 64 bit build support in the RPM spec file (Uwe Bonnes)
* Small fix to the RPM spec file (Uwe Bonnes)
* Ability to set RS232 break type (Intra2net)
* Grouped flow control and modem status code together (Intra2net)
New in 0.13 - 2008-06-13
------------------------
* Build .spec file via configure.in (Intra2net)
* Fixed "libusb-config --cflags" call (Mike Frysinger and Intra2net)
* Always set usb configuration (Mike Frysinger and Intra2net)
* Improved libusb-win32 support (Mike Frysinger)
New in 0.12 - 2008-04-16
------------------------
* Fix build of documentation for "out of tree" builds
* Fix USB config descriptor in the eeprom (Juergen Beisert)
* Ability to purge RX/TX buffers separately (Arnim Läuger)
* Setting of event and error character (Arnim Läuger)
* Poll modem status function (Arnim Läuger and Intra2net)
* Updated documentation and created AUTHORS file
New in 0.11 - 2008-03-01
------------------------
* Vala bindings helper functions (ftdi_new, ftdi_free, ftdi_list_free2) (Even Nermerson)
* Support for different EEPROM sizes (Andrew John Rogers, andrew@rogerstech.co.uk)
* Async write support. Linux only and no error handling.
You have to enable it via --with-async-mode.
* Detection of R-type chips
* FTDIChip-ID read support (Peter Holik)
New in 0.10 - 2007-05-08
------------------------
* Examples for libftdi_usb_find_all and CBUS mode
* Fixed ftdi_list_free
* Small cosmetic changes
New in 0.9 - 2007-02-09
-----------------------
* Fixed build without doxygen
* Correct .so file library version
New in 0.8 - 2007-02-08
-----------------------
* Complete doxygen documentation and examples
* Extended FT2232C bitbang mode example code (Max)
* ftdi_usb_get_strings function to get device ID strings (Matthijs ten Berge)
* Fix ftdi_read_pins on PowerPC systems (Thomas Fischl)
* Automatically detach ftdi_sio kernel driver (Uwe Bonnes and Intra2net)
* Configurable flow control (Lorenz Moesenlechner and Matthias Kranz)
New in 0.7 - 2005-10-11
-----------------------
* Baudrate calculation fix for FT2232C (Steven Turner/FTDI)
* Find all devices by vendor/product id (Tim Ansell and Intra2net)
* Documentation updates (Tim Ansell)
New in 0.6 - 2005-04-24
-----------------------
* Set library version on .so file again
* Configurable serial line parameters (Alain Abbas)
* Improved filtering of status bytes (Evgeny Sinelnikov)
* Extended FT2232C support (Uwe Bonnes)
* Small improvement to the baudrate calculation code (Emil)
* Error handling cleanup (Rogier Wolff and Intra2net)
New in 0.5 - 2004-09-24
-----------------------
* New autoconf suite
* pkgconfig support
* Status byte filtering now works for "big" readbuffer sizes (Thanks Evgeny!)
* Open device by description and/or serial (Evgeny Sinelnikov)
* Improved error handling (Evgeny Sinelnikov)
New in 0.4 - 2004-06-15
-----------------------
* Fixed filtering of status bytes (Readbuffer size is now 64 bytes)
* FT2232C support (Steven Turner/FTDI)
* New baudrate calculation code (Ian Abbott)
* Automatic detection of chip type
* Important: ftdi_write_data now returns the bytes written
* Fixed defaults values in ftdi_eeprom_initdefaults (Jean-Daniel Merkli)
* Reset internal readbuffer offsets for reset()/purge_buffers()
* Small typo fixes (Mark Haemmerling)
New in 0.3 - 2004-03-25
-----------------------
* Improved read function which takes arbitrary input buffer sizes
Attention: Call ftdi_deinit() on exit to free used memory
* Vastly increased read/write performance (configurable chunksize, default is 4096)
* Set/get latency timer function working (Thanks Steven Turner/FTDI)
* Increased library version because the changes require recompilation
New in 0.2 - 2004-01-03
-----------------------
* EEPROM build fix by Daniel Kirkham (Melbourne, Australia)
* Implemented basic ftdi_read_data() function
* EEPROM write fixes
New in 0.1 - 2003-06-10
-----------------------
* First public release

38
lib/libftdi/FindUSB1.cmake Normal file
View File

@@ -0,0 +1,38 @@
# - Try to find the freetype library
# Once done this defines
#
# LIBUSB_FOUND - system has libusb
# LIBUSB_INCLUDE_DIR - the libusb include directory
# LIBUSB_LIBRARIES - Link these to use libusb
# Copyright (c) 2006, 2008 Laurent Montel, <montel@kde.org>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
if (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
# in cache already
set(LIBUSB_FOUND TRUE)
else (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
IF (NOT WIN32)
# use pkg-config to get the directories and then use these values
# in the FIND_PATH() and FIND_LIBRARY() calls
find_package(PkgConfig)
pkg_check_modules(PC_LIBUSB libusb-1.0)
ENDIF(NOT WIN32)
FIND_PATH(LIBUSB_INCLUDE_DIR libusb.h
PATHS ${PC_LIBUSB_INCLUDEDIR} ${PC_LIBUSB_INCLUDE_DIRS})
FIND_LIBRARY(LIBUSB_LIBRARIES NAMES usb-1.0
PATHS ${PC_LIBUSB_LIBDIR} ${PC_LIBUSB_LIBRARY_DIRS})
include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBUSB DEFAULT_MSG LIBUSB_LIBRARIES LIBUSB_INCLUDE_DIR)
MARK_AS_ADVANCED(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARIES)
endif (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)

25
lib/libftdi/LICENSE Normal file
View File

@@ -0,0 +1,25 @@
The C library "libftdi" is distributed under the
GNU Library General Public License version 2.
A copy of the GNU Library General Public License (LGPL) is included
in this distribution, in the file COPYING.LIB.
----------------------------------------------------------------------
The C++ wrapper "ftdipp" is distributed under the GNU General
Public License version 2 (with a special exception described below).
A copy of the GNU General Public License (GPL) is included
in this distribution, in the file COPYING.GPL.
As a special exception, if other files instantiate templates or use macros
or inline functions from this file, or you compile this file and link it
with other works to produce a work based on this file, this file
does not by itself cause the resulting work to be covered
by the GNU General Public License.
However the source code for this file must still be made available
in accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work based
on this file might be covered by the GNU General Public License.

26
lib/libftdi/README Normal file
View File

@@ -0,0 +1,26 @@
--------------------------------------------------------------------
libftdi version 0.99
--------------------------------------------------------------------
libftdi - A library (using libusb) to talk to FTDI's UART/FIFO chips
including the popular bitbang mode.
The following chips are supported:
- FT4232H / FT2232H
- FT232R / FT245R
- FT2232L / FT2232D / FT2232C
- FT232BM / FT245BM (and the BL/BQ variants)
- FT8U232AM / FT8U245AM
The AUTHORS file contains a list of all the people
that made libftdi possible what it is today.
Changes
-------
You'll find the newest version of libftdi at:
http://www.intra2net.com/en/developer/libftdi
--------------------------------------------------------------------
www.intra2net.com 2003-201x Intra2net AG
--------------------------------------------------------------------

11
lib/libftdi/README.mingw Normal file
View File

@@ -0,0 +1,11 @@
To crosscompile for Win32 with mingw
- Get and build libusb-win32-src-x.tar.gz from Sourceforge
Version was "libusb-win32-src-0.1.12.1.tar.gz" for April 4, 2009
- Compile like "make host_prefix=i386-mingw32msvc all". Your prefixes may vary.
- Copy src/usb.h to /opt/cross/i386-mingw32msvc/include/
- Copy *.a to /opt/cross/i386-mingw32msvc/lib/
- Create a build directory like "mkdir build-win32", e.g in ../libftdi/
- cd in that directory and run
"cmake -DCMAKE_TOOLCHAIN_FILE=../Toolchain-mingw32.cmake .."
- Copy src/ftdi.h to /opt/cross/i386-mingw32msvc/include/
- Copy build-win32/src/*.a to /opt/cross/i386-mingw32msvc/lib/

16
lib/libftdi/TODO Normal file
View File

@@ -0,0 +1,16 @@
*** TODO for 1.0 release ***
Build related:
- Rename the library and header file,
so libftdi 0.x and 1.x can co-exist
API extentions:
- TO DECIDE: Make ftdi structure opaque?
Misc:
- Resolve TODO entries in ftdi_eeprom
- Look into merging ftdi_eeprom and examples/eeprom
Documentation:
- Mention libusb-1.0 dependency
- Comparison between 1.0 and 0.19
- Document the new EEPROM function

4
lib/libftdi/Toolchain-Crossbuild32.cmake Normal file
View File

@@ -0,0 +1,4 @@
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_C_COMPILER gcc -m32)
set(CMAKE_CXX_COMPILER g++ -m32)
set(CMAKE_FIND_ROOT_PATH /usr/lib)

16
lib/libftdi/Toolchain-mingw32.cmake Normal file
View File

@@ -0,0 +1,16 @@
# the name of the target operating system
SET(CMAKE_SYSTEM_NAME Windows)
# which compilers to use for C and C++
SET(CMAKE_C_COMPILER i386-mingw32msvc-gcc)
SET(CMAKE_CXX_COMPILER i386-mingw32msvc-g++)
# here is the target environment located
SET(CMAKE_FIND_ROOT_PATH /opt/cross/i386-mingw32msvc )
# adjust the default behaviour of the FIND_XXX() commands:
# search headers and libraries in the target environment, search
# programs in the host environment
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

28
lib/libftdi/bindings/CMakeLists.txt Normal file
View File

@@ -0,0 +1,28 @@
include(FindSWIG)
include(FindPythonLibs)
include(FindPythonInterp)
include(UseSWIG)
option(PYTHON_BINDINGS "Build python bindings via swig" ON)
if(PYTHON_BINDINGS AND SWIG_FOUND AND PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/src)
INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH})
LINK_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/../src)
SWIG_ADD_MODULE(ftdi python ftdi.i)
SWIG_LINK_LIBRARIES(ftdi ftdi ${PYTHON_LIBRARIES})
execute_process ( COMMAND ${PYTHON_EXECUTABLE} -c "import sys; print '%d.%d' % ( sys.version_info[0], sys.version_info[1] )"
OUTPUT_VARIABLE PYTHON_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE )
set ( SITEPACKAGE lib${LIB_SUFFIX}/python${PYTHON_VERSION}/site-packages )
INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/_ftdi.so DESTINATION ${SITEPACKAGE})
INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/ftdi.py DESTINATION ${SITEPACKAGE})
message(STATUS "Building python bindings via swig. Will be installed under ${CMAKE_INSTALL_PREFIX}/${SITEPACKAGE}")
else(PYTHON_BINDINGS AND SWIG_FOUND AND PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)
message(STATUS "Not building python bindings")
endif(PYTHON_BINDINGS AND SWIG_FOUND AND PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND)

88
lib/libftdi/bindings/ftdi.i Normal file
View File

@@ -0,0 +1,88 @@
/* File: ftdi.i */
%module(docstring="Python interface to libftdi") ftdi
%include <typemaps.i>
%include <cstring.i>
%typemap(in) unsigned char* = char*;
%ignore ftdi_write_data_async;
%ignore ftdi_async_complete;
%immutable ftdi_version_info::version_str;
%immutable ftdi_version_info::snapshot_str;
%rename("%(strip:[ftdi_])s") "";
%newobject ftdi_new;
%typemap(newfree) struct ftdi_context *ftdi "ftdi_free($1);";
%delobject ftdi_free;
%typemap(in,numinputs=0) SWIGTYPE** OUTPUT ($*ltype temp) %{ $1 = &temp; %}
%typemap(argout) SWIGTYPE** OUTPUT %{ $result = SWIG_Python_AppendOutput($result, SWIG_NewPointerObj((void*)*$1,$*descriptor,0)); %}
%apply SWIGTYPE** OUTPUT { struct ftdi_device_list **devlist };
int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist,
int vendor, int product);
%clear struct ftdi_device_list **devlist;
%apply char *OUTPUT { char * manufacturer, char * description, char * serial };
%cstring_bounded_output( char * manufacturer, 256 );
%cstring_bounded_output( char * description, 256 );
%cstring_bounded_output( char * serial, 256 );
%typemap(default,noblock=1) int mnf_len, int desc_len, int serial_len { $1 = 256; }
int ftdi_usb_get_strings(struct ftdi_context *ftdi, struct libusb_device *dev,
char * manufacturer, int mnf_len,
char * description, int desc_len,
char * serial, int serial_len);
%clear char * manufacturer, char * description, char * serial;
%clear int mnf_len, int desc_len, int serial_len;
%typemap(in,numinputs=1) (unsigned char *buf, int size) %{ $2 = PyInt_AsLong($input);$1 = (unsigned char*)malloc($2*sizeof(char)); %}
%typemap(argout) (unsigned char *buf, int size) %{ if(result<0) $2=0; $result = SWIG_Python_AppendOutput($result, PyString_FromStringAndSize((char*)$1, $2)); free($1); %}
int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size);
%clear (unsigned char *buf, int size);
%apply int *OUTPUT { unsigned int *chunksize };
int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize);
int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize);
%clear unsigned int *chunksize;
%apply char *OUTPUT { unsigned char *pins };
int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins);
%clear unsigned char *pins;
%apply char *OUTPUT { unsigned char *latency };
int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency);
%clear unsigned char *latency;
%apply short *OUTPUT { unsigned short *status };
int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status);
%clear unsigned short *status;
%apply int *OUTPUT { int* value };
int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value);
%clear int* value;
%typemap(in,numinputs=1) (unsigned char *buf, int size) %{ $2 = PyInt_AsLong($input);$1 = (unsigned char*)malloc($2*sizeof(char)); %}
%typemap(argout) (unsigned char *buf, int size) %{ if(result<0) $2=0; $result = SWIG_Python_AppendOutput($result, PyString_FromStringAndSize((char*)$1, $2)); free($1); %}
int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size);
%clear (unsigned char *buf, int size);
%apply short *OUTPUT { unsigned short *eeprom_val };
int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val);
%clear unsigned short *eeprom_val;
%apply int *OUTPUT { unsigned int *chipid };
int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid);
%clear unsigned int *chipid;
%include ftdi.h
%{
#include <ftdi.h>
%}
%include ftdi_i.h
%{
#include <ftdi_i.h>
%}

1722
lib/libftdi/doc/Doxyfile.in Normal file
View File

File diff suppressed because it is too large Load Diff

109
lib/libftdi/doc/EEPROM-structure Normal file
View File

@@ -0,0 +1,109 @@
Here we try to document what we know about the EEPROM Structure.
Even with a 93xx66 EEPROM, at maximum 256 Bytes are used
All important things happen in the first
0x14(FT232/245), 0x16(FT2232CD), 0x18(FT232/245R) or 0x1a (FT2232H/4432H) bytes
Type | Use extra EEPROM space
FT2XXB | No
Byte.BIT| TYPE_AM TYPE_BM TYPE_2232C TYPE_R TYPE_2232H TYPE_4232H
00.0 | 0 0 channel_a_type channel_a_type 0
00.1 | 0 0 channel_a_type channel_a_type 0
00.2 | 0 0 channel_a_type high_current channel_a_type 0
00.3 | 0 0 channel_a_driver channel_a_driver channel_a_driver channel_a_driver
00.4 | 0 0 high_current_a 0 0 0
00.5 | 0 0 0 0 0 0
00.6 | 0 0 0 0 0 0
00.7 | 0 0 0 0 SUSPEND_DBUS7 channel_c_driver
On TYPE_R 00.3 set mean D2XX, on other devices VCP
01.0 | 0 0 channel_b_type channel_b_type 0
01.1 | 0 0 channel_b_type channel_b_type 0
01.2 | 0 0 channel_b_type 0 channel_b_type 0
01.3 | 0 0 channel_b_driver 0 channel_b_driver channel_b_driver
01.4 | 0 0 high_current_b 0 0 0
01.5 | 0 0 0 0 0 0
01.6 | 0 0 0 0 0
01.7 | 0 0 0 0 0 channel_d_driver
Fixme: Missing 4232H validation
02 | Vendor ID (VID) LSB (all)
03 | Vendor ID (VID) MSB (all)
04 | Product ID (PID) LSB (all)
05 | Product ID (PID) MSB (all)
06 | Device release number LSB (not tested on TYPE_4232H)
07 | Device release number MSB (not tested on TYPE_4232H)
|
08.4 | Battery powered
08.5 | Remote wakeup
08.6 | Self powered: 1, bus powered: 0
08.7 | Always 1
|
09 | Max power (mA/2)
|
Byte.BIT| TYPE_AM TYPE_BM TYPE_2232C TYPE_R TYPE_2232H TYPE_4232H
0a.0 | 0 IsoIn IsoIn part A 0 0 0
0a.1 | 0 IsoOut IsoOut part A 0 0 0
0a.2 | 0 suspend_pull_down suspend_pull_down suspend_pull_down suspend_pull_down
0a.3 | 0 use_serial use_serial use_serial
0a.4 | 0 change_usb_version change_usb_version
0a.5 | 0 0 IsoIn part B 0 0 0
0a.6 | 0 0 IsoOut part B 0 0 0
0a.7 | 0 - reserved
0b | TYPE_R Bitmask Invert, 0 else
Byte.BIT| TYPE_4232H
0b.4 | channel_a_rs485enable
0b.5 | channel_b_rs485enable
0b.6 | channel_c_rs485enable
0b.7 | channel_d_rs485enable
Byte | TYPE_AM TYPE_BM TYPE_2232C TYPE_R TYPE_2232H TYPE_4232H
0c | 0 USB-VER-LSB USB-VER-LSB 0 ? ?
0d | 0 USB-VER-MSB USB-VER-MSB 0 ? ?
(On several FT2232H different values were observed -> The value is unused
if change USB version is not set, so it might contain garbage)
0e | OFFSET Vendor
0f | Len VENDOR
10 | Offset Product
11 | Length Product
12 | Offset Serial
13 | Length Serial
Byte.BIT| TYPE_AM TYPE_BM TYPE_2232C TYPE_R TYPE_2232H TYPE_4232H
14.3:0 | UA UA CHIP CBUS[0] AL A
14.7:0 | UA UA CHIP CBUS[1] AH B
15.3:0 | UA UA 0 CBUS[2] BL C
15.7:0 | UA UA 0 CBUS[3] BH D
16.3:0 | UA UA UA CBUS[4] 0 0
16.7:0 | UA UA UA 0 0 0
CHIP values:
0x46: EEPROM is a 93xx46
0x56: EEPROM is a 93xx56
0x66: EEPROM is a 93xx66
17 UA UA UA 0 0 0
18 UA UA UA VENDOR CHIP CHIP
19 UA UA UA VENDOR 0 0
1a UA (all)
Additional fields after the serial string:
0x00, 0x00 - reserved for "legacy port name prefix"
0x00, 0x00 - reserved for plug and play options
(Observed values with PnP == 0:
0x02 0x03 0x01 0x00)
Note: The additional fields after the serial number string
collide with the official FTDI formula from AN_121 regarding
the start of the user area:
"Start Address = the address following the last byte of SerialNumber string."

28
lib/libftdi/doc/release-checklist.txt Normal file
View File

@@ -0,0 +1,28 @@
*** Checklist for a new libftdi release ***
- Update ChangeLog and AUTHORS via git history
- Update version number in the following files:
- CMakeLists.txt
- README
- Run "make dist"
- Diff tarball to previous version, check if all
important changes are in the ChangeLog
- Ensure all modifications are checked in
- Sign tarball, build .src.rpm and sign it, too
- Create git tag:
- git tag -s -u 24F006F5 v0.XX
- git tag -d latest-release ; git tag latest-release
- git push --tags
- Website
- Upload tarball and .src.rpm
- Add ChangeLog to main page
- Update URLs in download section
- Generate API documentation and upload it
- Announce on mailinglist & freshmeat

54
lib/libftdi/examples/CMakeLists.txt Normal file
View File

@@ -0,0 +1,54 @@
option(EXAMPLES "Build example programs" ON)
if (EXAMPLES)
# Includes
include( ${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_BINARY_DIR}
)
message(STATUS "Building example programs.")
# Source includes
include_directories(BEFORE ${CMAKE_SOURCE_DIR}/src)
# Targets
add_executable(simple simple.c)
add_executable(bitbang bitbang.c)
add_executable(bitbang2 bitbang2.c)
add_executable(bitbang_cbus bitbang_cbus.c)
add_executable(bitbang_ft2232 bitbang_ft2232.c)
add_executable(find_all find_all.c)
add_executable(serial_test serial_test.c)
add_executable(baud_test baud_test.c)
add_executable(stream_test stream_test.c)
add_executable(eeprom eeprom.c)
# Linkage
target_link_libraries(simple ftdi)
target_link_libraries(bitbang ftdi)
target_link_libraries(bitbang2 ftdi)
target_link_libraries(bitbang_cbus ftdi)
target_link_libraries(bitbang_ft2232 ftdi)
target_link_libraries(find_all ftdi)
target_link_libraries(serial_test ftdi)
target_link_libraries(baud_test ftdi)
target_link_libraries(stream_test ftdi)
target_link_libraries(eeprom ftdi)
# libftdi++ examples
if(FTDI_BUILD_CPP)
if(Boost_FOUND)
message(STATUS "Building libftdi++ examples.")
include_directories(BEFORE ${CMAKE_SOURCE_DIR}/ftdipp
${Boost_INCLUDE_DIRS})
# Target
add_executable(find_all_pp find_all_pp.cpp)
# Linkage
target_link_libraries(find_all_pp ftdipp)
endif(Boost_FOUND)
endif(FTDI_BUILD_CPP)
else(EXAMPLES)
message(STATUS "Not building example programs.")
endif(EXAMPLES)

224
lib/libftdi/examples/baud_test.c Normal file
View File

@@ -0,0 +1,224 @@
/* baud_test.c
*
* test setting the baudrate and compare it with the expected runtime
*
* options:
* -p <devicestring> defaults to "i:0x0403:0x6001" (this is the first FT232R with default id)
* d:<devicenode> path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/)
* i:<vendor>:<product> first device with given vendor and product id,
* ids can be decimal, octal (preceded by "0") or hex (preceded by "0x")
* i:<vendor>:<product>:<index> as above with index being the number of the device (starting with 0)
* if there are more than one
* s:<vendor>:<product>:<serial> first device with given vendor id, product id and serial string
* -d <datasize to send in bytes>
* -b <baudrate> (divides by 16 if bitbang as taken from the ftdi datasheets)
* -m <mode to use> r: serial a: async bitbang s:sync bitbang
* -c <chunksize>
*
* (C) 2009 by Gerd v. Egidy <gerd.von.egidy@intra2net.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ftdi.h>
double get_prec_time()
{
struct timeval tv;
double res;
gettimeofday(&tv,NULL);
res=tv.tv_sec;
res+=((double)tv.tv_usec/1000000);
return res;
}
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
int i, t;
unsigned char *txbuf;
unsigned char *rxbuf;
double start, duration, plan;
int retval= 0;
// default values
int baud=9600;
int set_baud;
int datasize=100000;
char default_devicedesc[] = "i:0x0403:0x6001";
char *devicedesc=default_devicedesc;
int txchunksize=256;
enum ftdi_mpsse_mode test_mode=BITMODE_BITBANG;
while ((t = getopt (argc, argv, "b:d:p:m:c:")) != -1)
{
switch (t)
{
case 'd':
datasize = atoi (optarg);
break;
case 'm':
switch (*optarg)
{
case 'r':
// serial
test_mode=BITMODE_RESET;
break;
case 'a':
// async
test_mode=BITMODE_BITBANG;
break;
case 's':
// sync
test_mode=BITMODE_SYNCBB;
break;
}
break;
case 'b':
baud = atoi (optarg);
break;
case 'p':
devicedesc=optarg;
break;
case 'c':
txchunksize = atoi (optarg);
break;
}
}
txbuf=malloc(txchunksize);
rxbuf=malloc(txchunksize);
if (txbuf == NULL || rxbuf == NULL)
{
fprintf(stderr, "can't malloc\n");
return EXIT_FAILURE;
}
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
retval = EXIT_FAILURE;
goto done;
}
if (ftdi_usb_open_string(ftdi, devicedesc) < 0)
{
fprintf(stderr,"Can't open ftdi device: %s\n",ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_deinit;
}
set_baud=baud;
if (test_mode!=BITMODE_RESET)
{
// we do bitbang, so real baudrate / 16
set_baud=baud/16;
}
ftdi_set_baudrate(ftdi,set_baud);
printf("real baudrate used: %d\n",(test_mode==BITMODE_RESET) ? ftdi->baudrate : ftdi->baudrate*16);
if (ftdi_set_bitmode(ftdi, 0xFF,test_mode) < 0)
{
fprintf(stderr,"Can't set mode: %s\n",ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_close;
}
if (test_mode==BITMODE_RESET)
{
// serial 8N1: 8 data bits, 1 startbit, 1 stopbit
plan=((double)(datasize*10))/baud;
}
else
{
// bitbang means 8 bits at once
plan=((double)datasize)/baud;
}
printf("this test should take %.2f seconds\n",plan);
// prepare data to send: 0 and 1 bits alternating (except for serial start/stopbit):
// maybe someone wants to look at this with a scope or logic analyzer
for (i=0; i<txchunksize; i++)
{
if (test_mode==BITMODE_RESET)
txbuf[i]=0xAA;
else
txbuf[i]=(i%2) ? 0xff : 0;
}
if (ftdi_write_data_set_chunksize(ftdi, txchunksize) < 0 ||
ftdi_read_data_set_chunksize(ftdi, txchunksize) < 0)
{
fprintf(stderr,"Can't set chunksize: %s\n",ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_close;
}
if (test_mode==BITMODE_SYNCBB)
{
// completely clear the receive buffer before beginning
while (ftdi_read_data(ftdi, rxbuf, txchunksize)>0);
}
start=get_prec_time();
// don't wait for more data to arrive, take what we get and keep on sending
// yes, we really would like to have libusb 1.0+ with async read/write...
ftdi->usb_read_timeout=1;
i=0;
while (i < datasize)
{
int sendsize=txchunksize;
if (i+sendsize > datasize)
sendsize=datasize-i;
if ((sendsize=ftdi_write_data(ftdi, txbuf, sendsize)) < 0)
{
fprintf(stderr,"write failed at %d: %s\n",
i, ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_close;
}
i+=sendsize;
if (test_mode==BITMODE_SYNCBB)
{
// read the same amount of data as sent
ftdi_read_data(ftdi, rxbuf, sendsize);
}
}
duration=get_prec_time()-start;
printf("and took %.4f seconds, this is %.0f baud or factor %.3f\n",duration,(plan*baud)/duration,plan/duration);
do_close:
ftdi_usb_close(ftdi);
do_deinit:
ftdi_free(ftdi);
done:
if(rxbuf)
free(rxbuf);
if(txbuf)
free(txbuf);
exit (retval);
}

87
lib/libftdi/examples/bitbang.c Normal file
View File

@@ -0,0 +1,87 @@
/* This program is distributed under the GPL, version 2 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#ifdef __WIN32__
#define sleep(x) Sleep(x)
#endif
#include <ftdi.h>
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
int f,i;
unsigned char buf[1];
int retval = 0;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
retval = 1;
goto done;
}
printf("ftdi open succeeded: %d\n",f);
printf("enabling bitbang mode\n");
ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG);
sleep(3);
buf[0] = 0x0;
printf("turning everything on\n");
f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
{
fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(ftdi));
}
sleep(3);
buf[0] = 0xFF;
printf("turning everything off\n");
f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
{
fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(ftdi));
}
sleep(3);
for (i = 0; i < 32; i++)
{
buf[0] = 0 | (0xFF ^ 1 << (i % 8));
if ( i > 0 && (i % 8) == 0)
{
printf("\n");
}
printf("%02hhx ",buf[0]);
fflush(stdout);
f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
{
fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(ftdi));
}
sleep(1);
}
printf("\n");
printf("disabling bitbang mode\n");
ftdi_disable_bitbang(ftdi);
ftdi_usb_close(ftdi);
done:
ftdi_free(ftdi);
return retval;
}

92
lib/libftdi/examples/bitbang2.c Normal file
View File

@@ -0,0 +1,92 @@
/* ftdi_out.c
*
* Output a (stream of) byte(s) in bitbang mode to the
* ftdi245 chip that is (hopefully) attached.
*
* We have a little board that has a FT245BM chip and
* the 8 outputs are connected to several different
* things that we can turn on and off with this program.
*
* If you have an idea about hardware that can easily
* interface onto an FTDI chip, I'd like to collect
* ideas. If I find it worthwhile to make, I'll consider
* making it, I'll even send you a prototype (against
* cost-of-material) if you want.
*
* At "harddisk-recovery.nl" they have a little board that
* controls the power to two harddrives and two fans.
*
* -- REW R.E.Wolff@BitWizard.nl
*
*
*
* This program was based on libftdi_example_bitbang2232.c
* which doesn't carry an author or attribution header.
*
*
* This program is distributed under the GPL, version 2.
* Millions copies of the GPL float around the internet.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#ifdef __WIN32__
#define usleep(x) Sleep((x+999)/1000)
#endif
#include <ftdi.h>
void ftdi_fatal (struct ftdi_context *ftdi, char *str)
{
fprintf (stderr, "%s: %s\n",
str, ftdi_get_error_string (ftdi));
ftdi_deinit(ftdi);
exit (1);
}
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
int i, t;
unsigned char data;
int delay = 100000; /* 100 thousand microseconds: 1 tenth of a second */
while ((t = getopt (argc, argv, "d:")) != -1)
{
switch (t)
{
case 'd':
delay = atoi (optarg);
break;
}
}
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_bew failed\n");
return EXIT_FAILURE;
}
if (ftdi_usb_open(ftdi, 0x0403, 0x6001) < 0)
ftdi_fatal (ftdi, "Can't open ftdi device");
if (ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG) < 0)
ftdi_fatal (ftdi, "Can't enable bitbang");
for (i=optind; i < argc ; i++)
{
sscanf (argv[i], "%x", &t);
data = t;
if (ftdi_write_data(ftdi, &data, 1) < 0)
{
fprintf(stderr,"write failed for 0x%x: %s\n",
data, ftdi_get_error_string(ftdi));
}
usleep(delay);
}
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
exit (0);
}

94
lib/libftdi/examples/bitbang_cbus.c Normal file
View File

@@ -0,0 +1,94 @@
/* bitbang_cbus.c
Example to use CBUS bitbang mode of newer chipsets.
You must enable CBUS bitbang mode in the EEPROM first.
Thanks to Steve Brown <sbrown@ewol.com> for the
the information how to do it.
The top nibble controls input/output and the bottom nibble
controls the state of the lines set to output. The datasheet isn't clear
what happens if you set a bit in the output register when that line is
conditioned for input. This is described in more detail
in the FT232R bitbang app note.
BITMASK
CBUS Bits
3210 3210
xxxx xxxx
|    |------ Output Control 0->LO, 1->HI
|----------- Input/Output   0->Input, 1->Output
Example:
All pins to output with 0 bit high: 0xF1 (11110001)
Bits 0 and 1 to input, 2 and 3 to output and masked high: 0xCC (11001100)
The input is standard "0x" hex notation.
A carriage return terminates the program.
This program is distributed under the GPL, version 2
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ftdi.h>
int main(void)
{
struct ftdi_context *ftdi;
int f;
unsigned char buf[1];
unsigned char bitmask;
char input[10];
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
ftdi_deinit(ftdi);
exit(-1);
}
printf("ftdi open succeeded: %d\n",f);
while (1)
{
// Set bitmask from input
fgets(input, sizeof(input) - 1, stdin);
if (input[0] == '\n') break;
bitmask = strtol(input, NULL, 0);
printf("Using bitmask 0x%02x\n", bitmask);
f = ftdi_set_bitmode(ftdi, bitmask, BITMODE_CBUS);
if (f < 0)
{
fprintf(stderr, "set_bitmode failed for 0x%x, error %d (%s)\n", bitmask, f, ftdi_get_error_string(ftdi));
ftdi_usb_close(ftdi);
ftdi_deinit(ftdi);
exit(-1);
}
// read CBUS
f = ftdi_read_pins(ftdi, &buf[0]);
if (f < 0)
{
fprintf(stderr, "read_pins failed, error %d (%s)\n", f, ftdi_get_error_string(ftdi));
ftdi_usb_close(ftdi);
ftdi_deinit(ftdi);
exit(-1);
}
printf("Read returned 0x%01x\n", buf[0] & 0x0f);
}
printf("disabling bitbang mode\n");
ftdi_disable_bitbang(ftdi);
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
return 0;
}

62
lib/libftdi/examples/bitbang_cbus_eeprom_for_windows.ept Normal file
View File

@@ -0,0 +1,62 @@
[Basic Details]
Device Type=6
VID PID Type=0
USB VID=0403
USB PID=6001
[USB Power Options]
Bus Powered=1
Self Powered=0
Max Bus Power=44
[USB Serial Number Control]
Prefix=FT
Use Fixed Serial Number=0
Fixed Serial Number=FTDECZJT
[USB Remote WakeUp]
Enable Remote WakeUp=1
[Windows Plug and Play]
Enable Plug and Play=0
[USB String Descriptors]
Manufacturer=FTDI
Product=USB Serial Converter
[Programming Options]
Only Program Blank Devices=0
[BM Device Specific Options]
USB Version Number=1
Disable Serial Number=0
IO Pin Pull Down in Suspend=0
[Dual Device Specific Options A]
RS 232 mode=1
245 FIFO mode=0
245 CPU FIFO mode=0
OPTO Isolate mode=1
High Current Drive=0
[Dual Device Specific Options B]
RS 232 mode=1
245 FIFO mode=0
245 CPU FIFO mode=0
OPTO Isolate mode=0
High Current Drive=0
[Dual Device Driver Options A]
Virtual Com Port Driver=1
D2XX Driver=0
[Dual Device Driver Options B]
Virtual Com Port Driver=1
D2XX Driver=0
[R Device Specific Options]
Invert TXD=0
Invert RXD=0
Invert RTS#=0
Invert CTS#=0
Invert DTR#=0
Invert DSR#=0
Invert DCD#=0
Invert RI#=0
C0 Signal=10
C1 Signal=10
C2 Signal=10
C3 Signal=10
C4 Signal=5
Enable Ext Osc=0
High Current I/O=0
Load D2XX Driver=0
In EndPoint Size=0

109
lib/libftdi/examples/bitbang_ft2232.c Normal file
View File

@@ -0,0 +1,109 @@
/* bitbang_ft2232.c
Output some flickering in bitbang mode to the FT2232
Thanks to max@koeln.ccc.de for fixing and extending
the example for the second channel.
This program is distributed under the GPL, version 2
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#ifdef __WIN32__
#define sleep(x) Sleep(x)
#endif
#include <ftdi.h>
int main(int argc, char **argv)
{
struct ftdi_context *ftdi, *ftdi2;
unsigned char buf[1];
int f,i;
// Init 1. channel
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
ftdi_set_interface(ftdi, INTERFACE_A);
f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
ftdi_deinit(ftdi);
exit(-1);
}
printf("ftdi open succeeded(channel 1): %d\n",f);
printf("enabling bitbang mode(channel 1)\n");
ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG);
// Init 2. channel
if ((ftdi2 = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
ftdi_set_interface(ftdi2, INTERFACE_B);
f = ftdi_usb_open(ftdi2, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi2));
ftdi_deinit(ftdi2);
exit(-1);
}
printf("ftdi open succeeded(channel 2): %d\n",f);
printf("enabling bitbang mode (channel 2)\n");
ftdi_set_bitmode(ftdi2, 0xFF, BITMODE_BITBANG);
// Write data
printf("startloop\n");
for (i = 0; i < 23; i++)
{
buf[0] = 0x1;
printf("porta: %02i: 0x%02x \n",i,buf[0]);
f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
fprintf(stderr,"write failed on channel 1 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(ftdi));
sleep(1);
buf[0] = 0x2;
printf("porta: %02i: 0x%02x \n",i,buf[0]);
f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
fprintf(stderr,"write failed on channel 1 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(ftdi));
sleep(1);
buf[0] = 0x1;
printf("portb: %02i: 0x%02x \n",i,buf[0]);
f = ftdi_write_data(ftdi2, buf, 1);
if (f < 0)
fprintf(stderr,"write failed on channel 2 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(ftdi2));
sleep(1);
buf[0] = 0x2;
printf("portb: %02i: 0x%02x \n",i,buf[0]);
f = ftdi_write_data(ftdi2, buf, 1);
if (f < 0)
fprintf(stderr,"write failed on channel 2 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(ftdi2));
sleep(1);
}
printf("\n");
printf("disabling bitbang mode(channel 1)\n");
ftdi_disable_bitbang(ftdi);
ftdi_usb_close(ftdi);
ftdi_deinit(ftdi);
printf("disabling bitbang mode(channel 2)\n");
ftdi_disable_bitbang(ftdi2);
ftdi_usb_close(ftdi2);
ftdi_free(ftdi2);
return 0;
}

299
lib/libftdi/examples/eeprom.c Normal file
View File

@@ -0,0 +1,299 @@
/* LIBFTDI EEPROM access example
This program is distributed under the GPL, version 2
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <getopt.h>
#include <ftdi.h>
int read_decode_eeprom(struct ftdi_context *ftdi)
{
int i, j, f;
int value;
int size;
unsigned char buf[256];
f = ftdi_read_eeprom(ftdi);
if (f < 0)
{
fprintf(stderr, "ftdi_read_eeprom: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
return -1;
}
ftdi_get_eeprom_value(ftdi, CHIP_SIZE, & value);
if (value <0)
{
fprintf(stderr, "No EEPROM found or EEPROM empty\n");
fprintf(stderr, "On empty EEPROM, use -w option to write default values\n");
return -1;
}
fprintf(stderr, "Chip type %d ftdi_eeprom_size: %d\n", ftdi->type, value);
if (ftdi->type == TYPE_R)
size = 0xa0;
else
size = value;
ftdi_get_eeprom_buf(ftdi, buf, size);
for (i=0; i < size; i += 16)
{
fprintf(stdout,"0x%03x:", i);
for (j = 0; j< 8; j++)
fprintf(stdout," %02x", buf[i+j]);
fprintf(stdout," ");
for (; j< 16; j++)
fprintf(stdout," %02x", buf[i+j]);
fprintf(stdout," ");
for (j = 0; j< 8; j++)
fprintf(stdout,"%c", isprint(buf[i+j])?buf[i+j]:'.');
fprintf(stdout," ");
for (; j< 16; j++)
fprintf(stdout,"%c", isprint(buf[i+j])?buf[i+j]:'.');
fprintf(stdout,"\n");
}
f = ftdi_eeprom_decode(ftdi, 1);
if (f < 0)
{
fprintf(stderr, "ftdi_eeprom_decode: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
return -1;
}
return 0;
}
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
int f, i;
int vid = 0;
int pid = 0;
char const *desc = 0;
char const *serial = 0;
int erase = 0;
int use_defaults = 0;
int large_chip = 0;
int do_write = 0;
int retval = 0;
int value;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "Failed to allocate ftdi structure :%s \n",
ftdi_get_error_string(ftdi));
return EXIT_FAILURE;
}
while ((i = getopt(argc, argv, "d::ev:p:l:P:S:w")) != -1)
{
switch (i)
{
case 'd':
use_defaults = 1;
if (optarg)
large_chip = 0x66;
break;
case 'e':
erase = 1;
break;
case 'v':
vid = strtoul(optarg, NULL, 0);
break;
case 'p':
pid = strtoul(optarg, NULL, 0);
break;
case 'P':
desc = optarg;
break;
case 'S':
serial = optarg;
break;
case 'w':
do_write = 1;
break;
default:
fprintf(stderr, "usage: %s [options]\n", *argv);
fprintf(stderr, "\t-d[num] Work with default valuesfor 128 Byte "
"EEPROM or for 256 Byte EEPROM if some [num] is given\n");
fprintf(stderr, "\t-w write\n");
fprintf(stderr, "\t-e erase\n");
fprintf(stderr, "\t-v verbose decoding\n");
fprintf(stderr, "\t-p <number> Search for device with PID == number\n");
fprintf(stderr, "\t-v <number> Search for device with VID == number\n");
fprintf(stderr, "\t-P <string? Search for device with given "
"product description\n");
fprintf(stderr, "\t-S <string? Search for device with given "
"serial number\n");
retval = -1;
goto done;
}
}
// Select first interface
ftdi_set_interface(ftdi, INTERFACE_ANY);
if (!vid && !pid && desc == NULL && serial == NULL)
{
struct ftdi_device_list *devlist, *curdev;
int res;
if ((res = ftdi_usb_find_all(ftdi, &devlist, 0, 0)) < 0)
{
fprintf(stderr, "No FTDI with default VID/PID found\n");
retval = EXIT_FAILURE;
goto do_deinit;
}
if (res > 1)
{
int i = 1;
fprintf(stderr, "%d FTDI devices found: Only Readout on EEPROM done. ",res);
fprintf(stderr, "Use VID/PID/desc/serial to select device\n");
for (curdev = devlist; curdev != NULL; curdev= curdev->next, i++)
{
f = ftdi_usb_open_dev(ftdi, curdev->dev);
if (f<0)
{
fprintf(stderr, "Unable to open device %d: (%s)",
i, ftdi_get_error_string(ftdi));
continue;
}
fprintf(stderr, "Decoded values of device %d:\n", i);
read_decode_eeprom(ftdi);
ftdi_usb_close(ftdi);
}
ftdi_list_free(&devlist);
retval = EXIT_SUCCESS;
goto do_deinit;
}
else if (res == 1)
{
f = ftdi_usb_open_dev(ftdi, devlist[0].dev);
if (f<0)
{
fprintf(stderr, "Unable to open device %d: (%s)",
i, ftdi_get_error_string(ftdi));
}
}
else
{
fprintf(stderr, "No devices found\n");
f = 0;
}
ftdi_list_free(&devlist);
}
else
{
// Open device
f = ftdi_usb_open_desc(ftdi, vid, pid, desc, serial);
if (f < 0)
{
fprintf(stderr, "Device VID 0x%04x PID 0x%04x", vid, pid);
if (desc)
fprintf(stderr, " Desc %s", desc);
if (serial)
fprintf(stderr, " Serial %s", serial);
fprintf(stderr, "\n");
fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
retval = -1;
goto done;
}
}
if (erase)
{
f = ftdi_erase_eeprom(ftdi); /* needed to determine EEPROM chip type */
if (f < 0)
{
fprintf(stderr, "Erase failed: %s",
ftdi_get_error_string(ftdi));
retval = -2;
goto done;
}
if (ftdi_get_eeprom_value(ftdi, CHIP_TYPE, & value) <0)
{
fprintf(stderr, "ftdi_get_eeprom_value: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
}
if (value == -1)
fprintf(stderr, "No EEPROM\n");
else if (value == 0)
fprintf(stderr, "Internal EEPROM\n");
else
fprintf(stderr, "Found 93x%02x\n", value);
retval = 0;
goto done;
}
if (use_defaults)
{
ftdi_eeprom_initdefaults(ftdi, NULL, NULL, NULL);
if (ftdi_set_eeprom_value(ftdi, MAX_POWER, 500) <0)
{
fprintf(stderr, "ftdi_set_eeprom_value: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
}
if (large_chip)
if (ftdi_set_eeprom_value(ftdi, CHIP_TYPE, 0x66) <0)
{
fprintf(stderr, "ftdi_set_eeprom_value: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
}
f=(ftdi_eeprom_build(ftdi));
if (f < 0)
{
fprintf(stderr, "ftdi_eeprom_build: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
retval = -1;
goto done;
}
}
else if (do_write)
{
ftdi_eeprom_initdefaults(ftdi, NULL, NULL, NULL);
f = ftdi_erase_eeprom(ftdi);
if (ftdi_set_eeprom_value(ftdi, MAX_POWER, 500) <0)
{
fprintf(stderr, "ftdi_set_eeprom_value: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
}
f = ftdi_erase_eeprom(ftdi);/* needed to determine EEPROM chip type */
if (ftdi_get_eeprom_value(ftdi, CHIP_TYPE, & value) <0)
{
fprintf(stderr, "ftdi_get_eeprom_value: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
}
if (value == -1)
fprintf(stderr, "No EEPROM\n");
else if (value == 0)
fprintf(stderr, "Internal EEPROM\n");
else
fprintf(stderr, "Found 93x%02x\n", value);
f=(ftdi_eeprom_build(ftdi));
if (f < 0)
{
fprintf(stderr, "Erase failed: %s",
ftdi_get_error_string(ftdi));
retval = -2;
goto done;
}
f = ftdi_write_eeprom(ftdi);
{
fprintf(stderr, "ftdi_eeprom_decode: %d (%s)\n",
f, ftdi_get_error_string(ftdi));
retval = 1;
goto done;
}
}
retval = read_decode_eeprom(ftdi);
done:
ftdi_usb_close(ftdi);
do_deinit:
ftdi_free(ftdi);
return retval;
}

54
lib/libftdi/examples/find_all.c Normal file
View File

@@ -0,0 +1,54 @@
/* find_all.c
Example for ftdi_usb_find_all()
This program is distributed under the GPL, version 2
*/
#include <stdio.h>
#include <stdlib.h>
#include <ftdi.h>
int main(void)
{
int ret, i;
struct ftdi_context *ftdi;
struct ftdi_device_list *devlist, *curdev;
char manufacturer[128], description[128];
int retval = EXIT_SUCCESS;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
if ((ret = ftdi_usb_find_all(ftdi, &devlist, 0, 0)) < 0)
{
fprintf(stderr, "ftdi_usb_find_all failed: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_deinit;
}
printf("Number of FTDI devices found: %d\n", ret);
i = 0;
for (curdev = devlist; curdev != NULL; i++)
{
printf("Checking device: %d\n", i);
if ((ret = ftdi_usb_get_strings(ftdi, curdev->dev, manufacturer, 128, description, 128, NULL, 0)) < 0)
{
fprintf(stderr, "ftdi_usb_get_strings failed: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto done;
}
printf("Manufacturer: %s, Description: %s\n\n", manufacturer, description);
curdev = curdev->next;
}
done:
ftdi_list_free(&devlist);
do_deinit:
ftdi_free(ftdi);
return retval;
}

71
lib/libftdi/examples/find_all_pp.cpp Normal file
View File

@@ -0,0 +1,71 @@
/* final_all_pp.cpp
Simple libftdi-cpp usage
This program is distributed under the GPL, version 2
*/
#include "ftdi.hpp"
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <cstring>
using namespace Ftdi;
int main(int argc, char **argv)
{
// Show help
if (argc > 1)
{
if (strcmp(argv[1],"-h") == 0 || strcmp(argv[1],"--help") == 0)
{
std::cout << "Usage: " << argv[0] << " [-v VENDOR_ID] [-p PRODUCT_ID]" << std::endl;
return EXIT_SUCCESS;
}
}
// Parse args
int vid = 0x0403, pid = 0x6010, tmp = 0;
for (int i = 0; i < (argc - 1); i++)
{
if (strcmp(argv[i], "-v") == 0)
if ((tmp = strtol(argv[++i], 0, 16)) >= 0)
vid = tmp;
if (strcmp(argv[i], "-p") == 0)
if ((tmp = strtol(argv[++i], 0, 16)) >= 0)
pid = tmp;
}
// Print header
std::cout << std::hex << std::showbase
<< "Found devices ( VID: " << vid << ", PID: " << pid << " )"
<< std::endl
<< "------------------------------------------------"
<< std::endl << std::dec;
// Print whole list
List* list = List::find_all(vid, pid);
for (List::iterator it = list->begin(); it != list->end(); it++)
{
std::cout << "FTDI (" << &*it << "): "
<< it->vendor() << ", "
<< it->description() << ", "
<< it->serial();
// Open test
if(it->open() == 0)
std::cout << " (Open OK)";
else
std::cout << " (Open FAILED)";
it->close();
std::cout << std::endl;
}
delete list;
return EXIT_SUCCESS;
}

101
lib/libftdi/examples/python/complete.py Normal file
View File

@@ -0,0 +1,101 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Python example program.
Complete program to demonstrate the usage
of the swig generated python wrapper
You need to build and install the wrapper first"""
import os
import ftdi
import time
# initialize
ftdic = ftdi.new()
if ftdic == 0:
print 'new failed: %d', ret
os._exit( 1 )
# list all devices
ret, devlist = ftdi.usb_find_all( ftdic, 0x0403, 0x6001 )
if ret < 0:
print 'ftdi_usb_find_all failed: %d (%s)' % ( ret, ftdi.get_error_string( ftdic ) )
os._exit( 1 )
print 'Number of FTDI devices found: %d\n' % ret
curnode = devlist
i = 0
while( curnode != None ):
ret, manufacturer, description, serial = ftdi.usb_get_strings( ftdic, curnode.dev )
if ret < 0:
print 'ftdi_usb_get_strings failed: %d (%s)' % ( ret, ftdi.get_error_string( ftdic ) )
os._exit( 1 )
print 'Device #%d: manufacturer="%s" description="%s" serial="%s"\n' % ( i, manufacturer, description, serial )
curnode = curnode.next
i += 1
# open usb
ret = ftdi.usb_open( ftdic, 0x0403, 0x6001 )
if ret < 0:
print 'unable to open ftdi device: %d (%s)' % ( ret, ftdi.get_error_string( ftdic ) )
os._exit( 1 )
# bitbang
ret = ftdi.set_bitmode( ftdic, 0xff, ftdi.BITMODE_BITBANG )
if ret < 0:
print 'Cannot enable bitbang'
os._exit( 1 )
print 'turning everything on'
ftdi.write_data( ftdic, chr(0xff), 1 )
time.sleep( 1 )
print 'turning everything off\n'
ftdi.write_data( ftdic, chr(0x00), 1 )
time.sleep( 1 )
for i in range( 8 ):
val = 2**i
print 'enabling bit #%d (0x%02x)' % (i, val)
ftdi.write_data( ftdic, chr(val), 1 )
time.sleep ( 1 )
ftdi.disable_bitbang( ftdic )
print ''
# read pins
ret, pins = ftdi.read_pins( ftdic )
print 'pins:',
if ( ret == 0 ):
print '%02x' % ord( pins[0] )
print ''
# read chip id
ret, chipid = ftdi.read_chipid( ftdic )
print 'FDTI chip id: %X\n' % chipid
# read eeprom
eeprom_addr = 1
ret, eeprom_val = ftdi.read_eeprom_location( ftdic, eeprom_addr )
if (ret==0):
print 'eeprom @ %d: 0x%04x\n' % ( eeprom_addr, eeprom_val )
print 'complete eeprom:'
ret = ftdi.read_eeprom( ftdic )
size = 128
ret, eeprom = ftdi.get_eeprom_buf ( ftdic, size )
if ( ret == 0 ):
for i in range( size ):
print '%02x' % ord( eeprom[i] ),
if ( i % 8 == 7 ):
print ''
# close usb
ret = ftdi.usb_close( ftdic )
if ret < 0:
print 'unable to close ftdi device: %d (%s)' % ( ret, ftdi.get_error_string( ftdic ) )
os._exit( 1 )
ftdi.free( ftdic )

28
lib/libftdi/examples/python/simple.py Normal file
View File

@@ -0,0 +1,28 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Python example program.
Small program to demonstrate the usage
of the swig generated python wrapper
You need to build and install the wrapper first"""
import ftdi
def main():
"""Main program"""
context = ftdi.new()
version_info = ftdi.get_library_version()
print("[FTDI version] major: %d, minor: %d, micro: %d" \
", version_str: %s, snapshot_str: %s" %
(version_info.major, version_info.minor, version_info.micro,
version_info.version_str, version_info.snapshot_str))
print("ftdi.usb_open(): %d" % ftdi.usb_open(context, 0x0403, 0x6010))
print("ftdi.set_baudrate(): %d" % ftdi.set_baudrate(context, 9600))
ftdi.free(context)
main()

182
lib/libftdi/examples/serial_test.c Normal file
View File

@@ -0,0 +1,182 @@
/* serial_test.c
Read/write data via serial I/O
This program is distributed under the GPL, version 2
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#ifdef __WIN32__
#define sleep(x) Sleep(x)
#endif
#include <getopt.h>
#include <signal.h>
#include <ftdi.h>
static int exitRequested = 0;
/*
* sigintHandler --
*
* SIGINT handler, so we can gracefully exit when the user hits ctrl-C.
*/
static void
sigintHandler(int signum)
{
exitRequested = 1;
}
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
unsigned char buf[1024];
int f = 0, i;
int vid = 0x403;
int pid = 0;
int baudrate = 115200;
int interface = INTERFACE_ANY;
int do_write = 0;
unsigned int pattern = 0xffff;
int retval = EXIT_FAILURE;
while ((i = getopt(argc, argv, "i:v:p:b:w::")) != -1)
{
switch (i)
{
case 'i': // 0=ANY, 1=A, 2=B, 3=C, 4=D
interface = strtoul(optarg, NULL, 0);
break;
case 'v':
vid = strtoul(optarg, NULL, 0);
break;
case 'p':
pid = strtoul(optarg, NULL, 0);
break;
case 'b':
baudrate = strtoul(optarg, NULL, 0);
break;
case 'w':
do_write = 1;
if (optarg)
pattern = strtoul(optarg, NULL, 0);
if (pattern > 0xff)
{
fprintf(stderr, "Please provide a 8 bit pattern\n");
exit(-1);
}
break;
default:
fprintf(stderr, "usage: %s [-i interface] [-v vid] [-p pid] [-b baudrate] [-w [pattern]]\n", *argv);
exit(-1);
}
}
// Init
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
if (!vid && !pid && (interface == INTERFACE_ANY))
{
ftdi_set_interface(ftdi, INTERFACE_ANY);
struct ftdi_device_list *devlist;
int res;
if ((res = ftdi_usb_find_all(ftdi, &devlist, 0, 0)) < 0)
{
fprintf(stderr, "No FTDI with default VID/PID found\n");
goto do_deinit;
}
if (res == 1)
{
f = ftdi_usb_open_dev(ftdi, devlist[0].dev);
if (f<0)
{
fprintf(stderr, "Unable to open device %d: (%s)",
i, ftdi_get_error_string(ftdi));
}
}
ftdi_list_free(&devlist);
if (res > 1)
{
fprintf(stderr, "%d Devices found, please select Device with VID/PID\n", res);
/* TODO: List Devices*/
goto do_deinit;
}
if (res == 0)
{
fprintf(stderr, "No Devices found with default VID/PID\n");
goto do_deinit;
}
}
else
{
// Select interface
ftdi_set_interface(ftdi, interface);
// Open device
f = ftdi_usb_open(ftdi, vid, pid);
}
if (f < 0)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
exit(-1);
}
// Set baudrate
f = ftdi_set_baudrate(ftdi, baudrate);
if (f < 0)
{
fprintf(stderr, "unable to set baudrate: %d (%s)\n", f, ftdi_get_error_string(ftdi));
exit(-1);
}
/* Set line parameters
*
* TODO: Make these parameters settable from the command line
*
* Parameters are choosen that sending a continous stream of 0x55
* should give a square wave
*
*/
f = ftdi_set_line_property(ftdi, 8, STOP_BIT_1, NONE);
if (f < 0)
{
fprintf(stderr, "unable to set line parameters: %d (%s)\n", f, ftdi_get_error_string(ftdi));
exit(-1);
}
if (do_write)
for(i=0; i<1024; i++)
buf[i] = pattern;
signal(SIGINT, sigintHandler);
while (!exitRequested)
{
if (do_write)
f = ftdi_write_data(ftdi, buf,
(baudrate/512 >sizeof(buf))?sizeof(buf):
(baudrate/512)?baudrate/512:1);
else
f = ftdi_read_data(ftdi, buf, sizeof(buf));
if (f<0)
sleep(1);
else if(f> 0 && !do_write)
{
fprintf(stderr, "read %d bytes\n", f);
fwrite(buf, f, 1, stdout);
fflush(stderr);
fflush(stdout);
}
}
signal(SIGINT, SIG_DFL);
retval = EXIT_SUCCESS;
ftdi_usb_close(ftdi);
do_deinit:
ftdi_free(ftdi);
return retval;
}

53
lib/libftdi/examples/simple.c Normal file
View File

@@ -0,0 +1,53 @@
/* simple.c
Simple libftdi usage example
This program is distributed under the GPL, version 2
*/
#include <stdio.h>
#include <stdlib.h>
#include <ftdi.h>
int main(void)
{
int ret;
struct ftdi_context *ftdi;
struct ftdi_version_info version;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
version = ftdi_get_library_version();
printf("Initialized libftdi %s (major: %d, minor: %d, micro: %d, snapshot ver: %s)\n",
version.version_str, version.major, version.minor, version.micro,
version.snapshot_str);
if ((ret = ftdi_usb_open(ftdi, 0x0403, 0x6001)) < 0)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return EXIT_FAILURE;
}
// Read out FTDIChip-ID of R type chips
if (ftdi->type == TYPE_R)
{
unsigned int chipid;
printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(ftdi, &chipid));
printf("FTDI chipid: %X\n", chipid);
}
if ((ret = ftdi_usb_close(ftdi)) < 0)
{
fprintf(stderr, "unable to close ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return EXIT_FAILURE;
}
ftdi_free(ftdi);
return EXIT_SUCCESS;
}

358
lib/libftdi/examples/stream_test.c Normal file
View File

@@ -0,0 +1,358 @@
/* stream_test.c
*
* Test reading from FT2232H in synchronous FIFO mode.
*
* The FT2232H must supply data due to an appropriate circuit
*
* To check for skipped block with appended code,
* a structure as follows is assumed
* 1* uint32_t num (incremented in 0x4000 steps)
* 3* uint32_t dont_care
*
* After start, data will be read in streaming until the program is aborted
* Progess information wil be printed out
* If a filename is given on the command line, the data read will be
* written to that file
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>
#include <signal.h>
#include <errno.h>
#include <ftdi.h>
void check_outfile(char *);
static FILE *outputFile;
static int check = 1;
static int exitRequested = 0;
/*
* sigintHandler --
*
* SIGINT handler, so we can gracefully exit when the user hits ctrl-C.
*/
static void
sigintHandler(int signum)
{
exitRequested = 1;
}
static void
usage(const char *argv0)
{
fprintf(stderr,
"Usage: %s [options...] \n"
"Test streaming read from FT2232H\n"
"[-P string] only look for product with given string\n"
"[-n] don't check for special block structure\n"
"\n"
"If some filename is given, write data read to that file\n"
"Progess information is printed each second\n"
"Abort with ^C\n"
"\n"
"Options:\n"
"\n"
"Copyright (C) 2009 Micah Dowty <micah@navi.cx>\n"
"Adapted for use with libftdi (C) 2010 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>\n",
argv0);
exit(1);
}
static uint32_t start = 0;
static uint32_t offset = 0;
static uint64_t blocks = 0;
static uint32_t skips = 0;
static uint32_t n_err = 0;
static int
readCallback(uint8_t *buffer, int length, FTDIProgressInfo *progress, void *userdata)
{
if (length)
{
if (check)
{
int i,rem;
uint32_t num;
for (i= offset; i<length-16; i+=16)
{
num = *(uint32_t*) (buffer+i);
if (start && (num != start +0x4000))
{
uint32_t delta = ((num-start)/0x4000)-1;
fprintf(stderr, "Skip %7d blocks from 0x%08x to 0x%08x at blocks %10llu\n",
delta, start -0x4000, num, (unsigned long long)blocks);
n_err++;
skips += delta;
}
blocks ++;
start = num;
}
rem = length -i;
if (rem >3)
{
num = *(uint32_t*) (buffer+i);
if (start && (num != start +0x4000))
{
uint32_t delta = ((num-start)/0x4000)-1;
fprintf(stderr, "Skip %7d blocks from 0x%08x to 0x%08x at blocks %10llu\n",
delta, start -0x4000, num, (unsigned long long) blocks);
n_err++;
skips += delta;
}
start = num;
}
else if (rem)
start += 0x4000;
if (rem != 0)
{
blocks ++;
offset = 16-rem;
}
}
if (outputFile)
{
if (fwrite(buffer, length, 1, outputFile) != 1)
{
perror("Write error");
return 1;
}
}
}
if (progress)
{
fprintf(stderr, "%10.02fs total time %9.3f MiB captured %7.1f kB/s curr rate %7.1f kB/s totalrate %d dropouts\n",
progress->totalTime,
progress->current.totalBytes / (1024.0 * 1024.0),
progress->currentRate / 1024.0,
progress->totalRate / 1024.0,
n_err);
}
return exitRequested ? 1 : 0;
}
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
int err, c;
FILE *of = NULL;
char const *outfile = 0;
outputFile =0;
exitRequested = 0;
char *descstring = NULL;
int option_index;
static struct option long_options[] = {{NULL},};
while ((c = getopt_long(argc, argv, "P:n", long_options, &option_index)) !=- 1)
switch (c)
{
case -1:
break;
case 'P':
descstring = optarg;
break;
case 'n':
check = 0;
break;
default:
usage(argv[0]);
}
if (optind == argc - 1)
{
// Exactly one extra argument- a dump file
outfile = argv[optind];
}
else if (optind < argc)
{
// Too many extra args
usage(argv[0]);
}
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
if (ftdi_set_interface(ftdi, INTERFACE_A) < 0)
{
fprintf(stderr, "ftdi_set_interface failed\n");
ftdi_free(ftdi);
return EXIT_FAILURE;
}
if (ftdi_usb_open_desc(ftdi, 0x0403, 0x6010, descstring, NULL) < 0)
{
fprintf(stderr,"Can't open ftdi device: %s\n",ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return EXIT_FAILURE;
}
/* A timeout value of 1 results in may skipped blocks */
if(ftdi_set_latency_timer(ftdi, 2))
{
fprintf(stderr,"Can't set latency, Error %s\n",ftdi_get_error_string(ftdi));
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
return EXIT_FAILURE;
}
/* if(ftdi_usb_purge_rx_buffer(ftdi) < 0)
{
fprintf(stderr,"Can't rx purge\n",ftdi_get_error_string(ftdi));
return EXIT_FAILURE;
}*/
if (outfile)
if ((of = fopen(outfile,"w+")) == 0)
fprintf(stderr,"Can't open logfile %s, Error %s\n", outfile, strerror(errno));
if (of)
if (setvbuf(of, NULL, _IOFBF , 1<<16) == 0)
outputFile = of;
signal(SIGINT, sigintHandler);
err = ftdi_readstream(ftdi, readCallback, NULL, 8, 256);
if (err < 0 && !exitRequested)
exit(1);
if (outputFile) {
fclose(outputFile);
outputFile = NULL;
}
fprintf(stderr, "Capture ended.\n");
if (ftdi_set_bitmode(ftdi, 0xff, BITMODE_RESET) < 0)
{
fprintf(stderr,"Can't set synchronous fifo mode, Error %s\n",ftdi_get_error_string(ftdi));
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
return EXIT_FAILURE;
}
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
signal(SIGINT, SIG_DFL);
if (check && outfile)
{
if ((outputFile = fopen(outfile,"r")) == 0)
{
fprintf(stderr,"Can't open logfile %s, Error %s\n", outfile, strerror(errno));
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
return EXIT_FAILURE;
}
check_outfile(descstring);
fclose(outputFile);
}
else if (check)
fprintf(stderr,"%d errors of %llu blocks (%Le), %d (%Le) blocks skipped\n",
n_err, (unsigned long long) blocks, (long double)n_err/(long double) blocks,
skips, (long double)skips/(long double) blocks);
exit (0);
}
void check_outfile(char *descstring)
{
if(strcmp(descstring,"FT2232HTEST") == 0)
{
char buf0[1024];
char buf1[1024];
char bufr[1024];
char *pa, *pb, *pc;
unsigned int num_lines = 0, line_num = 1;
int err_count = 0;
unsigned int num_start, num_end;
pa = buf0;
pb = buf1;
pc = buf0;
if(fgets(pa, 1023, outputFile) == NULL)
{
fprintf(stderr,"Empty output file\n");
return;
}
while(fgets(pb, 1023, outputFile) != NULL)
{
num_lines++;
unsigned int num_save = num_start;
if( sscanf(pa,"%6u%94s%6u",&num_start, bufr,&num_end) !=3)
{
fprintf(stdout,"Format doesn't match at line %8d \"%s",
num_lines, pa);
err_count++;
line_num = num_save +2;
}
else
{
if ((num_start+1)%100000 != num_end)
{
if (err_count < 20)
fprintf(stdout,"Malformed line %d \"%s\"\n",
num_lines, pa);
err_count++;
}
else if(num_start != line_num)
{
if (err_count < 20)
fprintf(stdout,"Skipping from %d to %d\n",
line_num, num_start);
err_count++;
}
line_num = num_end;
}
pa = pb;
pb = pc;
pc = pa;
}
if(err_count)
fprintf(stdout,"\n%d errors of %d data sets %f\n", err_count, num_lines, (double) err_count/(double)num_lines);
else
fprintf(stdout,"No errors for %d lines\n",num_lines);
}
else if(strcmp(descstring,"LLBBC10") == 0)
{
uint32_t block0[4];
uint32_t block1[4];
uint32_t *pa = block0;
uint32_t *pb = block1;
uint32_t *pc = block0;
uint32_t start= 0;
uint32_t nread = 0;
int n_shown = 0;
int n_errors = 0;
if (fread(pa, sizeof(uint32_t), 4,outputFile) < 4)
{
fprintf(stderr,"Empty result file\n");
return;
}
while(fread(pb, sizeof(uint32_t), 4,outputFile) != 0)
{
blocks++;
nread = pa[0];
if(start>0 && (nread != start))
{
if(n_shown < 30)
{
fprintf(stderr, "Skip %7d blocks from 0x%08x to 0x%08x at blocks %10llu \n",
(nread-start)/0x4000, start -0x4000, nread, (unsigned long long) blocks);
n_shown ++;
}
n_errors++;
}
else if (n_shown >0)
n_shown--;
start = nread + 0x4000;
pa = pb;
pb = pc;
pc = pa;
}
if(n_errors)
fprintf(stderr, "%d blocks wrong from %llu blocks read\n",
n_errors, (unsigned long long) blocks);
else
fprintf(stderr, "%llu blocks all fine\n", (unsigned long long) blocks);
}
}

41
lib/libftdi/ftdi_eeprom/CMakeLists.txt Normal file
View File

@@ -0,0 +1,41 @@
set(FTDI_BUILD_EEPROM False PARENT_SCOPE)
option(FTDI_EEPROM "Build ftdi_eeprom" ON)
if (FTDI_EEPROM)
include(FindPkgConfig)
pkg_check_modules(Confuse libconfuse)
INCLUDE_DIRECTORIES(${Confuse_INCLUDE_DIRS})
LINK_DIRECTORIES(${Confuse_LIBRARY_DIRS})
SET(libs ${libs} ${Confuse_LIBRARIES})
if(Confuse_FOUND)
set(FTDI_BUILD_EEPROM True PARENT_SCOPE)
message(STATUS "Building ftdi_eeprom")
# Version defines
set(EEPROM_MAJOR_VERSION 0)
set(EEPROM_MINOR_VERSION 17)
set(EEPROM_VERSION_STRING ${EEPROM_MAJOR_VERSION}.${EEPROM_MINOR_VERSION})
include_directories(BEFORE ${CMAKE_SOURCE_DIR}/src)
include_directories(BEFORE ${CMAKE_BINARY_DIR}/ftdi_eeprom)
configure_file(
"ftdi_eeprom_version.h.in"
"${CMAKE_BINARY_DIR}/ftdi_eeprom/ftdi_eeprom_version.h"
)
add_executable(ftdi_eeprom main.c)
target_link_libraries(ftdi_eeprom ftdi)
target_link_libraries(ftdi_eeprom ${Confuse_LIBRARIES})
else(Confuse_FOUND)
message(STATUS "libConfuse not found, won't build ftdi_eeprom")
endif(Confuse_FOUND)
else(FTDI_EEPROM)
message(STATUS "ftdi_eeprom build is disabled")
endif(FTDI_EEPROM)

31
lib/libftdi/ftdi_eeprom/example.conf Normal file
View File

@@ -0,0 +1,31 @@
vendor_id=0x0403 # Vendor ID
product_id=0x6001 # Product ID
max_power=0 # Max. power consumption: value * 2 mA. Use 0 if self_powered = true.
###########
# Strings #
###########
manufacturer="ACME Inc" # Manufacturer
product="USB Serial Converter" # Product
serial="08-15" # Serial
###########
# Options #
###########
self_powered=true # Turn this off for bus powered
remote_wakeup=false # Turn this on for remote wakeup feature
use_serial=true # Use the serial number string
# Normally out don't have to change one of these flags
in_is_isochronous=false # In Endpoint is Isochronous
out_is_isochronous=false # Out Endpoint is Isochronous
suspend_pull_downs=false # Enable suspend pull downs for lower power
change_usb_version=false # Change USB Version
usb_version=0x0200 # Only used when change_usb_version is enabled
########
# Misc #
########
filename="eeprom.new" # Filename, leave empty to skip file writing

8
lib/libftdi/ftdi_eeprom/ftdi_eeprom_version.h.in Normal file
View File

@@ -0,0 +1,8 @@
#ifndef _FTDI_EEPROM_VERSION_H
#define _FTDI_EEPROM_VERSION_H
#define EEPROM_MAJOR_VERSION @EEPROM_MAJOR_VERSION@
#define EEPROM_MINOR_VERSION @EEPROM_MINOR_VERSION@
#define EEPROM_VERSION_STRING "@EEPROM_VERSION_STRING@"
#endif

381
lib/libftdi/ftdi_eeprom/main.c Normal file
View File

@@ -0,0 +1,381 @@
/***************************************************************************
main.c - description
-------------------
begin : Mon Apr 7 12:05:22 CEST 2003
copyright : (C) 2003-2011 by Intra2net AG and the libftdi developers
email : opensource@intra2net.com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
***************************************************************************/
/*
TODO:
- Remove 128 bytes limit
- Merge Uwe's eeprom tool. Current features:
- Init eeprom defaults based upon eeprom type
- Read -> Already there
- Write -> Already there
- Erase -> Already there
- Decode on stdout
- Ability to find device by PID/VID, product name or serial
TODO nice-to-have:
- Out-of-the-box compatibility with FTDI's eeprom tool configuration files
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <confuse.h>
#include <ftdi.h>
#include <ftdi_eeprom_version.h>
static int str_to_cbus(char *str, int max_allowed)
{
#define MAX_OPTION 14
const char* options[MAX_OPTION] = {
"TXDEN", "PWREN", "RXLED", "TXLED", "TXRXLED", "SLEEP",
"CLK48", "CLK24", "CLK12", "CLK6",
"IO_MODE", "BITBANG_WR", "BITBANG_RD", "SPECIAL"};
int i;
max_allowed += 1;
if (max_allowed > MAX_OPTION) max_allowed = MAX_OPTION;
for (i=0; i<max_allowed; i++) {
if (!(strcmp(options[i], str))) {
return i;
}
}
printf("WARNING: Invalid cbus option '%s'\n", str);
return 0;
}
/**
* @brief Set eeprom value
*
* \param ftdi pointer to ftdi_context
* \param value_name Enum of the value to set
* \param value Value to set
*
* Function will abort the program on error
**/
static void eeprom_set_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
{
if (ftdi_set_eeprom_value(ftdi, value_name, value) < 0)
{
printf("Unable to set eeprom value %d: %s. Aborting\n", value_name, ftdi_get_error_string(ftdi));
exit (-1);
}
}
/**
* @brief Get eeprom value
*
* \param ftdi pointer to ftdi_context
* \param value_name Enum of the value to get
* \param value Value to get
*
* Function will abort the program on error
**/
static void eeprom_get_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int *value)
{
if (ftdi_get_eeprom_value(ftdi, value_name, value) < 0)
{
printf("Unable to get eeprom value %d: %s. Aborting\n", value_name, ftdi_get_error_string(ftdi));
exit (-1);
}
}
int main(int argc, char *argv[])
{
/*
configuration options
*/
cfg_opt_t opts[] =
{
CFG_INT("vendor_id", 0, 0),
CFG_INT("product_id", 0, 0),
CFG_BOOL("self_powered", cfg_true, 0),
CFG_BOOL("remote_wakeup", cfg_true, 0),
CFG_BOOL("in_is_isochronous", cfg_false, 0),
CFG_BOOL("out_is_isochronous", cfg_false, 0),
CFG_BOOL("suspend_pull_downs", cfg_false, 0),
CFG_BOOL("use_serial", cfg_false, 0),
CFG_BOOL("change_usb_version", cfg_false, 0),
CFG_INT("usb_version", 0, 0),
CFG_INT("default_pid", 0x6001, 0),
CFG_INT("max_power", 0, 0),
CFG_STR("manufacturer", "Acme Inc.", 0),
CFG_STR("product", "USB Serial Converter", 0),
CFG_STR("serial", "08-15", 0),
CFG_STR("filename", "", 0),
CFG_BOOL("flash_raw", cfg_false, 0),
CFG_BOOL("high_current", cfg_false, 0),
CFG_STR_LIST("cbus0", "{TXDEN,PWREN,RXLED,TXLED,TXRXLED,SLEEP,CLK48,CLK24,CLK12,CLK6,IO_MODE,BITBANG_WR,BITBANG_RD,SPECIAL}", 0),
CFG_STR_LIST("cbus1", "{TXDEN,PWREN,RXLED,TXLED,TXRXLED,SLEEP,CLK48,CLK24,CLK12,CLK6,IO_MODE,BITBANG_WR,BITBANG_RD,SPECIAL}", 0),
CFG_STR_LIST("cbus2", "{TXDEN,PWREN,RXLED,TXLED,TXRXLED,SLEEP,CLK48,CLK24,CLK12,CLK6,IO_MODE,BITBANG_WR,BITBANG_RD,SPECIAL}", 0),
CFG_STR_LIST("cbus3", "{TXDEN,PWREN,RXLED,TXLED,TXRXLED,SLEEP,CLK48,CLK24,CLK12,CLK6,IO_MODE,BITBANG_WR,BITBANG_RD,SPECIAL}", 0),
CFG_STR_LIST("cbus4", "{TXDEN,PWRON,RXLED,TXLED,TX_RX_LED,SLEEP,CLK48,CLK24,CLK12,CLK6}", 0),
CFG_BOOL("invert_txd", cfg_false, 0),
CFG_BOOL("invert_rxd", cfg_false, 0),
CFG_BOOL("invert_rts", cfg_false, 0),
CFG_BOOL("invert_cts", cfg_false, 0),
CFG_BOOL("invert_dtr", cfg_false, 0),
CFG_BOOL("invert_dsr", cfg_false, 0),
CFG_BOOL("invert_dcd", cfg_false, 0),
CFG_BOOL("invert_ri", cfg_false, 0),
CFG_END()
};
cfg_t *cfg;
/*
normal variables
*/
int _read = 0, _erase = 0, _flash = 0;
int my_eeprom_size = 0;
unsigned char *eeprom_buf = NULL;
char *filename;
int size_check;
int i, argc_filename;
FILE *fp;
struct ftdi_context *ftdi = NULL;
printf("\nFTDI eeprom generator v%s\n", EEPROM_VERSION_STRING);
printf ("(c) Intra2net AG and the libftdi developers <opensource@intra2net.com>\n");
if (argc != 2 && argc != 3)
{
printf("Syntax: %s [commands] config-file\n", argv[0]);
printf("Valid commands:\n");
printf("--read-eeprom Read eeprom and write to -filename- from config-file\n");
printf("--erase-eeprom Erase eeprom\n");
printf("--flash-eeprom Flash eeprom\n");
exit (-1);
}
if (argc == 3)
{
if (strcmp(argv[1], "--read-eeprom") == 0)
_read = 1;
else if (strcmp(argv[1], "--erase-eeprom") == 0)
_erase = 1;
else if (strcmp(argv[1], "--flash-eeprom") == 0)
_flash = 1;
else
{
printf ("Can't open configuration file\n");
exit (-1);
}
argc_filename = 2;
}
else
{
argc_filename = 1;
}
if ((fp = fopen(argv[argc_filename], "r")) == NULL)
{
printf ("Can't open configuration file\n");
exit (-1);
}
fclose (fp);
cfg = cfg_init(opts, 0);
cfg_parse(cfg, argv[argc_filename]);
filename = cfg_getstr(cfg, "filename");
if (cfg_getbool(cfg, "self_powered") && cfg_getint(cfg, "max_power") > 0)
printf("Hint: Self powered devices should have a max_power setting of 0.\n");
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "Failed to allocate ftdi structure :%s \n",
ftdi_get_error_string(ftdi));
return EXIT_FAILURE;
}
if (_read > 0 || _erase > 0 || _flash > 0)
{
int vendor_id = cfg_getint(cfg, "vendor_id");
int product_id = cfg_getint(cfg, "product_id");
i = ftdi_usb_open(ftdi, vendor_id, product_id);
if (i != 0)
{
int default_pid = cfg_getint(cfg, "default_pid");
printf("Unable to find FTDI devices under given vendor/product id: 0x%X/0x%X\n", vendor_id, product_id);
printf("Error code: %d (%s)\n", i, ftdi_get_error_string(ftdi));
printf("Retrying with default FTDI pid=%#04x.\n", default_pid);
i = ftdi_usb_open(ftdi, 0x0403, default_pid);
if (i != 0)
{
printf("Error: %s\n", ftdi->error_str);
exit (-1);
}
}
}
ftdi_eeprom_initdefaults (ftdi, cfg_getstr(cfg, "manufacturer"),
cfg_getstr(cfg, "product"),
cfg_getstr(cfg, "serial"));
printf("FTDI read eeprom: %d\n", ftdi_read_eeprom(ftdi));
eeprom_get_value(ftdi, CHIP_SIZE, &my_eeprom_size);
// TODO: Do we know the eeprom size already?
printf("EEPROM size: %d\n", my_eeprom_size);
if (_read > 0)
{
ftdi_eeprom_decode(ftdi, 0 /* debug: 1 */);
eeprom_buf = malloc(my_eeprom_size);
ftdi_get_eeprom_buf(ftdi, eeprom_buf, my_eeprom_size);
if (eeprom_buf == NULL)
{
fprintf(stderr, "Malloc failed, aborting\n");
goto cleanup;
}
if (filename != NULL && strlen(filename) > 0)
{
FILE *fp = fopen (filename, "wb");
fwrite (eeprom_buf, 1, my_eeprom_size, fp);
fclose (fp);
}
else
{
printf("Warning: Not writing eeprom, you must supply a valid filename\n");
}
goto cleanup;
}
eeprom_set_value(ftdi, VENDOR_ID, cfg_getint(cfg, "vendor_id"));
eeprom_set_value(ftdi, PRODUCT_ID, cfg_getint(cfg, "product_id"));
eeprom_set_value(ftdi, SELF_POWERED, cfg_getbool(cfg, "self_powered"));
eeprom_set_value(ftdi, REMOTE_WAKEUP, cfg_getbool(cfg, "remote_wakeup"));
eeprom_set_value(ftdi, MAX_POWER, cfg_getint(cfg, "max_power"));
eeprom_set_value(ftdi, IN_IS_ISOCHRONOUS, cfg_getbool(cfg, "in_is_isochronous"));
eeprom_set_value(ftdi, OUT_IS_ISOCHRONOUS, cfg_getbool(cfg, "out_is_isochronous"));
eeprom_set_value(ftdi, SUSPEND_PULL_DOWNS, cfg_getbool(cfg, "suspend_pull_downs"));
eeprom_set_value(ftdi, USE_SERIAL, cfg_getbool(cfg, "use_serial"));
eeprom_set_value(ftdi, USE_USB_VERSION, cfg_getbool(cfg, "change_usb_version"));
eeprom_set_value(ftdi, USB_VERSION, cfg_getint(cfg, "usb_version"));
eeprom_set_value(ftdi, HIGH_CURRENT, cfg_getbool(cfg, "high_current"));
eeprom_set_value(ftdi, CBUS_FUNCTION_0, str_to_cbus(cfg_getstr(cfg, "cbus0"), 13));
eeprom_set_value(ftdi, CBUS_FUNCTION_1, str_to_cbus(cfg_getstr(cfg, "cbus1"), 13));
eeprom_set_value(ftdi, CBUS_FUNCTION_2, str_to_cbus(cfg_getstr(cfg, "cbus2"), 13));
eeprom_set_value(ftdi, CBUS_FUNCTION_3, str_to_cbus(cfg_getstr(cfg, "cbus3"), 13));
eeprom_set_value(ftdi, CBUS_FUNCTION_4, str_to_cbus(cfg_getstr(cfg, "cbus4"), 9));
int invert = 0;
if (cfg_getbool(cfg, "invert_rxd")) invert |= INVERT_RXD;
if (cfg_getbool(cfg, "invert_txd")) invert |= INVERT_TXD;
if (cfg_getbool(cfg, "invert_rts")) invert |= INVERT_RTS;
if (cfg_getbool(cfg, "invert_cts")) invert |= INVERT_CTS;
if (cfg_getbool(cfg, "invert_dtr")) invert |= INVERT_DTR;
if (cfg_getbool(cfg, "invert_dsr")) invert |= INVERT_DSR;
if (cfg_getbool(cfg, "invert_dcd")) invert |= INVERT_DCD;
if (cfg_getbool(cfg, "invert_ri")) invert |= INVERT_RI;
eeprom_set_value(ftdi, INVERT, invert);
eeprom_set_value(ftdi, CHANNEL_A_DRIVER, DRIVER_VCP);
eeprom_set_value(ftdi, CHANNEL_B_DRIVER, DRIVER_VCP);
eeprom_set_value(ftdi, CHANNEL_C_DRIVER, DRIVER_VCP);
eeprom_set_value(ftdi, CHANNEL_D_DRIVER, DRIVER_VCP);
eeprom_set_value(ftdi, CHANNEL_A_RS485, 0);
eeprom_set_value(ftdi, CHANNEL_B_RS485, 0);
eeprom_set_value(ftdi, CHANNEL_C_RS485, 0);
eeprom_set_value(ftdi, CHANNEL_D_RS485, 0);
if (_erase > 0)
{
printf("FTDI erase eeprom: %d\n", ftdi_erase_eeprom(ftdi));
}
size_check = ftdi_eeprom_build(ftdi);
if (size_check == -1)
{
printf ("Sorry, the eeprom can only contain 128 bytes (100 bytes for your strings).\n");
printf ("You need to short your string by: %d bytes\n", size_check);
goto cleanup;
} else if (size_check < 0) {
printf ("ftdi_eeprom_build(): error: %d\n", size_check);
}
else
{
printf ("Used eeprom space: %d bytes\n", my_eeprom_size-size_check);
}
if (_flash > 0)
{
if (cfg_getbool(cfg, "flash_raw"))
{
if (filename != NULL && strlen(filename) > 0)
{
eeprom_buf = malloc(my_eeprom_size);
FILE *fp = fopen(filename, "rb");
fread(eeprom_buf, 1, my_eeprom_size, fp);
fclose(fp);
ftdi_set_eeprom_buf(ftdi, eeprom_buf, my_eeprom_size);
}
}
printf ("FTDI write eeprom: %d\n", ftdi_write_eeprom(ftdi));
}
// Write to file?
if (filename != NULL && strlen(filename) > 0 && !cfg_getbool(cfg, "flash_raw"))
{
fp = fopen(filename, "w");
if (fp == NULL)
{
printf ("Can't write eeprom file.\n");
exit (-1);
}
else
printf ("Writing to file: %s\n", filename);
if (eeprom_buf == NULL)
eeprom_buf = malloc(my_eeprom_size);
ftdi_get_eeprom_buf(ftdi, eeprom_buf, my_eeprom_size);
fwrite(eeprom_buf, my_eeprom_size, 1, fp);
fclose(fp);
}
cleanup:
if (eeprom_buf)
free(eeprom_buf);
if (_read > 0 || _erase > 0 || _flash > 0)
{
printf("FTDI close: %d\n", ftdi_usb_close(ftdi));
}
ftdi_deinit (ftdi);
ftdi_free (ftdi);
cfg_free(cfg);
printf("\n");
return 0;
}

80
lib/libftdi/ftdipp/CMakeLists.txt Normal file
View File

@@ -0,0 +1,80 @@
# Check
set(FTDI_BUILD_CPP False PARENT_SCOPE)
option(FTDIPP "Build C++ binding library libftdi++" ON)
if (FTDIPP)
if(Boost_FOUND)
# Includes
include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_SOURCE_DIR}/src)
include_directories(${Boost_INCLUDE_DIRS})
# Targets
set(cpp_sources ftdi.cpp)
set(cpp_headers ftdi.hpp)
set(FTDI_BUILD_CPP True PARENT_SCOPE)
message(STATUS "Building libftdi++")
# Shared library
add_library(ftdipp SHARED ${cpp_sources})
math(EXPR VERSION_FIXUP "${MAJOR_VERSION} + 1") # Compatiblity with previous releases
set_target_properties(ftdipp PROPERTIES VERSION ${VERSION_FIXUP}.${MINOR_VERSION}.0 SOVERSION 2)
# Static library
add_library(ftdipp-static STATIC ${cpp_sources})
set_target_properties(ftdipp-static PROPERTIES OUTPUT_NAME "ftdipp")
# Prevent clobbering each other during the build
set_target_properties(ftdipp PROPERTIES CLEAN_DIRECT_OUTPUT 1)
set_target_properties(ftdipp-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
# Dependencies
target_link_libraries(ftdipp ftdi ${LIBUSB_LIBRARIES} ${BOOST_LIBRARIES})
# Install
if(${UNIX})
install( TARGETS ftdipp
LIBRARY DESTINATION lib${LIB_SUFFIX}
COMPONENT sharedlibs
)
install( TARGETS ftdipp-static
ARCHIVE DESTINATION lib${LIB_SUFFIX}
COMPONENT staticlibs
)
install( FILES ${cpp_headers}
DESTINATION include/${PROJECT_NAME}
COMPONENT headers
)
endif(${UNIX})
if(${WIN32})
install( TARGETS ftdipp
DESTINATION bin
COMPONENT sharedlibs
)
install( TARGETS ftdipp-static
DESTINATION bin
COMPONENT staticlibs
)
install( FILES ${cpp_headers}
DESTINATION include/${PROJECT_NAME}
COMPONENT headers
)
endif(${WIN32})
else(Boost_FOUND)
message(STATUS "Boost not found, won't build libftdi++")
endif(Boost_FOUND)
else(FTDIPP)
message(STATUS "Not building libftdi++")
endif(FTDIPP)

632
lib/libftdi/ftdipp/ftdi.cpp Normal file
View File

@@ -0,0 +1,632 @@
/***************************************************************************
ftdi.cpp - C++ wraper for libftdi
-------------------
begin : Mon Oct 13 2008
copyright : (C) 2008 by Marek Vavruša
email : opensource@intra2net.com and marek@vavrusa.com
***************************************************************************/
/*
Copyright (C) 2008 by Marek Vavruša
The software in this package is distributed under the GNU General
Public License version 2 (with a special exception described below).
A copy of GNU General Public License (GPL) is included in this distribution,
in the file COPYING.GPL.
As a special exception, if other files instantiate templates or use macros
or inline functions from this file, or you compile this file and link it
with other works to produce a work based on this file, this file
does not by itself cause the resulting work to be covered
by the GNU General Public License.
However the source code for this file must still be made available
in accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work based
on this file might be covered by the GNU General Public License.
*/
#include "ftdi.hpp"
#include "ftdi_i.h"
#include "ftdi.h"
namespace Ftdi
{
class Context::Private
{
public:
Private()
: open(false), ftdi(0), dev(0)
{
ftdi = ftdi_new();
}
~Private()
{
if (open)
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
}
bool open;
struct ftdi_context* ftdi;
struct libusb_device* dev;
std::string vendor;
std::string description;
std::string serial;
};
/*! \brief Constructor.
*/
Context::Context()
: d( new Private() )
{
}
/*! \brief Destructor.
*/
Context::~Context()
{
}
bool Context::is_open()
{
return d->open;
}
int Context::open(int vendor, int product)
{
// Open device
int ret = ftdi_usb_open(d->ftdi, vendor, product);
if (ret < 0)
return ret;
return get_strings_and_reopen();
}
int Context::open(int vendor, int product, const std::string& description, const std::string& serial, unsigned int index)
{
// translate empty strings to NULL
// -> do not use them to find the device (vs. require an empty string to be set in the EEPROM)
const char* c_description=NULL;
const char* c_serial=NULL;
if (!description.empty())
c_description=description.c_str();
if (!serial.empty())
c_serial=serial.c_str();
int ret = ftdi_usb_open_desc_index(d->ftdi, vendor, product, c_description, c_serial, index);
if (ret < 0)
return ret;
return get_strings_and_reopen();
}
int Context::open(const std::string& description)
{
int ret = ftdi_usb_open_string(d->ftdi, description.c_str());
if (ret < 0)
return ret;
return get_strings_and_reopen();
}
int Context::open(struct libusb_device *dev)
{
if (dev != 0)
d->dev = dev;
if (d->dev == 0)
return -1;
return get_strings_and_reopen();
}
int Context::close()
{
d->open = false;
d->dev = 0;
return ftdi_usb_close(d->ftdi);
}
int Context::reset()
{
return ftdi_usb_reset(d->ftdi);
}
int Context::flush(int mask)
{
int ret = 1;
if (mask & Input)
ret &= ftdi_usb_purge_rx_buffer(d->ftdi);
if (mask & Output)
ret &= ftdi_usb_purge_tx_buffer(d->ftdi);
return ret;
}
int Context::set_interface(enum ftdi_interface interface)
{
return ftdi_set_interface(d->ftdi, interface);
}
void Context::set_usb_device(struct libusb_device_handle *dev)
{
ftdi_set_usbdev(d->ftdi, dev);
d->dev = libusb_get_device(dev);
}
int Context::set_baud_rate(int baudrate)
{
return ftdi_set_baudrate(d->ftdi, baudrate);
}
int Context::set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
{
return ftdi_set_line_property(d->ftdi, bits, sbit, parity);
}
int Context::set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, enum ftdi_break_type break_type)
{
return ftdi_set_line_property2(d->ftdi, bits, sbit, parity, break_type);
}
int Context::read(unsigned char *buf, int size)
{
return ftdi_read_data(d->ftdi, buf, size);
}
int Context::set_read_chunk_size(unsigned int chunksize)
{
return ftdi_read_data_set_chunksize(d->ftdi, chunksize);
}
int Context::read_chunk_size()
{
unsigned chunk = -1;
if (ftdi_read_data_get_chunksize(d->ftdi, &chunk) < 0)
return -1;
return chunk;
}
int Context::write(unsigned char *buf, int size)
{
return ftdi_write_data(d->ftdi, buf, size);
}
int Context::set_write_chunk_size(unsigned int chunksize)
{
return ftdi_write_data_set_chunksize(d->ftdi, chunksize);
}
int Context::write_chunk_size()
{
unsigned chunk = -1;
if (ftdi_write_data_get_chunksize(d->ftdi, &chunk) < 0)
return -1;
return chunk;
}
int Context::set_flow_control(int flowctrl)
{
return ftdi_setflowctrl(d->ftdi, flowctrl);
}
int Context::set_modem_control(int mask)
{
int dtr = 0, rts = 0;
if (mask & Dtr)
dtr = 1;
if (mask & Rts)
rts = 1;
return ftdi_setdtr_rts(d->ftdi, dtr, rts);
}
int Context::set_dtr(bool state)
{
return ftdi_setdtr(d->ftdi, state);
}
int Context::set_rts(bool state)
{
return ftdi_setrts(d->ftdi, state);
}
int Context::set_latency(unsigned char latency)
{
return ftdi_set_latency_timer(d->ftdi, latency);
}
unsigned Context::latency()
{
unsigned char latency = 0;
ftdi_get_latency_timer(d->ftdi, &latency);
return latency;
}
unsigned short Context::poll_modem_status()
{
unsigned short status = 0;
ftdi_poll_modem_status(d->ftdi, &status);
return status;
}
int Context::set_event_char(unsigned char eventch, unsigned char enable)
{
return ftdi_set_event_char(d->ftdi, eventch, enable);
}
int Context::set_error_char(unsigned char errorch, unsigned char enable)
{
return ftdi_set_error_char(d->ftdi, errorch, enable);
}
int Context::set_bitmode(unsigned char bitmask, unsigned char mode)
{
return ftdi_set_bitmode(d->ftdi, bitmask, mode);
}
int Context::set_bitmode(unsigned char bitmask, enum ftdi_mpsse_mode mode)
{
return ftdi_set_bitmode(d->ftdi, bitmask, mode);
}
int Context::bitbang_disable()
{
return ftdi_disable_bitbang(d->ftdi);
}
int Context::read_pins(unsigned char *pins)
{
return ftdi_read_pins(d->ftdi, pins);
}
char* Context::error_string()
{
return ftdi_get_error_string(d->ftdi);
}
int Context::get_strings()
{
// Prepare buffers
char vendor[512], desc[512], serial[512];
int ret = ftdi_usb_get_strings(d->ftdi, d->dev, vendor, 512, desc, 512, serial, 512);
if (ret < 0)
return -1;
d->vendor = vendor;
d->description = desc;
d->serial = serial;
return 1;
}
int Context::get_strings_and_reopen()
{
if ( d->dev == 0 )
{
d->dev = libusb_get_device(d->ftdi->usb_dev);
}
// Get device strings (closes device)
int ret=get_strings();
if (ret < 0)
{
d->open = 0;
return ret;
}
// Reattach device
ret = ftdi_usb_open_dev(d->ftdi, d->dev);
d->open = (ret >= 0);
return ret;
}
/*! \brief Device strings properties.
*/
const std::string& Context::vendor()
{
return d->vendor;
}
/*! \brief Device strings properties.
*/
const std::string& Context::description()
{
return d->description;
}
/*! \brief Device strings properties.
*/
const std::string& Context::serial()
{
return d->serial;
}
void Context::set_context(struct ftdi_context* context)
{
ftdi_free(d->ftdi);
d->ftdi = context;
}
void Context::set_usb_device(struct libusb_device *dev)
{
d->dev = dev;
}
struct ftdi_context* Context::context()
{
return d->ftdi;
}
class Eeprom::Private
{
public:
Private()
: context(0)
{}
struct ftdi_eeprom eeprom;
struct ftdi_context* context;
};
Eeprom::Eeprom(Context* parent)
: d ( new Private() )
{
d->context = parent->context();
}
Eeprom::~Eeprom()
{
}
int Eeprom::init_defaults(char* manufacturer, char *product, char * serial)
{
return ftdi_eeprom_initdefaults(d->context, manufacturer, product, serial);
}
int Eeprom::chip_id(unsigned int *chipid)
{
return ftdi_read_chipid(d->context, chipid);
}
int Eeprom::build(unsigned char *output)
{
return ftdi_eeprom_build(d->context);
}
int Eeprom::read(unsigned char *eeprom)
{
return ftdi_read_eeprom(d->context);
}
int Eeprom::write(unsigned char *eeprom)
{
return ftdi_write_eeprom(d->context);
}
int Eeprom::read_location(int eeprom_addr, unsigned short *eeprom_val)
{
return ftdi_read_eeprom_location(d->context, eeprom_addr, eeprom_val);
}
int Eeprom::write_location(int eeprom_addr, unsigned short eeprom_val)
{
return ftdi_write_eeprom_location(d->context, eeprom_addr, eeprom_val);
}
int Eeprom::erase()
{
return ftdi_erase_eeprom(d->context);
}
class List::Private
{
public:
Private(struct ftdi_device_list* _devlist)
: devlist(_devlist)
{}
~Private()
{
if(devlist)
ftdi_list_free(&devlist);
}
std::list<Context> list;
struct ftdi_device_list* devlist;
};
List::List(struct ftdi_device_list* devlist)
: d( new Private(devlist) )
{
if (devlist != 0)
{
// Iterate list
for (; devlist != 0; devlist = devlist->next)
{
Context c;
c.set_usb_device(devlist->dev);
c.get_strings();
d->list.push_back(c);
}
}
}
List::~List()
{
}
/**
* Return begin iterator for accessing the contained list elements
* @return Iterator
*/
List::iterator List::begin()
{
return d->list.begin();
}
/**
* Return end iterator for accessing the contained list elements
* @return Iterator
*/
List::iterator List::end()
{
return d->list.end();
}
/**
* Return begin iterator for accessing the contained list elements
* @return Const iterator
*/
List::const_iterator List::begin() const
{
return d->list.begin();
}
/**
* Return end iterator for accessing the contained list elements
* @return Const iterator
*/
List::const_iterator List::end() const
{
return d->list.end();
}
/**
* Return begin reverse iterator for accessing the contained list elements
* @return Reverse iterator
*/
List::reverse_iterator List::rbegin()
{
return d->list.rbegin();
}
/**
* Return end reverse iterator for accessing the contained list elements
* @return Reverse iterator
*/
List::reverse_iterator List::rend()
{
return d->list.rend();
}
/**
* Return begin reverse iterator for accessing the contained list elements
* @return Const reverse iterator
*/
List::const_reverse_iterator List::rbegin() const
{
return d->list.rbegin();
}
/**
* Return end reverse iterator for accessing the contained list elements
* @return Const reverse iterator
*/
List::const_reverse_iterator List::rend() const
{
return d->list.rend();
}
/**
* Get number of elements stored in the list
* @return Number of elements
*/
List::ListType::size_type List::size() const
{
return d->list.size();
}
/**
* Check if list is empty
* @return True if empty, false otherwise
*/
bool List::empty() const
{
return d->list.empty();
}
/**
* Removes all elements. Invalidates all iterators.
* Do it in a non-throwing way and also make
* sure we really free the allocated memory.
*/
void List::clear()
{
ListType().swap(d->list);
// Free device list
if (d->devlist)
{
ftdi_list_free(&d->devlist);
d->devlist = 0;
}
}
/**
* Appends a copy of the element as the new last element.
* @param element Value to copy and append
*/
void List::push_back(const Context& element)
{
d->list.push_back(element);
}
/**
* Adds a copy of the element as the new first element.
* @param element Value to copy and add
*/
void List::push_front(const Context& element)
{
d->list.push_front(element);
}
/**
* Erase one element pointed by iterator
* @param pos Element to erase
* @return Position of the following element (or end())
*/
List::iterator List::erase(iterator pos)
{
return d->list.erase(pos);
}
/**
* Erase a range of elements
* @param beg Begin of range
* @param end End of range
* @return Position of the element after the erased range (or end())
*/
List::iterator List::erase(iterator beg, iterator end)
{
return d->list.erase(beg, end);
}
List* List::find_all(int vendor, int product)
{
struct ftdi_device_list* dlist = 0;
struct ftdi_context ftdi;
ftdi_init(&ftdi);
ftdi_usb_find_all(&ftdi, &dlist, vendor, product);
ftdi_deinit(&ftdi);
return new List(dlist);
}
}

217
lib/libftdi/ftdipp/ftdi.hpp Normal file
View File

@@ -0,0 +1,217 @@
/***************************************************************************
ftdi.hpp - C++ wrapper for libftdi
-------------------
begin : Mon Oct 13 2008
copyright : (C) 2008 by Marek Vavruša
email : opensource@intra2net.com and marek@vavrusa.com
***************************************************************************/
/*
Copyright (C) 2008 by Marek Vavruša
The software in this package is distributed under the GNU General
Public License version 2 (with a special exception described below).
A copy of GNU General Public License (GPL) is included in this distribution,
in the file COPYING.GPL.
As a special exception, if other files instantiate templates or use macros
or inline functions from this file, or you compile this file and link it
with other works to produce a work based on this file, this file
does not by itself cause the resulting work to be covered
by the GNU General Public License.
However the source code for this file must still be made available
in accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work based
on this file might be covered by the GNU General Public License.
*/
#ifndef __libftdi_hpp__
#define __libftdi_hpp__
#include <list>
#include <string>
#include <boost/shared_ptr.hpp>
#include <ftdi.h>
namespace Ftdi
{
/* Forward declarations*/
class List;
class Eeprom;
/*! \brief FTDI device context.
* Represents single FTDI device context.
*/
class Context
{
/* Friends */
friend class Eeprom;
friend class List;
public:
/*! \brief Direction flags for flush().
*/
enum Direction
{
Input,
Output
};
/*! \brief Modem control flags.
*/
enum ModemCtl
{
Dtr,
Rts
};
/* Constructor, Destructor */
Context();
~Context();
/* Properties */
Eeprom* eeprom();
const std::string& vendor();
const std::string& description();
const std::string& serial();
/* Device manipulators */
bool is_open();
int open(struct libusb_device *dev = 0);
int open(int vendor, int product);
int open(int vendor, int product, const std::string& description, const std::string& serial = std::string(), unsigned int index=0);
int open(const std::string& description);
int close();
int reset();
int flush(int mask = Input|Output);
int set_interface(enum ftdi_interface interface);
void set_usb_device(struct libusb_device_handle *dev);
/* Line manipulators */
int set_baud_rate(int baudrate);
int set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity);
int set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, enum ftdi_break_type break_type);
/* I/O */
int read(unsigned char *buf, int size);
int write(unsigned char *buf, int size);
int set_read_chunk_size(unsigned int chunksize);
int set_write_chunk_size(unsigned int chunksize);
int read_chunk_size();
int write_chunk_size();
/* Async IO
TODO: should wrap?
int writeAsync(unsigned char *buf, int size);
void asyncComplete(int wait_for_more);
*/
/* Flow control */
int set_event_char(unsigned char eventch, unsigned char enable);
int set_error_char(unsigned char errorch, unsigned char enable);
int set_flow_control(int flowctrl);
int set_modem_control(int mask = Dtr|Rts);
int set_latency(unsigned char latency);
int set_dtr(bool state);
int set_rts(bool state);
unsigned short poll_modem_status();
unsigned latency();
/* BitBang mode */
int set_bitmode(unsigned char bitmask, unsigned char mode);
int set_bitmode(unsigned char bitmask, enum ftdi_mpsse_mode mode);
int bitbang_disable();
int read_pins(unsigned char *pins);
/* Misc */
char* error_string();
protected:
int get_strings();
int get_strings_and_reopen();
/* Properties */
struct ftdi_context* context();
void set_context(struct ftdi_context* context);
void set_usb_device(struct libusb_device *dev);
private:
class Private;
boost::shared_ptr<Private> d;
};
/*! \brief Device EEPROM.
*/
class Eeprom
{
public:
Eeprom(Context* parent);
~Eeprom();
int init_defaults(char *manufacturer, char* product, char * serial);
int chip_id(unsigned int *chipid);
int build(unsigned char *output);
int read(unsigned char *eeprom);
int write(unsigned char *eeprom);
int read_location(int eeprom_addr, unsigned short *eeprom_val);
int write_location(int eeprom_addr, unsigned short eeprom_val);
int erase();
private:
class Private;
boost::shared_ptr<Private> d;
};
/*! \brief Device list.
*/
class List
{
public:
List(struct ftdi_device_list* devlist = 0);
~List();
static List* find_all(int vendor, int product);
/// List type storing "Context" objects
typedef std::list<Context> ListType;
/// Iterator type for the container
typedef ListType::iterator iterator;
/// Const iterator type for the container
typedef ListType::const_iterator const_iterator;
/// Reverse iterator type for the container
typedef ListType::reverse_iterator reverse_iterator;
/// Const reverse iterator type for the container
typedef ListType::const_reverse_iterator const_reverse_iterator;
iterator begin();
iterator end();
const_iterator begin() const;
const_iterator end() const;
reverse_iterator rbegin();
reverse_iterator rend();
const_reverse_iterator rbegin() const;
const_reverse_iterator rend() const;
ListType::size_type size() const;
bool empty() const;
void clear();
void push_back(const Context& element);
void push_front(const Context& element);
iterator erase(iterator pos);
iterator erase(iterator beg, iterator end);
private:
class Private;
boost::shared_ptr<Private> d;
};
}
#endif

3
lib/libftdi/libftdi-1.0.kdev4 Normal file
View File

@@ -0,0 +1,3 @@
[Project]
Manager=KDevCMakeManager
Name=libftdi-1.0

79
lib/libftdi/libftdi-config.in Normal file
View File

@@ -0,0 +1,79 @@
#!/bin/sh
prefix=@prefix@
exec_prefix=@exec_prefix@
exec_prefix_set=no
usage()
{
cat <<EOF
Usage: libftdi-config [OPTIONS] [LIBRARIES]
Options:
[--prefix[=DIR]]
[--exec-prefix[=DIR]]
[--version]
[--libs]
[--cflags]
EOF
exit $1
}
if test $# -eq 0; then
usage 1 1>&2
fi
while test $# -gt 0; do
case "$1" in
-*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
*) optarg= ;;
esac
case $1 in
--prefix=*)
prefix=$optarg
if test $exec_prefix_set = no ; then
exec_prefix=$optarg
fi
;;
--prefix)
echo_prefix=yes
;;
--exec-prefix=*)
exec_prefix=$optarg
exec_prefix_set=yes
;;
--exec-prefix)
echo_exec_prefix=yes
;;
--version)
echo @VERSION@
exit 0
;;
--cflags)
if test "@includedir@" != /usr/include ; then
includes="-I@includedir@"
fi
echo_cflags=yes
;;
--libs)
echo_libs=yes
;;
*)
usage 1 1>&2
;;
esac
shift
done
if test "$echo_prefix" = "yes"; then
echo $prefix
fi
if test "$echo_exec_prefix" = "yes"; then
echo $exec_prefix
fi
if test "$echo_cflags" = "yes"; then
echo $includes
fi
if test "$echo_libs" = "yes"; then
echo -L@libdir@ -lftdi @LIBS@
fi

25
lib/libftdi/libftdi.gyp Normal file
View File

@@ -0,0 +1,25 @@
{
'targets': [
{
'target_name': 'libftdi',
'type': 'static_library',
'dependencies': [
'../libusb/libusb.gyp:libusb'
],
'sources': [
'src/ftdi.c',
'src/ftdi_stream.c'
],
'include_dirs': [
'.',
'src'
],
'direct_dependent_settings': {
'include_dirs': [
'src',
],
},
}
]
}

28
lib/libftdi/libftdi.lnt Normal file
View File

@@ -0,0 +1,28 @@
// PC-Lint 9.00 settings
--iz:\usr\include\libusb-1.0
--i../src
--i../ftdipp
-emacro(527, ftdi_error_return) // ignore "unreachable code"
-emacro(717, ftdi_error_return)
-epu // Pointer to unsigned/signed of the same type is ok
+fie // Allow enum to int conversion
-ecall(534, usb_close) // silence ignored return value from usb_close
// Disable bogus BOOST warnings
-emacro(58,BOOST_ASSERT)
-emacro(506, BOOST_FOREACH)
-emacro(666, BOOST_FOREACH)
-esym(666, BOOST_FOREACH)
-emacro(1023, BOOST_FOREACH)
-emacro(1793, BOOST_FOREACH)
-esym(665, BOOST_FOREACH)
-e123
// Don't complain we are running with -wlib(0)
// as the boost headers can't be parsed properly
-estring(686, -wlib(0))
-wlib(0)

14
lib/libftdi/libftdi.pc.in Normal file
View File

@@ -0,0 +1,14 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
libusb_libs=@LIBUSB_1_0_LIBS@
libusb_cflags=@LIBUSB_1_0_CFLAGS@
Name: libftdi
Description: Library to program and control the FTDI USB controller
Requires:
Version: @VERSION@
Libs: -L${libdir} -lftdi ${libusb_libs}
Cflags: -I${includedir} ${libusb_cflags}

67
lib/libftdi/libftdi.spec.in Normal file
View File

@@ -0,0 +1,67 @@
Summary: Library to program and control the FTDI USB controller
Name: libftdi
Version: @VERSION@
Release: 1
License: LGPL for libftdi and GPLv2+linking exception for the C++ wrapper
Group: System Environment/Libraries
Vendor: Intra2net AG
Source: http://www.intra2net.com/en/developer/libftdi/download/%{name}-%{version}.tar.gz
Buildroot: /tmp/%{name}-%{version}-root
Requires: libusb
BuildRequires: libusb, libusb-devel, pkgconfig, doxygen
Prefix: /usr
URL: http://www.intra2net.com/en/developer/libftdi
%package devel
Summary: Header files and static libraries for libftdi
Group: Development/Libraries
Requires: libftdi = %{version}, libusb-devel
%description
Library to program and control the FTDI USB controller
%description devel
Header files and static libraries for libftdi
%prep
%setup -q
%build
PARAMS=""
./configure --prefix=%{prefix} \
--libdir=%{_libdir}
%endif
make
%install
make DESTDIR=$RPM_BUILD_ROOT install
# Remove example programs
rm -f $RPM_BUILD_ROOT/usr/bin/simple
rm -f $RPM_BUILD_ROOT/usr/bin/bitbang
rm -f $RPM_BUILD_ROOT/usr/bin/bitbang2
rm -f $RPM_BUILD_ROOT/usr/bin/bitbang_ft2232
rm -f $RPM_BUILD_ROOT/usr/bin/bitbang_cbus
rm -f $RPM_BUILD_ROOT/usr/bin/find_all
rm -f $RPM_BUILD_ROOT/usr/bin/find_all_pp
rm -f $RPM_BUILD_ROOT/usr/bin/serial_test
rm -f $RPM_BUILD_ROOT/usr/bin/baud_test
%clean
rm -fr $RPM_BUILD_ROOT
%files
%defattr(-,root,root)
%doc COPYING.LIB COPYING.GPL LICENSE
%{_libdir}/libftdi*.so*
%files devel
%defattr(-,root,root)
%doc doc/html doc/man
%{_bindir}/libftdi-config
%{prefix}/include/*.h
%{prefix}/include/*.hpp
%{_libdir}/libftdi*.*a
%{_libdir}/pkgconfig/*.pc

11
lib/libftdi/libftdipp.pc.in Normal file
View File

@@ -0,0 +1,11 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: libftdipp
Description: C++ wrapper for libftdi
Requires: libftdi
Version: @VERSION@
Libs: -L${libdir} -lftdipp
Cflags: -I${includedir}

8
lib/libftdi/packages/99-libftdi.rules Normal file
View File

@@ -0,0 +1,8 @@
# FTDI Devices: FT232BM/L/Q, FT245BM/L/Q, FT232RL/Q, FT245RL/Q, VNC1L with VDPS Firmware
SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", MODE="0664", GROUP="plugdev"
# FTDI Devices: FT2232C/D/L, FT2232HL/Q
SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6010", MODE="0664", GROUP="plugdev"
# FTDI Devices: FT4232HL/Q
SUBSYSTEM=="usb", ENV{DEVTYPE}=="usb_device", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6011", MODE="0664", GROUP="plugdev"

21
lib/libftdi/packages/CMakeLists.txt Normal file
View File

@@ -0,0 +1,21 @@
# Debian
if("${PACKAGE}" STREQUAL "Debian")
# Settings
set(REVISION 0)
set(CPACK_GENERATOR "DEB" PARENT_SCOPE)
set(CPACK_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION}-${REVISION} PARENT_SCOPE)
# Dependencies
set(CPACK_DEBIAN_PACKAGE_DEPENDS "libusb-0.1-4" PARENT_SCOPE)
set(DEBIAN_PACKAGE_BUILDS_DEPENDS "cmake, libusb-dev" PARENT_SCOPE)
# Bundles
message("-- Installing udev rules to /etc/udev/rules.d")
install(FILES 99-libftdi.rules
DESTINATION /etc/udev/rules.d)
endif("${PACKAGE}" STREQUAL "Debian")
# General RPM rules
set(CPACK_RPM_PACKAGE_DEPENDS "libusb" PARENT_SCOPE)

77
lib/libftdi/src/CMakeLists.txt Normal file
View File

@@ -0,0 +1,77 @@
# Includes
include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
)
# Version information
set(SNAPSHOT_VERSION "unknown")
execute_process(COMMAND git describe
OUTPUT_VARIABLE GIT_DESCRIBE_OUTPUT
RESULT_VARIABLE GIT_DESCRIBE_RESULT
OUTPUT_STRIP_TRAILING_WHITESPACE
)
if(${GIT_DESCRIBE_RESULT} STREQUAL 0)
set(SNAPSHOT_VERSION ${GIT_DESCRIBE_OUTPUT})
endif(${GIT_DESCRIBE_RESULT} STREQUAL 0)
message(STATUS "Detected git snapshot version: ${SNAPSHOT_VERSION}")
configure_file(ftdi_version_i.h.in "${CMAKE_CURRENT_BINARY_DIR}/ftdi_version_i.h" @ONLY)
# Targets
set(c_sources ftdi.c ftdi_stream.c)
set(c_headers ftdi.h)
add_library(ftdi SHARED ${c_sources})
math(EXPR VERSION_FIXUP "${MAJOR_VERSION} + 1") # Compatiblity with previous releases
set_target_properties(ftdi PROPERTIES VERSION ${VERSION_FIXUP}.${MINOR_VERSION}.0 SOVERSION 2)
# Static library
add_library(ftdi-static STATIC ${c_sources})
set_target_properties(ftdi-static PROPERTIES OUTPUT_NAME "ftdi")
# Prevent clobbering each other during the build
set_target_properties(ftdi PROPERTIES CLEAN_DIRECT_OUTPUT 1)
set_target_properties(ftdi-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
# Dependencies
target_link_libraries(ftdi ${LIBUSB_LIBRARIES})
# Install
if(${UNIX})
install( TARGETS ftdi
LIBRARY DESTINATION lib${LIB_SUFFIX}
COMPONENT sharedlibs
)
install( TARGETS ftdi-static
ARCHIVE DESTINATION lib${LIB_SUFFIX}
COMPONENT staticlibs
)
install( FILES ${c_headers}
DESTINATION include/${PROJECT_NAME}
COMPONENT headers
)
endif(${UNIX})
if(${WIN32})
install( TARGETS ftdi
DESTINATION bin
COMPONENT sharedlibs
)
install( TARGETS ftdi-static
DESTINATION bin
COMPONENT staticlibs
)
install( FILES ${c_headers}
DESTINATION include/${PROJECT_NAME}
COMPONENT headers
)
endif(${WIN32})

4122
lib/libftdi/src/ftdi.c Normal file
View File

File diff suppressed because it is too large Load Diff

530
lib/libftdi/src/ftdi.h Normal file
View File

@@ -0,0 +1,530 @@
/***************************************************************************
ftdi.h - description
-------------------
begin : Fri Apr 4 2003
copyright : (C) 2003-2011 by Intra2net AG and the libftdi developers
email : opensource@intra2net.com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License *
* version 2.1 as published by the Free Software Foundation; *
* *
***************************************************************************/
#ifndef __libftdi_h__
#define __libftdi_h__
#include <libusb.h>
/** FTDI chip type */
enum ftdi_chip_type { TYPE_AM=0, TYPE_BM=1, TYPE_2232C=2, TYPE_R=3, TYPE_2232H=4, TYPE_4232H=5, TYPE_232H=6 };
/** Parity mode for ftdi_set_line_property() */
enum ftdi_parity_type { NONE=0, ODD=1, EVEN=2, MARK=3, SPACE=4 };
/** Number of stop bits for ftdi_set_line_property() */
enum ftdi_stopbits_type { STOP_BIT_1=0, STOP_BIT_15=1, STOP_BIT_2=2 };
/** Number of bits for ftdi_set_line_property() */
enum ftdi_bits_type { BITS_7=7, BITS_8=8 };
/** Break type for ftdi_set_line_property2() */
enum ftdi_break_type { BREAK_OFF=0, BREAK_ON=1 };
/** MPSSE bitbang modes */
enum ftdi_mpsse_mode
{
BITMODE_RESET = 0x00, /**< switch off bitbang mode, back to regular serial/FIFO */
BITMODE_BITBANG= 0x01, /**< classical asynchronous bitbang mode, introduced with B-type chips */
BITMODE_MPSSE = 0x02, /**< MPSSE mode, available on 2232x chips */
BITMODE_SYNCBB = 0x04, /**< synchronous bitbang mode, available on 2232x and R-type chips */
BITMODE_MCU = 0x08, /**< MCU Host Bus Emulation mode, available on 2232x chips */
/* CPU-style fifo mode gets set via EEPROM */
BITMODE_OPTO = 0x10, /**< Fast Opto-Isolated Serial Interface Mode, available on 2232x chips */
BITMODE_CBUS = 0x20, /**< Bitbang on CBUS pins of R-type chips, configure in EEPROM before */
BITMODE_SYNCFF = 0x40, /**< Single Channel Synchronous FIFO mode, available on 2232H chips */
BITMODE_FT1284 = 0x80, /**< FT1284 mode, available on 232H chips */
};
/** Port interface for chips with multiple interfaces */
enum ftdi_interface
{
INTERFACE_ANY = 0,
INTERFACE_A = 1,
INTERFACE_B = 2,
INTERFACE_C = 3,
INTERFACE_D = 4
};
/** Automatic loading / unloading of kernel modules */
enum ftdi_module_detach_mode
{
AUTO_DETACH_SIO_MODULE = 0,
DONT_DETACH_SIO_MODULE = 1
};
/* Shifting commands IN MPSSE Mode*/
#define MPSSE_WRITE_NEG 0x01 /* Write TDI/DO on negative TCK/SK edge*/
#define MPSSE_BITMODE 0x02 /* Write bits, not bytes */
#define MPSSE_READ_NEG 0x04 /* Sample TDO/DI on negative TCK/SK edge */
#define MPSSE_LSB 0x08 /* LSB first */
#define MPSSE_DO_WRITE 0x10 /* Write TDI/DO */
#define MPSSE_DO_READ 0x20 /* Read TDO/DI */
#define MPSSE_WRITE_TMS 0x40 /* Write TMS/CS */
/* FTDI MPSSE commands */
#define SET_BITS_LOW 0x80
/*BYTE DATA*/
/*BYTE Direction*/
#define SET_BITS_HIGH 0x82
/*BYTE DATA*/
/*BYTE Direction*/
#define GET_BITS_LOW 0x81
#define GET_BITS_HIGH 0x83
#define LOOPBACK_START 0x84
#define LOOPBACK_END 0x85
#define TCK_DIVISOR 0x86
/* H Type specific commands */
#define DIS_DIV_5 0x8a
#define EN_DIV_5 0x8b
#define EN_3_PHASE 0x8c
#define DIS_3_PHASE 0x8d
#define CLK_BITS 0x8e
#define CLK_BYTES 0x8f
#define CLK_WAIT_HIGH 0x94
#define CLK_WAIT_LOW 0x95
#define EN_ADAPTIVE 0x96
#define DIS_ADAPTIVE 0x97
#define CLK_BYTES_OR_HIGH 0x9c
#define CLK_BYTES_OR_LOW 0x0d
/*FT232H specific commands */
#define DRIVE_OPEN_COLLECTOR 0x9e
/* Value Low */
/* Value HIGH */ /*rate is 12000000/((1+value)*2) */
#define DIV_VALUE(rate) (rate > 6000000)?0:((6000000/rate -1) > 0xffff)? 0xffff: (6000000/rate -1)
/* Commands in MPSSE and Host Emulation Mode */
#define SEND_IMMEDIATE 0x87
#define WAIT_ON_HIGH 0x88
#define WAIT_ON_LOW 0x89
/* Commands in Host Emulation Mode */
#define READ_SHORT 0x90
/* Address_Low */
#define READ_EXTENDED 0x91
/* Address High */
/* Address Low */
#define WRITE_SHORT 0x92
/* Address_Low */
#define WRITE_EXTENDED 0x93
/* Address High */
/* Address Low */
/* Definitions for flow control */
#define SIO_RESET 0 /* Reset the port */
#define SIO_MODEM_CTRL 1 /* Set the modem control register */
#define SIO_SET_FLOW_CTRL 2 /* Set flow control register */
#define SIO_SET_BAUD_RATE 3 /* Set baud rate */
#define SIO_SET_DATA 4 /* Set the data characteristics of the port */
#define FTDI_DEVICE_OUT_REQTYPE (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT)
#define FTDI_DEVICE_IN_REQTYPE (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN)
/* Requests */
#define SIO_RESET_REQUEST SIO_RESET
#define SIO_SET_BAUDRATE_REQUEST SIO_SET_BAUD_RATE
#define SIO_SET_DATA_REQUEST SIO_SET_DATA
#define SIO_SET_FLOW_CTRL_REQUEST SIO_SET_FLOW_CTRL
#define SIO_SET_MODEM_CTRL_REQUEST SIO_MODEM_CTRL
#define SIO_POLL_MODEM_STATUS_REQUEST 0x05
#define SIO_SET_EVENT_CHAR_REQUEST 0x06
#define SIO_SET_ERROR_CHAR_REQUEST 0x07
#define SIO_SET_LATENCY_TIMER_REQUEST 0x09
#define SIO_GET_LATENCY_TIMER_REQUEST 0x0A
#define SIO_SET_BITMODE_REQUEST 0x0B
#define SIO_READ_PINS_REQUEST 0x0C
#define SIO_READ_EEPROM_REQUEST 0x90
#define SIO_WRITE_EEPROM_REQUEST 0x91
#define SIO_ERASE_EEPROM_REQUEST 0x92
#define SIO_RESET_SIO 0
#define SIO_RESET_PURGE_RX 1
#define SIO_RESET_PURGE_TX 2
#define SIO_DISABLE_FLOW_CTRL 0x0
#define SIO_RTS_CTS_HS (0x1 << 8)
#define SIO_DTR_DSR_HS (0x2 << 8)
#define SIO_XON_XOFF_HS (0x4 << 8)
#define SIO_SET_DTR_MASK 0x1
#define SIO_SET_DTR_HIGH ( 1 | ( SIO_SET_DTR_MASK << 8))
#define SIO_SET_DTR_LOW ( 0 | ( SIO_SET_DTR_MASK << 8))
#define SIO_SET_RTS_MASK 0x2
#define SIO_SET_RTS_HIGH ( 2 | ( SIO_SET_RTS_MASK << 8 ))
#define SIO_SET_RTS_LOW ( 0 | ( SIO_SET_RTS_MASK << 8 ))
#define SIO_RTS_CTS_HS (0x1 << 8)
/* marker for unused usb urb structures
(taken from libusb) */
#define FTDI_URB_USERCONTEXT_COOKIE ((void *)0x1)
#ifdef __GNUC__
#define DEPRECATED(func) func __attribute__ ((deprecated))
#elif defined(_MSC_VER)
#define DEPRECATED(func) __declspec(deprecated) func
#else
#pragma message("WARNING: You need to implement DEPRECATED for this compiler")
#define DEPRECATED(func) func
#endif
struct ftdi_transfer_control
{
int completed;
unsigned char *buf;
int size;
int offset;
struct ftdi_context *ftdi;
struct libusb_transfer *transfer;
};
/**
\brief Main context structure for all libftdi functions.
Do not access directly if possible.
*/
struct ftdi_context
{
/* USB specific */
/** libusb's context */
struct libusb_context *usb_ctx;
/** libusb's usb_dev_handle */
struct libusb_device_handle *usb_dev;
/** usb read timeout */
int usb_read_timeout;
/** usb write timeout */
int usb_write_timeout;
/* FTDI specific */
/** FTDI chip type */
enum ftdi_chip_type type;
/** baudrate */
int baudrate;
/** bitbang mode state */
unsigned char bitbang_enabled;
/** pointer to read buffer for ftdi_read_data */
unsigned char *readbuffer;
/** read buffer offset */
unsigned int readbuffer_offset;
/** number of remaining data in internal read buffer */
unsigned int readbuffer_remaining;
/** read buffer chunk size */
unsigned int readbuffer_chunksize;
/** write buffer chunk size */
unsigned int writebuffer_chunksize;
/** maximum packet size. Needed for filtering modem status bytes every n packets. */
unsigned int max_packet_size;
/* FTDI FT2232C requirecments */
/** FT2232C interface number: 0 or 1 */
int interface; /* 0 or 1 */
/** FT2232C index number: 1 or 2 */
int index; /* 1 or 2 */
/* Endpoints */
/** FT2232C end points: 1 or 2 */
int in_ep;
int out_ep; /* 1 or 2 */
/** Bitbang mode. 1: (default) Normal bitbang mode, 2: FT2232C SPI bitbang mode */
unsigned char bitbang_mode;
/** Decoded eeprom structure */
struct ftdi_eeprom *eeprom;
/** String representation of last error */
char *error_str;
/** Defines behavior in case a kernel module is already attached to the device */
enum ftdi_module_detach_mode module_detach_mode;
};
/**
List all handled EEPROM values.
Append future new values only at the end to provide API/ABI stability*/
enum ftdi_eeprom_value
{
VENDOR_ID = 0,
PRODUCT_ID = 1,
SELF_POWERED = 2,
REMOTE_WAKEUP = 3,
IS_NOT_PNP = 4,
SUSPEND_DBUS7 = 5,
IN_IS_ISOCHRONOUS = 6,
OUT_IS_ISOCHRONOUS = 7,
SUSPEND_PULL_DOWNS = 8,
USE_SERIAL = 9,
USB_VERSION = 10,
USE_USB_VERSION = 11,
MAX_POWER = 12,
CHANNEL_A_TYPE = 13,
CHANNEL_B_TYPE = 14,
CHANNEL_A_DRIVER = 15,
CHANNEL_B_DRIVER = 16,
CBUS_FUNCTION_0 = 17,
CBUS_FUNCTION_1 = 18,
CBUS_FUNCTION_2 = 19,
CBUS_FUNCTION_3 = 20,
CBUS_FUNCTION_4 = 21,
CBUS_FUNCTION_5 = 22,
CBUS_FUNCTION_6 = 23,
CBUS_FUNCTION_7 = 24,
CBUS_FUNCTION_8 = 25,
CBUS_FUNCTION_9 = 26,
HIGH_CURRENT = 27,
HIGH_CURRENT_A = 28,
HIGH_CURRENT_B = 29,
INVERT = 30,
GROUP0_DRIVE = 31,
GROUP0_SCHMITT = 32,
GROUP0_SLEW = 33,
GROUP1_DRIVE = 34,
GROUP1_SCHMITT = 35,
GROUP1_SLEW = 36,
GROUP2_DRIVE = 37,
GROUP2_SCHMITT = 38,
GROUP2_SLEW = 39,
GROUP3_DRIVE = 40,
GROUP3_SCHMITT = 41,
GROUP3_SLEW = 42,
CHIP_SIZE = 43,
CHIP_TYPE = 44,
POWER_SAVE = 45,
CLOCK_POLARITY = 46,
DATA_ORDER = 47,
FLOW_CONTROL = 48,
CHANNEL_C_DRIVER = 49,
CHANNEL_D_DRIVER = 50,
CHANNEL_A_RS485 = 51,
CHANNEL_B_RS485 = 52,
CHANNEL_C_RS485 = 53,
CHANNEL_D_RS485 = 54,
};
/**
\brief list of usb devices created by ftdi_usb_find_all()
*/
struct ftdi_device_list
{
/** pointer to next entry */
struct ftdi_device_list *next;
/** pointer to libusb's usb_device */
struct libusb_device *dev;
};
#define FT1284_CLK_IDLE_STATE 0x01
#define FT1284_DATA_LSB 0x02 /* DS_FT232H 1.3 amd ftd2xx.h 1.0.4 disagree here*/
#define FT1284_FLOW_CONTROL 0x04
#define POWER_SAVE_DISABLE_H 0x80
#define USE_SERIAL_NUM 0x08
enum ftdi_cbus_func {/* FIXME: Recheck value, especially the last */
CBUS_TXDEN = 0, CBUS_PWREN = 1, CBUS_RXLED = 2, CBUS_TXLED = 3, CBUS_TXRXLED = 4,
CBUS_SLEEP = 5, CBUS_CLK48 = 6, CBUS_CLK24 = 7, CBUS_CLK12 = 8, CBUS_CLK6 = 9,
CBUS_IOMODE = 0xa, CBUS_BB_WR = 0xb, CBUS_BB_RD = 0xc, CBUS_BB = 0xd};
enum ftdi_cbush_func {/* FIXME: Recheck value, especially the last */
CBUSH_TRISTATE = 0, CBUSH_RXLED = 1, CBUSH_TXLED = 2, CBUSH_TXRXLED = 3, CBUSH_PWREN = 4,
CBUSH_SLEEP = 5, CBUSH_DRIVE_0 = 6, CBUSG_DRIVE1 = 7, CBUSH_IOMODE = 8, CBUSH_TXDEN = 9,
CBUSH_CLK30 = 0xa, CBUSH_CLK15 = 0xb, CBUSH_CLK7_5 = 0xc};
/** Invert TXD# */
#define INVERT_TXD 0x01
/** Invert RXD# */
#define INVERT_RXD 0x02
/** Invert RTS# */
#define INVERT_RTS 0x04
/** Invert CTS# */
#define INVERT_CTS 0x08
/** Invert DTR# */
#define INVERT_DTR 0x10
/** Invert DSR# */
#define INVERT_DSR 0x20
/** Invert DCD# */
#define INVERT_DCD 0x40
/** Invert RI# */
#define INVERT_RI 0x80
/** Interface Mode. */
#define CHANNEL_IS_UART 0x0
#define CHANNEL_IS_FIFO 0x1
#define CHANNEL_IS_OPTO 0x2
#define CHANNEL_IS_CPU 0x4
#define CHANNEL_IS_FT1284 0x8
#define CHANNEL_IS_RS485 0x10
#define DRIVE_4MA 0
#define DRIVE_8MA 1
#define DRIVE_12MA 2
#define DRIVE_16MA 3
#define SLOW_SLEW 4
#define IS_SCHMITT 8
/** Driver Type. */
#define DRIVER_VCP 0x08
#define DRIVER_VCPH 0x10 /* FT232H has moved the VCP bit */
#define USE_USB_VERSION_BIT 0x10
#define SUSPEND_DBUS7_BIT 0x80
/** High current drive. */
#define HIGH_CURRENT_DRIVE 0x10
#define HIGH_CURRENT_DRIVE_R 0x04
/**
\brief Progress Info for streaming read
*/
struct size_and_time
{
uint64_t totalBytes;
struct timeval time;
};
typedef struct
{
struct size_and_time first;
struct size_and_time prev;
struct size_and_time current;
double totalTime;
double totalRate;
double currentRate;
} FTDIProgressInfo;
typedef int (FTDIStreamCallback)(uint8_t *buffer, int length,
FTDIProgressInfo *progress, void *userdata);
/**
* Provide libftdi version information
* major: Library major version
* minor: Library minor version
* micro: Currently unused, ight get used for hotfixes.
* version_str: Version as (static) string
* snapshot_str: Git snapshot version if known. Otherwise "unknown" or empty string.
*/
struct ftdi_version_info
{
int major;
int minor;
int micro;
const char *version_str;
const char *snapshot_str;
};
#ifdef __cplusplus
extern "C"
{
#endif
int ftdi_init(struct ftdi_context *ftdi);
struct ftdi_context *ftdi_new(void);
int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface);
void ftdi_deinit(struct ftdi_context *ftdi);
void ftdi_free(struct ftdi_context *ftdi);
void ftdi_set_usbdev (struct ftdi_context *ftdi, struct libusb_device_handle *usbdev);
struct ftdi_version_info ftdi_get_library_version();
int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist,
int vendor, int product);
void ftdi_list_free(struct ftdi_device_list **devlist);
void ftdi_list_free2(struct ftdi_device_list *devlist);
int ftdi_usb_get_strings(struct ftdi_context *ftdi, struct libusb_device *dev,
char * manufacturer, int mnf_len,
char * description, int desc_len,
char * serial, int serial_len);
int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product);
int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
const char* description, const char* serial);
int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
const char* description, const char* serial, unsigned int index);
int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct libusb_device *dev);
int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description);
int ftdi_usb_close(struct ftdi_context *ftdi);
int ftdi_usb_reset(struct ftdi_context *ftdi);
int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi);
int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi);
int ftdi_usb_purge_buffers(struct ftdi_context *ftdi);
int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate);
int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity);
int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
enum ftdi_break_type break_type);
int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size);
int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize);
int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize);
int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size);
int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize);
int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize);
int ftdi_readstream(struct ftdi_context *ftdi, FTDIStreamCallback *callback,
void *userdata, int packetsPerTransfer, int numTransfers);
struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size);
void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more);
struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size);
int ftdi_transfer_data_done(struct ftdi_transfer_control *tc);
int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode);
int ftdi_disable_bitbang(struct ftdi_context *ftdi);
int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins);
int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency);
int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency);
int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status);
/* flow control */
int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl);
int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts);
int ftdi_setdtr(struct ftdi_context *ftdi, int state);
int ftdi_setrts(struct ftdi_context *ftdi, int state);
int ftdi_set_event_char(struct ftdi_context *ftdi, unsigned char eventch, unsigned char enable);
int ftdi_set_error_char(struct ftdi_context *ftdi, unsigned char errorch, unsigned char enable);
/* init eeprom for the given FTDI type */
int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi,
char * manufacturer, char *product,
char * serial);
int ftdi_eeprom_build(struct ftdi_context *ftdi);
int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose);
int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value);
int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value);
int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size);
int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, int size);
int ftdi_read_eeprom(struct ftdi_context *ftdi);
int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid);
int ftdi_write_eeprom(struct ftdi_context *ftdi);
int ftdi_erase_eeprom(struct ftdi_context *ftdi);
int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val);
int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val);
char *ftdi_get_error_string(struct ftdi_context *ftdi);
#ifdef __cplusplus
}
#endif
#endif /* __libftdi_h__ */

130
lib/libftdi/src/ftdi_i.h Normal file
View File

@@ -0,0 +1,130 @@
/***************************************************************************
ftdi_i.h - description
-------------------
begin : Don Sep 9 2011
copyright : (C) 2003-2011 by Intra2net AG and the libftdi developers
email : opensource@intra2net.com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License *
* version 2.1 as published by the Free Software Foundation; *
* *
***************************************************************************
Non public definitions here
*/
/* Even on 93xx66 at max 256 bytes are used (AN_121)*/
#define FTDI_MAX_EEPROM_SIZE 256
/**
\brief FTDI eeprom structure
*/
struct ftdi_eeprom
{
/** vendor id */
int vendor_id;
/** product id */
int product_id;
/** Was the eeprom structure initialized for the actual
connected device? **/
int initialized_for_connected_device;
/** self powered */
int self_powered;
/** remote wakeup */
int remote_wakeup;
int is_not_pnp;
/* Suspend on DBUS7 Low */
int suspend_dbus7;
/** input in isochronous transfer mode */
int in_is_isochronous;
/** output in isochronous transfer mode */
int out_is_isochronous;
/** suspend pull downs */
int suspend_pull_downs;
/** use serial */
int use_serial;
/** usb version */
int usb_version;
/** Use usb version on FT2232 devices*/
int use_usb_version;
/** maximum power */
int max_power;
/** manufacturer name */
char *manufacturer;
/** product name */
char *product;
/** serial number */
char *serial;
/* 2232D/H specific */
/* Hardware type, 0 = RS232 Uart, 1 = 245 FIFO, 2 = CPU FIFO,
4 = OPTO Isolate */
int channel_a_type;
int channel_b_type;
/* Driver Type, 1 = VCP */
int channel_a_driver;
int channel_b_driver;
int channel_c_driver;
int channel_d_driver;
/* 4232H specific */
int channel_a_rs485enable;
int channel_b_rs485enable;
int channel_c_rs485enable;
int channel_d_rs485enable;
/* Special function of FT232R/FT232H devices (and possibly others as well) */
/** CBUS pin function. See CBUS_xxx defines. */
int cbus_function[10];
/** Select hight current drive on R devices. */
int high_current;
/** Select hight current drive on A channel (2232C */
int high_current_a;
/** Select hight current drive on B channel (2232C). */
int high_current_b;
/** Select inversion of data lines (bitmask). */
int invert;
/*2232H/4432H Group specific values */
/* Group0 is AL on 2322H and A on 4232H
Group1 is AH on 2232H and B on 4232H
Group2 is BL on 2322H and C on 4232H
Group3 is BH on 2232H and C on 4232H*/
int group0_drive;
int group0_schmitt;
int group0_slew;
int group1_drive;
int group1_schmitt;
int group1_slew;
int group2_drive;
int group2_schmitt;
int group2_slew;
int group3_drive;
int group3_schmitt;
int group3_slew;
int powersave;
int clock_polarity;
int data_order;
int flow_control;
/** eeprom size in bytes. This doesn't get stored in the eeprom
but is the only way to pass it to ftdi_eeprom_build. */
int size;
/* EEPROM Type 0x46 for 93xx46, 0x56 for 93xx56 and 0x66 for 93xx66*/
int chip;
unsigned char buf[FTDI_MAX_EEPROM_SIZE];
};

295
lib/libftdi/src/ftdi_stream.c Normal file
View File

@@ -0,0 +1,295 @@
/***************************************************************************
ftdi_stream.c - description
-------------------
copyright : (C) 2009 Micah Dowty 2010 Uwe Bonnes
email : opensource@intra2net.com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License *
* version 2.1 as published by the Free Software Foundation; *
* *
***************************************************************************/
/* Adapted from
* fastftdi.c - A minimal FTDI FT232H interface for which supports bit-bang
* mode, but focuses on very high-performance support for
* synchronous FIFO mode. Requires libusb-1.0
*
* Copyright (C) 2009 Micah Dowty
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdlib.h>
#include <stdio.h>
#include "ftdi.h"
typedef struct
{
FTDIStreamCallback *callback;
void *userdata;
int packetsize;
int activity;
int result;
FTDIProgressInfo progress;
} FTDIStreamState;
/* Handle callbacks
*
* With Exit request, free memory and release the transfer
*
* state->result is only set when some error happens
*/
static void
ftdi_readstream_cb(struct libusb_transfer *transfer)
{
FTDIStreamState *state = transfer->user_data;
int packet_size = state->packetsize;
state->activity++;
if (transfer->status == LIBUSB_TRANSFER_COMPLETED)
{
int i;
uint8_t *ptr = transfer->buffer;
int length = transfer->actual_length;
int numPackets = (length + packet_size - 1) / packet_size;
int res = 0;
for (i = 0; i < numPackets; i++)
{
int payloadLen;
int packetLen = length;
if (packetLen > packet_size)
packetLen = packet_size;
payloadLen = packetLen - 2;
state->progress.current.totalBytes += payloadLen;
res = state->callback(ptr + 2, payloadLen,
NULL, state->userdata);
ptr += packetLen;
length -= packetLen;
}
if (res)
{
free(transfer->buffer);
libusb_free_transfer(transfer);
}
else
{
transfer->status = -1;
state->result = libusb_submit_transfer(transfer);
}
}
else
{
fprintf(stderr, "unknown status %d\n",transfer->status);
state->result = LIBUSB_ERROR_IO;
}
}
/**
Helper function to calculate (unix) time differences
\param a timeval
\param b timeval
*/
static double
TimevalDiff(const struct timeval *a, const struct timeval *b)
{
return (a->tv_sec - b->tv_sec) + 1e-6 * (a->tv_usec - b->tv_usec);
}
/**
Streaming reading of data from the device
Use asynchronous transfers in libusb-1.0 for high-performance
streaming of data from a device interface back to the PC. This
function continuously transfers data until either an error occurs
or the callback returns a nonzero value. This function returns
a libusb error code or the callback's return value.
For every contiguous block of received data, the callback will
be invoked.
\param ftdi pointer to ftdi_context
\param callback to user supplied function for one block of data
\param userdata
\param packetsPerTransfer number of packets per transfer
\param numTransfers Number of transfers per callback
*/
int
ftdi_readstream(struct ftdi_context *ftdi,
FTDIStreamCallback *callback, void *userdata,
int packetsPerTransfer, int numTransfers)
{
struct libusb_transfer **transfers;
FTDIStreamState state = { callback, userdata, ftdi->max_packet_size, 1 };
int bufferSize = packetsPerTransfer * ftdi->max_packet_size;
int xferIndex;
int err = 0;
/* Only FT2232H and FT232H know about the synchronous FIFO Mode*/
if ((ftdi->type != TYPE_2232H) && (ftdi->type != TYPE_232H))
{
fprintf(stderr,"Device doesn't support synchronous FIFO mode\n");
return 1;
}
/* We don't know in what state we are, switch to reset*/
if (ftdi_set_bitmode(ftdi, 0xff, BITMODE_RESET) < 0)
{
fprintf(stderr,"Can't reset mode\n");
return 1;
}
/* Purge anything remaining in the buffers*/
if (ftdi_usb_purge_buffers(ftdi) < 0)
{
fprintf(stderr,"Can't Purge\n");
return 1;
}
/*
* Set up all transfers
*/
transfers = calloc(numTransfers, sizeof *transfers);
if (!transfers) {
err = LIBUSB_ERROR_NO_MEM;
goto cleanup;
}
for (xferIndex = 0; xferIndex < numTransfers; xferIndex++)
{
struct libusb_transfer *transfer;
transfer = libusb_alloc_transfer(0);
transfers[xferIndex] = transfer;
if (!transfer) {
err = LIBUSB_ERROR_NO_MEM;
goto cleanup;
}
libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->out_ep,
malloc(bufferSize), bufferSize,
ftdi_readstream_cb,
&state, 0);
if (!transfer->buffer) {
err = LIBUSB_ERROR_NO_MEM;
goto cleanup;
}
transfer->status = -1;
err = libusb_submit_transfer(transfer);
if (err)
goto cleanup;
}
/* Start the transfers only when everything has been set up.
* Otherwise the transfers start stuttering and the PC not
* fetching data for several to several ten milliseconds
* and we skip blocks
*/
if (ftdi_set_bitmode(ftdi, 0xff, BITMODE_SYNCFF) < 0)
{
fprintf(stderr,"Can't set synchronous fifo mode: %s\n",
ftdi_get_error_string(ftdi));
goto cleanup;
}
/*
* Run the transfers, and periodically assess progress.
*/
gettimeofday(&state.progress.first.time, NULL);
do
{
FTDIProgressInfo *progress = &state.progress;
const double progressInterval = 1.0;
struct timeval timeout = { 0, ftdi->usb_read_timeout };
struct timeval now;
int err = libusb_handle_events_timeout(ftdi->usb_ctx, &timeout);
if (err == LIBUSB_ERROR_INTERRUPTED)
/* restart interrupted events */
err = libusb_handle_events_timeout(ftdi->usb_ctx, &timeout);
if (!state.result)
{
state.result = err;
}
if (state.activity == 0)
state.result = 1;
else
state.activity = 0;
// If enough time has elapsed, update the progress
gettimeofday(&now, NULL);
if (TimevalDiff(&now, &progress->current.time) >= progressInterval)
{
progress->current.time = now;
progress->totalTime = TimevalDiff(&progress->current.time,
&progress->first.time);
if (progress->prev.totalBytes)
{
// We have enough information to calculate rates
double currentTime;
currentTime = TimevalDiff(&progress->current.time,
&progress->prev.time);
progress->totalRate =
progress->current.totalBytes /progress->totalTime;
progress->currentRate =
(progress->current.totalBytes -
progress->prev.totalBytes) / currentTime;
}
state.callback(NULL, 0, progress, state.userdata);
progress->prev = progress->current;
}
} while (!state.result);
/*
* Cancel any outstanding transfers, and free memory.
*/
cleanup:
fprintf(stderr, "cleanup\n");
if (transfers)
free(transfers);
if (err)
return err;
else
return state.result;
}

11
lib/libftdi/src/ftdi_version_i.h Normal file
View File

@@ -0,0 +1,11 @@
#ifndef FTDI_VERSION_INTERNAL_H
#define FTDI_VERSION_INTERNAL_H
#define FTDI_MAJOR_VERSION 2
#define FTDI_MINOR_VERSION 0
#define FTDI_MICRO_VERSION 0
const char FTDI_VERSION_STRING[] = "";
const char FTDI_SNAPSHOT_VERSION[] = "";
#endif

11
lib/libftdi/src/ftdi_version_i.h.in Normal file
View File

@@ -0,0 +1,11 @@
#ifndef FTDI_VERSION_INTERNAL_H
#define FTDI_VERSION_INTERNAL_H
#define FTDI_MAJOR_VERSION @MAJOR_VERSION@
#define FTDI_MINOR_VERSION @MINOR_VERSION@
#define FTDI_MICRO_VERSION 0
const char FTDI_VERSION_STRING[] = "@VERSION_STRING@";
const char FTDI_SNAPSHOT_VERSION[] = "@SNAPSHOT_VERSION@";
#endif

30
lib/libftdi/test/CMakeLists.txt Normal file
View File

@@ -0,0 +1,30 @@
# Optional unit test
find_package(Boost COMPONENTS unit_test_framework)
if(Boost_UNIT_TEST_FRAMEWORK_FOUND)
message(STATUS "Building unit test")
enable_testing()
INCLUDE_DIRECTORIES(BEFORE ${CMAKE_SOURCE_DIR}/src ${Boost_INCLUDE_DIRS})
set(cpp_tests
basic.cpp
baudrate.cpp
)
add_executable(test_libftdi ${cpp_tests})
target_link_libraries(test_libftdi ftdi ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
add_test(test_libftdi test_libftdi)
# Add custom target so we run easily run "make check"
add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} DEPENDS test_libftdi)
else(Boost_UNIT_TEST_FRAMEWORK_FOUND)
message(STATUS "NOT building unit test (requires boost unit test framework)")
endif(Boost_UNIT_TEST_FRAMEWORK_FOUND)

33
lib/libftdi/test/basic.cpp Normal file
View File

@@ -0,0 +1,33 @@
/**@file
@brief Test basic FTDI functionality
@author Thomas Jarosch
*/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License *
* version 2.1 as published by the Free Software Foundation; *
* *
***************************************************************************/
#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>
#include <ftdi.h>
BOOST_AUTO_TEST_SUITE(Basic)
BOOST_AUTO_TEST_CASE(SimpleInit)
{
ftdi_context ftdi;
int rtn_init = ftdi_init(&ftdi);
BOOST_REQUIRE_EQUAL(0, rtn_init);
ftdi_deinit(&ftdi);
}
BOOST_AUTO_TEST_SUITE_END()

267
lib/libftdi/test/baudrate.cpp Normal file
View File

@@ -0,0 +1,267 @@
/**@file
@brief Test baudrate calculator code
@author Thomas Jarosch and Uwe Bonnes
*/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License *
* version 2.1 as published by the Free Software Foundation; *
* *
***************************************************************************/
#include <ftdi.h>
#define BOOST_TEST_DYN_LINK
#include <boost/test/unit_test.hpp>
#include <boost/foreach.hpp>
#include <vector>
#include <map>
#include <math.h>
using namespace std;
extern "C" int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi,
unsigned short *value, unsigned short *index);
/// Basic initialization of libftdi for every test
class BaseFTDIFixture
{
protected:
ftdi_context *ftdi;
public:
BaseFTDIFixture()
: ftdi(NULL)
{
ftdi = ftdi_new();
}
virtual ~BaseFTDIFixture()
{
delete ftdi;
ftdi = NULL;
}
};
BOOST_FIXTURE_TEST_SUITE(Baudrate, BaseFTDIFixture)
/// Helper class to store the convert_baudrate_UT_export result
struct calc_result
{
int actual_baudrate;
unsigned short divisor;
unsigned short fractional_bits;
unsigned short clock;
calc_result(int actual, unsigned short my_divisor, unsigned short my_fractional_bits, unsigned short my_clock)
: actual_baudrate(actual)
, divisor(my_divisor)
, fractional_bits(my_fractional_bits)
, clock(my_clock)
{
}
calc_result()
: actual_baudrate(0)
, divisor(0)
, fractional_bits(0)
, clock(0)
{
}
};
/**
* @brief Test convert_baudrate code against a list of baud rates
*
* @param baudrates Baudrates to check
**/
static void test_baudrates(ftdi_context *ftdi, const map<int, calc_result> &baudrates)
{
typedef std::pair<int, calc_result> baudrate_type;
BOOST_FOREACH(const baudrate_type &baudrate, baudrates)
{
unsigned short calc_value = 0, calc_index = 0;
int calc_baudrate = convert_baudrate_UT_export(baudrate.first, ftdi, &calc_value, &calc_index);
const calc_result *res = &baudrate.second;
unsigned short divisor = calc_value & 0x3fff;
unsigned short fractional_bits = (calc_value >> 14);
unsigned short clock = (calc_index & 0x200) ? 120 : 48;
switch (ftdi->type)
{
case TYPE_232H:
case TYPE_2232H:
case TYPE_4232H:
fractional_bits |= (calc_index & 0x100) ? 4 : 0;
break;
case TYPE_R:
case TYPE_2232C:
case TYPE_BM:
fractional_bits |= (calc_index & 0x001) ? 4 : 0;
break;
default:;
}
// Aid debugging since this test is a generic function
BOOST_CHECK_MESSAGE(res->actual_baudrate == calc_baudrate && res->divisor == divisor && res->fractional_bits == fractional_bits
&& res->clock == clock,
"\n\nERROR: baudrate calculation failed for --" << baudrate.first << " baud--. Details below: ");
BOOST_CHECK_EQUAL(res->actual_baudrate, calc_baudrate);
BOOST_CHECK_EQUAL(res->divisor, divisor);
BOOST_CHECK_EQUAL(res->fractional_bits, fractional_bits);
BOOST_CHECK_EQUAL(res->clock, clock);
}
}
BOOST_AUTO_TEST_CASE(TypeAMFixedBaudrates)
{
ftdi->type = TYPE_AM;
map<int, calc_result> baudrates;
baudrates[183] = calc_result(183, 16383, 0, 48);
baudrates[300] = calc_result(300, 10000, 0, 48);
baudrates[600] = calc_result(600, 5000, 0, 48);
baudrates[1200] = calc_result(1200, 2500, 0, 48);
baudrates[2400] = calc_result(2400, 1250, 0, 48);
baudrates[4800] = calc_result(4800, 625, 0, 48);
baudrates[9600] = calc_result(9600, 312, 1, 48);
baudrates[19200] = calc_result(19200, 156, 2, 48);
baudrates[38400] = calc_result(38400, 78, 3, 48);
baudrates[57600] = calc_result(57554, 52, 3, 48);
baudrates[115200] = calc_result(115385, 26, 0, 48);
baudrates[230400] = calc_result(230769, 13, 0, 48);
baudrates[460800] = calc_result(461538, 6, 1, 48);
baudrates[921600] = calc_result(923077, 3, 2, 48);
baudrates[1000000] = calc_result(1000000, 3, 0, 48);
baudrates[1090512] = calc_result(1000000, 3, 0, 48);
baudrates[1090909] = calc_result(1000000, 3, 0, 48);
baudrates[1090910] = calc_result(1000000, 3, 0, 48);
baudrates[1200000] = calc_result(1200000, 2, 1, 48);
baudrates[1333333] = calc_result(1333333, 2, 2, 48);
baudrates[1411764] = calc_result(1411765, 2, 3, 48);
baudrates[1500000] = calc_result(1500000, 2, 0, 48);
baudrates[2000000] = calc_result(1500000, 2, 0, 48);
baudrates[3000000] = calc_result(3000000, 0, 0, 48);
test_baudrates(ftdi, baudrates);
}
BOOST_AUTO_TEST_CASE(TypeBMFixedBaudrates)
{
// Unify testing of chips behaving the same
std::vector<enum ftdi_chip_type> test_types;
test_types.push_back(TYPE_BM);
test_types.push_back(TYPE_2232C);
test_types.push_back(TYPE_R);
map<int, calc_result> baudrates;
baudrates[183] = calc_result(183, 16383, 7, 48);
baudrates[184] = calc_result(184, 16304, 4, 48);
baudrates[300] = calc_result(300, 10000, 0, 48);
baudrates[600] = calc_result(600, 5000, 0, 48);
baudrates[1200] = calc_result(1200, 2500, 0, 48);
baudrates[2400] = calc_result(2400, 1250, 0, 48);
baudrates[4800] = calc_result(4800, 625, 0, 48);
baudrates[9600] = calc_result(9600, 312, 1, 48);
baudrates[19200] = calc_result(19200, 156, 2, 48);
baudrates[38400] = calc_result(38400, 78, 3, 48);
baudrates[57600] = calc_result(57554, 52, 3, 48);
baudrates[115200] = calc_result(115385, 26, 0, 48);
baudrates[230400] = calc_result(230769, 13, 0, 48);
baudrates[460800] = calc_result(461538, 6, 1, 48);
baudrates[921600] = calc_result(923077, 3, 2, 48);
baudrates[1000000] = calc_result(1000000, 3, 0, 48);
baudrates[1050000] = calc_result(1043478, 2, 7, 48);
baudrates[1400000] = calc_result(1411765, 2, 3, 48);
baudrates[1500000] = calc_result(1500000, 2, 0, 48);
baudrates[2000000] = calc_result(2000000, 1, 0, 48);
baudrates[3000000] = calc_result(3000000, 0, 0, 48);
baudrates[(3000000*16/(2*16+15))-1] = calc_result(round(3000000/3.000), 3, 0, 48);
baudrates[ 3000000*16/(2*16+15) ] = calc_result(round(3000000/3.000), 3, 0, 48);
baudrates[(3000000*16/(2*16+15))+1] = calc_result(round(3000000/2.875), 2, 7, 48);
baudrates[ 3000000*16/(2*16+13) ] = calc_result(round(3000000/2.875), 2, 7, 48);
baudrates[(3000000*16/(2*16+13))+1] = calc_result(round(3000000/2.750), 2, 6, 48);
baudrates[ 3000000*16/(2*16+11) ] = calc_result(round(3000000/2.750), 2, 6, 48);
baudrates[(3000000*16/(2*16+11))+1] = calc_result(round(3000000/2.625), 2, 5, 48);
baudrates[ 3000000*16/(2*16+ 9) ] = calc_result(round(3000000/2.625), 2, 5, 48);
baudrates[(3000000*16/(2*16+ 9))+1] = calc_result(round(3000000/2.500), 2, 1, 48);
baudrates[ 3000000*16/(2*16+ 7) ] = calc_result(round(3000000/2.500), 2, 1, 48);
baudrates[(3000000*16/(2*16+ 7))+1] = calc_result(round(3000000/2.375), 2, 4, 48);
baudrates[ 3000000*16/(2*16+ 5) ] = calc_result(round(3000000/2.375), 2, 4, 48);
baudrates[(3000000*16/(2*16+ 5))+1] = calc_result(round(3000000/2.250), 2, 2, 48);
baudrates[ 3000000*16/(2*16+ 3) ] = calc_result(round(3000000/2.250), 2, 2, 48);
baudrates[(3000000*16/(2*16+ 3))+1] = calc_result(round(3000000/2.125), 2, 3, 48);
baudrates[ 3000000*16/(2*16+ 1) ] = calc_result(round(3000000/2.125), 2, 3, 48);
baudrates[(3000000*16/(2*16+ 1))+1] = calc_result(round(3000000/2.000), 2, 0, 48);
BOOST_FOREACH(const enum ftdi_chip_type &test_chip_type, test_types)
{
ftdi->type = test_chip_type;
test_baudrates(ftdi, baudrates);
}
}
BOOST_AUTO_TEST_CASE(TypeHFixedBaudrates)
{
// Unify testing of chips behaving the same
std::vector<enum ftdi_chip_type> test_types;
test_types.push_back(TYPE_2232H);
test_types.push_back(TYPE_4232H);
test_types.push_back(TYPE_232H);
map<int, calc_result> baudrates;
baudrates[183] = calc_result(183, 16383, 7, 48);
baudrates[184] = calc_result(184, 16304, 4, 48);
baudrates[300] = calc_result(300, 10000, 0, 48);
baudrates[600] = calc_result(600, 5000, 0, 48);
baudrates[1200] = calc_result(1200, 10000, 0, 120);
baudrates[2400] = calc_result(2400, 5000, 0, 120);
baudrates[4800] = calc_result(4800, 2500, 0, 120);
baudrates[9600] = calc_result(9600, 1250, 0, 120);
baudrates[19200] = calc_result(19200, 625, 0, 120);
baudrates[38400] = calc_result(38400, 312, 1, 120);
baudrates[57600] = calc_result(57588, 208, 4, 120);
baudrates[115200] = calc_result(115246, 104, 3, 120);
baudrates[230400] = calc_result(230216, 52, 3, 120);
baudrates[460800] = calc_result(461538, 26, 0, 120);
baudrates[921600] = calc_result(923077, 13, 0, 120);
baudrates[1000000] = calc_result(1000000, 12, 0, 120);
baudrates[1000000] = calc_result(1000000, 12, 0, 120);
baudrates[6000000] = calc_result(6000000, 2, 0, 120);
baudrates[4173913] = calc_result(4173913, 2, 7, 120);
baudrates[8000000] = calc_result(8000000, 1, 0, 120);
baudrates[12000000] = calc_result(12000000, 0, 0, 120);
baudrates[(12000000*16/(2*16+15))-1] = calc_result(round(12000000/3.000), 3, 0, 120);
baudrates[ 12000000*16/(2*16+15) ] = calc_result(round(12000000/3.000), 3, 0, 120);
baudrates[(12000000*16/(2*16+15))+1] = calc_result(round(12000000/2.875), 2, 7, 120);
baudrates[ 12000000*16/(2*16+13) ] = calc_result(round(12000000/2.875), 2, 7, 120);
baudrates[(12000000*16/(2*16+13))+1] = calc_result(round(12000000/2.750), 2, 6, 120);
baudrates[ 12000000*16/(2*16+11) ] = calc_result(round(12000000/2.750), 2, 6, 120);
baudrates[(12000000*16/(2*16+11))+1] = calc_result(round(12000000/2.625), 2, 5, 120);
baudrates[ 12000000*16/(2*16+ 9) ] = calc_result(round(12000000/2.625), 2, 5, 120);
baudrates[(12000000*16/(2*16+ 9))+1] = calc_result(round(12000000/2.500), 2, 1, 120);
baudrates[ 12000000*16/(2*16+ 7) ] = calc_result(round(12000000/2.500), 2, 1, 120);
baudrates[(12000000*16/(2*16+ 7))+1] = calc_result(round(12000000/2.375), 2, 4, 120);
baudrates[ 12000000*16/(2*16+ 5) ] = calc_result(round(12000000/2.375), 2, 4, 120);
baudrates[(12000000*16/(2*16+ 5))+1] = calc_result(round(12000000/2.250), 2, 2, 120);
baudrates[ 12000000*16/(2*16+ 3) ] = calc_result(round(12000000/2.250), 2, 2, 120);
baudrates[(12000000*16/(2*16+ 3))+1] = calc_result(round(12000000/2.125), 2, 3, 120);
baudrates[ 12000000*16/(2*16+ 1) ] = calc_result(round(12000000/2.125), 2, 3, 120);
baudrates[(12000000*16/(2*16+ 1))+1] = calc_result(round(12000000/2.000), 2, 0, 120);
BOOST_FOREACH(const enum ftdi_chip_type &test_chip_type, test_types)
{
ftdi->type = test_chip_type;
test_baudrates(ftdi, baudrates);
}
}
BOOST_AUTO_TEST_SUITE_END()