Subversion Repositories DevTools

#! perl

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

# Copyright (C) 2006 ERG Limited, All rights reserved

#

# Module name   : jats_buildlinux.pl

# Module type   : Makefile system

# Compiler(s)   : n/a

# Environment(s): jats

#

# Description   : A utility to assist in building Linux Device Driver

#                 This script implemenst the runtime functionality of the

#                 MakeLinuxDriver directive

#

# Usage:

#

#......................................................................#

require 5.6.1;

use strict;

use warnings;

use Cwd;

use FileUtils;

use JatsSystem;

use JatsError;

use ArrayHashUtils;

use File::Path;

use File::Copy;

use File::Find;

use Getopt::Long;

use Pod::Usage;                             # required for help support

#

#   Initialise and configure some of the used packages

#

ErrorConfig( 'name' => 'BuildLinuxDriver' );

SystemConfig ( 'ExitOnError' => 1);

InitFileUtils();

#

#   Global variables

#

my $VERSION = "1.0.0";                      # Update this

my $opt_debug   = $ENV{'GBE_DEBUG'};        # Allow global debug

my $opt_verbose = $ENV{'GBE_VERBOSE'};      # Allow global verbose

my $opt_help = 0;

my $opt_manual = 0;

my $opt_output;

my $opt_kernel;

my $opt_gcc_path;

my $opt_arch;

my @opt_source;

my $opt_driver;

my $opt_leavetmp;

my $opt_show_cmds;

my $opt_type = 'P';

my $opt_platform;

my @opt_defs;

my @opt_incdirs;

#

#   Extract arguments

#

my $result = GetOptions (

                "help+"         => \$opt_help,              # flag, multiple use allowed

                "manual"        => \$opt_manual,            # flag, multiple use allowed

                "verbose+"      => \$opt_verbose,           # flag, multiple use allowed

                "Output=s"      => \$opt_output,

                "GccPath=s"     => \$opt_gcc_path,

                "Arch=s"        => \$opt_arch,

                "Driver=s"      => \$opt_driver,

                "LeaveTmp:s"    => \$opt_leavetmp,

                "Verbose:s"     => \$opt_show_cmds,

                "Type=s"        => \$opt_type,

                "Platform=s"    => \$opt_platform,

                "Define=s"      => \@opt_defs,

                "Define=s"      => \@opt_defs,

                "Incdir=s"      => \@opt_incdirs,

                );

#

#   Process help and manual options

#

pod2usage(-verbose => 0, -message => "Version: $VERSION") if ($opt_help == 1 || ! $result);

pod2usage(-verbose => 1) if ($opt_help == 2 );

pod2usage(-verbose => 2) if ($opt_manual || ($opt_help > 2));

#pod2usage(-verbose => 0, -message => "Version: $VERSION") if ( $#ARGV >= 0 );

#

#   Sanity Test user input

#

Error ("No Output File specified") unless ( $opt_output );

#

#   Locate the Kernel Headers

#   This will be provided by one of the external packages

#   Paths to the packages will be in @opt_incdirs

#   Look for a dir ectory with a 'Makefile' - use the first one

#

my $KERNELDIR;

foreach  ( @opt_incdirs )

{

    my $test_dir = $_ . '/' . $opt_platform;

    next unless ( -d $test_dir );

    next unless ( -f $test_dir . '/Makefile' );

    $KERNELDIR = $test_dir;

}

Error ("Could not find the Kernel Headers",

       "Need a package that contains include/$opt_platform/Makefile"

      ) unless ( $KERNELDIR );

#

#   Calculate required bits

#   The generated file. Based on the name of the desired output file and the

#   source path.

#

my $gen_file = StripDir($opt_output);

#

#   Cross-compiler toolchain root

#   Based on GccPath, remove the gcc bit

#

my $CROSS_COMPILE = $opt_gcc_path;

   $CROSS_COMPILE =~ s~-gcc$~-~;

#

#   The required architecture

