LXR linux/drivers/isdn/hysdn/hysdn

   1/* $Id: hysdn_sched.c,v 1.5.6.4 2001/11/06 21:58:19 kai Exp $
   2 *
   3 * Linux driver for HYSDN cards
   4 * scheduler routines for handling exchange card <-> pc.
   5 *
   6 * Author    Werner Cornelius (werner@titro.de) for Hypercope GmbH
   7 * Copyright 1999 by Werner Cornelius (werner@titro.de)
   8 *
   9 * This software may be used and distributed according to the terms
  10 * of the GNU General Public License, incorporated herein by reference.
  11 *
  12 */
  13
  14#include <linux/signal.h>
  15#include <linux/kernel.h>
  16#include <linux/ioport.h>
  17#include <linux/interrupt.h>
  18#include <linux/delay.h>
  19#include <asm/io.h>
  20
  21#include "hysdn_defs.h"
  22
  23/*****************************************************************************/
  24/* hysdn_sched_rx is called from the cards handler to announce new data is   */
  25/* available from the card. The routine has to handle the data and return    */
  26/* with a nonzero code if the data could be worked (or even thrown away), if */
  27/* no room to buffer the data is available a zero return tells the card      */
  28/* to keep the data until later.                                             */
  29/*****************************************************************************/
  30int
  31hysdn_sched_rx(hysdn_card *card, unsigned char *buf, unsigned short len,
  32               unsigned short chan)
  33{
  34
  35        switch (chan) {
  36        case CHAN_NDIS_DATA:
  37                if (hynet_enable & (1 << card->myid)) {
  38                        /* give packet to network handler */
  39                        hysdn_rx_netpkt(card, buf, len);
  40                }
  41                break;
  42
  43        case CHAN_ERRLOG:
  44                hysdn_card_errlog(card, (tErrLogEntry *) buf, len);
  45                if (card->err_log_state == ERRLOG_STATE_ON)
  46                        card->err_log_state = ERRLOG_STATE_START;       /* start new fetch */
  47                break;
  48#ifdef CONFIG_HYSDN_CAPI
  49        case CHAN_CAPI:
  50/* give packet to CAPI handler */
  51                if (hycapi_enable & (1 << card->myid)) {
  52                        hycapi_rx_capipkt(card, buf, len);
  53                }
  54                break;
  55#endif /* CONFIG_HYSDN_CAPI */
  56        default:
  57                printk(KERN_INFO "irq message channel %d len %d unhandled \n", chan, len);
  58                break;
  59
  60        }                       /* switch rx channel */
  61
  62        return (1);             /* always handled */
  63}                               /* hysdn_sched_rx */
  64
  65/*****************************************************************************/
  66/* hysdn_sched_tx is called from the cards handler to announce that there is */
  67/* room in the tx-buffer to the card and data may be sent if needed.         */
  68/* If the routine wants to send data it must fill buf, len and chan with the */
  69/* appropriate data and return a nonzero value. With a zero return no new    */
  70/* data to send is assumed. maxlen specifies the buffer size available for   */
  71/* sending.                                                                  */
  72/*****************************************************************************/
  73int
  74hysdn_sched_tx(hysdn_card *card, unsigned char *buf,
  75               unsigned short volatile *len, unsigned short volatile *chan,
  76               unsigned short maxlen)
  77{
  78        struct sk_buff *skb;
  79
  80        if (card->net_tx_busy) {
  81                card->net_tx_busy = 0;  /* reset flag */
  82                hysdn_tx_netack(card);  /* acknowledge packet send */
  83        }                       /* a network packet has completely been transferred */
  84        /* first of all async requests are handled */
  85        if (card->async_busy) {
  86                if (card->async_len <= maxlen) {
  87                        memcpy(buf, card->async_data, card->async_len);
  88                        *len = card->async_len;
  89                        *chan = card->async_channel;
  90                        card->async_busy = 0;   /* reset request */
  91                        return (1);
  92                }
  93                card->async_busy = 0;   /* in case of length error */
  94        }                       /* async request */
  95        if ((card->err_log_state == ERRLOG_STATE_START) &&
  96            (maxlen >= ERRLOG_CMD_REQ_SIZE)) {
  97                strcpy(buf, ERRLOG_CMD_REQ);    /* copy the command */
  98                *len = ERRLOG_CMD_REQ_SIZE;     /* buffer length */
  99                *chan = CHAN_ERRLOG;    /* and channel */
 100                card->err_log_state = ERRLOG_STATE_ON;  /* new state is on */
 101                return (1);     /* tell that data should be send */
 102        }                       /* error log start and able to send */
 103        if ((card->err_log_state == ERRLOG_STATE_STOP) &&
 104            (maxlen >= ERRLOG_CMD_STOP_SIZE)) {
 105                strcpy(buf, ERRLOG_CMD_STOP);   /* copy the command */
 106                *len = ERRLOG_CMD_STOP_SIZE;    /* buffer length */
 107                *chan = CHAN_ERRLOG;    /* and channel */
 108                card->err_log_state = ERRLOG_STATE_OFF;         /* new state is off */
 109                return (1);     /* tell that data should be send */
 110        }                       /* error log start and able to send */
 111        /* now handle network interface packets */
 112        if ((hynet_enable & (1 << card->myid)) &&
 113            (skb = hysdn_tx_netget(card)) != NULL)
 114        {
 115                if (skb->len <= maxlen) {
 116                        /* copy the packet to the buffer */
 117                        skb_copy_from_linear_data(skb, buf, skb->len);
 118                        *len = skb->len;
 119                        *chan = CHAN_NDIS_DATA;
 120                        card->net_tx_busy = 1;  /* we are busy sending network data */
 121                        return (1);     /* go and send the data */
 122                } else
 123                        hysdn_tx_netack(card);  /* aknowledge packet -> throw away */
 124        }                       /* send a network packet if available */
 125#ifdef CONFIG_HYSDN_CAPI
 126        if (((hycapi_enable & (1 << card->myid))) &&
 127            ((skb = hycapi_tx_capiget(card)) != NULL))
 128        {
 129                if (skb->len <= maxlen) {
 130                        skb_copy_from_linear_data(skb, buf, skb->len);
 131                        *len = skb->len;
 132                        *chan = CHAN_CAPI;
 133                        hycapi_tx_capiack(card);
 134                        return (1);     /* go and send the data */
 135                }
 136        }
 137#endif /* CONFIG_HYSDN_CAPI */
 138        return (0);             /* nothing to send */
 139}                               /* hysdn_sched_tx */
 140
 141
 142/*****************************************************************************/
 143/* send one config line to the card and return 0 if successful, otherwise a */
 144/* negative error code.                                                      */
 145/* The function works with timeouts perhaps not giving the greatest speed    */
 146/* sending the line, but this should be meaningless because only some lines  */
 147/* are to be sent and this happens very seldom.                              */
 148/*****************************************************************************/
 149int
 150hysdn_tx_cfgline(hysdn_card *card, unsigned char *line, unsigned short chan)
 151{
 152        int cnt = 50;           /* timeout intervalls */
 153        unsigned long flags;
 154
 155        if (card->debug_flags & LOG_SCHED_ASYN)
 156                hysdn_addlog(card, "async tx-cfg chan=%d len=%d", chan, strlen(line) + 1);
 157
 158        while (card->async_busy) {
 159
 160                if (card->debug_flags & LOG_SCHED_ASYN)
 161                        hysdn_addlog(card, "async tx-cfg delayed");
 162
 163                msleep_interruptible(20);               /* Timeout 20ms */
 164                if (!--cnt)
 165                        return (-ERR_ASYNC_TIME);       /* timed out */
 166        }                       /* wait for buffer to become free */
 167
 168        spin_lock_irqsave(&card->hysdn_lock, flags);
 169        strcpy(card->async_data, line);
 170        card->async_len = strlen(line) + 1;
 171        card->async_channel = chan;
 172        card->async_busy = 1;   /* request transfer */
 173
 174        /* now queue the task */
 175        schedule_work(&card->irq_queue);
 176        spin_unlock_irqrestore(&card->hysdn_lock, flags);
 177
 178        if (card->debug_flags & LOG_SCHED_ASYN)
 179                hysdn_addlog(card, "async tx-cfg data queued");
 180
 181        cnt++;                  /* short delay */
 182
 183        while (card->async_busy) {
 184
 185                if (card->debug_flags & LOG_SCHED_ASYN)
 186                        hysdn_addlog(card, "async tx-cfg waiting for tx-ready");
 187
 188                msleep_interruptible(20);               /* Timeout 20ms */
 189                if (!--cnt)
 190                        return (-ERR_ASYNC_TIME);       /* timed out */
 191        }                       /* wait for buffer to become free again */
 192
 193        if (card->debug_flags & LOG_SCHED_ASYN)
 194                hysdn_addlog(card, "async tx-cfg data send");
 195
 196        return (0);             /* line send correctly */
 197}                               /* hysdn_tx_cfgline */
 198