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/signal.h>
15 #include <linux/kernel.h>
16 #include <linux/ioport.h>
17 #include <linux/interrupt.h>
18 #include <linux/delay.h>
21 #include "hysdn_defs.h"
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 /*****************************************************************************/
31 hysdn_sched_rx(hysdn_card
*card
, unsigned char *buf
, unsigned short len
,
37 if (hynet_enable
& (1 << card
->myid
)) {
38 /* give packet to network handler */
39 hysdn_rx_netpkt(card
, buf
, len
);
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 */
48 #ifdef CONFIG_HYSDN_CAPI
50 /* give packet to CAPI handler */
51 if (hycapi_enable
& (1 << card
->myid
)) {
52 hycapi_rx_capipkt(card
, buf
, len
);
55 #endif /* CONFIG_HYSDN_CAPI */
57 printk(KERN_INFO
"irq message channel %d len %d unhandled \n", chan
, len
);
60 } /* switch rx channel */
62 return (1); /* always handled */
63 } /* hysdn_sched_rx */
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 */
72 /*****************************************************************************/
74 hysdn_sched_tx(hysdn_card
*card
, unsigned char *buf
,
75 unsigned short volatile *len
, unsigned short volatile *chan
,
76 unsigned short maxlen
)
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 */
93 card
->async_busy
= 0; /* in case of length error */
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
)
115 if (skb
->len
<= maxlen
) {
116 /* copy the packet to the buffer */
117 skb_copy_from_linear_data(skb
, buf
, 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 */
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 skb_copy_from_linear_data(skb
, buf
, 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 because 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 */
This page took 0.03475 seconds and 5 git commands to generate.