From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751045Ab3HTKmS (ORCPT ); Tue, 20 Aug 2013 06:42:18 -0400 Received: from m12-13.163.com ([220.181.12.13]:54871 "EHLO m12-13.163.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750873Ab3HTKmQ (ORCPT ); Tue, 20 Aug 2013 06:42:16 -0400 X-Coremail-DSSMTP: 119.123.183.130 Date: Tue, 20 Aug 2013 18:41:12 +0800 From: "liujunliang_ljl" To: "gregkh" Cc: "sunhecheng" , "linux-usb" , "netdev" , "linux-kernel" Subject: [PATCH-SR9700] Merge USB 1.1 Ethernet Adapter SR9700 Device Driver into the Linux Kernel Message-ID: <201308201841116403992@163.com> X-mailer: Foxmail 6, 15, 201, 22 [cn] Mime-Version: 1.0 Content-Type: text/plain; charset="gb2312" X-CM-TRANSID: DcCowECJdEbIRxNS6CymAA--.1118S2 X-Coremail-Antispam: 1Uf129KBjvAXoW3ury7Gr4rWF4fCw4kZw1xGrg_yoW8Zr1fGo Z7ZFsxAw18JryxArs5Ww1xXw4kXFyDKw45Ar43XrZ7Wa43XF1DKrW3W3y5C345Ja4S9rn5 Zr18tws3AFZYvrW5n29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UbIYCTnIWIevJa73UjIFyTuYvjxUfQJ5UUUUU X-CM-SenderInfo: xolxy3pqolt0hjboyzi6rwjhhfrp/1tbiHR9-X1EAFs4RZgAAsc Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by mail.home.local id r7KAgN0u012844 Dear all £º I am the software engineer Liu Junliang from ShenZhen CoreChips high technology company, on the market of SR9700 chip is designed and owned by us. SR9700 is a type of USB to Ethernet Converter and is compatible with USB 1.1 protocol, We want to merge SR9700 device driver into the Linux Kernel. The following is the Linux 3.10.7 version patch for SR9700, Please give us the assessment and support. Thanks a lot. [PATCH] : diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig index 287cc62..a94b196 100644 --- a/drivers/net/usb/Kconfig +++ b/drivers/net/usb/Kconfig @@ -272,6 +272,14 @@ config USB_NET_DM9601 This option adds support for Davicom DM9601 based USB 1.1 10/100 Ethernet adapters. +config USB_NET_SR9700 + tristate "CoreChip-sz SR9700 based USB 1.1 10/100 ethernet devices" + depends on USB_USBNET + select CRC32 + help + This option adds support for CoreChip-sz SR9700 based USB 1.1 + 10/100 Ethernet adapters. + config USB_NET_SMSC75XX tristate "SMSC LAN75XX based USB 2.0 gigabit ethernet devices" depends on USB_USBNET diff --git a/drivers/net/usb/Makefile b/drivers/net/usb/Makefile index 9ab5c9d..bba87a2 100644 --- a/drivers/net/usb/Makefile +++ b/drivers/net/usb/Makefile @@ -14,6 +14,7 @@ obj-$(CONFIG_USB_NET_AX88179_178A) += ax88179_178a.o obj-$(CONFIG_USB_NET_CDCETHER) += cdc_ether.o obj-$(CONFIG_USB_NET_CDC_EEM) += cdc_eem.o obj-$(CONFIG_USB_NET_DM9601) += dm9601.o +obj-$(CONFIG_USB_NET_SR9700) += sr9700.o obj-$(CONFIG_USB_NET_SMSC75XX) += smsc75xx.o obj-$(CONFIG_USB_NET_SMSC95XX) += smsc95xx.o obj-$(CONFIG_USB_NET_GL620A) += gl620a.o diff --git a/drivers/net/usb/sr9700.c b/drivers/net/usb/sr9700.c new file mode 100644 index 0000000..6a6429a --- /dev/null +++ b/drivers/net/usb/sr9700.c @@ -0,0 +1,557 @@ +/* + * CoreChip-sz SR9700 one chip USB 1.1 Ethernet Devices + * + * Author : liujl + * + * Based on dm9601.c + * + * 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, whether express or implied. + */ + +//#define DEBUG + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "sr9700.h" + +static int sr_read(struct usbnet *dev, u8 reg, u16 length, void *data) +{ + int err; + + err = usbnet_read_cmd(dev, SR_RD_REGS, SR_REQ_RD_REG, + 0, reg, data, length); + if(err != length && err >= 0) + err = -EINVAL; + return err; +} + +static int sr_write(struct usbnet *dev, u8 reg, u16 length, void *data) +{ + int err; + + err = usbnet_write_cmd(dev, SR_WR_REGS, SR_REQ_WR_REG, + 0, reg, data, length); + if (err >= 0 && err < length) + err = -EINVAL; + + return err; +} + +static int sr_read_reg(struct usbnet *dev, u8 reg, u8 *value) +{ + return sr_read(dev, reg, 1, value); +} + +static int sr_write_reg(struct usbnet *dev, u8 reg, u8 value) +{ + return usbnet_write_cmd(dev, SR_WR_REGS, SR_REQ_WR_REG, + value, reg, NULL, 0); +} + +static void sr_write_async(struct usbnet *dev, u8 reg, u16 length, void *data) +{ + usbnet_write_cmd_async(dev, SR_WR_REGS, SR_REQ_WR_REG, + 0, reg, data, length); +} + +static void sr_write_reg_async(struct usbnet *dev, u8 reg, u8 value) +{ + usbnet_write_cmd_async(dev, SR_WR_REGS, SR_REQ_WR_REG, + value, reg, NULL, 0); +} + +static int sr_share_read_word(struct usbnet *dev, int phy, u8 reg, __le16 *value) +{ + int ret, i; + + mutex_lock(&dev->phy_mutex); + + sr_write_reg(dev, EPAR, phy ? (reg | 0x40) : reg); + sr_write_reg(dev, EPCR, phy ? 0xc : 0x4); + + for (i = 0; i < SR_SHARE_TIMEOUT; i++) { + u8 tmp = 0; + + udelay(1); + ret = sr_read_reg(dev, EPCR, &tmp); + if (ret < 0) + goto out; + + /* ready */ + if ((tmp & 1) == 0) + break; + } + + if (i >= SR_SHARE_TIMEOUT) { + netdev_err(dev->net, "%s read timed out!", phy ? "phy" : "eeprom"); + ret = -EIO; + goto out; + } + + sr_write_reg(dev, EPCR, 0x0); + ret = sr_read(dev, EPDR, 2, value); + + netdev_dbg(dev->net, "read shared %d 0x%02x returned 0x%04x, %d", + phy, reg, *value, ret); + + out: + mutex_unlock(&dev->phy_mutex); + return ret; +} + +static int sr_share_write_word(struct usbnet *dev, int phy, u8 reg, __le16 value) +{ + int ret, i; + + mutex_lock(&dev->phy_mutex); + + ret = sr_write(dev, EPDR, 2, &value); + if (ret < 0) + goto out; + + sr_write_reg(dev, EPAR, phy ? (reg | 0x40) : reg); + sr_write_reg(dev, EPCR, phy ? 0x1a : 0x12); + + for (i = 0; i < SR_SHARE_TIMEOUT; i++) { + u8 tmp = 0; + + udelay(1); + ret = sr_read_reg(dev, EPCR, &tmp); + if (ret < 0) + goto out; + + /* ready */ + if ((tmp & 1) == 0) + break; + } + + if (i >= SR_SHARE_TIMEOUT) { + netdev_err(dev->net, "%s write timed out!", phy ? "phy" : "eeprom"); + ret = -EIO; + goto out; + } + + sr_write_reg(dev, EPCR, 0x0); + +out: + mutex_unlock(&dev->phy_mutex); + return ret; +} + +static int sr_read_eeprom_word(struct usbnet *dev, u8 offset, void *value) +{ + return sr_share_read_word(dev, 0, offset, value); +} + + +static int sr9700_get_eeprom_len(struct net_device *dev) +{ + return SR_EEPROM_LEN; +} + +static int sr9700_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom, u8 * data) +{ + struct usbnet *dev = netdev_priv(net); + __le16 *ebuf = (__le16 *) data; + int i; + + /* access is 16bit */ + if ((eeprom->offset % 2) || (eeprom->len % 2)) + return -EINVAL; + + for (i = 0; i < eeprom->len / 2; i++) { + if (sr_read_eeprom_word(dev, eeprom->offset / 2 + i, &ebuf[i]) < 0) + return -EINVAL; + } + return 0; +} + +static int sr_mdio_read(struct net_device *netdev, int phy_id, int loc) +{ + struct usbnet *dev = netdev_priv(netdev); + + __le16 res; + int rc = 0; + + if (phy_id) { + netdev_dbg(dev->net, "Only internal phy supported"); + return 0; + } + + /* Access NSR_LINKST bit for link status instead of MII_BMSR */ + if(loc == MII_BMSR){ + u8 value; + sr_read_reg(dev, NSR, &value); + if(value & NSR_LINKST) { + rc = 1; + } + } + sr_share_read_word(dev, 1, loc, &res); + if(rc == 1) + return (le16_to_cpu(res) | BMSR_LSTATUS); + else + return (le16_to_cpu(res) & ~BMSR_LSTATUS); + + netdev_dbg(dev->net, + "sr_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x", + phy_id, loc, le16_to_cpu(res)); + + return le16_to_cpu(res); +} + +static void sr_mdio_write(struct net_device *netdev, int phy_id, int loc, int val) +{ + struct usbnet *dev = netdev_priv(netdev); + __le16 res = cpu_to_le16(val); + + if (phy_id) { + netdev_dbg(dev->net, "Only internal phy supported"); + return; + } + + netdev_dbg(dev->net,"sr_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x", + phy_id, loc, val); + + sr_share_write_word(dev, 1, loc, res); +} + +/*-------------------------------------------------------------------------------------------*/ + +static void sr9700_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info) +{ + /* Inherit standard device info */ + usbnet_get_drvinfo(net, info); + info->eedump_len = SR_EEPROM_LEN; +} + +static u32 sr9700_get_link(struct net_device *net) +{ + struct usbnet *dev = netdev_priv(net); + int rc = 0; + u8 value = 0; + + /* Get the Link Status directly */ + sr_read_reg(dev, NSR, &value); + if(value & NSR_LINKST) { + rc = 1; + } + + return rc; +} + +static int sr9700_ioctl(struct net_device *net, struct ifreq *rq, int cmd) +{ + struct usbnet *dev = netdev_priv(net); + + return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL); +} + +static const struct ethtool_ops sr9700_ethtool_ops = { + .get_drvinfo = sr9700_get_drvinfo, + .get_link = sr9700_get_link, + .get_msglevel = usbnet_get_msglevel, + .set_msglevel = usbnet_set_msglevel, + .get_eeprom_len = sr9700_get_eeprom_len, + .get_eeprom = sr9700_get_eeprom, + .get_settings = usbnet_get_settings, + .set_settings = usbnet_set_settings, + .nway_reset = usbnet_nway_reset, +}; + +static void sr9700_set_multicast(struct net_device *net) +{ + struct usbnet *dev = netdev_priv(net); + /* We use the 20 byte dev->data for our 8 byte filter buffer + * to avoid allocating memory that is tricky to free later */ + u8 *hashes = (u8 *) & dev->data; + u8 rx_ctl = 0x31; // enable, disable_long, disable_crc + + memset(hashes, 0x00, SR_MCAST_SIZE); + hashes[SR_MCAST_SIZE - 1] |= 0x80; /* broadcast address */ + + if (net->flags & IFF_PROMISC) { + rx_ctl |= 0x02; + } else if (net->flags & IFF_ALLMULTI || + netdev_mc_count(net) > SR_MCAST_MAX) { + rx_ctl |= 0x04; + } else if (!netdev_mc_empty(net)) { + struct netdev_hw_addr *ha; + + netdev_for_each_mc_addr(ha, net) { + u32 crc = ether_crc(ETH_ALEN, ha->addr) >> 26; + hashes[crc >> 3] |= 1 << (crc & 0x7); + } + } + + sr_write_async(dev, MAR, SR_MCAST_SIZE, hashes); + sr_write_reg_async(dev, RCR, rx_ctl); +} + +static int sr9700_set_mac_address(struct net_device *net, void *p) +{ + struct sockaddr *addr = p; + struct usbnet *dev = netdev_priv(net); + + if (!is_valid_ether_addr(addr->sa_data)) { + dev_err(&net->dev, "not setting invalid mac address %pM\n", + addr->sa_data); + return -EINVAL; + } + + memcpy(net->dev_addr, addr->sa_data, net->addr_len); + sr_write_async(dev, PAR, 6, dev->net->dev_addr); + + return 0; +} + +static const struct net_device_ops sr9700_netdev_ops = { + .ndo_open = usbnet_open, + .ndo_stop = usbnet_stop, + .ndo_start_xmit = usbnet_start_xmit, + .ndo_tx_timeout = usbnet_tx_timeout, + .ndo_change_mtu = usbnet_change_mtu, + .ndo_validate_addr = eth_validate_addr, + .ndo_do_ioctl = sr9700_ioctl, + .ndo_set_rx_mode = sr9700_set_multicast, + .ndo_set_mac_address = sr9700_set_mac_address, +}; + +static int sr9700_bind(struct usbnet *dev, struct usb_interface *intf) +{ + int ret; + + ret = usbnet_get_endpoints(dev, intf); + if (ret) + goto out; + + dev->net->netdev_ops = &sr9700_netdev_ops; + dev->net->ethtool_ops = &sr9700_ethtool_ops; + dev->net->hard_header_len += SR_TX_OVERHEAD; + dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len; + dev->rx_urb_size = 3072; // bulkin buffer is preferably not less than 3K + + dev->mii.dev = dev->net; + dev->mii.mdio_read = sr_mdio_read; + dev->mii.mdio_write = sr_mdio_write; + dev->mii.phy_id_mask = 0x1f; + dev->mii.reg_num_mask = 0x1f; + + /* reset the sr9700 */ + sr_write_reg(dev, NCR, 1); + udelay(20); + + /* read MAC */ + if (sr_read(dev, PAR, ETH_ALEN, dev->net->dev_addr) < 0) { + printk(KERN_ERR "Error reading MAC address\n"); + ret = -ENODEV; + goto out; + } + + /* power up and reset phy */ + sr_write_reg(dev, PRR, 1); + mdelay(20); // at least 10ms, here 20ms for safe + sr_write_reg(dev, PRR, 0); + udelay(2 * 1000); // at least 1ms, here 2ms for reading right register + + /* receive broadcast packets */ + sr9700_set_multicast(dev->net); + + sr_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET); + sr_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE, ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP); + mii_nway_restart(&dev->mii); + +out: + return ret; +} + +static int sr9700_rx_fixup(struct usbnet *dev, struct sk_buff *skb) +{ + int len; + struct sk_buff *sr_skb; + + /* format: + b0: rx status + b1: packet length (incl crc) low + b2: packet length (incl crc) high + b3..n-4: packet data + bn-3..bn: ethernet crc + */ + + if (unlikely(skb->len < SR_RX_OVERHEAD)) { + dev_err(&dev->udev->dev, "unexpected tiny rx frame\n"); + return 0; + } + + /* + * Each packet contains multiple skbs + */ + while (skb->len > SR_RX_OVERHEAD) + { + if (skb->data[0] != 0x40) + { + return 0; + } + + /* ignore the CRC length */ + len = (skb->data[1] | (skb->data[2] << 8)) - 4; + + if (len > ETH_FRAME_LEN) + { + return 0; + } + + /* the last skb of current packet */ + if (skb->len == (len + SR_RX_OVERHEAD)) + { + skb_pull( skb, 3 ); + skb->len = len; + skb->tail = skb->data + len; + skb->truesize = len + sizeof(struct sk_buff); + return 2; + } + + /* skb_clone is used for address align */ + sr_skb = skb_clone(skb, GFP_ATOMIC); + if (sr_skb) + { + sr_skb->len = len; + sr_skb->data = skb->data + 3; + sr_skb->tail = skb->data + len; + sr_skb->truesize = len + sizeof(struct sk_buff); + usbnet_skb_return(dev, sr_skb); + } + else + { + return 0; + } + + skb_pull( skb, len + SR_RX_OVERHEAD ); + }; + + return 0; +} + +static struct sk_buff *sr9700_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags) +{ + int len; + + /* format: + b0: packet length low + b1: packet length high + b3..n: packet data + */ + + len = skb->len; + + if (skb_headroom(skb) < SR_TX_OVERHEAD) { + struct sk_buff *skb2; + + skb2 = skb_copy_expand(skb, SR_TX_OVERHEAD, 0, flags); + dev_kfree_skb_any(skb); + skb = skb2; + if (!skb) + return NULL; + } + + __skb_push(skb, SR_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++; + + skb->data[0] = len; + skb->data[1] = len >> 8; + + return skb; +} + +static void sr9700_status(struct usbnet *dev, struct urb *urb) +{ + int link; + u8 *buf; + + /* format: + b0: net status + b1: tx status 1 + b2: tx status 2 + b3: rx status + b4: rx overflow + b5: rx count + b6: tx count + b7: gpr + */ + + if (urb->actual_length < 8) + return; + + buf = urb->transfer_buffer; + + link = !!(buf[0] & 0x40); + if (netif_carrier_ok(dev->net) != link) { + usbnet_link_change(dev, link, 1); + netdev_dbg(dev->net, "Link Status is: %d", link); + } +} + +static int sr9700_link_reset(struct usbnet *dev) +{ + struct ethtool_cmd ecmd; + + mii_check_media(&dev->mii, 1, 1); + mii_ethtool_gset(&dev->mii, &ecmd); + + netdev_dbg(dev->net, "link_reset() speed: %d duplex: %d", + ecmd.speed, ecmd.duplex); + + return 0; +} + +static const struct driver_info sr9700_driver_info = { + .description = "CoreChip SR9700 USB Ethernet", + .flags = FLAG_ETHER, + .bind = sr9700_bind, + .rx_fixup = sr9700_rx_fixup, + .tx_fixup = sr9700_tx_fixup, + .status = sr9700_status, + .link_reset = sr9700_link_reset, + .reset = sr9700_link_reset, +}; + +static const struct usb_device_id products[] = { + { + USB_DEVICE(0x0fe6, 0x9700), /* SR9700 device */ + .driver_info = (unsigned long)&sr9700_driver_info, + }, + {}, // END +}; + +MODULE_DEVICE_TABLE(usb, products); + +static struct usb_driver sr9700_usb_driver = { + .name = "sr9700", + .id_table = products, + .probe = usbnet_probe, + .disconnect = usbnet_disconnect, + .suspend = usbnet_suspend, + .resume = usbnet_resume, + .disable_hub_initiated_lpm = 1, +}; + +module_usb_driver(sr9700_usb_driver); + +MODULE_AUTHOR("liujl "); +MODULE_DESCRIPTION("SR9700 one chip USB 1.1 USB to Ethernet device from http://www.corechip-sz.com/"); +MODULE_LICENSE("GPL"); diff --git a/drivers/net/usb/sr9700.h b/drivers/net/usb/sr9700.h new file mode 100644 index 0000000..d9fe82d --- /dev/null +++ b/drivers/net/usb/sr9700.h @@ -0,0 +1,152 @@ +/* + * CoreChip-sz SR9700 one chip USB 1.1 Ethernet Devices + * + * Author : liujl + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + */ + +/* sr9700 spec. register table on android platform */ +/* Registers */ +#define NCR 0x00 +#define NSR 0x01 +#define TCR 0x02 +#define TSR1 0x03 +#define TSR2 0x04 +#define RCR 0x05 +#define RSR 0x06 +#define ROCR 0x07 +#define BPTR 0x08 +#define FCTR 0x09 +#define FCR 0x0A +#define EPCR 0x0B +#define EPAR 0x0C +#define EPDR 0x0D // 0x0D ~ 0x0E +#define WCR 0x0F +#define PAR 0x10 +#define MAR 0x16 +#define PRR 0x1F +#define TWPAL 0x20 +#define TWPAH 0x21 +#define TRPAL 0x22 +#define TRPAH 0x23 +#define RWPAL 0x24 +#define RWPAH 0x25 +#define RRPAL 0x26 +#define RRPAH 0x27 +#define VID 0x28 +#define PID 0x2A +#define CHIPR 0x2C +#define USBDA 0xF0 +#define RXC 0xF1 +#define TXC_USBS 0xF2 +#define USBC 0xF4 + +/* Bit definition for registers */ +// Network Control Reg +#define NCR_RST (1 << 0) +#define NCR_LBK (3 << 1) +#define NCR_FDX (1 << 3) +#define NCR_WAKEEN (1 << 6) +// Network Status Reg +#define NSR_RXRDY (1 << 0) +#define NSR_RXOV (1 << 1) +#define NSR_TX1END (1 << 2) +#define NSR_TX2END (1 << 3) +#define NSR_TXFULL (1 << 4) +#define NSR_WAKEST (1 << 5) +#define NSR_LINKST (1 << 6) +#define NSR_SPEED (1 << 7) +// Tx Control Reg +#define TCR_CRC_DIS (1 << 1) +#define TCR_PAD_DIS (1 << 2) +#define TCR_LC_CARE (1 << 3) +#define TCR_CRS_CARE (1 << 4) +#define TCR_EXCECM (1 << 5) +#define TCR_LF_EN (1 << 6) +// Tx Status Reg for Packet 1 +#define TSR1_EC (1 << 2) +#define TSR1_COL (1 << 3) +#define TSR1_LC (1 << 4) +#define TSR1_NC (1 << 5) +#define TSR1_LOC (1 << 6) +#define TSR1_TLF (1 << 7) +// Tx Status Reg for Packet 2 +#define TSR2_EC (1 << 2) +#define TSR2_COL (1 << 3) +#define TSR2_LC (1 << 4) +#define TSR2_NC (1 << 5) +#define TSR2_LOC (1 << 6) +#define TSR2_TLF (1 << 7) +// Rx Control Reg +#define RCR_RXEN (1 << 0) +#define RCR_PRMSC (1 << 1) +#define RCR_RUNT (1 << 2) +#define RCR_ALL (1 << 3) +#define RCR_DIS_CRC (1 << 4) +#define RCR_DIS_LONG (1 << 5) +// Rx Status Reg +#define RSR_AE (1 << 2) +#define RSR_MF (1 << 6) +#define RSR_RF (1 << 7) +// Recv Overflow Counter Reg +#define ROCR_ROC (0x7F << 0) +#define ROCR_RXFU (1 << 7) +// Back Pressure Threshold Reg +#define BPTR_JPT (0x0F << 0) +#define BPTR_BPHW (0x0F << 4) +// Flow Control Threshold Reg +#define FCTR_LWOT (0x0F << 0) +#define FCTR_HWOT (0x0F << 4) +// rx/tx Flow Control Reg +#define FCR_FLCE (1 << 0) +#define FCR_BKPA (1 << 4) +#define FCR_TXPEN (1 << 5) +#define FCR_TXPF (1 << 6) +#define FCR_TXP0 (1 << 7) +// EEPROM & PHY Control Reg +#define EPCR_ERRE (1 << 0) +#define EPCR_ERPRW (1 << 1) +#define EPCR_ERPRR (1 << 2) +#define EPCR_EPOS (1 << 3) +#define EPCR_WEP (1 << 4) +// EEPROM & PHY Address Reg +#define EPAR_EROA (0x3F << 0) +#define EPAR_PHY_ADR (0x03 << 6) +// Wakeup Control Reg +#define WCR_MAGICST (1 << 0) +#define WCR_LINKST (1 << 2) +#define WCR_MAGICEN (1 << 3) +#define WCR_LINKEN (1 << 5) +// Phy Reset Reg +#define PRR_PHY_RST (1 << 0) +// USB Device Address Reg +#define USBDA_USBFA (0x7F << 0) +// TX packet Counter & USB Status Reg +#define TXC_USBS_TXC0 (1 << 0) +#define TXC_USBS_TXC1 (1 << 1) +#define TXC_USBS_TXC2 (1 << 2) +#define TXC_USBS_EP1RDY (1 << 5) +#define TXC_USBS_SUSFLAG (1 << 6) +#define TXC_USBS_RXFAULT (1 << 7) +// USB Control Reg +#define USBC_EP3NAK (1 << 4) +#define USBC_EP3ACK (1 << 5) + +/* Variables */ +#define SR_RD_REGS 0x00 +#define SR_WR_REGS 0x01 +#define SR_WR_REG 0x03 +#define SR_REQ_RD_REG (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE) +#define SR_REQ_WR_REG (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE) + +#define SR_SHARE_TIMEOUT 1000 +#define SR_EEPROM_LEN 256 +#define SR_MCAST_SIZE 8 +#define SR_MCAST_MAX 64 +#define SR_TX_OVERHEAD 2 // 2bytes header +#define SR_RX_OVERHEAD 7 // 3bytes header + 4crc tail + +/*----------------------------------------------------------------------------------------------*/ -------------------------------------------------- 2013-08-20 liujunliang_ljl www.corechip-sz.com ÿôèº{.nÇ+‰·Ÿ®‰­†+%ŠËÿ±éݶ¥Šwÿº{.nÇ+‰·¥Š{±þG«éÿŠ{ayºʇڙë,j­¢f£¢·hšïêÿ‘êçz_è®(­éšŽŠÝ¢j"ú¶m§ÿÿ¾«þG«éÿ¢¸?™¨è­Ú&£ø§~á¶iO•æ¬z·švØ^¶m§ÿÿà ÿ¶ìÿ¢¸?–I¥ From mboxrd@z Thu Jan 1 00:00:00 1970 From: "liujunliang_ljl" Subject: [PATCH-SR9700] Merge USB 1.1 Ethernet Adapter SR9700 Device Driver into the Linux Kernel Date: Tue, 20 Aug 2013 18:41:12 +0800 Message-ID: <201308201841116403992@163.com> Mime-Version: 1.0 Content-Type: text/plain; charset="gb2312" Content-Transfer-Encoding: base64 Cc: "sunhecheng" , "linux-usb" , "netdev" , "linux-kernel" To: "gregkh" Return-path: Sender: linux-usb-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org List-Id: netdev.vger.kernel.org RGVhciBhbGwgo7oNCg0KCQlJIGFtIHRoZSBzb2Z0d2FyZSBlbmdpbmVlciBMaXUgSnVubGlhbmcg ZnJvbSBTaGVuWmhlbiBDb3JlQ2hpcHMgaGlnaCB0ZWNobm9sb2d5IGNvbXBhbnksIG9uIHRoZSBt YXJrZXQgb2YgU1I5NzAwIGNoaXAgaXMgZGVzaWduZWQgYW5kIG93bmVkIGJ5IHVzLiANCiAgICAg ICAgU1I5NzAwIGlzIGEgdHlwZSBvZiBVU0IgdG8gRXRoZXJuZXQgQ29udmVydGVyIGFuZCBpcyBj b21wYXRpYmxlIHdpdGggVVNCIDEuMSBwcm90b2NvbCwgV2Ugd2FudCB0byBtZXJnZSBTUjk3MDAg ZGV2aWNlIGRyaXZlciBpbnRvIHRoZSBMaW51eCBLZXJuZWwuIFRoZSBmb2xsb3dpbmcgaXMgdGhl IExpbnV4IDMuMTAuNyB2ZXJzaW9uIHBhdGNoIGZvciBTUjk3MDAsIFBsZWFzZSBnaXZlIHVzIHRo ZSBhc3Nlc3NtZW50IGFuZCBzdXBwb3J0Lg0KICAgICAgICBUaGFua3MgYSBsb3QuDQoNCltQQVRD SF0gOiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgDQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9u ZXQvdXNiL0tjb25maWcgYi9kcml2ZXJzL25ldC91c2IvS2NvbmZpZw0KaW5kZXggMjg3Y2M2Mi4u YTk0YjE5NiAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvbmV0L3VzYi9LY29uZmlnDQorKysgYi9kcml2 ZXJzL25ldC91c2IvS2NvbmZpZw0KQEAgLTI3Miw2ICsyNzIsMTQgQEAgY29uZmlnIFVTQl9ORVRf RE05NjAxDQogCSAgVGhpcyBvcHRpb24gYWRkcyBzdXBwb3J0IGZvciBEYXZpY29tIERNOTYwMSBi YXNlZCBVU0IgMS4xDQogCSAgMTAvMTAwIEV0aGVybmV0IGFkYXB0ZXJzLg0KIA0KK2NvbmZpZyBV U0JfTkVUX1NSOTcwMA0KKwl0cmlzdGF0ZSAiQ29yZUNoaXAtc3ogU1I5NzAwIGJhc2VkIFVTQiAx LjEgMTAvMTAwIGV0aGVybmV0IGRldmljZXMiDQorCWRlcGVuZHMgb24gVVNCX1VTQk5FVA0KKwlz ZWxlY3QgQ1JDMzINCisJaGVscA0KKwkgIFRoaXMgb3B0aW9uIGFkZHMgc3VwcG9ydCBmb3IgQ29y ZUNoaXAtc3ogU1I5NzAwIGJhc2VkIFVTQiAxLjENCisJICAxMC8xMDAgRXRoZXJuZXQgYWRhcHRl cnMuDQorDQogY29uZmlnIFVTQl9ORVRfU01TQzc1WFgNCiAJdHJpc3RhdGUgIlNNU0MgTEFONzVY WCBiYXNlZCBVU0IgMi4wIGdpZ2FiaXQgZXRoZXJuZXQgZGV2aWNlcyINCiAJZGVwZW5kcyBvbiBV U0JfVVNCTkVUDQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdXNiL01ha2VmaWxlIGIvZHJpdmVy cy9uZXQvdXNiL01ha2VmaWxlDQppbmRleCA5YWI1YzlkLi5iYmE4N2EyIDEwMDY0NA0KLS0tIGEv ZHJpdmVycy9uZXQvdXNiL01ha2VmaWxlDQorKysgYi9kcml2ZXJzL25ldC91c2IvTWFrZWZpbGUN CkBAIC0xNCw2ICsxNCw3IEBAIG9iai0kKENPTkZJR19VU0JfTkVUX0FYODgxNzlfMTc4QSkgICAg ICArPSBheDg4MTc5XzE3OGEubw0KIG9iai0kKENPTkZJR19VU0JfTkVUX0NEQ0VUSEVSKQkrPSBj ZGNfZXRoZXIubw0KIG9iai0kKENPTkZJR19VU0JfTkVUX0NEQ19FRU0pCSs9IGNkY19lZW0ubw0K IG9iai0kKENPTkZJR19VU0JfTkVUX0RNOTYwMSkJKz0gZG05NjAxLm8NCitvYmotJChDT05GSUdf VVNCX05FVF9TUjk3MDApCSs9IHNyOTcwMC5vDQogb2JqLSQoQ09ORklHX1VTQl9ORVRfU01TQzc1 WFgpCSs9IHNtc2M3NXh4Lm8NCiBvYmotJChDT05GSUdfVVNCX05FVF9TTVNDOTVYWCkJKz0gc21z Yzk1eHgubw0KIG9iai0kKENPTkZJR19VU0JfTkVUX0dMNjIwQSkJKz0gZ2w2MjBhLm8NCmRpZmYg LS1naXQgYS9kcml2ZXJzL25ldC91c2Ivc3I5NzAwLmMgYi9kcml2ZXJzL25ldC91c2Ivc3I5NzAw LmMNCm5ldyBmaWxlIG1vZGUgMTAwNjQ0DQppbmRleCAwMDAwMDAwLi42YTY0MjlhDQotLS0gL2Rl di9udWxsDQorKysgYi9kcml2ZXJzL25ldC91c2Ivc3I5NzAwLmMNCkBAIC0wLDAgKzEsNTU3IEBA DQorLyoNCisgKiBDb3JlQ2hpcC1zeiBTUjk3MDAgb25lIGNoaXAgVVNCIDEuMSBFdGhlcm5ldCBE ZXZpY2VzDQorICoNCisgKiBBdXRob3IgOiBsaXVqbCA8bGl1anVubGlhbmdfbGpsQDE2My5jb20+ DQorICoNCisgKiBCYXNlZCBvbiBkbTk2MDEuYw0KKyAqDQorICogVGhpcyBmaWxlIGlzIGxpY2Vu c2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UNCisg KiB2ZXJzaW9uIDIuICBUaGlzIHByb2dyYW0gaXMgbGljZW5zZWQgImFzIGlzIiB3aXRob3V0IGFu eSB3YXJyYW50eSBvZiBhbnkNCisgKiBraW5kLCB3aGV0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4N CisgKi8NCisNCisvLyNkZWZpbmUgREVCVUcNCisNCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+ DQorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+DQorI2luY2x1ZGUgPGxpbnV4L3N0ZGRlZi5oPg0K KyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+DQorI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPg0K KyNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5oPg0KKyNpbmNsdWRlIDxsaW51eC9ldGh0b29s Lmg+DQorI2luY2x1ZGUgPGxpbnV4L21paS5oPg0KKyNpbmNsdWRlIDxsaW51eC91c2IuaD4NCisj aW5jbHVkZSA8bGludXgvY3JjMzIuaD4NCisjaW5jbHVkZSA8bGludXgvdXNiL3VzYm5ldC5oPg0K Kw0KKyNpbmNsdWRlICJzcjk3MDAuaCINCisNCitzdGF0aWMgaW50IHNyX3JlYWQoc3RydWN0IHVz Ym5ldCAqZGV2LCB1OCByZWcsIHUxNiBsZW5ndGgsIHZvaWQgKmRhdGEpDQorew0KKwlpbnQgZXJy Ow0KKw0KKwllcnIgPSB1c2JuZXRfcmVhZF9jbWQoZGV2LCBTUl9SRF9SRUdTLCBTUl9SRVFfUkRf UkVHLA0KKwkJCQkJMCwgcmVnLCBkYXRhLCBsZW5ndGgpOw0KKwlpZihlcnIgIT0gbGVuZ3RoICYm IGVyciA+PSAwKQ0KKwkJZXJyID0gLUVJTlZBTDsNCisJcmV0dXJuIGVycjsNCit9DQorDQorc3Rh dGljIGludCBzcl93cml0ZShzdHJ1Y3QgdXNibmV0ICpkZXYsIHU4IHJlZywgdTE2IGxlbmd0aCwg dm9pZCAqZGF0YSkNCit7DQorCWludCBlcnI7DQorDQorCWVyciA9IHVzYm5ldF93cml0ZV9jbWQo ZGV2LCBTUl9XUl9SRUdTLCBTUl9SRVFfV1JfUkVHLA0KKwkJCQkJMCwgcmVnLCBkYXRhLCBsZW5n dGgpOw0KKwlpZiAoZXJyID49IDAgJiYgZXJyIDwgbGVuZ3RoKQ0KKwkJZXJyID0gLUVJTlZBTDsN CisJDQorCXJldHVybiBlcnI7DQorfQ0KKw0KK3N0YXRpYyBpbnQgc3JfcmVhZF9yZWcoc3RydWN0 IHVzYm5ldCAqZGV2LCB1OCByZWcsIHU4ICp2YWx1ZSkNCit7DQorCXJldHVybiBzcl9yZWFkKGRl diwgcmVnLCAxLCB2YWx1ZSk7DQorfQ0KKw0KK3N0YXRpYyBpbnQgc3Jfd3JpdGVfcmVnKHN0cnVj dCB1c2JuZXQgKmRldiwgdTggcmVnLCB1OCB2YWx1ZSkNCit7DQorCXJldHVybiB1c2JuZXRfd3Jp dGVfY21kKGRldiwgU1JfV1JfUkVHUywgU1JfUkVRX1dSX1JFRywNCisJCQkgICAgICAgdmFsdWUs IHJlZywgTlVMTCwgMCk7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIHNyX3dyaXRlX2FzeW5jKHN0cnVj dCB1c2JuZXQgKmRldiwgdTggcmVnLCB1MTYgbGVuZ3RoLCB2b2lkICpkYXRhKQ0KK3sNCisJdXNi bmV0X3dyaXRlX2NtZF9hc3luYyhkZXYsIFNSX1dSX1JFR1MsIFNSX1JFUV9XUl9SRUcsDQorCQkJ CQkwLCByZWcsIGRhdGEsIGxlbmd0aCk7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIHNyX3dyaXRlX3Jl Z19hc3luYyhzdHJ1Y3QgdXNibmV0ICpkZXYsIHU4IHJlZywgdTggdmFsdWUpDQorew0KKwl1c2Ju ZXRfd3JpdGVfY21kX2FzeW5jKGRldiwgU1JfV1JfUkVHUywgU1JfUkVRX1dSX1JFRywNCisJCQkJ CXZhbHVlLCByZWcsIE5VTEwsIDApOw0KK30NCisNCitzdGF0aWMgaW50IHNyX3NoYXJlX3JlYWRf d29yZChzdHJ1Y3QgdXNibmV0ICpkZXYsIGludCBwaHksIHU4IHJlZywgX19sZTE2ICp2YWx1ZSkN Cit7DQorCWludCByZXQsIGk7DQorDQorCW11dGV4X2xvY2soJmRldi0+cGh5X211dGV4KTsNCisN CisJc3Jfd3JpdGVfcmVnKGRldiwgRVBBUiwgcGh5ID8gKHJlZyB8IDB4NDApIDogcmVnKTsNCisJ c3Jfd3JpdGVfcmVnKGRldiwgRVBDUiwgcGh5ID8gMHhjIDogMHg0KTsNCisNCisJZm9yIChpID0g MDsgaSA8IFNSX1NIQVJFX1RJTUVPVVQ7IGkrKykgew0KKwkJdTggdG1wID0gMDsNCisNCisJCXVk ZWxheSgxKTsNCisJCXJldCA9IHNyX3JlYWRfcmVnKGRldiwgRVBDUiwgJnRtcCk7DQorCQlpZiAo cmV0IDwgMCkNCisJCQlnb3RvIG91dDsNCisNCisJCS8qIHJlYWR5ICovDQorCQlpZiAoKHRtcCAm IDEpID09IDApDQorCQkJYnJlYWs7DQorCX0NCisNCisJaWYgKGkgPj0gU1JfU0hBUkVfVElNRU9V VCkgew0KKwkJbmV0ZGV2X2VycihkZXYtPm5ldCwgIiVzIHJlYWQgdGltZWQgb3V0ISIsIHBoeSA/ ICJwaHkiIDogImVlcHJvbSIpOw0KKwkJcmV0ID0gLUVJTzsNCisJCWdvdG8gb3V0Ow0KKwl9DQor DQorCXNyX3dyaXRlX3JlZyhkZXYsIEVQQ1IsIDB4MCk7DQorCXJldCA9IHNyX3JlYWQoZGV2LCBF UERSLCAyLCB2YWx1ZSk7DQorDQorCW5ldGRldl9kYmcoZGV2LT5uZXQsICJyZWFkIHNoYXJlZCAl ZCAweCUwMnggcmV0dXJuZWQgMHglMDR4LCAlZCIsDQorCSAgICAgICBwaHksIHJlZywgKnZhbHVl LCByZXQpOw0KKw0KKyBvdXQ6DQorCW11dGV4X3VubG9jaygmZGV2LT5waHlfbXV0ZXgpOw0KKwly ZXR1cm4gcmV0Ow0KK30NCisNCitzdGF0aWMgaW50IHNyX3NoYXJlX3dyaXRlX3dvcmQoc3RydWN0 IHVzYm5ldCAqZGV2LCBpbnQgcGh5LCB1OCByZWcsIF9fbGUxNiB2YWx1ZSkNCit7DQorCWludCBy ZXQsIGk7DQorDQorCW11dGV4X2xvY2soJmRldi0+cGh5X211dGV4KTsNCisNCisJcmV0ID0gc3Jf d3JpdGUoZGV2LCBFUERSLCAyLCAmdmFsdWUpOw0KKwlpZiAocmV0IDwgMCkNCisJCWdvdG8gb3V0 Ow0KKw0KKwlzcl93cml0ZV9yZWcoZGV2LCBFUEFSLCBwaHkgPyAocmVnIHwgMHg0MCkgOiByZWcp Ow0KKwlzcl93cml0ZV9yZWcoZGV2LCBFUENSLCBwaHkgPyAweDFhIDogMHgxMik7DQorDQorCWZv ciAoaSA9IDA7IGkgPCBTUl9TSEFSRV9USU1FT1VUOyBpKyspIHsNCisJCXU4IHRtcCA9IDA7DQor DQorCQl1ZGVsYXkoMSk7DQorCQlyZXQgPSBzcl9yZWFkX3JlZyhkZXYsIEVQQ1IsICZ0bXApOw0K KwkJaWYgKHJldCA8IDApDQorCQkJZ290byBvdXQ7DQorDQorCQkvKiByZWFkeSAqLw0KKwkJaWYg KCh0bXAgJiAxKSA9PSAwKQ0KKwkJCWJyZWFrOw0KKwl9DQorDQorCWlmIChpID49IFNSX1NIQVJF X1RJTUVPVVQpIHsNCisJCW5ldGRldl9lcnIoZGV2LT5uZXQsICIlcyB3cml0ZSB0aW1lZCBvdXQh IiwgcGh5ID8gInBoeSIgOiAiZWVwcm9tIik7DQorCQlyZXQgPSAtRUlPOw0KKwkJZ290byBvdXQ7 DQorCX0NCisNCisJc3Jfd3JpdGVfcmVnKGRldiwgRVBDUiwgMHgwKTsNCisNCitvdXQ6DQorCW11 dGV4X3VubG9jaygmZGV2LT5waHlfbXV0ZXgpOw0KKwlyZXR1cm4gcmV0Ow0KK30NCisNCitzdGF0 aWMgaW50IHNyX3JlYWRfZWVwcm9tX3dvcmQoc3RydWN0IHVzYm5ldCAqZGV2LCB1OCBvZmZzZXQs IHZvaWQgKnZhbHVlKQ0KK3sNCisJcmV0dXJuIHNyX3NoYXJlX3JlYWRfd29yZChkZXYsIDAsIG9m ZnNldCwgdmFsdWUpOw0KK30NCisNCisNCitzdGF0aWMgaW50IHNyOTcwMF9nZXRfZWVwcm9tX2xl bihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQ0KK3sNCisJcmV0dXJuIFNSX0VFUFJPTV9MRU47DQor fQ0KKw0KK3N0YXRpYyBpbnQgc3I5NzAwX2dldF9lZXByb20oc3RydWN0IG5ldF9kZXZpY2UgKm5l dCwgc3RydWN0IGV0aHRvb2xfZWVwcm9tICplZXByb20sIHU4ICogZGF0YSkNCit7DQorCXN0cnVj dCB1c2JuZXQgKmRldiA9IG5ldGRldl9wcml2KG5ldCk7DQorCV9fbGUxNiAqZWJ1ZiA9IChfX2xl MTYgKikgZGF0YTsNCisJaW50IGk7DQorDQorCS8qIGFjY2VzcyBpcyAxNmJpdCAqLw0KKwlpZiAo KGVlcHJvbS0+b2Zmc2V0ICUgMikgfHwgKGVlcHJvbS0+bGVuICUgMikpDQorCQlyZXR1cm4gLUVJ TlZBTDsNCisNCisJZm9yIChpID0gMDsgaSA8IGVlcHJvbS0+bGVuIC8gMjsgaSsrKSB7DQorCQlp ZiAoc3JfcmVhZF9lZXByb21fd29yZChkZXYsIGVlcHJvbS0+b2Zmc2V0IC8gMiArIGksICZlYnVm W2ldKSA8IDApDQorCQkJcmV0dXJuIC1FSU5WQUw7DQorCX0NCisJcmV0dXJuIDA7DQorfQ0KKw0K K3N0YXRpYyBpbnQgc3JfbWRpb19yZWFkKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYsIGludCBw aHlfaWQsIGludCBsb2MpDQorew0KKwlzdHJ1Y3QgdXNibmV0ICpkZXYgPSBuZXRkZXZfcHJpdihu ZXRkZXYpOw0KKw0KKwlfX2xlMTYgcmVzOw0KKwlpbnQgcmMgPSAwOw0KKw0KKwlpZiAocGh5X2lk KSB7DQorCQluZXRkZXZfZGJnKGRldi0+bmV0LCAiT25seSBpbnRlcm5hbCBwaHkgc3VwcG9ydGVk Iik7DQorCQlyZXR1cm4gMDsNCisJfQ0KKw0KKwkvKiBBY2Nlc3MgTlNSX0xJTktTVCBiaXQgZm9y IGxpbmsgc3RhdHVzIGluc3RlYWQgb2YgTUlJX0JNU1IgKi8NCisJaWYobG9jID09IE1JSV9CTVNS KXsNCisJCQl1OCB2YWx1ZTsNCisJCQlzcl9yZWFkX3JlZyhkZXYsIE5TUiwgJnZhbHVlKTsNCisJ CQlpZih2YWx1ZSAmIE5TUl9MSU5LU1QpIHsNCisJCQkJcmMgPSAxOw0KKwkJCX0NCisJfQ0KKwlz cl9zaGFyZV9yZWFkX3dvcmQoZGV2LCAxLCBsb2MsICZyZXMpOw0KKwlpZihyYyA9PSAxKQ0KKwkJ CXJldHVybiAobGUxNl90b19jcHUocmVzKSB8IEJNU1JfTFNUQVRVUyk7DQorCWVsc2UNCisJCQly ZXR1cm4gKGxlMTZfdG9fY3B1KHJlcykgJiB+Qk1TUl9MU1RBVFVTKTsNCisNCisJbmV0ZGV2X2Ri ZyhkZXYtPm5ldCwNCisJICAgICAgICJzcl9tZGlvX3JlYWQoKSBwaHlfaWQ9MHglMDJ4LCBsb2M9 MHglMDJ4LCByZXR1cm5zPTB4JTA0eCIsDQorCSAgICAgICBwaHlfaWQsIGxvYywgbGUxNl90b19j cHUocmVzKSk7DQorDQorCXJldHVybiBsZTE2X3RvX2NwdShyZXMpOw0KK30NCisNCitzdGF0aWMg dm9pZCBzcl9tZGlvX3dyaXRlKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYsIGludCBwaHlfaWQs IGludCBsb2MsIGludCB2YWwpDQorew0KKwlzdHJ1Y3QgdXNibmV0ICpkZXYgPSBuZXRkZXZfcHJp dihuZXRkZXYpOw0KKwlfX2xlMTYgcmVzID0gY3B1X3RvX2xlMTYodmFsKTsNCisNCisJaWYgKHBo eV9pZCkgew0KKwkJbmV0ZGV2X2RiZyhkZXYtPm5ldCwgIk9ubHkgaW50ZXJuYWwgcGh5IHN1cHBv cnRlZCIpOw0KKwkJcmV0dXJuOw0KKwl9DQorDQorCW5ldGRldl9kYmcoZGV2LT5uZXQsInNyX21k aW9fd3JpdGUoKSBwaHlfaWQ9MHglMDJ4LCBsb2M9MHglMDJ4LCB2YWw9MHglMDR4IiwNCisJICAg ICAgIHBoeV9pZCwgbG9jLCB2YWwpOw0KKw0KKwlzcl9zaGFyZV93cml0ZV93b3JkKGRldiwgMSwg bG9jLCByZXMpOw0KK30NCisNCisvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0q Lw0KKw0KK3N0YXRpYyB2b2lkIHNyOTcwMF9nZXRfZHJ2aW5mbyhzdHJ1Y3QgbmV0X2RldmljZSAq bmV0LCBzdHJ1Y3QgZXRodG9vbF9kcnZpbmZvICppbmZvKQ0KK3sNCisJLyogSW5oZXJpdCBzdGFu ZGFyZCBkZXZpY2UgaW5mbyAqLw0KKwl1c2JuZXRfZ2V0X2RydmluZm8obmV0LCBpbmZvKTsNCisJ aW5mby0+ZWVkdW1wX2xlbiA9IFNSX0VFUFJPTV9MRU47DQorfQ0KKw0KK3N0YXRpYyB1MzIgc3I5 NzAwX2dldF9saW5rKHN0cnVjdCBuZXRfZGV2aWNlICpuZXQpDQorew0KKwlzdHJ1Y3QgdXNibmV0 ICpkZXYgPSBuZXRkZXZfcHJpdihuZXQpOw0KKwlpbnQgcmMgPSAwOw0KKwl1OCB2YWx1ZSA9IDA7 DQorDQorCS8qIEdldCB0aGUgTGluayBTdGF0dXMgZGlyZWN0bHkgKi8NCisJc3JfcmVhZF9yZWco ZGV2LCBOU1IsICZ2YWx1ZSk7DQorCWlmKHZhbHVlICYgTlNSX0xJTktTVCkgew0KKwkJcmMgPSAx Ow0KKwl9DQorDQorCXJldHVybiByYzsNCit9DQorDQorc3RhdGljIGludCBzcjk3MDBfaW9jdGwo c3RydWN0IG5ldF9kZXZpY2UgKm5ldCwgc3RydWN0IGlmcmVxICpycSwgaW50IGNtZCkNCit7DQor CXN0cnVjdCB1c2JuZXQgKmRldiA9IG5ldGRldl9wcml2KG5ldCk7DQorDQorCXJldHVybiBnZW5l cmljX21paV9pb2N0bCgmZGV2LT5taWksIGlmX21paShycSksIGNtZCwgTlVMTCk7DQorfQ0KKw0K K3N0YXRpYyBjb25zdCBzdHJ1Y3QgZXRodG9vbF9vcHMgc3I5NzAwX2V0aHRvb2xfb3BzID0gew0K KwkuZ2V0X2RydmluZm8JPSBzcjk3MDBfZ2V0X2RydmluZm8sDQorCS5nZXRfbGluawk9IHNyOTcw MF9nZXRfbGluaywNCisJLmdldF9tc2dsZXZlbAk9IHVzYm5ldF9nZXRfbXNnbGV2ZWwsDQorCS5z ZXRfbXNnbGV2ZWwJPSB1c2JuZXRfc2V0X21zZ2xldmVsLA0KKwkuZ2V0X2VlcHJvbV9sZW4JPSBz cjk3MDBfZ2V0X2VlcHJvbV9sZW4sDQorCS5nZXRfZWVwcm9tCT0gc3I5NzAwX2dldF9lZXByb20s DQorCS5nZXRfc2V0dGluZ3MJPSB1c2JuZXRfZ2V0X3NldHRpbmdzLA0KKwkuc2V0X3NldHRpbmdz CT0gdXNibmV0X3NldF9zZXR0aW5ncywNCisJLm53YXlfcmVzZXQJPSB1c2JuZXRfbndheV9yZXNl dCwNCit9Ow0KKw0KK3N0YXRpYyB2b2lkIHNyOTcwMF9zZXRfbXVsdGljYXN0KHN0cnVjdCBuZXRf ZGV2aWNlICpuZXQpDQorew0KKwlzdHJ1Y3QgdXNibmV0ICpkZXYgPSBuZXRkZXZfcHJpdihuZXQp Ow0KKwkvKiBXZSB1c2UgdGhlIDIwIGJ5dGUgZGV2LT5kYXRhIGZvciBvdXIgOCBieXRlIGZpbHRl ciBidWZmZXINCisJICogdG8gYXZvaWQgYWxsb2NhdGluZyBtZW1vcnkgdGhhdCBpcyB0cmlja3kg dG8gZnJlZSBsYXRlciAqLw0KKwl1OCAqaGFzaGVzID0gKHU4ICopICYgZGV2LT5kYXRhOw0KKwl1 OCByeF9jdGwgPSAweDMxOwkvLyBlbmFibGUsIGRpc2FibGVfbG9uZywgZGlzYWJsZV9jcmMNCisN CisJbWVtc2V0KGhhc2hlcywgMHgwMCwgU1JfTUNBU1RfU0laRSk7DQorCWhhc2hlc1tTUl9NQ0FT VF9TSVpFIC0gMV0gfD0gMHg4MDsJLyogYnJvYWRjYXN0IGFkZHJlc3MgKi8NCisNCisgICAgICAg IGlmIChuZXQtPmZsYWdzICYgSUZGX1BST01JU0MpIHsNCisgICAgICAgICAgICAgICAgcnhfY3Rs IHw9IDB4MDI7DQorICAgICAgICB9IGVsc2UgaWYgKG5ldC0+ZmxhZ3MgJiBJRkZfQUxMTVVMVEkg fHwNCisgICAgICAgICAgICAgICAgICAgbmV0ZGV2X21jX2NvdW50KG5ldCkgPiBTUl9NQ0FTVF9N QVgpIHsNCisgICAgICAgICAgICAgICAgcnhfY3RsIHw9IDB4MDQ7DQorICAgICAgICB9IGVsc2Ug aWYgKCFuZXRkZXZfbWNfZW1wdHkobmV0KSkgew0KKyAgICAgICAgICAgICAgICBzdHJ1Y3QgbmV0 ZGV2X2h3X2FkZHIgKmhhOw0KKyANCisgICAgICAgICAgICAgICAgbmV0ZGV2X2Zvcl9lYWNoX21j X2FkZHIoaGEsIG5ldCkgew0KKyAgICAgICAgICAgICAgICAgICAgICAgIHUzMiBjcmMgPSBldGhl cl9jcmMoRVRIX0FMRU4sIGhhLT5hZGRyKSA+PiAyNjsNCisgICAgICAgICAgICAgICAgICAgICAg ICBoYXNoZXNbY3JjID4+IDNdIHw9IDEgPDwgKGNyYyAmIDB4Nyk7DQorICAgICAgICAgICAgICAg IH0NCisgICAgICAgIH0NCisNCisJc3Jfd3JpdGVfYXN5bmMoZGV2LCBNQVIsIFNSX01DQVNUX1NJ WkUsIGhhc2hlcyk7DQorCXNyX3dyaXRlX3JlZ19hc3luYyhkZXYsIFJDUiwgcnhfY3RsKTsNCit9 DQorDQorc3RhdGljIGludCBzcjk3MDBfc2V0X21hY19hZGRyZXNzKHN0cnVjdCBuZXRfZGV2aWNl ICpuZXQsIHZvaWQgKnApDQorew0KKwlzdHJ1Y3Qgc29ja2FkZHIgKmFkZHIgPSBwOw0KKwlzdHJ1 Y3QgdXNibmV0ICpkZXYgPSBuZXRkZXZfcHJpdihuZXQpOw0KKw0KKwlpZiAoIWlzX3ZhbGlkX2V0 aGVyX2FkZHIoYWRkci0+c2FfZGF0YSkpIHsNCisJCWRldl9lcnIoJm5ldC0+ZGV2LCAibm90IHNl dHRpbmcgaW52YWxpZCBtYWMgYWRkcmVzcyAlcE1cbiIsDQorCQkJCQkJCQlhZGRyLT5zYV9kYXRh KTsNCisJCXJldHVybiAtRUlOVkFMOw0KKwl9DQorDQorCW1lbWNweShuZXQtPmRldl9hZGRyLCBh ZGRyLT5zYV9kYXRhLCBuZXQtPmFkZHJfbGVuKTsNCisJc3Jfd3JpdGVfYXN5bmMoZGV2LCBQQVIs IDYsIGRldi0+bmV0LT5kZXZfYWRkcik7DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMg Y29uc3Qgc3RydWN0IG5ldF9kZXZpY2Vfb3BzIHNyOTcwMF9uZXRkZXZfb3BzID0gew0KKwkubmRv X29wZW4JCT0gdXNibmV0X29wZW4sDQorCS5uZG9fc3RvcAkJPSB1c2JuZXRfc3RvcCwNCisJLm5k b19zdGFydF94bWl0CQk9IHVzYm5ldF9zdGFydF94bWl0LA0KKwkubmRvX3R4X3RpbWVvdXQJCT0g dXNibmV0X3R4X3RpbWVvdXQsDQorCS5uZG9fY2hhbmdlX210dQkJPSB1c2JuZXRfY2hhbmdlX210 dSwNCisJLm5kb192YWxpZGF0ZV9hZGRyCT0gZXRoX3ZhbGlkYXRlX2FkZHIsDQorCS5uZG9fZG9f aW9jdGwgCQk9IHNyOTcwMF9pb2N0bCwNCisJLm5kb19zZXRfcnhfbW9kZQk9IHNyOTcwMF9zZXRf bXVsdGljYXN0LA0KKwkubmRvX3NldF9tYWNfYWRkcmVzcwk9IHNyOTcwMF9zZXRfbWFjX2FkZHJl c3MsDQorfTsNCisNCitzdGF0aWMgaW50IHNyOTcwMF9iaW5kKHN0cnVjdCB1c2JuZXQgKmRldiwg c3RydWN0IHVzYl9pbnRlcmZhY2UgKmludGYpDQorew0KKwlpbnQgcmV0Ow0KKw0KKwlyZXQgPSB1 c2JuZXRfZ2V0X2VuZHBvaW50cyhkZXYsIGludGYpOw0KKwlpZiAocmV0KQ0KKwkJZ290byBvdXQ7 DQorDQorCWRldi0+bmV0LT5uZXRkZXZfb3BzID0gJnNyOTcwMF9uZXRkZXZfb3BzOw0KKwlkZXYt Pm5ldC0+ZXRodG9vbF9vcHMgPSAmc3I5NzAwX2V0aHRvb2xfb3BzOw0KKwlkZXYtPm5ldC0+aGFy ZF9oZWFkZXJfbGVuICs9IFNSX1RYX09WRVJIRUFEOw0KKwlkZXYtPmhhcmRfbXR1ID0gZGV2LT5u ZXQtPm10dSArIGRldi0+bmV0LT5oYXJkX2hlYWRlcl9sZW47DQorCWRldi0+cnhfdXJiX3NpemUg PSAzMDcyOwkvLyBidWxraW4gYnVmZmVyIGlzIHByZWZlcmFibHkgbm90IGxlc3MgdGhhbiAzSw0K Kw0KKwlkZXYtPm1paS5kZXYgPSBkZXYtPm5ldDsNCisJZGV2LT5taWkubWRpb19yZWFkID0gc3Jf bWRpb19yZWFkOw0KKwlkZXYtPm1paS5tZGlvX3dyaXRlID0gc3JfbWRpb193cml0ZTsNCisJZGV2 LT5taWkucGh5X2lkX21hc2sgPSAweDFmOw0KKwlkZXYtPm1paS5yZWdfbnVtX21hc2sgPSAweDFm Ow0KKw0KKwkvKiByZXNldCB0aGUgc3I5NzAwICovDQorCXNyX3dyaXRlX3JlZyhkZXYsIE5DUiwg MSk7DQorCXVkZWxheSgyMCk7DQorDQorCS8qIHJlYWQgTUFDICovDQorCWlmIChzcl9yZWFkKGRl diwgUEFSLCBFVEhfQUxFTiwgZGV2LT5uZXQtPmRldl9hZGRyKSA8IDApIHsNCisJCXByaW50ayhL RVJOX0VSUiAiRXJyb3IgcmVhZGluZyBNQUMgYWRkcmVzc1xuIik7DQorCQlyZXQgPSAtRU5PREVW Ow0KKwkJZ290byBvdXQ7DQorCX0NCisNCisJLyogcG93ZXIgdXAgYW5kIHJlc2V0IHBoeSAqLw0K Kwlzcl93cml0ZV9yZWcoZGV2LCBQUlIsIDEpOw0KKwltZGVsYXkoMjApOwkJLy8gYXQgbGVhc3Qg MTBtcywgaGVyZSAyMG1zIGZvciBzYWZlDQorCXNyX3dyaXRlX3JlZyhkZXYsIFBSUiwgMCk7DQor CXVkZWxheSgyICogMTAwMCk7CS8vIGF0IGxlYXN0IDFtcywgaGVyZSAybXMgZm9yIHJlYWRpbmcg cmlnaHQgcmVnaXN0ZXINCisNCisJLyogcmVjZWl2ZSBicm9hZGNhc3QgcGFja2V0cyAqLw0KKwlz cjk3MDBfc2V0X211bHRpY2FzdChkZXYtPm5ldCk7DQorDQorCXNyX21kaW9fd3JpdGUoZGV2LT5u ZXQsIGRldi0+bWlpLnBoeV9pZCwgTUlJX0JNQ1IsIEJNQ1JfUkVTRVQpOw0KKwlzcl9tZGlvX3dy aXRlKGRldi0+bmV0LCBkZXYtPm1paS5waHlfaWQsIE1JSV9BRFZFUlRJU0UsIEFEVkVSVElTRV9B TEwgfCBBRFZFUlRJU0VfQ1NNQSB8IEFEVkVSVElTRV9QQVVTRV9DQVApOw0KKwltaWlfbndheV9y ZXN0YXJ0KCZkZXYtPm1paSk7DQorDQorb3V0Og0KKwlyZXR1cm4gcmV0Ow0KK30NCisNCitzdGF0 aWMgaW50IHNyOTcwMF9yeF9maXh1cChzdHJ1Y3QgdXNibmV0ICpkZXYsIHN0cnVjdCBza19idWZm ICpza2IpDQorew0KKwlpbnQgbGVuOw0KKwlzdHJ1Y3Qgc2tfYnVmZiAqc3Jfc2tiOw0KKw0KKwkv KiBmb3JtYXQ6DQorCSAgIGIwOiByeCBzdGF0dXMNCisJICAgYjE6IHBhY2tldCBsZW5ndGggKGlu Y2wgY3JjKSBsb3cNCisJICAgYjI6IHBhY2tldCBsZW5ndGggKGluY2wgY3JjKSBoaWdoDQorCSAg IGIzLi5uLTQ6IHBhY2tldCBkYXRhDQorCSAgIGJuLTMuLmJuOiBldGhlcm5ldCBjcmMNCisJICov DQorDQorCWlmICh1bmxpa2VseShza2ItPmxlbiA8IFNSX1JYX09WRVJIRUFEKSkgew0KKwkJZGV2 X2VycigmZGV2LT51ZGV2LT5kZXYsICJ1bmV4cGVjdGVkIHRpbnkgcnggZnJhbWVcbiIpOw0KKwkJ cmV0dXJuIDA7DQorCX0NCisNCisJLyoNCisJICogRWFjaCBwYWNrZXQgY29udGFpbnMgbXVsdGlw bGUgc2ticw0KKwkgKi8NCisJd2hpbGUgKHNrYi0+bGVuID4gU1JfUlhfT1ZFUkhFQUQpDQorCXsN CisJCWlmIChza2ItPmRhdGFbMF0gIT0gMHg0MCkNCisJCXsNCisJCQlyZXR1cm4gMDsNCisJCX0N CisNCisJCS8qIGlnbm9yZSB0aGUgQ1JDIGxlbmd0aCAqLw0KKwkJbGVuID0gKHNrYi0+ZGF0YVsx XSB8IChza2ItPmRhdGFbMl0gPDwgOCkpIC0gNDsNCisNCisJCWlmIChsZW4gPiBFVEhfRlJBTUVf TEVOKQ0KKwkJew0KKwkJCXJldHVybiAwOw0KKwkJfQ0KKw0KKwkJLyogdGhlIGxhc3Qgc2tiIG9m IGN1cnJlbnQgcGFja2V0ICovDQorCQlpZiAoc2tiLT5sZW4gPT0gKGxlbiArIFNSX1JYX09WRVJI RUFEKSkNCisJCXsNCisJCQlza2JfcHVsbCggc2tiLCAzICk7DQorCQkJc2tiLT5sZW4gPSBsZW47 DQorCQkJc2tiLT50YWlsID0gc2tiLT5kYXRhICsgbGVuOw0KKwkJCXNrYi0+dHJ1ZXNpemUgPSBs ZW4gKyBzaXplb2Yoc3RydWN0IHNrX2J1ZmYpOw0KKwkJCXJldHVybiAyOw0KKwkJfQ0KKw0KKwkJ Lyogc2tiX2Nsb25lIGlzIHVzZWQgZm9yIGFkZHJlc3MgYWxpZ24gKi8NCisJCXNyX3NrYiA9IHNr Yl9jbG9uZShza2IsIEdGUF9BVE9NSUMpOw0KKwkJaWYgKHNyX3NrYikgDQorCQl7DQorCQkJc3Jf c2tiLT5sZW4gPSBsZW47DQorCQkJc3Jfc2tiLT5kYXRhID0gc2tiLT5kYXRhICsgMzsNCisJCQlz cl9za2ItPnRhaWwgPSBza2ItPmRhdGEgKyBsZW47DQorCQkJc3Jfc2tiLT50cnVlc2l6ZSA9IGxl biArIHNpemVvZihzdHJ1Y3Qgc2tfYnVmZik7DQorCQkJdXNibmV0X3NrYl9yZXR1cm4oZGV2LCBz cl9za2IpOwkNCisJCX0NCisJCWVsc2UNCisJCXsNCisJCQlyZXR1cm4gMDsNCisJCX0NCisNCisJ CXNrYl9wdWxsKCBza2IsIGxlbiArIFNSX1JYX09WRVJIRUFEICk7DQorCX07DQorCQ0KKwlyZXR1 cm4gMDsNCit9DQorDQorc3RhdGljIHN0cnVjdCBza19idWZmICpzcjk3MDBfdHhfZml4dXAoc3Ry dWN0IHVzYm5ldCAqZGV2LCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBnZnBfdCBmbGFncykNCit7DQor CWludCBsZW47DQorDQorCS8qIGZvcm1hdDoNCisJICAgYjA6IHBhY2tldCBsZW5ndGggbG93DQor CSAgIGIxOiBwYWNrZXQgbGVuZ3RoIGhpZ2gNCisJICAgYjMuLm46IHBhY2tldCBkYXRhDQorCSov DQorDQorCWxlbiA9IHNrYi0+bGVuOw0KKw0KKwlpZiAoc2tiX2hlYWRyb29tKHNrYikgPCBTUl9U WF9PVkVSSEVBRCkgew0KKwkJc3RydWN0IHNrX2J1ZmYgKnNrYjI7DQorDQorCQlza2IyID0gc2ti X2NvcHlfZXhwYW5kKHNrYiwgU1JfVFhfT1ZFUkhFQUQsIDAsIGZsYWdzKTsNCisJCWRldl9rZnJl ZV9za2JfYW55KHNrYik7DQorCQlza2IgPSBza2IyOw0KKwkJaWYgKCFza2IpDQorCQkJcmV0dXJu IE5VTEw7DQorCX0NCisNCisJX19za2JfcHVzaChza2IsIFNSX1RYX09WRVJIRUFEKTsNCisNCisJ LyogdXNibmV0IGFkZHMgcGFkZGluZyBpZiBsZW5ndGggaXMgYSBtdWx0aXBsZSBvZiBwYWNrZXQg c2l6ZQ0KKwkgICBpZiBzbywgYWRqdXN0IGxlbmd0aCB2YWx1ZSBpbiBoZWFkZXIgKi8NCisJaWYg KChza2ItPmxlbiAlIGRldi0+bWF4cGFja2V0KSA9PSAwKQ0KKwkJbGVuKys7DQorDQorCXNrYi0+ ZGF0YVswXSA9IGxlbjsNCisJc2tiLT5kYXRhWzFdID0gbGVuID4+IDg7DQorDQorCXJldHVybiBz a2I7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIHNyOTcwMF9zdGF0dXMoc3RydWN0IHVzYm5ldCAqZGV2 LCBzdHJ1Y3QgdXJiICp1cmIpDQorew0KKwlpbnQgbGluazsNCisJdTggKmJ1ZjsNCisNCisJLyog Zm9ybWF0Og0KKwkgICBiMDogbmV0IHN0YXR1cw0KKwkgICBiMTogdHggc3RhdHVzIDENCisJICAg YjI6IHR4IHN0YXR1cyAyDQorCSAgIGIzOiByeCBzdGF0dXMNCisJICAgYjQ6IHJ4IG92ZXJmbG93 DQorCSAgIGI1OiByeCBjb3VudA0KKwkgICBiNjogdHggY291bnQNCisJICAgYjc6IGdwcg0KKwkq Lw0KKw0KKwlpZiAodXJiLT5hY3R1YWxfbGVuZ3RoIDwgOCkNCisJCXJldHVybjsNCisNCisJYnVm ID0gdXJiLT50cmFuc2Zlcl9idWZmZXI7DQorDQorCWxpbmsgPSAhIShidWZbMF0gJiAweDQwKTsN CisJaWYgKG5ldGlmX2NhcnJpZXJfb2soZGV2LT5uZXQpICE9IGxpbmspIHsNCisJCXVzYm5ldF9s aW5rX2NoYW5nZShkZXYsIGxpbmssIDEpOw0KKwkJbmV0ZGV2X2RiZyhkZXYtPm5ldCwgIkxpbmsg U3RhdHVzIGlzOiAlZCIsIGxpbmspOw0KKwl9DQorfQ0KKw0KK3N0YXRpYyBpbnQgc3I5NzAwX2xp bmtfcmVzZXQoc3RydWN0IHVzYm5ldCAqZGV2KQ0KK3sNCisJc3RydWN0IGV0aHRvb2xfY21kIGVj bWQ7DQorDQorCW1paV9jaGVja19tZWRpYSgmZGV2LT5taWksIDEsIDEpOw0KKwltaWlfZXRodG9v bF9nc2V0KCZkZXYtPm1paSwgJmVjbWQpOw0KKw0KKwluZXRkZXZfZGJnKGRldi0+bmV0LCAibGlu a19yZXNldCgpIHNwZWVkOiAlZCBkdXBsZXg6ICVkIiwNCisJICAgICAgIGVjbWQuc3BlZWQsIGVj bWQuZHVwbGV4KTsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3Qg ZHJpdmVyX2luZm8gc3I5NzAwX2RyaXZlcl9pbmZvID0gew0KKwkuZGVzY3JpcHRpb24JPSAiQ29y ZUNoaXAgU1I5NzAwIFVTQiBFdGhlcm5ldCIsDQorCS5mbGFncwkJPSBGTEFHX0VUSEVSLA0KKwku YmluZAkJPSBzcjk3MDBfYmluZCwNCisJLnJ4X2ZpeHVwCT0gc3I5NzAwX3J4X2ZpeHVwLA0KKwku dHhfZml4dXAJPSBzcjk3MDBfdHhfZml4dXAsDQorCS5zdGF0dXMJCT0gc3I5NzAwX3N0YXR1cywN CisJLmxpbmtfcmVzZXQJPSBzcjk3MDBfbGlua19yZXNldCwNCisJLnJlc2V0CQk9IHNyOTcwMF9s aW5rX3Jlc2V0LA0KK307DQorDQorc3RhdGljIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkIHBy b2R1Y3RzW10gPSB7DQorCXsNCisJIFVTQl9ERVZJQ0UoMHgwZmU2LCAweDk3MDApLAkvKiBTUjk3 MDAgZGV2aWNlICovDQorCSAuZHJpdmVyX2luZm8gPSAodW5zaWduZWQgbG9uZykmc3I5NzAwX2Ry aXZlcl9pbmZvLA0KKwkgfSwNCisJe30sCQkJLy8gRU5EDQorfTsNCisNCitNT0RVTEVfREVWSUNF X1RBQkxFKHVzYiwgcHJvZHVjdHMpOw0KKw0KK3N0YXRpYyBzdHJ1Y3QgdXNiX2RyaXZlciBzcjk3 MDBfdXNiX2RyaXZlciA9IHsNCisJLm5hbWUgPSAic3I5NzAwIiwNCisJLmlkX3RhYmxlID0gcHJv ZHVjdHMsDQorCS5wcm9iZSA9IHVzYm5ldF9wcm9iZSwNCisJLmRpc2Nvbm5lY3QgPSB1c2JuZXRf ZGlzY29ubmVjdCwNCisJLnN1c3BlbmQgPSB1c2JuZXRfc3VzcGVuZCwNCisJLnJlc3VtZSA9IHVz Ym5ldF9yZXN1bWUsDQorCS5kaXNhYmxlX2h1Yl9pbml0aWF0ZWRfbHBtID0gMSwNCit9Ow0KKw0K K21vZHVsZV91c2JfZHJpdmVyKHNyOTcwMF91c2JfZHJpdmVyKTsNCisNCitNT0RVTEVfQVVUSE9S KCJsaXVqbCA8bGl1anVubGlhbmdfbGpsQDE2My5jb20+Iik7DQorTU9EVUxFX0RFU0NSSVBUSU9O KCJTUjk3MDAgb25lIGNoaXAgVVNCIDEuMSBVU0IgdG8gRXRoZXJuZXQgZGV2aWNlIGZyb20gaHR0 cDovL3d3dy5jb3JlY2hpcC1zei5jb20vIik7DQorTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOw0KZGlm ZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3VzYi9zcjk3MDAuaCBiL2RyaXZlcnMvbmV0L3VzYi9zcjk3 MDAuaA0KbmV3IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAwMDAwMDAuLmQ5ZmU4MmQNCi0tLSAv ZGV2L251bGwNCisrKyBiL2RyaXZlcnMvbmV0L3VzYi9zcjk3MDAuaA0KQEAgLTAsMCArMSwxNTIg QEANCisvKg0KKyAqIENvcmVDaGlwLXN6IFNSOTcwMCBvbmUgY2hpcCBVU0IgMS4xIEV0aGVybmV0 IERldmljZXMNCisgKg0KKyAqIEF1dGhvciA6IGxpdWpsIDxsaXVqdW5saWFuZ19samxAMTYzLmNv bT4NCisgKg0KKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3INCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH TlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQ0KKyAqIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQgYnkg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCisgKi8NCisNCisvKiBzcjk3MDAgc3BlYy4g cmVnaXN0ZXIgdGFibGUgb24gYW5kcm9pZCBwbGF0Zm9ybSAqLw0KKy8qIFJlZ2lzdGVycyAqLw0K KyNkZWZpbmUJTkNSCQkJMHgwMA0KKyNkZWZpbmUJTlNSCQkJMHgwMQ0KKyNkZWZpbmUJVENSCQkJ MHgwMg0KKyNkZWZpbmUJVFNSMQkJMHgwMw0KKyNkZWZpbmUJVFNSMgkJMHgwNA0KKyNkZWZpbmUJ UkNSCQkJMHgwNQ0KKyNkZWZpbmUJUlNSCQkJMHgwNg0KKyNkZWZpbmUJUk9DUgkJMHgwNw0KKyNk ZWZpbmUJQlBUUgkJMHgwOA0KKyNkZWZpbmUJRkNUUgkJMHgwOQ0KKyNkZWZpbmUJRkNSCQkJMHgw QQ0KKyNkZWZpbmUJRVBDUgkJMHgwQg0KKyNkZWZpbmUJRVBBUgkJMHgwQw0KKyNkZWZpbmUJRVBE UgkJMHgwRAkvLyAweDBEIH4gMHgwRQ0KKyNkZWZpbmUJV0NSCQkJMHgwRg0KKyNkZWZpbmUJUEFS CQkJMHgxMA0KKyNkZWZpbmUJTUFSCQkJMHgxNg0KKyNkZWZpbmUJUFJSCQkJMHgxRg0KKyNkZWZp bmUJVFdQQUwJCTB4MjANCisjZGVmaW5lCVRXUEFICQkweDIxDQorI2RlZmluZQlUUlBBTAkJMHgy Mg0KKyNkZWZpbmUJVFJQQUgJCTB4MjMNCisjZGVmaW5lCVJXUEFMCQkweDI0DQorI2RlZmluZQlS V1BBSAkJMHgyNQ0KKyNkZWZpbmUJUlJQQUwJCTB4MjYNCisjZGVmaW5lCVJSUEFICQkweDI3DQor I2RlZmluZQlWSUQJCQkweDI4DQorI2RlZmluZQlQSUQJCQkweDJBDQorI2RlZmluZQlDSElQUgkJ MHgyQw0KKyNkZWZpbmUJVVNCREEJCTB4RjANCisjZGVmaW5lCVJYQwkJCTB4RjENCisjZGVmaW5l CVRYQ19VU0JTCTB4RjINCisjZGVmaW5lCVVTQkMJCTB4RjQNCisNCisvKiBCaXQgZGVmaW5pdGlv biBmb3IgcmVnaXN0ZXJzICovDQorLy8gTmV0d29yayBDb250cm9sIFJlZw0KKyNkZWZpbmUJTkNS X1JTVAkJCSgxIDw8IDApDQorI2RlZmluZQlOQ1JfTEJLCQkJKDMgPDwgMSkNCisjZGVmaW5lCU5D Ul9GRFgJCQkoMSA8PCAzKQ0KKyNkZWZpbmUJTkNSX1dBS0VFTgkJKDEgPDwgNikNCisvLyBOZXR3 b3JrIFN0YXR1cyBSZWcNCisjZGVmaW5lCU5TUl9SWFJEWQkoMSA8PCAwKQ0KKyNkZWZpbmUJTlNS X1JYT1YJKDEgPDwgMSkNCisjZGVmaW5lCU5TUl9UWDFFTkQJKDEgPDwgMikNCisjZGVmaW5lCU5T Ul9UWDJFTkQJKDEgPDwgMykNCisjZGVmaW5lCU5TUl9UWEZVTEwJKDEgPDwgNCkNCisjZGVmaW5l CU5TUl9XQUtFU1QJKDEgPDwgNSkNCisjZGVmaW5lCU5TUl9MSU5LU1QJKDEgPDwgNikNCisjZGVm aW5lCU5TUl9TUEVFRAkoMSA8PCA3KQ0KKy8vIFR4IENvbnRyb2wgUmVnDQorI2RlZmluZQlUQ1Jf Q1JDX0RJUwkJKDEgPDwgMSkNCisjZGVmaW5lCVRDUl9QQURfRElTCQkoMSA8PCAyKQ0KKyNkZWZp bmUJVENSX0xDX0NBUkUJCSgxIDw8IDMpDQorI2RlZmluZQlUQ1JfQ1JTX0NBUkUJKDEgPDwgNCkN CisjZGVmaW5lCVRDUl9FWENFQ00JCSgxIDw8IDUpDQorI2RlZmluZQlUQ1JfTEZfRU4JCSgxIDw8 IDYpDQorLy8gVHggU3RhdHVzIFJlZyBmb3IgUGFja2V0IDENCisjZGVmaW5lCVRTUjFfRUMJCSgx IDw8IDIpDQorI2RlZmluZQlUU1IxX0NPTAkoMSA8PCAzKQ0KKyNkZWZpbmUJVFNSMV9MQwkJKDEg PDwgNCkNCisjZGVmaW5lCVRTUjFfTkMJCSgxIDw8IDUpDQorI2RlZmluZQlUU1IxX0xPQwkJKDEg PDwgNikNCisjZGVmaW5lCVRTUjFfVExGCSgxIDw8IDcpDQorLy8gVHggU3RhdHVzIFJlZyBmb3Ig UGFja2V0IDINCisjZGVmaW5lCVRTUjJfRUMJCSgxIDw8IDIpDQorI2RlZmluZQlUU1IyX0NPTAko MSA8PCAzKQ0KKyNkZWZpbmUJVFNSMl9MQwkJKDEgPDwgNCkNCisjZGVmaW5lCVRTUjJfTkMJCSgx IDw8IDUpDQorI2RlZmluZQlUU1IyX0xPQwkJKDEgPDwgNikNCisjZGVmaW5lCVRTUjJfVExGCSgx IDw8IDcpDQorLy8gUnggQ29udHJvbCBSZWcNCisjZGVmaW5lCVJDUl9SWEVOCQkoMSA8PCAwKQ0K KyNkZWZpbmUJUkNSX1BSTVNDCQkoMSA8PCAxKQ0KKyNkZWZpbmUJUkNSX1JVTlQJCSgxIDw8IDIp DQorI2RlZmluZQlSQ1JfQUxMCQkJKDEgPDwgMykNCisjZGVmaW5lCVJDUl9ESVNfQ1JDCQkoMSA8 PCA0KQ0KKyNkZWZpbmUJUkNSX0RJU19MT05HCSgxIDw8IDUpDQorLy8gUnggU3RhdHVzIFJlZw0K KyNkZWZpbmUJUlNSX0FFCQkoMSA8PCAyKQ0KKyNkZWZpbmUJUlNSX01GCQkoMSA8PCA2KQ0KKyNk ZWZpbmUJUlNSX1JGCQkoMSA8PCA3KQ0KKy8vIFJlY3YgT3ZlcmZsb3cgQ291bnRlciBSZWcNCisj ZGVmaW5lCVJPQ1JfUk9DCQkoMHg3RiA8PCAwKQ0KKyNkZWZpbmUJUk9DUl9SWEZVCQkoMSA8PCA3 KQ0KKy8vIEJhY2sgUHJlc3N1cmUgVGhyZXNob2xkIFJlZw0KKyNkZWZpbmUJQlBUUl9KUFQJKDB4 MEYgPDwgMCkNCisjZGVmaW5lCUJQVFJfQlBIVwkoMHgwRiA8PCA0KQ0KKy8vIEZsb3cgQ29udHJv bCBUaHJlc2hvbGQgUmVnDQorI2RlZmluZQlGQ1RSX0xXT1QJCSgweDBGIDw8IDApDQorI2RlZmlu ZQlGQ1RSX0hXT1QJCSgweDBGIDw8IDQpDQorLy8gcngvdHggRmxvdyBDb250cm9sIFJlZw0KKyNk ZWZpbmUJRkNSX0ZMQ0UJKDEgPDwgMCkNCisjZGVmaW5lCUZDUl9CS1BBCSgxIDw8IDQpDQorI2Rl ZmluZQlGQ1JfVFhQRU4JKDEgPDwgNSkNCisjZGVmaW5lCUZDUl9UWFBGCSgxIDw8IDYpDQorI2Rl ZmluZQlGQ1JfVFhQMAkoMSA8PCA3KQ0KKy8vIEVFUFJPTSAmIFBIWSBDb250cm9sIFJlZw0KKyNk ZWZpbmUJRVBDUl9FUlJFCQkoMSA8PCAwKQ0KKyNkZWZpbmUJRVBDUl9FUlBSVwkJKDEgPDwgMSkN CisjZGVmaW5lCUVQQ1JfRVJQUlIJCSgxIDw8IDIpDQorI2RlZmluZQlFUENSX0VQT1MJCSgxIDw8 IDMpDQorI2RlZmluZQlFUENSX1dFUAkJKDEgPDwgNCkNCisvLyBFRVBST00gJiBQSFkgQWRkcmVz cyBSZWcNCisjZGVmaW5lCUVQQVJfRVJPQQkJKDB4M0YgPDwgMCkNCisjZGVmaW5lCUVQQVJfUEhZ X0FEUgkoMHgwMyA8PCA2KQ0KKy8vIFdha2V1cCBDb250cm9sIFJlZw0KKyNkZWZpbmUJV0NSX01B R0lDU1QJCSgxIDw8IDApDQorI2RlZmluZQlXQ1JfTElOS1NUCQkoMSA8PCAyKQ0KKyNkZWZpbmUJ V0NSX01BR0lDRU4JCSgxIDw8IDMpDQorI2RlZmluZQlXQ1JfTElOS0VOCQkoMSA8PCA1KQ0KKy8v IFBoeSBSZXNldCBSZWcNCisjZGVmaW5lCVBSUl9QSFlfUlNUCQkoMSA8PCAwKQ0KKy8vIFVTQiBE ZXZpY2UgQWRkcmVzcyBSZWcNCisjZGVmaW5lCVVTQkRBX1VTQkZBCSgweDdGIDw8IDApDQorLy8g VFggcGFja2V0IENvdW50ZXIgJiBVU0IgU3RhdHVzIFJlZw0KKyNkZWZpbmUJVFhDX1VTQlNfVFhD MAkoMSA8PCAwKQ0KKyNkZWZpbmUJVFhDX1VTQlNfVFhDMQkoMSA8PCAxKQ0KKyNkZWZpbmUJVFhD X1VTQlNfVFhDMgkoMSA8PCAyKQ0KKyNkZWZpbmUJVFhDX1VTQlNfRVAxUkRZCSgxIDw8IDUpDQor I2RlZmluZQlUWENfVVNCU19TVVNGTEFHCSgxIDw8IDYpDQorI2RlZmluZQlUWENfVVNCU19SWEZB VUxUCSgxIDw8IDcpDQorLy8gVVNCIENvbnRyb2wgUmVnDQorI2RlZmluZQlVU0JDX0VQM05BSwko MSA8PCA0KQ0KKyNkZWZpbmUJVVNCQ19FUDNBQ0sJKDEgPDwgNSkNCisNCisvKiBWYXJpYWJsZXMg Ki8NCisjZGVmaW5lCVNSX1JEX1JFR1MJCTB4MDANCisjZGVmaW5lCVNSX1dSX1JFR1MJCTB4MDEN CisjZGVmaW5lCVNSX1dSX1JFRwkJMHgwMw0KKyNkZWZpbmUJU1JfUkVRX1JEX1JFRwkoVVNCX0RJ Ul9JTiB8IFVTQl9UWVBFX1ZFTkRPUiB8IFVTQl9SRUNJUF9ERVZJQ0UpDQorI2RlZmluZQlTUl9S RVFfV1JfUkVHCShVU0JfRElSX09VVCB8IFVTQl9UWVBFX1ZFTkRPUiB8IFVTQl9SRUNJUF9ERVZJ Q0UpDQorDQorI2RlZmluZQlTUl9TSEFSRV9USU1FT1VUCTEwMDANCisjZGVmaW5lCVNSX0VFUFJP TV9MRU4JCTI1Ng0KKyNkZWZpbmUJU1JfTUNBU1RfU0laRQkJOA0KKyNkZWZpbmUJU1JfTUNBU1Rf TUFYCQk2NA0KKyNkZWZpbmUJU1JfVFhfT1ZFUkhFQUQJCTIJLy8gMmJ5dGVzIGhlYWRlcg0KKyNk ZWZpbmUJU1JfUlhfT1ZFUkhFQUQJCTcJLy8gM2J5dGVzIGhlYWRlciArIDRjcmMgdGFpbA0KKw0K Ky8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovDQoNCg0KLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0NCjIwMTMtMDgtMjAgDQps aXVqdW5saWFuZ19samwgDQp3d3cuY29yZWNoaXAtc3ouY29tDQo= -- To unsubscribe from this list: send the line "unsubscribe linux-usb" in the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org More majordomo info at http://vger.kernel.org/majordomo-info.html