Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6

	* SA E200

	* SA E200i

	* SA E500

	* SA P700m

	* SA P212

	* SA P410

	* SA P410i

	* SA P411

	* SA P812

	* SA P712m

	* SA P711m

Detecting drive failures:

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

Works.  Use "Insert file..." or external editor.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Gmail (Web GUI)

If you just have to use Gmail to send patches, it CAN be made to work.  It

requires a bit of external help, though.

The first problem is that Gmail converts tabs to spaces.  This will

totally break your patches.  To prevent this, you have to use a different

editor.  There is a firefox extension called "ViewSourceWith"

(https://addons.mozilla.org/en-US/firefox/addon/394) which allows you to

edit any text box in the editor of your choice.  Configure it to launch

your favorite editor.  When you want to send a patch, use this technique.

Once you have crafted your messsage + patch, save and exit the editor,

which should reload the Gmail edit box.  GMAIL WILL PRESERVE THE TABS.

Hoorah.  Apparently you can cut-n-paste literal tabs, but Gmail will

convert those to spaces upon sending!

The second problem is that Gmail converts tabs to spaces on replies.  If

you reply to a patch, don't expect to be able to apply it as a patch.

The last problem is that Gmail will base64-encode any message that has a

non-ASCII character.  That includes things like European names.  Be aware.

Gmail is not convenient for lkml patches, but CAN be made to work.

                                ###

VFAT MOUNT OPTIONS

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

uid=###       -- Set the owner of all files on this filesystem.

		 The default is the uid of current process.

gid=###       -- Set the group of all files on this filesystem.

		 The default is the gid of current process.

umask=###     -- The permission mask (for files and directories, see umask(1)).

                 The default is the umask of current process.

		 characters on FAT filesystem.

		 By default, FAT_DEFAULT_CODEPAGE setting is used.

iocharset=name -- Character set to use for converting between the

iocharset=<name> -- Character set to use for converting between the

		 encoding is used for user visible filename and 16 bit

		 Unicode characters. Long filenames are stored on disk

		 in Unicode format, but Unix for the most part doesn't

                 r: relaxed, case insensitive

                 n: normal, default setting, currently case insensitive

nocase        -- This was deprecated for vfat. Use shortname=win95 instead.

shortname=lower|win95|winnt|mixed

	      -- Shortname display/create setting.

		 lower: convert to lowercase for display,

tz=UTC        -- Interpret timestamps as UTC rather than local time.

                 This option disables the conversion of timestamps

                 between local time (as used by Windows on FAT) and UTC

                 (which Linux uses internally).  This is particuluarly

                 (which Linux uses internally).  This is particularly

                 useful when mounting devices (like digital cameras)

                 that are set to UTC in order to avoid the pitfalls of

                 local time.

showexec      -- If set, the execute permission bits of the file will be

		 allowed only if the extension part of the name is .EXE,

		 .COM, or .BAT. Not set by default.

debug         -- Can be set, but unused by the current implementation.

sys_immutable -- If set, ATTR_SYS attribute on FAT is handled as

		 IMMUTABLE flag on Linux. Not set by default.

flush         -- If set, the filesystem will try to flush to disk more

		 early than normal. Not set by default.

rodir	      -- FAT has the ATTR_RO (read-only) attribute. But on Windows,

		 the ATTR_RO of the directory will be just ignored actually,

		 and is used by only applications as flag. E.g. it's setted

		 for the customized folder.

		 If you want to use ATTR_RO as read-only flag even for

		 the directory, set this option.

<bool>: 0,1,yes,no,true,false

TODO

The io_mapping functions in linux/io-mapping.h provide an abstraction for

efficiently mapping small regions of an I/O device to the CPU. The initial

usage is to support the large graphics aperture on 32-bit processors where

ioremap_wc cannot be used to statically map the entire aperture to the CPU

as it would consume too much of the kernel address space.

A mapping object is created during driver initialization using

	struct io_mapping *io_mapping_create_wc(unsigned long base,

						unsigned long size)

		'base' is the bus address of the region to be made

		mappable, while 'size' indicates how large a mapping region to

		enable. Both are in bytes.

		This _wc variant provides a mapping which may only be used

		with the io_mapping_map_atomic_wc or io_mapping_map_wc.

With this mapping object, individual pages can be mapped either atomically

or not, depending on the necessary scheduling environment. Of course, atomic

maps are more efficient:

	void *io_mapping_map_atomic_wc(struct io_mapping *mapping,

				       unsigned long offset)

		'offset' is the offset within the defined mapping region.

		Accessing addresses beyond the region specified in the

		creation function yields undefined results. Using an offset

		which is not page aligned yields an undefined result. The

		return value points to a single page in CPU address space.

		This _wc variant returns a write-combining map to the

		page and may only be used with mappings created by

		io_mapping_create_wc

		Note that the task may not sleep while holding this page

		mapped.

	void io_mapping_unmap_atomic(void *vaddr)

		'vaddr' must be the the value returned by the last

		io_mapping_map_atomic_wc call. This unmaps the specified

		page and allows the task to sleep once again.

If you need to sleep while holding the lock, you can use the non-atomic

variant, although they may be significantly slower.

	void *io_mapping_map_wc(struct io_mapping *mapping,

				unsigned long offset)

		This works like io_mapping_map_atomic_wc except it allows

		the task to sleep while holding the page mapped.

	void io_mapping_unmap(void *vaddr)

		This works like io_mapping_unmap_atomic, except it is used

		for pages mapped with io_mapping_map_wc.

At driver close time, the io_mapping object must be freed:

	void io_mapping_free(struct io_mapping *mapping)

Current Implementation:

The initial implementation of these functions uses existing mapping

mechanisms and so provides only an abstraction layer and no new

functionality.

On 64-bit processors, io_mapping_create_wc calls ioremap_wc for the whole

range, creating a permanent kernel-visible mapping to the resource. The

map_atomic and map functions add the requested offset to the base of the

virtual address returned by ioremap_wc.

On 32-bit processors with HIGHMEM defined, io_mapping_map_atomic_wc uses

kmap_atomic_pfn to map the specified page in an atomic fashion;

kmap_atomic_pfn isn't really supposed to be used with device pages, but it

provides an efficient mapping for this usage.

On 32-bit processors without HIGHMEM defined, io_mapping_map_atomic_wc and

io_mapping_map_wc both use ioremap_wc, a terribly inefficient function which

performs an IPI to inform all processors about the new mapping. This results

in a significant performance penalty.

			Format:

			<cpu number>,...,<cpu number>

			or

			<cpu number>-<cpu number>  (must be a positive range in ascending order)

			<cpu number>-<cpu number>

			(must be a positive range in ascending order)

			or a mixture

			<cpu number>,...,<cpu number>-<cpu number>

			This option can be used to specify one or more CPUs

			to isolate from the general SMP balancing and scheduling

			algorithms. The only way to move a process onto or off

			an "isolated" CPU is via the CPU affinity syscalls.

			algorithms. You can move a process onto or off an

			"isolated" CPU via the CPU affinity syscalls or cpuset.

			<cpu number> begins at 0 and the maximum value is

			"number of CPUs in system - 1".

			Valid arguments: on, off

			Default: on

	noirqbalance	[X86-32,SMP,KNL] Disable kernel irq balancing

	noirqdebug	[X86-32] Disables the code which attempts to detect and

			disable unhandled interrupt sources.