A aventura da BIOS copiada

Não dava para esquecer. Ao ler a deliciosa coluna do mestre Piropo O sistema de arquivos de Windows esta semana, quando me deparei com aquela foto do gravador cassete tudo voltou na minha memória. Quem gosta de história dos primórdios da informática acho que vai se deliciar com esta. Quem não gosta, paciência, espere uma próxima coluna.

Já toquei de leve neste assunto por aqui. No começo dos anos 80 eu tive o meu primeiro “computador pessoal”. Era um TK82C, uma versão brasileira do brilhante equipamento SINCLAIR ZX81 feito nas Inglaterra. Seu criador (Clive Sinclair) foi agraciado com o título de “Sir”, um nobre cavalheiro inglês, por sua ótima criação. O computador era bem simples, ainda mais se comparado com os que temos hoje. Seu grande mérito foi criar uma máquina MUITO BARATA e que permitiu acesso a muitas pessoas. Apple II e TRS-80 já existiam, mas era muito mais caros.

[singlepic id=7852 w=320 h=240 float=]

Este TK82C vinha com 2 KB (isso mesmo QUILOBYTES e não MEGAS ou GIGAS). Era possível expandi-lo para 16 KB ou 48 KB. Trazia ROM de 8 KB que incluía o “sistema operacional”, interpretador BASIC e rotinas de I/O. Eu com meus parcos vencimentos de estudante e estagiário de engenharia comprei um com 16 KB. Era baseado no processador ZILOG Z80 , que até recentemente ainda era bastante usado (será que ainda é usado?) em dispositivos embarcados. Tinha freqüência de 2.0 Mhz (cerca de 2000 vezes mais lento que um PC atual). O monitor era uma TV, do próprio dono. Sua unidade de armazenamento de programas era o famigerado gravador cassete mostrado no começo do texto do mestre Piropo. A linguagem de programação era o BASIC. Todo programa para ser usado tinha que ser carregado da fita cassete. Ao ser desligado tudo se perdia, a menos que tivesse sido gravado de volta na fita.

[singlepic id=7851 w=320 h=240 float=]

Acreditem, eu virei este PC “de ponta cabeça”. Aprendi a programar em BASIC. Criei alguns jogos (como uma versão simples do STAR TREK-conversacional) e até um complexo programa para dimensionamento de diâmetro de eixos para a faculdade de engenharia. Eu entrava a intensidade das forças e as coordenadas dos pontos de aplicação, características do aço escolhido e após TRÊS MINUTOS de processamento o programa no TK82 mostrava os pontos mais solicitados do eixo e o diâmetro mínimo que este deveria ter para resistir aos esforços. Feito na mão estes cálculos demoravam de 60 a 90 minutos (dependia da crueldade do professor ao escolher os dados). Era ótimo! Depois dessa fase eu aprendi a linguagem assembler do Z80 e comecei a fazer minhas incursões nesta área.

Eu tenho certeza ABSOLUTA de que eu usei este computador em sua TOTALIDADE. Jamais irei utilizar outro computador de forma tão completa e intensa como o velho TK82C. Algum tempo depois foi lançado seu sucessor, o TK85 . Este tinha um teclado de verdade. As “teclas” do TK82 eram de membrana – uma superfície lisa de plástico-chato de usar. Tinha uma aparência mais moderna e principalmente o recurso HIGH SPEED – opcional-nem todos sabiam de sua existência! Não estou falando do fato do TK85 ser mais rápido (ele tinha uma freqüência mais alta do processador-3.25 Mhz-50% mais veloz) e sim da velocidade de leitura de gravação nas fitas cassete. O TK82 trabalhava a 300 bps enquanto o TK85 trabalhava a 9600 bps, ou seja, 32 vezes mais rápido. Eu tinha comprado um software de xadrez que demorava mais de 12 minutos para ser carregado. No TK85 o mesmo software era carregado em 30 segundo aproximadamente. Uma diferença GIGANTE!! E pensar que era um software de apenas 10 KB!!

[singlepic id=7855 w=320 h=240 float=]

[singlepic id=7854 w=320 h=240 float=]

Eu morria de raiva pelo fato de meu TK82 ser uma LESMA para carregar e gravar programas. Tinha uma loja perto de minha casa que vendia o TK85. Eu fiquei amigo do vendedor e volta e meia ia lá para xeretar. Ele me deixava ficar usando. Um belo dia eu tive uma idéia “diabólica”. O TK82 tinha 8 KB de memória ROM enquanto o TK85 tinha 10 KB. Será que este 2 KB eram responsáveis pelo HIGH SPEED?? Um belo dia fiz um programa em BASIC que gravou em uma matriz na memória os 10 KB da ROM. Em seguida eu gravei em uma fita cassete esta matriz (em velocidade baixa para poder ler no meu TK). Saí de lá me sentido o verdadeiro “pirata” que acabara de saquear um navio cheio de tesouros. Agora chego em casa, gravo os 2K bytes adicionais da ROM no meu TK82 e estou feito!!! LEDO ENGANO!! Não foi nada disso!!

