overclockomatic3188

#!/usr/bin/perl
#
# Copyright 2013  phjanderson
# 
# 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 3 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, see <http://www.gnu.org/licenses/>.
#

use strict;

# GPU frequency cap search list
my @gpu_cap_search_list = (
  [133000000, 266000000],
  [133000000, 400000000],
  [133000000, 466000000],
  [133000000, 500000000],
  [133000000, 533000000],
  [133000000, 600000000],
);

# GPU frequency cap replacement
my @gpu_cap_replace = (133000000, 800000000);


# these voltages are used to search for voltage/frequency tables
my @volt_list = (800000, 825000, 850000, 875000, 900000, 925000, 950000, 975000, 1000000, 1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000, 1325000, 1350000, 1375000, 1400000, 1425000, 1450000);

# for the frequencies we just generate a list of all frequencies between 100 and 2500mhz
my @freq_list;
for ( my $mhz = 100 ; $mhz <= 2500 ; $mhz++ ) {
  push( @freq_list, $mhz * 1000 );
  push( @freq_list, $mhz * 1000 + 1 );
  push( @freq_list, $mhz * 1000 + 2 );
  push( @freq_list, $mhz * 1000 + 3 );
  push( @freq_list, $mhz * 1000 + 4 );
}

# below are the profiles used for the patched kernels
# please remember that they cannot be longer than the frequency tables inside the kernel you are patching

# CPU profiles
my %cpu_profiles = (
  "cpustock" => 0,
  "cpu1608h" =>
    [
      [1150000, 1200000],
      [1250000, 1416000],
      [1350000, 1608000],
    ],
  "cpu1704h" =>
    [
      [1150000, 1200000],
      [1350000, 1608000],
      [1375000, 1704000],
    ],
  "cpu1800h" =>
    [
      [1150000, 1200000],
      [1350000, 1608000],
      [1375000, 1800000],
    ],
  "cpu1920h" =>
    [
      [1150000, 1200000],
      [1350000, 1608000],
      [1450000, 1920000],
    ],
  );

# GPU profiles
my %gpu_profiles = (
  "gpustock" => 0,
#  "gpu600" =>
#    [
#      [975000, 133000],
#      [1000000, 200000],
#      [1025000, 266000],
#      [1050000, 300000],
#      [1100000, 400000],
#      [1250000, 600000],
#   ],
#  "gpu600h" =>
#    [
#      [1100000, 400000],
#      [1250000, 600000],
#    ],
  "gpu798h" =>
    [
      [1100000, 400000],
      [1250000, 600000],
      [1375000, 798000],
   ],
  );

# DDR profiles
# the final digit of the frequency signifies the following:
# 1 DDR_FREQ_NORMAL
# 2 DDR_FREQ_VIDEO
# 3 DDR_FREQ_IDLE
# 4 DDR_FREQ_SUSPEND
# only 1 and 2 seem to be used in the source code for Android sticks and even though 2 is set it doesn't seem to be used
my %ddr_profiles = (
  "ddrstock" => 0,
#  "ddr400" =>
#    [
#      [1000000, 300002],
#      [1100000, 400001],
#    ],
#  "ddr600" =>
#    [
#      [1100000, 400002],
#      [1100000, 600001],
#    ],
  "ddr667" =>
    [
      [1100000, 400002],
      [1200000, 667001],
    ],
  "ddr720" =>
    [
      [1100000, 400002],
      [1200000, 720001],
    ],
  "ddr800" =>
    [
      [1100000, 400002],
      [1250000, 800001],
    ],
  );


########## System variables ##########

my %ddr_freq_type_map = (
  0 => "",
  1 => "1 DDR_FREQ_NORMAL",
  2 => "2 DDR_FREQ_VIDEO",
  3 => "3 DDR_FREQ_IDLE",
  4 => "4 DDR_FREQ_SUSPEND",
);

my $freq_table_end = pack("V", 0) . pack("V", 0xfffffffe);

