/*
* USB 10M/100M ethernet adapter
*
* This file is licensed under the terms of the GNU General Public License
* version 2. This program is licensed "as is" without any warranty of any
* kind, whther express or implied
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/stddef.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/mii.h>
#include <linux/usb.h>
#include <linux/crc32.h>
#include <linux/usb/usbnet.h>
#include <linux/slab.h>
#define CH9x00_VID 0x1A86
#define CH9x00_PID_8339 0x8339
#define CH9x00_PID_E091 0xE091
#define CH9x00_PID_E092 0xE092
#define DRIVER_VERSION "29-May-2013"
#define DEBUG_PRT //for debug
#undef DEBUG_PRT
#ifdef DEBUG_PRT
#define dbg_prt(format, arg...) printk(KERN_DEBUG format "\n", ## arg)
#else
#define dbg_prt(format, arg...) do {} while (0)
#endif
/**** Reg and CMD definition for CH9x00_PID_E091 and CH9x00_PID_8339****/
#define DEVICE_SPEED_10M 0x80
#define DEVICE_MEDIA_CONNECTED 0x40
#define DEVICE_DUPLEX_FULL 0x20
#define DEVICE_PHY 0x10
#define REQ_RD_REG (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
#define REQ_WR_REG (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
#define CTRL_TIMEOUT_MS 1000
#define MCAST_MAX 0x40
#define TX_OVERHEAD 0x04
#define RX_OVERHEAD 0x04
#define GET_MAC_ADDRESS 0x00
#define SET_HASH_TABLE 0x04
#define SET_PACKAGE_FILTER 0x05
#define RECEIVE_ALL 0x08
#define MULTIPKT_EN 0x04
#define BROADPKT_EN 0x02
#define HASH_MULTI_EN 0x01
#define CTRL_CLOSE 0x00
#define CTRL_OPEN 0x01
#define SET_SPEED_DUPLEX 0x06
#define HALF_DUPLEX 0x00
#define FULL_DUPLEX 0x01
#define SPEED_10M 0x00
#define SPEED_100M 0x02
#define MT 0x00
#define AT 0x04
#define SET_MAC_ADDRESS 0x07
#define SET_MAC_WAKEUP_FRAME 0x08
#define SET_WAKEUP_ENABLE 0x09
#define LINKCHG0_EN 0x01
#define LINKCHG1_EN 0x02
#define MAGICPKT_EN 0x04
#define WAKEUP1_EN 0x08
#define WAKEUP2_EN 0x10
#define WAKEUP3_EN 0x20
#define WAKEUP4_EN 0x40
#define SET_FULL_DUPLEX_FLOW_CONTROL 0x0A
#define SET_HALF_DUPLEX_FLOW_CONTROL 0x0B
//#define TEST_GET_MAC_ADDRESS
//#define TEST_SET_MAC_ADDRESS
//#define TEST_SET_HASH
//#define TEST_SET_PACKAGE_FILTER
//#define TEST_SET_SPEED_DUPLEX
//#define TEST_SET_WAKEUP_ENABLE
#if defined(TEST_SET_WAKEUP_ENABLE)
#define WKE1_EN
#define WKE2_EN
#define WKE3_EN
#define WKE4_EN
#define MAGIC_EN
#define LIKCHG1_EN
#define LIKCHG0_EN
#endif
/**** Reg and CMD definition for CH9x00_PID_E092 ****/
// === constant define
#define RX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? 60 : 4)
#define TX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? 60 : 4)
#define MIN_PACKET sizeof(struct ethhdr)
#define MAX_PACKET 32768
#define TX_TIMEOUT_JIFFIES (5 * HZ)
#define THROTTLE_JIFFIES (HZ /
#define UNLINK_TIMEOUT_MS 3
// for vendor-specific control operations
#define CONTROL_TIMEOUT_MS 1000
// request
#define REQUEST_READ 0x0E
#define REQUEST_WRITE 0x0F
#define REQUEST_TYPE_READ (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER)
#define REQUEST_TYPE_WRITE (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER)
// address space
// addr 00---63 : mii addr
// addr 64---128 : mac addr
// note : read/write must be in word (16 bit)
#define MAC_REG_CTRL 64
#define MAC_REG_STATUS 66
#define MAC_REG_INTERRUPT_MASK 68
#define MAC_REG_PHY_COMMAND 70
#define MAC_REG_PHY_DATA 72
#define MAC_REG_STATION_L 74
#define MAC_REG_STATION_M 76
#define MAC_REG_STATION_H 78
#define MAC_REG_HASH_L 80
#define MAC_REG_HASH_M1 82
#define MAC_REG_HASH_M2 84
#define MAC_REG_HASH_H 86
#define MAC_REG_THRESHOLD 88
#define MAC_REG_FIFO_DEPTH 90
#define MAC_REG_PAUSE 92
#define MAC_REG_FLOW_CONTROL 94
// BIT
// control register bit15 and bit13 reserve
#define LOOPBACK (0x01 << 14)
#define BASE100X (0x01 << 12)
#define MBPS_10 (0x01 << 11)
#define DUPLEX_MODE (0x01 << 10)
#define PAUSE_FRAME (0x01 << 9)
#define PROMISCUOUS (0x01 <<
#define MULTICAST (0x01 << 7)
#define BROADCAST (0x01 << 6)
#define HASH (0x01 << 5)
#define APPEND_PAD (0x01 << 4)
#define APPEND_CRC (0x01 << 3)
#define TRANSMITTER_ACTION (0x01 << 2)
#define RECEIVER_ACTION (0x01 << 1)
#define DMA_ACTION (0x01 << 0)
// status register bit15-bit7 reserve
#define ALIGNMENT (0x01 << 6)
#define FIFO_OVER_RUN (0x01 << 5)
#define FIFO_UNDER_RUN (0x01 << 4)
#define RX_ERROR (0x01 << 3)
#define RX_COMPLETE (0x01 << 2)
#define TX_ERROR (0x01 << 1)
#define TX_COMPLETE (0x01 << 0)
// fifo depth register bit14 and bit6 reserve
#define ETH_TXBD (0x01 << 15)
#define ETN_TX_FIFO_DEPTH // bit13:8
#define ETH_RXBD (0x01 << 7)// bit
#define ETH_RX_FIFO_DEPTH // bit5:0
// **************************************************
int speed_status;
int link_status;
int duplex_status;
int phy_status;
static void ch9x00_async_cmd_callback( struct urb *urb )
{
struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
if( urb->status < 0 )
printk( KERN_DEBUG "%s() failed with %d\n", __FUNCTION__, urb->status);
kfree(req);
usb_free_urb(urb);
}
static void ch9x00_set_reg_async(
struct usbnet *dev,
unsigned char request,
unsigned char requesttype,
unsigned short value,
unsigned short index,
unsigned short size,
void *data )
{
struct usb_ctrlrequest *req;
int ret;
struct urb *urb;
urb = usb_alloc_urb( 0, GFP_ATOMIC);
if(!urb) {
dev_dbg( &dev->udev->dev,
"Error allocation URB in write_cmd_async!\n");
return;
}
req = kmalloc( sizeof *req, GFP_ATOMIC);
if(!req) {
dev_err( &dev->udev->dev,
"Failed to allocate memory for control request\n");
goto out;
}
req->bRequestType = requesttype;
req->bRequest = request;
req->wValue = cpu_to_le16(value);
req->wIndex = cpu_to_le16(index);
req->wLength = cpu_to_le16(size);
usb_fill_control_urb( urb, dev->udev,
usb_sndctrlpipe(dev->udev, 0),
(void *)req, data, size, ch9x00_async_cmd_callback,req);
ret = usb_submit_urb(urb, GFP_ATOMIC);
if( ret < 0 ) {
dev_err( &dev->udev->dev,
"Error submitting the control message, ret:%d\n", ret );
goto out;
}
return;
out:
kfree(req);
usb_free_urb(urb);
}
static void set_speed_duplex( struct usbnet *dev, unsigned char value_l )
{
unsigned short value;
unsigned char value_low = 0x00;
unsigned char value_high = 0x00;
value_low = value_l;
value = value_low | (value_high << 8 );
ch9x00_set_reg_async( dev, SET_SPEED_DUPLEX, REQ_WR_REG, value, 0, 0, NULL);
return;
}
static int control_read( struct usbnet *dev,
unsigned char request, unsigned char requesttype,
unsigned short value, unsigned short index,
void *data, unsigned short size, int timeout )
{
unsigned char *buf = NULL;
int err = 0;
dbg_prt("\n--> Control_read() index=0x%02x size=%d\n", index, size );
buf = kmalloc( size, GFP_KERNEL );
if( !buf ) {
err = -ENOMEM;
goto err_out;
}
err = usb_control_msg( dev->udev,
usb_rcvctrlpipe(dev->udev, 0),
request, requesttype,
value, index,
buf, size, timeout);
if( err == size )
memcpy( data, buf, size );
else if( err >= 0 )
err = -EINVAL;
kfree(buf);
return err;
err_out:
return err;
}
static int control_write( struct usbnet *dev,
unsigned char request, unsigned char requesttype,
unsigned short value, unsigned short index,
void *data, unsigned short size, int timeout )
{
unsigned char *buf = NULL;
int err = 0;
dbg_prt("\n--> Control_write() index=0x%02x size=%d\n", index, size );
if( data ) {
buf = kmalloc( size, GFP_KERNEL );
if( !buf ) {
err = -ENOMEM;
goto err_out;
}
memcpy( buf, data, size );
}
err = usb_control_msg( dev->udev,
usb_sndctrlpipe( dev->udev, 0 ),
request, requesttype,
value, index,
buf, size, timeout );
if( err >= 0 && err < size )
err = -EINVAL;
kfree( buf );
return 0;
err_out:
return err;
}
static int ch9x00_mdio_read( struct net_device *netdev,
int phy_id, int loc )
{
struct usbnet *dev = netdev_priv(netdev);
int product_id = dev->udev->descriptor.idProduct;
__le16 res = 0x00; //for E091
unsigned char buff[2]; //for E092
dbg_prt("ch9x00_mdio_read phy_id:%02x loc:%02x\n", phy_id, loc);
if( product_id == CH9x00_PID_E091 ||
product_id == CH9x00_PID_8339 ) {
mutex_lock( &dev->phy_mutex );
if( phy_id == 0x00 ) {
switch(loc) {
case MII_BMCR: //Basic mode control register
{
if(speed_status == DEVICE_SPEED_10M){
//Do nothing here
}
else
res |= BMCR_SPEED100;
if(duplex_status == DEVICE_DUPLEX_FULL)
res |= BMCR_FULLDPLX;
else {
//Do nothing here
}
res |= BMCR_ANENABLE;
break;
}
case MII_BMSR: //Basic mode status register
{
if(link_status == DEVICE_MEDIA_CONNECTED) //up
res |= BMSR_LSTATUS;
else { //down
//Do nothing
}
if(speed_status == DEVICE_SPEED_10M) {
if(duplex_status == DEVICE_DUPLEX_FULL)
res |= BMSR_10FULL;
else
res |= BMSR_10HALF;
}
else {
if(duplex_status == DEVICE_DUPLEX_FULL)
res |= BMSR_100FULL;
else
res |= BMSR_100HALF;
}
break;
}
case MII_ADVERTISE: //Advertisement control reg
{
if(speed_status == DEVICE_SPEED_10M)
res |= ADVERTISE_10FULL;
else
res |= ADVERTISE_10HALF;
res |= 0x01; //IEEE 802.3
}
case MII_LPA: //Link partner ability reg
{
if(speed_status == DEVICE_SPEED_10M) {
if(duplex_status == DEVICE_DUPLEX_FULL)
res |= LPA_10FULL;
else
res |= LPA_10HALF;
}
else {
if(duplex_status == DEVICE_DUPLEX_FULL)
res |= LPA_100FULL;
else
res |= LPA_100HALF;
}
res |= 0x01; //IEEE 802.3
break;
}
case MII_EXPANSION: //Expansion register
break;
default:
break;
}
}
mutex_unlock( &dev->phy_mutex);
return le16_to_cpu(res);
}
else if( product_id == CH9x00_PID_E092 ) {
if( phy_id )
return 0;
control_read( dev, REQUEST_READ, REQUEST_TYPE_READ,
0, loc*2, buff, 0x02, CONTROL_TIMEOUT_MS );
return ( buff[0] | buff[1] << 8 );
}
return 0;
}
static void ch9x00_mdio_write( struct net_device *netdev,
int phy_id, int loc, int val )
{
struct usbnet *dev = netdev_priv(netdev);
int product_id = dev->udev->descriptor.idProduct;
unsigned char value_l = 0; //for E091
unsigned char buff[2]; //for E092
dbg_prt("ch9x00_mdio_write() phy_id=%02x loc:%02x\n", phy_id, loc);
if( product_id == CH9x00_PID_E091 ||
product_id == CH9x00_PID_8339 ) {
mutex_lock( &dev->phy_mutex );
if(phy_id == 0x00) {
switch(loc) {
case MII_BMCR: //Base mode control register
{
if( val & BMCR_ANRESTART ) {
//Do nothing
}
if( val & BMCR_ANENABLE ) {
value_l |= AT;
goto set;
}
if( val & BMCR_SPEED100 ) {
value_l |= SPEED_100M;
}
// bit 8 duplex mode 1 = full-duplex
if( val & BMCR_FULLDPLX ) {
value_l |= FULL_DUPLEX;
}
set:
set_speed_duplex(dev, value_l);
break;
}
case MII_BMSR: //Basic mode status register
break;
case MII_ADVERTISE: //Advertisement control reg
break;
case MII_LPA: //Link partner ability reg
break;
case MII_EXPANSION: //Expansion register
break;
default:
break;
}
}
mutex_unlock( &dev->phy_mutex );
return;
}
else if( product_id == CH9x00_PID_E092 ) {
buff[0] = (unsigned char)val;
buff[1] = (unsigned char)(val >>
;
if(phy_id)
return;
control_write( dev, REQUEST_WRITE, REQUEST_TYPE_WRITE,
0, loc*2, buff, 0x02, CONTROL_TIMEOUT_MS );
}
}
static int ch9x00_link_reset( struct usbnet *dev )
{
struct ethtool_cmd ecmd;
mii_check_media( &dev->mii, 1, 1 );
mii_ethtool_gset( &dev->mii, &ecmd );
dbg_prt("\nlink_reset() speed:%d duplex:%d \n", ecmd.speed, ecmd.duplex );
return 0;
}
static void ch9x00_status( struct usbnet *dev, struct urb *urb )
{
int link;
unsigned char *buf;
int product_id = dev->udev->descriptor.idProduct;
if( product_id == CH9x00_PID_E091 ||
product_id == CH9x00_PID_8339 ) {
if( urb->actual_length < 8 )
return;
buf = urb->transfer_buffer;
link = !!(buf[0] & DEVICE_MEDIA_CONNECTED );
link_status = buf[0] & DEVICE_MEDIA_CONNECTED;
speed_status = buf[0] & DEVICE_SPEED_10M;
duplex_status = buf[0] & DEVICE_DUPLEX_FULL;
phy_status = buf[0] & DEVICE_PHY;
if( netif_carrier_ok(dev->net) != link ) {
if(link) {
netif_carrier_on(dev->net);
usbnet_defer_kevent(dev, EVENT_LINK_RESET);
}
else {
netif_carrier_off(dev->net);
}
}
}
else if( product_id == CH9x00_PID_E092 ) {
if( urb->actual_length < 16 )
return;
buf = urb->transfer_buffer;
link = !!(buf[0] & 0x01);
if( link ) {
netif_carrier_on(dev->net);
usbnet_defer_kevent(dev, EVENT_LINK_RESET);
}
else {
netif_carrier_off(dev->net);
}
}
return;
}
static struct sk_buff *ch9x00_tx_fixup(
struct usbnet *dev, struct sk_buff *skb, gfp_t flags )
{
int i = 0;
int len = 0;
int tx_overhead = 0;
int product_id = dev->udev->descriptor.idProduct;
if( product_id == CH9x00_PID_E091 ||
product_id == CH9x00_PID_8339 )
tx_overhead = TX_OVERHEAD; //TX_OVERHEAD: 0x04
else if( product_id == CH9x00_PID_E092 )
tx_overhead = 0x40; //64
len = skb->len;
if( skb_headroom(skb) < tx_overhead ) {
struct sk_buff *skb2;
skb2 = skb_copy_expand(skb, tx_overhead, 0, flags);
dev_kfree_skb_any(skb);
skb = skb2;
if( !skb )
return NULL;
}
__skb_push(skb, tx_overhead);
/* usbnet adds padding if length is a multiple of packet size
if so, adjust length value in header */
if( (skb->len % dev->maxpacket) == 0 ) {
len++;
}
if( product_id == CH9x00_PID_E091 ||
product_id == CH9x00_PID_8339 ) {
skb->data[0] = len;
skb->data[1] = len >> 8;
skb->data[2] = 0x00;
skb->data[3] = 0x00;
}
else if( product_id == CH9x00_PID_E092 ) {
skb->data[0] = len;
skb->data[1] = len >> 8;
skb->data[2] = 0x00;
skb->data[3] = 0x80;
for( i = 4; i < 48; i++ )
skb->data
= 0x00;
skb->data[48] = len;
skb->data[49] = len >> 8;
skb->data[50] = 0x00;
skb->data[51] = 0x80;
for( i = 52; i < 64; i++ )
skb->data = 0x00;
}
return skb;
}
static int ch9x00_rx_fixup( struct usbnet *dev, struct sk_buff *skb )
{
int len = 0;
int rx_overhead = 0;
int product_id = dev->udev->descriptor.idProduct;
if( product_id == CH9x00_PID_E091 ||
product_id == CH9x00_PID_8339 ) {
rx_overhead = RX_OVERHEAD;
if( unlikely(skb->len < rx_overhead) ) {
dev_err( &dev->udev->dev, "unexpected tiny rx frame\n");
return 0;
}
len = (skb->data[0] | skb->data[1] << 8 );
skb_pull(skb, rx_overhead);
skb_trim(skb, len);
}
else if( product_id == CH9x00_PID_E092 ) {
// Do nothing here
rx_overhead = 64;
if( unlikely(skb->len < rx_overhead) ) {
dev_err( &dev->udev->dev, "unexpected tiny rx frame\n");
return 0;
}
len = (skb->data[skb->len - 16] | skb->data[skb->len - 15] << 8 );
/*printk("rx_fixup skb->len=%d, len=%d\n", skb->len, len );*/
/*skb_pull(skb, rx_overhead);*/
skb_trim(skb, len);
}
return 1;
}
static int get_mac_address( struct usbnet *dev, unsigned char *data )
{
int err = 0;
//for E092
unsigned char mac_addr[0x06];
int rd_mac_len = 0;
dbg_prt("\n--> get_mac_address:\n\tusbnet VID:%0x PID:%0x\n",
dev->udev->descriptor.idVendor,
dev->udev->descriptor.idProduct);
if( dev->udev->descriptor.idProduct == CH9x00_PID_E091 ||
dev->udev->descriptor.idProduct == CH9x00_PID_8339 )
err = control_read( dev, GET_MAC_ADDRESS, REQ_RD_REG,
0, 0, data, 0x06, CTRL_TIMEOUT_MS );
else if( dev->udev->descriptor.idProduct == CH9x00_PID_E092 ) {
memset( mac_addr, 0, sizeof(mac_addr) );
rd_mac_len = control_read( dev, REQUEST_READ, REQUEST_TYPE_READ,
0, MAC_REG_STATION_L, mac_addr, 0x02, CONTROL_TIMEOUT_MS );
rd_mac_len += control_read( dev, REQUEST_READ, REQUEST_TYPE_READ,
0, MAC_REG_STATION_M, mac_addr+2, 0x02, CONTROL_TIMEOUT_MS );
rd_mac_len += control_read( dev, REQUEST_READ, REQUEST_TYPE_READ,
0, MAC_REG_STATION_H, mac_addr+4, 0x02, CONTROL_TIMEOUT_MS );
if( rd_mac_len != ETH_ALEN )
err = -EINVAL;
//Set MAC
data[0] = mac_addr[5];
data[1] = mac_addr[4];
data[2] = mac_addr[3];
data[3] = mac_addr[2];
data[4] = mac_addr[1];
data[5] = mac_addr[0];
}
if( err < 0 )
goto err_out;
return 0;
err_out:
return err;
}
static int ch9x00_bind( struct usbnet *dev, struct usb_interface *intf )
{
int retval = 0;
unsigned char data[2];
//int vendor_id = dev->udev->descriptor.idVendor;
int product_id = dev->udev->descriptor.idProduct;
retval = usbnet_get_endpoints(dev, intf);
if(retval)
goto err_out;
// compatibility of E091 and E092
if( product_id == CH9x00_PID_E091 ||
product_id == CH9x00_PID_8339 ) {
if( (retval = get_mac_address(dev, dev->net->dev_addr)) < 0 ) {
return retval;
goto err_out;
}
}
// Initialize MII structure for Setting Speed Duplex
dev->mii.dev = dev->net;
dev->mii.mdio_read = ch9x00_mdio_read;
dev->mii.mdio_write = ch9x00_mdio_write;
dev->mii.reg_num_mask = 0x1f;
if( product_id == CH9x00_PID_E091 ||
product_id == CH9x00_PID_8339 ) {
dev->mii.phy_id_mask = 0x3f;
/*dev->rx_urb_size = dev->net->mtu + 14 + RX_OVERHEAD;*/
// Note: Max package length=1518 (MTU + ETH_HELN + RX_OVERHEAD)
dev->rx_urb_size = dev->net->mtu + ETH_HLEN + RX_OVERHEAD;
// Adaptor can restart, when driver rmmoded or insmoded
mii_nway_restart( &dev->mii );
}
else if( product_id == CH9x00_PID_E092 ) {
dev->mii.phy_id_mask = 0x1f;
dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
// Note: Max package legth= 24*64 + 16
dev->rx_urb_size = 24*64 + 16;
// Adaptor can restart, when driver rmmoded or insmoded
mii_nway_restart( &dev->mii );
// Initilization hardware
data[0] = 0x01;
data[1] = 0x0F;
retval = control_write( dev, REQUEST_WRITE, REQUEST_TYPE_WRITE,
0, 88, data, 0x02, CONTROL_TIMEOUT_MS );
data[0] = 0xA0;
data[1] = 0x90;
retval = control_write( dev, REQUEST_WRITE, REQUEST_TYPE_WRITE,
0, 90, data, 0x02, CONTROL_TIMEOUT_MS );
data[0] = 0x30;
data[1] = 0x00;
retval = control_write( dev, REQUEST_WRITE, REQUEST_TYPE_WRITE,
0, 92, data, 0x02, CONTROL_TIMEOUT_MS );
data[0] = 0x17;
data[1] = 0xD8;
retval = control_write( dev, REQUEST_WRITE, REQUEST_TYPE_WRITE,
0, 94, data, 0x02, CONTROL_TIMEOUT_MS );
data[0] = 0x01;
data[1] = 0x00;
retval = control_write( dev, REQUEST_WRITE, REQUEST_TYPE_WRITE,
0, 254, data, 0x02, CONTROL_TIMEOUT_MS );
data[0] = 0x5F; // 0x0101 1111
data[1] = 0x0D; // 0x0000 1101
// Control Register Setting
retval = control_write( dev, REQUEST_WRITE, REQUEST_TYPE_WRITE,
0, 64, data, 0x02, CONTROL_TIMEOUT_MS );
if( (retval = get_mac_address(dev, dev->net->dev_addr)) < 0 ) {
return retval;
goto err_out;
}
}
if( retval < 0 )
goto err_out;
return 0;
err_out:
return retval;
}
static const struct driver_info ch9x00_info = {
.description = "CH9x00 USB to Network Adaptor",
.flags = FLAG_ETHER,
.bind = ch9x00_bind,
.rx_fixup = ch9x00_rx_fixup,
.tx_fixup = ch9x00_tx_fixup,
.status = ch9x00_status,
.link_reset = ch9x00_link_reset,
.reset = ch9x00_link_reset,
};
static const struct usb_device_id ch9x00_products[] = {
{
USB_DEVICE( 0x1A86, 0xE091 ),
.driver_info = (unsigned long)&ch9x00_info,
},
{
USB_DEVICE( 0x1A86, 0xE092 ),
.driver_info = (unsigned long)&ch9x00_info,
},
{ USB_DEVICE( 0x1A86, 0x8339 ),
.driver_info = (unsigned long)&ch9x00_info,
},
{},
};
MODULE_DEVICE_TABLE( usb, ch9x00_products );
static struct usb_driver ch9x00_driver = {
.name = "ch9x00",
.id_table = ch9x00_products,
.probe = usbnet_probe,
.disconnect = usbnet_disconnect,
.suspend = usbnet_suspend,
.resume = usbnet_resume,
};
static int __init ch9x00_init( void )
{
printk( KERN_INFO "\tCH9x00 Driver Version:%s\n", DRIVER_VERSION);
return usb_register( &ch9x00_driver );
}
static void __exit ch9x00_exit( void )
{
usb_deregister( &ch9x00_driver );
}
module_init( ch9x00_init );
module_exit( ch9x00_exit );
MODULE_DESCRIPTION( "USB to Network adapter CH9x00" );
MODULE_LICENSE( "GPL" );
Тема: CH9200, драйвер и прочая шаурма (Прочитано 2306 раз)
