After the interrupt queueing was added, I don't think the old way of
resetting interrupts will work anymore.  This patch changes it to simply
do a full unlink and resubmission automatically.  Note that since
usb_hcd_giveback_urb() is never called for a resubmitting interrupt URB,
that means whatever gets released in usb_hcd_giveback_urb() won't get
released for that URB.  The only way to work around that is call
usb_hcd_giveback_urb after the user unlinks in their completion handler,
which will call the completion handler again with -ECONNRESET
status...which wouldn't be all that bad, but the drivers have to expect
it.

Hopefully the interrupt resubmission will go away soon...

This fixes a potential oops (depending on how the HCD handles it)
from a recent patch of mine.  Evidently I didn't test this bit a
device that'd show the problem, sigh.  Luckily Martin Diehl was
testing and found this.

  o Add support for JTEC FA8101 USB to Ethernet device

The talk about disconnect locking reminded me of this - the error code in
the no-driver case for the disconnect ioctl isn't a unique error code.
This changes the error code to what getdriver() uses, -ENODATA.

Here's a more complete patch for that driver binding problem.
Now (a) when scanning for a driver to handle a new device,
scanning stops after the first successful probe not the
first successful match; and (b) new drivers get every chance to
bind to additional devices, even after the first one succeeds.

Please merge.  This will help resolve some of the USB flakies
in recent kernels.  Note that (a) was noticed independently by
me and Andries Brouwer, and AFAIK this is the first patch to
also fix failure (b) which was uncovered by fixing (a).

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

Various small fixes and adds ids for new test firmware.

Duh: in driver_detach(), one of the first things we do is remove the device
from the driver's list of devices. So, we obviously cannot use ->next. 

Adapted from Greg KH: 

- add multiple possible enumerated states a device can be in: UNINITIALIZED, INITIALIZED,
  REGISTERED, and GONE.
- Check whether device is INITIALIZED or REGISTERED in device_present().
- Change struct device::current_state to ::power_state to better reflect what it is.

- take device_sem around all global list walks.
- don't modify refcount, as get_device()/put_device() also take device_sem
- But, make sure we check device_present() to make sure device is still around.

(Note device removal will block until device_sem is dropped, so list will remain
intact.)

- Separate out device_shutdown() walk from device_suspend() walk. Even though the
  code is nearly identical, it's a lot clearer as to what is going on when they 
  are autonomous. It was my bad for originally putting that FIXME in there, encouraging
  the consolidation. 

- Add debugging hooks for my convenience. :)

- Call ->shutdown() when shutting down device, instead of ->remove(). (See ChangeSet 
  1.799 for description and semantics).

- device_sem is added to make the global list walks easier (for power mgmt and shutdown), so
  they don't have to take and drop device_lock a lot. 

- Change list modifications to take device_sem instead of device_lock.

- Ditto for device refcount modifications.

- Kill get_device_locked(), as all the users are now gone. 

- make sure we check what we get back from get_bus()
- do down_read() instead of down_write(), so multiple people can do iterations
  concurrently.
- Note that devices and drivers are removed from these while doing a down_write(), 
  so all removals will be stalled until the iterators are done.
 

Drivers must belong to bus, and each bus has an rwsem. Instead of mucking with
the device_lock spinlock, and dropping it on each iteration of the loop, we take 
the bus's lock (read, so multiple drivers can access their list at the same time)
around the entire walk of the list.

->shutdown() is added to be explicitly called during reboot transitions by 
device_shutdown(). Drivers implementing this method should use it solely to quiesce
the device. Drivers do not have to free memory allocated by the driver, as it is 
implied that the system is rebooting; and, they must not fuss with the reference
counts. Devices are guaranteed not to disappear during the call, though their 
validity may be checked using device_present().

This is similar to struct bus_type's rwsem, though classes aren't doing 
anything nearly as fancy with it. We just make sure to take it when ever
we add or remove any devices or drivers. 

when removing system and platform devices.

- move list walking and matching to bus.c (since it's a function of the bus driver)
- do specialized walks of the bus's lists when binding; no more callbacks being passed
  to bus_for_each_*.
- take rwsem when adding and removing both devices and drivers. lists of each are now
  fully protected by that rwsem. It's also taken before we walk each list.
- move calls of device_{de,at}tach() to bus_{add,remove}_device() and calls of 
  driver_{de,at}tach() to bus_{add,remove}_driver().

There is a chance devclass_add_device() could get passed a device with no driver, so
we need to check that.

into osdl.org:/home/mochel/src/kernel/devel/linux-2.5-core

Synchronize all walks of the device and driver lists of a bus with an rwsem wrapped
around the entire iterator, instead of using device_lock and dropping it after we 
grabbed each node. 

Note this also prevents deadlock when walking the list of drivers and calling 
get_driver(), since get_driver() tries to take device_lock while we already have it
held.

into penguin.transmeta.com:/home/penguin/torvalds/repositories/kernel/linux

into tp1.ruhr-uni-bochum.de:/home/kai/src/kernel/v2.5/linux-2.5.make

into tp1.ruhr-uni-bochum.de:/home/kai/src/kernel/v2.5/linux-2.5.isdn

plus other small cleanups, in particular getting rid of
isdn_ppp_{receive,send}_ccp() and calling into the CCP code directly.

No (well, hardly any ;) code changes, only moving all /dev/ipppX related
code next to each other and some indenting changes.

o Now that all the infrastructure is in place, struct ipppd can
  easily be allocated when /dev/ipppX is opened and freed
  in the destructor.
o Separate the mix of state and flags in struct ipppd::state.
  We only have three states, open, assigned and connected, and
  additionally two flags to jump out of poll(), returning POLLHUP /
  POLLIN.

Instead of just recording the slot number and then retrieving
the ipppd via that, we can now just keep a pointer and get a
reference which makes sure that it does not go away until
we drop the reference.

We had introduced ipppd_get/put() earlier, so now add a real reference
count.

Basically, all what was missing was a common way to xmit frames
given the isdn_net_dev / isdn_net_local. We have this now by means
of function pointers (still room for improvement there, though), so
now let's do things from isdn_ppp_ccp.c.

Let isdn_ppp_ccp.c take care of keeping state / flags by itself.

Use a shared function for generating the PPP header, use the
{put,get}_u{8,16,32} helpers for endian-safe access.

I cannot see now reason why ISDN PPP devices should have a fake
::header routine which reserves a couple of bytes just to reclaim them
later during hard_start_xmit(), and since it works just as well without
it...