Subversion Repositories or1k_old

/*

 *  $Id: command.c,v 1.1.1.1 2001-09-10 07:44:19 simons Exp $

 *  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]);

}