564 lines
13 KiB
C
564 lines
13 KiB
C
/*
|
|
* $Id$
|
|
* Copyright (C) 1996 SpellCaster Telecommunications Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
* For more information, please contact gpl-info@spellcast.com or write:
|
|
*
|
|
* SpellCaster Telecommunications Inc.
|
|
* 5621 Finch Avenue East, Unit #3
|
|
* Scarborough, Ontario Canada
|
|
* M1B 2T9
|
|
* +1 (416) 297-8565
|
|
* +1 (416) 297-6433 Facsimile
|
|
*/
|
|
|
|
#define __NO_VERSION__
|
|
#include "includes.h" /* This must be first */
|
|
#include "hardware.h"
|
|
#include "message.h"
|
|
#include "card.h"
|
|
#include "scioc.h"
|
|
|
|
int dial(int card, unsigned long channel, setup_parm setup);
|
|
int hangup(int card, unsigned long channel);
|
|
int answer(int card, unsigned long channel);
|
|
int clreaz(int card, unsigned long channel);
|
|
int seteaz(int card, unsigned long channel, char *);
|
|
int geteaz(int card, unsigned long channel, char *);
|
|
int setsil(int card, unsigned long channel, char *);
|
|
int getsil(int card, unsigned long channel, char *);
|
|
int setl2(int card, unsigned long arg);
|
|
int getl2(int card, unsigned long arg);
|
|
int setl3(int card, unsigned long arg);
|
|
int getl3(int card, unsigned long arg);
|
|
int lock(void);
|
|
int unlock(void);
|
|
int acceptb(int card, unsigned long channel);
|
|
|
|
extern int cinst;
|
|
extern board *adapter[];
|
|
|
|
extern int sc_ioctl(int, scs_ioctl *);
|
|
extern int setup_buffers(int, int, unsigned int);
|
|
extern int indicate_status(int, int,ulong,char*);
|
|
extern void check_reset(unsigned long);
|
|
extern int send_and_receive(int, unsigned int, unsigned char, unsigned char,
|
|
unsigned char, unsigned char, unsigned char, unsigned char *,
|
|
RspMessage *, int);
|
|
extern int sendmessage(int, unsigned int, unsigned int, unsigned int,
|
|
unsigned int, unsigned int, unsigned int, unsigned int *);
|
|
extern inline void pullphone(char *, char *);
|
|
|
|
#ifdef DEBUG
|
|
/*
|
|
* Translate command codes to strings
|
|
*/
|
|
static char *commands[] = { "ISDN_CMD_IOCTL",
|
|
"ISDN_CMD_DIAL",
|
|
"ISDN_CMD_ACCEPTB",
|
|
"ISDN_CMD_ACCEPTB",
|
|
"ISDN_CMD_HANGUP",
|
|
"ISDN_CMD_CLREAZ",
|
|
"ISDN_CMD_SETEAZ",
|
|
"ISDN_CMD_GETEAZ",
|
|
"ISDN_CMD_SETSIL",
|
|
"ISDN_CMD_GETSIL",
|
|
"ISDN_CMD_SETL2",
|
|
"ISDN_CMD_GETL2",
|
|
"ISDN_CMD_SETL3",
|
|
"ISDN_CMD_GETL3",
|
|
"ISDN_CMD_LOCK",
|
|
"ISDN_CMD_UNLOCK",
|
|
"ISDN_CMD_SUSPEND",
|
|
"ISDN_CMD_RESUME" };
|
|
|
|
/*
|
|
* Translates ISDN4Linux protocol codes to strings for debug messages
|
|
*/
|
|
static char *l3protos[] = { "ISDN_PROTO_L3_TRANS" };
|
|
static char *l2protos[] = { "ISDN_PROTO_L2_X75I",
|
|
"ISDN_PROTO_L2_X75UI",
|
|
"ISDN_PROTO_L2_X75BUI",
|
|
"ISDN_PROTO_L2_HDLC",
|
|
"ISDN_PROTO_L2_TRANS" };
|
|
#endif
|
|
|
|
int get_card_from_id(int driver)
|
|
{
|
|
int i;
|
|
|
|
for(i = 0 ; i < cinst ; i++) {
|
|
if(adapter[i]->driverId == driver)
|
|
return i;
|
|
}
|
|
return -NODEV;
|
|
}
|
|
|
|
/*
|
|
* command
|
|
*/
|
|
|
|
int command(isdn_ctrl *cmd)
|
|
{
|
|
int card;
|
|
|
|
card = get_card_from_id(cmd->driver);
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
pr_debug("%s: Received %s command from Link Layer\n",
|
|
adapter[card]->devicename, commands[cmd->command]);
|
|
|
|
/*
|
|
* Dispatch the command
|
|
*/
|
|
switch(cmd->command) {
|
|
case ISDN_CMD_IOCTL:
|
|
{
|
|
unsigned long cmdptr;
|
|
scs_ioctl ioc;
|
|
int err;
|
|
|
|
memcpy(&cmdptr, cmd->parm.num, sizeof(unsigned long));
|
|
if((err = copy_from_user(&ioc, (scs_ioctl *) cmdptr,
|
|
sizeof(scs_ioctl)))) {
|
|
pr_debug("%s: Failed to verify user space 0x%x\n",
|
|
adapter[card]->devicename, cmdptr);
|
|
return err;
|
|
}
|
|
return sc_ioctl(card, &ioc);
|
|
}
|
|
case ISDN_CMD_DIAL:
|
|
return dial(card, cmd->arg, cmd->parm.setup);
|
|
case ISDN_CMD_HANGUP:
|
|
return hangup(card, cmd->arg);
|
|
case ISDN_CMD_ACCEPTD:
|
|
return answer(card, cmd->arg);
|
|
case ISDN_CMD_ACCEPTB:
|
|
return acceptb(card, cmd->arg);
|
|
case ISDN_CMD_CLREAZ:
|
|
return clreaz(card, cmd->arg);
|
|
case ISDN_CMD_SETEAZ:
|
|
return seteaz(card, cmd->arg, cmd->parm.num);
|
|
case ISDN_CMD_GETEAZ:
|
|
return geteaz(card, cmd->arg, cmd->parm.num);
|
|
case ISDN_CMD_SETSIL:
|
|
return setsil(card, cmd->arg, cmd->parm.num);
|
|
case ISDN_CMD_GETSIL:
|
|
return getsil(card, cmd->arg, cmd->parm.num);
|
|
case ISDN_CMD_SETL2:
|
|
return setl2(card, cmd->arg);
|
|
case ISDN_CMD_GETL2:
|
|
return getl2(card, cmd->arg);
|
|
case ISDN_CMD_SETL3:
|
|
return setl3(card, cmd->arg);
|
|
case ISDN_CMD_GETL3:
|
|
return getl3(card, cmd->arg);
|
|
case ISDN_CMD_LOCK:
|
|
return lock();
|
|
case ISDN_CMD_UNLOCK:
|
|
return unlock();
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Confirm our ability to communicate with the board. This test assumes no
|
|
* other message activity is present
|
|
*/
|
|
int loopback(int card)
|
|
{
|
|
|
|
int status;
|
|
static char testmsg[] = "Test Message";
|
|
RspMessage rspmsg;
|
|
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
pr_debug("%s: Sending loopback message\n", adapter[card]->devicename);
|
|
|
|
|
|
/*
|
|
* Send the loopback message to confirm that memory transfer is
|
|
* operational
|
|
*/
|
|
status = send_and_receive(card, CMPID, cmReqType1,
|
|
cmReqClass0,
|
|
cmReqMsgLpbk,
|
|
0,
|
|
(unsigned char) strlen(testmsg),
|
|
(unsigned char *)testmsg,
|
|
&rspmsg, SAR_TIMEOUT);
|
|
|
|
|
|
if (!status) {
|
|
pr_debug("%s: Loopback message successfully sent\n",
|
|
adapter[card]->devicename);
|
|
if(strcmp(rspmsg.msg_data.byte_array, testmsg)) {
|
|
pr_debug("%s: Loopback return != sent\n",
|
|
adapter[card]->devicename);
|
|
return -EIO;
|
|
}
|
|
return 0;
|
|
}
|
|
else {
|
|
pr_debug("%s: Send loopback message failed\n",
|
|
adapter[card]->devicename);
|
|
return -EIO;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* start the onboard firmware
|
|
*/
|
|
int startproc(int card)
|
|
{
|
|
int status;
|
|
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
/*
|
|
* send start msg
|
|
*/
|
|
status = sendmessage(card, CMPID,cmReqType2,
|
|
cmReqClass0,
|
|
cmReqStartProc,
|
|
0,0,0);
|
|
pr_debug("%s: Sent startProc\n", adapter[card]->devicename);
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
int loadproc(int card, char *data)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* Dials the number passed in
|
|
*/
|
|
int dial(int card, unsigned long channel, setup_parm setup)
|
|
{
|
|
int status;
|
|
char Phone[48];
|
|
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
/*extract ISDN number to dial from eaz/msn string*/
|
|
strcpy(Phone,setup.phone);
|
|
|
|
/*send the connection message*/
|
|
status = sendmessage(card, CEPID,ceReqTypePhy,
|
|
ceReqClass1,
|
|
ceReqPhyConnect,
|
|
(unsigned char) channel+1,
|
|
strlen(Phone),
|
|
(unsigned int *) Phone);
|
|
|
|
pr_debug("%s: Dialing %s on channel %d\n",
|
|
adapter[card]->devicename, Phone, channel+1);
|
|
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
* Answer an incoming call
|
|
*/
|
|
int answer(int card, unsigned long channel)
|
|
{
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
if(setup_buffers(card, channel+1, BUFFER_SIZE)) {
|
|
hangup(card, channel+1);
|
|
return -ENOBUFS;
|
|
}
|
|
|
|
indicate_status(card, ISDN_STAT_BCONN,channel,NULL);
|
|
pr_debug("%s: Answered incoming call on channel %s\n",
|
|
adapter[card]->devicename, channel+1);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Hangup up the call on specified channel
|
|
*/
|
|
int hangup(int card, unsigned long channel)
|
|
{
|
|
int status;
|
|
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
status = sendmessage(card, CEPID, ceReqTypePhy,
|
|
ceReqClass1,
|
|
ceReqPhyDisconnect,
|
|
(unsigned char) channel+1,
|
|
0,
|
|
NULL);
|
|
pr_debug("%s: Sent HANGUP message to channel %d\n",
|
|
adapter[card]->devicename, channel+1);
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
* Set the layer 2 protocol (X.25, HDLC, Raw)
|
|
*/
|
|
int setl2(int card, unsigned long arg)
|
|
{
|
|
int status =0;
|
|
int protocol,channel;
|
|
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
protocol = arg >> 8;
|
|
channel = arg & 0xff;
|
|
adapter[card]->channel[channel].l2_proto = protocol;
|
|
pr_debug("%s: Level 2 protocol for channel %d set to %s from %d\n",
|
|
adapter[card]->devicename, channel+1,l2protos[adapter[card]->channel[channel].l2_proto],protocol);
|
|
|
|
/*
|
|
* check that the adapter is also set to the correct protocol
|
|
*/
|
|
pr_debug("%s: Sending GetFrameFormat for channel %d\n",
|
|
adapter[card]->devicename, channel+1);
|
|
status = sendmessage(card, CEPID, ceReqTypeCall,
|
|
ceReqClass0,
|
|
ceReqCallGetFrameFormat,
|
|
(unsigned char)channel+1,
|
|
1,
|
|
(unsigned int *) protocol);
|
|
if(status)
|
|
return status;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Get the layer 2 protocol
|
|
*/
|
|
int getl2(int card, unsigned long channel) {
|
|
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
pr_debug("%s: Level 2 protocol for channel %d reported as %s\n",
|
|
adapter[card]->devicename, channel+1,
|
|
l2protos[adapter[card]->channel[channel].l2_proto]);
|
|
|
|
return adapter[card]->channel[channel].l2_proto;
|
|
}
|
|
|
|
/*
|
|
* Set the layer 3 protocol
|
|
*/
|
|
int setl3(int card, unsigned long channel)
|
|
{
|
|
int protocol = channel >> 8;
|
|
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
adapter[card]->channel[channel].l3_proto = protocol;
|
|
pr_debug("%s: Level 3 protocol for channel %d set to %s\n",
|
|
adapter[card]->devicename, channel+1, l3protos[protocol]);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Get the layer 3 protocol
|
|
*/
|
|
int getl3(int card, unsigned long arg)
|
|
{
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
pr_debug("%s: Level 3 protocol for channel %d reported as %s\n",
|
|
adapter[card]->devicename, arg+1,
|
|
l3protos[adapter[card]->channel[arg].l3_proto]);
|
|
return adapter[card]->channel[arg].l3_proto;
|
|
}
|
|
|
|
|
|
int acceptb(int card, unsigned long channel)
|
|
{
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
if(setup_buffers(card, channel+1, BUFFER_SIZE))
|
|
{
|
|
hangup(card, channel+1);
|
|
return -ENOBUFS;
|
|
}
|
|
|
|
pr_debug("%s: B-Channel connection accepted on channel %d\n",
|
|
adapter[card]->devicename, channel+1);
|
|
indicate_status(card, ISDN_STAT_BCONN, channel, NULL);
|
|
return 0;
|
|
}
|
|
|
|
int clreaz(int card, unsigned long arg)
|
|
{
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
strcpy(adapter[card]->channel[arg].eazlist, "");
|
|
adapter[card]->channel[arg].eazclear = 1;
|
|
pr_debug("%s: EAZ List cleared for channel %d\n",
|
|
adapter[card]->devicename, arg+1);
|
|
return 0;
|
|
}
|
|
|
|
int seteaz(int card, unsigned long arg, char *num)
|
|
{
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
strcpy(adapter[card]->channel[arg].eazlist, num);
|
|
adapter[card]->channel[arg].eazclear = 0;
|
|
pr_debug("%s: EAZ list for channel %d set to: %s\n",
|
|
adapter[card]->devicename, arg+1,
|
|
adapter[card]->channel[arg].eazlist);
|
|
return 0;
|
|
}
|
|
|
|
int geteaz(int card, unsigned long arg, char *num)
|
|
{
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
strcpy(num, adapter[card]->channel[arg].eazlist);
|
|
pr_debug("%s: EAZ List for channel %d reported: %s\n",
|
|
adapter[card]->devicename, arg+1,
|
|
adapter[card]->channel[arg].eazlist);
|
|
return 0;
|
|
}
|
|
|
|
int setsil(int card, unsigned long arg, char *num)
|
|
{
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
strcpy(adapter[card]->channel[arg].sillist, num);
|
|
pr_debug("%s: Service Indicators for channel %d set: %s\n",
|
|
adapter[card]->devicename, arg+1,
|
|
adapter[card]->channel[arg].sillist);
|
|
return 0;
|
|
}
|
|
|
|
int getsil(int card, unsigned long arg, char *num)
|
|
{
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
strcpy(num, adapter[card]->channel[arg].sillist);
|
|
pr_debug("%s: SIL for channel %d reported: %s\n",
|
|
adapter[card]->devicename, arg+1,
|
|
adapter[card]->channel[arg].sillist);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int lock()
|
|
{
|
|
MOD_INC_USE_COUNT;
|
|
return 0;
|
|
}
|
|
|
|
int unlock()
|
|
{
|
|
MOD_DEC_USE_COUNT;
|
|
return 0;
|
|
}
|
|
|
|
int reset(int card)
|
|
{
|
|
unsigned long flags;
|
|
|
|
if(!IS_VALID_CARD(card)) {
|
|
pr_debug("Invalid param: %d is not a valid card id\n", card);
|
|
return -ENODEV;
|
|
}
|
|
|
|
indicate_status(card, ISDN_STAT_STOP, 0, NULL);
|
|
|
|
if(adapter[card]->EngineUp) {
|
|
del_timer(&adapter[card]->stat_timer);
|
|
}
|
|
|
|
adapter[card]->EngineUp = 0;
|
|
|
|
save_flags(flags);
|
|
cli();
|
|
init_timer(&adapter[card]->reset_timer);
|
|
adapter[card]->reset_timer.function = check_reset;
|
|
adapter[card]->reset_timer.data = card;
|
|
adapter[card]->reset_timer.expires = jiffies + CHECKRESET_TIME;
|
|
add_timer(&adapter[card]->reset_timer);
|
|
restore_flags(flags);
|
|
|
|
outb(0x1,adapter[card]->ioport[SFT_RESET]);
|
|
|
|
pr_debug("%s: Adapter Reset\n", adapter[card]->devicename);
|
|
return 0;
|
|
}
|
|
|
|
void flushreadfifo (int card)
|
|
{
|
|
while(inb(adapter[card]->ioport[FIFO_STATUS]) & RF_HAS_DATA)
|
|
inb(adapter[card]->ioport[FIFO_READ]);
|
|
}
|