Viewing file:  fourbri.c (12.24 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* Diva Server 4BRI specific part of initialisation
*
* Copyright (C) Eicon Technology Corporation, 2000.
*
* Eicon File Revision : 1.7
*
* This software may be used and distributed according to the terms
* of the GNU General Public License, incorporated herein by reference.
*
*/
#include "sys.h"
#include "idi.h"
#include "divas.h"
#include "pc.h"
#include "pr_pc.h"
#include "dsp_defs.h"
#include "constant.h"
#include "adapter.h"
#include "uxio.h"
#define TEST_INT_DIVAS_Q 0x13
#define DIVAS_MAINT_OFFSET 0xff00 /* value for 4BRI card */
#define MQ_BOARD_DSP_OFFSET 0x00a00000
#define MQ_DSP1_ADDR_OFFSET 0x00000008
#define MQ_DSP_JUNK_OFFSET 0x00000400
#define MQ_DSP1_DATA_OFFSET 0x00000000
#define MQ_BOARD_ISAC_DSP_RESET 0x00800028
#define MQ_BREG_RISC 0x1200 /* RISC Reset */
#define MQ_ISAC_DSP_RESET 0x0028 /* ISAC and DSP reset address offset */
#define MQ_RISC_COLD_RESET_MASK 0x0001 /* RISC Cold reset */
#define MQ_RISC_WARM_RESET_MASK 0x0002 /* RISC Warm reset */
#define MQ_IRQ_REQ_ON 0x1
#define MQ_IRQ_REQ_OFF 0x0
#define MQ_BREG_IRQ_TEST 0x0608
#define PLX9054_INTCSR 0x69
#define PLX9054_INT_ENA 0x09
#define DIVAS_IOBASE 0x01
#define M_PCI_RESET 0x10
byte mem_in(ADAPTER *a, void *adr);
word mem_inw(ADAPTER *a, void *adr);
void mem_in_buffer(ADAPTER *a, void *adr, void *P, word length);
void mem_look_ahead(ADAPTER *a, PBUFFER *RBuffer, ENTITY *e);
void mem_out(ADAPTER *a, void *adr, byte data);
void mem_outw(ADAPTER *a, void *adr, word data);
void mem_out_buffer(ADAPTER *a, void *adr, void *P, word length);
void mem_inc(ADAPTER *a, void *adr);
int Divas4BRIInitPCI(card_t *card, dia_card_t *cfg);
static int fourbri_ISR (card_t* card);
int FPGA_Download(word, dword, byte *, byte *, int);
extern byte FPGA_Bytes[];
extern void *get_card(int);
byte UxCardPortIoIn(ux_diva_card_t *card, byte *base, int offset);
void UxCardPortIoOut(ux_diva_card_t *card, byte *base, int offset, byte);
word GetProtFeatureValue(char *sw_id);
void memcp(byte *dst, byte *src, dword dwLen);
int memcm(byte *dst, byte *src, dword dwLen);
static int diva_server_4bri_reset(card_t *card)
{
byte *ctl;
DPRINTF(("divas: reset Diva Server 4BRI"));
ctl = UxCardMemAttach(card->hw, DIVAS_CTL_MEMORY);
/* stop RISC, DSP's and ISAC */
UxCardMemOut(card->hw, &ctl[MQ_BREG_RISC], 0);
UxCardMemOut(card->hw, &ctl[MQ_ISAC_DSP_RESET], 0);
UxCardMemDetach(card->hw, ctl);
return 0;
}
static int diva_server_4bri_config(card_t *card, dia_config_t *config)
{
byte *shared;
int i, j;
DPRINTF(("divas: configure Diva Server 4BRI"));
shared = (byte *) UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
for (i=0; i<256; i++)
{
UxCardMemOut(card->hw, &shared[i], 0);
}
UxCardMemOut(card->hw, &shared[ 8], config->tei);
UxCardMemOut(card->hw, &shared[ 9], config->nt2);
UxCardMemOut(card->hw, &shared[10], config->sig_flags);
UxCardMemOut(card->hw, &shared[11], config->watchdog);
UxCardMemOut(card->hw, &shared[12], config->permanent);
UxCardMemOut(card->hw, &shared[13], config->x_interface);
UxCardMemOut(card->hw, &shared[14], config->stable_l2);
UxCardMemOut(card->hw, &shared[15], config->no_order_check);
UxCardMemOut(card->hw, &shared[16], config->handset_type);
UxCardMemOut(card->hw, &shared[17], 0);
UxCardMemOut(card->hw, &shared[18], config->low_channel);
UxCardMemOut(card->hw, &shared[19], config->prot_version);
UxCardMemOut(card->hw, &shared[20], config->crc4);
if ((card->hw->features) && (card->hw->features & PROTCAP_V90D))
{
DPRINTF(("divas: Signifying V.90"));
UxCardMemOut(card->hw, &shared[22], 4);
}
else
{
UxCardMemOut(card->hw, &shared[22], 0);
}
for (i=0; i<2; i++)
{
for (j=0; j<32; j++)
{
UxCardMemOut(card->hw, &shared[32+(i*96)+j],config->terminal[i].oad[j]);
}
for (j=0; j<32; j++)
{
UxCardMemOut(card->hw, &shared[64+(i*96)+j],config->terminal[i].osa[j]);
}
for (j=0; j<32; j++)
{
UxCardMemOut(card->hw, &shared[96+(i*96)+j],config->terminal[i].spid[j]);
}
}
UxCardMemDetach(card->hw, shared);
return 0;
}
static
void diva_server_4bri_reset_int(card_t *card)
{
byte *ctl;
ctl = UxCardMemAttach(card->hw, DIVAS_CTL_MEMORY);
UxCardMemOut(card->hw, &ctl[MQ_BREG_IRQ_TEST], MQ_IRQ_REQ_OFF);
UxCardMemDetach(card->hw, ctl);
return;
}
static int diva_server_4bri_test_int(card_t *card)
{
byte *ctl, i;
byte *reg;
DPRINTF(("divas: test interrupt for Diva Server 4BRI"));
/* We get the last (dummy) adapter in so we need to go back to the first */
card = get_card(card->cfg.card_id - 3);
/* Enable interrupts on PLX chip */
reg = UxCardMemAttach(card->hw, DIVAS_REG_MEMORY);
UxCardPortIoOut(card->hw, reg, PLX9054_INTCSR, PLX9054_INT_ENA);
UxCardMemDetach(card->hw, reg);
/* Set the test interrupt flag */
card->test_int_pend = TEST_INT_DIVAS_Q;
/* Now to trigger the interrupt */
ctl = UxCardMemAttach(card->hw, DIVAS_CTL_MEMORY);
UxCardMemOut(card->hw, &ctl[MQ_BREG_IRQ_TEST], MQ_IRQ_REQ_ON);
UxCardMemDetach(card->hw, ctl);
for (i = 0; i < 50; i++)
{
if (!card->test_int_pend)
{
break;
}
UxPause(10);
}
if (card->test_int_pend)
{
DPRINTF(("active: timeout waiting for card to interrupt"));
return (-1);
}
return 0;
}
static void print_hdr(unsigned char *code, int offset)
{
unsigned char hdr[80];
int i;
i = 0;
while ((i < (DIM(hdr) -1)) &&
(code[offset + i] != '\0') &&
(code[offset + i] != '\r') &&
(code[offset + i] != '\n'))
{
hdr[i] = code[offset + i];
i++;
}
hdr[i] = '\0';
DPRINTF(("divas: loading %s", hdr));
}
static int diva_server_4bri_load(card_t *card, dia_load_t *load)
{
byte *pRAM=NULL;
int download_offset=0;
card_t *FirstCard;
byte sw_id[80];
DPRINTF(("divas: loading Diva Server 4BRI[%d]", load->card_id));
switch(load->code_type)
{
case DIA_CPU_CODE:
DPRINTF(("divas: RISC code"));
print_hdr(load->code, 0x80);
card->hw->features = GetProtFeatureValue((char *)&load->code[0x80]);
download_offset = 0; // Protocol code written to offset 0
pRAM = UxCardMemAttach(card->hw, DIVAS_RAM_MEMORY);
break;
case DIA_DSP_CODE:
DPRINTF(("divas: DSP code"));
print_hdr(load->code, 0x0);
FirstCard = get_card(load->card_id - 3);
if ((card->hw->features) && (card->hw->features & PROTCAP_V90D))
{
download_offset = MQ_V90D_DSP_CODE_BASE;
}
else
{
download_offset = MQ_ORG_DSP_CODE_BASE;
}
pRAM = UxCardMemAttach(FirstCard->hw, DIVAS_RAM_MEMORY);
download_offset += (((sizeof(dword) + (sizeof(t_dsp_download_desc)* DSP_MAX_DOWNLOAD_COUNT)) + 3) & 0xFFFFFFFC);
break;
case DIA_TABLE_CODE:
DPRINTF(("divas: TABLE code"));
FirstCard = get_card(load->card_id - 3);
if ((card->hw->features) && (card->hw->features & PROTCAP_V90D))
{
download_offset = MQ_V90D_DSP_CODE_BASE + sizeof(dword);
}
else
{
download_offset = MQ_ORG_DSP_CODE_BASE + sizeof(dword);
}
pRAM = UxCardMemAttach(FirstCard->hw, DIVAS_RAM_MEMORY);
break;
case DIA_CONT_CODE:
DPRINTF(("divas: continuation code"));
break;
case DIA_DLOAD_CNT:
DPRINTF(("divas: COUNT code"));
FirstCard = get_card(load->card_id - 3);
if ((card->hw->features) && (card->hw->features & PROTCAP_V90D))
{
download_offset = MQ_V90D_DSP_CODE_BASE;
}
else
{
download_offset = MQ_ORG_DSP_CODE_BASE;
}
pRAM = UxCardMemAttach(FirstCard->hw, DIVAS_RAM_MEMORY);
break;
case DIA_FPGA_CODE:
DPRINTF(("divas: 4BRI FPGA download - %d bytes", load->length));
if (FPGA_Download(IDI_ADAPTER_MAESTRAQ,
card->hw->io_base,
sw_id,
load->code,
load->length
) == -1)
{
DPRINTF(("divas: FPGA download failed"));
return -1;
}
/* NOW reset the 4BRI */
diva_server_4bri_reset(card);
return 0; // No need for anything further loading
default:
DPRINTF(("divas: unknown code type"));
return -1;
}
memcp(pRAM + (download_offset & 0x3FFFFF), load->code, load->length);
{
int mism_off;
if ((mism_off = memcm(pRAM + (download_offset & 0x3FFFFF), load->code, load->length)))
{
DPRINTF(("divas: memory mismatch at offset %d", mism_off));
UxCardMemDetach(card->hw, pRAM);
return -1;
}
}
UxCardMemDetach(card->hw, pRAM);
return 0;
}
static int diva_server_4bri_start(card_t *card, byte *channels)
{
byte *ctl;
byte *shared, i;
int adapter_num;
DPRINTF(("divas: start Diva Server 4BRI"));
*channels = 0;
card->is_live = FALSE;
ctl = UxCardMemAttach(card->hw, DIVAS_CTL_MEMORY);
UxCardMemOutW(card->hw, &ctl[MQ_BREG_RISC], MQ_RISC_COLD_RESET_MASK);
UxPause(2);
UxCardMemOutW(card->hw, &ctl[MQ_BREG_RISC], MQ_RISC_WARM_RESET_MASK | MQ_RISC_COLD_RESET_MASK);
UxPause(10);
UxCardMemDetach(card->hw, ctl);
shared = (byte *) UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
for ( i = 0 ; i < 300 ; ++i )
{
UxPause (10) ;
if ( UxCardMemInW(card->hw, &shared[0x1E]) == 0x4447 )
{
DPRINTF(("divas: Protocol startup time %d.%02d seconds",
(i / 100), (i % 100) ));
break;
}
}
if (i==300)
{
DPRINTF(("divas: Timeout starting card"));
DPRINTF(("divas: Signature == 0x%04X", UxCardMemInW(card->hw, &shared[0x1E])));
UxCardMemDetach(card->hw, shared);
return -1;
}
UxCardMemDetach(card->hw, shared);
for (adapter_num=3; adapter_num >= 0; adapter_num--)
{
card_t *qbri_card;
qbri_card = get_card(card->cfg.card_id - adapter_num);
if (qbri_card)
{
qbri_card->is_live = TRUE;
shared = UxCardMemAttach(qbri_card->hw, DIVAS_SHARED_MEMORY);
*channels += UxCardMemIn(qbri_card->hw, &shared[0x3F6]);
UxCardMemDetach(qbri_card->hw, shared);
}
else
{
DPRINTF(("divas: Couldn't get card info %d", card->cfg.card_id));
}
}
diva_server_4bri_test_int(card);
return 0;
}
static
int diva_server_4bri_mem_get(card_t *card, mem_block_t *mem_block)
{
byte *a;
byte *card_addr;
word length = 0;
int i;
a = UxCardMemAttach(card->hw, DIVAS_RAM_MEMORY);
card_addr = a;
card_addr += mem_block->addr;
for (i=0; i < sizeof(mem_block->data); i++)
{
mem_block->data[i] = UxCardMemIn(card->hw, card_addr);
card_addr++;
length++;
}
UxCardMemDetach(card->hw, a);
return length;
}
/*
* Initialise 4BRI specific entry points
*/
int Divas4BriInit(card_t *card, dia_card_t *cfg)
{
// byte sw_id[80];
// extern int FPGA_Done;
DPRINTF(("divas: initialise Diva Server 4BRI"));
if (Divas4BRIInitPCI(card, cfg) == -1)
{
return -1;
}
/* Need to download the FPGA */
/* if (!FPGA_Done)
{
int retVal;
retVal=FPGA_Download(IDI_ADAPTER_MAESTRAQ,
cfg->io_base,
sw_id,
FPGA_Bytes
);
if(retVal==-1)
{
DPRINTF(("divas: FPGA Download Failed"));
return -1;
}
FPGA_Done = 1;
} */
card->card_reset = diva_server_4bri_reset;
card->card_load = diva_server_4bri_load;
card->card_config = diva_server_4bri_config;
card->card_start = diva_server_4bri_start;
card->reset_int = diva_server_4bri_reset_int;
card->card_mem_get = diva_server_4bri_mem_get;
card->xlog_offset = DIVAS_MAINT_OFFSET;
card->out = DivasOut;
card->test_int = DivasTestInt;
card->dpc = DivasDpc;
card->clear_int = DivasClearInt;
card->card_isr = fourbri_ISR;
card->a.ram_out = mem_out;
card->a.ram_outw = mem_outw;
card->a.ram_out_buffer = mem_out_buffer;
card->a.ram_inc = mem_inc;
card->a.ram_in = mem_in;
card->a.ram_inw = mem_inw;
card->a.ram_in_buffer = mem_in_buffer;
card->a.ram_look_ahead = mem_look_ahead;
return 0;
}
void memcp(byte *dst, byte *src, dword dwLen)
{
while (dwLen)
{
*dst = *src;
dst++; src++;
dwLen--;
}
}
int memcm(byte *dst, byte *src, dword dwLen)
{
int offset = 0;
while (offset < dwLen)
{
if(*dst != *src)
return (offset+1);
offset++;
src++;
dst++;
}
return 0;
}
/*int fourbri_ISR (card_t* card)
{
int served = 0;
byte *DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
if (UxCardPortIoIn (card->hw, DivasIOBase, M_PCI_RESET) & 0x01)
{
served = 1;
card->int_pend += 1;
DivasDpcSchedule();
UxCardPortIoOut (card->hw, DivasIOBase, M_PCI_RESET, 0x08);
}
UxCardMemDetach(card->hw, DivasIOBase);
return (served != 0);
}*/
static int fourbri_ISR (card_t* card)
{
byte *ctl;
card->int_pend += 1;
DivasDpcSchedule(); /* ISR DPC */
ctl = UxCardMemAttach(card->hw, DIVAS_CTL_MEMORY);
UxCardMemOut(card->hw, &ctl[MQ_BREG_IRQ_TEST], MQ_IRQ_REQ_OFF);
UxCardMemDetach(card->hw, ctl);
return (1);
}
|