URL https://opencores.org/ocsvn/or1k_old/or1k_old/trunk
Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [uclinux/] [uClinux-2.0.x/] [drivers/] [isdn/] [pcbit/] [drv.c] - Blame information for rev 1765

Go to most recent revision | Details | Compare with Previous | View Log

/*
 * Copyright (C) 1996 Universidade de Lisboa
 *
 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
 *
 * This software may be used and distributed according to the terms of
 * the GNU Public License, incorporated herein by reference.
 */
 
/*
 *        PCBIT-D interface with isdn4linux
 */
 
/*
 *      Fixes:
 *
 *      Nuno Grilo      <l38486@alfa.ist.utl.pt>
 *      fixed msn_list NULL pointer dereference.
 *
 */
 
#define __NO_VERSION__
 
#include <linux/module.h>
 
#include <linux/sched.h>
 
#include <linux/kernel.h>
 
#include <linux/types.h>
#include <linux/malloc.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/string.h>
#include <linux/skbuff.h>
 
#include <linux/isdnif.h>
#include <asm/string.h>
#include <asm/io.h>
 
#include "pcbit.h"
#include "edss1.h"
#include "layer2.h"
#include "capi.h"
 
 
extern ushort last_ref_num;
 
static int pcbit_ioctl(isdn_ctrl* ctl);
 
static char* pcbit_devname[MAX_PCBIT_CARDS] = {
        "pcbit0",
        "pcbit1",
        "pcbit2",
        "pcbit3"
};
 
/*
 * prototypes
 */
 
int pcbit_command(isdn_ctrl* ctl);
int pcbit_stat(u_char* buf, int len, int user, int, int);
int pcbit_xmit(int driver, int chan, struct sk_buff *skb);
int pcbit_writecmd(const u_char*, int, int, int, int);
 
static int set_protocol_running(struct pcbit_dev * dev);
 
static void pcbit_clear_msn(struct pcbit_dev *dev);
static void pcbit_set_msn(struct pcbit_dev *dev, char *list);
static int pcbit_check_msn(struct pcbit_dev *dev, char *msn);
 
 
extern void pcbit_deliver(void * data);
 
int pcbit_init_dev(int board, int mem_base, int irq)
{
        struct pcbit_dev *dev;
        isdn_if *dev_if;
 
        if ((dev=kmalloc(sizeof(struct pcbit_dev), GFP_KERNEL)) == NULL)
        {
                printk("pcbit_init: couldn't malloc pcbit_dev struct\n");
                return -ENOMEM;
        }
 
        dev_pcbit[board] = dev;
        memset(dev, 0, sizeof(struct pcbit_dev));
 
        if (mem_base >= 0xA0000 && mem_base <= 0xFFFFF )
                dev->sh_mem = (unsigned char*) mem_base;
        else
        {
                printk("memory address invalid");
                kfree(dev);
                dev_pcbit[board] = NULL;
                return -EACCES;
        }
 
        dev->b1 = kmalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
        if (!dev->b1) {
                printk("pcbit_init: couldn't malloc pcbit_chan struct\n");
                kfree(dev);
                return -ENOMEM;
        }
 
        dev->b2 = kmalloc(sizeof(struct pcbit_chan), GFP_KERNEL);
        if (!dev->b2) {
                printk("pcbit_init: couldn't malloc pcbit_chan struct\n");
                kfree(dev->b1);
                kfree(dev);
                return -ENOMEM;
        }
 
        memset(dev->b1, 0, sizeof(struct pcbit_chan));
        memset(dev->b2, 0, sizeof(struct pcbit_chan));
        dev->b2->id = 1;
 
 
        dev->qdelivery.next = NULL;
        dev->qdelivery.sync = 0;
        dev->qdelivery.routine = pcbit_deliver;
        dev->qdelivery.data = dev;
 
        /*
         *  interrupts
         */
 
        if (request_irq(irq, &pcbit_irq_handler, 0, pcbit_devname[board], dev) != 0)
        {
                kfree(dev->b1);
                kfree(dev->b2);
                kfree(dev);
                dev_pcbit[board] = NULL;
                return -EIO;
        }
 
        dev->irq = irq;
 
        /* next frame to be received */
        dev->rcv_seq = 0;
        dev->send_seq = 0;
        dev->unack_seq = 0;
 
        dev->hl_hdrlen = 10;
 
        dev_if = kmalloc(sizeof(isdn_if), GFP_KERNEL);
 
        if (!dev_if) {
                free_irq(irq, dev);
                kfree(dev->b1);
                kfree(dev->b2);
                kfree(dev);
                dev_pcbit[board] = NULL;
                return -EIO;
        }
 
        dev->dev_if = dev_if;
 
        dev_if->channels = 2;
 
 
        dev_if->features = (ISDN_FEATURE_P_EURO  | ISDN_FEATURE_L3_TRANS |
                            ISDN_FEATURE_L2_HDLC | ISDN_FEATURE_L2_TRANS );
 
        dev_if->writebuf_skb = pcbit_xmit;
        dev_if->writebuf  = NULL;
        dev_if->hl_hdrlen = 10;
 
        dev_if->maxbufsize = MAXBUFSIZE;
        dev_if->command  = pcbit_command;
 
        dev_if->writecmd = pcbit_writecmd;
        dev_if->readstat = pcbit_stat;
 
 
        strcpy(dev_if->id, pcbit_devname[board]);
 
        if (!register_isdn(dev_if)) {
                free_irq(irq, dev);
                kfree(dev->b1);
                kfree(dev->b2);
                kfree(dev);
                dev_pcbit[board] = NULL;
                return -EIO;
        }
 
        dev->id = dev_if->channels;
 
 
        dev->l2_state = L2_DOWN;
        dev->free = 511;
 
        /*
         * set_protocol_running(dev);
         */
 
        return 0;
}
 
