From 7d63ff74db765b41324dd6d5eb7546abfb868576 Mon Sep 17 00:00:00 2001 From: Mark Foreman Date: Thu, 11 Jun 2020 00:20:50 +0930 Subject: [PATCH] Modifications to build on Windows x64. --- .gitignore | 4 +- Makefile | 11 +- README.md | 2 + libusb/COPYING | 504 +++++++++++ libusb/libusb-1.0.a | Bin 0 -> 212844 bytes libusb/libusb.h | 2066 +++++++++++++++++++++++++++++++++++++++++++ libusb/readme.md | 3 + src/crypto.c | 2 +- src/getopt.c | 118 +++ src/getopt.h | 6 + src/main.c | 2 +- src/stlink.c | 44 +- 12 files changed, 2728 insertions(+), 34 deletions(-) create mode 100644 libusb/COPYING create mode 100644 libusb/libusb-1.0.a create mode 100644 libusb/libusb.h create mode 100644 libusb/readme.md create mode 100644 src/getopt.c create mode 100644 src/getopt.h diff --git a/.gitignore b/.gitignore index 35f44c8..e26ae2f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ src/*.o tiny-AES-c/*.o -stlink-tool \ No newline at end of file +stlink-tool +stlink-tool.exe +/.vscode diff --git a/Makefile b/Makefile index df4affb..44bb873 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,8 @@ -CFLAGS := -Wall -Wextra -Werror $(shell pkg-config --cflags libusb-1.0) -LDFLAGS := $(shell pkg-config --libs libusb-1.0) +CC := gcc.exe +CFLAGS := -Wall -Wextra -Werror -Ilibusb +LDFLAGS := -Llibusb -lusb-1.0 -lWs2_32 -lmsvcrt -OBJS := src/main.o src/stlink.o src/crypto.o tiny-AES-c/aes.o +OBJS := src/main.o src/getopt.o src/stlink.o src/crypto.o tiny-AES-c/aes.o %.o: %.c $(CC) $(CFLAGS) -o $@ -c $< @@ -10,5 +11,5 @@ stlink-tool: $(OBJS) $(CC) $(OBJS) $(LDFLAGS) -o $@ clean: - rm -f src/*.o - rm -f stlink-tool + del /f src\*.o + del /f stlink-tool diff --git a/README.md b/README.md index 6a2ae2a..877fbac 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ # stlink-tool +_This fork is for building on Windows x64. It no longer compiles on linux._ + libusb tool for flashing chinese ST-Link dongles. Please note that similarly to ST's updater, the uploaded firmware won't replace the bootloader (meaning that you should be able to reflash the original afterwards using [ST's firmware update utility](http://www.st.com/en/development-tools/stsw-link007.html)). ``` diff --git a/libusb/COPYING b/libusb/COPYING new file mode 100644 index 0000000..5ab7695 --- /dev/null +++ b/libusb/COPYING @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 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. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +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 and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/libusb/libusb-1.0.a b/libusb/libusb-1.0.a new file mode 100644 index 0000000000000000000000000000000000000000..52a494a39f367afb8afd391e4eb8600399c95727 GIT binary patch literal 212844 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

`JOo1|Mv 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 + * Copyright © 2007-2008 Daniel Drake + * Copyright © 2012 Pete Batard + * Copyright © 2012-2018 Nathan Hjelm + * For more information, please visit: http://libusb.info + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef LIBUSB_H +#define LIBUSB_H + +#ifdef _MSC_VER +/* on MS environments, the inline keyword is available in C++ only */ +#if !defined(__cplusplus) +#define inline __inline +#endif +/* ssize_t is also not available (copy/paste from MinGW) */ +#ifndef _SSIZE_T_DEFINED +#define _SSIZE_T_DEFINED +#undef ssize_t +#ifdef _WIN64 + typedef __int64 ssize_t; +#else + typedef int ssize_t; +#endif /* _WIN64 */ +#endif /* _SSIZE_T_DEFINED */ +#endif /* _MSC_VER */ + +/* stdint.h is not available on older MSVC */ +#if defined(_MSC_VER) && (_MSC_VER < 1600) && (!defined(_STDINT)) && (!defined(_STDINT_H)) +typedef unsigned __int8 uint8_t; +typedef unsigned __int16 uint16_t; +typedef unsigned __int32 uint32_t; +#else +#include +#endif + +#if !defined(_WIN32_WCE) +#include +#endif + +#if defined(__linux__) || defined(__APPLE__) || defined(__CYGWIN__) || defined(__HAIKU__) +#include +#endif + +#include +#include + +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +#define ZERO_SIZED_ARRAY /* [] - valid C99 code */ +#else +#define ZERO_SIZED_ARRAY 0 /* [0] - non-standard, but usually working code */ +#endif + +/* 'interface' might be defined as a macro on Windows, so we need to + * undefine it so as not to break the current libusb API, because + * libusb_config_descriptor has an 'interface' member + * As this can be problematic if you include windows.h after libusb.h + * in your sources, we force windows.h to be included first. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +#include +#if defined(interface) +#undef interface +#endif +#if !defined(__CYGWIN__) +#include +#endif +#endif + +#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) +#define LIBUSB_DEPRECATED_FOR(f) \ + __attribute__((deprecated("Use " #f " instead"))) +#elif __GNUC__ >= 3 +#define LIBUSB_DEPRECATED_FOR(f) __attribute__((deprecated)) +#else +#define LIBUSB_DEPRECATED_FOR(f) +#endif /* __GNUC__ */ + +/** \def LIBUSB_CALL + * \ingroup libusb_misc + * libusb's Windows calling convention. + * + * Under Windows, the selection of available compilers and configurations + * means that, unlike other platforms, there is not one true calling + * convention (calling convention: the manner in which parameters are + * passed to functions in the generated assembly code). + * + * Matching the Windows API itself, libusb uses the WINAPI convention (which + * translates to the stdcall convention) and guarantees that the + * library is compiled in this way. The public header file also includes + * appropriate annotations so that your own software will use the right + * convention, even if another convention is being used by default within + * your codebase. + * + * The one consideration that you must apply in your software is to mark + * all functions which you use as libusb callbacks with this LIBUSB_CALL + * annotation, so that they too get compiled for the correct calling + * convention. + * + * On non-Windows operating systems, this macro is defined as nothing. This + * means that you can apply it to your code without worrying about + * cross-platform compatibility. + */ +/* LIBUSB_CALL must be defined on both definition and declaration of libusb + * functions. You'd think that declaration would be enough, but cygwin will + * complain about conflicting types unless both are marked this way. + * The placement of this macro is important too; it must appear after the + * return type, before the function name. See internal documentation for + * API_EXPORTED. + */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +#define LIBUSB_CALL WINAPI +#else +#define LIBUSB_CALL +#endif + +/** \def LIBUSB_API_VERSION + * \ingroup libusb_misc + * libusb's API version. + * + * Since version 1.0.13, to help with feature detection, libusb defines + * a LIBUSB_API_VERSION macro that gets increased every time there is a + * significant change to the API, such as the introduction of a new call, + * the definition of a new macro/enum member, or any other element that + * libusb applications may want to detect at compilation time. + * + * The macro is typically used in an application as follows: + * \code + * #if defined(LIBUSB_API_VERSION) && (LIBUSB_API_VERSION >= 0x01001234) + * // Use one of the newer features from the libusb API + * #endif + * \endcode + * + * Internally, LIBUSB_API_VERSION is defined as follows: + * (libusb major << 24) | (libusb minor << 16) | (16 bit incremental) + */ +#define LIBUSB_API_VERSION 0x01000107 + +/* The following is kept for compatibility, but will be deprecated in the future */ +#define LIBUSBX_API_VERSION LIBUSB_API_VERSION + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \ingroup libusb_misc + * Convert a 16-bit value from host-endian to little-endian format. On + * little endian systems, this function does nothing. On big endian systems, + * the bytes are swapped. + * \param x the host-endian value to convert + * \returns the value in little-endian byte order + */ +static inline uint16_t libusb_cpu_to_le16(const uint16_t x) +{ + union { + uint8_t b8[2]; + uint16_t b16; + } _tmp; + _tmp.b8[1] = (uint8_t) (x >> 8); + _tmp.b8[0] = (uint8_t) (x & 0xff); + return _tmp.b16; +} + +/** \def libusb_le16_to_cpu + * \ingroup libusb_misc + * Convert a 16-bit value from little-endian to host-endian format. On + * little endian systems, this function does nothing. On big endian systems, + * the bytes are swapped. + * \param x the little-endian value to convert + * \returns the value in host-endian byte order + */ +#define libusb_le16_to_cpu libusb_cpu_to_le16 + +/* standard USB stuff */ + +/** \ingroup libusb_desc + * Device and/or Interface Class codes */ +enum libusb_class_code { + /** In the context of a \ref libusb_device_descriptor "device descriptor", + * this bDeviceClass value indicates that each interface specifies its + * own class information and all interfaces operate independently. + */ + LIBUSB_CLASS_PER_INTERFACE = 0, + + /** Audio class */ + LIBUSB_CLASS_AUDIO = 1, + + /** Communications class */ + LIBUSB_CLASS_COMM = 2, + + /** Human Interface Device class */ + LIBUSB_CLASS_HID = 3, + + /** Physical */ + LIBUSB_CLASS_PHYSICAL = 5, + + /** Printer class */ + LIBUSB_CLASS_PRINTER = 7, + + /** Image class */ + LIBUSB_CLASS_PTP = 6, /* legacy name from libusb-0.1 usb.h */ + LIBUSB_CLASS_IMAGE = 6, + + /** Mass storage class */ + LIBUSB_CLASS_MASS_STORAGE = 8, + + /** Hub class */ + LIBUSB_CLASS_HUB = 9, + + /** Data class */ + LIBUSB_CLASS_DATA = 10, + + /** Smart Card */ + LIBUSB_CLASS_SMART_CARD = 0x0b, + + /** Content Security */ + LIBUSB_CLASS_CONTENT_SECURITY = 0x0d, + + /** Video */ + LIBUSB_CLASS_VIDEO = 0x0e, + + /** Personal Healthcare */ + LIBUSB_CLASS_PERSONAL_HEALTHCARE = 0x0f, + + /** Diagnostic Device */ + LIBUSB_CLASS_DIAGNOSTIC_DEVICE = 0xdc, + + /** Wireless class */ + LIBUSB_CLASS_WIRELESS = 0xe0, + + /** Application class */ + LIBUSB_CLASS_APPLICATION = 0xfe, + + /** Class is vendor-specific */ + LIBUSB_CLASS_VENDOR_SPEC = 0xff +}; + +/** \ingroup libusb_desc + * Descriptor types as defined by the USB specification. */ +enum libusb_descriptor_type { + /** Device descriptor. See libusb_device_descriptor. */ + LIBUSB_DT_DEVICE = 0x01, + + /** Configuration descriptor. See libusb_config_descriptor. */ + LIBUSB_DT_CONFIG = 0x02, + + /** String descriptor */ + LIBUSB_DT_STRING = 0x03, + + /** Interface descriptor. See libusb_interface_descriptor. */ + LIBUSB_DT_INTERFACE = 0x04, + + /** Endpoint descriptor. See libusb_endpoint_descriptor. */ + LIBUSB_DT_ENDPOINT = 0x05, + + /** BOS descriptor */ + LIBUSB_DT_BOS = 0x0f, + + /** Device Capability descriptor */ + LIBUSB_DT_DEVICE_CAPABILITY = 0x10, + + /** HID descriptor */ + LIBUSB_DT_HID = 0x21, + + /** HID report descriptor */ + LIBUSB_DT_REPORT = 0x22, + + /** Physical descriptor */ + LIBUSB_DT_PHYSICAL = 0x23, + + /** Hub descriptor */ + LIBUSB_DT_HUB = 0x29, + + /** SuperSpeed Hub descriptor */ + LIBUSB_DT_SUPERSPEED_HUB = 0x2a, + + /** SuperSpeed Endpoint Companion descriptor */ + LIBUSB_DT_SS_ENDPOINT_COMPANION = 0x30 +}; + +/* Descriptor sizes per descriptor type */ +#define LIBUSB_DT_DEVICE_SIZE 18 +#define LIBUSB_DT_CONFIG_SIZE 9 +#define LIBUSB_DT_INTERFACE_SIZE 9 +#define LIBUSB_DT_ENDPOINT_SIZE 7 +#define LIBUSB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */ +#define LIBUSB_DT_HUB_NONVAR_SIZE 7 +#define LIBUSB_DT_SS_ENDPOINT_COMPANION_SIZE 6 +#define LIBUSB_DT_BOS_SIZE 5 +#define LIBUSB_DT_DEVICE_CAPABILITY_SIZE 3 + +/* BOS descriptor sizes */ +#define LIBUSB_BT_USB_2_0_EXTENSION_SIZE 7 +#define LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE 10 +#define LIBUSB_BT_CONTAINER_ID_SIZE 20 + +/* We unwrap the BOS => define its max size */ +#define LIBUSB_DT_BOS_MAX_SIZE ((LIBUSB_DT_BOS_SIZE) +\ + (LIBUSB_BT_USB_2_0_EXTENSION_SIZE) +\ + (LIBUSB_BT_SS_USB_DEVICE_CAPABILITY_SIZE) +\ + (LIBUSB_BT_CONTAINER_ID_SIZE)) + +#define LIBUSB_ENDPOINT_ADDRESS_MASK 0x0f /* in bEndpointAddress */ +#define LIBUSB_ENDPOINT_DIR_MASK 0x80 + +/** \ingroup libusb_desc + * Endpoint direction. Values for bit 7 of the + * \ref libusb_endpoint_descriptor::bEndpointAddress "endpoint address" scheme. + */ +enum libusb_endpoint_direction { + /** In: device-to-host */ + LIBUSB_ENDPOINT_IN = 0x80, + + /** Out: host-to-device */ + LIBUSB_ENDPOINT_OUT = 0x00 +}; + +#define LIBUSB_TRANSFER_TYPE_MASK 0x03 /* in bmAttributes */ + +/** \ingroup libusb_desc + * Endpoint transfer type. Values for bits 0:1 of the + * \ref libusb_endpoint_descriptor::bmAttributes "endpoint attributes" field. + */ +enum libusb_transfer_type { + /** Control endpoint */ + LIBUSB_TRANSFER_TYPE_CONTROL = 0, + + /** Isochronous endpoint */ + LIBUSB_TRANSFER_TYPE_ISOCHRONOUS = 1, + + /** Bulk endpoint */ + LIBUSB_TRANSFER_TYPE_BULK = 2, + + /** Interrupt endpoint */ + LIBUSB_TRANSFER_TYPE_INTERRUPT = 3, + + /** Stream endpoint */ + LIBUSB_TRANSFER_TYPE_BULK_STREAM = 4, +}; + +/** \ingroup libusb_misc + * Standard requests, as defined in table 9-5 of the USB 3.0 specifications */ +enum libusb_standard_request { + /** Request status of the specific recipient */ + LIBUSB_REQUEST_GET_STATUS = 0x00, + + /** Clear or disable a specific feature */ + LIBUSB_REQUEST_CLEAR_FEATURE = 0x01, + + /* 0x02 is reserved */ + + /** Set or enable a specific feature */ + LIBUSB_REQUEST_SET_FEATURE = 0x03, + + /* 0x04 is reserved */ + + /** Set device address for all future accesses */ + LIBUSB_REQUEST_SET_ADDRESS = 0x05, + + /** Get the specified descriptor */ + LIBUSB_REQUEST_GET_DESCRIPTOR = 0x06, + + /** Used to update existing descriptors or add new descriptors */ + LIBUSB_REQUEST_SET_DESCRIPTOR = 0x07, + + /** Get the current device configuration value */ + LIBUSB_REQUEST_GET_CONFIGURATION = 0x08, + + /** Set device configuration */ + LIBUSB_REQUEST_SET_CONFIGURATION = 0x09, + + /** Return the selected alternate setting for the specified interface */ + LIBUSB_REQUEST_GET_INTERFACE = 0x0A, + + /** Select an alternate interface for the specified interface */ + LIBUSB_REQUEST_SET_INTERFACE = 0x0B, + + /** Set then report an endpoint's synchronization frame */ + LIBUSB_REQUEST_SYNCH_FRAME = 0x0C, + + /** Sets both the U1 and U2 Exit Latency */ + LIBUSB_REQUEST_SET_SEL = 0x30, + + /** Delay from the time a host transmits a packet to the time it is + * received by the device. */ + LIBUSB_SET_ISOCH_DELAY = 0x31, +}; + +/** \ingroup libusb_misc + * Request type bits of the + * \ref libusb_control_setup::bmRequestType "bmRequestType" field in control + * transfers. */ +enum libusb_request_type { + /** Standard */ + LIBUSB_REQUEST_TYPE_STANDARD = (0x00 << 5), + + /** Class */ + LIBUSB_REQUEST_TYPE_CLASS = (0x01 << 5), + + /** Vendor */ + LIBUSB_REQUEST_TYPE_VENDOR = (0x02 << 5), + + /** Reserved */ + LIBUSB_REQUEST_TYPE_RESERVED = (0x03 << 5) +}; + +/** \ingroup libusb_misc + * Recipient bits of the + * \ref libusb_control_setup::bmRequestType "bmRequestType" field in control + * transfers. Values 4 through 31 are reserved. */ +enum libusb_request_recipient { + /** Device */ + LIBUSB_RECIPIENT_DEVICE = 0x00, + + /** Interface */ + LIBUSB_RECIPIENT_INTERFACE = 0x01, + + /** Endpoint */ + LIBUSB_RECIPIENT_ENDPOINT = 0x02, + + /** Other */ + LIBUSB_RECIPIENT_OTHER = 0x03, +}; + +#define LIBUSB_ISO_SYNC_TYPE_MASK 0x0C + +/** \ingroup libusb_desc + * Synchronization type for isochronous endpoints. Values for bits 2:3 of the + * \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in + * libusb_endpoint_descriptor. + */ +enum libusb_iso_sync_type { + /** No synchronization */ + LIBUSB_ISO_SYNC_TYPE_NONE = 0, + + /** Asynchronous */ + LIBUSB_ISO_SYNC_TYPE_ASYNC = 1, + + /** Adaptive */ + LIBUSB_ISO_SYNC_TYPE_ADAPTIVE = 2, + + /** Synchronous */ + LIBUSB_ISO_SYNC_TYPE_SYNC = 3 +}; + +#define LIBUSB_ISO_USAGE_TYPE_MASK 0x30 + +/** \ingroup libusb_desc + * Usage type for isochronous endpoints. Values for bits 4:5 of the + * \ref libusb_endpoint_descriptor::bmAttributes "bmAttributes" field in + * libusb_endpoint_descriptor. + */ +enum libusb_iso_usage_type { + /** Data endpoint */ + LIBUSB_ISO_USAGE_TYPE_DATA = 0, + + /** Feedback endpoint */ + LIBUSB_ISO_USAGE_TYPE_FEEDBACK = 1, + + /** Implicit feedback Data endpoint */ + LIBUSB_ISO_USAGE_TYPE_IMPLICIT = 2, +}; + +/** \ingroup libusb_desc + * A structure representing the standard USB device descriptor. This + * descriptor is documented in section 9.6.1 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_device_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE LIBUSB_DT_DEVICE in this + * context. */ + uint8_t bDescriptorType; + + /** USB specification release number in binary-coded decimal. A value of + * 0x0200 indicates USB 2.0, 0x0110 indicates USB 1.1, etc. */ + uint16_t bcdUSB; + + /** USB-IF class code for the device. See \ref libusb_class_code. */ + uint8_t bDeviceClass; + + /** USB-IF subclass code for the device, qualified by the bDeviceClass + * value */ + uint8_t bDeviceSubClass; + + /** USB-IF protocol code for the device, qualified by the bDeviceClass and + * bDeviceSubClass values */ + uint8_t bDeviceProtocol; + + /** Maximum packet size for endpoint 0 */ + uint8_t bMaxPacketSize0; + + /** USB-IF vendor ID */ + uint16_t idVendor; + + /** USB-IF product ID */ + uint16_t idProduct; + + /** Device release number in binary-coded decimal */ + uint16_t bcdDevice; + + /** Index of string descriptor describing manufacturer */ + uint8_t iManufacturer; + + /** Index of string descriptor describing product */ + uint8_t iProduct; + + /** Index of string descriptor containing device serial number */ + uint8_t iSerialNumber; + + /** Number of possible configurations */ + uint8_t bNumConfigurations; +}; + +/** \ingroup libusb_desc + * A structure representing the standard USB endpoint descriptor. This + * descriptor is documented in section 9.6.6 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_endpoint_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_ENDPOINT LIBUSB_DT_ENDPOINT in + * this context. */ + uint8_t bDescriptorType; + + /** The address of the endpoint described by this descriptor. Bits 0:3 are + * the endpoint number. Bits 4:6 are reserved. Bit 7 indicates direction, + * see \ref libusb_endpoint_direction. + */ + uint8_t bEndpointAddress; + + /** Attributes which apply to the endpoint when it is configured using + * the bConfigurationValue. Bits 0:1 determine the transfer type and + * correspond to \ref libusb_transfer_type. Bits 2:3 are only used for + * isochronous endpoints and correspond to \ref libusb_iso_sync_type. + * Bits 4:5 are also only used for isochronous endpoints and correspond to + * \ref libusb_iso_usage_type. Bits 6:7 are reserved. + */ + uint8_t bmAttributes; + + /** Maximum packet size this endpoint is capable of sending/receiving. */ + uint16_t wMaxPacketSize; + + /** Interval for polling endpoint for data transfers. */ + uint8_t bInterval; + + /** For audio devices only: the rate at which synchronization feedback + * is provided. */ + uint8_t bRefresh; + + /** For audio devices only: the address if the synch endpoint */ + uint8_t bSynchAddress; + + /** Extra descriptors. If libusb encounters unknown endpoint descriptors, + * it will store them here, should you wish to parse them. */ + const unsigned char *extra; + + /** Length of the extra descriptors, in bytes. Must be non-negative. */ + int extra_length; +}; + +/** \ingroup libusb_desc + * A structure representing the standard USB interface descriptor. This + * descriptor is documented in section 9.6.5 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_interface_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_INTERFACE LIBUSB_DT_INTERFACE + * in this context. */ + uint8_t bDescriptorType; + + /** Number of this interface */ + uint8_t bInterfaceNumber; + + /** Value used to select this alternate setting for this interface */ + uint8_t bAlternateSetting; + + /** Number of endpoints used by this interface (excluding the control + * endpoint). */ + uint8_t bNumEndpoints; + + /** USB-IF class code for this interface. See \ref libusb_class_code. */ + uint8_t bInterfaceClass; + + /** USB-IF subclass code for this interface, qualified by the + * bInterfaceClass value */ + uint8_t bInterfaceSubClass; + + /** USB-IF protocol code for this interface, qualified by the + * bInterfaceClass and bInterfaceSubClass values */ + uint8_t bInterfaceProtocol; + + /** Index of string descriptor describing this interface */ + uint8_t iInterface; + + /** Array of endpoint descriptors. This length of this array is determined + * by the bNumEndpoints field. */ + const struct libusb_endpoint_descriptor *endpoint; + + /** Extra descriptors. If libusb encounters unknown interface descriptors, + * it will store them here, should you wish to parse them. */ + const unsigned char *extra; + + /** Length of the extra descriptors, in bytes. Must be non-negative. */ + int extra_length; +}; + +/** \ingroup libusb_desc + * A collection of alternate settings for a particular USB interface. + */ +struct libusb_interface { + /** Array of interface descriptors. The length of this array is determined + * by the num_altsetting field. */ + const struct libusb_interface_descriptor *altsetting; + + /** The number of alternate settings that belong to this interface. + * Must be non-negative. */ + int num_altsetting; +}; + +/** \ingroup libusb_desc + * A structure representing the standard USB configuration descriptor. This + * descriptor is documented in section 9.6.3 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_config_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_CONFIG LIBUSB_DT_CONFIG + * in this context. */ + uint8_t bDescriptorType; + + /** Total length of data returned for this configuration */ + uint16_t wTotalLength; + + /** Number of interfaces supported by this configuration */ + uint8_t bNumInterfaces; + + /** Identifier value for this configuration */ + uint8_t bConfigurationValue; + + /** Index of string descriptor describing this configuration */ + uint8_t iConfiguration; + + /** Configuration characteristics */ + uint8_t bmAttributes; + + /** Maximum power consumption of the USB device from this bus in this + * configuration when the device is fully operation. Expressed in units + * of 2 mA when the device is operating in high-speed mode and in units + * of 8 mA when the device is operating in super-speed mode. */ + uint8_t MaxPower; + + /** Array of interfaces supported by this configuration. The length of + * this array is determined by the bNumInterfaces field. */ + const struct libusb_interface *interface; + + /** Extra descriptors. If libusb encounters unknown configuration + * descriptors, it will store them here, should you wish to parse them. */ + const unsigned char *extra; + + /** Length of the extra descriptors, in bytes. Must be non-negative. */ + int extra_length; +}; + +/** \ingroup libusb_desc + * A structure representing the superspeed endpoint companion + * descriptor. This descriptor is documented in section 9.6.7 of + * the USB 3.0 specification. All multiple-byte fields are represented in + * host-endian format. + */ +struct libusb_ss_endpoint_companion_descriptor { + + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_SS_ENDPOINT_COMPANION in + * this context. */ + uint8_t bDescriptorType; + + + /** The maximum number of packets the endpoint can send or + * receive as part of a burst. */ + uint8_t bMaxBurst; + + /** In bulk EP: bits 4:0 represents the maximum number of + * streams the EP supports. In isochronous EP: bits 1:0 + * represents the Mult - a zero based value that determines + * the maximum number of packets within a service interval */ + uint8_t bmAttributes; + + /** The total number of bytes this EP will transfer every + * service interval. valid only for periodic EPs. */ + uint16_t wBytesPerInterval; +}; + +/** \ingroup libusb_desc + * A generic representation of a BOS Device Capability descriptor. It is + * advised to check bDevCapabilityType and call the matching + * libusb_get_*_descriptor function to get a structure fully matching the type. + */ +struct libusb_bos_dev_capability_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY + * LIBUSB_DT_DEVICE_CAPABILITY in this context. */ + uint8_t bDescriptorType; + /** Device Capability type */ + uint8_t bDevCapabilityType; + /** Device Capability data (bLength - 3 bytes) */ + uint8_t dev_capability_data[ZERO_SIZED_ARRAY]; +}; + +/** \ingroup libusb_desc + * A structure representing the Binary Device Object Store (BOS) descriptor. + * This descriptor is documented in section 9.6.2 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_bos_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_BOS LIBUSB_DT_BOS + * in this context. */ + uint8_t bDescriptorType; + + /** Length of this descriptor and all of its sub descriptors */ + uint16_t wTotalLength; + + /** The number of separate device capability descriptors in + * the BOS */ + uint8_t bNumDeviceCaps; + + /** bNumDeviceCap Device Capability Descriptors */ + struct libusb_bos_dev_capability_descriptor *dev_capability[ZERO_SIZED_ARRAY]; +}; + +/** \ingroup libusb_desc + * A structure representing the USB 2.0 Extension descriptor + * This descriptor is documented in section 9.6.2.1 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_usb_2_0_extension_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY + * LIBUSB_DT_DEVICE_CAPABILITY in this context. */ + uint8_t bDescriptorType; + + /** Capability type. Will have value + * \ref libusb_capability_type::LIBUSB_BT_USB_2_0_EXTENSION + * LIBUSB_BT_USB_2_0_EXTENSION in this context. */ + uint8_t bDevCapabilityType; + + /** Bitmap encoding of supported device level features. + * A value of one in a bit location indicates a feature is + * supported; a value of zero indicates it is not supported. + * See \ref libusb_usb_2_0_extension_attributes. */ + uint32_t bmAttributes; +}; + +/** \ingroup libusb_desc + * A structure representing the SuperSpeed USB Device Capability descriptor + * This descriptor is documented in section 9.6.2.2 of the USB 3.0 specification. + * All multiple-byte fields are represented in host-endian format. + */ +struct libusb_ss_usb_device_capability_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY + * LIBUSB_DT_DEVICE_CAPABILITY in this context. */ + uint8_t bDescriptorType; + + /** Capability type. Will have value + * \ref libusb_capability_type::LIBUSB_BT_SS_USB_DEVICE_CAPABILITY + * LIBUSB_BT_SS_USB_DEVICE_CAPABILITY in this context. */ + uint8_t bDevCapabilityType; + + /** Bitmap encoding of supported device level features. + * A value of one in a bit location indicates a feature is + * supported; a value of zero indicates it is not supported. + * See \ref libusb_ss_usb_device_capability_attributes. */ + uint8_t bmAttributes; + + /** Bitmap encoding of the speed supported by this device when + * operating in SuperSpeed mode. See \ref libusb_supported_speed. */ + uint16_t wSpeedSupported; + + /** The lowest speed at which all the functionality supported + * by the device is available to the user. For example if the + * device supports all its functionality when connected at + * full speed and above then it sets this value to 1. */ + uint8_t bFunctionalitySupport; + + /** U1 Device Exit Latency. */ + uint8_t bU1DevExitLat; + + /** U2 Device Exit Latency. */ + uint16_t bU2DevExitLat; +}; + +/** \ingroup libusb_desc + * A structure representing the Container ID descriptor. + * This descriptor is documented in section 9.6.2.3 of the USB 3.0 specification. + * All multiple-byte fields, except UUIDs, are represented in host-endian format. + */ +struct libusb_container_id_descriptor { + /** Size of this descriptor (in bytes) */ + uint8_t bLength; + + /** Descriptor type. Will have value + * \ref libusb_descriptor_type::LIBUSB_DT_DEVICE_CAPABILITY + * LIBUSB_DT_DEVICE_CAPABILITY in this context. */ + uint8_t bDescriptorType; + + /** Capability type. Will have value + * \ref libusb_capability_type::LIBUSB_BT_CONTAINER_ID + * LIBUSB_BT_CONTAINER_ID in this context. */ + uint8_t bDevCapabilityType; + + /** Reserved field */ + uint8_t bReserved; + + /** 128 bit UUID */ + uint8_t ContainerID[16]; +}; + +/** \ingroup libusb_asyncio + * Setup packet for control transfers. */ +struct libusb_control_setup { + /** Request type. Bits 0:4 determine recipient, see + * \ref libusb_request_recipient. Bits 5:6 determine type, see + * \ref libusb_request_type. Bit 7 determines data transfer direction, see + * \ref libusb_endpoint_direction. + */ + uint8_t bmRequestType; + + /** Request. If the type bits of bmRequestType are equal to + * \ref libusb_request_type::LIBUSB_REQUEST_TYPE_STANDARD + * "LIBUSB_REQUEST_TYPE_STANDARD" then this field refers to + * \ref libusb_standard_request. For other cases, use of this field is + * application-specific. */ + uint8_t bRequest; + + /** Value. Varies according to request */ + uint16_t wValue; + + /** Index. Varies according to request, typically used to pass an index + * or offset */ + uint16_t wIndex; + + /** Number of bytes to transfer */ + uint16_t wLength; +}; + +#define LIBUSB_CONTROL_SETUP_SIZE (sizeof(struct libusb_control_setup)) + +/* libusb */ + +struct libusb_context; +struct libusb_device; +struct libusb_device_handle; + +/** \ingroup libusb_lib + * Structure providing the version of the libusb runtime + */ +struct libusb_version { + /** Library major version. */ + const uint16_t major; + + /** Library minor version. */ + const uint16_t minor; + + /** Library micro version. */ + const uint16_t micro; + + /** Library nano version. */ + const uint16_t nano; + + /** Library release candidate suffix string, e.g. "-rc4". */ + const char *rc; + + /** For ABI compatibility only. */ + const char* describe; +}; + +/** \ingroup libusb_lib + * Structure representing a libusb session. The concept of individual libusb + * sessions allows for your program to use two libraries (or dynamically + * load two modules) which both independently use libusb. This will prevent + * interference between the individual libusb users - for example + * libusb_set_option() will not affect the other user of the library, and + * libusb_exit() will not destroy resources that the other user is still + * using. + * + * Sessions are created by libusb_init() and destroyed through libusb_exit(). + * If your application is guaranteed to only ever include a single libusb + * user (i.e. you), you do not have to worry about contexts: pass NULL in + * every function call where a context is required. The default context + * will be used. + * + * For more information, see \ref libusb_contexts. + */ +typedef struct libusb_context libusb_context; + +/** \ingroup libusb_dev + * Structure representing a USB device detected on the system. This is an + * opaque type for which you are only ever provided with a pointer, usually + * originating from libusb_get_device_list(). + * + * Certain operations can be performed on a device, but in order to do any + * I/O you will have to first obtain a device handle using libusb_open(). + * + * Devices are reference counted with libusb_ref_device() and + * libusb_unref_device(), and are freed when the reference count reaches 0. + * New devices presented by libusb_get_device_list() have a reference count of + * 1, and libusb_free_device_list() can optionally decrease the reference count + * on all devices in the list. libusb_open() adds another reference which is + * later destroyed by libusb_close(). + */ +typedef struct libusb_device libusb_device; + + +/** \ingroup libusb_dev + * Structure representing a handle on a USB device. This is an opaque type for + * which you are only ever provided with a pointer, usually originating from + * libusb_open(). + * + * A device handle is used to perform I/O and other operations. When finished + * with a device handle, you should call libusb_close(). + */ +typedef struct libusb_device_handle libusb_device_handle; + +/** \ingroup libusb_dev + * Speed codes. Indicates the speed at which the device is operating. + */ +enum libusb_speed { + /** The OS doesn't report or know the device speed. */ + LIBUSB_SPEED_UNKNOWN = 0, + + /** The device is operating at low speed (1.5MBit/s). */ + LIBUSB_SPEED_LOW = 1, + + /** The device is operating at full speed (12MBit/s). */ + LIBUSB_SPEED_FULL = 2, + + /** The device is operating at high speed (480MBit/s). */ + LIBUSB_SPEED_HIGH = 3, + + /** The device is operating at super speed (5000MBit/s). */ + LIBUSB_SPEED_SUPER = 4, + + /** The device is operating at super speed plus (10000MBit/s). */ + LIBUSB_SPEED_SUPER_PLUS = 5, +}; + +/** \ingroup libusb_dev + * Supported speeds (wSpeedSupported) bitfield. Indicates what + * speeds the device supports. + */ +enum libusb_supported_speed { + /** Low speed operation supported (1.5MBit/s). */ + LIBUSB_LOW_SPEED_OPERATION = 1, + + /** Full speed operation supported (12MBit/s). */ + LIBUSB_FULL_SPEED_OPERATION = 2, + + /** High speed operation supported (480MBit/s). */ + LIBUSB_HIGH_SPEED_OPERATION = 4, + + /** Superspeed operation supported (5000MBit/s). */ + LIBUSB_SUPER_SPEED_OPERATION = 8, +}; + +/** \ingroup libusb_dev + * Masks for the bits of the + * \ref libusb_usb_2_0_extension_descriptor::bmAttributes "bmAttributes" field + * of the USB 2.0 Extension descriptor. + */ +enum libusb_usb_2_0_extension_attributes { + /** Supports Link Power Management (LPM) */ + LIBUSB_BM_LPM_SUPPORT = 2, +}; + +/** \ingroup libusb_dev + * Masks for the bits of the + * \ref libusb_ss_usb_device_capability_descriptor::bmAttributes "bmAttributes" field + * field of the SuperSpeed USB Device Capability descriptor. + */ +enum libusb_ss_usb_device_capability_attributes { + /** Supports Latency Tolerance Messages (LTM) */ + LIBUSB_BM_LTM_SUPPORT = 2, +}; + +/** \ingroup libusb_dev + * USB capability types + */ +enum libusb_bos_type { + /** Wireless USB device capability */ + LIBUSB_BT_WIRELESS_USB_DEVICE_CAPABILITY = 1, + + /** USB 2.0 extensions */ + LIBUSB_BT_USB_2_0_EXTENSION = 2, + + /** SuperSpeed USB device capability */ + LIBUSB_BT_SS_USB_DEVICE_CAPABILITY = 3, + + /** Container ID type */ + LIBUSB_BT_CONTAINER_ID = 4, +}; + +/** \ingroup libusb_misc + * Error codes. Most libusb functions return 0 on success or one of these + * codes on failure. + * You can call libusb_error_name() to retrieve a string representation of an + * error code or libusb_strerror() to get an end-user suitable description of + * an error code. + */ +enum libusb_error { + /** Success (no error) */ + LIBUSB_SUCCESS = 0, + + /** Input/output error */ + LIBUSB_ERROR_IO = -1, + + /** Invalid parameter */ + LIBUSB_ERROR_INVALID_PARAM = -2, + + /** Access denied (insufficient permissions) */ + LIBUSB_ERROR_ACCESS = -3, + + /** No such device (it may have been disconnected) */ + LIBUSB_ERROR_NO_DEVICE = -4, + + /** Entity not found */ + LIBUSB_ERROR_NOT_FOUND = -5, + + /** Resource busy */ + LIBUSB_ERROR_BUSY = -6, + + /** Operation timed out */ + LIBUSB_ERROR_TIMEOUT = -7, + + /** Overflow */ + LIBUSB_ERROR_OVERFLOW = -8, + + /** Pipe error */ + LIBUSB_ERROR_PIPE = -9, + + /** System call interrupted (perhaps due to signal) */ + LIBUSB_ERROR_INTERRUPTED = -10, + + /** Insufficient memory */ + LIBUSB_ERROR_NO_MEM = -11, + + /** Operation not supported or unimplemented on this platform */ + LIBUSB_ERROR_NOT_SUPPORTED = -12, + + /* NB: Remember to update LIBUSB_ERROR_COUNT below as well as the + message strings in strerror.c when adding new error codes here. */ + + /** Other error */ + LIBUSB_ERROR_OTHER = -99, +}; + +/* Total number of error codes in enum libusb_error */ +#define LIBUSB_ERROR_COUNT 14 + +/** \ingroup libusb_asyncio + * Transfer status codes */ +enum libusb_transfer_status { + /** Transfer completed without error. Note that this does not indicate + * that the entire amount of requested data was transferred. */ + LIBUSB_TRANSFER_COMPLETED, + + /** Transfer failed */ + LIBUSB_TRANSFER_ERROR, + + /** Transfer timed out */ + LIBUSB_TRANSFER_TIMED_OUT, + + /** Transfer was cancelled */ + LIBUSB_TRANSFER_CANCELLED, + + /** For bulk/interrupt endpoints: halt condition detected (endpoint + * stalled). For control endpoints: control request not supported. */ + LIBUSB_TRANSFER_STALL, + + /** Device was disconnected */ + LIBUSB_TRANSFER_NO_DEVICE, + + /** Device sent more data than requested */ + LIBUSB_TRANSFER_OVERFLOW, + + /* NB! Remember to update libusb_error_name() + when adding new status codes here. */ +}; + +/** \ingroup libusb_asyncio + * libusb_transfer.flags values */ +enum libusb_transfer_flags { + /** Report short frames as errors */ + LIBUSB_TRANSFER_SHORT_NOT_OK = 1U << 0, + + /** Automatically free() transfer buffer during libusb_free_transfer(). + * Note that buffers allocated with libusb_dev_mem_alloc() should not + * be attempted freed in this way, since free() is not an appropriate + * way to release such memory. */ + LIBUSB_TRANSFER_FREE_BUFFER = 1U << 1, + + /** Automatically call libusb_free_transfer() after callback returns. + * If this flag is set, it is illegal to call libusb_free_transfer() + * from your transfer callback, as this will result in a double-free + * when this flag is acted upon. */ + LIBUSB_TRANSFER_FREE_TRANSFER = 1U << 2, + + /** Terminate transfers that are a multiple of the endpoint's + * wMaxPacketSize with an extra zero length packet. This is useful + * when a device protocol mandates that each logical request is + * terminated by an incomplete packet (i.e. the logical requests are + * not separated by other means). + * + * This flag only affects host-to-device transfers to bulk and interrupt + * endpoints. In other situations, it is ignored. + * + * This flag only affects transfers with a length that is a multiple of + * the endpoint's wMaxPacketSize. On transfers of other lengths, this + * flag has no effect. Therefore, if you are working with a device that + * needs a ZLP whenever the end of the logical request falls on a packet + * boundary, then it is sensible to set this flag on every + * transfer (you do not have to worry about only setting it on transfers + * that end on the boundary). + * + * This flag is currently only supported on Linux. + * On other systems, libusb_submit_transfer() will return + * LIBUSB_ERROR_NOT_SUPPORTED for every transfer where this flag is set. + * + * Available since libusb-1.0.9. + */ + LIBUSB_TRANSFER_ADD_ZERO_PACKET = 1U << 3, +}; + +/** \ingroup libusb_asyncio + * Isochronous packet descriptor. */ +struct libusb_iso_packet_descriptor { + /** Length of data to request in this packet */ + unsigned int length; + + /** Amount of data that was actually transferred */ + unsigned int actual_length; + + /** Status code for this packet */ + enum libusb_transfer_status status; +}; + +struct libusb_transfer; + +/** \ingroup libusb_asyncio + * Asynchronous transfer callback function type. When submitting asynchronous + * transfers, you pass a pointer to a callback function of this type via the + * \ref libusb_transfer::callback "callback" member of the libusb_transfer + * structure. libusb will call this function later, when the transfer has + * completed or failed. See \ref libusb_asyncio for more information. + * \param transfer The libusb_transfer struct the callback function is being + * notified about. + */ +typedef void (LIBUSB_CALL *libusb_transfer_cb_fn)(struct libusb_transfer *transfer); + +/** \ingroup libusb_asyncio + * The generic USB transfer structure. The user populates this structure and + * then submits it in order to request a transfer. After the transfer has + * completed, the library populates the transfer with the results and passes + * it back to the user. + */ +struct libusb_transfer { + /** Handle of the device that this transfer will be submitted to */ + libusb_device_handle *dev_handle; + + /** A bitwise OR combination of \ref libusb_transfer_flags. */ + uint8_t flags; + + /** Address of the endpoint where this transfer will be sent. */ + unsigned char endpoint; + + /** Type of the endpoint from \ref libusb_transfer_type */ + unsigned char type; + + /** Timeout for this transfer in milliseconds. A value of 0 indicates no + * timeout. */ + unsigned int timeout; + + /** The status of the transfer. Read-only, and only for use within + * transfer callback function. + * + * If this is an isochronous transfer, this field may read COMPLETED even + * if there were errors in the frames. Use the + * \ref libusb_iso_packet_descriptor::status "status" field in each packet + * to determine if errors occurred. */ + enum libusb_transfer_status status; + + /** Length of the data buffer. Must be non-negative. */ + int length; + + /** Actual length of data that was transferred. Read-only, and only for + * use within transfer callback function. Not valid for isochronous + * endpoint transfers. */ + int actual_length; + + /** Callback function. This will be invoked when the transfer completes, + * fails, or is cancelled. */ + libusb_transfer_cb_fn callback; + + /** User context data to pass to the callback function. */ + void *user_data; + + /** Data buffer */ + unsigned char *buffer; + + /** Number of isochronous packets. Only used for I/O with isochronous + * endpoints. Must be non-negative. */ + int num_iso_packets; + + /** Isochronous packet descriptors, for isochronous transfers only. */ + struct libusb_iso_packet_descriptor iso_packet_desc[ZERO_SIZED_ARRAY]; +}; + +/** \ingroup libusb_misc + * Capabilities supported by an instance of libusb on the current running + * platform. Test if the loaded library supports a given capability by calling + * \ref libusb_has_capability(). + */ +enum libusb_capability { + /** The libusb_has_capability() API is available. */ + LIBUSB_CAP_HAS_CAPABILITY = 0x0000, + /** Hotplug support is available on this platform. */ + LIBUSB_CAP_HAS_HOTPLUG = 0x0001, + /** The library can access HID devices without requiring user intervention. + * Note that before being able to actually access an HID device, you may + * still have to call additional libusb functions such as + * \ref libusb_detach_kernel_driver(). */ + LIBUSB_CAP_HAS_HID_ACCESS = 0x0100, + /** The library supports detaching of the default USB driver, using + * \ref libusb_detach_kernel_driver(), if one is set by the OS kernel */ + LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER = 0x0101 +}; + +/** \ingroup libusb_lib + * Log message levels. + * - LIBUSB_LOG_LEVEL_NONE (0) : no messages ever printed by the library (default) + * - LIBUSB_LOG_LEVEL_ERROR (1) : error messages are printed to stderr + * - LIBUSB_LOG_LEVEL_WARNING (2) : warning and error messages are printed to stderr + * - LIBUSB_LOG_LEVEL_INFO (3) : informational messages are printed to stderr + * - LIBUSB_LOG_LEVEL_DEBUG (4) : debug and informational messages are printed to stderr + */ +enum libusb_log_level { + LIBUSB_LOG_LEVEL_NONE = 0, + LIBUSB_LOG_LEVEL_ERROR = 1, + LIBUSB_LOG_LEVEL_WARNING = 2, + LIBUSB_LOG_LEVEL_INFO = 3, + LIBUSB_LOG_LEVEL_DEBUG = 4, +}; + +/** \ingroup libusb_lib + * Log callback mode. + * \see libusb_set_log_cb() + */ +enum libusb_log_cb_mode { + + /** Callback function handling all log mesages. */ + LIBUSB_LOG_CB_GLOBAL = 1 << 0, + + /** Callback function handling context related log mesages. */ + LIBUSB_LOG_CB_CONTEXT = 1 << 1 +}; + +/** \ingroup libusb_lib + * Callback function for handling log messages. + * \param ctx the context which is related to the log message, or NULL if it + * is a global log message + * \param level the log level, see \ref libusb_log_level for a description + * \param str the log message + * \see libusb_set_log_cb() + */ +typedef void (LIBUSB_CALL *libusb_log_cb)(libusb_context *ctx, + enum libusb_log_level level, const char *str); + +int LIBUSB_CALL libusb_init(libusb_context **ctx); +void LIBUSB_CALL libusb_exit(libusb_context *ctx); +LIBUSB_DEPRECATED_FOR(libusb_set_option) +void LIBUSB_CALL libusb_set_debug(libusb_context *ctx, int level); +void LIBUSB_CALL libusb_set_log_cb(libusb_context *ctx, libusb_log_cb cb, int mode); +const struct libusb_version * LIBUSB_CALL libusb_get_version(void); +int LIBUSB_CALL libusb_has_capability(uint32_t capability); +const char * LIBUSB_CALL libusb_error_name(int errcode); +int LIBUSB_CALL libusb_setlocale(const char *locale); +const char * LIBUSB_CALL libusb_strerror(enum libusb_error errcode); + +ssize_t LIBUSB_CALL libusb_get_device_list(libusb_context *ctx, + libusb_device ***list); +void LIBUSB_CALL libusb_free_device_list(libusb_device **list, + int unref_devices); +libusb_device * LIBUSB_CALL libusb_ref_device(libusb_device *dev); +void LIBUSB_CALL libusb_unref_device(libusb_device *dev); + +int LIBUSB_CALL libusb_get_configuration(libusb_device_handle *dev, + int *config); +int LIBUSB_CALL libusb_get_device_descriptor(libusb_device *dev, + struct libusb_device_descriptor *desc); +int LIBUSB_CALL libusb_get_active_config_descriptor(libusb_device *dev, + struct libusb_config_descriptor **config); +int LIBUSB_CALL libusb_get_config_descriptor(libusb_device *dev, + uint8_t config_index, struct libusb_config_descriptor **config); +int LIBUSB_CALL libusb_get_config_descriptor_by_value(libusb_device *dev, + uint8_t bConfigurationValue, struct libusb_config_descriptor **config); +void LIBUSB_CALL libusb_free_config_descriptor( + struct libusb_config_descriptor *config); +int LIBUSB_CALL libusb_get_ss_endpoint_companion_descriptor( + struct libusb_context *ctx, + const struct libusb_endpoint_descriptor *endpoint, + struct libusb_ss_endpoint_companion_descriptor **ep_comp); +void LIBUSB_CALL libusb_free_ss_endpoint_companion_descriptor( + struct libusb_ss_endpoint_companion_descriptor *ep_comp); +int LIBUSB_CALL libusb_get_bos_descriptor(libusb_device_handle *dev_handle, + struct libusb_bos_descriptor **bos); +void LIBUSB_CALL libusb_free_bos_descriptor(struct libusb_bos_descriptor *bos); +int LIBUSB_CALL libusb_get_usb_2_0_extension_descriptor( + struct libusb_context *ctx, + struct libusb_bos_dev_capability_descriptor *dev_cap, + struct libusb_usb_2_0_extension_descriptor **usb_2_0_extension); +void LIBUSB_CALL libusb_free_usb_2_0_extension_descriptor( + struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension); +int LIBUSB_CALL libusb_get_ss_usb_device_capability_descriptor( + struct libusb_context *ctx, + struct libusb_bos_dev_capability_descriptor *dev_cap, + struct libusb_ss_usb_device_capability_descriptor **ss_usb_device_cap); +void LIBUSB_CALL libusb_free_ss_usb_device_capability_descriptor( + struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap); +int LIBUSB_CALL libusb_get_container_id_descriptor(struct libusb_context *ctx, + struct libusb_bos_dev_capability_descriptor *dev_cap, + struct libusb_container_id_descriptor **container_id); +void LIBUSB_CALL libusb_free_container_id_descriptor( + struct libusb_container_id_descriptor *container_id); +uint8_t LIBUSB_CALL libusb_get_bus_number(libusb_device *dev); +uint8_t LIBUSB_CALL libusb_get_port_number(libusb_device *dev); +int LIBUSB_CALL libusb_get_port_numbers(libusb_device *dev, uint8_t* port_numbers, int port_numbers_len); +LIBUSB_DEPRECATED_FOR(libusb_get_port_numbers) +int LIBUSB_CALL libusb_get_port_path(libusb_context *ctx, libusb_device *dev, uint8_t* path, uint8_t path_length); +libusb_device * LIBUSB_CALL libusb_get_parent(libusb_device *dev); +uint8_t LIBUSB_CALL libusb_get_device_address(libusb_device *dev); +int LIBUSB_CALL libusb_get_device_speed(libusb_device *dev); +int LIBUSB_CALL libusb_get_max_packet_size(libusb_device *dev, + unsigned char endpoint); +int LIBUSB_CALL libusb_get_max_iso_packet_size(libusb_device *dev, + unsigned char endpoint); + +int LIBUSB_CALL libusb_wrap_sys_device(libusb_context *ctx, intptr_t sys_dev, libusb_device_handle **dev_handle); +int LIBUSB_CALL libusb_open(libusb_device *dev, libusb_device_handle **dev_handle); +void LIBUSB_CALL libusb_close(libusb_device_handle *dev_handle); +libusb_device * LIBUSB_CALL libusb_get_device(libusb_device_handle *dev_handle); + +int LIBUSB_CALL libusb_set_configuration(libusb_device_handle *dev_handle, + int configuration); +int LIBUSB_CALL libusb_claim_interface(libusb_device_handle *dev_handle, + int interface_number); +int LIBUSB_CALL libusb_release_interface(libusb_device_handle *dev_handle, + int interface_number); + +libusb_device_handle * LIBUSB_CALL libusb_open_device_with_vid_pid( + libusb_context *ctx, uint16_t vendor_id, uint16_t product_id); + +int LIBUSB_CALL libusb_set_interface_alt_setting(libusb_device_handle *dev_handle, + int interface_number, int alternate_setting); +int LIBUSB_CALL libusb_clear_halt(libusb_device_handle *dev_handle, + unsigned char endpoint); +int LIBUSB_CALL libusb_reset_device(libusb_device_handle *dev_handle); + +int LIBUSB_CALL libusb_alloc_streams(libusb_device_handle *dev_handle, + uint32_t num_streams, unsigned char *endpoints, int num_endpoints); +int LIBUSB_CALL libusb_free_streams(libusb_device_handle *dev_handle, + unsigned char *endpoints, int num_endpoints); + +unsigned char * LIBUSB_CALL libusb_dev_mem_alloc(libusb_device_handle *dev_handle, + size_t length); +int LIBUSB_CALL libusb_dev_mem_free(libusb_device_handle *dev_handle, + unsigned char *buffer, size_t length); + +int LIBUSB_CALL libusb_kernel_driver_active(libusb_device_handle *dev_handle, + int interface_number); +int LIBUSB_CALL libusb_detach_kernel_driver(libusb_device_handle *dev_handle, + int interface_number); +int LIBUSB_CALL libusb_attach_kernel_driver(libusb_device_handle *dev_handle, + int interface_number); +int LIBUSB_CALL libusb_set_auto_detach_kernel_driver( + libusb_device_handle *dev_handle, int enable); + +/* async I/O */ + +/** \ingroup libusb_asyncio + * Get the data section of a control transfer. This convenience function is here + * to remind you that the data does not start until 8 bytes into the actual + * buffer, as the setup packet comes first. + * + * Calling this function only makes sense from a transfer callback function, + * or situations where you have already allocated a suitably sized buffer at + * transfer->buffer. + * + * \param transfer a transfer + * \returns pointer to the first byte of the data section + */ +static inline unsigned char *libusb_control_transfer_get_data( + struct libusb_transfer *transfer) +{ + return transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE; +} + +/** \ingroup libusb_asyncio + * Get the control setup packet of a control transfer. This convenience + * function is here to remind you that the control setup occupies the first + * 8 bytes of the transfer data buffer. + * + * Calling this function only makes sense from a transfer callback function, + * or situations where you have already allocated a suitably sized buffer at + * transfer->buffer. + * + * \param transfer a transfer + * \returns a casted pointer to the start of the transfer data buffer + */ +static inline struct libusb_control_setup *libusb_control_transfer_get_setup( + struct libusb_transfer *transfer) +{ + return (struct libusb_control_setup *)(void *) transfer->buffer; +} + +/** \ingroup libusb_asyncio + * Helper function to populate the setup packet (first 8 bytes of the data + * buffer) for a control transfer. The wIndex, wValue and wLength values should + * be given in host-endian byte order. + * + * \param buffer buffer to output the setup packet into + * This pointer must be aligned to at least 2 bytes boundary. + * \param bmRequestType see the + * \ref libusb_control_setup::bmRequestType "bmRequestType" field of + * \ref libusb_control_setup + * \param bRequest see the + * \ref libusb_control_setup::bRequest "bRequest" field of + * \ref libusb_control_setup + * \param wValue see the + * \ref libusb_control_setup::wValue "wValue" field of + * \ref libusb_control_setup + * \param wIndex see the + * \ref libusb_control_setup::wIndex "wIndex" field of + * \ref libusb_control_setup + * \param wLength see the + * \ref libusb_control_setup::wLength "wLength" field of + * \ref libusb_control_setup + */ +static inline void libusb_fill_control_setup(unsigned char *buffer, + uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, + uint16_t wLength) +{ + struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *) buffer; + setup->bmRequestType = bmRequestType; + setup->bRequest = bRequest; + setup->wValue = libusb_cpu_to_le16(wValue); + setup->wIndex = libusb_cpu_to_le16(wIndex); + setup->wLength = libusb_cpu_to_le16(wLength); +} + +struct libusb_transfer * LIBUSB_CALL libusb_alloc_transfer(int iso_packets); +int LIBUSB_CALL libusb_submit_transfer(struct libusb_transfer *transfer); +int LIBUSB_CALL libusb_cancel_transfer(struct libusb_transfer *transfer); +void LIBUSB_CALL libusb_free_transfer(struct libusb_transfer *transfer); +void LIBUSB_CALL libusb_transfer_set_stream_id( + struct libusb_transfer *transfer, uint32_t stream_id); +uint32_t LIBUSB_CALL libusb_transfer_get_stream_id( + struct libusb_transfer *transfer); + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for a control transfer. + * + * If you pass a transfer buffer to this function, the first 8 bytes will + * be interpreted as a control setup packet, and the wLength field will be + * used to automatically populate the \ref libusb_transfer::length "length" + * field of the transfer. Therefore the recommended approach is: + * -# Allocate a suitably sized data buffer (including space for control setup) + * -# Call libusb_fill_control_setup() + * -# If this is a host-to-device transfer with a data stage, put the data + * in place after the setup packet + * -# Call this function + * -# Call libusb_submit_transfer() + * + * It is also legal to pass a NULL buffer to this function, in which case this + * function will not attempt to populate the length field. Remember that you + * must then populate the buffer and length fields later. + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param buffer data buffer. If provided, this function will interpret the + * first 8 bytes as a setup packet and infer the transfer length from that. + * This pointer must be aligned to at least 2 bytes boundary. + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_control_transfer( + struct libusb_transfer *transfer, libusb_device_handle *dev_handle, + unsigned char *buffer, libusb_transfer_cb_fn callback, void *user_data, + unsigned int timeout) +{ + struct libusb_control_setup *setup = (struct libusb_control_setup *)(void *) buffer; + transfer->dev_handle = dev_handle; + transfer->endpoint = 0; + transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL; + transfer->timeout = timeout; + transfer->buffer = buffer; + if (setup) + transfer->length = (int) (LIBUSB_CONTROL_SETUP_SIZE + + libusb_le16_to_cpu(setup->wLength)); + transfer->user_data = user_data; + transfer->callback = callback; +} + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for a bulk transfer. + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param endpoint address of the endpoint where this transfer will be sent + * \param buffer data buffer + * \param length length of data buffer + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_bulk_transfer(struct libusb_transfer *transfer, + libusb_device_handle *dev_handle, unsigned char endpoint, + unsigned char *buffer, int length, libusb_transfer_cb_fn callback, + void *user_data, unsigned int timeout) +{ + transfer->dev_handle = dev_handle; + transfer->endpoint = endpoint; + transfer->type = LIBUSB_TRANSFER_TYPE_BULK; + transfer->timeout = timeout; + transfer->buffer = buffer; + transfer->length = length; + transfer->user_data = user_data; + transfer->callback = callback; +} + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for a bulk transfer using bulk streams. + * + * Since version 1.0.19, \ref LIBUSB_API_VERSION >= 0x01000103 + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param endpoint address of the endpoint where this transfer will be sent + * \param stream_id bulk stream id for this transfer + * \param buffer data buffer + * \param length length of data buffer + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_bulk_stream_transfer( + struct libusb_transfer *transfer, libusb_device_handle *dev_handle, + unsigned char endpoint, uint32_t stream_id, + unsigned char *buffer, int length, libusb_transfer_cb_fn callback, + void *user_data, unsigned int timeout) +{ + libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer, + length, callback, user_data, timeout); + transfer->type = LIBUSB_TRANSFER_TYPE_BULK_STREAM; + libusb_transfer_set_stream_id(transfer, stream_id); +} + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for an interrupt transfer. + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param endpoint address of the endpoint where this transfer will be sent + * \param buffer data buffer + * \param length length of data buffer + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_interrupt_transfer( + struct libusb_transfer *transfer, libusb_device_handle *dev_handle, + unsigned char endpoint, unsigned char *buffer, int length, + libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) +{ + transfer->dev_handle = dev_handle; + transfer->endpoint = endpoint; + transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT; + transfer->timeout = timeout; + transfer->buffer = buffer; + transfer->length = length; + transfer->user_data = user_data; + transfer->callback = callback; +} + +/** \ingroup libusb_asyncio + * Helper function to populate the required \ref libusb_transfer fields + * for an isochronous transfer. + * + * \param transfer the transfer to populate + * \param dev_handle handle of the device that will handle the transfer + * \param endpoint address of the endpoint where this transfer will be sent + * \param buffer data buffer + * \param length length of data buffer + * \param num_iso_packets the number of isochronous packets + * \param callback callback function to be invoked on transfer completion + * \param user_data user data to pass to callback function + * \param timeout timeout for the transfer in milliseconds + */ +static inline void libusb_fill_iso_transfer(struct libusb_transfer *transfer, + libusb_device_handle *dev_handle, unsigned char endpoint, + unsigned char *buffer, int length, int num_iso_packets, + libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout) +{ + transfer->dev_handle = dev_handle; + transfer->endpoint = endpoint; + transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS; + transfer->timeout = timeout; + transfer->buffer = buffer; + transfer->length = length; + transfer->num_iso_packets = num_iso_packets; + transfer->user_data = user_data; + transfer->callback = callback; +} + +/** \ingroup libusb_asyncio + * Convenience function to set the length of all packets in an isochronous + * transfer, based on the num_iso_packets field in the transfer structure. + * + * \param transfer a transfer + * \param length the length to set in each isochronous packet descriptor + * \see libusb_get_max_packet_size() + */ +static inline void libusb_set_iso_packet_lengths( + struct libusb_transfer *transfer, unsigned int length) +{ + int i; + for (i = 0; i < transfer->num_iso_packets; i++) + transfer->iso_packet_desc[i].length = length; +} + +/** \ingroup libusb_asyncio + * Convenience function to locate the position of an isochronous packet + * within the buffer of an isochronous transfer. + * + * This is a thorough function which loops through all preceding packets, + * accumulating their lengths to find the position of the specified packet. + * Typically you will assign equal lengths to each packet in the transfer, + * and hence the above method is sub-optimal. You may wish to use + * libusb_get_iso_packet_buffer_simple() instead. + * + * \param transfer a transfer + * \param packet the packet to return the address of + * \returns the base address of the packet buffer inside the transfer buffer, + * or NULL if the packet does not exist. + * \see libusb_get_iso_packet_buffer_simple() + */ +static inline unsigned char *libusb_get_iso_packet_buffer( + struct libusb_transfer *transfer, unsigned int packet) +{ + int i; + size_t offset = 0; + int _packet; + + /* oops..slight bug in the API. packet is an unsigned int, but we use + * signed integers almost everywhere else. range-check and convert to + * signed to avoid compiler warnings. FIXME for libusb-2. */ + if (packet > INT_MAX) + return NULL; + _packet = (int) packet; + + if (_packet >= transfer->num_iso_packets) + return NULL; + + for (i = 0; i < _packet; i++) + offset += transfer->iso_packet_desc[i].length; + + return transfer->buffer + offset; +} + +/** \ingroup libusb_asyncio + * Convenience function to locate the position of an isochronous packet + * within the buffer of an isochronous transfer, for transfers where each + * packet is of identical size. + * + * This function relies on the assumption that every packet within the transfer + * is of identical size to the first packet. Calculating the location of + * the packet buffer is then just a simple calculation: + * buffer + (packet_size * packet) + * + * Do not use this function on transfers other than those that have identical + * packet lengths for each packet. + * + * \param transfer a transfer + * \param packet the packet to return the address of + * \returns the base address of the packet buffer inside the transfer buffer, + * or NULL if the packet does not exist. + * \see libusb_get_iso_packet_buffer() + */ +static inline unsigned char *libusb_get_iso_packet_buffer_simple( + struct libusb_transfer *transfer, unsigned int packet) +{ + int _packet; + + /* oops..slight bug in the API. packet is an unsigned int, but we use + * signed integers almost everywhere else. range-check and convert to + * signed to avoid compiler warnings. FIXME for libusb-2. */ + if (packet > INT_MAX) + return NULL; + _packet = (int) packet; + + if (_packet >= transfer->num_iso_packets) + return NULL; + + return transfer->buffer + ((int) transfer->iso_packet_desc[0].length * _packet); +} + +/* sync I/O */ + +int LIBUSB_CALL libusb_control_transfer(libusb_device_handle *dev_handle, + uint8_t request_type, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, + unsigned char *data, uint16_t wLength, unsigned int timeout); + +int LIBUSB_CALL libusb_bulk_transfer(libusb_device_handle *dev_handle, + unsigned char endpoint, unsigned char *data, int length, + int *actual_length, unsigned int timeout); + +int LIBUSB_CALL libusb_interrupt_transfer(libusb_device_handle *dev_handle, + unsigned char endpoint, unsigned char *data, int length, + int *actual_length, unsigned int timeout); + +/** \ingroup libusb_desc + * Retrieve a descriptor from the default control pipe. + * This is a convenience function which formulates the appropriate control + * message to retrieve the descriptor. + * + * \param dev_handle a device handle + * \param desc_type the descriptor type, see \ref libusb_descriptor_type + * \param desc_index the index of the descriptor to retrieve + * \param data output buffer for descriptor + * \param length size of data buffer + * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure + */ +static inline int libusb_get_descriptor(libusb_device_handle *dev_handle, + uint8_t desc_type, uint8_t desc_index, unsigned char *data, int length) +{ + return libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN, + LIBUSB_REQUEST_GET_DESCRIPTOR, (uint16_t) ((desc_type << 8) | desc_index), + 0, data, (uint16_t) length, 1000); +} + +/** \ingroup libusb_desc + * Retrieve a descriptor from a device. + * This is a convenience function which formulates the appropriate control + * message to retrieve the descriptor. The string returned is Unicode, as + * detailed in the USB specifications. + * + * \param dev_handle a device handle + * \param desc_index the index of the descriptor to retrieve + * \param langid the language ID for the string descriptor + * \param data output buffer for descriptor + * \param length size of data buffer + * \returns number of bytes returned in data, or LIBUSB_ERROR code on failure + * \see libusb_get_string_descriptor_ascii() + */ +static inline int libusb_get_string_descriptor(libusb_device_handle *dev_handle, + uint8_t desc_index, uint16_t langid, unsigned char *data, int length) +{ + return libusb_control_transfer(dev_handle, LIBUSB_ENDPOINT_IN, + LIBUSB_REQUEST_GET_DESCRIPTOR, (uint16_t)((LIBUSB_DT_STRING << 8) | desc_index), + langid, data, (uint16_t) length, 1000); +} + +int LIBUSB_CALL libusb_get_string_descriptor_ascii(libusb_device_handle *dev_handle, + uint8_t desc_index, unsigned char *data, int length); + +/* polling and timeouts */ + +int LIBUSB_CALL libusb_try_lock_events(libusb_context *ctx); +void LIBUSB_CALL libusb_lock_events(libusb_context *ctx); +void LIBUSB_CALL libusb_unlock_events(libusb_context *ctx); +int LIBUSB_CALL libusb_event_handling_ok(libusb_context *ctx); +int LIBUSB_CALL libusb_event_handler_active(libusb_context *ctx); +void LIBUSB_CALL libusb_interrupt_event_handler(libusb_context *ctx); +void LIBUSB_CALL libusb_lock_event_waiters(libusb_context *ctx); +void LIBUSB_CALL libusb_unlock_event_waiters(libusb_context *ctx); +int LIBUSB_CALL libusb_wait_for_event(libusb_context *ctx, struct timeval *tv); + +int LIBUSB_CALL libusb_handle_events_timeout(libusb_context *ctx, + struct timeval *tv); +int LIBUSB_CALL libusb_handle_events_timeout_completed(libusb_context *ctx, + struct timeval *tv, int *completed); +int LIBUSB_CALL libusb_handle_events(libusb_context *ctx); +int LIBUSB_CALL libusb_handle_events_completed(libusb_context *ctx, int *completed); +int LIBUSB_CALL libusb_handle_events_locked(libusb_context *ctx, + struct timeval *tv); +int LIBUSB_CALL libusb_pollfds_handle_timeouts(libusb_context *ctx); +int LIBUSB_CALL libusb_get_next_timeout(libusb_context *ctx, + struct timeval *tv); + +/** \ingroup libusb_poll + * File descriptor for polling + */ +struct libusb_pollfd { + /** Numeric file descriptor */ + int fd; + + /** Event flags to poll for from . POLLIN indicates that you + * should monitor this file descriptor for becoming ready to read from, + * and POLLOUT indicates that you should monitor this file descriptor for + * nonblocking write readiness. */ + short events; +}; + +/** \ingroup libusb_poll + * Callback function, invoked when a new file descriptor should be added + * to the set of file descriptors monitored for events. + * \param fd the new file descriptor + * \param events events to monitor for, see \ref libusb_pollfd for a + * description + * \param user_data User data pointer specified in + * libusb_set_pollfd_notifiers() call + * \see libusb_set_pollfd_notifiers() + */ +typedef void (LIBUSB_CALL *libusb_pollfd_added_cb)(int fd, short events, + void *user_data); + +/** \ingroup libusb_poll + * Callback function, invoked when a file descriptor should be removed from + * the set of file descriptors being monitored for events. After returning + * from this callback, do not use that file descriptor again. + * \param fd the file descriptor to stop monitoring + * \param user_data User data pointer specified in + * libusb_set_pollfd_notifiers() call + * \see libusb_set_pollfd_notifiers() + */ +typedef void (LIBUSB_CALL *libusb_pollfd_removed_cb)(int fd, void *user_data); + +const struct libusb_pollfd ** LIBUSB_CALL libusb_get_pollfds( + libusb_context *ctx); +void LIBUSB_CALL libusb_free_pollfds(const struct libusb_pollfd **pollfds); +void LIBUSB_CALL libusb_set_pollfd_notifiers(libusb_context *ctx, + libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb, + void *user_data); + +/** \ingroup libusb_hotplug + * Callback handle. + * + * Callbacks handles are generated by libusb_hotplug_register_callback() + * and can be used to deregister callbacks. Callback handles are unique + * per libusb_context and it is safe to call libusb_hotplug_deregister_callback() + * on an already deregisted callback. + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * For more information, see \ref libusb_hotplug. + */ +typedef int libusb_hotplug_callback_handle; + +/** \ingroup libusb_hotplug + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * Flags for hotplug events */ +typedef enum { + /** Default value when not using any flags. */ + LIBUSB_HOTPLUG_NO_FLAGS = 0U, + + /** Arm the callback and fire it for all matching currently attached devices. */ + LIBUSB_HOTPLUG_ENUMERATE = 1U << 0, +} libusb_hotplug_flag; + +/** \ingroup libusb_hotplug + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * Hotplug events */ +typedef enum { + /** A device has been plugged in and is ready to use */ + LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED = 0x01U, + + /** A device has left and is no longer available. + * It is the user's responsibility to call libusb_close on any handle associated with a disconnected device. + * It is safe to call libusb_get_device_descriptor on a device that has left */ + LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT = 0x02U, +} libusb_hotplug_event; + +/** \ingroup libusb_hotplug + * Wildcard matching for hotplug events */ +#define LIBUSB_HOTPLUG_MATCH_ANY -1 + +/** \ingroup libusb_hotplug + * Hotplug callback function type. When requesting hotplug event notifications, + * you pass a pointer to a callback function of this type. + * + * This callback may be called by an internal event thread and as such it is + * recommended the callback do minimal processing before returning. + * + * libusb will call this function later, when a matching event had happened on + * a matching device. See \ref libusb_hotplug for more information. + * + * It is safe to call either libusb_hotplug_register_callback() or + * libusb_hotplug_deregister_callback() from within a callback function. + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * \param ctx context of this notification + * \param device libusb_device this event occurred on + * \param event event that occurred + * \param user_data user data provided when this callback was registered + * \returns bool whether this callback is finished processing events. + * returning 1 will cause this callback to be deregistered + */ +typedef int (LIBUSB_CALL *libusb_hotplug_callback_fn)(libusb_context *ctx, + libusb_device *device, + libusb_hotplug_event event, + void *user_data); + +/** \ingroup libusb_hotplug + * Register a hotplug callback function + * + * Register a callback with the libusb_context. The callback will fire + * when a matching event occurs on a matching device. The callback is + * armed until either it is deregistered with libusb_hotplug_deregister_callback() + * or the supplied callback returns 1 to indicate it is finished processing events. + * + * If the \ref LIBUSB_HOTPLUG_ENUMERATE is passed the callback will be + * called with a \ref LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED for all devices + * already plugged into the machine. Note that libusb modifies its internal + * device list from a separate thread, while calling hotplug callbacks from + * libusb_handle_events(), so it is possible for a device to already be present + * on, or removed from, its internal device list, while the hotplug callbacks + * still need to be dispatched. This means that when using \ref + * LIBUSB_HOTPLUG_ENUMERATE, your callback may be called twice for the arrival + * of the same device, once from libusb_hotplug_register_callback() and once + * from libusb_handle_events(); and/or your callback may be called for the + * removal of a device for which an arrived call was never made. + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * \param[in] ctx context to register this callback with + * \param[in] events bitwise or of events that will trigger this callback. See \ref + * libusb_hotplug_event + * \param[in] flags hotplug callback flags. See \ref libusb_hotplug_flag + * \param[in] vendor_id the vendor id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY + * \param[in] product_id the product id to match or \ref LIBUSB_HOTPLUG_MATCH_ANY + * \param[in] dev_class the device class to match or \ref LIBUSB_HOTPLUG_MATCH_ANY + * \param[in] cb_fn the function to be invoked on a matching event/device + * \param[in] user_data user data to pass to the callback function + * \param[out] callback_handle pointer to store the handle of the allocated callback (can be NULL) + * \returns LIBUSB_SUCCESS on success LIBUSB_ERROR code on failure + */ +int LIBUSB_CALL libusb_hotplug_register_callback(libusb_context *ctx, + libusb_hotplug_event events, + libusb_hotplug_flag flags, + int vendor_id, int product_id, + int dev_class, + libusb_hotplug_callback_fn cb_fn, + void *user_data, + libusb_hotplug_callback_handle *callback_handle); + +/** \ingroup libusb_hotplug + * Deregisters a hotplug callback. + * + * Deregister a callback from a libusb_context. This function is safe to call from within + * a hotplug callback. + * + * Since version 1.0.16, \ref LIBUSB_API_VERSION >= 0x01000102 + * + * \param[in] ctx context this callback is registered with + * \param[in] callback_handle the handle of the callback to deregister + */ +void LIBUSB_CALL libusb_hotplug_deregister_callback(libusb_context *ctx, + libusb_hotplug_callback_handle callback_handle); + +/** \ingroup libusb_lib + * Available option values for libusb_set_option(). + */ +enum libusb_option { + /** Set the log message verbosity. + * + * The default level is LIBUSB_LOG_LEVEL_NONE, which means no messages are ever + * printed. If you choose to increase the message verbosity level, ensure + * that your application does not close the stderr file descriptor. + * + * You are advised to use level LIBUSB_LOG_LEVEL_WARNING. libusb is conservative + * with its message logging and most of the time, will only log messages that + * explain error conditions and other oddities. This will help you debug + * your software. + * + * If the LIBUSB_DEBUG environment variable was set when libusb was + * initialized, this function does nothing: the message verbosity is fixed + * to the value in the environment variable. + * + * If libusb was compiled without any message logging, this function does + * nothing: you'll never get any messages. + * + * If libusb was compiled with verbose debug message logging, this function + * does nothing: you'll always get messages from all levels. + */ + LIBUSB_OPTION_LOG_LEVEL, + + /** Use the UsbDk backend for a specific context, if available. + * + * This option should be set immediately after calling libusb_init(), otherwise + * unspecified behavior may occur. + * + * Only valid on Windows. + */ + LIBUSB_OPTION_USE_USBDK, +}; + +int LIBUSB_CALL libusb_set_option(libusb_context *ctx, enum libusb_option option, ...); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libusb/readme.md b/libusb/readme.md new file mode 100644 index 0000000..2194b9a --- /dev/null +++ b/libusb/readme.md @@ -0,0 +1,3 @@ +Files here are from https://github.com/libusb/libusb/releases/tag/v1.0.23 +libusb-1.0.a is the MinGW64 static library. +Those files were release as LGPL 2.1 \ No newline at end of file diff --git a/src/crypto.c b/src/crypto.c index f962af7..011dd9b 100644 --- a/src/crypto.c +++ b/src/crypto.c @@ -21,7 +21,7 @@ #include #include -#include +#include #include "../tiny-AES-c/aes.h" #include "crypto.h" diff --git a/src/getopt.c b/src/getopt.c new file mode 100644 index 0000000..a535bd2 --- /dev/null +++ b/src/getopt.c @@ -0,0 +1,118 @@ +//https://gist.github.com/superwills/5815344 +// Put this in a separate .h file (called "getopt.h"). +// The prototype for the header file is: +/* +#ifndef GETOPT_H +#define GETOPT_H + +int getopt(int nargc, char * const nargv[], const char *ostr) ; + +#endif +*/ + +#include "getopt.h" // make sure you construct the header file as dictated above + +/* +* Copyright (c) 1987, 1993, 1994 +* The Regents of the University of California. All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions +* are met: +* 1. Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* 2. Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* 3. All advertising materials mentioning features or use of this software +* must display the following acknowledgement: +* This product includes software developed by the University of +* California, Berkeley and its contributors. +* 4. Neither the name of the University nor the names of its contributors +* may be used to endorse or promote products derived from this software +* without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +* SUCH DAMAGE. +*/ + +#include +#include + +int opterr = 1, /* if error message should be printed */ + optind = 1, /* index into parent argv vector */ + optopt, /* character checked for validity */ + optreset; /* reset getopt */ +char *optarg; /* argument associated with option */ + +#define BADCH (int)'?' +#define BADARG (int)':' +#define EMSG "" + +/* + * getopt -- + * Parse argc/argv argument vector. + */ +int getopt(int nargc, char * const nargv[], const char *ostr) +{ + static char *place = EMSG; /* option letter processing */ + const char *oli; /* option letter list index */ + + if (optreset || !*place) { /* update scanning pointer */ + optreset = 0; + if (optind >= nargc || *(place = nargv[optind]) != '-') { + place = EMSG; + return (-1); + } + if (place[1] && *++place == '-') { /* found "--" */ + ++optind; + place = EMSG; + return (-1); + } + } /* option letter okay? */ + if ((optopt = (int)*place++) == (int)':' || + !(oli = strchr(ostr, optopt))) { + /* + * if the user didn't specify '-' as an option, + * assume it means -1. + */ + if (optopt == (int)'-') + return (-1); + if (!*place) + ++optind; + if (opterr && *ostr != ':') + (void)printf("illegal option -- %c\n", optopt); + return (BADCH); + } + if (*++oli != ':') { /* don't need argument */ + optarg = NULL; + if (!*place) + ++optind; + } + else { /* need an argument */ + if (*place) /* no white space */ + optarg = place; + else if (nargc <= ++optind) { /* no arg */ + place = EMSG; + if (*ostr == ':') + return (BADARG); + if (opterr) + (void)printf("option requires an argument -- %c\n", optopt); + return (BADCH); + } + else /* white space */ + optarg = nargv[optind]; + place = EMSG; + ++optind; + } + return (optopt); /* dump back option letter */ +} \ No newline at end of file diff --git a/src/getopt.h b/src/getopt.h new file mode 100644 index 0000000..3598627 --- /dev/null +++ b/src/getopt.h @@ -0,0 +1,6 @@ +//https://gist.github.com/superwills/5815344 +#ifndef GETOPT_H +#define GETOPT_H +int getopt(int nargc, char * const nargv[], const char *ostr); +extern int optind; +#endif \ No newline at end of file diff --git a/src/main.c b/src/main.c index 492f219..3e71959 100644 --- a/src/main.c +++ b/src/main.c @@ -21,9 +21,9 @@ #include #include -#include #include +#include "getopt.h" #include "stlink.h" #define STLINK_VID 0x0483 diff --git a/src/stlink.c b/src/stlink.c index a596e2d..d23723e 100644 --- a/src/stlink.c +++ b/src/stlink.c @@ -24,8 +24,6 @@ #include #include #include -#include -#include #include #include @@ -232,7 +230,7 @@ int stlink_dfu_download(libusb_device_handle *dev_handle, return -3; } - usleep(dfu_status.bwPollTimeout * 1000); + Sleep(dfu_status.bwPollTimeout); if (stlink_dfu_status(dev_handle, &dfu_status)) { return -1; @@ -332,38 +330,27 @@ int stlink_flash(libusb_device_handle *dev_handle, unsigned int base_offset, unsigned int chunk_size, struct STLinkInfos *stlink_infos) { - unsigned char *firmware, firmware_chunk[chunk_size]; + unsigned char firmware_chunk[chunk_size]; unsigned int cur_chunk_size, flashed_bytes, file_size; - int fd, res; + FILE *fd; + int res; struct stat firmware_stat; - fd = open(filename, O_RDONLY); - if (fd == -1) { + fd = fopen(filename, "rb"); + if (fd == NULL) { fprintf(stderr, "File opening failed\n"); return -1; } - fstat(fd, &firmware_stat); + stat(filename, &firmware_stat); file_size = firmware_stat.st_size; - firmware = mmap(NULL, file_size, PROT_WRITE, MAP_PRIVATE, fd, 0); - if (firmware == MAP_FAILED) { - fprintf(stderr, "mmap failure\n"); - return -1; - } - printf("Loaded firmware : %s, size : %d bytes\n", filename, (int)file_size); flashed_bytes = 0; - while (flashed_bytes < file_size) { - if ((flashed_bytes+chunk_size) > file_size) { - cur_chunk_size = file_size - flashed_bytes; - } else { - cur_chunk_size = chunk_size; - } - + do { res = stlink_erase(dev_handle, base_offset+flashed_bytes); if (res) { fprintf(stderr, "Erase error\n"); @@ -376,11 +363,17 @@ int stlink_flash(libusb_device_handle *dev_handle, return res; } - memcpy(firmware_chunk, firmware+flashed_bytes, cur_chunk_size); + cur_chunk_size = fread(firmware_chunk, sizeof(unsigned char), chunk_size, fd); + if (cur_chunk_size <= 0) { + fprintf(stderr, "Read error\n"); + return cur_chunk_size; + } + + // Zero out the buffer after any partial reads (eg the final chunk). memset(firmware_chunk+cur_chunk_size, 0xff, chunk_size-cur_chunk_size); res = stlink_dfu_download(dev_handle, firmware_chunk, chunk_size, 2, stlink_infos); if (res) { - fprintf(stderr, "Erase error\n"); + fprintf(stderr, "Write error\n"); return res; } @@ -388,10 +381,9 @@ int stlink_flash(libusb_device_handle *dev_handle, fflush(stdout); /* Flush stdout buffer */ flashed_bytes += cur_chunk_size; - } + } while (flashed_bytes < file_size); - munmap(firmware, file_size); - close(fd); + fclose(fd); printf("\n");