my @crc_table = (
  0x00000000, 0x04c10db7, 0x09821b6e, 0x0d4316d9,
	0x130436dc, 0x17c53b6b, 0x1a862db2, 0x1e472005,
	0x26086db8, 0x22c9600f, 0x2f8a76d6, 0x2b4b7b61,
	0x350c5b64, 0x31cd56d3, 0x3c8e400a, 0x384f4dbd,
	0x4c10db70, 0x48d1d6c7, 0x4592c01e, 0x4153cda9,
	0x5f14edac, 0x5bd5e01b, 0x5696f6c2, 0x5257fb75,
	0x6a18b6c8, 0x6ed9bb7f, 0x639aada6, 0x675ba011,
	0x791c8014, 0x7ddd8da3, 0x709e9b7a, 0x745f96cd,
	0x9821b6e0, 0x9ce0bb57, 0x91a3ad8e, 0x9562a039,
	0x8b25803c, 0x8fe48d8b, 0x82a79b52, 0x866696e5,
	0xbe29db58, 0xbae8d6ef, 0xb7abc036, 0xb36acd81,
	0xad2ded84, 0xa9ece033, 0xa4aff6ea, 0xa06efb5d,
	0xd4316d90, 0xd0f06027, 0xddb376fe, 0xd9727b49,
	0xc7355b4c, 0xc3f456fb, 0xceb74022, 0xca764d95,
	0xf2390028, 0xf6f80d9f, 0xfbbb1b46, 0xff7a16f1,
	0xe13d36f4, 0xe5fc3b43, 0xe8bf2d9a, 0xec7e202d,
	0x34826077, 0x30436dc0, 0x3d007b19, 0x39c176ae,
	0x278656ab, 0x23475b1c, 0x2e044dc5, 0x2ac54072,
	0x128a0dcf, 0x164b0078, 0x1b0816a1, 0x1fc91b16,
	0x018e3b13, 0x054f36a4, 0x080c207d, 0x0ccd2dca,
	0x7892bb07, 0x7c53b6b0, 0x7110a069, 0x75d1adde,
	0x6b968ddb, 0x6f57806c, 0x621496b5, 0x66d59b02,
	0x5e9ad6bf, 0x5a5bdb08, 0x5718cdd1, 0x53d9c066,
	0x4d9ee063, 0x495fedd4, 0x441cfb0d, 0x40ddf6ba,
	0xaca3d697, 0xa862db20, 0xa521cdf9, 0xa1e0c04e,
	0xbfa7e04b, 0xbb66edfc, 0xb625fb25, 0xb2e4f692,
	0x8aabbb2f, 0x8e6ab698, 0x8329a041, 0x87e8adf6,
	0x99af8df3, 0x9d6e8044, 0x902d969d, 0x94ec9b2a,
	0xe0b30de7, 0xe4720050, 0xe9311689, 0xedf01b3e,
	0xf3b73b3b, 0xf776368c, 0xfa352055, 0xfef42de2,
	0xc6bb605f, 0xc27a6de8, 0xcf397b31, 0xcbf87686,
	0xd5bf5683, 0xd17e5b34, 0xdc3d4ded, 0xd8fc405a,
	0x6904c0ee, 0x6dc5cd59, 0x6086db80, 0x6447d637,
	0x7a00f632, 0x7ec1fb85, 0x7382ed5c, 0x7743e0eb,
	0x4f0cad56, 0x4bcda0e1, 0x468eb638, 0x424fbb8f,
	0x5c089b8a, 0x58c9963d, 0x558a80e4, 0x514b8d53,
	0x25141b9e, 0x21d51629, 0x2c9600f0, 0x28570d47,
	0x36102d42, 0x32d120f5, 0x3f92362c, 0x3b533b9b,
	0x031c7626, 0x07dd7b91, 0x0a9e6d48, 0x0e5f60ff,
	0x101840fa, 0x14d94d4d, 0x199a5b94, 0x1d5b5623,
	0xf125760e, 0xf5e47bb9, 0xf8a76d60, 0xfc6660d7,
	0xe22140d2, 0xe6e04d65, 0xeba35bbc, 0xef62560b,
	0xd72d1bb6, 0xd3ec1601, 0xdeaf00d8, 0xda6e0d6f,
	0xc4292d6a, 0xc0e820dd, 0xcdab3604, 0xc96a3bb3,
	0xbd35ad7e, 0xb9f4a0c9, 0xb4b7b610, 0xb076bba7,
	0xae319ba2, 0xaaf09615, 0xa7b380cc, 0xa3728d7b,
	0x9b3dc0c6, 0x9ffccd71, 0x92bfdba8, 0x967ed61f,
	0x8839f61a, 0x8cf8fbad, 0x81bbed74, 0x857ae0c3,
	0x5d86a099, 0x5947ad2e, 0x5404bbf7, 0x50c5b640,
	0x4e829645, 0x4a439bf2, 0x47008d2b, 0x43c1809c,
	0x7b8ecd21, 0x7f4fc096, 0x720cd64f, 0x76cddbf8,
	0x688afbfd, 0x6c4bf64a, 0x6108e093, 0x65c9ed24,
	0x11967be9, 0x1557765e, 0x18146087, 0x1cd56d30,
	0x02924d35, 0x06534082, 0x0b10565b, 0x0fd15bec,
	0x379e1651, 0x335f1be6, 0x3e1c0d3f, 0x3add0088,
	0x249a208d, 0x205b2d3a, 0x2d183be3, 0x29d93654,
	0xc5a71679, 0xc1661bce, 0xcc250d17, 0xc8e400a0,
	0xd6a320a5, 0xd2622d12, 0xdf213bcb, 0xdbe0367c,
	0xe3af7bc1, 0xe76e7676, 0xea2d60af, 0xeeec6d18,
	0xf0ab4d1d, 0xf46a40aa, 0xf9295673, 0xfde85bc4,
	0x89b7cd09, 0x8d76c0be, 0x8035d667, 0x84f4dbd0,
	0x9ab3fbd5, 0x9e72f662, 0x9331e0bb, 0x97f0ed0c,
	0xafbfa0b1, 0xab7ead06, 0xa63dbbdf, 0xa2fcb668,
	0xbcbb966d, 0xb87a9bda, 0xb5398d03, 0xb1f880b4,
	);