#ifdef MODULE
void pcbit_terminate(int board)
{
        struct pcbit_dev * dev;
 
        dev = dev_pcbit[board];
 
        if (dev) {
             /* unregister_isdn(dev->dev_if); */
                free_irq(dev->irq, dev);
                pcbit_clear_msn(dev);
                kfree(dev->dev_if);
                if (dev->b1->fsm_timer.function)
                        del_timer(&dev->b1->fsm_timer);
                if (dev->b2->fsm_timer.function)
                        del_timer(&dev->b2->fsm_timer);
                kfree(dev->b1);
                kfree(dev->b2);
                kfree(dev);
        }
}
#endif
 
int pcbit_command(isdn_ctrl* ctl)
{
        struct pcbit_dev  *dev;
        struct pcbit_chan *chan;
        struct callb_data info;
 
        dev = finddev(ctl->driver);
 
        if (!dev)
        {
                printk("pcbit_command: unknown device\n");
                return -1;
        }
 
        chan = (ctl->arg & 0x0F) ? dev->b2 : dev->b1;
 
 
        switch(ctl->command) {
        case ISDN_CMD_IOCTL:
                return pcbit_ioctl(ctl);
                break;
        case ISDN_CMD_DIAL:
                info.type = EV_USR_SETUP_REQ;
                info.data.setup.CalledPN = (char *) &ctl->parm.setup.phone;
                pcbit_fsm_event(dev, chan, EV_USR_SETUP_REQ, &info);
                break;
        case ISDN_CMD_ACCEPTD:
                pcbit_fsm_event(dev, chan, EV_USR_SETUP_RESP, NULL);
                break;
        case ISDN_CMD_ACCEPTB:
                printk("ISDN_CMD_ACCEPTB - not really needed\n");
                break;
        case ISDN_CMD_HANGUP:
                pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL);
                break;
        case ISDN_CMD_SETL2:
                chan->proto = (ctl->arg >> 8);
                break;
        case ISDN_CMD_GETL2:
                return chan->proto;
                break;
        case ISDN_CMD_LOCK:
                MOD_INC_USE_COUNT;
                break;
        case ISDN_CMD_UNLOCK:
                MOD_DEC_USE_COUNT;
                break;
        case ISDN_CMD_CLREAZ:
                pcbit_clear_msn(dev);
                break;
        case ISDN_CMD_SETEAZ:
                pcbit_set_msn(dev, ctl->parm.num);
                break;
        case ISDN_CMD_SETL3:
                if ((ctl->arg >> 8) != ISDN_PROTO_L3_TRANS)
                        printk(KERN_DEBUG "L3 protocol unknown\n");
                break;
        case ISDN_CMD_GETL3:
                return ISDN_PROTO_L3_TRANS;
                break;
        case ISDN_CMD_GETEAZ:
        case ISDN_CMD_SETSIL:
        case ISDN_CMD_GETSIL:
                printk(KERN_DEBUG "pcbit_command: code %d not implemented yet\n", ctl->command);
                break;
        default:
                printk(KERN_DEBUG "pcbit_command: unknown command\n");
                break;
        };
 
        return 0;
}
 
