This commit was manufactured by cvs2svn to create tag

[linux-2.6.git] / Documentation / sound / alsa / DocBook / writing-an-alsa-driver.tmpl

diff --git a/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl b/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl
index e789475..1faf763 100644 (file)
--- a/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl
+++ b/Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl
@@ -18,8 +18,8 @@
       </affiliation>
      </author>
 
       </affiliation>
      </author>
 

-     <date>March 6, 2005</date>
-     <edition>0.3.4</edition>
+     <date>November 17, 2005</date>
+     <edition>0.3.6</edition>

 
     <abstract>
       <para>
 
     <abstract>
       <para>


@@ -30,7 +30,7 @@
 
     <legalnotice>
     <para>
 
     <legalnotice>
     <para>

-    Copyright (c) 2002-2004  Takashi Iwai <email>tiwai@suse.de</email>
+    Copyright (c) 2002-2005  Takashi Iwai <email>tiwai@suse.de</email>

     </para>
 
     <para>
     </para>
 
     <para>


@@ -371,7 +371,7 @@
           <listitem><para>create <function>probe()</function> callback.</para></listitem>
           <listitem><para>create <function>remove()</function> callback.</para></listitem>
           <listitem><para>create pci_driver table which contains the three pointers above.</para></listitem>
           <listitem><para>create <function>probe()</function> callback.</para></listitem>
           <listitem><para>create <function>remove()</function> callback.</para></listitem>
           <listitem><para>create pci_driver table which contains the three pointers above.</para></listitem>

-          <listitem><para>create <function>init()</function> function just calling <function>pci_module_init()</function> to register the pci_driver table defined above.</para></listitem>
+          <listitem><para>create <function>init()</function> function just calling <function>pci_register_driver()</function> to register the pci_driver table defined above.</para></listitem>

           <listitem><para>create <function>exit()</function> function to call <function>pci_unregister_driver()</function> function.</para></listitem>
         </itemizedlist>
       </para>
           <listitem><para>create <function>exit()</function> function to call <function>pci_unregister_driver()</function> function.</para></listitem>
         </itemizedlist>
       </para>


@@ -403,9 +403,8 @@
   static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
 
   /* definition of the chip-specific record */
   static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
 
   /* definition of the chip-specific record */

-  typedef struct snd_mychip mychip_t;
-  struct snd_mychip {
-          snd_card_t *card;
+  struct mychip {
+          struct snd_card *card;

           // rest of implementation will be in the section
           // "PCI Resource Managements"
   };
           // rest of implementation will be in the section
           // "PCI Resource Managements"
   };


@@ -413,7 +412,7 @@
   /* chip-specific destructor
    * (see "PCI Resource Managements")
    */
   /* chip-specific destructor
    * (see "PCI Resource Managements")
    */

-  static int snd_mychip_free(mychip_t *chip)
+  static int snd_mychip_free(struct mychip *chip)

   {
           .... // will be implemented later...
   }
   {
           .... // will be implemented later...
   }


@@ -421,22 +420,21 @@
   /* component-destructor
    * (see "Management of Cards and Components")
    */
   /* component-destructor
    * (see "Management of Cards and Components")
    */

-  static int snd_mychip_dev_free(snd_device_t *device)
+  static int snd_mychip_dev_free(struct snd_device *device)

   {
   {

-          mychip_t *chip = device->device_data;
-          return snd_mychip_free(chip);
+          return snd_mychip_free(device->device_data);

   }
 
   /* chip-specific constructor
    * (see "Management of Cards and Components")
    */
   }
 
   /* chip-specific constructor
    * (see "Management of Cards and Components")
    */

-  static int __devinit snd_mychip_create(snd_card_t *card,
+  static int __devinit snd_mychip_create(struct snd_card *card,

                                          struct pci_dev *pci,
                                          struct pci_dev *pci,

-                                         mychip_t **rchip)
+                                         struct mychip **rchip)

   {
   {

-          mychip_t *chip;
+          struct mychip *chip;

           int err;
           int err;

-          static snd_device_ops_t ops = {
+          static struct snd_device_ops ops = {

                  .dev_free = snd_mychip_dev_free,
           };
 
                  .dev_free = snd_mychip_dev_free,
           };
 


@@ -447,7 +445,7 @@
           ....
 
           /* allocate a chip-specific data with zero filled */
           ....
 
           /* allocate a chip-specific data with zero filled */

-          chip = kcalloc(1, sizeof(*chip), GFP_KERNEL);
+          chip = kzalloc(sizeof(*chip), GFP_KERNEL);

           if (chip == NULL)
                   return -ENOMEM;
 
           if (chip == NULL)
                   return -ENOMEM;
 


@@ -474,8 +472,8 @@
                                const struct pci_device_id *pci_id)
   {
           static int dev;
                                const struct pci_device_id *pci_id)
   {
           static int dev;

-          snd_card_t *card;
-          mychip_t *chip;
+          struct snd_card *card;
+          struct mychip *chip;

           int err;
 
           /* (1) */
           int err;
 
           /* (1) */


@@ -582,7 +580,7 @@
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  snd_card_t *card;
+  struct snd_card *card;

   ....
   card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
 ]]>
   ....
   card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
 ]]>


@@ -605,7 +603,7 @@
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  mychip_t *chip;
+  struct mychip *chip;

   ....
   if ((err = snd_mychip_create(card, pci, &chip)) < 0) {
           snd_card_free(card);
   ....
   if ((err = snd_mychip_create(card, pci, &chip)) < 0) {
           snd_card_free(card);


@@ -806,7 +804,7 @@
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  snd_card_t *card;
+  struct snd_card *card;

   card = snd_card_new(index, id, module, extra_size);
 ]]>
           </programlisting>
   card = snd_card_new(index, id, module, extra_size);
 ]]>
           </programlisting>


@@ -830,7 +828,7 @@
       <para>
         After the card is created, you can attach the components
       (devices) to the card instance. On ALSA driver, a component is
       <para>
         After the card is created, you can attach the components
       (devices) to the card instance. On ALSA driver, a component is

-      represented as a <type>snd_device_t</type> object.
+      represented as a struct <structname>snd_device</structname> object.

       A component can be a PCM instance, a control interface, a raw
       MIDI interface, etc.  Each of such instances has one component
       entry.
       A component can be a PCM instance, a control interface, a raw
       MIDI interface, etc.  Each of such instances has one component
       entry.


@@ -891,14 +889,11 @@
       The chip-specific information, e.g. the i/o port address, its
       resource pointer, or the irq number, is stored in the
       chip-specific record.
       The chip-specific information, e.g. the i/o port address, its
       resource pointer, or the irq number, is stored in the
       chip-specific record.

-      Usually, the chip-specific record is typedef'ed as
-      <type>xxx_t</type> like the following:

 
         <informalexample>
           <programlisting>
 <![CDATA[
 
         <informalexample>
           <programlisting>
 <![CDATA[

-  typedef struct snd_mychip mychip_t;
-  struct snd_mychip {
+  struct mychip {

           ....
   };
 ]]>
           ....
   };
 ]]>


@@ -918,12 +913,12 @@
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(mychip_t));
+  card = snd_card_new(index[dev], id[dev], THIS_MODULE, sizeof(struct mychip));

 ]]>
             </programlisting>
           </informalexample>
 
 ]]>
             </programlisting>
           </informalexample>
 

-          whether <type>mychip_t</type> is the type of the chip record.
+          whether struct <structname>mychip</structname> is the type of the chip record.

         </para>
 
         <para>
         </para>
 
         <para>


@@ -932,7 +927,7 @@
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  mychip_t *chip = (mychip_t *)card->private_data;
+  struct mychip *chip = (struct mychip *)card->private_data;

 ]]>
             </programlisting>
           </informalexample>
 ]]>
             </programlisting>
           </informalexample>


@@ -949,16 +944,16 @@
           After allocating a card instance via
           <function>snd_card_new()</function> (with
           <constant>NULL</constant> on the 4th arg), call
           After allocating a card instance via
           <function>snd_card_new()</function> (with
           <constant>NULL</constant> on the 4th arg), call

-          <function>kcalloc()</function>. 
+          <function>kzalloc()</function>. 

 
           <informalexample>
             <programlisting>
 <![CDATA[
 
           <informalexample>
             <programlisting>
 <![CDATA[

-  snd_card_t *card;
-  mychip_t *chip;
+  struct snd_card *card;
+  struct mychip *chip;

   card = snd_card_new(index[dev], id[dev], THIS_MODULE, NULL);
   .....
   card = snd_card_new(index[dev], id[dev], THIS_MODULE, NULL);
   .....

-  chip = kcalloc(1, sizeof(*chip), GFP_KERNEL);
+  chip = kzalloc(sizeof(*chip), GFP_KERNEL);

 ]]>
             </programlisting>
           </informalexample>
 ]]>
             </programlisting>
           </informalexample>


@@ -971,8 +966,8 @@
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  struct snd_mychip {
-          snd_card_t *card;
+  struct mychip {
+          struct snd_card *card;

           ....
   };
 ]]>
           ....
   };
 ]]>


@@ -1000,7 +995,7 @@
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static snd_device_ops_t ops = {
+  static struct snd_device_ops ops = {

           .dev_free =        snd_mychip_dev_free,
   };
   ....
           .dev_free =        snd_mychip_dev_free,
   };
   ....


@@ -1018,10 +1013,9 @@
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_mychip_dev_free(snd_device_t *device)
+  static int snd_mychip_dev_free(struct snd_device *device)

   {
   {

-          mychip_t *chip = device->device_data;
-          return snd_mychip_free(chip);
+          return snd_mychip_free(device->device_data);

   }
 ]]>
             </programlisting>
   }
 ]]>
             </programlisting>


