Ticket #1371: regenerate_ath_hal_api.pl

#!/usr/bin/perl
strict;
use warnings;
require 'dumpvar.pl';

#
# Settings
# 
$path_to_ah_h = '../hal/ah.h';
$path_to_ath_hal_api_h = '../ath_hal/ath_hal_api.h';
$path_to_ath_hal_api_c = '../ath_hal/ath_hal_api.c';

#
# Name Mappings
# 
my %function_names = (
                     "ah_beaconInit"               => "ath_hal_beaconinit"
                   , "ah_disablePhyErrDiag"        => "ath_hal_disablePhyDiag"
                   , "ah_enablePhyErrDiag"         => "ath_hal_enablePhyDiag"
                   , "ah_enableReceive"            => "ath_hal_rxena"
                   , "ah_fillTxDesc"               => "ath_hal_filltxdesc"
                   , "ah_getAckCTSRate"            => "ath_hal_getackctsrate"
                   , "ah_setAckCTSRate"            => "ath_hal_setackctsrate"
                   , "ah_updateMibCounters"        => "ath_hal_updatemibcounters"
                   , "ah_getAntennaSwitch"         => "ath_hal_getantennaswitch"
                   , "ah_setAntennaSwitch"         => "ath_hal_setantennaswitch"
                   , "ah_getAckTimeout"            => "ath_hal_getacktimeout"
                   , "ah_getBssIdMask"             => "ath_hal_getbssidmask"
                   , "ah_getCapability"            => "ath_hal_getcapability"
                   , "ah_getChanNoise"             => "ath_hal_get_channel_noise"
                   , "ah_getCTSTimeout"            => "ath_hal_getctstimeout"
                   , "ah_getDefAntenna"            => "ath_hal_getdefantenna"
                   , "ah_getDiagState"             => "ath_hal_getdiagstate"
                   , "ah_getInterrupts"            => "ath_hal_intrget"
                   , "ah_getKeyCacheSize"          => "ath_hal_keycachesize"
                   , "ah_getMacAddress"            => "ath_hal_getmac"
                   , "ah_getPendingInterrupts"     => "ath_hal_getisr"
                   , "ah_getPowerMode"             => "ath_hal_getPowerMode"
                   , "ah_getRateTable"             => "ath_hal_getratetable"
                   , "ah_getRfGain"                => "ath_hal_getrfgain"
                   , "ah_getRxDP"                  => "ath_hal_getrxbuf"
                   , "ah_getRxFilter"              => "ath_hal_getrxfilter"
                   , "ah_getSlotTime"              => "ath_hal_getslottime"
                   , "ah_getTsf32"                 => "ath_hal_gettsf32"
                   , "ah_getTsf64"                 => "ath_hal_gettsf64"
                   , "ah_getTxDP"                  => "ath_hal_gettxbuf"
                   , "ah_getTxIntrQueue"           => "ath_hal_gettxintrtxqs"
                   , "ah_getTxQueueProps"          => "ath_hal_gettxqueueprops"
                   , "ah_gpioCfgOutput"            => "ath_hal_gpioCfgOutput"
                   , "ah_gpioSet"                  => "ath_hal_gpioset"
                   , "ah_gpioGet"                  => "ath_hal_gpioget"
                   , "ah_gpioSetIntr"              => "ath_hal_gpiosetintr"
                   , "ah_gpioCfgInput"             => "ath_hal_gpiCfgInput"
                   , "ah_isInterruptPending"       => "ath_hal_intrpend"
                   , "ah_isKeyCacheEntryValid"     => "ath_hal_keyisvalid"
                   , "ah_numTxPending"             => "ath_hal_numtxpending"
                   , "ah_perCalibration"           => "ath_hal_calibrate"
                   , "ah_phyDisable"               => "ath_hal_phydisable"
                   , "ah_disable"                  => "ath_hal_disable"
                   , "ah_procMibEvent"             => "ath_hal_mibevent"
                   , "ah_procRxDesc"               => "ath_hal_rxprocdesc"
                   , "ah_procTxDesc"               => "ath_hal_txprocdesc"
                   , "ah_radarWait"                => "ath_hal_radar_wait"
                   , "ah_releaseTxQueue"           => "ath_hal_releasetxqueue"
                   , "ah_reqTxIntrDesc"            => "ath_hal_txreqintrdesc"
                   , "ah_reset"                    => "ath_hal_reset"
                   , "ah_resetKeyCacheEntry"       => "ath_hal_keyreset"
                   , "ah_resetStationBeaconTimers" => "ath_hal_beaconreset"
                   , "ah_resetTsf"                 => "ath_hal_resettsf"
                   , "ah_resetTxQueue"             => "ath_hal_resettxqueue"
                   , "ah_rxMonitor"                => "ath_hal_rxmonitor"
                   , "ah_setAckTimeout"            => "ath_hal_setacktimeout"
                   , "ah_setBssIdMask"             => "ath_hal_setbssidmask"
                   , "ah_setCapability"            => "ath_hal_setcapability"
                   , "ah_setChannel"               => "ath_hal_setchannel"
                   , "ah_setCoverageClass"         => "ath_hal_setcoverageclass"
                   , "ah_setCTSTimeout"            => "ath_hal_setctstimeout"
                   , "ah_setDecompMask"            => "ath_hal_setdecompmask"
                   , "ah_setDefAntenna"            => "ath_hal_setdefantenna"
                   , "ah_setInterrupts"            => "ath_hal_intrset"
                   , "ah_setKeyCacheEntry"         => "ath_hal_keyset"
                   , "ah_setKeyCacheEntryMac"      => "ath_hal_keysetmac"
                   , "ah_setLedState"              => "ath_hal_setledstate"
                   , "ah_setMacAddress"            => "ath_hal_setmac"
                   , "ah_setMulticastFilter"       => "ath_hal_setmcastfilter"
                   , "ah_setMulticastFilterIndex"  => "ath_hal_setmcastfilterindex"
                   , "ah_setPCUConfig"             => "ath_hal_setopmode"
                   , "ah_setPowerMode"             => "ath_hal_setpower"
                   , "ah_setRxDP"                  => "ath_hal_putrxbuf"
                   , "ah_setRxFilter"              => "ath_hal_setrxfilter"
                   , "ah_setRegulatoryDomain"      => "ath_hal_setregulatorydomain"
                   , "ah_setSlotTime"              => "ath_hal_setslottime"
                   , "ah_setStationBeaconTimers"   => "ath_hal_beacontimers"
                   , "ah_setTxDP"                  => "ath_hal_puttxbuf"
                   , "ah_setTxQueueProps"          => "ath_hal_settxqueueprops"
                   , "ah_setTxPowerLimit"          => "ath_hal_settxpowerlimit"
                   , "ah_setBeaconTimers"          => "ath_hal_setbeacontimers"
                   , "ah_setupRxDesc"              => "ath_hal_setuprxdesc"
                   , "ah_setupTxDesc"              => "ath_hal_setuptxdesc"
                   , "ah_setupTxQueue"             => "ath_hal_setuptxqueue"
                   , "ah_setupXTxDesc"             => "ath_hal_setupxtxdesc"
                   , "ah_startPcuReceive"          => "ath_hal_startpcurecv"
                   , "ah_startTxDma"               => "ath_hal_txstart"
                   , "ah_stopDmaReceive"           => "ath_hal_stopdmarecv"
                   , "ah_stopPcuReceive"           => "ath_hal_stoppcurecv"
                   , "ah_stopTxDma"                => "ath_hal_stoptxdma"
                   , "ah_updateCTSForBursting"     => "ath_hal_updateCTSForBursting"
                   , "ah_updateTxTrigLevel"        => "ath_hal_updatetxtriglevel"
                   , "ah_waitForBeaconDone"        => "ath_hal_waitforbeacon"
                   , "ah_writeAssocid"             => "ath_hal_setassocid"
                   , "ah_detach"                   => "ath_hal_detach"
                   , "ah_clrMulticastFilterIndex"  => "ath_hal_clearmcastfilter"
                   , "ah_detectCardPresent"        => "ath_hal_detectcardpresent"
                   );