/*
 * Another Hack :-(
 * on some conditions the board stops sending TDATA_CONFs
 * let's see if we can turn around the problem
 */
 
#ifdef BLOCK_TIMER
static void pcbit_block_timer(unsigned long data)
{
        struct pcbit_chan *chan;
        struct pcbit_dev * dev;
        isdn_ctrl ictl;
 
        chan = (struct pcbit_chan *) data;
 
        dev = chan2dev(chan);
 
        if (dev == NULL) {
                printk(KERN_DEBUG "pcbit: chan2dev failed\n");
                return;
        }
 
        del_timer(&chan->block_timer);
        chan->block_timer.function = NULL;
 
#ifdef DEBUG
        printk(KERN_DEBUG "pcbit_block_timer\n");
#endif  
        chan->queued = 0;
        ictl.driver = dev->id;
        ictl.command = ISDN_STAT_BSENT;
        ictl.arg = chan->id;
        dev->dev_if->statcallb(&ictl);
}
#endif
 
int pcbit_xmit(int driver, int chnum, struct sk_buff *skb)
{
        ushort hdrlen;
        int refnum, len;
        struct pcbit_chan * chan;
        struct pcbit_dev *dev;
 
        dev = finddev(driver);
        if (dev == NULL)
        {
                printk("finddev returned NULL");
                return -1;
        }
 
        chan = chnum ? dev->b2 : dev->b1;
 
 
        if (chan->fsm_state != ST_ACTIVE)
                return -1;
 
        if (chan->queued >= MAX_QUEUED )
        {
#ifdef DEBUG_QUEUE
                printk(KERN_DEBUG
                       "pcbit: %d packets already in queue - write fails\n",
                       chan->queued);
#endif
                /*
                 * packet stays on the head of the device queue
                 * since dev_start_xmit will fail
                 * see net/core/dev.c
                 */
#ifdef BLOCK_TIMER
                if (chan->block_timer.function == NULL) {
                        init_timer(&chan->block_timer);
                        chan->block_timer.function =  &pcbit_block_timer;
                        chan->block_timer.data = (long) chan;
                        chan->block_timer.expires = jiffies + 1 * HZ;
                        add_timer(&chan->block_timer);
                }
#endif          
                return 0;
        }
 
 
        chan->queued++;
 
        len = skb->len;
 
        hdrlen = capi_tdata_req(chan, skb);
 
        refnum = last_ref_num++ & 0x7fffU;
        chan->s_refnum = refnum;
 
        pcbit_l2_write(dev, MSG_TDATA_REQ, refnum, skb, hdrlen);
 
        return len;
}
 
 
int pcbit_writecmd(const u_char* buf, int len, int user, int driver, int channel)
{
        struct pcbit_dev * dev;
        int i, j;
        const u_char * loadbuf;
        u_char * ptr = NULL;
 
        int errstat;
 
        dev = finddev(driver);
 
        if (!dev)
        {
                printk("pcbit_writecmd: couldn't find device");
                return -ENODEV;
        }
 
        switch(dev->l2_state) {
        case L2_LWMODE:
                /* check (size <= rdp_size); write buf into board */
                if (len > BANK4 + 1)
                {
                        printk("pcbit_writecmd: invalid length %d\n", len);
                        return -EFAULT;
                }
 
                if (user)
                {
                        u_char cbuf[1024];
 
                        copy_from_user(cbuf, buf, len);
                        for (i=0; i<len; i++)
                                writeb(cbuf[i], dev->sh_mem + i);
                }
                else
                        memcpy_toio(dev->sh_mem, buf, len);
                return len;
                break;
        case L2_FWMODE:
                /* this is the hard part */
                /* dumb board */
                if (len < 0)
                        return -EINVAL;
 
                if (user) {
                        /* get it into kernel space */
                        if ((ptr = kmalloc(len, GFP_KERNEL))==NULL)
                                return -ENOMEM;
                        copy_from_user(ptr, buf, len);
                        loadbuf = ptr;
                }
                else
                        loadbuf = buf;
 
                errstat = 0;
 
                for (i=0; i < len; i++)
                {
                        for(j=0; j < LOAD_RETRY; j++)
                                if (!(readb(dev->sh_mem + dev->loadptr)))
                                        break;
 
                        if (j == LOAD_RETRY)
                        {
                                errstat = -ETIME;
                                printk("TIMEOUT i=%d\n", i);
                                break;
                        }
                        writeb(loadbuf[i], dev->sh_mem + dev->loadptr + 1);
                        writeb(0x01, dev->sh_mem + dev->loadptr);
 
                        dev->loadptr += 2;
                        if (dev->loadptr > LOAD_ZONE_END)
                                dev->loadptr = LOAD_ZONE_START;
                }
 
                if (user)
                        kfree(ptr);
 
                return errstat ? errstat : len;
 
                break;
        default:
                return -EBUSY;
        }
        return 0;
}
 
