root/i2c/trunk/mkpatch/mkpatch.pl @ 3765

#!/usr/bin/perl

#    mkpatch - Create patches against the Linux kernel
#    Copyright (c) 1999  Frodo Looijaard <frodol@dds.nl>
#
#    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., 675 Mass Ave, Cambridge, MA 02139, USA.

use strict;

use vars qw($temp);
$temp = "mkpatch/.temp";

# Forward declaration
sub gen_drivers_char_Makefile;

# Generate a diff between the old kernel file and the new I2C file. We
# arrange the headers to tell us the old tree was under directory 
# `linux-old', and the new tree under `linux'.
# $_[0]: i2c package root (like /tmp/i2c)
# $_[1]: Linux kernel tree (like /usr/src/linux)
# $_[2]: Name of the kernel file
# $_[3]: Name of the patched file
sub print_diff
{
  my ($package_root,$kernel_root,$kernel_file,$package_file) = @_;
  my ($diff_command,$dummy);

  $diff_command = "diff -u";
  $diff_command .= " $kernel_root/$kernel_file ";
  $diff_command .= " $package_root/$package_file ";
  open INPUT, "$diff_command|" or die "Can't call `$diff_command'";
  if (<INPUT>) {
      print "--- linux-old/$kernel_file\t".`date`;
  }
  if (<INPUT>) {
      print "+++ linux/$kernel_file\t".`date`;
  }
  while (<INPUT>) {
    print;
  }
  close INPUT;
}


# This generates diffs for kernel file Documentation/Configure.help. This
# file contains the help texts that can be displayed during `make *config'
# for the kernel.
# The new texts are put at the end of the file, or just before the
# lm_sensors texts.
# Of course, care is taken old lines are removed.
# $_[0]: i2c package root (like /tmp/i2c)
# $_[1]: Linux kernel tree (like /usr/src/linux)
sub gen_Documentation_Configure_help
{
  my ($package_root,$kernel_root) = @_;
  my $kernel_file = "Documentation/Configure.help";
  my $package_file = $temp;
  my $printed = 0;

  open INPUT,"$kernel_root/$kernel_file"
        or die "Can't open `$kernel_root/$kernel_file'";
  open OUTPUT,">$package_root/$package_file"
        or die "Can't open $package_root/$package_file";
  MAIN: while(<INPUT>) {
    if (m@^I2C support$@ or m@^I2C bit-banging interfaces@ or
           m@^Philips style parallel port adapter@ or
           m@^ELV adapter@ or m@^Velleman K9000 adapter@ or
           m@^I2C PCF 8584 interfaces@ or m@^Elektor ISA card@ or
           m@^I2C device interface@ or
           m@^I2C /proc interface \(required for hardware sensors\)@) {
      $_ = <INPUT>;
      $_ = <INPUT>;
      $_ = <INPUT> while not m@^\S@ and not eof(INPUT);
      redo MAIN;
    }
    if (not $printed and (eof(INPUT) or m@I2C mainboard interfaces@ or
                          m@A couple of things I keep forgetting@ or
                          m@Bus Mouse Support@)) {
      print OUTPUT <<'EOF';
I2C support
CONFIG_I2C
  I2C (pronounce: I-square-C) is a slow serial bus protocol used in
  many micro controller applications and developed by Philips.  SMBus,
  or System Management Bus is a subset of the I2C protocol.  More
  information is contained in the directory <file:Documentation/i2c/>,
  especially in the file called "summary" there.

  Both I2C and SMBus are supported here. You will need this for
  hardware sensors support, and also for Video For Linux support.
  Specifically, if you want to use a BT848 based frame grabber/overlay
  boards under Linux, say Y here and also to "I2C bit-banging
  interfaces", below.

  If you want I2C support, you should say Y here and also to the
  specific driver for your bus adapter(s) below.  If you say Y to
  "/proc file system" below, you will then get a /proc interface which
  is documented in <file:Documentation/i2c/proc-interface>.

  This I2C support is also available as a module.  If you want to
  compile it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-core.o.

I2C bit-banging interfaces
CONFIG_I2C_ALGOBIT
  This allows you to use a range of I2C adapters called bit-banging
  adapters.  Say Y if you own an I2C adapter belonging to this class
  and then say Y to the specific driver for you adapter below.

  This support is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-algo-bit.o.

Philips style parallel port adapter
CONFIG_I2C_PHILIPSPAR
  This supports parallel-port I2C adapters made by Philips.  Say Y if
  you own such an adapter.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-philips-par.o.

  Note that if you want support for different parallel port devices,
  life will be much easier if you compile them all as modules.

ELV adapter
CONFIG_I2C_ELV
  This supports parallel-port I2C adapters called ELV.  Say Y if you
  own such an adapter.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-elv.o.

Velleman K9000 adapter
CONFIG_I2C_VELLEMAN
  This supports the Velleman K9000 parallel-port I2C adapter.  Say Y
  if you own such an adapter.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-velleman.o.

Basic I2C on Parallel Port adapter
CONFIG_I2C_PPORT
  This supports directly connecting I2C devices to the parallel port.
  See <file:Documentation/i2c/i2c-pport> for more information.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-pport.o.

I2C PCF 8584 interfaces
CONFIG_I2C_ALGOPCF
  This allows you to use a range of I2C adapters called PCF adapters.
  Say Y if you own an I2C adapter belonging to this class and then say
  Y to the specific driver for you adapter below.

  This support is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-algo-pcf.o.

Elektor ISA card
CONFIG_I2C_ELEKTOR
  This supports the PCF8584 ISA bus I2C adapter.  Say Y if you own
  such an adapter.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-elektor.o.

PCF on the EPP Parallel Port
CONFIG_I2C_PCFEPP
  This supports the PCF8584 connected to the parallel port.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-pcf-epp.o.

Motorola 8xx I2C algorithm
CONFIG_I2C_ALGO8XX
  This is the algorithm that allows you to use Motorola 8xx I2C adapters.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-algo-8xx.o.

Motorola 8xx I2C interface
CONFIG_I2C_RPXLITE
  This supports the Motorola 8xx I2C device.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-rpx.o.

IBM 405 I2C algorithm
CONFIG_I2C_IBM_OCP_ALGO
  This is the algorithm that allows you to use IBM 405 I2C adapters.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-algo-ibm_ocp.o.

IBM 405 I2C interface
CONFIG_I2C_IBM_OCP_ADAP
  This supports the IBM 405 I2C device.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-adap-ibm_ocp.o.

StrongARM SA-1110 interface
CONFIG_I2C_FRODO
  This supports the StrongARM SA-1110 Development Board.

  This driver is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-frodo.o.

I2C device interface
CONFIG_I2C_CHARDEV
  Say Y here to use i2c-* device files, usually found in the /dev
  directory on your system.  They make it possible to have user-space
  programs use the I2C bus.  Information on how to do this is
  contained in the file <file:Documentation/i2c/dev-interface>.

  This code is also available as a module.  If you want to compile
  it as a module, say M here and read
  <file:Documentation/modules.txt>.
  The module will be called i2c-dev.o.

I2C /proc interface (required for hardware sensors)
CONFIG_I2C_PROC
  This provides support for i2c device entries in the /proc filesystem.
  The entries will be found in /proc/sys/dev/sensors.

  This code is also available as a module. If you want to compile
  it as a module, say M here and read <file:Documentation/modules.txt>.
  The module will be called i2c-proc.o.

EOF
      $printed = 1;
    }
    print OUTPUT;
  }
  close INPUT;
  close OUTPUT;
  print_diff $package_root,$kernel_root,$kernel_file,$package_file;
}

