Subversion Repositories shark

/*

 Nome File : pxc.c

 Autore : Danilo Dealberti

          Claudio Melita

 Data : 16-11-1999

 Descrizione : modulo di implementazione delle funzioni del PXC200

 Modifiche :

*/

/*

 Note :

 Il seguente modulo permette Š in grado di supportare ogni frame grabber

 dotato del controllore single-chip Bt848/Bt848A/Bt849 della BrookTree (ora

 Conexant)

 Per variare la risoluzione di acquisizione o il formato dei dati in ingresso

 vanno variati i parametri contenuti nel seguente modulo , il quale Š

 specifico per immagini di 384x288 pixel codificate a 8 livelli di grigio

 Le modifiche possono essere effettuate consultando il manuale di descrizione del

 chip Bt848 disponibile al sito www.Conexant.com

*/

#include <kernel/func.h>

#include <sys/types.h>

#include <drivers/pci.h>

#include <drivers/pxc.h>

#include <drivers/llpci.h>

#include "../../drivers/pci/linuxpci.h"

#define appl2linear(x) (x)

// Prototipi locali

void PXC_fast(void);

void Generate_Program(DWORD *B1);

void Modify_Program(DWORD *B1);

// Variabili locali al modulo

static DWORD BaseAddr;

static BYTE IntLine;

static unsigned char *Corpo;

static unsigned char V_Corpo[7000];

static DWORD *Pun;

static DWORD Programma;

static DWORD Buffer1;

static int errore;

static PXC_Listeners Lista;

static BYTE bus,dev;

static TIME per;

static TIME Fotogramma;

static DWORD old;

static CAB Depositi;

static unsigned char *pointer;

TIME PXC_Initiate(int number) {

   struct pci_regs *reg;                  

   unsigned register int i;

   BYTE dep;

   DWORD dw;

//   MODEL m=BASE_MODEL;

//   TIME wcet;

   reg=NULL;

   if (pci_init()==1) {

      reg = (struct pci_regs *) pci_class((0x0400) << 8,0,&bus,&dev) ;

      if (reg != NULL) {

         // Ottiene l' indirizzo di base del frame grabber

         BaseAddr = (reg->IoBaseAddress-0x08); ;

         IntLine = reg->InterruptLine; // Ottiene la linea di interrupt

      } else {

         errore = 1;

         return 0;

      }

   } else {

      errore =2;

      return 0;

   }

   pcibios_read_config_dword(bus,dev,PCI_COMMAND,&dw);

   old=dw;

   dw |= (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER) ; // Abilita il mastering del BUS PCI e anche la mappatura in memoria

   pcibios_write_config_dword(bus,dev,PCI_COMMAND,dw);

   // Controllo della presenza di video input

   dep = (BYTE) lmempeekb((void *)(BaseAddr+PXC_DSTATUS));

   if (dep & 0x80) {

     // Creazione del CAB in base al numero di processi interessati

     Depositi = cab_create("",PXC_MAXX*PXC_MAXY*sizeof(unsigned char),number+2);

     if (Depositi<0) return 0;

      // Autoformat detected enabled

      lmempokeb((void *)(BaseAddr+PXC_IOFORM),0x58);

      // Fattore di scala orizzontale 2:1

      lmempokeb((void *)(BaseAddr+ PXC_E_HSCALE_HI),0x16);

      lmempokeb((void *)(BaseAddr+ PXC_E_HSCALE_LO),0x79);

      lmempokeb((void *)(BaseAddr+ PXC_O_HSCALE_HI),0x16);

      lmempokeb((void *)(BaseAddr+ PXC_O_HSCALE_LO),0x79);

      // Fattore di scala verticale 1:1

      lmempokeb((void *)(BaseAddr+ PXC_E_VSCALE_HI),0x60);

      lmempokeb((void *)(BaseAddr+ PXC_E_VSCALE_LO),0);

      lmempokeb((void *)(BaseAddr+ PXC_O_VSCALE_HI),0x60);

      lmempokeb((void *)(BaseAddr+ PXC_O_VSCALE_LO),0);

      // Numero di pixel orizzontali formanti l'immagine

      lmempokeb((void *)(BaseAddr+ PXC_E_HACTIVE_LO),0x80);

      lmempokeb((void *)(BaseAddr+ PXC_O_HACTIVE_LO),0x80);

      // Numero di pixel verticali formanti l'immagine

      lmempokeb((void *)(BaseAddr+ PXC_E_VACTIVE_LO),0x40);

      lmempokeb((void *)(BaseAddr+ PXC_O_VACTIVE_LO),0x40);

      // Temporizzazione verticale

      lmempokeb((void *)(BaseAddr+ PXC_E_VDELAY_LO),0x20);

      lmempokeb((void *)(BaseAddr+ PXC_O_VDELAY_LO),0x20);

      // Tempozizzazione Orizzontale

      lmempokeb((void *)(BaseAddr+ PXC_E_HDELAY_LO),0x4d);

      lmempokeb((void *)(BaseAddr+ PXC_O_HDELAY_LO),0x4d);

      // Parte alta di VACTIVE HACTIVE VDELAY HDELAY

      lmempokeb((void *)(BaseAddr+ PXC_E_CROP), 0x21);

      lmempokeb((void *)(BaseAddr+ PXC_O_CROP),0x21);

      // Temporizzazione del convertitore ADC e del periodo di burst

      lmempokeb((void *)(BaseAddr+ PXC_ADELAY),0x7f);

      lmempokeb((void *)(BaseAddr+ PXC_BDELAY),0x72);

      // Setta l'acquisizione a 8 livelli di grigio

      lmempokeb((void *)(BaseAddr+ PXC_COLOR_FMT), 0x66);

      // Generazione del programma nel buffer ottenuto dal CAB

      pointer = cab_reserve(Depositi);

      Generate_Program((DWORD *)pointer);

     // Cattura Full-Frame , sia even che odd field

     lmempokeb((void *)(BaseAddr+PXC_CAP_CTL),0x13);

     // Abilitazione delle interruzioni

     lmempoked((void *)(BaseAddr+PXC_INT_MASK),0x00001800);

     // Inserimento dell' indirizzo del programma RISC all' interno del

     // canale DMA

     lmempoked((void *)(BaseAddr+PXC_RISC_STRT_ADD),Programma);

     } else {

         errore=3;

         return 0;

     }

     // Inizializzazione della struttura dati utilizzata per

     // aggiungere processi ascoltatori dell' immagine

    for(i=0;i<PXC_MAX_LISTENERS;i++) {

         Lista.Elementi[i].proc=NIL;

         Lista.Elementi[i].DRel = 0;

    }

    Lista.Top=0;

    per = PXC_FRAME_TIME; // Ritorno periodo in us

    Fotogramma=0;

    return per;

}