/*
 *  demultiplexing of messages
 *
 */
 
void pcbit_l3_receive(struct pcbit_dev * dev, ulong msg,
                             struct sk_buff * skb,
                             ushort hdr_len, ushort refnum)
{
        struct pcbit_chan *chan;
        struct sk_buff *skb2;
        unsigned short len;
        struct callb_data cbdata;
        int complete, err;
        isdn_ctrl ictl;
#ifdef DEBUG
        struct msg_fmt * fmsg;
#endif
 
        switch(msg) {
 
        case MSG_TDATA_IND:
                if (!(chan = capi_channel(dev, skb))) {
                        printk(KERN_WARNING
                               "CAPI header: unknown channel id\n");
                        break;
                }
                chan->r_refnum = skb->data[7];
                skb_pull(skb, 8);
 
                dev->dev_if->rcvcallb_skb(dev->id, chan->id, skb);
 
                if (capi_tdata_resp(chan, &skb2) > 0)
                        pcbit_l2_write(dev, MSG_TDATA_RESP, refnum,
                                       skb2, skb2->len);
                return;
                break;
        case MSG_TDATA_CONF:
                if (!(chan = capi_channel(dev, skb))) {
                        printk(KERN_WARNING
                               "CAPI header: unknown channel id\n");
                        break;
                }
 
#ifdef DEBUG
                if ( (*((ushort *) (skb->data + 2) )) != 0) {
                        printk(KERN_DEBUG "TDATA_CONF error\n");
                }
#endif
#ifdef BLOCK_TIMER
                if (chan->queued == MAX_QUEUED) {
                        del_timer(&chan->block_timer);
                        chan->block_timer.function = NULL;
                }
 
#endif          
                chan->queued--;
 
                ictl.driver = dev->id;
                ictl.command = ISDN_STAT_BSENT;
                ictl.arg = chan->id;
                dev->dev_if->statcallb(&ictl);
                break;
 
        case MSG_CONN_IND:
                /*
                 *  channel: 1st not used will do
                 *           if both are used we're in trouble
                 */
 
                if (!dev->b1->fsm_state)
                        chan = dev->b1;
                else if (!dev->b2->fsm_state)
                        chan = dev->b2;
                else {
                        printk(KERN_INFO
                               "Incoming connection: no channels available");
 
                        if ((len = capi_disc_req(*(ushort*)(skb->data), &skb2, CAUSE_NOCHAN)) > 0)
                                pcbit_l2_write(dev, MSG_DISC_REQ, refnum, skb2, len);
                        break;
                }
 
                cbdata.data.setup.CalledPN = NULL;
                cbdata.data.setup.CallingPN = NULL;
 
                capi_decode_conn_ind(chan, skb, &cbdata);
                cbdata.type = EV_NET_SETUP;
 
                pcbit_fsm_event(dev, chan, EV_NET_SETUP, NULL);
 
                if (pcbit_check_msn(dev, cbdata.data.setup.CallingPN))
                        pcbit_fsm_event(dev, chan, EV_USR_PROCED_REQ, &cbdata);
                else
                        pcbit_fsm_event(dev, chan, EV_USR_RELEASE_REQ, NULL);
 
                if (cbdata.data.setup.CalledPN)
                        kfree(cbdata.data.setup.CalledPN);
                if (cbdata.data.setup.CallingPN)
                        kfree(cbdata.data.setup.CallingPN);
                break;
 
        case MSG_CONN_CONF:
                /*
                 * We should be able to find the channel by the message
                 * reference number. The current version of the firmware
                 * doesn't sent the ref number correctly.
                 */
#ifdef DEBUG
                printk(KERN_DEBUG "refnum=%04x b1=%04x b2=%04x\n", refnum,
                       dev->b1->s_refnum,
                       dev->b2->s_refnum);
#endif
#if 0   
                if (dev->b1->s_refnum == refnum)
                        chan = dev->b1;
                else {
 
                        if (dev->b2->s_refnum == refnum)
                                chan = dev->b2;
                        else {
                                chan = NULL;
                                printk(KERN_WARNING "Connection Confirm - refnum doesn't match chan\n");
                                break;
                        }
                }
#else
                /* We just try to find a channel in the right state */
 
                if (dev->b1->fsm_state == ST_CALL_INIT)
                        chan = dev->b1;
                else {
                        if (dev->b2->s_refnum == ST_CALL_INIT)
                                chan = dev->b2;
                        else {
                                chan = NULL;
                                printk(KERN_WARNING "Connection Confirm - no channel in Call Init state\n");
                                break;
                        }
                }
#endif
                if (capi_decode_conn_conf(chan, skb, &complete)) {
                        printk(KERN_DEBUG "conn_conf indicates error\n");
                        pcbit_fsm_event(dev, chan, EV_ERROR, NULL);
                }
                else
                        if (complete)
                                pcbit_fsm_event(dev, chan, EV_NET_CALL_PROC, NULL);
                        else
                                pcbit_fsm_event(dev, chan, EV_NET_SETUP_ACK, NULL);
                break;
        case MSG_CONN_ACTV_IND:
 
                if (!(chan = capi_channel(dev, skb))) {
                        printk(KERN_WARNING
                               "CAPI header: unknown channel id\n");
                        break;
                }
 
                if (capi_decode_conn_actv_ind(chan, skb)) {
                        printk("error in capi_decode_conn_actv_ind\n");
                     /* pcbit_fsm_event(dev, chan, EV_ERROR, NULL); */
                        break;
                }
                chan->r_refnum = refnum;
                pcbit_fsm_event(dev, chan, EV_NET_CONN, NULL);
                break;
        case MSG_CONN_ACTV_CONF:
 
                if (!(chan = capi_channel(dev, skb))) {
                        printk(KERN_WARNING
                               "CAPI header: unknown channel id\n");
                        break;
                }
 
                if (capi_decode_conn_actv_conf(chan, skb) == 0)
                        pcbit_fsm_event(dev, chan, EV_NET_CONN_ACK, NULL);
 
                else
                        printk(KERN_DEBUG "decode_conn_actv_conf failed\n");
                break;
 
        case  MSG_SELP_CONF:
 
                if (!(chan = capi_channel(dev, skb))) {
                        printk(KERN_WARNING
                               "CAPI header: unknown channel id\n");
                        break;
                }
 
                if (!(err = capi_decode_sel_proto_conf(chan, skb)))
                        pcbit_fsm_event(dev, chan, EV_NET_SELP_RESP, NULL);
                else {
                        /* Error */
                        printk("error %d - capi_decode_sel_proto_conf\n", err);
                }
                break;
        case MSG_ACT_TRANSP_CONF:
                if (!(chan = capi_channel(dev, skb))) {
                        printk(KERN_WARNING
                               "CAPI header: unknown channel id\n");
                        break;
                }
 
                if (!capi_decode_actv_trans_conf(chan, skb))
                        pcbit_fsm_event(dev, chan, EV_NET_ACTV_RESP, NULL);
                break;
 
        case MSG_DISC_IND:
 
                if (!(chan = capi_channel(dev, skb))) {
                        printk(KERN_WARNING
                               "CAPI header: unknown channel id\n");
                        break;
                }
 
                if (!capi_decode_disc_ind(chan, skb))
                        pcbit_fsm_event(dev, chan, EV_NET_DISC, NULL);
                else
                        printk(KERN_WARNING "capi_decode_disc_ind - error\n");
                break;
        case MSG_DISC_CONF:
                if (!(chan = capi_channel(dev, skb))) {
                        printk(KERN_WARNING
                               "CAPI header: unknown channel id\n");
                        break;
                }
 
                if (!capi_decode_disc_ind(chan, skb))
                        pcbit_fsm_event(dev, chan, EV_NET_RELEASE, NULL);
                else
                        printk(KERN_WARNING "capi_decode_disc_conf - error\n");
                break;
        case MSG_INFO_IND:
#ifdef DEBUG
                printk(KERN_DEBUG "received Info Indication - discarded\n");
#endif
                break;
#ifdef DEBUG
        case MSG_DEBUG_188:
                capi_decode_debug_188(skb->data, skb->len);
                break;
 
        default:
                printk(KERN_DEBUG "pcbit_l3_receive: unknown message %08lx\n",
                       msg);
                fmsg = (struct msg_fmt *) &msg;
                printk(KERN_DEBUG "cmd=%02x sub=%02x\n",
                       fmsg->cmd, fmsg->scmd);
                break;
#endif
        }
 
        SET_SKB_FREE(skb);
 
        kfree_skb(skb, FREE_READ);
 
}
 
