Merge git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

``ULONG_MAX`` then the XArray is not the data type for you.  The most

important user of the XArray is the page cache.

Each non-``NULL`` entry in the array has three bits associated with

it called marks.  Each mark may be set or cleared independently of

the others.  You can iterate over entries which are marked.

Normal pointers may be stored in the XArray directly.  They must be 4-byte

aligned, which is true for any pointer returned from kmalloc() and

alloc_page().  It isn't true for arbitrary user-space pointers,

a value entry by calling xa_is_value(), and convert it back to

an integer by calling xa_to_value().

Some users want to store tagged pointers instead of using the marks

described above.  They can call xa_tag_pointer() to create an

entry with a tag, xa_untag_pointer() to turn a tagged entry

back into an untagged pointer and xa_pointer_tag() to retrieve

the tag of an entry.  Tagged pointers use the same bits that are used

to distinguish value entries from normal pointers, so each user must

Some users want to tag the pointers they store in the XArray.  You can

call xa_tag_pointer() to create an entry with a tag, xa_untag_pointer()

to turn a tagged entry back into an untagged pointer and xa_pointer_tag()

to retrieve the tag of an entry.  Tagged pointers use the same bits that

are used to distinguish value entries from normal pointers, so you must

decide whether they want to store value entries or tagged pointers in

any particular XArray.

An unusual feature of the XArray is the ability to create entries which

occupy a range of indices.  Once stored to, looking up any index in

the range will return the same entry as looking up any other index in

the range.  Setting a mark on one index will set it on all of them.

Storing to any index will store to all of them.  Multi-index entries can

be explicitly split into smaller entries, or storing ``NULL`` into any

entry will cause the XArray to forget about the range.

the range.  Storing to any index will store to all of them.  Multi-index

entries can be explicitly split into smaller entries, or storing ``NULL``

into any entry will cause the XArray to forget about the range.

Normal API

==========

at that index is ``NULL``, you can use xa_insert() which

returns ``-EBUSY`` if the entry is not empty.

You can enquire whether a mark is set on an entry by using

xa_get_mark().  If the entry is not ``NULL``, you can set a mark

on it by using xa_set_mark() and remove the mark from an entry by

calling xa_clear_mark().  You can ask whether any entry in the

XArray has a particular mark set by calling xa_marked().

You can copy entries out of the XArray into a plain array by calling

xa_extract().  Or you can iterate over the present entries in

the XArray by calling xa_for_each().  You may prefer to use

xa_find() or xa_find_after() to move to the next present

entry in the XArray.

xa_extract().  Or you can iterate over the present entries in the XArray

by calling xa_for_each(), xa_for_each_start() or xa_for_each_range().

You may prefer to use xa_find() or xa_find_after() to move to the next

present entry in the XArray.

Calling xa_store_range() stores the same entry in a range

of indices.  If you do this, some of the other operations will behave

to free the entries first.  You can do this by iterating over all present

entries in the XArray using the xa_for_each() iterator.

Search Marks

------------

Each entry in the array has three bits associated with it called marks.

Each mark may be set or cleared independently of the others.  You can

iterate over marked entries by using the xa_for_each_marked() iterator.

You can enquire whether a mark is set on an entry by using

xa_get_mark().  If the entry is not ``NULL``, you can set a mark on it

by using xa_set_mark() and remove the mark from an entry by calling

xa_clear_mark().  You can ask whether any entry in the XArray has a

particular mark set by calling xa_marked().  Erasing an entry from the

XArray causes all marks associated with that entry to be cleared.

Setting or clearing a mark on any index of a multi-index entry will

affect all indices covered by that entry.  Querying the mark on any

index will return the same result.

There is no way to iterate over entries which are not marked; the data

structure does not allow this to be implemented efficiently.  There are

not currently iterators to search for logical combinations of bits (eg

iterate over all entries which have both ``XA_MARK_1`` and ``XA_MARK_2``

set, or iterate over all entries which have ``XA_MARK_0`` or ``XA_MARK_2``

set).  It would be possible to add these if a user arises.

Allocating XArrays

------------------

