Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6

What is anchor?

===============

A USB driver needs to support some callbacks requiring

a driver to cease all IO to an interface. To do so, a

driver has to keep track of the URBs it has submitted

to know they've all completed or to call usb_kill_urb

for them. The anchor is a data structure takes care of

keeping track of URBs and provides methods to deal with

multiple URBs.

Allocation and Initialisation

=============================

There's no API to allocate an anchor. It is simply declared

as struct usb_anchor. init_usb_anchor() must be called to

initialise the data structure.

Deallocation

============

Once it has no more URBs associated with it, the anchor can be

freed with normal memory management operations.

Association and disassociation of URBs with anchors

===================================================

An association of URBs to an anchor is made by an explicit

call to usb_anchor_urb(). The association is maintained until

an URB is finished by (successfull) completion. Thus disassociation

is automatic. A function is provided to forcibly finish (kill)

all URBs associated with an anchor.

Furthermore, disassociation can be made with usb_unanchor_urb()

Operations on multitudes of URBs

================================

usb_kill_anchored_urbs()

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

This function kills all URBs associated with an anchor. The URBs

are called in the reverse temporal order they were submitted.

This way no data can be reordered.

usb_wait_anchor_empty_timeout()

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

This function waits for all URBs associated with an anchor to finish

or a timeout, whichever comes first. Its return value will tell you

whether the timeout was reached.

What callbacks will usbcore do?

===============================

Usbcore will call into a driver through callbacks defined in the driver

structure and through the completion handler of URBs a driver submits.

Only the former are in the scope of this document. These two kinds of

callbacks are completely independent of each other. Information on the

completion callback can be found in Documentation/usb/URB.txt.

The callbacks defined in the driver structure are:

1. Hotplugging callbacks:

 * @probe: Called to see if the driver is willing to manage a particular

 *	interface on a device.

 * @disconnect: Called when the interface is no longer accessible, usually

 *	because its device has been (or is being) disconnected or the

 *	driver module is being unloaded.

