evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6 into for-linus

Browse source
This commit is contained in:
Lachlan McIlroy 2008-05-19 15:09:05 +10:00
commit c203e45f06
3038 changed files with 120326 additions and 49010 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -41,6 +41,7 @@ include/linux/autoconf.h
include/linux/compile.h include/linux/compile.h
include/linux/version.h include/linux/version.h
include/linux/utsrelease.h include/linux/utsrelease.h
include/linux/bounds.h
# stgit generated dirs # stgit generated dirs
patches-* patches-*

1
.mailmap
View file

@ -88,6 +88,7 @@ Rudolf Marek <R.Marek@sh.cvut.cz>
Rui Saraiva <rmps@joel.ist.utl.pt> Rui Saraiva <rmps@joel.ist.utl.pt>
Sachin P Sant <ssant@in.ibm.com> Sachin P Sant <ssant@in.ibm.com>
Sam Ravnborg <sam@mars.ravnborg.org> Sam Ravnborg <sam@mars.ravnborg.org>
S.Çağlar Onur <caglar@pardus.org.tr>
Simon Kelley <simon@thekelleys.org.uk> Simon Kelley <simon@thekelleys.org.uk>
Stéphane Witzmann <stephane.witzmann@ubpmes.univ-bpclermont.fr> Stéphane Witzmann <stephane.witzmann@ubpmes.univ-bpclermont.fr>
Stephen Hemminger <shemminger@osdl.org> Stephen Hemminger <shemminger@osdl.org>

46
Documentation/ABI/testing/sysfs-class-bdi Normal file
View file

@ -0,0 +1,46 @@
What: /sys/class/bdi/<bdi>/
Date: January 2008
Contact: Peter Zijlstra <a.p.zijlstra@chello.nl>
Description:
Provide a place in sysfs for the backing_dev_info object. This allows
setting and retrieving various BDI specific variables.
The <bdi> identifier can be either of the following:
MAJOR:MINOR
Device number for block devices, or value of st_dev on
non-block filesystems which provide their own BDI, such as NFS
and FUSE.
default
The default backing dev, used for non-block device backed
filesystems which do not provide their own BDI.
Files under /sys/class/bdi/<bdi>/
---------------------------------
read_ahead_kb (read-write)
Size of the read-ahead window in kilobytes
min_ratio (read-write)
Under normal circumstances each device is given a part of the
total write-back cache that relates to its current average
writeout speed in relation to the other devices.
The 'min_ratio' parameter allows assigning a minimum
percentage of the write-back cache to a particular device.
For example, this is useful for providing a minimum QoS.
max_ratio (read-write)
Allows limiting a particular device to use not more than the
given percentage of the write-back cache. This is useful in
situations where we want to avoid one device taking all or
most of the write-back cache. For example in case of an NFS
mount that is prone to get stuck, or a FUSE mount which cannot
be trusted to play fair.

69
Documentation/DMA-API.txt
View file