@@ -1087,15 +1081,15 @@
           <title>PCI Resource Managements Example</title>
           <programlisting>
 <![CDATA[
           <title>PCI Resource Managements Example</title>
           <programlisting>
 <![CDATA[

-  struct snd_mychip {
-          snd_card_t *card;
+  struct mychip {
+          struct snd_card *card;

           struct pci_dev *pci;
 
           unsigned long port;
           int irq;
   };
 
           struct pci_dev *pci;
 
           unsigned long port;
           int irq;
   };
 

-  static int snd_mychip_free(mychip_t *chip)
+  static int snd_mychip_free(struct mychip *chip)

   {
           /* disable hardware here if any */
           .... // (not implemented in this document)
   {
           /* disable hardware here if any */
           .... // (not implemented in this document)


@@ -1113,13 +1107,13 @@
   }
 
   /* chip-specific constructor */
   }
 
   /* chip-specific constructor */

-  static int __devinit snd_mychip_create(snd_card_t *card,
+  static int __devinit snd_mychip_create(struct snd_card *card,

                                          struct pci_dev *pci,
                                          struct pci_dev *pci,

-                                         mychip_t **rchip)
+                                         struct mychip **rchip)

   {
   {

-          mychip_t *chip;
+          struct mychip *chip;

           int err;
           int err;

-          static snd_device_ops_t ops = {
+          static struct snd_device_ops ops = {

                  .dev_free = snd_mychip_dev_free,
           };
 
                  .dev_free = snd_mychip_dev_free,
           };
 


@@ -1129,14 +1123,14 @@
           if ((err = pci_enable_device(pci)) < 0)
                   return err;
           /* check PCI availability (28bit DMA) */
           if ((err = pci_enable_device(pci)) < 0)
                   return err;
           /* check PCI availability (28bit DMA) */

-          if (pci_set_dma_mask(pci, 0x0fffffff) < 0 ||
-              pci_set_consistent_dma_mask(pci, 0x0fffffff) < 0) {
+          if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
+              pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {

                   printk(KERN_ERR "error to set 28bit mask DMA\n");
                   pci_disable_device(pci);
                   return -ENXIO;
           }
 
                   printk(KERN_ERR "error to set 28bit mask DMA\n");
                   pci_disable_device(pci);
                   return -ENXIO;
           }
 

-          chip = kcalloc(1, sizeof(*chip), GFP_KERNEL);
+          chip = kzalloc(sizeof(*chip), GFP_KERNEL);

           if (chip == NULL) {
                   pci_disable_device(pci);
                   return -ENOMEM;
           if (chip == NULL) {
                   pci_disable_device(pci);
                   return -ENOMEM;


@@ -1155,8 +1149,7 @@
           }
           chip->port = pci_resource_start(pci, 0);
           if (request_irq(pci->irq, snd_mychip_interrupt,
           }
           chip->port = pci_resource_start(pci, 0);
           if (request_irq(pci->irq, snd_mychip_interrupt,

-                          SA_INTERRUPT|SA_SHIRQ, "My Chip",
-                          (void *)chip)) {
+                          SA_INTERRUPT|SA_SHIRQ, "My Chip", chip)) {

                   printk(KERN_ERR "cannot grab irq %d\n", pci->irq);
                   snd_mychip_free(chip);
                   return -EBUSY;
                   printk(KERN_ERR "cannot grab irq %d\n", pci->irq);
                   snd_mychip_free(chip);
                   return -EBUSY;


@@ -1179,7 +1172,7 @@
   }        
 
   /* PCI IDs */
   }        
 
   /* PCI IDs */

-  static struct pci_device_id snd_mychip_ids[] = {
+  static struct pci_device_id snd_mychip_ids[] __devinitdata = {

           { PCI_VENDOR_ID_FOO, PCI_DEVICE_ID_BAR,
             PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
           ....
           { PCI_VENDOR_ID_FOO, PCI_DEVICE_ID_BAR,
             PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
           ....


@@ -1198,7 +1191,7 @@
   /* initialization of the module */
   static int __init alsa_card_mychip_init(void)
   {
   /* initialization of the module */
   static int __init alsa_card_mychip_init(void)
   {

-          return pci_module_init(&driver);
+          return pci_register_driver(&driver);

   }
 
   /* clean up the module */
   }
 
   /* clean up the module */


@@ -1223,7 +1216,7 @@
         The allocation of PCI resources is done in the
       <function>probe()</function> function, and usually an extra
       <function>xxx_create()</function> function is written for this
         The allocation of PCI resources is done in the
       <function>probe()</function> function, and usually an extra
       <function>xxx_create()</function> function is written for this

-      purpose. 
+      purpose.

       </para>
 
       <para>
       </para>
 
       <para>


@@ -1232,7 +1225,7 @@
       allocating resources. Also, you need to set the proper PCI DMA
       mask to limit the accessed i/o range. In some cases, you might
       need to call <function>pci_set_master()</function> function,
       allocating resources. Also, you need to set the proper PCI DMA
       mask to limit the accessed i/o range. In some cases, you might
       need to call <function>pci_set_master()</function> function,

-      too. 
+      too.

       </para>
 
       <para>
       </para>
 
       <para>


@@ -1243,8 +1236,8 @@
 <![CDATA[
   if ((err = pci_enable_device(pci)) < 0)
           return err;
 <![CDATA[
   if ((err = pci_enable_device(pci)) < 0)
           return err;

-  if (pci_set_dma_mask(pci, 0x0fffffff) < 0 ||
-      pci_set_consistent_dma_mask(pci, 0x0fffffff) < 0) {
+  if (pci_set_dma_mask(pci, DMA_28BIT_MASK) < 0 ||
+      pci_set_consistent_dma_mask(pci, DMA_28BIT_MASK) < 0) {

           printk(KERN_ERR "error to set 28bit mask DMA\n");
           pci_disable_device(pci);
           return -ENXIO;
           printk(KERN_ERR "error to set 28bit mask DMA\n");
           pci_disable_device(pci);
           return -ENXIO;


@@ -1263,19 +1256,19 @@
       functions. Unlike ALSA ver.0.5.x., there are no helpers for
       that. And these resources must be released in the destructor
       function (see below). Also, on ALSA 0.9.x, you don't need to
       functions. Unlike ALSA ver.0.5.x., there are no helpers for
       that. And these resources must be released in the destructor
       function (see below). Also, on ALSA 0.9.x, you don't need to

-      allocate (pseudo-)DMA for PCI like ALSA 0.5.x. 
+      allocate (pseudo-)DMA for PCI like ALSA 0.5.x.

       </para>
 
       <para>
         Now assume that this PCI device has an I/O port with 8 bytes
       </para>
 
       <para>
         Now assume that this PCI device has an I/O port with 8 bytes

-        and an interrupt. Then <type>mychip_t</type> will have the
-        following fields: 
+        and an interrupt. Then struct <structname>mychip</structname> will have the
+        following fields:

 
         <informalexample>
           <programlisting>
 <![CDATA[
 
         <informalexample>
           <programlisting>
 <![CDATA[

-  struct snd_mychip {
-          snd_card_t *card;
+  struct mychip {
+          struct snd_card *card;

 
           unsigned long port;
           int irq;
 
           unsigned long port;
           int irq;


@@ -1292,7 +1285,7 @@
       need to initialize this number as -1 before actual allocation,
       since irq 0 is valid. The port address and its resource pointer
       can be initialized as null by
       need to initialize this number as -1 before actual allocation,
       since irq 0 is valid. The port address and its resource pointer
       can be initialized as null by

-      <function>kcalloc()</function> automatically, so you
+      <function>kzalloc()</function> automatically, so you

       don't have to take care of resetting them. 
       </para>
 
       don't have to take care of resetting them. 
       </para>
 


@@ -1330,8 +1323,7 @@
           <programlisting>
 <![CDATA[
   if (request_irq(pci->irq, snd_mychip_interrupt,
           <programlisting>
 <![CDATA[
   if (request_irq(pci->irq, snd_mychip_interrupt,

-                  SA_INTERRUPT|SA_SHIRQ, "My Chip",
-                  (void *)chip)) {
+                  SA_INTERRUPT|SA_SHIRQ, "My Chip", chip)) {

           printk(KERN_ERR "cannot grab irq %d\n", pci->irq);
           snd_mychip_free(chip);
           return -EBUSY;
           printk(KERN_ERR "cannot grab irq %d\n", pci->irq);
           snd_mychip_free(chip);
           return -EBUSY;


@@ -1372,7 +1364,7 @@
   static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id,
                                           struct pt_regs *regs)
   {
   static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id,
                                           struct pt_regs *regs)
   {

-          mychip_t *chip = dev_id;
+          struct mychip *chip = dev_id;

           ....
           return IRQ_HANDLED;
   }
           ....
           return IRQ_HANDLED;
   }


@@ -1433,25 +1425,10 @@
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  if (chip->res_port) {
-          release_resource(chip->res_port);
-          kfree_nocheck(chip->res_port);
-  }
+  release_and_free_resource(chip->res_port);

 ]]>
           </programlisting>
         </informalexample>
 ]]>
           </programlisting>
         </informalexample>

-
-      As you can see, the resource pointer is also to be freed
-      via <function>kfree_nocheck()</function> after
-      <function>release_resource()</function> is called. You
-      cannot use <function>kfree()</function> here, because on ALSA,
-      <function>kfree()</function> may be a wrapper to its own
-      allocator with the memory debugging. Since the resource pointer
-      is allocated externally outside the ALSA, it must be released
-      via the native
-      <function>kfree()</function>.
-      <function>kfree_nocheck()</function> is used for that; it calls
-      the native <function>kfree()</function> without wrapper. 

       </para>
 
       <para>
       </para>
 
       <para>


@@ -1502,7 +1479,7 @@
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  struct snd_mychip {
+  struct mychip {

           ....
           unsigned long iobase_phys;
           void __iomem *iobase_virt;
           ....
           unsigned long iobase_phys;
           void __iomem *iobase_virt;


@@ -1532,7 +1509,7 @@
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static int snd_mychip_free(mychip_t *chip)
+  static int snd_mychip_free(struct mychip *chip)

   {
           ....
           if (chip->iobase_virt)
   {
           ....
           if (chip->iobase_virt)


@@ -1552,7 +1529,7 @@
       <title>Registration of Device Struct</title>
       <para>
        At some point, typically after calling <function>snd_device_new()</function>,
       <title>Registration of Device Struct</title>
       <para>
        At some point, typically after calling <function>snd_device_new()</function>,

-       you need to register the <structname>struct device</structname> of the chip
+       you need to register the struct <structname>device</structname> of the chip

        you're handling for udev and co.  ALSA provides a macro for compatibility with
        older kernels.  Simply call like the following:
         <informalexample>
        you're handling for udev and co.  ALSA provides a macro for compatibility with
        older kernels.  Simply call like the following:
         <informalexample>


@@ -1588,7 +1565,7 @@
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static struct pci_device_id snd_mychip_ids[] = {
+  static struct pci_device_id snd_mychip_ids[] __devinitdata = {

           { PCI_VENDOR_ID_FOO, PCI_DEVICE_ID_BAR,
             PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
           ....
           { PCI_VENDOR_ID_FOO, PCI_DEVICE_ID_BAR,
             PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
           ....


@@ -1654,7 +1631,7 @@
 <![CDATA[
   static int __init alsa_card_mychip_init(void)
   {
 <![CDATA[
   static int __init alsa_card_mychip_init(void)
   {

-          return pci_module_init(&driver);
+          return pci_register_driver(&driver);

   }
 
   static void __exit alsa_card_mychip_exit(void)
   }
 
   static void __exit alsa_card_mychip_exit(void)


@@ -1754,7 +1731,7 @@
   ....
 
   /* hardware definition */
   ....
 
   /* hardware definition */

-  static snd_pcm_hardware_t snd_mychip_playback_hw = {
+  static struct snd_pcm_hardware snd_mychip_playback_hw = {

           .info = (SNDRV_PCM_INFO_MMAP |
                    SNDRV_PCM_INFO_INTERLEAVED |
                    SNDRV_PCM_INFO_BLOCK_TRANSFER |
           .info = (SNDRV_PCM_INFO_MMAP |
                    SNDRV_PCM_INFO_INTERLEAVED |
                    SNDRV_PCM_INFO_BLOCK_TRANSFER |


@@ -1773,7 +1750,7 @@
   };
 
   /* hardware definition */
   };
 
   /* hardware definition */

-  static snd_pcm_hardware_t snd_mychip_capture_hw = {
+  static struct snd_pcm_hardware snd_mychip_capture_hw = {

           .info = (SNDRV_PCM_INFO_MMAP |
                    SNDRV_PCM_INFO_INTERLEAVED |
                    SNDRV_PCM_INFO_BLOCK_TRANSFER |
           .info = (SNDRV_PCM_INFO_MMAP |
                    SNDRV_PCM_INFO_INTERLEAVED |
                    SNDRV_PCM_INFO_BLOCK_TRANSFER |


@@ -1792,10 +1769,10 @@
   };
 
   /* open callback */
   };
 
   /* open callback */

-  static int snd_mychip_playback_open(snd_pcm_substream_t *substream)
+  static int snd_mychip_playback_open(struct snd_pcm_substream *substream)

   {
   {

-          mychip_t *chip = snd_pcm_substream_chip(substream);
-          snd_pcm_runtime_t *runtime = substream->runtime;
+          struct mychip *chip = snd_pcm_substream_chip(substream);
+          struct snd_pcm_runtime *runtime = substream->runtime;

 
           runtime->hw = snd_mychip_playback_hw;
           // more hardware-initialization will be done here
 
           runtime->hw = snd_mychip_playback_hw;
           // more hardware-initialization will be done here


@@ -1803,19 +1780,19 @@
   }
 
   /* close callback */
   }
 
   /* close callback */

-  static int snd_mychip_playback_close(snd_pcm_substream_t *substream)
+  static int snd_mychip_playback_close(struct snd_pcm_substream *substream)

   {
   {

-          mychip_t *chip = snd_pcm_substream_chip(substream);
+          struct mychip *chip = snd_pcm_substream_chip(substream);

           // the hardware-specific codes will be here
           return 0;
 
   }
 
   /* open callback */
           // the hardware-specific codes will be here
           return 0;
 
   }
 
   /* open callback */

-  static int snd_mychip_capture_open(snd_pcm_substream_t *substream)
+  static int snd_mychip_capture_open(struct snd_pcm_substream *substream)

   {
   {

-          mychip_t *chip = snd_pcm_substream_chip(substream);
-          snd_pcm_runtime_t *runtime = substream->runtime;
+          struct mychip *chip = snd_pcm_substream_chip(substream);
+          struct snd_pcm_runtime *runtime = substream->runtime;

 
           runtime->hw = snd_mychip_capture_hw;
           // more hardware-initialization will be done here
 
           runtime->hw = snd_mychip_capture_hw;
           // more hardware-initialization will be done here


@@ -1823,33 +1800,33 @@
   }
 
   /* close callback */
   }
 
   /* close callback */

-  static int snd_mychip_capture_close(snd_pcm_substream_t *substream)
+  static int snd_mychip_capture_close(struct snd_pcm_substream *substream)

   {
   {

-          mychip_t *chip = snd_pcm_substream_chip(substream);
+          struct mychip *chip = snd_pcm_substream_chip(substream);

           // the hardware-specific codes will be here
           return 0;
 
   }
 
   /* hw_params callback */
           // the hardware-specific codes will be here
           return 0;
 
   }
 
   /* hw_params callback */

-  static int snd_mychip_pcm_hw_params(snd_pcm_substream_t *substream,
-                               snd_pcm_hw_params_t * hw_params)
+  static int snd_mychip_pcm_hw_params(struct snd_pcm_substream *substream,
+                               struct snd_pcm_hw_params *hw_params)

   {
           return snd_pcm_lib_malloc_pages(substream,
                                      params_buffer_bytes(hw_params));
   }
 
   /* hw_free callback */
   {
           return snd_pcm_lib_malloc_pages(substream,
                                      params_buffer_bytes(hw_params));
   }
 
   /* hw_free callback */

-  static int snd_mychip_pcm_hw_free(snd_pcm_substream_t *substream)
+  static int snd_mychip_pcm_hw_free(struct snd_pcm_substream *substream)

   {
           return snd_pcm_lib_free_pages(substream);
   }
 
   /* prepare callback */
   {
           return snd_pcm_lib_free_pages(substream);
   }
 
   /* prepare callback */

-  static int snd_mychip_pcm_prepare(snd_pcm_substream_t *substream)
+  static int snd_mychip_pcm_prepare(struct snd_pcm_substream *substream)

   {
   {

-          mychip_t *chip = snd_pcm_substream_chip(substream);
-          snd_pcm_runtime_t *runtime = substream->runtime;
+          struct mychip *chip = snd_pcm_substream_chip(substream);
+          struct snd_pcm_runtime *runtime = substream->runtime;

 
           /* set up the hardware with the current configuration
            * for example...
 
           /* set up the hardware with the current configuration
            * for example...


@@ -1857,14 +1834,14 @@
           mychip_set_sample_format(chip, runtime->format);
           mychip_set_sample_rate(chip, runtime->rate);
           mychip_set_channels(chip, runtime->channels);
           mychip_set_sample_format(chip, runtime->format);
           mychip_set_sample_rate(chip, runtime->rate);
           mychip_set_channels(chip, runtime->channels);

-          mychip_set_dma_setup(chip, runtime->dma_area,
+          mychip_set_dma_setup(chip, runtime->dma_addr,

                                chip->buffer_size,
                                chip->period_size);
           return 0;
   }
 
   /* trigger callback */
                                chip->buffer_size,
                                chip->period_size);
           return 0;
   }
 
   /* trigger callback */

-  static int snd_mychip_pcm_trigger(snd_pcm_substream_t *substream,
+  static int snd_mychip_pcm_trigger(struct snd_pcm_substream *substream,

                                     int cmd)
   {
           switch (cmd) {
                                     int cmd)
   {
           switch (cmd) {


@@ -1881,9 +1858,9 @@
 
   /* pointer callback */
   static snd_pcm_uframes_t
 
   /* pointer callback */
   static snd_pcm_uframes_t

-  snd_mychip_pcm_pointer(snd_pcm_substream_t *substream)
+  snd_mychip_pcm_pointer(struct snd_pcm_substream *substream)

   {
   {

-          mychip_t *chip = snd_pcm_substream_chip(substream);
+          struct mychip *chip = snd_pcm_substream_chip(substream);

           unsigned int current_ptr;
 
           /* get the current hardware pointer */
           unsigned int current_ptr;
 
           /* get the current hardware pointer */


@@ -1892,7 +1869,7 @@
   }
 
   /* operators */
   }
 
   /* operators */

-  static snd_pcm_ops_t snd_mychip_playback_ops = {
+  static struct snd_pcm_ops snd_mychip_playback_ops = {

           .open =        snd_mychip_playback_open,
           .close =       snd_mychip_playback_close,
           .ioctl =       snd_pcm_lib_ioctl,
           .open =        snd_mychip_playback_open,
           .close =       snd_mychip_playback_close,
           .ioctl =       snd_pcm_lib_ioctl,


@@ -1904,7 +1881,7 @@
   };
 
   /* operators */
   };
 
   /* operators */

-  static snd_pcm_ops_t snd_mychip_capture_ops = {
+  static struct snd_pcm_ops snd_mychip_capture_ops = {

           .open =        snd_mychip_capture_open,
           .close =       snd_mychip_capture_close,
           .ioctl =       snd_pcm_lib_ioctl,
           .open =        snd_mychip_capture_open,
           .close =       snd_mychip_capture_close,
           .ioctl =       snd_pcm_lib_ioctl,


@@ -1920,9 +1897,9 @@
    */
 
   /* create a pcm device */
    */
 
   /* create a pcm device */

-  static int __devinit snd_mychip_new_pcm(mychip_t *chip)
+  static int __devinit snd_mychip_new_pcm(struct mychip *chip)

   {
   {

-          snd_pcm_t *pcm;
+          struct snd_pcm *pcm;

           int err;
 
           if ((err = snd_pcm_new(chip->card, "My Chip", 0, 1, 1,
           int err;
 
           if ((err = snd_pcm_new(chip->card, "My Chip", 0, 1, 1,


@@ -1959,9 +1936,9 @@
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static int __devinit snd_mychip_new_pcm(mychip_t *chip)
+  static int __devinit snd_mychip_new_pcm(struct mychip *chip)

   {
   {

-          snd_pcm_t *pcm;
+          struct snd_pcm *pcm;

           int err;
 
           if ((err = snd_pcm_new(chip->card, "My Chip", 0, 1, 1,
           int err;
 
           if ((err = snd_pcm_new(chip->card, "My Chip", 0, 1, 1,


@@ -2004,13 +1981,13 @@
       specify more numbers, but they must be handled properly in
       open/close, etc. callbacks.  When you need to know which
       substream you are referring to, then it can be obtained from
       specify more numbers, but they must be handled properly in
       open/close, etc. callbacks.  When you need to know which
       substream you are referring to, then it can be obtained from

-      <type>snd_pcm_substream_t</type> data passed to each callback
+      struct <structname>snd_pcm_substream</structname> data passed to each callback

       as follows: 
 
         <informalexample>
           <programlisting>
 <![CDATA[
       as follows: 
 
         <informalexample>
           <programlisting>
 <![CDATA[

-  snd_pcm_substream_t *substream;
+  struct snd_pcm_substream *substream;

   int index = substream->number;
 ]]>
           </programlisting>
   int index = substream->number;
 ]]>
           </programlisting>


@@ -2039,7 +2016,7 @@
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static snd_pcm_ops_t snd_mychip_playback_ops = {
+  static struct snd_pcm_ops snd_mychip_playback_ops = {

           .open =        snd_mychip_pcm_open,
           .close =       snd_mychip_pcm_close,
           .ioctl =       snd_pcm_lib_ioctl,
           .open =        snd_mychip_pcm_open,
           .close =       snd_mychip_pcm_close,
           .ioctl =       snd_pcm_lib_ioctl,


@@ -2117,18 +2094,18 @@
           <title>PCM Instance with a Destructor</title>
           <programlisting>
 <![CDATA[
           <title>PCM Instance with a Destructor</title>
           <programlisting>
 <![CDATA[

-  static void mychip_pcm_free(snd_pcm_t *pcm)
+  static void mychip_pcm_free(struct snd_pcm *pcm)

   {
   {

-          mychip_t *chip = snd_pcm_chip(pcm);
+          struct mychip *chip = snd_pcm_chip(pcm);

           /* free your own data */
           kfree(chip->my_private_pcm_data);
           // do what you like else
           ....
   }
 
           /* free your own data */
           kfree(chip->my_private_pcm_data);
           // do what you like else
           ....
   }
 

-  static int __devinit snd_mychip_new_pcm(mychip_t *chip)
+  static int __devinit snd_mychip_new_pcm(struct mychip *chip)

   {
   {

-          snd_pcm_t *pcm;
+          struct snd_pcm *pcm;

           ....
           /* allocate your own data */
           chip->my_private_pcm_data = kmalloc(...);
           ....
           /* allocate your own data */
           chip->my_private_pcm_data = kmalloc(...);


@@ -2164,7 +2141,7 @@
 <![CDATA[
 struct _snd_pcm_runtime {
        /* -- Status -- */
 <![CDATA[
 struct _snd_pcm_runtime {
        /* -- Status -- */

-       snd_pcm_substream_t *trigger_master;
+       struct snd_pcm_substream *trigger_master;

        snd_timestamp_t trigger_tstamp; /* trigger timestamp */
        int overrange;
        snd_pcm_uframes_t avail_max;
        snd_timestamp_t trigger_tstamp; /* trigger timestamp */
        int overrange;
        snd_pcm_uframes_t avail_max;


@@ -2190,8 +2167,7 @@ struct _snd_pcm_runtime {
        unsigned int rate_den;
 
        /* -- SW params -- */
        unsigned int rate_den;
 
        /* -- SW params -- */

-       int tstamp_timespec;            /* use timeval (0) or timespec (1) */
-       snd_pcm_tstamp_t tstamp_mode;   /* mmap timestamp is updated */
+       struct timespec tstamp_mode;    /* mmap timestamp is updated */

        unsigned int period_step;
        unsigned int sleep_min;         /* min ticks to sleep */
        snd_pcm_uframes_t xfer_align;   /* xfer size need to be a multiple */
        unsigned int period_step;
        unsigned int sleep_min;         /* min ticks to sleep */
        snd_pcm_uframes_t xfer_align;   /* xfer size need to be a multiple */


@@ -2208,8 +2184,8 @@ struct _snd_pcm_runtime {
        snd_pcm_sync_id_t sync;         /* hardware synchronization ID */
 
        /* -- mmap -- */
        snd_pcm_sync_id_t sync;         /* hardware synchronization ID */
 
        /* -- mmap -- */

-       volatile snd_pcm_mmap_status_t *status;
-       volatile snd_pcm_mmap_control_t *control;
+       volatile struct snd_pcm_mmap_status *status;
+       volatile struct snd_pcm_mmap_control *control;

        atomic_t mmap_count;
 
        /* -- locking / scheduling -- */
        atomic_t mmap_count;
 
        /* -- locking / scheduling -- */


@@ -2220,15 +2196,15 @@ struct _snd_pcm_runtime {
 
        /* -- private section -- */
        void *private_data;
 
        /* -- private section -- */
        void *private_data;

-       void (*private_free)(snd_pcm_runtime_t *runtime);
+       void (*private_free)(struct snd_pcm_runtime *runtime);

 
        /* -- hardware description -- */
 
        /* -- hardware description -- */

-       snd_pcm_hardware_t hw;
-       snd_pcm_hw_constraints_t hw_constraints;
+       struct snd_pcm_hardware hw;
+       struct snd_pcm_hw_constraints hw_constraints;

 
        /* -- interrupt callbacks -- */
 
        /* -- interrupt callbacks -- */

-       void (*transfer_ack_begin)(snd_pcm_substream_t *substream);
-       void (*transfer_ack_end)(snd_pcm_substream_t *substream);
+       void (*transfer_ack_begin)(struct snd_pcm_substream *substream);
+       void (*transfer_ack_end)(struct snd_pcm_substream *substream);

 
        /* -- timer -- */
        unsigned int timer_resolution;  /* timer resolution */
 
        /* -- timer -- */
        unsigned int timer_resolution;  /* timer resolution */


@@ -2242,7 +2218,7 @@ struct _snd_pcm_runtime {
 
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
        /* -- OSS things -- */
 
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
        /* -- OSS things -- */

-       snd_pcm_oss_runtime_t oss;
+       struct snd_pcm_oss_runtime oss;

 #endif
 };
 ]]>
 #endif
 };
 ]]>


@@ -2268,7 +2244,7 @@ struct _snd_pcm_runtime {
        <section id="pcm-interface-runtime-hw">
        <title>Hardware Description</title>
        <para>
        <section id="pcm-interface-runtime-hw">
        <title>Hardware Description</title>
        <para>

-         The hardware descriptor (<type>snd_pcm_hardware_t</type>)
+         The hardware descriptor (struct <structname>snd_pcm_hardware</structname>)

        contains the definitions of the fundamental hardware
        configuration.  Above all, you'll need to define this in
        <link linkend="pcm-interface-operators-open-callback"><citetitle>
        contains the definitions of the fundamental hardware
        configuration.  Above all, you'll need to define this in
        <link linkend="pcm-interface-operators-open-callback"><citetitle>


@@ -2283,7 +2259,7 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-          snd_pcm_runtime_t *runtime = substream->runtime;
+          struct snd_pcm_runtime *runtime = substream->runtime;

           ...
           runtime->hw = snd_mychip_playback_hw; /* common definition */
           if (chip->model == VERY_OLD_ONE)
           ...
           runtime->hw = snd_mychip_playback_hw; /* common definition */
           if (chip->model == VERY_OLD_ONE)


@@ -2298,7 +2274,7 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static snd_pcm_hardware_t snd_mychip_playback_hw = {
+  static struct snd_pcm_hardware snd_mychip_playback_hw = {

           .info = (SNDRV_PCM_INFO_MMAP |
                    SNDRV_PCM_INFO_INTERLEAVED |
                    SNDRV_PCM_INFO_BLOCK_TRANSFER |
           .info = (SNDRV_PCM_INFO_MMAP |
                    SNDRV_PCM_INFO_INTERLEAVED |
                    SNDRV_PCM_INFO_BLOCK_TRANSFER |


@@ -2353,9 +2329,14 @@ struct _snd_pcm_runtime {
         <constant>PAUSE</constant> bit means that the pcm supports the
         <quote>pause</quote> operation, while the
         <constant>RESUME</constant> bit means that the pcm supports
         <constant>PAUSE</constant> bit means that the pcm supports the
         <quote>pause</quote> operation, while the
         <constant>RESUME</constant> bit means that the pcm supports

-        the <quote>suspend/resume</quote> operation. If these flags
-        are set, the <structfield>trigger</structfield> callback below
-        must handle the corresponding commands. 
+        the full <quote>suspend/resume</quote> operation.
+       If <constant>PAUSE</constant> flag is set,
+       the <structfield>trigger</structfield> callback below
+        must handle the corresponding (pause push/release) commands.
+       The suspend/resume trigger commands can be defined even without
+       <constant>RESUME</constant> flag.  See <link
+       linkend="power-management"><citetitle>
+       Power Management</citetitle></link> section for details.

         </para>
 
        <para>
         </para>
 
        <para>


@@ -2528,7 +2509,7 @@ struct _snd_pcm_runtime {
        <title>Running Status</title>
        <para>
        The running status can be referred via <constant>runtime-&gt;status</constant>.
        <title>Running Status</title>
        <para>
        The running status can be referred via <constant>runtime-&gt;status</constant>.

-       This is the pointer to <type>snd_pcm_mmap_status_t</type>
+       This is the pointer to struct <structname>snd_pcm_mmap_status</structname>

        record.  For example, you can get the current DMA hardware
        pointer via <constant>runtime-&gt;status-&gt;hw_ptr</constant>.
        </para>
        record.  For example, you can get the current DMA hardware
        pointer via <constant>runtime-&gt;status-&gt;hw_ptr</constant>.
        </para>


@@ -2536,7 +2517,7 @@ struct _snd_pcm_runtime {
        <para>
        The DMA application pointer can be referred via
        <constant>runtime-&gt;control</constant>, which points
        <para>
        The DMA application pointer can be referred via
        <constant>runtime-&gt;control</constant>, which points

-       <type>snd_pcm_mmap_control_t</type> record.
+       struct <structname>snd_pcm_mmap_control</structname> record.

        However, accessing directly to this value is not recommended.
        </para>
        </section>
        However, accessing directly to this value is not recommended.
        </para>
        </section>


@@ -2558,9 +2539,9 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_xxx_open(snd_pcm_substream_t *substream)
+  static int snd_xxx_open(struct snd_pcm_substream *substream)

   {
   {

-          my_pcm_data_t *data;
+          struct my_pcm_data *data;

           ....
           data = kmalloc(sizeof(*data), GFP_KERNEL);
           substream->runtime->private_data = data;
           ....
           data = kmalloc(sizeof(*data), GFP_KERNEL);
           substream->runtime->private_data = data;


@@ -2602,7 +2583,7 @@ struct _snd_pcm_runtime {
 
       <para>
         The callback function takes at least the argument with
 
       <para>
         The callback function takes at least the argument with

-        <type>snd_pcm_substream_t</type> pointer. For retrieving the
+        <structname>snd_pcm_substream</structname> pointer. For retrieving the

         chip record from the given substream instance, you can use the
         following macro. 
 
         chip record from the given substream instance, you can use the
         following macro. 
 


@@ -2610,7 +2591,7 @@ struct _snd_pcm_runtime {
           <programlisting>
 <![CDATA[
   int xxx() {
           <programlisting>
 <![CDATA[
   int xxx() {

-          mychip_t *chip = snd_pcm_substream_chip(substream);
+          struct mychip *chip = snd_pcm_substream_chip(substream);

           ....
   }
 ]]>
           ....
   }
 ]]>


@@ -2632,7 +2613,7 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_xxx_open(snd_pcm_substream_t *substream);
+  static int snd_xxx_open(struct snd_pcm_substream *substream);

 ]]>
             </programlisting>
           </informalexample>
 ]]>
             </programlisting>
           </informalexample>


@@ -2647,10 +2628,10 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_xxx_open(snd_pcm_substream_t *substream)
+  static int snd_xxx_open(struct snd_pcm_substream *substream)

   {
   {

-          mychip_t *chip = snd_pcm_substream_chip(substream);
-          snd_pcm_runtime_t *runtime = substream->runtime;
+          struct mychip *chip = snd_pcm_substream_chip(substream);
+          struct snd_pcm_runtime *runtime = substream->runtime;

 
           runtime->hw = snd_mychip_playback_hw;
           return 0;
 
           runtime->hw = snd_mychip_playback_hw;
           return 0;


@@ -2683,7 +2664,7 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_xxx_close(snd_pcm_substream_t *substream);
+  static int snd_xxx_close(struct snd_pcm_substream *substream);

 ]]>
             </programlisting>
           </informalexample>
 ]]>
             </programlisting>
           </informalexample>


@@ -2698,7 +2679,7 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_xxx_close(snd_pcm_substream_t *substream)
+  static int snd_xxx_close(struct snd_pcm_substream *substream)

   {
           ....
           kfree(substream->runtime->private_data);
   {
           ....
           kfree(substream->runtime->private_data);


@@ -2725,8 +2706,8 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_xxx_hw_params(snd_pcm_substream_t * substream,
-                               snd_pcm_hw_params_t * hw_params);
+  static int snd_xxx_hw_params(struct snd_pcm_substream *substream,
+                               struct snd_pcm_hw_params *hw_params);

 ]]>
             </programlisting>
           </informalexample>
 ]]>
             </programlisting>
           </informalexample>


@@ -2801,7 +2782,7 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_xxx_hw_free(snd_pcm_substream_t * substream);
+  static int snd_xxx_hw_free(struct snd_pcm_substream *substream);

 ]]>
             </programlisting>
           </informalexample>
 ]]>
             </programlisting>
           </informalexample>


@@ -2836,7 +2817,7 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_xxx_prepare(snd_pcm_substream_t * substream);
+  static int snd_xxx_prepare(struct snd_pcm_substream *substream);

 ]]>
             </programlisting>
           </informalexample>
 ]]>
             </programlisting>
           </informalexample>


@@ -2855,7 +2836,7 @@ struct _snd_pcm_runtime {
 
         <para>
        Note that this callback became non-atomic since the recent version.
 
         <para>
        Note that this callback became non-atomic since the recent version.

-       You can use schedule-related fucntions safely in this callback now.
+       You can use schedule-related functions safely in this callback now.

         </para>
 
         <para>
         </para>
 
         <para>


@@ -2885,7 +2866,7 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_xxx_trigger(snd_pcm_substream_t * substream, int cmd);
+  static int snd_xxx_trigger(struct snd_pcm_substream *substream, int cmd);

 ]]>
             </programlisting>
           </informalexample>
 ]]>
             </programlisting>
           </informalexample>


@@ -2927,8 +2908,8 @@ struct _snd_pcm_runtime {
         </para>
 
         <para>
         </para>
 
         <para>

-          When the pcm supports the suspend/resume operation
-        (i.e. <constant>SNDRV_PCM_INFO_RESUME</constant> flag is set),
+          When the pcm supports the suspend/resume operation,
+       regardless of full or partial suspend/resume support,

         <constant>SUSPEND</constant> and <constant>RESUME</constant>
         commands must be handled, too.
         These commands are issued when the power-management status is
         <constant>SUSPEND</constant> and <constant>RESUME</constant>
         commands must be handled, too.
         These commands are issued when the power-management status is


@@ -2937,6 +2918,8 @@ struct _snd_pcm_runtime {
         do suspend and resume of the pcm substream, and usually, they
         are identical with <constant>STOP</constant> and
         <constant>START</constant> commands, respectively.
         do suspend and resume of the pcm substream, and usually, they
         are identical with <constant>STOP</constant> and
         <constant>START</constant> commands, respectively.

+         See <link linkend="power-management"><citetitle>
+       Power Management</citetitle></link> section for details.

         </para>
 
         <para>
         </para>
 
         <para>


@@ -2955,7 +2938,7 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static snd_pcm_uframes_t snd_xxx_pointer(snd_pcm_substream_t * substream)
+  static snd_pcm_uframes_t snd_xxx_pointer(struct snd_pcm_substream *substream)

 ]]>
             </programlisting>
           </informalexample>
 ]]>
             </programlisting>
           </informalexample>


@@ -3083,7 +3066,7 @@ struct _snd_pcm_runtime {
   static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id,
                                           struct pt_regs *regs)
   {
   static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id,
                                           struct pt_regs *regs)
   {

-          mychip_t *chip = dev_id;
+          struct mychip *chip = dev_id;

           spin_lock(&chip->lock);
           ....
           if (pcm_irq_invoked(chip)) {
           spin_lock(&chip->lock);
           ....
           if (pcm_irq_invoked(chip)) {


@@ -3127,7 +3110,7 @@ struct _snd_pcm_runtime {
   static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id,
                                           struct pt_regs *regs)
   {
   static irqreturn_t snd_mychip_interrupt(int irq, void *dev_id,
                                           struct pt_regs *regs)
   {

-          mychip_t *chip = dev_id;
+          struct mychip *chip = dev_id;

           spin_lock(&chip->lock);
           ....
           if (pcm_irq_invoked(chip)) {
           spin_lock(&chip->lock);
           ....
           if (pcm_irq_invoked(chip)) {


@@ -3237,13 +3220,13 @@ struct _snd_pcm_runtime {
 <![CDATA[
   static unsigned int rates[] =
           {4000, 10000, 22050, 44100};
 <![CDATA[
   static unsigned int rates[] =
           {4000, 10000, 22050, 44100};

-  static snd_pcm_hw_constraint_list_t constraints_rates = {
+  static struct snd_pcm_hw_constraint_list constraints_rates = {

           .count = ARRAY_SIZE(rates),
           .list = rates,
           .mask = 0,
   };
 
           .count = ARRAY_SIZE(rates),
           .list = rates,
           .mask = 0,
   };
 

-  static int snd_mychip_pcm_open(snd_pcm_substream_t *substream)
+  static int snd_mychip_pcm_open(struct snd_pcm_substream *substream)

   {
           int err;
           ....
   {
           int err;
           ....


@@ -3265,19 +3248,20 @@ struct _snd_pcm_runtime {
         You can even define your own constraint rules.
         For example, let's suppose my_chip can manage a substream of 1 channel
         if and only if the format is S16_LE, otherwise it supports any format
         You can even define your own constraint rules.
         For example, let's suppose my_chip can manage a substream of 1 channel
         if and only if the format is S16_LE, otherwise it supports any format

-        specified in the <type>snd_pcm_hardware_t</type> stucture (or in any
+        specified in the <structname>snd_pcm_hardware</structname> stucture (or in any

         other constraint_list). You can build a rule like this:
 
         <example>
          <title>Example of Hardware Constraints for Channels</title>
          <programlisting>
 <![CDATA[
         other constraint_list). You can build a rule like this:
 
         <example>
          <title>Example of Hardware Constraints for Channels</title>
          <programlisting>
 <![CDATA[

-  static int hw_rule_format_by_channels(snd_pcm_hw_params_t *params,
-                                        snd_pcm_hw_rule_t *rule)
+  static int hw_rule_format_by_channels(struct snd_pcm_hw_params *params,
+                                        struct snd_pcm_hw_rule *rule)

   {
   {

-          snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
-          snd_mask_t *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
-          snd_mask_t fmt;
+          struct snd_interval *c = hw_param_interval(params,
+                SNDRV_PCM_HW_PARAM_CHANNELS);
+          struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+          struct snd_mask fmt;

 
           snd_mask_any(&fmt);    /* Init the struct */
           if (c->min < 2) {
 
           snd_mask_any(&fmt);    /* Init the struct */
           if (c->min < 2) {


@@ -3314,12 +3298,13 @@ struct _snd_pcm_runtime {
         <title>Example of Hardware Constraints for Channels</title>
         <programlisting>
 <![CDATA[
         <title>Example of Hardware Constraints for Channels</title>
         <programlisting>
 <![CDATA[

-  static int hw_rule_channels_by_format(snd_pcm_hw_params_t *params,
-                                        snd_pcm_hw_rule_t *rule)
+  static int hw_rule_channels_by_format(struct snd_pcm_hw_params *params,
+                                        struct snd_pcm_hw_rule *rule)

   {
   {

-          snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
-          snd_mask_t *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
-          snd_interval_t ch;
+          struct snd_interval *c = hw_param_interval(params,
+                        SNDRV_PCM_HW_PARAM_CHANNELS);
+          struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
+          struct snd_interval ch;

 
           snd_interval_any(&ch);
           if (f->bits[0] == SNDRV_PCM_FMTBIT_S16_LE) {
 
           snd_interval_any(&ch);
           if (f->bits[0] == SNDRV_PCM_FMTBIT_S16_LE) {


@@ -3392,18 +3377,18 @@ struct _snd_pcm_runtime {
       callbacks: <structfield>info</structfield>,
       <structfield>get</structfield> and
       <structfield>put</structfield>. Then, define a
       callbacks: <structfield>info</structfield>,
       <structfield>get</structfield> and
       <structfield>put</structfield>. Then, define a

-      <type>snd_kcontrol_new_t</type> record, such as: 
+      struct <structname>snd_kcontrol_new</structname> record, such as: 

 
         <example>
          <title>Definition of a Control</title>
           <programlisting>
 <![CDATA[
 
         <example>
          <title>Definition of a Control</title>
           <programlisting>
 <![CDATA[

-  static snd_kcontrol_new_t my_control __devinitdata = {
+  static struct snd_kcontrol_new my_control __devinitdata = {

           .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
           .name = "PCM Playback Switch",
           .index = 0,
           .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
           .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
           .name = "PCM Playback Switch",
           .index = 0,
           .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,

-          .private_values = 0xffff,
+          .private_value = 0xffff,

           .info = my_control_info,
           .get = my_control_get,
           .put = my_control_put
           .info = my_control_info,
           .get = my_control_get,
           .put = my_control_put


@@ -3422,10 +3407,17 @@ struct _snd_pcm_runtime {
 
       <para>
         The <structfield>iface</structfield> field specifies the type of
 
       <para>
         The <structfield>iface</structfield> field specifies the type of

-      the control,
-      <constant>SNDRV_CTL_ELEM_IFACE_XXX</constant>. There are
-      <constant>MIXER</constant>, <constant>PCM</constant>,
-      <constant>CARD</constant>, etc.
+      the control, <constant>SNDRV_CTL_ELEM_IFACE_XXX</constant>, which
+      is usually <constant>MIXER</constant>.
+      Use <constant>CARD</constant> for global controls that are not
+      logically part of the mixer.
+      If the control is closely associated with some specific device on
+      the sound card, use <constant>HWDEP</constant>,
+      <constant>PCM</constant>, <constant>RAWMIDI</constant>,
+      <constant>TIMER</constant>, or <constant>SEQUENCER</constant>, and
+      specify the device number with the
+      <structfield>device</structfield> and
+      <structfield>subdevice</structfield> fields.

       </para>
 
       <para>
       </para>
 
       <para>


@@ -3457,7 +3449,7 @@ struct _snd_pcm_runtime {
       </para>
 
       <para>
       </para>
 
       <para>

-        The <structfield>private_values</structfield> field contains
+        The <structfield>private_value</structfield> field contains

       an arbitrary long integer value for this record. When using
       generic <structfield>info</structfield>,
       <structfield>get</structfield> and
       an arbitrary long integer value for this record. When using
       generic <structfield>info</structfield>,
       <structfield>get</structfield> and


@@ -3608,7 +3600,7 @@ struct _snd_pcm_runtime {
         <para>
           The <structfield>info</structfield> callback is used to get
         the detailed information of this control. This must store the
         <para>
           The <structfield>info</structfield> callback is used to get
         the detailed information of this control. This must store the

-        values of the given <type>snd_ctl_elem_info_t</type>
+        values of the given struct <structname>snd_ctl_elem_info</structname>

         object. For example, for a boolean control with a single
         element will be: 
 
         object. For example, for a boolean control with a single
         element will be: 
 


@@ -3616,8 +3608,8 @@ struct _snd_pcm_runtime {
            <title>Example of info callback</title>
             <programlisting>
 <![CDATA[
            <title>Example of info callback</title>
             <programlisting>
 <![CDATA[

-  static int snd_myctl_info(snd_kcontrol_t *kcontrol,
-                          snd_ctl_elem_info_t *uinfo)
+  static int snd_myctl_info(struct snd_kcontrol *kcontrol,
+                          struct snd_ctl_elem_info *uinfo)

   {
           uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
           uinfo->count = 1;
   {
           uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
           uinfo->count = 1;


@@ -3651,8 +3643,8 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_myctl_info(snd_kcontrol_t *kcontrol,
-                          snd_ctl_elem_info_t *uinfo)
+  static int snd_myctl_info(struct snd_kcontrol *kcontrol,
+                          struct snd_ctl_elem_info *uinfo)

   {
           static char *texts[4] = {
                   "First", "Second", "Third", "Fourth"
   {
           static char *texts[4] = {
                   "First", "Second", "Third", "Fourth"


@@ -3687,10 +3679,10 @@ struct _snd_pcm_runtime {
            <title>Example of get callback</title>
             <programlisting>
 <![CDATA[
            <title>Example of get callback</title>
             <programlisting>
 <![CDATA[

-  static int snd_myctl_get(snd_kcontrol_t *kcontrol,
-                           snd_ctl_elem_value_t *ucontrol)
+  static int snd_myctl_get(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *ucontrol)

   {
   {

-          mychip_t *chip = snd_kcontrol_chip(kcontrol);
+          struct mychip *chip = snd_kcontrol_chip(kcontrol);

           ucontrol->value.integer.value[0] = get_some_value(chip);
           return 0;
   }
           ucontrol->value.integer.value[0] = get_some_value(chip);
           return 0;
   }


@@ -3702,8 +3694,7 @@ struct _snd_pcm_runtime {
         <para>
           Here, the chip instance is retrieved via
         <function>snd_kcontrol_chip()</function> macro.  This macro
         <para>
           Here, the chip instance is retrieved via
         <function>snd_kcontrol_chip()</function> macro.  This macro

-        converts from kcontrol-&gt;private_data to the type defined by
-        <type>chip_t</type>. The
+        just accesses to kcontrol-&gt;private_data. The

         kcontrol-&gt;private_data field is 
         given as the argument of <function>snd_ctl_new()</function>
         (see the later subsection
         kcontrol-&gt;private_data field is 
         given as the argument of <function>snd_ctl_new()</function>
         (see the later subsection


@@ -3727,8 +3718,8 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  static int snd_sbmixer_get_single(snd_kcontrol_t *kcontrol,
-                                    snd_ctl_elem_value_t *ucontrol)
+  static int snd_sbmixer_get_single(struct snd_kcontrol *kcontrol,
+                                    struct snd_ctl_elem_value *ucontrol)

   {
           int reg = kcontrol->private_value & 0xff;
           int shift = (kcontrol->private_value >> 16) & 0xff;
   {
           int reg = kcontrol->private_value & 0xff;
           int shift = (kcontrol->private_value >> 16) & 0xff;


@@ -3764,10 +3755,10 @@ struct _snd_pcm_runtime {
            <title>Example of put callback</title>
             <programlisting>
 <![CDATA[
            <title>Example of put callback</title>
             <programlisting>
 <![CDATA[

-  static int snd_myctl_put(snd_kcontrol_t *kcontrol,
-                           snd_ctl_elem_value_t *ucontrol)
+  static int snd_myctl_put(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *ucontrol)

   {
   {

-          mychip_t *chip = snd_kcontrol_chip(kcontrol);
+          struct mychip *chip = snd_kcontrol_chip(kcontrol);

           int changed = 0;
           if (chip->current_value !=
                ucontrol->value.integer.value[0]) {
           int changed = 0;
           if (chip->current_value !=
                ucontrol->value.integer.value[0]) {


@@ -3824,7 +3815,7 @@ struct _snd_pcm_runtime {
         </informalexample>
 
         where <parameter>my_control</parameter> is the
         </informalexample>
 
         where <parameter>my_control</parameter> is the

-      <type>snd_kcontrol_new_t</type> object defined above, and chip
+      struct <structname>snd_kcontrol_new</structname> object defined above, and chip

       is the object pointer to be passed to
       kcontrol-&gt;private_data 
       which can be referred in callbacks. 
       is the object pointer to be passed to
       kcontrol-&gt;private_data 
       which can be referred in callbacks. 


@@ -3832,7 +3823,7 @@ struct _snd_pcm_runtime {
 
       <para>
         <function>snd_ctl_new1()</function> allocates a new
 
       <para>
         <function>snd_ctl_new1()</function> allocates a new

-      <type>snd_kcontrol_t</type> instance (that's why the definition
+      <structname>snd_kcontrol</structname> instance (that's why the definition

       of <parameter>my_control</parameter> can be with
       <parameter>__devinitdata</parameter> 
       prefix), and <function>snd_ctl_add</function> assigns the given
       of <parameter>my_control</parameter> can be with
       <parameter>__devinitdata</parameter> 
       prefix), and <function>snd_ctl_add</function> assigns the given


@@ -3859,7 +3850,7 @@ struct _snd_pcm_runtime {
       control id pointer for the notification. The event-mask
       specifies the types of notification, for example, in the above
       example, the change of control values is notified.
       control id pointer for the notification. The event-mask
       specifies the types of notification, for example, in the above
       example, the change of control values is notified.

-      The id pointer is the pointer of <type>snd_ctl_elem_id_t</type>
+      The id pointer is the pointer of struct <structname>snd_ctl_elem_id</structname>

       to be notified.
       You can find some examples in <filename>es1938.c</filename> or
       <filename>es1968.c</filename> for hardware volume interrupts. 
       to be notified.
       You can find some examples in <filename>es1938.c</filename> or
       <filename>es1968.c</filename> for hardware volume interrupts. 


@@ -3892,35 +3883,35 @@ struct _snd_pcm_runtime {
            <title>Example of AC97 Interface</title>
             <programlisting>
 <![CDATA[
            <title>Example of AC97 Interface</title>
             <programlisting>
 <![CDATA[

-  struct snd_mychip {
+  struct mychip {

           ....
           ....

-          ac97_t *ac97;
+          struct snd_ac97 *ac97;

           ....
   };
 
           ....
   };
 

-  static unsigned short snd_mychip_ac97_read(ac97_t *ac97,
+  static unsigned short snd_mychip_ac97_read(struct snd_ac97 *ac97,

                                              unsigned short reg)
   {
                                              unsigned short reg)
   {

-          mychip_t *chip = ac97->private_data;
+          struct mychip *chip = ac97->private_data;

           ....
           // read a register value here from the codec
           return the_register_value;
   }
 
           ....
           // read a register value here from the codec
           return the_register_value;
   }
 

-  static void snd_mychip_ac97_write(ac97_t *ac97,
+  static void snd_mychip_ac97_write(struct snd_ac97 *ac97,

                                    unsigned short reg, unsigned short val)
   {
                                    unsigned short reg, unsigned short val)
   {

-          mychip_t *chip = ac97->private_data;
+          struct mychip *chip = ac97->private_data;

           ....
           // write the given register value to the codec
   }
 
           ....
           // write the given register value to the codec
   }
 

-  static int snd_mychip_ac97(mychip_t *chip)
+  static int snd_mychip_ac97(struct mychip *chip)

   {
   {

-          ac97_bus_t *bus;
-          ac97_template_t ac97;
+          struct snd_ac97_bus *bus;
+          struct snd_ac97_template ac97;

           int err;
           int err;

-          static ac97_bus_ops_t ops = {
+          static struct snd_ac97_bus_ops ops = {

                   .write = snd_mychip_ac97_write,
                   .read = snd_mychip_ac97_read,
           };
                   .write = snd_mychip_ac97_write,
                   .read = snd_mychip_ac97_read,
           };


@@ -3947,8 +3938,8 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  ac97_bus_t *bus;
-  static ac97_bus_ops_t ops = {
+  struct snd_ac97_bus *bus;
+  static struct snd_ac97_bus_ops ops = {

         .write = snd_mychip_ac97_write,
         .read = snd_mychip_ac97_read,
   };
         .write = snd_mychip_ac97_write,
         .read = snd_mychip_ac97_read,
   };


@@ -3962,13 +3953,14 @@ struct _snd_pcm_runtime {
       </para>
 
       <para>
       </para>
 
       <para>

-      And then call <function>snd_ac97_mixer()</function> with an <type>ac97_template_t</type>
+      And then call <function>snd_ac97_mixer()</function> with an
+      struct <structname>snd_ac97_template</structname>

       record together with the bus pointer created above.
 
         <informalexample>
           <programlisting>
 <![CDATA[
       record together with the bus pointer created above.
 
         <informalexample>
           <programlisting>
 <![CDATA[

-  ac97_template_t ac97;
+  struct snd_ac97_template ac97;

   int err;
 
   memset(&ac97, 0, sizeof(ac97));
   int err;
 
   memset(&ac97, 0, sizeof(ac97));


@@ -4005,10 +3997,10 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static unsigned short snd_mychip_ac97_read(ac97_t *ac97,
+  static unsigned short snd_mychip_ac97_read(struct snd_ac97 *ac97,

                                              unsigned short reg)
   {
                                              unsigned short reg)
   {

-          mychip_t *chip = ac97->private_data;
+          struct mychip *chip = ac97->private_data;

           ....
           return the_register_value;
   }
           ....
           return the_register_value;
   }


@@ -4026,7 +4018,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static void snd_mychip_ac97_write(ac97_t *ac97,
+  static void snd_mychip_ac97_write(struct snd_ac97 *ac97,

                        unsigned short reg, unsigned short val)
 ]]>
           </programlisting>
                        unsigned short reg, unsigned short val)
 ]]>
           </programlisting>


@@ -4173,7 +4165,7 @@ struct _snd_pcm_runtime {
       <title>Multiple Codecs</title>
       <para>
         When there are several codecs on the same card, you need to
       <title>Multiple Codecs</title>
       <para>
         When there are several codecs on the same card, you need to

-      call <function>snd_ac97_new()</function> multiple times with
+      call <function>snd_ac97_mixer()</function> multiple times with

       ac97.num=1 or greater. The <structfield>num</structfield> field
       specifies the codec 
       number. 
       ac97.num=1 or greater. The <structfield>num</structfield> field
       specifies the codec 
       number. 


@@ -4222,7 +4214,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  snd_rawmidi_t *rmidi;
+  struct snd_rawmidi *rmidi;

   snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, port, integrated,
                       irq, irq_flags, &rmidi);
 ]]>
   snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, port, integrated,
                       irq, irq_flags, &rmidi);
 ]]>


@@ -4263,17 +4255,17 @@ struct _snd_pcm_runtime {
         Usually, the port address corresponds to the command port and
         port + 1 corresponds to the data port. If not, you may change
         the <structfield>cport</structfield> field of
         Usually, the port address corresponds to the command port and
         port + 1 corresponds to the data port. If not, you may change
         the <structfield>cport</structfield> field of

-        <type>mpu401_t</type> manually 
-        afterward. However, <type>mpu401_t</type> pointer is not
+        struct <structname>snd_mpu401</structname> manually 
+        afterward. However, <structname>snd_mpu401</structname> pointer is not

         returned explicitly by
         <function>snd_mpu401_uart_new()</function>. You need to cast
         rmidi-&gt;private_data to
         returned explicitly by
         <function>snd_mpu401_uart_new()</function>. You need to cast
         rmidi-&gt;private_data to

-        <type>mpu401_t</type> explicitly, 
+        <structname>snd_mpu401</structname> explicitly, 

 
         <informalexample>
           <programlisting>
 <![CDATA[
 
         <informalexample>
           <programlisting>
 <![CDATA[

-  mpu401_t *mpu;
+  struct snd_mpu401 *mpu;

   mpu = rmidi->private_data;
 ]]>
           </programlisting>
   mpu = rmidi->private_data;
 ]]>
           </programlisting>


@@ -4369,7 +4361,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  snd_rawmidi_t *rmidi;
+  struct snd_rawmidi *rmidi;

   err = snd_rawmidi_new(chip->card, "MyMIDI", 0, outs, ins, &rmidi);
   if (err < 0)
           return err;
   err = snd_rawmidi_new(chip->card, "MyMIDI", 0, outs, ins, &rmidi);
   if (err < 0)
           return err;


@@ -4429,7 +4421,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static snd_rawmidi_ops_t snd_mymidi_output_ops = {
+  static struct snd_rawmidi_ops snd_mymidi_output_ops = {

           .open =    snd_mymidi_output_open,
           .close =   snd_mymidi_output_close,
           .trigger = snd_mymidi_output_trigger,
           .open =    snd_mymidi_output_open,
           .close =   snd_mymidi_output_close,
           .trigger = snd_mymidi_output_trigger,


@@ -4449,9 +4441,9 @@ struct _snd_pcm_runtime {
           <programlisting>
 <![CDATA[
   struct list_head *list;
           <programlisting>
 <![CDATA[
   struct list_head *list;

-  snd_rawmidi_substream_t *substream;
+  struct snd_rawmidi_substream *substream;

   list_for_each(list, &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) {
   list_for_each(list, &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) {

-          substream = list_entry(list, snd_rawmidi_substream_t, list);
+          substream = list_entry(list, struct snd_rawmidi_substream, list);

           sprintf(substream->name, "My MIDI Port %d", substream->number + 1);
   }
   /* same for SNDRV_RAWMIDI_STREAM_INPUT */
           sprintf(substream->name, "My MIDI Port %d", substream->number + 1);
   }
   /* same for SNDRV_RAWMIDI_STREAM_INPUT */


@@ -4473,12 +4465,12 @@ struct _snd_pcm_runtime {
 
       <para>
       If there is more than one port, your callbacks can determine the
 
       <para>
       If there is more than one port, your callbacks can determine the

-      port index from the snd_rawmidi_substream_t data passed to each
+      port index from the struct snd_rawmidi_substream data passed to each

       callback:
         <informalexample>
           <programlisting>
 <![CDATA[
       callback:
         <informalexample>
           <programlisting>
 <![CDATA[

-  snd_rawmidi_substream_t *substream;
+  struct snd_rawmidi_substream *substream;

   int index = substream->number;
 ]]>
           </programlisting>
   int index = substream->number;
 ]]>
           </programlisting>


@@ -4491,7 +4483,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static int snd_xxx_open(snd_rawmidi_substream_t *substream);
+  static int snd_xxx_open(struct snd_rawmidi_substream *substream);

 ]]>
           </programlisting>
         </informalexample>
 ]]>
           </programlisting>
         </informalexample>


@@ -4509,7 +4501,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static int snd_xxx_close(snd_rawmidi_substream_t *substream);
+  static int snd_xxx_close(struct snd_rawmidi_substream *substream);

 ]]>
           </programlisting>
         </informalexample>
 ]]>
           </programlisting>
         </informalexample>


@@ -4532,7 +4524,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static void snd_xxx_output_trigger(snd_rawmidi_substream_t *substream, int up);
+  static void snd_xxx_output_trigger(struct snd_rawmidi_substream *substream, int up);

 ]]>
           </programlisting>
         </informalexample>
 ]]>
           </programlisting>
         </informalexample>


@@ -4557,7 +4549,7 @@ struct _snd_pcm_runtime {
 <![CDATA[
   unsigned char data;
   while (snd_rawmidi_transmit_peek(substream, &data, 1) == 1) {
 <![CDATA[
   unsigned char data;
   while (snd_rawmidi_transmit_peek(substream, &data, 1) == 1) {

-          if (mychip_try_to_transmit(data))
+          if (snd_mychip_try_to_transmit(data))

                   snd_rawmidi_transmit_ack(substream, 1);
           else
                   break; /* hardware FIFO full */
                   snd_rawmidi_transmit_ack(substream, 1);
           else
                   break; /* hardware FIFO full */


@@ -4574,11 +4566,11 @@ struct _snd_pcm_runtime {
           <informalexample>
             <programlisting>
 <![CDATA[
           <informalexample>
             <programlisting>
 <![CDATA[

-  while (mychip_transmit_possible()) {
+  while (snd_mychip_transmit_possible()) {

           unsigned char data;
           if (snd_rawmidi_transmit(substream, &data, 1) != 1)
                   break; /* no more data */
           unsigned char data;
           if (snd_rawmidi_transmit(substream, &data, 1) != 1)
                   break; /* no more data */

-          mychip_transmit(data);
+          snd_mychip_transmit(data);

   }
 ]]>
             </programlisting>
   }
 ]]>
             </programlisting>


@@ -4613,7 +4605,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static void snd_xxx_input_trigger(snd_rawmidi_substream_t *substream, int up);
+  static void snd_xxx_input_trigger(struct snd_rawmidi_substream *substream, int up);

 ]]>
           </programlisting>
         </informalexample>
 ]]>
           </programlisting>
         </informalexample>


@@ -4657,7 +4649,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static void snd_xxx_drain(snd_rawmidi_substream_t *substream);
+  static void snd_xxx_drain(struct snd_rawmidi_substream *substream);

 ]]>
           </programlisting>
         </informalexample>
 ]]>
           </programlisting>
         </informalexample>


@@ -4671,7 +4663,7 @@ struct _snd_pcm_runtime {
 
         <para>
         This callback is optional.  If you do not set
 
         <para>
         This callback is optional.  If you do not set

-        <structfield>drain</structfield> in the snd_rawmidi_ops_t
+        <structfield>drain</structfield> in the struct snd_rawmidi_ops

         structure, ALSA will simply wait for 50&nbsp;milliseconds
         instead.
         </para>
         structure, ALSA will simply wait for 50&nbsp;milliseconds
         instead.
         </para>


@@ -4713,7 +4705,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  opl3_t *opl3;
+  struct snd_opl3 *opl3;

   snd_opl3_create(card, lport, rport, OPL3_HW_OPL3_XXX,
                   integrated, &opl3);
 ]]>
   snd_opl3_create(card, lport, rport, OPL3_HW_OPL3_XXX,
                   integrated, &opl3);
 ]]>


@@ -4746,7 +4738,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  opl3_t *opl3;
+  struct snd_opl3 *opl3;

   snd_opl3_new(card, OPL3_HW_OPL3_XXX, &opl3);
 ]]>
           </programlisting>
   snd_opl3_new(card, OPL3_HW_OPL3_XXX, &opl3);
 ]]>
           </programlisting>


@@ -4777,7 +4769,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  snd_hwdep_t *opl3hwdep;
+  struct snd_hwdep *opl3hwdep;

   snd_opl3_hwdep_new(opl3, 0, 1, &opl3hwdep);
 ]]>
           </programlisting>
   snd_opl3_hwdep_new(opl3, 0, 1, &opl3hwdep);
 ]]>
           </programlisting>


@@ -4814,7 +4806,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  snd_hwdep_t *hw;
+  struct snd_hwdep *hw;

   snd_hwdep_new(card, "My HWDEP", 0, &hw);
 ]]>
           </programlisting>
   snd_hwdep_new(card, "My HWDEP", 0, &hw);
 ]]>
           </programlisting>


@@ -4833,7 +4825,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  mydata_t *p = kmalloc(sizeof(*p), GFP_KERNEL);
+  struct mydata *p = kmalloc(sizeof(*p), GFP_KERNEL);

   hw->private_data = p;
   hw->private_free = mydata_free;
 ]]>
   hw->private_data = p;
   hw->private_free = mydata_free;
 ]]>


@@ -4845,9 +4837,9 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static void mydata_free(snd_hwdep_t *hw)
+  static void mydata_free(struct snd_hwdep *hw)

   {
   {

-          mydata_t *p = hw->private_data;
+          struct mydata *p = hw->private_data;

           kfree(p);
   }
 ]]>
           kfree(p);
   }
 ]]>


@@ -5071,9 +5063,9 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static int playback_copy(snd_pcm_substream_t *substream, int channel,
+  static int playback_copy(struct snd_pcm_substream *substream, int channel,

                snd_pcm_uframes_t pos, void *src, snd_pcm_uframes_t count);
                snd_pcm_uframes_t pos, void *src, snd_pcm_uframes_t count);

-  static int capture_copy(snd_pcm_substream_t *substream, int channel,
+  static int capture_copy(struct snd_pcm_substream *substream, int channel,

                snd_pcm_uframes_t pos, void *dst, snd_pcm_uframes_t count);
 ]]>
           </programlisting>
                snd_pcm_uframes_t pos, void *dst, snd_pcm_uframes_t count);
 ]]>
           </programlisting>


@@ -5154,7 +5146,7 @@ struct _snd_pcm_runtime {
         <informalexample>
           <programlisting>
 <![CDATA[
         <informalexample>
           <programlisting>
 <![CDATA[

-  static int silence(snd_pcm_substream_t *substream, int channel,
+  static int silence(struct snd_pcm_substream *substream, int channel,

                      snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
 ]]>
           </programlisting>
                      snd_pcm_uframes_t pos, snd_pcm_uframes_t count);
 ]]>
           </programlisting>


@@ -5214,14 +5206,14 @@ struct _snd_pcm_runtime {
         You need to pass the <function>snd_dma_pci_data(pci)</function>,
         where pci is the struct <structname>pci_dev</structname> pointer
         of the chip as well.
         You need to pass the <function>snd_dma_pci_data(pci)</function>,
         where pci is the struct <structname>pci_dev</structname> pointer
         of the chip as well.

-        The <type>snd_sg_buf_t</type> instance is created as
+        The <type>struct snd_sg_buf</type> instance is created as

         substream-&gt;dma_private. You can cast
         the pointer like: 
 
         <informalexample>
           <programlisting>
 <![CDATA[
         substream-&gt;dma_private. You can cast
         the pointer like: 
 
         <informalexample>
           <programlisting>
 <![CDATA[

-  snd_pcm_sgbuf_t *sgbuf = (snd_pcm_sgbuf_t*)substream->dma_private;
+  struct snd_sg_buf *sgbuf = (struct snd_sg_buf *)substream->dma_private;

 ]]>
           </programlisting>
         </informalexample>
 ]]>
           </programlisting>
         </informalexample>


@@ -5276,7 +5268,7 @@ struct _snd_pcm_runtime {
   #include <linux/vmalloc.h>
 
   /* get the physical page pointer on the given offset */
   #include <linux/vmalloc.h>
 
   /* get the physical page pointer on the given offset */

-  static struct page *mychip_page(snd_pcm_substream_t *substream,
+  static struct page *mychip_page(struct snd_pcm_substream *substream,

                                   unsigned long offset)
   {
           void *pageptr = substream->runtime->dma_area + offset;
                                   unsigned long offset)
   {
           void *pageptr = substream->runtime->dma_area + offset;


@@ -5311,7 +5303,7 @@ struct _snd_pcm_runtime {
       <informalexample>
         <programlisting>
 <![CDATA[
       <informalexample>
         <programlisting>
 <![CDATA[

-  snd_info_entry_t *entry;
+  struct snd_info_entry *entry;

   int err = snd_card_proc_new(card, "my-file", &entry);
 ]]>
         </programlisting>
   int err = snd_card_proc_new(card, "my-file", &entry);
 ]]>
         </programlisting>


@@ -5355,8 +5347,8 @@ struct _snd_pcm_runtime {
       <informalexample>
         <programlisting>
 <![CDATA[
       <informalexample>
         <programlisting>
 <![CDATA[

-  static void my_proc_read(snd_info_entry_t *entry,
-                           snd_info_buffer_t *buffer);
+  static void my_proc_read(struct snd_info_entry *entry,
+                           struct snd_info_buffer *buffer);

 ]]>
         </programlisting>
       </informalexample>
 ]]>
         </programlisting>
       </informalexample>


@@ -5371,10 +5363,10 @@ struct _snd_pcm_runtime {
       <informalexample>
         <programlisting>
 <![CDATA[
       <informalexample>
         <programlisting>
 <![CDATA[

-  static void my_proc_read(snd_info_entry_t *entry,
-                           snd_info_buffer_t *buffer)
+  static void my_proc_read(struct snd_info_entry *entry,
+                           struct snd_info_buffer *buffer)

   {
   {

-          chip_t *chip = entry->private_data;
+          struct my_chip *chip = entry->private_data;

 
           snd_iprintf(buffer, "This is my chip!\n");
           snd_iprintf(buffer, "Port = %ld\n", chip->port);
 
           snd_iprintf(buffer, "This is my chip!\n");
           snd_iprintf(buffer, "Port = %ld\n", chip->port);


@@ -5463,7 +5455,7 @@ struct _snd_pcm_runtime {
       <informalexample>
         <programlisting>
 <![CDATA[
       <informalexample>
         <programlisting>
 <![CDATA[

-  static long my_file_io_read(snd_info_entry_t *entry,
+  static long my_file_io_read(struct snd_info_entry *entry,

                               void *file_private_data,
                               struct file *file,
                               char *buf,
                               void *file_private_data,
                               struct file *file,
                               char *buf,


@@ -5498,22 +5490,60 @@ struct _snd_pcm_runtime {
       <constant>CONFIG_PM</constant>. 
     </para>
 
       <constant>CONFIG_PM</constant>. 
     </para>
 

+       <para>
+       If the driver supports the suspend/resume
+       <emphasis>fully</emphasis>, that is, the device can be
+       properly resumed to the status at the suspend is called,
+       you can set <constant>SNDRV_PCM_INFO_RESUME</constant> flag
+       to pcm info field.  Usually, this is possible when the
+       registers of ths chip can be safely saved and restored to the
+       RAM.  If this is set, the trigger callback is called with
+       <constant>SNDRV_PCM_TRIGGER_RESUME</constant> after resume
+       callback is finished. 
+       </para>
+
+       <para>
+       Even if the driver doesn't support PM fully but only the
+       partial suspend/resume is possible, it's still worthy to
+       implement suspend/resume callbacks.  In such a case, applications
+       would reset the status by calling
+       <function>snd_pcm_prepare()</function> and restart the stream
+       appropriately.  Hence, you can define suspend/resume callbacks
+       below but don't set <constant>SNDRV_PCM_INFO_RESUME</constant>
+       info flag to the PCM.
+       </para>
+       
+       <para>
+       Note that the trigger with SUSPEND can be always called when
+       <function>snd_pcm_suspend_all</function> is called,
+       regardless of <constant>SNDRV_PCM_INFO_RESUME</constant> flag.
+       The <constant>RESUME</constant> flag affects only the behavior
+       of <function>snd_pcm_resume()</function>.
+       (Thus, in theory,
+       <constant>SNDRV_PCM_TRIGGER_RESUME</constant> isn't needed
+       to be handled in the trigger callback when no
+       <constant>SNDRV_PCM_INFO_RESUME</constant> flag is set.  But,
+       it's better to keep it for compatibility reason.)
+       </para>

     <para>
     <para>

-      ALSA provides the common power-management layer. Each card driver
-      needs to have only low-level suspend and resume callbacks.
+      In the earlier version of ALSA drivers, a common
+      power-management layer was provided, but it has been removed.
+      The driver needs to define the suspend/resume hooks according to
+      the bus the device is assigned.  In the case of PCI driver, the
+      callbacks look like below:

 
       <informalexample>
         <programlisting>
 <![CDATA[
   #ifdef CONFIG_PM
 
       <informalexample>
         <programlisting>
 <![CDATA[
   #ifdef CONFIG_PM

-  static int snd_my_suspend(snd_card_t *card, pm_message_t state)
+  static int snd_my_suspend(struct pci_dev *pci, pm_message_t state)

   {
   {

-          .... // do things for suspsend
+          .... /* do things for suspsend */

           return 0;
   }
           return 0;
   }

-  static int snd_my_resume(snd_card_t *card)
+  static int snd_my_resume(struct pci_dev *pci)

   {
   {

-          .... // do things for suspsend
+          .... /* do things for suspsend */

           return 0;
   }
   #endif
           return 0;
   }
   #endif


@@ -5526,11 +5556,18 @@ struct _snd_pcm_runtime {
       The scheme of the real suspend job is as following.
 
       <orderedlist>
       The scheme of the real suspend job is as following.
 
       <orderedlist>

-        <listitem><para>Retrieve the chip data from pm_private_data field.</para></listitem>
+        <listitem><para>Retrieve the card and the chip data.</para></listitem>
+        <listitem><para>Call <function>snd_power_change_state()</function> with
+         <constant>SNDRV_CTL_POWER_D3hot</constant> to change the
+         power status.</para></listitem>

         <listitem><para>Call <function>snd_pcm_suspend_all()</function> to suspend the running PCM streams.</para></listitem>
         <listitem><para>Call <function>snd_pcm_suspend_all()</function> to suspend the running PCM streams.</para></listitem>

+       <listitem><para>If AC97 codecs are used, call
+       <function>snd_ac97_resume()</function> for each codec.</para></listitem>

         <listitem><para>Save the register values if necessary.</para></listitem>
         <listitem><para>Stop the hardware if necessary.</para></listitem>
         <listitem><para>Save the register values if necessary.</para></listitem>
         <listitem><para>Stop the hardware if necessary.</para></listitem>

-        <listitem><para>Disable the PCI device by calling <function>pci_disable_device()</function>.</para></listitem>
+        <listitem><para>Disable the PCI device by calling
+         <function>pci_disable_device()</function>.  Then, call
+          <function>pci_save_state()</function> at last.</para></listitem>

       </orderedlist>
     </para>
 
       </orderedlist>
     </para>
 


@@ -5540,18 +5577,24 @@ struct _snd_pcm_runtime {
       <informalexample>
         <programlisting>
 <![CDATA[
       <informalexample>
         <programlisting>
 <![CDATA[

-  static int mychip_suspend(snd_card_t *card, pm_message_t state)
+  static int mychip_suspend(struct pci_dev *pci, pm_message_t state)

   {
           /* (1) */
   {
           /* (1) */

-          mychip_t *chip = card->pm_private_data;
+          struct snd_card *card = pci_get_drvdata(pci);
+          struct mychip *chip = card->private_data;

           /* (2) */
           /* (2) */

-          snd_pcm_suspend_all(chip->pcm);
+          snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);

           /* (3) */
           /* (3) */

-          snd_mychip_save_registers(chip);
+          snd_pcm_suspend_all(chip->pcm);

           /* (4) */
           /* (4) */

-          snd_mychip_stop_hardware(chip);
+          snd_ac97_suspend(chip->ac97);

           /* (5) */
           /* (5) */

-          pci_disable_device(chip->pci);
+          snd_mychip_save_registers(chip);
+          /* (6) */
+          snd_mychip_stop_hardware(chip);
+          /* (7) */
+          pci_disable_device(pci);
+          pci_save_state(pci);

           return 0;
   }
 ]]>
           return 0;
   }
 ]]>


@@ -5563,14 +5606,17 @@ struct _snd_pcm_runtime {
     The scheme of the real resume job is as following.
 
     <orderedlist>
     The scheme of the real resume job is as following.
 
     <orderedlist>

-    <listitem><para>Retrieve the chip data from pm_private_data field.</para></listitem>
-    <listitem><para>Enable the pci device again by calling
-    <function>pci_enable_device()</function>.</para></listitem>
+    <listitem><para>Retrieve the card and the chip data.</para></listitem>
+    <listitem><para>Set up PCI.  First, call <function>pci_restore_state()</function>.
+       Then enable the pci device again by calling <function>pci_enable_device()</function>.
+       Call <function>pci_set_master()</function> if necessary, too.</para></listitem>

     <listitem><para>Re-initialize the chip.</para></listitem>
     <listitem><para>Restore the saved registers if necessary.</para></listitem>
     <listitem><para>Resume the mixer, e.g. calling
     <function>snd_ac97_resume()</function>.</para></listitem>
     <listitem><para>Restart the hardware (if any).</para></listitem>
     <listitem><para>Re-initialize the chip.</para></listitem>
     <listitem><para>Restore the saved registers if necessary.</para></listitem>
     <listitem><para>Resume the mixer, e.g. calling
     <function>snd_ac97_resume()</function>.</para></listitem>
     <listitem><para>Restart the hardware (if any).</para></listitem>

+    <listitem><para>Call <function>snd_power_change_state()</function> with
+       <constant>SNDRV_CTL_POWER_D0</constant> to notify the processes.</para></listitem>

     </orderedlist>
     </para>
 
     </orderedlist>
     </para>
 


@@ -5580,12 +5626,15 @@ struct _snd_pcm_runtime {
       <informalexample>
         <programlisting>
 <![CDATA[
       <informalexample>
         <programlisting>
 <![CDATA[

-  static void mychip_resume(mychip_t *chip)
+  static int mychip_resume(struct pci_dev *pci)

   {
           /* (1) */
   {
           /* (1) */

-          mychip_t *chip = card->pm_private_data;
+          struct snd_card *card = pci_get_drvdata(pci);
+          struct mychip *chip = card->private_data;

           /* (2) */
           /* (2) */

-          pci_enable_device(chip->pci);
+          pci_restore_state(pci);
+          pci_enable_device(pci);
+          pci_set_master(pci);

           /* (3) */
           snd_mychip_reinit_chip(chip);
           /* (4) */
           /* (3) */
           snd_mychip_reinit_chip(chip);
           /* (4) */


@@ -5594,6 +5643,8 @@ struct _snd_pcm_runtime {
           snd_ac97_resume(chip->ac97);
           /* (6) */
           snd_mychip_restart_chip(chip);
           snd_ac97_resume(chip->ac97);
           /* (6) */
           snd_mychip_restart_chip(chip);

+          /* (7) */
+          snd_power_change_state(card, SNDRV_CTL_POWER_D0);

           return 0;
   }
 ]]>
           return 0;
   }
 ]]>


@@ -5602,8 +5653,23 @@ struct _snd_pcm_runtime {
     </para>
 
     <para>
     </para>
 
     <para>

-      OK, we have all callbacks now. Let's set up them now. In the
-      initialization of the card, add the following: 
+       As shown in the above, it's better to save registers after
+       suspending the PCM operations via
+       <function>snd_pcm_suspend_all()</function> or
+       <function>snd_pcm_suspend()</function>.  It means that the PCM
+       streams are already stoppped when the register snapshot is
+       taken.  But, remind that you don't have to restart the PCM
+       stream in the resume callback. It'll be restarted via 
+       trigger call with <constant>SNDRV_PCM_TRIGGER_RESUME</constant>
+       when necessary.
+    </para>
+
+    <para>
+      OK, we have all callbacks now. Let's set them up. In the
+      initialization of the card, make sure that you can get the chip
+      data from the card instance, typically via
+      <structfield>private_data</structfield> field, in case you
+      created the chip data individually.

 
       <informalexample>
         <programlisting>
 
       <informalexample>
         <programlisting>


@@ -5612,33 +5678,56 @@ struct _snd_pcm_runtime {
                                const struct pci_device_id *pci_id)
   {
           ....
                                const struct pci_device_id *pci_id)
   {
           ....

-          snd_card_t *card;
-          mychip_t *chip;
+          struct snd_card *card;
+          struct mychip *chip;
+          ....
+          card = snd_card_new(index[dev], id[dev], THIS_MODULE, NULL);

           ....
           ....

-          snd_card_set_pm_callback(card, snd_my_suspend, snd_my_resume, chip);
+          chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+          ....
+          card->private_data = chip;
+          ....
+  }
+]]>
+        </programlisting>
+      </informalexample>
+
+       When you created the chip data with
+       <function>snd_card_new()</function>, it's anyway accessible
+       via <structfield>private_data</structfield> field.
+
+      <informalexample>
+        <programlisting>
+<![CDATA[
+  static int __devinit snd_mychip_probe(struct pci_dev *pci,
+                               const struct pci_device_id *pci_id)
+  {
+          ....
+          struct snd_card *card;
+          struct mychip *chip;
+          ....
+          card = snd_card_new(index[dev], id[dev], THIS_MODULE,
+                              sizeof(struct mychip));
+          ....
+          chip = card->private_data;

           ....
   }
 ]]>
         </programlisting>
       </informalexample>
 
           ....
   }
 ]]>
         </programlisting>
       </informalexample>
 

-    Here you don't have to put ifdef CONFIG_PM around, since it's already
-    checked in the header and expanded to empty if not needed.

     </para>
 
     <para>
     </para>
 
     <para>

-      If you need a space for saving the registers, you'll need to
-    allocate the buffer for it here, too, since it would be fatal
+      If you need a space for saving the registers, allocate the
+       buffer for it here, too, since it would be fatal

     if you cannot allocate a memory in the suspend phase.
     The allocated buffer should be released in the corresponding
     destructor.
     </para>
 
     <para>
     if you cannot allocate a memory in the suspend phase.
     The allocated buffer should be released in the corresponding
     destructor.
     </para>
 
     <para>

-      And next, set suspend/resume callbacks to the pci_driver,
-      This can be done by passing a macro SND_PCI_PM_CALLBACKS
-      in the pci_driver struct.  This macro is expanded to the correct
-      (global) callbacks if CONFIG_PM is set.
+      And next, set suspend/resume callbacks to the pci_driver.

 
       <informalexample>
         <programlisting>
 
       <informalexample>
         <programlisting>


@@ -5648,7 +5737,10 @@ struct _snd_pcm_runtime {
           .id_table = snd_my_ids,
           .probe = snd_my_probe,
           .remove = __devexit_p(snd_my_remove),
           .id_table = snd_my_ids,
           .probe = snd_my_probe,
           .remove = __devexit_p(snd_my_remove),

-          SND_PCI_PM_CALLBACKS
+  #ifdef CONFIG_PM
+          .suspend = snd_my_suspend,
+          .resume = snd_my_resume,
+  #endif

   };
 ]]>
         </programlisting>
   };
 ]]>
         </programlisting>


@@ -5991,32 +6083,23 @@ struct _snd_pcm_runtime {
         The first argument is the expression to evaluate, and the
       second argument is the action if it fails. When
       <constant>CONFIG_SND_DEBUG</constant>, is set, it will show an
         The first argument is the expression to evaluate, and the
       second argument is the action if it fails. When
       <constant>CONFIG_SND_DEBUG</constant>, is set, it will show an

-      error message such as <computeroutput>BUG? (xxx) (called from
-      yyy)</computeroutput>. When no debug flag is set, this is
-      ignored. 
+      error message such as <computeroutput>BUG? (xxx)</computeroutput>
+      together with stack trace.

       </para>
       </para>

-    </section>
-
-    <section id="useful-functions-snd-runtime-check">
-      <title><function>snd_runtime_check()</function></title>

       <para>
       <para>

-        This macro is quite similar with
-      <function>snd_assert()</function>. Unlike
-      <function>snd_assert()</function>, the expression is always
-      evaluated regardless of
-      <constant>CONFIG_SND_DEBUG</constant>. When
-      <constant>CONFIG_SND_DEBUG</constant> is set, the macro will
-      show a message like <computeroutput>ERROR (xx) (called from
-      yyy)</computeroutput>. 
+        When no debug flag is set, this macro is ignored. 

       </para>
     </section>
 
     <section id="useful-functions-snd-bug">
       <title><function>snd_BUG()</function></title>
       <para>
       </para>
     </section>
 
     <section id="useful-functions-snd-bug">
       <title><function>snd_BUG()</function></title>
       <para>

-        It calls <function>snd_assert(0,)</function> -- that is, just
-      prints the error message at the point. It's useful to show that
-      a fatal error happens there. 
+        It shows <computeroutput>BUG?</computeroutput> message and
+      stack trace as well as <function>snd_assert</function> at the point.
+      It's useful to show that a fatal error happens there. 
+      </para>
+      <para>
+        When no debug flag is set, this macro is ignored. 

       </para>
     </section>
   </chapter>
       </para>
     </section>
   </chapter>