drivers/staging/i4l/pcbit/layer2.c

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