1/* 2 * PCBIT-D low-layer interface 3 * 4 * Copyright (C) 1996 Universidade de Lisboa 5 * 6 * Written by Pedro Roque Marques (roque@di.fc.ul.pt) 7 * 8 * This software may be used and distributed according to the terms of 9 * the GNU General Public License, incorporated herein by reference. 10 */ 11 12/* 13 * 19991203 - Fernando Carvalho - takion@superbofh.org 14 * Hacked to compile with egcs and run with current version of isdn modules 15*/ 16 17/* 18 * Based on documentation provided by Inesc: 19 * - "Interface com bus do PC para o PCBIT e PCBIT-D", Inesc, Jan 93 20 */ 21 22/* 23 * TODO: better handling of errors 24 * re-write/remove debug printks 25 */ 26 27#include <linux/string.h> 28#include <linux/kernel.h> 29#include <linux/types.h> 30#include <linux/slab.h> 31#include <linux/interrupt.h> 32#include <linux/workqueue.h> 33#include <linux/mm.h> 34#include <linux/skbuff.h> 35 36#include <linux/isdnif.h> 37 38#include <asm/system.h> 39#include <asm/io.h> 40 41 42#include "pcbit.h" 43#include "layer2.h" 44#include "edss1.h" 45 46#undef DEBUG_FRAG 47 48 49/* 50 * Prototypes 51 */ 52 53static void pcbit_transmit(struct pcbit_dev *dev); 54 55static void pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack); 56 57static void pcbit_l2_error(struct pcbit_dev *dev); 58static void pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info); 59static void pcbit_l2_err_recover(unsigned long data); 60 61static void pcbit_firmware_bug(struct pcbit_dev *dev); 62 63static __inline__ void 64pcbit_sched_delivery(struct pcbit_dev *dev) 65{ 66 schedule_work(&dev->qdelivery); 67} 68 69 70/* 71 * Called from layer3 72 */ 73 74int 75pcbit_l2_write(struct pcbit_dev *dev, ulong msg, ushort refnum, 76 struct sk_buff *skb, unsigned short hdr_len) 77{ 78 struct frame_buf *frame, 79 *ptr; 80 unsigned long flags; 81 82 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) { 83 dev_kfree_skb(skb); 84 return -1; 85 } 86 if ((frame = kmalloc(sizeof(struct frame_buf), 87 GFP_ATOMIC)) == NULL) { 88 printk(KERN_WARNING "pcbit_2_write: kmalloc failed\n"); 89 dev_kfree_skb(skb); 90 return -1; 91 } 92 frame->msg = msg; 93 frame->refnum = refnum; 94 frame->copied = 0; 95 frame->hdr_len = hdr_len; 96 97 if (skb) 98 frame->dt_len = skb->len - hdr_len; 99 else 100 frame->dt_len = 0; 101 102 frame->skb = skb; 103 104 frame->next = NULL; 105 106 spin_lock_irqsave(&dev->lock, flags); 107 108 if (dev->write_queue == NULL) { 109 dev->write_queue = frame; 110 spin_unlock_irqrestore(&dev->lock, flags); 111 pcbit_transmit(dev); 112 } else { 113 for (ptr = dev->write_queue; ptr->next; ptr = ptr->next); 114 ptr->next = frame; 115 116 spin_unlock_irqrestore(&dev->lock, flags); 117 } 118 return 0; 119} 120 121static __inline__ void 122pcbit_tx_update(struct pcbit_dev *dev, ushort len) 123{ 124 u_char info; 125 126 dev->send_seq = (dev->send_seq + 1) % 8; 127 128 dev->fsize[dev->send_seq] = len; 129 info = 0; 130 info |= dev->rcv_seq << 3; 131 info |= dev->send_seq; 132 133 writeb(info, dev->sh_mem + BANK4); 134 135} 136 137/* 138 * called by interrupt service routine or by write_2 139 */ 140 141static void 142pcbit_transmit(struct pcbit_dev *dev) 143{ 144 struct frame_buf *frame = NULL; 145 unsigned char unacked; 146 int flen; /* fragment frame length including all headers */ 147 int free; 148 int count, 149 cp_len; 150 unsigned long flags; 151 unsigned short tt; 152 153 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) 154 return; 155 156 unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07; 157 158 spin_lock_irqsave(&dev->lock, flags); 159 160 if (dev->free > 16 && dev->write_queue && unacked < 7) { 161 162 if (!dev->w_busy) 163 dev->w_busy = 1; 164 else { 165 spin_unlock_irqrestore(&dev->lock, flags); 166 return; 167 } 168 169 170 frame = dev->write_queue; 171 free = dev->free; 172 173 spin_unlock_irqrestore(&dev->lock, flags); 174 175 if (frame->copied == 0) { 176 177 /* Type 0 frame */ 178 179 ulong msg; 180 181 if (frame->skb) 182 flen = FRAME_HDR_LEN + PREHDR_LEN + frame->skb->len; 183 else 184 flen = FRAME_HDR_LEN + PREHDR_LEN; 185 186 if (flen > free) 187 flen = free; 188 189 msg = frame->msg; 190 191 /* 192 * Board level 2 header 193 */ 194 195 pcbit_writew(dev, flen - FRAME_HDR_LEN); 196 197 pcbit_writeb(dev, GET_MSG_CPU(msg)); 198 199 pcbit_writeb(dev, GET_MSG_PROC(msg)); 200 201 /* TH */ 202 pcbit_writew(dev, frame->hdr_len + PREHDR_LEN); 203 204 /* TD */ 205 pcbit_writew(dev, frame->dt_len); 206 207 208 /* 209 * Board level 3 fixed-header 210 */ 211 212 /* LEN = TH */ 213 pcbit_writew(dev, frame->hdr_len + PREHDR_LEN); 214 215 /* XX */ 216 pcbit_writew(dev, 0); 217 218 /* C + S */ 219 pcbit_writeb(dev, GET_MSG_CMD(msg)); 220 pcbit_writeb(dev, GET_MSG_SCMD(msg)); 221 222 /* NUM */ 223 pcbit_writew(dev, frame->refnum); 224 225 count = FRAME_HDR_LEN + PREHDR_LEN; 226 } else { 227 /* Type 1 frame */ 228 229 flen = 2 + (frame->skb->len - frame->copied); 230 231 if (flen > free) 232 flen = free; 233 234 /* TT */ 235 tt = ((ushort) (flen - 2)) | 0x8000U; /* Type 1 */ 236 pcbit_writew(dev, tt); 237 238 count = 2; 239 } 240 241 if (frame->skb) { 242 cp_len = frame->skb->len - frame->copied; 243 if (cp_len > flen - count) 244 cp_len = flen - count; 245 246 memcpy_topcbit(dev, frame->skb->data + frame->copied, 247 cp_len); 248 frame->copied += cp_len; 249 } 250 /* bookkeeping */ 251 dev->free -= flen; 252 pcbit_tx_update(dev, flen); 253 254 spin_lock_irqsave(&dev->lock, flags); 255 256 if (frame->skb == NULL || frame->copied == frame->skb->len) { 257 258 dev->write_queue = frame->next; 259 260 if (frame->skb != NULL) { 261 /* free frame */ 262 dev_kfree_skb(frame->skb); 263 } 264 kfree(frame); 265 } 266 dev->w_busy = 0; 267 spin_unlock_irqrestore(&dev->lock, flags); 268 } else { 269 spin_unlock_irqrestore(&dev->lock, flags); 270#ifdef DEBUG 271 printk(KERN_DEBUG "unacked %d free %d write_queue %s\n", 272 unacked, dev->free, dev->write_queue ? "not empty" : 273 "empty"); 274#endif 275 } 276} 277 278 279/* 280 * deliver a queued frame to the upper layer 281 */ 282 283void 284pcbit_deliver(struct work_struct *work) 285{ 286 struct frame_buf *frame; 287 unsigned long flags, msg; 288 struct pcbit_dev *dev = 289 container_of(work, struct pcbit_dev, qdelivery); 290 291 spin_lock_irqsave(&dev->lock, flags); 292 293 while ((frame = dev->read_queue)) { 294 dev->read_queue = frame->next; 295 spin_unlock_irqrestore(&dev->lock, flags); 296 297 msg = 0; 298 SET_MSG_CPU(msg, 0); 299 SET_MSG_PROC(msg, 0); 300 SET_MSG_CMD(msg, frame->skb->data[2]); 301 SET_MSG_SCMD(msg, frame->skb->data[3]); 302 303 frame->refnum = *((ushort *) frame->skb->data + 4); 304 frame->msg = *((ulong *) & msg); 305 306 skb_pull(frame->skb, 6); 307 308 pcbit_l3_receive(dev, frame->msg, frame->skb, frame->hdr_len, 309 frame->refnum); 310 311 kfree(frame); 312 313 spin_lock_irqsave(&dev->lock, flags); 314 } 315 316 spin_unlock_irqrestore(&dev->lock, flags); 317} 318 319/* 320 * Reads BANK 2 & Reassembles 321 */ 322 323static void 324pcbit_receive(struct pcbit_dev *dev) 325{ 326 unsigned short tt; 327 u_char cpu, 328 proc; 329 struct frame_buf *frame = NULL; 330 unsigned long flags; 331 u_char type1; 332 333 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) 334 return; 335 336 tt = pcbit_readw(dev); 337 338 if ((tt & 0x7fffU) > 511) { 339 printk(KERN_INFO "pcbit: invalid frame length -> TT=%04x\n", 340 tt); 341 pcbit_l2_error(dev); 342 return; 343 } 344 if (!(tt & 0x8000U)) { /* Type 0 */ 345 type1 = 0; 346 347 if (dev->read_frame) { 348 printk(KERN_DEBUG "pcbit_receive: Type 0 frame and read_frame != NULL\n"); 349 /* discard previous queued frame */ 350 if (dev->read_frame->skb) 351 kfree_skb(dev->read_frame->skb); 352 kfree(dev->read_frame); 353 dev->read_frame = NULL; 354 } 355 frame = kzalloc(sizeof(struct frame_buf), GFP_ATOMIC); 356 357 if (frame == NULL) { 358 printk(KERN_WARNING "kmalloc failed\n"); 359 return; 360 } 361 362 cpu = pcbit_readb(dev); 363 proc = pcbit_readb(dev); 364 365 366 if (cpu != 0x06 && cpu != 0x02) { 367 printk(KERN_DEBUG "pcbit: invalid cpu value\n"); 368 kfree(frame); 369 pcbit_l2_error(dev); 370 return; 371 } 372 /* 373 * we discard cpu & proc on receiving 374 * but we read it to update the pointer 375 */ 376 377 frame->hdr_len = pcbit_readw(dev); 378 frame->dt_len = pcbit_readw(dev); 379 380 /* 381 * 0 sized packet 382 * I don't know if they are an error or not... 383 * But they are very frequent 384 * Not documented 385 */ 386 387 if (frame->hdr_len == 0) { 388 kfree(frame); 389#ifdef DEBUG 390 printk(KERN_DEBUG "0 sized frame\n"); 391#endif 392 pcbit_firmware_bug(dev); 393 return; 394 } 395 /* sanity check the length values */ 396 if (frame->hdr_len > 1024 || frame->dt_len > 2048) { 397#ifdef DEBUG 398 printk(KERN_DEBUG "length problem: "); 399 printk(KERN_DEBUG "TH=%04x TD=%04x\n", 400 frame->hdr_len, 401 frame->dt_len); 402#endif 403 pcbit_l2_error(dev); 404 kfree(frame); 405 return; 406 } 407 /* minimum frame read */ 408 409 frame->skb = dev_alloc_skb(frame->hdr_len + frame->dt_len + 410 ((frame->hdr_len + 15) & ~15)); 411 412 if (!frame->skb) { 413 printk(KERN_DEBUG "pcbit_receive: out of memory\n"); 414 kfree(frame); 415 return; 416 } 417 /* 16 byte alignment for IP */ 418 if (frame->dt_len) 419 skb_reserve(frame->skb, (frame->hdr_len + 15) & ~15); 420 421 } else { 422 /* Type 1 */ 423 type1 = 1; 424 tt &= 0x7fffU; 425 426 if (!(frame = dev->read_frame)) { 427 printk("Type 1 frame and no frame queued\n"); 428 /* usually after an error: toss frame */ 429 dev->readptr += tt; 430 if (dev->readptr > dev->sh_mem + BANK2 + BANKLEN) 431 dev->readptr -= BANKLEN; 432 return; 433 434 } 435 } 436 437 memcpy_frompcbit(dev, skb_put(frame->skb, tt), tt); 438 439 frame->copied += tt; 440 spin_lock_irqsave(&dev->lock, flags); 441 if (frame->copied == frame->hdr_len + frame->dt_len) { 442 443 if (type1) { 444 dev->read_frame = NULL; 445 } 446 if (dev->read_queue) { 447 struct frame_buf *ptr; 448 for (ptr = dev->read_queue; ptr->next; ptr = ptr->next); 449 ptr->next = frame; 450 } else 451 dev->read_queue = frame; 452 453 } else { 454 dev->read_frame = frame; 455 } 456 spin_unlock_irqrestore(&dev->lock, flags); 457} 458 459/* 460 * The board sends 0 sized frames 461 * They are TDATA_CONFs that get messed up somehow 462 * gotta send a fake acknowledgment to the upper layer somehow 463 */ 464 465static __inline__ void 466pcbit_fake_conf(struct pcbit_dev *dev, struct pcbit_chan *chan) 467{ 468 isdn_ctrl ictl; 469 470 if (chan->queued) { 471 chan->queued--; 472 473 ictl.driver = dev->id; 474 ictl.command = ISDN_STAT_BSENT; 475 ictl.arg = chan->id; 476 dev->dev_if->statcallb(&ictl); 477 } 478} 479 480static void 481pcbit_firmware_bug(struct pcbit_dev *dev) 482{ 483 struct pcbit_chan *chan; 484 485 chan = dev->b1; 486 487 if (chan->fsm_state == ST_ACTIVE) { 488 pcbit_fake_conf(dev, chan); 489 } 490 chan = dev->b2; 491 492 if (chan->fsm_state == ST_ACTIVE) { 493 pcbit_fake_conf(dev, chan); 494 } 495} 496 497irqreturn_t 498pcbit_irq_handler(int interrupt, void *devptr) 499{ 500 struct pcbit_dev *dev; 501 u_char info, 502 ack_seq, 503 read_seq; 504 505 dev = (struct pcbit_dev *) devptr; 506 507 if (!dev) { 508 printk(KERN_WARNING "pcbit_irq_handler: wrong device\n"); 509 return IRQ_NONE; 510 } 511 if (dev->interrupt) { 512 printk(KERN_DEBUG "pcbit: reentering interrupt hander\n"); 513 return IRQ_HANDLED; 514 } 515 dev->interrupt = 1; 516 517 info = readb(dev->sh_mem + BANK3); 518 519 if (dev->l2_state == L2_STARTING || dev->l2_state == L2_ERROR) { 520 pcbit_l2_active_conf(dev, info); 521 dev->interrupt = 0; 522 return IRQ_HANDLED; 523 } 524 if (info & 0x40U) { /* E bit set */ 525#ifdef DEBUG 526 printk(KERN_DEBUG "pcbit_irq_handler: E bit on\n"); 527#endif 528 pcbit_l2_error(dev); 529 dev->interrupt = 0; 530 return IRQ_HANDLED; 531 } 532 if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) { 533 dev->interrupt = 0; 534 return IRQ_HANDLED; 535 } 536 ack_seq = (info >> 3) & 0x07U; 537 read_seq = (info & 0x07U); 538 539 dev->interrupt = 0; 540 541 if (read_seq != dev->rcv_seq) { 542 while (read_seq != dev->rcv_seq) { 543 pcbit_receive(dev); 544 dev->rcv_seq = (dev->rcv_seq + 1) % 8; 545 } 546 pcbit_sched_delivery(dev); 547 } 548 if (ack_seq != dev->unack_seq) { 549 pcbit_recv_ack(dev, ack_seq); 550 } 551 info = dev->rcv_seq << 3; 552 info |= dev->send_seq; 553 554 writeb(info, dev->sh_mem + BANK4); 555 return IRQ_HANDLED; 556} 557 558 559static void 560pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info) 561{ 562 u_char state; 563 564 state = dev->l2_state; 565 566#ifdef DEBUG 567 printk(KERN_DEBUG "layer2_active_confirm\n"); 568#endif 569 570 571 if (info & 0x80U) { 572 dev->rcv_seq = info & 0x07U; 573 dev->l2_state = L2_RUNNING; 574 } else 575 dev->l2_state = L2_DOWN; 576 577 if (state == L2_STARTING) 578 wake_up_interruptible(&dev->set_running_wq); 579 580 if (state == L2_ERROR && dev->l2_state == L2_RUNNING) { 581 pcbit_transmit(dev); 582 } 583} 584 585static void 586pcbit_l2_err_recover(unsigned long data) 587{ 588 589 struct pcbit_dev *dev; 590 struct frame_buf *frame; 591 592 dev = (struct pcbit_dev *) data; 593 594 del_timer(&dev->error_recover_timer); 595 if (dev->w_busy || dev->r_busy) { 596 init_timer(&dev->error_recover_timer); 597 dev->error_recover_timer.expires = jiffies + ERRTIME; 598 add_timer(&dev->error_recover_timer); 599 return; 600 } 601 dev->w_busy = dev->r_busy = 1; 602 603 if (dev->read_frame) { 604 if (dev->read_frame->skb) 605 kfree_skb(dev->read_frame->skb); 606 kfree(dev->read_frame); 607 dev->read_frame = NULL; 608 } 609 if (dev->write_queue) { 610 frame = dev->write_queue; 611#ifdef FREE_ON_ERROR 612 dev->write_queue = dev->write_queue->next; 613 614 if (frame->skb) { 615 dev_kfree_skb(frame->skb); 616 } 617 kfree(frame); 618#else 619 frame->copied = 0; 620#endif 621 } 622 dev->rcv_seq = dev->send_seq = dev->unack_seq = 0; 623 dev->free = 511; 624 dev->l2_state = L2_ERROR; 625 626 /* this is an hack... */ 627 pcbit_firmware_bug(dev); 628 629 dev->writeptr = dev->sh_mem; 630 dev->readptr = dev->sh_mem + BANK2; 631 632 writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)), 633 dev->sh_mem + BANK4); 634 dev->w_busy = dev->r_busy = 0; 635 636} 637 638static void 639pcbit_l2_error(struct pcbit_dev *dev) 640{ 641 if (dev->l2_state == L2_RUNNING) { 642 643 printk(KERN_INFO "pcbit: layer 2 error\n"); 644 645#ifdef DEBUG 646 log_state(dev); 647#endif 648 649 dev->l2_state = L2_DOWN; 650 651 init_timer(&dev->error_recover_timer); 652 dev->error_recover_timer.function = &pcbit_l2_err_recover; 653 dev->error_recover_timer.data = (ulong) dev; 654 dev->error_recover_timer.expires = jiffies + ERRTIME; 655 add_timer(&dev->error_recover_timer); 656 } 657} 658 659/* 660 * Description: 661 * if board acks frames 662 * update dev->free 663 * call pcbit_transmit to write possible queued frames 664 */ 665 666static void 667pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack) 668{ 669 int i, 670 count; 671 int unacked; 672 673 unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07; 674 675 /* dev->unack_seq < ack <= dev->send_seq; */ 676 677 if (unacked) { 678 679 if (dev->send_seq > dev->unack_seq) { 680 if (ack <= dev->unack_seq || ack > dev->send_seq) { 681 printk(KERN_DEBUG 682 "layer 2 ack unacceptable - dev %d", 683 dev->id); 684 685 pcbit_l2_error(dev); 686 } else if (ack > dev->send_seq && ack <= dev->unack_seq) { 687 printk(KERN_DEBUG 688 "layer 2 ack unacceptable - dev %d", 689 dev->id); 690 pcbit_l2_error(dev); 691 } 692 } 693 /* ack is acceptable */ 694 695 696 i = dev->unack_seq; 697 698 do { 699 dev->unack_seq = i = (i + 1) % 8; 700 dev->free += dev->fsize[i]; 701 } while (i != ack); 702 703 count = 0; 704 while (count < 7 && dev->write_queue) { 705 u8 lsend_seq = dev->send_seq; 706 707 pcbit_transmit(dev); 708 709 if (dev->send_seq == lsend_seq) 710 break; 711 count++; 712 } 713 } else 714 printk(KERN_DEBUG "recv_ack: unacked = 0\n"); 715} 716