diff -ruN linux/Documentation/Configure.help linux-patched/Documentation/Configure.help
--- linux/Documentation/Configure.help	Fri Oct 26 15:31:24 2001
+++ linux-patched/Documentation/Configure.help	Fri Oct 26 18:48:16 2001
@@ -11909,6 +11909,17 @@
   The module will be called rio500.o. If you want to compile it as
   a module, say M here and read Documentation/modules.txt.
 
+Alcatel Speedtouch USB support
+CONFIG_USB_SPEEDTOUCH
+  Say Y here if you want to use an Alcatel Speedtouch USB modem.
+  This device requires userspace support, availble from the 
+  Alcatel site (http:/www.alcateldsl.com).
+
+  This code is also available as a module ( = code which can be
+  inserted in and removed from the running kernel whenever you want).
+  The module will be called speedtch.o. If you want to compile it as
+  a module, say M here and read Documentation/modules.txt.
+
 D-Link DSB-R100 FM radio support
 CONFIG_USB_DSBR
   Say Y here if you want to connect this type of radio to your
diff -ruN linux/drivers/usb/Config.in linux-patched/drivers/usb/Config.in
--- linux/drivers/usb/Config.in	Fri Oct 26 15:47:59 2001
+++ linux-patched/drivers/usb/Config.in	Fri Oct 26 18:48:16 2001
@@ -94,5 +94,6 @@
 
 comment 'USB Miscellaneous drivers'
 dep_tristate '  USB Diamond Rio500 support (EXPERIMENTAL)' CONFIG_USB_RIO500 $CONFIG_USB $CONFIG_EXPERIMENTAL
+dep_tristate '  Alcatel Speedtouch USB support (EXPERIMENTAL)' CONFIG_USB_SPEEDTOUCH $CONFIG_USB $CONFIG_EXPERIMENTAL
 
 endmenu
diff -ruN linux/drivers/usb/Makefile linux-patched/drivers/usb/Makefile
--- linux/drivers/usb/Makefile	Sat Oct 13 20:47:28 2001
+++ linux-patched/drivers/usb/Makefile	Fri Oct 26 18:48:16 2001
@@ -77,6 +77,7 @@
 obj-$(CONFIG_USB_HPUSBSCSI)	+= hpusbscsi.o
 obj-$(CONFIG_USB_BLUETOOTH)	+= bluetooth.o
 obj-$(CONFIG_USB_USBNET)	+= usbnet.o
+obj-$(CONFIG_USB_SPEEDTOUCH)	+= speedtch.o
 
 # Object files in subdirectories
 
@@ -103,3 +104,8 @@
 
 pwc.o: $(pwc-objs)
 	$(LD) -r -o $@ $(pwc-objs)
