[PATCH] jiffies.h
[opensuse:kernel.git] / drivers / usb / net / cdc-ether.c
1 // Portions of this file taken from 
2 // Petko Manolov - Petkan (petkan@dce.bg)
3 // from his driver pegasus.c
4
5 /*
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  */
20
21
22 #include <linux/jiffies.h>
23 #include <linux/slab.h>
24 #include <linux/init.h>
25 #include <linux/delay.h>
26 #include <linux/netdevice.h>
27 #include <linux/etherdevice.h>
28 #include <linux/usb.h>
29 #include <linux/module.h>
30 #include "cdc-ether.h"
31
32 static const char *version = __FILE__ ": v0.98.5 22 Sep 2001 Brad Hards and another";
33
34 /* Take any CDC device, and sort it out in probe() */
35 static struct usb_device_id CDCEther_ids[] = {
36         { USB_DEVICE_INFO(USB_CLASS_COMM, 0, 0) },
37         { } /* Terminating null entry */
38 };
39
40 /* 
41  * module parameter that provides an alternate upper limit on the 
42  * number of multicast filters we use, with a default to use all
43  * the filters available to us. Note that the actual number used
44  * is the lesser of this parameter and the number returned in the
45  * descriptor for the particular device. See Table 41 of the CDC
46  * spec for more info on the descriptor limit.
47  */
48 static int multicast_filter_limit = 32767;
49
50
51 //////////////////////////////////////////////////////////////////////////////
52 // Callback routines from USB device /////////////////////////////////////////
53 //////////////////////////////////////////////////////////////////////////////
54
55 static void read_bulk_callback( struct urb *urb )
56 {
57         ether_dev_t *ether_dev = urb->context;
58         struct net_device *net;
59         int count = urb->actual_length, res;
60         struct sk_buff  *skb;
61
62         // Sanity check 
63         if ( !ether_dev || !(ether_dev->flags & CDC_ETHER_RUNNING) ) {
64                 dbg("BULK IN callback but driver is not active!");
65                 return;
66         }
67
68         net = ether_dev->net;
69         if ( !netif_device_present(net) ) {
70                 // Somebody killed our network interface...
71                 return;
72         }
73
74         if ( ether_dev->flags & CDC_ETHER_RX_BUSY ) {
75                 // Are we already trying to receive a frame???
76                 ether_dev->stats.rx_errors++;
77                 dbg("ether_dev Rx busy");
78                 return;
79         }
80
81         // We are busy, leave us alone!
82         ether_dev->flags |= CDC_ETHER_RX_BUSY;
83
84         switch ( urb->status ) {
85                 case 0:
86                         break;
87                 case -ETIMEDOUT:
88                         dbg( "no repsonse in BULK IN" );
89                         ether_dev->flags &= ~CDC_ETHER_RX_BUSY;
90                         break;
91                 default:
92                         dbg( "%s: RX status %d", net->name, urb->status );
93                         goto goon;
94         }
95
96         // Check to make sure we got some data...
97         if ( !count ) {
98                 // We got no data!!!
99                 goto goon;
100         }
101
102         // Tell the kernel we want some memory
103         if ( !(skb = dev_alloc_skb(count)) ) {
104                 // We got no receive buffer.
105                 goto goon;
106         }
107
108         // Here's where it came from
109         skb->dev = net;
110         
111         // Now we copy it over
112         eth_copy_and_sum(skb, ether_dev->rx_buff, count, 0);
113         
114         // Not sure
115         skb_put(skb, count);
116         // Not sure here either
117         skb->protocol = eth_type_trans(skb, net);
118         
119         // Ship it off to the kernel
120         netif_rx(skb);
121         
122         // update out statistics
123         ether_dev->stats.rx_packets++;
124         ether_dev->stats.rx_bytes += count;
125
126 goon:
127         // Prep the USB to wait for another frame
128         FILL_BULK_URB( ether_dev->rx_urb, ether_dev->usb,
129                         usb_rcvbulkpipe(ether_dev->usb, ether_dev->data_ep_in),
130                         ether_dev->rx_buff, ether_dev->wMaxSegmentSize, 
131                         read_bulk_callback, ether_dev );
132                         
133         // Give this to the USB subsystem so it can tell us 
134         // when more data arrives.
135         if ( (res = usb_submit_urb(ether_dev->rx_urb, GFP_KERNEL)) ) {
136                 warn( __FUNCTION__ " failed submint rx_urb %d", res);
137         }
138         
139         // We are no longer busy, show us the frames!!!
140         ether_dev->flags &= ~CDC_ETHER_RX_BUSY;
141 }
142
143 static void write_bulk_callback( struct urb *urb )
144 {
145         ether_dev_t *ether_dev = urb->context;
146
147         // Sanity check
148         if ( !ether_dev || !(ether_dev->flags & CDC_ETHER_RUNNING) ) {
149                 // We are insane!!!
150                 err( "write_bulk_callback: device not running" );
151                 return;
152         }
153
154         // Do we still have a valid kernel network device?
155         if ( !netif_device_present(ether_dev->net) ) {
156                 // Someone killed our network interface.
157                 err( "write_bulk_callback: net device not present" );
158                 return;
159         }
160
161         // Hmm...  What on Earth could have happened???
162         if ( urb->status ) {
163                 info("%s: TX status %d", ether_dev->net->name, urb->status);
164         }
165
166         // Update the network interface and tell it we are
167         // ready for another frame
168         ether_dev->net->trans_start = jiffies;
169         netif_wake_queue( ether_dev->net );
170 }
171
172 //static void intr_callback( struct urb *urb )
173 //{
174 //      ether_dev_t *ether_dev = urb->context;
175 //      struct net_device *net;
176 //      __u8    *d;
177 //
178 //      if ( !ether_dev )
179 //              return;
180 //              
181 //      switch ( urb->status ) {
182 //              case 0:
183 //                      break;
184 //              case -ENOENT:
185 //                      return;
186 //              default:
187 //                      info("intr status %d", urb->status);
188 //      }
189 //
190 //      d = urb->transfer_buffer;
191 //      net = ether_dev->net;
192 //      if ( d[0] & 0xfc ) {
193 //              ether_dev->stats.tx_errors++;
194 //              if ( d[0] & TX_UNDERRUN )
195 //                      ether_dev->stats.tx_fifo_errors++;
196 //              if ( d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT) )
197 //                      ether_dev->stats.tx_aborted_errors++;
198 //              if ( d[0] & LATE_COL )
199 //                      ether_dev->stats.tx_window_errors++;
200 //              if ( d[0] & (NO_CARRIER | LOSS_CARRIER) )
201 //                      ether_dev->stats.tx_carrier_errors++;
202 //      }
203 //}
204
205 //////////////////////////////////////////////////////////////////////////////
206 // Routines for turning net traffic on and off on the USB side ///////////////
207 //////////////////////////////////////////////////////////////////////////////
208
209 static inline int enable_net_traffic( ether_dev_t *ether_dev )
210 {
211         struct usb_device *usb = ether_dev->usb;
212
213         // Here would be the time to set the data interface to the configuration where
214         // it has two endpoints that use a protocol we can understand.
215
216         if (usb_set_interface( usb, 
217                                 ether_dev->data_bInterfaceNumber, 
218                                 ether_dev->data_bAlternateSetting_with_traffic ) )  {
219                 err("usb_set_interface() failed" );
220                 err("Attempted to set interface %d", ether_dev->data_bInterfaceNumber);
221                 err("To alternate setting       %d", ether_dev->data_bAlternateSetting_with_traffic);
222                 return -1;
223         }
224         return 0;
225 }
226
227 static inline void disable_net_traffic( ether_dev_t *ether_dev )
228 {
229         // The thing to do is to set the data interface to the alternate setting that has
230         // no endpoints.  This is what the spec suggests.
231
232         if (ether_dev->data_interface_altset_num_without_traffic >= 0 ) {
233                 if (usb_set_interface( ether_dev->usb, 
234                                         ether_dev->data_bInterfaceNumber, 
235                                         ether_dev->data_bAlternateSetting_without_traffic ) )   {
236                         err("usb_set_interface() failed");
237                 }
238         } else {
239                 // Some devices just may not support this...
240                 warn("No way to disable net traffic");
241         }
242 }
243
244 //////////////////////////////////////////////////////////////////////////////
245 // Callback routines for kernel Ethernet Device //////////////////////////////
246 //////////////////////////////////////////////////////////////////////////////
247
248 static void CDCEther_tx_timeout( struct net_device *net )
249 {
250         ether_dev_t *ether_dev = net->priv;
251
252         // Sanity check
253         if ( !ether_dev ) {
254                 // Seems to be a case of insanity here
255                 return;
256         }
257
258         // Tell syslog we are hosed.
259         warn("%s: Tx timed out.", net->name);
260         
261         // Tear the waiting frame off the list
262         ether_dev->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
263         usb_unlink_urb( ether_dev->tx_urb );
264         
265         // Update statistics
266         ether_dev->stats.tx_errors++;
267 }
268
269 static int CDCEther_start_xmit( struct sk_buff *skb, struct net_device *net )
270 {
271         ether_dev_t     *ether_dev = net->priv;
272         int     count;
273         int     res;
274
275         // If we are told to transmit an ethernet frame that fits EXACTLY 
276         // into an integer number of USB packets, we force it to send one 
277         // more byte so the device will get a runt USB packet signalling the 
278         // end of the ethernet frame
279         if ( (skb->len) ^ (ether_dev->data_ep_out_size) ) {
280                 // It was not an exact multiple
281                 // no need to add anything extra
282                 count = skb->len;
283         } else {
284                 // Add one to make it NOT an exact multiple
285                 count = skb->len + 1;
286         }
287
288         // Tell the kernel, "No more frames 'til we are done
289         // with this one.'
290         netif_stop_queue( net );
291
292         // Copy it from kernel memory to OUR memory
293         memcpy(ether_dev->tx_buff, skb->data, skb->len);
294
295         // Fill in the URB for shipping it out.
296         FILL_BULK_URB( ether_dev->tx_urb, ether_dev->usb,
297                         usb_sndbulkpipe(ether_dev->usb, ether_dev->data_ep_out),
298                         ether_dev->tx_buff, ether_dev->wMaxSegmentSize, 
299                         write_bulk_callback, ether_dev );
300
301         // Tell the URB how much it will be transporting today
302         ether_dev->tx_urb->transfer_buffer_length = count;
303         
304         // Send the URB on its merry way.
305         if ((res = usb_submit_urb(ether_dev->tx_urb, GFP_KERNEL)))  {
306                 // Hmm...  It didn't go. Tell someone...
307                 warn("failed tx_urb %d", res);
308                 // update some stats...
309                 ether_dev->stats.tx_errors++;
310                 // and tell the kernel to give us another.
311                 // Maybe we'll get it right next time.
312                 netif_start_queue( net );
313         } else {
314                 // Okay, it went out.
315                 // Update statistics
316                 ether_dev->stats.tx_packets++;
317                 ether_dev->stats.tx_bytes += skb->len;
318                 // And tell the kernel when the last transmit occurred.
319                 net->trans_start = jiffies;
320         }
321
322         // We are done with the kernel's memory
323         dev_kfree_skb(skb);
324
325         // We are done here.
326         return 0;
327 }
328
329 static struct net_device_stats *CDCEther_netdev_stats( struct net_device *net )
330 {
331         // Easy enough!
332         return &((ether_dev_t *)net->priv)->stats;
333 }
334
335 static int CDCEther_open(struct net_device *net)
336 {
337         ether_dev_t *ether_dev = (ether_dev_t *)net->priv;
338         int     res;
339
340         // Turn on the USB and let the packets flow!!!
341         if ( (res = enable_net_traffic( ether_dev )) ) {
342                 err( __FUNCTION__ "can't enable_net_traffic() - %d", res );
343                 return -EIO;
344         }
345
346         // Prep a receive URB
347         FILL_BULK_URB( ether_dev->rx_urb, ether_dev->usb,
348                         usb_rcvbulkpipe(ether_dev->usb, ether_dev->data_ep_in),
349                         ether_dev->rx_buff, ether_dev->wMaxSegmentSize, 
350                         read_bulk_callback, ether_dev );
351
352         // Put it out there so the device can send us stuff
353         if ( (res = usb_submit_urb(ether_dev->rx_urb, GFP_KERNEL)) )
354         {
355                 // Hmm...  Okay...
356                 warn( __FUNCTION__ " failed rx_urb %d", res );
357         }
358
359         // Tell the kernel we are ready to start receiving from it
360         netif_start_queue( net );
361         
362         // We are up and running.
363         ether_dev->flags |= CDC_ETHER_RUNNING;
364
365         // Let's get ready to move frames!!!
366         return 0;
367 }
368
369 static int CDCEther_close( struct net_device *net )
370 {
371         ether_dev_t     *ether_dev = net->priv;
372
373         // We are no longer running.
374         ether_dev->flags &= ~CDC_ETHER_RUNNING;
375         
376         // Tell the kernel to stop sending us stuff
377         netif_stop_queue( net );
378         
379         // If we are not already unplugged, turn off USB
380         // traffic
381         if ( !(ether_dev->flags & CDC_ETHER_UNPLUG) ) {
382                 disable_net_traffic( ether_dev );
383         }
384
385         // We don't need the URBs anymore.
386         usb_unlink_urb( ether_dev->rx_urb );
387         usb_unlink_urb( ether_dev->tx_urb );
388         usb_unlink_urb( ether_dev->intr_urb );
389         
390         // That's it.  I'm done.
391         return 0;
392 }
393
394 static int CDCEther_ioctl( struct net_device *net, struct ifreq *rq, int cmd )
395 {
396         //__u16 *data = (__u16 *)&rq->ifr_data;
397         //ether_dev_t   *ether_dev = net->priv;
398
399         // No support here yet.
400         // Do we need support???
401         switch(cmd) {
402                 case SIOCDEVPRIVATE:
403                         return -EOPNOTSUPP;
404                 case SIOCDEVPRIVATE+1:
405                         return -EOPNOTSUPP;
406                 case SIOCDEVPRIVATE+2:
407                         //return 0;
408                         return -EOPNOTSUPP;
409                 default:
410                         return -EOPNOTSUPP;
411         }
412 }
413
414 static void CDC_SetEthernetPacketFilter (ether_dev_t *ether_dev)
415 {
416         usb_control_msg(ether_dev->usb,
417                         usb_sndctrlpipe(ether_dev->usb, 0),
418                         SET_ETHERNET_PACKET_FILTER, /* request */
419                         USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE, /* request type */
420                         cpu_to_le16(ether_dev->mode_flags), /* value */
421                         cpu_to_le16((u16)ether_dev->comm_interface), /* index */
422                         NULL,
423                         0, /* size */
424                         HZ); /* timeout */
425 }       
426
427
428 static void CDCEther_set_multicast( struct net_device *net )
429 {
430         ether_dev_t *ether_dev = net->priv;
431         int i;
432         __u8 *buff;
433         
434
435         // Tell the kernel to stop sending us frames while we get this
436         // all set up.
437         netif_stop_queue(net);
438
439       /* Note: do not reorder, GCC is clever about common statements. */
440         if (net->flags & IFF_PROMISC) {
441                 /* Unconditionally log net taps. */
442                 info( "%s: Promiscuous mode enabled", net->name);
443                 ether_dev->mode_flags = MODE_FLAG_PROMISCUOUS |
444                         MODE_FLAG_ALL_MULTICAST |
445                         MODE_FLAG_DIRECTED |
446                         MODE_FLAG_BROADCAST |
447                         MODE_FLAG_MULTICAST;
448         } else if (net->mc_count > ether_dev->wNumberMCFilters) {
449                 /* Too many to filter perfectly -- accept all multicasts. */
450                 info("%s: set too many MC filters, using allmulti", net->name);
451                 ether_dev->mode_flags = MODE_FLAG_ALL_MULTICAST |
452                         MODE_FLAG_DIRECTED |
453                         MODE_FLAG_BROADCAST |
454                         MODE_FLAG_MULTICAST;
455         } else if (net->flags & IFF_ALLMULTI) {
456                 /* Filter in software */
457                 info("%s: using allmulti", net->name);
458                 ether_dev->mode_flags = MODE_FLAG_ALL_MULTICAST |
459                         MODE_FLAG_DIRECTED |
460                         MODE_FLAG_BROADCAST |
461                         MODE_FLAG_MULTICAST;
462         } else {
463                 /* do multicast filtering in hardware */
464                 struct dev_mc_list *mclist;
465                 info("%s: set multicast filters", net->name);
466                 ether_dev->mode_flags = MODE_FLAG_ALL_MULTICAST |
467                         MODE_FLAG_DIRECTED |
468                         MODE_FLAG_BROADCAST |
469                         MODE_FLAG_MULTICAST;
470                 buff = kmalloc(6 * net->mc_count, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
471                 for (i = 0, mclist = net->mc_list;
472                      mclist && i < net->mc_count;
473                      i++, mclist = mclist->next) {
474                         memcpy(&mclist->dmi_addr, &buff[i * 6], 6);
475                 }
476 #if 0
477                 usb_control_msg(ether_dev->usb,
478                                 usb_sndctrlpipe(ether_dev->usb, 0),
479                                 SET_ETHERNET_MULTICAST_FILTER, /* request */
480                                 USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE, /* request type */
481                                 cpu_to_le16(net->mc_count), /* value */
482                                 cpu_to_le16((u16)ether_dev->comm_interface), /* index */
483                                 buff,
484                                 (6* net->mc_count), /* size */
485                                 HZ); /* timeout */
486 #endif
487                 kfree(buff);
488         }
489
490 #if 0 
491         CDC_SetEthernetPacketFilter(ether_dev);
492 #endif  
493         // Tell the kernel to start giving frames to us again.
494         netif_wake_queue(net);
495 }
496
497 //////////////////////////////////////////////////////////////////////////////
498 // Routines used to parse out the Functional Descriptors /////////////////////
499 //////////////////////////////////////////////////////////////////////////////
500
501 static int parse_header_functional_descriptor( int *bFunctionLength, 
502                                                int bDescriptorType, 
503                                                int bDescriptorSubtype,
504                                                unsigned char *data,
505                                                ether_dev_t *ether_dev,
506                                                int *requirements )
507 {
508         // Check to make sure we haven't seen one of these already.
509         if ( (~*requirements) & REQ_HDR_FUNC_DESCR ) {
510                 err( "Multiple Header Functional Descriptors found." );
511                 return -1;
512         }
513         
514         // Is it the right size???
515         if (*bFunctionLength != 5) {
516                 info( "Invalid length in Header Functional Descriptor" );
517                 // This is a hack to get around a particular device (NO NAMES)
518                 // It has this function length set to the length of the
519                 // whole class-specific descriptor
520                 *bFunctionLength = 5;
521         }
522         
523         // Nothing extremely useful here.
524         // We'll keep it for posterity
525         ether_dev->bcdCDC = data[0] + (data[1] << 8);
526         dbg( "Found Header descriptor, CDC version %x", ether_dev->bcdCDC);
527
528         // We've seen one of these
529         *requirements &= ~REQ_HDR_FUNC_DESCR;
530         
531         // It's all good.
532         return 0;
533 }
534
535 static int parse_union_functional_descriptor( int *bFunctionLength, 
536                                               int bDescriptorType, 
537                                               int bDescriptorSubtype,
538                                               unsigned char *data,
539                                               ether_dev_t *ether_dev,
540                                               int *requirements )
541 {
542         // Check to make sure we haven't seen one of these already.
543         if ( (~*requirements) & REQ_UNION_FUNC_DESCR ) {
544                 err( "Multiple Union Functional Descriptors found." );
545                 return -1;
546         }
547
548         // Is it the right size?
549         if (*bFunctionLength != 5) {
550                 // It is NOT the size we expected.
551                 err( "Unsupported length in Union Functional Descriptor" );
552                 return -1;
553         }
554         
555         // Sanity check of sorts
556         if (ether_dev->comm_interface != data[0]) {
557                 // This tells us that we are chasing the wrong comm
558                 // interface or we are crazy or something else weird.
559                 if (ether_dev->comm_interface == data[1]) {
560                         info( "Probably broken Union descriptor, fudging data interface" );
561                         // We'll need this in a few microseconds, 
562                         // so guess here, and hope for the best
563                         ether_dev->data_interface = data[0];
564                 } else {
565                         err( "Union Functional Descriptor is broken beyond repair" );
566                         return -1;
567                 }
568         } else{ // Descriptor is OK
569                 // We'll need this in a few microseconds!
570                 ether_dev->data_interface = data[1];
571         }
572
573         // We've seen one of these now.
574         *requirements &= ~REQ_UNION_FUNC_DESCR;
575         
576         // Done
577         return 0;
578 }
579
580 static int parse_ethernet_functional_descriptor( int *bFunctionLength, 
581                                                  int bDescriptorType, 
582                                                  int bDescriptorSubtype,
583                                                  unsigned char *data,
584                                                  ether_dev_t *ether_dev,
585                                                  int *requirements )
586 {
587         // Check to make sure we haven't seen one of these already.
588         if ( (~*requirements) & REQ_ETH_FUNC_DESCR ) {
589                 err( "Multiple Ethernet Functional Descriptors found." );
590                 return -1;
591         }
592         
593         // Is it the right size?
594         if (*bFunctionLength != 13) {
595                 err( "Invalid length in Ethernet Networking Functional Descriptor" );
596                 return -1;
597         }
598         
599         // Lots of goodies from this one.  They are all important.
600         ether_dev->iMACAddress = data[0];
601         ether_dev->bmEthernetStatistics = data[1] + (data[2] << 8) + (data[3] << 16) + (data[4] << 24);
602         ether_dev->wMaxSegmentSize = data[5] + (data[6] << 8);
603         ether_dev->wNumberMCFilters = (data[7] + (data[8] << 8)) & 0x00007FFF;
604         if (ether_dev->wNumberMCFilters > multicast_filter_limit) {
605                 ether_dev->wNumberMCFilters = multicast_filter_limit;
606                 }       
607         ether_dev->bNumberPowerFilters = data[9];
608         
609         // We've seen one of these now.
610         *requirements &= ~REQ_ETH_FUNC_DESCR;
611         
612         // That's all she wrote.
613         return 0;
614 }
615
616 static int parse_protocol_unit_functional_descriptor( int *bFunctionLength, 
617                                                       int bDescriptorType, 
618                                                       int bDescriptorSubtype,
619                                                       unsigned char *data,
620                                                       ether_dev_t *ether_dev,
621                                                       int *requirements )
622 {
623         // There should only be one type if we are sane
624         if (bDescriptorType != CS_INTERFACE) {
625                 info( "Invalid bDescriptorType found." );
626                 return -1;
627         }
628
629         // The Subtype tells the tale.
630         switch (bDescriptorSubtype){
631                 case 0x00:      // Header Functional Descriptor
632                         return parse_header_functional_descriptor( bFunctionLength,
633                                                                    bDescriptorType,
634                                                                    bDescriptorSubtype,
635                                                                    data,
636                                                                    ether_dev,
637                                                                    requirements );
638                         break;
639                 case 0x06:      // Union Functional Descriptor
640                         return parse_union_functional_descriptor( bFunctionLength,
641                                                                   bDescriptorType,
642                                                                   bDescriptorSubtype,
643                                                                   data,
644                                                                   ether_dev,
645                                                                   requirements );
646                         break;
647                 case 0x0F:      // Ethernet Networking Functional Descriptor
648                         return parse_ethernet_functional_descriptor( bFunctionLength,
649                                                                      bDescriptorType,
650                                                                      bDescriptorSubtype,
651                                                                      data,
652                                                                      ether_dev,
653                                                                      requirements );
654                         break;
655                 default:        // We don't support this at this time...
656                         // However that doesn't necessarily indicate an error.
657                         dbg( "Unexpected header type %x:", bDescriptorSubtype );
658                         return 0;
659         }
660         // How did we get here???
661         return -1;
662 }
663
664 static int parse_ethernet_class_information( unsigned char *data, int length, ether_dev_t *ether_dev )
665 {
666         int loc = 0;
667         int rc;
668         int bFunctionLength;
669         int bDescriptorType;
670         int bDescriptorSubtype;
671         int requirements = REQUIREMENTS_TOTAL;
672
673         // As long as there is something here, we will try to parse it
674         while (loc < length) {
675                 // Length
676                 bFunctionLength = data[loc];
677                 loc++;
678                 
679                 // Type
680                 bDescriptorType = data[loc];
681                 loc++;
682                 
683                 // Subtype
684                 bDescriptorSubtype = data[loc];
685                 loc++;
686                 
687                 // ship this off to be processed elsewhere.
688                 rc = parse_protocol_unit_functional_descriptor( &bFunctionLength, 
689                                                                 bDescriptorType, 
690                                                                 bDescriptorSubtype, 
691                                                                 &data[loc],
692                                                                 ether_dev,
693                                                                 &requirements );
694                 // Did it process okay?
695                 if (rc) {
696                         // Something was hosed somewhere.
697                         // No need to continue;
698                         err("Bad descriptor parsing: %x", rc );
699                         return -1;
700                 }
701                 // We have already taken three bytes.
702                 loc += (bFunctionLength - 3);
703         }
704         // Check to see if we got everything we need.
705         if (requirements) {
706                 // We missed some of the requirements...
707                 err( "Not all required functional descriptors present 0x%08X", requirements );
708                 return -1;
709         }
710         // We got everything.
711         return 0;
712 }
713
714 //////////////////////////////////////////////////////////////////////////////
715 // Routine to check for the existence of the Functional Descriptors //////////
716 //////////////////////////////////////////////////////////////////////////////
717
718 static int find_and_parse_ethernet_class_information( struct usb_device *device, ether_dev_t *ether_dev )
719 {
720         struct usb_config_descriptor *conf = NULL;
721         struct usb_interface *comm_intf_group = NULL;
722         struct usb_interface_descriptor *comm_intf = NULL;
723         int rc = -1;
724         // The assumption here is that find_ethernet_comm_interface
725         // and find_valid_configuration 
726         // have already filled in the information about where to find
727         // the a valid commication interface.
728
729         conf = &( device->config[ether_dev->configuration_num] );
730         comm_intf_group = &( conf->interface[ether_dev->comm_interface] );
731         comm_intf = &( comm_intf_group->altsetting[ether_dev->comm_interface_altset_num] );
732         // Let's check and see if it has the extra information we need...
733
734         if (comm_intf->extralen > 0) {
735                 // This is where the information is SUPPOSED to be.
736                 rc = parse_ethernet_class_information( comm_intf->extra, comm_intf->extralen, ether_dev );
737         } else if (conf->extralen > 0) {
738                 // This is a hack.  The spec says it should be at the interface 
739                 // location checked above.  However I have seen it here also.
740                 // This is the same device that requires the functional descriptor hack above
741                 warn( "Ethernet information found at device configuration.  This is broken." );
742                 rc = parse_ethernet_class_information( conf->extra, conf->extralen, ether_dev );
743         } else  {
744                 // I don't know where else to look.
745                 warn( "No ethernet information found." );
746                 rc = -1;
747         }
748         return rc;
749 }
750
751 //////////////////////////////////////////////////////////////////////////////
752 // Routines to verify the data interface /////////////////////////////////////
753 //////////////////////////////////////////////////////////////////////////////
754
755 static int get_data_interface_endpoints( struct usb_device *device, ether_dev_t *ether_dev )
756 {
757         struct usb_config_descriptor *conf = NULL;
758         struct usb_interface *data_intf_group = NULL;
759         struct usb_interface_descriptor *data_intf = NULL;
760         
761         // Walk through and get to the data interface we are checking.
762         conf = &( device->config[ether_dev->configuration_num] );
763         data_intf_group = &( conf->interface[ether_dev->data_interface] );
764         data_intf = &( data_intf_group->altsetting[ether_dev->data_interface_altset_num_with_traffic] );
765
766         // Start out assuming we won't find anything we can use
767         ether_dev->data_ep_in = 0;
768         ether_dev->data_ep_out = 0;
769         
770         // If these are not BULK endpoints, we don't want them
771         if ( data_intf->endpoint[0].bmAttributes != 0x02 ) {
772                 return -1;
773         } if ( data_intf->endpoint[1].bmAttributes != 0x02 ) {
774                 return -1;
775         }
776
777         // Check the first endpoint to see if it is IN or OUT
778         if ( data_intf->endpoint[0].bEndpointAddress & 0x80 ) {
779                 // This endpoint is IN
780                 ether_dev->data_ep_in = data_intf->endpoint[0].bEndpointAddress & 0x7F;
781         } else {
782                 // This endpoint is OUT
783                 ether_dev->data_ep_out = data_intf->endpoint[0].bEndpointAddress & 0x7F;
784                 ether_dev->data_ep_out_size = data_intf->endpoint[0].wMaxPacketSize;
785         }
786
787         // Check the second endpoint to see if it is IN or OUT
788         if ( data_intf->endpoint[1].bEndpointAddress & 0x80 ) {
789                 // This endpoint is IN
790                 ether_dev->data_ep_in = data_intf->endpoint[1].bEndpointAddress & 0x7F;
791         } else  {
792                 // This endpoint is OUT
793                 ether_dev->data_ep_out = data_intf->endpoint[1].bEndpointAddress & 0x7F;
794                 ether_dev->data_ep_out_size = data_intf->endpoint[1].wMaxPacketSize;
795         }
796         
797         // Now make sure we got both an IN and an OUT
798         if (ether_dev->data_ep_in && ether_dev->data_ep_out) {
799                 // We did get both, we are in good shape...
800                 info( "detected BULK OUT packets of size %d", ether_dev->data_ep_out_size );
801                 return 0;
802         }
803         return -1;
804 }
805
806 static int verify_ethernet_data_interface( struct usb_device *device, ether_dev_t *ether_dev )
807 {
808         struct usb_config_descriptor *conf = NULL;
809         struct usb_interface *data_intf_group = NULL;
810         struct usb_interface_descriptor *data_intf = NULL;
811         int rc = -1;
812         int status;
813         int altset_num;
814
815         // The assumption here is that parse_ethernet_class_information()
816         // and find_valid_configuration() 
817         // have already filled in the information about where to find
818         // a data interface
819         conf = &( device->config[ether_dev->configuration_num] );
820         data_intf_group = &( conf->interface[ether_dev->data_interface] );
821
822         // start out assuming we won't find what we are looking for.
823         ether_dev->data_interface_altset_num_with_traffic = -1;
824         ether_dev->data_bAlternateSetting_with_traffic = -1;
825         ether_dev->data_interface_altset_num_without_traffic = -1;
826         ether_dev->data_bAlternateSetting_without_traffic = -1;
827
828         // Walk through every possible setting for this interface until
829         // we find what makes us happy.
830         for ( altset_num = 0; altset_num < data_intf_group->num_altsetting; altset_num++ ) {
831                 data_intf = &( data_intf_group->altsetting[altset_num] );
832
833                 // Is this a data interface we like?
834                 if ( ( data_intf->bInterfaceClass == 0x0A )
835                    && ( data_intf->bInterfaceSubClass == 0x00 )
836                    && ( data_intf->bInterfaceProtocol == 0x00 ) ) {
837                         if ( data_intf->bNumEndpoints == 2 ) {
838                                 // We are required to have one of these.
839                                 // An interface with 2 endpoints to send Ethernet traffic back and forth
840                                 // It actually may be possible that the device might only
841                                 // communicate in a vendor specific manner.
842                                 // That would not be very nice.
843                                 // We can add that one later.
844                                 ether_dev->data_bInterfaceNumber = data_intf->bInterfaceNumber;
845                                 ether_dev->data_interface_altset_num_with_traffic = altset_num;
846                                 ether_dev->data_bAlternateSetting_with_traffic = data_intf->bAlternateSetting;
847                                 status = get_data_interface_endpoints( device, ether_dev );
848                                 if (!status) {
849                                         rc = 0;
850                                 }
851                         }
852                         if ( data_intf->bNumEndpoints == 0 ) {
853                                 // According to the spec we are SUPPOSED to have one of these
854                                 // In fact the device is supposed to come up in this state.
855                                 // However, I have seen a device that did not have such an interface.
856                                 // So it must be just optional for our driver...
857                                 ether_dev->data_bInterfaceNumber = data_intf->bInterfaceNumber;
858                                 ether_dev->data_interface_altset_num_without_traffic = altset_num;
859                                 ether_dev->data_bAlternateSetting_without_traffic = data_intf->bAlternateSetting;
860                         }
861                 }
862         }
863         return rc;
864 }
865
866 //////////////////////////////////////////////////////////////////////////////
867 // Routine to find a communication interface /////////////////////////////////
868 //////////////////////////////////////////////////////////////////////////////
869
870 static int find_ethernet_comm_interface( struct usb_device *device, ether_dev_t *ether_dev )
871 {
872         struct usb_config_descriptor *conf = NULL;
873         struct usb_interface *comm_intf_group = NULL;
874         struct usb_interface_descriptor *comm_intf = NULL;
875         int intf_num;
876         int altset_num;
877         int rc;
878
879         conf = &( device->config[ether_dev->configuration_num] );
880
881         // We need to check and see if any of these interfaces are something we want.
882         // Walk through each interface one at a time
883         for ( intf_num = 0; intf_num < conf->bNumInterfaces; intf_num++ ) {
884                 comm_intf_group = &( conf->interface[intf_num] );
885                 // Now for each of those interfaces, check every possible
886                 // alternate setting.
887                 for ( altset_num = 0; altset_num < comm_intf_group->num_altsetting; altset_num++ ) {
888                         comm_intf = &( comm_intf_group->altsetting[altset_num] );
889
890                         // Is this a communication class of interface of the
891                         // ethernet subclass variety.
892                         if ( ( comm_intf->bInterfaceClass == 0x02 )
893                            && ( comm_intf->bInterfaceSubClass == 0x06 )
894                            && ( comm_intf->bInterfaceProtocol == 0x00 ) ) {
895                                 if ( comm_intf->bNumEndpoints == 1 ) {
896                                         // Good, we found one, we will try this one
897                                         // Fill in the structure...
898                                         ether_dev->comm_interface = intf_num;
899                                         ether_dev->comm_bInterfaceNumber = comm_intf->bInterfaceNumber;
900                                         ether_dev->comm_interface_altset_num = altset_num;
901                                         ether_dev->comm_bAlternateSetting = comm_intf->bAlternateSetting;
902
903                                         // Look for the Ethernet Functional Descriptors
904                                         rc = find_and_parse_ethernet_class_information( device, ether_dev );
905                                         if (rc) {
906                                                 // Nope this was no good after all.
907                                                 continue;
908                                         }
909
910                                         // Check that we really can talk to the data
911                                         // interface 
912                                         // This includes # of endpoints, protocols,
913                                         // etc.
914                                         rc = verify_ethernet_data_interface( device, ether_dev );
915                                         if (rc) {
916                                                 // We got something we didn't like
917                                                 continue;
918                                         }
919                                         // This communication interface seems to give us everything
920                                         // we require.  We have all the ethernet info we need.
921                                         // Let's get out of here and go home right now.
922                                         return 0;
923                                 } else {
924                                         // bNumEndPoints != 1
925                                         // We found an interface that had the wrong number of 
926                                         // endpoints but would have otherwise been okay
927                                 } // end bNumEndpoints check.
928                         } // end interface specifics check.
929                 } // end for altset_num
930         } // end for intf_num
931         return -1;
932 }
933
934 //////////////////////////////////////////////////////////////////////////////
935 // Routine to go through all configurations and find one that ////////////////
936 // is an Ethernet Networking Device //////////////////////////////////////////
937 //////////////////////////////////////////////////////////////////////////////
938
939 static int find_valid_configuration( struct usb_device *device, ether_dev_t *ether_dev )
940 {
941         struct usb_config_descriptor *conf = NULL;
942         int conf_num;
943         int rc;
944
945         // We will try each and every possible configuration
946         for ( conf_num = 0; conf_num < device->descriptor.bNumConfigurations; conf_num++ ) {
947                 conf = &( device->config[conf_num] );
948
949                 // Our first requirement : 2 interfaces
950                 if ( conf->bNumInterfaces != 2 ) {
951                         // I currently don't know how to handle devices with any number of interfaces
952                         // other than 2.
953                         continue;
954                 }
955
956                 // This one passed our first check, fill in some 
957                 // useful data
958                 ether_dev->configuration_num = conf_num;
959                 ether_dev->bConfigurationValue = conf->bConfigurationValue;
960
961                 // Now run it through the ringers and see what comes
962                 // out the other side.
963                 rc = find_ethernet_comm_interface( device, ether_dev );
964
965                 // Check if we found an ethernet Communcation Device
966                 if ( !rc ) {
967                         // We found one.
968                         return 0;
969                 }
970         }
971         // None of the configurations suited us.
972         return -1;
973 }
974
975 //////////////////////////////////////////////////////////////////////////////
976 // Routine that checks a given configuration to see if any driver ////////////
977 // has claimed any of the devices interfaces /////////////////////////////////
978 //////////////////////////////////////////////////////////////////////////////
979
980 static int check_for_claimed_interfaces( struct usb_config_descriptor *config )
981 {
982         struct usb_interface *comm_intf_group;
983         int intf_num;
984
985         // Go through all the interfaces and make sure none are 
986         // claimed by anybody else.
987         for ( intf_num = 0; intf_num < config->bNumInterfaces; intf_num++ ) {
988                 comm_intf_group = &( config->interface[intf_num] );
989                 if ( usb_interface_claimed( comm_intf_group ) ) {
990                         // Somebody has beat us to this guy.
991                         // We can't change the configuration out from underneath of whoever
992                         // is using this device, so we will go ahead and give up.
993                         return -1;
994                 }
995         }
996         // We made it all the way through.
997         // I guess no one has claimed any of these interfaces.
998         return 0;
999 }
1000
1001 //////////////////////////////////////////////////////////////////////////////
1002 // Routines to ask for and set the kernel network interface's MAC address ////
1003 // Used by driver's probe routine ////////////////////////////////////////////
1004 //////////////////////////////////////////////////////////////////////////////
1005
1006 static inline unsigned char hex2dec( unsigned char digit )
1007 {
1008         // Is there a standard way to do this???
1009         // I have written this code TOO MANY times.
1010         if ( (digit >= '0') && (digit <= '9') ) {
1011                 return (digit - '0');
1012         }
1013         if ( (digit >= 'a') && (digit <= 'f') ) {
1014                 return (digit - 'a' + 10);
1015         }
1016         if ( (digit >= 'A') && (digit <= 'F') ) {
1017                 return (digit - 'A' + 10);
1018         }
1019         return 0;
1020 }
1021
1022 static void set_ethernet_addr( ether_dev_t *ether_dev )
1023 {
1024         unsigned char   mac_addr[6];
1025         int             i;
1026         int             len;
1027         unsigned char   buffer[13];
1028
1029         // Let's assume we don't get anything...
1030         mac_addr[0] = 0x00;
1031         mac_addr[1] = 0x00;
1032         mac_addr[2] = 0x00;
1033         mac_addr[3] = 0x00;
1034         mac_addr[4] = 0x00;
1035         mac_addr[5] = 0x00;
1036
1037         // Let's ask the device...
1038         len = usb_string(ether_dev->usb, ether_dev->iMACAddress, buffer, 13);
1039
1040         // Sanity check!
1041         if (len != 12)  {
1042                 // You gotta love failing sanity checks
1043                 err("Attempting to get MAC address returned %d bytes", len);
1044                 return;
1045         }
1046
1047         // Fill in the mac_addr
1048         for (i = 0; i < 6; i++) {
1049                 mac_addr[i] = ( hex2dec( buffer[2 * i] ) << 4 ) + hex2dec( buffer[2 * i + 1] );
1050         }
1051
1052         // Now copy it over to the kernel's network driver.
1053         memcpy( ether_dev->net->dev_addr, mac_addr, sizeof(mac_addr) );
1054 }
1055
1056 //////////////////////////////////////////////////////////////////////////////
1057 // Routine to print to syslog information about the driver ///////////////////
1058 // Used by driver's probe routine ////////////////////////////////////////////
1059 //////////////////////////////////////////////////////////////////////////////
1060
1061 void log_device_info(ether_dev_t *ether_dev)
1062 {
1063         int len;
1064         int string_num;
1065         unsigned char manu[256];
1066         unsigned char prod[256];
1067         unsigned char sern[256];
1068         unsigned char *mac_addr;
1069
1070         // Default empty strings in case we don't find a real one
1071         manu[0] = 0x00;
1072         prod[0] = 0x00;
1073         sern[0] = 0x00;
1074
1075         // Try to get the device Manufacturer
1076         string_num = ether_dev->usb->descriptor.iManufacturer;
1077         if (string_num) {
1078                 // Put it into its buffer
1079                 len = usb_string(ether_dev->usb, string_num, manu, 255);
1080                 // Just to be safe
1081                 manu[len] = 0x00;
1082         }
1083
1084         // Try to get the device Product Name
1085         string_num = ether_dev->usb->descriptor.iProduct;
1086         if (string_num) {
1087                 // Put it into its buffer
1088                 len = usb_string(ether_dev->usb, string_num, prod, 255);
1089                 // Just to be safe
1090                 prod[len] = 0x00;
1091         }
1092
1093         // Try to get the device Serial Number
1094         string_num = ether_dev->usb->descriptor.iSerialNumber;
1095         if (string_num) {
1096                 // Put it into its buffer
1097                 len = usb_string(ether_dev->usb, string_num, sern, 255);
1098                 // Just to be safe
1099                 sern[len] = 0x00;
1100         }
1101
1102         // This makes it easier for us to print
1103         mac_addr = ether_dev->net->dev_addr;
1104
1105         // Now send everything we found to the syslog
1106         info( "%s: %s %s %s %02X:%02X:%02X:%02X:%02X:%02X", 
1107               ether_dev->net->name, manu, prod, sern, mac_addr[0], 
1108               mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], 
1109               mac_addr[5] );
1110 }
1111
1112 /* Forward declaration */
1113 static struct usb_driver CDCEther_driver ;
1114
1115 //////////////////////////////////////////////////////////////////////////////
1116 // Module's probe routine ////////////////////////////////////////////////////
1117 // claims interfaces if they are for an Ethernet CDC /////////////////////////
1118 //////////////////////////////////////////////////////////////////////////////
1119
1120 static void * CDCEther_probe( struct usb_device *usb, unsigned int ifnum,
1121                              const struct usb_device_id *id)
1122 {
1123         struct net_device       *net;
1124         ether_dev_t             *ether_dev;
1125         int                     rc;
1126
1127         // First we should check the active configuration to see if 
1128         // any other driver has claimed any of the interfaces.
1129         if ( check_for_claimed_interfaces( usb->actconfig ) ) {
1130                 // Someone has already put there grubby paws on this device.
1131                 // We don't want it now...
1132                 return NULL;
1133         }
1134
1135         // We might be finding a device we can use.
1136         // We all go ahead and allocate our storage space.
1137         // We need to because we have to start filling in the data that
1138         // we are going to need later.
1139         if(!(ether_dev = kmalloc(sizeof(ether_dev_t), GFP_KERNEL))) {
1140                 err("out of memory allocating device structure");
1141                 return NULL;
1142         }
1143
1144         // Zero everything out.
1145         memset(ether_dev, 0, sizeof(ether_dev_t));
1146
1147         ether_dev->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
1148         if (!ether_dev->rx_urb) {
1149                 kfree(ether_dev);
1150                 return NULL;
1151         }
1152         ether_dev->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
1153         if (!ether_dev->tx_urb) {
1154                 usb_free_urb(ether_dev->rx_urb);
1155                 kfree(ether_dev);
1156                 return NULL;
1157         }
1158         ether_dev->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
1159         if (!ether_dev->intr_urb) {
1160                 usb_free_urb(ether_dev->tx_urb);
1161                 usb_free_urb(ether_dev->rx_urb);
1162                 kfree(ether_dev);
1163                 return NULL;
1164         }
1165
1166         // Let's see if we can find a configuration we can use.
1167         rc = find_valid_configuration( usb, ether_dev );
1168         if (rc) {
1169                 // Nope we couldn't find one we liked.
1170                 // This device was not meant for us to control.
1171                 kfree( ether_dev );
1172                 return  NULL;
1173         }
1174
1175         // Now that we FOUND a configuration. let's try to make the 
1176         // device go into it.
1177         if ( usb_set_configuration( usb, ether_dev->bConfigurationValue ) ) {
1178                 err("usb_set_configuration() failed");
1179                 kfree( ether_dev );
1180                 return NULL;
1181         }
1182
1183         // Now set the communication interface up as required.
1184         if (usb_set_interface(usb, ether_dev->comm_bInterfaceNumber, ether_dev->comm_bAlternateSetting)) {
1185                 err("usb_set_interface() failed");
1186                 kfree( ether_dev );
1187                 return NULL;
1188         }
1189
1190         // Only turn traffic on right now if we must...
1191         if (ether_dev->data_interface_altset_num_without_traffic >= 0)  {
1192                 // We found an alternate setting for the data
1193                 // interface that allows us to turn off traffic.
1194                 // We should use it.
1195                 if (usb_set_interface( usb, 
1196                                        ether_dev->data_bInterfaceNumber, 
1197                                        ether_dev->data_bAlternateSetting_without_traffic)) {
1198                         err("usb_set_interface() failed");
1199                         kfree( ether_dev );
1200                         return NULL;
1201                 }
1202         } else  {
1203                 // We didn't find an alternate setting for the data
1204                 // interface that would let us turn off traffic.
1205                 // Oh well, let's go ahead and do what we must...
1206                 if (usb_set_interface( usb, 
1207                                        ether_dev->data_bInterfaceNumber, 
1208                                        ether_dev->data_bAlternateSetting_with_traffic)) {
1209                         err("usb_set_interface() failed");
1210                         kfree( ether_dev );
1211                         return NULL;
1212                 }
1213         }
1214
1215         // Now we need to get a kernel Ethernet interface.
1216         net = init_etherdev( NULL, 0 );
1217         if ( !net ) {
1218                 // Hmm...  The kernel is not sharing today...
1219                 // Fine, we didn't want it anyway...
1220                 err( "Unable to initialize ethernet device" );
1221                 kfree( ether_dev );
1222                 return  NULL;
1223         }
1224
1225         // Now that we have an ethernet device, let's set it up
1226         // (And I don't mean "set [it] up the bomb".)
1227         net->priv = ether_dev;
1228         SET_MODULE_OWNER(net);
1229         net->open = CDCEther_open;
1230         net->stop = CDCEther_close;
1231         net->watchdog_timeo = CDC_ETHER_TX_TIMEOUT;
1232         net->tx_timeout = CDCEther_tx_timeout;   // TX timeout function
1233         net->do_ioctl = CDCEther_ioctl;
1234         net->hard_start_xmit = CDCEther_start_xmit;
1235         net->set_multicast_list = CDCEther_set_multicast;
1236         net->get_stats = CDCEther_netdev_stats;
1237         net->mtu = ether_dev->wMaxSegmentSize - 14;
1238
1239         // We'll keep track of this information for later...
1240         ether_dev->usb = usb;
1241         ether_dev->net = net;
1242         
1243         // and don't forget the MAC address.
1244         set_ethernet_addr( ether_dev );
1245
1246         // Send a message to syslog about what we are handling
1247         log_device_info( ether_dev );
1248
1249         // I claim this interface to be a CDC Ethernet Networking device
1250         usb_driver_claim_interface( &CDCEther_driver, 
1251                                     &(usb->config[ether_dev->configuration_num].interface[ether_dev->comm_interface]), 
1252                                     ether_dev );
1253         // I claim this interface to be a CDC Ethernet Networking device
1254         usb_driver_claim_interface( &CDCEther_driver, 
1255                                     &(usb->config[ether_dev->configuration_num].interface[ether_dev->data_interface]), 
1256                                     ether_dev );
1257
1258         // Does this REALLY do anything???
1259         usb_get_dev( usb );
1260
1261         // TODO - last minute HACK
1262         ether_dev->comm_ep_in = 5;
1263
1264         // Okay, we are finally done...
1265         return NULL;
1266 }
1267
1268
1269 //////////////////////////////////////////////////////////////////////////////
1270 // Module's disconnect routine ///////////////////////////////////////////////
1271 // Called when the driver is unloaded or the device is unplugged /////////////
1272 // (Whichever happens first assuming the driver suceeded at its probe) ///////
1273 //////////////////////////////////////////////////////////////////////////////
1274
1275 static void CDCEther_disconnect( struct usb_device *usb, void *ptr )
1276 {
1277         ether_dev_t *ether_dev = ptr;
1278
1279         // Sanity check!!!
1280         if ( !ether_dev || !ether_dev->usb ) {
1281                 // We failed.  We are insane!!!
1282                 warn("unregistering non-existant device");
1283                 return;
1284         }
1285
1286         // Make sure we fail the sanity check if we try this again.
1287         ether_dev->usb = NULL;
1288         
1289         // It is possible that this function is called before
1290         // the "close" function.
1291         // This tells the close function we are already disconnected
1292         ether_dev->flags |= CDC_ETHER_UNPLUG;
1293         
1294         // We don't need the network device any more
1295         unregister_netdev( ether_dev->net );
1296         
1297         // For sanity checks
1298         ether_dev->net = NULL;
1299
1300         // I ask again, does this do anything???
1301         usb_put_dev( usb );
1302
1303         // We are done with this interface
1304         usb_driver_release_interface( &CDCEther_driver, 
1305                                       &(usb->config[ether_dev->configuration_num].interface[ether_dev->comm_interface]) );
1306
1307         // We are done with this interface too
1308         usb_driver_release_interface( &CDCEther_driver, 
1309                                       &(usb->config[ether_dev->configuration_num].interface[ether_dev->data_interface]) );
1310
1311         // No more tied up kernel memory
1312         usb_free_urb(ether_dev->intr_urb);
1313         usb_free_urb(ether_dev->rx_urb);
1314         usb_free_urb(ether_dev->rx_urb);
1315         kfree( ether_dev );
1316         
1317         // This does no good, but it looks nice!
1318         ether_dev = NULL;
1319 }
1320
1321 //////////////////////////////////////////////////////////////////////////////
1322 // Driver info ///////////////////////////////////////////////////////////////
1323 //////////////////////////////////////////////////////////////////////////////
1324
1325 static struct usb_driver CDCEther_driver = {
1326         name:           "CDCEther",
1327         probe:          CDCEther_probe,
1328         disconnect:     CDCEther_disconnect,
1329         id_table:       CDCEther_ids,
1330 };
1331
1332 //////////////////////////////////////////////////////////////////////////////
1333 // init and exit routines called when driver is installed and uninstalled ////
1334 //////////////////////////////////////////////////////////////////////////////
1335
1336 int __init CDCEther_init(void)
1337 {
1338         info( "%s", version );
1339         return usb_register( &CDCEther_driver );
1340 }
1341
1342 void __exit CDCEther_exit(void)
1343 {
1344         usb_deregister( &CDCEther_driver );
1345 }
1346
1347 //////////////////////////////////////////////////////////////////////////////
1348 // Module info ///////////////////////////////////////////////////////////////
1349 //////////////////////////////////////////////////////////////////////////////
1350
1351 module_init( CDCEther_init );
1352 module_exit( CDCEther_exit );
1353
1354 MODULE_AUTHOR("Brad Hards and another");
1355 MODULE_DESCRIPTION("USB CDC Ethernet driver");
1356 MODULE_LICENSE("GPL");
1357
1358 MODULE_PARM (multicast_filter_limit, "i");
1359 MODULE_PARM_DESC (multicast_filter_limit, "CDCEther maximum number of filtered multicast addresses");
1360
1361 MODULE_DEVICE_TABLE (usb, CDCEther_ids);
1362
1363 //////////////////////////////////////////////////////////////////////////////
1364 // End of file ///////////////////////////////////////////////////////////////
1365 //////////////////////////////////////////////////////////////////////////////