########## Functions ##########

sub calculate_rkcrc {
  my ($data) = @_;
  
  my $crc = 0;
  
  my $data_size = length($data);
  my $idx = 0;
  for ( my $idx = 0 ; $idx < $data_size ; $idx++ ) {
    $crc = $crc << 8 ^ $crc_table[$crc >> 24 ^ unpack( "C", substr( $data, $idx, 1 ) )];
    $crc = $crc % 0x100000000;
  }
  
  return $crc;
}

sub read_kernel {
  my ($srcfile) = @_;
  
  my $buffer;

  my $filesize = -s $srcfile;
  
  open INF, $srcfile
    or die "\nCan't open $srcfile for reading: $!\n";

  binmode INF;

  read (INF, $buffer, $filesize);

  close INF
    or die "Can't close $srcfile: $!\n";

  return $buffer;
}

sub parse_table_data {
  my ($table_data) = @_;

  my @table;

  my $table_size = length( $table_data ) / 8 - 1;
  for ( my $idx = 0 ; $idx < $table_size ; $idx++ ) {
    my $volt = unpack( "V", substr( $table_data, $idx * 8, 4 ) );
    my $freq = unpack( "V", substr( $table_data, $idx * 8 + 4, 4 ) );
    my @entry = ( $volt, $freq );
    push( @table, \@entry );
  }
    
  return \@table;
}

sub pack_table_data {
  my ($table_ref) = @_;

  my $table_data = "";

  for my $entry_ref ( @$table_ref ) {
    my ( $volt, $freq ) = @$entry_ref;
    $table_data .= pack( "V", $volt );
    $table_data .= pack( "V", $freq );
  }
  $table_data .= $freq_table_end;
  
  return $table_data;
}

sub find_tables {
  my ($buffer, $freq_list_ref, $volt_list_ref) = @_;
  
  my $regex="((" . join("|", map { my $packed = pack("V", $_); "\Q$packed\E" } @$volt_list_ref) . ")(" . join("|", map { my $packed = pack("V", $_); "\Q$packed\E" } @$freq_list_ref) . "))+" . $freq_table_end;

  my %tables;
  while ($buffer =~ /$regex/gs) {
    $tables{ $-[0] } = parse_table_data( ${^MATCH} );
  }
  
  return \%tables;
}

sub display_table {
  my ($table_ref) = @_;
  print "MHz\tmV\n";
  for my $entry_ref ( @$table_ref ) {
    my ( $volt, $freq ) = @$entry_ref;
    print int($freq/1000);
    print "\t";
    print int($volt/1000);
    if ( $freq%1000 > 0 ) {
      print "\t" . $ddr_freq_type_map{ $freq%1000 };
    }
    print "\n";
  }
}

########## Main ##########

print "=============================\n";
print "Rockchip Patchomatic Suite\n";
print "Overclockomatic RK3188 v1.2\n";
print "by phjanderson\n";
print "=============================\n\n";

if ( @ARGV != 1 ) {
  print "Error: no kernel image specified\n\n";
  print "Please specify a kernel image file name\n\n";
  exit( -1 );
}

my $srcfile = $ARGV[0];

my $target_base = $srcfile;
$target_base =~ s/\.[^.]+$//;

my $target_ext = substr( $srcfile, length( $target_base ) );

print "Reading kernel image\n";
my $buffer = read_kernel( $srcfile );
print "Done!\n\n";