2. Odd backdoor through usbfs:

 * @ioctl: Used for drivers that want to talk to userspace through

 *	the "usbfs" filesystem.  This lets devices provide ways to

 *	expose information to user space regardless of where they

 *	do (or don't) show up otherwise in the filesystem.

3. Power management (PM) callbacks:

 * @suspend: Called when the device is going to be suspended.

 * @resume: Called when the device is being resumed.

 * @reset_resume: Called when the suspended device has been reset instead

 *	of being resumed.

4. Device level operations:

 * @pre_reset: Called when the device is about to be reset.

 * @post_reset: Called after the device has been reset

The ioctl interface (2) should be used only if you have a very good

reason. Sysfs is preferred these days. The PM callbacks are covered

separately in Documentation/usb/power-management.txt.

Calling conventions

===================

All callbacks are mutually exclusive. There's no need for locking

against other USB callbacks. All callbacks are called from a task

context. You may sleep. However, it is important that all sleeps have a

small fixed upper limit in time. In particular you must not call out to

user space and await results.

Hotplugging callbacks

=====================

These callbacks are intended to associate and disassociate a driver with

an interface. A driver's bond to an interface is exclusive.

The probe() callback

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

int (*probe) (struct usb_interface *intf,

		const struct usb_device_id *id);

Accept or decline an interface. If you accept the device return 0,

otherwise -ENODEV or -ENXIO. Other error codes should be used only if a

genuine error occurred during initialisation which prevented a driver

from accepting a device that would else have been accepted.

You are strongly encouraged to use usbcore'sfacility,

usb_set_intfdata(), to associate a data structure with an interface, so

that you know which internal state and identity you associate with a

particular interface. The device will not be suspended and you may do IO

to the interface you are called for and endpoint 0 of the device. Device

initialisation that doesn't take too long is a good idea here.

The disconnect() callback

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

void (*disconnect) (struct usb_interface *intf);

This callback is a signal to break any connection with an interface.

You are not allowed any IO to a device after returning from this

callback. You also may not do any other operation that may interfere

with another driver bound the interface, eg. a power management

operation.

If you are called due to a physical disconnection, all your URBs will be

killed by usbcore. Note that in this case disconnect will be called some

time after the physical disconnection. Thus your driver must be prepared

to deal with failing IO even prior to the callback.

Device level callbacks

======================

pre_reset

---------

int (*pre_reset)(struct usb_interface *intf);

Another driver or user space is triggering a reset on the device which

contains the interface passed as an argument. Cease IO and save any

device state you need to restore.

If you need to allocate memory here, use GFP_NOIO or GFP_ATOMIC, if you

are in atomic context.

post_reset

----------

int (*post_reset)(struct usb_interface *intf);

The reset has completed.  Restore any saved device state and begin

using the device again.

If you need to allocate memory here, use GFP_NOIO or GFP_ATOMIC, if you

are in atomic context.

Call sequences

==============

No callbacks other than probe will be invoked for an interface

that isn't bound to your driver.

Probe will never be called for an interface bound to a driver.

Hence following a successful probe, disconnect will be called

before there is another probe for the same interface.

Once your driver is bound to an interface, disconnect can be

called at any time except in between pre_reset and post_reset.

pre_reset is always followed by post_reset, even if the reset

failed or the device has been unplugged.

suspend is always followed by one of: resume, reset_resume, or

disconnect.

		   Alan Stern <stern@rowland.harvard.edu>

		 September 2, 2006 (Updated May 29, 2007)

		September 2, 2006 (Updated February 25, 2008)

	What is the problem?

	What is the solution?

Setting CONFIG_USB_PERSIST will cause the kernel to work around these

issues.  It enables a mode in which the core USB device data

structures are allowed to persist across a power-session disruption.

The kernel includes a feature called USB-persist.  It tries to work

around these issues by allowing the core USB device data structures to

persist across a power-session disruption.

It works like this.  If the kernel sees that a USB host controller is

not in the expected state during resume (i.e., if the controller was

reset or otherwise had lost power) then it applies a persistence check

same descriptors as before, including the Vendor and Product IDs, then

the kernel continues to use the same device structure.  In effect, the

kernel treats the device as though it had merely been reset instead of

unplugged.

unplugged.  The same thing happens if the host controller is in the

expected state but a USB device was unplugged and then replugged.

If no device is now attached to the port, or if the descriptors are

different from what the kernel remembers, then the treatment is what

you would expect.  The kernel destroys the old device structure and

behaves as though the old device had been unplugged and a new device

plugged in, just as it would without the CONFIG_USB_PERSIST option.

plugged in.

The end result is that the USB device remains available and usable.

Filesystem mounts and memory mappings are unaffected, and the world is

now a good and happy place.

Note that even when CONFIG_USB_PERSIST is set, the "persist" feature

will be applied only to those devices for which it is enabled.  You

can enable the feature by doing (as root):

Note that the "USB-persist" feature will be applied only to those

devices for which it is enabled.  You can enable the feature by doing

(as root):

	echo 1 >/sys/bus/usb/devices/.../power/persist

where the "..." should be filled in the with the device's ID.  Disable

the feature by writing 0 instead of 1.  For hubs the feature is

automatically and permanently enabled, so you only have to worry about

setting it for devices where it really matters.

automatically and permanently enabled and the power/persist file

doesn't even exist, so you only have to worry about setting it for

devices where it really matters.

	Is this the best solution?

to plug in a USB flash device, create a persistent volume associated

with it, unplug the flash device, plug it back in later, and still

have the same persistent volume associated with the device.  As such

it would be more far-reaching than CONFIG_USB_PERSIST.

it would be more far-reaching than USB-persist.

On the other hand, writing a persistent volume manager would be a big

job and using it would require significant input from the user.  This

solution is much quicker and easier -- and it exists now, a giant

point in its favor!

Furthermore, the USB_PERSIST option applies to _all_ USB devices, not

Furthermore, the USB-persist feature applies to _all_ USB devices, not

just mass-storage devices.  It might turn out to be equally useful for

other device types, such as network interfaces.

	WARNING: Using CONFIG_USB_PERSIST can be dangerous!!

	WARNING: USB-persist can be dangerous!!

When recovering an interrupted power session the kernel does its best

to make sure the USB device hasn't been changed; that is, the same

If you replace one USB device with another of the same type (same

manufacturer, same IDs, and so on) there's an excellent chance the

kernel won't detect the change.  Serial numbers and other strings are

not compared.  In many cases it wouldn't help if they were, because

manufacturers frequently omit serial numbers entirely in their

devices.

kernel won't detect the change.  The serial number string and other

descriptors are compared with the kernel's stored values, but this

might not help since manufacturers frequently omit serial numbers

entirely in their devices.

Furthermore it's quite possible to leave a USB device exactly the same

while changing its media.  If you replace the flash memory card in a

YOU HAVE BEEN WARNED!  USE AT YOUR OWN RISK!

That having been said, most of the time there shouldn't be any trouble

at all.  The "persist" feature can be extremely useful.  Make the most

of it.

at all.  The USB-persist feature can be extremely useful.  Make the

most of it.

FTDI Single Port Serial Driver

  This is a single port DB-25 serial adapter. More information about this

  device and the Linux driver can be found at:

	http://reality.sgi.com/bryder_wellington/ftdi_sio/

  This is a single port DB-25 serial adapter.

  For any questions or problems with this driver, please contact Bill Ryder

  at bryder@sgi.com

  For any questions or problems with this driver, please contact Bill Ryder.

ZyXEL omni.net lcd plus ISDN TA

static void xpad_irq_in(struct urb *urb)

{

	struct usb_xpad *xpad = urb->context;

	int retval;

	int retval, status;

	switch (urb->status) {

	status = urb->status;

	switch (status) {

	case 0:

		/* success */

		break;

	case -ESHUTDOWN:

		/* this urb is terminated, clean up */

		dbg("%s - urb shutting down with status: %d",

			__FUNCTION__, urb->status);

			__FUNCTION__, status);

		return;

	default:

		dbg("%s - nonzero urb status received: %d",

			__FUNCTION__, urb->status);

			__FUNCTION__, status);

		goto exit;

	}

#if defined(CONFIG_JOYSTICK_XPAD_FF) || defined(CONFIG_JOYSTICK_XPAD_LEDS)

static void xpad_irq_out(struct urb *urb)

{

	int retval;

	int retval, status;

	switch (urb->status) {

	status = urb->status;

	switch (status) {

		case 0:

		/* success */

		break;

		case -ESHUTDOWN:

			/* this urb is terminated, clean up */

			dbg("%s - urb shutting down with status: %d",

				__FUNCTION__, urb->status);

				__FUNCTION__, status);

			return;

		default:

			dbg("%s - nonzero urb status received: %d",

				__FUNCTION__, urb->status);

				__FUNCTION__, status);

			goto exit;

	}