Ignore:
Timestamp:
Mar 18, 2021, 8:57:36 PM (5 years ago)
Author:
David Azarewicz
Message:

Merge changes from Paul's uniaud32next branch.

Location:
GPL/trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • GPL/trunk

  • GPL/trunk/alsa-kernel/isa/wavefront/wavefront.c

    r598 r679  
     1// SPDX-License-Identifier: GPL-2.0-or-later
    12/*
    23 *  ALSA card-level driver for Turtle Beach Wavefront cards
    … …  
    45 *
    56 *  Copyright (c) 1997-1999 by Paul Barton-Davis <pbd@op.net>
    6  *
    7  *  This program is free software; you can redistribute it and/or modify
    8  *  it under the terms of the GNU General Public License as published by
    9  *  the Free Software Foundation; either version 2 of the License, or
    10  *  (at your option) any later version.
    11  *
    12  *  This program is distributed in the hope that it will be useful,
    13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15  *  GNU General Public License for more details.
    16  *
    17  *  You should have received a copy of the GNU General Public License
    18  *  along with this program; if not, write to the Free Software
    19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    207 */
    218
    … …  
    2512#include <linux/isa.h>
    2613#include <linux/pnp.h>
    27 #include <linux/moduleparam.h>
     14#include <linux/module.h>
    2815#include <sound/core.h>
    2916#include <sound/initval.h>
    … …  
    3926static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;          /* Index 0-MAX */
    4027static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;           /* ID for this card */
    41 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;      /* Enable this card */
     28static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;     /* Enable this card */
    4229#ifdef CONFIG_PNP
    43 static int isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
     30static bool isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
    4431#endif
    4532static long cs4232_pcm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;  /* PnP setup */
    … …  
    5239static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;           /* 0,1,3,5,6,7 */
    5340static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;           /* 0,1,3,5,6,7 */
    54 static int use_cs4232_midi[SNDRV_CARDS];
     41static bool use_cs4232_midi[SNDRV_CARDS];
    5542
    5643module_param_array(index, int, NULL, 0444);
    … …  
    6451MODULE_PARM_DESC(isapnp, "ISA PnP detection for WaveFront soundcards.");
    6552#endif
    66 module_param_array(cs4232_pcm_port, long, NULL, 0444);
     53module_param_hw_array(cs4232_pcm_port, long, ioport, NULL, 0444);
    6754MODULE_PARM_DESC(cs4232_pcm_port, "Port # for CS4232 PCM interface.");
    68 module_param_array(cs4232_pcm_irq, int, NULL, 0444);
     55module_param_hw_array(cs4232_pcm_irq, int, irq, NULL, 0444);
    6956MODULE_PARM_DESC(cs4232_pcm_irq, "IRQ # for CS4232 PCM interface.");
    70 module_param_array(dma1, int, NULL, 0444);
     57module_param_hw_array(dma1, int, dma, NULL, 0444);
    7158MODULE_PARM_DESC(dma1, "DMA1 # for CS4232 PCM interface.");
    72 module_param_array(dma2, int, NULL, 0444);
     59module_param_hw_array(dma2, int, dma, NULL, 0444);
    7360MODULE_PARM_DESC(dma2, "DMA2 # for CS4232 PCM interface.");
    74 module_param_array(cs4232_mpu_port, long, NULL, 0444);
     61module_param_hw_array(cs4232_mpu_port, long, ioport, NULL, 0444);
    7562MODULE_PARM_DESC(cs4232_mpu_port, "port # for CS4232 MPU-401 interface.");
    76 module_param_array(cs4232_mpu_irq, int, NULL, 0444);
     63module_param_hw_array(cs4232_mpu_irq, int, irq, NULL, 0444);
    7764MODULE_PARM_DESC(cs4232_mpu_irq, "IRQ # for CS4232 MPU-401 interface.");
    78 module_param_array(ics2115_irq, int, NULL, 0444);
     65module_param_hw_array(ics2115_irq, int, irq, NULL, 0444);
    7966MODULE_PARM_DESC(ics2115_irq, "IRQ # for ICS2115.");
    80 module_param_array(ics2115_port, long, NULL, 0444);
     67module_param_hw_array(ics2115_port, long, ioport, NULL, 0444);
    8168MODULE_PARM_DESC(ics2115_port, "Port # for ICS2115.");
    82 module_param_array(fm_port, long, NULL, 0444);
     69module_param_hw_array(fm_port, long, ioport, NULL, 0444);
    8370MODULE_PARM_DESC(fm_port, "FM port #.");
    8471module_param_array(use_cs4232_midi, bool, NULL, 0444);
    … …  
    8976static int pnp_registered;
    9077
    91 static struct pnp_card_device_id snd_wavefront_pnpids[] = {
     78static const struct pnp_card_device_id snd_wavefront_pnpids[] = {
    9279        /* Tropez */
    9380        { .id = "CSC7532", .devs = { { "CSC0000" }, { "CSC0010" }, { "PnPb006" }, { "CSC0004" } } },
    … …  
    9986MODULE_DEVICE_TABLE(pnp_card, snd_wavefront_pnpids);
    10087
    101 static int __devinit
     88static int
    10289snd_wavefront_pnp (int dev, snd_wavefront_card_t *acard, struct pnp_card_link *card,
    10390                   const struct pnp_card_device_id *id)
    … …  
    232219}
    233220
    234 static struct snd_hwdep * __devinit
    235 snd_wavefront_new_synth (struct snd_card *card,
    236                          int hw_dev,
    237                          snd_wavefront_card_t *acard)
     221static struct snd_hwdep *snd_wavefront_new_synth(struct snd_card *card,
     222                                                 int hw_dev,
     223                                                 snd_wavefront_card_t *acard)
    238224{
    239225        struct snd_hwdep *wavefront_synth;
    … …  
    258244}
    259245
    260 static struct snd_hwdep * __devinit
    261 snd_wavefront_new_fx (struct snd_card *card,
    262                       int hw_dev,
    263                       snd_wavefront_card_t *acard,
    264                       unsigned long port)
     246static struct snd_hwdep *snd_wavefront_new_fx(struct snd_card *card,
     247                                              int hw_dev,
     248                                              snd_wavefront_card_t *acard,
     249                                              unsigned long port)
    265250
    266251{
    … …  
    285270static snd_wavefront_mpu_id external_id = external_mpu;
    286271
    287 static struct snd_rawmidi *__devinit
    288 snd_wavefront_new_midi (struct snd_card *card,
    289                         int midi_dev,
    290                         snd_wavefront_card_t *acard,
    291                         unsigned long port,
    292                         snd_wavefront_mpu_id mpu)
     272static struct snd_rawmidi *snd_wavefront_new_midi(struct snd_card *card,
     273                                                  int midi_dev,
     274                                                  snd_wavefront_card_t *acard,
     275                                                  unsigned long port,
     276                                                  snd_wavefront_mpu_id mpu)
    293277
    294278{
    … …  
    338322}
    339323
    340 static int snd_wavefront_card_new(int dev, struct snd_card **cardp)
     324static int snd_wavefront_card_new(struct device *pdev, int dev,
     325                                  struct snd_card **cardp)
    341326{
    342327        struct snd_card *card;
    … …  
    344329        int err;
    345330
    346         err = snd_card_create(index[dev], id[dev], THIS_MODULE,
    347                               sizeof(snd_wavefront_card_t), &card);
     331        err = snd_card_new(pdev, index[dev], id[dev], THIS_MODULE,
     332                           sizeof(snd_wavefront_card_t), &card);
    348333        if (err < 0)
    349334                return err;
    … …  
    362347}
    363348
    364 static int __devinit
     349static int
    365350snd_wavefront_probe (struct snd_card *card, int dev)
    366351{
    … …  
    383368        }
    384369
    385         err = snd_wss_pcm(chip, 0, NULL);
     370        err = snd_wss_pcm(chip, 0);
    386371        if (err < 0)
    387372                return err;
    388373
    389         err = snd_wss_timer(chip, 0, NULL);
     374        err = snd_wss_timer(chip, 0);
    390375        if (err < 0)
    391376                return err;
    … …  
    419404        }
    420405        if (request_irq(ics2115_irq[dev], snd_wavefront_ics2115_interrupt,
    421                         IRQF_DISABLED, "ICS2115", acard)) {
     406                        0, "ICS2115", acard)) {
    422407                snd_printk(KERN_ERR "unable to use ICS2115 IRQ %d\n", ics2115_irq[dev]);
    423408                return -EBUSY;
    … …  
    425410       
    426411        acard->wavefront.irq = ics2115_irq[dev];
     412        card->sync_irq = acard->wavefront.irq;
    427413        acard->wavefront.base = ics2115_port[dev];
    428414
    … …  
    450436                err = snd_mpu401_uart_new(card, midi_dev, MPU401_HW_CS4232,
    451437                                          cs4232_mpu_port[dev], 0,
    452                                           cs4232_mpu_irq[dev], IRQF_DISABLED,
    453                                           NULL);
     438                                          cs4232_mpu_irq[dev], NULL);
    454439                if (err < 0) {
    455440                        snd_printk (KERN_ERR "can't allocate CS4232 MPU-401 device\n");
    … …  
    543528}       
    544529
    545 static int __devinit snd_wavefront_isa_match(struct device *pdev,
    546                                              unsigned int dev)
     530static int snd_wavefront_isa_match(struct device *pdev,
     531                                   unsigned int dev)
    547532{
    548533        if (!enable[dev])
    … …  
    563548}
    564549
    565 static int __devinit snd_wavefront_isa_probe(struct device *pdev,
    566                                              unsigned int dev)
     550static int snd_wavefront_isa_probe(struct device *pdev,
     551                                   unsigned int dev)
    567552{
    568553        struct snd_card *card;
    569554        int err;
    570555
    571         err = snd_wavefront_card_new(dev, &card);
     556        err = snd_wavefront_card_new(pdev, dev, &card);
    572557        if (err < 0)
    573558                return err;
    574         snd_card_set_dev(card, pdev);
    575559        if ((err = snd_wavefront_probe(card, dev)) < 0) {
    576560                snd_card_free(card);
    … …  
    582566}
    583567
    584 static int __devexit snd_wavefront_isa_remove(struct device *devptr,
    585                                               unsigned int dev)
     568static int snd_wavefront_isa_remove(struct device *devptr,
     569                                    unsigned int dev)
    586570{
    587571        snd_card_free(dev_get_drvdata(devptr));
    588         dev_set_drvdata(devptr, NULL);
    589572        return 0;
    590573}
    … …  
    595578        .match          = snd_wavefront_isa_match,
    596579        .probe          = snd_wavefront_isa_probe,
    597         .remove         = __devexit_p(snd_wavefront_isa_remove),
     580        .remove         = snd_wavefront_isa_remove,
    598581        /* FIXME: suspend, resume */
    599582        .driver         = {
    … …  
    604587
    605588#ifdef CONFIG_PNP
    606 static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *pcard,
    607                                         const struct pnp_card_device_id *pid)
     589static int snd_wavefront_pnp_detect(struct pnp_card_link *pcard,
     590                                    const struct pnp_card_device_id *pid)
    608591{
    609592        static int dev;
    … …  
    618601                return -ENODEV;
    619602
    620         res = snd_wavefront_card_new(dev, &card);
     603        res = snd_wavefront_card_new(&pcard->card->dev, dev, &card);
    621604        if (res < 0)
    622605                return res;
    … …  
    629612                }
    630613        }
    631         snd_card_set_dev(card, &pcard->card->dev);
    632614
    633615        if ((res = snd_wavefront_probe(card, dev)) < 0)
    … …  
    639621}
    640622
    641 static void __devexit snd_wavefront_pnp_remove(struct pnp_card_link * pcard)
     623static void snd_wavefront_pnp_remove(struct pnp_card_link *pcard)
    642624{
    643625        snd_card_free(pnp_get_card_drvdata(pcard));
    … …  
    650632        .id_table       = snd_wavefront_pnpids,
    651633        .probe          = snd_wavefront_pnp_detect,
    652         .remove         = __devexit_p(snd_wavefront_pnp_remove),
     634        .remove         = snd_wavefront_pnp_remove,
    653635        /* FIXME: suspend,resume */
    654636};

  • GPL/trunk/alsa-kernel/isa/wavefront/wavefront_fx.c

    r598 r679  
     1// SPDX-License-Identifier: GPL-2.0-or-later
    12/*
    23 *  Copyright (c) 1998-2002 by Paul Davis <pbd@op.net>
    3  *
    4  *  This program is free software; you can redistribute it and/or modify
    5  *  it under the terms of the GNU General Public License as published by
    6  *  the Free Software Foundation; either version 2 of the License, or
    7  *  (at your option) any later version.
    8  *
    9  *  This program is distributed in the hope that it will be useful,
    10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    12  *  GNU General Public License for more details.
    13  *
    14  *  You should have received a copy of the GNU General Public License
    15  *  along with this program; if not, write to the Free Software
    16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    174 */
    185
    19 #include <asm/io.h>
     6#include <linux/io.h>
    207#include <linux/init.h>
    218#include <linux/time.h>
    229#include <linux/wait.h>
    2310#include <linux/slab.h>
     11#include <linux/module.h>
    2412#include <linux/firmware.h>
    2513#include <sound/core.h>
    2614#include <sound/snd_wavefront.h>
    2715#include <sound/initval.h>
    28 #include <proto.h>
    2916
    3017/* Control bits for the Load Control Register
    … …  
    8067                snd_printk ("FX memset: "
    8168                        "page must be >= 0 and <= 7\n");
    82                 return -(EINVAL);
     69                return -EINVAL;
    8370        }
    8471
    … …  
    8673                snd_printk ("FX memset: "
    8774                        "addr must be >= 0 and <= 7f\n");
    88                 return -(EINVAL);
     75                return -EINVAL;
    8976        }
    9077
    … …  
    119106                                    "(0x%x, 0x%x, 0x%lx, %d) incomplete\n",
    120107                                    page, addr, (unsigned long) data, cnt);
    121                         return -(EIO);
     108                        return -EIO;
    122109                }
    123110        }
    … …  
    154141}
    155142
    156 int
     143int 
    157144snd_wavefront_fx_release (struct snd_hwdep *hw, struct file *file)
    158145
    … …  
    241228*/
    242229
    243 int __devinit
     230int
    244231snd_wavefront_fx_start (snd_wavefront_t *dev)
    245232{

  • GPL/trunk/alsa-kernel/isa/wavefront/wavefront_midi.c

    r399 r679  
     1// SPDX-License-Identifier: GPL-2.0-only
    12/*
    23 * Copyright (C) by Paul Barton-Davis 1998-1999
    3  *
    4  * This file is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
    5  * Version 2 (June 1991). See the "COPYING" file distributed with this
    6  * software for more info. 
    74 */
    85
    … …  
    4845 */
    4946
    50 #include <asm/io.h>
     47#include <linux/io.h>
    5148#include <linux/init.h>
    5249#include <linux/time.h>
    … …  
    350347}
    351348
    352 static void snd_wavefront_midi_output_timer(unsigned long data)
    353 {
    354         snd_wavefront_card_t *card = (snd_wavefront_card_t *)data;
    355         snd_wavefront_midi_t *midi = &card->wavefront.midi;
     349static void snd_wavefront_midi_output_timer(struct timer_list *t)
     350{
     351        snd_wavefront_midi_t *midi = from_timer(midi, t, timer);
     352        snd_wavefront_card_t *card = midi->timer_card;
    356353        unsigned long flags;
    357354       
    358355        spin_lock_irqsave (&midi->virtual, flags);
    359         midi->timer.expires = 1 + jiffies;
    360         add_timer(&midi->timer);
     356        mod_timer(&midi->timer, 1 + jiffies);
    361357        spin_unlock_irqrestore (&midi->virtual, flags);
    362358        snd_wavefront_midi_output_write(card);
    … …  
    385381                if ((midi->mode[mpu] & MPU401_MODE_OUTPUT_TRIGGER) == 0) {
    386382                        if (!midi->istimer) {
    387                                 init_timer(&midi->timer);
    388                                 midi->timer.function = snd_wavefront_midi_output_timer;
    389                                 midi->timer.data = (unsigned long) substream->rmidi->card->private_data;
    390                                 midi->timer.expires = 1 + jiffies;
    391                                 add_timer(&midi->timer);
     383                                timer_setup(&midi->timer,
     384                                            snd_wavefront_midi_output_timer,
     385                                            0);
     386                                mod_timer(&midi->timer, 1 + jiffies);
    392387                        }
    393388                        midi->istimer++;
    … …  
    482477}
    483478
    484 int __devinit
     479int
    485480snd_wavefront_midi_start (snd_wavefront_card_t *card)
    486481
    … …  
    538533
    539534        /* Turn on Virtual MIDI, but first *always* turn it off,
    540            since otherwise consectutive reloads of the driver will
     535           since otherwise consecutive reloads of the driver will
    541536           never cause the hardware to generate the initial "internal" or
    542537           "external" source bytes in the MIDI data stream. This
    … …  
    562557}
    563558
    564 struct snd_rawmidi_ops snd_wavefront_midi_output =
     559const struct snd_rawmidi_ops snd_wavefront_midi_output =
    565560{
    566561        .open =         snd_wavefront_midi_output_open,
    … …  
    569564};
    570565
    571 struct snd_rawmidi_ops snd_wavefront_midi_input =
     566const struct snd_rawmidi_ops snd_wavefront_midi_input =
    572567{
    573568        .open =         snd_wavefront_midi_input_open,

  • GPL/trunk/alsa-kernel/isa/wavefront/wavefront_synth.c

    r598 r679  
     1// SPDX-License-Identifier: GPL-2.0-only
    12/* Copyright (C) by Paul Barton-Davis 1998-1999
    23 *
    34 * Some portions of this file are taken from work that is
    45 * copyright (C) by Hannu Savolainen 1993-1996
    5  *
    6  * This program is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
    7  * Version 2 (June 1991). See the "COPYING" file distributed with this software
    8  * for more info. 
    96 */
    107
    … …  
    2118 */
    2219
    23 #include <asm/io.h>
     20#include <linux/io.h>
    2421#include <linux/interrupt.h>
    2522#include <linux/init.h>
    … …  
    2724#include <linux/time.h>
    2825#include <linux/wait.h>
     26#include <linux/sched/signal.h>
    2927#include <linux/firmware.h>
    3028#include <linux/moduleparam.h>
    3129#include <linux/slab.h>
     30#include <linux/module.h>
    3231#include <sound/core.h>
    3332#include <sound/snd_wavefront.h>
    … …  
    539538
    540539                dst++;
    541         };
     540        }
    542541        return dst;
    543542};
    … …  
    787786                                      header->number);
    788787
     788        if (header->number >= ARRAY_SIZE(dev->patch_status))
     789                return -EINVAL;
     790
    789791        dev->patch_status[header->number] |= WF_SLOT_FILLED;
    790792
    791         bptr = buf;
    792793        bptr = munge_int32 (header->number, buf, 2);
    793794        munge_buf ((unsigned char *)&header->hdr.p, bptr, WF_PATCH_BYTES);
    … …  
    795796        if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PATCH, NULL, buf)) {
    796797                snd_printk ("download patch failed\n");
    797                 return -(EIO);
     798                return -EIO;
    798799        }
    799800
    … …  
    810811        DPRINT (WF_DEBUG_LOAD_PATCH, "downloading program %d\n",
    811812                header->number);
     813
     814        if (header->number >= ARRAY_SIZE(dev->prog_status))
     815                return -EINVAL;
    812816
    813817        dev->prog_status[header->number] = WF_SLOT_USED;
    … …  
    833837        if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_PROGRAM, NULL, buf)) {
    834838                snd_printk ("download patch failed\n");
    835                 return -(EIO);
     839                return -EIO;
    836840        }
    837841
    … …  
    900904        }
    901905
     906        if (header->number >= WF_MAX_SAMPLE)
     907                return -EINVAL;
     908
    902909        if (header->size) {
    903910
    … …  
    954961                snd_printk ("channel selection only "
    955962                            "possible on 16-bit samples");
    956                 return -(EINVAL);
     963                return -EINVAL;
    957964        }
    958965
    … …  
    10511058                snd_printk ("sample %sdownload refused.\n",
    10521059                            header->size ? "" : "header ");
    1053                 return -(EIO);
     1060                return -EIO;
    10541061        }
    10551062
    … …  
    10771084                        snd_printk ("download block "
    10781085                                    "request refused.\n");
    1079                         return -(EIO);
     1086                        return -EIO;
    10801087                }
    10811088
    … …  
    11371144                                snd_printk ("upload sample "
    11381145                                            "DMA ack timeout\n");
    1139                                 return -(EIO);
     1146                                return -EIO;
    11401147                        } else {
    11411148                                snd_printk ("upload sample "
    11421149                                            "DMA ack error 0x%x\n",
    11431150                                            dma_ack);
    1144                                 return -(EIO);
     1151                                return -EIO;
    11451152                        }
    11461153                }
    … …  
    11671174                                      header->number,
    11681175                                      header->hdr.a.OriginalSample);
    1169    
     1176
     1177        if (header->number >= WF_MAX_SAMPLE)
     1178                return -EINVAL;
     1179
    11701180        munge_int32 (header->number, &alias_hdr[0], 2);
    11711181        munge_int32 (header->hdr.a.OriginalSample, &alias_hdr[2], 2);
    … …  
    11831193        if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_SAMPLE_ALIAS, NULL, alias_hdr)) {
    11841194                snd_printk ("download alias failed.\n");
    1185                 return -(EIO);
     1195                return -EIO;
    11861196        }
    11871197
    … …  
    11981208        unsigned char *msample_hdr;
    11991209
    1200         msample_hdr = kmalloc(sizeof(WF_MSAMPLE_BYTES), GFP_KERNEL);
     1210        if (header->number >= WF_MAX_SAMPLE)
     1211                return -EINVAL;
     1212
     1213        msample_hdr = kmalloc(WF_MSAMPLE_BYTES, GFP_KERNEL);
    12011214        if (! msample_hdr)
    12021215                return -ENOMEM;
    … …  
    12341247                snd_printk ("download of multisample failed.\n");
    12351248                kfree(msample_hdr);
    1236                 return -(EIO);
     1249                return -EIO;
    12371250        }
    12381251
    … …  
    12561269        if (snd_wavefront_cmd (dev, WFC_UPLOAD_MULTISAMPLE, log_ns, number)) {
    12571270                snd_printk ("upload multisample failed.\n");
    1258                 return -(EIO);
     1271                return -EIO;
    12591272        }
    12601273   
    … …  
    12751288                        snd_printk ("upload multisample failed "
    12761289                                    "during sample loop.\n");
    1277                         return -(EIO);
     1290                        return -EIO;
    12781291                }
    12791292                d[0] = val;
    … …  
    12821295                        snd_printk ("upload multisample failed "
    12831296                                    "during sample loop.\n");
    1284                         return -(EIO);
     1297                        return -EIO;
    12851298                }
    12861299                d[1] = val;
    … …  
    13171330        if (snd_wavefront_cmd (dev, WFC_DOWNLOAD_EDRUM_PROGRAM, NULL, drumbuf)) {
    13181331                snd_printk ("download drum failed.\n");
    1319                 return -(EIO);
     1332                return -EIO;
    13201333        }
    13211334
    … …  
    17431756*/
    17441757
    1745 static int __devinit
     1758static int
    17461759snd_wavefront_interrupt_bits (int irq)
    17471760
    … …  
    17711784}
    17721785
    1773 static void __devinit
     1786static void
    17741787wavefront_should_cause_interrupt (snd_wavefront_t *dev,
    17751788                                  int val, int port, unsigned long timeout)
    17761789
    17771790{
    1778         wait_queue_t wait;
     1791        wait_queue_entry_t wait;
    17791792
    17801793        init_waitqueue_entry(&wait, current);
    … …  
    17901803}
    17911804
    1792 static int __devinit
     1805static int
    17931806wavefront_reset_to_cleanliness (snd_wavefront_t *dev)
    17941807
    … …  
    19411954}
    19421955
    1943 static int __devinit
     1956static int
    19441957wavefront_download_firmware (snd_wavefront_t *dev, char *path)
    19451958
    … …  
    20142027
    20152028
    2016 static int __devinit
     2029static int
    20172030wavefront_do_reset (snd_wavefront_t *dev)
    20182031
    … …  
    21032116}
    21042117
    2105 int __devinit
     2118int
    21062119snd_wavefront_start (snd_wavefront_t *dev)
    21072120
    … …  
    21452158}
    21462159
    2147 int __devinit
     2160int
    21482161snd_wavefront_detect (snd_wavefront_card_t *card)
    21492162
Note: See TracChangeset for help on using the changeset viewer.