# General-purpose GNU make include file
#
# Copyright (C) 2017, Broadcom. All Rights Reserved.
# 
# Permission to use, copy, modify, and/or distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
# 
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
# SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#
#
# <<Broadcom-WL-IPTag/Open:>>
#
# $Id: Makefile 506823 2014-10-07 12:59:32Z $
#
ifdef _WLAN_COMMON_MK
  $(if $D,$(info Info: Avoiding redundant include ($(MAKEFILE_LIST))))
else	# _WLAN_COMMON_MK
  _WLAN_COMMON_MK := 1
unexport _WLAN_COMMON_MK	# in case of make -e

################################################################
# Summary and Namespace Rules
################################################################
#   This is a special makefile fragment intended for common use.
# The most important design principle is that it defines variables
# and functions only within a tightly controlled namespace.
# If a make include file is used to set rules, pattern rules,
# or well known variables like CFLAGS, it can have unexpected
# effects on the including makefile with the result that people
# either stop including it or stop changing it.
# Therefore, the only way to keep this a file which can be
# safely included by any GNU makefile and extended at will is
# to allow it only to set variables and only in its own namespace.
#   The namespace is "WLAN_CamelCase" for normal variables,
# "wlan_lowercase" for functions, and WLAN_UPPERCASE for boolean
# "constants" (these are all really just make variables; only the
# usage patterns differ).
#   Internal (logically file-scoped) variables are prefixed with "-"
# and have no other namespace restrictions.
#   Every variable defined here should match one of these patterns.

################################################################
# Enforce required conditions
################################################################

ifneq (,$(filter 3.7% 3.80,$(MAKE_VERSION)))
  $(error $(MAKE): Error: version $(MAKE_VERSION) too old, 3.81+ required)
endif

################################################################
# Store this makefile's path before MAKEFILE_LIST gets changed.
################################################################

WLAN_Common := $(lastword $(MAKEFILE_LIST))

################################################################
# Derive including makefile since it's a little tricky.
################################################################

WLAN_Makefile := $(abspath $(lastword $(filter-out $(lastword $(MAKEFILE_LIST)),$(MAKEFILE_LIST))))

################################################################
# Shiny new ideas, can be enabled via environment for testing.
################################################################

ifdef WLAN_MakeBeta
  $(info Info: BUILDING WITH "WLAN_MakeBeta" ENABLED!)
  SHELL := /bin/bash
  #.SUFFIXES:
  #MAKEFLAGS += -r
endif

################################################################
# Allow a makefile to force this file into all child makes.
################################################################

ifdef WLAN_StickyCommon
  export MAKEFILES := $(MAKEFILES) $(abspath $(lastword $(MAKEFILE_LIST)))
endif

################################################################
# Host type determination
################################################################

_common-uname-s := $(shell uname -s)

# Typically this will not be tested explicitly; it's the default condition.
WLAN_HOST_TYPE := unix

ifneq (,$(filter Linux,$(_common-uname-s)))
  WLAN_LINUX_HOST := 1
else ifneq (,$(filter CYGWIN%,$(_common-uname-s)))
  WLAN_CYGWIN_HOST := 1
  WLAN_WINDOWS_HOST := 1
else ifneq (,$(filter Darwin,$(_common-uname-s)))
  WLAN_MACOS_HOST := 1
  WLAN_BSD_HOST := 1
else ifneq (,$(filter FreeBSD NetBSD,$(_common-uname-s)))
  WLAN_BSD_HOST := 1
else ifneq (,$(filter SunOS%,$(_common-uname-s)))
  WLAN_SOLARIS_HOST := 1
endif

################################################################
# Utility variables
################################################################

empty :=
space := $(empty) $(empty)
comma := ,

################################################################
# Utility functions
################################################################

# Provides enhanced-format messages from make logic.
wlan_die = $(error Error: $1)
wlan_warning = $(warning Warning: $1)
wlan_info = $(info Info: $1)

# Debug function to enable make verbosity.
wlan_dbg = $(if $D,$(call wlan_info,$1))

# Debug function to expose values of the listed variables.
wlan_dbgv = $(foreach _,$1,$(call wlan_dbg,$_=$($_)))

# Make-time assertion.
define wlan_assert
  ifeq (,$(findstring clean,$(MAKECMDGOALS)))
    $(if $1,,$(call wlan_die,$2))
  endif
endef

# Checks for the presence of an option in an option string
# like "aaa-bbb-ccc-ddd".
wlan_opt = $(if $(findstring -$1-,-$2-),1,0)

# The purpose of this macro is to avoid the need for full directory
# paths to be created via mkdir -p since mkdir -p has an inherent
# race in parallel use cases. Interestingly, though it exists to
# make -p unnecessary, it actually uses -p. Why is that? It's to
# take advantage of a useful side effect of -p which is that it
# doesn't complain if the directory already exists. In other words
# it creates directories one at a time to avoid creating its own
# race but still uses mkdir -p to protect itself against races with
# unrelated make processes.
# Usage: $(call wlan_target_needs_dir,<target>,<dir-path>)
define wlan_target_needs_dir
$(eval
$$1: | $$2
$$2: | $$(filter-out .,$$(patsubst %/,%,$$(dir $$2))); mkdir -p $$@
ifneq (,$$(findstring /,$$2))
  $$(call wlan_target_needs_dir,$$1,$$(patsubst %/,%,$$(dir $$2)))
endif
)
endef

# Compares two dotted numeric strings (e.g 2.3.16.1) for $1 >= $2
define wlan_version_ge
$(findstring TRUE,$(shell bash -c 'sort -cu -t. -k1,1nr -k2,2nr -k3,3nr -k4,4nr <(echo -e "$2\n$1") 2>&1 || echo TRUE'))
endef

# This is a useful macro to wrap around a compiler command line,
# e.g. "$(call wlan_cc,<command-line>). It organizes flags in a
# readable way while taking care not to change any ordering
# which matters. It also provides a hook for externally
# imposed C flags which can be passed in from the top level.
# This would be the best place to add a check for
# command line length. Requires a $(strlen) function;
# GMSL has one.
define wlan_cc
$(filter-out -D% -I%,$1) $(filter -D%,$1) $(filter -I%,$1) $(WLAN_EXTERNAL_CFLAGS)
endef

# Applies the standard cygpath translation for a path on Cygwin.
define wlan_cygpath
$(if $(WLAN_CYGWIN_HOST),$(shell cygpath -m $1),$1)
endef

# Change case without requiring a shell.
wlan_tolower = $(subst A,a,$(subst B,b,$(subst C,c,$(subst D,d,$(subst E,e,$(subst F,f,$(subst G,g,\
$(subst H,h,$(subst I,i,$(subst J,j,$(subst K,k,$(subst L,l,$(subst M,m,$(subst N,n,$(subst O,o,\
$(subst P,p,$(subst Q,q,$(subst R,r,$(subst S,s,$(subst T,t,$(subst U,u,$(subst V,v,$(subst W,w,\
$(subst X,x,$(subst Y,y,$(subst Z,z,$1))))))))))))))))))))))))))

wlan_toupper = $(subst a,A,$(subst b,B,$(subst c,C,$(subst d,D,$(subst e,E,$(subst f,F,$(subst g,G,\
$(subst h,H,$(subst i,I,$(subst j,J,$(subst k,K,$(subst l,L,$(subst m,M,$(subst n,N,$(subst o,O,\
$(subst p,P,$(subst q,Q,$(subst r,R,$(subst s,S,$(subst t,T,$(subst u,U,$(subst v,V,$(subst w,W,\
$(subst x,X,$(subst y,Y,$(subst z,Z,$1))))))))))))))))))))))))))