@ -145,7 +145,7 @@ Part Ic - DMA addressing limitations
int int
dma_supported(struct device *dev, u64 mask) dma_supported(struct device *dev, u64 mask)
int int
pci_dma_supported(struct device *dev, u64 mask) pci_dma_supported(struct pci_dev *hwdev, u64 mask)
Checks to see if the device can support DMA to the memory described by Checks to see if the device can support DMA to the memory described by
mask. mask.
@ -189,7 +189,7 @@ dma_addr_t
dma_map_single(struct device *dev, void *cpu_addr, size_t size, dma_map_single(struct device *dev, void *cpu_addr, size_t size,
enum dma_data_direction direction) enum dma_data_direction direction)
dma_addr_t dma_addr_t
pci_map_single(struct device *dev, void *cpu_addr, size_t size, pci_map_single(struct pci_dev *hwdev, void *cpu_addr, size_t size,
int direction) int direction)
Maps a piece of processor virtual memory so it can be accessed by the Maps a piece of processor virtual memory so it can be accessed by the
@ -395,6 +395,71 @@ Notes: You must do this:
See also dma_map_single(). See also dma_map_single().
dma_addr_t
dma_map_single_attrs(struct device *dev, void *cpu_addr, size_t size,
enum dma_data_direction dir,
struct dma_attrs *attrs)
void
dma_unmap_single_attrs(struct device *dev, dma_addr_t dma_addr,
size_t size, enum dma_data_direction dir,
struct dma_attrs *attrs)
int
dma_map_sg_attrs(struct device *dev, struct scatterlist *sgl,
int nents, enum dma_data_direction dir,
struct dma_attrs *attrs)
void
dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sgl,
int nents, enum dma_data_direction dir,
struct dma_attrs *attrs)
The four functions above are just like the counterpart functions
without the _attrs suffixes, except that they pass an optional
struct dma_attrs*.
struct dma_attrs encapsulates a set of "dma attributes". For the
definition of struct dma_attrs see linux/dma-attrs.h.
The interpretation of dma attributes is architecture-specific, and
each attribute should be documented in Documentation/DMA-attributes.txt.
If struct dma_attrs* is NULL, the semantics of each of these
functions is identical to those of the corresponding function
without the _attrs suffix. As a result dma_map_single_attrs()
can generally replace dma_map_single(), etc.
As an example of the use of the *_attrs functions, here's how
you could pass an attribute DMA_ATTR_FOO when mapping memory
for DMA:
#include <linux/dma-attrs.h>
/* DMA_ATTR_FOO should be defined in linux/dma-attrs.h and
* documented in Documentation/DMA-attributes.txt */
...
DEFINE_DMA_ATTRS(attrs);
dma_set_attr(DMA_ATTR_FOO, &attrs);
....
n = dma_map_sg_attrs(dev, sg, nents, DMA_TO_DEVICE, &attr);
....
Architectures that care about DMA_ATTR_FOO would check for its
presence in their implementations of the mapping and unmapping
routines, e.g.:
void whizco_dma_map_sg_attrs(struct device *dev, dma_addr_t dma_addr,
size_t size, enum dma_data_direction dir,
struct dma_attrs *attrs)
{
....
int foo = dma_get_attr(DMA_ATTR_FOO, attrs);
....
if (foo)
/* twizzle the frobnozzle */
....
Part II - Advanced dma_ usage Part II - Advanced dma_ usage
----------------------------- -----------------------------

24
Documentation/DMA-attributes.txt Normal file
View file

@ -0,0 +1,24 @@
DMA attributes
==============
This document describes the semantics of the DMA attributes that are
defined in linux/dma-attrs.h.
DMA_ATTR_WRITE_BARRIER
----------------------
DMA_ATTR_WRITE_BARRIER is a (write) barrier attribute for DMA. DMA
to a memory region with the DMA_ATTR_WRITE_BARRIER attribute forces
all pending DMA writes to complete, and thus provides a mechanism to
strictly order DMA from a device across all intervening busses and
bridges. This barrier is not specific to a particular type of
interconnect, it applies to the system as a whole, and so its
implementation must account for the idiosyncracies of the system all
the way from the DMA device to memory.
As an example of a situation where DMA_ATTR_WRITE_BARRIER would be
useful, suppose that a device does a DMA write to indicate that data is
ready and available in memory. The DMA of the "completion indication"
could race with data DMA. Mapping the memory used for completion
indications with DMA_ATTR_WRITE_BARRIER would prevent the race.

38
Documentation/DMA-mapping.txt
View file

@ -315,11 +315,11 @@ you should do:
dma_addr_t dma_handle; dma_addr_t dma_handle;
cpu_addr = pci_alloc_consistent(dev, size, &dma_handle); cpu_addr = pci_alloc_consistent(pdev, size, &dma_handle);
where dev is a struct pci_dev *. You should pass NULL for PCI like buses where pdev is a struct pci_dev *. This may be called in interrupt context.
where devices don't have struct pci_dev (like ISA, EISA). This may be You should use dma_alloc_coherent (see DMA-API.txt) for buses
called in interrupt context. where devices don't have struct pci_dev (like ISA, EISA).
This argument is needed because the DMA translations may be bus This argument is needed because the DMA translations may be bus
specific (and often is private to the bus which the device is attached specific (and often is private to the bus which the device is attached
@ -332,7 +332,7 @@ __get_free_pages (but takes size instead of a page order). If your
driver needs regions sized smaller than a page, you may prefer using driver needs regions sized smaller than a page, you may prefer using
the pci_pool interface, described below. the pci_pool interface, described below.
The consistent DMA mapping interfaces, for non-NULL dev, will by The consistent DMA mapping interfaces, for non-NULL pdev, will by
default return a DMA address which is SAC (Single Address Cycle) default return a DMA address which is SAC (Single Address Cycle)
addressable. Even if the device indicates (via PCI dma mask) that it addressable. Even if the device indicates (via PCI dma mask) that it
may address the upper 32-bits and thus perform DAC cycles, consistent may address the upper 32-bits and thus perform DAC cycles, consistent
@ -354,9 +354,9 @@ buffer you receive will not cross a 64K boundary.
To unmap and free such a DMA region, you call: To unmap and free such a DMA region, you call:
pci_free_consistent(dev, size, cpu_addr, dma_handle); pci_free_consistent(pdev, size, cpu_addr, dma_handle);
where dev, size are the same as in the above call and cpu_addr and where pdev, size are the same as in the above call and cpu_addr and
dma_handle are the values pci_alloc_consistent returned to you. dma_handle are the values pci_alloc_consistent returned to you.
This function may not be called in interrupt context. This function may not be called in interrupt context.
@ -371,9 +371,9 @@ Create a pci_pool like this:
struct pci_pool *pool; struct pci_pool *pool;
pool = pci_pool_create(name, dev, size, align, alloc); pool = pci_pool_create(name, pdev, size, align, alloc);
The "name" is for diagnostics (like a kmem_cache name); dev and size The "name" is for diagnostics (like a kmem_cache name); pdev and size
are as above. The device's hardware alignment requirement for this are as above. The device's hardware alignment requirement for this
type of data is "align" (which is expressed in bytes, and must be a type of data is "align" (which is expressed in bytes, and must be a
power of two). If your device has no boundary crossing restrictions, power of two). If your device has no boundary crossing restrictions,
@ -472,11 +472,11 @@ To map a single region, you do:
void *addr = buffer->ptr; void *addr = buffer->ptr;
size_t size = buffer->len; size_t size = buffer->len;
dma_handle = pci_map_single(dev, addr, size, direction); dma_handle = pci_map_single(pdev, addr, size, direction);
and to unmap it: and to unmap it:
pci_unmap_single(dev, dma_handle, size, direction); pci_unmap_single(pdev, dma_handle, size, direction);
You should call pci_unmap_single when the DMA activity is finished, e.g. You should call pci_unmap_single when the DMA activity is finished, e.g.
from the interrupt which told you that the DMA transfer is done. from the interrupt which told you that the DMA transfer is done.
@ -493,17 +493,17 @@ Specifically:
unsigned long offset = buffer->offset; unsigned long offset = buffer->offset;
size_t size = buffer->len; size_t size = buffer->len;
dma_handle = pci_map_page(dev, page, offset, size, direction); dma_handle = pci_map_page(pdev, page, offset, size, direction);
... ...
pci_unmap_page(dev, dma_handle, size, direction); pci_unmap_page(pdev, dma_handle, size, direction);
Here, "offset" means byte offset within the given page. Here, "offset" means byte offset within the given page.
With scatterlists, you map a region gathered from several regions by: With scatterlists, you map a region gathered from several regions by:
int i, count = pci_map_sg(dev, sglist, nents, direction); int i, count = pci_map_sg(pdev, sglist, nents, direction);
struct scatterlist *sg; struct scatterlist *sg;
for_each_sg(sglist, sg, count, i) { for_each_sg(sglist, sg, count, i) {
@ -527,7 +527,7 @@ accessed sg->address and sg->length as shown above.
To unmap a scatterlist, just call: To unmap a scatterlist, just call:
pci_unmap_sg(dev, sglist, nents, direction); pci_unmap_sg(pdev, sglist, nents, direction);
Again, make sure DMA activity has already finished. Again, make sure DMA activity has already finished.
@ -550,11 +550,11 @@ correct copy of the DMA buffer.
So, firstly, just map it with pci_map_{single,sg}, and after each DMA So, firstly, just map it with pci_map_{single,sg}, and after each DMA
transfer call either: transfer call either:
pci_dma_sync_single_for_cpu(dev, dma_handle, size, direction); pci_dma_sync_single_for_cpu(pdev, dma_handle, size, direction);
or: or:
pci_dma_sync_sg_for_cpu(dev, sglist, nents, direction); pci_dma_sync_sg_for_cpu(pdev, sglist, nents, direction);
as appropriate. as appropriate.
@ -562,7 +562,7 @@ Then, if you wish to let the device get at the DMA area again,
finish accessing the data with the cpu, and then before actually finish accessing the data with the cpu, and then before actually
giving the buffer to the hardware call either: giving the buffer to the hardware call either:
pci_dma_sync_single_for_device(dev, dma_handle, size, direction); pci_dma_sync_single_for_device(pdev, dma_handle, size, direction);
or: or:
@ -739,7 +739,7 @@ failure can be determined by:
dma_addr_t dma_handle; dma_addr_t dma_handle;
dma_handle = pci_map_single(dev, addr, size, direction); dma_handle = pci_map_single(pdev, addr, size, direction);
if (pci_dma_mapping_error(dma_handle)) { if (pci_dma_mapping_error(dma_handle)) {
/* /*
* reduce current DMA mapping usage, * reduce current DMA mapping usage,

2
Documentation/DocBook/Makefile
View file

@ -12,7 +12,7 @@ DOCBOOKS := wanbook.xml z8530book.xml mcabook.xml videobook.xml \
kernel-api.xml filesystems.xml lsm.xml usb.xml kgdb.xml \ kernel-api.xml filesystems.xml lsm.xml usb.xml kgdb.xml \
gadget.xml libata.xml mtdnand.xml librs.xml rapidio.xml \ gadget.xml libata.xml mtdnand.xml librs.xml rapidio.xml \
genericirq.xml s390-drivers.xml uio-howto.xml scsi.xml \ genericirq.xml s390-drivers.xml uio-howto.xml scsi.xml \
mac80211.xml mac80211.xml debugobjects.xml
### ###
# The build process is as follows (targets): # The build process is as follows (targets):

391
Documentation/DocBook/debugobjects.tmpl Normal file
View file

@ -0,0 +1,391 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
"http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" []>
<book id="debug-objects-guide">
<bookinfo>
<title>Debug objects life time</title>
<authorgroup>
<author>
<firstname>Thomas</firstname>
<surname>Gleixner</surname>
<affiliation>
<address>
<email>tglx@linutronix.de</email>
</address>
</affiliation>
</author>
</authorgroup>
<copyright>
<year>2008</year>
<holder>Thomas Gleixner</holder>
</copyright>
<legalnotice>
<para>
This documentation is free software; you can redistribute
it and/or modify it under the terms of the GNU General Public
License version 2 as published by the Free Software Foundation.
</para>
<para>
This program is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
</para>
<para>
You should have received a copy of the GNU General Public
License along with this program; if not, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
MA 02111-1307 USA
</para>
<para>
For more details see the file COPYING in the source
distribution of Linux.
</para>
</legalnotice>
</bookinfo>
<toc></toc>
<chapter id="intro">
<title>Introduction</title>
<para>
debugobjects is a generic infrastructure to track the life time
of kernel objects and validate the operations on those.
</para>
<para>
debugobjects is useful to check for the following error patterns:
<itemizedlist>
<listitem><para>Activation of uninitialized objects</para></listitem>
<listitem><para>Initialization of active objects</para></listitem>
<listitem><para>Usage of freed/destroyed objects</para></listitem>
</itemizedlist>
</para>
<para>
debugobjects is not changing the data structure of the real
object so it can be compiled in with a minimal runtime impact
and enabled on demand with a kernel command line option.
</para>
</chapter>
<chapter id="howto">
<title>Howto use debugobjects</title>
<para>
A kernel subsystem needs to provide a data structure which
describes the object type and add calls into the debug code at
appropriate places. The data structure to describe the object
type needs at minimum the name of the object type. Optional
functions can and should be provided to fixup detected problems
so the kernel can continue to work and the debug information can
be retrieved from a live system instead of hard core debugging
with serial consoles and stack trace transcripts from the
monitor.
</para>
<para>
The debug calls provided by debugobjects are:
<itemizedlist>
<listitem><para>debug_object_init</para></listitem>
<listitem><para>debug_object_init_on_stack</para></listitem>
<listitem><para>debug_object_activate</para></listitem>
<listitem><para>debug_object_deactivate</para></listitem>
<listitem><para>debug_object_destroy</para></listitem>
<listitem><para>debug_object_free</para></listitem>
</itemizedlist>
Each of these functions takes the address of the real object and
a pointer to the object type specific debug description
structure.
</para>
<para>
Each detected error is reported in the statistics and a limited
number of errors are printk'ed including a full stack trace.
</para>
<para>
The statistics are available via debugfs/debug_objects/stats.
They provide information about the number of warnings and the
number of successful fixups along with information about the
usage of the internal tracking objects and the state of the
internal tracking objects pool.
</para>
</chapter>
<chapter id="debugfunctions">
<title>Debug functions</title>
<sect1 id="prototypes">
<title>Debug object function reference</title>
!Elib/debugobjects.c
</sect1>
<sect1 id="debug_object_init">
<title>debug_object_init</title>
<para>
This function is called whenever the initialization function
of a real object is called.
</para>
<para>
When the real object is already tracked by debugobjects it is
checked, whether the object can be initialized. Initializing
is not allowed for active and destroyed objects. When
debugobjects detects an error, then it calls the fixup_init
function of the object type description structure if provided
by the caller. The fixup function can correct the problem
before the real initialization of the object happens. E.g. it
can deactivate an active object in order to prevent damage to
the subsystem.
</para>
<para>
When the real object is not yet tracked by debugobjects,
debugobjects allocates a tracker object for the real object
and sets the tracker object state to ODEBUG_STATE_INIT. It
verifies that the object is not on the callers stack. If it is
on the callers stack then a limited number of warnings
including a full stack trace is printk'ed. The calling code
must use debug_object_init_on_stack() and remove the object
before leaving the function which allocated it. See next
section.
</para>
</sect1>
<sect1 id="debug_object_init_on_stack">
<title>debug_object_init_on_stack</title>
<para>
This function is called whenever the initialization function
of a real object which resides on the stack is called.
</para>
<para>
When the real object is already tracked by debugobjects it is
checked, whether the object can be initialized. Initializing
is not allowed for active and destroyed objects. When
debugobjects detects an error, then it calls the fixup_init
function of the object type description structure if provided
by the caller. The fixup function can correct the problem
before the real initialization of the object happens. E.g. it
can deactivate an active object in order to prevent damage to
the subsystem.
</para>
<para>
When the real object is not yet tracked by debugobjects
debugobjects allocates a tracker object for the real object
and sets the tracker object state to ODEBUG_STATE_INIT. It
verifies that the object is on the callers stack.
</para>
<para>
An object which is on the stack must be removed from the
tracker by calling debug_object_free() before the function
which allocates the object returns. Otherwise we keep track of
stale objects.
</para>
</sect1>
<sect1 id="debug_object_activate">
<title>debug_object_activate</title>
<para>
This function is called whenever the activation function of a
real object is called.
</para>
<para>
When the real object is already tracked by debugobjects it is
checked, whether the object can be activated. Activating is
not allowed for active and destroyed objects. When
debugobjects detects an error, then it calls the
fixup_activate function of the object type description
structure if provided by the caller. The fixup function can
correct the problem before the real activation of the object
happens. E.g. it can deactivate an active object in order to
prevent damage to the subsystem.
</para>
<para>
When the real object is not yet tracked by debugobjects then
the fixup_activate function is called if available. This is
necessary to allow the legitimate activation of statically
allocated and initialized objects. The fixup function checks
whether the object is valid and calls the debug_objects_init()
function to initialize the tracking of this object.
</para>
<para>
When the activation is legitimate, then the state of the
associated tracker object is set to ODEBUG_STATE_ACTIVE.
</para>
</sect1>
<sect1 id="debug_object_deactivate">
<title>debug_object_deactivate</title>
<para>
This function is called whenever the deactivation function of
a real object is called.
</para>
<para>
When the real object is tracked by debugobjects it is checked,
whether the object can be deactivated. Deactivating is not
allowed for untracked or destroyed objects.
</para>
<para>
When the deactivation is legitimate, then the state of the
associated tracker object is set to ODEBUG_STATE_INACTIVE.
</para>
</sect1>
<sect1 id="debug_object_destroy">
<title>debug_object_destroy</title>
<para>
This function is called to mark an object destroyed. This is
useful to prevent the usage of invalid objects, which are
still available in memory: either statically allocated objects
or objects which are freed later.
</para>
<para>
When the real object is tracked by debugobjects it is checked,
whether the object can be destroyed. Destruction is not
allowed for active and destroyed objects. When debugobjects
detects an error, then it calls the fixup_destroy function of
the object type description structure if provided by the
caller. The fixup function can correct the problem before the
real destruction of the object happens. E.g. it can deactivate
an active object in order to prevent damage to the subsystem.
</para>
<para>
When the destruction is legitimate, then the state of the
associated tracker object is set to ODEBUG_STATE_DESTROYED.
</para>
</sect1>
<sect1 id="debug_object_free">
<title>debug_object_free</title>
<para>
This function is called before an object is freed.
</para>
<para>
When the real object is tracked by debugobjects it is checked,
whether the object can be freed. Free is not allowed for
active objects. When debugobjects detects an error, then it
calls the fixup_free function of the object type description
structure if provided by the caller. The fixup function can
correct the problem before the real free of the object
happens. E.g. it can deactivate an active object in order to
prevent damage to the subsystem.
</para>
<para>
Note that debug_object_free removes the object from the
tracker. Later usage of the object is detected by the other
debug checks.
</para>
</sect1>
</chapter>
<chapter id="fixupfunctions">
<title>Fixup functions</title>
<sect1 id="debug_obj_descr">
<title>Debug object type description structure</title>
!Iinclude/linux/debugobjects.h
</sect1>
<sect1 id="fixup_init">
<title>fixup_init</title>
<para>
This function is called from the debug code whenever a problem
in debug_object_init is detected. The function takes the
address of the object and the state which is currently
recorded in the tracker.
</para>
<para>
Called from debug_object_init when the object state is:
<itemizedlist>
<listitem><para>ODEBUG_STATE_ACTIVE</para></listitem>
</itemizedlist>
</para>
<para>
The function returns 1 when the fixup was successful,
otherwise 0. The return value is used to update the
statistics.
</para>
<para>
Note, that the function needs to call the debug_object_init()
function again, after the damage has been repaired in order to
keep the state consistent.
</para>
</sect1>
<sect1 id="fixup_activate">
<title>fixup_activate</title>
<para>
This function is called from the debug code whenever a problem
in debug_object_activate is detected.
</para>
<para>
Called from debug_object_activate when the object state is:
<itemizedlist>
<listitem><para>ODEBUG_STATE_NOTAVAILABLE</para></listitem>
<listitem><para>ODEBUG_STATE_ACTIVE</para></listitem>
</itemizedlist>
</para>
<para>
The function returns 1 when the fixup was successful,
otherwise 0. The return value is used to update the
statistics.
</para>
<para>
Note that the function needs to call the debug_object_activate()
function again after the damage has been repaired in order to
keep the state consistent.
</para>
<para>
The activation of statically initialized objects is a special
case. When debug_object_activate() has no tracked object for
this object address then fixup_activate() is called with
object state ODEBUG_STATE_NOTAVAILABLE. The fixup function
needs to check whether this is a legitimate case of a
statically initialized object or not. In case it is it calls
debug_object_init() and debug_object_activate() to make the
object known to the tracker and marked active. In this case
the function should return 0 because this is not a real fixup.
</para>
</sect1>
<sect1 id="fixup_destroy">
<title>fixup_destroy</title>
<para>
This function is called from the debug code whenever a problem
in debug_object_destroy is detected.
</para>
<para>
Called from debug_object_destroy when the object state is:
<itemizedlist>
<listitem><para>ODEBUG_STATE_ACTIVE</para></listitem>
</itemizedlist>
</para>
<para>
The function returns 1 when the fixup was successful,
otherwise 0. The return value is used to update the
statistics.
</para>
</sect1>
<sect1 id="fixup_free">
<title>fixup_free</title>
<para>
This function is called from the debug code whenever a problem
in debug_object_free is detected. Further it can be called
from the debug checks in kfree/vfree, when an active object is
detected from the debug_check_no_obj_freed() sanity checks.
</para>
<para>
Called from debug_object_free() or debug_check_no_obj_freed()
when the object state is:
<itemizedlist>
<listitem><para>ODEBUG_STATE_ACTIVE</para></listitem>
</itemizedlist>
</para>
<para>
The function returns 1 when the fixup was successful,
otherwise 0. The return value is used to update the
statistics.
</para>
</sect1>
</chapter>
<chapter id="bugs">
<title>Known Bugs And Assumptions</title>
<para>
None (knock on wood).
</para>
</chapter>
</book>

8
Documentation/DocBook/kgdb.tmpl
View file

@ -72,7 +72,7 @@
kgdb is a source level debugger for linux kernel. It is used along kgdb is a source level debugger for linux kernel. It is used along
with gdb to debug a linux kernel. The expectation is that gdb can with gdb to debug a linux kernel. The expectation is that gdb can
be used to "break in" to the kernel to inspect memory, variables be used to "break in" to the kernel to inspect memory, variables
and look through a cal stack information similar to what an and look through call stack information similar to what an
application developer would use gdb for. It is possible to place application developer would use gdb for. It is possible to place
breakpoints in kernel code and perform some limited execution breakpoints in kernel code and perform some limited execution
stepping. stepping.
@ -93,8 +93,10 @@
<chapter id="CompilingAKernel"> <chapter id="CompilingAKernel">
<title>Compiling a kernel</title> <title>Compiling a kernel</title>
<para> <para>
To enable <symbol>CONFIG_KGDB</symbol>, look under the "Kernel debugging" To enable <symbol>CONFIG_KGDB</symbol> you should first turn on
and then select "KGDB: kernel debugging with remote gdb". "Prompt for development and/or incomplete code/drivers"
(CONFIG_EXPERIMENTAL) in "General setup", then under the
"Kernel debugging" select "KGDB: kernel debugging with remote gdb".
</para> </para>
<para> <para>
Next you should choose one of more I/O drivers to interconnect debugging Next you should choose one of more I/O drivers to interconnect debugging

1
Documentation/DocBook/rapidio.tmpl
View file

@ -133,7 +133,6 @@
!Idrivers/rapidio/rio-sysfs.c !Idrivers/rapidio/rio-sysfs.c
</sect1> </sect1>
<sect1 id="PPC32_support"><title>PPC32 support</title> <sect1 id="PPC32_support"><title>PPC32 support</title>
!Iarch/powerpc/kernel/rio.c
!Earch/powerpc/sysdev/fsl_rio.c !Earch/powerpc/sysdev/fsl_rio.c
!Iarch/powerpc/sysdev/fsl_rio.c !Iarch/powerpc/sysdev/fsl_rio.c
</sect1> </sect1>

34
Documentation/braille-console.txt Normal file
View file

@ -0,0 +1,34 @@
Linux Braille Console
To get early boot messages on a braille device (before userspace screen
readers can start), you first need to compile the support for the usual serial
console (see serial-console.txt), and for braille device (in Device Drivers -
Accessibility).
Then you need to specify a console=brl, option on the kernel command line, the
format is:
console=brl,serial_options...
where serial_options... are the same as described in serial-console.txt
So for instance you can use console=brl,ttyS0 if the braille device is connected
to the first serial port, and console=brl,ttyS0,115200 to override the baud rate
to 115200, etc.
By default, the braille device will just show the last kernel message (console
mode). To review previous messages, press the Insert key to switch to the VT
review mode. In review mode, the arrow keys permit to browse in the VT content,
page up/down keys go at the top/bottom of the screen, and the home key goes back
to the cursor, hence providing very basic screen reviewing facility.
Sound feedback can be obtained by adding the braille_console.sound=1 kernel
parameter.
For simplicity, only one braille console can be enabled, other uses of
console=brl,... will be discarded. Also note that it does not interfere with
the console selection mecanism described in serial-console.txt
For now, only the VisioBraille device is supported.
Samuel Thibault <samuel.thibault@ens-lyon.org>

7
Documentation/cgroups.txt
View file

@ -310,8 +310,8 @@ and then start a subshell 'sh' in that cgroup:
cd /dev/cgroup cd /dev/cgroup
mkdir Charlie mkdir Charlie
cd Charlie cd Charlie
/bin/echo 2-3 > cpus /bin/echo 2-3 > cpuset.cpus
/bin/echo 1 > mems /bin/echo 1 > cpuset.mems
/bin/echo $$ > tasks /bin/echo $$ > tasks
sh sh
# The subshell 'sh' is now running in cgroup Charlie # The subshell 'sh' is now running in cgroup Charlie
@ -500,8 +500,7 @@ post-attachment activity that requires memory allocations or blocking.
void fork(struct cgroup_subsy *ss, struct task_struct *task) void fork(struct cgroup_subsy *ss, struct task_struct *task)
Called when a task is forked into a cgroup. Also called during Called when a task is forked into a cgroup.
registration for all existing tasks.
void exit(struct cgroup_subsys *ss, struct task_struct *task) void exit(struct cgroup_subsys *ss, struct task_struct *task)

48
Documentation/controllers/devices.txt Normal file
View file

@ -0,0 +1,48 @@
Device Whitelist Controller
1. Description:
Implement a cgroup to track and enforce open and mknod restrictions
on device files. A device cgroup associates a device access
whitelist with each cgroup. A whitelist entry has 4 fields.
'type' is a (all), c (char), or b (block). 'all' means it applies
to all types and all major and minor numbers. Major and minor are
either an integer or * for all. Access is a composition of r
(read), w (write), and m (mknod).
The root device cgroup starts with rwm to 'all'. A child device
cgroup gets a copy of the parent. Administrators can then remove
devices from the whitelist or add new entries. A child cgroup can
never receive a device access which is denied its parent. However
when a device access is removed from a parent it will not also be
removed from the child(ren).
2. User Interface
An entry is added using devices.allow, and removed using
devices.deny. For instance
echo 'c 1:3 mr' > /cgroups/1/devices.allow
allows cgroup 1 to read and mknod the device usually known as
/dev/null. Doing
echo a > /cgroups/1/devices.deny
will remove the default 'a *:* mrw' entry.
3. Security
Any task can move itself between cgroups. This clearly won't
suffice, but we can decide the best way to adequately restrict
movement as people get some experience with this. We may just want
to require CAP_SYS_ADMIN, which at least is a separate bit from
CAP_MKNOD. We may want to just refuse moving to a cgroup which
isn't a descendent of the current one. Or we may want to use
CAP_MAC_ADMIN, since we really are trying to lock down root.
CAP_SYS_ADMIN is needed to modify the whitelist or move another
task to a new cgroup. (Again we'll probably want to change that).
A cgroup may not be granted more permissions than the cgroup's
parent has.

181
Documentation/controllers/resource_counter.txt Normal file
View file

@ -0,0 +1,181 @@
The Resource Counter
The resource counter, declared at include/linux/res_counter.h,
is supposed to facilitate the resource management by controllers
by providing common stuff for accounting.
This "stuff" includes the res_counter structure and routines
to work with it.
1. Crucial parts of the res_counter structure
a. unsigned long long usage
The usage value shows the amount of a resource that is consumed
by a group at a given time. The units of measurement should be
determined by the controller that uses this counter. E.g. it can
be bytes, items or any other unit the controller operates on.
b. unsigned long long max_usage
The maximal value of the usage over time.
This value is useful when gathering statistical information about
the particular group, as it shows the actual resource requirements
for a particular group, not just some usage snapshot.
c. unsigned long long limit
The maximal allowed amount of resource to consume by the group. In
case the group requests for more resources, so that the usage value
would exceed the limit, the resource allocation is rejected (see
the next section).
d. unsigned long long failcnt
The failcnt stands for "failures counter". This is the number of
resource allocation attempts that failed.
c. spinlock_t lock
Protects changes of the above values.
2. Basic accounting routines
a. void res_counter_init(struct res_counter *rc)
Initializes the resource counter. As usual, should be the first
routine called for a new counter.
b. int res_counter_charge[_locked]
(struct res_counter *rc, unsigned long val)
When a resource is about to be allocated it has to be accounted
with the appropriate resource counter (controller should determine
which one to use on its own). This operation is called "charging".
This is not very important which operation - resource allocation
or charging - is performed first, but
* if the allocation is performed first, this may create a
temporary resource over-usage by the time resource counter is
charged;
* if the charging is performed first, then it should be uncharged
on error path (if the one is called).
c. void res_counter_uncharge[_locked]
(struct res_counter *rc, unsigned long val)
When a resource is released (freed) it should be de-accounted
from the resource counter it was accounted to. This is called
"uncharging".
The _locked routines imply that the res_counter->lock is taken.
2.1 Other accounting routines
There are more routines that may help you with common needs, like
checking whether the limit is reached or resetting the max_usage
value. They are all declared in include/linux/res_counter.h.
3. Analyzing the resource counter registrations
a. If the failcnt value constantly grows, this means that the counter's
limit is too tight. Either the group is misbehaving and consumes too
many resources, or the configuration is not suitable for the group
and the limit should be increased.
b. The max_usage value can be used to quickly tune the group. One may
set the limits to maximal values and either load the container with
a common pattern or leave one for a while. After this the max_usage
value shows the amount of memory the container would require during
its common activity.
Setting the limit a bit above this value gives a pretty good
configuration that works in most of the cases.
c. If the max_usage is much less than the limit, but the failcnt value
is growing, then the group tries to allocate a big chunk of resource
at once.
d. If the max_usage is much less than the limit, but the failcnt value
is 0, then this group is given too high limit, that it does not
require. It is better to lower the limit a bit leaving more resource
for other groups.
4. Communication with the control groups subsystem (cgroups)
All the resource controllers that are using cgroups and resource counters
should provide files (in the cgroup filesystem) to work with the resource
counter fields. They are recommended to adhere to the following rules:
a. File names
Field name File name
---------------------------------------------------
usage usage_in_<unit_of_measurement>
max_usage max_usage_in_<unit_of_measurement>
limit limit_in_<unit_of_measurement>
failcnt failcnt
lock no file :)
b. Reading from file should show the corresponding field value in the
appropriate format.
c. Writing to file
Field Expected behavior
----------------------------------
usage prohibited
max_usage reset to usage
limit set the limit
failcnt reset to zero
5. Usage example
a. Declare a task group (take a look at cgroups subsystem for this) and
fold a res_counter into it
struct my_group {
struct res_counter res;
<other fields>
}
b. Put hooks in resource allocation/release paths
int alloc_something(...)
{
if (res_counter_charge(res_counter_ptr, amount) < 0)
return -ENOMEM;
<allocate the resource and return to the caller>
}
void release_something(...)
{
res_counter_uncharge(res_counter_ptr, amount);
<release the resource>
}
In order to keep the usage value self-consistent, both the
"res_counter_ptr" and the "amount" in release_something() should be
the same as they were in the alloc_something() when the releasing
resource was allocated.
c. Provide the way to read res_counter values and set them (the cgroups
still can help with it).
c. Compile and run :)

14
Documentation/cpu-freq/user-guide.txt
View file

@ -154,6 +154,11 @@ scaling_governor, and by "echoing" the name of another
that some governors won't load - they only that some governors won't load - they only
work on some specific architectures or work on some specific architectures or
processors. processors.
cpuinfo_cur_freq : Current speed of the CPU, in KHz.
scaling_available_frequencies : List of available frequencies, in KHz.
scaling_min_freq and scaling_min_freq and
scaling_max_freq show the current "policy limits" (in scaling_max_freq show the current "policy limits" (in
kHz). By echoing new values into these kHz). By echoing new values into these
@ -162,6 +167,15 @@ scaling_max_freq show the current "policy limits" (in
first set scaling_max_freq, then first set scaling_max_freq, then
scaling_min_freq. scaling_min_freq.
affected_cpus : List of CPUs that require software coordination
of frequency.
related_cpus : List of CPUs that need some sort of frequency
coordination, whether software or hardware.
scaling_driver : Hardware driver for cpufreq.
scaling_cur_freq : Current frequency of the CPU, in KHz.
If you have selected the "userspace" governor which allows you to If you have selected the "userspace" governor which allows you to
set the CPU operating frequency to a specific value, you can read out set the CPU operating frequency to a specific value, you can read out

26
Documentation/cpusets.txt
View file

@ -171,6 +171,7 @@ files describing that cpuset:
- memory_migrate flag: if set, move pages to cpusets nodes - memory_migrate flag: if set, move pages to cpusets nodes
- cpu_exclusive flag: is cpu placement exclusive? - cpu_exclusive flag: is cpu placement exclusive?
- mem_exclusive flag: is memory placement exclusive? - mem_exclusive flag: is memory placement exclusive?
- mem_hardwall flag: is memory allocation hardwalled
- memory_pressure: measure of how much paging pressure in cpuset - memory_pressure: measure of how much paging pressure in cpuset
In addition, the root cpuset only has the following file: In addition, the root cpuset only has the following file:
@ -222,17 +223,18 @@ If a cpuset is cpu or mem exclusive, no other cpuset, other than
a direct ancestor or descendent, may share any of the same CPUs or a direct ancestor or descendent, may share any of the same CPUs or
Memory Nodes. Memory Nodes.
A cpuset that is mem_exclusive restricts kernel allocations for A cpuset that is mem_exclusive *or* mem_hardwall is "hardwalled",
page, buffer and other data commonly shared by the kernel across i.e. it restricts kernel allocations for page, buffer and other data
multiple users. All cpusets, whether mem_exclusive or not, restrict commonly shared by the kernel across multiple users. All cpusets,
allocations of memory for user space. This enables configuring a whether hardwalled or not, restrict allocations of memory for user
system so that several independent jobs can share common kernel data, space. This enables configuring a system so that several independent
such as file system pages, while isolating each jobs user allocation in jobs can share common kernel data, such as file system pages, while
its own cpuset. To do this, construct a large mem_exclusive cpuset to isolating each job's user allocation in its own cpuset. To do this,
hold all the jobs, and construct child, non-mem_exclusive cpusets for construct a large mem_exclusive cpuset to hold all the jobs, and
each individual job. Only a small amount of typical kernel memory, construct child, non-mem_exclusive cpusets for each individual job.
such as requests from interrupt handlers, is allowed to be taken Only a small amount of typical kernel memory, such as requests from
outside even a mem_exclusive cpuset. interrupt handlers, is allowed to be taken outside even a
mem_exclusive cpuset.
1.5 What is memory_pressure ? 1.5 What is memory_pressure ?
@ -707,7 +709,7 @@ Now you want to do something with this cpuset.
In this directory you can find several files: In this directory you can find several files:
# ls # ls
cpus cpu_exclusive mems mem_exclusive tasks cpus cpu_exclusive mems mem_exclusive mem_hardwall tasks
Reading them will give you information about the state of this cpuset: Reading them will give you information about the state of this cpuset:
the CPUs and Memory Nodes it can use, the processes that are using the CPUs and Memory Nodes it can use, the processes that are using

26
Documentation/feature-removal-schedule.txt
View file

@ -138,6 +138,24 @@ Who: Kay Sievers <kay.sievers@suse.de>
--------------------------- ---------------------------
What: find_task_by_pid
When: 2.6.26
Why: With pid namespaces, calling this funciton will return the
wrong task when called from inside a namespace.
The best way to save a task pid and find a task by this
pid later, is to find this task's struct pid pointer (or get
it directly from the task) and call pid_task() later.
If someone really needs to get a task by its pid_t, then
he most likely needs the find_task_by_vpid() to get the
task from the same namespace as the current task is in, but
this may be not so in general.
Who: Pavel Emelyanov <xemul@openvz.org>
---------------------------
What: ACPI procfs interface What: ACPI procfs interface
When: July 2008 When: July 2008
Why: ACPI sysfs conversion should be finished by January 2008. Why: ACPI sysfs conversion should be finished by January 2008.
@ -271,6 +289,14 @@ Who: Glauber Costa <gcosta@redhat.com>
--------------------------- ---------------------------
What: old style serial driver for ColdFire (CONFIG_SERIAL_COLDFIRE)
When: 2.6.28
Why: This driver still uses the old interface and has been replaced
by CONFIG_SERIAL_MCF.
Who: Sebastian Siewior <sebastian@breakpoint.cc>
---------------------------
What: /sys/o2cb symlink What: /sys/o2cb symlink
When: January 2010 When: January 2010
Why: /sys/fs/o2cb is the proper location for this information - /sys/o2cb Why: /sys/fs/o2cb is the proper location for this information - /sys/o2cb

2
Documentation/filesystems/Locking
View file

@ -92,7 +92,6 @@ prototypes:
void (*destroy_inode)(struct inode *); void (*destroy_inode)(struct inode *);
void (*dirty_inode) (struct inode *); void (*dirty_inode) (struct inode *);
int (*write_inode) (struct inode *, int); int (*write_inode) (struct inode *, int);
void (*put_inode) (struct inode *);
void (*drop_inode) (struct inode *); void (*drop_inode) (struct inode *);
void (*delete_inode) (struct inode *); void (*delete_inode) (struct inode *);
void (*put_super) (struct super_block *); void (*put_super) (struct super_block *);
@ -115,7 +114,6 @@ alloc_inode: no no no
destroy_inode: no destroy_inode: no
dirty_inode: no (must not sleep) dirty_inode: no (must not sleep)
write_inode: no write_inode: no
put_inode: no
drop_inode: no !!!inode_lock!!! drop_inode: no !!!inode_lock!!!
delete_inode: no delete_inode: no
put_super: yes yes no put_super: yes yes no

21
Documentation/filesystems/proc.txt
View file

@ -463,11 +463,17 @@ SwapTotal: 0 kB
SwapFree: 0 kB SwapFree: 0 kB
Dirty: 968 kB Dirty: 968 kB
Writeback: 0 kB Writeback: 0 kB
AnonPages: 861800 kB
Mapped: 280372 kB Mapped: 280372 kB
Slab: 684068 kB Slab: 284364 kB
SReclaimable: 159856 kB
SUnreclaim: 124508 kB
PageTables: 24448 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
WritebackTmp: 0 kB
CommitLimit: 7669796 kB CommitLimit: 7669796 kB
Committed_AS: 100056 kB Committed_AS: 100056 kB
PageTables: 24448 kB
VmallocTotal: 112216 kB VmallocTotal: 112216 kB
VmallocUsed: 428 kB VmallocUsed: 428 kB
VmallocChunk: 111088 kB VmallocChunk: 111088 kB
@ -503,8 +509,17 @@ VmallocChunk: 111088 kB
on the disk on the disk
Dirty: Memory which is waiting to get written back to the disk Dirty: Memory which is waiting to get written back to the disk
Writeback: Memory which is actively being written back to the disk Writeback: Memory which is actively being written back to the disk
AnonPages: Non-file backed pages mapped into userspace page tables
Mapped: files which have been mmaped, such as libraries Mapped: files which have been mmaped, such as libraries
Slab: in-kernel data structures cache Slab: in-kernel data structures cache
SReclaimable: Part of Slab, that might be reclaimed, such as caches
SUnreclaim: Part of Slab, that cannot be reclaimed on memory pressure
PageTables: amount of memory dedicated to the lowest level of page
tables.
NFS_Unstable: NFS pages sent to the server, but not yet committed to stable
storage
Bounce: Memory used for block device "bounce buffers"
WritebackTmp: Memory used by FUSE for temporary writeback buffers
CommitLimit: Based on the overcommit ratio ('vm.overcommit_ratio'), CommitLimit: Based on the overcommit ratio ('vm.overcommit_ratio'),
this is the total amount of memory currently available to this is the total amount of memory currently available to
be allocated on the system. This limit is only adhered to be allocated on the system. This limit is only adhered to
@ -531,8 +546,6 @@ Committed_AS: The amount of memory presently allocated on the system.
above) will not be permitted. This is useful if one needs above) will not be permitted. This is useful if one needs
to guarantee that processes will not fail due to lack of to guarantee that processes will not fail due to lack of
memory once that memory has been successfully allocated. memory once that memory has been successfully allocated.
PageTables: amount of memory dedicated to the lowest level of page
tables.
VmallocTotal: total size of vmalloc memory area VmallocTotal: total size of vmalloc memory area
VmallocUsed: amount of vmalloc area which is used VmallocUsed: amount of vmalloc area which is used
VmallocChunk: largest contigious block of vmalloc area which is free VmallocChunk: largest contigious block of vmalloc area which is free

4
Documentation/filesystems/vfs.txt
View file

@ -205,7 +205,6 @@ struct super_operations {
void (*dirty_inode) (struct inode *); void (*dirty_inode) (struct inode *);
int (*write_inode) (struct inode *, int); int (*write_inode) (struct inode *, int);
void (*put_inode) (struct inode *);
void (*drop_inode) (struct inode *); void (*drop_inode) (struct inode *);
void (*delete_inode) (struct inode *); void (*delete_inode) (struct inode *);
void (*put_super) (struct super_block *); void (*put_super) (struct super_block *);
@ -246,9 +245,6 @@ or bottom half).
inode to disc. The second parameter indicates whether the write inode to disc. The second parameter indicates whether the write
should be synchronous or not, not all filesystems check this flag. should be synchronous or not, not all filesystems check this flag.
put_inode: called when the VFS inode is removed from the inode
cache.
drop_inode: called when the last access to the inode is dropped, drop_inode: called when the last access to the inode is dropped,
with the inode_lock spinlock held. with the inode_lock spinlock held.

3
Documentation/hwmon/adt7473
View file

@ -69,7 +69,8 @@ point2: Set the pwm speed at a higher temperature bound.
The ADT7473 will scale the pwm between the lower and higher pwm speed when The ADT7473 will scale the pwm between the lower and higher pwm speed when
the temperature is between the two temperature boundaries. PWM values range the temperature is between the two temperature boundaries. PWM values range
from 0 (off) to 255 (full speed). from 0 (off) to 255 (full speed). Fan speed will be set to maximum when the
temperature sensor associated with the PWM control exceeds temp#_max.
Notes Notes
----- -----

3
Documentation/hwmon/w83l785ts
View file

@ -33,7 +33,8 @@ Known Issues
------------ ------------
On some systems (Asus), the BIOS is known to interfere with the driver On some systems (Asus), the BIOS is known to interfere with the driver
and cause read errors. The driver will retry a given number of times and cause read errors. Or maybe the W83L785TS-S chip is simply unreliable,
we don't really know. The driver will retry a given number of times
(5 by default) and then give up, returning the old value (or 0 if (5 by default) and then give up, returning the old value (or 0 if
there is no old value). It seems to work well enough so that you should there is no old value). It seems to work well enough so that you should
not notice anything. Thanks to James Bolt for helping test this feature. not notice anything. Thanks to James Bolt for helping test this feature.

99
Documentation/i2c/functionality
View file

@ -51,26 +51,38 @@ A few combinations of the above flags are also defined for your convenience:
the transparent emulation layer) the transparent emulation layer)
ALGORITHM/ADAPTER IMPLEMENTATION ADAPTER IMPLEMENTATION
-------------------------------- ----------------------
When you write a new algorithm driver, you will have to implement a When you write a new adapter driver, you will have to implement a
function callback `functionality', that gets an i2c_adapter structure function callback `functionality'. Typical implementations are given
pointer as its only parameter: below.
struct i2c_algorithm { A typical SMBus-only adapter would list all the SMBus transactions it
/* Many other things of course; check <linux/i2c.h>! */ supports. This example comes from the i2c-piix4 driver:
u32 (*functionality) (struct i2c_adapter *);
}
A typically implementation is given below, from i2c-algo-bit.c: static u32 piix4_func(struct i2c_adapter *adapter)
static u32 bit_func(struct i2c_adapter *adap)
{ {
return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
I2C_FUNC_PROTOCOL_MANGLING; I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
I2C_FUNC_SMBUS_BLOCK_DATA;
} }
A typical full-I2C adapter would use the following (from the i2c-pxa
driver):
static u32 i2c_pxa_functionality(struct i2c_adapter *adap)
{
return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
}
I2C_FUNC_SMBUS_EMUL includes all the SMBus transactions (with the
addition of I2C block transactions) which i2c-core can emulate using
I2C_FUNC_I2C without any help from the adapter driver. The idea is
to let the client drivers check for the support of SMBus functions
without having to care whether the said functions are implemented in
hardware by the adapter, or emulated in software by i2c-core on top
of an I2C adapter.
CLIENT CHECKING CLIENT CHECKING
@ -78,36 +90,33 @@ CLIENT CHECKING
Before a client tries to attach to an adapter, or even do tests to check Before a client tries to attach to an adapter, or even do tests to check
whether one of the devices it supports is present on an adapter, it should whether one of the devices it supports is present on an adapter, it should
check whether the needed functionality is present. There are two functions check whether the needed functionality is present. The typical way to do
defined which should be used instead of calling the functionality hook this is (from the lm75 driver):
in the algorithm structure directly:
/* Return the functionality mask */ static int lm75_detect(...)
extern u32 i2c_get_functionality (struct i2c_adapter *adap);
/* Return 1 if adapter supports everything we need, 0 if not. */
extern int i2c_check_functionality (struct i2c_adapter *adap, u32 func);
This is a typical way to use these functions (from the writing-clients
document):
int foo_detect_client(struct i2c_adapter *adapter, int address,
unsigned short flags, int kind)
{ {
/* Define needed variables */ (...)
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
/* As the very first action, we check whether the adapter has the I2C_FUNC_SMBUS_WORD_DATA))
needed functionality: we need the SMBus read_word_data, goto exit;
write_word_data and write_byte functions in this example. */ (...)
if (!i2c_check_functionality(adapter,I2C_FUNC_SMBUS_WORD_DATA |
I2C_FUNC_SMBUS_WRITE_BYTE))
goto ERROR0;
/* Now we can do the real detection */
ERROR0:
/* Return an error */
} }
Here, the lm75 driver checks if the adapter can do both SMBus byte data
and SMBus word data transactions. If not, then the driver won't work on
this adapter and there's no point in going on. If the check above is
successful, then the driver knows that it can call the following
functions: i2c_smbus_read_byte_data(), i2c_smbus_write_byte_data(),
i2c_smbus_read_word_data() and i2c_smbus_write_word_data(). As a rule of
thumb, the functionality constants you test for with
i2c_check_functionality() should match exactly the i2c_smbus_* functions
which you driver is calling.
Note that the check above doesn't tell whether the functionalities are
implemented in hardware by the underlying adapter or emulated in
software by i2c-core. Client drivers don't have to care about this, as
i2c-core will transparently implement SMBus transactions on top of I2C
adapters.
CHECKING THROUGH /DEV CHECKING THROUGH /DEV
@ -116,19 +125,19 @@ CHECKING THROUGH /DEV
If you try to access an adapter from a userspace program, you will have If you try to access an adapter from a userspace program, you will have
to use the /dev interface. You will still have to check whether the to use the /dev interface. You will still have to check whether the
functionality you need is supported, of course. This is done using functionality you need is supported, of course. This is done using
the I2C_FUNCS ioctl. An example, adapted from the lm_sensors i2cdetect the I2C_FUNCS ioctl. An example, adapted from the i2cdetect program, is
program, is below: below:
int file; int file;
if (file = open("/dev/i2c-0",O_RDWR) < 0) { if (file = open("/dev/i2c-0", O_RDWR) < 0) {
/* Some kind of error handling */ /* Some kind of error handling */
exit(1); exit(1);
} }
if (ioctl(file,I2C_FUNCS,&funcs) < 0) { if (ioctl(file, I2C_FUNCS, &funcs) < 0) {
/* Some kind of error handling */ /* Some kind of error handling */
exit(1); exit(1);
} }
if (! (funcs & I2C_FUNC_SMBUS_QUICK)) { if (!(funcs & I2C_FUNC_SMBUS_QUICK)) {
/* Oops, the needed functionality (SMBus write_quick function) is /* Oops, the needed functionality (SMBus write_quick function) is
not available! */ not available! */
exit(1); exit(1);

81
Documentation/i2c/smbus-protocol
View file

@ -1,5 +1,6 @@
SMBus Protocol Summary SMBus Protocol Summary
====================== ======================
The following is a summary of the SMBus protocol. It applies to The following is a summary of the SMBus protocol. It applies to
all revisions of the protocol (1.0, 1.1, and 2.0). all revisions of the protocol (1.0, 1.1, and 2.0).
Certain protocol features which are not supported by Certain protocol features which are not supported by
@ -8,6 +9,7 @@ this package are briefly described at the end of this document.
Some adapters understand only the SMBus (System Management Bus) protocol, Some adapters understand only the SMBus (System Management Bus) protocol,
which is a subset from the I2C protocol. Fortunately, many devices use which is a subset from the I2C protocol. Fortunately, many devices use
only the same subset, which makes it possible to put them on an SMBus. only the same subset, which makes it possible to put them on an SMBus.
If you write a driver for some I2C device, please try to use the SMBus If you write a driver for some I2C device, please try to use the SMBus
commands if at all possible (if the device uses only that subset of the commands if at all possible (if the device uses only that subset of the
I2C protocol). This makes it possible to use the device driver on both I2C protocol). This makes it possible to use the device driver on both
@ -15,7 +17,12 @@ SMBus adapters and I2C adapters (the SMBus command set is automatically
translated to I2C on I2C adapters, but plain I2C commands can not be translated to I2C on I2C adapters, but plain I2C commands can not be
handled at all on most pure SMBus adapters). handled at all on most pure SMBus adapters).
Below is a list of SMBus commands. Below is a list of SMBus protocol operations, and the functions executing
them. Note that the names used in the SMBus protocol specifications usually
don't match these function names. For some of the operations which pass a
single data byte, the functions using SMBus protocol operation names execute
a different protocol operation entirely.
Key to symbols Key to symbols
============== ==============
@ -35,17 +42,16 @@ Count (8 bits): A data byte containing the length of a block operation.
[..]: Data sent by I2C device, as opposed to data sent by the host adapter. [..]: Data sent by I2C device, as opposed to data sent by the host adapter.
SMBus Write Quick SMBus Quick Command: i2c_smbus_write_quick()
================= =============================================
This sends a single bit to the device, at the place of the Rd/Wr bit. This sends a single bit to the device, at the place of the Rd/Wr bit.
There is no equivalent Read Quick command.
A Addr Rd/Wr [A] P A Addr Rd/Wr [A] P
SMBus Read Byte SMBus Receive Byte: i2c_smbus_read_byte()
=============== ==========================================
This reads a single byte from a device, without specifying a device This reads a single byte from a device, without specifying a device
register. Some devices are so simple that this interface is enough; for register. Some devices are so simple that this interface is enough; for
@ -55,17 +61,17 @@ the previous SMBus command.
S Addr Rd [A] [Data] NA P S Addr Rd [A] [Data] NA P
SMBus Write Byte SMBus Send Byte: i2c_smbus_write_byte()
================ ========================================
This is the reverse of Read Byte: it sends a single byte to a device. This operation is the reverse of Receive Byte: it sends a single byte
See Read Byte for more information. to a device. See Receive Byte for more information.
S Addr Wr [A] Data [A] P S Addr Wr [A] Data [A] P
SMBus Read Byte Data SMBus Read Byte: i2c_smbus_read_byte_data()
==================== ============================================
This reads a single byte from a device, from a designated register. This reads a single byte from a device, from a designated register.
The register is specified through the Comm byte. The register is specified through the Comm byte.
@ -73,30 +79,30 @@ The register is specified through the Comm byte.
S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P
SMBus Read Word Data SMBus Read Word: i2c_smbus_read_word_data()
==================== ============================================
This command is very like Read Byte Data; again, data is read from a This operation is very like Read Byte; again, data is read from a
device, from a designated register that is specified through the Comm device, from a designated register that is specified through the Comm
byte. But this time, the data is a complete word (16 bits). byte. But this time, the data is a complete word (16 bits).
S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
SMBus Write Byte Data SMBus Write Byte: i2c_smbus_write_byte_data()
===================== ==============================================
This writes a single byte to a device, to a designated register. The This writes a single byte to a device, to a designated register. The
register is specified through the Comm byte. This is the opposite of register is specified through the Comm byte. This is the opposite of
the Read Byte Data command. the Read Byte operation.
S Addr Wr [A] Comm [A] Data [A] P S Addr Wr [A] Comm [A] Data [A] P
SMBus Write Word Data SMBus Write Word: i2c_smbus_write_word_data()
===================== ==============================================
This is the opposite operation of the Read Word Data command. 16 bits This is the opposite of the Read Word operation. 16 bits
of data is written to a device, to the designated register that is of data is written to a device, to the designated register that is
specified through the Comm byte. specified through the Comm byte.
@ -113,8 +119,8 @@ S Addr Wr [A] Comm [A] DataLow [A] DataHigh [A]
S Addr Rd [A] [DataLow] A [DataHigh] NA P S Addr Rd [A] [DataLow] A [DataHigh] NA P
SMBus Block Read SMBus Block Read: i2c_smbus_read_block_data()
================ ==============================================
This command reads a block of up to 32 bytes from a device, from a This command reads a block of up to 32 bytes from a device, from a
designated register that is specified through the Comm byte. The amount designated register that is specified through the Comm byte. The amount
@ -124,8 +130,8 @@ S Addr Wr [A] Comm [A]
S Addr Rd [A] [Count] A [Data] A [Data] A ... A [Data] NA P S Addr Rd [A] [Count] A [Data] A [Data] A ... A [Data] NA P
SMBus Block Write SMBus Block Write: i2c_smbus_write_block_data()
================= ================================================
The opposite of the Block Read command, this writes up to 32 bytes to The opposite of the Block Read command, this writes up to 32 bytes to
a device, to a designated register that is specified through the a device, to a designated register that is specified through the
@ -134,10 +140,11 @@ Comm byte. The amount of data is specified in the Count byte.
S Addr Wr [A] Comm [A] Count [A] Data [A] Data [A] ... [A] Data [A] P S Addr Wr [A] Comm [A] Count [A] Data [A] Data [A] ... [A] Data [A] P
SMBus Block Process Call SMBus Block Write - Block Read Process Call
======================== ===========================================
SMBus Block Process Call was introduced in Revision 2.0 of the specification. SMBus Block Write - Block Read Process Call was introduced in
Revision 2.0 of the specification.
This command selects a device register (through the Comm byte), sends This command selects a device register (through the Comm byte), sends
1 to 31 bytes of data to it, and reads 1 to 31 bytes of data in return. 1 to 31 bytes of data to it, and reads 1 to 31 bytes of data in return.
@ -159,13 +166,16 @@ alerting device's address.
Packet Error Checking (PEC) Packet Error Checking (PEC)
=========================== ===========================
Packet Error Checking was introduced in Revision 1.1 of the specification. Packet Error Checking was introduced in Revision 1.1 of the specification.
PEC adds a CRC-8 error-checking byte to all transfers. PEC adds a CRC-8 error-checking byte to transfers using it, immediately
before the terminating STOP.
Address Resolution Protocol (ARP) Address Resolution Protocol (ARP)
================================= =================================
The Address Resolution Protocol was introduced in Revision 2.0 of The Address Resolution Protocol was introduced in Revision 2.0 of
the specification. It is a higher-layer protocol which uses the the specification. It is a higher-layer protocol which uses the
messages above. messages above.
@ -177,14 +187,17 @@ require PEC checksums.
I2C Block Transactions I2C Block Transactions
====================== ======================
The following I2C block transactions are supported by the The following I2C block transactions are supported by the
SMBus layer and are described here for completeness. SMBus layer and are described here for completeness.
They are *NOT* defined by the SMBus specification.
I2C block transactions do not limit the number of bytes transferred I2C block transactions do not limit the number of bytes transferred
but the SMBus layer places a limit of 32 bytes. but the SMBus layer places a limit of 32 bytes.
I2C Block Read I2C Block Read: i2c_smbus_read_i2c_block_data()
============== ================================================
This command reads a block of bytes from a device, from a This command reads a block of bytes from a device, from a
designated register that is specified through the Comm byte. designated register that is specified through the Comm byte.
@ -203,8 +216,8 @@ S Addr Wr [A] Comm1 [A] Comm2 [A]
S Addr Rd [A] [Data] A [Data] A ... A [Data] NA P S Addr Rd [A] [Data] A [Data] A ... A [Data] NA P
I2C Block Write I2C Block Write: i2c_smbus_write_i2c_block_data()
=============== ==================================================
The opposite of the Block Read command, this writes bytes to The opposite of the Block Read command, this writes bytes to
a device, to a designated register that is specified through the a device, to a designated register that is specified through the
@ -212,5 +225,3 @@ Comm byte. Note that command lengths of 0, 2, or more bytes are
supported as they are indistinguishable from data. supported as they are indistinguishable from data.
S Addr Wr [A] Comm [A] Data [A] Data [A] ... [A] Data [A] P S Addr Wr [A] Comm [A] Data [A] Data [A] ... [A] Data [A] P

3
Documentation/i2c/writing-clients
View file

@ -164,7 +164,8 @@ I2C device drivers using this binding model work just like any other
kind of driver in Linux: they provide a probe() method to bind to kind of driver in Linux: they provide a probe() method to bind to
those devices, and a remove() method to unbind. those devices, and a remove() method to unbind.
static int foo_probe(struct i2c_client *client); static int foo_probe(struct i2c_client *client,
const struct i2c_device_id *id);
static int foo_remove(struct i2c_client *client); static int foo_remove(struct i2c_client *client);
Remember that the i2c_driver does not create those client handles. The Remember that the i2c_driver does not create those client handles. The

12
Documentation/i386/boot.txt
View file

@ -40,9 +40,17 @@ Protocol 2.05: (Kernel 2.6.20) Make protected mode kernel relocatable.
Introduce relocatable_kernel and kernel_alignment fields. Introduce relocatable_kernel and kernel_alignment fields.
Protocol 2.06: (Kernel 2.6.22) Added a field that contains the size of Protocol 2.06: (Kernel 2.6.22) Added a field that contains the size of
the boot command line the boot command line.
Protocol 2.09: (kernel 2.6.26) Added a field of 64-bit physical Protocol 2.07: (Kernel 2.6.24) Added paravirtualised boot protocol.
Introduced hardware_subarch and hardware_subarch_data
and KEEP_SEGMENTS flag in load_flags.
Protocol 2.08: (Kernel 2.6.26) Added crc32 checksum and ELF format
payload. Introduced payload_offset and payload length
fields to aid in locating the payload.
Protocol 2.09: (Kernel 2.6.26) Added a field of 64-bit physical
pointer to single linked list of struct setup_data. pointer to single linked list of struct setup_data.
**** MEMORY LAYOUT **** MEMORY LAYOUT

24
Documentation/kbuild/kconfig-language.txt
View file

@ -377,27 +377,3 @@ config FOO
limits FOO to module (=m) or disabled (=n). limits FOO to module (=m) or disabled (=n).
Build limited by a third config symbol which may be =y or =m
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A common idiom that we see (and sometimes have problems with) is this:
When option C in B (module or subsystem) uses interfaces from A (module
or subsystem), and both A and B are tristate (could be =y or =m if they
were independent of each other, but they aren't), then we need to limit
C such that it cannot be built statically if A is built as a loadable
module. (C already depends on B, so there is no dependency issue to
take care of here.)
If A is linked statically into the kernel image, C can be built
statically or as loadable module(s). However, if A is built as loadable
module(s), then C must be restricted to loadable module(s) also. This
can be expressed in kconfig language as:
config C
depends on A = y || A = B
or for real examples, use this command in a kernel tree:
$ find . -name Kconfig\* | xargs grep -ns "depends on.*=.*||.*=" | grep -v orig

5
Documentation/kdump/kdump.txt
View file

@ -245,6 +245,8 @@ The syntax is:
crashkernel=<range1>:<size1>[,<range2>:<size2>,...][@offset] crashkernel=<range1>:<size1>[,<range2>:<size2>,...][@offset]
range=start-[end] range=start-[end]
'start' is inclusive and 'end' is exclusive.
For example: For example:
crashkernel=512M-2G:64M,2G-:128M crashkernel=512M-2G:64M,2G-:128M
@ -253,10 +255,11 @@ This would mean:
1) if the RAM is smaller than 512M, then don't reserve anything 1) if the RAM is smaller than 512M, then don't reserve anything
(this is the "rescue" case) (this is the "rescue" case)
2) if the RAM size is between 512M and 2G, then reserve 64M 2) if the RAM size is between 512M and 2G (exclusive), then reserve 64M
3) if the RAM size is larger than 2G, then reserve 128M 3) if the RAM size is larger than 2G, then reserve 128M
Boot into System Kernel Boot into System Kernel
======================= =======================

31
Documentation/kernel-parameters.txt
View file

@ -398,9 +398,6 @@ and is between 256 and 4096 characters. It is defined in the file
cio_ignore= [S390] cio_ignore= [S390]
See Documentation/s390/CommonIO for details. See Documentation/s390/CommonIO for details.
cio_msg= [S390]
See Documentation/s390/CommonIO for details.
clock= [BUGS=X86-32, HW] gettimeofday clocksource override. clock= [BUGS=X86-32, HW] gettimeofday clocksource override.
[Deprecated] [Deprecated]
Forces specified clocksource (if available) to be used Forces specified clocksource (if available) to be used
@ -496,6 +493,11 @@ and is between 256 and 4096 characters. It is defined in the file
switching to the matching ttyS device later. The switching to the matching ttyS device later. The
options are the same as for ttyS, above. options are the same as for ttyS, above.
If the device connected to the port is not a TTY but a braille
device, prepend "brl," before the device type, for instance
console=brl,ttyS0
For now, only VisioBraille is supported.
earlycon= [KNL] Output early console device and options. earlycon= [KNL] Output early console device and options.
uart[8250],io,<addr>[,options] uart[8250],io,<addr>[,options]
uart[8250],mmio,<addr>[,options] uart[8250],mmio,<addr>[,options]
@ -556,6 +558,8 @@ and is between 256 and 4096 characters. It is defined in the file
1 will print _a lot_ more information - normally 1 will print _a lot_ more information - normally
only useful to kernel developers. only useful to kernel developers.
debug_objects [KNL] Enable object debugging
decnet.addr= [HW,NET] decnet.addr= [HW,NET]
Format: <area>[,<node>] Format: <area>[,<node>]
See also Documentation/networking/decnet.txt. See also Documentation/networking/decnet.txt.
@ -627,8 +631,7 @@ and is between 256 and 4096 characters. It is defined in the file
eata= [HW,SCSI] eata= [HW,SCSI]
edd= [EDD] edd= [EDD]
Format: {"of[f]" | "sk[ipmbr]"} Format: {"off" | "on" | "skip[mbr]"}
See comment in arch/i386/boot/edd.S
eisa_irq_edge= [PARISC,HW] eisa_irq_edge= [PARISC,HW]
See header of drivers/parisc/eisa.c. See header of drivers/parisc/eisa.c.
@ -683,6 +686,12 @@ and is between 256 and 4096 characters. It is defined in the file
floppy= [HW] floppy= [HW]
See Documentation/floppy.txt. See Documentation/floppy.txt.
force_pal_cache_flush
[IA-64] Avoid check_sal_cache_flush which may hang on
buggy SAL_CACHE_FLUSH implementations. Using this
parameter will force ia64_sal_cache_flush to call
ia64_pal_cache_flush instead of SAL_CACHE_FLUSH.
gamecon.map[2|3]= gamecon.map[2|3]=
[HW,JOY] Multisystem joystick and NES/SNES/PSX pad [HW,JOY] Multisystem joystick and NES/SNES/PSX pad
support via parallel port (up to 5 devices per port) support via parallel port (up to 5 devices per port)
@ -1088,9 +1097,6 @@ and is between 256 and 4096 characters. It is defined in the file
mac5380= [HW,SCSI] Format: mac5380= [HW,SCSI] Format:
<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags> <can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
mac53c9x= [HW,SCSI] Format:
<num_esps>,<disconnect>,<nosync>,<can_queue>,<cmd_per_lun>,<sg_tablesize>,<hostid>,<use_tags>
machvec= [IA64] Force the use of a particular machine-vector machvec= [IA64] Force the use of a particular machine-vector
(machvec) in a generic kernel. (machvec) in a generic kernel.
Example: machvec=hpzx1_swiotlb Example: machvec=hpzx1_swiotlb
@ -1389,6 +1395,13 @@ and is between 256 and 4096 characters. It is defined in the file
nr_uarts= [SERIAL] maximum number of UARTs to be registered. nr_uarts= [SERIAL] maximum number of UARTs to be registered.
olpc_ec_timeout= [OLPC] ms delay when issuing EC commands
Rather than timing out after 20 ms if an EC
command is not properly ACKed, override the length
of the timeout. We have interrupts disabled while
waiting for the ACK, so if this is set too high
interrupts *may* be lost!
opl3= [HW,OSS] opl3= [HW,OSS]
Format: <io> Format: <io>
@ -1512,6 +1525,8 @@ and is between 256 and 4096 characters. It is defined in the file
This is normally done in pci_enable_device(), This is normally done in pci_enable_device(),
so this option is a temporary workaround so this option is a temporary workaround
for broken drivers that don't call it. for broken drivers that don't call it.
skip_isa_align [X86] do not align io start addr, so can
handle more pci cards
firmware [ARM] Do not re-enumerate the bus but instead firmware [ARM] Do not re-enumerate the bus but instead
just use the configuration from the just use the configuration from the
bootloader. This is currently used on bootloader. This is currently used on

11
Documentation/keys-request-key.txt
View file

@ -11,26 +11,29 @@ request_key*():
struct key *request_key(const struct key_type *type, struct key *request_key(const struct key_type *type,
const char *description, const char *description,
const char *callout_string); const char *callout_info);
or: or:
struct key *request_key_with_auxdata(const struct key_type *type, struct key *request_key_with_auxdata(const struct key_type *type,
const char *description, const char *description,
const char *callout_string, const char *callout_info,
size_t callout_len,
void *aux); void *aux);
or: or:
struct key *request_key_async(const struct key_type *type, struct key *request_key_async(const struct key_type *type,
const char *description, const char *description,
const char *callout_string); const char *callout_info,
size_t callout_len);
or: or:
struct key *request_key_async_with_auxdata(const struct key_type *type, struct key *request_key_async_with_auxdata(const struct key_type *type,
const char *description, const char *description,
const char *callout_string, const char *callout_info,
size_t callout_len,
void *aux); void *aux);
Or by userspace invoking the request_key system call: Or by userspace invoking the request_key system call:

59
Documentation/keys.txt
View file

@ -170,7 +170,8 @@ The key service provides a number of features besides keys:
amount of description and payload space that can be consumed. amount of description and payload space that can be consumed.
The user can view information on this and other statistics through procfs The user can view information on this and other statistics through procfs
files. files. The root user may also alter the quota limits through sysctl files
(see the section "New procfs files").
Process-specific and thread-specific keyrings are not counted towards a Process-specific and thread-specific keyrings are not counted towards a
user's quota. user's quota.
@ -329,6 +330,27 @@ about the status of the key service:
<bytes>/<max> Key size quota <bytes>/<max> Key size quota
Four new sysctl files have been added also for the purpose of controlling the
quota limits on keys:
(*) /proc/sys/kernel/keys/root_maxkeys
/proc/sys/kernel/keys/root_maxbytes
These files hold the maximum number of keys that root may have and the
maximum total number of bytes of data that root may have stored in those
keys.
(*) /proc/sys/kernel/keys/maxkeys
/proc/sys/kernel/keys/maxbytes
These files hold the maximum number of keys that each non-root user may
have and the maximum total number of bytes of data that each of those
users may have stored in their keys.
Root may alter these by writing each new limit as a decimal number string to
the appropriate file.
=============================== ===============================
USERSPACE SYSTEM CALL INTERFACE USERSPACE SYSTEM CALL INTERFACE
=============================== ===============================
@ -711,6 +733,27 @@ The keyctl syscall functions are:
The assumed authoritative key is inherited across fork and exec. The assumed authoritative key is inherited across fork and exec.
(*) Get the LSM security context attached to a key.
long keyctl(KEYCTL_GET_SECURITY, key_serial_t key, char *buffer,
size_t buflen)
This function returns a string that represents the LSM security context
attached to a key in the buffer provided.
Unless there's an error, it always returns the amount of data it could
produce, even if that's too big for the buffer, but it won't copy more
than requested to userspace. If the buffer pointer is NULL then no copy
will take place.
A NUL character is included at the end of the string if the buffer is
sufficiently big. This is included in the returned count. If no LSM is
in force then an empty string will be returned.
A process must have view permission on the key for this function to be
successful.
=============== ===============
KERNEL SERVICES KERNEL SERVICES
=============== ===============
@ -771,7 +814,7 @@ payload contents" for more information.
struct key *request_key(const struct key_type *type, struct key *request_key(const struct key_type *type,
const char *description, const char *description,
const char *callout_string); const char *callout_info);
This is used to request a key or keyring with a description that matches This is used to request a key or keyring with a description that matches
the description specified according to the key type's match function. This the description specified according to the key type's match function. This
@ -793,24 +836,28 @@ payload contents" for more information.
struct key *request_key_with_auxdata(const struct key_type *type, struct key *request_key_with_auxdata(const struct key_type *type,
const char *description, const char *description,
const char *callout_string, const void *callout_info,
size_t callout_len,
void *aux); void *aux);
This is identical to request_key(), except that the auxiliary data is This is identical to request_key(), except that the auxiliary data is
passed to the key_type->request_key() op if it exists. passed to the key_type->request_key() op if it exists, and the callout_info
is a blob of length callout_len, if given (the length may be 0).
(*) A key can be requested asynchronously by calling one of: (*) A key can be requested asynchronously by calling one of:
struct key *request_key_async(const struct key_type *type, struct key *request_key_async(const struct key_type *type,
const char *description, const char *description,
const char *callout_string); const void *callout_info,
size_t callout_len);
or: or:
struct key *request_key_async_with_auxdata(const struct key_type *type, struct key *request_key_async_with_auxdata(const struct key_type *type,
const char *description, const char *description,
const char *callout_string, const char *callout_info,
size_t callout_len,
void *aux); void *aux);
which are asynchronous equivalents of request_key() and which are asynchronous equivalents of request_key() and

139
Documentation/laptops/thinkpad-acpi.txt
View file

@ -1,7 +1,7 @@
ThinkPad ACPI Extras Driver ThinkPad ACPI Extras Driver
Version 0.19 Version 0.20
January 06th, 2008 April 09th, 2008
Borislav Deianov <borislav@users.sf.net> Borislav Deianov <borislav@users.sf.net>
Henrique de Moraes Holschuh <hmh@hmh.eng.br> Henrique de Moraes Holschuh <hmh@hmh.eng.br>
@ -18,6 +18,11 @@ This driver used to be named ibm-acpi until kernel 2.6.21 and release
moved to the drivers/misc tree and renamed to thinkpad-acpi for kernel moved to the drivers/misc tree and renamed to thinkpad-acpi for kernel
2.6.22, and release 0.14. 2.6.22, and release 0.14.
The driver is named "thinkpad-acpi". In some places, like module
names, "thinkpad_acpi" is used because of userspace issues.
"tpacpi" is used as a shorthand where "thinkpad-acpi" would be too
long due to length limitations on some Linux kernel versions.
Status Status
------ ------
@ -571,6 +576,47 @@ netlink interface and the input layer interface, and don't bother at all
with hotkey_report_mode. with hotkey_report_mode.
Brightness hotkey notes:
These are the current sane choices for brightness key mapping in
thinkpad-acpi:
For IBM and Lenovo models *without* ACPI backlight control (the ones on
which thinkpad-acpi will autoload its backlight interface by default,
and on which ACPI video does not export a backlight interface):
1. Don't enable or map the brightness hotkeys in thinkpad-acpi, as
these older firmware versions unfortunately won't respect the hotkey
mask for brightness keys anyway, and always reacts to them. This
usually work fine, unless X.org drivers are doing something to block
the BIOS. In that case, use (3) below. This is the default mode of
operation.
2. Enable the hotkeys, but map them to something else that is NOT
KEY_BRIGHTNESS_UP/DOWN or any other keycode that would cause
userspace to try to change the backlight level, and use that as an
on-screen-display hint.
3. IF AND ONLY IF X.org drivers find a way to block the firmware from
automatically changing the brightness, enable the hotkeys and map
them to KEY_BRIGHTNESS_UP and KEY_BRIGHTNESS_DOWN, and feed that to
something that calls xbacklight. thinkpad-acpi will not be able to
change brightness in that case either, so you should disable its
backlight interface.
For Lenovo models *with* ACPI backlight control:
1. Load up ACPI video and use that. ACPI video will report ACPI
events for brightness change keys. Do not mess with thinkpad-acpi
defaults in this case. thinkpad-acpi should not have anything to do
with backlight events in a scenario where ACPI video is loaded:
brightness hotkeys must be disabled, and the backlight interface is
to be kept disabled as well. This is the default mode of operation.
2. Do *NOT* load up ACPI video, enable the hotkeys in thinkpad-acpi,
and map them to KEY_BRIGHTNESS_UP and KEY_BRIGHTNESS_DOWN. Process
these keys on userspace somehow (e.g. by calling xbacklight).
Bluetooth Bluetooth
--------- ---------
@ -647,16 +693,31 @@ while others are still having problems. For more information:
https://bugs.freedesktop.org/show_bug.cgi?id=2000 https://bugs.freedesktop.org/show_bug.cgi?id=2000
ThinkLight control -- /proc/acpi/ibm/light ThinkLight control
------------------------------------------ ------------------
The current status of the ThinkLight can be found in this file. A few procfs: /proc/acpi/ibm/light
models which do not make the status available will show it as sysfs attributes: as per LED class, for the "tpacpi::thinklight" LED
"unknown". The available commands are:
procfs notes:
The ThinkLight status can be read and set through the procfs interface. A
few models which do not make the status available will show the ThinkLight
status as "unknown". The available commands are:
echo on > /proc/acpi/ibm/light echo on > /proc/acpi/ibm/light
echo off > /proc/acpi/ibm/light echo off > /proc/acpi/ibm/light
sysfs notes:
The ThinkLight sysfs interface is documented by the LED class
documentation, in Documentation/leds-class.txt. The ThinkLight LED name
is "tpacpi::thinklight".
Due to limitations in the sysfs LED class, if the status of the thinklight
cannot be read or if it is unknown, thinkpad-acpi will report it as "off".
It is impossible to know if the status returned through sysfs is valid.
Docking / undocking -- /proc/acpi/ibm/dock Docking / undocking -- /proc/acpi/ibm/dock
------------------------------------------ ------------------------------------------
@ -815,28 +876,63 @@ The cmos command interface is prone to firmware split-brain problems, as
in newer ThinkPads it is just a compatibility layer. Do not use it, it is in newer ThinkPads it is just a compatibility layer. Do not use it, it is
exported just as a debug tool. exported just as a debug tool.
LED control -- /proc/acpi/ibm/led LED control
--------------------------------- -----------
Some of the LED indicators can be controlled through this feature. The procfs: /proc/acpi/ibm/led
available commands are: sysfs attributes: as per LED class, see below for names
echo '<led number> on' >/proc/acpi/ibm/led Some of the LED indicators can be controlled through this feature. On
echo '<led number> off' >/proc/acpi/ibm/led some older ThinkPad models, it is possible to query the status of the
echo '<led number> blink' >/proc/acpi/ibm/led LED indicators as well. Newer ThinkPads cannot query the real status
of the LED indicators.
The <led number> range is 0 to 7. The set of LEDs that can be procfs notes:
controlled varies from model to model. Here is the mapping on the X40:
The available commands are:
echo '<LED number> on' >/proc/acpi/ibm/led
echo '<LED number> off' >/proc/acpi/ibm/led
echo '<LED number> blink' >/proc/acpi/ibm/led
The <LED number> range is 0 to 7. The set of LEDs that can be
controlled varies from model to model. Here is the common ThinkPad
mapping:
0 - power 0 - power
1 - battery (orange) 1 - battery (orange)
2 - battery (green) 2 - battery (green)
3 - UltraBase 3 - UltraBase/dock
4 - UltraBay 4 - UltraBay
5 - UltraBase battery slot
6 - (unknown)
7 - standby 7 - standby
All of the above can be turned on and off and can be made to blink. All of the above can be turned on and off and can be made to blink.
sysfs notes:
The ThinkPad LED sysfs interface is described in detail by the LED class
documentation, in Documentation/leds-class.txt.
The leds are named (in LED ID order, from 0 to 7):
"tpacpi::power", "tpacpi:orange:batt", "tpacpi:green:batt",
"tpacpi::dock_active", "tpacpi::bay_active", "tpacpi::dock_batt",
"tpacpi::unknown_led", "tpacpi::standby".
Due to limitations in the sysfs LED class, if the status of the LED
indicators cannot be read due to an error, thinkpad-acpi will report it as
a brightness of zero (same as LED off).
If the thinkpad firmware doesn't support reading the current status,
trying to read the current LED brightness will just return whatever
brightness was last written to that attribute.
These LEDs can blink using hardware acceleration. To request that a
ThinkPad indicator LED should blink in hardware accelerated mode, use the
"timer" trigger, and leave the delay_on and delay_off parameters set to
zero (to request hardware acceleration autodetection).
ACPI sounds -- /proc/acpi/ibm/beep ACPI sounds -- /proc/acpi/ibm/beep
---------------------------------- ----------------------------------
@ -1090,6 +1186,15 @@ it there will be the following attributes:
dim the display. dim the display.
WARNING:
Whatever you do, do NOT ever call thinkpad-acpi backlight-level change
interface and the ACPI-based backlight level change interface
(available on newer BIOSes, and driven by the Linux ACPI video driver)
at the same time. The two will interact in bad ways, do funny things,
and maybe reduce the life of the backlight lamps by needlessly kicking
its level up and down at every change.
Volume control -- /proc/acpi/ibm/volume Volume control -- /proc/acpi/ibm/volume
--------------------------------------- ---------------------------------------

62
Documentation/lguest/lguest.c
View file

@ -131,6 +131,9 @@ struct device
/* Any queues attached to this device */ /* Any queues attached to this device */
struct virtqueue *vq; struct virtqueue *vq;
/* Handle status being finalized (ie. feature bits stable). */
void (*ready)(struct device *me);
/* Device-specific data. */ /* Device-specific data. */
void *priv; void *priv;
}; };
@ -925,24 +928,40 @@ static void enable_fd(int fd, struct virtqueue *vq)
write(waker_fd, &vq->dev->fd, sizeof(vq->dev->fd)); write(waker_fd, &vq->dev->fd, sizeof(vq->dev->fd));
} }
/* When the Guest asks us to reset a device, it's is fairly easy. */ /* When the Guest tells us they updated the status field, we handle it. */
static void reset_device(struct device *dev) static void update_device_status(struct device *dev)
{ {
struct virtqueue *vq; struct virtqueue *vq;
verbose("Resetting device %s\n", dev->name); /* This is a reset. */
/* Clear the status. */ if (dev->desc->status == 0) {
dev->desc->status = 0; verbose("Resetting device %s\n", dev->name);
/* Clear any features they've acked. */ /* Clear any features they've acked. */
memset(get_feature_bits(dev) + dev->desc->feature_len, 0, memset(get_feature_bits(dev) + dev->desc->feature_len, 0,
dev->desc->feature_len); dev->desc->feature_len);
/* Zero out the virtqueues. */ /* Zero out the virtqueues. */
for (vq = dev->vq; vq; vq = vq->next) { for (vq = dev->vq; vq; vq = vq->next) {
memset(vq->vring.desc, 0, memset(vq->vring.desc, 0,
vring_size(vq->config.num, getpagesize())); vring_size(vq->config.num, getpagesize()));
vq->last_avail_idx = 0; vq->last_avail_idx = 0;
}
} else if (dev->desc->status & VIRTIO_CONFIG_S_FAILED) {
warnx("Device %s configuration FAILED", dev->name);
} else if (dev->desc->status & VIRTIO_CONFIG_S_DRIVER_OK) {
unsigned int i;
verbose("Device %s OK: offered", dev->name);
for (i = 0; i < dev->desc->feature_len; i++)
verbose(" %08x", get_feature_bits(dev)[i]);
verbose(", accepted");
for (i = 0; i < dev->desc->feature_len; i++)
verbose(" %08x", get_feature_bits(dev)
[dev->desc->feature_len+i]);
if (dev->ready)
dev->ready(dev);
} }
} }
@ -954,9 +973,9 @@ static void handle_output(int fd, unsigned long addr)
/* Check each device and virtqueue. */ /* Check each device and virtqueue. */
for (i = devices.dev; i; i = i->next) { for (i = devices.dev; i; i = i->next) {
/* Notifications to device descriptors reset the device. */ /* Notifications to device descriptors update device status. */
if (from_guest_phys(addr) == i->desc) { if (from_guest_phys(addr) == i->desc) {
reset_device(i); update_device_status(i);
return; return;
} }
@ -1170,6 +1189,7 @@ static struct device *new_device(const char *name, u16 type, int fd,
dev->handle_input = handle_input; dev->handle_input = handle_input;
dev->name = name; dev->name = name;
dev->vq = NULL; dev->vq = NULL;
dev->ready = NULL;
/* Append to device list. Prepending to a single-linked list is /* Append to device list. Prepending to a single-linked list is
* easier, but the user expects the devices to be arranged on the bus * easier, but the user expects the devices to be arranged on the bus
@ -1398,7 +1418,7 @@ static bool service_io(struct device *dev)
struct vblk_info *vblk = dev->priv; struct vblk_info *vblk = dev->priv;
unsigned int head, out_num, in_num, wlen; unsigned int head, out_num, in_num, wlen;
int ret; int ret;
struct virtio_blk_inhdr *in; u8 *in;
struct virtio_blk_outhdr *out; struct virtio_blk_outhdr *out;
struct iovec iov[dev->vq->vring.num]; struct iovec iov[dev->vq->vring.num];
off64_t off; off64_t off;
@ -1416,7 +1436,7 @@ static bool service_io(struct device *dev)
head, out_num, in_num); head, out_num, in_num);
out = convert(&iov[0], struct virtio_blk_outhdr); out = convert(&iov[0], struct virtio_blk_outhdr);
in = convert(&iov[out_num+in_num-1], struct virtio_blk_inhdr); in = convert(&iov[out_num+in_num-1], u8);
off = out->sector * 512; off = out->sector * 512;
/* The block device implements "barriers", where the Guest indicates /* The block device implements "barriers", where the Guest indicates
@ -1430,7 +1450,7 @@ static bool service_io(struct device *dev)
* It'd be nice if we supported eject, for example, but we don't. */ * It'd be nice if we supported eject, for example, but we don't. */
if (out->type & VIRTIO_BLK_T_SCSI_CMD) { if (out->type & VIRTIO_BLK_T_SCSI_CMD) {
fprintf(stderr, "Scsi commands unsupported\n"); fprintf(stderr, "Scsi commands unsupported\n");
in->status = VIRTIO_BLK_S_UNSUPP; *in = VIRTIO_BLK_S_UNSUPP;
wlen = sizeof(*in); wlen = sizeof(*in);
} else if (out->type & VIRTIO_BLK_T_OUT) { } else if (out->type & VIRTIO_BLK_T_OUT) {
/* Write */ /* Write */
@ -1453,7 +1473,7 @@ static bool service_io(struct device *dev)
errx(1, "Write past end %llu+%u", off, ret); errx(1, "Write past end %llu+%u", off, ret);
} }
wlen = sizeof(*in); wlen = sizeof(*in);
in->status = (ret >= 0 ? VIRTIO_BLK_S_OK : VIRTIO_BLK_S_IOERR); *in = (ret >= 0 ? VIRTIO_BLK_S_OK : VIRTIO_BLK_S_IOERR);
} else { } else {
/* Read */ /* Read */
@ -1466,10 +1486,10 @@ static bool service_io(struct device *dev)
verbose("READ from sector %llu: %i\n", out->sector, ret); verbose("READ from sector %llu: %i\n", out->sector, ret);
if (ret >= 0) { if (ret >= 0) {
wlen = sizeof(*in) + ret; wlen = sizeof(*in) + ret;
in->status = VIRTIO_BLK_S_OK; *in = VIRTIO_BLK_S_OK;
} else { } else {
wlen = sizeof(*in); wlen = sizeof(*in);
in->status = VIRTIO_BLK_S_IOERR; *in = VIRTIO_BLK_S_IOERR;
} }
} }

12
Documentation/memory-barriers.txt
View file

@ -994,7 +994,17 @@ The Linux kernel has eight basic CPU memory barriers:
DATA DEPENDENCY read_barrier_depends() smp_read_barrier_depends() DATA DEPENDENCY read_barrier_depends() smp_read_barrier_depends()
All CPU memory barriers unconditionally imply compiler barriers. All memory barriers except the data dependency barriers imply a compiler
barrier. Data dependencies do not impose any additional compiler ordering.
Aside: In the case of data dependencies, the compiler would be expected to
issue the loads in the correct order (eg. `a[b]` would have to load the value
of b before loading a[b]), however there is no guarantee in the C specification
that the compiler may not speculate the value of b (eg. is equal to 1) and load
a before b (eg. tmp = a[1]; if (b != 1) tmp = a[b]; ). There is also the
problem of a compiler reloading b after having loaded a[b], thus having a newer
copy of b than a[b]. A consensus has not yet been reached about these problems,
however the ACCESS_ONCE macro is a good place to start looking.
SMP memory barriers are reduced to compiler barriers on uniprocessor compiled SMP memory barriers are reduced to compiler barriers on uniprocessor compiled
systems because it is assumed that a CPU will appear to be self-consistent, systems because it is assumed that a CPU will appear to be self-consistent,

4
Documentation/oops-tracing.txt
View file

@ -253,6 +253,10 @@ characters, each representing a particular tainted value.
8: 'D' if the kernel has died recently, i.e. there was an OOPS or BUG. 8: 'D' if the kernel has died recently, i.e. there was an OOPS or BUG.
9: 'A' if the ACPI table has been overridden.
10: 'W' if a warning has previously been issued by the kernel.
The primary reason for the 'Tainted: ' string is to tell kernel The primary reason for the 'Tainted: ' string is to tell kernel
debuggers if this is a clean kernel or if anything unusual has debuggers if this is a clean kernel or if anything unusual has
occurred. Tainting is permanent: even if an offending module is occurred. Tainting is permanent: even if an offending module is

23
Documentation/powerpc/mpc52xx-device-tree-bindings.txt
View file

@ -186,6 +186,12 @@ Recommended soc5200 child nodes; populate as needed for your board
name device_type compatible Description name device_type compatible Description
---- ----------- ---------- ----------- ---- ----------- ---------- -----------
gpt@<addr> gpt fsl,mpc5200-gpt General purpose timers gpt@<addr> gpt fsl,mpc5200-gpt General purpose timers
gpt@<addr> gpt fsl,mpc5200-gpt-gpio General purpose
timers in GPIO mode
gpio@<addr> fsl,mpc5200-gpio MPC5200 simple gpio
controller
gpio@<addr> fsl,mpc5200-gpio-wkup MPC5200 wakeup gpio
controller
rtc@<addr> rtc mpc5200-rtc Real time clock rtc@<addr> rtc mpc5200-rtc Real time clock
mscan@<addr> mscan mpc5200-mscan CAN bus controller mscan@<addr> mscan mpc5200-mscan CAN bus controller
pci@<addr> pci mpc5200-pci PCI bridge pci@<addr> pci mpc5200-pci PCI bridge
@ -225,6 +231,23 @@ PSC in i2s mode: The mpc5200 and mpc5200b PSCs are not compatible when in
i2s mode. An 'mpc5200b-psc-i2s' node cannot include 'mpc5200-psc-i2s' in the i2s mode. An 'mpc5200b-psc-i2s' node cannot include 'mpc5200-psc-i2s' in the
compatible field. compatible field.
7) GPIO controller nodes
Each GPIO controller node should have the empty property gpio-controller and
#gpio-cells set to 2. First cell is the GPIO number which is interpreted
according to the bit numbers in the GPIO control registers. The second cell
is for flags which is currently unsused.
8) FEC nodes
The FEC node can specify one of the following properties to configure
the MII link:
"fsl,7-wire-mode" - An empty property that specifies the link uses 7-wire
mode instead of MII
"current-speed" - Specifies that the MII should be configured for a fixed
speed. This property should contain two cells. The
first cell specifies the speed in Mbps and the second
should be '0' for half duplex and '1' for full duplex
"phy-handle" - Contains a phandle to an Ethernet PHY.
IV - Extra Notes IV - Extra Notes
================ ================

