Changeset 5556

Show
Ignore:
Timestamp:
12/11/08 14:46:28 (5 years ago)
Author:
khali
Message:

Add parentheses to all printl-like function calls, for clarity.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • i2c-tools/trunk/eeprom/decode-dimms

    r5555 r5556  
    440440 
    441441# SPD revision 
    442         printl "SPD Revision", $bytes->[62]; 
     442        printl("SPD Revision", $bytes->[62]); 
    443443 
    444444#size computation 
    445445 
    446         prints "Memory Characteristics"; 
     446        prints("Memory Characteristics"); 
    447447 
    448448        my $k = 0; 
     
    455455 
    456456        if ($ii > 0 && $ii <= 12 && $k > 0) { 
    457                 printl "Size", ((1 << $ii) * $k) . " MB"; 
     457                printl("Size", ((1 << $ii) * $k) . " MB"); 
    458458        } else { 
    459                 printl "INVALID SIZE", $bytes->[3] . "," . $bytes->[4] . "," . 
    460                                        $bytes->[5] . "," . $bytes->[17]; 
     459                printl("INVALID SIZE", $bytes->[3] . "," . $bytes->[4] . "," . 
     460                                       $bytes->[5] . "," . $bytes->[17]); 
    461461        } 
    462462 
     
    475475        $tras = $bytes->[30]; 
    476476 
    477         printl "tCL-tRCD-tRP-tRAS", 
     477        printl("tCL-tRCD-tRP-tRAS", 
    478478                $cas[$#cas] . "-" . 
    479479                ceil($trcd/$ctime) . "-" . 
    480480                ceil($trp/$ctime) . "-" . 
    481                 ceil($tras/$ctime); 
     481                ceil($tras/$ctime)); 
    482482 
    483483        $l = "Number of Row Address Bits"; 
    484         if ($bytes->[3] == 0) { printl $l, "Undefined!"; } 
    485         elsif ($bytes->[3] == 1) { printl $l, "1/16"; } 
    486         elsif ($bytes->[3] == 2) { printl $l, "2/17"; } 
    487         elsif ($bytes->[3] == 3) { printl $l, "3/18"; } 
    488         else { printl $l, $bytes->[3]; } 
     484        if ($bytes->[3] == 0) { printl($l, "Undefined!"); } 
     485        elsif ($bytes->[3] == 1) { printl($l, "1/16"); } 
     486        elsif ($bytes->[3] == 2) { printl($l, "2/17"); } 
     487        elsif ($bytes->[3] == 3) { printl($l, "3/18"); } 
     488        else { printl($l, $bytes->[3]); } 
    489489 
    490490        $l = "Number of Col Address Bits"; 
    491         if ($bytes->[4] == 0) { printl $l, "Undefined!"; } 
    492         elsif ($bytes->[4] == 1) { printl $l, "1/16"; } 
    493         elsif ($bytes->[4] == 2) { printl $l, "2/17"; } 
    494         elsif ($bytes->[4] == 3) { printl $l, "3/18"; } 
    495         else { printl $l, $bytes->[4]; } 
     491        if ($bytes->[4] == 0) { printl($l, "Undefined!"); } 
     492        elsif ($bytes->[4] == 1) { printl($l, "1/16"); } 
     493        elsif ($bytes->[4] == 2) { printl($l, "2/17"); } 
     494        elsif ($bytes->[4] == 3) { printl($l, "3/18"); } 
     495        else { printl($l, $bytes->[4]); } 
    496496 
    497497        $l = "Number of Module Rows"; 
    498         if ($bytes->[5] == 0 ) { printl $l, "Undefined!"; } 
    499         else { printl $l, $bytes->[5]; } 
     498        if ($bytes->[5] == 0 ) { printl($l, "Undefined!"); } 
     499        else { printl($l, $bytes->[5]); } 
    500500 
    501501        $l = "Data Width"; 
    502502        if ($bytes->[7] > 1) { 
    503                 printl $l, "Undefined!" 
     503                printl($l, "Undefined!"); 
    504504        } else { 
    505505                $temp = ($bytes->[7] * 256) + $bytes->[6]; 
    506                 printl $l, $temp; 
     506                printl($l, $temp); 
    507507        } 
    508508 
    509509        $l = "Module Interface Signal Levels"; 
    510         if ($bytes->[8] == 0) { printl $l, "5.0 Volt/TTL"; } 
    511         elsif ($bytes->[8] == 1) { printl $l, "LVTTL"; } 
    512         elsif ($bytes->[8] == 2) { printl $l, "HSTL 1.5"; } 
    513         elsif ($bytes->[8] == 3) { printl $l, "SSTL 3.3"; } 
    514         elsif ($bytes->[8] == 4) { printl $l, "SSTL 2.5"; } 
    515         elsif ($bytes->[8] == 255) { printl $l, "New Table"; } 
    516         else { printl $l, "Undefined!"; } 
     510        if ($bytes->[8] == 0) { printl($l, "5.0 Volt/TTL"); } 
     511        elsif ($bytes->[8] == 1) { printl($l, "LVTTL"); } 
     512        elsif ($bytes->[8] == 2) { printl($l, "HSTL 1.5"); } 
     513        elsif ($bytes->[8] == 3) { printl($l, "SSTL 3.3"); } 
     514        elsif ($bytes->[8] == 4) { printl($l, "SSTL 2.5"); } 
     515        elsif ($bytes->[8] == 255) { printl($l, "New Table"); } 
     516        else { printl($l, "Undefined!"); } 
    517517 
    518518        $l = "Module Configuration Type"; 
    519         if ($bytes->[11] == 0) { printl $l, "No Parity"; } 
    520         elsif ($bytes->[11] == 1) { printl $l, "Parity"; } 
    521         elsif ($bytes->[11] == 2) { printl $l, "ECC"; } 
    522         else { printl $l, "Undefined!"; } 
     519        if ($bytes->[11] == 0) { printl($l, "No Parity"); } 
     520        elsif ($bytes->[11] == 1) { printl($l, "Parity"); } 
     521        elsif ($bytes->[11] == 2) { printl($l, "ECC"); } 
     522        else { printl($l, "Undefined!"); } 
    523523 
    524524        $l = "Refresh Type"; 
    525         if ($bytes->[12] > 126) { printl $l, "Self Refreshing"; } 
    526         else { printl $l, "Not Self Refreshing"; } 
     525        if ($bytes->[12] > 126) { printl($l, "Self Refreshing"); } 
     526        else { printl($l, "Not Self Refreshing"); } 
    527527 
    528528        $l = "Refresh Rate"; 
    529529        $temp = $bytes->[12] & 0x7f; 
    530         if ($temp == 0) { printl $l, "Normal (15.625 us)"; } 
    531         elsif ($temp == 1) { printl $l, "Reduced (3.9 us)"; } 
    532         elsif ($temp == 2) { printl $l, "Reduced (7.8 us)"; } 
    533         elsif ($temp == 3) { printl $l, "Extended (31.3 us)"; } 
    534         elsif ($temp == 4) { printl $l, "Extended (62.5 us)"; } 
    535         elsif ($temp == 5) { printl $l, "Extended (125 us)"; } 
    536         else { printl $l, "Undefined!"; } 
     530        if ($temp == 0) { printl($l, "Normal (15.625 us)"); } 
     531        elsif ($temp == 1) { printl($l, "Reduced (3.9 us)"); } 
     532        elsif ($temp == 2) { printl($l, "Reduced (7.8 us)"); } 
     533        elsif ($temp == 3) { printl($l, "Extended (31.3 us)"); } 
     534        elsif ($temp == 4) { printl($l, "Extended (62.5 us)"); } 
     535        elsif ($temp == 5) { printl($l, "Extended (125 us)"); } 
     536        else { printl($l, "Undefined!"); } 
    537537 
    538538        $l = "Primary SDRAM Component Bank Config"; 
    539         if ($bytes->[13] > 126) { printl $l, "Bank2 = 2 x Bank1"; } 
    540         else { printl $l, "No Bank2 OR Bank2 = Bank1 width"; } 
     539        if ($bytes->[13] > 126) { printl($l, "Bank2 = 2 x Bank1"); } 
     540        else { printl($l, "No Bank2 OR Bank2 = Bank1 width"); } 
    541541 
    542542        $l = "Primary SDRAM Component Widths"; 
    543543        $temp = $bytes->[13] & 0x7f; 
    544         if ($temp == 0) { printl $l, "Undefined!"; } 
    545         else { printl $l, $temp; } 
     544        if ($temp == 0) { printl($l, "Undefined!"); } 
     545        else { printl($l, $temp); } 
    546546 
    547547        $l = "Error Checking SDRAM Component Bank Config"; 
    548         if ($bytes->[14] > 126) { printl $l, "Bank2 = 2 x Bank1"; } 
    549         else { printl $l, "No Bank2 OR Bank2 = Bank1 width"; } 
     548        if ($bytes->[14] > 126) { printl($l, "Bank2 = 2 x Bank1"); } 
     549        else { printl($l, "No Bank2 OR Bank2 = Bank1 width"); } 
    550550 
    551551        $l = "Error Checking SDRAM Component Widths"; 
    552552        $temp = $bytes->[14] & 0x7f; 
    553         if ($temp == 0) { printl $l, "Undefined!"; } 
    554         else { printl $l, $temp; } 
     553        if ($temp == 0) { printl($l, "Undefined!"); } 
     554        else { printl($l, $temp); } 
    555555 
    556556        $l = "Min Clock Delay for Back to Back Random Access"; 
    557         if ($bytes->[15] == 0) { printl $l, "Undefined!"; } 
    558         else { printl $l, $bytes->[15]; } 
     557        if ($bytes->[15] == 0) { printl($l, "Undefined!"); } 
     558        else { printl($l, $bytes->[15]); } 
    559559 
    560560        $l = "Supported Burst Lengths"; 
     
    566566        if (@array) { $temp = join ', ', @array; } 
    567567        else { $temp = "None"; } 
    568         printl $l, $temp; 
     568        printl($l, $temp); 
    569569 
    570570        $l = "Number of Device Banks"; 
    571         if ($bytes->[17] == 0) { printl $l, "Undefined/Reserved!"; } 
    572         else { printl $l, $bytes->[17]; } 
     571        if ($bytes->[17] == 0) { printl($l, "Undefined/Reserved!"); } 
     572        else { printl($l, $bytes->[17]); } 
    573573 
    574574        $l = "Supported CAS Latencies"; 
    575         printl $l, cas_latencies(@cas); 
     575        printl($l, cas_latencies(@cas)); 
    576576 
    577577        $l = "Supported CS Latencies"; 
     
    582582        if (@array) { $temp = join ', ', @array; } 
    583583        else { $temp = "None"; } 
    584         printl $l, $temp; 
     584        printl($l, $temp); 
    585585 
    586586        $l = "Supported WE Latencies"; 
     
    591591        if (@array) { $temp = join ', ', @array; } 
    592592        else { $temp = "None"; } 
    593         printl $l, $temp; 
     593        printl($l, $temp); 
    594594 
    595595        if (@cas >= 1) { 
    596596                $l = "Cycle Time at CAS ".$cas[$#cas]; 
    597                 printl $l, "$ctime ns"; 
     597                printl($l, "$ctime ns"); 
    598598 
    599599                $l = "Access Time at CAS ".$cas[$#cas]; 
    600600                $temp = ($bytes->[10] >> 4) + ($bytes->[10] & 0xf) * 0.1; 
    601                 printl $l, "$temp ns"; 
     601                printl($l, "$temp ns"); 
    602602        } 
    603603 
     
    605605                $l = "Cycle Time at CAS ".$cas[$#cas-1]; 
    606606                $temp = $bytes->[23] >> 4; 
    607                 if ($temp == 0) { printl $l, "Undefined!"; } 
     607                if ($temp == 0) { printl($l, "Undefined!"); } 
    608608                else { 
    609609                        if ($temp < 4 ) { $temp += 15; } 
    610                         printl $l, $temp + (($bytes->[23] & 0xf) * 0.1) . " ns"; 
     610                        printl($l, $temp + (($bytes->[23] & 0xf) * 0.1) . " ns"); 
    611611                } 
    612612 
    613613                $l = "Access Time at CAS ".$cas[$#cas-1]; 
    614614                $temp = $bytes->[24] >> 4; 
    615                 if ($temp == 0) { printl $l, "Undefined!"; } 
     615                if ($temp == 0) { printl($l, "Undefined!"); } 
    616616                else { 
    617617                        if ($temp < 4 ) { $temp += 15; } 
    618                         printl $l, $temp + (($bytes->[24] & 0xf) * 0.1) . " ns"; 
     618                        printl($l, $temp + (($bytes->[24] & 0xf) * 0.1) . " ns"); 
    619619                } 
    620620        } 
     
    623623                $l = "Cycle Time at CAS ".$cas[$#cas-2]; 
    624624                $temp = $bytes->[25] >> 2; 
    625                 if ($temp == 0) { printl $l, "Undefined!"; } 
    626                 else { printl $l, $temp + ($bytes->[25] & 0x3) * 0.25 . " ns"; } 
     625                if ($temp == 0) { printl($l, "Undefined!"); } 
     626                else { printl($l, $temp + ($bytes->[25] & 0x3) * 0.25 . " ns"); } 
    627627 
    628628                $l = "Access Time at CAS ".$cas[$#cas-2]; 
    629629                $temp = $bytes->[26] >> 2; 
    630                 if ($temp == 0) { printl $l, "Undefined!"; } 
    631                 else { printl $l, $temp + ($bytes->[26] & 0x3) * 0.25 . " ns"; } 
     630                if ($temp == 0) { printl($l, "Undefined!"); } 
     631                else { printl($l, $temp + ($bytes->[26] & 0x3) * 0.25 . " ns"); } 
    632632        } 
    633633 
     
    643643        if ($bytes->[21] & 128) { $temp .= "Undefined (bit 7)\n"; } 
    644644        if ($bytes->[21] == 0) { $temp .= "(None Reported)\n"; } 
    645         printl $l, $temp; 
     645        printl($l, $temp); 
    646646 
    647647        $l = "SDRAM Device Attributes (General)"; 
     
    657657        if ($bytes->[22] & 64) { $temp .= "Undefined (bit 6)\n"; } 
    658658        if ($bytes->[22] & 128) { $temp .= "Undefined (bit 7)\n"; } 
    659         printl $l, $temp; 
     659        printl($l, $temp); 
    660660 
    661661        $l = "Minimum Row Precharge Time"; 
    662         if ($bytes->[27] == 0) { printl $l, "Undefined!"; } 
    663         else { printl $l, "$bytes->[27] ns"; } 
     662        if ($bytes->[27] == 0) { printl($l, "Undefined!"); } 
     663        else { printl($l, "$bytes->[27] ns"); } 
    664664 
    665665        $l = "Row Active to Row Active Min"; 
    666         if ($bytes->[28] == 0) { printl $l, "Undefined!"; } 
    667         else { printl $l, "$bytes->[28] ns"; } 
     666        if ($bytes->[28] == 0) { printl($l, "Undefined!"); } 
     667        else { printl($l, "$bytes->[28] ns"); } 
    668668 
    669669        $l = "RAS to CAS Delay"; 
    670         if ($bytes->[29] == 0) { printl $l, "Undefined!"; } 
    671         else { printl $l, "$bytes->[29] ns"; } 
     670        if ($bytes->[29] == 0) { printl($l, "Undefined!"); } 
     671        else { printl($l, "$bytes->[29] ns"); } 
    672672 
    673673        $l = "Min RAS Pulse Width"; 
    674         if ($bytes->[30] == 0) { printl $l, "Undefined!"; } 
    675         else { printl $l, "$bytes->[30] ns"; } 
     674        if ($bytes->[30] == 0) { printl($l, "Undefined!"); } 
     675        else { printl($l, "$bytes->[30] ns"); } 
    676676 
    677677        $l = "Row Densities"; 
     
    686686        if ($bytes->[31] & 128) { $temp .= "512 MByte\n"; } 
    687687        if ($bytes->[31] == 0) { $temp .= "(Undefined! -- None Reported!)\n"; } 
    688         printl $l, $temp; 
     688        printl($l, $temp); 
    689689 
    690690        if (($bytes->[32] & 0xf) <= 9) { 
    691691                $l = "Command and Address Signal Setup Time"; 
    692692                $temp = (($bytes->[32] & 0x7f) >> 4) + ($bytes->[32] & 0xf) * 0.1; 
    693                 printl $l, (($bytes->[32] >> 7) ? -$temp : $temp) . " ns"; 
     693                printl($l, (($bytes->[32] >> 7) ? -$temp : $temp) . " ns"); 
    694694        } 
    695695 
     
    697697                $l = "Command and Address Signal Hold Time"; 
    698698                $temp = (($bytes->[33] & 0x7f) >> 4) + ($bytes->[33] & 0xf) * 0.1; 
    699                 printl $l, (($bytes->[33] >> 7) ? -$temp : $temp) . " ns"; 
     699                printl($l, (($bytes->[33] >> 7) ? -$temp : $temp) . " ns"); 
    700700        } 
    701701 
     
    703703                $l = "Data Signal Setup Time"; 
    704704                $temp = (($bytes->[34] & 0x7f) >> 4) + ($bytes->[34] & 0xf) * 0.1; 
    705                 printl $l, (($bytes->[34] >> 7) ? -$temp : $temp) . " ns"; 
     705                printl($l, (($bytes->[34] >> 7) ? -$temp : $temp) . " ns"); 
    706706        } 
    707707 
     
    709709                $l = "Data Signal Hold Time"; 
    710710                $temp = (($bytes->[35] & 0x7f) >> 4) + ($bytes->[35] & 0xf) * 0.1; 
    711                 printl $l, (($bytes->[35] >> 7) ? -$temp : $temp) . " ns"; 
     711                printl($l, (($bytes->[35] >> 7) ? -$temp : $temp) . " ns"); 
    712712        } 
    713713} 
     
    721721# SPD revision 
    722722        if ($bytes->[62] != 0xff) { 
    723                 printl "SPD Revision", ($bytes->[62] >> 4) . "." . 
    724                                        ($bytes->[62] & 0xf); 
     723                printl("SPD Revision", ($bytes->[62] >> 4) . "." . 
     724                                       ($bytes->[62] & 0xf)); 
    725725        } 
    726726 
    727727# speed 
    728         prints "Memory Characteristics"; 
     728        prints("Memory Characteristics"); 
    729729 
    730730        $l = "Maximum module speed"; 
     
    737737        $pcclk = $pcclk - ($pcclk % 100); 
    738738        $ddrclk = int ($ddrclk); 
    739         printl $l, "${ddrclk}MHz (PC${pcclk})"; 
     739        printl($l, "${ddrclk}MHz (PC${pcclk})"); 
    740740 
    741741#size computation 
     
    749749 
    750750        if ($ii > 0 && $ii <= 12 && $k > 0) { 
    751                 printl "Size", ((1 << $ii) * $k) . " MB"; 
     751                printl("Size", ((1 << $ii) * $k) . " MB"); 
    752752        } else { 
    753                 printl "INVALID SIZE", $bytes->[3] . ", " . $bytes->[4] . ", " . 
    754                                        $bytes->[5] . ", " . $bytes->[17]; 
     753                printl("INVALID SIZE", $bytes->[3] . ", " . $bytes->[4] . ", " . 
     754                                       $bytes->[5] . ", " . $bytes->[17]); 
    755755        } 
    756756 
     
    773773        $tras = $bytes->[30]; 
    774774 
    775         printl "tCL-tRCD-tRP-tRAS", 
     775        printl("tCL-tRCD-tRP-tRAS", 
    776776                $highestCAS . "-" . 
    777777                ceil($trcd/$ctime) . "-" . 
    778778                ceil($trp/$ctime) . "-" . 
    779                 ceil($tras/$ctime); 
     779                ceil($tras/$ctime)); 
    780780 
    781781# latencies 
    782         printl "Supported CAS Latencies", cas_latencies(keys %cas); 
     782        printl("Supported CAS Latencies", cas_latencies(keys %cas)); 
    783783 
    784784        my @array; 
     
    788788        if (@array) { $temp = join ', ', @array; } 
    789789        else { $temp = "None"; } 
    790         printl "Supported CS Latencies", $temp; 
     790        printl("Supported CS Latencies", $temp); 
    791791 
    792792        @array = (); 
     
    796796        if (@array) { $temp = join ', ', @array; } 
    797797        else { $temp = "None"; } 
    798         printl "Supported WE Latencies", $temp; 
     798        printl("Supported WE Latencies", $temp); 
    799799 
    800800# timings 
    801801        if (exists $cas{$highestCAS}) { 
    802                 printl "Minimum Cycle Time at CAS $highestCAS", 
    803                        "$ctime ns"; 
    804  
    805                 printl "Maximum Access Time at CAS $highestCAS", 
    806                        (($bytes->[10] >> 4) * 0.1 + ($bytes->[10] & 0xf) * 0.01) . " ns"; 
     802                printl("Minimum Cycle Time at CAS $highestCAS", 
     803                       "$ctime ns"); 
     804 
     805                printl("Maximum Access Time at CAS $highestCAS", 
     806                       (($bytes->[10] >> 4) * 0.1 + ($bytes->[10] & 0xf) * 0.01) . " ns"); 
    807807        } 
    808808 
    809809        if (exists $cas{$highestCAS-0.5} && spd_written(@$bytes[23..24])) { 
    810                 printl "Minimum Cycle Time at CAS ".($highestCAS-0.5), 
    811                        (($bytes->[23] >> 4) + ($bytes->[23] & 0xf) * 0.1) . " ns"; 
    812  
    813                 printl "Maximum Access Time at CAS ".($highestCAS-0.5), 
    814                        (($bytes->[24] >> 4) * 0.1 + ($bytes->[24] & 0xf) * 0.01) . " ns"; 
     810                printl("Minimum Cycle Time at CAS ".($highestCAS-0.5), 
     811                       (($bytes->[23] >> 4) + ($bytes->[23] & 0xf) * 0.1) . " ns"); 
     812 
     813                printl("Maximum Access Time at CAS ".($highestCAS-0.5), 
     814                       (($bytes->[24] >> 4) * 0.1 + ($bytes->[24] & 0xf) * 0.01) . " ns"); 
    815815        } 
    816816 
    817817        if (exists $cas{$highestCAS-1} && spd_written(@$bytes[25..26])) { 
    818                 printl "Minimum Cycle Time at CAS ".($highestCAS-1), 
    819                        (($bytes->[25] >> 4) + ($bytes->[25] & 0xf) * 0.1) . " ns"; 
    820  
    821                 printl "Maximum Access Time at CAS ".($highestCAS-1), 
    822                        (($bytes->[26] >> 4) * 0.1 + ($bytes->[26] & 0xf) * 0.01) . " ns"; 
     818                printl("Minimum Cycle Time at CAS ".($highestCAS-1), 
     819                       (($bytes->[25] >> 4) + ($bytes->[25] & 0xf) * 0.1) . " ns"); 
     820 
     821                printl("Maximum Access Time at CAS ".($highestCAS-1), 
     822                       (($bytes->[26] >> 4) * 0.1 + ($bytes->[26] & 0xf) * 0.01) . " ns"); 
    823823        } 
    824824 
     
    828828                elsif (($bytes->[47] & 0x03) == 0x02) { $temp = "1.7\""; } 
    829829                elsif (($bytes->[47] & 0x03) == 0x03) { $temp = "Other"; } 
    830                 printl "Module Height", $temp; 
     830                printl("Module Height", $temp); 
    831831        } 
    832832} 
     
    901901# SPD revision 
    902902        if ($bytes->[62] != 0xff) { 
    903                 printl "SPD Revision", ($bytes->[62] >> 4) . "." . 
    904                                        ($bytes->[62] & 0xf); 
     903                printl("SPD Revision", ($bytes->[62] >> 4) . "." . 
     904                                       ($bytes->[62] & 0xf)); 
    905905        } 
    906906 
    907907# speed 
    908         prints "Memory Characteristics"; 
     908        prints("Memory Characteristics"); 
    909909 
    910910        $l = "Maximum module speed"; 
     
    917917        $pcclk = $pcclk - ($pcclk % 100); 
    918918        $ddrclk = int ($ddrclk); 
    919         printl $l, "${ddrclk}MHz (PC2-${pcclk})"; 
     919        printl($l, "${ddrclk}MHz (PC2-${pcclk})"); 
    920920 
    921921#size computation 
     
    927927 
    928928        if($ii > 0 && $ii <= 12 && $k > 0) { 
    929                 printl "Size", ((1 << $ii) * $k) . " MB"; 
     929                printl("Size", ((1 << $ii) * $k) . " MB"); 
    930930        } else { 
    931                 printl "INVALID SIZE", $bytes->[3] . "," . $bytes->[4] . "," . 
    932                                        $bytes->[5] . "," . $bytes->[17]; 
    933         } 
    934  
    935         printl "Banks x Rows x Columns x Bits", 
    936                join(' x ', $bytes->[17], $bytes->[3], $bytes->[4], $bytes->[6]); 
    937         printl "Ranks", ($bytes->[5] & 7) + 1; 
    938  
    939         printl "SDRAM Device Width", $bytes->[13]." bits"; 
     931                printl("INVALID SIZE", $bytes->[3] . "," . $bytes->[4] . "," . 
     932                                       $bytes->[5] . "," . $bytes->[17]); 
     933        } 
     934 
     935        printl("Banks x Rows x Columns x Bits", 
     936               join(' x ', $bytes->[17], $bytes->[3], $bytes->[4], $bytes->[6])); 
     937        printl("Ranks", ($bytes->[5] & 7) + 1); 
     938 
     939        printl("SDRAM Device Width", $bytes->[13]." bits"); 
    940940 
    941941        my @heights = ('< 25.4', '25.4', '25.4 - 30.0', '30.0', '30.5', '> 30.5'); 
    942         printl "Module Height", $heights[$bytes->[5] >> 5]." mm"; 
     942        printl("Module Height", $heights[$bytes->[5] >> 5]." mm"); 
    943943 
    944944        my @suptypes = ddr2_module_types($bytes->[20]); 
    945         printl "Module Type".(@suptypes > 1 ? 's' : ''), join(', ', @suptypes); 
    946  
    947         printl "DRAM Package", $bytes->[5] & 0x10 ? "Stack" : "Planar"; 
     945        printl("Module Type".(@suptypes > 1 ? 's' : ''), join(', ', @suptypes)); 
     946 
     947        printl("DRAM Package", $bytes->[5] & 0x10 ? "Stack" : "Planar"); 
    948948 
    949949        my @volts = ("TTL (5V Tolerant)", "LVTTL", "HSTL 1.5V", 
    950950                     "SSTL 3.3V", "SSTL 2.5V", "SSTL 1.8V", "TBD"); 
    951         printl "Voltage Interface Level", $volts[$bytes->[8]]; 
    952  
    953         printl "Refresh Rate", ddr2_refresh_rate($bytes->[12]); 
     951        printl("Voltage Interface Level", $volts[$bytes->[8]]); 
     952 
     953        printl("Refresh Rate", ddr2_refresh_rate($bytes->[12])); 
    954954 
    955955        my @burst; 
     
    957957        push @burst, 8 if ($bytes->[16] & 8); 
    958958        $burst[0] = 'None' if !@burst; 
    959         printl "Supported Burst Lengths", join(', ', @burst); 
     959        printl("Supported Burst Lengths", join(', ', @burst)); 
    960960 
    961961        my $highestCAS = 0; 
     
    976976        $tras = $bytes->[30]; 
    977977 
    978         printl "tCL-tRCD-tRP-tRAS", 
     978        printl("tCL-tRCD-tRP-tRAS", 
    979979                $highestCAS . "-" . 
    980980                ceil($trcd/$ctime) . "-" . 
    981981                ceil($trp/$ctime) . "-" . 
    982                 ceil($tras/$ctime); 
     982                ceil($tras/$ctime)); 
    983983 
    984984# latencies 
    985         printl "Supported CAS Latencies (tCL)", cas_latencies(keys %cas); 
     985        printl("Supported CAS Latencies (tCL)", cas_latencies(keys %cas)); 
    986986 
    987987# timings 
    988988        if (exists $cas{$highestCAS}) { 
    989                 printl "Minimum Cycle Time at CAS $highestCAS (tCK min)", 
    990                        tns($ctime); 
    991                 printl "Maximum Access Time at CAS $highestCAS (tAC)", 
    992                        tns(ddr2_sdram_atime($bytes->[10])); 
     989                printl("Minimum Cycle Time at CAS $highestCAS (tCK min)", 
     990                       tns($ctime)); 
     991                printl("Maximum Access Time at CAS $highestCAS (tAC)", 
     992                       tns(ddr2_sdram_atime($bytes->[10]))); 
    993993        } 
    994994 
    995995        if (exists $cas{$highestCAS-1} && spd_written(@$bytes[23..24])) { 
    996                 printl "Minimum Cycle Time at CAS ".($highestCAS-1), 
    997                        tns(ddr2_sdram_ctime($bytes->[23])); 
    998                 printl "Maximum Access Time at CAS ".($highestCAS-1), 
    999                        tns(ddr2_sdram_atime($bytes->[24])); 
     996                printl("Minimum Cycle Time at CAS ".($highestCAS-1), 
     997                       tns(ddr2_sdram_ctime($bytes->[23]))); 
     998                printl("Maximum Access Time at CAS ".($highestCAS-1), 
     999                       tns(ddr2_sdram_atime($bytes->[24]))); 
    10001000        } 
    10011001 
    10021002        if (exists $cas{$highestCAS-2} && spd_written(@$bytes[25..26])) { 
    1003                 printl "Minimum Cycle Time at CAS ".($highestCAS-2), 
    1004                        tns(ddr2_sdram_ctime($bytes->[25])); 
    1005                 printl "Maximum Access Time at CAS ".($highestCAS-2), 
    1006                        tns(ddr2_sdram_atime($bytes->[26])); 
    1007         } 
    1008         printl "Maximum Cycle Time (tCK max)", 
    1009                tns(ddr2_sdram_ctime($bytes->[43])); 
     1003                printl("Minimum Cycle Time at CAS ".($highestCAS-2), 
     1004                       tns(ddr2_sdram_ctime($bytes->[25]))); 
     1005                printl("Maximum Access Time at CAS ".($highestCAS-2), 
     1006                       tns(ddr2_sdram_atime($bytes->[26]))); 
     1007        } 
     1008        printl("Maximum Cycle Time (tCK max)", 
     1009               tns(ddr2_sdram_ctime($bytes->[43]))); 
    10101010 
    10111011# more timing information 
    10121012        prints("Timing Parameters"); 
    1013         printl "Address/Command Setup Time Before Clock (tIS)", 
    1014                tns(ddr2_sdram_atime($bytes->[32])); 
    1015         printl "Address/Command Hold Time After Clock (tIH)", 
    1016                tns(ddr2_sdram_atime($bytes->[33])); 
    1017         printl "Data Input Setup Time Before Strobe (tDS)", 
    1018                tns(ddr2_sdram_atime($bytes->[34])); 
    1019         printl "Data Input Hold Time After Strobe (tDH)", 
    1020                tns(ddr2_sdram_atime($bytes->[35])); 
    1021         printl "Minimum Row Precharge Delay (tRP)", tns($trp); 
    1022         printl "Minimum Row Active to Row Active Delay (tRRD)", 
    1023                tns($bytes->[28]/4); 
    1024         printl "Minimum RAS# to CAS# Delay (tRCD)", tns($trcd); 
    1025         printl "Minimum RAS# Pulse Width (tRAS)", tns($tras); 
    1026         printl "Write Recovery Time (tWR)", tns($bytes->[36]/4); 
    1027         printl "Minimum Write to Read CMD Delay (tWTR)", tns($bytes->[37]/4); 
    1028         printl "Minimum Read to Pre-charge CMD Delay (tRTP)", tns($bytes->[38]/4); 
    1029         printl "Minimum Active to Auto-refresh Delay (tRC)", 
    1030                tns(ddr2_sdram_rtime($bytes->[41], 0, ($bytes->[40] >> 4) & 7)); 
    1031         printl "Minimum Recovery Delay (tRFC)", 
     1013        printl("Address/Command Setup Time Before Clock (tIS)", 
     1014               tns(ddr2_sdram_atime($bytes->[32]))); 
     1015        printl("Address/Command Hold Time After Clock (tIH)", 
     1016               tns(ddr2_sdram_atime($bytes->[33]))); 
     1017        printl("Data Input Setup Time Before Strobe (tDS)", 
     1018               tns(ddr2_sdram_atime($bytes->[34]))); 
     1019        printl("Data Input Hold Time After Strobe (tDH)", 
     1020               tns(ddr2_sdram_atime($bytes->[35]))); 
     1021        printl("Minimum Row Precharge Delay (tRP)", tns($trp)); 
     1022        printl("Minimum Row Active to Row Active Delay (tRRD)", 
     1023               tns($bytes->[28]/4)); 
     1024        printl("Minimum RAS# to CAS# Delay (tRCD)", tns($trcd)); 
     1025        printl("Minimum RAS# Pulse Width (tRAS)", tns($tras)); 
     1026        printl("Write Recovery Time (tWR)", tns($bytes->[36]/4)); 
     1027        printl("Minimum Write to Read CMD Delay (tWTR)", tns($bytes->[37]/4)); 
     1028        printl("Minimum Read to Pre-charge CMD Delay (tRTP)", tns($bytes->[38]/4)); 
     1029        printl("Minimum Active to Auto-refresh Delay (tRC)", 
     1030               tns(ddr2_sdram_rtime($bytes->[41], 0, ($bytes->[40] >> 4) & 7))); 
     1031        printl("Minimum Recovery Delay (tRFC)", 
    10321032               tns(ddr2_sdram_rtime($bytes->[42], $bytes->[40] & 1, 
    1033                                     ($bytes->[40] >> 1) & 7)); 
    1034         printl "Maximum DQS to DQ Skew (tDQSQ)", tns($bytes->[44]/100); 
    1035         printl "Maximum Read Data Hold Skew (tQHS)", tns($bytes->[45]/100); 
    1036         printl "PLL Relock Time", $bytes->[46] . " us" if ($bytes->[46]); 
     1033                                    ($bytes->[40] >> 1) & 7))); 
     1034        printl("Maximum DQS to DQ Skew (tDQSQ)", tns($bytes->[44]/100)); 
     1035        printl("Maximum Read Data Hold Skew (tQHS)", tns($bytes->[45]/100)); 
     1036        printl("PLL Relock Time", $bytes->[46] . " us") if ($bytes->[46]); 
    10371037} 
    10381038 
     
    10481048                            "Micro-DIMM", "Mini-RDIMM", "Mini-UDIMM"); 
    10491049 
    1050         printl "Module Type", ($bytes->[3] <= $#module_types) ? 
     1050        printl("Module Type", ($bytes->[3] <= $#module_types) ? 
    10511051                                        $module_types[$bytes->[3]] : 
    1052                                         sprint("Reserved (0x%.2X)", $bytes->[3]); 
     1052                                        sprint("Reserved (0x%.2X)", $bytes->[3])); 
    10531053 
    10541054# speed 
    1055         prints "Memory Characteristics"; 
     1055        prints("Memory Characteristics"); 
    10561056 
    10571057        $l = "Fine time base"; 
    10581058        my $dividend = ($bytes->[9] >> 4) & 15; 
    10591059        my $divisor  = $bytes->[9] & 15; 
    1060         printl $l, sprintf("%.3f", $dividend / $divisor) . " ps"; 
     1060        printl($l, sprintf("%.3f", $dividend / $divisor) . " ps"); 
    10611061 
    10621062        $l = "Medium time base"; 
     
    10641064        $divisor  = $bytes->[11]; 
    10651065        my $mtb = $dividend / $divisor; 
    1066         printl $l, tns3($mtb); 
     1066        printl($l, tns3($mtb)); 
    10671067 
    10681068        $l = "Maximum module speed"; 
     
    10721072        my $pcclk = int ($ddrclk * $tbits / 8); 
    10731073        $ddrclk = int ($ddrclk); 
    1074         printl $l, "${ddrclk}MHz (PC3-${pcclk})"; 
     1074        printl($l, "${ddrclk}MHz (PC3-${pcclk})"); 
    10751075 
    10761076# Size computation 
     
    10811081        $cap   -= 20 + 3; 
    10821082        my $k   = (($bytes->[7] >> 3) & 31) + 1; 
    1083         printl "Size", ((1 << $cap) * $k) . " MB"; 
    1084  
    1085         printl "Banks x Rows x Columns x Bits", 
     1083        printl("Size", ((1 << $cap) * $k) . " MB"); 
     1084 
     1085        printl("Banks x Rows x Columns x Bits", 
    10861086               join(' x ', 1 << ((($bytes->[4] >> 4) &  7) +  3), 
    10871087                           ((($bytes->[5] >> 3) & 31) + 12), 
    10881088                           ( ($bytes->[5]       &  7) +  9), 
    1089                            ( 1 << (($bytes->[8] &  7) + 3)) ); 
    1090         printl "Ranks", $k; 
    1091  
    1092         printl "SDRAM Device Width", (1 << (($bytes->[7] & 7) + 2))." bits"; 
     1089                           ( 1 << (($bytes->[8] &  7) + 3)) )); 
     1090        printl("Ranks", $k); 
     1091 
     1092        printl("SDRAM Device Width", (1 << (($bytes->[7] & 7) + 2))." bits"); 
    10931093 
    10941094        my $taa; 
     
    11021102        $tras = int((($bytes->[21] >> 4) * 256 + $bytes->[22]) / $bytes->[12]); 
    11031103 
    1104         printl "tCL-tRCD-tRP-tRAS", join("-", $taa, $trcd, $trp, $tras); 
     1104        printl("tCL-tRCD-tRP-tRAS", join("-", $taa, $trcd, $trp, $tras)); 
    11051105 
    11061106# latencies 
     
    11151115                } 
    11161116        } 
    1117         printl "Supported CAS Latencies (tCL)", cas_latencies(keys %cas); 
     1117        printl("Supported CAS Latencies (tCL)", cas_latencies(keys %cas)); 
    11181118 
    11191119# more timing information 
    1120         prints "Timing Parameters" ; 
    1121  
    1122         printl "Minimum Write Recovery time (tWR)", tns3($bytes->[17] * $mtb); 
    1123         printl "Minimum Row Active to Row Active Delay (tRRD)", 
    1124                 tns3($bytes->[19] * $mtb); 
    1125         printl "Minimum Active to Auto-Refresh Delay (tRC)", 
    1126                 tns3((((($bytes->[21] >> 4) & 15) << 8) + $bytes->[23]) * $mtb); 
    1127         printl "Minimum Recovery Delay (tRFC)",  
    1128                 tns3((($bytes->[25] << 8) + $bytes->[24]) * $mtb); 
    1129         printl "Minimum Write to Read CMD Delay (tWTR)", 
    1130                 tns3($bytes->[26] * $mtb); 
    1131         printl "Minimum Read to Pre-charge CMD Delay (tRTP)", 
    1132                 tns3($bytes->[27] * $mtb); 
    1133         printl "Minimum Four Activate Window Delay (tFAW)", 
    1134                 tns3(((($bytes->[28] & 15) << 8) + $bytes->[29]) * $mtb); 
     1120        prints("Timing Parameters"); 
     1121 
     1122        printl("Minimum Write Recovery time (tWR)", tns3($bytes->[17] * $mtb)); 
     1123        printl("Minimum Row Active to Row Active Delay (tRRD)", 
     1124                tns3($bytes->[19] * $mtb)); 
     1125        printl("Minimum Active to Auto-Refresh Delay (tRC)", 
     1126                tns3((((($bytes->[21] >> 4) & 15) << 8) + $bytes->[23]) * $mtb)); 
     1127        printl("Minimum Recovery Delay (tRFC)",  
     1128                tns3((($bytes->[25] << 8) + $bytes->[24]) * $mtb)); 
     1129        printl("Minimum Write to Read CMD Delay (tWTR)", 
     1130                tns3($bytes->[26] * $mtb)); 
     1131        printl("Minimum Read to Pre-charge CMD Delay (tRTP)", 
     1132                tns3($bytes->[27] * $mtb)); 
     1133        printl("Minimum Four Activate Window Delay (tFAW)", 
     1134                tns3(((($bytes->[28] & 15) << 8) + $bytes->[29]) * $mtb)); 
    11351135 
    11361136# miscellaneous stuff 
    1137         prints "Optional Features"; 
     1137        prints("Optional Features"); 
    11381138 
    11391139        my $volts = "1.5V"; 
     
    11471147                $volts .= ", 1.2X V"; 
    11481148        } 
    1149         printl "Operable voltages", $volts; 
    1150         printl "RZQ/6 supported?", ($bytes->[30] & 1) ? "Yes" : "No"; 
    1151         printl "RZQ/7 supported?", ($bytes->[30] & 2) ? "Yes" : "No"; 
    1152         printl "DLL-Off Mode supported?", ($bytes->[30] & 128) ? "Yes" : "No"; 
    1153         printl "Operating temperature range", sprintf "0-%dC", 
    1154                 ($bytes->[31] & 1) ? 95 : 85; 
    1155         printl "Refresh Rate in extended temp range", 
    1156                 ($bytes->[31] & 2) ? "2X" : "1X"; 
    1157         printl "Auto Self-Refresh?", ($bytes->[31] & 4) ? "Yes" : "No"; 
    1158         printl "On-Die Thermal Sensor readout?", 
    1159                 ($bytes->[31] & 8) ? "Yes" : "No"; 
    1160         printl "Partial Array Self-Refresh?", 
    1161                 ($bytes->[31] & 128) ? "Yes" : "No"; 
    1162         printl "Thermal Sensor Accuracy", 
     1149        printl("Operable voltages", $volts); 
     1150        printl("RZQ/6 supported?", ($bytes->[30] & 1) ? "Yes" : "No"); 
     1151        printl("RZQ/7 supported?", ($bytes->[30] & 2) ? "Yes" : "No"); 
     1152        printl("DLL-Off Mode supported?", ($bytes->[30] & 128) ? "Yes" : "No"); 
     1153        printl("Operating temperature range", sprintf "0-%dC", 
     1154                ($bytes->[31] & 1) ? 95 : 85); 
     1155        printl("Refresh Rate in extended temp range", 
     1156                ($bytes->[31] & 2) ? "2X" : "1X"); 
     1157        printl("Auto Self-Refresh?", ($bytes->[31] & 4) ? "Yes" : "No"); 
     1158        printl("On-Die Thermal Sensor readout?", 
     1159                ($bytes->[31] & 8) ? "Yes" : "No"); 
     1160        printl("Partial Array Self-Refresh?", 
     1161                ($bytes->[31] & 128) ? "Yes" : "No"); 
     1162        printl("Thermal Sensor Accuracy", 
    11631163                ($bytes->[32] & 128) ? sprintf($bytes->[32] & 127) : 
    1164                                         "Not implemented"; 
    1165         printl "SDRAM Device Type", 
     1164                                        "Not implemented"); 
     1165        printl("SDRAM Device Type", 
    11661166                ($bytes->[33] & 128) ? sprintf($bytes->[33] & 127) : 
    1167                                         "Standard Monolithic"; 
     1167                                        "Standard Monolithic"); 
    11681168        if ($bytes->[3] >= 1 && $bytes->[3] <= 6) { 
    11691169 
    1170                 prints "Physical Characteristics"; 
    1171                 printl "Module Height (mm)", ($bytes->[60] & 31) + 15; 
    1172                 printl "Module Thickness (mm)", sprintf("%d front, %d back", 
     1170                prints("Physical Characteristics"); 
     1171                printl("Module Height (mm)", ($bytes->[60] & 31) + 15); 
     1172                printl("Module Thickness (mm)", sprintf("%d front, %d back", 
    11731173                                                ($bytes->[61] & 15) + 1,  
    1174                                                 (($bytes->[61] >> 4) & 15) +1); 
    1175                 printl "Module Width (mm)", ($bytes->[3] <= 2) ? 133.5 : 
    1176                                         ($bytes->[3] == 3) ? 67.6 : "TBD"; 
     1174                                                (($bytes->[61] >> 4) & 15) +1)); 
     1175                printl("Module Width (mm)", ($bytes->[3] <= 2) ? 133.5 : 
     1176                                        ($bytes->[3] == 3) ? 67.6 : "TBD"); 
    11771177 
    11781178                my $alphabet = "ABCDEFGHJKLMNPRTUVWY"; 
     
    11941194                        } 
    11951195                } 
    1196                 printl "Module Reference Card", $ref_card; 
     1196                printl("Module Reference Card", $ref_card); 
    11971197        } 
    11981198        if ($bytes->[3] == 1 || $bytes->[3] == 5) { 
    1199                 prints "Registered DIMM"; 
     1199                prints("Registered DIMM"); 
    12001200 
    12011201                my @rows = ("Undefined", 1, 2, 4); 
    1202                 printl "# DRAM Rows", $rows[($bytes->[63] >> 2) & 3]; 
    1203                 printl "# Registers", $rows[$bytes->[63] & 3]; 
    1204                 printl "Register manufacturer", 
    1205                         manufacturer_ddr3($bytes->[65], $bytes->[66]); 
    1206                 printl "Register device type", 
     1202                printl("# DRAM Rows", $rows[($bytes->[63] >> 2) & 3]); 
     1203                printl("# Registers", $rows[$bytes->[63] & 3]); 
     1204                printl("Register manufacturer", 
     1205                        manufacturer_ddr3($bytes->[65], $bytes->[66])); 
     1206                printl("Register device type", 
    12071207                                (($bytes->[68] & 7) == 0) ? "SSTE32882" : 
    1208                                         "Undefined"; 
    1209                 printl "Register revision", sprintf("0x%.2X", $bytes->[67]); 
    1210                 printl "Heat spreader characteristics", 
     1208                                        "Undefined"); 
     1209                printl("Register revision", sprintf("0x%.2X", $bytes->[67])); 
     1210                printl("Heat spreader characteristics", 
    12111211                                ($bytes->[64] < 128) ? "Not incorporated" : 
    1212                                         sprintf("%.2X", ($bytes->[64] & 127)); 
     1212                                        sprintf("%.2X", ($bytes->[64] & 127))); 
    12131213                my $regs; 
    12141214                for (my $i = 0; $i < 8; $i++) { 
    12151215                        $regs = sprintf("SSTE32882 RC%d/RC%d", 
    12161216                                        $i * 2, $i * 2 + 1); 
    1217                         printl $regs, sprintf("%.2X", $bytes->[$i + 69]); 
     1217                        printl($regs, sprintf("%.2X", $bytes->[$i + 69])); 
    12181218                } 
    12191219        } 
     
    12261226 
    12271227#size computation 
    1228         prints "Memory Characteristics"; 
     1228        prints("Memory Characteristics"); 
    12291229 
    12301230        my $ii; 
     
    12331233 
    12341234        if ($ii > 0 && $ii < 16) { 
    1235                 printl "Size", (1 << $ii) . " MB"; 
     1235                printl("Size", (1 << $ii) . " MB"); 
    12361236        } else { 
    1237                 printl "INVALID SIZE", sprintf("0x%02x, 0x%02x", 
    1238                                                $bytes->[4], $bytes->[5]); 
     1237                printl("INVALID SIZE", sprintf("0x%02x, 0x%02x", 
     1238                                               $bytes->[4], $bytes->[5])); 
    12391239        } 
    12401240} 
     
    12461246 
    12471247#size computation 
    1248         prints "Memory Characteristics"; 
     1248        prints("Memory Characteristics"); 
    12491249 
    12501250        my $ii; 
     
    12531253 
    12541254        if ($ii > 0 && $ii < 16) { 
    1255                 printl "Size", (1 << $ii) . " MB"; 
     1255                printl("Size", (1 << $ii) . " MB"); 
    12561256        } else { 
    1257                 printl "INVALID SIZE", sprintf("0x%02x, 0x%02x", 
    1258                                                $bytes->[3], $bytes->[5]); 
     1257                printl("INVALID SIZE", sprintf("0x%02x, 0x%02x", 
     1258                                               $bytes->[3], $bytes->[5])); 
    12591259        } 
    12601260} 
     
    13761376        my ($l, $temp); 
    13771377 
    1378         prints "Intel Specification"; 
     1378        prints("Intel Specification"); 
    13791379 
    13801380        $l = "Frequency"; 
     
    13831383        elsif ($bytes->[126] == 133) { $temp = "133MHz"; } 
    13841384        else { $temp = "Undefined!"; } 
    1385         printl $l, $temp; 
     1385        printl($l, $temp); 
    13861386 
    13871387        $l = "Details for 100MHz Support"; 
     
    13981398        if (($bytes->[127] & 192) == 192) { $temp .= "Double-sided DIMM\n"; } 
    13991399        elsif (($bytes->[127] & 192) != 0) { $temp .= "Single-sided DIMM\n"; } 
    1400         printl $l, $temp; 
     1400        printl($l, $temp); 
    14011401} 
    14021402 
     
    14531453        close F; 
    14541454        $header and die "Unable to parse any data from hexdump '$_[0]'"; 
    1455         $word and printc "Using $use_hexdump 16-bit hex dump"; 
     1455        $word and printc("Using $use_hexdump 16-bit hex dump"); 
    14561456 
    14571457        # Cache the data for later use 
     
    16251625} 
    16261626 
    1627 printc "decode-dimms version $revision"; 
    1628 printh 'Memory Serial Presence Detect Decoder', 
     1627printc("decode-dimms version $revision"); 
     1628printh('Memory Serial Presence Detect Decoder', 
    16291629'By Philip Edelbrock, Christian Zuckschwerdt, Burkart Lingner, 
    1630 Jean Delvare, Trent Piepho and others'; 
     1630Jean Delvare, Trent Piepho and others'); 
    16311631 
    16321632 
     
    16641664 
    16651665                print "<b><u>" if $opt_html; 
    1666                 printl2 "\n\nDecoding EEPROM", 
     1666                printl2("\n\nDecoding EEPROM", 
    16671667                        $use_hexdump ? $dimm_list[$i] : ($use_sysfs ? 
    16681668                        "/sys/bus/i2c/drivers/eeprom/$dimm_list[$i]" : 
    1669                         "/proc/sys/dev/sensors/$dimm_list[$i]"); 
     1669                        "/proc/sys/dev/sensors/$dimm_list[$i]")); 
    16701670                print "</u></b>" if $opt_html; 
    16711671                print "<table border=1>\n" if $opt_html; 
     
    16741674                         || (!$use_sysfs && /^[^-]+-[^-]+-[^-]+-([^-]+)$/)) { 
    16751675                                my $dimm_num = $1 - 49; 
    1676                                 printl "Guessing DIMM is in", "bank $dimm_num"; 
     1676                                printl("Guessing DIMM is in", "bank $dimm_num"); 
    16771677                        } 
    16781678                } 
    16791679 
    16801680# Decode first 3 bytes (0-2) 
    1681                 prints "SPD EEPROM Information"; 
    1682  
    1683                 printl $l, ($chk_valid ? 
     1681                prints("SPD EEPROM Information"); 
     1682 
     1683                printl($l, ($chk_valid ? 
    16841684                        sprintf("OK (%s)", $chk_calc) : 
    16851685                        sprintf("Bad\n(found %s, calculated %s)", 
    1686                                 $chk_spd, $chk_calc)); 
     1686                                $chk_spd, $chk_calc))); 
    16871687 
    16881688                my $temp; 
     
    16921692                        elsif ($bytes[0] == 0) { $temp = "Invalid"; } 
    16931693                        else { $temp = "Reserved"; } 
    1694                         printl "SPD Revision", $temp; 
     1694                        printl("SPD Revision", $temp); 
    16951695                } else { 
    16961696                        my ($spd_size, $spd_used) = spd_sizes(\@bytes); 
    1697                         printl "# of bytes written to SDRAM EEPROM", $spd_used; 
    1698                         printl "Total number of bytes in EEPROM", $spd_size; 
     1697                        printl("# of bytes written to SDRAM EEPROM", $spd_used); 
     1698                        printl("Total number of bytes in EEPROM", $spd_size); 
    16991699 
    17001700                        # If there's more data than what we've read, let's 
     
    17251725                        } 
    17261726                } 
    1727                 printl $l, $type; 
     1727                printl($l, $type); 
    17281728 
    17291729# Decode next 61 bytes (3-63, depend on memory type) 
     
    17511751        } 
    17521752} 
    1753 printl2 "\n\nNumber of SDRAM DIMMs detected and decoded", $dimm_count; 
     1753printl2("\n\nNumber of SDRAM DIMMs detected and decoded", $dimm_count); 
    17541754 
    17551755print "</body></html>\n" if ($opt_html && !$opt_bodyonly);