From 750d9b37905b7a1cf9e8708c4688f3342c8be133 Mon Sep 17 00:00:00 2001 From: Dobrica Pavlinusic Date: Sun, 17 Aug 2014 19:43:04 +0200 Subject: [PATCH] version 4.1.0 from http://fpga4u.epfl.ch/wiki/FX2 --- Hex2bix.exe | Bin 0 -> 30240 bytes Makefile | 174 +++++ copying.txt | 340 ++++++++++ dscr.a51 | 375 +++++++++++ eeprom.c | 154 +++++ eeprom.h | 52 ++ fx2/Makefile | 70 ++ fx2/delay.c | 148 +++++ fx2/delay.h | 72 +++ fx2/fx2regs.h | 1428 +++++++++++++++++++++++++++++++++++++++++ fx2/fx2utils.c | 104 +++ fx2/fx2utils.h | 60 ++ fx2/i2c.c | 242 +++++++ fx2/i2c.h | 60 ++ fx2/isr.c | 336 ++++++++++ fx2/isr.h | 171 +++++ fx2/syncdelay.h | 128 ++++ fx2/timer.c | 94 +++ fx2/timer.h | 65 ++ fx2/usb_common.c | 752 ++++++++++++++++++++++ fx2/usb_common.h | 100 +++ fx2/usb_descriptors.h | 76 +++ fx2/usb_requests.h | 172 +++++ hardware.h | 68 ++ hw_basic.c | 443 +++++++++++++ hw_xpcu_i.c | 300 +++++++++ hw_xpcu_x.c | 440 +++++++++++++ readme.txt | 148 +++++ startup.a51 | 156 +++++ usbjtag.c | 470 ++++++++++++++ usbjtag.hex | 279 ++++++++ usbjtag.iic | Bin 0 -> 4216 bytes vectors.a51 | 352 ++++++++++ 33 files changed, 7829 insertions(+) create mode 100644 Hex2bix.exe create mode 100644 Makefile create mode 100644 copying.txt create mode 100644 dscr.a51 create mode 100644 eeprom.c create mode 100644 eeprom.h create mode 100644 fx2/Makefile create mode 100644 fx2/delay.c create mode 100644 fx2/delay.h create mode 100644 fx2/fx2regs.h create mode 100644 fx2/fx2utils.c create mode 100644 fx2/fx2utils.h create mode 100644 fx2/i2c.c create mode 100644 fx2/i2c.h create mode 100644 fx2/isr.c create mode 100644 fx2/isr.h create mode 100644 fx2/syncdelay.h create mode 100644 fx2/timer.c create mode 100644 fx2/timer.h create mode 100644 fx2/usb_common.c create mode 100644 fx2/usb_common.h create mode 100644 fx2/usb_descriptors.h create mode 100644 fx2/usb_requests.h create mode 100644 hardware.h create mode 100644 hw_basic.c create mode 100644 hw_xpcu_i.c create mode 100644 hw_xpcu_x.c create mode 100644 readme.txt create mode 100644 startup.a51 create mode 100644 usbjtag.c create mode 100644 usbjtag.hex create mode 100644 usbjtag.iic create mode 100644 vectors.a51 diff --git a/Hex2bix.exe b/Hex2bix.exe new file mode 100644 index 0000000000000000000000000000000000000000..78f6f1d2977bbf75dacd4befabbb223a566b614a GIT binary patch literal 30240 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 Z-UXWYpIV}^t2JM~D+zEzZV1NM{{ca4BHsW2 literal 0 HcmV?d00001 diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..8af9262 --- /dev/null +++ b/Makefile @@ -0,0 +1,174 @@ +#----------------------------------------------------------------------------- + +# Makefile for usb_jtag FX2 firmware + +#----------------------------------------------------------------------------- + +# Copyright 2007 Kolja Waschk, ixo.de + +#----------------------------------------------------------------------------- + +# This code is part of usbjtag. usbjtag is free software; you can redistribute + +# it and/or modify it under the terms of the GNU General Public License as + +# published by the Free Software Foundation; either version 2 of the License, + +# or (at your option) any later version. usbjtag is distributed in the hope + +# that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + +# GNU General Public License for more details. You should have received a + +# copy of the GNU General Public License along with this program in the file + +# COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + +# St, Fifth Floor, Boston, MA 02110-1301 USA + +#----------------------------------------------------------------------------- + + + +LIBDIR=fx2 + +LIB=libfx2.lib + + + +ifeq (${HARDWARE},) + + HARDWARE=hw_basic + + #HARDWARE=hw_xpcu_i + + #HARDWARE=hw_xpcu_x + +endif + + + +CC=sdcc + +CFLAGS+=-mmcs51 --no-xinit-opt -I${LIBDIR} -D${HARDWARE} + +CFLAGS+=--opt-code-size + + + +AS=asx8051 + +ASFLAGS+=-plosgff + + + +LDFLAGS=--code-loc 0x0000 --code-size 0x1800 + +LDFLAGS+=--xram-loc 0x1800 --xram-size 0x0800 + +LDFLAGS+=-Wl '-b USBDESCSEG = 0xE100' + +LDFLAGS+=-L ${LIBDIR} + + + +%.rel : %.a51 + + $(AS) $(ASFLAGS) $< + + + +%.rel : %.c + + $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@ + + + +%.iic : %.hex + + ./hex2bix -ir -f 0xC2 -m 0xF000 -c 0x1 -o $@ $< + + + +default: usbjtag.iic + + + +usbjtag.hex: vectors.rel usbjtag.rel dscr.rel eeprom.rel ${HARDWARE}.rel startup.rel ${LIBDIR}/${LIB} + + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $+ + + packihx $@ > .tmp.hex + + rm $@ + + mv .tmp.hex $@ + + + +${LIBDIR}/${LIB}: + + make -C ${LIBDIR} + + + +.PHONY: boot + +boot: usbjtag.hex + + -test -e /dev/usb_jtag && /sbin/fxload -D /dev/usb_jtag -I usbjtag.hex -t fx2 + + -test -e /dev/tracii_xl2 && /sbin/fxload -D /dev/tracii_xl2 -I usbjtag.hex -t fx2 + + -test -e /dev/xilinx_xpcu && /sbin/fxload -D /dev/xilinx_xpcu -I usbjtag.hex -t fx2 + + + +REF=/home/kawk/work/xilinx/xtern/xusbdfwu/xusbdfwu-1025.hex + + + +.PHONY: ref + +ref: + + -test -e /dev/usb_jtag && /sbin/fxload -D /dev/usb_jtag -I ${REF} -t fx2 + + -test -e /dev/tracii_xl2 && /sbin/fxload -D /dev/tracii_xl2 -I ${REF} -t fx2 + + -test -e /dev/xilinx_xpcu && /sbin/fxload -D /dev/xilinx_xpcu -I ${REF} -t fx2 + + + +dscr.rel: dscr.a51 + +eeprom.rel: eeprom.c eeprom.h + +usbjtag.rel: usbjtag.c hardware.h eeprom.h + +${HARDWARE}.rel: ${HARDWARE}.c hardware.h + + + +.PHONY: clean distclean + + + +clean: + + make -C ${LIBDIR} clean + + rm -f *.lst *.asm *.lib *.sym *.rel *.mem *.map *.rst *.lnk *.hex *.ihx *.iic + + + +distclean: clean + + + + + + + diff --git a/copying.txt b/copying.txt new file mode 100644 index 0000000..a8e1c52 --- /dev/null +++ b/copying.txt @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/dscr.a51 b/dscr.a51 new file mode 100644 index 0000000..3228002 --- /dev/null +++ b/dscr.a51 @@ -0,0 +1,375 @@ +;;; -*- asm -*- +;;; +;;;----------------------------------------------------------------------------- +;;; USB Descriptor(s) +;;;----------------------------------------------------------------------------- +;;; Copyright 2005..2007 Kolja Waschk, ixo.de +;;; Modified by LAP for FPGA4U project, Jan 2007. lap.epfl.ch +;;;----------------------------------------------------------------------------- +;;; Code based on USRP2 firmware (GNU Radio Project), version 3.0.2, +;;; Copyright 2003 Free Software Foundation, Inc. +;;;----------------------------------------------------------------------------- +;;; This code is part of usbjtag. usbjtag is free software; you can redistribute +;;; it and/or modify it under the terms of the GNU General Public License as +;;; published by the Free Software Foundation; either version 2 of the License, +;;; or (at your option) any later version. usbjtag is distributed in the hope +;;; that it will be useful, but WITHOUT ANY WARRANTY; without even the implied +;;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;;; GNU General Public License for more details. You should have received a +;;; copy of the GNU General Public License along with this program in the file +;;; COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin +;;; St, Fifth Floor, Boston, MA 02110-1301 USA +;;;----------------------------------------------------------------------------- + + .module usb_descriptors + + VID = 0x09FB ; Changed by LAP to match Altera VID + PID = 0x6001 ; Changed by LAP to match Altera USBBlaster PID + VERSION = 0x0400 ; Product Version (4 indicates *BM device) + USB_VER = 0x0110 ; Support USB version 1.10 + USB_ATTR = 0x80 ; Bus powered, not self-powered, no remote wakeup + FTD_ATTR = 0x001C ; Set USB version, use version string, enable suspend PD + MAX_POWER = 250 ; need 2*250 mA max + + DSCR_DEVICE = 1 ; Descriptor type: Device + DSCR_CONFIG = 2 ; Descriptor type: Configuration + DSCR_STRING = 3 ; Descriptor type: String + DSCR_INTRFC = 4 ; Descriptor type: Interface + DSCR_ENDPNT = 5 ; Descriptor type: Endpoint + DSCR_DEVQUAL = 6 ; Descriptor type: Device Qualifier + + DSCR_DEVICE_LEN = 18 + DSCR_CONFIG_LEN = 9 + DSCR_INTRFC_LEN = 9 + DSCR_ENDPNT_LEN = 7 + DSCR_DEVQUAL_LEN = 10 + + ET_CONTROL = 0 ; Endpoint type: Control + ET_ISO = 1 ; Endpoint type: Isochronous + ET_BULK = 2 ; Endpoint type: Bulk + ET_INT = 3 ; Endpoint type: Interrupt + +;;; -------------------------------------------------------- +;;; external ram data +;;;-------------------------------------------------------- + + .area USBDESCSEG (XDATA) + +;;; ---------------------------------------------------------------- +;;; descriptors used when operating at high speed (480Mb/sec) +;;; ---------------------------------------------------------------- + + .even ; descriptors must be 2-byte aligned for SUDPTR{H,L} to work + + ;; The .even directive isn't really honored by the linker. Bummer! + ;; (There's no way to specify an alignment requirement for a given area, + ;; hence when they're concatenated together, even doesn't work.) + ;; + ;; We work around this by telling the linker to put USBDESCSEG + ;; at 0xE000 absolute. This means that the maximimum length of this + ;; segment is 480 bytes, leaving room for the two hash slots + ;; at 0xE1EO to 0xE1FF. + ;; Note from LAP: TODOOOOO + +_high_speed_device_descr:: + .db DSCR_DEVICE_LEN + .db DSCR_DEVICE +_dscr_usbver:: + .db USB_VER ; Specification version (MSB) + .db 0xFF ; device class (vendor specific) 0xFF + .db 0x00 ; device subclass (vendor specific) + .db 0x00 ; device protocol (vendor specific) + .db 64 ; bMaxPacketSize0 for endpoint 0 +_dscr_vidpidver:: + .db VID ; idVendor + .db PID ; idProduct + .db VERSION ; bcdDevice +_dscr_strorder:: + .db SI_VENDOR ; iManufacturer (string index) + .db SI_PRODUCT ; iProduct (string index) + .db SI_SERIAL ; iSerial number (string index) + .db 1 ; bNumConfigurations + + .even +_high_speed_devqual_descr:: + .db DSCR_DEVQUAL_LEN + .db DSCR_DEVQUAL + .db USB_VER ; bcdUSB (MSB) + .db 0xFF ; bDeviceClass + .db 0xFF ; bDeviceSubClass + .db 0xFF ; bDeviceProtocol + .db 64 ; bMaxPacketSize0 + .db 1 ; bNumConfigurations (one config at 12Mb/sec) + .db 0 ; bReserved + + .even +_high_speed_config_descr:: + .db DSCR_CONFIG_LEN + .db DSCR_CONFIG + .db <(_high_speed_config_descr_end - _high_speed_config_descr) ; LSB + .db >(_high_speed_config_descr_end - _high_speed_config_descr) ; MSB + .db 2 ; bNumInterfaces + .db 1 ; bConfigurationValue + .db 0 ; iConfiguration +_dscr_attrpow:: + .db USB_ATTR ; bmAttributes + .db MAX_POWER ; bMaxPower [Unit: 0.5 mA] + + ;; interface descriptor + + .db DSCR_INTRFC_LEN + .db DSCR_INTRFC + .db 0 ; bInterfaceNumber (zero based) + .db 0 ; bAlternateSetting + .db 2 ; bNumEndpoints + .db 0xFF ; bInterfaceClass (vendor specific) + .db 0xFF ; bInterfaceSubClass (vendor specific) + .db 0xFF ; bInterfaceProtocol (vendor specific) + .db SI_PRODUCT ; iInterface (description) + + ;; endpoint descriptor + + .db DSCR_ENDPNT_LEN + .db DSCR_ENDPNT + .db 0x81 ; bEndpointAddress (ep 1 IN) + .db ET_BULK ; bmAttributes + .db <64 ; wMaxPacketSize (LSB) + .db >64 ; wMaxPacketSize (MSB) + .db 0 ; bInterval (iso only) + + ;; endpoint descriptor + + .db DSCR_ENDPNT_LEN + .db DSCR_ENDPNT + .db 0x02 ; bEndpointAddress (ep 2 OUT) + .db ET_BULK ; bmAttributes + .db <64 ; wMaxPacketSize (LSB) + .db >64 ; wMaxPacketSize (MSB) + .db 0 ; bInterval (iso only) + + ;; interface descriptor + + .db DSCR_INTRFC_LEN + .db DSCR_INTRFC + .db 1 ; bInterfaceNumber (zero based) + .db 0 ; bAlternateSetting + .db 2 ; bNumEndpoints + .db 0xFF ; bInterfaceClass (vendor specific) + .db 0xFF ; bInterfaceSubClass (vendor specific) + .db 0xFF ; bInterfaceProtocol (vendor specific) + .db SI_PRODUCT ; iInterface (description) + + ;; Endpoint Descriptor 2 + + .db DSCR_ENDPNT_LEN ; Descriptor length + .db DSCR_ENDPNT ; Descriptor type + .db 0x06 ; Endpoint number and direction + .db ET_BULK ; Endpoint type + .db 0x00 ; Maximum packet size (LSB) + .db 0x02 ; Max packect size (MSB) + .db 0x00 ; Polling interval + + ;; Endpoint Descriptor 2 + .db DSCR_ENDPNT_LEN ; Descriptor length + .db DSCR_ENDPNT ; Descriptor type + .db 0x88 ; Endpoint number, and direction + .db ET_BULK ; Endpoint type + .db 0x00 ; Maximum packet size (LSB) + .db 0x02 ; Max packect size (MSB) + .db 0x00 ; Polling interval + +_high_speed_config_descr_end: + +;;; ---------------------------------------------------------------- +;;; descriptors used when operating at full speed (12Mb/sec) +;;; ---------------------------------------------------------------- + + .even +_full_speed_device_descr:: + .db DSCR_DEVICE_LEN + .db DSCR_DEVICE + .db USB_VER ; Specification version (MSB) + .db 0x00 ; device class (vendor specific) + .db 0x00 ; device subclass (vendor specific) + .db 0x00 ; device protocol (vendor specific) + .db 64 ; bMaxPacketSize0 for endpoint 0 + .db VID ; idVendor + .db PID ; idProduct + .db VERSION ; bcdDevice + .db SI_VENDOR ; iManufacturer (string index) + .db SI_PRODUCT ; iProduct (string index) + .db SI_SERIAL ; iSerial number (None) + .db 1 ; bNumConfigurations + +;;; describes the other speed (480Mb/sec) + .even +_full_speed_devqual_descr:: + .db DSCR_DEVQUAL_LEN + .db DSCR_DEVQUAL + .db USB_VER ; bcdUSB + .db 0xFF ; bDeviceClass + .db 0xFF ; bDeviceSubClass + .db 0xFF ; bDeviceProtocol + .db 64 ; bMaxPacketSize0 + .db 1 ; bNumConfigurations (one config at 480Mb/sec) + .db 0 ; bReserved + + .even +_full_speed_config_descr:: + .db DSCR_CONFIG_LEN + .db DSCR_CONFIG + .db <(_full_speed_config_descr_end - _full_speed_config_descr) ; LSB + .db >(_full_speed_config_descr_end - _full_speed_config_descr) ; MSB + .db 2 ; bNumInterfaces + .db 1 ; bConfigurationValue + .db 0 ; iConfiguration + .db USB_ATTR ; bmAttributes + .db MAX_POWER ; bMaxPower [Unit: 0.5 mA] + + ;; interface descriptor + + .db DSCR_INTRFC_LEN + .db DSCR_INTRFC + .db 0 ; bInterfaceNumber (zero based) + .db 0 ; bAlternateSetting + .db 2 ; bNumEndpoints + .db 0xFF ; bInterfaceClass (vendor specific) + .db 0xFF ; bInterfaceSubClass (vendor specific) + .db 0xFF ; bInterfaceProtocol (vendor specific) + .db SI_PRODUCT ; iInterface (description) + + ;; endpoint descriptor + + .db DSCR_ENDPNT_LEN + .db DSCR_ENDPNT + .db 0x81 ; bEndpointAddress (ep 1 IN) + .db ET_BULK ; bmAttributes + .db <64 ; wMaxPacketSize (LSB) + .db >64 ; wMaxPacketSize (MSB) + .db 0 ; bInterval (iso only) + + ;; endpoint descriptor + + .db DSCR_ENDPNT_LEN + .db DSCR_ENDPNT + .db 0x02 ; bEndpointAddress (ep 2 OUT) + .db ET_BULK ; bmAttributes + .db <64 ; wMaxPacketSize (LSB) + .db >64 ; wMaxPacketSize (MSB) + .db 0 ; bInterval (iso only) + + ;; interface descriptor + + .db DSCR_INTRFC_LEN + .db DSCR_INTRFC + .db 1 ; bInterfaceNumber (zero based) + .db 0 ; bAlternateSetting + .db 2 ; bNumEndpoints + .db 0xFF ; bInterfaceClass (vendor specific) + .db 0xFF ; bInterfaceSubClass (vendor specific) + .db 0xFF ; bInterfaceProtocol (vendor specific) + .db SI_PRODUCT ; iInterface (description) + + ;; endpoint descriptor + + .db DSCR_ENDPNT_LEN + .db DSCR_ENDPNT + .db 0x06 ; bEndpointAddress (ep 6 OUT) + .db ET_BULK ; bmAttributes + .db 0x40 ; wMaxPacketSize (LSB) + .db 0x00 ; wMaxPacketSize (MSB) + .db 0 ; bInterval (iso only) + + ;; endpoint descriptor + + .db DSCR_ENDPNT_LEN + .db DSCR_ENDPNT + .db 0x88 ; bEndpointAddress (ep 8 IN) + .db ET_BULK ; bmAttributes + .db 0x40 ; wMaxPacketSize (LSB) + .db 0x00 ; wMaxPacketSize (MSB) + .db 0 ; bInterval (iso only) + + +_full_speed_config_descr_end: + +;;; ---------------------------------------------------------------- +;;; string descriptors +;;; ---------------------------------------------------------------- + +_nstring_descriptors:: + .db (_string_descriptors_end - _string_descriptors) / 2 + +_string_descriptors:: + .db str0 + .db str1 + .db str2 + .db str3 +_string_descriptors_end: + + SI_NONE = 0 + ;; str0 contains the language ID's. + .even +_str0:: +str0: .db str0_end - str0 + .db DSCR_STRING + .db 0 + .db 0 + .db <0x0409 ; magic code for US English (LSB) + .db >0x0409 ; magic code for US English (MSB) +str0_end: + + SI_VENDOR = 1 + .even +_str1:: +str1: .db str1_end - str1 + .db DSCR_STRING + .db 'E, 0 ; 16-bit unicode + .db 'P, 0 + .db 'F, 0 + .db 'L, 0 +str1_end: + + SI_PRODUCT = 2 + .even +_str2:: +str2: .db str2_end - str2 + .db DSCR_STRING + .db 'U, 0 + .db 'S, 0 + .db 'B, 0 + .db '-, 0 + .db 'B, 0 + .db 'l, 0 + .db 'a, 0 + .db 's, 0 + .db 't, 0 + .db 'e, 0 + .db 'r, 0 +str2_end: + + SI_SERIAL = 3 + .even +_str3:: +str3: .db str3_end - str3 + .db DSCR_STRING + .db '0, 0 + .db '0, 0 + .db '0, 0 + .db '0, 0 + .db '0, 0 + .db '0, 0 + .db '0, 0 + .db '0, 0 +str3_end: + diff --git a/eeprom.c b/eeprom.c new file mode 100644 index 0000000..fc1f319 --- /dev/null +++ b/eeprom.c @@ -0,0 +1,154 @@ +/*----------------------------------------------------------------------------- + + * FTDI EEPROM emulation + + *----------------------------------------------------------------------------- + + * Copyright (C) 2007 Kolja Waschk, ixo.de + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#include "eeprom.h" + +#include "usb_descriptors.h" + + + +xdata unsigned char eeprom[128]; + + + +extern xdata char dscr_vidpidver[6]; + +extern xdata char dscr_attrpow[2]; + +extern xdata char dscr_usbver[2]; + +extern xdata char dscr_strorder[4]; + +extern xdata char str1[]; + +extern xdata char str2[]; + +extern xdata char str3[]; + + + +static unsigned char ee_ptr; + +static unsigned short ee_cksum; + + + +void eeprom_append(unsigned char nb) + +{ + + unsigned char pree_ptr = ee_ptr & ~1; + + if(pree_ptr != ee_ptr) + + { + + ee_cksum = ee_cksum ^((unsigned short)nb << 8); + + ee_cksum = ee_cksum ^ eeprom[pree_ptr]; + + ee_cksum = (ee_cksum << 1) | (ee_cksum >> 15); + + }; + + eeprom[ee_ptr++] = nb; + +} + + + +void eeprom_init(void) + +{ + + char j,sofs; + + ee_ptr = 0; + + ee_cksum = 0xAAAA; + + + + eeprom_append(0x00); + + eeprom_append(0x00); + + for(j=0;j<6;j++) eeprom_append(dscr_vidpidver[j]); + + for(j=0;j<2;j++) eeprom_append(dscr_attrpow[j]); + + eeprom_append(0x1C); + + eeprom_append(0x00); + + for(j=0;j<2;j++) eeprom_append(dscr_usbver[j]); + + sofs = 0x80 + ee_ptr + 6; + + eeprom_append(sofs); + + eeprom_append(str1[0]); + + sofs += str1[0]; + + eeprom_append(sofs); + + eeprom_append(str2[0]); + + sofs += str2[0]; + + eeprom_append(sofs); + + eeprom_append(str3[0]); + + for(j=0;j>8)&0xFF; + +} + + + diff --git a/eeprom.h b/eeprom.h new file mode 100644 index 0000000..09efb08 --- /dev/null +++ b/eeprom.h @@ -0,0 +1,52 @@ +/*----------------------------------------------------------------------------- + + * FTDI EEPROM emulation + + *----------------------------------------------------------------------------- + + * Copyright (C) 2007 Kolja Waschk, ixo.de + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#ifndef _EEPROM_H + +#define _EEPROM_H 1 + + + +extern xdata unsigned char eeprom[128]; + +extern void eeprom_init(void); + + + +#endif /* _EEPROM_H */ + + + diff --git a/fx2/Makefile b/fx2/Makefile new file mode 100644 index 0000000..29f2ff0 --- /dev/null +++ b/fx2/Makefile @@ -0,0 +1,70 @@ +#----------------------------------------------------------------------------- + +# Makefile for FX2 library code + +#----------------------------------------------------------------------------- + +# Copyright (C) 2007 Kolja Waschk, ixo.de + +#----------------------------------------------------------------------------- + +# This code is part of usbjtag. usbjtag is free software; you can redistribute + +# it and/or modify it under the terms of the GNU General Public License as + +# published by the Free Software Foundation; either version 2 of the License, + +# or (at your option) any later version. usbjtag is distributed in the hope + +# that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + +# GNU General Public License for more details. You should have received a + +# copy of the GNU General Public License along with this program in the file + +# COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + +# St, Fifth Floor, Boston, MA 02110-1301 USA + +#----------------------------------------------------------------------------- + + + +CC=sdcc + +CFLAGS+=-mmcs51 --no-xinit-opt -I. + +CPPFLAGS+= + + + +%.rel : %.c + + $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@ + + + +libfx2.lib: delay.rel fx2utils.rel i2c.rel isr.rel timer.rel usb_common.rel + + rm -f $@ + + touch $@ + + for obj in $^ ; do basename $$obj .rel >> $@ ; done + + + +clean: + + rm -f *.lst *.asm *.lib *.sym *.rel *.lib + + + + + + + + + diff --git a/fx2/delay.c b/fx2/delay.c new file mode 100644 index 0000000..621363a --- /dev/null +++ b/fx2/delay.c @@ -0,0 +1,148 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * Delay routines + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +/* + + * Delay approximately 1 microsecond (including overhead in udelay). + + */ + +static void + +udelay1 (void) _naked + +{ + + _asm ; lcall that got us here took 4 bus cycles + + ret ; 4 bus cycles + + _endasm; + +} + + + +/* + + * delay for approximately usecs microseconds + + */ + +void + +udelay (unsigned char usecs) + +{ + + do { + + udelay1 (); + + } while (--usecs != 0); + +} + + + + + +/* + + * Delay approximately 1 millisecond. + + * We're running at 48 MHz, so we need 48,000 clock cycles. + + * + + * Note however, that each bus cycle takes 4 clock cycles (not obvious, + + * but explains the factor of 4 problem below). + + */ + +static void + +mdelay1 (void) _naked + +{ + + _asm + + mov dptr,#(-1200 & 0xffff) + +002$: + + inc dptr ; 3 bus cycles + + mov a, dpl ; 2 bus cycles + + orl a, dph ; 2 bus cycles + + jnz 002$ ; 3 bus cycles + + + + ret + + _endasm; + +} + + + +void + +mdelay (unsigned int msecs) + +{ + + do { + + mdelay1 (); + + } while (--msecs != 0); + +} + + + + + diff --git a/fx2/delay.h b/fx2/delay.h new file mode 100644 index 0000000..a159ac8 --- /dev/null +++ b/fx2/delay.h @@ -0,0 +1,72 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * Delay routines + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#ifndef _DELAY_H_ + +#define _DELAY_H_ + + + +/* + + * delay for approximately usecs microseconds + + * Note limit of 255 usecs. + + */ + +void udelay (unsigned char usecs); + + + +/* + + * delay for approximately msecs milliseconds + + */ + +void mdelay (unsigned short msecs); + + + + + +#endif /* _DELAY_H_ */ + diff --git a/fx2/fx2regs.h b/fx2/fx2regs.h new file mode 100644 index 0000000..597777a --- /dev/null +++ b/fx2/fx2regs.h @@ -0,0 +1,1428 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * FX2 register definitions + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +/* + +//----------------------------------------------------------------------------- + +// File: FX2regs.h + +// Contents: EZ-USB FX2 register declarations and bit mask definitions. + +// + +// $Archive: /USB/Target/Inc/fx2regs.h $ + +// $Date: 2009/09/30 14:08:56 $ + +// $Revision: 1.5 $ + +// + +// + +// Copyright (c) 2000 Cypress Semiconductor, All rights reserved + +//----------------------------------------------------------------------------- + +*/ + + + + + +#ifndef FX2REGS_H /* Header Sentry */ + +#define FX2REGS_H + + + +#define ALLOCATE_EXTERN // required for "right thing to happen" with fx2regs.h + + + +/* + +//----------------------------------------------------------------------------- + +// FX2 Related Register Assignments + +//----------------------------------------------------------------------------- + + + +// The Ez-USB FX2 registers are defined here. We use FX2regs.h for register + +// address allocation by using "#define ALLOCATE_EXTERN". + +// When using "#define ALLOCATE_EXTERN", you get (for instance): + +// xdata volatile BYTE OUT7BUF[64] _at_ 0x7B40; + +// Such lines are created from FX2.h by using the preprocessor. + +// Incidently, these lines will not generate any space in the resulting hex + +// file; they just bind the symbols to the addresses for compilation. + +// You just need to put "#define ALLOCATE_EXTERN" in your main program file; + +// i.e. fw.c or a stand-alone C source file. + +// Without "#define ALLOCATE_EXTERN", you just get the external reference: + +// extern xdata volatile BYTE OUT7BUF[64] ;// 0x7B40; + +// This uses the concatenation operator "##" to insert a comment "//" + +// to cut off the end of the line, "_at_ 0x7B40;", which is not wanted. + +*/ + + + + + +#ifdef ALLOCATE_EXTERN + +#define EXTERN + +#define _AT_(a) at a + +#else + +#define EXTERN extern + +#define _AT_ ;/ ## / + +#endif + + + +typedef unsigned char BYTE; + +typedef unsigned short WORD; + + + +EXTERN xdata _AT_(0xE400) volatile BYTE GPIF_WAVE_DATA[128]; + +EXTERN xdata _AT_(0xE480) volatile BYTE RES_WAVEDATA_END ; + + + +// General Configuration + + + +EXTERN xdata _AT_(0xE600) volatile BYTE CPUCS ; // Control & Status + +EXTERN xdata _AT_(0xE601) volatile BYTE IFCONFIG ; // Interface Configuration + +EXTERN xdata _AT_(0xE602) volatile BYTE PINFLAGSAB ; // FIFO FLAGA and FLAGB Assignments + +EXTERN xdata _AT_(0xE603) volatile BYTE PINFLAGSCD ; // FIFO FLAGC and FLAGD Assignments + +EXTERN xdata _AT_(0xE604) volatile BYTE FIFORESET ; // Restore FIFOS to default state + +EXTERN xdata _AT_(0xE605) volatile BYTE BREAKPT ; // Breakpoint + +EXTERN xdata _AT_(0xE606) volatile BYTE BPADDRH ; // Breakpoint Address H + +EXTERN xdata _AT_(0xE607) volatile BYTE BPADDRL ; // Breakpoint Address L + +EXTERN xdata _AT_(0xE608) volatile BYTE UART230 ; // 230 Kbaud clock for T0,T1,T2 + +EXTERN xdata _AT_(0xE609) volatile BYTE FIFOPINPOLAR ; // FIFO polarities + +EXTERN xdata _AT_(0xE60A) volatile BYTE REVID ; // Chip Revision + +EXTERN xdata _AT_(0xE60B) volatile BYTE REVCTL ; // Chip Revision Control + + + +// Endpoint Configuration + + + +EXTERN xdata _AT_(0xE610) volatile BYTE EP1OUTCFG ; // Endpoint 1-OUT Configuration + +EXTERN xdata _AT_(0xE611) volatile BYTE EP1INCFG ; // Endpoint 1-IN Configuration + +EXTERN xdata _AT_(0xE612) volatile BYTE EP2CFG ; // Endpoint 2 Configuration + +EXTERN xdata _AT_(0xE613) volatile BYTE EP4CFG ; // Endpoint 4 Configuration + +EXTERN xdata _AT_(0xE614) volatile BYTE EP6CFG ; // Endpoint 6 Configuration + +EXTERN xdata _AT_(0xE615) volatile BYTE EP8CFG ; // Endpoint 8 Configuration + +EXTERN xdata _AT_(0xE618) volatile BYTE EP2FIFOCFG ; // Endpoint 2 FIFO configuration + +EXTERN xdata _AT_(0xE619) volatile BYTE EP4FIFOCFG ; // Endpoint 4 FIFO configuration + +EXTERN xdata _AT_(0xE61A) volatile BYTE EP6FIFOCFG ; // Endpoint 6 FIFO configuration + +EXTERN xdata _AT_(0xE61B) volatile BYTE EP8FIFOCFG ; // Endpoint 8 FIFO configuration + +EXTERN xdata _AT_(0xE620) volatile BYTE EP2AUTOINLENH ; // Endpoint 2 Packet Length H (IN only) + +EXTERN xdata _AT_(0xE621) volatile BYTE EP2AUTOINLENL ; // Endpoint 2 Packet Length L (IN only) + +EXTERN xdata _AT_(0xE622) volatile BYTE EP4AUTOINLENH ; // Endpoint 4 Packet Length H (IN only) + +EXTERN xdata _AT_(0xE623) volatile BYTE EP4AUTOINLENL ; // Endpoint 4 Packet Length L (IN only) + +EXTERN xdata _AT_(0xE624) volatile BYTE EP6AUTOINLENH ; // Endpoint 6 Packet Length H (IN only) + +EXTERN xdata _AT_(0xE625) volatile BYTE EP6AUTOINLENL ; // Endpoint 6 Packet Length L (IN only) + +EXTERN xdata _AT_(0xE626) volatile BYTE EP8AUTOINLENH ; // Endpoint 8 Packet Length H (IN only) + +EXTERN xdata _AT_(0xE627) volatile BYTE EP8AUTOINLENL ; // Endpoint 8 Packet Length L (IN only) + +EXTERN xdata _AT_(0xE630) volatile BYTE EP2FIFOPFH ; // EP2 Programmable Flag trigger H + +EXTERN xdata _AT_(0xE631) volatile BYTE EP2FIFOPFL ; // EP2 Programmable Flag trigger L + +EXTERN xdata _AT_(0xE632) volatile BYTE EP4FIFOPFH ; // EP4 Programmable Flag trigger H + +EXTERN xdata _AT_(0xE633) volatile BYTE EP4FIFOPFL ; // EP4 Programmable Flag trigger L + +EXTERN xdata _AT_(0xE634) volatile BYTE EP6FIFOPFH ; // EP6 Programmable Flag trigger H + +EXTERN xdata _AT_(0xE635) volatile BYTE EP6FIFOPFL ; // EP6 Programmable Flag trigger L + +EXTERN xdata _AT_(0xE636) volatile BYTE EP8FIFOPFH ; // EP8 Programmable Flag trigger H + +EXTERN xdata _AT_(0xE637) volatile BYTE EP8FIFOPFL ; // EP8 Programmable Flag trigger L + +EXTERN xdata _AT_(0xE640) volatile BYTE EP2ISOINPKTS ; // EP2 (if ISO) IN Packets per frame (1-3) + +EXTERN xdata _AT_(0xE641) volatile BYTE EP4ISOINPKTS ; // EP4 (if ISO) IN Packets per frame (1-3) + +EXTERN xdata _AT_(0xE642) volatile BYTE EP6ISOINPKTS ; // EP6 (if ISO) IN Packets per frame (1-3) + +EXTERN xdata _AT_(0xE643) volatile BYTE EP8ISOINPKTS ; // EP8 (if ISO) IN Packets per frame (1-3) + +EXTERN xdata _AT_(0xE648) volatile BYTE INPKTEND ; // Force IN Packet End + +EXTERN xdata _AT_(0xE649) volatile BYTE OUTPKTEND ; // Force OUT Packet End + + + +// Interrupts + + + +EXTERN xdata _AT_(0xE650) volatile BYTE EP2FIFOIE ; // Endpoint 2 Flag Interrupt Enable + +EXTERN xdata _AT_(0xE651) volatile BYTE EP2FIFOIRQ ; // Endpoint 2 Flag Interrupt Request + +EXTERN xdata _AT_(0xE652) volatile BYTE EP4FIFOIE ; // Endpoint 4 Flag Interrupt Enable + +EXTERN xdata _AT_(0xE653) volatile BYTE EP4FIFOIRQ ; // Endpoint 4 Flag Interrupt Request + +EXTERN xdata _AT_(0xE654) volatile BYTE EP6FIFOIE ; // Endpoint 6 Flag Interrupt Enable + +EXTERN xdata _AT_(0xE655) volatile BYTE EP6FIFOIRQ ; // Endpoint 6 Flag Interrupt Request + +EXTERN xdata _AT_(0xE656) volatile BYTE EP8FIFOIE ; // Endpoint 8 Flag Interrupt Enable + +EXTERN xdata _AT_(0xE657) volatile BYTE EP8FIFOIRQ ; // Endpoint 8 Flag Interrupt Request + +EXTERN xdata _AT_(0xE658) volatile BYTE IBNIE ; // IN-BULK-NAK Interrupt Enable + +EXTERN xdata _AT_(0xE659) volatile BYTE IBNIRQ ; // IN-BULK-NAK interrupt Request + +EXTERN xdata _AT_(0xE65A) volatile BYTE NAKIE ; // Endpoint Ping NAK interrupt Enable + +EXTERN xdata _AT_(0xE65B) volatile BYTE NAKIRQ ; // Endpoint Ping NAK interrupt Request + +EXTERN xdata _AT_(0xE65C) volatile BYTE USBIE ; // USB Int Enables + +EXTERN xdata _AT_(0xE65D) volatile BYTE USBIRQ ; // USB Interrupt Requests + +EXTERN xdata _AT_(0xE65E) volatile BYTE EPIE ; // Endpoint Interrupt Enables + +EXTERN xdata _AT_(0xE65F) volatile BYTE EPIRQ ; // Endpoint Interrupt Requests + +EXTERN xdata _AT_(0xE660) volatile BYTE GPIFIE ; // GPIF Interrupt Enable + +EXTERN xdata _AT_(0xE661) volatile BYTE GPIFIRQ ; // GPIF Interrupt Request + +EXTERN xdata _AT_(0xE662) volatile BYTE USBERRIE ; // USB Error Interrupt Enables + +EXTERN xdata _AT_(0xE663) volatile BYTE USBERRIRQ ; // USB Error Interrupt Requests + +EXTERN xdata _AT_(0xE664) volatile BYTE ERRCNTLIM ; // USB Error counter and limit + +EXTERN xdata _AT_(0xE665) volatile BYTE CLRERRCNT ; // Clear Error Counter EC[3..0] + +EXTERN xdata _AT_(0xE666) volatile BYTE INT2IVEC ; // Interupt 2 (USB) Autovector + +EXTERN xdata _AT_(0xE667) volatile BYTE INT4IVEC ; // Interupt 4 (FIFOS & GPIF) Autovector + +EXTERN xdata _AT_(0xE668) volatile BYTE INTSETUP ; // Interrupt 2&4 Setup + + + +// Input/Output + + + +EXTERN xdata _AT_(0xE670) volatile BYTE PORTACFG ; // I/O PORTA Alternate Configuration + +EXTERN xdata _AT_(0xE671) volatile BYTE PORTCCFG ; // I/O PORTC Alternate Configuration + +EXTERN xdata _AT_(0xE672) volatile BYTE PORTECFG ; // I/O PORTE Alternate Configuration + +EXTERN xdata _AT_(0xE678) volatile BYTE I2CS ; // Control & Status + +EXTERN xdata _AT_(0xE679) volatile BYTE I2DAT ; // Data + +EXTERN xdata _AT_(0xE67A) volatile BYTE I2CTL ; // I2C Control + +EXTERN xdata _AT_(0xE67B) volatile BYTE XAUTODAT1 ; // Autoptr1 MOVX access + +EXTERN xdata _AT_(0xE67C) volatile BYTE XAUTODAT2 ; // Autoptr2 MOVX access + + + +#define EXTAUTODAT1 XAUTODAT1 + +#define EXTAUTODAT2 XAUTODAT2 + + + +// USB Control + + + +EXTERN xdata _AT_(0xE680) volatile BYTE USBCS ; // USB Control & Status + +EXTERN xdata _AT_(0xE681) volatile BYTE SUSPEND ; // Put chip into suspend + +EXTERN xdata _AT_(0xE682) volatile BYTE WAKEUPCS ; // Wakeup source and polarity + +EXTERN xdata _AT_(0xE683) volatile BYTE TOGCTL ; // Toggle Control + +EXTERN xdata _AT_(0xE684) volatile BYTE USBFRAMEH ; // USB Frame count H + +EXTERN xdata _AT_(0xE685) volatile BYTE USBFRAMEL ; // USB Frame count L + +EXTERN xdata _AT_(0xE686) volatile BYTE MICROFRAME ; // Microframe count, 0-7 + +EXTERN xdata _AT_(0xE687) volatile BYTE FNADDR ; // USB Function address + + + +// Endpoints + + + +EXTERN xdata _AT_(0xE68A) volatile BYTE EP0BCH ; // Endpoint 0 Byte Count H + +EXTERN xdata _AT_(0xE68B) volatile BYTE EP0BCL ; // Endpoint 0 Byte Count L + +EXTERN xdata _AT_(0xE68D) volatile BYTE EP1OUTBC ; // Endpoint 1 OUT Byte Count + +EXTERN xdata _AT_(0xE68F) volatile BYTE EP1INBC ; // Endpoint 1 IN Byte Count + +EXTERN xdata _AT_(0xE690) volatile BYTE EP2BCH ; // Endpoint 2 Byte Count H + +EXTERN xdata _AT_(0xE691) volatile BYTE EP2BCL ; // Endpoint 2 Byte Count L + +EXTERN xdata _AT_(0xE694) volatile BYTE EP4BCH ; // Endpoint 4 Byte Count H + +EXTERN xdata _AT_(0xE695) volatile BYTE EP4BCL ; // Endpoint 4 Byte Count L + +EXTERN xdata _AT_(0xE698) volatile BYTE EP6BCH ; // Endpoint 6 Byte Count H + +EXTERN xdata _AT_(0xE699) volatile BYTE EP6BCL ; // Endpoint 6 Byte Count L + +EXTERN xdata _AT_(0xE69C) volatile BYTE EP8BCH ; // Endpoint 8 Byte Count H + +EXTERN xdata _AT_(0xE69D) volatile BYTE EP8BCL ; // Endpoint 8 Byte Count L + +EXTERN xdata _AT_(0xE6A0) volatile BYTE EP0CS ; // Endpoint Control and Status + +EXTERN xdata _AT_(0xE6A1) volatile BYTE EP1OUTCS ; // Endpoint 1 OUT Control and Status + +EXTERN xdata _AT_(0xE6A2) volatile BYTE EP1INCS ; // Endpoint 1 IN Control and Status + +EXTERN xdata _AT_(0xE6A3) volatile BYTE EP2CS ; // Endpoint 2 Control and Status + +EXTERN xdata _AT_(0xE6A4) volatile BYTE EP4CS ; // Endpoint 4 Control and Status + +EXTERN xdata _AT_(0xE6A5) volatile BYTE EP6CS ; // Endpoint 6 Control and Status + +EXTERN xdata _AT_(0xE6A6) volatile BYTE EP8CS ; // Endpoint 8 Control and Status + +EXTERN xdata _AT_(0xE6A7) volatile BYTE EP2FIFOFLGS ; // Endpoint 2 Flags + +EXTERN xdata _AT_(0xE6A8) volatile BYTE EP4FIFOFLGS ; // Endpoint 4 Flags + +EXTERN xdata _AT_(0xE6A9) volatile BYTE EP6FIFOFLGS ; // Endpoint 6 Flags + +EXTERN xdata _AT_(0xE6AA) volatile BYTE EP8FIFOFLGS ; // Endpoint 8 Flags + +EXTERN xdata _AT_(0xE6AB) volatile BYTE EP2FIFOBCH ; // EP2 FIFO total byte count H + +EXTERN xdata _AT_(0xE6AC) volatile BYTE EP2FIFOBCL ; // EP2 FIFO total byte count L + +EXTERN xdata _AT_(0xE6AD) volatile BYTE EP4FIFOBCH ; // EP4 FIFO total byte count H + +EXTERN xdata _AT_(0xE6AE) volatile BYTE EP4FIFOBCL ; // EP4 FIFO total byte count L + +EXTERN xdata _AT_(0xE6AF) volatile BYTE EP6FIFOBCH ; // EP6 FIFO total byte count H + +EXTERN xdata _AT_(0xE6B0) volatile BYTE EP6FIFOBCL ; // EP6 FIFO total byte count L + +EXTERN xdata _AT_(0xE6B1) volatile BYTE EP8FIFOBCH ; // EP8 FIFO total byte count H + +EXTERN xdata _AT_(0xE6B2) volatile BYTE EP8FIFOBCL ; // EP8 FIFO total byte count L + +EXTERN xdata _AT_(0xE6B3) volatile BYTE SUDPTRH ; // Setup Data Pointer high address byte + +EXTERN xdata _AT_(0xE6B4) volatile BYTE SUDPTRL ; // Setup Data Pointer low address byte + +EXTERN xdata _AT_(0xE6B5) volatile BYTE SUDPTRCTL ; // Setup Data Pointer Auto Mode + +EXTERN xdata _AT_(0xE6B8) volatile BYTE SETUPDAT[8] ; // 8 bytes of SETUP data + + + +// GPIF + + + +EXTERN xdata _AT_(0xE6C0) volatile BYTE GPIFWFSELECT ; // Waveform Selector + +EXTERN xdata _AT_(0xE6C1) volatile BYTE GPIFIDLECS ; // GPIF Done, GPIF IDLE drive mode + +EXTERN xdata _AT_(0xE6C2) volatile BYTE GPIFIDLECTL ; // Inactive Bus, CTL states + +EXTERN xdata _AT_(0xE6C3) volatile BYTE GPIFCTLCFG ; // CTL OUT pin drive + +EXTERN xdata _AT_(0xE6C4) volatile BYTE GPIFADRH ; // GPIF Address H + +EXTERN xdata _AT_(0xE6C5) volatile BYTE GPIFADRL ; // GPIF Address L + + + +EXTERN xdata _AT_(0xE6CE) volatile BYTE GPIFTCB3 ; // GPIF Transaction Count Byte 3 + +EXTERN xdata _AT_(0xE6CF) volatile BYTE GPIFTCB2 ; // GPIF Transaction Count Byte 2 + +EXTERN xdata _AT_(0xE6D0) volatile BYTE GPIFTCB1 ; // GPIF Transaction Count Byte 1 + +EXTERN xdata _AT_(0xE6D1) volatile BYTE GPIFTCB0 ; // GPIF Transaction Count Byte 0 + + + +#define EP2GPIFTCH GPIFTCB1 // these are here for backwards compatibility + +#define EP2GPIFTCL GPIFTCB0 // before REVE silicon (ie. REVB and REVD) + +#define EP4GPIFTCH GPIFTCB1 // these are here for backwards compatibility + +#define EP4GPIFTCL GPIFTCB0 // before REVE silicon (ie. REVB and REVD) + +#define EP6GPIFTCH GPIFTCB1 // these are here for backwards compatibility + +#define EP6GPIFTCL GPIFTCB0 // before REVE silicon (ie. REVB and REVD) + +#define EP8GPIFTCH GPIFTCB1 // these are here for backwards compatibility + +#define EP8GPIFTCL GPIFTCB0 // before REVE silicon (ie. REVB and REVD) + + + +// EXTERN xdata volatile BYTE EP2GPIFTCH _AT_ 0xE6D0; // EP2 GPIF Transaction Count High + +// EXTERN xdata volatile BYTE EP2GPIFTCL _AT_ 0xE6D1; // EP2 GPIF Transaction Count Low + +EXTERN xdata _AT_(0xE6D2) volatile BYTE EP2GPIFFLGSEL ; // EP2 GPIF Flag select + +EXTERN xdata _AT_(0xE6D3) volatile BYTE EP2GPIFPFSTOP ; // Stop GPIF EP2 transaction on prog. flag + +EXTERN xdata _AT_(0xE6D4) volatile BYTE EP2GPIFTRIG ; // EP2 FIFO Trigger + +// EXTERN xdata volatile BYTE EP4GPIFTCH _AT_ 0xE6D8; // EP4 GPIF Transaction Count High + +// EXTERN xdata volatile BYTE EP4GPIFTCL _AT_ 0xE6D9; // EP4 GPIF Transactionr Count Low + +EXTERN xdata _AT_(0xE6DA) volatile BYTE EP4GPIFFLGSEL ; // EP4 GPIF Flag select + +EXTERN xdata _AT_(0xE6DB) volatile BYTE EP4GPIFPFSTOP ; // Stop GPIF EP4 transaction on prog. flag + +EXTERN xdata _AT_(0xE6DC) volatile BYTE EP4GPIFTRIG ; // EP4 FIFO Trigger + +// EXTERN xdata volatile BYTE EP6GPIFTCH _AT_ 0xE6E0; // EP6 GPIF Transaction Count High + +// EXTERN xdata volatile BYTE EP6GPIFTCL _AT_ 0xE6E1; // EP6 GPIF Transaction Count Low + +EXTERN xdata _AT_(0xE6E2) volatile BYTE EP6GPIFFLGSEL ; // EP6 GPIF Flag select + +EXTERN xdata _AT_(0xE6E3) volatile BYTE EP6GPIFPFSTOP ; // Stop GPIF EP6 transaction on prog. flag + +EXTERN xdata _AT_(0xE6E4) volatile BYTE EP6GPIFTRIG ; // EP6 FIFO Trigger + +// EXTERN xdata volatile BYTE EP8GPIFTCH _AT_ 0xE6E8; // EP8 GPIF Transaction Count High + +// EXTERN xdata volatile BYTE EP8GPIFTCL _AT_ 0xE6E9; // EP8GPIF Transaction Count Low + +EXTERN xdata _AT_(0xE6EA) volatile BYTE EP8GPIFFLGSEL ; // EP8 GPIF Flag select + +EXTERN xdata _AT_(0xE6EB) volatile BYTE EP8GPIFPFSTOP ; // Stop GPIF EP8 transaction on prog. flag + +EXTERN xdata _AT_(0xE6EC) volatile BYTE EP8GPIFTRIG ; // EP8 FIFO Trigger + +EXTERN xdata _AT_(0xE6F0) volatile BYTE XGPIFSGLDATH ; // GPIF Data H (16-bit mode only) + +EXTERN xdata _AT_(0xE6F1) volatile BYTE XGPIFSGLDATLX ; // Read/Write GPIF Data L & trigger transac + +EXTERN xdata _AT_(0xE6F2) volatile BYTE XGPIFSGLDATLNOX ; // Read GPIF Data L, no transac trigger + +EXTERN xdata _AT_(0xE6F3) volatile BYTE GPIFREADYCFG ; // Internal RDY,Sync/Async, RDY5CFG + +EXTERN xdata _AT_(0xE6F4) volatile BYTE GPIFREADYSTAT ; // RDY pin states + +EXTERN xdata _AT_(0xE6F5) volatile BYTE GPIFABORT ; // Abort GPIF cycles + + + +// UDMA + + + +EXTERN xdata _AT_(0xE6C6) volatile BYTE FLOWSTATE ; //Defines GPIF flow state + +EXTERN xdata _AT_(0xE6C7) volatile BYTE FLOWLOGIC ; //Defines flow/hold decision criteria + +EXTERN xdata _AT_(0xE6C8) volatile BYTE FLOWEQ0CTL ; //CTL states during active flow state + +EXTERN xdata _AT_(0xE6C9) volatile BYTE FLOWEQ1CTL ; //CTL states during hold flow state + +EXTERN xdata _AT_(0xE6CA) volatile BYTE FLOWHOLDOFF ; + +EXTERN xdata _AT_(0xE6CB) volatile BYTE FLOWSTB ; //CTL/RDY Signal to use as master data strobe + +EXTERN xdata _AT_(0xE6CC) volatile BYTE FLOWSTBEDGE ; //Defines active master strobe edge + +EXTERN xdata _AT_(0xE6CD) volatile BYTE FLOWSTBHPERIOD ; //Half Period of output master strobe + +EXTERN xdata _AT_(0xE60C) volatile BYTE GPIFHOLDAMOUNT ; //Data delay shift + +EXTERN xdata _AT_(0xE67D) volatile BYTE UDMACRCH ; //CRC Upper byte + +EXTERN xdata _AT_(0xE67E) volatile BYTE UDMACRCL ; //CRC Lower byte + +EXTERN xdata _AT_(0xE67F) volatile BYTE UDMACRCQUAL ; //UDMA In only, host terminated use only + + + + + +// Debug/Test + + + +EXTERN xdata _AT_(0xE6F8) volatile BYTE DBUG ; // Debug + +EXTERN xdata _AT_(0xE6F9) volatile BYTE TESTCFG ; // Test configuration + +EXTERN xdata _AT_(0xE6FA) volatile BYTE USBTEST ; // USB Test Modes + +EXTERN xdata _AT_(0xE6FB) volatile BYTE CT1 ; // Chirp Test--Override + +EXTERN xdata _AT_(0xE6FC) volatile BYTE CT2 ; // Chirp Test--FSM + +EXTERN xdata _AT_(0xE6FD) volatile BYTE CT3 ; // Chirp Test--Control Signals + +EXTERN xdata _AT_(0xE6FE) volatile BYTE CT4 ; // Chirp Test--Inputs + + + +// Endpoint Buffers + + + +EXTERN xdata _AT_(0xE740) volatile BYTE EP0BUF[64] ; // EP0 IN-OUT buffer + +EXTERN xdata _AT_(0xE780) volatile BYTE EP1OUTBUF[64] ; // EP1-OUT buffer + +EXTERN xdata _AT_(0xE7C0) volatile BYTE EP1INBUF[64] ; // EP1-IN buffer + +EXTERN xdata _AT_(0xF000) volatile BYTE EP2FIFOBUF[1024] ; // 512/1024-byte EP2 buffer (IN or OUT) + +EXTERN xdata _AT_(0xF400) volatile BYTE EP4FIFOBUF[1024] ; // 512 byte EP4 buffer (IN or OUT) + +EXTERN xdata _AT_(0xF800) volatile BYTE EP6FIFOBUF[1024] ; // 512/1024-byte EP6 buffer (IN or OUT) + +EXTERN xdata _AT_(0xFC00) volatile BYTE EP8FIFOBUF[1024] ; // 512 byte EP8 buffer (IN or OUT) + + + +#undef EXTERN + +#undef _AT_ + + + +/*----------------------------------------------------------------------------- + + Special Function Registers (SFRs) + + The byte registers and bits defined in the following list are based + + on the Synopsis definition of the 8051 Special Function Registers for EZ-USB. + + If you modify the register definitions below, please regenerate the file + + "ezregs.inc" which includes the same basic information for assembly inclusion. + +-----------------------------------------------------------------------------*/ + + + +sfr at 0x80 IOA; + +sfr at 0x81 SP; + +sfr at 0x82 DPL; + +sfr at 0x83 DPH; + +sfr at 0x84 DPL1; + +sfr at 0x85 DPH1; + +sfr at 0x86 DPS; + + /* DPS */ + + sbit at 0x86+0 SEL; + +sfr at 0x87 PCON; /* PCON */ + + //sbit IDLE = 0x87+0; + + //sbit STOP = 0x87+1; + + //sbit GF0 = 0x87+2; + + //sbit GF1 = 0x87+3; + + //sbit SMOD0 = 0x87+7; + +sfr at 0x88 TCON; + + /* TCON */ + + sbit at 0x88+0 IT0; + + sbit at 0x88+1 IE0; + + sbit at 0x88+2 IT1; + + sbit at 0x88+3 IE1; + + sbit at 0x88+4 TR0; + + sbit at 0x88+5 TF0; + + sbit at 0x88+6 TR1; + + sbit at 0x88+7 TF1; + +sfr at 0x89 TMOD; + + /* TMOD */ + + //sbit M00 = 0x89+0; + + //sbit M10 = 0x89+1; + + //sbit CT0 = 0x89+2; + + //sbit GATE0 = 0x89+3; + + //sbit M01 = 0x89+4; + + //sbit M11 = 0x89+5; + + //sbit CT1 = 0x89+6; + + //sbit GATE1 = 0x89+7; + +sfr at 0x8A TL0; + +sfr at 0x8B TL1; + +sfr at 0x8C TH0; + +sfr at 0x8D TH1; + +sfr at 0x8E CKCON; + + /* CKCON */ + + //sbit MD0 = 0x89+0; + + //sbit MD1 = 0x89+1; + + //sbit MD2 = 0x89+2; + + //sbit T0M = 0x89+3; + + //sbit T1M = 0x89+4; + + //sbit T2M = 0x89+5; + +// sfr at 0x8F SPC_FNC; // Was WRS in Reg320 + + /* CKCON */ + + //sbit WRS = 0x8F+0; + +sfr at 0x90 IOB; + +sfr at 0x91 EXIF; // EXIF Bit Values differ from Reg320 + + /* EXIF */ + + //sbit USBINT = 0x91+4; + + //sbit I2CINT = 0x91+5; + + //sbit IE4 = 0x91+6; + + //sbit IE5 = 0x91+7; + +sfr at 0x92 MPAGE; + +sfr at 0x98 SCON0; + + /* SCON0 */ + + sbit at 0x98+0 RI; + + sbit at 0x98+1 TI; + + sbit at 0x98+2 RB8; + + sbit at 0x98+3 TB8; + + sbit at 0x98+4 REN; + + sbit at 0x98+5 SM2; + + sbit at 0x98+6 SM1; + + sbit at 0x98+7 SM0; + +sfr at 0x99 SBUF0; + + + +sfr at 0x9A APTR1H; + +sfr at 0x9B APTR1L; + +sfr at 0x9C AUTODAT1; + +sfr at 0x9D AUTOPTRH2; + +sfr at 0x9E AUTOPTRL2; + +sfr at 0x9F AUTODAT2; + +sfr at 0xA0 IOC; + +sfr at 0xA1 INT2CLR; + +sfr at 0xA2 INT4CLR; + + + +#define AUTOPTRH1 APTR1H + +#define AUTOPTRL1 APTR1L + + + +sfr at 0xA8 IE; + + /* IE */ + + sbit at 0xA8+0 EX0; + + sbit at 0xA8+1 ET0; + + sbit at 0xA8+2 EX1; + + sbit at 0xA8+3 ET1; + + sbit at 0xA8+4 ES0; + + sbit at 0xA8+5 ET2; + + sbit at 0xA8+6 ES1; + + sbit at 0xA8+7 EA; + + + +sfr at 0xAA EP2468STAT; + + /* EP2468STAT */ + + //sbit EP2E = 0xAA+0; + + //sbit EP2F = 0xAA+1; + + //sbit EP4E = 0xAA+2; + + //sbit EP4F = 0xAA+3; + + //sbit EP6E = 0xAA+4; + + //sbit EP6F = 0xAA+5; + + //sbit EP8E = 0xAA+6; + + //sbit EP8F = 0xAA+7; + + + +sfr at 0xAB EP24FIFOFLGS; + +sfr at 0xAC EP68FIFOFLGS; + +sfr at 0xAF AUTOPTRSETUP; + + /* AUTOPTRSETUP */ + + sbit at 0xAF+0 EXTACC; + + sbit at 0xAF+1 APTR1FZ; + + sbit at 0xAF+2 APTR2FZ; + + + +sfr at 0xB0 IOD; + +sfr at 0xB1 IOE; + +sfr at 0xB2 OEA; + +sfr at 0xB3 OEB; + +sfr at 0xB4 OEC; + +sfr at 0xB5 OED; + +sfr at 0xB6 OEE; + + + +sfr at 0xB8 IP; + + /* IP */ + + sbit at 0xB8+0 PX0; + + sbit at 0xB8+1 PT0; + + sbit at 0xB8+2 PX1; + + sbit at 0xB8+3 PT1; + + sbit at 0xB8+4 PS0; + + sbit at 0xB8+5 PT2; + + sbit at 0xB8+6 PS1; + + + +sfr at 0xBA EP01STAT; + +sfr at 0xBB GPIFTRIG; + + + +sfr at 0xBD GPIFSGLDATH; + +sfr at 0xBE GPIFSGLDATLX; + +sfr at 0xBF GPIFSGLDATLNOX; + + + +sfr at 0xC0 SCON1; + + /* SCON1 */ + + sbit at 0xC0+0 RI1; + + sbit at 0xC0+1 TI1; + + sbit at 0xC0+2 RB81; + + sbit at 0xC0+3 TB81; + + sbit at 0xC0+4 REN1; + + sbit at 0xC0+5 SM21; + + sbit at 0xC0+6 SM11; + + sbit at 0xC0+7 SM01; + +sfr at 0xC1 SBUF1; + +sfr at 0xC8 T2CON; + + /* T2CON */ + + sbit at 0xC8+0 CP_RL2; + + sbit at 0xC8+1 C_T2; + + sbit at 0xC8+2 TR2; + + sbit at 0xC8+3 EXEN2; + + sbit at 0xC8+4 TCLK; + + sbit at 0xC8+5 RCLK; + + sbit at 0xC8+6 EXF2; + + sbit at 0xC8+7 TF2; + +sfr at 0xCA RCAP2L; + +sfr at 0xCB RCAP2H; + +sfr at 0xCC TL2; + +sfr at 0xCD TH2; + +sfr at 0xD0 PSW; + + /* PSW */ + + sbit at 0xD0+0 P; + + sbit at 0xD0+1 FL; + + sbit at 0xD0+2 OV; + + sbit at 0xD0+3 RS0; + + sbit at 0xD0+4 RS1; + + sbit at 0xD0+5 F0; + + sbit at 0xD0+6 AC; + + sbit at 0xD0+7 CY; + +sfr at 0xD8 EICON; // Was WDCON in DS80C320 EICON; Bit Values differ from Reg320 + + /* EICON */ + + sbit at 0xD8+3 INT6; + + sbit at 0xD8+4 RESI; + + sbit at 0xD8+5 ERESI; + + sbit at 0xD8+7 SMOD1; + +sfr at 0xE0 ACC; + +sfr at 0xE8 EIE; // EIE Bit Values differ from Reg320 + + /* EIE */ + + sbit at 0xE8+0 EIUSB; + + sbit at 0xE8+1 EI2C; + + sbit at 0xE8+2 EIEX4; + + sbit at 0xE8+3 EIEX5; + + sbit at 0xE8+4 EIEX6; + +sfr at 0xF0 B; + +sfr at 0xF8 EIP; // EIP Bit Values differ from Reg320 + + /* EIP */ + + sbit at 0xF8+0 PUSB; + + sbit at 0xF8+1 PI2C; + + sbit at 0xF8+2 EIPX4; + + sbit at 0xF8+3 EIPX5; + + sbit at 0xF8+4 EIPX6; + + + +/*----------------------------------------------------------------------------- + + Bit Masks + +-----------------------------------------------------------------------------*/ + + + +#define bmBIT0 1 + +#define bmBIT1 2 + +#define bmBIT2 4 + +#define bmBIT3 8 + +#define bmBIT4 16 + +#define bmBIT5 32 + +#define bmBIT6 64 + +#define bmBIT7 128 + + + +/* CPU Control & Status Register (CPUCS) */ + +#define bmPRTCSTB bmBIT5 + +#define bmCLKSPD (bmBIT4 | bmBIT3) + +#define bmCLKSPD1 bmBIT4 + +#define bmCLKSPD0 bmBIT3 + +#define bmCLKINV bmBIT2 + +#define bmCLKOE bmBIT1 + +#define bm8051RES bmBIT0 + +/* Port Alternate Configuration Registers */ + +/* Port A (PORTACFG) */ + +#define bmFLAGD bmBIT7 + +#define bmINT1 bmBIT1 + +#define bmINT0 bmBIT0 + +/* Port C (PORTCCFG) */ + +#define bmGPIFA7 bmBIT7 + +#define bmGPIFA6 bmBIT6 + +#define bmGPIFA5 bmBIT5 + +#define bmGPIFA4 bmBIT4 + +#define bmGPIFA3 bmBIT3 + +#define bmGPIFA2 bmBIT2 + +#define bmGPIFA1 bmBIT1 + +#define bmGPIFA0 bmBIT0 + +/* Port E (PORTECFG) */ + +#define bmGPIFA8 bmBIT7 + +#define bmT2EX bmBIT6 + +#define bmINT6 bmBIT5 + +#define bmRXD1OUT bmBIT4 + +#define bmRXD0OUT bmBIT3 + +#define bmT2OUT bmBIT2 + +#define bmT1OUT bmBIT1 + +#define bmT0OUT bmBIT0 + + + +/* I2C Control & Status Register (I2CS) */ + +#define bmSTART bmBIT7 + +#define bmSTOP bmBIT6 + +#define bmLASTRD bmBIT5 + +#define bmID (bmBIT4 | bmBIT3) + +#define bmBERR bmBIT2 + +#define bmACK bmBIT1 + +#define bmDONE bmBIT0 + +/* I2C Control Register (I2CTL) */ + +#define bmSTOPIE bmBIT1 + +#define bm400KHZ bmBIT0 + +/* Interrupt 2 (USB) Autovector Register (INT2IVEC) */ + +#define bmIV4 bmBIT6 + +#define bmIV3 bmBIT5 + +#define bmIV2 bmBIT4 + +#define bmIV1 bmBIT3 + +#define bmIV0 bmBIT2 + +/* USB Interrupt Request & Enable Registers (USBIE/USBIRQ) */ + +#define bmEP0ACK bmBIT6 + +#define bmHSGRANT bmBIT5 + +#define bmURES bmBIT4 + +#define bmSUSP bmBIT3 + +#define bmSUTOK bmBIT2 + +#define bmSOF bmBIT1 + +#define bmSUDAV bmBIT0 + +/* Breakpoint register (BREAKPT) */ + +#define bmBREAK bmBIT3 + +#define bmBPPULSE bmBIT2 + +#define bmBPEN bmBIT1 + +/* Interrupt 2 & 4 Setup (INTSETUP) */ + +#define bmAV2EN bmBIT3 + +#define bmINT4IN bmBIT1 + +#define bmAV4EN bmBIT0 + +/* USB Control & Status Register (USBCS) */ + +#define bmHSM bmBIT7 + +#define bmDISCON bmBIT3 + +#define bmNOSYNSOF bmBIT2 + +#define bmRENUM bmBIT1 + +#define bmSIGRESUME bmBIT0 + +/* Wakeup Control and Status Register (WAKEUPCS) */ + +#define bmWU2 bmBIT7 + +#define bmWU bmBIT6 + +#define bmWU2POL bmBIT5 + +#define bmWUPOL bmBIT4 + +#define bmDPEN bmBIT2 + +#define bmWU2EN bmBIT1 + +#define bmWUEN bmBIT0 + +/* End Point 0 Control & Status Register (EP0CS) */ + +#define bmHSNAK bmBIT7 + +/* End Point 0-1 Control & Status Registers (EP0CS/EP1OUTCS/EP1INCS) */ + +#define bmEPBUSY bmBIT1 + +#define bmEPSTALL bmBIT0 + +/* End Point 2-8 Control & Status Registers (EP2CS/EP4CS/EP6CS/EP8CS) */ + +#define bmNPAK (bmBIT6 | bmBIT5 | bmBIT4) + +#define bmEPFULL bmBIT3 + +#define bmEPEMPTY bmBIT2 + +/* Endpoint Status (EP2468STAT) SFR bits */ + +#define bmEP8FULL bmBIT7 + +#define bmEP8EMPTY bmBIT6 + +#define bmEP6FULL bmBIT5 + +#define bmEP6EMPTY bmBIT4 + +#define bmEP4FULL bmBIT3 + +#define bmEP4EMPTY bmBIT2 + +#define bmEP2FULL bmBIT1 + +#define bmEP2EMPTY bmBIT0 + +/* SETUP Data Pointer Auto Mode (SUDPTRCTL) */ + +#define bmSDPAUTO bmBIT0 + +/* Endpoint Data Toggle Control (TOGCTL) */ + +#define bmQUERYTOGGLE bmBIT7 + +#define bmSETTOGGLE bmBIT6 + +#define bmRESETTOGGLE bmBIT5 + +#define bmTOGCTLEPMASK bmBIT3 | bmBIT2 | bmBIT1 | bmBIT0 + +/* IBN (In Bulk Nak) enable and request bits (IBNIE/IBNIRQ) */ + +#define bmEP8IBN bmBIT5 + +#define bmEP6IBN bmBIT4 + +#define bmEP4IBN bmBIT3 + +#define bmEP2IBN bmBIT2 + +#define bmEP1IBN bmBIT1 + +#define bmEP0IBN bmBIT0 + + + +/* PING-NAK enable and request bits (NAKIE/NAKIRQ) */ + +#define bmEP8PING bmBIT7 + +#define bmEP6PING bmBIT6 + +#define bmEP4PING bmBIT5 + +#define bmEP2PING bmBIT4 + +#define bmEP1PING bmBIT3 + +#define bmEP0PING bmBIT2 + +#define bmIBN bmBIT0 + + + +/* Interface Configuration bits (IFCONFIG) */ + +#define bmIFCLKSRC bmBIT7 // set == INTERNAL + +#define bm3048MHZ bmBIT6 // set == 48 MHz + +#define bmIFCLKOE bmBIT5 + +#define bmIFCLKPOL bmBIT4 + +#define bmASYNC bmBIT3 + +#define bmGSTATE bmBIT2 + +#define bmIFCFG1 bmBIT1 + +#define bmIFCFG0 bmBIT0 + +#define bmIFCFGMASK (bmIFCFG0 | bmIFCFG1) + +#define bmIFGPIF bmIFCFG1 + + + +/* EP 2468 FIFO Configuration bits (EP2FIFOCFG,EP4FIFOCFG,EP6FIFOCFG,EP8FIFOCFG) */ + +#define bmINFM bmBIT6 + +#define bmOEP bmBIT5 + +#define bmAUTOOUT bmBIT4 + +#define bmAUTOIN bmBIT3 + +#define bmZEROLENIN bmBIT2 + +// must be zero bmBIT1 + +#define bmWORDWIDE bmBIT0 + + + +/* + + * Chip Revision Control Bits (REVCTL) - used to ebable/disable revision specific features + + */ + +#define bmNOAUTOARM bmBIT1 // these don't match the docs + +#define bmSKIPCOMMIT bmBIT0 // these don't match the docs + + + +#define bmDYN_OUT bmBIT1 // these do... + +#define bmENH_PKT bmBIT0 + + + + + +/* Fifo Reset bits (FIFORESET) */ + +#define bmNAKALL bmBIT7 + + + +/* Endpoint Configuration (EPxCFG) */ + +#define bmVALID bmBIT7 + +#define bmIN bmBIT6 + +#define bmTYPE1 bmBIT5 + +#define bmTYPE0 bmBIT4 + +#define bmISOCHRONOUS bmTYPE0 + +#define bmBULK bmTYPE1 + +#define bmINTERRUPT (bmTYPE1 | bmTYPE0) + +#define bm1KBUF bmBIT3 + +#define bmBUF1 bmBIT1 + +#define bmBUF0 bmBIT0 + +#define bmQUADBUF 0 + +#define bmINVALIDBUF bmBUF0 + +#define bmDOUBLEBUF bmBUF1 + +#define bmTRIPLEBUF (bmBUF1 | bmBUF0) + + + +/* OUTPKTEND */ + +#define bmSKIP bmBIT7 // low 4 bits specify which end point + + + +/* GPIFTRIG defs */ + +#define bmGPIF_IDLE bmBIT7 // status bit + + + +#define bmGPIF_EP2_START 0 + +#define bmGPIF_EP4_START 1 + +#define bmGPIF_EP6_START 2 + +#define bmGPIF_EP8_START 3 + +#define bmGPIF_READ bmBIT2 + +#define bmGPIF_WRITE 0 + + + +/* EXIF bits */ + +#define bmEXIF_USBINT bmBIT4 + +#define bmEXIF_I2CINT bmBIT5 + +#define bmEXIF_IE4 bmBIT6 + +#define bmEXIF_IE5 bmBIT7 + + + + + +#endif /* FX2REGS_H */ + diff --git a/fx2/fx2utils.c b/fx2/fx2utils.c new file mode 100644 index 0000000..b6797cc --- /dev/null +++ b/fx2/fx2utils.c @@ -0,0 +1,104 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * FX2 specific subroutines + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#include "fx2utils.h" + +#include "fx2regs.h" + +#include "delay.h" + + + +void + +fx2_stall_ep0 (void) + +{ + + EP0CS |= bmEPSTALL; + +} + + + +void + +fx2_reset_data_toggle (unsigned char ep) + +{ + + TOGCTL = ((ep & 0x80) >> 3 | (ep & 0x0f)); + + TOGCTL |= bmRESETTOGGLE; + +} + + + +void + +fx2_renumerate (void) + +{ + + USBCS |= bmDISCON | bmRENUM; + + + + // mdelay (1500); // FIXME why 1.5 seconds? + + mdelay (250); // FIXME why 1.5 seconds? + + + + USBIRQ = 0xff; // clear any pending USB irqs... + + EPIRQ = 0xff; // they're from before the renumeration + + + + EXIF &= ~bmEXIF_USBINT; + + + + USBCS &= ~bmDISCON; // reconnect USB + +} + diff --git a/fx2/fx2utils.h b/fx2/fx2utils.h new file mode 100644 index 0000000..54c61df --- /dev/null +++ b/fx2/fx2utils.h @@ -0,0 +1,60 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * FX2 specific subroutines + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#ifndef _FX2UTILS_H_ + +#define _FX2UTILS_H_ + + + +void fx2_stall_ep0 (void); + +void fx2_reset_data_toggle (unsigned char ep); + +void fx2_renumerate (void); + + + + + + + +#endif /* _FX2UTILS_H_ */ + diff --git a/fx2/i2c.c b/fx2/i2c.c new file mode 100644 index 0000000..99ed1f7 --- /dev/null +++ b/fx2/i2c.c @@ -0,0 +1,242 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * I2C read/write functions for FX2 + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#include "i2c.h" + +#include "fx2regs.h" + +#include + + + + + +// issue a stop bus cycle and wait for completion + + + + + +// returns non-zero if successful, else 0 + +unsigned char + +i2c_read (unsigned char addr, xdata unsigned char *buf, unsigned char len) + +{ + + volatile unsigned char junk; + + + + if (len == 0) // reading zero bytes always works + + return 1; + + + + while (I2CS & bmSTOP) // wait for stop to clear + + ; + + + + I2CS = bmSTART; + + I2DAT = (addr << 1) | 1; // write address and direction (1's the read bit) + + + + while ((I2CS & bmDONE) == 0) + + ; + + + + if ((I2CS & bmBERR) || (I2CS & bmACK) == 0) // no device answered... + + goto fail; + + + + if (len == 1) + + I2CS |= bmLASTRD; + + + + junk = I2DAT; // trigger the first read cycle + + + + while (--len != 0){ + + while ((I2CS & bmDONE) == 0) + + ; + + + + if (I2CS & bmBERR) + + goto fail; + + + + if (len == 1) + + I2CS |= bmLASTRD; + + + + *buf++ = I2DAT; // get data, trigger another read + + } + + + + // wait for final byte + + + + while ((I2CS & bmDONE) == 0) + + ; + + + + if (I2CS & bmBERR) + + goto fail; + + + + I2CS |= bmSTOP; + + *buf = I2DAT; + + + + return 1; + + + + fail: + + I2CS |= bmSTOP; + + return 0; + +} + + + + + + + +// returns non-zero if successful, else 0 + +unsigned char + +i2c_write (unsigned char addr, xdata const unsigned char *buf, unsigned char len) + +{ + + while (I2CS & bmSTOP) // wait for stop to clear + + ; + + + + I2CS = bmSTART; + + I2DAT = (addr << 1) | 0; // write address and direction (0's the write bit) + + + + while ((I2CS & bmDONE) == 0) + + ; + + + + if ((I2CS & bmBERR) || (I2CS & bmACK) == 0) // no device answered... + + goto fail; + + + + while (len > 0){ + + I2DAT = *buf++; + + len--; + + + + while ((I2CS & bmDONE) == 0) + + ; + + + + if ((I2CS & bmBERR) || (I2CS & bmACK) == 0) // no device answered... + + goto fail; + + } + + + + I2CS |= bmSTOP; + + return 1; + + + + fail: + + I2CS |= bmSTOP; + + return 0; + +} + diff --git a/fx2/i2c.h b/fx2/i2c.h new file mode 100644 index 0000000..2be98ad --- /dev/null +++ b/fx2/i2c.h @@ -0,0 +1,60 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * I2C read/write functions for FX2 + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#ifndef _I2C_H_ + +#define _I2C_H_ + + + +// returns non-zero if successful, else 0 + +unsigned char i2c_read (unsigned char addr, xdata unsigned char *buf, unsigned char len); + + + +// returns non-zero if successful, else 0 + +unsigned char i2c_write (unsigned char addr, xdata const unsigned char *buf, unsigned char len); + + + +#endif /* _I2C_H_ */ + diff --git a/fx2/isr.c b/fx2/isr.c new file mode 100644 index 0000000..f92a064 --- /dev/null +++ b/fx2/isr.c @@ -0,0 +1,336 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * Interrupt handling for FX2 + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#include "isr.h" + +#include "fx2regs.h" + +#include "syncdelay.h" + + + +extern xdata unsigned char _standard_interrupt_vector[]; + +extern xdata unsigned char _usb_autovector[]; + +extern xdata unsigned char _fifo_gpif_autovector[]; + + + +#define LJMP_OPCODE 0x02 + + + +/* + + * Hook standard interrupt vector. + + * + + * vector_number is from the SV_ list. + + * addr is the address of the interrupt service routine. + + */ + +void + +hook_sv (unsigned char vector_number, unsigned short addr) + +{ + + bit t; + + + + // sanity checks + + + + if (vector_number < SV_MIN || vector_number > SV_MAX) + + return; + + + + if ((vector_number & 0x0f) != 0x03 && (vector_number & 0x0f) != 0x0b) + + return; + + + + t = EA; + + EA = 0; + + _standard_interrupt_vector[vector_number] = LJMP_OPCODE; + + _standard_interrupt_vector[vector_number + 1] = addr >> 8; + + _standard_interrupt_vector[vector_number + 2] = addr & 0xff; + + EA = t; + +} + + + +/* + + * Hook usb interrupt vector. + + * + + * vector_number is from the UV_ list. + + * addr is the address of the interrupt service routine. + + */ + +void + +hook_uv (unsigned char vector_number, unsigned short addr) + +{ + + bit t; + + + + // sanity checks + + + +#if UV_MIN>0 + + if (vector_number < UV_MIN) return; + +#endif + + if (vector_number > UV_MAX) + + return; + + + + if ((vector_number & 0x3) != 0) + + return; + + + + t = EA; + + EA = 0; + + _usb_autovector[vector_number] = LJMP_OPCODE; + + _usb_autovector[vector_number + 1] = addr >> 8; + + _usb_autovector[vector_number + 2] = addr & 0xff; + + EA = t; + +} + + + +/* + + * Hook fifo/gpif interrupt vector. + + * + + * vector_number is from the FGV_ list. + + * addr is the address of the interrupt service routine. + + */ + +void + +hook_fgv (unsigned char vector_number, unsigned short addr) + +{ + + bit t; + + + + // sanity checks + + + + if (vector_number < FGV_MIN || vector_number > FGV_MAX) + + return; + + + + if ((vector_number & 0x3) != 0) + + return; + + + + t = EA; + + EA = 0; + + _fifo_gpif_autovector[vector_number] = LJMP_OPCODE; + + _fifo_gpif_autovector[vector_number + 1] = addr >> 8; + + _fifo_gpif_autovector[vector_number + 2] = addr & 0xff; + + EA = t; + +} + + + +/* + + * One time call to enable autovectoring for both USB and FIFO/GPIF. + + * + + * This disables all USB and FIFO/GPIF interrupts and clears + + * any pending interrupts too. It leaves the master USB and FIFO/GPIF + + * interrupts enabled. + + */ + +void + +setup_autovectors (void) + +{ + + // disable master usb and fifo/gpif interrupt enables + + EIUSB = 0; + + EIEX4 = 0; + + + + hook_sv (SV_INT_2, (unsigned short) _usb_autovector); + + hook_sv (SV_INT_4, (unsigned short) _fifo_gpif_autovector); + + + + // disable all fifo interrupt enables + + SYNCDELAY; + + EP2FIFOIE = 0; SYNCDELAY; + + EP4FIFOIE = 0; SYNCDELAY; + + EP6FIFOIE = 0; SYNCDELAY; + + EP8FIFOIE = 0; SYNCDELAY; + + + + // clear all pending fifo irqs + + EP2FIFOIRQ = 0xff; SYNCDELAY; + + EP4FIFOIRQ = 0xff; SYNCDELAY; + + EP6FIFOIRQ = 0xff; SYNCDELAY; + + EP8FIFOIRQ = 0xff; SYNCDELAY; + + + + IBNIE = 0; + + IBNIRQ = 0xff; + + NAKIE = 0; + + NAKIRQ = 0xff; + + USBIE = 0; + + USBIRQ = 0xff; + + EPIE = 0; + + EPIRQ = 0xff; + + SYNCDELAY; GPIFIE = 0; + + SYNCDELAY; GPIFIRQ = 0xff; + + USBERRIE = 0; + + USBERRIRQ = 0xff; + + CLRERRCNT = 0; + + + + INTSETUP = bmAV2EN | bmAV4EN | bmINT4IN; + + + + // clear master irq's for usb and fifo/gpif + + EXIF &= ~bmEXIF_USBINT; + + EXIF &= ~bmEXIF_IE4; + + + + // enable master usb and fifo/gpif interrrupts + + EIUSB = 1; + + EIEX4 = 1; + +} + diff --git a/fx2/isr.h b/fx2/isr.h new file mode 100644 index 0000000..f51c97f --- /dev/null +++ b/fx2/isr.h @@ -0,0 +1,171 @@ +/* -*- c++ -*- */ +/*----------------------------------------------------------------------------- + * Interrupt handling for FX2 + *----------------------------------------------------------------------------- + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + * Copyright 2003 Free Software Foundation, Inc. + *----------------------------------------------------------------------------- + * This code is part of usbjtag. usbjtag is free software; you can redistribute + * it and/or modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. usbjtag is distributed in the hope + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. You should have received a + * copy of the GNU General Public License along with this program in the file + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + * St, Fifth Floor, Boston, MA 02110-1301 USA + *----------------------------------------------------------------------------- + */ + +#ifndef _ISR_H_ +#define _ISR_H_ + +/* + * ---------------------------------------------------------------- + * routines for managing interrupt services routines + * ---------------------------------------------------------------- + */ + +/* + * The FX2 has three discrete sets of interrupt vectors. + + * The first set is the standard 8051 vector (13 8-byte entries). + * The second set is USB interrupt autovector (32 4-byte entries). + * The third set is the FIFO/GPIF autovector (14 4-byte entries). + * + * Since all the code we're running in the FX2 is ram based, we + * forego the typical "initialize the interrupt vectors at link time" + * strategy, in favor of calls at run time that install the correct + * pointers to functions. + */ + +/* + * Standard Vector numbers + */ + +#define SV_INT_0 0x03 +#define SV_TIMER_0 0x0b +#define SV_INT_1 0x13 +#define SV_TIMER_1 0x1b +#define SV_SERIAL_0 0x23 +#define SV_TIMER_2 0x2b +#define SV_RESUME 0x33 +#define SV_SERIAL_1 0x3b +#define SV_INT_2 0x43 // (INT_2) points at USB autovector +#define SV_I2C 0x4b +#define SV_INT_4 0x53 // (INT_4) points at FIFO/GPIF autovector +#define SV_INT_5 0x5b +#define SV_INT_6 0x63 + +#define SV_MIN SV_INT_0 +#define SV_MAX SV_INT_6 + +/* + * USB Auto Vector numbers + */ + +#define UV_SUDAV 0x00 +#define UV_SOF 0x04 +#define UV_SUTOK 0x08 +#define UV_SUSPEND 0x0c +#define UV_USBRESET 0x10 +#define UV_HIGHSPEED 0x14 +#define UV_EP0ACK 0x18 +#define UV_SPARE_1C 0x1c +#define UV_EP0IN 0x20 +#define UV_EP0OUT 0x24 +#define UV_EP1IN 0x28 +#define UV_EP1OUT 0x2c +#define UV_EP2 0x30 +#define UV_EP4 0x34 +#define UV_EP6 0x38 +#define UV_EP8 0x3c +#define UV_IBN 0x40 +#define UV_SPARE_44 0x44 +#define UV_EP0PINGNAK 0x48 +#define UV_EP1PINGNAK 0x4c +#define UV_EP2PINGNAK 0x50 +#define UV_EP4PINGNAK 0x54 +#define UV_EP6PINGNAK 0x58 +#define UV_EP8PINGNAK 0x5c +#define UV_ERRLIMIT 0x60 +#define UV_SPARE_64 0x64 +#define UV_SPARE_68 0x68 +#define UV_SPARE_6C 0x6c +#define UV_EP2ISOERR 0x70 +#define UV_EP4ISOERR 0x74 +#define UV_EP6ISOERR 0x78 +#define UV_EP8ISOERR 0x7c + +#define UV_MIN UV_SUDAV +#define UV_MAX UV_EP8ISOERR + +/* + * FIFO/GPIF Auto Vector numbers + */ + +#define FGV_EP2PF 0x80 +#define FGV_EP4PF 0x84 +#define FGV_EP6PF 0x88 +#define FGV_EP8PF 0x8c +#define FGV_EP2EF 0x90 +#define FGV_EP4EF 0x94 +#define FGV_EP6EF 0x98 +#define FGV_EP8EF 0x9c +#define FGV_EP2FF 0xa0 +#define FGV_EP4FF 0xa4 +#define FGV_EP6FF 0xa8 +#define FGV_EP8FF 0xac +#define FGV_GPIFDONE 0xb0 +#define FGV_GPIFWF 0xb4 + +#define FGV_MIN FGV_EP2PF +#define FGV_MAX FGV_GPIFWF + + +/* + * Hook standard interrupt vector. + * + * vector_number is from the SV_ list above. + * addr is the address of the interrupt service routine. + */ +void hook_sv (unsigned char vector_number, unsigned short addr); + +/* + * Hook usb interrupt vector. + * + * vector_number is from the UV_ list above. + * addr is the address of the interrupt service routine. + */ +void hook_uv (unsigned char vector_number, unsigned short addr); + +/* + * Hook fifo/gpif interrupt vector. + * + * vector_number is from the FGV_ list above. + * addr is the address of the interrupt service routine. + */ +void hook_fgv (unsigned char vector_number, unsigned short addr); + +/* + * One time call to enable autovectoring for both USB and FIFO/GPIF + */ +void setup_autovectors (void); + + +/* + * Must be called in each usb interrupt handler + */ +#define clear_usb_irq() \ + EXIF &= ~bmEXIF_USBINT; \ + INT2CLR = 0 + +/* + * Must be calledin each fifo/gpif interrupt handler + */ +#define clear_fifo_gpif_irq() \ + EXIF &= ~bmEXIF_IE4; \ + INT4CLR = 0 + +#endif /* _ISR_H_ */ diff --git a/fx2/syncdelay.h b/fx2/syncdelay.h new file mode 100644 index 0000000..178f316 --- /dev/null +++ b/fx2/syncdelay.h @@ -0,0 +1,128 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * Synchronization delay for FX2 access to specific registers + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#ifndef _SYNCDELAY_H_ + +#define _SYNCDELAY_H_ + + + +/* + + * Magic delay required between access to certain xdata registers (TRM page 15-106). + + * For our configuration, 48 MHz FX2 / 48 MHz IFCLK, we need three cycles. Each + + * NOP is a single cycle.... + + * + + * From TRM page 15-105: + + * + + * Under certain conditions, some read and write access to the FX2 registers must + + * be separated by a "synchronization delay". The delay is necessary only under the + + * following conditions: + + * + + * - between a write to any register in the 0xE600 - 0xE6FF range and a write to one + + * of the registers listed below. + + * + + * - between a write to one of the registers listed below and a read from any register + + * in the 0xE600 - 0xE6FF range. + + * + + * Registers which require a synchronization delay: + + * + + * FIFORESET FIFOPINPOLAR + + * INPKTEND EPxBCH:L + + * EPxFIFOPFH:L EPxAUTOINLENH:L + + * EPxFIFOCFG EPxGPIFFLGSEL + + * PINFLAGSAB PINFLAGSCD + + * EPxFIFOIE EPxFIFOIRQ + + * GPIFIE GPIFIRQ + + * UDMACRCH:L GPIFADRH:L + + * GPIFTRIG EPxGPIFTRIG + + * OUTPKTEND REVCTL + + * GPIFTCB3 GPIFTCB2 + + * GPIFTCB1 GPIFTCB0 + + */ + + + +/* + + * FIXME ensure that the peep hole optimizer isn't screwing us + + */ + +#define SYNCDELAY _asm nop; nop; nop; _endasm + +#define NOP _asm nop; _endasm + + + + + +#endif /* _SYNCDELAY_H_ */ + diff --git a/fx2/timer.c b/fx2/timer.c new file mode 100644 index 0000000..44e46e8 --- /dev/null +++ b/fx2/timer.c @@ -0,0 +1,94 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * Timer handling for FX2 + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#include "timer.h" + +#include "fx2regs.h" + +#include "isr.h" + + + +/* + + * Arrange to have isr_tick_handler called at 100 Hz. + + * + + * The cpu clock is running at 48e6. The input to the timer + + * is 48e6 / 12 = 4e6. + + * + + * We arrange to have the timer overflow every 40000 clocks == 100 Hz + + */ + + + +#define RELOAD_VALUE ((unsigned short) -40000) + + + +void + +hook_timer_tick (unsigned short isr_tick_handler) + +{ + + ET2 = 0; // disable timer 2 interrupts + + hook_sv (SV_TIMER_2, isr_tick_handler); + + + + RCAP2H = RELOAD_VALUE >> 8; // setup the auto reload value + + RCAP2L = RELOAD_VALUE & 0xFF; + + + + T2CON = 0x04; // interrupt on overflow; reload; run + + ET2 = 1; // enable timer 2 interrupts + +} + diff --git a/fx2/timer.h b/fx2/timer.h new file mode 100644 index 0000000..69f3927 --- /dev/null +++ b/fx2/timer.h @@ -0,0 +1,65 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * Timer handling for FX2 + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#ifndef _TIMER_H_ + +#define _TIMER_H_ + + + +/* + + * Arrange to have isr_tick_handler called at 100 Hz + + */ + +void hook_timer_tick (unsigned short isr_tick_handler); + + + +#define clear_timer_irq() \ + TF2 = 0 /* clear overflow flag */ + + + + + +#endif /* _TIMER_H_ */ + diff --git a/fx2/usb_common.c b/fx2/usb_common.c new file mode 100644 index 0000000..8805e45 --- /dev/null +++ b/fx2/usb_common.c @@ -0,0 +1,752 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * Common USB code for FX2 + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#include "usb_common.h" + +#include "fx2regs.h" + +#include "syncdelay.h" + +#include "fx2utils.h" + +#include "isr.h" + +#include "usb_descriptors.h" + +#include "usb_requests.h" + + + +extern xdata char str0[]; + +extern xdata char str1[]; + +extern xdata char str2[]; + +extern xdata char str3[]; + +extern xdata char str4[]; + +extern xdata char str5[]; + + + +volatile bit _usb_got_SUDAV; + + + +unsigned char _usb_config = 0; + +unsigned char _usb_alt_setting = 0; // FIXME really 1/interface + + + +xdata unsigned char *current_device_descr; + +xdata unsigned char *current_devqual_descr; + +xdata unsigned char *current_config_descr; + +xdata unsigned char *other_config_descr; + + + +static void + +setup_descriptors (void) + +{ + + if (USBCS & bmHSM){ // high speed mode + + current_device_descr = high_speed_device_descr; + + current_devqual_descr = high_speed_devqual_descr; + + current_config_descr = high_speed_config_descr; + + other_config_descr = full_speed_config_descr; + + EP8AUTOINLENH = 0x02; SYNCDELAY; // Size in bytes of the IN data automatically commited (512 bytes here) + + EP8AUTOINLENL = 0x00; SYNCDELAY; // Can use signal PKTEND if you want to commit a shorter packet + + } + + else { + + current_device_descr = full_speed_device_descr; + + current_devqual_descr = full_speed_devqual_descr; + + current_config_descr = full_speed_config_descr; + + other_config_descr = high_speed_config_descr; + + EP8AUTOINLENH = 0x00; SYNCDELAY; // Size in bytes of the IN data automatically commited (64 bytes here) + + EP8AUTOINLENL = 0x40; SYNCDELAY; // Can use signal PKTEND if you want to commit a shorter packet + + } + + + + // whack the type fields + + // FIXME, may not be required. + + // current_config_descr[1] = DT_CONFIG; + + // other_config_descr[1] = DT_OTHER_SPEED; + +} + + + +static void + +isr_SUDAV (void) interrupt + +{ + + clear_usb_irq (); + + _usb_got_SUDAV = 1; + +} + + + +static void + +isr_USBRESET (void) interrupt + +{ + + clear_usb_irq (); + + setup_descriptors (); + +} + + + +static void + +isr_HIGHSPEED (void) interrupt + +{ + + clear_usb_irq (); + + setup_descriptors (); + +} + + + +void + +usb_install_handlers (void) + +{ + + setup_descriptors (); // ensure that they're set before use + + + + hook_uv (UV_SUDAV, (unsigned short) isr_SUDAV); + + hook_uv (UV_USBRESET, (unsigned short) isr_USBRESET); + + hook_uv (UV_HIGHSPEED, (unsigned short) isr_HIGHSPEED); + + + + USBIE = bmSUDAV | bmURES | bmHSGRANT; + +} + + + +// On the FX2 the only plausible endpoints are 0, 1, 2, 4, 6, 8 + +// This doesn't check to see that they're enabled + + + +unsigned char + +plausible_endpoint (unsigned char ep) + +{ + + ep &= ~0x80; // ignore direction bit + + + + if (ep > 8) + + return 0; + + + + if (ep == 1) + + return 1; + + + + return (ep & 0x1) == 0; // must be even + +} + + + +// return pointer to control and status register for endpoint. + +// only called with plausible_endpoints + + + +xdata volatile unsigned char * + +epcs (unsigned char ep) + +{ + + if (ep == 0x01) // ep1 has different in and out CS regs + + return EP1OUTCS; + + + + if (ep == 0x81) + + return EP1INCS; + + + + ep &= ~0x80; // ignore direction bit + + + + if (ep == 0x00) // ep0 + + return EP0CS; + + + + return EP2CS + (ep >> 1); // 2, 4, 6, 8 are consecutive + +} + + + +void + +usb_handle_setup_packet (void) + +{ + + _usb_got_SUDAV = 0; + + + + // handle the standard requests... + + + + switch (bRequestType & bmRT_TYPE_MASK){ + + + + case bmRT_TYPE_CLASS: + + case bmRT_TYPE_RESERVED: + + fx2_stall_ep0 (); // we don't handle these. indicate error + + break; + + + + case bmRT_TYPE_VENDOR: + + // call the application code. + + // If it handles the command it returns non-zero + + + + if (!app_vendor_cmd ()) + + fx2_stall_ep0 (); + + break; + + + + case bmRT_TYPE_STD: + + // these are the standard requests... + + + + if ((bRequestType & bmRT_DIR_MASK) == bmRT_DIR_IN){ + + + + //////////////////////////////////// + + // handle the IN requests + + //////////////////////////////////// + + + + switch (bRequest){ + + + + case RQ_GET_CONFIG: + + EP0BUF[0] = _usb_config; // FIXME app should handle + + EP0BCH = 0; + + EP0BCL = 1; + + break; + + + + // -------------------------------- + + + + case RQ_GET_INTERFACE: + + EP0BUF[0] = _usb_alt_setting; // FIXME app should handle + + EP0BCH = 0; + + EP0BCL = 1; + + break; + + + + // -------------------------------- + + + + case RQ_GET_DESCR: + + switch (wValueH){ + + + + case DT_DEVICE: + + SUDPTRH = MSB (current_device_descr); + + SUDPTRL = LSB (current_device_descr); + + break; + + + + case DT_DEVQUAL: + + SUDPTRH = MSB (current_devqual_descr); + + SUDPTRL = LSB (current_devqual_descr); + + break; + + + + case DT_CONFIG: + + if (0 && wValueL != 1) // FIXME only a single configuration + + fx2_stall_ep0 (); + + else { + + SUDPTRH = MSB (current_config_descr); + + SUDPTRL = LSB (current_config_descr); + + } + + break; + + + + case DT_OTHER_SPEED: + + if (0 && wValueL != 1) // FIXME only a single configuration + + fx2_stall_ep0 (); + + else { + + SUDPTRH = MSB (other_config_descr); + + SUDPTRL = LSB (other_config_descr); + + } + + break; + + + + case DT_STRING: + + if (wValueL >= nstring_descriptors) + + fx2_stall_ep0 (); + + else { + + xdata char *p = string_descriptors[wValueL]; + + SUDPTRH = MSB (p); + + SUDPTRL = LSB (p); + + } + + break; + + + + default: + + fx2_stall_ep0 (); // invalid request + + break; + + } + + break; + + + + // -------------------------------- + + + + case RQ_GET_STATUS: + + switch (bRequestType & bmRT_RECIP_MASK){ + + case bmRT_RECIP_DEVICE: + + EP0BUF[0] = 0; + + EP0BUF[1] = 0; + + EP0BCH = 0; + + EP0BCL = 2; + + break; + + + + case bmRT_RECIP_INTERFACE: + + EP0BUF[0] = 0; + + EP0BUF[1] = 0; + + EP0BCH = 0; + + EP0BCL = 2; + + break; + + + + case bmRT_RECIP_ENDPOINT: + + if (plausible_endpoint (wIndexL)){ + + EP0BUF[0] = *epcs (wIndexL) & bmEPSTALL; + + EP0BUF[1] = 0; + + EP0BCH = 0; + + EP0BCL = 2; + + } + + else + + fx2_stall_ep0 (); + + break; + + + + default: + + fx2_stall_ep0 (); + + break; + + } + + break; + + + + // -------------------------------- + + + + case RQ_SYNCH_FRAME: // not implemented + + default: + + fx2_stall_ep0 (); + + break; + + } + + } + + + + else { + + + + //////////////////////////////////// + + // handle the OUT requests + + //////////////////////////////////// + + + + switch (bRequest){ + + + + case RQ_SET_CONFIG: + + IOE &= ~(1 << 6); + + _usb_config = wValueL; // FIXME app should handle + + break; + + + + case RQ_SET_INTERFACE: + + _usb_alt_setting = wValueL; // FIXME app should handle + + break; + + + + // -------------------------------- + + + + case RQ_CLEAR_FEATURE: + + switch (bRequestType & bmRT_RECIP_MASK){ + + + + case bmRT_RECIP_DEVICE: + + switch (wValueL){ + + case FS_DEV_REMOTE_WAKEUP: + + default: + + fx2_stall_ep0 (); + + } + + break; + + + + case bmRT_RECIP_ENDPOINT: + + if (wValueL == FS_ENDPOINT_HALT && plausible_endpoint (wIndexL)){ + + *epcs (wIndexL) &= ~bmEPSTALL; + + fx2_reset_data_toggle (wIndexL); + + } + + else + + fx2_stall_ep0 (); + + break; + + + + default: + + fx2_stall_ep0 (); + + break; + + } + + break; + + + + // -------------------------------- + + + + case RQ_SET_FEATURE: + + switch (bRequestType & bmRT_RECIP_MASK){ + + + + case bmRT_RECIP_DEVICE: + + switch (wValueL){ + + case FS_TEST_MODE: + + // hardware handles this after we complete SETUP phase handshake + + break; + + + + case FS_DEV_REMOTE_WAKEUP: + + default: + + fx2_stall_ep0 (); + + break; + + } + + } + + break; + + + + case bmRT_RECIP_ENDPOINT: + + switch (wValueL){ + + case FS_ENDPOINT_HALT: + + if (plausible_endpoint (wIndexL)) + + *epcs (wIndexL) |= bmEPSTALL; + + else + + fx2_stall_ep0 (); + + break; + + + + default: + + fx2_stall_ep0 (); + + break; + + } + + break; + + + + // -------------------------------- + + + + case RQ_SET_ADDRESS: // handled by fx2 hardware + + case RQ_SET_DESCR: // not implemented + + default: + + fx2_stall_ep0 (); + + } + + + + } + + break; + + + + } // bmRT_TYPE_MASK + + + + // ack handshake phase of device request + + EP0CS |= bmHSNAK; + +} + diff --git a/fx2/usb_common.h b/fx2/usb_common.h new file mode 100644 index 0000000..b34e4b8 --- /dev/null +++ b/fx2/usb_common.h @@ -0,0 +1,100 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * Common USB code for FX2 + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#ifndef _USB_COMMON_H_ + +#define _USB_COMMON_H_ + + + +#define bRequestType SETUPDAT[0] + +#define bRequest SETUPDAT[1] + +#define wValueL SETUPDAT[2] + +#define wValueH SETUPDAT[3] + +#define wIndexL SETUPDAT[4] + +#define wIndexH SETUPDAT[5] + +#define wLengthL SETUPDAT[6] + +#define wLengthH SETUPDAT[7] + + + +#define MSB(x) (((unsigned short) x) >> 8) + +#define LSB(x) (((unsigned short) x) & 0xff) + + + +extern volatile bit _usb_got_SUDAV; + + + +// Provided by user application to report device status. + +// returns non-zero if it handled the command. + +unsigned char app_get_status (void); + +// Provided by user application to handle VENDOR commands. + +// returns non-zero if it handled the command. + +unsigned char app_vendor_cmd (void); + + + +void usb_install_handlers (void); + +void usb_handle_setup_packet (void); + + + +#define usb_setup_packet_avail() _usb_got_SUDAV + + + +#endif /* _USB_COMMON_H_ */ + diff --git a/fx2/usb_descriptors.h b/fx2/usb_descriptors.h new file mode 100644 index 0000000..f4a2faf --- /dev/null +++ b/fx2/usb_descriptors.h @@ -0,0 +1,76 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * USB descriptor references + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +extern xdata const char high_speed_device_descr[]; + +extern xdata const char high_speed_devqual_descr[]; + +extern xdata const char high_speed_config_descr[]; + + + +extern xdata const char full_speed_device_descr[]; + +extern xdata const char full_speed_devqual_descr[]; + +extern xdata const char full_speed_config_descr[]; + + + +extern xdata unsigned char nstring_descriptors; + +extern xdata char * xdata string_descriptors[]; + + + +/* + + * We patch these locations with info read from the usrp config eeprom + + */ + +extern xdata char usb_desc_hw_rev_binary_patch_location_0[]; + +extern xdata char usb_desc_hw_rev_binary_patch_location_1[]; + +extern xdata char usb_desc_hw_rev_ascii_patch_location_0[]; + +extern xdata char usb_desc_serial_number_ascii[]; + diff --git a/fx2/usb_requests.h b/fx2/usb_requests.h new file mode 100644 index 0000000..5af607f --- /dev/null +++ b/fx2/usb_requests.h @@ -0,0 +1,172 @@ +/* -*- c++ -*- */ + +/*----------------------------------------------------------------------------- + + * USB request definitions + + *----------------------------------------------------------------------------- + + * Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + + * Copyright 2003 Free Software Foundation, Inc. + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +// Standard USB requests. + +// These are contained in end point 0 setup packets + + + + + +#ifndef _USB_REQUESTS_H_ + +#define _USB_REQUESTS_H_ + + + +// format of bmRequestType byte + + + +#define bmRT_DIR_MASK (0x1 << 7) + +#define bmRT_DIR_IN (1 << 7) + +#define bmRT_DIR_OUT (0 << 7) + + + +#define bmRT_TYPE_MASK (0x3 << 5) + +#define bmRT_TYPE_STD (0 << 5) + +#define bmRT_TYPE_CLASS (1 << 5) + +#define bmRT_TYPE_VENDOR (2 << 5) + +#define bmRT_TYPE_RESERVED (3 << 5) + + + +#define bmRT_RECIP_MASK (0x1f << 0) + +#define bmRT_RECIP_DEVICE (0 << 0) + +#define bmRT_RECIP_INTERFACE (1 << 0) + +#define bmRT_RECIP_ENDPOINT (2 << 0) + +#define bmRT_RECIP_OTHER (3 << 0) + + + + + +// standard request codes (bRequest) + + + +#define RQ_GET_STATUS 0 + +#define RQ_CLEAR_FEATURE 1 + +#define RQ_RESERVED_2 2 + +#define RQ_SET_FEATURE 3 + +#define RQ_RESERVED_4 4 + +#define RQ_SET_ADDRESS 5 + +#define RQ_GET_DESCR 6 + +#define RQ_SET_DESCR 7 + +#define RQ_GET_CONFIG 8 + +#define RQ_SET_CONFIG 9 + +#define RQ_GET_INTERFACE 10 + +#define RQ_SET_INTERFACE 11 + +#define RQ_SYNCH_FRAME 12 + + + +// standard descriptor types + + + +#define DT_DEVICE 1 + +#define DT_CONFIG 2 + +#define DT_STRING 3 + +#define DT_INTERFACE 4 + +#define DT_ENDPOINT 5 + +#define DT_DEVQUAL 6 + +#define DT_OTHER_SPEED 7 + +#define DT_INTERFACE_POWER 8 + + + +// standard feature selectors + + + +#define FS_ENDPOINT_HALT 0 // recip: endpoint + +#define FS_DEV_REMOTE_WAKEUP 1 // recip: device + +#define FS_TEST_MODE 2 // recip: device + + + +// Get Status device attributes + + + +#define bmGSDA_SELF_POWERED 0x01 + +#define bmGSDA_REM_WAKEUP 0x02 + + + + + +#endif /* _USB_REQUESTS_H_ */ + diff --git a/hardware.h b/hardware.h new file mode 100644 index 0000000..59f29e6 --- /dev/null +++ b/hardware.h @@ -0,0 +1,68 @@ +/*----------------------------------------------------------------------------- + + * Hardware-dependent code for usb_jtag + + *----------------------------------------------------------------------------- + + * Copyright (C) 2007 Kolja Waschk, ixo.de + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#ifndef _HARDWARE_H + +#define _HARDWARE_H 1 + + + +extern void ProgIO_Init(void); + +extern void ProgIO_Poll(void); + +extern void ProgIO_Enable(void); + +extern void ProgIO_Disable(void); + +extern void ProgIO_Deinit(void); + + + +extern void ProgIO_Set_State(unsigned char d); + +extern unsigned char ProgIO_Set_Get_State(unsigned char d); + +extern void ProgIO_ShiftOut(unsigned char x); + +extern unsigned char ProgIO_ShiftInOut(unsigned char x); + + + +#endif /* _HARDWARE_H */ + + + diff --git a/hw_basic.c b/hw_basic.c new file mode 100644 index 0000000..2014fbe --- /dev/null +++ b/hw_basic.c @@ -0,0 +1,443 @@ +/*----------------------------------------------------------------------------- + * Hardware-dependent code for usb_jtag + *----------------------------------------------------------------------------- + * Copyright (C) 2007 Kolja Waschk, ixo.de + *----------------------------------------------------------------------------- + * This code is part of usbjtag. usbjtag is free software; you can redistribute + * it and/or modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. usbjtag is distributed in the hope + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. You should have received a + * copy of the GNU General Public License along with this program in the file + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + * St, Fifth Floor, Boston, MA 02110-1301 USA + *----------------------------------------------------------------------------- + */ + +#include +#include "hardware.h" +#include "delay.h" + +//----------------------------------------------------------------------------- + +#define HAVE_PS_MODE 1 +#define HAVE_AS_MODE 1 +#define HAVE_OE_LED 1 + +//----------------------------------------------------------------------------- + +/* JTAG TCK, AS/PS DCLK */ + +sbit at 0xA2 TCK; /* Port C.0 */ +#define bmTCKOE bmBIT2 +#define SetTCK(x) do{TCK=(x);}while(0) + +/* JTAG TDI, AS ASDI, PS DATA0 */ + +sbit at 0xA0 TDI; /* Port C.2 */ +#define bmTDIOE bmBIT0 +#define SetTDI(x) do{TDI=(x);}while(0) + +/* JTAG TMS, AS/PS nCONFIG */ + +sbit at 0xA3 TMS; /* Port C.3 */ +#define bmTMSOE bmBIT3 +#define SetTMS(x) do{TMS=(x);}while(0) + +/* JTAG TDO, AS/PS CONF_DONE */ + +sbit at 0xA1 TDO; /* Port C.1 */ +#define bmTDOOE bmBIT1 +#define GetTDO(x) TDO + +/* JTAG ENABLE */ +sbit JTAG_EN = 0xA0+7; +#define bmJTAG_EN bmBIT7 + +//----------------------------------------------------------------------------- + +#if defined(HAVE_PS_MODE) || defined(HAVE_AS_MODE) + + /* AS DATAOUT, PS nSTATUS */ + + sbit at 0xA6 ASDO; /* Port C.6 */ + #define bmASDOOE bmBIT6 + #define GetASDO(x) ASDO + +#else + + #define bmASDOOE 0 + #define GetASDO(x) 0 + +#endif + +//----------------------------------------------------------------------------- + +#if defined(HAVE_AS_MODE) + + /* AS Mode nCS */ + + sbit at 0xA4 NCS; /* Port C.4 */ + #define bmNCSOE bmBIT4 + #define SetNCS(x) do{NCS=(x);}while(0) + #define GetNCS(x) NCS + + /* AS Mode nCE */ + + sbit at 0xA5 NCE; /* Port C.5 */ + #define bmNCEOE bmBIT5 + #define SetNCE(x) do{NCE=(x);}while(0) + + unsigned char ProgIO_ShiftInOut_AS(unsigned char x); + +#else + + #define bmNCSOE 0 + #define SetNCS(x) while(0){} + #define GetNCS(x) 1 + #define bmNCEOE 0 + #define SetNCE(x) while(0){} + + #define ProgIO_ShiftInOut_AS(x) ProgIO_ShiftInOut(x) + +#endif + +//----------------------------------------------------------------------------- + +#ifdef HAVE_OE_LED + + sbit at 0xA7 OELED; /* Port C.7 */ + #define bmOELEDOE bmBIT7 + #define SetOELED(x) do{OELED=(x);}while(0) + +#else + + #define bmOELEDOE 0 + #define SetOELED(x) while(0){} + +#endif + +//----------------------------------------------------------------------------- + +#define bmPROGOUTOE (bmTCKOE|bmTDIOE|bmTMSOE|bmNCEOE|bmNCSOE|bmOELEDOE) +#define bmPROGINOE (bmTDOOE|bmASDOOE) + +//----------------------------------------------------------------------------- + +void ProgIO_Poll(void) {} +// These aren't called anywhere in usbjtag.c, but I plan to do so... +void ProgIO_Enable(void) {} +void ProgIO_Disable(void) {} +void ProgIO_Deinit(void) {} + + +void ProgIO_Init(void) +{ + /* The following code depends on your actual circuit design. + Make required changes _before_ you try the code! */ + + // set port C output enable (so we can handle the JTAG enable signal) + OEC = (1 << 7); + + // set port E output enable (actually only PE6 is used to enable/disable the 1.2V regulator, but for strange reasons we also have to enable PE1-5) + OEE = 0x7F; + + // disconnect the 1.2V converter (in the configuration process, we can not draw + // more than 100ma) + IOE = (1 << 6); + + // set the CPU clock to 48MHz + CPUCS = bmCLKSPD1; + + // activate JTAG outputs on Port C + OEC = bmTDIOE | bmTCKOE | bmTMSOE | bmJTAG_EN; + + // put the system in FIFO mode by default + // internal clock source at 48Mhz, drive output pin, synchronous mode + // NOTE: Altera USB-Blaster does not work in another mode + IFCONFIG = bmIFCLKSRC | bm3048MHZ | bmIFCLKOE; + IFCONFIG |= bmASYNC | bmIFCFG1 | bmIFCFG0; +} + +void ProgIO_Set_State(unsigned char d) +{ + /* Set state of output pins: + * + * d.0 => TCK + * d.1 => TMS + * d.2 => nCE (only #ifdef HAVE_AS_MODE) + * d.3 => nCS (only #ifdef HAVE_AS_MODE) + * d.4 => TDI + * d.6 => LED / Output Enable + */ + + SetTCK((d & bmBIT0) ? 1 : 0); + SetTMS((d & bmBIT1) ? 1 : 0); +#ifdef HAVE_AS_MODE + SetNCE((d & bmBIT2) ? 1 : 0); + SetNCS((d & bmBIT3) ? 1 : 0); +#endif + SetTDI((d & bmBIT4) ? 1 : 0); +#ifdef HAVE_OE_LED + SetOELED((d & bmBIT5) ? 1 : 0); +#endif +} + +unsigned char ProgIO_Set_Get_State(unsigned char d) +{ + ProgIO_Set_State(d); + + /* Read state of input pins: + * + * TDO => d.0 + * DATAOUT => d.1 (only #ifdef HAVE_AS_MODE) + */ + + return (GetASDO()<<1)|GetTDO(); +} + +//----------------------------------------------------------------------------- + +void ProgIO_ShiftOut(unsigned char c) +{ + /* Shift out byte C: + * + * 8x { + * Output least significant bit on TDI + * Raise TCK + * Shift c right + * Lower TCK + * } + */ + + (void)c; /* argument passed in DPL */ + + _asm + MOV A,DPL + ;; Bit0 + RRC A + MOV _TDI,C + SETB _TCK + ;; Bit1 + RRC A + CLR _TCK + MOV _TDI,C + SETB _TCK + ;; Bit2 + RRC A + CLR _TCK + MOV _TDI,C + SETB _TCK + ;; Bit3 + RRC A + CLR _TCK + MOV _TDI,C + SETB _TCK + ;; Bit4 + RRC A + CLR _TCK + MOV _TDI,C + SETB _TCK + ;; Bit5 + RRC A + CLR _TCK + MOV _TDI,C + SETB _TCK + ;; Bit6 + RRC A + CLR _TCK + MOV _TDI,C + SETB _TCK + ;; Bit7 + RRC A + CLR _TCK + MOV _TDI,C + SETB _TCK + NOP + CLR _TCK + ret + _endasm; +} + +/* +;; For ShiftInOut, the timing is a little more +;; critical because we have to read _TDO/shift/set _TDI +;; when _TCK is low. But 20% duty cycle at 48/4/5 MHz +;; is just like 50% at 6 Mhz, and that's still acceptable +*/ + +#if HAVE_AS_MODE + +unsigned char ProgIO_ShiftInOut_JTAG(unsigned char c); +unsigned char ProgIO_ShiftInOut_AS(unsigned char c); + +unsigned char ProgIO_ShiftInOut(unsigned char c) +{ + if(GetNCS(x)) return ProgIO_ShiftInOut_JTAG(c); + return ProgIO_ShiftInOut_AS(c); +} + +#else /* HAVE_AS_MODE */ + +#define ProgIO_ShiftInOut_JTAG(x) ProgIO_ShiftInOut(x) + +#endif + +unsigned char ProgIO_ShiftInOut_JTAG(unsigned char c) +{ + /* Shift out byte C, shift in from TDO: + * + * 8x { + * Read carry from TDO + * Output least significant bit on TDI + * Raise TCK + * Shift c right, append carry (TDO) at left + * Lower TCK + * } + * Return c. + */ + + (void)c; /* argument passed in DPL */ + + _asm + MOV A,DPL + + ;; Bit0 + MOV C,_TDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit1 + MOV C,_TDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit2 + MOV C,_TDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit3 + MOV C,_TDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit4 + MOV C,_TDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit5 + MOV C,_TDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit6 + MOV C,_TDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit7 + MOV C,_TDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + + MOV DPL,A + ret + _endasm; + + /* return value in DPL */ + + return c; +} + +#ifdef HAVE_AS_MODE + +unsigned char ProgIO_ShiftInOut_AS(unsigned char c) +{ + /* Shift out byte C, shift in from TDO: + * + * 8x { + * Read carry from TDO + * Output least significant bit on TDI + * Raise TCK + * Shift c right, append carry (TDO) at left + * Lower TCK + * } + * Return c. + */ + + (void)c; /* argument passed in DPL */ + + _asm + MOV A,DPL + + ;; Bit0 + MOV C,_ASDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit1 + MOV C,_ASDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit2 + MOV C,_ASDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit3 + MOV C,_ASDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit4 + MOV C,_ASDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit5 + MOV C,_ASDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit6 + MOV C,_ASDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + ;; Bit7 + MOV C,_ASDO + RRC A + MOV _TDI,C + SETB _TCK + CLR _TCK + + MOV DPL,A + ret + _endasm; + return c; +} + +#endif /* HAVE_AS_MODE */ + + diff --git a/hw_xpcu_i.c b/hw_xpcu_i.c new file mode 100644 index 0000000..0e80063 --- /dev/null +++ b/hw_xpcu_i.c @@ -0,0 +1,300 @@ +/*----------------------------------------------------------------------------- + + * + + * Hardware-dependent code for usb_jtag + + *----------------------------------------------------------------------------- + + * Copyright (C) 2007 Kolja Waschk, ixo.de + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#include "hardware.h" + +#include "fx2regs.h" + +#include "syncdelay.h" + + + +//--------------------------------------------------------------------------- + + + +#define SetTCK(x) do{if(x) IOE|=0x08; else IOE&=~0x08; }while(0) + +#define SetTMS(x) do{if(x) IOE|=0x10; else IOE&=~0x10; }while(0) + +#define SetTDI(x) do{if(x) IOE|=0x40; else IOE&=~0x40; }while(0) + +#define GetTDO() ((IOE>>5)&1) + + + +/* XPCU has neither AS nor PS mode pins */ + + + +#define HAVE_OE_LED 1 + +/* +0=green led, +1=red led */ + +sbit at 0x80+1 OELED; + +#define SetOELED(x) do{OELED=(x);}while(0) + + + +//----------------------------------------------------------------------------- + + + +void ProgIO_Poll(void) {} + +void ProgIO_Enable(void) {} + +void ProgIO_Disable(void) {} + +void ProgIO_Deinit(void) {} + + + +void ProgIO_Init(void) + +{ + + /* The following code depends on your actual circuit design. + + Make required changes _before_ you try the code! */ + + + + // set the CPU clock to 48MHz, enable clock output to FPGA + + CPUCS = bmCLKOE | bmCLKSPD1; + + + + // Use internal 48 MHz, enable output, use "Port" mode for all pins + + IFCONFIG = bmIFCLKSRC | bm3048MHZ | bmIFCLKOE; + + + + GPIFABORT = 0xFF; + + + + PORTACFG = 0x00; OEA = 0x03; IOA=0x01; + + PORTCCFG = 0x00; OEC = 0x00; IOC=0x00; + + PORTECFG = 0x00; OEE = 0x58; IOE=0x00; + +} + + + +void ProgIO_Set_State(unsigned char d) + +{ + + /* Set state of output pins: + + * + + * d.0 => TCK + + * d.1 => TMS + + * d.2 => nCE (only #ifdef HAVE_AS_MODE) + + * d.3 => nCS (only #ifdef HAVE_AS_MODE) + + * d.4 => TDI + + * d.6 => LED / Output Enable + + */ + + + + SetTCK((d & bmBIT0) ? 1 : 0); + + SetTMS((d & bmBIT1) ? 1 : 0); + + SetTDI((d & bmBIT4) ? 1 : 0); + +#ifdef HAVE_OE_LED + + SetOELED((d & bmBIT5) ? 1 : 0); + +#endif + +} + + + +unsigned char ProgIO_Set_Get_State(unsigned char d) + +{ + + /* Read state of input pins: + + * + + * TDO => d.0 + + * DATAOUT => d.1 (only #ifdef HAVE_AS_MODE) + + */ + + + + ProgIO_Set_State(d); + + return 2|GetTDO(); + +} + + + +void ProgIO_ShiftOut(unsigned char c) + +{ + + /* Shift out byte C: + + * + + * 8x { + + * Output least significant bit on TDI + + * Raise TCK + + * Shift c right + + * Lower TCK + + * } + + */ + + + + unsigned char lc=c; + + + + if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc>>=1; IOE&=~0x08; + + if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc>>=1; IOE&=~0x08; + + if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc>>=1; IOE&=~0x08; + + if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc>>=1; IOE&=~0x08; + + + + if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc>>=1; IOE&=~0x08; + + if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc>>=1; IOE&=~0x08; + + if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc>>=1; IOE&=~0x08; + + if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc>>=1; IOE&=~0x08; + +} + + + +unsigned char ProgIO_ShiftInOut(unsigned char c) + +{ + + /* Shift out byte C, shift in from TDO: + + * + + * 8x { + + * Read carry from TDO + + * Output least significant bit on TDI + + * Raise TCK + + * Shift c right, append carry (TDO) at left + + * Lower TCK + + * } + + * Return c. + + */ + + + + unsigned char carry; + + unsigned char lc=c; + + + + carry = (IOE&0x20)<<2; if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc=carry|(lc>>1); IOE&=~0x08; + + carry = (IOE&0x20)<<2; if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc=carry|(lc>>1); IOE&=~0x08; + + carry = (IOE&0x20)<<2; if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc=carry|(lc>>1); IOE&=~0x08; + + carry = (IOE&0x20)<<2; if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc=carry|(lc>>1); IOE&=~0x08; + + + + carry = (IOE&0x20)<<2; if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc=carry|(lc>>1); IOE&=~0x08; + + carry = (IOE&0x20)<<2; if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc=carry|(lc>>1); IOE&=~0x08; + + carry = (IOE&0x20)<<2; if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc=carry|(lc>>1); IOE&=~0x08; + + carry = (IOE&0x20)<<2; if(lc&1) IOE|=0x40; else IOE&=~0x40; IOE|=0x08; lc=carry|(lc>>1); IOE&=~0x08; + + + + return lc; + +} + + + + + diff --git a/hw_xpcu_x.c b/hw_xpcu_x.c new file mode 100644 index 0000000..957de1f --- /dev/null +++ b/hw_xpcu_x.c @@ -0,0 +1,440 @@ +/*----------------------------------------------------------------------------- + + * Hardware-dependent code for usb_jtag + + *----------------------------------------------------------------------------- + + * Copyright (C) 2007 Kolja Waschk, ixo.de + + *----------------------------------------------------------------------------- + + * This code is part of usbjtag. usbjtag is free software; you can redistribute + + * it and/or modify it under the terms of the GNU General Public License as + + * published by the Free Software Foundation; either version 2 of the License, + + * or (at your option) any later version. usbjtag is distributed in the hope + + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + + * GNU General Public License for more details. You should have received a + + * copy of the GNU General Public License along with this program in the file + + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + + * St, Fifth Floor, Boston, MA 02110-1301 USA + + *----------------------------------------------------------------------------- + + */ + + + +#include "delay.h" + +#include "syncdelay.h" + +#include "hardware.h" + + + +#include "isr.h" + +#include "timer.h" + +#include "delay.h" + +#include "fx2regs.h" + +#include "fx2utils.h" + +#include "usb_common.h" + +#include "usb_descriptors.h" + +#include "usb_requests.h" + +#include "syncdelay.h" + +#include "eeprom.h" + + + +#define HAVE_OE_LED 1 + +sbit at 0x80+1 OELED; // red LED on S3E Starter Kit (0x80+0 is green one) + +#define SetOELED(x) do{OELED=(x);}while(0) + + + +void ProgIO_Poll(void) {} + +void ProgIO_Enable(void) {} + +void ProgiO_Disable(void) {} + +void ProgiO_Deinit(void) {} + + + +static unsigned char curios; + + + +const unsigned char wavedata[64] = + +{ + + /* Single Write: + + s0: BITS=D0 NEXT/SGLCRC DATA WAIT 4 + + s1: BITS= DATA WAIT 4 + + s2: BITS=D1|D0 DATA WAIT 4 + + s3: BITS=D1 DATA WAIT 3 + + s4: BITS=D1 DATA DP IF(RDY0) THEN 5 ELSE 2 + + s5: BITS=D1|D0 DATA WAIT 4 + + s6: BITS=D1 DATA WAIT 3 + + s7: BITS=D1 DATA FIN */ + + + + 4, 4, 4, 3, 0x2A, 4, 3, 7, + + 6, 2, 2, 2, 3, 2, 2, 2, + + 1, 0, 3, 2, 2, 3, 2, 2, + + 0, 0, 0, 0, 0, 0, 0, 0x3F, + + + + /* Single Read: + + s0: BITS=D0 WAIT 4 + + s1: BITS= WAIT 4 + + s2: BITS=D1|D0 WAIT 4 + + s3: BITS=D1 WAIT 4 + + s4: BITS=D1|D0 WAIT 3 + + s5: BITS=D1|D0 DP IF(RDY0) THEN 6 ELSE 3 + + s6: BITS=D1 DATA WAIT 4 + + s7: BITS=D1 FIN */ + + + + 4, 4, 4, 4, 3, 0x33, 4, 7, + + 0, 0, 0, 0, 0, 1, 2, 0, + + 1, 0, 3, 2, 3, 3, 2, 2, + + 0, 0, 0, 0, 0, 0, 0, 0x3F + +}; + + + +void ProgIO_Init(void) + +{ + + unsigned char i; + + + + /* The following code depends on your actual circuit design. + + Make required changes _before_ you try the code! */ + + + + // set the CPU clock to 48MHz, enable clock output to FPGA + + CPUCS = bmCLKOE | bmCLKSPD1; + + + + // Use internal 48 MHz, enable output, GPIF Master mode + + IFCONFIG = bmIFCLKSRC | bm3048MHZ | bmIFCLKOE | bmIFGPIF; + + + + PORTACFG = 0x00; OEA = 0xFB; IOA = 0x20; + + PORTCCFG = 0x00; OEC = 0xFF; IOC = 0x10; + + PORTECFG = 0x00; OEE = 0xFC; IOE = 0xC0; + + + + GPIFABORT = 0xFF; + + + + GPIFREADYCFG = 0xA0; + + GPIFCTLCFG = 0x00; + + GPIFIDLECS = 0x00; + + GPIFIDLECTL = 0x00; + + GPIFWFSELECT = 0x01; + + + + // Copy waveform data + + AUTOPTRSETUP = 0x07; + + APTR1H = MSB( &wavedata ); + + APTR1L = LSB( &wavedata ); + + AUTOPTRH2 = 0xE4; + + AUTOPTRL2 = 0x00; + + for ( i = 0; i < 64; i++ ) EXTAUTODAT2 = EXTAUTODAT1; + + + + SYNCDELAY; + + GPIFADRH = 0x00; + + SYNCDELAY; + + GPIFADRL = 0x00; + + + + FLOWSTATE = 0x00; + + FLOWLOGIC = 0x00; + + FLOWEQ0CTL = 0x00; + + FLOWEQ1CTL = 0x00; + + FLOWHOLDOFF = 0x00; + + FLOWSTB = 0x00; + + FLOWSTBEDGE = 0x00; + + FLOWSTBHPERIOD = 0x00; + + + + curios = 0; + +} + + + +unsigned char GetTDO(unsigned char r) + +{ + + unsigned char x; + + + + IOC = 0x41; + + while(!(GPIFTRIG & 0x80)); x = XGPIFSGLDATLX; + + while(!(GPIFTRIG & 0x80)); x = XGPIFSGLDATLNOX; + + + + if(IOA & 0x20) IOA |= 0x40; else IOA &= ~0x40; + + + + return (x&1) ? r : 0; + +} + + + +#define SetPins(x) while(!(GPIFTRIG & 0x80)); XGPIFSGLDATLX = (x) + + + +void ProgIO_Set_State(unsigned char d) + +{ + + /* Set state of output pins: + + * + + * d.0 => TCK (PE.6) + + * d.1 => TMS (PE.5) + + * d.4 => TDI (PE.4) + + * d.6 => LED / Output Enable + + */ + + + + curios = (d & bmBIT0) ? 0x40 : 0; // TCK + + curios |= (d & bmBIT1) ? 0x20 : 0; // TMS + + curios |= (d & bmBIT4) ? 0x10 : 0; // TDI + + + + IOC = 0x81; + + SetPins(curios); + + + + if(d & bmBIT6) IOA=(IOA&~3)|1; else IOA=(IOA&~3)|2; + +} + + + +unsigned char ProgIO_Set_Get_State(unsigned char d) + +{ + + ProgIO_Set_State(d); + + + + /* Read state of input pins: + + * + + * TDO => d.0 + + * DATAOUT => d.1 (only #ifdef HAVE_AS_MODE) + + */ + + + + return 2|GetTDO(0x01); + +} + + + +void ProgIO_ShiftOut(unsigned char c) + +{ + + unsigned char r,i; + + unsigned char locios = curios & ~0x50; + + + + IOC = 0x81; + + + + for(i=0,r=1;i<8;i++) + + { + + unsigned char t = locios; + + if(c & r) t |= 0x10; + + SetPins(t); + + SetPins(t|0x40); + + r <<= 1; + + SetPins(t); + + }; + + + + curios = locios; + +} + + + + + +unsigned char ProgIO_ShiftInOut(unsigned char c) + +{ + + unsigned char r,i,n; + + unsigned char locios = curios & ~0x50; + + + + for(i=0,r=1,n=0;i<8;i++) + + { + + unsigned char t = locios; + + + + n |= GetTDO(r); + + + + IOC = 0x81; + + if(c & r) t |= 0x10; + + SetPins(t); + + SetPins(t|0x40); + + r <<= 1; + + SetPins(t); + + }; + + + + curios = locios; + + return n; + +} + + + + + diff --git a/readme.txt b/readme.txt new file mode 100644 index 0000000..e22ce03 --- /dev/null +++ b/readme.txt @@ -0,0 +1,148 @@ +usb_jtag using Cypress FX2 chip + +=============================== + + + +The code in this directory is for Cypress FX2 (e.g. CY7C68013A) and can be compiled with + +the SDCC compiler (I tried version 2.6 as shipped with Ubuntu 6.10). Once I had a version + +that could be compiled with Keil tools (until early 2007), but switched to SDCC because I + +usually develop on a Linux host. + + + +No logic beside the FX2 itself and only a few external components are required for a basic + +JTAG adapter. I don't have detailed schematics available; my test setup consists of a FX2 + +on a custom board where it's directly connected to a Cyclone FPGA. + + + + ____________ + + | | + + | Cypress | + + USB__| EZ-USB FX2 |__JTAG(TDI,TDO,TCK,TMS) + + | CY7C68013A | + + |____________| + + __|__________ + + | | + + | 24 MHz XTAL | + + |_____________| + + + + + +Similar eval boards are now available from fpga4fun.com - the boards named + +"Saxo-L" and "Xylo-EM" are pre-wired for use with an adapted version of my + +code, while "Saxo" and "Xylo" can be used after soldering 4 extra wires: + + + + http://www.fpga4fun.com/board_Xylo.html + + + + + +As is, the code assumes the following pin assignment: + + + + Port C.0: TDI + + Port C.1: TDO + + Port C.2: TCK + + Port C.3: TMS + + + +Other assignments are possible; you'll have to adapt the definitions in hardware.h and maybe + +in hardware.c, too. + + + +The USB identification data (vendor/product ID, strings, ...) can be modified in dscr.a51. My + +firmware emulates the 128 byte EEPROM that usually holds configuration data for the FT245 and + +which can be read from the host; its content is computed from the data in dscr.a51 as well. + + + +The WAKEUP pin should be high for the re-numeration to work reliably (thanks Jean/fpga4fun!) + + + +From this release on, there is new code to support running in the "Xilinx + +Platform Cable USB". If you select HARDWARE=hw_xpcu_i or hw_xpcu_x at the top + +of the Makefile, a firmware for the XPCU will be built. I've tested this only + +with unmodified CPLD version 18 (0x12) on a Spartan-3E starter kit, as it was + +programmed by my WebPack 8.2i. The code needs optimization; yet it is merely a + +proof of concept. + + + + hw_xpcu_i: Access "internal" chain (the XPCU CPLD, IC3, itself) + + hw_xpcu_x: Access "external" chain (the Spartan 3E, PROM, etc.) + + + +Changes since previous release on 2007-01-28: + + - Initial suppport for running on Xilinx XPCU. + + - New FX2 code, based on USRP2 from the GNU Radio Project; + + - Firmware can now be compiled using SDCC 2.6. No more Keil support. + + - EEPROM content is automatically computed from descriptors, including checksum. + + + +Changes since initial release on 2006-04-23: + + - added this readme.txt + + - reorganized my project folder: diff is now created from Subversion repository + + - stripped *.dist extension from eeprom.c and dscr.a51 + + - added unique proper product and vendor ID (thanks to Antti Lukats!) + + - fixed checksum in eeprom.c + + - added comments about AS/PS mode pins in usbjtag.c + + + + + + + + + diff --git a/startup.a51 b/startup.a51 new file mode 100644 index 0000000..84ec4df --- /dev/null +++ b/startup.a51 @@ -0,0 +1,156 @@ +;;; -*- asm -*- + +;;; + +;;;----------------------------------------------------------------------------- + +;;; Startup code + +;;;----------------------------------------------------------------------------- + +;;; Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + +;;; Copyright 2003 Free Software Foundation, Inc. + +;;;----------------------------------------------------------------------------- + +;;; This code is part of usbjtag. usbjtag is free software; you can redistribute + +;;; it and/or modify it under the terms of the GNU General Public License as + +;;; published by the Free Software Foundation; either version 2 of the License, + +;;; or (at your option) any later version. usbjtag is distributed in the hope + +;;; that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + +;;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + +;;; GNU General Public License for more details. You should have received a + +;;; copy of the GNU General Public License along with this program in the file + +;;; COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + +;;; St, Fifth Floor, Boston, MA 02110-1301 USA + +;;;----------------------------------------------------------------------------- + + + +;;; The default external memory initialization provided by sdcc is not + +;;; appropriate to the FX2. This is derived from the sdcc code, but uses + +;;; the FX2 specific _MPAGE sfr. + + + + + + ;; .area XISEG (XDATA) ; the initialized external data area + + ;; .area XINIT (CODE) ; the code space consts to init XISEG + + .area XSEG (XDATA) ; zero initialized xdata + + .area USBDESCSEG (XDATA) ; usb descriptors + + + + + + .area CSEG (CODE) + + + + ;; sfr that sets upper address byte of MOVX using @r0 or @r1 + + _MPAGE = 0x0092 + + + +__sdcc_external_startup:: + + ;; This system is now compiled with the --no-xinit-opt + + ;; which means that any initialized XDATA is handled + + ;; inline by code in the GSINIT segs emitted for each file. + + ;; + + ;; We zero XSEG and all of the internal ram to ensure + + ;; a known good state for uninitialized variables. + + + +; _mcs51_genRAMCLEAR() start + + mov r0,#l_XSEG + + mov a,r0 + + orl a,#(l_XSEG >> 8) + + jz 00002$ + + mov r1,#((l_XSEG + 255) >> 8) + + mov dptr,#s_XSEG + + clr a + + + +00001$: movx @dptr,a + + inc dptr + + djnz r0,00001$ + + djnz r1,00001$ + + + + ;; We're about to clear internal memory. This will overwrite + + ;; the stack which contains our return address. + + ;; Pop our return address into DPH, DPL + +00002$: pop dph + + pop dpl + + + + ;; R0 and A contain 0. This loop will execute 256 times. + + ;; + + ;; FWIW the first iteration writes direct address 0x00, + + ;; which is the location of r0. We get lucky, we're + + ;; writing the correct value (0) + + + +00003$: mov @r0,a + + djnz r0,00003$ + + + + push dpl ; restore our return address + + push dph + + + + mov dpl,#0 ; indicate that data init is still required + + ret + diff --git a/usbjtag.c b/usbjtag.c new file mode 100644 index 0000000..3c81823 --- /dev/null +++ b/usbjtag.c @@ -0,0 +1,470 @@ +/*----------------------------------------------------------------------------- + * Code that turns a Cypress FX2 USB Controller into an USB JTAG adapter + *----------------------------------------------------------------------------- + * Copyright (C) 2005..2007 Kolja Waschk, ixo.de + *----------------------------------------------------------------------------- + * Check hardware.h/.c if it matches your hardware configuration (e.g. pinout). + * Changes regarding USB identification should be made in product.inc! + *----------------------------------------------------------------------------- + * This code is part of usbjtag. usbjtag is free software; you can redistribute + * it and/or modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the License, + * or (at your option) any later version. usbjtag is distributed in the hope + * that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. You should have received a + * copy of the GNU General Public License along with this program in the file + * COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + * St, Fifth Floor, Boston, MA 02110-1301 USA + *----------------------------------------------------------------------------- + */ + +// The firmware version should be regularly updated. +#define FWVERSION "4.1.0" + +#include "isr.h" +#include "timer.h" +#include "delay.h" +#include "fx2regs.h" +#include "fx2utils.h" +#include "usb_common.h" +#include "usb_descriptors.h" +#include "usb_requests.h" + +#include "syncdelay.h" + +#include "eeprom.h" +#include "hardware.h" + +//----------------------------------------------------------------------------- +// Define USE_MOD256_OUTBUFFER: +// Saves about 256 bytes in code size, improves speed a little. +// A further optimization could be not to use an extra output buffer at +// all, but to write directly into EP1INBUF. Not implemented yet. When +// downloading large amounts of data _to_ the target, there is no output +// and thus the output buffer isn't used at all and doesn't slow down things. + +#define USE_MOD256_OUTBUFFER 1 + +//----------------------------------------------------------------------------- +// Global data + +typedef bit BOOL; +#define FALSE 0 +#define TRUE 1 +static BOOL Running; +static BOOL WriteOnly; + +static BYTE ClockBytes; +static WORD Pending; + +#ifdef USE_MOD256_OUTBUFFER + static BYTE FirstDataInOutBuffer; + static BYTE FirstFreeInOutBuffer; +#else + static WORD FirstDataInOutBuffer; + static WORD FirstFreeInOutBuffer; +#endif + +#ifdef USE_MOD256_OUTBUFFER + /* Size of output buffer must be exactly 256 */ + #define OUTBUFFER_LEN 0x100 + /* Output buffer must begin at some address with lower 8 bits all zero */ + xdata at 0xE000 BYTE OutBuffer[OUTBUFFER_LEN]; +#else + #define OUTBUFFER_LEN 0x200 + static xdata BYTE OutBuffer[OUTBUFFER_LEN]; +#endif + +//----------------------------------------------------------------------------- + +void usb_jtag_init(void) // Called once at startup +{ + WORD tmp; + + Running = FALSE; + ClockBytes = 0; + Pending = 0; + WriteOnly = TRUE; + FirstDataInOutBuffer = 0; + FirstFreeInOutBuffer = 0; + + ProgIO_Init(); + + ProgIO_Enable(); + + // Make Timer2 reload at 100 Hz to trigger Keepalive packets + tmp = 65536 - ( 48000000 / 12 / 100 ); + RCAP2H = tmp >> 8; + RCAP2L = tmp & 0xFF; + CKCON = 0; // Default Clock + T2CON = 0x04; // Auto-reload mode using internal clock, no baud clock. + + // Enable Autopointer + EXTACC = 1; // Enable + APTR1FZ = 1; // Don't freeze + APTR2FZ = 1; // Don't freeze + + // define endpoint configuration + + REVCTL = 3; SYNCDELAY; // Allow FW access to FIFO buffer + FIFORESET = 0x80; SYNCDELAY; // From now on, NAK all, reset all FIFOS + FIFORESET = 0x02; SYNCDELAY; // Reset FIFO 2 + FIFORESET = 0x04; SYNCDELAY; // Reset FIFO 4 + FIFORESET = 0x06; SYNCDELAY; // Reset FIFO 6 + FIFORESET = 0x08; SYNCDELAY; // Reset FIFO 8 + FIFORESET = 0x00; SYNCDELAY; // Restore normal behaviour + + EP1OUTCFG = 0xA0; SYNCDELAY; // Endpoint 1 Type Bulk + EP1INCFG = 0xA0; SYNCDELAY; // Endpoint 1 Type Bulk + + EP2FIFOCFG = 0x00; SYNCDELAY; // Endpoint 2 + EP2CFG = 0xA2; SYNCDELAY; // Endpoint 2 Valid, Out, Type Bulk, Double buffered + + EP4FIFOCFG = 0x00; SYNCDELAY; // Endpoint 4 not used + EP4CFG = 0xA0; SYNCDELAY; // Endpoint 4 not used + + REVCTL = 0; SYNCDELAY; // Reset FW access to FIFO buffer, enable auto-arming when AUTOOUT is switched to 1 + + EP6CFG = 0xA2; SYNCDELAY; // Out endpoint, Bulk, Double buffering + EP6FIFOCFG = 0x00; SYNCDELAY; // Firmware has to see a rising edge on auto bit to enable auto arming + EP6FIFOCFG = bmAUTOOUT | bmWORDWIDE; SYNCDELAY; // Endpoint 6 used for user communicationn, auto commitment, 16 bits data bus + + EP8CFG = 0xE0; SYNCDELAY; // In endpoint, Bulk + EP8FIFOCFG = 0x00; SYNCDELAY; // Firmware has to see a rising edge on auto bit to enable auto arming + EP8FIFOCFG = bmAUTOIN | bmWORDWIDE; SYNCDELAY; // Endpoint 8 used for user communication, auto commitment, 16 bits data bus + + EP8AUTOINLENH = 0x00; SYNCDELAY; // Size in bytes of the IN data automatically commited (64 bytes here, but changed dynamically depending on the connection) + EP8AUTOINLENL = 0x40; SYNCDELAY; // Can use signal PKTEND if you want to commit a shorter packet + + // Out endpoints do not come up armed + // Since the defaults are double buffered we must write dummy byte counts twice + EP2BCL = 0x80; SYNCDELAY; // Arm EP2OUT by writing byte count w/skip.= + EP4BCL = 0x80; SYNCDELAY; + EP2BCL = 0x80; SYNCDELAY; // Arm EP4OUT by writing byte count w/skip.= + EP4BCL = 0x80; SYNCDELAY; + + // JTAG from FX2 enabled by default + IOC |= (1 << 7); + + // Put the system in high speed by default (REM: USB-Blaster is in full speed) + // This can be changed by vendor commands + CT1 &= ~0x02; + // Put the FIFO in sync mode + IFCONFIG &= ~bmASYNC; +} + +void OutputByte(BYTE d) +{ +#ifdef USE_MOD256_OUTBUFFER + OutBuffer[FirstFreeInOutBuffer] = d; + FirstFreeInOutBuffer = ( FirstFreeInOutBuffer + 1 ) & 0xFF; +#else + OutBuffer[FirstFreeInOutBuffer++] = d; + if(FirstFreeInOutBuffer >= OUTBUFFER_LEN) FirstFreeInOutBuffer = 0; +#endif + Pending++; +} + +//----------------------------------------------------------------------------- +// usb_jtag_activity does most of the work. It now happens to behave just like +// the combination of FT245BM and Altera-programmed EPM7064 CPLD in Altera's +// USB-Blaster. The CPLD knows two major modes: Bit banging mode and Byte +// shift mode. It starts in Bit banging mode. While bytes are received +// from the host on EP2OUT, each byte B of them is processed as follows: +// +// Please note: nCE, nCS, LED pins and DATAOUT actually aren't supported here. +// Support for these would be required for AS/PS mode and isn't too complicated, +// but I haven't had the time yet. +// +// Bit banging mode: +// +// 1. Remember bit 6 (0x40) in B as the "Read bit". +// +// 2. If bit 7 (0x40) is set, switch to Byte shift mode for the coming +// X bytes ( X := B & 0x3F ), and don't do anything else now. +// +// 3. Otherwise, set the JTAG signals as follows: +// TCK/DCLK high if bit 0 was set (0x01), otherwise low +// TMS/nCONFIG high if bit 1 was set (0x02), otherwise low +// nCE high if bit 2 was set (0x04), otherwise low +// nCS high if bit 3 was set (0x08), otherwise low +// TDI/ASDI/DATA0 high if bit 4 was set (0x10), otherwise low +// Output Enable/LED active if bit 5 was set (0x20), otherwise low +// +// 4. If "Read bit" (0x40) was set, record the state of TDO(CONF_DONE) and +// DATAOUT(nSTATUS) pins and put it as a byte ((DATAOUT<<1)|TDO) in the +// output FIFO _to_ the host (the code here reads TDO only and assumes +// DATAOUT=1) +// +// Byte shift mode: +// +// 1. Load shift register with byte from host +// +// 2. Do 8 times (i.e. for each bit of the byte; implemented in shift.a51) +// 2a) if nCS=1, set carry bit from TDO, else set carry bit from DATAOUT +// 2b) Rotate shift register through carry bit +// 2c) TDI := Carry bit +// 2d) Raise TCK, then lower TCK. +// +// 3. If "Read bit" was set when switching into byte shift mode, +// record the shift register content and put it into the FIFO +// _to_ the host. +// +// Some more (minor) things to consider to emulate the FT245BM: +// +// a) The FT245BM seems to transmit just packets of no more than 64 bytes +// (which perfectly matches the USB spec). Each packet starts with +// two non-data bytes (I use 0x31,0x60 here). A USB sniffer on Windows +// might show a number of packets to you as if it was a large transfer +// because of the way that Windows understands it: it _is_ a large +// transfer until terminated with an USB packet smaller than 64 byte. +// +// b) The Windows driver expects to get some data packets (with at least +// the two leading bytes 0x31,0x60) immediately after "resetting" the +// FT chip and then in regular intervals. Otherwise a blue screen may +// appear... In the code below, I make sure that every 10ms there is +// some packet. +// +// c) Vendor specific commands to configure the FT245 are mostly ignored +// in my code. Only those for reading the EEPROM are processed. See +// DR_GetStatus and DR_VendorCmd below for my implementation. +// +// All other TD_ and DR_ functions remain as provided with CY3681. +// +//----------------------------------------------------------------------------- + +void usb_jtag_activity(void) // Called repeatedly while the device is idle +{ + if(!Running) return; + + ProgIO_Poll(); + + if(!(EP1INCS & bmEPBUSY)) + { + if(Pending > 0) + { + BYTE o, n; + + AUTOPTRH2 = MSB( EP1INBUF ); + AUTOPTRL2 = LSB( EP1INBUF ); + + XAUTODAT2 = 0x31; + XAUTODAT2 = 0x60; + + if(Pending > 0x3E) { n = 0x3E; Pending -= n; } + else { n = Pending; Pending = 0; }; + + o = n; + +#ifdef USE_MOD256_OUTBUFFER + APTR1H = MSB( OutBuffer ); + APTR1L = FirstDataInOutBuffer; + while(n--) + { + XAUTODAT2 = XAUTODAT1; + APTR1H = MSB( OutBuffer ); // Stay within 256-Byte-Buffer + }; + FirstDataInOutBuffer = APTR1L; +#else + APTR1H = MSB( &(OutBuffer[FirstDataInOutBuffer]) ); + APTR1L = LSB( &(OutBuffer[FirstDataInOutBuffer]) ); + while(n--) + { + XAUTODAT2 = XAUTODAT1; + + if(++FirstDataInOutBuffer >= OUTBUFFER_LEN) + { + FirstDataInOutBuffer = 0; + APTR1H = MSB( OutBuffer ); + APTR1L = LSB( OutBuffer ); + }; + }; +#endif + SYNCDELAY; + EP1INBC = 2 + o; + TF2 = 1; // Make sure there will be a short transfer soon + } + else if(TF2) + { + EP1INBUF[0] = 0x31; + EP1INBUF[1] = 0x60; + SYNCDELAY; + EP1INBC = 2; + TF2 = 0; + }; + }; + + if(!(EP2468STAT & bmEP2EMPTY) && (Pending < OUTBUFFER_LEN-0x3F)) + { + BYTE i, n = EP2BCL; + + APTR1H = MSB( EP2FIFOBUF ); + APTR1L = LSB( EP2FIFOBUF ); + + for(i=0;i 0) + { + BYTE m; + + m = n-i; + if(ClockBytes < m) m = ClockBytes; + ClockBytes -= m; + i += m; + + /* Shift out 8 bits from d */ + + if(WriteOnly) /* Shift out 8 bits from d */ + { + while(m--) ProgIO_ShiftOut(XAUTODAT1); + } + else /* Shift in 8 bits at the other end */ + { + while(m--) OutputByte(ProgIO_ShiftInOut(XAUTODAT1)); + } + } + else + { + BYTE d = XAUTODAT1; + WriteOnly = (d & bmBIT6) ? FALSE : TRUE; + + if(d & bmBIT7) + { + /* Prepare byte transfer, do nothing else yet */ + + ClockBytes = d & 0x3F; + } + else + { + if(WriteOnly) + ProgIO_Set_State(d); + else + OutputByte(ProgIO_Set_Get_State(d)); + }; + i++; + }; + }; + + SYNCDELAY; + EP2BCL = 0x80; // Re-arm endpoint 2 + }; +} + +//----------------------------------------------------------------------------- +// Handler for Vendor Requests ( +//----------------------------------------------------------------------------- + +unsigned char app_vendor_cmd(void) +{ + // OUT requests. Pretend we handle them all... + if ((bRequestType & bmRT_DIR_MASK) == bmRT_DIR_OUT){ + if(bRequest == RQ_GET_STATUS){ + Running = 1; + }; + return 1; + } + + // IN requests. + switch (bRequest){ + case 0x90: // Read EEPROM + { // We need a block for addr + BYTE addr = (wIndexL<<1) & 0x7F; + EP0BUF[0] = eeprom[addr]; + EP0BUF[1] = eeprom[addr+1]; + EP0BCL = (wLengthL<2) ? wLengthL : 2; + } + break; + + case 0x91: // change USB speed + if (wIndexL == 0){ // high speed + CT1 &= ~0x02; + EP0BUF[0] = 0x2; + fx2_renumerate(); // renumerate + }else{ // full speed + CT1 |= 0x02; + EP0BUF[0] = 0x1; + fx2_renumerate(); // renumerate + } + EP0BCH = 0; // Arm endpoint + EP0BCL = 1; // # bytes to transfer + break; + + case 0x92: // change JTAG enable + if (wIndexL == 0){ // FX2 is master of JTAG + IOC |= (1 << 7); + }else{ // external connector is master of JTAG + IOC &= ~(1 << 7); + } + EP0BCH = 0; // Arm endpoint + EP0BCL = 0; // # bytes to transfer + break; + + case 0x93: // change synchronous/asynchronous mode + if(wIndexL == 0){ // sync + IFCONFIG &= ~bmASYNC; + EP0BUF[0] = 0; + }else{ + IFCONFIG |= bmASYNC; // async + EP0BUF[0] = 1; + } + EP0BCH = 0; // Arm endpoint + EP0BCL = 1; + break; + + case 0x94: // get Firmware version + { + int i=0; + char* ver=FWVERSION; + while(ver[i]!='\0'){ + EP0BUF[i]=ver[i]; + i++; + } + EP0BCH = 0; // Arm endpoint + EP0BCL = i; + break; + } + default: + // dummy data + EP0BUF[0] = 0x36; + EP0BUF[1] = 0x83; + EP0BCH = 0; + EP0BCL = (wLengthL<2) ? wLengthL : 2; + } + + return 1; +} + +//----------------------------------------------------------------------------- + +static void main_loop(void) +{ + while(1) + { + if(usb_setup_packet_avail()) usb_handle_setup_packet(); + usb_jtag_activity(); + } +} + +//----------------------------------------------------------------------------- + +void main(void) +{ + EA = 0; // disable all interrupts + + usb_jtag_init(); + eeprom_init(); + setup_autovectors (); + usb_install_handlers (); + + + EA = 1; // enable interrupts + + fx2_renumerate(); // simulates disconnect / reconnect + + main_loop(); +} + + + + diff --git a/usbjtag.hex b/usbjtag.hex new file mode 100644 index 0000000..9b3fbfa --- /dev/null +++ b/usbjtag.hex @@ -0,0 +1,279 @@ +:06000000020FA402006BD8 +:03000B0002006B85 +:0300130002006B7D +:03001B0002006B75 +:0300230002006B6D +:03002B0002006B65 +:0300330002006B5D +:03003B0002006B55 +:0300430002006B4D +:03004B0002006B45 +:0300530002006B3D +:03005B0002006B35 +:0300630002006B2D +:01006B003262 +:1000800002006B0002006B0002006B0002006B00BC +:1000900002006B0002006B0002006B0002006B00AC +:1000A00002006B0002006B0002006B0002006B009C +:0800B00002006B0002006B006E +:1001000002006B0002006B0002006B0002006B003B +:1001100002006B0002006B0002006B0002006B002B +:1001200002006B0002006B0002006B0002006B001B +:1001300002006B0002006B0002006B0002006B000B +:1001400002006B0002006B0002006B0002006B00FB +:1001500002006B0002006B0002006B0002006B00EB +:1001600002006B0002006B0002006B0002006B00DB +:1001700002006B0002006B0002006B0002006B00CB +:030FAC00020FAF82 +:030FC200020180A9 +:1001800012057B80FEC200E4F508F509F50AD201EC +:10019000750B00750C0012077812077575CB637527 +:1001A000CAC0758E0075C804D2AFD2B0D2B190E685 +:1001B0000B7403F00090E6047480F00090E6047481 +:1001C00002F00090E6047404F00090E6047406F077 +:1001D0000090E6047408F00090E604E4F00090E675 +:1001E0001074A0F00090E61174A0F00090E618E4FE +:1001F000F00090E61274A2F00090E619E4F000908E +:10020000E61374A0F00090E60BE4F00090E614749E +:10021000A2F00090E61AE4F00090E61A7411F000E3 +:1002200090E61574E0F00090E61BE4F00090E61B09 +:100230007409F00090E626E4F00090E6277440F0A0 +:100240000090E6917480F00090E6957480F0009044 +:10025000E6917480F00090E6957480F00043A080F1 +:1002600090E6FBE0FA54FDF090E601E0FA54F7F076 +:1002700022AA82850C827583E0EAF0050C0509E468 +:10028000B50902050A222000012212077490E6A295 +:10029000E0FA30E10302031FE509450A60697AC00C +:1002A0007BE78B9D7AC07BE77B008A9E90E67C741F +:1002B00031F07460F0C3743E9509E4950A50107AE9 +:1002C0003EE50924C2F509E50A34FFF50A8007AACC +:1002D00009E4F509F50A8A037C007DE08D9A850B17 +:1002E0009B8A041AEC601190E67BE0FC90E67CF0BF +:1002F0007C007DE08D9A80E9859B0B0090E68F74F1 +:10030000022BF0D2CF801830CF1590E7C07431F0B7 +:1003100090E7C17460F00090E68F7402F0C2CFE500 +:10032000AA30E00122C3E50994C1E50A9400400126 +:100330002290E691E0FA7B007CF08C9A7B007CF0C6 +:100340007C008B9B7B00C3EB9A4003020403E5080F +:100350006065EAC39BFCC3E5089C5002AC08E50855 +:10036000C39CF508EC2BFB3001208C058D061DEE9F +:1003700060D490E67BE0FEF582C002C003C00512A7 +:10038000080AD005D003D00280E28C051CED60B6CF +:1003900090E67BE0FDF582C002C003C0041208476E +:1003A000D004D003D002C002C003C004120271D036 +:1003B00004D003D00280D390E67BE0FC30E6047DDD +:1003C0000080027D01ED24FF9201EC30E707743FCD +:1003D0005CF508802A30010F8C82C002C00312072E +:1003E0009AD003D00280188C82C002C0031207F793 +:1003F000D003D002C002C003120271D003D0020B9E +:100400000203460090E6917480F02290E6B8E0FA8C +:1004100020E70C90E6B9E07002D2007582012290CC +:10042000E6B9E0FABA9002801ABA9102805ABA92FA +:10043000030204C0BA93030204DABA940302050A61 +:1004400002054390E6BCE025E0547FFA2400F582E3 +:10045000E43418F583E0FB90E740F074012A2400AF +:10046000F582E43418F583E0FA90E741F090E6BEB7 +:10047000E0FABA0200500790E6BEE0FA80027A0283 +:1004800090E68BEAF002056C90E6BCE0701390E613 +:10049000FBE0FA54FDF090E7407402F01209398055 +:1004A0001190E6FBE0FA4402F090E7407401F0128C +:1004B000093990E68AE4F090E68B7401F002056C4D +:1004C00090E6BCE0700543A080800353A07F90E6D7 +:1004D0008AE4F090E68BF002056C90E6BCE0700FC9 +:1004E00090E601E0FA54F7F090E740E4F0800E90D7 +:1004F000E601E0FA4408F090E7407401F090E68AE3 +:10050000E4F090E68B7401F080627A007B00EA24CC +:10051000C5FCEB340FFD7E808C828D838EF0120F34 +:1005200088FC6013EA2440F582EB34E7F583ECF0B5 +:100530000ABA00DA0B80D790E68AE4F090E68BEAFC +:10054000F0802990E7407436F090E7417483F09092 +:10055000E68AE4F090E6BEE0FABA0200500790E6C0 +:10056000BEE0FA80027A0290E68BEAF07582012200 +:10057000300203120AD412028680F5C2AF1201853E +:100580001205D8120EB9120A3ED2AF12093902056D +:0105900070FA +:060FC500342E312E300035 +:10E1000012011001FF000040FB0901600004010240 +:10E1100003010A061001FFFFFF400100090237005A +:10E1200002010080FA0904000002FFFFFF02070558 +:10E1300081024000000705020240000009040100BE +:10E1400002FFFFFF02070506020002000705880222 +:03E15000000200CA +:10E154001201100100000040FB09016000040102EB +:10E1640003010A061001FFFFFF4001000902370006 +:10E1740002010080FA0904000002FFFFFF02070504 +:10E18400810240000007050202400000090401006A +:10E1940002FFFFFF02070506024000000705880290 +:10E1A40040000004B0E1B6E1C0E1D8E1060300009C +:10E1B40009040A034500500046004C0018035500AA +:10E1C400530042002D0042006C0061007300740093 +:10E1D400650072001203300030003000300030005F +:06E1E400300030003000A5 +:10059100AA82E50D54FEFBB50D02802A8A048C0562 +:1005A100E4FC620EED620FEB2400F582E43418F5F1 +:1005B10083E0FB7C00620EEC620FE50E33C50F3366 +:1005C100C50F92E0F50EAB0D050DEB2400F582E4AD +:1005D1003418F583EAF022750D00750EAA750FAA7D +:1005E1007582001205917582001205917A00C3EAA5 +:1005F100648094865018EA2408F582E434E1F58396 +:10060100E0FBF582C002120591D0020A80E07A0077 +:10061100C3EA648094825018EA2423F582E434E129 +:10062100F583E0FBF582C002120591D0020A80E059 +:1006310075821C1205917582001205917A00C3EA38 +:10064100648094825018EA2402F582E434E1F5834F +:10065100E0FBF582C002120591D0020A80E07486A7 +:10066100250DFAF582C002120591D00290E1B6E0A3 +:10067100FBF582C002120591D00290E1B6E0FB2A9F +:10068100FAF582C002120591D00290E1C0E0FBF5BB +:1006910082C002120591D00290E1C0E0FB2AFAF576 +:1006A1008212059190E1D8E0FAF5821205917A0063 +:1006B10090E1B6E0FBC3EA64808BF063F08095F0D3 +:1006C1005018EA24B6F582E434E1F583E0FBF582C3 +:1006D100C002120591D0020A80D67A0090E1C0E0F2 +:1006E100FBC3EA64808BF063F08095F05018EA2434 +:1006F100C0F582E434E1F583E0FBF582C002120526 +:1007010091D0020A80D67A0090E1D8E0FBC3EA6476 +:10071100808BF063F08095F05018EA24D8F582E4DC +:1007210034E1F583E0FBF582C002120591D0020AA3 +:1007310080D67A00C3EA648094845018EA240EF5C6 +:1007410082E434E1F583E0FBF582C002120591D029 +:10075100020A80E07482250D40087582001205911D +:1007610080F2AA0E7B0090187EEAF0AA0F90187F03 +:03077100EAF02289 +:020FA400D22158 +:100774002222222275B48075B67F75B14090E600BE +:100784007410F075B48D90E60174E0F0E0FA90E630 +:1007940001740B4AF022E582FA30E0047B01800206 +:1007A4007B00EB24FF92A2EA30E1047B0180027B10 +:1007B40000EB24FF92A3EA30E2047B0180027B0079 +:1007C400EB24FF92A5EA30E3047B0180027B00EB7B +:1007D40024FF92A4EA30E4047B0180027B00EB2432 +:1007E400FF92A0EA30E5047A0180027A00EA24FF4D +:1007F40092A72212079AE4A2A63325E0FAE4A2A162 +:1008040033FB4AF58222E5821392A0D2A213C2A23C +:1008140092A0D2A213C2A292A0D2A213C2A292A068 +:10082400D2A213C2A292A0D2A213C2A292A0D2A216 +:1008340013C2A292A0D2A213C2A292A0D2A200C2B8 +:10084400A22222AA8230A4058A820208568A82023F +:1008540008A4E582A2A11392A0D2A2C2A2A2A113CB +:1008640092A0D2A2C2A2A2A11392A0D2A2C2A2A278 +:10087400A11392A0D2A2C2A2A2A11392A0D2A2C2F8 +:10088400A2A2A11392A0D2A2C2A2A2A11392A0D208 +:10089400A2C2A2A2A11392A0D2A2C2A2F582222233 +:1008A400E582A2A61392A0D2A2C2A2A2A61392A0EB +:1008B400D2A2C2A2A2A61392A0D2A2C2A2A2A6139C +:1008C40092A0D2A2C2A2A2A61392A0D2A2C2A2A213 +:1008D400A61392A0D2A2C2A2A2A61392A0D2A2C28E +:1008E400A2A2A61392A0D2A2C2A2F582222278804A +:1008F400E84400600C7901901800E4F0A3D8FCD916 +:10090400FAD083D082F6D8FDC082C08375820022DB +:1009140090E6A0E0FA4401F022AA8274805AFBC453 +:1009240023541FFB740F5A90E6834BF090E683E048 +:10093400FA4420F02290E680E0FA440AF09000FAAB +:10094400120F7590E65D74FFF090E65F74FFF0534C +:0B09540091EF90E680E0FA54F7F022EB +:060FBC00E478FFF6D8FD09 +:060FA6007510007511003A +:10095F0090E680E0FA30E7267512007513E1751402 +:10096F00127515E175161C7517E17518707519E17B +:10097F0090E6267402F00090E627E4F0002275124C +:10098F00547513E17514667515E17516707517E1D9 +:10099F0075181C7519E190E626E4F00090E62774AF +:1009AF0040F000225391EF75A100D20232C0E0C097 +:1009BF00F0C082C083C002C003C004C005C006C01F +:1009CF0007C000C001C0D075D0005391EF75A100D2 +:1009DF0012095FD0D0D001D000D007D006D005D0FB +:1009EF0004D003D002D083D082D0F0D0E032C0E068 +:1009FF00C0F0C082C083C002C003C004C005C006DF +:100A0F00C007C000C001C0D075D0005391EF75A1D1 +:100A1F000012095FD0D0D001D000D007D006D0058A +:100A2F00D004D003D002D083D082D0F0D0E03212E5 +:100A3F00095F751AB3751B09758200120E0A751AB4 +:100A4F00BC751B09758210120E0A751AFD751B09EC +:100A5F00758214120E0A90E65C7431F022E582540E +:100A6F007FFA24F7500475820022BA0104758201BF +:100A7F0022530201E4BA000104F58222AA82BA01CC +:100A8F000C90E6A1E0FB7C008B828C8322BA810C58 +:100A9F0090E6A2E0FB7C008B828C832253027FEADC +:100AAF00700C90E6A0E0FB7C008B828C832290E69A +:100ABF00A3E0FB7C00EAC313FA7D00EA2BFBED3CBD +:100ACF008B82F58322C20290E6B8E0FA530260BA35 +:100ADF0000028028BA2002800DBA4002800EBA6050 +:100AEF00028003020D9E120914020D9E12040BE5E3 +:100AFF00826003020D9E120914020D9E90E6B8E06B +:100B0F00FA530280BA80028003020C9790E6B9E094 +:100B1F00FABA0003020C0EBA06028035BA08028038 +:100B2F0008BA0A028017020C9190E740E510F09086 +:100B3F00E68AE4F090E68B7401F0020D9E90E74098 +:100B4F00E511F090E68AE4F090E68B7401F0020D67 +:100B5F009E90E6BBE0FABA01028017BA0202803813 +:100B6F00BA03028059BA0602801BBA0702803C0200 +:100B7F000C08AA12AB1390E6B3EBF07B0090E6B42F +:100B8F00EAF0020D9EAA14AB1590E6B3EBF07B00D2 +:100B9F0090E6B4EAF0020D9EAA16AB1790E6B3EBFF +:100BAF00F07B0090E6B4EAF0020D9EAA18AB199004 +:100BBF00E6B3EBF07B0090E6B4EAF0020D9E90E610 +:100BCF00BAE0FA90E1A7E0FBC3EA9B4006120914D2 +:100BDF00020D9E90E6BAE0FA75F002A424A8F58201 +:100BEF0074E135F0F583E0FAA3E0FB90E6B3F07B18 +:100BFF000090E6B4EAF0020D9E120914020D9E90C9 +:100C0F00E6B8E0FA53021FBA0002800ABA01028066 +:100C1F001BBA0268802C90E740E4F090E741F09017 +:100C2F00E68AF090E68B7402F0020D9E90E740E4A6 +:100C3F00F090E741F090E68AF090E68B7402F002B4 +:100C4F000D9E90E6BCE0FAF582120A6CE5826026F2 +:100C5F0090E6BCE0FAF582120A8BE0FA530201909B +:100C6F00E740EAF090E741E4F090E68AF090E68BF7 +:100C7F007402F0020D9E120914020D9E1209140245 +:100C8F000D9E120914020D9E90E6B9E0FA24F4505D +:100C9F0003020D9BEA2A2A900CAA73020D9B020CE9 +:100CAF00E3020D61020D42020D9B020D9B020D9B93 +:100CBF00020D9B020D9B020CCE020D9B020CDA5310 +:100CCF00B1BF90E6BAE0F510020D9E90E6BAE0F5DE +:100CDF0011020D9E90E6B8E0FA53021FBA0002808F +:100CEF0005BA024A800A90E6BAE0120914020D9E74 +:100CFF0090E6BAE0703390E6BCE0FAF582120A6C27 +:100D0F00E582602590E6BCE0FAF582120A8BAA8292 +:100D1F00AB83E0FC5304FE8A828B83ECF090E6BC3D +:100D2F00E0FAF58212091D8066120914806112091A +:100D3F0014805C90E6B8E0FA53021FBA005190E6B7 +:100D4F00BAE0FABA01028005BA020280421209140F +:100D5F00803D90E6BAE0FA702E90E6BCE0FAF5829C +:100D6F00120A6CE582601B90E6BCE0FAF582120A6B +:100D7F008BAA82AB83E0FC4304018A828B83ECF065 +:100D8F00800D12091480081209148003120914909F +:100D9F00E6A0E0FA4480F022AA82BA03004005EAF6 +:100DAF00249C500122740F5AFBBB03028007740F5F +:100DBF005AFBBB0B45A2AF9203C2AFEA2400F582E8 +:100DCF00E43400F5837402F07B0074012AFCE43BE9 +:100DDF00FDEC2400F582ED3400F583E51BFCF07487 +:100DEF00022AFAE43BFBEA2400F582EB3400F58398 +:100DFF00AA1A7B00EAF0A20392AF22E582FA2483BB +:100E0F0050012274035AFB600122A2AF9204C2AFB9 +:100E1F00EA2400F582E43401F5837402F07B007458 +:100E2F00012AFCE43BFDEC2400F582ED3401F5834F +:100E3F00E51BFCF074022AFAE43BFBEA2400F5827E +:100E4F00EB3401F583AA1A7B00EAF0A20492AF22D9 +:100E5F00AA82BA80004005EA244B50012274035A3B +:100E6F00FB600122A2AF9205C2AFEA2480F582E4B3 +:100E7F003400F5837402F07B0074012AFCE43BFD1F +:100E8F00EC2480F582ED3400F583E51BFCF0740251 +:100E9F002AFAE43BFBEA2480F582EB3400F583AABF +:100EAF001A7B00EAF0A20592AF22C2E8C2EA751AD5 +:100EBF0000751B01758243120DA7751A80751B00F3 +:100ECF00758253120DA70090E650E4F00090E652A1 +:100EDF00E4F00090E654E4F00090E656E4F0009061 +:100EEF00E65174FFF00090E65374FFF00090E65562 +:100EFF0074FFF00090E65774FFF00090E658E4F0AE +:100F0F0090E65974FFF090E65AE4F090E65B74FFB8 +:100F1F00F090E65CE4F090E65D74FFF090E65EE43E +:100F2F00F090E65F74FFF00090E660E4F00090E66A +:100F3F006174FFF090E662E4F090E66374FFF09066 +:100F4F00E665E4F090E668740BF05391AFD2E8D207 +:100F5F00EA2222AA82120F61DAFB2290FB50A3E54C +:100F6F0082458370F922AA82AB83120F6A1ABAFFE5 +:090F7F00011BBA00F5BB00F222CF +:0D0FAF007581201208F2E5826003020180C6 +:100F880020F71430F6148883A88220F507E6A88392 +:0C0F980075830022E280F7E49322E0223F +:00000001FF diff --git a/usbjtag.iic b/usbjtag.iic new file mode 100644 index 0000000000000000000000000000000000000000..c612e4b086fa93b3a0e934bd804dc359b312d777 GIT binary patch literal 4216 zcmb_feQXow8GrA+yZGBqE}?{ks;LQd3mYO8>O~M zOEWp3x2<48J?K@Hm{G7qujtBs=)$5q*o3&C)6M6_c0Xag0Nnr)P?q1y(j3n7xnaaq2aL;VIB*7-WlCh81A1K&O1-G;@>#)&f$|q z=lIHUh->NiIaR%l$`FgnC8=%T<;Z^-i%(N*2yWWAUU5;3)IS- z1quJe7Rg`OdP1hK4{rZH?q+kPj~fq-I^=I{FFHv}hzs1r<?v4S+)Y6`YG-cC zXjsOU+BRbeOy4`0p0kLbiJP2L zXqw4agvtyYY41c`sL=e$#Ms)v9CmfSn=30|?SwW&!h^A#n44dmjY!+QckG0bx$1R%arG;YumHGn4Jm2Jf zeMj!`9l4J$+r^*L$o_>q3|U?73p?#SC$|#*E~M4JRj?8Pt$sh84gFIt66Ml<irp~)g!**ypyxej7v9cW4rkSy=@Q}yA)?|Sb0mf}PJG59hOWG`Mw+eKVbq)v@ zj9@OOBTj(RNvJvpP3W`%MXpEfjRo}sAjW6J2;N`l0L{RRMl;V)zA#){+J_1&%Qv6t zQH!x)3c3rlvrzBS$9R*Kbjn2wblZZ~Jm-m-;4@AKF z^(suB(w&$%bvGu9vG*tx{(SXx$!9&ucZ%w2=IhKW(E2!-q+?8;)_F``rf7}21CwX4 z*O`z8q5XX@WV66K4d%{?Iql2#?J>GI?^E1XV$p`}IhCf)=Ndq2m%9oV;l z@^e4lPnq>v1)(05ufSz;FvhbvKGesjh6?tZ0xHJfh`JEG ziB06zO^#FT&9$J-H%?eGZYkx~m6_`pRVEtX<;RNieM7YGG{-19zpWhQf&ePafN~3h zg7#ieP)>mg019~%miN}XkVT42Xb-(7UC`c}E-2@wD*|%rMyjARAf=I0)QytwoYFv) zMtFaX01r=7D=V7cVPhK`Ut;46P^7^evB`@z`L0dAN3Z6~z-#6<%D%$b?Uc1E{0}Hg z%RC@N8Qc!$(oXd|8M}+Jugf0j1Vfn{nF4K*Qeelma!@O`p2@45V;%ni)nH5t{J24{ zaE&@DUO~5lO}FbpU(_9romZQR4)c6WiJ{E&+ZT+v+L|Kaw5dVM@?1vTYO={Xbw?w8J!-@P77EHklpCR`E2no8OFD m(R1kAsGffjMbHNHRru~kJJ6d*M!V2Yk;I44-T#C$5&AF5q-=cv literal 0 HcmV?d00001 diff --git a/vectors.a51 b/vectors.a51 new file mode 100644 index 0000000..9ca70bd --- /dev/null +++ b/vectors.a51 @@ -0,0 +1,352 @@ +;;; -*- asm -*- + +;;; + +;;;----------------------------------------------------------------------------- + +;;; Interrupt vectors + +;;;----------------------------------------------------------------------------- + +;;; Code taken from USRP2 firmware (GNU Radio Project), version 3.0.2, + +;;; Copyright 2003 Free Software Foundation, Inc. + +;;;----------------------------------------------------------------------------- + +;;; This code is part of usbjtag. usbjtag is free software; you can redistribute + +;;; it and/or modify it under the terms of the GNU General Public License as + +;;; published by the Free Software Foundation; either version 2 of the License, + +;;; or (at your option) any later version. usbjtag is distributed in the hope + +;;; that it will be useful, but WITHOUT ANY WARRANTY; without even the implied + +;;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + +;;; GNU General Public License for more details. You should have received a + +;;; copy of the GNU General Public License along with this program in the file + +;;; COPYING; if not, write to the Free Software Foundation, Inc., 51 Franklin + +;;; St, Fifth Floor, Boston, MA 02110-1301 USA + +;;;----------------------------------------------------------------------------- + + + +;;; N.B. This object module must come first in the list of modules + + + + .module vectors + + + +;;; ---------------------------------------------------------------- + +;;; standard FX2 interrupt vectors + +;;; ---------------------------------------------------------------- + + + + .area CSEG (CODE) + + .area GSINIT (CODE) + + .area CSEG (CODE) + +__standard_interrupt_vector:: + +__reset_vector:: + + ljmp s_GSINIT + + + + ;; 13 8-byte entries. We point them all at __isr_nop + + ljmp __isr_nop ; 3 bytes + + .ds 5 ; + 5 = 8 bytes for vector slot + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + ljmp __isr_nop + + .ds 5 + + + +__isr_nop:: + + reti + + + +;;; ---------------------------------------------------------------- + +;;; the FIFO/GPIF autovector. 14 4-byte entries. + +;;; must start on a 128 byte boundary. + +;;; ---------------------------------------------------------------- + + + + . = __reset_vector + 0x0080 + + + +__fifo_gpif_autovector:: + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + + + + +;;; ---------------------------------------------------------------- + +;;; the USB autovector. 32 4-byte entries. + +;;; must start on a 256 byte boundary. + +;;; ---------------------------------------------------------------- + + + + . = __reset_vector + 0x0100 + + + +__usb_autovector:: + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + + ljmp __isr_nop + + nop + -- 2.20.1