Periféricos e Interfaces had

Transcrição

1 9 Subsistema de video 9.1 Introdução O subsistema vídeo é responsável por produzir a imagem que aparece no écran. Parte deste consiste na geração de sinais que controlam a imagem que aparece no monitor. Em termos gerais o monitor consiste numa matriz de pixels, o menor elemento de composição de uma imagem, que podem ser iluminados ou não, ou ter uma dada cor. Deve ser referido que os subsistemas de vídeo actuais requerem bastante processamento, por isso devem ser o mais independente possível do CPU, de modo que este não tenha a seu cargo a criação das imagens, deixando-o livre para outro processamento e acelerando assim o desempenho global do sistema computacional CRT (Tubo de raios catódicos) O CRT é uma válvula onde é produzido um feixe de electrões numa extremidade, que é deflectido e atinge a superfície na outra extremidade. No caso de um monitor monocromático a superfície consiste num material fosforescente que ao ser bombardeado pelo feixe de electrões ilumina-se. Fig. 9-1: Estrutura de um tubo de raios catódicos O adaptador deve emitir sinais para o monitor que permitam deflectir o feixe de electrões de modo que varra todo o ecrã. O varrimento normalmente é efectuado da direita para a esquerda, linha a linha. No caso de um monitor monocromático, em cada linha existe um conjunto de pixels que se iluminam se atingidos pelo feixe. Ao terminar uma linha o feixe é posicionado no inicio da linha seguinte e o processo repete-se até se chegar à ultima linha do quadro (ou frame) onde o feixe é posicionado no inicio da primeira linha para apresentar a próxima imagem. Fig. 9-2: Estrutura de um tubo de raios catódicos PIN T09-1/7