Takes RCU read lock:

 * xa_load()

 * xa_for_each()

 * xa_for_each_start()

 * xa_for_each_range()

 * xa_find()

 * xa_find_after()

 * xa_extract()

then it is good manners to pause the iteration and reenable interrupts

every ``XA_CHECK_SCHED`` entries.

The xas_get_mark(), xas_set_mark() and

xas_clear_mark() functions require the xa_state cursor to have

been moved to the appropriate location in the xarray; they will do

nothing if you have called xas_pause() or xas_set()

The xas_get_mark(), xas_set_mark() and xas_clear_mark() functions require

the xa_state cursor to have been moved to the appropriate location in the

XArray; they will do nothing if you have called xas_pause() or xas_set()

immediately before.

You can call xas_set_update() to have a callback function

		The settings and programming routines for internal/external

		MDIO are different. Must be included for internal MDIO.

- fsl,erratum-a011043

		Usage: optional

		Value type: <boolean>

		Definition: Indicates the presence of the A011043 erratum

		describing that the MDIO_CFG[MDIO_RD_ER] bit may be falsely

		set when reading internal PCS registers. MDIO reads to

		internal PCS registers may result in having the

		MDIO_CFG[MDIO_RD_ER] bit set, even when there is no error and

		read data (MDIO_DATA[MDIO_DATA]) is correct.

		Software may get false read error when reading internal

		PCS registers through MDIO. As a workaround, all internal

		MDIO accesses should ignore the MDIO_CFG[MDIO_RD_ER] bit.

For internal PHY device on internal mdio bus, a PHY node should be created.

See the definition of the PHY node in booting-without-of.txt for an

example of how to define a PHY (Internal PHY has no interrupt line).

M:	Andrew Lunn <andrew@lunn.ch>

M:	Florian Fainelli <f.fainelli@gmail.com>

M:	Heiner Kallweit <hkallweit1@gmail.com>

R:	Russell King <linux@armlinux.org.uk>

L:	netdev@vger.kernel.org

S:	Maintained

F:	Documentation/ABI/testing/sysfs-class-net-phydev

F:	drivers/platform/x86/intel-vbtn.c

INTEL WIRELESS 3945ABG/BG, 4965AGN (iwlegacy)

M:	Stanislaw Gruszka <sgruszka@redhat.com>

M:	Stanislaw Gruszka <stf_xl@wp.pl>

L:	linux-wireless@vger.kernel.org

S:	Supported

F:	drivers/net/wireless/intel/iwlegacy/

NETWORKING [GENERAL]

M:	"David S. Miller" <davem@davemloft.net>

M:	Jakub Kicinski <kuba@kernel.org>

L:	netdev@vger.kernel.org

W:	http://www.linuxfoundation.org/en/Net

Q:	http://patchwork.ozlabs.org/project/netdev/list/

F:	arch/mips/ralink

RALINK RT2X00 WIRELESS LAN DRIVER

M:	Stanislaw Gruszka <sgruszka@redhat.com>

M:	Stanislaw Gruszka <stf_xl@wp.pl>

M:	Helmut Schaa <helmut.schaa@googlemail.com>

L:	linux-wireless@vger.kernel.org

S:	Maintained

F:	tools/testing/selftests/timers/

TIPC NETWORK LAYER

M:	Jon Maloy <jon.maloy@ericsson.com>

M:	Jon Maloy <jmaloy@redhat.com>

M:	Ying Xue <ying.xue@windriver.com>

L:	netdev@vger.kernel.org (core kernel code)

L:	tipc-discussion@lists.sourceforge.net (user apps, general discussion)

VERSION = 5

PATCHLEVEL = 5

SUBLEVEL = 0

EXTRAVERSION = -rc6

EXTRAVERSION = -rc7

NAME = Kleptomaniac Octopus

# *DOCUMENTATION*

};

/ {

	memory@80000000 {

		device_type = "memory";

		reg = <0x80000000 0x20000000>; /* 512 MB */

	};

	clk_mcasp0_fixed: clk_mcasp0_fixed {

		#clock-cells = <0>;

		compatible = "fixed-clock";