/*
 *   Single statbuf
 *   should be a statbuf per device
 */
 
static char statbuf[STATBUF_LEN];
static int stat_st = 0;
static int stat_end = 0;
 
 
static __inline void
memcpy_to_COND(int flag, char *d, const char *s, int len) {
        if (flag)
                copy_to_user(d, s, len);
        else
                memcpy(d, s, len);
}
 
 
int pcbit_stat(u_char* buf, int len, int user, int driver, int channel)
{
        int stat_count;
        stat_count = stat_end - stat_st;
 
        if (stat_count < 0)
                stat_count = STATBUF_LEN - stat_st + stat_end;
 
        /* FIXME: should we sleep and wait for more cookies ? */
        if (len > stat_count)
                len = stat_count;
 
        if (stat_st < stat_end)
        {
                memcpy_to_COND(user, buf, statbuf + stat_st, len);
                stat_st += len;
        }
        else
        {
                if (len > STATBUF_LEN - stat_st)
                {
                        memcpy_to_COND(user, buf, statbuf + stat_st,
                                       STATBUF_LEN - stat_st);
                        memcpy_to_COND(user, buf, statbuf,
                                       len - (STATBUF_LEN - stat_st));
 
                        stat_st = len - (STATBUF_LEN - stat_st);
                }
                else
                {
                        memcpy_to_COND(user, buf, statbuf + stat_st,
                                       len);
 
                        stat_st += len;
 
                        if (stat_st == STATBUF_LEN)
                                stat_st = 0;
                }
        }
 
        if (stat_st == stat_end)
                stat_st = stat_end = 0;
 
        return len;
}
 