# This generates diffs for drivers/Makefile
# $_[0]: i2c package root (like /tmp/i2c)
# $_[1]: Linux kernel tree (like /usr/src/linux)
sub gen_drivers_Makefile
{
  my ($package_root,$kernel_root) = @_;
  my $kernel_file = "drivers/Makefile";
  my $package_file = $temp;
  my $i2c_present;
  my $printed = 0;
  my $added = 0;

  open INPUT,"$kernel_root/$kernel_file"
        or die "Can't open `$kernel_root/$kernel_file'";
  open OUTPUT,">$package_root/$package_file"
        or die "Can't open $package_root/$package_file";
  MAIN: while(<INPUT>) {
    if (m@^ifeq.*CONFIG_I2C@) {
      $_ = <INPUT> while not m@^endif@;
      $_ = <INPUT>;
      $_ = <INPUT> if m@^$@;
      redo MAIN;
    } 
    if (m@^subdir.*CONFIG_I2C@) {
      $_ = <INPUT>;
      redo MAIN;
    }
    if (not $printed and
        (m@^ifeq \(\$\(CONFIG_ACPI\),y\)$@ or
         m@^ifeq \(\$\(CONFIG_SENSORS\),y\)@) or
         m@^subdir-\$\(CONFIG_ACPI\)@) {
        print OUTPUT <<'EOF';
subdir-$(CONFIG_I2C)            += i2c
EOF
        $printed = 1;
    }
    print OUTPUT;
  }
  close INPUT;
  close OUTPUT;
  die "Automatic patch generation for `drivers/Makefile' failed.\n".
      "See our home page http://www.lm-sensors.nu for assistance!" if $printed == 0 or $added == 0;
  print_diff $package_root,$kernel_root,$kernel_file,$package_file;
}


