v2.4.9.9 -> v2.4.9.10
[opensuse:kernel.git] / drivers / usb / pegasus.c
1 /*
2 **      Pegasus: USB 10/100Mbps/HomePNA (1Mbps) Controller
3 **
4 **      Copyright (c) 1999-2001 Petko Manolov (pmanolov@lnxw.com)
5 **      
6 **
7 **      ChangeLog:
8 **              ....    Most of the time spend reading sources & docs.
9 **              v0.2.x  First official release for the Linux kernel.
10 **              v0.3.0  Beutified and structured, some bugs fixed.
11 **              v0.3.x  URBifying bulk requests and bugfixing. First relatively
12 **                      stable release. Still can touch device's registers only
13 **                      from top-halves.
14 **              v0.4.0  Control messages remained unurbified are now URBs.
15 **                      Now we can touch the HW at any time.
16 **              v0.4.9  Control urbs again use process context to wait. Argh...
17 **                      Some long standing bugs (enable_net_traffic) fixed.
18 **                      Also nasty trick about resubmiting control urb from
19 **                      interrupt context used. Please let me know how it
20 **                      behaves. Pegasus II support added since this version.
21 **                      TODO: suppressing HCD warnings spewage on disconnect.
22 **              v0.4.13 Ethernet address is now set at probe(), not at open()
23 **                      time as this seems to break dhcpd. 
24 */
25
26 /*
27  * This program is free software; you can redistribute it and/or modify
28  * it under the terms of the GNU General Public License as published by
29  * the Free Software Foundation; either version 2 of the License, or
30  * (at your option) any later version.
31  *
32  * This program is distributed in the hope that it will be useful,
33  * but WITHOUT ANY WARRANTY; without even the implied warranty of
34  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
35  * GNU General Public License for more details.
36  *
37  * You should have received a copy of the GNU General Public License
38  * along with this program; if not, write to the Free Software
39  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
40  */
41
42
43 #include <linux/sched.h>
44 #include <linux/slab.h>
45 #include <linux/init.h>
46 #include <linux/delay.h>
47 #include <linux/netdevice.h>
48 #include <linux/etherdevice.h>
49 #include <linux/usb.h>
50 #include <linux/module.h>
51 #include "pegasus.h"
52
53 /*
54  * Version Information
55  */
56 #define DRIVER_VERSION "v0.4.21 (2001/08/27)"
57 #define DRIVER_AUTHOR "Petko Manolov <pmanolov@lnxw.com>"
58 #define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver"
59
60 #define PEGASUS_USE_INTR
61 #define PEGASUS_WRITE_EEPROM
62
63 static int loopback = 0;
64 static int mii_mode = 0;
65 static int multicast_filter_limit = 32;
66
67 static struct usb_eth_dev usb_dev_id[] = {
68 #define PEGASUS_DEV(pn, vid, pid, flags)        \
69         {name:pn, vendor:vid, device:pid, private:flags},
70 #include "pegasus.h"
71 #undef  PEGASUS_DEV
72         {NULL, 0, 0, 0}
73 };
74
75 static struct usb_device_id pegasus_ids[] = {
76 #define PEGASUS_DEV(pn, vid, pid, flags) \
77         {match_flags: USB_DEVICE_ID_MATCH_DEVICE, idVendor:vid, idProduct:pid},
78 #include "pegasus.h"
79 #undef  PEGASUS_DEV
80         { }
81 };
82
83
84 MODULE_AUTHOR( DRIVER_AUTHOR );
85 MODULE_DESCRIPTION( DRIVER_DESC );
86 MODULE_LICENSE("GPL");
87 MODULE_PARM(loopback, "i");
88 MODULE_PARM(mii_mode, "i");
89 MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)");
90 MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0");
91
92 MODULE_DEVICE_TABLE (usb, pegasus_ids);
93
94
95 static int update_eth_regs_async( pegasus_t * );
96 /* Aargh!!! I _really_ hate such tweaks */
97 static void ctrl_callback( urb_t *urb )
98 {
99         pegasus_t       *pegasus = urb->context;
100
101         if ( !pegasus )
102                 return;
103
104         switch ( urb->status ) {
105                 case USB_ST_NOERROR:
106                         if ( pegasus->flags & ETH_REGS_CHANGE ) {
107                                 pegasus->flags &= ~ETH_REGS_CHANGE;
108                                 pegasus->flags |= ETH_REGS_CHANGED;
109                                 update_eth_regs_async( pegasus );
110                                 return;
111                         }
112                         break;
113                 case USB_ST_URB_PENDING:
114                         return;
115                 case USB_ST_URB_KILLED:
116                         break;
117                 default:
118                         warn( __FUNCTION__ " status %d", urb->status);
119         }
120         pegasus->flags &= ~ETH_REGS_CHANGED;
121         wake_up(&pegasus->ctrl_wait );
122 }
123
124
125 static int get_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data)
126 {
127         int     ret;
128         unsigned char *buffer;
129         DECLARE_WAITQUEUE(wait, current);
130
131         buffer = kmalloc(size,GFP_KERNEL);
132         if (!buffer) {
133                 err("unable to allocate memory for configuration descriptors");
134                 return 0;
135         }
136         memcpy(buffer,data,size);
137
138         add_wait_queue(&pegasus->ctrl_wait, &wait);
139         set_current_state(TASK_UNINTERRUPTIBLE);
140         while ( pegasus->flags & ETH_REGS_CHANGED )
141                 schedule();
142         remove_wait_queue(&pegasus->ctrl_wait, &wait);
143         set_current_state(TASK_RUNNING);
144
145         pegasus->dr.requesttype = PEGASUS_REQT_READ;
146         pegasus->dr.request = PEGASUS_REQ_GET_REGS;
147         pegasus->dr.value = cpu_to_le16 (0);
148         pegasus->dr.index = cpu_to_le16p(&indx);
149         pegasus->dr.length = cpu_to_le16p(&size);
150         pegasus->ctrl_urb.transfer_buffer_length = size;
151
152         FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,
153                           usb_rcvctrlpipe(pegasus->usb,0),
154                           (char *)&pegasus->dr,
155                           buffer, size, ctrl_callback, pegasus );
156
157         add_wait_queue( &pegasus->ctrl_wait, &wait );
158         set_current_state( TASK_UNINTERRUPTIBLE );
159
160         if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) ) {
161                 err( __FUNCTION__ " BAD CTRLs %d", ret);
162                 goto out;
163         }
164
165         schedule();
166 out:
167         remove_wait_queue( &pegasus->ctrl_wait, &wait );
168         memcpy(data,buffer,size);
169         kfree(buffer);
170
171         return ret;
172 }
173
174
175 static int set_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data)
176 {
177         int     ret;
178         unsigned char *buffer;
179         DECLARE_WAITQUEUE(wait, current);
180
181         buffer = kmalloc(size, GFP_KERNEL);
182         if (!buffer) {
183                 err("unable to allocate memory for configuration descriptors");
184                 return 0;
185         }
186         memcpy(buffer, data, size);
187
188         add_wait_queue(&pegasus->ctrl_wait, &wait);
189         set_current_state(TASK_UNINTERRUPTIBLE);
190         while ( pegasus->flags & ETH_REGS_CHANGED )
191                 schedule();
192         remove_wait_queue(&pegasus->ctrl_wait, &wait);
193         set_current_state(TASK_RUNNING);
194
195         pegasus->dr.requesttype = PEGASUS_REQT_WRITE;
196         pegasus->dr.request = PEGASUS_REQ_SET_REGS;
197         pegasus->dr.value = cpu_to_le16 (0);
198         pegasus->dr.index = cpu_to_le16p( &indx );
199         pegasus->dr.length = cpu_to_le16p( &size );
200         pegasus->ctrl_urb.transfer_buffer_length = size;
201
202         FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,
203                           usb_sndctrlpipe(pegasus->usb,0),
204                           (char *)&pegasus->dr,
205                           buffer, size, ctrl_callback, pegasus );
206                           
207         add_wait_queue( &pegasus->ctrl_wait, &wait );
208         set_current_state( TASK_UNINTERRUPTIBLE );
209
210         if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) ) {
211                 err( __FUNCTION__ " BAD CTRL %d", ret);
212                 goto out;
213         }
214         
215         schedule();
216 out:
217         remove_wait_queue( &pegasus->ctrl_wait, &wait );
218         kfree(buffer);
219         
220         return ret;
221 }
222
223
224 static int set_register( pegasus_t *pegasus, __u16 indx, __u8 data )
225 {
226         int     ret;
227         unsigned char *buffer;
228         __u16 dat = data;
229         DECLARE_WAITQUEUE(wait, current);
230         
231         buffer = kmalloc(1, GFP_KERNEL);
232         if (!buffer) {
233                 err("unable to allocate memory for configuration descriptors");
234                 return 0;
235         }
236         memcpy(buffer, &data, 1);
237
238         add_wait_queue(&pegasus->ctrl_wait, &wait);
239         set_current_state(TASK_UNINTERRUPTIBLE);
240         while ( pegasus->flags & ETH_REGS_CHANGED )
241                 schedule();
242         remove_wait_queue(&pegasus->ctrl_wait, &wait);
243         set_current_state(TASK_RUNNING);
244
245         pegasus->dr.requesttype = PEGASUS_REQT_WRITE;
246         pegasus->dr.request = PEGASUS_REQ_SET_REG;
247         pegasus->dr.value = cpu_to_le16p( &dat);
248         pegasus->dr.index = cpu_to_le16p( &indx );
249         pegasus->dr.length = cpu_to_le16( 1 );
250         pegasus->ctrl_urb.transfer_buffer_length = 1;
251
252         FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,
253                           usb_sndctrlpipe(pegasus->usb,0),
254                           (char *)&pegasus->dr,
255                           buffer, 1, ctrl_callback, pegasus );
256
257         add_wait_queue( &pegasus->ctrl_wait, &wait );
258         set_current_state( TASK_UNINTERRUPTIBLE );
259
260         if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) ) {
261                 err( __FUNCTION__ " BAD CTRL %d", ret);
262                 goto out;
263         }
264
265         schedule();
266 out:
267         remove_wait_queue( &pegasus->ctrl_wait, &wait );
268         kfree(buffer);
269
270         return ret;
271 }
272
273
274 static int update_eth_regs_async( pegasus_t *pegasus )
275 {
276         int     ret;
277
278         pegasus->dr.requesttype = PEGASUS_REQT_WRITE;
279         pegasus->dr.request = PEGASUS_REQ_SET_REGS;
280         pegasus->dr.value = 0;
281         pegasus->dr.index =  cpu_to_le16(EthCtrl0);
282         pegasus->dr.length = cpu_to_le16(3);
283         pegasus->ctrl_urb.transfer_buffer_length = 3;
284
285         FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,
286                           usb_sndctrlpipe(pegasus->usb,0),
287                           (char *)&pegasus->dr,
288                           pegasus->eth_regs, 3, ctrl_callback, pegasus );
289
290         if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) )
291                 err( __FUNCTION__ " BAD CTRL %d, flags %x",ret,pegasus->flags );
292
293         return  ret;
294 }
295
296
297 static int read_mii_word( pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd )
298 {
299         int     i;
300         __u8    data[4] = { phy, 0, 0, indx };
301         __u16  regdi;
302         
303         set_register( pegasus, PhyCtrl, 0 );
304         set_registers( pegasus, PhyAddr, sizeof(data), data );
305         set_register( pegasus, PhyCtrl, (indx | PHY_READ) );
306         for (i = 0; i < REG_TIMEOUT; i++) {
307                 get_registers(pegasus, PhyCtrl, 1, data);
308                 if ( data[0] & PHY_DONE ) 
309                         break;
310         }
311         if ( i < REG_TIMEOUT ) {
312                 get_registers( pegasus, PhyData, 2, &regdi );
313                 *regd = le16_to_cpu(regdi);
314                 return  0;
315         }
316         warn( __FUNCTION__ " failed" );
317         
318         return 1;
319 }
320
321
322 static int write_mii_word( pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 regd )
323 {
324         int     i;
325         __u8    data[4] = { phy, 0, 0, indx };
326         
327         *(data + 1) = cpu_to_le16p( &regd );
328         set_register( pegasus, PhyCtrl, 0 );
329         set_registers( pegasus, PhyAddr, 4, data );
330         set_register( pegasus, PhyCtrl, (indx | PHY_WRITE) );
331         for (i = 0; i < REG_TIMEOUT; i++) {
332                 get_registers(pegasus, PhyCtrl, 1, data);
333                 if ( data[0] & PHY_DONE ) 
334                         break;
335         }
336         if ( i < REG_TIMEOUT )
337                 return  0;
338         warn( __FUNCTION__ " failed" );
339
340         return 1;
341 }
342
343
344 static int read_eprom_word( pegasus_t *pegasus, __u8 index, __u16 *retdata )
345 {
346         int     i;
347         __u8 tmp;
348         __u16 retdatai;
349         
350         set_register( pegasus, EpromCtrl, 0 );
351         set_register( pegasus, EpromOffset, index );
352         set_register( pegasus, EpromCtrl, EPROM_READ); 
353
354         for ( i=0; i < REG_TIMEOUT; i++ ) {
355                 get_registers( pegasus, EpromCtrl, 1, &tmp );
356                 if ( tmp & EPROM_DONE )
357                         break;
358         }
359         if ( i < REG_TIMEOUT ) {
360                 get_registers( pegasus, EpromData, 2, &retdatai );
361                 *retdata = le16_to_cpu (retdatai);
362                 return  0;
363         }
364         warn( __FUNCTION__ " failed" );
365
366         return -1;
367 }
368
369 #ifdef  PEGASUS_WRITE_EEPROM
370 static inline void enable_eprom_write( pegasus_t *pegasus )
371 {
372         __u8    tmp;
373
374         get_registers( pegasus, EthCtrl2, 1, &tmp );
375         set_register( pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE );
376 }
377
378
379 static inline void disable_eprom_write( pegasus_t *pegasus )
380 {
381         __u8    tmp;
382
383         get_registers( pegasus, EthCtrl2, 1, &tmp );
384         set_register( pegasus, EpromCtrl, 0 );
385         set_register( pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE );
386 }
387
388
389 static int write_eprom_word( pegasus_t *pegasus, __u8 index, __u16 data )
390 {
391         int     i, tmp;
392         __u8    d[4] = {0x3f, 0, 0, EPROM_WRITE};
393
394         set_registers( pegasus, EpromOffset, 4, d );
395         enable_eprom_write( pegasus );
396         set_register( pegasus, EpromOffset, index );
397         set_registers( pegasus, EpromData, 2, &data );
398         set_register( pegasus, EpromCtrl, EPROM_WRITE );
399
400         for ( i=0; i < REG_TIMEOUT; i++ ) {
401                 get_registers( pegasus, EpromCtrl, 1, &tmp );
402                 if ( tmp & EPROM_DONE )
403                         break;
404         }
405         disable_eprom_write( pegasus );
406         if ( i < REG_TIMEOUT )
407                 return  0;
408         warn( __FUNCTION__ " failed" );
409         return  -1;
410 }
411 #endif  /* PEGASUS_WRITE_EEPROM */
412
413 static inline void get_node_id( pegasus_t *pegasus, __u8 *id )
414 {
415         int     i;
416         __u16 w16;
417         
418         for (i = 0; i < 3; i++) {
419                 read_eprom_word( pegasus, i, &w16);
420                 ((__u16 *) id)[i] = cpu_to_le16p (&w16);
421         }
422 }
423
424
425 static void set_ethernet_addr( pegasus_t *pegasus )
426 {
427         __u8    node_id[6];
428
429         get_node_id(pegasus, node_id);
430         set_registers( pegasus, EthID, sizeof(node_id), node_id );
431         memcpy( pegasus->net->dev_addr, node_id, sizeof(node_id) );
432 }
433
434
435 static inline int reset_mac( pegasus_t *pegasus )
436 {
437         __u8    data = 0x8;
438         int     i;
439
440         set_register(pegasus, EthCtrl1, data);
441         for (i = 0; i < REG_TIMEOUT; i++) {
442                 get_registers(pegasus, EthCtrl1, 1, &data);
443                 if (~data & 0x08) {
444                         if (loopback & 1) 
445                                 break;
446                         if ( mii_mode && (pegasus->features & HAS_HOME_PNA) )
447                                 set_register( pegasus, Gpio1, 0x34 );
448                         else
449                                 set_register( pegasus, Gpio1, 0x26 );
450                         set_register( pegasus, Gpio0, pegasus->features );
451                         set_register( pegasus, Gpio0, DEFAULT_GPIO_SET );
452                         break;
453                 }
454         }
455         if ( i == REG_TIMEOUT )
456                 return 1;
457
458         if ( usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
459              usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK ) {
460                 __u16   auxmode;
461
462                 read_mii_word( pegasus, 0, 0x1b, &auxmode );
463                 write_mii_word( pegasus, 0, 0x1b, auxmode | 4 );
464         }
465
466         return  0;
467 }
468
469
470 static int enable_net_traffic( struct net_device *dev, struct usb_device *usb )
471 {
472         __u16   linkpart, bmsr;
473         __u8    data[4];
474         pegasus_t *pegasus = dev->priv;
475
476
477         if ( read_mii_word(pegasus, pegasus->phy, MII_BMSR, &bmsr) ) 
478                 return 1;
479         if ( !(bmsr & 0x20) && !loopback ) 
480                 warn( "%s: link NOT established (0x%x) - check the cable.",
481                         dev->name, bmsr );
482         if ( read_mii_word(pegasus, pegasus->phy, MII_ANLPA, &linkpart) )
483                 return 2;
484         if ( !(linkpart & 1) )
485                 warn( "link partner stat %x", linkpart );
486
487         data[0] = 0xc9;
488         data[1] = 0;
489         if ( linkpart & (ANLPA_100TX_FD | ANLPA_10T_FD) )
490                 data[1] |= 0x20; /* set full duplex */
491         if ( linkpart & (ANLPA_100TX_FD | ANLPA_100TX_HD) )
492                 data[1] |= 0x10; /* set 100 Mbps */
493         if ( mii_mode )
494                 data[1] = 0;
495         data[2] = (loopback & 1) ? 0x09 : 0x01;
496
497         memcpy( pegasus->eth_regs, data, sizeof(data) );
498
499         set_registers( pegasus, EthCtrl0, 3, data );
500
501         return 0;
502 }
503
504
505 static void read_bulk_callback( struct urb *urb )
506 {
507         pegasus_t *pegasus = urb->context;
508         struct net_device *net;
509         int count = urb->actual_length, res;
510         int rx_status;
511         struct sk_buff  *skb;
512         __u16 pkt_len;
513
514         if ( !pegasus || !(pegasus->flags & PEGASUS_RUNNING) )
515                 return;
516
517         net = pegasus->net;
518         if ( !netif_device_present(net) )
519                 return;
520
521         if ( pegasus->flags & PEGASUS_RX_BUSY ) {
522                 pegasus->stats.rx_errors++;
523                 dbg("pegasus Rx busy");
524                 return;
525         }
526         pegasus->flags |= PEGASUS_RX_BUSY;
527
528         switch ( urb->status ) {
529                 case USB_ST_NOERROR:
530                         break;
531                 case USB_ST_NORESPONSE:
532                         dbg( "reset MAC" );
533                         pegasus->flags &= ~PEGASUS_RX_BUSY;
534                         break;
535                 default:
536                         dbg( "%s: RX status %d", net->name, urb->status );
537                         goto goon;
538         }
539
540         if ( !count )
541                 goto goon;
542
543         rx_status = le32_to_cpu(*(int *)(pegasus->rx_buff + count - 4));
544         if ( rx_status & 0x000e0000 ) {
545                 dbg("%s: RX packet error %x", net->name, rx_status & 0xe0000);
546                 pegasus->stats.rx_errors++;
547                 if ( rx_status & 0x060000 )
548                         pegasus->stats.rx_length_errors++;
549                 if ( rx_status & 0x080000 )
550                         pegasus->stats.rx_crc_errors++;
551                 if ( rx_status & 0x100000 )
552                         pegasus->stats.rx_frame_errors++;
553                 goto goon;
554         }
555
556         pkt_len = (rx_status & 0xfff) - 8;
557
558         if ( !(skb = dev_alloc_skb(pkt_len+2)) )
559                 goto goon;
560
561         skb->dev = net;
562         skb_reserve(skb, 2);
563         eth_copy_and_sum(skb, pegasus->rx_buff, pkt_len, 0);
564         skb_put(skb, pkt_len);
565
566         skb->protocol = eth_type_trans(skb, net);
567         netif_rx(skb);
568         pegasus->stats.rx_packets++;
569         pegasus->stats.rx_bytes += pkt_len;
570
571 goon:
572         FILL_BULK_URB( &pegasus->rx_urb, pegasus->usb,
573                         usb_rcvbulkpipe(pegasus->usb, 1),
574                         pegasus->rx_buff, PEGASUS_MAX_MTU, 
575                         read_bulk_callback, pegasus );
576         if ( (res = usb_submit_urb(&pegasus->rx_urb)) )
577                 warn( __FUNCTION__ " failed submint rx_urb %d", res);
578         pegasus->flags &= ~PEGASUS_RX_BUSY;
579 }
580
581
582 static void write_bulk_callback( struct urb *urb )
583 {
584         pegasus_t *pegasus = urb->context;
585
586         if ( !pegasus || !(pegasus->flags & PEGASUS_RUNNING) )
587                 return;
588
589         if ( !netif_device_present(pegasus->net) )
590                 return;
591                 
592         if ( urb->status )
593                 info("%s: TX status %d", pegasus->net->name, urb->status);
594
595         pegasus->net->trans_start = jiffies;
596         netif_wake_queue( pegasus->net );
597 }
598
599 #ifdef  PEGASUS_USE_INTR
600 static void intr_callback( struct urb *urb )
601 {
602         pegasus_t *pegasus = urb->context;
603         struct net_device *net;
604         __u8    *d;
605
606         if ( !pegasus )
607                 return;
608                 
609         switch ( urb->status ) {
610                 case USB_ST_NOERROR:
611                         break;
612                 case USB_ST_URB_KILLED:
613                         return;
614                 default:
615                         info("intr status %d", urb->status);
616         }
617
618         d = urb->transfer_buffer;
619         net = pegasus->net;
620         if ( d[0] & 0xfc ) {
621                 pegasus->stats.tx_errors++;
622                 if ( d[0] & TX_UNDERRUN )
623                         pegasus->stats.tx_fifo_errors++;
624                 if ( d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT) )
625                         pegasus->stats.tx_aborted_errors++;
626                 if ( d[0] & LATE_COL )
627                         pegasus->stats.tx_window_errors++;
628                 if ( d[0] & (NO_CARRIER | LOSS_CARRIER) )
629                         pegasus->stats.tx_carrier_errors++;
630         }
631 }
632 #endif
633
634 static void pegasus_tx_timeout( struct net_device *net )
635 {
636         pegasus_t *pegasus = net->priv;
637
638         if ( !pegasus )
639                 return;
640                 
641         warn("%s: Tx timed out.", net->name);
642         pegasus->tx_urb.transfer_flags |= USB_ASYNC_UNLINK;
643         usb_unlink_urb( &pegasus->tx_urb );
644         pegasus->stats.tx_errors++;
645 }
646
647
648 static int pegasus_start_xmit( struct sk_buff *skb, struct net_device *net )
649 {
650         pegasus_t       *pegasus = net->priv;
651         int     count = ((skb->len+2) & 0x3f) ? skb->len+2 : skb->len+3;
652         int     res;
653         __u16 l16 = skb->len;
654         
655         netif_stop_queue( net );
656                 
657         ((__u16 *)pegasus->tx_buff)[0] = cpu_to_le16( l16 );
658         memcpy(pegasus->tx_buff+2, skb->data, skb->len);
659         FILL_BULK_URB( &pegasus->tx_urb, pegasus->usb,
660                         usb_sndbulkpipe(pegasus->usb, 2),
661                         pegasus->tx_buff, PEGASUS_MAX_MTU, 
662                         write_bulk_callback, pegasus );
663         pegasus->tx_urb.transfer_buffer_length = count;
664         if ((res = usb_submit_urb(&pegasus->tx_urb))) {
665                 warn("failed tx_urb %d", res);
666                 pegasus->stats.tx_errors++;
667                 netif_start_queue( net );
668         } else {
669                 pegasus->stats.tx_packets++;
670                 pegasus->stats.tx_bytes += skb->len;
671                 net->trans_start = jiffies;
672         }
673
674         dev_kfree_skb(skb);
675
676         return 0;
677 }
678
679
680 static struct net_device_stats *pegasus_netdev_stats( struct net_device *dev )
681 {
682         return &((pegasus_t *)dev->priv)->stats;
683 }
684
685
686 static inline void disable_net_traffic( pegasus_t *pegasus )
687 {
688         int     tmp=0;
689
690         set_registers( pegasus, EthCtrl0, 2, &tmp );
691 }
692
693
694 static inline void get_interrupt_interval( pegasus_t *pegasus )
695 {
696         __u8    data[2];
697
698         read_eprom_word( pegasus, 4, (__u16 *)data );
699         if ( data[1] < 0x80 ) {
700                 info( "intr interval will be changed from %ums to %ums",
701                      data[1], 0x80 );
702                 data[1] = 0x80;
703 #ifdef  PEGASUS_WRITE_EEPROM
704                 write_eprom_word( pegasus, 4, *(__u16 *)data );
705 #endif
706         }
707         pegasus->intr_interval = data[1];
708 }
709
710
711 static int pegasus_open(struct net_device *net)
712 {
713         pegasus_t *pegasus = (pegasus_t *)net->priv;
714         int     res;
715
716         MOD_INC_USE_COUNT;
717         if ( (res = enable_net_traffic(net, pegasus->usb)) ) {
718                 err("can't enable_net_traffic() - %d", res);
719                 MOD_DEC_USE_COUNT;
720                 return -EIO;
721         }
722         FILL_BULK_URB( &pegasus->rx_urb, pegasus->usb,
723                         usb_rcvbulkpipe(pegasus->usb, 1),
724                         pegasus->rx_buff, PEGASUS_MAX_MTU, 
725                         read_bulk_callback, pegasus );
726         if ( (res = usb_submit_urb(&pegasus->rx_urb)) )
727                 warn( __FUNCTION__ " failed rx_urb %d", res );
728 #ifdef  PEGASUS_USE_INTR
729         FILL_INT_URB( &pegasus->intr_urb, pegasus->usb,
730                         usb_rcvintpipe(pegasus->usb, 3),
731                         pegasus->intr_buff, sizeof(pegasus->intr_buff),
732                         intr_callback, pegasus, pegasus->intr_interval );
733         if ( (res = usb_submit_urb(&pegasus->intr_urb)) )
734                 warn( __FUNCTION__ " failed intr_urb %d", res);
735 #endif
736         netif_start_queue( net );
737         pegasus->flags |= PEGASUS_RUNNING;
738
739         return 0;
740 }
741
742
743 static int pegasus_close( struct net_device *net )
744 {
745         pegasus_t       *pegasus = net->priv;
746
747         pegasus->flags &= ~PEGASUS_RUNNING;
748         netif_stop_queue( net );
749         if ( !(pegasus->flags & PEGASUS_UNPLUG) )
750                 disable_net_traffic( pegasus );
751
752         usb_unlink_urb( &pegasus->rx_urb );
753         usb_unlink_urb( &pegasus->tx_urb );
754         usb_unlink_urb( &pegasus->ctrl_urb );
755 #ifdef  PEGASUS_USE_INTR
756         usb_unlink_urb( &pegasus->intr_urb );
757 #endif
758         MOD_DEC_USE_COUNT;
759
760         return 0;
761 }
762
763
764 static int pegasus_ioctl( struct net_device *net, struct ifreq *rq, int cmd )
765 {
766         __u16 *data = (__u16 *)&rq->ifr_data;
767         pegasus_t       *pegasus = net->priv;
768
769         switch(cmd) {
770                 case SIOCDEVPRIVATE:
771                         data[0] = pegasus->phy;
772                 case SIOCDEVPRIVATE+1:
773                         read_mii_word(pegasus, data[0], data[1]&0x1f, &data[3]);
774                         return 0;
775                 case SIOCDEVPRIVATE+2:
776                         if ( !capable(CAP_NET_ADMIN) )
777                                 return -EPERM;
778                         write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, data[2]);
779                         return 0;
780                 default:
781                         return -EOPNOTSUPP;
782         }
783 }
784
785
786 static void pegasus_set_multicast( struct net_device *net )
787 {
788         pegasus_t *pegasus = net->priv;
789
790         netif_stop_queue(net);
791
792         if (net->flags & IFF_PROMISC) {
793                 pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS;
794                 info("%s: Promiscuous mode enabled", net->name);
795         } else if ((net->mc_count > multicast_filter_limit) ||
796                         (net->flags & IFF_ALLMULTI)) {
797                 pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST;
798                 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
799                 info("%s set allmulti", net->name);
800         } else {
801                 pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST;
802                 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
803         }
804
805         pegasus->flags |= ETH_REGS_CHANGE;
806         ctrl_callback( &pegasus->ctrl_urb );
807
808         netif_wake_queue(net);
809 }
810
811
812 static __u8 mii_phy_probe( pegasus_t *pegasus )
813 {
814         int     i;
815         __u16   tmp;
816
817         for ( i=0; i < 32; i++ ) {
818                 read_mii_word( pegasus, i, MII_BMSR, &tmp );
819                 if ( tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0 )
820                         continue;
821                 else
822                         return  i;
823         }
824
825         return  0xff;
826 }
827
828
829 static inline void setup_pegasus_II( pegasus_t *pegasus )
830 {
831         set_register( pegasus, Reg1d, 0 );
832         set_register( pegasus, Reg7b, 2 );
833         if ( pegasus->features & HAS_HOME_PNA  && mii_mode )
834                 set_register( pegasus, Reg81, 6 );
835         else
836                 set_register( pegasus, Reg81, 2 );
837 }
838
839
840 static void * pegasus_probe( struct usb_device *dev, unsigned int ifnum,
841                              const struct usb_device_id *id)
842 {
843         struct net_device       *net;
844         pegasus_t               *pegasus;
845         int                     dev_index = id - pegasus_ids;
846
847         if (usb_set_configuration(dev, dev->config[0].bConfigurationValue)) {
848                 err("usb_set_configuration() failed");
849                 return NULL;
850         }
851
852         if(!(pegasus = kmalloc(sizeof(struct pegasus), GFP_KERNEL))) {
853                 err("out of memory allocating device structure");
854                 return NULL;
855         }
856
857         usb_inc_dev_use( dev );
858         memset(pegasus, 0, sizeof(struct pegasus));
859         pegasus->dev_index = dev_index;
860         init_waitqueue_head( &pegasus->ctrl_wait );
861
862         net = init_etherdev( NULL, 0 );
863         if ( !net ) {
864                 kfree( pegasus );
865                 return  NULL;
866         }
867         
868         pegasus->usb = dev;
869         pegasus->net = net;
870         net->priv = pegasus;
871         net->open = pegasus_open;
872         net->stop = pegasus_close;
873         net->watchdog_timeo = PEGASUS_TX_TIMEOUT;
874         net->tx_timeout = pegasus_tx_timeout;
875         net->do_ioctl = pegasus_ioctl;
876         net->hard_start_xmit = pegasus_start_xmit;
877         net->set_multicast_list = pegasus_set_multicast;
878         net->get_stats = pegasus_netdev_stats;
879         net->mtu = PEGASUS_MTU;
880
881         pegasus->features = usb_dev_id[dev_index].private;
882 #ifdef  PEGASUS_USE_INTR
883         get_interrupt_interval( pegasus );
884 #endif
885         if ( reset_mac(pegasus) ) {
886                 err("can't reset MAC");
887                 unregister_netdev( pegasus->net );
888                 kfree(pegasus);
889                 pegasus = NULL;
890                 return NULL;
891         }
892
893         info( "%s: %s", net->name, usb_dev_id[dev_index].name );
894
895         set_ethernet_addr( pegasus );
896
897         if ( pegasus->features & PEGASUS_II ) {
898                 info( "setup Pegasus II specific registers" );
899                 setup_pegasus_II( pegasus );
900         }
901         
902         pegasus->phy = mii_phy_probe( pegasus );
903         if ( pegasus->phy == 0xff ) {
904                 warn( "can't locate MII phy, using default" );
905                 pegasus->phy = 1;
906         }
907
908         return pegasus;
909 }
910
911
912 static void pegasus_disconnect( struct usb_device *dev, void *ptr )
913 {
914         struct pegasus *pegasus = ptr;
915
916         if ( !pegasus ) {
917                 warn("unregistering non-existant device");
918                 return;
919         }
920
921         pegasus->flags |= PEGASUS_UNPLUG;
922         unregister_netdev( pegasus->net );
923         usb_dec_dev_use( dev );
924         kfree( pegasus );
925         pegasus = NULL;
926 }
927
928
929 static struct usb_driver pegasus_driver = {
930         name:           "pegasus",
931         probe:          pegasus_probe,
932         disconnect:     pegasus_disconnect,
933         id_table:       pegasus_ids,
934 };
935
936 int __init pegasus_init(void)
937 {
938         info(DRIVER_VERSION ":" DRIVER_DESC);
939         return usb_register( &pegasus_driver );
940 }
941
942 void __exit pegasus_exit(void)
943 {
944         usb_deregister( &pegasus_driver );
945 }
946
947 module_init( pegasus_init );
948 module_exit( pegasus_exit );