diff -rubN linux.orig/Documentation/Configure.help linux/Documentation/Configure.help --- linux.orig/Documentation/Configure.help Wed Mar 21 16:18:14 2001 +++ linux/Documentation/Configure.help Wed Mar 21 16:41:23 2001 @@ -10734,6 +10734,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 rio500.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 -rubN linux.orig/drivers/usb/Config.in linux/drivers/usb/Config.in --- linux.orig/drivers/usb/Config.in Tue Nov 28 02:10:35 2000 +++ linux/drivers/usb/Config.in Wed Mar 21 16:28:13 2001 @@ -71,6 +71,7 @@ comment 'USB misc 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 fi endmenu diff -rubN linux.orig/drivers/usb/Makefile linux/drivers/usb/Makefile --- linux.orig/drivers/usb/Makefile Fri Dec 29 22:07:23 2000 +++ linux/drivers/usb/Makefile Wed Mar 21 17:17:24 2001 @@ -59,6 +59,7 @@ obj-$(CONFIG_USB_MICROTEK) += microtek.o obj-$(CONFIG_USB_BLUETOOTH) += bluetooth.o obj-$(CONFIG_USB_NET1080) += net1080.o +obj-$(CONFIG_USB_SPEEDTOUCH) += speedtch.o # Object files in subdirectories @@ -80,3 +81,7 @@ usbcore.o: $(usbcore-objs) $(LD) -r -o $@ $(usbcore-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 -rubN linux.orig/drivers/usb/sarlib/BUGS linux/drivers/usb/sarlib/BUGS --- linux.orig/drivers/usb/sarlib/BUGS Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/sarlib/BUGS Sun Apr 23 01:44:52 2000 @@ -0,0 +1 @@ +probably lots. \ No newline at end of file diff -rubN linux.orig/drivers/usb/sarlib/COPYING linux/drivers/usb/sarlib/COPYING --- linux.orig/drivers/usb/sarlib/COPYING Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/sarlib/COPYING Sun Mar 26 02:24:00 2000 @@ -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 -rubN linux.orig/drivers/usb/sarlib/COPYING.GPL linux/drivers/usb/sarlib/COPYING.GPL --- linux.orig/drivers/usb/sarlib/COPYING.GPL Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/sarlib/COPYING.GPL Sun Mar 26 02:14:33 2000 @@ -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. + + + Copyright (C) 19yy + + 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. + + , 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 -rubN linux.orig/drivers/usb/sarlib/ChangeLog linux/drivers/usb/sarlib/ChangeLog --- linux.orig/drivers/usb/sarlib/ChangeLog Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/sarlib/ChangeLog Mon Feb 26 12:45:25 2001 @@ -0,0 +1,27 @@ + +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 -rubN linux.orig/drivers/usb/sarlib/TODO linux/drivers/usb/sarlib/TODO --- linux.orig/drivers/usb/sarlib/TODO Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/sarlib/TODO Sun Apr 23 01:48:16 2000 @@ -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 -rubN linux.orig/drivers/usb/sarlib/USAGE linux/drivers/usb/sarlib/USAGE --- linux.orig/drivers/usb/sarlib/USAGE Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/sarlib/USAGE Mon Mar 27 00:48:47 2000 @@ -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 -rubN linux.orig/drivers/usb/sarlib/VERSION linux/drivers/usb/sarlib/VERSION --- linux.orig/drivers/usb/sarlib/VERSION Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/sarlib/VERSION Sun Feb 25 18:00:49 2001 @@ -0,0 +1 @@ +0.2.1 diff -rubN linux.orig/drivers/usb/sarlib/sarlib.c linux/drivers/usb/sarlib/sarlib.c --- linux.orig/drivers/usb/sarlib/sarlib.c Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/sarlib/sarlib.c Wed Mar 21 17:24:23 2001 @@ -0,0 +1,622 @@ +/* + * 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" + "lodsb\n\t" + "xorb %%dl,%%al\n\t" + "shrl $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; + + switch (vcc->type) { + case SARLIB_TYPE_AAL0: + /* reserving adequate headroom */ + PDEBUG("Requested size %d, Allocating size %d\n", size, (size/48) * ( SARLIB_USE_53BYTE_CELL ? 53 :52 )); + tmp = vcc->alloc_tx(vcc->vcc, (size/48) * ( SARLIB_USE_53BYTE_CELL ? 53 :52 )); + skb_put(tmp, (size/48) * ( SARLIB_USE_53BYTE_CELL ? 5 : 4 )); + break; + case SARLIB_TYPE_AAL1: + /* reserving adequate headroom */ + PDEBUG("Requested size %d, Allocating size %d\n", size, (size/47) * ( SARLIB_USE_53BYTE_CELL ? 53 :52 )); + tmp = vcc->alloc_tx(vcc->vcc, (size/47) * ( SARLIB_USE_53BYTE_CELL ? 53 :52 )); + skb_put(tmp, (size/47) * ( 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 */ + PDEBUG("Requested size %d, Allocating size %d\n", size, ((size + 8 + 47) / 48) * 48); + tmp = vcc->alloc_tx(vcc->vcc, ((size + 8 + 47) / 48) * 48 ); + break; + } + 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; +/* 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 * 53; + 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_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, skb->len); + source = skb->data; + target = out->data; + } + else { + PDEBUG("sarlib_encode_rawcell: sufficient headroom\n"); + source = skb->data; + skb_push(skb, number_of_cells * ( 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); + }; + } + + skb_put(out, total_length - skb->len); + + 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) { + 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 ((skb->len + vcc->reasBuffer->len) > (ATM_MAX_AAL5_PDU - 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. */ + 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 */ + skb_pull ( skb, ( vcc->flags & SARLIB_USE_53BYTE_CELL ? 53 : 52 ) ); + } + else + skb_pull ( skb, ( list->flags & SARLIB_USE_53BYTE_CELL ? 53 : 52 ) ); + } + + 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 + ** + ***********************/ + +#if 0 +//#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 -rubN linux.orig/drivers/usb/sarlib/sarlib.h linux/drivers/usb/sarlib/sarlib.h --- linux.orig/drivers/usb/sarlib/sarlib.h Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/sarlib/sarlib.h Sat Apr 22 16:51:01 2000 @@ -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 +#include +#include +#include +#include +#include +#include + +#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 -rubN linux.orig/drivers/usb/speedtouch.c linux/drivers/usb/speedtouch.c --- linux.orig/drivers/usb/speedtouch.c Thu Jan 1 01:00:00 1970 +++ linux/drivers/usb/speedtouch.c Wed Mar 21 17:14:31 2001 @@ -0,0 +1,900 @@ +/* + * Driver Module for Alcatel SpeedTouch USB xDSL modem + * + * Written by Johan Verrept (Johan.Verrept@advalvas.be) + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#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_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; + } 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 skb_queue; + udsl_usb_send_data_context_t send_ctx; + int data_started; + + /* atm device part */ + struct atm_dev *atm_dev; + struct sk_buff_head recvqueue; + struct sarlib_vcc_data *sarlib_vcc_list; + }; + +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 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; + + if (!instance->atm_dev) + return; + + atm_dev = instance->atm_dev; + + /* clean queue */ + while (!skb_queue_empty(&instance->recvqueue)) { + skb = skb_dequeue (&instance->recvqueue); + dev_kfree_skb(skb); + }; + + 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); + + 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) return -ENOMEM; + if (new != skb) { + vcc->pop(vcc, skb); + skb = new; + } + new = sarlib_encode_rawcell(dev_data->sarlib_vcc, skb); + if (!new) return -ENOMEM; + 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; +}; + + +void udsl_atm_processqueue ( struct udsl_instance_data *instance) { + struct sarlib_vcc_data *sarlib_vcc = NULL; + struct sk_buff *new = NULL, *skb = NULL; + + /* quick check */ + if (skb_queue_empty(&instance->recvqueue)) + return; + + PDEBUG("udsl_atm_processqueue entered\n"); + + while (!skb_queue_empty(&instance->recvqueue)) { + skb = skb_dequeue (&instance->recvqueue); + 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: + 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"); + 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); + }; + 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 */ + 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) { + struct udsl_instance_data *instance = (struct udsl_instance_data *)urb->context; + udsl_usb_send_data_context_t *ctx = &instance->send_ctx; + int err; + + PDEBUG("udsl_usb_send_data_completion (vcc = %p, skb = %p, status %d)\n", ctx->vcc, ctx->skb, urb->status); + + /* remove completed skb */ + ctx->skb = skb_dequeue(&(instance->skb_queue)); + ctx->vcc->pop (ctx->vcc, ctx->skb); + ctx->skb = NULL; + + if (skb_queue_empty(&instance->skb_queue)) + return; + + /* submit next skb */ + ctx->skb = skb_peek (&(instance->skb_queue)); + ctx->vcc = ((udsl_cb_t *)(ctx->skb->cb))->vcc; + + 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, + instance + ); + + 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); + } + +/**** send ******/ +int udsl_usb_send_data (struct udsl_instance_data *instance, struct atm_vcc *vcc, struct sk_buff *skb) { + int err; + urb_t *urb; + + 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); + + if (!skb_queue_empty(&instance->skb_queue)) { + ((udsl_cb_t *)skb->cb)->vcc = vcc; + skb_queue_tail (&instance->skb_queue, skb); + PDEBUG("udsl_usb_send_data: skb (0x%p) queued\n", skb); + return 0; + } + + ((udsl_cb_t *)skb->cb)->vcc = vcc; + skb_queue_tail (&instance->skb_queue, skb); + + /* submit packet */ + urb = &(instance->send_ctx.urb); + instance->send_ctx.skb = skb; + instance->send_ctx.vcc = vcc; + + 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 + ); + + 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; + + 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 */ + skb_queue_tail (&instance->recvqueue, ctx->skb); + 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); + + 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; + + skb_queue_head_init(&instance->skb_queue); + + 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) + continue; + + if (ctx->urb->status == -EINPROGRESS) + usb_unlink_urb(ctx->urb); + + usb_free_urb(ctx->urb); + kfree_skb(ctx->skb); + }; + + /* 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; + + 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 driver\n"); + + 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 */