pfe_ctrl-10.00.6.tar.gz from sdk-comcerto-openwrt-c2k_3.1-rc4
diff --git a/pfe_ctrl/Makefile b/pfe_ctrl/Makefile
new file mode 100644
index 0000000..03d9bae
--- /dev/null
+++ b/pfe_ctrl/Makefile
@@ -0,0 +1,148 @@
+PLATFORM?=C2000
+UNIT_TEST?=n
+UNIT_TEST_HIF?=n
+#PLATFORM?=EMULATION
+#PLATFORM?=PCI
+#UNIT_TEST?=y
+#UNIT_TEST_HIF?=y
+
+ifeq ($(PLATFORM),C2000)
+CROSS_COMPILE?=/home/upputuv/work/C2000/WiFi/porting_lsdk-10.1.45/sdk-cpe/staging_dir/toolchain-arm_v7-a_gcc-4.5-linaro_glibc-2.14_eabi/bin/arm-openwrt-linux-
+KERNELDIR?=/home/upputuv/work/C2000/WiFi/porting_lsdk-10.1.45/sdk-cpe/build_dir/linux-comcerto2000_hgw/linux-3.2.26
+ARCH=arm
+else
+ARCH=x86
+KERNELDIR=/lib/modules/`uname -r`/build
+endif
+
+# The following must be a relative path, or the kernel build system will fail
+PFE_DIR?=../pfe
+
+PFE_CTRL_VERSION_FILE:=version.h
+
+
+all: version config modules
+
+modules clean:
+ make CROSS_COMPILE=$(CROSS_COMPILE) V=1 ARCH=$(ARCH) -C $(KERNELDIR) M=`pwd` $@
+
+EXTRA_CFLAGS += -Werror -include $(src)/$(PFE_DIR)/c2000/version.h -I$(src)/$(PFE_DIR)/c2000 -I$(src)/$(PFE_DIR)/common -I$(src) -DENDIAN_LITTLE -DGCC_TOOLCHAIN -DCOMCERTO_2000 -DCOMCERTO_2000_CONTROL
+
+EXTRA_LDFLAGS += -T$(src)/control_link.lds
+
+obj-m += pfe.o
+
+pfe_ctrl_objs = $(PFE_DIR)/c2000/__pfe_ctrl.o \
+ $(PFE_DIR)/c2000/pfe.o \
+ $(PFE_DIR)/common/control_ipv4.o \
+ $(PFE_DIR)/common/control_ipv6.o \
+ $(PFE_DIR)/common/ipv6.o \
+ $(PFE_DIR)/common/control_mc4.o \
+ $(PFE_DIR)/common/control_mc6.o \
+ $(PFE_DIR)/common/multicast.o \
+ $(PFE_DIR)/common/control_pppoe.o \
+ $(PFE_DIR)/common/control_vlan.o \
+ $(PFE_DIR)/common/control_macvlan.o \
+ $(PFE_DIR)/common/query_ipv4.o \
+ $(PFE_DIR)/common/query_ipv6.o \
+ $(PFE_DIR)/common/query_mc.o \
+ $(PFE_DIR)/common/query_pppoe.o \
+ $(PFE_DIR)/common/query_vlan.o \
+ $(PFE_DIR)/common/query_tunnel.o \
+ $(PFE_DIR)/common/query_ipsec.o \
+ $(PFE_DIR)/common/query_Rx.o \
+ $(PFE_DIR)/c2000/control_expt.o \
+ $(PFE_DIR)/common/control_tunnel.o \
+ $(PFE_DIR)/common/module_hidrv.o \
+ $(PFE_DIR)/c2000/control_storage.o \
+ $(PFE_DIR)/common/layer2.o \
+ $(PFE_DIR)/common/alt_conf.o \
+ $(PFE_DIR)/common/control_stat.o \
+ $(PFE_DIR)/c2000/control_rx.o \
+ $(PFE_DIR)/c2000/control_tx.o \
+ $(PFE_DIR)/common/control_socket.o \
+ $(PFE_DIR)/common/control_rtp_relay.o \
+ $(PFE_DIR)/common/control_common.o \
+ $(PFE_DIR)/c2000/control_qm.o \
+ $(PFE_DIR)/common/fppdiag_lib.o \
+ $(PFE_DIR)/c2000/control_icc.o \
+ $(PFE_DIR)/common/control_voicebuf.o \
+ $(PFE_DIR)/common/control_ipsec.o \
+ $(PFE_DIR)/c2000/control_ipsec.o \
+ $(PFE_DIR)/c2000/control_ipsec_standalone.o \
+ $(PFE_DIR)/common/control_bridge.o \
+ $(PFE_DIR)/common/control_wifi_rx.o \
+ $(PFE_DIR)/c2000/control_ipsec.o \
+ $(PFE_DIR)/common/control_natpt.o \
+ $(PFE_DIR)/common/control_ipv4frag.o \
+ $(PFE_DIR)/common/control_ipv6frag.o \
+ $(PFE_DIR)/common/control_capture.o \
+ $(PFE_DIR)/c2000/control_l2tp.o \
+
+pfe-y += pfe_mod.o \
+ pfe_hw.o \
+ pfe_firmware.o \
+ pfe_ctrl.o \
+ pfe_ctrl_hal.o \
+ pfe_hif.o \
+ pfe_hif_lib.o\
+ pfe_eth.o \
+ pfe_pcap.o \
+ pfe_vwd.o \
+ pfe_perfmon.o \
+ pfe_tso.o \
+ pfe_sysfs.o \
+ pfe_diags.o \
+ $(pfe_ctrl_objs) \
+
+pfe-$(CONFIG_COMCERTO_MSP) += pfe_mspsync.o
+
+ifeq ($(UNIT_TEST),y)
+pfe-y += pfe_unit_test.o
+EXTRA_CFLAGS+=-DCONFIG_UNIT_TEST
+
+ifeq ($(UNIT_TEST_HIF),y)
+EXTRA_CFLAGS+=-DCONFIG_UNIT_TEST_HIF
+endif
+
+endif
+
+ifeq ($(PLATFORM),C2000)
+pfe-y += pfe_platform.o
+EXTRA_CFLAGS+=-DCONFIG_PLATFORM_C2000
+else ifeq ($(PLATFORM),PCI)
+pfe-y += pfe_pci.o
+EXTRA_CFLAGS+=-DCONFIG_PLATFORM_PCI
+EXTRA_CFLAGS+=-DCONFIG_UTIL_DISABLED
+#EXTRA_CFLAGS+=-DCONFIG_TMU_DUMMY
+else ifeq ($(PLATFORM),EMULATION)
+pfe-y += pfe_emulation.o
+EXTRA_CFLAGS+=-DCONFIG_PLATFORM_EMULATION
+endif
+
+distclean:
+ rm -rf pfe_ctrl-src.tar.gz pfe-src.tar.gz
+
+dist: all pfe_release_tar
+ pfe_ctrl_files="`find . -name '*.h'; find . -name '*.c'; find . -name '*.lds'; find . -name 'Makefile'`"; tar -czf pfe_ctrl-src.tar.gz $$pfe_ctrl_files
+
+pfe_release_tar:
+ pfe_files="`find $(PFE_DIR)/c2000 -name '*.h'; find $(PFE_DIR)/common -name '*.h'` $(PFE_DIR)/Makefile $(PFE_DIR)/config.mk $(PFE_DIR)/c2000/config.mk $(PFE_DIR)/toolchain.mk $(PFE_DIR)/license.txt $(PFE_DIR)/license_full.txt $(pfe_ctrl_objs:.o=.c)"; tar -cf pfe-src.tar $$pfe_files; tar -xf pfe-src.tar;bash pfe_licence.sh `basename $(PFE_DIR)`; rm `basename $(PFE_DIR)`/license.txt `basename $(PFE_DIR)`/license_full.txt;tar -czf pfe-src.tar.gz `basename $(PFE_DIR)`
+
+version:
+ if [ -d .git ]; then \
+ make -C $(PFE_DIR) version ; \
+ PFE_CTRL_GIT_VERSION=$$(git describe --always --tags --dirty) ; \
+ printf "/*Auto-generated file. Do not edit !*/\n#ifndef VERSION_H\n#define VERSION_H\n\n#define PFE_CTRL_VERSION \"$${PFE_CTRL_GIT_VERSION}\"\n\n#endif /* VERSION_H */\n" > $(PFE_CTRL_VERSION_FILE) ; \
+ fi
+
+config:
+ make -C $(PFE_DIR) config_check
+
+PFE_BIN_DIR=$(PFE_DIR)/obj_c2000/
+CLASS_BIN=$(PFE_BIN_DIR)/class/class_c2000_debug.elf
+UTIL_BIN=$(PFE_BIN_DIR)/util/util_c2000_debug.elf
+TMU_BIN=$(PFE_BIN_DIR)/tmu/tmu_c2000_debug.elf
+check_dmem:
+ ./check_shared_mem.py pfe.ko $(CLASS_BIN) $(TMU_BIN) $(UTIL_BIN)
+
diff --git a/pfe_ctrl/check_shared_mem.py b/pfe_ctrl/check_shared_mem.py
new file mode 100755
index 0000000..d6832a3
--- /dev/null
+++ b/pfe_ctrl/check_shared_mem.py
@@ -0,0 +1,100 @@
+#! /usr/bin/python
+
+import os, sys, string
+
+if sys.stdout.isatty():
+ OKBLUE = '\033[94m'
+ OKGREEN = '\033[92m'
+ WARNING = '\033[93m'
+ FAIL = '\033[91m'
+ ENDC = '\033[0m'
+ BOLD = "\033[1m"
+else:
+ OKBLUE = ''
+ OKGREEN = ''
+ WARNING = ''
+ FAIL = ''
+ ENDC = ''
+ BOLD = ''
+
+
+def hex_conv(s):
+ return int(s, 16)
+
+def parse_objdump(objdump_cmd):
+ syms = {}
+ for line in os.popen(objdump_cmd):
+ fields = line.split()
+ if len(fields) == 6:
+ if fields[3] == fields[5]:
+ start = hex_conv(fields[0])
+ else:
+ symbol = fields[5].replace("class_", "")
+ symbol = symbol.replace("util_", "")
+ symbol = symbol.replace("tmu_", "")
+ symbol = symbol.replace("mailbox", "mbox")
+ syms[symbol] = (hex_conv(fields[0]), hex_conv(fields[4]))
+ for sym in syms.keys():
+ (addr, size) = syms[sym]
+ syms[sym] = (addr-start, size)
+
+ return syms
+
+def one_way_compare(filename1, syms1, filename2, syms2):
+ list1 = syms1.keys()
+ list2 = syms2.keys()
+ err = 0
+
+ for sym in list1:
+ if sym not in list2:
+ print(WARNING + "ERROR: symbol " + sym + " present in " + filename1 + " but not in " +filename2 + ENDC)
+ err += 1
+ else:
+ (addr1, size1) = syms1[sym]
+ (addr2, size2) = syms2[sym]
+ if addr1 != addr2:
+ print(WARNING + "ERROR: symbol "+ sym + " at address " + str(addr1) + " in " + filename1 + ", at address " + str(addr2) + " in " + filename2 + ENDC)
+ syms2.pop(sym)
+ err += 1
+ if size1 != size2:
+ print(WARNING + "ERROR: symbol "+ sym + " has size " + str(size1) + " in " + filename1 + ", but size " + str(size2) + " in " + filename2 + ENDC)
+ syms2.pop(sym)
+ err += 1
+ return err
+
+
+
+def compare_shared_mem(ctrl_filename, pe, filename):
+
+ print("Comparing memory for "+ pe + " shared memory...")
+ sym_ctrl = parse_objdump("objdump -j ." + pe + "_dmem_sh -t " + sys.argv[1])
+
+ sym_pfe = parse_objdump("objdump -j .dmem_sh -t "+ filename)
+
+ err1 = one_way_compare(ctrl_filename, sym_ctrl, filename, sym_pfe)
+ err2 = one_way_compare(filename, sym_pfe, ctrl_filename, sym_ctrl)
+
+ if (err1 + err2) != 0:
+ print(FAIL + BOLD + pe + " ERROR: " + ctrl_filename + " and " + filename + " don't match." + ENDC)
+ else:
+ print(OKGREEN + BOLD + pe + " OK." + ENDC)
+ print("")
+
+ return err1 + err2
+
+# Main
+if __name__=="__main__":
+ if len(sys.argv)<3:
+ print("Usage: " + sys.argv[0] + " <pfe.ko file> <class ELF file> <tmu ELF file> <util ELF file>")
+ sys.exit(1)
+
+ compare_list = []
+ compare_list.append(("class", sys.argv[2]))
+ compare_list.append(("tmu", sys.argv[3]))
+ compare_list.append(("util", sys.argv[4]))
+
+ ret = 0
+ for (pe, filename) in compare_list:
+ ret += compare_shared_mem(sys.argv[1], pe, filename)
+
+ exit(ret)
diff --git a/pfe_ctrl/control_link.lds b/pfe_ctrl/control_link.lds
new file mode 100644
index 0000000..5771659
--- /dev/null
+++ b/pfe_ctrl/control_link.lds
@@ -0,0 +1,27 @@
+SECTIONS
+{
+ .class_dmem_sh : SUBALIGN(8) {
+ __class_dmem_sh = .;
+ *(SORT(.class_dmem_sh_*))
+ }
+
+ .class_pe_lmem_sh : SUBALIGN(8) {
+ __class_pe_lmem_sh = .;
+ *(SORT(.class_pe_lmem_sh_*))
+ }
+
+ .tmu_dmem_sh : SUBALIGN(8) {
+ __tmu_dmem_sh = .;
+ *(SORT(.tmu_dmem_sh_*))
+ }
+
+ .util_dmem_sh : SUBALIGN(8) {
+ __util_dmem_sh = .;
+ *(SORT(.util_dmem_sh_*))
+ }
+
+ .util_ddr_sh : SUBALIGN(8) {
+ __util_ddr_sh = .;
+ *(SORT(.util_ddr_sh_*))
+ }
+}
diff --git a/pfe_ctrl/doxygen/Doxyfile b/pfe_ctrl/doxygen/Doxyfile
new file mode 100644
index 0000000..2a8106e
--- /dev/null
+++ b/pfe_ctrl/doxygen/Doxyfile
@@ -0,0 +1,1661 @@
+# Doxyfile 1.7.1
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+# TAG = value [value, ...]
+# For lists items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
+# by quotes) that should identify the project.
+
+PROJECT_NAME = pfe
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY = .
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak,
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF = "The $name class" \
+ "The $name widget" \
+ "The $name file" \
+ is \
+ provides \
+ specifies \
+ contains \
+ represents \
+ a \
+ an \
+ the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful is your file systems
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF = YES
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE = 8
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C = YES
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given extension.
+# Doxygen has a built-in mapping, but you can override or extend it using this
+# tag. The format is ext=language, where ext is a file extension, and language
+# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
+# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
+# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
+# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+
+EXTENSION_MAPPING =
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen to replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING = YES
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
+# determine which symbols to keep in memory and which to flush to disk.
+# When the cache is full, less often used symbols will be written to disk.
+# For small to medium size projects (<1000 input files) the default value is
+# probably good enough. For larger projects a too small cache size can cause
+# doxygen to be busy swapping symbols to and from disk most of the time
+# causing a significant performance penality.
+# If the system has enough physical memory increasing the cache will improve the
+# performance by keeping more symbols in memory. Note that the value works on
+# a logarithmic scale so increasing the size by one will rougly double the
+# memory usage. The cache size is given by this formula:
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols
+
+SYMBOL_CACHE_SIZE = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC = YES
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespace are hidden.
+
+EXTRACT_ANON_NSPACES = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES = YES
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or define consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and defines in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES = 28
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES = YES
+
+# If the sources in your project are distributed over multiple directories
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page. This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. The create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR = YES
+
+# This WARN_NO_PARAMDOC option can be abled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
+# to stderr.
+
+WARN_LOGFILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
+# with spaces.
+
+INPUT = ..
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
+
+FILE_PATTERNS = *.c \
+ *.cc \
+ *.cxx \
+ *.cpp \
+ *.c++ \
+ *.d \
+ *.java \
+ *.ii \
+ *.ixx \
+ *.ipp \
+ *.i++ \
+ *.inl \
+ *.h \
+ *.hh \
+ *.hxx \
+ *.hpp \
+ *.h++ \
+ *.idl \
+ *.odl \
+ *.cs \
+ *.php \
+ *.php3 \
+ *.inc \
+ *.m \
+ *.mm \
+ *.dox \
+ *.py \
+ *.f90 \
+ *.f \
+ *.vhd \
+ *.vhdl
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE =
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix filesystem feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS = *
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output. If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
+# is applied to all files.
+
+FILTER_PATTERNS =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION = YES
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code. Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX = YES
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# generate HTML output.
+
+GENERATE_HTML = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header.
+
+HTML_HEADER =
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the stylesheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP = YES
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS = YES
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+
+GENERATE_DOCSET = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID = org.doxygen.Project
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+# will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it.
+
+DISABLE_INDEX = NO
+
+# This tag can be used to set the number of enum values (range [1..20])
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE = 4
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW = YES
+
+# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
+# and Class Hierarchy pages using a tree view instead of an ordered list.
+
+USE_INLINE_TREES = YES
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW = NO
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT = YES
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE = NO
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvances is that it is more difficult to setup
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# generate Latex output.
+
+GENERATE_LATEX = YES
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX = YES
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, a4wide, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE = a4
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader. This is useful
+# if you want to understand what is going on. On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all function-like macros that are alone
+# on a line, have an all uppercase name, and do not end with a semicolon. Such
+# function macros are typically used for boiler-plate code, and will confuse
+# the parser if not removed.
+
+SKIP_FUNCTION_MACROS = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option is superseded by the HAVE_DOT option below. This is only a
+# fallback. It is recommended to install and use dot, since it yields more
+# powerful graphs.
+
+CLASS_DIAGRAMS = NO
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS = 0
+
+# By default doxygen will write a font called FreeSans.ttf to the output
+# directory and reference it in all dot files that doxygen generates. This
+# font does not include all possible unicode characters however, so when you need
+# these (or just want a differently looking font) you can specify the font name
+# using DOT_FONTNAME. You need need to make sure dot is able to find the font,
+# which can be done by putting it in a standard location or by setting the
+# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
+# containing the font.
+
+DOT_FONTNAME = FreeSans.ttf
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE = 10
+
+# By default doxygen will tell dot to use the output directory to look for the
+# FreeSans.ttf font (which doxygen will put there itself). If you specify a
+# different font using DOT_FONTNAME you can set the path where dot
+# can find it using this tag.
+
+DOT_FONTPATH =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK = NO
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are png, jpg, or gif
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP = YES
diff --git a/pfe_ctrl/pfe_ctrl.c b/pfe_ctrl/pfe_ctrl.c
new file mode 100644
index 0000000..3af2e61
--- /dev/null
+++ b/pfe_ctrl/pfe_ctrl.c
@@ -0,0 +1,627 @@
+#ifdef __KERNEL__
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/list.h>
+#include <linux/kthread.h>
+#else
+#include "platform.h"
+#endif
+
+#include "pfe_mod.h"
+#include "pfe_ctrl.h"
+
+#include "pfe_ctrl_hal.h"
+#include "__pfe_ctrl.h"
+
+static struct pe_sync_mailbox CLASS_DMEM_SH2(sync_mailbox);
+static struct pe_sync_mailbox TMU_DMEM_SH2(sync_mailbox);
+static struct pe_sync_mailbox UTIL_DMEM_SH2(sync_mailbox);
+
+static struct pe_msg_mailbox CLASS_DMEM_SH2(msg_mailbox);
+static struct pe_msg_mailbox TMU_DMEM_SH2(msg_mailbox);
+static struct pe_msg_mailbox UTIL_DMEM_SH2(msg_mailbox);
+
+static int initialized = 0;
+
+#define TIMEOUT_MS 1000
+
+int relax(unsigned long end)
+{
+#ifdef __KERNEL__
+ if (time_after(jiffies, end)) {
+ if (time_after(jiffies, end + (TIMEOUT_MS * HZ) / 1000)) {
+ return -1;
+ }
+
+ if (need_resched())
+ schedule();
+ }
+#else
+ udelay(1);
+#endif
+
+ return 0;
+}
+
+/** PE sync stop.
+* Stops packet processing for a list of PE's (specified using a bitmask).
+* The caller must hold ctrl->mutex.
+*
+* @param ctrl Control context
+* @param pe_mask Mask of PE id's to stop
+*
+*/
+int pe_sync_stop(struct pfe_ctrl *ctrl, int pe_mask)
+{
+ struct pe_sync_mailbox *mbox;
+ int pe_stopped = 0;
+ unsigned long end = jiffies + 2;
+ int i;
+
+ for (i = 0; i < MAX_PE; i++)
+ if (pe_mask & (1 << i)) {
+ mbox = (void *)ctrl->sync_mailbox_baseaddr[i];
+
+ pe_dmem_write(i, cpu_to_be32(0x1), (unsigned long)&mbox->stop, 4);
+ }
+
+ while (pe_stopped != pe_mask) {
+ for (i = 0; i < MAX_PE; i++)
+ if ((pe_mask & (1 << i)) && !(pe_stopped & (1 << i))) {
+ mbox = (void *)ctrl->sync_mailbox_baseaddr[i];
+
+ if (pe_dmem_read(i, (unsigned long)&mbox->stopped, 4) & cpu_to_be32(0x1))
+ pe_stopped |= (1 << i);
+ }
+
+ if (relax(end) < 0)
+ goto err;
+ }
+
+ return 0;
+
+err:
+ printk(KERN_ERR "%s: timeout, %x %x\n", __func__, pe_mask, pe_stopped);
+
+ for (i = 0; i < MAX_PE; i++)
+ if (pe_mask & (1 << i)) {
+ mbox = (void *)ctrl->sync_mailbox_baseaddr[i];
+
+ pe_dmem_write(i, cpu_to_be32(0x0), (unsigned long)&mbox->stop, 4);
+ }
+
+ return -EIO;
+}
+
+/** PE start.
+* Starts packet processing for a list of PE's (specified using a bitmask).
+* The caller must hold ctrl->mutex.
+*
+* @param ctrl Control context
+* @param pe_mask Mask of PE id's to start
+*
+*/
+void pe_start(struct pfe_ctrl *ctrl, int pe_mask)
+{
+ struct pe_sync_mailbox *mbox;
+ int i;
+
+ for (i = 0; i < MAX_PE; i++)
+ if (pe_mask & (1 << i)) {
+
+ mbox = (void *)ctrl->sync_mailbox_baseaddr[i];
+
+ pe_dmem_write(i, cpu_to_be32(0x0), (unsigned long)&mbox->stop, 4);
+ }
+}
+
+
+/** Sends a control request to a given PE (to copy data to/from internal memory from/to DDR).
+* The caller must hold ctrl->mutex.
+*
+* @param ctrl Control context
+* @param id PE id
+* @param dst Physical destination address of data
+* @param src Physical source address of data
+* @param len Data length
+*
+*/
+int pe_request(struct pfe_ctrl *ctrl, int id, unsigned short cmd_type, unsigned long dst, unsigned long src, int len)
+{
+ struct pe_msg_mailbox mbox = {
+ .dst = cpu_to_be32(dst),
+ .src = cpu_to_be32(src),
+ .len = cpu_to_be32(len),
+ .request = cpu_to_be32((cmd_type << 16) | 0x1),
+ };
+ struct pe_msg_mailbox *pmbox = (void *)ctrl->msg_mailbox_baseaddr[id];
+ unsigned long end = jiffies + 2;
+ u32 rc;
+
+ /* This works because .request is written last */
+ pe_dmem_memcpy_to32(id, (unsigned long)pmbox, &mbox, sizeof(mbox));
+
+ while ((rc = pe_dmem_read(id, (unsigned long)&pmbox->request, 4)) & cpu_to_be32(0xffff)) {
+ if (relax(end) < 0)
+ goto err;
+ }
+
+ rc = be32_to_cpu(rc);
+
+ return rc >> 16;
+
+err:
+ printk(KERN_ERR "%s: timeout, %x\n", __func__, be32_to_cpu(rc));
+ pe_dmem_write(id, cpu_to_be32(0), (unsigned long)&pmbox->request, 4);
+ return -EIO;
+}
+
+
+
+int comcerto_fpp_send_command(u16 fcode, u16 length, u16 *payload, u16 *rlen, u16 *rbuf)
+{
+ struct pfe_ctrl *ctrl;
+
+ if (!initialized) {
+ printk(KERN_ERR "pfe control not initialized\n");
+ *rlen = 2;
+ rbuf[0] = 1; /* ERR_UNKNOWN_COMMAND */
+ goto out;
+ }
+
+ ctrl = &pfe->ctrl;
+
+ mutex_lock(&ctrl->mutex);
+
+ __pfe_ctrl_cmd_handler(fcode, length, payload, rlen, rbuf);
+
+ mutex_unlock(&ctrl->mutex);
+
+out:
+ return 0;
+}
+EXPORT_SYMBOL(comcerto_fpp_send_command);
+
+/**
+ * comcerto_fpp_send_command_simple -
+ *
+ * This function is used to send command to FPP in a synchronous way. Calls to the function blocks until a response
+ * from FPP is received. This API can not be used to query data from FPP
+ *
+ * Parameters
+ * fcode: Function code. FPP function code associated to the specified command payload
+ * length: Command length. Length in bytes of the command payload
+ * payload: Command payload. Payload of the command sent to the FPP. 16bits buffer allocated by the client's code and sized up to 256 bytes
+ *
+ * Return values
+ * 0: Success
+ * <0: Linux system failure (check errno for detailed error condition)
+ * >0: FPP returned code
+ */
+int comcerto_fpp_send_command_simple(u16 fcode, u16 length, u16 *payload)
+{
+ u16 rbuf[128];
+ u16 rlen;
+ int rc;
+
+ if (!initialized) {
+ printk(KERN_ERR "pfe control not initialized\n");
+ rbuf[0] = 1; /* ERR_UNKNOWN_COMMAND */
+ goto out;
+ }
+
+ rc = comcerto_fpp_send_command(fcode, length, payload, &rlen, rbuf);
+
+ /* if a command delivery error is detected, do not check command returned code */
+ if (rc < 0)
+ return rc;
+
+out:
+ /* retrieve FPP command returned code. Could be error or acknowledgment */
+ rc = rbuf[0];
+
+ return rc;
+}
+EXPORT_SYMBOL(comcerto_fpp_send_command_simple);
+
+
+static void comcerto_fpp_workqueue(struct work_struct *work)
+{
+ struct pfe_ctrl *ctrl = container_of(work, struct pfe_ctrl, work);
+ struct fpp_msg *msg;
+ unsigned long flags;
+ u16 rbuf[128];
+ u16 rlen;
+ int rc;
+
+ spin_lock_irqsave(&ctrl->lock, flags);
+
+ while (!list_empty(&ctrl->msg_list)) {
+
+ msg = list_entry(ctrl->msg_list.next, struct fpp_msg, list);
+
+ list_del(&msg->list);
+
+ spin_unlock_irqrestore(&ctrl->lock, flags);
+
+ rc = comcerto_fpp_send_command(msg->fcode, msg->length, msg->payload, &rlen, rbuf);
+
+ /* send command response to caller's callback */
+ if (msg->callback != NULL)
+ msg->callback(msg->data, rc, rlen, rbuf);
+
+ pfe_kfree(msg);
+
+ spin_lock_irqsave(&ctrl->lock, flags);
+ }
+
+ spin_unlock_irqrestore(&ctrl->lock, flags);
+}
+
+/**
+ * comcerto_fpp_send_command_atomic -
+ *
+ * This function is used to send command to FPP in an asynchronous way. The Caller specifies a function pointer
+ * that is called by the FPP Comcerto driver when command reponse from FPP engine is received. This API can be also
+ * used to query data from FPP. Queried data are returned through the specified client's callback function
+ *
+ * Parameters
+ * fcode: Function code. FPP function code associated to the specified command payload
+ * length: Command length. Length in bytes of the command payload
+ * payload: Command payload. Payload of the command sent to the FPP. 16bits buffer allocated by the client's code and sized up to 256 bytes
+ * callback: Client's callback handler for FPP response processing
+ * data: Client's private data. Not interpreted by the FPP driver and sent back to the Client as a reference (client's code own usage)
+ *
+ * Return values
+ * 0: Success
+ * <0: Linux system failure (check errno for detailed error condition)
+ **/
+int comcerto_fpp_send_command_atomic(u16 fcode, u16 length, u16 *payload, void (*callback)(unsigned long, int, u16, u16 *), unsigned long data)
+{
+ struct pfe_ctrl *ctrl;
+ struct fpp_msg *msg;
+ unsigned long flags;
+ int rc;
+
+ if (!initialized) {
+ printk(KERN_ERR "pfe control not initialized\n");
+ rc = -EIO;
+ goto err0;
+ }
+
+ ctrl = &pfe->ctrl;
+
+ if (length > FPP_MAX_MSG_LENGTH) {
+ rc = -EINVAL;
+ goto err0;
+ }
+
+ msg = pfe_kmalloc(sizeof(struct fpp_msg) + length, GFP_ATOMIC);
+ if (!msg) {
+ rc = -ENOMEM;
+ goto err0;
+ }
+
+ /* set caller's callback function */
+ msg->callback = callback;
+ msg->data = data;
+
+ msg->payload = (u16 *)(msg + 1);
+
+ msg->fcode = fcode;
+ msg->length = length;
+ memcpy(msg->payload, payload, length);
+
+ spin_lock_irqsave(&ctrl->lock, flags);
+
+ list_add(&msg->list, &ctrl->msg_list);
+
+ spin_unlock_irqrestore(&ctrl->lock, flags);
+
+ schedule_work(&ctrl->work);
+
+ return 0;
+
+err0:
+ return rc;
+}
+
+EXPORT_SYMBOL(comcerto_fpp_send_command_atomic);
+
+
+
+/** Sends a control request to TMU PE ).
+* The caller must hold ctrl->mutex.
+*
+* @param ctrl Control context
+* @param id TMU id
+* @param tmu_cmd_bitmask Bitmask of commands sent to TMU
+*
+*/
+int tmu_pe_request(struct pfe_ctrl *ctrl, int id, unsigned int tmu_cmd_bitmask)
+{
+ if ((id < TMU0_ID) || (id > TMU_MAX_ID))
+ return -EIO;
+
+ return (pe_request(ctrl, id, 0, tmu_cmd_bitmask, 0, 0));
+}
+
+
+
+
+
+static int pfe_ctrl_send_command_simple(u16 fcode, u16 length, u16 *payload)
+{
+ u16 rbuf[128];
+ u16 rlen;
+ int rc;
+
+ /* send command to FE */
+ comcerto_fpp_send_command(fcode, length, payload, &rlen, rbuf);
+
+ /* retrieve FE command returned code. Could be error or acknowledgment */
+ rc = rbuf[0];
+
+ return rc;
+}
+
+
+/**
+ * comcerto_fpp_register_event_cb -
+ *
+ */
+int comcerto_fpp_register_event_cb(int (*event_cb)(u16, u16, u16*))
+{
+ struct pfe_ctrl *ctrl;
+
+ if (!initialized) {
+ printk(KERN_ERR "pfe control not initialized\n");
+ return -EIO;
+ }
+
+ ctrl = &pfe->ctrl;
+
+ /* register FCI callback used for asynchrounous event */
+ ctrl->event_cb = event_cb;
+
+ return 0;
+}
+EXPORT_SYMBOL(comcerto_fpp_register_event_cb);
+
+
+int pfe_ctrl_set_eth_state(int id, unsigned int state, unsigned char *mac_addr)
+{
+ unsigned char msg[20];
+ int rc;
+
+ memset(msg, 0, 20);
+
+ msg[0] = id;
+
+ if (state) {
+ memcpy(msg + 14, mac_addr, 6);
+
+ if ((rc = pfe_ctrl_send_command_simple(CMD_TX_ENABLE, 20, (unsigned short *)msg)) != 0)
+ goto err;
+
+ } else {
+ if ((rc = pfe_ctrl_send_command_simple(CMD_TX_DISABLE, 2, (unsigned short *)msg)) != 0)
+ goto err;
+ }
+
+ return 0;
+
+err:
+ return -1;
+}
+
+
+int pfe_ctrl_set_lro(char enable)
+{
+ unsigned short msg = 0;
+ int rc;
+
+ msg = enable;
+
+ if ((rc = pfe_ctrl_send_command_simple(CMD_RX_LRO, 2, (unsigned short *)&msg)) != 0)
+ return -1;
+
+ return 0;
+}
+
+#ifdef CFG_PCAP
+typedef struct _tQosExptRateCommand {
+ unsigned short expt_iftype; // PCAP
+ unsigned short pkts_per_msec;
+}QosExptRateCommand, *PQosExptRateCommand;
+
+int pfe_ctrl_set_pcap(char enable)
+{
+ unsigned short msg = 0;
+ int rc;
+ msg = enable;
+
+ if ((rc = pfe_ctrl_send_command_simple(CMD_PKTCAP_ENABLE, 2, (unsigned short *)&msg)) != 0)
+ return -1;
+
+ return 0;
+}
+
+int pfe_ctrl_set_pcap_ratelimit(u32 pkts_per_msec)
+{
+ QosExptRateCommand pcap_ratelimit;
+ int rc;
+
+ pcap_ratelimit.expt_iftype = EXPT_TYPE_PCAP;
+ pcap_ratelimit.pkts_per_msec = pkts_per_msec;
+
+ if ((rc = pfe_ctrl_send_command_simple(CMD_QM_EXPT_RATE, sizeof(QosExptRateCommand), (unsigned short *)&pcap_ratelimit)) != 0)
+ return -1;
+
+ return 0;
+
+}
+#endif
+/** Control code timer thread.
+*
+* A kernel thread is used so that the timer code can be run under the control path mutex.
+* The thread wakes up regularly and checks if any timer in the timer list as expired.
+* The timers are re-started automatically.
+* The code tries to keep the number of times a timer runs per unit time constant on average,
+* if the thread scheduling is delayed, it's possible for a particular timer to be scheduled in
+* quick succession to make up for the lost time.
+*
+* @param data Pointer to the control context structure
+*
+* @return 0 on sucess, a negative value on error
+*
+*/
+static int pfe_ctrl_timer(void *data)
+{
+ struct pfe_ctrl *ctrl = data;
+ TIMER_ENTRY *timer, *next;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ while (1)
+ {
+ schedule_timeout_uninterruptible(ctrl->timer_period);
+
+ mutex_lock(&ctrl->mutex);
+
+ list_for_each_entry_safe(timer, next, &ctrl->timer_list, list)
+ {
+ if (time_after(jiffies, timer->timeout))
+ {
+ timer->timeout += timer->period;
+
+ timer->handler();
+ }
+ }
+
+ mutex_unlock(&ctrl->mutex);
+
+ if (kthread_should_stop())
+ break;
+ }
+
+ printk(KERN_INFO "%s exiting\n", __func__);
+
+ return 0;
+}
+
+
+int pfe_ctrl_init(struct pfe *pfe)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+ int id;
+ int rc;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ mutex_init(&ctrl->mutex);
+ spin_lock_init(&ctrl->lock);
+
+ ctrl->timer_period = HZ / TIMER_TICKS_PER_SEC;
+
+ INIT_LIST_HEAD(&ctrl->timer_list);
+
+ INIT_WORK(&ctrl->work, comcerto_fpp_workqueue);
+
+ INIT_LIST_HEAD(&ctrl->msg_list);
+
+ for (id = CLASS0_ID; id <= CLASS_MAX_ID; id++) {
+ ctrl->sync_mailbox_baseaddr[id] = virt_to_class_dmem(&class_sync_mailbox);
+ ctrl->msg_mailbox_baseaddr[id] = virt_to_class_dmem(&class_msg_mailbox);
+ }
+
+ for (id = TMU0_ID; id <= TMU_MAX_ID; id++) {
+ ctrl->sync_mailbox_baseaddr[id] = virt_to_tmu_dmem(&tmu_sync_mailbox);
+ ctrl->msg_mailbox_baseaddr[id] = virt_to_tmu_dmem(&tmu_msg_mailbox);
+ }
+
+#if !defined(CONFIG_UTIL_DISABLED)
+ ctrl->sync_mailbox_baseaddr[UTIL_ID] = virt_to_util_dmem(&util_sync_mailbox);
+ ctrl->msg_mailbox_baseaddr[UTIL_ID] = virt_to_util_dmem(&util_msg_mailbox);
+#endif
+
+ ctrl->hash_array_baseaddr = pfe->ddr_baseaddr + ROUTE_TABLE_BASEADDR;
+ ctrl->hash_array_phys_baseaddr = pfe->ddr_phys_baseaddr + ROUTE_TABLE_BASEADDR;
+ ctrl->ipsec_lmem_phys_baseaddr = CBUS_VIRT_TO_PFE(LMEM_BASE_ADDR + IPSEC_LMEM_BASEADDR);
+ ctrl->ipsec_lmem_baseaddr = (LMEM_BASE_ADDR + IPSEC_LMEM_BASEADDR);
+
+ ctrl->timer_thread = kthread_create(pfe_ctrl_timer, ctrl, "pfe_ctrl_timer");
+ if (IS_ERR(ctrl->timer_thread))
+ {
+ printk (KERN_ERR "%s: kthread_create() failed\n", __func__);
+ rc = PTR_ERR(ctrl->timer_thread);
+ goto err0;
+ }
+
+ ctrl->dma_pool = dma_pool_create("pfe_dma_pool_256B", pfe->dev, DMA_BUF_SIZE_256, DMA_BUF_MIN_ALIGNMENT, DMA_BUF_BOUNDARY);
+ if (!ctrl->dma_pool)
+ {
+ printk (KERN_ERR "%s: dma_pool_create() failed\n", __func__);
+ rc = -ENOMEM;
+ goto err1;
+ }
+
+ ctrl->dma_pool_512 = dma_pool_create("pfe_dma_pool_512B", pfe->dev, DMA_BUF_SIZE_512, DMA_BUF_MIN_ALIGNMENT, DMA_BUF_BOUNDARY);
+ if (!ctrl->dma_pool_512)
+ {
+ printk (KERN_ERR "%s: dma_pool_create() failed\n", __func__);
+ rc = -ENOMEM;
+ goto err2;
+ }
+
+ ctrl->dev = pfe->dev;
+
+ mutex_lock(&ctrl->mutex);
+
+ /* Initialize interface to fci */
+ rc = __pfe_ctrl_init();
+
+ mutex_unlock(&ctrl->mutex);
+
+ if (rc < 0)
+ goto err3;
+
+ wake_up_process(ctrl->timer_thread);
+
+ printk(KERN_INFO "%s finished\n", __func__);
+
+ initialized = 1;
+
+ return 0;
+
+err3:
+ dma_pool_destroy(ctrl->dma_pool_512);
+
+err2:
+ dma_pool_destroy(ctrl->dma_pool);
+
+err1:
+ kthread_stop(ctrl->timer_thread);
+
+err0:
+ return rc;
+}
+
+
+void pfe_ctrl_exit(struct pfe *pfe)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ initialized = 0;
+
+ __pfe_ctrl_exit();
+
+ dma_pool_destroy(ctrl->dma_pool);
+
+ dma_pool_destroy(ctrl->dma_pool_512);
+
+ kthread_stop(ctrl->timer_thread);
+}
diff --git a/pfe_ctrl/pfe_ctrl.h b/pfe_ctrl/pfe_ctrl.h
new file mode 100644
index 0000000..83def7e
--- /dev/null
+++ b/pfe_ctrl/pfe_ctrl.h
@@ -0,0 +1,88 @@
+#ifndef _PFE_CTRL_H_
+#define _PFE_CTRL_H_
+
+#include <linux/dmapool.h>
+
+#include "config.h"
+#include "pfe/pfe.h"
+
+#define DMA_BUF_SIZE_256 0x100 /* enough for 2 conntracks, 1 bridge entry or 1 multicast entry */
+#define DMA_BUF_SIZE_512 0x200 /* 512bytes dma allocated buffers used by rtp relay feature */
+#define DMA_BUF_MIN_ALIGNMENT 8
+#define DMA_BUF_BOUNDARY (4 * 1024) /* bursts can not cross 4k boundary */
+
+#define CMD_TX_ENABLE 0x0501
+#define CMD_TX_DISABLE 0x0502
+
+#define CMD_RX_LRO 0x0011
+#define CMD_PKTCAP_ENABLE 0x0d01
+#define CMD_QM_EXPT_RATE 0x020c
+
+#define EXPT_TYPE_PCAP 0x3
+
+struct pfe_ctrl {
+ struct mutex mutex;
+ spinlock_t lock;
+
+ void *dma_pool;
+ void *dma_pool_512;
+
+ struct device *dev;
+
+ void *hash_array_baseaddr; /** Virtual base address of the conntrack hash array */
+ unsigned long hash_array_phys_baseaddr; /** Physical base address of the conntrack hash array */
+
+ struct task_struct *timer_thread;
+ struct list_head timer_list;
+ unsigned long timer_period;
+
+ int (*event_cb)(u16, u16, u16*);
+
+ unsigned long sync_mailbox_baseaddr[MAX_PE]; /* Sync mailbox PFE internal address, initialized when parsing elf images */
+ unsigned long msg_mailbox_baseaddr[MAX_PE]; /* Msg mailbox PFE internal address, initialized when parsing elf images */
+
+ unsigned long class_dmem_sh;
+ unsigned long class_pe_lmem_sh;
+ unsigned long tmu_dmem_sh;
+ unsigned long util_dmem_sh;
+ unsigned long util_ddr_sh;
+ struct clk *clk_axi;
+ unsigned int sys_clk; // AXI clock value, in KHz
+ void *ipsec_lmem_baseaddr;
+ unsigned long ipsec_lmem_phys_baseaddr;
+
+ /* used for asynchronous message transfer to PFE */
+ struct list_head msg_list;
+ struct work_struct work;
+};
+
+int pfe_ctrl_init(struct pfe *pfe);
+void pfe_ctrl_exit(struct pfe *pfe);
+
+int pe_sync_stop(struct pfe_ctrl *ctrl, int pe_mask);
+void pe_start(struct pfe_ctrl *ctrl, int pe_mask);
+int pe_request(struct pfe_ctrl *ctrl, int id,unsigned short cmd_type, unsigned long dst, unsigned long src, int len);
+int pe_read(struct pfe_ctrl *ctrl, int id, u32 *dst, unsigned long src, int len, int clear_flag);
+int tmu_pe_request(struct pfe_ctrl *ctrl, int id, unsigned int tmu_cmd_bitmask);
+
+int pfe_ctrl_set_eth_state(int id, unsigned int state, unsigned char *mac_addr);
+int pfe_ctrl_set_lro(char enable);
+#ifdef CFG_PCAP
+int pfe_ctrl_set_pcap(char enable);
+int pfe_ctrl_set_pcap_ratelimit(u32 pkts_per_msec);
+#endif
+
+int relax(unsigned long end);
+
+/* used for asynchronous message transfer to PFE */
+#define FPP_MAX_MSG_LENGTH 256 /* expressed in U8 -> 256 bytes*/
+struct fpp_msg {
+ struct list_head list;
+ void (*callback)(unsigned long, int, u16, u16 *);
+ unsigned long data;
+ u16 fcode;
+ u16 length;
+ u16 *payload;
+};
+
+#endif /* _PFE_CTRL_H_ */
diff --git a/pfe_ctrl/pfe_ctrl_hal.c b/pfe_ctrl/pfe_ctrl_hal.c
new file mode 100644
index 0000000..bbeb60e
--- /dev/null
+++ b/pfe_ctrl/pfe_ctrl_hal.c
@@ -0,0 +1,212 @@
+
+/* OS abstraction functions used by PFE control code */
+
+#include <linux/slab.h>
+
+#include "pfe_ctrl_hal.h"
+
+#include "pfe_mod.h"
+
+extern char *__class_dmem_sh;
+extern char *__class_pe_lmem_sh;
+extern char *__tmu_dmem_sh;
+extern char *__util_dmem_sh;
+extern char *__util_ddr_sh;
+
+HostMessage msg_buf;
+static int msg_buf_used = 0;
+
+unsigned long virt_to_class(void *p)
+{
+ if (!p)
+ return 0;
+
+ if (p >= (void *)&__class_pe_lmem_sh)
+ return virt_to_class_pe_lmem(p);
+ else
+ return virt_to_class_dmem(p);
+}
+
+unsigned long virt_to_class_dmem(void *p)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+
+ if (p)
+ return (unsigned long)p - (unsigned long)&__class_dmem_sh + ctrl->class_dmem_sh;
+ else
+ return 0;
+}
+
+unsigned long virt_to_class_pe_lmem(void *p)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+
+ if (p)
+ return (unsigned long)p - (unsigned long)&__class_pe_lmem_sh + ctrl->class_pe_lmem_sh;
+ else
+ return 0;
+}
+
+unsigned long virt_to_tmu_dmem(void *p)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+
+ if (p)
+ return (unsigned long)p - (unsigned long)&__tmu_dmem_sh + ctrl->tmu_dmem_sh;
+ else
+ return 0;
+}
+
+
+unsigned long virt_to_util_dmem(void *p)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+
+ if (p)
+ return (unsigned long)p - (unsigned long)&__util_dmem_sh + ctrl->util_dmem_sh;
+ else
+ return 0;
+}
+
+/** Returns the DDR physical address of a Util PE shared DDR variable.
+ *
+ * @param p pointer (kernel space, virtual) to be converted to a physical address.
+ */
+unsigned long virt_to_util_ddr(void *p)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+
+ if (p)
+ return (unsigned long)p - (unsigned long)&__util_ddr_sh + ctrl->util_ddr_sh;
+ else
+ return 0;
+}
+/** Returns the virtual address of a Util PE shared DDR variable.
+ *
+ * @param p pointer (kernel space, virtual) to be converted to a pointer (usable in kernel space)
+ * pointing to the actual data.
+ */
+
+void * virt_to_util_virt(void *p)
+{
+ if (p)
+ return DDR_PHYS_TO_VIRT(virt_to_util_ddr(p));
+ else
+ return NULL;
+}
+
+unsigned long virt_to_phys_iram(void *p)
+{
+ if (p)
+ return (p - pfe->iram_baseaddr) + pfe->iram_phys_baseaddr;
+ else
+ return 0;
+}
+
+unsigned long virt_to_phys_ipsec_lmem(void *p)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+
+ if (p)
+ return (p - ctrl->ipsec_lmem_baseaddr) + ctrl->ipsec_lmem_phys_baseaddr;
+ else
+ return 0;
+}
+
+unsigned long virt_to_phys_ipsec_axi(void *p)
+{
+ if (p)
+ return (p - pfe->ipsec_baseaddr) + pfe->ipsec_phys_baseaddr;
+ else
+ return 0;
+}
+
+
+HostMessage *msg_alloc(void)
+{
+ if (msg_buf_used)
+ {
+ printk(KERN_ERR "%s: failed\n", __func__);
+ return NULL;
+ }
+
+ msg_buf_used = 1;
+
+ return &msg_buf;
+}
+
+void msg_free(HostMessage *msg)
+{
+ if (!msg_buf_used)
+ printk(KERN_ERR "%s: freing already free msg buffer\n", __func__);
+
+ msg_buf_used = 0;
+}
+
+int msg_send(HostMessage *msg)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+ int rc = -1;
+
+ if (!ctrl->event_cb)
+ goto out;
+
+ if (ctrl->event_cb(msg->code, msg->length, msg->data) < 0)
+ goto out;
+
+ rc = 0;
+
+out:
+ msg_free(msg);
+
+ return rc;
+}
+
+
+void timer_init(TIMER_ENTRY *timer, TIMER_HANDLER handler)
+{
+ timer->handler = handler;
+ timer->running = 0;
+}
+
+
+void timer_add(TIMER_ENTRY *timer, u16 granularity)
+{
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+
+ //printk(KERN_INFO "%s %lx\n", __func__, (unsigned long)timer);
+
+ timer->period = granularity;
+ timer->timeout = jiffies + timer->period;
+
+ if (!timer->running)
+ {
+ list_add(&timer->list, &ctrl->timer_list);
+ timer->running = 1;
+ }
+}
+
+
+void timer_del(TIMER_ENTRY *timer)
+{
+ //printk(KERN_INFO "%s %lx\n", __func__, (unsigned long)timer);
+
+ if (timer->running)
+ {
+ list_del(&timer->list);
+ timer->running = 0;
+ }
+}
+
+
+void *Heap_Alloc(int size)
+{
+ /* FIXME we may want to use dma API's and use non cacheable memory */
+ return pfe_kmalloc(size, GFP_KERNEL);
+}
+
+
+void Heap_Free(void *p)
+{
+ pfe_kfree(p);
+}
diff --git a/pfe_ctrl/pfe_ctrl_hal.h b/pfe_ctrl/pfe_ctrl_hal.h
new file mode 100644
index 0000000..34d39da
--- /dev/null
+++ b/pfe_ctrl/pfe_ctrl_hal.h
@@ -0,0 +1,111 @@
+
+#ifndef _PFE_CTRL_HAL_H_
+#define _PFE_CTRL_HAL_H_
+
+#include <linux/timer.h>
+#include <linux/jiffies.h>
+#include <linux/string.h>
+#include <linux/elf.h>
+#include <linux/slab.h>
+#include <asm/byteorder.h>
+#include <asm/io.h>
+
+#include "pfe_mod.h"
+
+#define CLASS_DMEM_SH(var) __attribute__((section(".class_dmem_sh_" #var))) var
+#define CLASS_PE_LMEM_SH(var) __attribute__((section(".class_pe_lmem_sh_" #var))) var
+#define TMU_DMEM_SH(var) __attribute__((section(".tmu_dmem_sh_" #var))) var
+#define UTIL_DMEM_SH(var) __attribute__((section(".util_dmem_sh_" #var))) var
+#define UTIL_DDR_SH(var) __attribute__((section(".util_ddr_sh_" #var))) var
+
+#define CLASS_DMEM_SH2(var) __attribute__((section(".class_dmem_sh_" #var))) class_##var
+#define CLASS_PE_LMEM_SH2(var) __attribute__((section(".class_pe_lmem_sh_" #var))) class_##var
+#define TMU_DMEM_SH2(var) __attribute__((section(".tmu_dmem_sh_" #var))) tmu_##var
+#define UTIL_DMEM_SH2(var) __attribute__((section(".util_dmem_sh_" #var))) util_##var
+
+/** Translate the name of a shared variable to its PFE counterpart.
+ * Those macros may be used to determine the address of a shared variable,
+ * and will work even if the variable is accessed through a macro, as is the case
+ * with most fields of gFppGlobals.
+ */
+#define CONCAT(str, var) str##var
+#define CLASS_VARNAME2(var) CONCAT(class_, var)
+#define UTIL_VARNAME2(var) CONCAT(util_, var)
+#define TMU_VARNAME2(var) CONCAT(tmu_, var)
+
+typedef struct tHostMessage {
+ u16 length;
+ u16 code;
+ u16 data[128];
+} HostMessage;
+
+HostMessage *msg_alloc(void);
+void msg_free(HostMessage *msg);
+int msg_send(HostMessage *msg);
+
+
+unsigned long virt_to_class(void *p);
+unsigned long virt_to_class_dmem(void *p);
+unsigned long virt_to_class_pe_lmem(void *p);
+unsigned long virt_to_tmu_dmem(void *p);
+unsigned long virt_to_util_dmem(void *p);
+unsigned long virt_to_util_ddr(void *p);
+void * virt_to_util_virt(void *p);
+unsigned long virt_to_phys_iram(void *p);
+unsigned long virt_to_phys_ipsec_lmem(void *p);
+unsigned long virt_to_phys_ipsec_axi(void *p);
+
+
+#define TIMER_TICKS_PER_SEC 100
+
+#if TIMER_TICKS_PER_SEC > HZ
+#error TIMER_TICKS_PER_SEC is too high
+#endif
+
+
+typedef void (* TIMER_HANDLER)(void);
+
+typedef struct {
+ struct list_head list;
+ unsigned long timeout;
+ unsigned long period;
+ TIMER_HANDLER handler;
+ char running;
+} TIMER_ENTRY;
+
+
+/** Initializes a timer structure.
+* Must be called once for each TIMER_ENTRY structure.
+* The caller must be holding the ctrl->mutex.
+*
+* @param timer pointer to the timer to be initialized
+* @param handler timer handler function pointer
+*
+*/
+void timer_init(TIMER_ENTRY *timer, TIMER_HANDLER handler);
+
+/** Adds a timer to the running timer list.
+* It's safe to call even if the timer was already running. In this case we just update the granularity.
+* The caller must be holding the ctrl->mutex.
+*
+* @param timer pointer to the timer to be added
+* @param granularity granularity of the timer (in timer tick units)
+*
+*/
+void timer_add(TIMER_ENTRY *timer, u16 granularity);
+
+/** Deletes a timer from the running timer list.
+* It's safe to call even if the timer is no longer running.
+* The caller must be holding the ctrl->mutex.
+*
+* @param timer pointer to the timer to be removed
+*/
+void timer_del(TIMER_ENTRY *timer);
+
+void *Heap_Alloc(int size);
+
+#define Heap_Alloc_ARAM(s) Heap_Alloc(s)
+#define __Heap_Alloc(h, s) Heap_Alloc(s)
+void Heap_Free(void *p);
+
+#endif /* _PFE_CTRL_HAL_H_ */
diff --git a/pfe_ctrl/pfe_diags.c b/pfe_ctrl/pfe_diags.c
new file mode 100644
index 0000000..cc13ed1
--- /dev/null
+++ b/pfe_ctrl/pfe_diags.c
@@ -0,0 +1,874 @@
+#include<linux/ioctl.h>
+
+/*
+ * fppdiag_driver.c
+ *
+ * Copyright (C) 2004,2005 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 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
+ */
+
+
+
+#ifdef FPP_DIAGNOSTICS
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/fs.h>
+#include <linux/stat.h> /* TODO check if needed */
+#include <linux/cdev.h> /* TODO check if needed */
+#include <linux/ioctl.h>
+#include <linux/semaphore.h>
+#include <linux/cpumask.h>
+#include <linux/version.h>
+#include <linux/dma-mapping.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/memory.h>
+
+#include <linux/sched.h>
+#include <linux/poll.h>
+#include <linux/timer.h>
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)
+#include <mach/hardware.h>
+#include <mach/debug.h>
+#include <mach/memory.h>
+#include <linux/sched.h>
+#endif
+
+#include "pfe_ctrl_hal.h"
+#include "pfe_mod.h"
+#include "pfe_diags.h"
+
+struct fppdiag_config CLASS_DMEM_SH2(fppdiagconfig) __attribute__((aligned(8)));
+struct fppdiag_config UTIL_DMEM_SH2(fppdiagconfig) __attribute__((aligned(8)));
+
+static int pe_id[NUM_PE_DIAGS] = { CLASS0_ID, CLASS1_ID, CLASS2_ID, CLASS3_ID, CLASS4_ID, CLASS5_ID, UTIL_ID };
+
+static char pe_names[7][4] = {
+ "PE0",
+ "PE1",
+ "PE2",
+ "PE3",
+ "PE4",
+ "PE5",
+ "UPE"};
+
+
+
+/** Enables the FPP diagnostics for a single PE by allocating and filling the ring buffers with the given ring size.
+ */
+static int pfediag_enable(int pe_index, int ring_size)
+{
+ int i, j;
+ struct fppdiag_drv_dat *fppdiag_driver_data = &pfe->diags.fppdiag_drv_data[pe_index];
+ struct fppdiag_config fppconfig;
+
+ if(ring_size <= 0)
+ return -1;
+
+ /* Allocate memory to store a ring_size of pages */
+ fppdiag_driver_data->pfe_rng_baseaddr = pfe_kzalloc((sizeof(u32) * ring_size), GFP_KERNEL);
+ if(!fppdiag_driver_data->pfe_rng_baseaddr)
+ return -1; /* Failure */
+
+ fppdiag_driver_data->virt_rng_baseaddr = pfe_kzalloc((sizeof(void *) * ring_size), GFP_KERNEL);
+ if(!fppdiag_driver_data->virt_rng_baseaddr)
+ goto err_virt;
+
+
+ /* Allocate pages */
+ for( i = 0; i < ring_size; i++)
+ {
+ void *ring_entry;
+ dma_addr_t phys_ring_entry;
+ ring_entry = (void *) get_zeroed_page(GFP_KERNEL);
+
+ if(!ring_entry)
+ break;
+ fppdiag_driver_data->virt_rng_baseaddr[i] = ring_entry;
+ /* Invalidate the cache for later use by FPP */
+ phys_ring_entry = dma_map_single(pfe->dev, ring_entry, PAGE_SIZE, DMA_FROM_DEVICE);
+ fppdiag_driver_data->pfe_rng_baseaddr[i] = cpu_to_be32((u32) phys_ring_entry);
+ }
+
+ /* In Failure case freeing the other pages */
+ if (i != ring_size)
+ goto err_ring;
+
+ fppdiag_driver_data->fpp_config.rng_baseaddr = (u32 *) dma_map_single(pfe->dev, fppdiag_driver_data->pfe_rng_baseaddr, (sizeof(void **) * ring_size), DMA_TO_DEVICE);
+
+ writel(0, &fppdiag_driver_data->virt_fppdiagctl->read_index);
+ writel(0, &fppdiag_driver_data->virt_fppdiagctl->write_index);
+
+ fppdiag_driver_data->fpp_config.rng_size = ring_size;
+ fppdiag_driver_data->fpp_config.diag_ctl_flag |= FPPDIAG_CTL_ENABLE;
+
+ fppconfig.rng_baseaddr = (u32 *) cpu_to_be32((u32) fppdiag_driver_data->fpp_config.rng_baseaddr);
+ fppconfig.rng_size = cpu_to_be32(fppdiag_driver_data->fpp_config.rng_size);
+ fppconfig.diag_ctl_flag = cpu_to_be16(fppdiag_driver_data->fpp_config.diag_ctl_flag);
+ fppconfig.diag_log_flag = cpu_to_be16(fppdiag_driver_data->fpp_config.diag_log_flag);
+ fppconfig.diag_mod_flag = cpu_to_be32(fppdiag_driver_data->fpp_config.diag_mod_flag);
+ fppconfig.fppdiagctl = (fppdiag_ctl_t *) cpu_to_be32((u32) fppdiag_driver_data->fpp_config.fppdiagctl);
+
+ // Copy fpp_config to PE DMEM
+ pe_sync_stop(&pfe->ctrl, pe_id[pe_index]);
+ if (pe_id[pe_index] != UTIL_ID) {
+ pe_dmem_memcpy_to32(pe_id[pe_index], virt_to_class_dmem(&class_fppdiagconfig), &fppconfig, sizeof(struct fppdiag_config));
+ }
+ else {
+ pe_dmem_memcpy_to32(pe_id[pe_index], virt_to_util_dmem(&util_fppdiagconfig), &fppconfig, sizeof(struct fppdiag_config));
+ }
+ pe_start(&pfe->ctrl, pe_id[pe_index]);
+
+ printk(KERN_INFO "PFE diags enabled for %sdiagctl = 0x%08x, rng_base_addr = 0x%08x\n",
+ pe_names[pe_index],
+ (u32) fppdiag_driver_data->fpp_config.fppdiagctl,
+ (u32) fppdiag_driver_data->fpp_config.rng_baseaddr);
+
+
+ return 0;
+
+err_ring:
+ /* Memory allocation failed above */
+ for (j = 0; j < i; j++) {
+ dma_unmap_single(pfe->dev, be32_to_cpu(fppdiag_driver_data->pfe_rng_baseaddr[j]), PAGE_SIZE, DMA_FROM_DEVICE);
+ free_page((u32) fppdiag_driver_data->virt_rng_baseaddr[j]);
+ }
+
+ pfe_kfree(fppdiag_driver_data->virt_rng_baseaddr);
+ fppdiag_driver_data->virt_rng_baseaddr = NULL;
+err_virt:
+ pfe_kfree(fppdiag_driver_data->pfe_rng_baseaddr);
+ fppdiag_driver_data->pfe_rng_baseaddr = NULL;
+ fppdiag_driver_data->fpp_config.rng_baseaddr = NULL;
+
+
+ return -1; /* Failure */
+}
+
+
+/** Enables FPP diagnostics for all PEs.
+ *
+ */
+static void pfediag_enable_all(int ring_size)
+{
+ int i;
+
+ for (i=0; i< NUM_PE_DIAGS; i++) {
+ pfediag_enable(i, ring_size);
+ }
+}
+
+
+/* This function disables the FPP diagnostics for a single PE and frees the memory allocated. */
+static int pfediag_disable(int pe_index)
+{
+ struct fppdiag_drv_dat *fppdiag_driver_data = &pfe->diags.fppdiag_drv_data[pe_index];
+ int i;
+ struct fppdiag_config fppconfig;
+
+ /* if fppdiag has already been disabled, we wouldn't want to disable it again,
+ to mark this we will check the validity of the rng array */
+ if(!fppdiag_driver_data->fpp_config.rng_baseaddr)
+ return 0;
+
+#if 0
+ if(comcerto_fpp_send_command(CMD_FPPDIAG_DISABLE, 0, NULL,
+ &rlen, (unsigned short *)rmsg))
+ return -1;
+#endif
+
+ fppconfig.diag_ctl_flag &= cpu_to_be32(~FPPDIAG_CTL_ENABLE);
+ fppconfig.rng_baseaddr = NULL;
+ fppconfig.rng_size = cpu_to_be32(DEFAULT_RING_SIZE);
+
+ // Copy fpp_config to PE DMEM
+ pe_sync_stop(&pfe->ctrl, pe_id[pe_index]);
+ if (pe_id[pe_index] != UTIL_ID) {
+ pe_dmem_memcpy_to32(pe_id[pe_index], virt_to_class_dmem(&class_fppdiagconfig), &fppconfig, sizeof(struct fppdiag_config));
+ }
+ else {
+ pe_dmem_memcpy_to32(pe_id[pe_index], virt_to_class_dmem(&util_fppdiagconfig), &fppconfig, sizeof(struct fppdiag_config));
+ }
+ pe_start(&pfe->ctrl, pe_id[pe_index]);
+
+ writel(0, &fppdiag_driver_data->virt_fppdiagctl->read_index);
+ writel(0, &fppdiag_driver_data->virt_fppdiagctl->write_index);
+
+ for( i = 0; i < fppdiag_driver_data->fpp_config.rng_size; i++)
+ {
+ if ( fppdiag_driver_data->pfe_rng_baseaddr[i])
+ {
+ /* Invalidate the cache */
+ dma_unmap_single(pfe->dev, be32_to_cpu(fppdiag_driver_data->pfe_rng_baseaddr[i]), PAGE_SIZE, DMA_FROM_DEVICE);
+ free_page((u32) fppdiag_driver_data->virt_rng_baseaddr[i]);
+ }
+ }
+ dma_unmap_single(pfe->dev, (dma_addr_t) fppdiag_driver_data->fpp_config.rng_baseaddr,
+ (sizeof(void **) * fppdiag_driver_data->fpp_config.rng_size), DMA_TO_DEVICE);
+ pfe_kfree(fppdiag_driver_data->pfe_rng_baseaddr);
+ fppdiag_driver_data->pfe_rng_baseaddr = NULL;
+ fppdiag_driver_data->fpp_config.rng_baseaddr = NULL;
+
+ pfe_kfree(fppdiag_driver_data->virt_rng_baseaddr);
+ fppdiag_driver_data->virt_rng_baseaddr = NULL;
+
+ fppdiag_driver_data->fpp_config.rng_size = DEFAULT_RING_SIZE;
+ fppdiag_driver_data->fpp_config.diag_ctl_flag &= ~FPPDIAG_CTL_ENABLE;
+
+ printk(KERN_INFO "PFE diagnostics for %s disabled.\n", pe_names[pe_index]);
+ return 0;
+}
+
+/** Disables FPP diagnostics for all PEs.
+ *
+ */
+static void pfediag_disable_all(void)
+{
+ int i;
+
+ for (i=0; i< NUM_PE_DIAGS; i++)
+ pfediag_disable(i);
+}
+
+#if 0 // TODO update code to work with PFE.
+/* This function checks for available entries written into the common buffers */
+static int fppdiag_get_avail_entries(int* fppdiag_read_index)
+{
+ int read_index, write_index;
+ fppdiag_ctl_t *fppdiagctl= (fppdiag_ctl_t *)(ARAM_DIAG_CTL_ADDR);
+
+ write_index = readl( &fppdiagctl->write_index);
+ read_index = readl( &fppdiagctl->read_index);
+ *fppdiag_read_index = read_index;
+ if(write_index < read_index )
+ {
+ return (fppdiag_drv_data->fpp_config.rng_size * FPPDIAG_ENTRIES_PER_PAGE)
+ - (read_index - write_index);
+ }
+ else
+ return (write_index - read_index);
+}
+
+static int fppdiag_update_fpp(struct fppdiag_config * fpp_config)
+{
+ short rlen = 1;
+ unsigned char rmsg[2] = {};
+ struct fppdiag_config msg = {} ;
+ msg.diag_mod_flag = fpp_config->diag_mod_flag;
+ msg.diag_log_flag = fpp_config->diag_log_flag;
+
+ if(comcerto_fpp_send_command(CMD_FPPDIAG_UPDATE, sizeof(msg),
+ (unsigned short *)&msg,
+ &rlen, rmsg))
+ return -1;
+
+ return 0;
+
+}
+
+static int fppdiag_update_diagmodule(pFPPDIAGCMD pFppCmd)
+{
+ if (pFppCmd->flags_enable)
+ fppdiag_drv_data->fpp_config.diag_mod_flag |= pFppCmd->flags.module;
+ else
+ fppdiag_drv_data->fpp_config.diag_mod_flag &= ~(pFppCmd->flags.module);
+ fppdiag_update_fpp(&fppdiag_drv_data->fpp_config);
+ return 0;
+}
+
+static int fppdiag_update_diaglog(pFPPDIAGCMD pFppCmd)
+{
+ if (pFppCmd->flags_enable)
+ fppdiag_drv_data->fpp_config.diag_log_flag |= pFppCmd->flags.log;
+ else
+ fppdiag_drv_data->fpp_config.diag_log_flag &= ~(pFppCmd->flags.log);
+ fppdiag_update_fpp(&fppdiag_drv_data->fpp_config);
+ return 0;
+}
+
+/* This function gets the diag information to present it to the user */
+static int fppdiag_get_diaginfo(pFPPDIAGINFO p_fppdiag_info)
+{
+ p_fppdiag_info->state = fppdiag_drv_data->fpp_config.diag_ctl_flag;
+ p_fppdiag_info->module = fppdiag_drv_data->fpp_config.diag_mod_flag;
+ p_fppdiag_info->log = fppdiag_drv_data->fpp_config.diag_log_flag;
+
+ return 0;
+}
+
+
+
+/* This function updates the read index once the information is updated from
+ * the user */
+static int fppdiag_update_read_index(pFPPDIAGDATA pFppData)
+{
+ fppdiag_ctl_t *fppdiagctl= (fppdiag_ctl_t *)(ARAM_DIAG_CTL_ADDR);
+ int read_index = readl( &fppdiagctl->read_index);
+ int diag_total_entries = fppdiag_drv_data->fpp_config.rng_size * FPPDIAG_ENTRIES_PER_PAGE;
+ unsigned long diag_data_addr;
+ unsigned int diag_page_addr;
+ int i = 0;
+
+ if (!fppdiag_drv_data->fpp_config.rng_baseaddr)
+ {
+ printk(KERN_INFO "ring base address is NULL\n");
+ return 0;
+ }
+
+ // TODO: This should be possible in a more efficient manner.
+ /* Invalidate the cache here for the entries read
+ * (old read_index to new read_index */
+
+ for (i = 0; i < pFppData->entries_to_read; i++)
+ {
+ diag_page_addr = (void *)phys_to_virt(be32_to_cpu(
+ fppdiag_drv_data->fpp_config.rng_baseaddr[read_index/FPPDIAG_ENTRIES_PER_PAGE]));
+ diag_data_addr = diag_page_addr +
+ ((read_index & FPPDIAG_ENTRY_MASK) << FPPDIAG_ENTRY_SHIFT );
+ dma_sync_single_for_cpu(pfe->dev, diag_data_addr, FPPDIAG_ENTRY_SIZE, DMA_FROM_DEVICE);
+
+ read_index++;
+ if (read_index == diag_total_entries)
+ read_index = 0;
+ }
+
+
+ writel(pFppData->read_index, &fppdiagctl->read_index);
+
+ return 0;
+}
+
+static unsigned int fppdiag_poll(struct file *filp, poll_table *wait)
+{
+ int read_index = 0;
+ int avail_entries = fppdiag_get_avail_entries(&read_index);
+
+ avail_entries = fppdiag_get_avail_entries(&read_index);
+ if(avail_entries == 0)
+ {
+ schedule();
+ }
+ return POLLIN;
+}
+
+
+static int fppdiag_open(struct inode *inode, struct file *filp)
+{
+ return 0;
+}
+
+static int fppdiag_release(struct inode *inode, struct file *filp)
+{
+ return 0;
+}
+
+static long fppdiag_ioctl(struct file *filp,
+ unsigned int cmd, unsigned long param)
+{
+ int rc = 0;
+ mutex_lock(&fppdiag_drv_data->lock);
+ switch (cmd)
+ {
+ case FPPDIAG_DRV_GET_RINGSIZE:
+ {
+ FPPCONFIG fppconfig;
+ pFPPCONFIG pFppConfig = (FPPCONFIG*) param;
+ fppconfig.ring_size = fppdiag_drv_data->fpp_config.rng_size;;
+ if (copy_to_user(pFppConfig, &fppconfig ,sizeof(FPPCONFIG))) {
+ printk(KERN_INFO " FPPDIAG_CONFIG Error");
+ rc = -EINVAL;
+ break;
+ }
+ }
+ break;
+ case FPPDIAG_DRV_GETDATA:
+ {
+ int read_index = 0;
+ int avail_entries = 0;
+ FPPDIAGDATA fppdiag_start_data;
+ pFPPDIAGDATA pFppDiagData = (FPPDIAGDATA*) param;
+ avail_entries = fppdiag_get_avail_entries(&read_index);
+ if (avail_entries > FPPDIAG_MAX_AVBL_ENTRIES)
+ avail_entries = FPPDIAG_MAX_AVBL_ENTRIES;
+
+ fppdiag_start_data.read_index = read_index;
+ fppdiag_start_data.entries_to_read = avail_entries;
+
+ if (copy_to_user(pFppDiagData, &fppdiag_start_data,
+ sizeof(FPPDIAGDATA))) {
+ printk(KERN_INFO " FPPDIAG_GETDATA:Error");
+ rc = -EINVAL;
+ break;
+ }
+ }
+ break;
+ case FPPDIAG_DRV_FINDATA:
+ {
+ FPPDIAGDATA fppdiag_fin_data;
+ pFPPDIAGDATA pFppDiagData = (FPPDIAGDATA*) param;
+
+ if (copy_from_user(&fppdiag_fin_data,pFppDiagData,sizeof(FPPDIAGDATA))) {
+ printk(KERN_INFO " FPPDIAG_FINDATA:Error");
+ rc = -EINVAL;
+ break;
+ }
+ fppdiag_update_read_index(&fppdiag_fin_data);
+
+ }
+ break;
+ case FPPDIAG_DRV_SET_STATE:
+ {
+
+ FPPDIAGCMD fppdiag_state_cmd;
+ pFPPDIAGCMD pFppDiagCmd = (FPPDIAGCMD*) param;
+
+ if (copy_from_user(&fppdiag_state_cmd,pFppDiagCmd,
+ sizeof(FPPDIAGCMD))) {
+ printk(KERN_INFO " FPPDIAG_STATE:Error");
+ rc = -EINVAL;
+ break;
+ }
+ pfediag_disable();
+ if(fppdiag_state_cmd.flags.state_size & 0xFF)
+ {
+ /* state_size holds MS 2 bytes of the ring buffer size and the LS 1 byte
+ holds enable/disable flag. */
+ if(pfediag_enable(&fppdiag_drv_data[0] /* FIXME */, fppdiag_state_cmd.flags.state_size >> 8 ) < 0)
+ {
+ printk(KERN_INFO " FPPDIAG_DRV_SET_STATE Error");
+ rc = -EINVAL;
+ break;
+ }
+ }
+ //fppdiag_update_diagstate(&fppdiag_state_cmd);
+ }
+ break;
+ case FPPDIAG_DRV_SET_MODULE:
+ {
+
+ FPPDIAGCMD fppdiag_state_cmd;
+ pFPPDIAGCMD pFppDiagCmd = (FPPDIAGCMD*) param;
+
+ if (copy_from_user(&fppdiag_state_cmd,pFppDiagCmd,
+ sizeof(FPPDIAGCMD))) {
+ printk(KERN_INFO " FPPDIAG_MODULE:Error");
+ rc = -EINVAL;
+ break;
+ }
+ fppdiag_update_diagmodule(&fppdiag_state_cmd);
+ }
+ break;
+ case FPPDIAG_DRV_SET_LOG:
+ {
+ FPPDIAGCMD fppdiag_state_cmd;
+ pFPPDIAGCMD pFppDiagCmd = (FPPDIAGCMD*) param;
+
+ if (copy_from_user(&fppdiag_state_cmd,pFppDiagCmd,
+ sizeof(FPPDIAGCMD))) {
+ printk(KERN_INFO " FPPDIAG_LOG:Error");
+ rc = -EINVAL;
+ break;
+ }
+ fppdiag_update_diaglog(&fppdiag_state_cmd);
+ }
+ break;
+ case FPPDIAG_DRV_GET_INFO:
+ {
+ FPPDIAGINFO fppdiag_info;
+ pFPPDIAGINFO p_fppdiag_info = (pFPPDIAGINFO) param;
+
+ fppdiag_get_diaginfo(&fppdiag_info);
+
+ if (copy_to_user(p_fppdiag_info, &fppdiag_info ,
+ sizeof(FPPDIAGINFO))) {
+ printk(KERN_INFO " FPPDIAG_DRV_GET_INFO Error");
+ rc = -EINVAL;
+ break;
+ }
+ }
+ break;
+ case FPPDIAG_DRV_DUMP_COUNTERS:
+ {
+ short rlen = 1;
+ unsigned char rmsg[2] = {};
+ struct fppdiag_config msg = {} ;
+ if(comcerto_fpp_send_command(CMD_FPPDIAG_DUMP_CTRS, sizeof(msg),
+ (unsigned short *)&msg,
+ &rlen, rmsg))
+ return -1;
+
+ }
+ break;
+ default:
+ {
+ printk(KERN_INFO "fppdiag_ioctl: cmd : %d is not implemented", cmd);
+ rc = -EINVAL;
+ break;
+ }
+ }
+ mutex_unlock(&fppdiag_drv_data->lock);
+ return rc;
+}
+
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)
+
+
+static int fppdiag_vma_fault(struct vm_area_struct *vma , struct vm_fault *vmf)
+{
+ struct page *pageptr = NULL;
+ unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
+ unsigned long physaddr = (unsigned long)vmf->virtual_address - vma->vm_start +
+ offset;
+ unsigned long pageframe = physaddr >> PAGE_SHIFT;
+ void* page_ptr = NULL;
+
+ //printk (KERN_DEBUG "diag_vm_nopage:start: %lx, end: %lx, address: %lx offset: %lx pageframe : %x\n", vma->vm_start, vma->vm_end, (unsigned long)vmf->virtual_address, offset, pageframe);
+
+ page_ptr = (void*)phys_to_virt(be32_to_cpu(fppdiag_drv_data->fpp_config.rng_baseaddr[pageframe]));
+ pageptr = virt_to_page(page_ptr);
+ get_page(pageptr);
+ vmf->page = pageptr;
+ if(pageptr)
+ return 0;
+ return VM_FAULT_SIGBUS;
+}
+
+#else
+
+static struct page *fppdiag_vma_nopage (struct vm_area_struct *vma,
+ unsigned long address, int *type)
+{
+ struct page *pageptr = NOPAGE_SIGBUS;
+ unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
+ unsigned long physaddr = address - vma->vm_start + offset;
+ unsigned long pageframe = physaddr >> PAGE_SHIFT;
+ void* page_ptr = NULL;
+
+ //printk (KERN_DEBUG "diag_vm_nopage:start: %lx, end: %lx, address: %lx offset: %lx pageframe : %x\n", vma->vm_start, vma->vm_end, address,offset,pageframe);
+
+ page_ptr = (void*)phys_to_virt(be32_to_cpu(fppdiag_drv_data->fpp_config.rng_baseaddr[pageframe]));
+ pageptr = virt_to_page(page_ptr);
+ get_page(pageptr);
+ if (type)
+ *type = VM_FAULT_MINOR;
+ return pageptr;
+}
+
+#endif
+
+void fppdiag_vma_open(struct vm_area_struct *vma)
+{
+ printk(KERN_NOTICE "Simple VMA open, virt %lx, phys %lx\n",
+ vma->vm_start, vma->vm_pgoff << PAGE_SHIFT);
+}
+
+void fppdiag_vma_close(struct vm_area_struct *vma)
+{
+ printk(KERN_NOTICE "Simple VMA close.\n");
+}
+
+
+static struct vm_operations_struct fppdiag_vm_ops = {
+ .open = fppdiag_vma_open,
+ .close = fppdiag_vma_close,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)
+ .fault = fppdiag_vma_fault,
+#else
+ .nopage = fppdiag_vma_nopage,
+#endif
+};
+
+
+
+static int fppdiag_mmap(struct file *file, struct vm_area_struct *vma)
+{
+ unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
+ unsigned long vsize = vma->vm_end - vma->vm_start;
+
+
+ printk (KERN_DEBUG "start: %lx, end: %lx off: %lx, vsize: %lx, \n",
+ vma->vm_start, vma->vm_end, offset, vsize);
+
+ if (offset >= __pa(high_memory) || (file->f_flags & O_SYNC))
+ {
+ printk(KERN_INFO "High Memory \n");
+ vma->vm_flags |= VM_IO;
+ }
+
+ vma->vm_flags |= VM_RESERVED;
+ vma->vm_ops = &fppdiag_vm_ops;
+ fppdiag_vma_open(vma);
+
+ return 0;
+}
+
+
+struct file_operations fppdiag_fops = {
+ .owner = THIS_MODULE,
+ .open = fppdiag_open,
+ .release = fppdiag_release,
+ .unlocked_ioctl = fppdiag_ioctl,
+ .mmap = fppdiag_mmap,
+ .poll = fppdiag_poll,
+};
+#endif // #if 0
+
+
+void pfe_diags_print(fppdiag_entry_t *entry, unsigned int pe_num)
+{
+ FPPDIAG_ARG_TYPE *args = (FPPDIAG_ARG_TYPE *)(entry->buffer + FPPDIAG_BUFFER_SIZE-FPPDIAG_MAX_ARGS*sizeof(FPPDIAG_ARG_TYPE));
+ struct pfe_diags_info * pfe_diags_info;
+ unsigned long str_offset = be32_to_cpu(*(u32 *)entry->buffer);
+ char string_buffer[256];
+
+ if (pe_id[pe_num] == UTIL_ID)
+ pfe_diags_info = &pfe->diags.util_diags_info;
+ else
+ pfe_diags_info = &pfe->diags.class_diags_info;
+
+ if (!pfe_diags_info) {
+ printk(KERN_WARNING "PFE diags: print message was received but diags strings could not be extracted from firmware, skipping.\n");
+ return;
+ }
+
+ str_offset -= pfe_diags_info->diags_str_base;
+ if (str_offset >= pfe_diags_info->diags_str_size) {
+ printk(KERN_WARNING "PFE diags: string offset passed by PFE %s is out of bounds: %ld", pe_names[pe_num], str_offset);
+ return;
+ }
+
+ snprintf(string_buffer, 256, "%s %s: %s", KERN_INFO, pe_names[pe_num], (char *)(pfe_diags_info->diags_str_array+str_offset));
+ printk(string_buffer, ntohl(args[0]), ntohl(args[1]), ntohl(args[2]), ntohl(args[3]));
+}
+
+void pfe_diags_dump(fppdiag_entry_t *entry, char *pe_name)
+{
+ unsigned int i;
+
+ for (i=0; i < FPPDIAG_BUFFER_SIZE; i++)
+ {
+ if ((i & 0x7) == 0)
+ printk(KERN_INFO "\n%s: 0x%02x ", pe_name, i);
+ printk(KERN_INFO "%02x ", entry->buffer[i]);
+ }
+ printk(KERN_INFO " \n");
+}
+
+void pfe_diags_exception_dump(fppdiag_entry_t *entry, char *pe_name)
+{
+ u32 *registers = (u32 *) entry->buffer;
+
+ printk(KERN_INFO "%s: Exception: EPC: %8x ECAS: %8x EID: %8x ED: %8x\n%s: r0/sp: %8x r1/ra: %8x r2/fp: %8x r3: %8x\n%s: r4: %8x r5: %8x r6: %8x r7: %8x\n%s: r8: %8x r9: %8x r10: %8x\n",
+ pe_name, ntohl(registers[0]), ntohl(registers[1]), ntohl(registers[2]), ntohl(registers[3]),
+ pe_name, ntohl(registers[4]), ntohl(registers[5]), ntohl(registers[6]), ntohl(registers[7]),
+ pe_name, ntohl(registers[8]), ntohl(registers[9]), ntohl(registers[10]), ntohl(registers[11]),
+ pe_name, ntohl(registers[12]), ntohl(registers[13]), ntohl(registers[14]) );
+}
+
+fppdiag_entry_t * pfe_diags_get_entry(unsigned int pe_num, unsigned int *pread_index)
+{
+ unsigned int read_index, page_index, previous_page_index, total_size;
+ fppdiag_ctl_t *fppdiagctl = pfe->diags.fppdiag_drv_data[pe_num].virt_fppdiagctl;
+ void *pageaddr;
+
+ total_size = pfe->diags.fppdiag_drv_data[pe_num].fpp_config.rng_size * FPPDIAG_ENTRIES_PER_PAGE;
+
+ read_index = be32_to_cpu(fppdiagctl->read_index);
+ previous_page_index = read_index/FPPDIAG_ENTRIES_PER_PAGE;
+ read_index++;
+ if (read_index == total_size)
+ read_index = 0;
+ page_index = read_index/FPPDIAG_ENTRIES_PER_PAGE;
+
+ if (read_index % FPPDIAG_ENTRIES_PER_PAGE == 0)
+ dma_sync_single_for_cpu(pfe->dev, pfe->diags.fppdiag_drv_data[pe_num].pfe_rng_baseaddr[previous_page_index], PAGE_SIZE, DMA_FROM_DEVICE);
+
+ pageaddr = pfe->diags.fppdiag_drv_data[pe_num].virt_rng_baseaddr[page_index];
+ *pread_index = read_index;
+ return (fppdiag_entry_t *) (pageaddr+(read_index % FPPDIAG_ENTRIES_PER_PAGE)*FPPDIAG_ENTRY_SIZE);
+}
+
+unsigned int pfe_diags_show_current(unsigned int pe_num)
+{
+ fppdiag_entry_t *entry;
+ unsigned int read_index;
+
+
+ entry = pfe_diags_get_entry(pe_num, &read_index);
+
+ switch (entry->flags)
+ {
+ case FPPDIAG_EXPT_ENTRY:
+ pfe_diags_exception_dump(entry, pe_names[pe_num]);
+ //pfe_diags_dump(entry, pe_names[pe_num]);
+ break;
+ case FPPDIAG_DUMP_ENTRY:
+ pfe_diags_dump(entry, pe_names[pe_num]);
+ break;
+ default:
+ pfe_diags_print(entry, pe_num);
+ break;
+ }
+
+ return read_index;
+}
+
+unsigned int fppdiag_show_one(unsigned int pe_start, unsigned int pe_end)
+{
+ fppdiag_ctl_t *fppdiagctl;
+ int pe_num = pe_start;
+
+ fppdiagctl = pfe->diags.fppdiag_drv_data[pe_num].virt_fppdiagctl;
+
+ while (be32_to_cpu(fppdiagctl->read_index) == be32_to_cpu(fppdiagctl->write_index))
+ {
+ pe_num++;
+ if (pe_num > pe_end)
+ pe_num = pe_start;
+ fppdiagctl = pfe->diags.fppdiag_drv_data[pe_num].virt_fppdiagctl;
+ }
+
+ fppdiagctl->read_index = cpu_to_be32(pfe_diags_show_current(pe_num));
+
+ return 0;
+}
+
+
+void pfe_diags_loop(unsigned long arg)
+{
+ int pe_num, count;
+ fppdiag_ctl_t *fppdiagctl;
+
+ for (pe_num=0; pe_num < NUM_PE_DIAGS; pe_num++) {
+ fppdiagctl = pfe->diags.fppdiag_drv_data[pe_num].virt_fppdiagctl;
+ count = 40;
+ while (count && (be32_to_cpu(fppdiagctl->read_index) != be32_to_cpu(fppdiagctl->write_index)))
+ {
+ fppdiagctl->read_index = cpu_to_be32(pfe_diags_show_current(pe_num));
+ count--;
+ }
+ }
+ add_timer(&pfe->diags.pfe_diags_timer);
+}
+
+
+
+int pfe_diags_init(struct pfe *pfe)
+{
+ int i;
+ int ret = 0;
+ fppdiag_ctl_t *phys_fppdiagctl, *virt_fppdiagctl;
+ struct fppdiag_drv_dat *fppdiag_drv_data;
+
+ printk(KERN_INFO "\n Fppdiag Driver initializing.\n");
+
+ fppdiag_drv_data = pfe_kzalloc(NUM_PE_DIAGS*sizeof(struct fppdiag_drv_dat), GFP_KERNEL);
+ if(!fppdiag_drv_data)
+ {
+ ret = -ENOMEM;
+ goto err0;
+ }
+ pfe->diags.fppdiag_drv_data = fppdiag_drv_data;
+
+ //fppdiagctl= (fppdiag_ctl_t *)(ARAM_DIAG_CTL_ADDR);
+ //ctl_phys_address = FPPDIAG_CTL_BASE_ADDR;
+ //fppdiagctl = pfe_kmalloc(NUM_PE_DIAGS*sizeof(fppdiag_ctl_t), GFP_KERNEL);
+ virt_fppdiagctl = dma_alloc_coherent(pfe->dev, NUM_PE_DIAGS*sizeof(fppdiag_ctl_t), (dma_addr_t *) &phys_fppdiagctl, GFP_KERNEL);
+ printk(KERN_INFO "PFE diags ctrl_phys_address = 0x%08x\n", (u32) phys_fppdiagctl);
+ if(!virt_fppdiagctl)
+ {
+ ret = -ENOMEM;
+ goto err0;
+ }
+
+#if 0 // TODO Update code to work with PFE
+ if(register_chrdev(FPPDIAG_MAJOR_NUMBER, FPPDIAG_DRIVER_NAME, &fppdiag_fops) < 0){
+ ret = -1;
+ printk(KERN_INFO "Diag register chrdev failed ");
+ goto err1;
+ }
+ else {
+ printk(KERN_INFO "DIAG driver allocated " );
+ }
+#endif
+
+ /* Initialize control structures */
+ for (i=0; i<NUM_PE_DIAGS; i++) {
+ fppdiag_drv_data[i].fpp_config.rng_baseaddr = NULL;
+ fppdiag_drv_data[i].fpp_config.diag_ctl_flag = FPPDIAG_CTL_FREERUN;
+ fppdiag_drv_data[i].fpp_config.diag_log_flag = 0xff;
+ fppdiag_drv_data[i].fpp_config.diag_mod_flag = 0xff;
+ fppdiag_drv_data[i].fpp_config.rng_size = DEFAULT_RING_SIZE;
+ fppdiag_drv_data[i].fpp_config.fppdiagctl = &phys_fppdiagctl[i];
+ fppdiag_drv_data[i].virt_fppdiagctl = &virt_fppdiagctl[i];
+ fppdiag_drv_data[i].virt_rng_baseaddr = NULL;
+
+ mutex_init(&fppdiag_drv_data[i].lock);
+
+ /* Reset the read and write index */
+ writel(0, &fppdiag_drv_data[i].virt_fppdiagctl->read_index);
+ writel(0, &fppdiag_drv_data[i].virt_fppdiagctl->write_index);
+ }
+
+ /* Until full diags control path is ready, enable diags now, and poll and dump diags from kernel-space */
+ pfediag_enable_all(8);
+
+ //Start timer to dump diags periodically
+ init_timer(&pfe->diags.pfe_diags_timer);
+ pfe->diags.pfe_diags_timer.function = pfe_diags_loop;
+ pfe->diags.pfe_diags_timer.expires = jiffies + 2;
+ add_timer(&pfe->diags.pfe_diags_timer);
+ //timer_init(&pfe->diags.pfe_diags_timer, pfe_diags_loop);
+
+
+ return 0;
+//err1:
+ pfe_kfree(fppdiag_drv_data);
+err0:
+ return ret;
+
+}
+
+void pfe_diags_exit(struct pfe *pfe)
+{
+ del_timer(&pfe->diags.pfe_diags_timer);
+
+ /* Disable the memory allocated for the modules */
+ pfediag_disable_all();
+
+#if 0
+ unregister_chrdev(FPPDIAG_MAJOR_NUMBER,FPPDIAG_DRIVER_NAME);
+#endif
+
+ /* Release the data initialized for this module */
+ pfe_kfree(pfe->diags.fppdiag_drv_data);
+}
+
+#else
+#include "pfe_mod.h"
+int pfe_diags_init(struct pfe *pfe)
+{
+ return 0;
+}
+
+void pfe_diags_exit(struct pfe *pfe)
+{
+}
+#endif
diff --git a/pfe_ctrl/pfe_diags.h b/pfe_ctrl/pfe_diags.h
new file mode 100644
index 0000000..7c02b87
--- /dev/null
+++ b/pfe_ctrl/pfe_diags.h
@@ -0,0 +1,114 @@
+/*
+ * diagdrv.h
+ *
+ * Copyright (C) 2004,2005 Mindspeed Technologies, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 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 _PFE_DIAGS_H_
+#define _PFE_DIAGS_H_
+
+#ifdef FPP_DIAGNOSTICS
+#include "fppdiag_lib.h"
+
+#define NUM_PE_DIAGS 7 /**< No diags for the TMU PEs */
+
+
+#define DEFAULT_RING_SIZE 32
+#define MAX_RING_SIZE 256
+
+#define FPPDIAG_MAX_AVBL_ENTRIES 100
+
+#define CMD_FPPDIAG_ENABLE 0x1201
+#define CMD_FPPDIAG_DISABLE 0x1202
+#define CMD_FPPDIAG_UPDATE 0x1203
+#define CMD_FPPDIAG_DUMP_CTRS 0x1204
+
+
+typedef struct fppdiag_config_host
+{
+ int ring_size;
+}FPPCONFIG , *pFPPCONFIG;
+
+typedef struct fppdiag_data
+{
+ int read_index;
+ int entries_to_read;
+}FPPDIAGDATA, *pFPPDIAGDATA;
+
+typedef struct fppdiag_cmd
+{
+ union{
+ unsigned short log;
+ unsigned int module;
+ unsigned int state_size;
+ }flags;
+ unsigned int flags_enable;
+}FPPDIAGCMD , *pFPPDIAGCMD;
+
+typedef struct fppdiag_drv_info
+{
+ unsigned char state;
+ unsigned short log;
+ unsigned int module;
+}FPPDIAGINFO ,*pFPPDIAGINFO;
+
+struct pfe_diags_info {
+ unsigned long diags_str_base;
+ unsigned long diags_str_size;
+ char * diags_str_array;
+};
+
+
+#define FPPDIAG_MAJOR_NUMBER 200
+#define FPPDIAG_DRIVER_NAME "/dev/fppdiag/"
+
+
+#define FPPDIAG_DRV_GET_RINGSIZE _IOR(FPPDIAG_MAJOR_NUMBER,1,FPPCONFIG)
+#define FPPDIAG_DRV_GETDATA _IOR(FPPDIAG_MAJOR_NUMBER,2,FPPDIAGDATA)
+#define FPPDIAG_DRV_FINDATA _IOW(FPPDIAG_MAJOR_NUMBER,3,FPPDIAGDATA)
+#define FPPDIAG_DRV_SET_STATE _IOW(FPPDIAG_MAJOR_NUMBER,4,FPPDIAGCMD)
+#define FPPDIAG_DRV_SET_MODULE _IOW(FPPDIAG_MAJOR_NUMBER,5,FPPDIAGCMD)
+#define FPPDIAG_DRV_SET_LOG _IOW(FPPDIAG_MAJOR_NUMBER,6,FPPDIAGCMD)
+#define FPPDIAG_DRV_GET_INFO _IOR(FPPDIAG_MAJOR_NUMBER,7,FPPDIAGINFO)
+#define FPPDIAG_DRV_DUMP_COUNTERS _IOR(FPPDIAG_MAJOR_NUMBER,8,FPPDIAGINFO)
+
+
+
+struct fppdiag_drv_dat
+{
+ struct fppdiag_config fpp_config;
+ struct mutex lock;
+ fppdiag_ctl_t *virt_fppdiagctl; /**< FPP diags control structure (points to same area as fpp_config.fppdiagctl, but with kernel space address) */
+ void **virt_rng_baseaddr; /**< Pointer to an array of page buffer addresses (same as in fpp_config but pointer AND content are kernel space addresses) */
+ dma_addr_t *pfe_rng_baseaddr; /**< Pointer to fpp_config.rng_baseaddr array (but with kernel space address) */
+};
+
+struct pfe_diags
+{
+ struct timer_list pfe_diags_timer;
+ struct fppdiag_drv_dat *fppdiag_drv_data;
+ struct pfe_diags_info class_diags_info;
+ struct pfe_diags_info util_diags_info;
+};
+
+extern int comcerto_fpp_send_command(u16 fcode, u16 length, u16 *payload, u16 *resp_length, u16 *resp_payload);
+
+#endif
+
+int pfe_diags_init(struct pfe *pfe);
+void pfe_diags_exit(struct pfe *pfe);
+#endif /* _PFE_DIAGS_H_ */
diff --git a/pfe_ctrl/pfe_emulation.c b/pfe_ctrl/pfe_emulation.c
new file mode 100644
index 0000000..2203cde
--- /dev/null
+++ b/pfe_ctrl/pfe_emulation.c
@@ -0,0 +1,160 @@
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+
+#include "pfe_mod.h"
+
+static u64 dma_mask = 0xffffffff;
+
+/**
+ * pfe_emulation_probe -
+ *
+ *
+ */
+static int pfe_emulation_probe(struct platform_device *pdev)
+{
+ int rc;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ pfe = kzalloc(sizeof(struct pfe), GFP_KERNEL);
+ if (!pfe) {
+ rc = -ENOMEM;
+ goto err_alloc;
+ }
+
+ platform_set_drvdata(pdev, pfe);
+
+ pfe->ddr_phys_baseaddr = 0x00020000; /* should match the value used on the BSP */
+ pfe->ddr_size = 12 * SZ_1M; /* should match the value used on the BSP */
+ pfe->ddr_baseaddr = vmalloc(pfe->ddr_size);
+ if (!pfe->ddr_baseaddr) {
+ printk(KERN_INFO "vmalloc() ddr failed\n");
+ rc = -ENOMEM;
+ goto err_ddr;
+ }
+
+ pfe->cbus_baseaddr = vmalloc(16 * SZ_1M);
+ if (!pfe->cbus_baseaddr) {
+ printk(KERN_INFO "vmalloc() cbus failed\n");
+ rc = -ENOMEM;
+ goto err_cbus;
+ }
+
+ pfe->apb_baseaddr = vmalloc(16 * SZ_1M);
+ if (!pfe->cbus_baseaddr) {
+ printk(KERN_INFO "vmalloc() apb failed\n");
+ rc = -ENOMEM;
+ goto err_apb;
+ }
+
+ pfe->iram_baseaddr = vmalloc(128 * SZ_1K);
+ if (!pfe->iram_baseaddr) {
+ printk(KERN_INFO "vmalloc() iram failed\n");
+ rc = -ENOMEM;
+ goto err_iram;
+ }
+
+ pfe->hif_irq = 0;
+ pfe->dev = &pdev->dev;
+ pfe->dev->dma_mask = &dma_mask;
+
+ pfe->ctrl.sys_clk = 250000;
+ rc = pfe_probe(pfe);
+ if (rc < 0)
+ goto err_probe;
+
+ return 0;
+
+err_probe:
+ vfree(pfe->iram_baseaddr);
+
+err_iram:
+ vfree(pfe->apb_baseaddr);
+
+err_apb:
+ vfree(pfe->cbus_baseaddr);
+
+err_cbus:
+ vfree(pfe->ddr_baseaddr);
+
+err_ddr:
+ platform_set_drvdata(pdev, NULL);
+
+ kfree(pfe);
+
+err_alloc:
+ return rc;
+}
+
+
+/**
+ * pfe_emulation_remove -
+ *
+ *
+ */
+static int pfe_emulation_remove(struct platform_device *pdev)
+{
+ struct pfe *pfe = platform_get_drvdata(pdev);
+ int rc;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ rc = pfe_remove(pfe);
+
+ vfree(pfe->iram_baseaddr);
+ vfree(pfe->apb_baseaddr);
+ vfree(pfe->cbus_baseaddr);
+ vfree(pfe->ddr_baseaddr);
+ platform_set_drvdata(pdev, NULL);
+
+ kfree(pfe);
+
+ return rc;
+}
+
+
+static struct platform_driver pfe_platform_driver = {
+ .probe = pfe_emulation_probe,
+ .remove = pfe_emulation_remove,
+ .driver = {
+ .name = "pfe",
+ },
+};
+
+
+static void pfe_device_release(struct device *dev)
+{
+
+}
+
+
+static struct platform_device pfe_platform_device = {
+ .name = "pfe",
+ .id = 0,
+ .dev.release = pfe_device_release,
+};
+
+static int __init pfe_module_init(void)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+ platform_device_register(&pfe_platform_device);
+
+ return platform_driver_register(&pfe_platform_driver);
+}
+
+
+static void __exit pfe_module_exit(void)
+{
+ platform_driver_unregister(&pfe_platform_driver);
+
+ platform_device_unregister(&pfe_platform_device);
+
+ printk(KERN_INFO "%s\n", __func__);
+}
+
+MODULE_LICENSE("GPL");
+module_init(pfe_module_init);
+module_exit(pfe_module_exit);
diff --git a/pfe_ctrl/pfe_eth.c b/pfe_ctrl/pfe_eth.c
new file mode 100644
index 0000000..d6681ac
--- /dev/null
+++ b/pfe_ctrl/pfe_eth.c
@@ -0,0 +1,2727 @@
+
+/** @pfe_eth.c.
+ * Ethernet driver for to handle exception path for PFE.
+ * - uses HIF functions to send/receive packets.
+ * - uses ctrl function to start/stop interfaces.
+ * - uses direct register accesses to control phy operation.
+ */
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/mii.h>
+#include <linux/phy.h>
+#include <linux/timer.h>
+#include <linux/hrtimer.h>
+#include <linux/platform_device.h>
+
+#include <net/ip.h>
+#include <net/sock.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/delay.h>
+
+#if defined(CONFIG_NF_CONNTRACK_MARK)
+#include <net/netfilter/nf_conntrack.h>
+#endif
+
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+#include <net/xfrm.h>
+#endif
+
+#include "pfe_mod.h"
+#include "pfe_eth.h"
+
+const char comcerto_eth_driver_version[]="1.0";
+static void *cbus_emac_base[3];
+static void *cbus_gpi_base[3];
+
+static void pfe_eth_exit_one(struct pfe_eth_priv_s *priv);
+static void pfe_eth_flush_tx(struct pfe_eth_priv_s *priv, int force);
+static void pfe_eth_flush_txQ(struct pfe_eth_priv_s *priv, int txQ_num, int from_tx, int n_desc);
+
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+extern struct xfrm_state *xfrm_state_lookup_byhandle(struct net *net, u16 handle);
+#endif
+
+unsigned int gemac_regs[] = {
+ 0x0000, /* Network control */
+ 0x0004, /* Network configuration */
+ 0x0008, /* Network status */
+ 0x0010, /* DMA configuration */
+ 0x0014, /* Transmit status */
+ 0x0020, /* Receive status */
+ 0x0024, /* Interrupt status */
+ 0x0030, /* Interrupt mask */
+ 0x0038, /* Received pause quantum */
+ 0x003c, /* Transmit pause quantum */
+ 0x0080, /* Hash register bottom [31:0] */
+ 0x0084, /* Hash register bottom [63:32] */
+ 0x0088, /* Specific address 1 bottom [31:0] */
+ 0x008c, /* Specific address 1 top [47:32] */
+ 0x0090, /* Specific address 2 bottom [31:0] */
+ 0x0094, /* Specific address 2 top [47:32] */
+ 0x0098, /* Specific address 3 bottom [31:0] */
+ 0x009c, /* Specific address 3 top [47:32] */
+ 0x00a0, /* Specific address 4 bottom [31:0] */
+ 0x00a4, /* Specific address 4 top [47:32] */
+ 0x00a8, /* Type ID Match 1 */
+ 0x00ac, /* Type ID Match 2 */
+ 0x00b0, /* Type ID Match 3 */
+ 0x00b4, /* Type ID Match 4 */
+ 0x00b8, /* Wake Up ON LAN */
+ 0x00bc, /* IPG stretch register */
+ 0x00c0, /* Stacked VLAN Register */
+ 0x00fc, /* Module ID */
+ 0x07a0 /* EMAC Control register */
+};
+
+/********************************************************************/
+/* SYSFS INTERFACE */
+/********************************************************************/
+#if defined(CONFIG_SMP) && (NR_CPUS > 1)
+/** pfe_eth_show_rx_cpu_affinity
+ *
+ */
+static ssize_t pfe_eth_show_rx_cpu_affinity(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+
+ return sprintf(buf, "%d\n", priv->cpu_id);
+}
+
+/** pfe_eth_set_rx_cpu_affinity
+ *
+ */
+static ssize_t pfe_eth_set_rx_cpu_affinity(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ unsigned int cpu_id = 0;
+
+ sscanf(buf, "%d", &cpu_id);
+
+ if (cpu_id < NR_CPUS) {
+ priv->cpu_id = (int)cpu_id;
+ hif_lib_set_rx_cpu_affinity(&priv->client, priv->cpu_id);
+ }
+ else
+ printk(KERN_ERR "%s: Invalid CPU (%d)\n", __func__, cpu_id);
+
+ return count;
+}
+#endif
+
+#ifdef PFE_ETH_TSO_STATS
+/** pfe_eth_show_tso_stats
+ *
+ */
+static ssize_t pfe_eth_show_tso_stats(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ ssize_t len = 0;
+ int i;
+
+ for (i = 0; i < 32; i++)
+ len += sprintf(buf + len, "TSO packets > %dKBytes = %u\n", i * 2, priv->tso.len_counters[i]);
+
+ return len;
+}
+
+/** pfe_eth_set_tso_stats
+ *
+ */
+static ssize_t pfe_eth_set_tso_stats(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+
+ memset(priv->tso.len_counters, 0, sizeof(priv->tso.len_counters));
+
+ return count;
+}
+#endif
+
+#ifdef PFE_ETH_LRO_STATS
+/*
+ * pfe_eth_show_lro_nb_stats
+ */
+static ssize_t pfe_eth_show_lro_nb_stats(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ ssize_t len = 0;
+ int i;
+
+ for (i = 0; i < LRO_NB_COUNT_MAX; i++)
+ len += sprintf(buf + len, "%d fragments packets = %u\n", i, priv->lro_nb_counters[i]);
+
+ return len;
+}
+
+/*
+ * pfe_eth_set_lro_nb_stats
+ */
+static ssize_t pfe_eth_set_lro_nb_stats(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+
+ memset(priv->lro_nb_counters, 0, sizeof(priv->lro_nb_counters));
+
+ return count;
+}
+
+/*
+ * pfe_eth_show_lro_len_stats
+ */
+static ssize_t pfe_eth_show_lro_len_stats(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ ssize_t len = 0;
+ int i;
+
+ for (i = 0; i < LRO_LEN_COUNT_MAX; i++)
+ len += sprintf(buf + len, "RX packets > %dKBytes = %u\n", i * 2, priv->lro_len_counters[i]);
+
+ return len;
+}
+
+/*
+ * pfe_eth_set_lro_len_stats
+ */
+static ssize_t pfe_eth_set_lro_len_stats(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+
+ memset(priv->lro_len_counters, 0, sizeof(priv->lro_len_counters));
+
+ return count;
+}
+#endif
+
+#ifdef PFE_ETH_NAPI_STATS
+/*
+ * pfe_eth_show_napi_stats
+ */
+static ssize_t pfe_eth_show_napi_stats(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ ssize_t len = 0;
+
+ len += sprintf(buf + len, "sched: %u\n", priv->napi_counters[NAPI_SCHED_COUNT]);
+ len += sprintf(buf + len, "poll: %u\n", priv->napi_counters[NAPI_POLL_COUNT]);
+ len += sprintf(buf + len, "packet: %u\n", priv->napi_counters[NAPI_PACKET_COUNT]);
+ len += sprintf(buf + len, "budget: %u\n", priv->napi_counters[NAPI_FULL_BUDGET_COUNT]);
+ len += sprintf(buf + len, "desc: %u\n", priv->napi_counters[NAPI_DESC_COUNT]);
+
+ return len;
+}
+
+/*
+ * pfe_eth_set_napi_stats
+ */
+static ssize_t pfe_eth_set_napi_stats(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+
+ memset(priv->napi_counters, 0, sizeof(priv->napi_counters));
+
+ return count;
+}
+#endif
+#ifdef PFE_ETH_TX_STATS
+/** pfe_eth_show_tx_stats
+ *
+ */
+static ssize_t pfe_eth_show_tx_stats(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ ssize_t len = 0;
+ int i;
+
+ len += sprintf(buf + len, "TX queues stats:\n");
+
+ for (i = 0; i < EMAC_TXQ_CNT; i++) {
+ struct netdev_queue *tx_queue = netdev_get_tx_queue(priv->dev, i);
+
+ len += sprintf(buf + len, "\n");
+ __netif_tx_lock_bh(tx_queue);
+
+ hif_tx_lock(&pfe->hif);
+ len += sprintf(buf + len, "Queue %2d : credits = %10d\n", i, hif_lib_tx_credit_avail(pfe, priv->id, i));
+ len += sprintf(buf + len, " tx packets = %10d\n", pfe->tmu_credit.tx_packets[priv->id][i]);
+ hif_tx_unlock(&pfe->hif);
+
+ /* Don't output additionnal stats if queue never used */
+ if (!pfe->tmu_credit.tx_packets[priv->id][i])
+ goto skip;
+
+ len += sprintf(buf + len, " clean_fail = %10d\n", priv->clean_fail[i]);
+ len += sprintf(buf + len, " stop_queue = %10d\n", priv->stop_queue_total[i]);
+ len += sprintf(buf + len, " stop_queue_hif = %10d\n", priv->stop_queue_hif[i]);
+ len += sprintf(buf + len, " stop_queue_hif_client = %10d\n", priv->stop_queue_hif_client[i]);
+ len += sprintf(buf + len, " stop_queue_credit = %10d\n", priv->stop_queue_credit[i]);
+skip:
+ __netif_tx_unlock_bh(tx_queue);
+ }
+ return len;
+}
+
+/** pfe_eth_set_tx_stats
+ *
+ */
+static ssize_t pfe_eth_set_tx_stats(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ int i;
+
+ for (i = 0; i < EMAC_TXQ_CNT; i++) {
+ struct netdev_queue *tx_queue = netdev_get_tx_queue(priv->dev, i);
+
+ __netif_tx_lock_bh(tx_queue);
+ priv->clean_fail[i] = 0;
+ priv->stop_queue_total[i] = 0;
+ priv->stop_queue_hif[i] = 0;
+ priv->stop_queue_hif_client[i]= 0;
+ priv->stop_queue_credit[i] = 0;
+ __netif_tx_unlock_bh(tx_queue);
+ }
+
+ return count;
+}
+#endif
+/** pfe_eth_show_txavail
+ *
+ */
+static ssize_t pfe_eth_show_txavail(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ ssize_t len = 0;
+ int i;
+
+ for (i = 0; i < EMAC_TXQ_CNT; i++) {
+ struct netdev_queue *tx_queue = netdev_get_tx_queue(priv->dev, i);
+
+ __netif_tx_lock_bh(tx_queue);
+
+ len += sprintf(buf + len, "%d", hif_lib_tx_avail(&priv->client, i));
+
+ __netif_tx_unlock_bh(tx_queue);
+
+ if (i == (EMAC_TXQ_CNT - 1))
+ len += sprintf(buf + len, "\n");
+ else
+ len += sprintf(buf + len, " ");
+ }
+
+ return len;
+}
+
+
+/** pfe_eth_show_default_priority
+ *
+ */
+static ssize_t pfe_eth_show_default_priority(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ unsigned long flags;
+ int rc;
+
+ spin_lock_irqsave(&priv->lock, flags);
+ rc = sprintf(buf, "%d\n", priv->default_priority);
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return rc;
+}
+
+/** pfe_eth_set_default_priority
+ *
+ */
+
+static ssize_t pfe_eth_set_default_priority(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(to_net_dev(dev));
+ unsigned long flags;
+
+ spin_lock_irqsave(&priv->lock, flags);
+ priv->default_priority = simple_strtoul(buf, NULL, 0);
+ spin_unlock_irqrestore(&priv->lock, flags);
+
+ return count;
+}
+
+#if defined(CONFIG_SMP) && (NR_CPUS > 1)
+static DEVICE_ATTR(rx_cpu_affinity, 0644, pfe_eth_show_rx_cpu_affinity, pfe_eth_set_rx_cpu_affinity);
+#endif
+
+static DEVICE_ATTR(txavail, 0444, pfe_eth_show_txavail, NULL);
+static DEVICE_ATTR(default_priority, 0644, pfe_eth_show_default_priority, pfe_eth_set_default_priority);
+
+#ifdef PFE_ETH_NAPI_STATS
+static DEVICE_ATTR(napi_stats, 0644, pfe_eth_show_napi_stats, pfe_eth_set_napi_stats);
+#endif
+
+#ifdef PFE_ETH_TX_STATS
+static DEVICE_ATTR(tx_stats, 0644, pfe_eth_show_tx_stats, pfe_eth_set_tx_stats);
+#endif
+
+#ifdef PFE_ETH_TSO_STATS
+static DEVICE_ATTR(tso_stats, 0644, pfe_eth_show_tso_stats, pfe_eth_set_tso_stats);
+#endif
+
+#ifdef PFE_ETH_LRO_STATS
+static DEVICE_ATTR(lro_nb_stats, 0644, pfe_eth_show_lro_nb_stats, pfe_eth_set_lro_nb_stats);
+static DEVICE_ATTR(lro_len_stats, 0644, pfe_eth_show_lro_len_stats, pfe_eth_set_lro_len_stats);
+#endif
+
+/** pfe_eth_sysfs_init
+ *
+ */
+static int pfe_eth_sysfs_init(struct net_device *dev)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ int err;
+
+ /* Initialize the default values */
+ /* By default, packets without conntrack will use this default high priority queue */
+ priv->default_priority = 15;
+
+ /* Create our sysfs files */
+ err = device_create_file(&dev->dev, &dev_attr_default_priority);
+ if (err) {
+ netdev_err(dev, "failed to create default_priority sysfs files\n");
+ goto err_priority;
+ }
+
+ err = device_create_file(&dev->dev, &dev_attr_txavail);
+ if (err) {
+ netdev_err(dev, "failed to create default_priority sysfs files\n");
+ goto err_txavail;
+ }
+
+#ifdef PFE_ETH_NAPI_STATS
+ err = device_create_file(&dev->dev, &dev_attr_napi_stats);
+ if (err) {
+ netdev_err(dev, "failed to create napi stats sysfs files\n");
+ goto err_napi;
+ }
+#endif
+
+#ifdef PFE_ETH_TX_STATS
+ err = device_create_file(&dev->dev, &dev_attr_tx_stats);
+ if (err) {
+ netdev_err(dev, "failed to create tx stats sysfs files\n");
+ goto err_tx;
+ }
+#endif
+
+#ifdef PFE_ETH_TSO_STATS
+ err = device_create_file(&dev->dev, &dev_attr_tso_stats);
+ if (err) {
+ netdev_err(dev, "failed to create tso stats sysfs files\n");
+ goto err_tso;
+ }
+#endif
+
+#ifdef PFE_ETH_LRO_STATS
+ err = device_create_file(&dev->dev, &dev_attr_lro_nb_stats);
+ if (err) {
+ netdev_err(dev, "failed to create lro nb stats sysfs files\n");
+ goto err_lro_nb;
+ }
+
+ err = device_create_file(&dev->dev, &dev_attr_lro_len_stats);
+ if (err) {
+ netdev_err(dev, "failed to create lro len stats sysfs files\n");
+ goto err_lro_len;
+ }
+#endif
+
+#if defined(CONFIG_SMP) && (NR_CPUS > 1)
+ err = device_create_file(&dev->dev, &dev_attr_rx_cpu_affinity);
+ if (err) {
+ netdev_err(dev, "failed to create rx cpu affinity sysfs file\n");
+ goto err_rx_affinity;
+ }
+#endif
+
+ return 0;
+
+#if defined(CONFIG_SMP) && (NR_CPUS > 1)
+err_rx_affinity:
+#ifdef PFE_ETH_LRO_STATS
+ device_remove_file(&dev->dev, &dev_attr_lro_len_stats);
+#endif
+#endif
+
+#ifdef PFE_ETH_LRO_STATS
+err_lro_len:
+ device_remove_file(&dev->dev, &dev_attr_lro_nb_stats);
+
+err_lro_nb:
+#endif
+
+#ifdef PFE_ETH_TSO_STATS
+ device_remove_file(&dev->dev, &dev_attr_tso_stats);
+
+err_tso:
+#endif
+#ifdef PFE_ETH_TX_STATS
+ device_remove_file(&dev->dev, &dev_attr_tx_stats);
+
+err_tx:
+#endif
+#ifdef PFE_ETH_NAPI_STATS
+ device_remove_file(&dev->dev, &dev_attr_napi_stats);
+
+err_napi:
+#endif
+ device_remove_file(&dev->dev, &dev_attr_txavail);
+
+err_txavail:
+ device_remove_file(&dev->dev, &dev_attr_default_priority);
+
+err_priority:
+ return -1;
+}
+
+/** pfe_eth_sysfs_exit
+ *
+ */
+void pfe_eth_sysfs_exit(struct net_device *dev)
+{
+#if defined(CONFIG_SMP) && (NR_CPUS > 1)
+ device_remove_file(&dev->dev, &dev_attr_rx_cpu_affinity);
+#endif
+
+#ifdef PFE_ETH_LRO_STATS
+ device_remove_file(&dev->dev, &dev_attr_lro_nb_stats);
+ device_remove_file(&dev->dev, &dev_attr_lro_len_stats);
+#endif
+
+#ifdef PFE_ETH_TSO_STATS
+ device_remove_file(&dev->dev, &dev_attr_tso_stats);
+#endif
+
+#ifdef PFE_ETH_TX_STATS
+ device_remove_file(&dev->dev, &dev_attr_tx_stats);
+#endif
+
+#ifdef PFE_ETH_NAPI_STATS
+ device_remove_file(&dev->dev, &dev_attr_napi_stats);
+#endif
+ device_remove_file(&dev->dev, &dev_attr_txavail);
+ device_remove_file(&dev->dev, &dev_attr_default_priority);
+}
+
+/*************************************************************************/
+/* ETHTOOL INTERCAE */
+/*************************************************************************/
+static char stat_gstrings[][ETH_GSTRING_LEN] = {
+ "tx- octets",
+ "tx- packets",
+ "tx- broadcast",
+ "tx- multicast",
+ "tx- pause",
+ "tx- 64 bytes packets",
+ "tx- 64 - 127 bytes packets",
+ "tx- 128 - 255 bytes packets",
+ "tx- 256 - 511 bytes packets",
+ "tx- 512 - 1023 bytes packets",
+ "tx- 1024 - 1518 bytes packets",
+ "tx- > 1518 bytes packets",
+ "tx- underruns - errors",
+ "tx- single collision",
+ "tx- multi collision",
+ "tx- exces. collision - errors",
+ "tx- late collision - errors",
+ "tx- deferred",
+ "tx- carrier sense - errors",
+ "rx- octets",
+ "rx- packets",
+ "rx- broadcast",
+ "rx- multicast",
+ "rx- pause",
+ "rx- 64 bytes packets",
+ "rx- 64 - 127 bytes packets",
+ "rx- 128 - 255 bytes packets",
+ "rx- 256 - 511 bytes packets",
+ "rx- 512 - 1023 bytes packets",
+ "rx- 1024 - 1518 bytes packets",
+ "rx- > 1518 bytes packets",
+ "rx- undersize -errors",
+ "rx- oversize - errors ",
+ "rx- jabbers - errors",
+ "rx- fcs - errors",
+ "rx- length - errors",
+ "rx- symbol - errors",
+ "rx- align - errors",
+ "rx- ressource - errors",
+ "rx- overrun - errors",
+ "rx- IP cksum - errors",
+ "rx- TCP cksum - errors",
+ "rx- UDP cksum - errors"
+};
+
+
+/**
+ * pfe_eth_gstrings - Fill in a buffer with the strings which correspond to
+ * the stats.
+ *
+ */
+static void pfe_eth_gstrings(struct net_device *dev, u32 stringset, u8 * buf)
+{
+ switch (stringset) {
+ case ETH_SS_STATS:
+ memcpy(buf, stat_gstrings, (EMAC_RMON_LEN - 2) * ETH_GSTRING_LEN);
+ break;
+
+ default:
+ WARN_ON(1);
+ break;
+ }
+}
+
+/**
+ * pfe_eth_fill_stats - Fill in an array of 64-bit statistics from
+ * various sources. This array will be appended
+ * to the end of the ethtool_stats* structure, and
+ * returned to user space
+ */
+static void pfe_eth_fill_stats(struct net_device *dev, struct ethtool_stats *dummy, u64 * buf)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ int i;
+ for (i=0;i<EMAC_RMON_LEN;i++, buf++) {
+ *buf = readl(priv->EMAC_baseaddr + EMAC_RMON_BASE_OFST + (i << 2));
+ if ( ( i == EMAC_RMON_TXBYTES_POS ) || ( i == EMAC_RMON_RXBYTES_POS ) ){
+ i++;
+ *buf |= (u64)readl(priv->EMAC_baseaddr + EMAC_RMON_BASE_OFST + (i << 2)) << 32;
+ }
+ }
+
+}
+
+/**
+ * pfe_eth_stats_count - Returns the number of stats (and their corresponding strings)
+ *
+ */
+static int pfe_eth_stats_count(struct net_device *dev, int sset)
+{
+ switch (sset) {
+ case ETH_SS_STATS:
+ return EMAC_RMON_LEN - 2;
+ default:
+ return -EOPNOTSUPP;
+ }
+}
+
+/**
+ * pfe_eth_get_drvinfo - Fills in the drvinfo structure with some basic info
+ *
+ */
+static void pfe_eth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
+{
+ strncpy(drvinfo->driver, DRV_NAME, COMCERTO_INFOSTR_LEN);
+ strncpy(drvinfo->version, comcerto_eth_driver_version, COMCERTO_INFOSTR_LEN);
+ strncpy(drvinfo->fw_version, "N/A", COMCERTO_INFOSTR_LEN);
+ strncpy(drvinfo->bus_info, "N/A", COMCERTO_INFOSTR_LEN);
+ drvinfo->testinfo_len = 0;
+ drvinfo->regdump_len = 0;
+ drvinfo->eedump_len = 0;
+}
+
+/**
+ * pfe_eth_set_settings - Used to send commands to PHY.
+ *
+ */
+
+static int pfe_eth_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ struct phy_device *phydev = priv->phydev;
+
+ if (NULL == phydev)
+ return -ENODEV;
+
+ return phy_ethtool_sset(phydev, cmd);
+}
+
+
+/**
+ * pfe_eth_getsettings - Return the current settings in the ethtool_cmd structure.
+ *
+ */
+static int pfe_eth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ struct phy_device *phydev = priv->phydev;
+
+ if (NULL == phydev)
+ return -ENODEV;
+
+ return phy_ethtool_gset(phydev, cmd);
+}
+
+/**
+ * pfe_eth_gemac_reglen - Return the length of the register structure.
+ *
+ */
+static int pfe_eth_gemac_reglen(struct net_device *dev)
+{
+ return (sizeof (gemac_regs)/ sizeof(u32)) + (( MAX_UC_SPEC_ADDR_REG - 3 ) * 2);
+}
+
+/**
+ * pfe_eth_gemac_get_regs - Return the gemac register structure.
+ *
+ */
+static void pfe_eth_gemac_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf)
+{
+ int i,j;
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ u32 *buf = (u32 *) regbuf;
+
+ for (i = 0; i < sizeof (gemac_regs) / sizeof (u32); i++)
+ buf[i] = readl( priv->EMAC_baseaddr + gemac_regs[i] );
+
+ for (j = 0; j < (( MAX_UC_SPEC_ADDR_REG - 3 ) * 2); j++,i++)
+ buf[i] = readl( priv->EMAC_baseaddr + EMAC_SPEC5_ADD_BOT + (j<<2) );
+
+}
+
+/**
+ * pfe_eth_get_msglevel - Gets the debug message mask.
+ *
+ */
+static uint32_t pfe_eth_get_msglevel(struct net_device *dev)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+
+ return priv->msg_enable;
+}
+
+/**
+ * pfe_eth_set_msglevel - Sets the debug message mask.
+ *
+ */
+static void pfe_eth_set_msglevel(struct net_device *dev, uint32_t data)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+
+ priv->msg_enable = data;
+}
+
+#define HIF_RX_COAL_MAX_CLKS (~(1<<31))
+#define HIF_RX_COAL_CLKS_PER_USEC (pfe->ctrl.sys_clk/1000)
+#define HIF_RX_COAL_MAX_USECS (HIF_RX_COAL_MAX_CLKS/HIF_RX_COAL_CLKS_PER_USEC)
+
+/**
+ * pfe_eth_set_coalesce - Sets rx interrupt coalescing timer.
+ *
+ */
+static int pfe_eth_set_coalesce(struct net_device *dev,
+ struct ethtool_coalesce *ec)
+{
+ if (ec->rx_coalesce_usecs > HIF_RX_COAL_MAX_USECS)
+ return -EINVAL;
+
+ if (!ec->rx_coalesce_usecs) {
+ writel(0, HIF_INT_COAL);
+ return 0;
+ }
+
+ writel((ec->rx_coalesce_usecs * HIF_RX_COAL_CLKS_PER_USEC) | HIF_INT_COAL_ENABLE, HIF_INT_COAL);
+
+ return 0;
+}
+
+/**
+ * pfe_eth_get_coalesce - Gets rx interrupt coalescing timer value.
+ *
+ */
+static int pfe_eth_get_coalesce(struct net_device *dev,
+ struct ethtool_coalesce *ec)
+{
+ int reg_val = readl(HIF_INT_COAL);
+
+ if (reg_val & HIF_INT_COAL_ENABLE)
+ ec->rx_coalesce_usecs = (reg_val & HIF_RX_COAL_MAX_CLKS) / HIF_RX_COAL_CLKS_PER_USEC;
+ else
+ ec->rx_coalesce_usecs = 0;
+
+ return 0;
+}
+
+/**
+ * pfe_eth_pause_rx_enabled - Tests if pause rx is enabled on GEM
+ *
+ */
+static int pfe_eth_pause_rx_enabled(struct pfe_eth_priv_s *priv)
+{
+ return (readl(priv->EMAC_baseaddr + EMAC_NETWORK_CONFIG) & EMAC_ENABLE_PAUSE_RX) != 0;
+}
+
+/**
+ * pfe_eth_set_pauseparam - Sets pause parameters
+ *
+ */
+static int pfe_eth_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+
+ if (epause->rx_pause)
+ {
+ gemac_enable_pause_rx(priv->EMAC_baseaddr);
+ if (priv->phydev)
+ priv->phydev->advertising |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
+ }
+ else
+ {
+ gemac_disable_pause_rx(priv->EMAC_baseaddr);
+ if (priv->phydev)
+ priv->phydev->advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
+ }
+
+ return 0;
+}
+
+/**
+ * pfe_eth_get_pauseparam - Gets pause parameters
+ *
+ */
+static void pfe_eth_get_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+
+ epause->autoneg = 0;
+ epause->tx_pause = 0;
+ epause->rx_pause = pfe_eth_pause_rx_enabled(priv);
+}
+
+
+struct ethtool_ops pfe_ethtool_ops = {
+ .get_settings = pfe_eth_get_settings,
+ .set_settings = pfe_eth_set_settings,
+ .get_drvinfo = pfe_eth_get_drvinfo,
+ .get_regs_len = pfe_eth_gemac_reglen,
+ .get_regs = pfe_eth_gemac_get_regs,
+ .get_link = ethtool_op_get_link,
+ .get_strings = pfe_eth_gstrings,
+ .get_sset_count = pfe_eth_stats_count,
+ .get_ethtool_stats = pfe_eth_fill_stats,
+ .get_msglevel = pfe_eth_get_msglevel,
+ .set_msglevel = pfe_eth_set_msglevel,
+ .set_coalesce = pfe_eth_set_coalesce,
+ .get_coalesce = pfe_eth_get_coalesce,
+ .set_pauseparam = pfe_eth_set_pauseparam,
+ .get_pauseparam = pfe_eth_get_pauseparam,
+};
+
+
+
+/** pfe_eth_mdio_reset
+ */
+static int pfe_eth_mdio_reset(struct mii_bus *bus)
+{
+ struct pfe_eth_priv_s *priv = (struct pfe_eth_priv_s *)bus->priv;
+
+ netif_info(priv, drv, priv->dev, "%s\n", __func__);
+
+#if !defined(CONFIG_PLATFORM_EMULATION)
+ mutex_lock(&bus->mdio_lock);
+
+ /* Setup the MII Mgmt clock speed */
+ gemac_set_mdc_div(priv->EMAC_baseaddr, priv->mdc_div);
+
+ /* Reset the management interface */
+ __raw_writel(__raw_readl(priv->EMAC_baseaddr + EMAC_NETWORK_CONTROL) | EMAC_MDIO_EN,
+ priv->EMAC_baseaddr + EMAC_NETWORK_CONTROL);
+
+ /* Wait until the bus is free */
+ while(!(__raw_readl(priv->EMAC_baseaddr + EMAC_NETWORK_STATUS) & EMAC_PHY_IDLE));
+
+ mutex_unlock(&bus->mdio_lock);
+#endif
+
+ return 0;
+}
+
+
+/** pfe_eth_gemac_phy_timeout
+ *
+ */
+static int pfe_eth_gemac_phy_timeout(struct pfe_eth_priv_s *priv, int timeout)
+{
+ while(!(__raw_readl(priv->EMAC_baseaddr + EMAC_NETWORK_STATUS) & EMAC_PHY_IDLE)) {
+
+ if (timeout-- <= 0) {
+ return -1;
+ }
+
+ udelay(10);
+ }
+
+ return 0;
+}
+
+
+/** pfe_eth_mdio_write
+ */
+static int pfe_eth_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value)
+{
+ struct pfe_eth_priv_s *priv = (struct pfe_eth_priv_s *)bus->priv;
+ u32 write_data;
+
+#if !defined(CONFIG_PLATFORM_EMULATION)
+
+ netif_info(priv, hw, priv->dev, "%s: phy %d\n", __func__, mii_id);
+
+// netif_info(priv, hw, priv->dev, "%s %d %d %x\n", bus->id, mii_id, regnum, value);
+
+ write_data = 0x50020000;
+ write_data |= ((mii_id << 23) | (regnum << 18) | value);
+ __raw_writel(write_data, priv->EMAC_baseaddr + EMAC_PHY_MANAGEMENT);
+
+ if (pfe_eth_gemac_phy_timeout(priv, EMAC_MDIO_TIMEOUT)){
+ netdev_err(priv->dev, "%s: phy MDIO write timeout\n", __func__);
+ return -1;
+ }
+
+#endif
+
+ return 0;
+}
+
+
+/** pfe_eth_mdio_read
+ */
+static int pfe_eth_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+ struct pfe_eth_priv_s *priv = (struct pfe_eth_priv_s *)bus->priv;
+ u16 value = 0;
+ u32 write_data;
+
+#if !defined(CONFIG_PLATFORM_EMULATION)
+ netif_info(priv, hw, priv->dev, "%s: phy %d\n", __func__, mii_id);
+
+ write_data = 0x60020000;
+ write_data |= ((mii_id << 23) | (regnum << 18));
+
+ __raw_writel(write_data, priv->EMAC_baseaddr + EMAC_PHY_MANAGEMENT);
+
+ if (pfe_eth_gemac_phy_timeout( priv, EMAC_MDIO_TIMEOUT)) {
+ netdev_err(priv->dev, "%s: phy MDIO read timeout\n", __func__);
+ return -1;
+ }
+
+ value = __raw_readl(priv->EMAC_baseaddr + EMAC_PHY_MANAGEMENT) & 0xFFFF;
+#endif
+
+// netif_info(priv, hw, priv->dev, "%s %d %d %x\n", bus->id, mii_id, regnum, value);
+
+ return value;
+}
+
+
+/** pfe_eth_mdio_init
+ */
+static int pfe_eth_mdio_init(struct pfe_eth_priv_s *priv, struct comcerto_mdio_platform_data *minfo)
+{
+ struct mii_bus *bus;
+ int rc;
+
+ netif_info(priv, drv, priv->dev, "%s\n", __func__);
+
+#if !defined(CONFIG_PLATFORM_EMULATION)
+ bus = mdiobus_alloc();
+ if (!bus) {
+ netdev_err(priv->dev, "mdiobus_alloc() failed\n");
+ rc = -ENOMEM;
+ goto err0;
+ }
+
+ bus->name = "Comcerto MDIO Bus";
+ bus->read = &pfe_eth_mdio_read;
+ bus->write = &pfe_eth_mdio_write;
+ bus->reset = &pfe_eth_mdio_reset;
+ snprintf(bus->id, MII_BUS_ID_SIZE, "comcerto-%x", priv->id);
+ bus->priv = priv;
+
+ bus->phy_mask = minfo->phy_mask;
+ priv->mdc_div = minfo->mdc_div;
+
+ if (!priv->mdc_div)
+ priv->mdc_div = 64;
+
+ bus->irq = minfo->irq;
+
+ bus->parent = priv->pfe->dev;
+
+ netif_info(priv, drv, priv->dev, "%s: mdc_div: %d, phy_mask: %x \n", __func__, priv->mdc_div, bus->phy_mask);
+
+ rc = mdiobus_register(bus);
+ if (rc) {
+ netdev_err(priv->dev, "mdiobus_register(%s) failed\n", bus->name);
+ goto err1;
+ }
+
+ priv->mii_bus = bus;
+
+ return 0;
+
+err1:
+ mdiobus_free(bus);
+err0:
+ return rc;
+#else
+ return 0;
+#endif
+
+}
+
+/** pfe_eth_mdio_exit
+ */
+static void pfe_eth_mdio_exit(struct mii_bus *bus)
+{
+ if (!bus)
+ return;
+
+ netif_info((struct pfe_eth_priv_s *)bus->priv, drv, ((struct pfe_eth_priv_s *)(bus->priv))->dev, "%s\n", __func__);
+
+ mdiobus_unregister(bus);
+ mdiobus_free(bus);
+}
+
+/** pfe_get_interface
+ */
+static phy_interface_t pfe_get_interface(struct net_device *dev)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ u32 mii_mode = priv->einfo->mii_config;
+
+ netif_info(priv, drv, dev, "%s\n", __func__);
+
+ if (priv->einfo->gemac_mode & (GEMAC_SW_CONF)) {
+ switch (mii_mode) {
+ case CONFIG_COMCERTO_USE_GMII:
+ return PHY_INTERFACE_MODE_GMII;
+ break;
+ case CONFIG_COMCERTO_USE_RGMII:
+ return PHY_INTERFACE_MODE_RGMII;
+ break;
+ case CONFIG_COMCERTO_USE_RMII:
+ return PHY_INTERFACE_MODE_RMII;
+ break;
+ case CONFIG_COMCERTO_USE_SGMII:
+ return PHY_INTERFACE_MODE_SGMII;
+ break;
+
+ default :
+ case CONFIG_COMCERTO_USE_MII:
+ return PHY_INTERFACE_MODE_MII;
+ break;
+
+ }
+ } else {
+ // Bootstrap config read from controller
+ BUG();
+ return 0;
+ }
+}
+
+/** pfe_get_phydev_speed
+ */
+static int pfe_get_phydev_speed(struct phy_device *phydev)
+{
+ switch (phydev->speed) {
+ case 10:
+ return SPEED_10M;
+ case 100:
+ return SPEED_100M;
+ case 1000:
+ default:
+ return SPEED_1000M;
+ }
+
+}
+
+/** pfe_get_phydev_duplex
+ */
+static int pfe_get_phydev_duplex(struct phy_device *phydev)
+{
+ return ( phydev->duplex == DUPLEX_HALF ) ? DUP_HALF:DUP_FULL ;
+}
+
+/** pfe_eth_adjust_link
+ */
+static void pfe_eth_adjust_link(struct net_device *dev)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ unsigned long flags;
+ struct phy_device *phydev = priv->phydev;
+ int new_state = 0;
+
+ netif_info(priv, drv, dev, "%s\n", __func__);
+
+ spin_lock_irqsave(&priv->lock, flags);
+ if (phydev->link) {
+ /* Now we make sure that we can be in full duplex mode.
+ * If not, we operate in half-duplex mode. */
+ if (phydev->duplex != priv->oldduplex) {
+ new_state = 1;
+ gemac_set_duplex(priv->EMAC_baseaddr, pfe_get_phydev_duplex(phydev));
+ priv->oldduplex = phydev->duplex;
+ }
+
+ if (phydev->speed != priv->oldspeed) {
+ new_state = 1;
+ gemac_set_speed(priv->EMAC_baseaddr, pfe_get_phydev_speed(phydev));
+ priv->oldspeed = phydev->speed;
+ }
+
+ if (!priv->oldlink) {
+ new_state = 1;
+ priv->oldlink = 1;
+ }
+
+ } else if (priv->oldlink) {
+ new_state = 1;
+ priv->oldlink = 0;
+ priv->oldspeed = 0;
+ priv->oldduplex = -1;
+ }
+
+ if (new_state && netif_msg_link(priv))
+ phy_print_status(phydev);
+
+ spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+
+/** pfe_phy_exit
+ */
+static void pfe_phy_exit(struct net_device *dev)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+
+ netif_info(priv, drv, dev, "%s\n", __func__);
+
+ phy_disconnect(priv->phydev);
+ priv->phydev = NULL;
+}
+
+/** pfe_eth_stop
+ */
+static void pfe_eth_stop( struct net_device *dev )
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+
+ netif_info(priv, drv, dev, "%s\n", __func__);
+
+ gemac_disable(priv->EMAC_baseaddr);
+ gpi_disable(priv->GPI_baseaddr);
+
+ if (priv->phydev)
+ phy_stop(priv->phydev);
+}
+
+/** pfe_eth_start
+ */
+static int pfe_eth_start( struct pfe_eth_priv_s *priv )
+{
+ netif_info(priv, drv, priv->dev, "%s\n", __func__);
+
+ if (priv->phydev)
+ phy_start(priv->phydev);
+
+ gpi_enable(priv->GPI_baseaddr);
+ gemac_enable(priv->EMAC_baseaddr);
+
+ return 0;
+}
+
+/** pfe_phy_init
+ *
+ */
+static int pfe_phy_init(struct net_device *dev)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ struct phy_device *phydev;
+ char phy_id[MII_BUS_ID_SIZE + 3];
+ char bus_id[MII_BUS_ID_SIZE];
+ phy_interface_t interface;
+
+ priv->oldlink = 0;
+ priv->oldspeed = 0;
+ priv->oldduplex = -1;
+
+ sprintf(bus_id, "comcerto-%d", priv->einfo->bus_id);
+ snprintf(phy_id, MII_BUS_ID_SIZE + 3, PHY_ID_FMT, bus_id, priv->einfo->phy_id);
+
+ netif_info(priv, drv, dev, "%s: %s\n", __func__, phy_id);
+
+ interface = pfe_get_interface(dev);
+
+ priv->oldlink = 0;
+ priv->oldspeed = 0;
+ priv->oldduplex = -1;
+
+ phydev = phy_connect(dev, phy_id, &pfe_eth_adjust_link, 0, interface);
+
+ if (IS_ERR(phydev)) {
+ netdev_err(dev, "phy_connect() failed\n");
+ return PTR_ERR(phydev);
+ }
+
+ priv->phydev = phydev;
+
+ phydev->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
+ if (pfe_eth_pause_rx_enabled(priv))
+ phydev->advertising |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
+ else
+ phydev->advertising &= ~(ADVERTISED_Pause | ADVERTISED_Asym_Pause);
+
+ return 0;
+}
+
+/** pfe_gemac_init
+ */
+static int pfe_gemac_init(struct pfe_eth_priv_s *priv)
+{
+ GEMAC_CFG cfg;
+
+ netif_info(priv, ifup, priv->dev, "%s\n", __func__);
+
+ /* software config */
+ /* MII interface mode selection */
+ switch (priv->einfo->mii_config) {
+ case CONFIG_COMCERTO_USE_GMII:
+ cfg.mode = GMII;
+ break;
+
+ case CONFIG_COMCERTO_USE_MII:
+ cfg.mode = MII;
+ break;
+
+ case CONFIG_COMCERTO_USE_RGMII:
+ cfg.mode = RGMII;
+ break;
+
+ case CONFIG_COMCERTO_USE_RMII:
+ cfg.mode = RMII;
+ break;
+
+ case CONFIG_COMCERTO_USE_SGMII:
+ cfg.mode = SGMII;
+ break;
+
+ default:
+ cfg.mode = RGMII;
+ }
+
+ /* Speed selection */
+ switch (priv->einfo->gemac_mode & GEMAC_SW_SPEED_1G ) {
+ case GEMAC_SW_SPEED_1G:
+ cfg.speed = SPEED_1000M;
+ break;
+
+ case GEMAC_SW_SPEED_100M:
+ cfg.speed = SPEED_100M;
+ break;
+
+ case GEMAC_SW_SPEED_10M:
+ cfg.speed = SPEED_10M;
+ break;
+
+ default:
+ cfg.speed = SPEED_1000M;
+ }
+
+ /* Duplex selection */
+ cfg.duplex = ( priv->einfo->gemac_mode & GEMAC_SW_FULL_DUPLEX ) ? DUPLEX_FULL : DUPLEX_HALF;
+
+ gemac_set_config( priv->EMAC_baseaddr, &cfg);
+ gemac_allow_broadcast( priv->EMAC_baseaddr );
+ gemac_disable_unicast( priv->EMAC_baseaddr );
+ gemac_disable_multicast( priv->EMAC_baseaddr );
+ gemac_disable_fcs_rx( priv->EMAC_baseaddr );
+ gemac_enable_1536_rx( priv->EMAC_baseaddr );
+ gemac_enable_rx_jmb( priv->EMAC_baseaddr );
+ gemac_enable_pause_rx( priv->EMAC_baseaddr );
+ gemac_set_bus_width(priv->EMAC_baseaddr, 64);
+
+ /*GEM will perform checksum verifications*/
+ if (priv->dev->features & NETIF_F_RXCSUM)
+ gemac_enable_rx_checksum_offload(priv->EMAC_baseaddr);
+ else
+ gemac_disable_rx_checksum_offload(priv->EMAC_baseaddr);
+
+ return 0;
+}
+
+/** pfe_eth_event_handler
+ */
+static int pfe_eth_event_handler(void *data, int event, int qno)
+{
+ struct pfe_eth_priv_s *priv = data;
+
+ switch (event) {
+ case EVENT_RX_PKT_IND:
+
+ if (qno == 0) {
+ if (napi_schedule_prep(&priv->high_napi)) {
+ netif_info(priv, intr, priv->dev, "%s: schedule high prio poll\n", __func__);
+
+#ifdef PFE_ETH_NAPI_STATS
+ priv->napi_counters[NAPI_SCHED_COUNT]++;
+#endif
+
+ __napi_schedule(&priv->high_napi);
+ }
+ }
+ else if (qno == 1) {
+ if (napi_schedule_prep(&priv->low_napi)) {
+ netif_info(priv, intr, priv->dev, "%s: schedule low prio poll\n", __func__);
+
+#ifdef PFE_ETH_NAPI_STATS
+ priv->napi_counters[NAPI_SCHED_COUNT]++;
+#endif
+ __napi_schedule(&priv->low_napi);
+ }
+ }
+ else if (qno == 2) {
+ if (napi_schedule_prep(&priv->lro_napi)) {
+ netif_info(priv, intr, priv->dev, "%s: schedule lro prio poll\n", __func__);
+
+#ifdef PFE_ETH_NAPI_STATS
+ priv->napi_counters[NAPI_SCHED_COUNT]++;
+#endif
+ __napi_schedule(&priv->lro_napi);
+ }
+ }
+
+ break;
+
+ case EVENT_TXDONE_IND:
+ case EVENT_HIGH_RX_WM:
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+/** pfe_eth_open
+ */
+static int pfe_eth_open( struct net_device *dev )
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ struct hif_client_s *client;
+ int rc;
+
+ netif_info(priv, ifup, dev, "%s\n", __func__);
+
+ /* Register client driver with HIF */
+ client = &priv->client;
+ memset(client, 0, sizeof(*client));
+ client->id = PFE_CL_GEM0 + priv->id;
+ client->tx_qn = EMAC_TXQ_CNT;
+ client->rx_qn = EMAC_RXQ_CNT;
+ client->priv = priv;
+ client->pfe = priv->pfe;
+ client->event_handler = pfe_eth_event_handler;
+ client->user_cpu_id = priv->cpu_id;
+
+ /* FIXME : For now hif lib sets all tx and rx queues to same size */
+ client->tx_qsize = EMAC_TXQ_DEPTH;
+ client->rx_qsize = EMAC_RXQ_DEPTH;
+
+ if ((rc = hif_lib_client_register(client))) {
+ netdev_err(dev, "%s: hif_lib_client_register(%d) failed\n", __func__, client->id);
+ goto err0;
+ }
+
+ netif_info(priv, drv, dev, "%s: registered client: %p\n", __func__, client);
+
+ /* Enable gemac tx clock */
+ clk_enable(priv->gemtx_clk);
+
+ pfe_gemac_init(priv);
+
+ if (!is_valid_ether_addr(dev->dev_addr)) {
+ netdev_err(dev, "%s: invalid MAC address\n", __func__);
+ rc = -EADDRNOTAVAIL;
+ goto err1;
+ }
+
+ gemac_set_laddrN( priv->EMAC_baseaddr, ( MAC_ADDR *)dev->dev_addr, 1 );
+
+
+ if (!(priv->einfo->phy_flags & GEMAC_NO_PHY)) {
+ rc = pfe_phy_init(dev);
+ if (rc) {
+ netdev_err(dev, "%s: pfe_phy_init() failed\n", __func__);
+ goto err2;
+ }
+ }
+
+ napi_enable(&priv->high_napi);
+ napi_enable(&priv->low_napi);
+ napi_enable(&priv->lro_napi);
+
+ rc = pfe_eth_start( priv );
+ netif_tx_wake_all_queues(dev);
+
+ pfe_ctrl_set_eth_state(priv->id, 1, dev->dev_addr);
+
+ priv->tx_timer.expires = jiffies + ( COMCERTO_TX_RECOVERY_TIMEOUT_MS * HZ )/1000;
+ add_timer(&priv->tx_timer);
+
+ return 0;
+err2:
+ pfe_ctrl_set_eth_state(priv->id, 0, NULL);
+
+err1:
+ hif_lib_client_unregister(&priv->client);
+ clk_disable(priv->gemtx_clk);
+
+err0:
+ return rc;
+}
+#define TX_POLL_TIMEOUT_MS 1000
+/** pfe_eth_close
+ */
+static int pfe_eth_close( struct net_device *dev )
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ int i, qstatus;
+ unsigned long next_poll = jiffies + 1, end = jiffies + (TX_POLL_TIMEOUT_MS * HZ) / 1000;
+ int tx_pkts, prv_tx_pkts;
+
+ netif_info(priv, ifdown, dev, "%s\n", __func__);
+
+ del_timer_sync(&priv->tx_timer);
+
+ for(i = 0; i < EMAC_TXQ_CNT; i++)
+ hrtimer_cancel(&priv->fast_tx_timeout[i].timer);
+
+ netif_tx_stop_all_queues(dev);
+
+ pfe_eth_flush_tx(priv, 1);
+
+ /*Disable transmit in PFE before disabling GEMAC */
+ pfe_ctrl_set_eth_state(priv->id, 0, NULL);
+
+ prv_tx_pkts = tmu_pkts_processed(priv->id);
+ /*Wait till TMU transmits all pending packets
+ * poll tmu_qstatus and pkts processed by TMU for every 10ms
+ * Consider TMU is busy, If we see TMU qeueu pending or any packets processed by TMU
+ */
+ while(1) {
+
+ if (time_after(jiffies, next_poll)) {
+
+ tx_pkts = tmu_pkts_processed(priv->id);
+ qstatus = tmu_qstatus(priv->id) & 0x7ffff;
+
+ if(!qstatus && (tx_pkts == prv_tx_pkts)) {
+ break;
+ }
+ /*Don't wait forever, break if we cross max timeout(TX_POLL_TIMEOUT_MS) */
+ if (time_after(jiffies, end)) {
+ printk(KERN_ERR "TMU%d is busy after %dmsec\n", priv->id, TX_POLL_TIMEOUT_MS);
+ break;
+ }
+ prv_tx_pkts = tx_pkts;
+ next_poll++;
+ }
+ if (need_resched())
+ schedule();
+
+
+ }
+ /* Wait for some more time to complete transmitting packet if any */
+ next_poll = jiffies + 1;
+ while(1) {
+ if (time_after(jiffies, next_poll))
+ break;
+ if (need_resched())
+ schedule();
+ }
+
+ pfe_eth_stop(dev);
+
+ napi_disable(&priv->lro_napi);
+ napi_disable(&priv->low_napi);
+ napi_disable(&priv->high_napi);
+
+ if (!(priv->einfo->phy_flags & GEMAC_NO_PHY))
+ pfe_phy_exit(dev);
+
+
+ /* Disable gemac tx clock */
+ clk_disable(priv->gemtx_clk);
+
+ hif_lib_client_unregister(&priv->client);
+
+ return 0;
+}
+
+
+/** pfe_eth_get_priority
+ *
+ */
+static int pfe_eth_get_queuenum( struct pfe_eth_priv_s *priv, struct sk_buff *skb )
+{
+ int queuenum;
+ unsigned long flags;
+
+ /* Get the FPP queue number from the CONNMARK value */
+#if defined(CONFIG_IP_NF_CONNTRACK_MARK) || defined(CONFIG_NF_CONNTRACK_MARK)
+ if (skb->nfct) {
+ enum ip_conntrack_info cinfo;
+ struct nf_conn *ct;
+ ct = nf_ct_get(skb, &cinfo);
+
+ if (ct) {
+ u_int32_t connmark;
+ connmark = ct->mark;
+
+ if ((connmark & 0x80000000) && priv->id != 0)
+ connmark >>= 16;
+
+ queuenum = connmark & EMAC_QUEUENUM_MASK;
+ }
+ else
+ queuenum = 0;
+ }
+ else /* continued after #endif ... */
+#endif
+ if (skb->mark & EMAC_QUEUENUM_MASK)
+ queuenum = skb->mark & EMAC_QUEUENUM_MASK;
+ else{
+ spin_lock_irqsave(&priv->lock, flags);
+ queuenum = priv->default_priority & EMAC_QUEUENUM_MASK;
+ spin_unlock_irqrestore(&priv->lock, flags);
+ }
+ return queuenum;
+}
+
+
+
+/** pfe_eth_might_stop_tx
+ *
+ */
+static int pfe_eth_might_stop_tx(struct pfe_eth_priv_s *priv, int queuenum, struct netdev_queue *tx_queue, unsigned int n_desc, unsigned int n_segs)
+{
+ int tried = 0;
+ ktime_t kt;
+
+try_again:
+ if (unlikely((__hif_tx_avail(&pfe->hif) < n_desc)
+ || (hif_lib_tx_avail(&priv->client, queuenum) < n_desc)
+ || (hif_lib_tx_credit_avail(pfe, priv->id, queuenum) < n_segs))) {
+
+ if (!tried) {
+ hif_tx_unlock(&pfe->hif);
+ pfe_eth_flush_txQ(priv, queuenum, 1, n_desc);
+ hif_lib_update_credit(&priv->client, queuenum);
+ tried = 1;
+ hif_tx_lock(&pfe->hif);
+ goto try_again;
+ }
+#ifdef PFE_ETH_TX_STATS
+ if (__hif_tx_avail(&pfe->hif) < n_desc)
+ priv->stop_queue_hif[queuenum]++;
+ else if (hif_lib_tx_avail(&priv->client, queuenum) < n_desc) {
+ priv->stop_queue_hif_client[queuenum]++;
+ }
+ else if (hif_lib_tx_credit_avail(pfe, priv->id, queuenum) < n_segs) {
+ priv->stop_queue_credit[queuenum]++;
+ }
+ priv->stop_queue_total[queuenum]++;
+#endif
+ netif_tx_stop_queue(tx_queue);
+
+ kt = ktime_set(0, COMCERTO_TX_FAST_RECOVERY_TIMEOUT_MS * NSEC_PER_MSEC);
+ hrtimer_start(&priv->fast_tx_timeout[queuenum].timer, kt, HRTIMER_MODE_REL);
+ return -1;
+ }
+ else {
+ return 0;
+ }
+}
+
+#define SA_MAX_OP 2
+/** pfe_hif_send_packet
+ *
+ * At this level if TX fails we drop the packet
+ */
+static void pfe_hif_send_packet( struct sk_buff *skb, struct pfe_eth_priv_s *priv, int queuenum)
+{
+ struct skb_shared_info *sh = skb_shinfo(skb);
+ unsigned int nr_frags, nr_bytes;
+ u32 ctrl = 0;
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+ int i;
+ u16 sah[SA_MAX_OP] = {0};
+ struct hif_ipsec_hdr *hif_ipsec;
+#endif
+
+ netif_info(priv, tx_queued, priv->dev, "%s\n", __func__);
+
+ if (skb_is_gso(skb)) {
+ if(likely(nr_bytes = pfe_tso(skb, &priv->client, &priv->tso, queuenum, 0))) {
+
+ hif_lib_tx_credit_use(pfe, priv->id, queuenum, sh->gso_segs);
+ priv->stats.tx_packets += sh->gso_segs;
+ priv->stats.tx_bytes += nr_bytes;
+ }
+ else
+ priv->stats.tx_dropped++;
+
+ return;
+ }
+
+ if (skb->ip_summed == CHECKSUM_PARTIAL) {
+ if (skb->len > 1522) {
+ *(u16*)(skb_transport_header(skb) + skb->csum_offset) = csum_fold(csum_partial(skb_transport_header(skb), skb->len - skb_transport_offset(skb), 0));
+ skb->ip_summed = 0;
+ ctrl = 0;
+ }
+ else
+ ctrl = HIF_CTRL_TX_CHECKSUM;
+ }
+
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+ /* check if packet sent from Host to PFE needs IPsec processing */
+ if (skb->ipsec_offload)
+ {
+ if (skb->sp)
+ {
+ for (i = skb->sp->len-1; i >= 0; i--)
+ {
+ struct xfrm_state *x = skb->sp->xvec[i];
+ sah[i] = htons(x->handle);
+ }
+
+ ctrl |= HIF_CTRL_TX_IPSEC_OUT;
+
+ /* add SA info to the hif header*/
+ hif_ipsec = (struct hif_ipsec_hdr *)(skb->data - sizeof(struct hif_ipsec_hdr));
+ hif_ipsec->sa_handle[0] = sah[0];
+ hif_ipsec->sa_handle[1] = sah[1];
+
+ skb->data -= sizeof(struct hif_ipsec_hdr);
+ skb->len += sizeof(struct hif_ipsec_hdr);
+ }
+ else
+ printk(KERN_ERR "%s: secure path data not found\n", __func__);
+ }
+#endif
+
+ nr_frags = sh->nr_frags;
+
+ if (nr_frags) {
+ skb_frag_t *f;
+ int i;
+
+ __hif_lib_xmit_pkt(&priv->client, queuenum, skb->data, skb_headlen(skb), ctrl, HIF_FIRST_BUFFER, skb);
+
+ for (i = 0; i < nr_frags - 1; i++) {
+ f = &sh->frags[i];
+ __hif_lib_xmit_pkt(&priv->client, queuenum, skb_frag_address(f), skb_frag_size(f), 0x0, 0x0, skb);
+ }
+
+ f = &sh->frags[i];
+
+ __hif_lib_xmit_pkt(&priv->client, queuenum, skb_frag_address(f), skb_frag_size(f), 0x0, HIF_LAST_BUFFER|HIF_DATA_VALID, skb);
+
+ netif_info(priv, tx_queued, priv->dev, "%s: pkt sent successfully skb:%p nr_frags:%d len:%d\n", __func__, skb, nr_frags, skb->len);
+ }
+ else {
+ __hif_lib_xmit_pkt(&priv->client, queuenum, skb->data, skb->len, ctrl, HIF_FIRST_BUFFER | HIF_LAST_BUFFER | HIF_DATA_VALID, skb);
+ netif_info(priv, tx_queued, priv->dev, "%s: pkt sent successfully skb:%p len:%d\n", __func__, skb, skb->len);
+ }
+ hif_tx_dma_start();
+ priv->stats.tx_packets++;
+ priv->stats.tx_bytes += skb->len;
+ hif_lib_tx_credit_use(pfe, priv->id, queuenum, 1);
+}
+
+/** pfe_eth_flush_txQ
+ */
+static void pfe_eth_flush_txQ(struct pfe_eth_priv_s *priv, int txQ_num, int from_tx, int n_desc)
+{
+ struct sk_buff *skb;
+ struct netdev_queue *tx_queue = netdev_get_tx_queue(priv->dev, txQ_num);
+ int count = max(TX_FREE_MAX_COUNT, n_desc);
+ unsigned int flags;
+
+ netif_info(priv, tx_done, priv->dev, "%s\n", __func__);
+
+ if (!from_tx)
+ __netif_tx_lock(tx_queue, smp_processor_id());
+
+ /* Clean HIF and client queue */
+ while (count && (skb = hif_lib_tx_get_next_complete(&priv->client, txQ_num, &flags, count))) {
+
+ /* FIXME : Invalid data can be skipped in hif_lib itself */
+ if (flags & HIF_DATA_VALID) {
+#ifdef ETH_HIF_NODMA_MAP
+ if (flags & HIF_DONT_DMA_MAP) {
+ pfe_tx_skb_unmap(skb);
+ }
+#endif
+ dev_kfree_skb_any(skb);
+
+ }
+ // When called from the timer, flush all descriptors
+ if (from_tx)
+ count--;
+ }
+
+ if (!from_tx)
+ __netif_tx_unlock(tx_queue);
+}
+
+/** pfe_eth_flush_tx
+ */
+static void pfe_eth_flush_tx(struct pfe_eth_priv_s *priv, int force)
+{
+ int ii;
+
+ netif_info(priv, tx_done, priv->dev, "%s\n", __func__);
+
+ for (ii = 0; ii < EMAC_TXQ_CNT; ii++) {
+ if (force || (time_after(jiffies, priv->client.tx_q[ii].jiffies_last_packet + (COMCERTO_TX_RECOVERY_TIMEOUT_MS * HZ)/1000))) {
+ pfe_eth_flush_txQ(priv, ii, 0, 0); //We will release everything we can based on from_tx param, so the count param can be set to any value
+ hif_lib_update_credit(&priv->client, ii);
+ }
+ }
+}
+
+
+/** pfe_eth_send_packet
+ */
+static int pfe_eth_send_packet(struct sk_buff *skb, struct net_device *dev)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ int txQ_num = skb_get_queue_mapping(skb);
+ int n_desc, n_segs, count;
+ struct netdev_queue *tx_queue = netdev_get_tx_queue(priv->dev, txQ_num);
+
+ netif_info(priv, tx_queued, dev, "%s\n", __func__);
+
+ if ((!skb_is_gso(skb)) && (skb_headroom(skb) < (PFE_PKT_HEADER_SZ + sizeof(unsigned long)))) {
+
+ netif_warn(priv, tx_err, priv->dev, "%s: copying skb\n", __func__);
+
+ if (pskb_expand_head(skb, (PFE_PKT_HEADER_SZ + sizeof(unsigned long)), 0, GFP_ATOMIC)) {
+ /* No need to re-transmit, no way to recover*/
+ kfree_skb(skb);
+ priv->stats.tx_dropped++;
+ return NETDEV_TX_OK;
+ }
+ }
+
+ pfe_tx_get_req_desc(skb, &n_desc, &n_segs);
+
+ hif_tx_lock(&pfe->hif);
+ if(unlikely(pfe_eth_might_stop_tx(priv, txQ_num, tx_queue, n_desc, n_segs))) {
+#ifdef PFE_ETH_TX_STATS
+ if(priv->was_stopped[txQ_num]) {
+ priv->clean_fail[txQ_num]++;
+ priv->was_stopped[txQ_num] = 0;
+ }
+#endif
+ hif_tx_unlock(&pfe->hif);
+ return NETDEV_TX_BUSY;
+ }
+
+ pfe_hif_send_packet(skb, priv, txQ_num);
+
+ hif_tx_unlock(&pfe->hif);
+
+ dev->trans_start = jiffies;
+
+ // Recycle buffers if a socket's send buffer becomes half full or if the HIF client queue starts filling up
+ if (((count = (hif_lib_tx_pending(&priv->client, txQ_num) - HIF_CL_TX_FLUSH_MARK)) > 0)
+ || (skb->sk && ((sk_wmem_alloc_get(skb->sk) << 1) > skb->sk->sk_sndbuf)))
+ pfe_eth_flush_txQ(priv, txQ_num, 1, count);
+
+#ifdef PFE_ETH_TX_STATS
+ priv->was_stopped[txQ_num] = 0;
+#endif
+
+ return NETDEV_TX_OK;
+}
+
+/** pfe_eth_select_queue
+ *
+ */
+static u16 pfe_eth_select_queue( struct net_device *dev, struct sk_buff *skb )
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+
+ return pfe_eth_get_queuenum(priv, skb);
+}
+
+
+/** pfe_eth_get_stats
+ */
+static struct net_device_stats *pfe_eth_get_stats(struct net_device *dev)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+
+ netif_info(priv, drv, dev, "%s\n", __func__);
+
+ return &priv->stats;
+}
+
+
+/** pfe_eth_change_mtu
+ */
+static int pfe_eth_change_mtu(struct net_device *dev, int new_mtu)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ int oldsize = dev->mtu ;
+ int frame_size = new_mtu + ETH_HLEN +4;
+
+ netif_info(priv, drv, dev, "%s\n", __func__);
+
+ if ((frame_size < 64) || (frame_size > JUMBO_FRAME_SIZE)) {
+ netif_err(priv, drv, dev, "Invalid MTU setting\n");
+ return -EINVAL;
+ }
+
+ if ((new_mtu > 1500) && (dev->features & NETIF_F_TSO))
+ {
+ netdev_err(dev, "MTU cannot be set to more than 1500 while TSO is enabled. TSO must be disabled first.\n");
+ return -EINVAL;
+ }
+
+ /* Only stop and start the controller if it isn't already
+ * stopped, and we changed something */
+ if ((oldsize != new_mtu) && (dev->flags & IFF_UP)){
+ netdev_err(dev, "Can not change MTU - fast_path must be disabled and ifconfig down must be issued first\n");
+
+ return -EINVAL;
+ }
+
+ dev->mtu = new_mtu;
+
+ return 0;
+}
+
+/** pfe_eth_set_mac_address
+ */
+static int pfe_eth_set_mac_address(struct net_device *dev, void *addr)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ struct sockaddr *sa = addr;
+
+ netif_info(priv, drv, dev, "%s\n", __func__);
+
+ if (!is_valid_ether_addr(sa->sa_data))
+ return -EADDRNOTAVAIL;
+
+ memcpy(dev->dev_addr, sa->sa_data, ETH_ALEN);
+
+ gemac_set_laddrN(priv->EMAC_baseaddr, (MAC_ADDR *)dev->dev_addr, 1);
+
+ return 0;
+
+}
+
+/** pfe_eth_enet_addr_byte_mac
+ */
+int pfe_eth_enet_addr_byte_mac(u8 * enet_byte_addr, MAC_ADDR *enet_addr)
+{
+ if ((enet_byte_addr == NULL) || (enet_addr == NULL))
+ {
+ return -1;
+ }
+ else
+ {
+ enet_addr->bottom = enet_byte_addr[0] |
+ (enet_byte_addr[1] << 8) |
+ (enet_byte_addr[2] << 16) |
+ (enet_byte_addr[3] << 24);
+ enet_addr->top = enet_byte_addr[4] |
+ (enet_byte_addr[5] << 8);
+ return 0;
+ }
+}
+
+/** pfe_eth_get_hash
+ */
+static int pfe_eth_get_hash(u8 * addr)
+{
+ u8 temp1,temp2,temp3,temp4,temp5,temp6,temp7,temp8;
+ temp1 = addr[0] & 0x3F ;
+ temp2 = ((addr[0] & 0xC0) >> 6)| ((addr[1] & 0x0F) << 2);
+ temp3 = ((addr[1] & 0xF0) >> 4) | ((addr[2] & 0x03) << 4);
+ temp4 = (addr[2] & 0xFC) >> 2;
+ temp5 = addr[3] & 0x3F;
+ temp6 = ((addr[3] & 0xC0) >> 6) | ((addr[4] & 0x0F) << 2);
+ temp7 = ((addr[4] & 0xF0) >>4 ) | ((addr[5] & 0x03) << 4);
+ temp8 = ((addr[5] &0xFC) >> 2);
+ return (temp1 ^ temp2 ^ temp3 ^ temp4 ^ temp5 ^ temp6 ^ temp7 ^ temp8);
+}
+
+/** pfe_eth_set_multi
+ */
+static void pfe_eth_set_multi(struct net_device *dev)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ MAC_ADDR hash_addr; /* hash register structure */
+ MAC_ADDR spec_addr; /* specific mac address register structure */
+ int result; /* index into hash register to set.. */
+ int uc_count = 0;
+ struct netdev_hw_addr *ha;
+
+ if (dev->flags & IFF_PROMISC) {
+ netif_info(priv, drv, dev, "entering promiscuous mode\n");
+
+ priv->promisc = 1;
+ gemac_enable_copy_all(priv->EMAC_baseaddr);
+ } else {
+ priv->promisc = 0;
+ gemac_disable_copy_all(priv->EMAC_baseaddr);
+ }
+
+ /* Enable broadcast frame reception if required. */
+ if (dev->flags & IFF_BROADCAST) {
+ gemac_allow_broadcast(priv->EMAC_baseaddr);
+ } else {
+ netif_info(priv, drv, dev, "disabling broadcast frame reception\n");
+
+ gemac_no_broadcast(priv->EMAC_baseaddr);
+ }
+
+ if (dev->flags & IFF_ALLMULTI) {
+ /* Set the hash to rx all multicast frames */
+ hash_addr.bottom = 0xFFFFFFFF;
+ hash_addr.top = 0xFFFFFFFF;
+ gemac_set_hash(priv->EMAC_baseaddr, &hash_addr);
+ gemac_enable_multicast(priv->EMAC_baseaddr);
+ netdev_for_each_uc_addr(ha, dev) {
+ if(uc_count >= MAX_UC_SPEC_ADDR_REG) break;
+ pfe_eth_enet_addr_byte_mac(ha->addr, &spec_addr);
+ gemac_set_laddrN(priv->EMAC_baseaddr, &spec_addr, uc_count + 2);
+ uc_count++;
+ }
+ } else if ((netdev_mc_count(dev) > 0) || (netdev_uc_count(dev))) {
+ u8 *addr;
+
+ hash_addr.bottom = 0;
+ hash_addr.top = 0;
+
+ netdev_for_each_mc_addr(ha, dev) {
+ addr = ha->addr;
+
+ netif_info(priv, drv, dev, "adding multicast address %X:%X:%X:%X:%X:%X to gem filter\n",
+ addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
+
+ result = pfe_eth_get_hash(addr);
+
+ if (result >= EMAC_HASH_REG_BITS) {
+ break;
+ } else {
+ if (result < 32) {
+ hash_addr.bottom |= (1 << result);
+ } else {
+ hash_addr.top |= (1 << (result - 32));
+ }
+ }
+
+ }
+
+ uc_count = -1;
+ netdev_for_each_uc_addr(ha, dev) {
+ addr = ha->addr;
+
+ if(++uc_count < MAX_UC_SPEC_ADDR_REG)
+ {
+ netdev_info(dev, "adding unicast address %02x:%02x:%02x:%02x:%02x:%02x to gem filter\n",
+ addr[0], addr[1], addr[2],
+ addr[3], addr[4], addr[5]);
+
+ pfe_eth_enet_addr_byte_mac(addr, &spec_addr);
+ gemac_set_laddrN(priv->EMAC_baseaddr, &spec_addr, uc_count + 2);
+ }
+ else
+ {
+ netif_info(priv, drv, dev, "adding unicast address %02x:%02x:%02x:%02x:%02x:%02x to gem hash\n",
+ addr[0], addr[1], addr[2],
+ addr[3], addr[4], addr[5]);
+
+ result = pfe_eth_get_hash(addr);
+ if (result >= EMAC_HASH_REG_BITS) {
+ break;
+ } else {
+ if (result < 32)
+ hash_addr.bottom |= (1 << result);
+ else
+ hash_addr.top |= (1 << (result - 32));
+ }
+
+
+ }
+ }
+
+ gemac_set_hash(priv->EMAC_baseaddr, &hash_addr);
+ if(netdev_mc_count(dev))
+ gemac_enable_multicast(priv->EMAC_baseaddr);
+ else
+ gemac_disable_multicast(priv->EMAC_baseaddr);
+ }
+
+ if(netdev_uc_count(dev) >= MAX_UC_SPEC_ADDR_REG)
+ gemac_enable_unicast(priv->EMAC_baseaddr);
+ else
+ {
+ /* Check if there are any specific address HW registers that need
+ * to be flushed
+ * */
+ for(uc_count = netdev_uc_count(dev); uc_count < MAX_UC_SPEC_ADDR_REG; uc_count++)
+ gemac_clear_laddrN(priv->EMAC_baseaddr, uc_count + 2);
+
+ gemac_disable_unicast(priv->EMAC_baseaddr);
+ }
+
+ if (dev->flags & IFF_LOOPBACK) {
+ gemac_set_loop(priv->EMAC_baseaddr, LB_LOCAL);
+ }
+
+ return;
+}
+
+/** pfe_eth_set_features
+ */
+static int pfe_eth_set_features(struct net_device *dev, u32 features)
+{
+ struct pfe_eth_priv_s *priv = netdev_priv(dev);
+ int rc = 0;
+
+ if (features & NETIF_F_RXCSUM)
+ gemac_enable_rx_checksum_offload(priv->EMAC_baseaddr);
+ else
+ gemac_disable_rx_checksum_offload(priv->EMAC_baseaddr);
+
+ if (features & NETIF_F_LRO) {
+ if (pfe_ctrl_set_lro(1) < 0)
+ rc = -1;
+ } else {
+ if (pfe_ctrl_set_lro(0) < 0)
+ rc = -1;
+ }
+
+ return rc;
+}
+
+/** pfe_eth_fix_features
+ */
+static u32 pfe_eth_fix_features(struct net_device *dev, u32 features)
+{
+ if (dev->mtu > 1500)
+ {
+ if (features & (NETIF_F_TSO))
+ {
+ features &= ~(NETIF_F_TSO);
+ netdev_err(dev, "TSO cannot be enabled when the MTU is larger than 1500. Please set the MTU to 1500 or lower first.\n");
+ }
+ }
+
+ return features;
+}
+
+/** pfe_eth_tx_timeout
+ */
+void pfe_eth_tx_timeout(unsigned long data )
+{
+ struct pfe_eth_priv_s *priv = (struct pfe_eth_priv_s *)data;
+
+ netif_info(priv, timer, priv->dev, "%s\n", __func__);
+
+ pfe_eth_flush_tx(priv, 0);
+
+ priv->tx_timer.expires = jiffies + ( COMCERTO_TX_RECOVERY_TIMEOUT_MS * HZ )/1000;
+ add_timer(&priv->tx_timer);
+}
+
+/** pfe_eth_fast_tx_timeout
+ */
+static enum hrtimer_restart pfe_eth_fast_tx_timeout(struct hrtimer *timer)
+{
+ struct pfe_eth_fast_timer *fast_tx_timeout = container_of(timer, struct pfe_eth_fast_timer, timer);
+ struct pfe_eth_priv_s *priv = container_of(fast_tx_timeout->base, struct pfe_eth_priv_s, fast_tx_timeout);
+ struct netdev_queue *tx_queue = netdev_get_tx_queue(priv->dev, fast_tx_timeout->queuenum);
+
+ if(netif_tx_queue_stopped(tx_queue)) {
+#ifdef PFE_ETH_TX_STATS
+ priv->was_stopped[fast_tx_timeout->queuenum] = 1;
+#endif
+ netif_tx_wake_queue(tx_queue);
+ }
+
+ return HRTIMER_NORESTART;
+}
+
+/** pfe_eth_fast_tx_timeout_init
+ */
+static void pfe_eth_fast_tx_timeout_init(struct pfe_eth_priv_s *priv)
+{
+ int i;
+ for (i = 0; i < EMAC_TXQ_CNT; i++) {
+ priv->fast_tx_timeout[i].queuenum = i;
+ hrtimer_init(&priv->fast_tx_timeout[i].timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+ priv->fast_tx_timeout[i].timer.function = pfe_eth_fast_tx_timeout;
+ priv->fast_tx_timeout[i].base = priv->fast_tx_timeout;
+ }
+}
+
+static struct sk_buff *pfe_eth_rx_skb(struct net_device *dev, struct pfe_eth_priv_s *priv, unsigned int qno)
+{
+ void *buf_addr;
+ unsigned int rx_ctrl;
+ unsigned int desc_ctrl = 0;
+ struct hif_ipsec_hdr *ipsec_hdr;
+ struct sk_buff *skb;
+ struct sk_buff *skb_frag, *skb_frag_last = NULL;
+ int length = 0, offset;
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+ struct timespec ktime;
+#endif
+
+ skb = priv->skb_inflight[qno];
+
+ if (skb && (skb_frag_last = skb_shinfo(skb)->frag_list)) {
+ while (skb_frag_last->next)
+ skb_frag_last = skb_frag_last->next;
+ }
+
+ while (!(desc_ctrl & CL_DESC_LAST)) {
+
+ buf_addr = hif_lib_receive_pkt(&priv->client, qno, &length, &offset, &rx_ctrl, &desc_ctrl, (void **)&ipsec_hdr);
+ if (!buf_addr)
+ goto incomplete;
+
+#ifdef PFE_ETH_NAPI_STATS
+ priv->napi_counters[NAPI_DESC_COUNT]++;
+#endif
+
+ /* First frag */
+ if (desc_ctrl & CL_DESC_FIRST) {
+#if defined(CONFIG_PLATFORM_EMULATION) || defined(CONFIG_PLATFORM_PCI)
+ skb = dev_alloc_skb(PFE_BUF_SIZE);
+ if (unlikely(!skb)) {
+ goto pkt_drop;
+ }
+
+ skb_copy_to_linear_data(skb, buf_addr, length + offset);
+ kfree(buf_addr);
+#else
+#if defined(CONFIG_COMCERTO_ZONE_DMA_NCNB)
+ skb = alloc_skb(length + offset + 32, GFP_ATOMIC);
+#else
+ skb = alloc_skb_header(PFE_BUF_SIZE, buf_addr, GFP_ATOMIC);
+#endif
+ if (unlikely(!skb)) {
+ goto pkt_drop;
+ }
+#endif
+ skb_reserve(skb, offset);
+#if defined(CONFIG_COMCERTO_ZONE_DMA_NCNB)
+ __memcpy(skb->data, buf_addr + offset, length);
+ kfree(buf_addr);
+#endif
+ skb_put(skb, length);
+ skb->dev = dev;
+
+ if ((dev->features & NETIF_F_RXCSUM) && (rx_ctrl & HIF_CTRL_RX_CHECKSUMMED))
+ skb->ip_summed = CHECKSUM_UNNECESSARY;
+ else
+ skb_checksum_none_assert(skb);
+
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+ if (rx_ctrl & HIF_CTRL_RX_IPSEC_IN) {
+ if (ipsec_hdr) {
+ struct sec_path *sp;
+ struct xfrm_state *x;
+ unsigned short *sah = &ipsec_hdr->sa_handle[0];
+ int i = 0;
+
+ sp = secpath_dup(skb->sp);
+
+ if (!sp)
+ {
+ kfree_skb(skb);
+ goto pkt_drop;
+ }
+
+ skb->sp = sp;
+
+ /* at maximum 2 SA are expected */
+ while (i <= 1)
+ {
+ if(!*sah)
+ break;
+
+ if ((x = xfrm_state_lookup_byhandle(dev_net(dev), ntohs(*sah))) == NULL)
+ {
+ kfree_skb(skb);
+ goto pkt_drop;
+ }
+
+ sp->xvec[i] = x;
+
+ if (!x->curlft.use_time)
+ {
+ ktime = current_kernel_time();
+ x->curlft.use_time = (unsigned long)ktime.tv_sec;
+ }
+
+ i++; sah++;
+ }
+
+ sp->len = i;
+ }
+ }
+#endif
+ } else {
+
+ /* Next frags */
+ if (unlikely(!skb)) {
+ printk(KERN_ERR "%s: NULL skb_inflight\n", __func__);
+ goto pkt_drop;
+ }
+
+#if defined(CONFIG_COMCERTO_ZONE_DMA_NCNB)
+ skb_frag = alloc_skb(length + offset + 32, GFP_ATOMIC);
+#else
+ skb_frag = alloc_skb_header(PFE_BUF_SIZE, buf_addr, GFP_ATOMIC);
+#endif
+ if (unlikely(!skb_frag)) {
+ kfree(buf_addr);
+ goto pkt_drop;
+ }
+
+ skb_reserve(skb_frag, offset);
+#if defined(CONFIG_COMCERTO_ZONE_DMA_NCNB)
+ __memcpy(skb_frag->data, buf_addr + offset, length);
+ kfree(buf_addr);
+#endif
+ skb_put(skb_frag, length);
+
+ skb_frag->dev = dev;
+
+ if (skb_shinfo(skb)->frag_list)
+ skb_frag_last->next = skb_frag;
+ else
+ skb_shinfo(skb)->frag_list = skb_frag;
+
+ skb->truesize += skb_frag->truesize;
+ skb->data_len += length;
+ skb->len += length;
+ skb_frag_last = skb_frag;
+ }
+ }
+
+ priv->skb_inflight[qno] = NULL;
+ return skb;
+
+incomplete:
+ priv->skb_inflight[qno] = skb;
+ return NULL;
+
+pkt_drop:
+ priv->skb_inflight[qno] = NULL;
+
+ if (skb) {
+ kfree_skb(skb);
+ } else {
+ kfree(buf_addr);
+ }
+
+ priv->stats.rx_errors++;
+
+ return NULL;
+}
+
+
+static struct sk_buff *pfe_eth_rx_page(struct net_device *dev, struct pfe_eth_priv_s *priv, unsigned int qno)
+{
+ struct page *p;
+ void *buf_addr;
+ unsigned int rx_ctrl;
+ unsigned int desc_ctrl;
+ struct sk_buff *skb;
+ int length, offset, data_offset;
+ struct hif_lro_hdr *lro_hdr;
+ u32 pe_id;
+
+ while (1) {
+ buf_addr = hif_lib_receive_pkt(&priv->client, qno, &length, &offset, &rx_ctrl, &desc_ctrl, (void **)&lro_hdr);
+ if (!buf_addr)
+ goto empty;
+
+ if (qno == 2)
+ pe_id = (rx_ctrl >> HIF_CTRL_RX_PE_ID_OFST) & 0xf;
+ else
+ pe_id = 0;
+
+ skb = priv->skb_inflight[qno + pe_id];
+
+#ifdef PFE_ETH_NAPI_STATS
+ priv->napi_counters[NAPI_DESC_COUNT]++;
+#endif
+
+ /* First frag */
+ if ((desc_ctrl & CL_DESC_FIRST) && !skb) {
+ p = virt_to_page(buf_addr);
+
+ skb = dev_alloc_skb(MAX_HDR_SIZE + PFE_PKT_HEADROOM + 2);
+ if (unlikely(!skb)) {
+ goto pkt_drop;
+ }
+
+ skb_reserve(skb, PFE_PKT_HEADROOM + 2);
+
+ if (lro_hdr) {
+ data_offset = lro_hdr->data_offset;
+ if (lro_hdr->mss)
+ skb_shinfo(skb)->gso_size = lro_hdr->mss;
+
+// printk(KERN_INFO "mss: %d, offset: %d, data_offset: %d, len: %d\n", lro_hdr->mss, offset, lro_hdr->data_offset, length);
+ } else {
+ data_offset = MAX_HDR_SIZE;
+ }
+
+ /* We don't need the fragment if the whole packet */
+ /* has been copied in the first linear skb */
+ if (length <= data_offset) {
+ __memcpy(skb->data, buf_addr + offset, length);
+ skb_put(skb, length);
+ free_page((unsigned long)buf_addr);
+ } else {
+ __memcpy(skb->data, buf_addr + offset, data_offset);
+ skb_put(skb, data_offset);
+ skb_add_rx_frag(skb, 0, p, offset + data_offset, length - data_offset);
+ }
+
+ skb->dev = dev;
+
+ if ((dev->features & NETIF_F_RXCSUM) && (rx_ctrl & HIF_CTRL_RX_CHECKSUMMED))
+ skb->ip_summed = CHECKSUM_UNNECESSARY;
+ else
+ skb_checksum_none_assert(skb);
+
+ } else {
+ /* Next frags */
+ if (unlikely(!skb)) {
+ printk(KERN_ERR "%s: NULL skb_inflight\n", __func__);
+ goto pkt_drop;
+ }
+
+ p = virt_to_page(buf_addr);
+
+ skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, p, offset, length);
+ }
+
+ /* Last buffer in a software chain */
+ if ((desc_ctrl & CL_DESC_LAST) && !(rx_ctrl & HIF_CTRL_RX_CONTINUED))
+ break;
+
+ /* Keep track of skb for this queue/pe */
+ priv->skb_inflight[qno + pe_id] = skb;
+ }
+
+ priv->skb_inflight[qno + pe_id] = NULL;
+
+ return skb;
+
+pkt_drop:
+ priv->skb_inflight[qno + pe_id] = NULL;
+
+ if (skb) {
+ kfree_skb(skb);
+ } else {
+ free_page((unsigned long)buf_addr);
+ }
+
+ priv->stats.rx_errors++;
+
+ return NULL;
+
+empty:
+ return NULL;
+}
+
+/** pfe_eth_poll
+ */
+static int pfe_eth_poll(struct pfe_eth_priv_s *priv, struct napi_struct *napi, unsigned int qno, int budget)
+{
+ struct net_device *dev = priv->dev;
+ struct sk_buff *skb;
+ int work_done = 0;
+ unsigned int len;
+
+ netif_info(priv, intr, priv->dev, "%s\n", __func__);
+
+#ifdef PFE_ETH_NAPI_STATS
+ priv->napi_counters[NAPI_POLL_COUNT]++;
+#endif
+
+ do {
+ if (page_mode)
+ skb = pfe_eth_rx_page(dev, priv, qno);
+ else
+ skb = pfe_eth_rx_skb(dev, priv, qno);
+
+ if (!skb)
+ break;
+
+ len = skb->len;
+
+ /* Packet will be processed */
+ skb->protocol = eth_type_trans(skb, dev);
+
+#ifdef PFE_ETH_LRO_STATS
+ priv->lro_len_counters[((u32)skb->len >> 11) & (LRO_LEN_COUNT_MAX - 1)]++;
+ priv->lro_nb_counters[skb_shinfo(skb)->nr_frags & (LRO_NB_COUNT_MAX - 1)]++;
+#endif
+
+ netif_receive_skb(skb);
+
+ priv->stats.rx_packets++;
+ priv->stats.rx_bytes += len;
+
+ dev->last_rx = jiffies;
+
+ work_done++;
+
+#ifdef PFE_ETH_NAPI_STATS
+ priv->napi_counters[NAPI_PACKET_COUNT]++;
+#endif
+
+ } while (work_done < budget);
+
+ /* If no Rx receive nor cleanup work was done, exit polling mode.
+ * No more netif_running(dev) check is required here , as this is checked in
+ * net/core/dev.c ( 2.6.33.5 kernel specific).
+ */
+ if (work_done < budget) {
+ napi_complete(napi);
+
+ hif_lib_event_handler_start(&priv->client, EVENT_RX_PKT_IND, qno);
+ }
+#ifdef PFE_ETH_NAPI_STATS
+ else
+ priv->napi_counters[NAPI_FULL_BUDGET_COUNT]++;
+#endif
+
+ return work_done;
+}
+
+/** pfe_eth_lro_poll
+ */
+static int pfe_eth_lro_poll(struct napi_struct *napi, int budget)
+{
+ struct pfe_eth_priv_s *priv = container_of(napi, struct pfe_eth_priv_s, lro_napi);
+
+ netif_info(priv, intr, priv->dev, "%s\n", __func__);
+
+ return pfe_eth_poll(priv, napi, 2, budget);
+}
+
+
+/** pfe_eth_low_poll
+ */
+static int pfe_eth_low_poll(struct napi_struct *napi, int budget)
+{
+ struct pfe_eth_priv_s *priv = container_of(napi, struct pfe_eth_priv_s, low_napi);
+
+ netif_info(priv, intr, priv->dev, "%s\n", __func__);
+
+ return pfe_eth_poll(priv, napi, 1, budget);
+}
+
+/** pfe_eth_high_poll
+ */
+static int pfe_eth_high_poll(struct napi_struct *napi, int budget )
+{
+ struct pfe_eth_priv_s *priv = container_of(napi, struct pfe_eth_priv_s, high_napi);
+
+ netif_info(priv, intr, priv->dev, "%s\n", __func__);
+
+ return pfe_eth_poll(priv, napi, 0, budget);
+}
+
+static const struct net_device_ops pfe_netdev_ops = {
+ .ndo_open = pfe_eth_open,
+ .ndo_stop = pfe_eth_close,
+ .ndo_start_xmit = pfe_eth_send_packet,
+ .ndo_select_queue = pfe_eth_select_queue,
+ .ndo_get_stats = pfe_eth_get_stats,
+ .ndo_change_mtu = pfe_eth_change_mtu,
+ .ndo_set_mac_address = pfe_eth_set_mac_address,
+ .ndo_set_rx_mode = pfe_eth_set_multi,
+ .ndo_set_features = pfe_eth_set_features,
+ .ndo_fix_features = pfe_eth_fix_features,
+ .ndo_validate_addr = eth_validate_addr,
+};
+
+
+/** pfe_eth_init_one
+ */
+
+static int pfe_eth_init_one( struct pfe *pfe, int id )
+{
+ struct net_device *dev = NULL;
+ struct pfe_eth_priv_s *priv = NULL;
+ struct comcerto_eth_platform_data *einfo;
+ struct comcerto_mdio_platform_data *minfo;
+ struct comcerto_pfe_platform_data *pfe_info;
+ int err;
+
+ /* Extract pltform data */
+#if defined(CONFIG_PLATFORM_EMULATION) || defined(CONFIG_PLATFORM_PCI)
+ pfe_info = (struct comcerto_pfe_platform_data *) &comcerto_pfe_pdata;
+#else
+ pfe_info = (struct comcerto_pfe_platform_data *) pfe->dev->platform_data;
+#endif
+ if (!pfe_info) {
+ printk(KERN_ERR "%s: pfe missing additional platform data\n", __func__);
+ err = -ENODEV;
+ goto err0;
+ }
+
+ einfo = (struct comcerto_eth_platform_data *) pfe_info->comcerto_eth_pdata;
+
+ /* einfo never be NULL, but no harm in having this check */
+ if (!einfo) {
+ printk(KERN_ERR "%s: pfe missing additional gemacs platform data\n", __func__);
+ err = -ENODEV;
+ goto err0;
+ }
+
+ minfo = (struct comcerto_mdio_platform_data *) pfe_info->comcerto_mdio_pdata;
+
+ /* einfo never be NULL, but no harm in having this check */
+ if (!minfo) {
+ printk(KERN_ERR "%s: pfe missing additional mdios platform data\n", __func__);
+ err = -ENODEV;
+ goto err0;
+ }
+
+ /*
+ * FIXME: Need to check some flag in "einfo" to know whether
+ * GEMAC is enabled Or not.
+ */
+
+ /* Create an ethernet device instance */
+ dev = alloc_etherdev_mq(sizeof (*priv), EMAC_TXQ_CNT);
+
+ if (!dev) {
+ printk(KERN_ERR "%s: gemac %d device allocation failed\n", __func__, einfo[id].gem_id);
+ err = -ENOMEM;
+ goto err0;
+ }
+
+ priv = netdev_priv(dev);
+ priv->dev = dev;
+ priv->id = einfo[id].gem_id;
+ priv->pfe = pfe;
+ /* get gemac tx clock */
+ priv->gemtx_clk = clk_get(NULL, "gemtx");
+
+ if (IS_ERR(priv->gemtx_clk)) {
+ printk(KERN_ERR "%s: Unable to get the clock for gemac %d\n", __func__, priv->id);
+ err = -ENODEV;
+ goto err1;
+ }
+
+ pfe->eth.eth_priv[id] = priv;
+
+ /* Set the info in the priv to the current info */
+ priv->einfo = &einfo[id];
+ priv->EMAC_baseaddr = cbus_emac_base[id];
+ priv->GPI_baseaddr = cbus_gpi_base[id];
+
+ /* FIXME : For now TMU queue numbers hardcoded, later should be taken from pfe.h */
+#define HIF_GEMAC_TMUQ_BASE 6
+ priv->low_tmuQ = HIF_GEMAC_TMUQ_BASE + (id * 2);
+ priv->high_tmuQ = priv->low_tmuQ + 1;
+
+ spin_lock_init(&priv->lock);
+ priv->tx_timer.data = (unsigned long)priv;
+ priv->tx_timer.function = pfe_eth_tx_timeout;
+ priv->tx_timer.expires = jiffies + ( COMCERTO_TX_RECOVERY_TIMEOUT_MS * HZ )/1000;
+ init_timer(&priv->tx_timer);
+ priv->cpu_id = -1;
+
+ pfe_eth_fast_tx_timeout_init(priv);
+
+ /* Copy the station address into the dev structure, */
+ memcpy(dev->dev_addr, einfo[id].mac_addr, ETH_ALEN);
+
+ err = dev_alloc_name(dev, einfo[id].name);
+
+ if (err < 0) {
+ netdev_err(dev, "%s: dev_alloc_name(%s) failed\n", __func__, einfo[id].name);
+ err = -EINVAL;
+ goto err2;
+ }
+
+ /* Initialize mdio */
+ if (minfo[id].enabled) {
+
+ if ((err = pfe_eth_mdio_init(priv, &minfo[id]))) {
+ netdev_err(dev, "%s: pfe_eth_mdio_init() failed\n", __func__);
+ goto err2;
+ }
+ }
+
+ dev->mtu = 1500;
+
+ /* supported features */
+ dev->hw_features = NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
+ NETIF_F_SG | NETIF_F_TSO;
+
+ /* enabled by default */
+ dev->features = dev->hw_features;
+
+ if (lro_mode) {
+ dev->hw_features |= NETIF_F_LRO;
+ dev->features |= NETIF_F_LRO;
+ pfe_ctrl_set_lro(1);
+ }
+
+ dev->netdev_ops = &pfe_netdev_ops;
+
+ dev->ethtool_ops = &pfe_ethtool_ops;
+
+ /* Enable basic messages by default */
+ priv->msg_enable = NETIF_MSG_IFUP | NETIF_MSG_IFDOWN | NETIF_MSG_LINK | NETIF_MSG_PROBE;
+
+ err = register_netdev(dev);
+
+ if (err) {
+ netdev_err(dev, "register_netdev() failed\n");
+ goto err3;
+ }
+
+ netif_napi_add(dev, &priv->low_napi, pfe_eth_low_poll, HIF_RX_POLL_WEIGHT - 16);
+ netif_napi_add(dev, &priv->high_napi, pfe_eth_high_poll, HIF_RX_POLL_WEIGHT - 16);
+ netif_napi_add(dev, &priv->lro_napi, pfe_eth_lro_poll, HIF_RX_POLL_WEIGHT - 16);
+
+ /* Create all the sysfs files */
+ if(pfe_eth_sysfs_init(dev))
+ goto err4;
+
+ netif_info(priv, probe, dev, "%s: created interface, baseaddr: %p\n", __func__, priv->EMAC_baseaddr);
+
+ return 0;
+err4:
+ unregister_netdev(dev);
+err3:
+ pfe_eth_mdio_exit(priv->mii_bus);
+err2:
+ clk_put(priv->gemtx_clk);
+err1:
+ free_netdev(priv->dev);
+
+err0:
+ return err;
+}
+
+/** pfe_eth_init
+ */
+int pfe_eth_init(struct pfe *pfe)
+{
+ int ii = 0;
+ int err;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ cbus_emac_base[0] = EMAC1_BASE_ADDR;
+ cbus_emac_base[1] = EMAC2_BASE_ADDR;
+ cbus_emac_base[2] = EMAC3_BASE_ADDR;
+
+ cbus_gpi_base[0] = EGPI1_BASE_ADDR;
+ cbus_gpi_base[1] = EGPI2_BASE_ADDR;
+ cbus_gpi_base[2] = EGPI3_BASE_ADDR;
+
+ for (ii = 0; ii < NUM_GEMAC_SUPPORT; ii++) {
+ if ((err = pfe_eth_init_one(pfe, ii)))
+ goto err0;
+ }
+
+ return 0;
+
+err0:
+ while(ii--){
+ pfe_eth_exit_one( pfe->eth.eth_priv[ii] );
+ }
+
+ /* Register three network devices in the kernel */
+ return err;
+}
+
+/** pfe_eth_exit_one
+ */
+static void pfe_eth_exit_one( struct pfe_eth_priv_s *priv )
+{
+ netif_info(priv, probe, priv->dev, "%s\n", __func__);
+
+ pfe_eth_sysfs_exit(priv->dev);
+
+ clk_put(priv->gemtx_clk);
+
+ unregister_netdev(priv->dev);
+
+ pfe_eth_mdio_exit(priv->mii_bus);
+
+
+ free_netdev(priv->dev);
+}
+
+/** pfe_eth_exit
+ */
+void pfe_eth_exit(struct pfe *pfe)
+{
+ int ii;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ for(ii = 0; ii < NUM_GEMAC_SUPPORT; ii++ ) {
+ /*
+ * FIXME: Need to check some flag in "einfo" to know whether
+ * GEMAC is enabled Or not.
+ */
+
+ pfe_eth_exit_one(pfe->eth.eth_priv[ii]);
+ }
+}
+
diff --git a/pfe_ctrl/pfe_eth.h b/pfe_ctrl/pfe_eth.h
new file mode 100644
index 0000000..76d8e44
--- /dev/null
+++ b/pfe_ctrl/pfe_eth.h
@@ -0,0 +1,305 @@
+#ifndef _PFE_ETH_H_
+#define _PFE_ETH_H_
+#include <linux/kernel.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/mii.h>
+#include <linux/phy.h>
+#include <linux/clk.h>
+#include <linux/interrupt.h>
+#include <linux/time.h>
+
+#define PFE_ETH_TSO_STATS
+#define PFE_ETH_LRO_STATS
+#define PFE_ETH_NAPI_STATS
+#define PFE_ETH_TX_STATS
+
+#define LRO_LEN_COUNT_MAX 32
+#define LRO_NB_COUNT_MAX 32
+
+#if defined(CONFIG_PLATFORM_PCI) || defined(CONFIG_PLATFORM_EMULATION)
+
+#define CONFIG_COMCERTO_GEMAC 1
+
+#define CONFIG_COMCERTO_USE_MII 1
+#define CONFIG_COMCERTO_USE_RMII 2
+#define CONFIG_COMCERTO_USE_GMII 4
+#define CONFIG_COMCERTO_USE_RGMII 8
+#define CONFIG_COMCERTO_USE_SGMII 16
+
+#define GEMAC_SW_CONF (1 << 8) | (1 << 11) // GEMAC configured by SW
+#define GEMAC_PHY_CONF 0 // GEMAC configured by phy lines (not for MII/GMII)
+#define GEMAC_SW_FULL_DUPLEX (1 << 9)
+#define GEMAC_SW_SPEED_10M (0 << 12)
+#define GEMAC_SW_SPEED_100M (1 << 12)
+#define GEMAC_SW_SPEED_1G (2 << 12)
+
+#define GEMAC_NO_PHY (1 << 0) // set if no phy connected to MAC (ex ethernet switch). In this case use MAC fixed configuration
+#define GEMAC_PHY_RGMII_ADD_DELAY (1 << 1)
+
+/* gemac to interface name assignment */
+#define GEMAC0_ITF_NAME "eth5"
+#define GEMAC1_ITF_NAME "eth6"
+#define GEMAC2_ITF_NAME "eth7"
+
+#define GEMAC0_MAC { 0x00, 0xED, 0xCD, 0xEF, 0xAA, 0xCC }
+#define GEMAC1_MAC { 0x00, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E }
+
+struct comcerto_eth_platform_data {
+ /* device specific information */
+ u32 device_flags;
+ char name[16];
+
+
+ /* board specific information */
+ u32 mii_config;
+ u32 gemac_mode;
+ u32 phy_flags;
+ u32 gem_id;
+ u32 bus_id;
+ u32 phy_id;
+ u8 *mac_addr;
+};
+
+struct comcerto_mdio_platform_data {
+ int enabled;
+ int irq[32];
+ u32 phy_mask;
+ int mdc_div;
+};
+
+struct comcerto_pfe_platform_data
+{
+ struct comcerto_eth_platform_data comcerto_eth_pdata[3];
+ struct comcerto_mdio_platform_data comcerto_mdio_pdata[3];
+};
+
+static struct comcerto_pfe_platform_data comcerto_pfe_pdata = {
+ .comcerto_eth_pdata[0] = {
+ .name = GEMAC0_ITF_NAME,
+ .device_flags = CONFIG_COMCERTO_GEMAC,
+ .mii_config = CONFIG_COMCERTO_USE_MII,
+ .gemac_mode = GEMAC_SW_CONF | GEMAC_SW_FULL_DUPLEX | GEMAC_SW_SPEED_100M,
+#if defined(CONFIG_PLATFORM_EMULATION) || defined(CONFIG_PLATFORM_PCI)
+ .phy_flags = GEMAC_NO_PHY,
+#else
+ .phy_flags = GEMAC_PHY_RGMII_ADD_DELAY,
+#endif
+ .bus_id = 0,
+ .phy_id = 0,
+ .gem_id = 0,
+ .mac_addr = (u8[])GEMAC0_MAC,
+ },
+
+ .comcerto_eth_pdata[1] = {
+ .name = GEMAC1_ITF_NAME,
+ .device_flags = CONFIG_COMCERTO_GEMAC,
+ .mii_config = CONFIG_COMCERTO_USE_RGMII,
+ .gemac_mode = GEMAC_SW_CONF | GEMAC_SW_FULL_DUPLEX | GEMAC_SW_SPEED_1G,
+ .phy_flags = GEMAC_NO_PHY,
+ .gem_id = 1,
+ .mac_addr = (u8[])GEMAC1_MAC,
+ },
+
+ .comcerto_eth_pdata[2] = {
+ .name = GEMAC2_ITF_NAME,
+ },
+
+ .comcerto_mdio_pdata[0] = {
+ .enabled = 1,
+ .phy_mask = 0xFFFFFFFE,
+ .mdc_div = 96,
+ .irq = {
+ [0] = PHY_POLL,
+ },
+ },
+};
+#endif
+
+#define NUM_GEMAC_SUPPORT 3
+#define DRV_NAME "c2000-geth"
+#define COMCERTO_INFOSTR_LEN 32
+#define COMCERTO_TX_RECOVERY_TIMEOUT_MS 500
+#define COMCERTO_TX_FAST_RECOVERY_TIMEOUT_MS 3
+
+#define EMAC_TXQ_CNT 16
+#define EMAC_TXQ_DEPTH (HIF_TX_DESC_NT)
+
+#define JUMBO_FRAME_SIZE 10258
+/**
+ * Client Tx queue threshold, for txQ flush condition.
+ * It must be smaller than the queue size (in case we ever change it in the future).
+ */
+#define HIF_CL_TX_FLUSH_MARK 32
+
+/**
+ * Max number of TX resources (HIF descriptors or skbs) that will be released
+ * in a single go during batch recycling.
+ * Should be lower than the flush mark so the SW can provide the HW with a
+ * continuous stream of packets instead of bursts.
+ */
+#define TX_FREE_MAX_COUNT 16
+#define EMAC_RXQ_CNT 3
+#define EMAC_RXQ_DEPTH HIF_RX_DESC_NT /* make sure clients can receive a full burst of packets */
+#define EMAC_RMON_TXBYTES_POS 0x00
+#define EMAC_RMON_RXBYTES_POS 0x14
+
+#define EMAC_QUEUENUM_MASK (EMAC_TXQ_CNT - 1)
+#define EMAC_MDIO_TIMEOUT 1000
+#define MAX_UC_SPEC_ADDR_REG 31
+
+#define ETH_HIF_NODMA_MAP 1
+
+#ifdef ETH_HIF_NODMA_MAP
+struct hif_frag_dma_map_s {
+ dma_addr_t data;
+ int len;
+};
+
+struct hif_frag_info_s {
+ struct hif_frag_dma_map_s *map;
+ int frag_count;
+};
+#endif
+
+/* The set of statistics registers implemented in the Cadence MAC.
+ * The statistics registers implemented are a subset of all the statistics
+ * available, but contains all the compulsory ones.
+ * For full descriptions on the registers, refer to the Cadence MAC programmers
+ * guide or the IEEE 802.3 specifications.
+ */
+struct gemac_stats{
+ u32 octets_tx_bot; /* Lower 32-bits for number of octets tx'd */
+ u32 octets_tx_top; /* Upper 16-bits for number of octets tx'd */
+ u32 frames_tx; /* Number of frames transmitted OK */
+ u32 broadcast_tx; /* Number of broadcast frames transmitted */
+ u32 multicast_tx; /* Number of multicast frames transmitted */
+ u32 pause_tx; /* Number of pause frames transmitted. */
+ u32 frame64_tx; /* Number of 64byte frames transmitted */
+ u32 frame65_127_tx; /* Number of 65-127 byte frames transmitted */
+ u32 frame128_255_tx; /* Number of 128-255 byte frames transmitted */
+ u32 frame256_511_tx; /* Number of 256-511 byte frames transmitted */
+ u32 frame512_1023_tx; /* Number of 512-1023 byte frames transmitted */
+ u32 frame1024_1518_tx; /* Number of 1024-1518 byte frames transmitted*/
+ u32 frame1519_tx; /* Number of frames greater than 1518 bytes tx*/
+ u32 tx_urun; /* Transmit underrun errors due to DMA */
+ u32 single_col; /* Number of single collision frames */
+ u32 multi_col; /* Number of multi collision frames */
+ u32 excess_col; /* Number of excessive collision frames. */
+ u32 late_col; /* Collisions occuring after slot time */
+ u32 def_tx; /* Frames deferred due to crs */
+ u32 crs_errors; /* Errors caused by crs not being asserted. */
+ u32 octets_rx_bot; /* Lower 32-bits for number of octets rx'd */
+ u32 octets_rx_top; /* Upper 16-bits for number of octets rx'd */
+ u32 frames_rx; /* Number of frames received OK */
+ u32 broadcast_rx; /* Number of broadcast frames received */
+ u32 multicast_rx; /* Number of multicast frames received */
+ u32 pause_rx; /* Number of pause frames received. */
+ u32 frame64_rx; /* Number of 64byte frames received */
+ u32 frame65_127_rx; /* Number of 65-127 byte frames received */
+ u32 frame128_255_rx; /* Number of 128-255 byte frames received */
+ u32 frame256_511_rx; /* Number of 256-511 byte frames received */
+ u32 frame512_1023_rx; /* Number of 512-1023 byte frames received */
+ u32 frame1024_1518_rx; /* Number of 1024-1518 byte frames received*/
+ u32 frame1519_rx; /* Number of frames greater than 1518 bytes rx*/
+ u32 usize_frames; /* Frames received less than min of 64 bytes */
+ u32 excess_length; /* Number of excessive length frames rx */
+ u32 jabbers; /* Excessive length + crc or align errors. */
+ u32 fcs_errors; /* Number of frames received with crc errors */
+ u32 length_check_errors;/* Number of frames with incorrect length */
+ u32 rx_symbol_errors; /* Number of times rx_er asserted during rx */
+ u32 align_errors; /* Frames received without integer no. bytes */
+ u32 rx_res_errors; /* Number of times buffers ran out during rx */
+ u32 rx_orun; /* Receive overrun errors due to DMA */
+ u32 ip_cksum; /* IP header checksum errors */
+ u32 tcp_cksum; /* TCP checksum errors */
+ u32 udp_cksum; /* UDP checksum errors */
+};
+
+#define EMAC_REG_SPACE sizeof(struct gemac_reg)
+#define EMAC_RMON_LEN (sizeof(struct gemac_stats)/sizeof(u32))
+
+
+struct pfe_eth_fast_timer {
+ int queuenum;
+ struct hrtimer timer;
+ void * base;
+};
+
+#include "pfe_tso.h"
+typedef struct pfe_eth_priv_s
+{
+ struct pfe *pfe;
+ struct hif_client_s client;
+ struct napi_struct lro_napi;
+ struct napi_struct low_napi;
+ struct napi_struct high_napi;
+ int low_tmuQ;
+ int high_tmuQ;
+ struct net_device_stats stats;
+ struct net_device *dev;
+ int id;
+ int promisc;
+ unsigned int msg_enable;
+
+ spinlock_t lock;
+ unsigned int event_status;
+ int irq;
+ void* EMAC_baseaddr;
+ void* GPI_baseaddr;
+ /* PHY stuff */
+ struct phy_device *phydev;
+ int oldspeed;
+ int oldduplex;
+ int oldlink;
+ /* mdio info */
+ int mdc_div;
+ struct mii_bus *mii_bus;
+ /* gemac tc clock */
+ struct clk *gemtx_clk;
+
+ int default_priority;
+ struct timer_list tx_timer;
+ struct pfe_eth_fast_timer fast_tx_timeout[EMAC_TXQ_CNT];
+ int cpu_id;
+
+#ifdef ETH_HIF_NODMA_MAP
+ /* This array is used to store the dma mapping for skb fragments */
+ struct hif_frag_info_s dma_map_array[EMAC_TXQ_CNT][EMAC_TXQ_DEPTH];
+#endif
+ struct comcerto_eth_platform_data *einfo;
+ struct sk_buff *skb_inflight[EMAC_RXQ_CNT + 6];
+
+#ifdef PFE_ETH_LRO_STATS
+ unsigned int lro_len_counters[LRO_LEN_COUNT_MAX];
+ unsigned int lro_nb_counters[LRO_NB_COUNT_MAX]; //TODO change to exact max number when RX scatter done
+#endif
+
+ struct tso_cb_s tso;
+
+#ifdef PFE_ETH_TX_STATS
+ unsigned int stop_queue_total[EMAC_TXQ_CNT];
+ unsigned int stop_queue_hif[EMAC_TXQ_CNT];
+ unsigned int stop_queue_hif_client[EMAC_TXQ_CNT];
+ unsigned int stop_queue_credit[EMAC_TXQ_CNT];
+ unsigned int clean_fail[EMAC_TXQ_CNT];
+ unsigned int was_stopped[EMAC_TXQ_CNT];
+#endif
+
+#ifdef PFE_ETH_NAPI_STATS
+ unsigned int napi_counters[NAPI_MAX_COUNT];
+#endif
+
+}pfe_eth_priv_t;
+
+struct pfe_eth {
+ struct pfe_eth_priv_s *eth_priv[3];
+};
+
+int pfe_eth_init(struct pfe *pfe);
+void pfe_eth_exit(struct pfe *pfe);
+
+
+
+#endif /* _PFE_ETH_H_ */
diff --git a/pfe_ctrl/pfe_firmware.c b/pfe_ctrl/pfe_firmware.c
new file mode 100644
index 0000000..2f2146e
--- /dev/null
+++ b/pfe_ctrl/pfe_firmware.c
@@ -0,0 +1,299 @@
+
+
+/** @file
+ * Contains all the functions to handle parsing and loading of PE firmware files.
+ */
+#include <linux/firmware.h>
+
+#include "pfe_mod.h"
+#include "pfe_firmware.h"
+#include "pfe/pfe.h"
+
+static Elf32_Shdr * get_elf_section_header(const struct firmware *fw, const char *section)
+{
+ Elf32_Ehdr *elf_hdr = (Elf32_Ehdr *)fw->data;
+ Elf32_Shdr *shdr, *shdr_shstr;
+ Elf32_Off e_shoff = be32_to_cpu(elf_hdr->e_shoff);
+ Elf32_Half e_shentsize = be16_to_cpu(elf_hdr->e_shentsize);
+ Elf32_Half e_shnum = be16_to_cpu(elf_hdr->e_shnum);
+ Elf32_Half e_shstrndx = be16_to_cpu(elf_hdr->e_shstrndx);
+ Elf32_Off shstr_offset;
+ Elf32_Word sh_name;
+ const char *name;
+ int i;
+
+ /* Section header strings */
+ shdr_shstr = (Elf32_Shdr *)(fw->data + e_shoff + e_shstrndx * e_shentsize);
+ shstr_offset = be32_to_cpu(shdr_shstr->sh_offset);
+
+ for (i = 0; i < e_shnum; i++) {
+ shdr = (Elf32_Shdr *)(fw->data + e_shoff + i * e_shentsize);
+
+ sh_name = be32_to_cpu(shdr->sh_name);
+
+ name = (const char *)(fw->data + shstr_offset + sh_name);
+
+ if (!strcmp(name, section))
+ return shdr;
+ }
+
+ printk(KERN_ERR "%s: didn't find section %s\n", __func__, section);
+
+ return NULL;
+}
+
+static unsigned long get_elf_section(const struct firmware *fw, const char *section)
+{
+ Elf32_Shdr *shdr = get_elf_section_header(fw, section);
+
+ if (shdr)
+ return be32_to_cpu(shdr->sh_addr);
+ else
+ return -1;
+}
+
+#if defined(FPP_DIAGNOSTICS)
+static int pfe_get_diags_info(const struct firmware *fw, struct pfe_diags_info *diags_info)
+{
+ Elf32_Shdr *shdr;
+ unsigned long offset, size;
+
+ shdr = get_elf_section_header(fw, ".pfe_diags_str");
+ if (shdr)
+ {
+ offset = be32_to_cpu(shdr->sh_offset);
+ size = be32_to_cpu(shdr->sh_size);
+ diags_info->diags_str_base = be32_to_cpu(shdr->sh_addr);
+ diags_info->diags_str_size = size;
+ diags_info->diags_str_array = pfe_kmalloc(size, GFP_KERNEL);
+ memcpy(diags_info->diags_str_array, fw->data+offset, size);
+
+ return 0;
+ } else
+ {
+ return -1;
+ }
+}
+#endif
+
+static void pfe_check_version_info(const struct firmware *fw)
+{
+ static char *version = NULL;
+
+ Elf32_Shdr *shdr = get_elf_section_header(fw, ".version");
+
+ if (shdr)
+ {
+ if(!version)
+ {
+ /* this is the first fw we load, use its version string as reference (whatever it is) */
+ version = (char *)(fw->data + be32_to_cpu(shdr->sh_offset));
+
+ printk(KERN_INFO "PFE binary version: %s\n", version);
+ }
+ else
+ {
+ /* already have loaded at least one firmware, check sequence can start now */
+ if(strcmp(version, (char *)(fw->data + be32_to_cpu(shdr->sh_offset))))
+ {
+ printk(KERN_INFO "WARNING: PFE firmware binaries from incompatible version\n");
+ }
+ }
+ }
+ else
+ {
+ /* version cannot be verified, a potential issue that should be reported */
+ printk(KERN_INFO "WARNING: PFE firmware binaries from incompatible version\n");
+ }
+}
+
+/** PFE elf firmware loader.
+* Loads an elf firmware image into a list of PE's (specified using a bitmask)
+*
+* @param pe_mask Mask of PE id's to load firmware to
+* @param fw Pointer to the firmware image
+*
+* @return 0 on sucess, a negative value on error
+*
+*/
+int pfe_load_elf(int pe_mask, const struct firmware *fw)
+{
+ Elf32_Ehdr *elf_hdr = (Elf32_Ehdr *)fw->data;
+ Elf32_Half sections = be16_to_cpu(elf_hdr->e_shnum);
+ Elf32_Shdr *shdr = (Elf32_Shdr *) (fw->data + be32_to_cpu(elf_hdr->e_shoff));
+ int id, section;
+ int rc;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ /* Some sanity checks */
+ if (strncmp(&elf_hdr->e_ident[EI_MAG0], ELFMAG, SELFMAG))
+ {
+ printk(KERN_ERR "%s: incorrect elf magic number\n", __func__);
+ return -EINVAL;
+ }
+
+ if (elf_hdr->e_ident[EI_CLASS] != ELFCLASS32)
+ {
+ printk(KERN_ERR "%s: incorrect elf class(%x)\n", __func__, elf_hdr->e_ident[EI_CLASS]);
+ return -EINVAL;
+ }
+
+ if (elf_hdr->e_ident[EI_DATA] != ELFDATA2MSB)
+ {
+ printk(KERN_ERR "%s: incorrect elf data(%x)\n", __func__, elf_hdr->e_ident[EI_DATA]);
+ return -EINVAL;
+ }
+
+ if (be16_to_cpu(elf_hdr->e_type) != ET_EXEC)
+ {
+ printk(KERN_ERR "%s: incorrect elf file type(%x)\n", __func__, be16_to_cpu(elf_hdr->e_type));
+ return -EINVAL;
+ }
+
+ for (section = 0; section < sections; section++, shdr++)
+ {
+ if (!(be32_to_cpu(shdr->sh_flags) & (SHF_WRITE | SHF_ALLOC | SHF_EXECINSTR)))
+ continue;
+
+ for (id = 0; id < MAX_PE; id++)
+ if (pe_mask & (1 << id))
+ {
+ rc = pe_load_elf_section(id, fw->data, shdr);
+ if (rc < 0)
+ goto err;
+ }
+ }
+
+ pfe_check_version_info(fw);
+
+ return 0;
+
+err:
+ return rc;
+}
+
+
+/** PFE firmware initialization.
+* Loads different firmware files from filesystem.
+* Initializes PE IMEM/DMEM and UTIL-PE DDR
+* Initializes control path symbol addresses (by looking them up in the elf firmware files
+* Takes PE's out of reset
+*
+* @return 0 on sucess, a negative value on error
+*
+*/
+int pfe_firmware_init(struct pfe *pfe)
+{
+ const struct firmware *class_fw, *tmu_fw, *util_fw;
+ int rc = 0;
+#if !defined(CONFIG_UTIL_DISABLED)
+ const char* util_fw_name;
+#endif
+ printk(KERN_INFO "%s\n", __func__);
+
+ if (request_firmware(&class_fw, CLASS_FIRMWARE_FILENAME, pfe->dev)) {
+ printk(KERN_ERR "%s: request firmware %s failed\n", __func__, CLASS_FIRMWARE_FILENAME);
+ rc = -ETIMEDOUT;
+ goto err0;
+ }
+
+ if (request_firmware(&tmu_fw, TMU_FIRMWARE_FILENAME, pfe->dev)) {
+ printk(KERN_ERR "%s: request firmware %s failed\n", __func__, TMU_FIRMWARE_FILENAME);
+ rc = -ETIMEDOUT;
+ goto err1;
+ }
+#if !defined(CONFIG_UTIL_DISABLED)
+ util_fw_name = (system_rev == 0) ? UTIL_REVA0_FIRMWARE_FILENAME : UTIL_FIRMWARE_FILENAME;
+
+ if (request_firmware(&util_fw, util_fw_name, pfe->dev)) {
+ printk(KERN_ERR "%s: request firmware %s failed\n", __func__, util_fw_name);
+ rc = -ETIMEDOUT;
+ goto err2;
+ }
+#endif
+ rc = pfe_load_elf(CLASS_MASK, class_fw);
+ if (rc < 0) {
+ printk(KERN_ERR "%s: class firmware load failed\n", __func__);
+ goto err3;
+ }
+
+ pfe->ctrl.class_dmem_sh = get_elf_section(class_fw, ".dmem_sh");
+ pfe->ctrl.class_pe_lmem_sh = get_elf_section(class_fw, ".pe_lmem_sh");
+
+#if defined(FPP_DIAGNOSTICS)
+ rc = pfe_get_diags_info(class_fw, &pfe->diags.class_diags_info);
+ if (rc < 0) {
+ printk (KERN_WARNING "PFE diags won't be available for class PEs\n");
+ rc = 0;
+ }
+#endif
+
+ printk(KERN_INFO "%s: class firmware loaded %#lx %#lx\n", __func__, pfe->ctrl.class_dmem_sh, pfe->ctrl.class_pe_lmem_sh);
+
+ rc = pfe_load_elf(TMU_MASK, tmu_fw);
+ if (rc < 0) {
+ printk(KERN_ERR "%s: tmu firmware load failed\n", __func__);
+ goto err3;
+ }
+
+ pfe->ctrl.tmu_dmem_sh = get_elf_section(tmu_fw, ".dmem_sh");
+
+ printk(KERN_INFO "%s: tmu firmware loaded %#lx\n", __func__, pfe->ctrl.tmu_dmem_sh);
+
+#if !defined(CONFIG_UTIL_DISABLED)
+ rc = pfe_load_elf(UTIL_MASK, util_fw);
+ if (rc < 0) {
+ printk(KERN_ERR "%s: util firmware load failed\n", __func__);
+ goto err3;
+ }
+
+ pfe->ctrl.util_dmem_sh = get_elf_section(util_fw, ".dmem_sh");
+ pfe->ctrl.util_ddr_sh = get_elf_section(util_fw, ".ddr_sh");
+
+#if defined(FPP_DIAGNOSTICS)
+ rc = pfe_get_diags_info(util_fw, &pfe->diags.util_diags_info);
+ if (rc < 0) {
+ printk(KERN_WARNING "PFE diags won't be available for util PE\n");
+ rc = 0;
+ }
+#endif
+
+ printk(KERN_INFO "%s: util firmware loaded %#lx\n", __func__, pfe->ctrl.util_dmem_sh);
+
+ util_enable();
+#endif
+
+ tmu_enable(0xf);
+ class_enable();
+
+err3:
+#if !defined(CONFIG_UTIL_DISABLED)
+ release_firmware(util_fw);
+
+err2:
+#endif
+ release_firmware(tmu_fw);
+
+err1:
+ release_firmware(class_fw);
+
+err0:
+ return rc;
+}
+
+/** PFE firmware cleanup
+* Puts PE's in reset
+*
+*
+*/
+void pfe_firmware_exit(struct pfe *pfe)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+ class_disable();
+ tmu_disable(0xf);
+#if !defined(CONFIG_UTIL_DISABLED)
+ util_disable();
+#endif
+}
diff --git a/pfe_ctrl/pfe_firmware.h b/pfe_ctrl/pfe_firmware.h
new file mode 100644
index 0000000..0d5db73
--- /dev/null
+++ b/pfe_ctrl/pfe_firmware.h
@@ -0,0 +1,17 @@
+#ifndef _PFE_FIRMWARE_H_
+#define _PFE_FIRMWARE_H_
+
+#define CLASS_FIRMWARE_FILENAME "class_c2000.elf"
+#define TMU_FIRMWARE_FILENAME "tmu_c2000.elf"
+#define UTIL_FIRMWARE_FILENAME "util_c2000.elf"
+#define UTIL_REVA0_FIRMWARE_FILENAME "util_c2000_revA0.elf"
+
+#define PFE_FW_CHECK_PASS 0
+#define PFE_FW_CHECK_FAIL 1
+#define NUM_PFE_FW 3
+
+int pfe_firmware_init(struct pfe *pfe);
+void pfe_firmware_exit(struct pfe *pfe);
+
+#endif /* _PFE_FIRMWARE_H_ */
+
diff --git a/pfe_ctrl/pfe_hif.c b/pfe_ctrl/pfe_hif.c
new file mode 100644
index 0000000..03e612f
--- /dev/null
+++ b/pfe_ctrl/pfe_hif.c
@@ -0,0 +1,897 @@
+#ifdef __KERNEL__
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/list.h>
+#include <linux/kthread.h>
+#include <linux/slab.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#else
+#include "platform.h"
+#endif
+
+
+#include "pfe_mod.h"
+
+#define HIF_INT_MASK (HIF_INT | HIF_RXPKT_INT)
+
+#define inc_cl_idx(idxname) idxname = (idxname+1) & (queue->size-1)
+#define inc_hif_rxidx(idxname) idxname = (idxname+1) & (hif->RxRingSize-1)
+#define inc_hif_txidx(idxname) idxname = (idxname+1) & (hif->TxRingSize-1)
+
+unsigned char napi_first_batch = 0;
+
+static int pfe_hif_alloc_descr(struct pfe_hif *hif)
+{
+#if !defined(CONFIG_PLATFORM_PCI)
+ void *addr;
+ dma_addr_t dma_addr;
+ int err = 0;
+
+ printk(KERN_INFO "%s\n", __func__);
+ addr = dma_alloc_coherent(pfe->dev,
+ HIF_RX_DESC_NT * sizeof(struct hif_desc) + HIF_TX_DESC_NT * sizeof(struct hif_desc),
+ &dma_addr, GFP_KERNEL);
+
+ if (!addr) {
+ printk(KERN_ERR "%s: Could not allocate buffer descriptors!\n", __func__);
+ err = -ENOMEM;
+ goto err0;
+ }
+
+ hif->descr_baseaddr_p = dma_addr;
+ hif->descr_baseaddr_v = addr;
+#else
+ hif->descr_baseaddr_p = pfe->ddr_phys_baseaddr + HIF_DESC_BASEADDR;
+ hif->descr_baseaddr_v = pfe->ddr_baseaddr + HIF_DESC_BASEADDR;
+#endif
+ hif->RxRingSize = HIF_RX_DESC_NT;
+ hif->TxRingSize = HIF_TX_DESC_NT;
+
+ addr = dma_alloc_coherent(pfe->dev, HIF_TX_DESC_NT * sizeof(struct hif_tso_hdr),
+ &dma_addr, GFP_KERNEL);
+
+ if (!addr) {
+ printk(KERN_ERR "%s: Could not allocate buffer per-packet tx header!\n", __func__);
+ err = -ENOMEM;
+ goto err1;
+ }
+
+ hif->tso_hdr_p = dma_addr;
+ hif->tso_hdr_v = addr;
+
+ return 0;
+
+err1:
+ dma_free_coherent(pfe->dev,
+ hif->RxRingSize * sizeof(struct hif_desc) + hif->TxRingSize * sizeof(struct hif_desc),
+ hif->descr_baseaddr_v, hif->descr_baseaddr_p);
+
+err0:
+ return err;
+}
+
+static void pfe_hif_free_descr(struct pfe_hif *hif)
+{
+ printk(KERN_INFO "%s\n", __func__);
+#if !defined(CONFIG_PLATFORM_PCI)
+ dma_free_coherent(pfe->dev, hif->TxRingSize * sizeof(struct hif_tso_hdr), hif->tso_hdr_v, hif->tso_hdr_p);
+ dma_free_coherent(pfe->dev,
+ hif->RxRingSize * sizeof(struct hif_desc) + hif->TxRingSize * sizeof(struct hif_desc),
+ hif->descr_baseaddr_v, hif->descr_baseaddr_p);
+#endif
+}
+void pfe_hif_desc_dump(struct pfe_hif *hif)
+{
+ struct hif_desc *desc;
+ unsigned long desc_p;
+ int ii=0;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ desc = hif->RxBase;
+ desc_p = ((u32)desc - (u32)hif->descr_baseaddr_v + hif->descr_baseaddr_p);
+
+ printk("HIF Rx desc base %p physical %x\n", desc, (u32)desc_p);
+ for (ii = 0; ii < hif->RxRingSize; ii++) {
+ printk(KERN_INFO "status: %08x, ctrl: %08x, data: %08x, next: %x\n",
+ desc->status, desc->ctrl, desc->data, desc->next);
+ desc++;
+ }
+
+ desc = hif->TxBase;
+ desc_p = ((u32)desc - (u32)hif->descr_baseaddr_v + hif->descr_baseaddr_p);
+
+ printk("HIF Tx desc base %p physical %x\n", desc, (u32)desc_p);
+ for (ii = 0; ii < hif->TxRingSize; ii++) {
+ printk(KERN_INFO "status: %08x, ctrl: %08x, data: %08x, next: %x\n",
+ desc->status, desc->ctrl, desc->data, desc->next);
+ desc++;
+ }
+}
+
+/* pfe_hif_release_buffers
+ *
+ */
+static void pfe_hif_release_buffers(struct pfe_hif *hif)
+{
+ struct hif_desc *desc;
+ int i = 0;
+
+ hif->RxBase = hif->descr_baseaddr_v;
+
+ printk(KERN_INFO "%s\n", __func__);
+ /*Free Rx buffers */
+#if !defined(CONFIG_PLATFORM_PCI)
+ desc = hif->RxBase;
+ for (i = 0; i < hif->RxRingSize; i++) {
+ if (desc->data) {
+ if ((i < hif->shm->rx_buf_pool_cnt) && (hif->shm->rx_buf_pool[i] == NULL)) {
+ dma_unmap_single(hif->dev, desc->data, pfe_pkt_size, DMA_FROM_DEVICE);
+ hif->shm->rx_buf_pool[i] = hif->rx_buf_addr[i];
+ }
+ else {
+ /*TODO This should not happen*/
+ printk(KERN_ERR "%s: buffer pool already full\n", __func__);
+ }
+ }
+
+ desc->data = 0;
+ desc->status = 0;
+ desc->ctrl = 0;
+ desc++;
+ }
+#endif
+}
+
+
+/*
+ * pfe_hif_init_buffers
+ * This function initializes the HIF Rx/Tx ring descriptors and
+ * initialize Rx queue with buffers.
+ */
+static int pfe_hif_init_buffers(struct pfe_hif *hif)
+{
+ struct hif_desc *desc, *first_desc_p;
+ u32 data;
+ int i = 0;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ /* Check enough Rx buffers available in the shared memory */
+ if (hif->shm->rx_buf_pool_cnt < hif->RxRingSize)
+ return -ENOMEM;
+
+ hif->RxBase = hif->descr_baseaddr_v;
+ memset(hif->RxBase, 0, hif->RxRingSize * sizeof(struct hif_desc));
+
+ /*Initialize Rx descriptors */
+ desc = hif->RxBase;
+ first_desc_p = (struct hif_desc *)hif->descr_baseaddr_p;
+
+ for (i = 0; i < hif->RxRingSize; i++) {
+ /* Initialize Rx buffers from the shared memory */
+
+#if defined(CONFIG_PLATFORM_PCI)
+ data = pfe->ddr_phys_baseaddr + HIF_RX_PKT_DDR_BASEADDR + i * DDR_BUF_SIZE;
+#else
+ data = (u32)dma_map_single(hif->dev, hif->shm->rx_buf_pool[i], pfe_pkt_size, DMA_FROM_DEVICE);
+ hif->rx_buf_addr[i] = hif->shm->rx_buf_pool[i];
+ hif->shm->rx_buf_pool[i] = NULL;
+#endif
+ if (likely(dma_mapping_error(hif->dev, data) == 0)) {
+ desc->data = data;
+ } else {
+ printk(KERN_ERR "%s : low on mem\n", __func__);
+
+ goto err;
+ }
+
+ desc->status = 0;
+ wmb();
+ desc->ctrl = BD_CTRL_PKT_INT_EN | BD_CTRL_LIFM | BD_CTRL_DIR |
+ BD_CTRL_DESC_EN | BD_BUF_LEN(pfe_pkt_size);
+ /* Chain descriptors */
+ desc->next = (u32)(first_desc_p + i + 1);
+ desc++;
+ }
+
+ /* Overwrite last descriptor to chain it to first one*/
+ desc--;
+ desc->next = (u32)first_desc_p;
+
+ /*Initialize Rx buffer descriptor ring base address */
+ writel(hif->descr_baseaddr_p, HIF_RX_BDP_ADDR);
+
+ hif->TxBase = hif->RxBase + hif->RxRingSize;
+ first_desc_p = (struct hif_desc *)hif->descr_baseaddr_p + hif->RxRingSize;
+ memset(hif->TxBase, 0, hif->TxRingSize * sizeof(struct hif_desc));
+
+ /*Initialize tx descriptors */
+ desc = hif->TxBase;
+
+ for (i = 0; i < hif->TxRingSize; i++) {
+ /* Chain descriptors */
+ desc->next = (u32)(first_desc_p + i + 1);
+#if defined(CONFIG_PLATFORM_PCI)
+ desc->data = pfe->ddr_phys_baseaddr + HIF_TX_PKT_DDR_BASEADDR + i * DDR_BUF_SIZE;
+#endif
+ desc++;
+ }
+
+ /* Overwrite last descriptor to chain it to first one */
+ desc--;
+ desc->next = (u32)first_desc_p;
+ hif->TxAvail = hif->TxRingSize;
+ hif->Txtosend = 0;
+ hif->Txtoclean = 0;
+
+ /*Initialize Tx buffer descriptor ring base address */
+ writel((u32)first_desc_p, HIF_TX_BDP_ADDR);
+
+ return 0;
+
+err:
+ pfe_hif_release_buffers(hif);
+ return -ENOMEM;
+}
+
+/* pfe_hif_client_register
+ *
+ * This function used to register a client driver with the HIF driver.
+ *
+ * Return value:
+ * 0 - on Successful registration
+ */
+static int pfe_hif_client_register(struct pfe_hif *hif, u32 client_id, struct hif_client_shm *client_shm)
+{
+ struct hif_client *client = &hif->client[client_id];
+ u32 i, cnt;
+ struct rx_queue_desc *rx_qbase;
+ struct tx_queue_desc *tx_qbase;
+ struct hif_rx_queue *rx_queue;
+ struct hif_tx_queue *tx_queue;
+ int err = 0;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ spin_lock_bh(&hif->tx_lock);
+
+ if (test_bit(client_id, &hif->shm->gClient_status[0])) {
+ printk(KERN_ERR "%s: client %d already registered\n", __func__, client_id);
+ err = -1;
+ goto unlock;
+ }
+
+ memset(client, 0, sizeof(struct hif_client));
+
+ /*Initialize client Rx queues baseaddr, size */
+
+ cnt = CLIENT_CTRL_RX_Q_CNT(client_shm->ctrl);
+ /*Check if client is requesting for more queues than supported */
+ if (cnt > HIF_CLIENT_QUEUES_MAX)
+ cnt = HIF_CLIENT_QUEUES_MAX;
+
+ client->rx_qn = cnt;
+ rx_qbase = (struct rx_queue_desc *)client_shm->rx_qbase;
+ for (i = 0; i < cnt; i++)
+ {
+ rx_queue = &client->rx_q[i];
+ rx_queue->base = rx_qbase + i * client_shm->rx_qsize;
+ rx_queue->size = client_shm->rx_qsize;
+ rx_queue->write_idx = 0;
+ }
+
+ /*Initialize client Tx queues baseaddr, size */
+ cnt = CLIENT_CTRL_TX_Q_CNT(client_shm->ctrl);
+
+ /*Check if client is requesting for more queues than supported */
+ if (cnt > HIF_CLIENT_QUEUES_MAX)
+ cnt = HIF_CLIENT_QUEUES_MAX;
+
+ client->tx_qn = cnt;
+ tx_qbase = (struct tx_queue_desc *)client_shm->tx_qbase;
+ for (i = 0; i < cnt; i++)
+ {
+ tx_queue = &client->tx_q[i];
+ tx_queue->base = tx_qbase + i * client_shm->tx_qsize;
+ tx_queue->size = client_shm->tx_qsize;
+ tx_queue->ack_idx = 0;
+ }
+
+ set_bit(client_id, &hif->shm->gClient_status[0]);
+
+unlock:
+ spin_unlock_bh(&hif->tx_lock);
+
+ return err;
+}
+
+
+/* pfe_hif_client_unregister
+ *
+ * This function used to unregister a client from the HIF driver.
+ *
+ */
+static void pfe_hif_client_unregister(struct pfe_hif *hif, u32 client_id)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+ /* Mark client as no longer available (which prevents further packet receive for this client) */
+ spin_lock_bh(&hif->tx_lock);
+
+ if (!test_bit(client_id, &hif->shm->gClient_status[0])) {
+ printk(KERN_ERR "%s: client %d not registered\n", __func__, client_id);
+
+ spin_unlock_bh(&hif->tx_lock);
+ return;
+ }
+
+ clear_bit(client_id, &hif->shm->gClient_status[0]);
+
+ spin_unlock_bh(&hif->tx_lock);
+}
+
+
+/* client_put_rxpacket-
+ * This functions puts the Rx pkt in the given client Rx queue.
+ * It actually swap the Rx pkt in the client Rx descriptor buffer
+ * and returns the free buffer from it.
+ *
+ * If the funtion returns NULL means client Rx queue is full and
+ * packet couldn't send to client queue.
+ */
+static void *client_put_rxpacket(struct hif_rx_queue *queue, void *pkt, u32 len, u32 flags, u32 client_ctrl)
+{
+ void *free_pkt = NULL;
+ struct rx_queue_desc *desc = queue->base + queue->write_idx;
+
+ if (desc->ctrl & CL_DESC_OWN) {
+#if defined(CONFIG_PLATFORM_PCI)
+ memcpy(desc->data, pkt, len);
+ free_pkt = PFE_HOST_TO_PCI(pkt);
+ smp_wmb();
+ desc->ctrl = CL_DESC_BUF_LEN(len) | flags;
+ inc_cl_idx(queue->write_idx);
+#else
+ //TODO: move allocations after Rx loop to improve instruction cache locality
+ if (page_mode)
+ free_pkt = (void *)__get_free_page(GFP_ATOMIC | GFP_DMA_PFE);
+ else
+ free_pkt = kmalloc(PFE_BUF_SIZE, GFP_ATOMIC | GFP_DMA_PFE);
+
+ if (free_pkt) {
+ desc->data = pkt;
+ desc->client_ctrl = client_ctrl;
+ smp_wmb();
+ desc->ctrl = CL_DESC_BUF_LEN(len) | flags;
+ inc_cl_idx(queue->write_idx);
+ free_pkt += pfe_pkt_headroom;
+ }
+#endif
+ }
+
+ return free_pkt;
+}
+
+
+/* pfe_hif_rx_process-
+ * This function does pfe hif rx queue processing.
+ * Dequeue packet from Rx queue and send it to corresponding client queue
+ */
+static int pfe_hif_rx_process(struct pfe_hif *hif, int budget)
+{
+ struct hif_desc *desc;
+ struct hif_hdr *pkt_hdr;
+ struct __hif_hdr hif_hdr;
+ void *free_buf;
+ int rtc, len, rx_processed = 0;
+ struct __hif_desc local_desc;
+ int flags;
+ unsigned int desc_p;
+
+ spin_lock_bh(&hif->lock);
+
+ rtc = hif->RxtocleanIndex;
+
+ while (rx_processed < budget)
+ {
+ /*TODO may need to implement rx process budget */
+ desc = hif->RxBase + rtc;
+
+ __memcpy12(&local_desc, desc);
+
+ /* ACK pending Rx interrupt */
+ if (local_desc.ctrl & BD_CTRL_DESC_EN) {
+ writel(HIF_INT_MASK, HIF_INT_SRC);
+
+ if(rx_processed == 0)
+ {
+ if(napi_first_batch == 1)
+ {
+ desc_p = hif->descr_baseaddr_p + ((u32)(desc) -(u32)hif->descr_baseaddr_v);
+ outer_inv_range(desc_p, (desc_p + 16));
+ napi_first_batch = 0;
+ }
+ }
+
+ __memcpy12(&local_desc, desc);
+
+ if (local_desc.ctrl & BD_CTRL_DESC_EN)
+ break;
+ }
+
+ napi_first_batch = 0;
+
+#ifdef HIF_NAPI_STATS
+ hif->napi_counters[NAPI_DESC_COUNT]++;
+#endif
+ len = BD_BUF_LEN(local_desc.ctrl);
+#if defined(CONFIG_PLATFORM_PCI)
+ pkt_hdr = &hif_hdr;
+ memcpy(pkt_hdr, (void *)PFE_PCI_TO_HOST(local_desc.data), sizeof(struct hif_hdr));
+#else
+ dma_unmap_single(hif->dev, local_desc.data, pfe_pkt_size, DMA_FROM_DEVICE);
+
+ pkt_hdr = (struct hif_hdr *)hif->rx_buf_addr[rtc];
+
+ /* Track last HIF header received */
+ if (!hif->started) {
+ hif->started = 1;
+
+ __memcpy8(&hif_hdr, pkt_hdr);
+
+ hif->qno = hif_hdr.hdr.qNo;
+ hif->client_id = hif_hdr.hdr.client_id;
+ hif->client_ctrl = (hif_hdr.hdr.client_ctrl1 << 16) | hif_hdr.hdr.client_ctrl;
+ flags = CL_DESC_FIRST;
+
+// printk(KERN_INFO "start of packet: id %d, q %d, len %d, flags %x %x\n", hif->client_id, hif->qno, len, local_desc.ctrl, hif->client_ctrl);
+ }
+ else {
+// printk(KERN_INFO "continuation: id %d, q %d, len %d, flags %x\n", hif->client_id, hif->qno, len, local_desc.ctrl);
+ flags = 0;
+ }
+
+ if (local_desc.ctrl & BD_CTRL_LIFM)
+ flags |= CL_DESC_LAST;
+#endif
+ /* Check for valid client id and still registered */
+ if ((hif->client_id >= HIF_CLIENTS_MAX) || !(test_bit(hif->client_id, &hif->shm->gClient_status[0]))) {
+ if (printk_ratelimit())
+ printk(KERN_ERR "%s: packet with invalid client id %d qNo %d\n", __func__, hif->client_id, hif->qno);
+
+#if defined(CONFIG_PLATFORM_PCI)
+ free_buf = local_desc.data;
+#else
+ free_buf = pkt_hdr;
+#endif
+ goto pkt_drop;
+ }
+
+ /* Check to valid queue number */
+ if (hif->client[hif->client_id].rx_qn <= hif->qno) {
+ printk(KERN_INFO "%s: packet with invalid queue: %d\n", __func__, hif->qno);
+ hif->qno = 0;
+ }
+
+#if defined(CONFIG_PLATFORM_PCI)
+ free_buf = client_put_rxpacket(&hif->client[hif->client_id].rx_q[hif->qno],
+ (void *)PFE_PCI_TO_HOST(desc->data), len, flags, hif->client_ctrl);
+#else
+ free_buf = client_put_rxpacket(&hif->client[hif->client_id].rx_q[hif->qno],
+ (void *)pkt_hdr, len, flags, hif->client_ctrl);
+#endif
+
+ hif_lib_indicate_client(hif->client_id, EVENT_RX_PKT_IND, hif->qno);
+
+ if (unlikely(!free_buf)) {
+#ifdef HIF_NAPI_STATS
+ hif->napi_counters[NAPI_CLIENT_FULL_COUNT]++;
+#endif
+ /* If we want to keep in polling mode to retry later, we need to tell napi that we consumed
+ the full budget or we will hit a livelock scenario. The core code keeps this napi instance
+ at the head of the list and none of the other instances get to run */
+ rx_processed = budget;
+
+ if (flags & CL_DESC_FIRST)
+ hif->started = 0;
+
+ break;
+ }
+
+ pkt_drop:
+#if defined(CONFIG_PLATFORM_PCI)
+ desc->data = (u32)free_buf;
+#else
+ /*Fill free buffer in the descriptor */
+ hif->rx_buf_addr[rtc] = free_buf;
+ desc->data = (u32)dma_map_single(hif->dev, free_buf, pfe_pkt_size, DMA_FROM_DEVICE);
+#endif
+ wmb();
+ desc->ctrl = BD_CTRL_PKT_INT_EN | BD_CTRL_LIFM | BD_CTRL_DIR |
+ BD_CTRL_DESC_EN | BD_BUF_LEN(pfe_pkt_size);
+
+ inc_hif_rxidx(rtc);
+
+ if (local_desc.ctrl & BD_CTRL_LIFM) {
+ if (!(hif->client_ctrl & HIF_CTRL_RX_CONTINUED)) {
+ rx_processed++;
+
+#ifdef HIF_NAPI_STATS
+ hif->napi_counters[NAPI_PACKET_COUNT]++;
+#endif
+ }
+ hif->started = 0;
+ }
+ }
+
+ hif->RxtocleanIndex = rtc;
+ spin_unlock_bh(&hif->lock);
+
+ /* we made some progress, re-start rx dma in case it stopped */
+ hif_rx_dma_start();
+
+ return rx_processed;
+}
+
+
+/* client_ack_txpacket-
+ * This function ack the Tx packet in the give client Tx queue by resetting
+ * ownership bit in the descriptor.
+ */
+static int client_ack_txpacket(struct pfe_hif *hif, unsigned int client_id, unsigned int q_no)
+{
+ struct hif_tx_queue *queue = &hif->client[client_id].tx_q[q_no];
+ struct tx_queue_desc *desc = queue->base + queue->ack_idx;
+
+ if (desc->ctrl & CL_DESC_OWN) {
+ /*TODO Do we need to match the pkt address also? */
+ desc->ctrl &= ~CL_DESC_OWN;
+ inc_cl_idx(queue->ack_idx);
+
+ return 0;
+ }
+ else {
+ /*This should not happen */
+ printk(KERN_ERR "%s: %d %d %d %d %d %p %d\n", __func__, hif->Txtosend, hif->Txtoclean, hif->TxAvail, client_id, q_no, queue, queue->ack_idx);
+ BUG();
+ return 1;
+ }
+}
+
+void __hif_tx_done_process(struct pfe_hif *hif, int count)
+{
+ struct hif_desc *desc;
+ struct hif_desc_sw *desc_sw;
+ int ttc, tx_avl;
+
+ ttc = hif->Txtoclean;
+ tx_avl = hif->TxAvail;
+
+ while ((tx_avl < hif->TxRingSize) && count--) {
+ desc = hif->TxBase + ttc;
+
+ if (desc->ctrl & BD_CTRL_DESC_EN)
+ break;
+
+ desc_sw = &hif->tx_sw_queue[ttc];
+
+ if (desc_sw->data) {
+#if !defined(CONFIG_PLATFORM_PCI)
+ dma_unmap_single(hif->dev, desc_sw->data, desc_sw->len, DMA_TO_DEVICE);
+#endif
+ }
+ client_ack_txpacket(hif, desc_sw->client_id, desc_sw->q_no);
+
+ inc_hif_txidx(ttc);
+ tx_avl++;
+ }
+
+ hif->Txtoclean = ttc;
+ hif->TxAvail = tx_avl;
+}
+
+
+/* __hif_xmit_pkt -
+ * This function puts one packet in the HIF Tx queue
+ */
+void __hif_xmit_pkt(struct pfe_hif *hif, unsigned int client_id, unsigned int q_no, void *data, u32 len, unsigned int flags)
+{
+ struct hif_desc *desc;
+ struct hif_desc_sw *desc_sw;
+
+#if defined(CONFIG_PLATFORM_EMULATION)
+ {
+ struct hif_queue *queue = &hif->client[client_id].rx_q[0];
+ struct queue_desc *qdesc = queue->base + queue->write_idx;
+ void *buf;
+
+ printk("%s: packet loop backed client_id:%d qno:%d data : %p len:%d\n", __func__, client_id, q_no, data, len);
+#if 1
+ if (qdesc->ctrl & CL_DESC_OWN) {
+ buf = (void *)qdesc->data;
+ memcpy(buf, data, len);
+ wmb();
+ qdesc->ctrl = CL_DESC_BUF_LEN(len);
+ inc_cl_idx(queue->write_idx);
+ printk("%s: packet loop backed..\n", __func__);
+ hif_lib_indicate_client(client_id, EVENT_RX_PKT_IND, q_no);
+ client_ack_txpacket(&hif->client[client_id].tx_q[q_no]);
+ }
+#endif
+ }
+
+#else
+ desc = hif->TxBase + hif->Txtosend;
+ desc_sw = &hif->tx_sw_queue[hif->Txtosend];
+
+ desc_sw->len = len;
+ desc_sw->client_id = client_id;
+ desc_sw->q_no = q_no;
+ desc_sw->flags = flags;
+
+#if !defined(CONFIG_PLATFORM_PCI)
+ if (flags & HIF_DONT_DMA_MAP) {
+ desc_sw->data = 0;
+ desc->data = (u32)data;
+ } else {
+ desc_sw->data = dma_map_single(hif->dev, data, len, DMA_TO_DEVICE);
+ desc->data = (u32)desc_sw->data;
+ }
+#else
+#define ALIGN32(x) ((x) & ~0x3)
+ memcpy(PFE_PCI_TO_HOST(desc->data), data, ALIGN32(len+0x3));
+#endif
+
+ inc_hif_txidx(hif->Txtosend);
+ hif->TxAvail--;
+
+ /* For TSO we skip actual TX until the last descriptor */
+ /* This reduce the number of required wmb() */
+ if ((flags & HIF_TSO) && (!((flags & HIF_DATA_VALID) && (flags & HIF_LAST_BUFFER))))
+ goto skip_tx;
+
+ wmb();
+
+ do {
+ desc_sw = &hif->tx_sw_queue[hif->Txtoflush];
+ desc = hif->TxBase + hif->Txtoflush;
+
+ if (desc_sw->flags & HIF_LAST_BUFFER) {
+ if ((desc_sw->client_id < PFE_CL_VWD0) || (desc_sw->client_id > (PFE_CL_VWD0 + MAX_VAP_SUPPORT)))
+ desc->ctrl = BD_CTRL_LIFM | BD_CTRL_BRFETCH_DISABLE |
+ BD_CTRL_RTFETCH_DISABLE | BD_CTRL_PARSE_DISABLE |
+ BD_CTRL_DESC_EN | BD_BUF_LEN(desc_sw->len);
+ else
+ desc->ctrl = BD_CTRL_LIFM | BD_CTRL_DESC_EN | BD_BUF_LEN(desc_sw->len);
+ }
+ else
+ desc->ctrl = BD_CTRL_DESC_EN | BD_BUF_LEN(desc_sw->len);
+
+ inc_hif_txidx(hif->Txtoflush);
+ }
+ while (hif->Txtoflush != hif->Txtosend);
+
+skip_tx:
+ return;
+
+#endif
+}
+
+
+int hif_xmit_pkt(struct pfe_hif *hif, unsigned int client_id, unsigned int q_no, void *data, unsigned int len)
+{
+ int rc = 0;
+
+ spin_lock_bh(&hif->tx_lock);
+
+ if (!hif->TxAvail)
+ rc = 1;
+ else {
+ __hif_xmit_pkt(hif, client_id, q_no, data, len, HIF_FIRST_BUFFER | HIF_LAST_BUFFER);
+ hif_tx_dma_start();
+ }
+ if (hif->TxAvail < (hif->TxRingSize >> 1))
+ __hif_tx_done_process(hif, TX_FREE_MAX_COUNT);
+
+ spin_unlock_bh(&hif->tx_lock);
+
+ return rc;
+}
+
+/* hif_isr-
+ * This ISR routine processes Rx/Tx done interrupts from the HIF hardware block
+ */
+static irqreturn_t hif_isr(int irq, void *dev_id)
+{
+ struct pfe_hif *hif = (struct pfe_hif *) dev_id;
+ int int_status;
+
+ /*Read hif interrupt source register */
+ int_status = readl_relaxed(HIF_INT_SRC);
+
+ if ((int_status & HIF_INT) == 0)
+ return(IRQ_NONE);
+
+ int_status &= ~(HIF_INT);
+
+ if (int_status & HIF_RXPKT_INT) {
+ int_status &= ~(HIF_RXPKT_INT);
+
+ /* Disable interrupts */
+ writel_relaxed(0, HIF_INT_ENABLE);
+
+ napi_first_batch = 1;
+
+ if (napi_schedule_prep(&hif->napi))
+ {
+#ifdef HIF_NAPI_STATS
+ hif->napi_counters[NAPI_SCHED_COUNT]++;
+#endif
+ __napi_schedule(&hif->napi);
+ }
+ }
+
+ if (int_status) {
+ printk(KERN_INFO "%s : Invalid interrupt : %d\n", __func__, int_status);
+ writel(int_status, HIF_INT_SRC);
+ }
+
+ return IRQ_HANDLED;
+}
+
+
+void hif_process_client_req(struct pfe_hif *hif, int req, int data1, int data2)
+{
+ unsigned int client_id = data1;
+
+ if (client_id >= HIF_CLIENTS_MAX)
+ {
+ printk(KERN_ERR "%s: client id %d out of bounds\n", __func__, client_id);
+ return;
+ }
+
+ switch (req) {
+ case REQUEST_CL_REGISTER:
+ /* Request for register a client */
+ printk(KERN_INFO "%s: register client_id %d\n", __func__, client_id);
+ pfe_hif_client_register(hif, client_id, (struct hif_client_shm *)&hif->shm->client[client_id]);
+ break;
+
+ case REQUEST_CL_UNREGISTER:
+ printk(KERN_INFO "%s: unregister client_id %d\n", __func__, client_id);
+
+ /* Request for unregister a client */
+ pfe_hif_client_unregister(hif, client_id);
+
+ break;
+
+ default:
+ printk(KERN_ERR "%s: unsupported request %d\n", __func__, req);
+ break;
+ }
+
+ /*TODO check for TMU queue resume request */
+
+ /*Process client Tx queues
+ * Currently we don't have checking for tx pending*/
+}
+
+/** pfe_hif_rx_poll
+ * This function is NAPI poll function to process HIF Rx queue.
+ */
+static int pfe_hif_rx_poll(struct napi_struct *napi, int budget)
+{
+ struct pfe_hif *hif = container_of(napi, struct pfe_hif, napi);
+ int work_done;
+
+#ifdef HIF_NAPI_STATS
+ hif->napi_counters[NAPI_POLL_COUNT]++;
+#endif
+
+ work_done = pfe_hif_rx_process(hif, budget);
+
+ if (work_done < budget)
+ {
+ napi_complete(napi);
+ writel_relaxed(HIF_INT_MASK, HIF_INT_ENABLE);
+ }
+#ifdef HIF_NAPI_STATS
+ else
+ hif->napi_counters[NAPI_FULL_BUDGET_COUNT]++;
+#endif
+
+ return work_done;
+}
+
+/* pfe_hif_init
+ * This function initializes the baseaddresses and irq, etc.
+ */
+int pfe_hif_init(struct pfe *pfe)
+{
+ struct pfe_hif *hif = &pfe->hif;
+ int err;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ hif->dev = pfe->dev;
+ hif->irq = pfe->hif_irq;
+
+ if ((err = pfe_hif_alloc_descr(hif))) {
+ goto err0;
+ }
+
+ if (pfe_hif_init_buffers(hif)) {
+ printk(KERN_ERR "%s: Could not initialize buffer descriptors\n", __func__);
+ err = -ENOMEM;
+ goto err1;
+ }
+
+ /* Initilize NAPI for Rx processing */
+ init_dummy_netdev(&hif->dummy_dev);
+ netif_napi_add(&hif->dummy_dev, &hif->napi, pfe_hif_rx_poll, HIF_RX_POLL_WEIGHT);
+ napi_enable(&hif->napi);
+
+ spin_lock_init(&hif->tx_lock);
+ spin_lock_init(&hif->lock);
+
+ hif_init();
+ hif_rx_enable();
+ hif_tx_enable();
+
+ /* Disable tx done interrupt */
+ writel(HIF_INT_MASK, HIF_INT_ENABLE);
+
+ gpi_enable(HGPI_BASE_ADDR);
+
+#ifdef __KERNEL__
+ err = request_irq(hif->irq, hif_isr, IRQF_DISABLED, "pfe_hif", hif);
+ if (err) {
+ printk(KERN_ERR "%s: failed to get the hif IRQ = %d\n", __func__, hif->irq);
+ goto err1;
+ }
+#else
+ /*TODO register interrupts */
+#endif
+
+ return 0;
+err1:
+ pfe_hif_free_descr(hif);
+err0:
+ return err;
+}
+
+/* pfe_hif_exit-
+ */
+void pfe_hif_exit(struct pfe *pfe)
+{
+ struct pfe_hif *hif = &pfe->hif;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ spin_lock_bh(&hif->lock);
+ hif->shm->gClient_status[0] = 0;
+ hif->shm->gClient_status[1] = 0; /* Make sure all clients are disabled */
+
+ spin_unlock_bh(&hif->lock);
+
+ /*Disable Rx/Tx */
+ gpi_disable(HGPI_BASE_ADDR);
+ hif_rx_disable();
+ hif_tx_disable();
+
+ napi_disable(&hif->napi);
+ netif_napi_del(&hif->napi);
+
+#ifdef __KERNEL__
+ free_irq(hif->irq, hif);
+#endif
+ pfe_hif_release_buffers(hif);
+ pfe_hif_free_descr(hif);
+}
diff --git a/pfe_ctrl/pfe_hif.h b/pfe_ctrl/pfe_hif.h
new file mode 100644
index 0000000..f331e0a
--- /dev/null
+++ b/pfe_ctrl/pfe_hif.h
@@ -0,0 +1,279 @@
+#ifndef _PFE_HIF_H_
+#define _PFE_HIF_H_
+
+#include <linux/netdevice.h>
+
+#define HIF_NAPI_STATS
+
+#define HIF_CLIENT_QUEUES_MAX 16
+#define HIF_RX_POLL_WEIGHT 64
+
+enum {
+ NAPI_SCHED_COUNT = 0,
+ NAPI_POLL_COUNT,
+ NAPI_PACKET_COUNT,
+ NAPI_DESC_COUNT,
+ NAPI_FULL_BUDGET_COUNT,
+ NAPI_CLIENT_FULL_COUNT,
+ NAPI_MAX_COUNT
+};
+
+
+/* XXX HIF_TX_DESC_NT value should be always greter than 4,
+ * Otherwise HIF_TX_POLL_MARK will become zero.
+ */
+#if defined(CONFIG_PLATFORM_PCI)
+#define HIF_RX_DESC_NT 4
+#define HIF_TX_DESC_NT 4
+#else
+#if defined(CONFIG_COMCERTO_64K_PAGES)
+#define HIF_RX_DESC_NT 64
+#else
+#define HIF_RX_DESC_NT 256
+#endif
+#define HIF_TX_DESC_NT 2048
+#endif
+
+#define HIF_FIRST_BUFFER (1 << 0)
+#define HIF_LAST_BUFFER (1 << 1)
+#define HIF_DONT_DMA_MAP (1 << 2) //TODO merge it with TSO
+#define HIF_DATA_VALID (1 << 3)
+#define HIF_TSO (1 << 4)
+
+#define MAX_VAP_SUPPORT 3
+#define MAX_WIFI_VAPS MAX_VAP_SUPPORT
+
+enum {
+ PFE_CL_GEM0 = 0,
+ PFE_CL_GEM1,
+ PFE_CL_GEM2,
+ PFE_CL_VWD0,
+ PFE_CL_VWD_LAST = PFE_CL_VWD0 + MAX_VAP_SUPPORT,
+ PFE_CL_PCAP0,
+ HIF_CLIENTS_MAX
+};
+
+/*structure to store client queue info */
+struct hif_rx_queue {
+ struct rx_queue_desc *base;
+ u32 size;
+ u32 write_idx;
+};
+
+struct hif_tx_queue {
+ struct tx_queue_desc *base;
+ u32 size;
+ u32 ack_idx;
+};
+
+/*Structure to store the client info */
+struct hif_client {
+ int rx_qn;
+ struct hif_rx_queue rx_q[HIF_CLIENT_QUEUES_MAX];
+ int tx_qn;
+ struct hif_tx_queue tx_q[HIF_CLIENT_QUEUES_MAX];
+};
+
+/*HIF hardware buffer descriptor */
+struct hif_desc {
+ volatile u32 ctrl;
+ volatile u32 status;
+ volatile u32 data;
+ volatile u32 next;
+};
+
+struct __hif_desc {
+ u32 ctrl;
+ u32 status;
+ u32 data;
+};
+
+struct hif_desc_sw {
+ dma_addr_t data;
+ u16 len;
+ u8 client_id;
+ u8 q_no;
+ u16 flags;
+};
+
+struct hif_hdr {
+ u8 client_id;
+ u8 qNo;
+ u16 client_ctrl;
+ u16 client_ctrl1;
+};
+
+struct __hif_hdr {
+ union {
+ struct hif_hdr hdr;
+ u32 word[2];
+ };
+};
+
+struct hif_lro_hdr {
+ u16 data_offset;
+ u16 mss;
+};
+
+struct hif_ipsec_hdr {
+ u16 sa_handle[2];
+}__attribute__((packed));
+
+struct hif_tso_hdr {
+ struct hif_hdr pkt_hdr;
+ u16 ip_off;
+ u16 ip_id;
+ u16 ip_len;
+ u16 tcp_off;
+ u32 tcp_seq;
+} __attribute__((packed));
+
+struct hif_pcap_hdr {
+ u8 ifindex;
+ u8 unused;
+ u16 seqno;
+ u32 timestamp;
+}__attribute__((packed));
+
+/* HIF_CTRL_TX... defines */
+#define HIF_CTRL_TX_IPSEC_OUT (1 << 7)
+#define HIF_CTRL_TX_OWN_MAC (1 << 6)
+#define HIF_CTRL_TX_TSO_END (1 << 5)
+#define HIF_CTRL_TX_TSO6 (1 << 4)
+#define HIF_CTRL_TX_TSO (1 << 3)
+#define HIF_CTRL_TX_CHECKSUM (1 << 2)
+#define HIF_CTRL_TX_CSUM_VALIDATE (1 << 1)
+#define HIF_CTRL_TX_WIFI (1 << 0)
+
+/* HIF_CTRL_RX... defines */
+#define HIF_CTRL_RX_OFFSET_OFST (24)
+#define HIF_CTRL_RX_PE_ID_OFST (16)
+#define HIF_CTRL_RX_IPSEC_IN (1 << 4)
+#define HIF_CTRL_RX_WIFI_EXPT (1 << 3)
+#define HIF_CTRL_RX_CHECKSUMMED (1 << 2)
+#define HIF_CTRL_RX_CONTINUED (1 << 1)
+#define HIF_CTRL_RX_WIFI_HEADROOM (1 << 0)
+
+#define HIF_CTRL_VAPID_OFST (8)
+
+struct pfe_hif {
+ /* To store registered clients in hif layer */
+ struct hif_client client[HIF_CLIENTS_MAX];
+ struct hif_shm *shm;
+ int irq;
+
+ void *descr_baseaddr_v;
+ unsigned long descr_baseaddr_p;
+
+ struct hif_desc *RxBase;
+ u32 RxRingSize;
+ u32 RxtocleanIndex;
+ void *rx_buf_addr[HIF_RX_DESC_NT];
+ unsigned int qno;
+ unsigned int client_id;
+ unsigned int client_ctrl;
+ unsigned int started;
+
+ struct hif_desc *TxBase;
+ u32 TxRingSize;
+ u32 Txtosend;
+ u32 Txtoclean;
+ u32 TxAvail;
+ u32 Txtoflush;
+ struct hif_desc_sw tx_sw_queue[HIF_TX_DESC_NT];
+ struct hif_tso_hdr *tso_hdr_v;
+ dma_addr_t tso_hdr_p;
+
+ spinlock_t tx_lock;
+ spinlock_t lock;
+ struct net_device dummy_dev;
+ struct napi_struct napi;
+ struct device *dev;
+
+#ifdef CONFIG_HOTPLUG_CPU
+ struct notifier_block cpu_notify;
+#endif
+
+#ifdef HIF_NAPI_STATS
+ unsigned int napi_counters[NAPI_MAX_COUNT];
+#endif
+};
+
+void __hif_xmit_pkt(struct pfe_hif *hif, unsigned int client_id, unsigned int q_no, void *data, u32 len, unsigned int flags);
+int hif_xmit_pkt(struct pfe_hif *hif, unsigned int client_id, unsigned int q_no, void *data, unsigned int len);
+void __hif_tx_done_process(struct pfe_hif *hif, int count);
+void hif_process_client_req(struct pfe_hif *hif, int req, int data1, int data2);
+int pfe_hif_init(struct pfe *pfe);
+void pfe_hif_exit(struct pfe *pfe);
+
+static inline void hif_tx_done_process(struct pfe_hif *hif, int count)
+{
+ spin_lock_bh(&hif->tx_lock);
+ __hif_tx_done_process(hif, count);
+ spin_unlock_bh(&hif->tx_lock);
+}
+
+static inline void hif_tx_lock(struct pfe_hif *hif)
+{
+ spin_lock_bh(&hif->tx_lock);
+}
+
+static inline void hif_tx_unlock(struct pfe_hif *hif)
+{
+ spin_unlock_bh(&hif->tx_lock);
+}
+
+static inline int __hif_tx_avail(struct pfe_hif *hif)
+{
+ return hif->TxAvail;
+}
+
+static inline void __memcpy8(void *dst, void *src)
+{
+ asm volatile ( "ldm %1, {r9, r10}\n\t"
+ "stm %0, {r9, r10}\n\t"
+ :
+ : "r" (dst), "r" (src)
+ : "r9", "r10", "memory"
+ );
+}
+
+static inline void __memcpy12(void *dst, void *src)
+{
+ asm volatile ( "ldm %1, {r8, r9, r10}\n\t"
+ "stm %0, {r8, r9, r10}\n\t"
+ :
+ : "r" (dst), "r" (src)
+ : "r8", "r9", "r10", "memory"
+ );
+}
+
+static inline void __memcpy16(void *dst, void *src)
+{
+ asm volatile ( "ldm %1, {r7, r8, r9, r10}\n\t"
+ "stm %0, {r7, r8, r9, r10}\n\t"
+ :
+ : "r"(dst), "r"(src)
+ : "r7", "r8", "r9", "r10", "memory"
+ );
+}
+
+#define HIF_MEMCPY_BURSTSIZE 32 /*__memcpy copy 32byte in a burst*/
+static inline void __memcpy(void *dst, void *src, unsigned int len)
+{
+ void *end = src + len;
+
+ dst = (void *)((unsigned long)dst & ~0x3);
+ src = (void *)((unsigned long)src & ~0x3);
+
+ while (src < end) {
+ asm volatile ( "ldm %1!, {r3, r4, r5, r6, r7, r8, r9, r10}\n\t"
+ "stm %0!, {r3, r4, r5, r6, r7, r8, r9, r10}\n\t"
+ : "+r"(dst), "+r"(src)
+ :
+ : "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "memory"
+ );
+ }
+}
+
+#endif /* _PFE_HIF_H_ */
diff --git a/pfe_ctrl/pfe_hif_lib.c b/pfe_ctrl/pfe_hif_lib.c
new file mode 100644
index 0000000..f12f0d7
--- /dev/null
+++ b/pfe_ctrl/pfe_hif_lib.c
@@ -0,0 +1,759 @@
+#include <linux/version.h>
+#include <asm/system.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
+#include <linux/sched.h>
+#include <linux/skbuff.h>
+#include <linux/moduleparam.h>
+#include <linux/cpu.h>
+
+#include "pfe_mod.h"
+#include "pfe_hif.h"
+#include "pfe_hif_lib.h"
+#include "pfe_ctrl_hal.h"
+
+
+unsigned int lro_mode = 0;
+unsigned int page_mode = 0;
+module_param(lro_mode, uint, S_IRUGO);
+MODULE_PARM_DESC(lro_mode,
+ "0: disable lro support(default), 1: enable lro support, skb data is kept in pages, class is configured in toe mode");
+unsigned int tx_qos = 0;
+module_param(tx_qos, uint, S_IRUGO);
+MODULE_PARM_DESC(tx_qos,
+ "0: disable tx qos (default), 1: enable tx qos, guarantee no packet drop at TMU level, only works if forwarding is disabled");
+unsigned int pfe_pkt_size;
+unsigned int pfe_pkt_headroom;
+
+
+/** @pfe_hal_lib.c.
+ * Common functions used by HIF client drivers
+ */
+
+/*HIF shared memory Global variable */
+struct hif_shm ghif_shm;
+
+/* TMU tx transmitted packets counter, 1 per TMU */
+unsigned int TMU_DMEM_SH(tx_trans)[EMAC_TXQ_CNT];
+
+/* Cleanup the HIF shared memory, release HIF rx_buffer_pool.
+ * This function should be called after pfe_hif_exit
+ *
+ * @param[in] hif_shm Shared memory address location in DDR
+ */
+static void pfe_hif_shm_clean(struct hif_shm *hif_shm)
+{
+ int i;
+ void *pkt;
+
+ for (i = 0; i < hif_shm->rx_buf_pool_cnt; i++) {
+ pkt = hif_shm->rx_buf_pool[i];
+ if (pkt) {
+ hif_shm->rx_buf_pool[i] = NULL;
+ pkt -= pfe_pkt_headroom;
+
+ if (page_mode)
+ free_page((unsigned long)pkt);
+ else
+ kfree(pkt);
+ }
+ }
+}
+
+/* Initialize shared memory used between HIF driver and clients,
+ * allocate rx_buffer_pool required for HIF Rx descriptors.
+ * This function should be called before initializing HIF driver.
+ *
+ * @param[in] hif_shm Shared memory address location in DDR
+ * @rerurn 0 - on succes, <0 on fail to initialize
+ */
+static int pfe_hif_shm_init(struct hif_shm *hif_shm)
+{
+ int i;
+ void *pkt;
+
+ memset(hif_shm, 0, sizeof(struct hif_shm));
+ hif_shm->rx_buf_pool_cnt = HIF_RX_DESC_NT;
+
+ for (i = 0; i < hif_shm->rx_buf_pool_cnt; i++) {
+ if (page_mode)
+ pkt = (void *)__get_free_page(GFP_KERNEL | GFP_DMA_PFE);
+ else
+ pkt = kmalloc(PFE_BUF_SIZE, GFP_KERNEL | GFP_DMA_PFE);
+
+ if (pkt)
+ hif_shm->rx_buf_pool[i] = pkt + pfe_pkt_headroom;
+ else
+ goto err0;
+ }
+
+ return 0;
+
+err0:
+ printk(KERN_ERR "%s Low memory\n", __func__);
+ pfe_hif_shm_clean(hif_shm);
+ return -ENOMEM;
+}
+
+/*This function sends indication to HIF driver
+ *
+ * @param[in] hif hif context
+ **/
+static void hif_lib_indicate_hif(struct pfe_hif *hif, int req, int data1, int data2)
+{
+ //TODO : If we separate HIF and HIF LIB, then send req and data through shared memory.
+
+ hif_process_client_req(hif, req, data1, data2);
+}
+
+/** hif_lib_set_rx_cpu_affinity
+ *
+ * @param[in] client Client control block.
+ * @param[in] cpu_id cpu number.
+ */
+void hif_lib_set_rx_cpu_affinity(struct hif_client_s *client, int cpu_id)
+{
+ spin_lock_bh(&pfe->hif.lock);
+
+
+ if (cpu_id < 0) {
+ printk(KERN_INFO "%s:Client (%d) and HIF Rx processing will use same cpu\n", __func__, client->id);
+ client->user_cpu_id = client->cpu_id = cpu_id;
+ }
+ else if ( cpu_online(cpu_id)) {
+ printk(KERN_INFO "%s:Client (%d) rx processing is moved to cpu#%d\n", __func__, client->id, cpu_id);
+ client->user_cpu_id = client->cpu_id = cpu_id;
+ }
+ else {
+ client->user_cpu_id = cpu_id;
+ printk(KERN_INFO "%s : CPU (%d) is offline, applied automatically after cpu online\n", __func__, cpu_id);
+ }
+ spin_unlock_bh(&pfe->hif.lock);
+}
+
+/** hif_lib_load_balance
+ *
+ */
+static void hif_lib_load_balance(void *data)
+{
+ int cl_id = (u32)data & 0xffff;
+ int qno = ((u32)data >> 16) & 0xff;
+ int event_type = ((u32)data >> 24) & 0xff;
+ struct hif_client_s *client = pfe->hif_client[cl_id];
+
+ client->event_handler(client->priv, event_type, qno);
+}
+
+void hif_lib_indicate_client(int client_id, int event_type, int qno)
+{
+ struct hif_client_s *client = pfe->hif_client[client_id];
+
+ /*
+ * TODO : Right now, all events are queue number based. So we are masking events per queue
+ * basis. Later if we add any events those do not depend on queue number, then we may
+ * may need may need to add masking per event.
+ */
+ if (!client || (event_type >= HIF_EVENT_MAX) || (qno >= HIF_CLIENT_QUEUES_MAX) )
+ return;
+
+ if (!test_and_set_bit(qno, &client->queue_mask[event_type])) {
+
+#if defined(CONFIG_SMP) && (NR_CPUS > 1)
+ if ((event_type == EVENT_RX_PKT_IND) && ((client->cpu_id != smp_processor_id()) && (client->cpu_id >= 0)))
+ if(!smp_call_function_single(client->cpu_id, hif_lib_load_balance, (void *)((event_type << 24) | (qno << 16) | client_id), 0))
+ return;
+
+#endif
+ client->event_handler(client->priv, event_type, qno);
+ }
+
+}
+
+
+/*This function releases Rx queue descriptors memory and pre-filled buffers
+ *
+ * @param[in] client hif_client context
+ */
+static void hif_lib_client_release_rx_buffers(struct hif_client_s *client)
+{
+ struct rx_queue_desc *desc;
+ int qno, ii;
+ void *buf;
+
+ for (qno = 0; qno < client->rx_qn; qno++) {
+ desc = client->rx_q[qno].base;
+
+ for (ii = 0; ii < client->rx_q[qno].size; ii++) {
+ buf = (void *)desc->data;
+ if (buf) {
+ buf -= pfe_pkt_headroom;
+
+ if (page_mode)
+ free_page((unsigned long)buf);
+ else
+ kfree(buf);
+
+ desc->ctrl = 0;
+ }
+
+ desc++;
+ }
+ }
+
+ kfree(client->rx_qbase);
+}
+
+
+/*This function allocates memory for the rxq descriptors and pre-fill rx queues
+ * with buffers.
+ * @param[in] client client context
+ * @param[in] q_size size of the rxQ, all queues are of same size
+ */
+static int hif_lib_client_init_rx_buffers(struct hif_client_s *client, int q_size)
+{
+ struct rx_queue_desc *desc;
+ struct hif_client_rx_queue *queue;
+ int ii, qno;
+
+ /*Allocate memory for the client queues */
+ client->rx_qbase = kzalloc(client->rx_qn * q_size * sizeof(struct rx_queue_desc), GFP_KERNEL);
+ if (!client->rx_qbase){
+ goto err;
+ }
+
+ for (qno = 0; qno < client->rx_qn; qno++) {
+ queue = &client->rx_q[qno];
+
+ queue->base = client->rx_qbase + qno * q_size * sizeof(struct rx_queue_desc);
+ queue->size = q_size;
+ queue->read_idx = 0;
+ queue->write_idx = 0;
+
+ dbg_print_info("rx queue: %d, base: %p, size: %d \n", qno, queue->base, queue->size);
+ }
+
+ for (qno = 0; qno < client->rx_qn; qno++) {
+ queue = &client->rx_q[qno];
+ desc = queue->base;
+
+ for (ii = 0; ii < queue->size; ii++) {
+ desc->ctrl = CL_DESC_BUF_LEN(pfe_pkt_size) | CL_DESC_OWN;
+ desc++;
+ }
+ }
+
+ return 0;
+
+err:
+ return 1;
+}
+
+#define inc_cl_idx(idxname) idxname = (idxname+1) & (queue->size-1)
+
+static void hif_lib_client_cleanup_tx_queue(struct hif_client_tx_queue *queue)
+{
+ dbg_print_info( "%s\n", __func__);
+
+ /* Check if there are any pending packets. Client must flush the tx queues
+ before unregistering, by calling by calling hif_lib_tx_get_next_complete() */
+ /* Hif no longer calls since we are no longer registered */
+
+ if (queue->tx_pending)
+ printk(KERN_ERR "%s: pending transmit packets\n", __func__);
+}
+
+static void hif_lib_client_release_tx_buffers(struct hif_client_s *client)
+{
+ int qno;
+
+ dbg_print_info("%s\n", __func__);
+
+ for (qno = 0; qno < client->tx_qn; qno++) {
+ hif_lib_client_cleanup_tx_queue(&client->tx_q[qno]);
+ }
+
+ kfree(client->tx_qbase);
+}
+
+static int hif_lib_client_init_tx_buffers(struct hif_client_s *client, int q_size)
+{
+ struct hif_client_tx_queue *queue;
+ int qno;
+
+ client->tx_qbase = kzalloc(client->tx_qn * q_size * sizeof(struct tx_queue_desc), GFP_KERNEL);
+ if (!client->tx_qbase) {
+ return 1;
+ }
+
+ for (qno = 0; qno < client->tx_qn; qno++) {
+ queue = &client->tx_q[qno];
+
+ queue->base = client->tx_qbase + qno * q_size * sizeof(struct tx_queue_desc);
+ queue->size = q_size;
+ queue->read_idx = 0;
+ queue->write_idx = 0;
+ queue->tx_pending = 0;
+
+ dbg_print_info("tx queue: %d, base: %p, size: %d \n", qno, queue->base, queue->size);
+ }
+
+ return 0;
+}
+
+static int hif_lib_event_dummy( void *priv, int event_type, int qno)
+{
+ return 0;
+}
+
+int hif_lib_client_register(struct hif_client_s *client)
+{
+ struct hif_shm *hif_shm;
+ struct hif_client_shm *client_shm;
+ int err, i;
+// int loop_cnt = 0;
+
+ dbg_print_info("%s\n", __func__);
+
+ spin_lock_bh(&pfe->hif.lock);
+ if (!(client->pfe) || (client->id >= HIF_CLIENTS_MAX) || (pfe->hif_client[client->id])) {
+ err = -EINVAL;
+ goto err;
+ }
+
+ hif_shm = client->pfe->hif.shm;
+
+ if (hif_lib_client_init_rx_buffers(client, client->rx_qsize)) {
+ err = -ENOMEM;
+ goto err_rx;
+ }
+
+ if (hif_lib_client_init_tx_buffers(client, client->tx_qsize)) {
+ err = -ENOMEM;
+ goto err_tx;
+ }
+
+ if (!client->event_handler)
+ client->event_handler = hif_lib_event_dummy;
+
+ /*Initialize client specific shared memory */
+ client_shm = (struct hif_client_shm *)&hif_shm->client[client->id];
+ client_shm->rx_qbase = (u32)client->rx_qbase;
+ client_shm->rx_qsize = client->rx_qsize;
+ client_shm->tx_qbase = (u32)client->tx_qbase;
+ client_shm->tx_qsize = client->tx_qsize;
+ client_shm->ctrl = (client->tx_qn << CLIENT_CTRL_TX_Q_CNT_OFST) | (client->rx_qn << CLIENT_CTRL_RX_Q_CNT_OFST);
+// spin_lock_init(&client->rx_lock);
+
+ for (i = 0; i < HIF_EVENT_MAX; i++) {
+ client->queue_mask[i] = 0; /* By default all events are unmasked */
+ }
+
+ /*Indicate to HIF driver*/
+ hif_lib_indicate_hif(&pfe->hif, REQUEST_CL_REGISTER, client->id, 0);
+
+ dbg_print_info("%s: client: %p, client_id: %d, tx_qsize: %d, rx_qsize: %d\n",
+ __func__, client, client->id, client->tx_qsize, client->rx_qsize);
+
+ client->cpu_id = -1;
+
+ pfe->hif_client[client->id] = client;
+ spin_unlock_bh(&pfe->hif.lock);
+
+ /*This function need to be called with out holding hif.lock */
+ hif_lib_set_rx_cpu_affinity(client, client->user_cpu_id);
+
+ return 0;
+
+err_tx:
+ hif_lib_client_release_rx_buffers(client);
+
+err_rx:
+err:
+ spin_unlock_bh(&pfe->hif.lock);
+ return err;
+}
+
+int hif_lib_client_unregister(struct hif_client_s *client)
+{
+ struct pfe *pfe = client->pfe;
+ u32 client_id = client->id;
+
+ printk(KERN_INFO "%s : client: %p, client_id: %d, txQ_depth: %d, rxQ_depth: %d\n",
+ __func__, client, client->id, client->tx_qsize, client->rx_qsize);
+
+
+ spin_lock_bh(&pfe->hif.lock);
+ hif_lib_indicate_hif(&pfe->hif, REQUEST_CL_UNREGISTER, client->id, 0);
+
+ hif_lib_client_release_tx_buffers(client);
+ hif_lib_client_release_rx_buffers(client);
+ pfe->hif_client[client_id] = NULL;
+ spin_unlock_bh(&pfe->hif.lock);
+
+ return 0;
+}
+
+int hif_lib_event_handler_start(struct hif_client_s *client, int event, int qno)
+{
+ struct hif_client_rx_queue *queue = &client->rx_q[qno];
+ struct rx_queue_desc *desc = queue->base + queue->read_idx;
+
+ if ((event >= HIF_EVENT_MAX) || ( qno >= HIF_CLIENT_QUEUES_MAX)) {
+ dbg_print_info("%s: Unsupported event : %d queue number : %d\n", __func__, event, qno);
+ return -1;
+ }
+
+ test_and_clear_bit(qno, &client->queue_mask[event]);
+
+ switch (event) {
+ case EVENT_RX_PKT_IND:
+ if (!(desc->ctrl & CL_DESC_OWN))
+ hif_lib_indicate_client(client->id, EVENT_RX_PKT_IND, qno);
+ break;
+
+ case EVENT_HIGH_RX_WM:
+ case EVENT_TXDONE_IND:
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+
+/*This function gets one packet from the specified client queue
+ * It also refill the rx buffer */
+void *hif_lib_receive_pkt(struct hif_client_s *client, int qno, int *len, int *ofst, unsigned int *rx_ctrl, unsigned int *desc_ctrl, void **priv_data)
+{
+ struct hif_client_rx_queue *queue = &client->rx_q[qno];
+ struct rx_queue_desc *desc;
+ void *pkt = NULL;
+
+ //printk(KERN_INFO "%s\n", __func__);
+#if defined(CONFIG_PLATFORM_EMULATION)
+ printk(KERN_INFO "%s:qno:%d cid:%d desc:%p rdidx:%d \n",
+ __func__, qno, client->id, desc,
+ queue->read_idx);
+#endif
+
+ /* Following lock is to protect rx queue access from, hif_lib_event_handler_start.
+ * In general below lock is not required, because hif_lib_xmit_pkt and
+ * hif_lib_event_handler_start are called from napi poll and which is not
+ * re-entrant. But if some client use in different way this lock is required.
+ */
+ //spin_lock_irqsave(&client->rx_lock, flags);
+ desc = queue->base + queue->read_idx;
+ if (!(desc->ctrl & CL_DESC_OWN)) {
+ pkt = desc->data - pfe_pkt_headroom;
+
+ *rx_ctrl = desc->client_ctrl;
+ *desc_ctrl = desc->ctrl;
+
+ if (desc->ctrl & CL_DESC_FIRST) {
+ u16 size = *rx_ctrl >> HIF_CTRL_RX_OFFSET_OFST;
+
+ if (size) {
+ *len = CL_DESC_BUF_LEN(desc->ctrl) - PFE_PKT_HEADER_SZ - size;
+ *ofst = pfe_pkt_headroom + PFE_PKT_HEADER_SZ + size;
+ *priv_data = desc->data + PFE_PKT_HEADER_SZ;
+ } else {
+ *len = CL_DESC_BUF_LEN(desc->ctrl) - PFE_PKT_HEADER_SZ;
+ *ofst = pfe_pkt_headroom + PFE_PKT_HEADER_SZ;
+ *priv_data = NULL;
+ }
+
+ if(*rx_ctrl & HIF_CTRL_RX_WIFI_HEADROOM) {
+ /* PFE inserts empty head room for WiFi Tx packets */
+ *ofst += PFE_WIFI_PKT_HEADROOM;
+ *len -= PFE_WIFI_PKT_HEADROOM;
+ if(priv_data)
+ priv_data += PFE_WIFI_PKT_HEADROOM;
+ }
+ } else {
+ *len = CL_DESC_BUF_LEN(desc->ctrl);
+ *ofst = pfe_pkt_headroom;
+ }
+
+ desc->data = NULL; // Needed so we don't free a buffer/page twice on module_exit
+ smp_wmb();
+
+ desc->ctrl = CL_DESC_BUF_LEN(pfe_pkt_size) | CL_DESC_OWN;
+ inc_cl_idx(queue->read_idx);
+ }
+
+ //spin_unlock_irqrestore(&client->rx_lock, flags);
+ return pkt;
+}
+
+void __hif_lib_xmit_tso_hdr(struct hif_client_s *client, unsigned int qno, u32 client_ctrl, unsigned int ip_off,
+ unsigned int ip_id, unsigned int ip_len, unsigned int tcp_off, unsigned int tcp_seq)
+{
+ struct hif_client_tx_queue *queue = &client->tx_q[qno];
+ struct tx_queue_desc *desc = queue->base + queue->write_idx;
+ struct hif_tso_hdr *tso_hdr;
+ u32 tso_hdr_p;
+
+// printk(KERN_INFO "%s\n",__func__);
+
+ tso_hdr = pfe->hif.tso_hdr_v + pfe->hif.Txtosend;
+ tso_hdr_p = (u32)pfe->hif.tso_hdr_p + (pfe->hif.Txtosend * sizeof(struct hif_tso_hdr));
+
+ tso_hdr->ip_off = ip_off;
+ tso_hdr->ip_id = ip_id;
+ tso_hdr->ip_len = ip_len;
+ tso_hdr->tcp_off = tcp_off;
+ tso_hdr->tcp_seq = tcp_seq;
+
+ tso_hdr->pkt_hdr.client_id = client->id;
+ tso_hdr->pkt_hdr.qNo = qno;
+ tso_hdr->pkt_hdr.client_ctrl = client_ctrl;
+// printk(KERN_DEBUG "%s : seq: %x id: %x desc_n: %d desc_addr: %p tx_hdr_v : %p tx_hdr_p: %x, ip_off: %d tcp_off: %d\n",__func__, tso_hdr->tcp_seq, tso_hdr->ip_id, pfe->hif.Txtosend, desc, tso_hdr, tso_hdr_p, tso_hdr->ip_off, tso_hdr->tcp_off );
+
+ desc->data = (void *)0x1; /* bogus non null value to avoid stopping tx done processing */
+ desc->ctrl = CL_DESC_OWN | CL_DESC_FLAGS(0);
+
+ __hif_xmit_pkt(&pfe->hif, client->id, qno, (void *)tso_hdr_p, sizeof(struct hif_tso_hdr), HIF_DONT_DMA_MAP | HIF_TSO);
+
+ inc_cl_idx(queue->write_idx);
+ queue->tx_pending++;
+}
+
+static inline void hif_hdr_write(struct hif_hdr *pkt_hdr, unsigned int client_id, unsigned int qno, u32 client_ctrl)
+{
+ /* Optimize the write since the destinaton may be non-cacheable */
+ if (!((unsigned long)pkt_hdr & 0x3)) {
+ ((u32 *)pkt_hdr)[0] = (client_ctrl << 16) | (qno << 8) | client_id;
+ } else {
+ ((u16 *)pkt_hdr)[0] = (qno << 8) | client_id;
+ ((u16 *)pkt_hdr)[1] = client_ctrl;
+ }
+}
+
+/*This function puts the given packet in the specific client queue */
+void __hif_lib_xmit_pkt(struct hif_client_s *client, unsigned int qno, void *data, unsigned int len, u32 client_ctrl, unsigned int flags, void *client_data)
+{
+ struct hif_client_tx_queue *queue = &client->tx_q[qno];
+ struct tx_queue_desc *desc = queue->base + queue->write_idx;
+
+ //printk(KERN_INFO "%s\n",__func__);
+
+ /* First buffer */
+ if (flags & HIF_FIRST_BUFFER)
+ {
+ data -= sizeof(struct hif_hdr);
+ len += sizeof(struct hif_hdr);
+
+ hif_hdr_write(data, client->id, qno, client_ctrl);
+ }
+
+ desc->data = client_data;
+ desc->ctrl = CL_DESC_OWN | CL_DESC_FLAGS(flags);
+
+ __hif_xmit_pkt(&pfe->hif, client->id, qno, data, len, flags);
+
+ inc_cl_idx(queue->write_idx);
+ queue->tx_pending++;
+ queue->jiffies_last_packet = jiffies;
+}
+
+/*This function puts the given packet in the specific client queue */
+int hif_lib_xmit_pkt(struct hif_client_s *client, unsigned int qno, void *data, unsigned int len, u32 client_ctrl, void *client_data)
+{
+ struct hif_client_tx_queue *queue = &client->tx_q[qno];
+ struct tx_queue_desc *desc = queue->base + queue->write_idx;
+
+ //printk(KERN_INFO "%s\n",__func__);
+
+ if (queue->tx_pending < queue->size) {
+ /*Construct pkt header */
+
+ data -= sizeof(struct hif_hdr);
+ len += sizeof(struct hif_hdr);
+
+ hif_hdr_write(data, client->id, qno, client_ctrl);
+
+ desc->data = client_data;
+ desc->ctrl = CL_DESC_OWN | CL_DESC_FLAGS(HIF_FIRST_BUFFER | HIF_LAST_BUFFER | HIF_DATA_VALID);
+
+ if (hif_xmit_pkt(&pfe->hif, client->id, qno, data, len))
+ return 1;
+
+ inc_cl_idx(queue->write_idx);
+ queue->tx_pending++;
+ queue->jiffies_last_packet = jiffies;
+
+ return 0;
+ }
+
+ dbg_print_info("%s Tx client %d qno %d is full\n",__func__, client->id, qno);
+ return 1;
+}
+
+void *hif_lib_tx_get_next_complete(struct hif_client_s *client, int qno, unsigned int *flags, int count)
+{
+ struct hif_client_tx_queue *queue = &client->tx_q[qno];
+ struct tx_queue_desc *desc = queue->base + queue->read_idx;
+
+ dbg_print_info("%s: qno : %d rd_indx: %d pending:%d\n",__func__, qno, queue->read_idx, queue->tx_pending);
+
+ if (!queue->tx_pending)
+ return NULL;
+
+ if (desc->ctrl & CL_DESC_OWN) {
+ hif_tx_done_process(&pfe->hif, count);
+
+ //Check again, if packets done in tx queue.
+ if (desc->ctrl & CL_DESC_OWN)
+ return NULL;
+ }
+
+ inc_cl_idx(queue->read_idx);
+ queue->tx_pending--;
+
+ *flags = CL_DESC_GET_FLAGS(desc->ctrl);
+
+ return desc->data;
+}
+
+//FIXME: TMU queues length mapping needs to be declared in shared PFE/PFE_CTRL header
+static void hif_lib_tmu_credit_init(struct pfe *pfe)
+{
+ int i, q;
+
+ for (i = 0; i < NUM_GEMAC_SUPPORT; i++)
+ for (q = 0; q < EMAC_TXQ_CNT; q++) {
+ pfe->tmu_credit.tx_credit_max[i][q] = (q == 0) ? DEFAULT_Q0_QDEPTH : DEFAULT_MAX_QDEPTH;
+ pfe->tmu_credit.tx_credit[i][q] = pfe->tmu_credit.tx_credit_max[i][q];
+ }
+}
+/** __hif_lib_update_credit
+ *
+ * @param[in] client hif client context
+ * @param[in] queue queue number in match with TMU
+ */
+void __hif_lib_update_credit(struct hif_client_s *client, unsigned int queue)
+{
+ unsigned int tmu_tx_packets, tmp;
+
+ if (tx_qos) {
+ tmu_tx_packets = be32_to_cpu(pe_dmem_read(TMU0_ID + client->id, virt_to_tmu_dmem(&tx_trans[queue]), 4));
+
+ // tx_packets counter overflowed
+ if (tmu_tx_packets > pfe->tmu_credit.tx_packets[client->id][queue]) {
+ tmp = UINT_MAX - tmu_tx_packets + pfe->tmu_credit.tx_packets[client->id][queue];
+ pfe->tmu_credit.tx_credit[client->id][queue] = pfe->tmu_credit.tx_credit_max[client->id][queue] - tmp;
+ }
+ // TMU tx <= pfe_eth tx, normal case or both OF since last time
+ else
+ pfe->tmu_credit.tx_credit[client->id][queue] = pfe->tmu_credit.tx_credit_max[client->id][queue] - (pfe->tmu_credit.tx_packets[client->id][queue] - tmu_tx_packets);
+ }
+}
+
+/** hif_lib_update_credit
+ *
+ * @param[in] client hif client context
+ * @param[in] queue queue number in match with TMU
+ */
+void hif_lib_update_credit(struct hif_client_s *client, unsigned int queue)
+{
+ spin_lock_bh(&pfe->hif.tx_lock);
+ __hif_lib_update_credit(client, queue);
+ spin_unlock_bh(&pfe->hif.tx_lock);
+}
+
+
+#ifdef CONFIG_HOTPLUG_CPU
+/** pfe_hif_lib_cpu_notifier
+ *
+ * @param[in] nfb cpu notifier control block.
+ * @param[in] action event to notify.
+ * @param[in] hcpu cpu id.
+ */
+static int pfe_hif_lib_cpu_notifier(struct notifier_block *nfb, unsigned long action, void *hcpu)
+{
+ int cpu = (long)hcpu;
+ int ii;
+ unsigned long flags;
+
+ spin_lock_irqsave(&pfe->hif.lock, flags);
+ switch (action & ~CPU_TASKS_FROZEN) {
+ case CPU_DOWN_FAILED:
+ case CPU_ONLINE:
+ printk(KERN_INFO "%s : CPU (%d) is up\n", __func__, cpu);
+
+ for (ii = 0; ii < HIF_CLIENTS_MAX; ii++) {
+ if (pfe->hif_client[ii] && (pfe->hif_client[ii]->user_cpu_id == cpu))
+ pfe->hif_client[ii]->cpu_id = pfe->hif_client[ii]->user_cpu_id;
+ }
+ break;
+
+ case CPU_DOWN_PREPARE:
+ printk(KERN_INFO "%s : CPU (%d) is down\n", __func__, cpu);
+
+ for (ii = 0; ii < HIF_CLIENTS_MAX; ii++) {
+ if (pfe->hif_client[ii] && (pfe->hif_client[ii]->user_cpu_id == cpu))
+ pfe->hif_client[ii]->cpu_id = -1;
+ }
+ break;
+ default:
+ break;
+ }
+ spin_unlock_irqrestore(&pfe->hif.lock, flags);
+
+ return NOTIFY_OK;
+}
+#endif
+
+
+int pfe_hif_lib_init(struct pfe *pfe)
+{
+ int rc;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ if (lro_mode) {
+ page_mode = 1;
+ pfe_pkt_size = min(PAGE_SIZE, MAX_PFE_PKT_SIZE);
+ pfe_pkt_headroom = 0;
+ } else {
+ page_mode = 0;
+ pfe_pkt_size = PFE_PKT_SIZE;
+ pfe_pkt_headroom = PFE_PKT_HEADROOM;
+ }
+ hif_lib_tmu_credit_init(pfe);
+ pfe->hif.shm = &ghif_shm;
+ rc = pfe_hif_shm_init(pfe->hif.shm);
+
+#ifdef CONFIG_HOTPLUG_CPU
+ if (rc)
+ goto err_shm_init;
+
+ pfe->hif.cpu_notify.notifier_call = pfe_hif_lib_cpu_notifier;
+ pfe->hif.cpu_notify.priority = 0;
+
+ rc = register_cpu_notifier(&pfe->hif.cpu_notify);
+
+ if (rc)
+ pfe_hif_shm_clean(pfe->hif.shm);
+
+
+err_shm_init:
+#endif
+
+ return rc;
+}
+
+
+void pfe_hif_lib_exit(struct pfe *pfe)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+#ifdef CONFIG_HOTPLUG_CPU
+ unregister_cpu_notifier(&pfe->hif.cpu_notify);
+#endif
+ pfe_hif_shm_clean(pfe->hif.shm);
+}
diff --git a/pfe_ctrl/pfe_hif_lib.h b/pfe_ctrl/pfe_hif_lib.h
new file mode 100644
index 0000000..bae74e8
--- /dev/null
+++ b/pfe_ctrl/pfe_hif_lib.h
@@ -0,0 +1,194 @@
+#ifndef _PFE_HIF_LIB_H_
+#define _PFE_HIF_LIB_H_
+
+#include "pfe_hif.h"
+
+#ifdef HIF_LIB_DEBUG
+#define dbg_print_info( fmt, args...) \
+ printk(KERN_INFO fmt, ##args)
+#else
+#define dbg_print_info( fmt, args...)
+#endif
+
+#define HIF_CL_REQ_TIMEOUT 10
+
+#if defined(CONFIG_COMCERTO_ZONE_DMA_NCNB)
+#define GFP_DMA_PFE (GFP_DMA_NCNB | __GFP_NOWARN)
+#else
+#define GFP_DMA_PFE 0
+#endif
+
+enum {
+ REQUEST_CL_REGISTER = 0,
+ REQUEST_CL_UNREGISTER,
+ HIF_REQUEST_MAX
+};
+
+enum {
+ EVENT_HIGH_RX_WM = 0, /* Event to indicate that client rx queue is reached water mark level */
+ EVENT_RX_PKT_IND, /* Event to indicate that, packet recieved for client */
+ EVENT_TXDONE_IND, /* Event to indicate that, packet tx done for client */
+ HIF_EVENT_MAX
+};
+
+/*structure to store client queue info */
+
+/*structure to store client queue info */
+struct hif_client_rx_queue {
+ struct rx_queue_desc *base;
+ u32 size;
+ u32 read_idx;
+ u32 write_idx;
+};
+
+struct hif_client_tx_queue {
+ struct tx_queue_desc *base;
+ u32 size;
+ u32 read_idx;
+ u32 write_idx;
+ u32 tx_pending;
+ unsigned long jiffies_last_packet;
+};
+
+struct hif_client_s
+{
+ int id;
+ int tx_qn;
+ int rx_qn;
+ void *rx_qbase;
+ void *tx_qbase;
+ /* FIXME tx/rx_qsize fields can be removed after per queue depth is supported*/
+ int tx_qsize;
+ int rx_qsize;
+ int cpu_id;
+ int user_cpu_id;
+
+// spinlock_t rx_lock;
+ struct hif_client_tx_queue tx_q[HIF_CLIENT_QUEUES_MAX];
+ struct hif_client_rx_queue rx_q[HIF_CLIENT_QUEUES_MAX];
+ int (*event_handler)(void *priv, int event, int data);
+ unsigned long queue_mask[HIF_EVENT_MAX];
+ struct pfe *pfe;
+ void *priv;
+};
+
+
+/* Client specific shared memory
+ * It contains number of Rx/Tx queues, base addresses and queue sizes */
+struct hif_client_shm {
+ u32 ctrl; /*0-7: number of Rx queues, 8-15: number of tx queues */
+ u32 rx_qbase; /*Rx queue base address */
+ u32 rx_qsize; /*each Rx queue size, all Rx queues are of same size */
+ u32 tx_qbase; /* Tx queue base address */
+ u32 tx_qsize; /*each Tx queue size, all Tx queues are of same size */
+};
+
+/*Client shared memory ctrl bit description */
+#define CLIENT_CTRL_RX_Q_CNT_OFST 0
+#define CLIENT_CTRL_TX_Q_CNT_OFST 8
+#define CLIENT_CTRL_RX_Q_CNT(ctrl) (((ctrl) >> CLIENT_CTRL_RX_Q_CNT_OFST) & 0xFF)
+#define CLIENT_CTRL_TX_Q_CNT(ctrl) (((ctrl) >> CLIENT_CTRL_TX_Q_CNT_OFST) & 0xFF)
+
+
+
+/*Shared memory used to communicate between HIF driver and host/client drivers
+ * Before starting the hif driver rx_buf_pool ans rx_buf_pool_cnt should be
+ * initialized with host buffers and buffers count in the pool.
+ * rx_buf_pool_cnt should be >= HIF_RX_DESC_NT.
+ *
+ */
+struct hif_shm {
+ u32 rx_buf_pool_cnt; /*Number of rx buffers available*/
+ void *rx_buf_pool[HIF_RX_DESC_NT];/*Rx buffers required to initialize HIF rx descriptors */
+ unsigned long gClient_status[2]; /*Global client status bit mask */
+ u32 hif_qfull; /*TODO Client-id that caused for the TMU3 queue stop */
+ u32 hif_qresume; /*TODO */
+ struct hif_client_shm client[HIF_CLIENTS_MAX]; /* Client specific shared memory */
+};
+
+
+#define CL_DESC_OWN (1 << 31) /* This sets owner ship to HIF driver */
+#define CL_DESC_LAST (1 << 30) /* This indicates last packet for multi buffers handling */
+#define CL_DESC_FIRST (1 << 29) /* This indicates first packet for multi buffers handling */
+#define CL_DESC_BUF_LEN(x) ((x) & 0xFFFF)
+#define CL_DESC_FLAGS(x) (((x) & 0xF) << 16)
+#define CL_DESC_GET_FLAGS(x) (((x) >> 16) & 0xF)
+
+struct rx_queue_desc {
+ void *data;
+ u32 ctrl; /*0-15bit len, 16-20bit flags, 31bit owner*/
+ u32 client_ctrl;
+};
+
+struct tx_queue_desc {
+ void *data;
+ u32 ctrl; /*0-15bit len, 16-20bit flags, 31bit owner*/
+};
+
+/* HIF Rx is not working properly for 2-byte aligned buffers and
+ * ip_header should be 4byte aligned for better iperformance.
+ * "ip_header = 64 + 6(hif_header) + 14 (MAC Header)" will be 4byte aligned.
+ */
+#define PFE_PKT_HEADER_SZ sizeof(struct hif_hdr)
+#define PFE_BUF_SIZE 2048 /* must be big enough for headroom, pkt size and skb shared info */
+#define PFE_PKT_HEADROOM 128
+#define SKB_SHARED_INFO_SIZE 256 /* At least sizeof(struct skb_shared_info) bytes */
+
+//#define PFE_PKT_SIZE 1544 /* maximum ethernet packet size */
+#define PFE_PKT_SIZE (PFE_BUF_SIZE - PFE_PKT_HEADROOM - SKB_SHARED_INFO_SIZE) /* maximum ethernet packet size after reassembly offload*/
+#define MAX_L2_HDR_SIZE 14 /* Not correct for VLAN/PPPoE */
+#define MAX_L3_HDR_SIZE 20 /* Not correct for IPv6 */
+#define MAX_L4_HDR_SIZE 60 /* TCP with maximum options */
+#define MAX_HDR_SIZE (MAX_L2_HDR_SIZE + MAX_L3_HDR_SIZE + MAX_L4_HDR_SIZE)
+#define MAX_WIFI_HDR_SIZE (MAX_L2_HDR_SIZE + MAX_L3_HDR_SIZE + 6)
+#define MAX_PFE_PKT_SIZE 16380UL /* Used in page mode to clamp packet size to the maximum supported by the hif hw interface (<16KiB) */
+
+extern unsigned int pfe_pkt_size;
+extern unsigned int pfe_pkt_headroom;
+extern unsigned int page_mode;
+extern unsigned int lro_mode;
+extern unsigned int tx_qos;
+
+int pfe_hif_lib_init(struct pfe *pfe);
+void pfe_hif_lib_exit(struct pfe *pfe);
+int hif_lib_client_register(struct hif_client_s *client);
+int hif_lib_client_unregister(struct hif_client_s *client);
+void __hif_lib_xmit_tso_hdr(struct hif_client_s *client, unsigned int qno, u32 client_ctrl, unsigned int ip_off, unsigned int ip_id, unsigned int ip_len, unsigned int tcp_off, unsigned int tcp_seq);
+void __hif_lib_xmit_pkt(struct hif_client_s *client, unsigned int qno, void *data, unsigned int len, u32 client_ctrl, unsigned int flags, void *client_data);
+int hif_lib_xmit_pkt(struct hif_client_s *client, unsigned int qno, void *data, unsigned int len, u32 client_ctrl, void *client_data);
+void hif_lib_indicate_client(int cl_id, int event, int data);
+int hif_lib_event_handler_start( struct hif_client_s *client, int event, int data );
+int hif_lib_tmu_queue_start( struct hif_client_s *client, int qno );
+int hif_lib_tmu_queue_stop( struct hif_client_s *client, int qno );
+void *hif_lib_tx_get_next_complete(struct hif_client_s *client, int qno, unsigned int *flags, int count);
+void *hif_lib_receive_pkt(struct hif_client_s *client, int qno, int *len, int *ofst, unsigned int *rx_ctrl, unsigned int *desc_ctrl, void **priv_data);
+void hif_lib_update_credit(struct hif_client_s *client, unsigned int qno);
+void __hif_lib_update_credit(struct hif_client_s *client, unsigned int queue);
+void hif_lib_set_rx_cpu_affinity(struct hif_client_s *client, int cpu_id);
+static inline int hif_lib_tx_avail(struct hif_client_s *client, unsigned int qno)
+{
+ struct hif_client_tx_queue *queue = &client->tx_q[qno];
+
+ return (queue->size - queue->tx_pending);
+}
+
+static inline int hif_lib_get_tx_wrIndex(struct hif_client_s *client, unsigned int qno)
+{
+ struct hif_client_tx_queue *queue = &client->tx_q[qno];
+
+ return queue->write_idx;
+}
+
+
+static inline int hif_lib_tx_pending(struct hif_client_s *client, unsigned int qno)
+{
+ struct hif_client_tx_queue *queue = &client->tx_q[qno];
+
+ return queue->tx_pending;
+}
+
+#define hif_lib_tx_credit_avail(pfe, id, qno) pfe->tmu_credit.tx_credit[id][qno]
+#define hif_lib_tx_credit_max(pfe, id, qno) pfe->tmu_credit.tx_credit_max[id][qno]
+#define hif_lib_tx_credit_use(pfe, id, qno, credit) do {if (tx_qos) {pfe->tmu_credit.tx_credit[id][qno]-= credit; pfe->tmu_credit.tx_packets[id][qno]+=credit;}} while (0)
+
+#endif /* _PFE_HIF_LIB_H_ */
diff --git a/pfe_ctrl/pfe_hw.c b/pfe_ctrl/pfe_hw.c
new file mode 100644
index 0000000..383ba14
--- /dev/null
+++ b/pfe_ctrl/pfe_hw.c
@@ -0,0 +1,153 @@
+#include "pfe_mod.h"
+#include "pfe_hw.h"
+
+/* Functions to handle most of pfe hw register initialization */
+
+int pfe_hw_init(struct pfe *pfe)
+{
+ CLASS_CFG class_cfg = {
+ .pe_sys_clk_ratio = PE_SYS_CLK_RATIO,
+ .route_table_baseaddr = pfe->ddr_phys_baseaddr + ROUTE_TABLE_BASEADDR,
+ .route_table_hash_bits = ROUTE_TABLE_HASH_BITS,
+ };
+
+ TMU_CFG tmu_cfg = {
+ .pe_sys_clk_ratio = PE_SYS_CLK_RATIO,
+ .llm_base_addr = pfe->ddr_phys_baseaddr + TMU_LLM_BASEADDR,
+ .llm_queue_len = TMU_LLM_QUEUE_LEN,
+ };
+
+#if !defined(CONFIG_UTIL_DISABLED)
+ UTIL_CFG util_cfg = {
+ .pe_sys_clk_ratio = PE_SYS_CLK_RATIO,
+ };
+#endif
+
+ BMU_CFG bmu1_cfg = {
+ .baseaddr = CBUS_VIRT_TO_PFE(LMEM_BASE_ADDR + BMU1_LMEM_BASEADDR),
+ .count = BMU1_BUF_COUNT,
+ .size = BMU1_BUF_SIZE,
+ };
+
+ BMU_CFG bmu2_cfg = {
+ .baseaddr = pfe->ddr_phys_baseaddr + BMU2_DDR_BASEADDR,
+ .count = BMU2_BUF_COUNT,
+ .size = BMU2_BUF_SIZE,
+ };
+
+ GPI_CFG egpi1_cfg = {
+ .lmem_rtry_cnt = EGPI1_LMEM_RTRY_CNT,
+ .tmlf_txthres = EGPI1_TMLF_TXTHRES,
+ .aseq_len = EGPI1_ASEQ_LEN,
+ };
+
+ GPI_CFG egpi2_cfg = {
+ .lmem_rtry_cnt = EGPI2_LMEM_RTRY_CNT,
+ .tmlf_txthres = EGPI2_TMLF_TXTHRES,
+ .aseq_len = EGPI2_ASEQ_LEN,
+ };
+
+ GPI_CFG egpi3_cfg = {
+ .lmem_rtry_cnt = EGPI3_LMEM_RTRY_CNT,
+ .tmlf_txthres = EGPI3_TMLF_TXTHRES,
+ .aseq_len = EGPI3_ASEQ_LEN,
+ };
+
+ GPI_CFG hgpi_cfg = {
+ .lmem_rtry_cnt = HGPI_LMEM_RTRY_CNT,
+ .tmlf_txthres = HGPI_TMLF_TXTHRES,
+ .aseq_len = HGPI_ASEQ_LEN,
+ };
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ if (lro_mode)
+ class_cfg.toe_mode = 1;
+
+ printk(KERN_INFO "CLASS version: %x\n", readl(CLASS_VERSION));
+ printk(KERN_INFO "TMU version: %x\n", readl(TMU_VERSION));
+
+ printk(KERN_INFO "BMU1 version: %x\n", readl(BMU1_BASE_ADDR + BMU_VERSION));
+ printk(KERN_INFO "BMU2 version: %x\n", readl(BMU2_BASE_ADDR + BMU_VERSION));
+
+ printk(KERN_INFO "EMAC1 network cfg: %x\n", readl(EMAC1_BASE_ADDR + EMAC_NETWORK_CONFIG));
+ printk(KERN_INFO "EMAC2 network cfg: %x\n", readl(EMAC2_BASE_ADDR + EMAC_NETWORK_CONFIG));
+#if !defined(CONFIG_PLATFORM_PCI)
+ printk(KERN_INFO "EMAC3 network cfg: %x\n", readl(EMAC3_BASE_ADDR + EMAC_NETWORK_CONFIG));
+#endif
+
+ printk(KERN_INFO "EGPI1 version: %x\n", readl(EGPI1_BASE_ADDR + GPI_VERSION));
+ printk(KERN_INFO "EGPI2 version: %x\n", readl(EGPI2_BASE_ADDR + GPI_VERSION));
+#if !defined(CONFIG_PLATFORM_PCI)
+ printk(KERN_INFO "EGPI3 version: %x\n", readl(EGPI3_BASE_ADDR + GPI_VERSION));
+#endif
+ printk(KERN_INFO "HGPI version: %x\n", readl(HGPI_BASE_ADDR + GPI_VERSION));
+
+#if !defined(CONFIG_PLATFORM_PCI)
+ printk(KERN_INFO "GPT version: %x\n", readl(CBUS_GPT_VERSION));
+#endif
+
+ printk(KERN_INFO "HIF version: %x\n", readl(HIF_VERSION));
+ printk(KERN_INFO "HIF NOPCY version: %x\n", readl(HIF_NOCPY_VERSION));
+
+#if !defined(CONFIG_UTIL_DISABLED)
+ printk(KERN_INFO "UTIL version: %x\n", readl(UTIL_VERSION));
+#endif
+
+ bmu_init(BMU1_BASE_ADDR, &bmu1_cfg);
+
+ printk(KERN_INFO "bmu_init(1) done\n");
+
+ bmu_init(BMU2_BASE_ADDR, &bmu2_cfg);
+
+ printk(KERN_INFO "bmu_init(2) done\n");
+
+ class_init(&class_cfg);
+
+ printk(KERN_INFO "class_init() done\n");
+
+ tmu_init(&tmu_cfg);
+
+ printk(KERN_INFO "tmu_init() done\n");
+#if !defined(CONFIG_UTIL_DISABLED)
+ util_init(&util_cfg);
+
+ printk(KERN_INFO "util_init() done\n");
+#endif
+ gpi_init(EGPI1_BASE_ADDR, &egpi1_cfg);
+
+ printk(KERN_INFO "gpi_init(1) done\n");
+
+ gpi_init(EGPI2_BASE_ADDR, &egpi2_cfg);
+
+ printk(KERN_INFO "gpi_init(2) done\n");
+#if !defined(CONFIG_PLATFORM_PCI)
+ gpi_init(EGPI3_BASE_ADDR, &egpi3_cfg);
+
+ printk(KERN_INFO "gpi_init(3) done\n");
+#endif
+ gpi_init(HGPI_BASE_ADDR, &hgpi_cfg);
+
+ printk(KERN_INFO "gpi_init(hif) done\n");
+
+ bmu_enable(BMU1_BASE_ADDR);
+
+ printk(KERN_INFO "bmu_enable(1) done\n");
+
+ bmu_enable(BMU2_BASE_ADDR);
+
+ printk(KERN_INFO "bmu_enable(2) done\n");
+
+ return 0;
+}
+
+void pfe_hw_exit(struct pfe *pfe)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+ bmu_disable(BMU1_BASE_ADDR);
+ bmu_reset(BMU1_BASE_ADDR);
+
+ bmu_disable(BMU2_BASE_ADDR);
+ bmu_reset(BMU2_BASE_ADDR);
+}
diff --git a/pfe_ctrl/pfe_hw.h b/pfe_ctrl/pfe_hw.h
new file mode 100644
index 0000000..9df71c1
--- /dev/null
+++ b/pfe_ctrl/pfe_hw.h
@@ -0,0 +1,13 @@
+#ifndef _PFE_HW_H_
+#define _PFE_HW_H_
+
+#if !defined(CONFIG_PLATFORM_PCI)
+#define PE_SYS_CLK_RATIO 1 /* SYS/AXI = 250MHz, HFE = 500MHz */
+#else
+#define PE_SYS_CLK_RATIO 0 /* SYS = 40MHz, HFE = 40MHz */
+#endif
+
+int pfe_hw_init(struct pfe *pfe);
+void pfe_hw_exit(struct pfe *pfe);
+
+#endif /* _PFE_HW_H_ */
diff --git a/pfe_ctrl/pfe_licence.sh b/pfe_ctrl/pfe_licence.sh
new file mode 100755
index 0000000..324482c
--- /dev/null
+++ b/pfe_ctrl/pfe_licence.sh
@@ -0,0 +1,83 @@
+#! /bin/sh
+
+if [ -z "$1" ]; then
+ echo "Invalid PFE directory path"
+ exit
+fi
+PFE_PATH=`pwd`/$1
+if [ ! -d "$PFE_PATH" ]; then
+ echo "PFE directory path does not exist : $PFE_PATH"
+ exit
+fi
+pfe_files=$(find ${PFE_PATH} -type f)
+#find ${PFE_PATH} -type f > pfe_files.log
+confidential_files_no=$(grep -nr "THIS FILE IS CONFIDENTIAL" ${PFE_PATH} | wc -l)
+authorized_files_no=$(grep -nr "AUTHORIZED USE IS GOVERNED BY CONFIDENTIALITY AND LICENSE AGREEMENTS WITH MINDSPEED TECHNOLOGIES, INC" ${PFE_PATH} | wc -l)
+unauthorized_files_no=$(grep -nr "UNAUTHORIZED COPIES AND USE ARE STRICTLY PROHIBITED AND MAY RESULT IN CRIMINAL AND/OR CIVIL PROSECUTION" ${PFE_PATH} | wc -l)
+copyright_files_no=$(grep -nr "Copyright" ${PFE_PATH} --exclude="licencse.txt" --exclude="license_full.txt" | wc -l)
+if [ -z "$confidential_files_no" -o -z "$authorized_files_no" -o -z "$unauthorized_files_no" -o -z "$copyright_files_no" ]; then
+ echo "Invalid pattern search. Please check it"
+ exit
+fi
+if [ $confidential_files_no -ne $authorized_files_no -o $confidential_files_no -ne $unauthorized_files_no -o $confidential_files_no -ne $copyright_files_no ]; then
+ echo "Removed text pattern not matched properly. $confidential_files_no: $authorized_files_no : $unauthorized_files_no : $copyright_files_no . Please check the patterns"
+ exit
+fi
+confidential_files=$(grep -nr "THIS FILE IS CONFIDENTIAL" ${PFE_PATH} | cut -d':' -f 1)
+#grep -nr "THIS FILE IS CONFIDENTIAL" ${PFE_PATH} | cut -d':' -f 1 > confidential_files.log
+#no_license_files=$(diff pfe_files_list pfe_conf_files_list --new-line-format="" --old-line-format="%L" --unchanged-line-format="")
+
+for pfe_file in $pfe_files ; do
+ matched=0
+ for conf_file in $confidential_files ; do
+ if [ $pfe_file = $conf_file ]; then
+ matched=1
+ break
+ fi
+ done
+ if [ $matched -eq 0 ]; then
+ no_license_files="$no_license_files $pfe_file"
+ fi
+done
+#echo $no_license_files > no_license_files.log
+DEBUG=""
+for conf_file in $confidential_files ; do
+ if [ `basename $conf_file` = "license.txt" -o `basename $conf_file` = "license_full.txt" ]; then
+ continue
+ fi
+ sed -i '/THIS FILE IS CONFIDENTIAL/,+4 {d}' $conf_file
+ copy_right_line_no=$(grep -nr "Copyright" $conf_file | cut -d':' -f 1)
+# echo "copy_right_line_no=$copy_right_line_no file $conf_file"
+ if [ -z "$copy_right_line_no" -o $copy_right_line_no -eq 0 ]; then
+ echo "Invalid copy right line number of file : $conf_file. Please check it"
+ exit
+ fi
+ if [ $copy_right_line_no -ge 4 ]; then
+ echo "copy right line present after line no 4 in file : $conf_file. Please check it"
+ exit
+ fi
+ $DEBUG head -n $copy_right_line_no $conf_file > ${conf_file}.tmp
+ file_ext=$(basename $conf_file | cut -d'.' -f 2)
+ if [ "$file_ext" = "Makefile" -o "$file_ext" = "makefile" -o "$file_ext" = "mk" ]; then
+ cat ${PFE_PATH}/license.txt | sed -r 's/\*/#/g' >>${conf_file}.tmp
+ else
+ cat ${PFE_PATH}/license.txt >>${conf_file}.tmp
+ fi
+ tail_line_no=`expr $copy_right_line_no + 1`
+# echo "conf_file=$conf_file tail_line_no=$tail_line_no"
+ $DEBUG tail -n +$tail_line_no $conf_file >>${conf_file}.tmp
+ $DEBUG mv ${conf_file}.tmp ${conf_file}
+done
+for no_license_file in $no_license_files ; do
+ if [ `basename $no_license_file` = "license.txt" -o `basename $no_license_file` = "license_full.txt" ]; then
+ continue
+ fi
+ file_ext=$(basename $no_license_file | cut -d'.' -f 2)
+ if [ "$file_ext" = "Makefile" -o "$file_ext" = "makefile" -o "$file_ext" = "mk" ]; then
+ cat ${PFE_PATH}/license_full.txt | sed -r 's/\/\*/#/g' | sed -r 's/\*\//#/g' | sed -r 's/\*/#/g' >${no_license_file}.tmp
+ else
+ cat ${PFE_PATH}/license_full.txt >${no_license_file}.tmp
+ fi
+ cat $no_license_file >>${no_license_file}.tmp
+ mv ${no_license_file}.tmp ${no_license_file}
+done
diff --git a/pfe_ctrl/pfe_mod.c b/pfe_ctrl/pfe_mod.c
new file mode 100644
index 0000000..2ffc879
--- /dev/null
+++ b/pfe_ctrl/pfe_mod.c
@@ -0,0 +1,177 @@
+#include <linux/dma-mapping.h>
+#include "pfe_mod.h"
+#include "version.h"
+
+struct pfe *pfe;
+
+#if defined(CONFIG_UNIT_TEST)
+extern void pfe_unit_test(struct pfe *pfe);
+#if defined(UNIT_TEST_HIF)
+void hif_unit_test(struct pfe *pfe);
+#endif
+#endif
+
+/**
+ * pfe_probe -
+ *
+ *
+ */
+int pfe_probe(struct pfe *pfe)
+{
+ int rc;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ printk(KERN_INFO "PFE Driver version:\n%s\nbuilt with pfe sources version: %s\n", PFE_CTRL_VERSION, PFE_VERSION);
+
+ if (DDR_MAX_SIZE > pfe->ddr_size) {
+ printk(KERN_ERR "%s: required DDR memory (%x) above platform ddr memory (%x)\n", __func__, DDR_MAX_SIZE, pfe->ddr_size);
+ rc = -ENOMEM;
+ goto err_hw;
+ }
+
+ if (((int) (pfe->ddr_phys_baseaddr + BMU2_DDR_BASEADDR) & (8*SZ_1M - 1)) != 0) {
+ printk(KERN_ERR "%s: BMU2 base address (0x%x) must be aligned on 8MB boundary\n", __func__, (int) pfe->ddr_phys_baseaddr + BMU2_DDR_BASEADDR);
+ rc = -ENOMEM;
+ goto err_hw;
+ }
+
+
+ printk(KERN_INFO "cbus_baseaddr: %lx, ddr_baseaddr: %lx, ddr_phys_baseaddr: %lx, ddr_size: %x\n",
+ (unsigned long)pfe->cbus_baseaddr, (unsigned long)pfe->ddr_baseaddr,
+ pfe->ddr_phys_baseaddr, pfe->ddr_size);
+
+ pfe_lib_init(pfe->cbus_baseaddr, pfe->ddr_baseaddr, pfe->ddr_phys_baseaddr, pfe->ddr_size);
+
+ rc = pfe_hw_init(pfe);
+ if (rc < 0)
+ goto err_hw;
+
+ rc = pfe_hif_lib_init(pfe);
+ if (rc < 0)
+ goto err_hif_lib;
+
+ rc = pfe_hif_init(pfe);
+ if (rc < 0)
+ goto err_hif;
+
+ rc = pfe_firmware_init(pfe);
+ if (rc < 0)
+ goto err_firmware;
+
+ rc = pfe_ctrl_init(pfe);
+ if (rc < 0)
+ goto err_ctrl;
+
+ rc = pfe_eth_init(pfe);
+ if (rc < 0)
+ goto err_eth;
+
+ rc = pfe_vwd_init(pfe);
+ if (rc < 0)
+ goto err_vwd;
+
+ rc = pfe_pcap_init(pfe);
+ if (rc < 0)
+ goto err_pcap;
+
+ rc = pfe_perfmon_init(pfe);
+ if(rc < 0)
+ goto err_perfmon;
+
+ rc = pfe_sysfs_init(pfe);
+ if(rc < 0)
+ goto err_sysfs;
+
+ rc = pfe_diags_init(pfe);
+ if(rc < 0)
+ goto err_diags;
+
+#if defined(CONFIG_COMCERTO_MSP)
+ rc = pfe_msp_sync_init(pfe);
+ if(rc < 0)
+ goto err_msp;
+#endif
+
+#if defined(CONFIG_UNIT_TEST)
+ pfe_unit_test(pfe);
+#endif
+
+ return 0;
+
+#if defined(CONFIG_COMCERTO_MSP)
+err_msp:
+ pfe_diags_exit(pfe);
+#endif
+
+err_diags:
+ pfe_sysfs_exit(pfe);
+
+err_sysfs:
+ pfe_perfmon_exit(pfe);
+
+err_perfmon:
+ pfe_pcap_exit(pfe);
+
+err_pcap:
+ pfe_vwd_exit(pfe);
+
+err_vwd:
+ pfe_eth_exit(pfe);
+
+err_eth:
+ pfe_ctrl_exit(pfe);
+
+err_ctrl:
+ pfe_firmware_exit(pfe);
+
+err_firmware:
+ pfe_hif_exit(pfe);
+
+err_hif:
+ pfe_hif_lib_exit(pfe);
+
+err_hif_lib:
+ pfe_hw_exit(pfe);
+
+err_hw:
+ return rc;
+}
+
+
+/**
+ * pfe_remove -
+ *
+ *
+ */
+int pfe_remove(struct pfe *pfe)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+#if defined(CONFIG_COMCERTO_MSP)
+ pfe_msp_sync_exit(pfe);
+#endif
+ pfe_diags_exit(pfe);
+
+ pfe_sysfs_exit(pfe);
+
+ pfe_perfmon_exit(pfe);
+
+ pfe_pcap_exit(pfe);
+
+ pfe_vwd_exit(pfe);
+
+ pfe_eth_exit(pfe);
+
+ pfe_ctrl_exit(pfe);
+
+ pfe_firmware_exit(pfe);
+
+ pfe_hif_exit(pfe);
+
+ pfe_hif_lib_exit(pfe);
+
+ pfe_hw_exit(pfe);
+
+ return 0;
+}
diff --git a/pfe_ctrl/pfe_mod.h b/pfe_ctrl/pfe_mod.h
new file mode 100644
index 0000000..f32c717
--- /dev/null
+++ b/pfe_ctrl/pfe_mod.h
@@ -0,0 +1,144 @@
+#ifndef _PFE_MOD_H_
+#define _PFE_MOD_H_
+
+#include <linux/device.h>
+#include <linux/elf.h>
+
+struct pfe;
+
+#include "pfe_hw.h"
+#include "pfe_firmware.h"
+#include "pfe_ctrl.h"
+#include "pfe_hif.h"
+#include "pfe_hif_lib.h"
+#include "pfe_eth.h"
+#include "pfe_vwd.h"
+#include "pfe_pcap.h"
+#include "pfe_sysfs.h"
+#include "pfe_mspsync.h"
+#include "pfe_diags.h"
+#include "pfe_perfmon.h"
+
+struct pfe_tmu_credit {
+ /* Number of allowed TX packet in-flight, matches TMU queue size */
+ unsigned int tx_credit[NUM_GEMAC_SUPPORT][EMAC_TXQ_CNT];
+ unsigned int tx_credit_max[NUM_GEMAC_SUPPORT][EMAC_TXQ_CNT];
+ unsigned int tx_packets[NUM_GEMAC_SUPPORT][EMAC_TXQ_CNT];
+};
+
+struct pfe {
+ unsigned long ddr_phys_baseaddr;
+ void *ddr_baseaddr;
+ unsigned int ddr_size;
+ void *cbus_baseaddr;
+ void *apb_baseaddr;
+ unsigned long iram_phys_baseaddr;
+ void *iram_baseaddr;
+ unsigned long ipsec_phys_baseaddr;
+ void *ipsec_baseaddr;
+ int hif_irq;
+ int hif_client_irq;
+ struct device *dev;
+ struct pfe_ctrl ctrl;
+ struct pfe_hif hif;
+ struct pfe_eth eth;
+ struct pfe_vwd_priv_s vwd;
+ struct hif_client_s *hif_client[HIF_CLIENTS_MAX];
+#if defined(FPP_DIAGNOSTICS)
+ struct pfe_diags diags;
+#endif
+ struct pfe_tmu_credit tmu_credit;
+ struct pcap_priv_s pcap;
+ struct pfe_cpumon cpumon;
+ struct pfe_memmon memmon;
+};
+
+extern struct pfe *pfe;
+
+int pfe_probe(struct pfe *pfe);
+int pfe_remove(struct pfe *pfe);
+
+#ifndef SZ_1K
+#define SZ_1K 1024
+#endif
+
+#ifndef SZ_1M
+#define SZ_1M (1024 * 1024)
+#endif
+
+/* DDR Mapping */
+#if !defined(CONFIG_PLATFORM_PCI)
+#define ROUTE_TABLE_BASEADDR 0
+#define ROUTE_TABLE_HASH_BITS 15 /**< 32K entries */
+#define ROUTE_TABLE_SIZE ((1 << ROUTE_TABLE_HASH_BITS) * CLASS_ROUTE_SIZE)
+#define BMU2_DDR_BASEADDR (ROUTE_TABLE_BASEADDR + ROUTE_TABLE_SIZE)
+#define BMU2_BUF_COUNT (4096 - 256) /**< This is to get a total DDR size of 12MiB */
+#define BMU2_DDR_SIZE (DDR_BUF_SIZE * BMU2_BUF_COUNT)
+#define UTIL_CODE_BASEADDR (BMU2_DDR_BASEADDR + BMU2_DDR_SIZE)
+#define UTIL_CODE_SIZE (128 * SZ_1K)
+#define UTIL_DDR_DATA_BASEADDR (UTIL_CODE_BASEADDR + UTIL_CODE_SIZE)
+#define UTIL_DDR_DATA_SIZE (64 * SZ_1K)
+#define CLASS_DDR_DATA_BASEADDR (UTIL_DDR_DATA_BASEADDR + UTIL_DDR_DATA_SIZE)
+#define CLASS_DDR_DATA_SIZE (32 * SZ_1K)
+#define TMU_DDR_DATA_BASEADDR (CLASS_DDR_DATA_BASEADDR + CLASS_DDR_DATA_SIZE)
+#define TMU_DDR_DATA_SIZE (32 * SZ_1K)
+#define TMU_LLM_BASEADDR (TMU_DDR_DATA_BASEADDR + TMU_DDR_DATA_SIZE)
+#define TMU_LLM_QUEUE_LEN (8 * 512) /**< Must be power of two and at least 16 * 8 = 128 bytes */
+#define TMU_LLM_SIZE (4 * 16 * TMU_LLM_QUEUE_LEN) /**< (4 TMU's x 16 queues x queue_len) */
+
+#define DDR_MAX_SIZE (TMU_LLM_BASEADDR + TMU_LLM_SIZE)
+
+#else
+
+#define UTIL_CODE_BASEADDR 0
+#if defined(CONFIG_UTIL_DISABLED)
+#define UTIL_CODE_SIZE (0 * SZ_1K)
+#else
+#define UTIL_CODE_SIZE (8 * SZ_1K)
+#endif
+#define UTIL_DDR_DATA_BASEADDR (UTIL_CODE_BASEADDR + UTIL_CODE_SIZE)
+#define UTIL_DDR_DATA_SIZE (0 * SZ_1K)
+#define CLASS_DDR_DATA_BASEADDR (UTIL_DDR_DATA_BASEADDR + UTIL_DDR_DATA_SIZE)
+#define CLASS_DDR_DATA_SIZE (0 * SZ_1K)
+#define TMU_DDR_DATA_BASEADDR (CLASS_DDR_DATA_BASEADDR + CLASS_DDR_DATA_SIZE)
+#define TMU_DDR_DATA_SIZE (0 * SZ_1K)
+#define ROUTE_TABLE_BASEADDR (TMU_DDR_DATA_BASEADDR + TMU_DDR_DATA_SIZE)
+#define ROUTE_TABLE_HASH_BITS 5 /**< 32 entries */
+#define ROUTE_TABLE_SIZE ((1 << ROUTE_TABLE_HASH_BITS) * CLASS_ROUTE_SIZE)
+#define BMU2_DDR_BASEADDR (ROUTE_TABLE_BASEADDR + ROUTE_TABLE_SIZE)
+#define BMU2_BUF_COUNT 16
+#define BMU2_DDR_SIZE (DDR_BUF_SIZE * BMU2_BUF_COUNT)
+#define TMU_LLM_BASEADDR (BMU2_DDR_BASEADDR + BMU2_DDR_SIZE)
+#define TMU_LLM_QUEUE_LEN (16 * 8) /**< Must be power of two and at least 16 * 8 = 128 bytes */
+#define TMU_LLM_SIZE (4 * 16 * TMU_LLM_QUEUE_LEN) /**< (4 TMU's x 16 queues x queue_len) */
+#define HIF_DESC_BASEADDR (TMU_LLM_BASEADDR + TMU_LLM_SIZE)
+#define HIF_RX_DESC_SIZE (16*HIF_RX_DESC_NT)
+#define HIF_TX_DESC_SIZE (16*HIF_TX_DESC_NT)
+#define HIF_DESC_SIZE (HIF_RX_DESC_SIZE + HIF_TX_DESC_SIZE)
+#define HIF_RX_PKT_DDR_BASEADDR (HIF_DESC_BASEADDR + HIF_DESC_SIZE)
+#define HIF_RX_PKT_DDR_SIZE (HIF_RX_DESC_NT * DDR_BUF_SIZE)
+#define HIF_TX_PKT_DDR_BASEADDR (HIF_RX_PKT_DDR_BASEADDR + HIF_RX_PKT_DDR_SIZE)
+#define HIF_TX_PKT_DDR_SIZE (HIF_TX_DESC_NT * DDR_BUF_SIZE)
+#define ROUTE_BASEADDR (HIF_TX_PKT_DDR_BASEADDR + HIF_TX_PKT_DDR_SIZE)
+#define ROUTE_SIZE (2 * CLASS_ROUTE_SIZE)
+
+#define DDR_MAX_SIZE (ROUTE_BASEADDR + ROUTE_SIZE)
+
+#define PFE_HOST_TO_PCI(addr) (((u32)addr)- ((u32)DDR_BASE_ADDR))
+#define PFE_PCI_TO_HOST(addr) (((u32)addr)+ ((u32)DDR_BASE_ADDR))
+#endif
+
+/* IRAM Mapping */
+#define IPSEC_IRAM_BASEADDR 0
+#define IPSEC_IRAM_SIZE 0x2000
+
+/* LMEM Mapping */
+#define BMU1_LMEM_BASEADDR 0
+#define BMU1_BUF_COUNT 256
+#define BMU1_LMEM_SIZE (LMEM_BUF_SIZE * BMU1_BUF_COUNT)
+#define IPSEC_LMEM_BASEADDR (BMU1_LMEM_BASEADDR + BMU1_LMEM_SIZE)
+#define IPSEC_LMEM_SIZE (30 * 1024)
+
+
+
+#endif /* _PFE_MOD_H */
diff --git a/pfe_ctrl/pfe_mspsync.c b/pfe_ctrl/pfe_mspsync.c
new file mode 100644
index 0000000..3e788ea
--- /dev/null
+++ b/pfe_ctrl/pfe_mspsync.c
@@ -0,0 +1,34 @@
+#ifdef __KERNEL__
+#include <linux/kernel.h>
+#include <linux/module.h>
+
+#else
+#include "platform.h"
+#endif
+
+
+#include "pfe_mod.h"
+
+int msp_register_pfe(struct pfe_info *pfe_sync_info);
+void msp_unregister_pfe(void);
+
+struct pfe_info pfe_sync_info;
+
+int pfe_msp_sync_init(struct pfe *pfe)
+{
+ pfe_sync_info.owner = THIS_MODULE;
+ pfe_sync_info.cbus_baseaddr = pfe->cbus_baseaddr;
+ pfe_sync_info.ddr_baseaddr = pfe->ddr_baseaddr;
+
+ if (msp_register_pfe(&pfe_sync_info)) {
+ printk(KERN_ERR "%s: Failed to register with msp\n",__func__);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+void pfe_msp_sync_exit(struct pfe *pfe)
+{
+ msp_unregister_pfe();
+}
diff --git a/pfe_ctrl/pfe_mspsync.h b/pfe_ctrl/pfe_mspsync.h
new file mode 100644
index 0000000..ef19df4
--- /dev/null
+++ b/pfe_ctrl/pfe_mspsync.h
@@ -0,0 +1,12 @@
+#ifndef _PFE_MSPSYNC_H_
+#define _PFE_MSPSYNC_H_
+
+struct pfe_info {
+ void *ddr_baseaddr;
+ void *cbus_baseaddr;
+ void *owner;
+};
+
+int pfe_msp_sync_init(struct pfe *pfe);
+void pfe_msp_sync_exit(struct pfe *pfe);
+#endif /* _PFE_MSPSYNC_H_ */
diff --git a/pfe_ctrl/pfe_pcap.c b/pfe_ctrl/pfe_pcap.c
new file mode 100644
index 0000000..f100366
--- /dev/null
+++ b/pfe_ctrl/pfe_pcap.c
@@ -0,0 +1,414 @@
+#include <linux/platform_device.h>
+#include <linux/kthread.h>
+#include "config.h"
+#include "pfe_mod.h"
+#include "pfe_pcap.h"
+#include "pfe_hif_lib.h"
+
+#ifdef CFG_PCAP
+
+/* PFE packet capture:
+ - uses HIF functions to receive packets
+ - uses ctrl function to control packet capture
+ */
+
+static ssize_t pcap_stats_get(struct device *, struct device_attribute *, char *);
+static ssize_t pcap_stats_clear(struct device *, struct device_attribute *, const char *, size_t );
+
+static int pcap_open(struct net_device *dev)
+{
+ printk(KERN_INFO "%s: %s\n", dev->name, __func__);
+ netif_stop_queue(dev);
+ return 0;
+}
+static int pcap_close(struct net_device *dev)
+{
+ printk(KERN_INFO "%s: %s\n", dev->name, __func__);
+ return 0;
+}
+
+static int pcap_hard_start_xmit(struct sk_buff *skb, struct net_device *dev )
+{
+ netif_stop_queue(dev);
+ printk(KERN_INFO "%s() Dropping pkt!!!\n",__func__);
+ kfree_skb(skb);
+ return NETDEV_TX_OK;
+}
+
+
+static DEVICE_ATTR(pcap_stats, 0644, pcap_stats_get, pcap_stats_clear);
+
+
+
+static int pcap_sysfs_init(struct device *dev)
+{
+ if (device_create_file(dev, &dev_attr_pcap_stats))
+ {
+ printk(KERN_ERR "Failed to create attr capture stats\n");
+ goto err_stats;
+ }
+
+ return 0;
+
+err_stats:
+ return -1;
+}
+
+/** pfe_pcap_sysfs_exit
+ *
+ */
+static void pcap_sysfs_exit(struct pfe* pfe)
+{
+ device_remove_file(pfe->dev, &dev_attr_pcap_stats);
+}
+
+static const struct net_device_ops pcap_netdev_ops = {
+ .ndo_open = pcap_open,
+ .ndo_stop = pcap_close,
+ .ndo_start_xmit = pcap_hard_start_xmit,
+};
+
+static struct net_device *pcap_register_capdev(char *dev_name)
+{
+ struct net_device *dev=NULL;
+
+ printk("%s:\n", __func__);
+
+ /* Create an ethernet device instance */
+ dev = (struct net_device *)alloc_etherdev(sizeof (int));
+ if (!dev) {
+ printk(KERN_ERR "%s: cap device allocation failed\n", __func__);
+ goto err0;
+ }
+
+ strcpy(dev->name, dev_name);
+ //dev->irq = priv->irq;
+
+ /* Fill in the dev structure */
+ dev->mtu = 1500;
+ dev->features = 0;
+ dev->netdev_ops = &pcap_netdev_ops;
+ /*TODO */
+ dev->dev_addr[0] = 0x0;
+ dev->dev_addr[1] = 0x21;
+ dev->dev_addr[2] = 0x32;
+ dev->dev_addr[3] = 0x43;
+ dev->dev_addr[4] = 0x54;
+ dev->dev_addr[5] = 0x65;
+
+ if(register_netdev(dev)) {
+ printk(KERN_ERR "%s: cannot register net device, aborting.\n", dev->name);
+ free_netdev(dev);
+ dev = NULL;
+ }
+
+err0:
+ return dev;
+}
+static void pcap_unregister_capdev(struct net_device *dev)
+{
+ unregister_netdev(dev);
+ free_netdev(dev);
+}
+
+static ssize_t pcap_stats_get(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct platform_device *pdev = to_platform_device(dev);
+ struct pfe* pfe = platform_get_drvdata(pdev);
+ struct pcap_priv_s *priv = &pfe->pcap;
+ int ii, len = 0;
+
+ //printk("rtc %d rtf %d\n", priv->rxQ.rxToCleanIndex,priv->rxQ.rxToFillIndex);
+ for (ii = 0; ii < NUM_GEMAC_SUPPORT; ii++)
+ len += sprintf(&buf[len], "GEMAC%d Rx pkts : %lu\n", ii, priv->stats[ii].rx_packets);
+
+ return len;
+}
+
+static ssize_t pcap_stats_clear(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct platform_device *pdev = to_platform_device(dev);
+ struct pfe* pfe = platform_get_drvdata(pdev);
+ struct pcap_priv_s *priv = &pfe->pcap;
+ int ii;
+
+ for (ii = 0; ii < NUM_GEMAC_SUPPORT; ii++)
+ priv->stats[ii].rx_packets = 0;
+ return count;
+}
+
+
+
+/** pfe_pcap_rx_poll
+ *
+ */
+static int pfe_pcap_rx_poll (struct napi_struct *napi, int budget)
+{
+ struct sk_buff *skb;
+ void *data_addr;
+ int length,offset;
+ unsigned int idx = 0, work_done=0, qno=0;
+ unsigned int desc_ctrl = 0,rx_ctrl;
+ struct hif_pcap_hdr *pcap_hdr;
+ u32 tstamp;
+ struct pcap_priv_s *priv = container_of(napi, struct pcap_priv_s, low_napi);
+
+
+ do{
+
+ data_addr = hif_lib_receive_pkt(&priv->client, qno, &length, &offset, &rx_ctrl, &desc_ctrl, (void **)&pcap_hdr);
+ if (!data_addr)
+ break;
+
+ idx = pcap_hdr->ifindex;
+
+ //printk("%s: data:%x len:%d idx:%d \n", __func__, (u32)data_addr, length, idx);
+
+ if(idx < NUM_GEMAC_SUPPORT && priv->dev[idx]) {
+ struct net_device *dev = priv->dev[idx];
+ if(length > 1514) {
+ printk(KERN_ERR "Dropping big packet\n");
+ goto pkt_drop;
+ }
+ skb = alloc_skb_header(PFE_BUF_SIZE, data_addr, GFP_ATOMIC);
+
+ if (unlikely(!skb)) {
+ printk(KERN_ERR "Failed to allocate skb header\n");
+ goto pkt_drop;
+ }
+
+ skb_reserve(skb, offset);
+ skb_put(skb, length);
+ skb->protocol = eth_type_trans(skb, dev);
+ tstamp = ntohl(pcap_hdr->timestamp);
+ skb->tstamp = ktime_set( tstamp/USEC_PER_SEC, (tstamp%USEC_PER_SEC)*1000 );
+
+ /* Send packet to PF_PACKET socket queue */
+ capture_receive_skb(skb);
+
+ priv->stats[idx].rx_packets++;
+ priv->stats[idx].rx_bytes += length;
+ //dev->last_rx = jiffies;
+ work_done++;
+ }
+ else
+ {
+pkt_drop:
+ printk(KERN_ERR "Received with wrong dev\n");
+ pfe_kfree(data_addr);
+ }
+
+ }while(work_done < budget);
+
+ if (work_done < budget) {
+ napi_complete(napi);
+
+ hif_lib_event_handler_start(&priv->client, EVENT_RX_PKT_IND, qno);
+ }
+ return (work_done);
+
+}
+
+
+
+
+
+static int pfe_pcap_event_handler(void *data, int event, int qno)
+{
+ struct pcap_priv_s *priv = data;
+
+
+ switch (event) {
+ case EVENT_RX_PKT_IND:
+ /* qno is always 0 */
+ if (qno == 0) {
+ if (napi_schedule_prep(&priv->low_napi)) {
+ //printk(KERN_INFO "%s: schedule high prio poll\n", __func__);
+
+ __napi_schedule(&priv->low_napi);
+ }
+ }
+
+ break;
+
+ case EVENT_TXDONE_IND:
+ case EVENT_HIGH_RX_WM:
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+
+int pfe_pcap_up( struct pcap_priv_s *priv)
+{
+ struct hif_client_s *client;
+ int err = 0,rc, ii;
+
+ char ifname[IFNAMSIZ];
+
+ printk(KERN_INFO "%s\n", __func__);
+
+
+ priv->pfe = pfe;
+
+ for (ii = 0; ii < NUM_GEMAC_SUPPORT; ii++)
+ {
+ snprintf(ifname, IFNAMSIZ, "cap_gemac%d", ii);
+ priv->dev[ii] = pcap_register_capdev(ifname);
+
+ if(priv->dev[ii]==NULL) {
+ printk(KERN_ERR "%s: Failed to register capture device\n",__func__);
+ err = -EAGAIN;
+ goto err0;
+ }
+ }
+
+ if (pcap_sysfs_init(pfe->dev) < 0 )
+ {
+ printk(KERN_ERR "%s: Failed to register to sysfs\n",__func__);
+ err = -EAGAIN;
+ goto err0;
+ }
+
+ /* Register pktcap client driver to HIF */
+ client = &priv->client;
+ memset(client, 0, sizeof(*client));
+ client->id = PFE_CL_PCAP0;
+ client->tx_qn = PCAP_TXQ_CNT;
+ client->rx_qn = PCAP_RXQ_CNT;
+ client->priv = priv;
+ client->pfe = priv->pfe;
+ client->event_handler = pfe_pcap_event_handler;
+
+ /* FIXME : For now hif lib sets all tx and rx queues to same size */
+ client->tx_qsize = PCAP_TXQ_DEPTH;
+ client->rx_qsize = PCAP_RXQ_DEPTH;
+
+ printk(KERN_INFO "%s Registering client \n", __func__);
+ if ((rc = hif_lib_client_register(client))) {
+ printk(KERN_ERR"%s: hif_lib_client_register(%d) failed\n", __func__, client->id);
+ goto err1;
+ }
+
+ printk(KERN_INFO "%s Enable PCAP in pfe \n", __func__);
+ /* Enable Packet capture in PFE */
+ if ((rc = pfe_ctrl_set_pcap(1)) != 0)
+ {
+ printk("%s: Failed to send command(enable) to pfe\n",__func__);
+ err = -EAGAIN;
+ goto err2;
+ }
+
+ printk(KERN_INFO "%s Enable PCAP ratelimit in pfe \n", __func__);
+ /* Set the default values for the configurable parameters*/
+ priv->rate_limit = COMCERTO_CAP_DFL_RATELIMIT;
+ priv->pkts_per_msec = priv->rate_limit/1000;
+
+ if ((rc = pfe_ctrl_set_pcap_ratelimit(priv->pkts_per_msec)) != 0)
+ {
+ printk("%s: Failed to send ratelimit command to pfe\n",__func__);
+ err = -EAGAIN;
+ goto err2;
+ }
+
+
+
+ return 0;
+
+err2:
+ hif_lib_client_unregister(client);
+err1:
+ pcap_sysfs_exit(pfe);
+err0:
+ for (ii = 0; ii < NUM_GEMAC_SUPPORT; ii++)
+ if(priv->dev[ii])
+ pcap_unregister_capdev(priv->dev[ii]);
+
+ return err;
+
+}
+
+static int pfe_pcap_down(struct pcap_priv_s* priv)
+{
+ struct hif_client_s *client = &priv->client;
+ int ii;
+
+ printk("%s()\n", __func__);
+
+ /* Disable Packet capture module in PFE */
+ if(pfe_ctrl_set_pcap(0)!= 0)
+ printk(KERN_ERR "%s: Failed while sending command CMD_PKTCAP_ENABLE\n", __func__ );
+ hif_lib_client_unregister(client);
+ pcap_sysfs_exit(pfe);
+
+ for (ii = 0; ii < NUM_GEMAC_SUPPORT; ii++)
+ if(priv->dev[ii])
+ pcap_unregister_capdev(priv->dev[ii]);
+
+ return 0;
+
+}
+
+static int pcap_driver_init(struct pfe* pfe)
+{
+ struct pcap_priv_s *priv = &pfe->pcap;
+ int err;
+
+ /* Initilize NAPI for Rx processing */
+ init_dummy_netdev(&priv->dummy_dev);
+ netif_napi_add(&priv->dummy_dev, &priv->low_napi, pfe_pcap_rx_poll, PCAP_RX_POLL_WEIGHT);
+ napi_enable(&priv->low_napi);
+
+ priv->pfe = pfe;
+
+ err = pfe_pcap_up(priv);
+
+ if (err < 0)
+ napi_disable(&priv->low_napi);
+
+ return err;
+}
+
+int pfe_pcap_init(struct pfe *pfe)
+{
+ int rc ;
+ printk(KERN_INFO "%s\n",__func__);
+
+ rc = pcap_driver_init(pfe);
+ if(rc) goto err0;
+ return 0;
+err0:
+ return rc;
+}
+
+void pfe_pcap_exit(struct pfe *pfe)
+{
+ struct pcap_priv_s *priv = &pfe->pcap;
+
+ printk(KERN_INFO "%s\n", __func__);
+ pfe_pcap_down(priv);
+
+}
+
+#else /* !CFG_PCAP */
+
+int pfe_pcap_init(struct pfe *pfe)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+ return 0;
+}
+
+void pfe_pcap_exit(struct pfe *pfe)
+{
+ printk(KERN_INFO "%s\n", __func__);
+}
+
+#endif /* !CFG_PCAP */
+
diff --git a/pfe_ctrl/pfe_pcap.h b/pfe_ctrl/pfe_pcap.h
new file mode 100644
index 0000000..54553b5
--- /dev/null
+++ b/pfe_ctrl/pfe_pcap.h
@@ -0,0 +1,40 @@
+#ifndef _PFE_PCAP_H_
+#define _PFE_PCAP_H_
+
+
+
+#define COMCERTO_CAP_RX_DESC_NT (1024)
+#define COMCERTO_CAP_DFL_RATELIMIT 10000 //pps
+#define COMCERTO_CAP_MIN_RATELIMIT 1000 //pps
+#define COMCERTO_CAP_MAX_RATELIMIT 800000 //pps
+#define COMCERTO_CAP_DFL_BUDGET 32 //packets processed in tasklet
+#define COMCERTO_CAP_MAX_BUDGET 64
+#define COMCERTO_CAP_POLL_MS 100
+
+int pfe_pcap_init(struct pfe *pfe);
+void pfe_pcap_exit(struct pfe *pfe);
+
+#define PCAP_RXQ_CNT 1
+#define PCAP_TXQ_CNT 1
+
+#define PCAP_RXQ_DEPTH 1024
+#define PCAP_TXQ_DEPTH 1
+
+#define PCAP_RX_POLL_WEIGHT (HIF_RX_POLL_WEIGHT - 16)
+
+
+typedef struct pcap_priv_s {
+ struct pfe* pfe;
+ unsigned char name[12];
+
+ struct net_device_stats stats[NUM_GEMAC_SUPPORT];
+ struct net_device *dev[NUM_GEMAC_SUPPORT];
+ struct hif_client_s client;
+ u32 rate_limit;
+ u32 pkts_per_msec;
+ struct net_device dummy_dev;
+ struct napi_struct low_napi;
+}pcap_priv_t;
+
+
+#endif /* _PFE_PCAP_H_ */
diff --git a/pfe_ctrl/pfe_pci.c b/pfe_ctrl/pfe_pci.c
new file mode 100644
index 0000000..0bab3da
--- /dev/null
+++ b/pfe_ctrl/pfe_pci.c
@@ -0,0 +1,199 @@
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/pci.h>
+#include <linux/vmalloc.h>
+
+
+#include "pfe_mod.h"
+
+#if 0
+static struct pci_device_id pfe_pci_tbl[] =
+{
+ { 0x0700, 0x1108, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+ { 0 },
+};
+#else
+static struct pci_device_id pfe_pci_tbl[] =
+{
+ { 0x0700, 0x1107, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+ { 0 },
+};
+#endif
+
+
+static int __devinit pfe_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+ int rc;
+ unsigned long mem_start, mem_end, mem_len;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ pfe = kzalloc(sizeof(struct pfe), GFP_KERNEL);
+ if (!pfe) {
+ rc = -ENOMEM;
+ goto err_alloc;
+ }
+
+ pci_set_drvdata(pdev, pfe);
+
+ rc = pci_enable_device(pdev);
+ if (rc < 0)
+ {
+ printk(KERN_INFO "pci_enable_device() failed\n");
+ goto err_pci_enable;
+ }
+
+ printk(KERN_INFO "PCI device enabled\n");
+
+ mem_start = pci_resource_start(pdev, 0);
+ mem_end = pci_resource_end(pdev, 0);
+ mem_len = pci_resource_len(pdev, 0);
+
+ printk(KERN_INFO "PCI resource 0 %#lx:%#lx (%lx)\n", mem_start, mem_end, mem_len);
+
+#if 0
+ if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM))
+ {
+ printk("\n cann't read PCI resource flags");
+ goto err_out_disable_pdev;
+ }
+
+ printk("\n PCI resource flags read as MEM mapped");
+
+
+ io_start = pci_resource_start(pdev, 1);
+ printk("\n PCI resource start address:%x ",io_start);
+ io_end = pci_resource_end(pdev, 1);
+ printk("\n PCI resource end address:%x ",io_end);
+ io_len = pci_resource_len(pdev, 1);
+ printk("\n PCI resource end address:%x ",io_len);
+
+ if (!(pci_resource_flags(pdev, 1) & IORESOURCE_IO))
+ {
+ printk("\n cann't read PCI resource flags");
+ goto err_out_disable_pdev;
+ }
+
+ printk("\n PCI resource flags read as IO mapped");
+#endif
+ if ((rc = pci_request_regions(pdev, "pfe-pci"))) {
+ printk(KERN_INFO "pci_request_regions() failed\n");
+ goto err_pci_request;
+ }
+#if 0
+ printk("\n PCI acquired regions");
+ if ((rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK))){
+ printk("\n No usable DMA configuration");
+ goto err_out_free_res;
+ }
+
+ printk("using i/o access mode\n");
+#endif
+ pfe->cbus_baseaddr = ioremap(mem_start, mem_len);
+ if (!pfe->cbus_baseaddr) {
+ printk(KERN_INFO "ioremap() cbus failed\n");
+ rc = -ENOMEM;
+ goto err_cbus;
+ }
+
+ pfe->ddr_baseaddr = pfe->cbus_baseaddr + 8 * SZ_1M;
+ pfe->ddr_phys_baseaddr = 0x20000; /* This is the physical address seen by the FPGA ... */
+ pfe->ddr_size = 0x10000;
+
+ pfe->apb_baseaddr = vmalloc(16 * SZ_1M);
+ if (!pfe->apb_baseaddr) {
+ printk(KERN_INFO "vmalloc() apb failed\n");
+ rc = -ENOMEM;
+ goto err_apb;
+ }
+
+ pfe->iram_baseaddr = vmalloc(128 * SZ_1K);
+ if (!pfe->iram_baseaddr) {
+ printk(KERN_INFO "vmalloc() iram failed\n");
+ rc = -ENOMEM;
+ goto err_iram;
+ }
+
+ pfe->hif_irq = pdev->irq;
+ pfe->dev = &pdev->dev;
+
+ pfe->ctrl.sys_clk = 40000;
+
+ rc = pfe_probe(pfe);
+ if (rc < 0)
+ goto err_probe;
+
+ return 0;
+
+err_probe:
+ vfree(pfe->iram_baseaddr);
+
+err_iram:
+ vfree(pfe->apb_baseaddr);
+
+err_apb:
+ iounmap(pfe->cbus_baseaddr);
+
+err_cbus:
+ pci_release_regions(pdev);
+
+err_pci_request:
+ pci_disable_device(pdev);
+
+err_pci_enable:
+
+ pci_set_drvdata(pdev, NULL);
+
+ kfree(pfe);
+
+err_alloc:
+ return rc;
+}
+
+
+static void __devexit pfe_pci_remove (struct pci_dev *pdev)
+{
+ struct pfe *pfe = pci_get_drvdata(pdev);
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ pfe_remove(pfe);
+
+ vfree(pfe->iram_baseaddr);
+ vfree(pfe->apb_baseaddr);
+
+ iounmap(pfe->cbus_baseaddr);
+
+ pci_release_regions(pdev);
+ pci_disable_device(pdev);
+ pci_set_drvdata(pdev, NULL);
+
+ kfree(pfe);
+}
+
+
+static struct pci_driver pfe_pci_driver = {
+ .name = "pfe-pci",
+ .id_table = pfe_pci_tbl,
+ .probe = pfe_pci_probe,
+ .remove = __devexit_p(pfe_pci_remove),
+};
+
+
+static int __init pfe_module_init(void)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+ return pci_register_driver(&pfe_pci_driver);
+}
+
+static void __exit pfe_module_exit(void)
+{
+ pci_unregister_driver(&pfe_pci_driver);
+
+ printk(KERN_INFO "%s\n", __func__);
+}
+
+MODULE_LICENSE("GPL");
+module_init(pfe_module_init);
+module_exit(pfe_module_exit);
diff --git a/pfe_ctrl/pfe_perfmon.c b/pfe_ctrl/pfe_perfmon.c
new file mode 100644
index 0000000..50c0bce
--- /dev/null
+++ b/pfe_ctrl/pfe_perfmon.c
@@ -0,0 +1,151 @@
+/* PFE performance monitoring functions */
+
+#include "pfe_ctrl_hal.h"
+#include "pfe_perfmon.h"
+
+static TIMER_ENTRY cpumon_timer;
+
+u32 CLASS_DMEM_SH2(cpu_ticks[2]);
+u32 TMU_DMEM_SH2(cpu_ticks[2]);
+u32 UTIL_DMEM_SH2(cpu_ticks[2]);
+
+#define compute_active_pct(total_ticks, active_ticks) ((active_ticks * 100 + (total_ticks >> 1)) / total_ticks)
+
+static void cpumon_timer_handler(void)
+{
+ int id;
+ u32 dmem_addr;
+ u32 ticks[2];
+ u32 total, active;
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+ struct pfe_cpumon *cpumon = &pfe->cpumon;
+
+ // Process class PE's
+ total = active = 0;
+ dmem_addr = virt_to_class_dmem(&class_cpu_ticks[0]);
+ for (id = CLASS0_ID; id <= CLASS_MAX_ID; id++)
+ {
+ cpumon->cpu_usage_pct[id] = 0;
+ if (pe_sync_stop(ctrl, (1 << id)) < 0)
+ continue;
+ ticks[0] = be32_to_cpu(pe_dmem_read(id, dmem_addr, 4));
+ ticks[1] = be32_to_cpu(pe_dmem_read(id, dmem_addr + 4, 4));
+ pe_dmem_write(id, 0, dmem_addr, 4);
+ pe_dmem_write(id, 0, dmem_addr + 4, 4);
+ pe_start(ctrl, (1 << id));
+ ticks[0] >>= 8; // divide both values by 256, so multiply by 100 won't overflow
+ ticks[1] >>= 8;
+ total += ticks[0];
+ active += ticks[1];
+ if (ticks[0] != 0)
+ cpumon->cpu_usage_pct[id] = compute_active_pct(ticks[0], ticks[1]);
+ }
+ if (total != 0)
+ cpumon->class_usage_pct = compute_active_pct(total, active);
+ else
+ cpumon->class_usage_pct = 0;
+
+ // Process TMU PE's
+ total = active = 0;
+ dmem_addr = virt_to_tmu_dmem(&tmu_cpu_ticks[0]);
+ for (id = TMU0_ID; id <= TMU_MAX_ID; id++)
+ {
+ cpumon->cpu_usage_pct[id] = 0;
+ if (pe_sync_stop(ctrl, (1 << id)) < 0)
+ continue;
+ ticks[0] = be32_to_cpu(pe_dmem_read(id, dmem_addr, 4));
+ ticks[1] = be32_to_cpu(pe_dmem_read(id, dmem_addr + 4, 4));
+ pe_dmem_write(id, 0, dmem_addr, 4);
+ pe_dmem_write(id, 0, dmem_addr + 4, 4);
+ pe_start(ctrl, (1 << id));
+ if (id == TMU0_ID) { int x=0; if (++x == 10){x=0; printk("total=%x, active=%x\n",ticks[0],ticks[1]);}} //zzz
+ ticks[0] >>= 8; // divide both values by 256, so multiply by 100 won't overflow
+ ticks[1] >>= 8;
+ if (ticks[0] != 0)
+ cpumon->cpu_usage_pct[id] = compute_active_pct(ticks[0], ticks[1]);
+ }
+
+ // Process Util PE
+ dmem_addr = virt_to_util_dmem(&util_cpu_ticks[0]);
+ cpumon->cpu_usage_pct[UTIL_ID] = 0;
+ if (pe_sync_stop(ctrl, (1 << UTIL_ID)) < 0)
+ return;
+ ticks[0] = be32_to_cpu(pe_dmem_read(UTIL_ID, dmem_addr, 4));
+ ticks[1] = be32_to_cpu(pe_dmem_read(UTIL_ID, dmem_addr + 4, 4));
+ pe_dmem_write(UTIL_ID, 0, dmem_addr, 4);
+ pe_dmem_write(UTIL_ID, 0, dmem_addr + 4, 4);
+ pe_start(ctrl, (1 << UTIL_ID));
+ ticks[0] >>= 8; // divide both values by 256, so multiply by 100 won't overflow
+ ticks[1] >>= 8;
+ if (ticks[0] != 0)
+ cpumon->cpu_usage_pct[UTIL_ID] = compute_active_pct(ticks[0], ticks[1]);
+}
+
+static int pfe_cpumon_init(struct pfe *pfe)
+{
+ timer_init(&cpumon_timer, cpumon_timer_handler);
+ timer_add(&cpumon_timer, CT_CPUMON_INTERVAL);
+ return 0;
+}
+
+static void pfe_cpumon_exit(struct pfe *pfe)
+{
+ timer_del(&cpumon_timer);
+}
+
+
+/*********************************************************************************/
+
+// Memory monitor functions
+
+void * pfe_kmalloc(size_t size, int flags)
+{
+ struct pfe_memmon *memmon = &pfe->memmon;
+ void *ptr;
+ ptr = kmalloc(size, flags);
+ if (ptr)
+ memmon->kernel_memory_allocated += ksize(ptr);
+ return ptr;
+}
+
+void * pfe_kzalloc(size_t size, int flags)
+{
+ struct pfe_memmon *memmon = &pfe->memmon;
+ void *ptr;
+ ptr = kzalloc(size, flags);
+ if (ptr)
+ memmon->kernel_memory_allocated += ksize(ptr);
+ return ptr;
+}
+
+void pfe_kfree(void *ptr)
+{
+ struct pfe_memmon *memmon = &pfe->memmon;
+ memmon->kernel_memory_allocated -= ksize(ptr);
+ kfree(ptr);
+}
+
+static int pfe_memmon_init(struct pfe *pfe)
+{
+ return 0;
+}
+
+static void pfe_memmon_exit(struct pfe *pfe)
+{
+}
+
+/*********************************************************************************/
+
+
+int pfe_perfmon_init(struct pfe *pfe)
+{
+ pfe_cpumon_init(pfe);
+ pfe_memmon_init(pfe);
+ return 0;
+}
+
+void pfe_perfmon_exit(struct pfe *pfe)
+{
+ pfe_cpumon_exit(pfe);
+ pfe_memmon_exit(pfe);
+}
diff --git a/pfe_ctrl/pfe_perfmon.h b/pfe_ctrl/pfe_perfmon.h
new file mode 100644
index 0000000..12240bd
--- /dev/null
+++ b/pfe_ctrl/pfe_perfmon.h
@@ -0,0 +1,22 @@
+#ifndef _PFE_PERFMON_H_
+#define _PFE_PERFMON_H_
+
+#define CT_CPUMON_INTERVAL (1 * TIMER_TICKS_PER_SEC)
+
+struct pfe_cpumon {
+ u32 cpu_usage_pct[MAX_PE];
+ u32 class_usage_pct;
+};
+
+struct pfe_memmon {
+ u32 kernel_memory_allocated;
+};
+
+void * pfe_kmalloc(size_t size, int flags);
+void * pfe_kzalloc(size_t size, int flags);
+void pfe_kfree(void *ptr);
+
+int pfe_perfmon_init(struct pfe *pfe);
+void pfe_perfmon_exit(struct pfe *pfe);
+
+#endif /* _PFE_PERFMON_H_ */
diff --git a/pfe_ctrl/pfe_platform.c b/pfe_ctrl/pfe_platform.c
new file mode 100644
index 0000000..ee5361f
--- /dev/null
+++ b/pfe_ctrl/pfe_platform.c
@@ -0,0 +1,233 @@
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/clk.h>
+
+#include "pfe_mod.h"
+
+/**
+ * pfe_platform_probe -
+ *
+ *
+ */
+static int pfe_platform_probe(struct platform_device *pdev)
+{
+ struct resource *r;
+ int rc;
+ struct clk *clk_axi;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ pfe = kzalloc(sizeof(struct pfe), GFP_KERNEL);
+ if (!pfe) {
+ rc = -ENOMEM;
+ goto err_alloc;
+ }
+
+ platform_set_drvdata(pdev, pfe);
+
+ r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ddr");
+ if (!r) {
+ printk(KERN_INFO "platform_get_resource_byname(ddr) failed\n");
+ rc = -ENXIO;
+ goto err_ddr;
+ }
+
+ pfe->ddr_phys_baseaddr = r->start;
+ pfe->ddr_size = resource_size(r);
+
+ pfe->ddr_baseaddr = ioremap(r->start, resource_size(r));
+ if (!pfe->ddr_baseaddr) {
+ printk(KERN_INFO "ioremap() ddr failed\n");
+ rc = -ENOMEM;
+ goto err_ddr;
+ }
+
+ r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "axi");
+ if (!r) {
+ printk(KERN_INFO "platform_get_resource_byname(axi) failed\n");
+ rc = -ENXIO;
+ goto err_axi;
+ }
+
+ pfe->cbus_baseaddr = ioremap(r->start, resource_size(r));
+ if (!pfe->cbus_baseaddr) {
+ printk(KERN_INFO "ioremap() axi failed\n");
+ rc = -ENOMEM;
+ goto err_axi;
+ }
+
+ r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "apb");
+ if (!r) {
+ printk(KERN_INFO "platform_get_resource_byname(apb) failed\n");
+ rc = -ENXIO;
+ goto err_apb;
+ }
+
+ pfe->apb_baseaddr = ioremap(r->start, resource_size(r));
+ if (!pfe->apb_baseaddr) {
+ printk(KERN_INFO "ioremap() apb failed\n");
+ rc = -ENOMEM;
+ goto err_apb;
+ }
+
+ r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "iram");
+ if (!r) {
+ printk(KERN_INFO "platform_get_resource_byname(iram) failed\n");
+ rc = -ENXIO;
+ goto err_iram;
+ }
+
+ pfe->iram_phys_baseaddr = r->start;
+ pfe->iram_baseaddr = ioremap(r->start, resource_size(r));
+ if (!pfe->iram_baseaddr) {
+ printk(KERN_INFO "ioremap() iram failed\n");
+ rc = -ENOMEM;
+ goto err_iram;
+ }
+
+ r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ipsec");
+ if (!r) {
+ printk(KERN_INFO "platform_get_resource_byname(ipsec) failed\n");
+ rc = -ENXIO;
+ goto err_ipsec;
+ }
+
+ pfe->ipsec_phys_baseaddr = r->start;
+ /* Just map only initial 1MB , as its enough to access espah engine
+ */
+ //pfe->ipsec_baseaddr = ioremap(r->start, resource_size(r));
+ pfe->ipsec_baseaddr = ioremap(r->start, 1*1024*1024);
+ if (!pfe->ipsec_baseaddr) {
+ printk(KERN_INFO "ioremap() ipsec failed\n");
+ rc = -ENOMEM;
+ goto err_ipsec;
+ }
+
+ printk(KERN_INFO "ipsec: baseaddr :%x --- %x\n", (u32)pfe->ipsec_phys_baseaddr, (u32)pfe->ipsec_baseaddr);
+
+ pfe->hif_irq = platform_get_irq_byname(pdev, "hif");
+ if (pfe->hif_irq < 0) {
+ printk(KERN_INFO "platform_get_irq_byname(hif) failed\n");
+ rc = pfe->hif_irq;
+ goto err_hif_irq;
+ }
+
+#if 0
+ pfe->hif_client_irq = platform_get_irq_byname(pdev, "hif_client");
+ if (pfe->hif_client_irq < 0) {
+ printk(KERN_INFO "platform_get_irq_byname(hif_client) failed\n");
+ rc = pfe->hif_client_irq;
+ goto err_hif_irq;
+ }
+#endif
+
+ pfe->dev = &pdev->dev;
+
+ /* FIXME this needs to be done at the BSP level with proper locking */
+ writel(readl(AXI_RESET_1) | (1 << 3), AXI_RESET_1);
+ mdelay(1);
+ writel(readl(AXI_RESET_1) & ~(1 << 3), AXI_RESET_1);
+
+ /* Get the system clock */
+ clk_axi = clk_get(NULL,"axi");
+ if (IS_ERR(clk_axi)) {
+ printk(KERN_INFO "clk_get call failed\n");
+ rc = -ENXIO;
+ goto err_clk;
+ }
+ pfe->ctrl.clk_axi = clk_axi;
+ pfe->ctrl.sys_clk = clk_get_rate(clk_axi) / 1000; // save sys_clk value as KHz
+
+ rc = pfe_probe(pfe);
+ if (rc < 0)
+ goto err_probe;
+
+ return 0;
+
+err_probe:
+ clk_put(clk_axi);
+
+err_clk:
+err_hif_irq:
+ iounmap(pfe->ipsec_baseaddr);
+err_ipsec:
+ iounmap(pfe->iram_baseaddr);
+err_iram:
+ iounmap(pfe->apb_baseaddr);
+
+err_apb:
+ iounmap(pfe->cbus_baseaddr);
+
+err_axi:
+ iounmap(pfe->ddr_baseaddr);
+
+err_ddr:
+ platform_set_drvdata(pdev, NULL);
+
+ kfree(pfe);
+
+err_alloc:
+ return rc;
+}
+
+
+/**
+ * pfe_platform_remove -
+ *
+ *
+ */
+static int pfe_platform_remove(struct platform_device *pdev)
+{
+ struct pfe *pfe = platform_get_drvdata(pdev);
+ int rc;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ rc = pfe_remove(pfe);
+
+ /* FIXME this needs to be done at the BSP level with proper locking */
+ writel(readl(AXI_RESET_1) | (1 << 3), AXI_RESET_1);
+
+ clk_put(pfe->ctrl.clk_axi);
+ iounmap(pfe->ipsec_baseaddr);
+ iounmap(pfe->iram_baseaddr);
+ iounmap(pfe->apb_baseaddr);
+ iounmap(pfe->cbus_baseaddr);
+ iounmap(pfe->ddr_baseaddr);
+
+ platform_set_drvdata(pdev, NULL);
+
+ kfree(pfe);
+
+ return rc;
+}
+
+
+static struct platform_driver pfe_platform_driver = {
+ .probe = pfe_platform_probe,
+ .remove = pfe_platform_remove,
+ .driver = {
+ .name = "pfe",
+ },
+};
+
+
+static int __init pfe_module_init(void)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+ return platform_driver_register(&pfe_platform_driver);
+}
+
+
+static void __exit pfe_module_exit(void)
+{
+ platform_driver_unregister(&pfe_platform_driver);
+
+ printk(KERN_INFO "%s\n", __func__);
+}
+
+MODULE_LICENSE("GPL");
+module_init(pfe_module_init);
+module_exit(pfe_module_exit);
diff --git a/pfe_ctrl/pfe_sysfs.c b/pfe_ctrl/pfe_sysfs.c
new file mode 100644
index 0000000..2c3018e
--- /dev/null
+++ b/pfe_ctrl/pfe_sysfs.c
@@ -0,0 +1,831 @@
+/*
+ * (C) Copyright 2011
+ * Author : Mindspeed Technologes
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ * */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+#include "pfe_mod.h"
+#include "pfe_ctrl_hal.h"
+
+static unsigned long class_do_clear = 0;
+static unsigned long tmu_do_clear = 0;
+static unsigned long util_do_clear = 0;
+
+static ssize_t pe_status(char *buf, int id, u32 dmem_addr, unsigned long do_clear)
+{
+ ssize_t len = 0;
+ u32 val;
+ char statebuf[5];
+ struct pfe_cpumon *cpumon = &pfe->cpumon;
+ u32 debug_indicator;
+ u32 debug[16];
+
+ *(u32 *)statebuf = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+
+ statebuf[4] = '\0';
+ len += sprintf(buf + len, "state=%4s ", statebuf);
+
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, "ctr=%08x ", cpu_to_be32(val));
+
+ val = pe_dmem_read(id, dmem_addr, 4);
+ if (do_clear && val)
+ pe_dmem_write(id, 0, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, "rx=%u ", cpu_to_be32(val));
+
+ val = pe_dmem_read(id, dmem_addr, 4);
+ if (do_clear && val)
+ pe_dmem_write(id, 0, dmem_addr, 4);
+ dmem_addr += 4;
+ if (id >= TMU0_ID && id <= TMU_MAX_ID)
+ len += sprintf(buf + len, "qstatus=%x", cpu_to_be32(val));
+ else
+ len += sprintf(buf + len, "tx=%u", cpu_to_be32(val));
+
+ val = pe_dmem_read(id, dmem_addr, 4);
+ if (do_clear && val)
+ pe_dmem_write(id, 0, dmem_addr, 4);
+ dmem_addr += 4;
+ if (val)
+ len += sprintf(buf + len, " drop=%u", cpu_to_be32(val));
+
+ len += sprintf(buf + len, " load=%d%%", cpumon->cpu_usage_pct[id]);
+
+ len += sprintf(buf + len, "\n");
+
+ debug_indicator = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ if (!strncmp((char *)&debug_indicator, "DBUG", 4))
+ {
+ int j, last = 0;
+ for (j = 0; j < 16; j++)
+ {
+ debug[j] = pe_dmem_read(id, dmem_addr, 4);
+ if (debug[j])
+ {
+ if (do_clear)
+ pe_dmem_write(id, 0, dmem_addr, 4);
+ last = j + 1;
+ }
+ dmem_addr += 4;
+ }
+ for (j = 0; j < last; j++)
+ {
+ len += sprintf(buf + len, "%08x%s", cpu_to_be32(debug[j]),
+ (j & 0x7) == 0x7 || j == last - 1 ? "\n" : " ");
+ }
+ }
+
+ return len;
+}
+
+static ssize_t class_phy_stats(char *buf, int phy)
+{
+ ssize_t len = 0;
+ int off1 = phy * 0x28;
+ int off2 = phy * 0x10;
+
+ if (phy == 3)
+ off1 = CLASS_PHY4_RX_PKTS - CLASS_PHY1_RX_PKTS;
+
+ len += sprintf(buf + len, "phy: %d\n", phy);
+ len += sprintf(buf + len, " rx: %10u, tx: %10u, intf: %10u, ipv4: %10u, ipv6: %10u\n",
+ readl(CLASS_PHY1_RX_PKTS + off1), readl(CLASS_PHY1_TX_PKTS + off1),
+ readl(CLASS_PHY1_INTF_MATCH_PKTS + off1), readl(CLASS_PHY1_V4_PKTS + off1),
+ readl(CLASS_PHY1_V6_PKTS + off1));
+
+ len += sprintf(buf + len, " icmp: %10u, igmp: %10u, tcp: %10u, udp: %10u\n",
+ readl(CLASS_PHY1_ICMP_PKTS + off2), readl(CLASS_PHY1_IGMP_PKTS + off2),
+ readl(CLASS_PHY1_TCP_PKTS + off2), readl(CLASS_PHY1_UDP_PKTS + off2));
+
+ len += sprintf(buf + len, " err\n");
+ len += sprintf(buf + len, " lp: %10u, intf: %10u, l3: %10u, chcksum: %10u, ttl: %10u\n",
+ readl(CLASS_PHY1_LP_FAIL_PKTS + off1), readl(CLASS_PHY1_INTF_FAIL_PKTS + off1),
+ readl(CLASS_PHY1_L3_FAIL_PKTS + off1), readl(CLASS_PHY1_CHKSUM_ERR_PKTS + off1),
+ readl(CLASS_PHY1_TTL_ERR_PKTS + off1));
+
+ return len;
+}
+
+static ssize_t tmu_queue_stats(char *buf, int tmu, int queue)
+{
+ ssize_t len = 0;
+
+ len += sprintf(buf + len, "%d-%02d, ", tmu, queue);
+
+ /* Select queue */
+ writel((tmu << 8) | queue, TMU_TEQ_CTRL);
+ writel((tmu << 8) | queue, TMU_LLM_CTRL);
+
+ len += sprintf(buf + len, "(teq) drop: %10u, tx: %10u (llm) head: %08x, tail: %08x, drop: %10u\n",
+ readl(TMU_TEQ_DROP_STAT), readl(TMU_TEQ_TRANS_STAT),
+ readl(TMU_LLM_QUE_HEADPTR), readl(TMU_LLM_QUE_TAILPTR),
+ readl(TMU_LLM_QUE_DROPCNT));
+
+ return len;
+}
+
+
+static ssize_t tmu_queues(char *buf, int tmu)
+{
+ ssize_t len = 0;
+ int queue;
+
+ for (queue = 0; queue < 16; queue++)
+ len += tmu_queue_stats(buf + len, tmu, queue);
+
+ return len;
+}
+
+static ssize_t tmu_ctx(char *buf, int tmu)
+{
+ ssize_t len = 0;
+ int i;
+ u32 val, tmu_context_addr = TMU_CONTEXT_ADDR;
+
+ len += sprintf(buf+len, " TMU %d \n", TMU0_ID+tmu);
+ for (i = 1; i <= 160 ; i++, tmu_context_addr += 4)
+ {
+ val = pe_dmem_read(TMU0_ID+tmu, tmu_context_addr , 4);
+ if (i == 5)
+ len += sprintf(buf+len, "\nShapers: Each shaper structure is 8 bytes and there are 10 shapers\n");
+
+ if (i == 25)
+ len += sprintf(buf+len, "\nScheduler: Each scheduler structure is 48 bytes and there are 8 schedulers\n");
+ if (i == 121)
+ len += sprintf(buf+len, "\nQueue: Each queue structure is 2 bytes and there are 16 queues\n");
+
+ if (i == 129)
+ len += sprintf(buf+len, "\nqlenmasks array for 16 queues\n");
+ if (i == 145)
+ len += sprintf(buf+len, "\nqresultmap array for 16 queues\n");
+ if (i%8 == 0)
+ len += sprintf(buf+len, "%08x \n", cpu_to_be32(val));
+ else
+ len += sprintf(buf+len, "%08x ", cpu_to_be32(val));
+ }
+
+ len += sprintf(buf+len, "\n");
+
+ return len;
+}
+
+static ssize_t block_version(char *buf, void *addr)
+{
+ ssize_t len = 0;
+ u32 val;
+
+ val = readl(addr);
+ len += sprintf(buf + len, "revision: %x, version: %x, id: %x\n", (val >> 24) & 0xff, (val >> 16) & 0xff, val & 0xffff);
+
+ return len;
+}
+
+static ssize_t bmu(char *buf, int id, void *base)
+{
+ ssize_t len = 0;
+
+ len += sprintf(buf + len, "bmu: %d\n ", id);
+
+ len += block_version(buf + len, base + BMU_VERSION);
+
+ len += sprintf(buf + len, " buf size: %x\n", (1 << readl(base + BMU_BUF_SIZE)));
+ len += sprintf(buf + len, " buf count: %x\n", readl(base + BMU_BUF_CNT));
+ len += sprintf(buf + len, " buf rem: %x\n", readl(base + BMU_REM_BUF_CNT));
+ len += sprintf(buf + len, " buf curr: %x\n", readl(base + BMU_CURR_BUF_CNT));
+ len += sprintf(buf + len, " free err: %x\n", readl(base + BMU_FREE_ERR_ADDR));
+
+ return len;
+}
+
+static ssize_t gpi(char *buf, int id, void *base)
+{
+ ssize_t len = 0;
+ u32 val;
+
+ len += sprintf(buf + len, "gpi%d:\n ", id);
+ len += block_version(buf + len, base + GPI_VERSION);
+
+ len += sprintf(buf + len, " tx under stick: %x\n", readl(base + GPI_FIFO_STATUS));
+ val = readl(base + GPI_FIFO_DEBUG);
+ len += sprintf(buf + len, " tx pkts: %x\n", (val >> 23) & 0x3f);
+ len += sprintf(buf + len, " rx pkts: %x\n", (val >> 18) & 0x3f);
+ len += sprintf(buf + len, " tx bytes: %x\n", (val >> 9) & 0x1ff);
+ len += sprintf(buf + len, " rx bytes: %x\n", (val >> 0) & 0x1ff);
+ len += sprintf(buf + len, " overrun: %x\n", readl(base + GPI_OVERRUN_DROPCNT));
+
+ return len;
+}
+
+static ssize_t pfe_set_class(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ class_do_clear = simple_strtoul(buf, NULL, 0);
+ return count;
+}
+
+static ssize_t pfe_show_class(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+ int id;
+ u32 val;
+ struct pfe_cpumon *cpumon = &pfe->cpumon;
+
+ len += block_version(buf + len, CLASS_VERSION);
+
+ for (id = CLASS0_ID; id <= CLASS_MAX_ID; id++)
+ {
+ len += sprintf(buf + len, "%d: ", id - CLASS0_ID);
+
+ val = readl(CLASS_PE0_DEBUG + id * 4);
+ len += sprintf(buf + len, "pc=1%04x ", val & 0xffff);
+
+ len += pe_status(buf + len, id, PESTATUS_ADDR_CLASS, class_do_clear);
+ }
+ len += sprintf(buf + len, "aggregate load=%d%%\n\n", cpumon->class_usage_pct);
+
+ len += sprintf(buf + len, "pe status: 0x%x\n", readl(CLASS_PE_STATUS));
+ len += sprintf(buf + len, "max buf cnt: 0x%x afull thres: 0x%x\n", readl(CLASS_MAX_BUF_CNT), readl(CLASS_AFULL_THRES));
+ len += sprintf(buf + len, "tsq max cnt: 0x%x tsq fifo thres: 0x%x\n", readl(CLASS_TSQ_MAX_CNT), readl(CLASS_TSQ_FIFO_THRES));
+ len += sprintf(buf + len, "state: 0x%x\n", readl(CLASS_STATE));
+
+ len += class_phy_stats(buf + len, 0);
+ len += class_phy_stats(buf + len, 1);
+ len += class_phy_stats(buf + len, 2);
+ len += class_phy_stats(buf + len, 3);
+
+ return len;
+}
+
+static ssize_t pfe_set_tmu(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ tmu_do_clear = simple_strtoul(buf, NULL, 0);
+ return count;
+}
+
+static ssize_t pfe_show_tmu(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+ int id;
+ u32 val;
+
+ len += block_version(buf + len, TMU_VERSION);
+
+ for (id = TMU0_ID; id <= TMU_MAX_ID; id++)
+ {
+ len += sprintf(buf + len, "%d: ", id - TMU0_ID);
+
+ len += pe_status(buf + len, id, PESTATUS_ADDR_TMU, tmu_do_clear);
+ }
+
+ len += sprintf(buf + len, "pe status: %x\n", readl(TMU_PE_STATUS));
+ len += sprintf(buf + len, "inq fifo cnt: %x\n", readl(TMU_PHY_INQ_FIFO_CNT));
+ val = readl(TMU_INQ_STAT);
+ len += sprintf(buf + len, "inq wr ptr: %x\n", val & 0x3ff);
+ len += sprintf(buf + len, "inq rd ptr: %x\n", val >> 10);
+
+
+ return len;
+}
+
+
+static unsigned long drops_do_clear = 0;
+static u32 CLASS_DMEM_SH2(drop_counter)[CLASS_NUM_DROP_COUNTERS];
+static u32 UTIL_DMEM_SH2(drop_counter)[UTIL_NUM_DROP_COUNTERS];
+
+char *class_drop_description[CLASS_NUM_DROP_COUNTERS] = {
+ "ICC",
+ "Host Pkt Error",
+ "Rx Error",
+ "IPsec Outbound",
+ "IPsec Inbound",
+ "EXPT IPsec Error",
+ "Reassembly",
+ "Fragmenter",
+ "NAT-T",
+ "Socket",
+ "Multicast",
+ "NAT-PT",
+ "Tx Disabled",
+};
+
+char *util_drop_description[UTIL_NUM_DROP_COUNTERS] = {
+ "IPsec Outbound",
+ "IPsec Inbound",
+ "IPsec Rate Limiter",
+ "Fragmenter",
+ "Socket",
+ "Tx Disabled",
+ "Rx Error",
+};
+
+static ssize_t pfe_set_drops(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ drops_do_clear = simple_strtoul(buf, NULL, 0);
+ return count;
+}
+
+static ssize_t pfe_show_drops(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+ int id, dropnum;
+ int tmu, queue;
+ u32 val;
+ u32 dmem_addr;
+ int num_class_drops = 0, num_tmu_drops = 0, num_util_drops = 0;
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+ static u32 tmu_drops[4];
+
+ memset(class_drop_counter, 0, sizeof(class_drop_counter));
+ for (id = CLASS0_ID; id <= CLASS_MAX_ID; id++)
+ {
+ if (drops_do_clear)
+ pe_sync_stop(ctrl, (1 << id));
+ for (dropnum = 0; dropnum < CLASS_NUM_DROP_COUNTERS; dropnum++)
+ {
+ dmem_addr = virt_to_class_dmem(&class_drop_counter[dropnum]);
+ val = be32_to_cpu(pe_dmem_read(id, dmem_addr, 4));
+ class_drop_counter[dropnum] += val;
+ num_class_drops += val;
+ if (drops_do_clear)
+ pe_dmem_write(id, 0, dmem_addr, 4);
+ }
+ if (drops_do_clear)
+ pe_start(ctrl, (1 << id));
+ }
+
+ if (drops_do_clear)
+ pe_sync_stop(ctrl, (1 << UTIL_ID));
+ for (dropnum = 0; dropnum < UTIL_NUM_DROP_COUNTERS; dropnum++)
+ {
+ dmem_addr = virt_to_util_dmem(&util_drop_counter[dropnum]);
+ val = be32_to_cpu(pe_dmem_read(UTIL_ID, dmem_addr, 4));
+ util_drop_counter[dropnum] = val;
+ num_util_drops += val;
+ if (drops_do_clear)
+ pe_dmem_write(UTIL_ID, 0, dmem_addr, 4);
+ }
+ if (drops_do_clear)
+ pe_start(ctrl, (1 << UTIL_ID));
+
+ for (tmu = 0; tmu < 4; tmu++)
+ {
+ for (queue = 0; queue < 16; queue++)
+ {
+ writel((tmu << 8) | queue, TMU_TEQ_CTRL); /* Select queue */
+ val = readl(TMU_TEQ_DROP_STAT);
+ tmu_drops[tmu] += val;
+ num_tmu_drops += tmu_drops[tmu];
+ }
+ }
+
+ if (num_class_drops == 0 && num_util_drops == 0 && num_tmu_drops == 0)
+ len += sprintf(buf + len, "No PE drops\n\n");
+
+ if (num_class_drops > 0)
+ {
+ len += sprintf(buf + len, "Class PE drops --\n");
+ for (dropnum = 0; dropnum < CLASS_NUM_DROP_COUNTERS; dropnum++)
+ {
+ if (class_drop_counter[dropnum] > 0)
+ len += sprintf(buf + len, " %s: %d\n", class_drop_description[dropnum], class_drop_counter[dropnum]);
+ }
+ len += sprintf(buf + len, "\n");
+ }
+
+ if (num_util_drops > 0)
+ {
+ len += sprintf(buf + len, "Util PE drops --\n");
+ for (dropnum = 0; dropnum < UTIL_NUM_DROP_COUNTERS; dropnum++)
+ {
+ if (util_drop_counter[dropnum] > 0)
+ len += sprintf(buf + len, " %s: %d\n", util_drop_description[dropnum], util_drop_counter[dropnum]);
+ }
+ len += sprintf(buf + len, "\n");
+ }
+
+ if (num_tmu_drops > 0)
+ {
+ len += sprintf(buf + len, "TMU drops --\n");
+ for (tmu = 0; tmu < 4; tmu++)
+ {
+ if (tmu_drops[tmu] > 0)
+ len += sprintf(buf + len, " TMU%d: %d\n", tmu, tmu_drops[tmu]);
+ if (drops_do_clear)
+ tmu_drops[tmu] = 0;
+ }
+ len += sprintf(buf + len, "\n");
+ }
+
+ return len;
+}
+
+static ssize_t pfe_show_tmu0_queues(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ return tmu_queues(buf, 0);
+}
+
+static ssize_t pfe_show_tmu1_queues(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ return tmu_queues(buf, 1);
+}
+
+static ssize_t pfe_show_tmu2_queues(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ return tmu_queues(buf, 2);
+}
+
+static ssize_t pfe_show_tmu3_queues(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ return tmu_queues(buf, 3);
+}
+
+static ssize_t pfe_show_tmu0_ctx(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ return tmu_ctx(buf, 0);
+}
+static ssize_t pfe_show_tmu1_ctx(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ return tmu_ctx(buf, 1);
+}
+static ssize_t pfe_show_tmu2_ctx(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ return tmu_ctx(buf, 2);
+}
+
+static ssize_t pfe_show_tmu3_ctx(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ return tmu_ctx(buf, 3);
+}
+
+
+#if !defined(CONFIG_UTIL_DISABLED)
+static ssize_t pfe_set_util(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ util_do_clear = simple_strtoul(buf, NULL, 0);
+ return count;
+}
+
+static ssize_t pfe_show_util(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+ struct pfe_ctrl *ctrl = &pfe->ctrl;
+
+
+ len += block_version(buf + len, UTIL_VERSION);
+
+ pe_sync_stop(ctrl, (1 << UTIL_ID));
+ len += pe_status(buf + len, UTIL_ID, PESTATUS_ADDR_UTIL, util_do_clear);
+ pe_start(ctrl, (1 << UTIL_ID));
+
+ len += sprintf(buf + len, "pe status: %x\n", readl(UTIL_PE_STATUS));
+ len += sprintf(buf + len, "max buf cnt: %x\n", readl(UTIL_MAX_BUF_CNT));
+ len += sprintf(buf + len, "tsq max cnt: %x\n", readl(UTIL_TSQ_MAX_CNT));
+
+ return len;
+}
+#endif
+
+static ssize_t pfe_show_bmu(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+
+ len += bmu(buf + len, 1, BMU1_BASE_ADDR);
+ len += bmu(buf + len, 2, BMU2_BASE_ADDR);
+
+ return len;
+}
+
+static ssize_t pfe_show_hif(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+
+ len += sprintf(buf + len, "hif:\n ");
+ len += block_version(buf + len, HIF_VERSION);
+
+ len += sprintf(buf + len, " tx curr bd: %x\n", readl(HIF_TX_CURR_BD_ADDR));
+ len += sprintf(buf + len, " tx status: %x\n", readl(HIF_TX_STATUS));
+ len += sprintf(buf + len, " tx dma status: %x\n", readl(HIF_TX_DMA_STATUS));
+
+ len += sprintf(buf + len, " rx curr bd: %x\n", readl(HIF_RX_CURR_BD_ADDR));
+ len += sprintf(buf + len, " rx status: %x\n", readl(HIF_RX_STATUS));
+ len += sprintf(buf + len, " rx dma status: %x\n", readl(HIF_RX_DMA_STATUS));
+
+ len += sprintf(buf + len, "hif nocopy:\n ");
+ len += block_version(buf + len, HIF_NOCPY_VERSION);
+
+ len += sprintf(buf + len, " tx curr bd: %x\n", readl(HIF_NOCPY_TX_CURR_BD_ADDR));
+ len += sprintf(buf + len, " tx status: %x\n", readl(HIF_NOCPY_TX_STATUS));
+ len += sprintf(buf + len, " tx dma status: %x\n", readl(HIF_NOCPY_TX_DMA_STATUS));
+
+ len += sprintf(buf + len, " rx curr bd: %x\n", readl(HIF_NOCPY_RX_CURR_BD_ADDR));
+ len += sprintf(buf + len, " rx status: %x\n", readl(HIF_NOCPY_RX_STATUS));
+ len += sprintf(buf + len, " rx dma status: %x\n", readl(HIF_NOCPY_RX_DMA_STATUS));
+
+ return len;
+}
+
+
+static ssize_t pfe_show_gpi(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+
+ len += gpi(buf + len, 0, EGPI1_BASE_ADDR);
+ len += gpi(buf + len, 1, EGPI2_BASE_ADDR);
+ len += gpi(buf + len, 2, EGPI3_BASE_ADDR);
+ len += gpi(buf + len, 3, HGPI_BASE_ADDR);
+
+ return len;
+}
+void ipsec_standalone_init(void);
+static ssize_t pfe_set_ipsec_cmd(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+
+ ipsec_standalone_init();
+ len += sprintf(buf + len, " ipsec details added ");
+ return len;
+}
+
+static ssize_t pfe_show_ipsec_cntrs(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+ u32 dmem_addr = IPSEC_CNTRS_ADDR;
+ u32 val;
+ int id = UTIL_ID;
+
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, " \noutbound cntrs:\n ");
+ len += sprintf(buf + len, " rcvd: %08x ", cpu_to_be32(val));
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, " xmit: %08x ", cpu_to_be32(val));
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, " tohost: %08x ", cpu_to_be32(val));
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, " dropped: %08x ", cpu_to_be32(val));
+
+ len += sprintf(buf + len, " \ninbound cntrs:\n ");
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, " rcvd: %08x ", cpu_to_be32(val));
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, " xmit: %08x ", cpu_to_be32(val));
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, " tohost: %08x ", cpu_to_be32(val));
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, " dropped: %08x\n ", cpu_to_be32(val));
+
+ val = pe_dmem_read(id, dmem_addr, 4);
+ dmem_addr += 4;
+ len += sprintf(buf + len, " wa_drops: %08x\n ", cpu_to_be32(val));
+ return len;
+}
+
+static ssize_t pfe_show_pfemem(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+ struct pfe_memmon *memmon = &pfe->memmon;
+
+ len += sprintf(buf + len, "Kernel Memory: %d Bytes (%d KB)\n", memmon->kernel_memory_allocated, (memmon->kernel_memory_allocated + 1023) / 1024);
+
+ return len;
+}
+
+#ifdef HIF_NAPI_STATS
+static ssize_t pfe_show_hif_napi_stats(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ struct platform_device *pdev = to_platform_device(dev);
+ struct pfe *pfe = platform_get_drvdata(pdev);
+ ssize_t len = 0;
+
+ len += sprintf(buf + len, "sched: %u\n", pfe->hif.napi_counters[NAPI_SCHED_COUNT]);
+ len += sprintf(buf + len, "poll: %u\n", pfe->hif.napi_counters[NAPI_POLL_COUNT]);
+ len += sprintf(buf + len, "packet: %u\n", pfe->hif.napi_counters[NAPI_PACKET_COUNT]);
+ len += sprintf(buf + len, "budget: %u\n", pfe->hif.napi_counters[NAPI_FULL_BUDGET_COUNT]);
+ len += sprintf(buf + len, "desc: %u\n", pfe->hif.napi_counters[NAPI_DESC_COUNT]);
+ len += sprintf(buf + len, "full: %u\n", pfe->hif.napi_counters[NAPI_CLIENT_FULL_COUNT]);
+
+ return len;
+}
+
+static ssize_t pfe_set_hif_napi_stats(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct platform_device *pdev = to_platform_device(dev);
+ struct pfe *pfe = platform_get_drvdata(pdev);
+
+ memset(pfe->hif.napi_counters, 0, sizeof(pfe->hif.napi_counters));
+
+ return count;
+}
+
+static DEVICE_ATTR(hif_napi_stats, 0644, pfe_show_hif_napi_stats, pfe_set_hif_napi_stats);
+#endif
+
+
+static DEVICE_ATTR(class, 0644, pfe_show_class, pfe_set_class);
+static DEVICE_ATTR(tmu, 0644, pfe_show_tmu, pfe_set_tmu);
+#if !defined(CONFIG_UTIL_DISABLED)
+static DEVICE_ATTR(util, 0644, pfe_show_util, pfe_set_util);
+#endif
+static DEVICE_ATTR(bmu, 0444, pfe_show_bmu, NULL);
+static DEVICE_ATTR(hif, 0444, pfe_show_hif, NULL);
+static DEVICE_ATTR(gpi, 0444, pfe_show_gpi, NULL);
+static DEVICE_ATTR(drops, 0644, pfe_show_drops, pfe_set_drops);
+static DEVICE_ATTR(tmu0_queues, 0444, pfe_show_tmu0_queues, NULL);
+static DEVICE_ATTR(tmu1_queues, 0444, pfe_show_tmu1_queues, NULL);
+static DEVICE_ATTR(tmu2_queues, 0444, pfe_show_tmu2_queues, NULL);
+static DEVICE_ATTR(tmu3_queues, 0444, pfe_show_tmu3_queues, NULL);
+static DEVICE_ATTR(tmu0_ctx, 0444, pfe_show_tmu0_ctx, NULL);
+static DEVICE_ATTR(tmu1_ctx, 0444, pfe_show_tmu1_ctx, NULL);
+static DEVICE_ATTR(tmu2_ctx, 0444, pfe_show_tmu2_ctx, NULL);
+static DEVICE_ATTR(tmu3_ctx, 0444, pfe_show_tmu3_ctx, NULL);
+static DEVICE_ATTR(ipsec_cntrs, 0444, pfe_show_ipsec_cntrs, NULL);
+static DEVICE_ATTR(ipsec_cmd, 0444, pfe_set_ipsec_cmd, NULL);
+static DEVICE_ATTR(pfemem, 0444, pfe_show_pfemem, NULL);
+
+
+int pfe_sysfs_init(struct pfe *pfe)
+{
+ if (device_create_file(pfe->dev, &dev_attr_class))
+ goto err_class;
+
+ if (device_create_file(pfe->dev, &dev_attr_tmu))
+ goto err_tmu;
+
+#if !defined(CONFIG_UTIL_DISABLED)
+ if (device_create_file(pfe->dev, &dev_attr_util))
+ goto err_util;
+#endif
+
+ if (device_create_file(pfe->dev, &dev_attr_bmu))
+ goto err_bmu;
+
+ if (device_create_file(pfe->dev, &dev_attr_hif))
+ goto err_hif;
+
+ if (device_create_file(pfe->dev, &dev_attr_gpi))
+ goto err_gpi;
+
+ if (device_create_file(pfe->dev, &dev_attr_drops))
+ goto err_drops;
+
+ if (device_create_file(pfe->dev, &dev_attr_tmu0_queues))
+ goto err_tmu0_queues;
+
+ if (device_create_file(pfe->dev, &dev_attr_tmu1_queues))
+ goto err_tmu1_queues;
+
+ if (device_create_file(pfe->dev, &dev_attr_tmu2_queues))
+ goto err_tmu2_queues;
+
+ if (device_create_file(pfe->dev, &dev_attr_tmu3_queues))
+ goto err_tmu3_queues;
+
+ if (device_create_file(pfe->dev, &dev_attr_tmu0_ctx))
+ goto err_tmu0_ctx;
+
+ if (device_create_file(pfe->dev, &dev_attr_tmu1_ctx))
+ goto err_tmu1_ctx;
+
+ if (device_create_file(pfe->dev, &dev_attr_tmu2_ctx))
+ goto err_tmu2_ctx;
+
+ if (device_create_file(pfe->dev, &dev_attr_tmu3_ctx))
+ goto err_tmu3_ctx;
+
+ if (device_create_file(pfe->dev, &dev_attr_ipsec_cmd))
+ goto err_ipsec_cmd;
+
+ if (device_create_file(pfe->dev, &dev_attr_ipsec_cntrs))
+ goto err_ipsec_cntrs;
+
+ if (device_create_file(pfe->dev, &dev_attr_pfemem))
+ goto err_pfemem;
+
+#ifdef HIF_NAPI_STATS
+ if (device_create_file(pfe->dev, &dev_attr_hif_napi_stats))
+ goto err_hif_napi_stats;
+#endif
+
+ return 0;
+
+#ifdef HIF_NAPI_STATS
+err_hif_napi_stats:
+ device_remove_file(pfe->dev, &dev_attr_pfemem);
+#endif
+
+err_pfemem:
+ device_remove_file(pfe->dev, &dev_attr_ipsec_cntrs);
+
+err_ipsec_cntrs:
+ device_remove_file(pfe->dev, &dev_attr_ipsec_cmd);
+
+err_ipsec_cmd:
+ device_remove_file(pfe->dev, &dev_attr_tmu3_ctx);
+
+err_tmu3_ctx:
+ device_remove_file(pfe->dev, &dev_attr_tmu2_ctx);
+
+err_tmu2_ctx:
+ device_remove_file(pfe->dev, &dev_attr_tmu1_ctx);
+
+err_tmu1_ctx:
+ device_remove_file(pfe->dev, &dev_attr_tmu0_ctx);
+
+err_tmu0_ctx:
+ device_remove_file(pfe->dev, &dev_attr_tmu3_queues);
+
+err_tmu3_queues:
+ device_remove_file(pfe->dev, &dev_attr_tmu2_queues);
+
+err_tmu2_queues:
+ device_remove_file(pfe->dev, &dev_attr_tmu1_queues);
+
+err_tmu1_queues:
+ device_remove_file(pfe->dev, &dev_attr_tmu0_queues);
+
+err_tmu0_queues:
+ device_remove_file(pfe->dev, &dev_attr_drops);
+
+err_drops:
+ device_remove_file(pfe->dev, &dev_attr_gpi);
+
+err_gpi:
+ device_remove_file(pfe->dev, &dev_attr_hif);
+
+err_hif:
+ device_remove_file(pfe->dev, &dev_attr_bmu);
+
+err_bmu:
+#if !defined(CONFIG_UTIL_DISABLED)
+ device_remove_file(pfe->dev, &dev_attr_util);
+
+err_util:
+#endif
+ device_remove_file(pfe->dev, &dev_attr_tmu);
+
+err_tmu:
+ device_remove_file(pfe->dev, &dev_attr_class);
+
+err_class:
+ return -1;
+}
+
+
+void pfe_sysfs_exit(struct pfe *pfe)
+{
+#ifdef HIF_NAPI_STATS
+ device_remove_file(pfe->dev, &dev_attr_hif_napi_stats);
+#endif
+
+ device_remove_file(pfe->dev, &dev_attr_pfemem);
+ device_remove_file(pfe->dev, &dev_attr_ipsec_cntrs);
+ device_remove_file(pfe->dev, &dev_attr_ipsec_cmd);
+ device_remove_file(pfe->dev, &dev_attr_tmu3_ctx);
+ device_remove_file(pfe->dev, &dev_attr_tmu2_ctx);
+ device_remove_file(pfe->dev, &dev_attr_tmu1_ctx);
+ device_remove_file(pfe->dev, &dev_attr_tmu0_ctx);
+ device_remove_file(pfe->dev, &dev_attr_tmu3_queues);
+ device_remove_file(pfe->dev, &dev_attr_tmu2_queues);
+ device_remove_file(pfe->dev, &dev_attr_tmu1_queues);
+ device_remove_file(pfe->dev, &dev_attr_tmu0_queues);
+ device_remove_file(pfe->dev, &dev_attr_drops);
+ device_remove_file(pfe->dev, &dev_attr_gpi);
+ device_remove_file(pfe->dev, &dev_attr_hif);
+ device_remove_file(pfe->dev, &dev_attr_bmu);
+#if !defined(CONFIG_UTIL_DISABLED)
+ device_remove_file(pfe->dev, &dev_attr_util);
+#endif
+ device_remove_file(pfe->dev, &dev_attr_tmu);
+ device_remove_file(pfe->dev, &dev_attr_class);
+}
+
diff --git a/pfe_ctrl/pfe_sysfs.h b/pfe_ctrl/pfe_sysfs.h
new file mode 100644
index 0000000..5fe02a5
--- /dev/null
+++ b/pfe_ctrl/pfe_sysfs.h
@@ -0,0 +1,15 @@
+#ifndef _PFE_SYSFS_H_
+#define _PFE_SYSFS_H_
+
+#include <linux/proc_fs.h>
+
+#define PESTATUS_ADDR_CLASS 0x800
+#define PESTATUS_ADDR_TMU 0x80
+#define PESTATUS_ADDR_UTIL 0x0
+
+#define TMU_CONTEXT_ADDR 0x3c8
+#define IPSEC_CNTRS_ADDR 0x840
+
+int pfe_sysfs_init(struct pfe *pfe);
+void pfe_sysfs_exit(struct pfe *pfe);
+#endif /* _PFE_SYSFS_H_ */
diff --git a/pfe_ctrl/pfe_tso.c b/pfe_ctrl/pfe_tso.c
new file mode 100644
index 0000000..566b25f
--- /dev/null
+++ b/pfe_ctrl/pfe_tso.c
@@ -0,0 +1,316 @@
+
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/mii.h>
+#include <linux/phy.h>
+#include <linux/timer.h>
+
+#include <net/ip.h>
+#include <net/sock.h>
+#include "pfe_mod.h"
+#include "pfe_tso.h"
+
+
+/** pfe_tso_skb_unmap
+ */
+
+void pfe_tx_skb_unmap( struct sk_buff *skb)
+{
+ struct hif_frag_info_s *fi = (struct hif_frag_info_s *)skb->cb;
+ int ii;
+ //printk("frag count : %d, map :%p\n", fi->frag_count, fi->map);
+
+ for (ii = 0; ii < fi->frag_count; ii++) {
+ struct hif_frag_dma_map_s *dma = fi->map + ii;
+
+ // printk("frag addr : %x len : %d\n", dma->data, dma->len);
+ dma_unmap_single(pfe->hif.dev, dma->data, dma->len, DMA_TO_DEVICE);
+ }
+}
+
+/** pfe_tso_to_desc
+ */
+static unsigned int pfe_tso_to_desc(struct sk_buff *skb)
+{
+ struct skb_shared_info *sh = skb_shinfo(skb);
+ unsigned int sh_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
+ skb_frag_t *f; /* current fragment */
+ int len;
+ int f_size; /* size of the current fragment */
+ unsigned int s_size; /* segment size */
+ unsigned int n_desc = 0;
+ int i;
+
+ /* linear part */
+ len = skb_headlen(skb) - sh_len;
+ s_size = sh->gso_size;
+
+ while (len >= s_size) {
+ if (printk_ratelimit())
+ printk(KERN_INFO "%s: remainig leanier len : %d\n", __func__, len);
+
+ len -= s_size;
+ n_desc++;
+ }
+
+ if (len) {
+ if (printk_ratelimit())
+ printk(KERN_INFO "%s: remainig leanier len : %d\n", __func__, len);
+
+ n_desc++;
+ s_size -= len;
+ }
+
+ /* fragment part */
+ for (i = 0; i < sh->nr_frags; i++) {
+ f = &sh->frags[i];
+ f_size = skb_frag_size(f);
+
+ while (f_size >= s_size) {
+ f_size -= s_size;
+ n_desc++;
+ s_size = sh->gso_size;
+ }
+
+ if (f_size) {
+ n_desc++;
+ s_size -= f_size;
+ }
+ }
+
+ return n_desc;
+
+}
+
+/** pfe_tso_get_req_desc
+ * Compute number of required HIF descriptors and number of packets on wire
+ * n_desc : number of HIF descriptors
+ * n_segs : number of segments on wire
+ */
+void pfe_tx_get_req_desc(struct sk_buff *skb, unsigned int *n_desc, unsigned int *n_segs)
+{
+ struct skb_shared_info *sh = skb_shinfo(skb);
+ /**
+ * TSO case
+ * Number of descriptors required = payload scatter +
+ * sh->gso_segs (pre segment header) +
+ * sh->gso_segs (hif/tso segment header)
+ * sh->gso_segs : number of packets on wire
+ */
+ if (skb_is_gso(skb)) {
+ *n_desc = pfe_tso_to_desc(skb) + 2 * sh->gso_segs;
+ *n_segs = sh->gso_segs;
+ }
+ // Scattered data
+ else if (sh->nr_frags) {
+ *n_desc = sh->nr_frags + 1;
+ *n_segs = 1;
+ }
+ // Regular case
+ else {
+ *n_desc = 1;
+ *n_segs = 1;
+ }
+ return;
+}
+
+#define inc_txq_idx(idxname) idxname = (idxname+1) & (qdepth-1)
+/** pfe_tso
+ */
+int pfe_tso( struct sk_buff *skb, struct hif_client_s *client, struct tso_cb_s *tso, int qno, u32 init_ctrl)
+{
+ struct skb_shared_info *sh = skb_shinfo(skb);
+ skb_frag_t *f;
+ struct tcphdr *th;
+ unsigned int tcp_off = skb_transport_offset(skb);
+ unsigned int ip_off = skb_network_offset(skb);
+ unsigned int sh_len = tcp_off + tcp_hdrlen(skb); /* segment header length (link + network + transport) */
+ unsigned int data_len = skb->len - sh_len;
+ unsigned int f_id; /* id of the current fragment */
+ unsigned int f_len; /* size of the current fragment */
+ unsigned int s_len; /* size of the current segment */
+ unsigned int ip_tcp_hdr_len;
+ unsigned int l_len; /* skb linear size */
+ unsigned int len;
+ int segment;
+ unsigned int off, f_off;
+ u32 ctrl;
+ unsigned int id;
+ unsigned int seq;
+ int wrIndx;
+ struct hif_frag_info_s *f_info;
+ struct hif_frag_dma_map_s *f_dma, *q_dma_base, *f_dma_first;
+ unsigned int tx_bytes = 0;
+ int qdepth = client->tx_qsize;
+
+ // ctrl = (skb->ip_summed == CHECKSUM_PARTIAL) ? HIF_CTRL_TX_CHECKSUM : 0;
+ ctrl = (HIF_CTRL_TX_CHECKSUM | init_ctrl);
+
+ if (skb->protocol == htons(ETH_P_IP)) {
+ struct iphdr *ih = ip_hdr(skb);
+
+ id = ntohs(ih->id);
+
+ ctrl |= HIF_CTRL_TX_TSO;
+
+ } else if (skb->protocol == htons(ETH_P_IPV6)) {
+ id = 0;
+ ctrl |= HIF_CTRL_TX_TSO6;
+ }
+ else {
+ kfree_skb(skb);
+ return 0;
+ }
+
+#ifdef PFE_TSO_STATS
+ tso->len_counters[((u32)skb->len >> 11) & 0x1f]++;
+#endif
+
+ th = tcp_hdr(skb);
+ ip_tcp_hdr_len = sh_len - ip_off;
+
+ seq = ntohl(th->seq);
+
+ /* linear part */
+ l_len = skb_headlen(skb) - sh_len;
+ off = sh_len;
+
+ /* fragment part */
+ f_id = 0;
+ f_len = 0;
+ f = NULL;
+ f_off = 0;
+
+ f_info = (struct hif_frag_info_s *)skb->cb;
+
+ /* In case of TSO segmentation, we might need to transmit single skb->fragment
+ * in multiple segments/scatters. So hif will perform cache flush, for each scatter
+ * of same fragment separatly. Since cahche flush is expensive operatrion we will
+ * perform dma mapping for full fragment here and provide physical addresses to HIF.
+ *
+ * Preserve dmamapping information corresponding to skb fragments in array, this
+ * information is used while freeing SKB.
+ */
+ wrIndx = hif_lib_get_tx_wrIndex(client, qno);
+ q_dma_base = (struct hif_frag_dma_map_s *)&tso->dma_map_array[qno][0];
+ f_dma = f_info->map = q_dma_base + wrIndx;
+ f_dma_first = f_dma;
+ f_dma->data = dma_map_single(pfe->hif.dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE);
+ f_dma->len = skb_headlen(skb);
+ f_info->frag_count = 1;
+ //printk("data : %x, len :%d base : %p\n",f_dma->data, f_dma->len, f_info->map);
+
+
+// printk("%s: orig_seq: %x, orig_id: %x, seg_size: %d, seg_n: %d, data_len: %d, hdr_len: %d skb_fras: %d\n", __func__, seq, id, s_len, sh->gso_segs, data_len, sh_len, sh->nr_frags);
+
+ for (segment = 0; segment < sh->gso_segs; segment++) {
+ unsigned int hif_flags = HIF_TSO;
+
+ if (segment == (sh->gso_segs - 1)) {
+ ctrl |= HIF_CTRL_TX_TSO_END;
+ }
+
+ /* The last segment may be less than gso_size. */
+ if (data_len < sh->gso_size)
+ s_len = data_len;
+ else
+ s_len = sh->gso_size;
+
+ data_len -= s_len;
+
+// printk("%s: seq: %x, id: %x, ctrl: %x\n", __func__, seq, id, ctrl);
+
+ /* hif/tso header */
+ __hif_lib_xmit_tso_hdr(client, qno, ctrl, ip_off, id, ip_tcp_hdr_len + s_len, tcp_off, seq);
+
+ id++;
+ seq += s_len;
+
+ /* ethernet/ip/tcp header */
+ __hif_lib_xmit_pkt(client, qno, (void *)f_dma_first->data, sh_len, 0, HIF_DONT_DMA_MAP | hif_flags, skb);
+ tx_bytes += sh_len;
+
+ while (l_len && s_len)
+ {
+ len = s_len;
+ if (len > l_len)
+ len = l_len;
+
+ l_len -= len;
+ s_len -= len;
+
+ if (!s_len)
+ hif_flags |= HIF_LAST_BUFFER;
+
+ if (printk_ratelimit())
+ printk(KERN_INFO "%s: Extra lienear data addr: %p, len: %d, flags: %x\n", __func__,
+ skb->data + off, len, hif_flags);
+
+ __hif_lib_xmit_pkt(client, qno, (void *)((u32)f_dma->data + off),
+ len, 0, hif_flags | HIF_DONT_DMA_MAP, skb);
+ off += len;
+ tx_bytes += len;
+ }
+
+ while (s_len) {
+ hif_flags = HIF_TSO | HIF_DONT_DMA_MAP;
+
+ /* Advance as needed. */
+ if (!f_len) {
+ f = &sh->frags[f_id];
+ f_len = skb_frag_size(f);
+ f_off = 0;
+ f_id++;
+
+ /* In case of TSO segmentation, we might need to transmit single skb->fragment
+ * in multiple segments/scatters. So hif will perform cache flush, for each scatter
+ * of same fragment separatly. Since cahche flush is expensive operatrion we will
+ * perform dma mapping for full fragment here and provide physical addresses to HIF.
+ *
+ * Preserve dmamapping information corresponding to skb fragments in array, this
+ * information is used while freeing SKB.
+ */
+ inc_txq_idx(wrIndx);
+ f_dma = q_dma_base + wrIndx;
+ f_dma->data = dma_map_single(pfe->hif.dev, skb_frag_address(f), f_len, DMA_TO_DEVICE);
+ f_dma->len = f_len;
+ f_info->frag_count++;
+ //printk("data : %x, len :%d\n",f_dma->data, f_dma->len);
+ //printk("%s: frag addr: %p, len: %d\n", __func__, f, f_len);
+ }
+
+ /* Use bytes from the current fragment. */
+ len = s_len;
+ if (len > f_len)
+ len = f_len;
+
+ f_len -= len;
+ s_len -= len;
+
+ if (!s_len) {
+ hif_flags |= HIF_LAST_BUFFER;
+
+ if (segment == (sh->gso_segs - 1))
+ hif_flags |= HIF_DATA_VALID;
+ }
+
+ //printk("%s: scatter addr: %p, len: %d, flags: %x\n", __func__,
+ // skb_frag_address(f) + f_off, len, hif_flags);
+
+ __hif_lib_xmit_pkt(client, qno, (void *)((u32)f_dma->data + f_off), len, 0, hif_flags, skb);
+
+ f_off += len;
+ tx_bytes += len;
+ }
+ }
+
+ hif_tx_dma_start();
+
+ return tx_bytes;
+
+}
diff --git a/pfe_ctrl/pfe_tso.h b/pfe_ctrl/pfe_tso.h
new file mode 100644
index 0000000..473b97d
--- /dev/null
+++ b/pfe_ctrl/pfe_tso.h
@@ -0,0 +1,16 @@
+#ifndef _PFE_TSO_H_
+#define _PFE_TSO_H_
+
+#define PFE_TSO_STATS
+
+struct tso_cb_s
+{
+ unsigned int len_counters[32];
+ /* This array is used to store the dma mapping for skb fragments */
+ struct hif_frag_info_s dma_map_array[EMAC_TXQ_CNT][EMAC_TXQ_DEPTH];
+};
+
+int pfe_tso( struct sk_buff *skb, struct hif_client_s *client, struct tso_cb_s *tso, int qno, u32 ctrl);
+void pfe_tx_skb_unmap( struct sk_buff *skb);
+void pfe_tx_get_req_desc(struct sk_buff *skb, unsigned int *n_desc, unsigned int *n_segs);
+#endif /* _PFE_TSO_H_ */
diff --git a/pfe_ctrl/pfe_unit_test.c b/pfe_ctrl/pfe_unit_test.c
new file mode 100644
index 0000000..52cf994
--- /dev/null
+++ b/pfe_ctrl/pfe_unit_test.c
@@ -0,0 +1,571 @@
+#include "pfe_mod.h"
+#include "pfe_ctrl.h"
+
+#include <linux/slab.h>
+#include <linux/dma-mapping.h>
+#include <linux/delay.h>
+
+#if defined(CONFIG_UNIT_TEST_HIF)
+void hif_unit_test(struct pfe *pfe);
+#endif
+
+#define DMEM_TEST_BASE_ADDR 0x0 /* !!! For class overlaps with packets in dmem, for tmu overwrites exception vectors !!! */
+
+
+#define PMEM_TEST_BASE_ADDR 0x10000
+
+#define BUF_SIZE 6
+
+static u32 w[BUF_SIZE] = {0x01234567, 0x8988cdef, 0x00cc2233, 0x4455dd77, 0x8899aabb, 0xccddeeff};
+static u32 zero[BUF_SIZE] = {0, };
+static u32 r[BUF_SIZE];
+
+volatile void *buf_coherent;
+unsigned long buf_coherent_phys;
+
+static int memcmp_io(void *a, void *b, int len)
+{
+#if defined(CONFIG_PLATFORM_PCI)
+ int rc;
+
+ for (;len >= 4; len -= 4)
+ {
+ rc = readl(a) - readl(b);
+ if (rc)
+ return rc;
+
+ a += 4;
+ b += 4;
+ }
+
+ return 0;
+#else
+ return memcmp(a, b, len);
+#endif
+}
+
+static void memcpy_io(void *dst, void *src, int len)
+{
+#if defined(CONFIG_PLATFORM_PCI)
+ for (;len >= 4; len -= 4)
+ {
+ writel(*(u32 *)src, dst);
+ dst += 4;
+ src += 4;
+ }
+#else
+ memcpy(dst, src, len);
+#endif
+}
+
+static void pe_request_write(struct pfe_ctrl *ctrl, unsigned int id)
+{
+ int len, i;
+ int rc;
+
+ for (len = 1; len <= BUF_SIZE * sizeof(u32); len += 1) {
+ /* Copy to dmem memory */
+ pe_dmem_memcpy_to32(id, DMEM_TEST_BASE_ADDR, &w[0], len);
+
+ memset_io(buf_coherent, 0, BUF_SIZE * sizeof(u32));
+
+ /* Request PE to copy it back */
+ rc = pe_request(ctrl, id, buf_coherent_phys, DMEM_TEST_BASE_ADDR, len);
+ if (rc) {
+ printk(KERN_ERR "PE %d: pe_request() failed: %d %#x\n", id, rc, readl(CLASS_PE0_DEBUG));
+ continue;
+ }
+
+ if (memcmp_io(buf_coherent, w, len))
+ printk(KERN_ERR "PE %d: %s failed: %d", id, __func__, len);
+ else
+ printk(KERN_ERR "PE %d: %s success: %d", id, __func__, len);
+
+ for (i = 0; i < len; i++)
+ printk(" %x/%x", ((volatile u8 *)buf_coherent)[i], ((u8 *)w)[i]);
+
+ printk("\n");
+ }
+}
+
+static void pe_request_read(struct pfe_ctrl *ctrl, unsigned int id)
+{
+ u8 *rb = (u8 *)&r[0];
+ int len, i;
+ int rc;
+
+ for (len = 1; len <= BUF_SIZE * sizeof(u32); len += 1) {
+ /* Zero memory */
+ pe_dmem_memcpy_to32(id, DMEM_TEST_BASE_ADDR, &zero[0], len);
+
+ /* Request PE to copy to internal memory */
+ memcpy_io(buf_coherent, w, BUF_SIZE * sizeof(u32));
+ rc = pe_request(ctrl, id, DMEM_TEST_BASE_ADDR, buf_coherent_phys, len);
+ if (rc) {
+ printk(KERN_ERR "PE %d: pe_request() failed: %d %#x\n", id, rc, readl(CLASS_PE0_DEBUG));
+ continue;
+ }
+
+ /* Read back and compare */
+ for (i = 0; i < len; i++)
+ rb[i] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR + i, 1);
+
+ if (memcmp_io(rb, buf_coherent, len))
+ printk(KERN_ERR "PE %d: %s failed: %d", id, __func__, len);
+ else
+ printk(KERN_ERR "PE %d: %s success: %d", id, __func__, len);
+
+ for (i = 0; i < len; i++)
+ printk(" %x/%x", rb[i], ((volatile u8 *)buf_coherent)[i]);
+
+ printk("\n");
+ }
+}
+
+static void pcie_mem_dump(struct pfe *pfe)
+{
+ int i;
+ u32 a;
+ int print;
+ int count;
+
+ for (i = 0, count = 0, print = 1; i < 64 *SZ_1K; i+=4) {
+ a = readl(pfe->ddr_baseaddr + i);
+ if (a == 0x67452301)
+ print = 1;
+
+ if (print) {
+ count++;
+ printk(KERN_ERR "%#x %#x\n", i, a);
+
+ if (count == 16) {
+ count = 0;
+ print = 0;
+ }
+ }
+ }
+}
+
+static void pcie_mem(struct pfe_ctrl *ctrl)
+{
+ int i, r;
+#if 0
+ for (i = 0; i < 100; i++) {
+ writeb(i, buf_coherent + i);
+ if ((r = readb(buf_coherent + i)) != i)
+ printk(KERN_ERR "%s: readb() %d %d\n", __func__, i, r);
+ }
+
+ for (i = 0; i < 100/2; i++) {
+ writew(i, buf_coherent + i * 2);
+ if ((r = readw(buf_coherent + i * 2)) != i)
+ printk(KERN_ERR "%s: readw() %d %d\n", __func__, i, r);
+ }
+#endif
+
+#if 0
+ for (i = 0; i < 100/4; i++) {
+ writel(i, buf_coherent + i * 4);
+ if ((r = readl(buf_coherent + i * 4)) != i)
+ printk(KERN_ERR "%s: readl() %d %d\n", __func__, i, r);
+ }
+#endif
+ for (i = 0; i < 256; i++)
+ printk(KERN_ERR "%lx %lx %x %x %x\n", buf_coherent_phys, (unsigned long)buf_coherent, readl(pfe->ddr_baseaddr), readl(buf_coherent), readl(CLASS_PE0_DEBUG));
+}
+
+static void pe_stop_start(struct pfe_ctrl *ctrl, int pe_mask)
+{
+ printk(KERN_INFO "%s\n", __func__);
+
+ pe_sync_stop(ctrl, pe_mask);
+
+ printk(KERN_INFO "%s stopped\n", __func__);
+
+ pe_start(ctrl, pe_mask);
+
+ printk(KERN_INFO "%s re-started\n", __func__);
+}
+
+
+static void pe_running(struct pfe_ctrl *ctrl)
+{
+ struct pe_sync_mailbox *mbox;
+ struct pe_msg_mailbox *msg;
+ u32 val;
+ u32 r32[2];
+ u16 r16[2];
+ u8 r8[4];
+ int i;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ mbox = (void *)ctrl->sync_mailbox_baseaddr[CLASS0_ID];
+
+ for (i = 0; i < 100; i++) {
+ val = pe_dmem_read(CLASS0_ID, (unsigned long)&mbox->stopped, 4);
+ printk(KERN_ERR "%s: %#lx %#x %#10x %#10x %#10x %#10x\n", __func__, (unsigned long)&mbox->stopped, be32_to_cpu(val),
+ readl(CLASS_PE0_DEBUG), readl(CLASS_PE1_DEBUG), readl(CLASS_PE2_DEBUG), readl(CLASS_PE3_DEBUG));
+ }
+
+ printk(KERN_ERR "%s: stopped", __func__);
+
+ for (i = 0; i < MAX_PE; i++) {
+ mbox = (void *)ctrl->sync_mailbox_baseaddr[i];
+ val = pe_dmem_read(i, (unsigned long)&mbox->stopped, 4);
+
+ printk(" %x", val);
+ }
+
+ printk("\n");
+
+ printk(KERN_ERR "%s: request", __func__);
+
+ for (i = 0; i < MAX_PE; i++) {
+ msg = (void *)ctrl->msg_mailbox_baseaddr[i];
+ val = pe_dmem_read(i, (unsigned long)&msg->request, 4);
+
+ printk(" %x", val);
+ }
+
+ printk("\n");
+
+
+ r32[0] = pe_dmem_read(CLASS0_ID, 0x800, 4);
+ r32[1] = pe_dmem_read(CLASS0_ID, 0x804, 4);
+ r16[0] = pe_dmem_read(CLASS0_ID, 0x808, 2);
+ r16[1] = pe_dmem_read(CLASS0_ID, 0x80a, 2);
+
+ r8[0] = pe_dmem_read(CLASS0_ID, 0x80c, 1);
+ r8[1] = pe_dmem_read(CLASS0_ID, 0x80d, 1);
+ r8[2] = pe_dmem_read(CLASS0_ID, 0x80e, 1);
+ r8[3] = pe_dmem_read(CLASS0_ID, 0x80f, 1);
+
+
+ printk(KERN_ERR "%x %x\n", r32[0], r32[1]);
+ printk(KERN_ERR "%x %x\n", r16[0], r16[1]);
+ printk(KERN_ERR "%x %x %x %x\n", r8[0], r8[1], r8[2], r8[3]);
+ printk(KERN_ERR "%x %x %x %x\n", pe_dmem_read(CLASS0_ID, 0x810, 4), pe_dmem_read(CLASS1_ID, 0x810, 4),
+ pe_dmem_read(CLASS2_ID, 0x810, 4), pe_dmem_read(CLASS3_ID, 0x810, 4));
+}
+
+
+static void pmem_writeN_readN(unsigned int id)
+{
+ u8 *rb = (u8 *)&r[0];
+ int len, i;
+
+ /* PMEM can not be modified if CPU is running */
+ class_disable();
+
+ for (len = 1; len <= BUF_SIZE * sizeof(u32); len++) {
+ pe_pmem_memcpy_to32(id, PMEM_TEST_BASE_ADDR, &zero[0], len);
+
+ pe_pmem_memcpy_to32(id, PMEM_TEST_BASE_ADDR, &w[0], len);
+
+ for (i = 0; i < len; i++)
+ rb[i] = pe_pmem_read(id, PMEM_TEST_BASE_ADDR + i, 1);
+
+ if (memcmp(rb, w, len))
+ printk(KERN_ERR "PE %d: %s failed: %d\n", id, __func__, len);
+ else
+ printk(KERN_ERR "PE %d: %s success: %d\n", id, __func__, len);
+ }
+
+ class_enable();
+}
+
+
+static void pmem_write4_read4(unsigned int id)
+{
+ /* PMEM can not be modified if CPU is running */
+ class_disable();
+
+ pe_pmem_memcpy_to32(id, PMEM_TEST_BASE_ADDR, &w[0], 4);
+
+ r[0] = pe_pmem_read(id, PMEM_TEST_BASE_ADDR, 4);
+
+ if (r[0] != w[0])
+ printk(KERN_ERR "PE %d: %s failed: %#x %#x\n", id, __func__, w[0], r[0]);
+ else
+ printk(KERN_ERR "PE %d: %s success\n", id, __func__);
+
+ class_enable();
+}
+
+static void dmem_writeN_readN(unsigned int id)
+{
+ u32 zero[3] = {0, };
+ u8 *rb = (u8 *)&r[0];
+ int len, i;
+
+ for (len = 1; len <= BUF_SIZE * sizeof(u32); len++)
+ {
+ pe_dmem_memcpy_to32(id, DMEM_TEST_BASE_ADDR, &zero[0], len);
+
+ pe_dmem_memcpy_to32(id, DMEM_TEST_BASE_ADDR, &w[0], len);
+
+ for (i = 0; i < len; i++)
+ rb[i] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR + i, 1);
+
+ if (memcmp(rb, w, len))
+ printk(KERN_ERR "PE %d: %s failed: %d\n", id, __func__, len);
+ else
+ printk(KERN_ERR "PE %d: %s success: %d\n", id, __func__, len);
+ }
+}
+
+
+static void dmem_write4_read2(unsigned int id)
+{
+ u16 *h = (u16 *)&r[0];
+
+ pe_dmem_write(id, w[0], DMEM_TEST_BASE_ADDR + 0, 4);
+
+ h[0] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR + 0, 2);
+ h[1] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR + 2, 2);
+
+ if (r[0] != w[0])
+ printk(KERN_ERR "PE %d: %s failed: %#x %#x\n", id, __func__, w[0], r[0]);
+ else
+ printk(KERN_ERR "PE %d: %s success\n", id, __func__);
+}
+
+
+static void dmem_write4_read1(unsigned int id)
+{
+ u8 *b = (u8 *)&r[0];
+
+ pe_dmem_write(id, w[0], DMEM_TEST_BASE_ADDR + 0, 4);
+
+ b[0] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR + 0, 1);
+ b[1] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR + 1, 1);
+ b[2] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR + 2, 1);
+ b[3] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR + 3, 1);
+
+ if (r[0] != w[0])
+ printk(KERN_ERR "PE %d: %s failed: %#x %#x\n", id, __func__, w[0], r[0]);
+ else
+ printk(KERN_ERR "PE %d: %s success\n", id, __func__);
+}
+
+static void dmem_write1_read4(unsigned int id)
+{
+ u8 *b = (u8 *)&w[0];
+
+ pe_dmem_write(id, 0x0, DMEM_TEST_BASE_ADDR, 4);
+
+ pe_dmem_write(id, b[0], DMEM_TEST_BASE_ADDR + 0, 1);
+ pe_dmem_write(id, b[1], DMEM_TEST_BASE_ADDR + 1, 1);
+ pe_dmem_write(id, b[2], DMEM_TEST_BASE_ADDR + 2, 1);
+ pe_dmem_write(id, b[3], DMEM_TEST_BASE_ADDR + 3, 1);
+
+ r[0] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR, 4);
+
+ if (r[0] != w[0])
+ printk(KERN_ERR "PE %d: %s failed: %#x %#x\n", id, __func__, w[0], r[0]);
+ else
+ printk(KERN_ERR "PE %d: %s success\n", id, __func__);
+}
+
+
+static void dmem_write2_read4(unsigned int id)
+{
+ u16 *h = (u16 *)&w[0];
+
+ pe_dmem_write(id, 0x0, DMEM_TEST_BASE_ADDR, 4);
+
+ pe_dmem_write(id, h[0], DMEM_TEST_BASE_ADDR + 0, 2);
+ pe_dmem_write(id, h[1], DMEM_TEST_BASE_ADDR + 2, 2);
+
+ r[0] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR, 4);
+
+ if (r[0] != w[0])
+ printk(KERN_ERR "PE %d: %s failed: %#x %#x\n", id, __func__, w[0], r[0]);
+ else
+ printk(KERN_ERR "PE %d: %s success\n", id, __func__);
+}
+
+
+static void dmem_read4_write4(unsigned int id)
+{
+ pe_dmem_write(id, w[0], DMEM_TEST_BASE_ADDR, 4);
+
+ r[0] = pe_dmem_read(id, DMEM_TEST_BASE_ADDR, 4);
+
+ if (r[0] != w[0])
+ printk(KERN_ERR "PE %d: %s failed: %#x %#x\n", id, __func__, w[0], r[0]);
+ else
+ printk(KERN_ERR "PE %d: %s success\n", id, __func__);
+}
+
+
+void bmu_unit_test(void *base, BMU_CFG *cfg)
+{
+ unsigned long buf;
+ int i;
+ int loop = 2;
+ unsigned long *bitmap;
+ unsigned int bitoff;
+
+ bitmap = kzalloc((cfg->count + 7) / 8, GFP_KERNEL);
+ if (!bitmap)
+ return;
+
+ bmu_enable(base);
+
+ do {
+ printk(KERN_INFO "%s: testing %d\n", __func__, loop);
+
+ for (i = 0; i < cfg->count; i++) {
+ buf = readl(base + BMU_ALLOC_CTRL);
+ if (!buf) {
+ printk(KERN_ERR "%s: allocation failed %d\n", __func__, i);
+ continue;
+ }// else
+ // printk(KERN_ERR "%s: allocated %lx\n", __func__, buf);
+
+ if (buf & ((1 << cfg->size) - 1))
+ printk(KERN_ERR "%s: non aligned buffer %lx\n", __func__, buf);
+
+ if (buf < cfg->baseaddr)
+ printk(KERN_ERR "%s: out of bounds buffer %lx\n", __func__, buf);
+
+ if (buf >= (cfg->baseaddr + cfg->count * (1 << cfg->size)))
+ printk(KERN_ERR "%s: out of bounds buffer %lx\n", __func__, buf);
+
+// if ((readl(base + BMU_BUF_CNT) & 0xffff) != (i + 1))
+// printk(KERN_ERR "%s: used buffer count wrong %d %d\n", __func__, readl(base + BMU_BUF_CNT) & 0xffff, i + 1);
+
+ if (readl(base + BMU_REM_BUF_CNT) != (cfg->count - i - 1))
+ printk(KERN_ERR "%s: remaining buffer count wrong %d %d\n", __func__, readl(base + BMU_REM_BUF_CNT), cfg->count - i - 1);
+
+ if (readl(base + BMU_CURR_BUF_CNT) != (i + 1))
+ printk(KERN_ERR "%s: allocate buffer count wrong %d %d\n", __func__, readl(base + BMU_CURR_BUF_CNT), i + 1);
+
+ bitoff = (buf - cfg->baseaddr) >> cfg->size;
+
+ if (test_and_set_bit(bitoff, bitmap))
+ printk(KERN_ERR "%s: duplicated buffer %lx\n", __func__, buf);
+ }
+
+ if (readl(base + BMU_ALLOC_CTRL) != 0)
+ printk(KERN_ERR "%s: too many buffers in pool\n", __func__);
+
+ for (i = 0; i < cfg->count; i++) {
+ buf = cfg->baseaddr + i * (1 << cfg->size);
+ writel(buf, base + BMU_FREE_CTRL);
+
+ bitoff = (buf - cfg->baseaddr) >> cfg->size;
+
+ if (!test_and_clear_bit(bitoff, bitmap))
+ printk(KERN_ERR "%s: not allocated buffer %lx\n", __func__, buf);
+ }
+
+ } while (loop--);
+
+ bmu_disable(base);
+
+ kfree(bitmap);
+}
+
+
+void pfe_unit_test(struct pfe *pfe)
+{
+ int i;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+#if defined(CONFIG_TMU_DUMMY)
+ for (i = 0; i <= CLASS_MAX_ID; i++) {
+#else
+ for (i = 0; i < MAX_PE; i++) {
+#endif
+ dmem_read4_write4(i);
+ dmem_write2_read4(i);
+ dmem_write1_read4(i);
+ dmem_write4_read1(i);
+ dmem_write4_read2(i);
+ dmem_writeN_readN(i);
+#if 0
+ pmem_write4_read4(i);
+ pmem_writeN_readN(i);
+#endif
+ }
+
+ pe_running(&pfe->ctrl);
+
+ /* Skip TMU, UTIL testing for now */
+#if defined(CONFIG_TMU_DUMMY)
+ pe_stop_start(&pfe->ctrl, CLASS_MASK);
+#else
+ pe_stop_start(&pfe->ctrl, CLASS_MASK | TMU_MASK);
+#endif
+
+#if defined(CONFIG_UNIT_TEST_HIF)
+ hif_unit_test(pfe);
+#endif
+
+#if !defined(CONFIG_PLATFORM_PCI)
+ buf_coherent = dma_alloc_coherent(pfe->dev, BUF_SIZE * sizeof(u32), &buf_coherent_phys, GFP_KERNEL);
+ if (!buf_coherent) {
+ printk(KERN_ERR "%s: dma_alloc_coherent() failed\n", __func__);
+ goto out;
+ }
+#else
+ buf_coherent = pfe->ddr_baseaddr + 0x8;
+ buf_coherent_phys = pfe->ddr_phys_baseaddr + 0x8;
+
+ pcie_mem_dump(pfe);
+ pcie_mem(&pfe->ctrl);
+#endif
+
+ for (i = CLASS0_ID; i <= CLASS_MAX_ID; i++) {
+ pe_request_read(&pfe->ctrl, i);
+
+ pe_request_write(&pfe->ctrl, i);
+ }
+
+#if !defined(CONFIG_PLATFORM_PCI)
+ dma_free_coherent(pfe->dev, BUF_SIZE * sizeof(u32), buf_coherent, buf_coherent_phys);
+
+out:
+#endif
+
+ return;
+}
+
+#if defined(CONFIG_UNIT_TEST_HIF)
+void hif_unit_test(struct pfe *pfe)
+{
+ struct hif_client_s *client;
+ unsigned char *pkt;
+
+ printk(KERN_INFO "%s\n", __func__);
+ client = hif_lib_client_register(pfe, NULL, PFE_CL_EVENT, 64, 2, 2);
+ if(client==NULL) {
+ printk("Failed to register client\n");
+ return;
+ }
+
+ printk("hif client registered successfully \n");
+
+ pkt = kmalloc(FPP_SKB_SIZE, GFP_KERNEL);
+ if(!pkt) goto client_dereg;
+
+ if(hif_lib_xmit_pkt(client, 0, pkt+PKT_HEADROOM, 100)==0)
+ printk("%s Packet successfully transmitted\n",__func__);
+ else
+ printk("%s Failed to transmit packet\n",__func__);
+
+ kfree(pkt);
+
+client_dereg:
+ if(hif_lib_client_deregister(pfe, client) != 0) {
+ printk("Failed to deregister client\n");
+ return;
+ }
+ printk("hif client deregistered successfully \n");
+}
+
+#endif
diff --git a/pfe_ctrl/pfe_vwd.c b/pfe_ctrl/pfe_vwd.c
new file mode 100644
index 0000000..da3f879
--- /dev/null
+++ b/pfe_ctrl/pfe_vwd.c
@@ -0,0 +1,2912 @@
+#include <linux/version.h>
+#include <linux/kobject.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+
+#include <net/pkt_sched.h>
+#include <linux/rcupdate.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/if_ether.h>
+#include <linux/netfilter.h>
+#include <linux/netfilter_ipv4.h>
+#include <linux/netfilter_ipv6.h>
+#include <linux/netfilter_bridge.h>
+#include <linux/irqnr.h>
+#include <linux/ppp_defs.h>
+
+#include <linux/rculist.h>
+#include <../../../net/bridge/br_private.h>
+
+#include "config.h"
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+#include <net/xfrm.h>
+#endif
+
+#include "pfe_mod.h"
+#include "pfe_tso.h"
+#include "pfe_vwd.h"
+
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+#include <net/xfrm.h>
+#endif
+
+#ifdef CFG_WIFI_OFFLOAD
+
+//#define VWD_DEBUG
+
+unsigned int vwd_tx_ofld = 0;
+module_param(vwd_tx_ofld, uint, S_IRUGO);
+MODULE_PARM_DESC(vwd_tx_ofld,
+ "0: Local Tx offload is not supported for offload interfaces, 1: Local Tx offload is supported for offload interfaces");
+
+static int pfe_vwd_rx_low_poll(struct napi_struct *napi, int budget);
+static int pfe_vwd_rx_high_poll(struct napi_struct *napi, int budget);
+static void pfe_vwd_sysfs_exit(void);
+static void pfe_vwd_vap_down(struct vap_desc_s *vap);
+static unsigned int pfe_vwd_nf_route_hook_fn( unsigned int hook, struct sk_buff *skb,
+ const struct net_device *in, const struct net_device *out,
+ int (*okfn)(struct sk_buff *));
+static unsigned int pfe_vwd_nf_bridge_hook_fn( unsigned int hook, struct sk_buff *skb,
+ const struct net_device *in, const struct net_device *out,
+ int (*okfn)(struct sk_buff *));
+static int pfe_vwd_handle_vap( struct pfe_vwd_priv_s *vwd, struct vap_cmd_s *cmd );
+static int pfe_vwd_event_handler(void *data, int event, int qno);
+extern int comcerto_wifi_rx_fastpath_register(int (*hdlr)(struct sk_buff *skb));
+extern void comcerto_wifi_rx_fastpath_unregister(void);
+
+extern unsigned int page_mode;
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+extern struct xfrm_state *xfrm_state_lookup_byhandle(struct net *net, u16 handle);
+#endif
+
+
+/* IPV4 route hook , recieve the packet and forward to VWD driver*/
+static struct nf_hook_ops vwd_hook = {
+ .hook = pfe_vwd_nf_route_hook_fn,
+ .pf = PF_INET,
+ .hooknum = NF_INET_PRE_ROUTING,
+ .priority = NF_IP_PRI_FIRST,
+};
+
+/* IPV6 route hook , recieve the packet and forward to VWD driver*/
+static struct nf_hook_ops vwd_hook_ipv6 = {
+ .hook = pfe_vwd_nf_route_hook_fn,
+ .pf = PF_INET6,
+ .hooknum = NF_INET_PRE_ROUTING,
+ .priority = NF_IP6_PRI_FIRST,
+};
+
+/* Bridge hook , recieve the packet and forward to VWD driver*/
+static struct nf_hook_ops vwd_hook_bridge = {
+ .hook = pfe_vwd_nf_bridge_hook_fn,
+ .pf = PF_BRIDGE,
+ .hooknum = NF_BR_PRE_ROUTING,
+ .priority = NF_BR_PRI_FIRST,
+};
+
+struct pfe_vwd_priv_s glbl_pfe_vwd_priv;
+
+#ifdef VWD_DEBUG
+static void pfe_vwd_dump_skb( struct sk_buff *skb )
+{
+ int i;
+
+ for (i = 0; i < skb->len; i++)
+ {
+ if (!(i % 16))
+ printk("\n");
+
+ printk(" %02x", skb->data[i]);
+ }
+}
+#endif
+
+/** get_vap_by_name
+ *
+ */
+static struct vap_desc_s *get_vap_by_name(struct pfe_vwd_priv_s *priv, const char *name)
+{
+ int ii;
+ struct vap_desc_s *vap = NULL;
+
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++)
+ if (priv->vaps[ii] && (!strcmp(priv->vaps[ii]->ifname, name))) {
+ vap = priv->vaps[ii];
+ break;
+ }
+
+ return vap;
+}
+
+
+/**
+ * vwd_vap_device_event_notifier
+ */
+static int vwd_vap_device_event_notifier(struct notifier_block *unused,
+ unsigned long event, void *ptr)
+{
+ struct net_device *dev = ptr;
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ int ii;
+
+
+ switch (event) {
+ case NETDEV_UP:
+ spin_lock_bh(&priv->vaplock);
+
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++) {
+ if(!strcmp(priv->conf_vap_names[ii], dev->name) && !pfe->vwd.vaps[ii])
+ break;
+ }
+ spin_unlock_bh(&priv->vaplock);
+
+ if (ii < MAX_VAP_SUPPORT) {
+ printk(KERN_INFO"%s : VAP name(%s) is already configured\n", __func__, dev->name);
+ schedule_work(&priv->event);
+ }
+ break;
+
+ case NETDEV_DOWN:
+ if (!dev->wifi_offload_dev)
+ goto done;
+
+ if ( !(dev->flags & IFF_UP)){
+ schedule_work(&priv->event);
+ }
+ break;
+
+ }
+
+done:
+
+ return NOTIFY_DONE;
+}
+
+
+static struct notifier_block vwd_vap_notifier = {
+ .notifier_call = vwd_vap_device_event_notifier,
+};
+
+/** pfe_vwd_vap_create
+ *
+ */
+static int pfe_vwd_vap_create(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ struct net_device *wifi_dev;
+ struct vap_cmd_s vap_cmd;
+ char name[IFNAMSIZ];
+ char tmp_name[IFNAMSIZ];
+ int ii, len;
+
+ len = IFNAMSIZ - 1;
+
+ if (len > count)
+ len = count;
+
+ memcpy(tmp_name, buf, len);
+ tmp_name[len] = '\n';
+ sscanf(tmp_name, "%s", name);
+
+ spin_lock(&priv->conf_lock);
+ spin_lock_bh(&priv->vaplock);
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++) {
+ if (!strcmp(priv->conf_vap_names[ii], name)) {
+ printk("%s: VAP with same name already exist\n", __func__);
+ goto done;
+ }
+ }
+
+
+ wifi_dev = dev_get_by_name(&init_net, name);
+ if(wifi_dev) {
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++) {
+ if (!priv->vaps[ii])
+ break;
+ }
+
+ if (ii < MAX_VAP_SUPPORT) {
+ vap_cmd.action = ADD;
+ vap_cmd.vapid = ii;
+ vap_cmd.ifindex = wifi_dev->ifindex;
+ strcpy(vap_cmd.ifname, name);
+ memcpy(vap_cmd.macaddr, wifi_dev->dev_addr, 6);
+ vap_cmd.direct_rx_path = 0;
+
+ if (!pfe_vwd_handle_vap(priv, &vap_cmd)){
+ strcpy(priv->conf_vap_names[ii], name);
+
+ printk(KERN_INFO"VAP added successfully\n");
+ }
+ }
+ else
+ printk("%s: All VAPs are used.. No space.\n",__func__);
+
+
+ dev_put(wifi_dev);
+ }
+ else {
+ printk(KERN_ERR "%s: %s is invalid interface Or not created...\n",__func__, name);
+ }
+
+done:
+ spin_unlock_bh(&priv->vaplock);
+ spin_unlock(&priv->conf_lock);
+
+ return count;
+}
+
+/** pfe_vwd_vap_remove
+ *
+ */
+static int pfe_vwd_vap_remove(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ struct vap_desc_s *vap;
+ struct net_device *wifi_dev;
+ struct vap_cmd_s vap_cmd;
+ char name[IFNAMSIZ];
+ char tmp_name[IFNAMSIZ];
+ int len;
+
+ len = IFNAMSIZ - 1;
+
+ if (len > count)
+ len = count;
+
+ memcpy(tmp_name, buf, len);
+ tmp_name[len] = '\n';
+
+ sscanf(tmp_name, "%s", name);
+
+ wifi_dev = dev_get_by_name(&init_net, name);
+
+ spin_lock(&priv->conf_lock);
+ spin_lock_bh(&priv->vaplock);
+
+ if (wifi_dev) {
+ vap = get_vap_by_name(priv, name);
+
+ if (!vap) {
+ printk(KERN_ERR "%s: %s is not valid VAP\n", __func__, name);
+ dev_put(wifi_dev);
+ goto done;
+ }
+
+ vap_cmd.action = REMOVE;
+ vap_cmd.vapid = vap->vapid;
+ strcpy(vap_cmd.ifname, name);
+ if (!pfe_vwd_handle_vap(priv, &vap_cmd)){
+ printk(KERN_INFO"VAP removed successfully\n");
+ priv->conf_vap_names[vap->vapid][0] = '\0';
+ }
+ dev_put(wifi_dev);
+ }
+
+done:
+ spin_unlock_bh(&priv->vaplock);
+ spin_unlock(&priv->conf_lock);
+
+ return count;
+}
+
+
+#ifdef PFE_VWD_LRO_STATS
+/*
+ * pfe_vwd_show_lro_nb_stats
+ */
+static ssize_t pfe_vwd_show_lro_nb_stats(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ ssize_t len = 0;
+ int i;
+
+ for (i = 0; i < LRO_NB_COUNT_MAX; i++)
+ len += sprintf(buf + len, "%d fragments packets = %d\n", i, priv->lro_nb_counters[i]);
+
+ return len;
+}
+
+/*
+ * pfe_vwd_set_lro_nb_stats
+ */
+static ssize_t pfe_vwd_set_lro_nb_stats(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+
+ memset(priv->lro_nb_counters, 0, sizeof(priv->lro_nb_counters));
+
+ return count;
+}
+
+/*
+ * pfe_vwd_show_lro_len_stats
+ */
+static ssize_t pfe_vwd_show_lro_len_stats(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ ssize_t len = 0;
+ int i;
+
+ for (i = 0; i < LRO_LEN_COUNT_MAX; i++)
+ len += sprintf(buf + len, "RX packets > %dKBytes = %d\n", i * 2, priv->lro_len_counters[i]);
+
+ return len;
+}
+
+/*
+ * pfe_vwd_set_lro_len_stats
+ */
+static ssize_t pfe_vwd_set_lro_len_stats(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+
+ memset(priv->lro_len_counters, 0, sizeof(priv->lro_len_counters));
+
+ return count;
+}
+#endif
+
+#ifdef PFE_VWD_NAPI_STATS
+/*
+ * pfe_vwd_show_napi_stats
+ */
+static ssize_t pfe_vwd_show_napi_stats(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ ssize_t len = 0;
+
+ len += sprintf(buf + len, "sched: %d\n", priv->napi_counters[NAPI_SCHED_COUNT]);
+ len += sprintf(buf + len, "poll: %d\n", priv->napi_counters[NAPI_POLL_COUNT]);
+ len += sprintf(buf + len, "packet: %d\n", priv->napi_counters[NAPI_PACKET_COUNT]);
+ len += sprintf(buf + len, "budget: %d\n", priv->napi_counters[NAPI_FULL_BUDGET_COUNT]);
+ len += sprintf(buf + len, "desc: %d\n", priv->napi_counters[NAPI_DESC_COUNT]);
+
+ return len;
+}
+
+/*
+ * pfe_vwd_set_napi_stats
+ */
+static ssize_t pfe_vwd_set_napi_stats(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+
+ memset(priv->napi_counters, 0, sizeof(priv->napi_counters));
+
+ return count;
+}
+#endif
+
+/** pfe_vwd_show_dump_stats
+ *
+ */
+static ssize_t pfe_vwd_show_dump_stats(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ ssize_t len = 0;
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+
+#ifdef VWD_DEBUG_STATS
+ len += sprintf(buf, "\nTo PFE\n");
+ len += sprintf(buf + len, " WiFi Rx pkts : %d\n", priv->pkts_transmitted);
+ len += sprintf(buf + len, " WiFi Tx pkts : %d\n", priv->pkts_total_local_tx);
+ len += sprintf(buf + len, " WiFi Tx SG pkts : %d\n", priv->pkts_local_tx_sgs);
+ len += sprintf(buf + len, " Drops : %d\n", priv->pkts_tx_dropped);
+
+ len += sprintf(buf + len, "From PFE\n");
+ len += sprintf(buf + len, " WiFi Rx pkts : %d %d %d\n", priv->pkts_slow_forwarded[0],
+ priv->pkts_slow_forwarded[1], priv->pkts_slow_forwarded[2]);
+ len += sprintf(buf + len, " WiFi Tx pkts : %d %d %d\n", priv->pkts_rx_fast_forwarded[0],
+ priv->pkts_rx_fast_forwarded[1], priv->pkts_rx_fast_forwarded[2]);
+ len += sprintf(buf + len, " Skb Alloc fails : %d\n", priv->rx_skb_alloc_fail);
+#endif
+ len += sprintf(buf + len, "\nStatus\n");
+ len += sprintf(buf + len, " Fast path - %s\n", priv->fast_path_enable ? "Enable" : "Disable");
+ len += sprintf(buf + len, " Route hook - %s\n", priv->fast_routing_enable ? "Enable" : "Disable");
+ len += sprintf(buf + len, " Bridge hook - %s\n", priv->fast_bridging_enable ? "Enable" : "Disable");
+ len += sprintf(buf + len, " TSO hook - %s\n", priv->tso_hook_enable ? "Enable" : "Disable");
+
+
+ return len;
+}
+
+
+/** pfe_vwd_show_fast_path_enable
+ *
+ */
+static ssize_t pfe_vwd_show_fast_path_enable(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ int idx;
+
+ idx = sprintf(buf, "\n%d\n", priv->fast_path_enable);
+
+ return idx;
+}
+
+/** pfe_vwd_set_fast_path_enable
+ *
+ */
+static ssize_t pfe_vwd_set_fast_path_enable(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ unsigned int fast_path = 0;
+
+ sscanf(buf, "%d", &fast_path);
+
+ printk("%s: Wifi fast path %d\n", __func__, fast_path);
+
+ if (fast_path && !priv->fast_path_enable)
+ {
+ printk("%s: Wifi fast path enabled \n", __func__);
+
+ priv->fast_path_enable = 1;
+
+ }
+ else if (!fast_path && priv->fast_path_enable)
+ {
+ printk("%s: Wifi fast path disabled \n", __func__);
+
+ priv->fast_path_enable = 0;
+
+ }
+
+ return count;
+}
+
+/** pfe_vwd_show_route_hook_enable
+ *
+ */
+static ssize_t pfe_vwd_show_route_hook_enable(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ int idx;
+
+ idx = sprintf(buf, "\n%d\n", priv->fast_routing_enable);
+
+ return idx;
+}
+
+/** pfe_vwd_set_route_hook_enable
+ *
+ */
+static ssize_t pfe_vwd_set_route_hook_enable(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ unsigned int user_val = 0;
+
+ sscanf(buf, "%d", &user_val);
+
+ if (user_val && !priv->fast_routing_enable)
+ {
+ printk("%s: Wifi fast routing enabled \n", __func__);
+ priv->fast_routing_enable = 1;
+
+ if (priv->fast_bridging_enable)
+ {
+ nf_unregister_hook(&vwd_hook_bridge);
+ priv->fast_bridging_enable = 0;
+ }
+
+ nf_register_hook(&vwd_hook);
+ nf_register_hook(&vwd_hook_ipv6);
+
+
+ }
+ else if (!user_val && priv->fast_routing_enable)
+ {
+ printk("%s: Wifi fast routing disabled \n", __func__);
+ priv->fast_routing_enable = 0;
+
+ nf_unregister_hook(&vwd_hook);
+ nf_unregister_hook(&vwd_hook_ipv6);
+
+ }
+
+ return count;
+}
+
+/** pfe_vwd_show_bridge_hook_enable
+ *
+ */
+static int pfe_vwd_show_bridge_hook_enable(struct device *dev, struct device_attribute *attr, char *buf)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ int idx;
+
+ idx = sprintf(buf, "%d", priv->fast_bridging_enable);
+ return idx;
+}
+
+/** pfe_vwd_set_bridge_hook_enable
+ *
+ */
+static int pfe_vwd_set_bridge_hook_enable(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ unsigned int user_val = 0;
+
+ sscanf(buf, "%d", &user_val);
+
+ if ( user_val && !priv->fast_bridging_enable )
+ {
+ printk("%s: Wifi fast bridging enabled \n", __func__);
+ priv->fast_bridging_enable = 1;
+
+ if(priv->fast_routing_enable)
+ {
+ nf_unregister_hook(&vwd_hook);
+ nf_unregister_hook(&vwd_hook_ipv6);
+ priv->fast_routing_enable = 0;
+ }
+
+ nf_register_hook(&vwd_hook_bridge);
+ }
+ else if ( !user_val && priv->fast_bridging_enable )
+ {
+ printk("%s: Wifi fast bridging disabled \n", __func__);
+ priv->fast_bridging_enable = 0;
+
+ nf_unregister_hook(&vwd_hook_bridge);
+ }
+
+ return count;
+}
+
+/** pfe_vwd_show_direct_tx_path
+ *
+ */
+static int pfe_vwd_show_direct_tx_path(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
+{
+ struct vap_desc_s *vap;
+ int rc;
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+ BUG_ON(!vap);
+ rc = sprintf(buf, "%d\n", vap->direct_tx_path);
+ spin_unlock_bh(&pfe->vwd.vaplock);
+
+ return rc;
+}
+
+/** pfe_vwd_set_direct_tx_path
+ *
+ */
+static int pfe_vwd_set_direct_tx_path(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)
+{
+ struct vap_desc_s *vap;
+ int enable;
+
+ sscanf(buf, "%d", &enable);
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+ BUG_ON(!vap);
+ printk(KERN_INFO "%s: VWD => WiFi direct path is %s for %s\n",
+ __func__, enable ? "enabled":"disabled", vap->ifname);
+ vap->direct_tx_path = enable;
+ spin_unlock_bh(&pfe->vwd.vaplock);
+
+ return count;
+}
+
+/** pfe_vwd_show_direct_rx_path
+ *
+ */
+static int pfe_vwd_show_direct_rx_path(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
+{
+ struct vap_desc_s *vap;
+ int rc;
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+ BUG_ON(!vap);
+ rc = sprintf(buf, "%d\n", vap->direct_rx_path);
+ spin_unlock_bh(&pfe->vwd.vaplock);
+
+ return rc;
+}
+
+/** pfe_vwd_set_direct_rx_path
+ *
+ */
+static int pfe_vwd_set_direct_rx_path(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)
+{
+ struct vap_desc_s *vap;
+ int enable;
+
+ sscanf(buf, "%d", &enable);
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+ BUG_ON(!vap);
+ printk(KERN_INFO "%s: WiFi => VWD direct path is %s for %s\n",
+ __func__, enable ? "enabled":"disabled", vap->ifname);
+ vap->direct_rx_path = enable;
+
+ spin_unlock_bh(&pfe->vwd.vaplock);
+
+ return count;
+}
+
+#if defined(CONFIG_SMP) && (NR_CPUS > 1)
+/** pfe_vwd_show_rx_cpu_affinity
+ *
+ */
+static int pfe_vwd_show_rx_cpu_affinity(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
+{
+ struct vap_desc_s *vap;
+ int rc;
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+ BUG_ON(!vap);
+ rc = sprintf(buf, "%d\n", vap->cpu_id);
+ spin_unlock_bh(&pfe->vwd.vaplock);
+
+ return rc;
+}
+
+/** pfe_vwd_set_rx_cpu_affinity
+ *
+ */
+static int pfe_vwd_set_rx_cpu_affinity(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)
+{
+ struct vap_desc_s *vap;
+ unsigned int cpu_id;
+
+ sscanf(buf, "%d", &cpu_id);
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+ BUG_ON(!vap);
+
+ if (cpu_id < NR_CPUS) {
+ vap->cpu_id = cpu_id;
+ hif_lib_set_rx_cpu_affinity(&vap->client, cpu_id);
+ }
+ else
+ printk(KERN_ERR "%s: Invalid cpu#%d \n", __func__, cpu_id);
+
+ spin_unlock_bh(&pfe->vwd.vaplock);
+
+ return count;
+}
+#endif
+
+#if defined(CONFIG_COMCERTO_CUSTOM_SKB_LAYOUT)
+/** pfe_vwd_show_custom_skb_enable
+ *
+ */
+static int pfe_vwd_show_custom_skb_enable(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
+{
+ struct vap_desc_s *vap;
+ int rc;
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+ BUG_ON(!vap);
+ rc = sprintf(buf, "%d\n", vap->custom_skb);
+ spin_unlock_bh(&pfe->vwd.vaplock);
+
+ return rc;
+}
+
+/** pfe_vwd_set_custom_skb_enable
+ *
+ */
+static int pfe_vwd_set_custom_skb_enable(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)
+{
+ struct vap_desc_s *vap;
+ int enable;
+
+ sscanf(buf, "%d", &enable);
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+ BUG_ON(!vap);
+ printk(KERN_INFO "%s: Custun skb feature is %s for %s\n", __func__, enable ? "enabled":"disabled", vap->ifname);
+ vap->custom_skb = enable;
+ spin_unlock_bh(&pfe->vwd.vaplock);
+
+ return count;
+}
+#endif
+
+#ifdef PFE_VWD_TX_STATS
+/** pfe_vwd_show_vap_tx_stats
+ *
+ */
+static int pfe_vwd_show_vap_tx_stats(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
+{
+ struct vap_desc_s *vap;
+ int len = 0, ii;
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+
+ BUG_ON(!vap);
+
+ len = sprintf(buf, "TX queues stats:\n");
+
+ for (ii = 0; ii < VWD_TXQ_CNT; ii++) {
+ len += sprintf(buf + len, "Queue #%02d\n", ii);
+ len += sprintf(buf + len, " clean_fail = %10d\n", vap->clean_fail[ii]);
+ len += sprintf(buf + len, " stop_queue = %10d\n", vap->stop_queue_total[ii]);
+ len += sprintf(buf + len, " stop_queue_hif = %10d\n", vap->stop_queue_hif[ii]);
+ len += sprintf(buf + len, " stop_queue_hif_client = %10d\n", vap->stop_queue_hif_client[ii]);
+ }
+
+ spin_unlock_bh(&pfe->vwd.vaplock);
+ return len;
+}
+
+/** pfe_vwd_set_vap_tx_stats
+ *
+ */
+static int pfe_vwd_set_vap_tx_stats(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)
+{
+ struct vap_desc_s *vap;
+ int ii;
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ vap = get_vap_by_name(&pfe->vwd, kobject_name(kobj));
+
+ BUG_ON(!vap);
+
+ for (ii = 0; ii < VWD_TXQ_CNT; ii++) {
+ spin_lock_bh(&vap->tx_lock[ii]);
+ vap->clean_fail[ii] = 0;
+ vap->stop_queue_total[ii] = 0;
+ vap->stop_queue_hif[ii] = 0;
+ vap->stop_queue_hif_client[ii] = 0;
+ spin_unlock_bh(&vap->tx_lock[ii]);
+ }
+
+ spin_unlock_bh(&pfe->vwd.vaplock);
+ return count;
+}
+#endif
+
+/*
+ * pfe_vwd_show_tso_stats
+ */
+static ssize_t pfe_vwd_show_tso_stats(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ ssize_t len = 0;
+ int i;
+
+ for (i = 0; i < 32; i++)
+ len += sprintf(buf + len, "TSO packets > %dKBytes = %u\n", i * 2, priv->tso.len_counters[i]);
+
+ return len;
+}
+
+/*
+ * pfe_vwd_set_tso_stats
+ */
+static ssize_t pfe_vwd_set_tso_stats(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+
+ memset(priv->tso.len_counters, 0, sizeof(priv->tso.len_counters));
+ return count;
+}
+
+/** pfe_vwd_classify_packet
+ *
+ */
+static int pfe_vwd_classify_packet( struct pfe_vwd_priv_s *priv, struct sk_buff *skb,
+ int bridge_hook, int route_hook, int *vapid, int *own_mac)
+{
+ unsigned short type;
+ struct vap_desc_s *vap;
+ int rc = 1, ii, length;
+ unsigned char *data_ptr;
+ struct ethhdr *hdr;
+#if defined (CONFIG_COMCERTO_VWD_MULTI_MAC)
+ struct net_bridge_fdb_entry *dst = NULL;
+ struct net_bridge_port *p = NULL;
+ const unsigned char *dest = eth_hdr(skb)->h_dest;
+#endif
+ *own_mac = 0;
+
+ /* Move to packet network header */
+ data_ptr = skb_mac_header(skb);
+ length = skb->len + (skb->data - data_ptr);
+
+ spin_lock_bh(&priv->vaplock);
+ /* Broadcasts and MC are handled by stack */
+ if( (eth_hdr(skb)->h_dest[0] & 0x1) ||
+ ( length <= ETH_HLEN ) )
+ {
+ rc = 1;
+ goto done;
+ }
+
+ /* FIXME: This packet is VWD slow path packet, and already seen by VWD */
+
+ if (*(unsigned long *)skb->head == 0xdead)
+ {
+ //printk(KERN_INFO "%s:This is dead packet....\n", __func__);
+ *(unsigned long *)skb->head = 0x0;
+ rc = 1;
+ goto done;
+ }
+
+#ifdef VWD_DEBUG
+ printk(KERN_INFO "%s: skb cur len:%d skb orig len:%d\n", __func__, skb->len, length );
+#endif
+
+ /* FIXME: We need to check the route table for the route entry. If route
+ * entry found for the current packet, send the packet to PFE. Otherwise
+ * REJECT the packet.
+ */
+ for ( ii = 0; ii < MAX_VAP_SUPPORT; ii++ )
+ {
+ vap = priv->vaps[ii];
+ if ((vap) && (vap->ifindex == skb->skb_iif) )
+ {
+ /* This interface packets need to be processed by direct API */
+ if (vap->direct_rx_path) {
+ rc = 1;
+ goto done;
+ }
+
+ hdr = (struct ethhdr *)data_ptr;
+ type = htons(hdr->h_proto);
+ data_ptr += ETH_HLEN;
+ length -= ETH_HLEN;
+ rc = 0;
+
+ *vapid = vap->vapid;
+
+ /* FIXME send only IPV4 and IPV6 packets to PFE */
+ //Determain final protocol type
+ //FIXME : This multi level parsing is not required for
+ // Bridged packets.
+ if( type == ETH_P_8021Q )
+ {
+ struct vlan_hdr *vhdr = (struct vlan_hdr *)data_ptr;
+
+ data_ptr += VLAN_HLEN;
+ length -= VLAN_HLEN;
+ type = htons(vhdr->h_vlan_encapsulated_proto);
+ }
+
+ if( type == ETH_P_PPP_SES )
+ {
+ struct pppoe_hdr *phdr = (struct pppoe_hdr *)data_ptr;
+
+ data_ptr += PPPOE_SES_HLEN;
+ length -= PPPOE_SES_HLEN;
+
+ if (htons(*(u16 *)(phdr+1)) == PPP_IP)
+ type = ETH_P_IP;
+ else if (htons(*(u16 *)(phdr+1)) == PPP_IPV6)
+ type = ETH_P_IPV6;
+ }
+
+
+ if (bridge_hook)
+ {
+#if defined (CONFIG_COMCERTO_VWD_MULTI_MAC)
+ /* check if destination MAC matches one of the interfaces attached to the bridge */
+ if((p = rcu_dereference(skb->dev->br_port)) != NULL)
+ dst = __br_fdb_get(p->br, dest);
+
+ if (skb->pkt_type == PACKET_HOST || (dst && dst->is_local))
+#else
+ if (skb->pkt_type == PACKET_HOST)
+#endif
+ {
+ *own_mac = 1;
+
+ if ((type != ETH_P_IP) && (type != ETH_P_IPV6))
+ {
+ rc = 1;
+ goto done;
+ }
+ }
+ else if (!memcmp(vap->macaddr, eth_hdr(skb)->h_dest, ETH_ALEN))
+ {
+ //WiFi management packets received with dst address
+ //as bssid
+ rc = 1;
+ goto done;
+ }
+ }
+ else
+ *own_mac = 1;
+
+ break;
+ }
+
+ }
+
+done:
+ spin_unlock_bh(&priv->vaplock);
+ return rc;
+
+}
+
+/** pfe_vwd_flush_txQ
+ *
+ */
+static void pfe_vwd_flush_txQ(struct vap_desc_s *vap, int queuenum, int from_tx, int n_desc)
+{
+ struct sk_buff *skb;
+ int count = max(TX_FREE_MAX_COUNT, n_desc);
+ unsigned int flags;
+
+ //printk(KERN_INFO "%s\n", __func__);
+
+ if (!from_tx)
+ spin_lock_bh(&vap->tx_lock[queuenum]);
+
+ while (count && (skb = hif_lib_tx_get_next_complete(&vap->client, queuenum, &flags, count))) {
+
+ /* FIXME : Invalid data can be skipped in hif_lib itself */
+ if (flags & HIF_DATA_VALID) {
+ if (flags & HIF_DONT_DMA_MAP)
+ pfe_tx_skb_unmap(skb);
+ dev_kfree_skb_any(skb);
+ }
+ // When called from the timer, flush all descriptors
+ if (from_tx)
+ count--;
+ }
+
+ if (!from_tx)
+ spin_unlock_bh(&vap->tx_lock[queuenum]);
+
+
+}
+
+/** pfe_eth_flush_tx
+ */
+static void pfe_vwd_flush_tx(struct vap_desc_s *vap, int force)
+{
+ int ii;
+
+ for (ii = 0; ii < VWD_TXQ_CNT; ii++) {
+ if (force || (time_after(jiffies, vap->client.tx_q[ii].jiffies_last_packet + (COMCERTO_TX_RECOVERY_TIMEOUT_MS * HZ)/1000)))
+ pfe_vwd_flush_txQ(vap, ii, 0, 0); //We will release everything we can based on from_tx param, so the count param can be set to any value
+ }
+}
+
+
+/** pfe_vwd_tx_timeout
+ */
+void pfe_vwd_tx_timeout(unsigned long data )
+{
+ struct pfe_vwd_priv_s *priv = (struct pfe_vwd_priv_s *)data;
+ int ii;
+
+ spin_lock_bh(&priv->vaplock);
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++) {
+ if (!priv->vaps[ii])
+ continue;
+
+ pfe_vwd_flush_tx(priv->vaps[ii], 0);
+ }
+
+ priv->tx_timer.expires = jiffies + ( COMCERTO_TX_RECOVERY_TIMEOUT_MS * HZ )/1000;
+ add_timer(&priv->tx_timer);
+ spin_unlock_bh(&priv->vaplock);
+}
+
+/** pfe_vwd_send_packet
+ *
+ */
+static void pfe_vwd_send_packet( struct sk_buff *skb, struct pfe_vwd_priv_s *priv, int queuenum, struct vap_desc_s *vap, int own_mac, u32 ctrl)
+{
+ void *data;
+ int count;
+ unsigned int nr_frags;
+ struct skb_shared_info *sh;
+ unsigned int nr_desc, nr_segs;
+
+ spin_lock_bh(&vap->tx_lock[queuenum]);
+
+ if (skb_headroom(skb) < (PFE_PKT_HEADER_SZ + sizeof(unsigned long))) {
+
+ //printk(KERN_INFO "%s: copying skb %d\n", __func__, skb_headroom(skb));
+
+ if (pskb_expand_head(skb, (PFE_PKT_HEADER_SZ + sizeof(unsigned long)), 0, GFP_ATOMIC)) {
+ kfree_skb(skb);
+#ifdef VWD_DEBUG_STATS
+ priv->pkts_tx_dropped += 1;
+#endif
+ goto out;
+ }
+ }
+
+ pfe_tx_get_req_desc(skb, &nr_desc, &nr_segs);
+ hif_tx_lock(&pfe->hif);
+
+ if ((__hif_tx_avail(&pfe->hif) < nr_desc) || (hif_lib_tx_avail(&vap->client, queuenum) < nr_desc)) {
+
+ //printk(KERN_ERR "%s: __hif_lib_xmit_pkt() failed\n", __func__);
+ kfree_skb(skb);
+#ifdef VWD_DEBUG_STATS
+ priv->pkts_tx_dropped++;
+#endif
+ goto out;
+ }
+
+ /* Send vap_id to PFE */
+ if (own_mac)
+ ctrl |= ((vap->vapid << HIF_CTRL_VAPID_OFST) | HIF_CTRL_TX_OWN_MAC);
+ else
+ ctrl |= (vap->vapid << HIF_CTRL_VAPID_OFST);
+
+
+ if ((vap->wifi_dev->features & NETIF_F_RXCSUM) && (skb->ip_summed == CHECKSUM_NONE))
+ ctrl |= HIF_CTRL_TX_CSUM_VALIDATE;
+
+ sh = skb_shinfo(skb);
+ nr_frags = sh->nr_frags;
+
+ /* if nr_desc > 1, then skb is scattered, otherwise linear skb */
+ if (nr_frags) {
+ skb_frag_t *f;
+ int i;
+
+ __hif_lib_xmit_pkt(&vap->client, queuenum, skb->data, skb_headlen(skb), ctrl, HIF_FIRST_BUFFER, skb);
+
+ for (i = 0; i < nr_frags - 1; i++) {
+ f = &sh->frags[i];
+
+ __hif_lib_xmit_pkt(&vap->client, queuenum, skb_frag_address(f), skb_frag_size(f), 0x0, 0x0, skb);
+ }
+
+ f = &sh->frags[i];
+
+ __hif_lib_xmit_pkt(&vap->client, queuenum, skb_frag_address(f), skb_frag_size(f), 0x0, HIF_LAST_BUFFER|HIF_DATA_VALID, skb);
+
+
+#ifdef VWD_DEBUG_STATS
+ priv->pkts_local_tx_sgs += 1;
+#endif
+ }
+ else
+ {
+#if defined(CONFIG_COMCERTO_CUSTOM_SKB_LAYOUT)
+ if (skb->mspd_data && skb->mspd_len) {
+ int len = skb->len - skb->mspd_len;
+
+ //printk("%s : custom skb\n", __func__);
+
+ data = (skb->mspd_data + skb->mspd_ofst) - len;
+ memcpy(data, skb->data, len);
+ }
+ else
+#endif
+
+ data = skb->data;
+
+ __hif_lib_xmit_pkt(&vap->client, queuenum, data, skb->len, ctrl, HIF_FIRST_BUFFER | HIF_LAST_BUFFER | HIF_DATA_VALID, skb);
+ }
+
+ hif_tx_dma_start();
+
+#ifdef VWD_DEBUG_STATS
+ priv->pkts_transmitted += 1;
+#endif
+ vap->stats.tx_packets++;
+ vap->stats.tx_bytes += skb->len;
+
+
+out:
+ hif_tx_unlock(&pfe->hif);
+ // Recycle buffers if a socket's send buffer becomes half full or if the HIF client queue starts filling up
+ if (((count = (hif_lib_tx_pending(&vap->client, queuenum) - HIF_CL_TX_FLUSH_MARK)) > 0)
+ || (skb && skb->sk && ((sk_wmem_alloc_get(skb->sk) << 1) > skb->sk->sk_sndbuf)))
+ pfe_vwd_flush_txQ(vap, queuenum, 1, count);
+
+ spin_unlock_bh(&vap->tx_lock[queuenum]);
+
+ return;
+}
+
+/*
+ * vwd_wifi_if_send_pkt
+ */
+static int vwd_wifi_if_send_pkt(struct sk_buff *skb)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ int ii;
+ unsigned int dst_mac[2];
+
+ if (!priv->fast_path_enable)
+ goto end;
+
+ /* Copy destination mac into cacheable memory */
+ if (!((unsigned long)skb->data & 0x3))
+ __memcpy8(dst_mac, skb->data);
+ else
+ memcpy(dst_mac, skb->data, 6);
+
+ if (dst_mac[0] & 0x1)
+ goto end;
+
+ spin_lock_bh(&priv->vaplock);
+
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++)
+ {
+ struct vap_desc_s *vap;
+
+ vap = priv->vaps[ii];
+
+ if (vap && (vap->ifindex == skb->dev->ifindex))
+ {
+ if (unlikely(!vap->direct_rx_path)) {
+ spin_unlock_bh(&priv->vaplock);
+ goto end;
+ }
+
+ if (!memcmp(vap->macaddr, dst_mac, ETH_ALEN))
+ pfe_vwd_send_packet( skb, priv, 0, vap, 1, 0);
+ else
+ pfe_vwd_send_packet( skb, priv, 0, vap, 0, 0);
+
+ break;
+ }
+ }
+
+ spin_unlock_bh(&priv->vaplock);
+
+ if (unlikely(ii == MAX_VAP_SUPPORT))
+ goto end;
+
+ return 0;
+
+end:
+ return -1;
+}
+
+
+/** vwd_nf_bridge_hook_fn
+ *
+ */
+static unsigned int pfe_vwd_nf_bridge_hook_fn( unsigned int hook, struct sk_buff *skb,
+ const struct net_device *in, const struct net_device *out,
+ int (*okfn)(struct sk_buff *))
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ int vapid = -1;
+ int own_mac = 0;
+
+#ifdef VWD_DEBUG
+ printk("%s: protocol : 0x%04x\n", __func__, htons(skb->protocol));
+#endif
+
+ if( !priv->fast_path_enable )
+ goto done;
+
+ if( !pfe_vwd_classify_packet(priv, skb, 1, 0, &vapid, &own_mac) )
+ {
+#ifdef VWD_DEBUG
+ printk("%s: Accepted\n", __func__);
+ // pfe_vwd_dump_skb( skb );
+#endif
+ skb_push(skb, ETH_HLEN);
+ pfe_vwd_send_packet( skb, priv, 0, priv->vaps[vapid], own_mac, 0);
+ return NF_STOLEN;
+ }
+
+done:
+
+ return NF_ACCEPT;
+
+}
+
+/** vwd_nf_route_hook_fn
+ *
+ */
+static unsigned int pfe_vwd_nf_route_hook_fn( unsigned int hook, struct sk_buff *skb,
+ const struct net_device *in, const struct net_device *out,
+ int (*okfn)(struct sk_buff *))
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+ int vapid = -1;
+ int own_mac = 0;
+
+#ifdef VWD_DEBUG
+ printk("%s: protocol : 0x%04x\n", __func__, htons(skb->protocol));
+#endif
+
+ if (!priv->fast_path_enable)
+ goto done;
+
+ if (!pfe_vwd_classify_packet(priv, skb, 0, 1, &vapid, &own_mac))
+ {
+#ifdef VWD_DEBUG
+ printk("%s: Accepted\n", __func__);
+// pfe_vwd_dump_skb( skb );
+#endif
+ skb_push(skb, ETH_HLEN);
+ pfe_vwd_send_packet( skb, priv, 0, priv->vaps[vapid], own_mac, 0);
+ return NF_STOLEN;
+ }
+
+done:
+ return NF_ACCEPT;
+
+}
+
+static DEVICE_ATTR(vwd_debug_stats, 0444, pfe_vwd_show_dump_stats, NULL);
+static DEVICE_ATTR(vwd_fast_path_enable, 0644, pfe_vwd_show_fast_path_enable, pfe_vwd_set_fast_path_enable);
+static DEVICE_ATTR(vwd_route_hook_enable, 0644, pfe_vwd_show_route_hook_enable, pfe_vwd_set_route_hook_enable);
+static DEVICE_ATTR(vwd_bridge_hook_enable, 0644, pfe_vwd_show_bridge_hook_enable, pfe_vwd_set_bridge_hook_enable);
+static DEVICE_ATTR(vwd_tso_stats, 0644, pfe_vwd_show_tso_stats, pfe_vwd_set_tso_stats);
+
+static struct kobj_attribute direct_rx_attr =
+ __ATTR(direct_rx_path, 0644, pfe_vwd_show_direct_rx_path, pfe_vwd_set_direct_rx_path);
+static struct kobj_attribute direct_tx_attr =
+ __ATTR(direct_tx_path, 0644, pfe_vwd_show_direct_tx_path, pfe_vwd_set_direct_tx_path);
+#if defined(CONFIG_COMCERTO_CUSTOM_SKB_LAYOUT)
+static struct kobj_attribute custom_skb_attr =
+ __ATTR(custom_skb_enable, 0644, pfe_vwd_show_custom_skb_enable, pfe_vwd_set_custom_skb_enable);
+#endif
+#if defined(CONFIG_SMP) && (NR_CPUS > 1)
+static struct kobj_attribute rx_cpu_affinity_attr =
+ __ATTR(rx_cpu_affinity, 0644, pfe_vwd_show_rx_cpu_affinity, pfe_vwd_set_rx_cpu_affinity);
+#endif
+#ifdef PFE_VWD_TX_STATS
+static struct kobj_attribute tx_stats_attr =
+ __ATTR(tx_stats, 0644, pfe_vwd_show_vap_tx_stats, pfe_vwd_set_vap_tx_stats);
+#endif
+static struct attribute *vap_attrs[] = {
+ &direct_rx_attr.attr,
+ &direct_tx_attr.attr,
+#if defined(CONFIG_COMCERTO_CUSTOM_SKB_LAYOUT)
+ &custom_skb_attr.attr,
+#endif
+#if defined(CONFIG_SMP) && (NR_CPUS > 1)
+ &rx_cpu_affinity_attr.attr,
+#endif
+#ifdef PFE_VWD_TX_STATS
+ &tx_stats_attr.attr,
+#endif
+ NULL,
+};
+
+static struct attribute_group vap_attr_group = {
+ .attrs = vap_attrs,
+};
+
+#ifdef PFE_VWD_NAPI_STATS
+static DEVICE_ATTR(vwd_napi_stats, 0644, pfe_vwd_show_napi_stats, pfe_vwd_set_napi_stats);
+#endif
+static DEVICE_ATTR(vwd_vap_create, 0644, NULL, pfe_vwd_vap_create);
+static DEVICE_ATTR(vwd_vap_remove, 0644, NULL, pfe_vwd_vap_remove);
+#ifdef PFE_VWD_LRO_STATS
+static DEVICE_ATTR(vwd_lro_nb_stats, 0644, pfe_vwd_show_lro_nb_stats, pfe_vwd_set_lro_nb_stats);
+static DEVICE_ATTR(vwd_lro_len_stats, 0644, pfe_vwd_show_lro_len_stats, pfe_vwd_set_lro_len_stats);
+#endif
+/** pfe_vwd_sysfs_init
+ *
+ */
+static int pfe_vwd_sysfs_init( struct pfe_vwd_priv_s *priv )
+{
+ struct pfe *pfe = priv->pfe;
+
+ if (device_create_file(pfe->dev, &dev_attr_vwd_debug_stats))
+ goto err_dbg_sts;
+
+ if (device_create_file(pfe->dev, &dev_attr_vwd_fast_path_enable))
+ goto err_fp_en;
+
+ if (device_create_file(pfe->dev, &dev_attr_vwd_route_hook_enable))
+ goto err_rt;
+
+ if (device_create_file(pfe->dev, &dev_attr_vwd_bridge_hook_enable))
+ goto err_br;
+
+ if (vwd_tx_ofld && device_create_file(pfe->dev, &dev_attr_vwd_vap_create))
+ goto err_vap_add;
+
+ if (vwd_tx_ofld && device_create_file(pfe->dev, &dev_attr_vwd_vap_remove))
+ goto err_vap_del;
+
+ if (device_create_file(pfe->dev, &dev_attr_vwd_tso_stats))
+ goto err_tso_stats;
+
+#ifdef PFE_VWD_NAPI_STATS
+ if (device_create_file(pfe->dev, &dev_attr_vwd_napi_stats))
+ goto err_napi;
+#endif
+
+#ifdef PFE_VWD_LRO_STATS
+ if (device_create_file(pfe->dev, &dev_attr_vwd_lro_nb_stats))
+ goto err_lro_nb;
+
+ if (device_create_file(pfe->dev, &dev_attr_vwd_lro_len_stats))
+ goto err_lro_len;
+#endif
+
+ return 0;
+
+#ifdef PFE_VWD_LRO_STATS
+err_lro_len:
+ device_remove_file(pfe->dev, &dev_attr_vwd_lro_nb_stats);
+err_lro_nb:
+#endif
+
+#ifdef PFE_VWD_NAPI_STATS
+ device_remove_file(pfe->dev, &dev_attr_vwd_napi_stats);
+err_napi:
+#endif
+
+#if defined(PFE_VWD_LRO_STATS) || defined(PFE_VWD_NAPI_STATS)
+ device_remove_file(pfe->dev, &dev_attr_vwd_tso_stats);
+#endif
+
+err_tso_stats:
+ if (vwd_tx_ofld)
+ device_remove_file(pfe->dev, &dev_attr_vwd_vap_remove);
+err_vap_del:
+ if (vwd_tx_ofld)
+ device_remove_file(pfe->dev, &dev_attr_vwd_vap_create);
+err_vap_add:
+ device_remove_file(pfe->dev, &dev_attr_vwd_bridge_hook_enable);
+err_br:
+ device_remove_file(pfe->dev, &dev_attr_vwd_route_hook_enable);
+err_rt:
+ device_remove_file(pfe->dev, &dev_attr_vwd_fast_path_enable);
+err_fp_en:
+ device_remove_file(pfe->dev, &dev_attr_vwd_debug_stats);
+err_dbg_sts:
+ return -1;
+}
+
+
+/** pfe_vwd_sysfs_exit
+ *
+ */
+static void pfe_vwd_sysfs_exit(void)
+{
+ device_remove_file(pfe->dev, &dev_attr_vwd_tso_stats);
+#ifdef PFE_VWD_LRO_STATS
+ device_remove_file(pfe->dev, &dev_attr_vwd_lro_len_stats);
+ device_remove_file(pfe->dev, &dev_attr_vwd_lro_nb_stats);
+#endif
+
+#ifdef PFE_VWD_NAPI_STATS
+ device_remove_file(pfe->dev, &dev_attr_vwd_napi_stats);
+#endif
+ if (vwd_tx_ofld) {
+ device_remove_file(pfe->dev, &dev_attr_vwd_vap_create);
+ device_remove_file(pfe->dev, &dev_attr_vwd_vap_remove);
+ }
+ device_remove_file(pfe->dev, &dev_attr_vwd_bridge_hook_enable);
+ device_remove_file(pfe->dev, &dev_attr_vwd_route_hook_enable);
+ device_remove_file(pfe->dev, &dev_attr_vwd_fast_path_enable);
+ device_remove_file(pfe->dev, &dev_attr_vwd_debug_stats);
+}
+
+/** pfe_vwd_rx_page
+ *
+ */
+static struct sk_buff *pfe_vwd_rx_page(struct vap_desc_s *vap, int qno, unsigned int *ctrl)
+{
+ struct page *p;
+ void *buf_addr;
+ unsigned int rx_ctrl;
+ unsigned int desc_ctrl = 0;
+ struct sk_buff *skb;
+ int length, offset, data_offset;
+ struct hif_lro_hdr *lro_hdr;
+ u32 pe_id;
+ struct pfe_vwd_priv_s *priv = vap->priv;
+
+
+ while (1) {
+ buf_addr = hif_lib_receive_pkt(&vap->client, qno, &length, &offset, &rx_ctrl, &desc_ctrl, (void **)&lro_hdr);
+
+ if (!buf_addr)
+ goto empty;
+
+ if (qno == 2)
+ pe_id = (rx_ctrl >> HIF_CTRL_RX_PE_ID_OFST) & 0xf;
+ else
+ pe_id = 0;
+
+ skb = vap->skb_inflight[qno + pe_id];
+
+#ifdef PFE_VWD_NAPI_STATS
+ priv->napi_counters[NAPI_DESC_COUNT]++;
+#endif
+
+ *ctrl = rx_ctrl;
+
+ /* First frag */
+ if ((desc_ctrl & CL_DESC_FIRST) && !skb) {
+ p = virt_to_page(buf_addr);
+
+ skb = dev_alloc_skb(MAX_HDR_SIZE + PFE_PKT_HEADROOM + 2);
+ if (unlikely(!skb)) {
+ goto pkt_drop;
+ }
+
+ skb_reserve(skb, PFE_PKT_HEADROOM + 2);
+
+ if (lro_hdr) {
+ data_offset = lro_hdr->data_offset;
+ if (lro_hdr->mss)
+ skb_shinfo(skb)->gso_size = lro_hdr->mss;
+
+ // printk(KERN_INFO "mss: %d, offset: %d, data_offset: %d, len: %d\n", lro_hdr->mss, offset, lro_hdr->data_offset, length);
+ } else {
+ data_offset = MAX_HDR_SIZE;
+ }
+
+ /* We don't need the fragment if the whole packet */
+ /* has been copied in the first linear skb */
+ if (length <= data_offset) {
+ __memcpy(skb->data, buf_addr + offset, length);
+ skb_put(skb, length);
+ free_page((unsigned long)buf_addr);
+ } else {
+ __memcpy(skb->data, buf_addr + offset, data_offset);
+ skb_put(skb, data_offset);
+ skb_add_rx_frag(skb, 0, p, offset + data_offset, length - data_offset);
+ }
+
+ if ((vap->wifi_dev->features & NETIF_F_RXCSUM) && (rx_ctrl & HIF_CTRL_RX_CHECKSUMMED))
+ {
+ skb->ip_summed = CHECKSUM_UNNECESSARY;
+#ifdef VWD_DEBUG_STATS
+ priv->rx_csum_correct++;
+#endif
+ }
+
+ } else {
+ /* Next frags */
+ if (unlikely(!skb)) {
+ printk(KERN_ERR "%s: NULL skb_inflight\n", __func__);
+ goto pkt_drop;
+ }
+
+ p = virt_to_page(buf_addr);
+
+ skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, p, offset, length);
+ }
+
+ /* Last buffer in a software chain */
+ if ((desc_ctrl & CL_DESC_LAST) && !(rx_ctrl & HIF_CTRL_RX_CONTINUED))
+ break;
+
+ /* Keep track of skb for this queue/pe */
+ vap->skb_inflight[qno + pe_id] = skb;
+ }
+
+ vap->skb_inflight[qno + pe_id] = NULL;
+
+ return skb;
+
+pkt_drop:
+ vap->skb_inflight[qno + pe_id] = NULL;
+
+ if (skb) {
+ kfree_skb(skb);
+ } else {
+ free_page((unsigned long)buf_addr);
+ }
+
+ return NULL;
+
+empty:
+ return NULL;
+}
+
+/** pfe_vwd_rx_skb
+ *
+ */
+static struct sk_buff *pfe_vwd_rx_skb(struct vap_desc_s *vap, int qno, unsigned int *ctrl)
+{
+ void *buf_addr;
+ struct hif_ipsec_hdr *ipsec_hdr;
+ unsigned int rx_ctrl;
+ unsigned int desc_ctrl = 0;
+ struct sk_buff *skb = NULL;
+ int length = 0, offset;
+ struct pfe_vwd_priv_s *priv = vap->priv;
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+ struct timespec ktime;
+#endif
+
+ buf_addr = hif_lib_receive_pkt(&vap->client, qno, &length, &offset, &rx_ctrl, &desc_ctrl,(void **) &ipsec_hdr);
+ if (!buf_addr)
+ goto out;
+
+ *ctrl = rx_ctrl;
+#ifdef PFE_VWD_NAPI_STATS
+ priv->napi_counters[NAPI_DESC_COUNT]++;
+#endif
+
+#if defined(CONFIG_COMCERTO_CUSTOM_SKB_LAYOUT)
+ if ((vap->custom_skb) && !(rx_ctrl & HIF_CTRL_RX_WIFI_EXPT)) {
+ /* Even we use smaller area allocate bigger buffer, to meet skb helper function's requirements */
+ skb = dev_alloc_skb(length + offset + 32);
+
+ if (unlikely(!skb)) {
+#ifdef VWD_DEBUG_STATS
+ priv->rx_skb_alloc_fail += 1;
+#endif
+ goto pkt_drop;
+ }
+
+ /**
+ * __memcpy expects src and dst need to be same alignment. So make sure that
+ * skb->data starts at same alignement as buf_addr + offset.
+ */
+ skb_reserve(skb, offset);
+ if (length <= MAX_WIFI_HDR_SIZE) {
+ __memcpy(skb->data, buf_addr + offset, length);
+ skb_put(skb, length);
+ kfree(buf_addr);
+ }
+ else {
+ __memcpy(skb->data, buf_addr + offset, MAX_WIFI_HDR_SIZE);
+ skb_put(skb, length);
+ skb->mspd_data = buf_addr;
+ skb->mspd_len = length - MAX_WIFI_HDR_SIZE;
+ skb->mspd_ofst = offset + MAX_WIFI_HDR_SIZE;
+ }
+ }
+
+ else
+#endif
+ if (rx_ctrl & HIF_CTRL_RX_WIFI_EXPT) {
+#if defined(CONFIG_COMCERTO_ZONE_DMA_NCNB)
+ skb = dev_alloc_skb(length + offset + 32);
+#else
+ skb = alloc_skb_header(PFE_BUF_SIZE, buf_addr, GFP_ATOMIC);
+#endif
+
+ if (unlikely(!skb)) {
+#ifdef VWD_DEBUG_STATS
+ priv->rx_skb_alloc_fail += 1;
+#endif
+ goto pkt_drop;
+ }
+
+ skb_reserve(skb, offset);
+#if defined(CONFIG_COMCERTO_ZONE_DMA_NCNB)
+ /* Since, these packets are going to linux stack,
+ * to avoid NCNB access overhead copy NCNB to CB buffer.
+ */
+ __memcpy(skb->data, buf_addr + offset, length);
+ kfree(buf_addr);
+#endif
+ skb_put(skb, length);
+
+
+ if ((vap->wifi_dev->features & NETIF_F_RXCSUM) && (rx_ctrl & HIF_CTRL_RX_CHECKSUMMED))
+ {
+ skb->ip_summed = CHECKSUM_UNNECESSARY;
+#ifdef VWD_DEBUG_STATS
+ priv->rx_csum_correct++;
+#endif
+ }
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+ if (rx_ctrl & HIF_CTRL_RX_IPSEC_IN) {
+ if (ipsec_hdr) {
+ struct sec_path *sp;
+ struct xfrm_state *x;
+ unsigned short *sah = &ipsec_hdr->sa_handle[0];
+ int i = 0;
+
+ sp = secpath_dup(skb->sp);
+
+ if (!sp)
+ {
+ goto pkt_drop;
+ }
+
+ skb->sp = sp;
+
+ /* at maximum 2 SA are expected */
+ while (i <= 1)
+ {
+ if(!*sah)
+ break;
+
+ if ((x = xfrm_state_lookup_byhandle(dev_net(vap->dev), ntohs(*sah))) == NULL)
+ {
+ goto pkt_drop;
+ }
+
+ sp->xvec[i] = x;
+
+ if (!x->curlft.use_time)
+ {
+ ktime = current_kernel_time();
+ x->curlft.use_time = (unsigned long)ktime.tv_sec;
+ }
+
+ i++; sah++;
+ }
+
+ sp->len = i;
+ }
+ }
+#endif
+
+ }
+ else
+ {
+ skb = alloc_skb_header(PFE_BUF_SIZE, buf_addr, GFP_ATOMIC);
+
+ if (unlikely(!skb)) {
+#ifdef VWD_DEBUG_STATS
+ priv->rx_skb_alloc_fail += 1;
+#endif
+ goto pkt_drop;
+ }
+
+ skb_reserve(skb, offset);
+ skb_put(skb, length);
+ }
+
+
+ return skb;
+
+pkt_drop:
+ if (skb) {
+ kfree_skb(skb);
+ } else {
+ kfree(buf_addr);
+ }
+
+out:
+ return NULL;
+}
+
+/** pfe_vwd_send_to_vap
+ *
+ */
+
+/* The most of the logic inside this function is copied from dev_queue_xmit() in linux/net/core/dev.c.*/
+
+static void pfe_vwd_send_to_vap(struct vap_desc_s *vap, struct sk_buff *skb, struct net_device *dev)
+{
+ struct netdev_queue *txq;
+ int cpu, rc;
+
+ if (!vap->direct_tx_path) {
+ original_dev_queue_xmit(skb);
+ return;
+ }
+
+ /* Disable soft irqs for various locks below. Also
+ * stops preemption for RCU.
+ */
+ rcu_read_lock_bh();
+
+ if (unlikely(dev->real_num_tx_queues != 1)) {
+ //printk("%s : number of queues : %d\n", __func__, dev->real_num_tx_queues);
+ goto deliver_slow;
+ }
+
+ if (dev->flags & IFF_UP) {
+ skb_set_queue_mapping(skb, 0);
+ txq = netdev_get_tx_queue(dev, 0);
+
+ cpu = smp_processor_id();
+
+ if (txq->xmit_lock_owner != cpu) {
+ HARD_TX_LOCK(dev, txq, cpu);
+
+ if (unlikely(netif_tx_queue_stopped(txq))) {
+ //printk("%s : stopped \n", __func__);
+ HARD_TX_UNLOCK(dev, txq);
+ goto deliver_slow;
+ }
+
+ rc = dev->netdev_ops->ndo_start_xmit(skb, dev);
+
+ if (dev_xmit_complete(rc)) {
+ HARD_TX_UNLOCK(dev, txq);
+ goto done;
+ }
+ }
+ }
+
+ rcu_read_unlock_bh();
+ kfree_skb(skb);
+
+ return;
+
+done:
+ //printk("%s : devivered packet through fast path\n", __func__);
+ rcu_read_unlock_bh();
+ return;
+
+deliver_slow:
+ rcu_read_unlock_bh();
+
+ /* deliver packet to vap through stack */
+ original_dev_queue_xmit(skb);
+ return;
+}
+
+/** pfe_vwd_rx_poll
+ *
+ */
+static int pfe_vwd_rx_poll( struct vap_desc_s *vap, struct napi_struct *napi, int qno, int budget)
+{
+ struct sk_buff *skb;
+ int work_done = 0;
+ struct net_device *dev;
+ struct pfe_vwd_priv_s *priv = vap->priv;
+
+ //printk(KERN_INFO"%s\n", __func__);
+ dev = dev_get_by_index(&init_net, vap->ifindex);
+
+#ifdef PFE_VWD_NAPI_STATS
+ priv->napi_counters[NAPI_POLL_COUNT]++;
+#endif
+ do {
+ unsigned int ctrl = 0;
+
+ if (page_mode)
+ skb = pfe_vwd_rx_page(vap, qno, &ctrl);
+ else
+ skb = pfe_vwd_rx_skb(vap, qno, &ctrl);
+
+ if (!skb)
+ break;
+ if(!dev) {
+ /*VAP got disappeared, simply drop the packet */
+ kfree_skb(skb);
+ work_done++;
+ continue;
+ }
+
+ skb->dev = dev;
+ dev->last_rx = jiffies;
+
+#ifdef PFE_VWD_LRO_STATS
+ priv->lro_len_counters[((u32)skb->len >> 11) & (LRO_LEN_COUNT_MAX - 1)]++;
+ priv->lro_nb_counters[skb_shinfo(skb)->nr_frags & (LRO_NB_COUNT_MAX - 1)]++;
+#endif
+ vap->stats.rx_packets++;
+ vap->stats.rx_bytes += skb->len;
+
+ /*FIXME: Need to handle WiFi to WiFi fast path */
+ if (ctrl & HIF_CTRL_RX_WIFI_EXPT) {
+ //printk("%s : packet sent to expt\n", __func__);
+
+ *(unsigned long *)skb->head = 0xdead;
+ skb->protocol = eth_type_trans(skb, dev);
+#ifdef VWD_DEBUG_STATS
+ priv->pkts_slow_forwarded[qno] += 1;
+#endif
+ netif_receive_skb(skb);
+ }
+ else {
+ struct ethhdr *hdr;
+
+ hdr = (struct ethhdr *)skb->data;
+ skb->protocol = hdr->h_proto;
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22))
+ skb->mac.raw = skb->data;
+ skb->nh.raw = skb->data + sizeof(struct ethhdr);
+#else
+ skb_reset_mac_header(skb);
+ skb_set_network_header(skb, sizeof(struct ethhdr));
+#endif
+
+#ifdef VWD_DEBUG_STATS
+ priv->pkts_rx_fast_forwarded[qno] += 1;
+#endif
+ skb->priority = 0;
+
+
+ pfe_vwd_send_to_vap(vap, skb, dev);
+ }
+
+
+ work_done++;
+#ifdef PFE_VWD_NAPI_STATS
+ priv->napi_counters[NAPI_PACKET_COUNT]++;
+#endif
+ } while (work_done < budget);
+
+ if(dev)
+ dev_put(dev);
+
+ /* If no Rx receive nor cleanup work was done, exit polling mode.
+ * No more netif_running(dev) check is required here , as this is checked in
+ * net/core/dev.c ( 2.6.33.5 kernel specific).
+ */
+ if (work_done < budget) {
+ napi_complete(napi);
+
+ hif_lib_event_handler_start(&vap->client, EVENT_RX_PKT_IND, qno);
+ }
+#ifdef PFE_VWD_NAPI_STATS
+ else
+ priv->napi_counters[NAPI_FULL_BUDGET_COUNT]++;
+#endif
+
+ return work_done;
+}
+
+/** pfe_vwd_lro_poll
+ */
+static int pfe_vwd_lro_poll(struct napi_struct *napi, int budget)
+{
+ struct vap_desc_s *vap = container_of(napi, struct vap_desc_s, lro_napi);
+
+
+ return pfe_vwd_rx_poll(vap, napi, 2, budget);
+}
+
+
+/** pfe_eth_low_poll
+ */
+static int pfe_vwd_rx_high_poll(struct napi_struct *napi, int budget)
+{
+ struct vap_desc_s *vap = container_of(napi, struct vap_desc_s, high_napi);
+
+ return pfe_vwd_rx_poll(vap, napi, 1, budget);
+}
+
+/** pfe_eth_high_poll
+ */
+static int pfe_vwd_rx_low_poll(struct napi_struct *napi, int budget )
+{
+ struct vap_desc_s *vap = container_of(napi, struct vap_desc_s, low_napi);
+
+ return pfe_vwd_rx_poll(vap, napi, 0, budget);
+}
+
+/** pfe_vwd_event_handler
+ */
+static int pfe_vwd_event_handler(void *data, int event, int qno)
+{
+ struct vap_desc_s *vap = data;
+
+ //printk(KERN_INFO "%s: %d\n", __func__, __LINE__);
+
+ switch (event) {
+ case EVENT_RX_PKT_IND:
+ if (qno == 0) {
+ if (napi_schedule_prep(&vap->low_napi)) {
+ //printk(KERN_INFO "%s: schedule high prio poll\n", __func__);
+
+ __napi_schedule(&vap->low_napi);
+ }
+ }
+ else if (qno == 1) {
+ if (napi_schedule_prep(&vap->high_napi)) {
+ //printk(KERN_INFO "%s: schedule high prio poll\n", __func__);
+
+ __napi_schedule(&vap->high_napi);
+ }
+ }
+ else if (qno == 2) {
+ if (napi_schedule_prep(&vap->lro_napi)) {
+ //printk(KERN_INFO "%s: schedule lro poll\n", __func__);
+
+ __napi_schedule(&vap->lro_napi);
+ }
+ }
+
+#ifdef PFE_VWD_NAPI_STATS
+ vap->priv->napi_counters[NAPI_SCHED_COUNT]++;
+#endif
+ break;
+
+ case EVENT_TXDONE_IND:
+ case EVENT_HIGH_RX_WM:
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+/** pfe_vwd_fast_tx_timeout
+ */
+static enum hrtimer_restart pfe_vwd_fast_tx_timeout(struct hrtimer *timer)
+{
+ struct pfe_eth_fast_timer *fast_tx_timeout = container_of(timer, struct pfe_eth_fast_timer, timer);
+ struct vap_desc_s *vap = container_of(fast_tx_timeout->base, struct vap_desc_s, fast_tx_timeout);
+
+ if(netif_queue_stopped(vap->dev)) {
+#ifdef PFE_VWD_TX_STATS
+ vap->was_stopped[fast_tx_timeout->queuenum] = 1;
+#endif
+ netif_wake_queue(vap->dev);
+ }
+
+ return HRTIMER_NORESTART;
+}
+
+/** pfe_eth_fast_tx_timeout_init
+ */
+static void pfe_vwd_fast_tx_timeout_init(struct vap_desc_s *vap)
+{
+ int i;
+ for (i = 0; i < VWD_TXQ_CNT; i++) {
+ vap->fast_tx_timeout[i].queuenum = i;
+ hrtimer_init(&vap->fast_tx_timeout[i].timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+ vap->fast_tx_timeout[i].timer.function = pfe_vwd_fast_tx_timeout;
+ vap->fast_tx_timeout[i].base = vap->fast_tx_timeout;
+ }
+}
+
+static int pfe_vwd_might_stop_tx(struct vap_desc_s *vap, int queuenum, unsigned int n_desc)
+{
+ int tried = 0;
+ ktime_t kt;
+
+try_again:
+ if (unlikely((__hif_tx_avail(&pfe->hif) < n_desc)
+ || (hif_lib_tx_avail(&vap->client, queuenum) < n_desc))) {
+
+ if (!tried) {
+ hif_tx_unlock(&pfe->hif);
+ pfe_vwd_flush_txQ(vap, queuenum, 1, n_desc);
+ tried = 1;
+ hif_tx_lock(&pfe->hif);
+ goto try_again;
+ }
+#ifdef PFE_VWD_TX_STATS
+ if (__hif_tx_avail(&pfe->hif) < n_desc)
+ vap->stop_queue_hif[queuenum]++;
+ else if (hif_lib_tx_avail(&vap->client, queuenum) < n_desc) {
+ vap->stop_queue_hif_client[queuenum]++;
+ }
+ vap->stop_queue_total[queuenum]++;
+#endif
+ netif_stop_queue(vap->dev);
+
+ kt = ktime_set(0, COMCERTO_TX_FAST_RECOVERY_TIMEOUT_MS * NSEC_PER_MSEC);
+ hrtimer_start(&vap->fast_tx_timeout[queuenum].timer, kt, HRTIMER_MODE_REL);
+ return -1;
+ }
+ else {
+ return 0;
+ }
+}
+
+#define SA_MAX_OP 2
+
+/**
+ * pfe_vwd_xmit_local_packet()
+ */
+static int pfe_vwd_vap_xmit_local_packet(struct sk_buff *skb, struct net_device *dev)
+{
+ struct vap_desc_s *vap = netdev_priv(dev);
+ struct skb_shared_info *sh;
+ int queuenum = 0, n_desc = 0, n_segs;
+ int count = 0, nr_frags;
+ int ii;
+ u32 ctrl = HIF_CTRL_TX_WIFI;
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+ u16 sah[SA_MAX_OP] = {0};
+ struct hif_ipsec_hdr *hif_ipsec;
+#endif
+
+ pfe_tx_get_req_desc(skb, &n_desc, &n_segs);
+
+ spin_lock_bh(&pfe->vwd.vaplock);
+ spin_lock_bh(&vap->tx_lock[queuenum]);
+ hif_tx_lock(&pfe->hif);
+
+ if (pfe_vwd_might_stop_tx(vap, queuenum, n_desc)){
+ hif_tx_unlock(&pfe->hif);
+ spin_unlock_bh(&vap->tx_lock[queuenum]);
+ spin_unlock_bh(&pfe->vwd.vaplock);
+#ifdef PFE_VWD_TX_STATS
+ if(vap->was_stopped[queuenum]) {
+ vap->clean_fail[queuenum]++;
+ vap->was_stopped[queuenum] = 0;
+ }
+#endif
+ return NETDEV_TX_BUSY;
+ }
+
+
+ if ( !(skb_is_gso(skb)) && (skb_headroom(skb) < (PFE_PKT_HEADER_SZ + sizeof(unsigned long)))) {
+
+ //printk(KERN_INFO "%s: copying skb %d\n", __func__, skb_headroom(skb));
+
+ if (pskb_expand_head(skb, (PFE_PKT_HEADER_SZ + sizeof(unsigned long)), 0, GFP_ATOMIC)) {
+ kfree_skb(skb);
+ goto out;
+ }
+ }
+
+ /* Send vap_id to PFE */
+ ctrl |= vap->vapid << HIF_CTRL_VAPID_OFST;
+ sh = skb_shinfo(skb);
+
+ if (skb_is_gso(skb)) {
+ int nr_bytes;
+
+ if(likely(nr_bytes = pfe_tso(skb, &vap->client, &pfe->vwd.tso, queuenum, ctrl))) {
+ vap->stats.tx_packets += sh->gso_segs;
+ vap->stats.tx_bytes += nr_bytes;
+ }
+ else
+ vap->stats.tx_dropped++;
+
+ goto out;
+ }
+
+ if (skb->ip_summed == CHECKSUM_PARTIAL)
+ ctrl |= HIF_CTRL_TX_CHECKSUM;
+
+ nr_frags = sh->nr_frags;
+
+#if defined(CONFIG_INET_IPSEC_OFFLOAD) || defined(CONFIG_INET6_IPSEC_OFFLOAD)
+ /* check if packet sent from Host to PFE needs IPsec processing */
+ if (skb->ipsec_offload)
+ {
+ if (skb->sp)
+ {
+ for (ii = skb->sp->len-1; ii >= 0; ii--)
+ {
+ struct xfrm_state *x = skb->sp->xvec[ii];
+ sah[ii] = htons(x->handle);
+ }
+
+ ctrl |= HIF_CTRL_TX_IPSEC_OUT;
+
+ /* add SA info to the hif header*/
+ hif_ipsec = (struct hif_ipsec_hdr *)(skb->data - sizeof(struct hif_ipsec_hdr));
+ hif_ipsec->sa_handle[0] = sah[0];
+ hif_ipsec->sa_handle[1] = sah[1];
+
+ skb->data -= sizeof(struct hif_ipsec_hdr);
+ skb->len += sizeof(struct hif_ipsec_hdr);
+ }
+ else
+ printk(KERN_ERR "%s: secure path data not found\n", __func__);
+ }
+#endif
+
+ if (nr_frags) {
+ skb_frag_t *f;
+
+ __hif_lib_xmit_pkt(&vap->client, queuenum, skb->data, skb_headlen(skb), ctrl, HIF_FIRST_BUFFER, skb);
+
+ for (ii = 0; ii < nr_frags - 1; ii++) {
+ f = &sh->frags[ii];
+
+ __hif_lib_xmit_pkt(&vap->client, queuenum, skb_frag_address(f), skb_frag_size(f), 0x0, 0x0, skb);
+ }
+
+ f = &sh->frags[ii];
+
+ __hif_lib_xmit_pkt(&vap->client, queuenum, skb_frag_address(f), skb_frag_size(f), 0x0, HIF_LAST_BUFFER|HIF_DATA_VALID, skb);
+
+#ifdef VWD_DEBUG_STATS
+ pfe->vwd.pkts_local_tx_sgs += 1;
+#endif
+ }
+ else
+ {
+ __hif_lib_xmit_pkt(&vap->client, queuenum, skb->data, skb->len, ctrl, HIF_FIRST_BUFFER | HIF_LAST_BUFFER | HIF_DATA_VALID, skb);
+ }
+
+ hif_tx_dma_start();
+
+#ifdef VWD_DEBUG_STATS
+ pfe->vwd.pkts_transmitted += 1;
+#endif
+ vap->stats.tx_packets++;
+ vap->stats.tx_bytes += skb->len;
+
+ //printk(KERN_INFO "%s: pkt sent successfully skb:%p len:%d\n", __func__, skb, skb->len);
+
+out:
+ hif_tx_unlock(&pfe->hif);
+
+ dev->trans_start = jiffies;
+
+ // Recycle buffers if a socket's send buffer becomes half full or if the HIF client queue starts filling up
+ if (((count = (hif_lib_tx_pending(&vap->client, queuenum) - HIF_CL_TX_FLUSH_MARK)) > 0)
+ || (skb && skb->sk && ((sk_wmem_alloc_get(skb->sk) << 1) > skb->sk->sk_sndbuf)))
+ pfe_vwd_flush_txQ(vap, queuenum, 1, count);
+
+ spin_unlock_bh(&vap->tx_lock[queuenum]);
+ spin_unlock_bh(&pfe->vwd.vaplock);
+
+ return 0;
+}
+
+/**
+ * pfe_vwd_get_stats()
+ */
+
+static struct net_device_stats *pfe_vwd_vap_get_stats(struct net_device *dev)
+{
+ struct vap_desc_s *vap = netdev_priv(dev);
+
+ return &vap->stats;
+}
+
+static const struct net_device_ops vwd_netdev_ops = {
+ .ndo_start_xmit = pfe_vwd_vap_xmit_local_packet,
+ .ndo_get_stats = pfe_vwd_vap_get_stats,
+};
+
+/**
+ * pfe_vwd_vap_get_drvinfo - Fills in the drvinfo structure with some basic info
+ *
+ */
+static void pfe_vwd_vap_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
+{
+ strncpy(drvinfo->driver, "VWD", COMCERTO_INFOSTR_LEN);
+ strncpy(drvinfo->version, "1.0", COMCERTO_INFOSTR_LEN);
+ strncpy(drvinfo->fw_version, "N/A", COMCERTO_INFOSTR_LEN);
+ strncpy(drvinfo->bus_info, "N/A", COMCERTO_INFOSTR_LEN);
+ drvinfo->testinfo_len = 0;
+ drvinfo->regdump_len = 0;
+ drvinfo->eedump_len = 0;
+}
+
+struct ethtool_ops pfe_vwd_vap_ethtool_ops = {
+ .get_drvinfo = pfe_vwd_vap_get_drvinfo,
+};
+
+/** pfe_vwd_vap_up
+ *
+ */
+
+static struct vap_desc_s *pfe_vwd_vap_up(struct pfe_vwd_priv_s *vwd, struct vap_cmd_s *cmd, struct net_device *wifi_dev)
+{
+ struct vap_desc_s *vap = NULL;
+ struct net_device *dev;
+ struct hif_client_s *client;
+ int ii, rc;
+ int vap_unlocked = 0;
+ unsigned char name[IFNAMSIZ];
+
+ printk("%s:%d\n", __func__, __LINE__);
+
+ sprintf(name, "vwd%d", cmd->vapid);
+
+ dev = alloc_etherdev(sizeof(*vap));
+
+ if (!dev) {
+ printk(KERN_ERR "%s : Unable to allocate device structure for %s\n", __func__, cmd->ifname);
+ goto err0;
+ }
+
+ vap = netdev_priv(dev);
+ vap->vapid = cmd->vapid;
+ vap->ifindex = wifi_dev->ifindex;
+ vap->direct_rx_path = cmd->direct_rx_path;
+ vap->direct_tx_path = 0;
+ memcpy(vap->ifname, wifi_dev->name, 12);
+ memcpy(vap->macaddr, wifi_dev->dev_addr, 6);
+
+ vap->wifi_dev = wifi_dev;
+ vap->dev = dev;
+ vap->priv = vwd;
+ vap->cpu_id = -1;
+ dev->netdev_ops = &vwd_netdev_ops;
+
+ dev->mtu = 1500;
+ dev->flags |= IFF_NOARP;
+
+ if (dev_alloc_name(dev, name) < 0) {
+ netdev_err(dev, "%s: dev_alloc_name(%s) failed\n", __func__, name);
+ goto err1;
+ }
+
+ /* FIXME: Assuming that vwd_tx_ofld is NAS mode. But tx_ofld_mode is required for HGW also
+ * to perform encryption for WiFi locat Tx IPSec packets.
+ */
+ if (vwd_tx_ofld) {
+ /* FIXME : We need to backup wifi device ethtool ops and override required functions
+ * with our own function which will enable required functionality for both WiFi
+ * and vwd network device.
+ */
+ vap->wifi_ethtool_ops = wifi_dev->ethtool_ops;
+
+ if (!wifi_dev->ethtool_ops)
+ wifi_dev->ethtool_ops = &pfe_vwd_vap_ethtool_ops;
+
+ /* supported features */
+ dev->hw_features = NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
+ NETIF_F_SG | NETIF_F_TSO;
+
+ /* enabled by default */
+ dev->features = dev->hw_features;
+ if (lro_mode) {
+ dev->hw_features |= NETIF_F_LRO;
+ dev->features |= NETIF_F_LRO;
+ }
+
+ /* Enable offloading features to offload device/interface */
+ if (!(wifi_dev->hw_features & NETIF_F_RXCSUM))
+ vap->diff_hw_features |= NETIF_F_RXCSUM;
+
+ if (!(wifi_dev->hw_features & NETIF_F_IP_CSUM))
+ vap->diff_hw_features |= NETIF_F_IP_CSUM;
+
+ if (!(wifi_dev->hw_features & NETIF_F_IPV6_CSUM))
+ vap->diff_hw_features |= NETIF_F_IPV6_CSUM;
+
+ if (!(wifi_dev->hw_features & NETIF_F_SG))
+ vap->diff_hw_features |= NETIF_F_SG;
+
+ if (!(wifi_dev->hw_features & NETIF_F_TSO))
+ vap->diff_hw_features |= NETIF_F_TSO;
+
+ if (lro_mode) {
+ if (!(wifi_dev->hw_features & NETIF_F_LRO))
+ vap->diff_hw_features |= NETIF_F_LRO;
+ }
+
+ wifi_dev->hw_features |= vap->diff_hw_features;
+ }
+
+ if (spin_is_locked(&vwd->vaplock)) {
+ spin_unlock_bh(&vwd->vaplock);
+ vap_unlocked = 1;
+ }
+
+ rc = register_netdev(dev);
+
+ if (vap_unlocked)
+ spin_lock_bh(&vwd->vaplock);
+
+ if (rc) {
+ netdev_err(dev, "register_netdev() failed\n");
+ goto err1;
+ }
+
+ /* Initilize NAPI for Rx processing */
+ netif_napi_add(vap->dev, &vap->low_napi, pfe_vwd_rx_low_poll, VWD_RX_POLL_WEIGHT);
+ netif_napi_add(vap->dev, &vap->high_napi, pfe_vwd_rx_high_poll, VWD_RX_POLL_WEIGHT);
+ netif_napi_add(vap->dev, &vap->lro_napi, pfe_vwd_lro_poll, VWD_RX_POLL_WEIGHT);
+ napi_enable(&vap->high_napi);
+ napi_enable(&vap->low_napi);
+ napi_enable(&vap->lro_napi);
+ pfe_vwd_fast_tx_timeout_init(vap);
+
+ vap->vap_kobj = kobject_create_and_add(vap->ifname, &pfe->dev->kobj);
+ if (!vap->vap_kobj) {
+ printk(KERN_ERR "%s : Failed to create kobject\n", __func__);
+ goto err2;
+ }
+
+ if (sysfs_create_group(vap->vap_kobj, &vap_attr_group)) {
+ printk(KERN_ERR "%s : Failed to create sysfs entries \n", __func__);
+ goto err3;
+ }
+
+
+ /* Register VWD Client driver with HIF */
+ client = &vap->client;
+ memset(client, 0, sizeof(*client));
+ client->id = PFE_CL_VWD0 + vap->vapid;
+ client->tx_qn = VWD_TXQ_CNT;
+ client->rx_qn = VWD_RXQ_CNT;
+ client->priv = vap;
+ client->pfe = pfe;
+ client->event_handler = pfe_vwd_event_handler;
+ client->user_cpu_id = vap->cpu_id;
+
+ /* FIXME : For now hif lib sets all tx and rx queues to same size */
+ client->tx_qsize = EMAC_TXQ_DEPTH;
+ client->rx_qsize = EMAC_RXQ_DEPTH;
+
+ if (hif_lib_client_register(client)) {
+ printk(KERN_ERR"%s: hif_lib_client_register(%d) failed\n", __func__, client->id);
+ goto err4;
+ }
+
+ for (ii = 0; ii < VWD_TXQ_CNT; ii++)
+ spin_lock_init(&vap->tx_lock[ii]);
+
+ if (vwd_tx_ofld) {
+ dev_get_by_index(&init_net, dev->ifindex);
+ wifi_dev->wifi_offload_dev = dev;
+
+ rtnl_lock();
+ wifi_dev->flags |= IFF_WIFI_OFLD;
+ dev->flags |= IFF_UP;
+ netif_tx_wake_all_queues(dev);
+ set_bit(__LINK_STATE_START, &dev->state);
+ dev_activate(dev);
+ rtnl_unlock();
+ }
+
+ vwd->vaps[cmd->vapid] = vap;
+ if (!vwd->vap_count) {
+ printk("%s: Tx recover Timer started...\n", __func__);
+ add_timer(&vwd->tx_timer);
+ }
+
+ vwd->vap_count++;
+
+ return vap;
+
+err4:
+ sysfs_remove_group(vap->vap_kobj, &vap_attr_group);
+
+err3:
+ kobject_put(vap->vap_kobj);
+
+err2:
+ napi_disable(&vap->high_napi);
+ napi_disable(&vap->low_napi);
+ napi_disable(&vap->lro_napi);
+ spin_unlock_bh(&pfe->vwd.vaplock);
+ unregister_netdev(dev);
+ spin_lock_bh(&pfe->vwd.vaplock);
+err1:
+ free_netdev(dev);
+err0:
+ return NULL;
+}
+
+/** pfe_vwd_vap_down
+ *
+ */
+static void pfe_vwd_vap_down(struct vap_desc_s *vap)
+{
+ int i;
+ int vap_unlocked = 0;
+ struct net_device *dev = vap->dev;
+
+ printk("%s:%d\n", __func__, __LINE__);
+ pfe->vwd.vap_count--;
+ pfe->vwd.vaps[vap->vapid] = NULL;
+ netif_stop_queue(vap->dev);
+
+ for (i = 0; i < VWD_TXQ_CNT; i++)
+ hrtimer_cancel(&vap->fast_tx_timeout[i].timer);
+
+ pfe_vwd_flush_tx(vap, 1);
+ hif_lib_client_unregister(&vap->client);
+ napi_disable(&vap->high_napi);
+ napi_disable(&vap->low_napi);
+ napi_disable(&vap->lro_napi);
+ sysfs_remove_group(vap->vap_kobj, &vap_attr_group);
+ kobject_put(vap->vap_kobj);
+
+ /* FIXME Assuming that vwd_tx_ofld is NAS mode */
+ if (vwd_tx_ofld) {
+ struct net_device *wifi_dev = dev_get_by_name(&init_net, vap->ifname);
+
+ if (wifi_dev) {
+ wifi_dev->ethtool_ops = vap->wifi_ethtool_ops;
+ wifi_dev->wifi_offload_dev = NULL;
+ rtnl_lock();
+ wifi_dev->flags &= ~IFF_WIFI_OFLD;
+ wifi_dev->hw_features &= ~vap->diff_hw_features;
+ wifi_dev->features &= ~vap->diff_hw_features;
+ rtnl_unlock();
+ dev_put(wifi_dev);
+ }
+
+ rtnl_lock();
+ vap->dev->flags &= ~(IFF_UP);
+ rtnl_unlock();
+ vap->diff_hw_features = 0;
+ dev_put(dev);
+ }
+
+ if (spin_is_locked(&pfe->vwd.vaplock)) {
+ spin_unlock_bh(&pfe->vwd.vaplock);
+ vap_unlocked = 1;
+ }
+
+ if (!pfe->vwd.vap_count) {
+ printk("%s: Tx recover Timer stopped...\n", __func__);
+ del_timer_sync(&pfe->vwd.tx_timer);
+ }
+
+
+ unregister_netdev(dev);
+
+ if (vap_unlocked)
+ spin_lock_bh(&pfe->vwd.vaplock);
+
+ free_netdev(dev);
+}
+
+/**
+ * pfe_vwd_vap_event_hanler
+ */
+static void pfe_vwd_vap_event_hanler(struct work_struct *work)
+{
+ struct pfe_vwd_priv_s *priv = container_of(work, struct pfe_vwd_priv_s, event);
+ struct net_device *wifi_dev;
+ struct vap_cmd_s vap_cmd;
+ struct vap_desc_s *vap;
+ int ii;
+
+ printk("%s: %s\n", __func__, priv->name);
+
+ spin_lock(&priv->conf_lock);
+ spin_lock_bh(&priv->vaplock);
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++) {
+ if (!strlen(priv->conf_vap_names[ii]))
+ continue;
+
+ wifi_dev = dev_get_by_name(&init_net, priv->conf_vap_names[ii]);
+ if (wifi_dev && !priv->vaps[ii] && (wifi_dev->flags & IFF_UP)) {
+
+ vap_cmd.vapid = ii;
+ strcpy(vap_cmd.ifname, priv->conf_vap_names[ii]);
+ vap_cmd.direct_rx_path = 0;
+ if ((vap = pfe_vwd_vap_up(priv, &vap_cmd, wifi_dev))) {
+ printk("%s:ADD: name:%s, vapid:%d, direct_rx_path : %s, ifindex:%d, mac:%x:%x:%x:%x:%x:%x\n",
+ __func__, vap->ifname, vap->vapid,
+ vap->direct_rx_path ? "ON":"OFF", wifi_dev->ifindex,
+ wifi_dev->dev_addr[0], wifi_dev->dev_addr[1],
+ wifi_dev->dev_addr[2], wifi_dev->dev_addr[3],
+ wifi_dev->dev_addr[4], wifi_dev->dev_addr[5] );
+
+ }
+ else {
+ printk(KERN_ERR "%s: Unable to add VAP (%s)\n", __func__, vap_cmd.ifname);
+ }
+ }
+
+ if (wifi_dev)
+ dev_put(wifi_dev);
+ }
+
+
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++) {
+ if (!priv->vaps[ii])
+ continue;
+
+ wifi_dev = dev_get_by_name(&init_net, priv->conf_vap_names[ii]);
+
+ if ( (wifi_dev && !(wifi_dev->flags & IFF_UP)) || !wifi_dev)
+ pfe_vwd_vap_down(priv->vaps[ii]);
+
+ if (wifi_dev)
+ dev_put(wifi_dev);
+ }
+ spin_unlock_bh(&priv->vaplock);
+ spin_unlock(&priv->conf_lock);
+
+}
+
+
+/** pfe_vwd_handle_vap
+ *
+ */
+static int pfe_vwd_handle_vap( struct pfe_vwd_priv_s *vwd, struct vap_cmd_s *cmd )
+{
+ struct vap_desc_s *vap;
+ int rc = 0, ii;
+ struct net_device *dev;
+
+
+ printk("%s function called %d: %s\n", __func__, cmd->action, cmd->ifname);
+
+ dev = dev_get_by_name(&init_net, cmd->ifname);
+
+ if ((!dev) && ((cmd->action != REMOVE) && (cmd->action != RESET)))
+ return -EINVAL;
+
+
+ switch( cmd->action )
+ {
+ case ADD:
+ /* Find free VAP */
+
+ if( cmd->vapid >= MAX_VAP_SUPPORT )
+ {
+ rc = -EINVAL;
+ goto done;
+ }
+
+
+ if (vwd->vaps[cmd->vapid])
+ {
+ rc = -EINVAL;
+ break;
+ }
+
+ if ((vap = pfe_vwd_vap_up(vwd, cmd, dev))) {
+ printk("%s:ADD: name:%s, vapid:%d, direct_rx_path : %s, ifindex:%d, mac:%x:%x:%x:%x:%x:%x\n",
+ __func__, vap->ifname, vap->vapid,
+ vap->direct_rx_path ? "ON":"OFF", vap->ifindex,
+ vap->macaddr[0], vap->macaddr[1],
+ vap->macaddr[2], vap->macaddr[3],
+ vap->macaddr[4], vap->macaddr[5] );
+ }
+ else {
+ printk(KERN_ERR "%s: Unable to add VAP (%s)\n", __func__, cmd->ifname);
+ }
+ break;
+
+ case REMOVE:
+ /* Find VAP to be removed*/
+ if (cmd->vapid >= MAX_VAP_SUPPORT)
+ {
+ rc = -EINVAL;
+ goto done;
+ }
+
+ vap = vwd->vaps[cmd->vapid];
+
+ if (!vap)
+ {
+ rc = 0;
+ goto done;
+ }
+
+ printk("%s:REMOVE: name:%s, vapid:%d ifindex:%d mac:%x:%x:%x:%x:%x:%x\n", __func__,
+ vap->ifname, vap->vapid, vap->ifindex,
+ vap->macaddr[0], vap->macaddr[1],
+ vap->macaddr[2], vap->macaddr[3],
+ vap->macaddr[4], vap->macaddr[5] );
+
+ pfe_vwd_vap_down(vap);
+
+
+ break;
+
+ case UPDATE:
+ /* Find VAP to be updated */
+
+ if( cmd->vapid >= MAX_VAP_SUPPORT )
+ {
+ rc = -EINVAL;
+ goto done;
+ }
+
+ vap = vwd->vaps[cmd->vapid];
+
+ if (!vap)
+ {
+ rc = -EINVAL;
+ goto done;
+ }
+
+ printk("%s:UPDATE: old mac:%x:%x:%x:%x:%x:%x\n", __func__,
+ vap->macaddr[0], vap->macaddr[1],
+ vap->macaddr[2], vap->macaddr[3],
+ vap->macaddr[4], vap->macaddr[5] );
+
+ /* Not yet implemented */
+ memcpy(vap->macaddr, cmd->macaddr, 6);
+
+ printk("%s:UPDATE: name:%s, vapid:%d ifindex:%d mac:%x:%x:%x:%x:%x:%x\n", __func__,
+ vap->ifname, vap->vapid, vap->ifindex,
+ vap->macaddr[0], vap->macaddr[1],
+ vap->macaddr[2], vap->macaddr[3],
+ vap->macaddr[4], vap->macaddr[5] );
+ break;
+
+ case RESET:
+ /* Remove all VAPs */
+ printk("%s: Removing fastpath vaps\n", __func__);
+ for (ii = 0; (ii < MAX_VAP_SUPPORT) && vwd->vap_count; ii++) {
+ vap = vwd->vaps[ii];
+ if (vap) {
+ pfe_vwd_vap_down(vap);
+ }
+ }
+ break;
+
+
+ default:
+ rc = -EINVAL;
+
+ }
+done:
+
+ if(dev)
+ dev_put(dev);
+
+
+ return rc;
+
+}
+
+#define SIOCVAPUPDATE ( 0x6401 )
+
+/** pfe_vwd_ioctl
+ *
+ */
+static long
+pfe_vwd_ioctl(struct file * file, unsigned int cmd, unsigned long arg)
+{
+ struct vap_cmd_s vap_cmd;
+ void __user *argp = (void __user *)arg;
+ int rc;
+ struct pfe_vwd_priv_s *priv = (struct pfe_vwd_priv_s *)file->private_data;
+
+ printk("%s: start\n", __func__);
+ switch(cmd) {
+ case SIOCVAPUPDATE:
+ if (copy_from_user(&vap_cmd, argp, sizeof(struct vap_cmd_s)))
+ return -EFAULT;
+
+ spin_lock_bh(&priv->vaplock);
+ rc = pfe_vwd_handle_vap(priv, &vap_cmd);
+ spin_unlock_bh(&priv->vaplock);
+
+ return rc;
+ }
+ printk("%s: end\n", __func__);
+
+ return -EOPNOTSUPP;
+}
+
+
+/** vwd_open
+ *
+ */
+ static int
+pfe_vwd_open(struct inode *inode, struct file *file)
+{
+ int result = 0;
+ unsigned int dev_minor = MINOR(inode->i_rdev);
+
+#if defined (CONFIG_COMCERTO_VWD_MULTI_MAC)
+ printk( "%s : Multi MAC mode enabled\n", __func__);
+#endif
+ printk( "%s : minor device -> %d\n", __func__, dev_minor);
+ if (dev_minor != 0)
+ {
+ printk(KERN_ERR ": trying to access unknown minor device -> %d\n", dev_minor);
+ result = -ENODEV;
+ goto out;
+ }
+
+ file->private_data = &pfe->vwd;
+
+out:
+ return result;
+}
+
+/** vwd_close
+ *
+ */
+ static int
+pfe_vwd_close(struct inode * inode, struct file * file)
+{
+ printk( "%s \n", __func__);
+
+ return 0;
+}
+
+struct file_operations vwd_fops = {
+unlocked_ioctl: pfe_vwd_ioctl,
+ open: pfe_vwd_open,
+ release: pfe_vwd_close,
+};
+
+
+/** pfe_vwd_up
+ *
+ */
+static int pfe_vwd_up(struct pfe_vwd_priv_s *priv )
+{
+ int ii;
+
+ printk("%s: start\n", __func__);
+
+ nf_register_hook(&vwd_hook);
+ nf_register_hook(&vwd_hook_ipv6);
+
+ if (pfe_vwd_sysfs_init(priv))
+ goto err0;
+
+ priv->fast_path_enable = 0;
+ priv->fast_bridging_enable = 0;
+ priv->fast_routing_enable = 1;
+
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++)
+ priv->vaps[ii] = NULL;
+
+ comcerto_wifi_rx_fastpath_register(vwd_wifi_if_send_pkt);
+
+ if (vwd_tx_ofld) {
+ priv->event_queue = create_workqueue("vwd_events");
+ INIT_WORK(&priv->event, pfe_vwd_vap_event_hanler);
+
+ register_netdevice_notifier(&vwd_vap_notifier);
+ }
+ return 0;
+
+err0:
+ nf_unregister_hook(&vwd_hook);
+ nf_unregister_hook(&vwd_hook_ipv6);
+
+ return -1;
+}
+
+/** pfe_vwd_down
+ *
+ */
+static int pfe_vwd_down( struct pfe_vwd_priv_s *priv )
+{
+ int ii;
+
+ printk(KERN_INFO "%s: %s\n", priv->name, __func__);
+
+ comcerto_wifi_rx_fastpath_unregister();
+
+ if( priv->fast_bridging_enable )
+ {
+ nf_unregister_hook(&vwd_hook_bridge);
+ }
+
+ if( priv->fast_routing_enable )
+ {
+ nf_unregister_hook(&vwd_hook);
+ nf_unregister_hook(&vwd_hook_ipv6);
+ }
+
+ /*Stop Tx recovery timer and cleanup all vaps*/
+ if (priv->vap_count) {
+ printk("%s: Tx recover Timer stopped...\n", __func__);
+ del_timer_sync(&priv->tx_timer);
+ }
+
+ for (ii = 0; ii < MAX_VAP_SUPPORT; ii++)
+ {
+ if (priv->vaps[ii]) {
+ pfe_vwd_vap_down(priv->vaps[ii]);
+ }
+ }
+
+ if (vwd_tx_ofld) {
+ unregister_netdevice_notifier(&vwd_vap_notifier);
+ flush_workqueue(priv->event_queue);
+ destroy_workqueue(priv->event_queue);
+ }
+
+
+ priv->vap_count = 0;
+ pfe_vwd_sysfs_exit();
+
+ return 0;
+}
+
+/** pfe_vwd_driver_init
+ *
+ * PFE wifi offload:
+ * - uses HIF functions to receive/send packets
+ */
+
+static int pfe_vwd_driver_init( struct pfe_vwd_priv_s *priv )
+{
+ printk("%s: start\n", __func__);
+
+ strcpy(priv->name, "vwd");
+
+ spin_lock_init(&priv->vaplock);
+ spin_lock_init(&priv->conf_lock);
+ priv->pfe = pfe;
+
+ pfe_vwd_up(priv);
+ printk("%s: end\n", __func__);
+ return 0;
+}
+
+/** vwd_driver_remove
+ *
+ */
+static int pfe_vwd_driver_remove(void)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+
+ pfe_vwd_down(priv);
+
+ return 0;
+}
+
+/** pfe_vwd_init
+ *
+ */
+int pfe_vwd_init(struct pfe *pfe)
+{
+ struct pfe_vwd_priv_s *priv ;
+ int rc = 0;
+
+ printk(KERN_INFO "%s\n", __func__);
+ priv = &pfe->vwd;
+ memset(priv, 0, sizeof(*priv));
+
+
+ rc = alloc_chrdev_region(&priv->char_devno,VWD_MINOR, VWD_MINOR_COUNT, VWD_DRV_NAME);
+ if (rc < 0) {
+ printk(KERN_ERR "%s: alloc_chrdev_region() failed\n", __func__);
+ goto err0;
+ }
+
+ cdev_init(&priv->char_dev, &vwd_fops);
+ priv->char_dev.owner = THIS_MODULE;
+
+ rc = cdev_add (&priv->char_dev, priv->char_devno, VWD_DEV_COUNT);
+ if (rc < 0) {
+ printk(KERN_ERR "%s: cdev_add() failed\n", __func__);
+ goto err1;
+ }
+
+ printk(KERN_INFO "%s: created vwd device(%d, %d)\n", __func__, MAJOR(priv->char_devno),
+ MINOR(priv->char_devno));
+
+ priv->pfe = pfe;
+
+ priv->tx_timer.data = (unsigned long)priv;
+ priv->tx_timer.function = pfe_vwd_tx_timeout;
+ priv->tx_timer.expires = jiffies + ( COMCERTO_TX_RECOVERY_TIMEOUT_MS * HZ )/1000;
+ init_timer(&priv->tx_timer);
+
+ if( pfe_vwd_driver_init( priv ) )
+ goto err1;
+
+ return 0;
+
+err1:
+
+ unregister_chrdev_region(priv->char_devno, VWD_MINOR_COUNT);
+
+err0:
+ return rc;
+}
+
+/** pfe_vwd_exit
+ *
+ */
+void pfe_vwd_exit(struct pfe *pfe)
+{
+ struct pfe_vwd_priv_s *priv = &pfe->vwd;
+
+ printk(KERN_INFO "%s\n", __func__);
+
+ pfe_vwd_driver_remove();
+ cdev_del(&priv->char_dev);
+ unregister_chrdev_region(priv->char_devno, VWD_MINOR_COUNT);
+}
+
+#else /* !CFG_WIFI_OFFLOAD */
+
+/** pfe_vwd_init
+ *
+ */
+int pfe_vwd_init(struct pfe *pfe)
+{
+ printk(KERN_INFO "%s\n", __func__);
+ return 0;
+}
+
+/** pfe_vwd_exit
+ *
+ */
+void pfe_vwd_exit(struct pfe *pfe)
+{
+ printk(KERN_INFO "%s\n", __func__);
+}
+
+#endif /* !CFG_WIFI_OFFLOAD */
+
diff --git a/pfe_ctrl/pfe_vwd.h b/pfe_ctrl/pfe_vwd.h
new file mode 100644
index 0000000..7d7aed4
--- /dev/null
+++ b/pfe_ctrl/pfe_vwd.h
@@ -0,0 +1,128 @@
+#ifndef _PFE_VWD_H_
+#define _PFE_VWD_H_
+
+#include <linux/cdev.h>
+#include <linux/interrupt.h>
+#include "pfe_tso.h"
+
+
+#define PFE_VWD_TX_STATS
+#define PFE_VWD_LRO_STATS
+#define PFE_VWD_NAPI_STATS
+#define VWD_DEBUG_STATS
+#define VWD_TXQ_CNT 16
+#define VWD_RXQ_CNT 3
+
+#define PFE_WIFI_PKT_HEADROOM 96 /*PFE inserts this headroom for WiFi tx packets only in lro mode */
+
+#define VWD_MINOR 0
+#define VWD_MINOR_COUNT 1
+#define VWD_DRV_NAME "vwd"
+#define VWD_DEV_COUNT 1
+#define VWD_RX_POLL_WEIGHT HIF_RX_POLL_WEIGHT - 16
+
+struct vap_desc_s {
+ struct kobject *vap_kobj;
+ struct net_device *dev;
+ struct net_device *wifi_dev;
+ const struct ethtool_ops *wifi_ethtool_ops;
+ struct pfe_vwd_priv_s *priv;
+ unsigned int ifindex;
+ unsigned int diff_hw_features;
+ struct hif_client_s client;
+ struct net_device dummy_dev;
+ struct napi_struct low_napi;
+ struct napi_struct high_napi;
+ struct napi_struct lro_napi;
+ spinlock_t tx_lock[VWD_TXQ_CNT];
+ struct sk_buff *skb_inflight[VWD_RXQ_CNT + 6];
+ struct pfe_eth_fast_timer fast_tx_timeout[VWD_TXQ_CNT];
+ struct net_device_stats stats;
+ int cpu_id;
+ unsigned char ifname[12];
+ unsigned char macaddr[6];
+ unsigned short vapid;
+ unsigned short programmed;
+ unsigned short bridged;
+ unsigned short direct_rx_path; /* Direct path support from offload device=>VWD */
+ unsigned short direct_tx_path; /* Direct path support from offload VWD=>device */
+ unsigned short custom_skb; /* Customized skb model from VWD=>offload_device */
+#ifdef PFE_VWD_TX_STATS
+ unsigned int stop_queue_total[VWD_TXQ_CNT];
+ unsigned int stop_queue_hif[VWD_TXQ_CNT];
+ unsigned int stop_queue_hif_client[VWD_TXQ_CNT];
+ unsigned int clean_fail[VWD_TXQ_CNT];
+ unsigned int was_stopped[VWD_TXQ_CNT];
+#endif
+};
+
+
+
+struct vap_cmd_s {
+ int action;
+#define ADD 0
+#define REMOVE 1
+#define UPDATE 2
+#define RESET 3
+ int ifindex;
+ unsigned short vapid;
+ unsigned short direct_rx_path;
+ unsigned char ifname[12];
+ unsigned char macaddr[6];
+};
+
+
+
+struct pfe_vwd_priv_s {
+
+ struct pfe *pfe;
+ unsigned char name[12];
+
+ struct cdev char_dev;
+ int char_devno;
+
+ struct vap_desc_s *vaps[MAX_VAP_SUPPORT];
+ char conf_vap_names[MAX_VAP_SUPPORT][IFNAMSIZ];
+ int vap_count;
+ int vap_programmed_count;
+ int vap_bridged_count;
+ spinlock_t vaplock;
+ spinlock_t conf_lock;
+ struct timer_list tx_timer;
+ struct tso_cb_s tso;
+ struct workqueue_struct *event_queue;
+ struct work_struct event;
+
+#ifdef PFE_VWD_LRO_STATS
+ unsigned int lro_len_counters[LRO_LEN_COUNT_MAX];
+ unsigned int lro_nb_counters[LRO_NB_COUNT_MAX]; //TODO change to exact max number when RX scatter done
+#endif
+#ifdef PFE_VWD_NAPI_STATS
+ unsigned int napi_counters[NAPI_MAX_COUNT];
+#endif
+ int fast_path_enable;
+ int fast_bridging_enable;
+ int fast_routing_enable;
+ int tso_hook_enable;
+
+#ifdef VWD_DEBUG_STATS
+ u32 pkts_local_tx_sgs;
+ u32 pkts_total_local_tx;
+ u32 pkts_local_tx_csum;
+ u32 pkts_transmitted;
+ u32 pkts_slow_forwarded[VWD_RXQ_CNT];
+ u32 pkts_tx_dropped;
+ u32 pkts_rx_fast_forwarded[VWD_RXQ_CNT];
+ u32 rx_skb_alloc_fail;
+ u32 rx_csum_correct;
+#endif
+
+ u32 msg_enable;
+
+};
+
+
+int pfe_vwd_init(struct pfe *pfe);
+void pfe_vwd_exit(struct pfe *pfe);
+
+#endif /* _PFE_VWD_H_ */
diff --git a/pfe_ctrl/platform.h b/pfe_ctrl/platform.h
new file mode 100644
index 0000000..4f0ded4
--- /dev/null
+++ b/pfe_ctrl/platform.h
@@ -0,0 +1,6 @@
+#ifndef _PLATFORM_H_
+#define _PLATFORM_H_
+
+#define virt_to_phys(virt) ((unsigned long)virt)
+
+#endif /* _PLATFORM_H_ */
diff --git a/pfe_ctrl/version.h b/pfe_ctrl/version.h
new file mode 100644
index 0000000..102974d
--- /dev/null
+++ b/pfe_ctrl/version.h
@@ -0,0 +1,7 @@
+/*Auto-generated file. Do not edit !*/
+#ifndef VERSION_H
+#define VERSION_H
+
+#define PFE_CTRL_VERSION "pfe_ctrl_10_00_6"
+
+#endif /* VERSION_H */