/**************************************************************************/

void PXC_Start(void) {

   handler_set(IntLine, (void (*)(int))PXC_fast, NIL);

   lmempokew((void *)(BaseAddr+PXC_GPIO_DMA_CTL),0x0000);

   lmempokew((void *)(BaseAddr+PXC_GPIO_DMA_CTL),0x0003);

}

/**************************************************************************/

int PXC_Push_Listener(PID l, int drel)

{

   int pele;

   if (l == NIL) return 0;

   if (Lista.Top == PXC_MAX_LISTENERS) {

      errore=4;

      return 0; // Non vi sono pi— elementi liberi

   }

   pele = Lista.Top;

   Lista.Top++;

 // Setta tutto ci• che serve per il nuovo elemento

   Lista.Elementi[pele].proc=l;

   Lista.Elementi[pele].DRel = drel;

   return 1;

}

/**************************************************************************/

int PXC_Pop_Listener()

{

   if (Lista.Top > 0) {

      Lista.Top --;

      return 1;

   }

   return 0;

}

/**************************************************************************/

void PXC_Close(void)

{

//   DWORD dw;

 // Ferma il DMA

   lmempokew((void *)(BaseAddr+PXC_GPIO_DMA_CTL),0x0000);

   pcibios_write_config_dword(bus,dev,PCI_COMMAND,old);

   handler_remove(IntLine);

   for(;PXC_Pop_Listener();) ; // Li toglie tutti

   // Rimozione del CAB

   cab_delete(Depositi);

}

/*************************************************************************/