print "Searching GPU frequency limit cap\n";
my $gpu_cap_found = 0;
for my $gpu_cap_search (@gpu_cap_search_list) {
  my $gpu_cap_search_data = pack("V", $gpu_cap_search->[0]) . pack("V", $gpu_cap_search->[1]);
  my $gpu_cap_search_count =()= $buffer =~ /\Q$gpu_cap_search_data\E/g;
  if ( $gpu_cap_search_count == 1 ) {
    print "Found: " . $gpu_cap_search->[0] . ", " . $gpu_cap_search->[1] . "\n";
    print "Patching...\n";
    my $gpu_cap_replace_data = pack("V", $gpu_cap_replace[0]) . pack("V", $gpu_cap_replace[1]);
    $buffer =~ s/\Q$gpu_cap_search_data\E/$gpu_cap_replace_data/g;
    $gpu_cap_found = 1;
    last;
  }
}
if( !$gpu_cap_found ) {
  print "Warning: unable to patch the GPU frequency limit cap!\n";

  print "Searching GPU frequency limit cap (reversed)\n";
  $gpu_cap_found = 0;
  for my $gpu_cap_search (@gpu_cap_search_list) {
    my $gpu_cap_search_data = pack("V", $gpu_cap_search->[1]) . pack("V", $gpu_cap_search->[0]);
    my $gpu_cap_search_count =()= $buffer =~ /\Q$gpu_cap_search_data\E/g;
    if ( $gpu_cap_search_count == 1 ) {
      print "Found: " . $gpu_cap_search->[0] . ", " . $gpu_cap_search->[1] . "\n";
      print "Patching...\n";
      my $gpu_cap_replace_data = pack("V", $gpu_cap_replace[1]) . pack("V", $gpu_cap_replace[0]);
      $buffer =~ s/\Q$gpu_cap_search_data\E/$gpu_cap_replace_data/g;
      $gpu_cap_found = 1;
      last;
    }
  }
  if( !$gpu_cap_found ) {
    print "Warning: unable to patch the GPU frequency limit cap (reversed)!\n";
  }
}
print "\n";


print "Searching volt/frequency tables\n";
my $tables_ref = find_tables( $buffer, \@freq_list, \@volt_list );
my %tables = %$tables_ref;
print "Done!\n\n";

if ( scalar keys %tables < 3 ) {
  print "Error: found only " . ( scalar keys %tables ) . " frequency tables, at least 3 are needed\n\n";
  exit( -1 );
}

print "Volt/frequency tables found in the image:\n";
my $table_idx = 1;
my %table_idx_offset_map;
for my $offset ( sort { $a <=> $b } keys %tables ) {
  my $table_ref = $tables{ $offset };

  $table_idx_offset_map{ $table_idx } = $offset;

  print "== Table $table_idx at offset $offset ==\n";
  
  display_table( $table_ref );
  
  print "\n";
  
  $table_idx++;
}

print "== End of tables ==\n\n";

print "Please identify the CPU, GPU and DDR table. Press ctrl-c to cancel.\n\n";

my $input;

my $cpu_table_offset = 0;
do {
  print "Which table is the CPU table?\n";
  print "(The CPU table is mostly the largest table ranging from 312 to 1608 MHz)\n";
  chomp ($input = <STDIN>);
  if ( exists $table_idx_offset_map{ int($input) } ) {
    $cpu_table_offset = $table_idx_offset_map{ int($input) };
  }
  else {
    print "Table does not exist.\n";
  }
  print "\n";
} until ( $cpu_table_offset != 0 );
my $cpu_table_ref = $tables{$cpu_table_offset};
my $cpu_table_length = @$cpu_table_ref;

my $gpu_table_offset = 0;
do {
  print "Which table is the GPU table?\n";
  print "(The GPU table is mostly the second largest table ranging from 133 to 600 MHz)\n";
  chomp ($input = <STDIN>);
  if ( exists $table_idx_offset_map{ int($input) } ) {
    $gpu_table_offset = $table_idx_offset_map{ int($input) };
  }
  else {
    print "Table does not exist.\n";
  }
  print "\n";
} until ( $gpu_table_offset != 0 );
my $gpu_table_ref = $tables{$gpu_table_offset};
my $gpu_table_length = @$gpu_table_ref;