11
Documentation/s390/CommonIO
View file

@ -8,17 +8,6 @@ Command line parameters
Enable logging of debug information in case of ccw device timeouts. Enable logging of debug information in case of ccw device timeouts.
* cio_msg = yes | no
Determines whether information on found devices and sensed device
characteristics should be shown during startup or when new devices are
found, i. e. messages of the types "Detected device 0.0.4711 on subchannel
0.0.0042" and "SenseID: Device 0.0.4711 reports: ...".
Default is off.
* cio_ignore = {all} | * cio_ignore = {all} |
{<device> | <range of devices>} | {<device> | <range of devices>} |
{!<device> | !<range of devices>} {!<device> | !<range of devices>}

165
Documentation/scheduler/sched-design.txt
View file

@ -1,165 +0,0 @@
Goals, Design and Implementation of the
new ultra-scalable O(1) scheduler
This is an edited version of an email Ingo Molnar sent to
lkml on 4 Jan 2002. It describes the goals, design, and
implementation of Ingo's new ultra-scalable O(1) scheduler.
Last Updated: 18 April 2002.
Goal
====
The main goal of the new scheduler is to keep all the good things we know
and love about the current Linux scheduler:
- good interactive performance even during high load: if the user
types or clicks then the system must react instantly and must execute
the user tasks smoothly, even during considerable background load.
- good scheduling/wakeup performance with 1-2 runnable processes.
- fairness: no process should stay without any timeslice for any
unreasonable amount of time. No process should get an unjustly high
amount of CPU time.
- priorities: less important tasks can be started with lower priority,
more important tasks with higher priority.
- SMP efficiency: no CPU should stay idle if there is work to do.
- SMP affinity: processes which run on one CPU should stay affine to
that CPU. Processes should not bounce between CPUs too frequently.
- plus additional scheduler features: RT scheduling, CPU binding.
and the goal is also to add a few new things:
- fully O(1) scheduling. Are you tired of the recalculation loop
blowing the L1 cache away every now and then? Do you think the goodness
loop is taking a bit too long to finish if there are lots of runnable
processes? This new scheduler takes no prisoners: wakeup(), schedule(),
the timer interrupt are all O(1) algorithms. There is no recalculation
loop. There is no goodness loop either.
- 'perfect' SMP scalability. With the new scheduler there is no 'big'
runqueue_lock anymore - it's all per-CPU runqueues and locks - two
tasks on two separate CPUs can wake up, schedule and context-switch
completely in parallel, without any interlocking. All
scheduling-relevant data is structured for maximum scalability.
- better SMP affinity. The old scheduler has a particular weakness that
causes the random bouncing of tasks between CPUs if/when higher
priority/interactive tasks, this was observed and reported by many
people. The reason is that the timeslice recalculation loop first needs
every currently running task to consume its timeslice. But when this
happens on eg. an 8-way system, then this property starves an
increasing number of CPUs from executing any process. Once the last
task that has a timeslice left has finished using up that timeslice,
the recalculation loop is triggered and other CPUs can start executing
tasks again - after having idled around for a number of timer ticks.
The more CPUs, the worse this effect.
Furthermore, this same effect causes the bouncing effect as well:
whenever there is such a 'timeslice squeeze' of the global runqueue,
idle processors start executing tasks which are not affine to that CPU.
(because the affine tasks have finished off their timeslices already.)
The new scheduler solves this problem by distributing timeslices on a
per-CPU basis, without having any global synchronization or
recalculation.
- batch scheduling. A significant proportion of computing-intensive tasks
benefit from batch-scheduling, where timeslices are long and processes
are roundrobin scheduled. The new scheduler does such batch-scheduling
of the lowest priority tasks - so nice +19 jobs will get
'batch-scheduled' automatically. With this scheduler, nice +19 jobs are
in essence SCHED_IDLE, from an interactiveness point of view.
- handle extreme loads more smoothly, without breakdown and scheduling
storms.
- O(1) RT scheduling. For those RT folks who are paranoid about the
O(nr_running) property of the goodness loop and the recalculation loop.
- run fork()ed children before the parent. Andrea has pointed out the
advantages of this a few months ago, but patches for this feature
do not work with the old scheduler as well as they should,
because idle processes often steal the new child before the fork()ing
CPU gets to execute it.
Design
======
The core of the new scheduler contains the following mechanisms:
- *two* priority-ordered 'priority arrays' per CPU. There is an 'active'
array and an 'expired' array. The active array contains all tasks that
are affine to this CPU and have timeslices left. The expired array
contains all tasks which have used up their timeslices - but this array
is kept sorted as well. The active and expired array is not accessed
directly, it's accessed through two pointers in the per-CPU runqueue
structure. If all active tasks are used up then we 'switch' the two
pointers and from now on the ready-to-go (former-) expired array is the
active array - and the empty active array serves as the new collector
for expired tasks.
- there is a 64-bit bitmap cache for array indices. Finding the highest
priority task is thus a matter of two x86 BSFL bit-search instructions.
the split-array solution enables us to have an arbitrary number of active
and expired tasks, and the recalculation of timeslices can be done
immediately when the timeslice expires. Because the arrays are always
access through the pointers in the runqueue, switching the two arrays can
be done very quickly.
this is a hybride priority-list approach coupled with roundrobin
scheduling and the array-switch method of distributing timeslices.
- there is a per-task 'load estimator'.
one of the toughest things to get right is good interactive feel during
heavy system load. While playing with various scheduler variants i found
that the best interactive feel is achieved not by 'boosting' interactive
tasks, but by 'punishing' tasks that want to use more CPU time than there
is available. This method is also much easier to do in an O(1) fashion.
to establish the actual 'load' the task contributes to the system, a
complex-looking but pretty accurate method is used: there is a 4-entry
'history' ringbuffer of the task's activities during the last 4 seconds.
This ringbuffer is operated without much overhead. The entries tell the
scheduler a pretty accurate load-history of the task: has it used up more
CPU time or less during the past N seconds. [the size '4' and the interval
of 4x 1 seconds was found by lots of experimentation - this part is
flexible and can be changed in both directions.]
the penalty a task gets for generating more load than the CPU can handle
is a priority decrease - there is a maximum amount to this penalty
relative to their static priority, so even fully CPU-bound tasks will
observe each other's priorities, and will share the CPU accordingly.
the SMP load-balancer can be extended/switched with additional parallel
computing and cache hierarchy concepts: NUMA scheduling, multi-core CPUs
can be supported easily by changing the load-balancer. Right now it's
tuned for my SMP systems.
i skipped the prev->mm == next->mm advantage - no workload i know of shows
any sensitivity to this. It can be added back by sacrificing O(1)
schedule() [the current and one-lower priority list can be searched for a
that->mm == current->mm condition], but costs a fair number of cycles
during a number of important workloads, so i wanted to avoid this as much
as possible.
- the SMP idle-task startup code was still racy and the new scheduler
triggered this. So i streamlined the idle-setup code a bit. We do not call
into schedule() before all processors have started up fully and all idle
threads are in place.
- the patch also cleans up a number of aspects of sched.c - moves code
into other areas of the kernel where it's appropriate, and simplifies
certain code paths and data constructs. As a result, the new scheduler's
code is smaller than the old one.
Ingo

