Suporte a hardware no Linux

A principal diferença entre Windows e Linux com relação a drivers e suporte a dispositivos é que no Windows os drivers são desenvolvidos pelos fabricantes e precisam ser instalados manualmente, após a instalação do sistema, enquanto no Linux os drivers são incorporados diretamente ao Kernel e por isso vêm pré-instalados no sistema.

Naturalmente, o Windows também inclui uma biblioteca de drivers, com suporte a um grande número de dispositivos, mas a biblioteca fica rapidamente desatualizada, já que a vida útil do sistema é muito grande. Ao instalar o Vista em um PC montado com componentes disponíveis na mesma época do lançamento, praticamente todo o hardware será ativado durante a instalação, mas ao fazer o mesmo com o XP, que foi lançado em 2001, você precisará instalar praticamente tudo posteriormente.

Podemos dividir os drivers de dispositivo para o Linux em dois grupos. O primeiro é o dos drivers de código aberto, que podem tanto ser desenvolvidos pelos próprios fabricantes quanto por voluntários em cantos remotos do mundo. Estes drivers open-source são incluídos diretamente no Kernel, o que faz com que sejam incluídos diretamente nas distribuições e você não precise se preocupar muito com eles. Os componentes suportados são detectados durante a instalação do sistema e todo mundo fica feliz.

O maior problema é justamente quando o sistema de detecção não funciona tão bem quanto deveria, ou o sistema não possui os drivers para o dispositivo em questão. Neste ponto, a maioria das pessoas simplesmente desiste ou passa a testar outras distribuições até encontrar alguma que consiga detectar os componentes que precisa, ao invés de tentar resolver o problema inicial. Embora solucionar problemas no Linux possa ser um processo complexo, neste artigo vou tentar dar algumas dicas gerais de por onde começar.

Em primeiro lugar, o suporte a dispositivos no Linux é feito através de “módulos” incluídos no Kernel, arquivos que ficam dentro da pasta “/lib/modules/versão_do_kernel_usada/”. Estes módulos são a coisa mais parecida com um “driver” dentro da concepção que temos no Windows. Para ativar suporte a um certo dispositivo, você precisa apenas carregar o módulo referente a ele.

Veja que os módulos ficam organizados em pastas: a pasta “kernel/drivers/net/” contém drivers para placas de rede, a pasta “kernel/drivers/usb/” agrupa os que dão suporte dispositivos USB e assim por diante.

Até o Kernel 2.4, os módulos de Kernel utilizavam a extensão “.o”, que é uma extensão genérica para objetos em C. A partir do Kernel 2.6, passou a ser usada a extensão “.ko” (kernel object), que é mais específica.

Quase sempre, os módulos possuem nomes que dão uma idéia do dispositivo a que oferecem suporte. O “8139too.ko” dá suporte às placas de rede com o chipset Realtek 8139, o “sis900.ko” dá suporte às placas SiS 900, enquanto o “e100.ko” ativa as placas Intel E100.

Os módulos podem ser carregados e descarregados a qualquer momento usando os comandos “modprobe” e “modprobe -r“; não apenas na inicialização do sistema.

Algumas distribuições oferecem uma opção de carregar módulos adicionais durante a instalação, justamente pensando nos raros casos onde você precisa de um determinado módulo para ativar a placa SCSI onde está instalado o HD para poder prosseguir com a instalação, por exemplo.

Os módulos são gerados durante a compilação do Kernel. Você não precisa se preocupar com isso se não quiser, pois as distribuições quase sempre incluem versões bem completas do Kernel por padrão. Mas, de qualquer forma, existe sempre a possibilidade de recompilar o Kernel, mexendo nas opções e ativando ou desativando os módulos que quiser.

As distribuições atuais são bem competentes com relação à detecção do hardware da máquina, mas sempre existem casos onde a detecção de hardware falha. Se existe um driver disponível e o problema foi apenas na detecção do dispositivo, o suporte a ele pode ser ativado carregando o módulo referente a ele, como em:

(como root)

Aqui carregamos o módulo que dá suporte a placa IPW2200, usadas em notebooks Intel Centrino. Os módulos são inteligentes, eles detectam se o dispositivo a que dão suporte está realmente presente, caso contrário incluem uma mensagem de erro no log do sistema e não fazem nada. com poucas excessões, você pode testar o carregamento de quantos módulos quiser, sem causar problemas ao funcionamento do sistema.