# This macro derives the base (aka root) of the entire "checkout tree" as well as the
# current "build tree" and "component tree" (svn or git checkout).
# Definitions:
# - Checkout Tree: the root of the full tree of files retrieved from SCM. May comprise
#   any number of individual checkouts, potentially from different branches, repos,
#   or even SCM tools.
# - Build Tree: the root of a coherent subtree within the checkout tree, sufficient to
#   build some subset of the required deliverables.
# - Component Tree: the root of a single component within the build tree, generally a
#   single checkout from svn or git.
# These could all have the same value but more often a component is a subdir of a build
# tree which may be a subdir of a DEPS checkout. The only guaranteed relationship is that
# each component tree is within a build tree which is within the unitary checkout tree.
# Returns a list: [checkout-tree, build-tree, component-tree]
# Notes:
# 1. We've observed a bug, or at least a surprising behavior, in emake which causes
# $(realpath ...) to fail. That's why a $(shell ...) fallback is used below.
# 2. There may be no SCM metadata at all, particularly in the case of a source package
# delivered to a customer. This is where guessing (as described below) comes in.
# 3. This macro always trusts .wlbase if present. It looks next for a .gclient
# file, then sparsefile_url.py. If none of these are found we have to guess starting
# from the location of this file. If a ../../../main file exists from here, set the
# base there. Otherwise set it at ../.. from here.
define wlan_basedirs
$(eval\
  _refdir := $$(realpath $$(or $1,$$(dir $$(lastword $$(MAKEFILE_LIST)))))
  _refdir ?= $$(shell cd $$(or $1,$$(dir $$(lastword $$(MAKEFILE_LIST)))) && pwd -P)
  _parts := $$(strip $$(subst /,$$(space),$$(subst \,/,$$(_refdir))))
  _paths := /
  $$(foreach _i,$$(_parts),$$(eval _paths += $$(addsuffix /$$(_i),$$(lastword $$(_paths)))))
  _paths := $$(patsubst //%,/%,$$(wordlist 2,$$(words $$(_paths)),$$(_paths)))
  _wlb := $$(patsubst %/,%,$$(dir $$(lastword $$(wildcard $$(addsuffix /.wlbase,$$(_paths))))))
  _dep := $$(patsubst %/,%,$$(dir $$(lastword $$(wildcard $$(addsuffix /.gclient,$$(_paths))))))
  ifndef _dep
    _sprs := $$(subst /.svn/sparsefile_url.py,,$$(lastword $$(wildcard $$(addsuffix /.svn/sparsefile_url.py,$$(_paths)))))
    ifndef _sprs
      _guess := $$(strip $$(if $$(wildcard $$(dir $$(abspath $$(WLAN_Common)))../../../main),\
	$$(abspath $$(dir $$(WLAN_Common))../../..),\
	$$(abspath $$(dir $$(WLAN_Common))../..)))
    endif  # _sprs
  endif  # _dep
  _arg3 := $$(patsubst %/,%,$$(dir $$(lastword $$(wildcard $$(addsuffix /.svn,$$(_paths)) $$(addsuffix /.git,$$(_paths))))))
  _arg2 := $$(abspath $$(_refdir)/../..)
  _arg1 := $$(or $$(_wlb),$$(_dep),$$(_sprs),$$(_guess),$$(_arg3))
)$(strip $(_arg1) $(_arg2) $(_arg3))
endef

################################################################
# Standard make variables
################################################################

# The WLAN_CheckoutBaseA variable points to the root of the entire
# checkout while WLAN_TreeBaseA points to the root of the current
# build tree and WLAN_ComponentBaseA points to the root of the
# component containing the including Makefile. They could have the
# values values but in other cases such as DHDAP routers a single
# DEPS checkout may contain multiple build trees (potentially from
# different branches) with each build tree composed of multiple components.
# These 'A' variables are absolute paths; each has an 'R' variant
# which is relative.
ifndef WLAN_TreeBaseA
  _basedata := $(call wlan_basedirs)
  WLAN_CheckoutBaseA := $(word 1,$(_basedata))
  WLAN_TreeBaseA := $(word 2,$(_basedata))
  WLAN_ComponentBaseA := $(word 3,$(_basedata))
  ifdef WLAN_CYGWIN_HOST
    WLAN_TreeBaseA := $(shell cygpath -m -a $(WLAN_TreeBaseA))
  endif
endif

# Pick up the "relpath" make function from the same dir as this makefile.
include $(dir $(lastword $(MAKEFILE_LIST)))RelPath.mk

# The *R variables are relativized versions of the *A variables.
WLAN_CheckoutBaseR = $(call relpath,$(WLAN_CheckoutBaseA))
WLAN_TreeBaseR = $(call relpath,$(WLAN_TreeBaseA))
WLAN_ComponentBaseR = $(call relpath,$(WLAN_ComponentBaseA))

# For compatibility, due to the prevalence of $(SRCBASE)
WLAN_SrcBaseA := $(WLAN_TreeBaseA)/src
WLAN_SrcBaseR  = $(patsubst %/,%,$(dir $(WLAN_TreeBaseR)))

# Show makefile list before we start including things.
$(call wlan_dbgv, CURDIR MAKEFILE_LIST)

################################################################
# Pick up the "universal settings file" containing
# the list of all available software components.
################################################################

include $(dir $(lastword $(MAKEFILE_LIST)))../tools/release/WLAN.usf

################################################################
# Calculate paths to requested components.
################################################################

# This uses pattern matching to pull component paths from
# their basenames (e.g. src/wl/xyz => xyz).
# It also strips out component paths which don't currently exist.
# This may be required due to our "sparse tree" build styles
# and the fact that linux mkdep throws an error when a directory
# specified with -I doesn't exist.
define _common-component-names-to-rel-paths
$(strip \
  $(patsubst $(WLAN_TreeBaseA)/%,%,$(wildcard $(addprefix $(WLAN_TreeBaseA)/,\
  $(sort $(foreach name,$(if $1,$1,$(WLAN_COMPONENT_PATHS)),$(filter %/$(name),$(WLAN_COMPONENT_PATHS))))))))
endef

# It's also possible to request the full set with a literal '*'.
ifeq (,$(WLAN_ComponentsInUse))
  WLAN_ComponentsInUse		:= $(sort $(notdir $(WLAN_COMPONENT_PATHS)))
  # $(call wlan_die,no SW component request)
else ifeq (*,$(WLAN_ComponentsInUse))
  WLAN_ComponentsInUse		:= $(sort $(notdir $(WLAN_COMPONENT_PATHS)))
  # $(call wlan_info,all SW components requested ("$(WLAN_ComponentsInUse)"))
else
  WLAN_ComponentsInUse		:= $(sort $(WLAN_ComponentsInUse))
endif

# For backward compatibility we accept certain old component names from older
# branches and convert them to their updated names here.
WLAN_ComponentsInUse := $(sort $(subst phymods,phy,$(WLAN_ComponentsInUse)))

# Translate the resulting list of components names to paths.
WLAN_ComponentPathsInUse	:= $(call _common-component-names-to-rel-paths,$(WLAN_ComponentsInUse))

# Loop through all components in use. If a cfg-xyz.mk file exists at the base of
# component xyz's subtree, include it and use its contents to modify the list
# of include and src dirs. Otherwise, use the defaults for that component.
# Also generate a WLAN_ComponentBaseDir_xyz variable for each component "xyz".
WLAN_ComponentIncPathsInUse :=
WLAN_ComponentSrcPathsInUse :=
$(foreach _path,$(WLAN_ComponentPathsInUse), \
  $(if $(wildcard $(WLAN_TreeBaseA)/$(_path)/cfg-$(notdir $(_path)).mk),$(eval include $(WLAN_TreeBaseA)/$(_path)/cfg-$(notdir $(_path)).mk)) \
  $(eval $(notdir $(_path))_IncDirs ?= include) \
  $(eval $(notdir $(_path))_SrcDirs ?= src) \
  $(eval WLAN_ComponentIncPathsInUse += $(addprefix $(_path)/,$($(notdir $(_path))_IncDirs))) \
  $(eval WLAN_ComponentSrcPathsInUse += $(addprefix $(_path)/,$($(notdir $(_path))_SrcDirs))) \
  $(eval WLAN_ComponentBaseDir_$$(notdir $(_path)) := $$(WLAN_TreeBaseA)/$(_path)) \
)

# Global include/source path
WLAN_StdSrcDirs = src/shared src/wl/sys src/bcmcrypto
WLAN_StdSrcDirs += components/clm-api/src
WLAN_StdIncDirs = src/include components/shared
WLAN_StdIncDirs += components/clm-api/include
WLAN_SrcIncDirs = src/shared src/wl/sys src/bcmcrypto \
	src/wl/keymgmt/src src/wl/iocv/src \
	components/drivers/wl/shim/src src/wl/proxd/src src/wl/mesh/src \
	src/wl/randmac/src

WLAN_StdSrcDirsR	 = $(addprefix $(WLAN_TreeBaseR)/,$(WLAN_StdSrcDirs))
WLAN_StdIncDirsR	 = $(addprefix $(WLAN_TreeBaseR)/,$(WLAN_StdIncDirs))
WLAN_SrcIncDirsR	 = $(addprefix $(WLAN_TreeBaseR)/,$(WLAN_SrcIncDirs))
WLAN_StdIncPathR	 = $(addprefix -I,$(wildcard $(WLAN_StdIncDirsR)))
WLAN_IncDirsR		 = $(WLAN_StdIncDirsR) $(WLAN_SrcIncDirsR)
WLAN_IncPathR		 = $(addprefix -I,$(wildcard $(WLAN_IncDirsR)))

WLAN_StdSrcDirsA	 = $(addprefix $(WLAN_TreeBaseA)/,$(WLAN_StdSrcDirs))
WLAN_StdIncDirsA	 = $(addprefix $(WLAN_TreeBaseA)/,$(WLAN_StdIncDirs))
WLAN_SrcIncDirsA	 = $(addprefix $(WLAN_TreeBaseA)/,$(WLAN_SrcIncDirs))
WLAN_StdIncPathA	 = $(addprefix -I,$(wildcard $(WLAN_StdIncDirsA)))
WLAN_IncDirsA		 = $(WLAN_StdIncDirsA) $(WLAN_SrcIncDirsA)
WLAN_IncPathA		 = $(addprefix -I,$(wildcard $(WLAN_IncDirsA)))

# Public convenience macros based on WLAN_ComponentPathsInUse list.
WLAN_ComponentSrcDirsR	 = $(addprefix $(WLAN_TreeBaseR)/,$(WLAN_ComponentSrcPathsInUse))
WLAN_ComponentIncDirsR	 = $(addprefix $(WLAN_TreeBaseR)/,$(WLAN_ComponentIncPathsInUse))
WLAN_ComponentIncPathR	 = $(addprefix -I,$(wildcard $(WLAN_ComponentIncDirsR)))

WLAN_ComponentSrcDirsA	 = $(addprefix $(WLAN_TreeBaseA)/,$(WLAN_ComponentSrcPathsInUse))
WLAN_ComponentIncDirsA	 = $(addprefix $(WLAN_TreeBaseA)/,$(WLAN_ComponentIncPathsInUse))
WLAN_ComponentIncPathA	 = $(addprefix -I,$(wildcard $(WLAN_ComponentIncDirsA)))

WLAN_ComponentSrcDirs	 = $(WLAN_ComponentSrcDirsA)
WLAN_ComponentIncDirs	 = $(WLAN_ComponentIncDirsA)
WLAN_ComponentIncPath	 = $(WLAN_ComponentIncPathA)

# Dump a representative sample of derived variables in debug mode.
$(call wlan_dbgv, WLAN_TreeBaseA WLAN_TreeBaseR WLAN_SrcBaseA WLAN_SrcBaseR \
    WLAN_ComponentPathsInUse WLAN_ComponentIncPath WLAN_ComponentIncPathR \
    WLAN_ComponentSrcDirs WLAN_ComponentSrcDirsR)

# Special case for Windows to reflect CL in the build log if used.
ifdef WLAN_WINDOWS_HOST
  ifdef CL
    $(info Info: CL=$(CL))
  endif
endif

# A big hammer for debugging each shell invocation.
# Warning: this can get lost if a sub-makefile sets SHELL explicitly, and
# in that case the parent should add $(WLAN_ShellDebugSHELL) to the call.
ifeq ($D,2)
  WLAN_ShellDebug := 1
endif
ifdef WLAN_ShellDebug
  ORIG_SHELL := $(SHELL)
  SHELL = $(strip $(warning Shell: ORIG_SHELL=$(ORIG_SHELL) PATH=$(PATH))$(ORIG_SHELL)) -x
  WLAN_ShellDebugSHELL := SHELL='$$(warning Shell: ORIG_SHELL=$$(ORIG_SHELL) PATH=$$(PATH))$(ORIG_SHELL) -x'
endif

# Variables of general utility.
WLAN_Perl := perl
WLAN_Python := python
WLAN_WINPFX ?= Z:

# These macros are used to stash an extra copy of generated source files,
# such that when a source release is made those files can be reconstituted
# from the stash during builds. Required if the generating tools or inputs
# are not shipped.
define wlan_copy_to_gen
  $(if $(WLAN_COPY_GEN),&& mkdir -p $(subst $(abspath $2),$(abspath $2/$(WLAN_GEN_BASEDIR)),$(dir $(abspath $1))) && \
    cp -pv $1 $(subst $(abspath $2),$(abspath $2/$(WLAN_GEN_BASEDIR)),$(abspath $1).GEN))
endef

############################################################################
# CLM function; Generates a rule to run ClmCompiler iff the XML exists.
# USAGE: $(call WLAN_GenClmCompilerRule,target-dir,src-base[,flags])
#     $1 is the directory where the generated .c file goes (it must exist)
#     $2 gives the base of the WL driver tree (SRCBASE).
#     $3 is an optional set of flags to pass to ClmCompiler.
#   The ClmCompiler options are concatenated from three places.
#     1) The optional $3 argument
#     2) The make variable CLMCOMPEXTFLAGS which is by default --obfuscate
#        but can be overridden AFTER the WLAN_GenClmCompilerRule usage
#     3) --config $(CLM_TYPE) if ($CLM_TYPE) is defined.  CLM_TYPE
#        represent the basename, without the .clm, of a ClmCompiler
#        config that is expected to be in src/wl/clm/types directory.
#        If $(CLM_TYPE) is defined, a dependency to that .clm will
#        be added.
#   The created ClmCompiler rule will use/depend on a xml file.  This will be
# src/wl/clm/private/wlc_clm_data_$CLM_TYPE).xml if it exists else
# components/clm/clm-private/wlc_clm_data.xml will be used.  This allows you
# to use a xml file that corresponds to the .clm being used.
#   This macro uses GNU make's eval function to generate an
# explicit rule to generate a particular CLM data file each time
# it's called. Make variables which should be evaluated during eval
# processing get one $, those which must defer till "runtime" get $$.
#   The "clm_compiled" phony target is provided for makefiles which need
# to defer some other processing until CLM data is ready, and "clm_clean"
# and "CLM_DATA_FILES" make it easier for internal client makefiles to
# clean up CLM data (externally, this is treated as source and not removed).
#   The outermost conditional allows this rule to become a no-op
# in external settings where there is no XML input file while allowing
# it to turn back on automatically if an XML file is provided.
#   A vpath is used to find the XML input because this file is not allowed
# to be present in external builds. Use of vpath allows it to be "poached"
# from the internal build as necessary.
#   Note: the .c file is listed with and without a path due to the way the
# Linux kernel Makefiles generate .depend data.
CLMCOMPEXTFLAGS := --obfuscate
define WLAN_GenClmCompilerRule
$(eval\
.PHONY: clm_compiled clm_clean

# The "mkdir -p foo 2>/dev/null || test -d foo || mkdir -p foo" logic below is
# intended to defeat potential race conditions. If the first mkdir fails we
# check whether we just lost the race to create it; if it still doesn't exist
# there must be some other problem so we run mkdir again to generate
# the appropriate error message and die.
$1: ; mkdir -p $$@ 2>/dev/null || test -d $$@ || mkdir -p $$@
vpath wlc_clm_data.c $1 $$(abspath $1)
ifneq (,$(or $(wildcard $(addsuffix /../components/clm-private/wlc_clm_data.xml,$2 $2/../../src $2/../../../src)),$(wildcard $(addsuffix /wl/clm/private/wlc_clm_data_$(CLM_TYPE).xml,$2 $2/../../src $2/../../../src))))
  vpath wlc_clm_data.xml $(wildcard $(addsuffix /../components/clm-private,$2 $2/../../src $2/../../../src))
  vpath wlc_clm_data_$(CLM_TYPE).xml $(addsuffix /wl/clm/private,$2 $2/../../src $2/../../../src)
  vpath %.clm $(addsuffix /wl/clm/types,$2 $2/../../src $2/../../../src)
  $1/wlc_clm_data.c: \
      $$(if $$(wildcard $2/wl/clm/private/wlc_clm_data_$$(CLM_TYPE).xml),$2/wl/clm/private/wlc_clm_data_$$(CLM_TYPE).xml,wlc_clm_data.xml) \
      $2/../components/clm-api/include/wlc_clm_data.h \
      $$(wildcard $2/../components/clm-bin/ClmCompiler.py) \
      $$(if $$(CLM_TYPE),$$(CLM_TYPE).clm) \
      | $1; \
    @echo wlc_clm_data.c rule -- $$@: $$+ ;\
    $$(strip $$(firstword $$(wildcard $$(addsuffix /components/clm-bin/ClmCompiler.py, $2/.. $2/../.. $2/../../..))) \
      --clmapi_include_dir $$(firstword $$(wildcard $$(addsuffix components/clm-api/include, $2/../ $2/../../ $2/../../../ ))) \
      --print_options --bcmwifi_include_dir $$(firstword $$(wildcard $$(addsuffix shared/bcmwifi/include, $2/ $2/../../src/ $2/../../../src/ ))) \
      $$(if $$(CLM_TYPE),--config_file $$(lastword $$^)) $3 $(CLMCOMPEXTFLAGS) $$< $$@ $$(call wlan_copy_to_gen,$$@,$2))
else
  vpath %.GEN $(subst $(abspath $2),$(abspath $2/$(WLAN_GEN_BASEDIR)),$1) $(sort $(patsubst %/,%,$(dir $(wildcard $(subst $(abspath $2),$(abspath $2/$(WLAN_GEN_BASEDIR)),$(dir $1))*/*.GEN))))
  $1/%: %.GEN ; cp -pv $$< $$@
endif
  clm_compiled: $1/wlc_clm_data.c
  clm_clean:: ; $$(RM) $1/wlc_clm_data.c
  CLM_DATA_FILES += $1/wlc_clm_data.c
)
endef

################################################################
# Generates rule that generates wlc_sar_tbl.c file
# USAGE: $(call WLAN_GenSarTblRule,target-dir,src-base,[sar-files])
# Arguments:
# target-dir -- Directory where generated wlc_sar_tbl.c shall be put.
# src-base   -- Top level 'src' directory. Strange manipulations with
#               it within macro expansion are due to some strange
#               peculiarities of Linux driver builds
# sar_files  -- Space-separated list of base names of .csv files that
#               contain SAR entries that shall be put to generated SAR
#               table. Empty means use all files in src/wl/sar directory
define WLAN_GenSarTblRule
$(eval\
$1/wlc_sar_tbl.c: ; $$(firstword $$(wildcard \
    $$(addsuffix /components/tools/bin/sar_conv.py, $2/.. $2/../.. $2/../../..))) create_c \
    --driver_dir $$(addsuffix /../.., $$(firstword $$(wildcard \
    $$(addsuffix /include, $2 $2/../../src $2/../../../src)))) \
    $$(addprefix $$(firstword $$(wildcard \
    $$(addsuffix /wl/sar, $2 $2/../../src $2/../../../src)))/, \
    $$(if $3,$3,*.csv)) $$@
)
endef

################################################################

endif	# _WLAN_COMMON_MK