# This generates diffs for drivers/i2c/Makefile
sub gen_drivers_i2c_Makefile
{
  my ($package_root,$kernel_root) = @_;
  my $kernel_file = "drivers/i2c/Makefile";
  my $package_file = $temp;
  my $use_new_format = 0;

  open OUTPUT,">$package_root/$package_file"
        or die "Can't open $package_root/$package_file";
  print OUTPUT <<'EOF';
#
# Makefile for the kernel i2c bus driver.
#

O_TARGET := i2c.o

export-objs     := i2c-core.o i2c-algo-bit.o i2c-algo-pcf.o \
                   i2c-algo-8xx.o i2c-proc.o i2c-algo-ibm_ocp.o

obj-$(CONFIG_I2C)               += i2c-core.o
obj-$(CONFIG_I2C_CHARDEV)       += i2c-dev.o
obj-$(CONFIG_I2C_ALGOBIT)       += i2c-algo-bit.o
obj-$(CONFIG_I2C_PHILIPSPAR)    += i2c-philips-par.o
obj-$(CONFIG_I2C_ELV)           += i2c-elv.o
obj-$(CONFIG_I2C_VELLEMAN)      += i2c-velleman.o
obj-$(CONFIG_I2C_PPORT)         += i2c-pport.o
obj-$(CONFIG_I2C_ALGOPCF)       += i2c-algo-pcf.o
obj-$(CONFIG_I2C_ELEKTOR)       += i2c-elektor.o
obj-$(CONFIG_I2C_PCFEPP)        += i2c-pcf-epp.o
obj-$(CONFIG_I2C_PROC)          += i2c-proc.o
obj-$(CONFIG_I2C_ALGO8XX)       += i2c-algo-8xx.o
obj-$(CONFIG_I2C_RPXLITE)       += i2c-rpx.o
obj-$(CONFIG_I2C_IBM_OCP_ALGO)  += i2c-algo-ibm_ocp.o
obj-$(CONFIG_I2C_IBM_OCP_ADAP)  += i2c-adap-ibm_ocp.o
obj-$(CONFIG_I2C_FRODO)         += i2c-frodo.o

EOF

  close OUTPUT;
  print_diff $package_root,$kernel_root,$kernel_file,$package_file;
}

 
# Generate the diffs for the list of MAINTAINERS
# $_[0]: i2c package root (like /tmp/i2c)
# $_[1]: Linux kernel tree (like /usr/src/linux)
sub gen_MAINTAINERS
{
  my ($package_root,$kernel_root) = @_;
  my $kernel_file = "MAINTAINERS";
  my $package_file = $temp;
  my $done = 0;

  open INPUT,"$kernel_root/$kernel_file"
        or die "Can't open `$kernel_root/$kernel_file'";
  open OUTPUT,">$package_root/$package_file"
        or die "Can't open $package_root/$package_file";
  MAIN: while(<INPUT>) {
    if (m@I2C DRIVERS@) {
       $_=<INPUT> while not m@^$@;
       $_=<INPUT>;
       redo MAIN;
    }
    if (not $done and (m@i386 BOOT CODE@ or m@IBM MCA SCSI SUBSYSTEM DRIVER@)) {
      print OUTPUT <<'EOF';
I2C DRIVERS
P:      Simon Vogl
M:      simon@tk.uni-linz.ac.at
P:      Frodo Looijaard
M:      frodol@dds.nl
L:      linux-i2c@pelican.tk.uni-linz.ac.at
W:      http://www.tk.uni-linz.ac.at/~simon/private/i2c
S:      Maintained

EOF
      $done = 1;
    }
    print OUTPUT;
  }
  close INPUT;
  close OUTPUT;
  die "Automatic patch generation for `MAINTAINERS' failed.\n".
      "See our home page http://www.lm-sensors.nu for assistance!" if $done == 0;
  print_diff $package_root,$kernel_root,$kernel_file,$package_file;
}

# Main function
sub main
{
  my ($package_root,$kernel_root,%files,%includes,$package_file,$kernel_file);
  my ($diff_command,$dummy,$data0,$data1,$sedscript,@sensors_subs);

  # --> Read the command-line
  $package_root = $ARGV[0];
  die "Package root `$package_root' is not found\n" 
        unless -d "$package_root/mkpatch";
  $kernel_root = $ARGV[1];

  # --> Read FILES
  open INPUT, "$package_root/mkpatch/FILES" 
        or die "Can't open `$package_root/mkpatch/FILES'";
  while (<INPUT>) {
    ($data0,$data1) = /(\S+)\s+(\S+)/;
    $files{$data0} = $data1;
  } 
  close INPUT;

  # --> Read INCLUDES
  open INPUT, "$package_root/mkpatch/INCLUDES" 
        or die "Can't open `$package_root/mkpatch/INCLUDES'";
  while (<INPUT>) {
    ($data0,$data1) = /(\S+)\s+(\S+)/;
    $includes{$data0} = $data1;
    $sedscript .= 's,(#\s*include\s*)'.$data0.'(\s*),\1'."$data1".'\2, ; ';
  } 
  close INPUT;

  # --> Start generating
  foreach $package_file (sort keys %files) {
    $kernel_file = $files{$package_file};
    open INPUT, "$package_root/$package_file"
         or die "Can't open `$package_root/$package_file'";
    open OUTPUT, ">$package_root/$temp"
         or die "Can't open `$package_root/$temp'";
    while (<INPUT>) {
      eval $sedscript;
      print OUTPUT;
    }
    close INPUT;
    close OUTPUT;
    print_diff "$package_root","$kernel_root","$kernel_file","$temp";
  }

#  gen_Makefile $package_root, $kernel_root;
#  gen_drivers_Makefile $package_root, $kernel_root;
#  gen_drivers_i2c_Makefile $package_root, $kernel_root;
#  gen_Documentation_Configure_help $package_root, $kernel_root;
}

main;