isdn/mISDN/hwchannel.c

39 	struct bchannel	*bch  = container_of(ws, struct bchannel, workq);
43 	if (test_and_clear_bit(FLG_RECVQUEUE, &bch->Flags)) {
44 		while ((skb = skb_dequeue(&bch->rqueue))) {
45 			bch->rcount--;
46 			if (likely(bch->ch.peer)) {
47 				err = bch->ch.recv(bch->ch.peer, skb);
156 mISDN_ctrl_bchannel(struct bchannel *bch, struct mISDN_ctrl_req *cq)
167 			memset(bch->fill, cq->p2 & 0xff, MISDN_BCH_FILL_SIZE);
168 			test_and_set_bit(FLG_FILLEMPTY, &bch->Flags);
170 			test_and_clear_bit(FLG_FILLEMPTY, &bch->Flags);
175 		cq->p2 = bch->dropcnt;
177 			test_and_set_bit(FLG_RX_OFF, &bch->Flags);
179 			test_and_clear_bit(FLG_RX_OFF, &bch->Flags);
180 		bch->dropcnt = 0;
184 			bch->next_maxlen = cq->p2;
186 			bch->next_minlen = cq->p1;
188 		cq->p1 = bch->minlen;
189 		cq->p2 = bch->maxlen;
249 recv_Bchannel(struct bchannel *bch, unsigned int id, bool force)
254 	if (unlikely(!bch->rx_skb))
256 	if (unlikely(!bch->rx_skb->len)) {
260 		dev_kfree_skb(bch->rx_skb);
261 		bch->rx_skb = NULL;
263 		if (test_bit(FLG_TRANSPARENT, &bch->Flags) &&
264 		    (bch->rx_skb->len < bch->minlen) && !force)
266 		hh = mISDN_HEAD_P(bch->rx_skb);
269 		if (bch->rcount >= 64) {
272 			       bch->nr);
273 			skb_queue_purge(&bch->rqueue);
275 		bch->rcount++;
276 		skb_queue_tail(&bch->rqueue, bch->rx_skb);
277 		bch->rx_skb = NULL;
278 		schedule_event(bch, FLG_RECVQUEUE);
292 recv_Bchannel_skb(struct bchannel *bch, struct sk_buff *skb)
294 	if (bch->rcount >= 64) {
296 		       "flushing!\n", bch);
297 		skb_queue_purge(&bch->rqueue);
298 		bch->rcount = 0;
300 	bch->rcount++;
301 	skb_queue_tail(&bch->rqueue, skb);
302 	schedule_event(bch, FLG_RECVQUEUE);
338 confirm_Bsend(struct bchannel *bch)
342 	if (bch->rcount >= 64) {
344 		       "flushing!\n", bch);
345 		skb_queue_purge(&bch->rqueue);
346 		bch->rcount = 0;
348 	skb = _alloc_mISDN_skb(PH_DATA_CNF, mISDN_HEAD_ID(bch->tx_skb),
352 		       mISDN_HEAD_ID(bch->tx_skb));
355 	bch->rcount++;
356 	skb_queue_tail(&bch->rqueue, skb);
357 	schedule_event(bch, FLG_RECVQUEUE);
361 get_next_bframe(struct bchannel *bch)
363 	bch->tx_idx = 0;
364 	if (test_bit(FLG_TX_NEXT, &bch->Flags)) {
365 		bch->tx_skb = bch->next_skb;
366 		if (bch->tx_skb) {
367 			bch->next_skb = NULL;
368 			test_and_clear_bit(FLG_TX_NEXT, &bch->Flags);
370 			confirm_Bsend(bch);
373 			test_and_clear_bit(FLG_TX_NEXT, &bch->Flags);
377 	bch->tx_skb = NULL;
378 	test_and_clear_bit(FLG_TX_BUSY, &bch->Flags);
470 bchannel_get_rxbuf(struct bchannel *bch, int reqlen)
474 	if (bch->rx_skb) {
475 		len = skb_tailroom(bch->rx_skb);
478 				bch->nr, reqlen, len);
479 			if (test_bit(FLG_TRANSPARENT, &bch->Flags)) {
481 				recv_Bchannel(bch, 0, true);
491 	if (unlikely(bch->maxlen != bch->next_maxlen))
492 		bch->maxlen = bch->next_maxlen;
493 	if (unlikely(bch->minlen != bch->next_minlen))
494 		bch->minlen = bch->next_minlen;
495 	if (unlikely(reqlen > bch->maxlen))
497 	if (test_bit(FLG_TRANSPARENT, &bch->Flags)) {
498 		if (reqlen >= bch->minlen) {
501 			len = 2 * bch->minlen;
502 			if (len > bch->maxlen)
503 				len = bch->maxlen;
507 		len = bch->maxlen;
509 	bch->rx_skb = mI_alloc_skb(len, GFP_ATOMIC);
510 	if (!bch->rx_skb) {
511 		pr_warn("B%d receive no memory for %d bytes\n", bch->nr, len);