From 1ec2f43f2c20f90354a407d2ec230f7dfe401841 Mon Sep 17 00:00:00 2001 From: Michael Mann Date: Fri, 20 Jul 2012 01:21:27 +0000 Subject: [PATCH] WiMAX OFDMA PHY SAP dissector plugin (https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=2695) svn path=/trunk/; revision=43844 --- CMakeLists.txt | 1 + Makefile.am | 3 +- Makefile.nmake | 1 + configure.in | 1 + packaging/nsis/Makefile.nmake | 1 + packaging/nsis/wireshark.nsi | 1 + plugins/Makefile.am | 3 +- plugins/Makefile.nmake | 3 +- plugins/wimaxmacphy/AUTHORS | 5 + plugins/wimaxmacphy/COPYING | 340 ++ plugins/wimaxmacphy/ChangeLog | 5 + plugins/wimaxmacphy/Makefile.am | 125 + plugins/wimaxmacphy/Makefile.common | 42 + plugins/wimaxmacphy/Makefile.nmake | 104 + plugins/wimaxmacphy/moduleinfo.h | 18 + plugins/wimaxmacphy/moduleinfo.nmake | 28 + plugins/wimaxmacphy/packet-wimaxmacphy.c | 5492 ++++++++++++++++++++++ plugins/wimaxmacphy/packet-wimaxmacphy.h | 31 + plugins/wimaxmacphy/plugin.rc.in | 34 + 19 files changed, 6235 insertions(+), 3 deletions(-) create mode 100644 plugins/wimaxmacphy/AUTHORS create mode 100644 plugins/wimaxmacphy/COPYING create mode 100644 plugins/wimaxmacphy/ChangeLog create mode 100644 plugins/wimaxmacphy/Makefile.am create mode 100644 plugins/wimaxmacphy/Makefile.common create mode 100644 plugins/wimaxmacphy/Makefile.nmake create mode 100644 plugins/wimaxmacphy/moduleinfo.h create mode 100644 plugins/wimaxmacphy/moduleinfo.nmake create mode 100644 plugins/wimaxmacphy/packet-wimaxmacphy.c create mode 100644 plugins/wimaxmacphy/packet-wimaxmacphy.h create mode 100644 plugins/wimaxmacphy/plugin.rc.in diff --git a/CMakeLists.txt b/CMakeLists.txt index f1eee7e250..d98b8ecc51 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -429,6 +429,7 @@ if(ENABLE_PLUGINS) plugins/unistim plugins/wimax plugins/wimaxasncp + plugins/wimaxmacphy ) # It seems this stuff doesn't build with autofoo either... # if(YAPP_FOUND) diff --git a/Makefile.am b/Makefile.am index 11e9118fae..faec90013d 100644 --- a/Makefile.am +++ b/Makefile.am @@ -283,7 +283,8 @@ plugin_ldadd = $(_CUSTOM_plugin_ldadd_) \ -dlopen plugins/profinet/profinet.la \ -dlopen plugins/stats_tree/stats_tree.la \ -dlopen plugins/unistim/unistim.la \ - -dlopen plugins/wimax/wimax.la + -dlopen plugins/wimax/wimax.la \ + -dlopen plugins/wimaxmacphy/wimaxmacphy.la WTAP_PLUGIN_SOURCES = \ epan/plugins.c \ diff --git a/Makefile.nmake b/Makefile.nmake index 69e44ff1b2..aa091c4be4 100644 --- a/Makefile.nmake +++ b/Makefile.nmake @@ -264,6 +264,7 @@ wireshark.bsc: \ plugins\unistim\*.sbr \ plugins\wimax\*.sbr \ plugins\wimaxasncp\*.sbr \ + plugins\wimaxmacphy\*.sbr \ ui\*.sbr \ ui\cli\*.sbr \ ui\gtk\*.sbr \ diff --git a/configure.in b/configure.in index 3c533c3679..755386c645 100644 --- a/configure.in +++ b/configure.in @@ -2162,6 +2162,7 @@ AC_OUTPUT( plugins/unistim/Makefile plugins/wimax/Makefile plugins/wimaxasncp/Makefile + plugins/wimaxmacphy/Makefile tools/Makefile tools/lemon/Makefile wiretap/Makefile diff --git a/packaging/nsis/Makefile.nmake b/packaging/nsis/Makefile.nmake index 2bc28a1c3e..d174a8c01a 100644 --- a/packaging/nsis/Makefile.nmake +++ b/packaging/nsis/Makefile.nmake @@ -58,6 +58,7 @@ PLUGINS= \ ../../plugins/unistim/unistim.dll \ ../../plugins/wimax/wimax.dll \ ../../plugins/wimaxasncp/wimaxasncp.dll \ + ../../plugins/wimaxmacphy/wimaxmacphy.dll \ $(CUSTOM_PLUGINS) NSI=\ diff --git a/packaging/nsis/wireshark.nsi b/packaging/nsis/wireshark.nsi index 754bcb6d65..9fde73c4dd 100644 --- a/packaging/nsis/wireshark.nsi +++ b/packaging/nsis/wireshark.nsi @@ -816,6 +816,7 @@ File "${STAGING_DIR}\plugins\${VERSION}\profinet.dll" File "${STAGING_DIR}\plugins\${VERSION}\unistim.dll" File "${STAGING_DIR}\plugins\${VERSION}\wimax.dll" File "${STAGING_DIR}\plugins\${VERSION}\wimaxasncp.dll" +File "${STAGING_DIR}\plugins\${VERSION}\wimaxmacphy.dll" !include "custom_plugins.txt" SectionEnd diff --git a/plugins/Makefile.am b/plugins/Makefile.am index 588ec416cf..45d7c765e9 100644 --- a/plugins/Makefile.am +++ b/plugins/Makefile.am @@ -35,7 +35,8 @@ SUBDIRS = $(_CUSTOM_SUBDIRS_) \ stats_tree \ unistim \ wimax \ - wimaxasncp + wimaxasncp \ + wimaxmacphy plugindir = @plugindir@ diff --git a/plugins/Makefile.nmake b/plugins/Makefile.nmake index d76a0e6f4e..2415d9286b 100644 --- a/plugins/Makefile.nmake +++ b/plugins/Makefile.nmake @@ -19,7 +19,8 @@ PLUGIN_LIST = \ stats_tree \ unistim \ wimax \ - wimaxasncp + wimaxasncp \ + wimaxmacphy all: diff --git a/plugins/wimaxmacphy/AUTHORS b/plugins/wimaxmacphy/AUTHORS new file mode 100644 index 0000000000..d67332d9b7 --- /dev/null +++ b/plugins/wimaxmacphy/AUTHORS @@ -0,0 +1,5 @@ +Initial development commissioned by Mobile Metrics - http://mobilemetrics.net/ + +Authors : +Stephen Croll + diff --git a/plugins/wimaxmacphy/COPYING b/plugins/wimaxmacphy/COPYING new file mode 100644 index 0000000000..5cac8f82c5 --- /dev/null +++ b/plugins/wimaxmacphy/COPYING @@ -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 Library 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 Library General +Public License instead of this License. diff --git a/plugins/wimaxmacphy/ChangeLog b/plugins/wimaxmacphy/ChangeLog new file mode 100644 index 0000000000..ce4f0bcc4a --- /dev/null +++ b/plugins/wimaxmacphy/ChangeLog @@ -0,0 +1,5 @@ +2007-08-07 Stephen Croll + + * initial version + + diff --git a/plugins/wimaxmacphy/Makefile.am b/plugins/wimaxmacphy/Makefile.am new file mode 100644 index 0000000000..3015ce87f2 --- /dev/null +++ b/plugins/wimaxmacphy/Makefile.am @@ -0,0 +1,125 @@ +# Makefile.am +# Automake file for wimaxmacphy plugin +# +# $Id$ +# +# Wireshark - Network traffic analyzer +# By Gerald Combs +# Copyright 1998 Gerald Combs +# +# 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. +# + +INCLUDES = -I$(top_srcdir) -I$(includedir) + +include Makefile.common + +if HAVE_WARNINGS_AS_ERRORS +# AM_CFLAGS = -Werror +endif + +plugindir = @plugindir@ + +plugin_LTLIBRARIES = wimaxmacphy.la +wimaxmacphy_la_SOURCES = \ + plugin.c \ + moduleinfo.h \ + $(DISSECTOR_SRC) \ + $(DISSECTOR_SUPPORT_SRC) \ + $(DISSECTOR_INCLUDES) +wimaxmacphy_la_LDFLAGS = -module -avoid-version +wimaxmacphy_la_LIBADD = @PLUGIN_LIBS@ + +# Libs must be cleared, or else libtool won't create a shared module. +# If your module needs to be linked against any particular libraries, +# add them here. +LIBS = + +# +# Build plugin.c, which contains the plugin version[] string, a +# function plugin_register() that calls the register routines for all +# protocols, and a function plugin_reg_handoff() that calls the handoff +# registration routines for all protocols. +# +# We do this by scanning sources. If that turns out to be too slow, +# maybe we could just require every .o file to have an register routine +# of a given name (packet-aarp.o -> proto_register_aarp, etc.). +# +# Formatting conventions: The name of the proto_register_* routines an +# proto_reg_handoff_* routines must start in column zero, or must be +# preceded only by "void " starting in column zero, and must not be +# inside #if. +# +# DISSECTOR_SRC is assumed to have all the files that need to be scanned. +# +# For some unknown reason, having a big "for" loop in the Makefile +# to scan all the files doesn't work with some "make"s; they seem to +# pass only the first few names in the list to the shell, for some +# reason. +# +# Therefore, we have a script to generate the plugin.c file. +# The shell script runs slowly, as multiple greps and seds are run +# for each input file; this is especially slow on Windows. Therefore, +# if Python is present (as indicated by PYTHON being defined), we run +# a faster Python script to do that work instead. +# +# The first argument is the directory in which the source files live. +# The second argument is "plugin", to indicate that we should build +# a plugin.c file for a plugin. +# All subsequent arguments are the files to scan. +# +plugin.c: $(DISSECTOR_SRC) Makefile.common $(top_srcdir)/tools/make-dissector-reg \ + $(top_srcdir)/tools/make-dissector-reg.py + @if test -n "$(PYTHON)"; then \ + echo Making plugin.c with python ; \ + $(PYTHON) $(top_srcdir)/tools/make-dissector-reg.py $(srcdir) \ + plugin $(DISSECTOR_SRC) ; \ + else \ + echo Making plugin.c with shell script ; \ + $(top_srcdir)/tools/make-dissector-reg $(srcdir) \ + $(plugin_src) plugin $(DISSECTOR_SRC) ; \ + fi + +# +# Currently plugin.c can be included in the distribution because +# we always build all protocol dissectors. We used to have to check +# whether or not to build the snmp dissector. If we again need to +# variably build something, making plugin.c non-portable, uncomment +# the dist-hook line below. +# +# Oh, yuk. We don't want to include "plugin.c" in the distribution, as +# its contents depend on the configuration, and therefore we want it +# to be built when the first "make" is done; however, Automake insists +# on putting *all* source into the distribution. +# +# We work around this by having a "dist-hook" rule that deletes +# "plugin.c", so that "dist" won't pick it up. +# +#dist-hook: +# @rm -f $(distdir)/plugin.c + +CLEANFILES = \ + wimaxmacphy \ + *~ + +MAINTAINERCLEANFILES = \ + Makefile.in \ + plugin.c + +EXTRA_DIST = \ + Makefile.common \ + Makefile.nmake \ + moduleinfo.nmake \ + plugin.rc.in diff --git a/plugins/wimaxmacphy/Makefile.common b/plugins/wimaxmacphy/Makefile.common new file mode 100644 index 0000000000..a046d407dc --- /dev/null +++ b/plugins/wimaxmacphy/Makefile.common @@ -0,0 +1,42 @@ +# Makefile.common for wimaxmacphy plugin +# Contains the stuff from Makefile.am and Makefile.nmake that is +# a) common to both files and +# b) portable between both files +# +# $Id$ +# +# Wireshark - Network traffic analyzer +# By Gerald Combs +# Copyright 1998 Gerald Combs +# +# 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. + +# the name of the plugin +PLUGIN_NAME = wimaxmacphy + +# the dissector sources (without any helpers) +DISSECTOR_SRC = \ + packet-wimaxmacphy.c + +# corresponding headers +DISSECTOR_INCLUDES = \ + packet-wimaxmacphy.h + +# Dissector helpers. They're included in the source files in this +# directory, but they're not dissectors themselves, i.e. they're not +# used to generate "register.c"). +DISSECTOR_SUPPORT_SRC = + + diff --git a/plugins/wimaxmacphy/Makefile.nmake b/plugins/wimaxmacphy/Makefile.nmake new file mode 100644 index 0000000000..4553bc4219 --- /dev/null +++ b/plugins/wimaxmacphy/Makefile.nmake @@ -0,0 +1,104 @@ +# Makefile.nmake +# nmake file for wimaxmacphy plugin +# +# $Id$ +# + +include ..\..\config.nmake +include moduleinfo.nmake + +include Makefile.common + +CFLAGS=$(WARNINGS_ARE_ERRORS) $(STANDARD_CFLAGS) \ + /I../.. $(GLIB_CFLAGS) \ + /I$(PCAP_DIR)\include + +.c.obj:: + $(CC) $(CFLAGS) -Fd.\ -c $< + +LDFLAGS = $(PLUGIN_LDFLAGS) + +!IFDEF ENABLE_LIBWIRESHARK +LINK_PLUGIN_WITH=..\..\epan\libwireshark.lib +CFLAGS=/D_NEED_VAR_IMPORT_ $(CFLAGS) + +DISSECTOR_OBJECTS = $(DISSECTOR_SRC:.c=.obj) + +DISSECTOR_SUPPORT_OBJECTS = $(DISSECTOR_SUPPORT_SRC:.c=.obj) + +OBJECTS = $(DISSECTOR_OBJECTS) $(DISSECTOR_SUPPORT_OBJECTS) plugin.obj + +RESOURCE=$(PLUGIN_NAME).res + +all: $(PLUGIN_NAME).dll + +$(PLUGIN_NAME).rc : moduleinfo.nmake + sed -e s/@PLUGIN_NAME@/$(PLUGIN_NAME)/ \ + -e s/@RC_MODULE_VERSION@/$(RC_MODULE_VERSION)/ \ + -e s/@RC_VERSION@/$(RC_VERSION)/ \ + -e s/@MODULE_VERSION@/$(MODULE_VERSION)/ \ + -e s/@PACKAGE@/$(PACKAGE)/ \ + -e s/@VERSION@/$(VERSION)/ \ + -e s/@MSVC_VARIANT@/$(MSVC_VARIANT)/ \ + < plugin.rc.in > $@ + +$(PLUGIN_NAME).dll $(PLUGIN_NAME).exp $(PLUGIN_NAME).lib : $(OBJECTS) $(LINK_PLUGIN_WITH) $(RESOURCE) $(DISSECTOR_INCLUDES) + link -dll /out:$(PLUGIN_NAME).dll $(LDFLAGS) $(OBJECTS) $(LINK_PLUGIN_WITH) \ + $(GLIB_LIBS) $(RESOURCE) + +# +# Build plugin.c, which contains the plugin version[] string, a +# function plugin_register() that calls the register routines for all +# protocols, and a function plugin_reg_handoff() that calls the handoff +# registration routines for all protocols. +# +# We do this by scanning sources. If that turns out to be too slow, +# maybe we could just require every .o file to have an register routine +# of a given name (packet-aarp.o -> proto_register_aarp, etc.). +# +# Formatting conventions: The name of the proto_register_* routines an +# proto_reg_handoff_* routines must start in column zero, or must be +# preceded only by "void " starting in column zero, and must not be +# inside #if. +# +# DISSECTOR_SRC is assumed to have all the files that need to be scanned. +# +# For some unknown reason, having a big "for" loop in the Makefile +# to scan all the files doesn't work with some "make"s; they seem to +# pass only the first few names in the list to the shell, for some +# reason. +# +# Therefore, we have a script to generate the plugin.c file. +# The shell script runs slowly, as multiple greps and seds are run +# for each input file; this is especially slow on Windows. Therefore, +# if Python is present (as indicated by PYTHON being defined), we run +# a faster Python script to do that work instead. +# +# The first argument is the directory in which the source files live. +# The second argument is "plugin", to indicate that we should build +# a plugin.c file for a plugin. +# All subsequent arguments are the files to scan. +# +!IFDEF PYTHON +plugin.c: $(DISSECTOR_SRC) moduleinfo.h Makefile.common ../../tools/make-dissector-reg.py + @echo Making plugin.c (using python) + @$(PYTHON) "../../tools/make-dissector-reg.py" . plugin $(DISSECTOR_SRC) +!ELSE +plugin.c: $(DISSECTOR_SRC) moduleinfo.h Makefile.common ../../tools/make-dissector-reg + @echo Making plugin.c (using sh) + @$(SH) ../../tools/make-dissector-reg . plugin $(DISSECTOR_SRC) +!ENDIF + +!ENDIF + +clean: + rm -f $(OBJECTS) $(RESOURCE) plugin.c *.pdb *.sbr \ + $(PLUGIN_NAME).dll $(PLUGIN_NAME).dll.manifest $(PLUGIN_NAME).lib \ + $(PLUGIN_NAME).exp $(PLUGIN_NAME).rc + +distclean: clean + +maintainer-clean: distclean + +checkapi: + $(PERL) ../../tools/checkAPIs.pl -g abort -g termoutput -build $(DISSECTOR_SRC) $(DISSECTOR_INCLUDES) diff --git a/plugins/wimaxmacphy/moduleinfo.h b/plugins/wimaxmacphy/moduleinfo.h new file mode 100644 index 0000000000..bd8114cb57 --- /dev/null +++ b/plugins/wimaxmacphy/moduleinfo.h @@ -0,0 +1,18 @@ +/* Included *after* config.h, in order to re-define these macros */ + +#ifdef PACKAGE +#undef PACKAGE +#endif + +/* Name of package */ +#define PACKAGE "wimaxmacphy" + + +#ifdef VERSION +#undef VERSION +#endif + +/* Version number of package */ +#define VERSION "0.0.1" + + diff --git a/plugins/wimaxmacphy/moduleinfo.nmake b/plugins/wimaxmacphy/moduleinfo.nmake new file mode 100644 index 0000000000..71017242ec --- /dev/null +++ b/plugins/wimaxmacphy/moduleinfo.nmake @@ -0,0 +1,28 @@ +# +# $Id$ +# + +# The name +PACKAGE=wimaxmacphy + +# The version +MODULE_VERSION_MAJOR=0 +MODULE_VERSION_MINOR=0 +MODULE_VERSION_MICRO=1 +MODULE_VERSION_EXTRA=0 + +# +# The RC_VERSION should be comma-separated, not dot-separated, +# as per Graham Bloice's message in +# +# http://www.ethereal.com/lists/ethereal-dev/200303/msg00283.html +# +# "The RC_VERSION variable in config.nmake should be comma separated. +# This allows the resources to be built correctly and the version +# number to be correctly displayed in the explorer properties dialog +# for the executables, and XP's tooltip, rather than 0.0.0.0." +# + +MODULE_VERSION=$(MODULE_VERSION_MAJOR).$(MODULE_VERSION_MINOR).$(MODULE_VERSION_MICRO).$(MODULE_VERSION_EXTRA) +RC_MODULE_VERSION=$(MODULE_VERSION_MAJOR),$(MODULE_VERSION_MINOR),$(MODULE_VERSION_MICRO),$(MODULE_VERSION_EXTRA) + diff --git a/plugins/wimaxmacphy/packet-wimaxmacphy.c b/plugins/wimaxmacphy/packet-wimaxmacphy.c new file mode 100644 index 0000000000..084ef0bd7b --- /dev/null +++ b/plugins/wimaxmacphy/packet-wimaxmacphy.c @@ -0,0 +1,5492 @@ +/* packet-wimaxmacphy.c + * Routines for wimaxmacphy (WiMAX MAX PHY over Ethernet) packet dissection + * Copyright 2008, Mobile Metrics - http://mobilemetrics.net/ + * + * $Id$ + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * 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. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include + +#include +#include +#include + +/* IF PROTO exposes code to other dissectors, then it must be exported + in a header file. If not, a header file is not needed at all. */ +#include "packet-wimaxmacphy.h" + +/* Forward declaration we need below */ +void proto_reg_handoff_wimaxmacphy(void); + +/* Initialize the protocol and registered fields */ + +static int proto_wimaxmacphy = -1; +static int hf_wimaxmacphy_hdr_phy_entity_id = -1; +static int hf_wimaxmacphy_hdr_message_segmentation = -1; +static int hf_wimaxmacphy_hdr_message_type = -1; +static int hf_wimaxmacphy_unknown = -1; +static int hf_wimaxmacphy_prim_length_of_txvector = -1; +static int hf_wimaxmacphy_prim_length_of_rxvector = -1; +static int hf_wimaxmacphy_prim_status = -1; +static int hf_wimaxmacphy_prim_txstart_indication_status = -1; +static int hf_wimaxmacphy_prim_reserved1 = -1; +static int hf_wimaxmacphy_prim_reserved2 = -1; +static int hf_wimaxmacphy_prim_reserved3 = -1; +static int hf_wimaxmacphy_prim_reserved4 = -1; +static int hf_wimaxmacphy_prim_reserved5 = -1; +static int hf_wimaxmacphy_prim_next_frame_number = -1; +static int hf_wimaxmacphy_prim_extended_frame_number = -1; +static int hf_wimaxmacphy_prim_current_frame_number_lsn = -1; +static int hf_wimaxmacphy_prim_initial_frame_number = -1; +static int hf_wimaxmacphy_prim_dl_zone_number = -1; +static int hf_wimaxmacphy_prim_sub_burst_burst_split_point = -1; +static int hf_wimaxmacphy_prim_dl_sub_burst_burst_number = -1; +static int hf_wimaxmacphy_prim_phy_sdu = -1; +static int hf_wimaxmacphy_prim_phy_request = -1; +static int hf_wimaxmacphy_prim_requested_aas_calibration_zone_size = -1; +static int hf_wimaxmacphy_prim_requested_aas_calibration_zone_alloc = -1; +static int hf_wimaxmacphy_prim_number_of_consecutive_frames_with_aas = -1; +static int hf_wimaxmacphy_prim_frame_number = -1; +static int hf_wimaxmacphy_prim_issid = -1; +static int hf_wimaxmacphy_prim_integrity = -1; +static int hf_wimaxmacphy_prim_number_of_bytes_received = -1; +static int hf_wimaxmacphy_prim_rssi_per_subcarrier_level = -1; +static int hf_wimaxmacphy_prim_cinr = -1; +static int hf_wimaxmacphy_prim_power_offset = -1; +static int hf_wimaxmacphy_prim_current_frame_number_msn = -1; +static int hf_wimaxmacphy_prim_acid_for_harq_data_bursts = -1; +static int hf_wimaxmacphy_prim_indication_type = -1; +static int hf_wimaxmacphy_prim_zone_permutation_type = -1; +static int hf_wimaxmacphy_prim_update_aas_handle_in_mac = -1; +static int hf_wimaxmacphy_prim_aas_handle = -1; +static int hf_wimaxmacphy_prim_time_deviation = -1; +static int hf_wimaxmacphy_prim_frequency_deviation = -1; +static int hf_wimaxmacphy_prim_phy_aas_report_present = -1; +static int hf_wimaxmacphy_prim_number_of_affected_ss = -1; +static int hf_wimaxmacphy_prim_zonexid = -1; +static int hf_wimaxmacphy_prim_cdma_code = -1; +static int hf_wimaxmacphy_prim_cdma_symbol = -1; +static int hf_wimaxmacphy_prim_cdma_subchannel = -1; +static int hf_wimaxmacphy_prim_harq_ack_issid = -1; +static int hf_wimaxmacphy_prim_harq_ack_acid = -1; +static int hf_wimaxmacphy_prim_harq_ack_reserved1 = -1; +static int hf_wimaxmacphy_prim_harq_ack_ack_valid = -1; +static int hf_wimaxmacphy_prim_harq_ack_unnamed = -1; +static int hf_wimaxmacphy_prim_harq_ack_reserved2 = -1; +static int hf_wimaxmacphy_prim_fast_issid = -1; +static int hf_wimaxmacphy_prim_fast_cqich_id = -1; +static int hf_wimaxmacphy_prim_fast_feedback_type_coding = -1; +static int hf_wimaxmacphy_prim_fast_feedback_type_coding_bit0 = -1; +static int hf_wimaxmacphy_prim_fast_feedback_type_coding_bit1 = -1; +static int hf_wimaxmacphy_prim_fast_feedback_type_coding_bit2 = -1; +static int hf_wimaxmacphy_prim_fast_feedback_type_coding_bit3 = -1; +static int hf_wimaxmacphy_prim_fast_feedback_type_coding_bit4 = -1; +static int hf_wimaxmacphy_prim_fast_feedback_type_coding_bit5 = -1; +static int hf_wimaxmacphy_prim_fast_feedback_type_coding_bit6 = -1; +static int hf_wimaxmacphy_prim_fast_feedback_type_coding_bit7 = -1; +static int hf_wimaxmacphy_prim_fast_feedback_valid = -1; +static int hf_wimaxmacphy_prim_fast_feedback_sub_type = -1; +static int hf_wimaxmacphy_prim_fast_reserved = -1; +static int hf_wimaxmacphy_prim_fast_feedback_value = -1; +static int hf_wimaxmacphy_subframe_subframe_type = -1; +static int hf_wimaxmacphy_subframe_frame_number = -1; +static int hf_wimaxmacphy_subframe_downlink_reserved1 = -1; +static int hf_wimaxmacphy_subframe_phy_sap_version_number = -1; +static int hf_wimaxmacphy_subframe_downlink_reserved2 = -1; +static int hf_wimaxmacphy_subframe_allocation_start_time = -1; +static int hf_wimaxmacphy_number_of_zone_descriptors = -1; +static int hf_wimaxmacphy_zone_padding = -1; +static int hf_wimaxmacphy_dl_zone_type = -1; +static int hf_wimaxmacphy_ul_zone_type = -1; +static int hf_wimaxmacphy_zone_number = -1; +static int hf_wimaxmacphy_zone_start_symbol_offset = -1; +static int hf_wimaxmacphy_zone_end_symbol_offset = -1; +static int hf_wimaxmacphy_dl_zone_permutation_type = -1; +static int hf_wimaxmacphy_ul_zone_permutation_type = -1; +static int hf_wimaxmacphy_dl_zone_use_all_subchannels_indicator = -1; +static int hf_wimaxmacphy_ul_zone_use_all_subchannels_indicator = -1; +static int hf_wimaxmacphy_ul_zone_disable_pusc_subchannel_rotation = -1; +static int hf_wimaxmacphy_zone_dl_perm_base = -1; +static int hf_wimaxmacphy_zone_ul_perm_base = -1; +static int hf_wimaxmacphy_zone_prbs_id = -1; +static int hf_wimaxmacphy_zone_agc_range_extension = -1; +static int hf_wimaxmacphy_zone_dedicated_pilots = -1; +static int hf_wimaxmacphy_zone_reserved = -1; +static int hf_wimaxmacphy_zone_stc_type = -1; +static int hf_wimaxmacphy_zone_matrix_indicator = -1; +static int hf_wimaxmacphy_zone_midamble_presence = -1; +static int hf_wimaxmacphy_zone_midamble_boosting = -1; +static int hf_wimaxmacphy_zone_preamble_configuration = -1; +static int hf_wimaxmacphy_zone_sdma_supported_indication = -1; +static int hf_wimaxmacphy_zone_preamble_type = -1; +static int hf_wimaxmacphy_dl_zone_aas_reserved = -1; +static int hf_wimaxmacphy_ul_zone_aas_reserved = -1; +static int hf_wimaxmacphy_number_of_burst_descriptors = -1; +static int hf_wimaxmacphy_burst_padding = -1; +static int hf_wimaxmacphy_dl_burst_type = -1; +static int hf_wimaxmacphy_ul_burst_type = -1; +static int hf_wimaxmacphy_burst_type_extension = -1; +static int hf_wimaxmacphy_burst_number = -1; +static int hf_wimaxmacphy_burst_modulation_fec_code_type = -1; +static int hf_wimaxmacphy_burst_data_length = -1; +static int hf_wimaxmacphy_burst_ofdma_symbol_offset = -1; +static int hf_wimaxmacphy_burst_subchannel_offset = -1; +static int hf_wimaxmacphy_burst_boosting = -1; +static int hf_wimaxmacphy_burst_reserved = -1; +static int hf_wimaxmacphy_burst_repetition_coding_indication = -1; +static int hf_wimaxmacphy_burst_issid = -1; +static int hf_wimaxmacphy_burst_aas_handle = -1; +static int hf_wimaxmacphy_dl_burst_map_number_of_slots = -1; +static int hf_wimaxmacphy_dl_burst_map_reserved = -1; +static int hf_wimaxmacphy_dl_burst_normal_number_of_symbols = -1; +static int hf_wimaxmacphy_dl_burst_normal_number_of_subchannels = -1; +static int hf_wimaxmacphy_dl_burst_normal_aas_handle = -1; +static int hf_wimaxmacphy_ul_burst_normal_number_of_slots = -1; +static int hf_wimaxmacphy_ul_burst_normal_reserved = -1; +static int hf_wimaxmacphy_burst_papr_number_of_symbols = -1; +static int hf_wimaxmacphy_burst_papr_number_of_subchannels = -1; +static int hf_wimaxmacphy_burst_papr_reserved = -1; +static int hf_wimaxmacphy_ul_burst_papr_unnamed = -1; +static int hf_wimaxmacphy_ul_burst_harq_ack_number_of_symbols = -1; +static int hf_wimaxmacphy_ul_burst_harq_ack_number_of_subchannels = -1; +static int hf_wimaxmacphy_ul_burst_harq_ack_reserved = -1; +static int hf_wimaxmacphy_ul_burst_fast_number_of_symbols = -1; +static int hf_wimaxmacphy_ul_burst_fast_number_of_subchannels = -1; +static int hf_wimaxmacphy_ul_burst_fast_reserved = -1; +static int hf_wimaxmacphy_ul_burst_initial_number_of_symbols = -1; +static int hf_wimaxmacphy_ul_burst_initial_number_of_subchannels = -1; +static int hf_wimaxmacphy_ul_burst_initial_ranging_method = -1; +static int hf_wimaxmacphy_ul_burst_initial_reserved1 = -1; +static int hf_wimaxmacphy_ul_burst_initial_zone_xid = -1; +static int hf_wimaxmacphy_ul_burst_initial_reserved2 = -1; +static int hf_wimaxmacphy_ul_burst_periodic_number_of_symbols = -1; +static int hf_wimaxmacphy_ul_burst_periodic_number_of_subchannels = -1; +static int hf_wimaxmacphy_ul_burst_periodic_ranging_method = -1; +static int hf_wimaxmacphy_ul_burst_periodic_reserved1 = -1; +static int hf_wimaxmacphy_ul_burst_periodic_zone_xid = -1; +static int hf_wimaxmacphy_ul_burst_periodic_reserved2 = -1; +static int hf_wimaxmacphy_ul_burst_sounding_number_of_symbols = -1; +static int hf_wimaxmacphy_ul_burst_sounding_number_of_subchannels = -1; +static int hf_wimaxmacphy_ul_burst_sounding_type = -1; +static int hf_wimaxmacphy_ul_burst_sounding_separability_type = -1; +static int hf_wimaxmacphy_ul_burst_sounding_max_cyclic_shift_indx = -1; +static int hf_wimaxmacphy_ul_burst_sounding_decimation_value = -1; +static int hf_wimaxmacphy_ul_burst_sounding_decimation_offset_rand = -1; +static int hf_wimaxmacphy_ul_burst_sounding_reserved = -1; +static int hf_wimaxmacphy_ul_burst_noise_number_of_symbols = -1; +static int hf_wimaxmacphy_ul_burst_noise_number_of_subchannels = -1; +static int hf_wimaxmacphy_ul_burst_noise_reserved = -1; +static int hf_wimaxmacphy_burst_opt_aas_preamble_modifier_type = -1; +static int hf_wimaxmacphy_burst_opt_aas_preamble_shift_index = -1; +static int hf_wimaxmacphy_burst_opt_aas_reserved = -1; +static int hf_wimaxmacphy_burst_opt_mimo_matrix_indicator = -1; +static int hf_wimaxmacphy_burst_opt_mimo_layer_index = -1; +static int hf_wimaxmacphy_dl_burst_opt_mimo_reserved = -1; +static int hf_wimaxmacphy_ul_burst_opt_mimo_matrix_indicator = -1; +static int hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns = -1; +static int hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit0 = -1; +static int hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit1 = -1; +static int hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit2 = -1; +static int hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit3 = -1; +static int hf_wimaxmacphy_ul_burst_opt_mimo_collaborative = -1; +static int hf_wimaxmacphy_ul_burst_opt_mimo_antenna_unnamed = -1; +static int hf_wimaxmacphy_number_of_sub_burst_descriptors = -1; +static int hf_wimaxmacphy_sub_burst_padding = -1; +static int hf_wimaxmacphy_dl_sub_burst_type = -1; +static int hf_wimaxmacphy_ul_sub_burst_type = -1; +static int hf_wimaxmacphy_sub_burst_number = -1; +static int hf_wimaxmacphy_sub_burst_symbol_offset = -1; +static int hf_wimaxmacphy_sub_burst_subchannel_offset = -1; +static int hf_wimaxmacphy_sub_burst_number_of_slots = -1; +static int hf_wimaxmacphy_sub_burst_reserved1 = -1; +static int hf_wimaxmacphy_sub_burst_reserved2 = -1; +static int hf_wimaxmacphy_sub_burst_modulation_fec_code_type = -1; +static int hf_wimaxmacphy_sub_burst_issid = -1; +static int hf_wimaxmacphy_sub_burst_aas_handle = -1; +static int hf_wimaxmacphy_sub_burst_boosting = -1; +static int hf_wimaxmacphy_sub_burst_repetition_coding_indication = -1; +static int hf_wimaxmacphy_sub_burst_data_length = -1; +static int hf_wimaxmacphy_sub_burst_harq_chase_harq_channel_id = -1; +static int hf_wimaxmacphy_sub_burst_harq_chase_harq_sequence_number = -1; +static int hf_wimaxmacphy_sub_burst_harq_chase_flush_unnamed = -1; +static int hf_wimaxmacphy_sub_burst_harq_chase_reserved = -1; +static int hf_wimaxmacphy_sub_burst_mimo_chase_harq_channel_id = -1; +static int hf_wimaxmacphy_sub_burst_mimo_chase_harq_sequence_number = -1; +static int hf_wimaxmacphy_sub_burst_mimo_chase_flush_unnamed = -1; +static int hf_wimaxmacphy_sub_burst_mimo_chase_layer_index = -1; +static int hf_wimaxmacphy_ul_sub_burst_ctype = -1; +static int hf_wimaxmacphy_ul_sub_burst_mini_subchannel_index = -1; +static int hf_wimaxmacphy_ul_sub_burst_mini_reserved = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_type_coding = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit0 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit1 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit2 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit3 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit4 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit5 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit6 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit7 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_reserved1 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_sub_type = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_cqich_id = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_reserved2 = -1; +static int hf_wimaxmacphy_ul_sub_burst_feedback_slot_offset = -1; +static int hf_wimaxmacphy_ul_sub_burst_harq_ack_acid = -1; +static int hf_wimaxmacphy_ul_sub_burst_harq_ack_reserved = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_symbol_index = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_power_assignment = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_power_boost = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_allocation_mode = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_start_freq_band = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_num_freq_bands = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_band_bit_map = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_cyclic_time_shift = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_decimation_offset = -1; +static int hf_wimaxmacphy_ul_sub_burst_sounding_reserved = -1; +static int hf_wimaxmacphy_ul_sub_burst_mimo_chase_matrix = -1; + +/* Initialize the subtree pointers */ +static gint ett_wimaxmacphy = -1; +static gint ett_wimaxmacphy_primitive = -1; +static gint ett_wimaxmacphy_prim_harq_ack = -1; +static gint ett_wimaxmacphy_prim_fast_feedback = -1; +static gint ett_wimaxmacphy_prim_fast_feedback_type_coding = -1; +static gint ett_wimaxmacphy_dl_zone_descriptor = -1; +static gint ett_wimaxmacphy_dl_zone_stc = -1; +static gint ett_wimaxmacphy_dl_zone_aas = -1; +static gint ett_wimaxmacphy_dl_burst_descriptor = -1; +static gint ett_wimaxmacphy_dl_burst_map = -1; +static gint ett_wimaxmacphy_dl_burst_normal = -1; +static gint ett_wimaxmacphy_dl_burst_papr = -1; +static gint ett_wimaxmacphy_dl_sub_burst_descriptor = -1; +static gint ett_wimaxmacphy_dl_sub_burst_harq_chase = -1; +static gint ett_wimaxmacphy_dl_sub_burst_mimo_chase = -1; +static gint ett_wimaxmacphy_dl_burst_opt_aas = -1; +static gint ett_wimaxmacphy_dl_burst_opt_mimo = -1; +static gint ett_wimaxmacphy_ul_zone_descriptor = -1; +static gint ett_wimaxmacphy_ul_zone_aas = -1; +static gint ett_wimaxmacphy_ul_burst_descriptor = -1; +static gint ett_wimaxmacphy_ul_burst_harq_ack = -1; +static gint ett_wimaxmacphy_ul_burst_fast_feedback = -1; +static gint ett_wimaxmacphy_ul_burst_initial_ranging = -1; +static gint ett_wimaxmacphy_ul_burst_periodic_ranging = -1; +static gint ett_wimaxmacphy_ul_burst_papr_safety_zone = -1; +static gint ett_wimaxmacphy_ul_burst_sounding_zone = -1; +static gint ett_wimaxmacphy_ul_burst_noise_floor = -1; +static gint ett_wimaxmacphy_ul_burst_normal_data = -1; +static gint ett_wimaxmacphy_ul_burst_opt_aas = -1; +static gint ett_wimaxmacphy_ul_burst_opt_mimo = -1; +static gint ett_wimaxmacphy_ul_sub_burst_descriptor = -1; +static gint ett_wimaxmacphy_ul_pilot_patterns = -1; +static gint ett_wimaxmacphy_ul_feedback_type_coding = -1; +static gint ett_wimaxmacphy_ul_sub_burst_mini_subchannel = -1; +static gint ett_wimaxmacphy_ul_sub_burst_fast_feedback = -1; +static gint ett_wimaxmacphy_ul_sub_burst_harq_ack = -1; +static gint ett_wimaxmacphy_ul_sub_burst_sounding_signal = -1; +static gint ett_wimaxmacphy_ul_sub_burst_harq_chase = -1; +static gint ett_wimaxmacphy_ul_sub_burst_mimo_chase = -1; +static gint ett_wimaxmacphy_ul_sub_burst_sub_allocation_specific = -1; + +/* Preferences */ +static guint wimaxmacphy_udp_port = 0; + + +/* PHY SAP message header size */ +#define WIMAXMACPHY_HEADER_SIZE 2 + +#define WIMAXMACPHY_BIT(n) (1 << (n)) + +#define WIMAXMACPHY_PHY_TXSTART_REQUEST 1 +#define WIMAXMACPHY_PHY_TXSTART_CONFIRMATION 2 +#define WIMAXMACPHY_PHY_TXSTART_INDICATION 3 +#define WIMAXMACPHY_PHY_TXSDU_REQUEST 4 +#define WIMAXMACPHY_PHY_TXSDU_CONFIRMATION 5 +#define WIMAXMACPHY_PHY_TXEND_INDICATION 6 +#define WIMAXMACPHY_PHY_RXSTART_REQUEST 7 +#define WIMAXMACPHY_PHY_RXSTART_CONFIRMATION 8 +#define WIMAXMACPHY_PHY_RXSTART_INDICATION 9 +#define WIMAXMACPHY_PHY_RXSDU_INDICATION 10 +#define WIMAXMACPHY_PHY_RXEND_INDICATION 11 +#define WIMAXMACPHY_PHY_RXCDMA_INDICATION 15 + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_message_segmentation_vals[] = +{ + { 0x00, "Middle segment of the message segment sequence"}, + { 0x01, "Last segment of the message segment sequence"}, + { 0x02, "First segment of the message segment sequence"}, + { 0x03, "The entire message is contained in this segment"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_message_type_vals[] = +{ + { 0, "Reserved"}, + { 1, "PHY_TXSTART.request"}, + { 2, "PHY_TXSTART.confirmation"}, + { 3, "PHY_TXSTART.indication"}, + { 4, "PHY_TXSDU.request"}, + { 5, "PHY_TXSDU.confirmation"}, + { 6, "PHY_TXEND.indication"}, + { 7, "PHY_RXSTART.request"}, + { 8, "PHY_RXSTART.confirmation"}, + { 9, "PHY_RXSTART.indication"}, + { 10, "PHY_RXSDU.indication"}, + { 11, "PHY_RXEND.indication"}, + { 12, "Reserved (OFDM)"}, + { 13, "Reserved (OFDM)"}, + { 14, "Reserved (OFDM)"}, + { 15, "PHY_RXCDMA.indication"}, + { 16, "Reserved (OFDMA SS)"}, + { 17, "Reserved (OFDMA SS)"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ +/* error code field coding, for all but TXSTART.indication + */ +static const value_string wimaxmacphy_prim_status_vals[]= +{ + { 0, "Success"}, + { 1, "Primitive is not supported"}, + { 2, "FEC code type is not supported"}, + { 3, "Overrun"}, + { 4, "Underrun"}, + { 5, "Transport Media Error"}, + { 6, "TX data size do not match TXVECTOR"}, + { 7, "Invalid RX/TX VECTOR format"}, + { 0, NULL} +}; + +/* --------------------------------------------------------------------------- + * error code field coding, TXSTART.indication specific, delta is description + * for value 1 + */ + +static const value_string wimaxmacphy_prim_txstart_indication_status_vals[]= +{ + { 0, "Success"}, + { 1, "Restart flag"}, + { 2, "FEC code type is not supported"}, + { 3, "Overrun"}, + { 4, "Underrun"}, + { 5, "Transport Media Error"}, + { 6, "TX data size do not match TXVECTOR"}, + { 7, "Invalid RX/TX VECTOR format"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_prim_sub_burst_burst_split_point_vals[]= +{ + { 0x00, "all 10 bits for burst number"}, + { 0x01, "1 bit sub-burst and 9 bits burst number"}, + { 0x02, "2 bit sub-burst and 8 bits burst number"}, + { 0x03, "3 bit sub-burst and 7 bits burst number"}, + { 0x04, "4 bit sub-burst and 6 bits burst number"}, + { 0x05, "5 bit sub-burst and 5 bits burst number"}, + { 0x06, "6 bit sub-burst and 4 bits burst number"}, + { 0x07, "7 bit sub-burst and 3 bits burst number"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_prim_phy_request_vals[]= +{ + { 0x0, "LW 1 not present"}, + { 0x1, "AAS calibration request present in LW 1"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_prim_integrity_vals[]= +{ + { 0, "valid data"}, + { 1, "invalid data"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_prim_indication_type_vals[]= +{ + { 0, "Data burst"}, + { 1, "HARQ ACK channel"}, + { 2, "Fast Feedback Channel"}, + { 3, "HARQ data burst"}, + { 4, "MIMO data burst"}, + { 5, "MIMO HARQ data burst"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_prim_zone_permutation_type_vals[]= +{ + { 0x0, "PUSC"}, + { 0x1, "Optional PUSC"}, + { 0x2, "AMC - 1 x 6"}, + { 0x3, "AMC - 2 x 3"}, + { 0x4, "AMC - 3 x 2"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_prim_phy_aas_report_present_vals[]= +{ + { 0x0, " not present (only LW 0 is significant)"}, + { 0x1, "AAS info aged out report present"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_prim_harq_ack_ack_valid_vals[]= +{ + { 0, "valid data"}, + { 1, "invalid data"}, + { 0, NULL} +}; + +static const true_false_string set_notset = { + "Set", + "Not set" +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_prim_harq_ack_unnamed_vals[]= +{ + { 0, "ACK"}, + { 1, "NAK"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_prim_fast_feedback_valid_vals[]= +{ + { 0, "valid data"}, + { 1, "invalid data"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_prim_fast_feedback_sub_type_vals[]= +{ + { 0, "CQI (CINR) measurement"}, + { 1, "Control feedback"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_subframe_type_vals[]= +{ + { 1, "Downlink Subframe"}, + { 2, "Uplink Subframe"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_dl_zone_type_vals[]= +{ + { 0x20, "Normal Zone Parameters"}, + { 0x21, "STC Zone Parameters"}, + { 0x22, "AAS Zone Parameters"}, + { 0x23, "Common Sync Symbol Parameters"}, + { 0x24, "AAS Calibration Zone"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_zone_type_vals[]= +{ + { 0x20, "Normal Zone Parameters"}, + { 0x21, "Reserved"}, + { 0x22, "AAS Zone Parameters"}, + { 0x23, "Reserved"}, + { 0x24, "Reserved"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_dl_zone_permutation_type_vals[]= +{ + { 0x00, "PUSC"}, + { 0x01, "FUSC"}, + { 0x02, "Optional FUSC"}, + { 0x03, "AMC - 1 x 6"}, + { 0x04, "AMC - 2 x 3"}, + { 0x05, "AMC - 3 x 2"}, + { 0x06, "TUSC1"}, + { 0x07, "TUSC2"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_zone_permutation_type_vals[]= +{ + { 0x00, "PUSC"}, + { 0x01, "FUSC"}, + { 0x02, "Optional FUSC"}, + { 0x03, "AMC - 1 x 6"}, + { 0x04, "AMC - 2 x 3"}, + { 0x05, "AMC - 3 x 2"}, + { 0x06, "Reserved"}, + { 0x07, "Reserved"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_zone_use_all_subchannels_indicator_vals[]= +{ + { 0, "use only subchannels specified in PHY configuration register"}, + { 1, "use all subchannels"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_ul_zone_disable_pusc_subchannel_rotation_vals[]= +{ + { 0, "rotation enabled"}, + { 1, "rotation disabled"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_zone_dedicated_pilots_vals[]= +{ + { 0, "pilots are broadcast"}, + { 1, "pilots are dedicated"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_zone_agc_range_extension_vals[]= +{ + { 0, "default range"}, + { 1, "range to cover SS very close to BS"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_zone_stc_type_vals[]= +{ + { 0x00, "STC using 2 antennas"}, + { 0x01, "STC using 3 antennas"}, + { 0x02, "STC using 4 antennas"}, + { 0x03, "FHDC using 2 antennas"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_matrix_indicator_vals[]= +{ + { 0x00, "Matrix A"}, + { 0x01, "Matrix B"}, + { 0x02, "Matrix C"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_zone_midamble_presence_vals[]= +{ + { 0, "not present"}, + { 1, "present"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_zone_midamble_boosting_vals[]= +{ + { 0, "no boosting"}, + { 1, "boosting"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_zone_preamble_configuration_vals[]= +{ + { 0x00, "0 symbols (preambles not supported)"}, + { 0x01, "1 symbol"}, + { 0x02, "2 symbols"}, + { 0x03, "3 symbols"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_zone_sdma_supported_indication_vals[]= +{ + { 0, "SDMA not supported"}, + { 1, "SDMA supported"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_zone_preamble_type_vals[]= +{ + { 0, "frequency shifted preamble"}, + { 1, "time shifted preamble"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_dl_burst_type_vals[]= +{ + { 0x40, "Map Data Burst"}, + { 0x41, "Normal Data Burst"}, + { 0x42, "Control Command"}, + { 0x43, "PAPR Allocation"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_burst_type_vals[]= +{ + { 0x40, "HARQ ACK Channel allocation"}, + { 0x41, "Fast Feedback Channel allocation"}, + { 0x42, "Initial Ranging/Handover Ranging region"}, + { 0x43, "Periodic Ranging/Bandwidth Request region"}, + { 0x44, "PAPR/Safety Zone allocation"}, + { 0x45, "Sounding Zone allocation"}, + { 0x46, "Noise Floor Calculation allocation"}, + { 0x47, "Normal Data burst"}, + { 0x48, "Control Command"}, + { 0x49, "Reserved"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_burst_type_extension_vals[]= +{ + { 0x00, "no extended data:"}, + { 0x01, "AAS v1"}, + { 0x02, "MIMO v1"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_modulation_fec_code_type_vals[]= +{ + { 0, "QPSK (CC) 1/2"}, + { 1, "QPSK (CC) 3/4"}, + { 2, "16-QAM (CC) 1/2"}, + { 3, "16-QAM (CC) 3/4"}, + { 4, "64-QAM (CC) 1/2"}, + { 5, "64-QAM (CC) 2/3"}, + { 6, "64-QAM (CC) 3/4"}, + { 7, "QPSK (BTC) 1/2"}, + { 8, "QPSK (BTC) 3/4"}, + { 9, "16-QAM (BTC) 3/5"}, + { 10, "16-QAM (BTC) 4/5"}, + { 11, "64-QAM (BTC) 5/8"}, + { 12, "64-QAM (BTC) 4/5"}, + { 13, "QPSK (CTC) 1/2"}, + { 14, "Reserved"}, + { 15, "QPSK (CTC) 3/4"}, + { 16, "16-QAM (CTC) 1/2"}, + { 17, "16-QAM (CTC) 3/4"}, + { 18, "64-QAM (CTC) 1/2"}, + { 19, "64-QAM (CTC) 2/3"}, + { 20, "64-QAM (CTC) 3/4"}, + { 21, "64-QAM (CTC) 5/6"}, + { 22, "QPSK (ZT CC) 1/2"}, + { 23, "QPSK (ZT CC) 3/4"}, + { 24, "16-QAM (ZT CC) 1/2"}, + { 25, "16-QAM (ZT CC) 3/4"}, + { 26, "64-QAM (ZT CC) 1/2"}, + { 27, "64-QAM (ZT CC) 2/3"}, + { 28, "64-QAM (ZT CC) 3/4"}, + { 29, "QPSK (LDPC) 1/2"}, + { 30, "QPSK (LDPC) 2/3 A code"}, + { 31, "QPSK (LDPC) 3/4 A code"}, + { 32, "16-QAM (LDPC) 1/2"}, + { 33, "16-QAM (LDPC) 2/3 A code"}, + { 34, "16-QAM (LDPC) 3/4 A code"}, + { 35, "64-QAM (LDPC) 1/2"}, + { 36, "64-QAM (LDPC) 2/3 A code"}, + { 37, "64-QAM (LDPC) 3/4 A code"}, + { 38, "QPSK (LDPC) 2/3 B code"}, + { 39, "QPSK (LDPC) 3/4 B code"}, + { 40, "16-QAM (LDPC) 2/3 B code"}, + { 41, "16-QAM (LDPC) 3/4 B code"}, + { 42, "64-QAM (LDPC) 2/3 B code"}, + { 43, "64-QAM (LDPC) 3/4 B code"}, + { 44, "QPSK (CC with optional interleaver) 1/2"}, + { 45, "QPSK (CC with optional interleaver) 3/4"}, + { 46, "16-QAM (CC with optional interleaver) 1/2"}, + { 47, "16-QAM (CC with optional interleaver) 3/4"}, + { 48, "64-QAM (CC with optional interleaver) 2/3"}, + { 49, "64-QAM (CC with optional interleaver) 3/4"}, + { 50, "QPSK (LDPC) 5/6"}, + { 51, "16-QAM(LDPC) 5/6"}, + { 52, "64-QAM(LDPC) 5/6"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_burst_boosting_vals[]= +{ + { 0x00, "normal"}, + { 0x01, "+6dB"}, + { 0x02, "-6dB"}, + { 0x03, "+9dB"}, + { 0x04, "+3dB"}, + { 0x05, "-3dB"}, + { 0x06, "-9 dB"}, + { 0x07, "-12 dB"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_burst_repetition_coding_indication_vals[]= +{ + { 0x00, "No repetition coding"}, + { 0x01, "Repetition coding of 2"}, + { 0x02, "Repetition coding of 4"}, + { 0x03, "Repetition coding of 6"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_dl_sub_burst_type_vals[]= +{ + { 0x60, "No HARQ"}, + { 0x61, "HARQ Chase Combining"}, + { 0x62, "HARQ IR-CTC"}, + { 0x63, "HARQ IR-CC"}, + { 0x64, "MIMO Chase Combining"}, + { 0x65, "MIMO IR-CTC"}, + { 0x66, "MIMO IR-CC"}, + { 0x67, "MIMO-STC"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_sub_burst_type_vals[]= +{ + { 0x60, "No HARQ"}, + { 0x61, "HARQ Chase Combining"}, + { 0x62, "HARQ IR-CTC"}, + { 0x63, "HARQ IR-CC"}, + { 0x64, "MIMO Chase Combining"}, + { 0x65, "MIMO IR-CTC"}, + { 0x66, "MIMO IR-CC"}, + { 0x67, "MIMO-STC"}, + { 0x68, "Mini-subchannel"}, + { 0x69, "Fast Feedback channel"}, + { 0x6A, "HARQ ACK subchannel"}, + { 0x6B, "Sounding signal"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_sub_burst_flush_unnamed_vals[]= +{ + { 0x00, "no flush action"}, + { 0x02, "flush request to PHY for the ISSID/ACID"}, + { 0x03, "flush request to PHY for the given ISSID"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_burst_papr_unnamed_vals[]= +{ + { 0, "UL PAPR reduction"}, + { 1, "UL Safety zone"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_burst_ranging_method_vals[]= +{ + { 0, "ranging over 2 symbols"}, + { 1, "ranging over 4 symbols"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_burst_sounding_type_vals[]= +{ + { 0, "Type A"}, + { 1, "Type B"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_ul_burst_sounding_separability_type_vals[]= +{ + { 0, "all subcarriers"}, + { 1, "decimated subcarriers in a band"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_ul_burst_sounding_max_cyclic_shift_indx_vals[]= +{ + { 0x00, "P=4"}, + { 0x01, "P=8;"}, + { 0x02, "P=16"}, + { 0x03, "P=32"}, + { 0x04, "P=9"}, + { 0x05, "P=18"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_ul_burst_sounding_decimation_offset_rand_vals[]= +{ + { 0, "no randomization"}, + { 1, "randomization"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_ul_burst_opt_mimo_matrix_indicator_vals[]= +{ + { 0x00, "Matrix A (STTD)"}, + { 0x01, "Matrix B (SM)"}, + { 0x02, "Reserved"}, + { 0x03, "Reserved"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_burst_opt_mimo_collaborative_vals[]= +{ + { 0, "non-collaborative"}, + { 1, "collaborative"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_burst_opt_mimo_antenna_unnamed_vals[]= +{ + { 0, "Single TX antenna SS"}, + { 1, "Dual TX antenna SS"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_sub_burst_ctype_vals[]= +{ + { 0x00, "2 mini-subchannels adjacent tiles"}, + { 0x01, "2 mini subchannels interleaved tiles"}, + { 0x02, "3 mini subchannels"}, + { 0x03, "6 mini subchannels"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_sub_burst_feedback_sub_type_vals[]= +{ + { 0, "CQI (CINR) measurement"}, + { 1, "Control feedback"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_ul_sub_burst_sounding_power_assignment_vals[]= +{ + { 0x00, "Equal power"}, + { 0x01, "Reserved"}, + { 0x02, "Interference dependent. Per subcarrier power limit."}, + { 0x03, "Interference dependent. Total power limit."}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_sub_burst_sounding_power_boost_vals[]= +{ + { 0, "no boost"}, + { 1, "boost"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static +const value_string wimaxmacphy_ul_sub_burst_sounding_allocation_mode_vals[]= +{ + { 0, "Normal"}, + { 1, "Band AMC"}, + { 0, NULL} +}; + +/* ------------------------------------------------------------------------- */ + +static const value_string wimaxmacphy_ul_sub_burst_mimo_chase_matrix_vals[]= +{ + { 0, "Matrix A"}, + { 1, "Matrix B"}, + { 0, NULL} +}; + +static gint dissect_wimaxmacphy_dl_sub_burst_descriptor(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + guint start_offset = offset; + guint8 sub_burst_type; + proto_item *item; + proto_tree *subtree; + + sub_burst_type = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_dl_sub_burst_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_symbol_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_subchannel_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_number_of_slots, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_reserved1, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_reserved2, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_modulation_fec_code_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_issid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_aas_handle, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_boosting, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_repetition_coding_indication, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_data_length, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + /* sub-burst-specific parts */ + switch (sub_burst_type) + { + case 0x61: /* HARQ chase combining */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "HARQ Chase Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_sub_burst_harq_chase); + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_harq_chase_harq_channel_id, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_harq_chase_harq_sequence_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_harq_chase_flush_unnamed, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_harq_chase_reserved, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + + case 0x64: /* MIMO chase combining */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "MIMO Chase Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_sub_burst_mimo_chase); + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_mimo_chase_harq_channel_id, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_mimo_chase_harq_sequence_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_mimo_chase_flush_unnamed, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_mimo_chase_layer_index, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + + default: + /* do nothing */ + break; + } + + return offset - start_offset; +} + +static guint dissect_wimaxmacphy_dl_burst_descriptor(tvbuff_t *tvb, guint offset, packet_info *pinfo, proto_tree *tree) +{ + guint start_offset = offset; + guint8 burst_type, burst_type_extension, sub_burst_descriptor_count, sub_burst; + proto_item *item, *opt_item; + proto_tree *subtree, *opt_tree; + + burst_type = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_dl_burst_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + burst_type_extension = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_burst_type_extension, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_modulation_fec_code_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_data_length, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_ofdma_symbol_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_subchannel_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_boosting, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_repetition_coding_indication, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* burst-specific parts */ + switch (burst_type) + { + case 0x40: /* map */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "MAP Data Burst Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_burst_map); + + proto_tree_add_item(subtree, hf_wimaxmacphy_dl_burst_map_number_of_slots, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_dl_burst_map_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + + case 0x41: /* normal */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "Normal Data Burst Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_burst_normal); + + proto_tree_add_item(subtree, hf_wimaxmacphy_dl_burst_normal_number_of_symbols, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_dl_burst_normal_number_of_subchannels, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_dl_burst_normal_aas_handle, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* extensions */ + switch (burst_type_extension) + { + case 0x01: /* AAS v1 */ + + opt_item = proto_tree_add_text(tree, tvb, offset, 4, "Optional AAS Specific"); + opt_tree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_burst_opt_aas); + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_burst_opt_aas_preamble_modifier_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_burst_opt_aas_preamble_shift_index, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_burst_opt_aas_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* ??? Algorithm specific Information (per Burst Type extension) */ + break; + + case 0x02: /* MIMO v1 */ + + opt_item = proto_tree_add_text(tree, tvb, offset, 4, "Optional MIMO Specific"); + opt_tree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_burst_opt_mimo); + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_burst_opt_mimo_matrix_indicator, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_burst_opt_mimo_layer_index, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_dl_burst_opt_mimo_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + + /* ??? Algorithm specific Information (per Burst Type extension) */ + break; + + default: + /* do nothing */ + break; + } + + break; + + case 0x43: /* PAPR */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "PAPR Allocation Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_burst_papr); + + proto_tree_add_item(subtree, hf_wimaxmacphy_burst_papr_number_of_symbols, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_burst_papr_number_of_subchannels, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_burst_papr_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + + default: + /* do nothing */ + break; + } + + /* sub-burst portion */ + sub_burst_descriptor_count = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_number_of_sub_burst_descriptors, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_padding, tvb, offset, 3, ENC_BIG_ENDIAN); + offset += 3; + + /* sub-burst descriptors */ + for (sub_burst = 0; sub_burst < sub_burst_descriptor_count; ++sub_burst) + { + proto_item *item; + proto_tree *sub_burst_descriptor_tree; + guint sub_burst_descriptor_length; + + item = proto_tree_add_text(tree, tvb, offset, 1, "Sub-Burst Descriptor %u", sub_burst); + sub_burst_descriptor_tree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_sub_burst_descriptor); + + sub_burst_descriptor_length = dissect_wimaxmacphy_dl_sub_burst_descriptor(tvb, offset, + pinfo, sub_burst_descriptor_tree); + + proto_item_set_len(item, sub_burst_descriptor_length); + offset += sub_burst_descriptor_length; + } + + return offset - start_offset; +} + +static guint dissect_wimaxmacphy_dl_zone_descriptor(tvbuff_t *tvb, guint offset, packet_info *pinfo, proto_tree *tree) +{ + guint start_offset = offset; + guint8 zone_type, burst_descriptor_count, burst; + proto_item *item; + proto_tree *subtree; + + zone_type = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_dl_zone_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_start_symbol_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_end_symbol_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_dl_zone_permutation_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_dl_zone_use_all_subchannels_indicator, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_dl_perm_base, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_prbs_id, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_dedicated_pilots, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_reserved, tvb, offset, 3, ENC_BIG_ENDIAN); + offset += 3; + + /* zone-specific parts */ + switch (zone_type) + { + case 0x21: /* STC */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "STC Zone Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_zone_stc); + + proto_tree_add_item(subtree, hf_wimaxmacphy_zone_stc_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_zone_matrix_indicator, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_zone_midamble_presence, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_zone_midamble_boosting, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + + case 0x22: /* AAS */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "AAS Zone Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_zone_aas); + + proto_tree_add_item(subtree, hf_wimaxmacphy_zone_preamble_configuration, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_zone_sdma_supported_indication, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_dl_zone_aas_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* ??? Algorithm Specific Information (per Zone Type) */ + break; + + default: + /* do nothing */ + break; + } + + /* burst portion */ + burst_descriptor_count = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_number_of_burst_descriptors, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_padding, tvb, offset, 3, ENC_BIG_ENDIAN); + offset += 3; + + /* burst descriptors */ + for (burst = 0; burst < burst_descriptor_count; ++burst) + { + proto_item *item; + proto_tree *burst_descriptor_tree; + guint burst_descriptor_length; + + /* note: we'll adjust the length later */ + item = proto_tree_add_text(tree, tvb, offset, 1, "Burst Descriptor %u", burst); + burst_descriptor_tree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_burst_descriptor); + + burst_descriptor_length = dissect_wimaxmacphy_dl_burst_descriptor( + tvb, offset, pinfo, burst_descriptor_tree); + + proto_item_set_len(item, burst_descriptor_length); + + offset += burst_descriptor_length; + } + + return offset - start_offset; +} + +static guint dissect_wimaxmacphy_dl_subframe_descriptor(tvbuff_t *tvb, guint offset, packet_info *pinfo, proto_tree *tree) +{ + guint start_offset = offset; + guint8 zone_descriptor_count; + guint8 zone; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_subframe_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_frame_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_downlink_reserved1, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_phy_sap_version_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_downlink_reserved2, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + /* zone portion */ + zone_descriptor_count = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_number_of_zone_descriptors, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_number_of_zone_descriptors, tvb, offset, 3, ENC_BIG_ENDIAN); + offset += 3; + + /* zone descriptors */ + for (zone = 0; zone < zone_descriptor_count; ++zone) + { + proto_item *item; + proto_tree *zone_descriptor_tree; + guint zone_descriptor_length; + + item = proto_tree_add_text(tree, tvb, offset, 1, "Zone Descriptor %u", zone); + zone_descriptor_tree = proto_item_add_subtree(item, ett_wimaxmacphy_dl_zone_descriptor); + + zone_descriptor_length = dissect_wimaxmacphy_dl_zone_descriptor( + tvb, offset, pinfo, zone_descriptor_tree); + + proto_item_set_len(item, zone_descriptor_length); + + offset += zone_descriptor_length; + } + + return offset - start_offset; +} + +static gint dissect_wimaxmacphy_ul_sub_burst_sub_allocation_specific_part(tvbuff_t *tvb, guint offset, + packet_info *pinfo _U_, proto_tree *tree, guint8 sub_burst_type) +{ + guint start_offset = offset; + proto_item *item, *opt_item; + proto_tree *subtree, *opt_tree; + + item = proto_tree_add_text(tree, tvb, offset, 1, "Sub-Allocation Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_sub_burst_sub_allocation_specific); + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_symbol_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_subchannel_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_number_of_slots, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_data_length, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_repetition_coding_indication, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_modulation_fec_code_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_sub_burst_reserved1, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* HARQ chase and MIMO chase specific parts */ + switch (sub_burst_type) + { + case 0x61: /* HARQ chase combining */ + + opt_item = proto_tree_add_text(tree, tvb, offset, 4, "HARQ Chase Specific"); + opt_tree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_sub_burst_harq_chase); + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_sub_burst_harq_chase_harq_channel_id, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_sub_burst_harq_chase_harq_sequence_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_sub_burst_harq_chase_flush_unnamed, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_sub_burst_harq_chase_reserved, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + + case 0x64: /* MIMO chase combining */ + + opt_item = proto_tree_add_text(tree, tvb, offset, 4, "MIMO Chase Specific"); + opt_tree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_sub_burst_mimo_chase); + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_sub_burst_mimo_chase_harq_channel_id, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_sub_burst_mimo_chase_harq_sequence_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_sub_burst_mimo_chase_flush_unnamed, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_ul_sub_burst_mimo_chase_matrix, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + + default: + /* do nothing */ + break; + } + + proto_item_set_len(item, offset - start_offset); + + return offset - start_offset; +} + +static gint dissect_wimaxmacphy_ul_sub_burst_descriptor(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + guint8 sub_burst_type; + proto_item *item, *feedback_item; + proto_tree *subtree, *feedback_tree; + guint start_offset = offset; + + sub_burst_type = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_ul_sub_burst_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_issid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_aas_handle, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_reserved1, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* sub-burst-specific parts */ + switch (sub_burst_type) + { + case 0x68: /* mini-subchannel */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "Mini-Subchannel Allocation Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_sub_burst_mini_subchannel); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_ctype, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_mini_subchannel_index, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_mini_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + + case 0x69: /* fast feedback */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "Fast Feedback Allocation Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_sub_burst_fast_feedback); + + feedback_item = proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_feedback_type_coding, tvb, offset, 1, ENC_BIG_ENDIAN); + feedback_tree = proto_item_add_subtree(feedback_item, ett_wimaxmacphy_ul_feedback_type_coding); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit0, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit1, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit2, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit3, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit4, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit5, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit6, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit7, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_feedback_reserved1, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_feedback_sub_type, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_feedback_cqich_id, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_feedback_reserved2, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_feedback_slot_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + + case 0x6a: /* HARQ ACK */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "HARQ ACK Subchannel Allocation Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_sub_burst_harq_ack); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_harq_ack_acid, tvb, offset, 4, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_harq_ack_reserved, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + break; + + case 0x6b: /* sounding signal */ + + item = proto_tree_add_text(tree, tvb, offset, 11, "Sounding Signal Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_sub_burst_sounding_signal); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_symbol_index, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_power_assignment, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_power_boost, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_allocation_mode, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_start_freq_band, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_num_freq_bands, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_band_bit_map, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_cyclic_time_shift, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_decimation_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_sub_burst_sounding_reserved, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + + default: + offset += dissect_wimaxmacphy_ul_sub_burst_sub_allocation_specific_part( + tvb, offset, pinfo, tree, sub_burst_type); + break; + } + + return offset-start_offset; +} + +static guint dissect_wimaxmacphy_ul_burst_descriptor(tvbuff_t *tvb, guint offset, packet_info *pinfo, proto_tree *tree) +{ + guint8 burst_type, burst_type_extension, + sub_burst_descriptor_count, sub_burst; + proto_item *item, *opt_item, *pilot_patterns_item; + proto_tree *subtree, *opt_tree, *pilot_patterns_tree; + guint start_offset = offset; + + burst_type = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_ul_burst_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + burst_type_extension = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_burst_type_extension, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_modulation_fec_code_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_data_length, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_ofdma_symbol_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_subchannel_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_reserved, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_repetition_coding_indication, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_issid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_aas_handle, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* burst-specific parts */ + switch (burst_type) + { + case 0x40: /* HARQ ACK channel */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "HARQ ACK Channel Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_harq_ack); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_harq_ack_number_of_symbols, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_harq_ack_number_of_subchannels, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_harq_ack_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + + case 0x41: /* fast feedback channel */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "Fast Feedback Channel Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_fast_feedback); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_fast_number_of_symbols, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_fast_number_of_subchannels, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_fast_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + + case 0x42: /* initial ranging/handover ranging */ + + item = proto_tree_add_text(tree, tvb, offset, 8, "Initial Ranging/Handover Ranging Allocation Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_initial_ranging); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_initial_number_of_symbols, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_initial_number_of_subchannels, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_initial_ranging_method, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_initial_reserved1, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_initial_zone_xid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_initial_reserved2, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + + case 0x43: /* periodic ranging/bandwidth request */ + + item = proto_tree_add_text(tree, tvb, offset, 8, "Periodic Ranging/Bandwidth Request Allocation Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_periodic_ranging); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_periodic_number_of_symbols, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_periodic_number_of_subchannels, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_periodic_ranging_method, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_periodic_reserved1, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_periodic_zone_xid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_periodic_reserved2, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + + case 0x44: /* PAPR/safety zone */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "PAPR/Safety Zone Channel Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_papr_safety_zone); + + proto_tree_add_item(subtree, hf_wimaxmacphy_burst_papr_number_of_symbols, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_burst_papr_number_of_subchannels, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_papr_unnamed, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_burst_papr_reserved, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + + case 0x45: /* sounding zone */ + + item = proto_tree_add_text(tree, tvb, offset, 8, "Sounding Zone Allocation Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_sounding_zone); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_sounding_number_of_symbols, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_sounding_number_of_subchannels, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_sounding_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_sounding_separability_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_sounding_max_cyclic_shift_indx, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_sounding_decimation_value, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_sounding_decimation_offset_rand, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_sounding_reserved, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + + case 0x46: /* noise floor calculation */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "Noise Floor Calculation Allocation Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_noise_floor); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_noise_number_of_symbols, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_noise_number_of_subchannels, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_noise_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + break; + + case 0x47: /* normal data */ + + item = proto_tree_add_text(tree, tvb, offset, 4, "Normal Data Burst Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_normal_data); + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_normal_number_of_slots, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_ul_burst_normal_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* extensions */ + switch (burst_type_extension) + { + case 0x01: /* AAS v1 */ + + opt_item = proto_tree_add_text(tree, tvb, offset, 4, "Optional AAS Specific"); + opt_tree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_opt_aas); + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_burst_opt_aas_preamble_modifier_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_burst_opt_aas_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_burst_opt_aas_preamble_shift_index, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* ??? Algorithm specific Information (per Burst Type extension) */ + break; + + case 0x02: /* MIMO v1 */ + + opt_item = proto_tree_add_text(tree, tvb, offset, 4, "Optional MIMO Specific"); + opt_tree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_opt_mimo); + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_ul_burst_opt_mimo_matrix_indicator, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* optional MIMO-specific - pilot patterns */ + pilot_patterns_item = proto_tree_add_item(opt_tree, hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns, tvb, offset, 1, ENC_BIG_ENDIAN); + pilot_patterns_tree = proto_item_add_subtree(pilot_patterns_item, ett_wimaxmacphy_ul_pilot_patterns); + proto_tree_add_item(pilot_patterns_tree, hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit0, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(pilot_patterns_tree, hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit1, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(pilot_patterns_tree, hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit2, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(pilot_patterns_tree, hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit3, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_ul_burst_opt_mimo_collaborative, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(opt_tree, hf_wimaxmacphy_ul_burst_opt_mimo_antenna_unnamed, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(opt_tree, hf_wimaxmacphy_burst_opt_mimo_layer_index, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* ??? Algorithm specific Information (per Burst Type extension) */ + break; + + default: + /* do nothing */ + break; + } + + break; + + default: + /* do nothing */ + break; + } + + /* sub-burst portion */ + sub_burst_descriptor_count = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_number_of_sub_burst_descriptors, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_sub_burst_padding, tvb, offset, 3, ENC_BIG_ENDIAN); + offset += 3; + + /* sub-burst descriptors */ + for (sub_burst = 0; sub_burst < sub_burst_descriptor_count; ++sub_burst) + { + proto_tree *sub_burst_descriptor_tree; + guint sub_burst_descriptor_length; + + item = proto_tree_add_text(tree, tvb, offset, 1, "Sub-Burst Descriptor %u", sub_burst); + sub_burst_descriptor_tree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_sub_burst_descriptor); + + sub_burst_descriptor_length = dissect_wimaxmacphy_ul_sub_burst_descriptor(tvb, offset, + pinfo, sub_burst_descriptor_tree); + + proto_item_set_len(item, sub_burst_descriptor_length); + + offset += sub_burst_descriptor_length; + } + + return offset-start_offset; +} + +static guint dissect_wimaxmacphy_ul_zone_descriptor(tvbuff_t *tvb, guint offset, packet_info *pinfo, proto_tree *tree) +{ + guint start_offset = offset; + guint8 zone_type, burst_descriptor_count, burst; + proto_item *item; + + zone_type = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_ul_zone_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_start_symbol_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_end_symbol_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_ul_zone_permutation_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_ul_zone_use_all_subchannels_indicator, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_ul_zone_disable_pusc_subchannel_rotation, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_ul_perm_base, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_agc_range_extension, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* zone-specific parts */ + switch (zone_type) + { + case 0x22: /* AAS */ + { + proto_tree *subtree; + + item = proto_tree_add_text(tree, tvb, offset, 4, "AAS Zone Specific"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_zone_aas); + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_preamble_configuration, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_preamble_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_sdma_supported_indication, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_ul_zone_aas_reserved, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* ??? Algorithm Specific Information (per Zone Type) */ + break; + } + default: + /* do nothing */ + break; + } + + /* burst portion */ + burst_descriptor_count = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_number_of_burst_descriptors, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_burst_padding, tvb, offset, 3, ENC_BIG_ENDIAN); + offset += 3; + + /* burst descriptors */ + for (burst = 0; burst < burst_descriptor_count; ++burst) + { + proto_tree *burst_descriptor_tree; + guint burst_descriptor_length; + + item = proto_tree_add_text(tree, tvb, offset, 1, "Burst Descriptor %u", burst); + burst_descriptor_tree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_burst_descriptor); + + burst_descriptor_length = dissect_wimaxmacphy_ul_burst_descriptor( + tvb, offset, pinfo, burst_descriptor_tree); + proto_item_set_len(item, burst_descriptor_length); + + offset += burst_descriptor_length; + } + + return offset - start_offset; +} + +static guint dissect_wimaxmacphy_ul_subframe_descriptor(tvbuff_t *tvb, guint offset, packet_info *pinfo, proto_tree *tree) +{ + guint start_offset = offset; + guint8 zone_descriptor_count; + guint8 zone; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_subframe_type, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_frame_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_downlink_reserved1, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_phy_sap_version_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_subframe_allocation_start_time, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + zone_descriptor_count = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_number_of_zone_descriptors, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_zone_padding, tvb, offset, 3, ENC_BIG_ENDIAN); + offset += 3; + + /* ----------------------------------------------------------------------- + * zone descriptors + * ----------------------------------------------------------------------- + */ + + for (zone = 0; zone < zone_descriptor_count; ++zone) + { + proto_item *item; + proto_tree *zone_descriptor_tree; + guint zone_descriptor_length; + + item = proto_tree_add_text(tree, tvb, offset, 1, "Zone Descriptor %u", zone); + zone_descriptor_tree = proto_item_add_subtree(item, ett_wimaxmacphy_ul_zone_descriptor); + + zone_descriptor_length = dissect_wimaxmacphy_ul_zone_descriptor( + tvb, offset, pinfo, zone_descriptor_tree); + + proto_item_set_len(item, zone_descriptor_length); + offset += zone_descriptor_length; + } + + return offset-start_offset; +} + +static guint dissect_wimaxmacphy_phy_txstart_request(tvbuff_t *tvb, guint offset, packet_info *pinfo, proto_tree *tree) +{ + guint16 txvector_length; + guint subframe_descriptor_length; + + txvector_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_length_of_txvector, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + subframe_descriptor_length = dissect_wimaxmacphy_dl_subframe_descriptor( + tvb, offset, pinfo, tree); + + offset += subframe_descriptor_length; + + if (subframe_descriptor_length < txvector_length) + proto_tree_add_item(tree, hf_wimaxmacphy_unknown, tvb, offset, txvector_length - subframe_descriptor_length, ENC_NA); + + return txvector_length+2; +} + +static guint dissect_wimaxmacphy_phy_txstart_confirmation(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + proto_tree_add_item(tree, hf_wimaxmacphy_prim_status, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved2, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_next_frame_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + return 2; +} + +static guint dissect_wimaxmacphy_phy_txstart_indication(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + proto_tree_add_item(tree, hf_wimaxmacphy_prim_txstart_indication_status, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_extended_frame_number, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_current_frame_number_lsn, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved1, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_initial_frame_number, tvb, offset, 3, ENC_BIG_ENDIAN); + offset += 3; + + return 6; +} + +static guint dissect_wimaxmacphy_phy_txsdu_request(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + guint length; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_dl_zone_number, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_sub_burst_burst_split_point, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_dl_sub_burst_burst_number, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + length = tvb_reported_length_remaining(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_phy_sdu, tvb, offset, length, ENC_NA); + + return length+2; +} + +static guint dissect_wimaxmacphy_phy_txsdu_confirmation(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + proto_tree_add_item(tree, hf_wimaxmacphy_prim_dl_zone_number, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_sub_burst_burst_split_point, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_dl_sub_burst_burst_number, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved5, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_status, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved2, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_next_frame_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + return 6; +} + +static guint dissect_wimaxmacphy_phy_txend_indication(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + proto_tree_add_item(tree, hf_wimaxmacphy_prim_status, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_phy_request, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_current_frame_number_lsn, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_requested_aas_calibration_zone_size, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_requested_aas_calibration_zone_alloc, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_number_of_consecutive_frames_with_aas, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved5, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + return 6; +} + +static guint dissect_wimaxmacphy_phy_rxstart_request(tvbuff_t *tvb, guint offset, packet_info *pinfo, proto_tree *tree) +{ + guint16 rxvector_length; + guint subframe_descriptor_length; + + rxvector_length = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_length_of_rxvector, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + subframe_descriptor_length = dissect_wimaxmacphy_ul_subframe_descriptor( + tvb, offset, pinfo, tree); + + offset += subframe_descriptor_length; + + /* check for unprocessed bytes */ + if (subframe_descriptor_length < rxvector_length) + proto_tree_add_item(tree, hf_wimaxmacphy_unknown, tvb, offset, rxvector_length - subframe_descriptor_length, ENC_NA); + + return rxvector_length+2; +} + +static guint dissect_wimaxmacphy_phy_rxstart_confirmation(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + proto_tree_add_item(tree, hf_wimaxmacphy_prim_status, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved2, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_frame_number, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + return 2; +} + +static guint dissect_wimaxmacphy_phy_rxstart_indication(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + proto_tree_add_item(tree, hf_wimaxmacphy_prim_status, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved2, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_current_frame_number_lsn, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + return 2; +} + +static guint dissect_wimaxmacphy_phy_rxsdu_indication(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + guint8 indication_type; + proto_item *item, *feedback_item; + proto_tree *subtree, *feedback_tree; + guint length, start_offset = offset; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_issid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_integrity, tvb, offset, 4, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_number_of_bytes_received, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_rssi_per_subcarrier_level, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_cinr, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved1, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_power_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_current_frame_number_msn, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_acid_for_harq_data_bursts, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + indication_type = (tvb_get_guint8(tvb, offset) >> 4) & 0x0F; + proto_tree_add_item(tree, hf_wimaxmacphy_prim_indication_type, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_zone_permutation_type, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_update_aas_handle_in_mac, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_aas_handle, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_time_deviation, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_frequency_deviation, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + switch (indication_type) + { + case 0: /* data burst */ + { + length = tvb_reported_length_remaining(tvb, offset); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_phy_sdu, tvb, offset, length, ENC_NA); + offset += length; + break; + } + case 1: /* HARQ ACK */ + { + item = proto_tree_add_text(tree, tvb, offset, 4, "HARQ ACK channel data format"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_prim_harq_ack); + + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_harq_ack_issid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_harq_ack_acid, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_harq_ack_reserved1, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_harq_ack_ack_valid, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_harq_ack_unnamed, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_harq_ack_reserved2, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + } + case 2: /* fast feedback */ + { + item = proto_tree_add_text(tree, tvb, offset, 8, "Fast Feedback channel data format"); + subtree = proto_item_add_subtree(item, ett_wimaxmacphy_prim_harq_ack); + + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_fast_issid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_fast_cqich_id, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + feedback_item = proto_tree_add_item(subtree, hf_wimaxmacphy_prim_fast_feedback_type_coding, tvb, offset, 1, ENC_BIG_ENDIAN); + feedback_tree = proto_item_add_subtree(feedback_item, ett_wimaxmacphy_prim_fast_feedback_type_coding); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_prim_fast_feedback_type_coding_bit0, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_prim_fast_feedback_type_coding_bit1, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_prim_fast_feedback_type_coding_bit2, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_prim_fast_feedback_type_coding_bit3, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_prim_fast_feedback_type_coding_bit4, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_prim_fast_feedback_type_coding_bit5, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_prim_fast_feedback_type_coding_bit6, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(feedback_tree, hf_wimaxmacphy_prim_fast_feedback_type_coding_bit7, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_fast_feedback_valid, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_fast_feedback_sub_type, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_fast_reserved, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(subtree, hf_wimaxmacphy_prim_fast_feedback_value, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + break; + } + default: + break; + } + + return offset-start_offset; +} + +static guint dissect_wimaxmacphy_phy_rxend_indication(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + guint start_offset = offset; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_status, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_phy_aas_report_present, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_current_frame_number_lsn, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_number_of_affected_ss, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved1, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + do + { + /* list of ISSIDs (at least one required) */ + proto_tree_add_item(tree, hf_wimaxmacphy_prim_issid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + } + while (tvb_reported_length_remaining(tvb, offset)); + + return offset-start_offset; +} + +static guint dissect_wimaxmacphy_phy_rxcdma_indication(tvbuff_t *tvb, guint offset, packet_info *pinfo _U_, proto_tree *tree) +{ + guint start_offset = offset; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_zonexid, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_cdma_code, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_cdma_symbol, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved1, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_cdma_subchannel, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_rssi_per_subcarrier_level, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_cinr, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved3, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_power_offset, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_current_frame_number_msn, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(tree, hf_wimaxmacphy_prim_reserved4, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_aas_handle, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_time_deviation, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, hf_wimaxmacphy_prim_frequency_deviation, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + return offset-start_offset; +} + +static int +dissect_wimaxmacphy(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + /* Set up structures needed to add the protocol subtree and manage it */ + proto_tree *wimaxmacphy_tree, *primitive_tree; + proto_item *item; + + guint offset = 0; + guint8 message_type; + + /* Ensure minimum size */ + if (tvb_length(tvb) < WIMAXMACPHY_HEADER_SIZE) + return 0; + + col_set_str(pinfo->cinfo, COL_PROTOCOL, "wimaxmacphy"); + col_clear(pinfo->cinfo, COL_INFO); + + if (tree) + { + item = proto_tree_add_item(tree, proto_wimaxmacphy, tvb, 0, -1, ENC_NA); + wimaxmacphy_tree = proto_item_add_subtree(item, ett_wimaxmacphy); + + proto_tree_add_item(wimaxmacphy_tree, hf_wimaxmacphy_hdr_phy_entity_id, + tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(wimaxmacphy_tree, hf_wimaxmacphy_hdr_message_segmentation, + tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + message_type = tvb_get_guint8(tvb, offset); + item = proto_tree_add_item(wimaxmacphy_tree, hf_wimaxmacphy_hdr_message_type, + tvb, offset, 1, ENC_BIG_ENDIAN); + + primitive_tree = proto_item_add_subtree(item, ett_wimaxmacphy_primitive); + col_add_str(pinfo->cinfo, COL_INFO, val_to_str(message_type, wimaxmacphy_message_type_vals, "Unknown")); + offset += 1; + + switch(message_type) + { + case WIMAXMACPHY_PHY_TXSTART_REQUEST: + offset += dissect_wimaxmacphy_phy_txstart_request( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_TXSTART_CONFIRMATION: + offset += dissect_wimaxmacphy_phy_txstart_confirmation( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_TXSTART_INDICATION: + offset += dissect_wimaxmacphy_phy_txstart_indication( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_TXSDU_REQUEST: + offset += dissect_wimaxmacphy_phy_txsdu_request( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_TXSDU_CONFIRMATION: + offset += dissect_wimaxmacphy_phy_txsdu_confirmation( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_TXEND_INDICATION: + offset += dissect_wimaxmacphy_phy_txend_indication( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_RXSTART_REQUEST: + offset += dissect_wimaxmacphy_phy_rxstart_request( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_RXSTART_CONFIRMATION: + offset += dissect_wimaxmacphy_phy_rxstart_confirmation( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_RXSTART_INDICATION: + offset += dissect_wimaxmacphy_phy_rxstart_indication( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_RXSDU_INDICATION: + offset += dissect_wimaxmacphy_phy_rxsdu_indication( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_RXEND_INDICATION: + offset += dissect_wimaxmacphy_phy_rxend_indication( + tvb, offset, pinfo, primitive_tree); + break; + case WIMAXMACPHY_PHY_RXCDMA_INDICATION: + offset += dissect_wimaxmacphy_phy_rxcdma_indication( + tvb, offset, pinfo, primitive_tree); + break; + default: + proto_tree_add_item(primitive_tree, hf_wimaxmacphy_unknown, + tvb, offset, tvb_reported_length_remaining(tvb, offset), ENC_NA); + offset += tvb_reported_length_remaining(tvb, offset); + break; + } + + if (tvb_reported_length_remaining(tvb, offset) > 0) + { + /* Incorporate any "extra" bytes */ + item = proto_tree_add_item(wimaxmacphy_tree, hf_wimaxmacphy_unknown, + tvb, offset, tvb_reported_length_remaining(tvb, offset), ENC_NA); + + expert_add_info_format(pinfo, item, PI_MALFORMED, PI_ERROR, "Unexpected bytes"); + } + } + + return tvb_length(tvb); +} + +void +proto_register_wimaxmacphy(void) +{ + module_t *wimaxmacphy_module; + + static hf_register_info hf[] = { + { + &hf_wimaxmacphy_hdr_phy_entity_id, + { + "PHY entity ID", + "wimaxmacphy.hdr_phy_entity_id", + FT_UINT8, + BASE_DEC, + NULL, + 0xfc, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_hdr_message_segmentation, + { + "Message Segmentation", + "wimaxmacphy.hdr_message_segmentation", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_message_segmentation_vals), + 0x03, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_hdr_message_type, + { + "Message Type", + "wimaxmacphy.hdr_message_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_message_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_unknown, + { + "Unknown(!)", + "wimaxmacphy.unknown_primitive", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_length_of_txvector, + { + "Length of TXVECTOR", + "wimaxmacphy.prim_length_of_txvector", + FT_UINT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_length_of_rxvector, + { + "Length of RXVECTOR", + "wimaxmacphy.prim_length_of_rxvector", + FT_UINT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_status, + { + "Status", + "wimaxmacphy.prim_status", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_prim_status_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_txstart_indication_status, + { + "Status", + "wimaxmacphy.prim_status", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_prim_txstart_indication_status_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_reserved1, + { + "Reserved", + "wimaxmacphy.prim_reserved1", + FT_UINT8, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_reserved2, + { + "Reserved", + "wimaxmacphy.prim_reserved2", + FT_UINT8, + BASE_HEX, + NULL, + 0xF0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_reserved3, + { + "Reserved", + "wimaxmacphy.prim_reserved3", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_reserved4, + { + "Reserved", + "wimaxmacphy.prim_reserved4", + FT_UINT16, + BASE_HEX, + NULL, + 0x0FFF, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_reserved5, + { + "Reserved", + "wimaxmacphy.prim_reserved5", + FT_UINT16, + BASE_HEX, + NULL, + 0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_next_frame_number, + { + "Next Frame Number (lsb)", + "wimaxmacphy.prim_next_frame_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_extended_frame_number, + { + "Extended frame number", + "wimaxmacphy.prim_extended_frame_number", + FT_UINT8, + BASE_DEC, + NULL, + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_current_frame_number_lsn, + { + "Current Frame Number (lsb)", + "wimaxmacphy.prim_current_frame_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0f, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_initial_frame_number, + { + "Initial Frame Number (from PHY)", + "wimaxmacphy.prim_initial_frame_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_dl_zone_number, + { + "DL zone number", + "wimaxmacphy.prim_dl_zone_number", + FT_UINT16, + BASE_DEC, + NULL, + 0xe000, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_sub_burst_burst_split_point, + { + "Sub-burst/burst split point", + "wimaxmacphy.prim_sub_burst_burst_split_point", + FT_UINT16, + BASE_DEC, + NULL, + 0x1c00, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_dl_sub_burst_burst_number, + { + "DL sub-burst/burst number in this zone", + "wimaxmacphy.prim_dl_sub_burst_burst_number", + FT_UINT16, + BASE_DEC, + NULL, + 0x03ff, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_phy_sdu, + { + "PHY SDU", + "wimaxmacphy.prim_phy_sdu", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_phy_request, + { + "PHY request (LW 1)", + "wimaxmacphy.prim_phy_request", + FT_UINT8, + BASE_HEX, + NULL, + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_requested_aas_calibration_zone_size, + { + "Requested AAS Calibration Zone size", + "wimaxmacphy.prim_requested_aas_calibration_zone_size", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_requested_aas_calibration_zone_alloc, + { + "Requested AAS Calibration Zone allocation deadline", + "wimaxmacphy.prim_requested_aas_calibration_zone_alloc", + FT_UINT8, + BASE_DEC, + NULL, + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_number_of_consecutive_frames_with_aas, + { + "Number of consecutive frames with AAS Calibration Zone" + " allocation", + "wimaxmacphy.prim_number_of_consecutive_frames_with_aas", + FT_UINT8, + BASE_DEC, + NULL, + 0x0f, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_frame_number, + { + "Frame Number (lsb)", + "wimaxmacphy.prim_frame_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0f, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_issid, + { + "ISSID", + "wimaxmacphy.prim_issid", + FT_INT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_integrity, + { + "Integrity", + "wimaxmacphy.prim_integrity", + FT_UINT32, + BASE_DEC, + VALS(wimaxmacphy_prim_integrity_vals), + 0x80000000, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_number_of_bytes_received, + { + "Number of bytes received", + "wimaxmacphy.prim_number_of_bytes_received", + FT_UINT32, + BASE_DEC, + NULL, + 0x7fffffff, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_rssi_per_subcarrier_level, + { + "RSSI per subcarrier level", + "wimaxmacphy.prim_rssi_per_subcarrier_level", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_cinr, + { + "CINR", + "wimaxmacphy.prim_cinr", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_power_offset, + { + "Power Offset", + "wimaxmacphy.prim_power_offset", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_current_frame_number_msn, + { + "Current Frame Number (lsb)", + "wimaxmacphy.prim_current_frame_number", + FT_UINT8, + BASE_DEC, + NULL, + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_acid_for_harq_data_bursts, + { + "ACID for HARQ data bursts", + "wimaxmacphy.prim_acid_for_harq_data_bursts", + FT_UINT8, + BASE_DEC, + NULL, + 0x0f, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_indication_type, + { + "Indication Type", + "wimaxmacphy.prim_indication_type", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_prim_indication_type_vals), + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_zone_permutation_type, + { + "Zone Permutation Type", + "wimaxmacphy.prim_zone_permutation_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_prim_zone_permutation_type_vals), + 0x0e, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_update_aas_handle_in_mac, + { + "Update AAS handle in MAC", + "wimaxmacphy.prim_update_aas_handle_in_mac", + FT_UINT8, + BASE_HEX, + NULL, + 0x1, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_aas_handle, + { + "AAS Handle", + "wimaxmacphy.prim_aas_handle", + FT_UINT16, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_time_deviation, + { + "Time deviation in units of 1/Fs", + "wimaxmacphy.prim_time_deviation", + FT_INT32, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_frequency_deviation, + { + "Frequency deviation in Hz", + "wimaxmacphy.prim_frequency_deviation", + FT_INT32, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_harq_ack_issid, + { + "ISSID", + "wimaxmacphy.prim_harq_ack_issid", + FT_INT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_harq_ack_acid, + { + "ACID", + "wimaxmacphy.prim_harq_ack_acid", + FT_UINT8, + BASE_DEC, + NULL, + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_harq_ack_reserved1, + { + "Reserved", + "wimaxmacphy.prim_harq_ack_reserved1", + FT_UINT8, + BASE_HEX, + NULL, + 0x0c, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_harq_ack_ack_valid, + { + "ACK Valid", + "wimaxmacphy.prim_harq_ack_ack_valid", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_prim_harq_ack_ack_valid_vals), + 0x2, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_harq_ack_unnamed, + { + "Unnamed", + "wimaxmacphy.prim_harq_ack_unnamed", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_prim_harq_ack_unnamed_vals), + 0x1, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_harq_ack_reserved2, + { + "Reserved", + "wimaxmacphy.prim_harq_ack_reserved2", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_issid, + { + "ISSID", + "wimaxmacphy.prim_fast_issid", + FT_INT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_cqich_id, + { + "CQICH_ID", + "wimaxmacphy.prim_fast_cqich_id", + FT_UINT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_type_coding, + { + "Feedback type coding", + "wimaxmacphy.prim_fast_type_coding", + FT_UINT8, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_type_coding_bit0, + { + "3 bit-MIMO Fast-feedback", + "wimaxmacphy.prim_fast_type_coding.bit0", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x01, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_type_coding_bit1, + { + "Enhanced FAST_FEEDBACK", + "wimaxmacphy.prim_fast_type_coding.bit1", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x02, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_type_coding_bit2, + { + "Reserved", + "wimaxmacphy.prim_fast_type_coding.bit2", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x04, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_type_coding_bit3, + { + "Reserved", + "wimaxmacphy.prim_fast_type_coding.bit3", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x08, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_type_coding_bit4, + { + "UEP fast-feedback", + "wimaxmacphy.prim_fast_type_coding.bit4", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x10, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_type_coding_bit5, + { + "A measurement report performed on the last DL burst", + "wimaxmacphy.prim_fast_type_coding.bit5", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x20, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_type_coding_bit6, + { + "Primary/Secondary FAST_FEEDBACK", + "wimaxmacphy.prim_fast_type_coding.bit6", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x40, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_type_coding_bit7, + { + "DIUC-CQI Fast-feedback", + "wimaxmacphy.prim_fast_type_coding.bit7", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x80, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_valid, + { + "Feedback Valid", + "wimaxmacphy.prim_fast_feedback_valid", + FT_UINT16, + BASE_DEC, + VALS(wimaxmacphy_prim_fast_feedback_valid_vals), + 0x8000, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_sub_type, + { + "Feedback sub-type", + "wimaxmacphy.prim_fast_feedback_sub_type", + FT_UINT8, + BASE_DEC, + VALS( + wimaxmacphy_prim_fast_feedback_sub_type_vals), + 0x7000, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_reserved, + { + "Reserved", + "wimaxmacphy.prim_fast_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_fast_feedback_value, + { + "Feedback value", + "wimaxmacphy.prim_fast_feedback_value", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_phy_aas_report_present, + { + "PHY AAS report present", + "wimaxmacphy.prim_phy_aas_report_present", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_prim_phy_aas_report_present_vals), + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_number_of_affected_ss, + { + "Number of affected SS", + "wimaxmacphy.prim_number_of_affected_ss", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_zonexid, + { + "ZoneXID", + "wimaxmacphy.prim_zonexid", + FT_UINT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_cdma_code, + { + "CDMA code", + "wimaxmacphy.prim_cdma_code", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_cdma_symbol, + { + "CDMA symbol", + "wimaxmacphy.prim_cdma_symbol", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_prim_cdma_subchannel, + { + "CDMA subchannel", + "wimaxmacphy.prim_cdma_subchannel", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_subframe_subframe_type, + { + "Subframe Type", + "wimaxmacphy.subframe_subframe_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_subframe_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_subframe_frame_number, + { + "Frame Number", + "wimaxmacphy.subframe_frame_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_subframe_downlink_reserved1, + { + "Reserved", + "wimaxmacphy.subframe_downlink_reserved1", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_subframe_phy_sap_version_number, + { + "PHY SAP version number", + "wimaxmacphy.subframe_phy_sap_version_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_subframe_downlink_reserved2, + { + "Downlink reserved", + "wimaxmacphy.subframe_downlink_reserved2", + FT_UINT32, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_subframe_allocation_start_time, + { + "Allocation start time", + "wimaxmacphy.subframe_allocation_start_time", + FT_UINT32, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_number_of_zone_descriptors, + { + "Number of Zone Descriptors", + "wimaxmacphy.number_of_zone_descriptors", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_padding, + { + "Padding", + "wimaxmacphy.zone_padding", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_zone_type, + { + "Zone Type", + "wimaxmacphy.zone_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_dl_zone_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_zone_type, + { + "Zone Type", + "wimaxmacphy.zone_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_ul_zone_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_number, + { + "Zone Number", + "wimaxmacphy.zone_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_start_symbol_offset, + { + "Start Symbol Offset", + "wimaxmacphy.zone_start_symbol_offset", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_end_symbol_offset, + { + "End Symbol Offset", + "wimaxmacphy.zone_end_symbol_offset", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_zone_permutation_type, + { + "Permutation Type", + "wimaxmacphy.zone_permutation_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_dl_zone_permutation_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_zone_permutation_type, + { + "Permutation Type", + "wimaxmacphy.zone_permutation_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_ul_zone_permutation_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_zone_use_all_subchannels_indicator, + { + "Use all subchannels indicator", + "wimaxmacphy.zone_use_all_subchannels_indicator", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_zone_use_all_subchannels_indicator_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_zone_use_all_subchannels_indicator, + { + "Use all subchannels indicator", + "wimaxmacphy.zone_use_all_subchannels_indicator", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_zone_use_all_subchannels_indicator_vals), + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_zone_disable_pusc_subchannel_rotation, + { + "Disable PUSC subchannel rotation", + "wimaxmacphy.zone_disable_pusc_subchannel_rotation", + FT_UINT8, + BASE_DEC, + VALS( + wimaxmacphy_ul_zone_disable_pusc_subchannel_rotation_vals), + 0x0f, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_dl_perm_base, + { + "DL_PermBase", + "wimaxmacphy.zone_dl_perm_base", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_ul_perm_base, + { + "UL_PermBase", + "wimaxmacphy.zone_ul_perm_base", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_prbs_id, + { + "PRBS_ID", + "wimaxmacphy.zone_prbs_id", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_dedicated_pilots, + { + "Dedicated pilots", + "wimaxmacphy.zone_dedicated_pilots", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_zone_dedicated_pilots_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_agc_range_extension, + { + "Rx AGC range extension", + "wimaxmacphy.zone_agc_range_extension", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_zone_agc_range_extension_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_reserved, + { + "Reserved", + "wimaxmacphy.zone_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_stc_type, + { + "STC type", + "wimaxmacphy.zone_stc_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_zone_stc_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_matrix_indicator, + { + "Matrix Indicator", + "wimaxmacphy.zone_matrix_indicator", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_matrix_indicator_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_midamble_presence, + { + "Midamble presence", + "wimaxmacphy.zone_midamble_presence", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_zone_midamble_presence_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_midamble_boosting, + { + "Midamble boosting", + "wimaxmacphy.zone_midamble_boosting", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_zone_midamble_boosting_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_preamble_configuration, + { + "Preamble configuration", + "wimaxmacphy.zone_preamble_configuration", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_zone_preamble_configuration_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_sdma_supported_indication, + { + "SDMA supported indication", + "wimaxmacphy.zone_sdma_supported_indication", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_zone_sdma_supported_indication_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_zone_preamble_type, + { + "Preamble type", + "wimaxmacphy.zone_preamble_type", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_zone_preamble_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_zone_aas_reserved, + { + "Reserved", + "wimaxmacphy.zone_aas_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_zone_aas_reserved, + { + "Reserved", + "wimaxmacphy.zone_aas_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_number_of_burst_descriptors, + { + "Number of Burst Descriptors", + "wimaxmacphy.number_of_burst_descriptors", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_padding, + { + "Padding", + "wimaxmacphy.burst_padding", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_burst_type, + { + "Burst Type", + "wimaxmacphy.burst_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_dl_burst_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_type, + { + "Burst Type", + "wimaxmacphy.dl_burst_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_ul_burst_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_type_extension, + { + "Burst Type extension", + "wimaxmacphy.burst_type_extension", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_burst_type_extension_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_number, + { + "Burst Number", + "wimaxmacphy.burst_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_modulation_fec_code_type, + { + "Modulation/FEC Code Type", + "wimaxmacphy.burst_modulation_fec_code_type", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_modulation_fec_code_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_data_length, + { + "Burst Data Length", + "wimaxmacphy.burst_data_length", + FT_UINT32, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_ofdma_symbol_offset, + { + "OFDMA Symbol offset", + "wimaxmacphy.burst_ofdma_symbol_offset", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_subchannel_offset, + { + "Subchannel offset", + "wimaxmacphy.burst_subchannel_offset", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_boosting, + { + "Boosting", + "wimaxmacphy.burst_boosting", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_burst_boosting_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_reserved, + { + "Reserved", + "wimaxmacphy.burst_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_repetition_coding_indication, + { + "Repetition coding indication", + "wimaxmacphy.burst_repetition_coding_indication", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_burst_repetition_coding_indication_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_issid, + { + "ISSID", + "wimaxmacphy.burst_issid", + FT_INT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_aas_handle, + { + "AAS Handle", + "wimaxmacphy.burst_aas_handle", + FT_UINT16, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_burst_map_number_of_slots, + { + "Number of slots (duration) after repetition code is" + " applied", + "wimaxmacphy.burst_map_number_of_slots", + FT_UINT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_burst_map_reserved, + { + "Reserved", + "wimaxmacphy.burst_map_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_burst_normal_number_of_symbols, + { + "Number of Symbols", + "wimaxmacphy.burst_normal_number_of_symbols", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_burst_normal_number_of_subchannels, + { + "Number of Subchannels", + "wimaxmacphy.burst_normal_number_of_subchannels", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_burst_normal_aas_handle, + { + "AAS Handle", + "wimaxmacphy.burst_normal_aas_handle", + FT_UINT16, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_normal_number_of_slots, + { + "Number of slots", + "wimaxmacphy.burst_normal_number_of_slots", + FT_UINT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_normal_reserved, + { + "Reserved", + "wimaxmacphy.burst_normal_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_papr_number_of_symbols, + { + "Number of Symbols", + "wimaxmacphy.burst_papr_number_of_symbols", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_papr_number_of_subchannels, + { + "Number of Subchannels", + "wimaxmacphy.burst_papr_number_of_subchannels", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_papr_reserved, + { + "Reserved", + "wimaxmacphy.burst_papr_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_papr_unnamed, + { + "Unnamed", + "wimaxmacphy.burst_papr_unnamed", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_ul_burst_papr_unnamed_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_harq_ack_number_of_symbols, + { + "Number of Symbols", + "wimaxmacphy.burst_harq_ack_number_of_symbols", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_harq_ack_number_of_subchannels, + { + "Number of Subchannels", + "wimaxmacphy.burst_harq_ack_number_of_subchannels", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_harq_ack_reserved, + { + "Reserved", + "wimaxmacphy.burst_harq_ack_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_fast_number_of_symbols, + { + "Number of Symbols", + "wimaxmacphy.burst_fast_number_of_symbols", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_fast_number_of_subchannels, + { + "Number of Subchannels", + "wimaxmacphy.burst_fast_number_of_subchannels", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_fast_reserved, + { + "Reserved", + "wimaxmacphy.burst_fast_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_initial_number_of_symbols, + { + "Number of Symbols", + "wimaxmacphy.burst_initial_number_of_symbols", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_initial_number_of_subchannels, + { + "Number of Subchannels", + "wimaxmacphy.burst_initial_number_of_subchannels", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_initial_ranging_method, + { + "Ranging method", + "wimaxmacphy.burst_initial_ranging_method", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_ul_burst_ranging_method_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_initial_reserved1, + { + "Reserved", + "wimaxmacphy.burst_initial_reserved1", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_initial_zone_xid, + { + "Zone XID", + "wimaxmacphy.burst_initial_zone_xid", + FT_UINT16, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_initial_reserved2, + { + "Reserved", + "wimaxmacphy.burst_initial_reserved2", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_periodic_number_of_symbols, + { + "Number of Symbols", + "wimaxmacphy.burst_periodic_number_of_symbols", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_periodic_number_of_subchannels, + { + "Number of Subchannels", + "wimaxmacphy.burst_periodic_number_of_subchannels", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_periodic_ranging_method, + { + "Ranging method", + "wimaxmacphy.burst_periodic_ranging_method", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_ul_burst_ranging_method_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_periodic_reserved1, + { + "Reserved", + "wimaxmacphy.burst_periodic_reserved1", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_periodic_zone_xid, + { + "Zone XID", + "wimaxmacphy.burst_periodic_zone_xid", + FT_UINT16, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_periodic_reserved2, + { + "Reserved", + "wimaxmacphy.burst_periodic_reserved2", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_noise_number_of_symbols, + { + "Number of Symbols", + "wimaxmacphy.burst_noise_number_of_symbols", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_noise_number_of_subchannels, + { + "Number of Subchannels", + "wimaxmacphy.burst_noise_number_of_subchannels", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_noise_reserved, + { + "Reserved", + "wimaxmacphy.burst_noise_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_sounding_number_of_symbols, + { + "Number of Symbols", + "wimaxmacphy.burst_sounding_number_of_symbols", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_sounding_number_of_subchannels, + { + "Number of Subchannels", + "wimaxmacphy.burst_sounding_number_of_subchannels", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_sounding_type, + { + "Sounding type", + "wimaxmacphy.burst_sounding_type", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_ul_burst_sounding_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_sounding_separability_type, + { + "Separability type", + "wimaxmacphy.burst_sounding_separability_type", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_ul_burst_sounding_separability_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_sounding_max_cyclic_shift_indx, + { + "Max Cyclic Shift Indx", + "wimaxmacphy.burst_sounding_max_cyclic_shift_indx", + FT_UINT8, + BASE_DEC, + VALS( + wimaxmacphy_ul_burst_sounding_max_cyclic_shift_indx_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_sounding_decimation_value, + { + "Decimation value", + "wimaxmacphy.burst_sounding_decimation_value", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_sounding_decimation_offset_rand, + { + "Decimation offset randomization", + "wimaxmacphy.burst_sounding_decimation_offset_rand", + FT_UINT8, + BASE_DEC, + VALS( + wimaxmacphy_ul_burst_sounding_decimation_offset_rand_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_sounding_reserved, + { + "Reserved", + "wimaxmacphy.burst_sounding_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_opt_aas_preamble_modifier_type, + { + "Preamble Modifier Type", + "wimaxmacphy.burst_opt_aas_preamble_modifier_type", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_opt_aas_preamble_shift_index, + { + "Preamble Shift index", + "wimaxmacphy.burst_opt_aas_preamble_shift_index", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_opt_aas_reserved, + { + "Reserved", + "wimaxmacphy.burst_opt_aas_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_opt_mimo_matrix_indicator, + { + "Matrix indicator", + "wimaxmacphy.burst_opt_mimo_matrix_indicator", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_matrix_indicator_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_burst_opt_mimo_layer_index, + { + "Layer index", + "wimaxmacphy.burst_opt_mimo_layer_index", + FT_UINT8, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_burst_opt_mimo_reserved, + { + "Reserved", + "wimaxmacphy.burst_opt_mimo_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_opt_mimo_matrix_indicator, + { + "Matrix indicator (dual antenna SS)", + "wimaxmacphy.burst_opt_mimo_matrix_indicator", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_ul_burst_opt_mimo_matrix_indicator_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns, + { + "Pilot patterns", + "wimaxmacphy.burst_opt_mimo_pilot_patterns", + FT_UINT8, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit0, + { + "Pattern A", + "wimaxmacphy.burst_opt_mimo_pilot_patterns.A", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x01, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit1, + { + "Pattern B", + "wimaxmacphy.burst_opt_mimo_pilot_patterns.B", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x02, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit2, + { + "Pattern C", + "wimaxmacphy.burst_opt_mimo_pilot_patterns.C", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x04, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_opt_mimo_pilot_patterns_bit3, + { + "Pattern D", + "wimaxmacphy.burst_opt_mimo_pilot_patterns.D", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x08, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_opt_mimo_collaborative, + { + "Collaborative MIMO control", + "wimaxmacphy.burst_opt_mimo_collaborative", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_ul_burst_opt_mimo_collaborative_vals), + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_burst_opt_mimo_antenna_unnamed, + { + "Antenna(?)", + "wimaxmacphy.burst_opt_mimo_antenna_unnamed", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_ul_burst_opt_mimo_antenna_unnamed_vals), + 0x0f, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_number_of_sub_burst_descriptors, + { + "Number of Sub-Burst Descriptors", + "wimaxmacphy.number_of_sub_burst_descriptors", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_padding, + { + "Padding", + "wimaxmacphy.sub_burst_padding", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_dl_sub_burst_type, + { + "Sub-Burst Type", + "wimaxmacphy.sub_burst_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_dl_sub_burst_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_type, + { + "Sub-Burst Type", + "wimaxmacphy.sub_burst_type", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_ul_sub_burst_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_number, + { + "Sub-Burst number", + "wimaxmacphy.sub_burst_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_symbol_offset, + { + "Symbol Offset", + "wimaxmacphy.sub_burst_symbol_offset", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_subchannel_offset, + { + "Subchannel Offset", + "wimaxmacphy.sub_burst_subchannel_offset", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_number_of_slots, + { + "Number of slots in this sub-burst", + "wimaxmacphy.sub_burst_number_of_slots", + FT_UINT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_reserved1, + { + "Reserved", + "wimaxmacphy.sub_burst_reserved1", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_reserved2, + { + "Reserved", + "wimaxmacphy.sub_burst_reserved2", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_modulation_fec_code_type, + { + "Modulation/FEC Code Type", + "wimaxmacphy.sub_burst_modulation_fec_code_type", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_modulation_fec_code_type_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_issid, + { + "ISSID", + "wimaxmacphy.sub_burst_issid", + FT_INT16, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_aas_handle, + { + "AAS Handle", + "wimaxmacphy.sub_burst_aas_handle", + FT_UINT16, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_boosting, + { + "Boosting", + "wimaxmacphy.sub_burst_boosting", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_burst_boosting_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_repetition_coding_indication, + { + "Repetition coding indication", + "wimaxmacphy.sub_burst_repetition_coding_indication", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_burst_repetition_coding_indication_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_data_length, + { + "Sub-Burst Data Length", + "wimaxmacphy.sub_burst_data_length", + FT_UINT32, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_harq_chase_harq_channel_id, + { + "HARQ channeld id (ACID)", + "wimaxmacphy.sub_burst_harq_chase_harq_channel_id", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_harq_chase_harq_sequence_number, + { + "HARQ sequence number (AI_SN)", + "wimaxmacphy.sub_burst_harq_chase_harq_sequence_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_harq_chase_flush_unnamed, + { + "Flush(?)", + "wimaxmacphy.sub_burst_harq_chase_flush_unnamed", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_sub_burst_flush_unnamed_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_harq_chase_reserved, + { + "Reserved", + "wimaxmacphy.sub_burst_harq_chase_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_mimo_chase_harq_channel_id, + { + "HARQ channel id (ACID)", + "wimaxmacphy.sub_burst_mimo_chase_harq_channel_id", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_mimo_chase_harq_sequence_number, + { + "HARQ sequence number (AI_SN)", + "wimaxmacphy.sub_burst_mimo_chase_harq_sequence_number", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_mimo_chase_flush_unnamed, + { + "Flush(?)", + "wimaxmacphy.sub_burst_mimo_chase_flush_unnamed", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_sub_burst_flush_unnamed_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_sub_burst_mimo_chase_layer_index, + { + "Layer index", + "wimaxmacphy.sub_burst_mimo_chase_layer_index", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_ctype, + { + "CType", + "wimaxmacphy.sub_burst_ctype", + FT_UINT8, + BASE_HEX, + VALS(wimaxmacphy_ul_sub_burst_ctype_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_mini_subchannel_index, + { + "Mini-subchannel Index", + "wimaxmacphy.sub_burst_mini_subchannel_index", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_mini_reserved, + { + "Reserved", + "wimaxmacphy.sub_burst_mini_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_type_coding, + { + "Feedback type coding", + "wimaxmacphy.sub_burst_feedback_type_coding", + FT_UINT8, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit0, + { + "3 bit-MIMO Fast-feedback", + "wimaxmacphy.sub_burst_feedback_type_coding.bit0", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x01, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit1, + { + "Enhanced FAST_FEEDBACK", + "wimaxmacphy.sub_burst_feedback_type_coding.bit1", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x02, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit2, + { + "Reserved", + "wimaxmacphy.sub_burst_feedback_type_coding.bit2", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x04, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit3, + { + "Reserved", + "wimaxmacphy.sub_burst_feedback_type_coding.bit3", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x08, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit4, + { + "UEP fast-feedback", + "wimaxmacphy.sub_burst_feedback_type_coding.bit4", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x10, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit5, + { + "A measurement report performed on the last DL burst", + "wimaxmacphy.sub_burst_feedback_type_coding.bit5", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x20, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit6, + { + "Primary/Secondary FAST_FEEDBACK", + "wimaxmacphy.sub_burst_feedback_type_coding.bit6", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x40, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_type_coding_bit7, + { + "DIUC-CQI Fast-feedback", + "wimaxmacphy.sub_burst_feedback_type_coding.bit7", + FT_BOOLEAN, + 8, + TFS(&set_notset), + 0x80, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_reserved1, + { + "Reserved", + "wimaxmacphy.sub_burst_feedback_reserved1", + FT_UINT16, + BASE_DEC, + NULL, + 0x8000, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_sub_type, + { + "Feedback sub-type", + "wimaxmacphy.sub_burst_feedback_sub_type", + FT_UINT16, + BASE_DEC, + NULL, + 0x7000, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_cqich_id, + { + "CQICH_ID", + "wimaxmacphy.sub_burst_feedback_cqich_id", + FT_UINT16, + BASE_DEC, + NULL, + 0x0fff, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_reserved2, + { + "Reserved", + "wimaxmacphy.sub_burst_feedback_reserved2", + FT_UINT8, + BASE_DEC, + NULL, + 0xc0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_feedback_slot_offset, + { + "Slot offset", + "wimaxmacphy.sub_burst_feedback_slot_offset", + FT_UINT8, + BASE_DEC, + NULL, + 0x3f, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_harq_ack_acid, + { + "ACID", + "wimaxmacphy.sub_burst_harq_ack_acid", + FT_UINT8, + BASE_DEC, + NULL, + 0xf0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_harq_ack_reserved, + { + "Reserved", + "wimaxmacphy.sub_burst_harq_ack_reserved", + FT_UINT32, + BASE_HEX, + NULL, + 0x0fff, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_symbol_index, + { + "Sounding symbol index within Sounding zone", + "wimaxmacphy.sub_burst_sounding_symbol_index", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_power_assignment, + { + "Power assignment method", + "wimaxmacphy.sub_burst_sounding_power_assignment_method", + FT_UINT8, + BASE_HEX, + VALS( + wimaxmacphy_ul_sub_burst_sounding_power_assignment_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_power_boost, + { + "Power boost", + "wimaxmacphy.", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_ul_sub_burst_sounding_power_boost_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_allocation_mode, + { + "Allocation mode", + "wimaxmacphy.sub_burst_sounding_allocation_mode", + FT_UINT8, + BASE_DEC, + VALS( + wimaxmacphy_ul_sub_burst_sounding_allocation_mode_vals), + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_start_freq_band, + { + "Start frequency band", + "wimaxmacphy.sub_burst_sounding_start_freq_band", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_num_freq_bands, + { + "Number of frequency bands", + "wimaxmacphy.ub_burst_sounding_num_freq_bands", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_band_bit_map, + { + "Band bit map", + "wimaxmacphy.sub_burst_sounding_band_bit_map", + FT_UINT16, + BASE_HEX, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_cyclic_time_shift, + { + "Cyclic time shift index", + "wimaxmacphy.sub_burst_sounding_cyclic_time_shift_index", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_decimation_offset, + { + "Decimation offset", + "wimaxmacphy.sub_burst_sounding_decimation_offset", + FT_UINT8, + BASE_DEC, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_sounding_reserved, + { + "Reserved", + "wimaxmacphy.sub_burst_sounding_reserved", + FT_BYTES, + BASE_NONE, + NULL, + 0x0, + NULL, + HFILL + } + }, + { + &hf_wimaxmacphy_ul_sub_burst_mimo_chase_matrix, + { + "Matrix (dual antenna SS)", + "wimaxmacphy.sub_burst_mimo_chase_matrix", + FT_UINT8, + BASE_DEC, + VALS(wimaxmacphy_ul_sub_burst_mimo_chase_matrix_vals), + 0x0, + NULL, + HFILL + } + } + }; + + /* Protocol subtree array */ + static gint *ett[] = { + &ett_wimaxmacphy, + &ett_wimaxmacphy_primitive, + &ett_wimaxmacphy_prim_harq_ack, + &ett_wimaxmacphy_prim_fast_feedback, + &ett_wimaxmacphy_prim_fast_feedback_type_coding, + &ett_wimaxmacphy_dl_zone_descriptor, + &ett_wimaxmacphy_dl_zone_stc, + &ett_wimaxmacphy_dl_zone_aas, + &ett_wimaxmacphy_dl_burst_descriptor, + &ett_wimaxmacphy_dl_burst_map, + &ett_wimaxmacphy_dl_burst_normal, + &ett_wimaxmacphy_dl_burst_papr, + &ett_wimaxmacphy_dl_burst_opt_aas, + &ett_wimaxmacphy_dl_burst_opt_mimo, + &ett_wimaxmacphy_dl_sub_burst_descriptor, + &ett_wimaxmacphy_dl_sub_burst_harq_chase, + &ett_wimaxmacphy_dl_sub_burst_mimo_chase, + &ett_wimaxmacphy_ul_zone_descriptor, + &ett_wimaxmacphy_ul_zone_aas, + &ett_wimaxmacphy_ul_burst_descriptor, + &ett_wimaxmacphy_ul_burst_harq_ack, + &ett_wimaxmacphy_ul_burst_fast_feedback, + &ett_wimaxmacphy_ul_burst_initial_ranging, + &ett_wimaxmacphy_ul_burst_periodic_ranging, + &ett_wimaxmacphy_ul_burst_papr_safety_zone, + &ett_wimaxmacphy_ul_burst_sounding_zone, + &ett_wimaxmacphy_ul_burst_noise_floor, + &ett_wimaxmacphy_ul_burst_normal_data, + &ett_wimaxmacphy_ul_burst_opt_aas, + &ett_wimaxmacphy_ul_burst_opt_mimo, + &ett_wimaxmacphy_ul_sub_burst_descriptor, + &ett_wimaxmacphy_ul_sub_burst_mini_subchannel, + &ett_wimaxmacphy_ul_sub_burst_fast_feedback, + &ett_wimaxmacphy_ul_sub_burst_harq_ack, + &ett_wimaxmacphy_ul_sub_burst_sounding_signal, + &ett_wimaxmacphy_ul_sub_burst_harq_chase, + &ett_wimaxmacphy_ul_sub_burst_mimo_chase, + &ett_wimaxmacphy_ul_pilot_patterns, + &ett_wimaxmacphy_ul_feedback_type_coding, + &ett_wimaxmacphy_ul_sub_burst_sub_allocation_specific + }; + + /* Register the protocol name and description */ + proto_wimaxmacphy = proto_register_protocol("WiMAX MAC-PHY over Ethernet", + "WiMAX MAC-PHY", + "wimaxmacphy"); + + /* Required function calls to register the header fields and subtrees + * used */ + proto_register_field_array(proto_wimaxmacphy, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + + /* Register preferences module (See Section 2.6 for more on + * preferences) */ + wimaxmacphy_module = prefs_register_protocol( + proto_wimaxmacphy, + proto_reg_handoff_wimaxmacphy); + + prefs_register_uint_preference(wimaxmacphy_module, "udp.port", + "WiMAX MAX PHY UDP Port", + "WiMAX MAX PHY UDP port", + 10, + &wimaxmacphy_udp_port); + +} + +void +proto_reg_handoff_wimaxmacphy(void) +{ + static guint old_wimaxmacphy_udp_port = 0; + static gboolean inited = FALSE; + static dissector_handle_t wimaxmacphy_handle; + + if (!inited) { + wimaxmacphy_handle = new_create_dissector_handle(dissect_wimaxmacphy, proto_wimaxmacphy); + inited = TRUE; + } + + /* Register UDP port for dissection */ + if(old_wimaxmacphy_udp_port != 0 && old_wimaxmacphy_udp_port != wimaxmacphy_udp_port){ + dissector_delete_uint("udp.port", old_wimaxmacphy_udp_port, wimaxmacphy_handle); + } + + if(wimaxmacphy_udp_port != 0 && old_wimaxmacphy_udp_port != wimaxmacphy_udp_port) { + dissector_add_uint("udp.port", wimaxmacphy_udp_port, wimaxmacphy_handle); + } +} diff --git a/plugins/wimaxmacphy/packet-wimaxmacphy.h b/plugins/wimaxmacphy/packet-wimaxmacphy.h new file mode 100644 index 0000000000..a767d1e158 --- /dev/null +++ b/plugins/wimaxmacphy/packet-wimaxmacphy.h @@ -0,0 +1,31 @@ +/* $Id$ + * + * Routines for wimaxmacphy (WiMAX MAX SHY over Ethernet) packet dissection + * Copyright 2008, Mobile Metrics - http://mobilemetrics.net/ + * + * Wireshark - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __PACKET_WIMAXASNCP_H__ +#define __PACKET_WIMAXASNCP_H__ + +void proto_register_wimaxmacphy (void); +void proto_reg_handoff_wimaxmacphy(void); + +#endif /* __PACKET_WIMAXASNCP_H__ */ diff --git a/plugins/wimaxmacphy/plugin.rc.in b/plugins/wimaxmacphy/plugin.rc.in new file mode 100644 index 0000000000..5ec37b8052 --- /dev/null +++ b/plugins/wimaxmacphy/plugin.rc.in @@ -0,0 +1,34 @@ +#include "winver.h" + +VS_VERSION_INFO VERSIONINFO + FILEVERSION @RC_MODULE_VERSION@ + PRODUCTVERSION @RC_VERSION@ + FILEFLAGSMASK 0x0L +#ifdef _DEBUG + FILEFLAGS VS_FF_DEBUG +#else + FILEFLAGS 0 +#endif + FILEOS VOS_NT_WINDOWS32 + FILETYPE VFT_DLL +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "CompanyName", "The Wireshark developer community, http://www.wireshark.org/\0" + VALUE "FileDescription", "@PACKAGE@ dissector\0" + VALUE "FileVersion", "@MODULE_VERSION@\0" + VALUE "InternalName", "@PACKAGE@ @MODULE_VERSION@\0" + VALUE "LegalCopyright", "Copyright © 1998 Gerald Combs , Gilbert Ramirez and others\0" + VALUE "OriginalFilename", "@PLUGIN_NAME@.dll\0" + VALUE "ProductName", "Wireshark\0" + VALUE "ProductVersion", "@VERSION@\0" + VALUE "Comments", "Build with @MSVC_VARIANT@\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END