2 O número de quadros, isto é imagens completas criadas por segundo, depende da frequência vertical. Quanto maior for esta frequência mais quadros são formados na unidade de tempo, reduzindo a cintilação. O número de pixels numa linha indica a resolução horizontal e o número de linhas a resolução vertical. No caso de se ter um monitor que suporte escala de cinzentos (gray scale) a iluminação do pixel depende da intensidade do feixe de electrões. No caso de um monitor a cores RGB, cada pixel é composto por três células de material fosforescente, ou tríade, que quando bombardeadas pelo feixe de electrões emitem luz vermelha, verde e azul. A iluminação de cada uma destas células depende da intensidade do feixe de electrões. A cor é assim composta, em cada pixel, pela combinação dos tons destas três células LCD (Display de cristal liquido) No caso de monitores de cristal líquido, cada pixel também é composto por uma tríade RGB onde cada célula tem uma intensidade variável, dependendo da polarização. Esta polarização é obtida através da aplicação de uma voltagem a dois ecrans de polarização por cada célula Assim se bem que neste caso não exista um feixe de electrões que bombardeia cada célula, o sistema de composição de cor é idêntico. 9.2 Memória de video ou framebuffer Modos de vídeo padrão De acordo com a aula teórica 20 de (Costa e Bastos, 2004, 2005) Estrutura da memória de vídeo em modos de texto e gráficos De acordo com as aulas teóricas 20 e 21 de (Costa e Bastos, 2004, 2005), excepto MSDOS e BIOS Acesso à memória de video no espaço de utilizador Para se aceder à memória de video, primeiro tem de se obter o endereço virtual correspondente ao endereço físico. Em espaço de utilizador pode-se usar a função mmap ( ) definida em <sys/mman.h>. Para isso é necessário primeiro abrir o ficheiro correspondente ao dispositivo de memória: /dev/mem e a partir deste indicar qual o endereço físico addr que se pretende: unsigned char *virt_addr, *p; unsigned int addr=0xb8000; unsigned int len=0x10; f=open ("/dev/mem", O_RDWR); if (f<0) { printf("file not found\n"); exit(1); virt_addr = (unsigned char*) mmap(0, len, PROT_READ PROT_WRITE, MAP_SHARED, f, addr); printf("\nendereço virtual %p, correspondente ao físico: %p\n\n", virt_addr, addr); Os argumentos de mmap são: 0; comprimento da zona de memória a mapear; protecção (no exemplo acima foi dada permissão para escrita e leitura); modo de acesso (se privado a escrita PIN T09-2/7

3 não é enviada para o ficheiro /dev/mem, i.e., não é escrita nos endereços físicos, por isso, no exemplo acima foi seleccionado mode de partilha da memória. Agora pode-se usar o ponteiro para a memória virtual para ler os primeiro 10 caracteres e atributos no buffer de video: p=virt_addr; for (i=0;i<len;i+=2) printf("%c %d\n", p[i], p[i+1]); ou escrever nesse buffer. Por exemplo para que a côr de fundo de uma linha do buffer de video em modo de texto passe para branco: p=virt_addr; for (i=1;i<160;i+=2) p[i]=p[i] (0x07 << 4); Quando já não for necessária, o mapeamento pode ser terminado com: munmap(virt_addr, len); close(f); Acesso à memória de video no espaço do kernel No espaço do kernel terá de ser efectuado também um mapeamento da memória física em páginas de memória virtual. Tal pode ser efectuado com a função ioremap( ), definida em <asm/io.h>., que tem como argumentos o endereço físico e o comprimento em bytes. No caso de um módulo, o remapeamento pode ser efectuado na rotina de inicialização: unsigned char *virt_addr, *p; unsigned int addr=0xb8000; unsigned int len=0x10; virt_addr=(unsigned char*)ioremap(addr, len); printk("\nendereço virtual 0x%p, correspondente ao físico: 0x%x\n", virt_addr, addr); Para aceder a valores na memória virtual mapeada com esta função é necessário usara as funções ioreadx( ) e iowritex( ) já introduzidas: p = virt_addr; for (i=0;i<len;i+=2) printk("%c %d\n", ioread8(p++), ioread8(p++)); Na rotina de encerramento pode cancelar-se o mapeamento com: iounmap(virt_addr); Acesso exclusivo à memória de E/S no kernel Como já foi referido para o caso de drivers para dispositivos de caracter, é conveniente garantir acesso exclusivo aos portos de E/S e também à memória de E/S, garantido que apenas um driver acede a estes recursos. Assim ao inserir um novo módulo, se a região ou parte dela, de portos ou de memória, requerida já foi reservada por um outro driver, o módulo não deve ser inserido, ou pelo menos não deve usar o que já está reservado. A memória já reservada (endereços físicos) pode ser consultada com: cat /proc/iomem f7ff : System RAM PIN T09-3/7

4 0009f ffff : reserved 000a bffff : Video RAM area 128 KBytes 000c c7fff : Video ROM 000f fffff : System ROM ffeffff : System RAM be469 : Kernel code 002be46a e3 : Kernel data (...) f f7ffffff : S3 Inc. ViRGE/DX or /GX fbfff000-fbfff07f : Digital Equipment Corporation DECchip 21142/43 É comum que a área A0000H-BFFFFH esteja reservada pelo driver vga. No entanto esta área tem apenas um comprimento de 128 KBytes, embora os controladores SVGA actuais suportem uma memória de video muito maior. No exemplo acima um adaptador gráfico S3 usa também a região F H-F7FFFFFFH que ocupa 64 MBytes. A verificação e reserva de regiões de memória de E/S, pode ser efectuada na rotina de inicialização e a libertação das regiões na rotina de encerramento, para que após a remoção do driver a memória fique disponível para outro. A verificação se uma região, considerando endereços fisícos, desde base a base+len-1, se encontra reservada e a sua reserva pode ser efectuada com a função request_mem_region ( ), onde os argumentos são: o endereço físico, o tamanho em bytes e o nome que deverá aparecer em proc/iomem: unsigned long base= 0x000A0000; //endereço físico unsigned long len = 0x ; //nº de bytes a reservar void *vaddr; //endereço virtual if (!request_mem_region(base, len, "drivername")) { printk(kern_info "Memória de E/S de: %Xh a %Xh indisponível\n", base, base+len-1); return -ENODEV; Se algum endereço na zona de memória já está reservado a esta função retorna NULL. É da responsabilidade do programador verificar o valor de retorno e não usar estes portos. Não existe mecanismo no kernel que o impeça, no entanto se dois módulos partilharem a mesma zona de memória de E/S o sistema operativo poderá ficar instável. Como já foi visto, será também necessário obter o endereço virtual correspondente com ioremap ( ): vaddr = (unsigned char*) ioremap(base, len); if (!vaddr) { printk(kern_info "Impossível obter endereço virtual para região" "de memória física: %Xh a %Xh \n", base, base+len-1); return -ENODEV; Na rotina de encerramento deve ser libertada a região de memória e eliminado o mapeamento na memória virtual: iounmap(vaddr); release_mem_region(base, len); As funções de reserva e libertação de regiões de memória de E/S, tal como as versões para portos de E/S, estão declaradas em <linux/ioport.h>. PIN T09-4/7

5 9.3 Registos do subsistema VGA De acordo com a aula teórica 22 de (Costa e Bastos, 2004, 2005). 9.4 Bitplanes em modos de texto e gráficos De acordo com as aulas teóricas 23 e 24 de (Costa e Bastos, 2004, 2005), excepto MSDOS e BIOS. 9.5 SVGALIB Em Linux a programação do subsistema de vídeo em C, pode ser efectuada num nível mais elevado através da biblioteca SVGALIB. O exemplo seguinte mostra como inicializar um modo gráfico de 320 colunas por 200 linhas, onde cada pixel pode ter 256 cores, e escrever na posição na linha 10 coluna 10 um pixel com a cor 4, e após 5 segundos regressa ao modo de texto. Nesta biblioteca é assumido que o canto superior esquerdo é a origem do referencial. #include <stdlib.h> #include <vga.h> int main(void) { vga_init(); vga_setmode(g320x200x256); vga_setcolor(4); vga_drawpixel(10, 10); sleep(5); vga_setmode(text); return EXIT_SUCCESS; Para compilar este programa deve ser linkada a biblioteca svgalib e em algumas versões a biblioteca matemática: gcc svgalibdemo.c -lvga -lm Par configurar um sistema Debian para desenvolvimento de aplicações SVGALIB pode-se usar: apt-get install libsvga1 apt-get install libsvga1-dev O exemplo seguinte mostra como escrever directamente na memória de vídeo, de modo a efectuar o mesmo que o conjunto de instruções: vga_setcolor(4); vga_drawpixel(10, 10); no modo de vídeo do exemplo acima. Esta técnica permite acelerar o tratamento de vídeo. No entanto nem em todos os modos a escrita de um pixel pode ser efectuada directamente na memória de vídeo como mostra o exemplo. Poderá ser um pouco mais complexa, dependendo de como são usados os bitplanes no modo em questão. Assim as funções de alto nível da PIN T09-5/7

6 svgalib permitem libertar o programador desta gestão de memória de vídeo, quando pretende escrever um pixel. #include <stdlib.h> #include <vga.h> int main(void) { unsigned char*p; int i; vga_init(); vga_setmode(g320x200x256); p=graph_mem; //Idêntico a: vga_setcolor(4); vga_drawpixel(10, 10); p[10*320+10]=4; sleep(5); vga_setmode(text); printf("\nvga fb: %p\n", p); return EXIT_SUCCESS; Repare-se que a svgalib exporta a variável graph_mem que aponta o ínicio da memória de vídeo. Finalmente um exemplo simples de como animar um bloco para se deslocar por cima de um campo de pontos sem apagar o fundo: #include <stdlib.h> #include <vga.h> #define cols 320 unsigned char block[64]; void move(int l, int c) { unsigned char* p=graph_mem; unsigned char tmp; int i, j; for (j=0;j<8; j++) for (i=0;i<8; i++) { tmp=p[(l+j)*cols+c+i]; p[(l+j)*cols+c+i]=block[j*8+i]; block[j*8+i]=tmp; ; int main(void) { unsigned char* p; int pix[100], i; vga_init(); vga_setmode(g320x200x256); for (i=0; i<64; i++) block[i]=4; p=graph_mem; //virtual addr of A0000H for (i=0;i<1000;i++) p[rand()%10000]=rand()%16; //cria fundo PIN T09-6/7

7 while(1) //anima bloco for (i=10; i<100; i++) { move (10, i); usleep (1000); move (10, i); vga_setmode(text); return EXIT_SUCCESS; A única intervenção da svglib neste caso foi para seleccionar o modo gráfico. Todo o resto é efectuado directamente na memória de vídeo. A função usleep (int micseg) é usada para efectuar um atraso num dado número de micro segundos, de modo que seja vísivel a deslocação do bloco. Se se pretender animar um objecto com uma forma irregular, pode-se usar uma função que para um dado código de cor do objecto, p. ex 255, não altera o fundo do ecran: void move(int l, int c) { unsigned char* p=graph_mem; unsigned char tmp; int i, j; for (j=0;j<8; j++) for (i=0;i<8; i++) if (block[j*8+i]!= 255){ tmp=p[(l+j)*cols+c+i]; p[(l+j)*cols+c+i]=block[j*8+i]; block[j*8+i]=tmp; ; Pode-se agora construir, por exemplo, uma figura baseada num bloco com a área central transparente, i.e. código de cor 255: //... for (i=0; i<64; i++) block[i]=4; for (i=24+2; i<24+6; i++) block[i]=255; for (i=32+2; i<32+6; i++) block[i]=255; //... e usar esta última versão da função move ( ) para animar a figura. 9.6 Bibliografia Costa, Ana Paula e José Bastos (2004, 2005) Resumos das aulas teóricas de Periféricos e Interfaces , Corbet, Jonathan, Alessandro Rubini e Kroah-Hartman, Greg (2005). Linux Device Drivers 3rd edition, O Reilly, Messmer, Hans-Peter (2002). The Indispensable PC Hardware Book 4 th edition, Addison- Wesley Salzman, Peter Jay, Michael Burian and Ori Pomerantz (2005). The Linux Kernel Module Programming Guide, Tanenbaum, Andrew S. (2001). "Modern Operating Systems. 2nd Edition", Prentice Hall Linux man pages PIN T09-7/7