| /* |
| * PCBIT-D low-layer interface |
| * |
| * Copyright (C) 1996 Universidade de Lisboa |
| * |
| * Written by Pedro Roque Marques (roque@di.fc.ul.pt) |
| * |
| * This software may be used and distributed according to the terms of |
| * the GNU General Public License, incorporated herein by reference. |
| */ |
| |
| /* |
| * 19991203 - Fernando Carvalho - takion@superbofh.org |
| * Hacked to compile with egcs and run with current version of isdn modules |
| */ |
| |
| /* |
| * Based on documentation provided by Inesc: |
| * - "Interface com bus do PC para o PCBIT e PCBIT-D", Inesc, Jan 93 |
| */ |
| |
| /* |
| * TODO: better handling of errors |
| * re-write/remove debug printks |
| */ |
| |
| #include <linux/string.h> |
| #include <linux/kernel.h> |
| #include <linux/types.h> |
| #include <linux/sched.h> |
| #include <linux/slab.h> |
| #include <linux/interrupt.h> |
| #include <linux/workqueue.h> |
| #include <linux/mm.h> |
| #include <linux/skbuff.h> |
| |
| #include <linux/isdnif.h> |
| |
| #include <asm/system.h> |
| #include <asm/io.h> |
| |
| |
| #include "pcbit.h" |
| #include "layer2.h" |
| #include "edss1.h" |
| |
| #undef DEBUG_FRAG |
| |
| |
| /* |
| * Prototypes |
| */ |
| |
| static void pcbit_transmit(struct pcbit_dev *dev); |
| |
| static void pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack); |
| |
| static void pcbit_l2_error(struct pcbit_dev *dev); |
| static void pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info); |
| static void pcbit_l2_err_recover(unsigned long data); |
| |
| static void pcbit_firmware_bug(struct pcbit_dev *dev); |
| |
| static __inline__ void |
| pcbit_sched_delivery(struct pcbit_dev *dev) |
| { |
| schedule_work(&dev->qdelivery); |
| } |
| |
| |
| /* |
| * Called from layer3 |
| */ |
| |
| int |
| pcbit_l2_write(struct pcbit_dev *dev, ulong msg, ushort refnum, |
| struct sk_buff *skb, unsigned short hdr_len) |
| { |
| struct frame_buf *frame, |
| *ptr; |
| unsigned long flags; |
| |
| if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) { |
| dev_kfree_skb(skb); |
| return -1; |
| } |
| if ((frame = kmalloc(sizeof(struct frame_buf), |
| GFP_ATOMIC)) == NULL) { |
| printk(KERN_WARNING "pcbit_2_write: kmalloc failed\n"); |
| dev_kfree_skb(skb); |
| return -1; |
| } |
| frame->msg = msg; |
| frame->refnum = refnum; |
| frame->copied = 0; |
| frame->hdr_len = hdr_len; |
| |
| if (skb) |
| frame->dt_len = skb->len - hdr_len; |
| else |
| frame->dt_len = 0; |
| |
| frame->skb = skb; |
| |
| frame->next = NULL; |
| |
| spin_lock_irqsave(&dev->lock, flags); |
| |
| if (dev->write_queue == NULL) { |
| dev->write_queue = frame; |
| spin_unlock_irqrestore(&dev->lock, flags); |
| pcbit_transmit(dev); |
| } else { |
| for (ptr = dev->write_queue; ptr->next; ptr = ptr->next); |
| ptr->next = frame; |
| |
| spin_unlock_irqrestore(&dev->lock, flags); |
| } |
| return 0; |
| } |
| |
| static __inline__ void |
| pcbit_tx_update(struct pcbit_dev *dev, ushort len) |
| { |
| u_char info; |
| |
| dev->send_seq = (dev->send_seq + 1) % 8; |
| |
| dev->fsize[dev->send_seq] = len; |
| info = 0; |
| info |= dev->rcv_seq << 3; |
| info |= dev->send_seq; |
| |
| writeb(info, dev->sh_mem + BANK4); |
| |
| } |
| |
| /* |
| * called by interrupt service routine or by write_2 |
| */ |
| |
| static void |
| pcbit_transmit(struct pcbit_dev *dev) |
| { |
| struct frame_buf *frame = NULL; |
| unsigned char unacked; |
| int flen; /* fragment frame length including all headers */ |
| int free; |
| int count, |
| cp_len; |
| unsigned long flags; |
| unsigned short tt; |
| |
| if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) |
| return; |
| |
| unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07; |
| |
| spin_lock_irqsave(&dev->lock, flags); |
| |
| if (dev->free > 16 && dev->write_queue && unacked < 7) { |
| |
| if (!dev->w_busy) |
| dev->w_busy = 1; |
| else { |
| spin_unlock_irqrestore(&dev->lock, flags); |
| return; |
| } |
| |
| |
| frame = dev->write_queue; |
| free = dev->free; |
| |
| spin_unlock_irqrestore(&dev->lock, flags); |
| |
| if (frame->copied == 0) { |
| |
| /* Type 0 frame */ |
| |
| ulong msg; |
| |
| if (frame->skb) |
| flen = FRAME_HDR_LEN + PREHDR_LEN + frame->skb->len; |
| else |
| flen = FRAME_HDR_LEN + PREHDR_LEN; |
| |
| if (flen > free) |
| flen = free; |
| |
| msg = frame->msg; |
| |
| /* |
| * Board level 2 header |
| */ |
| |
| pcbit_writew(dev, flen - FRAME_HDR_LEN); |
| |
| pcbit_writeb(dev, GET_MSG_CPU(msg)); |
| |
| pcbit_writeb(dev, GET_MSG_PROC(msg)); |
| |
| /* TH */ |
| pcbit_writew(dev, frame->hdr_len + PREHDR_LEN); |
| |
| /* TD */ |
| pcbit_writew(dev, frame->dt_len); |
| |
| |
| /* |
| * Board level 3 fixed-header |
| */ |
| |
| /* LEN = TH */ |
| pcbit_writew(dev, frame->hdr_len + PREHDR_LEN); |
| |
| /* XX */ |
| pcbit_writew(dev, 0); |
| |
| /* C + S */ |
| pcbit_writeb(dev, GET_MSG_CMD(msg)); |
| pcbit_writeb(dev, GET_MSG_SCMD(msg)); |
| |
| /* NUM */ |
| pcbit_writew(dev, frame->refnum); |
| |
| count = FRAME_HDR_LEN + PREHDR_LEN; |
| } else { |
| /* Type 1 frame */ |
| |
| flen = 2 + (frame->skb->len - frame->copied); |
| |
| if (flen > free) |
| flen = free; |
| |
| /* TT */ |
| tt = ((ushort) (flen - 2)) | 0x8000U; /* Type 1 */ |
| pcbit_writew(dev, tt); |
| |
| count = 2; |
| } |
| |
| if (frame->skb) { |
| cp_len = frame->skb->len - frame->copied; |
| if (cp_len > flen - count) |
| cp_len = flen - count; |
| |
| memcpy_topcbit(dev, frame->skb->data + frame->copied, |
| cp_len); |
| frame->copied += cp_len; |
| } |
| /* bookkeeping */ |
| dev->free -= flen; |
| pcbit_tx_update(dev, flen); |
| |
| spin_lock_irqsave(&dev->lock, flags); |
| |
| if (frame->skb == NULL || frame->copied == frame->skb->len) { |
| |
| dev->write_queue = frame->next; |
| |
| if (frame->skb != NULL) { |
| /* free frame */ |
| dev_kfree_skb(frame->skb); |
| } |
| kfree(frame); |
| } |
| dev->w_busy = 0; |
| spin_unlock_irqrestore(&dev->lock, flags); |
| } else { |
| spin_unlock_irqrestore(&dev->lock, flags); |
| #ifdef DEBUG |
| printk(KERN_DEBUG "unacked %d free %d write_queue %s\n", |
| unacked, dev->free, dev->write_queue ? "not empty" : |
| "empty"); |
| #endif |
| } |
| } |
| |
| |
| /* |
| * deliver a queued frame to the upper layer |
| */ |
| |
| void |
| pcbit_deliver(struct work_struct *work) |
| { |
| struct frame_buf *frame; |
| unsigned long flags, msg; |
| struct pcbit_dev *dev = |
| container_of(work, struct pcbit_dev, qdelivery); |
| |
| spin_lock_irqsave(&dev->lock, flags); |
| |
| while ((frame = dev->read_queue)) { |
| dev->read_queue = frame->next; |
| spin_unlock_irqrestore(&dev->lock, flags); |
| |
| msg = 0; |
| SET_MSG_CPU(msg, 0); |
| SET_MSG_PROC(msg, 0); |
| SET_MSG_CMD(msg, frame->skb->data[2]); |
| SET_MSG_SCMD(msg, frame->skb->data[3]); |
| |
| frame->refnum = *((ushort *) frame->skb->data + 4); |
| frame->msg = *((ulong *) & msg); |
| |
| skb_pull(frame->skb, 6); |
| |
| pcbit_l3_receive(dev, frame->msg, frame->skb, frame->hdr_len, |
| frame->refnum); |
| |
| kfree(frame); |
| |
| spin_lock_irqsave(&dev->lock, flags); |
| } |
| |
| spin_unlock_irqrestore(&dev->lock, flags); |
| } |
| |
| /* |
| * Reads BANK 2 & Reassembles |
| */ |
| |
| static void |
| pcbit_receive(struct pcbit_dev *dev) |
| { |
| unsigned short tt; |
| u_char cpu, |
| proc; |
| struct frame_buf *frame = NULL; |
| unsigned long flags; |
| u_char type1; |
| |
| if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) |
| return; |
| |
| tt = pcbit_readw(dev); |
| |
| if ((tt & 0x7fffU) > 511) { |
| printk(KERN_INFO "pcbit: invalid frame length -> TT=%04x\n", |
| tt); |
| pcbit_l2_error(dev); |
| return; |
| } |
| if (!(tt & 0x8000U)) { /* Type 0 */ |
| type1 = 0; |
| |
| if (dev->read_frame) { |
| printk(KERN_DEBUG "pcbit_receive: Type 0 frame and read_frame != NULL\n"); |
| /* discard previous queued frame */ |
| kfree_skb(dev->read_frame->skb); |
| kfree(dev->read_frame); |
| dev->read_frame = NULL; |
| } |
| frame = kzalloc(sizeof(struct frame_buf), GFP_ATOMIC); |
| |
| if (frame == NULL) { |
| printk(KERN_WARNING "kmalloc failed\n"); |
| return; |
| } |
| |
| cpu = pcbit_readb(dev); |
| proc = pcbit_readb(dev); |
| |
| |
| if (cpu != 0x06 && cpu != 0x02) { |
| printk(KERN_DEBUG "pcbit: invalid cpu value\n"); |
| kfree(frame); |
| pcbit_l2_error(dev); |
| return; |
| } |
| /* |
| * we discard cpu & proc on receiving |
| * but we read it to update the pointer |
| */ |
| |
| frame->hdr_len = pcbit_readw(dev); |
| frame->dt_len = pcbit_readw(dev); |
| |
| /* |
| * 0 sized packet |
| * I don't know if they are an error or not... |
| * But they are very frequent |
| * Not documented |
| */ |
| |
| if (frame->hdr_len == 0) { |
| kfree(frame); |
| #ifdef DEBUG |
| printk(KERN_DEBUG "0 sized frame\n"); |
| #endif |
| pcbit_firmware_bug(dev); |
| return; |
| } |
| /* sanity check the length values */ |
| if (frame->hdr_len > 1024 || frame->dt_len > 2048) { |
| #ifdef DEBUG |
| printk(KERN_DEBUG "length problem: "); |
| printk(KERN_DEBUG "TH=%04x TD=%04x\n", |
| frame->hdr_len, |
| frame->dt_len); |
| #endif |
| pcbit_l2_error(dev); |
| kfree(frame); |
| return; |
| } |
| /* minimum frame read */ |
| |
| frame->skb = dev_alloc_skb(frame->hdr_len + frame->dt_len + |
| ((frame->hdr_len + 15) & ~15)); |
| |
| if (!frame->skb) { |
| printk(KERN_DEBUG "pcbit_receive: out of memory\n"); |
| kfree(frame); |
| return; |
| } |
| /* 16 byte alignment for IP */ |
| if (frame->dt_len) |
| skb_reserve(frame->skb, (frame->hdr_len + 15) & ~15); |
| |
| } else { |
| /* Type 1 */ |
| type1 = 1; |
| tt &= 0x7fffU; |
| |
| if (!(frame = dev->read_frame)) { |
| printk("Type 1 frame and no frame queued\n"); |
| /* usually after an error: toss frame */ |
| dev->readptr += tt; |
| if (dev->readptr > dev->sh_mem + BANK2 + BANKLEN) |
| dev->readptr -= BANKLEN; |
| return; |
| |
| } |
| } |
| |
| memcpy_frompcbit(dev, skb_put(frame->skb, tt), tt); |
| |
| frame->copied += tt; |
| spin_lock_irqsave(&dev->lock, flags); |
| if (frame->copied == frame->hdr_len + frame->dt_len) { |
| |
| if (type1) { |
| dev->read_frame = NULL; |
| } |
| if (dev->read_queue) { |
| struct frame_buf *ptr; |
| for (ptr = dev->read_queue; ptr->next; ptr = ptr->next); |
| ptr->next = frame; |
| } else |
| dev->read_queue = frame; |
| |
| } else { |
| dev->read_frame = frame; |
| } |
| spin_unlock_irqrestore(&dev->lock, flags); |
| } |
| |
| /* |
| * The board sends 0 sized frames |
| * They are TDATA_CONFs that get messed up somehow |
| * gotta send a fake acknowledgment to the upper layer somehow |
| */ |
| |
| static __inline__ void |
| pcbit_fake_conf(struct pcbit_dev *dev, struct pcbit_chan *chan) |
| { |
| isdn_ctrl ictl; |
| |
| if (chan->queued) { |
| chan->queued--; |
| |
| ictl.driver = dev->id; |
| ictl.command = ISDN_STAT_BSENT; |
| ictl.arg = chan->id; |
| dev->dev_if->statcallb(&ictl); |
| } |
| } |
| |
| static void |
| pcbit_firmware_bug(struct pcbit_dev *dev) |
| { |
| struct pcbit_chan *chan; |
| |
| chan = dev->b1; |
| |
| if (chan->fsm_state == ST_ACTIVE) { |
| pcbit_fake_conf(dev, chan); |
| } |
| chan = dev->b2; |
| |
| if (chan->fsm_state == ST_ACTIVE) { |
| pcbit_fake_conf(dev, chan); |
| } |
| } |
| |
| irqreturn_t |
| pcbit_irq_handler(int interrupt, void *devptr) |
| { |
| struct pcbit_dev *dev; |
| u_char info, |
| ack_seq, |
| read_seq; |
| |
| dev = (struct pcbit_dev *) devptr; |
| |
| if (!dev) { |
| printk(KERN_WARNING "pcbit_irq_handler: wrong device\n"); |
| return IRQ_NONE; |
| } |
| if (dev->interrupt) { |
| printk(KERN_DEBUG "pcbit: reentering interrupt hander\n"); |
| return IRQ_HANDLED; |
| } |
| dev->interrupt = 1; |
| |
| info = readb(dev->sh_mem + BANK3); |
| |
| if (dev->l2_state == L2_STARTING || dev->l2_state == L2_ERROR) { |
| pcbit_l2_active_conf(dev, info); |
| dev->interrupt = 0; |
| return IRQ_HANDLED; |
| } |
| if (info & 0x40U) { /* E bit set */ |
| #ifdef DEBUG |
| printk(KERN_DEBUG "pcbit_irq_handler: E bit on\n"); |
| #endif |
| pcbit_l2_error(dev); |
| dev->interrupt = 0; |
| return IRQ_HANDLED; |
| } |
| if (dev->l2_state != L2_RUNNING && dev->l2_state != L2_LOADING) { |
| dev->interrupt = 0; |
| return IRQ_HANDLED; |
| } |
| ack_seq = (info >> 3) & 0x07U; |
| read_seq = (info & 0x07U); |
| |
| dev->interrupt = 0; |
| |
| if (read_seq != dev->rcv_seq) { |
| while (read_seq != dev->rcv_seq) { |
| pcbit_receive(dev); |
| dev->rcv_seq = (dev->rcv_seq + 1) % 8; |
| } |
| pcbit_sched_delivery(dev); |
| } |
| if (ack_seq != dev->unack_seq) { |
| pcbit_recv_ack(dev, ack_seq); |
| } |
| info = dev->rcv_seq << 3; |
| info |= dev->send_seq; |
| |
| writeb(info, dev->sh_mem + BANK4); |
| return IRQ_HANDLED; |
| } |
| |
| |
| static void |
| pcbit_l2_active_conf(struct pcbit_dev *dev, u_char info) |
| { |
| u_char state; |
| |
| state = dev->l2_state; |
| |
| #ifdef DEBUG |
| printk(KERN_DEBUG "layer2_active_confirm\n"); |
| #endif |
| |
| |
| if (info & 0x80U) { |
| dev->rcv_seq = info & 0x07U; |
| dev->l2_state = L2_RUNNING; |
| } else |
| dev->l2_state = L2_DOWN; |
| |
| if (state == L2_STARTING) |
| wake_up_interruptible(&dev->set_running_wq); |
| |
| if (state == L2_ERROR && dev->l2_state == L2_RUNNING) { |
| pcbit_transmit(dev); |
| } |
| } |
| |
| static void |
| pcbit_l2_err_recover(unsigned long data) |
| { |
| |
| struct pcbit_dev *dev; |
| struct frame_buf *frame; |
| |
| dev = (struct pcbit_dev *) data; |
| |
| del_timer(&dev->error_recover_timer); |
| if (dev->w_busy || dev->r_busy) { |
| init_timer(&dev->error_recover_timer); |
| dev->error_recover_timer.expires = jiffies + ERRTIME; |
| add_timer(&dev->error_recover_timer); |
| return; |
| } |
| dev->w_busy = dev->r_busy = 1; |
| |
| if (dev->read_frame) { |
| kfree_skb(dev->read_frame->skb); |
| kfree(dev->read_frame); |
| dev->read_frame = NULL; |
| } |
| if (dev->write_queue) { |
| frame = dev->write_queue; |
| #ifdef FREE_ON_ERROR |
| dev->write_queue = dev->write_queue->next; |
| |
| if (frame->skb) { |
| dev_kfree_skb(frame->skb); |
| } |
| kfree(frame); |
| #else |
| frame->copied = 0; |
| #endif |
| } |
| dev->rcv_seq = dev->send_seq = dev->unack_seq = 0; |
| dev->free = 511; |
| dev->l2_state = L2_ERROR; |
| |
| /* this is an hack... */ |
| pcbit_firmware_bug(dev); |
| |
| dev->writeptr = dev->sh_mem; |
| dev->readptr = dev->sh_mem + BANK2; |
| |
| writeb((0x80U | ((dev->rcv_seq & 0x07) << 3) | (dev->send_seq & 0x07)), |
| dev->sh_mem + BANK4); |
| dev->w_busy = dev->r_busy = 0; |
| |
| } |
| |
| static void |
| pcbit_l2_error(struct pcbit_dev *dev) |
| { |
| if (dev->l2_state == L2_RUNNING) { |
| |
| printk(KERN_INFO "pcbit: layer 2 error\n"); |
| |
| #ifdef DEBUG |
| log_state(dev); |
| #endif |
| |
| dev->l2_state = L2_DOWN; |
| |
| init_timer(&dev->error_recover_timer); |
| dev->error_recover_timer.function = &pcbit_l2_err_recover; |
| dev->error_recover_timer.data = (ulong) dev; |
| dev->error_recover_timer.expires = jiffies + ERRTIME; |
| add_timer(&dev->error_recover_timer); |
| } |
| } |
| |
| /* |
| * Description: |
| * if board acks frames |
| * update dev->free |
| * call pcbit_transmit to write possible queued frames |
| */ |
| |
| static void |
| pcbit_recv_ack(struct pcbit_dev *dev, unsigned char ack) |
| { |
| int i, |
| count; |
| int unacked; |
| |
| unacked = (dev->send_seq + (8 - dev->unack_seq)) & 0x07; |
| |
| /* dev->unack_seq < ack <= dev->send_seq; */ |
| |
| if (unacked) { |
| |
| if (dev->send_seq > dev->unack_seq) { |
| if (ack <= dev->unack_seq || ack > dev->send_seq) { |
| printk(KERN_DEBUG |
| "layer 2 ack unacceptable - dev %d", |
| dev->id); |
| |
| pcbit_l2_error(dev); |
| } else if (ack > dev->send_seq && ack <= dev->unack_seq) { |
| printk(KERN_DEBUG |
| "layer 2 ack unacceptable - dev %d", |
| dev->id); |
| pcbit_l2_error(dev); |
| } |
| } |
| /* ack is acceptable */ |
| |
| |
| i = dev->unack_seq; |
| |
| do { |
| dev->unack_seq = i = (i + 1) % 8; |
| dev->free += dev->fsize[i]; |
| } while (i != ack); |
| |
| count = 0; |
| while (count < 7 && dev->write_queue) { |
| u8 lsend_seq = dev->send_seq; |
| |
| pcbit_transmit(dev); |
| |
| if (dev->send_seq == lsend_seq) |
| break; |
| count++; |
| } |
| } else |
| printk(KERN_DEBUG "recv_ack: unacked = 0\n"); |
| } |