/***	Pegasus: USB 10/100Mbps/HomePNA (1Mbps) Controller****	Copyright (c) 1999-2001 Petko Manolov (pmanolov@lnxw.com)**	****	ChangeLog:**		....	Most of the time spend reading sources & docs.**		v0.2.x	First official release for the Linux kernel.**		v0.3.0	Beutified and structured, some bugs fixed.**		v0.3.x	URBifying bulk requests and bugfixing. First relatively**			stable release. Still can touch device's registers only**			from top-halves.**		v0.4.0	Control messages remained unurbified are now URBs.**			Now we can touch the HW at any time.**		v0.4.9	Control urbs again use process context to wait. Argh...**			Some long standing bugs (enable_net_traffic) fixed.**			Also nasty trick about resubmiting control urb from**			interrupt context used. Please let me know how it**			behaves. Pegasus II support added since this version.**			TODO: suppressing HCD warnings spewage on disconnect.**		v0.4.13	Ethernet address is now set at probe(), not at open()**			time as this seems to break dhcpd. *//* * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */#include <linux/sched.h>#include <linux/slab.h>#include <linux/init.h>#include <linux/delay.h>#include <linux/netdevice.h>#include <linux/etherdevice.h>#include <linux/usb.h>#include <linux/module.h>#include "pegasus.h"/* * Version Information */#define DRIVER_VERSION "v0.4.22 (2001/12/07)"#define DRIVER_AUTHOR "Petko Manolov <pmanolov@lnxw.com>"#define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver"#define	PEGASUS_USE_INTR#define	PEGASUS_WRITE_EEPROMstatic int loopback = 0;static int mii_mode = 0;static int multicast_filter_limit = 32;static struct usb_eth_dev usb_dev_id[] = {#define	PEGASUS_DEV(pn, vid, pid, flags)	\	{name:pn, vendor:vid, device:pid, private:flags},#include "pegasus.h"#undef	PEGASUS_DEV	{NULL, 0, 0, 0}};static struct usb_device_id pegasus_ids[] = {#define	PEGASUS_DEV(pn, vid, pid, flags) \	{match_flags: USB_DEVICE_ID_MATCH_DEVICE, idVendor:vid, idProduct:pid},#include "pegasus.h"#undef	PEGASUS_DEV	{ }};MODULE_AUTHOR( DRIVER_AUTHOR );MODULE_DESCRIPTION( DRIVER_DESC );MODULE_LICENSE("GPL");MODULE_PARM(loopback, "i");MODULE_PARM(mii_mode, "i");MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)");MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0");MODULE_DEVICE_TABLE (usb, pegasus_ids);static int update_eth_regs_async( pegasus_t * );/* Aargh!!! I _really_ hate such tweaks */static void ctrl_callback( urb_t *urb ){	pegasus_t	*pegasus = urb->context;	if ( !pegasus )		return;	switch ( urb->status ) {		case USB_ST_NOERROR:			if ( pegasus->flags & ETH_REGS_CHANGE ) {				pegasus->flags &= ~ETH_REGS_CHANGE;				pegasus->flags |= ETH_REGS_CHANGED;				update_eth_regs_async( pegasus );				return;			}			break;		case USB_ST_URB_PENDING:			return;		case USB_ST_URB_KILLED:			break;		default:			warn( __FUNCTION__ " status %d", urb->status);	}	pegasus->flags &= ~ETH_REGS_CHANGED;	wake_up(&pegasus->ctrl_wait );}static int get_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data){	int	ret;	unsigned char *buffer;	DECLARE_WAITQUEUE(wait, current);	buffer = kmalloc(size,GFP_KERNEL);	if (!buffer) {		err("unable to allocate memory for configuration descriptors");		return 0;	}	memcpy(buffer,data,size);	add_wait_queue(&pegasus->ctrl_wait, &wait);	set_current_state(TASK_UNINTERRUPTIBLE);	while ( pegasus->flags & ETH_REGS_CHANGED )		schedule();	remove_wait_queue(&pegasus->ctrl_wait, &wait);	set_current_state(TASK_RUNNING);	pegasus->dr.requesttype = PEGASUS_REQT_READ;	pegasus->dr.request = PEGASUS_REQ_GET_REGS;	pegasus->dr.value = cpu_to_le16 (0);	pegasus->dr.index = cpu_to_le16p(&indx);	pegasus->dr.length = cpu_to_le16p(&size);	pegasus->ctrl_urb.transfer_buffer_length = size;	FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,			  usb_rcvctrlpipe(pegasus->usb,0),			  (char *)&pegasus->dr,			  buffer, size, ctrl_callback, pegasus );	add_wait_queue( &pegasus->ctrl_wait, &wait );	set_current_state( TASK_UNINTERRUPTIBLE );	if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) ) {		err( __FUNCTION__ " BAD CTRLs %d", ret);		goto out;	}	schedule();out:	remove_wait_queue( &pegasus->ctrl_wait, &wait );	memcpy(data,buffer,size);	kfree(buffer);	return ret;}static int set_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data){	int	ret;	unsigned char *buffer;	DECLARE_WAITQUEUE(wait, current);	buffer = kmalloc(size, GFP_KERNEL);	if (!buffer) {		err("unable to allocate memory for configuration descriptors");		return 0;	}	memcpy(buffer, data, size);	add_wait_queue(&pegasus->ctrl_wait, &wait);	set_current_state(TASK_UNINTERRUPTIBLE);	while ( pegasus->flags & ETH_REGS_CHANGED )		schedule();	remove_wait_queue(&pegasus->ctrl_wait, &wait);	set_current_state(TASK_RUNNING);	pegasus->dr.requesttype = PEGASUS_REQT_WRITE;	pegasus->dr.request = PEGASUS_REQ_SET_REGS;	pegasus->dr.value = cpu_to_le16 (0);	pegasus->dr.index = cpu_to_le16p( &indx );	pegasus->dr.length = cpu_to_le16p( &size );	pegasus->ctrl_urb.transfer_buffer_length = size;	FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,			  usb_sndctrlpipe(pegasus->usb,0),			  (char *)&pegasus->dr,			  buffer, size, ctrl_callback, pegasus );			  	add_wait_queue( &pegasus->ctrl_wait, &wait );	set_current_state( TASK_UNINTERRUPTIBLE );	if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) ) {		err( __FUNCTION__ " BAD CTRL %d", ret);		goto out;	}		schedule();out:	remove_wait_queue( &pegasus->ctrl_wait, &wait );	kfree(buffer);		return ret;}static int set_register( pegasus_t *pegasus, __u16 indx, __u8 data ){	int	ret;	unsigned char *buffer;	__u16 dat = data;	DECLARE_WAITQUEUE(wait, current);		buffer = kmalloc(1, GFP_KERNEL);	if (!buffer) {		err("unable to allocate memory for configuration descriptors");		return 0;	}	memcpy(buffer, &data, 1);	add_wait_queue(&pegasus->ctrl_wait, &wait);	set_current_state(TASK_UNINTERRUPTIBLE);	while ( pegasus->flags & ETH_REGS_CHANGED )		schedule();	remove_wait_queue(&pegasus->ctrl_wait, &wait);	set_current_state(TASK_RUNNING);	pegasus->dr.requesttype = PEGASUS_REQT_WRITE;	pegasus->dr.request = PEGASUS_REQ_SET_REG;	pegasus->dr.value = cpu_to_le16p( &dat);	pegasus->dr.index = cpu_to_le16p( &indx );	pegasus->dr.length = cpu_to_le16( 1 );	pegasus->ctrl_urb.transfer_buffer_length = 1;	FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,			  usb_sndctrlpipe(pegasus->usb,0),			  (char *)&pegasus->dr,			  buffer, 1, ctrl_callback, pegasus );	add_wait_queue( &pegasus->ctrl_wait, &wait );	set_current_state( TASK_UNINTERRUPTIBLE );	if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) ) {		err( __FUNCTION__ " BAD CTRL %d", ret);		goto out;	}	schedule();out:	remove_wait_queue( &pegasus->ctrl_wait, &wait );	kfree(buffer);	return ret;}static int update_eth_regs_async( pegasus_t *pegasus ){	int	ret;	pegasus->dr.requesttype = PEGASUS_REQT_WRITE;	pegasus->dr.request = PEGASUS_REQ_SET_REGS;	pegasus->dr.value = 0;	pegasus->dr.index =  cpu_to_le16(EthCtrl0);	pegasus->dr.length = cpu_to_le16(3);	pegasus->ctrl_urb.transfer_buffer_length = 3;	FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,			  usb_sndctrlpipe(pegasus->usb,0),			  (char *)&pegasus->dr,			  pegasus->eth_regs, 3, ctrl_callback, pegasus );	if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) )		err( __FUNCTION__ " BAD CTRL %d, flags %x",ret,pegasus->flags );	return	ret;}static int read_mii_word( pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd ){	int	i;	__u8	data[4] = { phy, 0, 0, indx };	__u16  regdi;		set_register( pegasus, PhyCtrl, 0 );	set_registers( pegasus, PhyAddr, sizeof(data), data );	set_register( pegasus, PhyCtrl, (indx | PHY_READ) );	for (i = 0; i < REG_TIMEOUT; i++) {		get_registers(pegasus, PhyCtrl, 1, data);		if ( data[0] & PHY_DONE ) 			break;	}	if ( i < REG_TIMEOUT ) {		get_registers( pegasus, PhyData, 2, &regdi );		*regd = le16_to_cpu(regdi);		return	0;	}	warn( __FUNCTION__ " failed" );		return 1;}static int write_mii_word( pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 regd ){	int	i;	__u8	data[4] = { phy, 0, 0, indx };		*(data + 1) = cpu_to_le16p( &regd );	set_register( pegasus, PhyCtrl, 0 );	set_registers( pegasus, PhyAddr, 4, data );	set_register( pegasus, PhyCtrl, (indx | PHY_WRITE) );	for (i = 0; i < REG_TIMEOUT; i++) {		get_registers(pegasus, PhyCtrl, 1, data);		if ( data[0] & PHY_DONE ) 			break;	}	if ( i < REG_TIMEOUT )		return	0;	warn( __FUNCTION__ " failed" );	return 1;}static int read_eprom_word( pegasus_t *pegasus, __u8 index, __u16 *retdata ){	int	i;	__u8 tmp;	__u16 retdatai;		set_register( pegasus, EpromCtrl, 0 );	set_register( pegasus, EpromOffset, index );	set_register( pegasus, EpromCtrl, EPROM_READ); 	for ( i=0; i < REG_TIMEOUT; i++ ) {		get_registers( pegasus, EpromCtrl, 1, &tmp );		if ( tmp & EPROM_DONE )			break;	}	if ( i < REG_TIMEOUT ) {		get_registers( pegasus, EpromData, 2, &retdatai );		*retdata = le16_to_cpu (retdatai);		return	0;	}	warn( __FUNCTION__ " failed" );	return -1;}#ifdef	PEGASUS_WRITE_EEPROMstatic inline void enable_eprom_write( pegasus_t *pegasus ){	__u8	tmp;	get_registers( pegasus, EthCtrl2, 1, &tmp );	set_register( pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE );}static inline void disable_eprom_write( pegasus_t *pegasus ){	__u8 	tmp;	get_registers( pegasus, EthCtrl2, 1, &tmp );	set_register( pegasus, EpromCtrl, 0 );	set_register( pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE );}static int write_eprom_word( pegasus_t *pegasus, __u8 index, __u16 data ){	int	i, tmp;	__u8	d[4] = {0x3f, 0, 0, EPROM_WRITE};	set_registers( pegasus, EpromOffset, 4, d );	enable_eprom_write( pegasus );	set_register( pegasus, EpromOffset, index );	set_registers( pegasus, EpromData, 2, &data );	set_register( pegasus, EpromCtrl, EPROM_WRITE );	for ( i=0; i < REG_TIMEOUT; i++ ) {		get_registers( pegasus, EpromCtrl, 1, &tmp );		if ( tmp & EPROM_DONE )			break;	}	disable_eprom_write( pegasus );	if ( i < REG_TIMEOUT )		return	0;	warn( __FUNCTION__ " failed" );	return	-1;}#endif	/* PEGASUS_WRITE_EEPROM */static inline void get_node_id( pegasus_t *pegasus, __u8 *id ){	int	i;	__u16 w16;		for (i = 0; i < 3; i++) {		read_eprom_word( pegasus, i, &w16);		((__u16 *) id)[i] = cpu_to_le16p (&w16);	}}static void set_ethernet_addr( pegasus_t *pegasus ){	__u8	node_id[6];	get_node_id(pegasus, node_id);	set_registers( pegasus, EthID, sizeof(node_id), node_id );	memcpy( pegasus->net->dev_addr, node_id, sizeof(node_id) );}static inline int reset_mac( pegasus_t *pegasus ){	__u8	data = 0x8;	int	i;	set_register(pegasus, EthCtrl1, data);	for (i = 0; i < REG_TIMEOUT; i++) {		get_registers(pegasus, EthCtrl1, 1, &data);		if (~data & 0x08) {			if (loopback & 1) 				break;			if ( mii_mode && (pegasus->features & HAS_HOME_PNA) )				set_register( pegasus, Gpio1, 0x34 );			else				set_register( pegasus, Gpio1, 0x26 );			set_register( pegasus, Gpio0, pegasus->features );			set_register( pegasus, Gpio0, DEFAULT_GPIO_SET );			break;		}	}	if ( i == REG_TIMEOUT )		return 1;	if ( usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||	     usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK ) {		__u16	auxmode;		read_mii_word( pegasus, 0, 0x1b, &auxmode );		write_mii_word( pegasus, 0, 0x1b, auxmode | 4 );	}	return	0;}static int enable_net_traffic( struct net_device *dev, struct usb_device *usb ){	__u16	linkpart, bmsr;	__u8	data[4];	pegasus_t *pegasus = dev->priv;