/********************************************************************* * * Filename: wrapper.c * Version: 1.2 * Description: IrDA SIR async wrapper layer * Status: Stable * Author: Dag Brattli <dagb@cs.uit.no> * Created at: Mon Aug 4 20:40:53 1997 * Modified at: Fri Jan 28 13:21:09 2000 * Modified by: Dag Brattli <dagb@cs.uit.no> * Modified at: Fri May 28 3:11 CST 1999 * Modified by: Horst von Brand <vonbrand@sleipnir.valparaiso.cl> * * Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>, * All Rights Reserved. * Copyright (c) 2000-2002 Jean Tourrilhes <jt@hpl.hp.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of * the License, or (at your option) any later version. * * Neither Dag Brattli nor University of Tromsø admit liability nor * provide warranty for any of this software. This material is * provided "AS-IS" and at no charge. * ********************************************************************/ #include <linux/skbuff.h> #include <linux/string.h> #include <linux/module.h> #include <asm/byteorder.h> #include <net/irda/irda.h> #include <net/irda/wrapper.h> #include <net/irda/crc.h> #include <net/irda/irlap.h> #include <net/irda/irlap_frame.h> #include <net/irda/irda_device.h> /************************** FRAME WRAPPING **************************/ /* * Unwrap and unstuff SIR frames * * Note : at FIR and MIR, HDLC framing is used and usually handled * by the controller, so we come here only for SIR... Jean II */ /* * Function stuff_byte (byte, buf) * * Byte stuff one single byte and put the result in buffer pointed to by * buf. The buffer must at all times be able to have two bytes inserted. * * This is in a tight loop, better inline it, so need to be prior to callers. * (2000 bytes on P6 200MHz, non-inlined ~370us, inline ~170us) - Jean II */ static inline int stuff_byte(__u8 byte, __u8 *buf) { switch (byte) { case BOF: /* FALLTHROUGH */ case EOF: /* FALLTHROUGH */ case CE: /* Insert transparently coded */ buf[0] = CE; /* Send link escape */ buf[1] = byte^IRDA_TRANS; /* Complement bit 5 */ return 2; /* break; */ default: /* Non-special value, no transparency required */ buf[0] = byte; return 1; /* break; */ } } /* * Function async_wrap (skb, *tx_buff, buffsize) * * Makes a new buffer with wrapping and stuffing, should check that * we don't get tx buffer overflow. */ int async_wrap_skb(struct sk_buff *skb, __u8 *tx_buff, int buffsize) { struct irda_skb_cb *cb = (struct irda_skb_cb *) skb->cb; int xbofs; int i; int n; union { __u16 value; __u8 bytes[2]; } fcs; /* Initialize variables */ fcs.value = INIT_FCS; n = 0; /* * Send XBOF's for required min. turn time and for the negotiated * additional XBOFS */ if (cb->magic != LAP_MAGIC) { /* * This will happen for all frames sent from user-space. * Nothing to worry about, but we set the default number of * BOF's */ IRDA_DEBUG(1, "%s(), wrong magic in skb!\n", __func__); xbofs = 10; } else xbofs = cb->xbofs + cb->xbofs_delay; IRDA_DEBUG(4, "%s(), xbofs=%d\n", __func__, xbofs); /* Check that we never use more than 115 + 48 xbofs */ if (xbofs > 163) { IRDA_DEBUG(0, "%s(), too many xbofs (%d)\n", __func__, xbofs); xbofs = 163; } memset(tx_buff + n, XBOF, xbofs); n += xbofs; /* Start of packet character BOF */ tx_buff[n++] = BOF; /* Insert frame and calc CRC */ for (i=0; i < skb->len; i++) { /* * Check for the possibility of tx buffer overflow. We use * bufsize-5 since the maximum number of bytes that can be * transmitted after this point is 5. */ if(n >= (buffsize-5)) { IRDA_ERROR("%s(), tx buffer overflow (n=%d)\n", __func__, n); return n; } n += stuff_byte(skb->data[i], tx_buff+n); fcs.value = irda_fcs(fcs.value, skb->data[i]); } /* Insert CRC in little endian format (LSB first) */ fcs.value = ~fcs.value; #ifdef __LITTLE_ENDIAN n += stuff_byte(fcs.bytes[0], tx_buff+n); n += stuff_byte(fcs.bytes[1], tx_buff+n); #else /* ifdef __BIG_ENDIAN */ n += stuff_byte(fcs.bytes[1], tx_buff+n); n += stuff_byte(fcs.bytes[0], tx_buff+n); #endif tx_buff[n++] = EOF; return n; } EXPORT_SYMBOL(async_wrap_skb); /************************* FRAME UNWRAPPING *************************/ /* * Unwrap and unstuff SIR frames * * Complete rewrite by Jean II : * More inline, faster, more compact, more logical. Jean II * (16 bytes on P6 200MHz, old 5 to 7 us, new 4 to 6 us) * (24 bytes on P6 200MHz, old 9 to 10 us, new 7 to 8 us) * (for reference, 115200 b/s is 1 byte every 69 us) * And reduce wrapper.o by ~900B in the process ;-) * * Then, we have the addition of ZeroCopy, which is optional * (i.e. the driver must initiate it) and improve final processing. * (2005 B frame + EOF on P6 200MHz, without 30 to 50 us, with 10 to 25 us) * * Note : at FIR and MIR, HDLC framing is used and usually handled * by the controller, so we come here only for SIR... Jean II */ /* * We can also choose where we want to do the CRC calculation. We can * do it "inline", as we receive the bytes, or "postponed", when * receiving the End-Of-Frame. * (16 bytes on P6 200MHz, inlined 4 to 6 us, postponed 4 to 5 us) * (24 bytes on P6 200MHz, inlined 7 to 8 us, postponed 5 to 7 us) * With ZeroCopy : * (2005 B frame on P6 200MHz, inlined 10 to 25 us, postponed 140 to 180 us) * Without ZeroCopy : * (2005 B frame on P6 200MHz, inlined 30 to 50 us, postponed 150 to 180 us) * (Note : numbers taken with irq disabled) * * From those numbers, it's not clear which is the best strategy, because * we end up running through a lot of data one way or another (i.e. cache * misses). I personally prefer to avoid the huge latency spike of the * "postponed" solution, because it come just at the time when we have * lot's of protocol processing to do and it will hurt our ability to * reach low link turnaround times... Jean II */ //#define POSTPONE_RX_CRC /* * Function async_bump (buf, len, stats) * * Got a frame, make a copy of it, and pass it up the stack! We can try * to inline it since it's only called from state_inside_frame */ static inline void async_bump(struct net_device *dev, struct net_device_stats *stats, iobuff_t *rx_buff) { struct sk_buff *newskb; struct sk_buff *dataskb; int docopy; /* Check if we need to copy the data to a new skb or not. * If the driver doesn't use ZeroCopy Rx, we have to do it. * With ZeroCopy Rx, the rx_buff already point to a valid * skb. But, if the frame is small, it is more efficient to * copy it to save memory (copy will be fast anyway - that's * called Rx-copy-break). Jean II */ docopy = ((rx_buff->skb == NULL) || (rx_buff->len < IRDA_RX_COPY_THRESHOLD)); /* Allocate a new skb */ newskb = dev_alloc_skb(docopy ? rx_buff->len + 1 : rx_buff->truesize); if (!newskb) { stats->rx_dropped++; /* We could deliver the current skb if doing ZeroCopy Rx, * but this would stall the Rx path. Better drop the * packet... Jean II */ return; } /* Align IP header to 20 bytes (i.e. increase skb->data) * Note this is only useful with IrLAN, as PPP has a variable * header size (2 or 1 bytes) - Jean II */ skb_reserve(newskb, 1); if(docopy) { /* Copy data without CRC (length already checked) */ skb_copy_to_linear_data(newskb, rx_buff->data, rx_buff->len - 2); /* Deliver this skb */ dataskb = newskb; } else { /* We are using ZeroCopy. Deliver old skb */ dataskb = rx_buff->skb; /* And hook the new skb to the rx_buff */ rx_buff->skb = newskb; rx_buff->head = newskb->data; /* NOT newskb->head */ //printk(KERN_DEBUG "ZeroCopy : len = %d, dataskb = %p, newskb = %p\n", rx_buff->len, dataskb, newskb); } /* Set proper length on skb (without CRC) */ skb_put(dataskb, rx_buff->len - 2); /* Feed it to IrLAP layer */ dataskb->dev = dev; skb_reset_mac_header(dataskb); dataskb->protocol = htons(ETH_P_IRDA); netif_rx(dataskb); stats->rx_packets++; stats->rx_bytes += rx_buff->len; /* Clean up rx_buff (redundant with async_unwrap_bof() ???) */ rx_buff->data = rx_buff->head; rx_buff->len = 0; } /* * Function async_unwrap_bof(dev, byte) * * Handle Beginning Of Frame character received within a frame * */ static inline void async_unwrap_bof(struct net_device *dev, struct net_device_stats *stats, iobuff_t *rx_buff, __u8 byte) { switch(rx_buff->state) { case LINK_ESCAPE: case INSIDE_FRAME: /* Not supposed to happen, the previous frame is not * finished - Jean II */ IRDA_DEBUG(1, "%s(), Discarding incomplete frame\n", __func__); stats->rx_errors++; stats->rx_missed_errors++; irda_device_set_media_busy(dev, TRUE); break; case OUTSIDE_FRAME: case BEGIN_FRAME: default: /* We may receive multiple BOF at the start of frame */ break; } /* Now receiving frame */ rx_buff->state = BEGIN_FRAME; rx_buff->in_frame = TRUE; /* Time to initialize receive buffer */ rx_buff->data = rx_buff->head; rx_buff->len = 0; rx_buff->fcs = INIT_FCS; } /* * Function async_unwrap_eof(dev, byte) * * Handle End Of Frame character received within a frame * */ static inline void async_unwrap_eof(struct net_device *dev, struct net_device_stats *stats, iobuff_t *rx_buff, __u8 byte) { #ifdef POSTPONE_RX_CRC int i; #endif switch(rx_buff->state) { case OUTSIDE_FRAME: /* Probably missed the BOF */ stats->rx_errors++; stats->rx_missed_errors++; irda_device_set_media_busy(dev, TRUE); break; case BEGIN_FRAME: case LINK_ESCAPE: case INSIDE_FRAME: default: /* Note : in the case of BEGIN_FRAME and LINK_ESCAPE, * the fcs will most likely not match and generate an * error, as expected - Jean II */ rx_buff->state = OUTSIDE_FRAME; rx_buff->in_frame = FALSE; #ifdef POSTPONE_RX_CRC /* If we haven't done the CRC as we receive bytes, we * must do it now... Jean II */ for(i = 0; i < rx_buff->len; i++) rx_buff->fcs = irda_fcs(rx_buff->fcs, rx_buff->data[i]); #endif /* Test FCS and signal success if the frame is good */ if (rx_buff->fcs == GOOD_FCS) { /* Deliver frame */ async_bump(dev, stats, rx_buff); break; } else { /* Wrong CRC, discard frame! */ irda_device_set_media_busy(dev, TRUE); IRDA_DEBUG(1, "%s(), crc error\n", __func__); stats->rx_errors++; stats->rx_crc_errors++; } break; } } /* * Function async_unwrap_ce(dev, byte) * * Handle Character Escape character received within a frame * */ static inline void async_unwrap_ce(struct net_device *dev, struct net_device_stats *stats, iobuff_t *rx_buff, __u8 byte) { switch(rx_buff->state) { case OUTSIDE_FRAME: /* Activate carrier sense */ irda_device_set_media_busy(dev, TRUE); break; case LINK_ESCAPE: IRDA_WARNING("%s: state not defined\n", __func__); break; case BEGIN_FRAME: case INSIDE_FRAME: default: /* Stuffed byte coming */ rx_buff->state = LINK_ESCAPE; break; } } /* * Function async_unwrap_other(dev, byte) * * Handle other characters received within a frame * */ static inline void async_unwrap_other(struct net_device *dev, struct net_device_stats *stats, iobuff_t *rx_buff, __u8 byte) { switch(rx_buff->state) { /* This is on the critical path, case are ordered by * probability (most frequent first) - Jean II */ case INSIDE_FRAME: /* Must be the next byte of the frame */ if (rx_buff->len < rx_buff->truesize) { rx_buff->data[rx_buff->len++] = byte; #ifndef POSTPONE_RX_CRC rx_buff->fcs = irda_fcs(rx_buff->fcs, byte); #endif } else { IRDA_DEBUG(1, "%s(), Rx buffer overflow, aborting\n", __func__); rx_buff->state = OUTSIDE_FRAME; } break; case LINK_ESCAPE: /* * Stuffed char, complement bit 5 of byte * following CE, IrLAP p.114 */ byte ^= IRDA_TRANS; if (rx_buff->len < rx_buff->truesize) { rx_buff->data[rx_buff->len++] = byte; #ifndef POSTPONE_RX_CRC rx_buff->fcs = irda_fcs(rx_buff->fcs, byte); #endif rx_buff->state = INSIDE_FRAME; } else { IRDA_DEBUG(1, "%s(), Rx buffer overflow, aborting\n", __func__); rx_buff->state = OUTSIDE_FRAME; } break; case OUTSIDE_FRAME: /* Activate carrier sense */ if(byte != XBOF) irda_device_set_media_busy(dev, TRUE); break; case BEGIN_FRAME: default: rx_buff->data[rx_buff->len++] = byte; #ifndef POSTPONE_RX_CRC rx_buff->fcs = irda_fcs(rx_buff->fcs, byte); #endif rx_buff->state = INSIDE_FRAME; break; } } /* * Function async_unwrap_char (dev, rx_buff, byte) * * Parse and de-stuff frame received from the IrDA-port * * This is the main entry point for SIR drivers. */ void async_unwrap_char(struct net_device *dev, struct net_device_stats *stats, iobuff_t *rx_buff, __u8 byte) { switch(byte) { case CE: async_unwrap_ce(dev, stats, rx_buff, byte); break; case BOF: async_unwrap_bof(dev, stats, rx_buff, byte); break; case EOF: async_unwrap_eof(dev, stats, rx_buff, byte); break; default: async_unwrap_other(dev, stats, rx_buff, byte); break; } } EXPORT_SYMBOL(async_unwrap_char);