* Re: [PATCH 4/8] trivial: fix some typos and punctuation in comments
From: Ivo van Doorn @ 2009-10-15 20:07 UTC (permalink / raw)
To: Thadeu Lima de Souza Cascardo
Cc: trivial, linville, johannes, users, linux-kernel, linux-wireless,
netdev
In-Reply-To: <1255636103-5817-1-git-send-email-cascardo@holoscopio.com>
On Thursday 15 October 2009, Thadeu Lima de Souza Cascardo wrote:
> Signed-off-by: Thadeu Lima de Souza Cascardo <cascardo@holoscopio.com>
Acked-by: Ivo van Doorn <IvDoorn@gmail.com>
> ---
> drivers/net/wireless/rt2x00/rt61pci.c | 36 ++++++++++++++++----------------
> 1 files changed, 18 insertions(+), 18 deletions(-)
>
> diff --git a/drivers/net/wireless/rt2x00/rt61pci.c b/drivers/net/wireless/rt2x00/rt61pci.c
> index b20e3ea..343e565 100644
> --- a/drivers/net/wireless/rt2x00/rt61pci.c
> +++ b/drivers/net/wireless/rt2x00/rt61pci.c
> @@ -51,7 +51,7 @@ MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
> * These indirect registers work with busy bits,
> * and we will try maximal REGISTER_BUSY_COUNT times to access
> * the register while taking a REGISTER_BUSY_DELAY us delay
> - * between each attampt. When the busy bit is still set at that time,
> + * between each attempt. When the busy bit is still set at that time,
> * the access attempt is considered to have failed,
> * and we will print an error.
> */
> @@ -386,7 +386,7 @@ static int rt61pci_config_shared_key(struct rt2x00_dev *rt2x00dev,
> * The driver does not support the IV/EIV generation
> * in hardware. However it doesn't support the IV/EIV
> * inside the ieee80211 frame either, but requires it
> - * to be provided seperately for the descriptor.
> + * to be provided separately for the descriptor.
> * rt2x00lib will cut the IV/EIV data out of all frames
> * given to us by mac80211, but we must tell mac80211
> * to generate the IV/EIV data.
> @@ -397,7 +397,7 @@ static int rt61pci_config_shared_key(struct rt2x00_dev *rt2x00dev,
> /*
> * SEC_CSR0 contains only single-bit fields to indicate
> * a particular key is valid. Because using the FIELD32()
> - * defines directly will cause a lot of overhead we use
> + * defines directly will cause a lot of overhead, we use
> * a calculation to determine the correct bit directly.
> */
> mask = 1 << key->hw_key_idx;
> @@ -425,11 +425,11 @@ static int rt61pci_config_pairwise_key(struct rt2x00_dev *rt2x00dev,
> /*
> * rt2x00lib can't determine the correct free
> * key_idx for pairwise keys. We have 2 registers
> - * with key valid bits. The goal is simple, read
> - * the first register, if that is full move to
> + * with key valid bits. The goal is simple: read
> + * the first register. If that is full, move to
> * the next register.
> - * When both registers are full, we drop the key,
> - * otherwise we use the first invalid entry.
> + * When both registers are full, we drop the key.
> + * Otherwise, we use the first invalid entry.
> */
> rt2x00pci_register_read(rt2x00dev, SEC_CSR2, ®);
> if (reg && reg == ~0) {
> @@ -464,8 +464,8 @@ static int rt61pci_config_pairwise_key(struct rt2x00_dev *rt2x00dev,
> &addr_entry, sizeof(addr_entry));
>
> /*
> - * Enable pairwise lookup table for given BSS idx,
> - * without this received frames will not be decrypted
> + * Enable pairwise lookup table for given BSS idx.
> + * Without this, received frames will not be decrypted
> * by the hardware.
> */
> rt2x00pci_register_read(rt2x00dev, SEC_CSR4, ®);
> @@ -487,7 +487,7 @@ static int rt61pci_config_pairwise_key(struct rt2x00_dev *rt2x00dev,
> /*
> * SEC_CSR2 and SEC_CSR3 contain only single-bit fields to indicate
> * a particular key is valid. Because using the FIELD32()
> - * defines directly will cause a lot of overhead we use
> + * defines directly will cause a lot of overhead, we use
> * a calculation to determine the correct bit directly.
> */
> if (key->hw_key_idx < 32) {
> @@ -556,7 +556,7 @@ static void rt61pci_config_intf(struct rt2x00_dev *rt2x00dev,
> if (flags & CONFIG_UPDATE_TYPE) {
> /*
> * Clear current synchronisation setup.
> - * For the Beacon base registers we only need to clear
> + * For the Beacon base registers, we only need to clear
> * the first byte since that byte contains the VALID and OWNER
> * bits which (when set to 0) will invalidate the entire beacon.
> */
> @@ -1168,8 +1168,8 @@ static int rt61pci_check_firmware(struct rt2x00_dev *rt2x00dev,
> return FW_BAD_LENGTH;
>
> /*
> - * The last 2 bytes in the firmware array are the crc checksum itself,
> - * this means that we should never pass those 2 bytes to the crc
> + * The last 2 bytes in the firmware array are the crc checksum itself.
> + * This means that we should never pass those 2 bytes to the crc
> * algorithm.
> */
> fw_crc = (data[len - 2] << 8 | data[len - 1]);
> @@ -1986,7 +1986,7 @@ static void rt61pci_fill_rxdone(struct queue_entry *entry,
>
> /*
> * Hardware has stripped IV/EIV data from 802.11 frame during
> - * decryption. It has provided the data seperately but rt2x00lib
> + * decryption. It has provided the data separately but rt2x00lib
> * should decide if it should be reinserted.
> */
> rxdesc->flags |= RX_FLAG_IV_STRIPPED;
> @@ -2042,7 +2042,7 @@ static void rt61pci_txdone(struct rt2x00_dev *rt2x00dev)
> * During each loop we will compare the freshly read
> * STA_CSR4 register value with the value read from
> * the previous loop. If the 2 values are equal then
> - * we should stop processing because the chance it
> + * we should stop processing because the chance is
> * quite big that the device has been unplugged and
> * we risk going into an endless loop.
> */
> @@ -2330,7 +2330,7 @@ static int rt61pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
> __set_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags);
>
> /*
> - * Detect if this device has an hardware controlled radio.
> + * Detect if this device has a hardware controlled radio.
> */
> if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
> __set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
> @@ -2355,7 +2355,7 @@ static int rt61pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
> __set_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags);
>
> /*
> - * When working with a RF2529 chip without double antenna
> + * When working with a RF2529 chip without double antenna,
> * the antenna settings should be gathered from the NIC
> * eeprom word.
> */
> @@ -2668,7 +2668,7 @@ static int rt61pci_conf_tx(struct ieee80211_hw *hw, u16 queue_idx,
>
> /*
> * We only need to perform additional register initialization
> - * for WMM queues/
> + * for WMM queues.
> */
> if (queue_idx >= 4)
> return 0;
^ permalink raw reply
* [PATCH 4/8] trivial: fix some typos and punctuation in comments
From: Thadeu Lima de Souza Cascardo @ 2009-10-15 19:48 UTC (permalink / raw)
To: trivial
Cc: linville, IvDoorn, johannes, users, linux-kernel, linux-wireless,
netdev, Thadeu Lima de Souza Cascardo
Signed-off-by: Thadeu Lima de Souza Cascardo <cascardo@holoscopio.com>
---
drivers/net/wireless/rt2x00/rt61pci.c | 36 ++++++++++++++++----------------
1 files changed, 18 insertions(+), 18 deletions(-)
diff --git a/drivers/net/wireless/rt2x00/rt61pci.c b/drivers/net/wireless/rt2x00/rt61pci.c
index b20e3ea..343e565 100644
--- a/drivers/net/wireless/rt2x00/rt61pci.c
+++ b/drivers/net/wireless/rt2x00/rt61pci.c
@@ -51,7 +51,7 @@ MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
* These indirect registers work with busy bits,
* and we will try maximal REGISTER_BUSY_COUNT times to access
* the register while taking a REGISTER_BUSY_DELAY us delay
- * between each attampt. When the busy bit is still set at that time,
+ * between each attempt. When the busy bit is still set at that time,
* the access attempt is considered to have failed,
* and we will print an error.
*/
@@ -386,7 +386,7 @@ static int rt61pci_config_shared_key(struct rt2x00_dev *rt2x00dev,
* The driver does not support the IV/EIV generation
* in hardware. However it doesn't support the IV/EIV
* inside the ieee80211 frame either, but requires it
- * to be provided seperately for the descriptor.
+ * to be provided separately for the descriptor.
* rt2x00lib will cut the IV/EIV data out of all frames
* given to us by mac80211, but we must tell mac80211
* to generate the IV/EIV data.
@@ -397,7 +397,7 @@ static int rt61pci_config_shared_key(struct rt2x00_dev *rt2x00dev,
/*
* SEC_CSR0 contains only single-bit fields to indicate
* a particular key is valid. Because using the FIELD32()
- * defines directly will cause a lot of overhead we use
+ * defines directly will cause a lot of overhead, we use
* a calculation to determine the correct bit directly.
*/
mask = 1 << key->hw_key_idx;
@@ -425,11 +425,11 @@ static int rt61pci_config_pairwise_key(struct rt2x00_dev *rt2x00dev,
/*
* rt2x00lib can't determine the correct free
* key_idx for pairwise keys. We have 2 registers
- * with key valid bits. The goal is simple, read
- * the first register, if that is full move to
+ * with key valid bits. The goal is simple: read
+ * the first register. If that is full, move to
* the next register.
- * When both registers are full, we drop the key,
- * otherwise we use the first invalid entry.
+ * When both registers are full, we drop the key.
+ * Otherwise, we use the first invalid entry.
*/
rt2x00pci_register_read(rt2x00dev, SEC_CSR2, ®);
if (reg && reg == ~0) {
@@ -464,8 +464,8 @@ static int rt61pci_config_pairwise_key(struct rt2x00_dev *rt2x00dev,
&addr_entry, sizeof(addr_entry));
/*
- * Enable pairwise lookup table for given BSS idx,
- * without this received frames will not be decrypted
+ * Enable pairwise lookup table for given BSS idx.
+ * Without this, received frames will not be decrypted
* by the hardware.
*/
rt2x00pci_register_read(rt2x00dev, SEC_CSR4, ®);
@@ -487,7 +487,7 @@ static int rt61pci_config_pairwise_key(struct rt2x00_dev *rt2x00dev,
/*
* SEC_CSR2 and SEC_CSR3 contain only single-bit fields to indicate
* a particular key is valid. Because using the FIELD32()
- * defines directly will cause a lot of overhead we use
+ * defines directly will cause a lot of overhead, we use
* a calculation to determine the correct bit directly.
*/
if (key->hw_key_idx < 32) {
@@ -556,7 +556,7 @@ static void rt61pci_config_intf(struct rt2x00_dev *rt2x00dev,
if (flags & CONFIG_UPDATE_TYPE) {
/*
* Clear current synchronisation setup.
- * For the Beacon base registers we only need to clear
+ * For the Beacon base registers, we only need to clear
* the first byte since that byte contains the VALID and OWNER
* bits which (when set to 0) will invalidate the entire beacon.
*/
@@ -1168,8 +1168,8 @@ static int rt61pci_check_firmware(struct rt2x00_dev *rt2x00dev,
return FW_BAD_LENGTH;
/*
- * The last 2 bytes in the firmware array are the crc checksum itself,
- * this means that we should never pass those 2 bytes to the crc
+ * The last 2 bytes in the firmware array are the crc checksum itself.
+ * This means that we should never pass those 2 bytes to the crc
* algorithm.
*/
fw_crc = (data[len - 2] << 8 | data[len - 1]);
@@ -1986,7 +1986,7 @@ static void rt61pci_fill_rxdone(struct queue_entry *entry,
/*
* Hardware has stripped IV/EIV data from 802.11 frame during
- * decryption. It has provided the data seperately but rt2x00lib
+ * decryption. It has provided the data separately but rt2x00lib
* should decide if it should be reinserted.
*/
rxdesc->flags |= RX_FLAG_IV_STRIPPED;
@@ -2042,7 +2042,7 @@ static void rt61pci_txdone(struct rt2x00_dev *rt2x00dev)
* During each loop we will compare the freshly read
* STA_CSR4 register value with the value read from
* the previous loop. If the 2 values are equal then
- * we should stop processing because the chance it
+ * we should stop processing because the chance is
* quite big that the device has been unplugged and
* we risk going into an endless loop.
*/
@@ -2330,7 +2330,7 @@ static int rt61pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
__set_bit(CONFIG_FRAME_TYPE, &rt2x00dev->flags);
/*
- * Detect if this device has an hardware controlled radio.
+ * Detect if this device has a hardware controlled radio.
*/
if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
__set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
@@ -2355,7 +2355,7 @@ static int rt61pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
__set_bit(CONFIG_EXTERNAL_LNA_BG, &rt2x00dev->flags);
/*
- * When working with a RF2529 chip without double antenna
+ * When working with a RF2529 chip without double antenna,
* the antenna settings should be gathered from the NIC
* eeprom word.
*/
@@ -2668,7 +2668,7 @@ static int rt61pci_conf_tx(struct ieee80211_hw *hw, u16 queue_idx,
/*
* We only need to perform additional register initialization
- * for WMM queues/
+ * for WMM queues.
*/
if (queue_idx >= 4)
return 0;
--
1.6.3.3
^ permalink raw reply related
* Re: [PATCH] Phonet: hold socket before giving it to sk_deliver_skb()
From: David Miller @ 2009-10-15 19:29 UTC (permalink / raw)
To: remi; +Cc: netdev, remi.denis-courmont
In-Reply-To: <1255611600-18534-1-git-send-email-remi@remlab.net>
From: Rémi Denis-Courmont <remi@remlab.net>
Date: Thu, 15 Oct 2009 16:00:00 +0300
> From: Rémi Denis-Courmont <remi.denis-courmont@nokia.com>
>
> Signed-off-by: Rémi Denis-Courmont <remi.denis-courmont@nokia.com>
Applied.
^ permalink raw reply
* [PATCH] iproute2: Add ll_index_to_addr function
From: David Ward @ 2009-10-15 18:53 UTC (permalink / raw)
To: netdev; +Cc: David Ward
After calling ll_init_map, all of the information stored in the link-layer map
can be retrieved by function calls (ll_index_to_*), except for the link-layer
address. This patch fills the gap by adding a ll_index_to_addr function.
Changes welcome.
Signed-off-by: David Ward <david.ward@ll.mit.edu>
---
include/ll_map.h | 2 ++
lib/ll_map.c | 21 +++++++++++++++++++++
2 files changed, 23 insertions(+), 0 deletions(-)
diff --git a/include/ll_map.h b/include/ll_map.h
index c4d5c6d..752b827 100644
--- a/include/ll_map.h
+++ b/include/ll_map.h
@@ -9,5 +9,7 @@ extern const char *ll_index_to_name(unsigned idx);
extern const char *ll_idx_n2a(unsigned idx, char *buf);
extern int ll_index_to_type(unsigned idx);
extern unsigned ll_index_to_flags(unsigned idx);
+extern unsigned ll_index_to_addr(unsigned idx, unsigned char *addr,
+ unsigned alen);
#endif /* __LL_MAP_H__ */
diff --git a/lib/ll_map.c b/lib/ll_map.c
index c1d61a9..7c0bea2 100644
--- a/lib/ll_map.c
+++ b/lib/ll_map.c
@@ -134,6 +134,27 @@ unsigned ll_index_to_flags(unsigned idx)
return 0;
}
+unsigned ll_index_to_addr(unsigned idx, unsigned char *addr,
+ unsigned alen)
+{
+ struct idxmap *im;
+
+ if (idx == 0)
+ return 0;
+
+ for (im = idxmap[idx&0xF]; im; im = im->next) {
+ if (im->index == idx) {
+ if (alen > sizeof(im->addr))
+ alen = sizeof(im->addr);
+ if (alen > im->alen)
+ alen = im->alen;
+ memcpy(addr, im->addr, alen);
+ return alen;
+ }
+ }
+ return 0;
+}
+
unsigned ll_name_to_index(const char *name)
{
static char ncache[16];
--
1.5.5.6
^ permalink raw reply related
* [PATCH] [NIU] VLAN does not work with niu driver
From: Joyce Yu @ 2009-10-15 19:16 UTC (permalink / raw)
To: netdev
[-- Attachment #1: Type: text/plain, Size: 6 bytes --]
--
[-- Attachment #2: 0001-VLAN-does-not-work-with-niu-driver.patch --]
[-- Type: text/x-patch, Size: 727 bytes --]
>From eb878a6887fed77e6b4c69a014a2c98ea2b52736 Mon Sep 17 00:00:00 2001
From: Joyce Yu <joyce.yu@sun.com>
Date: Thu, 15 Oct 2009 06:49:29 -0700
Subject: [PATCH] VLAN does not work with niu driver
---
drivers/net/niu.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index f9364d0..d6c7ac6 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -3545,7 +3545,7 @@ static int niu_process_rx_pkt(struct napi_struct *napi, struct niu *np,
rp->rcr_index = index;
skb_reserve(skb, NET_IP_ALIGN);
- __pskb_pull_tail(skb, min(len, NIU_RXPULL_MAX));
+ __pskb_pull_tail(skb, min(len, VLAN_ETH_HLEN));
rp->rx_packets++;
rp->rx_bytes += skb->len;
--
1.6.4
^ permalink raw reply related
* [PATCH] iproute2: Support 20-byte link layer address in idxmap
From: David Ward @ 2009-10-15 18:53 UTC (permalink / raw)
To: netdev; +Cc: David Ward
Extend the link-layer address field from 8 to 20 bytes to support InfiniBand.
Signed-off-by: David Ward <david.ward@ll.mit.edu>
---
lib/ll_map.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/lib/ll_map.c b/lib/ll_map.c
index 7c0bea2..5addf4a 100644
--- a/lib/ll_map.c
+++ b/lib/ll_map.c
@@ -31,7 +31,7 @@ struct idxmap
int type;
int alen;
unsigned flags;
- unsigned char addr[8];
+ unsigned char addr[20];
char name[16];
};
--
1.5.5.6
^ permalink raw reply related
* Re: [BUILD-FAILURE] next-20091015 - vbus_enet driver breaks with allmodconfig
From: Randy Dunlap @ 2009-10-15 18:54 UTC (permalink / raw)
To: Gregory Haskins, Gregory Haskins
Cc: Kamalesh Babulal, sfr, greg, netdev, LKML, linux-next
In-Reply-To: <20091015114210.65e1be72.randy.dunlap@oracle.com>
On Thu, 15 Oct 2009 11:42:10 -0700 Randy Dunlap wrote:
> On Thu, 15 Oct 2009 13:39:44 -0400 Gregory Haskins wrote:
>
> > Gregory Haskins wrote:
> > >>>> On 10/15/2009 at 6:48 AM, in message
> > > <20091015104852.GA6740@linux.vnet.ibm.com>, Kamalesh Babulal
> > > <kamalesh@linux.vnet.ibm.com> wrote:
> > >> Hi Gregory,
> > >>
> > >> While building next-20091015 with allmodconfig on the powerpc
> > >> vbus-enet driver breaks
> > >
> > > Hi Kamalesh,
> > >
> > > I'll take a look at this and get a fix submitted today.
> > >
> > > Kind Regards,
> > > -Greg
> > >
> > >> MODPOST 2492 modules
> > >> ERROR: ".vbus_driver_register" [drivers/net/vbus-enet.ko] undefined!
> > >> ERROR: ".vbus_driver_unregister" [drivers/net/vbus-enet.ko] undefined!
> > >> ERROR: ".vbus_driver_ioq_alloc" [drivers/net/vbus-enet.ko] undefined!
> > >>
> > >> CONFIG_VBUS_ENET=m
> > >> CONFIG_VBUS_ENET_DEBUG=y
> > >> CONFIG_VBUS_PROXY=n
> >
> > Hi Kamalesh,
> >
> > I am having difficulty reproducing the problem. When I look at the
> > Kconfig, I see that VBUS_ENET has a "select VBUS_PROXY" as I would
> > expect. Additionally, if I run allmodconfig I can confirm that I get
> > VBUS_ENET=m, VBUS_PROXY=y:
>
> Greg,
>
> Did you try to reproduce it with the ppc64 config file?
> allmodconfig on what arch?
>
> I think the problem is that arch/x86/Kconfig says:
>
> source "drivers/vbus/Kconfig"
>
> and that should actually be in drivers/Kconfig, so that it applies
> to ppc64 et al, not just x86.
>
OTOH, drivers/vbus/pci-bridge.c uses create_irq(), which is implemented
only on x86 and ia64 and one ARM platform, so all of this ppc testing
seems to be invalid... ?
>
> > ghaskins@dev:~/sandbox/git/fabric/linux-2.6-next> rm .config
> > ghaskins@dev:~/sandbox/git/fabric/linux-2.6-next> make allmodconfig
> > scripts/kconfig/conf -m arch/x86/Kconfig
> > #
> > # configuration written to .config
> > #
> > ghaskins@dev:~/sandbox/git/fabric/linux-2.6-next> grep -i vbus .config
> > CONFIG_VBUS_PROXY=y
> > CONFIG_VBUS_PCIBRIDGE=y
> > CONFIG_VBUS_ENET=m
> > CONFIG_VBUS_ENET_DEBUG=y
> > CONFIG_USB_GADGET_VBUS_DRAW=2
> > CONFIG_USB_GPIO_VBUS=m
> >
> > I am not sure how your environment could have generated the VBUS_PROXY=n
> > outcome. Does anyone have any ideas?
> >
> > -Greg
---
~Randy
^ permalink raw reply
* Re: [BUILD-FAILURE] next-20091015 - vbus_enet driver breaks with allmodconfig
From: Randy Dunlap @ 2009-10-15 18:42 UTC (permalink / raw)
To: Gregory Haskins
Cc: Gregory Haskins, Kamalesh Babulal, sfr, greg, netdev, LKML,
linux-next
In-Reply-To: <4AD75E60.4020306@gmail.com>
On Thu, 15 Oct 2009 13:39:44 -0400 Gregory Haskins wrote:
> Gregory Haskins wrote:
> >>>> On 10/15/2009 at 6:48 AM, in message
> > <20091015104852.GA6740@linux.vnet.ibm.com>, Kamalesh Babulal
> > <kamalesh@linux.vnet.ibm.com> wrote:
> >> Hi Gregory,
> >>
> >> While building next-20091015 with allmodconfig on the powerpc
> >> vbus-enet driver breaks
> >
> > Hi Kamalesh,
> >
> > I'll take a look at this and get a fix submitted today.
> >
> > Kind Regards,
> > -Greg
> >
> >> MODPOST 2492 modules
> >> ERROR: ".vbus_driver_register" [drivers/net/vbus-enet.ko] undefined!
> >> ERROR: ".vbus_driver_unregister" [drivers/net/vbus-enet.ko] undefined!
> >> ERROR: ".vbus_driver_ioq_alloc" [drivers/net/vbus-enet.ko] undefined!
> >>
> >> CONFIG_VBUS_ENET=m
> >> CONFIG_VBUS_ENET_DEBUG=y
> >> CONFIG_VBUS_PROXY=n
>
> Hi Kamalesh,
>
> I am having difficulty reproducing the problem. When I look at the
> Kconfig, I see that VBUS_ENET has a "select VBUS_PROXY" as I would
> expect. Additionally, if I run allmodconfig I can confirm that I get
> VBUS_ENET=m, VBUS_PROXY=y:
Greg,
Did you try to reproduce it with the ppc64 config file?
allmodconfig on what arch?
I think the problem is that arch/x86/Kconfig says:
source "drivers/vbus/Kconfig"
and that should actually be in drivers/Kconfig, so that it applies
to ppc64 et al, not just x86.
> ghaskins@dev:~/sandbox/git/fabric/linux-2.6-next> rm .config
> ghaskins@dev:~/sandbox/git/fabric/linux-2.6-next> make allmodconfig
> scripts/kconfig/conf -m arch/x86/Kconfig
> #
> # configuration written to .config
> #
> ghaskins@dev:~/sandbox/git/fabric/linux-2.6-next> grep -i vbus .config
> CONFIG_VBUS_PROXY=y
> CONFIG_VBUS_PCIBRIDGE=y
> CONFIG_VBUS_ENET=m
> CONFIG_VBUS_ENET_DEBUG=y
> CONFIG_USB_GADGET_VBUS_DRAW=2
> CONFIG_USB_GPIO_VBUS=m
>
> I am not sure how your environment could have generated the VBUS_PROXY=n
> outcome. Does anyone have any ideas?
>
> -Greg
---
~Randy
^ permalink raw reply
* Re: NOHZ: local_softirq_pending 08
From: Jarek Poplawski @ 2009-10-15 17:53 UTC (permalink / raw)
To: Tilman Schmidt
Cc: David Miller, johannes, hidave.darkstar, linux-kernel, tglx,
linux-wireless, linux-ppp, netdev, paulus
In-Reply-To: <20091015114052.GA9870@ff.dom.local>
Jarek Poplawski wrote, On 10/15/2009 01:40 PM:
> On 12-10-2009 13:25, Tilman Schmidt wrote:
>> -----BEGIN PGP SIGNED MESSAGE-----
>> Hash: SHA1
>>
>> On Mon, 12 Oct 2009 03:32:46 -0700 (PDT), David Miller wrote:
>>> The PPP receive paths in ppp_generic.c do a local_bh_disable()/
>>> local_bh_enable() around packet receiving (via ppp_recv_lock()/
>>> ppp_recv_unlock() in ppp_do_recv).
>>>
>>> So at least that part is perfectly fine.
>>>
>>> ppp_input(), as called from ppp_sync_process(), also disables BH's
>>> around ppp_do_recv() calls (via read_lock_bh()/read_unlock_bh()).
>>>
>>> So that's fine too.
>>>
>>> Do you have a bug report or are you just scanning around looking
>>> for trouble? :-)
>> I have encountered the message in the subject during a test of
>> the Gigaset CAPI driver, and would like to determine whether
>> it's a bug in the driver, a bug somewhere else, or no bug at
>> all. The test scenario was PPP over ISDN with pppd+capiplugin.
>> In an alternative scenario, also PPP over ISDN but with
>> smpppd+capidrv, the message did not occur.
>>
>> Johannes' answer pointed me to the netif_rx() function.
>> The Gigaset driver itself doesn't call that function at all.
>> In the scenario where I saw the message, it was the SYNC_PPP
>> line discipline that did. But from your explanation I gather
>> that the cause cannot lie there.
>>
>> So now I'm looking for other possible causes of that message.
BTW, it seems calling napi_schedule() from process context should
trigger such a warning too.
Jarek P.
>
> Anyway, I agree with Michael Buesch there is no reason to waste time
> for tracking all netif_rx vs netif_rx_ni uses, and it seems we could
> avoid it by using the "proper" version of raise_softirq_irqoff() in
> __napi_schedule(). Could anybody try if I'm not wrong?
>
> Thanks,
> Jarek P.
> ---
>
> net/core/dev.c | 2 +-
> 1 files changed, 1 insertions(+), 1 deletions(-)
>
> diff --git a/net/core/dev.c b/net/core/dev.c
> index 28b0b9e..7fc4009 100644
> --- a/net/core/dev.c
> +++ b/net/core/dev.c
> @@ -2728,7 +2728,7 @@ void __napi_schedule(struct napi_struct *n)
>
> local_irq_save(flags);
> list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
> - __raise_softirq_irqoff(NET_RX_SOFTIRQ);
> + raise_softirq_irqoff(NET_RX_SOFTIRQ);
> local_irq_restore(flags);
> }
> EXPORT_SYMBOL(__napi_schedule);
> --
> To unsubscribe from this list: send the line "unsubscribe linux-ppp" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
^ permalink raw reply
* Re: [BUILD-FAILURE] next-20091015 - vbus_enet driver breaks with allmodconfig
From: Gregory Haskins @ 2009-10-15 17:39 UTC (permalink / raw)
To: Gregory Haskins; +Cc: Kamalesh Babulal, sfr, greg, netdev, LKML, linux-next
In-Reply-To: <4AD6CD940200005A00056857@sinclair.provo.novell.com>
[-- Attachment #1: Type: text/plain, Size: 123159 bytes --]
Gregory Haskins wrote:
>>>> On 10/15/2009 at 6:48 AM, in message
> <20091015104852.GA6740@linux.vnet.ibm.com>, Kamalesh Babulal
> <kamalesh@linux.vnet.ibm.com> wrote:
>> Hi Gregory,
>>
>> While building next-20091015 with allmodconfig on the powerpc
>> vbus-enet driver breaks
>
> Hi Kamalesh,
>
> I'll take a look at this and get a fix submitted today.
>
> Kind Regards,
> -Greg
>
>> MODPOST 2492 modules
>> ERROR: ".vbus_driver_register" [drivers/net/vbus-enet.ko] undefined!
>> ERROR: ".vbus_driver_unregister" [drivers/net/vbus-enet.ko] undefined!
>> ERROR: ".vbus_driver_ioq_alloc" [drivers/net/vbus-enet.ko] undefined!
>>
>> CONFIG_VBUS_ENET=m
>> CONFIG_VBUS_ENET_DEBUG=y
>> CONFIG_VBUS_PROXY=n
Hi Kamalesh,
I am having difficulty reproducing the problem. When I look at the
Kconfig, I see that VBUS_ENET has a "select VBUS_PROXY" as I would
expect. Additionally, if I run allmodconfig I can confirm that I get
VBUS_ENET=m, VBUS_PROXY=y:
ghaskins@dev:~/sandbox/git/fabric/linux-2.6-next> rm .config
ghaskins@dev:~/sandbox/git/fabric/linux-2.6-next> make allmodconfig
scripts/kconfig/conf -m arch/x86/Kconfig
#
# configuration written to .config
#
ghaskins@dev:~/sandbox/git/fabric/linux-2.6-next> grep -i vbus .config
CONFIG_VBUS_PROXY=y
CONFIG_VBUS_PCIBRIDGE=y
CONFIG_VBUS_ENET=m
CONFIG_VBUS_ENET_DEBUG=y
CONFIG_USB_GADGET_VBUS_DRAW=2
CONFIG_USB_GPIO_VBUS=m
I am not sure how your environment could have generated the VBUS_PROXY=n
outcome. Does anyone have any ideas?
-Greg
>>
>>
>> #
>> # Automatically generated make config: don't edit
>> # Linux kernel version: 2.6.32-rc4
>> # Thu Oct 15 03:26:26 2009
>> #
>> CONFIG_PPC64=y
>>
>> #
>> # Processor support
>> #
>> CONFIG_PPC_BOOK3S_64=y
>> # CONFIG_PPC_BOOK3E_64 is not set
>> CONFIG_PPC_BOOK3S=y
>> CONFIG_POWER4_ONLY=y
>> CONFIG_POWER4=y
>> CONFIG_TUNE_CELL=y
>> CONFIG_PPC_FPU=y
>> CONFIG_ALTIVEC=y
>> CONFIG_VSX=y
>> CONFIG_PPC_STD_MMU=y
>> CONFIG_PPC_STD_MMU_64=y
>> CONFIG_PPC_MM_SLICES=y
>> CONFIG_VIRT_CPU_ACCOUNTING=y
>> CONFIG_PPC_HAVE_PMU_SUPPORT=y
>> CONFIG_PPC_PERF_CTRS=y
>> CONFIG_SMP=y
>> CONFIG_NR_CPUS=32
>> CONFIG_64BIT=y
>> CONFIG_WORD_SIZE=64
>> CONFIG_ARCH_PHYS_ADDR_T_64BIT=y
>> CONFIG_MMU=y
>> CONFIG_GENERIC_CMOS_UPDATE=y
>> CONFIG_GENERIC_TIME=y
>> CONFIG_GENERIC_TIME_VSYSCALL=y
>> CONFIG_GENERIC_CLOCKEVENTS=y
>> CONFIG_GENERIC_HARDIRQS=y
>> CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ=y
>> CONFIG_HAVE_SETUP_PER_CPU_AREA=y
>> CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK=y
>> CONFIG_IRQ_PER_CPU=y
>> CONFIG_STACKTRACE_SUPPORT=y
>> CONFIG_HAVE_LATENCYTOP_SUPPORT=y
>> CONFIG_TRACE_IRQFLAGS_SUPPORT=y
>> CONFIG_LOCKDEP_SUPPORT=y
>> CONFIG_RWSEM_XCHGADD_ALGORITHM=y
>> CONFIG_ARCH_HAS_ILOG2_U32=y
>> CONFIG_ARCH_HAS_ILOG2_U64=y
>> CONFIG_GENERIC_HWEIGHT=y
>> CONFIG_GENERIC_FIND_NEXT_BIT=y
>> CONFIG_GENERIC_GPIO=y
>> CONFIG_ARCH_NO_VIRT_TO_BUS=y
>> CONFIG_PPC=y
>> CONFIG_EARLY_PRINTK=y
>> CONFIG_COMPAT=y
>> CONFIG_SYSVIPC_COMPAT=y
>> CONFIG_SCHED_OMIT_FRAME_POINTER=y
>> CONFIG_ARCH_MAY_HAVE_PC_FDC=y
>> CONFIG_PPC_OF=y
>> CONFIG_OF=y
>> CONFIG_PPC_UDBG_16550=y
>> CONFIG_GENERIC_TBSYNC=y
>> CONFIG_AUDIT_ARCH=y
>> CONFIG_GENERIC_BUG=y
>> CONFIG_DTC=y
>> # CONFIG_DEFAULT_UIMAGE is not set
>> CONFIG_HIBERNATE_64=y
>> CONFIG_ARCH_HIBERNATION_POSSIBLE=y
>> CONFIG_ARCH_SUSPEND_POSSIBLE=y
>> # CONFIG_PPC_DCR_NATIVE is not set
>> CONFIG_PPC_DCR_MMIO=y
>> CONFIG_PPC_DCR=y
>> CONFIG_PPC_OF_PLATFORM_PCI=y
>> CONFIG_ARCH_SUPPORTS_DEBUG_PAGEALLOC=y
>> CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
>> CONFIG_CONSTRUCTORS=y
>>
>> #
>> # General setup
>> #
>> CONFIG_EXPERIMENTAL=y
>> CONFIG_LOCK_KERNEL=y
>> CONFIG_INIT_ENV_ARG_LIMIT=32
>> CONFIG_LOCALVERSION=""
>> # CONFIG_LOCALVERSION_AUTO is not set
>> CONFIG_SWAP=y
>> CONFIG_SYSVIPC=y
>> CONFIG_SYSVIPC_SYSCTL=y
>> CONFIG_POSIX_MQUEUE=y
>> CONFIG_POSIX_MQUEUE_SYSCTL=y
>> CONFIG_BSD_PROCESS_ACCT=y
>> CONFIG_BSD_PROCESS_ACCT_V3=y
>> CONFIG_TASKSTATS=y
>> CONFIG_TASK_DELAY_ACCT=y
>> CONFIG_TASK_XACCT=y
>> CONFIG_TASK_IO_ACCOUNTING=y
>> CONFIG_AUDIT=y
>> CONFIG_AUDITSYSCALL=y
>> CONFIG_AUDIT_WATCH=y
>> CONFIG_AUDIT_TREE=y
>>
>> #
>> # RCU Subsystem
>> #
>> CONFIG_TREE_RCU=y
>> # CONFIG_TREE_PREEMPT_RCU is not set
>> CONFIG_RCU_TRACE=y
>> CONFIG_RCU_FANOUT=64
>> CONFIG_RCU_FANOUT_EXACT=y
>> CONFIG_TREE_RCU_TRACE=y
>> CONFIG_IKCONFIG=m
>> CONFIG_IKCONFIG_PROC=y
>> CONFIG_LOG_BUF_SHIFT=17
>> CONFIG_GROUP_SCHED=y
>> CONFIG_FAIR_GROUP_SCHED=y
>> CONFIG_RT_GROUP_SCHED=y
>> CONFIG_USER_SCHED=y
>> # CONFIG_CGROUP_SCHED is not set
>> CONFIG_CGROUPS=y
>> CONFIG_CGROUP_DEBUG=y
>> CONFIG_CGROUP_NS=y
>> CONFIG_CGROUP_FREEZER=y
>> CONFIG_CGROUP_DEVICE=y
>> CONFIG_CPUSETS=y
>> CONFIG_PROC_PID_CPUSET=y
>> CONFIG_CGROUP_CPUACCT=y
>> CONFIG_RESOURCE_COUNTERS=y
>> CONFIG_CGROUP_MEM_RES_CTLR=y
>> CONFIG_CGROUP_MEM_RES_CTLR_SWAP=y
>> CONFIG_MM_OWNER=y
>> CONFIG_SYSFS_DEPRECATED=y
>> CONFIG_SYSFS_DEPRECATED_V2=y
>> CONFIG_RELAY=y
>> CONFIG_NAMESPACES=y
>> CONFIG_UTS_NS=y
>> CONFIG_IPC_NS=y
>> CONFIG_USER_NS=y
>> CONFIG_PID_NS=y
>> CONFIG_NET_NS=y
>> CONFIG_BLK_DEV_INITRD=y
>> CONFIG_INITRAMFS_SOURCE=""
>> CONFIG_RD_GZIP=y
>> CONFIG_RD_BZIP2=y
>> CONFIG_RD_LZMA=y
>> CONFIG_CC_OPTIMIZE_FOR_SIZE=y
>> CONFIG_SYSCTL=y
>> CONFIG_ANON_INODES=y
>> CONFIG_EMBEDDED=y
>> CONFIG_SYSCTL_SYSCALL=y
>> CONFIG_KALLSYMS=y
>> CONFIG_KALLSYMS_ALL=y
>> CONFIG_KALLSYMS_EXTRA_PASS=y
>> CONFIG_HOTPLUG=y
>> CONFIG_PRINTK=y
>> CONFIG_BUG=y
>> CONFIG_ELF_CORE=y
>> CONFIG_PCSPKR_PLATFORM=y
>> CONFIG_BASE_FULL=y
>> CONFIG_FUTEX=y
>> CONFIG_EPOLL=y
>> CONFIG_SIGNALFD=y
>> CONFIG_TIMERFD=y
>> CONFIG_EVENTFD=y
>> CONFIG_SHMEM=y
>> CONFIG_AIO=y
>> CONFIG_HAVE_PERF_EVENTS=y
>> CONFIG_PERF_USE_VMALLOC=y
>>
>> #
>> # Kernel Performance Events And Counters
>> #
>> CONFIG_PERF_EVENTS=y
>> CONFIG_EVENT_PROFILE=y
>> CONFIG_PERF_COUNTERS=y
>> CONFIG_DEBUG_PERF_USE_VMALLOC=y
>> CONFIG_VM_EVENT_COUNTERS=y
>> CONFIG_PCI_QUIRKS=y
>> CONFIG_SLUB_DEBUG=y
>> CONFIG_COMPAT_BRK=y
>> # CONFIG_SLAB is not set
>> CONFIG_SLUB=y
>> # CONFIG_SLQB is not set
>> # CONFIG_SLOB is not set
>> CONFIG_PROFILING=y
>> CONFIG_TRACEPOINTS=y
>> CONFIG_OPROFILE=m
>> CONFIG_HAVE_OPROFILE=y
>> CONFIG_KPROBES=y
>> CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y
>> CONFIG_HAVE_SYSCALL_WRAPPERS=y
>> CONFIG_KRETPROBES=y
>> CONFIG_HAVE_IOREMAP_PROT=y
>> CONFIG_HAVE_KPROBES=y
>> CONFIG_HAVE_KRETPROBES=y
>> CONFIG_HAVE_ARCH_TRACEHOOK=y
>> CONFIG_HAVE_DMA_ATTRS=y
>> CONFIG_USE_GENERIC_SMP_HELPERS=y
>> CONFIG_HAVE_DMA_API_DEBUG=y
>>
>> #
>> # GCOV-based kernel profiling
>> #
>> CONFIG_GCOV_KERNEL=y
>> CONFIG_GCOV_PROFILE_ALL=y
>> CONFIG_SLOW_WORK=y
>> # CONFIG_HAVE_GENERIC_DMA_COHERENT is not set
>> CONFIG_SLABINFO=y
>> CONFIG_RT_MUTEXES=y
>> CONFIG_BASE_SMALL=0
>> CONFIG_MODULES=y
>> CONFIG_MODULE_FORCE_LOAD=y
>> CONFIG_MODULE_UNLOAD=y
>> CONFIG_MODULE_FORCE_UNLOAD=y
>> CONFIG_MODVERSIONS=y
>> CONFIG_MODULE_SRCVERSION_ALL=y
>> CONFIG_STOP_MACHINE=y
>> CONFIG_BLOCK=y
>> CONFIG_BLK_DEV_BSG=y
>> CONFIG_BLK_DEV_INTEGRITY=y
>> CONFIG_BLOCK_COMPAT=y
>>
>> #
>> # IO Schedulers
>> #
>> CONFIG_IOSCHED_NOOP=y
>> CONFIG_IOSCHED_DEADLINE=m
>> CONFIG_IOSCHED_CFQ=m
>> # CONFIG_DEFAULT_DEADLINE is not set
>> # CONFIG_DEFAULT_CFQ is not set
>> CONFIG_DEFAULT_NOOP=y
>> CONFIG_DEFAULT_IOSCHED="noop"
>> CONFIG_FREEZER=y
>> CONFIG_PPC_MSI_BITMAP=y
>>
>> #
>> # Platform support
>> #
>> CONFIG_PPC_PSERIES=y
>> CONFIG_PPC_SPLPAR=y
>> CONFIG_EEH=y
>> CONFIG_PSERIES_MSI=y
>> CONFIG_SCANLOG=m
>> CONFIG_LPARCFG=y
>> CONFIG_PPC_PSERIES_DEBUG=y
>> CONFIG_PPC_SMLPAR=y
>> CONFIG_DTL=y
>> CONFIG_PPC_ISERIES=y
>>
>> #
>> # iSeries device drivers
>> #
>> CONFIG_VIODASD=m
>> CONFIG_VIOCD=m
>> CONFIG_VIOTAPE=m
>> CONFIG_VIOPATH=y
>> CONFIG_PPC_PMAC=y
>> CONFIG_PPC_PMAC64=y
>> CONFIG_PPC_MAPLE=y
>> CONFIG_PPC_PASEMI=y
>>
>> #
>> # PA Semi PWRficient options
>> #
>> CONFIG_PPC_PASEMI_IOMMU=y
>> CONFIG_PPC_PASEMI_IOMMU_DMA_FORCE=y
>> CONFIG_PPC_PASEMI_MDIO=m
>> CONFIG_PPC_PS3=y
>>
>> #
>> # PS3 Platform Options
>> #
>> CONFIG_PS3_ADVANCED=y
>> CONFIG_PS3_HTAB_SIZE=20
>> CONFIG_PS3_DYNAMIC_DMA=y
>> CONFIG_PS3_VUART=m
>> CONFIG_PS3_PS3AV=m
>> CONFIG_PS3_SYS_MANAGER=m
>> CONFIG_PS3_STORAGE=m
>> CONFIG_PS3_DISK=m
>> CONFIG_PS3_ROM=m
>> CONFIG_PS3_FLASH=m
>> CONFIG_PS3_LPM=m
>> CONFIG_PPC_CELL=y
>> CONFIG_PPC_CELL_COMMON=y
>> CONFIG_PPC_CELL_NATIVE=y
>> CONFIG_PPC_IBM_CELL_BLADE=y
>> CONFIG_PPC_CELLEB=y
>> CONFIG_PPC_CELL_QPACE=y
>> CONFIG_AXON_MSI=y
>>
>> #
>> # Cell Broadband Engine options
>> #
>> CONFIG_SPU_FS=m
>> CONFIG_SPU_FS_64K_LS=y
>> CONFIG_SPU_BASE=y
>> CONFIG_CBE_RAS=y
>> CONFIG_PPC_IBM_CELL_RESETBUTTON=y
>> CONFIG_PPC_IBM_CELL_POWERBUTTON=m
>> CONFIG_CBE_THERM=m
>> CONFIG_CBE_CPUFREQ=m
>> CONFIG_CBE_CPUFREQ_PMI_ENABLE=y
>> CONFIG_CBE_CPUFREQ_PMI=m
>> CONFIG_PPC_PMI=m
>> CONFIG_CBE_CPUFREQ_SPU_GOVERNOR=m
>> CONFIG_OPROFILE_CELL=y
>> # CONFIG_PQ2ADS is not set
>> CONFIG_PPC_NATIVE=y
>> CONFIG_PPC_OF_BOOT_TRAMPOLINE=y
>> CONFIG_UDBG_RTAS_CONSOLE=y
>> CONFIG_PPC_UDBG_BEAT=y
>> CONFIG_XICS=y
>> # CONFIG_IPIC is not set
>> CONFIG_MPIC=y
>> # CONFIG_MPIC_WEIRD is not set
>> CONFIG_PPC_I8259=y
>> CONFIG_U3_DART=y
>> CONFIG_PPC_RTAS=y
>> CONFIG_RTAS_ERROR_LOGGING=y
>> CONFIG_RTAS_PROC=y
>> CONFIG_RTAS_FLASH=m
>> CONFIG_MMIO_NVRAM=y
>> CONFIG_MPIC_U3_HT_IRQS=y
>> CONFIG_MPIC_BROKEN_REGREAD=y
>> CONFIG_IBMVIO=y
>> CONFIG_IBMEBUS=y
>> # CONFIG_PPC_MPC106 is not set
>> CONFIG_PPC_970_NAP=y
>> CONFIG_PPC_INDIRECT_IO=y
>> CONFIG_GENERIC_IOMAP=y
>> CONFIG_CPU_FREQ=y
>> CONFIG_CPU_FREQ_TABLE=y
>> CONFIG_CPU_FREQ_DEBUG=y
>> CONFIG_CPU_FREQ_STAT=m
>> CONFIG_CPU_FREQ_STAT_DETAILS=y
>> CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y
>> # CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE is not set
>> # CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set
>> # CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND is not set
>> # CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE is not set
>> CONFIG_CPU_FREQ_GOV_PERFORMANCE=y
>> CONFIG_CPU_FREQ_GOV_POWERSAVE=m
>> CONFIG_CPU_FREQ_GOV_USERSPACE=m
>> CONFIG_CPU_FREQ_GOV_ONDEMAND=m
>> CONFIG_CPU_FREQ_GOV_CONSERVATIVE=m
>>
>> #
>> # CPU Frequency drivers
>> #
>> CONFIG_CPU_FREQ_PMAC64=y
>> CONFIG_PPC_PASEMI_CPUFREQ=y
>> CONFIG_AXON_RAM=m
>> # CONFIG_FSL_ULI1575 is not set
>> CONFIG_SIMPLE_GPIO=y
>>
>> #
>> # Kernel options
>> #
>> CONFIG_TICK_ONESHOT=y
>> CONFIG_NO_HZ=y
>> CONFIG_HIGH_RES_TIMERS=y
>> CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
>> # CONFIG_HZ_100 is not set
>> CONFIG_HZ_250=y
>> # CONFIG_HZ_300 is not set
>> # CONFIG_HZ_1000 is not set
>> CONFIG_HZ=250
>> CONFIG_SCHED_HRTICK=y
>> CONFIG_PREEMPT_NONE=y
>> # CONFIG_PREEMPT_VOLUNTARY is not set
>> # CONFIG_PREEMPT is not set
>> CONFIG_BINFMT_ELF=y
>> CONFIG_COMPAT_BINFMT_ELF=y
>> CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS=y
>> # CONFIG_HAVE_AOUT is not set
>> CONFIG_BINFMT_MISC=m
>> CONFIG_HUGETLB_PAGE_SIZE_VARIABLE=y
>> CONFIG_IOMMU_VMERGE=y
>> CONFIG_IOMMU_HELPER=y
>> CONFIG_SWIOTLB=y
>> CONFIG_HOTPLUG_CPU=y
>> CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
>> CONFIG_ARCH_HAS_WALK_MEMORY=y
>> CONFIG_ARCH_ENABLE_MEMORY_HOTREMOVE=y
>> CONFIG_KEXEC=y
>> CONFIG_CRASH_DUMP=y
>> CONFIG_PHYP_DUMP=y
>> CONFIG_IRQ_ALL_CPUS=y
>> CONFIG_NUMA=y
>> CONFIG_NODES_SHIFT=8
>> CONFIG_MAX_ACTIVE_REGIONS=256
>> CONFIG_ARCH_SELECT_MEMORY_MODEL=y
>> CONFIG_ARCH_SPARSEMEM_ENABLE=y
>> CONFIG_ARCH_SPARSEMEM_DEFAULT=y
>> CONFIG_ARCH_POPULATES_NODE_MAP=y
>> CONFIG_SELECT_MEMORY_MODEL=y
>> # CONFIG_FLATMEM_MANUAL is not set
>> # CONFIG_DISCONTIGMEM_MANUAL is not set
>> CONFIG_SPARSEMEM_MANUAL=y
>> CONFIG_SPARSEMEM=y
>> CONFIG_NEED_MULTIPLE_NODES=y
>> CONFIG_HAVE_MEMORY_PRESENT=y
>> CONFIG_SPARSEMEM_EXTREME=y
>> CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y
>> CONFIG_SPARSEMEM_VMEMMAP=y
>> CONFIG_MEMORY_HOTPLUG=y
>>
>> #
>> # Memory hotplug is currently incompatible with Software Suspend
>> #
>> CONFIG_MEMORY_HOTPLUG_SPARSE=y
>> CONFIG_MEMORY_HOTREMOVE=y
>> CONFIG_PAGEFLAGS_EXTENDED=y
>> CONFIG_SPLIT_PTLOCK_CPUS=4
>> CONFIG_MIGRATION=y
>> CONFIG_PHYS_ADDR_T_64BIT=y
>> CONFIG_ZONE_DMA_FLAG=1
>> CONFIG_BOUNCE=y
>> CONFIG_HAVE_MLOCK=y
>> CONFIG_HAVE_MLOCKED_PAGE_BIT=y
>> CONFIG_KSM=y
>> CONFIG_DEFAULT_MMAP_MIN_ADDR=4096
>> CONFIG_ARCH_MEMORY_PROBE=y
>> CONFIG_NODES_SPAN_OTHER_NODES=y
>> CONFIG_PPC_HAS_HASH_64K=y
>> CONFIG_PPC_4K_PAGES=y
>> # CONFIG_PPC_16K_PAGES is not set
>> # CONFIG_PPC_64K_PAGES is not set
>> # CONFIG_PPC_256K_PAGES is not set
>> CONFIG_FORCE_MAX_ZONEORDER=13
>> CONFIG_SCHED_SMT=y
>> CONFIG_PROC_DEVICETREE=y
>> CONFIG_CMDLINE_BOOL=y
>> CONFIG_CMDLINE="console=ttyS0,9600 console=tty0 root=/dev/sda2"
>> CONFIG_EXTRA_TARGETS=""
>> CONFIG_ARCH_WANTS_FREEZER_CONTROL=y
>> CONFIG_PM=y
>> CONFIG_PM_DEBUG=y
>> CONFIG_PM_ADVANCED_DEBUG=y
>> CONFIG_PM_VERBOSE=y
>> CONFIG_CAN_PM_TRACE=y
>> CONFIG_PM_SLEEP_SMP=y
>> CONFIG_PM_SLEEP=y
>> # CONFIG_PM_SLEEP_ADVANCED_DEBUG is not set
>> CONFIG_SUSPEND=y
>> CONFIG_SUSPEND_FREEZER=y
>> CONFIG_HIBERNATION_NVS=y
>> CONFIG_HIBERNATION=y
>> CONFIG_PM_STD_PARTITION=""
>> CONFIG_PM_RUNTIME=y
>> CONFIG_SECCOMP=y
>> CONFIG_ISA_DMA_API=y
>>
>> #
>> # Bus options
>> #
>> CONFIG_ZONE_DMA=y
>> CONFIG_GENERIC_ISA_DMA=y
>> # CONFIG_PPC_INDIRECT_PCI is not set
>> CONFIG_PPC_PCI_CHOICE=y
>> CONFIG_PCI=y
>> CONFIG_PCI_DOMAINS=y
>> CONFIG_PCI_SYSCALL=y
>> CONFIG_PCIEPORTBUS=y
>> CONFIG_HOTPLUG_PCI_PCIE=m
>> CONFIG_PCIEAER=y
>> CONFIG_PCIE_ECRC=y
>> CONFIG_PCIEAER_INJECT=m
>> CONFIG_PCIEASPM=y
>> CONFIG_PCIEASPM_DEBUG=y
>> CONFIG_ARCH_SUPPORTS_MSI=y
>> CONFIG_PCI_MSI=y
>> CONFIG_PCI_LEGACY=y
>> CONFIG_PCI_DEBUG=y
>> CONFIG_PCI_STUB=m
>> CONFIG_PCI_IOV=y
>> CONFIG_PCCARD=m
>> CONFIG_PCMCIA_DEBUG=y
>> CONFIG_PCMCIA=m
>> CONFIG_PCMCIA_LOAD_CIS=y
>> CONFIG_PCMCIA_IOCTL=y
>> CONFIG_CARDBUS=y
>>
>> #
>> # PC-card bridges
>> #
>> CONFIG_YENTA=m
>> CONFIG_YENTA_O2=y
>> CONFIG_YENTA_RICOH=y
>> CONFIG_YENTA_TI=y
>> CONFIG_YENTA_ENE_TUNE=y
>> CONFIG_YENTA_TOSHIBA=y
>> CONFIG_PD6729=m
>> CONFIG_I82092=m
>> CONFIG_ELECTRA_CF=m
>> CONFIG_PCCARD_NONSTATIC=m
>> CONFIG_HOTPLUG_PCI=m
>> CONFIG_HOTPLUG_PCI_FAKE=m
>> CONFIG_HOTPLUG_PCI_CPCI=y
>> CONFIG_HOTPLUG_PCI_SHPC=m
>> CONFIG_HOTPLUG_PCI_RPA=m
>> CONFIG_HOTPLUG_PCI_RPA_DLPAR=m
>> # CONFIG_HAS_RAPIDIO is not set
>> CONFIG_RELOCATABLE=y
>> CONFIG_PAGE_OFFSET=0xc000000000000000
>> CONFIG_KERNEL_START=0xc000000000000000
>> CONFIG_PHYSICAL_START=0x00000000
>> CONFIG_NET=y
>> CONFIG_COMPAT_NETLINK_MESSAGES=y
>>
>> #
>> # Networking options
>> #
>> CONFIG_PACKET=m
>> CONFIG_PACKET_MMAP=y
>> CONFIG_UNIX=m
>> CONFIG_XFRM=y
>> CONFIG_XFRM_USER=m
>> CONFIG_XFRM_SUB_POLICY=y
>> CONFIG_XFRM_MIGRATE=y
>> CONFIG_XFRM_STATISTICS=y
>> CONFIG_XFRM_IPCOMP=m
>> CONFIG_NET_KEY=m
>> CONFIG_NET_KEY_MIGRATE=y
>> CONFIG_INET=y
>> CONFIG_IP_MULTICAST=y
>> CONFIG_IP_ADVANCED_ROUTER=y
>> CONFIG_ASK_IP_FIB_HASH=y
>> # CONFIG_IP_FIB_TRIE is not set
>> CONFIG_IP_FIB_HASH=y
>> CONFIG_IP_MULTIPLE_TABLES=y
>> CONFIG_IP_ROUTE_MULTIPATH=y
>> CONFIG_IP_ROUTE_VERBOSE=y
>> CONFIG_IP_PNP=y
>> CONFIG_IP_PNP_DHCP=y
>> CONFIG_IP_PNP_BOOTP=y
>> CONFIG_IP_PNP_RARP=y
>> CONFIG_NET_IPIP=m
>> CONFIG_NET_IPGRE=m
>> CONFIG_NET_IPGRE_BROADCAST=y
>> CONFIG_IP_MROUTE=y
>> CONFIG_IP_PIMSM_V1=y
>> CONFIG_IP_PIMSM_V2=y
>> CONFIG_ARPD=y
>> CONFIG_SYN_COOKIES=y
>> CONFIG_INET_AH=m
>> CONFIG_INET_ESP=m
>> CONFIG_INET_IPCOMP=m
>> CONFIG_INET_XFRM_TUNNEL=m
>> CONFIG_INET_TUNNEL=m
>> CONFIG_INET_XFRM_MODE_TRANSPORT=m
>> CONFIG_INET_XFRM_MODE_TUNNEL=m
>> CONFIG_INET_XFRM_MODE_BEET=m
>> CONFIG_INET_LRO=y
>> CONFIG_INET_DIAG=m
>> CONFIG_INET_TCP_DIAG=m
>> CONFIG_TCP_CONG_ADVANCED=y
>> CONFIG_TCP_CONG_BIC=m
>> CONFIG_TCP_CONG_CUBIC=m
>> CONFIG_TCP_CONG_WESTWOOD=m
>> CONFIG_TCP_CONG_HTCP=m
>> CONFIG_TCP_CONG_HSTCP=m
>> CONFIG_TCP_CONG_HYBLA=m
>> CONFIG_TCP_CONG_VEGAS=m
>> CONFIG_TCP_CONG_SCALABLE=m
>> CONFIG_TCP_CONG_LP=m
>> CONFIG_TCP_CONG_VENO=m
>> CONFIG_TCP_CONG_YEAH=m
>> CONFIG_TCP_CONG_ILLINOIS=m
>> # CONFIG_DEFAULT_BIC is not set
>> # CONFIG_DEFAULT_CUBIC is not set
>> # CONFIG_DEFAULT_HTCP is not set
>> # CONFIG_DEFAULT_VEGAS is not set
>> # CONFIG_DEFAULT_WESTWOOD is not set
>> CONFIG_DEFAULT_RENO=y
>> CONFIG_DEFAULT_TCP_CONG="reno"
>> CONFIG_TCP_MD5SIG=y
>> CONFIG_IPV6=m
>> CONFIG_IPV6_PRIVACY=y
>> CONFIG_IPV6_ROUTER_PREF=y
>> CONFIG_IPV6_ROUTE_INFO=y
>> CONFIG_IPV6_OPTIMISTIC_DAD=y
>> CONFIG_INET6_AH=m
>> CONFIG_INET6_ESP=m
>> CONFIG_INET6_IPCOMP=m
>> CONFIG_IPV6_MIP6=m
>> CONFIG_INET6_XFRM_TUNNEL=m
>> CONFIG_INET6_TUNNEL=m
>> CONFIG_INET6_XFRM_MODE_TRANSPORT=m
>> CONFIG_INET6_XFRM_MODE_TUNNEL=m
>> CONFIG_INET6_XFRM_MODE_BEET=m
>> CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION=m
>> CONFIG_IPV6_SIT=m
>> CONFIG_IPV6_SIT_6RD=y
>> CONFIG_IPV6_NDISC_NODETYPE=y
>> CONFIG_IPV6_TUNNEL=m
>> CONFIG_IPV6_MULTIPLE_TABLES=y
>> CONFIG_IPV6_SUBTREES=y
>> CONFIG_IPV6_MROUTE=y
>> CONFIG_IPV6_PIMSM_V2=y
>> CONFIG_NETLABEL=y
>> CONFIG_NETWORK_SECMARK=y
>> CONFIG_NETFILTER=y
>> CONFIG_NETFILTER_DEBUG=y
>> CONFIG_NETFILTER_ADVANCED=y
>> CONFIG_BRIDGE_NETFILTER=y
>>
>> #
>> # Core Netfilter Configuration
>> #
>> CONFIG_NETFILTER_NETLINK=m
>> CONFIG_NETFILTER_NETLINK_QUEUE=m
>> CONFIG_NETFILTER_NETLINK_LOG=m
>> CONFIG_NF_CONNTRACK=m
>> CONFIG_NF_CT_ACCT=y
>> CONFIG_NF_CONNTRACK_MARK=y
>> CONFIG_NF_CONNTRACK_SECMARK=y
>> CONFIG_NF_CONNTRACK_EVENTS=y
>> CONFIG_NF_CT_PROTO_DCCP=m
>> CONFIG_NF_CT_PROTO_GRE=m
>> CONFIG_NF_CT_PROTO_SCTP=m
>> CONFIG_NF_CT_PROTO_UDPLITE=m
>> CONFIG_NF_CONNTRACK_AMANDA=m
>> CONFIG_NF_CONNTRACK_FTP=m
>> CONFIG_NF_CONNTRACK_H323=m
>> CONFIG_NF_CONNTRACK_IRC=m
>> CONFIG_NF_CONNTRACK_NETBIOS_NS=m
>> CONFIG_NF_CONNTRACK_PPTP=m
>> CONFIG_NF_CONNTRACK_SANE=m
>> CONFIG_NF_CONNTRACK_SIP=m
>> CONFIG_NF_CONNTRACK_TFTP=m
>> CONFIG_NF_CT_NETLINK=m
>> CONFIG_NETFILTER_TPROXY=m
>> CONFIG_NETFILTER_XTABLES=m
>> CONFIG_NETFILTER_XT_TARGET_CLASSIFY=m
>> CONFIG_NETFILTER_XT_TARGET_CONNMARK=m
>> CONFIG_NETFILTER_XT_TARGET_CONNSECMARK=m
>> CONFIG_NETFILTER_XT_TARGET_DSCP=m
>> CONFIG_NETFILTER_XT_TARGET_HL=m
>> CONFIG_NETFILTER_XT_TARGET_LED=m
>> CONFIG_NETFILTER_XT_TARGET_MARK=m
>> CONFIG_NETFILTER_XT_TARGET_NFLOG=m
>> CONFIG_NETFILTER_XT_TARGET_NFQUEUE=m
>> CONFIG_NETFILTER_XT_TARGET_NOTRACK=m
>> CONFIG_NETFILTER_XT_TARGET_RATEEST=m
>> CONFIG_NETFILTER_XT_TARGET_TPROXY=m
>> CONFIG_NETFILTER_XT_TARGET_TRACE=m
>> CONFIG_NETFILTER_XT_TARGET_SECMARK=m
>> CONFIG_NETFILTER_XT_TARGET_TCPMSS=m
>> CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP=m
>> CONFIG_NETFILTER_XT_MATCH_CLUSTER=m
>> CONFIG_NETFILTER_XT_MATCH_COMMENT=m
>> CONFIG_NETFILTER_XT_MATCH_CONNBYTES=m
>> CONFIG_NETFILTER_XT_MATCH_CONNLIMIT=m
>> CONFIG_NETFILTER_XT_MATCH_CONNMARK=m
>> CONFIG_NETFILTER_XT_MATCH_CONNTRACK=m
>> CONFIG_NETFILTER_XT_MATCH_DCCP=m
>> CONFIG_NETFILTER_XT_MATCH_DSCP=m
>> CONFIG_NETFILTER_XT_MATCH_ESP=m
>> CONFIG_NETFILTER_XT_MATCH_HASHLIMIT=m
>> CONFIG_NETFILTER_XT_MATCH_HELPER=m
>> CONFIG_NETFILTER_XT_MATCH_HL=m
>> CONFIG_NETFILTER_XT_MATCH_IPRANGE=m
>> CONFIG_NETFILTER_XT_MATCH_LENGTH=m
>> CONFIG_NETFILTER_XT_MATCH_LIMIT=m
>> CONFIG_NETFILTER_XT_MATCH_MAC=m
>> CONFIG_NETFILTER_XT_MATCH_MARK=m
>> CONFIG_NETFILTER_XT_MATCH_MULTIPORT=m
>> CONFIG_NETFILTER_XT_MATCH_OWNER=m
>> CONFIG_NETFILTER_XT_MATCH_POLICY=m
>> CONFIG_NETFILTER_XT_MATCH_PHYSDEV=m
>> CONFIG_NETFILTER_XT_MATCH_PKTTYPE=m
>> CONFIG_NETFILTER_XT_MATCH_QUOTA=m
>> CONFIG_NETFILTER_XT_MATCH_RATEEST=m
>> CONFIG_NETFILTER_XT_MATCH_REALM=m
>> CONFIG_NETFILTER_XT_MATCH_RECENT=m
>> CONFIG_NETFILTER_XT_MATCH_RECENT_PROC_COMPAT=y
>> CONFIG_NETFILTER_XT_MATCH_SCTP=m
>> CONFIG_NETFILTER_XT_MATCH_SOCKET=m
>> CONFIG_NETFILTER_XT_MATCH_STATE=m
>> CONFIG_NETFILTER_XT_MATCH_STATISTIC=m
>> CONFIG_NETFILTER_XT_MATCH_STRING=m
>> CONFIG_NETFILTER_XT_MATCH_TCPMSS=m
>> CONFIG_NETFILTER_XT_MATCH_TIME=m
>> CONFIG_NETFILTER_XT_MATCH_U32=m
>> CONFIG_NETFILTER_XT_MATCH_OSF=m
>> CONFIG_IP_VS=m
>> CONFIG_IP_VS_IPV6=y
>> CONFIG_IP_VS_DEBUG=y
>> CONFIG_IP_VS_TAB_BITS=12
>>
>> #
>> # IPVS transport protocol load balancing support
>> #
>> CONFIG_IP_VS_PROTO_TCP=y
>> CONFIG_IP_VS_PROTO_UDP=y
>> CONFIG_IP_VS_PROTO_AH_ESP=y
>> CONFIG_IP_VS_PROTO_ESP=y
>> CONFIG_IP_VS_PROTO_AH=y
>>
>> #
>> # IPVS scheduler
>> #
>> CONFIG_IP_VS_RR=m
>> CONFIG_IP_VS_WRR=m
>> CONFIG_IP_VS_LC=m
>> CONFIG_IP_VS_WLC=m
>> CONFIG_IP_VS_LBLC=m
>> CONFIG_IP_VS_LBLCR=m
>> CONFIG_IP_VS_DH=m
>> CONFIG_IP_VS_SH=m
>> CONFIG_IP_VS_SED=m
>> CONFIG_IP_VS_NQ=m
>>
>> #
>> # IPVS application helper
>> #
>> CONFIG_IP_VS_FTP=m
>>
>> #
>> # IP: Netfilter Configuration
>> #
>> CONFIG_NF_DEFRAG_IPV4=m
>> CONFIG_NF_CONNTRACK_IPV4=m
>> CONFIG_NF_CONNTRACK_PROC_COMPAT=y
>> CONFIG_IP_NF_QUEUE=m
>> CONFIG_IP_NF_IPTABLES=m
>> CONFIG_IP_NF_MATCH_ADDRTYPE=m
>> CONFIG_IP_NF_MATCH_AH=m
>> CONFIG_IP_NF_MATCH_ECN=m
>> CONFIG_IP_NF_MATCH_TTL=m
>> CONFIG_IP_NF_FILTER=m
>> CONFIG_IP_NF_TARGET_REJECT=m
>> CONFIG_IP_NF_TARGET_LOG=m
>> CONFIG_IP_NF_TARGET_ULOG=m
>> CONFIG_NF_NAT=m
>> CONFIG_NF_NAT_NEEDED=y
>> CONFIG_IP_NF_TARGET_MASQUERADE=m
>> CONFIG_IP_NF_TARGET_NETMAP=m
>> CONFIG_IP_NF_TARGET_REDIRECT=m
>> CONFIG_NF_NAT_SNMP_BASIC=m
>> CONFIG_NF_NAT_PROTO_DCCP=m
>> CONFIG_NF_NAT_PROTO_GRE=m
>> CONFIG_NF_NAT_PROTO_UDPLITE=m
>> CONFIG_NF_NAT_PROTO_SCTP=m
>> CONFIG_NF_NAT_FTP=m
>> CONFIG_NF_NAT_IRC=m
>> CONFIG_NF_NAT_TFTP=m
>> CONFIG_NF_NAT_AMANDA=m
>> CONFIG_NF_NAT_PPTP=m
>> CONFIG_NF_NAT_H323=m
>> CONFIG_NF_NAT_SIP=m
>> CONFIG_IP_NF_MANGLE=m
>> CONFIG_IP_NF_TARGET_CLUSTERIP=m
>> CONFIG_IP_NF_TARGET_ECN=m
>> CONFIG_IP_NF_TARGET_TTL=m
>> CONFIG_IP_NF_RAW=m
>> CONFIG_IP_NF_SECURITY=m
>> CONFIG_IP_NF_ARPTABLES=m
>> CONFIG_IP_NF_ARPFILTER=m
>> CONFIG_IP_NF_ARP_MANGLE=m
>>
>> #
>> # IPv6: Netfilter Configuration
>> #
>> CONFIG_NF_CONNTRACK_IPV6=m
>> CONFIG_IP6_NF_QUEUE=m
>> CONFIG_IP6_NF_IPTABLES=m
>> CONFIG_IP6_NF_MATCH_AH=m
>> CONFIG_IP6_NF_MATCH_EUI64=m
>> CONFIG_IP6_NF_MATCH_FRAG=m
>> CONFIG_IP6_NF_MATCH_OPTS=m
>> CONFIG_IP6_NF_MATCH_HL=m
>> CONFIG_IP6_NF_MATCH_IPV6HEADER=m
>> CONFIG_IP6_NF_MATCH_MH=m
>> CONFIG_IP6_NF_MATCH_RT=m
>> CONFIG_IP6_NF_TARGET_HL=m
>> CONFIG_IP6_NF_TARGET_LOG=m
>> CONFIG_IP6_NF_FILTER=m
>> CONFIG_IP6_NF_TARGET_REJECT=m
>> CONFIG_IP6_NF_MANGLE=m
>> CONFIG_IP6_NF_RAW=m
>> CONFIG_IP6_NF_SECURITY=m
>>
>> #
>> # DECnet: Netfilter Configuration
>> #
>> CONFIG_DECNET_NF_GRABULATOR=m
>> CONFIG_BRIDGE_NF_EBTABLES=m
>> CONFIG_BRIDGE_EBT_BROUTE=m
>> CONFIG_BRIDGE_EBT_T_FILTER=m
>> CONFIG_BRIDGE_EBT_T_NAT=m
>> CONFIG_BRIDGE_EBT_802_3=m
>> CONFIG_BRIDGE_EBT_AMONG=m
>> CONFIG_BRIDGE_EBT_ARP=m
>> CONFIG_BRIDGE_EBT_IP=m
>> CONFIG_BRIDGE_EBT_IP6=m
>> CONFIG_BRIDGE_EBT_LIMIT=m
>> CONFIG_BRIDGE_EBT_MARK=m
>> CONFIG_BRIDGE_EBT_PKTTYPE=m
>> CONFIG_BRIDGE_EBT_STP=m
>> CONFIG_BRIDGE_EBT_VLAN=m
>> CONFIG_BRIDGE_EBT_ARPREPLY=m
>> CONFIG_BRIDGE_EBT_DNAT=m
>> CONFIG_BRIDGE_EBT_MARK_T=m
>> CONFIG_BRIDGE_EBT_REDIRECT=m
>> CONFIG_BRIDGE_EBT_SNAT=m
>> CONFIG_BRIDGE_EBT_LOG=m
>> CONFIG_BRIDGE_EBT_ULOG=m
>> CONFIG_BRIDGE_EBT_NFLOG=m
>> CONFIG_IP_DCCP=m
>> CONFIG_INET_DCCP_DIAG=m
>>
>> #
>> # DCCP CCIDs Configuration (EXPERIMENTAL)
>> #
>> CONFIG_IP_DCCP_CCID2_DEBUG=y
>> CONFIG_IP_DCCP_CCID3=y
>> CONFIG_IP_DCCP_CCID3_DEBUG=y
>> CONFIG_IP_DCCP_CCID3_RTO=100
>> CONFIG_IP_DCCP_TFRC_LIB=y
>> CONFIG_IP_DCCP_TFRC_DEBUG=y
>>
>> #
>> # DCCP Kernel Hacking
>> #
>> CONFIG_IP_DCCP_DEBUG=y
>> CONFIG_NET_DCCPPROBE=m
>> CONFIG_IP_SCTP=m
>> CONFIG_SCTP_DBG_MSG=y
>> CONFIG_SCTP_DBG_OBJCNT=y
>> # CONFIG_SCTP_HMAC_NONE is not set
>> # CONFIG_SCTP_HMAC_SHA1 is not set
>> CONFIG_SCTP_HMAC_MD5=y
>> CONFIG_RDS=m
>> CONFIG_RDS_RDMA=m
>> CONFIG_RDS_TCP=m
>> CONFIG_RDS_DEBUG=y
>> CONFIG_TIPC=m
>> CONFIG_TIPC_ADVANCED=y
>> CONFIG_TIPC_ZONES=3
>> CONFIG_TIPC_CLUSTERS=1
>> CONFIG_TIPC_NODES=255
>> CONFIG_TIPC_SLAVE_NODES=0
>> CONFIG_TIPC_PORTS=8191
>> CONFIG_TIPC_LOG=0
>> CONFIG_TIPC_DEBUG=y
>> CONFIG_ATM=m
>> CONFIG_ATM_CLIP=m
>> CONFIG_ATM_CLIP_NO_ICMP=y
>> CONFIG_ATM_LANE=m
>> CONFIG_ATM_MPOA=m
>> CONFIG_ATM_BR2684=m
>> CONFIG_ATM_BR2684_IPFILTER=y
>> CONFIG_STP=m
>> CONFIG_GARP=m
>> CONFIG_BRIDGE=m
>> CONFIG_NET_DSA=y
>> CONFIG_NET_DSA_TAG_DSA=y
>> CONFIG_NET_DSA_TAG_EDSA=y
>> CONFIG_NET_DSA_TAG_TRAILER=y
>> CONFIG_NET_DSA_MV88E6XXX=y
>> CONFIG_NET_DSA_MV88E6060=y
>> CONFIG_NET_DSA_MV88E6XXX_NEED_PPU=y
>> CONFIG_NET_DSA_MV88E6131=y
>> CONFIG_NET_DSA_MV88E6123_61_65=y
>> CONFIG_VLAN_8021Q=m
>> CONFIG_VLAN_8021Q_GVRP=y
>> CONFIG_DECNET=m
>> CONFIG_DECNET_ROUTER=y
>> CONFIG_LLC=m
>> CONFIG_LLC2=m
>> CONFIG_IPX=m
>> CONFIG_IPX_INTERN=y
>> CONFIG_ATALK=m
>> CONFIG_DEV_APPLETALK=m
>> CONFIG_IPDDP=m
>> CONFIG_IPDDP_ENCAP=y
>> CONFIG_IPDDP_DECAP=y
>> CONFIG_X25=m
>> CONFIG_LAPB=m
>> CONFIG_ECONET=m
>> CONFIG_ECONET_AUNUDP=y
>> CONFIG_ECONET_NATIVE=y
>> CONFIG_WAN_ROUTER=m
>> CONFIG_PHONET=m
>> CONFIG_IEEE802154=m
>> CONFIG_NET_SCHED=y
>>
>> #
>> # Queueing/Scheduling
>> #
>> CONFIG_NET_SCH_CBQ=m
>> CONFIG_NET_SCH_HTB=m
>> CONFIG_NET_SCH_HFSC=m
>> CONFIG_NET_SCH_ATM=m
>> CONFIG_NET_SCH_PRIO=m
>> CONFIG_NET_SCH_MULTIQ=m
>> CONFIG_NET_SCH_RED=m
>> CONFIG_NET_SCH_SFQ=m
>> CONFIG_NET_SCH_TEQL=m
>> CONFIG_NET_SCH_TBF=m
>> CONFIG_NET_SCH_GRED=m
>> CONFIG_NET_SCH_DSMARK=m
>> CONFIG_NET_SCH_NETEM=m
>> CONFIG_NET_SCH_DRR=m
>> CONFIG_NET_SCH_INGRESS=m
>>
>> #
>> # Classification
>> #
>> CONFIG_NET_CLS=y
>> CONFIG_NET_CLS_BASIC=m
>> CONFIG_NET_CLS_TCINDEX=m
>> CONFIG_NET_CLS_ROUTE4=m
>> CONFIG_NET_CLS_ROUTE=y
>> CONFIG_NET_CLS_FW=m
>> CONFIG_NET_CLS_U32=m
>> CONFIG_CLS_U32_PERF=y
>> CONFIG_CLS_U32_MARK=y
>> CONFIG_NET_CLS_RSVP=m
>> CONFIG_NET_CLS_RSVP6=m
>> CONFIG_NET_CLS_FLOW=m
>> CONFIG_NET_CLS_CGROUP=y
>> CONFIG_NET_EMATCH=y
>> CONFIG_NET_EMATCH_STACK=32
>> CONFIG_NET_EMATCH_CMP=m
>> CONFIG_NET_EMATCH_NBYTE=m
>> CONFIG_NET_EMATCH_U32=m
>> CONFIG_NET_EMATCH_META=m
>> CONFIG_NET_EMATCH_TEXT=m
>> CONFIG_NET_CLS_ACT=y
>> CONFIG_NET_ACT_POLICE=m
>> CONFIG_NET_ACT_GACT=m
>> CONFIG_GACT_PROB=y
>> CONFIG_NET_ACT_MIRRED=m
>> CONFIG_NET_ACT_IPT=m
>> CONFIG_NET_ACT_NAT=m
>> CONFIG_NET_ACT_PEDIT=m
>> CONFIG_NET_ACT_SIMP=m
>> CONFIG_NET_ACT_SKBEDIT=m
>> CONFIG_NET_CLS_IND=y
>> CONFIG_NET_SCH_FIFO=y
>> CONFIG_DCB=y
>>
>> #
>> # Network testing
>> #
>> CONFIG_NET_PKTGEN=m
>> CONFIG_NET_TCPPROBE=m
>> CONFIG_NET_DROP_MONITOR=y
>> CONFIG_HAMRADIO=y
>>
>> #
>> # Packet Radio protocols
>> #
>> CONFIG_AX25=m
>> CONFIG_AX25_DAMA_SLAVE=y
>> CONFIG_NETROM=m
>> CONFIG_ROSE=m
>>
>> #
>> # AX.25 network device drivers
>> #
>> CONFIG_MKISS=m
>> CONFIG_6PACK=m
>> CONFIG_BPQETHER=m
>> CONFIG_BAYCOM_SER_FDX=m
>> CONFIG_BAYCOM_SER_HDX=m
>> CONFIG_BAYCOM_PAR=m
>> CONFIG_YAM=m
>> CONFIG_CAN=m
>> CONFIG_CAN_RAW=m
>> CONFIG_CAN_BCM=m
>>
>> #
>> # CAN Device Drivers
>> #
>> CONFIG_CAN_VCAN=m
>> CONFIG_CAN_DEV=m
>> CONFIG_CAN_CALC_BITTIMING=y
>> CONFIG_CAN_SJA1000=m
>> CONFIG_CAN_SJA1000_PLATFORM=m
>> CONFIG_CAN_SJA1000_OF_PLATFORM=m
>> CONFIG_CAN_EMS_PCI=m
>> CONFIG_CAN_EMS_USB=m
>> CONFIG_CAN_KVASER_PCI=m
>> CONFIG_CAN_DEBUG_DEVICES=y
>> CONFIG_IRDA=m
>>
>> #
>> # IrDA protocols
>> #
>> CONFIG_IRLAN=m
>> CONFIG_IRNET=m
>> CONFIG_IRCOMM=m
>> CONFIG_IRDA_ULTRA=y
>>
>> #
>> # IrDA options
>> #
>> CONFIG_IRDA_CACHE_LAST_LSAP=y
>> CONFIG_IRDA_FAST_RR=y
>> CONFIG_IRDA_DEBUG=y
>>
>> #
>> # Infrared-port device drivers
>> #
>>
>> #
>> # SIR device drivers
>> #
>> CONFIG_IRTTY_SIR=m
>>
>> #
>> # Dongle support
>> #
>> CONFIG_DONGLE=y
>> CONFIG_ESI_DONGLE=m
>> CONFIG_ACTISYS_DONGLE=m
>> CONFIG_TEKRAM_DONGLE=m
>> CONFIG_TOIM3232_DONGLE=m
>> CONFIG_LITELINK_DONGLE=m
>> CONFIG_MA600_DONGLE=m
>> CONFIG_GIRBIL_DONGLE=m
>> CONFIG_MCP2120_DONGLE=m
>> CONFIG_OLD_BELKIN_DONGLE=m
>> CONFIG_ACT200L_DONGLE=m
>> CONFIG_KINGSUN_DONGLE=m
>> CONFIG_KSDAZZLE_DONGLE=m
>> CONFIG_KS959_DONGLE=m
>>
>> #
>> # FIR device drivers
>> #
>> CONFIG_USB_IRDA=m
>> CONFIG_SIGMATEL_FIR=m
>> CONFIG_NSC_FIR=m
>> CONFIG_WINBOND_FIR=m
>> CONFIG_SMC_IRCC_FIR=m
>> CONFIG_ALI_FIR=m
>> CONFIG_VLSI_FIR=m
>> CONFIG_VIA_FIR=m
>> CONFIG_MCS_FIR=m
>> CONFIG_BT=m
>> CONFIG_BT_L2CAP=m
>> CONFIG_BT_SCO=m
>> CONFIG_BT_RFCOMM=m
>> CONFIG_BT_RFCOMM_TTY=y
>> CONFIG_BT_BNEP=m
>> CONFIG_BT_BNEP_MC_FILTER=y
>> CONFIG_BT_BNEP_PROTO_FILTER=y
>> CONFIG_BT_CMTP=m
>> CONFIG_BT_HIDP=m
>>
>> #
>> # Bluetooth device drivers
>> #
>> CONFIG_BT_HCIBTUSB=m
>> CONFIG_BT_HCIBTSDIO=m
>> CONFIG_BT_HCIUART=m
>> CONFIG_BT_HCIUART_H4=y
>> CONFIG_BT_HCIUART_BCSP=y
>> CONFIG_BT_HCIUART_LL=y
>> CONFIG_BT_HCIBCM203X=m
>> CONFIG_BT_HCIBPA10X=m
>> CONFIG_BT_HCIBFUSB=m
>> CONFIG_BT_HCIDTL1=m
>> CONFIG_BT_HCIBT3C=m
>> CONFIG_BT_HCIBLUECARD=m
>> CONFIG_BT_HCIBTUART=m
>> CONFIG_BT_HCIVHCI=m
>> CONFIG_BT_MRVL=m
>> CONFIG_BT_MRVL_SDIO=m
>> CONFIG_AF_RXRPC=m
>> CONFIG_AF_RXRPC_DEBUG=y
>> CONFIG_RXKAD=m
>> CONFIG_FIB_RULES=y
>> CONFIG_WIRELESS=y
>> CONFIG_WIRELESS_EXT=y
>> CONFIG_WEXT_CORE=y
>> CONFIG_WEXT_PROC=y
>> CONFIG_WEXT_SPY=y
>> CONFIG_WEXT_PRIV=y
>> CONFIG_CFG80211=m
>> CONFIG_NL80211_TESTMODE=y
>> CONFIG_CFG80211_DEVELOPER_WARNINGS=y
>> CONFIG_CFG80211_REG_DEBUG=y
>> CONFIG_CFG80211_DEFAULT_PS_VALUE=1
>> CONFIG_CFG80211_DEFAULT_PS=y
>> CONFIG_CFG80211_DEBUGFS=y
>> CONFIG_WIRELESS_OLD_REGULATORY=y
>> CONFIG_CFG80211_WEXT=y
>> CONFIG_WIRELESS_EXT_SYSFS=y
>> CONFIG_LIB80211=m
>> CONFIG_LIB80211_CRYPT_WEP=m
>> CONFIG_LIB80211_CRYPT_CCMP=m
>> CONFIG_LIB80211_CRYPT_TKIP=m
>> CONFIG_LIB80211_DEBUG=y
>> CONFIG_MAC80211=m
>> CONFIG_MAC80211_RC_PID=y
>> CONFIG_MAC80211_RC_MINSTREL=y
>> # CONFIG_MAC80211_RC_DEFAULT_PID is not set
>> CONFIG_MAC80211_RC_DEFAULT_MINSTREL=y
>> CONFIG_MAC80211_RC_DEFAULT="minstrel"
>> CONFIG_MAC80211_MESH=y
>> CONFIG_MAC80211_LEDS=y
>> CONFIG_MAC80211_DEBUGFS=y
>> CONFIG_MAC80211_DEBUG_MENU=y
>> CONFIG_MAC80211_DEBUG_PACKET_ALIGNMENT=y
>> CONFIG_MAC80211_NOINLINE=y
>> CONFIG_MAC80211_VERBOSE_DEBUG=y
>> CONFIG_MAC80211_HT_DEBUG=y
>> CONFIG_MAC80211_TKIP_DEBUG=y
>> CONFIG_MAC80211_IBSS_DEBUG=y
>> CONFIG_MAC80211_VERBOSE_PS_DEBUG=y
>> CONFIG_MAC80211_VERBOSE_MPL_DEBUG=y
>> CONFIG_MAC80211_DEBUG_COUNTERS=y
>> CONFIG_MAC80211_DRIVER_API_TRACER=y
>> CONFIG_WIMAX=m
>> CONFIG_WIMAX_DEBUG_LEVEL=8
>> CONFIG_RFKILL=m
>> CONFIG_RFKILL_LEDS=y
>> CONFIG_RFKILL_INPUT=y
>> CONFIG_NET_9P=m
>> CONFIG_NET_9P_VIRTIO=m
>> CONFIG_NET_9P_RDMA=m
>> CONFIG_NET_9P_DEBUG=y
>>
>> #
>> # Device Drivers
>> #
>>
>> #
>> # Generic Driver Options
>> #
>> CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
>> CONFIG_DEVTMPFS=y
>> CONFIG_DEVTMPFS_MOUNT=y
>> CONFIG_STANDALONE=y
>> CONFIG_PREVENT_FIRMWARE_BUILD=y
>> CONFIG_FW_LOADER=m
>> CONFIG_FIRMWARE_IN_KERNEL=y
>> CONFIG_EXTRA_FIRMWARE=""
>> CONFIG_DEBUG_DRIVER=y
>> CONFIG_DEBUG_DEVRES=y
>> # CONFIG_SYS_HYPERVISOR is not set
>> CONFIG_CONNECTOR=m
>> CONFIG_MTD=m
>> CONFIG_MTD_DEBUG=y
>> CONFIG_MTD_DEBUG_VERBOSE=0
>> CONFIG_MTD_TESTS=m
>> CONFIG_MTD_CONCAT=m
>> CONFIG_MTD_PARTITIONS=y
>> CONFIG_MTD_REDBOOT_PARTS=m
>> CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK=-1
>> CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED=y
>> CONFIG_MTD_REDBOOT_PARTS_READONLY=y
>> CONFIG_MTD_OF_PARTS=m
>> CONFIG_MTD_AR7_PARTS=m
>>
>> #
>> # User Modules And Translation Layers
>> #
>> CONFIG_MTD_CHAR=m
>> CONFIG_HAVE_MTD_OTP=y
>> CONFIG_MTD_BLKDEVS=m
>> CONFIG_MTD_BLOCK=m
>> CONFIG_MTD_BLOCK_RO=m
>> CONFIG_FTL=m
>> CONFIG_NFTL=m
>> CONFIG_NFTL_RW=y
>> CONFIG_INFTL=m
>> CONFIG_RFD_FTL=m
>> CONFIG_SSFDC=m
>> CONFIG_MTD_OOPS=m
>>
>> #
>> # RAM/ROM/Flash chip drivers
>> #
>> CONFIG_MTD_CFI=m
>> CONFIG_MTD_JEDECPROBE=m
>> CONFIG_MTD_GEN_PROBE=m
>> CONFIG_MTD_CFI_ADV_OPTIONS=y
>> CONFIG_MTD_CFI_NOSWAP=y
>> # CONFIG_MTD_CFI_BE_BYTE_SWAP is not set
>> # CONFIG_MTD_CFI_LE_BYTE_SWAP is not set
>> CONFIG_MTD_CFI_GEOMETRY=y
>> CONFIG_MTD_MAP_BANK_WIDTH_1=y
>> CONFIG_MTD_MAP_BANK_WIDTH_2=y
>> CONFIG_MTD_MAP_BANK_WIDTH_4=y
>> CONFIG_MTD_MAP_BANK_WIDTH_8=y
>> CONFIG_MTD_MAP_BANK_WIDTH_16=y
>> CONFIG_MTD_MAP_BANK_WIDTH_32=y
>> CONFIG_MTD_CFI_I1=y
>> CONFIG_MTD_CFI_I2=y
>> CONFIG_MTD_CFI_I4=y
>> CONFIG_MTD_CFI_I8=y
>> CONFIG_MTD_OTP=y
>> CONFIG_MTD_CFI_INTELEXT=m
>> CONFIG_MTD_CFI_AMDSTD=m
>> CONFIG_MTD_CFI_STAA=m
>> CONFIG_MTD_CFI_UTIL=m
>> CONFIG_MTD_RAM=m
>> CONFIG_MTD_ROM=m
>> CONFIG_MTD_ABSENT=m
>>
>> #
>> # Mapping drivers for chip access
>> #
>> CONFIG_MTD_COMPLEX_MAPPINGS=y
>> CONFIG_MTD_PHYSMAP=m
>> CONFIG_MTD_PHYSMAP_COMPAT=y
>> CONFIG_MTD_PHYSMAP_START=0x8000000
>> CONFIG_MTD_PHYSMAP_LEN=0
>> CONFIG_MTD_PHYSMAP_BANKWIDTH=2
>> CONFIG_MTD_PHYSMAP_OF=m
>> CONFIG_MTD_PCI=m
>> CONFIG_MTD_GPIO_ADDR=m
>> CONFIG_MTD_INTEL_VR_NOR=m
>> CONFIG_MTD_PLATRAM=m
>>
>> #
>> # Self-contained MTD device drivers
>> #
>> CONFIG_MTD_PMC551=m
>> CONFIG_MTD_PMC551_BUGFIX=y
>> CONFIG_MTD_PMC551_DEBUG=y
>> CONFIG_MTD_DATAFLASH=m
>> CONFIG_MTD_DATAFLASH_WRITE_VERIFY=y
>> CONFIG_MTD_DATAFLASH_OTP=y
>> CONFIG_MTD_M25P80=m
>> CONFIG_M25PXX_USE_FAST_READ=y
>> CONFIG_MTD_SST25L=m
>> CONFIG_MTD_SLRAM=m
>> CONFIG_MTD_PHRAM=m
>> CONFIG_MTD_MTDRAM=m
>> CONFIG_MTDRAM_TOTAL_SIZE=4096
>> CONFIG_MTDRAM_ERASE_SIZE=128
>> CONFIG_MTD_BLOCK2MTD=m
>>
>> #
>> # Disk-On-Chip Device Drivers
>> #
>> CONFIG_MTD_DOC2000=m
>> CONFIG_MTD_DOC2001=m
>> CONFIG_MTD_DOC2001PLUS=m
>> CONFIG_MTD_DOCPROBE=m
>> CONFIG_MTD_DOCECC=m
>> CONFIG_MTD_DOCPROBE_ADVANCED=y
>> CONFIG_MTD_DOCPROBE_ADDRESS=0x0000
>> CONFIG_MTD_DOCPROBE_HIGH=y
>> CONFIG_MTD_DOCPROBE_55AA=y
>> CONFIG_MTD_NAND=m
>> CONFIG_MTD_NAND_VERIFY_WRITE=y
>> CONFIG_MTD_NAND_ECC_SMC=y
>> CONFIG_MTD_NAND_MUSEUM_IDS=y
>> CONFIG_MTD_NAND_IDS=m
>> CONFIG_MTD_NAND_DISKONCHIP=m
>> CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADVANCED=y
>> CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS=0
>> CONFIG_MTD_NAND_DISKONCHIP_PROBE_HIGH=y
>> CONFIG_MTD_NAND_DISKONCHIP_BBTWRITE=y
>> CONFIG_MTD_NAND_CAFE=m
>> CONFIG_MTD_NAND_PASEMI=m
>> CONFIG_MTD_NAND_NANDSIM=m
>> CONFIG_MTD_NAND_PLATFORM=m
>> CONFIG_MTD_ALAUDA=m
>> CONFIG_MTD_NAND_FSL_ELBC=m
>> CONFIG_MTD_ONENAND=m
>> CONFIG_MTD_ONENAND_VERIFY_WRITE=y
>> CONFIG_MTD_ONENAND_GENERIC=m
>> CONFIG_MTD_ONENAND_OTP=y
>> CONFIG_MTD_ONENAND_2X_PROGRAM=y
>> CONFIG_MTD_ONENAND_SIM=m
>>
>> #
>> # LPDDR flash memory drivers
>> #
>> CONFIG_MTD_LPDDR=m
>> CONFIG_MTD_QINFO_PROBE=m
>>
>> #
>> # UBI - Unsorted block images
>> #
>> CONFIG_MTD_UBI=m
>> CONFIG_MTD_UBI_WL_THRESHOLD=4096
>> CONFIG_MTD_UBI_BEB_RESERVE=1
>> CONFIG_MTD_UBI_GLUEBI=m
>>
>> #
>> # UBI debugging options
>> #
>> CONFIG_MTD_UBI_DEBUG=y
>> CONFIG_MTD_UBI_DEBUG_MSG=y
>> CONFIG_MTD_UBI_DEBUG_PARANOID=y
>> CONFIG_MTD_UBI_DEBUG_DISABLE_BGT=y
>> CONFIG_MTD_UBI_DEBUG_EMULATE_BITFLIPS=y
>> CONFIG_MTD_UBI_DEBUG_EMULATE_WRITE_FAILURES=y
>> CONFIG_MTD_UBI_DEBUG_EMULATE_ERASE_FAILURES=y
>>
>> #
>> # Additional UBI debugging messages
>> #
>> CONFIG_MTD_UBI_DEBUG_MSG_BLD=y
>> CONFIG_MTD_UBI_DEBUG_MSG_EBA=y
>> CONFIG_MTD_UBI_DEBUG_MSG_WL=y
>> CONFIG_MTD_UBI_DEBUG_MSG_IO=y
>> CONFIG_OF_DEVICE=y
>> CONFIG_OF_GPIO=y
>> CONFIG_OF_I2C=m
>> CONFIG_OF_SPI=y
>> CONFIG_OF_MDIO=y
>> CONFIG_PARPORT=m
>> CONFIG_PARPORT_PC=m
>> CONFIG_PARPORT_SERIAL=m
>> CONFIG_PARPORT_PC_FIFO=y
>> CONFIG_PARPORT_PC_SUPERIO=y
>> CONFIG_PARPORT_PC_PCMCIA=m
>> # CONFIG_PARPORT_GSC is not set
>> CONFIG_PARPORT_AX88796=m
>> CONFIG_PARPORT_1284=y
>> CONFIG_PARPORT_NOT_PC=y
>> CONFIG_BLK_DEV=y
>> CONFIG_BLK_DEV_FD=m
>> CONFIG_PARIDE=m
>>
>> #
>> # Parallel IDE high-level drivers
>> #
>> CONFIG_PARIDE_PD=m
>> CONFIG_PARIDE_PCD=m
>> CONFIG_PARIDE_PF=m
>> CONFIG_PARIDE_PT=m
>> CONFIG_PARIDE_PG=m
>>
>> #
>> # Parallel IDE protocol modules
>> #
>> CONFIG_PARIDE_ATEN=m
>> CONFIG_PARIDE_BPCK=m
>> CONFIG_PARIDE_COMM=m
>> CONFIG_PARIDE_DSTR=m
>> CONFIG_PARIDE_FIT2=m
>> CONFIG_PARIDE_FIT3=m
>> CONFIG_PARIDE_EPAT=m
>> CONFIG_PARIDE_EPATC8=y
>> CONFIG_PARIDE_EPIA=m
>> CONFIG_PARIDE_FRIQ=m
>> CONFIG_PARIDE_FRPW=m
>> CONFIG_PARIDE_KBIC=m
>> CONFIG_PARIDE_KTTI=m
>> CONFIG_PARIDE_ON20=m
>> CONFIG_PARIDE_ON26=m
>> CONFIG_BLK_CPQ_CISS_DA=m
>> CONFIG_CISS_SCSI_TAPE=y
>> CONFIG_BLK_DEV_DAC960=m
>> CONFIG_BLK_DEV_UMEM=m
>> # CONFIG_BLK_DEV_COW_COMMON is not set
>> CONFIG_BLK_DEV_LOOP=m
>> CONFIG_BLK_DEV_CRYPTOLOOP=m
>>
>> #
>> # DRBD disabled because PROC_FS, INET or CONNECTOR not selected
>> #
>> CONFIG_BLK_DEV_DRBD=m
>> CONFIG_DRBD_FAULT_INJECTION=y
>> CONFIG_BLK_DEV_NBD=m
>> CONFIG_BLK_DEV_OSD=m
>> CONFIG_BLK_DEV_SX8=m
>> CONFIG_BLK_DEV_UB=m
>> CONFIG_BLK_DEV_RAM=m
>> CONFIG_BLK_DEV_RAM_COUNT=16
>> CONFIG_BLK_DEV_RAM_SIZE=4096
>> CONFIG_BLK_DEV_XIP=y
>> CONFIG_CDROM_PKTCDVD=m
>> CONFIG_CDROM_PKTCDVD_BUFFERS=8
>> CONFIG_CDROM_PKTCDVD_WCACHE=y
>> CONFIG_ATA_OVER_ETH=m
>> CONFIG_VIRTIO_BLK=m
>> CONFIG_BLK_DEV_HD=y
>> CONFIG_MISC_DEVICES=y
>> CONFIG_HWLAT_DETECTOR=m
>> CONFIG_PHANTOM=m
>> CONFIG_SGI_IOC4=m
>> CONFIG_TIFM_CORE=m
>> CONFIG_TIFM_7XX1=m
>> CONFIG_ICS932S401=m
>> CONFIG_ENCLOSURE_SERVICES=m
>> CONFIG_HP_ILO=m
>> CONFIG_ISL29003=m
>> CONFIG_DS1682=m
>> CONFIG_C2PORT=m
>>
>> #
>> # EEPROM support
>> #
>> CONFIG_EEPROM_AT24=m
>> CONFIG_EEPROM_AT25=m
>> CONFIG_EEPROM_LEGACY=m
>> CONFIG_EEPROM_MAX6875=m
>> CONFIG_EEPROM_93CX6=m
>> CONFIG_CB710_CORE=m
>> CONFIG_CB710_DEBUG=y
>> CONFIG_CB710_DEBUG_ASSUMPTIONS=y
>> CONFIG_HAVE_IDE=y
>> CONFIG_IDE=m
>>
>> #
>> # Please see Documentation/ide/ide.txt for help/info on IDE drives
>> #
>> CONFIG_IDE_XFER_MODE=y
>> CONFIG_IDE_TIMINGS=y
>> CONFIG_IDE_ATAPI=y
>> CONFIG_BLK_DEV_IDE_SATA=y
>> CONFIG_IDE_GD=m
>> CONFIG_IDE_GD_ATA=y
>> CONFIG_IDE_GD_ATAPI=y
>> CONFIG_BLK_DEV_IDECS=m
>> CONFIG_BLK_DEV_DELKIN=m
>> CONFIG_BLK_DEV_IDECD=m
>> CONFIG_BLK_DEV_IDECD_VERBOSE_ERRORS=y
>> CONFIG_BLK_DEV_IDETAPE=m
>> CONFIG_IDE_TASK_IOCTL=y
>> CONFIG_IDE_PROC_FS=y
>>
>> #
>> # IDE chipset support/bugfixes
>> #
>> CONFIG_BLK_DEV_PLATFORM=m
>> CONFIG_BLK_DEV_IDEDMA_SFF=y
>>
>> #
>> # PCI IDE chipsets support
>> #
>> CONFIG_BLK_DEV_IDEPCI=y
>> CONFIG_BLK_DEV_OFFBOARD=y
>> CONFIG_BLK_DEV_GENERIC=m
>> CONFIG_BLK_DEV_OPTI621=m
>> CONFIG_BLK_DEV_IDEDMA_PCI=y
>> CONFIG_BLK_DEV_AEC62XX=m
>> CONFIG_BLK_DEV_ALI15X3=m
>> CONFIG_BLK_DEV_AMD74XX=m
>> CONFIG_BLK_DEV_CMD64X=m
>> CONFIG_BLK_DEV_TRIFLEX=m
>> CONFIG_BLK_DEV_CS5520=m
>> CONFIG_BLK_DEV_CS5530=m
>> CONFIG_BLK_DEV_HPT366=m
>> CONFIG_BLK_DEV_JMICRON=m
>> CONFIG_BLK_DEV_SC1200=m
>> CONFIG_BLK_DEV_PIIX=m
>> CONFIG_BLK_DEV_IT8172=m
>> CONFIG_BLK_DEV_IT8213=m
>> CONFIG_BLK_DEV_IT821X=m
>> CONFIG_BLK_DEV_NS87415=m
>> CONFIG_BLK_DEV_PDC202XX_OLD=m
>> CONFIG_BLK_DEV_PDC202XX_NEW=m
>> CONFIG_BLK_DEV_SVWKS=m
>> CONFIG_BLK_DEV_SIIMAGE=m
>> CONFIG_BLK_DEV_SL82C105=m
>> CONFIG_BLK_DEV_SLC90E66=m
>> CONFIG_BLK_DEV_TRM290=m
>> CONFIG_BLK_DEV_VIA82CXXX=m
>> CONFIG_BLK_DEV_TC86C001=m
>> CONFIG_BLK_DEV_CELLEB=m
>> CONFIG_BLK_DEV_IDE_PMAC=m
>> CONFIG_BLK_DEV_IDE_PMAC_ATA100FIRST=y
>> CONFIG_BLK_DEV_IDEDMA=y
>>
>> #
>> # SCSI device support
>> #
>> CONFIG_RAID_ATTRS=m
>> CONFIG_SCSI=m
>> CONFIG_SCSI_DMA=y
>> CONFIG_SCSI_TGT=m
>> CONFIG_SCSI_NETLINK=y
>> CONFIG_SCSI_PROC_FS=y
>>
>> #
>> # SCSI support type (disk, tape, CD-ROM)
>> #
>> CONFIG_BLK_DEV_SD=m
>> CONFIG_CHR_DEV_ST=m
>> CONFIG_CHR_DEV_OSST=m
>> CONFIG_BLK_DEV_SR=m
>> CONFIG_BLK_DEV_SR_VENDOR=y
>> CONFIG_CHR_DEV_SG=m
>> CONFIG_CHR_DEV_SCH=m
>> CONFIG_SCSI_ENCLOSURE=m
>> CONFIG_SCSI_MULTI_LUN=y
>> CONFIG_SCSI_CONSTANTS=y
>> CONFIG_SCSI_LOGGING=y
>> CONFIG_SCSI_SCAN_ASYNC=y
>> CONFIG_SCSI_WAIT_SCAN=m
>>
>> #
>> # SCSI Transports
>> #
>> CONFIG_SCSI_SPI_ATTRS=m
>> CONFIG_SCSI_FC_ATTRS=m
>> CONFIG_SCSI_FC_TGT_ATTRS=y
>> CONFIG_SCSI_ISCSI_ATTRS=m
>> CONFIG_SCSI_SAS_ATTRS=m
>> CONFIG_SCSI_SAS_LIBSAS=m
>> CONFIG_SCSI_SAS_ATA=y
>> CONFIG_SCSI_SAS_HOST_SMP=y
>> CONFIG_SCSI_SAS_LIBSAS_DEBUG=y
>> CONFIG_SCSI_SRP_ATTRS=m
>> CONFIG_SCSI_SRP_TGT_ATTRS=y
>> CONFIG_SCSI_LOWLEVEL=y
>> CONFIG_ISCSI_TCP=m
>> CONFIG_SCSI_CXGB3_ISCSI=m
>> CONFIG_SCSI_BNX2_ISCSI=m
>> CONFIG_BE2ISCSI=m
>> CONFIG_BLK_DEV_3W_XXXX_RAID=m
>> CONFIG_SCSI_3W_9XXX=m
>> CONFIG_SCSI_ACARD=m
>> CONFIG_SCSI_AACRAID=m
>> CONFIG_SCSI_AIC7XXX=m
>> CONFIG_AIC7XXX_CMDS_PER_DEVICE=32
>> CONFIG_AIC7XXX_RESET_DELAY_MS=5000
>> CONFIG_AIC7XXX_DEBUG_ENABLE=y
>> CONFIG_AIC7XXX_DEBUG_MASK=0
>> CONFIG_AIC7XXX_REG_PRETTY_PRINT=y
>> CONFIG_SCSI_AIC7XXX_OLD=m
>> CONFIG_SCSI_AIC79XX=m
>> CONFIG_AIC79XX_CMDS_PER_DEVICE=32
>> CONFIG_AIC79XX_RESET_DELAY_MS=5000
>> CONFIG_AIC79XX_DEBUG_ENABLE=y
>> CONFIG_AIC79XX_DEBUG_MASK=0
>> CONFIG_AIC79XX_REG_PRETTY_PRINT=y
>> CONFIG_SCSI_AIC94XX=m
>> CONFIG_AIC94XX_DEBUG=y
>> CONFIG_SCSI_MVSAS=m
>> CONFIG_SCSI_MVSAS_DEBUG=y
>> CONFIG_SCSI_ARCMSR=m
>> CONFIG_SCSI_ARCMSR_AER=y
>> CONFIG_MEGARAID_NEWGEN=y
>> CONFIG_MEGARAID_MM=m
>> CONFIG_MEGARAID_MAILBOX=m
>> CONFIG_MEGARAID_LEGACY=m
>> CONFIG_MEGARAID_SAS=m
>> CONFIG_SCSI_MPT2SAS=m
>> CONFIG_SCSI_MPT2SAS_MAX_SGE=128
>> CONFIG_SCSI_MPT2SAS_LOGGING=y
>> CONFIG_SCSI_HPTIOP=m
>> CONFIG_LIBFC=m
>> CONFIG_LIBFCOE=m
>> CONFIG_FCOE=m
>> CONFIG_SCSI_DMX3191D=m
>> CONFIG_SCSI_EATA=m
>> CONFIG_SCSI_EATA_TAGGED_QUEUE=y
>> CONFIG_SCSI_EATA_LINKED_COMMANDS=y
>> CONFIG_SCSI_EATA_MAX_TAGS=16
>> CONFIG_SCSI_FUTURE_DOMAIN=m
>> CONFIG_SCSI_GDTH=m
>> CONFIG_SCSI_IPS=m
>> CONFIG_SCSI_IBMVSCSI=m
>> CONFIG_SCSI_IBMVSCSIS=m
>> CONFIG_SCSI_IBMVFC=m
>> CONFIG_SCSI_IBMVFC_TRACE=y
>> CONFIG_SCSI_INITIO=m
>> CONFIG_SCSI_INIA100=m
>> CONFIG_SCSI_PPA=m
>> CONFIG_SCSI_IMM=m
>> CONFIG_SCSI_IZIP_EPP16=y
>> CONFIG_SCSI_IZIP_SLOW_CTR=y
>> CONFIG_SCSI_STEX=m
>> CONFIG_SCSI_SYM53C8XX_2=m
>> CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=1
>> CONFIG_SCSI_SYM53C8XX_DEFAULT_TAGS=16
>> CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64
>> CONFIG_SCSI_SYM53C8XX_MMIO=y
>> CONFIG_SCSI_IPR=m
>> CONFIG_SCSI_IPR_TRACE=y
>> CONFIG_SCSI_IPR_DUMP=y
>> CONFIG_SCSI_QLOGIC_1280=m
>> CONFIG_SCSI_QLA_FC=m
>> CONFIG_SCSI_QLA_ISCSI=m
>> CONFIG_SCSI_LPFC=m
>> CONFIG_SCSI_LPFC_DEBUG_FS=y
>> CONFIG_SCSI_DC395x=m
>> CONFIG_SCSI_DC390T=m
>> CONFIG_SCSI_DEBUG=m
>> CONFIG_SCSI_PMCRAID=m
>> CONFIG_SCSI_SRP=m
>> CONFIG_SCSI_BFA_FC=m
>> CONFIG_SCSI_LOWLEVEL_PCMCIA=y
>> CONFIG_PCMCIA_FDOMAIN=m
>> CONFIG_PCMCIA_QLOGIC=m
>> CONFIG_PCMCIA_SYM53C500=m
>> CONFIG_SCSI_DH=m
>> CONFIG_SCSI_DH_RDAC=m
>> CONFIG_SCSI_DH_HP_SW=m
>> CONFIG_SCSI_DH_EMC=m
>> CONFIG_SCSI_DH_ALUA=m
>> CONFIG_SCSI_OSD_INITIATOR=m
>> CONFIG_SCSI_OSD_ULD=m
>> CONFIG_SCSI_OSD_DPRINT_SENSE=1
>> CONFIG_SCSI_OSD_DEBUG=y
>> CONFIG_ATA=m
>> CONFIG_ATA_NONSTANDARD=y
>> CONFIG_ATA_VERBOSE_ERROR=y
>> CONFIG_SATA_PMP=y
>> CONFIG_SATA_AHCI=m
>> CONFIG_SATA_SIL24=m
>> CONFIG_ATA_SFF=y
>> CONFIG_SATA_SVW=m
>> CONFIG_ATA_PIIX=m
>> CONFIG_SATA_MV=m
>> CONFIG_SATA_NV=m
>> CONFIG_PDC_ADMA=m
>> CONFIG_SATA_QSTOR=m
>> CONFIG_SATA_PROMISE=m
>> CONFIG_SATA_SX4=m
>> CONFIG_SATA_SIL=m
>> CONFIG_SATA_SIS=m
>> CONFIG_SATA_ULI=m
>> CONFIG_SATA_VIA=m
>> CONFIG_SATA_VITESSE=m
>> CONFIG_SATA_INIC162X=m
>> CONFIG_PATA_ALI=m
>> CONFIG_PATA_AMD=m
>> CONFIG_PATA_ARTOP=m
>> CONFIG_PATA_ATP867X=m
>> CONFIG_PATA_ATIIXP=m
>> CONFIG_PATA_CMD640_PCI=m
>> CONFIG_PATA_CMD64X=m
>> CONFIG_PATA_CS5520=m
>> CONFIG_PATA_CS5530=m
>> CONFIG_PATA_CYPRESS=m
>> CONFIG_PATA_EFAR=m
>> CONFIG_ATA_GENERIC=m
>> CONFIG_PATA_HPT366=m
>> CONFIG_PATA_HPT37X=m
>> CONFIG_PATA_HPT3X2N=m
>> CONFIG_PATA_HPT3X3=m
>> CONFIG_PATA_HPT3X3_DMA=y
>> CONFIG_PATA_IT821X=m
>> CONFIG_PATA_IT8213=m
>> CONFIG_PATA_JMICRON=m
>> CONFIG_PATA_TRIFLEX=m
>> CONFIG_PATA_MARVELL=m
>> CONFIG_PATA_MPIIX=m
>> CONFIG_PATA_OLDPIIX=m
>> CONFIG_PATA_NETCELL=m
>> CONFIG_PATA_NINJA32=m
>> CONFIG_PATA_NS87410=m
>> CONFIG_PATA_NS87415=m
>> CONFIG_PATA_OPTI=m
>> CONFIG_PATA_OPTIDMA=m
>> CONFIG_PATA_PCMCIA=m
>> CONFIG_PATA_PDC_OLD=m
>> CONFIG_PATA_RADISYS=m
>> CONFIG_PATA_RDC=m
>> CONFIG_PATA_RZ1000=m
>> CONFIG_PATA_SC1200=m
>> CONFIG_PATA_SERVERWORKS=m
>> CONFIG_PATA_PDC2027X=m
>> CONFIG_PATA_SIL680=m
>> CONFIG_PATA_SIS=m
>> CONFIG_PATA_VIA=m
>> CONFIG_PATA_WINBOND=m
>> CONFIG_PATA_PLATFORM=m
>> CONFIG_PATA_OF_PLATFORM=m
>> CONFIG_PATA_SCC=m
>> CONFIG_PATA_SCH=m
>> CONFIG_MD=y
>> CONFIG_BLK_DEV_MD=m
>> CONFIG_MD_LINEAR=m
>> CONFIG_MD_RAID0=m
>> CONFIG_MD_RAID1=m
>> CONFIG_MD_RAID10=m
>> CONFIG_MD_RAID456=m
>> CONFIG_MULTICORE_RAID456=y
>> CONFIG_MD_RAID6_PQ=m
>> CONFIG_ASYNC_RAID6_TEST=m
>> CONFIG_MD_MULTIPATH=m
>> CONFIG_MD_FAULTY=m
>> CONFIG_BLK_DEV_DM=m
>> CONFIG_DM_DEBUG=y
>> CONFIG_DM_CRYPT=m
>> CONFIG_DM_SNAPSHOT=m
>> CONFIG_DM_MIRROR=m
>> CONFIG_DM_LOG_USERSPACE=m
>> CONFIG_DM_ZERO=m
>> CONFIG_DM_MULTIPATH=m
>> CONFIG_DM_MULTIPATH_QL=m
>> CONFIG_DM_MULTIPATH_ST=m
>> CONFIG_DM_DELAY=m
>> CONFIG_DM_UEVENT=y
>> CONFIG_FUSION=y
>> CONFIG_FUSION_SPI=m
>> CONFIG_FUSION_FC=m
>> CONFIG_FUSION_SAS=m
>> CONFIG_FUSION_MAX_SGE=128
>> CONFIG_FUSION_CTL=m
>> CONFIG_FUSION_LAN=m
>> CONFIG_FUSION_LOGGING=y
>>
>> #
>> # IEEE 1394 (FireWire) support
>> #
>>
>> #
>> # You can enable one or both FireWire driver stacks.
>> #
>>
>> #
>> # See the help texts for more information.
>> #
>> CONFIG_FIREWIRE=m
>> CONFIG_FIREWIRE_OHCI=m
>> CONFIG_FIREWIRE_OHCI_DEBUG=y
>> CONFIG_FIREWIRE_SBP2=m
>> CONFIG_FIREWIRE_NET=m
>> CONFIG_IEEE1394=m
>> CONFIG_IEEE1394_OHCI1394=m
>> CONFIG_IEEE1394_PCILYNX=m
>> CONFIG_IEEE1394_SBP2=m
>> CONFIG_IEEE1394_ETH1394_ROM_ENTRY=y
>> CONFIG_IEEE1394_ETH1394=m
>> CONFIG_IEEE1394_RAWIO=m
>> CONFIG_IEEE1394_VIDEO1394=m
>> CONFIG_IEEE1394_DV1394=m
>> CONFIG_IEEE1394_VERBOSEDEBUG=y
>> CONFIG_I2O=m
>> CONFIG_I2O_LCT_NOTIFY_ON_CHANGES=y
>> CONFIG_I2O_EXT_ADAPTEC=y
>> CONFIG_I2O_EXT_ADAPTEC_DMA64=y
>> CONFIG_I2O_BUS=m
>> CONFIG_I2O_BLOCK=m
>> CONFIG_I2O_SCSI=m
>> CONFIG_I2O_PROC=m
>> CONFIG_MACINTOSH_DRIVERS=y
>> CONFIG_ADB_PMU=y
>> CONFIG_ADB_PMU_LED=y
>> CONFIG_ADB_PMU_LED_IDE=y
>> CONFIG_PMAC_SMU=y
>> CONFIG_MAC_EMUMOUSEBTN=y
>> CONFIG_THERM_PM72=m
>> CONFIG_WINDFARM=m
>> CONFIG_WINDFARM_PM81=m
>> CONFIG_WINDFARM_PM91=m
>> CONFIG_WINDFARM_PM112=m
>> CONFIG_WINDFARM_PM121=m
>> CONFIG_PMAC_RACKMETER=m
>> CONFIG_NETDEVICES=y
>> CONFIG_IFB=m
>> CONFIG_DUMMY=m
>> CONFIG_BONDING=m
>> CONFIG_MACVLAN=m
>> CONFIG_EQUALIZER=m
>> CONFIG_TUN=m
>> CONFIG_VETH=m
>> CONFIG_ARCNET=m
>> CONFIG_ARCNET_1201=m
>> CONFIG_ARCNET_1051=m
>> CONFIG_ARCNET_RAW=m
>> CONFIG_ARCNET_CAP=m
>> CONFIG_ARCNET_COM90xx=m
>> CONFIG_ARCNET_COM90xxIO=m
>> CONFIG_ARCNET_RIM_I=m
>> CONFIG_ARCNET_COM20020=m
>> CONFIG_ARCNET_COM20020_PCI=m
>> CONFIG_PHYLIB=y
>>
>> #
>> # MII PHY device drivers
>> #
>> CONFIG_MARVELL_PHY=m
>> CONFIG_DAVICOM_PHY=m
>> CONFIG_QSEMI_PHY=m
>> CONFIG_LXT_PHY=m
>> CONFIG_CICADA_PHY=m
>> CONFIG_VITESSE_PHY=m
>> CONFIG_SMSC_PHY=m
>> CONFIG_BROADCOM_PHY=m
>> CONFIG_ICPLUS_PHY=m
>> CONFIG_REALTEK_PHY=m
>> CONFIG_NATIONAL_PHY=m
>> CONFIG_STE10XP=m
>> CONFIG_LSI_ET1011C_PHY=m
>> CONFIG_FIXED_PHY=y
>> CONFIG_MDIO_BITBANG=m
>> CONFIG_MDIO_GPIO=m
>> CONFIG_NET_ETHERNET=y
>> CONFIG_MII=m
>> CONFIG_HAPPYMEAL=m
>> CONFIG_SUNGEM=m
>> CONFIG_CASSINI=m
>> CONFIG_NET_VENDOR_3COM=y
>> CONFIG_VORTEX=m
>> CONFIG_TYPHOON=m
>> CONFIG_ENC28J60=m
>> CONFIG_ENC28J60_WRITEVERIFY=y
>> CONFIG_ETHOC=m
>> CONFIG_DNET=m
>> CONFIG_NET_TULIP=y
>> CONFIG_DE2104X=m
>> CONFIG_DE2104X_DSL=0
>> CONFIG_TULIP=m
>> CONFIG_TULIP_MWI=y
>> CONFIG_TULIP_MMIO=y
>> CONFIG_TULIP_NAPI=y
>> CONFIG_TULIP_NAPI_HW_MITIGATION=y
>> CONFIG_DE4X5=m
>> CONFIG_WINBOND_840=m
>> CONFIG_DM9102=m
>> CONFIG_ULI526X=m
>> CONFIG_PCMCIA_XIRCOM=m
>> CONFIG_HP100=m
>> CONFIG_IBMVETH=m
>> CONFIG_IBM_NEW_EMAC=m
>> CONFIG_IBM_NEW_EMAC_RXB=128
>> CONFIG_IBM_NEW_EMAC_TXB=64
>> CONFIG_IBM_NEW_EMAC_POLL_WEIGHT=32
>> CONFIG_IBM_NEW_EMAC_RX_COPY_THRESHOLD=256
>> CONFIG_IBM_NEW_EMAC_RX_SKB_HEADROOM=0
>> CONFIG_IBM_NEW_EMAC_DEBUG=y
>> CONFIG_IBM_NEW_EMAC_ZMII=y
>> CONFIG_IBM_NEW_EMAC_RGMII=y
>> CONFIG_IBM_NEW_EMAC_TAH=y
>> CONFIG_IBM_NEW_EMAC_EMAC4=y
>> # CONFIG_IBM_NEW_EMAC_NO_FLOW_CTRL is not set
>> # CONFIG_IBM_NEW_EMAC_MAL_CLR_ICINTSTAT is not set
>> # CONFIG_IBM_NEW_EMAC_MAL_COMMON_ERR is not set
>> CONFIG_NET_PCI=y
>> CONFIG_PCNET32=m
>> CONFIG_AMD8111_ETH=m
>> CONFIG_ADAPTEC_STARFIRE=m
>> CONFIG_B44=m
>> CONFIG_B44_PCI_AUTOSELECT=y
>> CONFIG_B44_PCICORE_AUTOSELECT=y
>> CONFIG_B44_PCI=y
>> CONFIG_FORCEDETH=m
>> CONFIG_FORCEDETH_NAPI=y
>> CONFIG_E100=m
>> CONFIG_FEALNX=m
>> CONFIG_NATSEMI=m
>> CONFIG_NE2K_PCI=m
>> CONFIG_8139CP=m
>> CONFIG_8139TOO=m
>> CONFIG_8139TOO_PIO=y
>> CONFIG_8139TOO_TUNE_TWISTER=y
>> CONFIG_8139TOO_8129=y
>> CONFIG_8139_OLD_RX_RESET=y
>> CONFIG_R6040=m
>> CONFIG_SIS900=m
>> CONFIG_EPIC100=m
>> CONFIG_SMSC9420=m
>> CONFIG_SUNDANCE=m
>> CONFIG_SUNDANCE_MMIO=y
>> CONFIG_TLAN=m
>> CONFIG_KS8842=m
>> CONFIG_KS8851=m
>> CONFIG_KS8851_MLL=m
>> CONFIG_VIA_RHINE=m
>> CONFIG_VIA_RHINE_MMIO=y
>> CONFIG_SC92031=m
>> CONFIG_NET_POCKET=y
>> CONFIG_DE600=m
>> CONFIG_DE620=m
>> CONFIG_ATL2=m
>> CONFIG_NETDEV_1000=y
>> CONFIG_ACENIC=m
>> CONFIG_ACENIC_OMIT_TIGON_I=y
>> CONFIG_DL2K=m
>> CONFIG_E1000=m
>> CONFIG_E1000E=m
>> CONFIG_IP1000=m
>> CONFIG_IGB=m
>> CONFIG_IGBVF=m
>> CONFIG_NS83820=m
>> CONFIG_HAMACHI=m
>> CONFIG_YELLOWFIN=m
>> CONFIG_R8169=m
>> CONFIG_R8169_VLAN=y
>> CONFIG_SIS190=m
>> CONFIG_SKGE=m
>> CONFIG_SKGE_DEBUG=y
>> CONFIG_SKY2=m
>> CONFIG_SKY2_DEBUG=y
>> CONFIG_VIA_VELOCITY=m
>> CONFIG_TIGON3=m
>> CONFIG_BNX2=m
>> CONFIG_CNIC=m
>> CONFIG_SPIDER_NET=m
>> CONFIG_GELIC_NET=m
>> CONFIG_GELIC_WIRELESS=y
>> CONFIG_GELIC_WIRELESS_OLD_PSK_INTERFACE=y
>> CONFIG_QLA3XXX=m
>> CONFIG_ATL1=m
>> CONFIG_ATL1E=m
>> CONFIG_ATL1C=m
>> CONFIG_JME=m
>> CONFIG_NETDEV_10000=y
>> CONFIG_MDIO=m
>> CONFIG_CHELSIO_T1=m
>> CONFIG_CHELSIO_T1_1G=y
>> CONFIG_CHELSIO_T3_DEPENDS=y
>> CONFIG_CHELSIO_T3=m
>> CONFIG_EHEA=m
>> CONFIG_ENIC=m
>> CONFIG_IXGBE=m
>> CONFIG_IXGBE_DCB=y
>> CONFIG_IXGB=m
>> CONFIG_S2IO=m
>> CONFIG_VXGE=m
>> CONFIG_VXGE_DEBUG_TRACE_ALL=y
>> CONFIG_MYRI10GE=m
>> CONFIG_NETXEN_NIC=m
>> CONFIG_NIU=m
>> CONFIG_PASEMI_MAC=m
>> CONFIG_MLX4_EN=m
>> CONFIG_MLX4_CORE=m
>> CONFIG_MLX4_DEBUG=y
>> CONFIG_TEHUTI=m
>> CONFIG_BNX2X=m
>> CONFIG_QLGE=m
>> CONFIG_SFC=m
>> CONFIG_SFC_MTD=y
>> CONFIG_BE2NET=m
>> CONFIG_TR=m
>> CONFIG_IBMOL=m
>> CONFIG_3C359=m
>> CONFIG_TMS380TR=m
>> CONFIG_TMSPCI=m
>> CONFIG_ABYSS=m
>> CONFIG_WLAN=y
>> CONFIG_WLAN_PRE80211=y
>> CONFIG_STRIP=m
>> CONFIG_PCMCIA_WAVELAN=m
>> CONFIG_PCMCIA_NETWAVE=m
>> CONFIG_WLAN_80211=y
>> CONFIG_PCMCIA_RAYCS=m
>> CONFIG_LIBERTAS_THINFIRM=m
>> CONFIG_LIBERTAS_THINFIRM_USB=m
>> CONFIG_AIRO=m
>> CONFIG_ATMEL=m
>> CONFIG_PCI_ATMEL=m
>> CONFIG_PCMCIA_ATMEL=m
>> CONFIG_AT76C50X_USB=m
>> CONFIG_AIRO_CS=m
>> CONFIG_PCMCIA_WL3501=m
>> CONFIG_PRISM54=m
>> CONFIG_USB_ZD1201=m
>> CONFIG_USB_NET_RNDIS_WLAN=m
>> CONFIG_RTL8180=m
>> CONFIG_RTL8187=m
>> CONFIG_RTL8187_LEDS=y
>> CONFIG_ADM8211=m
>> CONFIG_MAC80211_HWSIM=m
>> CONFIG_MWL8K=m
>> CONFIG_ATH_COMMON=m
>> CONFIG_ATH_DEBUG=y
>> CONFIG_ATH5K=m
>> CONFIG_ATH5K_DEBUG=y
>> CONFIG_ATH9K_HW=m
>> CONFIG_ATH9K=m
>> CONFIG_ATH9K_DEBUG=y
>> CONFIG_AR9170_USB=m
>> CONFIG_AR9170_LEDS=y
>> CONFIG_B43=m
>> CONFIG_B43_PCI_AUTOSELECT=y
>> CONFIG_B43_PCICORE_AUTOSELECT=y
>> CONFIG_B43_PCMCIA=y
>> CONFIG_B43_SDIO=y
>> CONFIG_B43_PIO=y
>> CONFIG_B43_PHY_LP=y
>> CONFIG_B43_LEDS=y
>> CONFIG_B43_HWRNG=y
>> CONFIG_B43_DEBUG=y
>> CONFIG_B43_FORCE_PIO=y
>> CONFIG_B43LEGACY=m
>> CONFIG_B43LEGACY_PCI_AUTOSELECT=y
>> CONFIG_B43LEGACY_PCICORE_AUTOSELECT=y
>> CONFIG_B43LEGACY_LEDS=y
>> CONFIG_B43LEGACY_HWRNG=y
>> CONFIG_B43LEGACY_DEBUG=y
>> CONFIG_B43LEGACY_DMA=y
>> CONFIG_B43LEGACY_PIO=y
>> CONFIG_B43LEGACY_DMA_AND_PIO_MODE=y
>> # CONFIG_B43LEGACY_DMA_MODE is not set
>> # CONFIG_B43LEGACY_PIO_MODE is not set
>> CONFIG_HOSTAP=m
>> CONFIG_HOSTAP_FIRMWARE=y
>> CONFIG_HOSTAP_FIRMWARE_NVRAM=y
>> CONFIG_HOSTAP_PLX=m
>> CONFIG_HOSTAP_PCI=m
>> CONFIG_HOSTAP_CS=m
>> CONFIG_IPW2100=m
>> CONFIG_IPW2100_MONITOR=y
>> CONFIG_IPW2100_DEBUG=y
>> CONFIG_IPW2200=m
>> CONFIG_IPW2200_MONITOR=y
>> CONFIG_IPW2200_RADIOTAP=y
>> CONFIG_IPW2200_PROMISCUOUS=y
>> CONFIG_IPW2200_QOS=y
>> CONFIG_IPW2200_DEBUG=y
>> CONFIG_LIBIPW=m
>> CONFIG_LIBIPW_DEBUG=y
>> CONFIG_IWLWIFI=m
>> CONFIG_IWLWIFI_SPECTRUM_MEASUREMENT=y
>> CONFIG_IWLWIFI_DEBUG=y
>> CONFIG_IWLWIFI_DEBUGFS=y
>> CONFIG_IWLWIFI_DEVICE_TRACING=y
>> CONFIG_IWLAGN=m
>> CONFIG_IWL4965=y
>> CONFIG_IWL5000=y
>> CONFIG_IWL3945=m
>> CONFIG_IWL3945_SPECTRUM_MEASUREMENT=y
>> CONFIG_IWM=m
>> CONFIG_IWM_DEBUG=y
>> CONFIG_LIBERTAS=m
>> CONFIG_LIBERTAS_USB=m
>> CONFIG_LIBERTAS_CS=m
>> CONFIG_LIBERTAS_SDIO=m
>> CONFIG_LIBERTAS_SPI=m
>> CONFIG_LIBERTAS_DEBUG=y
>> CONFIG_HERMES=m
>> CONFIG_HERMES_CACHE_FW_ON_INIT=y
>> CONFIG_APPLE_AIRPORT=m
>> CONFIG_PLX_HERMES=m
>> CONFIG_TMD_HERMES=m
>> CONFIG_NORTEL_HERMES=m
>> CONFIG_PCI_HERMES=m
>> CONFIG_PCMCIA_HERMES=m
>> CONFIG_PCMCIA_SPECTRUM=m
>> CONFIG_P54_COMMON=m
>> CONFIG_P54_USB=m
>> CONFIG_P54_PCI=m
>> CONFIG_P54_SPI=m
>> CONFIG_P54_LEDS=y
>> CONFIG_RT2X00=m
>> CONFIG_RT2400PCI=m
>> CONFIG_RT2500PCI=m
>> CONFIG_RT61PCI=m
>> CONFIG_RT2500USB=m
>> CONFIG_RT73USB=m
>> CONFIG_RT2800USB=m
>> CONFIG_RT2X00_LIB_PCI=m
>> CONFIG_RT2X00_LIB_USB=m
>> CONFIG_RT2X00_LIB=m
>> CONFIG_RT2X00_LIB_HT=y
>> CONFIG_RT2X00_LIB_FIRMWARE=y
>> CONFIG_RT2X00_LIB_CRYPTO=y
>> CONFIG_RT2X00_LIB_LEDS=y
>> CONFIG_RT2X00_LIB_DEBUGFS=y
>> CONFIG_RT2X00_DEBUG=y
>> CONFIG_WL12XX=m
>> CONFIG_WL1251=m
>> CONFIG_WL1251_SPI=m
>> CONFIG_WL1251_SDIO=m
>> CONFIG_WL1271=m
>> CONFIG_ZD1211RW=m
>> CONFIG_ZD1211RW_DEBUG=y
>>
>> #
>> # WiMAX Wireless Broadband devices
>> #
>> CONFIG_WIMAX_I2400M=m
>> CONFIG_WIMAX_I2400M_USB=m
>> CONFIG_WIMAX_I2400M_SDIO=m
>> CONFIG_WIMAX_I2400M_DEBUG_LEVEL=8
>>
>> #
>> # USB Network Adapters
>> #
>> CONFIG_USB_CATC=m
>> CONFIG_USB_KAWETH=m
>> CONFIG_USB_PEGASUS=m
>> CONFIG_USB_RTL8150=m
>> CONFIG_USB_USBNET=m
>> CONFIG_USB_NET_AX8817X=m
>> CONFIG_USB_NET_CDCETHER=m
>> CONFIG_USB_NET_CDC_EEM=m
>> CONFIG_USB_NET_DM9601=m
>> CONFIG_USB_NET_SMSC95XX=m
>> CONFIG_USB_NET_GL620A=m
>> CONFIG_USB_NET_NET1080=m
>> CONFIG_USB_NET_PLUSB=m
>> CONFIG_USB_NET_MCS7830=m
>> CONFIG_USB_NET_RNDIS_HOST=m
>> CONFIG_USB_NET_CDC_SUBSET=m
>> CONFIG_USB_ALI_M5632=y
>> CONFIG_USB_AN2720=y
>> CONFIG_USB_BELKIN=y
>> CONFIG_USB_ARMLINUX=y
>> CONFIG_USB_EPSON2888=y
>> CONFIG_USB_KC2190=y
>> CONFIG_USB_NET_ZAURUS=m
>> CONFIG_USB_HSO=m
>> CONFIG_USB_NET_INT51X1=m
>> CONFIG_USB_CDC_PHONET=m
>> CONFIG_NET_PCMCIA=y
>> CONFIG_PCMCIA_3C589=m
>> CONFIG_PCMCIA_3C574=m
>> CONFIG_PCMCIA_FMVJ18X=m
>> CONFIG_PCMCIA_PCNET=m
>> CONFIG_PCMCIA_NMCLAN=m
>> CONFIG_PCMCIA_SMC91C92=m
>> CONFIG_PCMCIA_XIRC2PS=m
>> CONFIG_PCMCIA_AXNET=m
>> CONFIG_ARCNET_COM20020_CS=m
>> CONFIG_PCMCIA_IBMTR=m
>> CONFIG_WAN=y
>> CONFIG_HDLC=m
>> CONFIG_HDLC_RAW=m
>> CONFIG_HDLC_RAW_ETH=m
>> CONFIG_HDLC_CISCO=m
>> CONFIG_HDLC_FR=m
>> CONFIG_HDLC_PPP=m
>> CONFIG_HDLC_X25=m
>> CONFIG_PCI200SYN=m
>> CONFIG_WANXL=m
>> CONFIG_PC300TOO=m
>> CONFIG_FARSYNC=m
>> CONFIG_DSCC4=m
>> CONFIG_DSCC4_PCISYNC=y
>> CONFIG_DSCC4_PCI_RST=y
>> CONFIG_DLCI=m
>> CONFIG_DLCI_MAX=8
>> CONFIG_WAN_ROUTER_DRIVERS=m
>> CONFIG_CYCLADES_SYNC=m
>> CONFIG_CYCLOMX_X25=y
>> CONFIG_LAPBETHER=m
>> CONFIG_X25_ASY=m
>> CONFIG_ATM_DRIVERS=y
>> CONFIG_ATM_DUMMY=m
>> CONFIG_ATM_TCP=m
>> CONFIG_ATM_LANAI=m
>> CONFIG_ATM_ENI=m
>> CONFIG_ATM_ENI_DEBUG=y
>> CONFIG_ATM_ENI_TUNE_BURST=y
>> CONFIG_ATM_ENI_BURST_TX_16W=y
>> CONFIG_ATM_ENI_BURST_TX_8W=y
>> CONFIG_ATM_ENI_BURST_TX_4W=y
>> CONFIG_ATM_ENI_BURST_TX_2W=y
>> CONFIG_ATM_ENI_BURST_RX_16W=y
>> CONFIG_ATM_ENI_BURST_RX_8W=y
>> CONFIG_ATM_ENI_BURST_RX_4W=y
>> CONFIG_ATM_ENI_BURST_RX_2W=y
>> CONFIG_ATM_IDT77252=m
>> CONFIG_ATM_IDT77252_DEBUG=y
>> CONFIG_ATM_IDT77252_RCV_ALL=y
>> CONFIG_ATM_IDT77252_USE_SUNI=y
>> CONFIG_ATM_IA=m
>> CONFIG_ATM_IA_DEBUG=y
>> CONFIG_ATM_FORE200E=m
>> CONFIG_ATM_FORE200E_USE_TASKLET=y
>> CONFIG_ATM_FORE200E_TX_RETRY=16
>> CONFIG_ATM_FORE200E_DEBUG=0
>> CONFIG_ATM_HE=m
>> CONFIG_ATM_HE_USE_SUNI=y
>> CONFIG_ATM_SOLOS=m
>> CONFIG_IEEE802154_DRIVERS=m
>> CONFIG_IEEE802154_FAKEHARD=m
>> CONFIG_ISERIES_VETH=m
>> CONFIG_FDDI=m
>> CONFIG_DEFXX=m
>> CONFIG_DEFXX_MMIO=y
>> CONFIG_SKFP=m
>> CONFIG_HIPPI=y
>> CONFIG_ROADRUNNER=m
>> CONFIG_ROADRUNNER_LARGE_RINGS=y
>> CONFIG_PLIP=m
>> CONFIG_PPP=m
>> CONFIG_PPP_MULTILINK=y
>> CONFIG_PPP_FILTER=y
>> CONFIG_PPP_ASYNC=m
>> CONFIG_PPP_SYNC_TTY=m
>> CONFIG_PPP_DEFLATE=m
>> CONFIG_PPP_BSDCOMP=m
>> CONFIG_PPP_MPPE=m
>> CONFIG_PPPOE=m
>> CONFIG_PPPOATM=m
>> CONFIG_PPPOL2TP=m
>> CONFIG_SLIP=m
>> CONFIG_SLIP_COMPRESSED=y
>> CONFIG_SLHC=m
>> CONFIG_SLIP_SMART=y
>> CONFIG_SLIP_MODE_SLIP6=y
>> CONFIG_NET_FC=y
>> CONFIG_NETCONSOLE=m
>> CONFIG_NETCONSOLE_DYNAMIC=y
>> CONFIG_NETPOLL=y
>> CONFIG_NETPOLL_TRAP=y
>> CONFIG_NET_POLL_CONTROLLER=y
>> CONFIG_VIRTIO_NET=m
>> CONFIG_VBUS_ENET=m
>> CONFIG_VBUS_ENET_DEBUG=y
>> CONFIG_ISDN=y
>> CONFIG_ISDN_I4L=m
>> CONFIG_MISDN=m
>> CONFIG_MISDN_DSP=m
>> CONFIG_MISDN_L1OIP=m
>>
>> #
>> # mISDN hardware drivers
>> #
>> CONFIG_MISDN_HFCPCI=m
>> CONFIG_MISDN_HFCMULTI=m
>> CONFIG_MISDN_HFCUSB=m
>> CONFIG_MISDN_AVMFRITZ=m
>> CONFIG_MISDN_SPEEDFAX=m
>> CONFIG_MISDN_INFINEON=m
>> CONFIG_MISDN_W6692=m
>> CONFIG_MISDN_NETJET=m
>> CONFIG_MISDN_IPAC=m
>> CONFIG_MISDN_ISAR=m
>> CONFIG_ISDN_PPP=y
>> CONFIG_ISDN_PPP_VJ=y
>> CONFIG_ISDN_MPP=y
>> CONFIG_IPPP_FILTER=y
>> CONFIG_ISDN_PPP_BSDCOMP=m
>> CONFIG_ISDN_AUDIO=y
>> CONFIG_ISDN_TTY_FAX=y
>> CONFIG_ISDN_X25=y
>>
>> #
>> # ISDN feature submodules
>> #
>> CONFIG_ISDN_DIVERSION=m
>>
>> #
>> # ISDN4Linux hardware drivers
>> #
>>
>> #
>> # Passive cards
>> #
>> CONFIG_ISDN_DRV_HISAX=m
>>
>> #
>> # D-channel protocol features
>> #
>> CONFIG_HISAX_EURO=y
>> CONFIG_DE_AOC=y
>> CONFIG_HISAX_NO_SENDCOMPLETE=y
>> CONFIG_HISAX_NO_LLC=y
>> CONFIG_HISAX_NO_KEYPAD=y
>> CONFIG_HISAX_1TR6=y
>> CONFIG_HISAX_NI1=y
>> CONFIG_HISAX_MAX_CARDS=8
>>
>> #
>> # HiSax supported cards
>> #
>> CONFIG_HISAX_16_3=y
>> CONFIG_HISAX_S0BOX=y
>> CONFIG_HISAX_AVM_A1_PCMCIA=y
>> CONFIG_HISAX_ELSA=y
>> CONFIG_HISAX_DIEHLDIVA=y
>> CONFIG_HISAX_SEDLBAUER=y
>> CONFIG_HISAX_NICCY=y
>> CONFIG_HISAX_BKM_A4T=y
>> CONFIG_HISAX_SCT_QUADRO=y
>> CONFIG_HISAX_GAZEL=y
>> CONFIG_HISAX_W6692=y
>> CONFIG_HISAX_HFC_SX=y
>> CONFIG_HISAX_DEBUG=y
>>
>> #
>> # HiSax PCMCIA card service modules
>> #
>> CONFIG_HISAX_SEDLBAUER_CS=m
>> CONFIG_HISAX_ELSA_CS=m
>> CONFIG_HISAX_AVM_A1_CS=m
>> CONFIG_HISAX_TELES_CS=m
>>
>> #
>> # HiSax sub driver modules
>> #
>> CONFIG_HISAX_ST5481=m
>> CONFIG_HISAX_HFCUSB=m
>> CONFIG_HISAX_HFC4S8S=m
>> CONFIG_HISAX_FRITZ_PCIPNP=m
>>
>> #
>> # Active cards
>> #
>> CONFIG_HYSDN=m
>> CONFIG_HYSDN_CAPI=y
>> CONFIG_ISDN_HDLC=m
>> CONFIG_ISDN_CAPI=m
>> CONFIG_ISDN_DRV_AVMB1_VERBOSE_REASON=y
>> CONFIG_CAPI_TRACE=y
>> CONFIG_ISDN_CAPI_MIDDLEWARE=y
>> CONFIG_ISDN_CAPI_CAPI20=m
>> CONFIG_ISDN_CAPI_CAPIFS_BOOL=y
>> CONFIG_ISDN_CAPI_CAPIFS=m
>> CONFIG_ISDN_CAPI_CAPIDRV=m
>>
>> #
>> # CAPI hardware drivers
>> #
>> CONFIG_CAPI_AVM=y
>> CONFIG_ISDN_DRV_AVMB1_B1PCI=m
>> CONFIG_ISDN_DRV_AVMB1_B1PCIV4=y
>> CONFIG_ISDN_DRV_AVMB1_B1PCMCIA=m
>> CONFIG_ISDN_DRV_AVMB1_AVM_CS=m
>> CONFIG_ISDN_DRV_AVMB1_T1PCI=m
>> CONFIG_ISDN_DRV_AVMB1_C4=m
>> CONFIG_CAPI_EICON=y
>> CONFIG_ISDN_DIVAS=m
>> CONFIG_ISDN_DIVAS_BRIPCI=y
>> CONFIG_ISDN_DIVAS_PRIPCI=y
>> CONFIG_ISDN_DIVAS_DIVACAPI=m
>> CONFIG_ISDN_DIVAS_USERIDI=m
>> CONFIG_ISDN_DIVAS_MAINT=m
>> CONFIG_ISDN_DRV_GIGASET=m
>> CONFIG_GIGASET_CAPI=y
>> # CONFIG_GIGASET_I4L is not set
>> # CONFIG_GIGASET_DUMMYLL is not set
>> CONFIG_GIGASET_BASE=m
>> CONFIG_GIGASET_M105=m
>> CONFIG_GIGASET_M101=m
>> CONFIG_GIGASET_DEBUG=y
>> CONFIG_PHONE=m
>> CONFIG_PHONE_IXJ=m
>> CONFIG_PHONE_IXJ_PCMCIA=m
>>
>> #
>> # Input device support
>> #
>> CONFIG_INPUT=y
>> CONFIG_INPUT_FF_MEMLESS=m
>> CONFIG_INPUT_POLLDEV=m
>>
>> #
>> # Userland interfaces
>> #
>> CONFIG_INPUT_MOUSEDEV=m
>> CONFIG_INPUT_MOUSEDEV_PSAUX=y
>> CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
>> CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
>> CONFIG_INPUT_JOYDEV=m
>> CONFIG_INPUT_EVDEV=m
>> CONFIG_INPUT_EVBUG=m
>>
>> #
>> # Input Device Drivers
>> #
>> CONFIG_INPUT_KEYBOARD=y
>> CONFIG_KEYBOARD_ADP5588=m
>> CONFIG_KEYBOARD_ATKBD=m
>> CONFIG_QT2160=m
>> CONFIG_KEYBOARD_LKKBD=m
>> CONFIG_KEYBOARD_GPIO=m
>> CONFIG_KEYBOARD_MATRIX=m
>> CONFIG_KEYBOARD_LM8323=m
>> CONFIG_KEYBOARD_MAX7359=m
>> CONFIG_KEYBOARD_NEWTON=m
>> CONFIG_KEYBOARD_OPENCORES=m
>> CONFIG_KEYBOARD_STOWAWAY=m
>> CONFIG_KEYBOARD_SUNKBD=m
>> CONFIG_KEYBOARD_XTKBD=m
>> CONFIG_INPUT_MOUSE=y
>> CONFIG_MOUSE_PS2=m
>> CONFIG_MOUSE_PS2_ALPS=y
>> CONFIG_MOUSE_PS2_LOGIPS2PP=y
>> CONFIG_MOUSE_PS2_SYNAPTICS=y
>> CONFIG_MOUSE_PS2_TRACKPOINT=y
>> CONFIG_MOUSE_PS2_ELANTECH=y
>> CONFIG_MOUSE_PS2_SENTELIC=y
>> CONFIG_MOUSE_PS2_TOUCHKIT=y
>> CONFIG_MOUSE_SERIAL=m
>> CONFIG_MOUSE_APPLETOUCH=m
>> CONFIG_MOUSE_BCM5974=m
>> CONFIG_MOUSE_VSXXXAA=m
>> CONFIG_MOUSE_GPIO=m
>> CONFIG_MOUSE_SYNAPTICS_I2C=m
>> CONFIG_INPUT_JOYSTICK=y
>> CONFIG_JOYSTICK_ANALOG=m
>> CONFIG_JOYSTICK_A3D=m
>> CONFIG_JOYSTICK_ADI=m
>> CONFIG_JOYSTICK_COBRA=m
>> CONFIG_JOYSTICK_GF2K=m
>> CONFIG_JOYSTICK_GRIP=m
>> CONFIG_JOYSTICK_GRIP_MP=m
>> CONFIG_JOYSTICK_GUILLEMOT=m
>> CONFIG_JOYSTICK_INTERACT=m
>> CONFIG_JOYSTICK_SIDEWINDER=m
>> CONFIG_JOYSTICK_TMDC=m
>> CONFIG_JOYSTICK_IFORCE=m
>> CONFIG_JOYSTICK_IFORCE_USB=y
>> CONFIG_JOYSTICK_IFORCE_232=y
>> CONFIG_JOYSTICK_WARRIOR=m
>> CONFIG_JOYSTICK_MAGELLAN=m
>> CONFIG_JOYSTICK_SPACEORB=m
>> CONFIG_JOYSTICK_SPACEBALL=m
>> CONFIG_JOYSTICK_STINGER=m
>> CONFIG_JOYSTICK_TWIDJOY=m
>> CONFIG_JOYSTICK_ZHENHUA=m
>> CONFIG_JOYSTICK_DB9=m
>> CONFIG_JOYSTICK_GAMECON=m
>> CONFIG_JOYSTICK_TURBOGRAFX=m
>> CONFIG_JOYSTICK_JOYDUMP=m
>> CONFIG_JOYSTICK_XPAD=m
>> CONFIG_JOYSTICK_XPAD_FF=y
>> CONFIG_JOYSTICK_XPAD_LEDS=y
>> CONFIG_JOYSTICK_WALKERA0701=m
>> CONFIG_INPUT_TABLET=y
>> CONFIG_TABLET_USB_ACECAD=m
>> CONFIG_TABLET_USB_AIPTEK=m
>> CONFIG_TABLET_USB_GTCO=m
>> CONFIG_TABLET_USB_KBTAB=m
>> CONFIG_TABLET_USB_WACOM=m
>> CONFIG_INPUT_TOUCHSCREEN=y
>> CONFIG_TOUCHSCREEN_ADS7846=m
>> CONFIG_TOUCHSCREEN_AD7877=m
>> CONFIG_TOUCHSCREEN_AD7879_I2C=m
>> CONFIG_TOUCHSCREEN_AD7879=m
>> CONFIG_TOUCHSCREEN_EETI=m
>> CONFIG_TOUCHSCREEN_FUJITSU=m
>> CONFIG_TOUCHSCREEN_GUNZE=m
>> CONFIG_TOUCHSCREEN_ELO=m
>> CONFIG_TOUCHSCREEN_WACOM_W8001=m
>> CONFIG_TOUCHSCREEN_MCS5000=m
>> CONFIG_TOUCHSCREEN_MTOUCH=m
>> CONFIG_TOUCHSCREEN_INEXIO=m
>> CONFIG_TOUCHSCREEN_MK712=m
>> CONFIG_TOUCHSCREEN_PENMOUNT=m
>> CONFIG_TOUCHSCREEN_TOUCHRIGHT=m
>> CONFIG_TOUCHSCREEN_TOUCHWIN=m
>> CONFIG_TOUCHSCREEN_UCB1400=m
>> CONFIG_TOUCHSCREEN_WM97XX=m
>> CONFIG_TOUCHSCREEN_WM9705=y
>> CONFIG_TOUCHSCREEN_WM9712=y
>> CONFIG_TOUCHSCREEN_WM9713=y
>> CONFIG_TOUCHSCREEN_USB_COMPOSITE=m
>> CONFIG_TOUCHSCREEN_USB_EGALAX=y
>> CONFIG_TOUCHSCREEN_USB_PANJIT=y
>> CONFIG_TOUCHSCREEN_USB_3M=y
>> CONFIG_TOUCHSCREEN_USB_ITM=y
>> CONFIG_TOUCHSCREEN_USB_ETURBO=y
>> CONFIG_TOUCHSCREEN_USB_GUNZE=y
>> CONFIG_TOUCHSCREEN_USB_DMC_TSC10=y
>> CONFIG_TOUCHSCREEN_USB_IRTOUCH=y
>> CONFIG_TOUCHSCREEN_USB_IDEALTEK=y
>> CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH=y
>> CONFIG_TOUCHSCREEN_USB_GOTOP=y
>> CONFIG_TOUCHSCREEN_USB_JASTEC=y
>> CONFIG_TOUCHSCREEN_USB_E2I=y
>> CONFIG_TOUCHSCREEN_TOUCHIT213=m
>> CONFIG_TOUCHSCREEN_TSC2007=m
>> CONFIG_TOUCHSCREEN_PCAP=m
>> CONFIG_INPUT_MISC=y
>> CONFIG_INPUT_PCSPKR=m
>> CONFIG_INPUT_ATI_REMOTE=m
>> CONFIG_INPUT_ATI_REMOTE2=m
>> CONFIG_INPUT_KEYSPAN_REMOTE=m
>> CONFIG_INPUT_POWERMATE=m
>> CONFIG_INPUT_YEALINK=m
>> CONFIG_INPUT_CM109=m
>> CONFIG_INPUT_UINPUT=m
>> CONFIG_INPUT_PCF50633_PMU=m
>> CONFIG_INPUT_GPIO_ROTARY_ENCODER=m
>> CONFIG_INPUT_WM831X_ON=m
>> CONFIG_INPUT_PCAP=m
>>
>> #
>> # Hardware I/O ports
>> #
>> CONFIG_SERIO=m
>> CONFIG_SERIO_I8042=m
>> CONFIG_SERIO_SERPORT=m
>> CONFIG_SERIO_PARKBD=m
>> CONFIG_SERIO_PCIPS2=m
>> CONFIG_SERIO_LIBPS2=m
>> CONFIG_SERIO_RAW=m
>> CONFIG_SERIO_XILINX_XPS_PS2=m
>> CONFIG_SERIO_ALTERA_PS2=m
>> CONFIG_GAMEPORT=m
>> CONFIG_GAMEPORT_NS558=m
>> CONFIG_GAMEPORT_L4=m
>> CONFIG_GAMEPORT_EMU10K1=m
>> CONFIG_GAMEPORT_FM801=m
>>
>> #
>> # Character devices
>> #
>> CONFIG_VT=y
>> CONFIG_CONSOLE_TRANSLATIONS=y
>> CONFIG_VT_CONSOLE=y
>> CONFIG_HW_CONSOLE=y
>> CONFIG_VT_HW_CONSOLE_BINDING=y
>> CONFIG_DEVKMEM=y
>> CONFIG_SERIAL_NONSTANDARD=y
>> CONFIG_COMPUTONE=m
>> CONFIG_ROCKETPORT=m
>> CONFIG_CYCLADES=m
>> CONFIG_CYZ_INTR=y
>> CONFIG_DIGIEPCA=m
>> CONFIG_MOXA_INTELLIO=m
>> CONFIG_MOXA_SMARTIO=m
>> CONFIG_ISI=m
>> CONFIG_SYNCLINK=m
>> CONFIG_SYNCLINKMP=m
>> CONFIG_SYNCLINK_GT=m
>> CONFIG_N_HDLC=m
>> CONFIG_RISCOM8=m
>> CONFIG_SPECIALIX=m
>> CONFIG_SX=m
>> CONFIG_RIO=m
>> CONFIG_RIO_OLDPCI=y
>> CONFIG_STALDRV=y
>> CONFIG_STALLION=m
>> CONFIG_ISTALLION=m
>> CONFIG_NOZOMI=m
>>
>> #
>> # Serial drivers
>> #
>> CONFIG_SERIAL_8250=m
>> CONFIG_SERIAL_8250_PCI=m
>> CONFIG_SERIAL_8250_CS=m
>> CONFIG_SERIAL_8250_NR_UARTS=4
>> CONFIG_SERIAL_8250_RUNTIME_UARTS=4
>> CONFIG_SERIAL_8250_EXTENDED=y
>> CONFIG_SERIAL_8250_MANY_PORTS=y
>> CONFIG_SERIAL_8250_SHARE_IRQ=y
>> CONFIG_SERIAL_8250_DETECT_IRQ=y
>> CONFIG_SERIAL_8250_RSA=y
>>
>> #
>> # Non-8250 serial port support
>> #
>> CONFIG_SERIAL_MAX3100=m
>> CONFIG_SERIAL_CORE=y
>> CONFIG_SERIAL_CORE_CONSOLE=y
>> CONFIG_CONSOLE_POLL=y
>> CONFIG_SERIAL_PMACZILOG=m
>> CONFIG_SERIAL_PMACZILOG_TTYS=y
>> CONFIG_SERIAL_ICOM=m
>> CONFIG_SERIAL_TXX9=y
>> CONFIG_HAS_TXX9_SERIAL=y
>> CONFIG_SERIAL_TXX9_NR_UARTS=6
>> CONFIG_SERIAL_TXX9_CONSOLE=y
>> CONFIG_SERIAL_TXX9_STDSERIAL=y
>> CONFIG_SERIAL_JSM=m
>> CONFIG_SERIAL_OF_PLATFORM=m
>> CONFIG_SERIAL_OF_PLATFORM_NWPSERIAL=m
>> CONFIG_UNIX98_PTYS=y
>> CONFIG_DEVPTS_MULTIPLE_INSTANCES=y
>> CONFIG_LEGACY_PTYS=y
>> CONFIG_LEGACY_PTY_COUNT=256
>> CONFIG_PRINTER=m
>> CONFIG_LP_CONSOLE=y
>> CONFIG_PPDEV=m
>> CONFIG_HVC_DRIVER=y
>> CONFIG_HVC_IRQ=y
>> CONFIG_HVC_CONSOLE=y
>> CONFIG_HVC_ISERIES=y
>> CONFIG_HVC_RTAS=y
>> CONFIG_HVC_BEAT=y
>> CONFIG_HVC_UDBG=y
>> CONFIG_VIRTIO_CONSOLE=m
>> CONFIG_HVCS=m
>> CONFIG_IBM_BSR=m
>> CONFIG_IPMI_HANDLER=m
>> CONFIG_IPMI_PANIC_EVENT=y
>> CONFIG_IPMI_PANIC_STRING=y
>> CONFIG_IPMI_DEVICE_INTERFACE=m
>> CONFIG_IPMI_SI=m
>> CONFIG_IPMI_WATCHDOG=m
>> CONFIG_IPMI_POWEROFF=m
>> CONFIG_HW_RANDOM=m
>> CONFIG_HW_RANDOM_TIMERIOMEM=m
>> CONFIG_HW_RANDOM_PASEMI=m
>> CONFIG_HW_RANDOM_VIRTIO=m
>> CONFIG_R3964=m
>> CONFIG_APPLICOM=m
>>
>> #
>> # PCMCIA character devices
>> #
>> CONFIG_SYNCLINK_CS=m
>> CONFIG_CARDMAN_4000=m
>> CONFIG_CARDMAN_4040=m
>> CONFIG_IPWIRELESS=m
>> CONFIG_RAW_DRIVER=m
>> CONFIG_MAX_RAW_DEVS=256
>> CONFIG_HANGCHECK_TIMER=m
>> CONFIG_TCG_TPM=m
>> CONFIG_TCG_NSC=m
>> CONFIG_TCG_ATMEL=m
>> CONFIG_DEVPORT=y
>> CONFIG_I2C=m
>> CONFIG_I2C_BOARDINFO=y
>> CONFIG_I2C_COMPAT=y
>> CONFIG_I2C_CHARDEV=m
>> CONFIG_I2C_HELPER_AUTO=y
>> CONFIG_I2C_ALGOBIT=m
>> CONFIG_I2C_ALGOPCA=m
>>
>> #
>> # I2C Hardware Bus support
>> #
>>
>> #
>> # PC SMBus host controller drivers
>> #
>> CONFIG_I2C_ALI1535=m
>> CONFIG_I2C_ALI1563=m
>> CONFIG_I2C_ALI15X3=m
>> CONFIG_I2C_AMD756=m
>> CONFIG_I2C_AMD8111=m
>> CONFIG_I2C_I801=m
>> CONFIG_I2C_ISCH=m
>> CONFIG_I2C_PIIX4=m
>> CONFIG_I2C_NFORCE2=m
>> CONFIG_I2C_SIS5595=m
>> CONFIG_I2C_SIS630=m
>> CONFIG_I2C_SIS96X=m
>> CONFIG_I2C_VIA=m
>> CONFIG_I2C_VIAPRO=m
>>
>> #
>> # Mac SMBus host controller drivers
>> #
>> CONFIG_I2C_POWERMAC=m
>>
>> #
>> # I2C system bus drivers (mostly embedded / system-on-chip)
>> #
>> CONFIG_I2C_GPIO=m
>> CONFIG_I2C_OCORES=m
>> CONFIG_I2C_PASEMI=m
>> CONFIG_I2C_SIMTEC=m
>>
>> #
>> # External I2C/SMBus adapter drivers
>> #
>> CONFIG_I2C_PARPORT=m
>> CONFIG_I2C_PARPORT_LIGHT=m
>> CONFIG_I2C_TAOS_EVM=m
>> CONFIG_I2C_TINY_USB=m
>>
>> #
>> # Other I2C/SMBus bus drivers
>> #
>> CONFIG_I2C_PCA_PLATFORM=m
>> CONFIG_I2C_STUB=m
>>
>> #
>> # Miscellaneous I2C Chip support
>> #
>> CONFIG_SENSORS_TSL2550=m
>> CONFIG_I2C_DEBUG_CORE=y
>> CONFIG_I2C_DEBUG_ALGO=y
>> CONFIG_I2C_DEBUG_BUS=y
>> CONFIG_I2C_DEBUG_CHIP=y
>> CONFIG_SPI=y
>> CONFIG_SPI_DEBUG=y
>> CONFIG_SPI_MASTER=y
>>
>> #
>> # SPI Master Controller Drivers
>> #
>> CONFIG_SPI_BITBANG=m
>> CONFIG_SPI_BUTTERFLY=m
>> CONFIG_SPI_GPIO=m
>> CONFIG_SPI_LM70_LLP=m
>>
>> #
>> # SPI Protocol Masters
>> #
>> CONFIG_SPI_SPIDEV=m
>> CONFIG_SPI_TLE62X0=m
>>
>> #
>> # PPS support
>> #
>> CONFIG_PPS=m
>> CONFIG_PPS_DEBUG=y
>> CONFIG_ARCH_WANT_OPTIONAL_GPIOLIB=y
>> CONFIG_ARCH_REQUIRE_GPIOLIB=y
>> CONFIG_GPIOLIB=y
>> CONFIG_DEBUG_GPIO=y
>> CONFIG_GPIO_SYSFS=y
>>
>> #
>> # Memory mapped GPIO expanders:
>> #
>> CONFIG_GPIO_XILINX=y
>>
>> #
>> # I2C GPIO expanders:
>> #
>> CONFIG_GPIO_MAX732X=m
>> CONFIG_GPIO_PCA953X=m
>> CONFIG_GPIO_PCF857X=m
>> CONFIG_GPIO_WM831X=m
>>
>> #
>> # PCI GPIO expanders:
>> #
>> CONFIG_GPIO_LANGWELL=y
>>
>> #
>> # SPI GPIO expanders:
>> #
>> CONFIG_GPIO_MAX7301=m
>> CONFIG_GPIO_MCP23S08=m
>> CONFIG_GPIO_MC33880=m
>>
>> #
>> # AC97 GPIO expanders:
>> #
>> CONFIG_GPIO_UCB1400=y
>> CONFIG_W1=m
>> CONFIG_W1_CON=y
>>
>> #
>> # 1-wire Bus Masters
>> #
>> CONFIG_W1_MASTER_MATROX=m
>> CONFIG_W1_MASTER_DS2490=m
>> CONFIG_W1_MASTER_DS2482=m
>> CONFIG_W1_MASTER_GPIO=m
>>
>> #
>> # 1-wire Slaves
>> #
>> CONFIG_W1_SLAVE_THERM=m
>> CONFIG_W1_SLAVE_SMEM=m
>> CONFIG_W1_SLAVE_DS2431=m
>> CONFIG_W1_SLAVE_DS2433=m
>> CONFIG_W1_SLAVE_DS2433_CRC=y
>> CONFIG_W1_SLAVE_DS2760=m
>> CONFIG_W1_SLAVE_BQ27000=m
>> CONFIG_POWER_SUPPLY=m
>> CONFIG_POWER_SUPPLY_DEBUG=y
>> CONFIG_PDA_POWER=m
>> CONFIG_WM831X_POWER=m
>> CONFIG_WM8350_POWER=m
>> CONFIG_BATTERY_DS2760=m
>> CONFIG_BATTERY_DS2782=m
>> CONFIG_BATTERY_BQ27x00=m
>> CONFIG_BATTERY_MAX17040=m
>> CONFIG_CHARGER_PCF50633=m
>> CONFIG_HWMON=m
>> CONFIG_HWMON_VID=m
>> CONFIG_HWMON_DEBUG_CHIP=y
>>
>> #
>> # Native drivers
>> #
>> CONFIG_SENSORS_AD7414=m
>> CONFIG_SENSORS_AD7418=m
>> CONFIG_SENSORS_ADCXX=m
>> CONFIG_SENSORS_ADM1021=m
>> CONFIG_SENSORS_ADM1025=m
>> CONFIG_SENSORS_ADM1026=m
>> CONFIG_SENSORS_ADM1029=m
>> CONFIG_SENSORS_ADM1031=m
>> CONFIG_SENSORS_ADM9240=m
>> CONFIG_SENSORS_ADT7462=m
>> CONFIG_SENSORS_ADT7470=m
>> CONFIG_SENSORS_ADT7473=m
>> CONFIG_SENSORS_ADT7475=m
>> CONFIG_SENSORS_ATXP1=m
>> CONFIG_SENSORS_DS1621=m
>> CONFIG_SENSORS_I5K_AMB=m
>> CONFIG_SENSORS_F71805F=m
>> CONFIG_SENSORS_F71882FG=m
>> CONFIG_SENSORS_F75375S=m
>> CONFIG_SENSORS_G760A=m
>> CONFIG_SENSORS_GL518SM=m
>> CONFIG_SENSORS_GL520SM=m
>> CONFIG_SENSORS_IBMAEM=m
>> CONFIG_SENSORS_IBMPEX=m
>> CONFIG_SENSORS_IT87=m
>> CONFIG_SENSORS_LM63=m
>> CONFIG_SENSORS_LM70=m
>> CONFIG_SENSORS_LM73=m
>> CONFIG_SENSORS_LM75=m
>> CONFIG_SENSORS_LM77=m
>> CONFIG_SENSORS_LM78=m
>> CONFIG_SENSORS_LM80=m
>> CONFIG_SENSORS_LM83=m
>> CONFIG_SENSORS_LM85=m
>> CONFIG_SENSORS_LM87=m
>> CONFIG_SENSORS_LM90=m
>> CONFIG_SENSORS_LM92=m
>> CONFIG_SENSORS_LM93=m
>> CONFIG_SENSORS_LTC4215=m
>> CONFIG_SENSORS_LTC4245=m
>> CONFIG_SENSORS_LM95241=m
>> CONFIG_SENSORS_MAX1111=m
>> CONFIG_SENSORS_MAX1619=m
>> CONFIG_SENSORS_MAX6650=m
>> CONFIG_SENSORS_PC87360=m
>> CONFIG_SENSORS_PC87427=m
>> CONFIG_SENSORS_PCF8591=m
>> CONFIG_SENSORS_SHT15=m
>> CONFIG_SENSORS_SIS5595=m
>> CONFIG_SENSORS_DME1737=m
>> CONFIG_SENSORS_SMSC47M1=m
>> CONFIG_SENSORS_SMSC47M192=m
>> CONFIG_SENSORS_SMSC47B397=m
>> CONFIG_SENSORS_ADS7828=m
>> CONFIG_SENSORS_THMC50=m
>> CONFIG_SENSORS_TMP401=m
>> CONFIG_SENSORS_TMP421=m
>> CONFIG_SENSORS_VIA686A=m
>> CONFIG_SENSORS_VT1211=m
>> CONFIG_SENSORS_VT8231=m
>> CONFIG_SENSORS_W83781D=m
>> CONFIG_SENSORS_W83791D=m
>> CONFIG_SENSORS_W83792D=m
>> CONFIG_SENSORS_W83793=m
>> CONFIG_SENSORS_W83L785TS=m
>> CONFIG_SENSORS_W83L786NG=m
>> CONFIG_SENSORS_W83627HF=m
>> CONFIG_SENSORS_W83627EHF=m
>> CONFIG_SENSORS_WM831X=m
>> CONFIG_SENSORS_WM8350=m
>> CONFIG_SENSORS_LIS3_SPI=m
>> CONFIG_SENSORS_MC13783_ADC=m
>> CONFIG_THERMAL=m
>> CONFIG_THERMAL_HWMON=y
>> CONFIG_WATCHDOG=y
>> CONFIG_WATCHDOG_NOWAYOUT=y
>>
>> #
>> # Watchdog Device Drivers
>> #
>> CONFIG_SOFT_WATCHDOG=m
>> CONFIG_WM831X_WATCHDOG=m
>> CONFIG_WM8350_WATCHDOG=m
>> CONFIG_ALIM7101_WDT=m
>> CONFIG_WATCHDOG_RTAS=m
>>
>> #
>> # PCI-based Watchdog Cards
>> #
>> CONFIG_PCIPCWATCHDOG=m
>> CONFIG_WDTPCI=m
>>
>> #
>> # USB-based Watchdog Cards
>> #
>> CONFIG_USBPCWATCHDOG=m
>> CONFIG_SSB_POSSIBLE=y
>>
>> #
>> # Sonics Silicon Backplane
>> #
>> CONFIG_SSB=m
>> CONFIG_SSB_SPROM=y
>> CONFIG_SSB_BLOCKIO=y
>> CONFIG_SSB_PCIHOST_POSSIBLE=y
>> CONFIG_SSB_PCIHOST=y
>> CONFIG_SSB_B43_PCI_BRIDGE=y
>> CONFIG_SSB_PCMCIAHOST_POSSIBLE=y
>> CONFIG_SSB_PCMCIAHOST=y
>> CONFIG_SSB_SDIOHOST_POSSIBLE=y
>> CONFIG_SSB_SDIOHOST=y
>> CONFIG_SSB_SILENT=y
>> CONFIG_SSB_DRIVER_PCICORE_POSSIBLE=y
>> CONFIG_SSB_DRIVER_PCICORE=y
>>
>> #
>> # Multifunction device drivers
>> #
>> CONFIG_MFD_CORE=m
>> CONFIG_MFD_SM501=m
>> CONFIG_MFD_SM501_GPIO=y
>> CONFIG_HTC_PASIC3=m
>> CONFIG_UCB1400_CORE=m
>> CONFIG_TPS65010=m
>> # CONFIG_MFD_TMIO is not set
>> CONFIG_MFD_WM8400=m
>> CONFIG_MFD_WM831X=m
>> CONFIG_MFD_WM8350=m
>> CONFIG_MFD_WM8350_I2C=m
>> CONFIG_MFD_PCF50633=m
>> CONFIG_MFD_MC13783=m
>> CONFIG_PCF50633_ADC=m
>> CONFIG_PCF50633_GPIO=m
>> CONFIG_AB3100_CORE=m
>> CONFIG_AB3100_OTP=m
>> CONFIG_EZX_PCAP=y
>> CONFIG_AB4500_CORE=m
>> CONFIG_REGULATOR=y
>> CONFIG_REGULATOR_DEBUG=y
>> CONFIG_REGULATOR_FIXED_VOLTAGE=m
>> CONFIG_REGULATOR_VIRTUAL_CONSUMER=m
>> CONFIG_REGULATOR_USERSPACE_CONSUMER=m
>> CONFIG_REGULATOR_BQ24022=m
>> CONFIG_REGULATOR_MAX1586=m
>> CONFIG_REGULATOR_MAX8660=m
>> CONFIG_REGULATOR_WM831X=m
>> CONFIG_REGULATOR_WM8350=m
>> CONFIG_REGULATOR_WM8400=m
>> CONFIG_REGULATOR_PCF50633=m
>> CONFIG_REGULATOR_LP3971=m
>> CONFIG_REGULATOR_PCAP=m
>> CONFIG_REGULATOR_MC13783=m
>> CONFIG_REGULATOR_AB3100=m
>> CONFIG_REGULATOR_TPS65023=m
>> CONFIG_REGULATOR_TPS6507X=m
>> CONFIG_MEDIA_SUPPORT=m
>>
>> #
>> # Multimedia core support
>> #
>> CONFIG_VIDEO_DEV=m
>> CONFIG_VIDEO_V4L2_COMMON=m
>> CONFIG_VIDEO_ALLOW_V4L1=y
>> CONFIG_VIDEO_V4L1_COMPAT=y
>> CONFIG_DVB_CORE=m
>> CONFIG_VIDEO_MEDIA=m
>>
>> #
>> # Multimedia drivers
>> #
>> CONFIG_VIDEO_SAA7146=m
>> CONFIG_VIDEO_SAA7146_VV=m
>> CONFIG_MEDIA_ATTACH=y
>> CONFIG_MEDIA_TUNER=m
>> CONFIG_MEDIA_TUNER_CUSTOMISE=y
>> CONFIG_MEDIA_TUNER_SIMPLE=m
>> CONFIG_MEDIA_TUNER_TDA8290=m
>> CONFIG_MEDIA_TUNER_TDA827X=m
>> CONFIG_MEDIA_TUNER_TDA18271=m
>> CONFIG_MEDIA_TUNER_TDA9887=m
>> CONFIG_MEDIA_TUNER_TEA5761=m
>> CONFIG_MEDIA_TUNER_TEA5767=m
>> CONFIG_MEDIA_TUNER_MT20XX=m
>> CONFIG_MEDIA_TUNER_MT2060=m
>> CONFIG_MEDIA_TUNER_MT2266=m
>> CONFIG_MEDIA_TUNER_MT2131=m
>> CONFIG_MEDIA_TUNER_QT1010=m
>> CONFIG_MEDIA_TUNER_XC2028=m
>> CONFIG_MEDIA_TUNER_XC5000=m
>> CONFIG_MEDIA_TUNER_MXL5005S=m
>> CONFIG_MEDIA_TUNER_MXL5007T=m
>> CONFIG_MEDIA_TUNER_MC44S803=m
>> CONFIG_VIDEO_V4L2=m
>> CONFIG_VIDEO_V4L1=m
>> CONFIG_VIDEOBUF_GEN=m
>> CONFIG_VIDEOBUF_DMA_SG=m
>> CONFIG_VIDEOBUF_VMALLOC=m
>> CONFIG_VIDEOBUF_DVB=m
>> CONFIG_VIDEO_BTCX=m
>> CONFIG_VIDEO_IR=m
>> CONFIG_VIDEO_TVEEPROM=m
>> CONFIG_VIDEO_TUNER=m
>> CONFIG_VIDEO_CAPTURE_DRIVERS=y
>> CONFIG_VIDEO_ADV_DEBUG=y
>> CONFIG_VIDEO_FIXED_MINOR_RANGES=y
>> CONFIG_VIDEO_HELPER_CHIPS_AUTO=y
>> CONFIG_VIDEO_IR_I2C=m
>> CONFIG_VIDEO_TVAUDIO=m
>> CONFIG_VIDEO_TDA7432=m
>> CONFIG_VIDEO_TDA9840=m
>> CONFIG_VIDEO_TEA6415C=m
>> CONFIG_VIDEO_TEA6420=m
>> CONFIG_VIDEO_MSP3400=m
>> CONFIG_VIDEO_CS5345=m
>> CONFIG_VIDEO_CS53L32A=m
>> CONFIG_VIDEO_M52790=m
>> CONFIG_VIDEO_WM8775=m
>> CONFIG_VIDEO_WM8739=m
>> CONFIG_VIDEO_VP27SMPX=m
>> CONFIG_VIDEO_SAA6588=m
>> CONFIG_VIDEO_OV7670=m
>> CONFIG_VIDEO_MT9V011=m
>> CONFIG_VIDEO_SAA711X=m
>> CONFIG_VIDEO_SAA717X=m
>> CONFIG_VIDEO_TVP5150=m
>> CONFIG_VIDEO_CX25840=m
>> CONFIG_VIDEO_CX2341X=m
>> CONFIG_VIDEO_SAA7127=m
>> CONFIG_VIDEO_UPD64031A=m
>> CONFIG_VIDEO_UPD64083=m
>> CONFIG_VIDEO_VIVI=m
>> CONFIG_VIDEO_BT848=m
>> CONFIG_VIDEO_BT848_DVB=y
>> CONFIG_VIDEO_BWQCAM=m
>> CONFIG_VIDEO_CQCAM=m
>> CONFIG_VIDEO_W9966=m
>> CONFIG_VIDEO_CPIA=m
>> CONFIG_VIDEO_CPIA_PP=m
>> CONFIG_VIDEO_CPIA_USB=m
>> CONFIG_VIDEO_CPIA2=m
>> CONFIG_VIDEO_SAA5246A=m
>> CONFIG_VIDEO_SAA5249=m
>> CONFIG_VIDEO_SAA7134=m
>> CONFIG_VIDEO_SAA7134_ALSA=m
>> CONFIG_VIDEO_SAA7134_DVB=m
>> CONFIG_VIDEO_MXB=m
>> CONFIG_VIDEO_HEXIUM_ORION=m
>> CONFIG_VIDEO_HEXIUM_GEMINI=m
>> CONFIG_VIDEO_CX88=m
>> CONFIG_VIDEO_CX88_ALSA=m
>> CONFIG_VIDEO_CX88_BLACKBIRD=m
>> CONFIG_VIDEO_CX88_DVB=m
>> CONFIG_VIDEO_CX88_MPEG=m
>> CONFIG_VIDEO_CX88_VP3054=m
>> CONFIG_VIDEO_CX23885=m
>> CONFIG_VIDEO_AU0828=m
>> CONFIG_VIDEO_IVTV=m
>> CONFIG_VIDEO_FB_IVTV=m
>> CONFIG_VIDEO_CX18=m
>> CONFIG_VIDEO_SAA7164=m
>> CONFIG_VIDEO_CAFE_CCIC=m
>> CONFIG_SOC_CAMERA=m
>> CONFIG_SOC_CAMERA_MT9M001=m
>> CONFIG_SOC_CAMERA_MT9M111=m
>> CONFIG_SOC_CAMERA_MT9T031=m
>> CONFIG_SOC_CAMERA_MT9V022=m
>> CONFIG_SOC_CAMERA_TW9910=m
>> CONFIG_SOC_CAMERA_PLATFORM=m
>> CONFIG_SOC_CAMERA_OV772X=m
>> CONFIG_V4L_USB_DRIVERS=y
>> CONFIG_USB_VIDEO_CLASS=m
>> CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y
>> CONFIG_USB_GSPCA=m
>> CONFIG_USB_M5602=m
>> CONFIG_USB_STV06XX=m
>> CONFIG_USB_GL860=m
>> CONFIG_USB_GSPCA_CONEX=m
>> CONFIG_USB_GSPCA_ETOMS=m
>> CONFIG_USB_GSPCA_FINEPIX=m
>> CONFIG_USB_GSPCA_JEILINJ=m
>> CONFIG_USB_GSPCA_MARS=m
>> CONFIG_USB_GSPCA_MR97310A=m
>> CONFIG_USB_GSPCA_OV519=m
>> CONFIG_USB_GSPCA_OV534=m
>> CONFIG_USB_GSPCA_PAC207=m
>> CONFIG_USB_GSPCA_PAC7311=m
>> CONFIG_USB_GSPCA_SN9C20X=m
>> CONFIG_USB_GSPCA_SN9C20X_EVDEV=y
>> CONFIG_USB_GSPCA_SONIXB=m
>> CONFIG_USB_GSPCA_SONIXJ=m
>> CONFIG_USB_GSPCA_SPCA500=m
>> CONFIG_USB_GSPCA_SPCA501=m
>> CONFIG_USB_GSPCA_SPCA505=m
>> CONFIG_USB_GSPCA_SPCA506=m
>> CONFIG_USB_GSPCA_SPCA508=m
>> CONFIG_USB_GSPCA_SPCA561=m
>> CONFIG_USB_GSPCA_SQ905=m
>> CONFIG_USB_GSPCA_SQ905C=m
>> CONFIG_USB_GSPCA_STK014=m
>> CONFIG_USB_GSPCA_SUNPLUS=m
>> CONFIG_USB_GSPCA_T613=m
>> CONFIG_USB_GSPCA_TV8532=m
>> CONFIG_USB_GSPCA_VC032X=m
>> CONFIG_USB_GSPCA_ZC3XX=m
>> CONFIG_VIDEO_PVRUSB2=m
>> CONFIG_VIDEO_PVRUSB2_SYSFS=y
>> CONFIG_VIDEO_PVRUSB2_DVB=y
>> CONFIG_VIDEO_PVRUSB2_DEBUGIFC=y
>> CONFIG_VIDEO_HDPVR=m
>> CONFIG_VIDEO_EM28XX=m
>> CONFIG_VIDEO_EM28XX_ALSA=m
>> CONFIG_VIDEO_EM28XX_DVB=m
>> CONFIG_VIDEO_CX231XX=m
>> CONFIG_VIDEO_CX231XX_ALSA=m
>> CONFIG_VIDEO_CX231XX_DVB=m
>> CONFIG_VIDEO_USBVISION=m
>> CONFIG_VIDEO_USBVIDEO=m
>> CONFIG_USB_VICAM=m
>> CONFIG_USB_IBMCAM=m
>> CONFIG_USB_KONICAWC=m
>> CONFIG_USB_QUICKCAM_MESSENGER=m
>> CONFIG_USB_ET61X251=m
>> CONFIG_VIDEO_OVCAMCHIP=m
>> CONFIG_USB_W9968CF=m
>> CONFIG_USB_OV511=m
>> CONFIG_USB_SE401=m
>> CONFIG_USB_SN9C102=m
>> CONFIG_USB_STV680=m
>> CONFIG_USB_ZC0301=m
>> CONFIG_USB_PWC=m
>> CONFIG_USB_PWC_DEBUG=y
>> CONFIG_USB_PWC_INPUT_EVDEV=y
>> CONFIG_USB_ZR364XX=m
>> CONFIG_USB_STKWEBCAM=m
>> CONFIG_USB_S2255=m
>> CONFIG_RADIO_ADAPTERS=y
>> CONFIG_RADIO_GEMTEK_PCI=m
>> CONFIG_RADIO_MAXIRADIO=m
>> CONFIG_RADIO_MAESTRO=m
>> CONFIG_I2C_SI4713=m
>> CONFIG_RADIO_SI4713=m
>> CONFIG_USB_DSBR=m
>> CONFIG_RADIO_SI470X=y
>> CONFIG_USB_SI470X=m
>> CONFIG_I2C_SI470X=m
>> CONFIG_USB_MR800=m
>> CONFIG_RADIO_TEA5764=m
>> CONFIG_DVB_MAX_ADAPTERS=8
>> CONFIG_DVB_DYNAMIC_MINORS=y
>> CONFIG_DVB_CAPTURE_DRIVERS=y
>>
>> #
>> # Supported SAA7146 based PCI Adapters
>> #
>> CONFIG_TTPCI_EEPROM=m
>> CONFIG_DVB_AV7110=m
>> CONFIG_DVB_AV7110_OSD=y
>> CONFIG_DVB_BUDGET_CORE=m
>> CONFIG_DVB_BUDGET=m
>> CONFIG_DVB_BUDGET_CI=m
>> CONFIG_DVB_BUDGET_AV=m
>> CONFIG_DVB_BUDGET_PATCH=m
>>
>> #
>> # Supported USB Adapters
>> #
>> CONFIG_DVB_USB=m
>> CONFIG_DVB_USB_DEBUG=y
>> CONFIG_DVB_USB_A800=m
>> CONFIG_DVB_USB_DIBUSB_MB=m
>> CONFIG_DVB_USB_DIBUSB_MB_FAULTY=y
>> CONFIG_DVB_USB_DIBUSB_MC=m
>> CONFIG_DVB_USB_DIB0700=m
>> CONFIG_DVB_USB_UMT_010=m
>> CONFIG_DVB_USB_CXUSB=m
>> CONFIG_DVB_USB_M920X=m
>> CONFIG_DVB_USB_GL861=m
>> CONFIG_DVB_USB_AU6610=m
>> CONFIG_DVB_USB_DIGITV=m
>> CONFIG_DVB_USB_VP7045=m
>> CONFIG_DVB_USB_VP702X=m
>> CONFIG_DVB_USB_GP8PSK=m
>> CONFIG_DVB_USB_NOVA_T_USB2=m
>> CONFIG_DVB_USB_TTUSB2=m
>> CONFIG_DVB_USB_DTT200U=m
>> CONFIG_DVB_USB_OPERA1=m
>> CONFIG_DVB_USB_AF9005=m
>> CONFIG_DVB_USB_AF9005_REMOTE=m
>> CONFIG_DVB_USB_DW2102=m
>> CONFIG_DVB_USB_CINERGY_T2=m
>> CONFIG_DVB_USB_ANYSEE=m
>> CONFIG_DVB_USB_DTV5100=m
>> CONFIG_DVB_USB_AF9015=m
>> CONFIG_DVB_USB_CE6230=m
>> CONFIG_DVB_USB_FRIIO=m
>> CONFIG_DVB_TTUSB_BUDGET=m
>> CONFIG_DVB_TTUSB_DEC=m
>> CONFIG_SMS_SIANO_MDTV=m
>>
>> #
>> # Siano module components
>> #
>> CONFIG_SMS_USB_DRV=m
>> CONFIG_SMS_SDIO_DRV=m
>>
>> #
>> # Supported FlexCopII (B2C2) Adapters
>> #
>> CONFIG_DVB_B2C2_FLEXCOP=m
>> CONFIG_DVB_B2C2_FLEXCOP_PCI=m
>> CONFIG_DVB_B2C2_FLEXCOP_USB=m
>> CONFIG_DVB_B2C2_FLEXCOP_DEBUG=y
>>
>> #
>> # Supported BT878 Adapters
>> #
>> CONFIG_DVB_BT8XX=m
>>
>> #
>> # Supported Pluto2 Adapters
>> #
>> CONFIG_DVB_PLUTO2=m
>>
>> #
>> # Supported SDMC DM1105 Adapters
>> #
>> CONFIG_DVB_DM1105=m
>>
>> #
>> # Supported FireWire (IEEE 1394) Adapters
>> #
>> CONFIG_DVB_FIREDTV=m
>> CONFIG_DVB_FIREDTV_IEEE1394=y
>> CONFIG_DVB_FIREDTV_INPUT=y
>>
>> #
>> # Supported Earthsoft PT1 Adapters
>> #
>> CONFIG_DVB_PT1=m
>>
>> #
>> # Supported DVB Frontends
>> #
>> CONFIG_DVB_FE_CUSTOMISE=y
>>
>> #
>> # Customise DVB Frontends
>> #
>>
>> #
>> # Multistandard (satellite) frontends
>> #
>> CONFIG_DVB_STB0899=m
>> CONFIG_DVB_STB6100=m
>> CONFIG_DVB_STV090x=m
>> CONFIG_DVB_STV6110x=m
>>
>> #
>> # DVB-S (satellite) frontends
>> #
>> CONFIG_DVB_CX24110=m
>> CONFIG_DVB_CX24123=m
>> CONFIG_DVB_MT312=m
>> CONFIG_DVB_ZL10036=m
>> CONFIG_DVB_ZL10039=m
>> CONFIG_DVB_S5H1420=m
>> CONFIG_DVB_STV0288=m
>> CONFIG_DVB_STB6000=m
>> CONFIG_DVB_STV0299=m
>> CONFIG_DVB_STV6110=m
>> CONFIG_DVB_STV0900=m
>> CONFIG_DVB_TDA8083=m
>> CONFIG_DVB_TDA10086=m
>> CONFIG_DVB_TDA8261=m
>> CONFIG_DVB_VES1X93=m
>> CONFIG_DVB_TUNER_ITD1000=m
>> CONFIG_DVB_TUNER_CX24113=m
>> CONFIG_DVB_TDA826X=m
>> CONFIG_DVB_TUA6100=m
>> CONFIG_DVB_CX24116=m
>> CONFIG_DVB_SI21XX=m
>>
>> #
>> # DVB-T (terrestrial) frontends
>> #
>> CONFIG_DVB_SP8870=m
>> CONFIG_DVB_SP887X=m
>> CONFIG_DVB_CX22700=m
>> CONFIG_DVB_CX22702=m
>> CONFIG_DVB_DRX397XD=m
>> CONFIG_DVB_L64781=m
>> CONFIG_DVB_TDA1004X=m
>> CONFIG_DVB_NXT6000=m
>> CONFIG_DVB_MT352=m
>> CONFIG_DVB_ZL10353=m
>> CONFIG_DVB_DIB3000MB=m
>> CONFIG_DVB_DIB3000MC=m
>> CONFIG_DVB_DIB7000M=m
>> CONFIG_DVB_DIB7000P=m
>> CONFIG_DVB_TDA10048=m
>> CONFIG_DVB_AF9013=m
>>
>> #
>> # DVB-C (cable) frontends
>> #
>> CONFIG_DVB_VES1820=m
>> CONFIG_DVB_TDA10021=m
>> CONFIG_DVB_TDA10023=m
>> CONFIG_DVB_STV0297=m
>>
>> #
>> # ATSC (North American/Korean Terrestrial/Cable DTV) frontends
>> #
>> CONFIG_DVB_NXT200X=m
>> CONFIG_DVB_OR51211=m
>> CONFIG_DVB_OR51132=m
>> CONFIG_DVB_BCM3510=m
>> CONFIG_DVB_LGDT330X=m
>> CONFIG_DVB_LGDT3304=m
>> CONFIG_DVB_LGDT3305=m
>> CONFIG_DVB_S5H1409=m
>> CONFIG_DVB_AU8522=m
>> CONFIG_DVB_S5H1411=m
>>
>> #
>> # ISDB-T (terrestrial) frontends
>> #
>> CONFIG_DVB_S921=m
>> CONFIG_DVB_DIB8000=m
>>
>> #
>> # Digital terrestrial only tuners/PLL
>> #
>> CONFIG_DVB_PLL=m
>> CONFIG_DVB_TUNER_DIB0070=m
>>
>> #
>> # SEC control devices for DVB-S
>> #
>> CONFIG_DVB_LNBP21=m
>> CONFIG_DVB_ISL6405=m
>> CONFIG_DVB_ISL6421=m
>> CONFIG_DVB_ISL6423=m
>> CONFIG_DVB_LGS8GL5=m
>> CONFIG_DVB_LGS8GXX=m
>>
>> #
>> # Tools to develop new frontends
>> #
>> CONFIG_DVB_DUMMY_FE=m
>> CONFIG_DAB=y
>> CONFIG_USB_DABUSB=m
>>
>> #
>> # Graphics support
>> #
>> CONFIG_AGP=m
>> CONFIG_AGP_UNINORTH=m
>> CONFIG_VGA_ARB=y
>> CONFIG_DRM=m
>> CONFIG_DRM_KMS_HELPER=m
>> CONFIG_DRM_TTM=m
>> CONFIG_DRM_TDFX=m
>> CONFIG_DRM_R128=m
>> CONFIG_DRM_RADEON=m
>> CONFIG_DRM_MGA=m
>> CONFIG_DRM_SIS=m
>> CONFIG_DRM_VIA=m
>> CONFIG_DRM_SAVAGE=m
>> CONFIG_VGASTATE=m
>> CONFIG_VIDEO_OUTPUT_CONTROL=m
>> CONFIG_FB=m
>> CONFIG_FIRMWARE_EDID=y
>> CONFIG_FB_DDC=m
>> # CONFIG_FB_BOOT_VESA_SUPPORT is not set
>> CONFIG_FB_CFB_FILLRECT=m
>> CONFIG_FB_CFB_COPYAREA=m
>> CONFIG_FB_CFB_IMAGEBLIT=m
>> # CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set
>> CONFIG_FB_SYS_FILLRECT=m
>> CONFIG_FB_SYS_COPYAREA=m
>> CONFIG_FB_SYS_IMAGEBLIT=m
>> CONFIG_FB_FOREIGN_ENDIAN=y
>> CONFIG_FB_BOTH_ENDIAN=y
>> # CONFIG_FB_BIG_ENDIAN is not set
>> # CONFIG_FB_LITTLE_ENDIAN is not set
>> CONFIG_FB_SYS_FOPS=m
>> CONFIG_FB_DEFERRED_IO=y
>> CONFIG_FB_SVGALIB=m
>> CONFIG_FB_MACMODES=m
>> CONFIG_FB_BACKLIGHT=y
>> CONFIG_FB_MODE_HELPERS=y
>> CONFIG_FB_TILEBLITTING=y
>>
>> #
>> # Frame buffer hardware drivers
>> #
>> CONFIG_FB_CIRRUS=m
>> CONFIG_FB_PM2=m
>> CONFIG_FB_PM2_FIFO_DISCONNECT=y
>> CONFIG_FB_CYBER2000=m
>> CONFIG_FB_VGA16=m
>> CONFIG_FB_UVESA=m
>> CONFIG_FB_S1D13XXX=m
>> CONFIG_FB_NVIDIA=m
>> CONFIG_FB_NVIDIA_I2C=y
>> CONFIG_FB_NVIDIA_DEBUG=y
>> CONFIG_FB_NVIDIA_BACKLIGHT=y
>> CONFIG_FB_RIVA=m
>> CONFIG_FB_RIVA_I2C=y
>> CONFIG_FB_RIVA_DEBUG=y
>> CONFIG_FB_RIVA_BACKLIGHT=y
>> CONFIG_FB_MATROX=m
>> CONFIG_FB_MATROX_MILLENIUM=y
>> CONFIG_FB_MATROX_MYSTIQUE=y
>> CONFIG_FB_MATROX_G=y
>> CONFIG_FB_MATROX_I2C=m
>> CONFIG_FB_MATROX_MAVEN=m
>> CONFIG_FB_RADEON=m
>> CONFIG_FB_RADEON_I2C=y
>> CONFIG_FB_RADEON_BACKLIGHT=y
>> CONFIG_FB_RADEON_DEBUG=y
>> CONFIG_FB_ATY128=m
>> CONFIG_FB_ATY128_BACKLIGHT=y
>> CONFIG_FB_ATY=m
>> CONFIG_FB_ATY_CT=y
>> CONFIG_FB_ATY_GENERIC_LCD=y
>> CONFIG_FB_ATY_GX=y
>> CONFIG_FB_ATY_BACKLIGHT=y
>> CONFIG_FB_S3=m
>> CONFIG_FB_SAVAGE=m
>> CONFIG_FB_SAVAGE_I2C=y
>> CONFIG_FB_SAVAGE_ACCEL=y
>> CONFIG_FB_SIS=m
>> CONFIG_FB_SIS_300=y
>> CONFIG_FB_SIS_315=y
>> CONFIG_FB_VIA=m
>> CONFIG_FB_NEOMAGIC=m
>> CONFIG_FB_KYRO=m
>> CONFIG_FB_3DFX=m
>> CONFIG_FB_3DFX_ACCEL=y
>> CONFIG_FB_3DFX_I2C=y
>> CONFIG_FB_VOODOO1=m
>> CONFIG_FB_VT8623=m
>> CONFIG_FB_TRIDENT=m
>> CONFIG_FB_ARK=m
>> CONFIG_FB_PM3=m
>> CONFIG_FB_CARMINE=m
>> CONFIG_FB_CARMINE_DRAM_EVAL=y
>> # CONFIG_CARMINE_DRAM_CUSTOM is not set
>> CONFIG_FB_TMIO=m
>> CONFIG_FB_TMIO_ACCELL=y
>> CONFIG_FB_SM501=m
>> CONFIG_FB_IBM_GXT4500=m
>> CONFIG_FB_PS3=m
>> CONFIG_FB_PS3_DEFAULT_SIZE_M=9
>> CONFIG_FB_VIRTUAL=m
>> CONFIG_FB_METRONOME=m
>> CONFIG_FB_MB862XX=m
>> CONFIG_FB_MB862XX_PCI_GDC=y
>> CONFIG_FB_BROADSHEET=m
>> CONFIG_BACKLIGHT_LCD_SUPPORT=y
>> CONFIG_LCD_CLASS_DEVICE=m
>> CONFIG_LCD_LMS283GF05=m
>> CONFIG_LCD_LTV350QV=m
>> CONFIG_LCD_ILI9320=m
>> CONFIG_LCD_TDO24M=m
>> CONFIG_LCD_VGG2432A4=m
>> CONFIG_LCD_PLATFORM=m
>> CONFIG_BACKLIGHT_CLASS_DEVICE=m
>> CONFIG_BACKLIGHT_GENERIC=m
>> CONFIG_BACKLIGHT_WM831X=m
>>
>> #
>> # Display device support
>> #
>> CONFIG_DISPLAY_SUPPORT=m
>>
>> #
>> # Display hardware drivers
>> #
>>
>> #
>> # Console display driver support
>> #
>> CONFIG_VGA_CONSOLE=y
>> CONFIG_VGACON_SOFT_SCROLLBACK=y
>> CONFIG_VGACON_SOFT_SCROLLBACK_SIZE=64
>> CONFIG_DUMMY_CONSOLE=y
>> CONFIG_FRAMEBUFFER_CONSOLE=m
>> CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
>> CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
>> CONFIG_FONTS=y
>> CONFIG_FONT_8x8=y
>> CONFIG_FONT_8x16=y
>> CONFIG_FONT_6x11=y
>> CONFIG_FONT_7x14=y
>> CONFIG_FONT_PEARL_8x8=y
>> CONFIG_FONT_ACORN_8x8=y
>> CONFIG_FONT_MINI_4x6=y
>> CONFIG_FONT_SUN8x16=y
>> CONFIG_FONT_SUN12x22=y
>> CONFIG_FONT_10x18=y
>> CONFIG_LOGO=y
>> CONFIG_LOGO_LINUX_MONO=y
>> CONFIG_LOGO_LINUX_VGA16=y
>> CONFIG_LOGO_LINUX_CLUT224=y
>> CONFIG_SOUND=m
>> CONFIG_SOUND_OSS_CORE=y
>> CONFIG_SOUND_OSS_CORE_PRECLAIM=y
>> CONFIG_SND=m
>> CONFIG_SND_TIMER=m
>> CONFIG_SND_PCM=m
>> CONFIG_SND_HWDEP=m
>> CONFIG_SND_RAWMIDI=m
>> CONFIG_SND_JACK=y
>> CONFIG_SND_SEQUENCER=m
>> CONFIG_SND_SEQ_DUMMY=m
>> CONFIG_SND_OSSEMUL=y
>> CONFIG_SND_MIXER_OSS=m
>> CONFIG_SND_PCM_OSS=m
>> CONFIG_SND_PCM_OSS_PLUGINS=y
>> CONFIG_SND_SEQUENCER_OSS=y
>> CONFIG_SND_HRTIMER=m
>> CONFIG_SND_SEQ_HRTIMER_DEFAULT=y
>> CONFIG_SND_DYNAMIC_MINORS=y
>> CONFIG_SND_SUPPORT_OLD_API=y
>> CONFIG_SND_VERBOSE_PROCFS=y
>> CONFIG_SND_VERBOSE_PRINTK=y
>> CONFIG_SND_DEBUG=y
>> CONFIG_SND_DEBUG_VERBOSE=y
>> CONFIG_SND_PCM_XRUN_DEBUG=y
>> CONFIG_SND_VMASTER=y
>> CONFIG_SND_RAWMIDI_SEQ=m
>> CONFIG_SND_OPL3_LIB_SEQ=m
>> # CONFIG_SND_OPL4_LIB_SEQ is not set
>> # CONFIG_SND_SBAWE_SEQ is not set
>> CONFIG_SND_EMU10K1_SEQ=m
>> CONFIG_SND_MPU401_UART=m
>> CONFIG_SND_OPL3_LIB=m
>> CONFIG_SND_VX_LIB=m
>> CONFIG_SND_AC97_CODEC=m
>> CONFIG_SND_DRIVERS=y
>> CONFIG_SND_DUMMY=m
>> CONFIG_SND_VIRMIDI=m
>> CONFIG_SND_MTPAV=m
>> CONFIG_SND_MTS64=m
>> CONFIG_SND_SERIAL_U16550=m
>> CONFIG_SND_MPU401=m
>> CONFIG_SND_PORTMAN2X4=m
>> CONFIG_SND_AC97_POWER_SAVE=y
>> CONFIG_SND_AC97_POWER_SAVE_DEFAULT=0
>> CONFIG_SND_SB_COMMON=m
>> CONFIG_SND_SB16_DSP=m
>> CONFIG_SND_PCI=y
>> CONFIG_SND_AD1889=m
>> CONFIG_SND_ALS300=m
>> CONFIG_SND_ALS4000=m
>> CONFIG_SND_ALI5451=m
>> CONFIG_SND_ATIIXP=m
>> CONFIG_SND_ATIIXP_MODEM=m
>> CONFIG_SND_AU8810=m
>> CONFIG_SND_AU8820=m
>> CONFIG_SND_AU8830=m
>> CONFIG_SND_AW2=m
>> CONFIG_SND_AZT3328=m
>> CONFIG_SND_BT87X=m
>> CONFIG_SND_BT87X_OVERCLOCK=y
>> CONFIG_SND_CA0106=m
>> CONFIG_SND_CMIPCI=m
>> CONFIG_SND_OXYGEN_LIB=m
>> CONFIG_SND_OXYGEN=m
>> CONFIG_SND_CS4281=m
>> CONFIG_SND_CS46XX=m
>> CONFIG_SND_CS46XX_NEW_DSP=y
>> CONFIG_SND_CS5530=m
>> CONFIG_SND_CS5535AUDIO=m
>> CONFIG_SND_CTXFI=m
>> CONFIG_SND_DARLA20=m
>> CONFIG_SND_GINA20=m
>> CONFIG_SND_LAYLA20=m
>> CONFIG_SND_DARLA24=m
>> CONFIG_SND_GINA24=m
>> CONFIG_SND_LAYLA24=m
>> CONFIG_SND_MONA=m
>> CONFIG_SND_MIA=m
>> CONFIG_SND_ECHO3G=m
>> CONFIG_SND_INDIGO=m
>> CONFIG_SND_INDIGOIO=m
>> CONFIG_SND_INDIGODJ=m
>> CONFIG_SND_INDIGOIOX=m
>> CONFIG_SND_INDIGODJX=m
>> CONFIG_SND_EMU10K1=m
>> CONFIG_SND_EMU10K1X=m
>> CONFIG_SND_ENS1370=m
>> CONFIG_SND_ENS1371=m
>> CONFIG_SND_ES1938=m
>> CONFIG_SND_ES1968=m
>> CONFIG_SND_FM801=m
>> CONFIG_SND_FM801_TEA575X_BOOL=y
>> CONFIG_SND_FM801_TEA575X=m
>> CONFIG_SND_HDA_INTEL=m
>> CONFIG_SND_HDA_HWDEP=y
>> CONFIG_SND_HDA_RECONFIG=y
>> CONFIG_SND_HDA_INPUT_BEEP=y
>> CONFIG_SND_HDA_INPUT_JACK=y
>> CONFIG_SND_HDA_PATCH_LOADER=y
>> CONFIG_SND_HDA_CODEC_REALTEK=y
>> CONFIG_SND_HDA_CODEC_ANALOG=y
>> CONFIG_SND_HDA_CODEC_SIGMATEL=y
>> CONFIG_SND_HDA_CODEC_VIA=y
>> CONFIG_SND_HDA_CODEC_ATIHDMI=y
>> CONFIG_SND_HDA_CODEC_NVHDMI=y
>> CONFIG_SND_HDA_CODEC_INTELHDMI=y
>> CONFIG_SND_HDA_ELD=y
>> CONFIG_SND_HDA_CODEC_CIRRUS=y
>> CONFIG_SND_HDA_CODEC_CONEXANT=y
>> CONFIG_SND_HDA_CODEC_CA0110=y
>> CONFIG_SND_HDA_CODEC_CMEDIA=y
>> CONFIG_SND_HDA_CODEC_SI3054=y
>> CONFIG_SND_HDA_GENERIC=y
>> CONFIG_SND_HDA_POWER_SAVE=y
>> CONFIG_SND_HDA_POWER_SAVE_DEFAULT=0
>> CONFIG_SND_HDSP=m
>> CONFIG_SND_HDSPM=m
>> CONFIG_SND_HIFIER=m
>> CONFIG_SND_ICE1712=m
>> CONFIG_SND_ICE1724=m
>> CONFIG_SND_INTEL8X0=m
>> CONFIG_SND_INTEL8X0M=m
>> CONFIG_SND_KORG1212=m
>> CONFIG_SND_LX6464ES=m
>> CONFIG_SND_MAESTRO3=m
>> CONFIG_SND_MIXART=m
>> CONFIG_SND_NM256=m
>> CONFIG_SND_PCXHR=m
>> CONFIG_SND_RIPTIDE=m
>> CONFIG_SND_RME32=m
>> CONFIG_SND_RME96=m
>> CONFIG_SND_RME9652=m
>> CONFIG_SND_SONICVIBES=m
>> CONFIG_SND_TRIDENT=m
>> CONFIG_SND_VIA82XX=m
>> CONFIG_SND_VIA82XX_MODEM=m
>> CONFIG_SND_VIRTUOSO=m
>> CONFIG_SND_VX222=m
>> CONFIG_SND_YMFPCI=m
>> CONFIG_SND_PPC=y
>> CONFIG_SND_POWERMAC=m
>> CONFIG_SND_POWERMAC_AUTO_DRC=y
>> CONFIG_SND_PS3=m
>> CONFIG_SND_PS3_DEFAULT_START_DELAY=2000
>> CONFIG_SND_AOA=m
>> CONFIG_SND_AOA_FABRIC_LAYOUT=m
>> CONFIG_SND_AOA_ONYX=m
>> CONFIG_SND_AOA_TAS=m
>> CONFIG_SND_AOA_TOONIE=m
>> CONFIG_SND_AOA_SOUNDBUS=m
>> CONFIG_SND_AOA_SOUNDBUS_I2S=m
>> CONFIG_SND_SPI=y
>> CONFIG_SND_USB=y
>> CONFIG_SND_USB_AUDIO=m
>> CONFIG_SND_USB_USX2Y=m
>> CONFIG_SND_USB_CAIAQ=m
>> CONFIG_SND_USB_CAIAQ_INPUT=y
>> CONFIG_SND_PCMCIA=y
>> CONFIG_SND_VXPOCKET=m
>> CONFIG_SND_PDAUDIOCF=m
>> CONFIG_SND_SOC=m
>> CONFIG_SND_SOC_I2C_AND_SPI=m
>> CONFIG_SND_SOC_ALL_CODECS=m
>> CONFIG_SND_SOC_WM_HUBS=m
>> CONFIG_SND_SOC_AD1836=m
>> CONFIG_SND_SOC_AD1938=m
>> CONFIG_SND_SOC_AD73311=m
>> CONFIG_SND_SOC_AK4104=m
>> CONFIG_SND_SOC_AK4535=m
>> CONFIG_SND_SOC_AK4642=m
>> CONFIG_SND_SOC_AK4671=m
>> CONFIG_SND_SOC_CS4270=m
>> CONFIG_SND_SOC_L3=m
>> CONFIG_SND_SOC_PCM3008=m
>> CONFIG_SND_SOC_SPDIF=m
>> CONFIG_SND_SOC_SSM2602=m
>> CONFIG_SND_SOC_TLV320AIC23=m
>> CONFIG_SND_SOC_TLV320AIC26=m
>> CONFIG_SND_SOC_TLV320AIC3X=m
>> CONFIG_SND_SOC_UDA134X=m
>> CONFIG_SND_SOC_UDA1380=m
>> CONFIG_SND_SOC_WM8350=m
>> CONFIG_SND_SOC_WM8400=m
>> CONFIG_SND_SOC_WM8510=m
>> CONFIG_SND_SOC_WM8523=m
>> CONFIG_SND_SOC_WM8580=m
>> CONFIG_SND_SOC_WM8711=m
>> CONFIG_SND_SOC_WM8728=m
>> CONFIG_SND_SOC_WM8731=m
>> CONFIG_SND_SOC_WM8750=m
>> CONFIG_SND_SOC_WM8753=m
>> CONFIG_SND_SOC_WM8776=m
>> CONFIG_SND_SOC_WM8900=m
>> CONFIG_SND_SOC_WM8903=m
>> CONFIG_SND_SOC_WM8940=m
>> CONFIG_SND_SOC_WM8960=m
>> CONFIG_SND_SOC_WM8961=m
>> CONFIG_SND_SOC_WM8971=m
>> CONFIG_SND_SOC_WM8974=m
>> CONFIG_SND_SOC_WM8988=m
>> CONFIG_SND_SOC_WM8990=m
>> CONFIG_SND_SOC_WM8993=m
>> CONFIG_SND_SOC_WM9081=m
>> CONFIG_SND_SOC_MAX9877=m
>> CONFIG_SND_SOC_TPA6130A2=m
>> CONFIG_SOUND_PRIME=m
>> CONFIG_AC97_BUS=m
>> CONFIG_HID_SUPPORT=y
>> CONFIG_HID=m
>> CONFIG_HIDRAW=y
>>
>> #
>> # USB Input Devices
>> #
>> CONFIG_USB_HID=m
>> CONFIG_HID_PID=y
>> CONFIG_USB_HIDDEV=y
>>
>> #
>> # USB HID Boot Protocol drivers
>> #
>> CONFIG_USB_KBD=m
>> CONFIG_USB_MOUSE=m
>>
>> #
>> # Special HID drivers
>> #
>> CONFIG_HID_A4TECH=m
>> CONFIG_HID_APPLE=m
>> CONFIG_HID_BELKIN=m
>> CONFIG_HID_CHERRY=m
>> CONFIG_HID_CHICONY=m
>> CONFIG_HID_CYPRESS=m
>> CONFIG_HID_DRAGONRISE=m
>> CONFIG_DRAGONRISE_FF=y
>> CONFIG_HID_EZKEY=m
>> CONFIG_HID_KYE=m
>> CONFIG_HID_GYRATION=m
>> CONFIG_HID_TWINHAN=m
>> CONFIG_HID_KENSINGTON=m
>> CONFIG_HID_LOGITECH=m
>> CONFIG_LOGITECH_FF=y
>> CONFIG_LOGIRUMBLEPAD2_FF=y
>> CONFIG_HID_MICROSOFT=m
>> CONFIG_HID_MONTEREY=m
>> CONFIG_HID_NTRIG=m
>> CONFIG_HID_PANTHERLORD=m
>> CONFIG_PANTHERLORD_FF=y
>> CONFIG_HID_PETALYNX=m
>> CONFIG_HID_SAMSUNG=m
>> CONFIG_HID_SONY=m
>> CONFIG_HID_SUNPLUS=m
>> CONFIG_HID_GREENASIA=m
>> CONFIG_GREENASIA_FF=y
>> CONFIG_HID_SMARTJOYPLUS=m
>> CONFIG_SMARTJOYPLUS_FF=y
>> CONFIG_HID_TOPSEED=m
>> CONFIG_HID_THRUSTMASTER=m
>> CONFIG_THRUSTMASTER_FF=y
>> CONFIG_HID_WACOM=m
>> CONFIG_HID_ZEROPLUS=m
>> CONFIG_ZEROPLUS_FF=y
>> CONFIG_USB_SUPPORT=y
>> CONFIG_USB_ARCH_HAS_HCD=y
>> CONFIG_USB_ARCH_HAS_OHCI=y
>> CONFIG_USB_ARCH_HAS_EHCI=y
>> CONFIG_USB=m
>> CONFIG_USB_DEBUG=y
>> CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
>>
>> #
>> # Miscellaneous USB options
>> #
>> CONFIG_USB_DEVICEFS=y
>> CONFIG_USB_DEVICE_CLASS=y
>> CONFIG_USB_DYNAMIC_MINORS=y
>> CONFIG_USB_SUSPEND=y
>> # CONFIG_USB_OTG is not set
>> CONFIG_USB_OTG_WHITELIST=y
>> CONFIG_USB_OTG_BLACKLIST_HUB=y
>> CONFIG_USB_MON=m
>> CONFIG_USB_WUSB=m
>> CONFIG_USB_WUSB_CBAF=m
>> CONFIG_USB_WUSB_CBAF_DEBUG=y
>>
>> #
>> # USB Host Controller Drivers
>> #
>> CONFIG_USB_C67X00_HCD=m
>> CONFIG_USB_XHCI_HCD=m
>> CONFIG_USB_XHCI_HCD_DEBUGGING=y
>> CONFIG_USB_EHCI_HCD=m
>> CONFIG_USB_EHCI_ROOT_HUB_TT=y
>> CONFIG_USB_EHCI_TT_NEWSCHED=y
>> CONFIG_USB_EHCI_BIG_ENDIAN_MMIO=y
>> CONFIG_USB_EHCI_HCD_PPC_OF=y
>> CONFIG_USB_OXU210HP_HCD=m
>> CONFIG_USB_ISP116X_HCD=m
>> CONFIG_USB_ISP1760_HCD=m
>> CONFIG_USB_ISP1362_HCD=m
>> CONFIG_USB_OHCI_HCD=m
>> CONFIG_USB_OHCI_HCD_PPC_OF_BE=y
>> CONFIG_USB_OHCI_HCD_PPC_OF_LE=y
>> CONFIG_USB_OHCI_HCD_PPC_OF=y
>> CONFIG_USB_OHCI_HCD_PCI=y
>> CONFIG_USB_OHCI_HCD_SSB=y
>> CONFIG_USB_OHCI_BIG_ENDIAN_DESC=y
>> CONFIG_USB_OHCI_BIG_ENDIAN_MMIO=y
>> CONFIG_USB_OHCI_LITTLE_ENDIAN=y
>> CONFIG_USB_UHCI_HCD=m
>> CONFIG_USB_U132_HCD=m
>> CONFIG_USB_SL811_HCD=m
>> CONFIG_USB_SL811_CS=m
>> CONFIG_USB_R8A66597_HCD=m
>> CONFIG_USB_WHCI_HCD=m
>> CONFIG_USB_HWA_HCD=m
>> # CONFIG_USB_GADGET_MUSB_HDRC is not set
>>
>> #
>> # USB Device Class drivers
>> #
>> CONFIG_USB_ACM=m
>> CONFIG_USB_PRINTER=m
>> CONFIG_USB_WDM=m
>> CONFIG_USB_TMC=m
>>
>> #
>> # NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may
>> #
>>
>> #
>> # also be needed; see USB_STORAGE Help for more info
>> #
>> CONFIG_USB_STORAGE=m
>> CONFIG_USB_STORAGE_DEBUG=y
>> CONFIG_USB_STORAGE_DATAFAB=m
>> CONFIG_USB_STORAGE_FREECOM=m
>> CONFIG_USB_STORAGE_ISD200=m
>> CONFIG_USB_STORAGE_USBAT=m
>> CONFIG_USB_STORAGE_SDDR09=m
>> CONFIG_USB_STORAGE_SDDR55=m
>> CONFIG_USB_STORAGE_JUMPSHOT=m
>> CONFIG_USB_STORAGE_ALAUDA=m
>> CONFIG_USB_STORAGE_ONETOUCH=m
>> CONFIG_USB_STORAGE_KARMA=m
>> # CONFIG_USB_STORAGE_CYPRESS_ATACB is not set
>> CONFIG_USB_LIBUSUAL=y
>>
>> #
>> # USB Imaging devices
>> #
>> CONFIG_USB_MDC800=m
>> CONFIG_USB_MICROTEK=m
>>
>> #
>> # USB port drivers
>> #
>> CONFIG_USB_USS720=m
>> CONFIG_USB_SERIAL=m
>> CONFIG_USB_EZUSB=y
>> CONFIG_USB_SERIAL_GENERIC=y
>> CONFIG_USB_SERIAL_AIRCABLE=m
>> CONFIG_USB_SERIAL_ARK3116=m
>> CONFIG_USB_SERIAL_BELKIN=m
>> CONFIG_USB_SERIAL_CH341=m
>> CONFIG_USB_SERIAL_WHITEHEAT=m
>> CONFIG_USB_SERIAL_DIGI_ACCELEPORT=m
>> CONFIG_USB_SERIAL_CP210X=m
>> CONFIG_USB_SERIAL_CYPRESS_M8=m
>> CONFIG_USB_SERIAL_EMPEG=m
>> CONFIG_USB_SERIAL_FTDI_SIO=m
>> CONFIG_USB_SERIAL_FUNSOFT=m
>> CONFIG_USB_SERIAL_VISOR=m
>> CONFIG_USB_SERIAL_IPAQ=m
>> CONFIG_USB_SERIAL_IR=m
>> CONFIG_USB_SERIAL_EDGEPORT=m
>> CONFIG_USB_SERIAL_EDGEPORT_TI=m
>> CONFIG_USB_SERIAL_GARMIN=m
>> CONFIG_USB_SERIAL_IPW=m
>> CONFIG_USB_SERIAL_IUU=m
>> CONFIG_USB_SERIAL_KEYSPAN_PDA=m
>> CONFIG_USB_SERIAL_KEYSPAN=m
>> CONFIG_USB_SERIAL_KEYSPAN_MPR=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA28=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA28X=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA28XA=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA28XB=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA19=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA18X=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA19W=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA19QW=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA19QI=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA49W=y
>> CONFIG_USB_SERIAL_KEYSPAN_USA49WLC=y
>> CONFIG_USB_SERIAL_KLSI=m
>> CONFIG_USB_SERIAL_KOBIL_SCT=m
>> CONFIG_USB_SERIAL_MCT_U232=m
>> CONFIG_USB_SERIAL_MOS7720=m
>> CONFIG_USB_SERIAL_MOS7840=m
>> CONFIG_USB_SERIAL_MOTOROLA=m
>> CONFIG_USB_SERIAL_NAVMAN=m
>> CONFIG_USB_SERIAL_PL2303=m
>> CONFIG_USB_SERIAL_OTI6858=m
>> CONFIG_USB_SERIAL_QUALCOMM=m
>> CONFIG_USB_SERIAL_SPCP8X5=m
>> CONFIG_USB_SERIAL_HP4X=m
>> CONFIG_USB_SERIAL_SAFE=m
>> CONFIG_USB_SERIAL_SAFE_PADDED=y
>> CONFIG_USB_SERIAL_SIEMENS_MPI=m
>> CONFIG_USB_SERIAL_SIERRAWIRELESS=m
>> CONFIG_USB_SERIAL_SYMBOL=m
>> CONFIG_USB_SERIAL_TI=m
>> CONFIG_USB_SERIAL_CYBERJACK=m
>> CONFIG_USB_SERIAL_XIRCOM=m
>> CONFIG_USB_SERIAL_OPTION=m
>> CONFIG_USB_SERIAL_OMNINET=m
>> CONFIG_USB_SERIAL_OPTICON=m
>> CONFIG_USB_SERIAL_DEBUG=m
>>
>> #
>> # USB Miscellaneous drivers
>> #
>> CONFIG_USB_EMI62=m
>> CONFIG_USB_EMI26=m
>> CONFIG_USB_ADUTUX=m
>> CONFIG_USB_SEVSEG=m
>> CONFIG_USB_RIO500=m
>> CONFIG_USB_LEGOTOWER=m
>> CONFIG_USB_LCD=m
>> CONFIG_USB_BERRY_CHARGE=m
>> CONFIG_USB_LED=m
>> CONFIG_USB_CYPRESS_CY7C63=m
>> CONFIG_USB_CYTHERM=m
>> CONFIG_USB_IDMOUSE=m
>> CONFIG_USB_FTDI_ELAN=m
>> CONFIG_USB_APPLEDISPLAY=m
>> CONFIG_USB_SISUSBVGA=m
>> CONFIG_USB_SISUSBVGA_CON=y
>> CONFIG_USB_LD=m
>> CONFIG_USB_TRANCEVIBRATOR=m
>> CONFIG_USB_IOWARRIOR=m
>> CONFIG_USB_TEST=m
>> CONFIG_USB_ISIGHTFW=m
>> CONFIG_USB_VST=m
>> CONFIG_USB_ATM=m
>> CONFIG_USB_SPEEDTOUCH=m
>> CONFIG_USB_CXACRU=m
>> CONFIG_USB_UEAGLEATM=m
>> CONFIG_USB_XUSBATM=m
>> CONFIG_USB_GADGET=m
>> CONFIG_USB_GADGET_DEBUG=y
>> CONFIG_USB_GADGET_DEBUG_FILES=y
>> CONFIG_USB_GADGET_DEBUG_FS=y
>> CONFIG_USB_GADGET_VBUS_DRAW=2
>> CONFIG_USB_GADGET_SELECTED=y
>> # CONFIG_USB_GADGET_AT91 is not set
>> # CONFIG_USB_GADGET_ATMEL_USBA is not set
>> # CONFIG_USB_GADGET_FSL_USB2 is not set
>> # CONFIG_USB_GADGET_LH7A40X is not set
>> # CONFIG_USB_GADGET_OMAP is not set
>> # CONFIG_USB_GADGET_PXA25X is not set
>> CONFIG_USB_GADGET_R8A66597=y
>> CONFIG_USB_R8A66597=m
>> # CONFIG_USB_GADGET_PXA27X is not set
>> # CONFIG_USB_GADGET_S3C_HSOTG is not set
>> # CONFIG_USB_GADGET_IMX is not set
>> # CONFIG_USB_GADGET_S3C2410 is not set
>> # CONFIG_USB_GADGET_M66592 is not set
>> # CONFIG_USB_GADGET_AMD5536UDC is not set
>> # CONFIG_USB_GADGET_FSL_QE is not set
>> # CONFIG_USB_GADGET_CI13XXX is not set
>> # CONFIG_USB_GADGET_NET2280 is not set
>> # CONFIG_USB_GADGET_GOKU is not set
>> # CONFIG_USB_GADGET_LANGWELL is not set
>> # CONFIG_USB_GADGET_DUMMY_HCD is not set
>> CONFIG_USB_GADGET_DUALSPEED=y
>> CONFIG_USB_ZERO=m
>> CONFIG_USB_AUDIO=m
>> CONFIG_USB_ETH=m
>> CONFIG_USB_ETH_RNDIS=y
>> CONFIG_USB_ETH_EEM=y
>> CONFIG_USB_GADGETFS=m
>> CONFIG_USB_FILE_STORAGE=m
>> CONFIG_USB_FILE_STORAGE_TEST=y
>> CONFIG_USB_G_SERIAL=m
>> CONFIG_USB_MIDI_GADGET=m
>> CONFIG_USB_G_PRINTER=m
>> CONFIG_USB_CDC_COMPOSITE=m
>>
>> #
>> # OTG and related infrastructure
>> #
>> CONFIG_USB_OTG_UTILS=y
>> CONFIG_USB_GPIO_VBUS=m
>> CONFIG_NOP_USB_XCEIV=m
>> CONFIG_UWB=m
>> CONFIG_UWB_HWA=m
>> CONFIG_UWB_WHCI=m
>> CONFIG_UWB_WLP=m
>> CONFIG_UWB_I1480U=m
>> CONFIG_UWB_I1480U_WLP=m
>> CONFIG_MMC=m
>> CONFIG_MMC_DEBUG=y
>> CONFIG_MMC_UNSAFE_RESUME=y
>>
>> #
>> # MMC/SD/SDIO Card Drivers
>> #
>> CONFIG_MMC_BLOCK=m
>> CONFIG_MMC_BLOCK_BOUNCE=y
>> CONFIG_SDIO_UART=m
>> CONFIG_MMC_TEST=m
>>
>> #
>> # MMC/SD/SDIO Host Controller Drivers
>> #
>> CONFIG_MMC_SDHCI=m
>> CONFIG_MMC_SDHCI_IO_ACCESSORS=y
>> CONFIG_MMC_SDHCI_PCI=m
>> CONFIG_MMC_RICOH_MMC=m
>> CONFIG_MMC_SDHCI_OF=m
>> CONFIG_MMC_SDHCI_PLTFM=m
>> CONFIG_MMC_WBSD=m
>> # CONFIG_MMC_AT91 is not set
>> # CONFIG_MMC_ATMELMCI is not set
>> CONFIG_MMC_TIFM_SD=m
>> CONFIG_MMC_SPI=m
>> CONFIG_MMC_SDRICOH_CS=m
>> CONFIG_MMC_CB710=m
>> CONFIG_MMC_VIA_SDMMC=m
>> CONFIG_MEMSTICK=m
>> CONFIG_MEMSTICK_DEBUG=y
>>
>> #
>> # MemoryStick drivers
>> #
>> CONFIG_MEMSTICK_UNSAFE_RESUME=y
>> CONFIG_MSPRO_BLOCK=m
>>
>> #
>> # MemoryStick Host Controller Drivers
>> #
>> CONFIG_MEMSTICK_TIFM_MS=m
>> CONFIG_MEMSTICK_JMICRON_38X=m
>> CONFIG_NEW_LEDS=y
>> CONFIG_LEDS_CLASS=y
>>
>> #
>> # LED drivers
>> #
>> CONFIG_LEDS_PCA9532=m
>> CONFIG_LEDS_GPIO=m
>> CONFIG_LEDS_GPIO_PLATFORM=y
>> CONFIG_LEDS_GPIO_OF=y
>> CONFIG_LEDS_LP3944=m
>> CONFIG_LEDS_PCA955X=m
>> CONFIG_LEDS_WM831X_STATUS=m
>> CONFIG_LEDS_WM8350=m
>> CONFIG_LEDS_DAC124S085=m
>> CONFIG_LEDS_BD2802=m
>>
>> #
>> # LED Triggers
>> #
>> CONFIG_LEDS_TRIGGERS=y
>> CONFIG_LEDS_TRIGGER_TIMER=m
>> CONFIG_LEDS_TRIGGER_IDE_DISK=y
>> CONFIG_LEDS_TRIGGER_HEARTBEAT=m
>> CONFIG_LEDS_TRIGGER_BACKLIGHT=m
>> CONFIG_LEDS_TRIGGER_GPIO=m
>> CONFIG_LEDS_TRIGGER_DEFAULT_ON=m
>>
>> #
>> # iptables trigger is under Netfilter config (LED target)
>> #
>> CONFIG_ACCESSIBILITY=y
>> CONFIG_A11Y_BRAILLE_CONSOLE=y
>> CONFIG_INFINIBAND=m
>> CONFIG_INFINIBAND_USER_MAD=m
>> CONFIG_INFINIBAND_USER_ACCESS=m
>> CONFIG_INFINIBAND_USER_MEM=y
>> CONFIG_INFINIBAND_ADDR_TRANS=y
>> CONFIG_INFINIBAND_MTHCA=m
>> CONFIG_INFINIBAND_MTHCA_DEBUG=y
>> CONFIG_INFINIBAND_IPATH=m
>> CONFIG_INFINIBAND_EHCA=m
>> CONFIG_INFINIBAND_AMSO1100=m
>> CONFIG_INFINIBAND_AMSO1100_DEBUG=y
>> CONFIG_INFINIBAND_CXGB3=m
>> CONFIG_INFINIBAND_CXGB3_DEBUG=y
>> CONFIG_MLX4_INFINIBAND=m
>> CONFIG_INFINIBAND_NES=m
>> CONFIG_INFINIBAND_NES_DEBUG=y
>> CONFIG_INFINIBAND_IPOIB=m
>> CONFIG_INFINIBAND_IPOIB_CM=y
>> CONFIG_INFINIBAND_IPOIB_DEBUG=y
>> CONFIG_INFINIBAND_IPOIB_DEBUG_DATA=y
>> CONFIG_INFINIBAND_SRP=m
>> CONFIG_INFINIBAND_ISER=m
>> CONFIG_EDAC=y
>>
>> #
>> # Reporting subsystems
>> #
>> CONFIG_EDAC_DEBUG=y
>> CONFIG_EDAC_DEBUG_VERBOSE=y
>> CONFIG_EDAC_MM_EDAC=m
>> CONFIG_EDAC_PASEMI=m
>> CONFIG_EDAC_CELL=m
>> CONFIG_EDAC_AMD8131=m
>> CONFIG_EDAC_AMD8111=m
>> CONFIG_EDAC_CPC925=m
>> CONFIG_RTC_LIB=m
>> CONFIG_RTC_CLASS=m
>>
>> #
>> # RTC interfaces
>> #
>> CONFIG_RTC_INTF_SYSFS=y
>> CONFIG_RTC_INTF_PROC=y
>> CONFIG_RTC_INTF_DEV=y
>> CONFIG_RTC_INTF_DEV_UIE_EMUL=y
>> CONFIG_RTC_DRV_TEST=m
>>
>> #
>> # I2C RTC drivers
>> #
>> CONFIG_RTC_DRV_DS1307=m
>> CONFIG_RTC_DRV_DS1374=m
>> CONFIG_RTC_DRV_DS1672=m
>> CONFIG_RTC_DRV_MAX6900=m
>> CONFIG_RTC_DRV_RS5C372=m
>> CONFIG_RTC_DRV_ISL1208=m
>> CONFIG_RTC_DRV_X1205=m
>> CONFIG_RTC_DRV_PCF8563=m
>> CONFIG_RTC_DRV_PCF8583=m
>> CONFIG_RTC_DRV_M41T80=m
>> CONFIG_RTC_DRV_M41T80_WDT=y
>> CONFIG_RTC_DRV_S35390A=m
>> CONFIG_RTC_DRV_FM3130=m
>> CONFIG_RTC_DRV_RX8581=m
>> CONFIG_RTC_DRV_RX8025=m
>>
>> #
>> # SPI RTC drivers
>> #
>> CONFIG_RTC_DRV_M41T94=m
>> CONFIG_RTC_DRV_DS1305=m
>> CONFIG_RTC_DRV_DS1390=m
>> CONFIG_RTC_DRV_MAX6902=m
>> CONFIG_RTC_DRV_R9701=m
>> CONFIG_RTC_DRV_RS5C348=m
>> CONFIG_RTC_DRV_DS3234=m
>> CONFIG_RTC_DRV_PCF2123=m
>>
>> #
>> # Platform RTC drivers
>> #
>> CONFIG_RTC_DRV_CMOS=m
>> CONFIG_RTC_DRV_DS1286=m
>> CONFIG_RTC_DRV_DS1511=m
>> CONFIG_RTC_DRV_DS1553=m
>> CONFIG_RTC_DRV_DS1742=m
>> CONFIG_RTC_DRV_STK17TA8=m
>> CONFIG_RTC_DRV_M48T86=m
>> CONFIG_RTC_DRV_M48T35=m
>> CONFIG_RTC_DRV_M48T59=m
>> CONFIG_RTC_DRV_MSM6242=m
>> CONFIG_RTC_DRV_BQ4802=m
>> CONFIG_RTC_DRV_RP5C01=m
>> CONFIG_RTC_DRV_V3020=m
>> CONFIG_RTC_DRV_WM831X=m
>> CONFIG_RTC_DRV_WM8350=m
>> CONFIG_RTC_DRV_PCF50633=m
>> CONFIG_RTC_DRV_AB3100=m
>>
>> #
>> # on-CPU RTC drivers
>> #
>> CONFIG_RTC_DRV_GENERIC=m
>> CONFIG_RTC_DRV_PS3=m
>> CONFIG_RTC_DRV_PCAP=m
>> CONFIG_DMADEVICES=y
>>
>> #
>> # DMA Devices
>> #
>> CONFIG_AUXDISPLAY=y
>> CONFIG_KS0108=m
>> CONFIG_KS0108_PORT=0x378
>> CONFIG_KS0108_DELAY=2
>> CONFIG_UIO=m
>> CONFIG_UIO_CIF=m
>> CONFIG_UIO_PDRV=m
>> CONFIG_UIO_PDRV_GENIRQ=m
>> CONFIG_UIO_SMX=m
>> CONFIG_UIO_AEC=m
>> CONFIG_UIO_SERCOS3=m
>> CONFIG_UIO_PCI_GENERIC=m
>>
>> #
>> # TI VLYNQ
>> #
>> CONFIG_STAGING=y
>> CONFIG_STAGING_EXCLUDE_BUILD=y
>>
>> #
>> # File systems
>> #
>> CONFIG_EXT2_FS=m
>> CONFIG_EXT2_FS_XATTR=y
>> CONFIG_EXT2_FS_POSIX_ACL=y
>> CONFIG_EXT2_FS_SECURITY=y
>> CONFIG_EXT2_FS_XIP=y
>> CONFIG_EXT3_FS=m
>> CONFIG_EXT3_DEFAULTS_TO_ORDERED=y
>> CONFIG_EXT3_FS_XATTR=y
>> CONFIG_EXT3_FS_POSIX_ACL=y
>> CONFIG_EXT3_FS_SECURITY=y
>> CONFIG_EXT4_FS=m
>> CONFIG_EXT4_FS_XATTR=y
>> CONFIG_EXT4_FS_POSIX_ACL=y
>> CONFIG_EXT4_FS_SECURITY=y
>> CONFIG_EXT4_DEBUG=y
>> CONFIG_FS_XIP=y
>> CONFIG_JBD=m
>> CONFIG_JBD_DEBUG=y
>> CONFIG_JBD2=m
>> CONFIG_JBD2_DEBUG=y
>> CONFIG_FS_MBCACHE=m
>> CONFIG_REISERFS_FS=m
>> CONFIG_REISERFS_CHECK=y
>> CONFIG_REISERFS_PROC_INFO=y
>> CONFIG_REISERFS_FS_XATTR=y
>> CONFIG_REISERFS_FS_POSIX_ACL=y
>> CONFIG_REISERFS_FS_SECURITY=y
>> CONFIG_JFS_FS=m
>> CONFIG_JFS_POSIX_ACL=y
>> CONFIG_JFS_SECURITY=y
>> CONFIG_JFS_DEBUG=y
>> CONFIG_JFS_STATISTICS=y
>> CONFIG_FS_POSIX_ACL=y
>> CONFIG_XFS_FS=m
>> CONFIG_XFS_QUOTA=y
>> CONFIG_XFS_POSIX_ACL=y
>> CONFIG_XFS_RT=y
>> CONFIG_XFS_DEBUG=y
>> CONFIG_GFS2_FS=m
>> CONFIG_GFS2_FS_LOCKING_DLM=y
>> CONFIG_OCFS2_FS=m
>> CONFIG_OCFS2_FS_O2CB=m
>> CONFIG_OCFS2_FS_USERSPACE_CLUSTER=m
>> CONFIG_OCFS2_FS_STATS=y
>> CONFIG_OCFS2_DEBUG_MASKLOG=y
>> CONFIG_OCFS2_DEBUG_FS=y
>> CONFIG_OCFS2_FS_POSIX_ACL=y
>> CONFIG_BTRFS_FS=m
>> CONFIG_BTRFS_FS_POSIX_ACL=y
>> CONFIG_NILFS2_FS=m
>> CONFIG_FILE_LOCKING=y
>> CONFIG_FSNOTIFY=y
>> CONFIG_DNOTIFY=y
>> CONFIG_INOTIFY=y
>> CONFIG_INOTIFY_USER=y
>> CONFIG_QUOTA=y
>> CONFIG_QUOTA_NETLINK_INTERFACE=y
>> CONFIG_PRINT_QUOTA_WARNING=y
>> CONFIG_QUOTA_TREE=m
>> CONFIG_QFMT_V1=m
>> CONFIG_QFMT_V2=m
>> CONFIG_QUOTACTL=y
>> CONFIG_AUTOFS_FS=m
>> CONFIG_AUTOFS4_FS=m
>> CONFIG_FUSE_FS=m
>> CONFIG_CUSE=m
>> CONFIG_GENERIC_ACL=y
>>
>> #
>> # Caches
>> #
>> CONFIG_FSCACHE=m
>> CONFIG_FSCACHE_STATS=y
>> CONFIG_FSCACHE_HISTOGRAM=y
>> CONFIG_FSCACHE_DEBUG=y
>> CONFIG_CACHEFILES=m
>> CONFIG_CACHEFILES_DEBUG=y
>> CONFIG_CACHEFILES_HISTOGRAM=y
>>
>> #
>> # CD-ROM/DVD Filesystems
>> #
>> CONFIG_ISO9660_FS=m
>> CONFIG_JOLIET=y
>> CONFIG_ZISOFS=y
>> CONFIG_UDF_FS=m
>> CONFIG_UDF_NLS=y
>>
>> #
>> # DOS/FAT/NT Filesystems
>> #
>> CONFIG_FAT_FS=m
>> CONFIG_MSDOS_FS=m
>> CONFIG_VFAT_FS=m
>> CONFIG_FAT_DEFAULT_CODEPAGE=437
>> CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
>> CONFIG_NTFS_FS=m
>> CONFIG_NTFS_DEBUG=y
>> CONFIG_NTFS_RW=y
>>
>> #
>> # Pseudo filesystems
>> #
>> CONFIG_PROC_FS=y
>> CONFIG_PROC_KCORE=y
>> CONFIG_PROC_VMCORE=y
>> CONFIG_PROC_SYSCTL=y
>> CONFIG_PROC_PAGE_MONITOR=y
>> CONFIG_SYSFS=y
>> CONFIG_TMPFS=y
>> CONFIG_TMPFS_POSIX_ACL=y
>> CONFIG_HUGETLBFS=y
>> CONFIG_HUGETLB_PAGE=y
>> CONFIG_CONFIGFS_FS=m
>> CONFIG_MISC_FILESYSTEMS=y
>> CONFIG_ADFS_FS=m
>> CONFIG_ADFS_FS_RW=y
>> CONFIG_AFFS_FS=m
>> CONFIG_ECRYPT_FS=m
>> CONFIG_HFS_FS=m
>> CONFIG_HFSPLUS_FS=m
>> CONFIG_BEFS_FS=m
>> CONFIG_BEFS_DEBUG=y
>> CONFIG_BFS_FS=m
>> CONFIG_EFS_FS=m
>> CONFIG_JFFS2_FS=m
>> CONFIG_JFFS2_FS_DEBUG=0
>> CONFIG_JFFS2_FS_WRITEBUFFER=y
>> CONFIG_JFFS2_FS_WBUF_VERIFY=y
>> CONFIG_JFFS2_SUMMARY=y
>> CONFIG_JFFS2_FS_XATTR=y
>> CONFIG_JFFS2_FS_POSIX_ACL=y
>> CONFIG_JFFS2_FS_SECURITY=y
>> CONFIG_JFFS2_COMPRESSION_OPTIONS=y
>> CONFIG_JFFS2_ZLIB=y
>> CONFIG_JFFS2_LZO=y
>> CONFIG_JFFS2_RTIME=y
>> CONFIG_JFFS2_RUBIN=y
>> # CONFIG_JFFS2_CMODE_NONE is not set
>> CONFIG_JFFS2_CMODE_PRIORITY=y
>> # CONFIG_JFFS2_CMODE_SIZE is not set
>> # CONFIG_JFFS2_CMODE_FAVOURLZO is not set
>> CONFIG_UBIFS_FS=m
>> CONFIG_UBIFS_FS_XATTR=y
>> CONFIG_UBIFS_FS_ADVANCED_COMPR=y
>> CONFIG_UBIFS_FS_LZO=y
>> CONFIG_UBIFS_FS_ZLIB=y
>> CONFIG_UBIFS_FS_DEBUG=y
>> CONFIG_UBIFS_FS_DEBUG_MSG_LVL=0
>> CONFIG_UBIFS_FS_DEBUG_CHKS=y
>> CONFIG_CRAMFS=m
>> CONFIG_SQUASHFS=m
>> CONFIG_SQUASHFS_EMBEDDED=y
>> CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE=3
>> CONFIG_VXFS_FS=m
>> CONFIG_MINIX_FS=m
>> CONFIG_OMFS_FS=m
>> CONFIG_HPFS_FS=m
>> CONFIG_QNX4FS_FS=m
>> CONFIG_ROMFS_FS=m
>> CONFIG_ROMFS_BACKED_BY_BLOCK=y
>> # CONFIG_ROMFS_BACKED_BY_MTD is not set
>> # CONFIG_ROMFS_BACKED_BY_BOTH is not set
>> CONFIG_ROMFS_ON_BLOCK=y
>> CONFIG_SYSV_FS=m
>> CONFIG_UFS_FS=m
>> CONFIG_UFS_FS_WRITE=y
>> CONFIG_UFS_DEBUG=y
>> CONFIG_EXOFS_FS=m
>> CONFIG_EXOFS_DEBUG=y
>> CONFIG_NETWORK_FILESYSTEMS=y
>> CONFIG_NFS_FS=m
>> CONFIG_NFS_V3=y
>> CONFIG_NFS_V3_ACL=y
>> CONFIG_NFS_V4=y
>> CONFIG_NFS_V4_1=y
>> CONFIG_NFS_FSCACHE=y
>> CONFIG_NFSD=m
>> CONFIG_NFSD_V2_ACL=y
>> CONFIG_NFSD_V3=y
>> CONFIG_NFSD_V3_ACL=y
>> CONFIG_NFSD_V4=y
>> CONFIG_LOCKD=m
>> CONFIG_LOCKD_V4=y
>> CONFIG_EXPORTFS=m
>> CONFIG_NFS_ACL_SUPPORT=m
>> CONFIG_NFS_COMMON=y
>> CONFIG_SUNRPC=m
>> CONFIG_SUNRPC_GSS=m
>> CONFIG_SUNRPC_XPRT_RDMA=m
>> CONFIG_RPCSEC_GSS_KRB5=m
>> CONFIG_RPCSEC_GSS_SPKM3=m
>> CONFIG_SMB_FS=m
>> CONFIG_SMB_NLS_DEFAULT=y
>> CONFIG_SMB_NLS_REMOTE="cp437"
>> CONFIG_CIFS=m
>> CONFIG_CIFS_STATS=y
>> CONFIG_CIFS_STATS2=y
>> CONFIG_CIFS_WEAK_PW_HASH=y
>> CONFIG_CIFS_UPCALL=y
>> CONFIG_CIFS_XATTR=y
>> CONFIG_CIFS_POSIX=y
>> CONFIG_CIFS_DEBUG2=y
>> CONFIG_CIFS_DFS_UPCALL=y
>> CONFIG_CIFS_EXPERIMENTAL=y
>> CONFIG_NCP_FS=m
>> CONFIG_NCPFS_PACKET_SIGNING=y
>> CONFIG_NCPFS_IOCTL_LOCKING=y
>> CONFIG_NCPFS_STRONG=y
>> CONFIG_NCPFS_NFS_NS=y
>> CONFIG_NCPFS_OS2_NS=y
>> CONFIG_NCPFS_SMALLDOS=y
>> CONFIG_NCPFS_NLS=y
>> CONFIG_NCPFS_EXTRAS=y
>> CONFIG_CODA_FS=m
>> CONFIG_AFS_FS=m
>> CONFIG_AFS_DEBUG=y
>> CONFIG_AFS_FSCACHE=y
>> CONFIG_9P_FS=m
>> CONFIG_9P_FSCACHE=y
>>
>> #
>> # Partition Types
>> #
>> CONFIG_PARTITION_ADVANCED=y
>> CONFIG_ACORN_PARTITION=y
>> CONFIG_ACORN_PARTITION_CUMANA=y
>> CONFIG_ACORN_PARTITION_EESOX=y
>> CONFIG_ACORN_PARTITION_ICS=y
>> CONFIG_ACORN_PARTITION_ADFS=y
>> CONFIG_ACORN_PARTITION_POWERTEC=y
>> CONFIG_ACORN_PARTITION_RISCIX=y
>> CONFIG_OSF_PARTITION=y
>> CONFIG_AMIGA_PARTITION=y
>> CONFIG_ATARI_PARTITION=y
>> CONFIG_MAC_PARTITION=y
>> CONFIG_MSDOS_PARTITION=y
>> CONFIG_BSD_DISKLABEL=y
>> CONFIG_MINIX_SUBPARTITION=y
>> CONFIG_SOLARIS_X86_PARTITION=y
>> CONFIG_UNIXWARE_DISKLABEL=y
>> CONFIG_LDM_PARTITION=y
>> CONFIG_LDM_DEBUG=y
>> CONFIG_SGI_PARTITION=y
>> CONFIG_ULTRIX_PARTITION=y
>> CONFIG_SUN_PARTITION=y
>> CONFIG_KARMA_PARTITION=y
>> CONFIG_EFI_PARTITION=y
>> CONFIG_SYSV68_PARTITION=y
>> CONFIG_NLS=m
>> CONFIG_NLS_DEFAULT="iso8859-1"
>> CONFIG_NLS_CODEPAGE_437=m
>> CONFIG_NLS_CODEPAGE_737=m
>> CONFIG_NLS_CODEPAGE_775=m
>> CONFIG_NLS_CODEPAGE_850=m
>> CONFIG_NLS_CODEPAGE_852=m
>> CONFIG_NLS_CODEPAGE_855=m
>> CONFIG_NLS_CODEPAGE_857=m
>> CONFIG_NLS_CODEPAGE_860=m
>> CONFIG_NLS_CODEPAGE_861=m
>> CONFIG_NLS_CODEPAGE_862=m
>> CONFIG_NLS_CODEPAGE_863=m
>> CONFIG_NLS_CODEPAGE_864=m
>> CONFIG_NLS_CODEPAGE_865=m
>> CONFIG_NLS_CODEPAGE_866=m
>> CONFIG_NLS_CODEPAGE_869=m
>> CONFIG_NLS_CODEPAGE_936=m
>> CONFIG_NLS_CODEPAGE_950=m
>> CONFIG_NLS_CODEPAGE_932=m
>> CONFIG_NLS_CODEPAGE_949=m
>> CONFIG_NLS_CODEPAGE_874=m
>> CONFIG_NLS_ISO8859_8=m
>> CONFIG_NLS_CODEPAGE_1250=m
>> CONFIG_NLS_CODEPAGE_1251=m
>> CONFIG_NLS_ASCII=m
>> CONFIG_NLS_ISO8859_1=m
>> CONFIG_NLS_ISO8859_2=m
>> CONFIG_NLS_ISO8859_3=m
>> CONFIG_NLS_ISO8859_4=m
>> CONFIG_NLS_ISO8859_5=m
>> CONFIG_NLS_ISO8859_6=m
>> CONFIG_NLS_ISO8859_7=m
>> CONFIG_NLS_ISO8859_9=m
>> CONFIG_NLS_ISO8859_13=m
>> CONFIG_NLS_ISO8859_14=m
>> CONFIG_NLS_ISO8859_15=m
>> CONFIG_NLS_KOI8_R=m
>> CONFIG_NLS_KOI8_U=m
>> CONFIG_NLS_UTF8=m
>> CONFIG_DLM=m
>> CONFIG_DLM_DEBUG=y
>> CONFIG_BINARY_PRINTF=y
>>
>> #
>> # Library routines
>> #
>> CONFIG_BITREVERSE=y
>> CONFIG_GENERIC_FIND_LAST_BIT=y
>> CONFIG_CRC_CCITT=m
>> CONFIG_CRC16=m
>> CONFIG_CRC_T10DIF=m
>> CONFIG_CRC_ITU_T=m
>> CONFIG_CRC32=y
>> CONFIG_CRC7=m
>> CONFIG_LIBCRC32C=m
>> CONFIG_ZLIB_INFLATE=y
>> CONFIG_ZLIB_DEFLATE=m
>> CONFIG_LZO_COMPRESS=m
>> CONFIG_LZO_DECOMPRESS=m
>> CONFIG_DECOMPRESS_GZIP=y
>> CONFIG_DECOMPRESS_BZIP2=y
>> CONFIG_DECOMPRESS_LZMA=y
>> CONFIG_GENERIC_ALLOCATOR=y
>> CONFIG_REED_SOLOMON=m
>> CONFIG_REED_SOLOMON_DEC16=y
>> CONFIG_TEXTSEARCH=y
>> CONFIG_TEXTSEARCH_KMP=m
>> CONFIG_TEXTSEARCH_BM=m
>> CONFIG_TEXTSEARCH_FSM=m
>> CONFIG_HAS_IOMEM=y
>> CONFIG_HAS_IOPORT=y
>> CONFIG_HAS_DMA=y
>> CONFIG_CHECK_SIGNATURE=y
>> CONFIG_HAVE_LMB=y
>> CONFIG_NLATTR=y
>> CONFIG_LRU_CACHE=m
>> CONFIG_SHM_SIGNAL=m
>> CONFIG_IOQ=m
>>
>> #
>> # Kernel hacking
>> #
>> CONFIG_PRINTK_TIME=y
>> CONFIG_ENABLE_WARN_DEPRECATED=y
>> CONFIG_ENABLE_MUST_CHECK=y
>> CONFIG_FRAME_WARN=2048
>> CONFIG_MAGIC_SYSRQ=y
>> CONFIG_STRIP_ASM_SYMS=y
>> CONFIG_UNUSED_SYMBOLS=y
>> CONFIG_DEBUG_FS=y
>> CONFIG_HEADERS_CHECK=y
>> CONFIG_DEBUG_KERNEL=y
>> CONFIG_DEBUG_SHIRQ=y
>> CONFIG_DETECT_SOFTLOCKUP=y
>> CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC=y
>> CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=1
>> CONFIG_DETECT_HUNG_TASK=y
>> CONFIG_BOOTPARAM_HUNG_TASK_PANIC=y
>> CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=1
>> CONFIG_SCHED_DEBUG=y
>> CONFIG_SCHEDSTATS=y
>> CONFIG_TIMER_STATS=y
>> CONFIG_DEBUG_OBJECTS=y
>> CONFIG_DEBUG_OBJECTS_SELFTEST=y
>> CONFIG_DEBUG_OBJECTS_FREE=y
>> CONFIG_DEBUG_OBJECTS_TIMERS=y
>> CONFIG_DEBUG_OBJECTS_ENABLE_DEFAULT=1
>> CONFIG_SLUB_DEBUG_ON=y
>> CONFIG_SLUB_STATS=y
>> CONFIG_DEBUG_RT_MUTEXES=y
>> CONFIG_DEBUG_PI_LIST=y
>> CONFIG_RT_MUTEX_TESTER=y
>> CONFIG_DEBUG_SPINLOCK=y
>> CONFIG_DEBUG_MUTEXES=y
>> CONFIG_DEBUG_LOCK_ALLOC=y
>> CONFIG_PROVE_LOCKING=y
>> CONFIG_LOCKDEP=y
>> CONFIG_LOCK_STAT=y
>> CONFIG_DEBUG_LOCKDEP=y
>> CONFIG_TRACE_IRQFLAGS=y
>> CONFIG_DEBUG_SPINLOCK_SLEEP=y
>> CONFIG_DEBUG_LOCKING_API_SELFTESTS=y
>> CONFIG_STACKTRACE=y
>> CONFIG_DEBUG_KOBJECT=y
>> CONFIG_DEBUG_BUGVERBOSE=y
>> CONFIG_DEBUG_INFO=y
>> CONFIG_DEBUG_VM=y
>> CONFIG_DEBUG_WRITECOUNT=y
>> CONFIG_DEBUG_MEMORY_INIT=y
>> CONFIG_DEBUG_LIST=y
>> CONFIG_DEBUG_SG=y
>> CONFIG_DEBUG_NOTIFIERS=y
>> CONFIG_DEBUG_CREDENTIALS=y
>> CONFIG_FRAME_POINTER=y
>> CONFIG_RCU_TORTURE_TEST=m
>> CONFIG_RCU_CPU_STALL_DETECTOR=y
>> CONFIG_KPROBES_SANITY_TEST=y
>> CONFIG_BACKTRACE_SELF_TEST=m
>> CONFIG_DEBUG_BLOCK_EXT_DEVT=y
>> CONFIG_DEBUG_FORCE_WEAK_PER_CPU=y
>> CONFIG_LKDTM=m
>> CONFIG_FAULT_INJECTION=y
>> CONFIG_FAILSLAB=y
>> CONFIG_FAIL_PAGE_ALLOC=y
>> CONFIG_FAIL_MAKE_REQUEST=y
>> CONFIG_FAIL_IO_TIMEOUT=y
>> CONFIG_FAULT_INJECTION_DEBUG_FS=y
>> CONFIG_FAULT_INJECTION_STACKTRACE_FILTER=y
>> CONFIG_LATENCYTOP=y
>> CONFIG_SYSCTL_SYSCALL_CHECK=y
>> CONFIG_NOP_TRACER=y
>> CONFIG_HAVE_FUNCTION_TRACER=y
>> CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y
>> CONFIG_HAVE_DYNAMIC_FTRACE=y
>> CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
>> CONFIG_TRACER_MAX_TRACE=y
>> CONFIG_RING_BUFFER=y
>> CONFIG_EVENT_TRACING=y
>> CONFIG_CONTEXT_SWITCH_TRACER=y
>> CONFIG_RING_BUFFER_ALLOW_SWAP=y
>> CONFIG_TRACING=y
>> CONFIG_GENERIC_TRACER=y
>> CONFIG_TRACING_SUPPORT=y
>> CONFIG_FTRACE=y
>> CONFIG_FUNCTION_TRACER=y
>> CONFIG_FUNCTION_GRAPH_TRACER=y
>> CONFIG_IRQSOFF_TRACER=y
>> CONFIG_SCHED_TRACER=y
>> CONFIG_BOOT_TRACER=y
>> CONFIG_BRANCH_PROFILE_NONE=y
>> # CONFIG_PROFILE_ANNOTATED_BRANCHES is not set
>> # CONFIG_PROFILE_ALL_BRANCHES is not set
>> CONFIG_STACK_TRACER=y
>> CONFIG_KMEMTRACE=y
>> CONFIG_WORKQUEUE_TRACER=y
>> CONFIG_BLK_DEV_IO_TRACE=y
>> CONFIG_DYNAMIC_FTRACE=y
>> CONFIG_FUNCTION_PROFILER=y
>> CONFIG_FTRACE_MCOUNT_RECORD=y
>> CONFIG_FTRACE_SELFTEST=y
>> CONFIG_FTRACE_STARTUP_TEST=y
>> CONFIG_EVENT_TRACE_TEST_SYSCALLS=y
>> CONFIG_RING_BUFFER_BENCHMARK=m
>> CONFIG_FIREWIRE_OHCI_REMOTE_DMA=y
>> CONFIG_BUILD_DOCSRC=y
>> CONFIG_DYNAMIC_DEBUG=y
>> CONFIG_DMA_API_DEBUG=y
>> CONFIG_SAMPLES=y
>> CONFIG_SAMPLE_TRACEPOINTS=m
>> CONFIG_SAMPLE_TRACE_EVENTS=m
>> CONFIG_SAMPLE_KOBJECT=m
>> CONFIG_SAMPLE_KPROBES=m
>> CONFIG_SAMPLE_KRETPROBES=m
>> CONFIG_HAVE_ARCH_KGDB=y
>> CONFIG_KGDB=y
>> CONFIG_KGDB_SERIAL_CONSOLE=m
>> CONFIG_KGDB_TESTS=y
>> CONFIG_KGDB_TESTS_ON_BOOT=y
>> CONFIG_KGDB_TESTS_BOOT_STRING="V1F100"
>> CONFIG_PPC_DISABLE_WERROR=y
>> CONFIG_PRINT_STACK_DEPTH=64
>> CONFIG_DEBUG_STACKOVERFLOW=y
>> CONFIG_DEBUG_STACK_USAGE=y
>> CONFIG_HCALL_STATS=y
>> CONFIG_PPC_EMULATED_STATS=y
>> CONFIG_CODE_PATCHING_SELFTEST=y
>> CONFIG_FTR_FIXUP_SELFTEST=y
>> CONFIG_MSI_BITMAP_SELFTEST=y
>> CONFIG_XMON=y
>> CONFIG_XMON_DEFAULT=y
>> CONFIG_XMON_DISASSEMBLY=y
>> CONFIG_DEBUGGER=y
>> CONFIG_IRQSTACKS=y
>> CONFIG_VIRQ_DEBUG=y
>> CONFIG_BOOTX_TEXT=y
>> CONFIG_PPC_EARLY_DEBUG=y
>> CONFIG_PPC_EARLY_DEBUG_LPAR=y
>> # CONFIG_PPC_EARLY_DEBUG_G5 is not set
>> # CONFIG_PPC_EARLY_DEBUG_RTAS_PANEL is not set
>> # CONFIG_PPC_EARLY_DEBUG_RTAS_CONSOLE is not set
>> # CONFIG_PPC_EARLY_DEBUG_MAPLE is not set
>> # CONFIG_PPC_EARLY_DEBUG_ISERIES is not set
>> # CONFIG_PPC_EARLY_DEBUG_PAS_REALMODE is not set
>> # CONFIG_PPC_EARLY_DEBUG_BEAT is not set
>> # CONFIG_PPC_EARLY_DEBUG_44x is not set
>> # CONFIG_PPC_EARLY_DEBUG_40x is not set
>> # CONFIG_PPC_EARLY_DEBUG_CPM is not set
>>
>> #
>> # Security options
>> #
>> CONFIG_KEYS=y
>> CONFIG_KEYS_DEBUG_PROC_KEYS=y
>> CONFIG_SECURITY=y
>> CONFIG_SECURITYFS=y
>> CONFIG_SECURITY_NETWORK=y
>> CONFIG_SECURITY_NETWORK_XFRM=y
>> CONFIG_SECURITY_PATH=y
>> CONFIG_SECURITY_FILE_CAPABILITIES=y
>> CONFIG_LSM_MMAP_MIN_ADDR=65536
>> CONFIG_SECURITY_SELINUX=y
>> CONFIG_SECURITY_SELINUX_BOOTPARAM=y
>> CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE=1
>> CONFIG_SECURITY_SELINUX_DISABLE=y
>> CONFIG_SECURITY_SELINUX_DEVELOP=y
>> CONFIG_SECURITY_SELINUX_AVC_STATS=y
>> CONFIG_SECURITY_SELINUX_CHECKREQPROT_VALUE=1
>> CONFIG_SECURITY_SELINUX_POLICYDB_VERSION_MAX=y
>> CONFIG_SECURITY_SELINUX_POLICYDB_VERSION_MAX_VALUE=19
>> CONFIG_SECURITY_SMACK=y
>> CONFIG_SECURITY_TOMOYO=y
>> CONFIG_KEYS_COMPAT=y
>> CONFIG_XOR_BLOCKS=m
>> CONFIG_ASYNC_CORE=m
>> CONFIG_ASYNC_MEMCPY=m
>> CONFIG_ASYNC_XOR=m
>> CONFIG_ASYNC_PQ=m
>> CONFIG_ASYNC_RAID6_RECOV=m
>> CONFIG_CRYPTO=y
>>
>> #
>> # Crypto core or helper
>> #
>> CONFIG_CRYPTO_FIPS=y
>> CONFIG_CRYPTO_ALGAPI=y
>> CONFIG_CRYPTO_ALGAPI2=y
>> CONFIG_CRYPTO_AEAD=m
>> CONFIG_CRYPTO_AEAD2=y
>> CONFIG_CRYPTO_BLKCIPHER=m
>> CONFIG_CRYPTO_BLKCIPHER2=y
>> CONFIG_CRYPTO_HASH=y
>> CONFIG_CRYPTO_HASH2=y
>> CONFIG_CRYPTO_RNG=m
>> CONFIG_CRYPTO_RNG2=y
>> CONFIG_CRYPTO_PCOMP=y
>> CONFIG_CRYPTO_MANAGER=m
>> CONFIG_CRYPTO_MANAGER2=y
>> CONFIG_CRYPTO_GF128MUL=m
>> CONFIG_CRYPTO_NULL=m
>> CONFIG_CRYPTO_WORKQUEUE=y
>> CONFIG_CRYPTO_CRYPTD=m
>> CONFIG_CRYPTO_AUTHENC=m
>> CONFIG_CRYPTO_TEST=m
>>
>> #
>> # Authenticated Encryption with Associated Data
>> #
>> CONFIG_CRYPTO_CCM=m
>> CONFIG_CRYPTO_GCM=m
>> CONFIG_CRYPTO_SEQIV=m
>>
>> #
>> # Block modes
>> #
>> CONFIG_CRYPTO_CBC=m
>> CONFIG_CRYPTO_CTR=m
>> CONFIG_CRYPTO_CTS=m
>> CONFIG_CRYPTO_ECB=m
>> CONFIG_CRYPTO_LRW=m
>> CONFIG_CRYPTO_PCBC=m
>> CONFIG_CRYPTO_XTS=m
>>
>> #
>> # Hash modes
>> #
>> CONFIG_CRYPTO_HMAC=m
>> CONFIG_CRYPTO_XCBC=m
>> CONFIG_CRYPTO_VMAC=m
>>
>> #
>> # Digest
>> #
>> CONFIG_CRYPTO_CRC32C=m
>> CONFIG_CRYPTO_GHASH=m
>> CONFIG_CRYPTO_MD4=m
>> CONFIG_CRYPTO_MD5=y
>> CONFIG_CRYPTO_MICHAEL_MIC=m
>> CONFIG_CRYPTO_RMD128=m
>> CONFIG_CRYPTO_RMD160=m
>> CONFIG_CRYPTO_RMD256=m
>> CONFIG_CRYPTO_RMD320=m
>> CONFIG_CRYPTO_SHA1=m
>> CONFIG_CRYPTO_SHA256=m
>> CONFIG_CRYPTO_SHA512=m
>> CONFIG_CRYPTO_TGR192=m
>> CONFIG_CRYPTO_WP512=m
>>
>> #
>> # Ciphers
>> #
>> CONFIG_CRYPTO_AES=m
>> CONFIG_CRYPTO_ANUBIS=m
>> CONFIG_CRYPTO_ARC4=m
>> CONFIG_CRYPTO_BLOWFISH=m
>> CONFIG_CRYPTO_CAMELLIA=m
>> CONFIG_CRYPTO_CAST5=m
>> CONFIG_CRYPTO_CAST6=m
>> CONFIG_CRYPTO_DES=m
>> CONFIG_CRYPTO_FCRYPT=m
>> CONFIG_CRYPTO_KHAZAD=m
>> CONFIG_CRYPTO_SALSA20=m
>> CONFIG_CRYPTO_SEED=m
>> CONFIG_CRYPTO_SERPENT=m
>> CONFIG_CRYPTO_TEA=m
>> CONFIG_CRYPTO_TWOFISH=m
>> CONFIG_CRYPTO_TWOFISH_COMMON=m
>>
>> #
>> # Compression
>> #
>> CONFIG_CRYPTO_DEFLATE=m
>> CONFIG_CRYPTO_ZLIB=m
>> CONFIG_CRYPTO_LZO=m
>>
>> #
>> # Random Number Generation
>> #
>> CONFIG_CRYPTO_ANSI_CPRNG=m
>> CONFIG_CRYPTO_HW=y
>> CONFIG_CRYPTO_DEV_HIFN_795X=m
>> CONFIG_CRYPTO_DEV_HIFN_795X_RNG=y
>> # CONFIG_PPC_CLOCK is not set
>> CONFIG_VIRTUALIZATION=y
>> CONFIG_VIRTIO=m
>> CONFIG_VIRTIO_RING=m
>> CONFIG_VIRTIO_PCI=m
>> CONFIG_VIRTIO_BALLOON=m
>> Kamalesh
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at http://www.tux.org/lkml/
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 267 bytes --]
^ permalink raw reply
* Re: PF_RING: Include in main line kernel?
From: Ben Greear @ 2009-10-15 16:33 UTC (permalink / raw)
To: Evgeniy Polyakov; +Cc: David Miller, deri, shemminger, brad.doctor, netdev
In-Reply-To: <20091015070234.GA29506@ioremap.net>
On 10/15/2009 12:02 AM, Evgeniy Polyakov wrote:
> On Wed, Oct 14, 2009 at 02:49:23PM -0700, David Miller (davem@davemloft.net) wrote:
>>> Maybe something similar to the attached patch?
>>
>> This is not something I'm interested in applying.
>>
>> It makes implementing proprietary complete networking stacks
>> for Linux way too easy.
>
> Such kernels will be tainted and thus its bugs and problems will be
> clearly indicated by the proprietary module.
>
>> Instead I'd rather have a GPL exported function that allows indication
>> of consumption somehow. That's why we have a special hook for
>> bonding, so it cannot be abused in proprietary modules.
>
> I believe bonding with its hook is a historical heritage and priority
> absence in packet hooks which do not currently allow something to be
> registered very first and steal packets from the stack.
>
> Looks like bonding could be implemented as a packet handler with Ben's
> patch applied, isn't it?
Bonding, bridging, mac-vlans, pktgen-rx logic, sniffers, and others could. The only trick is
ordering...it may be better to keep the hard-coded hooks in a definite
order than to allow users to switch them around.
Or, could have a precedence value when adding hooks (protocols) so that modules
can properly order themselves by default, but users *could* reorder
them if they really wanted to (might be useful to have mac-vlans before
bonding some of the time, and after it others, for instance...)
Thanks,
Ben
--
Ben Greear <greearb@candelatech.com>
Candela Technologies Inc http://www.candelatech.com
^ permalink raw reply
* [PATCH net-next-2.6] inet: rename some inet_sock fields
From: Eric Dumazet @ 2009-10-15 16:30 UTC (permalink / raw)
To: David S. Miller; +Cc: Linux Netdev List
In order to have better cache layouts of struct sock (separate zones
for rx/tx paths), we need this preliminary patch.
Goal is to transfert fields used at lookup time in the first
read-mostly cache line (inside struct sock_common) and move sk_refcnt
to a separate cache line (only written by rx path)
This patch adds inet_ prefix to daddr, rcv_saddr, dport, num, saddr,
sport and id fields. This allows a future patch to define these
fields as macros, like sk_refcnt, without name clashes.
Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
---
drivers/net/pppol2tp.c | 22 ++--
fs/ocfs2/cluster/netdebug.c | 8 -
include/linux/ipv6.h | 2
include/net/inet6_hashtables.h | 4
include/net/inet_hashtables.h | 12 +-
include/net/inet_sock.h | 36 +++----
include/net/inet_timewait_sock.h | 2
include/net/ip.h | 12 +-
net/dccp/ipv4.c | 40 ++++----
net/dccp/ipv6.c | 27 +++--
net/dccp/output.c | 4
net/dccp/probe.c | 13 +-
net/dccp/proto.c | 4
net/ipv4/af_inet.c | 62 ++++++-------
net/ipv4/datagram.c | 18 +--
net/ipv4/inet_connection_sock.c | 20 ++--
net/ipv4/inet_diag.c | 26 ++---
net/ipv4/inet_hashtables.c | 34 +++----
net/ipv4/inet_timewait_sock.c | 12 +-
net/ipv4/ip_input.c | 2
net/ipv4/ip_output.c | 15 +--
net/ipv4/ip_sockglue.c | 8 -
net/ipv4/ipmr.c | 2
net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c | 8 -
net/ipv4/raw.c | 30 +++---
net/ipv4/tcp.c | 4
net/ipv4/tcp_ipv4.c | 70 +++++++--------
net/ipv4/tcp_output.c | 4
net/ipv4/tcp_probe.c | 11 +-
net/ipv4/tcp_timer.c | 8 -
net/ipv4/udp.c | 51 +++++-----
net/ipv6/af_inet6.c | 28 +++---
net/ipv6/datagram.c | 15 +--
net/ipv6/inet6_connection_sock.c | 6 -
net/ipv6/inet6_hashtables.c | 12 +-
net/ipv6/ip6mr.c | 2
net/ipv6/ipv6_sockglue.c | 6 -
net/ipv6/raw.c | 30 +++---
net/ipv6/syncookies.c | 2
net/ipv6/tcp_ipv6.c | 32 +++---
net/ipv6/udp.c | 24 ++---
net/netfilter/xt_socket.c | 2
net/rds/tcp_listen.c | 8 -
net/sctp/protocol.c | 8 -
net/sctp/socket.c | 30 +++---
net/sunrpc/svcsock.c | 8 -
security/lsm_audit.c | 12 +-
47 files changed, 408 insertions(+), 388 deletions(-)
diff --git a/drivers/net/pppol2tp.c b/drivers/net/pppol2tp.c
index 5910df6..849cc9c 100644
--- a/drivers/net/pppol2tp.c
+++ b/drivers/net/pppol2tp.c
@@ -516,7 +516,7 @@ static inline int pppol2tp_verify_udp_checksum(struct sock *sk,
return 0;
inet = inet_sk(sk);
- psum = csum_tcpudp_nofold(inet->saddr, inet->daddr, ulen,
+ psum = csum_tcpudp_nofold(inet->inet_saddr, inet->inet_daddr, ulen,
IPPROTO_UDP, 0);
if ((skb->ip_summed == CHECKSUM_COMPLETE) &&
@@ -949,8 +949,8 @@ static int pppol2tp_sendmsg(struct kiocb *iocb, struct socket *sock, struct msgh
inet = inet_sk(sk_tun);
udp_len = hdr_len + sizeof(ppph) + total_len;
uh = (struct udphdr *) skb->data;
- uh->source = inet->sport;
- uh->dest = inet->dport;
+ uh->source = inet->inet_sport;
+ uh->dest = inet->inet_dport;
uh->len = htons(udp_len);
uh->check = 0;
skb_put(skb, sizeof(struct udphdr));
@@ -978,7 +978,8 @@ static int pppol2tp_sendmsg(struct kiocb *iocb, struct socket *sock, struct msgh
else if (!(skb_dst(skb)->dev->features & NETIF_F_V4_CSUM)) {
skb->ip_summed = CHECKSUM_COMPLETE;
csum = skb_checksum(skb, 0, udp_len, 0);
- uh->check = csum_tcpudp_magic(inet->saddr, inet->daddr,
+ uh->check = csum_tcpudp_magic(inet->inet_saddr,
+ inet->inet_daddr,
udp_len, IPPROTO_UDP, csum);
if (uh->check == 0)
uh->check = CSUM_MANGLED_0;
@@ -986,7 +987,8 @@ static int pppol2tp_sendmsg(struct kiocb *iocb, struct socket *sock, struct msgh
skb->ip_summed = CHECKSUM_PARTIAL;
skb->csum_start = skb_transport_header(skb) - skb->head;
skb->csum_offset = offsetof(struct udphdr, check);
- uh->check = ~csum_tcpudp_magic(inet->saddr, inet->daddr,
+ uh->check = ~csum_tcpudp_magic(inet->inet_saddr,
+ inet->inet_daddr,
udp_len, IPPROTO_UDP, 0);
}
@@ -1136,8 +1138,8 @@ static int pppol2tp_xmit(struct ppp_channel *chan, struct sk_buff *skb)
__skb_push(skb, sizeof(*uh));
skb_reset_transport_header(skb);
uh = udp_hdr(skb);
- uh->source = inet->sport;
- uh->dest = inet->dport;
+ uh->source = inet->inet_sport;
+ uh->dest = inet->inet_dport;
uh->len = htons(udp_len);
uh->check = 0;
@@ -1181,7 +1183,8 @@ static int pppol2tp_xmit(struct ppp_channel *chan, struct sk_buff *skb)
else if (!(skb_dst(skb)->dev->features & NETIF_F_V4_CSUM)) {
skb->ip_summed = CHECKSUM_COMPLETE;
csum = skb_checksum(skb, 0, udp_len, 0);
- uh->check = csum_tcpudp_magic(inet->saddr, inet->daddr,
+ uh->check = csum_tcpudp_magic(inet->inet_saddr,
+ inet->inet_daddr,
udp_len, IPPROTO_UDP, csum);
if (uh->check == 0)
uh->check = CSUM_MANGLED_0;
@@ -1189,7 +1192,8 @@ static int pppol2tp_xmit(struct ppp_channel *chan, struct sk_buff *skb)
skb->ip_summed = CHECKSUM_PARTIAL;
skb->csum_start = skb_transport_header(skb) - skb->head;
skb->csum_offset = offsetof(struct udphdr, check);
- uh->check = ~csum_tcpudp_magic(inet->saddr, inet->daddr,
+ uh->check = ~csum_tcpudp_magic(inet->inet_saddr,
+ inet->inet_daddr,
udp_len, IPPROTO_UDP, 0);
}
diff --git a/fs/ocfs2/cluster/netdebug.c b/fs/ocfs2/cluster/netdebug.c
index da794bc..a3f150e 100644
--- a/fs/ocfs2/cluster/netdebug.c
+++ b/fs/ocfs2/cluster/netdebug.c
@@ -294,10 +294,10 @@ static int sc_seq_show(struct seq_file *seq, void *v)
if (sc->sc_sock) {
inet = inet_sk(sc->sc_sock->sk);
/* the stack's structs aren't sparse endian clean */
- saddr = (__force __be32)inet->saddr;
- daddr = (__force __be32)inet->daddr;
- sport = (__force __be16)inet->sport;
- dport = (__force __be16)inet->dport;
+ saddr = (__force __be32)inet->inet_saddr;
+ daddr = (__force __be32)inet->inet_daddr;
+ sport = (__force __be16)inet->inet_sport;
+ dport = (__force __be16)inet->inet_dport;
}
/* XXX sigh, inet-> doesn't have sparse annotation so any
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 5640425..e0cc9a7 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -505,7 +505,7 @@ static inline struct raw6_sock *raw6_sk(const struct sock *sk)
#define INET6_MATCH(__sk, __net, __hash, __saddr, __daddr, __ports, __dif)\
(((__sk)->sk_hash == (__hash)) && sock_net((__sk)) == (__net) && \
- ((*((__portpair *)&(inet_sk(__sk)->dport))) == (__ports)) && \
+ ((*((__portpair *)&(inet_sk(__sk)->inet_dport))) == (__ports)) && \
((__sk)->sk_family == AF_INET6) && \
ipv6_addr_equal(&inet6_sk(__sk)->daddr, (__saddr)) && \
ipv6_addr_equal(&inet6_sk(__sk)->rcv_saddr, (__daddr)) && \
diff --git a/include/net/inet6_hashtables.h b/include/net/inet6_hashtables.h
index 22c73a7..92838d3 100644
--- a/include/net/inet6_hashtables.h
+++ b/include/net/inet6_hashtables.h
@@ -46,8 +46,8 @@ static inline int inet6_sk_ehashfn(const struct sock *sk)
const struct ipv6_pinfo *np = inet6_sk(sk);
const struct in6_addr *laddr = &np->rcv_saddr;
const struct in6_addr *faddr = &np->daddr;
- const __u16 lport = inet->num;
- const __be16 fport = inet->dport;
+ const __u16 lport = inet->inet_num;
+ const __be16 fport = inet->inet_dport;
struct net *net = sock_net(sk);
return inet6_ehashfn(net, laddr, lport, faddr, fport);
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index 5f11c4a..5b698b3 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -241,7 +241,7 @@ static inline int inet_lhashfn(struct net *net, const unsigned short num)
static inline int inet_sk_listen_hashfn(const struct sock *sk)
{
- return inet_lhashfn(sock_net(sk), inet_sk(sk)->num);
+ return inet_lhashfn(sock_net(sk), inet_sk(sk)->inet_num);
}
/* Caller must disable local BH processing. */
@@ -301,8 +301,8 @@ typedef __u64 __bitwise __addrpair;
#endif /* __BIG_ENDIAN */
#define INET_MATCH(__sk, __net, __hash, __cookie, __saddr, __daddr, __ports, __dif)\
(((__sk)->sk_hash == (__hash)) && net_eq(sock_net(__sk), (__net)) && \
- ((*((__addrpair *)&(inet_sk(__sk)->daddr))) == (__cookie)) && \
- ((*((__portpair *)&(inet_sk(__sk)->dport))) == (__ports)) && \
+ ((*((__addrpair *)&(inet_sk(__sk)->inet_daddr))) == (__cookie)) && \
+ ((*((__portpair *)&(inet_sk(__sk)->inet_dport))) == (__ports)) && \
(!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
#define INET_TW_MATCH(__sk, __net, __hash, __cookie, __saddr, __daddr, __ports, __dif)\
(((__sk)->sk_hash == (__hash)) && net_eq(sock_net(__sk), (__net)) && \
@@ -313,9 +313,9 @@ typedef __u64 __bitwise __addrpair;
#define INET_ADDR_COOKIE(__name, __saddr, __daddr)
#define INET_MATCH(__sk, __net, __hash, __cookie, __saddr, __daddr, __ports, __dif) \
(((__sk)->sk_hash == (__hash)) && net_eq(sock_net(__sk), (__net)) && \
- (inet_sk(__sk)->daddr == (__saddr)) && \
- (inet_sk(__sk)->rcv_saddr == (__daddr)) && \
- ((*((__portpair *)&(inet_sk(__sk)->dport))) == (__ports)) && \
+ (inet_sk(__sk)->inet_daddr == (__saddr)) && \
+ (inet_sk(__sk)->inet_rcv_saddr == (__daddr)) && \
+ ((*((__portpair *)&(inet_sk(__sk)->inet_dport))) == (__ports)) && \
(!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
#define INET_TW_MATCH(__sk, __net, __hash,__cookie, __saddr, __daddr, __ports, __dif) \
(((__sk)->sk_hash == (__hash)) && net_eq(sock_net(__sk), (__net)) && \
diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h
index 47004f3..bd4c53f 100644
--- a/include/net/inet_sock.h
+++ b/include/net/inet_sock.h
@@ -93,14 +93,14 @@ struct rtable;
*
* @sk - ancestor class
* @pinet6 - pointer to IPv6 control block
- * @daddr - Foreign IPv4 addr
- * @rcv_saddr - Bound local IPv4 addr
- * @dport - Destination port
- * @num - Local port
- * @saddr - Sending source
+ * @inet_daddr - Foreign IPv4 addr
+ * @inet_rcv_saddr - Bound local IPv4 addr
+ * @inet_dport - Destination port
+ * @inet_num - Local port
+ * @inet_saddr - Sending source
* @uc_ttl - Unicast TTL
- * @sport - Source port
- * @id - ID counter for DF pkts
+ * @inet_sport - Source port
+ * @inet_id - ID counter for DF pkts
* @tos - TOS
* @mc_ttl - Multicasting TTL
* @is_icsk - is this an inet_connection_sock?
@@ -115,16 +115,16 @@ struct inet_sock {
struct ipv6_pinfo *pinet6;
#endif
/* Socket demultiplex comparisons on incoming packets. */
- __be32 daddr;
- __be32 rcv_saddr;
- __be16 dport;
- __u16 num;
- __be32 saddr;
+ __be32 inet_daddr;
+ __be32 inet_rcv_saddr;
+ __be16 inet_dport;
+ __u16 inet_num;
+ __be32 inet_saddr;
__s16 uc_ttl;
__u16 cmsg_flags;
struct ip_options *opt;
- __be16 sport;
- __u16 id;
+ __be16 inet_sport;
+ __u16 inet_id;
__u8 tos;
__u8 mc_ttl;
__u8 pmtudisc;
@@ -190,10 +190,10 @@ static inline unsigned int inet_ehashfn(struct net *net,
static inline int inet_sk_ehashfn(const struct sock *sk)
{
const struct inet_sock *inet = inet_sk(sk);
- const __be32 laddr = inet->rcv_saddr;
- const __u16 lport = inet->num;
- const __be32 faddr = inet->daddr;
- const __be16 fport = inet->dport;
+ const __be32 laddr = inet->inet_rcv_saddr;
+ const __u16 lport = inet->inet_num;
+ const __be32 faddr = inet->inet_daddr;
+ const __be16 fport = inet->inet_dport;
struct net *net = sock_net(sk);
return inet_ehashfn(net, laddr, lport, faddr, fport);
diff --git a/include/net/inet_timewait_sock.h b/include/net/inet_timewait_sock.h
index b63b80f..37f3aea 100644
--- a/include/net/inet_timewait_sock.h
+++ b/include/net/inet_timewait_sock.h
@@ -194,7 +194,7 @@ static inline struct inet_timewait_sock *inet_twsk(const struct sock *sk)
static inline __be32 inet_rcv_saddr(const struct sock *sk)
{
return likely(sk->sk_state != TCP_TIME_WAIT) ?
- inet_sk(sk)->rcv_saddr : inet_twsk(sk)->tw_rcv_saddr;
+ inet_sk(sk)->inet_rcv_saddr : inet_twsk(sk)->tw_rcv_saddr;
}
extern void inet_twsk_put(struct inet_timewait_sock *tw);
diff --git a/include/net/ip.h b/include/net/ip.h
index 2f47e54..376adf4 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -240,8 +240,8 @@ static inline void ip_select_ident(struct iphdr *iph, struct dst_entry *dst, str
* does not change, they drop every other packet in
* a TCP stream using header compression.
*/
- iph->id = (sk && inet_sk(sk)->daddr) ?
- htons(inet_sk(sk)->id++) : 0;
+ iph->id = (sk && inet_sk(sk)->inet_daddr) ?
+ htons(inet_sk(sk)->inet_id++) : 0;
} else
__ip_select_ident(iph, dst, 0);
}
@@ -249,9 +249,9 @@ static inline void ip_select_ident(struct iphdr *iph, struct dst_entry *dst, str
static inline void ip_select_ident_more(struct iphdr *iph, struct dst_entry *dst, struct sock *sk, int more)
{
if (iph->frag_off & htons(IP_DF)) {
- if (sk && inet_sk(sk)->daddr) {
- iph->id = htons(inet_sk(sk)->id);
- inet_sk(sk)->id += 1 + more;
+ if (sk && inet_sk(sk)->inet_daddr) {
+ iph->id = htons(inet_sk(sk)->inet_id);
+ inet_sk(sk)->inet_id += 1 + more;
} else
iph->id = 0;
} else
@@ -317,7 +317,7 @@ static inline void ip_ib_mc_map(__be32 naddr, const unsigned char *broadcast, ch
static __inline__ void inet_reset_saddr(struct sock *sk)
{
- inet_sk(sk)->rcv_saddr = inet_sk(sk)->saddr = 0;
+ inet_sk(sk)->inet_rcv_saddr = inet_sk(sk)->inet_saddr = 0;
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
if (sk->sk_family == PF_INET6) {
struct ipv6_pinfo *np = inet6_sk(sk);
diff --git a/net/dccp/ipv4.c b/net/dccp/ipv4.c
index 7302e14..00028d4 100644
--- a/net/dccp/ipv4.c
+++ b/net/dccp/ipv4.c
@@ -62,10 +62,10 @@ int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
nexthop = inet->opt->faddr;
}
- tmp = ip_route_connect(&rt, nexthop, inet->saddr,
+ tmp = ip_route_connect(&rt, nexthop, inet->inet_saddr,
RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
IPPROTO_DCCP,
- inet->sport, usin->sin_port, sk, 1);
+ inet->inet_sport, usin->sin_port, sk, 1);
if (tmp < 0)
return tmp;
@@ -77,12 +77,12 @@ int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
if (inet->opt == NULL || !inet->opt->srr)
daddr = rt->rt_dst;
- if (inet->saddr == 0)
- inet->saddr = rt->rt_src;
- inet->rcv_saddr = inet->saddr;
+ if (inet->inet_saddr == 0)
+ inet->inet_saddr = rt->rt_src;
+ inet->inet_rcv_saddr = inet->inet_saddr;
- inet->dport = usin->sin_port;
- inet->daddr = daddr;
+ inet->inet_dport = usin->sin_port;
+ inet->inet_daddr = daddr;
inet_csk(sk)->icsk_ext_hdr_len = 0;
if (inet->opt != NULL)
@@ -98,17 +98,19 @@ int dccp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
if (err != 0)
goto failure;
- err = ip_route_newports(&rt, IPPROTO_DCCP, inet->sport, inet->dport,
- sk);
+ err = ip_route_newports(&rt, IPPROTO_DCCP, inet->inet_sport,
+ inet->inet_dport, sk);
if (err != 0)
goto failure;
/* OK, now commit destination to socket. */
sk_setup_caps(sk, &rt->u.dst);
- dp->dccps_iss = secure_dccp_sequence_number(inet->saddr, inet->daddr,
- inet->sport, inet->dport);
- inet->id = dp->dccps_iss ^ jiffies;
+ dp->dccps_iss = secure_dccp_sequence_number(inet->inet_saddr,
+ inet->inet_daddr,
+ inet->inet_sport,
+ inet->inet_dport);
+ inet->inet_id = dp->dccps_iss ^ jiffies;
err = dccp_connect(sk);
rt = NULL;
@@ -123,7 +125,7 @@ failure:
dccp_set_state(sk, DCCP_CLOSED);
ip_rt_put(rt);
sk->sk_route_caps = 0;
- inet->dport = 0;
+ inet->inet_dport = 0;
goto out;
}
@@ -352,7 +354,9 @@ void dccp_v4_send_check(struct sock *sk, int unused, struct sk_buff *skb)
struct dccp_hdr *dh = dccp_hdr(skb);
dccp_csum_outgoing(skb);
- dh->dccph_checksum = dccp_v4_csum_finish(skb, inet->saddr, inet->daddr);
+ dh->dccph_checksum = dccp_v4_csum_finish(skb,
+ inet->inet_saddr,
+ inet->inet_daddr);
}
EXPORT_SYMBOL_GPL(dccp_v4_send_check);
@@ -393,14 +397,14 @@ struct sock *dccp_v4_request_recv_sock(struct sock *sk, struct sk_buff *skb,
newinet = inet_sk(newsk);
ireq = inet_rsk(req);
- newinet->daddr = ireq->rmt_addr;
- newinet->rcv_saddr = ireq->loc_addr;
- newinet->saddr = ireq->loc_addr;
+ newinet->inet_daddr = ireq->rmt_addr;
+ newinet->inet_rcv_saddr = ireq->loc_addr;
+ newinet->inet_saddr = ireq->loc_addr;
newinet->opt = ireq->opt;
ireq->opt = NULL;
newinet->mc_index = inet_iif(skb);
newinet->mc_ttl = ip_hdr(skb)->ttl;
- newinet->id = jiffies;
+ newinet->inet_id = jiffies;
dccp_sync_mss(newsk, dst_mtu(dst));
diff --git a/net/dccp/ipv6.c b/net/dccp/ipv6.c
index a2afb55..6d89f9f 100644
--- a/net/dccp/ipv6.c
+++ b/net/dccp/ipv6.c
@@ -158,8 +158,8 @@ static void dccp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
ipv6_addr_copy(&fl.fl6_src, &np->saddr);
fl.oif = sk->sk_bound_dev_if;
- fl.fl_ip_dport = inet->dport;
- fl.fl_ip_sport = inet->sport;
+ fl.fl_ip_dport = inet->inet_dport;
+ fl.fl_ip_sport = inet->inet_sport;
security_sk_classify_flow(sk, &fl);
err = ip6_dst_lookup(sk, &dst, &fl);
@@ -510,9 +510,9 @@ static struct sock *dccp_v6_request_recv_sock(struct sock *sk,
memcpy(newnp, np, sizeof(struct ipv6_pinfo));
- ipv6_addr_set_v4mapped(newinet->daddr, &newnp->daddr);
+ ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
- ipv6_addr_set_v4mapped(newinet->saddr, &newnp->saddr);
+ ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
@@ -640,7 +640,8 @@ static struct sock *dccp_v6_request_recv_sock(struct sock *sk,
dccp_sync_mss(newsk, dst_mtu(dst));
- newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
+ newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
+ newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
__inet6_hash(newsk);
__inet_inherit_port(sk, newsk);
@@ -968,10 +969,9 @@ static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
icsk->icsk_af_ops = &dccp_ipv6_af_ops;
sk->sk_backlog_rcv = dccp_v6_do_rcv;
goto failure;
- } else {
- ipv6_addr_set_v4mapped(inet->saddr, &np->saddr);
- ipv6_addr_set_v4mapped(inet->rcv_saddr, &np->rcv_saddr);
}
+ ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
+ ipv6_addr_set_v4mapped(inet->inet_rcv_saddr, &np->rcv_saddr);
return err;
}
@@ -984,7 +984,7 @@ static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
ipv6_addr_copy(&fl.fl6_src, saddr ? saddr : &np->saddr);
fl.oif = sk->sk_bound_dev_if;
fl.fl_ip_dport = usin->sin6_port;
- fl.fl_ip_sport = inet->sport;
+ fl.fl_ip_sport = inet->inet_sport;
security_sk_classify_flow(sk, &fl);
if (np->opt != NULL && np->opt->srcrt != NULL) {
@@ -1017,7 +1017,7 @@ static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
/* set the source address */
ipv6_addr_copy(&np->saddr, saddr);
- inet->rcv_saddr = LOOPBACK4_IPV6;
+ inet->inet_rcv_saddr = LOOPBACK4_IPV6;
__ip6_dst_store(sk, dst, NULL, NULL);
@@ -1026,7 +1026,7 @@ static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
np->opt->opt_nflen);
- inet->dport = usin->sin6_port;
+ inet->inet_dport = usin->sin6_port;
dccp_set_state(sk, DCCP_REQUESTING);
err = inet6_hash_connect(&dccp_death_row, sk);
@@ -1035,7 +1035,8 @@ static int dccp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,
np->daddr.s6_addr32,
- inet->sport, inet->dport);
+ inet->inet_sport,
+ inet->inet_dport);
err = dccp_connect(sk);
if (err)
goto late_failure;
@@ -1046,7 +1047,7 @@ late_failure:
dccp_set_state(sk, DCCP_CLOSED);
__sk_dst_reset(sk);
failure:
- inet->dport = 0;
+ inet->inet_dport = 0;
sk->sk_route_caps = 0;
return err;
}
diff --git a/net/dccp/output.c b/net/dccp/output.c
index c96119f..d6bb753 100644
--- a/net/dccp/output.c
+++ b/net/dccp/output.c
@@ -99,8 +99,8 @@ static int dccp_transmit_skb(struct sock *sk, struct sk_buff *skb)
/* Build DCCP header and checksum it. */
dh = dccp_zeroed_hdr(skb, dccp_header_size);
dh->dccph_type = dcb->dccpd_type;
- dh->dccph_sport = inet->sport;
- dh->dccph_dport = inet->dport;
+ dh->dccph_sport = inet->inet_sport;
+ dh->dccph_dport = inet->inet_dport;
dh->dccph_doff = (dccp_header_size + dcb->dccpd_opt_len) / 4;
dh->dccph_ccval = dcb->dccpd_ccval;
dh->dccph_cscov = dp->dccps_pcslen;
diff --git a/net/dccp/probe.c b/net/dccp/probe.c
index 5e6ec8b..dc32842 100644
--- a/net/dccp/probe.c
+++ b/net/dccp/probe.c
@@ -80,19 +80,20 @@ static int jdccp_sendmsg(struct kiocb *iocb, struct sock *sk,
if (ccid_get_current_tx_ccid(dccp_sk(sk)) == DCCPC_CCID3)
hc = ccid3_hc_tx_sk(sk);
- if (port == 0 || ntohs(inet->dport) == port ||
- ntohs(inet->sport) == port) {
+ if (port == 0 || ntohs(inet->inet_dport) == port ||
+ ntohs(inet->inet_sport) == port) {
if (hc)
printl("%pI4:%u %pI4:%u %d %d %d %d %u %llu %llu %d\n",
- &inet->saddr, ntohs(inet->sport),
- &inet->daddr, ntohs(inet->dport), size,
+ &inet->inet_saddr, ntohs(inet->inet_sport),
+ &inet->inet_daddr, ntohs(inet->inet_dport), size,
hc->tx_s, hc->tx_rtt, hc->tx_p,
hc->tx_x_calc, hc->tx_x_recv >> 6,
hc->tx_x >> 6, hc->tx_t_ipi);
else
printl("%pI4:%u %pI4:%u %d\n",
- &inet->saddr, ntohs(inet->sport),
- &inet->daddr, ntohs(inet->dport), size);
+ &inet->inet_saddr, ntohs(inet->inet_sport),
+ &inet->inet_daddr, ntohs(inet->inet_dport),
+ size);
}
jprobe_return();
diff --git a/net/dccp/proto.c b/net/dccp/proto.c
index ecb203f..671cd14 100644
--- a/net/dccp/proto.c
+++ b/net/dccp/proto.c
@@ -278,7 +278,7 @@ int dccp_disconnect(struct sock *sk, int flags)
sk->sk_send_head = NULL;
}
- inet->dport = 0;
+ inet->inet_dport = 0;
if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
inet_reset_saddr(sk);
@@ -290,7 +290,7 @@ int dccp_disconnect(struct sock *sk, int flags)
inet_csk_delack_init(sk);
__sk_dst_reset(sk);
- WARN_ON(inet->num && !icsk->icsk_bind_hash);
+ WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
sk->sk_error_report(sk);
return err;
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 1deff48..04a14b1 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -174,12 +174,12 @@ static int inet_autobind(struct sock *sk)
/* We may need to bind the socket. */
lock_sock(sk);
inet = inet_sk(sk);
- if (!inet->num) {
+ if (!inet->inet_num) {
if (sk->sk_prot->get_port(sk, 0)) {
release_sock(sk);
return -EAGAIN;
}
- inet->sport = htons(inet->num);
+ inet->inet_sport = htons(inet->inet_num);
}
release_sock(sk);
return 0;
@@ -354,7 +354,7 @@ lookup_protocol:
inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;
if (SOCK_RAW == sock->type) {
- inet->num = protocol;
+ inet->inet_num = protocol;
if (IPPROTO_RAW == protocol)
inet->hdrincl = 1;
}
@@ -364,7 +364,7 @@ lookup_protocol:
else
inet->pmtudisc = IP_PMTUDISC_WANT;
- inet->id = 0;
+ inet->inet_id = 0;
sock_init_data(sock, sk);
@@ -381,13 +381,13 @@ lookup_protocol:
sk_refcnt_debug_inc(sk);
- if (inet->num) {
+ if (inet->inet_num) {
/* It assumes that any protocol which allows
* the user to assign a number at socket
* creation time automatically
* shares.
*/
- inet->sport = htons(inet->num);
+ inet->inet_sport = htons(inet->inet_num);
/* Add to protocol hash chains. */
sk->sk_prot->hash(sk);
}
@@ -494,27 +494,27 @@ int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
/* Check these errors (active socket, double bind). */
err = -EINVAL;
- if (sk->sk_state != TCP_CLOSE || inet->num)
+ if (sk->sk_state != TCP_CLOSE || inet->inet_num)
goto out_release_sock;
- inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;
+ inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;
if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
- inet->saddr = 0; /* Use device */
+ inet->inet_saddr = 0; /* Use device */
/* Make sure we are allowed to bind here. */
if (sk->sk_prot->get_port(sk, snum)) {
- inet->saddr = inet->rcv_saddr = 0;
+ inet->inet_saddr = inet->inet_rcv_saddr = 0;
err = -EADDRINUSE;
goto out_release_sock;
}
- if (inet->rcv_saddr)
+ if (inet->inet_rcv_saddr)
sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
if (snum)
sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
- inet->sport = htons(inet->num);
- inet->daddr = 0;
- inet->dport = 0;
+ inet->inet_sport = htons(inet->inet_num);
+ inet->inet_daddr = 0;
+ inet->inet_dport = 0;
sk_dst_reset(sk);
err = 0;
out_release_sock:
@@ -532,7 +532,7 @@ int inet_dgram_connect(struct socket *sock, struct sockaddr * uaddr,
if (uaddr->sa_family == AF_UNSPEC)
return sk->sk_prot->disconnect(sk, flags);
- if (!inet_sk(sk)->num && inet_autobind(sk))
+ if (!inet_sk(sk)->inet_num && inet_autobind(sk))
return -EAGAIN;
return sk->sk_prot->connect(sk, (struct sockaddr *)uaddr, addr_len);
}
@@ -689,17 +689,17 @@ int inet_getname(struct socket *sock, struct sockaddr *uaddr,
sin->sin_family = AF_INET;
if (peer) {
- if (!inet->dport ||
+ if (!inet->inet_dport ||
(((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) &&
peer == 1))
return -ENOTCONN;
- sin->sin_port = inet->dport;
- sin->sin_addr.s_addr = inet->daddr;
+ sin->sin_port = inet->inet_dport;
+ sin->sin_addr.s_addr = inet->inet_daddr;
} else {
- __be32 addr = inet->rcv_saddr;
+ __be32 addr = inet->inet_rcv_saddr;
if (!addr)
- addr = inet->saddr;
- sin->sin_port = inet->sport;
+ addr = inet->inet_saddr;
+ sin->sin_port = inet->inet_sport;
sin->sin_addr.s_addr = addr;
}
memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
@@ -714,7 +714,7 @@ int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
struct sock *sk = sock->sk;
/* We may need to bind the socket. */
- if (!inet_sk(sk)->num && inet_autobind(sk))
+ if (!inet_sk(sk)->inet_num && inet_autobind(sk))
return -EAGAIN;
return sk->sk_prot->sendmsg(iocb, sk, msg, size);
@@ -728,7 +728,7 @@ static ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset,
struct sock *sk = sock->sk;
/* We may need to bind the socket. */
- if (!inet_sk(sk)->num && inet_autobind(sk))
+ if (!inet_sk(sk)->inet_num && inet_autobind(sk))
return -EAGAIN;
if (sk->sk_prot->sendpage)
@@ -1059,9 +1059,9 @@ static int inet_sk_reselect_saddr(struct sock *sk)
struct inet_sock *inet = inet_sk(sk);
int err;
struct rtable *rt;
- __be32 old_saddr = inet->saddr;
+ __be32 old_saddr = inet->inet_saddr;
__be32 new_saddr;
- __be32 daddr = inet->daddr;
+ __be32 daddr = inet->inet_daddr;
if (inet->opt && inet->opt->srr)
daddr = inet->opt->faddr;
@@ -1071,7 +1071,7 @@ static int inet_sk_reselect_saddr(struct sock *sk)
RT_CONN_FLAGS(sk),
sk->sk_bound_dev_if,
sk->sk_protocol,
- inet->sport, inet->dport, sk, 0);
+ inet->inet_sport, inet->inet_dport, sk, 0);
if (err)
return err;
@@ -1087,7 +1087,7 @@ static int inet_sk_reselect_saddr(struct sock *sk)
__func__, &old_saddr, &new_saddr);
}
- inet->saddr = inet->rcv_saddr = new_saddr;
+ inet->inet_saddr = inet->inet_rcv_saddr = new_saddr;
/*
* XXX The only one ugly spot where we need to
@@ -1113,7 +1113,7 @@ int inet_sk_rebuild_header(struct sock *sk)
return 0;
/* Reroute. */
- daddr = inet->daddr;
+ daddr = inet->inet_daddr;
if (inet->opt && inet->opt->srr)
daddr = inet->opt->faddr;
{
@@ -1123,7 +1123,7 @@ int inet_sk_rebuild_header(struct sock *sk)
.nl_u = {
.ip4_u = {
.daddr = daddr,
- .saddr = inet->saddr,
+ .saddr = inet->inet_saddr,
.tos = RT_CONN_FLAGS(sk),
},
},
@@ -1131,8 +1131,8 @@ int inet_sk_rebuild_header(struct sock *sk)
.flags = inet_sk_flowi_flags(sk),
.uli_u = {
.ports = {
- .sport = inet->sport,
- .dport = inet->dport,
+ .sport = inet->inet_sport,
+ .dport = inet->inet_dport,
},
},
};
diff --git a/net/ipv4/datagram.c b/net/ipv4/datagram.c
index 5e6c5a0..fb24658 100644
--- a/net/ipv4/datagram.c
+++ b/net/ipv4/datagram.c
@@ -39,7 +39,7 @@ int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
sk_dst_reset(sk);
oif = sk->sk_bound_dev_if;
- saddr = inet->saddr;
+ saddr = inet->inet_saddr;
if (ipv4_is_multicast(usin->sin_addr.s_addr)) {
if (!oif)
oif = inet->mc_index;
@@ -49,7 +49,7 @@ int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
err = ip_route_connect(&rt, usin->sin_addr.s_addr, saddr,
RT_CONN_FLAGS(sk), oif,
sk->sk_protocol,
- inet->sport, usin->sin_port, sk, 1);
+ inet->inet_sport, usin->sin_port, sk, 1);
if (err) {
if (err == -ENETUNREACH)
IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
@@ -60,14 +60,14 @@ int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
ip_rt_put(rt);
return -EACCES;
}
- if (!inet->saddr)
- inet->saddr = rt->rt_src; /* Update source address */
- if (!inet->rcv_saddr)
- inet->rcv_saddr = rt->rt_src;
- inet->daddr = rt->rt_dst;
- inet->dport = usin->sin_port;
+ if (!inet->inet_saddr)
+ inet->inet_saddr = rt->rt_src; /* Update source address */
+ if (!inet->inet_rcv_saddr)
+ inet->inet_rcv_saddr = rt->rt_src;
+ inet->inet_daddr = rt->rt_dst;
+ inet->inet_dport = usin->sin_port;
sk->sk_state = TCP_ESTABLISHED;
- inet->id = jiffies;
+ inet->inet_id = jiffies;
sk_dst_set(sk, &rt->u.dst);
return(0);
diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
index 9139e8f..f6a0af7 100644
--- a/net/ipv4/inet_connection_sock.c
+++ b/net/ipv4/inet_connection_sock.c
@@ -368,7 +368,7 @@ struct dst_entry *inet_csk_route_req(struct sock *sk,
.proto = sk->sk_protocol,
.flags = inet_sk_flowi_flags(sk),
.uli_u = { .ports =
- { .sport = inet_sk(sk)->sport,
+ { .sport = inet_sk(sk)->inet_sport,
.dport = ireq->rmt_port } } };
struct net *net = sock_net(sk);
@@ -547,9 +547,9 @@ struct sock *inet_csk_clone(struct sock *sk, const struct request_sock *req,
newsk->sk_state = TCP_SYN_RECV;
newicsk->icsk_bind_hash = NULL;
- inet_sk(newsk)->dport = inet_rsk(req)->rmt_port;
- inet_sk(newsk)->num = ntohs(inet_rsk(req)->loc_port);
- inet_sk(newsk)->sport = inet_rsk(req)->loc_port;
+ inet_sk(newsk)->inet_dport = inet_rsk(req)->rmt_port;
+ inet_sk(newsk)->inet_num = ntohs(inet_rsk(req)->loc_port);
+ inet_sk(newsk)->inet_sport = inet_rsk(req)->loc_port;
newsk->sk_write_space = sk_stream_write_space;
newicsk->icsk_retransmits = 0;
@@ -580,8 +580,8 @@ void inet_csk_destroy_sock(struct sock *sk)
/* It cannot be in hash table! */
WARN_ON(!sk_unhashed(sk));
- /* If it has not 0 inet_sk(sk)->num, it must be bound */
- WARN_ON(inet_sk(sk)->num && !inet_csk(sk)->icsk_bind_hash);
+ /* If it has not 0 inet_sk(sk)->inet_num, it must be bound */
+ WARN_ON(inet_sk(sk)->inet_num && !inet_csk(sk)->icsk_bind_hash);
sk->sk_prot->destroy(sk);
@@ -616,8 +616,8 @@ int inet_csk_listen_start(struct sock *sk, const int nr_table_entries)
* after validation is complete.
*/
sk->sk_state = TCP_LISTEN;
- if (!sk->sk_prot->get_port(sk, inet->num)) {
- inet->sport = htons(inet->num);
+ if (!sk->sk_prot->get_port(sk, inet->inet_num)) {
+ inet->inet_sport = htons(inet->inet_num);
sk_dst_reset(sk);
sk->sk_prot->hash(sk);
@@ -693,8 +693,8 @@ void inet_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr)
const struct inet_sock *inet = inet_sk(sk);
sin->sin_family = AF_INET;
- sin->sin_addr.s_addr = inet->daddr;
- sin->sin_port = inet->dport;
+ sin->sin_addr.s_addr = inet->inet_daddr;
+ sin->sin_port = inet->inet_dport;
}
EXPORT_SYMBOL_GPL(inet_csk_addr2sockaddr);
diff --git a/net/ipv4/inet_diag.c b/net/ipv4/inet_diag.c
index cb73fde..bdb78dd 100644
--- a/net/ipv4/inet_diag.c
+++ b/net/ipv4/inet_diag.c
@@ -116,10 +116,10 @@ static int inet_csk_diag_fill(struct sock *sk,
r->id.idiag_cookie[0] = (u32)(unsigned long)sk;
r->id.idiag_cookie[1] = (u32)(((unsigned long)sk >> 31) >> 1);
- r->id.idiag_sport = inet->sport;
- r->id.idiag_dport = inet->dport;
- r->id.idiag_src[0] = inet->rcv_saddr;
- r->id.idiag_dst[0] = inet->daddr;
+ r->id.idiag_sport = inet->inet_sport;
+ r->id.idiag_dport = inet->inet_dport;
+ r->id.idiag_src[0] = inet->inet_rcv_saddr;
+ r->id.idiag_dst[0] = inet->inet_daddr;
#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
if (r->idiag_family == AF_INET6) {
@@ -504,11 +504,11 @@ static int inet_csk_diag_dump(struct sock *sk,
} else
#endif
{
- entry.saddr = &inet->rcv_saddr;
- entry.daddr = &inet->daddr;
+ entry.saddr = &inet->inet_rcv_saddr;
+ entry.daddr = &inet->inet_daddr;
}
- entry.sport = inet->num;
- entry.dport = ntohs(inet->dport);
+ entry.sport = inet->inet_num;
+ entry.dport = ntohs(inet->inet_dport);
entry.userlocks = sk->sk_userlocks;
if (!inet_diag_bc_run(RTA_DATA(bc), RTA_PAYLOAD(bc), &entry))
@@ -584,7 +584,7 @@ static int inet_diag_fill_req(struct sk_buff *skb, struct sock *sk,
if (tmo < 0)
tmo = 0;
- r->id.idiag_sport = inet->sport;
+ r->id.idiag_sport = inet->inet_sport;
r->id.idiag_dport = ireq->rmt_port;
r->id.idiag_src[0] = ireq->loc_addr;
r->id.idiag_dst[0] = ireq->rmt_addr;
@@ -639,7 +639,7 @@ static int inet_diag_dump_reqs(struct sk_buff *skb, struct sock *sk,
if (cb->nlh->nlmsg_len > 4 + NLMSG_SPACE(sizeof(*r))) {
bc = (struct rtattr *)(r + 1);
- entry.sport = inet->num;
+ entry.sport = inet->inet_num;
entry.userlocks = sk->sk_userlocks;
}
@@ -732,7 +732,7 @@ static int inet_diag_dump(struct sk_buff *skb, struct netlink_callback *cb)
continue;
}
- if (r->id.idiag_sport != inet->sport &&
+ if (r->id.idiag_sport != inet->inet_sport &&
r->id.idiag_sport)
goto next_listen;
@@ -797,10 +797,10 @@ skip_listen_ht:
goto next_normal;
if (!(r->idiag_states & (1 << sk->sk_state)))
goto next_normal;
- if (r->id.idiag_sport != inet->sport &&
+ if (r->id.idiag_sport != inet->inet_sport &&
r->id.idiag_sport)
goto next_normal;
- if (r->id.idiag_dport != inet->dport &&
+ if (r->id.idiag_dport != inet->inet_dport &&
r->id.idiag_dport)
goto next_normal;
if (inet_csk_diag_dump(sk, skb, cb) < 0) {
diff --git a/net/ipv4/inet_hashtables.c b/net/ipv4/inet_hashtables.c
index a45aaf3..47ad7aa 100644
--- a/net/ipv4/inet_hashtables.c
+++ b/net/ipv4/inet_hashtables.c
@@ -64,7 +64,7 @@ void inet_bind_hash(struct sock *sk, struct inet_bind_bucket *tb,
atomic_inc(&hashinfo->bsockets);
- inet_sk(sk)->num = snum;
+ inet_sk(sk)->inet_num = snum;
sk_add_bind_node(sk, &tb->owners);
tb->num_owners++;
inet_csk(sk)->icsk_bind_hash = tb;
@@ -76,7 +76,7 @@ void inet_bind_hash(struct sock *sk, struct inet_bind_bucket *tb,
static void __inet_put_port(struct sock *sk)
{
struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;
- const int bhash = inet_bhashfn(sock_net(sk), inet_sk(sk)->num,
+ const int bhash = inet_bhashfn(sock_net(sk), inet_sk(sk)->inet_num,
hashinfo->bhash_size);
struct inet_bind_hashbucket *head = &hashinfo->bhash[bhash];
struct inet_bind_bucket *tb;
@@ -88,7 +88,7 @@ static void __inet_put_port(struct sock *sk)
__sk_del_bind_node(sk);
tb->num_owners--;
inet_csk(sk)->icsk_bind_hash = NULL;
- inet_sk(sk)->num = 0;
+ inet_sk(sk)->inet_num = 0;
inet_bind_bucket_destroy(hashinfo->bind_bucket_cachep, tb);
spin_unlock(&head->lock);
}
@@ -105,7 +105,7 @@ EXPORT_SYMBOL(inet_put_port);
void __inet_inherit_port(struct sock *sk, struct sock *child)
{
struct inet_hashinfo *table = sk->sk_prot->h.hashinfo;
- const int bhash = inet_bhashfn(sock_net(sk), inet_sk(child)->num,
+ const int bhash = inet_bhashfn(sock_net(sk), inet_sk(child)->inet_num,
table->bhash_size);
struct inet_bind_hashbucket *head = &table->bhash[bhash];
struct inet_bind_bucket *tb;
@@ -126,9 +126,9 @@ static inline int compute_score(struct sock *sk, struct net *net,
int score = -1;
struct inet_sock *inet = inet_sk(sk);
- if (net_eq(sock_net(sk), net) && inet->num == hnum &&
+ if (net_eq(sock_net(sk), net) && inet->inet_num == hnum &&
!ipv6_only_sock(sk)) {
- __be32 rcv_saddr = inet->rcv_saddr;
+ __be32 rcv_saddr = inet->inet_rcv_saddr;
score = sk->sk_family == PF_INET ? 1 : 0;
if (rcv_saddr) {
if (rcv_saddr != daddr)
@@ -273,13 +273,14 @@ static int __inet_check_established(struct inet_timewait_death_row *death_row,
{
struct inet_hashinfo *hinfo = death_row->hashinfo;
struct inet_sock *inet = inet_sk(sk);
- __be32 daddr = inet->rcv_saddr;
- __be32 saddr = inet->daddr;
+ __be32 daddr = inet->inet_rcv_saddr;
+ __be32 saddr = inet->inet_daddr;
int dif = sk->sk_bound_dev_if;
INET_ADDR_COOKIE(acookie, saddr, daddr)
- const __portpair ports = INET_COMBINED_PORTS(inet->dport, lport);
+ const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport);
struct net *net = sock_net(sk);
- unsigned int hash = inet_ehashfn(net, daddr, lport, saddr, inet->dport);
+ unsigned int hash = inet_ehashfn(net, daddr, lport,
+ saddr, inet->inet_dport);
struct inet_ehash_bucket *head = inet_ehash_bucket(hinfo, hash);
spinlock_t *lock = inet_ehash_lockp(hinfo, hash);
struct sock *sk2;
@@ -312,8 +313,8 @@ static int __inet_check_established(struct inet_timewait_death_row *death_row,
unique:
/* Must record num and sport now. Otherwise we will see
* in hash table socket with a funny identity. */
- inet->num = lport;
- inet->sport = htons(lport);
+ inet->inet_num = lport;
+ inet->inet_sport = htons(lport);
sk->sk_hash = hash;
WARN_ON(!sk_unhashed(sk));
__sk_nulls_add_node_rcu(sk, &head->chain);
@@ -341,8 +342,9 @@ not_unique:
static inline u32 inet_sk_port_offset(const struct sock *sk)
{
const struct inet_sock *inet = inet_sk(sk);
- return secure_ipv4_port_ephemeral(inet->rcv_saddr, inet->daddr,
- inet->dport);
+ return secure_ipv4_port_ephemeral(inet->inet_rcv_saddr,
+ inet->inet_daddr,
+ inet->inet_dport);
}
void __inet_hash_nolisten(struct sock *sk)
@@ -424,7 +426,7 @@ int __inet_hash_connect(struct inet_timewait_death_row *death_row,
void (*hash)(struct sock *sk))
{
struct inet_hashinfo *hinfo = death_row->hashinfo;
- const unsigned short snum = inet_sk(sk)->num;
+ const unsigned short snum = inet_sk(sk)->inet_num;
struct inet_bind_hashbucket *head;
struct inet_bind_bucket *tb;
int ret;
@@ -485,7 +487,7 @@ ok:
/* Head lock still held and bh's disabled */
inet_bind_hash(sk, tb, port);
if (sk_unhashed(sk)) {
- inet_sk(sk)->sport = htons(port);
+ inet_sk(sk)->inet_sport = htons(port);
hash(sk);
}
spin_unlock(&head->lock);
diff --git a/net/ipv4/inet_timewait_sock.c b/net/ipv4/inet_timewait_sock.c
index 2fe5711..1f5d508 100644
--- a/net/ipv4/inet_timewait_sock.c
+++ b/net/ipv4/inet_timewait_sock.c
@@ -86,7 +86,7 @@ void __inet_twsk_hashdance(struct inet_timewait_sock *tw, struct sock *sk,
Note, that any socket with inet->num != 0 MUST be bound in
binding cache, even if it is closed.
*/
- bhead = &hashinfo->bhash[inet_bhashfn(twsk_net(tw), inet->num,
+ bhead = &hashinfo->bhash[inet_bhashfn(twsk_net(tw), inet->inet_num,
hashinfo->bhash_size)];
spin_lock(&bhead->lock);
tw->tw_tb = icsk->icsk_bind_hash;
@@ -124,14 +124,14 @@ struct inet_timewait_sock *inet_twsk_alloc(const struct sock *sk, const int stat
kmemcheck_annotate_bitfield(tw, flags);
/* Give us an identity. */
- tw->tw_daddr = inet->daddr;
- tw->tw_rcv_saddr = inet->rcv_saddr;
+ tw->tw_daddr = inet->inet_daddr;
+ tw->tw_rcv_saddr = inet->inet_rcv_saddr;
tw->tw_bound_dev_if = sk->sk_bound_dev_if;
- tw->tw_num = inet->num;
+ tw->tw_num = inet->inet_num;
tw->tw_state = TCP_TIME_WAIT;
tw->tw_substate = state;
- tw->tw_sport = inet->sport;
- tw->tw_dport = inet->dport;
+ tw->tw_sport = inet->inet_sport;
+ tw->tw_dport = inet->inet_dport;
tw->tw_family = sk->sk_family;
tw->tw_reuse = sk->sk_reuse;
tw->tw_hash = sk->sk_hash;
diff --git a/net/ipv4/ip_input.c b/net/ipv4/ip_input.c
index 6c98b43..fdf51ba 100644
--- a/net/ipv4/ip_input.c
+++ b/net/ipv4/ip_input.c
@@ -161,7 +161,7 @@ int ip_call_ra_chain(struct sk_buff *skb)
/* If socket is bound to an interface, only report
* the packet if it came from that interface.
*/
- if (sk && inet_sk(sk)->num == protocol &&
+ if (sk && inet_sk(sk)->inet_num == protocol &&
(!sk->sk_bound_dev_if ||
sk->sk_bound_dev_if == dev->ifindex) &&
sock_net(sk) == dev_net(dev)) {
diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c
index f989518..322b408 100644
--- a/net/ipv4/ip_output.c
+++ b/net/ipv4/ip_output.c
@@ -329,7 +329,7 @@ int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
__be32 daddr;
/* Use correct destination address if we have options. */
- daddr = inet->daddr;
+ daddr = inet->inet_daddr;
if(opt && opt->srr)
daddr = opt->faddr;
@@ -338,13 +338,13 @@ int ip_queue_xmit(struct sk_buff *skb, int ipfragok)
.mark = sk->sk_mark,
.nl_u = { .ip4_u =
{ .daddr = daddr,
- .saddr = inet->saddr,
+ .saddr = inet->inet_saddr,
.tos = RT_CONN_FLAGS(sk) } },
.proto = sk->sk_protocol,
.flags = inet_sk_flowi_flags(sk),
.uli_u = { .ports =
- { .sport = inet->sport,
- .dport = inet->dport } } };
+ { .sport = inet->inet_sport,
+ .dport = inet->inet_dport } } };
/* If this fails, retransmit mechanism of transport layer will
* keep trying until route appears or the connection times
@@ -379,7 +379,7 @@ packet_routed:
if (opt && opt->optlen) {
iph->ihl += opt->optlen >> 2;
- ip_options_build(skb, opt, inet->daddr, rt, 0);
+ ip_options_build(skb, opt, inet->inet_daddr, rt, 0);
}
ip_select_ident_more(iph, &rt->u.dst, sk,
@@ -846,7 +846,8 @@ int ip_append_data(struct sock *sk,
maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
if (inet->cork.length + length > 0xFFFF - fragheaderlen) {
- ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu-exthdrlen);
+ ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->inet_dport,
+ mtu-exthdrlen);
return -EMSGSIZE;
}
@@ -1100,7 +1101,7 @@ ssize_t ip_append_page(struct sock *sk, struct page *page,
maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
if (inet->cork.length + size > 0xFFFF - fragheaderlen) {
- ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu);
+ ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->inet_dport, mtu);
return -EMSGSIZE;
}
diff --git a/net/ipv4/ip_sockglue.c b/net/ipv4/ip_sockglue.c
index 0c0b6e3..c602d98 100644
--- a/net/ipv4/ip_sockglue.c
+++ b/net/ipv4/ip_sockglue.c
@@ -245,7 +245,7 @@ int ip_ra_control(struct sock *sk, unsigned char on,
{
struct ip_ra_chain *ra, *new_ra, **rap;
- if (sk->sk_type != SOCK_RAW || inet_sk(sk)->num == IPPROTO_RAW)
+ if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num == IPPROTO_RAW)
return -EINVAL;
new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
@@ -492,7 +492,7 @@ static int do_ip_setsockopt(struct sock *sk, int level,
if (sk->sk_family == PF_INET ||
(!((1 << sk->sk_state) &
(TCPF_LISTEN | TCPF_CLOSE)) &&
- inet->daddr != LOOPBACK4_IPV6)) {
+ inet->inet_daddr != LOOPBACK4_IPV6)) {
#endif
if (inet->opt)
icsk->icsk_ext_hdr_len -= inet->opt->optlen;
@@ -1181,8 +1181,8 @@ static int do_ip_getsockopt(struct sock *sk, int level, int optname,
if (inet->cmsg_flags & IP_CMSG_PKTINFO) {
struct in_pktinfo info;
- info.ipi_addr.s_addr = inet->rcv_saddr;
- info.ipi_spec_dst.s_addr = inet->rcv_saddr;
+ info.ipi_addr.s_addr = inet->inet_rcv_saddr;
+ info.ipi_spec_dst.s_addr = inet->inet_rcv_saddr;
info.ipi_ifindex = inet->mc_index;
put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
}
diff --git a/net/ipv4/ipmr.c b/net/ipv4/ipmr.c
index c757f0b..6949745 100644
--- a/net/ipv4/ipmr.c
+++ b/net/ipv4/ipmr.c
@@ -956,7 +956,7 @@ int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsi
switch (optname) {
case MRT_INIT:
if (sk->sk_type != SOCK_RAW ||
- inet_sk(sk)->num != IPPROTO_IGMP)
+ inet_sk(sk)->inet_num != IPPROTO_IGMP)
return -EOPNOTSUPP;
if (optlen != sizeof(int))
return -ENOPROTOOPT;
diff --git a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
index aa95bb8..9cd423f 100644
--- a/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+++ b/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
@@ -255,10 +255,10 @@ getorigdst(struct sock *sk, int optval, void __user *user, int *len)
struct nf_conntrack_tuple tuple;
memset(&tuple, 0, sizeof(tuple));
- tuple.src.u3.ip = inet->rcv_saddr;
- tuple.src.u.tcp.port = inet->sport;
- tuple.dst.u3.ip = inet->daddr;
- tuple.dst.u.tcp.port = inet->dport;
+ tuple.src.u3.ip = inet->inet_rcv_saddr;
+ tuple.src.u.tcp.port = inet->inet_sport;
+ tuple.dst.u3.ip = inet->inet_daddr;
+ tuple.dst.u.tcp.port = inet->inet_dport;
tuple.src.l3num = PF_INET;
tuple.dst.protonum = sk->sk_protocol;
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index 39e2a6b..9ef8c08 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -87,7 +87,7 @@ void raw_hash_sk(struct sock *sk)
struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;
struct hlist_head *head;
- head = &h->ht[inet_sk(sk)->num & (RAW_HTABLE_SIZE - 1)];
+ head = &h->ht[inet_sk(sk)->inet_num & (RAW_HTABLE_SIZE - 1)];
write_lock_bh(&h->lock);
sk_add_node(sk, head);
@@ -115,9 +115,9 @@ static struct sock *__raw_v4_lookup(struct net *net, struct sock *sk,
sk_for_each_from(sk, node) {
struct inet_sock *inet = inet_sk(sk);
- if (net_eq(sock_net(sk), net) && inet->num == num &&
- !(inet->daddr && inet->daddr != raddr) &&
- !(inet->rcv_saddr && inet->rcv_saddr != laddr) &&
+ if (net_eq(sock_net(sk), net) && inet->inet_num == num &&
+ !(inet->inet_daddr && inet->inet_daddr != raddr) &&
+ !(inet->inet_rcv_saddr && inet->inet_rcv_saddr != laddr) &&
!(sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif))
goto found; /* gotcha */
}
@@ -326,7 +326,7 @@ static int raw_send_hdrinc(struct sock *sk, void *from, size_t length,
int err;
if (length > rt->u.dst.dev->mtu) {
- ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport,
+ ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->inet_dport,
rt->u.dst.dev->mtu);
return -EMSGSIZE;
}
@@ -489,10 +489,10 @@ static int raw_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
err = -EDESTADDRREQ;
if (sk->sk_state != TCP_ESTABLISHED)
goto out;
- daddr = inet->daddr;
+ daddr = inet->inet_daddr;
}
- ipc.addr = inet->saddr;
+ ipc.addr = inet->inet_saddr;
ipc.opt = NULL;
ipc.shtx.flags = 0;
ipc.oif = sk->sk_bound_dev_if;
@@ -634,9 +634,9 @@ static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
if (addr->sin_addr.s_addr && chk_addr_ret != RTN_LOCAL &&
chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST)
goto out;
- inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;
+ inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;
if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
- inet->saddr = 0; /* Use device */
+ inet->inet_saddr = 0; /* Use device */
sk_dst_reset(sk);
ret = 0;
out: return ret;
@@ -706,7 +706,7 @@ static int raw_init(struct sock *sk)
{
struct raw_sock *rp = raw_sk(sk);
- if (inet_sk(sk)->num == IPPROTO_ICMP)
+ if (inet_sk(sk)->inet_num == IPPROTO_ICMP)
memset(&rp->filter, 0, sizeof(rp->filter));
return 0;
}
@@ -743,7 +743,7 @@ static int do_raw_setsockopt(struct sock *sk, int level, int optname,
char __user *optval, unsigned int optlen)
{
if (optname == ICMP_FILTER) {
- if (inet_sk(sk)->num != IPPROTO_ICMP)
+ if (inet_sk(sk)->inet_num != IPPROTO_ICMP)
return -EOPNOTSUPP;
else
return raw_seticmpfilter(sk, optval, optlen);
@@ -773,7 +773,7 @@ static int do_raw_getsockopt(struct sock *sk, int level, int optname,
char __user *optval, int __user *optlen)
{
if (optname == ICMP_FILTER) {
- if (inet_sk(sk)->num != IPPROTO_ICMP)
+ if (inet_sk(sk)->inet_num != IPPROTO_ICMP)
return -EOPNOTSUPP;
else
return raw_geticmpfilter(sk, optval, optlen);
@@ -932,10 +932,10 @@ EXPORT_SYMBOL_GPL(raw_seq_stop);
static void raw_sock_seq_show(struct seq_file *seq, struct sock *sp, int i)
{
struct inet_sock *inet = inet_sk(sp);
- __be32 dest = inet->daddr,
- src = inet->rcv_saddr;
+ __be32 dest = inet->inet_daddr,
+ src = inet->inet_rcv_saddr;
__u16 destp = 0,
- srcp = inet->num;
+ srcp = inet->inet_num;
seq_printf(seq, "%4d: %08X:%04X %08X:%04X"
" %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d\n",
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index cf13726..206a291 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -1998,7 +1998,7 @@ int tcp_disconnect(struct sock *sk, int flags)
__skb_queue_purge(&sk->sk_async_wait_queue);
#endif
- inet->dport = 0;
+ inet->inet_dport = 0;
if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
inet_reset_saddr(sk);
@@ -2022,7 +2022,7 @@ int tcp_disconnect(struct sock *sk, int flags)
memset(&tp->rx_opt, 0, sizeof(tp->rx_opt));
__sk_dst_reset(sk);
- WARN_ON(inet->num && !icsk->icsk_bind_hash);
+ WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
sk->sk_error_report(sk);
return err;
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 9971870..a4a3390 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -165,10 +165,10 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
nexthop = inet->opt->faddr;
}
- tmp = ip_route_connect(&rt, nexthop, inet->saddr,
+ tmp = ip_route_connect(&rt, nexthop, inet->inet_saddr,
RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
IPPROTO_TCP,
- inet->sport, usin->sin_port, sk, 1);
+ inet->inet_sport, usin->sin_port, sk, 1);
if (tmp < 0) {
if (tmp == -ENETUNREACH)
IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
@@ -183,11 +183,11 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
if (!inet->opt || !inet->opt->srr)
daddr = rt->rt_dst;
- if (!inet->saddr)
- inet->saddr = rt->rt_src;
- inet->rcv_saddr = inet->saddr;
+ if (!inet->inet_saddr)
+ inet->inet_saddr = rt->rt_src;
+ inet->inet_rcv_saddr = inet->inet_saddr;
- if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
+ if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
/* Reset inherited state */
tp->rx_opt.ts_recent = 0;
tp->rx_opt.ts_recent_stamp = 0;
@@ -210,8 +210,8 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
}
}
- inet->dport = usin->sin_port;
- inet->daddr = daddr;
+ inet->inet_dport = usin->sin_port;
+ inet->inet_daddr = daddr;
inet_csk(sk)->icsk_ext_hdr_len = 0;
if (inet->opt)
@@ -230,7 +230,7 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
goto failure;
err = ip_route_newports(&rt, IPPROTO_TCP,
- inet->sport, inet->dport, sk);
+ inet->inet_sport, inet->inet_dport, sk);
if (err)
goto failure;
@@ -239,12 +239,12 @@ int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
sk_setup_caps(sk, &rt->u.dst);
if (!tp->write_seq)
- tp->write_seq = secure_tcp_sequence_number(inet->saddr,
- inet->daddr,
- inet->sport,
+ tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
+ inet->inet_daddr,
+ inet->inet_sport,
usin->sin_port);
- inet->id = tp->write_seq ^ jiffies;
+ inet->inet_id = tp->write_seq ^ jiffies;
err = tcp_connect(sk);
rt = NULL;
@@ -261,7 +261,7 @@ failure:
tcp_set_state(sk, TCP_CLOSE);
ip_rt_put(rt);
sk->sk_route_caps = 0;
- inet->dport = 0;
+ inet->inet_dport = 0;
return err;
}
@@ -520,12 +520,13 @@ void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
struct tcphdr *th = tcp_hdr(skb);
if (skb->ip_summed == CHECKSUM_PARTIAL) {
- th->check = ~tcp_v4_check(len, inet->saddr,
- inet->daddr, 0);
+ th->check = ~tcp_v4_check(len, inet->inet_saddr,
+ inet->inet_daddr, 0);
skb->csum_start = skb_transport_header(skb) - skb->head;
skb->csum_offset = offsetof(struct tcphdr, check);
} else {
- th->check = tcp_v4_check(len, inet->saddr, inet->daddr,
+ th->check = tcp_v4_check(len, inet->inet_saddr,
+ inet->inet_daddr,
csum_partial(th,
th->doff << 2,
skb->csum));
@@ -848,7 +849,7 @@ static struct tcp_md5sig_key *
struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
struct sock *addr_sk)
{
- return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->daddr);
+ return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->inet_daddr);
}
EXPORT_SYMBOL(tcp_v4_md5_lookup);
@@ -923,7 +924,7 @@ EXPORT_SYMBOL(tcp_v4_md5_do_add);
static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
u8 *newkey, u8 newkeylen)
{
- return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->daddr,
+ return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->inet_daddr,
newkey, newkeylen);
}
@@ -1089,8 +1090,8 @@ int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
__be32 saddr, daddr;
if (sk) {
- saddr = inet_sk(sk)->saddr;
- daddr = inet_sk(sk)->daddr;
+ saddr = inet_sk(sk)->inet_saddr;
+ daddr = inet_sk(sk)->inet_daddr;
} else if (req) {
saddr = inet_rsk(req)->loc_addr;
daddr = inet_rsk(req)->rmt_addr;
@@ -1380,9 +1381,9 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
newtp = tcp_sk(newsk);
newinet = inet_sk(newsk);
ireq = inet_rsk(req);
- newinet->daddr = ireq->rmt_addr;
- newinet->rcv_saddr = ireq->loc_addr;
- newinet->saddr = ireq->loc_addr;
+ newinet->inet_daddr = ireq->rmt_addr;
+ newinet->inet_rcv_saddr = ireq->loc_addr;
+ newinet->inet_saddr = ireq->loc_addr;
newinet->opt = ireq->opt;
ireq->opt = NULL;
newinet->mc_index = inet_iif(skb);
@@ -1390,7 +1391,7 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
inet_csk(newsk)->icsk_ext_hdr_len = 0;
if (newinet->opt)
inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
- newinet->id = newtp->write_seq ^ jiffies;
+ newinet->inet_id = newtp->write_seq ^ jiffies;
tcp_mtup_init(newsk);
tcp_sync_mss(newsk, dst_mtu(dst));
@@ -1403,7 +1404,8 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
#ifdef CONFIG_TCP_MD5SIG
/* Copy over the MD5 key from the original socket */
- if ((key = tcp_v4_md5_do_lookup(sk, newinet->daddr)) != NULL) {
+ key = tcp_v4_md5_do_lookup(sk, newinet->inet_daddr);
+ if (key != NULL) {
/*
* We're using one, so create a matching key
* on the newsk structure. If we fail to get
@@ -1412,7 +1414,7 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
*/
char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
if (newkey != NULL)
- tcp_v4_md5_do_add(newsk, newinet->daddr,
+ tcp_v4_md5_do_add(newsk, newinet->inet_daddr,
newkey, key->keylen);
newsk->sk_route_caps &= ~NETIF_F_GSO_MASK;
}
@@ -1711,8 +1713,8 @@ int tcp_v4_remember_stamp(struct sock *sk)
struct inet_peer *peer = NULL;
int release_it = 0;
- if (!rt || rt->rt_dst != inet->daddr) {
- peer = inet_getpeer(inet->daddr, 1);
+ if (!rt || rt->rt_dst != inet->inet_daddr) {
+ peer = inet_getpeer(inet->inet_daddr, 1);
release_it = 1;
} else {
if (!rt->peer)
@@ -2225,7 +2227,7 @@ static void get_openreq4(struct sock *sk, struct request_sock *req,
" %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
i,
ireq->loc_addr,
- ntohs(inet_sk(sk)->sport),
+ ntohs(inet_sk(sk)->inet_sport),
ireq->rmt_addr,
ntohs(ireq->rmt_port),
TCP_SYN_RECV,
@@ -2248,10 +2250,10 @@ static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
struct tcp_sock *tp = tcp_sk(sk);
const struct inet_connection_sock *icsk = inet_csk(sk);
struct inet_sock *inet = inet_sk(sk);
- __be32 dest = inet->daddr;
- __be32 src = inet->rcv_saddr;
- __u16 destp = ntohs(inet->dport);
- __u16 srcp = ntohs(inet->sport);
+ __be32 dest = inet->inet_daddr;
+ __be32 src = inet->inet_rcv_saddr;
+ __u16 destp = ntohs(inet->inet_dport);
+ __u16 srcp = ntohs(inet->inet_sport);
if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
timer_active = 1;
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index fcd278a..2e2eb74 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -661,8 +661,8 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
/* Build TCP header and checksum it. */
th = tcp_hdr(skb);
- th->source = inet->sport;
- th->dest = inet->dport;
+ th->source = inet->inet_sport;
+ th->dest = inet->inet_dport;
th->seq = htonl(tcb->seq);
th->ack_seq = htonl(tp->rcv_nxt);
*(((__be16 *)th) + 6) = htons(((tcp_header_size >> 2) << 12) |
diff --git a/net/ipv4/tcp_probe.c b/net/ipv4/tcp_probe.c
index 59f5b5e..7a3cc2f 100644
--- a/net/ipv4/tcp_probe.c
+++ b/net/ipv4/tcp_probe.c
@@ -94,7 +94,8 @@ static int jtcp_rcv_established(struct sock *sk, struct sk_buff *skb,
const struct inet_sock *inet = inet_sk(sk);
/* Only update if port matches */
- if ((port == 0 || ntohs(inet->dport) == port || ntohs(inet->sport) == port)
+ if ((port == 0 || ntohs(inet->inet_dport) == port ||
+ ntohs(inet->inet_sport) == port)
&& (full || tp->snd_cwnd != tcp_probe.lastcwnd)) {
spin_lock(&tcp_probe.lock);
@@ -103,10 +104,10 @@ static int jtcp_rcv_established(struct sock *sk, struct sk_buff *skb,
struct tcp_log *p = tcp_probe.log + tcp_probe.head;
p->tstamp = ktime_get();
- p->saddr = inet->saddr;
- p->sport = inet->sport;
- p->daddr = inet->daddr;
- p->dport = inet->dport;
+ p->saddr = inet->inet_saddr;
+ p->sport = inet->inet_sport;
+ p->daddr = inet->inet_daddr;
+ p->dport = inet->inet_dport;
p->length = skb->len;
p->snd_nxt = tp->snd_nxt;
p->snd_una = tp->snd_una;
diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index cdb2ca7..6e8996c 100644
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -303,15 +303,15 @@ void tcp_retransmit_timer(struct sock *sk)
struct inet_sock *inet = inet_sk(sk);
if (sk->sk_family == AF_INET) {
LIMIT_NETDEBUG(KERN_DEBUG "TCP: Peer %pI4:%u/%u unexpectedly shrunk window %u:%u (repaired)\n",
- &inet->daddr, ntohs(inet->dport),
- inet->num, tp->snd_una, tp->snd_nxt);
+ &inet->inet_daddr, ntohs(inet->inet_dport),
+ inet->inet_num, tp->snd_una, tp->snd_nxt);
}
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
else if (sk->sk_family == AF_INET6) {
struct ipv6_pinfo *np = inet6_sk(sk);
LIMIT_NETDEBUG(KERN_DEBUG "TCP: Peer %pI6:%u/%u unexpectedly shrunk window %u:%u (repaired)\n",
- &np->daddr, ntohs(inet->dport),
- inet->num, tp->snd_una, tp->snd_nxt);
+ &np->daddr, ntohs(inet->inet_dport),
+ inet->inet_num, tp->snd_una, tp->snd_nxt);
}
#endif
#endif
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 45a8a7e..ec5c7a7 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -214,7 +214,7 @@ int udp_lib_get_port(struct sock *sk, unsigned short snum,
goto fail_unlock;
}
found:
- inet_sk(sk)->num = snum;
+ inet_sk(sk)->inet_num = snum;
sk->sk_hash = snum;
if (sk_unhashed(sk)) {
sk_nulls_add_node_rcu(sk, &hslot->head);
@@ -233,8 +233,8 @@ static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
struct inet_sock *inet1 = inet_sk(sk1), *inet2 = inet_sk(sk2);
return (!ipv6_only_sock(sk2) &&
- (!inet1->rcv_saddr || !inet2->rcv_saddr ||
- inet1->rcv_saddr == inet2->rcv_saddr));
+ (!inet1->inet_rcv_saddr || !inet2->inet_rcv_saddr ||
+ inet1->inet_rcv_saddr == inet2->inet_rcv_saddr));
}
int udp_v4_get_port(struct sock *sk, unsigned short snum)
@@ -253,18 +253,18 @@ static inline int compute_score(struct sock *sk, struct net *net, __be32 saddr,
struct inet_sock *inet = inet_sk(sk);
score = (sk->sk_family == PF_INET ? 1 : 0);
- if (inet->rcv_saddr) {
- if (inet->rcv_saddr != daddr)
+ if (inet->inet_rcv_saddr) {
+ if (inet->inet_rcv_saddr != daddr)
return -1;
score += 2;
}
- if (inet->daddr) {
- if (inet->daddr != saddr)
+ if (inet->inet_daddr) {
+ if (inet->inet_daddr != saddr)
return -1;
score += 2;
}
- if (inet->dport) {
- if (inet->dport != sport)
+ if (inet->inet_dport) {
+ if (inet->inet_dport != sport)
return -1;
score += 2;
}
@@ -360,9 +360,10 @@ static inline struct sock *udp_v4_mcast_next(struct net *net, struct sock *sk,
if (!net_eq(sock_net(s), net) ||
s->sk_hash != hnum ||
- (inet->daddr && inet->daddr != rmt_addr) ||
- (inet->dport != rmt_port && inet->dport) ||
- (inet->rcv_saddr && inet->rcv_saddr != loc_addr) ||
+ (inet->inet_daddr && inet->inet_daddr != rmt_addr) ||
+ (inet->inet_dport != rmt_port && inet->inet_dport) ||
+ (inet->inet_rcv_saddr &&
+ inet->inet_rcv_saddr != loc_addr) ||
ipv6_only_sock(s) ||
(s->sk_bound_dev_if && s->sk_bound_dev_if != dif))
continue;
@@ -646,14 +647,14 @@ int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
} else {
if (sk->sk_state != TCP_ESTABLISHED)
return -EDESTADDRREQ;
- daddr = inet->daddr;
- dport = inet->dport;
+ daddr = inet->inet_daddr;
+ dport = inet->inet_dport;
/* Open fast path for connected socket.
Route will not be used, if at least one option is set.
*/
connected = 1;
}
- ipc.addr = inet->saddr;
+ ipc.addr = inet->inet_saddr;
ipc.oif = sk->sk_bound_dev_if;
err = sock_tx_timestamp(msg, sk, &ipc.shtx);
@@ -708,7 +709,7 @@ int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
.proto = sk->sk_protocol,
.flags = inet_sk_flowi_flags(sk),
.uli_u = { .ports =
- { .sport = inet->sport,
+ { .sport = inet->inet_sport,
.dport = dport } } };
struct net *net = sock_net(sk);
@@ -752,7 +753,7 @@ back_from_confirm:
inet->cork.fl.fl4_dst = daddr;
inet->cork.fl.fl_ip_dport = dport;
inet->cork.fl.fl4_src = saddr;
- inet->cork.fl.fl_ip_sport = inet->sport;
+ inet->cork.fl.fl_ip_sport = inet->inet_sport;
up->pending = AF_INET;
do_append_data:
@@ -1029,15 +1030,15 @@ int udp_disconnect(struct sock *sk, int flags)
*/
sk->sk_state = TCP_CLOSE;
- inet->daddr = 0;
- inet->dport = 0;
+ inet->inet_daddr = 0;
+ inet->inet_dport = 0;
sk->sk_bound_dev_if = 0;
if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
inet_reset_saddr(sk);
if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
sk->sk_prot->unhash(sk);
- inet->sport = 0;
+ inet->inet_sport = 0;
}
sk_dst_reset(sk);
return 0;
@@ -1053,7 +1054,7 @@ void udp_lib_unhash(struct sock *sk)
spin_lock_bh(&hslot->lock);
if (sk_nulls_del_node_init_rcu(sk)) {
- inet_sk(sk)->num = 0;
+ inet_sk(sk)->inet_num = 0;
sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
}
spin_unlock_bh(&hslot->lock);
@@ -1752,10 +1753,10 @@ static void udp4_format_sock(struct sock *sp, struct seq_file *f,
int bucket, int *len)
{
struct inet_sock *inet = inet_sk(sp);
- __be32 dest = inet->daddr;
- __be32 src = inet->rcv_saddr;
- __u16 destp = ntohs(inet->dport);
- __u16 srcp = ntohs(inet->sport);
+ __be32 dest = inet->inet_daddr;
+ __be32 src = inet->inet_rcv_saddr;
+ __u16 destp = ntohs(inet->inet_dport);
+ __u16 srcp = ntohs(inet->inet_sport);
seq_printf(f, "%5d: %08X:%04X %08X:%04X"
" %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d%n",
diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index 9421651..b6d0588 100644
--- a/net/ipv6/af_inet6.c
+++ b/net/ipv6/af_inet6.c
@@ -185,7 +185,7 @@ lookup_protocol:
inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;
if (SOCK_RAW == sock->type) {
- inet->num = protocol;
+ inet->inet_num = protocol;
if (IPPROTO_RAW == protocol)
inet->hdrincl = 1;
}
@@ -228,12 +228,12 @@ lookup_protocol:
*/
sk_refcnt_debug_inc(sk);
- if (inet->num) {
+ if (inet->inet_num) {
/* It assumes that any protocol which allows
* the user to assign a number at socket
* creation time automatically shares.
*/
- inet->sport = htons(inet->num);
+ inet->inet_sport = htons(inet->inet_num);
sk->sk_prot->hash(sk);
}
if (sk->sk_prot->init) {
@@ -281,7 +281,7 @@ int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
lock_sock(sk);
/* Check these errors (active socket, double bind). */
- if (sk->sk_state != TCP_CLOSE || inet->num) {
+ if (sk->sk_state != TCP_CLOSE || inet->inet_num) {
err = -EINVAL;
goto out;
}
@@ -353,8 +353,8 @@ int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
}
}
- inet->rcv_saddr = v4addr;
- inet->saddr = v4addr;
+ inet->inet_rcv_saddr = v4addr;
+ inet->inet_saddr = v4addr;
ipv6_addr_copy(&np->rcv_saddr, &addr->sin6_addr);
@@ -375,9 +375,9 @@ int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
}
if (snum)
sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
- inet->sport = htons(inet->num);
- inet->dport = 0;
- inet->daddr = 0;
+ inet->inet_sport = htons(inet->inet_num);
+ inet->inet_dport = 0;
+ inet->inet_daddr = 0;
out:
release_sock(sk);
return err;
@@ -441,12 +441,12 @@ int inet6_getname(struct socket *sock, struct sockaddr *uaddr,
sin->sin6_flowinfo = 0;
sin->sin6_scope_id = 0;
if (peer) {
- if (!inet->dport)
+ if (!inet->inet_dport)
return -ENOTCONN;
if (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) &&
peer == 1)
return -ENOTCONN;
- sin->sin6_port = inet->dport;
+ sin->sin6_port = inet->inet_dport;
ipv6_addr_copy(&sin->sin6_addr, &np->daddr);
if (np->sndflow)
sin->sin6_flowinfo = np->flow_label;
@@ -456,7 +456,7 @@ int inet6_getname(struct socket *sock, struct sockaddr *uaddr,
else
ipv6_addr_copy(&sin->sin6_addr, &np->rcv_saddr);
- sin->sin6_port = inet->sport;
+ sin->sin6_port = inet->inet_sport;
}
if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL)
sin->sin6_scope_id = sk->sk_bound_dev_if;
@@ -655,8 +655,8 @@ int inet6_sk_rebuild_header(struct sock *sk)
fl.fl6_flowlabel = np->flow_label;
fl.oif = sk->sk_bound_dev_if;
fl.mark = sk->sk_mark;
- fl.fl_ip_dport = inet->dport;
- fl.fl_ip_sport = inet->sport;
+ fl.fl_ip_dport = inet->inet_dport;
+ fl.fl_ip_sport = inet->inet_sport;
security_sk_classify_flow(sk, &fl);
if (np->opt && np->opt->srcrt) {
diff --git a/net/ipv6/datagram.c b/net/ipv6/datagram.c
index dbfec71..9f70452 100644
--- a/net/ipv6/datagram.c
+++ b/net/ipv6/datagram.c
@@ -98,13 +98,14 @@ ipv4_connected:
if (err)
goto out;
- ipv6_addr_set_v4mapped(inet->daddr, &np->daddr);
+ ipv6_addr_set_v4mapped(inet->inet_daddr, &np->daddr);
if (ipv6_addr_any(&np->saddr))
- ipv6_addr_set_v4mapped(inet->saddr, &np->saddr);
+ ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
if (ipv6_addr_any(&np->rcv_saddr))
- ipv6_addr_set_v4mapped(inet->rcv_saddr, &np->rcv_saddr);
+ ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
+ &np->rcv_saddr);
goto out;
}
@@ -133,7 +134,7 @@ ipv4_connected:
ipv6_addr_copy(&np->daddr, daddr);
np->flow_label = fl.fl6_flowlabel;
- inet->dport = usin->sin6_port;
+ inet->inet_dport = usin->sin6_port;
/*
* Check for a route to destination an obtain the
@@ -145,8 +146,8 @@ ipv4_connected:
ipv6_addr_copy(&fl.fl6_src, &np->saddr);
fl.oif = sk->sk_bound_dev_if;
fl.mark = sk->sk_mark;
- fl.fl_ip_dport = inet->dport;
- fl.fl_ip_sport = inet->sport;
+ fl.fl_ip_dport = inet->inet_dport;
+ fl.fl_ip_sport = inet->inet_sport;
if (!fl.oif && (addr_type&IPV6_ADDR_MULTICAST))
fl.oif = np->mcast_oif;
@@ -188,7 +189,7 @@ ipv4_connected:
if (ipv6_addr_any(&np->rcv_saddr)) {
ipv6_addr_copy(&np->rcv_saddr, &fl.fl6_src);
- inet->rcv_saddr = LOOPBACK4_IPV6;
+ inet->inet_rcv_saddr = LOOPBACK4_IPV6;
}
ip6_dst_store(sk, dst,
diff --git a/net/ipv6/inet6_connection_sock.c b/net/ipv6/inet6_connection_sock.c
index a9f4a21..19dceef 100644
--- a/net/ipv6/inet6_connection_sock.c
+++ b/net/ipv6/inet6_connection_sock.c
@@ -132,7 +132,7 @@ void inet6_csk_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr)
sin6->sin6_family = AF_INET6;
ipv6_addr_copy(&sin6->sin6_addr, &np->daddr);
- sin6->sin6_port = inet_sk(sk)->dport;
+ sin6->sin6_port = inet_sk(sk)->inet_dport;
/* We do not store received flowlabel for TCP */
sin6->sin6_flowinfo = 0;
sin6->sin6_scope_id = 0;
@@ -195,8 +195,8 @@ int inet6_csk_xmit(struct sk_buff *skb, int ipfragok)
IP6_ECN_flow_xmit(sk, fl.fl6_flowlabel);
fl.oif = sk->sk_bound_dev_if;
fl.mark = sk->sk_mark;
- fl.fl_ip_sport = inet->sport;
- fl.fl_ip_dport = inet->dport;
+ fl.fl_ip_sport = inet->inet_sport;
+ fl.fl_ip_dport = inet->inet_dport;
security_sk_classify_flow(sk, &fl);
if (np->opt && np->opt->srcrt) {
diff --git a/net/ipv6/inet6_hashtables.c b/net/ipv6/inet6_hashtables.c
index 874aed8..00c6a3e 100644
--- a/net/ipv6/inet6_hashtables.c
+++ b/net/ipv6/inet6_hashtables.c
@@ -125,7 +125,7 @@ static int inline compute_score(struct sock *sk, struct net *net,
{
int score = -1;
- if (net_eq(sock_net(sk), net) && inet_sk(sk)->num == hnum &&
+ if (net_eq(sock_net(sk), net) && inet_sk(sk)->inet_num == hnum &&
sk->sk_family == PF_INET6) {
const struct ipv6_pinfo *np = inet6_sk(sk);
@@ -214,10 +214,10 @@ static int __inet6_check_established(struct inet_timewait_death_row *death_row,
const struct in6_addr *daddr = &np->rcv_saddr;
const struct in6_addr *saddr = &np->daddr;
const int dif = sk->sk_bound_dev_if;
- const __portpair ports = INET_COMBINED_PORTS(inet->dport, lport);
+ const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport);
struct net *net = sock_net(sk);
const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr,
- inet->dport);
+ inet->inet_dport);
struct inet_ehash_bucket *head = inet_ehash_bucket(hinfo, hash);
spinlock_t *lock = inet_ehash_lockp(hinfo, hash);
struct sock *sk2;
@@ -248,8 +248,8 @@ static int __inet6_check_established(struct inet_timewait_death_row *death_row,
unique:
/* Must record num and sport now. Otherwise we will see
* in hash table socket with a funny identity. */
- inet->num = lport;
- inet->sport = htons(lport);
+ inet->inet_num = lport;
+ inet->inet_sport = htons(lport);
WARN_ON(!sk_unhashed(sk));
__sk_nulls_add_node_rcu(sk, &head->chain);
sk->sk_hash = hash;
@@ -279,7 +279,7 @@ static inline u32 inet6_sk_port_offset(const struct sock *sk)
const struct ipv6_pinfo *np = inet6_sk(sk);
return secure_ipv6_port_ephemeral(np->rcv_saddr.s6_addr32,
np->daddr.s6_addr32,
- inet->dport);
+ inet->inet_dport);
}
int inet6_hash_connect(struct inet_timewait_death_row *death_row,
diff --git a/net/ipv6/ip6mr.c b/net/ipv6/ip6mr.c
index 7161539..85849b4 100644
--- a/net/ipv6/ip6mr.c
+++ b/net/ipv6/ip6mr.c
@@ -1297,7 +1297,7 @@ int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, uns
switch (optname) {
case MRT6_INIT:
if (sk->sk_type != SOCK_RAW ||
- inet_sk(sk)->num != IPPROTO_ICMPV6)
+ inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
return -EOPNOTSUPP;
if (optlen < sizeof(int))
return -EINVAL;
diff --git a/net/ipv6/ipv6_sockglue.c b/net/ipv6/ipv6_sockglue.c
index dc0f736..39e10ac 100644
--- a/net/ipv6/ipv6_sockglue.c
+++ b/net/ipv6/ipv6_sockglue.c
@@ -64,7 +64,7 @@ int ip6_ra_control(struct sock *sk, int sel)
struct ip6_ra_chain *ra, *new_ra, **rap;
/* RA packet may be delivered ONLY to IPPROTO_RAW socket */
- if (sk->sk_type != SOCK_RAW || inet_sk(sk)->num != IPPROTO_RAW)
+ if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num != IPPROTO_RAW)
return -ENOPROTOOPT;
new_ra = (sel>=0) ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
@@ -106,7 +106,7 @@ struct ipv6_txoptions *ipv6_update_options(struct sock *sk,
if (inet_sk(sk)->is_icsk) {
if (opt &&
!((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) &&
- inet_sk(sk)->daddr != LOOPBACK4_IPV6) {
+ inet_sk(sk)->inet_daddr != LOOPBACK4_IPV6) {
struct inet_connection_sock *icsk = inet_csk(sk);
icsk->icsk_ext_hdr_len = opt->opt_flen + opt->opt_nflen;
icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
@@ -234,7 +234,7 @@ static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,
case IPV6_V6ONLY:
if (optlen < sizeof(int) ||
- inet_sk(sk)->num)
+ inet_sk(sk)->inet_num)
goto e_inval;
np->ipv6only = valbool;
retv = 0;
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index fd737ef..52ed7d7 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -72,7 +72,7 @@ static struct sock *__raw_v6_lookup(struct net *net, struct sock *sk,
int is_multicast = ipv6_addr_is_multicast(loc_addr);
sk_for_each_from(sk, node)
- if (inet_sk(sk)->num == num) {
+ if (inet_sk(sk)->inet_num == num) {
struct ipv6_pinfo *np = inet6_sk(sk);
if (!net_eq(sock_net(sk), net))
@@ -298,7 +298,7 @@ static int rawv6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
dev_put(dev);
}
- inet->rcv_saddr = inet->saddr = v4addr;
+ inet->inet_rcv_saddr = inet->inet_saddr = v4addr;
ipv6_addr_copy(&np->rcv_saddr, &addr->sin6_addr);
if (!(addr_type & IPV6_ADDR_MULTICAST))
ipv6_addr_copy(&np->saddr, &addr->sin6_addr);
@@ -415,14 +415,14 @@ int rawv6_rcv(struct sock *sk, struct sk_buff *skb)
skb_network_header_len(skb));
if (!csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
&ipv6_hdr(skb)->daddr,
- skb->len, inet->num, skb->csum))
+ skb->len, inet->inet_num, skb->csum))
skb->ip_summed = CHECKSUM_UNNECESSARY;
}
if (!skb_csum_unnecessary(skb))
skb->csum = ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
&ipv6_hdr(skb)->daddr,
skb->len,
- inet->num, 0));
+ inet->inet_num, 0));
if (inet->hdrincl) {
if (skb_checksum_complete(skb)) {
@@ -765,8 +765,8 @@ static int rawv6_sendmsg(struct kiocb *iocb, struct sock *sk,
proto = ntohs(sin6->sin6_port);
if (!proto)
- proto = inet->num;
- else if (proto != inet->num)
+ proto = inet->inet_num;
+ else if (proto != inet->inet_num)
return(-EINVAL);
if (proto > 255)
@@ -799,7 +799,7 @@ static int rawv6_sendmsg(struct kiocb *iocb, struct sock *sk,
if (sk->sk_state != TCP_ESTABLISHED)
return -EDESTADDRREQ;
- proto = inet->num;
+ proto = inet->inet_num;
daddr = &np->daddr;
fl.fl6_flowlabel = np->flow_label;
}
@@ -966,7 +966,7 @@ static int do_rawv6_setsockopt(struct sock *sk, int level, int optname,
switch (optname) {
case IPV6_CHECKSUM:
- if (inet_sk(sk)->num == IPPROTO_ICMPV6 &&
+ if (inet_sk(sk)->inet_num == IPPROTO_ICMPV6 &&
level == IPPROTO_IPV6) {
/*
* RFC3542 tells that IPV6_CHECKSUM socket
@@ -1006,7 +1006,7 @@ static int rawv6_setsockopt(struct sock *sk, int level, int optname,
break;
case SOL_ICMPV6:
- if (inet_sk(sk)->num != IPPROTO_ICMPV6)
+ if (inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
return -EOPNOTSUPP;
return rawv6_seticmpfilter(sk, level, optname, optval,
optlen);
@@ -1029,7 +1029,7 @@ static int compat_rawv6_setsockopt(struct sock *sk, int level, int optname,
case SOL_RAW:
break;
case SOL_ICMPV6:
- if (inet_sk(sk)->num != IPPROTO_ICMPV6)
+ if (inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
return -EOPNOTSUPP;
return rawv6_seticmpfilter(sk, level, optname, optval, optlen);
case SOL_IPV6:
@@ -1086,7 +1086,7 @@ static int rawv6_getsockopt(struct sock *sk, int level, int optname,
break;
case SOL_ICMPV6:
- if (inet_sk(sk)->num != IPPROTO_ICMPV6)
+ if (inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
return -EOPNOTSUPP;
return rawv6_geticmpfilter(sk, level, optname, optval,
optlen);
@@ -1109,7 +1109,7 @@ static int compat_rawv6_getsockopt(struct sock *sk, int level, int optname,
case SOL_RAW:
break;
case SOL_ICMPV6:
- if (inet_sk(sk)->num != IPPROTO_ICMPV6)
+ if (inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
return -EOPNOTSUPP;
return rawv6_geticmpfilter(sk, level, optname, optval, optlen);
case SOL_IPV6:
@@ -1156,7 +1156,7 @@ static int rawv6_ioctl(struct sock *sk, int cmd, unsigned long arg)
static void rawv6_close(struct sock *sk, long timeout)
{
- if (inet_sk(sk)->num == IPPROTO_RAW)
+ if (inet_sk(sk)->inet_num == IPPROTO_RAW)
ip6_ra_control(sk, -1);
ip6mr_sk_done(sk);
sk_common_release(sk);
@@ -1175,7 +1175,7 @@ static int rawv6_init_sk(struct sock *sk)
{
struct raw6_sock *rp = raw6_sk(sk);
- switch (inet_sk(sk)->num) {
+ switch (inet_sk(sk)->inet_num) {
case IPPROTO_ICMPV6:
rp->checksum = 1;
rp->offset = 2;
@@ -1225,7 +1225,7 @@ static void raw6_sock_seq_show(struct seq_file *seq, struct sock *sp, int i)
dest = &np->daddr;
src = &np->rcv_saddr;
destp = 0;
- srcp = inet_sk(sp)->num;
+ srcp = inet_sk(sp)->inet_num;
seq_printf(seq,
"%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
"%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d\n",
diff --git a/net/ipv6/syncookies.c b/net/ipv6/syncookies.c
index cbe55e5..c46da53 100644
--- a/net/ipv6/syncookies.c
+++ b/net/ipv6/syncookies.c
@@ -254,7 +254,7 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb)
fl.oif = sk->sk_bound_dev_if;
fl.mark = sk->sk_mark;
fl.fl_ip_dport = inet_rsk(req)->rmt_port;
- fl.fl_ip_sport = inet_sk(sk)->sport;
+ fl.fl_ip_sport = inet_sk(sk)->inet_sport;
security_req_classify_flow(req, &fl);
if (ip6_dst_lookup(sk, &dst, &fl))
goto out_free;
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 4517630..c54ec36 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -226,8 +226,9 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
#endif
goto failure;
} else {
- ipv6_addr_set_v4mapped(inet->saddr, &np->saddr);
- ipv6_addr_set_v4mapped(inet->rcv_saddr, &np->rcv_saddr);
+ ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
+ ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
+ &np->rcv_saddr);
}
return err;
@@ -243,7 +244,7 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
fl.oif = sk->sk_bound_dev_if;
fl.mark = sk->sk_mark;
fl.fl_ip_dport = usin->sin6_port;
- fl.fl_ip_sport = inet->sport;
+ fl.fl_ip_sport = inet->inet_sport;
if (np->opt && np->opt->srcrt) {
struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
@@ -275,7 +276,7 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
/* set the source address */
ipv6_addr_copy(&np->saddr, saddr);
- inet->rcv_saddr = LOOPBACK4_IPV6;
+ inet->inet_rcv_saddr = LOOPBACK4_IPV6;
sk->sk_gso_type = SKB_GSO_TCPV6;
__ip6_dst_store(sk, dst, NULL, NULL);
@@ -287,7 +288,7 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
- inet->dport = usin->sin6_port;
+ inet->inet_dport = usin->sin6_port;
tcp_set_state(sk, TCP_SYN_SENT);
err = inet6_hash_connect(&tcp_death_row, sk);
@@ -297,8 +298,8 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
if (!tp->write_seq)
tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
np->daddr.s6_addr32,
- inet->sport,
- inet->dport);
+ inet->inet_sport,
+ inet->inet_dport);
err = tcp_connect(sk);
if (err)
@@ -310,7 +311,7 @@ late_failure:
tcp_set_state(sk, TCP_CLOSE);
__sk_dst_reset(sk);
failure:
- inet->dport = 0;
+ inet->inet_dport = 0;
sk->sk_route_caps = 0;
return err;
}
@@ -383,8 +384,8 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
ipv6_addr_copy(&fl.fl6_src, &np->saddr);
fl.oif = sk->sk_bound_dev_if;
fl.mark = sk->sk_mark;
- fl.fl_ip_dport = inet->dport;
- fl.fl_ip_sport = inet->sport;
+ fl.fl_ip_dport = inet->inet_dport;
+ fl.fl_ip_sport = inet->inet_sport;
security_skb_classify_flow(skb, &fl);
if ((err = ip6_dst_lookup(sk, &dst, &fl))) {
@@ -1291,9 +1292,9 @@ static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
memcpy(newnp, np, sizeof(struct ipv6_pinfo));
- ipv6_addr_set_v4mapped(newinet->daddr, &newnp->daddr);
+ ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);
- ipv6_addr_set_v4mapped(newinet->saddr, &newnp->saddr);
+ ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
@@ -1431,7 +1432,8 @@ static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
tcp_initialize_rcv_mss(newsk);
- newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
+ newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
+ newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
#ifdef CONFIG_TCP_MD5SIG
/* Copy over the MD5 key from the original socket */
@@ -1931,8 +1933,8 @@ static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
dest = &np->daddr;
src = &np->rcv_saddr;
- destp = ntohs(inet->dport);
- srcp = ntohs(inet->sport);
+ destp = ntohs(inet->inet_dport);
+ srcp = ntohs(inet->inet_sport);
if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
timer_active = 1;
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index b86425b..829d300 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -53,7 +53,7 @@ int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
{
const struct in6_addr *sk_rcv_saddr6 = &inet6_sk(sk)->rcv_saddr;
const struct in6_addr *sk2_rcv_saddr6 = inet6_rcv_saddr(sk2);
- __be32 sk_rcv_saddr = inet_sk(sk)->rcv_saddr;
+ __be32 sk1_rcv_saddr = inet_sk(sk)->inet_rcv_saddr;
__be32 sk2_rcv_saddr = inet_rcv_saddr(sk2);
int sk_ipv6only = ipv6_only_sock(sk);
int sk2_ipv6only = inet_v6_ipv6only(sk2);
@@ -63,8 +63,8 @@ int ipv6_rcv_saddr_equal(const struct sock *sk, const struct sock *sk2)
/* if both are mapped, treat as IPv4 */
if (addr_type == IPV6_ADDR_MAPPED && addr_type2 == IPV6_ADDR_MAPPED)
return (!sk2_ipv6only &&
- (!sk_rcv_saddr || !sk2_rcv_saddr ||
- sk_rcv_saddr == sk2_rcv_saddr));
+ (!sk1_rcv_saddr || !sk2_rcv_saddr ||
+ sk1_rcv_saddr == sk2_rcv_saddr));
if (addr_type2 == IPV6_ADDR_ANY &&
!(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED))
@@ -100,8 +100,8 @@ static inline int compute_score(struct sock *sk, struct net *net,
struct inet_sock *inet = inet_sk(sk);
score = 0;
- if (inet->dport) {
- if (inet->dport != sport)
+ if (inet->inet_dport) {
+ if (inet->inet_dport != sport)
return -1;
score++;
}
@@ -417,8 +417,8 @@ static struct sock *udp_v6_mcast_next(struct net *net, struct sock *sk,
if (s->sk_hash == num && s->sk_family == PF_INET6) {
struct ipv6_pinfo *np = inet6_sk(s);
- if (inet->dport) {
- if (inet->dport != rmt_port)
+ if (inet->inet_dport) {
+ if (inet->inet_dport != rmt_port)
continue;
}
if (!ipv6_addr_any(&np->daddr) &&
@@ -792,7 +792,7 @@ int udpv6_sendmsg(struct kiocb *iocb, struct sock *sk,
if (ipv6_addr_v4mapped(daddr)) {
struct sockaddr_in sin;
sin.sin_family = AF_INET;
- sin.sin_port = sin6 ? sin6->sin6_port : inet->dport;
+ sin.sin_port = sin6 ? sin6->sin6_port : inet->inet_dport;
sin.sin_addr.s_addr = daddr->s6_addr32[3];
msg->msg_name = &sin;
msg->msg_namelen = sizeof(sin);
@@ -865,7 +865,7 @@ do_udp_sendmsg:
if (sk->sk_state != TCP_ESTABLISHED)
return -EDESTADDRREQ;
- fl.fl_ip_dport = inet->dport;
+ fl.fl_ip_dport = inet->inet_dport;
daddr = &np->daddr;
fl.fl6_flowlabel = np->flow_label;
connected = 1;
@@ -911,7 +911,7 @@ do_udp_sendmsg:
fl.fl6_dst.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
if (ipv6_addr_any(&fl.fl6_src) && !ipv6_addr_any(&np->saddr))
ipv6_addr_copy(&fl.fl6_src, &np->saddr);
- fl.fl_ip_sport = inet->sport;
+ fl.fl_ip_sport = inet->inet_sport;
/* merge ip6_build_xmit from ip6_output */
if (opt && opt->srcrt) {
@@ -1192,8 +1192,8 @@ static void udp6_sock_seq_show(struct seq_file *seq, struct sock *sp, int bucket
dest = &np->daddr;
src = &np->rcv_saddr;
- destp = ntohs(inet->dport);
- srcp = ntohs(inet->sport);
+ destp = ntohs(inet->inet_dport);
+ srcp = ntohs(inet->inet_sport);
seq_printf(seq,
"%5d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
"%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d\n",
diff --git a/net/netfilter/xt_socket.c b/net/netfilter/xt_socket.c
index ebf00ad..362afbd 100644
--- a/net/netfilter/xt_socket.c
+++ b/net/netfilter/xt_socket.c
@@ -149,7 +149,7 @@ socket_match(const struct sk_buff *skb, const struct xt_match_param *par,
/* Ignore sockets listening on INADDR_ANY */
wildcard = (sk->sk_state != TCP_TIME_WAIT &&
- inet_sk(sk)->rcv_saddr == 0);
+ inet_sk(sk)->inet_rcv_saddr == 0);
/* Ignore non-transparent sockets,
if XT_SOCKET_TRANSPARENT is used */
diff --git a/net/rds/tcp_listen.c b/net/rds/tcp_listen.c
index 24b743e..45474a4 100644
--- a/net/rds/tcp_listen.c
+++ b/net/rds/tcp_listen.c
@@ -67,11 +67,11 @@ static int rds_tcp_accept_one(struct socket *sock)
inet = inet_sk(new_sock->sk);
rdsdebug("accepted tcp %u.%u.%u.%u:%u -> %u.%u.%u.%u:%u\n",
- NIPQUAD(inet->saddr), ntohs(inet->sport),
- NIPQUAD(inet->daddr), ntohs(inet->dport));
+ NIPQUAD(inet->inet_saddr), ntohs(inet->inet_sport),
+ NIPQUAD(inet->inet_daddr), ntohs(inet->inet_dport));
- conn = rds_conn_create(inet->saddr, inet->daddr, &rds_tcp_transport,
- GFP_KERNEL);
+ conn = rds_conn_create(inet->inet_saddr, inet->inet_daddr,
+ &rds_tcp_transport, GFP_KERNEL);
if (IS_ERR(conn)) {
ret = PTR_ERR(conn);
goto out;
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
index 612dc87..d9f4cc2 100644
--- a/net/sctp/protocol.c
+++ b/net/sctp/protocol.c
@@ -296,19 +296,19 @@ static void sctp_v4_from_sk(union sctp_addr *addr, struct sock *sk)
{
addr->v4.sin_family = AF_INET;
addr->v4.sin_port = 0;
- addr->v4.sin_addr.s_addr = inet_sk(sk)->rcv_saddr;
+ addr->v4.sin_addr.s_addr = inet_sk(sk)->inet_rcv_saddr;
}
/* Initialize sk->sk_rcv_saddr from sctp_addr. */
static void sctp_v4_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
{
- inet_sk(sk)->rcv_saddr = addr->v4.sin_addr.s_addr;
+ inet_sk(sk)->inet_rcv_saddr = addr->v4.sin_addr.s_addr;
}
/* Initialize sk->sk_daddr from sctp_addr. */
static void sctp_v4_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
{
- inet_sk(sk)->daddr = addr->v4.sin_addr.s_addr;
+ inet_sk(sk)->inet_daddr = addr->v4.sin_addr.s_addr;
}
/* Initialize a sctp_addr from an address parameter. */
@@ -598,7 +598,7 @@ static struct sock *sctp_v4_create_accept_sk(struct sock *sk,
newinet = inet_sk(newsk);
- newinet->daddr = asoc->peer.primary_addr.v4.sin_addr.s_addr;
+ newinet->inet_daddr = asoc->peer.primary_addr.v4.sin_addr.s_addr;
sk_refcnt_debug_inc(newsk);
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index 0970e92..4085db9 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -394,7 +394,7 @@ SCTP_STATIC int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len)
/* Refresh ephemeral port. */
if (!bp->port)
- bp->port = inet_sk(sk)->num;
+ bp->port = inet_sk(sk)->inet_num;
/* Add the address to the bind address list.
* Use GFP_ATOMIC since BHs will be disabled.
@@ -403,7 +403,7 @@ SCTP_STATIC int sctp_do_bind(struct sock *sk, union sctp_addr *addr, int len)
/* Copy back into socket for getsockname() use. */
if (!ret) {
- inet_sk(sk)->sport = htons(inet_sk(sk)->num);
+ inet_sk(sk)->inet_sport = htons(inet_sk(sk)->inet_num);
af->to_sk_saddr(addr, sk);
}
@@ -1115,7 +1115,7 @@ static int __sctp_connect(struct sock* sk,
}
/* Initialize sk's dport and daddr for getpeername() */
- inet_sk(sk)->dport = htons(asoc->peer.port);
+ inet_sk(sk)->inet_dport = htons(asoc->peer.port);
af = sctp_get_af_specific(sa_addr->sa.sa_family);
af->to_sk_daddr(sa_addr, sk);
sk->sk_err = 0;
@@ -5851,7 +5851,7 @@ pp_not_found:
*/
success:
if (!sctp_sk(sk)->bind_hash) {
- inet_sk(sk)->num = snum;
+ inet_sk(sk)->inet_num = snum;
sk_add_bind_node(sk, &pp->owner);
sctp_sk(sk)->bind_hash = pp;
}
@@ -5923,7 +5923,7 @@ SCTP_STATIC int sctp_listen_start(struct sock *sk, int backlog)
if (sctp_autobind(sk))
return -EAGAIN;
} else {
- if (sctp_get_port(sk, inet_sk(sk)->num)) {
+ if (sctp_get_port(sk, inet_sk(sk)->inet_num)) {
sk->sk_state = SCTP_SS_CLOSED;
return -EADDRINUSE;
}
@@ -6094,14 +6094,14 @@ static void sctp_bucket_destroy(struct sctp_bind_bucket *pp)
static inline void __sctp_put_port(struct sock *sk)
{
struct sctp_bind_hashbucket *head =
- &sctp_port_hashtable[sctp_phashfn(inet_sk(sk)->num)];
+ &sctp_port_hashtable[sctp_phashfn(inet_sk(sk)->inet_num)];
struct sctp_bind_bucket *pp;
sctp_spin_lock(&head->lock);
pp = sctp_sk(sk)->bind_hash;
__sk_del_bind_node(sk);
sctp_sk(sk)->bind_hash = NULL;
- inet_sk(sk)->num = 0;
+ inet_sk(sk)->inet_num = 0;
sctp_bucket_destroy(pp);
sctp_spin_unlock(&head->lock);
}
@@ -6128,7 +6128,7 @@ static int sctp_autobind(struct sock *sk)
/* Initialize a local sockaddr structure to INADDR_ANY. */
af = sctp_sk(sk)->pf->af;
- port = htons(inet_sk(sk)->num);
+ port = htons(inet_sk(sk)->inet_num);
af->inaddr_any(&autoaddr, port);
return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);
@@ -6697,12 +6697,12 @@ void sctp_copy_sock(struct sock *newsk, struct sock *sk,
/* Initialize sk's sport, dport, rcv_saddr and daddr for
* getsockname() and getpeername()
*/
- newinet->sport = inet->sport;
- newinet->saddr = inet->saddr;
- newinet->rcv_saddr = inet->rcv_saddr;
- newinet->dport = htons(asoc->peer.port);
+ newinet->inet_sport = inet->inet_sport;
+ newinet->inet_saddr = inet->inet_saddr;
+ newinet->inet_rcv_saddr = inet->inet_rcv_saddr;
+ newinet->inet_dport = htons(asoc->peer.port);
newinet->pmtudisc = inet->pmtudisc;
- newinet->id = asoc->next_tsn ^ jiffies;
+ newinet->inet_id = asoc->next_tsn ^ jiffies;
newinet->uc_ttl = inet->uc_ttl;
newinet->mc_loop = 1;
@@ -6741,13 +6741,13 @@ static void sctp_sock_migrate(struct sock *oldsk, struct sock *newsk,
newsp->hmac = NULL;
/* Hook this new socket in to the bind_hash list. */
- head = &sctp_port_hashtable[sctp_phashfn(inet_sk(oldsk)->num)];
+ head = &sctp_port_hashtable[sctp_phashfn(inet_sk(oldsk)->inet_num)];
sctp_local_bh_disable();
sctp_spin_lock(&head->lock);
pp = sctp_sk(oldsk)->bind_hash;
sk_add_bind_node(newsk, &pp->owner);
sctp_sk(newsk)->bind_hash = pp;
- inet_sk(newsk)->num = inet_sk(oldsk)->num;
+ inet_sk(newsk)->inet_num = inet_sk(oldsk)->inet_num;
sctp_spin_unlock(&head->lock);
sctp_local_bh_enable();
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index ccc5e83..c2a1787 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -272,14 +272,14 @@ static int svc_one_sock_name(struct svc_sock *svsk, char *buf, int remaining)
case PF_INET:
len = snprintf(buf, remaining, "ipv4 %s %pI4 %d\n",
proto_name,
- &inet_sk(sk)->rcv_saddr,
- inet_sk(sk)->num);
+ &inet_sk(sk)->inet_rcv_saddr,
+ inet_sk(sk)->inet_num);
break;
case PF_INET6:
len = snprintf(buf, remaining, "ipv6 %s %pI6 %d\n",
proto_name,
&inet6_sk(sk)->rcv_saddr,
- inet_sk(sk)->num);
+ inet_sk(sk)->inet_num);
break;
default:
len = snprintf(buf, remaining, "*unknown-%d*\n",
@@ -1311,7 +1311,7 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv,
/* Register socket with portmapper */
if (*errp >= 0 && pmap_register)
*errp = svc_register(serv, inet->sk_family, inet->sk_protocol,
- ntohs(inet_sk(inet)->sport));
+ ntohs(inet_sk(inet)->inet_sport));
if (*errp < 0) {
kfree(svsk);
diff --git a/security/lsm_audit.c b/security/lsm_audit.c
index 3bb90b6..e04566a 100644
--- a/security/lsm_audit.c
+++ b/security/lsm_audit.c
@@ -273,11 +273,11 @@ static void dump_common_audit_data(struct audit_buffer *ab,
case AF_INET: {
struct inet_sock *inet = inet_sk(sk);
- print_ipv4_addr(ab, inet->rcv_saddr,
- inet->sport,
+ print_ipv4_addr(ab, inet->inet_rcv_saddr,
+ inet->inet_sport,
"laddr", "lport");
- print_ipv4_addr(ab, inet->daddr,
- inet->dport,
+ print_ipv4_addr(ab, inet->inet_daddr,
+ inet->inet_dport,
"faddr", "fport");
break;
}
@@ -286,10 +286,10 @@ static void dump_common_audit_data(struct audit_buffer *ab,
struct ipv6_pinfo *inet6 = inet6_sk(sk);
print_ipv6_addr(ab, &inet6->rcv_saddr,
- inet->sport,
+ inet->inet_sport,
"laddr", "lport");
print_ipv6_addr(ab, &inet6->daddr,
- inet->dport,
+ inet->inet_dport,
"faddr", "fport");
break;
}
^ permalink raw reply related
* Re: [net-next-2.6 PATCH 1/4] TCPCT part 1: initial SYN exchange with SYNACK data
From: William Allen Simpson @ 2009-10-15 16:29 UTC (permalink / raw)
To: netdev
In-Reply-To: <4AD70B73.2040401@gmail.com>
William Allen Simpson wrote:
> #3 It's not possible to wrap and extend request_sock, as that is already
> done by IPv6 and others, causing a conflict. That was suggested by
> another maintainer, and I drafted some code last week, but wasn't able to
> figure out a non-conflicting code path.
>
After private discussion with others, I'm proposing a wrapper over a union
of those other header files, that would ensure new fields would be beyond
the previous extensions. It would have to be in its own .h file, and
would have the unfortunate side effect of hauling in other protocols, but
only into a very few net/ipv4/tcp*.c files.
The only advantage is that it doesn't matter how big this request_sock
will become, as it is thrown away immediately after use (just like stack
parameters in the previous proposal). Fourth time's the charm?
That is, something like:
#include <linux/ipv6.h>
#include <net/dccp/ipv6.h>
struct extend_request_sock {
union {
/* the biggest known */
struct tcp6_request_sock tcp6rsk;
struct dccp6_request_sock dccp6rsk;
} wrap;
u8 cookie_bakery[TCP_COOKIE_MAX];
u8 cookie_plus;
u8 cookie_in_always:1,
cookie_out_never:1;
}
^ permalink raw reply
* Re: [Patch] sctp: remove deprecated SCTP_GET_*_OLD stuffs
From: Vlad Yasevich @ 2009-10-15 16:30 UTC (permalink / raw)
To: Amerigo Wang; +Cc: linux-kernel, netdev, akpm
In-Reply-To: <20091015082849.4605.48311.sendpatchset@localhost.localdomain>
Amerigo Wang wrote:
> SCTP_GET_*_OLD stuffs are schedlued to be removed.
>
> Cc: Vlad Yasevich <vladislav.yasevich@hp.com>
> Signed-off-by: WANG Cong <amwang@redhat.com>
>
I guess 2.6.32 is as good a time as any for this. I'll
queue this to my tree.
Thanks
-vlad
>
> ---
> diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
> index 04e6c81..0b0eee5 100644
> --- a/Documentation/feature-removal-schedule.txt
> +++ b/Documentation/feature-removal-schedule.txt
> @@ -302,18 +302,6 @@ Who: ocfs2-devel@oss.oracle.com
>
> ---------------------------
>
> -What: SCTP_GET_PEER_ADDRS_NUM_OLD, SCTP_GET_PEER_ADDRS_OLD,
> - SCTP_GET_LOCAL_ADDRS_NUM_OLD, SCTP_GET_LOCAL_ADDRS_OLD
> -When: June 2009
> -Why: A newer version of the options have been introduced in 2005 that
> - removes the limitions of the old API. The sctp library has been
> - converted to use these new options at the same time. Any user
> - space app that directly uses the old options should convert to using
> - the new options.
> -Who: Vlad Yasevich <vladislav.yasevich@hp.com>
> -
> ----------------------------
> -
> What: Ability for non root users to shm_get hugetlb pages based on mlock
> resource limits
> When: 2.6.31
> diff --git a/include/net/sctp/user.h b/include/net/sctp/user.h
> index be2334a..0991f1b 100644
> --- a/include/net/sctp/user.h
> +++ b/include/net/sctp/user.h
> @@ -131,14 +131,6 @@ enum sctp_optname {
> #define SCTP_SOCKOPT_BINDX_REM SCTP_SOCKOPT_BINDX_REM
> SCTP_SOCKOPT_PEELOFF, /* peel off association. */
> #define SCTP_SOCKOPT_PEELOFF SCTP_SOCKOPT_PEELOFF
> - SCTP_GET_PEER_ADDRS_NUM_OLD, /* Get number of peer addresss. */
> -#define SCTP_GET_PEER_ADDRS_NUM_OLD SCTP_GET_PEER_ADDRS_NUM_OLD
> - SCTP_GET_PEER_ADDRS_OLD, /* Get all peer addresss. */
> -#define SCTP_GET_PEER_ADDRS_OLD SCTP_GET_PEER_ADDRS_OLD
> - SCTP_GET_LOCAL_ADDRS_NUM_OLD, /* Get number of local addresss. */
> -#define SCTP_GET_LOCAL_ADDRS_NUM_OLD SCTP_GET_LOCAL_ADDRS_NUM_OLD
> - SCTP_GET_LOCAL_ADDRS_OLD, /* Get all local addresss. */
> -#define SCTP_GET_LOCAL_ADDRS_OLD SCTP_GET_LOCAL_ADDRS_OLD
> SCTP_SOCKOPT_CONNECTX_OLD, /* CONNECTX old requests. */
> #define SCTP_SOCKOPT_CONNECTX_OLD SCTP_SOCKOPT_CONNECTX_OLD
> SCTP_GET_PEER_ADDRS, /* Get all peer addresss. */
> diff --git a/net/sctp/socket.c b/net/sctp/socket.c
> index c8d0575..1732a70 100644
> --- a/net/sctp/socket.c
> +++ b/net/sctp/socket.c
> @@ -4339,90 +4339,6 @@ static int sctp_getsockopt_initmsg(struct sock *sk, int len, char __user *optval
> return 0;
> }
>
> -static int sctp_getsockopt_peer_addrs_num_old(struct sock *sk, int len,
> - char __user *optval,
> - int __user *optlen)
> -{
> - sctp_assoc_t id;
> - struct sctp_association *asoc;
> - struct list_head *pos;
> - int cnt = 0;
> -
> - if (len < sizeof(sctp_assoc_t))
> - return -EINVAL;
> -
> - if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))
> - return -EFAULT;
> -
> - printk(KERN_WARNING "SCTP: Use of SCTP_GET_PEER_ADDRS_NUM_OLD "
> - "socket option deprecated\n");
> - /* For UDP-style sockets, id specifies the association to query. */
> - asoc = sctp_id2assoc(sk, id);
> - if (!asoc)
> - return -EINVAL;
> -
> - list_for_each(pos, &asoc->peer.transport_addr_list) {
> - cnt ++;
> - }
> -
> - return cnt;
> -}
> -
> -/*
> - * Old API for getting list of peer addresses. Does not work for 32-bit
> - * programs running on a 64-bit kernel
> - */
> -static int sctp_getsockopt_peer_addrs_old(struct sock *sk, int len,
> - char __user *optval,
> - int __user *optlen)
> -{
> - struct sctp_association *asoc;
> - int cnt = 0;
> - struct sctp_getaddrs_old getaddrs;
> - struct sctp_transport *from;
> - void __user *to;
> - union sctp_addr temp;
> - struct sctp_sock *sp = sctp_sk(sk);
> - int addrlen;
> -
> - if (len < sizeof(struct sctp_getaddrs_old))
> - return -EINVAL;
> -
> - len = sizeof(struct sctp_getaddrs_old);
> -
> - if (copy_from_user(&getaddrs, optval, len))
> - return -EFAULT;
> -
> - if (getaddrs.addr_num <= 0) return -EINVAL;
> -
> - printk(KERN_WARNING "SCTP: Use of SCTP_GET_PEER_ADDRS_OLD "
> - "socket option deprecated\n");
> -
> - /* For UDP-style sockets, id specifies the association to query. */
> - asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
> - if (!asoc)
> - return -EINVAL;
> -
> - to = (void __user *)getaddrs.addrs;
> - list_for_each_entry(from, &asoc->peer.transport_addr_list,
> - transports) {
> - memcpy(&temp, &from->ipaddr, sizeof(temp));
> - sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
> - addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len;
> - if (copy_to_user(to, &temp, addrlen))
> - return -EFAULT;
> - to += addrlen ;
> - cnt ++;
> - if (cnt >= getaddrs.addr_num) break;
> - }
> - getaddrs.addr_num = cnt;
> - if (put_user(len, optlen))
> - return -EFAULT;
> - if (copy_to_user(optval, &getaddrs, len))
> - return -EFAULT;
> -
> - return 0;
> -}
>
> static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
> char __user *optval, int __user *optlen)
> @@ -4475,81 +4391,6 @@ static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
> return 0;
> }
>
> -static int sctp_getsockopt_local_addrs_num_old(struct sock *sk, int len,
> - char __user *optval,
> - int __user *optlen)
> -{
> - sctp_assoc_t id;
> - struct sctp_bind_addr *bp;
> - struct sctp_association *asoc;
> - struct sctp_sockaddr_entry *addr;
> - int cnt = 0;
> -
> - if (len < sizeof(sctp_assoc_t))
> - return -EINVAL;
> -
> - if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))
> - return -EFAULT;
> -
> - printk(KERN_WARNING "SCTP: Use of SCTP_GET_LOCAL_ADDRS_NUM_OLD "
> - "socket option deprecated\n");
> -
> - /*
> - * For UDP-style sockets, id specifies the association to query.
> - * If the id field is set to the value '0' then the locally bound
> - * addresses are returned without regard to any particular
> - * association.
> - */
> - if (0 == id) {
> - bp = &sctp_sk(sk)->ep->base.bind_addr;
> - } else {
> - asoc = sctp_id2assoc(sk, id);
> - if (!asoc)
> - return -EINVAL;
> - bp = &asoc->base.bind_addr;
> - }
> -
> - /* If the endpoint is bound to 0.0.0.0 or ::0, count the valid
> - * addresses from the global local address list.
> - */
> - if (sctp_list_single_entry(&bp->address_list)) {
> - addr = list_entry(bp->address_list.next,
> - struct sctp_sockaddr_entry, list);
> - if (sctp_is_any(sk, &addr->a)) {
> - rcu_read_lock();
> - list_for_each_entry_rcu(addr,
> - &sctp_local_addr_list, list) {
> - if (!addr->valid)
> - continue;
> -
> - if ((PF_INET == sk->sk_family) &&
> - (AF_INET6 == addr->a.sa.sa_family))
> - continue;
> -
> - if ((PF_INET6 == sk->sk_family) &&
> - inet_v6_ipv6only(sk) &&
> - (AF_INET == addr->a.sa.sa_family))
> - continue;
> -
> - cnt++;
> - }
> - rcu_read_unlock();
> - } else {
> - cnt = 1;
> - }
> - goto done;
> - }
> -
> - /* Protection on the bound address list is not needed,
> - * since in the socket option context we hold the socket lock,
> - * so there is no way that the bound address list can change.
> - */
> - list_for_each_entry(addr, &bp->address_list, list) {
> - cnt ++;
> - }
> -done:
> - return cnt;
> -}
>
> /* Helper function that copies local addresses to user and returns the number
> * of addresses copied.
> @@ -4637,112 +4478,6 @@ static int sctp_copy_laddrs(struct sock *sk, __u16 port, void *to,
> return cnt;
> }
>
> -/* Old API for getting list of local addresses. Does not work for 32-bit
> - * programs running on a 64-bit kernel
> - */
> -static int sctp_getsockopt_local_addrs_old(struct sock *sk, int len,
> - char __user *optval, int __user *optlen)
> -{
> - struct sctp_bind_addr *bp;
> - struct sctp_association *asoc;
> - int cnt = 0;
> - struct sctp_getaddrs_old getaddrs;
> - struct sctp_sockaddr_entry *addr;
> - void __user *to;
> - union sctp_addr temp;
> - struct sctp_sock *sp = sctp_sk(sk);
> - int addrlen;
> - int err = 0;
> - void *addrs;
> - void *buf;
> - int bytes_copied = 0;
> -
> - if (len < sizeof(struct sctp_getaddrs_old))
> - return -EINVAL;
> -
> - len = sizeof(struct sctp_getaddrs_old);
> - if (copy_from_user(&getaddrs, optval, len))
> - return -EFAULT;
> -
> - if (getaddrs.addr_num <= 0 ||
> - getaddrs.addr_num >= (INT_MAX / sizeof(union sctp_addr)))
> - return -EINVAL;
> -
> - printk(KERN_WARNING "SCTP: Use of SCTP_GET_LOCAL_ADDRS_OLD "
> - "socket option deprecated\n");
> -
> - /*
> - * For UDP-style sockets, id specifies the association to query.
> - * If the id field is set to the value '0' then the locally bound
> - * addresses are returned without regard to any particular
> - * association.
> - */
> - if (0 == getaddrs.assoc_id) {
> - bp = &sctp_sk(sk)->ep->base.bind_addr;
> - } else {
> - asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
> - if (!asoc)
> - return -EINVAL;
> - bp = &asoc->base.bind_addr;
> - }
> -
> - to = getaddrs.addrs;
> -
> - /* Allocate space for a local instance of packed array to hold all
> - * the data. We store addresses here first and then put write them
> - * to the user in one shot.
> - */
> - addrs = kmalloc(sizeof(union sctp_addr) * getaddrs.addr_num,
> - GFP_KERNEL);
> - if (!addrs)
> - return -ENOMEM;
> -
> - /* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
> - * addresses from the global local address list.
> - */
> - if (sctp_list_single_entry(&bp->address_list)) {
> - addr = list_entry(bp->address_list.next,
> - struct sctp_sockaddr_entry, list);
> - if (sctp_is_any(sk, &addr->a)) {
> - cnt = sctp_copy_laddrs_old(sk, bp->port,
> - getaddrs.addr_num,
> - addrs, &bytes_copied);
> - goto copy_getaddrs;
> - }
> - }
> -
> - buf = addrs;
> - /* Protection on the bound address list is not needed since
> - * in the socket option context we hold a socket lock and
> - * thus the bound address list can't change.
> - */
> - list_for_each_entry(addr, &bp->address_list, list) {
> - memcpy(&temp, &addr->a, sizeof(temp));
> - sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
> - addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
> - memcpy(buf, &temp, addrlen);
> - buf += addrlen;
> - bytes_copied += addrlen;
> - cnt ++;
> - if (cnt >= getaddrs.addr_num) break;
> - }
> -
> -copy_getaddrs:
> - /* copy the entire address list into the user provided space */
> - if (copy_to_user(to, addrs, bytes_copied)) {
> - err = -EFAULT;
> - goto error;
> - }
> -
> - /* copy the leading structure back to user */
> - getaddrs.addr_num = cnt;
> - if (copy_to_user(optval, &getaddrs, len))
> - err = -EFAULT;
> -
> -error:
> - kfree(addrs);
> - return err;
> -}
>
> static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
> char __user *optval, int __user *optlen)
> @@ -5593,22 +5328,6 @@ SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
> case SCTP_INITMSG:
> retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
> break;
> - case SCTP_GET_PEER_ADDRS_NUM_OLD:
> - retval = sctp_getsockopt_peer_addrs_num_old(sk, len, optval,
> - optlen);
> - break;
> - case SCTP_GET_LOCAL_ADDRS_NUM_OLD:
> - retval = sctp_getsockopt_local_addrs_num_old(sk, len, optval,
> - optlen);
> - break;
> - case SCTP_GET_PEER_ADDRS_OLD:
> - retval = sctp_getsockopt_peer_addrs_old(sk, len, optval,
> - optlen);
> - break;
> - case SCTP_GET_LOCAL_ADDRS_OLD:
> - retval = sctp_getsockopt_local_addrs_old(sk, len, optval,
> - optlen);
> - break;
> case SCTP_GET_PEER_ADDRS:
> retval = sctp_getsockopt_peer_addrs(sk, len, optval,
> optlen);
>
^ permalink raw reply
* [PATCH] cosa: Kill off the use of the old ioctl path
From: Alan Cox @ 2009-10-14 15:22 UTC (permalink / raw)
To: netdev
Signed-off-by: Alan Cox <alan@linux.intel.com>
---
drivers/net/wan/cosa.c | 20 +++++++++++++-------
1 files changed, 13 insertions(+), 7 deletions(-)
diff --git a/drivers/net/wan/cosa.c b/drivers/net/wan/cosa.c
index e2c33c0..d888390 100644
--- a/drivers/net/wan/cosa.c
+++ b/drivers/net/wan/cosa.c
@@ -297,8 +297,8 @@ static ssize_t cosa_write(struct file *file,
static unsigned int cosa_poll(struct file *file, poll_table *poll);
static int cosa_open(struct inode *inode, struct file *file);
static int cosa_release(struct inode *inode, struct file *file);
-static int cosa_chardev_ioctl(struct inode *inode, struct file *file,
- unsigned int cmd, unsigned long arg);
+static long cosa_chardev_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg);
#ifdef COSA_FASYNC_WORKING
static int cosa_fasync(struct inode *inode, struct file *file, int on);
#endif
@@ -309,7 +309,7 @@ static const struct file_operations cosa_fops = {
.read = cosa_read,
.write = cosa_write,
.poll = cosa_poll,
- .ioctl = cosa_chardev_ioctl,
+ .unlocked_ioctl = cosa_chardev_ioctl,
.open = cosa_open,
.release = cosa_release,
#ifdef COSA_FASYNC_WORKING
@@ -1204,12 +1204,18 @@ static int cosa_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
return hdlc_ioctl(dev, ifr, cmd);
}
-static int cosa_chardev_ioctl(struct inode *inode, struct file *file,
- unsigned int cmd, unsigned long arg)
+static long cosa_chardev_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
{
struct channel_data *channel = file->private_data;
- struct cosa_data *cosa = channel->cosa;
- return cosa_ioctl_common(cosa, channel, cmd, arg);
+ struct cosa_data *cosa;
+ long ret;
+
+ lock_kernel();
+ cosa = channel->cosa;
+ ret = cosa_ioctl_common(cosa, channel, cmd, arg);
+ unlock_kernel();
+ return ret;
}
\f
^ permalink raw reply related
* [net-next-2.6 PATCH 3/4 resent] TCPCT part 1c: redefine TCP header functions *_len_th(), cleanup
From: William Allen Simpson @ 2009-10-15 15:07 UTC (permalink / raw)
To: Linux Kernel Network Developers
[-- Attachment #1: Type: text/plain, Size: 928 bytes --]
Redefine two TCP header functions to accept TCP header pointer.
When subtracting, return signed int to allow error checking.
In the only two existing files using the latter function, clean up
confusing and inconsistent mixing of both byte and word offsets.
However, remove proposed header length checking, and document the
assumptions instead. In the immortal words of the reviewer:
This is transmit, and the packets can only come from the Linux
TCP stack, not some external entity.
You're being way too anal here, and adding these checks to
drivers would be just a lot of rediculious bloat. [sic]
These functions will also be used in subsequent patches that implement
additional features.
---
drivers/net/bnx2.c | 22 +++++++++++++---------
drivers/net/tg3.c | 32 +++++++++++++++++---------------
include/linux/tcp.h | 10 ++++++++--
3 files changed, 38 insertions(+), 26 deletions(-)
[-- Attachment #2: TCPCT+1-3.patch --]
[-- Type: text/plain, Size: 4445 bytes --]
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 08cddb6..2cb342c 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -6330,18 +6330,17 @@ bnx2_start_xmit(struct sk_buff *skb, struct net_device *dev)
}
#endif
if ((mss = skb_shinfo(skb)->gso_size)) {
- u32 tcp_opt_len;
- struct iphdr *iph;
+ struct tcphdr *th = tcp_hdr(skb);
+ int tcp_opt_words = th->doff - (sizeof(*th) >> 2);
+ /* assumes positive tcp_opt_words without checking */
vlan_tag_flags |= TX_BD_FLAGS_SW_LSO;
- tcp_opt_len = tcp_optlen(skb);
-
if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6) {
u32 tcp_off = skb_transport_offset(skb) -
sizeof(struct ipv6hdr) - ETH_HLEN;
- vlan_tag_flags |= ((tcp_opt_len >> 2) << 8) |
+ vlan_tag_flags |= (tcp_opt_words << 8) |
TX_BD_FLAGS_SW_FLAGS;
if (likely(tcp_off == 0))
vlan_tag_flags &= ~TX_BD_FLAGS_TCP6_OFF0_MSK;
@@ -6354,10 +6353,15 @@ bnx2_start_xmit(struct sk_buff *skb, struct net_device *dev)
mss |= (tcp_off & 0xc) << TX_BD_TCP6_OFF2_SHL;
}
} else {
- iph = ip_hdr(skb);
- if (tcp_opt_len || (iph->ihl > 5)) {
- vlan_tag_flags |= ((iph->ihl - 5) +
- (tcp_opt_len >> 2)) << 8;
+ struct iphdr *iph = ip_hdr(skb);
+ int ip_opt_words = iph->ihl - (sizeof(*iph) >> 2);
+ int opt_words;
+
+ /* assumes positive ip_opt_words without checking */
+ opt_words = ip_opt_words + tcp_opt_words;
+
+ if (opt_words > 0) {
+ vlan_tag_flags |= opt_words << 8;
}
}
} else
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index ba5d3fe..7e89e2a 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -5230,7 +5230,8 @@ static netdev_tx_t tg3_start_xmit(struct sk_buff *skb,
else {
struct iphdr *iph = ip_hdr(skb);
- tcp_opt_len = tcp_optlen(skb);
+ tcp_opt_len = tcp_option_len_th(tcp_hdr(skb));
+ /* assumes positive tcp_opt_len without checking */
ip_tcp_len = ip_hdrlen(skb) + sizeof(struct tcphdr);
iph->check = 0;
@@ -5392,7 +5393,8 @@ static netdev_tx_t tg3_start_xmit_dma_bug(struct sk_buff *skb,
mss = 0;
if ((mss = skb_shinfo(skb)->gso_size) != 0) {
struct iphdr *iph;
- int tcp_opt_len, ip_tcp_len, hdr_len;
+ int tcp_opt_len, ip_hdr_len, ip_opt_len, ip_tcp_len, hdr_len;
+ int opt_bytes;
if (skb_header_cloned(skb) &&
pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
@@ -5400,10 +5402,12 @@ static netdev_tx_t tg3_start_xmit_dma_bug(struct sk_buff *skb,
goto out_unlock;
}
- tcp_opt_len = tcp_optlen(skb);
- ip_tcp_len = ip_hdrlen(skb) + sizeof(struct tcphdr);
-
+ tcp_opt_len = tcp_option_len_th(tcp_hdr(skb));
+ /* assumes positive tcp_opt_len without checking */
+ ip_hdr_len = ip_hdrlen(skb);
+ ip_tcp_len = ip_hdr_len + sizeof(struct tcphdr);
hdr_len = ip_tcp_len + tcp_opt_len;
+
if (unlikely((ETH_HLEN + hdr_len) > 80) &&
(tp->tg3_flags2 & TG3_FLG2_TSO_BUG))
return (tg3_tso_bug(tp, skb));
@@ -5423,20 +5427,18 @@ static netdev_tx_t tg3_start_xmit_dma_bug(struct sk_buff *skb,
IPPROTO_TCP,
0);
+ ip_opt_len = ip_hdr_len - sizeof(struct iphdr);
+ /* assumes positive ip_opt_len without checking */
+ opt_bytes = ip_opt_len + tcp_opt_len;
+
if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO) ||
(GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705)) {
- if (tcp_opt_len || iph->ihl > 5) {
- int tsflags;
-
- tsflags = (iph->ihl - 5) + (tcp_opt_len >> 2);
- mss |= (tsflags << 11);
+ if (opt_bytes > 0) {
+ mss |= (opt_bytes >> 2) << 11;
}
} else {
- if (tcp_opt_len || iph->ihl > 5) {
- int tsflags;
-
- tsflags = (iph->ihl - 5) + (tcp_opt_len >> 2);
- base_flags |= tsflags << 12;
+ if (opt_bytes > 0) {
+ base_flags |= (opt_bytes >> 2) << 12;
}
}
}
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 63ab660..d304ba5 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -217,9 +217,15 @@ static inline unsigned int tcp_hdrlen(const struct sk_buff *skb)
return tcp_hdr(skb)->doff * 4;
}
-static inline unsigned int tcp_optlen(const struct sk_buff *skb)
+static inline unsigned int tcp_header_len_th(const struct tcphdr *th)
{
- return (tcp_hdr(skb)->doff - 5) * 4;
+ return th->doff * 4;
+}
+
+/* When doff is bad, this could be negative. */
+static inline int tcp_option_len_th(const struct tcphdr *th)
+{
+ return (int)tcp_header_len_th(th) - sizeof(*th);
}
/* This defines a selective acknowledgement block. */
--
1.6.0.4
^ permalink raw reply related
* [PATCH v0 7/7] gianfar: Basic Support for programming hash rules
From: Sandeep Gopalpet @ 2009-10-15 16:31 UTC (permalink / raw)
To: netdev; +Cc: Sandeep Gopalpet
This patch provides basic hash rules programming via the ethtool
interface.
Signed-off-by: Sandeep Gopalpet <sandeep.kumar@freescale.com>
---
drivers/net/gianfar.c | 73 +++++++++++++
drivers/net/gianfar.h | 93 ++++++++++++++++
drivers/net/gianfar_ethtool.c | 236 +++++++++++++++++++++++++++++++++++++++++
include/linux/ethtool.h | 2 +
4 files changed, 404 insertions(+), 0 deletions(-)
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 4ea85f1..d4ccc42 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -166,6 +166,9 @@ static const struct net_device_ops gfar_netdev_ops = {
#endif
};
+unsigned int ftp_rqfpr[MAX_FILER_IDX + 1];
+unsigned int ftp_rqfcr[MAX_FILER_IDX + 1];
+
inline void lock_rx_qs(struct gfar_private *priv)
{
int i = 0x0;
@@ -501,6 +504,73 @@ static unsigned int reverse_bitmap(unsigned int bit_map, unsigned int max_qs)
}
return new_bit_map;
}
+
+u32 cluster_entry_per_class(struct gfar_private *priv, u32 rqfar, u32 class)
+{
+ u32 rqfpr = FPR_FILER_MASK;
+ u32 rqfcr = 0x0;
+
+ rqfar--;
+ rqfcr = RQFCR_CLE | RQFCR_PID_MASK | RQFCR_CMP_EXACT;
+ ftp_rqfpr[rqfar] = rqfpr;
+ ftp_rqfcr[rqfar] = rqfcr;
+ gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
+
+ rqfar--;
+ rqfcr = RQFCR_CMP_NOMATCH;
+ ftp_rqfpr[rqfar] = rqfpr;
+ ftp_rqfcr[rqfar] = rqfcr;
+ gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
+
+ rqfar--;
+ rqfcr = RQFCR_CMP_EXACT | RQFCR_PID_PARSE | RQFCR_CLE | RQFCR_AND;
+ rqfpr = class;
+ ftp_rqfcr[rqfar] = rqfcr;
+ ftp_rqfpr[rqfar] = rqfpr;
+ gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
+
+ rqfar--;
+ rqfcr = RQFCR_CMP_EXACT | RQFCR_PID_MASK | RQFCR_AND;
+ rqfpr = class;
+ ftp_rqfcr[rqfar] = rqfcr;
+ ftp_rqfpr[rqfar] = rqfpr;
+ gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
+
+ return rqfar;
+}
+
+static void gfar_init_filer_table(struct gfar_private *priv)
+{
+ int i = 0x0;
+ u32 rqfar = MAX_FILER_IDX;
+ u32 rqfcr = 0x0;
+ u32 rqfpr = FPR_FILER_MASK;
+
+ /* Default rule */
+ rqfcr = RQFCR_CMP_MATCH;
+ ftp_rqfcr[rqfar] = rqfcr;
+ ftp_rqfpr[rqfar] = rqfpr;
+ gfar_write_filer(priv, rqfar, rqfcr, rqfpr);
+
+ rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV6);
+ rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV6 | RQFPR_UDP);
+ rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV6 | RQFPR_TCP);
+ rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV4);
+ rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV4 | RQFPR_UDP);
+ rqfar = cluster_entry_per_class(priv, rqfar, RQFPR_IPV4 | RQFPR_TCP);
+
+ /* cur_filer_idx indicated the fisrt non-masked rule */
+ priv->cur_filer_idx = rqfar;
+
+ /* Rest are masked rules */
+ rqfcr = RQFCR_CMP_NOMATCH;
+ for (i = 0; i < rqfar; i++) {
+ ftp_rqfcr[i] = rqfcr;
+ ftp_rqfpr[i] = rqfpr;
+ gfar_write_filer(priv, i, rqfcr, rqfpr);
+ }
+}
+
/* Set up the ethernet device structure, private data,
* and anything else we need before we start */
static int gfar_probe(struct of_device *ofdev,
@@ -740,6 +810,9 @@ static int gfar_probe(struct of_device *ofdev,
priv->gfargrp[i].int_name_tx[len_devname] = '\0';
}
+ /* Initialize the filer table */
+ gfar_init_filer_table(priv);
+
/* Create all the sysfs files */
gfar_init_sysfs(dev);
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index feba4d7..c669b2d 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -381,6 +381,84 @@ extern const char gfar_driver_version[];
#define BD_LFLAG(flags) ((flags) << 16)
#define BD_LENGTH_MASK 0x0000ffff
+#define CLASS_CODE_UNRECOG 0x00
+#define CLASS_CODE_DUMMY1 0x01
+#define CLASS_CODE_ETHERTYPE1 0x02
+#define CLASS_CODE_ETHERTYPE2 0x03
+#define CLASS_CODE_USER_PROG1 0x04
+#define CLASS_CODE_USER_PROG2 0x05
+#define CLASS_CODE_USER_PROG3 0x06
+#define CLASS_CODE_USER_PROG4 0x07
+#define CLASS_CODE_TCP_IPV4 0x08
+#define CLASS_CODE_UDP_IPV4 0x09
+#define CLASS_CODE_AH_ESP_IPV4 0x0a
+#define CLASS_CODE_SCTP_IPV4 0x0b
+#define CLASS_CODE_TCP_IPV6 0x0c
+#define CLASS_CODE_UDP_IPV6 0x0d
+#define CLASS_CODE_AH_ESP_IPV6 0x0e
+#define CLASS_CODE_SCTP_IPV6 0x0f
+
+#define FPR_FILER_MASK 0xFFFFFFFF
+#define MAX_FILER_IDX 0xFF
+
+/* RQFCR register bits */
+#define RQFCR_GPI 0x80000000
+#define RQFCR_HASHTBL_Q 0x00000000
+#define RQFCR_HASHTBL_0 0x00020000
+#define RQFCR_HASHTBL_1 0x00040000
+#define RQFCR_HASHTBL_2 0x00060000
+#define RQFCR_HASHTBL_3 0x00080000
+#define RQFCR_HASH 0x00010000
+#define RQFCR_CLE 0x00000200
+#define RQFCR_RJE 0x00000100
+#define RQFCR_AND 0x00000080
+#define RQFCR_CMP_EXACT 0x00000000
+#define RQFCR_CMP_MATCH 0x00000020
+#define RQFCR_CMP_NOEXACT 0x00000040
+#define RQFCR_CMP_NOMATCH 0x00000060
+
+/* RQFCR PID values */
+#define RQFCR_PID_MASK 0x00000000
+#define RQFCR_PID_PARSE 0x00000001
+#define RQFCR_PID_ARB 0x00000002
+#define RQFCR_PID_DAH 0x00000003
+#define RQFCR_PID_DAL 0x00000004
+#define RQFCR_PID_SAH 0x00000005
+#define RQFCR_PID_SAL 0x00000006
+#define RQFCR_PID_ETY 0x00000007
+#define RQFCR_PID_VID 0x00000008
+#define RQFCR_PID_PRI 0x00000009
+#define RQFCR_PID_TOS 0x0000000A
+#define RQFCR_PID_L4P 0x0000000B
+#define RQFCR_PID_DIA 0x0000000C
+#define RQFCR_PID_SIA 0x0000000D
+#define RQFCR_PID_DPT 0x0000000E
+#define RQFCR_PID_SPT 0x0000000F
+
+/* RQFPR when PID is 0x0001 */
+#define RQFPR_HDR_GE_512 0x00200000
+#define RQFPR_LERR 0x00100000
+#define RQFPR_RAR 0x00080000
+#define RQFPR_RARQ 0x00040000
+#define RQFPR_AR 0x00020000
+#define RQFPR_ARQ 0x00010000
+#define RQFPR_EBC 0x00008000
+#define RQFPR_VLN 0x00004000
+#define RQFPR_CFI 0x00002000
+#define RQFPR_JUM 0x00001000
+#define RQFPR_IPF 0x00000800
+#define RQFPR_FIF 0x00000400
+#define RQFPR_IPV4 0x00000200
+#define RQFPR_IPV6 0x00000100
+#define RQFPR_ICC 0x00000080
+#define RQFPR_ICV 0x00000040
+#define RQFPR_TCP 0x00000020
+#define RQFPR_UDP 0x00000010
+#define RQFPR_TUC 0x00000008
+#define RQFPR_TUV 0x00000004
+#define RQFPR_PER 0x00000002
+#define RQFPR_EER 0x00000001
+
/* TxBD status field bits */
#define TXBD_READY 0x8000
#define TXBD_PADCRC 0x4000
@@ -957,6 +1035,8 @@ struct gfar_private {
unsigned int rx_stash_size;
unsigned int rx_stash_index;
+ u32 cur_filer_idx;
+
struct sk_buff_head rx_recycle;
struct vlan_group *vlgrp;
@@ -1000,6 +1080,9 @@ struct gfar_private {
struct gfar_extra_stats extra_stats;
};
+extern unsigned int ftp_rqfpr[MAX_FILER_IDX + 1];
+extern unsigned int ftp_rqfcr[MAX_FILER_IDX + 1];
+
static inline u32 gfar_read(volatile unsigned __iomem *addr)
{
u32 val;
@@ -1012,6 +1095,16 @@ static inline void gfar_write(volatile unsigned __iomem *addr, u32 val)
out_be32(addr, val);
}
+static inline void gfar_write_filer(struct gfar_private *priv,
+ unsigned int far, unsigned int fcr, unsigned int fpr)
+{
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
+
+ gfar_write(®s->rqfar, far);
+ gfar_write(®s->rqfcr, fcr);
+ gfar_write(®s->rqfpr, fpr);
+}
+
extern inline void lock_rx_qs(struct gfar_private *priv);
extern inline void lock_tx_qs(struct gfar_private *priv);
extern inline void unlock_rx_qs(struct gfar_private *priv);
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index 562f6c2..1010367 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -645,6 +645,241 @@ static int gfar_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
}
#endif
+static int gfar_ethflow_to_class(int flow_type, u64 *class)
+{
+ switch (flow_type) {
+ case TCP_V4_FLOW:
+ *class = CLASS_CODE_TCP_IPV4;
+ break;
+ case UDP_V4_FLOW:
+ *class = CLASS_CODE_UDP_IPV4;
+ break;
+ case AH_V4_FLOW:
+ case ESP_V4_FLOW:
+ *class = CLASS_CODE_AH_ESP_IPV4;
+ break;
+ case SCTP_V4_FLOW:
+ *class = CLASS_CODE_SCTP_IPV4;
+ break;
+ case TCP_V6_FLOW:
+ *class = CLASS_CODE_TCP_IPV6;
+ break;
+ case UDP_V6_FLOW:
+ *class = CLASS_CODE_UDP_IPV6;
+ break;
+ case AH_V6_FLOW:
+ case ESP_V6_FLOW:
+ *class = CLASS_CODE_AH_ESP_IPV6;
+ break;
+ case SCTP_V6_FLOW:
+ *class = CLASS_CODE_SCTP_IPV6;
+ break;
+ default:
+ return 0;
+ }
+
+ return 1;
+}
+
+static void ethflow_to_filer_rules (struct gfar_private *priv, u64 ethflow)
+{
+ u32 fcr = 0x0, fpr = FPR_FILER_MASK;
+
+ if (ethflow & RXH_L2DA) {
+ fcr = RQFCR_PID_DAH |RQFCR_CMP_NOMATCH |
+ RQFCR_HASH | RQFCR_AND | RQFCR_HASHTBL_0;
+ ftp_rqfpr[priv->cur_filer_idx] = fpr;
+ ftp_rqfcr[priv->cur_filer_idx] = fcr;
+ gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
+ priv->cur_filer_idx = priv->cur_filer_idx - 1;
+
+ fcr = RQFCR_PID_DAL | RQFCR_AND | RQFCR_CMP_NOMATCH |
+ RQFCR_HASH | RQFCR_AND | RQFCR_HASHTBL_0;
+ ftp_rqfpr[priv->cur_filer_idx] = fpr;
+ ftp_rqfcr[priv->cur_filer_idx] = fcr;
+ gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
+ priv->cur_filer_idx = priv->cur_filer_idx - 1;
+ }
+
+ if (ethflow & RXH_VLAN) {
+ fcr = RQFCR_PID_VID | RQFCR_CMP_NOMATCH | RQFCR_HASH |
+ RQFCR_AND | RQFCR_HASHTBL_0;
+ gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
+ ftp_rqfpr[priv->cur_filer_idx] = fpr;
+ ftp_rqfcr[priv->cur_filer_idx] = fcr;
+ priv->cur_filer_idx = priv->cur_filer_idx - 1;
+ }
+
+ if (ethflow & RXH_IP_SRC) {
+ fcr = RQFCR_PID_SIA | RQFCR_CMP_NOMATCH | RQFCR_HASH |
+ RQFCR_AND | RQFCR_HASHTBL_0;
+ ftp_rqfpr[priv->cur_filer_idx] = fpr;
+ ftp_rqfcr[priv->cur_filer_idx] = fcr;
+ gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
+ priv->cur_filer_idx = priv->cur_filer_idx - 1;
+ }
+
+ if (ethflow & (RXH_IP_DST)) {
+ fcr = RQFCR_PID_DIA | RQFCR_CMP_NOMATCH | RQFCR_HASH |
+ RQFCR_AND | RQFCR_HASHTBL_0;
+ ftp_rqfpr[priv->cur_filer_idx] = fpr;
+ ftp_rqfcr[priv->cur_filer_idx] = fcr;
+ gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
+ priv->cur_filer_idx = priv->cur_filer_idx - 1;
+ }
+
+ if (ethflow & RXH_L3_PROTO) {
+ fcr = RQFCR_PID_L4P | RQFCR_CMP_NOMATCH | RQFCR_HASH |
+ RQFCR_AND | RQFCR_HASHTBL_0;
+ ftp_rqfpr[priv->cur_filer_idx] = fpr;
+ ftp_rqfcr[priv->cur_filer_idx] = fcr;
+ gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
+ priv->cur_filer_idx = priv->cur_filer_idx - 1;
+ }
+
+ if (ethflow & RXH_L4_B_0_1) {
+ fcr = RQFCR_PID_SPT | RQFCR_CMP_NOMATCH | RQFCR_HASH |
+ RQFCR_AND | RQFCR_HASHTBL_0;
+ ftp_rqfpr[priv->cur_filer_idx] = fpr;
+ ftp_rqfcr[priv->cur_filer_idx] = fcr;
+ gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
+ priv->cur_filer_idx = priv->cur_filer_idx - 1;
+ }
+
+ if (ethflow & RXH_L4_B_2_3) {
+ fcr = RQFCR_PID_DPT | RQFCR_CMP_NOMATCH | RQFCR_HASH |
+ RQFCR_AND | RQFCR_HASHTBL_0;
+ ftp_rqfpr[priv->cur_filer_idx] = fpr;
+ ftp_rqfcr[priv->cur_filer_idx] = fcr;
+ gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
+ priv->cur_filer_idx = priv->cur_filer_idx - 1;
+ }
+}
+
+static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u64 class)
+{
+ unsigned int last_rule_idx = priv->cur_filer_idx;
+ unsigned int cmp_rqfpr;
+ unsigned int local_rqfpr[MAX_FILER_IDX + 1];
+ unsigned int local_rqfcr[MAX_FILER_IDX + 1];
+ int i = 0x0, k = 0x0;
+ int j = MAX_FILER_IDX, l = 0x0;
+
+ switch (class) {
+ case TCP_V4_FLOW:
+ cmp_rqfpr = RQFPR_IPV4 |RQFPR_TCP;
+ break;
+ case UDP_V4_FLOW:
+ cmp_rqfpr = RQFPR_IPV4 |RQFPR_UDP;
+ break;
+ case TCP_V6_FLOW:
+ cmp_rqfpr = RQFPR_IPV6 |RQFPR_TCP;
+ break;
+ case UDP_V6_FLOW:
+ cmp_rqfpr = RQFPR_IPV6 |RQFPR_UDP;
+ break;
+ case IPV4_FLOW:
+ cmp_rqfpr = RQFPR_IPV4;
+ case IPV6_FLOW:
+ cmp_rqfpr = RQFPR_IPV6;
+ break;
+ default:
+ printk(KERN_ERR "Right now this class is not supported\n");
+ return 0;
+ }
+
+ for (i = 0; i < MAX_FILER_IDX + 1; i++) {
+ local_rqfpr[j] = ftp_rqfpr[i];
+ local_rqfcr[j] = ftp_rqfcr[i];
+ j--;
+ if ((ftp_rqfcr[i] == (RQFCR_PID_PARSE |
+ RQFCR_CLE |RQFCR_AND)) &&
+ (ftp_rqfpr[i] == cmp_rqfpr))
+ break;
+ }
+
+ if (i == MAX_FILER_IDX + 1) {
+ printk(KERN_ERR "No parse rule found, ");
+ printk(KERN_ERR "can't create hash rules\n");
+ return 0;
+ }
+
+ /* If a match was found, then it begins the starting of a cluster rule
+ * if it was already programmed, we need to overwrite these rules
+ */
+ for (l = i+1; l < MAX_FILER_IDX; l++) {
+ if ((ftp_rqfcr[l] & RQFCR_CLE) &&
+ !(ftp_rqfcr[l] & RQFCR_AND)) {
+ ftp_rqfcr[l] = RQFCR_CLE | RQFCR_CMP_EXACT |
+ RQFCR_HASHTBL_0 | RQFCR_PID_MASK;
+ ftp_rqfpr[l] = FPR_FILER_MASK;
+ gfar_write_filer(priv, l, ftp_rqfcr[l], ftp_rqfpr[l]);
+ break;
+ }
+
+ if (!(ftp_rqfcr[l] & RQFCR_CLE) && (ftp_rqfcr[l] & RQFCR_AND))
+ continue;
+ else {
+ local_rqfpr[j] = ftp_rqfpr[l];
+ local_rqfcr[j] = ftp_rqfcr[l];
+ j--;
+ }
+ }
+
+ priv->cur_filer_idx = l - 1;
+ last_rule_idx = l;
+
+ /* hash rules */
+ ethflow_to_filer_rules(priv, ethflow);
+
+ /* Write back the popped out rules again */
+ for (k = j+1; k < MAX_FILER_IDX; k++) {
+ ftp_rqfpr[priv->cur_filer_idx] = local_rqfpr[k];
+ ftp_rqfcr[priv->cur_filer_idx] = local_rqfcr[k];
+ gfar_write_filer(priv, priv->cur_filer_idx,
+ local_rqfcr[k], local_rqfpr[k]);
+ if (!priv->cur_filer_idx)
+ break;
+ priv->cur_filer_idx = priv->cur_filer_idx - 1;
+ }
+
+ return 1;
+}
+
+static int gfar_set_hash_opts(struct gfar_private *priv, struct ethtool_rxnfc *cmd)
+{
+ u64 class;
+
+ if (!gfar_ethflow_to_class(cmd->flow_type, &class))
+ return -EINVAL;
+
+ if (class < CLASS_CODE_USER_PROG1 ||
+ class > CLASS_CODE_SCTP_IPV6)
+ return -EINVAL;
+
+ /* write the filer rules here */
+ if (!gfar_ethflow_to_filer_table(priv, cmd->data, cmd->flow_type))
+ return -1;
+
+ return 0;
+}
+
+static int gfar_set_nfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
+{
+ struct gfar_private *priv = netdev_priv(dev);
+ int ret = 0;
+
+ switch(cmd->cmd) {
+ case ETHTOOL_SRXFH:
+ ret = gfar_set_hash_opts(priv, cmd);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+
+ return ret;
+}
+
const struct ethtool_ops gfar_ethtool_ops = {
.get_settings = gfar_gsettings,
.set_settings = gfar_ssettings,
@@ -670,4 +905,5 @@ const struct ethtool_ops gfar_ethtool_ops = {
.get_wol = gfar_get_wol,
.set_wol = gfar_set_wol,
#endif
+ .set_rxnfc = gfar_set_nfc,
};
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index 15e4eb7..a476321 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -676,6 +676,8 @@ struct ethtool_ops {
#define AH_V6_FLOW 0x0b
#define ESP_V6_FLOW 0x0c
#define IP_USER_FLOW 0x0d
+#define IPV4_FLOW 0x10
+#define IPV6_FLOW 0x11
/* L3-L4 network traffic flow hash options */
#define RXH_L2DA (1 << 1)
--
1.5.2.2
^ permalink raw reply related
* [PATCH v0 6/7] gianfar: Add Multiple group Support
From: Sandeep Gopalpet @ 2009-10-15 16:31 UTC (permalink / raw)
To: netdev; +Cc: Sandeep Gopalpet
This patch introduces multiple group support for etsec2.0
devices.
Multiple group support is provided by mapping the set of enabled
queues to different groups and then programming the per group
regsiters imask, ievent, rstat, tstat.
The queues corresponding to a group are indicated by programming
isrg (interrupt steering) registers.
Signed-off-by: Sandeep Gopalpet <sandeep.kumar@freescale.com>
---
drivers/net/gianfar.c | 548 +++++++++++++++++++++++++++--------------
drivers/net/gianfar.h | 29 ++-
drivers/net/gianfar_ethtool.c | 58 +++--
drivers/net/gianfar_sysfs.c | 12 +-
4 files changed, 429 insertions(+), 218 deletions(-)
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index bb5dd08..4ea85f1 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -224,16 +224,91 @@ static void free_rx_pointers(struct gfar_private *priv)
kfree(priv->rx_queue[i]);
}
+static void unmap_group_regs(struct gfar_private *priv)
+{
+ int i = 0;
+
+ for (i = 0; i < MAXGROUPS; i++)
+ if (priv->gfargrp[i].regs)
+ iounmap(priv->gfargrp[i].regs);
+}
+
+static void disable_napi(struct gfar_private *priv)
+{
+ int i = 0;
+
+ for (i = 0; i < priv->num_grps; i++)
+ napi_disable(&priv->gfargrp[i].napi);
+}
+
+static void enable_napi(struct gfar_private *priv)
+{
+ int i = 0;
+
+ for (i = 0; i < priv->num_grps; i++)
+ napi_enable(&priv->gfargrp[i].napi);
+}
+
+static int gfar_parse_group(struct device_node *np,
+ struct gfar_private *priv, const char *model)
+{
+ u32 *queue_mask;
+ u64 addr, size;
+
+ addr = of_translate_address(np,
+ of_get_address(np, 0, &size, NULL));
+ priv->gfargrp[priv->num_grps].regs = ioremap(addr, size);
+
+ if (!priv->gfargrp[priv->num_grps].regs)
+ return -ENOMEM;
+
+ priv->gfargrp[priv->num_grps].interruptTransmit =
+ irq_of_parse_and_map(np, 0);
+
+ /* If we aren't the FEC we have multiple interrupts */
+ if (model && strcasecmp(model, "FEC")) {
+ priv->gfargrp[priv->num_grps].interruptReceive =
+ irq_of_parse_and_map(np, 1);
+ priv->gfargrp[priv->num_grps].interruptError =
+ irq_of_parse_and_map(np,2);
+ if (priv->gfargrp[priv->num_grps].interruptTransmit < 0 ||
+ priv->gfargrp[priv->num_grps].interruptReceive < 0 ||
+ priv->gfargrp[priv->num_grps].interruptError < 0) {
+ return -EINVAL;
+ }
+ }
+
+ priv->gfargrp[priv->num_grps].grp_id = priv->num_grps;
+ priv->gfargrp[priv->num_grps].priv = priv;
+ spin_lock_init(&priv->gfargrp[priv->num_grps].grplock);
+ if(priv->mode == MQ_MG_MODE) {
+ queue_mask = (u32 *)of_get_property(np,
+ "fsl,rx-bit-map", NULL);
+ priv->gfargrp[priv->num_grps].rx_bit_map =
+ queue_mask ? *queue_mask :(DEFAULT_MAPPING >> priv->num_grps);
+ queue_mask = (u32 *)of_get_property(np,
+ "fsl,tx-bit-map", NULL);
+ priv->gfargrp[priv->num_grps].tx_bit_map =
+ queue_mask ? *queue_mask : (DEFAULT_MAPPING >> priv->num_grps);
+ } else {
+ priv->gfargrp[priv->num_grps].rx_bit_map = 0xFF;
+ priv->gfargrp[priv->num_grps].tx_bit_map = 0xFF;
+ }
+ priv->num_grps++;
+
+ return 0;
+}
+
static int gfar_of_init(struct of_device *ofdev, struct net_device **pdev)
{
const char *model;
const char *ctype;
const void *mac_addr;
- u64 addr, size;
int err = 0, i;
struct net_device *dev = NULL;
struct gfar_private *priv = NULL;
struct device_node *np = ofdev->node;
+ struct device_node *child = NULL;
const u32 *stash;
const u32 *stash_len;
const u32 *stash_idx;
@@ -277,36 +352,26 @@ static int gfar_of_init(struct of_device *ofdev, struct net_device **pdev)
dev->real_num_tx_queues = num_tx_qs;
priv->num_tx_queues = num_tx_qs;
priv->num_rx_queues = num_rx_qs;
-
- /* get a pointer to the register memory */
- addr = of_translate_address(np, of_get_address(np, 0, &size, NULL));
- priv->gfargrp.regs = ioremap(addr, size);
-
- if (priv->gfargrp.regs == NULL) {
- err = -ENOMEM;
- goto err_out;
- }
-
- priv->gfargrp.priv = priv; /* back pointer from group to priv */
- priv->gfargrp.rx_bit_map = DEFAULT_MAPPING;
- priv->gfargrp.tx_bit_map = DEFAULT_MAPPING;
-
- priv->gfargrp.interruptTransmit = irq_of_parse_and_map(np, 0);
+ priv->num_grps = 0x0;
model = of_get_property(np, "model", NULL);
- /* If we aren't the FEC we have multiple interrupts */
- if (model && strcasecmp(model, "FEC")) {
- priv->gfargrp.interruptReceive = irq_of_parse_and_map(np, 1);
-
- priv->gfargrp.interruptError = irq_of_parse_and_map(np, 2);
+ for (i = 0; i < MAXGROUPS; i++)
+ priv->gfargrp[i].regs = NULL;
- if (priv->gfargrp.interruptTransmit < 0 ||
- priv->gfargrp.interruptReceive < 0 ||
- priv->gfargrp.interruptError < 0) {
- err = -EINVAL;
- goto err_out;
+ /* Parse and initialize group specific information */
+ if (of_device_is_compatible(np, "fsl,etsec2")) {
+ priv->mode = MQ_MG_MODE;
+ for_each_child_of_node(np, child) {
+ err = gfar_parse_group(child, priv, model);
+ if (err)
+ goto err_grp_init;
}
+ } else {
+ priv->mode = SQ_SG_MODE;
+ err = gfar_parse_group(np, priv, model);
+ if(err)
+ goto err_grp_init;
}
for (i = 0; i < priv->num_tx_queues; i++)
@@ -405,8 +470,8 @@ rx_alloc_failed:
free_rx_pointers(priv);
tx_alloc_failed:
free_tx_pointers(priv);
-err_out:
- iounmap(priv->gfargrp.regs);
+err_grp_init:
+ unmap_group_regs(priv);
free_netdev(dev);
return err;
}
@@ -445,9 +510,11 @@ static int gfar_probe(struct of_device *ofdev,
struct net_device *dev = NULL;
struct gfar_private *priv = NULL;
struct gfar __iomem *regs = NULL;
- int err = 0, i;
+ int err = 0, i, grp_idx = 0;
int len_devname;
u32 rstat = 0, tstat = 0, rqueue = 0, tqueue = 0;
+ u32 isrg = 0;
+ u32 *baddr;
err = gfar_of_init(ofdev, &dev);
@@ -460,12 +527,11 @@ static int gfar_probe(struct of_device *ofdev,
priv->node = ofdev->node;
SET_NETDEV_DEV(dev, &ofdev->dev);
- spin_lock_init(&priv->gfargrp.grplock);
spin_lock_init(&priv->bflock);
INIT_WORK(&priv->reset_task, gfar_reset_task);
dev_set_drvdata(&ofdev->dev, priv);
- regs = priv->gfargrp.regs;
+ regs = priv->gfargrp[0].regs;
/* Stop the DMA engine now, in case it was running before */
/* (The firmware could have used it, and left it running). */
@@ -498,7 +564,8 @@ static int gfar_probe(struct of_device *ofdev,
dev->ethtool_ops = &gfar_ethtool_ops;
/* Register for napi ...We are registering NAPI for each grp */
- netif_napi_add(dev, &priv->gfargrp.napi, gfar_poll, GFAR_DEV_WEIGHT);
+ for (i = 0; i < priv->num_grps; i++)
+ netif_napi_add(dev, &priv->gfargrp[i].napi, gfar_poll, GFAR_DEV_WEIGHT);
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
priv->rx_csum_enable = 1;
@@ -554,25 +621,51 @@ static int gfar_probe(struct of_device *ofdev,
if (dev->features & NETIF_F_IP_CSUM)
dev->hard_header_len += GMAC_FCB_LEN;
+ /* Program the isrg regs only if number of grps > 1 */
+ if (priv->num_grps > 1) {
+ baddr = ®s->isrg0;
+ for (i = 0; i < priv->num_grps; i++) {
+ isrg |= (priv->gfargrp[i].rx_bit_map << ISRG_SHIFT_RX);
+ isrg |= (priv->gfargrp[i].tx_bit_map << ISRG_SHIFT_TX);
+ gfar_write(baddr, isrg);
+ baddr++;
+ isrg = 0x0;
+ }
+ }
+
/* Need to reverse the bit maps as bit_map's MSB is q0
* but, for_each_bit parses from right to left, which
* basically reverses the queue numbers */
- priv->gfargrp.tx_bit_map = reverse_bitmap(priv->gfargrp.tx_bit_map, MAX_TX_QS);
- priv->gfargrp.rx_bit_map = reverse_bitmap(priv->gfargrp.rx_bit_map, MAX_RX_QS);
-
- /* Calculate RSTAT, TSTAT, RQUEUE and TQUEUE values */
- for_each_bit(i, &priv->gfargrp.rx_bit_map, priv->num_rx_queues) {
- priv->gfargrp.num_rx_queues++;
- rstat = rstat | (RSTAT_CLEAR_RHALT >> i);
- rqueue = rqueue | ((RQUEUE_EN0 | RQUEUE_EX0) >> i);
- }
- for_each_bit (i, &priv->gfargrp.tx_bit_map, priv->num_tx_queues) {
- priv->gfargrp.num_tx_queues++;
- tstat = tstat | (TSTAT_CLEAR_THALT >> i);
- tqueue = tqueue | (TQUEUE_EN0 >> i);
+ for (i = 0; i< priv->num_grps; i++) {
+ priv->gfargrp[i].tx_bit_map = reverse_bitmap(
+ priv->gfargrp[i].tx_bit_map, MAX_TX_QS);
+ priv->gfargrp[i].rx_bit_map = reverse_bitmap(
+ priv->gfargrp[i].rx_bit_map, MAX_RX_QS);
+ }
+
+ /* Calculate RSTAT, TSTAT, RQUEUE and TQUEUE values,
+ * also assign queues to groups */
+ for (grp_idx = 0; grp_idx < priv->num_grps; grp_idx++) {
+ priv->gfargrp[grp_idx].num_rx_queues = 0x0;
+ for_each_bit(i, &priv->gfargrp[grp_idx].rx_bit_map,
+ priv->num_rx_queues) {
+ priv->gfargrp[grp_idx].num_rx_queues++;
+ priv->rx_queue[i]->grp = &priv->gfargrp[grp_idx];
+ rstat = rstat | (RSTAT_CLEAR_RHALT >> i);
+ rqueue = rqueue | ((RQUEUE_EN0 | RQUEUE_EX0) >> i);
+ }
+ priv->gfargrp[grp_idx].num_tx_queues = 0x0;
+ for_each_bit (i, &priv->gfargrp[grp_idx].tx_bit_map,
+ priv->num_tx_queues) {
+ priv->gfargrp[grp_idx].num_tx_queues++;
+ priv->tx_queue[i]->grp = &priv->gfargrp[grp_idx];
+ tstat = tstat | (TSTAT_CLEAR_THALT >> i);
+ tqueue = tqueue | (TQUEUE_EN0 >> i);
+ }
+ priv->gfargrp[grp_idx].rstat = rstat;
+ priv->gfargrp[grp_idx].tstat = tstat;
+ rstat = tstat =0;
}
- priv->gfargrp.rstat = rstat;
- priv->gfargrp.tstat = tstat;
gfar_write(®s->rqueue, rqueue);
gfar_write(®s->tqueue, tqueue);
@@ -612,20 +705,40 @@ static int gfar_probe(struct of_device *ofdev,
/* fill out IRQ number and name fields */
len_devname = strlen(dev->name);
- strncpy(&priv->gfargrp.int_name_tx[0], dev->name, len_devname);
- if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
- strncpy(&priv->gfargrp.int_name_tx[len_devname],
- "_tx", sizeof("_tx") + 1);
-
- strncpy(&priv->gfargrp.int_name_rx[0], dev->name, len_devname);
- strncpy(&priv->gfargrp.int_name_rx[len_devname],
- "_rx", sizeof("_rx") + 1);
-
- strncpy(&priv->gfargrp.int_name_er[0], dev->name, len_devname);
- strncpy(&priv->gfargrp.int_name_er[len_devname],
- "_er", sizeof("_er") + 1);
- } else
- priv->gfargrp.int_name_tx[len_devname] = '\0';
+ for (i = 0; i < priv->num_grps; i++) {
+ strncpy(&priv->gfargrp[i].int_name_tx[0], dev->name,
+ len_devname);
+ if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
+ strncpy(&priv->gfargrp[i].int_name_tx[len_devname],
+ "_g", sizeof("_g"));
+ priv->gfargrp[i].int_name_tx[
+ strlen(priv->gfargrp[i].int_name_tx)] = i+48;
+ strncpy(&priv->gfargrp[i].int_name_tx[strlen(
+ priv->gfargrp[i].int_name_tx)],
+ "_tx", sizeof("_tx") + 1);
+
+ strncpy(&priv->gfargrp[i].int_name_rx[0], dev->name,
+ len_devname);
+ strncpy(&priv->gfargrp[i].int_name_rx[len_devname],
+ "_g", sizeof("_g"));
+ priv->gfargrp[i].int_name_rx[
+ strlen(priv->gfargrp[i].int_name_rx)] = i+48;
+ strncpy(&priv->gfargrp[i].int_name_rx[strlen(
+ priv->gfargrp[i].int_name_rx)],
+ "_rx", sizeof("_rx") + 1);
+
+ strncpy(&priv->gfargrp[i].int_name_er[0], dev->name,
+ len_devname);
+ strncpy(&priv->gfargrp[i].int_name_er[len_devname],
+ "_g", sizeof("_g"));
+ priv->gfargrp[i].int_name_er[strlen(
+ priv->gfargrp[i].int_name_er)] = i+48;
+ strncpy(&priv->gfargrp[i].int_name_er[strlen(\
+ priv->gfargrp[i].int_name_er)],
+ "_er", sizeof("_er") + 1);
+ } else
+ priv->gfargrp[i].int_name_tx[len_devname] = '\0';
+ }
/* Create all the sysfs files */
gfar_init_sysfs(dev);
@@ -646,7 +759,7 @@ static int gfar_probe(struct of_device *ofdev,
return 0;
register_fail:
- iounmap(priv->gfargrp.regs);
+ unmap_group_regs(priv);
free_tx_pointers(priv);
free_rx_pointers(priv);
if (priv->phy_node)
@@ -669,7 +782,7 @@ static int gfar_remove(struct of_device *ofdev)
dev_set_drvdata(&ofdev->dev, NULL);
unregister_netdev(priv->ndev);
- iounmap(priv->gfargrp.regs);
+ unmap_group_regs(priv);
free_netdev(priv->ndev);
return 0;
@@ -680,7 +793,7 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
{
struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
struct net_device *dev = priv->ndev;
- struct gfar __iomem *regs = NULL;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
unsigned long flags;
u32 tempval;
@@ -689,8 +802,6 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
netif_device_detach(dev);
- regs = priv->gfargrp.regs;
-
if (netif_running(dev)) {
local_irq_save(flags);
lock_tx_qs(priv);
@@ -712,7 +823,7 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
unlock_tx_qs(priv);
local_irq_restore(flags);
- napi_disable(&priv->gfargrp.napi);
+ disable_napi(priv);
if (magic_packet) {
/* Enable interrupt on Magic Packet */
@@ -734,7 +845,7 @@ static int gfar_resume(struct of_device *ofdev)
{
struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
struct net_device *dev = priv->ndev;
- struct gfar __iomem *regs = NULL;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
unsigned long flags;
u32 tempval;
int magic_packet = priv->wol_en &&
@@ -751,8 +862,6 @@ static int gfar_resume(struct of_device *ofdev)
/* Disable Magic Packet mode, in case something
* else woke us up.
*/
- regs = priv->gfargrp.regs;
-
local_irq_save(flags);
lock_tx_qs(priv);
lock_rx_qs(priv);
@@ -769,7 +878,7 @@ static int gfar_resume(struct of_device *ofdev)
netif_device_attach(dev);
- napi_enable(&priv->gfargrp.napi);
+ enable_napi(priv);
return 0;
}
@@ -784,10 +893,9 @@ static int gfar_resume(struct of_device *ofdev)
static phy_interface_t gfar_get_interface(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = NULL;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
u32 ecntrl;
- regs = priv->gfargrp.regs;
ecntrl = gfar_read(®s->ecntrl);
if (ecntrl & ECNTRL_SGMII_MODE)
@@ -911,14 +1019,18 @@ static void init_registers(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
struct gfar __iomem *regs = NULL;
+ int i = 0;
- regs = priv->gfargrp.regs;
- /* Clear IEVENT */
- gfar_write(®s->ievent, IEVENT_INIT_CLEAR);
+ for (i = 0; i < priv->num_grps; i++) {
+ regs = priv->gfargrp[i].regs;
+ /* Clear IEVENT */
+ gfar_write(®s->ievent, IEVENT_INIT_CLEAR);
- /* Initialize IMASK */
- gfar_write(®s->imask, IMASK_INIT_CLEAR);
+ /* Initialize IMASK */
+ gfar_write(®s->imask, IMASK_INIT_CLEAR);
+ }
+ regs = priv->gfargrp[0].regs;
/* Init hash registers to zero */
gfar_write(®s->igaddr0, 0);
gfar_write(®s->igaddr1, 0);
@@ -959,15 +1071,20 @@ static void init_registers(struct net_device *dev)
static void gfar_halt_nodisable(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = NULL;
u32 tempval;
+ int i = 0;
- /* Mask all interrupts */
- gfar_write(®s->imask, IMASK_INIT_CLEAR);
+ for (i = 0; i < priv->num_grps; i++) {
+ regs = priv->gfargrp[i].regs;
+ /* Mask all interrupts */
+ gfar_write(®s->imask, IMASK_INIT_CLEAR);
- /* Clear all interrupts */
- gfar_write(®s->ievent, IEVENT_INIT_CLEAR);
+ /* Clear all interrupts */
+ gfar_write(®s->ievent, IEVENT_INIT_CLEAR);
+ }
+ regs = priv->gfargrp[0].regs;
/* Stop the DMA, and wait for it to stop */
tempval = gfar_read(®s->dmactrl);
if ((tempval & (DMACTRL_GRS | DMACTRL_GTS))
@@ -985,7 +1102,7 @@ static void gfar_halt_nodisable(struct net_device *dev)
void gfar_halt(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
u32 tempval;
gfar_halt_nodisable(dev);
@@ -996,11 +1113,19 @@ void gfar_halt(struct net_device *dev)
gfar_write(®s->maccfg1, tempval);
}
+static void free_grp_irqs(struct gfar_priv_grp *grp)
+{
+ free_irq(grp->interruptError, grp);
+ free_irq(grp->interruptTransmit, grp);
+ free_irq(grp->interruptReceive, grp);
+}
+
void stop_gfar(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
unsigned long flags;
+ int i = 0;
phy_stop(priv->phydev);
@@ -1017,11 +1142,12 @@ void stop_gfar(struct net_device *dev)
/* Free the IRQs */
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
- free_irq(priv->gfargrp.interruptError, &priv->gfargrp);
- free_irq(priv->gfargrp.interruptTransmit, &priv->gfargrp);
- free_irq(priv->gfargrp.interruptReceive, &priv->gfargrp);
+ for (i = 0; i < priv->num_grps; i++)
+ free_grp_irqs(&priv->gfargrp[i]);
} else {
- free_irq(priv->gfargrp.interruptTransmit, &priv->gfargrp);
+ for (i = 0; i < priv->num_grps; i++)
+ free_irq(priv->gfargrp[i].interruptTransmit,
+ &priv->gfargrp[i]);
}
free_skb_resources(priv);
@@ -1115,8 +1241,9 @@ static void free_skb_resources(struct gfar_private *priv)
void gfar_start(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
u32 tempval;
+ int i = 0;
/* Enable Rx and Tx in MACCFG1 */
tempval = gfar_read(®s->maccfg1);
@@ -1133,16 +1260,111 @@ void gfar_start(struct net_device *dev)
tempval &= ~(DMACTRL_GRS | DMACTRL_GTS);
gfar_write(®s->dmactrl, tempval);
- /* Clear THLT/RHLT, so that the DMA starts polling now */
- gfar_write(®s->tstat, priv->gfargrp.tstat);
- gfar_write(®s->rstat, priv->gfargrp.rstat);
-
- /* Unmask the interrupts we look for */
- gfar_write(®s->imask, IMASK_DEFAULT);
+ for (i = 0; i < priv->num_grps; i++) {
+ regs = priv->gfargrp[i].regs;
+ /* Clear THLT/RHLT, so that the DMA starts polling now */
+ gfar_write(®s->tstat, priv->gfargrp[i].tstat);
+ gfar_write(®s->rstat, priv->gfargrp[i].rstat);
+ /* Unmask the interrupts we look for */
+ gfar_write(®s->imask, IMASK_DEFAULT);
+ }
dev->trans_start = jiffies;
}
+void gfar_configure_coalescing(struct gfar_private *priv,
+ unsigned int tx_mask, unsigned int rx_mask)
+{
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
+ u32 *baddr;
+ int i = 0;
+
+ /* Backward compatible case ---- even if we enable
+ * multiple queues, there's only single reg to program
+ */
+ gfar_write(®s->txic, 0);
+ if(likely(priv->tx_queue[0]->txcoalescing))
+ gfar_write(®s->txic, priv->tx_queue[0]->txic);
+
+ gfar_write(®s->rxic, 0);
+ if(unlikely(priv->rx_queue[0]->rxcoalescing))
+ gfar_write(®s->rxic, priv->rx_queue[0]->rxic);
+
+ if (priv->mode == MQ_MG_MODE) {
+ baddr = ®s->txic0;
+ for_each_bit (i, &tx_mask, priv->num_tx_queues) {
+ if (likely(priv->tx_queue[i]->txcoalescing)) {
+ gfar_write(baddr + i, 0);
+ gfar_write(baddr + i, priv->tx_queue[i]->txic);
+ }
+ }
+
+ baddr = ®s->rxic0;
+ for_each_bit (i, &rx_mask, priv->num_rx_queues) {
+ if (likely(priv->rx_queue[i]->rxcoalescing)) {
+ gfar_write(baddr + i, 0);
+ gfar_write(baddr + i, priv->rx_queue[i]->rxic);
+ }
+ }
+ }
+}
+
+static int register_grp_irqs(struct gfar_priv_grp *grp)
+{
+ struct gfar_private *priv = grp->priv;
+ struct net_device *dev = priv->ndev;
+ int err;
+
+ /* If the device has multiple interrupts, register for
+ * them. Otherwise, only register for the one */
+ if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
+ /* Install our interrupt handlers for Error,
+ * Transmit, and Receive */
+ if ((err = request_irq(grp->interruptError, gfar_error, 0,
+ grp->int_name_er,grp)) < 0) {
+ if (netif_msg_intr(priv))
+ printk(KERN_ERR "%s: Can't get IRQ %d\n",
+ dev->name, grp->interruptError);
+
+ goto err_irq_fail;
+ }
+
+ if ((err = request_irq(grp->interruptTransmit, gfar_transmit,
+ 0, grp->int_name_tx, grp)) < 0) {
+ if (netif_msg_intr(priv))
+ printk(KERN_ERR "%s: Can't get IRQ %d\n",
+ dev->name, grp->interruptTransmit);
+ goto tx_irq_fail;
+ }
+
+ if ((err = request_irq(grp->interruptReceive, gfar_receive, 0,
+ grp->int_name_rx, grp)) < 0) {
+ if (netif_msg_intr(priv))
+ printk(KERN_ERR "%s: Can't get IRQ %d\n",
+ dev->name, grp->interruptReceive);
+ goto rx_irq_fail;
+ }
+ } else {
+ if ((err = request_irq(grp->interruptTransmit, gfar_interrupt, 0,
+ grp->int_name_tx, grp)) < 0) {
+ if (netif_msg_intr(priv))
+ printk(KERN_ERR "%s: Can't get IRQ %d\n",
+ dev->name, grp->interruptTransmit);
+ goto err_irq_fail;
+ }
+ }
+
+ return 0;
+
+rx_irq_fail:
+ free_irq(grp->interruptTransmit, grp);
+tx_irq_fail:
+ free_irq(grp->interruptError, grp);
+err_irq_fail:
+ return err;
+
+}
+
/* Bring the controller up and running */
int startup_gfar(struct net_device *dev)
{
@@ -1154,15 +1376,19 @@ int startup_gfar(struct net_device *dev)
struct gfar_private *priv = netdev_priv(dev);
struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar_priv_rx_q *rx_queue = NULL;
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = NULL;
int err = 0;
u32 *baddr;
u32 rctrl = 0;
u32 tctrl = 0;
u32 attrs = 0;
- gfar_write(®s->imask, IMASK_INIT_CLEAR);
+ for (i = 0; i < priv->num_grps; i++) {
+ regs = priv->gfargrp[i].regs;
+ gfar_write(®s->imask, IMASK_INIT_CLEAR);
+ }
+ regs = priv->gfargrp[0].regs;
priv->total_tx_ring_size = 0;
for (i = 0; i < priv->num_tx_queues; i++)
priv->total_tx_ring_size += priv->tx_queue[i]->tx_ring_size;
@@ -1302,63 +1528,18 @@ int startup_gfar(struct net_device *dev)
rxbdp->status |= RXBD_WRAP;
}
- /* If the device has multiple interrupts, register for
- * them. Otherwise, only register for the one */
- if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
- /* Install our interrupt handlers for Error,
- * Transmit, and Receive */
- if (request_irq(priv->gfargrp.interruptError, gfar_error,
- 0, priv->gfargrp.int_name_er, &priv->gfargrp) < 0) {
- if (netif_msg_intr(priv))
- printk(KERN_ERR "%s: Can't get IRQ %d\n",
- dev->name, priv->gfargrp.interruptError);
-
- err = -1;
- goto err_irq_fail;
- }
-
- if (request_irq(priv->gfargrp.interruptTransmit, gfar_transmit,
- 0, priv->gfargrp.int_name_tx, &priv->gfargrp) < 0) {
- if (netif_msg_intr(priv))
- printk(KERN_ERR "%s: Can't get IRQ %d\n",
- dev->name, priv->gfargrp.interruptTransmit);
-
- err = -1;
-
- goto tx_irq_fail;
- }
-
- if (request_irq(priv->gfargrp.interruptReceive, gfar_receive,
- 0, priv->gfargrp.int_name_rx, &priv->gfargrp) < 0) {
- if (netif_msg_intr(priv))
- printk(KERN_ERR "%s: Can't get IRQ %d (receive0)\n",
- dev->name, priv->gfargrp.interruptReceive);
-
- err = -1;
- goto rx_irq_fail;
- }
- } else {
- if (request_irq(priv->gfargrp.interruptTransmit, gfar_interrupt,
- 0, priv->gfargrp.int_name_tx, &priv->gfargrp) < 0) {
- if (netif_msg_intr(priv))
- printk(KERN_ERR "%s: Can't get IRQ %d\n",
- dev->name, priv->gfargrp.interruptTransmit);
-
- err = -1;
- goto err_irq_fail;
+ for (i = 0; i < priv->num_grps; i++) {
+ err = register_grp_irqs(&priv->gfargrp[i]);
+ if (err) {
+ for (j = 0; j < i; j++)
+ free_grp_irqs(&priv->gfargrp[j]);
+ goto irq_fail;
}
}
phy_start(priv->phydev);
- /* Configure the coalescing support */
- gfar_write(®s->txic, 0);
- if (tx_queue->txcoalescing)
- gfar_write(®s->txic, tx_queue->txic);
-
- gfar_write(®s->rxic, 0);
- if (rx_queue->rxcoalescing)
- gfar_write(®s->rxic, rx_queue->rxic);
+ gfar_configure_coalescing(priv, 0xFF, 0xFF);
if (priv->rx_csum_enable)
rctrl |= RCTRL_CHECKSUMMING;
@@ -1421,11 +1602,7 @@ int startup_gfar(struct net_device *dev)
return 0;
-rx_irq_fail:
- free_irq(priv->gfargrp.interruptTransmit, &priv->gfargrp);
-tx_irq_fail:
- free_irq(priv->gfargrp.interruptError, &priv->gfargrp);
-err_irq_fail:
+irq_fail:
err_rxalloc_fail:
rx_skb_fail:
tx_skb_fail:
@@ -1446,7 +1623,7 @@ static int gfar_enet_open(struct net_device *dev)
struct gfar_private *priv = netdev_priv(dev);
int err;
- napi_enable(&priv->gfargrp.napi);
+ enable_napi(priv);
skb_queue_head_init(&priv->rx_recycle);
@@ -1458,13 +1635,13 @@ static int gfar_enet_open(struct net_device *dev)
err = init_phy(dev);
if (err) {
- napi_disable(&priv->gfargrp.napi);
+ disable_napi(priv);
return err;
}
err = startup_gfar(dev);
if (err) {
- napi_disable(&priv->gfargrp.napi);
+ disable_napi(priv);
return err;
}
@@ -1553,7 +1730,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
tx_queue = priv->tx_queue[rq];
txq = netdev_get_tx_queue(dev, rq);
base = tx_queue->tx_bd_base;
- regs = priv->gfargrp.regs;
+ regs = tx_queue->grp->regs;
/* make space for additional header when fcb is needed */
if (((skb->ip_summed == CHECKSUM_PARTIAL) ||
@@ -1690,7 +1867,7 @@ static int gfar_close(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- napi_disable(&priv->gfargrp.napi);
+ disable_napi(priv);
skb_queue_purge(&priv->rx_recycle);
cancel_work_sync(&priv->reset_task);
@@ -1723,7 +1900,7 @@ static void gfar_vlan_rx_register(struct net_device *dev,
unsigned long flags;
u32 tempval;
- regs = priv->gfargrp.regs;
+ regs = priv->gfargrp[0].regs;
local_irq_save(flags);
lock_rx_qs(priv);
@@ -1767,7 +1944,7 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu)
{
int tempsize, tempval;
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
int oldsize = priv->rx_buffer_size;
int frame_size = new_mtu + ETH_HLEN;
@@ -2197,7 +2374,7 @@ static int gfar_poll(struct napi_struct *napi, int budget)
struct gfar_priv_grp *gfargrp = container_of(napi,
struct gfar_priv_grp, napi);
struct gfar_private *priv = gfargrp->priv;
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = gfargrp->regs;
struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar_priv_rx_q *rx_queue = NULL;
int rx_cleaned = 0, budget_per_queue = 0, rx_cleaned_per_queue = 0;
@@ -2256,14 +2433,8 @@ static int gfar_poll(struct napi_struct *napi, int budget)
/* If we are coalescing interrupts, update the timer */
/* Otherwise, clear it */
- if (likely(rx_queue->rxcoalescing)) {
- gfar_write(®s->rxic, 0);
- gfar_write(®s->rxic, rx_queue->rxic);
- }
- if (likely(tx_queue->txcoalescing)) {
- gfar_write(®s->txic, 0);
- gfar_write(®s->txic, tx_queue->txic);
- }
+ gfar_configure_coalescing(priv,
+ gfargrp->rx_bit_map, gfargrp->tx_bit_map);
}
return rx_cleaned;
@@ -2278,20 +2449,26 @@ static int gfar_poll(struct napi_struct *napi, int budget)
static void gfar_netpoll(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
+ int i = 0;
/* If the device has multiple interrupts, run tx/rx */
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
- disable_irq(priv->gfargrp.interruptTransmit);
- disable_irq(priv->gfargrp.interruptReceive);
- disable_irq(priv->gfargrp.interruptError);
- gfar_interrupt(priv->gfargrp.interruptTransmit, &priv->gfargrp);
- enable_irq(priv->gfargrp.interruptError);
- enable_irq(priv->gfargrp.interruptReceive);
- enable_irq(priv->gfargrp.interruptTransmit);
+ for (i = 0; i < priv->num_grps; i++) {
+ disable_irq(priv->gfargrp[i].interruptTransmit);
+ disable_irq(priv->gfargrp[i].interruptReceive);
+ disable_irq(priv->gfargrp[i].interruptError);
+ gfar_interrupt(priv->gfargrp[i].interruptTransmit,
+ &priv->gfargrp[i]);
+ enable_irq(priv->gfargrp[i].interruptError);
+ enable_irq(priv->gfargrp[i].interruptReceive);
+ enable_irq(priv->gfargrp[i].interruptTransmit);
+ }
} else {
- disable_irq(priv->gfargrp.interruptTransmit);
- gfar_interrupt(priv->gfargrp.interruptTransmit, &priv->gfargrp);
- enable_irq(priv->gfargrp.interruptTransmit);
+ for (i = 0; i < priv->num_grps; i++) {
+ disable_irq(priv->gfargrp[i].interruptTransmit);
+ gfar_interrupt(priv->gfargrp[i].interruptTransmit,
+ &priv->gfargrp[i]);
+ enable_irq(priv->gfargrp[i].interruptTransmit);
}
}
#endif
@@ -2328,7 +2505,7 @@ static irqreturn_t gfar_interrupt(int irq, void *grp_id)
static void adjust_link(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
unsigned long flags;
struct phy_device *phydev = priv->phydev;
int new_state = 0;
@@ -2412,7 +2589,7 @@ static void gfar_set_multi(struct net_device *dev)
{
struct dev_mc_list *mc_ptr;
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
u32 tempval;
if (dev->flags & IFF_PROMISC) {
@@ -2545,7 +2722,7 @@ static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr)
static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
int idx;
char tmpbuf[MAC_ADDR_LEN];
u32 tempval;
@@ -2652,6 +2829,9 @@ static struct of_device_id gfar_match[] =
.type = "network",
.compatible = "gianfar",
},
+ {
+ .compatible = "fsl,etsec2",
+ },
{},
};
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index 4770d7e..feba4d7 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -79,6 +79,9 @@ extern const char gfar_driver_version[];
#define MAX_TX_QS 0x8
#define MAX_RX_QS 0x8
+/* MAXIMUM NUMBER OF GROUPS SUPPORTED */
+#define MAXGROUPS 0x2
+
/* These need to be powers of 2 for this driver */
#define DEFAULT_TX_RING_SIZE 256
#define DEFAULT_RX_RING_SIZE 256
@@ -795,7 +798,24 @@ struct gfar {
#define FSL_GIANFAR_DEV_HAS_BD_STASHING 0x00000200
#define FSL_GIANFAR_DEV_HAS_BUF_STASHING 0x00000400
+#if (MAXGROUPS == 2)
+#define DEFAULT_MAPPING 0xAA
+#else
#define DEFAULT_MAPPING 0xFF
+#endif
+
+#define ISRG_SHIFT_TX 0x10
+#define ISRG_SHIFT_RX 0x18
+
+/* The same driver can operate in two modes */
+/* SQ_SG_MODE: Single Queue Single Group Mode
+ * (Backward compatible mode)
+ * MQ_MG_MODE: Multi Queue Multi Group mode
+ */
+enum {
+ SQ_SG_MODE = 0,
+ MQ_MG_MODE
+};
/**
* struct gfar_priv_tx_q - per tx queue structure
@@ -824,6 +844,7 @@ struct gfar_priv_tx_q {
struct txbd8 *cur_tx;
struct txbd8 *dirty_tx;
struct net_device *dev;
+ struct gfar_priv_grp *grp;
u16 skb_curtx;
u16 skb_dirtytx;
u16 qindex;
@@ -856,6 +877,7 @@ struct gfar_priv_rx_q {
struct rxbd8 *rx_bd_base;
struct rxbd8 *cur_rx;
struct net_device *dev;
+ struct gfar_priv_grp *grp;
u16 skb_currx;
u16 qindex;
unsigned int rx_ring_size;
@@ -883,6 +905,7 @@ struct gfar_priv_grp {
struct napi_struct napi;
struct gfar_private *priv;
struct gfar __iomem *regs;
+ unsigned int grp_id;
unsigned int rx_bit_map;
unsigned int tx_bit_map;
unsigned int num_tx_queues;
@@ -914,6 +937,8 @@ struct gfar_private {
/* Indicates how many tx, rx queues are enabled */
unsigned int num_tx_queues;
unsigned int num_rx_queues;
+ unsigned int num_grps;
+ unsigned int mode;
/* The total tx and rx ring size for the enabled queues */
unsigned int total_tx_ring_size;
@@ -923,7 +948,7 @@ struct gfar_private {
struct net_device *ndev;
struct of_device *ofdev;
- struct gfar_priv_grp gfargrp;
+ struct gfar_priv_grp gfargrp[MAXGROUPS];
struct gfar_priv_tx_q *tx_queue[MAX_TX_QS];
struct gfar_priv_rx_q *rx_queue[MAX_RX_QS];
@@ -997,6 +1022,8 @@ extern void stop_gfar(struct net_device *dev);
extern void gfar_halt(struct net_device *dev);
extern void gfar_phy_test(struct mii_bus *bus, struct phy_device *phydev,
int enable, u32 regnum, u32 read);
+extern void gfar_configure_coalescing(struct gfar_private *priv,
+ unsigned int tx_mask, unsigned int rx_mask);
void gfar_init_sysfs(struct net_device *dev);
extern const struct ethtool_ops gfar_ethtool_ops;
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index d3d2623..562f6c2 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -137,7 +137,7 @@ static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy,
{
int i;
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
u64 *extra = (u64 *) & priv->extra_stats;
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
@@ -226,7 +226,7 @@ static void gfar_get_regs(struct net_device *dev, struct ethtool_regs *regs, voi
{
int i;
struct gfar_private *priv = netdev_priv(dev);
- u32 __iomem *theregs = (u32 __iomem *) priv->gfargrp.regs;
+ u32 __iomem *theregs = (u32 __iomem *) priv->gfargrp[0].regs;
u32 *buf = (u32 *) regbuf;
for (i = 0; i < sizeof (struct gfar) / sizeof (u32); i++)
@@ -352,22 +352,23 @@ static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->gfargrp.regs;
- struct gfar_priv_tx_q *tx_queue = NULL;
- struct gfar_priv_rx_q *rx_queue = NULL;
+ int i = 0;
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
return -EOPNOTSUPP;
- tx_queue = priv->tx_queue[0];
- rx_queue = priv->rx_queue[0];
-
/* Set up rx coalescing */
+ /* As of now, we will enable/disable coalescing for all
+ * queues together in case of eTSEC2, this will be modified
+ * along with the ethtool interface */
if ((cvals->rx_coalesce_usecs == 0) ||
- (cvals->rx_max_coalesced_frames == 0))
- rx_queue->rxcoalescing = 0;
- else
- rx_queue->rxcoalescing = 1;
+ (cvals->rx_max_coalesced_frames == 0)) {
+ for (i = 0; i < priv->num_rx_queues; i++)
+ priv->rx_queue[i]->rxcoalescing = 0;
+ } else {
+ for (i = 0; i < priv->num_rx_queues; i++)
+ priv->rx_queue[i]->rxcoalescing = 1;
+ }
if (NULL == priv->phydev)
return -ENODEV;
@@ -385,15 +386,21 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
return -EINVAL;
}
- rx_queue->rxic = mk_ic_value(cvals->rx_max_coalesced_frames,
- gfar_usecs2ticks(priv, cvals->rx_coalesce_usecs));
+ for (i = 0; i < priv->num_rx_queues; i++) {
+ priv->rx_queue[i]->rxic = mk_ic_value(
+ cvals->rx_max_coalesced_frames,
+ gfar_usecs2ticks(priv, cvals->rx_coalesce_usecs));
+ }
/* Set up tx coalescing */
if ((cvals->tx_coalesce_usecs == 0) ||
- (cvals->tx_max_coalesced_frames == 0))
- tx_queue->txcoalescing = 0;
- else
- tx_queue->txcoalescing = 1;
+ (cvals->tx_max_coalesced_frames == 0)) {
+ for (i = 0; i < priv->num_tx_queues; i++)
+ priv->tx_queue[i]->txcoalescing = 0;
+ } else {
+ for (i = 0; i < priv->num_tx_queues; i++)
+ priv->tx_queue[i]->txcoalescing = 1;
+ }
/* Check the bounds of the values */
if (cvals->tx_coalesce_usecs > GFAR_MAX_COAL_USECS) {
@@ -408,16 +415,13 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
return -EINVAL;
}
- tx_queue->txic = mk_ic_value(cvals->tx_max_coalesced_frames,
- gfar_usecs2ticks(priv, cvals->tx_coalesce_usecs));
-
- gfar_write(®s->rxic, 0);
- if (rx_queue->rxcoalescing)
- gfar_write(®s->rxic, rx_queue->rxic);
+ for (i = 0; i < priv->num_tx_queues; i++) {
+ priv->tx_queue[i]->txic = mk_ic_value(
+ cvals->tx_max_coalesced_frames,
+ gfar_usecs2ticks(priv, cvals->tx_coalesce_usecs));
+ }
- gfar_write(®s->txic, 0);
- if (tx_queue->txcoalescing)
- gfar_write(®s->txic, tx_queue->txic);
+ gfar_configure_coalescing(priv, 0xFF, 0xFF);
return 0;
}
diff --git a/drivers/net/gianfar_sysfs.c b/drivers/net/gianfar_sysfs.c
index 4b726f6..3724835 100644
--- a/drivers/net/gianfar_sysfs.c
+++ b/drivers/net/gianfar_sysfs.c
@@ -50,7 +50,7 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
int new_setting = 0;
u32 temp;
unsigned long flags;
@@ -105,7 +105,7 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
unsigned int length = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -164,7 +164,7 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
unsigned short index = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -212,7 +212,7 @@ static ssize_t gfar_set_fifo_threshold(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
unsigned int length = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -252,7 +252,7 @@ static ssize_t gfar_set_fifo_starve(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
unsigned int num = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -293,7 +293,7 @@ static ssize_t gfar_set_fifo_starve_off(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
- struct gfar __iomem *regs = priv->gfargrp.regs;
+ struct gfar __iomem *regs = priv->gfargrp[0].regs;
unsigned int num = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
--
1.5.2.2
^ permalink raw reply related
* [PATCH v0 5/7] gianfar: Add support etsec2.0 registers.
From: Sandeep Gopalpet @ 2009-10-15 16:31 UTC (permalink / raw)
To: netdev; +Cc: Sandeep Gopalpet
This patch adds support for etsec2.0 regsiters
Signed-off-by: Sandeep Gopalpet <sandeep.kumar@freescale.com>
---
drivers/net/gianfar.h | 55 +++++++++++++++++++++++++++++++++++++++---------
1 files changed, 44 insertions(+), 11 deletions(-)
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index 9b466c2..4770d7e 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -566,25 +566,32 @@ struct gfar_stats {
struct gfar {
u32 tsec_id; /* 0x.000 - Controller ID register */
- u8 res1[12];
+ u32 tsec_id2; /* 0x.004 - Controller ID2 register */
+ u8 res1[8];
u32 ievent; /* 0x.010 - Interrupt Event Register */
u32 imask; /* 0x.014 - Interrupt Mask Register */
u32 edis; /* 0x.018 - Error Disabled Register */
- u8 res2[4];
+ u32 emapg; /* 0x.01c - Group Error mapping register */
u32 ecntrl; /* 0x.020 - Ethernet Control Register */
u32 minflr; /* 0x.024 - Minimum Frame Length Register */
u32 ptv; /* 0x.028 - Pause Time Value Register */
u32 dmactrl; /* 0x.02c - DMA Control Register */
u32 tbipa; /* 0x.030 - TBI PHY Address Register */
- u8 res3[88];
+ u8 res2[28];
+ u32 fifo_rx_pause; /* 0x.050 - FIFO receive pause start threshold
+ register */
+ u32 fifo_rx_pause_shutoff; /* x.054 - FIFO receive starve shutoff
+ register */
+ u32 fifo_rx_alarm; /* 0x.058 - FIFO receive alarm start threshold
+ register */
+ u32 fifo_rx_alarm_shutoff; /*0x.05c - FIFO receive alarm starve
+ shutoff register */
+ u8 res3[44];
u32 fifo_tx_thr; /* 0x.08c - FIFO transmit threshold register */
u8 res4[8];
u32 fifo_tx_starve; /* 0x.098 - FIFO transmit starve register */
u32 fifo_tx_starve_shutoff; /* 0x.09c - FIFO transmit starve shutoff register */
- u8 res5[4];
- u32 fifo_rx_pause; /* 0x.0a4 - FIFO receive pause threshold register */
- u32 fifo_rx_alarm; /* 0x.0a8 - FIFO receive alarm threshold register */
- u8 res6[84];
+ u8 res5[96];
u32 tctrl; /* 0x.100 - Transmit Control Register */
u32 tstat; /* 0x.104 - Transmit Status Register */
u32 dfvlan; /* 0x.108 - Default VLAN Control word */
@@ -635,7 +642,11 @@ struct gfar {
u8 res12[8];
u32 rxic; /* 0x.310 - Receive Interrupt Coalescing Configuration Register */
u32 rqueue; /* 0x.314 - Receive queue control register */
- u8 res13[24];
+ u32 rir0; /* 0x.318 - Ring mapping register 0 */
+ u32 rir1; /* 0x.31c - Ring mapping register 1 */
+ u32 rir2; /* 0x.320 - Ring mapping register 2 */
+ u32 rir3; /* 0x.324 - Ring mapping register 3 */
+ u8 res13[8];
u32 rbifx; /* 0x.330 - Receive bit field extract control register */
u32 rqfar; /* 0x.334 - Receive queue filing table address register */
u32 rqfcr; /* 0x.338 - Receive queue filing table control register */
@@ -684,7 +695,7 @@ struct gfar {
u32 maxfrm; /* 0x.510 - Maximum Frame Length Register */
u8 res18[12];
u8 gfar_mii_regs[24]; /* See gianfar_phy.h */
- u8 res19[4];
+ u32 ifctrl; /* 0x.538 - Interface control register */
u32 ifstat; /* 0x.53c - Interface Status Register */
u32 macstnaddr1; /* 0x.540 - Station Address Part 1 Register */
u32 macstnaddr2; /* 0x.544 - Station Address Part 2 Register */
@@ -745,8 +756,30 @@ struct gfar {
u8 res23c[248];
u32 attr; /* 0x.bf8 - Attributes Register */
u32 attreli; /* 0x.bfc - Attributes Extract Length and Extract Index Register */
- u8 res24[1024];
-
+ u8 res24[688];
+ u32 isrg0; /* 0x.eb0 - Interrupt steering group 0 register */
+ u32 isrg1; /* 0x.eb4 - Interrupt steering group 1 register */
+ u32 isrg2; /* 0x.eb8 - Interrupt steering group 2 register */
+ u32 isrg3; /* 0x.ebc - Interrupt steering group 3 register */
+ u8 res25[16];
+ u32 rxic0; /* 0x.ed0 - Ring 0 Rx interrupt coalescing */
+ u32 rxic1; /* 0x.ed4 - Ring 1 Rx interrupt coalescing */
+ u32 rxic2; /* 0x.ed8 - Ring 2 Rx interrupt coalescing */
+ u32 rxic3; /* 0x.edc - Ring 3 Rx interrupt coalescing */
+ u32 rxic4; /* 0x.ee0 - Ring 4 Rx interrupt coalescing */
+ u32 rxic5; /* 0x.ee4 - Ring 5 Rx interrupt coalescing */
+ u32 rxic6; /* 0x.ee8 - Ring 6 Rx interrupt coalescing */
+ u32 rxic7; /* 0x.eec - Ring 7 Rx interrupt coalescing */
+ u8 res26[32];
+ u32 txic0; /* 0x.f10 - Ring 0 Tx interrupt coalescing */
+ u32 txic1; /* 0x.f14 - Ring 1 Tx interrupt coalescing */
+ u32 txic2; /* 0x.f18 - Ring 2 Tx interrupt coalescing */
+ u32 txic3; /* 0x.f1c - Ring 3 Tx interrupt coalescing */
+ u32 txic4; /* 0x.f20 - Ring 4 Tx interrupt coalescing */
+ u32 txic5; /* 0x.f24 - Ring 5 Tx interrupt coalescing */
+ u32 txic6; /* 0x.f28 - Ring 6 Tx interrupt coalescing */
+ u32 txic7; /* 0x.f2c - Ring 7 Tx interrupt coalescing */
+ u8 res27[208];
};
/* Flags related to gianfar device features */
--
1.5.2.2
^ permalink raw reply related
* [PATCH v0 3/7] gianfar: Add Multiple Queue Support
From: Sandeep Gopalpet @ 2009-10-15 16:31 UTC (permalink / raw)
To: netdev; +Cc: Sandeep Gopalpet
This patch introduces multiple Tx and Rx queues.
The incoming packets can be classified into different queues
based on filer rules (out of scope of this patch). The number
of queues enabled will be based on a DTS entries fsl,num_tx_queues
and fsl,num_rx_queues.
Although we are enabling multiple queues, the interrupt coalescing
is on per device level (etsec-1.7 doesn't support multiple rxics
and txics).
Signed-off-by: Sandeep Gopalpet <sandeep.kumar@freescale.com>
---
drivers/net/gianfar.c | 658 ++++++++++++++++++++++++++++-------------
drivers/net/gianfar.h | 95 ++++++-
drivers/net/gianfar_ethtool.c | 70 +++--
drivers/net/gianfar_sysfs.c | 50 ++--
4 files changed, 598 insertions(+), 275 deletions(-)
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 8bee911..bb5dd08 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -143,6 +143,7 @@ void gfar_start(struct net_device *dev);
static void gfar_clear_exact_match(struct net_device *dev);
static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr);
static int gfar_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
+u16 gfar_select_queue(struct net_device *dev, struct sk_buff *skb);
MODULE_AUTHOR("Freescale Semiconductor, Inc");
MODULE_DESCRIPTION("Gianfar Ethernet Driver");
@@ -156,6 +157,7 @@ static const struct net_device_ops gfar_netdev_ops = {
.ndo_set_multicast_list = gfar_set_multi,
.ndo_tx_timeout = gfar_timeout,
.ndo_do_ioctl = gfar_ioctl,
+ .ndo_select_queue = gfar_select_queue,
.ndo_vlan_rx_register = gfar_vlan_rx_register,
.ndo_set_mac_address = eth_mac_addr,
.ndo_validate_addr = eth_validate_addr,
@@ -164,36 +166,131 @@ static const struct net_device_ops gfar_netdev_ops = {
#endif
};
+inline void lock_rx_qs(struct gfar_private *priv)
+{
+ int i = 0x0;
+
+ for (i = 0; i < priv->num_rx_queues; i++)
+ spin_lock(&priv->rx_queue[i]->rxlock);
+}
+
+inline void lock_tx_qs(struct gfar_private *priv)
+{
+ int i = 0x0;
+
+ for (i = 0; i < priv->num_tx_queues; i++)
+ spin_lock(&priv->tx_queue[i]->txlock);
+}
+
+inline void unlock_rx_qs(struct gfar_private *priv)
+{
+ int i = 0x0;
+
+ for (i = 0; i < priv->num_rx_queues; i++)
+ spin_unlock(&priv->rx_queue[i]->rxlock);
+}
+
+inline void unlock_tx_qs(struct gfar_private *priv)
+{
+ int i = 0x0;
+
+ for (i = 0; i < priv->num_tx_queues; i++)
+ spin_unlock(&priv->tx_queue[i]->txlock);
+}
+
/* Returns 1 if incoming frames use an FCB */
static inline int gfar_uses_fcb(struct gfar_private *priv)
{
return priv->vlgrp || priv->rx_csum_enable;
}
-static int gfar_of_init(struct net_device *dev)
+u16 gfar_select_queue(struct net_device *dev, struct sk_buff *skb)
+{
+ return skb_get_queue_mapping(skb);
+}
+static void free_tx_pointers(struct gfar_private *priv)
+{
+ int i = 0;
+
+ for (i = 0; i < priv->num_tx_queues; i++)
+ kfree(priv->tx_queue[i]);
+}
+
+static void free_rx_pointers(struct gfar_private *priv)
+{
+ int i = 0;
+
+ for (i = 0; i < priv->num_rx_queues; i++)
+ kfree(priv->rx_queue[i]);
+}
+
+static int gfar_of_init(struct of_device *ofdev, struct net_device **pdev)
{
const char *model;
const char *ctype;
const void *mac_addr;
u64 addr, size;
- int err = 0;
- struct gfar_private *priv = netdev_priv(dev);
- struct device_node *np = priv->node;
+ int err = 0, i;
+ struct net_device *dev = NULL;
+ struct gfar_private *priv = NULL;
+ struct device_node *np = ofdev->node;
const u32 *stash;
const u32 *stash_len;
const u32 *stash_idx;
+ unsigned int num_tx_qs, num_rx_qs;
+ u32 *tx_queues, *rx_queues;
if (!np || !of_device_is_available(np))
return -ENODEV;
+ /* parse the num of tx and rx queues */
+ tx_queues = (u32 *)of_get_property(np, "fsl,num_tx_queues", NULL);
+ num_tx_qs = tx_queues ? *tx_queues : 1;
+
+ if (num_tx_qs > MAX_TX_QS) {
+ printk(KERN_ERR "num_tx_qs(=%d) greater than MAX_TX_QS(=%d)\n",
+ num_tx_qs, MAX_TX_QS);
+ printk(KERN_ERR "Cannot do alloc_etherdev, aborting\n");
+ return -EINVAL;
+ }
+
+ rx_queues = (u32 *)of_get_property(np, "fsl,num_rx_queues", NULL);
+ num_rx_qs = rx_queues ? *rx_queues : 1;
+
+ if (num_rx_qs > MAX_RX_QS) {
+ printk(KERN_ERR "num_rx_qs(=%d) greater than MAX_RX_QS(=%d)\n",
+ num_tx_qs, MAX_TX_QS);
+ printk(KERN_ERR "Cannot do alloc_etherdev, aborting\n");
+ return -EINVAL;
+ }
+
+ *pdev = alloc_etherdev_mq(sizeof(*priv), num_tx_qs);
+ dev = *pdev;
+ if (NULL == dev)
+ return -ENOMEM;
+
+ priv = netdev_priv(dev);
+ priv->node = ofdev->node;
+ priv->ndev = dev;
+
+ dev->num_tx_queues = num_tx_qs;
+ dev->real_num_tx_queues = num_tx_qs;
+ priv->num_tx_queues = num_tx_qs;
+ priv->num_rx_queues = num_rx_qs;
+
/* get a pointer to the register memory */
addr = of_translate_address(np, of_get_address(np, 0, &size, NULL));
priv->gfargrp.regs = ioremap(addr, size);
- if (priv->gfargrp.regs == NULL)
- return -ENOMEM;
+ if (priv->gfargrp.regs == NULL) {
+ err = -ENOMEM;
+ goto err_out;
+ }
priv->gfargrp.priv = priv; /* back pointer from group to priv */
+ priv->gfargrp.rx_bit_map = DEFAULT_MAPPING;
+ priv->gfargrp.tx_bit_map = DEFAULT_MAPPING;
+
priv->gfargrp.interruptTransmit = irq_of_parse_and_map(np, 0);
model = of_get_property(np, "model", NULL);
@@ -212,6 +309,38 @@ static int gfar_of_init(struct net_device *dev)
}
}
+ for (i = 0; i < priv->num_tx_queues; i++)
+ priv->tx_queue[i] = NULL;
+ for (i = 0; i < priv->num_rx_queues; i++)
+ priv->rx_queue[i] = NULL;
+
+ for (i = 0; i < priv->num_tx_queues; i++) {
+ priv->tx_queue[i] = (struct gfar_priv_tx_q *)kmalloc(
+ sizeof (struct gfar_priv_tx_q), GFP_KERNEL);
+ if (!priv->tx_queue[i]) {
+ err = -ENOMEM;
+ goto tx_alloc_failed;
+ }
+ priv->tx_queue[i]->tx_skbuff = NULL;
+ priv->tx_queue[i]->qindex = i;
+ priv->tx_queue[i]->dev = dev;
+ spin_lock_init(&(priv->tx_queue[i]->txlock));
+ }
+
+ for (i = 0; i < priv->num_rx_queues; i++) {
+ priv->rx_queue[i] = (struct gfar_priv_rx_q *)kmalloc(
+ sizeof (struct gfar_priv_rx_q), GFP_KERNEL);
+ if (!priv->rx_queue[i]) {
+ err = -ENOMEM;
+ goto rx_alloc_failed;
+ }
+ priv->rx_queue[i]->rx_skbuff = NULL;
+ priv->rx_queue[i]->qindex = i;
+ priv->rx_queue[i]->dev = dev;
+ spin_lock_init(&(priv->rx_queue[i]->rxlock));
+ }
+
+
stash = of_get_property(np, "bd-stash", NULL);
if (stash) {
@@ -272,8 +401,13 @@ static int gfar_of_init(struct net_device *dev)
return 0;
+rx_alloc_failed:
+ free_rx_pointers(priv);
+tx_alloc_failed:
+ free_tx_pointers(priv);
err_out:
iounmap(priv->gfargrp.regs);
+ free_netdev(dev);
return err;
}
@@ -291,6 +425,17 @@ static int gfar_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
return phy_mii_ioctl(priv->phydev, if_mii(rq), cmd);
}
+static unsigned int reverse_bitmap(unsigned int bit_map, unsigned int max_qs)
+{
+ unsigned int new_bit_map = 0x0;
+ int mask = 0x1 << (max_qs - 1), i;
+ for (i = 0; i < max_qs; i++) {
+ if (bit_map & mask)
+ new_bit_map = new_bit_map + (1 << i);
+ mask = mask >> 0x1;
+ }
+ return new_bit_map;
+}
/* Set up the ethernet device structure, private data,
* and anything else we need before we start */
static int gfar_probe(struct of_device *ofdev,
@@ -300,14 +445,14 @@ static int gfar_probe(struct of_device *ofdev,
struct net_device *dev = NULL;
struct gfar_private *priv = NULL;
struct gfar __iomem *regs = NULL;
- int err = 0;
+ int err = 0, i;
int len_devname;
+ u32 rstat = 0, tstat = 0, rqueue = 0, tqueue = 0;
- /* Create an ethernet device instance */
- dev = alloc_etherdev(sizeof (*priv));
+ err = gfar_of_init(ofdev, &dev);
- if (NULL == dev)
- return -ENOMEM;
+ if (err)
+ return err;
priv = netdev_priv(dev);
priv->ndev = dev;
@@ -315,23 +460,6 @@ static int gfar_probe(struct of_device *ofdev,
priv->node = ofdev->node;
SET_NETDEV_DEV(dev, &ofdev->dev);
- err = gfar_of_init(dev);
-
- if (err)
- goto regs_fail;
-
- priv->tx_queue = (struct gfar_priv_tx_q *)kmalloc(
- sizeof (struct gfar_priv_tx_q), GFP_KERNEL);
- if (!priv->tx_queue)
- goto regs_fail;
-
- priv->rx_queue = (struct gfar_priv_rx_q *)kmalloc(
- sizeof (struct gfar_priv_rx_q), GFP_KERNEL);
- if (!priv->rx_queue)
- goto rx_queue_fail;
-
- spin_lock_init(&priv->tx_queue->txlock);
- spin_lock_init(&priv->rx_queue->rxlock);
spin_lock_init(&priv->gfargrp.grplock);
spin_lock_init(&priv->bflock);
INIT_WORK(&priv->reset_task, gfar_reset_task);
@@ -369,8 +497,8 @@ static int gfar_probe(struct of_device *ofdev,
dev->netdev_ops = &gfar_netdev_ops;
dev->ethtool_ops = &gfar_ethtool_ops;
- /* Register for napi ...NAPI is for each rx_queue */
- netif_napi_add(dev, &priv->rx_queue->napi, gfar_poll, GFAR_DEV_WEIGHT);
+ /* Register for napi ...We are registering NAPI for each grp */
+ netif_napi_add(dev, &priv->gfargrp.napi, gfar_poll, GFAR_DEV_WEIGHT);
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
priv->rx_csum_enable = 1;
@@ -426,17 +554,44 @@ static int gfar_probe(struct of_device *ofdev,
if (dev->features & NETIF_F_IP_CSUM)
dev->hard_header_len += GMAC_FCB_LEN;
+ /* Need to reverse the bit maps as bit_map's MSB is q0
+ * but, for_each_bit parses from right to left, which
+ * basically reverses the queue numbers */
+ priv->gfargrp.tx_bit_map = reverse_bitmap(priv->gfargrp.tx_bit_map, MAX_TX_QS);
+ priv->gfargrp.rx_bit_map = reverse_bitmap(priv->gfargrp.rx_bit_map, MAX_RX_QS);
+
+ /* Calculate RSTAT, TSTAT, RQUEUE and TQUEUE values */
+ for_each_bit(i, &priv->gfargrp.rx_bit_map, priv->num_rx_queues) {
+ priv->gfargrp.num_rx_queues++;
+ rstat = rstat | (RSTAT_CLEAR_RHALT >> i);
+ rqueue = rqueue | ((RQUEUE_EN0 | RQUEUE_EX0) >> i);
+ }
+ for_each_bit (i, &priv->gfargrp.tx_bit_map, priv->num_tx_queues) {
+ priv->gfargrp.num_tx_queues++;
+ tstat = tstat | (TSTAT_CLEAR_THALT >> i);
+ tqueue = tqueue | (TQUEUE_EN0 >> i);
+ }
+ priv->gfargrp.rstat = rstat;
+ priv->gfargrp.tstat = tstat;
+
+ gfar_write(®s->rqueue, rqueue);
+ gfar_write(®s->tqueue, tqueue);
+
priv->rx_buffer_size = DEFAULT_RX_BUFFER_SIZE;
/* Initializing some of the rx/tx queue level parameters */
- priv->tx_queue->tx_ring_size = DEFAULT_TX_RING_SIZE;
- priv->tx_queue->num_txbdfree = DEFAULT_TX_RING_SIZE;
- priv->tx_queue->txcoalescing = DEFAULT_TX_COALESCE;
- priv->tx_queue->txic = DEFAULT_TXIC;
+ for (i = 0; i < priv->num_tx_queues; i++) {
+ priv->tx_queue[i]->tx_ring_size = DEFAULT_TX_RING_SIZE;
+ priv->tx_queue[i]->num_txbdfree = DEFAULT_TX_RING_SIZE;
+ priv->tx_queue[i]->txcoalescing = DEFAULT_TX_COALESCE;
+ priv->tx_queue[i]->txic = DEFAULT_TXIC;
+ }
- priv->rx_queue->rx_ring_size = DEFAULT_RX_RING_SIZE;
- priv->rx_queue->rxcoalescing = DEFAULT_RX_COALESCE;
- priv->rx_queue->rxic = DEFAULT_RXIC;
+ for (i = 0; i < priv->num_rx_queues; i++) {
+ priv->rx_queue[i]->rx_ring_size = DEFAULT_RX_RING_SIZE;
+ priv->rx_queue[i]->rxcoalescing = DEFAULT_RX_COALESCE;
+ priv->rx_queue[i]->rxic = DEFAULT_RXIC;
+ }
/* Enable most messages by default */
priv->msg_enable = (NETIF_MSG_IFUP << 1 ) - 1;
@@ -481,17 +636,19 @@ static int gfar_probe(struct of_device *ofdev,
/* Even more device info helps when determining which kernel */
/* provided which set of benchmarks. */
printk(KERN_INFO "%s: Running with NAPI enabled\n", dev->name);
- printk(KERN_INFO "%s: %d/%d RX/TX BD ring size\n",
- dev->name, priv->rx_queue->rx_ring_size, priv->tx_queue->tx_ring_size);
+ for (i = 0; i < priv->num_rx_queues; i++)
+ printk(KERN_INFO "%s: :RX BD ring size for Q[%d]: %d\n",
+ dev->name, i, priv->rx_queue[i]->rx_ring_size);
+ for(i = 0; i < priv->num_tx_queues; i++)
+ printk(KERN_INFO "%s:TX BD ring size for Q[%d]: %d\n",
+ dev->name, i, priv->tx_queue[i]->tx_ring_size);
return 0;
register_fail:
iounmap(priv->gfargrp.regs);
- kfree(priv->rx_queue);
-rx_queue_fail:
- kfree(priv->tx_queue);
-regs_fail:
+ free_tx_pointers(priv);
+ free_rx_pointers(priv);
if (priv->phy_node)
of_node_put(priv->phy_node);
if (priv->tbi_node)
@@ -523,8 +680,6 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
{
struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
struct net_device *dev = priv->ndev;
- struct gfar_priv_tx_q *tx_queue = NULL;
- struct gfar_priv_rx_q *rx_queue = NULL;
struct gfar __iomem *regs = NULL;
unsigned long flags;
u32 tempval;
@@ -534,13 +689,12 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
netif_device_detach(dev);
- tx_queue = priv->tx_queue;
- rx_queue = priv->rx_queue;
regs = priv->gfargrp.regs;
if (netif_running(dev)) {
- spin_lock_irqsave(&tx_queue->txlock, flags);
- spin_lock(&tx_queue->rxlock);
+ local_irq_save(flags);
+ lock_tx_qs(priv);
+ lock_rx_qs(priv);
gfar_halt_nodisable(dev);
@@ -554,10 +708,11 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
gfar_write(®s->maccfg1, tempval);
- spin_unlock(&rx_queue->rxlock);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
+ unlock_rx_qs(priv);
+ unlock_tx_qs(priv);
+ local_irq_restore(flags);
- napi_disable(&rx_queue->napi);
+ napi_disable(&priv->gfargrp.napi);
if (magic_packet) {
/* Enable interrupt on Magic Packet */
@@ -579,8 +734,6 @@ static int gfar_resume(struct of_device *ofdev)
{
struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
struct net_device *dev = priv->ndev;
- struct gfar_priv_tx_q *tx_queue = NULL;
- struct gfar_priv_rx_q *rx_queue = NULL;
struct gfar __iomem *regs = NULL;
unsigned long flags;
u32 tempval;
@@ -598,12 +751,11 @@ static int gfar_resume(struct of_device *ofdev)
/* Disable Magic Packet mode, in case something
* else woke us up.
*/
- rx_queue = priv->rx_queue;
- tx_queue = priv->tx_queue;
regs = priv->gfargrp.regs;
- spin_lock_irqsave(&tx_queue->txlock, flags);
- spin_lock(&rx_queue->rxlock);
+ local_irq_save(flags);
+ lock_tx_qs(priv);
+ lock_rx_qs(priv);
tempval = gfar_read(®s->maccfg2);
tempval &= ~MACCFG2_MPEN;
@@ -611,12 +763,13 @@ static int gfar_resume(struct of_device *ofdev)
gfar_start(dev);
- spin_unlock(&rx_queue->rxlock);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
+ unlock_rx_qs(priv);
+ unlock_tx_qs(priv);
+ local_irq_restore(flags);
netif_device_attach(dev);
- napi_enable(&rx_queue->napi);
+ napi_enable(&priv->gfargrp.napi);
return 0;
}
@@ -847,23 +1000,20 @@ void stop_gfar(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
struct gfar __iomem *regs = priv->gfargrp.regs;
- struct gfar_priv_tx_q *tx_queue = NULL;
- struct gfar_priv_rx_q *rx_queue = NULL;
unsigned long flags;
phy_stop(priv->phydev);
- tx_queue = priv->tx_queue;
- rx_queue = priv->rx_queue;
-
/* Lock it down */
- spin_lock_irqsave(&tx_queue->txlock, flags);
- spin_lock(&rx_queue->rxlock);
+ local_irq_save(flags);
+ lock_tx_qs(priv);
+ lock_rx_qs(priv);
gfar_halt(dev);
- spin_unlock(&rx_queue->rxlock);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
+ unlock_rx_qs(priv);
+ unlock_tx_qs(priv);
+ local_irq_restore(flags);
/* Free the IRQs */
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
@@ -877,24 +1027,18 @@ void stop_gfar(struct net_device *dev)
free_skb_resources(priv);
dma_free_coherent(&priv->ofdev->dev,
- sizeof(struct txbd8)* tx_queue->tx_ring_size
- + sizeof(struct rxbd8)* rx_queue->rx_ring_size,
- tx_queue->tx_bd_base,
+ sizeof(struct txbd8)* priv->total_tx_ring_size
+ + sizeof(struct rxbd8)* priv->total_rx_ring_size,
+ priv->tx_queue[0]->tx_bd_base,
gfar_read(®s->tbase0));
}
-/* If there are any tx skbs or rx skbs still around, free them.
- * Then free tx_skbuff and rx_skbuff */
-static void free_skb_resources(struct gfar_private *priv)
+static void free_skb_tx_queue(struct gfar_priv_tx_q *tx_queue)
{
- struct rxbd8 *rxbdp;
struct txbd8 *txbdp;
- struct gfar_priv_tx_q *tx_queue = NULL;
- struct gfar_priv_rx_q *rx_queue = NULL;
+ struct gfar_private *priv = netdev_priv(tx_queue->dev);
int i, j;
- /* Go through all the buffer descriptors and free their data buffers */
- tx_queue = priv->tx_queue;
txbdp = tx_queue->tx_bd_base;
for (i = 0; i < tx_queue->tx_ring_size; i++) {
@@ -915,8 +1059,14 @@ static void free_skb_resources(struct gfar_private *priv)
}
kfree(tx_queue->tx_skbuff);
+}
+
+static void free_skb_rx_queue(struct gfar_priv_rx_q *rx_queue)
+{
+ struct rxbd8 *rxbdp;
+ struct gfar_private *priv = netdev_priv(rx_queue->dev);
+ int i;
- rx_queue = priv->rx_queue;
rxbdp = rx_queue->rx_bd_base;
/* rx_skbuff is not guaranteed to be allocated, so only
@@ -924,9 +1074,9 @@ static void free_skb_resources(struct gfar_private *priv)
if (rx_queue->rx_skbuff != NULL) {
for (i = 0; i < rx_queue->rx_ring_size; i++) {
if (rx_queue->rx_skbuff[i]) {
- dma_unmap_single(&priv->ofdev->dev, rxbdp->bufPtr,
- priv->rx_buffer_size,
- DMA_FROM_DEVICE);
+ dma_unmap_single(&priv->ofdev->dev,
+ rxbdp->bufPtr, priv->rx_buffer_size,
+ DMA_FROM_DEVICE);
dev_kfree_skb_any(rx_queue->rx_skbuff[i]);
rx_queue->rx_skbuff[i] = NULL;
@@ -942,6 +1092,26 @@ static void free_skb_resources(struct gfar_private *priv)
}
}
+/* If there are any tx skbs or rx skbs still around, free them.
+ * Then free tx_skbuff and rx_skbuff */
+static void free_skb_resources(struct gfar_private *priv)
+{
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
+ int i;
+
+ /* Go through all the buffer descriptors and free their data buffers */
+ for (i = 0; i < priv->num_tx_queues; i++) {
+ tx_queue = priv->tx_queue[i];
+ free_skb_tx_queue(tx_queue);
+ }
+
+ for (i = 0; i < priv->num_rx_queues; i++) {
+ rx_queue = priv->rx_queue[i];
+ free_skb_rx_queue(rx_queue);
+ }
+}
+
void gfar_start(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
@@ -964,8 +1134,8 @@ void gfar_start(struct net_device *dev)
gfar_write(®s->dmactrl, tempval);
/* Clear THLT/RHLT, so that the DMA starts polling now */
- gfar_write(®s->tstat, TSTAT_CLEAR_THALT);
- gfar_write(®s->rstat, RSTAT_CLEAR_RHALT);
+ gfar_write(®s->tstat, priv->gfargrp.tstat);
+ gfar_write(®s->rstat, priv->gfargrp.rstat);
/* Unmask the interrupts we look for */
gfar_write(®s->imask, IMASK_DEFAULT);
@@ -980,25 +1150,31 @@ int startup_gfar(struct net_device *dev)
struct rxbd8 *rxbdp;
dma_addr_t addr = 0;
unsigned long vaddr;
- int i;
+ int i, j, k;
struct gfar_private *priv = netdev_priv(dev);
- struct gfar_priv_tx_q *tx_queue;
- struct gfar_priv_rx_q *rx_queue;
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
struct gfar __iomem *regs = priv->gfargrp.regs;
int err = 0;
+ u32 *baddr;
u32 rctrl = 0;
u32 tctrl = 0;
u32 attrs = 0;
gfar_write(®s->imask, IMASK_INIT_CLEAR);
- tx_queue = priv->tx_queue;
- rx_queue = priv->rx_queue;
+ priv->total_tx_ring_size = 0;
+ for (i = 0; i < priv->num_tx_queues; i++)
+ priv->total_tx_ring_size += priv->tx_queue[i]->tx_ring_size;
+
+ priv->total_rx_ring_size = 0;
+ for (i = 0; i < priv->num_rx_queues; i++)
+ priv->total_rx_ring_size += priv->rx_queue[i]->rx_ring_size;
/* Allocate memory for the buffer descriptors */
vaddr = (unsigned long) dma_alloc_coherent(&priv->ofdev->dev,
- sizeof (struct txbd8) * tx_queue->tx_ring_size +
- sizeof (struct rxbd8) * rx_queue->rx_ring_size,
+ sizeof (struct txbd8) * priv->total_tx_ring_size +
+ sizeof (struct rxbd8) * priv->total_rx_ring_size,
&addr, GFP_KERNEL);
if (vaddr == 0) {
@@ -1008,93 +1184,123 @@ int startup_gfar(struct net_device *dev)
return -ENOMEM;
}
- tx_queue->tx_bd_base = (struct txbd8 *) vaddr;
- tx_queue->dev = dev;
-
- /* enet DMA only understands physical addresses */
- gfar_write(®s->tbase0, addr);
+ baddr = ®s->tbase0;
+ for (i = 0; i < priv->num_tx_queues; i++) {
+ tx_queue = priv->tx_queue[i];
+ tx_queue->tx_bd_base = (struct txbd8 *) vaddr;
+ /* enet DMA only understands physical addresses */
+ gfar_write(baddr, addr);
+ printk("txbd[%d]: addr, vaddr = 0x%lx,0x%lx\n",
+ i, (unsigned long)addr, (unsigned long)vaddr);
+ addr += sizeof(struct txbd8) *tx_queue->tx_ring_size;
+ vaddr += sizeof(struct txbd8) *tx_queue->tx_ring_size;
+ baddr += 2;
+ }
+ baddr = ®s->rbase0;
/* Start the rx descriptor ring where the tx ring leaves off */
- addr = addr + sizeof (struct txbd8) * tx_queue->tx_ring_size;
- vaddr = vaddr + sizeof (struct txbd8) * tx_queue->tx_ring_size;
- rx_queue->rx_bd_base = (struct rxbd8 *) vaddr;
- rx_queue->dev = dev;
- gfar_write(®s->rbase0, addr);
+ for (i = 0; i < priv->num_rx_queues; i++) {
+ rx_queue = priv->rx_queue[i];
+ rx_queue->rx_bd_base = (struct rxbd8 *) vaddr;
+ gfar_write(baddr, addr);
+ printk("rxbd[%d]: addr,vaddr=0x%lx,0x%lx\n",
+ i,(unsigned long)addr,(unsigned long)vaddr);
+ addr += sizeof (struct rxbd8) * rx_queue->rx_ring_size;
+ vaddr += sizeof (struct rxbd8) * rx_queue->rx_ring_size;
+ baddr += 2;
+ }
/* Setup the skbuff rings */
- tx_queue->tx_skbuff =
- (struct sk_buff **) kmalloc(sizeof (struct sk_buff *) *
- tx_queue->tx_ring_size, GFP_KERNEL);
-
- if (NULL == tx_queue->tx_skbuff) {
- if (netif_msg_ifup(priv))
- printk(KERN_ERR "%s: Could not allocate tx_skbuff\n",
+ for (i = 0; i < priv->num_tx_queues; i++) {
+ tx_queue = priv->tx_queue[i];
+ tx_queue->tx_skbuff =
+ (struct sk_buff **)kmalloc(sizeof
+ (struct sk_buff *) * tx_queue->tx_ring_size,
+ GFP_KERNEL);
+ if (NULL == tx_queue->tx_skbuff) {
+ if (netif_msg_ifup(priv))
+ printk(KERN_ERR
+ "%s: Could not allocate tx_skbuff\n",
dev->name);
- err = -ENOMEM;
- goto tx_skb_fail;
- }
-
+ err = -ENOMEM;
+ goto tx_skb_fail;
+ }
- for (i = 0; i < tx_queue->tx_ring_size; i++)
- tx_queue->tx_skbuff[i] = NULL;
+ for (k = 0; k < tx_queue->tx_ring_size; k++)
+ tx_queue->tx_skbuff[k] = NULL;
+ }
- rx_queue->rx_skbuff =
- (struct sk_buff **) kmalloc(sizeof (struct sk_buff *) *
+ for (i = 0; i < priv->num_rx_queues; i++) {
+ rx_queue = priv->rx_queue[i];
+ rx_queue->rx_skbuff =
+ (struct sk_buff **)kmalloc(sizeof (struct sk_buff *) *
rx_queue->rx_ring_size, GFP_KERNEL);
- if (NULL == rx_queue->rx_skbuff) {
- if (netif_msg_ifup(priv))
- printk(KERN_ERR "%s: Could not allocate rx_skbuff\n",
+ if (NULL == rx_queue->rx_skbuff) {
+ if (netif_msg_ifup(priv))
+ printk(KERN_ERR
+ "%s: Could not allocate rx_skbuff\n",
dev->name);
- err = -ENOMEM;
- goto rx_skb_fail;
- }
+ err = -ENOMEM;
+ goto rx_skb_fail;
+ }
- for (i = 0; i < rx_queue->rx_ring_size; i++)
- rx_queue->rx_skbuff[i] = NULL;
+ for (j = 0; j < rx_queue->rx_ring_size; j++)
+ rx_queue->rx_skbuff[j] = NULL;
+ }
/* Initialize some variables in our per tx/rx queue structure */
- tx_queue->num_txbdfree = tx_queue->tx_ring_size;
- tx_queue->dirty_tx = tx_queue->cur_tx = tx_queue->tx_bd_base;
- tx_queue->skb_curtx = tx_queue->skb_dirtytx = 0;
- rx_queue->cur_rx = rx_queue->rx_bd_base;
- rx_queue->skb_currx = 0;
+ for (i = 0; i < priv->num_tx_queues; i++) {
+ tx_queue = priv->tx_queue[i];
+ tx_queue->num_txbdfree = tx_queue->tx_ring_size;
+ tx_queue->dirty_tx = tx_queue->tx_bd_base;
+ tx_queue->cur_tx = tx_queue->tx_bd_base;
+ tx_queue->skb_curtx = 0;
+ tx_queue->skb_dirtytx = 0;
+ txbdp = tx_queue->tx_bd_base;
+
+ /* Initialize Transmit Descriptor Ring */
+ for (j = 0; j < tx_queue->tx_ring_size; j++) {
+ txbdp->lstatus = 0;
+ txbdp->bufPtr = 0;
+ txbdp++;
+ }
- /* Initialize Transmit Descriptor Ring */
- txbdp = tx_queue->tx_bd_base;
- for (i = 0; i < tx_queue->tx_ring_size; i++) {
- txbdp->lstatus = 0;
- txbdp->bufPtr = 0;
- txbdp++;
+ /* Set the last descriptor in the ring to indicate wrap */
+ txbdp--;
+ txbdp->status |= TXBD_WRAP;
}
- /* Set the last descriptor in the ring to indicate wrap */
- txbdp--;
- txbdp->status |= TXBD_WRAP;
+ for (i = 0; i < priv->num_rx_queues; i++) {
+ rx_queue = priv->rx_queue[i];
+ rx_queue->cur_rx = rx_queue->rx_bd_base;
+ rx_queue->skb_currx = 0;
+ rxbdp = rx_queue->rx_bd_base;
- rxbdp = rx_queue->rx_bd_base;
- for (i = 0; i < rx_queue->rx_ring_size; i++) {
- struct sk_buff *skb;
+ for (j = 0; j < rx_queue->rx_ring_size; j++) {
+ struct sk_buff *skb;
- skb = gfar_new_skb(dev);
+ skb = gfar_new_skb(dev);
- if (!skb) {
- printk(KERN_ERR "%s: Can't allocate RX buffers\n",
+ if (!skb) {
+ printk(KERN_ERR
+ "%s: Can't allocate RX buffers\n",
dev->name);
- goto err_rxalloc_fail;
- }
+ goto err_rxalloc_fail;
+ }
- rx_queue->rx_skbuff[i] = skb;
+ rx_queue->rx_skbuff[j] = skb;
- gfar_new_rxbdp(rx_queue, rxbdp, skb);
+ gfar_new_rxbdp(rx_queue, rxbdp, skb);
- rxbdp++;
- }
+ rxbdp++;
+ }
- /* Set the last descriptor in the ring to wrap */
- rxbdp--;
- rxbdp->status |= RXBD_WRAP;
+ /* Set the last descriptor in the ring to wrap */
+ rxbdp--;
+ rxbdp->status |= RXBD_WRAP;
+ }
/* If the device has multiple interrupts, register for
* them. Otherwise, only register for the one */
@@ -1157,6 +1363,9 @@ int startup_gfar(struct net_device *dev)
if (priv->rx_csum_enable)
rctrl |= RCTRL_CHECKSUMMING;
+ if (priv->filer_en)
+ rctrl |= RCTRL_FILREN;
+
if (priv->extended_hash) {
rctrl |= RCTRL_EXTHASH;
@@ -1181,6 +1390,8 @@ int startup_gfar(struct net_device *dev)
if (dev->features & NETIF_F_IP_CSUM)
tctrl |= TCTRL_INIT_CSUM;
+ tctrl |= TCTRL_TXSCHED_PRIO;
+
gfar_write(®s->tctrl, tctrl);
/* Set the extraction length and index */
@@ -1217,12 +1428,12 @@ tx_irq_fail:
err_irq_fail:
err_rxalloc_fail:
rx_skb_fail:
- free_skb_resources(priv);
tx_skb_fail:
+ free_skb_resources(priv);
dma_free_coherent(&priv->ofdev->dev,
- sizeof(struct txbd8)*tx_queue->tx_ring_size
- + sizeof(struct rxbd8)*rx_queue->rx_ring_size,
- tx_queue->tx_bd_base,
+ sizeof(struct txbd8)*priv->total_tx_ring_size
+ + sizeof(struct rxbd8)*priv->total_rx_ring_size,
+ priv->tx_queue[0]->tx_bd_base,
gfar_read(®s->tbase0));
return err;
@@ -1235,7 +1446,7 @@ static int gfar_enet_open(struct net_device *dev)
struct gfar_private *priv = netdev_priv(dev);
int err;
- napi_enable(&priv->rx_queue->napi);
+ napi_enable(&priv->gfargrp.napi);
skb_queue_head_init(&priv->rx_recycle);
@@ -1247,17 +1458,17 @@ static int gfar_enet_open(struct net_device *dev)
err = init_phy(dev);
if (err) {
- napi_disable(&priv->rx_queue->napi);
+ napi_disable(&priv->gfargrp.napi);
return err;
}
err = startup_gfar(dev);
if (err) {
- napi_disable(&priv->rx_queue->napi);
+ napi_disable(&priv->gfargrp.napi);
return err;
}
- netif_start_queue(dev);
+ netif_tx_start_all_queues(dev);
device_set_wakeup_enable(&dev->dev, priv->wol_en);
@@ -1327,16 +1538,20 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
struct gfar_priv_tx_q *tx_queue = NULL;
+ struct netdev_queue *txq;
struct gfar __iomem *regs = NULL;
struct txfcb *fcb = NULL;
struct txbd8 *txbdp, *txbdp_start, *base;
u32 lstatus;
- int i;
+ int i, rq = 0;
u32 bufaddr;
unsigned long flags;
unsigned int nr_frags, length;
- tx_queue = priv->tx_queue;
+
+ rq = skb->queue_mapping;
+ tx_queue = priv->tx_queue[rq];
+ txq = netdev_get_tx_queue(dev, rq);
base = tx_queue->tx_bd_base;
regs = priv->gfargrp.regs;
@@ -1364,7 +1579,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
/* check if there is space to queue this packet */
if ((nr_frags+1) > tx_queue->num_txbdfree) {
/* no space, stop the queue */
- netif_stop_queue(dev);
+ netif_tx_stop_queue(txq);
dev->stats.tx_fifo_errors++;
spin_unlock_irqrestore(&tx_queue->txlock, flags);
return NETDEV_TX_BUSY;
@@ -1456,13 +1671,13 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
/* If the next BD still needs to be cleaned up, then the bds
are full. We need to tell the kernel to stop sending us stuff. */
if (!tx_queue->num_txbdfree) {
- netif_stop_queue(dev);
+ netif_tx_stop_queue(txq);
dev->stats.tx_fifo_errors++;
}
/* Tell the DMA to go go go */
- gfar_write(®s->tstat, TSTAT_CLEAR_THALT);
+ gfar_write(®s->tstat, TSTAT_CLEAR_THALT >> tx_queue->qindex);
/* Unlock priv */
spin_unlock_irqrestore(&tx_queue->txlock, flags);
@@ -1475,7 +1690,7 @@ static int gfar_close(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- napi_disable(&priv->rx_queue->napi);
+ napi_disable(&priv->gfargrp.napi);
skb_queue_purge(&priv->rx_recycle);
cancel_work_sync(&priv->reset_task);
@@ -1485,7 +1700,7 @@ static int gfar_close(struct net_device *dev)
phy_disconnect(priv->phydev);
priv->phydev = NULL;
- netif_stop_queue(dev);
+ netif_tx_stop_all_queues(dev);
return 0;
}
@@ -1504,14 +1719,13 @@ static void gfar_vlan_rx_register(struct net_device *dev,
struct vlan_group *grp)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar_priv_rx_q *rx_queue = NULL;
struct gfar __iomem *regs = NULL;
unsigned long flags;
u32 tempval;
- rx_queue = priv->rx_queue;
regs = priv->gfargrp.regs;
- spin_lock_irqsave(&rx_queue->rxlock, flags);
+ local_irq_save(flags);
+ lock_rx_qs(priv);
priv->vlgrp = grp;
@@ -1545,7 +1759,8 @@ static void gfar_vlan_rx_register(struct net_device *dev,
gfar_change_mtu(dev, dev->mtu);
- spin_unlock_irqrestore(&rx_queue->rxlock, flags);
+ unlock_rx_qs(priv);
+ local_irq_restore(flags);
}
static int gfar_change_mtu(struct net_device *dev, int new_mtu)
@@ -1617,10 +1832,10 @@ static void gfar_reset_task(struct work_struct *work)
struct net_device *dev = priv->ndev;
if (dev->flags & IFF_UP) {
- netif_stop_queue(dev);
+ netif_tx_stop_all_queues(dev);
stop_gfar(dev);
startup_gfar(dev);
- netif_start_queue(dev);
+ netif_tx_start_all_queues(dev);
}
netif_tx_schedule_all(dev);
@@ -1651,7 +1866,7 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
int howmany = 0;
u32 lstatus;
- rx_queue = priv->rx_queue;
+ rx_queue = priv->rx_queue[tx_queue->qindex];
bdp = tx_queue->dirty_tx;
skb_dirtytx = tx_queue->skb_dirtytx;
@@ -1704,8 +1919,8 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
}
/* If we freed a buffer, we can restart transmission, if necessary */
- if (netif_queue_stopped(dev) && tx_queue->num_txbdfree)
- netif_wake_queue(dev);
+ if (__netif_subqueue_stopped(dev, tx_queue->qindex) && tx_queue->num_txbdfree)
+ netif_wake_subqueue(dev, tx_queue->qindex);
/* Update dirty indicators */
tx_queue->skb_dirtytx = skb_dirtytx;
@@ -1718,19 +1933,12 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
static void gfar_schedule_cleanup(struct gfar_priv_grp *gfargrp)
{
- struct gfar_private *priv = gfargrp->priv;
- struct gfar_priv_tx_q *tx_queue = NULL;
- struct gfar_priv_rx_q *rx_queue = NULL;
unsigned long flags;
- rx_queue = priv->rx_queue;
- tx_queue = priv->tx_queue;
- spin_lock_irqsave(&tx_queue->txlock, flags);
- spin_lock(&rx_queue->rxlock);
-
- if (napi_schedule_prep(&rx_queue->napi)) {
+ spin_lock_irqsave(&gfargrp->grplock, flags);
+ if (napi_schedule_prep(&gfargrp->napi)) {
gfar_write(&gfargrp->regs->imask, IMASK_RTX_DISABLED);
- __napi_schedule(&rx_queue->napi);
+ __napi_schedule(&gfargrp->napi);
} else {
/*
* Clear IEVENT, so interrupts aren't called again
@@ -1738,9 +1946,8 @@ static void gfar_schedule_cleanup(struct gfar_priv_grp *gfargrp)
*/
gfar_write(&gfargrp->regs->ievent, IEVENT_RTX_MASK);
}
+ spin_unlock_irqrestore(&gfargrp->grplock, flags);
- spin_unlock(&rx_queue->rxlock);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
}
/* Interrupt Handler for Transmit complete */
@@ -1866,6 +2073,7 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
fcb = (struct rxfcb *)skb->data;
/* Remove the FCB from the skb */
+ skb_set_queue_mapping(skb, fcb->rq);
/* Remove the padded bytes, if there are any */
if (amount_pull)
skb_pull(skb, amount_pull);
@@ -1986,28 +2194,54 @@ int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
static int gfar_poll(struct napi_struct *napi, int budget)
{
- struct gfar_priv_rx_q *rx_queue = container_of(napi,
- struct gfar_priv_rx_q, napi);
- struct net_device *dev = rx_queue->dev;
- struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_grp *gfargrp = container_of(napi,
+ struct gfar_priv_grp, napi);
+ struct gfar_private *priv = gfargrp->priv;
struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_tx_q *tx_queue = NULL;
- int tx_cleaned = 0;
- int rx_cleaned = 0;
+ struct gfar_priv_rx_q *rx_queue = NULL;
+ int rx_cleaned = 0, budget_per_queue = 0, rx_cleaned_per_queue = 0;
+ int tx_cleaned = 0, i, left_over_budget = budget, serviced_queues = 0;
+ int num_queues = 0;
unsigned long flags;
+ num_queues = gfargrp->num_rx_queues;
+ budget_per_queue = budget/num_queues;
+
/* Clear IEVENT, so interrupts aren't called again
* because of the packets that have already arrived */
gfar_write(®s->ievent, IEVENT_RTX_MASK);
- tx_queue = priv->tx_queue;
- /* If we fail to get the lock, don't bother with the TX BDs */
- if (spin_trylock_irqsave(&tx_queue->txlock, flags)) {
- tx_cleaned = gfar_clean_tx_ring(tx_queue);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
- }
+ while (num_queues && left_over_budget) {
+
+ budget_per_queue = left_over_budget/num_queues;
+ left_over_budget = 0;
- rx_cleaned = gfar_clean_rx_ring(rx_queue, budget);
+ for_each_bit(i, &gfargrp->rx_bit_map, priv->num_rx_queues) {
+ if (test_bit(i, &serviced_queues))
+ continue;
+ rx_queue = priv->rx_queue[i];
+ tx_queue = priv->tx_queue[rx_queue->qindex];
+
+ /* If we fail to get the lock,
+ * don't bother with the TX BDs */
+ if (spin_trylock_irqsave(&tx_queue->txlock, flags)) {
+ tx_cleaned += gfar_clean_tx_ring(tx_queue);
+ spin_unlock_irqrestore(&tx_queue->txlock,
+ flags);
+ }
+
+ rx_cleaned_per_queue = gfar_clean_rx_ring(rx_queue,
+ budget_per_queue);
+ rx_cleaned += rx_cleaned_per_queue;
+ if(rx_cleaned_per_queue < budget_per_queue) {
+ left_over_budget = left_over_budget +
+ (budget_per_queue - rx_cleaned_per_queue);
+ set_bit(i, &serviced_queues);
+ num_queues--;
+ }
+ }
+ }
if (tx_cleaned)
return budget;
@@ -2016,7 +2250,7 @@ static int gfar_poll(struct napi_struct *napi, int budget)
napi_complete(napi);
/* Clear the halt bit in RSTAT */
- gfar_write(®s->rstat, RSTAT_CLEAR_RHALT);
+ gfar_write(®s->rstat, gfargrp->rstat);
gfar_write(®s->imask, IMASK_DEFAULT);
@@ -2094,14 +2328,14 @@ static irqreturn_t gfar_interrupt(int irq, void *grp_id)
static void adjust_link(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar __iomem *regs = priv->gfargrp.regs;
unsigned long flags;
struct phy_device *phydev = priv->phydev;
int new_state = 0;
- tx_queue = priv->tx_queue;
- spin_lock_irqsave(&tx_queue->txlock, flags);
+ local_irq_save(flags);
+ lock_tx_qs(priv);
+
if (phydev->link) {
u32 tempval = gfar_read(®s->maccfg2);
u32 ecntrl = gfar_read(®s->ecntrl);
@@ -2166,8 +2400,8 @@ static void adjust_link(struct net_device *dev)
if (new_state && netif_msg_link(priv))
phy_print_status(phydev);
-
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
+ unlock_tx_qs(priv);
+ local_irq_restore(flags);
}
/* Update the hash table based on the current list of multicast
@@ -2371,7 +2605,7 @@ static irqreturn_t gfar_error(int irq, void *grp_id)
priv->extra_stats.tx_underrun++;
/* Reactivate the Tx Queues */
- gfar_write(®s->tstat, TSTAT_CLEAR_THALT);
+ gfar_write(®s->tstat, gfargrp->tstat);
}
if (netif_msg_tx_err(priv))
printk(KERN_DEBUG "%s: Transmit Error\n", dev->name);
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index 440f17c..9b466c2 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -75,6 +75,10 @@
extern const char gfar_driver_name[];
extern const char gfar_driver_version[];
+/* MAXIMUM NUMBER OF QUEUES SUPPORTED */
+#define MAX_TX_QS 0x8
+#define MAX_RX_QS 0x8
+
/* These need to be powers of 2 for this driver */
#define DEFAULT_TX_RING_SIZE 256
#define DEFAULT_RX_RING_SIZE 256
@@ -172,12 +176,63 @@ extern const char gfar_driver_version[];
#define MINFLR_INIT_SETTINGS 0x00000040
+/* Tqueue control */
+#define TQUEUE_EN0 0x00008000
+#define TQUEUE_EN1 0x00004000
+#define TQUEUE_EN2 0x00002000
+#define TQUEUE_EN3 0x00001000
+#define TQUEUE_EN4 0x00000800
+#define TQUEUE_EN5 0x00000400
+#define TQUEUE_EN6 0x00000200
+#define TQUEUE_EN7 0x00000100
+#define TQUEUE_EN_ALL 0x0000FF00
+
+#define TR03WT_WT0_MASK 0xFF000000
+#define TR03WT_WT1_MASK 0x00FF0000
+#define TR03WT_WT2_MASK 0x0000FF00
+#define TR03WT_WT3_MASK 0x000000FF
+
+#define TR47WT_WT4_MASK 0xFF000000
+#define TR47WT_WT5_MASK 0x00FF0000
+#define TR47WT_WT6_MASK 0x0000FF00
+#define TR47WT_WT7_MASK 0x000000FF
+
+/* Rqueue control */
+#define RQUEUE_EX0 0x00800000
+#define RQUEUE_EX1 0x00400000
+#define RQUEUE_EX2 0x00200000
+#define RQUEUE_EX3 0x00100000
+#define RQUEUE_EX4 0x00080000
+#define RQUEUE_EX5 0x00040000
+#define RQUEUE_EX6 0x00020000
+#define RQUEUE_EX7 0x00010000
+#define RQUEUE_EX_ALL 0x00FF0000
+
+#define RQUEUE_EN0 0x00000080
+#define RQUEUE_EN1 0x00000040
+#define RQUEUE_EN2 0x00000020
+#define RQUEUE_EN3 0x00000010
+#define RQUEUE_EN4 0x00000008
+#define RQUEUE_EN5 0x00000004
+#define RQUEUE_EN6 0x00000002
+#define RQUEUE_EN7 0x00000001
+#define RQUEUE_EN_ALL 0x000000FF
+
/* Init to do tx snooping for buffers and descriptors */
#define DMACTRL_INIT_SETTINGS 0x000000c3
#define DMACTRL_GRS 0x00000010
#define DMACTRL_GTS 0x00000008
-#define TSTAT_CLEAR_THALT 0x80000000
+#define TSTAT_CLEAR_THALT_ALL 0xFF000000
+#define TSTAT_CLEAR_THALT 0x80000000
+#define TSTAT_CLEAR_THALT0 0x80000000
+#define TSTAT_CLEAR_THALT1 0x40000000
+#define TSTAT_CLEAR_THALT2 0x20000000
+#define TSTAT_CLEAR_THALT3 0x10000000
+#define TSTAT_CLEAR_THALT4 0x08000000
+#define TSTAT_CLEAR_THALT5 0x04000000
+#define TSTAT_CLEAR_THALT6 0x02000000
+#define TSTAT_CLEAR_THALT7 0x01000000
/* Interrupt coalescing macros */
#define IC_ICEN 0x80000000
@@ -228,6 +283,13 @@ extern const char gfar_driver_version[];
#define TCTRL_IPCSEN 0x00004000
#define TCTRL_TUCSEN 0x00002000
#define TCTRL_VLINS 0x00001000
+#define TCTRL_THDF 0x00000800
+#define TCTRL_RFCPAUSE 0x00000010
+#define TCTRL_TFCPAUSE 0x00000008
+#define TCTRL_TXSCHED_MASK 0x00000006
+#define TCTRL_TXSCHED_INIT 0x00000000
+#define TCTRL_TXSCHED_PRIO 0x00000002
+#define TCTRL_TXSCHED_WRRS 0x00000004
#define TCTRL_INIT_CSUM (TCTRL_TUCSEN | TCTRL_IPCSEN)
#define IEVENT_INIT_CLEAR 0xffffffff
@@ -700,6 +762,8 @@ struct gfar {
#define FSL_GIANFAR_DEV_HAS_BD_STASHING 0x00000200
#define FSL_GIANFAR_DEV_HAS_BUF_STASHING 0x00000400
+#define DEFAULT_MAPPING 0xFF
+
/**
* struct gfar_priv_tx_q - per tx queue structure
* @txlock: per queue tx spin lock
@@ -742,7 +806,6 @@ struct gfar_priv_tx_q {
/**
* struct gfar_priv_rx_q - per rx queue structure
* @rxlock: per queue rx spin lock
- * @napi: the napi poll function
* @rx_skbuff: skb pointers
* @skb_currx: currently use skb pointer
* @rx_bd_base: First rx buffer descriptor
@@ -756,7 +819,6 @@ struct gfar_priv_tx_q {
struct gfar_priv_rx_q {
spinlock_t rxlock __attribute__ ((aligned (SMP_CACHE_BYTES)));
- struct napi_struct napi;
struct sk_buff ** rx_skbuff;
struct rxbd8 *rx_bd_base;
struct rxbd8 *cur_rx;
@@ -771,6 +833,7 @@ struct gfar_priv_rx_q {
/**
* struct gfar_priv_grp - per group structure
+ * @napi: the napi poll function
* @priv: back pointer to the priv structure
* @regs: the ioremapped register space for this group
* @grp_id: group id for this group
@@ -784,8 +847,17 @@ struct gfar_priv_rx_q {
struct gfar_priv_grp {
spinlock_t grplock __attribute__ ((aligned (SMP_CACHE_BYTES)));
+ struct napi_struct napi;
struct gfar_private *priv;
struct gfar __iomem *regs;
+ unsigned int rx_bit_map;
+ unsigned int tx_bit_map;
+ unsigned int num_tx_queues;
+ unsigned int num_rx_queues;
+ unsigned int rstat;
+ unsigned int tstat;
+ unsigned int imask;
+ unsigned int ievent;
unsigned int interruptTransmit;
unsigned int interruptReceive;
unsigned int interruptError;
@@ -806,13 +878,21 @@ struct gfar_priv_grp {
*/
struct gfar_private {
+ /* Indicates how many tx, rx queues are enabled */
+ unsigned int num_tx_queues;
+ unsigned int num_rx_queues;
+
+ /* The total tx and rx ring size for the enabled queues */
+ unsigned int total_tx_ring_size;
+ unsigned int total_rx_ring_size;
+
struct device_node *node;
struct net_device *ndev;
struct of_device *ofdev;
struct gfar_priv_grp gfargrp;
- struct gfar_priv_tx_q *tx_queue;
- struct gfar_priv_rx_q *rx_queue;
+ struct gfar_priv_tx_q *tx_queue[MAX_TX_QS];
+ struct gfar_priv_rx_q *rx_queue[MAX_RX_QS];
/* RX per device parameters */
unsigned int rx_buffer_size;
@@ -843,6 +923,7 @@ struct gfar_private {
unsigned char rx_csum_enable:1,
extended_hash:1,
bd_stash_en:1,
+ filer_en:1,
wol_en:1; /* Wake-on-LAN enabled */
unsigned short padding;
@@ -873,6 +954,10 @@ static inline void gfar_write(volatile unsigned __iomem *addr, u32 val)
out_be32(addr, val);
}
+extern inline void lock_rx_qs(struct gfar_private *priv);
+extern inline void lock_tx_qs(struct gfar_private *priv);
+extern inline void unlock_rx_qs(struct gfar_private *priv);
+extern inline void unlock_tx_qs(struct gfar_private *priv);
extern irqreturn_t gfar_receive(int irq, void *dev_id);
extern int startup_gfar(struct net_device *dev);
extern void stop_gfar(struct net_device *dev);
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index c681b41..d3d2623 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -204,9 +204,11 @@ static int gfar_gsettings(struct net_device *dev, struct ethtool_cmd *cmd)
if (NULL == phydev)
return -ENODEV;
- tx_queue = priv->tx_queue;
- rx_queue = priv->rx_queue;
+ tx_queue = priv->tx_queue[0];
+ rx_queue = priv->rx_queue[0];
+ /* etsec-1.7 and older versions have only one txic
+ * and rxic regs although they support multiple queues */
cmd->maxtxpkt = get_icft_value(tx_queue->txic);
cmd->maxrxpkt = get_icft_value(rx_queue->rxic);
@@ -298,8 +300,8 @@ static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
if (NULL == priv->phydev)
return -ENODEV;
- rx_queue = priv->rx_queue;
- tx_queue = priv->tx_queue;
+ rx_queue = priv->rx_queue[0];
+ tx_queue = priv->tx_queue[0];
rxtime = get_ictt_value(rx_queue->rxic);
rxcount = get_icft_value(rx_queue->rxic);
@@ -357,8 +359,8 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
return -EOPNOTSUPP;
- tx_queue = priv->tx_queue;
- rx_queue = priv->rx_queue;
+ tx_queue = priv->tx_queue[0];
+ rx_queue = priv->rx_queue[0];
/* Set up rx coalescing */
if ((cvals->rx_coalesce_usecs == 0) ||
@@ -429,8 +431,8 @@ static void gfar_gringparam(struct net_device *dev, struct ethtool_ringparam *rv
struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar_priv_rx_q *rx_queue = NULL;
- tx_queue = priv->tx_queue;
- rx_queue = priv->rx_queue;
+ tx_queue = priv->tx_queue[0];
+ rx_queue = priv->rx_queue[0];
rvals->rx_max_pending = GFAR_RX_MAX_RING_SIZE;
rvals->rx_mini_max_pending = GFAR_RX_MAX_RING_SIZE;
@@ -453,9 +455,7 @@ static void gfar_gringparam(struct net_device *dev, struct ethtool_ringparam *rv
static int gfar_sringparam(struct net_device *dev, struct ethtool_ringparam *rvals)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar_priv_tx_q *tx_queue = NULL;
- struct gfar_priv_rx_q *rx_queue = NULL;
- int err = 0;
+ int err = 0, i = 0;
if (rvals->rx_pending > GFAR_RX_MAX_RING_SIZE)
return -EINVAL;
@@ -475,37 +475,41 @@ static int gfar_sringparam(struct net_device *dev, struct ethtool_ringparam *rva
return -EINVAL;
}
- tx_queue = priv->tx_queue;
- rx_queue = priv->rx_queue;
if (dev->flags & IFF_UP) {
unsigned long flags;
/* Halt TX and RX, and process the frames which
* have already been received */
- spin_lock_irqsave(&tx_queue->txlock, flags);
- spin_lock(&rx_queue->rxlock);
+ local_irq_save(flags);
+ lock_tx_qs(priv);
+ lock_rx_qs(priv);
gfar_halt(dev);
- spin_unlock(&rx_queue->rxlock);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
+ unlock_rx_qs(priv);
+ unlock_tx_qs(priv);
+ local_irq_restore(flags);
- gfar_clean_rx_ring(rx_queue, rx_queue->rx_ring_size);
+ for (i = 0; i < priv->num_rx_queues; i++)
+ gfar_clean_rx_ring(priv->rx_queue[i],
+ priv->rx_queue[i]->rx_ring_size);
/* Now we take down the rings to rebuild them */
stop_gfar(dev);
}
/* Change the size */
- rx_queue->rx_ring_size = rvals->rx_pending;
- tx_queue->tx_ring_size = rvals->tx_pending;
- tx_queue->num_txbdfree = tx_queue->tx_ring_size;
+ for (i = 0; i < priv->num_rx_queues; i++) {
+ priv->rx_queue[i]->rx_ring_size = rvals->rx_pending;
+ priv->tx_queue[i]->tx_ring_size = rvals->tx_pending;
+ priv->tx_queue[i]->num_txbdfree = priv->tx_queue[i]->tx_ring_size;
+ }
/* Rebuild the rings with the new size */
if (dev->flags & IFF_UP) {
err = startup_gfar(dev);
- netif_wake_queue(dev);
+ netif_tx_wake_all_queues(dev);
}
return err;
}
@@ -513,29 +517,29 @@ static int gfar_sringparam(struct net_device *dev, struct ethtool_ringparam *rva
static int gfar_set_rx_csum(struct net_device *dev, uint32_t data)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar_priv_rx_q *rx_queue = NULL;
- struct gfar_priv_tx_q *tx_queue = NULL;
unsigned long flags;
- int err = 0;
+ int err = 0, i = 0;
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
return -EOPNOTSUPP;
- tx_queue = priv->tx_queue;
- rx_queue = priv->rx_queue;
if (dev->flags & IFF_UP) {
/* Halt TX and RX, and process the frames which
* have already been received */
- spin_lock_irqsave(&tx_queue->txlock, flags);
- spin_lock(&rx_queue->rxlock);
+ local_irq_save(flags);
+ lock_tx_qs(priv);
+ lock_rx_qs(priv);
gfar_halt(dev);
- spin_unlock(&rx_queue->rxlock);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
+ unlock_tx_qs(priv);
+ unlock_rx_qs(priv);
+ local_irq_save(flags);
- gfar_clean_rx_ring(rx_queue, rx_queue->rx_ring_size);
+ for (i = 0; i < priv->num_rx_queues; i++)
+ gfar_clean_rx_ring(priv->rx_queue[i],
+ priv->rx_queue[i]->rx_ring_size);
/* Now we take down the rings to rebuild them */
stop_gfar(dev);
@@ -547,7 +551,7 @@ static int gfar_set_rx_csum(struct net_device *dev, uint32_t data)
if (dev->flags & IFF_UP) {
err = startup_gfar(dev);
- netif_wake_queue(dev);
+ netif_tx_wake_all_queues(dev);
}
return err;
}
diff --git a/drivers/net/gianfar_sysfs.c b/drivers/net/gianfar_sysfs.c
index adea11e..4b726f6 100644
--- a/drivers/net/gianfar_sysfs.c
+++ b/drivers/net/gianfar_sysfs.c
@@ -51,7 +51,6 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
struct gfar __iomem *regs = priv->gfargrp.regs;
- struct gfar_priv_rx_q *rx_queue = NULL;
int new_setting = 0;
u32 temp;
unsigned long flags;
@@ -59,7 +58,6 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BD_STASHING))
return count;
- rx_queue = priv->rx_queue;
/* Find out the new setting */
if (!strncmp("on", buf, count - 1) || !strncmp("1", buf, count - 1))
@@ -70,7 +68,9 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
else
return count;
- spin_lock_irqsave(&rx_queue->rxlock, flags);
+
+ local_irq_save(flags);
+ lock_rx_qs(priv);
/* Set the new stashing value */
priv->bd_stash_en = new_setting;
@@ -84,7 +84,8 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
gfar_write(®s->attr, temp);
- spin_unlock_irqrestore(&rx_queue->rxlock, flags);
+ unlock_rx_qs(priv);
+ local_irq_restore(flags);
return count;
}
@@ -105,7 +106,6 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
struct gfar __iomem *regs = priv->gfargrp.regs;
- struct gfar_priv_rx_q *rx_queue = NULL;
unsigned int length = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -113,9 +113,9 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
return count;
- rx_queue = priv->rx_queue;
+ local_irq_save(flags);
+ lock_rx_qs(priv);
- spin_lock_irqsave(&rx_queue->rxlock, flags);
if (length > priv->rx_buffer_size)
goto out;
@@ -140,7 +140,8 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
gfar_write(®s->attr, temp);
out:
- spin_unlock_irqrestore(&rx_queue->rxlock, flags);
+ unlock_rx_qs(priv);
+ local_irq_restore(flags);
return count;
}
@@ -164,7 +165,6 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
struct gfar __iomem *regs = priv->gfargrp.regs;
- struct gfar_priv_rx_q *rx_queue = NULL;
unsigned short index = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -172,9 +172,9 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
return count;
- rx_queue = priv->rx_queue;
+ local_irq_save(flags);
+ lock_rx_qs(priv);
- spin_lock_irqsave(&rx_queue->rxlock, flags);
if (index > priv->rx_stash_size)
goto out;
@@ -189,7 +189,8 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
gfar_write(®s->attreli, flags);
out:
- spin_unlock_irqrestore(&rx_queue->rxlock, flags);
+ unlock_rx_qs(priv);
+ local_irq_restore(flags);
return count;
}
@@ -212,7 +213,6 @@ static ssize_t gfar_set_fifo_threshold(struct device *dev,
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
struct gfar __iomem *regs = priv->gfargrp.regs;
- struct gfar_priv_tx_q *tx_queue = NULL;
unsigned int length = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -220,9 +220,8 @@ static ssize_t gfar_set_fifo_threshold(struct device *dev,
if (length > GFAR_MAX_FIFO_THRESHOLD)
return count;
- tx_queue = priv->tx_queue;
-
- spin_lock_irqsave(&tx_queue->txlock, flags);
+ local_irq_save(flags);
+ lock_tx_qs(priv);
priv->fifo_threshold = length;
@@ -231,7 +230,8 @@ static ssize_t gfar_set_fifo_threshold(struct device *dev,
temp |= length;
gfar_write(®s->fifo_tx_thr, temp);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
+ unlock_tx_qs(priv);
+ local_irq_restore(flags);
return count;
}
@@ -253,7 +253,6 @@ static ssize_t gfar_set_fifo_starve(struct device *dev,
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
struct gfar __iomem *regs = priv->gfargrp.regs;
- struct gfar_priv_tx_q *tx_queue = NULL;
unsigned int num = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -261,8 +260,8 @@ static ssize_t gfar_set_fifo_starve(struct device *dev,
if (num > GFAR_MAX_FIFO_STARVE)
return count;
- tx_queue = priv->tx_queue;
- spin_lock_irqsave(&tx_queue->txlock, flags);
+ local_irq_save(flags);
+ lock_tx_qs(priv);
priv->fifo_starve = num;
@@ -271,7 +270,8 @@ static ssize_t gfar_set_fifo_starve(struct device *dev,
temp |= num;
gfar_write(®s->fifo_tx_starve, temp);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
+ unlock_tx_qs(priv);
+ local_irq_restore(flags);
return count;
}
@@ -294,7 +294,6 @@ static ssize_t gfar_set_fifo_starve_off(struct device *dev,
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
struct gfar __iomem *regs = priv->gfargrp.regs;
- struct gfar_priv_tx_q *tx_queue = NULL;
unsigned int num = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -302,8 +301,8 @@ static ssize_t gfar_set_fifo_starve_off(struct device *dev,
if (num > GFAR_MAX_FIFO_STARVE_OFF)
return count;
- tx_queue = priv->tx_queue;
- spin_lock_irqsave(&tx_queue->txlock, flags);
+ local_irq_save(flags);
+ lock_tx_qs(priv);
priv->fifo_starve_off = num;
@@ -312,7 +311,8 @@ static ssize_t gfar_set_fifo_starve_off(struct device *dev,
temp |= num;
gfar_write(®s->fifo_tx_starve_shutoff, temp);
- spin_unlock_irqrestore(&tx_queue->txlock, flags);
+ unlock_tx_qs(priv);
+ local_irq_restore(flags);
return count;
}
--
1.5.2.2
^ permalink raw reply related
* [PATCH v0 4/7] fsl_pq_mdio: Add Suport for etsec2.0 devices.
From: Sandeep Gopalpet @ 2009-10-15 16:31 UTC (permalink / raw)
To: netdev; +Cc: Sandeep Gopalpet
This patch adds mdio support for etsec2.0 devices.
Modified the fsl_pq_mdio structure to include the new mdio
members.
Signed-off-by: Sandeep Gopalpet <sandeep.kumar@freescale.com>
---
drivers/net/fsl_pq_mdio.c | 59 ++++++++++++++++++++++++++++++++++++--------
drivers/net/fsl_pq_mdio.h | 11 +++++++-
2 files changed, 57 insertions(+), 13 deletions(-)
diff --git a/drivers/net/fsl_pq_mdio.c b/drivers/net/fsl_pq_mdio.c
index d167090..6de7b24 100644
--- a/drivers/net/fsl_pq_mdio.c
+++ b/drivers/net/fsl_pq_mdio.c
@@ -3,8 +3,9 @@
* Provides Bus interface for MIIM regs
*
* Author: Andy Fleming <afleming@freescale.com>
+ * Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
*
- * Copyright (c) 2002-2004,2008 Freescale Semiconductor, Inc.
+ * Copyright 2002-2004, 2008-2009 Freescale Semiconductor, Inc.
*
* Based on gianfar_mii.c and ucc_geth_mii.c (Li Yang, Kim Phillips)
*
@@ -189,19 +190,29 @@ static int fsl_pq_mdio_find_free(struct mii_bus *new_bus)
#if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE)
-static u32 __iomem *get_gfar_tbipa(struct fsl_pq_mdio __iomem *regs)
+static u32 __iomem *get_gfar_tbipa(struct fsl_pq_mdio __iomem *regs, struct device_node *np)
{
struct gfar __iomem *enet_regs;
+ u32 __iomem *ioremap_tbipa;
+ u64 addr, size;
/*
* This is mildly evil, but so is our hardware for doing this.
* Also, we have to cast back to struct gfar because of
* definition weirdness done in gianfar.h.
*/
- enet_regs = (struct gfar __iomem *)
- ((char __iomem *)regs - offsetof(struct gfar, gfar_mii_regs));
-
- return &enet_regs->tbipa;
+ if(of_device_is_compatible(np, "fsl,gianfar-mdio") ||
+ of_device_is_compatible(np, "fsl,gianfar-tbi") ||
+ of_device_is_compatible(np, "gianfar")) {
+ enet_regs = (struct gfar __iomem *)regs;
+ return &enet_regs->tbipa;
+ } else if (of_device_is_compatible(np, "fsl,etsec2-mdio") ||
+ of_device_is_compatible(np, "fsl,etsec2-tbi")) {
+ addr = of_translate_address(np, of_get_address(np, 1, &size, NULL));
+ ioremap_tbipa = ioremap(addr, size);
+ return ioremap_tbipa;
+ } else
+ return NULL;
}
#endif
@@ -250,11 +261,11 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
{
struct device_node *np = ofdev->node;
struct device_node *tbi;
- struct fsl_pq_mdio __iomem *regs;
+ struct fsl_pq_mdio __iomem *regs = NULL;
u32 __iomem *tbipa;
struct mii_bus *new_bus;
int tbiaddr = -1;
- u64 addr, size;
+ u64 addr = 0, size = 0, ioremap_miimcfg = 0;
int err = 0;
new_bus = mdiobus_alloc();
@@ -268,8 +279,22 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
fsl_pq_mdio_bus_name(new_bus->id, np);
/* Set the PHY base address */
- addr = of_translate_address(np, of_get_address(np, 0, &size, NULL));
- regs = ioremap(addr, size);
+ if (of_device_is_compatible(np,"fsl,gianfar-mdio") ||
+ of_device_is_compatible(np, "fsl,gianfar-tbi") ||
+ of_device_is_compatible(np, "fsl,ucc-mdio") ||
+ of_device_is_compatible(np,"ucc_geth_phy" )) {
+ addr = of_translate_address(np, of_get_address(np, 0, &size, NULL));
+ ioremap_miimcfg = container_of(addr, struct fsl_pq_mdio, miimcfg);
+ regs = ioremap(ioremap_miimcfg, size +
+ offsetof(struct fsl_pq_mdio, miimcfg));
+ } else if (of_device_is_compatible(np,"fsl,etsec2-mdio") ||
+ of_device_is_compatible(np, "fsl,etsec2-tbi")) {
+ addr = of_translate_address(np, of_get_address(np, 0, &size, NULL));
+ regs = ioremap(addr, size);
+ } else {
+ err = -EINVAL;
+ goto err_free_bus;
+ }
if (NULL == regs) {
err = -ENOMEM;
@@ -290,9 +315,15 @@ static int fsl_pq_mdio_probe(struct of_device *ofdev,
if (of_device_is_compatible(np, "fsl,gianfar-mdio") ||
of_device_is_compatible(np, "fsl,gianfar-tbi") ||
+ of_device_is_compatible(np, "fsl,etsec2-mdio") ||
+ of_device_is_compatible(np, "fsl,etsec2-tbi") ||
of_device_is_compatible(np, "gianfar")) {
#if defined(CONFIG_GIANFAR) || defined(CONFIG_GIANFAR_MODULE)
- tbipa = get_gfar_tbipa(regs);
+ tbipa = get_gfar_tbipa(regs, np);
+ if (!tbipa) {
+ err = -EINVAL;
+ goto err_free_irqs;
+ }
#else
err = -ENODEV;
goto err_free_irqs;
@@ -405,6 +436,12 @@ static struct of_device_id fsl_pq_mdio_match[] = {
{
.compatible = "fsl,gianfar-mdio",
},
+ {
+ .compatible = "fsl,etsec2-tbi",
+ },
+ {
+ .compatible = "fsl,etsec2-mdio",
+ },
{},
};
diff --git a/drivers/net/fsl_pq_mdio.h b/drivers/net/fsl_pq_mdio.h
index 36dad52..1f7d865 100644
--- a/drivers/net/fsl_pq_mdio.h
+++ b/drivers/net/fsl_pq_mdio.h
@@ -3,8 +3,9 @@
* Driver for the MDIO bus controller on Freescale PowerQUICC processors
*
* Author: Andy Fleming
+ * Modifier: Sandeep Gopalpet
*
- * Copyright (c) 2002-2004,2008 Freescale Semiconductor, Inc.
+ * Copyright 2002-2004, 2008-2009 Freescale Semiconductor, Inc.
*
* 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
@@ -23,6 +24,12 @@
#define MII_READ_COMMAND 0x00000001
struct fsl_pq_mdio {
+ u8 res1[16];
+ u32 ieventm; /* MDIO Interrupt event register (for etsec2)*/
+ u32 imaskm; /* MDIO Interrupt mask register (for etsec2)*/
+ u8 res2[4];
+ u32 emapm; /* MDIO Event mapping register (for etsec2)*/
+ u8 res3[1280];
u32 miimcfg; /* MII management configuration reg */
u32 miimcom; /* MII management command reg */
u32 miimadd; /* MII management address reg */
@@ -31,9 +38,9 @@ struct fsl_pq_mdio {
u32 miimind; /* MII management indication reg */
u8 reserved[28]; /* Space holder */
u32 utbipar; /* TBI phy address reg (only on UCC) */
+ u8 res4[2728];
} __attribute__ ((packed));
-
int fsl_pq_mdio_read(struct mii_bus *bus, int mii_id, int regnum);
int fsl_pq_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value);
int fsl_pq_local_mdio_write(struct fsl_pq_mdio __iomem *regs, int mii_id,
--
1.5.2.2
^ permalink raw reply related
* [PATCH v0 2/7] gianfar: Introduce logical group support.
From: Sandeep Gopalpet @ 2009-10-15 16:30 UTC (permalink / raw)
To: netdev; +Cc: Sandeep Gopalpet
This patch introduces the group structure. The elements of this
structure are the interrupt lines, their corresponding names,
the register memory map.
The elements for this group are factored out from the gfar_private
structure. The introduction of group structure will help in
providing support for newer versions of etsec.
Currently, the support is present only for single group and
single tx/rx queues.
Signed-off-by: Sandeep Gopalpet <sandeep.kumar@freescale.com>
---
drivers/net/gianfar.c | 368 ++++++++++++++++++++++-------------------
drivers/net/gianfar.h | 38 +++--
drivers/net/gianfar_ethtool.c | 14 +-
drivers/net/gianfar_sysfs.c | 34 +++--
4 files changed, 250 insertions(+), 204 deletions(-)
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 3fdccd4..8bee911 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -188,24 +188,25 @@ static int gfar_of_init(struct net_device *dev)
/* get a pointer to the register memory */
addr = of_translate_address(np, of_get_address(np, 0, &size, NULL));
- priv->regs = ioremap(addr, size);
+ priv->gfargrp.regs = ioremap(addr, size);
- if (priv->regs == NULL)
+ if (priv->gfargrp.regs == NULL)
return -ENOMEM;
- priv->interruptTransmit = irq_of_parse_and_map(np, 0);
+ priv->gfargrp.priv = priv; /* back pointer from group to priv */
+ priv->gfargrp.interruptTransmit = irq_of_parse_and_map(np, 0);
model = of_get_property(np, "model", NULL);
/* If we aren't the FEC we have multiple interrupts */
if (model && strcasecmp(model, "FEC")) {
- priv->interruptReceive = irq_of_parse_and_map(np, 1);
+ priv->gfargrp.interruptReceive = irq_of_parse_and_map(np, 1);
- priv->interruptError = irq_of_parse_and_map(np, 2);
+ priv->gfargrp.interruptError = irq_of_parse_and_map(np, 2);
- if (priv->interruptTransmit < 0 ||
- priv->interruptReceive < 0 ||
- priv->interruptError < 0) {
+ if (priv->gfargrp.interruptTransmit < 0 ||
+ priv->gfargrp.interruptReceive < 0 ||
+ priv->gfargrp.interruptError < 0) {
err = -EINVAL;
goto err_out;
}
@@ -272,7 +273,7 @@ static int gfar_of_init(struct net_device *dev)
return 0;
err_out:
- iounmap(priv->regs);
+ iounmap(priv->gfargrp.regs);
return err;
}
@@ -298,6 +299,7 @@ static int gfar_probe(struct of_device *ofdev,
u32 tempval;
struct net_device *dev = NULL;
struct gfar_private *priv = NULL;
+ struct gfar __iomem *regs = NULL;
int err = 0;
int len_devname;
@@ -330,32 +332,34 @@ static int gfar_probe(struct of_device *ofdev,
spin_lock_init(&priv->tx_queue->txlock);
spin_lock_init(&priv->rx_queue->rxlock);
+ spin_lock_init(&priv->gfargrp.grplock);
spin_lock_init(&priv->bflock);
INIT_WORK(&priv->reset_task, gfar_reset_task);
dev_set_drvdata(&ofdev->dev, priv);
+ regs = priv->gfargrp.regs;
/* Stop the DMA engine now, in case it was running before */
/* (The firmware could have used it, and left it running). */
gfar_halt(dev);
/* Reset MAC layer */
- gfar_write(&priv->regs->maccfg1, MACCFG1_SOFT_RESET);
+ gfar_write(®s->maccfg1, MACCFG1_SOFT_RESET);
/* We need to delay at least 3 TX clocks */
udelay(2);
tempval = (MACCFG1_TX_FLOW | MACCFG1_RX_FLOW);
- gfar_write(&priv->regs->maccfg1, tempval);
+ gfar_write(®s->maccfg1, tempval);
/* Initialize MACCFG2. */
- gfar_write(&priv->regs->maccfg2, MACCFG2_INIT_SETTINGS);
+ gfar_write(®s->maccfg2, MACCFG2_INIT_SETTINGS);
/* Initialize ECNTRL */
- gfar_write(&priv->regs->ecntrl, ECNTRL_INIT_SETTINGS);
+ gfar_write(®s->ecntrl, ECNTRL_INIT_SETTINGS);
/* Set the dev->base_addr to the gfar reg region */
- dev->base_addr = (unsigned long) (priv->regs);
+ dev->base_addr = (unsigned long) regs;
SET_NETDEV_DEV(dev, &ofdev->dev);
@@ -383,35 +387,35 @@ static int gfar_probe(struct of_device *ofdev,
priv->extended_hash = 1;
priv->hash_width = 9;
- priv->hash_regs[0] = &priv->regs->igaddr0;
- priv->hash_regs[1] = &priv->regs->igaddr1;
- priv->hash_regs[2] = &priv->regs->igaddr2;
- priv->hash_regs[3] = &priv->regs->igaddr3;
- priv->hash_regs[4] = &priv->regs->igaddr4;
- priv->hash_regs[5] = &priv->regs->igaddr5;
- priv->hash_regs[6] = &priv->regs->igaddr6;
- priv->hash_regs[7] = &priv->regs->igaddr7;
- priv->hash_regs[8] = &priv->regs->gaddr0;
- priv->hash_regs[9] = &priv->regs->gaddr1;
- priv->hash_regs[10] = &priv->regs->gaddr2;
- priv->hash_regs[11] = &priv->regs->gaddr3;
- priv->hash_regs[12] = &priv->regs->gaddr4;
- priv->hash_regs[13] = &priv->regs->gaddr5;
- priv->hash_regs[14] = &priv->regs->gaddr6;
- priv->hash_regs[15] = &priv->regs->gaddr7;
+ priv->hash_regs[0] = ®s->igaddr0;
+ priv->hash_regs[1] = ®s->igaddr1;
+ priv->hash_regs[2] = ®s->igaddr2;
+ priv->hash_regs[3] = ®s->igaddr3;
+ priv->hash_regs[4] = ®s->igaddr4;
+ priv->hash_regs[5] = ®s->igaddr5;
+ priv->hash_regs[6] = ®s->igaddr6;
+ priv->hash_regs[7] = ®s->igaddr7;
+ priv->hash_regs[8] = ®s->gaddr0;
+ priv->hash_regs[9] = ®s->gaddr1;
+ priv->hash_regs[10] = ®s->gaddr2;
+ priv->hash_regs[11] = ®s->gaddr3;
+ priv->hash_regs[12] = ®s->gaddr4;
+ priv->hash_regs[13] = ®s->gaddr5;
+ priv->hash_regs[14] = ®s->gaddr6;
+ priv->hash_regs[15] = ®s->gaddr7;
} else {
priv->extended_hash = 0;
priv->hash_width = 8;
- priv->hash_regs[0] = &priv->regs->gaddr0;
- priv->hash_regs[1] = &priv->regs->gaddr1;
- priv->hash_regs[2] = &priv->regs->gaddr2;
- priv->hash_regs[3] = &priv->regs->gaddr3;
- priv->hash_regs[4] = &priv->regs->gaddr4;
- priv->hash_regs[5] = &priv->regs->gaddr5;
- priv->hash_regs[6] = &priv->regs->gaddr6;
- priv->hash_regs[7] = &priv->regs->gaddr7;
+ priv->hash_regs[0] = ®s->gaddr0;
+ priv->hash_regs[1] = ®s->gaddr1;
+ priv->hash_regs[2] = ®s->gaddr2;
+ priv->hash_regs[3] = ®s->gaddr3;
+ priv->hash_regs[4] = ®s->gaddr4;
+ priv->hash_regs[5] = ®s->gaddr5;
+ priv->hash_regs[6] = ®s->gaddr6;
+ priv->hash_regs[7] = ®s->gaddr7;
}
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_PADDING)
@@ -453,20 +457,20 @@ static int gfar_probe(struct of_device *ofdev,
/* fill out IRQ number and name fields */
len_devname = strlen(dev->name);
- strncpy(&priv->int_name_tx[0], dev->name, len_devname);
+ strncpy(&priv->gfargrp.int_name_tx[0], dev->name, len_devname);
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
- strncpy(&priv->int_name_tx[len_devname],
+ strncpy(&priv->gfargrp.int_name_tx[len_devname],
"_tx", sizeof("_tx") + 1);
- strncpy(&priv->int_name_rx[0], dev->name, len_devname);
- strncpy(&priv->int_name_rx[len_devname],
+ strncpy(&priv->gfargrp.int_name_rx[0], dev->name, len_devname);
+ strncpy(&priv->gfargrp.int_name_rx[len_devname],
"_rx", sizeof("_rx") + 1);
- strncpy(&priv->int_name_er[0], dev->name, len_devname);
- strncpy(&priv->int_name_er[len_devname],
+ strncpy(&priv->gfargrp.int_name_er[0], dev->name, len_devname);
+ strncpy(&priv->gfargrp.int_name_er[len_devname],
"_er", sizeof("_er") + 1);
} else
- priv->int_name_tx[len_devname] = '\0';
+ priv->gfargrp.int_name_tx[len_devname] = '\0';
/* Create all the sysfs files */
gfar_init_sysfs(dev);
@@ -483,7 +487,7 @@ static int gfar_probe(struct of_device *ofdev,
return 0;
register_fail:
- iounmap(priv->regs);
+ iounmap(priv->gfargrp.regs);
kfree(priv->rx_queue);
rx_queue_fail:
kfree(priv->tx_queue);
@@ -508,7 +512,7 @@ static int gfar_remove(struct of_device *ofdev)
dev_set_drvdata(&ofdev->dev, NULL);
unregister_netdev(priv->ndev);
- iounmap(priv->regs);
+ iounmap(priv->gfargrp.regs);
free_netdev(priv->ndev);
return 0;
@@ -521,6 +525,7 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
struct net_device *dev = priv->ndev;
struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar_priv_rx_q *rx_queue = NULL;
+ struct gfar __iomem *regs = NULL;
unsigned long flags;
u32 tempval;
@@ -531,6 +536,7 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
tx_queue = priv->tx_queue;
rx_queue = priv->rx_queue;
+ regs = priv->gfargrp.regs;
if (netif_running(dev)) {
spin_lock_irqsave(&tx_queue->txlock, flags);
@@ -539,14 +545,14 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
gfar_halt_nodisable(dev);
/* Disable Tx, and Rx if wake-on-LAN is disabled. */
- tempval = gfar_read(&priv->regs->maccfg1);
+ tempval = gfar_read(®s->maccfg1);
tempval &= ~MACCFG1_TX_EN;
if (!magic_packet)
tempval &= ~MACCFG1_RX_EN;
- gfar_write(&priv->regs->maccfg1, tempval);
+ gfar_write(®s->maccfg1, tempval);
spin_unlock(&rx_queue->rxlock);
spin_unlock_irqrestore(&tx_queue->txlock, flags);
@@ -555,12 +561,12 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
if (magic_packet) {
/* Enable interrupt on Magic Packet */
- gfar_write(&priv->regs->imask, IMASK_MAG);
+ gfar_write(®s->imask, IMASK_MAG);
/* Enable Magic Packet mode */
- tempval = gfar_read(&priv->regs->maccfg2);
+ tempval = gfar_read(®s->maccfg2);
tempval |= MACCFG2_MPEN;
- gfar_write(&priv->regs->maccfg2, tempval);
+ gfar_write(®s->maccfg2, tempval);
} else {
phy_stop(priv->phydev);
}
@@ -575,6 +581,7 @@ static int gfar_resume(struct of_device *ofdev)
struct net_device *dev = priv->ndev;
struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar_priv_rx_q *rx_queue = NULL;
+ struct gfar __iomem *regs = NULL;
unsigned long flags;
u32 tempval;
int magic_packet = priv->wol_en &&
@@ -593,13 +600,14 @@ static int gfar_resume(struct of_device *ofdev)
*/
rx_queue = priv->rx_queue;
tx_queue = priv->tx_queue;
+ regs = priv->gfargrp.regs;
spin_lock_irqsave(&tx_queue->txlock, flags);
spin_lock(&rx_queue->rxlock);
- tempval = gfar_read(&priv->regs->maccfg2);
+ tempval = gfar_read(®s->maccfg2);
tempval &= ~MACCFG2_MPEN;
- gfar_write(&priv->regs->maccfg2, tempval);
+ gfar_write(®s->maccfg2, tempval);
gfar_start(dev);
@@ -623,7 +631,11 @@ static int gfar_resume(struct of_device *ofdev)
static phy_interface_t gfar_get_interface(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- u32 ecntrl = gfar_read(&priv->regs->ecntrl);
+ struct gfar __iomem *regs = NULL;
+ u32 ecntrl;
+
+ regs = priv->gfargrp.regs;
+ ecntrl = gfar_read(®s->ecntrl);
if (ecntrl & ECNTRL_SGMII_MODE)
return PHY_INTERFACE_MODE_SGMII;
@@ -745,46 +757,48 @@ static void gfar_configure_serdes(struct net_device *dev)
static void init_registers(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar __iomem *regs = NULL;
+ regs = priv->gfargrp.regs;
/* Clear IEVENT */
- gfar_write(&priv->regs->ievent, IEVENT_INIT_CLEAR);
+ gfar_write(®s->ievent, IEVENT_INIT_CLEAR);
/* Initialize IMASK */
- gfar_write(&priv->regs->imask, IMASK_INIT_CLEAR);
+ gfar_write(®s->imask, IMASK_INIT_CLEAR);
/* Init hash registers to zero */
- gfar_write(&priv->regs->igaddr0, 0);
- gfar_write(&priv->regs->igaddr1, 0);
- gfar_write(&priv->regs->igaddr2, 0);
- gfar_write(&priv->regs->igaddr3, 0);
- gfar_write(&priv->regs->igaddr4, 0);
- gfar_write(&priv->regs->igaddr5, 0);
- gfar_write(&priv->regs->igaddr6, 0);
- gfar_write(&priv->regs->igaddr7, 0);
-
- gfar_write(&priv->regs->gaddr0, 0);
- gfar_write(&priv->regs->gaddr1, 0);
- gfar_write(&priv->regs->gaddr2, 0);
- gfar_write(&priv->regs->gaddr3, 0);
- gfar_write(&priv->regs->gaddr4, 0);
- gfar_write(&priv->regs->gaddr5, 0);
- gfar_write(&priv->regs->gaddr6, 0);
- gfar_write(&priv->regs->gaddr7, 0);
+ gfar_write(®s->igaddr0, 0);
+ gfar_write(®s->igaddr1, 0);
+ gfar_write(®s->igaddr2, 0);
+ gfar_write(®s->igaddr3, 0);
+ gfar_write(®s->igaddr4, 0);
+ gfar_write(®s->igaddr5, 0);
+ gfar_write(®s->igaddr6, 0);
+ gfar_write(®s->igaddr7, 0);
+
+ gfar_write(®s->gaddr0, 0);
+ gfar_write(®s->gaddr1, 0);
+ gfar_write(®s->gaddr2, 0);
+ gfar_write(®s->gaddr3, 0);
+ gfar_write(®s->gaddr4, 0);
+ gfar_write(®s->gaddr5, 0);
+ gfar_write(®s->gaddr6, 0);
+ gfar_write(®s->gaddr7, 0);
/* Zero out the rmon mib registers if it has them */
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
- memset_io(&(priv->regs->rmon), 0, sizeof (struct rmon_mib));
+ memset_io(&(regs->rmon), 0, sizeof (struct rmon_mib));
/* Mask off the CAM interrupts */
- gfar_write(&priv->regs->rmon.cam1, 0xffffffff);
- gfar_write(&priv->regs->rmon.cam2, 0xffffffff);
+ gfar_write(®s->rmon.cam1, 0xffffffff);
+ gfar_write(®s->rmon.cam2, 0xffffffff);
}
/* Initialize the max receive buffer length */
- gfar_write(&priv->regs->mrblr, priv->rx_buffer_size);
+ gfar_write(®s->mrblr, priv->rx_buffer_size);
/* Initialize the Minimum Frame Length Register */
- gfar_write(&priv->regs->minflr, MINFLR_INIT_SETTINGS);
+ gfar_write(®s->minflr, MINFLR_INIT_SETTINGS);
}
@@ -792,7 +806,7 @@ static void init_registers(struct net_device *dev)
static void gfar_halt_nodisable(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->regs;
+ struct gfar __iomem *regs = priv->gfargrp.regs;
u32 tempval;
/* Mask all interrupts */
@@ -802,13 +816,13 @@ static void gfar_halt_nodisable(struct net_device *dev)
gfar_write(®s->ievent, IEVENT_INIT_CLEAR);
/* Stop the DMA, and wait for it to stop */
- tempval = gfar_read(&priv->regs->dmactrl);
+ tempval = gfar_read(®s->dmactrl);
if ((tempval & (DMACTRL_GRS | DMACTRL_GTS))
!= (DMACTRL_GRS | DMACTRL_GTS)) {
tempval |= (DMACTRL_GRS | DMACTRL_GTS);
- gfar_write(&priv->regs->dmactrl, tempval);
+ gfar_write(®s->dmactrl, tempval);
- while (!(gfar_read(&priv->regs->ievent) &
+ while (!(gfar_read(®s->ievent) &
(IEVENT_GRSC | IEVENT_GTSC)))
cpu_relax();
}
@@ -818,7 +832,7 @@ static void gfar_halt_nodisable(struct net_device *dev)
void gfar_halt(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->regs;
+ struct gfar __iomem *regs = priv->gfargrp.regs;
u32 tempval;
gfar_halt_nodisable(dev);
@@ -832,7 +846,7 @@ void gfar_halt(struct net_device *dev)
void stop_gfar(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->regs;
+ struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar_priv_rx_q *rx_queue = NULL;
unsigned long flags;
@@ -853,11 +867,11 @@ void stop_gfar(struct net_device *dev)
/* Free the IRQs */
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
- free_irq(priv->interruptError, dev);
- free_irq(priv->interruptTransmit, dev);
- free_irq(priv->interruptReceive, dev);
+ free_irq(priv->gfargrp.interruptError, &priv->gfargrp);
+ free_irq(priv->gfargrp.interruptTransmit, &priv->gfargrp);
+ free_irq(priv->gfargrp.interruptReceive, &priv->gfargrp);
} else {
- free_irq(priv->interruptTransmit, dev);
+ free_irq(priv->gfargrp.interruptTransmit, &priv->gfargrp);
}
free_skb_resources(priv);
@@ -931,7 +945,7 @@ static void free_skb_resources(struct gfar_private *priv)
void gfar_start(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->regs;
+ struct gfar __iomem *regs = priv->gfargrp.regs;
u32 tempval;
/* Enable Rx and Tx in MACCFG1 */
@@ -940,14 +954,14 @@ void gfar_start(struct net_device *dev)
gfar_write(®s->maccfg1, tempval);
/* Initialize DMACTRL to have WWR and WOP */
- tempval = gfar_read(&priv->regs->dmactrl);
+ tempval = gfar_read(®s->dmactrl);
tempval |= DMACTRL_INIT_SETTINGS;
- gfar_write(&priv->regs->dmactrl, tempval);
+ gfar_write(®s->dmactrl, tempval);
/* Make sure we aren't stopped */
- tempval = gfar_read(&priv->regs->dmactrl);
+ tempval = gfar_read(®s->dmactrl);
tempval &= ~(DMACTRL_GRS | DMACTRL_GTS);
- gfar_write(&priv->regs->dmactrl, tempval);
+ gfar_write(®s->dmactrl, tempval);
/* Clear THLT/RHLT, so that the DMA starts polling now */
gfar_write(®s->tstat, TSTAT_CLEAR_THALT);
@@ -970,7 +984,7 @@ int startup_gfar(struct net_device *dev)
struct gfar_private *priv = netdev_priv(dev);
struct gfar_priv_tx_q *tx_queue;
struct gfar_priv_rx_q *rx_queue;
- struct gfar __iomem *regs = priv->regs;
+ struct gfar __iomem *regs = priv->gfargrp.regs;
int err = 0;
u32 rctrl = 0;
u32 tctrl = 0;
@@ -1087,42 +1101,42 @@ int startup_gfar(struct net_device *dev)
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
/* Install our interrupt handlers for Error,
* Transmit, and Receive */
- if (request_irq(priv->interruptError, gfar_error,
- 0, priv->int_name_er, dev) < 0) {
+ if (request_irq(priv->gfargrp.interruptError, gfar_error,
+ 0, priv->gfargrp.int_name_er, &priv->gfargrp) < 0) {
if (netif_msg_intr(priv))
printk(KERN_ERR "%s: Can't get IRQ %d\n",
- dev->name, priv->interruptError);
+ dev->name, priv->gfargrp.interruptError);
err = -1;
goto err_irq_fail;
}
- if (request_irq(priv->interruptTransmit, gfar_transmit,
- 0, priv->int_name_tx, dev) < 0) {
+ if (request_irq(priv->gfargrp.interruptTransmit, gfar_transmit,
+ 0, priv->gfargrp.int_name_tx, &priv->gfargrp) < 0) {
if (netif_msg_intr(priv))
printk(KERN_ERR "%s: Can't get IRQ %d\n",
- dev->name, priv->interruptTransmit);
+ dev->name, priv->gfargrp.interruptTransmit);
err = -1;
goto tx_irq_fail;
}
- if (request_irq(priv->interruptReceive, gfar_receive,
- 0, priv->int_name_rx, dev) < 0) {
+ if (request_irq(priv->gfargrp.interruptReceive, gfar_receive,
+ 0, priv->gfargrp.int_name_rx, &priv->gfargrp) < 0) {
if (netif_msg_intr(priv))
printk(KERN_ERR "%s: Can't get IRQ %d (receive0)\n",
- dev->name, priv->interruptReceive);
+ dev->name, priv->gfargrp.interruptReceive);
err = -1;
goto rx_irq_fail;
}
} else {
- if (request_irq(priv->interruptTransmit, gfar_interrupt,
- 0, priv->int_name_tx, dev) < 0) {
+ if (request_irq(priv->gfargrp.interruptTransmit, gfar_interrupt,
+ 0, priv->gfargrp.int_name_tx, &priv->gfargrp) < 0) {
if (netif_msg_intr(priv))
printk(KERN_ERR "%s: Can't get IRQ %d\n",
- dev->name, priv->interruptTransmit);
+ dev->name, priv->gfargrp.interruptTransmit);
err = -1;
goto err_irq_fail;
@@ -1162,18 +1176,18 @@ int startup_gfar(struct net_device *dev)
}
/* Init rctrl based on our settings */
- gfar_write(&priv->regs->rctrl, rctrl);
+ gfar_write(®s->rctrl, rctrl);
if (dev->features & NETIF_F_IP_CSUM)
tctrl |= TCTRL_INIT_CSUM;
- gfar_write(&priv->regs->tctrl, tctrl);
+ gfar_write(®s->tctrl, tctrl);
/* Set the extraction length and index */
attrs = ATTRELI_EL(priv->rx_stash_size) |
ATTRELI_EI(priv->rx_stash_index);
- gfar_write(&priv->regs->attreli, attrs);
+ gfar_write(®s->attreli, attrs);
/* Start with defaults, and add stashing or locking
* depending on the approprate variables */
@@ -1185,11 +1199,11 @@ int startup_gfar(struct net_device *dev)
if (priv->rx_stash_size != 0)
attrs |= ATTR_BUFSTASH;
- gfar_write(&priv->regs->attr, attrs);
+ gfar_write(®s->attr, attrs);
- gfar_write(&priv->regs->fifo_tx_thr, priv->fifo_threshold);
- gfar_write(&priv->regs->fifo_tx_starve, priv->fifo_starve);
- gfar_write(&priv->regs->fifo_tx_starve_shutoff, priv->fifo_starve_off);
+ gfar_write(®s->fifo_tx_thr, priv->fifo_threshold);
+ gfar_write(®s->fifo_tx_starve, priv->fifo_starve);
+ gfar_write(®s->fifo_tx_starve_shutoff, priv->fifo_starve_off);
/* Start the controller */
gfar_start(dev);
@@ -1197,9 +1211,9 @@ int startup_gfar(struct net_device *dev)
return 0;
rx_irq_fail:
- free_irq(priv->interruptTransmit, dev);
+ free_irq(priv->gfargrp.interruptTransmit, &priv->gfargrp);
tx_irq_fail:
- free_irq(priv->interruptError, dev);
+ free_irq(priv->gfargrp.interruptError, &priv->gfargrp);
err_irq_fail:
err_rxalloc_fail:
rx_skb_fail:
@@ -1313,6 +1327,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar __iomem *regs = NULL;
struct txfcb *fcb = NULL;
struct txbd8 *txbdp, *txbdp_start, *base;
u32 lstatus;
@@ -1323,6 +1338,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
tx_queue = priv->tx_queue;
base = tx_queue->tx_bd_base;
+ regs = priv->gfargrp.regs;
/* make space for additional header when fcb is needed */
if (((skb->ip_summed == CHECKSUM_PARTIAL) ||
@@ -1446,7 +1462,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
}
/* Tell the DMA to go go go */
- gfar_write(&priv->regs->tstat, TSTAT_CLEAR_THALT);
+ gfar_write(®s->tstat, TSTAT_CLEAR_THALT);
/* Unlock priv */
spin_unlock_irqrestore(&tx_queue->txlock, flags);
@@ -1489,40 +1505,42 @@ static void gfar_vlan_rx_register(struct net_device *dev,
{
struct gfar_private *priv = netdev_priv(dev);
struct gfar_priv_rx_q *rx_queue = NULL;
+ struct gfar __iomem *regs = NULL;
unsigned long flags;
u32 tempval;
rx_queue = priv->rx_queue;
+ regs = priv->gfargrp.regs;
spin_lock_irqsave(&rx_queue->rxlock, flags);
priv->vlgrp = grp;
if (grp) {
/* Enable VLAN tag insertion */
- tempval = gfar_read(&priv->regs->tctrl);
+ tempval = gfar_read(®s->tctrl);
tempval |= TCTRL_VLINS;
- gfar_write(&priv->regs->tctrl, tempval);
+ gfar_write(®s->tctrl, tempval);
/* Enable VLAN tag extraction */
- tempval = gfar_read(&priv->regs->rctrl);
+ tempval = gfar_read(®s->rctrl);
tempval |= (RCTRL_VLEX | RCTRL_PRSDEP_INIT);
- gfar_write(&priv->regs->rctrl, tempval);
+ gfar_write(®s->rctrl, tempval);
} else {
/* Disable VLAN tag insertion */
- tempval = gfar_read(&priv->regs->tctrl);
+ tempval = gfar_read(®s->tctrl);
tempval &= ~TCTRL_VLINS;
- gfar_write(&priv->regs->tctrl, tempval);
+ gfar_write(®s->tctrl, tempval);
/* Disable VLAN tag extraction */
- tempval = gfar_read(&priv->regs->rctrl);
+ tempval = gfar_read(®s->rctrl);
tempval &= ~RCTRL_VLEX;
/* If parse is no longer required, then disable parser */
if (tempval & RCTRL_REQ_PARSER)
tempval |= RCTRL_PRSDEP_INIT;
else
tempval &= ~RCTRL_PRSDEP_INIT;
- gfar_write(&priv->regs->rctrl, tempval);
+ gfar_write(®s->rctrl, tempval);
}
gfar_change_mtu(dev, dev->mtu);
@@ -1534,6 +1552,7 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu)
{
int tempsize, tempval;
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar __iomem *regs = priv->gfargrp.regs;
int oldsize = priv->rx_buffer_size;
int frame_size = new_mtu + ETH_HLEN;
@@ -1565,20 +1584,20 @@ static int gfar_change_mtu(struct net_device *dev, int new_mtu)
dev->mtu = new_mtu;
- gfar_write(&priv->regs->mrblr, priv->rx_buffer_size);
- gfar_write(&priv->regs->maxfrm, priv->rx_buffer_size);
+ gfar_write(®s->mrblr, priv->rx_buffer_size);
+ gfar_write(®s->maxfrm, priv->rx_buffer_size);
/* If the mtu is larger than the max size for standard
* ethernet frames (ie, a jumbo frame), then set maccfg2
* to allow huge frames, and to check the length */
- tempval = gfar_read(&priv->regs->maccfg2);
+ tempval = gfar_read(®s->maccfg2);
if (priv->rx_buffer_size > DEFAULT_RX_BUFFER_SIZE)
tempval |= (MACCFG2_HUGEFRAME | MACCFG2_LENGTHCHECK);
else
tempval &= ~(MACCFG2_HUGEFRAME | MACCFG2_LENGTHCHECK);
- gfar_write(&priv->regs->maccfg2, tempval);
+ gfar_write(®s->maccfg2, tempval);
if ((oldsize != tempsize) && (dev->flags & IFF_UP))
startup_gfar(dev);
@@ -1697,9 +1716,9 @@ static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
return howmany;
}
-static void gfar_schedule_cleanup(struct net_device *dev)
+static void gfar_schedule_cleanup(struct gfar_priv_grp *gfargrp)
{
- struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_private *priv = gfargrp->priv;
struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar_priv_rx_q *rx_queue = NULL;
unsigned long flags;
@@ -1710,14 +1729,14 @@ static void gfar_schedule_cleanup(struct net_device *dev)
spin_lock(&rx_queue->rxlock);
if (napi_schedule_prep(&rx_queue->napi)) {
- gfar_write(&priv->regs->imask, IMASK_RTX_DISABLED);
+ gfar_write(&gfargrp->regs->imask, IMASK_RTX_DISABLED);
__napi_schedule(&rx_queue->napi);
} else {
/*
* Clear IEVENT, so interrupts aren't called again
* because of the packets that have already arrived.
*/
- gfar_write(&priv->regs->ievent, IEVENT_RTX_MASK);
+ gfar_write(&gfargrp->regs->ievent, IEVENT_RTX_MASK);
}
spin_unlock(&rx_queue->rxlock);
@@ -1725,9 +1744,9 @@ static void gfar_schedule_cleanup(struct net_device *dev)
}
/* Interrupt Handler for Transmit complete */
-static irqreturn_t gfar_transmit(int irq, void *dev_id)
+static irqreturn_t gfar_transmit(int irq, void *grp_id)
{
- gfar_schedule_cleanup((struct net_device *)dev_id);
+ gfar_schedule_cleanup((struct gfar_priv_grp *)grp_id);
return IRQ_HANDLED;
}
@@ -1815,9 +1834,9 @@ static inline void count_errors(unsigned short status, struct net_device *dev)
}
}
-irqreturn_t gfar_receive(int irq, void *dev_id)
+irqreturn_t gfar_receive(int irq, void *grp_id)
{
- gfar_schedule_cleanup((struct net_device *)dev_id);
+ gfar_schedule_cleanup((struct gfar_priv_grp *)grp_id);
return IRQ_HANDLED;
}
@@ -1971,6 +1990,7 @@ static int gfar_poll(struct napi_struct *napi, int budget)
struct gfar_priv_rx_q, napi);
struct net_device *dev = rx_queue->dev;
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_tx_q *tx_queue = NULL;
int tx_cleaned = 0;
int rx_cleaned = 0;
@@ -1978,7 +1998,7 @@ static int gfar_poll(struct napi_struct *napi, int budget)
/* Clear IEVENT, so interrupts aren't called again
* because of the packets that have already arrived */
- gfar_write(&priv->regs->ievent, IEVENT_RTX_MASK);
+ gfar_write(®s->ievent, IEVENT_RTX_MASK);
tx_queue = priv->tx_queue;
/* If we fail to get the lock, don't bother with the TX BDs */
@@ -1996,19 +2016,19 @@ static int gfar_poll(struct napi_struct *napi, int budget)
napi_complete(napi);
/* Clear the halt bit in RSTAT */
- gfar_write(&priv->regs->rstat, RSTAT_CLEAR_RHALT);
+ gfar_write(®s->rstat, RSTAT_CLEAR_RHALT);
- gfar_write(&priv->regs->imask, IMASK_DEFAULT);
+ gfar_write(®s->imask, IMASK_DEFAULT);
/* If we are coalescing interrupts, update the timer */
/* Otherwise, clear it */
if (likely(rx_queue->rxcoalescing)) {
- gfar_write(&priv->regs->rxic, 0);
- gfar_write(&priv->regs->rxic, rx_queue->rxic);
+ gfar_write(®s->rxic, 0);
+ gfar_write(®s->rxic, rx_queue->rxic);
}
if (likely(tx_queue->txcoalescing)) {
- gfar_write(&priv->regs->txic, 0);
- gfar_write(&priv->regs->txic, tx_queue->txic);
+ gfar_write(®s->txic, 0);
+ gfar_write(®s->txic, tx_queue->txic);
}
}
@@ -2027,41 +2047,40 @@ static void gfar_netpoll(struct net_device *dev)
/* If the device has multiple interrupts, run tx/rx */
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
- disable_irq(priv->interruptTransmit);
- disable_irq(priv->interruptReceive);
- disable_irq(priv->interruptError);
- gfar_interrupt(priv->interruptTransmit, dev);
- enable_irq(priv->interruptError);
- enable_irq(priv->interruptReceive);
- enable_irq(priv->interruptTransmit);
+ disable_irq(priv->gfargrp.interruptTransmit);
+ disable_irq(priv->gfargrp.interruptReceive);
+ disable_irq(priv->gfargrp.interruptError);
+ gfar_interrupt(priv->gfargrp.interruptTransmit, &priv->gfargrp);
+ enable_irq(priv->gfargrp.interruptError);
+ enable_irq(priv->gfargrp.interruptReceive);
+ enable_irq(priv->gfargrp.interruptTransmit);
} else {
- disable_irq(priv->interruptTransmit);
- gfar_interrupt(priv->interruptTransmit, dev);
- enable_irq(priv->interruptTransmit);
+ disable_irq(priv->gfargrp.interruptTransmit);
+ gfar_interrupt(priv->gfargrp.interruptTransmit, &priv->gfargrp);
+ enable_irq(priv->gfargrp.interruptTransmit);
}
}
#endif
/* The interrupt handler for devices with one interrupt */
-static irqreturn_t gfar_interrupt(int irq, void *dev_id)
+static irqreturn_t gfar_interrupt(int irq, void *grp_id)
{
- struct net_device *dev = dev_id;
- struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_grp *gfargrp = grp_id;
/* Save ievent for future reference */
- u32 events = gfar_read(&priv->regs->ievent);
+ u32 events = gfar_read(&gfargrp->regs->ievent);
/* Check for reception */
if (events & IEVENT_RX_MASK)
- gfar_receive(irq, dev_id);
+ gfar_receive(irq, grp_id);
/* Check for transmit completion */
if (events & IEVENT_TX_MASK)
- gfar_transmit(irq, dev_id);
+ gfar_transmit(irq, grp_id);
/* Check for errors */
if (events & IEVENT_ERR_MASK)
- gfar_error(irq, dev_id);
+ gfar_error(irq, grp_id);
return IRQ_HANDLED;
}
@@ -2076,7 +2095,7 @@ static void adjust_link(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
struct gfar_priv_tx_q *tx_queue = NULL;
- struct gfar __iomem *regs = priv->regs;
+ struct gfar __iomem *regs = priv->gfargrp.regs;
unsigned long flags;
struct phy_device *phydev = priv->phydev;
int new_state = 0;
@@ -2159,7 +2178,7 @@ static void gfar_set_multi(struct net_device *dev)
{
struct dev_mc_list *mc_ptr;
struct gfar_private *priv = netdev_priv(dev);
- struct gfar __iomem *regs = priv->regs;
+ struct gfar __iomem *regs = priv->gfargrp.regs;
u32 tempval;
if (dev->flags & IFF_PROMISC) {
@@ -2292,10 +2311,11 @@ static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr)
static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar __iomem *regs = priv->gfargrp.regs;
int idx;
char tmpbuf[MAC_ADDR_LEN];
u32 tempval;
- u32 __iomem *macptr = &priv->regs->macstnaddr1;
+ u32 __iomem *macptr = ®s->macstnaddr1;
macptr += num*2;
@@ -2312,16 +2332,18 @@ static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr)
}
/* GFAR error interrupt handler */
-static irqreturn_t gfar_error(int irq, void *dev_id)
+static irqreturn_t gfar_error(int irq, void *grp_id)
{
- struct net_device *dev = dev_id;
- struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_grp *gfargrp = grp_id;
+ struct gfar __iomem *regs = gfargrp->regs;
+ struct gfar_private *priv= gfargrp->priv;
+ struct net_device *dev = priv->ndev;
/* Save ievent for future reference */
- u32 events = gfar_read(&priv->regs->ievent);
+ u32 events = gfar_read(®s->ievent);
/* Clear IEVENT */
- gfar_write(&priv->regs->ievent, events & IEVENT_ERR_MASK);
+ gfar_write(®s->ievent, events & IEVENT_ERR_MASK);
/* Magic Packet is not an error. */
if ((priv->device_flags & FSL_GIANFAR_DEV_HAS_MAGIC_PACKET) &&
@@ -2331,7 +2353,7 @@ static irqreturn_t gfar_error(int irq, void *dev_id)
/* Hmm... */
if (netif_msg_rx_err(priv) || netif_msg_tx_err(priv))
printk(KERN_DEBUG "%s: error interrupt (ievent=0x%08x imask=0x%08x)\n",
- dev->name, events, gfar_read(&priv->regs->imask));
+ dev->name, events, gfar_read(®s->imask));
/* Update the error counters */
if (events & IEVENT_TXE) {
@@ -2349,7 +2371,7 @@ static irqreturn_t gfar_error(int irq, void *dev_id)
priv->extra_stats.tx_underrun++;
/* Reactivate the Tx Queues */
- gfar_write(&priv->regs->tstat, TSTAT_CLEAR_THALT);
+ gfar_write(®s->tstat, TSTAT_CLEAR_THALT);
}
if (netif_msg_tx_err(priv))
printk(KERN_DEBUG "%s: Transmit Error\n", dev->name);
@@ -2358,11 +2380,11 @@ static irqreturn_t gfar_error(int irq, void *dev_id)
dev->stats.rx_errors++;
priv->extra_stats.rx_bsy++;
- gfar_receive(irq, dev_id);
+ gfar_receive(irq, grp_id);
if (netif_msg_rx_err(priv))
printk(KERN_DEBUG "%s: busy error (rstat: %x)\n",
- dev->name, gfar_read(&priv->regs->rstat));
+ dev->name, gfar_read(®s->rstat));
}
if (events & IEVENT_BABR) {
dev->stats.rx_errors++;
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index 8bb77f1..440f17c 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -769,6 +769,32 @@ struct gfar_priv_rx_q {
unsigned long rxic;
};
+/**
+ * struct gfar_priv_grp - per group structure
+ * @priv: back pointer to the priv structure
+ * @regs: the ioremapped register space for this group
+ * @grp_id: group id for this group
+ * @interruptTransmit: The TX interrupt number for this group
+ * @interruptReceive: The RX interrupt number for this group
+ * @interruptError: The ERROR interrupt number for this group
+ * @int_name_tx: tx interrupt name for this group
+ * @int_name_rx: rx interrupt name for this group
+ * @int_name_er: er interrupt name for this group
+ */
+
+struct gfar_priv_grp {
+ spinlock_t grplock __attribute__ ((aligned (SMP_CACHE_BYTES)));
+ struct gfar_private *priv;
+ struct gfar __iomem *regs;
+ unsigned int interruptTransmit;
+ unsigned int interruptReceive;
+ unsigned int interruptError;
+
+ char int_name_tx[GFAR_INT_NAME_MAX];
+ char int_name_rx[GFAR_INT_NAME_MAX];
+ char int_name_er[GFAR_INT_NAME_MAX];
+};
+
/* Struct stolen almost completely (and shamelessly) from the FCC enet source
* (Ok, that's not so true anymore, but there is a family resemblence)
* The GFAR buffer descriptors track the ring buffers. The rx_bd_base
@@ -784,6 +810,7 @@ struct gfar_private {
struct net_device *ndev;
struct of_device *ofdev;
+ struct gfar_priv_grp gfargrp;
struct gfar_priv_tx_q *tx_queue;
struct gfar_priv_rx_q *rx_queue;
@@ -796,9 +823,6 @@ struct gfar_private {
struct vlan_group *vlgrp;
- /* Unprotected fields */
- /* Pointer to the GFAR memory mapped Registers */
- struct gfar __iomem *regs;
/* Hash registers and their width */
u32 __iomem *hash_regs[16];
@@ -822,10 +846,6 @@ struct gfar_private {
wol_en:1; /* Wake-on-LAN enabled */
unsigned short padding;
- unsigned int interruptTransmit;
- unsigned int interruptReceive;
- unsigned int interruptError;
-
/* PHY stuff */
struct phy_device *phydev;
struct mii_bus *mii_bus;
@@ -837,10 +857,6 @@ struct gfar_private {
struct work_struct reset_task;
- char int_name_tx[GFAR_INT_NAME_MAX];
- char int_name_rx[GFAR_INT_NAME_MAX];
- char int_name_er[GFAR_INT_NAME_MAX];
-
/* Network Statistics */
struct gfar_extra_stats extra_stats;
};
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index 6d0d171..c681b41 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -137,10 +137,11 @@ static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy,
{
int i;
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar __iomem *regs = priv->gfargrp.regs;
u64 *extra = (u64 *) & priv->extra_stats;
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
- u32 __iomem *rmon = (u32 __iomem *) & priv->regs->rmon;
+ u32 __iomem *rmon = (u32 __iomem *) ®s->rmon;
struct gfar_stats *stats = (struct gfar_stats *) buf;
for (i = 0; i < GFAR_RMON_LEN; i++)
@@ -223,7 +224,7 @@ static void gfar_get_regs(struct net_device *dev, struct ethtool_regs *regs, voi
{
int i;
struct gfar_private *priv = netdev_priv(dev);
- u32 __iomem *theregs = (u32 __iomem *) priv->regs;
+ u32 __iomem *theregs = (u32 __iomem *) priv->gfargrp.regs;
u32 *buf = (u32 *) regbuf;
for (i = 0; i < sizeof (struct gfar) / sizeof (u32); i++)
@@ -349,6 +350,7 @@ static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar_priv_rx_q *rx_queue = NULL;
@@ -407,13 +409,13 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
tx_queue->txic = mk_ic_value(cvals->tx_max_coalesced_frames,
gfar_usecs2ticks(priv, cvals->tx_coalesce_usecs));
- gfar_write(&priv->regs->rxic, 0);
+ gfar_write(®s->rxic, 0);
if (rx_queue->rxcoalescing)
- gfar_write(&priv->regs->rxic, rx_queue->rxic);
+ gfar_write(®s->rxic, rx_queue->rxic);
- gfar_write(&priv->regs->txic, 0);
+ gfar_write(®s->txic, 0);
if (tx_queue->txcoalescing)
- gfar_write(&priv->regs->txic, tx_queue->txic);
+ gfar_write(®s->txic, tx_queue->txic);
return 0;
}
diff --git a/drivers/net/gianfar_sysfs.c b/drivers/net/gianfar_sysfs.c
index 9c664f8..adea11e 100644
--- a/drivers/net/gianfar_sysfs.c
+++ b/drivers/net/gianfar_sysfs.c
@@ -50,6 +50,7 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_rx_q *rx_queue = NULL;
int new_setting = 0;
u32 temp;
@@ -74,14 +75,14 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
/* Set the new stashing value */
priv->bd_stash_en = new_setting;
- temp = gfar_read(&priv->regs->attr);
+ temp = gfar_read(®s->attr);
if (new_setting)
temp |= ATTR_BDSTASH;
else
temp &= ~(ATTR_BDSTASH);
- gfar_write(&priv->regs->attr, temp);
+ gfar_write(®s->attr, temp);
spin_unlock_irqrestore(&rx_queue->rxlock, flags);
@@ -103,6 +104,7 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_rx_q *rx_queue = NULL;
unsigned int length = simple_strtoul(buf, NULL, 0);
u32 temp;
@@ -122,20 +124,20 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
priv->rx_stash_size = length;
- temp = gfar_read(&priv->regs->attreli);
+ temp = gfar_read(®s->attreli);
temp &= ~ATTRELI_EL_MASK;
temp |= ATTRELI_EL(length);
- gfar_write(&priv->regs->attreli, temp);
+ gfar_write(®s->attreli, temp);
/* Turn stashing on/off as appropriate */
- temp = gfar_read(&priv->regs->attr);
+ temp = gfar_read(®s->attr);
if (length)
temp |= ATTR_BUFSTASH;
else
temp &= ~(ATTR_BUFSTASH);
- gfar_write(&priv->regs->attr, temp);
+ gfar_write(®s->attr, temp);
out:
spin_unlock_irqrestore(&rx_queue->rxlock, flags);
@@ -161,6 +163,7 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_rx_q *rx_queue = NULL;
unsigned short index = simple_strtoul(buf, NULL, 0);
u32 temp;
@@ -180,10 +183,10 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
priv->rx_stash_index = index;
- temp = gfar_read(&priv->regs->attreli);
+ temp = gfar_read(®s->attreli);
temp &= ~ATTRELI_EI_MASK;
temp |= ATTRELI_EI(index);
- gfar_write(&priv->regs->attreli, flags);
+ gfar_write(®s->attreli, flags);
out:
spin_unlock_irqrestore(&rx_queue->rxlock, flags);
@@ -208,6 +211,7 @@ static ssize_t gfar_set_fifo_threshold(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_tx_q *tx_queue = NULL;
unsigned int length = simple_strtoul(buf, NULL, 0);
u32 temp;
@@ -222,10 +226,10 @@ static ssize_t gfar_set_fifo_threshold(struct device *dev,
priv->fifo_threshold = length;
- temp = gfar_read(&priv->regs->fifo_tx_thr);
+ temp = gfar_read(®s->fifo_tx_thr);
temp &= ~FIFO_TX_THR_MASK;
temp |= length;
- gfar_write(&priv->regs->fifo_tx_thr, temp);
+ gfar_write(®s->fifo_tx_thr, temp);
spin_unlock_irqrestore(&tx_queue->txlock, flags);
@@ -248,6 +252,7 @@ static ssize_t gfar_set_fifo_starve(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_tx_q *tx_queue = NULL;
unsigned int num = simple_strtoul(buf, NULL, 0);
u32 temp;
@@ -261,10 +266,10 @@ static ssize_t gfar_set_fifo_starve(struct device *dev,
priv->fifo_starve = num;
- temp = gfar_read(&priv->regs->fifo_tx_starve);
+ temp = gfar_read(®s->fifo_tx_starve);
temp &= ~FIFO_TX_STARVE_MASK;
temp |= num;
- gfar_write(&priv->regs->fifo_tx_starve, temp);
+ gfar_write(®s->fifo_tx_starve, temp);
spin_unlock_irqrestore(&tx_queue->txlock, flags);
@@ -288,6 +293,7 @@ static ssize_t gfar_set_fifo_starve_off(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar __iomem *regs = priv->gfargrp.regs;
struct gfar_priv_tx_q *tx_queue = NULL;
unsigned int num = simple_strtoul(buf, NULL, 0);
u32 temp;
@@ -301,10 +307,10 @@ static ssize_t gfar_set_fifo_starve_off(struct device *dev,
priv->fifo_starve_off = num;
- temp = gfar_read(&priv->regs->fifo_tx_starve_shutoff);
+ temp = gfar_read(®s->fifo_tx_starve_shutoff);
temp &= ~FIFO_TX_STARVE_OFF_MASK;
temp |= num;
- gfar_write(&priv->regs->fifo_tx_starve_shutoff, temp);
+ gfar_write(®s->fifo_tx_starve_shutoff, temp);
spin_unlock_irqrestore(&tx_queue->txlock, flags);
--
1.5.2.2
^ permalink raw reply related
* [PATCH v0 1/7] gianfar: Add per queue structure support
From: Sandeep Gopalpet @ 2009-10-15 16:30 UTC (permalink / raw)
To: netdev; +Cc: Sandeep Gopalpet
This patch introduces per tx and per rx queue structures.
Earlier the members of these structures were inside the
gfar_private structure.
Moving forward if we want to support multiple queues, we need
to refactor the gfar_private structure so that introduction of
multiple queues is easier.
Signed-off-by: Sandeep Gopalpet <sandeep.kumar@freescale.com>
---
drivers/net/gianfar.c | 362 ++++++++++++++++++++++++-----------------
drivers/net/gianfar.h | 114 +++++++++-----
drivers/net/gianfar_ethtool.c | 100 ++++++++----
drivers/net/gianfar_sysfs.c | 43 ++++--
4 files changed, 381 insertions(+), 238 deletions(-)
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 1e5289f..3fdccd4 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -8,9 +8,10 @@
*
* Author: Andy Fleming
* Maintainer: Kumar Gala
+ * Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
*
- * Copyright (c) 2002-2006 Freescale Semiconductor, Inc.
- * Copyright (c) 2007 MontaVista Software, Inc.
+ * Copyright 2002-2009 Freescale Semiconductor, Inc.
+ * Copyright 2007 MontaVista Software, Inc.
*
* 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
@@ -109,7 +110,7 @@ static void gfar_reset_task(struct work_struct *work);
static void gfar_timeout(struct net_device *dev);
static int gfar_close(struct net_device *dev);
struct sk_buff *gfar_new_skb(struct net_device *dev);
-static void gfar_new_rxbdp(struct net_device *dev, struct rxbd8 *bdp,
+static void gfar_new_rxbdp(struct gfar_priv_rx_q *rx_queue, struct rxbd8 *bdp,
struct sk_buff *skb);
static int gfar_set_mac_address(struct net_device *dev);
static int gfar_change_mtu(struct net_device *dev, int new_mtu);
@@ -130,8 +131,8 @@ static int gfar_poll(struct napi_struct *napi, int budget);
#ifdef CONFIG_NET_POLL_CONTROLLER
static void gfar_netpoll(struct net_device *dev);
#endif
-int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit);
-static int gfar_clean_tx_ring(struct net_device *dev);
+int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit);
+static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue);
static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
int amount_pull);
static void gfar_vlan_rx_register(struct net_device *netdev,
@@ -212,7 +213,7 @@ static int gfar_of_init(struct net_device *dev)
stash = of_get_property(np, "bd-stash", NULL);
- if(stash) {
+ if (stash) {
priv->device_flags |= FSL_GIANFAR_DEV_HAS_BD_STASHING;
priv->bd_stash_en = 1;
}
@@ -317,8 +318,18 @@ static int gfar_probe(struct of_device *ofdev,
if (err)
goto regs_fail;
- spin_lock_init(&priv->txlock);
- spin_lock_init(&priv->rxlock);
+ priv->tx_queue = (struct gfar_priv_tx_q *)kmalloc(
+ sizeof (struct gfar_priv_tx_q), GFP_KERNEL);
+ if (!priv->tx_queue)
+ goto regs_fail;
+
+ priv->rx_queue = (struct gfar_priv_rx_q *)kmalloc(
+ sizeof (struct gfar_priv_rx_q), GFP_KERNEL);
+ if (!priv->rx_queue)
+ goto rx_queue_fail;
+
+ spin_lock_init(&priv->tx_queue->txlock);
+ spin_lock_init(&priv->rx_queue->rxlock);
spin_lock_init(&priv->bflock);
INIT_WORK(&priv->reset_task, gfar_reset_task);
@@ -350,12 +361,13 @@ static int gfar_probe(struct of_device *ofdev,
/* Fill in the dev structure */
dev->watchdog_timeo = TX_TIMEOUT;
- netif_napi_add(dev, &priv->napi, gfar_poll, GFAR_DEV_WEIGHT);
dev->mtu = 1500;
-
dev->netdev_ops = &gfar_netdev_ops;
dev->ethtool_ops = &gfar_ethtool_ops;
+ /* Register for napi ...NAPI is for each rx_queue */
+ netif_napi_add(dev, &priv->rx_queue->napi, gfar_poll, GFAR_DEV_WEIGHT);
+
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
priv->rx_csum_enable = 1;
dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_HIGHDMA;
@@ -411,14 +423,16 @@ static int gfar_probe(struct of_device *ofdev,
dev->hard_header_len += GMAC_FCB_LEN;
priv->rx_buffer_size = DEFAULT_RX_BUFFER_SIZE;
- priv->tx_ring_size = DEFAULT_TX_RING_SIZE;
- priv->rx_ring_size = DEFAULT_RX_RING_SIZE;
- priv->num_txbdfree = DEFAULT_TX_RING_SIZE;
- priv->txcoalescing = DEFAULT_TX_COALESCE;
- priv->txic = DEFAULT_TXIC;
- priv->rxcoalescing = DEFAULT_RX_COALESCE;
- priv->rxic = DEFAULT_RXIC;
+ /* Initializing some of the rx/tx queue level parameters */
+ priv->tx_queue->tx_ring_size = DEFAULT_TX_RING_SIZE;
+ priv->tx_queue->num_txbdfree = DEFAULT_TX_RING_SIZE;
+ priv->tx_queue->txcoalescing = DEFAULT_TX_COALESCE;
+ priv->tx_queue->txic = DEFAULT_TXIC;
+
+ priv->rx_queue->rx_ring_size = DEFAULT_RX_RING_SIZE;
+ priv->rx_queue->rxcoalescing = DEFAULT_RX_COALESCE;
+ priv->rx_queue->rxic = DEFAULT_RXIC;
/* Enable most messages by default */
priv->msg_enable = (NETIF_MSG_IFUP << 1 ) - 1;
@@ -464,12 +478,15 @@ static int gfar_probe(struct of_device *ofdev,
/* provided which set of benchmarks. */
printk(KERN_INFO "%s: Running with NAPI enabled\n", dev->name);
printk(KERN_INFO "%s: %d/%d RX/TX BD ring size\n",
- dev->name, priv->rx_ring_size, priv->tx_ring_size);
+ dev->name, priv->rx_queue->rx_ring_size, priv->tx_queue->tx_ring_size);
return 0;
register_fail:
iounmap(priv->regs);
+ kfree(priv->rx_queue);
+rx_queue_fail:
+ kfree(priv->tx_queue);
regs_fail:
if (priv->phy_node)
of_node_put(priv->phy_node);
@@ -502,6 +519,8 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
{
struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
struct net_device *dev = priv->ndev;
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
unsigned long flags;
u32 tempval;
@@ -510,9 +529,12 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
netif_device_detach(dev);
+ tx_queue = priv->tx_queue;
+ rx_queue = priv->rx_queue;
+
if (netif_running(dev)) {
- spin_lock_irqsave(&priv->txlock, flags);
- spin_lock(&priv->rxlock);
+ spin_lock_irqsave(&tx_queue->txlock, flags);
+ spin_lock(&tx_queue->rxlock);
gfar_halt_nodisable(dev);
@@ -526,10 +548,10 @@ static int gfar_suspend(struct of_device *ofdev, pm_message_t state)
gfar_write(&priv->regs->maccfg1, tempval);
- spin_unlock(&priv->rxlock);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock(&rx_queue->rxlock);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
- napi_disable(&priv->napi);
+ napi_disable(&rx_queue->napi);
if (magic_packet) {
/* Enable interrupt on Magic Packet */
@@ -551,6 +573,8 @@ static int gfar_resume(struct of_device *ofdev)
{
struct gfar_private *priv = dev_get_drvdata(&ofdev->dev);
struct net_device *dev = priv->ndev;
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
unsigned long flags;
u32 tempval;
int magic_packet = priv->wol_en &&
@@ -567,9 +591,11 @@ static int gfar_resume(struct of_device *ofdev)
/* Disable Magic Packet mode, in case something
* else woke us up.
*/
+ rx_queue = priv->rx_queue;
+ tx_queue = priv->tx_queue;
- spin_lock_irqsave(&priv->txlock, flags);
- spin_lock(&priv->rxlock);
+ spin_lock_irqsave(&tx_queue->txlock, flags);
+ spin_lock(&rx_queue->rxlock);
tempval = gfar_read(&priv->regs->maccfg2);
tempval &= ~MACCFG2_MPEN;
@@ -577,12 +603,12 @@ static int gfar_resume(struct of_device *ofdev)
gfar_start(dev);
- spin_unlock(&priv->rxlock);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock(&rx_queue->rxlock);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
netif_device_attach(dev);
- napi_enable(&priv->napi);
+ napi_enable(&rx_queue->napi);
return 0;
}
@@ -807,18 +833,23 @@ void stop_gfar(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
struct gfar __iomem *regs = priv->regs;
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
unsigned long flags;
phy_stop(priv->phydev);
+ tx_queue = priv->tx_queue;
+ rx_queue = priv->rx_queue;
+
/* Lock it down */
- spin_lock_irqsave(&priv->txlock, flags);
- spin_lock(&priv->rxlock);
+ spin_lock_irqsave(&tx_queue->txlock, flags);
+ spin_lock(&rx_queue->rxlock);
gfar_halt(dev);
- spin_unlock(&priv->rxlock);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock(&rx_queue->rxlock);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
/* Free the IRQs */
if (priv->device_flags & FSL_GIANFAR_DEV_HAS_MULTI_INTR) {
@@ -832,9 +863,9 @@ void stop_gfar(struct net_device *dev)
free_skb_resources(priv);
dma_free_coherent(&priv->ofdev->dev,
- sizeof(struct txbd8)*priv->tx_ring_size
- + sizeof(struct rxbd8)*priv->rx_ring_size,
- priv->tx_bd_base,
+ sizeof(struct txbd8)* tx_queue->tx_ring_size
+ + sizeof(struct rxbd8)* rx_queue->rx_ring_size,
+ tx_queue->tx_bd_base,
gfar_read(®s->tbase0));
}
@@ -844,43 +875,47 @@ static void free_skb_resources(struct gfar_private *priv)
{
struct rxbd8 *rxbdp;
struct txbd8 *txbdp;
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
int i, j;
/* Go through all the buffer descriptors and free their data buffers */
- txbdp = priv->tx_bd_base;
+ tx_queue = priv->tx_queue;
+ txbdp = tx_queue->tx_bd_base;
- for (i = 0; i < priv->tx_ring_size; i++) {
- if (!priv->tx_skbuff[i])
+ for (i = 0; i < tx_queue->tx_ring_size; i++) {
+ if (!tx_queue->tx_skbuff[i])
continue;
dma_unmap_single(&priv->ofdev->dev, txbdp->bufPtr,
txbdp->length, DMA_TO_DEVICE);
txbdp->lstatus = 0;
- for (j = 0; j < skb_shinfo(priv->tx_skbuff[i])->nr_frags; j++) {
+ for (j = 0; j < skb_shinfo(tx_queue->tx_skbuff[i])->nr_frags; j++) {
txbdp++;
dma_unmap_page(&priv->ofdev->dev, txbdp->bufPtr,
txbdp->length, DMA_TO_DEVICE);
}
txbdp++;
- dev_kfree_skb_any(priv->tx_skbuff[i]);
- priv->tx_skbuff[i] = NULL;
+ dev_kfree_skb_any(tx_queue->tx_skbuff[i]);
+ tx_queue->tx_skbuff[i] = NULL;
}
- kfree(priv->tx_skbuff);
+ kfree(tx_queue->tx_skbuff);
- rxbdp = priv->rx_bd_base;
+ rx_queue = priv->rx_queue;
+ rxbdp = rx_queue->rx_bd_base;
/* rx_skbuff is not guaranteed to be allocated, so only
* free it and its contents if it is allocated */
- if(priv->rx_skbuff != NULL) {
- for (i = 0; i < priv->rx_ring_size; i++) {
- if (priv->rx_skbuff[i]) {
+ if (rx_queue->rx_skbuff != NULL) {
+ for (i = 0; i < rx_queue->rx_ring_size; i++) {
+ if (rx_queue->rx_skbuff[i]) {
dma_unmap_single(&priv->ofdev->dev, rxbdp->bufPtr,
priv->rx_buffer_size,
DMA_FROM_DEVICE);
- dev_kfree_skb_any(priv->rx_skbuff[i]);
- priv->rx_skbuff[i] = NULL;
+ dev_kfree_skb_any(rx_queue->rx_skbuff[i]);
+ rx_queue->rx_skbuff[i] = NULL;
}
rxbdp->lstatus = 0;
@@ -889,7 +924,7 @@ static void free_skb_resources(struct gfar_private *priv)
rxbdp++;
}
- kfree(priv->rx_skbuff);
+ kfree(rx_queue->rx_skbuff);
}
}
@@ -933,6 +968,8 @@ int startup_gfar(struct net_device *dev)
unsigned long vaddr;
int i;
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_tx_q *tx_queue;
+ struct gfar_priv_rx_q *rx_queue;
struct gfar __iomem *regs = priv->regs;
int err = 0;
u32 rctrl = 0;
@@ -941,10 +978,13 @@ int startup_gfar(struct net_device *dev)
gfar_write(®s->imask, IMASK_INIT_CLEAR);
+ tx_queue = priv->tx_queue;
+ rx_queue = priv->rx_queue;
+
/* Allocate memory for the buffer descriptors */
vaddr = (unsigned long) dma_alloc_coherent(&priv->ofdev->dev,
- sizeof (struct txbd8) * priv->tx_ring_size +
- sizeof (struct rxbd8) * priv->rx_ring_size,
+ sizeof (struct txbd8) * tx_queue->tx_ring_size +
+ sizeof (struct rxbd8) * rx_queue->rx_ring_size,
&addr, GFP_KERNEL);
if (vaddr == 0) {
@@ -954,23 +994,25 @@ int startup_gfar(struct net_device *dev)
return -ENOMEM;
}
- priv->tx_bd_base = (struct txbd8 *) vaddr;
+ tx_queue->tx_bd_base = (struct txbd8 *) vaddr;
+ tx_queue->dev = dev;
/* enet DMA only understands physical addresses */
gfar_write(®s->tbase0, addr);
/* Start the rx descriptor ring where the tx ring leaves off */
- addr = addr + sizeof (struct txbd8) * priv->tx_ring_size;
- vaddr = vaddr + sizeof (struct txbd8) * priv->tx_ring_size;
- priv->rx_bd_base = (struct rxbd8 *) vaddr;
+ addr = addr + sizeof (struct txbd8) * tx_queue->tx_ring_size;
+ vaddr = vaddr + sizeof (struct txbd8) * tx_queue->tx_ring_size;
+ rx_queue->rx_bd_base = (struct rxbd8 *) vaddr;
+ rx_queue->dev = dev;
gfar_write(®s->rbase0, addr);
/* Setup the skbuff rings */
- priv->tx_skbuff =
+ tx_queue->tx_skbuff =
(struct sk_buff **) kmalloc(sizeof (struct sk_buff *) *
- priv->tx_ring_size, GFP_KERNEL);
+ tx_queue->tx_ring_size, GFP_KERNEL);
- if (NULL == priv->tx_skbuff) {
+ if (NULL == tx_queue->tx_skbuff) {
if (netif_msg_ifup(priv))
printk(KERN_ERR "%s: Could not allocate tx_skbuff\n",
dev->name);
@@ -978,14 +1020,15 @@ int startup_gfar(struct net_device *dev)
goto tx_skb_fail;
}
- for (i = 0; i < priv->tx_ring_size; i++)
- priv->tx_skbuff[i] = NULL;
- priv->rx_skbuff =
+ for (i = 0; i < tx_queue->tx_ring_size; i++)
+ tx_queue->tx_skbuff[i] = NULL;
+
+ rx_queue->rx_skbuff =
(struct sk_buff **) kmalloc(sizeof (struct sk_buff *) *
- priv->rx_ring_size, GFP_KERNEL);
+ rx_queue->rx_ring_size, GFP_KERNEL);
- if (NULL == priv->rx_skbuff) {
+ if (NULL == rx_queue->rx_skbuff) {
if (netif_msg_ifup(priv))
printk(KERN_ERR "%s: Could not allocate rx_skbuff\n",
dev->name);
@@ -993,19 +1036,19 @@ int startup_gfar(struct net_device *dev)
goto rx_skb_fail;
}
- for (i = 0; i < priv->rx_ring_size; i++)
- priv->rx_skbuff[i] = NULL;
+ for (i = 0; i < rx_queue->rx_ring_size; i++)
+ rx_queue->rx_skbuff[i] = NULL;
- /* Initialize some variables in our dev structure */
- priv->num_txbdfree = priv->tx_ring_size;
- priv->dirty_tx = priv->cur_tx = priv->tx_bd_base;
- priv->cur_rx = priv->rx_bd_base;
- priv->skb_curtx = priv->skb_dirtytx = 0;
- priv->skb_currx = 0;
+ /* Initialize some variables in our per tx/rx queue structure */
+ tx_queue->num_txbdfree = tx_queue->tx_ring_size;
+ tx_queue->dirty_tx = tx_queue->cur_tx = tx_queue->tx_bd_base;
+ tx_queue->skb_curtx = tx_queue->skb_dirtytx = 0;
+ rx_queue->cur_rx = rx_queue->rx_bd_base;
+ rx_queue->skb_currx = 0;
/* Initialize Transmit Descriptor Ring */
- txbdp = priv->tx_bd_base;
- for (i = 0; i < priv->tx_ring_size; i++) {
+ txbdp = tx_queue->tx_bd_base;
+ for (i = 0; i < tx_queue->tx_ring_size; i++) {
txbdp->lstatus = 0;
txbdp->bufPtr = 0;
txbdp++;
@@ -1015,8 +1058,8 @@ int startup_gfar(struct net_device *dev)
txbdp--;
txbdp->status |= TXBD_WRAP;
- rxbdp = priv->rx_bd_base;
- for (i = 0; i < priv->rx_ring_size; i++) {
+ rxbdp = rx_queue->rx_bd_base;
+ for (i = 0; i < rx_queue->rx_ring_size; i++) {
struct sk_buff *skb;
skb = gfar_new_skb(dev);
@@ -1028,9 +1071,9 @@ int startup_gfar(struct net_device *dev)
goto err_rxalloc_fail;
}
- priv->rx_skbuff[i] = skb;
+ rx_queue->rx_skbuff[i] = skb;
- gfar_new_rxbdp(dev, rxbdp, skb);
+ gfar_new_rxbdp(rx_queue, rxbdp, skb);
rxbdp++;
}
@@ -1090,12 +1133,12 @@ int startup_gfar(struct net_device *dev)
/* Configure the coalescing support */
gfar_write(®s->txic, 0);
- if (priv->txcoalescing)
- gfar_write(®s->txic, priv->txic);
+ if (tx_queue->txcoalescing)
+ gfar_write(®s->txic, tx_queue->txic);
gfar_write(®s->rxic, 0);
- if (priv->rxcoalescing)
- gfar_write(®s->rxic, priv->rxic);
+ if (rx_queue->rxcoalescing)
+ gfar_write(®s->rxic, rx_queue->rxic);
if (priv->rx_csum_enable)
rctrl |= RCTRL_CHECKSUMMING;
@@ -1163,9 +1206,9 @@ rx_skb_fail:
free_skb_resources(priv);
tx_skb_fail:
dma_free_coherent(&priv->ofdev->dev,
- sizeof(struct txbd8)*priv->tx_ring_size
- + sizeof(struct rxbd8)*priv->rx_ring_size,
- priv->tx_bd_base,
+ sizeof(struct txbd8)*tx_queue->tx_ring_size
+ + sizeof(struct rxbd8)*rx_queue->rx_ring_size,
+ tx_queue->tx_bd_base,
gfar_read(®s->tbase0));
return err;
@@ -1178,7 +1221,7 @@ static int gfar_enet_open(struct net_device *dev)
struct gfar_private *priv = netdev_priv(dev);
int err;
- napi_enable(&priv->napi);
+ napi_enable(&priv->rx_queue->napi);
skb_queue_head_init(&priv->rx_recycle);
@@ -1189,14 +1232,14 @@ static int gfar_enet_open(struct net_device *dev)
err = init_phy(dev);
- if(err) {
- napi_disable(&priv->napi);
+ if (err) {
+ napi_disable(&priv->rx_queue->napi);
return err;
}
err = startup_gfar(dev);
if (err) {
- napi_disable(&priv->napi);
+ napi_disable(&priv->rx_queue->napi);
return err;
}
@@ -1269,6 +1312,7 @@ static inline struct txbd8 *next_txbd(struct txbd8 *bdp, struct txbd8 *base,
static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_tx_q *tx_queue = NULL;
struct txfcb *fcb = NULL;
struct txbd8 *txbdp, *txbdp_start, *base;
u32 lstatus;
@@ -1277,7 +1321,8 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
unsigned long flags;
unsigned int nr_frags, length;
- base = priv->tx_bd_base;
+ tx_queue = priv->tx_queue;
+ base = tx_queue->tx_bd_base;
/* make space for additional header when fcb is needed */
if (((skb->ip_summed == CHECKSUM_PARTIAL) ||
@@ -1298,21 +1343,21 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
/* total number of fragments in the SKB */
nr_frags = skb_shinfo(skb)->nr_frags;
- spin_lock_irqsave(&priv->txlock, flags);
+ spin_lock_irqsave(&tx_queue->txlock, flags);
/* check if there is space to queue this packet */
- if ((nr_frags+1) > priv->num_txbdfree) {
+ if ((nr_frags+1) > tx_queue->num_txbdfree) {
/* no space, stop the queue */
netif_stop_queue(dev);
dev->stats.tx_fifo_errors++;
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
return NETDEV_TX_BUSY;
}
/* Update transmit stats */
dev->stats.tx_bytes += skb->len;
- txbdp = txbdp_start = priv->cur_tx;
+ txbdp = txbdp_start = tx_queue->cur_tx;
if (nr_frags == 0) {
lstatus = txbdp->lstatus | BD_LFLAG(TXBD_LAST | TXBD_INTERRUPT);
@@ -1320,7 +1365,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
/* Place the fragment addresses and lengths into the TxBDs */
for (i = 0; i < nr_frags; i++) {
/* Point at the next BD, wrapping as needed */
- txbdp = next_txbd(txbdp, base, priv->tx_ring_size);
+ txbdp = next_txbd(txbdp, base, tx_queue->tx_ring_size);
length = skb_shinfo(skb)->frags[i].size;
@@ -1362,7 +1407,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
}
/* setup the TxBD length and buffer pointer for the first BD */
- priv->tx_skbuff[priv->skb_curtx] = skb;
+ tx_queue->tx_skbuff[tx_queue->skb_curtx] = skb;
txbdp_start->bufPtr = dma_map_single(&priv->ofdev->dev, skb->data,
skb_headlen(skb), DMA_TO_DEVICE);
@@ -1382,19 +1427,19 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
/* Update the current skb pointer to the next entry we will use
* (wrapping if necessary) */
- priv->skb_curtx = (priv->skb_curtx + 1) &
- TX_RING_MOD_MASK(priv->tx_ring_size);
+ tx_queue->skb_curtx = (tx_queue->skb_curtx + 1) &
+ TX_RING_MOD_MASK(tx_queue->tx_ring_size);
- priv->cur_tx = next_txbd(txbdp, base, priv->tx_ring_size);
+ tx_queue->cur_tx = next_txbd(txbdp, base, tx_queue->tx_ring_size);
/* reduce TxBD free count */
- priv->num_txbdfree -= (nr_frags + 1);
+ tx_queue->num_txbdfree -= (nr_frags + 1);
dev->trans_start = jiffies;
/* If the next BD still needs to be cleaned up, then the bds
are full. We need to tell the kernel to stop sending us stuff. */
- if (!priv->num_txbdfree) {
+ if (!tx_queue->num_txbdfree) {
netif_stop_queue(dev);
dev->stats.tx_fifo_errors++;
@@ -1404,7 +1449,7 @@ static int gfar_start_xmit(struct sk_buff *skb, struct net_device *dev)
gfar_write(&priv->regs->tstat, TSTAT_CLEAR_THALT);
/* Unlock priv */
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
return NETDEV_TX_OK;
}
@@ -1414,7 +1459,7 @@ static int gfar_close(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
- napi_disable(&priv->napi);
+ napi_disable(&priv->rx_queue->napi);
skb_queue_purge(&priv->rx_recycle);
cancel_work_sync(&priv->reset_task);
@@ -1443,10 +1488,12 @@ static void gfar_vlan_rx_register(struct net_device *dev,
struct vlan_group *grp)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_rx_q *rx_queue = NULL;
unsigned long flags;
u32 tempval;
- spin_lock_irqsave(&priv->rxlock, flags);
+ rx_queue = priv->rx_queue;
+ spin_lock_irqsave(&rx_queue->rxlock, flags);
priv->vlgrp = grp;
@@ -1480,7 +1527,7 @@ static void gfar_vlan_rx_register(struct net_device *dev,
gfar_change_mtu(dev, dev->mtu);
- spin_unlock_irqrestore(&priv->rxlock, flags);
+ spin_unlock_irqrestore(&rx_queue->rxlock, flags);
}
static int gfar_change_mtu(struct net_device *dev, int new_mtu)
@@ -1569,24 +1616,27 @@ static void gfar_timeout(struct net_device *dev)
}
/* Interrupt Handler for Transmit complete */
-static int gfar_clean_tx_ring(struct net_device *dev)
+static int gfar_clean_tx_ring(struct gfar_priv_tx_q *tx_queue)
{
+ struct net_device *dev = tx_queue->dev;
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_rx_q *rx_queue = NULL;
struct txbd8 *bdp;
struct txbd8 *lbdp = NULL;
- struct txbd8 *base = priv->tx_bd_base;
+ struct txbd8 *base = tx_queue->tx_bd_base;
struct sk_buff *skb;
int skb_dirtytx;
- int tx_ring_size = priv->tx_ring_size;
+ int tx_ring_size = tx_queue->tx_ring_size;
int frags = 0;
int i;
int howmany = 0;
u32 lstatus;
- bdp = priv->dirty_tx;
- skb_dirtytx = priv->skb_dirtytx;
+ rx_queue = priv->rx_queue;
+ bdp = tx_queue->dirty_tx;
+ skb_dirtytx = tx_queue->skb_dirtytx;
- while ((skb = priv->tx_skbuff[skb_dirtytx])) {
+ while ((skb = tx_queue->tx_skbuff[skb_dirtytx])) {
frags = skb_shinfo(skb)->nr_frags;
lbdp = skip_txbd(bdp, frags, base, tx_ring_size);
@@ -1618,29 +1668,29 @@ static int gfar_clean_tx_ring(struct net_device *dev)
* If there's room in the queue (limit it to rx_buffer_size)
* we add this skb back into the pool, if it's the right size
*/
- if (skb_queue_len(&priv->rx_recycle) < priv->rx_ring_size &&
+ if (skb_queue_len(&priv->rx_recycle) < rx_queue->rx_ring_size &&
skb_recycle_check(skb, priv->rx_buffer_size +
RXBUF_ALIGNMENT))
__skb_queue_head(&priv->rx_recycle, skb);
else
dev_kfree_skb_any(skb);
- priv->tx_skbuff[skb_dirtytx] = NULL;
+ tx_queue->tx_skbuff[skb_dirtytx] = NULL;
skb_dirtytx = (skb_dirtytx + 1) &
TX_RING_MOD_MASK(tx_ring_size);
howmany++;
- priv->num_txbdfree += frags + 1;
+ tx_queue->num_txbdfree += frags + 1;
}
/* If we freed a buffer, we can restart transmission, if necessary */
- if (netif_queue_stopped(dev) && priv->num_txbdfree)
+ if (netif_queue_stopped(dev) && tx_queue->num_txbdfree)
netif_wake_queue(dev);
/* Update dirty indicators */
- priv->skb_dirtytx = skb_dirtytx;
- priv->dirty_tx = bdp;
+ tx_queue->skb_dirtytx = skb_dirtytx;
+ tx_queue->dirty_tx = bdp;
dev->stats.tx_packets += howmany;
@@ -1650,14 +1700,18 @@ static int gfar_clean_tx_ring(struct net_device *dev)
static void gfar_schedule_cleanup(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
unsigned long flags;
- spin_lock_irqsave(&priv->txlock, flags);
- spin_lock(&priv->rxlock);
+ rx_queue = priv->rx_queue;
+ tx_queue = priv->tx_queue;
+ spin_lock_irqsave(&tx_queue->txlock, flags);
+ spin_lock(&rx_queue->rxlock);
- if (napi_schedule_prep(&priv->napi)) {
+ if (napi_schedule_prep(&rx_queue->napi)) {
gfar_write(&priv->regs->imask, IMASK_RTX_DISABLED);
- __napi_schedule(&priv->napi);
+ __napi_schedule(&rx_queue->napi);
} else {
/*
* Clear IEVENT, so interrupts aren't called again
@@ -1666,8 +1720,8 @@ static void gfar_schedule_cleanup(struct net_device *dev)
gfar_write(&priv->regs->ievent, IEVENT_RTX_MASK);
}
- spin_unlock(&priv->rxlock);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock(&rx_queue->rxlock);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
}
/* Interrupt Handler for Transmit complete */
@@ -1677,9 +1731,10 @@ static irqreturn_t gfar_transmit(int irq, void *dev_id)
return IRQ_HANDLED;
}
-static void gfar_new_rxbdp(struct net_device *dev, struct rxbd8 *bdp,
+static void gfar_new_rxbdp(struct gfar_priv_rx_q *rx_queue, struct rxbd8 *bdp,
struct sk_buff *skb)
{
+ struct net_device *dev = rx_queue->dev;
struct gfar_private *priv = netdev_priv(dev);
u32 lstatus;
@@ -1688,7 +1743,7 @@ static void gfar_new_rxbdp(struct net_device *dev, struct rxbd8 *bdp,
lstatus = BD_LFLAG(RXBD_EMPTY | RXBD_INTERRUPT);
- if (bdp == priv->rx_bd_base + priv->rx_ring_size - 1)
+ if (bdp == rx_queue->rx_bd_base + rx_queue->rx_ring_size - 1)
lstatus |= BD_LFLAG(RXBD_WRAP);
eieio();
@@ -1818,8 +1873,9 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
* until the budget/quota has been reached. Returns the number
* of frames handled
*/
-int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit)
+int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit)
{
+ struct net_device *dev = rx_queue->dev;
struct rxbd8 *bdp, *base;
struct sk_buff *skb;
int pkt_len;
@@ -1828,8 +1884,8 @@ int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit)
struct gfar_private *priv = netdev_priv(dev);
/* Get the first full descriptor */
- bdp = priv->cur_rx;
- base = priv->rx_bd_base;
+ bdp = rx_queue->cur_rx;
+ base = rx_queue->rx_bd_base;
amount_pull = (gfar_uses_fcb(priv) ? GMAC_FCB_LEN : 0) +
priv->padding;
@@ -1841,7 +1897,7 @@ int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit)
/* Add another skb for the future */
newskb = gfar_new_skb(dev);
- skb = priv->rx_skbuff[priv->skb_currx];
+ skb = rx_queue->rx_skbuff[rx_queue->skb_currx];
dma_unmap_single(&priv->ofdev->dev, bdp->bufPtr,
priv->rx_buffer_size, DMA_FROM_DEVICE);
@@ -1889,30 +1945,33 @@ int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit)
}
- priv->rx_skbuff[priv->skb_currx] = newskb;
+ rx_queue->rx_skbuff[rx_queue->skb_currx] = newskb;
/* Setup the new bdp */
- gfar_new_rxbdp(dev, bdp, newskb);
+ gfar_new_rxbdp(rx_queue, bdp, newskb);
/* Update to the next pointer */
- bdp = next_bd(bdp, base, priv->rx_ring_size);
+ bdp = next_bd(bdp, base, rx_queue->rx_ring_size);
/* update to point at the next skb */
- priv->skb_currx =
- (priv->skb_currx + 1) &
- RX_RING_MOD_MASK(priv->rx_ring_size);
+ rx_queue->skb_currx =
+ (rx_queue->skb_currx + 1) &
+ RX_RING_MOD_MASK(rx_queue->rx_ring_size);
}
/* Update the current rxbd pointer to be the next one */
- priv->cur_rx = bdp;
+ rx_queue->cur_rx = bdp;
return howmany;
}
static int gfar_poll(struct napi_struct *napi, int budget)
{
- struct gfar_private *priv = container_of(napi, struct gfar_private, napi);
- struct net_device *dev = priv->ndev;
+ struct gfar_priv_rx_q *rx_queue = container_of(napi,
+ struct gfar_priv_rx_q, napi);
+ struct net_device *dev = rx_queue->dev;
+ struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_tx_q *tx_queue = NULL;
int tx_cleaned = 0;
int rx_cleaned = 0;
unsigned long flags;
@@ -1920,14 +1979,15 @@ static int gfar_poll(struct napi_struct *napi, int budget)
/* Clear IEVENT, so interrupts aren't called again
* because of the packets that have already arrived */
gfar_write(&priv->regs->ievent, IEVENT_RTX_MASK);
+ tx_queue = priv->tx_queue;
/* If we fail to get the lock, don't bother with the TX BDs */
- if (spin_trylock_irqsave(&priv->txlock, flags)) {
- tx_cleaned = gfar_clean_tx_ring(dev);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ if (spin_trylock_irqsave(&tx_queue->txlock, flags)) {
+ tx_cleaned = gfar_clean_tx_ring(tx_queue);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
}
- rx_cleaned = gfar_clean_rx_ring(dev, budget);
+ rx_cleaned = gfar_clean_rx_ring(rx_queue, budget);
if (tx_cleaned)
return budget;
@@ -1942,13 +2002,13 @@ static int gfar_poll(struct napi_struct *napi, int budget)
/* If we are coalescing interrupts, update the timer */
/* Otherwise, clear it */
- if (likely(priv->rxcoalescing)) {
+ if (likely(rx_queue->rxcoalescing)) {
gfar_write(&priv->regs->rxic, 0);
- gfar_write(&priv->regs->rxic, priv->rxic);
+ gfar_write(&priv->regs->rxic, rx_queue->rxic);
}
- if (likely(priv->txcoalescing)) {
+ if (likely(tx_queue->txcoalescing)) {
gfar_write(&priv->regs->txic, 0);
- gfar_write(&priv->regs->txic, priv->txic);
+ gfar_write(&priv->regs->txic, tx_queue->txic);
}
}
@@ -2015,12 +2075,14 @@ static irqreturn_t gfar_interrupt(int irq, void *dev_id)
static void adjust_link(struct net_device *dev)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_tx_q *tx_queue = NULL;
struct gfar __iomem *regs = priv->regs;
unsigned long flags;
struct phy_device *phydev = priv->phydev;
int new_state = 0;
- spin_lock_irqsave(&priv->txlock, flags);
+ tx_queue = priv->tx_queue;
+ spin_lock_irqsave(&tx_queue->txlock, flags);
if (phydev->link) {
u32 tempval = gfar_read(®s->maccfg2);
u32 ecntrl = gfar_read(®s->ecntrl);
@@ -2086,7 +2148,7 @@ static void adjust_link(struct net_device *dev)
if (new_state && netif_msg_link(priv))
phy_print_status(phydev);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
}
/* Update the hash table based on the current list of multicast
@@ -2100,7 +2162,7 @@ static void gfar_set_multi(struct net_device *dev)
struct gfar __iomem *regs = priv->regs;
u32 tempval;
- if(dev->flags & IFF_PROMISC) {
+ if (dev->flags & IFF_PROMISC) {
/* Set RCTRL to PROM */
tempval = gfar_read(®s->rctrl);
tempval |= RCTRL_PROM;
@@ -2112,7 +2174,7 @@ static void gfar_set_multi(struct net_device *dev)
gfar_write(®s->rctrl, tempval);
}
- if(dev->flags & IFF_ALLMULTI) {
+ if (dev->flags & IFF_ALLMULTI) {
/* Set the hash to rx all multicast frames */
gfar_write(®s->igaddr0, 0xffffffff);
gfar_write(®s->igaddr1, 0xffffffff);
@@ -2164,7 +2226,7 @@ static void gfar_set_multi(struct net_device *dev)
em_num = 0;
}
- if(dev->mc_count == 0)
+ if (dev->mc_count == 0)
return;
/* Parse the list, and set the appropriate bits */
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index 2cd9433..8bb77f1 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -7,8 +7,9 @@
*
* Author: Andy Fleming
* Maintainer: Kumar Gala
+ * Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
*
- * Copyright (c) 2002-2004 Freescale Semiconductor, Inc.
+ * Copyright 2002-2009 Freescale Semiconductor, Inc.
*
* 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
@@ -699,6 +700,75 @@ struct gfar {
#define FSL_GIANFAR_DEV_HAS_BD_STASHING 0x00000200
#define FSL_GIANFAR_DEV_HAS_BUF_STASHING 0x00000400
+/**
+ * struct gfar_priv_tx_q - per tx queue structure
+ * @txlock: per queue tx spin lock
+ * @tx_skbuff:skb pointers
+ * @skb_curtx: to be used skb pointer
+ * @skb_dirtytx:the last used skb pointer
+ * @qindex: index of this queue
+ * @dev: back pointer to the dev structure
+ * @grp: back pointer to the group to which this queue belongs
+ * @tx_bd_base: First tx buffer descriptor
+ * @cur_tx: Next free ring entry
+ * @dirty_tx: First buffer in line to be transmitted
+ * @tx_ring_size: Tx ring size
+ * @num_txbdfree: number of free TxBds
+ * @txcoalescing: enable/disable tx coalescing
+ * @txic: transmit interrupt coalescing value
+ * @txcount: coalescing value if based on tx frame count
+ * @txtime: coalescing value if based on time
+ */
+struct gfar_priv_tx_q {
+ spinlock_t txlock __attribute__ ((aligned (SMP_CACHE_BYTES)));
+ struct sk_buff ** tx_skbuff;
+ /* Buffer descriptor pointers */
+ struct txbd8 *tx_bd_base;
+ struct txbd8 *cur_tx;
+ struct txbd8 *dirty_tx;
+ struct net_device *dev;
+ u16 skb_curtx;
+ u16 skb_dirtytx;
+ u16 qindex;
+ unsigned int tx_ring_size;
+ unsigned int num_txbdfree;
+ /* Configuration info for the coalescing features */
+ unsigned char txcoalescing;
+ unsigned long txic;
+ unsigned short txcount;
+ unsigned short txtime;
+};
+
+/**
+ * struct gfar_priv_rx_q - per rx queue structure
+ * @rxlock: per queue rx spin lock
+ * @napi: the napi poll function
+ * @rx_skbuff: skb pointers
+ * @skb_currx: currently use skb pointer
+ * @rx_bd_base: First rx buffer descriptor
+ * @cur_rx: Next free rx ring entry
+ * @qindex: index of this queue
+ * @dev: back pointer to the dev structure
+ * @rx_ring_size: Rx ring size
+ * @rxcoalescing: enable/disable rx-coalescing
+ * @rxic: receive interrupt coalescing vlaue
+ */
+
+struct gfar_priv_rx_q {
+ spinlock_t rxlock __attribute__ ((aligned (SMP_CACHE_BYTES)));
+ struct napi_struct napi;
+ struct sk_buff ** rx_skbuff;
+ struct rxbd8 *rx_bd_base;
+ struct rxbd8 *cur_rx;
+ struct net_device *dev;
+ u16 skb_currx;
+ u16 qindex;
+ unsigned int rx_ring_size;
+ /* RX Coalescing values */
+ unsigned char rxcoalescing;
+ unsigned long rxic;
+};
+
/* Struct stolen almost completely (and shamelessly) from the FCC enet source
* (Ok, that's not so true anymore, but there is a family resemblence)
* The GFAR buffer descriptors track the ring buffers. The rx_bd_base
@@ -709,51 +779,15 @@ struct gfar {
* the buffer descriptor determines the actual condition.
*/
struct gfar_private {
- /* Fields controlled by TX lock */
- spinlock_t txlock;
-
- /* Pointer to the array of skbuffs */
- struct sk_buff ** tx_skbuff;
-
- /* next free skb in the array */
- u16 skb_curtx;
-
- /* First skb in line to be transmitted */
- u16 skb_dirtytx;
-
- /* Configuration info for the coalescing features */
- unsigned char txcoalescing;
- unsigned long txic;
-
- /* Buffer descriptor pointers */
- struct txbd8 *tx_bd_base; /* First tx buffer descriptor */
- struct txbd8 *cur_tx; /* Next free ring entry */
- struct txbd8 *dirty_tx; /* First buffer in line
- to be transmitted */
- unsigned int tx_ring_size;
- unsigned int num_txbdfree; /* number of TxBDs free */
-
- /* RX Locked fields */
- spinlock_t rxlock;
struct device_node *node;
struct net_device *ndev;
struct of_device *ofdev;
- struct napi_struct napi;
-
- /* skb array and index */
- struct sk_buff ** rx_skbuff;
- u16 skb_currx;
-
- /* RX Coalescing values */
- unsigned char rxcoalescing;
- unsigned long rxic;
- struct rxbd8 *rx_bd_base; /* First Rx buffers */
- struct rxbd8 *cur_rx; /* Next free rx ring entry */
+ struct gfar_priv_tx_q *tx_queue;
+ struct gfar_priv_rx_q *rx_queue;
- /* RX parameters */
- unsigned int rx_ring_size;
+ /* RX per device parameters */
unsigned int rx_buffer_size;
unsigned int rx_stash_size;
unsigned int rx_stash_index;
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index 6c144b5..6d0d171 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -7,8 +7,9 @@
*
* Author: Andy Fleming
* Maintainer: Kumar Gala
+ * Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
*
- * Copyright (c) 2003,2004 Freescale Semiconductor, Inc.
+ * Copyright 2003-2006, 2008-2009 Freescale Semiconductor, Inc.
*
* This software may be used and distributed according to
* the terms of the GNU Public License, Version 2, incorporated herein
@@ -41,7 +42,7 @@
#include "gianfar.h"
extern void gfar_start(struct net_device *dev);
-extern int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit);
+extern int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue, int rx_work_limit);
#define GFAR_MAX_COAL_USECS 0xffff
#define GFAR_MAX_COAL_FRAMES 0xff
@@ -197,12 +198,16 @@ static int gfar_gsettings(struct net_device *dev, struct ethtool_cmd *cmd)
{
struct gfar_private *priv = netdev_priv(dev);
struct phy_device *phydev = priv->phydev;
+ struct gfar_priv_rx_q *rx_queue = NULL;
+ struct gfar_priv_tx_q *tx_queue = NULL;
if (NULL == phydev)
return -ENODEV;
+ tx_queue = priv->tx_queue;
+ rx_queue = priv->rx_queue;
- cmd->maxtxpkt = get_icft_value(priv->txic);
- cmd->maxrxpkt = get_icft_value(priv->rxic);
+ cmd->maxtxpkt = get_icft_value(tx_queue->txic);
+ cmd->maxrxpkt = get_icft_value(rx_queue->rxic);
return phy_ethtool_gset(phydev, cmd);
}
@@ -279,6 +284,8 @@ static unsigned int gfar_ticks2usecs(struct gfar_private *priv, unsigned int tic
static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_rx_q *rx_queue = NULL;
+ struct gfar_priv_tx_q *tx_queue = NULL;
unsigned long rxtime;
unsigned long rxcount;
unsigned long txtime;
@@ -290,10 +297,13 @@ static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
if (NULL == priv->phydev)
return -ENODEV;
- rxtime = get_ictt_value(priv->rxic);
- rxcount = get_icft_value(priv->rxic);
- txtime = get_ictt_value(priv->txic);
- txcount = get_icft_value(priv->txic);
+ rx_queue = priv->rx_queue;
+ tx_queue = priv->tx_queue;
+
+ rxtime = get_ictt_value(rx_queue->rxic);
+ rxcount = get_icft_value(rx_queue->rxic);
+ txtime = get_ictt_value(tx_queue->txic);
+ txcount = get_icft_value(tx_queue->txic);
cvals->rx_coalesce_usecs = gfar_ticks2usecs(priv, rxtime);
cvals->rx_max_coalesced_frames = rxcount;
@@ -339,16 +349,21 @@ static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
return -EOPNOTSUPP;
+ tx_queue = priv->tx_queue;
+ rx_queue = priv->rx_queue;
+
/* Set up rx coalescing */
if ((cvals->rx_coalesce_usecs == 0) ||
(cvals->rx_max_coalesced_frames == 0))
- priv->rxcoalescing = 0;
+ rx_queue->rxcoalescing = 0;
else
- priv->rxcoalescing = 1;
+ rx_queue->rxcoalescing = 1;
if (NULL == priv->phydev)
return -ENODEV;
@@ -366,15 +381,15 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
return -EINVAL;
}
- priv->rxic = mk_ic_value(cvals->rx_max_coalesced_frames,
+ rx_queue->rxic = mk_ic_value(cvals->rx_max_coalesced_frames,
gfar_usecs2ticks(priv, cvals->rx_coalesce_usecs));
/* Set up tx coalescing */
if ((cvals->tx_coalesce_usecs == 0) ||
(cvals->tx_max_coalesced_frames == 0))
- priv->txcoalescing = 0;
+ tx_queue->txcoalescing = 0;
else
- priv->txcoalescing = 1;
+ tx_queue->txcoalescing = 1;
/* Check the bounds of the values */
if (cvals->tx_coalesce_usecs > GFAR_MAX_COAL_USECS) {
@@ -389,16 +404,16 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
return -EINVAL;
}
- priv->txic = mk_ic_value(cvals->tx_max_coalesced_frames,
+ tx_queue->txic = mk_ic_value(cvals->tx_max_coalesced_frames,
gfar_usecs2ticks(priv, cvals->tx_coalesce_usecs));
gfar_write(&priv->regs->rxic, 0);
- if (priv->rxcoalescing)
- gfar_write(&priv->regs->rxic, priv->rxic);
+ if (rx_queue->rxcoalescing)
+ gfar_write(&priv->regs->rxic, rx_queue->rxic);
gfar_write(&priv->regs->txic, 0);
- if (priv->txcoalescing)
- gfar_write(&priv->regs->txic, priv->txic);
+ if (tx_queue->txcoalescing)
+ gfar_write(&priv->regs->txic, tx_queue->txic);
return 0;
}
@@ -409,6 +424,11 @@ static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals
static void gfar_gringparam(struct net_device *dev, struct ethtool_ringparam *rvals)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
+
+ tx_queue = priv->tx_queue;
+ rx_queue = priv->rx_queue;
rvals->rx_max_pending = GFAR_RX_MAX_RING_SIZE;
rvals->rx_mini_max_pending = GFAR_RX_MAX_RING_SIZE;
@@ -418,10 +438,10 @@ static void gfar_gringparam(struct net_device *dev, struct ethtool_ringparam *rv
/* Values changeable by the user. The valid values are
* in the range 1 to the "*_max_pending" counterpart above.
*/
- rvals->rx_pending = priv->rx_ring_size;
- rvals->rx_mini_pending = priv->rx_ring_size;
- rvals->rx_jumbo_pending = priv->rx_ring_size;
- rvals->tx_pending = priv->tx_ring_size;
+ rvals->rx_pending = rx_queue->rx_ring_size;
+ rvals->rx_mini_pending = rx_queue->rx_ring_size;
+ rvals->rx_jumbo_pending = rx_queue->rx_ring_size;
+ rvals->tx_pending = tx_queue->tx_ring_size;
}
/* Change the current ring parameters, stopping the controller if
@@ -431,6 +451,8 @@ static void gfar_gringparam(struct net_device *dev, struct ethtool_ringparam *rv
static int gfar_sringparam(struct net_device *dev, struct ethtool_ringparam *rvals)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_tx_q *tx_queue = NULL;
+ struct gfar_priv_rx_q *rx_queue = NULL;
int err = 0;
if (rvals->rx_pending > GFAR_RX_MAX_RING_SIZE)
@@ -451,29 +473,32 @@ static int gfar_sringparam(struct net_device *dev, struct ethtool_ringparam *rva
return -EINVAL;
}
+ tx_queue = priv->tx_queue;
+ rx_queue = priv->rx_queue;
+
if (dev->flags & IFF_UP) {
unsigned long flags;
/* Halt TX and RX, and process the frames which
* have already been received */
- spin_lock_irqsave(&priv->txlock, flags);
- spin_lock(&priv->rxlock);
+ spin_lock_irqsave(&tx_queue->txlock, flags);
+ spin_lock(&rx_queue->rxlock);
gfar_halt(dev);
- spin_unlock(&priv->rxlock);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock(&rx_queue->rxlock);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
- gfar_clean_rx_ring(dev, priv->rx_ring_size);
+ gfar_clean_rx_ring(rx_queue, rx_queue->rx_ring_size);
/* Now we take down the rings to rebuild them */
stop_gfar(dev);
}
/* Change the size */
- priv->rx_ring_size = rvals->rx_pending;
- priv->tx_ring_size = rvals->tx_pending;
- priv->num_txbdfree = priv->tx_ring_size;
+ rx_queue->rx_ring_size = rvals->rx_pending;
+ tx_queue->tx_ring_size = rvals->tx_pending;
+ tx_queue->num_txbdfree = tx_queue->tx_ring_size;
/* Rebuild the rings with the new size */
if (dev->flags & IFF_UP) {
@@ -486,24 +511,29 @@ static int gfar_sringparam(struct net_device *dev, struct ethtool_ringparam *rva
static int gfar_set_rx_csum(struct net_device *dev, uint32_t data)
{
struct gfar_private *priv = netdev_priv(dev);
+ struct gfar_priv_rx_q *rx_queue = NULL;
+ struct gfar_priv_tx_q *tx_queue = NULL;
unsigned long flags;
int err = 0;
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM))
return -EOPNOTSUPP;
+ tx_queue = priv->tx_queue;
+ rx_queue = priv->rx_queue;
+
if (dev->flags & IFF_UP) {
/* Halt TX and RX, and process the frames which
* have already been received */
- spin_lock_irqsave(&priv->txlock, flags);
- spin_lock(&priv->rxlock);
+ spin_lock_irqsave(&tx_queue->txlock, flags);
+ spin_lock(&rx_queue->rxlock);
gfar_halt(dev);
- spin_unlock(&priv->rxlock);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock(&rx_queue->rxlock);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
- gfar_clean_rx_ring(dev, priv->rx_ring_size);
+ gfar_clean_rx_ring(rx_queue, rx_queue->rx_ring_size);
/* Now we take down the rings to rebuild them */
stop_gfar(dev);
diff --git a/drivers/net/gianfar_sysfs.c b/drivers/net/gianfar_sysfs.c
index dd26da7..9c664f8 100644
--- a/drivers/net/gianfar_sysfs.c
+++ b/drivers/net/gianfar_sysfs.c
@@ -8,8 +8,9 @@
*
* Author: Andy Fleming
* Maintainer: Kumar Gala (galak@kernel.crashing.org)
+ * Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
*
- * Copyright (c) 2002-2005 Freescale Semiconductor, Inc.
+ * Copyright 2002-2009 Freescale Semiconductor, Inc.
*
* 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
@@ -49,6 +50,7 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar_priv_rx_q *rx_queue = NULL;
int new_setting = 0;
u32 temp;
unsigned long flags;
@@ -56,6 +58,8 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BD_STASHING))
return count;
+ rx_queue = priv->rx_queue;
+
/* Find out the new setting */
if (!strncmp("on", buf, count - 1) || !strncmp("1", buf, count - 1))
new_setting = 1;
@@ -65,7 +69,7 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
else
return count;
- spin_lock_irqsave(&priv->rxlock, flags);
+ spin_lock_irqsave(&rx_queue->rxlock, flags);
/* Set the new stashing value */
priv->bd_stash_en = new_setting;
@@ -79,7 +83,7 @@ static ssize_t gfar_set_bd_stash(struct device *dev,
gfar_write(&priv->regs->attr, temp);
- spin_unlock_irqrestore(&priv->rxlock, flags);
+ spin_unlock_irqrestore(&rx_queue->rxlock, flags);
return count;
}
@@ -99,6 +103,7 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar_priv_rx_q *rx_queue = NULL;
unsigned int length = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -106,7 +111,9 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
return count;
- spin_lock_irqsave(&priv->rxlock, flags);
+ rx_queue = priv->rx_queue;
+
+ spin_lock_irqsave(&rx_queue->rxlock, flags);
if (length > priv->rx_buffer_size)
goto out;
@@ -131,7 +138,7 @@ static ssize_t gfar_set_rx_stash_size(struct device *dev,
gfar_write(&priv->regs->attr, temp);
out:
- spin_unlock_irqrestore(&priv->rxlock, flags);
+ spin_unlock_irqrestore(&rx_queue->rxlock, flags);
return count;
}
@@ -154,6 +161,7 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar_priv_rx_q *rx_queue = NULL;
unsigned short index = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -161,7 +169,9 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_BUF_STASHING))
return count;
- spin_lock_irqsave(&priv->rxlock, flags);
+ rx_queue = priv->rx_queue;
+
+ spin_lock_irqsave(&rx_queue->rxlock, flags);
if (index > priv->rx_stash_size)
goto out;
@@ -176,7 +186,7 @@ static ssize_t gfar_set_rx_stash_index(struct device *dev,
gfar_write(&priv->regs->attreli, flags);
out:
- spin_unlock_irqrestore(&priv->rxlock, flags);
+ spin_unlock_irqrestore(&rx_queue->rxlock, flags);
return count;
}
@@ -198,6 +208,7 @@ static ssize_t gfar_set_fifo_threshold(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar_priv_tx_q *tx_queue = NULL;
unsigned int length = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -205,7 +216,9 @@ static ssize_t gfar_set_fifo_threshold(struct device *dev,
if (length > GFAR_MAX_FIFO_THRESHOLD)
return count;
- spin_lock_irqsave(&priv->txlock, flags);
+ tx_queue = priv->tx_queue;
+
+ spin_lock_irqsave(&tx_queue->txlock, flags);
priv->fifo_threshold = length;
@@ -214,7 +227,7 @@ static ssize_t gfar_set_fifo_threshold(struct device *dev,
temp |= length;
gfar_write(&priv->regs->fifo_tx_thr, temp);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
return count;
}
@@ -235,6 +248,7 @@ static ssize_t gfar_set_fifo_starve(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar_priv_tx_q *tx_queue = NULL;
unsigned int num = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -242,7 +256,8 @@ static ssize_t gfar_set_fifo_starve(struct device *dev,
if (num > GFAR_MAX_FIFO_STARVE)
return count;
- spin_lock_irqsave(&priv->txlock, flags);
+ tx_queue = priv->tx_queue;
+ spin_lock_irqsave(&tx_queue->txlock, flags);
priv->fifo_starve = num;
@@ -251,7 +266,7 @@ static ssize_t gfar_set_fifo_starve(struct device *dev,
temp |= num;
gfar_write(&priv->regs->fifo_tx_starve, temp);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
return count;
}
@@ -273,6 +288,7 @@ static ssize_t gfar_set_fifo_starve_off(struct device *dev,
const char *buf, size_t count)
{
struct gfar_private *priv = netdev_priv(to_net_dev(dev));
+ struct gfar_priv_tx_q *tx_queue = NULL;
unsigned int num = simple_strtoul(buf, NULL, 0);
u32 temp;
unsigned long flags;
@@ -280,7 +296,8 @@ static ssize_t gfar_set_fifo_starve_off(struct device *dev,
if (num > GFAR_MAX_FIFO_STARVE_OFF)
return count;
- spin_lock_irqsave(&priv->txlock, flags);
+ tx_queue = priv->tx_queue;
+ spin_lock_irqsave(&tx_queue->txlock, flags);
priv->fifo_starve_off = num;
@@ -289,7 +306,7 @@ static ssize_t gfar_set_fifo_starve_off(struct device *dev,
temp |= num;
gfar_write(&priv->regs->fifo_tx_starve_shutoff, temp);
- spin_unlock_irqrestore(&priv->txlock, flags);
+ spin_unlock_irqrestore(&tx_queue->txlock, flags);
return count;
}
--
1.5.2.2
^ permalink raw reply related
* [net-next-2.6 PATCH 2/4 resent] TCPCT part 1b: sysctl_tcp_cookie_size and TCP_COOKIE_TRANSACTIONS
From: William Allen Simpson @ 2009-10-15 15:01 UTC (permalink / raw)
To: Linux Kernel Network Developers
[-- Attachment #1: Type: text/plain, Size: 881 bytes --]
Define sysctl (tcp_cookie_size) to turn on and off the cookie option
default globally, instead of a compiled configuration option.
Define per socket option (TCP_COOKIE_TRANSACTIONS) for setting constant
data values, retrieving variable cookie values, and other facilities.
This is a straightforward re-implementation of an earlier (year-old)
patch that no longer applies cleanly, with permission of the original
author (Adam Langley). The patch was previously reviewed:
http://thread.gmane.org/gmane.linux.network/102586
These functions will also be used in subsequent patches that implement
additional features.
---
include/linux/tcp.h | 31 ++++++++++++++++++++++++++++++-
include/net/tcp.h | 1 +
net/ipv4/sysctl_net_ipv4.c | 8 ++++++++
net/ipv4/tcp_output.c | 8 ++++++++
4 files changed, 47 insertions(+), 1 deletions(-)
[-- Attachment #2: TCPCT+1-2.patch --]
[-- Type: text/plain, Size: 3571 bytes --]
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 61723a7..63ab660 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -96,6 +96,7 @@ enum {
#define TCP_QUICKACK 12 /* Block/reenable quick acks */
#define TCP_CONGESTION 13 /* Congestion control algorithm */
#define TCP_MD5SIG 14 /* TCP MD5 Signature (RFC2385) */
+#define TCP_COOKIE_TRANSACTIONS 15 /* TCP Cookie Transactions */
#define TCPI_OPT_TIMESTAMPS 1
#define TCPI_OPT_SACK 2
@@ -170,6 +171,34 @@ struct tcp_md5sig {
__u8 tcpm_key[TCP_MD5SIG_MAXKEYLEN]; /* key (binary) */
};
+/* for TCP_COOKIE_TRANSACTIONS (TCPCT) socket option */
+#define TCP_COOKIE_MAX 16 /* 128-bits */
+#define TCP_COOKIE_MIN 8 /* 64-bits */
+#define TCP_COOKIE_PAIR_SIZE (2*TCP_COOKIE_MAX)
+
+#define TCP_S_DATA_MAX 64U /* after TCP+IP options */
+#define TCP_S_DATA_MSS_DEFAULT 536U /* default MSS (RFC1122) */
+
+/* Flags for both getsockopt and setsockopt */
+#define TCP_COOKIE_IN_ALWAYS (1 << 0) /* Discard SYN without cookie */
+#define TCP_COOKIE_OUT_NEVER (1 << 1) /* Prohibit outgoing cookies,
+ * supercedes everything else. */
+#define TCP_EXTEND_TIMESTAMP (1 << 4) /* Initiate 64-bit timestamps */
+
+/* Flags for getsockopt */
+#define TCP_S_DATA_IN (1 << 2) /* Was data received? */
+#define TCP_S_DATA_OUT (1 << 3) /* Was data sent? */
+
+/* TCP_COOKIE_TRANSACTIONS data */
+struct tcp_cookie_transactions {
+ __u16 tcpct_flags; /* see above */
+ __u8 __tcpct_pad1; /* zero */
+ __u8 tcpct_cookie_desired; /* bytes */
+ __u16 tcpct_s_data_desired; /* bytes of variable data */
+ __u16 tcpct_used; /* bytes in value */
+ __u8 tcpct_value[TCP_S_DATA_MSS_DEFAULT];
+};
+
#ifdef __KERNEL__
#include <linux/skbuff.h>
@@ -431,6 +460,6 @@ static inline struct tcp_timewait_sock *tcp_twsk(const struct sock *sk)
return (struct tcp_timewait_sock *)sk;
}
-#endif
+#endif /* __KERNEL__ */
#endif /* _LINUX_TCP_H */
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 28bcaf7..63d17fd 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -237,6 +237,7 @@ extern int sysctl_tcp_base_mss;
extern int sysctl_tcp_workaround_signed_windows;
extern int sysctl_tcp_slow_start_after_idle;
extern int sysctl_tcp_max_ssthresh;
+extern int sysctl_tcp_cookie_size;
extern atomic_t tcp_memory_allocated;
extern struct percpu_counter tcp_sockets_allocated;
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 2dcf04d..3422c54 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -714,6 +714,14 @@ static struct ctl_table ipv4_table[] = {
},
{
.ctl_name = CTL_UNNUMBERED,
+ .procname = "tcp_cookie_size",
+ .data = &sysctl_tcp_cookie_size,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = proc_dointvec
+ },
+ {
+ .ctl_name = CTL_UNNUMBERED,
.procname = "udp_mem",
.data = &sysctl_udp_mem,
.maxlen = sizeof(sysctl_udp_mem),
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 765d80f..c235196 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -59,6 +59,14 @@ int sysctl_tcp_base_mss __read_mostly = 512;
/* By default, RFC2861 behavior. */
int sysctl_tcp_slow_start_after_idle __read_mostly = 1;
+#ifdef CONFIG_SYSCTL
+/* By default, let the user enable it. */
+int sysctl_tcp_cookie_size __read_mostly = 0;
+#else
+int sysctl_tcp_cookie_size __read_mostly = TCP_COOKIE_MAX;
+#endif
+
+
/* Account for new data that has been sent to the network. */
static void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb)
{
--
1.6.0.4
^ permalink raw reply related
* Re: [PATCH] Phonet: hold socket before giving it to sk_deliver_skb()
From: Eric Dumazet @ 2009-10-15 14:52 UTC (permalink / raw)
To: Rémi Denis-Courmont; +Cc: netdev, Rémi Denis-Courmont
In-Reply-To: <1255611600-18534-1-git-send-email-remi@remlab.net>
Rémi Denis-Courmont a écrit :
> From: Rémi Denis-Courmont <remi.denis-courmont@nokia.com>
>
> Signed-off-by: Rémi Denis-Courmont <remi.denis-courmont@nokia.com>
> ---
> net/phonet/socket.c | 4 +++-
> 1 files changed, 3 insertions(+), 1 deletions(-)
>
> diff --git a/net/phonet/socket.c b/net/phonet/socket.c
> index 8c84190..0412beb 100644
> --- a/net/phonet/socket.c
> +++ b/net/phonet/socket.c
> @@ -112,8 +112,10 @@ void pn_deliver_sock_broadcast(struct net *net, struct sk_buff *skb)
> continue;
>
> clone = skb_clone(skb, GFP_ATOMIC);
> - if (clone)
> + if (clone) {
> + sock_hold(sknode);
> sk_receive_skb(sknode, clone, 0);
> + }
> }
> spin_unlock(&pnsocks.lock);
> }
Indeed sk_receive_skb() does a sock_put(sk)
Acked-by: Eric Dumazet <eric.dumazet@gmail.com>
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox