1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * 4 * Author Karsten Keil <kkeil@novell.com> 5 * 6 * Copyright 2008 by Karsten Keil <kkeil@novell.com> 7 */ 8 9 #include <linux/gfp.h> 10 #include <linux/module.h> 11 #include <linux/mISDNhw.h> 12 13 static void 14 dchannel_bh(struct work_struct *ws) 15 { 16 struct dchannel *dch = container_of(ws, struct dchannel, workq); 17 struct sk_buff *skb; 18 int err; 19 20 if (test_and_clear_bit(FLG_RECVQUEUE, &dch->Flags)) { 21 while ((skb = skb_dequeue(&dch->rqueue))) { 22 if (likely(dch->dev.D.peer)) { 23 err = dch->dev.D.recv(dch->dev.D.peer, skb); 24 if (err) 25 dev_kfree_skb(skb); 26 } else 27 dev_kfree_skb(skb); 28 } 29 } 30 if (test_and_clear_bit(FLG_PHCHANGE, &dch->Flags)) { 31 if (dch->phfunc) 32 dch->phfunc(dch); 33 } 34 } 35 36 static void 37 bchannel_bh(struct work_struct *ws) 38 { 39 struct bchannel *bch = container_of(ws, struct bchannel, workq); 40 struct sk_buff *skb; 41 int err; 42 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); 48 if (err) 49 dev_kfree_skb(skb); 50 } else 51 dev_kfree_skb(skb); 52 } 53 } 54 } 55 56 int 57 mISDN_initdchannel(struct dchannel *ch, int maxlen, void *phf) 58 { 59 test_and_set_bit(FLG_HDLC, &ch->Flags); 60 ch->maxlen = maxlen; 61 ch->hw = NULL; 62 ch->rx_skb = NULL; 63 ch->tx_skb = NULL; 64 ch->tx_idx = 0; 65 ch->phfunc = phf; 66 skb_queue_head_init(&ch->squeue); 67 skb_queue_head_init(&ch->rqueue); 68 INIT_LIST_HEAD(&ch->dev.bchannels); 69 INIT_WORK(&ch->workq, dchannel_bh); 70 return 0; 71 } 72 EXPORT_SYMBOL(mISDN_initdchannel); 73 74 int 75 mISDN_initbchannel(struct bchannel *ch, unsigned short maxlen, 76 unsigned short minlen) 77 { 78 ch->Flags = 0; 79 ch->minlen = minlen; 80 ch->next_minlen = minlen; 81 ch->init_minlen = minlen; 82 ch->maxlen = maxlen; 83 ch->next_maxlen = maxlen; 84 ch->init_maxlen = maxlen; 85 ch->hw = NULL; 86 ch->rx_skb = NULL; 87 ch->tx_skb = NULL; 88 ch->tx_idx = 0; 89 skb_queue_head_init(&ch->rqueue); 90 ch->rcount = 0; 91 ch->next_skb = NULL; 92 INIT_WORK(&ch->workq, bchannel_bh); 93 return 0; 94 } 95 EXPORT_SYMBOL(mISDN_initbchannel); 96 97 int 98 mISDN_freedchannel(struct dchannel *ch) 99 { 100 if (ch->tx_skb) { 101 dev_kfree_skb(ch->tx_skb); 102 ch->tx_skb = NULL; 103 } 104 if (ch->rx_skb) { 105 dev_kfree_skb(ch->rx_skb); 106 ch->rx_skb = NULL; 107 } 108 skb_queue_purge(&ch->squeue); 109 skb_queue_purge(&ch->rqueue); 110 flush_work(&ch->workq); 111 return 0; 112 } 113 EXPORT_SYMBOL(mISDN_freedchannel); 114 115 void 116 mISDN_clear_bchannel(struct bchannel *ch) 117 { 118 if (ch->tx_skb) { 119 dev_kfree_skb(ch->tx_skb); 120 ch->tx_skb = NULL; 121 } 122 ch->tx_idx = 0; 123 if (ch->rx_skb) { 124 dev_kfree_skb(ch->rx_skb); 125 ch->rx_skb = NULL; 126 } 127 if (ch->next_skb) { 128 dev_kfree_skb(ch->next_skb); 129 ch->next_skb = NULL; 130 } 131 test_and_clear_bit(FLG_TX_BUSY, &ch->Flags); 132 test_and_clear_bit(FLG_TX_NEXT, &ch->Flags); 133 test_and_clear_bit(FLG_ACTIVE, &ch->Flags); 134 test_and_clear_bit(FLG_FILLEMPTY, &ch->Flags); 135 test_and_clear_bit(FLG_TX_EMPTY, &ch->Flags); 136 test_and_clear_bit(FLG_RX_OFF, &ch->Flags); 137 ch->dropcnt = 0; 138 ch->minlen = ch->init_minlen; 139 ch->next_minlen = ch->init_minlen; 140 ch->maxlen = ch->init_maxlen; 141 ch->next_maxlen = ch->init_maxlen; 142 skb_queue_purge(&ch->rqueue); 143 ch->rcount = 0; 144 } 145 EXPORT_SYMBOL(mISDN_clear_bchannel); 146 147 void 148 mISDN_freebchannel(struct bchannel *ch) 149 { 150 cancel_work_sync(&ch->workq); 151 mISDN_clear_bchannel(ch); 152 } 153 EXPORT_SYMBOL(mISDN_freebchannel); 154 155 int 156 mISDN_ctrl_bchannel(struct bchannel *bch, struct mISDN_ctrl_req *cq) 157 { 158 int ret = 0; 159 160 switch (cq->op) { 161 case MISDN_CTRL_GETOP: 162 cq->op = MISDN_CTRL_RX_BUFFER | MISDN_CTRL_FILL_EMPTY | 163 MISDN_CTRL_RX_OFF; 164 break; 165 case MISDN_CTRL_FILL_EMPTY: 166 if (cq->p1) { 167 memset(bch->fill, cq->p2 & 0xff, MISDN_BCH_FILL_SIZE); 168 test_and_set_bit(FLG_FILLEMPTY, &bch->Flags); 169 } else { 170 test_and_clear_bit(FLG_FILLEMPTY, &bch->Flags); 171 } 172 break; 173 case MISDN_CTRL_RX_OFF: 174 /* read back dropped byte count */ 175 cq->p2 = bch->dropcnt; 176 if (cq->p1) 177 test_and_set_bit(FLG_RX_OFF, &bch->Flags); 178 else 179 test_and_clear_bit(FLG_RX_OFF, &bch->Flags); 180 bch->dropcnt = 0; 181 break; 182 case MISDN_CTRL_RX_BUFFER: 183 if (cq->p2 > MISDN_CTRL_RX_SIZE_IGNORE) 184 bch->next_maxlen = cq->p2; 185 if (cq->p1 > MISDN_CTRL_RX_SIZE_IGNORE) 186 bch->next_minlen = cq->p1; 187 /* we return the old values */ 188 cq->p1 = bch->minlen; 189 cq->p2 = bch->maxlen; 190 break; 191 default: 192 pr_info("mISDN unhandled control %x operation\n", cq->op); 193 ret = -EINVAL; 194 break; 195 } 196 return ret; 197 } 198 EXPORT_SYMBOL(mISDN_ctrl_bchannel); 199 200 static inline u_int 201 get_sapi_tei(u_char *p) 202 { 203 u_int sapi, tei; 204 205 sapi = *p >> 2; 206 tei = p[1] >> 1; 207 return sapi | (tei << 8); 208 } 209 210 void 211 recv_Dchannel(struct dchannel *dch) 212 { 213 struct mISDNhead *hh; 214 215 if (dch->rx_skb->len < 2) { /* at least 2 for sapi / tei */ 216 dev_kfree_skb(dch->rx_skb); 217 dch->rx_skb = NULL; 218 return; 219 } 220 hh = mISDN_HEAD_P(dch->rx_skb); 221 hh->prim = PH_DATA_IND; 222 hh->id = get_sapi_tei(dch->rx_skb->data); 223 skb_queue_tail(&dch->rqueue, dch->rx_skb); 224 dch->rx_skb = NULL; 225 schedule_event(dch, FLG_RECVQUEUE); 226 } 227 EXPORT_SYMBOL(recv_Dchannel); 228 229 void 230 recv_Echannel(struct dchannel *ech, struct dchannel *dch) 231 { 232 struct mISDNhead *hh; 233 234 if (ech->rx_skb->len < 2) { /* at least 2 for sapi / tei */ 235 dev_kfree_skb(ech->rx_skb); 236 ech->rx_skb = NULL; 237 return; 238 } 239 hh = mISDN_HEAD_P(ech->rx_skb); 240 hh->prim = PH_DATA_E_IND; 241 hh->id = get_sapi_tei(ech->rx_skb->data); 242 skb_queue_tail(&dch->rqueue, ech->rx_skb); 243 ech->rx_skb = NULL; 244 schedule_event(dch, FLG_RECVQUEUE); 245 } 246 EXPORT_SYMBOL(recv_Echannel); 247 248 void 249 recv_Bchannel(struct bchannel *bch, unsigned int id, bool force) 250 { 251 struct mISDNhead *hh; 252 253 /* if allocation did fail upper functions still may call us */ 254 if (unlikely(!bch->rx_skb)) 255 return; 256 if (unlikely(!bch->rx_skb->len)) { 257 /* we have no data to send - this may happen after recovery 258 * from overflow or too small allocation. 259 * We need to free the buffer here */ 260 dev_kfree_skb(bch->rx_skb); 261 bch->rx_skb = NULL; 262 } else { 263 if (test_bit(FLG_TRANSPARENT, &bch->Flags) && 264 (bch->rx_skb->len < bch->minlen) && !force) 265 return; 266 hh = mISDN_HEAD_P(bch->rx_skb); 267 hh->prim = PH_DATA_IND; 268 hh->id = id; 269 if (bch->rcount >= 64) { 270 printk(KERN_WARNING 271 "B%d receive queue overflow - flushing!\n", 272 bch->nr); 273 skb_queue_purge(&bch->rqueue); 274 } 275 bch->rcount++; 276 skb_queue_tail(&bch->rqueue, bch->rx_skb); 277 bch->rx_skb = NULL; 278 schedule_event(bch, FLG_RECVQUEUE); 279 } 280 } 281 EXPORT_SYMBOL(recv_Bchannel); 282 283 void 284 recv_Dchannel_skb(struct dchannel *dch, struct sk_buff *skb) 285 { 286 skb_queue_tail(&dch->rqueue, skb); 287 schedule_event(dch, FLG_RECVQUEUE); 288 } 289 EXPORT_SYMBOL(recv_Dchannel_skb); 290 291 void 292 recv_Bchannel_skb(struct bchannel *bch, struct sk_buff *skb) 293 { 294 if (bch->rcount >= 64) { 295 printk(KERN_WARNING "B-channel %p receive queue overflow, " 296 "flushing!\n", bch); 297 skb_queue_purge(&bch->rqueue); 298 bch->rcount = 0; 299 } 300 bch->rcount++; 301 skb_queue_tail(&bch->rqueue, skb); 302 schedule_event(bch, FLG_RECVQUEUE); 303 } 304 EXPORT_SYMBOL(recv_Bchannel_skb); 305 306 static void 307 confirm_Dsend(struct dchannel *dch) 308 { 309 struct sk_buff *skb; 310 311 skb = _alloc_mISDN_skb(PH_DATA_CNF, mISDN_HEAD_ID(dch->tx_skb), 312 0, NULL, GFP_ATOMIC); 313 if (!skb) { 314 printk(KERN_ERR "%s: no skb id %x\n", __func__, 315 mISDN_HEAD_ID(dch->tx_skb)); 316 return; 317 } 318 skb_queue_tail(&dch->rqueue, skb); 319 schedule_event(dch, FLG_RECVQUEUE); 320 } 321 322 int 323 get_next_dframe(struct dchannel *dch) 324 { 325 dch->tx_idx = 0; 326 dch->tx_skb = skb_dequeue(&dch->squeue); 327 if (dch->tx_skb) { 328 confirm_Dsend(dch); 329 return 1; 330 } 331 dch->tx_skb = NULL; 332 test_and_clear_bit(FLG_TX_BUSY, &dch->Flags); 333 return 0; 334 } 335 EXPORT_SYMBOL(get_next_dframe); 336 337 static void 338 confirm_Bsend(struct bchannel *bch) 339 { 340 struct sk_buff *skb; 341 342 if (bch->rcount >= 64) { 343 printk(KERN_WARNING "B-channel %p receive queue overflow, " 344 "flushing!\n", bch); 345 skb_queue_purge(&bch->rqueue); 346 bch->rcount = 0; 347 } 348 skb = _alloc_mISDN_skb(PH_DATA_CNF, mISDN_HEAD_ID(bch->tx_skb), 349 0, NULL, GFP_ATOMIC); 350 if (!skb) { 351 printk(KERN_ERR "%s: no skb id %x\n", __func__, 352 mISDN_HEAD_ID(bch->tx_skb)); 353 return; 354 } 355 bch->rcount++; 356 skb_queue_tail(&bch->rqueue, skb); 357 schedule_event(bch, FLG_RECVQUEUE); 358 } 359 360 int 361 get_next_bframe(struct bchannel *bch) 362 { 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); 369 /* confirm imediately to allow next data */ 370 confirm_Bsend(bch); 371 return 1; 372 } else { 373 test_and_clear_bit(FLG_TX_NEXT, &bch->Flags); 374 printk(KERN_WARNING "B TX_NEXT without skb\n"); 375 } 376 } 377 bch->tx_skb = NULL; 378 test_and_clear_bit(FLG_TX_BUSY, &bch->Flags); 379 return 0; 380 } 381 EXPORT_SYMBOL(get_next_bframe); 382 383 void 384 queue_ch_frame(struct mISDNchannel *ch, u_int pr, int id, struct sk_buff *skb) 385 { 386 struct mISDNhead *hh; 387 388 if (!skb) { 389 _queue_data(ch, pr, id, 0, NULL, GFP_ATOMIC); 390 } else { 391 if (ch->peer) { 392 hh = mISDN_HEAD_P(skb); 393 hh->prim = pr; 394 hh->id = id; 395 if (!ch->recv(ch->peer, skb)) 396 return; 397 } 398 dev_kfree_skb(skb); 399 } 400 } 401 EXPORT_SYMBOL(queue_ch_frame); 402 403 int 404 dchannel_senddata(struct dchannel *ch, struct sk_buff *skb) 405 { 406 /* check oversize */ 407 if (skb->len <= 0) { 408 printk(KERN_WARNING "%s: skb too small\n", __func__); 409 return -EINVAL; 410 } 411 if (skb->len > ch->maxlen) { 412 printk(KERN_WARNING "%s: skb too large(%d/%d)\n", 413 __func__, skb->len, ch->maxlen); 414 return -EINVAL; 415 } 416 /* HW lock must be obtained */ 417 if (test_and_set_bit(FLG_TX_BUSY, &ch->Flags)) { 418 skb_queue_tail(&ch->squeue, skb); 419 return 0; 420 } else { 421 /* write to fifo */ 422 ch->tx_skb = skb; 423 ch->tx_idx = 0; 424 return 1; 425 } 426 } 427 EXPORT_SYMBOL(dchannel_senddata); 428 429 int 430 bchannel_senddata(struct bchannel *ch, struct sk_buff *skb) 431 { 432 433 /* check oversize */ 434 if (skb->len <= 0) { 435 printk(KERN_WARNING "%s: skb too small\n", __func__); 436 return -EINVAL; 437 } 438 if (skb->len > ch->maxlen) { 439 printk(KERN_WARNING "%s: skb too large(%d/%d)\n", 440 __func__, skb->len, ch->maxlen); 441 return -EINVAL; 442 } 443 /* HW lock must be obtained */ 444 /* check for pending next_skb */ 445 if (ch->next_skb) { 446 printk(KERN_WARNING 447 "%s: next_skb exist ERROR (skb->len=%d next_skb->len=%d)\n", 448 __func__, skb->len, ch->next_skb->len); 449 return -EBUSY; 450 } 451 if (test_and_set_bit(FLG_TX_BUSY, &ch->Flags)) { 452 test_and_set_bit(FLG_TX_NEXT, &ch->Flags); 453 ch->next_skb = skb; 454 return 0; 455 } else { 456 /* write to fifo */ 457 ch->tx_skb = skb; 458 ch->tx_idx = 0; 459 confirm_Bsend(ch); 460 return 1; 461 } 462 } 463 EXPORT_SYMBOL(bchannel_senddata); 464 465 /* The function allocates a new receive skb on demand with a size for the 466 * requirements of the current protocol. It returns the tailroom of the 467 * receive skb or an error. 468 */ 469 int 470 bchannel_get_rxbuf(struct bchannel *bch, int reqlen) 471 { 472 int len; 473 474 if (bch->rx_skb) { 475 len = skb_tailroom(bch->rx_skb); 476 if (len < reqlen) { 477 pr_warn("B%d no space for %d (only %d) bytes\n", 478 bch->nr, reqlen, len); 479 if (test_bit(FLG_TRANSPARENT, &bch->Flags)) { 480 /* send what we have now and try a new buffer */ 481 recv_Bchannel(bch, 0, true); 482 } else { 483 /* on HDLC we have to drop too big frames */ 484 return -EMSGSIZE; 485 } 486 } else { 487 return len; 488 } 489 } 490 /* update current min/max length first */ 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)) 496 return -EMSGSIZE; 497 if (test_bit(FLG_TRANSPARENT, &bch->Flags)) { 498 if (reqlen >= bch->minlen) { 499 len = reqlen; 500 } else { 501 len = 2 * bch->minlen; 502 if (len > bch->maxlen) 503 len = bch->maxlen; 504 } 505 } else { 506 /* with HDLC we do not know the length yet */ 507 len = bch->maxlen; 508 } 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); 512 len = -ENOMEM; 513 } 514 return len; 515 } 516 EXPORT_SYMBOL(bchannel_get_rxbuf); 517