+
+speedtch.o: speedtouch.o sarlib/sarlib.o
+	$(LD) -r -o $@ speedtouch.o sarlib/sarlib.o
+
+sarlib/sarlib.o: sarlib/sarlib.c sarlib/sarlib.h
diff -ruN linux/drivers/usb/sarlib/BUGS linux-patched/drivers/usb/sarlib/BUGS
--- linux/drivers/usb/sarlib/BUGS	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/BUGS	Fri Oct 26 18:48:16 2001
@@ -0,0 +1 @@
+probably lots.
diff -ruN linux/drivers/usb/sarlib/COPYING linux-patched/drivers/usb/sarlib/COPYING
--- linux/drivers/usb/sarlib/COPYING	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/COPYING	Fri Oct 26 18:48:16 2001
@@ -0,0 +1,10 @@
+Program code and documentation are
+(C) Copyright 2000 Johan Verrept,
+All rights reserved.
+
+This package 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.
+
+See the file COPYING.GPL for details.
diff -ruN linux/drivers/usb/sarlib/COPYING.GPL linux-patched/drivers/usb/sarlib/COPYING.GPL
--- linux/drivers/usb/sarlib/COPYING.GPL	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/COPYING.GPL	Fri Oct 26 18:48:16 2001
@@ -0,0 +1,340 @@
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                          675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	Appendix: How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    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.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff -ruN linux/drivers/usb/sarlib/ChangeLog linux-patched/drivers/usb/sarlib/ChangeLog
--- linux/drivers/usb/sarlib/ChangeLog	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/ChangeLog	Fri Oct 26 18:48:16 2001
@@ -0,0 +1,45 @@
+Version 0.2.4:
+	- Fixed wrong buffer overrun check in sarlib_decode_rawcell()
+	  reported by Stephen Robinson <stephen.robinson@zen.co.uk>
+	- Fixed bug when input skb did not contain a multple of 52/53 bytes.
+	  (would happen when the speedtouch device resynced)
+	  also reported by Stephen Robinson <stephen.robinson@zen.co.uk>
+
+Version 0.2.3:
+	- Fixed wrong allocation size. caused memory corruption in some
+	  cases. Reported by Vladimir Dergachev <volodya@mindspring.com>
+	- Added some comments
+
+Version 0.2.2:
+	- Fixed CRCASM (patch from Linus Flannagan <linusf@netservices.eng.net>)
+	- Fixed problem when user did NOT use the SARLIB_USE_53BYTE_CELL flag.
+          (reported by  Piers Scannell <email@lot105.com> )
+	- No more in-buffer rewriting for cloned buffers.
+	- Removed the PII specific CFLAGS in the Makefile.
+
+Version 0.2.1:
+	- removed dependancy on alloc_tx. tis presented problems when using
+		this with the  br2684 code.
+
+Version 0.2:
+        - added AAL0 reassembly
+        - added alloc_tx support                  
+        - replaced alloc_skb in decode functions to dev_alloc_skb to allow
+                 calling from interrupt
+        - fixed embarassing AAL5 bug. I was setting the pti bit in the wrong
+                byte...
+        - fixed another emabrassing bug.. picked up the wrong crc type and
+                forgot to invert the crc result...
+        - fixed AAL5 length calculations.
+        - removed automatic skb freeing from encode functions.
+                This caused problems because i did kfree_skb it, while it
+                needed to be popped. I cannot determine though whether it
+                needs to be popped or not. Figu'e it out ye'self ;-)
+        - added mru field. This is the buffersize. sarlib_decode_aal0 will
+                use when it allocates a receive buffer. A stop gap for real
+		buffer management.
+
+Version 0.1:
+	- library created.
+	- only contains AAL5, AAL0 can be easily added. ( actually, only
+		AAL0 reassembly is missing)
diff -ruN linux/drivers/usb/sarlib/Makefile linux-patched/drivers/usb/sarlib/Makefile
--- linux/drivers/usb/sarlib/Makefile	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/Makefile	Fri Oct 26 18:48:16 2001
@@ -0,0 +1,36 @@
+#
+## Makefile for the SAR Library
+#
+
+include /usr/src/linux/.config
+
+# you can add -DCRCASM to get better performance
+CFLAGS := -O2 -Wstrict-prototypes  -fomit-frame-pointer -fno-strict-aliasing -pipe -fno-strength-reduce -Wall -D__KERNEL__ -DLINUX
+
+INCLUDES := -I/usr/src/linux/include/ -I/usr/include/
+
+VERSION = $(shell cat VERSION)
+SHORTVERSION = $(shell cat VERSION | cut -d '.' -f 1-2)
+# parse kernel options
+
+ifdef CONFIG_SMP
+	CFLAGS += -D__SMP__
+endif
+
+all: normal debug
+
+normal: sarlib.o 
+
+debug: sarlibdbg.o
+
+%.o : %.c %.h Makefile
+	$(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@
+
+%dbg.o : %.c %.h Makefile
+	$(CC) $(CFLAGS) $(INCLUDES) -DDEBUG -c $< -o $@
+
+package: clean
+	(cd ..; rm sarlib-$(VERSION); ln -s sarlib-$(SHORTVERSION) sarlib-$(VERSION); tar zcvfh sarlib-$(VERSION).tgz sarlib-$(VERSION)/);
+
+clean:
+	/bin/rm -f *.o
\ No newline at end of file
diff -ruN linux/drivers/usb/sarlib/TODO linux-patched/drivers/usb/sarlib/TODO
--- linux/drivers/usb/sarlib/TODO	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/TODO	Fri Oct 26 18:48:16 2001
@@ -0,0 +1,16 @@
+#
+## SAR Library To Do list
+#
+
+Lots to do.
+
+- Adding AAL1, AAL34 and maybe even AAL2 ( probably not, unless the
+	telephony thing wants it, need to look into it).
+- Add atm cell header crc calculation.
+- more optimalisations
+	- crc_calc / copy combinations.
+- completing support to run as well in userspace as in kernel space.
+	( replacing skb's with generalised functions, define for kernel
+	space to skb functions and to sarlib buffer system for user space.
+- completing buffer management on receive size.  introduced mru setting to
+	reduce problem. would maybe be better to go to scatter gather method.
diff -ruN linux/drivers/usb/sarlib/USAGE linux-patched/drivers/usb/sarlib/USAGE
--- linux/drivers/usb/sarlib/USAGE	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/USAGE	Fri Oct 26 18:48:16 2001
@@ -0,0 +1,86 @@
+#
+## SAR Library  (C) 2000, Johan Verrept (Johan.Verrept@advalvas.be)
+#
+
+For updates, check the linux-atm mailing list or mail me.
+The updates will be very infrequent because I don't have much time.
+Any remarks, patches and bug fixes are welcome.
+
+WARNING: This is experimental software. Use at your own risk.
+
+License
+=======
+
+This code falls under the GNU Public License, see COPYING
+If you want to use this in a commercial product, contact me.
+
+Usage & requirements
+====================
+
+Usage: Just link this library to your driver/module/kernel.
+Requirements:
+	This needs the Linux ATM stuff, but can be easily ported to
+	any platform.
+
+API
+===
+
+The API to the SARLib is simple. At least, I tried to make it as simple as I
+could.  I alsi tried to map it to the ATM Linux API as much as I could.
+
+There is a sarlib_open() function which will initialize the sarlib_vcc
+structure with the provided parameters. The sarlib_close() function frees
+this all.
+the sarlib_open() function is passed in a type, all the header parts, a
+pointer to the Linux ATM vcc, a pointer to a list of sarlib_vcc's and a
+flags field.
+there are 2 flags available now:
+	SARLIB_USE_53BYTE_CELL  will force sarlib_encode_rawcell() to produce
+53 byte cell in stead of the linux 52 byte cells.
+	SARLIB_SET_PTI          this will cause the pti bit of the last cell
+int the provided buffer to be set ( by sarlib_encode_rawcell())
+
+Real SARing happens in the sarlib_encode_xxx() and sarlib_decode_xxx()
+functions. Everything is straight forward for the encoding of the data,
+althought there are a few assumptions.
+
+sarlib_encode_rawcell assumes it gets a multiple of 48 bytes.
+	if SARLIB_SET_PTI is set, it assumes a full aal5 pdu is supplied.
+	It does NOT calculate the cell header CRC at the moment.
+
+sarlib_encode_aal5    assumes it gets a full aal5 pdu.
+
+The decode functions have no assumptions. Both decode functions need to be 
+repeated until they return NULL.  
+
+sarlib_decode_rawcell() requires a LIST of sarlib_vcc's. This allows the user 
+to pass in any cells they received, sarlib_decode_rawcell() will drop the 
+ones it doesn't know, the others are copied into the relevant sarlib_vcc 
+reassembly buffer.  Depending on the type of reassemly (only AAL5 at the
+moment) it will return a pointer to that buffer when a complete AAL5 pdu 
+has been received. The third argument will contains a pointer the relevant 
+sarlib_vcc.  You must repeat the call with the same arguments after
+processing the buffer, to allow sarlib_decode_rawcell() to process the
+remaining cells in the receive skb. It does NOT check the cell header crc.
+
+sarlib_decode_aal5() requires a complete AAL5 packet to process.
+This will do aal5 length and crc checking.  There is some intelligence in
+there that will try to recover from an illegal length.  It will take the
+length from the trailer and check whether the crc over this part is valid.
+This allows the SARLib to only drop 1 AAL5 pdu when the last cell of a pdu
+is lost. ( otherwise it would have to drop both...)
+
+There is also a sarlib_alloc_tx function now.  It is supposed to be called
+with a sarlib_vcc structure instead of a atm_vcc, I had to do this because I
+had no way of getting to the sarlib_vcc structure from the atm_vcc
+structure... the user program will have to wrap the sarlib_vcc function.
+BE CAREFULL!!  the sarlib_open function will copy the alloc_tx pointer from
+the atm_vcc and call it!  You cannot set the alloc_tx function in the vcc 
+BEFORE passing it to sarlib_open!! You will have to do it afterwards...
+
+Acknowledgements
+================
+
+Thanks to :
+
+- Whoever wrote the CRC routines in linux/drivers/net/wan/sbni.c
diff -ruN linux/drivers/usb/sarlib/VERSION linux-patched/drivers/usb/sarlib/VERSION
--- linux/drivers/usb/sarlib/VERSION	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/VERSION	Fri Oct 26 18:48:16 2001
@@ -0,0 +1 @@
+0.2.4
diff -ruN linux/drivers/usb/sarlib/sarlib.c linux-patched/drivers/usb/sarlib/sarlib.c
--- linux/drivers/usb/sarlib/sarlib.c	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/sarlib.c	Fri Oct 26 18:48:16 2001
@@ -0,0 +1,637 @@
+/*
+ *  General SAR library for ATM devices. 
+ * 
+ *  Written By Johan Verrept ( Johan.Verrept@advalvas.be )
+ *
+ *  Copyright (c) 2000, Johan Verrept
+ *
+ *  This code falls under the GNU General Public License, see COPYING for details
+ *
+ *  Version 0.1 : Module Created.
+ */
+
+#include "sarlib.h"
+
+#ifndef __KERNEL__
+
+/* user space functions */
+#define atomic_add(i,v)  *(v) += i
+#define atomic_inc(v)    *(v) ++
+
+#define Malloc(size)  malloc(size)
+
+#else
+/* kernel functions */
+
+#define Malloc(size)  dev_alloc_skb(size)
+#endif
+
+/***********************
+ **
+ **  things to remember
+ **
+ ***********************/
+
+/*
+  1. the sarlib_vcc_data list pointer MUST be initialized to NULL
+  2. sarlib_encode_rawcell will drop incomplete cells.
+  3. ownership of the skb goes to the library !
+*/
+
+#define ATM_HDR_VPVC_MASK  (ATM_HDR_VPI_MASK | ATM_HDR_VCI_MASK)
+
+/***********************
+ **
+ **  LOCAL STRUCTURES
+ **
+ ***********************/
+
+/***********************
+ **
+ **  LOCAL MACROS
+ **
+ ***********************/
+/*
+#define DEBUG 1
+*/
+#ifdef DEBUG
+#define PDEBUG(arg...)  printk(KERN_DEBUG "SARLib: " arg)
+#else
+#define PDEBUG(arg...)
+#endif
+    
+#define ADD_HEADER(dest, header) \
+  *dest++ = (unsigned char) (header >> 24); \
+  *dest++ = (unsigned char) (header >> 16); \
+  *dest++ = (unsigned char) (header >> 8); \
+  *dest++ = (unsigned char) (header & 0xff);
+
+/*
+ * CRC Routines from  net/wan/sbni.c)
+ * table generated by Rocksoft^tm Model CRC Algorithm Table Generation Program V1.0
+ */
+#define CRC32_REMAINDER CBF43926
+#define CRC32_INITIAL 0xffffffff
+#define CRC32(c,crc) (crc32tab[((size_t)(crc>>24) ^ (c)) & 0xff] ^ (((crc) << 8)))
+unsigned long  crc32tab[256] =
+{
+ 0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
+ 0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
+ 0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
+ 0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
+ 0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
+ 0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
+ 0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
+ 0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
+ 0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
+ 0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
+ 0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
+ 0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
+ 0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
+ 0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
+ 0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
+ 0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
+ 0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
+ 0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
+ 0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
+ 0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
+ 0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
+ 0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
+ 0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
+ 0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
+ 0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
+ 0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
+ 0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
+ 0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
+ 0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
+ 0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
+ 0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
+ 0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
+ 0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
+ 0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
+ 0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
+ 0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
+ 0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
+ 0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
+ 0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
+ 0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
+ 0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
+ 0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
+ 0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
+ 0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
+ 0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
+ 0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
+ 0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
+ 0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
+ 0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
+ 0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
+ 0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
+ 0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
+ 0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
+ 0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
+ 0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
+ 0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
+ 0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
+ 0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
+ 0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
+ 0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
+ 0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
+ 0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
+ 0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
+ 0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L 
+};
+                                                                
+#ifdef CRCASM
+
+unsigned long calc_crc(char *mem, int len, unsigned initial)
+{
+  unsigned crc, dummy_len;
+  __asm__ (
+    "xorl %%eax,%%eax\n\t"
+    "1:\n\t"   
+    "movl %%edx,%%eax\n\t"
+    "shrl $16,%%eax\n\t"
+    "lodsb\n\t"
+    "xorb %%ah,%%al\n\t"
+    "andl $255,%%eax\n\t"
+    "shll $8,%%edx\n\t"
+    "xorl (%%edi,%%eax,4),%%edx\n\t"
+    "loop 1b"
+    : "=d" (crc), "=c" (dummy_len)
+    : "S" (mem), "D" (&crc32tab[0]), "1" (len), "0" (initial)
+    : "eax"
+  );
+  return crc;
+}
+
+#else
+  
+unsigned long calc_crc(char *mem, int len, unsigned initial)
+{  
+  unsigned crc;
+  crc = initial;
+      
+  for(;len;mem++,len--)
+  {   
+    crc = CRC32(*mem, crc);
+  }
+  return(crc);
+}     
+#endif
+
+#define crc32( crc, mem, len) calc_crc(mem, len, crc);
+
+/* initialiation routines. not used at the moment 
+ * I will avoid these as long as possible !!
+ */
+
+int open_sarlib(void) {
+  return 0;
+  }
+
+int remove_sarlib(void) {
+  return 0;
+  }
+
+/* ATOMIC version of alloc_tx */
+struct sk_buff *sarlib_alloc_skb_wrapper(struct atm_vcc *vcc, unsigned int size) {
+  struct sk_buff *skb;
+  
+  if (atomic_read(&vcc->tx_inuse) && !atm_may_send(vcc,size)) {
+    PDEBUG("Sorry: tx_inuse = %d, size = %d, sndbuf = %d\n",
+      atomic_read(&vcc->tx_inuse),size,vcc->sk->sndbuf);
+      return NULL;
+    }
+  skb = alloc_skb(size,GFP_ATOMIC);
+  if (!skb) return NULL;
+  atomic_add(skb->truesize+ATM_PDU_OVHD,&vcc->tx_inuse);
+  return skb;
+  }
+
+struct sk_buff *sarlib_alloc_tx(struct sarlib_vcc_data *vcc, unsigned int size) {
+  struct sk_buff *tmp = NULL;
+  int bufsize=0;
+  
+  switch (vcc->type) {
+    case SARLIB_TYPE_AAL0:
+      /* reserving adequate headroom */
+      bufsize = size + (((size/48) + 1) * ( (vcc->flags & SARLIB_USE_53BYTE_CELL) ? 5 : 4 ));
+      break;
+    case SARLIB_TYPE_AAL1:
+      /* reserving adequate headroom */
+      bufsize = size + (((size/47) + 1) * ( (vcc->flags & SARLIB_USE_53BYTE_CELL) ? 5 : 4 ));
+      break;
+    case SARLIB_TYPE_AAL2:
+    case SARLIB_TYPE_AAL34:
+      /* not supported */
+      break;
+    case SARLIB_TYPE_AAL5:
+      /* reserving adequate tailroom */
+      bufsize = size + (((size + 8 + 47) / 48) * 48);
+      break;
+    }
+
+  PDEBUG("Requested size %d, Allocating size %d\n", size, bufsize);
+  tmp = vcc->alloc_tx(vcc->vcc, bufsize);
+  skb_put(tmp, bufsize);
+
+  return tmp;
+  }
+
+struct sarlib_vcc_data *sarlib_open(struct sarlib_vcc_data **list, struct atm_vcc *vcc, uint type, ushort vpi, ushort vci, unchar pti, unchar gfc, uint flags) {
+  struct sarlib_vcc_data *new;
+
+  new = kmalloc (sizeof (struct sarlib_vcc_data), GFP_KERNEL);
+  
+  if (!new)
+    return NULL;
+  
+  if (!vcc)
+    return NULL;
+  
+  memset( new, 0, sizeof (struct sarlib_vcc_data));
+  new->vcc        = vcc;
+/*
+ * This gives problems with the ATM layer alloc_tx().
+ * It is not usable from interrupt context and for
+ * some reason this is used in interurpt context 
+ * with br2684.c
+ *
+  if (vcc->alloc_tx)
+    new->alloc_tx  = vcc->alloc_tx;
+  else
+*/
+    new->alloc_tx  = sarlib_alloc_skb_wrapper;
+
+  new->stats     = vcc->stats;
+  new->type       = type;
+  new->next       = NULL;
+  new->gfc        = gfc;
+  new->vp         = vpi;
+  new->vc         = vci;
+  new->pti        = pti;
+  
+  switch (type) {
+    case SARLIB_TYPE_AAL0:
+      new->mtu = SARLIB_DEF_MTU_AAL0;
+      break;
+    case SARLIB_TYPE_AAL1:
+      new->mtu = SARLIB_DEF_MTU_AAL1;
+      break;
+    case SARLIB_TYPE_AAL2:
+      new->mtu = SARLIB_DEF_MTU_AAL2;
+      break;
+    case SARLIB_TYPE_AAL34:
+      /* not supported */
+      new->mtu = SARLIB_DEF_MTU_AAL34;
+      break;
+    case SARLIB_TYPE_AAL5:
+      new->mtu = SARLIB_DEF_MTU_AAL5;
+      break;
+    }
+  
+  new->atmHeader  = ((unsigned long)gfc << ATM_HDR_GFC_SHIFT) 
+                      | ((unsigned long)vpi << ATM_HDR_VPI_SHIFT) 
+                      | ((unsigned long)vci << ATM_HDR_VCI_SHIFT) 
+                      | ((unsigned long)pti << ATM_HDR_PTI_SHIFT) ;
+  new->flags      = flags;
+  new->next       = NULL;
+  new->reasBuffer = NULL;
+  
+  new->next = *list;
+  *list = new;
+
+  PDEBUG("Allocated new SARLib vcc 0x%p with vp %d vc %d\n", new, vpi, vci);
+  
+  return new;
+  }
+
+void sarlib_close(struct sarlib_vcc_data **list, struct sarlib_vcc_data *vcc) {
+  struct sarlib_vcc_data *work;
+  
+  if (*list == vcc) {
+    *list = (*list)->next;
+    }
+  else {
+    for (work = *list; work && work->next && (work->next != vcc) ; work = work->next);
+    
+    /* return if not found */
+    if ( work->next != vcc)
+      return;
+    
+    work->next = work->next->next;
+    }
+
+  if (vcc->reasBuffer) {
+    dev_kfree_skb (vcc->reasBuffer);
+    }
+
+  PDEBUG("Allocated SARLib vcc 0x%p with vp %d vc %d\n", vcc, vcc->vp, vcc->vc);
+  
+  kfree (vcc);
+  }
+
+/***********************
+ **
+ **    ENCODE FUNCTIONS
+ **
+ ***********************/
+
+struct sk_buff *sarlib_encode_rawcell (struct sarlib_vcc_data *ctx, struct sk_buff *skb) {
+  int number_of_cells = (skb->len) / 48;
+  int total_length = number_of_cells * (ctx->flags & SARLIB_USE_53BYTE_CELL ? 53 : 52);
+  unsigned char *source;
+  unsigned char *target;
+  struct sk_buff *out = NULL;
+  int i;
+  
+  PDEBUG("sarlib_encode_rawcell (0x%p, 0x%p) called\n", ctx, skb);
+
+  if (skb_cloned(skb) || (skb_headroom(skb) < (number_of_cells * (ctx->flags & SARLIB_USE_53BYTE_CELL ? 5 :4) )) ) {
+    PDEBUG("sarlib_encode_rawcell allocating new skb. ctx->alloc_tx = 0x%p, ctx->vcc = 0x%p\n", ctx->alloc_tx, ctx->vcc);
+    /* get new skb */
+    out = ctx->alloc_tx (ctx->vcc, total_length);
+    if (!out) return NULL;
+    
+    skb_put(out, total_length);
+    source = skb->data;
+    target = out->data;
+    }
+  else {
+    PDEBUG("sarlib_encode_rawcell: sufficient headroom\n");
+    source = skb->data;
+    skb_push(skb, number_of_cells * ( (ctx->flags & SARLIB_USE_53BYTE_CELL) ? 5 :4)) ;
+    target = skb->data;
+    out = skb;
+    }
+
+  PDEBUG("source 0x=%p, target 0x%p\n", source, target);
+
+  if (ctx->flags & SARLIB_USE_53BYTE_CELL) {
+    for (i = 0 ; i < number_of_cells; i++) {
+      ADD_HEADER(target, ctx->atmHeader);
+      *target++ = (char) 0xEC;
+      memcpy(target, source, 48);
+      target += 48;
+      source += 48;
+      PDEBUG("source 0x=%p, target 0x%p\n", source, target);
+      }
+    }
+  else {
+    for (i = 0; i < number_of_cells; i++) {
+      ADD_HEADER(target, ctx->atmHeader);
+      memcpy(target, source, 48); 
+      target += 48;
+      source += 48;
+      PDEBUG("source 0x=%p, target 0x%p\n", source, target);
+      };
+    }
+  
+  if (ctx->flags & SARLIB_SET_PTI) {
+    /* setting pti bit in last cell */
+    *(target - (ctx->flags & SARLIB_USE_53BYTE_CELL ? 50 : 49)) |= 0x2;
+    }
+
+  /* update stats */
+  if (ctx->stats && (ctx->type <= SARLIB_TYPE_AAL1 ) )
+    atomic_add ( number_of_cells, &(ctx->stats->tx));
+  
+  PDEBUG("sarlib_encode_rawcell return 0x%p (length %d)\n", out, out->len);
+  return out;
+  }
+
+struct sk_buff *sarlib_encode_aal5 (struct sarlib_vcc_data *ctx, struct sk_buff *skb) {
+  int length, pdu_length;
+  unsigned char *trailer;
+  unsigned char *pad;
+  uint crc = 0xffffffff;
+
+  PDEBUG("sarlib_encode_aal5 (0x%p, 0x%p) called\n", ctx, skb);
+
+  /* determine aal5 length */
+  pdu_length = skb->len;
+  length = ((pdu_length + 8 + 47) / 48) * 48;
+  
+  if ( skb_tailroom(skb) < (length - pdu_length) ) {
+    struct sk_buff *out;
+    PDEBUG("sarlib_encode_aal5 allocating new skb. ctx->alloc_tx = 0x%p, ctx->vcc = 0x%p\n", ctx->alloc_tx, ctx->vcc);
+    /* get new skb */
+    out = ctx->alloc_tx (ctx->vcc, length);    
+    if (!out) return NULL;
+
+    PDEBUG("out->data = 0x%p\n", out->data);    
+    PDEBUG("sarlib_encode_aal5 pdu length %d, allocated length %d\n", skb->len, length);
+    memcpy (out->data, skb->data, skb->len);
+    skb_put(out, skb->len);
+    
+    skb = out;
+    }
+
+  PDEBUG("skb->data = 0x%p\n", skb->data);
+  /* note end of pdu and add length */
+  pad = skb_put(skb, length - pdu_length);
+  trailer = skb->tail - 8;
+
+  PDEBUG("trailer = 0x%p\n", trailer);
+
+  /* zero padding space */
+  memset(pad, 0, length - pdu_length-8);
+  
+  /* add trailer */
+  *trailer++ = (unsigned char) 0; /* UU  = 0 */
+  *trailer++ = (unsigned char) 0; /* CPI = 0 */
+  *trailer++ = (unsigned char) (pdu_length >> 8);
+  *trailer++ = (unsigned char) (pdu_length & 0xff);
+  crc = ~crc32(crc, skb->data, length-4);
+  *trailer++ = (unsigned char) (crc >>  24);
+  *trailer++ = (unsigned char) (crc >>  16);
+  *trailer++ = (unsigned char) (crc >>   8);
+  *trailer++ = (unsigned char) (crc & 0xff);
+  
+  /* update stats */
+  if (ctx->stats)
+    atomic_inc(&ctx->stats->tx);
+  
+  PDEBUG("sarlib_encode_aal5 return 0x%p (length %d)\n", skb, skb->len);
+  return skb;
+  }
+
+/***********************
+ **
+ **  DECODE FUNCTIONS
+ **
+ ***********************/
+
+struct sk_buff *sarlib_decode_rawcell (struct sarlib_vcc_data *list, struct sk_buff *skb, struct sarlib_vcc_data **ctx) {
+  while (skb->len) {
+    unsigned char *cell = skb->data;
+    unsigned char *cell_payload;
+    struct sarlib_vcc_data *vcc = list;
+    unsigned long atmHeader = ((unsigned long)(cell[0]) << 24) | ((unsigned long)(cell[1]) << 16) | ((unsigned long)(cell[2]) << 8) | (cell[3] & 0xff);
+
+    PDEBUG("sarlib_decode_rawcell (0x%p, 0x%p, 0x%p) called\n", list, skb, ctx);
+    PDEBUG("sarlib_decode_rawcell skb->data %p, skb->tail %p\n", skb->data, skb->tail);
+    
+    if (!list || !skb || !ctx) return NULL;
+    if (!skb->data || !skb->tail) return NULL;
+    
+    /* here should the header CRC check be... */
+    
+    /* look up correct vcc */
+    for (; vcc && ((vcc->atmHeader & ATM_HDR_VPVC_MASK) != (atmHeader & ATM_HDR_VPVC_MASK)) ; vcc = vcc->next);
+    
+    PDEBUG("sarlib_decode_rawcell found vcc %p for packet on vp %d, vc %d\n", vcc, (int)((atmHeader & ATM_HDR_VPI_MASK) >> ATM_HDR_VPI_SHIFT), (int) ((atmHeader & ATM_HDR_VCI_MASK)>>ATM_HDR_VCI_SHIFT) );
+    
+    if (vcc && (skb->len >= (vcc->flags & SARLIB_USE_53BYTE_CELL ? 53 : 52))) {
+      cell_payload = cell + ( vcc->flags & SARLIB_USE_53BYTE_CELL ? 5 : 4 );
+      
+      switch (vcc->type) {
+        case SARLIB_TYPE_AAL0:
+        /* case SARLIB_TYPE_AAL1: when we have a decode AAL1 function... */
+          {
+          struct sk_buff *tmp = Malloc(vcc->mtu);
+          
+          if (tmp) {
+            memcpy (tmp->tail, cell_payload, 48);
+            skb_put(tmp, 48);
+            
+            if (vcc->stats)
+              atomic_inc (&vcc->stats->rx);
+
+            skb_pull ( skb,  ( vcc->flags & SARLIB_USE_53BYTE_CELL ? 53 : 52 ) );
+            PDEBUG("sarlib_decode_rawcell returns SARLIB_TYPE_AAL0 pdu 0x%p with length %d\n", tmp, tmp->len);
+            return tmp;
+            };
+          }
+          break;
+        case SARLIB_TYPE_AAL1:
+        case SARLIB_TYPE_AAL2:
+        case SARLIB_TYPE_AAL34:
+          /* not supported */
+          break;
+        case SARLIB_TYPE_AAL5:
+          if (!vcc->reasBuffer)
+            vcc->reasBuffer = Malloc(vcc->mtu);
+
+          /* if alloc fails, we just drop the cell. it is possible that we can still
+           * receive cells on other vcc's 
+           */
+          if (vcc->reasBuffer) {
+            /* if (buffer overrun) discard received cells until now */
+            if ( (vcc->reasBuffer->len) > (vcc->mtu - 48))
+              skb_trim(vcc->reasBuffer, 0);
+
+            /* copy data */
+            memcpy (vcc->reasBuffer->tail, cell_payload, 48);
+            skb_put(vcc->reasBuffer, 48);
+
+            /* check for end of buffer */
+            if (cell[3] & 0x2) {
+              struct sk_buff *tmp;
+  
+              /* the aal5 buffer ends here, cut the buffer. */
+              /* buffer will always have at least one whole cell, so */
+              /* don't need to check return from skb_pull */
+              skb_pull ( skb, ( vcc->flags & SARLIB_USE_53BYTE_CELL ? 53 : 52 ) );
+              *ctx = vcc;
+              tmp = vcc->reasBuffer;
+              vcc->reasBuffer = NULL;
+              
+              PDEBUG("sarlib_decode_rawcell returns SARLIB_TYPE_AAL5 pdu 0x%p with length %d\n", tmp, tmp->len);
+              return tmp;
+              }
+            }
+          break;
+        };
+      /* flush the cell */
+      /* buffer will always contain at least one whole cell, so don't */
+      /* need to check return value from skb_pull */
+      skb_pull ( skb,  ( vcc->flags & SARLIB_USE_53BYTE_CELL ? 53 : 52 ) );
+      }
+    else { 
+      /* If data is corrupt and skb doesn't hold a whole cell, flush the lot */
+      if (skb_pull ( skb,  ( list->flags & SARLIB_USE_53BYTE_CELL ? 53 : 52 ) ) == NULL) {
+        skb_trim (skb, 0);
+        }
+      }
+    }
+
+  return NULL;
+  };
+
+struct sk_buff *sarlib_decode_aal5 (struct sarlib_vcc_data *ctx, struct sk_buff *skb) {
+  uint crc         = 0xffffffff;
+  uint length, pdu_crc, pdu_length;
+
+  PDEBUG("sarlib_decode_aal5 (0x%p, 0x%p) called\n", ctx, skb);
+    
+  if (skb->len && (skb->len % 48)) 
+    return NULL;
+
+  length      = (skb->tail[-6] << 8) + skb->tail[-5];
+  pdu_crc     = (skb->tail[-4] << 24) + (skb->tail[-3] << 16) + (skb->tail[-2] << 8) + skb->tail[-1];
+  pdu_length  = ((length + 47 + 8)/ 48) * 48;
+
+  PDEBUG("sarlib_decode_aal5: skb->len = %d, length = %d, pdu_crc = 0x%x, pdu_length = %d\n", skb->len, length, pdu_crc, pdu_length);
+  
+  /* is skb long enough ? */
+  if (skb->len < pdu_length) {
+    if (ctx->stats)
+      atomic_inc(&ctx->stats->rx_err);
+    return NULL;
+    }
+  
+  /* is skb too long ? */
+  if (skb->len > pdu_length) {
+    PDEBUG("sarlib_decode_aal5: Warning: readjusting illeagl size %d -> %d\n", skb->len,  pdu_length);
+    /* buffer is too long. we can try to recover
+     * if we discard the first part of the skb.
+     * the crc will decide whether this was ok
+     */
+    skb_pull(skb, skb->len - pdu_length);
+    }
+   
+  crc = ~crc32(crc, skb->data, pdu_length - 4);
+  
+  /* check crc */
+  if (pdu_crc != crc) {
+    PDEBUG("sarlib_decode_aal5: crc check failed!\n");
+    if (ctx->stats)
+      atomic_inc (&ctx->stats->rx_err);
+    return NULL;
+    }
+  
+  /* pdu is ok */
+  skb_trim(skb, length);
+  
+  /* update stats */
+  if (ctx->stats)
+    atomic_inc (&ctx->stats->rx);
+
+  PDEBUG("sarlib_decode_aal5 returns pdu 0x%p with length %d\n", skb, skb->len);
+  return skb;
+  };
+
+/***********************
+ **
+ **    MODULE SUPPORT
+ **
+ ***********************/
+ 
+#ifdef MODULE
+/*
+ *
+ *  they are empty, this probably won't be a module anyway...
+ *
+ */
+/*
+int init_modules(void) {
+  return 0;
+  }
+
+
+int cleanup_module(void) {
+  return 0;
+  }
+*/
+#endif
diff -ruN linux/drivers/usb/sarlib/sarlib.h linux-patched/drivers/usb/sarlib/sarlib.h
--- linux/drivers/usb/sarlib/sarlib.h	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/sarlib/sarlib.h	Fri Oct 26 18:48:16 2001
@@ -0,0 +1,78 @@
+/*
+ *
+ *  General SAR library for ATM devices.
+ *
+ *  Copyright (c) 2000, Johan Verrept
+ *
+ *  This code falls under the GNU General Public License, see COPYING for details.
+ *
+ */
+
+#ifndef _SARLIB_H_
+#define _SARLIB_H_
+
+#include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/malloc.h>
+#include <linux/atmdev.h>
+#include <linux/skbuff.h>
+#include <linux/types.h>
+#include <linux/atm.h>
+
+#define SARLIB_USE_53BYTE_CELL  0x1L
+#define SARLIB_SET_PTI          0x2L
+
+
+/* types */
+#define SARLIB_TYPE_AAL0        ATM_AAL0
+#define SARLIB_TYPE_AAL1        ATM_AAL1
+#define SARLIB_TYPE_AAL2        ATM_AAL2
+#define SARLIB_TYPE_AAL34       ATM_AAL34
+#define SARLIB_TYPE_AAL5        ATM_AAL5
+
+
+/* default MTU's */
+#define SARLIB_DEF_MTU_AAL0         48
+#define SARLIB_DEF_MTU_AAL1         47
+#define SARLIB_DEF_MTU_AAL2          0 /* not supported */
+#define SARLIB_DEF_MTU_AAL34         0 /* not supported */
+#define SARLIB_DEF_MTU_AAL5      65535 /* max mtu ..    */
+
+typedef struct sarlib_vcc_data {
+  struct sarlib_vcc_data   *next;
+
+  /* general sarlib flags, per connection */
+  int                flags;
+  int                type;
+
+  /* connection specific non-sarlib data */
+  struct sk_buff    *(*alloc_tx)(struct atm_vcc *vcc, unsigned int size);
+  struct atm_vcc    *vcc;
+  struct k_atm_aal_stats *stats;
+  unsigned short     mtu; /* max is actually  65k for AAL5... */
+
+  /* cell data */
+  unsigned int       vp;
+  unsigned int       vc;
+  unsigned char      gfc;
+  unsigned char      pti;
+  unsigned int       headerFlags;
+  unsigned long      atmHeader;
+   
+  /* raw cell reassembly */
+  struct sk_buff    *reasBuffer;
+  } sarlib_vcc_data_t;
+
+
+extern struct sarlib_vcc_data *sarlib_open (struct sarlib_vcc_data **list, struct atm_vcc *vcc, uint type, ushort vpi, ushort vci, unchar pti, unchar gfc, uint flags);
+extern void                    sarlib_close(struct sarlib_vcc_data **list, struct sarlib_vcc_data *vcc);
+
+extern struct sk_buff *sarlib_encode_rawcell (struct sarlib_vcc_data *ctx, struct sk_buff *skb);
+extern struct sk_buff *sarlib_encode_aal5    (struct sarlib_vcc_data *ctx, struct sk_buff *skb);
+
+struct sk_buff *sarlib_decode_rawcell (struct sarlib_vcc_data *list, struct sk_buff *skb, struct sarlib_vcc_data **ctx);
+struct sk_buff *sarlib_decode_aal5    (struct sarlib_vcc_data *ctx,  struct sk_buff *skb);
+
+struct sk_buff *sarlib_alloc_tx(struct sarlib_vcc_data *vcc, unsigned int size);
+
+#endif /* _SARLIB_H_ */
diff -ruN linux/drivers/usb/speedtouch.c linux-patched/drivers/usb/speedtouch.c
--- linux/drivers/usb/speedtouch.c	Thu Jan  1 01:00:00 1970
+++ linux-patched/drivers/usb/speedtouch.c	Fri Oct 26 18:48:16 2001
@@ -0,0 +1,986 @@
+/*
+ *  Driver Module for Alcatel SpeedTouch USB xDSL modem
+ *  Copyright 2001, Alcatel
+ *  Written by Johan Verrept (Johan.Verrept@advalvas.be)
+ */
+
+#include <linux/module.h> 
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/timer.h>
+#include <linux/errno.h>
+#include <linux/proc_fs.h>
+#include <linux/malloc.h>
+#include <linux/list.h>
+#include <asm/uaccess.h>
+#include <linux/usb.h>
+#include <linux/smp_lock.h>
+
+#include <linux/atm.h>
+#include <linux/atmdev.h>
+
+#include "sarlib/sarlib.h"
+
+/*
+#define DEBUG 1
+#define DEBUG_PACKET 1
+*/
+
+#ifdef DEBUG
+#define PDEBUG(arg...)  printk(KERN_DEBUG "SpeedTouch USB: " arg)
+#else
+#define PDEBUG(arg...)
+#endif
+
+
+#ifdef DEBUG_PACKET
+#define PACKETDEBUG(arg...) udsl_print_packet ( arg )
+#else
+#define PACKETDEBUG(arg...)
+#endif
+
+MODULE_AUTHOR ("Johan Verrept (Johan.Verrept@advalvas.be)");
+MODULE_DESCRIPTION ("Driver for the Alcatel Speed Touch USB ADSL modem.");
+
+#define SPEEDTOUCH_VENDORID              0x06b9
+#define SPEEDTOUCH_PRODUCTID             0x4061
+
+#define MAX_UDSL                              1
+#define UDSL_OBUF_SIZE                    32768
+#define UDSL_MINOR                           48
+#define UDSL_NUMBER_RCV_URBS                  1
+#define UDSL_NUMBER_SND_URBS                  1
+#define UDSL_RECEIVE_BUFFER_SIZE          64*53
+#define UDSL_MAX_AAL5_MRU                  2048  /* max should be (1500 IP mtu + 2 ppp bytes + 32 * 5 cellheader overhead) for PPPoA and (1500 + 14 + 32*5 cellheader overhead) for PPPoE */
+#define UDSL_SEND_CONTEXTS                    8
+
+#define UDSL_IOCTL_START                      1
+#define UDSL_IOCTL_STOP                       2
+
+/* endpoint declarations */
+
+#define UDSL_ENDPOINT_DATA_OUT      0x7
+#define UDSL_ENDPOINT_DATA_IN      0x87
+
+/* usb_device_id struct */
+
+static struct usb_device_id udsl_usb_ids [] = 
+{
+  { USB_DEVICE (SPEEDTOUCH_VENDORID, SPEEDTOUCH_PRODUCTID) },
+  { } /* list terminator */
+};
+
+/* not exporting this prevents the depmod from generating the map that causes the modules to be isnserted as driver.
+ * we do not want this, we want the script run.
+MODULE_DEVICE_TABLE ( usb, udsl_usb_ids);
+*/
+/* context declarations */
+
+typedef struct udsl_data_ctx {
+  struct sk_buff            *skb;
+  urb_t                     *urb;
+  struct udsl_instance_data *instance;
+  } udsl_data_ctx_t;
+
+typedef struct udsl_usb_send_data_context {
+  urb_t                     urb;
+  struct sk_buff            *skb;
+  struct atm_vcc            *vcc;
+  struct udsl_instance_data *instance;
+  } udsl_usb_send_data_context_t;
+
+/*
+ * UDSL main driver data
+ */ 
+
+struct udsl_instance_data {
+  int                 minor;
+
+  /* usb device part */
+  struct usb_device  *usb_dev;
+  udsl_data_ctx_t    *rcvbufs;
+  struct sk_buff_head sndqueue;
+  spinlock_t          sndqlock;
+  udsl_usb_send_data_context_t send_ctx[UDSL_NUMBER_SND_URBS];
+  int                 data_started;
+  
+  /* atm device part */
+  struct atm_dev     *atm_dev;
+  struct sk_buff_head recvqueue;
+  spinlock_t          recvqlock;
+
+  struct sarlib_vcc_data *sarlib_vcc_list;
+  } udsl_instance_t;
+
+struct udsl_instance_data *minor_data[MAX_UDSL];
+
+static const char udsl_driver_name[] = "Alcatel SpeedTouch USB";
+
+/* data thread */
+static int datapid = 0;
+DECLARE_WAIT_QUEUE_HEAD(udsl_wqh);
+
+#ifdef DEBUG_PACKET
+int udsl_print_packet (const unsigned char *data, int len);
+#endif
+
+/*
+ * atm driver prototypes and stuctures
+ */
+
+static int udsl_atm_open(struct atm_vcc *vcc, short vpi, int vci);
+static void udsl_atm_close(struct atm_vcc *vcc);
+static int udsl_atm_ioctl(struct atm_dev *dev, unsigned int cmd, void *arg);
+static int udsl_atm_send(struct atm_vcc *vcc, struct sk_buff *skb);
+int udsl_atm_proc_read (struct atm_dev * atm_dev, loff_t * pos, char * page);
+void udsl_atm_processqueue ( struct udsl_instance_data *instance);
+
+static struct atmdev_ops udsl_atm_devops = 
+  {
+  open:       udsl_atm_open,
+  close:      udsl_atm_close,
+  ioctl:      udsl_atm_ioctl,
+  send:       udsl_atm_send,
+  proc_read:  udsl_atm_proc_read,
+  };
+
+typedef struct udsl_atm_dev_data {
+  struct sarlib_vcc_data *sarlib_vcc;
+  } udsl_atm_dev_data_t;
+
+/*
+ * usb driver prototypes and structures
+ */
+static void * udsl_usb_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id);
+static void   udsl_usb_disconnect(struct usb_device *dev, void *ptr);
+       int    udsl_usb_send_data (struct udsl_instance_data *instance, struct atm_vcc *vcc, struct sk_buff *skb);
+static int    udsl_usb_ioctl (struct usb_device *hub, unsigned int code, void *user_data);
+static int    udsl_usb_cancelsends (struct udsl_instance_data *instance, struct atm_vcc *vcc);
+
+static struct usb_driver udsl_usb_driver =
+{
+    name:       udsl_driver_name,
+    probe:      udsl_usb_probe,
+    disconnect: udsl_usb_disconnect,
+    ioctl:      udsl_usb_ioctl,
+    id_table:   udsl_usb_ids,
+};
+
+/************
+**   ATM   **
+************/
+
+/***************************************************************************
+*
+* init functions
+*
+****************************************************************************/
+
+struct atm_dev *udsl_atm_startdevice(struct udsl_instance_data *instance, struct atmdev_ops *devops) {
+  MOD_INC_USE_COUNT;
+
+  instance->atm_dev = atm_dev_register(udsl_driver_name, devops, -1, 0);
+  instance->atm_dev->dev_data = instance;
+  instance->atm_dev->ci_range.vpi_bits = ATM_CI_MAX;
+  instance->atm_dev->ci_range.vci_bits = ATM_CI_MAX;
+  instance->atm_dev->signal = ATM_PHY_SIG_LOST;
+  
+  skb_queue_head_init(&instance->recvqueue);
+
+  /* tmp init atm device, set to 128kbit */
+  instance->atm_dev->link_rate = 128*1000/424;
+  
+  return instance->atm_dev;
+  }
+
+void udsl_atm_stopdevice(struct udsl_instance_data *instance) {
+  struct atm_vcc *walk;
+  struct sk_buff *skb;
+  struct atm_dev *atm_dev;
+  unsigned long iflags;
+  
+  if (!instance->atm_dev)
+    return;
+
+  atm_dev = instance->atm_dev;
+
+  /* clean queue */
+  spin_lock_irqsave(&instance->recvqlock, iflags);
+  while (!skb_queue_empty(&instance->recvqueue)) {
+    skb = skb_dequeue (&instance->recvqueue);
+    dev_kfree_skb(skb);
+    };
+  spin_unlock_irqrestore (&instance->recvqlock, iflags);
+  
+  atm_dev->signal = ATM_PHY_SIG_LOST;
+  walk = atm_dev->vccs;
+  shutdown_atm_dev(atm_dev);
+
+  for (; walk; walk = walk->next)
+    wake_up(&walk->sleep);
+
+  instance->atm_dev = NULL;
+  MOD_DEC_USE_COUNT;
+  }
+
+void udsl_atm_set_mac(struct udsl_instance_data *instance, const char mac[6]) {
+  if (!instance->atm_dev)
+      return;
+
+  memcpy (instance->atm_dev->esi, mac, 6);
+  }
+
+/***************************************************************************
+*
+* ATM helper functions
+*
+****************************************************************************/
+struct sk_buff * udsl_atm_alloc_tx(struct atm_vcc *vcc,unsigned int size) {
+  sarlib_vcc_data_t *sarlib_vcc = ((struct udsl_atm_dev_data *)vcc->dev_data)->sarlib_vcc;
+  
+  if (sarlib_vcc)
+    return sarlib_alloc_tx(sarlib_vcc, size);
+  
+  printk(KERN_INFO "SpeedTouch USB: udsl_atm_alloc_tx could not find correct alloc_tx function !\n");
+  return NULL;
+  }
+
+int udsl_atm_proc_read (struct atm_dev * atm_dev, loff_t * pos, char * page) {
+  struct udsl_instance_data *instance = (struct udsl_instance_data *) atm_dev->dev_data;
+  int left = *pos;
+    
+  if (!left--)
+    return sprintf(page, "Speed Touch USB:%d (%02x:%02x:%02x:%02x:%02x:%02x)\n", instance->minor,
+              atm_dev->esi[0], atm_dev->esi[1], atm_dev->esi[2], atm_dev->esi[3], atm_dev->esi[4], atm_dev->esi[5]);
+  
+  if (!left--)
+    return sprintf(page, "AAL0: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
+      atomic_read(&atm_dev->stats.aal0.tx), atomic_read(&atm_dev->stats.aal0.tx_err),
+      atomic_read(&atm_dev->stats.aal0.rx), atomic_read(&atm_dev->stats.aal0.rx_err), atomic_read(&atm_dev->stats.aal0.rx_drop));
+
+  if (!left--)
+    return sprintf(page, "AAL5: tx %d ( %d err ), rx %d ( %d err, %d drop )\n",
+      atomic_read(&atm_dev->stats.aal5.tx), atomic_read(&atm_dev->stats.aal5.tx_err),
+      atomic_read(&atm_dev->stats.aal5.rx), atomic_read(&atm_dev->stats.aal5.rx_err), atomic_read(&atm_dev->stats.aal5.rx_drop));
+
+  return 0;
+  }
+
+/***************************************************************************
+*
+* ATM DATA functions
+*
+****************************************************************************/
+int udsl_atm_send(struct atm_vcc *vcc, struct sk_buff *skb) {
+  struct udsl_atm_dev_data  *dev_data = (struct udsl_atm_dev_data *)  vcc->dev_data;
+  struct udsl_instance_data *instance = (struct udsl_instance_data *) vcc->dev->dev_data;
+  struct sk_buff *new = NULL;
+  int err;
+  
+  PDEBUG("udsl_atm_send called\n");
+  
+  if (!dev_data)
+    return -EINVAL;
+  
+  switch (vcc->qos.aal) {
+    case ATM_AAL5:
+      new = sarlib_encode_aal5(dev_data->sarlib_vcc, skb);
+      if (!new) goto nomem;
+      if (new != skb) {
+        vcc->pop(vcc, skb);
+        skb = new;
+        }
+      new = sarlib_encode_rawcell(dev_data->sarlib_vcc, skb);
+      if (!new) goto nomem;
+      if (new != skb) {
+        vcc->pop(vcc, skb);
+        skb = new;
+        }
+      err = udsl_usb_send_data (instance, vcc, skb);
+      PDEBUG("udsl_atm_send successfull (%d)\n", err);
+      return err;
+      break;
+    default:
+      return -EINVAL;
+    };      
+    
+  PDEBUG("udsl_atm_send unsuccessfull\n");    
+  return 0;
+nomem:
+  vcc->pop(vcc, skb);
+  return -ENOMEM;
+};
+
+
+void udsl_atm_processqueue ( struct udsl_instance_data *instance) {
+  struct sarlib_vcc_data *sarlib_vcc = NULL;
+  struct sk_buff *new = NULL, *skb = NULL, *tmp = NULL;
+  unsigned long iflags;
+
+  /* quick check */
+  spin_lock_irqsave (&instance->recvqlock, iflags);
+  if (skb_queue_empty(&instance->recvqueue)) {
+    spin_unlock_irqrestore (&instance->recvqlock, iflags);
+    return;
+    }
+  PDEBUG("udsl_atm_processqueue entered\n");
+
+  while (!skb_queue_empty(&instance->recvqueue)) {
+    skb = skb_dequeue (&instance->recvqueue);
+    
+    spin_unlock_irqrestore (&instance->recvqlock, iflags);
+    
+    PDEBUG("skb = %p, skb->len = %d\n", skb, skb->len);
+    PACKETDEBUG (skb->data, skb->len);
+
+    while ( (new = sarlib_decode_rawcell (instance->sarlib_vcc_list, skb, &sarlib_vcc)) != NULL) {
+      PDEBUG("(after cell processing)skb->len = %d\n", new->len);
+      switch (sarlib_vcc->type) {
+        case SARLIB_TYPE_AAL5:
+          tmp = new;
+          new = sarlib_decode_aal5 (sarlib_vcc, new);
+
+          /* we can't send NULL skbs upstream, the ATM layer would try to close the vcc... */
+          if (new) {
+            PDEBUG("(after aal5 decap) skb->len = %d\n", new->len);
+            if (new->len && atm_charge(sarlib_vcc->vcc, new->truesize)) {
+              PACKETDEBUG (new->data, new->len);
+              sarlib_vcc->vcc->push(sarlib_vcc->vcc, new);
+              }
+            else {
+              PDEBUG("dropping incoming packet : rx_inuse = %d, vcc->sk->rcvbuf = %d, skb->true_size = %d\n", atomic_read(&sarlib_vcc->vcc->rx_inuse), sarlib_vcc->vcc->sk->rcvbuf, new->truesize);
+              dev_kfree_skb(new);
+              }
+            }
+          else {
+            PDEBUG("sarlib_decode_aal5 returned NULL!\n");
+            dev_kfree_skb(tmp);
+          }
+          break;
+        default:
+          /* not supported. we delete the skb. */
+          printk(KERN_INFO "SpeedTouch USB: illegal vcc type. Dropping packet.\n");
+          dev_kfree_skb(new);
+          break;
+        }
+      };
+    dev_kfree_skb (skb);
+    spin_lock_irqsave (&instance->recvqlock, iflags);
+    };
+
+  spin_unlock_irqrestore (&instance->recvqlock, iflags);
+  PDEBUG("udsl_atm_processqueue successfull\n");
+  }
+
+int udsl_atm_processqueue_thread (void *data) {
+  int i=0;
+  DECLARE_WAITQUEUE(wait, current);
+     
+  lock_kernel();
+  exit_files(current);  /* daemonize doesn't do exit_files */
+  daemonize();
+
+  /* Setup a nice name */
+  strcpy(current->comm, "kSpeedSARd");
+  
+  add_wait_queue(&udsl_wqh, &wait);
+
+  for(;;) {
+    interruptible_sleep_on(&udsl_wqh);
+    if (signal_pending(current)) break;
+    PDEBUG("SpeedSARd awoke\n");
+    for (i=0; i < MAX_UDSL ; i++)
+      if (minor_data[i])
+        udsl_atm_processqueue(minor_data[i]);
+    };
+  
+  datapid = 0;
+  PDEBUG("SpeedSARd is exiting\n");
+  return 0;
+  }
+
+
+void udsl_atm_sar_start (void) {
+  datapid = kernel_thread(udsl_atm_processqueue_thread, (void *)NULL,
+      CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
+  }
+
+void udsl_atm_sar_stop (void) {
+  int ret;
+
+  /* Kill the thread */
+  ret = kill_proc(datapid, SIGTERM, 1);
+  if (!ret) {
+    /* Wait 10 seconds */
+    int count = 10 * 100;
+
+    while (datapid && --count) {
+      current->state = TASK_INTERRUPTIBLE;
+      schedule_timeout(1);
+      }
+
+    if (!count)
+      err("giving up on killing SpeedSAR thread.");
+    }
+  }
+
+/***************************************************************************
+*
+* SAR driver entries
+*
+****************************************************************************/
+int udsl_atm_open(struct atm_vcc *vcc, short vpi, int vci) {
+  struct udsl_atm_dev_data  *dev_data;
+  struct udsl_instance_data *instance = (struct udsl_instance_data *)vcc->dev->dev_data;
+
+  PDEBUG("udsl_atm_open called\n");
+
+  /* at the moment only AAL5 support */
+  if (vcc->qos.aal != ATM_AAL5)
+    return -EINVAL;
+
+  MOD_INC_USE_COUNT;
+  dev_data = (struct udsl_atm_dev_data *)kmalloc (sizeof(struct udsl_atm_dev_data), GFP_KERNEL);
+  if (!dev_data)
+    return -ENOMEM;
+
+  dev_data->sarlib_vcc = sarlib_open (&(instance->sarlib_vcc_list), vcc, SARLIB_TYPE_AAL5, vpi, vci, 0, 0, SARLIB_USE_53BYTE_CELL | SARLIB_SET_PTI);
+  if (!dev_data->sarlib_vcc) {
+    kfree(dev_data);
+    return -ENOMEM; /* this is the only reason sarlib_open can fail... */
+    }
+
+  vcc->vpi = vpi;
+  vcc->vci = vci;
+  set_bit(ATM_VF_ADDR,    &vcc->flags);
+  set_bit(ATM_VF_PARTIAL, &vcc->flags);
+  set_bit(ATM_VF_READY,   &vcc->flags);
+  vcc->dev_data = dev_data;
+  vcc->alloc_tx = udsl_atm_alloc_tx;
+  
+  dev_data->sarlib_vcc->mtu = UDSL_MAX_AAL5_MRU;
+  
+  PDEBUG("udsl_atm_open successfull\n");
+  return 0;
+}
+
+void udsl_atm_close(struct atm_vcc *vcc) {
+  struct udsl_atm_dev_data  *dev_data = (struct udsl_atm_dev_data *)vcc->dev_data;
+  struct udsl_instance_data *instance = (struct udsl_instance_data *)vcc->dev->dev_data;
+  
+  PDEBUG("udsl_atm_close called\n");
+
+  /* freeing resources */
+  /* cancel all sends on this vcc */
+  udsl_usb_cancelsends(instance, vcc);
+  
+  sarlib_close (&(instance->sarlib_vcc_list), dev_data->sarlib_vcc);
+  kfree (dev_data);
+  vcc->dev_data = NULL;
+  clear_bit(ATM_VF_PARTIAL, &vcc->flags);
+
+  /* freeing address */
+  vcc->vpi = ATM_VPI_UNSPEC;
+  vcc->vci = ATM_VCI_UNSPEC;
+  clear_bit(ATM_VF_ADDR,    &vcc->flags);
+
+  MOD_DEC_USE_COUNT;
+  
+  PDEBUG("udsl_atm_close successfull\n");  
+  return;
+};
+
+int udsl_atm_ioctl(struct atm_dev *dev, unsigned int cmd, void *arg) {
+  switch (cmd) {
+    case ATM_QUERYLOOP:
+      return put_user(ATM_LM_NONE, (int *) arg) ? -EFAULT : 0;
+    default:
+      return -ENOIOCTLCMD;
+    }
+};
+
+
+/************
+**   USB   **
+************/
+
+/***************************************************************************
+*
+* usb data functions
+*
+****************************************************************************/
+
+typedef struct udsl_cb {
+  struct atm_vcc *vcc;
+  } udsl_cb_t;
+
+static void udsl_usb_send_data_complete(urb_t *urb) {
+  udsl_usb_send_data_context_t *ctx      = (udsl_usb_send_data_context_t *)urb->context;
+  struct udsl_instance_data    *instance = ctx->instance;
+  int err;
+  unsigned long flags;
+  
+  PDEBUG("udsl_usb_send_data_completion (vcc = %p, skb = %p, status %d)\n", ctx->vcc, ctx->skb, urb->status);
+
+  ctx->vcc->pop (ctx->vcc, ctx->skb);
+  ctx->skb = NULL;
+
+  spin_lock_irqsave (&instance->sndqlock, flags);
+  if (skb_queue_empty(&instance->sndqueue)) {
+    spin_unlock_irqrestore (&instance->sndqlock, flags);
+    return;
+    }
+
+  /* submit next skb */
+  ctx->skb = skb_dequeue (&(instance->sndqueue));
+  ctx->vcc = ((udsl_cb_t *)(ctx->skb->cb))->vcc;
+  spin_unlock_irqrestore (&instance->sndqlock, flags);
+  
+  FILL_BULK_URB(urb,
+    instance->usb_dev,
+    usb_sndbulkpipe(instance->usb_dev, UDSL_ENDPOINT_DATA_OUT),
+    (unsigned char *)ctx->skb->data,
+    ctx->skb->len,
+    (usb_complete_t)udsl_usb_send_data_complete,
+    ctx
+    );
+  urb->transfer_flags |= USB_QUEUE_BULK;
+  
+  err = usb_submit_urb(urb);
+
+  PDEBUG("udsl_usb_send_data_completion (send packet %p with length %d), retval = %d\n", ctx->skb, ctx->skb->len, err);
+  }
+
+int udsl_usb_cancelsends (struct udsl_instance_data *instance, struct atm_vcc *vcc) {
+  int i;
+  unsigned long flags;
+  
+  spin_lock_irqsave (&instance->sndqlock, flags);
+  for (i=0; i < UDSL_NUMBER_SND_URBS ; i++) {
+    if (!instance->send_ctx[i].skb) continue;
+    if (instance->send_ctx[i].vcc==vcc) {
+      usb_unlink_urb (&instance->send_ctx[i].urb);
+      instance->send_ctx[i].vcc->pop (instance->send_ctx[i].vcc, instance->send_ctx[i].skb);
+      instance->send_ctx[i].skb = NULL;
+      }
+    }
+  spin_unlock_irqrestore(&instance->sndqlock, flags);
+  
+  return 0;
+  }
+
+/**** send ******/
+int udsl_usb_send_data (struct udsl_instance_data *instance, struct atm_vcc *vcc, struct sk_buff *skb) {
+  int    err, i;
+  urb_t *urb;
+  unsigned long flags;
+
+  PDEBUG("udsl_usb_send_data entered, sending packet %p with length %d\n", skb, skb->len);
+
+  if (!instance->data_started)
+    return -EAGAIN;
+
+  PACKETDEBUG (skb->data, skb->len);
+
+  spin_lock_irqsave (&instance->sndqlock, flags);
+  ((udsl_cb_t *)skb->cb)->vcc = vcc;
+  
+  /* we are already queueing */
+  if (!skb_queue_empty(&instance->sndqueue)) {
+    skb_queue_tail (&instance->sndqueue, skb);
+    spin_unlock_irqrestore(&instance->sndqlock, flags);
+    PDEBUG("udsl_usb_send_data: already queing, skb (0x%p) queued\n", skb);
+    return 0;
+    }
+
+  for (i=0; i < UDSL_NUMBER_SND_URBS ; i++)
+    if (instance->send_ctx[i].skb==NULL) break;
+
+  /* we must start queueing */
+  if (i == UDSL_NUMBER_SND_URBS) {
+    skb_queue_tail (&instance->sndqueue, skb);
+    spin_unlock_irqrestore(&instance->sndqlock, flags);
+    PDEBUG("udsl_usb_send_data: skb (0x%p) queued\n", skb);
+    return 0;
+    };
+
+  /* init context */
+  urb = &(instance->send_ctx[i].urb);
+  instance->send_ctx[i].skb       = skb;
+  instance->send_ctx[i].vcc       = vcc;
+  instance->send_ctx[i].instance  = instance;
+
+  spin_unlock_irqrestore(&instance->sndqlock, flags);
+
+  /* submit packet */  
+  FILL_BULK_URB(urb,
+    instance->usb_dev,
+    usb_sndbulkpipe(instance->usb_dev, UDSL_ENDPOINT_DATA_OUT),
+    (unsigned char *)skb->data,
+    skb->len,
+    (usb_complete_t)udsl_usb_send_data_complete,
+    &(instance->send_ctx[i])
+    );
+  urb->transfer_flags |= USB_QUEUE_BULK;
+  
+  err = usb_submit_urb(urb);
+
+  if (err != 0)
+    skb_unlink(skb);
+
+  PDEBUG("udsl_usb_send_data done (retval = %d)\n", err);
+  return err;
+  }
+
+/********* receive *******/
+void udsl_usb_data_receive(urb_t *urb) {
+  udsl_data_ctx_t *ctx; 
+  struct udsl_instance_data *instance;
+  unsigned long flags;
+  
+  if (!urb) return;
+  
+  PDEBUG("udsl_usb_receive_data entered, got packet %p with length %d an status %d\n", urb, urb->actual_length, urb->status);
+
+  ctx = (udsl_data_ctx_t *)urb->context;
+  if (!ctx || !ctx->skb) return;
+
+  instance = ctx->instance;
+
+  switch (urb->status) {
+    case 0:
+      PDEBUG("udsl_usb_data_receive: processing urb with ctx %p, urb %p (%p), skb %p\n", ctx, ctx ? ctx->urb : NULL , urb, ctx ? ctx->skb : NULL);
+    
+      /* update the skb structure */
+      skb_put(ctx->skb, urb->actual_length);
+
+      /* queue the skb for processing and wake the SAR */
+      spin_lock_irqsave (&instance->recvqlock, flags);
+      skb_queue_tail (&instance->recvqueue, ctx->skb);
+      spin_unlock_irqrestore (&instance->recvqlock, flags);
+      wake_up(&udsl_wqh);
+
+      /* get a new skb */
+      ctx->skb = dev_alloc_skb(UDSL_RECEIVE_BUFFER_SIZE);
+      if (!ctx->skb) {
+        PDEBUG("No skb, loosing urb.\n");
+        usb_free_urb(ctx->urb);
+        ctx->urb = NULL;  
+        return;
+        }
+      break;
+    case -EPIPE:  /* stall or babble */
+      usb_clear_halt(urb->dev, usb_rcvbulkpipe(urb->dev, UDSL_ENDPOINT_DATA_IN));
+      break;
+    case -ENOENT:  /* buffer was unlinked */
+    case -EILSEQ:    /* unplug or timeout */
+    case -ETIMEDOUT: /* unplug or timeout */
+      /* 
+       * we don't do anything here and we don't resubmit
+       */
+      return;
+    }
+
+  FILL_BULK_URB(urb,
+    instance->usb_dev,
+    usb_rcvbulkpipe(instance->usb_dev, UDSL_ENDPOINT_DATA_IN),
+    (unsigned char *)ctx->skb->data,
+    UDSL_RECEIVE_BUFFER_SIZE,
+    (usb_complete_t)udsl_usb_data_receive,
+    ctx
+    );
+  urb->transfer_flags        |= USB_QUEUE_BULK;
+  
+  usb_submit_urb(urb);
+
+  return;
+  };
+
+int udsl_usb_data_init(struct udsl_instance_data *instance) {
+  int i, succes;
+
+  /* set alternate setting 1 on interface 1 */
+  usb_set_interface(instance->usb_dev, 1, 2);
+
+  PDEBUG("max packet size on endpoint %d is %d\n", UDSL_ENDPOINT_DATA_OUT, usb_maxpacket (instance->usb_dev, usb_sndbulkpipe(instance->usb_dev, UDSL_ENDPOINT_DATA_OUT), 0));
+
+  instance->rcvbufs = (udsl_data_ctx_t *)kmalloc (sizeof(udsl_data_ctx_t) * UDSL_NUMBER_RCV_URBS , GFP_KERNEL);
+  if (!instance->rcvbufs) 
+    return -ENOMEM;  
+
+  memset (instance->rcvbufs, 0, sizeof(udsl_data_ctx_t) * UDSL_NUMBER_RCV_URBS);
+  skb_queue_head_init(&instance->sndqueue);
+
+  for (i=0, succes = 0 ; i < UDSL_NUMBER_RCV_URBS; i++) {
+    udsl_data_ctx_t *ctx = &(instance->rcvbufs[i]);
+    
+    ctx->urb = NULL;    
+    ctx->skb = dev_alloc_skb(UDSL_RECEIVE_BUFFER_SIZE);
+    if (!ctx->skb) continue;
+
+    ctx->urb = usb_alloc_urb(0);
+    if (!ctx->urb) {
+      kfree_skb(ctx->skb);
+      ctx->skb = NULL;
+      break;
+      };
+
+    FILL_BULK_URB(ctx->urb,
+      instance->usb_dev,
+      usb_rcvbulkpipe(instance->usb_dev, UDSL_ENDPOINT_DATA_IN),
+      (unsigned char *)ctx->skb->data,
+      UDSL_RECEIVE_BUFFER_SIZE,
+      (usb_complete_t)udsl_usb_data_receive,
+      ctx
+      );
+    ctx->urb->transfer_flags |= USB_QUEUE_BULK;
+
+    ctx->instance = instance;
+    
+    PDEBUG("udsl_usb_data_init: usb with skb->truesize = %d (Asked for %d)\n", ctx->skb->truesize, UDSL_RECEIVE_BUFFER_SIZE);
+    
+    if (usb_submit_urb(ctx->urb) < 0)      
+      PDEBUG("udsl_usb_data_init: Submit failed, loosing urb.\n");
+    else
+      succes++;
+    }
+  
+  instance->data_started=1;
+  instance->atm_dev->signal = ATM_PHY_SIG_FOUND;
+  
+  PDEBUG("udsl_usb_data_init %d urb%s queued for receive\n", succes, (succes!=1) ? "s" : "");
+  return 0;
+  }
+
+int udsl_usb_data_exit(struct udsl_instance_data *instance) {
+  int i;
+  
+  if (!instance->data_started)
+    return 0;
+  
+  if (!instance->rcvbufs)
+    return 0;
+   
+  /* destroy urbs */
+  for (i=0; i < UDSL_NUMBER_RCV_URBS; i++) {
+    udsl_data_ctx_t *ctx = &(instance->rcvbufs[i]);
+
+    if ((!ctx->urb) || (!ctx->skb))
+      continue;
+     
+    if (ctx->urb->status == -EINPROGRESS)
+      usb_unlink_urb(ctx->urb);
+      
+    usb_free_urb(ctx->urb);
+    kfree_skb(ctx->skb);
+    ctx->skb = NULL;
+    };
+  
+  for (i=0; i < UDSL_NUMBER_SND_URBS; i++) {
+    udsl_usb_send_data_context_t *ctx = &(instance->send_ctx[i]);
+
+    if (!ctx->skb)
+      continue;
+
+    if (ctx->urb.status == -EINPROGRESS)
+      usb_unlink_urb(&ctx->urb);
+    
+    /* not sure if completion handler is called */
+    if (ctx->skb)
+      ctx->vcc->pop (ctx->vcc, ctx->skb);
+    ctx->skb = NULL;
+    }
+
+  /* free receive contexts */
+  kfree (instance->rcvbufs);
+  instance->rcvbufs = NULL;
+  
+  instance->data_started=0;
+  instance->atm_dev->signal = ATM_PHY_SIG_LOST;
+  
+  return 0;
+  };
+
+
+/***************************************************************************
+*
+* usb driver entries
+*
+****************************************************************************/
+#define hex2int(c) ( (c >= '0')&&(c <= '9') ?  (c - '0') : ((c & 0xf)+9) )
+
+
+static int udsl_usb_ioctl (struct usb_device *dev, unsigned int code, void *user_data) {
+  struct udsl_instance_data *instance;
+  int i;
+
+  for (i=0; i < MAX_UDSL; i++)
+    if (minor_data[i] && (minor_data[i]->usb_dev == dev))
+      break;
+  
+  if (i==MAX_UDSL)
+    return -EINVAL;
+
+  instance = minor_data[i];
+
+  switch(code) {
+    case UDSL_IOCTL_START:
+      return udsl_usb_data_init (instance);
+      break;
+    case UDSL_IOCTL_STOP:
+      return udsl_usb_data_exit (instance);
+      break;
+    default:
+      break;
+    }
+  return -EINVAL;
+  }
+
+void *udsl_usb_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id)
+{
+  int i;
+  unsigned char mac[6];
+  unsigned char mac_str[13];
+  struct udsl_instance_data *instance = NULL;
+
+  PDEBUG("Trying device with Vendor=0x%x, Product=0x%x, ifnum %d\n", dev->descriptor.idVendor, dev->descriptor.idProduct, ifnum);
+
+  if  ((dev->descriptor.bDeviceClass != USB_CLASS_VENDOR_SPEC)||
+      (dev->descriptor.idVendor  != SPEEDTOUCH_VENDORID)||
+      (dev->descriptor.idProduct != SPEEDTOUCH_PRODUCTID)||
+      (ifnum!=1))
+    return NULL;
+
+  MOD_INC_USE_COUNT;
+
+  for (i=0; i < MAX_UDSL; i++)
+    if (minor_data[i] == NULL)
+      break;
+
+  if (i >= MAX_UDSL) {
+    printk(KERN_INFO "No minor table space available for SpeedTouch USB\n");
+    return NULL;
+    };
+
+  PDEBUG("Device Accepted, assigning minor %d\n", i);
+
+  /* device init */
+  instance = kmalloc(sizeof(struct udsl_instance_data), GFP_KERNEL);
+  if (!instance) {
+    PDEBUG("No memory for Instance data!\n");
+    return NULL;
+    }
+
+  /* initialize structure */
+  memset(instance, 0, sizeof(struct udsl_instance_data));  
+  instance->minor    = i;
+  instance->usb_dev  = dev;
+  instance->rcvbufs  = NULL;
+  spin_lock_init (&instance->sndqlock);
+  spin_lock_init (&instance->recvqlock);
+
+  udsl_atm_startdevice(instance, &udsl_atm_devops);
+
+  /* set MAC address, it is stored in the serial number */
+  usb_string(instance->usb_dev, instance->usb_dev->descriptor.iSerialNumber, mac_str, 13);
+  for (i=0; i<6; i++)
+    mac[i] = (hex2int(mac_str[i*2])*16) + (hex2int(mac_str[i*2+1]));
+
+  PDEBUG("MAC is %02x:%02x:%02x:%02x:%02x:%02x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+  udsl_atm_set_mac(instance, mac);
+
+  minor_data[instance->minor] = instance;
+
+  return instance;
+}
+
+void udsl_usb_disconnect(struct usb_device *dev, void *ptr)
+{
+  struct udsl_instance_data *instance = (struct udsl_instance_data *)ptr;
+  int i = instance->minor;
+
+  /* unlinking receive buffers */
+  udsl_usb_data_exit(instance);
+
+  /* removing atm device */
+  if (instance->atm_dev)
+    udsl_atm_stopdevice(instance);
+
+  PDEBUG("disconnecting minor %d\n", i);
+
+  while (MOD_IN_USE > 1) {
+    current->state = TASK_INTERRUPTIBLE;
+    schedule_timeout(1);
+    }
+
+  kfree (instance);
+  minor_data[i] = NULL;
+
+  MOD_DEC_USE_COUNT;
+}
+
+/***************************************************************************
+*
+* Driver Init
+*
+****************************************************************************/
+
+int udsl_usb_init(void)
+{
+  int i;
+
+  PDEBUG ("Initializing SpeedTouch Driver Version %s\n", udsl_version);
+  
+  for (i =0; i < MAX_UDSL ; i++)
+    minor_data[i] = NULL;
+
+  init_waitqueue_head(&udsl_wqh);
+  udsl_atm_sar_start();
+  
+  return usb_register(&udsl_usb_driver);
+}
+
+int udsl_usb_cleanup(void)
+{
+  /* killing threads */
+  udsl_atm_sar_stop();
+  
+  usb_deregister(&udsl_usb_driver);
+  return 0;
+}
+
+#ifdef MODULE
+int init_module(void)
+{
+	return udsl_usb_init();
+}
+
+int cleanup_module(void)
+{
+	return udsl_usb_cleanup();
+}
+#endif
+
+#ifdef DEBUG_PACKET
+/*******************************************************************************
+*
+* Debug 
+*
+*******************************************************************************/
+
+int udsl_print_packet (const unsigned char *data, int len) {
+  unsigned char buffer[256];
+  int i=0, j=0;
+  
+  for (i = 0; i < len ; ) {
+    buffer[0] = '\0';
+    sprintf(buffer,"%.3d :", i);
+    for (j = 0; (j < 16) && (i< len) ; j++, i++) {
+      sprintf(buffer, "%s %2.2x", buffer, data[i]);
+      }
+    PDEBUG("%s\n", buffer);
+    }
+  return i;
+  };
+
+#endif /* PACKETDEBUG */