static void pcbit_logstat(struct pcbit_dev *dev, char *str)
{
        int i;
        isdn_ctrl ictl;
 
        for (i=stat_end; i<strlen(str); i++)
        {
                statbuf[i]=str[i];
                stat_end = (stat_end + 1) % STATBUF_LEN;
                if (stat_end == stat_st)
                        stat_st = (stat_st + 1) % STATBUF_LEN;
        }
 
        ictl.command=ISDN_STAT_STAVAIL;
        ictl.driver=dev->id;
        ictl.arg=strlen(str);
        dev->dev_if->statcallb(&ictl);
}
 
extern char * isdn_state_table[];
extern char * strisdnevent(unsigned short);
 
 
void pcbit_state_change(struct pcbit_dev * dev, struct pcbit_chan * chan,
                        unsigned short i, unsigned short ev, unsigned short f)
{
        char buf[256];
 
        sprintf(buf, "change on device: %d channel:%d\n%s -> %s -> %s\n",
                dev->id, chan->id,
                isdn_state_table[i], strisdnevent(ev), isdn_state_table[f]
                );
 
#ifdef DEBUG
        printk("%s", buf);
#endif
 
        pcbit_logstat(dev, buf);
}
 
static void set_running_timeout(unsigned long ptr)
{
        struct pcbit_dev * dev;
 
#ifdef DEBUG
        printk(KERN_DEBUG "set_running_timeout\n");
#endif
        dev = (struct pcbit_dev *) ptr;
 
        wake_up_interruptible(&dev->set_running_wq);
}
 
