If two processes are waiting in rtc_read(), only one will get the data.  The
other will madly spin around theloop in state TASK_RUNNING until another
interrupt happens.

Fix it by resetting TASK_INTERRUPTIBLE _inside_ the retry loop.

From: Andi Kleen <ak@suse.de>

This makes the 2.5 kernel with common ioctl32 code compile with DRM enabled
again.  The DRM code in the kernel is obsolete anyways and has been long
removed.  It definitely does not belong in the common ioctl emulation
layer.

Egbert Eich is working on proper 32bit DRM emulation, but it will be likely
directly integrated in the DRI/DRM sources.

for the default "pci_domain_nr()" definition. The inline function
will evaluate the argument.

Milton Miller noticed a free-after-use problem in the cleanup path of a
failed module load.

The problem is that mod is moved to point from the sucked-in file
(always freed last) to the module core, after which time the
"free(mod->core), reference mod->percpu" sequence is bogus, eg.  when
the module_init function fails.

This is fixed by keeping the pointer in a local variable, which solves
the problem. We no longer need to reference the free'd data structure.

This should fix most (all??) of the recently reported problems with MD:

Recent changes to md malloced some data structures differently and
didn't zero out those data structures, where the old code had zeroed it
out.

This adds the relevant memsets.

into home.transmeta.com:/home/torvalds/v2.5/linux

into home.transmeta.com:/home/torvalds/v2.5/linux

into kroah.com:/home/greg/linux/BK/pci-2.5

so hackish.

into home.transmeta.com:/home/torvalds/v2.5/linux

into kroah.com:/home/greg/linux/BK/gregkh-2.5

so that __d_drop() can safely be done multiple times on
a dentry without corrupting other hash entries.

Noticed by Trond Myklebust.

list pointers to give us a nice oops if somebody is doing something
bad.

Also introduce hlist_del_rcu_init() - same as hlist_del_init().

The endpoint disable() change resolved the bug
identified by the FIXME ... this updates the comment.

The main thing this fixes is making the control-OUT path work.
Drivers like RNDIS and DFU need it; this should resolve one
bug report.  It also has some minor cleanups.

Rather than just saying that USBDEVFS_CONTROL failed,
say also which process it failed for ... so it's easier
to figure out what's happen.

This patch makes the hub status irq DMA-aware, by pre-allocating the
transfer buffer in consistent memory.  Unfortunately, there doesn't seem
to be an easy way to do the same for the status report buffers.

This patch removes the code that faked the EVPD INQUIRY.  The SCSI core no
longer does that, so there is no need to filter it.

This patch re-organizes probe and disconnect into smaller functions (which
are all functionally equivalent to the current code).  This allows easier
verification that the code is correct, and will make for easier
implementation of the proper SCSI shutdown code.

This patch introduces some handling for babble conditions.

Basically, once a babble is detected, we return sense data saying the
command was invalid.  We also go on to transfer the CSW (for BBB transport)
so we stay in phase with the device.

This isn't guaranteed to work with every device that babbles, but it can't
hurt compared to the current behavior.  Properly operating devices are
unaffected by this patch.

- Remove explicit call from arm PM sequence, as its handled implicitly 
  by sysdev_restore() in driver model core.

Patch originally from Nigel Cunningham and Pavel Machek. Cleaned up and 
converted to new system device API by your truly.

It turns out that at least some system device drivers need to allocate 
memory and/or sleep for one reason or another when either saving or 
restoring state. 

Instead of adding a 'level' paramter to the suspend() and resume() methods,
which I despise and think is a horrible programming interface, two new 
methods have been added to struct sysdev_driver:

        int     (*save)(struct sys_device *, u32 state);
        int     (*restore)(struct sys_device *);

that are called explicitly before and after suspend() and resume() 
respectively, with interrupts enabled. This gives the drivers the
flexibility to allocate memory and sleep, if necessary.