Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/juhl/trivial

 };

-static DEFINE_MUTEX(cache_lock);

+static spinlock_t cache_lock = SPIN_LOCK_UNLOCKED;

+static DEFINE_SPINLOCK(cache_lock);

 static LIST_HEAD(cache);

 static unsigned int cache_num = 0;

 #define MAX_CACHE_SIZE 10

-        int popularity;

 };

 static spinlock_t cache_lock = SPIN_LOCK_UNLOCKED;

 static DEFINE_SPINLOCK(cache_lock);

@@ -77,6 +84,7 @@

         obj->id = id;

         obj->popularity = 0;

      useful documents, at the USB home page (see Resources). An excellent

      introduction to the Linux USB subsystem can be found at the USB Working

      Devices List (see Resources). It explains how the Linux USB subsystem is

      structured and introduces the reader to the concept of USB urbs, which

      are essential to USB drivers.

      structured and introduces the reader to the concept of USB urbs

      (USB Request Blocks), which are essential to USB drivers.

  </para>

  <para>

      The first thing a Linux USB driver needs to do is register itself with

module_init(usb_skel_init);

  </programlisting>

  <para>

      When the driver is unloaded from the system, it needs to unregister

      itself with the USB subsystem. This is done with the usb_unregister

      When the driver is unloaded from the system, it needs to deregister

      itself with the USB subsystem. This is done with the usb_deregister

      function:

  </para>

  <programlisting>

     were passed to the USB subsystem will be called from a user program trying

     to talk to the device. The first function called will be open, as the

     program tries to open the device for I/O. We increment our private usage

     count and save off a pointer to our internal structure in the file

     count and save a pointer to our internal structure in the file

     structure. This is done so that future calls to file operations will

     enable the driver to determine which device the user is addressing.  All

     of this is done with the following code:

     send to the device based on the size of the write urb it has created (this

     size depends on the size of the bulk out end point that the device has).

     Then it copies the data from user space to kernel space, points the urb to

     the data and submits the urb to the USB subsystem.  This can be shown in

     he following code:

     the data and submits the urb to the USB subsystem.  This can be seen in

     the following code:

  </para>

  <programlisting>

/* we can only write as much as 1 urb will hold */

copy the maintainer when you change their code.

For small patches you may want to CC the Trivial Patch Monkey

trivial@kernel.org managed by Adrian Bunk; which collects "trivial"

trivial@kernel.org managed by Jesper Juhl; which collects "trivial"

patches. Trivial patches must qualify for one of the following rules:

 Spelling fixes in documentation

 Spelling fixes which could break grep(1)

 since people copy, as long as it's trivial)

 Any fix by the author/maintainer of the file (ie. patch monkey

 in re-transmission mode)

URL: <http://www.kernel.org/pub/linux/kernel/people/bunk/trivial/>

URL: <http://www.kernel.org/pub/linux/kernel/people/juhl/trivial/>

io_request_lock for serialization need to be modified accordingly.

Usually it's as easy as adding a global lock:

	static spinlock_t my_driver_lock = SPIN_LOCK_UNLOCKED;

	static DEFINE_SPINLOCK(my_driver_lock);

and passing the address to that lock to blk_init_queue().

but from now on a more direct method of locking has to be used:

	spinlock_t driver_lock = SPIN_LOCK_UNLOCKED;

	DEFINE_SPINLOCK(driver_lock);

	struct driver_data;

	irq_handler (...)