22
Documentation/scsi/ChangeLog.megaraid_sas
View file

@ -1,3 +1,25 @@
1 Release Date : Mon. March 10 11:02:31 PDT 2008 -
(emaild-id:megaraidlinux@lsi.com)
Sumant Patro
Bo Yang
2 Current Version : 00.00.03.20-RC1
3 Older Version : 00.00.03.16
1. Rollback the sense info implementation
Sense buffer ptr data type in the ioctl path is reverted back
to u32 * as in previous versions of driver.
2. Fixed the driver frame count.
When Driver sent wrong frame count to firmware. As this
particular command is sent to drive, FW is seeing continuous
chip resets and so the command will timeout.
3. Add the new controller(1078DE) support to the driver
and Increase the max_wait to 60 from 10 in the controller
operational status. With this max_wait increase, driver will
make sure the FW will finish the pending cmd for KDUMP case.
1 Release Date : Thur. Nov. 07 16:30:43 PST 2007 - 1 Release Date : Thur. Nov. 07 16:30:43 PST 2007 -
(emaild-id:megaraidlinux@lsi.com) (emaild-id:megaraidlinux@lsi.com)
Sumant Patro Sumant Patro

1
Documentation/sound/alsa/ALSA-Configuration.txt
View file

@ -795,6 +795,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
lg-lw LG LW20/LW25 laptop lg-lw LG LW20/LW25 laptop
tcl TCL S700 tcl TCL S700
clevo Clevo laptops (m520G, m665n) clevo Clevo laptops (m520G, m665n)
medion Medion Rim 2150
test for testing/debugging purpose, almost all controls can be test for testing/debugging purpose, almost all controls can be
adjusted. Appearing only when compiled with adjusted. Appearing only when compiled with
$CONFIG_SND_DEBUG=y $CONFIG_SND_DEBUG=y

2
Documentation/sysrq.txt
View file

@ -85,6 +85,8 @@ On all - write a character to /proc/sysrq-trigger. e.g.:
'k' - Secure Access Key (SAK) Kills all programs on the current virtual 'k' - Secure Access Key (SAK) Kills all programs on the current virtual
console. NOTE: See important comments below in SAK section. console. NOTE: See important comments below in SAK section.
'l' - Shows a stack backtrace for all active CPUs.
'm' - Will dump current memory info to your console. 'm' - Will dump current memory info to your console.
'n' - Used to make RT tasks nice-able 'n' - Used to make RT tasks nice-able

33
Documentation/thermal/sysfs-api.txt
View file

@ -108,10 +108,12 @@ and throttle appropriate devices.
RO read only value RO read only value
RW read/write value RW read/write value
All thermal sysfs attributes will be represented under /sys/class/thermal Thermal sysfs attributes will be represented under /sys/class/thermal.
Hwmon sysfs I/F extension is also available under /sys/class/hwmon
if hwmon is compiled in or built as a module.
Thermal zone device sys I/F, created once it's registered: Thermal zone device sys I/F, created once it's registered:
|thermal_zone[0-*]: /sys/class/thermal/thermal_zone[0-*]:
|-----type: Type of the thermal zone |-----type: Type of the thermal zone
|-----temp: Current temperature |-----temp: Current temperature
|-----mode: Working mode of the thermal zone |-----mode: Working mode of the thermal zone
@ -119,7 +121,7 @@ Thermal zone device sys I/F, created once it's registered:
|-----trip_point_[0-*]_type: Trip point type |-----trip_point_[0-*]_type: Trip point type
Thermal cooling device sys I/F, created once it's registered: Thermal cooling device sys I/F, created once it's registered:
|cooling_device[0-*]: /sys/class/thermal/cooling_device[0-*]:
|-----type : Type of the cooling device(processor/fan/...) |-----type : Type of the cooling device(processor/fan/...)
|-----max_state: Maximum cooling state of the cooling device |-----max_state: Maximum cooling state of the cooling device
|-----cur_state: Current cooling state of the cooling device |-----cur_state: Current cooling state of the cooling device
@ -130,10 +132,19 @@ They represent the relationship between a thermal zone and its associated coolin
They are created/removed for each They are created/removed for each
thermal_zone_bind_cooling_device/thermal_zone_unbind_cooling_device successful execution. thermal_zone_bind_cooling_device/thermal_zone_unbind_cooling_device successful execution.
|thermal_zone[0-*] /sys/class/thermal/thermal_zone[0-*]
|-----cdev[0-*]: The [0-*]th cooling device in the current thermal zone |-----cdev[0-*]: The [0-*]th cooling device in the current thermal zone
|-----cdev[0-*]_trip_point: Trip point that cdev[0-*] is associated with |-----cdev[0-*]_trip_point: Trip point that cdev[0-*] is associated with
Besides the thermal zone device sysfs I/F and cooling device sysfs I/F,
the generic thermal driver also creates a hwmon sysfs I/F for each _type_ of
thermal zone device. E.g. the generic thermal driver registers one hwmon class device
and build the associated hwmon sysfs I/F for all the registered ACPI thermal zones.
/sys/class/hwmon/hwmon[0-*]:
|-----name: The type of the thermal zone devices.
|-----temp[1-*]_input: The current temperature of thermal zone [1-*].
|-----temp[1-*]_critical: The critical trip point of thermal zone [1-*].
Please read Documentation/hwmon/sysfs-interface for additional information.
*************************** ***************************
* Thermal zone attributes * * Thermal zone attributes *
@ -141,7 +152,10 @@ thermal_zone_bind_cooling_device/thermal_zone_unbind_cooling_device successful e
type Strings which represent the thermal zone type. type Strings which represent the thermal zone type.
This is given by thermal zone driver as part of registration. This is given by thermal zone driver as part of registration.
Eg: "ACPI thermal zone" indicates it's a ACPI thermal device Eg: "acpitz" indicates it's an ACPI thermal device.
In order to keep it consistent with hwmon sys attribute,
this should be a short, lowercase string,
not containing spaces nor dashes.
RO RO
Required Required
@ -218,7 +232,7 @@ the sys I/F structure will be built like this:
/sys/class/thermal: /sys/class/thermal:
|thermal_zone1: |thermal_zone1:
|-----type: ACPI thermal zone |-----type: acpitz
|-----temp: 37000 |-----temp: 37000
|-----mode: kernel |-----mode: kernel
|-----trip_point_0_temp: 100000 |-----trip_point_0_temp: 100000
@ -243,3 +257,10 @@ the sys I/F structure will be built like this:
|-----type: Fan |-----type: Fan
|-----max_state: 2 |-----max_state: 2
|-----cur_state: 0 |-----cur_state: 0
/sys/class/hwmon:
|hwmon0:
|-----name: acpitz
|-----temp1_input: 37000
|-----temp1_crit: 100000

