1 /* $Id: hysdn_sched.c,v 1.5.6.4 2001/11/06 21:58:19 kai Exp $
3 * Linux driver for HYSDN cards
4 * scheduler routines for handling exchange card <-> pc.
6 * Author Werner Cornelius (werner@titro.de) for Hypercope GmbH
7 * Copyright 1999 by Werner Cornelius (werner@titro.de)
9 * This software may be used and distributed according to the terms
10 * of the GNU General Public License, incorporated herein by reference.
14 #include <linux/sched.h>
15 #include <linux/signal.h>
16 #include <linux/kernel.h>
17 #include <linux/ioport.h>
18 #include <linux/interrupt.h>
19 #include <linux/delay.h>
22 #include "hysdn_defs.h"
24 /*****************************************************************************/
25 /* hysdn_sched_rx is called from the cards handler to announce new data is */
26 /* available from the card. The routine has to handle the data and return */
27 /* with a nonzero code if the data could be worked (or even thrown away), if */
28 /* no room to buffer the data is available a zero return tells the card */
29 /* to keep the data until later. */
30 /*****************************************************************************/
32 hysdn_sched_rx(hysdn_card
*card
, unsigned char *buf
, unsigned short len
,
38 if (hynet_enable
& (1 << card
->myid
)) {
39 /* give packet to network handler */
40 hysdn_rx_netpkt(card
, buf
, len
);
45 hysdn_card_errlog(card
, (tErrLogEntry
*) buf
, len
);
46 if (card
->err_log_state
== ERRLOG_STATE_ON
)
47 card
->err_log_state
= ERRLOG_STATE_START
; /* start new fetch */
49 #ifdef CONFIG_HYSDN_CAPI
51 /* give packet to CAPI handler */
52 if (hycapi_enable
& (1 << card
->myid
)) {
53 hycapi_rx_capipkt(card
, buf
, len
);
56 #endif /* CONFIG_HYSDN_CAPI */
58 printk(KERN_INFO
"irq message channel %d len %d unhandled \n", chan
, len
);
61 } /* switch rx channel */
63 return (1); /* always handled */
64 } /* hysdn_sched_rx */
66 /*****************************************************************************/
67 /* hysdn_sched_tx is called from the cards handler to announce that there is */
68 /* room in the tx-buffer to the card and data may be sent if needed. */
69 /* If the routine wants to send data it must fill buf, len and chan with the */
70 /* appropriate data and return a nonzero value. With a zero return no new */
71 /* data to send is assumed. maxlen specifies the buffer size available for */
73 /*****************************************************************************/
75 hysdn_sched_tx(hysdn_card
*card
, unsigned char *buf
,
76 unsigned short volatile *len
, unsigned short volatile *chan
,
77 unsigned short maxlen
)
81 if (card
->net_tx_busy
) {
82 card
->net_tx_busy
= 0; /* reset flag */
83 hysdn_tx_netack(card
); /* acknowledge packet send */
84 } /* a network packet has completely been transferred */
85 /* first of all async requests are handled */
86 if (card
->async_busy
) {
87 if (card
->async_len
<= maxlen
) {
88 memcpy(buf
, card
->async_data
, card
->async_len
);
89 *len
= card
->async_len
;
90 *chan
= card
->async_channel
;
91 card
->async_busy
= 0; /* reset request */
94 card
->async_busy
= 0; /* in case of length error */
96 if ((card
->err_log_state
== ERRLOG_STATE_START
) &&
97 (maxlen
>= ERRLOG_CMD_REQ_SIZE
)) {
98 strcpy(buf
, ERRLOG_CMD_REQ
); /* copy the command */
99 *len
= ERRLOG_CMD_REQ_SIZE
; /* buffer length */
100 *chan
= CHAN_ERRLOG
; /* and channel */
101 card
->err_log_state
= ERRLOG_STATE_ON
; /* new state is on */
102 return (1); /* tell that data should be send */
103 } /* error log start and able to send */
104 if ((card
->err_log_state
== ERRLOG_STATE_STOP
) &&
105 (maxlen
>= ERRLOG_CMD_STOP_SIZE
)) {
106 strcpy(buf
, ERRLOG_CMD_STOP
); /* copy the command */
107 *len
= ERRLOG_CMD_STOP_SIZE
; /* buffer length */
108 *chan
= CHAN_ERRLOG
; /* and channel */
109 card
->err_log_state
= ERRLOG_STATE_OFF
; /* new state is off */
110 return (1); /* tell that data should be send */
111 } /* error log start and able to send */
112 /* now handle network interface packets */
113 if ((hynet_enable
& (1 << card
->myid
)) &&
114 (skb
= hysdn_tx_netget(card
)) != NULL
)
116 if (skb
->len
<= maxlen
) {
117 memcpy(buf
, skb
->data
, skb
->len
); /* copy the packet to the buffer */
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 */
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
) )
129 if (skb
->len
<= maxlen
) {
130 memcpy(buf
, skb
->data
, skb
->len
);
133 hycapi_tx_capiack(card
);
134 return (1); /* go and send the data */
137 #endif /* CONFIG_HYSDN_CAPI */
138 return (0); /* nothing to send */
139 } /* hysdn_sched_tx */
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 beacuse only some lines */
147 /* are to be sent and this happens very seldom. */
148 /*****************************************************************************/
150 hysdn_tx_cfgline(hysdn_card
*card
, unsigned char *line
, unsigned short chan
)
152 int cnt
= 50; /* timeout intervalls */
155 if (card
->debug_flags
& LOG_SCHED_ASYN
)
156 hysdn_addlog(card
, "async tx-cfg chan=%d len=%d", chan
, strlen(line
) + 1);
158 while (card
->async_busy
) {
160 if (card
->debug_flags
& LOG_SCHED_ASYN
)
161 hysdn_addlog(card
, "async tx-cfg delayed");
163 msleep_interruptible(20); /* Timeout 20ms */
165 return (-ERR_ASYNC_TIME
); /* timed out */
166 } /* wait for buffer to become free */
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 */
174 /* now queue the task */
175 schedule_work(&card
->irq_queue
);
176 spin_unlock_irqrestore(&card
->hysdn_lock
, flags
);
178 if (card
->debug_flags
& LOG_SCHED_ASYN
)
179 hysdn_addlog(card
, "async tx-cfg data queued");
181 cnt
++; /* short delay */
183 while (card
->async_busy
) {
185 if (card
->debug_flags
& LOG_SCHED_ASYN
)
186 hysdn_addlog(card
, "async tx-cfg waiting for tx-ready");
188 msleep_interruptible(20); /* Timeout 20ms */
190 return (-ERR_ASYNC_TIME
); /* timed out */
191 } /* wait for buffer to become free again */
193 if (card
->debug_flags
& LOG_SCHED_ASYN
)
194 hysdn_addlog(card
, "async tx-cfg data send");
196 return (0); /* line send correctly */
197 } /* hysdn_tx_cfgline */