#
# Boilerplate text
# 
$header_comment = <<EOF
/*
 * Wrapper macros/functions for the binary HAL to comply with local coding convention.
 * 
 * Provides function-style calling convention using either macros or wrapper functions for function pointers in the HAL.
 * 
 * The typical convention is foo(hal,p1,p2,p3,...) turns into hal->foo(p1,p2,p3,...) where foo 
 * is a function pointer and a member of the struct ath_hal.
 *
 * The macros are faster, but the functions have the advantage that they show up unobfuscated in backtraces thus giving you a clue as to where in 
 * your code you went wrong in your use of the HAL.
 *
 */
EOF
;

my %custom_wrappers = (
          "HAL_BOOL ath_hal_burstsupported(struct ath_hal * ah)"                                => "(ath_hal_getcapability(ah, HAL_CAP_BURST, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_ciphersupported(struct ath_hal * ah, u_int32_t cipher)"             => "(ath_hal_getcapability(ah, HAL_CAP_CIPHER, cipher, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_compressionsupported(struct ath_hal * ah)"                          => "(ath_hal_getcapability(ah, HAL_CAP_COMPRESSION, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_fastframesupported(struct ath_hal * ah)"                            => "(ath_hal_getcapability(ah, HAL_CAP_FASTFRAME, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_getcountrycode(struct ath_hal * ah, u_int32_t* destination)"        => "((*(destination) = ah->ah_countryCode), AH_TRUE)"
        , "HAL_BOOL ath_hal_getdiversity(struct ath_hal * ah)"                                  => "(ath_hal_getcapability(ah, HAL_CAP_DIVERSITY, 1, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_getmaxtxpow(struct ath_hal * ah, u_int32_t* destination)"           => "(ath_hal_getcapability(ah, HAL_CAP_TXPOW, 2, destination) == HAL_OK)"
        , "HAL_BOOL ath_hal_getmcastkeysearch(struct ath_hal * ah)"                             => "(ath_hal_getcapability(ah, HAL_CAP_MCAST_KEYSRCH, 1, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_getnumtxqueues(struct ath_hal * ah, u_int32_t* destination)"        => "(ath_hal_getcapability(ah, HAL_CAP_NUM_TXQUEUES, 0, destination) == HAL_OK)"
        , "HAL_BOOL ath_hal_getregdomain(struct ath_hal * ah, u_int32_t* destination)"          => "(ath_hal_getcapability(ah, HAL_CAP_REG_DMN, 0, destination))"
        , "HAL_BOOL ath_hal_gettkipmic(struct ath_hal * ah)"                                    => "(ath_hal_getcapability(ah, HAL_CAP_TKIP_MIC, 1, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_gettkipsplit(struct ath_hal * ah)"                                  => "(ath_hal_getcapability(ah, HAL_CAP_TKIP_SPLIT, 1, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_gettpc(struct ath_hal * ah)"                                        => "(ath_hal_getcapability(ah, HAL_CAP_TPC, 1, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_gettpscale(struct ath_hal * ah, u_int32_t* destination)"            => "(ath_hal_getcapability(ah, HAL_CAP_TXPOW, 3, destination) == HAL_OK)"
        , "HAL_BOOL ath_hal_gettsfadjust(struct ath_hal * ah)"                                  => "(ath_hal_getcapability(ah, HAL_CAP_TSF_ADJUST, 1, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_gettxpowlimit(struct ath_hal * ah, u_int32_t* destination)"         => "(ath_hal_getcapability(ah, HAL_CAP_TXPOW, 1, destination) == HAL_OK)"
        , "HAL_BOOL ath_hal_halfrate_chansupported(struct ath_hal * ah)"                        => "(ath_hal_getcapability(ah, HAL_CAP_CHAN_HALFRATE, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hasbssidmask(struct ath_hal * ah)"                                  => "(ath_hal_getcapability(ah, HAL_CAP_BSSIDMASK, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hasbursting(struct ath_hal * ah)"                                   => "(ath_hal_getcapability(ah, HAL_CAP_BURST, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hascompression(struct ath_hal * ah)"                                => "(ath_hal_getcapability(ah, HAL_CAP_COMPRESSION, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hasdiversity(struct ath_hal * ah)"                                  => "(ath_hal_getcapability(ah, HAL_CAP_DIVERSITY, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hasfastframes(struct ath_hal * ah)"                                 => "(ath_hal_getcapability(ah, HAL_CAP_FASTFRAME, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hasmcastkeysearch(struct ath_hal * ah)"                             => "(ath_hal_getcapability(ah, HAL_CAP_MCAST_KEYSRCH, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hasrfsilent(struct ath_hal * ah)"                                   => "(ath_hal_getcapability(ah, HAL_CAP_RFSILENT, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hastkipmic(struct ath_hal * ah)"                                    => "(ath_hal_getcapability(ah, HAL_CAP_TKIP_MIC, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hastkipsplit(struct ath_hal * ah)"                                  => "(ath_hal_getcapability(ah, HAL_CAP_TKIP_SPLIT, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hastpc(struct ath_hal * ah)"                                        => "(ath_hal_getcapability(ah, HAL_CAP_TPC, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hastsfadjust(struct ath_hal * ah)"                                  => "(ath_hal_getcapability(ah, HAL_CAP_TSF_ADJUST, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hastxpowlimit(struct ath_hal * ah)"                                 => "(ath_hal_getcapability(ah, HAL_CAP_TXPOW, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hasveol(struct ath_hal * ah)"                                       => "(ath_hal_getcapability(ah, HAL_CAP_VEOL, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_hwphycounters(struct ath_hal * ah)"                                 => "(ath_hal_getcapability(ah, HAL_CAP_PHYCOUNTERS, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_quarterrate_chansupported(struct ath_hal * ah)"                     => "(ath_hal_getcapability(ah, HAL_CAP_CHAN_QUARTERRATE, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_setdiversity(struct ath_hal * ah, int v)"                           => "(ath_hal_setcapability(ah, HAL_CAP_DIVERSITY, 1, v, NULL))"
        , "HAL_BOOL ath_hal_setrfsilent(struct ath_hal * ah, u_int32_t v)"                      => "(ath_hal_setcapability(ah, HAL_CAP_RFSILENT, 1, v, NULL))"
        , "HAL_BOOL ath_hal_settkipmic(struct ath_hal * ah, u_int32_t v)"                       => "(ath_hal_setcapability(ah, HAL_CAP_TKIP_MIC, 1, v, NULL))"
        , "HAL_BOOL ath_hal_settkipsplit(struct ath_hal * ah, int v)"                           => "(ath_hal_setcapability(ah, HAL_CAP_TKIP_SPLIT, 1, v, NULL))"
        , "HAL_BOOL ath_hal_settpc(struct ath_hal * ah, u_int32_t v)"                           => "(ath_hal_setcapability(ah, HAL_CAP_TPC, 1, v, NULL))"
        , "HAL_BOOL ath_hal_settpscale(struct ath_hal * ah, u_int32_t v)"                       => "(ath_hal_setcapability(ah, HAL_CAP_TXPOW, 3, v, NULL))"
        , "HAL_BOOL ath_hal_settsfadjust(struct ath_hal * ah, u_int32_t v)"                     => "(ath_hal_setcapability(ah, HAL_CAP_TSF_ADJUST, 1, v, NULL))"
        , "HAL_BOOL ath_hal_turboagsupported(struct ath_hal * ah, int countrycode)"             => "(ath_hal_getwirelessmodes(ah, countrycode) & (HAL_MODE_108G|HAL_MODE_TURBO))"
        , "HAL_BOOL ath_hal_wmetkipmic(struct ath_hal * ah)"                                    => "(ath_hal_getcapability(ah, HAL_CAP_WME_TKIPMIC, 0, NULL) == HAL_OK)"
        , "HAL_BOOL ath_hal_xrsupported(struct ath_hal * ah)"                                   => "(ath_hal_getcapability(ah, HAL_CAP_XR, 0, NULL) == HAL_OK)"
);