2
Documentation/video4linux/CARDLIST.cx23885
View file

@ -5,6 +5,6 @@
4 -> DViCO FusionHDTV5 Express [18ac:d500] 4 -> DViCO FusionHDTV5 Express [18ac:d500]
5 -> Hauppauge WinTV-HVR1500Q [0070:7790,0070:7797] 5 -> Hauppauge WinTV-HVR1500Q [0070:7790,0070:7797]
6 -> Hauppauge WinTV-HVR1500 [0070:7710,0070:7717] 6 -> Hauppauge WinTV-HVR1500 [0070:7710,0070:7717]
7 -> Hauppauge WinTV-HVR1200 [0070:71d1] 7 -> Hauppauge WinTV-HVR1200 [0070:71d1,0070:71d3]
8 -> Hauppauge WinTV-HVR1700 [0070:8101] 8 -> Hauppauge WinTV-HVR1700 [0070:8101]
9 -> Hauppauge WinTV-HVR1400 [0070:8010] 9 -> Hauppauge WinTV-HVR1400 [0070:8010]

2
Documentation/video4linux/CARDLIST.em28xx
View file

@ -14,4 +14,4 @@
13 -> Terratec Prodigy XS (em2880) [0ccd:0047] 13 -> Terratec Prodigy XS (em2880) [0ccd:0047]
14 -> Pixelview Prolink PlayTV USB 2.0 (em2820/em2840) 14 -> Pixelview Prolink PlayTV USB 2.0 (em2820/em2840)
15 -> V-Gear PocketTV (em2800) 15 -> V-Gear PocketTV (em2800)
16 -> Hauppauge WinTV HVR 950 (em2880) [2040:6513] 16 -> Hauppauge WinTV HVR 950 (em2880) [2040:6513,2040:6517,2040:651b,2040:651f]

3
Documentation/video4linux/CARDLIST.saa7134
View file

@ -128,7 +128,7 @@
127 -> Beholder BeholdTV 507 FM/RDS / BeholdTV 509 FM [0000:5071,0000:507B,5ace:5070,5ace:5090] 127 -> Beholder BeholdTV 507 FM/RDS / BeholdTV 509 FM [0000:5071,0000:507B,5ace:5070,5ace:5090]
128 -> Beholder BeholdTV Columbus TVFM [0000:5201] 128 -> Beholder BeholdTV Columbus TVFM [0000:5201]
129 -> Beholder BeholdTV 607 / BeholdTV 609 [5ace:6070,5ace:6071,5ace:6072,5ace:6073,5ace:6090,5ace:6091,5ace:6092,5ace:6093] 129 -> Beholder BeholdTV 607 / BeholdTV 609 [5ace:6070,5ace:6071,5ace:6072,5ace:6073,5ace:6090,5ace:6091,5ace:6092,5ace:6093]
130 -> Beholder BeholdTV M6 / BeholdTV M6 Extra [5ace:6190,5ace:6193] 130 -> Beholder BeholdTV M6 / BeholdTV M6 Extra [5ace:6190,5ace:6193,5ace:6191]
131 -> Twinhan Hybrid DTV-DVB 3056 PCI [1822:0022] 131 -> Twinhan Hybrid DTV-DVB 3056 PCI [1822:0022]
132 -> Genius TVGO AM11MCE 132 -> Genius TVGO AM11MCE
133 -> NXP Snake DVB-S reference design 133 -> NXP Snake DVB-S reference design
@ -140,3 +140,4 @@
139 -> Compro VideoMate T750 [185b:c900] 139 -> Compro VideoMate T750 [185b:c900]
140 -> Avermedia DVB-S Pro A700 [1461:a7a1] 140 -> Avermedia DVB-S Pro A700 [1461:a7a1]
141 -> Avermedia DVB-S Hybrid+FM A700 [1461:a7a2] 141 -> Avermedia DVB-S Hybrid+FM A700 [1461:a7a2]
142 -> Beholder BeholdTV H6 [5ace:6290]

34
Documentation/video4linux/cx18.txt Normal file
View file

@ -0,0 +1,34 @@
Some notes regarding the cx18 driver for the Conexant CX23418 MPEG
encoder chip:
1) The only hardware currently supported is the Hauppauge HVR-1600.
2) Some people have problems getting the i2c bus to work. Cause unknown.
The symptom is that the eeprom cannot be read and the card is
unusable.
3) The audio from the analog tuner is mono only. Probably caused by
incorrect audio register information in the datasheet. We are
waiting for updated information from Conexant.
4) VBI (raw or sliced) has not yet been implemented.
5) MPEG indexing is not yet implemented.
6) The driver is still a bit rough around the edges, this should
improve over time.
Firmware:
The firmware needs to be extracted from the Windows Hauppauge HVR-1600
driver, available here:
http://hauppauge.lightpath.net/software/install_cd/hauppauge_cd_3.4d1.zip
Unzip, then copy the following files to the firmware directory
and rename them as follows:
Drivers/Driver18/hcw18apu.rom -> v4l-cx23418-apu.fw
Drivers/Driver18/hcw18enc.rom -> v4l-cx23418-cpu.fw
Drivers/Driver18/hcw18mlC.rom -> v4l-cx23418-dig.fw

10
Documentation/vm/slabinfo.c
View file