#

my $ARCH;

   $ARCH = 'arm'  if ( $opt_arch =~ m/arm/i );

   $ARCH = 'i386' if ( $opt_arch =~ m/i386/i );

   Error ("Cannot determine architecture") unless ( $ARCH );

#

#   Source files

#   These may be comma seperated. Expand the array

#

@opt_source = @ARGV;

Error ("No source files specified" ) unless ( @opt_source );

#

#   Must have a nice name for the driver

#

Error ("No driver name specified") unless ( $opt_driver );

Message    "======================================================================";

Message    "Build Linux Device Driver using the native build method";

Message    "         Driver : $opt_driver";

Message    "          Arch  : $ARCH";

Message    "          Type  : $opt_type";

Message    "         Output : $opt_output";

Message    "       Platform : $opt_platform";

Message    " Cross Compiler : $CROSS_COMPILE";

Message    " Kernel Headers : $KERNELDIR";

Message    "         Source : @opt_source";

foreach  ( @opt_defs )

{

    Message    "         Define : $_";

}

foreach  ( @opt_incdirs )

{

    Message    "         Incdir : $_";

}

Message    "======================================================================";

#

#   Clean any existing build artifacts

#   The build optiosn to place things in a different diractory are broken.

#   We must be able to build for multiple targets without confusion so we

#   clean, then build, then copy out the bits we need.

clean();

#

#   Generate a Makefile for use by the driver Builder

#   This encapsulates the complete driver build mechanism

#

create_makefile();

#

#   Remove some 'make' environment variables

#   The JATS make and the PACKAGE make must not know about each other

#

foreach my $var qw ( MAKE MAKEFLAGS MAKEOVERRIDES MAKELEVEL MAKE_MODE

                     CC CXX CPP CFLAGS ASFLAGS LDFLAGS

                     DEBFLAGS LDDINC DEBUG KERNELRELEASE LDDINC

                     )

{

    delete $ENV{$var};

}

#

#   Build up the make command

#   Create an array of arguments - Don't need to escape funny bits

#

my @make_args = ();

push @make_args, "ARCH=$ARCH";

push @make_args, "CROSS_COMPILE=$CROSS_COMPILE";

push @make_args, "KERNELDIR=$KERNELDIR";

push @make_args, "-f", "Kbuild";

push @make_args, "V=1" unless ( $opt_show_cmds );

System ( 'make', @make_args );

Error  ("Generated output module file not found: $gen_file") unless ( -f $gen_file );

copy ( $gen_file, $opt_output ) || Error ("Cannot copy output file: $opt_output");

clean() unless $opt_leavetmp;

Message "Script complete";

exit 0;

#-------------------------------------------------------------------------------

# Function        : create_makefile

#

# Description     : Generate a makefile called Kbuild

#                   This will be used by the kernel builder to do the hard work

#

#                   The makefile is created via a template embedded in this file

#

# Inputs          : None

#

# Returns         : Creates a file called Kbuild

#

sub create_makefile