#
# Open the files we need
# 
if(!open AH_H, "<$path_to_ah_h") {
   die "Cannot open $path_to_ah_h: $!";
}
if(!open ATH_HAL_API_H, ">$path_to_ath_hal_api_h") {
   close AH_H;
   die "Cannot open $path_to_ath_hal_api_h: $!";
}
if(!open ATH_HAL_API_C, ">$path_to_ath_hal_api_c") {
   close AH_H;
   close ATH_HAL_API_H;
   die "Cannot open $path_to_ath_hal_api_c: $!";
}

#
# Parse HAL function declarations
# 
# list of declarations in document order
@hal_prototypes = ();
# hash of string->string (hal's function name to return type)
%hal_return_types = ();
# hash of string->list of strings (ordered list of parameter names)
%hal_parameter_names = ();
# hash of string->list of strings (ordered list of parameter types)
%hal_parameter_types = ();

# Parse and scrub the hal structure's member function declarations 
$line_continued = 0;
$line_buffer = "";
foreach (<AH_H>) {
   chomp($_);
   s/\s+$//g;
   s/^\s+//g;
   s/\s+/ /g;
   if (/__ahdecl\s*\(.*/ || $line_continued) {
      $line_buffer .= "$_";
      if (/__ahdecl.*;/ || ($line_continued && /;/)) {
         push @hal_prototypes, $line_buffer;
         $line_buffer = "";
         $line_continued = 0;
      }
      else {
         $line_buffer .= " ";
         $line_continued = 1;
      }
   }
}

# Now pick apart the return type, parameter types, and parameter names
foreach $proto (@hal_prototypes) {
   $proto =~ /^((?:(?:const|struct|\*)\s*)*[^\s]+)[\s]*\*?[\s]*__ahdecl\(\*([^\)]*)\)\((.*)\);/;
   my $return_type   = $1;
   my $member_name   = $2;
   my $parameterlist = $3;
   $hal_return_types{"$member_name"} = "$return_type";
   @{$hal_parameter_names{"$member_name"}} = ();
   @{$hal_parameter_types{"$member_name"}} = ();
   my @parameters = split /,\s?/, $parameterlist;
   $argnum = 0;
   $first = 1;
   foreach(@parameters) {
      $_ =~ s/ \*/\* /;
      $_ =~ /^((?:(?:const|struct|\*)\s*)*)([^\s]+\*?)\s*([^\s]*)\s*/;
      my $type = "$1$2";
      my $name = "$3";
      if(0 == length($name)) {
         if($argnum == 0 && $type =~ /ath_hal/) {
            $name = "ah";
         }
         else {
            $name = "a" . $argnum;
         }
      }
      
      push @{$hal_parameter_names{$member_name}}, $name;
      push @{$hal_parameter_types{$member_name}}, $type;
      $first = 0;
      $argnum++;
   }
}