@ -38,7 +38,7 @@ struct slabinfo {
unsigned long alloc_from_partial, alloc_slab, free_slab, alloc_refill; unsigned long alloc_from_partial, alloc_slab, free_slab, alloc_refill;
unsigned long cpuslab_flush, deactivate_full, deactivate_empty; unsigned long cpuslab_flush, deactivate_full, deactivate_empty;
unsigned long deactivate_to_head, deactivate_to_tail; unsigned long deactivate_to_head, deactivate_to_tail;
unsigned long deactivate_remote_frees; unsigned long deactivate_remote_frees, order_fallback;
int numa[MAX_NODES]; int numa[MAX_NODES];
int numa_partial[MAX_NODES]; int numa_partial[MAX_NODES];
} slabinfo[MAX_SLABS]; } slabinfo[MAX_SLABS];
@ -293,7 +293,7 @@ int line = 0;
void first_line(void) void first_line(void)
{ {
if (show_activity) if (show_activity)
printf("Name Objects Alloc Free %%Fast\n"); printf("Name Objects Alloc Free %%Fast Fallb O\n");
else else
printf("Name Objects Objsize Space " printf("Name Objects Objsize Space "
"Slabs/Part/Cpu O/S O %%Fr %%Ef Flg\n"); "Slabs/Part/Cpu O/S O %%Fr %%Ef Flg\n");
@ -573,11 +573,12 @@ void slabcache(struct slabinfo *s)
total_alloc = s->alloc_fastpath + s->alloc_slowpath; total_alloc = s->alloc_fastpath + s->alloc_slowpath;
total_free = s->free_fastpath + s->free_slowpath; total_free = s->free_fastpath + s->free_slowpath;
printf("%-21s %8ld %8ld %8ld %3ld %3ld \n", printf("%-21s %8ld %10ld %10ld %3ld %3ld %5ld %1d\n",
s->name, s->objects, s->name, s->objects,
total_alloc, total_free, total_alloc, total_free,
total_alloc ? (s->alloc_fastpath * 100 / total_alloc) : 0, total_alloc ? (s->alloc_fastpath * 100 / total_alloc) : 0,
total_free ? (s->free_fastpath * 100 / total_free) : 0); total_free ? (s->free_fastpath * 100 / total_free) : 0,
s->order_fallback, s->order);
} }
else else
printf("%-21s %8ld %7d %8s %14s %4d %1d %3ld %3ld %s\n", printf("%-21s %8ld %7d %8s %14s %4d %1d %3ld %3ld %s\n",
@ -1188,6 +1189,7 @@ void read_slab_dir(void)
slab->deactivate_to_head = get_obj("deactivate_to_head"); slab->deactivate_to_head = get_obj("deactivate_to_head");
slab->deactivate_to_tail = get_obj("deactivate_to_tail"); slab->deactivate_to_tail = get_obj("deactivate_to_tail");
slab->deactivate_remote_frees = get_obj("deactivate_remote_frees"); slab->deactivate_remote_frees = get_obj("deactivate_remote_frees");
slab->order_fallback = get_obj("order_fallback");
chdir(".."); chdir("..");
if (slab->name[0] == ':') if (slab->name[0] == ':')
alias_targets++; alias_targets++;

192
MAINTAINERS
View file

@ -367,12 +367,12 @@ S: Maintained for 2.4; PCI support for 2.6.
AMD GEODE CS5536 USB DEVICE CONTROLLER DRIVER AMD GEODE CS5536 USB DEVICE CONTROLLER DRIVER
P: Thomas Dahlmann P: Thomas Dahlmann
M: thomas.dahlmann@amd.com M: thomas.dahlmann@amd.com
L: info-linux@geode.amd.com (subscribers-only) L: linux-geode@lists.infradead.org (moderated for non-subscribers)
S: Supported S: Supported
AMD GEODE PROCESSOR/CHIPSET SUPPORT AMD GEODE PROCESSOR/CHIPSET SUPPORT
P: Jordan Crouse P: Jordan Crouse
L: info-linux@geode.amd.com (subscribers-only) L: linux-geode@lists.infradead.org (moderated for non-subscribers)
W: http://www.amd.com/us-en/ConnectivitySolutions/TechnicalResources/0,,50_2334_2452_11363,00.html W: http://www.amd.com/us-en/ConnectivitySolutions/TechnicalResources/0,,50_2334_2452_11363,00.html
S: Supported S: Supported
@ -752,11 +752,13 @@ W: http://atmelwlandriver.sourceforge.net/
S: Maintained S: Maintained
AUDIT SUBSYSTEM AUDIT SUBSYSTEM
P: David Woodhouse P: Al Viro
M: dwmw2@infradead.org M: viro@zeniv.linux.org.uk
P: Eric Paris
M: eparis@redhat.com
L: linux-audit@redhat.com (subscribers-only) L: linux-audit@redhat.com (subscribers-only)
W: http://people.redhat.com/sgrubb/audit/ W: http://people.redhat.com/sgrubb/audit/
T: git kernel.org:/pub/scm/linux/kernel/git/dwmw2/audit-2.6.git T: git git.kernel.org/pub/scm/linux/kernel/git/viro/audit-current.git
S: Maintained S: Maintained
AUXILIARY DISPLAY DRIVERS AUXILIARY DISPLAY DRIVERS
@ -1037,7 +1039,7 @@ P: Urs Thuermann
M: urs.thuermann@volkswagen.de M: urs.thuermann@volkswagen.de
P: Oliver Hartkopp P: Oliver Hartkopp
M: oliver.hartkopp@volkswagen.de M: oliver.hartkopp@volkswagen.de
L: socketcan-core@lists.berlios.de L: socketcan-core@lists.berlios.de (subscribers-only)
W: http://developer.berlios.de/projects/socketcan/ W: http://developer.berlios.de/projects/socketcan/
S: Maintained S: Maintained
@ -1194,9 +1196,9 @@ S: Maintained
CPUSETS CPUSETS
P: Paul Jackson P: Paul Jackson
P: Simon Derr P: Paul Menage
M: pj@sgi.com M: pj@sgi.com
M: simon.derr@bull.net M: menage@google.com
L: linux-kernel@vger.kernel.org L: linux-kernel@vger.kernel.org
W: http://www.bullopensource.org/cpuset/ W: http://www.bullopensource.org/cpuset/
S: Supported S: Supported
@ -1228,6 +1230,15 @@ P: Jaya Kumar
M: jayakumar.alsa@gmail.com M: jayakumar.alsa@gmail.com
S: Maintained S: Maintained
CX18 VIDEO4LINUX DRIVER
P: Hans Verkuil, Andy Walls
M: hverkuil@xs4all.nl, awalls@radix.net
L: ivtv-devel@ivtvdriver.org
L: ivtv-users@ivtvdriver.org
L: video4linux-list@redhat.com
W: http://linuxtv.org
S: Maintained
CYBERPRO FB DRIVER CYBERPRO FB DRIVER
P: Russell King P: Russell King
M: rmk@arm.linux.org.uk M: rmk@arm.linux.org.uk
@ -1531,6 +1542,13 @@ L: bluesmoke-devel@lists.sourceforge.net
W: bluesmoke.sourceforge.net W: bluesmoke.sourceforge.net
S: Maintained S: Maintained
EEEPC LAPTOP EXTRAS DRIVER
P: Corentin Chary
M: corentincj@iksaif.net
L: acpi4asus-user@lists.sourceforge.net
W: http://sourceforge.net/projects/acpi4asus
S: Maintained
EEPRO100 NETWORK DRIVER EEPRO100 NETWORK DRIVER
P: Andrey V. Savochkin P: Andrey V. Savochkin
M: saw@saw.sw.com.sg M: saw@saw.sw.com.sg
@ -1548,6 +1566,14 @@ M: raisch@de.ibm.com
L: general@lists.openfabrics.org L: general@lists.openfabrics.org
S: Supported S: Supported
EMBEDDED LINUX
P: Paul Gortmaker
M: paul.gortmaker@windriver.com
P David Woodhouse
M: dwmw2@infradead.org
L: linux-embedded@vger.kernel.org
S: Maintained
EMULEX LPFC FC SCSI DRIVER EMULEX LPFC FC SCSI DRIVER
P: James Smart P: James Smart
M: james.smart@emulex.com M: james.smart@emulex.com
@ -1914,8 +1940,10 @@ L: lm-sensors@lm-sensors.org
S: Maintained S: Maintained
I2C SUBSYSTEM I2C SUBSYSTEM
P: Jean Delvare P: Jean Delvare (PC drivers, core)
M: khali@linux-fr.org M: khali@linux-fr.org
P: Ben Dooks (embedded platforms)
M: ben-linux@fluff.org
L: i2c@lm-sensors.org L: i2c@lm-sensors.org
T: quilt http://khali.linux-fr.org/devel/linux-2.6/jdelvare-i2c/ T: quilt http://khali.linux-fr.org/devel/linux-2.6/jdelvare-i2c/
S: Maintained S: Maintained
@ -2095,12 +2123,10 @@ L: netdev@vger.kernel.org
S: Maintained S: Maintained
INTEL ETHERNET DRIVERS (e100/e1000/e1000e/igb/ixgb/ixgbe) INTEL ETHERNET DRIVERS (e100/e1000/e1000e/igb/ixgb/ixgbe)
P: Auke Kok
M: auke-jan.h.kok@intel.com
P: Jesse Brandeburg
M: jesse.brandeburg@intel.com
P: Jeff Kirsher P: Jeff Kirsher
M: jeffrey.t.kirsher@intel.com M: jeffrey.t.kirsher@intel.com
P: Jesse Brandeburg
M: jesse.brandeburg@intel.com
P: Bruce Allan P: Bruce Allan
M: bruce.w.allan@intel.com M: bruce.w.allan@intel.com
P: John Ronciak P: John Ronciak
@ -2694,7 +2720,7 @@ P: David Howells
M: dhowells@redhat.com M: dhowells@redhat.com
P: Koichi Yasutake P: Koichi Yasutake
M: yasutake.koichi@jp.panasonic.com M: yasutake.koichi@jp.panasonic.com
L: linux-am33-list@redhat.com L: linux-am33-list@redhat.com (moderated for non-subscribers)
W: ftp://ftp.redhat.com/pub/redhat/gnupro/AM33/ W: ftp://ftp.redhat.com/pub/redhat/gnupro/AM33/
S: Maintained S: Maintained
@ -2757,7 +2783,7 @@ M: rubini@ipvvis.unipv.it
L: linux-kernel@vger.kernel.org L: linux-kernel@vger.kernel.org
S: Maintained S: Maintained
MOXA SMARTIO/INDUSTIO SERIAL CARD (MXSER 2.0) MOXA SMARTIO/INDUSTIO/INTELLIO SERIAL CARD
P: Jiri Slaby P: Jiri Slaby
M: jirislaby@gmail.com M: jirislaby@gmail.com
L: linux-kernel@vger.kernel.org L: linux-kernel@vger.kernel.org
@ -3113,7 +3139,8 @@ PCI SUBSYSTEM
P: Jesse Barnes P: Jesse Barnes
M: jbarnes@virtuousgeek.org M: jbarnes@virtuousgeek.org
L: linux-kernel@vger.kernel.org L: linux-kernel@vger.kernel.org
L: linux-pci@atrey.karlin.mff.cuni.cz L: linux-pci@vger.kernel.org
T: git kernel.org:/pub/scm/linux/kernel/git/jbarnes/pci-2.6.git
S: Supported S: Supported
PCI HOTPLUG CORE PCI HOTPLUG CORE
@ -3574,6 +3601,13 @@ M: pfg@sgi.com
L: linux-ia64@vger.kernel.org L: linux-ia64@vger.kernel.org
S: Supported S: Supported
SFC NETWORK DRIVER
P: Steve Hodgson
P: Ben Hutchings
P: Robert Stonehouse
M: linux-net-drivers@solarflare.com
S: Supported
SGI VISUAL WORKSTATION 320 AND 540 SGI VISUAL WORKSTATION 320 AND 540
P: Andrey Panin P: Andrey Panin
M: pazke@donpac.ru M: pazke@donpac.ru
@ -3740,42 +3774,6 @@ M: chrisw@sous-sol.org
L: stable@kernel.org L: stable@kernel.org
S: Maintained S: Maintained
TPM DEVICE DRIVER
P: Kylene Hall
M: tpmdd-devel@lists.sourceforge.net
W: http://tpmdd.sourceforge.net
P: Marcel Selhorst
M: tpm@selhorst.net
W: http://www.prosec.rub.de/tpm/
L: tpmdd-devel@lists.sourceforge.net
S: Maintained
Telecom Clock Driver for MCPL0010
P: Mark Gross
M: mark.gross@intel.com
S: Supported
TENSILICA XTENSA PORT (xtensa):
P: Chris Zankel
M: chris@zankel.net
S: Maintained
THINKPAD ACPI EXTRAS DRIVER
P: Henrique de Moraes Holschuh
M: ibm-acpi@hmh.eng.br
L: ibm-acpi-devel@lists.sourceforge.net
W: http://ibm-acpi.sourceforge.net
W: http://thinkwiki.org/wiki/Ibm-acpi
T: git repo.or.cz/linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git
S: Maintained
UltraSPARC (sparc64):
P: David S. Miller
M: davem@davemloft.net
L: sparclinux@vger.kernel.org
T: git kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6.git
S: Maintained
SHARP LH SUPPORT (LH7952X & LH7A40X) SHARP LH SUPPORT (LH7952X & LH7A40X)
P: Marc Singer P: Marc Singer
M: elf@buici.com M: elf@buici.com
@ -3872,6 +3870,12 @@ P: Christoph Hellwig
M: hch@infradead.org M: hch@infradead.org
S: Maintained S: Maintained
TASKSTATS STATISTICS INTERFACE
P: Shailabh Nagar
M: nagar@watson.ibm.com
L: linux-kernel@vger.kernel.org
S: Maintained
TC CLASSIFIER TC CLASSIFIER
P: Jamal Hadi Salim P: Jamal Hadi Salim
M: hadi@cyberus.ca M: hadi@cyberus.ca
@ -3894,6 +3898,25 @@ M: andy@greyhouse.net
L: netdev@vger.kernel.org L: netdev@vger.kernel.org
S: Supported S: Supported
Telecom Clock Driver for MCPL0010
P: Mark Gross
M: mark.gross@intel.com
S: Supported
TENSILICA XTENSA PORT (xtensa):
P: Chris Zankel
M: chris@zankel.net
S: Maintained
THINKPAD ACPI EXTRAS DRIVER
P: Henrique de Moraes Holschuh
M: ibm-acpi@hmh.eng.br
L: ibm-acpi-devel@lists.sourceforge.net
W: http://ibm-acpi.sourceforge.net
W: http://thinkwiki.org/wiki/Ibm-acpi
T: git repo.or.cz/linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git
S: Maintained
TI FLASH MEDIA INTERFACE DRIVER TI FLASH MEDIA INTERFACE DRIVER
P: Alex Dubov P: Alex Dubov
M: oakad@yahoo.com M: oakad@yahoo.com
@ -3911,12 +3934,6 @@ P: Deepak Saxena
M: dsaxena@plexity.net M: dsaxena@plexity.net
S: Maintained S: Maintained
TASKSTATS STATISTICS INTERFACE
P: Shailabh Nagar
M: nagar@watson.ibm.com
L: linux-kernel@vger.kernel.org
S: Maintained
TIPC NETWORK LAYER TIPC NETWORK LAYER
P: Per Liden P: Per Liden
M: per.liden@ericsson.com M: per.liden@ericsson.com
@ -3950,6 +3967,16 @@ L: tlinux-users@tce.toshiba-dme.co.jp
W: http://www.buzzard.org.uk/toshiba/ W: http://www.buzzard.org.uk/toshiba/
S: Maintained S: Maintained
TPM DEVICE DRIVER
P: Kylene Hall
M: tpmdd-devel@lists.sourceforge.net
W: http://tpmdd.sourceforge.net
P: Marcel Selhorst
M: tpm@selhorst.net
W: http://www.prosec.rub.de/tpm/
L: tpmdd-devel@lists.sourceforge.net
S: Maintained
TRIDENT 4DWAVE/SIS 7018 PCI AUDIO CORE TRIDENT 4DWAVE/SIS 7018 PCI AUDIO CORE
P: Muli Ben-Yehuda P: Muli Ben-Yehuda
M: mulix@mulix.org M: mulix@mulix.org
@ -3962,6 +3989,12 @@ M: trivial@kernel.org
L: linux-kernel@vger.kernel.org L: linux-kernel@vger.kernel.org
S: Maintained S: Maintained
TTY LAYER
P: Alan Cox
M: alan@lxorguk.ukuu.org.uk
L: linux-kernel@vger.kernel.org
S: Maintained
TULIP NETWORK DRIVERS TULIP NETWORK DRIVERS
P: Grant Grundler P: Grant Grundler
M: grundler@parisc-linux.org M: grundler@parisc-linux.org
@ -4027,6 +4060,12 @@ L: linux-usb@vger.kernel.org
S: Maintained S: Maintained
W: http://www.kroah.com/linux-usb/ W: http://www.kroah.com/linux-usb/
USB CYPRESS C67X00 DRIVER
P: Peter Korsgaard
M: jacmet@sunsite.dk
L: linux-usb@vger.kernel.org
S: Maintained
USB DAVICOM DM9601 DRIVER USB DAVICOM DM9601 DRIVER
P: Peter Korsgaard P: Peter Korsgaard
M: jacmet@sunsite.dk M: jacmet@sunsite.dk
@ -4130,6 +4169,20 @@ L: linux-usb@vger.kernel.org
W: http://www.chello.nl/~j.vreeken/se401/ W: http://www.chello.nl/~j.vreeken/se401/
S: Maintained S: Maintained
USB SERIAL BELKIN F5U103 DRIVER
P: William Greathouse
M: wgreathouse@smva.com
L: linux-usb@vger.kernel.org
S: Maintained
USB SERIAL CYPRESS M8 DRIVER
P: Lonnie Mendez
M: dignome@gmail.com
L: linux-usb@vger.kernel.org
S: Maintained
W: http://geocities.com/i0xox0i
W: http://firstlight.net/cvs
USB SERIAL CYBERJACK DRIVER USB SERIAL CYBERJACK DRIVER
P: Matthias Bruestle and Harald Welte P: Matthias Bruestle and Harald Welte
M: support@reiner-sct.com M: support@reiner-sct.com
@ -4149,20 +4202,6 @@ M: gregkh@suse.de
L: linux-usb@vger.kernel.org L: linux-usb@vger.kernel.org
S: Supported S: Supported
USB SERIAL BELKIN F5U103 DRIVER
P: William Greathouse
M: wgreathouse@smva.com
L: linux-usb@vger.kernel.org
S: Maintained
USB SERIAL CYPRESS M8 DRIVER
P: Lonnie Mendez
M: dignome@gmail.com
L: linux-usb@vger.kernel.org
S: Maintained
W: http://geocities.com/i0xox0i
W: http://firstlight.net/cvs
USB SERIAL EMPEG EMPEG-CAR MARK I/II DRIVER USB SERIAL EMPEG EMPEG-CAR MARK I/II DRIVER
P: Gary Brubaker P: Gary Brubaker
M: xavyer@ix.netcom.com M: xavyer@ix.netcom.com
@ -4265,7 +4304,7 @@ M: gregkh@suse.de
L: linux-kernel@vger.kernel.org L: linux-kernel@vger.kernel.org
S: Maintained S: Maintained
FAT/VFAT/MSDOS FILESYSTEM: VFAT/FAT/MSDOS FILESYSTEM:
P: OGAWA Hirofumi P: OGAWA Hirofumi
M: hirofumi@mail.parknet.co.jp M: hirofumi@mail.parknet.co.jp
L: linux-kernel@vger.kernel.org L: linux-kernel@vger.kernel.org
@ -4310,6 +4349,13 @@ M: dushistov@mail.ru
L: linux-kernel@vger.kernel.org L: linux-kernel@vger.kernel.org
S: Maintained S: Maintained
UltraSPARC (sparc64):
P: David S. Miller
M: davem@davemloft.net
L: sparclinux@vger.kernel.org
T: git kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6.git
S: Maintained
USB DIAMOND RIO500 DRIVER USB DIAMOND RIO500 DRIVER
P: Cesar Miquel P: Cesar Miquel
M: miquel@df.uba.ar M: miquel@df.uba.ar

10
Makefile
View file

@ -1,7 +1,7 @@
VERSION = 2 VERSION = 2
PATCHLEVEL = 6 PATCHLEVEL = 6
SUBLEVEL = 25 SUBLEVEL = 26
EXTRAVERSION = EXTRAVERSION = -rc3
NAME = Funky Weasel is Jiggy wit it NAME = Funky Weasel is Jiggy wit it
# *DOCUMENTATION* # *DOCUMENTATION*
@ -794,7 +794,7 @@ endif # ifdef CONFIG_KALLSYMS
quiet_cmd_vmlinux-modpost = LD $@ quiet_cmd_vmlinux-modpost = LD $@
cmd_vmlinux-modpost = $(LD) $(LDFLAGS) -r -o $@ \ cmd_vmlinux-modpost = $(LD) $(LDFLAGS) -r -o $@ \
$(vmlinux-init) --start-group $(vmlinux-main) --end-group \ $(vmlinux-init) --start-group $(vmlinux-main) --end-group \
$(filter-out $(vmlinux-init) $(vmlinux-main) $(vmlinux-lds) FORCE ,$^) $(filter-out $(vmlinux-init) $(vmlinux-main) FORCE ,$^)
define rule_vmlinux-modpost define rule_vmlinux-modpost
: :
+$(call cmd,vmlinux-modpost) +$(call cmd,vmlinux-modpost)
@ -818,7 +818,9 @@ endif
ifdef CONFIG_KALLSYMS ifdef CONFIG_KALLSYMS
.tmp_vmlinux1: vmlinux.o .tmp_vmlinux1: vmlinux.o
endif endif
vmlinux.o: $(vmlinux-lds) $(vmlinux-init) $(vmlinux-main) FORCE
modpost-init := $(filter-out init/built-in.o, $(vmlinux-init))
vmlinux.o: $(modpost-init) $(vmlinux-main) FORCE
$(call if_changed_rule,vmlinux-modpost) $(call if_changed_rule,vmlinux-modpost)
# The actual objects are generated when descending, # The actual objects are generated when descending,

3
arch/Kconfig
View file

@ -36,3 +36,6 @@ config HAVE_KPROBES
config HAVE_KRETPROBES config HAVE_KRETPROBES
def_bool n def_bool n
config HAVE_DMA_ATTRS
def_bool n

6
arch/alpha/kernel/asm-offsets.c
View file

@ -8,13 +8,9 @@
#include <linux/stddef.h> #include <linux/stddef.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/ptrace.h> #include <linux/ptrace.h>
#include <linux/kbuild.h>
#include <asm/io.h> #include <asm/io.h>
#define DEFINE(sym, val) \
asm volatile("\n->" #sym " %0 " #val : : "i" (val))
#define BLANK() asm volatile("\n->" : : )
void foo(void) void foo(void)
{ {
DEFINE(TI_TASK, offsetof(struct thread_info, task)); DEFINE(TI_TASK, offsetof(struct thread_info, task));

69
arch/alpha/kernel/osf_sys.c
View file

@ -981,27 +981,18 @@ asmlinkage int
osf_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, osf_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp,
struct timeval32 __user *tvp) struct timeval32 __user *tvp)
{ {
fd_set_bits fds; s64 timeout = MAX_SCHEDULE_TIMEOUT;
char *bits;
size_t size;
long timeout;
int ret = -EINVAL;
struct fdtable *fdt;
int max_fds;
timeout = MAX_SCHEDULE_TIMEOUT;
if (tvp) { if (tvp) {
time_t sec, usec; time_t sec, usec;
if (!access_ok(VERIFY_READ, tvp, sizeof(*tvp)) if (!access_ok(VERIFY_READ, tvp, sizeof(*tvp))
|| __get_user(sec, &tvp->tv_sec) || __get_user(sec, &tvp->tv_sec)
|| __get_user(usec, &tvp->tv_usec)) { || __get_user(usec, &tvp->tv_usec)) {
ret = -EFAULT; return -EFAULT;
goto out_nofds;
} }
if (sec < 0 || usec < 0) if (sec < 0 || usec < 0)
goto out_nofds; return -EINVAL;
if ((unsigned long) sec < MAX_SELECT_SECONDS) { if ((unsigned long) sec < MAX_SELECT_SECONDS) {
timeout = (usec + 1000000/HZ - 1) / (1000000/HZ); timeout = (usec + 1000000/HZ - 1) / (1000000/HZ);
@ -1009,60 +1000,8 @@ osf_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp,
} }
} }
rcu_read_lock();
fdt = files_fdtable(current->files);
max_fds = fdt->max_fds;
rcu_read_unlock();
if (n < 0 || n > max_fds)
goto out_nofds;
/*
* We need 6 bitmaps (in/out/ex for both incoming and outgoing),
* since we used fdset we need to allocate memory in units of
* long-words.
*/
ret = -ENOMEM;
size = FDS_BYTES(n);
bits = kmalloc(6 * size, GFP_KERNEL);
if (!bits)
goto out_nofds;
fds.in = (unsigned long *) bits;
fds.out = (unsigned long *) (bits + size);
fds.ex = (unsigned long *) (bits + 2*size);
fds.res_in = (unsigned long *) (bits + 3*size);
fds.res_out = (unsigned long *) (bits + 4*size);
fds.res_ex = (unsigned long *) (bits + 5*size);
if ((ret = get_fd_set(n, inp->fds_bits, fds.in)) ||
(ret = get_fd_set(n, outp->fds_bits, fds.out)) ||
(ret = get_fd_set(n, exp->fds_bits, fds.ex)))
goto out;
zero_fd_set(n, fds.res_in);
zero_fd_set(n, fds.res_out);
zero_fd_set(n, fds.res_ex);
ret = do_select(n, &fds, &timeout);
/* OSF does not copy back the remaining time. */ /* OSF does not copy back the remaining time. */
return core_sys_select(n, inp, outp, exp, &timeout);
if (ret < 0)
goto out;
if (!ret) {
ret = -ERESTARTNOHAND;
if (signal_pending(current))
goto out;
ret = 0;
}
if (set_fd_set(n, inp->fds_bits, fds.res_in) ||
set_fd_set(n, outp->fds_bits, fds.res_out) ||
set_fd_set(n, exp->fds_bits, fds.res_ex))
ret = -EFAULT;
out:
kfree(bits);
out_nofds:
return ret;
} }
struct rusage32 { struct rusage32 {

4
arch/alpha/kernel/pci.c
View file

@ -514,8 +514,8 @@ sys_pciconfig_iobase(long which, unsigned long bus, unsigned long dfn)
void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen) void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
{ {
unsigned long start = pci_resource_start(dev, bar); resource_size_t start = pci_resource_start(dev, bar);
unsigned long len = pci_resource_len(dev, bar); resource_size_t len = pci_resource_len(dev, bar);
unsigned long flags = pci_resource_flags(dev, bar); unsigned long flags = pci_resource_flags(dev, bar);
if (!len || !start) if (!len || !start)

66
arch/arm/common/locomo.c
View file

@ -321,11 +321,42 @@ static void locomo_gpio_unmask_irq(unsigned int irq)
locomo_writel(r, mapbase + LOCOMO_GIE); locomo_writel(r, mapbase + LOCOMO_GIE);
} }
static int GPIO_IRQ_rising_edge;
static int GPIO_IRQ_falling_edge;
static int locomo_gpio_type(unsigned int irq, unsigned int type)
{
unsigned int mask;
void __iomem *mapbase = get_irq_chip_data(irq);
mask = 1 << (irq - LOCOMO_IRQ_GPIO_START);
if (type == IRQT_PROBE) {
if ((GPIO_IRQ_rising_edge | GPIO_IRQ_falling_edge) & mask)
return 0;
type = __IRQT_RISEDGE | __IRQT_FALEDGE;
}
if (type & __IRQT_RISEDGE)
GPIO_IRQ_rising_edge |= mask;
else
GPIO_IRQ_rising_edge &= ~mask;
if (type & __IRQT_FALEDGE)
GPIO_IRQ_falling_edge |= mask;
else
GPIO_IRQ_falling_edge &= ~mask;
locomo_writel(GPIO_IRQ_rising_edge, mapbase + LOCOMO_GRIE);
locomo_writel(GPIO_IRQ_falling_edge, mapbase + LOCOMO_GFIE);
return 0;
}
static struct irq_chip locomo_gpio_chip = { static struct irq_chip locomo_gpio_chip = {
.name = "LOCOMO-gpio", .name = "LOCOMO-gpio",
.ack = locomo_gpio_ack_irq, .ack = locomo_gpio_ack_irq,
.mask = locomo_gpio_mask_irq, .mask = locomo_gpio_mask_irq,
.unmask = locomo_gpio_unmask_irq, .unmask = locomo_gpio_unmask_irq,
.set_type = locomo_gpio_type,
}; };
static void locomo_lt_handler(unsigned int irq, struct irq_desc *desc) static void locomo_lt_handler(unsigned int irq, struct irq_desc *desc)
@ -450,22 +481,18 @@ static void locomo_setup_irq(struct locomo *lchip)
set_irq_chip(IRQ_LOCOMO_KEY_BASE, &locomo_chip); set_irq_chip(IRQ_LOCOMO_KEY_BASE, &locomo_chip);
set_irq_chip_data(IRQ_LOCOMO_KEY_BASE, irqbase); set_irq_chip_data(IRQ_LOCOMO_KEY_BASE, irqbase);
set_irq_chained_handler(IRQ_LOCOMO_KEY_BASE, locomo_key_handler); set_irq_chained_handler(IRQ_LOCOMO_KEY_BASE, locomo_key_handler);
set_irq_flags(IRQ_LOCOMO_KEY_BASE, IRQF_VALID | IRQF_PROBE);
set_irq_chip(IRQ_LOCOMO_GPIO_BASE, &locomo_chip); set_irq_chip(IRQ_LOCOMO_GPIO_BASE, &locomo_chip);
set_irq_chip_data(IRQ_LOCOMO_GPIO_BASE, irqbase); set_irq_chip_data(IRQ_LOCOMO_GPIO_BASE, irqbase);
set_irq_chained_handler(IRQ_LOCOMO_GPIO_BASE, locomo_gpio_handler); set_irq_chained_handler(IRQ_LOCOMO_GPIO_BASE, locomo_gpio_handler);
set_irq_flags(IRQ_LOCOMO_GPIO_BASE, IRQF_VALID | IRQF_PROBE);
set_irq_chip(IRQ_LOCOMO_LT_BASE, &locomo_chip); set_irq_chip(IRQ_LOCOMO_LT_BASE, &locomo_chip);
set_irq_chip_data(IRQ_LOCOMO_LT_BASE, irqbase); set_irq_chip_data(IRQ_LOCOMO_LT_BASE, irqbase);
set_irq_chained_handler(IRQ_LOCOMO_LT_BASE, locomo_lt_handler); set_irq_chained_handler(IRQ_LOCOMO_LT_BASE, locomo_lt_handler);
set_irq_flags(IRQ_LOCOMO_LT_BASE, IRQF_VALID | IRQF_PROBE);
set_irq_chip(IRQ_LOCOMO_SPI_BASE, &locomo_chip); set_irq_chip(IRQ_LOCOMO_SPI_BASE, &locomo_chip);
set_irq_chip_data(IRQ_LOCOMO_SPI_BASE, irqbase); set_irq_chip_data(IRQ_LOCOMO_SPI_BASE, irqbase);
set_irq_chained_handler(IRQ_LOCOMO_SPI_BASE, locomo_spi_handler); set_irq_chained_handler(IRQ_LOCOMO_SPI_BASE, locomo_spi_handler);
set_irq_flags(IRQ_LOCOMO_SPI_BASE, IRQF_VALID | IRQF_PROBE);
/* install handlers for IRQ_LOCOMO_KEY_BASE generated interrupts */ /* install handlers for IRQ_LOCOMO_KEY_BASE generated interrupts */
set_irq_chip(LOCOMO_IRQ_KEY_START, &locomo_key_chip); set_irq_chip(LOCOMO_IRQ_KEY_START, &locomo_key_chip);
@ -488,7 +515,7 @@ static void locomo_setup_irq(struct locomo *lchip)
set_irq_flags(LOCOMO_IRQ_LT_START, IRQF_VALID | IRQF_PROBE); set_irq_flags(LOCOMO_IRQ_LT_START, IRQF_VALID | IRQF_PROBE);
/* install handlers for IRQ_LOCOMO_SPI_BASE generated interrupts */ /* install handlers for IRQ_LOCOMO_SPI_BASE generated interrupts */
for (irq = LOCOMO_IRQ_SPI_START; irq < LOCOMO_IRQ_SPI_START + 3; irq++) { for (irq = LOCOMO_IRQ_SPI_START; irq < LOCOMO_IRQ_SPI_START + 4; irq++) {
set_irq_chip(irq, &locomo_spi_chip); set_irq_chip(irq, &locomo_spi_chip);
set_irq_chip_data(irq, irqbase); set_irq_chip_data(irq, irqbase);
set_irq_handler(irq, handle_edge_irq); set_irq_handler(irq, handle_edge_irq);
@ -574,20 +601,20 @@ static int locomo_suspend(struct platform_device *dev, pm_message_t state)
save->LCM_GPO = locomo_readl(lchip->base + LOCOMO_GPO); /* GPIO */ save->LCM_GPO = locomo_readl(lchip->base + LOCOMO_GPO); /* GPIO */
locomo_writel(0x00, lchip->base + LOCOMO_GPO); locomo_writel(0x00, lchip->base + LOCOMO_GPO);
save->LCM_SPICT = locomo_readl(lchip->base + LOCOMO_SPICT); /* SPI */ save->LCM_SPICT = locomo_readl(lchip->base + LOCOMO_SPI + LOCOMO_SPICT); /* SPI */
locomo_writel(0x40, lchip->base + LOCOMO_SPICT); locomo_writel(0x40, lchip->base + LOCOMO_SPICT);
save->LCM_GPE = locomo_readl(lchip->base + LOCOMO_GPE); /* GPIO */ save->LCM_GPE = locomo_readl(lchip->base + LOCOMO_GPE); /* GPIO */
locomo_writel(0x00, lchip->base + LOCOMO_GPE); locomo_writel(0x00, lchip->base + LOCOMO_GPE);
save->LCM_ASD = locomo_readl(lchip->base + LOCOMO_ASD); /* ADSTART */ save->LCM_ASD = locomo_readl(lchip->base + LOCOMO_ASD); /* ADSTART */
locomo_writel(0x00, lchip->base + LOCOMO_ASD); locomo_writel(0x00, lchip->base + LOCOMO_ASD);
save->LCM_SPIMD = locomo_readl(lchip->base + LOCOMO_SPIMD); /* SPI */ save->LCM_SPIMD = locomo_readl(lchip->base + LOCOMO_SPI + LOCOMO_SPIMD); /* SPI */
locomo_writel(0x3C14, lchip->base + LOCOMO_SPIMD); locomo_writel(0x3C14, lchip->base + LOCOMO_SPI + LOCOMO_SPIMD);
locomo_writel(0x00, lchip->base + LOCOMO_PAIF); locomo_writel(0x00, lchip->base + LOCOMO_PAIF);
locomo_writel(0x00, lchip->base + LOCOMO_DAC); locomo_writel(0x00, lchip->base + LOCOMO_DAC);
locomo_writel(0x00, lchip->base + LOCOMO_BACKLIGHT + LOCOMO_TC); locomo_writel(0x00, lchip->base + LOCOMO_BACKLIGHT + LOCOMO_TC);
if ( (locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT0) & 0x88) && (locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT1) & 0x88) ) if ((locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT0) & 0x88) && (locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT1) & 0x88))
locomo_writel(0x00, lchip->base + LOCOMO_C32K); /* CLK32 off */ locomo_writel(0x00, lchip->base + LOCOMO_C32K); /* CLK32 off */
else else
/* 18MHz already enabled, so no wait */ /* 18MHz already enabled, so no wait */
@ -616,10 +643,10 @@ static int locomo_resume(struct platform_device *dev)
spin_lock_irqsave(&lchip->lock, flags); spin_lock_irqsave(&lchip->lock, flags);
locomo_writel(save->LCM_GPO, lchip->base + LOCOMO_GPO); locomo_writel(save->LCM_GPO, lchip->base + LOCOMO_GPO);
locomo_writel(save->LCM_SPICT, lchip->base + LOCOMO_SPICT); locomo_writel(save->LCM_SPICT, lchip->base + LOCOMO_SPI + LOCOMO_SPICT);
locomo_writel(save->LCM_GPE, lchip->base + LOCOMO_GPE); locomo_writel(save->LCM_GPE, lchip->base + LOCOMO_GPE);
locomo_writel(save->LCM_ASD, lchip->base + LOCOMO_ASD); locomo_writel(save->LCM_ASD, lchip->base + LOCOMO_ASD);
locomo_writel(save->LCM_SPIMD, lchip->base + LOCOMO_SPIMD); locomo_writel(save->LCM_SPIMD, lchip->base + LOCOMO_SPI + LOCOMO_SPIMD);
locomo_writel(0x00, lchip->base + LOCOMO_C32K); locomo_writel(0x00, lchip->base + LOCOMO_C32K);
locomo_writel(0x90, lchip->base + LOCOMO_TADC); locomo_writel(0x90, lchip->base + LOCOMO_TADC);
@ -688,9 +715,9 @@ __locomo_probe(struct device *me, struct resource *mem, int irq)
/* GPIO */ /* GPIO */
locomo_writel(0, lchip->base + LOCOMO_GPO); locomo_writel(0, lchip->base + LOCOMO_GPO);
locomo_writel( (LOCOMO_GPIO(2) | LOCOMO_GPIO(3) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14)) locomo_writel((LOCOMO_GPIO(1) | LOCOMO_GPIO(2) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14))
, lchip->base + LOCOMO_GPE); , lchip->base + LOCOMO_GPE);
locomo_writel( (LOCOMO_GPIO(2) | LOCOMO_GPIO(3) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14)) locomo_writel((LOCOMO_GPIO(1) | LOCOMO_GPIO(2) | LOCOMO_GPIO(13) | LOCOMO_GPIO(14))
, lchip->base + LOCOMO_GPD); , lchip->base + LOCOMO_GPD);
locomo_writel(0, lchip->base + LOCOMO_GIE); locomo_writel(0, lchip->base + LOCOMO_GIE);
@ -833,7 +860,10 @@ void locomo_gpio_set_dir(struct device *dev, unsigned int bits, unsigned int dir
spin_lock_irqsave(&lchip->lock, flags); spin_lock_irqsave(&lchip->lock, flags);
r = locomo_readl(lchip->base + LOCOMO_GPD); r = locomo_readl(lchip->base + LOCOMO_GPD);
r &= ~bits; if (dir)
r |= bits;
else
r &= ~bits;
locomo_writel(r, lchip->base + LOCOMO_GPD); locomo_writel(r, lchip->base + LOCOMO_GPD);
r = locomo_readl(lchip->base + LOCOMO_GPE); r = locomo_readl(lchip->base + LOCOMO_GPE);

22
arch/arm/configs/am200epdkit_defconfig
View file

@ -1,7 +1,7 @@
# #
# Automatically generated make config: don't edit # Automatically generated make config: don't edit
# Linux kernel version: 2.6.25-rc3 # Linux kernel version: 2.6.25
# Sun Mar 9 06:33:33 2008 # Sun Apr 20 00:29:49 2008
# #
CONFIG_ARM=y CONFIG_ARM=y
CONFIG_SYS_SUPPORTS_APM_EMULATION=y CONFIG_SYS_SUPPORTS_APM_EMULATION=y
@ -51,7 +51,8 @@ CONFIG_FAIR_GROUP_SCHED=y
# CONFIG_RT_GROUP_SCHED is not set # CONFIG_RT_GROUP_SCHED is not set
CONFIG_USER_SCHED=y CONFIG_USER_SCHED=y
# CONFIG_CGROUP_SCHED is not set # CONFIG_CGROUP_SCHED is not set
# CONFIG_SYSFS_DEPRECATED is not set CONFIG_SYSFS_DEPRECATED=y
CONFIG_SYSFS_DEPRECATED_V2=y
# CONFIG_RELAY is not set # CONFIG_RELAY is not set
# CONFIG_NAMESPACES is not set # CONFIG_NAMESPACES is not set
# CONFIG_BLK_DEV_INITRD is not set # CONFIG_BLK_DEV_INITRD is not set
@ -85,6 +86,7 @@ CONFIG_SLAB=y
CONFIG_HAVE_OPROFILE=y CONFIG_HAVE_OPROFILE=y
# CONFIG_KPROBES is not set # CONFIG_KPROBES is not set
CONFIG_HAVE_KPROBES=y CONFIG_HAVE_KPROBES=y
CONFIG_HAVE_KRETPROBES=y
CONFIG_PROC_PAGE_MONITOR=y CONFIG_PROC_PAGE_MONITOR=y
CONFIG_SLABINFO=y CONFIG_SLABINFO=y
CONFIG_RT_MUTEXES=y CONFIG_RT_MUTEXES=y
@ -115,7 +117,6 @@ CONFIG_IOSCHED_NOOP=y
CONFIG_DEFAULT_NOOP=y CONFIG_DEFAULT_NOOP=y
CONFIG_DEFAULT_IOSCHED="noop" CONFIG_DEFAULT_IOSCHED="noop"
CONFIG_CLASSIC_RCU=y CONFIG_CLASSIC_RCU=y
# CONFIG_PREEMPT_RCU is not set
# #
# System Type # System Type
@ -320,8 +321,6 @@ CONFIG_TCP_CONG_CUBIC=y
CONFIG_DEFAULT_TCP_CONG="cubic" CONFIG_DEFAULT_TCP_CONG="cubic"
# CONFIG_TCP_MD5SIG is not set # CONFIG_TCP_MD5SIG is not set
# CONFIG_IPV6 is not set # CONFIG_IPV6 is not set
# CONFIG_INET6_XFRM_TUNNEL is not set
# CONFIG_INET6_TUNNEL is not set
# CONFIG_NETWORK_SECMARK is not set # CONFIG_NETWORK_SECMARK is not set
# CONFIG_NETFILTER is not set # CONFIG_NETFILTER is not set
# CONFIG_IP_DCCP is not set # CONFIG_IP_DCCP is not set
@ -383,7 +382,6 @@ CONFIG_IEEE80211=m
CONFIG_IEEE80211_CRYPT_WEP=m CONFIG_IEEE80211_CRYPT_WEP=m
# CONFIG_IEEE80211_CRYPT_CCMP is not set # CONFIG_IEEE80211_CRYPT_CCMP is not set
# CONFIG_IEEE80211_CRYPT_TKIP is not set # CONFIG_IEEE80211_CRYPT_TKIP is not set
# CONFIG_IEEE80211_SOFTMAC is not set
# CONFIG_RFKILL is not set # CONFIG_RFKILL is not set
# CONFIG_NET_9P is not set # CONFIG_NET_9P is not set
@ -503,7 +501,7 @@ CONFIG_IDE_MAX_HWIFS=2
CONFIG_BLK_DEV_IDE=m CONFIG_BLK_DEV_IDE=m
# #
# Please see Documentation/ide.txt for help/info on IDE drives # Please see Documentation/ide/ide.txt for help/info on IDE drives
# #
# CONFIG_BLK_DEV_IDE_SATA is not set # CONFIG_BLK_DEV_IDE_SATA is not set
CONFIG_BLK_DEV_IDEDISK=m CONFIG_BLK_DEV_IDEDISK=m
@ -518,10 +516,9 @@ CONFIG_IDE_PROC_FS=y
# #
# IDE chipset support/bugfixes # IDE chipset support/bugfixes
# #
CONFIG_IDE_GENERIC=m
# CONFIG_BLK_DEV_PLATFORM is not set # CONFIG_BLK_DEV_PLATFORM is not set
# CONFIG_BLK_DEV_IDEDMA is not set # CONFIG_BLK_DEV_IDEDMA is not set
CONFIG_IDE_ARCH_OBSOLETE_INIT=y # CONFIG_BLK_DEV_HD_ONLY is not set
# CONFIG_BLK_DEV_HD is not set # CONFIG_BLK_DEV_HD is not set
# #
@ -562,6 +559,7 @@ CONFIG_NETDEV_10000=y
# #
# CONFIG_WLAN_PRE80211 is not set # CONFIG_WLAN_PRE80211 is not set
# CONFIG_WLAN_80211 is not set # CONFIG_WLAN_80211 is not set
# CONFIG_IWLWIFI_LEDS is not set
# CONFIG_NET_PCMCIA is not set # CONFIG_NET_PCMCIA is not set
# CONFIG_WAN is not set # CONFIG_WAN is not set
# CONFIG_PPP is not set # CONFIG_PPP is not set
@ -707,6 +705,8 @@ CONFIG_SSB_POSSIBLE=y
# #
# CONFIG_MFD_SM501 is not set # CONFIG_MFD_SM501 is not set
# CONFIG_MFD_ASIC3 is not set # CONFIG_MFD_ASIC3 is not set
# CONFIG_HTC_EGPIO is not set
# CONFIG_HTC_PASIC3 is not set
# #
# Multimedia devices # Multimedia devices
@ -745,6 +745,7 @@ CONFIG_FB_TILEBLITTING=y
CONFIG_FB_PXA=y CONFIG_FB_PXA=y
CONFIG_FB_PXA_PARAMETERS=y CONFIG_FB_PXA_PARAMETERS=y
CONFIG_FB_MBX=m CONFIG_FB_MBX=m
# CONFIG_FB_METRONOME is not set
CONFIG_FB_VIRTUAL=m CONFIG_FB_VIRTUAL=m
# CONFIG_BACKLIGHT_LCD_SUPPORT is not set # CONFIG_BACKLIGHT_LCD_SUPPORT is not set
@ -891,7 +892,6 @@ CONFIG_RTC_LIB=y
# CONFIG_JFS_FS is not set # CONFIG_JFS_FS is not set
# CONFIG_FS_POSIX_ACL is not set # CONFIG_FS_POSIX_ACL is not set
# CONFIG_XFS_FS is not set # CONFIG_XFS_FS is not set
# CONFIG_GFS2_FS is not set
# CONFIG_OCFS2_FS is not set # CONFIG_OCFS2_FS is not set
# CONFIG_DNOTIFY is not set # CONFIG_DNOTIFY is not set
CONFIG_INOTIFY=y CONFIG_INOTIFY=y

2
arch/arm/kernel/armksyms.c
View file

@ -179,3 +179,5 @@ EXPORT_SYMBOL(_find_next_zero_bit_be);
EXPORT_SYMBOL(_find_first_bit_be); EXPORT_SYMBOL(_find_first_bit_be);
EXPORT_SYMBOL(_find_next_bit_be); EXPORT_SYMBOL(_find_next_bit_be);
#endif #endif
EXPORT_SYMBOL(copy_page);

2
arch/arm/kernel/arthur.c
View file

@ -90,3 +90,5 @@ static void __exit arthur_exit(void)
module_init(arthur_init); module_init(arthur_init);
module_exit(arthur_exit); module_exit(arthur_exit);
MODULE_LICENSE("GPL");

8
arch/arm/kernel/asm-offsets.c
View file

@ -16,6 +16,7 @@
#include <asm/thread_info.h> #include <asm/thread_info.h>
#include <asm/memory.h> #include <asm/memory.h>
#include <asm/procinfo.h> #include <asm/procinfo.h>
#include <linux/kbuild.h>
/* /*
* Make sure that the compiler and target are compatible. * Make sure that the compiler and target are compatible.
@ -35,13 +36,6 @@
#error Known good compilers: 3.3 #error Known good compilers: 3.3
#endif #endif
/* Use marker if you need to separate the values later */
#define DEFINE(sym, val) \
asm volatile("\n->" #sym " %0 " #val : : "i" (val))
#define BLANK() asm volatile("\n->" : : )
int main(void) int main(void)
{ {
DEFINE(TSK_ACTIVE_MM, offsetof(struct task_struct, active_mm)); DEFINE(TSK_ACTIVE_MM, offsetof(struct task_struct, active_mm));

2
arch/arm/kernel/atags.c
View file

@ -35,7 +35,7 @@ create_proc_entries(void)
{ {
struct proc_dir_entry* tags_entry; struct proc_dir_entry* tags_entry;
tags_entry = create_proc_read_entry("atags", 0400, &proc_root, read_buffer, &tags_buffer); tags_entry = create_proc_read_entry("atags", 0400, NULL, read_buffer, &tags_buffer);
if (!tags_entry) if (!tags_entry)
return -ENOMEM; return -ENOMEM;

54
arch/arm/kernel/ecard.c
View file

@ -37,6 +37,7 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/mutex.h> #include <linux/mutex.h>
@ -723,17 +724,14 @@ unsigned int __ecard_address(ecard_t *ec, card_type_t type, card_speed_t speed)
return address; return address;
} }
static int ecard_prints(char *buffer, ecard_t *ec) static int ecard_prints(struct seq_file *m, ecard_t *ec)
{ {
char *start = buffer; seq_printf(m, " %d: %s ", ec->slot_no, ec->easi ? "EASI" : " ");
buffer += sprintf(buffer, " %d: %s ", ec->slot_no,
ec->easi ? "EASI" : " ");
if (ec->cid.id == 0) { if (ec->cid.id == 0) {
struct in_chunk_dir incd; struct in_chunk_dir incd;
buffer += sprintf(buffer, "[%04X:%04X] ", seq_printf(m, "[%04X:%04X] ",
ec->cid.manufacturer, ec->cid.product); ec->cid.manufacturer, ec->cid.product);
if (!ec->card_desc && ec->cid.cd && if (!ec->card_desc && ec->cid.cd &&
@ -744,43 +742,43 @@ static int ecard_prints(char *buffer, ecard_t *ec)
strcpy((char *)ec->card_desc, incd.d.string); strcpy((char *)ec->card_desc, incd.d.string);
} }
buffer += sprintf(buffer, "%s\n", ec->card_desc ? ec->card_desc : "*unknown*"); seq_printf(m, "%s\n", ec->card_desc ? ec->card_desc : "*unknown*");
} else } else
buffer += sprintf(buffer, "Simple card %d\n", ec->cid.id); seq_printf(m, "Simple card %d\n", ec->cid.id);
return buffer - start; return 0;
} }
static int get_ecard_dev_info(char *buf, char **start, off_t pos, int count) static int ecard_devices_proc_show(struct seq_file *m, void *v)
{ {
ecard_t *ec = cards; ecard_t *ec = cards;
off_t at = 0;
int len, cnt;
cnt = 0; while (ec) {
while (ec && count > cnt) { ecard_prints(m, ec);
len = ecard_prints(buf, ec);
at += len;
if (at >= pos) {
if (!*start) {
*start = buf + (pos - (at - len));
cnt = at - pos;
} else
cnt += len;
buf += len;
}
ec = ec->next; ec = ec->next;
} }
return (count > cnt) ? cnt : count; return 0;
} }
static int ecard_devices_proc_open(struct inode *inode, struct file *file)
{
return single_open(file, ecard_devices_proc_show, NULL);
}
static const struct file_operations bus_ecard_proc_fops = {
.owner = THIS_MODULE,
.open = ecard_devices_proc_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static struct proc_dir_entry *proc_bus_ecard_dir = NULL; static struct proc_dir_entry *proc_bus_ecard_dir = NULL;
static void ecard_proc_init(void) static void ecard_proc_init(void)
{ {
proc_bus_ecard_dir = proc_mkdir("ecard", proc_bus); proc_bus_ecard_dir = proc_mkdir("bus/ecard", NULL);
create_proc_info_entry("devices", 0, proc_bus_ecard_dir, proc_create("devices", 0, proc_bus_ecard_dir, &bus_ecard_proc_fops);
get_ecard_dev_info);
} }
#define ec_set_resource(ec,nr,st,sz) \ #define ec_set_resource(ec,nr,st,sz) \

2
arch/arm/kernel/kprobes-decode.c
View file

@ -1176,7 +1176,7 @@ space_cccc_001x(kprobe_opcode_t insn, struct arch_specific_insn *asi)
* *S (bit 20) updates condition codes * *S (bit 20) updates condition codes
* ADC/SBC/RSC reads the C flag * ADC/SBC/RSC reads the C flag
*/ */
insn &= 0xfff00ff0; /* Rn = r0, Rd = r0 */ insn &= 0xfff00fff; /* Rn = r0, Rd = r0 */
asi->insn[0] = insn; asi->insn[0] = insn;
asi->insn_handler = (insn & (1 << 20)) ? /* S-bit */ asi->insn_handler = (insn & (1 << 20)) ? /* S-bit */
emulate_alu_imm_rwflags : emulate_alu_imm_rflags; emulate_alu_imm_rwflags : emulate_alu_imm_rflags;

2
arch/arm/kernel/kprobes.c
View file

@ -66,7 +66,7 @@ int __kprobes arch_prepare_kprobe(struct kprobe *p)
return -ENOMEM; return -ENOMEM;
for (is = 0; is < MAX_INSN_SIZE; ++is) for (is = 0; is < MAX_INSN_SIZE; ++is)
p->ainsn.insn[is] = tmp_insn[is]; p->ainsn.insn[is] = tmp_insn[is];
flush_insns(&p->ainsn.insn, MAX_INSN_SIZE); flush_insns(p->ainsn.insn, MAX_INSN_SIZE);
break; break;
case INSN_GOOD_NO_SLOT: /* instruction doesn't need insn slot */ case INSN_GOOD_NO_SLOT: /* instruction doesn't need insn slot */

17
arch/arm/kernel/sys_arm.c
View file

@ -34,23 +34,6 @@ extern unsigned long do_mremap(unsigned long addr, unsigned long old_len,
unsigned long new_len, unsigned long flags, unsigned long new_len, unsigned long flags,
unsigned long new_addr); unsigned long new_addr);
/*
* sys_pipe() is the normal C calling standard for creating
* a pipe. It's not the way unix traditionally does this, though.
*/
asmlinkage int sys_pipe(unsigned long __user *fildes)
{
int fd[2];
int error;
error = do_pipe(fd);
if (!error) {
if (copy_to_user(fildes, fd, 2*sizeof(int)))
error = -EFAULT;
}
return error;
}
/* common code for old and new mmaps */ /* common code for old and new mmaps */
inline long do_mmap2( inline long do_mmap2(
unsigned long addr, unsigned long len, unsigned long addr, unsigned long len,

2
arch/arm/mach-at91/at91cap9_devices.c
View file

@ -246,7 +246,7 @@ void __init at91_add_device_mmc(short mmc_id, struct at91_mmc_data *data)
} }
mmc0_data = *data; mmc0_data = *data;
at91_clock_associate("mci0_clk", &at91cap9_mmc1_device.dev, "mci_clk"); at91_clock_associate("mci0_clk", &at91cap9_mmc0_device.dev, "mci_clk");
platform_device_register(&at91cap9_mmc0_device); platform_device_register(&at91cap9_mmc0_device);
} else { /* MCI1 */ } else { /* MCI1 */
/* CLK */ /* CLK */

4
arch/arm/mach-at91/at91sam9261_devices.c
View file

@ -544,10 +544,10 @@ void __init at91_add_device_lcdc(struct atmel_lcdfb_info *data)
struct resource *fb_res = &lcdc_resources[2]; struct resource *fb_res = &lcdc_resources[2];
size_t fb_len = fb_res->end - fb_res->start + 1; size_t fb_len = fb_res->end - fb_res->start + 1;
fb = ioremap_writecombine(fb_res->start, fb_len); fb = ioremap(fb_res->start, fb_len);
if (fb) { if (fb) {
memset(fb, 0, fb_len); memset(fb, 0, fb_len);
iounmap(fb, fb_len); iounmap(fb);
} }
} }
lcdc_data = *data; lcdc_data = *data;

2
arch/arm/mach-at91/at91sam9263_devices.c
View file

@ -308,7 +308,7 @@ void __init at91_add_device_mmc(short mmc_id, struct at91_mmc_data *data)
} }
mmc0_data = *data; mmc0_data = *data;
at91_clock_associate("mci0_clk", &at91sam9263_mmc1_device.dev, "mci_clk"); at91_clock_associate("mci0_clk", &at91sam9263_mmc0_device.dev, "mci_clk");
platform_device_register(&at91sam9263_mmc0_device); platform_device_register(&at91sam9263_mmc0_device);
} else { /* MCI1 */ } else { /* MCI1 */
/* CLK */ /* CLK */

21
arch/arm/mach-at91/at91sam9rl_devices.c
View file

@ -332,13 +332,6 @@ static struct resource lcdc_resources[] = {
.end = AT91SAM9RL_ID_LCDC, .end = AT91SAM9RL_ID_LCDC,
.flags = IORESOURCE_IRQ, .flags = IORESOURCE_IRQ,
}, },
#if defined(CONFIG_FB_INTSRAM)
[2] = {
.start = AT91SAM9RL_SRAM_BASE,
.end = AT91SAM9RL_SRAM_BASE + AT91SAM9RL_SRAM_SIZE - 1,
.flags = IORESOURCE_MEM,
},
#endif
}; };
static struct platform_device at91_lcdc_device = { static struct platform_device at91_lcdc_device = {
@ -381,20 +374,6 @@ void __init at91_add_device_lcdc(struct atmel_lcdfb_info *data)
at91_set_B_periph(AT91_PIN_PC24, 0); /* LCDD22 */ at91_set_B_periph(AT91_PIN_PC24, 0); /* LCDD22 */
at91_set_B_periph(AT91_PIN_PC25, 0); /* LCDD23 */ at91_set_B_periph(AT91_PIN_PC25, 0); /* LCDD23 */
#ifdef CONFIG_FB_INTSRAM
{
void __iomem *fb;
struct resource *fb_res = &lcdc_resources[2];
size_t fb_len = fb_res->end - fb_res->start + 1;
fb = ioremap_writecombine(fb_res->start, fb_len);
if (fb) {
memset(fb, 0, fb_len);
iounmap(fb, fb_len);
}
}
#endif
lcdc_data = *data; lcdc_data = *data;
platform_device_register(&at91_lcdc_device); platform_device_register(&at91_lcdc_device);
} }