{

    #

    #   Create variables for the data that will be substituted

    #

    my $driver_line = "obj-m	:= $opt_driver.o";

    #

    #   Convert the list of source files into object files

    #

    my @obj_files = map { $_ =~ s~\..*$~.o~; $_ } @opt_source;

    my $file_list = "${opt_driver}-objs := @obj_files";

    my $debug_line = "DEBUG = y";

       $debug_line = "# " . $debug_line unless ( $opt_type eq 'D' );

    my $filename = "Kbuild";

    unlink ($filename);

    open (KBUILD, ">", $filename ) || Error ("Cannot generate file: $filename");

    while ( <DATA> )

    {

        $_ =~ s~\s+$~~;

        #

        #   Replace the entire line

        #

        $_ = $debug_line if ( m~__DEBUG_LINE__~ );

        $_ = $driver_line if ( m~__DEVICE_NAME__~ );

        $_ = $file_list if ( m~__FILE_LIST__~ );

        last if ( m~__END__~ );

        if ( m~__DEFINES__~ )

        {

            print KBUILD "# User definitions\n";

            foreach my $line ( @opt_defs )

            {

                print KBUILD "CFLAGS += -D$line\n";

            }

            print KBUILD "# End of User definitions\n";

            next;

        }

        if ( m~__INCDIR__~ )

        {

            print KBUILD "# Search Include Directories\n";

            foreach my $line ( @opt_incdirs )

            {

                if ( ! -d $line )

                {

                    Verbose("Incdir does not exist: $line");

                    next;

                }

                if ( $line =~ m~^/~ )

                {

                    print KBUILD "CFLAGS += -I$line\n";

                }

                else

                {

                    print KBUILD "CFLAGS += -I\$(PWD)/$line\n";

                }

            }

            print KBUILD "# End of User Include Directories\n";

            next;

        }

        print KBUILD "$_\n";

    }

    close (KBUILD);

}

#-------------------------------------------------------------------------------

# Function        : clean

#

# Description     : Clean up build artifacts

#                   That was done in a makefile, buts its quicker todo it

#                   internally

#

# Inputs          :

#

# Returns         :

#

sub clean

{

    foreach my $files qw (*.o *~ core .depend .*.cmd *.ko *.mod.c Kbuild )

    {

        unlink ( glob ( $files ));

    }

    rmtree  ( '.tmp_versions' );

}

__DATA__

#

#   This is a generated file

#   Do not edit or check into version control

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

# Comment/uncomment the following line to disable/enable debugging

DEBUG = y __DEBUG_LINE__

__DEFINES__

__INCDIR__

# Add your debugging flag (or not) to CFLAGS

ifeq ($(DEBUG),y)

  DEBFLAGS = -O -g -DDEV_DEBUG # "-O" is needed to expand inlines

else

  DEBFLAGS = -O2

endif

CFLAGS += $(DEBFLAGS)

CFLAGS += -I$(LDDINC)

ifneq ($(KERNELRELEASE),)

# call from kernel build system

llcd-objs := __FILE_LIST__

obj-m	:= __DEVICE_NAME__

else

KERNELDIR ?= "-- Must be defined by calling makefile"

PWD       := $(shell pwd)

modules:

	$(MAKE) -C $(KERNELDIR) M=$(PWD) LDDINC=$(PWD)/../include modules

endif

depend .depend dep:

	$(CC) $(CFLAGS) -M *.c > .depend

ifeq (.depend,$(wildcard .depend))

include .depend

endif

__END__

#-------------------------------------------------------------------------------

#   Documentation

#

=pod

=head1 NAME

jats_buildlinux - Build a Linux Device Driver

=head1 SYNOPSIS

perl jats_buildlinux [options] source_files+

 Options:

    -help              - brief help message

    -help -help        - Detailed help message

    -man               - Full documentation

    -Output=path       - Path to the output file

    -Kernel=path       - Path to the Kernel Headers

    -GccPath=path      - Path to the gcc compiler to use

    -Arch=name         - Architecture name

    -Driver=name       - Base name of the driver to build

    -LeaveTmp=num      - Leave tmp files after build

    -Verbose=num       - Verbose command output

    -Type=[P|D]        - Type of build

    -Platform=name     - Target Platform

    -Define=text       - Definitions to pass to compiler

    -Incdir=path       - Extend the header file search path

=head1 OPTIONS

=over 8

=item B<-help>

Print a brief help message and exits.

=item B<-help -help>

Print a detailed help message with an explanation for each option.

=item B<-man>

Prints the manual page and exits.

=head1 DESCRIPTION

This program is used internally by Jats to implement the body of the MakeLinuxDriver

directive. The command is not intended to be called by the user.

=head1 EXAMPLE

    MakeLinuxDriver ('*', 'llcd.ko',

                          '--KernelPackage=linux_kernel_headers', @CSRCS );

=cut