xref: /openbmc/linux/drivers/isdn/mISDN/hwchannel.c (revision 4800cd83)
1 /*
2  *
3  * Author	Karsten Keil <kkeil@novell.com>
4  *
5  * Copyright 2008  by Karsten Keil <kkeil@novell.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  */
17 
18 #include <linux/gfp.h>
19 #include <linux/module.h>
20 #include <linux/mISDNhw.h>
21 
22 static void
23 dchannel_bh(struct work_struct *ws)
24 {
25 	struct dchannel	*dch  = container_of(ws, struct dchannel, workq);
26 	struct sk_buff	*skb;
27 	int		err;
28 
29 	if (test_and_clear_bit(FLG_RECVQUEUE, &dch->Flags)) {
30 		while ((skb = skb_dequeue(&dch->rqueue))) {
31 			if (likely(dch->dev.D.peer)) {
32 				err = dch->dev.D.recv(dch->dev.D.peer, skb);
33 				if (err)
34 					dev_kfree_skb(skb);
35 			} else
36 				dev_kfree_skb(skb);
37 		}
38 	}
39 	if (test_and_clear_bit(FLG_PHCHANGE, &dch->Flags)) {
40 		if (dch->phfunc)
41 			dch->phfunc(dch);
42 	}
43 }
44 
45 static void
46 bchannel_bh(struct work_struct *ws)
47 {
48 	struct bchannel	*bch  = container_of(ws, struct bchannel, workq);
49 	struct sk_buff	*skb;
50 	int		err;
51 
52 	if (test_and_clear_bit(FLG_RECVQUEUE, &bch->Flags)) {
53 		while ((skb = skb_dequeue(&bch->rqueue))) {
54 			bch->rcount--;
55 			if (likely(bch->ch.peer)) {
56 				err = bch->ch.recv(bch->ch.peer, skb);
57 				if (err)
58 					dev_kfree_skb(skb);
59 			} else
60 				dev_kfree_skb(skb);
61 		}
62 	}
63 }
64 
65 int
66 mISDN_initdchannel(struct dchannel *ch, int maxlen, void *phf)
67 {
68 	test_and_set_bit(FLG_HDLC, &ch->Flags);
69 	ch->maxlen = maxlen;
70 	ch->hw = NULL;
71 	ch->rx_skb = NULL;
72 	ch->tx_skb = NULL;
73 	ch->tx_idx = 0;
74 	ch->phfunc = phf;
75 	skb_queue_head_init(&ch->squeue);
76 	skb_queue_head_init(&ch->rqueue);
77 	INIT_LIST_HEAD(&ch->dev.bchannels);
78 	INIT_WORK(&ch->workq, dchannel_bh);
79 	return 0;
80 }
81 EXPORT_SYMBOL(mISDN_initdchannel);
82 
83 int
84 mISDN_initbchannel(struct bchannel *ch, int maxlen)
85 {
86 	ch->Flags = 0;
87 	ch->maxlen = maxlen;
88 	ch->hw = NULL;
89 	ch->rx_skb = NULL;
90 	ch->tx_skb = NULL;
91 	ch->tx_idx = 0;
92 	skb_queue_head_init(&ch->rqueue);
93 	ch->rcount = 0;
94 	ch->next_skb = NULL;
95 	INIT_WORK(&ch->workq, bchannel_bh);
96 	return 0;
97 }
98 EXPORT_SYMBOL(mISDN_initbchannel);
99 
100 int
101 mISDN_freedchannel(struct dchannel *ch)
102 {
103 	if (ch->tx_skb) {
104 		dev_kfree_skb(ch->tx_skb);
105 		ch->tx_skb = NULL;
106 	}
107 	if (ch->rx_skb) {
108 		dev_kfree_skb(ch->rx_skb);
109 		ch->rx_skb = NULL;
110 	}
111 	skb_queue_purge(&ch->squeue);
112 	skb_queue_purge(&ch->rqueue);
113 	flush_work_sync(&ch->workq);
114 	return 0;
115 }
116 EXPORT_SYMBOL(mISDN_freedchannel);
117 
118 void
119 mISDN_clear_bchannel(struct bchannel *ch)
120 {
121 	if (ch->tx_skb) {
122 		dev_kfree_skb(ch->tx_skb);
123 		ch->tx_skb = NULL;
124 	}
125 	ch->tx_idx = 0;
126 	if (ch->rx_skb) {
127 		dev_kfree_skb(ch->rx_skb);
128 		ch->rx_skb = NULL;
129 	}
130 	if (ch->next_skb) {
131 		dev_kfree_skb(ch->next_skb);
132 		ch->next_skb = NULL;
133 	}
134 	test_and_clear_bit(FLG_TX_BUSY, &ch->Flags);
135 	test_and_clear_bit(FLG_TX_NEXT, &ch->Flags);
136 	test_and_clear_bit(FLG_ACTIVE, &ch->Flags);
137 }
138 EXPORT_SYMBOL(mISDN_clear_bchannel);
139 
140 int
141 mISDN_freebchannel(struct bchannel *ch)
142 {
143 	mISDN_clear_bchannel(ch);
144 	skb_queue_purge(&ch->rqueue);
145 	ch->rcount = 0;
146 	flush_work_sync(&ch->workq);
147 	return 0;
148 }
149 EXPORT_SYMBOL(mISDN_freebchannel);
150 
151 static inline u_int
152 get_sapi_tei(u_char *p)
153 {
154 	u_int	sapi, tei;
155 
156 	sapi = *p >> 2;
157 	tei = p[1] >> 1;
158 	return sapi | (tei << 8);
159 }
160 
161 void
162 recv_Dchannel(struct dchannel *dch)
163 {
164 	struct mISDNhead *hh;
165 
166 	if (dch->rx_skb->len < 2) { /* at least 2 for sapi / tei */
167 		dev_kfree_skb(dch->rx_skb);
168 		dch->rx_skb = NULL;
169 		return;
170 	}
171 	hh = mISDN_HEAD_P(dch->rx_skb);
172 	hh->prim = PH_DATA_IND;
173 	hh->id = get_sapi_tei(dch->rx_skb->data);
174 	skb_queue_tail(&dch->rqueue, dch->rx_skb);
175 	dch->rx_skb = NULL;
176 	schedule_event(dch, FLG_RECVQUEUE);
177 }
178 EXPORT_SYMBOL(recv_Dchannel);
179 
180 void
181 recv_Echannel(struct dchannel *ech, struct dchannel *dch)
182 {
183 	struct mISDNhead *hh;
184 
185 	if (ech->rx_skb->len < 2) { /* at least 2 for sapi / tei */
186 		dev_kfree_skb(ech->rx_skb);
187 		ech->rx_skb = NULL;
188 		return;
189 	}
190 	hh = mISDN_HEAD_P(ech->rx_skb);
191 	hh->prim = PH_DATA_E_IND;
192 	hh->id = get_sapi_tei(ech->rx_skb->data);
193 	skb_queue_tail(&dch->rqueue, ech->rx_skb);
194 	ech->rx_skb = NULL;
195 	schedule_event(dch, FLG_RECVQUEUE);
196 }
197 EXPORT_SYMBOL(recv_Echannel);
198 
199 void
200 recv_Bchannel(struct bchannel *bch, unsigned int id)
201 {
202 	struct mISDNhead *hh;
203 
204 	hh = mISDN_HEAD_P(bch->rx_skb);
205 	hh->prim = PH_DATA_IND;
206 	hh->id = id;
207 	if (bch->rcount >= 64) {
208 		printk(KERN_WARNING "B-channel %p receive queue overflow, "
209 			"fushing!\n", bch);
210 		skb_queue_purge(&bch->rqueue);
211 		bch->rcount = 0;
212 		return;
213 	}
214 	bch->rcount++;
215 	skb_queue_tail(&bch->rqueue, bch->rx_skb);
216 	bch->rx_skb = NULL;
217 	schedule_event(bch, FLG_RECVQUEUE);
218 }
219 EXPORT_SYMBOL(recv_Bchannel);
220 
221 void
222 recv_Dchannel_skb(struct dchannel *dch, struct sk_buff *skb)
223 {
224 	skb_queue_tail(&dch->rqueue, skb);
225 	schedule_event(dch, FLG_RECVQUEUE);
226 }
227 EXPORT_SYMBOL(recv_Dchannel_skb);
228 
229 void
230 recv_Bchannel_skb(struct bchannel *bch, struct sk_buff *skb)
231 {
232 	if (bch->rcount >= 64) {
233 		printk(KERN_WARNING "B-channel %p receive queue overflow, "
234 			"fushing!\n", bch);
235 		skb_queue_purge(&bch->rqueue);
236 		bch->rcount = 0;
237 	}
238 	bch->rcount++;
239 	skb_queue_tail(&bch->rqueue, skb);
240 	schedule_event(bch, FLG_RECVQUEUE);
241 }
242 EXPORT_SYMBOL(recv_Bchannel_skb);
243 
244 static void
245 confirm_Dsend(struct dchannel *dch)
246 {
247 	struct sk_buff	*skb;
248 
249 	skb = _alloc_mISDN_skb(PH_DATA_CNF, mISDN_HEAD_ID(dch->tx_skb),
250 	    0, NULL, GFP_ATOMIC);
251 	if (!skb) {
252 		printk(KERN_ERR "%s: no skb id %x\n", __func__,
253 		    mISDN_HEAD_ID(dch->tx_skb));
254 		return;
255 	}
256 	skb_queue_tail(&dch->rqueue, skb);
257 	schedule_event(dch, FLG_RECVQUEUE);
258 }
259 
260 int
261 get_next_dframe(struct dchannel *dch)
262 {
263 	dch->tx_idx = 0;
264 	dch->tx_skb = skb_dequeue(&dch->squeue);
265 	if (dch->tx_skb) {
266 		confirm_Dsend(dch);
267 		return 1;
268 	}
269 	dch->tx_skb = NULL;
270 	test_and_clear_bit(FLG_TX_BUSY, &dch->Flags);
271 	return 0;
272 }
273 EXPORT_SYMBOL(get_next_dframe);
274 
275 void
276 confirm_Bsend(struct bchannel *bch)
277 {
278 	struct sk_buff	*skb;
279 
280 	if (bch->rcount >= 64) {
281 		printk(KERN_WARNING "B-channel %p receive queue overflow, "
282 			"fushing!\n", bch);
283 		skb_queue_purge(&bch->rqueue);
284 		bch->rcount = 0;
285 	}
286 	skb = _alloc_mISDN_skb(PH_DATA_CNF, mISDN_HEAD_ID(bch->tx_skb),
287 	    0, NULL, GFP_ATOMIC);
288 	if (!skb) {
289 		printk(KERN_ERR "%s: no skb id %x\n", __func__,
290 		    mISDN_HEAD_ID(bch->tx_skb));
291 		return;
292 	}
293 	bch->rcount++;
294 	skb_queue_tail(&bch->rqueue, skb);
295 	schedule_event(bch, FLG_RECVQUEUE);
296 }
297 EXPORT_SYMBOL(confirm_Bsend);
298 
299 int
300 get_next_bframe(struct bchannel *bch)
301 {
302 	bch->tx_idx = 0;
303 	if (test_bit(FLG_TX_NEXT, &bch->Flags)) {
304 		bch->tx_skb = bch->next_skb;
305 		if (bch->tx_skb) {
306 			bch->next_skb = NULL;
307 			test_and_clear_bit(FLG_TX_NEXT, &bch->Flags);
308 			if (!test_bit(FLG_TRANSPARENT, &bch->Flags))
309 				confirm_Bsend(bch); /* not for transparent */
310 			return 1;
311 		} else {
312 			test_and_clear_bit(FLG_TX_NEXT, &bch->Flags);
313 			printk(KERN_WARNING "B TX_NEXT without skb\n");
314 		}
315 	}
316 	bch->tx_skb = NULL;
317 	test_and_clear_bit(FLG_TX_BUSY, &bch->Flags);
318 	return 0;
319 }
320 EXPORT_SYMBOL(get_next_bframe);
321 
322 void
323 queue_ch_frame(struct mISDNchannel *ch, u_int pr, int id, struct sk_buff *skb)
324 {
325 	struct mISDNhead *hh;
326 
327 	if (!skb) {
328 		_queue_data(ch, pr, id, 0, NULL, GFP_ATOMIC);
329 	} else {
330 		if (ch->peer) {
331 			hh = mISDN_HEAD_P(skb);
332 			hh->prim = pr;
333 			hh->id = id;
334 			if (!ch->recv(ch->peer, skb))
335 				return;
336 		}
337 		dev_kfree_skb(skb);
338 	}
339 }
340 EXPORT_SYMBOL(queue_ch_frame);
341 
342 int
343 dchannel_senddata(struct dchannel *ch, struct sk_buff *skb)
344 {
345 	/* check oversize */
346 	if (skb->len <= 0) {
347 		printk(KERN_WARNING "%s: skb too small\n", __func__);
348 		return -EINVAL;
349 	}
350 	if (skb->len > ch->maxlen) {
351 		printk(KERN_WARNING "%s: skb too large(%d/%d)\n",
352 			__func__, skb->len, ch->maxlen);
353 		return -EINVAL;
354 	}
355 	/* HW lock must be obtained */
356 	if (test_and_set_bit(FLG_TX_BUSY, &ch->Flags)) {
357 		skb_queue_tail(&ch->squeue, skb);
358 		return 0;
359 	} else {
360 		/* write to fifo */
361 		ch->tx_skb = skb;
362 		ch->tx_idx = 0;
363 		return 1;
364 	}
365 }
366 EXPORT_SYMBOL(dchannel_senddata);
367 
368 int
369 bchannel_senddata(struct bchannel *ch, struct sk_buff *skb)
370 {
371 
372 	/* check oversize */
373 	if (skb->len <= 0) {
374 		printk(KERN_WARNING "%s: skb too small\n", __func__);
375 		return -EINVAL;
376 	}
377 	if (skb->len > ch->maxlen) {
378 		printk(KERN_WARNING "%s: skb too large(%d/%d)\n",
379 			__func__, skb->len, ch->maxlen);
380 		return -EINVAL;
381 	}
382 	/* HW lock must be obtained */
383 	/* check for pending next_skb */
384 	if (ch->next_skb) {
385 		printk(KERN_WARNING
386 		    "%s: next_skb exist ERROR (skb->len=%d next_skb->len=%d)\n",
387 		    __func__, skb->len, ch->next_skb->len);
388 		return -EBUSY;
389 	}
390 	if (test_and_set_bit(FLG_TX_BUSY, &ch->Flags)) {
391 		test_and_set_bit(FLG_TX_NEXT, &ch->Flags);
392 		ch->next_skb = skb;
393 		return 0;
394 	} else {
395 		/* write to fifo */
396 		ch->tx_skb = skb;
397 		ch->tx_idx = 0;
398 		return 1;
399 	}
400 }
401 EXPORT_SYMBOL(bchannel_senddata);
402