3
arch/arm/mach-at91/board-csb337.c
View file

@ -79,8 +79,7 @@ static struct at91_udc_data __initdata csb337_udc_data = {
static struct i2c_board_info __initdata csb337_i2c_devices[] = { static struct i2c_board_info __initdata csb337_i2c_devices[] = {
{ {
I2C_BOARD_INFO("rtc-ds1307", 0x68), I2C_BOARD_INFO("ds1307", 0x68),
.type = "ds1307",
}, },
}; };

3
arch/arm/mach-at91/board-dk.c
View file

@ -132,8 +132,7 @@ static struct i2c_board_info __initdata dk_i2c_devices[] = {
I2C_BOARD_INFO("x9429", 0x28), I2C_BOARD_INFO("x9429", 0x28),
}, },
{ {
I2C_BOARD_INFO("at24c", 0x50), I2C_BOARD_INFO("24c1024", 0x50),
.type = "24c1024",
} }
}; };

3
arch/arm/mach-at91/board-eb9200.c
View file

@ -93,8 +93,7 @@ static struct at91_mmc_data __initdata eb9200_mmc_data = {
static struct i2c_board_info __initdata eb9200_i2c_devices[] = { static struct i2c_board_info __initdata eb9200_i2c_devices[] = {
{ {
I2C_BOARD_INFO("at24c", 0x50), I2C_BOARD_INFO("24c512", 0x50),
.type = "24c512",
}, },
}; };

14
arch/arm/mach-at91/pm.c
View file

@ -61,6 +61,15 @@ static inline void sdram_selfrefresh_enable(void)
#else #else
#include <asm/arch/at91sam9_sdramc.h> #include <asm/arch/at91sam9_sdramc.h>
#ifdef CONFIG_ARCH_AT91SAM9263
/*
* FIXME either or both the SDRAM controllers (EB0, EB1) might be in use;
* handle those cases both here and in the Suspend-To-RAM support.
*/
#define AT91_SDRAMC AT91_SDRAMC0
#warning Assuming EB1 SDRAM controller is *NOT* used
#endif
static u32 saved_lpr; static u32 saved_lpr;
static inline void sdram_selfrefresh_enable(void) static inline void sdram_selfrefresh_enable(void)
@ -75,11 +84,6 @@ static inline void sdram_selfrefresh_enable(void)
#define sdram_selfrefresh_disable() at91_sys_write(AT91_SDRAMC_LPR, saved_lpr) #define sdram_selfrefresh_disable() at91_sys_write(AT91_SDRAMC_LPR, saved_lpr)
/*
* FIXME: The AT91SAM9263 has a second EBI controller which may have
* additional SDRAM. pm_slowclock.S will require a similar fix.
*/
#endif #endif

6
arch/arm/mach-davinci/clock.c
View file

@ -311,11 +311,7 @@ static const struct file_operations proc_davinci_ck_operations = {
static int __init davinci_ck_proc_init(void) static int __init davinci_ck_proc_init(void)
{ {
struct proc_dir_entry *entry; proc_create("davinci_clocks", 0, NULL, &proc_davinci_ck_operations);
entry = create_proc_entry("davinci_clocks", 0, NULL);
if (entry)
entry->proc_fops = &proc_davinci_ck_operations;
return 0; return 0;
} }

2
arch/arm/mach-ep93xx/core.c
View file

@ -280,7 +280,7 @@ static int ep93xx_gpio_irq_type(unsigned int irq, unsigned int type)
const int port = gpio >> 3; const int port = gpio >> 3;
const int port_mask = 1 << (gpio & 7); const int port_mask = 1 << (gpio & 7);
gpio_direction_output(gpio, gpio_get_value(gpio)); gpio_direction_input(gpio);
switch (type) { switch (type) {
case IRQT_RISING: case IRQT_RISING:

3
arch/arm/mach-iop32x/em7210.c
View file

@ -50,8 +50,7 @@ static struct sys_timer em7210_timer = {
*/ */
static struct i2c_board_info __initdata em7210_i2c_devices[] = { static struct i2c_board_info __initdata em7210_i2c_devices[] = {
{ {
I2C_BOARD_INFO("rtc-rs5c372", 0x32), I2C_BOARD_INFO("rs5c372a", 0x32),
.type = "rs5c372a",
}, },
}; };

4
arch/arm/mach-iop32x/glantank.c
View file

@ -176,12 +176,10 @@ static struct f75375s_platform_data glantank_f75375s = {
static struct i2c_board_info __initdata glantank_i2c_devices[] = { static struct i2c_board_info __initdata glantank_i2c_devices[] = {
{ {
I2C_BOARD_INFO("rtc-rs5c372", 0x32), I2C_BOARD_INFO("rs5c372a", 0x32),
.type = "rs5c372a",
}, },
{ {
I2C_BOARD_INFO("f75375", 0x2e), I2C_BOARD_INFO("f75375", 0x2e),
.type = "f75375",
.platform_data = &glantank_f75375s, .platform_data = &glantank_f75375s,
}, },
}; };

4
arch/arm/mach-iop32x/n2100.c
View file

@ -208,12 +208,10 @@ static struct f75375s_platform_data n2100_f75375s = {
static struct i2c_board_info __initdata n2100_i2c_devices[] = { static struct i2c_board_info __initdata n2100_i2c_devices[] = {
{ {
I2C_BOARD_INFO("rtc-rs5c372", 0x32), I2C_BOARD_INFO("rs5c372b", 0x32),
.type = "rs5c372b",
}, },
{ {
I2C_BOARD_INFO("f75375", 0x2e), I2C_BOARD_INFO("f75375", 0x2e),
.type = "f75375",
.platform_data = &n2100_f75375s, .platform_data = &n2100_f75375s,
}, },
}; };

2
arch/arm/mach-ixp4xx/dsmg600-setup.c
View file

@ -65,7 +65,7 @@ static struct platform_device dsmg600_i2c_gpio = {
static struct i2c_board_info __initdata dsmg600_i2c_board_info [] = { static struct i2c_board_info __initdata dsmg600_i2c_board_info [] = {
{ {
I2C_BOARD_INFO("rtc-pcf8563", 0x51), I2C_BOARD_INFO("pcf8563", 0x51),
}, },
}; };

4
arch/arm/mach-ixp4xx/ixp4xx_npe.c
View file

@ -448,7 +448,9 @@ int npe_send_message(struct npe *npe, const void *msg, const char *what)
return -ETIMEDOUT; return -ETIMEDOUT;
} }
#if DEBUG_MSG > 1
debug_msg(npe, "Sending a message took %i cycles\n", cycles); debug_msg(npe, "Sending a message took %i cycles\n", cycles);
#endif
return 0; return 0;
} }
@ -484,7 +486,9 @@ int npe_recv_message(struct npe *npe, void *msg, const char *what)
return -ETIMEDOUT; return -ETIMEDOUT;
} }
#if DEBUG_MSG > 1
debug_msg(npe, "Receiving a message took %i cycles\n", cycles); debug_msg(npe, "Receiving a message took %i cycles\n", cycles);
#endif
return 0; return 0;
} }

2
arch/arm/mach-ixp4xx/ixp4xx_qmgr.c
View file

@ -184,6 +184,8 @@ void qmgr_release_queue(unsigned int queue)
case 3: mask[0] = 0xFF; break; case 3: mask[0] = 0xFF; break;
} }
mask[1] = mask[2] = mask[3] = 0;
while (addr--) while (addr--)
shift_mask(mask); shift_mask(mask);

2
arch/arm/mach-ixp4xx/nas100d-setup.c
View file