Em alguns casos, pode ser necessário especificar opções diversas ao carregar o módulo, como no caso das placas de captura de vídeo, que são ativadas através do módulo “bttv”. Se você tem uma PixelView PlayTV Pro, por exemplo, precisa carregar o módulo incluindo os parâmetros “card=37 tuner=2”. Na maioria dos casos, o módulo já vai estar carregado (devido ao sistema de detecção de hardware da distribuição) mas com os parâmetros incorretos. Neste caso, você precisaria primeiro descarregar o módulo (usando o comando “modprobe -r”), para depois carregá-lo novamente usando o modprobe, como em:

Originalmente, a modificação seria perdida ao reiniciar a máquina. Para não precisar ficar executando os comandos novamente a cada boot, você adicionaria os comandos (apenas os comandos, sem o “#”, que indica que eles devem ser executados como root) em um dos arquivos de inicialização do sistema.

Os mais próprios para isso são os arquivos “/etc/rc.local” ou “/etc/rc.d/rc.local“. Verifique qual dos dois está disponível, abra-o em um editor de texto puro, como o kedit, kwrite, gedit ou mcedit e adicione os comandos no final do arquivo, antes da linha “exit 0” (caso presente).

Naturalmente, pouca gente sabe os nomes e parâmetros dos módulos de cor. Ao se deparar com problemas de detecção, o caminho é sempre pesquisar pelo modelo da placa ou pelo chipset usado. Quase sempre você vai encontrar dicas de como ativá-la em algum wiki ou fórum. Em muitos casos é só questão de ativar o módulo apropriado, mas em outros você precisa instalar algum driver proprietário ou experimental manualmente.

Os drivers proprietários são uma categoria à parte. Eles não são incluídos diretamente na maior parte das distribuições, seja por restrições na distribuição (em muitos casos a EULA não permite a redistribuição do driver, de forma que ele precisa ser baixado manualmente no site do fabricante) ou seja dúvidas com relação à estabilidade e segurança, já que o código não está disponível e por isso não pode ser auditado em busca de erros.

É aqui que entram os drivers para softmodems, algumas placas wireless e também os drivers para placas 3D da nVidia e da ATI.

A psicologia para lidar com eles é a seguinte: instalar um destes drivers envolve duas tarefas: baixar o pacote com o código fonte, ou um instalador e em seguida instalá-lo, carregando o módulo criado e fazendo outras configurações necessárias.

Ao instalar um modem Lucent, por exemplo, é criado um dispositivo “/dev/ttyLT0” por onde o modem é acessado. Para facilitar esta tarefa, geralmente os drivers vêm com algum tipo de instalador, geralmente um script simples de modo texto que cuida disso para você.

Os módulos são parte integrante do Kernel, por isso os módulos para uma determinada distribuição não funcionam em outra, a menos que por uma grande coincidência as duas utilizem exatamente a mesma versão do Kernel. Isso é bastante improvável já que o Kernel do Linux é atualizado quase que diariamente.

Se você usar uma distribuição popular, Mandriva, Fedora, SuSE, etc., é possível que você encontre um driver pré-compilado para download (que pode ser encontrado com a ajuda do Google ;). Neste caso, você só vai precisar instalar um pacote RPM ou executar um arquivo de instalação. Em outras situações, você encontrará apenas um arquivo genérico ainda não compilado, contendo um instalador que se encarrega de compilar um módulo sob medida para o Kernel em uso.

Como ele não tem como adivinhar qual distribuição ou Kernel você está utilizando, é necessário ter instalados dois pacotes que acompanham qualquer distribuição: kernel-source e kernel-headers. No Mandriva, por exemplo, você pode instalá-los usando os comandos:

Naturalmente, para que ele possa compilar qualquer coisa, você precisará também de um compilador, o gcc, que também acompanha as distribuições. Você pode instalá-lo marcando a categoria de pacotes de desenvolvimento (development) durante a instalação do sistema.

No caso do Ubuntu e outras distribuições da família do Debian, instale o pacote “build-essential” (que contém os compiladores básicos) e o pacote “linux-headers-2.6.x-x” (onde o 2.6.x-x é a versão do Kernel em uso), que contém os headers, ou seja, as partes do código fonte necessárias para compilar módulos.

Você pode usar o comando “uname -a” para descobrir qual versão do Kernel está instalada, como em:

Em seguida, instale os pacotes usando o apt-get, como em:

No caso do Ubuntu, você pode precisar criar manualmente o link “/usr/src/linux”, apontando para a pasta referente à versão instalada. Para isso, acesse a pasta “/usr/src” e rode o comando “sudo ln -sf linux-headers-2.6.*-* linux”, como em:

Com os compiladores e os headers do Kernel instalados, você vai conseguir instalar qualquer driver sem maiores problemas, basta seguir as instruções na página de download ou no arquivo INSTALL ou README dentro do pacote. Ao baixar, procure por uma versão atualizada, que seja compatível com a versão do Kernel em uso. É muito comum que drivers pouco usados sejam atualizados esporadicamente e não funcionem em versões recentes do Kernel. Neste caso existe pouco a fazer senão esperar o lançamento de uma versão atualizada.

Vamos a um exemplo de instalação com o driver “gspca”, que adiciona suporte a um grande número de webcams, incluindo muitos dos modelos incorporados à tela dos notebooks. Ele pode ser baixado no: http://mxhaard.free.fr/download.html.

Na página de download, você encontra um aviso:

Como no exemplo estamos usando o Kernel versão 2.6.18-4, baixaríamos o primeiro arquivo.

Para instalá-lo, você descompacta o arquivo e, dentro da pasta criada (como root) executa os comandos:

Na maioria dos pacotes, você precisaria usar primeiro o comando “./configure”, mas no caso do gspca ele não é necessário. Como os comandos de instalação podem sofrer pequenas variações de um pacote para o outro, é sempre importante dar uma olhada rápida nas instruções de instalação.

Com o módulo instalado o próximo passo é carregá-lo. Se a webcam estiver entre os modelos suportados, ela passará a ser vista pelos programas de mensagem (como o kopete) e visualização de imagem que oferecem suporte a câmera.

Para que ele seja carregado automaticamente durante o boot, adicione o comando no final do arquivo “/etc/rc.local” ou “/etc/rc.d/rc.local”. Existe também um arquivo específico para incluir módulos que devem ser carregados durante o boot, que é o “/etc/modules“. Ao usá-lo, você deve incluir apenas o nome do módulo (sem o “modprobe”) no final do arquivo.

Outro exemplo de driver muito comum é o driver 3D para placas nVidia, disponível no: http://www.nvidia.com/object/unix.html.

O pacote disponível para download contém um instalador, que automatiza o processo de instalação e permite que o mesmo pacote possa ser instalado em qualquer distribuição.

Existem três versões do driver. A mais recente oferece suporte às GeForce 6100 em diante, excluindo o suporte às placas antigas.

Existem ainda duas versões “legacy”, destinadas às placas anteriores. A versão 96xx oferece suporte às GeForce 2, GeForce 3 e GeForce 4, incluindo as GeForce 2 MX e GeForce 4 MX e as GeForce 2 onboard, enquanto a versão 71xx oferece suporte às placas realmente antigas, a partir das TnT.

Em qualquer um dos três casos, o processo de instalação é o mesmo. Comece marcando a permissão de execução para o arquivo, o que pode ser feito através das propriedades do arquivo, ou via terminal, usando o comando “chmod +x”, como em:

Por precaução, o instalador exige que você o execute em modo texto puro, já que o instalador não tem como substituir os módulos antigos caso eles estejam em uso. Dependendo da distribuição usada, o comando para fechar o ambiente gráfico pode ser “/etc/init.d/kdm stop”, “/etc/init.d/gdm stop”, “service dm stop”, “telinit 3” ou “init 3”.

Depois de executar o comando apropriado (sempre como root) você cai em um terminal de texto puro. Logue-se como root (no Ubuntu você pode se logar com o seu login de usuário e usar o comando “sudo su” para virar root), acesse a pasta onde foi baixado o arquivo, usando o comando “cd” e execute-o, usando o comando “./” seguido do nome do arquivo, como em:

A maior parte da instalação consiste em simplesmente copiar alguns arquivos e bibliotecas. Mas, existe um componente que precisa ser gerado sob medida para o seu sistema, que é o módulo de Kernel, que permite que o driver tenha acesso de baixo nível ao hardware.

O instalador já traz vários módulos pré-compilados para várias distribuições, incluindo Mandriva, SuSe, Fedora e outras. Ao usar uma delas, ele simplesmente vai instalar o que já tem sem fazer mais perguntas. Caso contrário, ele verificará se existe algum módulo disponível no FTP da nVidia e em seguida tentará compilar um módulo sob medida, o que é feito automaticamente depois de uma tela de confirmação:

No final ele pergunta se deve editar o arquivo de configuração do X automaticamente. Responda “yes” para que ele faça as alterações automaticamente e reinicie o modo gráfico. Este era um passo que precisava ser feito manualmente em versões antigas do driver.

Para as placas wireless que não possuem drivers nativos, existe a opção de carregar o driver do Windows XP através do Ndiswrapper. Infelizmente ele funciona apenas com drivers de rede, por isso não é uma solução para quem precisa de drivers para um softmodem ou outro dispositivo.

Ele já vem pré-instalado na maioria das distribuições atuais. Caso não esteja, procure pelos pacotes “ndiswrapper-utils” e “ndiswrapper-modules” no gerenciador de pacotes.

Para usar o Ndiswrapper, você precisa ter em mãos o driver da placa para Windows XP, que pode ser encontrado no CD de instalação ou no site do fabricante. Comece descompactando o arquivo do driver, caso necessário. Os drivers distribuídos na forma de arquivos .exe são na verdade arquivos compactados no formato cab que contém um instalador. Eles podem ser descompactados no Linux usando o comando “cabextract” (que faz parte do pacote do mesmo nome), como em:

Para carregar o driver, use o comando “ndiswrapper -i” (como root), seguido do caminho completo para o arquivo “.inf”, como em:

Com o driver carregado, ative o módulo com o comando:

Se tudo estiver ok, o led da placa acenderá, indicando que ela está ativa. A partir daí, falta apenas configurar a rede da forma normal. Caso você esteja tendo problemas para se conectar em redes com encriptação WPA, verifique se o pacote “wpa_supplicant” está instalado.

Muitas distribuições incluem wizards ou utilitários gráficos para facilitar a configuração do Ndiswrapper, como no ndisgtk, mas estes passos manuais podem ser usados quando tudo mais falhar.

Aqui está uma lista de outros drivers de que você pode precisar. Eles vem pré-instalados em muitas distribuições, mas sempre existem casos em que você precisa instalar manualmente:

Placas 3D com chipset ATI: http://www.ati.com (na seção “Drivers & Software > Linux Display Drivers”).

Placas wireless com chipsets ACX100 e ACX111: http://rhlx01.fht-esslingen.de/~andi/acx100/

Placas wireless com chipset Atheros: http://madwifi.sourceforge.net/

Placas wireless com chipset ADM8122 (ADMteck): http://aluminum.sourmilk.net/adm8211/

Notebooks com placas wireless Intel IPW2100 ou IPW2200: http://ipw2200.sourceforge.net/ ou http://ipw2100.sourceforge.net/. Além do driver, é necessário baixar e o arquivo compactado na seção “firmware”, que deve ser descompactado dentro da pasta “/lib/firmware”. Muitas distribuições incluem o driver, mas não o firmware, que também é necessário para a placa funcionar.

Placas wireless com chipset Ralink rt2400, rt2500 ou rt61: http://prdownloads.sourceforge.net/rt2400/

Placas wireless com chipset Realtek rtl8180: http://rtl8180-sa2400.sourceforge.net/

Modems PC-Tel onboard e AMR (incluindo os das placas M810, M812, e outros modelos da PC-Chips/ECS, além de vários notebooks) e modems PCI com chipset PC-Tel recentes, como os LG-Netodragon: http://www.smlink.com/ (Support > Drivers Download > Linux Drivers) ou http://linmodems.technion.ac.il/packages/smartlink/

Modems com chipset PC-Tel em versão PCI, que não são atendidos pelo driver da Smartlink: http://linmodems.technion.ac.il/pctel-linux/welcome.html

Modems com chipset Intel 537 (Tigerjet) e Intel 537ep (Ambient): http://linmodems.technion.ac.il/packages/Intel/537/

Modems Lucent e Agere (este driver funciona apenas com os modelos antigos): http://linmodems.technion.ac.il/packages/ltmodem/kernel-2.6/

Modem ADSL Speedtouch USB (incluindo o Speedtouch 330): http://sourceforge.net/projects/speedtouch/

Diversas placas de TV só funcionam caso o módulo seja carregado usando as opções adequadas, como no exemplo da PlayTV Pro que usei a pouco. Você pode ver um resumo dos chipsets suportados no Linux e os parâmetros utilizados pelos diferentes modelos de placas no: http://tvtime.sourceforge.net/cards.html