initial commit
Signed-off-by: Steve Markgraf <steve@steve-m.de>
This commit is contained in:
commit
65d43393ed
|
|
@ -0,0 +1,38 @@
|
|||
Makefile
|
||||
Makefile.in
|
||||
.deps
|
||||
.libs
|
||||
*.o
|
||||
*.lo
|
||||
*.la
|
||||
*.pc
|
||||
aclocal.m4
|
||||
acinclude.m4
|
||||
aminclude.am
|
||||
m4/*.m4
|
||||
autom4te.cache
|
||||
config.h*
|
||||
config.sub
|
||||
config.log
|
||||
config.status
|
||||
config.guess
|
||||
configure
|
||||
depcomp
|
||||
missing
|
||||
ltmain.sh
|
||||
install-sh
|
||||
stamp-h1
|
||||
libtool
|
||||
Doxyfile
|
||||
|
||||
.tarball-version
|
||||
.version
|
||||
|
||||
.*.swp
|
||||
|
||||
doc/
|
||||
|
||||
CMakeCache.txt
|
||||
*/CMakeFiles
|
||||
CMakeFiles
|
||||
*.cmake
|
||||
|
|
@ -0,0 +1,160 @@
|
|||
# Copyright 2018 Osmocom Project
|
||||
#
|
||||
# This file is part of osmo-fl2k
|
||||
#
|
||||
# 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, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
|
||||
########################################################################
|
||||
# Project setup
|
||||
########################################################################
|
||||
cmake_minimum_required(VERSION 2.6)
|
||||
project(libosmo-fl2k C)
|
||||
|
||||
#select the release build type by default to get optimization flags
|
||||
if(NOT CMAKE_BUILD_TYPE)
|
||||
set(CMAKE_BUILD_TYPE "Release")
|
||||
message(STATUS "Build type not specified: defaulting to release.")
|
||||
endif(NOT CMAKE_BUILD_TYPE)
|
||||
set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")
|
||||
|
||||
list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules)
|
||||
|
||||
if(NOT LIB_INSTALL_DIR)
|
||||
set(LIB_INSTALL_DIR lib)
|
||||
endif()
|
||||
|
||||
# Set the version information here
|
||||
set(VERSION_INFO_MAJOR_VERSION 0) # increment major on api compatibility changes
|
||||
set(VERSION_INFO_MINOR_VERSION 1) # increment minor on feature-level changes
|
||||
set(VERSION_INFO_PATCH_VERSION git) # increment patch for bug fixes and docs
|
||||
include(Version) # setup version info
|
||||
|
||||
########################################################################
|
||||
# Compiler specific setup
|
||||
########################################################################
|
||||
if(CMAKE_COMPILER_IS_GNUCC AND NOT WIN32)
|
||||
ADD_DEFINITIONS(-Wall)
|
||||
ADD_DEFINITIONS(-Wextra)
|
||||
ADD_DEFINITIONS(-Wno-unused-parameter)
|
||||
ADD_DEFINITIONS(-Wno-unused)
|
||||
ADD_DEFINITIONS(-Wsign-compare)
|
||||
ADD_DEFINITIONS(-Wdeclaration-after-statement)
|
||||
#http://gcc.gnu.org/wiki/Visibility
|
||||
add_definitions(-fvisibility=hidden)
|
||||
endif()
|
||||
|
||||
########################################################################
|
||||
# Find build dependencies
|
||||
########################################################################
|
||||
find_package(PkgConfig)
|
||||
find_package(LibUSB)
|
||||
set(THREADS_USE_PTHREADS_WIN32 true)
|
||||
find_package(Threads)
|
||||
|
||||
if(NOT LIBUSB_FOUND)
|
||||
message(FATAL_ERROR "LibUSB 1.0 required to compile libosmo-fl2k")
|
||||
endif()
|
||||
if(NOT THREADS_FOUND)
|
||||
message(FATAL_ERROR "pthreads(-win32) required to compile libosmo-fl2k")
|
||||
endif()
|
||||
########################################################################
|
||||
# Setup the include and linker paths
|
||||
########################################################################
|
||||
include_directories(
|
||||
${CMAKE_SOURCE_DIR}/include
|
||||
${LIBUSB_INCLUDE_DIR}
|
||||
${THREADS_PTHREADS_INCLUDE_DIR}
|
||||
)
|
||||
|
||||
#link_directories(
|
||||
# ...
|
||||
#)
|
||||
|
||||
# Set component parameters
|
||||
#set(INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE INTERNAL "" FORCE)
|
||||
|
||||
########################################################################
|
||||
# Create uninstall target
|
||||
########################################################################
|
||||
configure_file(
|
||||
${CMAKE_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in
|
||||
${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
|
||||
@ONLY)
|
||||
|
||||
add_custom_target(uninstall
|
||||
${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
|
||||
)
|
||||
|
||||
########################################################################
|
||||
# Install udev rules
|
||||
########################################################################
|
||||
option(INSTALL_UDEV_RULES "Install udev rules for libosmo-fl2k" OFF)
|
||||
if (INSTALL_UDEV_RULES)
|
||||
install (
|
||||
FILES osmo-fl2k.rules
|
||||
DESTINATION "/etc/udev/rules.d"
|
||||
COMPONENT "udev"
|
||||
)
|
||||
else (INSTALL_UDEV_RULES)
|
||||
message (STATUS "Udev rules not being installed, install them with -DINSTALL_UDEV_RULES=ON")
|
||||
endif (INSTALL_UDEV_RULES)
|
||||
|
||||
########################################################################
|
||||
# Add subdirectories
|
||||
########################################################################
|
||||
add_subdirectory(include)
|
||||
add_subdirectory(src)
|
||||
|
||||
########################################################################
|
||||
# Create Pkg Config File
|
||||
########################################################################
|
||||
FOREACH(inc ${LIBUSB_INCLUDE_DIR})
|
||||
LIST(APPEND FL2K_PC_CFLAGS "-I${inc}")
|
||||
ENDFOREACH(inc)
|
||||
|
||||
FOREACH(lib ${LIBUSB_LIBRARY_DIRS})
|
||||
LIST(APPEND FL2K_PC_LIBS "-L${lib}")
|
||||
ENDFOREACH(lib)
|
||||
|
||||
# use space-separation format for the pc file
|
||||
STRING(REPLACE ";" " " FL2K_PC_CFLAGS "${FL2K_PC_CFLAGS}")
|
||||
STRING(REPLACE ";" " " FL2K_PC_LIBS "${FL2K_PC_LIBS}")
|
||||
|
||||
# unset these vars to avoid hard-coded paths to cross environment
|
||||
IF(CMAKE_CROSSCOMPILING)
|
||||
UNSET(FL2K_PC_CFLAGS)
|
||||
UNSET(FL2K_PC_LIBS)
|
||||
ENDIF(CMAKE_CROSSCOMPILING)
|
||||
|
||||
set(prefix ${CMAKE_INSTALL_PREFIX})
|
||||
set(exec_prefix \${prefix})
|
||||
set(libdir \${exec_prefix}/${LIB_INSTALL_DIR})
|
||||
set(includedir \${prefix}/include)
|
||||
|
||||
CONFIGURE_FILE(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/libosmo-fl2k.pc.in
|
||||
${CMAKE_CURRENT_BINARY_DIR}/libosmo-fl2k.pc
|
||||
@ONLY)
|
||||
|
||||
INSTALL(
|
||||
FILES ${CMAKE_CURRENT_BINARY_DIR}/libosmo-fl2k.pc
|
||||
DESTINATION ${LIB_INSTALL_DIR}/pkgconfig
|
||||
)
|
||||
|
||||
########################################################################
|
||||
# Print Summary
|
||||
########################################################################
|
||||
MESSAGE(STATUS "Building for version: ${VERSION} / ${LIBVER}")
|
||||
MESSAGE(STATUS "Using install prefix: ${CMAKE_INSTALL_PREFIX}")
|
||||
|
|
@ -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.
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,4 @@
|
|||
# osmo-fl2k
|
||||
#### turns FL2000-based USB 3.0 to VGA adapters into low cost DACs
|
||||
|
||||
For more information see https://osmocom.org/projects/osmo-fl2k/wiki
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
# http://www.vtk.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F
|
||||
|
||||
IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
|
||||
MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
|
||||
ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
|
||||
|
||||
FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
|
||||
STRING(REGEX REPLACE "\n" ";" files "${files}")
|
||||
FOREACH(file ${files})
|
||||
MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
|
||||
IF(EXISTS "$ENV{DESTDIR}${file}")
|
||||
EXEC_PROGRAM(
|
||||
"@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
|
||||
OUTPUT_VARIABLE rm_out
|
||||
RETURN_VALUE rm_retval
|
||||
)
|
||||
IF(NOT "${rm_retval}" STREQUAL 0)
|
||||
MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
|
||||
ENDIF(NOT "${rm_retval}" STREQUAL 0)
|
||||
ELSEIF(IS_SYMLINK "$ENV{DESTDIR}${file}")
|
||||
EXEC_PROGRAM(
|
||||
"@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
|
||||
OUTPUT_VARIABLE rm_out
|
||||
RETURN_VALUE rm_retval
|
||||
)
|
||||
IF(NOT "${rm_retval}" STREQUAL 0)
|
||||
MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
|
||||
ENDIF(NOT "${rm_retval}" STREQUAL 0)
|
||||
ELSE(EXISTS "$ENV{DESTDIR}${file}")
|
||||
MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
|
||||
ENDIF(EXISTS "$ENV{DESTDIR}${file}")
|
||||
ENDFOREACH(file)
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
#!/bin/sh
|
||||
# Print a version string.
|
||||
scriptversion=2010-01-28.01
|
||||
|
||||
# Copyright (C) 2007-2010 Free Software Foundation, Inc.
|
||||
#
|
||||
# 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 3 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, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
# This script is derived from GIT-VERSION-GEN from GIT: http://git.or.cz/.
|
||||
# It may be run two ways:
|
||||
# - from a git repository in which the "git describe" command below
|
||||
# produces useful output (thus requiring at least one signed tag)
|
||||
# - from a non-git-repo directory containing a .tarball-version file, which
|
||||
# presumes this script is invoked like "./git-version-gen .tarball-version".
|
||||
|
||||
# In order to use intra-version strings in your project, you will need two
|
||||
# separate generated version string files:
|
||||
#
|
||||
# .tarball-version - present only in a distribution tarball, and not in
|
||||
# a checked-out repository. Created with contents that were learned at
|
||||
# the last time autoconf was run, and used by git-version-gen. Must not
|
||||
# be present in either $(srcdir) or $(builddir) for git-version-gen to
|
||||
# give accurate answers during normal development with a checked out tree,
|
||||
# but must be present in a tarball when there is no version control system.
|
||||
# Therefore, it cannot be used in any dependencies. GNUmakefile has
|
||||
# hooks to force a reconfigure at distribution time to get the value
|
||||
# correct, without penalizing normal development with extra reconfigures.
|
||||
#
|
||||
# .version - present in a checked-out repository and in a distribution
|
||||
# tarball. Usable in dependencies, particularly for files that don't
|
||||
# want to depend on config.h but do want to track version changes.
|
||||
# Delete this file prior to any autoconf run where you want to rebuild
|
||||
# files to pick up a version string change; and leave it stale to
|
||||
# minimize rebuild time after unrelated changes to configure sources.
|
||||
#
|
||||
# It is probably wise to add these two files to .gitignore, so that you
|
||||
# don't accidentally commit either generated file.
|
||||
#
|
||||
# Use the following line in your configure.ac, so that $(VERSION) will
|
||||
# automatically be up-to-date each time configure is run (and note that
|
||||
# since configure.ac no longer includes a version string, Makefile rules
|
||||
# should not depend on configure.ac for version updates).
|
||||
#
|
||||
# AC_INIT([GNU project],
|
||||
# m4_esyscmd([build-aux/git-version-gen .tarball-version]),
|
||||
# [bug-project@example])
|
||||
#
|
||||
# Then use the following lines in your Makefile.am, so that .version
|
||||
# will be present for dependencies, and so that .tarball-version will
|
||||
# exist in distribution tarballs.
|
||||
#
|
||||
# BUILT_SOURCES = $(top_srcdir)/.version
|
||||
# $(top_srcdir)/.version:
|
||||
# echo $(VERSION) > $@-t && mv $@-t $@
|
||||
# dist-hook:
|
||||
# echo $(VERSION) > $(distdir)/.tarball-version
|
||||
|
||||
case $# in
|
||||
1) ;;
|
||||
*) echo 1>&2 "Usage: $0 \$srcdir/.tarball-version"; exit 1;;
|
||||
esac
|
||||
|
||||
tarball_version_file=$1
|
||||
nl='
|
||||
'
|
||||
|
||||
# First see if there is a tarball-only version file.
|
||||
# then try "git describe", then default.
|
||||
if test -f $tarball_version_file
|
||||
then
|
||||
v=`cat $tarball_version_file` || exit 1
|
||||
case $v in
|
||||
*$nl*) v= ;; # reject multi-line output
|
||||
[0-9]*) ;;
|
||||
*) v= ;;
|
||||
esac
|
||||
test -z "$v" \
|
||||
&& echo "$0: WARNING: $tarball_version_file seems to be damaged" 1>&2
|
||||
fi
|
||||
|
||||
if test -n "$v"
|
||||
then
|
||||
: # use $v
|
||||
elif
|
||||
v=`git describe --abbrev=4 --match='v*' HEAD 2>/dev/null \
|
||||
|| git describe --abbrev=4 HEAD 2>/dev/null` \
|
||||
&& case $v in
|
||||
[0-9]*) ;;
|
||||
v[0-9]*) ;;
|
||||
*) (exit 1) ;;
|
||||
esac
|
||||
then
|
||||
# Is this a new git that lists number of commits since the last
|
||||
# tag or the previous older version that did not?
|
||||
# Newer: v6.10-77-g0f8faeb
|
||||
# Older: v6.10-g0f8faeb
|
||||
case $v in
|
||||
*-*-*) : git describe is okay three part flavor ;;
|
||||
*-*)
|
||||
: git describe is older two part flavor
|
||||
# Recreate the number of commits and rewrite such that the
|
||||
# result is the same as if we were using the newer version
|
||||
# of git describe.
|
||||
vtag=`echo "$v" | sed 's/-.*//'`
|
||||
numcommits=`git rev-list "$vtag"..HEAD | wc -l`
|
||||
v=`echo "$v" | sed "s/\(.*\)-\(.*\)/\1-$numcommits-\2/"`;
|
||||
;;
|
||||
esac
|
||||
|
||||
# Change the first '-' to a '.', so version-comparing tools work properly.
|
||||
# Remove the "g" in git describe's output string, to save a byte.
|
||||
v=`echo "$v" | sed 's/-/./;s/\(.*\)-g/\1-/'`;
|
||||
else
|
||||
v=UNKNOWN
|
||||
fi
|
||||
|
||||
v=`echo "$v" |sed 's/^v//'`
|
||||
|
||||
# Don't declare a version "dirty" merely because a time stamp has changed.
|
||||
git status > /dev/null 2>&1
|
||||
|
||||
dirty=`sh -c 'git diff-index --name-only HEAD' 2>/dev/null` || dirty=
|
||||
case "$dirty" in
|
||||
'') ;;
|
||||
*) # Append the suffix only if there isn't one already.
|
||||
case $v in
|
||||
*-dirty) ;;
|
||||
*) v="$v-dirty" ;;
|
||||
esac ;;
|
||||
esac
|
||||
|
||||
# Omit the trailing newline, so that m4_esyscmd can use the result directly.
|
||||
echo "$v" | tr -d '\012'
|
||||
|
||||
# Local variables:
|
||||
# eval: (add-hook 'write-file-hooks 'time-stamp)
|
||||
# time-stamp-start: "scriptversion="
|
||||
# time-stamp-format: "%:y-%02m-%02d.%02H"
|
||||
# time-stamp-end: "$"
|
||||
# End:
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
# Copyright 2018 Osmocom Project
|
||||
#
|
||||
# This file is part of osmo-fl2k
|
||||
#
|
||||
# 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, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
########################################################################
|
||||
# Install public header files
|
||||
########################################################################
|
||||
install(FILES
|
||||
osmo-fl2k.h
|
||||
osmo-fl2k_export.h
|
||||
DESTINATION include
|
||||
)
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
/*
|
||||
* osmo-fl2k, turns FL2000-based USB 3.0 to VGA adapters into
|
||||
* low cost DACs
|
||||
*
|
||||
* Copyright (C) 2016-2018 by Steve Markgraf <steve@steve-m.de>
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0+
|
||||
*
|
||||
* 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, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef __FL2K_H
|
||||
#define __FL2K_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <osmo-fl2k_export.h>
|
||||
|
||||
enum fl2k_error {
|
||||
FL2K_SUCCESS = 0,
|
||||
FL2K_TRUE = 1,
|
||||
FL2K_ERROR_INVALID_PARAM = -1,
|
||||
FL2K_ERROR_NO_DEVICE = -2,
|
||||
FL2K_ERROR_NOT_FOUND = -5,
|
||||
FL2K_ERROR_BUSY = -6,
|
||||
FL2K_ERROR_NO_MEM = -11,
|
||||
};
|
||||
|
||||
typedef struct fl2k_data_info {
|
||||
/* information provided by library */
|
||||
void *ctx;
|
||||
uint32_t underflow_cnt; /* underflows since last callback */
|
||||
uint32_t len; /* buffer length */
|
||||
int using_zerocopy; /* using zerocopy kernel buffers */
|
||||
int device_error; /* device error happened, terminate application */
|
||||
|
||||
/* filled in by application */
|
||||
int sampletype_signed; /* are samples signed or unsigned? */
|
||||
char *r_buf; /* pointer to red buffer */
|
||||
char *g_buf; /* pointer to green buffer */
|
||||
char *b_buf; /* pointer to blue buffer */
|
||||
} fl2k_data_info_t;
|
||||
|
||||
typedef struct fl2k_dev fl2k_dev_t;
|
||||
|
||||
/** The transfer length was chosen by the following criteria:
|
||||
* - Must be a supported resolution of the FL2000DX
|
||||
* - Must be a multiple of 61440 bytes (URB payload length),
|
||||
* which is important for using the DAC without HSYNC/VSYNC blanking,
|
||||
* otherwise a couple of samples are missing between every buffer
|
||||
* - Should be smaller than 4MB in order to be allocatable by kmalloc()
|
||||
* for zerocopy transfers
|
||||
**/
|
||||
#define FL2K_BUF_LEN (1280 * 1024)
|
||||
#define FL2K_XFER_LEN (FL2K_BUF_LEN * 3)
|
||||
|
||||
FL2K_API uint32_t fl2k_get_device_count(void);
|
||||
|
||||
FL2K_API const char* fl2k_get_device_name(uint32_t index);
|
||||
|
||||
FL2K_API int fl2k_open(fl2k_dev_t **dev, uint32_t index);
|
||||
|
||||
FL2K_API int fl2k_close(fl2k_dev_t *dev);
|
||||
|
||||
/* configuration functions */
|
||||
|
||||
/*!
|
||||
* Set the sample rate (pixel clock) for the device
|
||||
*
|
||||
* \param dev the device handle given by fl2k_open()
|
||||
* \param samp_rate the sample rate to be set, maximum value depends
|
||||
* on host and USB controller
|
||||
* \return 0 on success, -EINVAL on invalid rate
|
||||
*/
|
||||
FL2K_API int fl2k_set_sample_rate(fl2k_dev_t *dev, uint32_t target_freq);
|
||||
|
||||
/*!
|
||||
* Get actual sample rate the device is configured to.
|
||||
*
|
||||
* \param dev the device handle given by fl2k_open()
|
||||
* \return 0 on error, sample rate in Hz otherwise
|
||||
*/
|
||||
FL2K_API uint32_t fl2k_get_sample_rate(fl2k_dev_t *dev);
|
||||
|
||||
/* streaming functions */
|
||||
|
||||
typedef void(*fl2k_tx_cb_t)(fl2k_data_info_t *data_info);
|
||||
|
||||
/*!
|
||||
* Starts the tx thread. This function will block until
|
||||
* it is being canceled using fl2k_stop_tx()
|
||||
*
|
||||
* \param dev the device handle given by fl2k_open()
|
||||
* \param ctx user specific context to pass via the callback function
|
||||
* \param buf_num optional buffer count, buf_num * FL2K_BUF_LEN = overall buffer size
|
||||
* set to 0 for default buffer count (4)
|
||||
* \return 0 on success
|
||||
*/
|
||||
FL2K_API int fl2k_start_tx(fl2k_dev_t *dev, fl2k_tx_cb_t cb,
|
||||
void *ctx, uint32_t buf_num);
|
||||
|
||||
/*!
|
||||
* Cancel all pending asynchronous operations on the device.
|
||||
*
|
||||
* \param dev the device handle given by fl2k_open()
|
||||
* \return 0 on success
|
||||
*/
|
||||
FL2K_API int fl2k_stop_tx(fl2k_dev_t *dev);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __FL2K_H */
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
/*
|
||||
* osmo-fl2k, turns FL2000-based USB 3.0 to VGA adapters into
|
||||
* low cost DACs
|
||||
*
|
||||
* Copyright (C) 2016-2018 by Steve Markgraf <steve@steve-m.de>
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0+
|
||||
*
|
||||
* 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, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef FL2K_EXPORT_H
|
||||
#define FL2K_EXPORT_H
|
||||
|
||||
#if defined __GNUC__
|
||||
# if __GNUC__ >= 4
|
||||
# define __FL2K_EXPORT __attribute__((visibility("default")))
|
||||
# define __FL2K_IMPORT __attribute__((visibility("default")))
|
||||
# else
|
||||
# define __FL2K_EXPORT
|
||||
# define __FL2K_IMPORT
|
||||
# endif
|
||||
#elif _MSC_VER
|
||||
# define __FL2K_EXPORT __declspec(dllexport)
|
||||
# define __FL2K_IMPORT __declspec(dllimport)
|
||||
#else
|
||||
# define __FL2K_EXPORT
|
||||
# define __FL2K_IMPORT
|
||||
#endif
|
||||
|
||||
#ifndef libosmo-fl2k_STATIC
|
||||
# ifdef fl2k_EXPORTS
|
||||
# define FL2K_API __FL2K_EXPORT
|
||||
# else
|
||||
# define FL2K_API __FL2K_IMPORT
|
||||
# endif
|
||||
#else
|
||||
#define FL2K_API
|
||||
#endif
|
||||
#endif /* FL2K_EXPORT_H */
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
prefix=@prefix@
|
||||
exec_prefix=@exec_prefix@
|
||||
libdir=@libdir@
|
||||
includedir=@includedir@
|
||||
|
||||
Name: Osmocom osmo-fl2k Library
|
||||
Description: C Utility Library
|
||||
Version: @VERSION@
|
||||
Cflags: -I${includedir}/ @FL2K_PC_CFLAGS@
|
||||
Libs: -L${libdir} -losmo-fl2k -lusb-1.0
|
||||
Libs.private: @FL2K_PC_LIBS@
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
#
|
||||
# Copyright 2016-2018 Osmocom osmo-fl2k project
|
||||
#
|
||||
# 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, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
|
||||
# FL2000 USB 3.0 VGA Adapter default PID/VID
|
||||
SUBSYSTEMS=="usb", ATTRS{idVendor}=="1d5c", ATTRS{idProduct}=="2000", MODE:="0666"
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
# Copyright 2018 Osmocom Project
|
||||
#
|
||||
# This file is part of osmo-fl2k
|
||||
#
|
||||
# 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, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
MACRO(LIBFL2K_APPEND_SRCS)
|
||||
LIST(APPEND libosmo-fl2k_srcs ${ARGV})
|
||||
ENDMACRO(LIBFL2K_APPEND_SRCS)
|
||||
|
||||
LIBFL2K_APPEND_SRCS(
|
||||
libosmo-fl2k.c
|
||||
)
|
||||
|
||||
########################################################################
|
||||
# Set up Windows DLL resource files
|
||||
########################################################################
|
||||
IF(MSVC)
|
||||
include(${CMAKE_SOURCE_DIR}/cmake/Modules/Version.cmake)
|
||||
|
||||
configure_file(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/libosmo-fl2k.rc.in
|
||||
${CMAKE_CURRENT_BINARY_DIR}/libosmo-fl2k.rc
|
||||
@ONLY)
|
||||
|
||||
LIBFL2K_APPEND_SRCS(${CMAKE_CURRENT_BINARY_DIR}/libosmo-fl2k.rc)
|
||||
ENDIF(MSVC)
|
||||
|
||||
########################################################################
|
||||
# Setup shared library variant
|
||||
########################################################################
|
||||
add_library(libosmo-fl2k_shared SHARED ${libosmo-fl2k_srcs})
|
||||
target_link_libraries(libosmo-fl2k_shared ${LIBUSB_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
|
||||
set_target_properties(libosmo-fl2k_shared PROPERTIES DEFINE_SYMBOL "libosmofl2k_EXPORTS")
|
||||
set_target_properties(libosmo-fl2k_shared PROPERTIES OUTPUT_NAME osmo-fl2k)
|
||||
set_target_properties(libosmo-fl2k_shared PROPERTIES SOVERSION ${MAJOR_VERSION})
|
||||
set_target_properties(libosmo-fl2k_shared PROPERTIES VERSION ${LIBVER})
|
||||
|
||||
########################################################################
|
||||
# Setup static library variant
|
||||
########################################################################
|
||||
add_library(libosmo-fl2k_static STATIC ${libosmo-fl2k_srcs})
|
||||
target_link_libraries(libosmo-fl2k_static ${LIBUSB_LIBRARIES})
|
||||
set_property(TARGET libosmo-fl2k_static APPEND PROPERTY COMPILE_DEFINITIONS "libosmofl2k_STATIC" )
|
||||
if(NOT WIN32)
|
||||
# Force same library filename for static and shared variants of the library
|
||||
set_target_properties(libosmo-fl2k_static PROPERTIES OUTPUT_NAME osmo-fl2k)
|
||||
endif()
|
||||
|
||||
########################################################################
|
||||
# Setup libraries used in executables
|
||||
########################################################################
|
||||
if(WIN32)
|
||||
add_library(libgetopt_static STATIC
|
||||
getopt/getopt.c
|
||||
)
|
||||
target_link_libraries(
|
||||
libosmo-fl2k_shared
|
||||
)
|
||||
endif()
|
||||
|
||||
########################################################################
|
||||
# Build utility
|
||||
########################################################################
|
||||
add_executable(fl2k_file fl2k_file.c)
|
||||
add_executable(fl2k_tcp fl2k_tcp.c)
|
||||
add_executable(fl2k_test fl2k_test.c)
|
||||
set(INSTALL_TARGETS libosmo-fl2k_shared libosmo-fl2k_static fl2k_file fl2k_tcp fl2k_test)
|
||||
|
||||
target_link_libraries(fl2k_file libosmo-fl2k_shared
|
||||
${LIBUSB_LIBRARIES}
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
)
|
||||
|
||||
target_link_libraries(fl2k_tcp libosmo-fl2k_shared
|
||||
${LIBUSB_LIBRARIES}
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
)
|
||||
|
||||
target_link_libraries(fl2k_test libosmo-fl2k_shared
|
||||
${LIBUSB_LIBRARIES}
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
)
|
||||
|
||||
|
||||
if(UNIX)
|
||||
target_link_libraries(fl2k_test m)
|
||||
endif()
|
||||
|
||||
if(WIN32)
|
||||
target_link_libraries(fl2k_file libgetopt_static)
|
||||
target_link_libraries(fl2k_tcp ws2_32 libgetopt_static)
|
||||
target_link_libraries(fl2k_test libgetopt_static)
|
||||
set_property(TARGET fl2k_file APPEND PROPERTY COMPILE_DEFINITIONS "libosmo-fl2k_STATIC" )
|
||||
set_property(TARGET fl2k_tcp APPEND PROPERTY COMPILE_DEFINITIONS "libosmo-fl2k_STATIC" )
|
||||
set_property(TARGET fl2k_test APPEND PROPERTY COMPILE_DEFINITIONS "libosmo-fl2k_STATIC" )
|
||||
endif()
|
||||
########################################################################
|
||||
# Install built library files & utilities
|
||||
########################################################################
|
||||
install(TARGETS ${INSTALL_TARGETS}
|
||||
LIBRARY DESTINATION ${LIB_INSTALL_DIR} # .so/.dylib file
|
||||
ARCHIVE DESTINATION ${LIB_INSTALL_DIR} # .lib file
|
||||
RUNTIME DESTINATION bin # .dll file
|
||||
)
|
||||
|
|
@ -0,0 +1,207 @@
|
|||
/*
|
||||
* osmo-fl2k, turns FL2000-based USB 3.0 to VGA adapters into
|
||||
* low cost DACs
|
||||
*
|
||||
* Copyright (C) 2016-2018 by Steve Markgraf <steve@steve-m.de>
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0+
|
||||
*
|
||||
* 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, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef _WIN32
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <windows.h>
|
||||
#include <io.h>
|
||||
#include <fcntl.h>
|
||||
#include "getopt/getopt.h"
|
||||
#endif
|
||||
|
||||
#include "osmo-fl2k.h"
|
||||
|
||||
static fl2k_dev_t *dev = NULL;
|
||||
|
||||
static volatile int do_exit = 0;
|
||||
static volatile int repeat = 1;
|
||||
FILE *file;
|
||||
char *txbuf = NULL;
|
||||
|
||||
void usage(void)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"fl2k_file, a sample player for FL2K VGA dongles\n\n"
|
||||
"Usage:\n"
|
||||
"\t[-d device_index (default: 0)]\n"
|
||||
"\t[-r repeat file (default: 1)]\n"
|
||||
"\t[-s samplerate (default: 100 MS/s)]\n"
|
||||
"\tfilename (use '-' to read from stdin)\n\n"
|
||||
);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
BOOL WINAPI
|
||||
sighandler(int signum)
|
||||
{
|
||||
if (CTRL_C_EVENT == signum) {
|
||||
fprintf(stderr, "Signal caught, exiting!\n");
|
||||
fl2k_stop_tx(dev);
|
||||
do_exit = 1;
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
#else
|
||||
static void sighandler(int signum)
|
||||
{
|
||||
fprintf(stderr, "Signal caught, exiting!\n");
|
||||
fl2k_stop_tx(dev);
|
||||
do_exit = 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
void fl2k_callback(fl2k_data_info_t *data_info)
|
||||
{
|
||||
int r, left = FL2K_BUF_LEN;
|
||||
static uint32_t repeat_cnt = 0;
|
||||
|
||||
data_info->sampletype_signed = 1;
|
||||
data_info->r_buf = txbuf;
|
||||
data_info->g_buf = txbuf;
|
||||
data_info->b_buf = txbuf;
|
||||
|
||||
while (!do_exit && (left > 0)) {
|
||||
r = fread(txbuf + (FL2K_BUF_LEN - left), 1, left, file);
|
||||
|
||||
if (ferror(file))
|
||||
fprintf(stderr, "File Error\n");
|
||||
|
||||
if (feof(file)) {
|
||||
if (repeat) {
|
||||
repeat_cnt++;
|
||||
fprintf(stderr, "repeat %d\n", repeat_cnt);
|
||||
rewind(file);
|
||||
} else {
|
||||
fl2k_stop_tx(dev);
|
||||
do_exit = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (r > 0)
|
||||
left -= r;
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
#ifndef _WIN32
|
||||
struct sigaction sigact, sigign;
|
||||
#endif
|
||||
int r, opt, i;
|
||||
uint32_t samp_rate = 100000000;
|
||||
uint32_t buf_num = 0;
|
||||
int dev_index = 0;
|
||||
void *status;
|
||||
char *filename = NULL;
|
||||
|
||||
while ((opt = getopt(argc, argv, "d:r:s:")) != -1) {
|
||||
switch (opt) {
|
||||
case 'd':
|
||||
dev_index = (uint32_t)atoi(optarg);
|
||||
break;
|
||||
case 'r':
|
||||
repeat = (int)atoi(optarg);
|
||||
break;
|
||||
case 's':
|
||||
samp_rate = (uint32_t)atof(optarg);
|
||||
break;
|
||||
default:
|
||||
usage();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (argc <= optind)
|
||||
usage();
|
||||
else
|
||||
filename = argv[optind];
|
||||
|
||||
if (dev_index < 0)
|
||||
exit(1);
|
||||
|
||||
file = fopen(filename, "rb");
|
||||
if (!file) {
|
||||
fprintf(stderr, "Failed to open %s\n", filename);
|
||||
goto out;
|
||||
}
|
||||
|
||||
txbuf = malloc(FL2K_BUF_LEN);
|
||||
if (!txbuf) {
|
||||
fprintf(stderr, "malloc error!\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
fl2k_open(&dev, (uint32_t)dev_index);
|
||||
if (NULL == dev) {
|
||||
fprintf(stderr, "Failed to open fl2k device #%d.\n", dev_index);
|
||||
goto out;
|
||||
}
|
||||
|
||||
r = fl2k_start_tx(dev, fl2k_callback, NULL, 0);
|
||||
|
||||
/* Set the sample rate */
|
||||
r = fl2k_set_sample_rate(dev, samp_rate);
|
||||
if (r < 0)
|
||||
fprintf(stderr, "WARNING: Failed to set sample rate.\n");
|
||||
|
||||
|
||||
#ifndef _WIN32
|
||||
sigact.sa_handler = sighandler;
|
||||
sigemptyset(&sigact.sa_mask);
|
||||
sigact.sa_flags = 0;
|
||||
sigign.sa_handler = SIG_IGN;
|
||||
sigaction(SIGINT, &sigact, NULL);
|
||||
sigaction(SIGTERM, &sigact, NULL);
|
||||
sigaction(SIGQUIT, &sigact, NULL);
|
||||
sigaction(SIGPIPE, &sigign, NULL);
|
||||
#else
|
||||
SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
|
||||
#endif
|
||||
|
||||
while (!do_exit) {
|
||||
#ifndef _WIN32
|
||||
usleep(500000);
|
||||
#else
|
||||
Sleep(0.5);
|
||||
#endif
|
||||
}
|
||||
|
||||
fl2k_close(dev);
|
||||
|
||||
out:
|
||||
if (txbuf)
|
||||
free(txbuf);
|
||||
|
||||
if (file && (file != stdin))
|
||||
fclose(file);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,250 @@
|
|||
/*
|
||||
* osmo-fl2k, turns FL2000-based USB 3.0 to VGA adapters into
|
||||
* low cost DACs
|
||||
*
|
||||
* Copyright (C) 2016-2018 by Steve Markgraf <steve@steve-m.de>
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0+
|
||||
*
|
||||
* 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, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef _WIN32
|
||||
#include <unistd.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/time.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/tcp.h> /* for TCP_NODELAY */
|
||||
#include <fcntl.h>
|
||||
#else
|
||||
#include <winsock2.h>
|
||||
#include "getopt/getopt.h"
|
||||
#endif
|
||||
|
||||
#include "osmo-fl2k.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#pragma comment(lib, "ws2_32.lib")
|
||||
|
||||
typedef int socklen_t;
|
||||
|
||||
#else
|
||||
#define closesocket close
|
||||
#define SOCKADDR struct sockaddr
|
||||
#define SOCKET int
|
||||
#define SOCKET_ERROR -1
|
||||
#endif
|
||||
|
||||
static SOCKET s;
|
||||
static fl2k_dev_t *dev = NULL;
|
||||
static volatile int do_exit = 0;
|
||||
static volatile int connected = 0;
|
||||
static char *txbuf = NULL;
|
||||
static fd_set readfds;
|
||||
static SOCKET sock;
|
||||
|
||||
void usage(void)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"fl2k_tcp, a spectrum client for FL2K VGA dongles\n\n"
|
||||
"Usage:\t[-a server address]\n"
|
||||
"\t[-d device index (default: 0)]\n"
|
||||
"\t[-p port (default: 1234)]\n"
|
||||
"\t[-s samplerate in Hz (default: 100 MS/s)]\n"
|
||||
"\t[-b number of buffers (default: 4)]\n"
|
||||
);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
BOOL WINAPI
|
||||
sighandler(int signum)
|
||||
{
|
||||
if (CTRL_C_EVENT == signum) {
|
||||
fprintf(stderr, "Signal caught, exiting!\n");
|
||||
fl2k_stop_tx(dev);
|
||||
do_exit = 1;
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
#else
|
||||
static void sighandler(int signum)
|
||||
{
|
||||
fprintf(stderr, "Signal caught, exiting!\n");
|
||||
do_exit = 1;
|
||||
fl2k_stop_tx(dev);
|
||||
}
|
||||
#endif
|
||||
|
||||
void fl2k_callback(fl2k_data_info_t *data_info)
|
||||
{
|
||||
int left = FL2K_BUF_LEN;
|
||||
int received;
|
||||
int r;
|
||||
struct timeval tv = { 1, 0 };
|
||||
|
||||
if (!connected)
|
||||
return;
|
||||
|
||||
data_info->sampletype_signed = 1;
|
||||
data_info->r_buf = txbuf;
|
||||
|
||||
while (!do_exit && (left > 0)) {
|
||||
FD_ZERO(&readfds);
|
||||
FD_SET(sock, &readfds);
|
||||
tv.tv_sec = 1;
|
||||
tv.tv_usec = 0;
|
||||
r = select(sock + 1, &readfds, NULL, NULL, &tv);
|
||||
|
||||
if (r) {
|
||||
received = recv(sock, txbuf + (FL2K_BUF_LEN - left), left, 0);
|
||||
left -= received;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int r, opt, i;
|
||||
char *addr = "127.0.0.1";
|
||||
int port = 1234;
|
||||
uint32_t samp_rate = 100000000;
|
||||
struct sockaddr_in local, remote;
|
||||
uint32_t buf_num = 0;
|
||||
int dev_index = 0;
|
||||
int dev_given = 0;
|
||||
int flag = 1;
|
||||
|
||||
#ifdef _WIN32
|
||||
WSADATA wsd;
|
||||
i = WSAStartup(MAKEWORD(2,2), &wsd);
|
||||
#else
|
||||
struct sigaction sigact, sigign;
|
||||
#endif
|
||||
|
||||
while ((opt = getopt(argc, argv, "d:s:a:p:b:")) != -1) {
|
||||
switch (opt) {
|
||||
case 'd':
|
||||
dev_index = (uint32_t)atoi(optarg);
|
||||
dev_given = 1;
|
||||
break;
|
||||
case 's':
|
||||
samp_rate = (uint32_t)atof(optarg);
|
||||
break;
|
||||
case 'a':
|
||||
addr = optarg;
|
||||
break;
|
||||
case 'p':
|
||||
port = atoi(optarg);
|
||||
break;
|
||||
case 'b':
|
||||
buf_num = atoi(optarg);
|
||||
break;
|
||||
default:
|
||||
usage();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (argc < optind)
|
||||
usage();
|
||||
|
||||
if (dev_index < 0) {
|
||||
exit(1);
|
||||
}
|
||||
|
||||
txbuf = malloc(FL2K_BUF_LEN);
|
||||
|
||||
if (!txbuf) {
|
||||
fprintf(stderr, "malloc error!\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
fl2k_open(&dev, (uint32_t)dev_index);
|
||||
if (NULL == dev) {
|
||||
fprintf(stderr, "Failed to open fl2k device #%d.\n", dev_index);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
r = fl2k_start_tx(dev, fl2k_callback, NULL, buf_num);
|
||||
|
||||
/* Set the sample rate */
|
||||
r = fl2k_set_sample_rate(dev, samp_rate);
|
||||
if (r < 0)
|
||||
fprintf(stderr, "WARNING: Failed to set sample rate.\n");
|
||||
|
||||
#ifndef _WIN32
|
||||
sigact.sa_handler = sighandler;
|
||||
sigemptyset(&sigact.sa_mask);
|
||||
sigact.sa_flags = 0;
|
||||
sigign.sa_handler = SIG_IGN;
|
||||
sigaction(SIGINT, &sigact, NULL);
|
||||
sigaction(SIGTERM, &sigact, NULL);
|
||||
sigaction(SIGQUIT, &sigact, NULL);
|
||||
sigaction(SIGPIPE, &sigact, NULL);
|
||||
#else
|
||||
SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
|
||||
#endif
|
||||
|
||||
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
|
||||
memset(&remote, 0, sizeof(remote));
|
||||
|
||||
remote.sin_family = AF_INET;
|
||||
remote.sin_port = htons(port);
|
||||
remote.sin_addr.s_addr = inet_addr(addr);
|
||||
|
||||
fprintf(stderr, "Connecting to %s:%d...\n", addr, port);
|
||||
while (connect(sock, (struct sockaddr *)&remote, sizeof(remote)) != 0) {
|
||||
#ifndef _WIN32
|
||||
usleep(500000);
|
||||
#else
|
||||
Sleep(0.5);
|
||||
#endif
|
||||
if (do_exit)
|
||||
goto out;
|
||||
}
|
||||
|
||||
setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char *)&flag,sizeof(flag));
|
||||
fprintf(stderr, "Connected\n");
|
||||
connected = 1;
|
||||
|
||||
while (!do_exit) {
|
||||
#ifndef _WIN32
|
||||
usleep(500000);
|
||||
#else
|
||||
Sleep(0.5);
|
||||
#endif
|
||||
}
|
||||
|
||||
out:
|
||||
free(txbuf);
|
||||
fl2k_close(dev);
|
||||
closesocket(s);
|
||||
#ifdef _WIN32
|
||||
WSACleanup();
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,310 @@
|
|||
/*
|
||||
* osmo-fl2k, turns FL2000-based USB 3.0 to VGA adapters into
|
||||
* low cost DACs
|
||||
*
|
||||
* Copyright (C) 2016-2018 by Steve Markgraf <steve@steve-m.de>
|
||||
*
|
||||
* based on rtl_test:
|
||||
*
|
||||
* Copyright (C) 2012-2014 by Steve Markgraf <steve@steve-m.de>
|
||||
* Copyright (C) 2012-2014 by Kyle Keen <keenerd@gmail.com>
|
||||
* Copyright (C) 2014 by Michael Tatarinov <kukabu@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0+
|
||||
*
|
||||
* 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, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
|
||||
#ifdef __APPLE__
|
||||
#include <sys/time.h>
|
||||
#else
|
||||
#include <time.h>
|
||||
#endif
|
||||
|
||||
#ifndef _WIN32
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <windows.h>
|
||||
#include "getopt/getopt.h"
|
||||
#endif
|
||||
|
||||
#include "osmo-fl2k.h"
|
||||
|
||||
#define DEFAULT_SAMPLE_RATE 100000000
|
||||
#define PPM_DURATION 10
|
||||
#define PPM_DUMP_TIME 1
|
||||
|
||||
struct time_generic
|
||||
/* holds all the platform specific values */
|
||||
{
|
||||
#ifndef _WIN32
|
||||
time_t tv_sec;
|
||||
long tv_nsec;
|
||||
#else
|
||||
long tv_sec;
|
||||
long tv_nsec;
|
||||
int init;
|
||||
LARGE_INTEGER frequency;
|
||||
LARGE_INTEGER ticks;
|
||||
#endif
|
||||
};
|
||||
|
||||
static int do_exit = 0;
|
||||
static fl2k_dev_t *dev = NULL;
|
||||
|
||||
static uint32_t samp_rate = DEFAULT_SAMPLE_RATE;
|
||||
static unsigned int ppm_duration = PPM_DURATION;
|
||||
|
||||
static char *buffer;
|
||||
static int cb_cnt = 0;
|
||||
|
||||
void usage(void)
|
||||
{
|
||||
fprintf(stderr,
|
||||
"fl2k_test, clock accuracy test for FL2K VGA dongles,\n"
|
||||
"also outputs a square wave at fs/2\n\n"
|
||||
"Usage:\n"
|
||||
"\t[-d device_index (default: 0)]\n"
|
||||
"\t[-s samplerate (default: 100 MS/s)]\n"
|
||||
);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
BOOL WINAPI
|
||||
sighandler(int signum)
|
||||
{
|
||||
if (CTRL_C_EVENT == signum) {
|
||||
fprintf(stderr, "Signal caught, exiting!\n");
|
||||
fl2k_stop_tx(dev);
|
||||
do_exit = 1;
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
#else
|
||||
static void sighandler(int signum)
|
||||
{
|
||||
fprintf(stderr, "Signal caught, exiting!\n");
|
||||
fl2k_stop_tx(dev);
|
||||
do_exit = 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef _WIN32
|
||||
static int ppm_gettime(struct time_generic *tg)
|
||||
{
|
||||
int rv = ENOSYS;
|
||||
struct timespec ts;
|
||||
|
||||
#ifdef __unix__
|
||||
rv = clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
tg->tv_sec = ts.tv_sec;
|
||||
tg->tv_nsec = ts.tv_nsec;
|
||||
#elif __APPLE__
|
||||
struct timeval tv;
|
||||
|
||||
rv = gettimeofday(&tv, NULL);
|
||||
ts->tv_sec = tv.tv_sec;
|
||||
ts->tv_nsec = tv.tv_usec * 1000;
|
||||
#endif
|
||||
return rv;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
static int ppm_gettime(struct time_generic *tg)
|
||||
{
|
||||
int rv;
|
||||
int64_t frac;
|
||||
if (!tg->init) {
|
||||
QueryPerformanceFrequency(&tg->frequency);
|
||||
tg->init = 1;
|
||||
}
|
||||
rv = QueryPerformanceCounter(&tg->ticks);
|
||||
tg->tv_sec = tg->ticks.QuadPart / tg->frequency.QuadPart;
|
||||
frac = (int64_t)(tg->ticks.QuadPart - (tg->tv_sec * tg->frequency.QuadPart));
|
||||
tg->tv_nsec = (long)(frac * 1000000000L / (int64_t)tg->frequency.QuadPart);
|
||||
return !rv;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int ppm_report(uint64_t nsamples, uint64_t interval)
|
||||
{
|
||||
double real_rate, ppm;
|
||||
|
||||
real_rate = nsamples * 1e9 / interval;
|
||||
ppm = 1e6 * (real_rate / (double)samp_rate - 1.);
|
||||
return (int)round(ppm);
|
||||
}
|
||||
|
||||
static void ppm_test(uint32_t len)
|
||||
{
|
||||
static uint64_t nsamples = 0;
|
||||
static uint64_t interval = 0;
|
||||
static uint64_t nsamples_total = 0;
|
||||
static uint64_t interval_total = 0;
|
||||
static struct time_generic ppm_now;
|
||||
static struct time_generic ppm_recent;
|
||||
|
||||
static enum {
|
||||
PPM_INIT_NO,
|
||||
PPM_INIT_DUMP,
|
||||
PPM_INIT_RUN
|
||||
} ppm_init = PPM_INIT_NO;
|
||||
|
||||
ppm_gettime(&ppm_now);
|
||||
|
||||
if (ppm_init != PPM_INIT_RUN) {
|
||||
/*
|
||||
* Kyle Keen wrote:
|
||||
* PPM_DUMP_TIME throws out the first N seconds of data.
|
||||
* The dongle's PPM is usually very bad when first starting up,
|
||||
* typically incorrect by more than twice the final value.
|
||||
* Discarding the first few seconds allows the value to stabilize much faster.
|
||||
*/
|
||||
if (ppm_init == PPM_INIT_NO) {
|
||||
ppm_recent.tv_sec = ppm_now.tv_sec + PPM_DUMP_TIME;
|
||||
ppm_init = PPM_INIT_DUMP;
|
||||
return;
|
||||
}
|
||||
if (ppm_init == PPM_INIT_DUMP && ppm_recent.tv_sec < ppm_now.tv_sec)
|
||||
return;
|
||||
ppm_recent = ppm_now;
|
||||
ppm_init = PPM_INIT_RUN;
|
||||
return;
|
||||
}
|
||||
nsamples += (uint64_t)len;
|
||||
interval = (uint64_t)(ppm_now.tv_sec - ppm_recent.tv_sec);
|
||||
if (interval < ppm_duration)
|
||||
return;
|
||||
interval *= 1000000000UL;
|
||||
interval += (int64_t)(ppm_now.tv_nsec - ppm_recent.tv_nsec);
|
||||
|
||||
nsamples_total += nsamples;
|
||||
interval_total += interval;
|
||||
printf("real sample rate: %i current PPM: %i cumulative PPM: %i\n",
|
||||
(int)((1000000000UL * nsamples) / interval),
|
||||
ppm_report(nsamples, interval),
|
||||
ppm_report(nsamples_total, interval_total));
|
||||
ppm_recent = ppm_now;
|
||||
nsamples = 0;
|
||||
}
|
||||
|
||||
void fl2k_callback(fl2k_data_info_t *data_info)
|
||||
{
|
||||
/* drop first couple of callbacks until everything is settled */
|
||||
if (cb_cnt > 20) {
|
||||
ppm_test(FL2K_BUF_LEN);
|
||||
} else {
|
||||
/* as data is repetitive, it only needs to be handed
|
||||
* over until all transfer buffers contain the data */
|
||||
data_info->r_buf = buffer;
|
||||
cb_cnt++;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
#ifndef _WIN32
|
||||
struct sigaction sigact;
|
||||
#endif
|
||||
int r, opt, i;
|
||||
uint32_t dev_index = 0;
|
||||
|
||||
while ((opt = getopt(argc, argv, "d:s:p::h")) != -1) {
|
||||
switch (opt) {
|
||||
case 'd':
|
||||
dev_index = (uint32_t)atoi(optarg);
|
||||
break;
|
||||
case 's':
|
||||
samp_rate = (uint32_t)atof(optarg);
|
||||
break;
|
||||
case 'p':
|
||||
if (optarg)
|
||||
ppm_duration = atoi(optarg);
|
||||
break;
|
||||
case 'h':
|
||||
default:
|
||||
usage();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
buffer = malloc(FL2K_BUF_LEN);
|
||||
if (!buffer)
|
||||
goto exit;
|
||||
|
||||
fl2k_open(&dev, (uint32_t)dev_index);
|
||||
if (NULL == dev) {
|
||||
fprintf(stderr, "Failed to open fl2k device #%d.\n", dev_index);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
#ifndef _WIN32
|
||||
sigact.sa_handler = sighandler;
|
||||
sigemptyset(&sigact.sa_mask);
|
||||
sigact.sa_flags = 0;
|
||||
sigaction(SIGINT, &sigact, NULL);
|
||||
sigaction(SIGTERM, &sigact, NULL);
|
||||
sigaction(SIGQUIT, &sigact, NULL);
|
||||
sigaction(SIGPIPE, &sigact, NULL);
|
||||
#else
|
||||
SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
|
||||
#endif
|
||||
|
||||
/* initialize buffer with rect signal */
|
||||
for (i = 0; i < FL2K_BUF_LEN; i += 2) {
|
||||
buffer[i] = 0x00;
|
||||
buffer[i+1] = 0xff;
|
||||
}
|
||||
|
||||
r = fl2k_start_tx(dev, fl2k_callback, NULL, 0);
|
||||
|
||||
/* Set the sample rate */
|
||||
r = fl2k_set_sample_rate(dev, samp_rate);
|
||||
if (r < 0)
|
||||
fprintf(stderr, "WARNING: Failed to set sample rate.\n");
|
||||
|
||||
samp_rate = fl2k_get_sample_rate(dev);
|
||||
|
||||
fprintf(stderr, "Reporting PPM error measurement every %u seconds...\n", ppm_duration);
|
||||
fprintf(stderr, "Press ^C after a few minutes.\n");
|
||||
|
||||
while (!do_exit) {
|
||||
#ifndef _WIN32
|
||||
usleep(500000);
|
||||
#else
|
||||
Sleep(0.5);
|
||||
#endif
|
||||
}
|
||||
|
||||
if (do_exit) {
|
||||
fprintf(stderr, "\nUser cancel, exiting...\n");
|
||||
}
|
||||
|
||||
exit:
|
||||
fl2k_close(dev);
|
||||
free(buffer);
|
||||
|
||||
return 0;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,180 @@
|
|||
/* Declarations for getopt.
|
||||
Copyright (C) 1989-1994, 1996-1999, 2001 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C 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.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C 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 the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#ifndef _GETOPT_H
|
||||
|
||||
#ifndef __need_getopt
|
||||
# define _GETOPT_H 1
|
||||
#endif
|
||||
|
||||
/* If __GNU_LIBRARY__ is not already defined, either we are being used
|
||||
standalone, or this is the first header included in the source file.
|
||||
If we are being used with glibc, we need to include <features.h>, but
|
||||
that does not exist if we are standalone. So: if __GNU_LIBRARY__ is
|
||||
not defined, include <ctype.h>, which will pull in <features.h> for us
|
||||
if it's from glibc. (Why ctype.h? It's guaranteed to exist and it
|
||||
doesn't flood the namespace with stuff the way some other headers do.) */
|
||||
#if !defined __GNU_LIBRARY__
|
||||
# include <ctype.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* For communication from `getopt' to the caller.
|
||||
When `getopt' finds an option that takes an argument,
|
||||
the argument value is returned here.
|
||||
Also, when `ordering' is RETURN_IN_ORDER,
|
||||
each non-option ARGV-element is returned here. */
|
||||
|
||||
extern char *optarg;
|
||||
|
||||
/* Index in ARGV of the next element to be scanned.
|
||||
This is used for communication to and from the caller
|
||||
and for communication between successive calls to `getopt'.
|
||||
|
||||
On entry to `getopt', zero means this is the first call; initialize.
|
||||
|
||||
When `getopt' returns -1, this is the index of the first of the
|
||||
non-option elements that the caller should itself scan.
|
||||
|
||||
Otherwise, `optind' communicates from one call to the next
|
||||
how much of ARGV has been scanned so far. */
|
||||
|
||||
extern int optind;
|
||||
|
||||
/* Callers store zero here to inhibit the error message `getopt' prints
|
||||
for unrecognized options. */
|
||||
|
||||
extern int opterr;
|
||||
|
||||
/* Set to an option character which was unrecognized. */
|
||||
|
||||
extern int optopt;
|
||||
|
||||
#ifndef __need_getopt
|
||||
/* Describe the long-named options requested by the application.
|
||||
The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
|
||||
of `struct option' terminated by an element containing a name which is
|
||||
zero.
|
||||
|
||||
The field `has_arg' is:
|
||||
no_argument (or 0) if the option does not take an argument,
|
||||
required_argument (or 1) if the option requires an argument,
|
||||
optional_argument (or 2) if the option takes an optional argument.
|
||||
|
||||
If the field `flag' is not NULL, it points to a variable that is set
|
||||
to the value given in the field `val' when the option is found, but
|
||||
left unchanged if the option is not found.
|
||||
|
||||
To have a long-named option do something other than set an `int' to
|
||||
a compiled-in constant, such as set a value from `optarg', set the
|
||||
option's `flag' field to zero and its `val' field to a nonzero
|
||||
value (the equivalent single-letter option character, if there is
|
||||
one). For long options that have a zero `flag' field, `getopt'
|
||||
returns the contents of the `val' field. */
|
||||
|
||||
struct option
|
||||
{
|
||||
# if (defined __STDC__ && __STDC__) || defined __cplusplus
|
||||
const char *name;
|
||||
# else
|
||||
char *name;
|
||||
# endif
|
||||
/* has_arg can't be an enum because some compilers complain about
|
||||
type mismatches in all the code that assumes it is an int. */
|
||||
int has_arg;
|
||||
int *flag;
|
||||
int val;
|
||||
};
|
||||
|
||||
/* Names for the values of the `has_arg' field of `struct option'. */
|
||||
|
||||
# define no_argument 0
|
||||
# define required_argument 1
|
||||
# define optional_argument 2
|
||||
#endif /* need getopt */
|
||||
|
||||
|
||||
/* Get definitions and prototypes for functions to process the
|
||||
arguments in ARGV (ARGC of them, minus the program name) for
|
||||
options given in OPTS.
|
||||
|
||||
Return the option character from OPTS just read. Return -1 when
|
||||
there are no more options. For unrecognized options, or options
|
||||
missing arguments, `optopt' is set to the option letter, and '?' is
|
||||
returned.
|
||||
|
||||
The OPTS string is a list of characters which are recognized option
|
||||
letters, optionally followed by colons, specifying that that letter
|
||||
takes an argument, to be placed in `optarg'.
|
||||
|
||||
If a letter in OPTS is followed by two colons, its argument is
|
||||
optional. This behavior is specific to the GNU `getopt'.
|
||||
|
||||
The argument `--' causes premature termination of argument
|
||||
scanning, explicitly telling `getopt' that there are no more
|
||||
options.
|
||||
|
||||
If OPTS begins with `--', then non-option arguments are treated as
|
||||
arguments to the option '\0'. This behavior is specific to the GNU
|
||||
`getopt'. */
|
||||
|
||||
#if (defined __STDC__ && __STDC__) || defined __cplusplus
|
||||
# ifdef __GNU_LIBRARY__
|
||||
/* Many other libraries have conflicting prototypes for getopt, with
|
||||
differences in the consts, in stdlib.h. To avoid compilation
|
||||
errors, only prototype getopt for the GNU C library. */
|
||||
extern int getopt (int __argc, char *const *__argv, const char *__shortopts);
|
||||
# else /* not __GNU_LIBRARY__ */
|
||||
extern int getopt ();
|
||||
# endif /* __GNU_LIBRARY__ */
|
||||
|
||||
# ifndef __need_getopt
|
||||
extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts,
|
||||
const struct option *__longopts, int *__longind);
|
||||
extern int getopt_long_only (int __argc, char *const *__argv,
|
||||
const char *__shortopts,
|
||||
const struct option *__longopts, int *__longind);
|
||||
|
||||
/* Internal only. Users should not call this directly. */
|
||||
extern int _getopt_internal (int __argc, char *const *__argv,
|
||||
const char *__shortopts,
|
||||
const struct option *__longopts, int *__longind,
|
||||
int __long_only);
|
||||
# endif
|
||||
#else /* not __STDC__ */
|
||||
extern int getopt ();
|
||||
# ifndef __need_getopt
|
||||
extern int getopt_long ();
|
||||
extern int getopt_long_only ();
|
||||
|
||||
extern int _getopt_internal ();
|
||||
# endif
|
||||
#endif /* __STDC__ */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Make sure we later can get all the definitions and declarations. */
|
||||
#undef __need_getopt
|
||||
|
||||
#endif /* getopt.h */
|
||||
|
|
@ -0,0 +1,969 @@
|
|||
/*
|
||||
* osmo-fl2k, turns FL2000-based USB 3.0 to VGA adapters into
|
||||
* low cost DACs
|
||||
*
|
||||
* Copyright (C) 2016-2018 by Steve Markgraf <steve@steve-m.de>
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0+
|
||||
*
|
||||
* 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, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <signal.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef _WIN32
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include <math.h>
|
||||
#include <libusb.h>
|
||||
#include <pthread.h>
|
||||
|
||||
/*
|
||||
* All libusb callback functions should be marked with the LIBUSB_CALL macro
|
||||
* to ensure that they are compiled with the same calling convention as libusb.
|
||||
*
|
||||
* If the macro isn't available in older libusb versions, we simply define it.
|
||||
*/
|
||||
#ifndef LIBUSB_CALL
|
||||
#define LIBUSB_CALL
|
||||
#endif
|
||||
|
||||
/* libusb < 1.0.9 doesn't have libusb_handle_events_timeout_completed */
|
||||
#ifndef HAVE_LIBUSB_HANDLE_EVENTS_TIMEOUT_COMPLETED
|
||||
#define libusb_handle_events_timeout_completed(ctx, tv, c) \
|
||||
libusb_handle_events_timeout(ctx, tv)
|
||||
#endif
|
||||
|
||||
#include "osmo-fl2k.h"
|
||||
|
||||
enum fl2k_async_status {
|
||||
FL2K_INACTIVE = 0,
|
||||
FL2K_CANCELING,
|
||||
FL2K_RUNNING
|
||||
};
|
||||
|
||||
typedef enum fl2k_buf_state {
|
||||
BUF_EMPTY = 0,
|
||||
BUF_SUBMITTED,
|
||||
BUF_FILLED,
|
||||
} fl2k_buf_state_t;
|
||||
|
||||
typedef struct fl2k_xfer_info {
|
||||
fl2k_dev_t *dev;
|
||||
uint64_t seq;
|
||||
fl2k_buf_state_t state;
|
||||
} fl2k_xfer_info_t;
|
||||
|
||||
struct fl2k_dev {
|
||||
libusb_context *ctx;
|
||||
struct libusb_device_handle *devh;
|
||||
uint32_t xfer_num;
|
||||
uint32_t xfer_buf_num;
|
||||
uint32_t xfer_buf_len;
|
||||
struct libusb_transfer **xfer;
|
||||
unsigned char **xfer_buf;
|
||||
|
||||
fl2k_xfer_info_t *xfer_info;
|
||||
|
||||
fl2k_tx_cb_t cb;
|
||||
void *cb_ctx;
|
||||
enum fl2k_async_status async_status;
|
||||
int async_cancel;
|
||||
|
||||
int use_zerocopy;
|
||||
int terminate;
|
||||
|
||||
/* thread related */
|
||||
pthread_t usb_worker_thread;
|
||||
pthread_t sample_worker_thread;
|
||||
pthread_mutex_t buf_mutex;
|
||||
pthread_cond_t buf_cond;
|
||||
|
||||
double rate; /* Hz */
|
||||
|
||||
/* status */
|
||||
int dev_lost;
|
||||
int driver_active;
|
||||
uint32_t underflow_cnt;
|
||||
};
|
||||
|
||||
typedef struct fl2k_dongle {
|
||||
uint16_t vid;
|
||||
uint16_t pid;
|
||||
const char *name;
|
||||
} fl2k_dongle_t;
|
||||
|
||||
static fl2k_dongle_t known_devices[] = {
|
||||
{ 0x1d5c, 0x2000, "FL2000DX OEM" },
|
||||
};
|
||||
|
||||
#define DEFAULT_BUF_NUMBER 4
|
||||
|
||||
#define CTRL_IN (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN)
|
||||
#define CTRL_OUT (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT)
|
||||
#define CTRL_TIMEOUT 300
|
||||
#define BULK_TIMEOUT 0
|
||||
|
||||
static int fl2k_read_reg(fl2k_dev_t *dev, uint16_t reg, uint32_t *val)
|
||||
{
|
||||
int r;
|
||||
uint8_t data[4];
|
||||
|
||||
if (!dev || !val)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
r = libusb_control_transfer(dev->devh, CTRL_IN, 0x40,
|
||||
0, reg, data, 4, CTRL_TIMEOUT);
|
||||
|
||||
if (r < 4)
|
||||
fprintf(stderr, "Error, short read from register!\n");
|
||||
|
||||
*val = (data[3] << 24) | (data[2] << 16) | (data[1] << 8) | data[0];
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static int fl2k_write_reg(fl2k_dev_t *dev, uint16_t reg, uint32_t val)
|
||||
{
|
||||
uint8_t data[4];
|
||||
|
||||
if (!dev)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
data[0] = val & 0xff;
|
||||
data[1] = (val >> 8) & 0xff;
|
||||
data[2] = (val >> 16) & 0xff;
|
||||
data[3] = (val >> 24) & 0xff;
|
||||
|
||||
return libusb_control_transfer(dev->devh, CTRL_OUT, 0x41,
|
||||
0, reg, data, 4, CTRL_TIMEOUT);
|
||||
}
|
||||
|
||||
int fl2k_init_device(fl2k_dev_t *dev)
|
||||
{
|
||||
if (!dev)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
/* initialization */
|
||||
fl2k_write_reg(dev, 0x8020, 0xdf0000cc);
|
||||
|
||||
/* set DAC freq to lowest value possible to avoid
|
||||
* underrun during init */
|
||||
fl2k_write_reg(dev, 0x802c, 0x00416f3f);
|
||||
|
||||
fl2k_write_reg(dev, 0x8048, 0x7ffb8004);
|
||||
fl2k_write_reg(dev, 0x803c, 0xd701004d);
|
||||
fl2k_write_reg(dev, 0x8004, 0x0000031c);
|
||||
fl2k_write_reg(dev, 0x8004, 0x0010039d);
|
||||
fl2k_write_reg(dev, 0x8008, 0x07800898);
|
||||
|
||||
fl2k_write_reg(dev, 0x801c, 0x00000000);
|
||||
fl2k_write_reg(dev, 0x0070, 0x04186085);
|
||||
|
||||
/* blanking magic */
|
||||
fl2k_write_reg(dev, 0x8008, 0xfeff0780);
|
||||
fl2k_write_reg(dev, 0x800c, 0x0000f001);
|
||||
|
||||
/* VSYNC magic */
|
||||
fl2k_write_reg(dev, 0x8010, 0x0400042a);
|
||||
fl2k_write_reg(dev, 0x8014, 0x0010002d);
|
||||
|
||||
fl2k_write_reg(dev, 0x8004, 0x00000002);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fl2k_deinit_device(fl2k_dev_t *dev)
|
||||
{
|
||||
int r = 0;
|
||||
|
||||
if (!dev)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
/* TODO, power down DACs, PLL, put device in reset */
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static double fl2k_reg_to_freq(uint32_t reg)
|
||||
{
|
||||
double sample_clock, offset, offs_div;
|
||||
uint32_t pll_clock = 160000000;
|
||||
uint8_t div = reg & 0x3f;
|
||||
uint8_t out_div = (reg >> 8) & 0xf;
|
||||
uint8_t frac = (reg >> 16) & 0xf;
|
||||
uint8_t mult = (reg >> 20) & 0xf;
|
||||
|
||||
sample_clock = (pll_clock * mult) / (uint32_t)div;
|
||||
offs_div = (pll_clock / 5.0f ) * mult;
|
||||
offset = ((double)sample_clock/(offs_div/2)) * 1000000.0f;
|
||||
sample_clock += (uint32_t)offset * frac;
|
||||
sample_clock /= out_div;
|
||||
|
||||
// fprintf(stderr, "div: %d\tod: %d\tfrac: %d\tmult %d\tclock: %f\treg "
|
||||
// "%08x\n", div, out_div, frac, mult, sample_clock, reg);
|
||||
|
||||
return sample_clock;
|
||||
}
|
||||
|
||||
int fl2k_set_sample_rate(fl2k_dev_t *dev, uint32_t target_freq)
|
||||
{
|
||||
double sample_clock, error, last_error = 1e20f;
|
||||
uint32_t reg = 0, result_reg = 0;
|
||||
uint8_t div, mult, frac, out_div;
|
||||
|
||||
if (!dev)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
/* Output divider (accepts value 1-15)
|
||||
* works, but adds lots of phase noise, so do not use it */
|
||||
out_div = 1;
|
||||
|
||||
/* Observation: PLL multiplier of 7 works, but has more phase
|
||||
* noise. Prefer multiplier 6 and 5 */
|
||||
for (mult = 6; mult >= 3; mult--) {
|
||||
for (div = 63; div > 1; div--) {
|
||||
for (frac = 1; frac <= 15; frac++) {
|
||||
reg = (mult << 20) | (frac << 16) |
|
||||
(0x60 << 8) | (out_div << 8) | div;
|
||||
|
||||
sample_clock = fl2k_reg_to_freq(reg);
|
||||
error = sample_clock - (double)target_freq;
|
||||
|
||||
/* Keep closest match */
|
||||
if (fabsf(error) < last_error) {
|
||||
result_reg = reg;
|
||||
last_error = fabsf(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sample_clock = fl2k_reg_to_freq(result_reg);
|
||||
error = sample_clock - (double)target_freq;
|
||||
dev->rate = sample_clock;
|
||||
|
||||
if (fabsf(error) > 1)
|
||||
fprintf(stderr, "Requested sample rate %d not possible, using"
|
||||
" %f, error is %f\n", target_freq, sample_clock, error);
|
||||
|
||||
return fl2k_write_reg(dev, 0x802c, result_reg);
|
||||
}
|
||||
|
||||
uint32_t fl2k_get_sample_rate(fl2k_dev_t *dev)
|
||||
{
|
||||
if (!dev)
|
||||
return 0;
|
||||
|
||||
return (uint32_t)dev->rate;
|
||||
}
|
||||
|
||||
static fl2k_dongle_t *find_known_device(uint16_t vid, uint16_t pid)
|
||||
{
|
||||
unsigned int i;
|
||||
fl2k_dongle_t *device = NULL;
|
||||
|
||||
for (i = 0; i < sizeof(known_devices)/sizeof(fl2k_dongle_t); i++ ) {
|
||||
if (known_devices[i].vid == vid && known_devices[i].pid == pid) {
|
||||
device = &known_devices[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return device;
|
||||
}
|
||||
|
||||
uint32_t fl2k_get_device_count(void)
|
||||
{
|
||||
int i,r;
|
||||
libusb_context *ctx;
|
||||
libusb_device **list;
|
||||
uint32_t device_count = 0;
|
||||
struct libusb_device_descriptor dd;
|
||||
ssize_t cnt;
|
||||
|
||||
r = libusb_init(&ctx);
|
||||
if (r < 0)
|
||||
return 0;
|
||||
|
||||
cnt = libusb_get_device_list(ctx, &list);
|
||||
|
||||
for (i = 0; i < cnt; i++) {
|
||||
libusb_get_device_descriptor(list[i], &dd);
|
||||
|
||||
if (find_known_device(dd.idVendor, dd.idProduct))
|
||||
device_count++;
|
||||
}
|
||||
|
||||
libusb_free_device_list(list, 1);
|
||||
|
||||
libusb_exit(ctx);
|
||||
|
||||
return device_count;
|
||||
}
|
||||
|
||||
const char *fl2k_get_device_name(uint32_t index)
|
||||
{
|
||||
int i,r;
|
||||
libusb_context *ctx;
|
||||
libusb_device **list;
|
||||
struct libusb_device_descriptor dd;
|
||||
fl2k_dongle_t *device = NULL;
|
||||
uint32_t device_count = 0;
|
||||
ssize_t cnt;
|
||||
|
||||
r = libusb_init(&ctx);
|
||||
if (r < 0)
|
||||
return "";
|
||||
|
||||
cnt = libusb_get_device_list(ctx, &list);
|
||||
|
||||
for (i = 0; i < cnt; i++) {
|
||||
libusb_get_device_descriptor(list[i], &dd);
|
||||
|
||||
device = find_known_device(dd.idVendor, dd.idProduct);
|
||||
|
||||
if (device) {
|
||||
device_count++;
|
||||
|
||||
if (index == device_count - 1)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
libusb_free_device_list(list, 1);
|
||||
|
||||
libusb_exit(ctx);
|
||||
|
||||
if (device)
|
||||
return device->name;
|
||||
else
|
||||
return "";
|
||||
}
|
||||
|
||||
int fl2k_open(fl2k_dev_t **out_dev, uint32_t index)
|
||||
{
|
||||
int r;
|
||||
int i;
|
||||
libusb_device **list;
|
||||
fl2k_dev_t *dev = NULL;
|
||||
libusb_device *device = NULL;
|
||||
uint32_t device_count = 0;
|
||||
struct libusb_device_descriptor dd;
|
||||
uint8_t reg;
|
||||
ssize_t cnt;
|
||||
|
||||
dev = malloc(sizeof(fl2k_dev_t));
|
||||
if (NULL == dev)
|
||||
return -ENOMEM;
|
||||
|
||||
memset(dev, 0, sizeof(fl2k_dev_t));
|
||||
|
||||
r = libusb_init(&dev->ctx);
|
||||
if(r < 0){
|
||||
free(dev);
|
||||
return -1;
|
||||
}
|
||||
|
||||
libusb_set_debug(dev->ctx, 3);
|
||||
|
||||
dev->dev_lost = 1;
|
||||
|
||||
cnt = libusb_get_device_list(dev->ctx, &list);
|
||||
|
||||
for (i = 0; i < cnt; i++) {
|
||||
device = list[i];
|
||||
|
||||
libusb_get_device_descriptor(list[i], &dd);
|
||||
|
||||
if (find_known_device(dd.idVendor, dd.idProduct)) {
|
||||
device_count++;
|
||||
}
|
||||
|
||||
if (index == device_count - 1)
|
||||
break;
|
||||
|
||||
device = NULL;
|
||||
}
|
||||
|
||||
if (!device) {
|
||||
r = -1;
|
||||
goto err;
|
||||
}
|
||||
|
||||
r = libusb_open(device, &dev->devh);
|
||||
libusb_free_device_list(list, 1);
|
||||
if (r < 0) {
|
||||
fprintf(stderr, "usb_open error %d\n", r);
|
||||
if(r == LIBUSB_ERROR_ACCESS)
|
||||
fprintf(stderr, "Please fix the device permissions, e.g. "
|
||||
"by installing the udev rules file\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
/* If the adapter has an SPI flash for the Windows driver, we
|
||||
* need to detach the USB mass storage driver first in order to
|
||||
* open the device */
|
||||
if (libusb_kernel_driver_active(dev->devh, 3) == 1) {
|
||||
fprintf(stderr, "Kernel mass storage driver is attached, "
|
||||
"detaching driver. This may take more than"
|
||||
" 10 seconds!\n");
|
||||
r = libusb_detach_kernel_driver(dev->devh, 3);
|
||||
if (r < 0) {
|
||||
fprintf(stderr, "Failed to detach mass storage "
|
||||
"driver: %d\n", r);
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
r = libusb_claim_interface(dev->devh, 0);
|
||||
if (r < 0) {
|
||||
fprintf(stderr, "usb_claim_interface 0 error %d\n", r);
|
||||
goto err;
|
||||
}
|
||||
r = libusb_claim_interface(dev->devh, 1);
|
||||
|
||||
if (r < 0) {
|
||||
fprintf(stderr, "usb_claim_interface 1 error %d\n", r);
|
||||
goto err;
|
||||
}
|
||||
|
||||
r = fl2k_init_device(dev);
|
||||
if (r < 0)
|
||||
goto err;
|
||||
|
||||
dev->dev_lost = 0;
|
||||
|
||||
found:
|
||||
*out_dev = dev;
|
||||
|
||||
return 0;
|
||||
err:
|
||||
if (dev) {
|
||||
if (dev->ctx)
|
||||
libusb_exit(dev->ctx);
|
||||
|
||||
free(dev);
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
int fl2k_close(fl2k_dev_t *dev)
|
||||
{
|
||||
if (!dev)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
if(!dev->dev_lost) {
|
||||
/* block until all async operations have been completed (if any) */
|
||||
while (FL2K_INACTIVE != dev->async_status) {
|
||||
#ifdef _WIN32
|
||||
Sleep(1);
|
||||
#else
|
||||
usleep(1000);
|
||||
#endif
|
||||
}
|
||||
|
||||
fl2k_deinit_device(dev);
|
||||
}
|
||||
|
||||
libusb_release_interface(dev->devh, 0);
|
||||
libusb_close(dev->devh);
|
||||
libusb_exit(dev->ctx);
|
||||
|
||||
free(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct libusb_transfer *fl2k_get_next_xfer(fl2k_dev_t *dev,
|
||||
fl2k_buf_state_t state)
|
||||
{
|
||||
unsigned int i;
|
||||
int next_buf = -1;
|
||||
uint64_t next_seq = 0;
|
||||
fl2k_xfer_info_t *xfer_info;
|
||||
|
||||
for (i = 0; i < dev->xfer_buf_num; i++) {
|
||||
xfer_info = (fl2k_xfer_info_t *)dev->xfer[i]->user_data;
|
||||
if (!xfer_info)
|
||||
continue;
|
||||
|
||||
if (xfer_info->state == state) {
|
||||
if (state == BUF_EMPTY) {
|
||||
return dev->xfer[i];
|
||||
} else if ((xfer_info->seq < next_seq) || next_buf < 0) {
|
||||
next_seq = xfer_info->seq;
|
||||
next_buf = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ((state == BUF_FILLED) && (next_buf >= 0))
|
||||
return dev->xfer[next_buf];
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void LIBUSB_CALL _libusb_callback(struct libusb_transfer *xfer)
|
||||
{
|
||||
fl2k_xfer_info_t *xfer_info = (fl2k_xfer_info_t *)xfer->user_data;
|
||||
fl2k_xfer_info_t *next_xfer_info;
|
||||
fl2k_dev_t *dev = (fl2k_dev_t *)xfer_info->dev;
|
||||
struct libusb_transfer *next_xfer = NULL;
|
||||
|
||||
if (LIBUSB_TRANSFER_COMPLETED == xfer->status) {
|
||||
/* resubmit transfer */
|
||||
if (FL2K_RUNNING == dev->async_status) {
|
||||
/* get next transfer */
|
||||
next_xfer = fl2k_get_next_xfer(dev, BUF_FILLED);
|
||||
|
||||
if (next_xfer) {
|
||||
next_xfer_info = (fl2k_xfer_info_t *) next_xfer->user_data;
|
||||
|
||||
/* Submit next filled transfer */
|
||||
next_xfer_info->state = BUF_SUBMITTED;
|
||||
libusb_submit_transfer(next_xfer);
|
||||
|
||||
xfer_info->state = BUF_EMPTY;
|
||||
pthread_cond_signal(&dev->buf_cond);
|
||||
} else {
|
||||
/* We need to re-submit the transfer
|
||||
* in any case, as otherwise the device
|
||||
* stops to output data and hangs
|
||||
* (happens only in the hacked 'gapless'
|
||||
* mode without HSYNC and VSYNC) */
|
||||
libusb_submit_transfer(xfer);
|
||||
pthread_cond_signal(&dev->buf_cond);
|
||||
dev->underflow_cnt++;
|
||||
}
|
||||
}
|
||||
} else if (LIBUSB_TRANSFER_CANCELLED != xfer->status) {
|
||||
dev->dev_lost = 1;
|
||||
fl2k_stop_tx(dev);
|
||||
pthread_cond_signal(&dev->buf_cond);
|
||||
fprintf(stderr, "cb transfer status: %d, "
|
||||
"canceling...\n", xfer->status);
|
||||
}
|
||||
}
|
||||
|
||||
static int fl2k_alloc_submit_transfers(fl2k_dev_t *dev)
|
||||
{
|
||||
unsigned int i;
|
||||
int r = 0;
|
||||
|
||||
if (!dev)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
dev->xfer = malloc(dev->xfer_buf_num * sizeof(struct libusb_transfer *));
|
||||
|
||||
for (i = 0; i < dev->xfer_buf_num; ++i)
|
||||
dev->xfer[i] = libusb_alloc_transfer(0);
|
||||
|
||||
dev->xfer_buf = malloc(dev->xfer_buf_num * sizeof(unsigned char *));
|
||||
dev->xfer_info = malloc(dev->xfer_buf_num * sizeof(fl2k_xfer_info_t));
|
||||
|
||||
#if defined (__linux__) && LIBUSB_API_VERSION >= 0x01000105
|
||||
fprintf(stderr, "Using %d zero-copy buffers\n", dev->xfer_buf_num);
|
||||
|
||||
dev->use_zerocopy = 1;
|
||||
for (i = 0; i < dev->xfer_buf_num; ++i) {
|
||||
dev->xfer_buf[i] = libusb_dev_mem_alloc(dev->devh, dev->xfer_buf_len);
|
||||
|
||||
if (!dev->xfer_buf[i]) {
|
||||
fprintf(stderr, "Failed to allocate zerocopy"
|
||||
" buffer for transfer %d\n",
|
||||
i);
|
||||
|
||||
// TODO: free dev_mem buffers again
|
||||
dev->use_zerocopy = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!dev->use_zerocopy) {
|
||||
for (i = 0; i < dev->xfer_buf_num; ++i) {
|
||||
dev->xfer_buf[i] = malloc(dev->xfer_buf_len);
|
||||
|
||||
if (!dev->xfer_buf[i])
|
||||
return FL2K_ERROR_NO_MEM;
|
||||
}
|
||||
}
|
||||
|
||||
/* fill transfers */
|
||||
for (i = 0; i < dev->xfer_buf_num; ++i) {
|
||||
libusb_fill_bulk_transfer(dev->xfer[i],
|
||||
dev->devh,
|
||||
0x01,
|
||||
dev->xfer_buf[i],
|
||||
dev->xfer_buf_len,
|
||||
_libusb_callback,
|
||||
&dev->xfer_info[i],
|
||||
0);
|
||||
|
||||
dev->xfer_info[i].dev = dev;
|
||||
dev->xfer_info[i].state = BUF_EMPTY;
|
||||
|
||||
/* if we allocate the memory through the Kernel, it is
|
||||
* already cleared */
|
||||
if (!dev->use_zerocopy)
|
||||
memset(dev->xfer_buf[i], 0, dev->xfer_buf_len);
|
||||
}
|
||||
|
||||
/* submit transfers */
|
||||
for (i = 0; i < dev->xfer_num; ++i) {
|
||||
r = libusb_submit_transfer(dev->xfer[i]);
|
||||
dev->xfer_info[i].state = BUF_SUBMITTED;
|
||||
|
||||
if (r < 0) {
|
||||
fprintf(stderr, "Failed to submit transfer %i\n"
|
||||
"Please increase your allowed "
|
||||
"usbfs buffer size with the "
|
||||
"following command:\n"
|
||||
"echo 0 > /sys/module/usbcore"
|
||||
"/parameters/usbfs_memory_mb\n", i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int _fl2k_free_async_buffers(fl2k_dev_t *dev)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
if (!dev)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
if (dev->xfer) {
|
||||
for (i = 0; i < dev->xfer_buf_num; ++i) {
|
||||
if (dev->xfer[i]) {
|
||||
libusb_free_transfer(dev->xfer[i]);
|
||||
}
|
||||
}
|
||||
|
||||
free(dev->xfer);
|
||||
dev->xfer = NULL;
|
||||
}
|
||||
|
||||
if (dev->xfer_buf) {
|
||||
for (i = 0; i < dev->xfer_buf_num; ++i) {
|
||||
if (dev->xfer_buf[i]) {
|
||||
if (dev->use_zerocopy) {
|
||||
libusb_dev_mem_free(dev->devh,
|
||||
dev->xfer_buf[i],
|
||||
dev->xfer_buf_len);
|
||||
} else {
|
||||
free(dev->xfer_buf[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
free(dev->xfer_buf);
|
||||
dev->xfer_buf = NULL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void *fl2k_usb_worker(void *arg)
|
||||
{
|
||||
fl2k_dev_t *dev = (fl2k_dev_t *)arg;
|
||||
struct timeval tv = { 1, 0 };
|
||||
struct timeval zerotv = { 0, 0 };
|
||||
enum fl2k_async_status next_status = FL2K_INACTIVE;
|
||||
int r = 0;
|
||||
unsigned int i;
|
||||
|
||||
while (FL2K_RUNNING == dev->async_status) {
|
||||
r = libusb_handle_events_timeout_completed(dev->ctx, &tv,
|
||||
&dev->async_cancel);
|
||||
}
|
||||
|
||||
while (FL2K_INACTIVE != dev->async_status) {
|
||||
r = libusb_handle_events_timeout_completed(dev->ctx, &tv,
|
||||
&dev->async_cancel);
|
||||
if (r < 0) {
|
||||
/*fprintf(stderr, "handle_events returned: %d\n", r);*/
|
||||
if (r == LIBUSB_ERROR_INTERRUPTED) /* stray signal */
|
||||
continue;
|
||||
break;
|
||||
}
|
||||
|
||||
if (FL2K_CANCELING == dev->async_status) {
|
||||
next_status = FL2K_INACTIVE;
|
||||
|
||||
if (!dev->xfer)
|
||||
break;
|
||||
|
||||
for (i = 0; i < dev->xfer_buf_num; ++i) {
|
||||
if (!dev->xfer[i])
|
||||
continue;
|
||||
|
||||
if (LIBUSB_TRANSFER_CANCELLED !=
|
||||
dev->xfer[i]->status) {
|
||||
r = libusb_cancel_transfer(dev->xfer[i]);
|
||||
/* handle events after canceling
|
||||
* to allow transfer status to
|
||||
* propagate */
|
||||
libusb_handle_events_timeout_completed(dev->ctx,
|
||||
&zerotv, NULL);
|
||||
if (r < 0)
|
||||
continue;
|
||||
|
||||
next_status = FL2K_CANCELING;
|
||||
}
|
||||
}
|
||||
|
||||
if (dev->dev_lost || FL2K_INACTIVE == next_status) {
|
||||
/* handle any events that still need to
|
||||
* be handled before exiting after we
|
||||
* just cancelled all transfers */
|
||||
libusb_handle_events_timeout_completed(dev->ctx,
|
||||
&zerotv, NULL);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_fl2k_free_async_buffers(dev);
|
||||
dev->async_status = next_status;
|
||||
|
||||
pthread_exit(NULL);
|
||||
}
|
||||
|
||||
/* Buffer format conversion functions for R, G, B DACs */
|
||||
static inline void fl2k_convert_r(char *out,
|
||||
char *in,
|
||||
uint32_t len,
|
||||
uint8_t offset)
|
||||
{
|
||||
unsigned int i, j = 0;
|
||||
|
||||
if (!in || !out)
|
||||
return;
|
||||
|
||||
for (i = 0; i < len; i += 24) {
|
||||
out[i+ 6] = in[j++] + offset;
|
||||
out[i+ 1] = in[j++] + offset;
|
||||
out[i+12] = in[j++] + offset;
|
||||
out[i+15] = in[j++] + offset;
|
||||
out[i+10] = in[j++] + offset;
|
||||
out[i+21] = in[j++] + offset;
|
||||
out[i+16] = in[j++] + offset;
|
||||
out[i+19] = in[j++] + offset;
|
||||
}
|
||||
}
|
||||
|
||||
static inline void fl2k_convert_g(char *out,
|
||||
char *in,
|
||||
uint32_t len,
|
||||
uint8_t offset)
|
||||
{
|
||||
unsigned int i, j = 0;
|
||||
|
||||
if (!in || !out)
|
||||
return;
|
||||
|
||||
for (i = 0; i < len; i += 24) {
|
||||
out[i+ 5] = in[j++] + offset;
|
||||
out[i+ 0] = in[j++] + offset;
|
||||
out[i+ 3] = in[j++] + offset;
|
||||
out[i+14] = in[j++] + offset;
|
||||
out[i+ 9] = in[j++] + offset;
|
||||
out[i+20] = in[j++] + offset;
|
||||
out[i+23] = in[j++] + offset;
|
||||
out[i+18] = in[j++] + offset;
|
||||
}
|
||||
}
|
||||
|
||||
static inline void fl2k_convert_b(char *out,
|
||||
char *in,
|
||||
uint32_t len,
|
||||
uint8_t offset)
|
||||
{
|
||||
unsigned int i, j = 0;
|
||||
|
||||
if (!in || !out)
|
||||
return;
|
||||
|
||||
for (i = 0; i < len; i += 24) {
|
||||
out[i+ 4] = in[j++] + offset;
|
||||
out[i+ 7] = in[j++] + offset;
|
||||
out[i+ 2] = in[j++] + offset;
|
||||
out[i+13] = in[j++] + offset;
|
||||
out[i+ 8] = in[j++] + offset;
|
||||
out[i+11] = in[j++] + offset;
|
||||
out[i+22] = in[j++] + offset;
|
||||
out[i+17] = in[j++] + offset;
|
||||
}
|
||||
}
|
||||
|
||||
static void *fl2k_sample_worker(void *arg)
|
||||
{
|
||||
int r = 0;
|
||||
unsigned int i, j;
|
||||
fl2k_dev_t *dev = (fl2k_dev_t *)arg;
|
||||
fl2k_xfer_info_t *xfer_info = NULL;
|
||||
struct libusb_transfer *xfer = NULL;
|
||||
char *out_buf = NULL;
|
||||
fl2k_data_info_t data_info;
|
||||
uint32_t underflows = 0;
|
||||
uint64_t buf_cnt = 0;
|
||||
|
||||
while (FL2K_RUNNING == dev->async_status) {
|
||||
memset(&data_info, 0, sizeof(fl2k_data_info_t));
|
||||
|
||||
data_info.len = FL2K_BUF_LEN;
|
||||
data_info.underflow_cnt = dev->underflow_cnt;
|
||||
data_info.ctx = dev->cb_ctx;
|
||||
|
||||
if (dev->underflow_cnt > underflows) {
|
||||
fprintf(stderr, "Underflow! Skipped %d buffers\n",
|
||||
dev->underflow_cnt - underflows);
|
||||
underflows = dev->underflow_cnt;
|
||||
}
|
||||
|
||||
/* call application callback to get samples */
|
||||
if (dev->cb)
|
||||
dev->cb(&data_info);
|
||||
|
||||
xfer = fl2k_get_next_xfer(dev, BUF_EMPTY);
|
||||
|
||||
if (!xfer) {
|
||||
pthread_cond_wait(&dev->buf_cond, &dev->buf_mutex);
|
||||
/* in the meantime, the device might be gone */
|
||||
if (FL2K_RUNNING != dev->async_status)
|
||||
break;
|
||||
|
||||
xfer = fl2k_get_next_xfer(dev, BUF_EMPTY);
|
||||
if (!xfer) {
|
||||
fprintf(stderr, "no free transfer, skipping"
|
||||
" input buffer\n");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* We have an empty USB transfer buffer */
|
||||
xfer_info = (fl2k_xfer_info_t *)xfer->user_data;
|
||||
out_buf = (char *)xfer->buffer;
|
||||
|
||||
/* Re-arrange and copy bytes in buffer for DACs */
|
||||
fl2k_convert_r(out_buf, data_info.r_buf, dev->xfer_buf_len,
|
||||
data_info.sampletype_signed ? 128 : 0);
|
||||
|
||||
fl2k_convert_g(out_buf, data_info.g_buf, dev->xfer_buf_len,
|
||||
data_info.sampletype_signed ? 128 : 0);
|
||||
|
||||
fl2k_convert_b(out_buf, data_info.b_buf, dev->xfer_buf_len,
|
||||
data_info.sampletype_signed ? 128 : 0);
|
||||
|
||||
xfer_info->seq = buf_cnt++;
|
||||
xfer_info->state = BUF_FILLED;
|
||||
}
|
||||
|
||||
/* notify application if we've lost the device */
|
||||
if (dev->dev_lost && dev->cb) {
|
||||
data_info.device_error = 1;
|
||||
dev->cb(&data_info);
|
||||
fl2k_stop_tx(dev);
|
||||
}
|
||||
|
||||
pthread_exit(NULL);
|
||||
}
|
||||
|
||||
|
||||
int fl2k_start_tx(fl2k_dev_t *dev, fl2k_tx_cb_t cb, void *ctx,
|
||||
uint32_t buf_num)
|
||||
{
|
||||
int r = 0;
|
||||
int i;
|
||||
pthread_attr_t attr;
|
||||
|
||||
if (!dev || !cb)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
dev->async_status = FL2K_RUNNING;
|
||||
dev->async_cancel = 0;
|
||||
|
||||
dev->cb = cb;
|
||||
dev->cb_ctx = ctx;
|
||||
|
||||
if (buf_num > 0)
|
||||
dev->xfer_num = buf_num;
|
||||
else
|
||||
dev->xfer_num = DEFAULT_BUF_NUMBER;
|
||||
|
||||
/* have two spare buffers that can be filled while the
|
||||
* others are submitted */
|
||||
dev->xfer_buf_num = dev->xfer_num + 2;
|
||||
dev->xfer_buf_len = FL2K_XFER_LEN;
|
||||
|
||||
r = fl2k_alloc_submit_transfers(dev);
|
||||
if (r < 0)
|
||||
goto cleanup;
|
||||
|
||||
pthread_mutex_init(&dev->buf_mutex, NULL);
|
||||
pthread_cond_init(&dev->buf_cond, NULL);
|
||||
pthread_attr_init(&attr);
|
||||
|
||||
r = pthread_create(&dev->usb_worker_thread, &attr,
|
||||
fl2k_usb_worker, (void *)dev);
|
||||
if (r < 0) {
|
||||
fprintf(stderr, "Error spawning USB worker thread!\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
r = pthread_create(&dev->sample_worker_thread, &attr,
|
||||
fl2k_sample_worker, (void *)dev);
|
||||
if (r < 0) {
|
||||
fprintf(stderr, "Error spawning sample worker thread!\n");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
pthread_attr_destroy(&attr);
|
||||
|
||||
return 0;
|
||||
|
||||
cleanup:
|
||||
_fl2k_free_async_buffers(dev);
|
||||
return FL2K_ERROR_BUSY;
|
||||
|
||||
}
|
||||
|
||||
int fl2k_stop_tx(fl2k_dev_t *dev)
|
||||
{
|
||||
if (!dev)
|
||||
return FL2K_ERROR_INVALID_PARAM;
|
||||
|
||||
/* if streaming, try to cancel gracefully */
|
||||
if (FL2K_RUNNING == dev->async_status) {
|
||||
dev->async_status = FL2K_CANCELING;
|
||||
dev->async_cancel = 1;
|
||||
return 0;
|
||||
/* if called while in pending state, change the state forcefully */
|
||||
} else if (FL2K_INACTIVE != dev->async_status) {
|
||||
dev->async_status = FL2K_INACTIVE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return FL2K_ERROR_BUSY;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
|
||||
#include <afxres.h>
|
||||
|
||||
VS_VERSION_INFO VERSIONINFO
|
||||
FILEVERSION 0,0,0,0
|
||||
PRODUCTVERSION 0,0,0,0
|
||||
FILEFLAGSMASK 0x3fL
|
||||
#ifndef NDEBUG
|
||||
FILEFLAGS 0x0L
|
||||
#else
|
||||
FILEFLAGS 0x1L
|
||||
#endif
|
||||
FILEOS VOS__WINDOWS32
|
||||
FILETYPE VFT_DLL
|
||||
FILESUBTYPE VFT2_DRV_INSTALLABLE
|
||||
BEGIN
|
||||
BLOCK "StringFileInfo"
|
||||
BEGIN
|
||||
BLOCK "040904b0"
|
||||
BEGIN
|
||||
VALUE "FileDescription", "osmocom libosmo-fl2k"
|
||||
VALUE "FileVersion", "@VERSION@"
|
||||
VALUE "InternalName", "libosmo-fl2k.dll"
|
||||
VALUE "LegalCopyright", "Licensed under GPLv2+"
|
||||
VALUE "OriginalFilename", "libosmo-fl2k.dll"
|
||||
VALUE "ProductName", "osmocom libosmo-fl2k"
|
||||
VALUE "ProductVersion", "@VERSION@"
|
||||
END
|
||||
END
|
||||
BLOCK "VarFileInfo"
|
||||
BEGIN
|
||||
VALUE "Translation", 0x409, 1200
|
||||
END
|
||||
END
|
||||
Loading…
Reference in New Issue