@ -54,7 +54,7 @@ static struct platform_device nas100d_flash = {
static struct i2c_board_info __initdata nas100d_i2c_board_info [] = { static struct i2c_board_info __initdata nas100d_i2c_board_info [] = {
{ {
I2C_BOARD_INFO("rtc-pcf8563", 0x51), I2C_BOARD_INFO("pcf8563", 0x51),
}, },
}; };

2
arch/arm/mach-ixp4xx/nslu2-setup.c
View file

@ -57,7 +57,7 @@ static struct i2c_gpio_platform_data nslu2_i2c_gpio_data = {
static struct i2c_board_info __initdata nslu2_i2c_board_info [] = { static struct i2c_board_info __initdata nslu2_i2c_board_info [] = {
{ {
I2C_BOARD_INFO("rtc-x1205", 0x6f), I2C_BOARD_INFO("x1205", 0x6f),
}, },
}; };

22
arch/arm/mach-ns9xxx/irq.c
View file

@ -62,7 +62,7 @@ static struct irq_chip ns9xxx_chip = {
#if 0 #if 0
#define handle_irq handle_level_irq #define handle_irq handle_level_irq
#else #else
void handle_prio_irq(unsigned int irq, struct irq_desc *desc) static void handle_prio_irq(unsigned int irq, struct irq_desc *desc)
{ {
unsigned int cpu = smp_processor_id(); unsigned int cpu = smp_processor_id();
struct irqaction *action; struct irqaction *action;
@ -70,27 +70,35 @@ void handle_prio_irq(unsigned int irq, struct irq_desc *desc)
spin_lock(&desc->lock); spin_lock(&desc->lock);
if (unlikely(desc->status & IRQ_INPROGRESS)) BUG_ON(desc->status & IRQ_INPROGRESS);
goto out_unlock;
desc->status &= ~(IRQ_REPLAY | IRQ_WAITING); desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
kstat_cpu(cpu).irqs[irq]++; kstat_cpu(cpu).irqs[irq]++;
action = desc->action; action = desc->action;
if (unlikely(!action || (desc->status & IRQ_DISABLED))) if (unlikely(!action || (desc->status & IRQ_DISABLED)))
goto out_unlock; goto out_mask;
desc->status |= IRQ_INPROGRESS; desc->status |= IRQ_INPROGRESS;
spin_unlock(&desc->lock); spin_unlock(&desc->lock);
action_ret = handle_IRQ_event(irq, action); action_ret = handle_IRQ_event(irq, action);
/* XXX: There is no direct way to access noirqdebug, so check
* unconditionally for spurious irqs...
* Maybe this function should go to kernel/irq/chip.c? */
note_interrupt(irq, desc, action_ret);
spin_lock(&desc->lock); spin_lock(&desc->lock);
desc->status &= ~IRQ_INPROGRESS; desc->status &= ~IRQ_INPROGRESS;
if (!(desc->status & IRQ_DISABLED) && desc->chip->ack)
desc->chip->ack(irq);
out_unlock: if (desc->status & IRQ_DISABLED)
out_mask:
desc->chip->mask(irq);
/* ack unconditionally to unmask lower prio irqs */
desc->chip->ack(irq);
spin_unlock(&desc->lock); spin_unlock(&desc->lock);
} }
#define handle_irq handle_prio_irq #define handle_irq handle_prio_irq

2
arch/arm/mach-omap1/board-h2.c
View file

@ -351,11 +351,9 @@ static void __init h2_init_smc91x(void)
static struct i2c_board_info __initdata h2_i2c_board_info[] = { static struct i2c_board_info __initdata h2_i2c_board_info[] = {
{ {
I2C_BOARD_INFO("tps65010", 0x48), I2C_BOARD_INFO("tps65010", 0x48),
.type = "tps65010",
.irq = OMAP_GPIO_IRQ(58), .irq = OMAP_GPIO_IRQ(58),
}, { }, {
I2C_BOARD_INFO("isp1301_omap", 0x2d), I2C_BOARD_INFO("isp1301_omap", 0x2d),
.type = "isp1301_omap",
.irq = OMAP_GPIO_IRQ(2), .irq = OMAP_GPIO_IRQ(2),
}, },
}; };

3
arch/arm/mach-omap1/board-h3.c
View file

@ -473,8 +473,7 @@ static struct omap_board_config_kernel h3_config[] __initdata = {
static struct i2c_board_info __initdata h3_i2c_board_info[] = { static struct i2c_board_info __initdata h3_i2c_board_info[] = {
{ {
I2C_BOARD_INFO("tps65010", 0x48), I2C_BOARD_INFO("tps65013", 0x48),
.type = "tps65013",
/* .irq = OMAP_GPIO_IRQ(??), */ /* .irq = OMAP_GPIO_IRQ(??), */
}, },
}; };

1
arch/arm/mach-omap1/board-osk.c
View file

@ -254,7 +254,6 @@ static struct tps65010_board tps_board = {
static struct i2c_board_info __initdata osk_i2c_board_info[] = { static struct i2c_board_info __initdata osk_i2c_board_info[] = {
{ {
I2C_BOARD_INFO("tps65010", 0x48), I2C_BOARD_INFO("tps65010", 0x48),
.type = "tps65010",
.irq = OMAP_GPIO_IRQ(OMAP_MPUIO(1)), .irq = OMAP_GPIO_IRQ(OMAP_MPUIO(1)),
.platform_data = &tps_board, .platform_data = &tps_board,

2
arch/arm/mach-omap1/board-palmte.c
View file

@ -63,7 +63,7 @@ static const int palmte_keymap[] = {
KEY(1, 1, KEY_DOWN), KEY(1, 1, KEY_DOWN),
KEY(1, 2, KEY_UP), KEY(1, 2, KEY_UP),
KEY(1, 3, KEY_RIGHT), KEY(1, 3, KEY_RIGHT),
KEY(1, 4, KEY_CENTER), KEY(1, 4, KEY_ENTER),
0, 0,
}; };

2
arch/arm/mach-omap1/board-palmz71.c
View file

@ -65,7 +65,7 @@ static int palmz71_keymap[] = {
KEY(1, 1, KEY_DOWN), KEY(1, 1, KEY_DOWN),
KEY(1, 2, KEY_UP), KEY(1, 2, KEY_UP),
KEY(1, 3, KEY_RIGHT), KEY(1, 3, KEY_RIGHT),
KEY(1, 4, KEY_CENTER), KEY(1, 4, KEY_ENTER),
KEY(2, 0, KEY_CAMERA), KEY(2, 0, KEY_CAMERA),
0, 0,
}; };

1
arch/arm/mach-omap2/board-2430sdp.c
View file

@ -208,6 +208,7 @@ static void __init omap_2430sdp_init(void)
static void __init omap_2430sdp_map_io(void) static void __init omap_2430sdp_map_io(void)
{ {
omap2_set_globals_243x();
omap2_map_common_io(); omap2_map_common_io();
} }

1
arch/arm/mach-omap2/board-apollon.c
View file

@ -394,6 +394,7 @@ static void __init omap_apollon_init(void)
static void __init omap_apollon_map_io(void) static void __init omap_apollon_map_io(void)
{ {
omap2_set_globals_242x();
omap2_map_common_io(); omap2_map_common_io();
} }

1
arch/arm/mach-omap2/board-generic.c
View file

@ -65,6 +65,7 @@ static void __init omap_generic_init(void)
static void __init omap_generic_map_io(void) static void __init omap_generic_map_io(void)
{ {
omap2_set_globals_242x(); /* should be 242x, 243x, or 343x */
omap2_map_common_io(); omap2_map_common_io();
} }

1
arch/arm/mach-omap2/board-h4.c
View file

@ -420,6 +420,7 @@ static void __init omap_h4_init(void)
static void __init omap_h4_map_io(void) static void __init omap_h4_map_io(void)
{ {
omap2_set_globals_242x();
omap2_map_common_io(); omap2_map_common_io();
} }

4
arch/arm/mach-omap2/clock.c
View file

@ -205,7 +205,9 @@ static void omap2_clk_wait_ready(struct clk *clk)
/* REVISIT: What are the appropriate exclusions for 34XX? */ /* REVISIT: What are the appropriate exclusions for 34XX? */
/* OMAP3: ignore DSS-mod clocks */ /* OMAP3: ignore DSS-mod clocks */
if (cpu_is_omap34xx() && if (cpu_is_omap34xx() &&
(((u32)reg & ~0xff) == (u32)OMAP_CM_REGADDR(OMAP3430_DSS_MOD, 0))) (((u32)reg & ~0xff) == (u32)OMAP_CM_REGADDR(OMAP3430_DSS_MOD, 0) ||
((((u32)reg & ~0xff) == (u32)OMAP_CM_REGADDR(CORE_MOD, 0)) &&
clk->enable_bit == OMAP3430_EN_SSI_SHIFT)))
return; return;
/* Check if both functional and interface clocks /* Check if both functional and interface clocks

21
arch/arm/mach-omap2/clock34xx.h
View file

@ -836,7 +836,8 @@ static struct clk dpll5_m2_ck = {
.clksel_reg = OMAP_CM_REGADDR(PLL_MOD, OMAP3430ES2_CM_CLKSEL5), .clksel_reg = OMAP_CM_REGADDR(PLL_MOD, OMAP3430ES2_CM_CLKSEL5),
.clksel_mask = OMAP3430ES2_DIV_120M_MASK, .clksel_mask = OMAP3430ES2_DIV_120M_MASK,
.clksel = div16_dpll5_clksel, .clksel = div16_dpll5_clksel,
.flags = CLOCK_IN_OMAP3430ES2 | RATE_PROPAGATES, .flags = CLOCK_IN_OMAP3430ES2 | RATE_PROPAGATES |
PARENT_CONTROLS_CLOCK,
.recalc = &omap2_clksel_recalc, .recalc = &omap2_clksel_recalc,
}; };
@ -1046,12 +1047,13 @@ static struct clk iva2_ck = {
.name = "iva2_ck", .name = "iva2_ck",
.parent = &dpll2_m2_ck, .parent = &dpll2_m2_ck,
.init = &omap2_init_clksel_parent, .init = &omap2_init_clksel_parent,
.enable_reg = OMAP_CM_REGADDR(OMAP3430_IVA2_MOD, CM_FCLKEN),
.enable_bit = OMAP3430_CM_FCLKEN_IVA2_EN_IVA2_SHIFT,
.clksel_reg = OMAP_CM_REGADDR(OMAP3430_IVA2_MOD, .clksel_reg = OMAP_CM_REGADDR(OMAP3430_IVA2_MOD,
OMAP3430_CM_IDLEST_PLL), OMAP3430_CM_IDLEST_PLL),
.clksel_mask = OMAP3430_ST_IVA2_CLK_MASK, .clksel_mask = OMAP3430_ST_IVA2_CLK_MASK,
.clksel = iva2_clksel, .clksel = iva2_clksel,
.flags = CLOCK_IN_OMAP343X | RATE_PROPAGATES | .flags = CLOCK_IN_OMAP343X | RATE_PROPAGATES,
PARENT_CONTROLS_CLOCK,
.recalc = &omap2_clksel_recalc, .recalc = &omap2_clksel_recalc,
}; };
@ -1836,7 +1838,8 @@ static struct clk omapctrl_ick = {
static struct clk ssi_l4_ick = { static struct clk ssi_l4_ick = {
.name = "ssi_l4_ick", .name = "ssi_l4_ick",
.parent = &l4_ick, .parent = &l4_ick,
.flags = CLOCK_IN_OMAP343X | RATE_PROPAGATES, .flags = CLOCK_IN_OMAP343X | RATE_PROPAGATES |
PARENT_CONTROLS_CLOCK,
.recalc = &followparent_recalc, .recalc = &followparent_recalc,
}; };
@ -2344,7 +2347,7 @@ static struct clk gpio6_fck = {
.name = "gpio6_fck", .name = "gpio6_fck",
.parent = &per_32k_alwon_fck, .parent = &per_32k_alwon_fck,
.enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN), .enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN),
.enable_bit = OMAP3430_EN_GPT6_SHIFT, .enable_bit = OMAP3430_EN_GPIO6_SHIFT,
.flags = CLOCK_IN_OMAP343X, .flags = CLOCK_IN_OMAP343X,
.recalc = &followparent_recalc, .recalc = &followparent_recalc,
}; };
@ -2353,7 +2356,7 @@ static struct clk gpio5_fck = {
.name = "gpio5_fck", .name = "gpio5_fck",
.parent = &per_32k_alwon_fck, .parent = &per_32k_alwon_fck,
.enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN), .enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN),
.enable_bit = OMAP3430_EN_GPT5_SHIFT, .enable_bit = OMAP3430_EN_GPIO5_SHIFT,
.flags = CLOCK_IN_OMAP343X, .flags = CLOCK_IN_OMAP343X,
.recalc = &followparent_recalc, .recalc = &followparent_recalc,
}; };
@ -2362,7 +2365,7 @@ static struct clk gpio4_fck = {
.name = "gpio4_fck", .name = "gpio4_fck",
.parent = &per_32k_alwon_fck, .parent = &per_32k_alwon_fck,
.enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN), .enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN),
.enable_bit = OMAP3430_EN_GPT4_SHIFT, .enable_bit = OMAP3430_EN_GPIO4_SHIFT,
.flags = CLOCK_IN_OMAP343X, .flags = CLOCK_IN_OMAP343X,
.recalc = &followparent_recalc, .recalc = &followparent_recalc,
}; };
@ -2371,7 +2374,7 @@ static struct clk gpio3_fck = {
.name = "gpio3_fck", .name = "gpio3_fck",
.parent = &per_32k_alwon_fck, .parent = &per_32k_alwon_fck,
.enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN), .enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN),
.enable_bit = OMAP3430_EN_GPT3_SHIFT, .enable_bit = OMAP3430_EN_GPIO3_SHIFT,
.flags = CLOCK_IN_OMAP343X, .flags = CLOCK_IN_OMAP343X,
.recalc = &followparent_recalc, .recalc = &followparent_recalc,
}; };
@ -2380,7 +2383,7 @@ static struct clk gpio2_fck = {
.name = "gpio2_fck", .name = "gpio2_fck",
.parent = &per_32k_alwon_fck, .parent = &per_32k_alwon_fck,
.enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN), .enable_reg = OMAP_CM_REGADDR(OMAP3430_PER_MOD, CM_FCLKEN),
.enable_bit = OMAP3430_EN_GPT2_SHIFT, .enable_bit = OMAP3430_EN_GPIO2_SHIFT,
.flags = CLOCK_IN_OMAP343X, .flags = CLOCK_IN_OMAP343X,
.recalc = &followparent_recalc, .recalc = &followparent_recalc,
}; };

1
arch/arm/mach-omap2/cm-regbits-34xx.h
View file

@ -56,6 +56,7 @@
/* CM_FCLKEN_IVA2 */ /* CM_FCLKEN_IVA2 */
#define OMAP3430_CM_FCLKEN_IVA2_EN_IVA2 (1 << 0) #define OMAP3430_CM_FCLKEN_IVA2_EN_IVA2 (1 << 0)
#define OMAP3430_CM_FCLKEN_IVA2_EN_IVA2_SHIFT 0
/* CM_CLKEN_PLL_IVA2 */ /* CM_CLKEN_PLL_IVA2 */
#define OMAP3430_IVA2_DPLL_RAMPTIME_SHIFT 8 #define OMAP3430_IVA2_DPLL_RAMPTIME_SHIFT 8

25
arch/arm/mach-omap2/mailbox.c
View file

@ -70,6 +70,9 @@ struct omap_mbox2_priv {
static struct clk *mbox_ick_handle; static struct clk *mbox_ick_handle;
static void omap2_mbox_enable_irq(struct omap_mbox *mbox,
omap_mbox_type_t irq);
static inline unsigned int mbox_read_reg(unsigned int reg) static inline unsigned int mbox_read_reg(unsigned int reg)
{ {
return __raw_readl(mbox_base + reg); return __raw_readl(mbox_base + reg);
@ -81,7 +84,7 @@ static inline void mbox_write_reg(unsigned int val, unsigned int reg)
} }
/* Mailbox H/W preparations */ /* Mailbox H/W preparations */
static inline int omap2_mbox_startup(struct omap_mbox *mbox) static int omap2_mbox_startup(struct omap_mbox *mbox)
{ {
unsigned int l; unsigned int l;
@ -97,38 +100,40 @@ static inline int omap2_mbox_startup(struct omap_mbox *mbox)
l |= 0x00000011; l |= 0x00000011;
mbox_write_reg(l, MAILBOX_SYSCONFIG); mbox_write_reg(l, MAILBOX_SYSCONFIG);
omap2_mbox_enable_irq(mbox, IRQ_RX);
return 0; return 0;
} }
static inline void omap2_mbox_shutdown(struct omap_mbox *mbox) static void omap2_mbox_shutdown(struct omap_mbox *mbox)
{ {
clk_disable(mbox_ick_handle); clk_disable(mbox_ick_handle);
clk_put(mbox_ick_handle); clk_put(mbox_ick_handle);
} }
/* Mailbox FIFO handle functions */ /* Mailbox FIFO handle functions */
static inline mbox_msg_t omap2_mbox_fifo_read(struct omap_mbox *mbox) static mbox_msg_t omap2_mbox_fifo_read(struct omap_mbox *mbox)
{ {
struct omap_mbox2_fifo *fifo = struct omap_mbox2_fifo *fifo =
&((struct omap_mbox2_priv *)mbox->priv)->rx_fifo; &((struct omap_mbox2_priv *)mbox->priv)->rx_fifo;
return (mbox_msg_t) mbox_read_reg(fifo->msg); return (mbox_msg_t) mbox_read_reg(fifo->msg);
} }
static inline void omap2_mbox_fifo_write(struct omap_mbox *mbox, mbox_msg_t msg) static void omap2_mbox_fifo_write(struct omap_mbox *mbox, mbox_msg_t msg)
{ {
struct omap_mbox2_fifo *fifo = struct omap_mbox2_fifo *fifo =
&((struct omap_mbox2_priv *)mbox->priv)->tx_fifo; &((struct omap_mbox2_priv *)mbox->priv)->tx_fifo;
mbox_write_reg(msg, fifo->msg); mbox_write_reg(msg, fifo->msg);
} }
static inline int omap2_mbox_fifo_empty(struct omap_mbox *mbox) static int omap2_mbox_fifo_empty(struct omap_mbox *mbox)
{ {
struct omap_mbox2_fifo *fifo = struct omap_mbox2_fifo *fifo =
&((struct omap_mbox2_priv *)mbox->priv)->rx_fifo; &((struct omap_mbox2_priv *)mbox->priv)->rx_fifo;
return (mbox_read_reg(fifo->msg_stat) == 0); return (mbox_read_reg(fifo->msg_stat) == 0);
} }
static inline int omap2_mbox_fifo_full(struct omap_mbox *mbox) static int omap2_mbox_fifo_full(struct omap_mbox *mbox)
{ {
struct omap_mbox2_fifo *fifo = struct omap_mbox2_fifo *fifo =
&((struct omap_mbox2_priv *)mbox->priv)->tx_fifo; &((struct omap_mbox2_priv *)mbox->priv)->tx_fifo;
@ -136,7 +141,7 @@ static inline int omap2_mbox_fifo_full(struct omap_mbox *mbox)
} }
/* Mailbox IRQ handle functions */ /* Mailbox IRQ handle functions */
static inline void omap2_mbox_enable_irq(struct omap_mbox *mbox, static void omap2_mbox_enable_irq(struct omap_mbox *mbox,
omap_mbox_type_t irq) omap_mbox_type_t irq)
{ {
struct omap_mbox2_priv *p = (struct omap_mbox2_priv *)mbox->priv; struct omap_mbox2_priv *p = (struct omap_mbox2_priv *)mbox->priv;
@ -147,7 +152,7 @@ static inline void omap2_mbox_enable_irq(struct omap_mbox *mbox,
mbox_write_reg(l, p->irqenable); mbox_write_reg(l, p->irqenable);
} }
static inline void omap2_mbox_disable_irq(struct omap_mbox *mbox, static void omap2_mbox_disable_irq(struct omap_mbox *mbox,
omap_mbox_type_t irq) omap_mbox_type_t irq)
{ {
struct omap_mbox2_priv *p = (struct omap_mbox2_priv *)mbox->priv; struct omap_mbox2_priv *p = (struct omap_mbox2_priv *)mbox->priv;
@ -158,7 +163,7 @@ static inline void omap2_mbox_disable_irq(struct omap_mbox *mbox,
mbox_write_reg(l, p->irqenable); mbox_write_reg(l, p->irqenable);
} }
static inline void omap2_mbox_ack_irq(struct omap_mbox *mbox, static void omap2_mbox_ack_irq(struct omap_mbox *mbox,
omap_mbox_type_t irq) omap_mbox_type_t irq)
{ {
struct omap_mbox2_priv *p = (struct omap_mbox2_priv *)mbox->priv; struct omap_mbox2_priv *p = (struct omap_mbox2_priv *)mbox->priv;
@ -167,7 +172,7 @@ static inline void omap2_mbox_ack_irq(struct omap_mbox *mbox,
mbox_write_reg(bit, p->irqstatus); mbox_write_reg(bit, p->irqstatus);
} }
static inline int omap2_mbox_is_irq(struct omap_mbox *mbox, static int omap2_mbox_is_irq(struct omap_mbox *mbox,
omap_mbox_type_t irq) omap_mbox_type_t irq)
{ {
struct omap_mbox2_priv *p = (struct omap_mbox2_priv *)mbox->priv; struct omap_mbox2_priv *p = (struct omap_mbox2_priv *)mbox->priv;

2
arch/arm/mach-omap2/prm.h
View file

@ -30,7 +30,7 @@
/* /*
* Architecture-specific global PRM registers * Architecture-specific global PRM registers
* Use prm_{read,write}_reg() with these registers. * Use __raw_{read,write}l() with these registers.
* *
* With a few exceptions, these are the register names beginning with * With a few exceptions, these are the register names beginning with
* PRCM_* on 24xx, and PRM_* on 34xx. (The exceptions are the * PRCM_* on 24xx, and PRM_* on 34xx. (The exceptions are the

70
arch/arm/mach-orion5x/addr-map.c
View file

@ -19,14 +19,14 @@
/* /*
* The Orion has fully programable address map. There's a separate address * The Orion has fully programable address map. There's a separate address
* map for each of the device _master_ interfaces, e.g. CPU, PCI, PCIE, USB, * map for each of the device _master_ interfaces, e.g. CPU, PCI, PCIe, USB,
* Gigabit Ethernet, DMA/XOR engines, etc. Each interface has its own * Gigabit Ethernet, DMA/XOR engines, etc. Each interface has its own
* address decode windows that allow it to access any of the Orion resources. * address decode windows that allow it to access any of the Orion resources.
* *
* CPU address decoding -- * CPU address decoding --
* Linux assumes that it is the boot loader that already setup the access to * Linux assumes that it is the boot loader that already setup the access to
* DDR and internal registers. * DDR and internal registers.
* Setup access to PCI and PCI-E IO/MEM space is issued by this file. * Setup access to PCI and PCIe IO/MEM space is issued by this file.
* Setup access to various devices located on the device bus interface (e.g. * Setup access to various devices located on the device bus interface (e.g.
* flashes, RTC, etc) should be issued by machine-setup.c according to * flashes, RTC, etc) should be issued by machine-setup.c according to
* specific board population (by using orion5x_setup_*_win()). * specific board population (by using orion5x_setup_*_win()).
@ -34,11 +34,7 @@
* Non-CPU Masters address decoding -- * Non-CPU Masters address decoding --
* Unlike the CPU, we setup the access from Orion's master interfaces to DDR * Unlike the CPU, we setup the access from Orion's master interfaces to DDR
* banks only (the typical use case). * banks only (the typical use case).
* Setup access for each master to DDR is issued by common.c. * Setup access for each master to DDR is issued by platform device setup.
*
* Note: although orion_setbits() and orion_clrbits() are not atomic
* no locking is necessary here since code in this file is only called
* at boot time when there is no concurrency issues.
*/ */
/* /*
@ -48,10 +44,6 @@
#define TARGET_DEV_BUS 1 #define TARGET_DEV_BUS 1
#define TARGET_PCI 3 #define TARGET_PCI 3
#define TARGET_PCIE 4 #define TARGET_PCIE 4
#define ATTR_DDR_CS(n) (((n) ==0) ? 0xe : \
((n) == 1) ? 0xd : \
((n) == 2) ? 0xb : \
((n) == 3) ? 0x7 : 0xf)
#define ATTR_PCIE_MEM 0x59 #define ATTR_PCIE_MEM 0x59
#define ATTR_PCIE_IO 0x51 #define ATTR_PCIE_IO 0x51
#define ATTR_PCIE_WA 0x79 #define ATTR_PCIE_WA 0x79
@ -61,17 +53,12 @@
#define ATTR_DEV_CS1 0x1d #define ATTR_DEV_CS1 0x1d
#define ATTR_DEV_CS2 0x1b #define ATTR_DEV_CS2 0x1b
#define ATTR_DEV_BOOT 0xf #define ATTR_DEV_BOOT 0xf
#define WIN_EN 1
/* /*
* Helpers to get DDR bank info * Helpers to get DDR bank info
*/ */
#define DDR_BASE_CS(n) ORION5X_DDR_REG(0x1500 + ((n) * 8)) #define DDR_BASE_CS(n) ORION5X_DDR_REG(0x1500 + ((n) << 3))
#define DDR_SIZE_CS(n) ORION5X_DDR_REG(0x1504 + ((n) * 8)) #define DDR_SIZE_CS(n) ORION5X_DDR_REG(0x1504 + ((n) << 3))
#define DDR_MAX_CS 4
#define DDR_REG_TO_SIZE(reg) (((reg) | 0xffffff) + 1)
#define DDR_REG_TO_BASE(reg) ((reg) & 0xff000000)
#define DDR_BANK_EN 1
/* /*
* CPU Address Decode Windows registers * CPU Address Decode Windows registers
@ -81,17 +68,6 @@
#define CPU_WIN_REMAP_LO(n) ORION5X_BRIDGE_REG(0x008 | ((n) << 4)) #define CPU_WIN_REMAP_LO(n) ORION5X_BRIDGE_REG(0x008 | ((n) << 4))
#define CPU_WIN_REMAP_HI(n) ORION5X_BRIDGE_REG(0x00c | ((n) << 4)) #define CPU_WIN_REMAP_HI(n) ORION5X_BRIDGE_REG(0x00c | ((n) << 4))
/*
* Gigabit Ethernet Address Decode Windows registers
*/
#define ETH_WIN_BASE(win) ORION5X_ETH_REG(0x200 + ((win) * 8))
#define ETH_WIN_SIZE(win) ORION5X_ETH_REG(0x204 + ((win) * 8))
#define ETH_WIN_REMAP(win) ORION5X_ETH_REG(0x280 + ((win) * 4))
#define ETH_WIN_EN ORION5X_ETH_REG(0x290)
#define ETH_WIN_PROT ORION5X_ETH_REG(0x294)
#define ETH_MAX_WIN 6
#define ETH_MAX_REMAP_WIN 4
struct mbus_dram_target_info orion5x_mbus_dram_info; struct mbus_dram_target_info orion5x_mbus_dram_info;
@ -202,39 +178,3 @@ void __init orion5x_setup_pcie_wa_win(u32 base, u32 size)
{ {
setup_cpu_win(7, base, size, TARGET_PCIE, ATTR_PCIE_WA, -1); setup_cpu_win(7, base, size, TARGET_PCIE, ATTR_PCIE_WA, -1);
} }
void __init orion5x_setup_eth_wins(void)
{
int i;
/*
* First, disable and clear windows
*/
for (i = 0; i < ETH_MAX_WIN; i++) {
orion5x_write(ETH_WIN_BASE(i), 0);
orion5x_write(ETH_WIN_SIZE(i), 0);
orion5x_setbits(ETH_WIN_EN, 1 << i);
orion5x_clrbits(ETH_WIN_PROT, 0x3 << (i * 2));
if (i < ETH_MAX_REMAP_WIN)
orion5x_write(ETH_WIN_REMAP(i), 0);
}
/*
* Setup windows for DDR banks.
*/
for (i = 0; i < DDR_MAX_CS; i++) {
u32 base, size;
size = orion5x_read(DDR_SIZE_CS(i));
base = orion5x_read(DDR_BASE_CS(i));
if (size & DDR_BANK_EN) {
base = DDR_REG_TO_BASE(base);
size = DDR_REG_TO_SIZE(size);
orion5x_write(ETH_WIN_SIZE(i), (size-1) & 0xffff0000);
orion5x_write(ETH_WIN_BASE(i), (base & 0xffff0000) |
(ATTR_DDR_CS(i) << 8) |
TARGET_DDR);
orion5x_clrbits(ETH_WIN_EN, 1 << i);
orion5x_setbits(ETH_WIN_PROT, 0x3 << (i * 2));
}
}
}

17
arch/arm/mach-orion5x/common.c
View file

@ -132,7 +132,7 @@ static struct platform_device orion5x_uart = {
static struct resource orion5x_ehci0_resources[] = { static struct resource orion5x_ehci0_resources[] = {
{ {
.start = ORION5X_USB0_PHYS_BASE, .start = ORION5X_USB0_PHYS_BASE,
.end = ORION5X_USB0_PHYS_BASE + SZ_4K, .end = ORION5X_USB0_PHYS_BASE + SZ_4K - 1,
.flags = IORESOURCE_MEM, .flags = IORESOURCE_MEM,
}, },
{ {
@ -145,7 +145,7 @@ static struct resource orion5x_ehci0_resources[] = {
static struct resource orion5x_ehci1_resources[] = { static struct resource orion5x_ehci1_resources[] = {
{ {
.start = ORION5X_USB1_PHYS_BASE, .start = ORION5X_USB1_PHYS_BASE,
.end = ORION5X_USB1_PHYS_BASE + SZ_4K, .end = ORION5X_USB1_PHYS_BASE + SZ_4K - 1,
.flags = IORESOURCE_MEM, .flags = IORESOURCE_MEM,
}, },
{ {
@ -190,6 +190,11 @@ static struct platform_device orion5x_ehci1 = {
* (The Orion and Discovery (MV643xx) families use the same Ethernet driver) * (The Orion and Discovery (MV643xx) families use the same Ethernet driver)
****************************************************************************/ ****************************************************************************/
struct mv643xx_eth_shared_platform_data orion5x_eth_shared_data = {
.dram = &orion5x_mbus_dram_info,
.t_clk = ORION5X_TCLK,
};
static struct resource orion5x_eth_shared_resources[] = { static struct resource orion5x_eth_shared_resources[] = {
{ {
.start = ORION5X_ETH_PHYS_BASE + 0x2000, .start = ORION5X_ETH_PHYS_BASE + 0x2000,
@ -201,6 +206,9 @@ static struct resource orion5x_eth_shared_resources[] = {
static struct platform_device orion5x_eth_shared = { static struct platform_device orion5x_eth_shared = {
.name = MV643XX_ETH_SHARED_NAME, .name = MV643XX_ETH_SHARED_NAME,
.id = 0, .id = 0,
.dev = {
.platform_data = &orion5x_eth_shared_data,
},
.num_resources = 1, .num_resources = 1,
.resource = orion5x_eth_shared_resources, .resource = orion5x_eth_shared_resources,
}; };
@ -223,7 +231,9 @@ static struct platform_device orion5x_eth = {
void __init orion5x_eth_init(struct mv643xx_eth_platform_data *eth_data) void __init orion5x_eth_init(struct mv643xx_eth_platform_data *eth_data)
{ {
eth_data->shared = &orion5x_eth_shared;
orion5x_eth.dev.platform_data = eth_data; orion5x_eth.dev.platform_data = eth_data;
platform_device_register(&orion5x_eth_shared); platform_device_register(&orion5x_eth_shared);
platform_device_register(&orion5x_eth); platform_device_register(&orion5x_eth);
} }
@ -317,7 +327,7 @@ struct sys_timer orion5x_timer = {
****************************************************************************/ ****************************************************************************/
/* /*
* Identify device ID and rev from PCIE configuration header space '0'. * Identify device ID and rev from PCIe configuration header space '0'.
*/ */
static void __init orion5x_id(u32 *dev, u32 *rev, char **dev_name) static void __init orion5x_id(u32 *dev, u32 *rev, char **dev_name)
{ {
@ -360,7 +370,6 @@ void __init orion5x_init(void)
* Setup Orion address map * Setup Orion address map
*/ */
orion5x_setup_cpu_mbus_bridge(); orion5x_setup_cpu_mbus_bridge();
orion5x_setup_eth_wins();
/* /*
* Register devices. * Register devices.

4
arch/arm/mach-orion5x/common.h
View file

@ -22,7 +22,6 @@ void orion5x_setup_dev0_win(u32 base, u32 size);
void orion5x_setup_dev1_win(u32 base, u32 size); void orion5x_setup_dev1_win(u32 base, u32 size);
void orion5x_setup_dev2_win(u32 base, u32 size); void orion5x_setup_dev2_win(u32 base, u32 size);
void orion5x_setup_pcie_wa_win(u32 base, u32 size); void orion5x_setup_pcie_wa_win(u32 base, u32 size);
void orion5x_setup_eth_wins(void);
/* /*
* Shared code used internally by other Orion core functions. * Shared code used internally by other Orion core functions.
@ -33,10 +32,9 @@ struct pci_sys_data;
struct pci_bus; struct pci_bus;
void orion5x_pcie_id(u32 *dev, u32 *rev); void orion5x_pcie_id(u32 *dev, u32 *rev);
int orion5x_pcie_local_bus_nr(void);
int orion5x_pci_local_bus_nr(void);
int orion5x_pci_sys_setup(int nr, struct pci_sys_data *sys); int orion5x_pci_sys_setup(int nr, struct pci_sys_data *sys);
struct pci_bus *orion5x_pci_sys_scan_bus(int nr, struct pci_sys_data *sys); struct pci_bus *orion5x_pci_sys_scan_bus(int nr, struct pci_sys_data *sys);
int orion5x_pci_map_irq(struct pci_dev *dev, u8 slot, u8 pin);
/* /*
* Valid GPIO pins according to MPP setup, used by machine-setup. * Valid GPIO pins according to MPP setup, used by machine-setup.

19
arch/arm/mach-orion5x/db88f5281-setup.c
View file

@ -241,14 +241,17 @@ void __init db88f5281_pci_preinit(void)
static int __init db88f5281_pci_map_irq(struct pci_dev *dev, u8 slot, u8 pin) static int __init db88f5281_pci_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
{ {
/* int irq;
* PCIE IRQ is connected internally (not GPIO)
*/
if (dev->bus->number == orion5x_pcie_local_bus_nr())
return IRQ_ORION5X_PCIE0_INT;
/* /*
* PCI IRQs are connected via GPIOs * Check for devices with hard-wired IRQs.
*/
irq = orion5x_pci_map_irq(dev, slot, pin);
if (irq != -1)
return irq;
/*
* PCI IRQs are connected via GPIOs.
*/ */
switch (slot - DB88F5281_PCI_SLOT0_OFFS) { switch (slot - DB88F5281_PCI_SLOT0_OFFS) {
case 0: case 0:
@ -292,9 +295,7 @@ static struct mv643xx_eth_platform_data db88f5281_eth_data = {
* RTC DS1339 on I2C bus * RTC DS1339 on I2C bus
****************************************************************************/ ****************************************************************************/
static struct i2c_board_info __initdata db88f5281_i2c_rtc = { static struct i2c_board_info __initdata db88f5281_i2c_rtc = {
.driver_name = "rtc-ds1307", I2C_BOARD_INFO("ds1339", 0x68),
.type = "ds1339",
.addr = 0x68,
}; };
/***************************************************************************** /*****************************************************************************

Some files were not shown because too many files have changed in this diff Show more