Não quero entrar em detalhes de programação assembler, não é o objetivo deste texto. Mas alguns conceitos precisam ser entendidos. O TK82 e TK85 reservavam os primeiros 16 KB do endereçamento da memória para ROM. Dados e programas só podiam ser gravados na RAM cujo endereço começava a partir de 16 KB. Fiz a carga da ROM completa que fora gravada no cassete na memória e comparei os primeiros 8 KB com a do meu TK82. Era igualzinha!! UFA!! Realmente a diferença eram os 2 KB adicionais.

Assim eu me preocupei em carregar somente os 2 KB finais no topo da minha memória, que no caso era no endereço 32 KB para baixo (eu tinha 16 KB de RAM). Dos endereços 30K a 32K estava a rotina copiada do TK85. Eu já tinha descoberto o “ponto de chamada” das rotinas de HIGH SPEED. A titulo de exemplo imagine que no TK85 a leitura em HIGH SPEED fosse no endereço 8500 e a rotina de gravação fosse no 9500. Pensei que bastaria mudar a chamada para os novos endereços (que eram 30500 e 31500 no meu exemplo). Qual não foi o meu terror misturado com surpresa ao ver que toda vez que chamava estas rotinas o computador travava de forma definitiva. Não funcionava!! Que decepção!!

Comecei a “dissassemblar” a rotina, convertendo código binário em instruções inteligíveis e transformá-la em código mnemônico do Z80. Algo parecido com isso:

LD H, L-move o conteúdo do registrador L para o registrador H

PUSH BC-coloca na pilha 16 bits de uma vez os registradores B e C

POP HL-retira da pilha 16 bits e armazena nos registradores H e L

JP 8700

-pula (jump) a execução do programa para o endereço 8700

JR 200

-pula (jump) a execução do programa 200 bytes para frente.

Este código é apenas uma amostra. Como já faz mais de 20 anos que fiz isso, algumas instruções podem não estar exatas, mas o que vale é o exemplo. Se olharem com bastante atenção o motivo de não ter funcionado está presente neste singelo exemplo de código assembler. Qualquer programa, em qualquer linguagem tem instruções que realizam desvios ou “pulos” no fluxo de execução. Um bloco de IF ou mesmo de WHILE em um programa tem PULOS implícitos. Em assembler é a mesma coisa. Ou melhor, depois que qualquer programa em VB, Delphi, C#, C++, etc. é compilado, tudo no final vira assembler.

Analisando aqueles 2 KB copiados do TK85 percebi que havia várias instruções de desvio (JUMP). Algumas eram “do bem”, ou seja, era pulos RELATIVOS. Avançar o programa 200 bytes para frente vai funcionar independentemente de ONDE na memória o código está carregado. Agora um pulo ABSOLUTO do tipo JP 8700 , que desvia a execução do programa para o endereço 8700 jamais iria funcionar em meu TK82. NÃO HAVIA este endereço na ROM de meu computador!! Por isso que TRAVAVA SEMPRE que eu executava!!

Qual o remédio para isso??? Acreditem, virou uma questão de HONRA para mim. Eu tive que analisar os 2048 bytes de instruções assembler adicionais e transformar todos os desvios absolutos em desvios relativos. As vezes não dava porque os desvios relativos só podiam ser 256 bytes para trás ou para frente (ou seriam 128? não importa). Nestes casos eu tinha que descobrir o NOVO endereço para o qual o pulo seria realizado e modificar a minha matriz na memória com a instrução nova que realizava este alterado desvio e gravá-la de volta para o cassete.

[singlepic id=7853 w=320 h=240 float=]

Foram quase TRÊS MESES fazendo isso. Toda vez que sobrava um tempo no final da noite, após voltar da faculdade, eu mergulhava nas instruções. Eu cheguei a SONHAR com códigos mnemônicos do assembler do Z80!! Sério!! Eu os via flutuando na minha frente e de repente todos se embaralhavam!! Eram pesadelos em linguagem assembler!

Após três meses gramando… SUCESSO!! Consegui usar as rotinas de HIGH SPEED do TK85 no meu TK82!! Toda vez que ligava o TK eu tinha que primeiro carregar em velocidade lenta aqueles 2 KB adicionais. Isso demorava cerca de 80 segundos. Depois disso os programas que eu já convertera para a nova velocidade podiam ser carregados de forma 32 vezes mais rápida!! VITÓRIA, VITÓRIA, VITÓRIA!!!

Usei assim por mais um tempo e foi muito útil!! Apesar do teclado melhor o TK85 não me seduzia mais. Em julho de 1984 (há exatos 24 anos) comecei o meu primeiro estágio (ainda estudante) na área de informática. Fui apresentado ao IBM PC baseado no processador Intel 8088 de 4.77 Mhz, dois disquetes de 5 ¼ e 256 KBytes de memória. Era difícil voltar a usar o meu TK82. Tudo que precisava, mesmo que para uso pessoal fazia no PC, também em BASIC, após o expediente no trabalho. Mas agradeço MUITO ao TK82 pela minha iniciação. Como disse sei que JAMAIS irei usar um computador tão plenamente como eu o utilizei. E na entrevista de estágio quando mencionei que conhecia BASIC e ASSEMBLER de Z80 vi que isso causou certa reação em meu entrevistador. Pode ser que sim, pode ser que não, mas isso pode ter influído na sua escolha por mim como o primeiro estagiário de TI daquela empresa. E talvez se o TK82 não tivesse me dado este empurrão eu nem estaria aqui escrevendo hoje!! Coisas do destino?? Jamais saberei!!!