static int set_protocol_running(struct pcbit_dev * dev)
{
        isdn_ctrl ctl;
 
        init_timer(&dev->set_running_timer);
 
        dev->set_running_timer.function = &set_running_timeout;
        dev->set_running_timer.data = (ulong) dev;
        dev->set_running_timer.expires = jiffies + SET_RUN_TIMEOUT;
 
        /* kick it */
 
        dev->l2_state = L2_STARTING;
 
        writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)),
               dev->sh_mem + BANK4);
 
        add_timer(&dev->set_running_timer);
 
        interruptible_sleep_on(&dev->set_running_wq);
 
        del_timer(&dev->set_running_timer);
 
        if (dev->l2_state == L2_RUNNING)
        {
                printk(KERN_DEBUG "pcbit: running\n");
 
                dev->unack_seq = dev->send_seq;
 
                dev->writeptr = dev->sh_mem;
                dev->readptr = dev->sh_mem + BANK2;
 
                /* tell the good news to the upper layer */
                ctl.driver = dev->id;
                ctl.command = ISDN_STAT_RUN;
 
                dev->dev_if->statcallb(&ctl);
        }
        else
        {
                printk(KERN_DEBUG "pcbit: initialization failed\n");
                printk(KERN_DEBUG "pcbit: firmware not loaded\n");
 
                dev->l2_state = L2_DOWN;
 
#ifdef DEBUG
                printk(KERN_DEBUG "Bank3 = %02x\n",
                       readb(dev->sh_mem + BANK3));
#endif
                *(dev->sh_mem + BANK4) = 0x40U;
 
                /* warn the upper layer */
                ctl.driver = dev->id;
                ctl.command = ISDN_STAT_STOP;
 
                dev->dev_if->statcallb(&ctl);
 
                return -EL2HLT; /* Level 2 halted */
        }
 
        return 0;
}
 
static int pcbit_ioctl(isdn_ctrl* ctl)
{
        struct pcbit_dev * dev;
        struct pcbit_ioctl *cmd;
 
        dev = finddev(ctl->driver);
 
        if (!dev)
        {
                printk(KERN_DEBUG "pcbit_ioctl: unknown device\n");
                return -ENODEV;
        }
 
        cmd = (struct pcbit_ioctl *) ctl->parm.num;
 
        switch(ctl->arg) {
        case PCBIT_IOCTL_GETSTAT:
                cmd->info.l2_status = dev->l2_state;
                break;
 
        case PCBIT_IOCTL_STRLOAD:
                if (dev->l2_state == L2_RUNNING)
                        return -EBUSY;
 
                dev->unack_seq = dev->send_seq = dev->rcv_seq = 0;
 
                dev->writeptr = dev->sh_mem;
                dev->readptr = dev->sh_mem + BANK2;
 
                dev->l2_state = L2_LOADING;
                break;
 
        case PCBIT_IOCTL_LWMODE:
                if (dev->l2_state != L2_LOADING)
                        return -EINVAL;
 
                dev->l2_state = L2_LWMODE;
                break;
 
        case PCBIT_IOCTL_FWMODE:
                if (dev->l2_state == L2_RUNNING)
                        return -EBUSY;
                dev->loadptr = LOAD_ZONE_START;
                dev->l2_state = L2_FWMODE;
 
                break;
        case PCBIT_IOCTL_ENDLOAD:
                if (dev->l2_state == L2_RUNNING)
                        return -EBUSY;
                dev->l2_state = L2_DOWN;
                break;
 
        case PCBIT_IOCTL_SETBYTE:
                if (dev->l2_state == L2_RUNNING)
                        return -EBUSY;
 
                /* check addr */
                if (cmd->info.rdp_byte.addr > BANK4)
                        return -EFAULT;
 
                writeb(cmd->info.rdp_byte.value, dev->sh_mem + cmd->info.rdp_byte.addr);
                break;
        case PCBIT_IOCTL_GETBYTE:
                if (dev->l2_state == L2_RUNNING)
                        return -EBUSY;
 
                /* check addr */
 
                if (cmd->info.rdp_byte.addr > BANK4)
                {
                        printk("getbyte: invalid addr %04x\n", cmd->info.rdp_byte.addr);
                        return -EFAULT;
                }
 
                cmd->info.rdp_byte.value = readb(dev->sh_mem + cmd->info.rdp_byte.addr);
                break;
        case PCBIT_IOCTL_RUNNING:
                if (dev->l2_state == L2_RUNNING)
                        return -EBUSY;
                return set_protocol_running(dev);
                break;
        case PCBIT_IOCTL_WATCH188:
                if (dev->l2_state != L2_LOADING)
                        return -EINVAL;
                pcbit_l2_write(dev, MSG_WATCH188, 0x0001, NULL, 0);
                break;
        case PCBIT_IOCTL_PING188:
                if (dev->l2_state != L2_LOADING)
                        return -EINVAL;
                pcbit_l2_write(dev, MSG_PING188_REQ, 0x0001, NULL, 0);
                break;
        case PCBIT_IOCTL_APION:
                if (dev->l2_state != L2_LOADING)
                        return -EINVAL;
                pcbit_l2_write(dev, MSG_API_ON, 0x0001, NULL, 0);
                break;
        case PCBIT_IOCTL_STOP:
                dev->l2_state = L2_DOWN;
                writeb(0x40, dev->sh_mem + BANK4);
                dev->rcv_seq = 0;
                dev->send_seq = 0;
                dev->unack_seq = 0;
                break;
        default:
                printk("error: unknown ioctl\n");
                break;
        };
        return 0;
}
 
