Changeset 246


Ignore:
Timestamp:
Aug 22, 2007, 3:33:25 AM (13 years ago)
Author:
Brendan Oakley
Message:

Merged to ALSA 0.9.3

Location:
GPL/branches/alsa-resync1/alsa-kernel
Files:
2 added
60 edited
1 moved

Legend:

Unmodified
Added
Removed
  • GPL/branches/alsa-resync1/alsa-kernel/core/info.c

    r222 r246  
    2121
    2222#include <sound/driver.h>
     23#include <linux/version.h>
    2324#include <linux/init.h>
    2425#include <linux/vmalloc.h>
  • GPL/branches/alsa-resync1/alsa-kernel/core/makefile.os2

    r224 r246  
    3232#
    3333#===================================================================
    34 FILE1    = sound.obj init.obj memory.obj memory_wrapper.obj memalloc.obj sgbuf.obj
     34FILE1    = sound.obj init.obj memory.obj memalloc.obj sgbuf.obj
    3535FILE2    = control.obj device.obj misc.obj wrappers.obj
    3636#FILE3    = sound_oss.obj info_oss.obj isadma.obj
  • GPL/branches/alsa-resync1/alsa-kernel/core/pcm_native.c

    r232 r246  
    2121
    2222#include <sound/driver.h>
     23#include <linux/version.h>
    2324#include <linux/mm.h>
    2425#include <linux/file.h>
  • GPL/branches/alsa-resync1/alsa-kernel/core/sound.c

    r224 r246  
    2121
    2222#include <sound/driver.h>
     23#include <linux/version.h>
    2324#include <linux/init.h>
    2425#include <linux/slab.h>
  • GPL/branches/alsa-resync1/alsa-kernel/core/wrappers.c

    r224 r246  
    2020 */
    2121
    22 #include <linux/version.h>
    2322#include <linux/config.h>
    2423#include <linux/module.h>
  • GPL/branches/alsa-resync1/alsa-kernel/drivers/dummy.c

    r212 r246  
    2020
    2121#include <sound/driver.h>
     22#include <linux/version.h>
    2223#include <linux/init.h>
    2324#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
     
    5960#define MAX_BUFFER_SIZE         (256 * 1024)
    6061#define USE_FORMATS             SNDRV_PCM_FMTBIT_S32_LE
    61 #define USE_CHANNELS_MIN        10
    62 #define USE_CHANNELS_MAX        10
     62#define USE_CHANNELS_MIN        12
     63#define USE_CHANNELS_MAX        12
    6364#define USE_PERIODS_MIN         1
    6465#define USE_PERIODS_MAX         1024
  • GPL/branches/alsa-resync1/alsa-kernel/drivers/mtpav.c

    r224 r246  
    103103 *      defines
    104104 */
    105 //#define USE_FAKE_MTP //       dont actually read/write to MTP device (for debugging without an actual unit) (does not work yet)
     105//#define USE_FAKE_MTP //       don't actually read/write to MTP device (for debugging without an actual unit) (does not work yet)
    106106
    107107// parallel port usage masks
     
    587587}
    588588
    589 static void snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs)
    590 {
    591         mtpav_t *mcard = snd_magic_cast(mtpav_t, dev_id, return);
     589static irqreturn_t snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs)
     590{
     591        mtpav_t *mcard = snd_magic_cast(mtpav_t, dev_id, return IRQ_NONE);
    592592
    593593        //printk("irqh()\n");
     
    595595        snd_mtpav_read_bytes(mcard);
    596596        spin_unlock(&mcard->spinlock);
     597        return IRQ_HANDLED;
    597598}
    598599
     
    765766                goto __error;
    766767
    767         err = snd_card_register(mtp_card->card);        // dont snd_card_register until AFTER all cards reources done!
     768        err = snd_card_register(mtp_card->card);        // don't snd_card_register until AFTER all cards reources done!
    768769
    769770        //printk("snd_card_register returned %d\n", err);
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/ad1848.h

    r222 r246  
    2424
    2525#include "pcm.h"
     26#include <linux/interrupt.h>
    2627
    2728/* IO ports */
     
    165166const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction);
    166167int snd_ad1848_mixer(ad1848_t * chip);
    167 void snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs);
     168irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs);
    168169
    169170/* exported mixer stuffs */
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/adriver.h

    r234 r246  
    2222 *
    2323 */
     24
     25#include <linux/version.h>
    2426
    2527#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 2, 3)
     
    213215#endif
    214216
     217/* pm_message_t type */
     218#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 11)
     219#include <linux/pm.h>
     220#ifndef PMSG_FREEZE
     221typedef u32 /* __bitwise */ pm_message_t;
     222#define PMSG_FREEZE     3
     223#define PMSG_SUSPEND    3
     224#define PMSG_ON         0
     225#endif
     226#endif
    215227#ifndef PCI_D0
    216228#define PCI_D0     0
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/config.h

    r92 r246  
    4444#define EXPORT_SYMBOL(a)
    4545#define CONFIG_SOUND
    46 #define CONFIG_SND_VERSION      "0.0.1"
     46#define CONFIG_SND_VERSION      "0.9.3"
    4747#define ATTRIBUTE_UNUSED
    4848
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/core.h

    r224 r246  
    198198#define snd_power_lock(card)            do { (void)(card); } while (0)
    199199#define snd_power_unlock(card)          do { (void)(card); } while (0)
    200 #define snd_power_wait(card)            do { (void)(card); } while (0)
    201 #define snd_power_get_state(card) SNDRV_CTL_POWER_D0
     200static inline int snd_power_wait(snd_card_t *card, unsigned int state, struct file *file) { return 0; }
     201#define snd_power_get_state(card)       SNDRV_CTL_POWER_D0
    202202#define snd_power_change_state(card, state)     do { (void)(card); } while (0)
    203203#define snd_card_set_pm_callback(card,suspend,resume,data) -EINVAL
     
    501501#define unlikely(x)     __builtin_expect((x),0)
    502502
    503 typedef u32 /*__bitwise*/ pm_message_t;
    504 
    505 #ifndef __devexit_p
    506 #define __devexit_p(x) x
    507 #endif
    508 
    509503#define printk_ratelimit()      1
    510504
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/cs4231.h

    r215 r246  
    316316void snd_cs4231_mce_down(cs4231_t *chip);
    317317
    318 void snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs);
     318irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs);
    319319
    320320const char *snd_cs4231_chip_id(cs4231_t *chip);
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/driver.h

    r224 r246  
    2828
    2929#include <linux/config.h>
    30 #include <linux/version.h>
    3130
    3231#define SNDRV_CARDS             8       /* number of supported soundcards - don't change - minor numbers */
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/es1688.h

    r96 r246  
    2525#include "control.h"
    2626#include "pcm.h"
     27#include <linux/interrupt.h>
    2728
    2829#define ES1688_HW_AUTO          0x0000
     
    110111unsigned char snd_es1688_mixer_read(es1688_t *chip, unsigned char reg);
    111112
    112 void snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs);
     113irqreturn_t snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs);
    113114
    114115int snd_es1688_create(snd_card_t * card,
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/gus.h

    r222 r246  
    562562
    563563#if 0
    564 extern void snd_gf1_lfo_effect_interrupt(snd_gus_card_t * gus, snd_gf1_voice_t * voice);
     564extern irqreturn_t snd_gf1_lfo_effect_interrupt(snd_gus_card_t * gus, snd_gf1_voice_t * voice);
    565565#endif
    566566extern void snd_gf1_lfo_init(snd_gus_card_t * gus);
     
    667667/* gus_irq.c */
    668668
    669 void snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs);
     669irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs);
    670670#ifdef CONFIG_SND_DEBUG
    671671void snd_gus_irq_profile_init(snd_gus_card_t *gus);
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/initval.h

    r224 r246  
    135135#include <linux/interrupt.h>
    136136
    137 static void snd_legacy_empty_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
    138 {
     137static irqreturn_t snd_legacy_empty_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
     138{
     139        return IRQ_HANDLED;
    139140}
    140141
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/isapnp.h

    r234 r246  
    2222#ifndef LINUX_ISAPNP_H
    2323#define LINUX_ISAPNP_H
     24
     25#define ISAPNP_ALSA_LOCAL 1
    2426
    2527/*
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/snd_wavefront.h

    r212 r246  
    9999struct _snd_wavefront_card {
    100100        snd_wavefront_t wavefront;
    101 #ifdef __ISAPNP__
    102         struct isapnp_dev *wss;
    103         struct isapnp_dev *ctrl;
    104         struct isapnp_dev *mpu;
    105         struct isapnp_dev *synth;
    106 #endif /* CONFIG_ISAPNP */
     101#ifdef CONFIG_PNP
     102        struct pnp_dev *wss;
     103        struct pnp_dev *ctrl;
     104        struct pnp_dev *mpu;
     105        struct pnp_dev *synth;
     106#endif /* CONFIG_PNP */
    107107};
    108108
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/uda1341.h

    r224 r246  
    1616 */
    1717
    18 /* uda1341.h,v 1.4 2003/02/25 12:48:16 perex Exp */
     18/* uda1341.h,v 1.5 2003/04/19 13:34:32 perex Exp */
    1919
    2020#define UDA1341_ALSA_NAME "snd-uda1341"
     
    211211        CMD_AGC_TIME,
    212212        CMD_AGC_LEVEL,
     213#ifdef CONFIG_PM
     214        CMD_SUSPEND,
     215        CMD_RESUME,
     216#endif
    213217        CMD_LAST,
    214218};
     
    222226
    223227int __init snd_chip_uda1341_mixer_new(snd_card_t *card, struct l3_client **clnt);
    224 void __init snd_chip_uda1341_mixer_del(snd_card_t *card);
    225 
    226 #ifdef DEBUG_MODE
    227 #define DEBUG(format, args...)      do{printk(format, ##args);}while(0)
    228 #else
    229 #define DEBUG(format, args...)      /* nothing */
    230 #endif
    231 
    232 #ifdef DEBUG_FUNCTION_NAMES
    233 #define DEBUG_NAME(format, args...)     do{printk(format, ##args);}while(0)
    234 #else
    235 #define DEBUG_NAME(format, args...)     /* nothing */
    236 #endif
    237228
    238229/*
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/wavefront.h

    r96 r246  
    688688/* Allow direct user-space control over FX memory/coefficient data.
    689689   In theory this could be used to download the FX microprogram,
    690    but it would be a little slower, and involve some wierd code.
     690   but it would be a little slower, and involve some weird code.
    691691 */
    692692
  • GPL/branches/alsa-resync1/alsa-kernel/isa/ad1816a/ad1816a.c

    r224 r246  
    2323#include <linux/time.h>
    2424#include <linux/wait.h>
    25 #ifndef LINUX_ISAPNP_H
    26 #include <linux/isapnp.h>
    27 #define isapnp_card pci_bus
    28 #define isapnp_dev pci_dev
    29 #endif
     25#include <linux/pnp.h>
    3026#include <sound/core.h>
    3127#define SNDRV_GET_ID
     
    9490
    9591struct snd_card_ad1816a {
    96 #ifdef __ISAPNP__
    97         struct isapnp_dev *dev;
    98         struct isapnp_dev *devmpu;
    99 #endif  /* __ISAPNP__ */
     92        struct pnp_dev *dev;
     93        struct pnp_dev *devmpu;
    10094};
    10195
    102 static snd_card_t *snd_ad1816a_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    103 
    104 #ifdef __ISAPNP__
    105 
    106 static struct isapnp_card *snd_ad1816a_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    107 static const struct isapnp_card_id *snd_ad1816a_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    108 
    109 #define ISAPNP_AD1816A(_va, _vb, _vc, _device, _fa, _fb, _fc, _audio, _mpu401) \
    110         { \
    111                 ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    112                 .devs = { ISAPNP_DEVICE_ID(_fa, _fb, _fc, _audio), \
    113                          ISAPNP_DEVICE_ID(_fa, _fb, _fc, _mpu401), } \
    114         }
    115 
    116 static struct isapnp_card_id snd_ad1816a_pnpids[] __devinitdata = {
     96static struct pnp_card_device_id snd_ad1816a_pnpids[] __devinitdata = {
     97        /* Analog Devices AD1815 */
     98        { .id = "ADS7150", .devs = { { .id = "ADS7150" }, { .id = "ADS7151" } } },
     99        /* Analog Devices AD1816A - added by Kenneth Platz <kxp@atl.hp.com> */
     100        { .id = "ADS7181", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
     101        /* Analog Devices AD1816A - Aztech/Newcom SC-16 3D */
     102        { .id = "AZT1022", .devs = { { .id = "AZT1018" }, { .id = "AZT2002" } } },
     103        /* Highscreen Sound-Boostar 16 3D - added by Stefan Behnel */
     104        { .id = "LWC1061", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
    117105        /* Highscreen Sound-Boostar 16 3D */
    118         ISAPNP_AD1816A('M','D','K',0x1605,'A','D','S',0x7180,0x7181),
    119         /* Highscreen Sound-Boostar 16 3D - added by Stefan Behnel */
    120         ISAPNP_AD1816A('L','W','C',0x1061,'A','D','S',0x7180,0x7181),
    121         /* Analog Devices AD1815 */
    122         ISAPNP_AD1816A('A','D','S',0x7150,'A','D','S',0x7150,0x7151),
    123         /* Analog Devices AD1816A - added by Kenneth Platz <kxp@atl.hp.com> */
    124         ISAPNP_AD1816A('A','D','S',0x7181,'A','D','S',0x7180,0x7181),
     106        { .id = "MDK1605", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
     107        /* Shark Predator ISA - added by Ken Arromdee */
     108        { .id = "SMM7180", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
     109        /* Analog Devices AD1816A - Terratec AudioSystem EWS64S */
     110        { .id = "TER1112", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
    125111        /* Analog Devices AD1816A - Terratec Base 64 */
    126         ISAPNP_AD1816A('T','E','R',0x1411,'A','D','S',0x7180,0x7181),
    127         /* Analog Devices AD1816A - Terratec AudioSystem EWS64S */
    128         ISAPNP_AD1816A('T','E','R',0x1112,'A','D','S',0x7180,0x7181),
    129         /* Analog Devices AD1816A - Aztech/Newcom SC-16 3D */
    130         ISAPNP_AD1816A('A','Z','T',0x1022,'A','Z','T',0x1018,0x2002),
    131         /* Shark Predator ISA - added by Ken Arromdee */
    132         ISAPNP_AD1816A('S','M','M',0x7180,'A','D','S',0x7180,0x7181),
    133         { ISAPNP_CARD_END, }
     112        { .id = "TER1411", .devs = { { .id = "ADS7180" }, { .id = "ADS7181" } } },
     113        /* end */
     114        { .id = "" }
    134115};
    135116
    136 ISAPNP_CARD_TABLE(snd_ad1816a_pnpids);
    137 
    138 #endif  /* __ISAPNP__ */
     117MODULE_DEVICE_TABLE(pnp_card, snd_ad1816a_pnpids);
     118
    139119
    140120#define DRIVER_NAME     "snd-card-ad1816a"
    141121
    142122
    143 #ifdef __ISAPNP__
    144 static int __init snd_card_ad1816a_isapnp(int dev,
    145                                           struct snd_card_ad1816a *acard)
    146 {
    147         const struct isapnp_card_id *id = snd_ad1816a_isapnp_id[dev];
    148         struct isapnp_card *card = snd_ad1816a_isapnp_cards[dev];
    149         struct isapnp_dev *pdev;
    150 
    151         acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    152         if (acard->dev->active) {
    153                 acard->dev = NULL;
     123static int __devinit snd_card_ad1816a_pnp(int dev, struct snd_card_ad1816a *acard,
     124                                          struct pnp_card_link *card,
     125                                          const struct pnp_card_device_id *id)
     126{
     127        struct pnp_dev *pdev;
     128        struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
     129        int err;
     130
     131        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
     132        if (acard->dev == NULL) {
     133                kfree(cfg);
    154134                return -EBUSY;
    155135        }
    156         acard->devmpu = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
    157         if (acard->devmpu->active) {
    158                 acard->dev = acard->devmpu = NULL;
     136        acard->devmpu = pnp_request_card_device(card, id->devs[1].id, NULL);
     137        if (acard->devmpu == NULL) {
     138                kfree(cfg);
    159139                return -EBUSY;
    160140        }
    161141
    162142        pdev = acard->dev;
    163         if (pdev->prepare(pdev) < 0)
    164                 return -EAGAIN;
     143        pnp_init_resource_table(cfg);
    165144
    166145        if (port[dev] != SNDRV_AUTO_PORT)
    167                 isapnp_resource_change(&pdev->resource[2], port[dev], 16);
     146                pnp_resource_change(&cfg->port_resource[2], port[dev], 16);
    168147        if (fm_port[dev] != SNDRV_AUTO_PORT)
    169                 isapnp_resource_change(&pdev->resource[1], fm_port[dev], 4);
     148                pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
    170149        if (dma1[dev] != SNDRV_AUTO_DMA)
    171                 isapnp_resource_change(&pdev->dma_resource[0], dma1[dev],
    172                         1);
     150                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
    173151        if (dma2[dev] != SNDRV_AUTO_DMA)
    174                 isapnp_resource_change(&pdev->dma_resource[1], dma2[dev],
    175                         1);
     152                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
    176153        if (irq[dev] != SNDRV_AUTO_IRQ)
    177                 isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
    178 
    179         if (pdev->activate(pdev) < 0) {
    180                 printk(KERN_ERR PFX "AUDIO isapnp configure failure\n");
     154                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
     155
     156        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
     157                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
     158        err = pnp_activate_dev(pdev);
     159        if (err < 0) {
     160                printk(KERN_ERR PFX "AUDIO PnP configure failure\n");
     161                kfree(cfg);
    181162                return -EBUSY;
    182163        }
    183164
    184         port[dev] = pdev->resource[2].start;
    185         fm_port[dev] = pdev->resource[1].start;
    186         dma1[dev] = pdev->dma_resource[0].start;
    187         dma2[dev] = pdev->dma_resource[1].start;
    188         irq[dev] = pdev->irq_resource[0].start;
     165        port[dev] = pnp_port_start(pdev, 2);
     166        fm_port[dev] = pnp_port_start(pdev, 1);
     167        dma1[dev] = pnp_dma(pdev, 0);
     168        dma2[dev] = pnp_dma(pdev, 1);
     169        irq[dev] = pnp_irq(pdev, 0);
    189170
    190171        pdev = acard->devmpu;
    191         if (pdev == NULL || pdev->prepare(pdev) < 0) {
    192                 mpu_port[dev] = -1;
    193                 acard->devmpu = NULL;
    194                 return 0;
    195         }
     172        pnp_init_resource_table(cfg);
    196173
    197174        if (mpu_port[dev] != SNDRV_AUTO_PORT)
    198                 isapnp_resource_change(&pdev->resource[0], mpu_port[dev],
    199                         2);
     175                pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
    200176        if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
    201                 isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev],
    202                         1);
    203 
    204         if (pdev->activate(pdev) < 0) {
    205                 /* not fatal error */
    206                 printk(KERN_ERR PFX "MPU-401 isapnp configure failure\n");
     177                pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
     178
     179        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
     180                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
     181        err = pnp_activate_dev(pdev);
     182        if (err < 0) {
     183                printk(KERN_ERR PFX "MPU401 PnP configure failure\n");
    207184                mpu_port[dev] = -1;
    208185                acard->devmpu = NULL;
    209186        } else {
    210                 mpu_port[dev] = pdev->resource[0].start;
    211                 mpu_irq[dev] = pdev->irq_resource[0].start;
    212         }
    213 
     187                mpu_port[dev] = pnp_port_start(pdev, 0);
     188                mpu_irq[dev] = pnp_irq(pdev, 0);
     189        }
     190
     191        kfree(cfg);
    214192        return 0;
    215193}
    216194
    217 static void snd_card_ad1816a_deactivate(struct snd_card_ad1816a *acard)
    218 {
    219         if (acard->dev) {
    220                 acard->dev->deactivate(acard->dev);
    221                 acard->dev = NULL;
    222         }
    223         if (acard->devmpu) {
    224                 acard->devmpu->deactivate(acard->devmpu);
    225                 acard->devmpu = NULL;
    226         }
    227 }
    228 #endif  /* __ISAPNP__ */
    229 
    230 static void snd_card_ad1816a_free(snd_card_t *card)
    231 {
    232         struct snd_card_ad1816a *acard = (struct snd_card_ad1816a *)card->private_data;
    233 
    234         if (acard) {
    235 #ifdef __ISAPNP__
    236                 snd_card_ad1816a_deactivate(acard);
    237 #endif  /* __ISAPNP__ */
    238         }
    239 }
    240 
    241 static int __init snd_card_ad1816a_probe(int dev)
     195static int __devinit snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard,
     196                                            const struct pnp_card_device_id *pid)
    242197{
    243198        int error;
     
    251206                return -ENOMEM;
    252207        acard = (struct snd_card_ad1816a *)card->private_data;
    253         card->private_free = snd_card_ad1816a_free;
    254 
    255 #ifdef __ISAPNP__
    256         if ((error = snd_card_ad1816a_isapnp(dev, acard))) {
    257                 snd_card_free(card);
    258                 return error;
    259         }
    260 #else
    261         printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
    262         return -ENOSYS;
    263 #endif  /* __ISAPNP__ */
     208
     209        if ((error = snd_card_ad1816a_pnp(dev, acard, pcard, pid))) {
     210                snd_card_free(card);
     211                return error;
     212        }
    264213
    265214        if ((error = snd_ad1816a_create(card, port[dev],
     
    315264                return error;
    316265        }
    317         snd_ad1816a_cards[dev] = card;
     266        pnp_set_card_drvdata(pcard, card);
    318267        return 0;
    319268}
    320269
    321 #ifdef __ISAPNP__
    322 static int __init snd_ad1816a_isapnp_detect(struct isapnp_card *card,
    323                                             const struct isapnp_card_id *id)
     270static int __devinit snd_ad1816a_pnp_detect(struct pnp_card_link *card,
     271                                            const struct pnp_card_device_id *id)
    324272{
    325273        static int dev;
     
    329277                if (!enable[dev])
    330278                        continue;
    331                 snd_ad1816a_isapnp_cards[dev] = card;
    332                 snd_ad1816a_isapnp_id[dev] = id;
    333                 res = snd_card_ad1816a_probe(dev);
     279                res = snd_card_ad1816a_probe(dev, card, id);
    334280                if (res < 0)
    335281                        return res;
     
    339285        return -ENODEV;
    340286}
    341 #endif
     287
     288static void __devexit snd_ad1816a_pnp_remove(struct pnp_card_link * pcard)
     289{
     290        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     291
     292        snd_card_disconnect(card);
     293        snd_card_free_in_thread(card);
     294}
     295
     296static struct pnp_card_driver ad1816a_pnpc_driver = {
     297        .flags          = PNP_DRIVER_RES_DISABLE,
     298        .name           = "ad1816a",
     299        .id_table       = snd_ad1816a_pnpids,
     300        .probe          = snd_ad1816a_pnp_detect,
     301        .remove         = __devexit_p(snd_ad1816a_pnp_remove),
     302};
    342303
    343304static int __init alsa_card_ad1816a_init(void)
     
    345306        int cards = 0;
    346307
    347 #ifdef __ISAPNP__
    348         cards += isapnp_probe_cards(snd_ad1816a_pnpids, snd_ad1816a_isapnp_detect);
    349 #else
    350         printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
    351 #endif
     308        cards += pnp_register_card_driver(&ad1816a_pnpc_driver);
    352309#ifdef MODULE
    353         if (!cards)
     310        if (!cards) {
     311                pnp_unregister_card_driver(&ad1816a_pnpc_driver);
    354312                printk(KERN_ERR "no AD1816A based soundcards found.\n");
     313        }
    355314#endif  /* MODULE */
    356315        return cards ? 0 : -ENODEV;
     
    359318static void __exit alsa_card_ad1816a_exit(void)
    360319{
    361         int dev;
    362 
    363         for (dev = 0; dev < SNDRV_CARDS; dev++)
    364                 snd_card_free(snd_ad1816a_cards[dev]);
     320        pnp_unregister_card_driver(&ad1816a_pnpc_driver);
    365321}
    366322
  • GPL/branches/alsa-resync1/alsa-kernel/isa/ad1816a/ad1816a_lib.c

    r210 r246  
    310310
    311311
    312 static void snd_ad1816a_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    313 {
    314         ad1816a_t *chip = snd_magic_cast(ad1816a_t, dev_id, return);
     312static irqreturn_t snd_ad1816a_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     313{
     314        ad1816a_t *chip = snd_magic_cast(ad1816a_t, dev_id, return IRQ_NONE);
    315315        unsigned char status;
    316316
     
    331331        snd_ad1816a_out(chip, AD1816A_INTERRUPT_STATUS, 0x00);
    332332        spin_unlock(&chip->lock);
     333        return IRQ_HANDLED;
    333334}
    334335
  • GPL/branches/alsa-resync1/alsa-kernel/isa/ad1848/ad1848_lib.c

    r224 r246  
    586586}
    587587
    588 void snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    589 {
    590         ad1848_t *chip = snd_magic_cast(ad1848_t, dev_id, return);
     588irqreturn_t snd_ad1848_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     589{
     590        ad1848_t *chip = snd_magic_cast(ad1848_t, dev_id, return IRQ_NONE);
    591591
    592592        if ((chip->mode & AD1848_MODE_PLAY) && chip->playback_substream &&
     
    597597                snd_pcm_period_elapsed(chip->capture_substream);
    598598        outb(0, AD1848P(chip, STATUS)); /* clear global interrupt bit */
     599        return IRQ_HANDLED;
    599600}
    600601
  • GPL/branches/alsa-resync1/alsa-kernel/isa/als100.c

    r224 r246  
    2525#include <linux/wait.h>
    2626#include <linux/time.h>
    27 #ifndef LINUX_ISAPNP_H
    28 #include <linux/isapnp.h>
    29 #define isapnp_card pci_bus
    30 #define isapnp_dev pci_dev
    31 #endif
     27#include <linux/pnp.h>
    3228#include <sound/core.h>
    3329#define SNDRV_GET_ID
     
    9793
    9894struct snd_card_als100 {
    99 #ifdef __ISAPNP__
    100         struct isapnp_dev *dev;
    101         struct isapnp_dev *devmpu;
    102         struct isapnp_dev *devopl;
    103 #endif  /* __ISAPNP__ */
     95        int dev_no;
     96        struct pnp_dev *dev;
     97        struct pnp_dev *devmpu;
     98        struct pnp_dev *devopl;
    10499};
    105100
    106 static snd_card_t *snd_als100_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    107 
    108 #ifdef __ISAPNP__
    109 static struct isapnp_card *snd_als100_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    110 static const struct isapnp_card_id *snd_als100_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    111 
    112 #define ISAPNP_ALS100(_va, _vb, _vc, _device, _audio, _mpu401, _opl) \
    113         { \
    114                 ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    115                 .devs = { ISAPNP_DEVICE_ID('@', '@', '@', _audio), \
    116                          ISAPNP_DEVICE_ID('@', 'X', '@', _mpu401), \
    117                          ISAPNP_DEVICE_ID('@', 'H', '@', _opl) } \
    118         }
    119 
    120 static struct isapnp_card_id snd_als100_pnpids[] __devinitdata = {
     101static struct pnp_card_device_id snd_als100_pnpids[] __devinitdata = {
    121102        /* ALS100 - PRO16PNP */
    122         ISAPNP_ALS100('A','L','S',0x0001,0x0001,0x0001,0x0001),
     103        { .id = "ALS0001", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } } },
    123104        /* ALS110 - MF1000 - Digimate 3D Sound */
    124         ISAPNP_ALS100('A','L','S',0x0110,0x1001,0x1001,0x1001),
     105        { .id = "ALS0110", .devs = { { "@@@1001" }, { "@X@1001" }, { "@H@1001" } } },
    125106        /* ALS120 */
    126         ISAPNP_ALS100('A','L','S',0x0120,0x2001,0x2001,0x2001),
     107        { .id = "ALS0120", .devs = { { "@@@2001" }, { "@X@2001" }, { "@H@2001" } } },
    127108        /* ALS200 */
    128         ISAPNP_ALS100('A','L','S',0x0200,0x0020,0x0020,0x0001),
     109        { .id = "ALS0200", .devs = { { "@@@0020" }, { "@X@0020" }, { "@H@0001" } } },
    129110        /* RTL3000 */
    130         ISAPNP_ALS100('R','T','L',0x3000,0x2001,0x2001,0x2001),
    131         { ISAPNP_CARD_END, }
     111        { .id = "RTL3000", .devs = { { "@@@2001" }, { "@X@2001" }, { "@H@2001" } } },
     112        { .id = "", } /* end */
    132113};
    133114
    134 ISAPNP_CARD_TABLE(snd_als100_pnpids);
    135 
    136 #endif  /* __ISAPNP__ */
     115MODULE_DEVICE_TABLE(pnp_card, snd_als100_pnpids);
    137116
    138117#define DRIVER_NAME     "snd-card-als100"
    139118
    140 
    141 #ifdef __ISAPNP__
    142 static int __init snd_card_als100_isapnp(int dev, struct snd_card_als100 *acard)
    143 {
    144         const struct isapnp_card_id *id = snd_als100_isapnp_id[dev];
    145         struct isapnp_card *card = snd_als100_isapnp_cards[dev];
    146         struct isapnp_dev *pdev;
    147 
    148         acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    149         if (acard->dev->active) {
    150                 acard->dev = NULL;
    151                 return -EBUSY;
    152         }
    153         acard->devmpu = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
    154         if (acard->devmpu->active) {
    155                 acard->dev = acard->devmpu = NULL;
    156                 return -EBUSY;
    157         }
    158         acard->devopl = isapnp_find_dev(card, id->devs[2].vendor, id->devs[2].function, NULL);
    159         if (acard->devopl->active) {
    160                 acard->dev = acard->devmpu = acard->devopl = NULL;
    161                 return -EBUSY;
    162         }
     119static int __devinit snd_card_als100_pnp(int dev, struct snd_card_als100 *acard,
     120                                         struct pnp_card_link *card,
     121                                         const struct pnp_card_device_id *id)
     122{
     123        struct pnp_dev *pdev;
     124        struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
     125        int err;
     126
     127        if (!cfg)
     128                return -ENOMEM;
     129        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
     130        if (acard->dev == NULL) {
     131                kfree(cfg);
     132                return -ENODEV;
     133        }
     134        acard->devmpu = pnp_request_card_device(card, id->devs[1].id, acard->dev);
     135        acard->devopl = pnp_request_card_device(card, id->devs[2].id, acard->devmpu);
    163136
    164137        pdev = acard->dev;
    165         if (pdev->prepare(pdev)<0)
    166                 return -EAGAIN;
    167 
     138
     139        pnp_init_resource_table(cfg);
     140
     141        /* override resources */
    168142        if (port[dev] != SNDRV_AUTO_PORT)
    169                 isapnp_resource_change(&pdev->resource[0], port[dev], 16);
     143                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
    170144        if (dma8[dev] != SNDRV_AUTO_DMA)
    171                 isapnp_resource_change(&pdev->dma_resource[0], dma8[dev],
    172                         1);
     145                pnp_resource_change(&cfg->dma_resource[0], dma8[dev], 1);
    173146        if (dma16[dev] != SNDRV_AUTO_DMA)
    174                 isapnp_resource_change(&pdev->dma_resource[1], dma16[dev],
    175                         1);
     147                pnp_resource_change(&cfg->dma_resource[1], dma16[dev], 1);
    176148        if (irq[dev] != SNDRV_AUTO_IRQ)
    177                 isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
    178 
    179         if (pdev->activate(pdev)<0) {
    180                 printk(KERN_ERR PFX "AUDIO isapnp configure failure\n");
    181                 return -EBUSY;
    182         }
    183 
    184         port[dev] = pdev->resource[0].start;
    185         dma8[dev] = pdev->dma_resource[1].start;
    186         dma16[dev] = pdev->dma_resource[0].start;
    187         irq[dev] = pdev->irq_resource[0].start;
     149                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
     150        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
     151                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
     152        err = pnp_activate_dev(pdev);
     153        if (err < 0) {
     154                snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n");
     155                kfree(cfg);
     156                return err;
     157        }
     158        port[dev] = pnp_port_start(pdev, 0);
     159        dma8[dev] = pnp_dma(pdev, 1);
     160        dma16[dev] = pnp_dma(pdev, 0);
     161        irq[dev] = pnp_irq(pdev, 0);
    188162
    189163        pdev = acard->devmpu;
    190         if (pdev == NULL || pdev->prepare(pdev)<0) {
    191                 mpu_port[dev] = -1;
    192                 return 0;
    193         }
    194 
     164        if (pdev != NULL) {
     165                pnp_init_resource_table(cfg);
    195166        if (mpu_port[dev] != SNDRV_AUTO_PORT)
    196                 isapnp_resource_change(&pdev->resource[0], mpu_port[dev],
    197                         2);
     167                        pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
    198168        if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
    199                 isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev],
    200                         1);
    201 
    202         if (pdev->activate(pdev)<0) {
    203                 printk(KERN_ERR PFX "MPU-401 isapnp configure failure\n");
    204                 mpu_port[dev] = -1;
    205                 acard->devmpu = NULL;
     169                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
     170                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
     171                        snd_printk(KERN_ERR PFX "MPU401 the requested resources are invalid, using auto config\n");
     172                err = pnp_activate_dev(pdev);
     173                if (err < 0)
     174                        goto __mpu_error;
     175                mpu_port[dev] = pnp_port_start(pdev, 0);
     176                mpu_irq[dev] = pnp_irq(pdev, 0);
    206177        } else {
    207                 mpu_port[dev] = pdev->resource[0].start;
    208                 mpu_irq[dev] = pdev->irq_resource[0].start;
     178             __mpu_error:
     179                if (pdev) {
     180                        pnp_release_card_device(pdev);
     181                        snd_printk(KERN_ERR PFX "MPU401 pnp configure failure, skipping\n");
     182                }
     183                acard->devmpu = NULL;
     184                mpu_port[dev] = -1;
    209185        }
    210186
    211187        pdev = acard->devopl;
    212         if (pdev == NULL || pdev->prepare(pdev)<0) {
    213                 fm_port[dev] = -1;
    214                 return 0;
    215         }
    216 
    217         if (fm_port[dev] != SNDRV_AUTO_PORT)
    218                 isapnp_resource_change(&pdev->resource[0], fm_port[dev], 4);
    219 
    220         if (pdev->activate(pdev)<0) {
    221                 printk(KERN_ERR PFX "OPL isapnp configure failure\n");
    222                 fm_port[dev] = -1;
     188        if (pdev != NULL) {
     189                pnp_init_resource_table(cfg);
     190                if (fm_port[dev] != SNDRV_AUTO_PORT)
     191                        pnp_resource_change(&cfg->port_resource[0], fm_port[dev], 4);
     192                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
     193                        snd_printk(KERN_ERR PFX "OPL3 the requested resources are invalid, using auto config\n");
     194                err = pnp_activate_dev(pdev);
     195                if (err < 0)
     196                        goto __fm_error;
     197                fm_port[dev] = pnp_port_start(pdev, 0);
     198        } else {
     199              __fm_error:
     200                if (pdev) {
     201                        pnp_release_card_device(pdev);
     202                        snd_printk(KERN_ERR PFX "OPL3 pnp configure failure, skipping\n");
     203                }
    223204                acard->devopl = NULL;
    224         } else {
    225                 fm_port[dev] = pdev->resource[0].start;
    226         }
    227 
     205                fm_port[dev] = -1;
     206        }
     207
     208        kfree(cfg);
    228209        return 0;
    229210}
    230211
    231 static void snd_card_als100_deactivate(struct snd_card_als100 *acard)
    232 {
    233         if (acard->dev) {
    234                 acard->dev->deactivate(acard->dev);
    235                 acard->dev = NULL;
    236         }
    237         if (acard->devmpu) {
    238                 acard->devmpu->deactivate(acard->devmpu);
    239                 acard->devmpu = NULL;
    240         }
    241         if (acard->devopl) {
    242                 acard->devopl->deactivate(acard->devopl);
    243                 acard->devopl = NULL;
    244         }
    245 }
    246 #endif  /* __ISAPNP__ */
    247 
    248 static void snd_card_als100_free(snd_card_t *card)
    249 {
    250         struct snd_card_als100 *acard = (struct snd_card_als100 *)card->private_data;
    251 
    252         if (acard) {
    253 #ifdef __ISAPNP__
    254                 snd_card_als100_deactivate(acard);
    255 #endif  /* __ISAPNP__ */
    256         }
    257 }
    258 
    259 static int __init snd_card_als100_probe(int dev)
     212static int __init snd_card_als100_probe(int dev,
     213                                        struct pnp_card_link *pcard,
     214                                        const struct pnp_card_device_id *pid)
    260215{
    261216        int error;
     
    269224                return -ENOMEM;
    270225        acard = (struct snd_card_als100 *)card->private_data;
    271         card->private_free = snd_card_als100_free;
    272 
    273 #ifdef __ISAPNP__
    274         if ((error = snd_card_als100_isapnp(dev, acard))) {
    275                 snd_card_free(card);
    276                 return error;
    277         }
    278 #else
    279         printk(KERN_ERR PFX "you have to enable PnP support ...\n");
    280         snd_card_free(card);
    281         return -ENOSYS;
    282 #endif  /* __ISAPNP__ */
     226
     227        if ((error = snd_card_als100_pnp(dev, acard, pcard, pid))) {
     228                snd_card_free(card);
     229                return error;
     230        }
    283231
    284232        if ((error = snd_sbdsp_create(card, port[dev],
     
    307255                                        mpu_irq[dev], SA_INTERRUPT,
    308256                                        NULL) < 0)
    309                         printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
     257                        snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
    310258        }
    311259
     
    314262                                    fm_port[dev], fm_port[dev] + 2,
    315263                                    OPL3_HW_AUTO, 0, &opl3) < 0) {
    316                         printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
     264                        snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
    317265                                fm_port[dev], fm_port[dev] + 2);
    318266                } else {
     
    337285                return error;
    338286        }
    339         snd_als100_cards[dev] = card;
     287        pnp_set_card_drvdata(pcard, card);
    340288        return 0;
    341289}
    342290
    343 #ifdef __ISAPNP__
    344 static int __init snd_als100_isapnp_detect(struct isapnp_card *card,
    345                                            const struct isapnp_card_id *id)
     291static int __devinit snd_als100_pnp_detect(struct pnp_card_link *card,
     292                                           const struct pnp_card_device_id *id)
    346293{
    347294        static int dev;
     
    351298                if (!enable[dev])
    352299                        continue;
    353                 snd_als100_isapnp_cards[dev] = card;
    354                 snd_als100_isapnp_id[dev] = id;
    355                 res = snd_card_als100_probe(dev);
     300                res = snd_card_als100_probe(dev, card, id);
    356301                if (res < 0)
    357302                        return res;
     
    361306        return -ENODEV;
    362307}
    363 #endif
     308
     309static void __devexit snd_als100_pnp_remove(struct pnp_card_link * pcard)
     310{
     311        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     312
     313        snd_card_disconnect(card);
     314        snd_card_free_in_thread(card);
     315}
     316
     317static struct pnp_card_driver als100_pnpc_driver = {
     318        .flags          = PNP_DRIVER_RES_DISABLE,
     319        .name           = "als100",
     320        .id_table       = snd_als100_pnpids,
     321        .probe          = snd_als100_pnp_detect,
     322        .remove         = __devexit_p(snd_als100_pnp_remove),
     323};
    364324
    365325static int __init alsa_card_als100_init(void)
     
    367327        int cards = 0;
    368328
    369 #ifdef __ISAPNP__
    370         cards += isapnp_probe_cards(snd_als100_pnpids, snd_als100_isapnp_detect);
    371 #else
    372         printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
    373 #endif
     329        cards += pnp_register_card_driver(&als100_pnpc_driver);
    374330#ifdef MODULE
    375         if (!cards)
    376                 printk(KERN_ERR "no ALS100 based soundcards found\n");
     331        if (!cards) {
     332                pnp_unregister_card_driver(&als100_pnpc_driver);
     333                snd_printk(KERN_ERR "no ALS100 based soundcards found\n");
     334        }
    377335#endif
    378336        return cards ? 0 : -ENODEV;
     
    381339static void __exit alsa_card_als100_exit(void)
    382340{
    383         int dev;
    384 
    385         for (dev = 0; dev < SNDRV_CARDS; dev++)
    386                 snd_card_free(snd_als100_cards[dev]);
     341        pnp_unregister_card_driver(&als100_pnpc_driver);
    387342}
    388343
  • GPL/branches/alsa-resync1/alsa-kernel/isa/azt2320.c

    r224 r246  
    3737#include <linux/time.h>
    3838#include <linux/wait.h>
     39#include <linux/pnp.h>
    3940#include <sound/core.h>
    4041#define SNDRV_GET_ID
     
    105106
    106107struct snd_card_azt2320 {
    107 #ifdef __ISAPNP__
    108         struct isapnp_dev *dev;
    109         struct isapnp_dev *devmpu;
    110 #endif  /* __ISAPNP__ */
     108#ifdef CONFIG_PNP
     109        int dev_no;
     110        struct pnp_dev *dev;
     111        struct pnp_dev *devmpu;
     112#endif  /* CONFIG_PNP */
    111113};
    112114
    113 static snd_card_t *snd_azt2320_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    114 
    115 #ifdef __ISAPNP__
    116 
    117 static struct isapnp_card *snd_azt2320_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    118 static const struct isapnp_card_id *snd_azt2320_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    119 
    120 #define ISAPNP_AZT2320(_va, _vb, _vc, _device, _audio, _mpu401) \
    121         { \
    122                 ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    123                 .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    124                          ISAPNP_DEVICE_ID(_va, _vb, _vc, _mpu401), } \
    125         }
    126 
    127 static struct isapnp_card_id snd_azt2320_pnpids[] __devinitdata = {
     115static struct pnp_card_device_id snd_azt2320_pnpids[] __devinitdata = {
    128116        /* PRO16V */
    129         ISAPNP_AZT2320('A','Z','T',0x1008,0x1008,0x2001),
     117        { .id = "AZT1008", .devs = { { "AZT1008" }, { "AZT2001" }, } },
    130118        /* Aztech Sound Galaxy 16 */
    131         ISAPNP_AZT2320('A','Z','T',0x2320,0x0001,0x0002),
     119        { .id = "AZT2320", .devs = { { "AZT0001" }, { "AZT0002" }, } },
    132120        /* Packard Bell Sound III 336 AM/SP */
    133         ISAPNP_AZT2320('A','Z','T',0x3000,0x1003,0x2001),
     121        { .id = "AZT3000", .devs = { { "AZT1003" }, { "AZT2001" }, } },
    134122        /* AT3300 */
    135         ISAPNP_AZT2320('A','Z','T',0x3002,0x1004,0x2001),
     123        { .id = "AZT3002", .devs = { { "AZT1004" }, { "AZT2001" }, } },
    136124        /* --- */
    137         ISAPNP_AZT2320('A','Z','T',0x3005,0x1003,0x2001),
     125        { .id = "AZT3005", .devs = { { "AZT1003" }, { "AZT2001" }, } },
    138126        /* --- */
    139         ISAPNP_AZT2320('A','Z','T',0x3011,0x1003,0x2001),
    140         { ISAPNP_CARD_END, }    /* end */
     127        { .id = "AZT3011", .devs = { { "AZT1003" }, { "AZT2001" }, } },
     128        { .id = "" }    /* end */
    141129};
    142130
    143 ISAPNP_CARD_TABLE(snd_azt2320_pnpids);
    144 
    145 #endif  /* __ISAPNP__ */
     131MODULE_DEVICE_TABLE(pnp_card, snd_azt2320_pnpids);
    146132
    147133#define DRIVER_NAME     "snd-card-azt2320"
    148134
    149 
    150 #ifdef __ISAPNP__
    151 static int __init snd_card_azt2320_isapnp(int dev, struct snd_card_azt2320 *acard)
    152 {
    153         const struct isapnp_card_id *id = snd_azt2320_isapnp_id[dev];
    154         struct isapnp_card *card = snd_azt2320_isapnp_cards[dev];
    155         struct isapnp_dev *pdev;
    156 
    157         acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    158         if (acard->dev->active) {
    159                 acard->dev = NULL;
    160                 return -EBUSY;
    161         }
    162         acard->devmpu = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
    163         if (acard->devmpu->active) {
    164                 acard->dev = acard->devmpu = NULL;
    165                 return -EBUSY;
    166         }
     135static int __devinit snd_card_azt2320_pnp(int dev, struct snd_card_azt2320 *acard,
     136                                          struct pnp_card_link *card,
     137                                          const struct pnp_card_device_id *id)
     138{
     139        struct pnp_dev *pdev;
     140        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
     141        int err;
     142
     143        if (!cfg)
     144                return -ENOMEM;
     145
     146        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
     147        if (acard->dev == NULL) {
     148                kfree(cfg);
     149                return -ENODEV;
     150        }
     151
     152        acard->devmpu = pnp_request_card_device(card, id->devs[1].id, NULL);
    167153
    168154        pdev = acard->dev;
    169         if (pdev->prepare(pdev) < 0)
    170                 return -EAGAIN;
    171 
     155        pnp_init_resource_table(cfg);
     156
     157        /* override resources */
    172158        if (port[dev] != SNDRV_AUTO_PORT)
    173                 isapnp_resource_change(&pdev->resource[0], port[dev], 16);
     159                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
    174160        if (fm_port[dev] != SNDRV_AUTO_PORT)
    175                 isapnp_resource_change(&pdev->resource[1], fm_port[dev], 4);
     161                pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
    176162        if (wss_port[dev] != SNDRV_AUTO_PORT)
    177                 isapnp_resource_change(&pdev->resource[2], wss_port[dev],
    178                         4);
     163                pnp_resource_change(&cfg->port_resource[2], wss_port[dev], 4);
    179164        if (dma1[dev] != SNDRV_AUTO_DMA)
    180                 isapnp_resource_change(&pdev->dma_resource[0], dma1[dev],
    181                         1);
     165                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
    182166        if (dma2[dev] != SNDRV_AUTO_DMA)
    183                 isapnp_resource_change(&pdev->dma_resource[1], dma2[dev],
    184                         1);
     167                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
    185168        if (irq[dev] != SNDRV_AUTO_IRQ)
    186                 isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
    187 
    188         if (pdev->activate(pdev) < 0) {
    189                 printk(KERN_ERR PFX "AUDIO isapnp configure failure\n");
    190                 return -EBUSY;
    191         }
    192 
    193         port[dev] = pdev->resource[0].start;
    194         fm_port[dev] = pdev->resource[1].start;
    195         wss_port[dev] = pdev->resource[2].start;
    196         dma1[dev] = pdev->dma_resource[0].start;
    197         dma2[dev] = pdev->dma_resource[1].start;
    198         irq[dev] = pdev->irq_resource[0].start;
     169                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
     170        if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
     171                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
     172
     173        err = pnp_activate_dev(pdev);
     174        if (err < 0) {
     175                snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n");
     176                kfree(cfg);
     177                return err;
     178        }
     179        port[dev] = pnp_port_start(pdev, 0);
     180        fm_port[dev] = pnp_port_start(pdev, 1);
     181        wss_port[dev] = pnp_port_start(pdev, 2);
     182        dma1[dev] = pnp_dma(pdev, 0);
     183        dma2[dev] = pnp_dma(pdev, 1);
     184        irq[dev] = pnp_irq(pdev, 0);
    199185
    200186        pdev = acard->devmpu;
    201         if (pdev == NULL || pdev->prepare(pdev) < 0) {
    202                 mpu_port[dev] = -1;
    203                 return 0;
    204         }
    205 
     187        if (pdev != NULL) {
     188                pnp_init_resource_table(cfg);
    206189        if (mpu_port[dev] != SNDRV_AUTO_PORT)
    207                 isapnp_resource_change(&pdev->resource[0], mpu_port[dev],
    208                         2);
     190                        pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
    209191        if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
    210                 isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev],
    211                         1);
    212 
    213         if (pdev->activate(pdev) < 0) {
    214                 /* not fatal error */
    215                 printk(KERN_ERR PFX "MPU-401 isapnp configure failure\n");
    216                 mpu_port[dev] = -1;
    217                 acard->devmpu = NULL;
     192                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
     193                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
     194                        snd_printk(KERN_ERR PFX "MPU401 the requested resources are invalid, using auto config\n");
     195                err = pnp_activate_dev(pdev);
     196                if (err < 0)
     197                        goto __mpu_error;
     198                mpu_port[dev] = pnp_port_start(pdev, 0);
     199                mpu_irq[dev] = pnp_irq(pdev, 0);
    218200        } else {
    219                 mpu_port[dev] = pdev->resource[0].start;
    220                 mpu_irq[dev] = pdev->irq_resource[0].start;
    221         }
    222 
     201             __mpu_error:
     202                if (pdev) {
     203                        pnp_release_card_device(pdev);
     204                        snd_printk(KERN_ERR PFX "MPU401 pnp configure failure, skipping\n");
     205                }
     206                acard->devmpu = NULL;
     207                mpu_port[dev] = -1;
     208        }
     209
     210        kfree (cfg);
    223211        return 0;
    224212}
    225213
    226 static void snd_card_azt2320_deactivate(struct snd_card_azt2320 *acard)
    227 {
    228         if (acard->dev)
    229                 acard->dev->deactivate(acard->dev);
    230         if (acard->devmpu)
    231                 acard->devmpu->deactivate(acard->devmpu);
    232 }
    233 #endif  /* __ISAPNP__ */
    234 
    235214/* same of snd_sbdsp_command by Jaroslav Kysela */
    236 static int __init snd_card_azt2320_command(unsigned long port, unsigned char val)
     215static int __devinit snd_card_azt2320_command(unsigned long port, unsigned char val)
    237216{
    238217        int i;
     
    240219
    241220        limit = jiffies + HZ / 10;
    242         for (i = 50000; i && (limit - jiffies) > 0; i--)
     221        for (i = 50000; i && time_after(limit, jiffies); i--)
    243222                if (!(inb(port + 0x0c) & 0x80)) {
    244223                        outb(val, port + 0x0c);
     
    248227}
    249228
    250 static int __init snd_card_azt2320_enable_wss(unsigned long port)
     229static int __devinit snd_card_azt2320_enable_wss(unsigned long port)
    251230{
    252231        int error;
     
    261240}
    262241
    263 static void snd_card_azt2320_free(snd_card_t *card)
    264 {
    265         struct snd_card_azt2320 *acard = (struct snd_card_azt2320 *)card->private_data;
    266 
    267         if (acard) {
    268 #ifdef __ISAPNP__
    269                 snd_card_azt2320_deactivate(acard);
    270 #endif  /* __ISAPNP__ */
    271         }
    272 }
    273 
    274 static int __init snd_card_azt2320_probe(int dev)
     242static int __devinit snd_card_azt2320_probe(int dev,
     243                                            struct pnp_card_link *pcard,
     244                                            const struct pnp_card_device_id *pid)
    275245{
    276246        int error;
     
    284254                return -ENOMEM;
    285255        acard = (struct snd_card_azt2320 *)card->private_data;
    286         card->private_free = snd_card_azt2320_free;
    287 
    288 #ifdef __ISAPNP__
    289         if ((error = snd_card_azt2320_isapnp(dev, acard))) {
    290                 snd_card_free(card);
    291                 return error;
    292         }
    293 #endif  /* __ISAPNP__ */
     256
     257        if ((error = snd_card_azt2320_pnp(dev, acard, pcard, pid))) {
     258                snd_card_free(card);
     259                return error;
     260        }
    294261
    295262        if ((error = snd_card_azt2320_enable_wss(port[dev]))) {
     
    325292                                mpu_irq[dev], SA_INTERRUPT,
    326293                                NULL) < 0)
    327                         printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n",
    328                                 mpu_port[dev]);
     294                        snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
    329295        }
    330296
     
    333299                                    fm_port[dev], fm_port[dev] + 2,
    334300                                    OPL3_HW_AUTO, 0, &opl3) < 0) {
    335                         printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
     301                        snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
    336302                                fm_port[dev], fm_port[dev] + 2);
    337303                } else {
     
    356322                return error;
    357323        }
    358         snd_azt2320_cards[dev] = card;
     324        pnp_set_card_drvdata(pcard, card);
    359325        return 0;
    360326}
    361327
    362 #ifdef __ISAPNP__
    363 static int __init snd_azt2320_isapnp_detect(struct isapnp_card *card,
    364                                             const struct isapnp_card_id *id)
     328static int __devinit snd_azt2320_pnp_detect(struct pnp_card_link *card,
     329                                            const struct pnp_card_device_id *id)
    365330{
    366331        static int dev;
     
    370335                if (!enable[dev])
    371336                        continue;
    372                 snd_azt2320_isapnp_cards[dev] = card;
    373                 snd_azt2320_isapnp_id[dev] = id;
    374                 res = snd_card_azt2320_probe(dev);
     337                res = snd_card_azt2320_probe(dev, card, id);
    375338                if (res < 0)
    376339                        return res;
     
    380343        return -ENODEV;
    381344}
    382 #endif
     345
     346static void __devexit snd_azt2320_pnp_remove(struct pnp_card_link * pcard)
     347{
     348        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     349
     350        snd_card_disconnect(card);
     351        snd_card_free_in_thread(card);
     352}
     353
     354static struct pnp_card_driver azt2320_pnpc_driver = {
     355        .flags          = PNP_DRIVER_RES_DISABLE,
     356        .name           = "azt2320",
     357        .id_table       = snd_azt2320_pnpids,
     358        .probe          = snd_azt2320_pnp_detect,
     359        .remove         = __devexit_p(snd_azt2320_pnp_remove),
     360};
    383361
    384362static int __init alsa_card_azt2320_init(void)
     
    386364        int cards = 0;
    387365
    388 #ifdef __ISAPNP__
    389         cards += isapnp_probe_cards(snd_azt2320_pnpids, snd_azt2320_isapnp_detect);
    390 #else
    391         printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
    392 #endif
     366        cards += pnp_register_card_driver(&azt2320_pnpc_driver);
    393367#ifdef MODULE
    394         if (!cards)
    395                 printk(KERN_ERR "no AZT2320 based soundcards found\n");
     368        if (!cards) {
     369                pnp_unregister_card_driver(&azt2320_pnpc_driver);
     370                snd_printk(KERN_ERR "no AZT2320 based soundcards found\n");
     371        }
    396372#endif
    397373        return cards ? 0 : -ENODEV;
     
    400376static void __exit alsa_card_azt2320_exit(void)
    401377{
    402         int dev;
    403 
    404         for (dev = 0; dev < SNDRV_CARDS; dev++)
    405                 snd_card_free(snd_azt2320_cards[dev]);
     378        pnp_unregister_card_driver(&azt2320_pnpc_driver);
    406379}
    407380
  • GPL/branches/alsa-resync1/alsa-kernel/isa/cmi8330.c

    r224 r246  
    4747#include <linux/init.h>
    4848#include <linux/slab.h>
    49 #ifndef LINUX_ISAPNP_H
    50 #include <linux/isapnp.h>
    51 #define isapnp_card pci_bus
    52 #define isapnp_dev pci_dev
    53 #endif
     49#include <linux/pnp.h>
    5450#include <sound/core.h>
    5551#include <sound/ad1848.h>
     
    7470static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
    7571static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP;
    76 #ifdef __ISAPNP__
     72#ifdef CONFIG_PNP
    7773#ifdef TARGET_OS2
    7874static int isapnp[SNDRV_CARDS] = {REPEAT_SNDRV(1)};
     
    9894MODULE_PARM_DESC(enable, "Enable CMI8330 soundcard.");
    9995MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
    100 #ifdef __ISAPNP__
     96#ifdef CONFIG_PNP
    10197MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
    102 MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
     98MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
    10399MODULE_PARM_SYNTAX(isapnp, SNDRV_ISAPNP_DESC);
    104100#endif
     
    161157
    162158struct snd_cmi8330 {
    163 #ifdef __ISAPNP__
    164         struct isapnp_dev *cap;
    165         struct isapnp_dev *play;
     159#ifdef CONFIG_PNP
     160        struct pnp_dev *cap;
     161        struct pnp_dev *play;
    166162#endif
    167163        snd_card_t *card;
     
    177173};
    178174
    179 static snd_card_t *snd_cmi8330_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    180 
    181 #ifdef __ISAPNP__
    182 
    183 static struct isapnp_card *snd_cmi8330_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    184 static const struct isapnp_card_id *snd_cmi8330_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    185 
    186 #define ISAPNP_CMI8330(_va, _vb, _vc, _device, _audio1, _audio2) \
    187         { \
    188                 ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    189                 .devs = { ISAPNP_DEVICE_ID('@', '@', '@', _audio1), \
    190                          ISAPNP_DEVICE_ID('@', 'X', '@', _audio2), } \
    191         }
    192 
    193 static struct isapnp_card_id snd_cmi8330_pnpids[] __devinitdata =
    194 {
    195         ISAPNP_CMI8330('C','M','I',0x0001,0x0001,0x0001),
    196         { ISAPNP_CARD_END, }
     175static snd_card_t *snd_cmi8330_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
     176
     177#ifdef CONFIG_PNP
     178
     179static struct pnp_card_device_id snd_cmi8330_pnpids[] __devinitdata = {
     180        { .id = "CMI0001", .devs = { { "@@@0001" }, { "@X@0001" } } },
     181        { .id = "" }
    197182};
    198183
    199 ISAPNP_CARD_TABLE(snd_cmi8330_pnpids);
     184MODULE_DEVICE_TABLE(pnp_card, snd_cmi8330_pnpids);
    200185
    201186#endif
     
    263248
    264249
    265 static int __init cmi8330_add_sb_mixers(sb_t *chip)
     250static int __devinit cmi8330_add_sb_mixers(sb_t *chip)
    266251{
    267252        int idx, err;
     
    288273#endif
    289274
    290 static int __init snd_cmi8330_mixer(snd_card_t *card, struct snd_cmi8330 *acard)
     275static int __devinit snd_cmi8330_mixer(snd_card_t *card, struct snd_cmi8330 *acard)
    291276{
    292277        unsigned int idx;
     
    307292}
    308293
    309 #ifdef __ISAPNP__
    310 static int __init snd_cmi8330_isapnp(int dev, struct snd_cmi8330 *acard)
    311 {
    312         const struct isapnp_card_id *id = snd_cmi8330_isapnp_id[dev];
    313         struct isapnp_card *card = snd_cmi8330_isapnp_cards[dev];
    314         struct isapnp_dev *pdev;
    315 
    316         acard->cap = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    317         if (acard->cap->active) {
    318                 acard->cap = NULL;
     294#ifdef CONFIG_PNP
     295static int __devinit snd_cmi8330_pnp(int dev, struct snd_cmi8330 *acard,
     296                                     struct pnp_card_link *card,
     297                                     const struct pnp_card_device_id *id)
     298{
     299        struct pnp_dev *pdev;
     300        struct pnp_resource_table * cfg = kmalloc(GFP_ATOMIC, sizeof(struct pnp_resource_table));
     301        int err;
     302
     303        acard->cap = pnp_request_card_device(card, id->devs[0].id, NULL);
     304        if (acard->cap == NULL) {
     305                kfree(cfg);
    319306                return -EBUSY;
    320307        }
    321         acard->play = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
    322         if (acard->play->active) {
    323                 acard->cap = acard->play = NULL;
     308        acard->play = pnp_request_card_device(card, id->devs[1].id, NULL);
     309        if (acard->play == NULL) {
     310                kfree(cfg);
    324311                return -EBUSY;
    325312        }
    326313
    327314        pdev = acard->cap;
    328         if (pdev->prepare(pdev)<0)
    329                 return -EAGAIN;
     315        pnp_init_resource_table(cfg);
    330316        /* allocate AD1848 resources */
    331317        if (wssport[dev] != SNDRV_AUTO_PORT)
    332                 isapnp_resource_change(&pdev->resource[0], wssport[dev], 8);
     318                pnp_resource_change(&cfg->port_resource[0], wssport[dev], 8);
    333319        if (wssdma[dev] != SNDRV_AUTO_DMA)
    334                 isapnp_resource_change(&pdev->dma_resource[0], wssdma[dev], 1);
     320                pnp_resource_change(&cfg->dma_resource[0], wssdma[dev], 1);
    335321        if (wssirq[dev] != SNDRV_AUTO_IRQ)
    336                 isapnp_resource_change(&pdev->irq_resource[0], wssirq[dev], 1);
    337 
    338         if (pdev->activate(pdev)<0) {
    339                 snd_printk("(AD1848) PnP configure failure\n");
     322                pnp_resource_change(&cfg->irq_resource[0], wssirq[dev], 1);
     323
     324        err = pnp_manual_config_dev(pdev, cfg, 0);
     325        if (err < 0)
     326                snd_printk(KERN_ERR "CMI8330/C3D (AD1848) PnP manual resources are invalid, using auto config\n");
     327        err = pnp_activate_dev(pdev);
     328        if (err < 0) {
     329                snd_printk(KERN_ERR "CMI8330/C3D (AD1848) PnP configure failure\n");
     330                kfree(cfg);
    340331                return -EBUSY;
    341332        }
    342         wssport[dev] = pdev->resource[0].start;
    343         wssdma[dev] = pdev->dma_resource[0].start;
    344         wssirq[dev] = pdev->irq_resource[0].start;
     333        wssport[dev] = pnp_port_start(pdev, 0);
     334        wssdma[dev] = pnp_dma(pdev, 0);
     335        wssirq[dev] = pnp_irq(pdev, 0);
    345336
    346337        /* allocate SB16 resources */
    347338        pdev = acard->play;
    348         if (pdev->prepare(pdev)<0) {
    349                 acard->cap->deactivate(acard->cap);
    350                 return -EAGAIN;
    351         }
     339        pnp_init_resource_table(cfg);
    352340        if (sbport[dev] != SNDRV_AUTO_PORT)
    353                 isapnp_resource_change(&pdev->resource[0], sbport[dev], 16);
     341                pnp_resource_change(&cfg->port_resource[0], sbport[dev], 16);
    354342        if (sbdma8[dev] != SNDRV_AUTO_DMA)
    355                 isapnp_resource_change(&pdev->dma_resource[0], sbdma8[dev], 1);
     343                pnp_resource_change(&cfg->dma_resource[0], sbdma8[dev], 1);
    356344        if (sbdma16[dev] != SNDRV_AUTO_DMA)
    357                 isapnp_resource_change(&pdev->dma_resource[1], sbdma16[dev], 1);
     345                pnp_resource_change(&cfg->dma_resource[1], sbdma16[dev], 1);
    358346        if (sbirq[dev] != SNDRV_AUTO_IRQ)
    359                 isapnp_resource_change(&pdev->irq_resource[0], sbirq[dev], 1);
    360 
    361         if (pdev->activate(pdev)<0) {
    362                 snd_printk("CMI8330/C3D (SB16) PnP configure failure\n");
    363                 acard->cap->deactivate(acard->cap);
     347                pnp_resource_change(&cfg->irq_resource[0], sbirq[dev], 1);
     348
     349        err = pnp_manual_config_dev(pdev, cfg, 0);
     350        if (err < 0)
     351                snd_printk(KERN_ERR "CMI8330/C3D (SB16) PnP manual resources are invalid, using auto config\n");
     352        err = pnp_activate_dev(pdev);
     353        if (err < 0) {
     354                snd_printk(KERN_ERR "CMI8330/C3D (SB16) PnP configure failure\n");
     355                kfree(cfg);
    364356                return -EBUSY;
    365357        }
    366         sbport[dev] = pdev->resource[0].start;
    367         sbdma8[dev] = pdev->dma_resource[0].start;
    368         sbdma16[dev] = pdev->dma_resource[1].start;
    369         sbirq[dev] = pdev->irq_resource[0].start;
    370 
     358        sbport[dev] = pnp_port_start(pdev, 0);
     359        sbdma8[dev] = pnp_dma(pdev, 0);
     360        sbdma16[dev] = pnp_dma(pdev, 1);
     361        sbirq[dev] = pnp_irq(pdev, 0);
     362
     363        kfree(cfg);
    371364        return 0;
    372 }
    373 
    374 static void snd_cmi8330_deactivate(struct snd_cmi8330 *acard)
    375 {
    376         if (acard->cap) {
    377                 acard->cap->deactivate(acard->cap);
    378                 acard->cap = NULL;
    379         }
    380         if (acard->play) {
    381                 acard->play->deactivate(acard->play);
    382                 acard->play = NULL;
    383         }
    384365}
    385366#endif
     
    429410}
    430411
    431 static int __init snd_cmi8330_pcm(snd_card_t *card, struct snd_cmi8330 *chip)
     412static int __devinit snd_cmi8330_pcm(snd_card_t *card, struct snd_cmi8330 *chip)
    432413{
    433414        snd_pcm_t *pcm;
     
    472453 */
    473454
    474 static void snd_cmi8330_free(snd_card_t *card)
    475 {
    476         struct snd_cmi8330 *acard = (struct snd_cmi8330 *)card->private_data;
    477 
    478         if (acard) {
    479 #ifdef __ISAPNP__
    480                 snd_cmi8330_deactivate(acard);
    481 #endif
    482         }
    483 }
    484 
    485 static int __init snd_cmi8330_probe(int dev)
     455static int __devinit snd_cmi8330_probe(int dev,
     456                                       struct pnp_card_link *pcard,
     457                                       const struct pnp_card_device_id *pid)
    486458{
    487459        snd_card_t *card;
     
    490462        int i, err;
    491463
    492 #ifdef __ISAPNP__
     464#ifdef CONFIG_PNP
    493465        if (!isapnp[dev]) {
    494466#endif
     
    501473                        return -EINVAL;
    502474                }
    503 #ifdef __ISAPNP__
     475#ifdef CONFIG_PNP
    504476        }
    505477#endif
     
    512484        acard = (struct snd_cmi8330 *)card->private_data;
    513485        acard->card = card;
    514         card->private_free = snd_cmi8330_free;
    515 
    516 #ifdef __ISAPNP__
    517         if (isapnp[dev] && (err = snd_cmi8330_isapnp(dev, acard)) < 0) {
     486
     487#ifdef CONFIG_PNP
     488        if (isapnp[dev] && (err = snd_cmi8330_pnp(dev, acard, pcard, pid)) < 0) {
    518489                snd_printk("PnP detection failed\n");
    519490                snd_card_free(card);
     
    585556        }
    586557
    587         snd_cmi8330_cards[dev] = card;
     558        if (pcard)
     559                pnp_set_card_drvdata(pcard, card);
     560        else
     561                snd_cmi8330_legacy[dev] = card;
    588562        return 0;
    589563}
    590564
    591 static void __exit alsa_card_cmi8330_exit(void)
    592 {
    593         int i;
    594 
    595         for (i = 0; i < SNDRV_CARDS; i++)
    596                 snd_card_free(snd_cmi8330_cards[i]);
    597 }
    598 
    599 #ifdef __ISAPNP__
    600 static int __init snd_cmi8330_isapnp_detect(struct isapnp_card *card,
    601                                             const struct isapnp_card_id *id)
     565#ifdef CONFIG_PNP
     566static int __devinit snd_cmi8330_pnp_detect(struct pnp_card_link *card,
     567                                            const struct pnp_card_device_id *id)
    602568{
    603569        static int dev;
     
    607573                if (!enable[dev] || !isapnp[dev])
    608574                        continue;
    609                 snd_cmi8330_isapnp_cards[dev] = card;
    610                 snd_cmi8330_isapnp_id[dev] = id;
    611                 res = snd_cmi8330_probe(dev);
     575                res = snd_cmi8330_probe(dev, card, id);
    612576                if (res < 0)
    613577                        return res;
     
    617581        return -ENODEV;
    618582}
    619 #endif /* __ISAPNP__ */
     583
     584static void __devexit snd_cmi8330_pnp_remove(struct pnp_card_link * pcard)
     585{
     586        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     587
     588        snd_card_disconnect(card);
     589        snd_card_free_in_thread(card);
     590}
     591
     592static struct pnp_card_driver cmi8330_pnpc_driver = {
     593        .flags = PNP_DRIVER_RES_DISABLE,
     594        .name = "cmi8330",
     595        .id_table = snd_cmi8330_pnpids,
     596        .probe = snd_cmi8330_pnp_detect,
     597        .remove = __devexit_p(snd_cmi8330_pnp_remove),
     598};
     599#endif /* CONFIG_PNP */
    620600
    621601static int __init alsa_card_cmi8330_init(void)
     
    626606                if (!enable[dev])
    627607                        continue;
    628 #ifdef __ISAPNP__
     608#ifdef CONFIG_PNP
    629609                if (isapnp[dev])
    630610                        continue;
    631611#endif
    632                 if (snd_cmi8330_probe(dev) >= 0)
     612                if (snd_cmi8330_probe(dev, NULL, NULL) >= 0)
    633613                        cards++;
    634614        }
    635 #ifdef __ISAPNP__
    636         cards += isapnp_probe_cards(snd_cmi8330_pnpids, snd_cmi8330_isapnp_detect);
     615#ifdef CONFIG_PNP
     616        cards += pnp_register_card_driver(&cmi8330_pnpc_driver);
    637617#endif
    638618
    639619        if (!cards) {
     620#ifdef CONFIG_PNP
     621                pnp_unregister_card_driver(&cmi8330_pnpc_driver);
     622#endif
    640623#ifdef MODULE
    641                 printk(KERN_ERR "CMI8330 not found or device busy\n");
     624                snd_printk(KERN_ERR "CMI8330 not found or device busy\n");
    642625#endif
    643626                return -ENODEV;
    644627        }
    645628        return 0;
     629}
     630
     631static void __exit alsa_card_cmi8330_exit(void)
     632{
     633        int i;
     634
     635#ifdef CONFIG_PNP
     636        /* PnP cards first */
     637        pnp_unregister_card_driver(&cmi8330_pnpc_driver);
     638#endif
     639        for (i = 0; i < SNDRV_CARDS; i++)
     640                snd_card_free(snd_cmi8330_legacy[i]);
    646641}
    647642
     
    675670               get_option(&str,&wssirq[nr_dev]) == 2 &&
    676671               get_option(&str,&wssdma[nr_dev]) == 2);
    677 #ifdef __ISAPNP__
     672#ifdef CONFIG_PNP
    678673        if (pnp != INT_MAX)
    679674                isapnp[nr_dev] = pnp;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4231_lib.c

    r224 r246  
    449449        int result = 0;
    450450        unsigned int what;
     451        struct list_head *pos;
    451452        snd_pcm_substream_t *s;
    452453        int do_start;
     
    468469
    469470        what = 0;
    470         s = substream;
    471                 do {
     471        snd_pcm_group_for_each(pos, substream) {
     472                s = snd_pcm_group_substream_entry(pos);
    472473                        if (s == chip->playback_substream) {
    473474                                what |= CS4231_PLAYBACK_ENABLE;
     
    477478                                snd_pcm_trigger_done(s, substream);
    478479                        }
    479                         s = s->link_next;
    480                 } while (s != substream);
     480        }
    481481                spin_lock(&chip->reg_lock);
    482482        if (do_start) {
     
    968968}
    969969
    970 void snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    971 {
    972         cs4231_t *chip = snd_magic_cast(cs4231_t, dev_id, return);
     970irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     971{
     972        cs4231_t *chip = snd_magic_cast(cs4231_t, dev_id, return IRQ_NONE);
    973973        unsigned char status;
    974974
     
    999999        snd_cs4231_outm(chip, CS4231_IRQ_STATUS, ~CS4231_ALL_IRQS | ~status, 0);
    10001000        spin_unlock(&chip->reg_lock);
     1001        return IRQ_HANDLED;
    10011002}
    10021003
  • GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4236.c

    r224 r246  
    2323#include <linux/init.h>
    2424#include <linux/slab.h>
    25 #ifndef LINUX_ISAPNP_H
    26 #include <linux/isapnp.h>
    27 #define isapnp_card pci_bus
    28 #define isapnp_dev pci_dev
    29 #endif
     25#include <linux/pnp.h>
    3026#include <sound/core.h>
    3127#include <sound/cs4231.h>
     
    8884static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
    8985static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
    90 #ifdef __ISAPNP__
     86#ifdef CONFIG_PNP
    9187#ifdef TARGET_OS2
    9288static int isapnp[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
     
    114110MODULE_PARM_DESC(enable, "Enable " IDENT " soundcard.");
    115111MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
    116 #ifdef __ISAPNP__
     112#ifdef CONFIG_PNP
    117113MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
    118114MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
     
    149145struct snd_card_cs4236 {
    150146        struct resource *res_sb_port;
    151 #ifdef __ISAPNP__
    152         struct isapnp_dev *wss;
    153         struct isapnp_dev *ctrl;
    154         struct isapnp_dev *mpu;
     147#ifdef CONFIG_PNP
     148        struct pnp_dev *wss;
     149        struct pnp_dev *ctrl;
     150        struct pnp_dev *mpu;
    155151#endif
    156152};
    157153
    158 static snd_card_t *snd_cs4236_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    159 
    160 #ifdef __ISAPNP__
    161 
    162 static struct isapnp_card *snd_cs4236_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    163 static const struct isapnp_card_id *snd_cs4236_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
     154static snd_card_t *snd_cs4236_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
     155
     156#ifdef CONFIG_PNP
    164157
    165158#ifdef TARGET_OS2
     
    209202
    210203#ifdef CS4232
    211 static struct isapnp_card_id snd_card_pnpids[] __devinitdata = {
     204static struct pnp_card_device_id snd_cs423x_pnpids[] __devinitdata = {
    212205        /* Philips PCA70PS */
    213         ISAPNP_CS4232_1('C','S','C',0x0d32,0x0000,0x0010,0xb006),
     206        { .id = "CSC0d32", .devs = { { "CSC0000" }, { "CSC0010" }, { "PNPb006" } } },
    214207        /* TerraTec Maestro 32/96 (CS4232) */
    215         ISAPNP_CS4232('C','S','C',0x1a32,0x0000,0x0010,0x0003),
     208        { .id = "CSC1a32", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    216209        /* HP Omnibook 5500 onboard */
    217         ISAPNP_CS4232('C','S','C',0x4232,0x0000,0x0002,0x0003),
     210        { .id = "CSC4232", .devs = { { "CSC0000" }, { "CSC0002" }, { "CSC0003" } } },
    218211        /* Unnamed CS4236 card (Made in Taiwan) */
    219         ISAPNP_CS4232('C','S','C',0x4236,0x0000,0x0010,0x0003),
     212        { .id = "CSC4236", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    220213        /* Turtle Beach TBS-2000 (CS4232) */
    221         ISAPNP_CS4232('C','S','C',0x7532,0x0000,0x0010,0xb006),
     214        { .id = "CSC7532", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSCb006" } } },
    222215        /* Turtle Beach Tropez Plus (CS4232) */
    223         ISAPNP_CS4232_1('C','S','C',0x7632,0x0000,0x0010,0xb006),
     216        { .id = "CSC7632", .devs = { { "CSC0000" }, { "CSC0010" }, { "PNPb006" } } },
    224217        /* SIC CrystalWave 32 (CS4232) */
    225         ISAPNP_CS4232('C','S','C',0xf032,0x0000,0x0010,0x0003),
     218        { .id = "CSCf032", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    226219        /* --- */
    227         { ISAPNP_CARD_END, }    /* end */
     220        { .id = "" }    /* end */
    228221};
    229222#else /* CS4236 */
    230 static struct isapnp_card_id snd_card_pnpids[] __devinitdata = {
     223static struct pnp_card_device_id snd_cs423x_pnpids[] __devinitdata = {
    231224        /* Intel Marlin Spike Motherboard - CS4235 */
    232         ISAPNP_CS4232('C','S','C',0x0225,0x0000,0x0010,0x0003),
     225        { .id = "CSC0225", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    233226        /* Intel Marlin Spike Motherboard (#2) - CS4235 */
    234         ISAPNP_CS4232('C','S','C',0x0225,0x0100,0x0110,0x0103),
     227        { .id = "CSC0225", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
    235228        /* Genius Sound Maker 3DJ - CS4237B */
    236         ISAPNP_CS4232('C','S','C',0x0437,0x0000,0x0010,0x0003),
     229        { .id = "CSC0437", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    237230        /* Digital PC 5000 Onboard - CS4236B */
    238         ISAPNP_CS4232_WOMPU('C','S','C',0x0735,0x0000,0x0010),
     231        { .id = "CSC0735", .devs = { { "CSC0000" }, { "CSC0010" } } },
    239232        /* some uknown CS4236B */
    240         ISAPNP_CS4232('C','S','C',0x0b35,0x0000,0x0010,0x0003),
     233        { .id = "CSC0b35", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    241234        /* Intel PR440FX Onboard sound */
    242         ISAPNP_CS4232('C','S','C',0x0b36,0x0000,0x0010,0x0003),
     235        { .id = "CSC0b36", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    243236        /* CS4235 on mainboard without MPU */
    244         ISAPNP_CS4232_WOMPU('C','S','C',0x1425,0x0100,0x0110),
     237        { .id = "CSC1425", .devs = { { "CSC0100" }, { "CSC0110" } } },
    245238        /* Gateway E1000 Onboard CS4236B */
    246         ISAPNP_CS4232('C','S','C',0x1335,0x0000,0x0010,0x0003),
     239        { .id = "CSC1335", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    247240        /* HP 6330 Onboard sound */
    248         ISAPNP_CS4232('C','S','C',0x1525,0x0100,0x0110,0x0103),
     241        { .id = "CSC1525", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
    249242        /* Crystal Computer TidalWave128 */
    250         ISAPNP_CS4232('C','S','C',0x1e37,0x0000,0x0010,0x0003),
     243        { .id = "CSC1e37", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    251244        /* ACER AW37 - CS4235 */
    252         ISAPNP_CS4232('C','S','C',0x4236,0x0000,0x0010,0x0003),
     245        { .id = "CSC4236", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    253246        /* build-in soundcard in EliteGroup P5TX-LA motherboard - CS4237B */
    254         ISAPNP_CS4232('C','S','C',0x4237,0x0000,0x0010,0x0003),
     247        { .id = "CSC4237", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    255248        /* Crystal 3D - CS4237B */
    256         ISAPNP_CS4232('C','S','C',0x4336,0x0000,0x0010,0x0003),
     249        { .id = "CSC4336", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    257250        /* Typhoon Soundsystem PnP - CS4236B */
    258         ISAPNP_CS4232('C','S','C',0x4536,0x0000,0x0010,0x0003),
     251        { .id = "CSC4536", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    259252        /* Crystal CX4235-XQ3 EP - CS4235 */
    260         ISAPNP_CS4232('C','S','C',0x4625,0x0100,0x0110,0x0103),
     253        { .id = "CSC4625", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
     254        /* Crystal Semiconductors CS4237B */
     255        { .id = "CSC4637", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
     256        /* NewClear 3D - CX4237B-XQ3 */
     257        { .id = "CSC4837", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
     258        /* Dell Optiplex GX1 - CS4236B */
     259        { .id = "CSC6835", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
     260        /* Dell P410 motherboard - CS4236B */
     261        { .id = "CSC6835", .devs = { { "CSC0000" }, { "CSC0010" } } },
     262        /* Dell Workstation 400 Onboard - CS4236B */
     263        { .id = "CSC6836", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
     264        /* Turtle Beach Malibu - CS4237B */
     265        { .id = "CSC7537", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
     266        /* CS4235 - onboard */
     267        { .id = "CSC8025", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
     268        /* IBM Aptiva 2137 E24 Onboard - CS4237B */
     269        { .id = "CSC8037", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
     270        /* IBM IntelliStation M Pro motherboard */
     271        { .id = "CSCc835", .devs = { { "CSC0000" }, { "CSC0010" } } },
     272        /* Guillemot MaxiSound 16 PnP - CS4236B */
     273        { .id = "CSC9836", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
     274        /* Gallant SC-70P */
     275        { .id = "CSC9837", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    261276        /* TerraTec AudioSystem EWS64XL - CS4236B */
    262         ISAPNP_CS4232('C','S','C',0xa836,0xa800,0xa810,0xa803),
     277        { .id = "CSCa836", .devs = { { "CSCa800" }, { "CSCa810" }, { "CSCa803" } } },
    263278        /* TerraTec AudioSystem EWS64XL - CS4236B */
    264         ISAPNP_CS4232_WOMPU('C','S','C',0xa836,0xa800,0xa810),
    265         /* Crystal Semiconductors CS4237B */
    266         ISAPNP_CS4232('C','S','C',0x4637,0x0000,0x0010,0x0003),
    267         /* NewClear 3D - CX4237B-XQ3 */
    268         ISAPNP_CS4232('C','S','C',0x4837,0x0000,0x0010,0x0003),
    269         /* Dell Optiplex GX1 - CS4236B */
    270         ISAPNP_CS4232('C','S','C',0x6835,0x0000,0x0010,0x0003),
    271         /* Dell P410 motherboard - CS4236B */
    272         ISAPNP_CS4232_WOMPU('C','S','C',0x6835,0x0000,0x0010),
    273         /* Dell Workstation 400 Onboard - CS4236B */
    274         ISAPNP_CS4232('C','S','C',0x6836,0x0000,0x0010,0x0003),
    275         /* Turtle Beach Malibu - CS4237B */
    276         ISAPNP_CS4232('C','S','C',0x7537,0x0000,0x0010,0x0003),
    277         /* CS4235 - onboard */
    278         ISAPNP_CS4232('C','S','C',0x8025,0x0100,0x0110,0x0103),
     279        { .id = "CSCa836", .devs = { { "CSCa800" }, { "CSCa810" } } },
     280        /* ACER AW37/Pro - CS4235 */
     281        { .id = "CSCd925", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
     282        /* ACER AW35/Pro - CS4237B */
     283        { .id = "CSCd937", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
     284        /* CS4235 without MPU401 */
     285        { .id = "CSCe825", .devs = { { "CSC0100" }, { "CSC0110" } } },
     286        /* IBM IntelliStation M Pro 6898 11U - CS4236B */
     287        { .id = "CSCe835", .devs = { { "CSC0000" }, { "CSC0010" } } },
    279288        /* IBM PC 300PL Onboard - CS4236B */
    280         ISAPNP_CS4232_WOMPU('C','S','C',0xe836,0x0000,0x0010),
    281         /* IBM Aptiva 2137 E24 Onboard - CS4237B */
    282         ISAPNP_CS4232('C','S','C',0x8037,0x0000,0x0010,0x0003),
    283         /* IBM IntelliStation M Pro motherboard */
    284         ISAPNP_CS4232_WOMPU('C','S','C',0xc835,0x0000,0x0010),
    285         /* Guillemot MaxiSound 16 PnP - CS4236B */
    286         ISAPNP_CS4232('C','S','C',0x9836,0x0000,0x0010,0x0003),
    287         /* Gallant SC-70P */
    288         ISAPNP_CS4232('C','S','C',0x9837,0x0000,0x0010,0x0003),
    289         /* ACER AW37/Pro - CS4235 */
    290         ISAPNP_CS4232('C','S','C',0xd925,0x0000,0x0010,0x0003),
    291         /* ACER AW35/Pro - CS4237B */
    292         ISAPNP_CS4232('C','S','C',0xd937,0x0000,0x0010,0x0003),
    293         /* CS4235 without MPU401 */
    294         ISAPNP_CS4232_WOMPU('C','S','C',0xe825,0x0100,0x0110),
    295         /* IBM IntelliStation M Pro 6898 11U - CS4236B */
    296         ISAPNP_CS4232_WOMPU('C','S','C',0xe835,0x0000,0x0010),
     289        { .id = "CSCe836", .devs = { { "CSC0000" }, { "CSC0010" } } },
    297290        /* Some noname CS4236 based card */
    298         ISAPNP_CS4232('C','S','C',0xe936,0x0000,0x0010,0x0003),
     291        { .id = "CSCe936", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    299292        /* CS4236B */
    300         ISAPNP_CS4232('C','S','C',0xf235,0x0000,0x0010,0x0003),
     293        { .id = "CSCf235", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    301294        /* CS4236B */
    302         ISAPNP_CS4232('C','S','C',0xf238,0x0000,0x0010,0x0003),
     295        { .id = "CSCf238", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
    303296        /* --- */
    304         { ISAPNP_CARD_END, }    /* end */
     297        { .id = "" }    /* end */
    305298};
    306299#endif
    307300
    308 ISAPNP_CARD_TABLE(snd_card_pnpids);
    309 
    310 static int __init snd_card_cs4236_isapnp(int dev, struct snd_card_cs4236 *acard)
    311 {
    312         const struct isapnp_card_id *id = snd_cs4236_isapnp_id[dev];
    313         struct isapnp_card *card = snd_cs4236_isapnp_cards[dev];
    314         struct isapnp_dev *pdev;
    315        
    316         acard->wss = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    317         if (acard->wss->active) {
    318                 acard->wss = NULL;
     301MODULE_DEVICE_TABLE(pnp_card, snd_cs423x_pnpids);
     302
     303static int __devinit snd_card_cs4236_pnp(int dev, struct snd_card_cs4236 *acard,
     304                                         struct pnp_card_link *card,
     305                                         const struct pnp_card_device_id *id)
     306{
     307        struct pnp_dev *pdev;
     308        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
     309        int err;
     310
     311        acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL);
     312        if (acard->wss == NULL) {
     313                kfree(cfg);
    319314                return -EBUSY;
    320315        }
    321         acard->ctrl = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
    322         if (acard->ctrl->active) {
    323                 acard->wss = acard->ctrl = NULL;
     316        acard->ctrl = pnp_request_card_device(card, id->devs[1].id, NULL);
     317        if (acard->ctrl == NULL) {
     318                kfree(cfg);
    324319                return -EBUSY;
    325320        }
    326         if (id->devs[2].vendor && id->devs[2].function) {
    327                 acard->mpu = isapnp_find_dev(card, id->devs[2].vendor, id->devs[2].function, NULL);
    328                 if (acard->mpu->active) {
    329                         acard->wss = acard->ctrl = acard->mpu = NULL;
     321        if (id->devs[2].id[0]) {
     322                acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL);
     323                if (acard->mpu == NULL) {
     324                        kfree(cfg);
    330325                        return -EBUSY;
    331326                }
     
    334329        /* WSS initialization */
    335330        pdev = acard->wss;
    336         if (pdev->prepare(pdev) < 0)
    337                 return -EAGAIN;
     331        pnp_init_resource_table(cfg);
    338332        if (port[dev] != SNDRV_AUTO_PORT)
    339                 isapnp_resource_change(&pdev->resource[0], port[dev], 4);
     333                pnp_resource_change(&cfg->port_resource[0], port[dev], 4);
    340334        if (fm_port[dev] != SNDRV_AUTO_PORT && fm_port[dev] >= 0)
    341                 isapnp_resource_change(&pdev->resource[1], fm_port[dev], 4);
     335                pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
    342336        if (sb_port[dev] != SNDRV_AUTO_PORT)
    343                 isapnp_resource_change(&pdev->resource[2], sb_port[dev], 16);
     337                pnp_resource_change(&cfg->port_resource[2], sb_port[dev], 16);
    344338        if (irq[dev] != SNDRV_AUTO_IRQ)
    345                 isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
     339                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
    346340        if (dma1[dev] != SNDRV_AUTO_DMA)
    347                 isapnp_resource_change(&pdev->dma_resource[0], dma1[dev], 1);
     341                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
    348342        if (dma2[dev] != SNDRV_AUTO_DMA)
    349                 isapnp_resource_change(&pdev->dma_resource[1], dma2[dev] < 0 ? 4 : dma2[dev], 1);
    350         if (pdev->activate(pdev)<0) {
    351                 printk(KERN_ERR IDENT " isapnp configure failed for WSS (out of resources?)\n");
     343                pnp_resource_change(&cfg->dma_resource[1], dma2[dev] < 0 ? 4 : dma2[dev], 1);
     344        err = pnp_manual_config_dev(pdev, cfg, 0);
     345        if (err < 0)
     346                snd_printk(KERN_ERR IDENT " WSS PnP manual resources are invalid, using auto config\n");
     347        err = pnp_activate_dev(pdev);
     348        if (err < 0) {
     349                kfree(cfg);
     350                printk(KERN_ERR IDENT " WSS PnP configure failed for WSS (out of resources?)\n");
    352351                return -EBUSY;
    353352        }
    354         port[dev] = pdev->resource[0].start;
     353        port[dev] = pnp_port_start(pdev, 0);
    355354        if (fm_port[dev] >= 0)
    356                 fm_port[dev] = pdev->resource[1].start;
    357         sb_port[dev] = pdev->resource[2].start;
    358         irq[dev] = pdev->irq_resource[0].start;
    359         dma1[dev] = pdev->dma_resource[0].start;
    360         dma2[dev] = pdev->dma_resource[1].start == 4 ? -1 : (int)pdev->dma_resource[1].start;
     355                fm_port[dev] = pnp_port_start(pdev, 1);
     356        sb_port[dev] = pnp_port_start(pdev, 2);
     357        irq[dev] = pnp_irq(pdev, 0);
     358        dma1[dev] = pnp_dma(pdev, 0);
     359        dma2[dev] = pnp_dma(pdev, 1) == 4 ? -1 : (int)pnp_dma(pdev, 1);
    361360        snd_printdd("isapnp WSS: wss port=0x%lx, fm port=0x%lx, sb port=0x%lx\n",
    362361                        port[dev], fm_port[dev], sb_port[dev]);
     
    366365        if (acard->ctrl && cport[dev] >= 0) {
    367366        pdev = acard->ctrl;
    368         if (pdev->prepare(pdev) < 0) {
    369                 acard->wss->deactivate(acard->wss);
    370                 return -EAGAIN;
    371         }
     367                pnp_init_resource_table(cfg);
    372368                if (cport[dev] != SNDRV_AUTO_PORT)
    373                         isapnp_resource_change(&pdev->resource[0], cport[dev], 8);
    374         if (pdev->activate(pdev)<0) {
    375                 printk(KERN_ERR IDENT " isapnp configure failed for control (out of resources?)\n");
    376                 acard->wss->deactivate(acard->wss);
     369                        pnp_resource_change(&cfg->port_resource[0], cport[dev], 8);
     370                err = pnp_manual_config_dev(pdev, cfg, 0);
     371                if (err < 0)
     372                        snd_printk(KERN_ERR IDENT " CTRL PnP manual resources are invalid, using auto config\n");
     373                err = pnp_activate_dev(pdev);
     374                if (err < 0) {
     375                        kfree(cfg);
     376                        printk(KERN_ERR IDENT " CTRL PnP configure failed for WSS (out of resources?)\n");
    377377                return -EBUSY;
    378378        }
    379                 cport[dev] = pdev->resource[0].start;
     379                cport[dev] = pnp_port_start(pdev, 0);
    380380                snd_printdd("isapnp CTRL: control port=0x%lx\n", cport[dev]);
    381381        }
     
    383383        if (acard->mpu && mpu_port[dev] >= 0) {
    384384                pdev = acard->mpu;
    385                 if (pdev->prepare(pdev) < 0) {
    386                         acard->wss->deactivate(acard->wss);
    387                         acard->ctrl->deactivate(acard->ctrl);
    388                         return -EAGAIN;
    389                 }
     385                pnp_init_resource_table(cfg);
    390386                if (mpu_port[dev] != SNDRV_AUTO_PORT)
    391                         isapnp_resource_change(&pdev->resource[0], mpu_port[dev], 2);
     387                        pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
    392388                if (mpu_irq[dev] != SNDRV_AUTO_IRQ && mpu_irq[dev] >= 0)
    393                         isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev], 1);
    394                 if (pdev->activate(pdev)<0) {
     389                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
     390                err = pnp_manual_config_dev(pdev, cfg, 0);
     391                if (err < 0)
     392                        snd_printk(KERN_ERR IDENT " MPU401 PnP manual resources are invalid, using auto config\n");
     393                err = pnp_activate_dev(pdev);
     394                if (err < 0) {
     395                        kfree(cfg);
     396                        printk(KERN_ERR IDENT " MPU401 PnP configure failed for WSS (out of resources?)\n");
    395397                        mpu_port[dev] = SNDRV_AUTO_PORT;
    396398                        mpu_irq[dev] = SNDRV_AUTO_IRQ;
    397                         printk(KERN_ERR IDENT " isapnp configure failed for MPU (out of resources?)\n");
    398399                } else {
    399                         mpu_port[dev] = pdev->resource[0].start;
    400                         if ((pdev->irq_resource[0].flags & IORESOURCE_IRQ) &&
    401                             mpu_irq[dev] >= 0) {
    402                                 mpu_irq[dev] = pdev->irq_resource[0].start;
     400                        mpu_port[dev] = pnp_port_start(pdev, 0);
     401                        if (pnp_irq_valid(pdev, 0) && pnp_irq(pdev, 0) >= 0) {
     402                                mpu_irq[dev] = pnp_irq(pdev, 0);
    403403                        } else {
    404404                                mpu_irq[dev] = -1;      /* disable interrupt */
     
    407407                snd_printdd("isapnp MPU: port=0x%lx, irq=%i\n", mpu_port[dev], mpu_irq[dev]);
    408408        }
     409        kfree(cfg);
    409410        return 0;
    410411}
    411 
    412 static void snd_card_cs4236_deactivate(struct snd_card_cs4236 *acard)
    413 {
    414         if (acard->wss) {
    415                 acard->wss->deactivate(acard->wss);
    416                 acard->wss = NULL;
    417         }
    418         if (acard->ctrl) {
    419                 acard->ctrl->deactivate(acard->ctrl);
    420                 acard->ctrl = NULL;
    421         }
    422         if (acard->mpu) {
    423                 acard->mpu->deactivate(acard->mpu);
    424                 acard->mpu = NULL;
    425         }
    426 }
    427412#endif
    428413
     
    432417
    433418        if (acard) {
    434 #ifdef __ISAPNP__
    435                 snd_card_cs4236_deactivate(acard);
    436 #endif
    437419                if (acard->res_sb_port) {
    438420                        release_resource(acard->res_sb_port);
     
    442424}
    443425
    444 static int __init snd_card_cs4236_probe(int dev)
     426static int __devinit snd_card_cs423x_probe(int dev, struct pnp_card_link *pcard,
     427                                           const struct pnp_card_device_id *pid)
    445428{
    446429        snd_card_t *card;
     
    451434        int err;
    452435
    453 #ifdef __ISAPNP__
     436#ifdef CONFIG_PNP
    454437        if (!isapnp[dev]) {
    455438#endif
     
    462445                        return -EINVAL;
    463446                }
    464 #ifdef __ISAPNP__
     447#ifdef CONFIG_PNP
    465448        }
    466449#endif
     
    471454        acard = (struct snd_card_cs4236 *)card->private_data;
    472455        card->private_free = snd_card_cs4236_free;
    473 #ifdef __ISAPNP__
    474         if (isapnp[dev] && (err = snd_card_cs4236_isapnp(dev, acard))<0) {
     456#ifdef CONFIG_PNP
     457        if (isapnp[dev] && (err = snd_card_cs4236_pnp(dev, acard, pcard, pid))<0) {
    475458                printk(KERN_ERR "isapnp detection failed and probing for " IDENT " is not supported\n");
    476459                snd_card_free(card);
     
    574557                return err;
    575558        }
    576         snd_cs4236_cards[dev] = card;
     559        if (pcard)
     560                pnp_set_card_drvdata(pcard, card);
     561        else
     562                snd_cs4236_legacy[dev] = card;
    577563        return 0;
    578564}
    579565
    580 #ifdef __ISAPNP__
    581 static int __init snd_cs4236_isapnp_detect(struct isapnp_card *card,
    582                                            const struct isapnp_card_id *id)
     566#ifdef CONFIG_PNP
     567static int __devinit snd_cs423x_pnp_detect(struct pnp_card_link *card,
     568                                           const struct pnp_card_device_id *id)
    583569{
    584570        static int dev;
     
    588574                if (!enable[dev])
    589575                        continue;
    590                 snd_cs4236_isapnp_cards[dev] = card;
    591                 snd_cs4236_isapnp_id[dev] = id;
    592                 res = snd_card_cs4236_probe(dev);
     576                res = snd_card_cs423x_probe(dev, card, id);
    593577                if (res < 0)
    594578                        return res;
     
    598582        return -ENODEV;
    599583}
    600 #endif /* __ISAPNP__ */
     584
     585static void __devexit snd_cs423x_pnp_remove(struct pnp_card_link * pcard)
     586{
     587        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     588       
     589        snd_card_disconnect(card);
     590        snd_card_free_in_thread(card);
     591}
     592                       
     593static struct pnp_card_driver cs423x_pnpc_driver = {
     594        .flags = PNP_DRIVER_RES_DISABLE,
     595        .name = "cs423x",
     596        .id_table = snd_cs423x_pnpids,
     597        .probe = snd_cs423x_pnp_detect,
     598        .remove = __devexit_p(snd_cs423x_pnp_remove),
     599};
     600#endif /* CONFIG_PNP */
    601601
    602602static int __init alsa_card_cs423x_init(void)
     
    607607                if (!enable[dev])
    608608                        continue;
    609 #ifdef __ISAPNP__
     609#ifdef CONFIG_PNP
    610610                if (isapnp[dev])
    611611                        continue;
    612612#endif
    613                 if (snd_card_cs4236_probe(dev) >= 0)
     613                if (snd_card_cs423x_probe(dev, NULL, NULL) >= 0)
    614614                        cards++;
    615615        }
    616 #ifdef __ISAPNP__
    617         cards += isapnp_probe_cards(snd_card_pnpids, snd_cs4236_isapnp_detect);
     616#ifdef CONFIG_PNP
     617        cards += pnp_register_card_driver(&cs423x_pnpc_driver);
    618618#endif
    619619        if (!cards) {
     620#ifdef CONFIG_PNP
     621                pnp_unregister_card_driver(&cs423x_pnpc_driver);
     622#endif
    620623#ifdef MODULE
    621624                printk(KERN_ERR IDENT " soundcard not found or device busy\n");
     
    630633        int idx;
    631634
     635#ifdef CONFIG_PNP
     636        /* PnP cards first */
     637        pnp_unregister_card_driver(&cs423x_pnpc_driver);
     638#endif
    632639        for (idx = 0; idx < SNDRV_CARDS; idx++)
    633                 snd_card_free(snd_cs4236_cards[idx]);
     640                snd_card_free(snd_cs4236_legacy[idx]);
    634641}
    635642
     
    666673               get_option(&str,&dma1[nr_dev]) == 2 &&
    667674               get_option(&str,&dma2[nr_dev]) == 2);
    668 #ifdef __ISAPNP__
     675#ifdef CONFIG_PNP
    669676        if (pnp != INT_MAX)
    670677                isapnp[nr_dev] = pnp;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/dt019x.c

    r224 r246  
    2626#include <linux/sched.h>
    2727#include <linux/wait.h>
    28 #ifndef LINUX_ISAPNP_H
    29 #include <linux/isapnp.h>
    30 #define isapnp_card pci_bus
    31 #define isapnp_dev pci_dev
    32 #endif
     28#include <linux/pnp.h>
    3329#include <sound/core.h>
    3430#define SNDRV_GET_ID
     
    8884
    8985struct snd_card_dt019x {
    90 #ifdef __ISAPNP__
    91         struct isapnp_dev *dev;
    92         struct isapnp_dev *devmpu;
    93         struct isapnp_dev *devopl;
    94 #endif  /* __ISAPNP__ */
     86        struct pnp_dev *dev;
     87        struct pnp_dev *devmpu;
     88        struct pnp_dev *devopl;
    9589};
    9690
    97 static snd_card_t *snd_dt019x_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    98 
    99 #ifdef __ISAPNP__
    100 static struct isapnp_card *snd_dt019x_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    101 static const struct isapnp_card_id *snd_dt019x_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    102 
    103 static struct isapnp_card_id snd_dt019x_pnpids[] __devinitdata = {
     91static struct pnp_card_device_id snd_dt019x_pnpids[] __devinitdata = {
    10492        /* DT197A30 */
    105         {
    106                 ISAPNP_CARD_ID('R','W','B',0x1688),
    107                 .devs = { ISAPNP_DEVICE_ID('@','@','@',0x0001),
    108                         ISAPNP_DEVICE_ID('@','X','@',0x0001),
    109                         ISAPNP_DEVICE_ID('@','H','@',0x0001) }
    110         },
     93        { .id = "RWB1688", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" }, } },
    11194        /* DT0196 / ALS-007 */
    112         {
    113                 ISAPNP_CARD_ID('A','L','S',0x0007),
    114                 .devs = { ISAPNP_DEVICE_ID('@','@','@',0x0001),
    115                         ISAPNP_DEVICE_ID('@','X','@',0x0001),
    116                         ISAPNP_DEVICE_ID('@','H','@',0x0001) }
    117         },
    118         { ISAPNP_CARD_END, }
     95        { .id = "ALS0007", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" }, } },
     96        { .id = "",  }
    11997};
    12098
    121 ISAPNP_CARD_TABLE(snd_dt019x_pnpids);
    122 
    123 #endif  /* __ISAPNP__ */
     99MODULE_DEVICE_TABLE(pnp_card, snd_dt019x_pnpids);
     100
    124101
    125102#define DRIVER_NAME     "snd-card-dt019x"
    126103
    127104
    128 #ifdef __ISAPNP__
    129 static int __init snd_card_dt019x_isapnp(int dev, struct snd_card_dt019x *acard)
    130 {
    131         const struct isapnp_card_id *id = snd_dt019x_isapnp_id[dev];
    132         struct isapnp_card *card = snd_dt019x_isapnp_cards[dev];
    133         struct isapnp_dev *pdev;
    134 
    135         acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    136         if (acard->dev->active) {
    137                 acard->dev = NULL;
    138                 return -EBUSY;
    139         }
    140         acard->devmpu = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
    141         if (acard->devmpu->active) {
    142                 acard->dev = acard->devmpu = NULL;
    143                 return -EBUSY;
    144         }
    145         acard->devopl = isapnp_find_dev(card, id->devs[2].vendor, id->devs[2].function, NULL);
    146         if (acard->devopl->active) {
    147                 acard->dev = acard->devmpu = acard->devopl = NULL;
    148                 return -EBUSY;
    149         }
     105static int __devinit snd_card_dt019x_pnp(int dev, struct snd_card_dt019x *acard,
     106                                         struct pnp_card_link *card,
     107                                         const struct pnp_card_device_id *pid)
     108{
     109        struct pnp_dev *pdev;
     110        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
     111        int err;
     112
     113        if (!cfg)
     114                return -ENOMEM;
     115
     116        acard->dev = pnp_request_card_device(card, pid->devs[0].id, NULL);
     117        if (acard->dev == NULL) {
     118                kfree (cfg);
     119                return -ENODEV;
     120        }
     121        acard->devmpu = pnp_request_card_device(card, pid->devs[1].id, NULL);
     122        acard->devopl = pnp_request_card_device(card, pid->devs[2].id, NULL);
    150123
    151124        pdev = acard->dev;
    152         if (!pdev || pdev->prepare(pdev)<0)
    153                 return -EAGAIN;
     125        pnp_init_resource_table(cfg);
    154126
    155127        if (port[dev] != SNDRV_AUTO_PORT)
    156                 isapnp_resource_change(&pdev->resource[0], port[dev], 16);
     128                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
    157129        if (dma8[dev] != SNDRV_AUTO_DMA)
    158                 isapnp_resource_change(&pdev->dma_resource[0], dma8[dev],
     130                pnp_resource_change(&cfg->dma_resource[0], dma8[dev],
    159131                        1);
    160132        if (irq[dev] != SNDRV_AUTO_IRQ)
    161                 isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
    162 
    163         if (pdev->activate(pdev)<0) {
    164                 printk(KERN_ERR PFX "DT-019X AUDIO isapnp configure failure\n");
    165                 return -EBUSY;
    166         }
    167         port[dev] = pdev->resource[0].start;
    168         dma8[dev] = pdev->dma_resource[0].start;
    169         irq[dev] = pdev->irq_resource[0].start;
     133                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
     134
     135        if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
     136                snd_printk(KERN_ERR PFX "DT-019X AUDIO the requested resources are invalid, using auto config\n");
     137        err = pnp_activate_dev(pdev);
     138        if (err < 0) {
     139                snd_printk(KERN_ERR PFX "DT-019X AUDIO pnp configure failure\n");
     140                kfree(cfg);
     141                return err;
     142        }
     143
     144        port[dev] = pnp_port_start(pdev, 0);
     145        dma8[dev] = pnp_dma(pdev, 0);
     146        irq[dev] = pnp_irq(pdev, 0);
    170147        snd_printdd("dt019x: found audio interface: port=0x%lx, irq=0x%lx, dma=0x%lx\n",
    171148                        port[dev],irq[dev],dma8[dev]);
    172149
    173150        pdev = acard->devmpu;
    174         if (!pdev || pdev->prepare(pdev)<0)
    175                 return 0;
    176 
    177         if (mpu_port[dev] != SNDRV_AUTO_PORT)
    178                 isapnp_resource_change(&pdev->resource[0], mpu_port[dev],
    179                         2);
    180         if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
    181                 isapnp_resource_change(&pdev->irq_resource[0], mpu_irq[dev],
    182                         1);
    183 
    184         if (pdev->activate(pdev)<0) {
    185                 printk(KERN_ERR PFX "DT-019X MPU-401 isapnp configure failure\n");
    186                 mpu_port[dev] = -1;
    187                 acard->devmpu = NULL;
    188         } else {
    189                 mpu_port[dev] = pdev->resource[0].start;
    190                 mpu_irq[dev] = pdev->irq_resource[0].start;
     151
     152        if (pdev != NULL) {
     153                pnp_init_resource_table(cfg);
     154                if (mpu_port[dev] != SNDRV_AUTO_PORT)
     155                        pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
     156                if (mpu_irq[dev] != SNDRV_AUTO_IRQ)
     157                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
     158                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
     159                        snd_printk(KERN_ERR PFX "DT-019X MPU401 the requested resources are invalid, using auto config\n");
     160                err = pnp_activate_dev(pdev);
     161                if (err < 0)
     162                        goto __mpu_error;
     163                mpu_port[dev] = pnp_port_start(pdev, 0);
     164                mpu_irq[dev] = pnp_irq(pdev, 0);
    191165                snd_printdd("dt019x: found MPU-401: port=0x%lx, irq=0x%lx\n",
    192166                                mpu_port[dev],mpu_irq[dev]);
     167        } else {
     168                __mpu_error:
     169                if (pdev) {
     170                        pnp_release_card_device(pdev);
     171                        snd_printk(KERN_ERR PFX "DT-019X MPU401 pnp configure failure, skipping\n");
     172                }
     173                acard->devmpu = NULL;
     174                mpu_port[dev] = -1;
    193175        }
    194176
    195177        pdev = acard->devopl;
    196         if (!pdev || pdev->prepare(pdev)<0)
    197                 return 0;
    198 
    199         if (fm_port[dev] != SNDRV_AUTO_PORT)
    200                 isapnp_resource_change(&pdev->resource[0], fm_port[dev], 4);
    201 
    202         if (pdev->activate(pdev)<0) {
    203                 printk(KERN_ERR PFX "DT-019X OPL3 isapnp configure failure\n");
     178        if (pdev != NULL) {
     179                pnp_init_resource_table(cfg);
     180                if (fm_port[dev] != SNDRV_AUTO_PORT)
     181                        pnp_resource_change(&cfg->port_resource[0], fm_port[dev], 4);
     182                if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
     183                        snd_printk(KERN_ERR PFX "DT-019X OPL3 the requested resources are invalid, using auto config\n");
     184                err = pnp_activate_dev(pdev);
     185                if (err < 0)
     186                        goto __fm_error;
     187                fm_port[dev] = pnp_port_start(pdev, 0);
     188                snd_printdd("dt019x: found OPL3 synth: port=0x%lx\n",fm_port[dev]);
     189        } else {
     190                __fm_error:
     191                if (pdev) {
     192                        pnp_release_card_device(pdev);
     193                        snd_printk(KERN_ERR PFX "DT-019X OPL3 pnp configure failure, skipping\n");
     194                }
     195                acard->devopl = NULL;
    204196                fm_port[dev] = -1;
    205                 acard->devopl = NULL;
    206         } else {
    207                 fm_port[dev] = pdev->resource[0].start;
    208                 snd_printdd("dt019x: found OPL3 synth: port=0x%lx\n",fm_port[dev]);
    209         }
    210 
     197        }
     198
     199        kfree(cfg);
    211200        return 0;
    212201}
    213202
    214 static void snd_card_dt019x_deactivate(struct snd_card_dt019x *acard)
    215 {
    216         if (acard->dev) {
    217                 acard->dev->deactivate(acard->dev);
    218                 acard->dev = NULL;
    219         }
    220         if (acard->devmpu) {
    221                 acard->devmpu->deactivate(acard->devmpu);
    222                 acard->devmpu = NULL;
    223         }
    224         if (acard->devopl) {
    225                 acard->devopl->deactivate(acard->devopl);
    226                 acard->devopl = NULL;
    227         }
    228 }
    229 #endif  /* __ISAPNP__ */
    230 
    231 static void snd_card_dt019x_free(snd_card_t *card)
    232 {
    233         struct snd_card_dt019x *acard = (struct snd_card_dt019x *)card->private_data;
    234 
    235         if (acard != NULL) {
    236 #ifdef __ISAPNP__
    237                 snd_card_dt019x_deactivate(acard);
    238 #endif  /* __ISAPNP__ */
    239         }
    240 }
    241 
    242 static int __init snd_card_dt019x_probe(int dev)
     203static int __devinit snd_card_dt019x_probe(int dev, struct pnp_card_link *pcard, const struct pnp_card_device_id *pid)
    243204{
    244205        int error;
     
    252213                return -ENOMEM;
    253214        acard = (struct snd_card_dt019x *)card->private_data;
    254         card->private_free = snd_card_dt019x_free;
    255 
    256 #ifdef __ISAPNP__
    257         if ((error = snd_card_dt019x_isapnp(dev, acard))) {
    258                 snd_card_free(card);
    259                 return error;
    260         }
    261 #else
    262         printk(KERN_ERR PFX "you have to enable PnP support ...\n");
    263         snd_card_free(card);
    264         return -ENOSYS;
    265 #endif  /* __ISAPNP__ */
     215
     216        if ((error = snd_card_dt019x_pnp(dev, acard, pcard, pid))) {
     217                snd_card_free(card);
     218                return error;
     219        }
    266220
    267221        if ((error = snd_sbdsp_create(card, port[dev],
     
    293247                                        SA_INTERRUPT,
    294248                                        NULL) < 0)
    295                         printk(KERN_ERR PFX "no MPU-401 device at 0x%lx ?\n",
    296                                 mpu_port[dev]);
     249                        snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx ?\n", mpu_port[dev]);
    297250        }
    298251
     
    302255                                    fm_port[dev] + 2,
    303256                                    OPL3_HW_AUTO, 0, &opl3) < 0) {
    304                         printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx ?\n",
    305                                 fm_port[dev], fm_port[dev] + 2);
     257                        snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx ?\n",
     258                                   fm_port[dev], fm_port[dev] + 2);
    306259                } else {
    307260                        if ((error = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
     
    325278                return error;
    326279        }
    327         snd_dt019x_cards[dev] = card;
     280        pnp_set_card_drvdata(pcard, card);
    328281        return 0;
    329282}
    330283
    331 #ifdef __ISAPNP__
    332 static int __init snd_dt019x_isapnp_detect(struct isapnp_card *card,
    333                                             const struct isapnp_card_id *id)
     284static int __devinit snd_dt019x_pnp_probe(struct pnp_card_link *card,
     285                                          const struct pnp_card_device_id *pid)
    334286{
    335287        static int dev;
     
    339291                if (!enable[dev])
    340292                        continue;
    341                 snd_dt019x_isapnp_cards[dev] = card;
    342                 snd_dt019x_isapnp_id[dev] = id;
    343                 res = snd_card_dt019x_probe(dev);
     293                res = snd_card_dt019x_probe(dev, card, pid);
    344294                if (res < 0)
    345295                        return res;
     
    349299        return -ENODEV;
    350300}
    351 #endif /* __ISAPNP__ */
     301
     302static void __devexit snd_dt019x_pnp_remove(struct pnp_card_link * pcard)
     303{
     304        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     305        snd_card_disconnect(card);
     306        snd_card_free_in_thread(card);
     307}
     308
     309static struct pnp_card_driver dt019x_pnpc_driver = {
     310        .flags          = PNP_DRIVER_RES_DISABLE,
     311        .name           = "dt019x",
     312        .id_table       = snd_dt019x_pnpids,
     313        .probe          = snd_dt019x_pnp_probe,
     314        .remove         = __devexit_p(snd_dt019x_pnp_remove),
     315};
    352316
    353317static int __init alsa_card_dt019x_init(void)
     
    355319        int cards = 0;
    356320
    357 #ifdef __ISAPNP__
    358         cards += isapnp_probe_cards(snd_dt019x_pnpids, snd_dt019x_isapnp_detect);
    359 #else
    360         printk(KERN_ERR PFX "you have to enable ISA PnP support.\n");
    361 #endif
     321        cards += pnp_register_card_driver(&dt019x_pnpc_driver);
     322
    362323#ifdef MODULE
    363324        if (!cards)
    364                 printk(KERN_ERR "no DT-019X / ALS-007 based soundcards found\n");
     325                snd_printk(KERN_ERR "no DT-019X / ALS-007 based soundcards found\n");
    365326#endif
    366327        return cards ? 0 : -ENODEV;
     
    369330static void __exit alsa_card_dt019x_exit(void)
    370331{
    371         int dev;
    372 
    373         for (dev = 0; dev < SNDRV_CARDS; dev++)
    374                 snd_card_free(snd_dt019x_cards[dev]);
     332        pnp_unregister_card_driver(&dt019x_pnpc_driver);
    375333}
    376334
  • GPL/branches/alsa-resync1/alsa-kernel/isa/es1688/es1688_lib.c

    r224 r246  
    483483}
    484484
    485 void snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    486 {
    487         es1688_t *chip = snd_magic_cast(es1688_t, dev_id, return);
     485irqreturn_t snd_es1688_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     486{
     487        es1688_t *chip = snd_magic_cast(es1688_t, dev_id, return IRQ_NONE);
    488488
    489489        if (chip->trigger_value == 0x05)        /* ok.. playback is active */
     
    493493
    494494        inb(ES1688P(chip, DATA_AVAIL)); /* ack interrupt */
     495        return IRQ_HANDLED;
    495496}
    496497
  • GPL/branches/alsa-resync1/alsa-kernel/isa/es18xx.c

    r224 r246  
    7171#include <linux/pm.h>
    7272#include <linux/slab.h>
    73 #ifndef LINUX_ISAPNP_H
     73#include <linux/pnp.h>
    7474#include <linux/isapnp.h>
    75 #define isapnp_card pci_bus
    76 #define isapnp_dev pci_dev
    77 #endif
    7875#include <sound/core.h>
    7976#include <sound/control.h>
     
    731728}
    732729
    733 static void snd_es18xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    734 {
    735         es18xx_t *chip = snd_magic_cast(es18xx_t, dev_id, return);
     730static irqreturn_t snd_es18xx_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     731{
     732        es18xx_t *chip = snd_magic_cast(es18xx_t, dev_id, return IRQ_NONE);
    736733        unsigned char status;
    737 
    738734
    739735        if (chip->caps & ES18XX_CONTROL) {
     
    791787                snd_es18xx_mixer_write(chip, 0x66, 0x00);
    792788        }
    793 
     789        return IRQ_HANDLED;
    794790}
    795791
     
    12641260
    12651261#if 0
    1266 static int __init snd_es18xx_config_read(es18xx_t *chip, unsigned char reg)
     1262static int __devinit snd_es18xx_config_read(es18xx_t *chip, unsigned char reg)
    12671263{
    12681264        int data;
     
    12761272#endif
    12771273
    1278 static void __init snd_es18xx_config_write(es18xx_t *chip,
     1274static void __devinit snd_es18xx_config_write(es18xx_t *chip,
    12791275                                           unsigned char reg, unsigned char data)
    12801276{
     
    12881284}
    12891285
    1290 static int __init snd_es18xx_initialize(es18xx_t *chip)
     1286static int __devinit snd_es18xx_initialize(es18xx_t *chip)
    12911287{
    12921288        int mask = 0;
     
    14371433}
    14381434
    1439 static int __init snd_es18xx_identify(es18xx_t *chip)
     1435static int __devinit snd_es18xx_identify(es18xx_t *chip)
    14401436{
    14411437        int hi,lo;
     
    15011497}
    15021498
    1503 static int __init snd_es18xx_probe(es18xx_t *chip)
     1499static int __devinit snd_es18xx_probe(es18xx_t *chip)
    15041500{
    15051501        if (snd_es18xx_identify(chip) < 0) {
    1506                 printk(KERN_ERR PFX "[0x%lx] ESS chip not found\n", chip->port);
     1502                snd_printk(KERN_ERR PFX "[0x%lx] ESS chip not found\n", chip->port);
    15071503                return -ENODEV;
    15081504        }
     
    15701566}
    15711567
    1572 int __init snd_es18xx_pcm(es18xx_t *chip, int device, snd_pcm_t ** rpcm)
     1568int __devinit snd_es18xx_pcm(es18xx_t *chip, int device, snd_pcm_t ** rpcm)
    15731569{
    15741570        snd_pcm_t *pcm;
     
    17151711}
    17161712
    1717 static int __init snd_es18xx_new_device(snd_card_t * card,
     1713static int __devinit snd_es18xx_new_device(snd_card_t * card,
    17181714                                        unsigned long port,
    17191715                                        unsigned long mpu_port,
     
    17471743        if ((chip->res_port = request_region(port, 16, "ES18xx")) == NULL) {
    17481744                snd_es18xx_free(chip);
    1749                 printk(KERN_ERR PFX "unable to grap ports 0x%lx-0x%lx\n", port, port + 16 - 1);
     1745                snd_printk(KERN_ERR PFX "unable to grap ports 0x%lx-0x%lx\n", port, port + 16 - 1);
    17501746                return -EBUSY;
    17511747        }
     
    17531749        if (request_irq(irq, snd_es18xx_interrupt, SA_INTERRUPT, "ES18xx", (void *) chip)) {
    17541750                snd_es18xx_free(chip);
    1755                 printk(KERN_ERR PFX "unable to grap IRQ %d\n", irq);
     1751                snd_printk(KERN_ERR PFX "unable to grap IRQ %d\n", irq);
    17561752                return -EBUSY;
    17571753        }
     
    17601756        if (request_dma(dma1, "ES18xx DMA 1")) {
    17611757                snd_es18xx_free(chip);
    1762                 printk(KERN_ERR PFX "unable to grap DMA1 %d\n", dma1);
     1758                snd_printk(KERN_ERR PFX "unable to grap DMA1 %d\n", dma1);
    17631759                return -EBUSY;
    17641760        }
     
    17671763        if (dma2 != dma1 && request_dma(dma2, "ES18xx DMA 2")) {
    17681764                snd_es18xx_free(chip);
    1769                 printk(KERN_ERR PFX "unable to grap DMA2 %d\n", dma2);
     1765                snd_printk(KERN_ERR PFX "unable to grap DMA2 %d\n", dma2);
    17701766                return -EBUSY;
    17711767        }
     
    17841780}
    17851781
    1786 static int __init snd_es18xx_mixer(es18xx_t *chip)
     1782static int __devinit snd_es18xx_mixer(es18xx_t *chip)
    17871783{
    17881784        snd_card_t *card;
     
    18871883static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
    18881884static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
    1889 #ifdef __ISAPNP__
     1885#ifdef CONFIG_PNP
    18901886#ifdef TARGET_OS2
    18911887static int isapnp[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
     
    18951891#endif
    18961892static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* 0x220,0x240,0x260,0x280 */
    1897 #ifndef __ISAPNP__
     1893#ifndef CONFIG_PNP
    18981894#ifdef TARGET_OS2
    18991895static long mpu_port[SNDRV_CARDS] = {-1,-1,-1,-1,-1,-1,-1,-1};
     
    19171913MODULE_PARM_DESC(enable, "Enable ES18xx soundcard.");
    19181914MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
    1919 #ifdef __ISAPNP__
     1915#ifdef CONFIG_PNP
    19201916MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
    1921 MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
     1917MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
    19221918MODULE_PARM_SYNTAX(isapnp, SNDRV_ISAPNP_DESC);
    19231919#endif
     
    19421938
    19431939struct snd_audiodrive {
    1944 #ifdef __ISAPNP__
    1945         struct isapnp_dev *dev;
    1946         struct isapnp_dev *devc;
     1940#ifdef CONFIG_PNP
     1941        struct pnp_dev *dev;
     1942        struct pnp_dev *devc;
    19471943#endif
    19481944};
    19491945
    1950 static snd_card_t *snd_audiodrive_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    1951 
    1952 #ifdef __ISAPNP__
    1953 
    1954 static struct isapnp_card *snd_audiodrive_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    1955 static const struct isapnp_card_id *snd_audiodrive_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    1956 
    1957 #define ISAPNP_ES18XX(_va, _vb, _vc, _device, _audio, _control) \
    1958         { \
    1959                 ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    1960                 .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    1961                          ISAPNP_DEVICE_ID(_va, _vb, _vc, _control) } \
    1962         }
    1963 
    1964 static struct isapnp_card_id snd_audiodrive_pnpids[] __devinitdata = {
     1946static snd_card_t *snd_audiodrive_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
     1947
     1948#ifdef CONFIG_PNP
     1949
     1950static struct pnp_card_device_id snd_audiodrive_pnpids[] __devinitdata = {
    19651951        /* ESS 1868 (integrated on Compaq dual P-Pro motherboard and Genius 18PnP 3D) */
    1966         ISAPNP_ES18XX('E','S','S',0x1868,0x1868,0x0000),
     1952        { .id = "ESS1868", .devs = { { "ESS1868" }, { "ESS0000" } } },
    19671953        /* ESS 1868 (integrated on Maxisound Cards) */
    1968         ISAPNP_ES18XX('E','S','S',0x1868,0x8601,0x8600),
     1954        { .id = "ESS1868", .devs = { { "ESS8601" }, { "ESS8600" } } },
    19691955        /* ESS 1868 (integrated on Maxisound Cards) */
    1970         ISAPNP_ES18XX('E','S','S',0x1868,0x8611,0x8610),
     1956        { .id = "ESS1868", .devs = { { "ESS8611" }, { "ESS8610" } } },
    19711957        /* ESS ES1869 Plug and Play AudioDrive */
    1972         ISAPNP_ES18XX('E','S','S',0x0003,0x1869,0x0006),
     1958        { .id = "ESS0003", .devs = { { "ESS1869" }, { "ESS0006" } } },
    19731959        /* ESS 1869 */
    1974         ISAPNP_ES18XX('E','S','S',0x1869,0x1869,0x0006),
     1960        { .id = "ESS1869", .devs = { { "ESS1869" }, { "ESS0006" } } },
    19751961        /* ESS 1878 */
    1976         ISAPNP_ES18XX('E','S','S',0x1878,0x1878,0x0004),
     1962        { .id = "ESS1878", .devs = { { "ESS1878" }, { "ESS0004" } } },
    19771963        /* ESS 1879 */
    1978         ISAPNP_ES18XX('E','S','S',0x1879,0x1879,0x0009),
     1964        { .id = "ESS1879", .devs = { { "ESS1879" }, { "ESS0009" } } },
    19791965        /* --- */
    1980         { ISAPNP_CARD_END, } /* end */
     1966        { .id = "" } /* end */
    19811967};
    19821968
    1983 ISAPNP_CARD_TABLE(snd_audiodrive_pnpids);
    1984 
    1985 static int __init snd_audiodrive_isapnp(int dev, struct snd_audiodrive *acard)
    1986 {
    1987         const struct isapnp_card_id *id = snd_audiodrive_isapnp_id[dev];
    1988         struct isapnp_card *card = snd_audiodrive_isapnp_cards[dev];
    1989         struct isapnp_dev *pdev;
    1990 
    1991         acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    1992         if (acard->dev->active) {
    1993                 acard->dev = NULL;
     1969MODULE_DEVICE_TABLE(pnp_card, snd_audiodrive_pnpids);
     1970
     1971static int __devinit snd_audiodrive_pnp(int dev, struct snd_audiodrive *acard,
     1972                                        struct pnp_card_link *card,
     1973                                        const struct pnp_card_device_id *id)
     1974{
     1975        struct pnp_dev *pdev;
     1976        struct pnp_resource_table * cfg = kmalloc(GFP_ATOMIC, sizeof(struct pnp_resource_table));
     1977        int err;
     1978
     1979        if (!cfg)
     1980                return -ENOMEM;
     1981        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
     1982        if (acard->dev == NULL) {
     1983                kfree(cfg);
    19941984                return -EBUSY;
    19951985        }
    1996         acard->devc = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
    1997         if (acard->devc->active) {
    1998                 acard->dev = acard->devc = NULL;
     1986        acard->devc = pnp_request_card_device(card, id->devs[1].id, NULL);
     1987        if (acard->devc == NULL) {
     1988                kfree(cfg);
    19991989                return -EBUSY;
    20001990        }
    20011991        /* Control port initialization */
    2002         if (acard->devc->prepare(acard->devc)<0)
     1992        err = pnp_activate_dev(acard->devc);
     1993        if (err < 0) {
     1994                snd_printk(KERN_ERR PFX "PnP control configure failure (out of resources?)\n");
    20031995                return -EAGAIN;
    2004         if (acard->devc->activate(acard->devc)<0) {
    2005                 printk(KERN_ERR PFX "isapnp control configure failure (out of resources?)\n");
    2006                 return -EAGAIN;
    2007         }
    2008         snd_printdd("isapnp: port=0x%lx\n", acard->devc->resource[0].start);
     1996        }
     1997        snd_printdd("pnp: port=0x%lx\n", pnp_port_start(acard->devc, 0));
    20091998        /* PnP initialization */
    20101999        pdev = acard->dev;
    2011         if (pdev->prepare(pdev)<0) {
    2012                 acard->devc->deactivate(acard->devc);
    2013                 return -EAGAIN;
    2014         }
     2000        pnp_init_resource_table(cfg);
    20152001        if (port[dev] != SNDRV_AUTO_PORT)
    2016                 isapnp_resource_change(&pdev->resource[0], port[dev], 16);
     2002                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
    20172003        if (fm_port[dev] != SNDRV_AUTO_PORT)
    2018                 isapnp_resource_change(&pdev->resource[1], fm_port[dev], 4);
     2004                pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
    20192005        if (mpu_port[dev] != SNDRV_AUTO_PORT)
    2020                 isapnp_resource_change(&pdev->resource[2], mpu_port[dev], 2);
     2006                pnp_resource_change(&cfg->port_resource[2], mpu_port[dev], 2);
    20212007        if (dma1[dev] != SNDRV_AUTO_DMA)
    2022                 isapnp_resource_change(&pdev->dma_resource[0], dma1[dev], 1);
     2008                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
    20232009        if (dma2[dev] != SNDRV_AUTO_DMA)
    2024                 isapnp_resource_change(&pdev->dma_resource[1], dma2[dev], 1);
     2010                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
    20252011        if (irq[dev] != SNDRV_AUTO_IRQ)
    2026                 isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
    2027         if (pdev->activate(pdev)<0) {
    2028                 printk(KERN_ERR PFX "isapnp configure failure (out of resources?)\n");
    2029                 acard->devc->deactivate(acard->devc);
     2012                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
     2013        err = pnp_manual_config_dev(pdev, cfg, 0);
     2014        if (err < 0)
     2015                snd_printk(KERN_ERR PFX "PnP manual resources are invalid, using auto config\n");
     2016        err = pnp_activate_dev(pdev);
     2017        if (err < 0) {
     2018                snd_printk(KERN_ERR PFX "PnP configure failure (out of resources?)\n");
     2019                kfree(cfg);
    20302020                return -EBUSY;
    20312021        }
    20322022        /* ok. hack using Vendor-Defined Card-Level registers */
    20332023        /* skip csn and logdev initialization - already done in isapnp_configure */
    2034         isapnp_cfg_begin(pdev->bus->number, pdev->devfn);
    2035         isapnp_write_byte(0x27, pdev->irq_resource[0].start);   /* Hardware Volume IRQ Number */
     2024        if (pnp_device_is_isapnp(pdev)) {
     2025                isapnp_cfg_begin(isapnp_card_number(pdev), isapnp_csn_number(pdev));
     2026                isapnp_write_byte(0x27, pnp_irq(pdev, 0));      /* Hardware Volume IRQ Number */
    20362027        if (mpu_port[dev] != SNDRV_AUTO_PORT)
    2037                 isapnp_write_byte(0x28, pdev->irq);             /* MPU-401 IRQ Number */
    2038         isapnp_write_byte(0x72, pdev->irq_resource[0].start);   /* second IRQ */
     2028                        isapnp_write_byte(0x28, pnp_irq(pdev, 0)); /* MPU-401 IRQ Number */
     2029                isapnp_write_byte(0x72, pnp_irq(pdev, 0));      /* second IRQ */
    20392030        isapnp_cfg_end();
    2040         port[dev] = pdev->resource[0].start;
    2041         fm_port[dev] = pdev->resource[1].start;
    2042         mpu_port[dev] = pdev->resource[2].start;
    2043         dma1[dev] = pdev->dma_resource[0].start;
    2044         dma2[dev] = pdev->dma_resource[1].start;
    2045         irq[dev] = pdev->irq_resource[0].start;
    2046         snd_printdd("isapnp ES18xx: port=0x%lx, fm port=0x%lx, mpu port=0x%lx\n", port[dev], fm_port[dev], mpu_port[dev]);
    2047         snd_printdd("isapnp ES18xx: dma1=%i, dma2=%i, irq=%i\n", dma1[dev], dma2[dev], irq[dev]);
    2048         return 0;
    2049 }
    2050 
    2051 static void snd_audiodrive_deactivate(struct snd_audiodrive *acard)
    2052 {
    2053         if (acard->devc) {
    2054                 acard->devc->deactivate(acard->devc);
    2055                 acard->devc = NULL;
    2056         }
    2057         if (acard->dev) {
    2058                 acard->dev->deactivate(acard->dev);
    2059                 acard->dev = NULL;
    2060         }
    2061 }
    2062 #endif /* __ISAPNP__ */
    2063 
    2064 static void snd_audiodrive_free(snd_card_t *card)
    2065 {
    2066         struct snd_audiodrive *acard = (struct snd_audiodrive *)card->private_data;
    2067 
    2068         if (acard) {
    2069 #ifdef __ISAPNP__
    2070                 snd_audiodrive_deactivate(acard);
    2071 #endif
    2072         }
    2073 }
    2074 
    2075 static int __init snd_audiodrive_probe(int dev)
     2031        } else {
     2032                snd_printk(KERN_ERR PFX "unable to install ISA PnP hack, expect malfunction\n");
     2033        }
     2034        port[dev] = pnp_port_start(pdev, 0);
     2035        fm_port[dev] = pnp_port_start(pdev, 1);
     2036        mpu_port[dev] = pnp_port_start(pdev, 2);
     2037        dma1[dev] = pnp_dma(pdev, 0);
     2038        dma2[dev] = pnp_dma(pdev, 1);
     2039        irq[dev] = pnp_irq(pdev, 0);
     2040        snd_printdd("PnP ES18xx: port=0x%lx, fm port=0x%lx, mpu port=0x%lx\n", port[dev], fm_port[dev], mpu_port[dev]);
     2041        snd_printdd("PnP ES18xx: dma1=%i, dma2=%i, irq=%i\n", dma1[dev], dma2[dev], irq[dev]);
     2042        kfree(cfg);
     2043        return 0;
     2044}
     2045#endif /* CONFIG_PNP_ */
     2046
     2047static int __devinit snd_audiodrive_probe(int dev, struct pnp_card_link *pcard,
     2048                                          const struct pnp_card_device_id *pid)
    20762049{
    20772050        static int possible_irqs[] = {5, 9, 10, 7, 11, 12, -1};
     
    20902063                return -ENOMEM;
    20912064        acard = (struct snd_audiodrive *)card->private_data;
    2092         card->private_free = snd_audiodrive_free;
    2093 #ifdef __ISAPNP__
    2094         if (isapnp[dev] && (err = snd_audiodrive_isapnp(dev, acard)) < 0) {
     2065#ifdef CONFIG_PNP
     2066        if (isapnp[dev] && (err = snd_audiodrive_pnp(dev, acard, pcard, pid)) < 0) {
    20952067                snd_card_free(card);
    20962068                return err;
     
    21432115        if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
    21442116        if (snd_opl3_create(card, chip->fm_port, chip->fm_port + 2, OPL3_HW_OPL3, 0, &opl3) < 0) {
    2145                         printk(KERN_ERR PFX "opl3 not detected at 0x%lx\n", chip->fm_port);
     2117                        snd_printk(KERN_ERR PFX "opl3 not detected at 0x%lx\n", chip->fm_port);
    21462118        } else {
    21472119                if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
     
    21892161                return err;
    21902162        }
    2191         snd_audiodrive_cards[dev] = card;
    2192         return 0;
    2193 }
    2194 
    2195 static int __init snd_audiodrive_probe_legacy_port(unsigned long xport)
     2163        if (pcard)
     2164                pnp_set_card_drvdata(pcard, card);
     2165        else
     2166                snd_audiodrive_legacy[dev] = card;
     2167        return 0;
     2168}
     2169
     2170static int __devinit snd_audiodrive_probe_legacy_port(unsigned long xport)
    21962171{
    21972172        static int dev;
     
    22012176                if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT)
    22022177                        continue;
    2203 #ifdef __ISAPNP__
     2178#ifdef CONFIG_PNP
    22042179                if (isapnp[dev])
    22052180                        continue;
    22062181#endif
    22072182                port[dev] = xport;
    2208                 res = snd_audiodrive_probe(dev);
     2183                res = snd_audiodrive_probe(dev, NULL, NULL);
    22092184                if (res < 0)
    22102185                        port[dev] = SNDRV_AUTO_PORT;
     
    22152190
    22162191
    2217 #ifdef __ISAPNP__
    2218 static int __init snd_audiodrive_isapnp_detect(struct isapnp_card *card,
    2219                                                const struct isapnp_card_id *id)
     2192#ifdef CONFIG_PNP
     2193static int __devinit snd_audiodrive_pnp_detect(struct pnp_card_link *card,
     2194                                               const struct pnp_card_device_id *id)
    22202195{
    22212196        static int dev;
     
    22252200                if (!enable[dev] || !isapnp[dev])
    22262201                        continue;
    2227                 snd_audiodrive_isapnp_cards[dev] = card;
    2228                 snd_audiodrive_isapnp_id[dev] = id;
    2229                 res = snd_audiodrive_probe(dev);
     2202                res = snd_audiodrive_probe(dev, card, id);
    22302203                if (res < 0)
    22312204                        return res;
     
    22362209        return -ENODEV;
    22372210}
    2238 #endif /* __ISAPNP__ */
     2211
     2212static void __devexit snd_audiodrive_pnp_remove(struct pnp_card_link * pcard)
     2213{
     2214        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     2215
     2216        snd_card_disconnect(card);
     2217        snd_card_free_in_thread(card);
     2218}
     2219
     2220static struct pnp_card_driver es18xx_pnpc_driver = {
     2221        .flags = PNP_DRIVER_RES_DISABLE,
     2222        .name = "es18xx",
     2223        .id_table = snd_audiodrive_pnpids,
     2224        .probe = snd_audiodrive_pnp_detect,
     2225        .remove = __devexit_p(snd_audiodrive_pnp_remove),
     2226};
     2227#endif /* CONFIG_PNP */
    22392228
    22402229static int __init alsa_card_es18xx_init(void)
     
    22472236                if (!enable[dev] || port[dev] == SNDRV_AUTO_PORT)
    22482237                        continue;
    2249 #ifdef __ISAPNP__
     2238#ifdef CONFIG_PNP
    22502239                if (isapnp[dev])
    22512240                        continue;
    22522241#endif
    2253                 if (snd_audiodrive_probe(dev) >= 0)
     2242                if (snd_audiodrive_probe(dev, NULL, NULL) >= 0)
    22542243                        cards++;
    22552244        }
    22562245        /* legacy auto configured cards */
    22572246        cards += snd_legacy_auto_probe(possible_ports, snd_audiodrive_probe_legacy_port);
    2258 #ifdef __ISAPNP__
     2247#ifdef CONFIG_PNP
    22592248        /* ISA PnP cards at last */
    2260         cards += isapnp_probe_cards(snd_audiodrive_pnpids, snd_audiodrive_isapnp_detect);
     2249        cards += pnp_register_card_driver(&es18xx_pnpc_driver);
    22612250#endif
    22622251        if(!cards) {
     2252#ifdef CONFIG_PNP
     2253                pnp_unregister_card_driver(&es18xx_pnpc_driver);
     2254#endif
    22632255#ifdef MODULE
    2264                 printk(KERN_ERR "ESS AudioDrive ES18xx soundcard not found or device busy\n");
     2256                snd_printk(KERN_ERR "ESS AudioDrive ES18xx soundcard not found or device busy\n");
    22652257#endif
    22662258                return -ENODEV;
     
    22732265        int idx;
    22742266
     2267#ifdef CONFIG_PNP
     2268        /* PnP cards first */
     2269        pnp_unregister_card_driver(&es18xx_pnpc_driver);
     2270#endif
    22752271        for(idx = 0; idx < SNDRV_CARDS; idx++)
    2276                 snd_card_free(snd_audiodrive_cards[idx]);
     2272                snd_card_free(snd_audiodrive_legacy[idx]);
    22772273}
    22782274
    22792275module_init(alsa_card_es18xx_init)
    22802276module_exit(alsa_card_es18xx_exit)
     2277
    22812278
    22822279#ifndef MODULE
     
    23032300               get_option(&str,&dma1[nr_dev]) == 2 &&
    23042301               get_option(&str,&dma2[nr_dev]) == 2);
    2305 #ifdef __ISAPNP__
     2302#ifdef CONFIG_PNP
    23062303        if (pnp != INT_MAX)
    23072304                isapnp[nr_dev] = pnp;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gus_irq.c

    r210 r246  
    3131#endif
    3232
    33 void snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     33irqreturn_t snd_gus_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    3434{
    35         snd_gus_card_t * gus = snd_magic_cast(snd_gus_card_t, dev_id, return);
     35        snd_gus_card_t * gus = snd_magic_cast(snd_gus_card_t, dev_id, return IRQ_NONE);
    3636        unsigned char status;
    3737        int loop = 100;
    38        
    39       __again:
     38        int handled = 0;
     39
     40__again:
    4041        status = inb(gus->gf1.reg_irqstat);
    4142        if (status == 0)
    42                 return;
     43                return IRQ_RETVAL(handled);
     44        handled = 1;
    4345        // snd_printk("IRQ: status = 0x%x\n", status);
    4446        if (status & 0x02) {
     
    102104        if (--loop > 0)
    103105                goto __again;
     106        return IRQ_NONE;
    104107}
    105108
  • GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gusmax.c

    r212 r246  
    137137}
    138138
    139 static void snd_gusmax_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     139static irqreturn_t snd_gusmax_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    140140{
    141141        struct snd_gusmax *maxcard = (struct snd_gusmax *) dev_id;
    142142        int loop, max = 5;
     143        int handled = 0;
    143144
    144145        do {
    145146                loop = 0;
    146147                if (inb(maxcard->gus_status_reg)) {
     148                        handled = 1;
    147149                        snd_gus_interrupt(irq, maxcard->gus, regs);
    148150                        loop++;
    149151                }
    150152                if (inb(maxcard->pcm_status_reg) & 0x01) { /* IRQ bit is set? */
     153                        handled = 1;
    151154                        snd_cs4231_interrupt(irq, maxcard->cs4231, regs);
    152155                        loop++;
    153156                }
    154157        } while (loop && --max > 0);
     158        return IRQ_RETVAL(handled);
    155159}
    156160
  • GPL/branches/alsa-resync1/alsa-kernel/isa/gus/interwave.c

    r224 r246  
    2828#include <linux/init.h>
    2929#include <linux/slab.h>
    30 #ifndef LINUX_ISAPNP_H
    31 #include <linux/isapnp.h>
    32 #define isapnp_card pci_bus
    33 #define isapnp_dev pci_dev
    34 #endif
     30#include <linux/pnp.h>
    3531#include <sound/core.h>
    3632#include <sound/gus.h>
     
    6359static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
    6460static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
    65 #ifdef __ISAPNP__
     61#ifdef CONFIG_PNP
    6662#ifdef TARGET_OS2
    6763static int isapnp[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
     
    143139        unsigned short gus_status_reg;
    144140        unsigned short pcm_status_reg;
    145 #ifdef __ISAPNP__
    146         struct isapnp_dev *dev;
    147 #ifdef SNDRV_STB
    148         struct isapnp_dev *devtc;
     141#ifdef CONFIG_PNP
     142        struct pnp_dev *dev;
     143#ifdef SNDRV_STB
     144        struct pnp_dev *devtc;
    149145#endif
    150146#endif
    151147};
    152148
    153 static snd_card_t *snd_interwave_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    154 
    155 #ifdef __ISAPNP__
    156 
    157 static struct isapnp_card *snd_interwave_isapnp_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    158 static const struct isapnp_card_id *snd_interwave_isapnp_id[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    159 
    160 #define ISAPNP_INTERWAVE(_va, _vb, _vc, _device, _audio) \
    161         { \
    162                 ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    163                 .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), } \
    164         }
    165 #define ISAPNP_INTERWAVE_STB(_va, _vb, _vc, _device, _audio, _tone) \
    166         { \
    167                 ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    168                 .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    169                          ISAPNP_DEVICE_ID(_va, _vb, _vc, _tone), } \
    170         }
    171 
    172 static struct isapnp_card_id snd_interwave_pnpids[] __devinitdata = {
     149static snd_card_t *snd_interwave_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
     150
     151#ifdef CONFIG_PNP
     152
     153static struct pnp_card_device_id snd_interwave_pnpids[] __devinitdata = {
    173154#ifndef SNDRV_STB
    174155        /* Gravis UltraSound Plug & Play */
    175         ISAPNP_INTERWAVE('G','R','V',0x0001,0x0000),
     156        { .id = "GRV0001", .devs = { { .id = "GRV0000" } } },
    176157        /* STB SoundRage32 */
    177         ISAPNP_INTERWAVE('S','T','B',0x011a,0x0010),
     158        { .id = "STB011a", .devs = { { .id = "STB0010" } } },
    178159        /* MED3210 */
    179         ISAPNP_INTERWAVE('D','X','P',0x3201,0x0010),
     160        { .id = "DXP3201", .devs = { { .id = "DXP0010" } } },
    180161        /* Dynasonic Pro */
    181162        /* This device also have CDC1117:DynaSonix Pro Audio Effects Processor */
    182         ISAPNP_INTERWAVE('C','D','C',0x1111,0x1112),
     163        { .id = "CDC1111", .devs = { { .id = "CDC1112" } } },
    183164        /* Panasonic PCA761AW Audio Card */
    184         ISAPNP_INTERWAVE('A','D','V',0x55ff,0x0010),
     165        { .id = "ADV55ff", .devs = { { .id = "ADV0010" } } },
    185166#else
    186167        /* InterWave STB with TEA6330T */
    187         ISAPNP_INTERWAVE_STB('A','D','V',0x550a,0x0010,0x0015),
    188 #endif
    189         { ISAPNP_CARD_END, }
     168        { .id = "ADV550a", .devs = { { .id = "ADV0010" }, { .id = "ADV0015" } } },
     169#endif
     170        { .id = "" }
    190171};
    191172
    192 ISAPNP_CARD_TABLE(snd_interwave_pnpids);
    193 
    194 #endif /* __ISAPNP__ */
     173MODULE_DEVICE_TABLE(pnp_card, snd_interwave_pnpids);
     174
     175#endif /* CONFIG_PNP */
    195176
    196177
     
    239220};
    240221
    241 static int __init snd_interwave_detect_stb(struct snd_interwave *iwcard,
    242                                            snd_gus_card_t * gus, int dev,
    243                                            snd_i2c_bus_t **rbus)
     222static int __devinit snd_interwave_detect_stb(struct snd_interwave *iwcard,
     223                                              snd_gus_card_t * gus, int dev,
     224                                              snd_i2c_bus_t **rbus)
    244225{
    245226        unsigned long port;
     
    279260#endif
    280261
    281 static int __init snd_interwave_detect(struct snd_interwave *iwcard,
    282                                        snd_gus_card_t * gus,
    283                                        int dev
    284 #ifdef SNDRV_STB
    285                                        , snd_i2c_bus_t **rbus
    286 #endif
    287                                        )
     262static int __devinit snd_interwave_detect(struct snd_interwave *iwcard,
     263                                          snd_gus_card_t * gus,
     264                                          int dev
     265#ifdef SNDRV_STB
     266                                          , snd_i2c_bus_t **rbus
     267#endif
     268                                          )
    288269{
    289270        unsigned long flags;
     
    344325}
    345326
    346 static void snd_interwave_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     327static irqreturn_t snd_interwave_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    347328{
    348329        struct snd_interwave *iwcard = (struct snd_interwave *) dev_id;
    349330        int loop, max = 5;
     331        int handled = 0;
    350332
    351333        do {
    352334                loop = 0;
    353335                if (inb(iwcard->gus_status_reg)) {
     336                        handled = 1;
    354337                        snd_gus_interrupt(irq, iwcard->gus, regs);
    355338                        loop++;
    356339                }
    357340                if (inb(iwcard->pcm_status_reg) & 0x01) {       /* IRQ bit is set? */
     341                        handled = 1;
    358342                        snd_cs4231_interrupt(irq, iwcard->cs4231, regs);
    359343                        loop++;
    360344                }
    361345        } while (loop && --max > 0);
    362 }
    363 
    364 static void __init snd_interwave_reset(snd_gus_card_t * gus)
     346        return IRQ_RETVAL(handled);
     347}
     348
     349static void __devinit snd_interwave_reset(snd_gus_card_t * gus)
    365350{
    366351        snd_gf1_write8(gus, SNDRV_GF1_GB_RESET, 0x00);
     
    370355}
    371356
    372 static void __init snd_interwave_bank_sizes(snd_gus_card_t * gus, int *sizes)
     357static void __devinit snd_interwave_bank_sizes(snd_gus_card_t * gus, int *sizes)
    373358{
    374359        unsigned int idx;
     
    419404};
    420405
    421 static void __init snd_interwave_detect_memory(snd_gus_card_t * gus)
     406static void __devinit snd_interwave_detect_memory(snd_gus_card_t * gus)
    422407{
    423408        static unsigned int lmc[13] =
     
    522507}
    523508
    524 static void __init snd_interwave_init(int dev, snd_gus_card_t * gus)
     509static void __devinit snd_interwave_init(int dev, snd_gus_card_t * gus)
    525510{
    526511        unsigned long flags;
     
    553538};
    554539
    555 static int __init snd_interwave_mixer(cs4231_t *chip)
     540static int __devinit snd_interwave_mixer(cs4231_t *chip)
    556541{
    557542        snd_card_t *card = chip->card;
     
    601586}
    602587
    603 #ifdef __ISAPNP__
    604 
    605 static int __init snd_interwave_isapnp(int dev, struct snd_interwave *iwcard)
    606 {
    607         const struct isapnp_card_id *id = snd_interwave_isapnp_id[dev];
    608         struct isapnp_card *card = snd_interwave_isapnp_cards[dev];
    609         struct isapnp_dev *pdev;
    610 
    611         iwcard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    612         if (iwcard->dev->active) {
    613                 iwcard->dev = NULL;
     588#ifdef CONFIG_PNP
     589
     590static int __devinit snd_interwave_pnp(int dev, struct snd_interwave *iwcard,
     591                                       struct pnp_card_link *card,
     592                                       const struct pnp_card_device_id *id)
     593{
     594        struct pnp_dev *pdev;
     595        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
     596        int err;
     597
     598        iwcard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
     599        if (iwcard->dev == NULL) {
     600                kfree(cfg);
    614601                return -EBUSY;
    615602        }
    616603#ifdef SNDRV_STB
    617         iwcard->devtc = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
    618         if (iwcard->devtc->active) {
    619                 iwcard->dev = iwcard->devtc = NULL;
     604        iwcard->devtc = pnp_request_card_device(card, id->devs[1].id, NULL);
     605        if (iwcard->devtc == NULL) {
     606                kfree(cfg);
    620607                return -EBUSY;
    621608        }
     
    623610        /* Synth & Codec initialization */
    624611        pdev = iwcard->dev;
    625         if (pdev->prepare(pdev)<0)
    626                 return -EAGAIN;
     612        pnp_init_resource_table(cfg);
    627613        if (port[dev] != SNDRV_AUTO_PORT) {
    628                 isapnp_resource_change(&pdev->resource[0], port[dev], 16);
    629                 isapnp_resource_change(&pdev->resource[1], port[dev] + 0x100, 12);
    630                 isapnp_resource_change(&pdev->resource[2], port[dev] + 0x10c, 4);
     614                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
     615                pnp_resource_change(&cfg->port_resource[1], port[dev] + 0x100, 12);
     616                pnp_resource_change(&cfg->port_resource[2], port[dev] + 0x10c, 4);
    631617        }
    632618        if (dma1[dev] != SNDRV_AUTO_DMA)
    633                 isapnp_resource_change(&pdev->dma_resource[0], dma1[dev], 1);
     619                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
    634620        if (dma2[dev] != SNDRV_AUTO_DMA)
    635                 isapnp_resource_change(&pdev->dma_resource[1], dma2[dev], 1);
     621                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
    636622        if (dma2[dev] < 0)
    637                 isapnp_resource_change(&pdev->dma_resource[1], 4, 1);
     623                pnp_resource_change(&cfg->dma_resource[1], 4, 1);
    638624        if (irq[dev] != SNDRV_AUTO_IRQ)
    639                 isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
    640         if (pdev->activate(pdev)<0) {
    641                 snd_printk("isapnp configure failure (out of resources?)\n");
    642                 return -EBUSY;
    643         }
    644         if (pdev->resource[0].start + 0x100 != pdev->resource[1].start ||
    645             pdev->resource[0].start + 0x10c != pdev->resource[2].start) {
    646                 snd_printk("isapnp configure failure (wrong ports)\n");
    647                 pdev->deactivate(pdev);
     625                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
     626        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
     627                snd_printk(KERN_ERR "InterWave - Synth - the requested resources are invalid, using auto config\n");
     628        err = pnp_activate_dev(pdev);
     629        if (err < 0) {
     630                kfree(cfg);
     631                snd_printk(KERN_ERR "InterWave PnP configure failure (out of resources?)\n");
     632                return err;
     633        }
     634        if (pnp_port_start(pdev, 0) + 0x100 != pnp_port_start(pdev, 1) ||
     635            pnp_port_start(pdev, 0) + 0x10c != pnp_port_start(pdev, 2)) {
     636                kfree(cfg);
     637                snd_printk(KERN_ERR "PnP configure failure (wrong ports)\n");
    648638                return -ENOENT;
    649639        }
    650         port[dev] = pdev->resource[0].start;
    651         dma1[dev] = pdev->dma_resource[0].start;
     640        port[dev] = pnp_port_start(pdev, 0);
     641        dma1[dev] = pnp_dma(pdev, 1);
    652642        if (dma2[dev] >= 0)
    653                 dma2[dev] = pdev->dma_resource[1].start;
    654         irq[dev] = pdev->irq_resource[0].start;
     643                dma2[dev] = pnp_dma(pdev, 1);
     644        irq[dev] = pnp_irq(pdev, 0);
    655645        snd_printdd("isapnp IW: sb port=0x%lx, gf1 port=0x%lx, codec port=0x%lx\n",
    656                                 pdev->resource[0].start,
    657                                 pdev->resource[1].start,
    658                                 pdev->resource[2].start);
     646                                pnp_port_start(pdev, 0),
     647                                pnp_port_start(pdev, 1),
     648                                pnp_port_start(pdev, 2));
    659649        snd_printdd("isapnp IW: dma1=%i, dma2=%i, irq=%i\n", dma1[dev], dma2[dev], irq[dev]);
    660650#ifdef SNDRV_STB
    661651        /* Tone Control initialization */
    662652        pdev = iwcard->devtc;
    663         if (pdev->prepare(pdev)<0) {
    664                 iwcard->dev->deactivate(iwcard->dev);
    665                 return -EAGAIN;
    666         }
     653        pnp_init_resource_table(cfg);
    667654        if (port_tc[dev] != SNDRV_AUTO_PORT)
    668                 isapnp_resource_change(&pdev->resource[0], port_tc[dev], 1);
    669         if (pdev->activate(pdev)<0) {
    670                 snd_printk("Tone Control isapnp configure failure (out of resources?)\n");
    671                 iwcard->dev->deactivate(iwcard->dev);
    672                 return -EBUSY;
    673         }
    674         port_tc[dev] = pdev->resource[0].start;
     655                pnp_resource_change(&cfg->port_resource[0], port_tc[dev], 1);
     656        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
     657                snd_printk(KERN_ERR "InterWave - ToneControl - the requested resources are invalid, using auto config\n");
     658        err = pnp_activate_dev(pdev);
     659        if (err < 0) {
     660                kfree(cfg);
     661                snd_printk(KERN_ERR "InterWave ToneControl PnP configure failure (out of resources?)\n");
     662                return err;
     663        }
     664        port_tc[dev] = pnp_port_start(pdev, 0);
    675665        snd_printdd("isapnp IW: tone control port=0x%lx\n", port_tc[dev]);
    676666#endif
     667        kfree(cfg);
    677668        return 0;
    678669}
    679 
    680 static void snd_interwave_deactivate(struct snd_interwave *iwcard)
    681 {
    682         if (iwcard->dev) {
    683                 iwcard->dev->deactivate(iwcard->dev);
    684                 iwcard->dev = NULL;
    685         }
    686 #ifdef SNDRV_STB
    687         if (iwcard->devtc) {
    688                 iwcard->devtc->deactivate(iwcard->devtc);
    689                 iwcard->devtc = NULL;
    690         }
    691 #endif
    692 }
    693 
    694 #endif /* __ISAPNP__ */
     670#endif /* CONFIG_PNP */
    695671
    696672static void snd_interwave_free(snd_card_t *card)
     
    700676        if (iwcard == NULL)
    701677                return;
    702 #ifdef __ISAPNP__
    703         snd_interwave_deactivate(iwcard);
    704 #endif
    705678#ifdef SNDRV_STB
    706679        if (iwcard->i2c_res) {
     
    713686}
    714687
    715 static int __init snd_interwave_probe(int dev)
     688static int __devinit snd_interwave_probe(int dev, struct pnp_card_link *pcard,
     689                                         const struct pnp_card_device_id *pid)
    716690{
    717691        static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1};
     
    737711        iwcard->irq = -1;
    738712        card->private_free = snd_interwave_free;
    739 #ifdef __ISAPNP__
    740         if (isapnp[dev] && snd_interwave_isapnp(dev, iwcard)) {
     713#ifdef CONFIG_PNP
     714        if (isapnp[dev] && snd_interwave_pnp(dev, iwcard, pcard, pid)) {
    741715                snd_card_free(card);
    742716                return -ENODEV;
     
    892866        iwcard->cs4231 = cs4231;
    893867        iwcard->gus = gus;
    894         snd_interwave_cards[dev++] = card;
     868        if (pcard)
     869                pnp_set_card_drvdata(pcard, card);
     870        else
     871                snd_interwave_legacy[dev++] = card;
    895872        return 0;
    896873}
    897874
    898 static int __init snd_interwave_probe_legacy_port(unsigned long xport)
     875static int __devinit snd_interwave_probe_legacy_port(unsigned long xport)
    899876{
    900877        static int dev;
     
    904881                if (!enable[dev] || port[dev] != SNDRV_AUTO_PORT)
    905882                        continue;
    906 #ifdef __ISAPNP__
     883#ifdef CONFIG_PNP
    907884                if (isapnp[dev])
    908885                        continue;
    909886#endif
    910887                port[dev] = xport;
    911                 res = snd_interwave_probe(dev);
     888                res = snd_interwave_probe(dev, NULL, NULL);
    912889                if (res < 0)
    913890                        port[dev] = SNDRV_AUTO_PORT;
     
    917894}
    918895
    919 #ifdef __ISAPNP__
    920 
    921 static int __init snd_interwave_isapnp_detect(struct isapnp_card *card,
    922                                               const struct isapnp_card_id *id)
     896#ifdef CONFIG_PNP
     897
     898static int __devinit snd_interwave_pnp_detect(struct pnp_card_link *card,
     899                                           const struct pnp_card_device_id *id)
    923900{
    924901        static int dev;
     
    928905                if (!enable[dev] || !isapnp[dev])
    929906                        continue;
    930                 snd_interwave_isapnp_cards[dev] = card;
    931                 snd_interwave_isapnp_id[dev] = id;
    932                 res = snd_interwave_probe(dev);
     907                res = snd_interwave_probe(dev, card, id);
    933908                if (res < 0)
    934909                        return res;
     
    940915}
    941916
    942 #endif /* __ISAPNP__ */
     917static void __devexit snd_interwave_pnp_remove(struct pnp_card_link * pcard)
     918{
     919        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     920
     921        snd_card_disconnect(card);
     922        snd_card_free_in_thread(card);
     923}
     924
     925static struct pnp_card_driver interwave_pnpc_driver = {
     926        .flags = PNP_DRIVER_RES_DISABLE,
     927        .name = "interwave",
     928        .id_table = snd_interwave_pnpids,
     929        .probe = snd_interwave_pnp_detect,
     930        .remove = __devexit_p(snd_interwave_pnp_remove),
     931};
     932
     933#endif /* CONFIG_PNP */
    943934
    944935static int __init alsa_card_interwave_init(void)
     
    951942                if (!enable[dev] || port[dev] == SNDRV_AUTO_PORT)
    952943                        continue;
    953 #ifdef __ISAPNP__
     944#ifdef CONFIG_PNP
    954945                if (isapnp[dev])
    955946                        continue;
    956947#endif
    957                 if (!snd_interwave_probe(dev)) {
     948                if (!snd_interwave_probe(dev, NULL, NULL)) {
    958949                        cards++;
    959950                        continue;
     
    965956        /* legacy auto configured cards */
    966957        cards += snd_legacy_auto_probe(possible_ports, snd_interwave_probe_legacy_port);
    967 #ifdef __ISAPNP__
     958#ifdef CONFIG_PNP
    968959        /* ISA PnP cards */
    969         cards += isapnp_probe_cards(snd_interwave_pnpids, snd_interwave_isapnp_detect);
     960        cards += pnp_register_card_driver(&interwave_pnpc_driver);
    970961#endif
    971962
    972963        if (!cards) {
     964#ifdef CONFIG_PNP
     965                pnp_unregister_card_driver(&interwave_pnpc_driver);
     966#endif
    973967#ifdef MODULE
    974968                printk(KERN_ERR "InterWave soundcard not found or device busy\n");
     
    983977        int dev;
    984978
     979#ifdef CONFIG_PNP
     980        /* PnP cards first */
     981        pnp_unregister_card_driver(&interwave_pnpc_driver);
     982#endif
    985983        for (dev = 0; dev < SNDRV_CARDS; dev++)
    986                 snd_card_free(snd_interwave_cards[dev]);
     984                snd_card_free(snd_interwave_legacy[dev]);
    987985}
    988986
     
    10201018               get_option(&str,&pcm_channels[nr_dev]) == 2 &&
    10211019               get_option(&str,&effect[nr_dev]) == 2);
    1022 #ifdef __ISAPNP__
     1020#ifdef CONFIG_PNP
    10231021        if (pnp != INT_MAX)
    10241022                isapnp[nr_dev] = pnp;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/opl3sa2.c

    r224 r246  
    2525#include <linux/pm.h>
    2626#include <linux/slab.h>
    27 #ifndef LINUX_ISAPNP_H
    28 #include <linux/isapnp.h>
    29 #define isapnp_card pci_bus
    30 #define isapnp_dev pci_dev
    31 #endif
     27#include <linux/pnp.h>
    3228#include <sound/core.h>
    3329#include <sound/cs4231.h>
     
    5248static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
    5349static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
    54 #ifdef __ISAPNP__
     50#ifdef CONFIG_PNP
    5551#ifdef TARGET_OS2
    5652static int isapnp[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
     
    8278MODULE_PARM_DESC(enable, "Enable OPL3-SA soundcard.");
    8379MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
    84 #ifdef __ISAPNP__
     80#ifdef CONFIG_PNP
    8581MODULE_PARM(isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
    86 MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
     82MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard.");
    8783MODULE_PARM_SYNTAX(isapnp, SNDRV_ISAPNP_DESC);
    8884#endif
     
    156152        snd_rawmidi_t *rmidi;
    157153        cs4231_t *cs4231;
    158 #ifdef __ISAPNP__
    159         struct isapnp_dev *dev;
     154#ifdef CONFIG_PNP
     155        struct pnp_dev *dev;
    160156#endif
    161157        unsigned char ctlregs[0x20];
     
    170166};
    171167
    172 static snd_card_t *snd_opl3sa2_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    173 
    174 #ifdef __ISAPNP__
    175 
    176 static struct isapnp_card *snd_opl3sa2_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    177 static const struct isapnp_card_id *snd_opl3sa2_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    178 
    179 #ifdef TARGET_OS2
    180 #define ISAPNP_OPL3SA2(_va, _vb, _vc, _device, _function) \
    181         { \
    182                 0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    183                 { ISAPNP_DEVICE_ID(_va, _vb, _vc, _function), } \
    184         }
    185 #else
    186 #define ISAPNP_OPL3SA2(_va, _vb, _vc, _device, _function) \
    187         { \
    188                 ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    189                 devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _function), } \
    190         }
    191 #endif
    192 
    193 static struct isapnp_card_id snd_opl3sa2_pnpids[] __devinitdata = {
     168static snd_card_t *snd_opl3sa2_legacy[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
     169
     170#ifdef CONFIG_PNP
     171
     172static struct pnp_card_device_id snd_opl3sa2_pnpids[] __devinitdata = {
    194173        /* Yamaha YMF719E-S (Genius Sound Maker 3DX) */
    195         ISAPNP_OPL3SA2('Y','M','H',0x0020,0x0021),
     174        { .id = "YMH0020", .devs = { { "YMH0021" } } },
    196175        /* Yamaha OPL3-SA3 (integrated on Intel's Pentium II AL440LX motherboard) */
    197         ISAPNP_OPL3SA2('Y','M','H',0x0030,0x0021),
     176        { .id = "YMH0030", .devs = { { "YMH0021" } } },
    198177        /* Yamaha OPL3-SA2 */
    199         ISAPNP_OPL3SA2('Y','M','H',0x0800,0x0021),
     178        { .id = "YMH0800", .devs = { { "YMH0021" } } },
    200179        /* NeoMagic MagicWave 3DX */
    201         ISAPNP_OPL3SA2('N','M','X',0x2200,0x2210),
     180        { .id = "NMX2200", .devs = { { "YMH2210" } } },
    202181        /* --- */
    203         { ISAPNP_CARD_END, }    /* end */
     182        { .id = "" }    /* end */
    204183};
    205184
    206 ISAPNP_CARD_TABLE(snd_opl3sa2_pnpids);
    207 
    208 #endif /* __ISAPNP__ */
     185MODULE_DEVICE_TABLE(pnp_card, snd_opl3sa2_pnpids);
     186
     187#endif /* CONFIG_PNP */
    209188
    210189
     
    327306}
    328307
    329 static int snd_opl3sa2_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     308static irqreturn_t snd_opl3sa2_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    330309{
    331310        unsigned short status;
    332311        opl3sa2_t *chip = dev_id;
     312        int handled = 0;
    333313
    334314        if (chip == NULL || chip->card == NULL)
    335                 return 0;
     315                return IRQ_NONE;
    336316
    337317        status = snd_opl3sa2_read(chip, OPL3SA2_IRQ_STATUS);
    338318
    339         if (status & 0x20)
     319        if (status & 0x20) {
     320                handled = 1;
    340321                snd_opl3_interrupt(chip->synth);
    341 
    342         if ((status & 0x10) && chip->rmidi != NULL)
     322        }
     323
     324        if ((status & 0x10) && chip->rmidi != NULL) {
     325                handled = 1;
    343326                snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
    344 
    345         if (status & 0x07)      /* TI,CI,PI */
     327        }
     328
     329        if (status & 0x07) {    /* TI,CI,PI */
     330                handled = 1;
    346331                snd_cs4231_interrupt(irq, chip->cs4231, regs);
     332        }
    347333
    348334        if (status & 0x40) { /* hardware volume change */
     335                handled = 1;
    349336                /* reading from Master Lch register at 0x07 clears this bit */
    350337                snd_opl3sa2_read(chip, OPL3SA2_MASTER_RIGHT);
     
    355342                }
    356343        }
    357         return 0;
     344        return IRQ_RETVAL(handled);
    358345}
    359346
     
    605592#endif /* CONFIG_PM */
    606593
    607 #ifdef __ISAPNP__
    608 static int __init snd_opl3sa2_isapnp(int dev, opl3sa2_t *chip)
    609 {
    610         const struct isapnp_card_id *id = snd_opl3sa2_isapnp_id[dev];
    611         struct isapnp_card *card = snd_opl3sa2_isapnp_cards[dev];
    612         struct isapnp_dev *pdev;
    613 
    614         chip->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    615         if (chip->dev->active) {
    616                 chip->dev = NULL;
     594#ifdef CONFIG_PNP
     595static int __init snd_opl3sa2_pnp(int dev, opl3sa2_t *chip,
     596                                  struct pnp_card_link *card,
     597                                  const struct pnp_card_device_id *id)
     598{
     599        struct pnp_dev *pdev;
     600        struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL);
     601        int err;
     602
     603        if (!cfg)
     604                return -ENOMEM;
     605        pdev = chip->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
     606        if (chip->dev == NULL) {
     607                kfree(cfg);
    617608                return -EBUSY;
    618609        }
    619610        /* PnP initialization */
    620         pdev = chip->dev;
    621         if (pdev->prepare(pdev)<0)
    622                 return -EAGAIN;
     611        pnp_init_resource_table(cfg);
    623612        if (sb_port[dev] != SNDRV_AUTO_PORT)
    624                 isapnp_resource_change(&pdev->resource[0], sb_port[dev], 16);
    625         if (wss_port[dev] != SNDRV_AUTO_PORT)
    626                 isapnp_resource_change(&pdev->resource[1], wss_port[dev], 8);
     613                pnp_resource_change(&cfg->port_resource[0], sb_port[dev], 16);
     614                pnp_resource_change(&cfg->port_resource[1], wss_port[dev], 8);
    627615        if (fm_port[dev] != SNDRV_AUTO_PORT)
    628                 isapnp_resource_change(&pdev->resource[2], fm_port[dev], 4);
     616                pnp_resource_change(&cfg->port_resource[2], fm_port[dev], 4);
    629617        if (midi_port[dev] != SNDRV_AUTO_PORT)
    630                 isapnp_resource_change(&pdev->resource[3], midi_port[dev], 2);
     618                pnp_resource_change(&cfg->port_resource[3], midi_port[dev], 2);
    631619        if (port[dev] != SNDRV_AUTO_PORT)
    632                 isapnp_resource_change(&pdev->resource[4], port[dev], 2);
     620                pnp_resource_change(&cfg->port_resource[4], port[dev], 2);
    633621        if (dma1[dev] != SNDRV_AUTO_DMA)
    634                 isapnp_resource_change(&pdev->dma_resource[0], dma1[dev], 1);
     622                pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
    635623        if (dma2[dev] != SNDRV_AUTO_DMA)
    636                 isapnp_resource_change(&pdev->dma_resource[1], dma2[dev], 1);
     624                pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1);
    637625        if (irq[dev] != SNDRV_AUTO_IRQ)
    638                 isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
    639         if (pdev->activate(pdev)<0) {
    640                 snd_printk("isapnp configure failure (out of resources?)\n");
     626                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
     627        err = pnp_manual_config_dev(pdev, cfg, 0);
     628        if (err < 0)
     629                snd_printk(KERN_ERR "PnP manual resources are invalid, using auto config\n");
     630        err = pnp_activate_dev(pdev);
     631        if (err < 0) {
     632                kfree(cfg);
     633                snd_printk(KERN_ERR "PnP configure failure (out of resources?)\n");
    641634                return -EBUSY;
    642635        }
    643         sb_port[dev] = pdev->resource[0].start;
    644         wss_port[dev] = pdev->resource[1].start;
    645         fm_port[dev] = pdev->resource[2].start;
    646         midi_port[dev] = pdev->resource[3].start;
    647         port[dev] = pdev->resource[4].start;
    648         dma1[dev] = pdev->dma_resource[0].start;
    649         dma2[dev] = pdev->dma_resource[1].start;
    650         irq[dev] = pdev->irq_resource[0].start;
    651         snd_printdd("isapnp OPL3-SA: sb port=0x%lx, wss port=0x%lx, fm port=0x%lx, midi port=0x%lx\n",
     636        sb_port[dev] = pnp_port_start(pdev, 0);
     637        wss_port[dev] = pnp_port_start(pdev, 1);
     638        fm_port[dev] = pnp_port_start(pdev, 2);
     639        midi_port[dev] = pnp_port_start(pdev, 3);
     640        port[dev] = pnp_port_start(pdev, 4);
     641        dma1[dev] = pnp_dma(pdev, 0);
     642        dma2[dev] = pnp_dma(pdev, 1);
     643        irq[dev] = pnp_irq(pdev, 0);
     644        snd_printdd("PnP OPL3-SA: sb port=0x%lx, wss port=0x%lx, fm port=0x%lx, midi port=0x%lx\n",
    652645                sb_port[dev], wss_port[dev], fm_port[dev], midi_port[dev]);
    653         snd_printdd("isapnp OPL3-SA: control port=0x%lx, dma1=%i, dma2=%i, irq=%i\n",
     646        snd_printdd("PnP OPL3-SA: control port=0x%lx, dma1=%i, dma2=%i, irq=%i\n",
    654647                port[dev], dma1[dev], dma2[dev], irq[dev]);
    655         return 0;
    656 }
    657 
    658 static void snd_opl3sa2_deactivate(opl3sa2_t *chip)
    659 {
    660         if (chip->dev) {
    661                 chip->dev->deactivate(chip->dev);
    662                 chip->dev = NULL;
    663         }
    664 }
    665 #endif /* __ISAPNP__ */
     648        kfree(cfg);
     649        return 0;
     650}
     651#endif /* CONFIG_PNP */
    666652
    667653static int snd_opl3sa2_free(opl3sa2_t *chip)
    668654{
    669 #ifdef __ISAPNP__
    670         snd_opl3sa2_deactivate(chip);
    671 #endif
    672655#ifdef CONFIG_PM
    673656        if (chip->pm_dev)
     
    690673}
    691674
    692 static int __init snd_opl3sa2_probe(int dev)
     675static int __devinit snd_opl3sa2_probe(int dev,
     676                                       struct pnp_card_link *pcard,
     677                                       const struct pnp_card_device_id *pid)
    693678{
    694679        int xirq, xdma1, xdma2;
     
    702687        int err;
    703688
    704 #ifdef __ISAPNP__
     689#ifdef CONFIG_PNP
    705690        if (!isapnp[dev]) {
    706691#endif
     
    721706                        return -EINVAL;
    722707                }
    723 #ifdef __ISAPNP__
     708#ifdef CONFIG_PNP
    724709        }
    725710#endif
     
    737722        if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0)
    738723                goto __error;
    739 #ifdef __ISAPNP__
    740         if (isapnp[dev] && (err = snd_opl3sa2_isapnp(dev, chip)) < 0)
     724#ifdef CONFIG_PNP
     725        if (isapnp[dev] && (err = snd_opl3sa2_pnp(dev, chip, pcard, pid)) < 0)
    741726                goto __error;
    742727#endif
     
    807792                goto __error;
    808793
    809         snd_opl3sa2_cards[dev] = card;
     794        if (pcard)
     795                pnp_set_card_drvdata(pcard, card);
     796        else
     797                snd_opl3sa2_legacy[dev] = card;
    810798        return 0;
    811799
     
    815803}
    816804
    817 #ifdef __ISAPNP__
    818 static int __init snd_opl3sa2_isapnp_detect(struct isapnp_card *card,
    819                                             const struct isapnp_card_id *id)
     805#ifdef CONFIG_PNP
     806static int __devinit snd_opl3sa2_pnp_detect(struct pnp_card_link *card,
     807                                            const struct pnp_card_device_id *id)
    820808{
    821809        static int dev;
     
    823811
    824812        for ( ; dev < SNDRV_CARDS; dev++) {
    825                 if (!enable[dev])
     813                if (!enable[dev] && !isapnp[dev])
    826814                        continue;
    827                 snd_opl3sa2_isapnp_cards[dev] = card;
    828                 snd_opl3sa2_isapnp_id[dev] = id;
    829                 res = snd_opl3sa2_probe(dev);
     815                res = snd_opl3sa2_probe(dev, card, id);
    830816                if (res < 0)
    831817                        return res;
     
    835821        return -ENODEV;
    836822}
    837 #endif /* __ISAPNP__ */
     823
     824static void __devexit snd_opl3sa2_pnp_remove(struct pnp_card_link * pcard)
     825{
     826        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     827       
     828        snd_card_disconnect(card);
     829        snd_card_free_in_thread(card);
     830}
     831
     832static struct pnp_card_driver opl3sa2_pnpc_driver = {
     833        .flags = PNP_DRIVER_RES_DISABLE,
     834        .name = "opl3sa2",
     835        .id_table = snd_opl3sa2_pnpids,
     836        .probe = snd_opl3sa2_pnp_detect,
     837        .remove = __devexit_p(snd_opl3sa2_pnp_remove),
     838};
     839#endif /* CONFIG_PNP */
    838840
    839841static int __init alsa_card_opl3sa2_init(void)
     
    844846                if (!enable[dev])
    845847                        continue;
    846 #ifdef __ISAPNP__
     848#ifdef CONFIG_PNP
    847849                if (isapnp[dev])
    848850                        continue;
    849851#endif
    850                 if (snd_opl3sa2_probe(dev) >= 0)
     852                if (snd_opl3sa2_probe(dev, NULL, NULL) >= 0)
    851853                        cards++;
    852854        }
    853 #ifdef __ISAPNP__
    854         cards += isapnp_probe_cards(snd_opl3sa2_pnpids, snd_opl3sa2_isapnp_detect);
     855#ifdef CONFIG_PNP
     856        cards += pnp_register_card_driver(&opl3sa2_pnpc_driver);
    855857#endif
    856858        if (!cards) {
    857859#ifdef MODULE
    858                 printk(KERN_ERR "Yamaha OPL3-SA soundcard not found or device busy\n");
     860                snd_printk(KERN_ERR "Yamaha OPL3-SA soundcard not found or device busy\n");
     861#endif
     862#ifdef CONFIG_PNP
     863                pnp_unregister_card_driver(&opl3sa2_pnpc_driver);
    859864#endif
    860865                return -ENODEV;
     
    867872        int idx;
    868873
     874#ifdef CONFIG_PNP
     875        /* PnP cards first */
     876        pnp_unregister_card_driver(&opl3sa2_pnpc_driver);
     877#endif
    869878        for (idx = 0; idx < SNDRV_CARDS; idx++)
    870                 snd_card_free(snd_opl3sa2_cards[idx]);
     879                snd_card_free(snd_opl3sa2_legacy[idx]);
    871880}
    872881
     
    901910               get_option(&str,&dma2[nr_dev]) == 2 &&
    902911               get_option(&str,&opl3sa3_ymode[nr_dev]) == 2);
    903 #ifdef __ISAPNP__
     912#ifdef CONFIG_PNP
    904913        if (pnp != INT_MAX)
    905914                isapnp[nr_dev] = pnp;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/opti9xx/opti92x-ad1848.c

    r231 r246  
    3030#include <linux/init.h>
    3131#include <linux/slab.h>
    32 #ifndef LINUX_ISAPNP_H
    33 #include <linux/isapnp.h>
    34 #define isapnp_card pci_bus
    35 #define isapnp_dev pci_dev
    36 #endif
     32#include <linux/pnp.h>
    3733#include <sound/core.h>
    3834#ifdef CS4231
     
    4844#include <sound/mpu401.h>
    4945#include <sound/opl3.h>
     46#ifdef USE_OPL4
     47#ifndef OPTi93X
     48#include "opl4.h" /* <sound/opl4.h> */
     49#endif
     50#endif
    5051#define SNDRV_LEGACY_FIND_FREE_IRQ
    5152#define SNDRV_LEGACY_FIND_FREE_DMA
     
    268269        int mpu_irq;
    269270
    270 #if defined(OPTi93X)
    271         opti93x_t *opti93x;
    272 #elif defined(CS4231)
    273         cs4231_t *cs4231;
    274 #else
    275         ad1848_t *ad1848;
    276 #endif  /* AD1848 */
    277         snd_rawmidi_t *rmidi;
    278 #ifdef __ISAPNP__
    279         struct isapnp_dev *dev;
    280         struct isapnp_dev *devmpu;
    281 #endif  /* __ISAPNP__ */
     271#ifdef CONFIG_PNP
     272        struct pnp_dev *dev;
     273        struct pnp_dev *devmpu;
     274#endif  /* CONFIG_PNP */
    282275};
    283276
    284 static snd_card_t *snd_opti9xx_card = SNDRV_DEFAULT_PTR1;
    285 
    286 #ifdef __ISAPNP__
     277static int snd_opti9xx_first_hit = 1;
     278static snd_card_t *snd_opti9xx_legacy = SNDRV_DEFAULT_PTR1;
     279
     280#ifdef CONFIG_PNP
    287281
    288282#define ISAPNP_OPTI9XX(_va, _vb, _vc, _device, _fa, _fb, _fc, _audio, _mpu401) \
     
    293287        }
    294288
    295 static struct isapnp_card_id snd_card_opti9xx_pnpids[] = {
     289static struct pnp_card_device_id snd_opti9xx_pnpids[] = {
    296290#ifndef OPTi93X
    297291        /* OPTi 82C924 */
    298         ISAPNP_OPTI9XX('O','P','T',0x0924,'O','P','T',0x0000,0x0002),
     292        { .id = "OPT0924", .devs = { { "OPT0000" }, { "OPT0002" } }, .driver_data = 0x0924 },
    299293        /* OPTi 82C925 */
    300         ISAPNP_OPTI9XX('O','P','T',0x0925,'O','P','T',0x9250,0x0002),
     294        { .id = "OPT0925", .devs = { { "OPT9250" }, { "OPT0002" } }, .driver_data = 0x0925 },
    301295#else
    302296        /* OPTi 82C931/3 */
    303         ISAPNP_OPTI9XX('O','P','T',0x0931,'O','P','T',0x9310,0x0002),
     297        { .id = "OPT0931", .devs = { { "OPT9310" }, { "OPT0002" } }, .driver_data = 0x0931 },
    304298#endif  /* OPTi93X */
    305         { ISAPNP_CARD_END, }
     299        { .id = "" }
    306300};
    307301
    308 ISAPNP_CARD_TABLE(snd_card_opti9xx_pnpids);
    309 
    310 #endif  /* __ISAPNP__ */
     302MODULE_DEVICE_TABLE(pnp_card, snd_opti9xx_pnpids);
     303
     304#endif  /* CONFIG_PNP */
    311305
    312306#ifdef OPTi93X
     
    334328}
    335329
    336 static int __init snd_opti9xx_init(opti9xx_t *chip, unsigned short hardware)
     330static int __devinit snd_opti9xx_init(opti9xx_t *chip, unsigned short hardware)
    337331{
    338332        static int opti9xx_mc_size[] = {7, 7, 10, 10, 2, 2, 2};
     
    479473
    480474
    481 static int __init snd_opti9xx_configure(opti9xx_t *chip)
     475static int __devinit snd_opti9xx_configure(opti9xx_t *chip)
    482476{
    483477        unsigned char wss_base_bits;
     
    976970        {
    977971                unsigned int what = 0;
    978                 snd_pcm_substream_t *s = substream;
    979                 do {
     972                struct list_head *pos;
     973                snd_pcm_substream_t *s;
     974                snd_pcm_group_for_each(pos, substream) {
     975                        s = snd_pcm_group_substream_entry(pos);
    980976                        if (s == chip->playback_substream) {
    981977                                what |= OPTi93X_PLAYBACK_ENABLE;
     
    985981                                snd_pcm_trigger_done(s, substream);
    986982                        }
    987                         s = s->link_next;
    988                 } while (s != substream);
     983                }
    989984                spin_lock(&chip->lock);
    990985                if (cmd == SNDRV_PCM_TRIGGER_START) {
     
    11321127}
    11331128
    1134 void snd_opti93x_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    1135 {
    1136         opti93x_t *codec = snd_magic_cast(opti93x_t, dev_id, return);
     1129irqreturn_t snd_opti93x_interrupt(int irq, void *dev_id, struct pt_regs *regs)
     1130{
     1131        opti93x_t *codec = snd_magic_cast(opti93x_t, dev_id, return IRQ_NONE);
    11371132        unsigned char status;
    11381133
     
    11451140        }
    11461141        outb(0x00, OPTi93X_PORT(codec, STATUS));
     1142        return IRQ_HANDLED;
    11471143}
    11481144
     
    16701666#endif /* OPTi93X */
    16711667
    1672 static int __init snd_card_opti9xx_detect(snd_card_t *card, opti9xx_t *chip)
     1668static int __devinit snd_card_opti9xx_detect(snd_card_t *card, opti9xx_t *chip)
    16731669{
    16741670        int i, err;
     
    17161712}
    17171713
    1718 #ifdef __ISAPNP__
    1719 static int __init snd_card_opti9xx_isapnp(opti9xx_t *chip)
    1720 {
    1721         struct isapnp_dev *pdev = NULL;
    1722         const struct isapnp_card_id *pid = snd_card_opti9xx_pnpids-1;
    1723         static struct isapnp_card *card = NULL;
    1724 
    1725       __again:
    1726         while (1) {
    1727                 pid++;
    1728                 if (pid->card_vendor == 0)
    1729                         return -ENODEV;
    1730                 if ((card = isapnp_find_card(pid->card_vendor, pid->card_device, card)))
    1731                         break;
    1732         }
    1733         if (card == NULL)
    1734                 return -ENODEV;
    1735 
    1736         chip->dev = isapnp_find_dev(card, pid->devs[0].vendor, pid->devs[0].function, NULL);
    1737         if (chip->dev == NULL)
    1738                 goto __again;
    1739 
    1740         chip->devmpu = isapnp_find_dev(card, pid->devs[1].vendor, pid->devs[1].function, NULL);
     1714#ifdef CONFIG_PNP
     1715static int __devinit snd_card_opti9xx_pnp(opti9xx_t *chip, struct pnp_card_link *card,
     1716                                          const struct pnp_card_device_id *pid)
     1717{
     1718        struct pnp_dev *pdev;
     1719        struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
     1720        int err;
     1721
     1722        chip->dev = pnp_request_card_device(card, pid->devs[0].id, NULL);
     1723        if (chip->dev == NULL) {
     1724                kfree(cfg);
     1725                return -EBUSY;
     1726        }
     1727        chip->devmpu = pnp_request_card_device(card, pid->devs[1].id, NULL);
    17411728
    17421729        pdev = chip->dev;
    1743         if (pdev->prepare(pdev) < 0)
    1744                 return -EAGAIN;
     1730        pnp_init_resource_table(cfg);
    17451731
    17461732#ifdef OPTi93X
    17471733        if (port != SNDRV_AUTO_PORT)
    1748                 isapnp_resource_change(&pdev->resource[0], port + 4, 4);
     1734                pnp_resource_change(&cfg->port_resource[0], port + 4, 4);
    17491735#else
    1750         if ((pid->card_device != ISAPNP_DEVICE(0x0924)) && (port != SNDRV_AUTO_PORT))
    1751                 isapnp_resource_change(&pdev->resource[1], port, 4);
     1736        if (pid->driver_data != 0x0924 && port != SNDRV_AUTO_PORT)
     1737                pnp_resource_change(&cfg->port_resource[1], port, 4);
    17521738#endif  /* OPTi93X */
    17531739        if (irq != SNDRV_AUTO_IRQ)
    1754                 isapnp_resource_change(&pdev->irq_resource[0], irq, 1);
     1740                pnp_resource_change(&cfg->irq_resource[0], irq, 1);
    17551741        if (dma1 != SNDRV_AUTO_DMA)
    1756                 isapnp_resource_change(&pdev->dma_resource[0], dma1, 1);
     1742                pnp_resource_change(&cfg->dma_resource[0], dma1, 1);
    17571743#if defined(CS4231) || defined(OPTi93X)
    17581744        if (dma2 != SNDRV_AUTO_DMA)
    1759                 isapnp_resource_change(&pdev->dma_resource[1], dma2, 1);
     1745                pnp_resource_change(&cfg->dma_resource[1], dma2, 1);
    17601746#endif  /* CS4231 || OPTi93X */
    17611747        if (fm_port != SNDRV_AUTO_PORT)
    1762                 isapnp_resource_change(&pdev->resource[1], fm_port, 4);
    1763 
    1764         if (pdev->activate(pdev) < 0) {
    1765                 snd_printk("AUDIO isapnp configure failure\n");
    1766                 return -EBUSY;
     1748                pnp_resource_change(&cfg->port_resource[1], fm_port, 4);
     1749
     1750        if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
     1751                snd_printk(KERN_ERR "AUDIO the requested resources are invalid, using auto config\n");
     1752        err = pnp_activate_dev(pdev);
     1753        if (err < 0) {
     1754                snd_printk(KERN_ERR "AUDIO pnp configure failure\n");
     1755                kfree(cfg);
     1756                return err;
    17671757        }
    17681758
    17691759#ifdef OPTi93X
    1770         port = pdev->resource[0].start - 4;
    1771         fm_port = pdev->resource[1].start;
     1760        port = pnp_port_start(pdev, 0) - 4;
     1761        fm_port = pnp_port_start(pdev, 1);
    17721762#else
    1773         if (pid->card_device != ISAPNP_DEVICE(0x0924))
    1774                 port = pdev->resource[1].start;
    1775         fm_port = pdev->resource[2].start;
     1763        if (pid->driver_data != 0x0924)
     1764                port = pnp_port_start(pdev, 1);
     1765        fm_port = pnp_port_start(pdev, 2);
    17761766#endif  /* OPTi93X */
    1777         irq = pdev->irq_resource[0].start;
    1778         dma1 = pdev->dma_resource[0].start;
     1767        irq = pnp_irq(pdev, 0);
     1768        dma1 = pnp_dma(pdev, 0);
    17791769#if defined(CS4231) || defined(OPTi93X)
    1780         dma2 = pdev->dma_resource[1].start;
     1770        dma2 = pnp_dma(pdev, 1);
    17811771#endif  /* CS4231 || OPTi93X */
    17821772
    17831773        pdev = chip->devmpu;
    1784         if (pdev == NULL || pdev->prepare(pdev) < 0) {
    1785                 mpu_port = -1;
    1786                 chip->devmpu = NULL;
    1787                 return pid->card_device;
    1788         }
    1789 
    1790         if (mpu_port != SNDRV_AUTO_PORT)
    1791                 isapnp_resource_change(&pdev->resource[0], mpu_port, 2);
    1792         if (mpu_irq != SNDRV_AUTO_IRQ)
    1793                 isapnp_resource_change(&pdev->irq_resource[0], mpu_irq, 1);
    1794 
    1795         if (pdev->activate(pdev) < 0) {
    1796                 snd_printk("MPU-401 isapnp configure failure\n");
    1797                 mpu_port = -1;
    1798                 chip->devmpu = NULL;
    1799         } else {
    1800                 mpu_port = pdev->resource[0].start;
    1801                 mpu_irq = pdev->irq_resource[0].start;
    1802         }
    1803         return pid->card_device;
    1804 }
    1805 
    1806 static void snd_card_opti9xx_deactivate(opti9xx_t *chip)
    1807 {
    1808         if (chip->dev)
    1809                 chip->dev->deactivate(chip->dev);
    1810         if (chip->devmpu)
    1811                 chip->devmpu->deactivate(chip->devmpu);
    1812 }
    1813 #endif  /* __ISAPNP__ */
     1774        if (pdev) {
     1775                pnp_init_resource_table(cfg);
     1776
     1777                if (mpu_port != SNDRV_AUTO_PORT)
     1778                        pnp_resource_change(&cfg->port_resource[0], mpu_port, 2);
     1779                if (mpu_irq != SNDRV_AUTO_IRQ)
     1780                        pnp_resource_change(&cfg->irq_resource[0], mpu_irq, 1);
     1781
     1782                if (pnp_manual_config_dev(pdev, cfg, 0) < 0)
     1783                        snd_printk(KERN_ERR "AUDIO the requested resources are invalid, using auto config\n");
     1784                err = pnp_activate_dev(pdev);
     1785                if (err < 0) {
     1786                        snd_printk(KERN_ERR "AUDIO pnp configure failure\n");
     1787                        mpu_port = -1;
     1788                        chip->devmpu = NULL;
     1789                } else {
     1790                        mpu_port = pnp_port_start(pdev, 0);
     1791                        mpu_irq = pnp_irq(pdev, 0);
     1792                }
     1793        }
     1794        kfree(cfg);
     1795        return pid->driver_data;
     1796}
     1797#endif  /* CONFIG_PNP */
    18141798
    18151799#if 0
    1816 static int __init snd_card_opti9xx_resources(struct snd_card_opti9xx *chip,
    1817                                              snd_card_t *card)
     1800static int __devinit snd_card_opti9xx_resources(struct snd_card_opti9xx *chip,
     1801                                                snd_card_t *card)
    18181802{
    18191803        int error, i, pnp = 0;
    18201804
    1821 #ifdef __ISAPNP__
     1805#ifdef CONFIG_PNP
    18221806        pnp = chip->dev != NULL;
    1823 #endif  /* __ISAPNP__ */
     1807#endif  /* CONFIG_PNP */
    18241808
    18251809#ifndef OPTi93X
     
    19151899       
    19161900        if (chip) {
    1917 #ifdef __ISAPNP__
    1918                 snd_card_opti9xx_deactivate(chip);
    1919 #endif  /* __ISAPNP__ */
    19201901                if (chip->res_mc_base) {
    19211902                        release_resource(chip->res_mc_base);
     
    19251906}
    19261907
    1927 static int __init snd_card_opti9xx_probe(void)
     1908static int __devinit snd_card_opti9xx_probe(struct pnp_card_link *pcard,
     1909                                            const struct pnp_card_device_id *pid)
    19281910{
    19291911        static long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1};
     
    19531935        snd_rawmidi_t *rmidi;
    19541936        snd_hwdep_t *synth;
    1955 #ifdef __ISAPNP__
     1937#ifdef CONFIG_PNP
    19561938        int hw;
    1957 #endif  /* __ISAPNP__ */
    1958 
     1939#endif  /* CONFIG_PNP */
     1940
     1941        if (pcard && !snd_opti9xx_first_hit)
     1942                return -EBUSY;
    19591943        if (!(card = snd_card_new(index, id, THIS_MODULE,
    19601944                                  sizeof(opti9xx_t))))
     
    19631947        chip = (opti9xx_t *)card->private_data;
    19641948
    1965 #ifdef __ISAPNP__
    1966         if (isapnp && (hw = snd_card_opti9xx_isapnp(chip)) > 0) {
     1949#ifdef CONFIG_PNP
     1950        if (isapnp && pcard && (hw = snd_card_opti9xx_pnp(chip, pcard, pid)) > 0) {
    19671951                switch (hw) {
    1968                 case ISAPNP_DEVICE(0x0924):
     1952                case 0x0924:
    19691953                        hw = OPTi9XX_HW_82C924;
    19701954                        break;
    1971                 case ISAPNP_DEVICE(0x0925):
     1955                case 0x0925:
    19721956                        hw = OPTi9XX_HW_82C925;
    19731957                        break;
    1974                 case ISAPNP_DEVICE(0x0931):
     1958                case 0x0931:
    19751959                        hw = OPTi9XX_HW_82C931;
    19761960                        break;
     
    19871971                        chip->mc_base -= 0x80;
    19881972        } else {
    1989 #endif  /* __ISAPNP__ */
     1973#endif  /* CONFIG_PNP */
    19901974                if ((error = snd_card_opti9xx_detect(card, chip)) < 0) {
    19911975                        snd_card_free(card);
    19921976                        return error;
    19931977                }
    1994 #ifdef __ISAPNP__
    1995         }
    1996 #endif  /* __ISAPNP__ */
     1978#ifdef CONFIG_PNP
     1979        }
     1980#endif  /* CONFIG_PNP */
    19971981
    19981982        if ((chip->res_mc_base = request_region(chip->mc_base, chip->mc_base_size, "OPTi9xx MC")) == NULL) {
     
    20111995#endif
    20121996
    2013 #ifdef __ISAPNP__
     1997#ifdef CONFIG_PNP
    20141998        if (!isapnp) {
    20151999#endif
     
    20592043#endif
    20602044
    2061 #ifdef __ISAPNP__
     2045#ifdef CONFIG_PNP
    20622046        }
    20632047#endif
     
    21282112
    21292113        if (chip->fm_port > 0) {
    2130                 opl3_t *opl3;
    2131                 if (snd_opl3_create(card,
    2132                                     chip->fm_port,
    2133                                     chip->fm_port + 2,
    2134                                     OPL3_HW_AUTO, 0, &opl3) < 0) {
     2114                opl3_t *opl3 = NULL;
     2115#ifdef USE_OPL4
     2116#ifndef OPTi93X
     2117                if (chip->hardware == OPTi9XX_HW_82C928 ||
     2118                    chip->hardware == OPTi9XX_HW_82C929 ||
     2119                    chip->hardware == OPTi9XX_HW_82C924) {
     2120                        opl4_t *opl4;
     2121                        /* assume we have an OPL4 */
     2122                        snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2),
     2123                                               0x20, 0x20);
     2124                        if (snd_opl4_create(card,
     2125                                            chip->fm_port,
     2126                                            chip->fm_port - 8,
     2127                                            2, &opl3, &opl4) < 0) {
     2128                                /* no luck, use OPL3 instead */
     2129                                snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2),
     2130                                                       0x00, 0x20);
     2131                        }
     2132                }
     2133#endif  /* !OPTi93X */
     2134#endif
     2135                if (!opl3 && snd_opl3_create(card,
     2136                                             chip->fm_port,
     2137                                             chip->fm_port + 2,
     2138                                             OPL3_HW_AUTO, 0, &opl3) < 0) {
    21352139                        snd_printk("no OPL device at 0x%lx-0x%lx\n",
    2136                                 chip->fm_port, chip->fm_port + 4 - 1);
    2137                 } else {
     2140                                   chip->fm_port, chip->fm_port + 4 - 1);
     2141                }
     2142                if (opl3) {
    21382143                        if ((error = snd_opl3_timer_new(opl3,
    21392144#ifdef CS4231
     
    21672172                return error;
    21682173        }
    2169         snd_opti9xx_card = card;
     2174        snd_opti9xx_first_hit = 0;
     2175        if (pcard)
     2176                pnp_set_card_drvdata(pcard, card);
     2177        else
     2178                snd_opti9xx_legacy = card;
    21702179        return 0;
    21712180}
    21722181
     2182#ifdef CONFIG_PNP
     2183static void __devexit snd_opti9xx_pnp_remove(struct pnp_card_link * pcard)
     2184{
     2185        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     2186
     2187        snd_card_disconnect(card);
     2188        snd_card_free_in_thread(card);
     2189        snd_opti9xx_first_hit = 0;
     2190}
     2191
     2192static struct pnp_card_driver opti9xx_pnpc_driver = {
     2193        .flags          = PNP_DRIVER_RES_DISABLE,
     2194        .name           = "opti9xx",
     2195        .id_table       = snd_opti9xx_pnpids,
     2196        .probe          = snd_card_opti9xx_probe,
     2197        .remove         = __devexit_p(snd_opti9xx_pnp_remove),
     2198};
     2199#endif
     2200
    21732201static int __init alsa_card_opti9xx_init(void)
    21742202{
    2175         int error;
    2176 
    2177         if ((error = snd_card_opti9xx_probe())) {
     2203        int cards, error;
     2204
     2205        cards = pnp_register_card_driver(&opti9xx_pnpc_driver);
     2206        if (cards == 0 && (error = snd_card_opti9xx_probe(NULL, NULL)) < 0) {
     2207#ifdef CONFIG_PNP
     2208                pnp_unregister_card_driver(&opti9xx_pnpc_driver);
     2209#endif
    21782210#ifdef MODULE
    21792211#ifdef OPTi93X
     
    21902222static void __exit alsa_card_opti9xx_exit(void)
    21912223{
    2192         if (snd_opti9xx_card)
    2193                 snd_card_free(snd_opti9xx_card);
     2224#ifdef CONFIG_PNP
     2225        pnp_unregister_card_driver(&opti9xx_pnpc_driver);
     2226#endif
     2227        if (snd_opti9xx_legacy)
     2228                snd_card_free(snd_opti9xx_legacy);
    21942229}
    21952230
     
    22242259#endif
    22252260               );
    2226 #ifdef __ISAPNP__
     2261#ifdef CONFIG_PNP
    22272262        if (pnp != INT_MAX)
    22282263                isapnp = pnp;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/es968.c

    r224 r246  
    2424#include <linux/init.h>
    2525#include <linux/time.h>
    26 #ifndef LINUX_ISAPNP_H
    27 #include <linux/isapnp.h>
    28 #define isapnp_card pci_bus
    29 #define isapnp_dev pci_dev
    30 #endif
     26#include <linux/pnp.h>
    3127#include <sound/core.h>
    3228#define SNDRV_GET_ID
     
    3531
    3632#define chip_t sb_t
     33
     34#define PFX "es968: "
    3735
    3836MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
     
    6967
    7068struct snd_card_es968 {
    71 #ifdef __ISAPNP__
    72     struct isapnp_dev *dev;
    73 #endif  /* __ISAPNP__ */
     69        struct pnp_dev *dev;
    7470};
    7571
    76 static snd_card_t *snd_es968_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    77 
    78 #ifdef __ISAPNP__
    79 static struct isapnp_card *snd_es968_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    80 static const struct isapnp_card_id *snd_es968_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    81 
    82 static struct isapnp_card_id snd_es968_pnpids[] __devinitdata = {
    83     {
    84         ISAPNP_CARD_ID('E','S','S',0x0968),
    85                 .devs = { ISAPNP_DEVICE_ID('E','S','S',0x0968), }
    86     },
    87     { ISAPNP_CARD_END, }
     72static struct pnp_card_device_id snd_es968_pnpids[] __devinitdata = {
     73        { .id = "ESS0968", .devs = { { "@@@0968" }, } },
     74        { .id = "", } /* end */
    8875};
    8976
    90 ISAPNP_CARD_TABLE(snd_es968_pnpids);
    91 
    92 #endif  /* __ISAPNP__ */
     77MODULE_DEVICE_TABLE(pnp_card, snd_es968_pnpids);
    9378
    9479#define DRIVER_NAME     "snd-card-es968"
    9580
    96 
    97 static void snd_card_es968_interrupt(int irq, void *dev_id,
     81static irqreturn_t snd_card_es968_interrupt(int irq, void *dev_id,
    9882                                     struct pt_regs *regs)
    9983{
    100         sb_t *chip = snd_magic_cast(sb_t, dev_id, return);
     84        sb_t *chip = snd_magic_cast(sb_t, dev_id, return IRQ_NONE);
    10185
    10286    if (chip->open & SB_OPEN_PCM) {
    103         snd_sb8dsp_interrupt(chip);
     87                return snd_sb8dsp_interrupt(chip);
    10488    } else {
    105         snd_sb8dsp_midi_interrupt(chip);
    106     }
    107 }
    108 
    109 #ifdef __ISAPNP__
    110 static int __init snd_card_es968_isapnp(int dev, struct snd_card_es968 *acard)
    111 {
    112     const struct isapnp_card_id *id = snd_es968_isapnp_id[dev];
    113     struct isapnp_card *card = snd_es968_isapnp_cards[dev];
    114     struct isapnp_dev *pdev;
    115 
    116     acard->dev = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
    117     if (acard->dev->active) {
    118         acard->dev = NULL;
    119         return -EBUSY;
     89                return snd_sb8dsp_midi_interrupt(chip);
     90        }
     91}
     92
     93static int __devinit snd_card_es968_pnp(int dev, struct snd_card_es968 *acard,
     94                                        struct pnp_card_link *card,
     95                                        const struct pnp_card_device_id *id)
     96{
     97        struct pnp_dev *pdev;
     98        struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
     99        int err;
     100        if (!cfg)
     101                return -ENOMEM;
     102        acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
     103        if (acard->dev == NULL) {
     104                kfree(cfg);
     105                return -ENODEV;
    120106    }
    121107
    122108    pdev = acard->dev;
    123     if (pdev->prepare(pdev)<0)
    124         return -EAGAIN;
    125 
     109
     110        pnp_init_resource_table(cfg);
     111
     112        /* override resources */
    126113        if (port[dev] != SNDRV_AUTO_PORT)
    127                 isapnp_resource_change(&pdev->resource[0], port[dev], 16);
     114                pnp_resource_change(&cfg->port_resource[0], port[dev], 16);
    128115        if (dma8[dev] != SNDRV_AUTO_DMA)
    129                 isapnp_resource_change(&pdev->dma_resource[0], dma8[dev],
    130                                1);
     116                pnp_resource_change(&cfg->dma_resource[0], dma8[dev], 1);
    131117        if (irq[dev] != SNDRV_AUTO_IRQ)
    132                 isapnp_resource_change(&pdev->irq_resource[0], irq[dev], 1);
    133 
    134     if (pdev->activate(pdev)<0) {
    135         snd_printk("AUDIO isapnp configure failure\n");
    136         return -EBUSY;
    137     }
    138 
    139         port[dev] = pdev->resource[0].start;
    140         dma8[dev] = pdev->dma_resource[0].start;
    141         irq[dev] = pdev->irq_resource[0].start;
    142 
     118                pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
     119        if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0)
     120                snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n");
     121        err = pnp_activate_dev(pdev);
     122        if (err < 0) {
     123                snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n");
     124                return err;
     125        }
     126        port[dev] = pnp_port_start(pdev, 0);
     127        dma8[dev] = pnp_dma(pdev, 1);
     128        irq[dev] = pnp_irq(pdev, 0);
     129
     130        kfree(cfg);
    143131    return 0;
    144132}
    145133
    146 static void snd_card_es968_deactivate(struct snd_card_es968 *acard)
    147 {
    148     if (acard->dev) {
    149         acard->dev->deactivate(acard->dev);
    150         acard->dev = NULL;
    151     }
    152 }
    153 #endif  /* __ISAPNP__ */
    154 
    155 static void snd_card_es968_free(snd_card_t *card)
    156 {
    157     struct snd_card_es968 *acard = (struct snd_card_es968 *)card->private_data;
    158 
    159     if (acard) {
    160 #ifdef __ISAPNP__
    161         snd_card_es968_deactivate(acard);
    162 #endif  /* __ISAPNP__ */
    163     }
    164 }
    165 
    166 static int __init snd_card_es968_probe(int dev)
     134static int __init snd_card_es968_probe(int dev,
     135                                        struct pnp_card_link *pcard,
     136                                        const struct pnp_card_device_id *pid)
    167137{
    168138    int error;
     
    175145        return -ENOMEM;
    176146    acard = (struct snd_card_es968 *)card->private_data;
    177     card->private_free = snd_card_es968_free;
    178 
    179 #ifdef __ISAPNP__
    180     if ((error = snd_card_es968_isapnp(dev, acard))) {
    181         snd_card_free(card);
    182         return error;
    183     }
    184 #else
    185     snd_printk("you have to enable PnP support ...\n");
    186     snd_card_free(card);
    187     return -ENOSYS;
    188 #endif  /* __ISAPNP__ */
     147        if ((error = snd_card_es968_pnp(dev, acard, pcard, pid))) {
     148                snd_card_free(card);
     149                return error;
     150        }
    189151
    190152        if ((error = snd_sbdsp_create(card, port[dev],
     
    222184        return error;
    223185    }
    224     snd_es968_cards[dev] = card;
     186        pnp_set_card_drvdata(pcard, card);
    225187    return 0;
    226188}
    227189
    228 #ifdef __ISAPNP__
    229 static int __init snd_es968_isapnp_detect(struct isapnp_card *card,
    230                                           const struct isapnp_card_id *id)
     190static int __devinit snd_es968_pnp_detect(struct pnp_card_link *card,
     191                                          const struct pnp_card_device_id *id)
    231192{
    232193        static int dev;
     
    236197                if (!enable[dev])
    237198            continue;
    238         snd_es968_isapnp_cards[dev] = card;
    239         snd_es968_isapnp_id[dev] = id;
    240         res = snd_card_es968_probe(dev);
     199                res = snd_card_es968_probe(dev, card, id);
    241200        if (res < 0)
    242201            return res;
     
    246205    return -ENODEV;
    247206}
    248 #endif /* __ISAPNP__ */
     207
     208static void __devexit snd_es968_pnp_remove(struct pnp_card_link * pcard)
     209{
     210        snd_card_t *card = (snd_card_t *) pnp_get_card_drvdata(pcard);
     211
     212        snd_card_disconnect(card);
     213        snd_card_free_in_thread(card);
     214}
     215
     216static struct pnp_card_driver es968_pnpc_driver = {
     217        .flags          = PNP_DRIVER_RES_DISABLE,
     218        .name           = "es968",
     219        .id_table       = snd_es968_pnpids,
     220        .probe          = snd_es968_pnp_detect,
     221        .remove         = __devexit_p(snd_es968_pnp_remove),
     222};
    249223
    250224static int __init alsa_card_es968_init(void)
    251225{
    252     int cards = 0;
    253 
    254 #ifdef __ISAPNP__
    255     cards += isapnp_probe_cards(snd_es968_pnpids, snd_es968_isapnp_detect);
    256 #else
    257     snd_printk("you have to enable ISA PnP support.\n");
     226        int res = pnp_register_card_driver(&es968_pnpc_driver);
     227        if (res == 0)
     228        {
     229                pnp_unregister_card_driver(&es968_pnpc_driver);
     230#ifdef MODULE
     231                snd_printk(KERN_ERR "no ES968 based soundcards found\n");
    258232#endif
    259 #ifdef MODULE
    260     if (!cards)
    261         snd_printk("no ES968 based soundcards found\n");
    262 #endif
    263     return cards ? 0 : -ENODEV;
     233        }
     234        return res < 0 ? res : 0;
    264235}
    265236
    266237static void __exit alsa_card_es968_exit(void)
    267238{
    268     int dev;
    269 
    270     for (dev = 0; dev < SNDRV_CARDS; dev++)
    271         snd_card_free(snd_es968_cards[dev]);
     239        pnp_unregister_card_driver(&es968_pnpc_driver);