#
# Generate the header file
# 
print ATH_HAL_API_H <<EOF
$header_comment
#ifndef _IF_ATH_HAL_H
#define _IF_ATH_HAL_H

#include "ah.h"

EOF
;
for $member_name (keys %hal_return_types) {
   my $api_return_type   = $hal_return_types{$member_name};
   my $api_name      = $member_name;
   if(exists $function_names{$member_name}) {
      $api_name = $function_names{$member_name};
   }
   print ATH_HAL_API_H "static inline " . $api_return_type . " " . $api_name . "(";
   my @names = @{$hal_parameter_names{$member_name}};
   my @types = @{$hal_parameter_types{$member_name}};
   for $i (0..$#names) {
      if($i) {
         print ATH_HAL_API_H ", ";
      }
      print ATH_HAL_API_H $types[$i] . " " . $names[$i];
   }
   print ATH_HAL_API_H ") {";
   print ATH_HAL_API_H "\n\tATH_HAL_LOCK_IRQ(ah);";
   print ATH_HAL_API_H "\n\t";
   if(! ($api_return_type =~ /void/ )) {
      print ATH_HAL_API_H $api_return_type . " ret = ";
   }

   print ATH_HAL_API_H "ah->$member_name(";
   for $j (0..$#names) {
      if($j) {
         print ATH_HAL_API_H ", ";
      }
      print ATH_HAL_API_H $names[$j];
   }
   print ATH_HAL_API_H ");";
   print ATH_HAL_API_H "\n\tATH_HAL_UNLOCK_IRQ(ah);";
   if(! ($api_return_type =~ /void/ )) {
      print ATH_HAL_API_H "\n\treturn ret;";
   }
   print ATH_HAL_API_H "\n};\n";
}
print ATH_HAL_API_H <<EOF

#endif /* _IF_ATH_HAL_H */
EOF
;
   print %hal_parameter_maps;

#
# Generate the implementation file
# 
print ATH_HAL_API_C <<EOF
$header_comment
#include "opt_ah.h"

#ifdef AH_HALOPS_FUNC

#ifndef AUTOCONF_INCLUDED
#include <linux/config.h>
#endif
#include <linux/version.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/random.h>
#include <linux/delay.h>
#include <linux/cache.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/if_arp.h>
#include <linux/rtnetlink.h>
#include <asm/uaccess.h>

#include "ath_hal_api.h"
EOF
;
#foreach (<AH_H>) {
#   print ATH_HAL_API_C "$_";
#}
print ATH_HAL_API_C <<EOF

#endif /* #ifndef AH_HALOPS_FUNC */
EOF
;

# Close up the files
close AH_H;
close ATH_HAL_API_H;
close ATH_HAL_API_C;