void PXC_fast(void) {

   DWORD pen;

   register int i;

   pen=lmempeekd((void *)(BaseAddr+PXC_INT_STAT));

   if (pen & 0x00000800) {

         // COMMIT al CAB

      cab_putmes(Depositi,pointer);

      // Interrompi il programma RISC

      lmempokew((void *)(BaseAddr+PXC_GPIO_DMA_CTL),0x0000);

      // Crea il nuovo programma in memoria dopo aver riservato il nuovo

      // CAB

      pointer=cab_reserve(Depositi);

      Modify_Program((DWORD *)pointer);

      // Riabilita il programma

      lmempokew((void *)(BaseAddr+PXC_GPIO_DMA_CTL),0x0003);

      Fotogramma++;

      // Attivazione dei task nel fast handler direttamente, visto il suo

      // tempo di esecuzione molto ridotto (decine di microsec contro un

      // interrupt period di 20 millisec )

      for(i=0;i<Lista.Top;i++)

         if (!(Fotogramma % Lista.Elementi[i].DRel)) {

           LEVEL l;

           PID p = Lista.Elementi[i].proc;

           if (proc_table[p].control & FREEZE_ACTIVATION)

             proc_table[p].frozen_activations++;

           else {

             l = proc_table[p].task_level;

             level_table[l]->task_activate(l,p);

             event_need_reschedule();

           }

//           task_activate(Lista.Elementi[i].proc);

         }

    } else {

  // C'Š un errore nell' acquisizione, per ora non lo trattiamo

    }

    lmempoked((void *)(BaseAddr+PXC_INT_STAT),pen); // EOI al Bt848

}

/*************************************************************************/

void Generate_Program(DWORD *B1)

{

 unsigned register int i;

      // Definizione del programma all' interno dello spazio di memoria puntato

      // da Programma , va DWORD aligned , quindi prima lo allineamo, poi

      // andiamo a scriverci dentro il programma, il quale pu• essere variabile

      // in funzione delle opzioni di ingresso

      Corpo = V_Corpo;

      Programma = appl2linear(Corpo);

      if (Programma % 4) {

         unsigned char diff;

        // Procediamo all' allineamento del buffer

         diff = (unsigned char)(((Programma / 4)+1) * 4 -Programma);

         Programma += diff;

         Corpo += diff;  // Anche il puntatore del buffer va aumentato

      }

      // Si innesca sempre da qui

      Pun = (DWORD *) Corpo;

      Buffer1 = appl2linear(B1);

      //Buffer2 = appl2linear(B2);

      (*Pun)=PXC_SYNC | PXC_FM1 ;

      Pun++;

      (*Pun)=0;

      for(i=0;i< PXC_MAXY;i++)

      {

         Pun++;

         (*Pun) = PXC_WRITE | PXC_SET_SOL | PXC_SET_EOL | PXC_MAXX ;

         Pun++;

         (*Pun)=(Buffer1+ i* PXC_MAXX);

      }

      Pun++;

      (*Pun) = PXC_SYNC | PXC_VRE | PXC_SET_IRQ ;

      Pun++;

      (*Pun) = 0;

      Pun++;

      (*Pun) = PXC_SYNC | PXC_FM1   ;

      Pun++;

      (*Pun) = 0;

      // Write mettendo SOL e EOL e come byte count 768 , come indirizzo

      // quello del buffer per il campo dispari

      for(i=0; i<PXC_MAXY; i++) {

         Pun++;

         (*Pun) = PXC_WRITE | PXC_SET_SOL | PXC_SET_EOL | PXC_MAXX ;

         Pun++;

         (*Pun)=(/*Buffer2*/Buffer1+i*PXC_MAXX);

      }

      Pun++;

      (*Pun) = PXC_SYNC | PXC_VRO ;

      Pun++;

      (*Pun)=0;

      // Jump all' indirizzo contenuto in programma e interrupt

      Pun++;

      (*Pun) = PXC_JUMP | PXC_SET_IRQ ;

      Pun++;

      (*Pun) = Programma;

     // Fine programma di istruzione del RISC DMA channels

}

/*********************************************************************/

void Modify_Program(DWORD *B1)

{

 unsigned register int i;

      // Si innesca sempre da qui

      Pun = (DWORD *) Corpo;

      Buffer1 = appl2linear(B1);

      Pun++;

      for(i=0;i< PXC_MAXY;i++)

      {

         Pun+=2;

         (*Pun)=(Buffer1+ i* PXC_MAXX);

      }

      Pun+=4;

      for(i=0; i<PXC_MAXY; i++) {

         Pun+=2;

         (*Pun)=(Buffer1+i*PXC_MAXX);

      }

     // Fine programma di istruzione del RISC DMA channels

}

/****************************************************************************/

CAB PXC_GetCab(void)

{

 return Depositi;

}