/*
 *        MSN list handling
 *
 *        if null reject all calls
 *        if first entry has null MSN accept all calls
 */
 
static void pcbit_clear_msn(struct pcbit_dev *dev)
{
        struct msn_entry *ptr, *back;
 
        for (ptr=dev->msn_list; ptr; )
        {
                back = ptr->next;
                kfree(ptr);
                ptr = back;
        }
 
        dev->msn_list = NULL;
}
 
static void pcbit_set_msn(struct pcbit_dev *dev, char *list)
{
        struct msn_entry *ptr;
        struct msn_entry *back = NULL;
        char *cp, *sp;
        int len;
 
        if (strlen(list) == 0) {
                ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
                if (!ptr) {
                        printk(KERN_WARNING "kmalloc failed\n");
                        return;
                }
 
                ptr->msn = NULL;
 
                ptr->next = dev->msn_list;
                dev->msn_list = ptr;
 
                return;
        }
 
        if (dev->msn_list)
                for (back=dev->msn_list; back->next; back=back->next);
 
        sp = list;
 
        do {
                cp=strchr(sp, ',');
                if (cp)
                        len = cp - sp;
                else
                        len = strlen(sp);
 
                ptr = kmalloc(sizeof(struct msn_entry), GFP_ATOMIC);
 
                if (!ptr) {
                        printk(KERN_WARNING "kmalloc failed\n");
                        return;
                }
                ptr->next = NULL;
 
                ptr->msn = kmalloc(len, GFP_ATOMIC);
                if (!ptr->msn) {
                        printk(KERN_WARNING "kmalloc failed\n");
                        return;
                }
 
                memcpy(ptr->msn, sp, len - 1);
                ptr->msn[len] = 0;
 
#ifdef DEBUG
                printk(KERN_DEBUG "msn: %s\n", ptr->msn);
#endif
                if (dev->msn_list == NULL)
                        dev->msn_list = ptr;
                else
                        back->next = ptr;
                back = ptr;
                sp += len;
        } while(cp);
}
 
/*
 *  check if we do signal or reject an incoming call
 */
static int pcbit_check_msn(struct pcbit_dev *dev, char *msn)
{
        struct msn_entry *ptr;
 
        for (ptr=dev->msn_list; ptr; ptr=ptr->next) {
 
                if (ptr->msn == NULL)
                        return 1;
 
                if (strcmp(ptr->msn, msn) == 0)
                        return 1;
        }
 
        return 0;
}
Browse

Tools

Subversion Repositories or1k_old

[/] [or1k_old/] [trunk/] [uclinux/] [uClinux-2.0.x/] [drivers/] [isdn/] [pcbit/] [drv.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	199	simons	`/*`
2			`* Copyright (C) 1996 Universidade de Lisboa`
3			`*`
4			`* Written by Pedro Roque Marques (roque@di.fc.ul.pt)`
5			`*`
6			`* This software may be used and distributed according to the terms of`
7			`* the GNU Public License, incorporated herein by reference.`
8			`*/`
9
10			`/*`
11			`* PCBIT-D interface with isdn4linux`
12			`*/`
13
14			`/*`
15			`* Fixes:`
16			`*`
17			`* Nuno Grilo <l38486@alfa.ist.utl.pt>`
18			`* fixed msn_list NULL pointer dereference.`
19			`*`
20			`*/`
21
22			`#define __NO_VERSION__`
23
24			`#include <linux/module.h>`
25
26			`#include <linux/sched.h>`
27
28			`#include <linux/kernel.h>`
29
30			`#include <linux/types.h>`
31			`#include <linux/malloc.h>`
32			`#include <linux/mm.h>`
33			`#include <linux/interrupt.h>`
34			`#include <linux/string.h>`
35			`#include <linux/skbuff.h>`
36
37			`#include <linux/isdnif.h>`
38			`#include <asm/string.h>`
39			`#include <asm/io.h>`
40