Viewing file:  common.c (15.65 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* Copyright (C) Eicon Technology Corporation, 2000.
*
* Eicon File Revision : 1.15
*
* This software may be used and distributed according to the terms
* of the GNU General Public License, incorporated herein by reference.
*
*/
#include "eicon.h"
#include "sys.h"
#include "idi.h"
#include "constant.h"
#include "divas.h"
#include "pc.h"
#include "pr_pc.h"
#include "uxio.h"
#define DIVAS_LOAD_CMD 0x02
#define DIVAS_START_CMD 0x03
#define DIVAS_IRQ_RESET 0xC18
#define DIVAS_IRQ_RESET_VAL 0xFE
#define TEST_INT_DIVAS 0x11
#define TEST_INT_DIVAS_BRI 0x12
#define TEST_INT_DIVAS_Q 0x13
#define DIVAS_RESET 0x81
#define DIVAS_LED1 0x04
#define DIVAS_LED2 0x08
#define DIVAS_LED3 0x20
#define DIVAS_LED4 0x40
#define DIVAS_SIGNATURE 0x4447
#define MP_PROTOCOL_ADDR 0xA0011000
#define PLX_IOBASE 0
#define DIVAS_IOBASE 1
typedef struct {
dword cmd;
dword addr;
dword len;
dword err;
dword live;
dword reserved[(0x1020>>2)-6];
dword signature;
byte data[1];
} diva_server_boot_t;
int DivasCardNext;
card_t DivasCards[MAX_CARDS];
dia_config_t *DivasConfig(card_t *, dia_config_t *);
static
DESCRIPTOR DIDD_Table[32];
void DIVA_DIDD_Read( DESCRIPTOR *table, int tablelength )
{
memset(table, 0, tablelength);
if (tablelength > sizeof(DIDD_Table))
tablelength = sizeof(DIDD_Table);
if(tablelength % sizeof(DESCRIPTOR)) {
tablelength /= sizeof(DESCRIPTOR);
tablelength *= sizeof(DESCRIPTOR);
}
if (tablelength > 0)
memcpy((void *)table, (void *)DIDD_Table, tablelength);
return;
}
void DIVA_DIDD_Write(DESCRIPTOR *table, int tablelength)
{
if (tablelength > sizeof(DIDD_Table))
tablelength = sizeof(DIDD_Table);
memcpy((void *)DIDD_Table, (void *)table, tablelength);
return;
}
static
void init_idi_tab(void)
{
DESCRIPTOR d[32];
memset(d, 0, sizeof(d));
d[0].type = IDI_DIMAINT; /* identify the DIMAINT entry */
d[0].channels = 0; /* zero channels associated with dimaint*/
d[0].features = 0; /* no features associated with dimaint */
d[0].request = (IDI_CALL) DivasPrintf;
DIVA_DIDD_Write(d, sizeof(d));
return;
}
/*
* I/O routines for memory mapped cards
*/
byte mem_in(ADAPTER *a, void *adr)
{
card_t *card = a->io;
unsigned char *b, *m;
byte value;
m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
m += (unsigned int) adr;
value = UxCardMemIn(card->hw, m);
UxCardMemDetach(card->hw, b);
return value;
}
word mem_inw(ADAPTER *a, void *adr)
{
card_t *card = a->io;
unsigned char *b, *m;
word value;
m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
m += (unsigned int) adr;
value = UxCardMemInW(card->hw, m);
UxCardMemDetach(card->hw, b);
return value;
}
void mem_in_buffer(ADAPTER *a, void *adr, void *P, word length)
{
card_t *card = a->io;
unsigned char *b, *m;
m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
m += (unsigned int) adr;
UxCardMemInBuffer(card->hw, m, P, length);
UxCardMemDetach(card->hw, b);
return;
}
void mem_look_ahead(ADAPTER *a, PBUFFER *RBuffer, ENTITY *e)
{
card_t *card = a->io;
unsigned char *b, *m;
m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
m += (dword) &RBuffer->length;
card->RBuffer.length = UxCardMemInW(card->hw, m);
m = b;
m += (dword) &RBuffer->P;
UxCardMemInBuffer(card->hw, m, card->RBuffer.P, card->RBuffer.length);
e->RBuffer = (DBUFFER *) &card->RBuffer;
UxCardMemDetach(card->hw, b);
return;
}
void mem_out(ADAPTER *a, void *adr, byte data)
{
card_t *card = a->io;
unsigned char *b, *m;
m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
m += (unsigned int) adr;
UxCardMemOut(card->hw, m, data);
UxCardMemDetach(card->hw, b);
return;
}
void mem_outw(ADAPTER *a, void *adr, word data)
{
card_t *card = a->io;
unsigned char *b, *m;
m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
m += (unsigned int) adr;
UxCardMemOutW(card->hw, m, data);
UxCardMemDetach(card->hw, b);
return;
}
void mem_out_buffer(ADAPTER *a, void *adr, void *P, word length)
{
card_t *card = a->io;
unsigned char *b, *m;
m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
m += (unsigned int) adr;
UxCardMemOutBuffer(card->hw, m, P, length);
UxCardMemDetach(card->hw, b);
return;
}
void mem_inc(ADAPTER *a, void *adr)
{
word value;
card_t *card = a->io;
unsigned char *b, *m;
m = b = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
m += (unsigned int) adr;
value = UxCardMemInW(card->hw, m);
value++;
UxCardMemOutW(card->hw, m, value);
UxCardMemDetach(card->hw, b);
return;
}
/*
* I/O routines for I/O mapped cards
*/
byte io_in(ADAPTER *a, void *adr)
{
card_t *card = a->io;
byte value;
byte *DivasIOBase = NULL;
DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
value = UxCardIoIn(card->hw, DivasIOBase, adr);
UxCardMemDetach(card->hw, DivasIOBase);
return value;
}
word io_inw(ADAPTER *a, void *adr)
{
card_t *card = a->io;
word value;
byte *DivasIOBase = NULL;
DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
value = UxCardIoInW(card->hw, DivasIOBase, adr);
UxCardMemDetach(card->hw, DivasIOBase);
return value;
}
void io_in_buffer(ADAPTER *a, void *adr, void *P, word length)
{
card_t *card = a->io;
byte *DivasIOBase = NULL;
DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
UxCardIoInBuffer(card->hw, DivasIOBase, adr, P,length);
UxCardMemDetach(card->hw, DivasIOBase);
return;
}
void io_look_ahead(ADAPTER *a, PBUFFER *RBuffer, ENTITY *e)
{
card_t *card = a->io;
byte *DivasIOBase = NULL;
DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
card->RBuffer.length = UxCardIoInW(card->hw, DivasIOBase, (byte *) RBuffer);
UxCardIoInBuffer(card->hw, DivasIOBase, &RBuffer->P, card->RBuffer.P, card->RBuffer.length);
UxCardMemDetach(card->hw, DivasIOBase);
e->RBuffer = (DBUFFER *) &card->RBuffer;
return;
}
void io_out(ADAPTER *a, void *adr, byte data)
{
card_t *card = a->io;
byte *DivasIOBase = NULL;
DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
UxCardIoOut(card->hw, DivasIOBase, adr, data);
UxCardMemDetach(card->hw, DivasIOBase);
return;
}
void io_outw(ADAPTER *a, void *adr, word data)
{
card_t *card = a->io;
byte *DivasIOBase = NULL;
DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
UxCardIoOutW(card->hw, DivasIOBase, adr, data);
UxCardMemDetach(card->hw, DivasIOBase);
return;
}
void io_out_buffer(ADAPTER *a, void *adr, void *P, word length)
{
card_t *card = a->io;
byte *DivasIOBase = NULL;
DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
UxCardIoOutBuffer(card->hw, DivasIOBase, adr, P, length);
UxCardMemDetach(card->hw, DivasIOBase);
return;
}
void io_inc(ADAPTER *a, void *adr)
{
word value;
card_t *card = a->io;
byte *DivasIOBase;
DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
value = UxCardIoInW(card->hw, DivasIOBase, adr);
value++;
UxCardIoOutW(card->hw, DivasIOBase, adr, value);
UxCardMemDetach(card->hw, DivasIOBase);
return;
}
static
void test_int(card_t *card)
{
byte *shared, *DivasIOBase;
switch (card->test_int_pend)
{
case TEST_INT_DIVAS:
DPRINTF(("divas: test interrupt pending"));
shared = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
if (UxCardMemIn(card->hw, &shared[0x3FE]))
{
UxCardMemOut(card->hw,
&(((struct pr_ram *)shared)->RcOutput), 0);
UxCardMemDetach(card->hw, shared);
(*card->reset_int)(card);
shared = UxCardMemAttach(card->hw, DIVAS_SHARED_MEMORY);
UxCardMemOut(card->hw, &shared[0x3FE], 0);
DPRINTF(("divas: test interrupt cleared"));
}
UxCardMemDetach(card->hw, shared);
card->test_int_pend = 0;
break;
case TEST_INT_DIVAS_BRI:
DPRINTF(("divas: BRI test interrupt pending"));
(*card->reset_int)(card);
DivasIOBase = UxCardMemAttach(card->hw, DIVAS_IOBASE);
UxCardIoOutW(card->hw, DivasIOBase, (void *) 0x3FE, 0);
UxCardMemDetach(card->hw, DivasIOBase);
DPRINTF(("divas: test interrupt cleared"));
card->test_int_pend = 0;
break;
case TEST_INT_DIVAS_Q:
DPRINTF(("divas: 4BRI test interrupt pending"));
(*card->reset_int)(card);
card->test_int_pend = 0;
break;
default:
DPRINTF(("divas: unknown test interrupt pending"));
return;
}
return;
}
void card_isr (void *dev_id)
{
card_t *card = (card_t *) dev_id;
ADAPTER *a = &card->a;
int ipl;
if (card->test_int_pend)
{
ipl = UxCardLock(card->hw);
card->int_pend=0;
test_int(card);
UxCardUnlock(card->hw,ipl);
return;
}
if(card->card_isr)
{
(*(card->card_isr))(card);
}
else
{
ipl = UxCardLock(card->hw);
if ((card->test_int)(a))
{
(card->reset_int)(card);
}
UxCardUnlock(card->hw,ipl);
}
}
int DivasCardNew(dia_card_t *card_info)
{
card_t *card;
static boolean_t first_call = TRUE;
boolean_t NeedISRandReset = FALSE;
DPRINTF(("divas: new card "));
if (first_call)
{
first_call = FALSE;
init_idi_tab();
}
DivasConfigGet(card_info);
if (DivasCardNext == DIM(DivasCards))
{
KDPRINTF((KERN_WARNING "Divas: no space available for new card"));
return -1;
}
card = &DivasCards[DivasCardNext];
card->state = DIA_UNKNOWN;
card->cfg = *card_info;
card->a.io = card;
if (UxCardHandleGet(&card->hw, card_info))
{
KDPRINTF((KERN_WARNING "Divas: cannot get OS specific handle for card"));
return -1;
}
if (card_info->card_type == DIA_CARD_TYPE_DIVA_SERVER_B)
{
DivasBriPatch(card);
card_info->io_base = card->cfg.io_base;
}
switch (card_info->card_type)
{
case DIA_CARD_TYPE_DIVA_SERVER:
if (DivasPriInit(card, card_info))
{
return -1;
}
NeedISRandReset = TRUE;
break;
case DIA_CARD_TYPE_DIVA_SERVER_B:
if (DivasBriInit(card, card_info))
{
return -1;
}
NeedISRandReset = TRUE;
break;
case DIA_CARD_TYPE_DIVA_SERVER_Q:
if (Divas4BriInit(card, card_info))
{
return -1;
}
if (card_info->name[6] == '0')
{
NeedISRandReset = TRUE;
}
else // Need to set paramater for ISR anyway
{
card->hw->user_isr_arg = card;
card->hw->user_isr = card_isr;
}
break;
default:
KDPRINTF((KERN_WARNING "Divas: unsupported card type (%d)", card_info->card_type));
return -1;
}
if (NeedISRandReset)
{
if (UxIsrInstall(card->hw, card_isr, card))
{
KDPRINTF((KERN_WARNING "Divas: Install ISR failed (IRQ %d)", card->cfg.irq));
UxCardHandleFree(card->hw);
return -1;
}
if (card_info->card_type != DIA_CARD_TYPE_DIVA_SERVER_Q)
{
if ((*card->card_reset)(card))
{
KDPRINTF((KERN_WARNING "Divas: Adapter reset failed"));
return -1;
}
card->state = DIA_RESET;
}
NeedISRandReset = FALSE;
}
DivasCardNext++;
return 0;
}
void *get_card(int card_id)
{
int i;
for (i=0; i < DivasCardNext; i++)
{
if (DivasCards[i].cfg.card_id == card_id)
{
return(&DivasCards[i]);
}
}
DPRINTF(("divas: get_card() : no such card id (%d)", card_id));
return NULL;
}
int DivasCardConfig(dia_config_t *config)
{
card_t *card;
int status;
DPRINTF(("divas: configuring card"));
card = get_card(config->card_id);
if (!card)
{
return -1;
}
config = DivasConfig(card, config);
status = (*card->card_config)(card, config);
if (!status)
{
card->state = DIA_CONFIGURED;
}
return status;
}
int DivasCardLoad(dia_load_t *load)
{
card_t *card;
int status;
card = get_card(load->card_id);
if (!card)
{
return -1;
}
if (card->state == DIA_RUNNING)
{
(*card->card_reset)(card);
}
status = (*card->card_load)(card, load);
if (!status)
{
card->state = DIA_LOADED;
}
return status;
}
static int idi_register(card_t *card, byte channels)
{
DESCRIPTOR d[32];
int length, num_entities;
DPRINTF(("divas: registering card with IDI"));
num_entities = (channels > 2) ? MAX_PENTITIES : MAX_ENTITIES;
card->e_tbl = UxAlloc(sizeof(E_INFO) * num_entities);
if (!card->e_tbl)
{
KDPRINTF((KERN_WARNING "Divas: IDI register failed - no memory available"));
return -1;
}
memset(card->e_tbl, 0, sizeof(E_INFO) * num_entities);
card->e_max = num_entities;
DIVA_DIDD_Read(d, sizeof(d));
for(length=0; length < DIM(d); length++)
if (d[length].type == 0) break;
if (length >= DIM(d))
{
KDPRINTF((KERN_WARNING "Divas: IDI register failed - table full"));
return -1;
}
switch (card->cfg.card_type)
{
case DIA_CARD_TYPE_DIVA_SERVER:
d[length].type = IDI_ADAPTER_PR;
/* d[length].serial = card->serial_no; */
break;
case DIA_CARD_TYPE_DIVA_SERVER_B:
d[length].type = IDI_ADAPTER_MAESTRA;
/* d[length].serial = card->serial_no; */
break;
// 4BRI is treated as 4 BRI adapters
case DIA_CARD_TYPE_DIVA_SERVER_Q:
d[length].type = IDI_ADAPTER_MAESTRA;
/* d[length].serial = card->cfg.serial; */
}
d[length].features = 0;
d[length].features |= DI_FAX3|DI_MODEM|DI_POST|DI_V110|DI_V120;
if ( card->hw->features & PROTCAP_MANIF )
{
d[length].features |= DI_MANAGE ;
}
if ( card->hw->features & PROTCAP_V_42 )
{
d[length].features |= DI_V_42 ;
}
if ( card->hw->features & PROTCAP_EXTD_FAX )
{
d[length].features |= DI_EXTD_FAX ;
}
d[length].channels = channels;
d[length].request = DivasIdiRequest[card - DivasCards];
length++;
DIVA_DIDD_Write(d, sizeof(d));
return 0;
}
int DivasCardStart(int card_id)
{
card_t *card;
byte channels;
int status;
DPRINTF(("divas: starting card"));
card = get_card(card_id);
if (!card)
{
return -1;
}
status = (*card->card_start)(card, &channels);
if (status)
{
return status;
}
/* 4BRI == 4 x BRI so call idi_register 4 times each with 2 channels */
if (card->cfg.card_type == DIA_CARD_TYPE_DIVA_SERVER_Q)
{
int i;
card_t *FourBRISlave;
for (i=3; i >= 0; i--)
{
FourBRISlave = get_card(card_id - i); /* 0, 1, 2, 3 */
if (FourBRISlave)
{
idi_register(FourBRISlave, 2);
FourBRISlave->state = DIA_RUNNING;
}
}
card->serial_no = card->cfg.serial;
DPRINTF(("divas: card id %d (4BRI), serial no. 0x%x ready with %d channels",
card_id - 3, card->serial_no, (int) channels));
}
else
{
status = idi_register(card, channels);
if (!status)
{
card->state = DIA_RUNNING;
DPRINTF(("divas: card id %d, serial no. 0x%x ready with %d channels",
card_id, card->serial_no, (int) channels));
}
}
return status;
}
int DivasGetMem(mem_block_t *mem_block)
{
card_t *card;
word card_id = mem_block->card_id;
card = get_card(card_id);
if (!card)
{
return 0;
}
return (*card->card_mem_get)(card, mem_block);
}
/*
* Deleyed Procedure Call for handling interrupts from card
*/
void DivaDoCardDpc(card_t *card)
{
ADAPTER *a;
a = &card->a;
if(UxInterlockedIncrement(card->hw, &card->dpc_reentered) > 1)
{
return;
}
do{
if((*(card->test_int))(a))
{
(*(card->dpc))(a);
(*(card->clear_int))(a);
}
(*(card->out))(a);
}while(UxInterlockedDecrement(card->hw, &card->dpc_reentered));
}
void DivasDoDpc(void *pData)
{
card_t *card = DivasCards;
int i = DivasCardNext;
while(i--)
{
if (card->state == DIA_RUNNING)
DivaDoCardDpc(card);
card++;
}
}
void DivasDoRequestDpc(void *pData)
{
DivasDoDpc(pData);
}
/*
* DivasGetNum
* Returns the number of active adapters
*/
int DivasGetNum(void)
{
return(DivasCardNext);
}
/*
* DivasGetList
* Returns a list of active adapters
*/
int DivasGetList(dia_card_list_t *card_list)
{
int i;
memset(card_list, 0, sizeof(dia_card_list_t));
for(i = 0; i < DivasCardNext; i++)
{
card_list->card_type = DivasCards[i].cfg.card_type;
card_list->card_slot = DivasCards[i].cfg.slot;
card_list->state = DivasCards[i].state;
card_list++;
}
return 0;
}
/*
* control logging for specified card
*/
void DivasLog(dia_log_t *log)
{
card_t *card;
card = get_card(log->card_id);
if (!card)
{
return;
}
card->log_types = log->log_types;
return;
}
|