my $ddr_table_offset = 0;
do {
  print "Which table is the DDR table?\n";
  print "(The DDR table is mostly quite short, mostly 2 entries, and can be recognized by the labels DDR_FREQ_... at the end of each line)\n";
  chomp ($input = <STDIN>);
  if ( exists $table_idx_offset_map{ int($input) } ) {
    $ddr_table_offset = $table_idx_offset_map{ int($input) };
  }
  else {
    print "Table does not exist.\n";
  }
  print "\n";
} until ( $ddr_table_offset != 0 );
my $ddr_table_ref = $tables{$ddr_table_offset};
my $ddr_table_length = @$ddr_table_ref;

print "Patching kernels... please wait...\n\n";

foreach my $cpu_profile_key (keys %cpu_profiles) {
  foreach my $gpu_profile_key (keys %gpu_profiles) {
    foreach my $ddr_profile_key (keys %ddr_profiles) {
      my $target_buffer = $buffer;
      
      my $cpu_profile_table_ref = $cpu_profiles{ $cpu_profile_key };
      my $cpu_profile_table_length = 0;
      if ( $cpu_profile_table_ref != 0 ) {
        $cpu_profile_table_length = @{$cpu_profile_table_ref};
      }

      my $gpu_profile_table_ref = $gpu_profiles{ $gpu_profile_key };
      my $gpu_profile_table_length = 0;
      if ( $gpu_profile_table_ref != 0 ) {
        $gpu_profile_table_length = @{$gpu_profile_table_ref};
      }

      my $ddr_profile_table_ref = $ddr_profiles{ $ddr_profile_key };
      my $ddr_profile_table_length = 0;
      if ( $ddr_profile_table_ref != 0 ) {
        $ddr_profile_table_length = @{$ddr_profile_table_ref};
      }
      
      if ( $cpu_profile_table_ref != 0 ) {
        if ( $cpu_profile_table_length > $cpu_table_length ) {
          print "ERROR: CPU profile table $cpu_profile_key is larger than the CPU table in the kernel";
          exit -1;
        }
        else {
          my $new_cpu_table_data = pack_table_data( $cpu_profile_table_ref ) . ($freq_table_end x ($cpu_table_length - $cpu_profile_table_length));
          my $new_cpu_table_data_length = length( $new_cpu_table_data );
          
          $target_buffer = substr( $target_buffer, 0, $cpu_table_offset) . $new_cpu_table_data . substr( $target_buffer, $cpu_table_offset + $new_cpu_table_data_length);
        }
      }
      else {
        #print "CPU stock mode, not patching the CPU table\n";
      }

      if ( $gpu_profile_table_ref != 0 ) {
        if ( $gpu_profile_table_length > $gpu_table_length ) {
          print "ERROR: GPU profile table $gpu_profile_key is larger than the GPU table in the kernel";
          exit -1;
        }
        else {
          my $new_gpu_table_data = pack_table_data( $gpu_profile_table_ref ) . ($freq_table_end x ($gpu_table_length - $gpu_profile_table_length));
          my $new_gpu_table_data_length = length( $new_gpu_table_data );
          
          $target_buffer = substr( $target_buffer, 0, $gpu_table_offset) . $new_gpu_table_data . substr( $target_buffer, $gpu_table_offset + $new_gpu_table_data_length);
        }
      }
      else {
        #print "GPU stock mode, not patching the GPU table\n";
      }

      if ( $ddr_profile_table_ref != 0 ) {
        if ( $ddr_profile_table_length > $ddr_table_length ) {
          print "ERROR: DDR profile table $ddr_profile_key is larger than the DDR table in the kernel";
          exit -1;
        }
        else {
          my $new_ddr_table_data = pack_table_data( $ddr_profile_table_ref ) . ($freq_table_end x ($ddr_table_length - $ddr_profile_table_length));
          my $new_ddr_table_data_length = length( $new_ddr_table_data );
          
          $target_buffer = substr( $target_buffer, 0, $ddr_table_offset) . $new_ddr_table_data . substr( $target_buffer, $ddr_table_offset + $new_ddr_table_data_length);
        }
      }
      else {
        #print "DDR stock mode, not patching the DDR table\n";
      }

      my $crc = calculate_rkcrc( substr( $target_buffer, 8, -4 ) );
      $target_buffer = substr( $target_buffer, 0, -4 ) . pack( "V", $crc );

      my $target_file = $target_base . "_" . $cpu_profile_key . "_" . $gpu_profile_key . "_" . $ddr_profile_key . $target_ext;
      
      print "Writing $target_file\n";
      
      open OUTF, ">$target_file"
        or die "\nCan't open $target_file for writing: $!\n";

      binmode OUTF;

      print OUTF $target_buffer;

      close OUTF
        or die "Can't close $target_file: $!\n";
    }
  }
}

print "\nAll done!\n";