Changeset 224


Ignore:
Timestamp:
Jul 26, 2007, 5:21:09 AM (13 years ago)
Author:
Brendan Oakley
Message:

Merged to Alsa 0.9.1

Location:
GPL/branches/alsa-resync1/alsa-kernel
Files:
4 added
2 deleted
61 edited

Legend:

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

    r106 r224  
    421421                                   hwdep->card, hwdep->device,
    422422                                   &snd_hwdep_reg, name)) < 0) {
    423                 snd_printk(KERN_ERR "unable to register hardware dependant device %i:%i\n",
     423                snd_printk(KERN_ERR "unable to register hardware dependent device %i:%i\n",
    424424                   hwdep->card->number, hwdep->device);
    425425        snd_hwdep_devices[idx] = NULL;
  • GPL/branches/alsa-resync1/alsa-kernel/core/isadma.c

    r222 r224  
    7575
    7676/**
    77  * snd_dma_residue - return the residue count of the given DMA
     77 * snd_dma_pointer - return the current pointer to DMA transfer buffer in bytes
    7878 * @dma: the dma number
     79 * @size: the dma transfer size
    7980 *
    80  * Returns the residue count of the given DMA transfer.
     81 * Returns the current pointer in DMA tranfer buffer in bytes
    8182 */
    82 unsigned int snd_dma_residue(unsigned long dma)
     83unsigned int snd_dma_pointer(unsigned long dma, unsigned int size)
    8384{
    8485        unsigned long flags;
     
    9394                enable_dma(dma);
    9495        release_dma_lock(flags);
    95         return result;
     96#ifdef CONFIG_SND_DEBUG
     97        if (result > size)
     98                snd_printk(KERN_ERR "pointer (0x%x) for DMA #%ld is greater than transfer size (0x%x)\n", result, dma, size);
     99#endif
     100        return result >= size ? 0 : size - result;
    96101}
  • GPL/branches/alsa-resync1/alsa-kernel/core/makefile.os2

    r32 r224  
    3232#
    3333#===================================================================
    34 FILE1    = sound.obj init.obj memory.obj memalloc.obj sgbuf.obj
     34FILE1    = sound.obj init.obj memory.obj memory_wrapper.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/memory.c

    r210 r224  
    3030#include <sound/core.h>
    3131#include <sound/info.h>
    32 #ifdef CONFIG_SBUS
    33 #include <asm/sbus.h>
    34 #endif
    3532#include <sound/memalloc.h>
    3633
     
    5148#define snd_alloc_track_entry(obj) (struct snd_alloc_track *)((char*)obj - (unsigned long)((struct snd_alloc_track *)0)->data)
    5249
    53 static long snd_alloc_pages;
    5450static long snd_alloc_kmalloc;
    5551static long snd_alloc_vmalloc;
     
    7369        struct list_head *head;
    7470        struct snd_alloc_track *t;
    75         if (snd_alloc_pages > 0)
    76                 snd_printk(KERN_ERR "Not freed snd_alloc_pages = %li\n", snd_alloc_pages);
     71
    7772        if (snd_alloc_kmalloc > 0)
    7873                snd_printk(KERN_ERR "Not freed snd_alloc_kmalloc = %li\n", snd_alloc_kmalloc);
     
    198193static void snd_memory_info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer)
    199194{
    200         long pages = snd_alloc_pages >> (PAGE_SHIFT-12);
    201         snd_iprintf(buffer, "pages  : %li bytes (%li pages per %likB)\n", pages * PAGE_SIZE, pages, PAGE_SIZE / 1024);
    202195        snd_iprintf(buffer, "kmalloc: %li bytes\n", snd_alloc_kmalloc);
    203196        snd_iprintf(buffer, "vmalloc: %li bytes\n", snd_alloc_vmalloc);
  • GPL/branches/alsa-resync1/alsa-kernel/core/pcm_memory.c

    r222 r224  
    2727#include <sound/info.h>
    2828#include <sound/initval.h>
    29 #ifdef CONFIG_PCI
    30 #include <sound/pcm_sgbuf.h>
    31 #endif
    3229
    3330static int preallocate_dma = 1;
     
    197194    snd_info_entry_t *entry;
    198195
     196        memset(&substream->dma_buffer, 0, sizeof(substream->dma_buffer));
    199197    if (size > 0 && preallocate_dma && substream->number < maximum_substreams)
    200198        preallocate_pcm_pages(substream, size);
     
    217215    return 0;
    218216}
     217
    219218
    220219/**
  • GPL/branches/alsa-resync1/alsa-kernel/core/rtctimer.c

    r222 r224  
    3434#include <linux/mc146818rtc.h>
    3535
    36 /* use tasklet for interrupt handling */
    37 #define USE_TASKLET
    38 
    3936#define RTC_FREQ        1024            /* default frequency */
    4037#define NANO_SEC        1000000000L     /* 10^9 in sec */
     
    6663static rtc_task_t rtc_task;
    6764
    68 /* tasklet */
    69 #ifdef USE_TASKLET
    70 static struct tasklet_struct rtc_tq;
    71 #endif
    7265
    7366static int
     
    119112static void rtctimer_interrupt(void *private_data)
    120113{
     114        int ticks;
     115
    121116        atomic_inc(&rtc_inc);
    122 #ifdef USE_TASKLET
    123         tasklet_hi_schedule(&rtc_tq);
    124 #else
    125         {
    126                 int ticks = atomic_read(&rtc_inc);
     117        ticks = atomic_read(&rtc_inc);
    127118                snd_timer_interrupt((snd_timer_t*)private_data, ticks);
    128119                atomic_sub(ticks, &rtc_inc);
    129120        }
    130 #endif /* USE_TASKLET */
    131 }
    132 
    133 #ifdef USE_TASKLET
    134 static void rtctimer_interrupt2(unsigned long private_data)
    135 {
    136         snd_timer_t *timer = (snd_timer_t *)private_data;
    137         int ticks;
    138 
    139         snd_assert(timer != NULL, return);
    140         do {
    141                 ticks = atomic_read(&rtc_inc);
    142                 snd_timer_interrupt(timer, ticks);
    143         } while (!atomic_sub_and_test(ticks, &rtc_inc));
    144 }
    145 #endif /* USE_TASKLET */
    146121
    147122
     
    169144        if (err < 0)
    170145                return err;
    171 
    172 #ifdef USE_TASKLET
    173         tasklet_init(&rtc_tq, rtctimer_interrupt2, (unsigned long)timer);
    174 #endif /* USE_TASKLET */
    175146
    176147        strcpy(timer->name, "RTC timer");
  • GPL/branches/alsa-resync1/alsa-kernel/core/sound.c

    r222 r224  
    550550EXPORT_SYMBOL(snd_verbose_printd);
    551551#endif
    552 #if defined(CONFIG_SND_DEBUG) && !defined(CONFIG_SND_VERBOSE_PRINTK)
    553 EXPORT_SYMBOL(snd_printd);
    554 #endif
    555552/* wrappers */
    556553#ifdef CONFIG_SND_DEBUG_MEMORY
  • GPL/branches/alsa-resync1/alsa-kernel/core/wrappers.c

    r212 r224  
    5050#endif
    5151
    52 
    53 /* check the condition in <sound/core.h> !! */
    54 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0)
    55 #if defined(__i386__) || defined(__ppc__) || defined(__x86_64__)
    56 
    57 #include <linux/pci.h>
    58 
    59 /* to be sure... */
    60 #ifdef HACK_PCI_ALLOC_CONSISTENT
    61 #error pci_alloc_consistent hack is already defined!!
    62 #endif
    63 
    64 /*
    65  * A dirty hack... when the kernel code is fixed this should be removed.
    66  *
    67  * since pci_alloc_consistent always tries GFP_DMA when the requested
    68  * pci memory region is below 32bit, it happens quite often that even
    69  * 2 order of pages cannot be allocated.
    70  *
    71  * so in the following, we allocate at first without dma_mask, so that
    72  * allocation will be done without GFP_DMA.  if the area doesn't match
    73  * with the requested region, then realloate with the original dma_mask
    74  * again.
    75  */
    76 
    77 void *snd_pci_hack_alloc_consistent(struct pci_dev *hwdev, size_t size,
    78                                     dma_addr_t *dma_handle)
    79 {
    80         void *ret;
    81         u64 dma_mask;
    82         unsigned long rmask;
    83 
    84         if (hwdev == NULL)
    85                 return pci_alloc_consistent(hwdev, size, dma_handle);
    86         dma_mask = hwdev->dma_mask;
    87         rmask = ~((unsigned long)dma_mask);
    88         hwdev->dma_mask = 0xffffffff; /* do without masking */
    89         ret = pci_alloc_consistent(hwdev, size, dma_handle);
    90         hwdev->dma_mask = dma_mask; /* restore */
    91         if (ret) {
    92                 /* obtained address is out of range? */
    93                 if (((unsigned long)*dma_handle + size - 1) & rmask) {
    94                         /* reallocate with the proper mask */
    95                         pci_free_consistent(hwdev, size, ret, *dma_handle);
    96                         ret = pci_alloc_consistent(hwdev, size, dma_handle);
    97                 }
    98         } else {
    99                 /* wish to success now with the proper mask... */
    100                 if (dma_mask != 0xffffffff)
    101                         ret = pci_alloc_consistent(hwdev, size, dma_handle);
    102         }
    103         return ret;
    104 }
    105 
    106 #endif
    107 #endif
  • GPL/branches/alsa-resync1/alsa-kernel/drivers/mtpav.c

    r215 r224  
    5252
    5353#include <sound/driver.h>
    54 #include <asm/io.h>
    5554#include <linux/init.h>
     55#include <linux/interrupt.h>
    5656#include <linux/slab.h>
    5757#include <linux/ioport.h>
     
    6161#include <sound/rawmidi.h>
    6262#include <linux/delay.h>
     63
     64#include <asm/io.h>
    6365
    6466/*
     
    134136        u8 hwport;
    135137        u8 mode;
     138        u8 running_status;
    136139        snd_rawmidi_substream_t *input;
    137140        snd_rawmidi_substream_t *output;
     
    204207static int translate_hwport_to_subdevice(mtpav_t *chip, int hwport)
    205208{
    206         int port;
     209        int p;
    207210        if (hwport <= 0x00) /* all ports */
    208211                return chip->num_ports + MTPAV_PIDX_BROADCAST;
    209212        else if (hwport <= 0x08) { /* single port */
    210                 port = hwport - 1;
    211                 if (port >= chip->num_ports)
    212                         port = 0;
    213                 return port;
     213                p = hwport - 1;
     214                if (p >= chip->num_ports)
     215                        p = 0;
     216                return p;
    214217        } else if (hwport <= 0x10) { /* remote port */
    215                 port = hwport - 0x09 + chip->num_ports;
    216                 if (port >= chip->num_ports * 2)
    217                         port = chip->num_ports;
    218                 return port;
     218                p = hwport - 0x09 + chip->num_ports;
     219                if (p >= chip->num_ports * 2)
     220                        p = chip->num_ports;
     221                return p;
    219222        } else if (hwport == 0x11)  /* computer port */
    220223                return chip->num_ports + MTPAV_PIDX_COMPUTER;
     
    300303        u8 outbyte;
    301304
     305        // Get the outbyte first, so we can emulate running status if
     306        // necessary
     307        if (snd_rawmidi_transmit(substream, &outbyte, 1) != 1)
     308                return;
     309
    302310        // send port change command if necessary
    303311
     
    309317                //snd_printk("new outport: 0x%x\n", (unsigned int) port->hwport);
    310318
     319                if (!(outbyte & 0x80) && port->running_status)
     320                        snd_mtpav_send_byte(mtp_card, port->running_status);
    311321        }
    312322
    313323        // send data
    314324
    315         while (snd_rawmidi_transmit(substream, &outbyte, 1) == 1)
     325        do {
     326                if (outbyte & 0x80)
     327                        port->running_status = outbyte;
     328               
    316329                snd_mtpav_send_byte(mtp_card, outbyte);
     330        } while (snd_rawmidi_transmit(substream, &outbyte, 1) == 1);
    317331}
    318332
     
    334348static void snd_mtpav_portscan(mtpav_t *chip)   // put mtp into smart routing mode
    335349{
    336         u8 port;
    337 
    338         for (port = 0; port < 8; port++) {
     350        u8 p;
     351
     352        for (p = 0; p < 8; p++) {
    339353                snd_mtpav_send_byte(chip, 0xf5);
    340                 snd_mtpav_send_byte(chip, port);
     354                snd_mtpav_send_byte(chip, p);
    341355                snd_mtpav_send_byte(chip, 0xfe);
    342356        }
     
    349363{
    350364        unsigned long flags;
    351         mtpav_port_t *port = &mtp_card->ports[substream->number];
     365        mtpav_port_t *portp = &mtp_card->ports[substream->number];
    352366
    353367        //printk("mtpav port: %d opened\n", (int) substream->number);
    354368        spin_lock_irqsave(&mtp_card->spinlock, flags);
    355         port->mode |= MTPAV_MODE_INPUT_OPENED;
    356         port->input = substream;
     369        portp->mode |= MTPAV_MODE_INPUT_OPENED;
     370        portp->input = substream;
    357371        if (mtp_card->share_irq++ == 0)
    358372                snd_mtpav_mputreg(mtp_card, CREG, (SIGC_INTEN | SIGC_WRITE));   // enable pport interrupts
     
    367381{
    368382        unsigned long flags;
    369         mtpav_port_t *port = &mtp_card->ports[substream->number];
    370 
    371         //printk("mtpav port: %d closed\n", (int) port);
     383        mtpav_port_t *portp = &mtp_card->ports[substream->number];
     384
     385        //printk("mtpav port: %d closed\n", (int) portp);
    372386
    373387        spin_lock_irqsave(&mtp_card->spinlock, flags);
    374388
    375         port->mode &= (~MTPAV_MODE_INPUT_OPENED);
    376         port->input = NULL;
     389        portp->mode &= (~MTPAV_MODE_INPUT_OPENED);
     390        portp->input = NULL;
    377391        if (--mtp_card->share_irq == 0)
    378392                snd_mtpav_mputreg(mtp_card, CREG, 0);   // disable pport interrupts
     
    388402{
    389403        unsigned long flags;
    390         mtpav_port_t *port = &mtp_card->ports[substream->number];
     404        mtpav_port_t *portp = &mtp_card->ports[substream->number];
    391405
    392406        spin_lock_irqsave(&mtp_card->spinlock, flags);
    393407        if (up)
    394                 port->mode |= MTPAV_MODE_INPUT_TRIGGERED;
     408                portp->mode |= MTPAV_MODE_INPUT_TRIGGERED;
    395409        else
    396                 port->mode &= ~MTPAV_MODE_INPUT_TRIGGERED;
     410                portp->mode &= ~MTPAV_MODE_INPUT_TRIGGERED;
    397411        spin_unlock_irqrestore(&mtp_card->spinlock, flags);
    398412
     
    415429        /* process each port */
    416430        for (p = 0; p <= chip->num_ports * 2 + MTPAV_PIDX_BROADCAST; p++) {
    417                 mtpav_port_t *port = &mtp_card->ports[p];
    418                 if ((port->mode & MTPAV_MODE_OUTPUT_TRIGGERED) && port->output)
    419                         snd_mtpav_output_port_write(port, port->output);
     431                mtpav_port_t *portp = &mtp_card->ports[p];
     432                if ((portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED) && portp->output)
     433                        snd_mtpav_output_port_write(portp, portp->output);
    420434        }
    421435        spin_unlock(&chip->spinlock);
     
    425439static void snd_mtpav_add_output_timer(mtpav_t *chip)
    426440{
     441        init_timer(&chip->timer);
    427442        chip->timer.function = snd_mtpav_output_timer;
    428443        chip->timer.data = (unsigned long) mtp_card;
     
    443458{
    444459        unsigned long flags;
    445         mtpav_port_t *port = &mtp_card->ports[substream->number];
     460        mtpav_port_t *portp = &mtp_card->ports[substream->number];
    446461
    447462        spin_lock_irqsave(&mtp_card->spinlock, flags);
    448         port->mode |= MTPAV_MODE_OUTPUT_OPENED;
    449         port->output = substream;
     463        portp->mode |= MTPAV_MODE_OUTPUT_OPENED;
     464        portp->output = substream;
    450465        spin_unlock_irqrestore(&mtp_card->spinlock, flags);
    451466        return 0;
     
    458473{
    459474        unsigned long flags;
    460         mtpav_port_t *port = &mtp_card->ports[substream->number];
     475        mtpav_port_t *portp = &mtp_card->ports[substream->number];
    461476
    462477        spin_lock_irqsave(&mtp_card->spinlock, flags);
    463         port->mode &= (~MTPAV_MODE_OUTPUT_OPENED);
    464         port->output = NULL;
     478        portp->mode &= (~MTPAV_MODE_OUTPUT_OPENED);
     479        portp->output = NULL;
    465480        spin_unlock_irqrestore(&mtp_card->spinlock, flags);
    466481        return 0;
     
    473488{
    474489        unsigned long flags;
    475         mtpav_port_t *port = &mtp_card->ports[substream->number];
     490        mtpav_port_t *portp = &mtp_card->ports[substream->number];
    476491
    477492        spin_lock_irqsave(&mtp_card->spinlock, flags);
    478493        if (up) {
    479                 if (! (port->mode  & MTPAV_MODE_OUTPUT_TRIGGERED)) {
     494                if (! (portp->mode  & MTPAV_MODE_OUTPUT_TRIGGERED)) {
    480495                        if (mtp_card->istimer++ == 0)
    481496                                snd_mtpav_add_output_timer(mtp_card);
    482                         port->mode |= MTPAV_MODE_OUTPUT_TRIGGERED;
     497                        portp->mode |= MTPAV_MODE_OUTPUT_TRIGGERED;
    483498                }
    484499        } else {
    485                 port->mode &= ~MTPAV_MODE_OUTPUT_TRIGGERED;
     500                portp->mode &= ~MTPAV_MODE_OUTPUT_TRIGGERED;
    486501                if (--mtp_card->istimer == 0)
    487502                        snd_mtpav_remove_output_timer(mtp_card);
     
    499514static void snd_mtpav_inmidi_process(mtpav_t *mcrd, u8 inbyte)
    500515{
    501         mtpav_port_t *port;
    502 
    503         if (mcrd->inmidiport > mcrd->num_ports * 2 + MTPAV_PIDX_BROADCAST)
     516        mtpav_port_t *portp;
     517
     518        if ((int)mcrd->inmidiport > mcrd->num_ports * 2 + MTPAV_PIDX_BROADCAST)
    504519                return;
    505520
    506         port = &mcrd->ports[mcrd->inmidiport];
    507         if (port->mode & MTPAV_MODE_INPUT_TRIGGERED) {
     521        portp = &mcrd->ports[mcrd->inmidiport];
     522        if (portp->mode & MTPAV_MODE_INPUT_TRIGGERED) {
    508523                spin_unlock(&mcrd->spinlock);
    509                 snd_rawmidi_receive(port->input, &inbyte, 1);
     524                snd_rawmidi_receive(portp->input, &inbyte, 1);
    510525                spin_lock(&mcrd->spinlock);
    511526        }
     
    681696static mtpav_t *new_mtpav(void)
    682697{
    683         mtpav_t *ncrd = (mtpav_t *) snd_kcalloc(sizeof(mtpav_t), GFP_KERNEL);
     698        mtpav_t *ncrd = (mtpav_t *) snd_magic_kcalloc(mtpav_t, 0, GFP_KERNEL);
    684699        if (ncrd != NULL) {
    685700                spin_lock_init(&ncrd->spinlock);
     
    714729                kfree_nocheck(crd->res_port);
    715730        }
    716         if (crd != NULL)
    717                 kfree(crd);
     731        snd_magic_kfree(crd);
    718732}
    719733
     
    790804#ifndef MODULE
    791805
    792 /* format is: snd-mtpav=snd_enable,index,id,
     806/* format is: snd-mtpav=enable,index,id,
    793807                        port,irq,hwports */
    794808
  • GPL/branches/alsa-resync1/alsa-kernel/drivers/serial-u16550.c

    r215 r224  
    77 *
    88 *   This code is based on the code from ALSA 0.5.9, but heavily rewritten.
    9  *
    10  * Sat Mar 31 17:27:57 PST 2001 tim.mann@compaq.com
    11  *      Added support for the Midiator MS-124T and for the MS-124W in
    12  *      Single Addressed (S/A) or Multiple Burst (M/B) mode, with
    13  *      power derived either parasitically from the serial port or
    14  *      from a separate power supply.
    15  *
    16  *      The new snd_adaptor module parameter allows you to select
    17  *      either the default Roland Soundcanvas support (0), which was
    18  *      previously included in this driver but was not documented,
    19  *      Midiator MS-124T support (1), Midiator MS-124W S/A mode
    20  *      support (2), or MS-124W M/B mode support (3).  For the
    21  *      Midiator MS-124W, you must set the physical M-S and A-B
    22  *      switches on the Midiator to match the driver mode you select.
    23  * 
    24  *      - In Roland Soundcanvas mode, multiple ALSA raw MIDI
    25  *      substreams are supported (midiCnD0-midiCnD15).  Whenever you
    26  *      write to a different substream, the driver sends the
    27  *      nonstandard MIDI command sequence F5 NN, where NN is the
    28  *      substream number plus 1.  Roland modules use this command to
    29  *      switch between different "parts", so this feature lets you
    30  *      treat each part as a distinct raw MIDI substream.  The driver
    31  *      provides no way to send F5 00 (no selection) or to not send
    32  *      the F5 NN command sequence at all; perhaps it ought to.
    33  *
    34  *      - In MS-124T mode, one raw MIDI substream is supported
    35  *      (midiCnD0); the snd_outs module parameter is automatically set
    36  *      to 1.  The driver sends the same data to all four MIDI Out
    37  *      connectors.  Set the A-B switch and the snd_speed module
    38  *      parameter to match (A=19200, B=9600).
    39  *
    40  *      Usage example for MS-124T, with A-B switch in A position:
    41  *        setserial /dev/ttyS0 uart none
    42  *        /sbin/modprobe snd-card-serial snd_port=0x3f8 snd_irq=4 \
    43  *            snd_adaptor=1 snd_speed=19200
    44  *
    45  *      - In MS-124W S/A mode, one raw MIDI substream is supported
    46  *      (midiCnD0); the snd_outs module parameter is automatically set
    47  *      to 1.  The driver sends the same data to all four MIDI Out
    48  *      connectors at full MIDI speed.
    49  *
    50  *      Usage example for S/A mode:
    51  *        setserial /dev/ttyS0 uart none
    52  *        /sbin/modprobe snd-card-serial snd_port=0x3f8 snd_irq=4 \
    53  *            snd_adaptor=2
    54  *
    55  *      - In MS-124W M/B mode, the driver supports 16 ALSA raw MIDI
    56  *      substreams; the snd_outs module parameter is automatically set
    57  *      to 16.  The substream number gives a bitmask of which MIDI Out
    58  *      connectors the data should be sent to, with midiCnD1 sending
    59  *      to Out 1, midiCnD2 to Out 2, midiCnD4 to Out 3, and midiCnD8
    60  *      to Out 4.  Thus midiCnD15 sends the data to all 4 ports.  As a
    61  *      special case, midiCnD0 also sends to all ports, since it is
    62  *      not useful to send the data to no ports.  M/B mode has extra
    63  *      overhead to select the MIDI Out for each byte, so the
    64  *      aggregate data rate across all four MIDI Outs is at most one
    65  *      byte every 520 us, as compared with the full MIDI data rate of
    66  *      one byte every 320 us per port.
    67  *
    68  *      Usage example for M/B mode:
    69  *        setserial /dev/ttyS0 uart none
    70  *        /sbin/insmod snd-card-serial snd_port=0x3f8 snd_irq=4 \
    71  *            snd_adaptor=3
    72  *
    73  *      - The MS-124W hardware's M/A mode is currently not supported.
    74  *      This mode allows the MIDI Outs to act independently at double
    75  *      the aggregate throughput of M/B, but does not allow sending
    76  *      the same byte simultaneously to multiple MIDI Outs.  The M/A
    77  *      protocol requires the driver to twiddle the modem control
    78  *      lines under timing constraints, so it would be a bit more
    79  *      complicated to implement than the other modes.
    80  *
    81  *      - Midiator models other than MS-124W and MS-124T are currently
    82  *      not supported.  Note that the suffix letter is significant;
    83  *      the MS-124 and MS-124B are not compatible, nor are the other
    84  *      known models MS-101, MS-101B, MS-103, and MS-114.  I do have
    85  *      documentation that partially covers these models, but no units
    86  *      to experiment with.  The MS-124W support is tested with a real
    87  *      unit.  The MS-124T support is untested, but should work.
    889 *
    8910 *   This program is free software; you can redistribute it and/or modify
     
    10122 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    10223 *
     24 * Sat Mar 31 17:27:57 PST 2001 tim.mann@compaq.com
     25 *      Added support for the Midiator MS-124T and for the MS-124W in
     26 *      Single Addressed (S/A) or Multiple Burst (M/B) mode, with
     27 *      power derived either parasitically from the serial port or
     28 *      from a separate power supply.
     29 *
     30 *      More documentation can be found in serial-u16550.txt.
    10331 */
    10432
    10533#include <sound/driver.h>
    106 #include <asm/io.h>
    10734#include <linux/init.h>
     35#include <linux/interrupt.h>
    10836#include <linux/slab.h>
     37#include <linux/ioport.h>
    10938#include <sound/core.h>
    11039#include <sound/rawmidi.h>
     
    11443#include <linux/serial_reg.h>
    11544
    116 MODULE_DESCRIPTION("MIDI serial");
     45#include <asm/io.h>
     46
     47MODULE_DESCRIPTION("MIDI serial u16550");
    11748MODULE_LICENSE("GPL");
    11849MODULE_CLASSES("{sound}");
    119 MODULE_DEVICES("{{ALSA, MIDI serial}}");
     50MODULE_DEVICES("{{ALSA, MIDI serial u16550}}");
    12051
    12152#define SNDRV_SERIAL_SOUNDCANVAS 0 /* Roland Soundcanvas; F5 NN selects part */
     
    282213/* This loop should be called with interrupts disabled
    283214 * We don't want to interrupt this,
    284  * as we're already handling an interupt
     215 * as we're already handling an interrupt
    285216 */
    286217static void snd_uart16550_io_loop(snd_uart16550_t * uart)
     
    352283 * After receiving a interrupt, it is important to indicate to the UART that
    353284 * this has been done.
    354  * For a Rx interupt, this is done by reading the received byte.
    355  * For a Tx interupt this is done by either:
     285 * For a Rx interrupt, this is done by reading the received byte.
     286 * For a Tx interrupt this is done by either:
    356287 * a) Writing a byte
    357288 * b) Reading the IIR
    358  * It is particularly important to read the IIR if a Tx interupt is received
     289 * It is particularly important to read the IIR if a Tx interrupt is received
    359290 * when there is no data in tx_buff[], as in this case there no other
    360  * indication that the interupt has been serviced, and it remains outstanding
    361  * indefinitely. This has the curious side effect that and no further interupts
     291 * indication that the interrupt has been serviced, and it remains outstanding
     292 * indefinitely. This has the curious side effect that and no further interrupts
    362293 * will be generated from this device AT ALL!!.
    363  * It is also desirable to clear outstanding interupts when the device is
     294 * It is also desirable to clear outstanding interrupts when the device is
    364295 * opened/closed.
    365296 *
     
    401332 *  return negative error if not found
    402333 */
    403 static int __init snd_uart16550_detect(unsigned int io_base)
    404 {
     334static int __init snd_uart16550_detect(snd_uart16550_t *uart)
     335{
     336        unsigned long io_base = uart->base;
    405337    int ok;
    406338    unsigned char c;
    407339
    408     if (check_region(io_base, 8))
    409         return -EBUSY;
    410 
    411340    /* Do some vague tests for the presence of the uart */
    412     if (io_base == 0)
     341        if (io_base == 0) {
    413342        return -ENODEV; /* Not configured */
     343        }
     344
     345        uart->res_base = request_region(io_base, 8, "Serial MIDI");
     346        if (uart->res_base == NULL)
     347                return -EBUSY;
    414348
    415349    ok = 1;                     /* uart detected unless one of the following tests should fail */
     
    454388         | UART_FCR_CLEAR_XMIT  /* Clear transmitter FIFO */
    455389         | UART_FCR_TRIGGER_4   /* Set FIFO trigger at 4-bytes */
    456          /* NOTE: interupt generated after T=(time)4-bytes
     390        /* NOTE: interrupt generated after T=(time)4-bytes
    457391          * if less than UART_FCR_TRIGGER bytes received
    458392          */
     
    506440
    507441    if (uart->irq < 0) {
    508         byte = (0 & UART_IER_RDI)       /* Disable Receiver data interupt */
    509             |(0 & UART_IER_THRI)        /* Disable Transmitter holding register empty interupt */
     442                byte = (0 & UART_IER_RDI)       /* Disable Receiver data interrupt */
     443                    |(0 & UART_IER_THRI)        /* Disable Transmitter holding register empty interrupt */
    510444            ;
    511445    } else if (uart->adaptor == SNDRV_SERIAL_MS124W_SA) {
     
    516450                byte = UART_IER_RDI     /* Enable Receiver data interrupt */
    517451                    | UART_IER_MSI      /* Enable Modem status interrupt */
    518                     | UART_IER_THRI     /* Enable Transmitter holding register empty interupt */
     452                    | UART_IER_THRI     /* Enable Transmitter holding register empty interrupt */
    519453                    ;
    520454    } else {
    521         byte = UART_IER_RDI     /* Enable Receiver data interupt */
    522             | UART_IER_THRI     /* Enable Transmitter holding register empty interupt */
     455                byte = UART_IER_RDI     /* Enable Receiver data interrupt */
     456                    | UART_IER_THRI     /* Enable Transmitter holding register empty interrupt */
    523457            ;
    524458    }
     
    539473     */
    540474
    541     outb((0 & UART_IER_RDI)             /* Disable Receiver data interupt */
    542          |(0 & UART_IER_THRI)   /* Disable Transmitter holding register empty interupt */
     475        outb((0 & UART_IER_RDI)         /* Disable Receiver data interrupt */
     476             |(0 & UART_IER_THRI)       /* Disable Transmitter holding register empty interrupt */
    543477         ,uart->base + UART_IER);       /* Interupt enable Register */
    544478
     
    565499    }
    566500
    567     inb(uart->base + UART_IIR); /* Clear any outstanding interupts */
     501        inb(uart->base + UART_IIR);     /* Clear any outstanding interrupts */
    568502
    569503    /* Restore old divisor */
     
    848782                                       snd_uart16550_t **ruart)
    849783{
    850 #ifdef TARGET_OS2
    851784    static snd_device_ops_t ops = {
    852         snd_uart16550_dev_free,0,0,0
     785                .dev_free =     snd_uart16550_dev_free,
    853786    };
    854 #else
    855     static snd_device_ops_t ops = {
    856     dev_free:       snd_uart16550_dev_free,
    857     };
    858 #endif
    859787    snd_uart16550_t *uart;
    860788    int err;
     
    867795    spin_lock_init(&uart->open_lock);
    868796    uart->irq = -1;
    869     if ((uart->res_base = request_region(iobase, 8, "Serial MIDI")) == NULL) {
    870         snd_printk("unable to grab ports 0x%lx-0x%lx\n", iobase, iobase + 8 - 1);
    871         return -EBUSY;
    872     }
    873797    uart->base = iobase;
     798
     799        if ((err = snd_uart16550_detect(uart)) <= 0) {
     800                printk(KERN_ERR "no UART detected at 0x%lx\n", iobase);
     801                return err;
     802        }
     803
    874804    if (irq >= 0) {
    875805        if (request_irq(irq, snd_uart16550_interrupt,
     
    988918    strcpy(card->driver, "Serial");
    989919    strcpy(card->shortname, "Serial midi (uart16550A)");
    990 
    991         if ((err = snd_uart16550_detect(port[dev])) <= 0) {
    992         snd_card_free(card);
    993                 printk(KERN_ERR "no UART detected at 0x%lx\n", (long)port[dev]);
    994         return err;
    995     }
    996920
    997921    if ((err = snd_uart16550_create(card,
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/asound.h

    r96 r224  
    11/*
    22 *  Advanced Linux Sound Architecture - ALSA - Driver
    3  *  Copyright (c) 1994-2000 by Jaroslav Kysela <perex@suse.cz>,
     3 *  Copyright (c) 1994-2003 by Jaroslav Kysela <perex@suse.cz>,
    44 *                             Abramo Bagnara <abramo@alsa-project.org>
    55 *
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/core.h

    r222 r224  
    3131
    3232/* Typedef's */
    33 typedef struct timeval snd_timestamp_t;
     33typedef struct timespec snd_timestamp_t;
    3434#ifndef TARGET_OS2
    3535typedef enum sndrv_card_type snd_card_type;
     
    325325void snd_dma_program(unsigned long dma, const void *buf, unsigned int size, unsigned short mode);
    326326void snd_dma_disable(unsigned long dma);
    327 unsigned int snd_dma_residue(unsigned long dma);
     327unsigned int snd_dma_pointer(unsigned long dma, unsigned int size);
    328328
    329329/* misc.c */
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/driver.h

    r210 r224  
    5757#endif /* TARGET_OS2 */
    5858
    59 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 4, 0)
    60 #if defined(__i386__) || defined(__ppc__) || defined(__x86_64__)
    61 /*
    62  * Here a dirty hack for 2.4 kernels.. See sound/core/memory.c.
    63  */
    64 #define HACK_PCI_ALLOC_CONSISTENT
    65 #include <linux/pci.h>
    66 void *snd_pci_hack_alloc_consistent(struct pci_dev *hwdev, size_t size,
    67                                     dma_addr_t *dma_handle);
    68 #undef pci_alloc_consistent
    69 #define pci_alloc_consistent snd_pci_hack_alloc_consistent
    70 #endif /* i386 or ppc */
    71 #endif /* 2.4.0 */
    72 
    7359#ifdef CONFIG_SND_DEBUG_MEMORY
    7460#include <linux/slab.h>
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/initval.h

    r222 r224  
    2626#define MODULE_GENERIC_STRING(name, string) \
    2727static const char __module_generic_string_##name [] \
    28   __attribute__ ((section(".modstring"))) = #name "=" string;
     28  __attribute__ ((unused, __section__(".modstring"))) = #name "=" string;
    2929#else
    3030#define MODULE_GENERIC_STRING(name, string)
     
    102102#define SNDRV_BOOLEAN_FALSE_DESC "allows:{{0,Disabled},{1,Enabled}},default:0,dialog:check"
    103103
    104 #define SNDRV_ENABLED           "enable:(snd_enable)"
     104#define SNDRV_ENABLED           "enable:(enable)"
    105105
    106106#define SNDRV_INDEX_DESC        SNDRV_ENABLED ",allows:{{0,7}},unique,skill:required,dialog:list"
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/mixer_oss.h

    r222 r224  
    3232typedef int (*snd_mixer_oss_get_recsrc_t)(snd_mixer_oss_file_t *fmixer, snd_mixer_oss_slot_t *chn, int *active);
    3333typedef int (*snd_mixer_oss_put_recsrc_t)(snd_mixer_oss_file_t *fmixer, snd_mixer_oss_slot_t *chn, int active);
    34 typedef int (*snd_mixer_oss_get_recsrce_t)(snd_mixer_oss_file_t *fmixer, int *active_index);
    35 typedef int (*snd_mixer_oss_put_recsrce_t)(snd_mixer_oss_file_t *fmixer, int active_index);
     34typedef int (*snd_mixer_oss_get_recsrce_t)(snd_mixer_oss_file_t *fmixer, unsigned int *active_index);
     35typedef int (*snd_mixer_oss_put_recsrce_t)(snd_mixer_oss_file_t *fmixer, unsigned int active_index);
    3636
    3737#define SNDRV_OSS_MAX_MIXERS    32
  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/uda1341.h

    r215 r224  
    1616 */
    1717
    18 /* uda1341.h,v 1.2 2002/04/17 07:53:22 perex Exp */
     18/* uda1341.h,v 1.4 2003/02/25 12:48:16 perex Exp */
    1919
    2020#define UDA1341_ALSA_NAME "snd-uda1341"
     21
     22/*
     23 * Default rate set after inicialization
     24 */
     25#define AUDIO_RATE_DEFAULT      44100
    2126
    2227/*
     
    161166 *
    162167 * UDA1341 datasheet on page 21: Peak value (dB) = (Peak level - 63.5)*5*log2
    163  * There is an tabel with these values [level]=value: [3]=-90.31, [7]=-84.29
     168 * There is an table with these values [level]=value: [3]=-90.31, [7]=-84.29
    164169 * [61]=-2.78, [62] = -1.48, [63] = 0.0
    165170 * I tried to compute it, but using but even using logarithm with base either 10 or 2
  • GPL/branches/alsa-resync1/alsa-kernel/isa/ad1816a/ad1816a.c

    r212 r224  
    107107static const struct isapnp_card_id *snd_ad1816a_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    108108
    109 #ifdef TARGET_OS2
    110 #define ISAPNP_AD1816A(_va, _vb, _vc, _device, _fa, _fb, _fc, _audio, _mpu401) \
    111         { \
    112                 0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    113                 { ISAPNP_DEVICE_ID(_fa, _fb, _fc, _audio), \
    114                   ISAPNP_DEVICE_ID(_fa, _fb, _fc, _mpu401), } \
    115         }
    116 #else
    117109#define ISAPNP_AD1816A(_va, _vb, _vc, _device, _fa, _fb, _fc, _audio, _mpu401) \
    118110        { \
    119111                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    120                 devs : { ISAPNP_DEVICE_ID(_fa, _fb, _fc, _audio), \
     112                .devs = { ISAPNP_DEVICE_ID(_fa, _fb, _fc, _audio), \
    121113                         ISAPNP_DEVICE_ID(_fa, _fb, _fc, _mpu401), } \
    122114        }
    123 #endif
    124115
    125116static struct isapnp_card_id snd_ad1816a_pnpids[] __devinitdata = {
  • GPL/branches/alsa-resync1/alsa-kernel/isa/ad1848/ad1848_lib.c

    r210 r224  
    2222#define SNDRV_MAIN_OBJECT_FILE
    2323#include <sound/driver.h>
    24 #include <asm/io.h>
    25 #include <asm/dma.h>
    2624#include <linux/delay.h>
    2725#include <linux/init.h>
     26#include <linux/interrupt.h>
    2827#include <linux/slab.h>
    2928#include <linux/ioport.h>
    3029#include <sound/core.h>
    3130#include <sound/ad1848.h>
     31#include <sound/control.h>
    3232#include <sound/pcm_params.h>
     33
     34#include <asm/io.h>
     35#include <asm/dma.h>
    3336
    3437MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
     
    603606        if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_PLAYBACK_ENABLE))
    604607                return 0;
    605         ptr = chip->dma_size - snd_dma_residue(chip->dma);
     608        ptr = snd_dma_pointer(chip->dma, chip->dma_size);
    606609        return bytes_to_frames(substream->runtime, ptr);
    607610}
     
    614617        if (!(chip->image[AD1848_IFACE_CTRL] & AD1848_CAPTURE_ENABLE))
    615618                return 0;
    616         ptr = chip->dma_size - snd_dma_residue(chip->dma);
     619        ptr = snd_dma_pointer(chip->dma, chip->dma_size);
    617620        return bytes_to_frames(substream->runtime, ptr);
    618621}
     
    935938}
    936939
     940const snd_pcm_ops_t *snd_ad1848_get_pcm_ops(int direction)
     941{
     942        return direction == SNDRV_PCM_STREAM_PLAYBACK ?
     943                &snd_ad1848_playback_ops : &snd_ad1848_capture_ops;
     944}
     945
    937946/*
    938947 *  MIXER part
     
    989998}
    990999
    991 int snd_ad1848_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     1000static int snd_ad1848_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    9921001{
    9931002        int mask = (kcontrol->private_value >> 16) & 0xff;
     
    10001009}
    10011010
    1002 int snd_ad1848_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1011static int snd_ad1848_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
    10031012{
    10041013        ad1848_t *chip = snd_kcontrol_chip(kcontrol);
     
    10171026}
    10181027
    1019 int snd_ad1848_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1028static int snd_ad1848_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
    10201029{
    10211030        ad1848_t *chip = snd_kcontrol_chip(kcontrol);
     
    10401049}
    10411050
    1042 int snd_ad1848_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     1051static int snd_ad1848_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    10431052{
    10441053        int mask = (kcontrol->private_value >> 24) & 0xff;
     
    10511060}
    10521061
    1053 int snd_ad1848_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1062static int snd_ad1848_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
    10541063{
    10551064        ad1848_t *chip = snd_kcontrol_chip(kcontrol);
     
    10731082}
    10741083
    1075 int snd_ad1848_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1084static int snd_ad1848_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
    10761085{
    10771086        ad1848_t *chip = snd_kcontrol_chip(kcontrol);
     
    11101119}
    11111120
    1112 #define AD1848_CONTROLS (sizeof(snd_ad1848_controls)/sizeof(snd_kcontrol_new_t))
    1113 
    1114 static snd_kcontrol_new_t snd_ad1848_controls[] = {
     1121/*
     1122 */
     1123int snd_ad1848_add_ctl(ad1848_t *chip, const char *name, int index, int type, unsigned long value)
     1124{
     1125        static snd_kcontrol_new_t newctls[] = {
     1126                [AD1848_MIX_SINGLE] = {
     1127                        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     1128                        .info = snd_ad1848_info_single,
     1129                        .get = snd_ad1848_get_single,
     1130                        .put = snd_ad1848_put_single,
     1131                },
     1132                [AD1848_MIX_DOUBLE] = {
     1133                        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     1134                        .info = snd_ad1848_info_double,
     1135                        .get = snd_ad1848_get_double,
     1136                        .put = snd_ad1848_put_double,
     1137                },
     1138                [AD1848_MIX_CAPTURE] = {
     1139                        .info = snd_ad1848_info_mux,
     1140                        .get = snd_ad1848_get_mux,
     1141                        .put = snd_ad1848_put_mux,
     1142                },
     1143        };
     1144        snd_kcontrol_t *ctl;
     1145        int err;
     1146
     1147        ctl = snd_ctl_new1(&newctls[type], chip);
     1148        if (! ctl)
     1149                return -ENOMEM;
     1150        strncpy(ctl->id.name, name, sizeof(ctl->id.name)-1);
     1151        ctl->id.index = index;
     1152        ctl->private_value = value;
     1153        if ((err = snd_ctl_add(chip->card, ctl)) < 0) {
     1154                snd_ctl_free_one(ctl);
     1155                return err;
     1156        }
     1157        return 0;
     1158}
     1159
     1160
     1161static struct ad1848_mix_elem snd_ad1848_controls[] = {
    11151162AD1848_DOUBLE("PCM Playback Switch", 0, AD1848_LEFT_OUTPUT, AD1848_RIGHT_OUTPUT, 7, 7, 1, 1),
    11161163AD1848_DOUBLE("PCM Playback Volume", 0, AD1848_LEFT_OUTPUT, AD1848_RIGHT_OUTPUT, 0, 0, 63, 1),
     
    11211168AD1848_DOUBLE("Capture Volume", 0, AD1848_LEFT_INPUT, AD1848_RIGHT_INPUT, 0, 0, 15, 0),
    11221169{
    1123         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    11241170        .name = "Capture Source",
    1125         .info = snd_ad1848_info_mux,
    1126         .get = snd_ad1848_get_mux,
    1127         .put = snd_ad1848_put_mux,
     1171        .type = AD1848_MIX_CAPTURE,
    11281172},
    11291173AD1848_SINGLE("Loopback Capture Switch", 0, AD1848_LOOPBACK, 0, 1, 0),
     
    11351179        snd_card_t *card;
    11361180        snd_pcm_t *pcm;
    1137         int err, idx;
     1181        unsigned int idx;
     1182        int err;
    11381183
    11391184        snd_assert(chip != NULL && chip->pcm != NULL, return -EINVAL);
     
    11441189        strcpy(card->mixername, pcm->name);
    11451190
    1146         for (idx = 0; idx < AD1848_CONTROLS; idx++) {
    1147                 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_ad1848_controls[idx], chip))) < 0)
     1191        for (idx = 0; idx < ARRAY_SIZE(snd_ad1848_controls); idx++)
     1192                if ((err = snd_ad1848_add_ctl_elem(chip, &snd_ad1848_controls[idx])) < 0)
    11481193                        return err;
    1149         }
     1194
    11501195        return 0;
    11511196}
     
    11591204EXPORT_SYMBOL(snd_ad1848_create);
    11601205EXPORT_SYMBOL(snd_ad1848_pcm);
     1206EXPORT_SYMBOL(snd_ad1848_get_pcm_ops);
    11611207EXPORT_SYMBOL(snd_ad1848_mixer);
    1162 EXPORT_SYMBOL(snd_ad1848_info_single);
    1163 EXPORT_SYMBOL(snd_ad1848_get_single);
    1164 EXPORT_SYMBOL(snd_ad1848_put_single);
    1165 EXPORT_SYMBOL(snd_ad1848_info_double);
    1166 EXPORT_SYMBOL(snd_ad1848_get_double);
    1167 EXPORT_SYMBOL(snd_ad1848_put_double);
     1208EXPORT_SYMBOL(snd_ad1848_add_ctl);
    11681209
    11691210/*
  • GPL/branches/alsa-resync1/alsa-kernel/isa/als100.c

    r212 r224  
    110110static const struct isapnp_card_id *snd_als100_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    111111
    112 #ifdef TARGET_OS2
    113112#define ISAPNP_ALS100(_va, _vb, _vc, _device, _audio, _mpu401, _opl) \
    114113        { \
    115                 0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    116                       { ISAPNP_DEVICE_ID('@', '@', '@', _audio), \
     114                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
     115                .devs = { ISAPNP_DEVICE_ID('@', '@', '@', _audio), \
    117116                         ISAPNP_DEVICE_ID('@', 'X', '@', _mpu401), \
    118117                         ISAPNP_DEVICE_ID('@', 'H', '@', _opl) } \
    119118        }
    120 #else
    121 #define ISAPNP_ALS100(_va, _vb, _vc, _device, _audio, _mpu401, _opl) \
    122         { \
    123                 ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    124                 devs : { ISAPNP_DEVICE_ID('@', '@', '@', _audio), \
    125                          ISAPNP_DEVICE_ID('@', 'X', '@', _mpu401), \
    126                          ISAPNP_DEVICE_ID('@', 'H', '@', _opl) } \
    127         }
    128 #endif
    129119
    130120static struct isapnp_card_id snd_als100_pnpids[] __devinitdata = {
  • GPL/branches/alsa-resync1/alsa-kernel/isa/azt2320.c

    r212 r224  
    118118static const struct isapnp_card_id *snd_azt2320_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    119119
    120 #ifdef TARGET_OS2
    121 #define ISAPNP_AZT2320(_va, _vb, _vc, _device, _audio, _mpu401) \
    122         { \
    123                 0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    124                 { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    125                   ISAPNP_DEVICE_ID(_va, _vb, _vc, _mpu401), } \
    126         }
    127 #else
    128120#define ISAPNP_AZT2320(_va, _vb, _vc, _device, _audio, _mpu401) \
    129121        { \
    130122                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    131                 devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
     123                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    132124                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _mpu401), } \
    133125        }
    134 #endif
    135126
    136127static struct isapnp_card_id snd_azt2320_pnpids[] __devinitdata = {
  • GPL/branches/alsa-resync1/alsa-kernel/isa/cmi8330.c

    r212 r224  
    3131 *  To quickly load the module,
    3232 *
    33  *  modprobe -a snd-card-cmi8330 sbport=0x220 sbirq=5 sbdma8=1
     33 *  modprobe -a snd-cmi8330 sbport=0x220 sbirq=5 sbdma8=1
    3434 *    sbdma16=5 wssport=0x530 wssirq=11 wssdma=0
    3535 *
     
    5858#include <sound/initval.h>
    5959
     60/*
     61 */
     62/* #define ENABLE_SB_MIXER */
     63#define PLAYBACK_ON_SB
     64
     65/*
     66 */
    6067MODULE_AUTHOR("George Talusan <gstalusan@uwaterloo.ca>");
    6168MODULE_DESCRIPTION("C-Media CMI8330");
     
    134141static unsigned char snd_cmi8330_image[((CMI8330_CDINGAIN)-16) + 1] =
    135142{
    136         0x0,                    /* 16 - recording mux */
    137         0x40,                   /* 17 - mute mux */
     143        0x40,                   /* 16 - recording mux (SB-mixer-enabled) */
     144#ifdef ENABLE_SB_MIXER
     145        0x40,                   /* 17 - mute mux (Mode2) */
     146#else
     147        0x0,                    /* 17 - mute mux */
     148#endif
    138149        0x0,                    /* 18 - vol */
    139150        0x0,                    /* 19 - master volume */
     
    147158};
    148159
     160typedef int (*snd_pcm_open_callback_t)(snd_pcm_substream_t *);
     161
    149162struct snd_cmi8330 {
    150163#ifdef __ISAPNP__
     
    152165        struct isapnp_dev *play;
    153166#endif
     167        snd_card_t *card;
     168        ad1848_t *wss;
     169        sb_t *sb;
     170
     171        snd_pcm_t *pcm;
     172        struct snd_cmi8330_stream {
     173                snd_pcm_ops_t ops;
     174                snd_pcm_open_callback_t open;
     175                void *private_data; /* sb or wss */
     176        } streams[2];
    154177};
    155178
     
    161184static const struct isapnp_card_id *snd_cmi8330_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    162185
    163 #ifdef TARGET_OS2
    164 #define ISAPNP_CMI8330(_va, _vb, _vc, _device, _audio1, _audio2) \
    165         { \
    166                 0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    167                  { ISAPNP_DEVICE_ID('@', '@', '@', _audio1), \
    168                    ISAPNP_DEVICE_ID('@', 'X', '@', _audio2), } \
    169         }
    170 #else
    171186#define ISAPNP_CMI8330(_va, _vb, _vc, _device, _audio1, _audio2) \
    172187        { \
    173188                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    174                 devs : { ISAPNP_DEVICE_ID('@', '@', '@', _audio1), \
     189                .devs = { ISAPNP_DEVICE_ID('@', '@', '@', _audio1), \
    175190                         ISAPNP_DEVICE_ID('@', 'X', '@', _audio2), } \
    176191        }
    177 #endif
    178192
    179193static struct isapnp_card_id snd_cmi8330_pnpids[] __devinitdata =
     
    187201#endif
    188202
    189 #define CMI8330_CONTROLS (sizeof(snd_cmi8330_controls)/sizeof(snd_kcontrol_new_t))
    190 
    191 static snd_kcontrol_new_t snd_cmi8330_controls[] __devinitdata = {
     203
     204static struct ad1848_mix_elem snd_cmi8330_controls[] __initdata = {
    192205AD1848_DOUBLE("Master Playback Volume", 0, CMI8330_MASTVOL, CMI8330_MASTVOL, 4, 0, 15, 0),
    193206AD1848_SINGLE("Loud Playback Switch", 0, CMI8330_MUTEMUX, 6, 1, 1),
     
    201214AD1848_DOUBLE("CD Capture Switch", 0, CMI8330_RMUX3D, CMI8330_RMUX3D, 4, 3, 1, 0),
    202215AD1848_DOUBLE("CD Playback Volume", 0, CMI8330_CDINVOL, CMI8330_CDINVOL, 4, 0, 15, 0),
    203 AD1848_DOUBLE("CD Capture Switch", 0, CMI8330_CDINGAIN, CMI8330_CDINGAIN, 4, 0, 15, 0),
     216AD1848_DOUBLE("CD Capture Volume", 0, CMI8330_CDINGAIN, CMI8330_CDINGAIN, 4, 0, 15, 0),
    204217AD1848_SINGLE("Mic Playback Switch", 0, CMI8330_MUTEMUX, 0, 1, 0),
    205218AD1848_SINGLE("Mic Playback Volume", 0, CMI8330_OUTPUTVOL, 0, 7, 0),
     
    217230};
    218231
    219 static int __init snd_cmi8330_mixer(snd_card_t *card, ad1848_t *chip)
     232#ifdef ENABLE_SB_MIXER
     233static struct sbmix_elem cmi8330_sb_mixers[] __initdata = {
     234SB_DOUBLE("SB Master Playback Volume", SB_DSP4_MASTER_DEV, (SB_DSP4_MASTER_DEV + 1), 3, 3, 31),
     235SB_DOUBLE("Tone Control - Bass", SB_DSP4_BASS_DEV, (SB_DSP4_BASS_DEV + 1), 4, 4, 15),
     236SB_DOUBLE("Tone Control - Treble", SB_DSP4_TREBLE_DEV, (SB_DSP4_TREBLE_DEV + 1), 4, 4, 15),
     237SB_DOUBLE("SB PCM Playback Volume", SB_DSP4_PCM_DEV, (SB_DSP4_PCM_DEV + 1), 3, 3, 31),
     238SB_DOUBLE("SB Synth Playback Volume", SB_DSP4_SYNTH_DEV, (SB_DSP4_SYNTH_DEV + 1), 3, 3, 31),
     239SB_DOUBLE("SB CD Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 2, 1, 1),
     240SB_DOUBLE("SB CD Playback Volume", SB_DSP4_CD_DEV, (SB_DSP4_CD_DEV + 1), 3, 3, 31),
     241SB_DOUBLE("SB Line Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 4, 3, 1),
     242SB_DOUBLE("SB Line Playback Volume", SB_DSP4_LINE_DEV, (SB_DSP4_LINE_DEV + 1), 3, 3, 31),
     243SB_SINGLE("SB Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1),
     244SB_SINGLE("SB Mic Playback Volume", SB_DSP4_MIC_DEV, 3, 31),
     245SB_SINGLE("SB PC Speaker Volume", SB_DSP4_SPEAKER_DEV, 6, 3),
     246SB_DOUBLE("SB Capture Volume", SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3),
     247SB_DOUBLE("SB Playback Volume", SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3),
     248SB_SINGLE("SB Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1),
     249};
     250
     251static unsigned char cmi8330_sb_init_values[][2] __initdata = {
     252        { SB_DSP4_MASTER_DEV + 0, 0 },
     253        { SB_DSP4_MASTER_DEV + 1, 0 },
     254        { SB_DSP4_PCM_DEV + 0, 0 },
     255        { SB_DSP4_PCM_DEV + 1, 0 },
     256        { SB_DSP4_SYNTH_DEV + 0, 0 },
     257        { SB_DSP4_SYNTH_DEV + 1, 0 },
     258        { SB_DSP4_INPUT_LEFT, 0 },
     259        { SB_DSP4_INPUT_RIGHT, 0 },
     260        { SB_DSP4_OUTPUT_SW, 0 },
     261        { SB_DSP4_SPEAKER_DEV, 0 },
     262};
     263
     264
     265static int __init cmi8330_add_sb_mixers(sb_t *chip)
    220266{
    221267        int idx, err;
     268        unsigned long flags;
     269
     270        spin_lock_irqsave(&chip->mixer_lock, flags);
     271        snd_sbmixer_write(chip, 0x00, 0x00);            /* mixer reset */
     272        spin_unlock_irqrestore(&chip->mixer_lock, flags);
     273
     274        /* mute and zero volume channels */
     275        for (idx = 0; idx < ARRAY_SIZE(cmi8330_sb_init_values); idx++) {
     276                spin_lock_irqsave(&chip->mixer_lock, flags);
     277                snd_sbmixer_write(chip, cmi8330_sb_init_values[idx][0],
     278                                  cmi8330_sb_init_values[idx][1]);
     279                spin_unlock_irqrestore(&chip->mixer_lock, flags);
     280        }
     281
     282        for (idx = 0; idx < ARRAY_SIZE(cmi8330_sb_mixers); idx++) {
     283                if ((err = snd_sbmixer_add_ctl_elem(chip, &cmi8330_sb_mixers[idx])) < 0)
     284                        return err;
     285        }
     286        return 0;
     287}
     288#endif
     289
     290static int __init snd_cmi8330_mixer(snd_card_t *card, struct snd_cmi8330 *acard)
     291{
     292        unsigned int idx;
     293        int err;
    222294
    223295        strcpy(card->mixername, "CMI8330/C3D");
    224296
    225         for (idx = 0; idx < CMI8330_CONTROLS; idx++)
    226                 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_cmi8330_controls[idx], chip))) < 0)
     297        for (idx = 0; idx < ARRAY_SIZE(snd_cmi8330_controls); idx++) {
     298                if ((err = snd_ad1848_add_ctl_elem(acard->wss, &snd_cmi8330_controls[idx])) < 0)
    227299                        return err;
    228 
     300        }
     301
     302#ifdef ENABLE_SB_MIXER
     303        if ((err = cmi8330_add_sb_mixers(acard->sb)) < 0)
     304                return err;
     305#endif
    229306        return 0;
    230307}
     
    308385#endif
    309386
     387/*
     388 * PCM interface
     389 *
     390 * since we call the different chip interfaces for playback and capture
     391 * directions, we need a trick.
     392 *
     393 * - copy the ops for each direction into a local record.
     394 * - replace the open callback with the new one, which replaces the
     395 *   substream->private_data with the corresponding chip instance
     396 *   and calls again the original open callback of the chip.
     397 *
     398 */
     399
     400#ifdef PLAYBACK_ON_SB
     401#define CMI_SB_STREAM   SNDRV_PCM_STREAM_PLAYBACK
     402#define CMI_AD_STREAM   SNDRV_PCM_STREAM_CAPTURE
     403#else
     404#define CMI_SB_STREAM   SNDRV_PCM_STREAM_CAPTURE
     405#define CMI_AD_STREAM   SNDRV_PCM_STREAM_PLAYBACK
     406#endif
     407
     408static int snd_cmi8330_playback_open(snd_pcm_substream_t * substream)
     409{
     410        struct snd_cmi8330 *chip = (struct snd_cmi8330 *)_snd_pcm_substream_chip(substream);
     411
     412        /* replace the private_data and call the original open callback */
     413        substream->private_data = chip->streams[SNDRV_PCM_STREAM_PLAYBACK].private_data;
     414        return chip->streams[SNDRV_PCM_STREAM_PLAYBACK].open(substream);
     415}
     416
     417static int snd_cmi8330_capture_open(snd_pcm_substream_t * substream)
     418{
     419        struct snd_cmi8330 *chip = (struct snd_cmi8330 *)_snd_pcm_substream_chip(substream);
     420
     421        /* replace the private_data and call the original open callback */
     422        substream->private_data = chip->streams[SNDRV_PCM_STREAM_CAPTURE].private_data;
     423        return chip->streams[SNDRV_PCM_STREAM_CAPTURE].open(substream);
     424}
     425
     426static void snd_cmi8330_pcm_free(snd_pcm_t *pcm)
     427{
     428        snd_pcm_lib_preallocate_free_for_all(pcm);
     429}
     430
     431static int __init snd_cmi8330_pcm(snd_card_t *card, struct snd_cmi8330 *chip)
     432{
     433        snd_pcm_t *pcm;
     434        const snd_pcm_ops_t *ops;
     435        int err;
     436        static snd_pcm_open_callback_t cmi_open_callbacks[2] = {
     437                snd_cmi8330_playback_open,
     438                snd_cmi8330_capture_open
     439        };
     440
     441        if ((err = snd_pcm_new(card, "CMI8330", 0, 1, 1, &pcm)) < 0)
     442                return err;
     443        strcpy(pcm->name, "CMI8330");
     444        pcm->private_data = chip;
     445        pcm->private_free = snd_cmi8330_pcm_free;
     446       
     447        /* SB16 */
     448        ops = snd_sb16dsp_get_pcm_ops(CMI_SB_STREAM);
     449        chip->streams[CMI_SB_STREAM].ops = *ops;
     450        chip->streams[CMI_SB_STREAM].open = ops->open;
     451        chip->streams[CMI_SB_STREAM].ops.open = cmi_open_callbacks[CMI_SB_STREAM];
     452        chip->streams[CMI_SB_STREAM].private_data = chip->sb;
     453
     454        /* AD1848 */
     455        ops = snd_ad1848_get_pcm_ops(CMI_AD_STREAM);
     456        chip->streams[CMI_AD_STREAM].ops = *ops;
     457        chip->streams[CMI_AD_STREAM].open = ops->open;
     458        chip->streams[CMI_AD_STREAM].ops.open = cmi_open_callbacks[CMI_AD_STREAM];
     459        chip->streams[CMI_AD_STREAM].private_data = chip->wss;
     460
     461        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &chip->streams[SNDRV_PCM_STREAM_PLAYBACK].ops);
     462        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &chip->streams[SNDRV_PCM_STREAM_CAPTURE].ops);
     463
     464        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, 128*1024);
     465        chip->pcm = pcm;
     466
     467        return 0;
     468}
     469
     470
     471/*
     472 */
     473
    310474static void snd_cmi8330_free(snd_card_t *card)
    311475{
     
    323487        snd_card_t *card;
    324488        struct snd_cmi8330 *acard;
    325         ad1848_t *chip_wss;
    326         sb_t *chip_sb;
    327489        unsigned long flags;
    328490        int i, err;
    329         snd_pcm_t *pcm, *wss_pcm, *sb_pcm;
    330         snd_pcm_str_t *pstr;
    331491
    332492#ifdef __ISAPNP__
     
    351511        }
    352512        acard = (struct snd_cmi8330 *)card->private_data;
     513        acard->card = card;
    353514        card->private_free = snd_cmi8330_free;
    354515
     
    366527                                     wssdma[dev],
    367528                                     AD1848_HW_DETECT,
    368                                      &chip_wss)) < 0) {
     529                                     &acard->wss)) < 0) {
    369530                snd_printk("(AD1848) device busy??\n");
    370531                snd_card_free(card);
    371532                return err;
    372533        }
    373         if (chip_wss->hardware != AD1848_HW_CMI8330) {
     534        if (acard->wss->hardware != AD1848_HW_CMI8330) {
    374535                snd_printk("(AD1848) not found during probe\n");
    375536                snd_card_free(card);
    376537                return -ENODEV;
    377         }
    378         if ((err = snd_ad1848_pcm(chip_wss, 0, &wss_pcm)) < 0) {
    379                 snd_printk("(AD1848) no enough memory??\n");
    380                 snd_card_free(card);
    381                 return err;
    382538        }
    383539
     
    387543                                    sbdma8[dev],
    388544                                    sbdma16[dev],
    389                                     SB_HW_AUTO, &chip_sb)) < 0) {
     545                                    SB_HW_AUTO, &acard->sb)) < 0) {
    390546                snd_printk("(SB16) device busy??\n");
    391547                snd_card_free(card);
    392548                return err;
    393549        }
    394         if ((err = snd_sb16dsp_pcm(chip_sb, 1, &sb_pcm)) < 0) {
    395                 snd_printk("(SB16) no enough memory??\n");
    396                 snd_card_free(card);
    397                 return err;
    398         }
    399 
    400         if (chip_sb->hardware != SB_HW_16) {
     550        if (acard->sb->hardware != SB_HW_16) {
    401551                snd_printk("(SB16) not found during probe\n");
    402552                snd_card_free(card);
     
    404554        }
    405555
    406         memcpy(&chip_wss->image[16], &snd_cmi8330_image, sizeof(snd_cmi8330_image));
    407 
    408         spin_lock_irqsave(&chip_wss->reg_lock, flags);
    409         snd_ad1848_out(chip_wss, AD1848_MISC_INFO,      /* switch on MODE2 */
    410                        chip_wss->image[AD1848_MISC_INFO] |= 0x40);
    411         spin_unlock_irqrestore(&chip_wss->reg_lock, flags);
    412 
    413         if ((err = snd_cmi8330_mixer(card, chip_wss)) < 0) {
     556        spin_lock_irqsave(&acard->wss->reg_lock, flags);
     557        snd_ad1848_out(acard->wss, AD1848_MISC_INFO, 0x40); /* switch on MODE2 */
     558        for (i = CMI8330_RMUX3D; i <= CMI8330_CDINGAIN; i++)
     559                snd_ad1848_out(acard->wss, i, snd_cmi8330_image[i - CMI8330_RMUX3D]);
     560        spin_unlock_irqrestore(&acard->wss->reg_lock, flags);
     561
     562        if ((err = snd_cmi8330_mixer(card, acard)) < 0) {
    414563                snd_printk("failed to create mixers\n");
    415564                snd_card_free(card);
    416565                return err;
    417566        }
    418         spin_lock_irqsave(&chip_wss->reg_lock, flags);
    419         for (i = CMI8330_RMUX3D; i <= CMI8330_CDINGAIN; i++)
    420                 snd_ad1848_out(chip_wss, i, chip_wss->image[i]);
    421         spin_unlock_irqrestore(&chip_wss->reg_lock, flags);
    422 
    423         /*
    424          * KLUDGE ALERT
    425          *  disable AD1848 playback
    426          *  disable SB16 capture
    427          */
    428         pcm = wss_pcm;
    429         pstr = &pcm->streams[SNDRV_PCM_STREAM_PLAYBACK];
    430         snd_magic_kfree(pstr->substream);
    431         pstr->substream = 0;
    432         pstr->substream_count = 0;
    433 
    434         pcm = sb_pcm;
    435         pstr = &pcm->streams[SNDRV_PCM_STREAM_CAPTURE];
    436         snd_magic_kfree(pstr->substream);
    437         pstr->substream = 0;
    438         pstr->substream_count = 0;
     567
     568        if ((err = snd_cmi8330_pcm(card, acard)) < 0) {
     569                snd_printk("failed to create pcms\n");
     570                snd_card_free(card);
     571                return err;
     572        }
    439573
    440574        strcpy(card->driver, "CMI8330/C3D");
    441575        strcpy(card->shortname, "C-Media CMI8330/C3D");
    442576        sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
    443                 wss_pcm->name,
    444                 chip_wss->port,
     577                card->shortname,
     578                acard->wss->port,
    445579                wssirq[dev],
    446580                wssdma[dev]);
  • GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4231_lib.c

    r215 r224  
    2626
    2727#include <sound/driver.h>
    28 #include <asm/io.h>
    29 #include <asm/dma.h>
    30 #include <asm/irq.h>
    3128#include <linux/delay.h>
    3229#include <linux/pm.h>
    3330#include <linux/init.h>
     31#include <linux/interrupt.h>
    3432#include <linux/slab.h>
    3533#include <linux/ioport.h>
     
    3735#include <sound/cs4231.h>
    3836#include <sound/pcm_params.h>
     37
     38#include <asm/io.h>
     39#include <asm/dma.h>
     40#include <asm/irq.h>
    3941
    4042MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
     
    157159#endif
    158160#ifdef SBUS_SUPPORT
    159                 return sbus_writeb(chip->port + (offset << 2));
     161                return sbus_readb(chip->port + (offset << 2));
    160162#endif
    161163#ifdef EBUS_SUPPORT
     
    337339        int timeout;
    338340
    339         spin_lock_irqsave(&chip->reg_lock, flags);
    340341        for (timeout = 250; timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT); timeout--)
    341342                udelay(100);
     
    344345                snd_printk("mce_up - auto calibration time out (0)\n");
    345346#endif
     347        spin_lock_irqsave(&chip->reg_lock, flags);
    346348        chip->mce_bit |= CS4231_MCE;
    347349        timeout = cs4231_inb(chip, CS4231P(REGSEL));
     
    359361        signed long time;
    360362
    361         spin_lock_irqsave(&chip->reg_lock, flags);
    362363        snd_cs4231_busy_wait(chip);
    363364#if 0
     
    368369                snd_printk("mce_down [0x%lx] - auto calibration time out (0)\n", (long)CS4231P(REGSEL));
    369370#endif
     371        spin_lock_irqsave(&chip->reg_lock, flags);
    370372        chip->mce_bit &= ~CS4231_MCE;
    371373        timeout = cs4231_inb(chip, CS4231P(REGSEL));
    372374        cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
     375        spin_unlock_irqrestore(&chip->reg_lock, flags);
    373376        if (timeout == 0x80)
    374377                snd_printk("mce_down [0x%lx]: serious init problem - codec still busy\n", chip->port);
    375378        if ((timeout & CS4231_MCE) == 0 ||
    376379            !(chip->hardware & (CS4231_HW_CS4231_MASK | CS4231_HW_CS4232_MASK))) {
    377                 spin_unlock_irqrestore(&chip->reg_lock, flags);
    378380                return;
    379381        }
     
    386388        if ((snd_cs4231_in(chip, CS4231_TEST_INIT) & CS4231_CALIB_IN_PROGRESS) == 0) {
    387389                snd_printd("cs4231_mce_down - auto calibration time out (1)\n");
    388                 spin_unlock_irqrestore(&chip->reg_lock, flags);
    389390                return;
    390391        }
     
    392393        printk("(2) timeout = %i, jiffies = %li\n", timeout, jiffies);
    393394#endif
    394         time = HZ / 4;
     395        timeout = HZ / 4 / 2;
     396        time = 2;
    395397        while (snd_cs4231_in(chip, CS4231_TEST_INIT) & CS4231_CALIB_IN_PROGRESS) {
    396                 spin_unlock_irqrestore(&chip->reg_lock, flags);
    397                 if (time <= 0) {
     398                set_current_state(TASK_INTERRUPTIBLE);
     399                time = schedule_timeout(time);
     400                if (time > 0)
     401                        continue;
     402                time = 2;
     403                if (--timeout < 0) {
    398404                        snd_printk("mce_down - auto calibration time out (2)\n");
    399405                        return;
    400406                }
    401                 set_current_state(TASK_INTERRUPTIBLE);
    402                 time = schedule_timeout(time);
    403                 spin_lock_irqsave(&chip->reg_lock, flags);
    404407        }
    405408#if 0
    406409        printk("(3) jiffies = %li\n", jiffies);
    407410#endif
    408         time = HZ / 10;
     411        timeout = HZ / 10 / 2;
     412        time = 2;
    409413        while (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT) {
    410                 spin_unlock_irqrestore(&chip->reg_lock, flags);
    411                 if (time <= 0) {
    412                         snd_printk("mce_down - auto calibration time out (3)\n");
     414                set_current_state(TASK_INTERRUPTIBLE);         
     415                time = schedule_timeout(time);
     416                if (time > 0)
     417                        continue;
     418                time = 2;
     419                if (--timeout < 0) {
     420                        snd_printk(KERN_ERR "mce_down - auto calibration time out (3)\n");
    413421                        return;
    414422                }
    415                 set_current_state(TASK_INTERRUPTIBLE);         
    416                 time = schedule_timeout(time);
    417                 spin_lock_irqsave(&chip->reg_lock, flags);
    418         }
    419         spin_unlock_irqrestore(&chip->reg_lock, flags);
     423        }
    420424#if 0
    421425        printk("(4) jiffies = %li\n", jiffies);
     
    444448        cs4231_t *chip = snd_pcm_substream_chip(substream);
    445449        int result = 0;
     450        unsigned int what;
     451        snd_pcm_substream_t *s;
     452        int do_start;
    446453
    447454#if 0
     
    451458        switch (cmd) {
    452459        case SNDRV_PCM_TRIGGER_START:
     460        case SNDRV_PCM_TRIGGER_RESUME:
     461                do_start = 1; break;
    453462        case SNDRV_PCM_TRIGGER_STOP:
    454         {
    455                 unsigned int what = 0;
    456                 snd_pcm_substream_t *s = substream;
     463        case SNDRV_PCM_TRIGGER_SUSPEND:
     464                do_start = 0; break;
     465        default:
     466                return -EINVAL;
     467        }
     468
     469        what = 0;
     470        s = substream;
    457471                do {
    458472                        if (s == chip->playback_substream) {
     
    466480                } while (s != substream);
    467481                spin_lock(&chip->reg_lock);
    468                 if (cmd == SNDRV_PCM_TRIGGER_START) {
     482        if (do_start) {
    469483                        chip->image[CS4231_IFACE_CTRL] |= what;
    470484                        if (chip->trigger)
     
    477491                snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
    478492                spin_unlock(&chip->reg_lock);
    479                 break;
    480         }
    481         default:
    482                 result = -EINVAL;
    483                 break;
    484         }
    485493#if 0
    486494        snd_cs4231_debug(chip);
     
    576584                        snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, chip->image[CS4231_PLAYBK_FORMAT] = pdfr);
    577585                        snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1] &= ~0x10);
     586                        udelay(100); /* Fixes audible clicks at least on GUS MAX */
    578587                        full_calib = 0;
    579588                }
     
    10001009        if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE))
    10011010                return 0;
    1002         ptr = chip->p_dma_size - snd_dma_residue(chip->dma1);
     1011        ptr = snd_dma_pointer(chip->dma1, chip->p_dma_size);
    10031012        return bytes_to_frames(substream->runtime, ptr);
    10041013}
     
    10111020        if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE))
    10121021                return 0;
    1013         ptr = chip->c_dma_size - snd_dma_residue(chip->dma2);
     1022        ptr = snd_dma_pointer(chip->dma2, chip->c_dma_size);
    10141023        return bytes_to_frames(substream->runtime, ptr);
    10151024}
     
    11871196{
    11881197        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
    1189                                  SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START),
     1198                                 SNDRV_PCM_INFO_MMAP_VALID |
     1199                                 SNDRV_PCM_INFO_RESUME |
     1200                                 SNDRV_PCM_INFO_SYNC_START),
    11901201        .formats =              (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM |
    11911202                                 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE),
     
    12061217{
    12071218        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
    1208                                  SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START),
     1219                                 SNDRV_PCM_INFO_MMAP_VALID |
     1220                                 SNDRV_PCM_INFO_RESUME |
     1221                                 SNDRV_PCM_INFO_SYNC_START),
    12091222        .formats =              (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM |
    12101223                                 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE),
     
    13661379           include rescheduling.  -- iwai
    13671380           */
    1368         spin_lock_irqsave(&chip->reg_lock, flags);
    13691381        snd_cs4231_busy_wait(chip);
     1382        spin_lock_irqsave(&chip->reg_lock, flags);
    13701383        chip->mce_bit &= ~CS4231_MCE;
    13711384        timeout = cs4231_inb(chip, CS4231P(REGSEL));
    13721385        cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
     1386        spin_unlock_irqrestore(&chip->reg_lock, flags);
    13731387        if (timeout == 0x80)
    13741388                snd_printk("down [0x%lx]: serious init problem - codec still busy\n", chip->port);
    13751389        if ((timeout & CS4231_MCE) == 0 ||
    13761390            !(chip->hardware & (CS4231_HW_CS4231_MASK | CS4231_HW_CS4232_MASK))) {
    1377                 spin_unlock_irqrestore(&chip->reg_lock, flags);
    13781391                return;
    13791392        }
    13801393        snd_cs4231_busy_wait(chip);
    1381         spin_unlock_irqrestore(&chip->reg_lock, flags);
    13821394#endif
    13831395}
     
    14531465        case CS4231_HW_CS4232A: return "CS4232A";
    14541466        case CS4231_HW_CS4235:  return "CS4235";
     1467        case CS4231_HW_CS4236:  return "CS4236";
    14551468        case CS4231_HW_CS4236B: return "CS4236B";
    14561469        case CS4231_HW_CS4237B: return "CS4237B";
     
    19011914{
    19021915        snd_card_t *card;
    1903         int err, idx;
     1916        unsigned int idx;
     1917        int err;
    19041918
    19051919        snd_assert(chip != NULL && chip->pcm != NULL, return -EINVAL);
  • GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4236.c

    r212 r224  
    188188        { \
    189189                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    190                 devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _wss), \
     190                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _wss), \
    191191                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _ctrl), \
    192192                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _mpu401) } \
     
    195195        { \
    196196                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    197                 devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _wss), \
     197                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _wss), \
    198198                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _ctrl), \
    199199                         ISAPNP_DEVICE_ID('P', 'N', 'P', _mpu401) } \
     
    202202        { \
    203203                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    204                 devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _wss), \
     204                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _wss), \
    205205                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _ctrl) } \
    206206        }
     
    216216        /* HP Omnibook 5500 onboard */
    217217        ISAPNP_CS4232('C','S','C',0x4232,0x0000,0x0002,0x0003),
     218        /* Unnamed CS4236 card (Made in Taiwan) */
     219        ISAPNP_CS4232('C','S','C',0x4236,0x0000,0x0010,0x0003),
    218220        /* Turtle Beach TBS-2000 (CS4232) */
    219221        ISAPNP_CS4232('C','S','C',0x7532,0x0000,0x0010,0xb006),
     
    291293        /* CS4235 without MPU401 */
    292294        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),
    293297        /* Some noname CS4236 based card */
    294298        ISAPNP_CS4232('C','S','C',0xe936,0x0000,0x0010,0x0003),
     
    354358        irq[dev] = pdev->irq_resource[0].start;
    355359        dma1[dev] = pdev->dma_resource[0].start;
    356         dma2[dev] = pdev->dma_resource[1].start == 4 ? -1 : pdev->dma_resource[1].start;
     360        dma2[dev] = pdev->dma_resource[1].start == 4 ? -1 : (int)pdev->dma_resource[1].start;
    357361        snd_printdd("isapnp WSS: wss port=0x%lx, fm port=0x%lx, sb port=0x%lx\n",
    358362                        port[dev], fm_port[dev], sb_port[dev]);
     
    637641/* format is: snd-cs4232=enable,index,id,isapnp,port,
    638642                         cport,mpu_port,fm_port,sb_port,
    639                          irq,mpu_irq,dma1,dma1_size,
    640                          dma2,dma2_size */
     643                         irq,mpu_irq,dma1,dma2 */
    641644/* format is: snd-cs4236=enable,index,id,isapnp,port,
    642645                         cport,mpu_port,fm_port,sb_port,
    643                          irq,mpu_irq,dma1,dma1_size,
    644                          dma2,dma2_size */
     646                         irq,mpu_irq,dma1,dma2 */
    645647
    646648static int __init alsa_card_cs423x_setup(char *str)
  • GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4236_lib.c

    r210 r224  
    271271        cs4231_t *chip;
    272272        unsigned char ver1, ver2;
    273         int err, reg;
     273        unsigned int reg;
     274        int err;
    274275
    275276        *rchip = NULL;
     
    282283        if ((err = snd_cs4231_create(card, port, cport, irq, dma1, dma2, hardware, hwshare, &chip)) < 0)
    283284                return err;
     285
    284286        if (!(chip->hardware & CS4231_HW_CS4236B_MASK)) {
     287                snd_printk("CS4236+: MODE3 and extended registers not available, hardware=0x%lx\n",chip->hardware);
    285288                snd_device_free(card, chip);
    286289                return -ENODEV;
     
    909912{
    910913        snd_card_t *card;
    911         int err, idx, count;
     914        unsigned int idx, count;
     915        int err;
    912916        snd_kcontrol_new_t *kcontrol;
    913917
     
    943947                break;
    944948        default:
    945                 count = -1;
     949                count = 0;
    946950                kcontrol = NULL;
    947951        }
  • GPL/branches/alsa-resync1/alsa-kernel/isa/dt019x.c

    r212 r224  
    104104        /* DT197A30 */
    105105        {
    106 #ifdef TARGET_OS2
    107                 0, ISAPNP_CARD_ID('R','W','B',0x1688),
    108                 { ISAPNP_DEVICE_ID('@','@','@',0x1688),
    109                   ISAPNP_DEVICE_ID('@','X','@',0x0001),
    110                   ISAPNP_DEVICE_ID('@','H','@',0x0001) }
    111 #else
    112106                ISAPNP_CARD_ID('R','W','B',0x1688),
    113107                .devs = { ISAPNP_DEVICE_ID('@','@','@',0x0001),
     
    118112        {
    119113                ISAPNP_CARD_ID('A','L','S',0x0007),
    120                 devs: { ISAPNP_DEVICE_ID('@','@','@',0x0001),
     114                .devs = { ISAPNP_DEVICE_ID('@','@','@',0x0001),
    121115                        ISAPNP_DEVICE_ID('@','X','@',0x0001),
    122116                        ISAPNP_DEVICE_ID('@','H','@',0x0001) }
    123 #endif
    124117        },
    125118        { ISAPNP_CARD_END, }
     
    387380#ifndef MODULE
    388381
    389 /* format is: snd-dt019x=enable,index,id,snd_isapnp,
     382/* format is: snd-dt019x=enable,index,id,
    390383                          port,mpu_port,fm_port,
    391384                          irq,mpu_irq,dma8,dma8_size */
  • GPL/branches/alsa-resync1/alsa-kernel/isa/es1688/es1688_lib.c

    r210 r224  
    2121
    2222#include <sound/driver.h>
    23 #include <asm/io.h>
    24 #include <asm/dma.h>
    2523#include <linux/init.h>
     24#include <linux/interrupt.h>
    2625#include <linux/delay.h>
    2726#include <linux/slab.h>
     
    3029#include <sound/es1688.h>
    3130#include <sound/initval.h>
     31
     32#include <asm/io.h>
     33#include <asm/dma.h>
    3234
    3335MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
     
    345347#if 0
    346348        printk("trigger: val = 0x%x, value = 0x%x\n", val, value);
    347         printk("trigger: residue = 0x%x\n", get_dma_residue(chip->dma8));
     349        printk("trigger: pointer = 0x%x\n", snd_dma_pointer(chip->dma8, chip->dma_size));
    348350#endif
    349351        snd_es1688_write(chip, 0xb8, (val & 0xf0) | value);
     
    500502        if (chip->trigger_value != 0x05)
    501503                return 0;
    502         ptr = chip->dma_size - snd_dma_residue(chip->dma8);
     504        ptr = snd_dma_pointer(chip->dma8, chip->dma_size);
    503505        return bytes_to_frames(substream->runtime, ptr);
    504506}
     
    511513        if (chip->trigger_value != 0x0f)
    512514                return 0;
    513         ptr = chip->dma_size - snd_dma_residue(chip->dma8);
     515        ptr = snd_dma_pointer(chip->dma8, chip->dma_size);
    514516        return bytes_to_frames(substream->runtime, ptr);
    515517}
     
    10131015{
    10141016        snd_card_t *card;
    1015         int err, idx;
     1017        unsigned int idx;
     1018        int err;
    10161019        unsigned char reg, val;
    10171020
  • GPL/branches/alsa-resync1/alsa-kernel/isa/es18xx.c

    r215 r224  
    445445                shift++;
    446446
    447         switch (substream->number) {
    448         case 0:
     447        if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) {
    449448                if ((chip->caps & ES18XX_DUPLEX_MONO) &&
    450449                    (chip->capture_a_substream) &&
     
    454453                }
    455454                chip->dma2_shift = shift;
    456                 break;
    457         case 1:
     455        } else {
    458456                chip->dma1_shift = shift;
    459                 break;
    460457        }
    461458        if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
    462459                return err;
    463460        return 0;
     461}
     462
     463static int snd_es18xx_pcm_hw_free(snd_pcm_substream_t * substream)
     464{
     465        return snd_pcm_lib_free_pages(substream);
    464466}
    465467
     
    496498                                        int cmd)
    497499{
    498         if (cmd == SNDRV_PCM_TRIGGER_START) {
     500        switch (cmd) {
     501        case SNDRV_PCM_TRIGGER_START:
     502        case SNDRV_PCM_TRIGGER_RESUME:
    499503                if (chip->active & DAC2)
    500504                        return 0;
    501505                chip->active |= DAC2;
    502         } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
    503                 if (!(chip->active & DAC2))
    504                         return 0;
    505                 chip->active &= ~DAC2;
    506         } else {
    507                 return -EINVAL;
    508         }
    509 
    510         if (cmd == SNDRV_PCM_TRIGGER_START) {   
    511506                /* Start DMA */
    512507                if (chip->dma2 >= 4)
     
    524519                        snd_es18xx_dsp_command(chip, 0xD1);
    525520#endif
    526         }
    527         else {
     521                break;
     522        case SNDRV_PCM_TRIGGER_STOP:
     523        case SNDRV_PCM_TRIGGER_SUSPEND:
     524                if (!(chip->active & DAC2))
     525                        return 0;
     526                chip->active &= ~DAC2;
    528527                /* Stop DMA */
    529528                snd_es18xx_mixer_write(chip, 0x78, 0x00);
     
    537536                        snd_es18xx_dsp_command(chip, 0xD3);
    538537#endif
     538                break;
     539        default:
     540                return -EINVAL;
    539541        }
    540542
     
    609611        es18xx_t *chip = snd_pcm_substream_chip(substream);
    610612
    611         if (cmd == SNDRV_PCM_TRIGGER_START) {
     613        switch (cmd) {
     614        case SNDRV_PCM_TRIGGER_START:
     615        case SNDRV_PCM_TRIGGER_RESUME:
    612616                if (chip->active & ADC1)
    613617                        return 0;
    614618                chip->active |= ADC1;
    615         } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
     619                /* Start DMA */
     620                snd_es18xx_write(chip, 0xB8, 0x0f);
     621                break;
     622        case SNDRV_PCM_TRIGGER_STOP:
     623        case SNDRV_PCM_TRIGGER_SUSPEND:
    616624                if (!(chip->active & ADC1))
    617625                        return 0;
    618626                chip->active &= ~ADC1;
    619         } else {
    620                 return -EINVAL;
    621         }
    622 
    623         if (cmd == SNDRV_PCM_TRIGGER_START)
    624                 /* Start DMA */
    625                 snd_es18xx_write(chip, 0xB8, 0x0f);
    626         else
    627627                /* Stop DMA */
    628628                snd_es18xx_write(chip, 0xB8, 0x00);
     629                break;
     630        default:
     631                return -EINVAL;
     632        }
     633
    629634        return 0;
    630635}
     
    671676                                        int cmd)
    672677{
    673         if (cmd == SNDRV_PCM_TRIGGER_START) {
     678        switch (cmd) {
     679        case SNDRV_PCM_TRIGGER_START:
     680        case SNDRV_PCM_TRIGGER_RESUME:
    674681                if (chip->active & DAC1)
    675682                        return 0;
    676683                chip->active |= DAC1;
    677         } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
    678                 if (!(chip->active & DAC1))
    679                         return 0;
    680                 chip->active &= ~DAC1;
    681         } else {
    682                 return -EINVAL;
    683         }
    684 
    685         if (cmd == SNDRV_PCM_TRIGGER_START) {
    686684                /* Start DMA */
    687685                snd_es18xx_write(chip, 0xB8, 0x05);
     
    692690                snd_es18xx_dsp_command(chip, 0xD1);
    693691#endif
    694         }
    695         else {
     692                break;
     693        case SNDRV_PCM_TRIGGER_STOP:
     694        case SNDRV_PCM_TRIGGER_SUSPEND:
     695                if (!(chip->active & DAC1))
     696                        return 0;
     697                chip->active &= ~DAC1;
    696698                /* Stop DMA */
    697699                snd_es18xx_write(chip, 0xB8, 0x00);
     
    702704                snd_es18xx_dsp_command(chip, 0xD3);
    703705#endif
    704         }
     706                break;
     707        default:
     708        return -EINVAL;
     709        }
     710
    705711        return 0;
    706712}
     
    709715{
    710716        es18xx_t *chip = snd_pcm_substream_chip(substream);
    711         switch (substream->number) {
    712         case 0:
     717        if (substream->number == 0 && (chip->caps & ES18XX_PCM2))
    713718                return snd_es18xx_playback1_prepare(chip, substream);
    714         case 1:
     719        else
    715720                return snd_es18xx_playback2_prepare(chip, substream);
    716         }
    717         return -EINVAL;
    718721}
    719722
     
    722725{
    723726        es18xx_t *chip = snd_pcm_substream_chip(substream);
    724         switch (substream->number) {
    725         case 0:
     727        if (substream->number == 0 && (chip->caps & ES18XX_PCM2))
    726728                return snd_es18xx_playback1_trigger(chip, substream, cmd);
    727         case 1:
     729        else
    728730                return snd_es18xx_playback2_trigger(chip, substream, cmd);
    729         }
    730         return -EINVAL;
    731731}
    732732
     
    799799        int pos;
    800800
    801         switch (substream->number) {
    802         case 0:
     801        if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) {
    803802                if (!(chip->active & DAC2))
    804803                        return 0;
    805                 pos = chip->dma2_size - snd_dma_residue(chip->dma2);
     804                pos = snd_dma_pointer(chip->dma2, chip->dma2_size);
    806805                return pos >> chip->dma2_shift;
    807         case 1:
     806        } else {
    808807                if (!(chip->active & DAC1))
    809808                        return 0;
    810                 pos = chip->dma1_size - snd_dma_residue(chip->dma1);
     809                pos = snd_dma_pointer(chip->dma1, chip->dma1_size);
    811810                return pos >> chip->dma1_shift;
    812811        }
    813         return 0;
    814812}
    815813
     
    821819        if (!(chip->active & ADC1))
    822820                return 0;
    823         pos = chip->dma1_size - snd_dma_residue(chip->dma1);
     821        pos = snd_dma_pointer(chip->dma1, chip->dma1_size);
    824822        return pos >> chip->dma1_shift;
    825823}
     
    828826{
    829827        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
     828                                 SNDRV_PCM_INFO_RESUME |
    830829                                 SNDRV_PCM_INFO_MMAP_VALID),
    831830        .formats =              (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 |
     
    847846{
    848847        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
     848                                 SNDRV_PCM_INFO_RESUME |
    849849                                 SNDRV_PCM_INFO_MMAP_VALID),
    850850        .formats =              (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 |
     
    868868        es18xx_t *chip = snd_pcm_substream_chip(substream);
    869869
    870         switch (substream->number) {
    871         case 0:
     870        if (substream->number == 0 && (chip->caps & ES18XX_PCM2)) {
    872871                if ((chip->caps & ES18XX_DUPLEX_MONO) &&
    873872                    chip->capture_a_substream &&
     
    875874                        return -EAGAIN;
    876875                chip->playback_a_substream = substream;
    877                 break;
    878         case 1:
     876        } else if (substream->number <= 1) {
    879877                if (chip->capture_a_substream)
    880878                        return -EAGAIN;
    881879                chip->playback_b_substream = substream;
    882                 break;
    883         default:
     880        } else {
    884881                snd_BUG();
    885882                return -EINVAL;
     
    913910        es18xx_t *chip = snd_pcm_substream_chip(substream);
    914911
    915         switch (substream->number) {
    916         case 0:
     912        if (substream->number == 0 && (chip->caps & ES18XX_PCM2))
    917913                chip->playback_a_substream = NULL;
    918                 break;
    919         case 1:
     914        else
    920915                chip->playback_b_substream = NULL;
    921                 break;
    922         default:
    923                 snd_BUG();
    924                 return -EINVAL;
    925         }
    926916       
    927917        snd_pcm_lib_free_pages(substream);
     
    15451535        snd_printd("[0x%lx] ESS%x chip found\n", chip->port, chip->version);
    15461536
     1537        if (chip->dma1 == chip->dma2)
     1538                chip->caps &= ~(ES18XX_PCM2 | ES18XX_DUPLEX_SAME);
     1539
    15471540        return snd_es18xx_initialize(chip);
    15481541}
     
    15531546        .ioctl =        snd_pcm_lib_ioctl,
    15541547        .hw_params =    snd_es18xx_playback_hw_params,
     1548        .hw_free =      snd_es18xx_pcm_hw_free,
    15551549        .prepare =      snd_es18xx_playback_prepare,
    15561550        .trigger =      snd_es18xx_playback_trigger,
     
    15631557        .ioctl =        snd_pcm_lib_ioctl,
    15641558        .hw_params =    snd_es18xx_capture_hw_params,
     1559        .hw_free =      snd_es18xx_pcm_hw_free,
    15651560        .prepare =      snd_es18xx_capture_prepare,
    15661561        .trigger =      snd_es18xx_capture_trigger,
     
    16011596        if (chip->caps & ES18XX_DUPLEX_SAME)
    16021597                pcm->info_flags |= SNDRV_PCM_INFO_JOINT_DUPLEX;
     1598        if (! (chip->caps & ES18XX_PCM2))
     1599                pcm->info_flags |= SNDRV_PCM_INFO_HALF_DUPLEX;
    16031600        sprintf(pcm->name, "ESS AudioDrive ES%x", chip->version);
    16041601        chip->pcm = pcm;
     
    16171614        snd_card_t *card = chip->card;
    16181615
    1619         snd_power_lock(card);
    16201616        if (card->power_state == SNDRV_CTL_POWER_D3hot)
    1621                 goto __skip;
     1617                return;
    16221618
    16231619        snd_pcm_suspend_all(chip->pcm);
     
    16301626
    16311627        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
    1632       __skip:
    1633         snd_power_unlock(card);
    16341628}
    16351629
     
    16381632        snd_card_t *card = chip->card;
    16391633
    1640         snd_power_lock(card);
    16411634        if (card->power_state == SNDRV_CTL_POWER_D0)
    1642                 goto __skip;
     1635                return;
    16431636
    16441637        /* restore PM register, we won't wake till (not 0x07) i/o activity though */
     
    16461639
    16471640        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
    1648       __skip:
    1649         snd_power_unlock(card);
    16501641}
    16511642
     
    17101701                free_dma(chip->dma1);
    17111702        }
    1712         if (chip->dma2 >= 0) {
     1703        if (chip->dma2 >= 0 && chip->dma1 != chip->dma2) {
    17131704                disable_dma(chip->dma2);
    17141705                free_dma(chip->dma2);
     
    17741765        chip->dma1 = dma1;
    17751766
    1776         if (request_dma(dma2, "ES18xx DMA 2")) {
     1767        if (dma2 != dma1 && request_dma(dma2, "ES18xx DMA 2")) {
    17771768                snd_es18xx_free(chip);
    17781769                printk(KERN_ERR PFX "unable to grap DMA2 %d\n", dma2);
     
    17961787{
    17971788        snd_card_t *card;
    1798         int err, idx;
     1789        int err;
     1790        unsigned int idx;
    17991791
    18001792        card = chip->card;
     
    18021794        strcpy(card->mixername, chip->pcm->name);
    18031795
    1804         for (idx = 0; idx < sizeof(snd_es18xx_base_controls) /
    1805                      sizeof(snd_es18xx_base_controls[0]); idx++) {
     1796        for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_base_controls); idx++) {
    18061797                snd_kcontrol_t *kctl;
    18071798                kctl = snd_ctl_new1(&snd_es18xx_base_controls[idx], chip);
     
    18221813        }
    18231814        if (chip->caps & ES18XX_PCM2) {
    1824                 for (idx = 0; idx < sizeof(snd_es18xx_pcm2_controls) /
    1825                              sizeof(snd_es18xx_pcm2_controls[0]); idx++) {
     1815                for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_pcm2_controls); idx++) {
    18261816                        if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_es18xx_pcm2_controls[idx], chip))) < 0)
    18271817                                return err;
    18281818                }
    18291819        } else {
    1830                 for (idx = 0; idx < sizeof(snd_es18xx_pcm1_controls) /
    1831                              sizeof(snd_es18xx_pcm1_controls[0]); idx++) {
     1820                for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_pcm1_controls); idx++) {
    18321821                        if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_es18xx_pcm1_controls[idx], chip))) < 0)
    18331822                                return err;
     
    18401829        }
    18411830        if (chip->caps & ES18XX_RECMIX) {
    1842                 for (idx = 0; idx < sizeof(snd_es18xx_recmix_controls) /
    1843                              sizeof(snd_es18xx_recmix_controls[0]); idx++) {
     1831                for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_recmix_controls); idx++) {
    18441832                        if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_es18xx_recmix_controls[idx], chip))) < 0)
    18451833                                return err;
     
    18581846        }
    18591847        if (chip->caps & ES18XX_SPATIALIZER) {
    1860                 for (idx = 0; idx < sizeof(snd_es18xx_spatializer_controls) /
    1861                              sizeof(snd_es18xx_spatializer_controls[0]); idx++) {
     1848                for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_spatializer_controls); idx++) {
    18621849                        if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_es18xx_spatializer_controls[idx], chip))) < 0)
    18631850                                return err;
     
    18651852        }
    18661853        if (chip->caps & ES18XX_HWV) {
    1867                 for (idx = 0; idx < sizeof(snd_es18xx_hw_volume_controls) /
    1868                              sizeof(snd_es18xx_hw_volume_controls[0]); idx++) {
     1854                for (idx = 0; idx < ARRAY_SIZE(snd_es18xx_hw_volume_controls); idx++) {
    18691855                        snd_kcontrol_t *kctl;
    18701856                        kctl = snd_ctl_new1(&snd_es18xx_hw_volume_controls[idx], chip);
     
    19271913MODULE_PARM(id, "1-" __MODULE_STRING(SNDRV_CARDS) "s");
    19281914MODULE_PARM_DESC(id, "ID string for ES18xx soundcard.");
    1929 MODULE_PARM_SYNTAX(snd_id, SNDRV_ID_DESC);
     1915MODULE_PARM_SYNTAX(id, SNDRV_ID_DESC);
    19301916MODULE_PARM(enable, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
    19311917MODULE_PARM_DESC(enable, "Enable ES18xx soundcard.");
     
    19691955static const struct isapnp_card_id *snd_audiodrive_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
    19701956
    1971 #ifdef TARGET_OS2
    1972 #define ISAPNP_ES18XX(_va, _vb, _vc, _device, _audio, _control) \
    1973         { \
    1974                 0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    1975                 { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    1976                   ISAPNP_DEVICE_ID(_va, _vb, _vc, _control) } \
    1977         }
    1978 #else
    19791957#define ISAPNP_ES18XX(_va, _vb, _vc, _device, _audio, _control) \
    19801958        { \
    19811959                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    1982                 devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
     1960                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    19831961                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _control) } \
    19841962        }
    1985 #endif
    19861963
    19871964static struct isapnp_card_id snd_audiodrive_pnpids[] __devinitdata = {
     
    21982175        sprintf(card->driver, "ES%x", chip->version);
    21992176        sprintf(card->shortname, "ESS AudioDrive ES%x", chip->version);
     2177        if (xdma1 != xdma2)
    22002178        sprintf(card->longname, "%s at 0x%lx, irq %d, dma1 %d, dma2 %d",
    22012179                card->shortname,
    22022180                chip->port,
    22032181                xirq, xdma1, xdma2);
     2182        else
     2183                sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
     2184                        card->shortname,
     2185                        chip->port,
     2186                        xirq, xdma1);
    22042187        if ((err = snd_card_register(card)) < 0) {
    22052188                snd_card_free(card);
  • GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gus_mem.c

    r210 r224  
    170170                        continue;
    171171                size1 = ptr2 - ptr1;
    172                 if (size <= size1) {
     172                if ((int)size <= size1) {
    173173                        block->ptr = ptr1;
    174174                        block->size = size;
     
    197197                nblock = snd_gf1_mem_share(alloc, share_id);
    198198                if (nblock != NULL) {
    199                         if (size != nblock->size) {
     199                        if (size != (int)nblock->size) {
    200200                                /* TODO: remove in the future */
    201201                                snd_printk("snd_gf1_mem_alloc - share: sizes differ\n");
     
    265265                return -ENOMEM;
    266266#ifdef CONFIG_SND_DEBUG
    267         alloc->info_entry = NULL;
    268         entry = snd_info_create_card_entry(gus->card, "gusmem", gus->card->proc_root);
    269         if (entry) {
    270                 entry->content = SNDRV_INFO_CONTENT_TEXT;
     267        if (! snd_card_proc_new(gus->card, "gusmem", &entry)) {
     268                snd_info_set_text_ops(entry, gus, snd_gf1_mem_info_read);
    271269                entry->c.text.read_size = 256 * 1024;
    272                 entry->c.text.read = snd_gf1_mem_info_read;
    273                 entry->private_data = gus;
    274                 if (snd_info_register(entry) < 0) {
    275                         snd_info_free_entry(entry);
    276                         entry = NULL;
    277                 }
    278         }
    279         alloc->info_entry = entry;
     270        }
    280271#endif
    281272        return 0;
     
    294285                block = nblock;
    295286        }
    296 #ifdef CONFIG_SND_DEBUG
    297         if (alloc->info_entry)
    298                 snd_info_unregister(alloc->info_entry);
    299 #endif
    300287        return 0;
    301288}
  • GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gus_mixer.c

    r210 r224  
    173173{
    174174        snd_card_t *card;
    175         int idx, err, max;
     175        unsigned int idx, max;
     176        int err;
    176177
    177178        snd_assert(gus != NULL, return -EINVAL);
  • GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gus_pcm.c

    r210 r224  
    4949        snd_pcm_substream_t * substream;
    5050        spinlock_t lock;
    51         int voices;
     51        unsigned int voices;
    5252        snd_gus_voice_t *pvoices[2];
    5353        unsigned int memory;
     
    187187        snd_pcm_runtime_t * runtime;
    188188        unsigned char voice_ctrl, ramp_ctrl;
    189         int idx;
     189        unsigned int idx;
    190190        unsigned int end, step;
    191191
     
    601601{
    602602        snd_gus_card_t *gus = snd_pcm_substream_chip(substream);
    603         int pos = gus->c_period_size - snd_dma_residue(gus->gf1.dma2);
     603        int pos = snd_dma_pointer(gus->gf1.dma2, gus->c_period_size);
    604604        pos = bytes_to_frames(substream->runtime, (gus->c_pos + pos) % gus->c_dma_size);
    605605        return pos;
     
    621621{
    622622        .info =                 SNDRV_PCM_INFO_NONINTERLEAVED,
    623         formats:                (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 |
     623        .formats                = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 |
    624624                                 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE),
    625625        .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
     
    767767        snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol);
    768768        unsigned long flags;
    769         int change, idx;
     769        int change;
     770        unsigned int idx;
    770771        unsigned short val1, val2, vol;
    771772        gus_pcm_private_t *pcmp;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gus_synth.c

    r207 r224  
    1616 *   You should have received a copy of the GNU General Public License
    1717 *   along with this program; if not, write to the Free Software
    18  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    19  *
    20  */
    21 
    22 #define SNDRV_MAIN_OBJECT_FILE
     18 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
     19 *
     20 */
     21
    2322#include <sound/driver.h>
     23#include <linux/init.h>
     24#include <linux/time.h>
     25#include <sound/core.h>
    2426#include <sound/gus.h>
    2527#include <sound/seq_device.h>
     28
     29MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
     30MODULE_DESCRIPTION("Routines for Gravis UltraSound soundcards - Synthesizer");
     31MODULE_LICENSE("GPL");
    2632
    2733/*
     
    4652        snd_gus_card_t * gus = port->gus;
    4753        snd_gus_voice_t * voice;
    48         int idx;
     54        unsigned int idx;
    4955
    5056        if (info->voices > 32)
     
    128134                                       int what)
    129135{
    130         int idx;
     136        unsigned int idx;
    131137        snd_gus_card_t *gus = snd_magic_cast(snd_gus_card_t, private_data, return);
    132138        snd_gus_voice_t *pvoice;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/gus/interwave.c

    r212 r224  
    122122MODULE_PARM(joystick_dac, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
    123123MODULE_PARM_DESC(joystick_dac, "Joystick DAC level 0.59V-4.52V or 0.389V-2.98V for InterWave driver.");
    124 MODULE_PARM_SYNTAX(snd_joystic_dac, SNDRV_ENABLED ",allows:{{0,31}}");
     124MODULE_PARM_SYNTAX(joystick_dac, SNDRV_ENABLED ",allows:{{0,31}}");
    125125MODULE_PARM(midi, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
    126126MODULE_PARM_DESC(midi, "MIDI UART enable for InterWave driver.");
     
    158158static const struct isapnp_card_id *snd_interwave_isapnp_id[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
    159159
    160 #ifdef TARGET_OS2
    161 #define ISAPNP_INTERWAVE(_va, _vb, _vc, _device, _audio) \
    162         { \
    163                 0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    164                 { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio)}  \
    165         }
    166 #define ISAPNP_INTERWAVE_STB(_va, _vb, _vc, _device, _audio, _tone) \
    167         { \
    168                 0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    169                 { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    170                   ISAPNP_DEVICE_ID(_va, _vb, _vc, _tone) }\
    171         }
    172 #else
    173160#define ISAPNP_INTERWAVE(_va, _vb, _vc, _device, _audio) \
    174161        { \
    175162                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    176                 devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), } \
     163                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), } \
    177164        }
    178165#define ISAPNP_INTERWAVE_STB(_va, _vb, _vc, _device, _audio, _tone) \
    179166        { \
    180167                ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    181                 devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
     168                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    182169                         ISAPNP_DEVICE_ID(_va, _vb, _vc, _tone), } \
    183170        }
    184 #endif
    185171
    186172static struct isapnp_card_id snd_interwave_pnpids[] __devinitdata = {
     
    571557        snd_card_t *card = chip->card;
    572558        snd_ctl_elem_id_t id1, id2;
    573         int idx, err;
     559        unsigned int idx;
     560        int err;
    574561
    575562        memset(&id1, 0, sizeof(id1));
  • GPL/branches/alsa-resync1/alsa-kernel/isa/opl3sa2.c

    r212 r224  
    2121
    2222#include <sound/driver.h>
    23 #include <asm/io.h>
    2423#include <linux/init.h>
     24#include <linux/interrupt.h>
    2525#include <linux/pm.h>
    2626#include <linux/slab.h>
     
    3636#define SNDRV_GET_ID
    3737#include <sound/initval.h>
     38
     39#include <asm/io.h>
    3840
    3941MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
     
    356358}
    357359
    358 #ifdef TARGET_OS2
    359 #define OPL3SA2_SINGLE(xname, xindex, reg, shift, mask, invert) \
    360 { SNDRV_CTL_ELEM_IFACE_MIXER, 0, 0, xname, xindex, \
    361   0, 0, snd_opl3sa2_info_single, \
    362   snd_opl3sa2_get_single, snd_opl3sa2_put_single, \
    363   0, \
    364   reg | (shift << 8) | (mask << 16) | (invert << 24) }
    365 
    366 #else
    367360#define OPL3SA2_SINGLE(xname, xindex, reg, shift, mask, invert) \
    368361{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
     
    370363  .get = snd_opl3sa2_get_single, .put = snd_opl3sa2_put_single, \
    371364  .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
    372 #endif
    373365
    374366static int snd_opl3sa2_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     
    424416}
    425417
    426 #ifdef TARGET_OS2
    427 #define OPL3SA2_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
    428 { SNDRV_CTL_ELEM_IFACE_MIXER, 0, 0, xname, xindex, \
    429   0, 0, snd_opl3sa2_info_double, \
    430   snd_opl3sa2_get_double, snd_opl3sa2_put_double, \
    431   0, \
    432   left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
    433 
    434 #else
    435418#define OPL3SA2_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
    436419{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
     
    438421  .get = snd_opl3sa2_get_double, .put = snd_opl3sa2_put_double, \
    439422  .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
    440 #endif
    441423
    442424int snd_opl3sa2_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
  • GPL/branches/alsa-resync1/alsa-kernel/isa/opti9xx/opti92x-ad1848.c

    r212 r224  
    4848#include <sound/mpu401.h>
    4949#include <sound/opl3.h>
    50 #define SNDRV_LEGACY_FIND_FREE_IOPORT
    5150#define SNDRV_LEGACY_FIND_FREE_IRQ
    5251#define SNDRV_LEGACY_FIND_FREE_DMA
     
    325324
    326325
     326static long snd_legacy_find_free_ioport(long *port_table, long size)
     327{
     328        while (*port_table != -1) {
     329                if (!check_region(*port_table, size))
     330                        return *port_table;
     331                port_table++;
     332        }
     333        return -1;
     334}
     335
    327336static int __init snd_opti9xx_init(opti9xx_t *chip, unsigned short hardware)
    328337{
     
    817826}
    818827
    819 unsigned int rates[] = {  5512,  6615,  8000,  9600, 11025, 16000, 18900,
    820                          22050, 27428, 32000, 33075, 37800, 44100, 48000 };
     828static unsigned int rates[] = {  5512,  6615,  8000,  9600, 11025, 16000,
     829                                18900, 22050, 27428, 32000, 33075, 37800,
     830                                44100, 48000 };
    821831#define RATES sizeof(rates) / sizeof(rates[0])
    822832
     
    827837};
    828838
    829 unsigned char bits[] = {  0x01,  0x0f,  0x00,  0x0e,  0x03,  0x02,  0x05,
    830                           0x07,  0x04,  0x06,  0x0d,  0x09,  0x0b,  0x0c};
     839static unsigned char bits[] = {  0x01,  0x0f,  0x00,  0x0e,  0x03,  0x02,
     840                                 0x05,  0x07,  0x04,  0x06,  0x0d,  0x09,
     841                                 0x0b,  0x0c};
    831842
    832843static unsigned char snd_opti93x_get_freq(unsigned int rate)
    833844{
    834         int i;
     845        unsigned int i;
    835846
    836847        for (i = 0; i < RATES; i++) {
     
    10901101                return 0;
    10911102
    1092         ptr = chip->p_dma_size - snd_dma_residue(chip->dma1);
     1103        ptr = snd_dma_pointer(chip->dma1, chip->p_dma_size);
    10931104        return bytes_to_frames(substream->runtime, ptr);
    10941105}
     
    11021113                return 0;
    11031114
    1104         ptr = chip->c_dma_size - snd_dma_residue(chip->dma2);
     1115        ptr = snd_dma_pointer(chip->dma2, chip->c_dma_size);
    11051116        return bytes_to_frames(substream->runtime, ptr);
    11061117}
     
    16251636        snd_card_t *card;
    16261637        snd_kcontrol_new_t knew;
    1627         int err, idx;
     1638        int err;
     1639        unsigned int idx;
    16281640
    16291641        snd_assert(chip != NULL && chip->card != NULL, return -EINVAL);
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/emu8000.c

    r212 r224  
    663663                return -EINVAL;
    664664        }
    665         if (len < sizeof(rec) || copy_from_user(&rec, buf, sizeof(rec)))
     665        if (len < (long)sizeof(rec) || copy_from_user(&rec, buf, sizeof(rec)))
    666666                return -EFAULT;
    667667        chorus_parm[mode] = rec;
     
    791791                return -EINVAL;
    792792        }
    793         if (len < sizeof(rec) || copy_from_user(&rec, buf, sizeof(rec)))
     793        if (len < (long)sizeof(rec) || copy_from_user(&rec, buf, sizeof(rec)))
    794794                return -EFAULT;
    795795        reverb_parm[mode] = rec;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/emu8000_pcm.c

    r215 r224  
    216216
    217217        /* update period */
    218         if (rec->period_pos >= rec->period_size) {
     218        if (rec->period_pos >= (int)rec->period_size) {
    219219                rec->period_pos %= rec->period_size;
    220220                spin_unlock(&rec->timer_lock);
     
    593593        rec->offset = EMU8000_DRAM_OFFSET + (rec->block->offset >> 1); /* in word */
    594594        /* at least dma_bytes must be set for non-interleaved mode */
    595         subs->dma_bytes = params_buffer_bytes(hw_params);
     595        subs->dma_buffer.bytes = params_buffer_bytes(hw_params);
    596596
    597597        return 0;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/es968.c

    r212 r224  
    278278
    279279/* format is: snd-es968=enable,index,id,
    280                         port,irq,snd_dma1 */
     280                        port,irq,dma1 */
    281281
    282282static int __init alsa_card_es968_setup(char *str)
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb16.c

    r212 r224  
    200200    { \
    201201    ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    202     devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), } \
     202                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), } \
    203203    }
    204204#define ISAPNP_SBAWE(_va, _vb, _vc, _device, _audio, _awe) \
    205205    { \
    206206    ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
    207     devs : { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
     207                .devs = { ISAPNP_DEVICE_ID(_va, _vb, _vc, _audio), \
    208208    ISAPNP_DEVICE_ID(_va, _vb, _vc, _awe), } \
    209209    }
     
    214214    /* Sound Blaster 16 PnP */
    215215    ISAPNP_SB16('C','T','L',0x0024,0x0031),
     216        /* Sound Blaster 16 PnP */
     217        ISAPNP_SB16('C','T','L',0x0025,0x0031),
    216218    /* Sound Blaster 16 PnP */
    217219    ISAPNP_SB16('C','T','L',0x0026,0x0031),
     
    235237    /* Sound Blaster Vibra16CL - added by ctm@ardi.com */
    236238    ISAPNP_SB16('C','T','L',0x0080,0x0041),
     239        /* Sound Blaster 16 'value' PnP. It says model ct4130 on the pcb, */
     240        /* but ct4131 on a sticker on the board.. */
     241        ISAPNP_SB16('C','T','L',0x0086,0x0041),
    237242    /* Sound Blaster Vibra16X */
    238243    ISAPNP_SB16('C','T','L',0x00f0,0x0043),
     
    664669                printk(KERN_ERR "Sound Blaster 16 soundcard not found or device busy\n");
    665670#ifdef SNDRV_SBAWE_EMU8000
    666                 printk(KERN_ERR "In case, if you have non-AWE card, try snd-card-sb16 module\n");
    667 #else
    668                 printk(KERN_ERR "In case, if you have AWE card, try snd-card-sbawe module\n");
     671                printk(KERN_ERR "In case, if you have non-AWE card, try snd-sb16 module\n");
     672#else
     673                printk(KERN_ERR "In case, if you have AWE card, try snd-sbawe module\n");
    669674#endif
    670675#endif
     
    697702        static unsigned __initdata nr_dev = 0;
    698703        int __attribute__ ((__unused__)) pnp = INT_MAX;
    699         int __attribute__ ((__unused__)) csp = INT_MAX;
     704        int __attribute__ ((__unused__)) xcsp = INT_MAX;
    700705
    701706        if (nr_dev >= SNDRV_CARDS)
     
    714719#ifdef CONFIG_SND_SB16_CSP
    715720               &&
    716                get_option(&str,&csp[nr_dev]) == 2
     721               get_option(&str,&xcsp) == 2
    717722#endif
    718723#ifdef SNDRV_SBAWE_EMU8000
     
    727732#endif
    728733#ifdef CONFIG_SND_SB16_CSP
    729         if (csp != INT_MAX)
    730                 csp[nr_dev] = csp;
     734        if (xcsp != INT_MAX)
     735                csp[nr_dev] = xcsp;
    731736#endif
    732737        nr_dev++;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb16_csp.c

    r210 r224  
    4343#else
    4444#define CSP_HDR_VALUE(a,b,c,d)  ((d) | ((c)<<8) | ((b)<<16) | ((a)<<24))
    45 #define LE_SHORT(v)             bswap_16(v)
    46 #define LE_INT(v)               bswap_32(v)
    4745#endif
    4846#define LE_SHORT(v)             le16_to_cpu(v)
     
    108106
    109107static int init_proc_entry(snd_sb_csp_t * p, int device);
    110 static void delete_proc_entry(snd_sb_csp_t * p);
    111108static void info_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer);
    112109
     
    171168        if (p->running & SNDRV_SB_CSP_ST_RUNNING)
    172169            snd_sb_csp_stop(p);
    173         delete_proc_entry(p);
    174170        kfree(p);
    175171    }
     
    216212        info.version = p->version;
    217213        info.state = p->running;
    218         err = copy_to_user((void *) arg, &info, sizeof(info));
     214                if (copy_to_user((void *) arg, &info, sizeof(info)))
     215                        err = -EFAULT;
     216                else
     217                        err = 0;
    219218        break;
    220219
     
    10091008    return change;
    10101009}
    1011 #ifdef TARGET_OS2
     1010
    10121011static snd_kcontrol_new_t snd_sb_qsound_switch = {
    10131012        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     
    11051104    snd_info_entry_t *entry;
    11061105    sprintf(name, "cspD%d", device);
    1107     entry = p->proc = snd_info_create_card_entry(p->chip->card, name, p->chip->card->proc_root);
    1108     if (entry) {
    1109         entry->content = SNDRV_INFO_CONTENT_TEXT;
    1110         entry->c.text.read_size = 256;
    1111         entry->c.text.read = info_read;
    1112         entry->private_data = p;
    1113         if (snd_info_register(entry) < 0) {
    1114             snd_info_free_entry(entry);
    1115             p->proc = NULL;
    1116         }
    1117     }
    1118     return 0;
    1119 }
    1120 
    1121 static void delete_proc_entry(snd_sb_csp_t * p)
    1122 {
    1123     if (p->proc) {
    1124         snd_info_unregister(p->proc);
    1125         p->proc = NULL;
    1126     }
     1106        if (! snd_card_proc_new(p->chip->card, name, &entry))
     1107                snd_info_set_text_ops(entry, p, info_read);
     1108        return 0;
    11271109}
    11281110
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb16_main.c

    r212 r224  
    1010 *  Note: 16-bit wide is assigned to first direction which made request.
    1111 *        With full duplex - playback is preferred with abstract layer.
     12 *
     13 *  Note: Some chip revisions have hardware bug. Changing capture
     14 *        channel from full-duplex 8bit DMA to 16bit DMA will block
     15 *        16bit DMA transfers from DSP chip (capture) until 8bit transfer
     16 *        to DSP chip (playback) starts. This bug can be avoided with
     17 *        "16bit DMA Allocation" setting set to Playback or Capture.
    1218 *
    1319 *
     
    5561            /* manually loaded codec */
    5662            if ((csp->mode & SNDRV_SB_CSP_MODE_DSP_WRITE) &&
    57                 ((1 << runtime->format) == csp->acc_format)) {
     63                            ((1U << runtime->format) == csp->acc_format)) {
    5864                /* Supported runtime PCM format for playback */
    5965                if (csp->ops.csp_use(csp) == 0) {
     
    103109            /* manually loaded codec */
    104110            if ((csp->mode & SNDRV_SB_CSP_MODE_DSP_READ) &&
    105                 ((1 << runtime->format) == csp->acc_format)) {
     111                            ((1U << runtime->format) == csp->acc_format)) {
    106112                /* Supported runtime PCM format for capture */
    107113                if (csp->ops.csp_use(csp) == 0) {
     
    446452
    447453    dma = (chip->mode & SB_MODE_PLAYBACK_8) ? chip->dma8 : chip->dma16;
    448     ptr = chip->p_dma_size - snd_dma_residue(dma);
     454        ptr = snd_dma_pointer(dma, chip->p_dma_size);
    449455    return bytes_to_frames(substream->runtime, ptr);
    450456}
     
    457463
    458464    dma = (chip->mode & SB_MODE_CAPTURE_8) ? chip->dma8 : chip->dma16;
    459     ptr = chip->c_dma_size - snd_dma_residue(dma);
     465        ptr = snd_dma_pointer(dma, chip->c_dma_size);
    460466    return bytes_to_frames(substream->runtime, ptr);
    461467}
     
    465471*/
    466472
    467 #ifdef TARGET_OS2
    468473static snd_pcm_hardware_t snd_sb16_playback =
    469474{
     
    883888}
    884889
     890const snd_pcm_ops_t *snd_sb16dsp_get_pcm_ops(int direction)
     891{
     892        return direction == SNDRV_PCM_STREAM_PLAYBACK ?
     893                &snd_sb16_playback_ops : &snd_sb16_capture_ops;
     894}
     895
    885896EXPORT_SYMBOL(snd_sb16dsp_pcm);
     897EXPORT_SYMBOL(snd_sb16dsp_get_pcm_ops);
    886898EXPORT_SYMBOL(snd_sb16dsp_configure);
    887899EXPORT_SYMBOL(snd_sb16dsp_interrupt);
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb8.c

    r212 r224  
    124124        snd_card_free(card);
    125125        if (chip->hardware == SB_HW_ALS100)
    126             snd_printdd("ALS100 chip detected at 0x%lx, try snd-card-als100 module\n",
     126                        snd_printdd("ALS100 chip detected at 0x%lx, try snd-als100 module\n",
    127127                                    port[dev]);
    128128        else
    129             snd_printdd("SB 16 chip detected at 0x%lx, try snd-card-sb16 module\n",
     129                        snd_printdd("SB 16 chip detected at 0x%lx, try snd-sb16 module\n",
    130130                                    port[dev]);
    131131        return -ENODEV;
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/sb8_main.c

    r210 r224  
    9898    snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
    9999    if (r->min > SB8_RATE(22050) || r->max <= SB8_RATE(11025)) {
    100 #ifdef TARGET_OS2
    101         snd_interval_t t = { 1, 1 };
    102 #else
    103         snd_interval_t t = { min: 1, max: 1 };
    104 #endif
     100                snd_interval_t t = { .min = 1, .max = 1 };
    105101        return snd_interval_refine(hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS), &t);
    106102    }
     
    370366    if (chip->mode != SB_MODE_PLAYBACK_8)
    371367        return 0;
    372     ptr = chip->p_dma_size - snd_dma_residue(chip->dma8);
     368        ptr = snd_dma_pointer(chip->dma8, chip->p_dma_size);
    373369    return bytes_to_frames(substream->runtime, ptr);
    374370}
     
    381377    if (chip->mode != SB_MODE_CAPTURE_8)
    382378        return 0;
    383     ptr = chip->c_dma_size - snd_dma_residue(chip->dma8);
     379        ptr = snd_dma_pointer(chip->dma8, chip->c_dma_size);
    384380    return bytes_to_frames(substream->runtime, ptr);
    385381}
  • GPL/branches/alsa-resync1/alsa-kernel/isa/sgalaxy.c

    r212 r224  
    3131#include <sound/sb.h>
    3232#include <sound/ad1848.h>
     33#include <sound/control.h>
    3334#define SNDRV_LEGACY_FIND_FREE_IRQ
    3435#define SNDRV_LEGACY_FIND_FREE_DMA
     
    4445static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
    4546static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
    46 static int snd_enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;      /* Enable this card */
     47static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;  /* Enable this card */
    4748static long sbport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;   /* 0x220,0x240 */
    4849static long wssport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;  /* 0x530,0xe80,0xf40,0x604 */
     
    177178}
    178179
    179 #define SGALAXY_CONTROLS 2
    180 
    181 static snd_kcontrol_new_t snd_sgalaxy_controls[2] = {
     180static struct ad1848_mix_elem snd_sgalaxy_controls[] = {
    182181AD1848_DOUBLE("Aux Playback Switch", 0, SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 7, 7, 1, 1),
    183182AD1848_DOUBLE("Aux Playback Volume", 0, SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 0, 0, 31, 0)
     
    188187        snd_card_t *card = chip->card;
    189188        snd_ctl_elem_id_t id1, id2;
    190         int idx, err;
     189        unsigned int idx;
     190        int err;
    191191
    192192        memset(&id1, 0, sizeof(id1));
     
    212212                return err;
    213213        /* build AUX2 input */
    214         for (idx = 0; idx < SGALAXY_CONTROLS; idx++) {
    215                 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_sgalaxy_controls[idx], chip))) < 0)
     214        for (idx = 0; idx < ARRAY_SIZE(snd_sgalaxy_controls); idx++) {
     215                if ((err = snd_ad1848_add_ctl_elem(chip, &snd_sgalaxy_controls[idx])) < 0)
    216216                        return err;
    217217        }
     
    301301        int dev, cards;
    302302
    303         for (dev = cards = 0; dev < SNDRV_CARDS && snd_enable[dev]; dev++) {
     303        for (dev = cards = 0; dev < SNDRV_CARDS && enable[dev]; dev++) {
    304304                if (snd_sgalaxy_probe(dev) >= 0)
    305305                        cards++;
     
    328328#ifndef MODULE
    329329
    330 /* format is: snd-sgalaxy=snd_enable,index,id,
     330/* format is: snd-sgalaxy=enable,index,id,
    331331                          sbport,wssport,
    332332                          irq,dma1 */
     
    338338        if (nr_dev >= SNDRV_CARDS)
    339339                return 0;
    340         (void)(get_option(&str,&snd_enable[nr_dev]) == 2 &&
     340        (void)(get_option(&str,&enable[nr_dev]) == 2 &&
    341341               get_option(&str,&index[nr_dev]) == 2 &&
    342342               get_id(&str,&id[nr_dev]) == 2 &&
  • GPL/branches/alsa-resync1/alsa-kernel/isa/wavefront/wavefront_fx.c

    r210 r224  
    3434#define FX_AUTO_INCR    0x04    /* auto-increment DSP address after transfer */
    3535
    36 static inline void
    37 dec_mod_count(struct module *module)
    38 {
    39         if (module)
    40                 __MOD_DEC_USE_COUNT(module);
    41 }
    42 
    4336static int
    4437wavefront_fx_idle (snd_wavefront_t *dev)
     
    152145
    153146{
    154         MOD_INC_USE_COUNT;
    155         if (!try_inc_mod_count(hw->card->module)) {
    156                 MOD_DEC_USE_COUNT;
     147        if (!try_module_get(hw->card->module))
    157148                return -EFAULT;
    158         }
    159149        file->private_data = hw;
    160150        return 0;
     
    165155
    166156{
    167         dec_mod_count(hw->card->module);
    168         MOD_DEC_USE_COUNT;
     157        module_put(hw->card->module);
    169158        return 0;
    170159}
     
    207196                        pd = (unsigned short *) &r.data[3];
    208197                } else {
    209                         if (r.data[2] > sizeof (page_data)) {
     198                        if (r.data[2] > (long)sizeof (page_data)) {
    210199                                snd_printk ("cannot write "
    211200                                            "> 255 bytes to FX\n");
  • GPL/branches/alsa-resync1/alsa-kernel/isa/wavefront/wavefront_synth.c

    r212 r224  
    234234};
    235235
    236 static inline void
    237 dec_mod_count(struct module *module)
    238 {
    239         if (module)
    240                 __MOD_DEC_USE_COUNT(module);
    241 }
    242 
    243236static const char *
    244237wavefront_errorstr (int errnum)
     
    887880        u16 *data_end = 0;
    888881        unsigned int i;
    889         const int max_blksize = 4096/2;
     882        const unsigned int max_blksize = 4096/2;
    890883        unsigned int written;
    891884        unsigned int blocksize;
     
    954947                dev->freemem = wavefront_freemem (dev);
    955948
    956                 if (dev->freemem < header->size) {
     949                if (dev->freemem < (int)header->size) {
    957950                        snd_printk ("insufficient memory to "
    958951                                    "load %d byte sample.\n",
     
    16141607
    16151608{
    1616         MOD_INC_USE_COUNT;
    1617         if (!try_inc_mod_count(hw->card->module)) {
    1618                 MOD_DEC_USE_COUNT;
     1609        if (!try_module_get(hw->card->module))
    16191610                return -EFAULT;
    1620         }
    16211611        file->private_data = hw;
    16221612        return 0;
     
    16271617
    16281618{
    1629         dec_mod_count(hw->card->module);
    1630         MOD_DEC_USE_COUNT;
     1619        module_put(hw->card->module);
    16311620        return 0;
    16321621}
  • GPL/branches/alsa-resync1/alsa-kernel/pci/emu10k1/emuproc.c

    r210 r224  
    478478
    479479
    480 #ifdef TARGET_OS2
    481480static struct snd_info_entry_ops snd_emu10k1_proc_ops_fx8010 = {
    482     0, 0, snd_emu10k1_fx8010_read, 0, 0,0,0,0
     481        .read = snd_emu10k1_fx8010_read,
    483482};
    484 #else
    485 static struct snd_info_entry_ops snd_emu10k1_proc_ops_fx8010 = {
    486 read: snd_emu10k1_fx8010_read,
    487 };
    488 #endif
     483
    489484int __devinit snd_emu10k1_proc_init(struct snd_emu10k1 * emu)
    490485{
  • GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ak4524.c

    r215 r224  
    22 *   ALSA driver for ICEnsemble ICE1712 (Envy24)
    33 *
    4  *   AK4524 / AK4528 / AK4529 interface
     4 *   AK4524 / AK4528 / AK4529 / AK4355 / AK4381 interface
    55 *
    66 *      Copyright (c) 2000 Jaroslav Kysela <perex@suse.cz>
     
    3232
    3333/*
    34  * write AK4524 register
     34 * write AK4xxx register
    3535 */
    36 void snd_ice1712_ak4524_write(ice1712_t *ice, int chip,
    37                                      unsigned char addr, unsigned char data)
    38 {
    39         unsigned char tmp, saved[2];
     36void snd_ice1712_akm4xxx_write(akm4xxx_t *ak, int chip,
     37                              unsigned char addr, unsigned char data)
     38{
     39        unsigned int tmp;
    4040        int idx;
    4141        unsigned int addrdata;
    42         ak4524_t *ak = &ice->ak4524;
     42        ice1712_t *ice = ak->chip;
    4343
    4444        snd_assert(chip >= 0 && chip < 4, return);
    4545
    4646        if (ak->ops.start) {
    47                 if (ak->ops.start(ice, saved, chip) < 0)
     47                if (ak->ops.start(ak, chip) < 0)
    4848                        return;
    4949        } else
    50                 snd_ice1712_save_gpio_status(ice, saved);
    51 
    52         tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
     50                snd_ice1712_save_gpio_status(ice);
     51
     52        tmp = snd_ice1712_gpio_read(ice);
    5353        tmp |= ak->add_flags;
    5454        tmp &= ~ak->mask_flags;
     
    5656                if (ak->cif) {
    5757                        tmp |= ak->cs_mask; /* start without chip select */
     58                }  else {
     59                        tmp &= ~ak->cs_mask; /* chip select low */
     60                        snd_ice1712_gpio_write(ice, tmp);
     61                        udelay(1);
     62                }
    5863        } else {
    59                         tmp &= ~ak->cs_mask; /* chip select low */
    60                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
    61                 udelay(1);
    62                 }
    63         } else {
     64                /* doesn't handle cf=1 yet */
    6465                tmp &= ~ak->cs_mask;
    6566                tmp |= ak->cs_addr;
    66         }
    67 
    68         addr &= 0x07;
     67                snd_ice1712_gpio_write(ice, tmp);
     68                udelay(1);
     69        }
     70
    6971        /* build I2C address + data byte */
    70         /* assume C1=1, C0=0 */
    71         addrdata = 0xa000 | (addr << 8) | data;
     72        addrdata = (ak->caddr << 6) | 0x20 | (addr & 0x1f);
     73        addrdata = (addrdata << 8) | data;
    7274        for (idx = 15; idx >= 0; idx--) {
    73                 tmp &= ~(ak->data_mask | ak->clk_mask);
     75                /* drop clock */
     76                tmp &= ~ak->clk_mask;
     77                snd_ice1712_gpio_write(ice, tmp);
     78                udelay(1);
     79                /* set data */
    7480                if (addrdata & (1 << idx))
    7581                        tmp |= ak->data_mask;
    76                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
    77                 //udelay(200);
     82                else
     83                        tmp &= ~ak->data_mask;
     84                snd_ice1712_gpio_write(ice, tmp);
    7885                udelay(1);
     86                /* raise clock */
    7987                tmp |= ak->clk_mask;
    80                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
     88                snd_ice1712_gpio_write(ice, tmp);
    8189                udelay(1);
    8290        }
    8391
    84         if (ak->type == SND_AK4524) {
    85         if ((addr != 0x04 && addr != 0x05) || (data & 0x80) == 0)
     92        /* save the data */
     93        if (ak->type == SND_AK4524 || ak->type == SND_AK4528) {
     94                if ((addr != 0x04 && addr != 0x05) || (data & 0x80) == 0)
     95                        ak->images[chip][addr] = data;
     96                else
     97                        ak->ipga_gain[chip][addr-4] = data;
     98        } else {
     99                /* AK4529, or else */
    86100                ak->images[chip][addr] = data;
    87         else
    88                 ak->ipga_gain[chip][addr-4] = data;
    89         }
    90 
     101        }
     102       
    91103        if (ak->cs_mask == ak->cs_addr) {
    92104                if (ak->cif) {
    93105                        /* assert a cs pulse to trigger */
    94106                        tmp &= ~ak->cs_mask;
    95                         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
     107                        snd_ice1712_gpio_write(ice, tmp);
    96108                        udelay(1);
    97109                }
     
    101113                tmp |= ak->cs_none; /* deselect address */
    102114        }
    103                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
    104                 udelay(1);
     115        snd_ice1712_gpio_write(ice, tmp);
     116        udelay(1);
    105117
    106118        if (ak->ops.stop)
    107                 ak->ops.stop(ice, saved);
     119                ak->ops.stop(ak);
    108120        else
    109                 snd_ice1712_restore_gpio_status(ice, saved);
    110 }
    111 
    112 void snd_ice1712_ak4524_reset(ice1712_t *ice, int state)
    113 {
    114         int chip;
     121                snd_ice1712_restore_gpio_status(ice);
     122}
     123
     124/*
     125 * reset the AKM codecs
     126 * @state: 1 = reset codec, 0 = restore the registers
     127 *
     128 * assert the reset operation and restores the register values to the chips.
     129 */
     130void snd_ice1712_akm4xxx_reset(akm4xxx_t *ak, int state)
     131{
     132        unsigned int chip;
    115133        unsigned char reg;
    116         ak4524_t *ak = &ice->ak4524;
    117134       
    118135        switch (ak->type) {
    119136        case SND_AK4524:
    120137        case SND_AK4528:
    121         for (chip = 0; chip < ak->num_dacs/2; chip++) {
    122                 snd_ice1712_ak4524_write(ice, chip, 0x01, state ? 0x00 : 0x03);
    123                 if (state)
    124                         continue;
     138                for (chip = 0; chip < ak->num_dacs/2; chip++) {
     139                        snd_ice1712_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03);
     140                        if (state)
     141                                continue;
    125142                        /* DAC volumes */
    126143                        for (reg = 0x04; reg < (ak->type == SND_AK4528 ? 0x06 : 0x08); reg++)
    127                         snd_ice1712_ak4524_write(ice, chip, reg, ak->images[chip][reg]);
     144                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->images[chip][reg]);
    128145                        if (ak->type == SND_AK4528)
    129                         continue;
     146                                continue;
    130147                        /* IPGA */
    131                 for (reg = 0x04; reg < 0x06; reg++)
    132                         snd_ice1712_ak4524_write(ice, chip, reg, ak->ipga_gain[chip][reg-4]);
     148                        for (reg = 0x04; reg < 0x06; reg++)
     149                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->ipga_gain[chip][reg-4]);
    133150                }
    134151                break;
     
    136153                /* FIXME: needed for ak4529? */
    137154                break;
     155        case SND_AK4355:
     156                snd_ice1712_akm4xxx_write(ak, 0, 0x01, state ? 0x02 : 0x01);
     157                if (state)
     158                        return;
     159                for (reg = 0x00; reg < 0x0a; reg++)
     160                        if (reg != 0x01)
     161                                snd_ice1712_akm4xxx_write(ak, 0, reg, ak->images[0][reg]);
     162                break;
     163        case SND_AK4381:
     164                for (chip = 0; chip < ak->num_dacs/2; chip++) {
     165                        snd_ice1712_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f);
     166                        if (state)
     167                                continue;
     168                        for (reg = 0x01; reg < 0x05; reg++)
     169                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->images[chip][reg]);
     170                }
     171                break;
    138172        }
    139173}
    140174
    141175/*
    142  * initialize all the ak4524/4528 chips
     176 * initialize all the ak4xxx chips
    143177 */
    144 void __devinit snd_ice1712_ak4524_init(ice1712_t *ice)
     178static void __devinit snd_ice1712_akm4xxx_init_chip(akm4xxx_t *ak)
    145179{
    146180        static unsigned char inits_ak4524[] = {
     
    171205                0x09, 0x01, /* 9: ATS=0, RSTN=1 */
    172206                0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
    173                 0x00, 0x08, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
     207                0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
    174208                0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
    175209                0x02, 0xff, /* 2: LOUT1 muted */
     
    184218                0xff, 0xff
    185219        };
     220        static unsigned char inits_ak4355[] = {
     221                0x01, 0x02, /* 1: reset and soft-mute */
     222                0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect, disable DZF, sharp roll-off, RSTN#=0 */
     223                // 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */
     224                0x02, 0x2e,
     225                0x03, 0x01, /* 3: de-emphasis off */
     226                0x04, 0x00, /* 4: LOUT1 volume muted */
     227                0x05, 0x00, /* 5: ROUT1 volume muted */
     228                0x06, 0x00, /* 6: LOUT2 volume muted */
     229                0x07, 0x00, /* 7: ROUT2 volume muted */
     230                0x08, 0x00, /* 8: LOUT3 volume muted */
     231                0x09, 0x00, /* 9: ROUT3 volume muted */
     232                0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
     233                0x01, 0x01, /* 1: un-reset, unmute */
     234                0xff, 0xff
     235        };
     236        static unsigned char inits_ak4381[] = {
     237                0x00, 0x0c, /* 0: mode3(i2s), disable auto-clock detect */
     238                // 0x01, 0x02, /* 1: de-emphasis off, normal speed, sharp roll-off, DZF off */
     239                0x01, 0x12,
     240                0x02, 0x00, /* 2: DZF disabled */
     241                0x03, 0x00, /* 3: LATT 0 */
     242                0x04, 0x00, /* 4: RATT 0 */
     243                0x00, 0x0f, /* 0: power-up, un-reset */
     244                0xff, 0xff
     245        };
     246
    186247        int chip, num_chips;
    187248        unsigned char *ptr, reg, data, *inits;
    188         ak4524_t *ak = &ice->ak4524;
    189249
    190250        switch (ak->type) {
     
    198258                break;
    199259        case SND_AK4529:
    200         default:
    201260                inits = inits_ak4529;
    202261                num_chips = 1;
    203262                break;
     263        case SND_AK4355:
     264                inits = inits_ak4355;
     265                num_chips = 1;
     266                break;
     267        case SND_AK4381:
     268                inits = inits_ak4381;
     269                num_chips = ak->num_dacs / 2;
     270                break;
     271        default:
     272                snd_BUG();
     273                return;
    204274        }
    205275
     
    209279                        reg = *ptr++;
    210280                        data = *ptr++;
    211                         snd_ice1712_ak4524_write(ice, chip, reg, data);
    212                 }
    213         }
     281                        snd_ice1712_akm4xxx_write(ak, chip, reg, data);
     282                }
     283        }
     284}
     285
     286
     287/*
     288 * initialize the akm4xxx_t record with the template
     289 */
     290void snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *temp, ice1712_t *ice)
     291{
     292        *ak = *temp;
     293        ak->chip = ice;
     294        snd_ice1712_akm4xxx_init_chip(ak);
    214295}
    215296
     
    217298#define AK_GET_CHIP(val)                (((val) >> 8) & 0xff)
    218299#define AK_GET_ADDR(val)                ((val) & 0xff)
    219 #define AK_GET_SHIFT(val)               (((val) >> 16) & 0xff)
    220 #define AK_COMPOSE(chip,addr,shift)     (((chip) << 8) | (addr) | ((shift) << 16))
    221 
    222 static int snd_ice1712_ak4524_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    223 {
     300#define AK_GET_SHIFT(val)               (((val) >> 16) & 0x7f)
     301#define AK_GET_INVERT(val)              (((val) >> 23) & 1)
     302#define AK_GET_MASK(val)                (((val) >> 24) & 0xff)
     303#define AK_COMPOSE(chip,addr,shift,mask) (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24))
     304#define AK_INVERT                       (1<<23)
     305
     306static int snd_ice1712_akm4xxx_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     307{
     308        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
     309
    224310        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
    225311        uinfo->count = 1;
    226312        uinfo->value.integer.min = 0;
    227         uinfo->value.integer.max = 127;
    228         return 0;
    229 }
    230 
    231 static int snd_ice1712_ak4524_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
    232 {
    233         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
     313        uinfo->value.integer.max = mask;
     314        return 0;
     315}
     316
     317static int snd_ice1712_akm4xxx_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
     318{
     319        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
    234320        int chip = AK_GET_CHIP(kcontrol->private_value);
    235321        int addr = AK_GET_ADDR(kcontrol->private_value);
    236         ucontrol->value.integer.value[0] = ice->ak4524.images[chip][addr];
    237         return 0;
    238 }
    239 
    240 static int snd_ice1712_ak4524_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
    241 {
    242         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
     322        int invert = AK_GET_INVERT(kcontrol->private_value);
     323        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
     324        unsigned char val = ak->images[chip][addr];
     325       
     326        ucontrol->value.integer.value[0] = invert ? mask - val : val;
     327        return 0;
     328}
     329
     330static int snd_ice1712_akm4xxx_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
     331{
     332        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
    243333        int chip = AK_GET_CHIP(kcontrol->private_value);
    244334        int addr = AK_GET_ADDR(kcontrol->private_value);
    245         unsigned char nval = ucontrol->value.integer.value[0];
    246         int change = ice->ak4524.images[chip][addr] != nval;
     335        int invert = AK_GET_INVERT(kcontrol->private_value);
     336        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
     337        unsigned char nval = ucontrol->value.integer.value[0] % (mask+1);
     338        int change;
     339
     340        if (invert)
     341                nval = mask - nval;
     342        change = ak->images[chip][addr] != nval;
    247343        if (change)
    248                 snd_ice1712_ak4524_write(ice, chip, addr, nval);
     344                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
    249345        return change;
    250346}
    251347
    252 static int snd_ice1712_ak4524_ipga_gain_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     348static int snd_ice1712_akm4xxx_ipga_gain_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    253349{
    254350        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
     
    259355}
    260356
    261 static int snd_ice1712_ak4524_ipga_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
    262 {
    263         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
     357static int snd_ice1712_akm4xxx_ipga_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
     358{
     359        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
    264360        int chip = AK_GET_CHIP(kcontrol->private_value);
    265361        int addr = AK_GET_ADDR(kcontrol->private_value);
    266         ucontrol->value.integer.value[0] = ice->ak4524.ipga_gain[chip][addr-4] & 0x7f;
    267         return 0;
    268 }
    269 
    270 static int snd_ice1712_ak4524_ipga_gain_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
    271 {
    272         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
     362        ucontrol->value.integer.value[0] = ak->ipga_gain[chip][addr-4] & 0x7f;
     363        return 0;
     364}
     365
     366static int snd_ice1712_akm4xxx_ipga_gain_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
     367{
     368        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
    273369        int chip = AK_GET_CHIP(kcontrol->private_value);
    274370        int addr = AK_GET_ADDR(kcontrol->private_value);
    275371        unsigned char nval = (ucontrol->value.integer.value[0] % 37) | 0x80;
    276         int change = ice->ak4524.ipga_gain[chip][addr] != nval;
     372        int change = ak->ipga_gain[chip][addr] != nval;
    277373        if (change)
    278                 snd_ice1712_ak4524_write(ice, chip, addr, nval);
     374                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
    279375        return change;
    280376}
    281377
    282 static int snd_ice1712_ak4524_deemphasis_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
     378static int snd_ice1712_akm4xxx_deemphasis_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
    283379{
    284380        static char *texts[4] = {
     
    294390}
    295391
    296 static int snd_ice1712_ak4524_deemphasis_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol)
    297 {
    298         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
     392static int snd_ice1712_akm4xxx_deemphasis_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol)
     393{
     394        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
    299395        int chip = AK_GET_CHIP(kcontrol->private_value);
    300396        int addr = AK_GET_ADDR(kcontrol->private_value);
    301397        int shift = AK_GET_SHIFT(kcontrol->private_value);
    302         ucontrol->value.enumerated.item[0] = (ice->ak4524.images[chip][addr] >> shift) & 3;
    303         return 0;
    304 }
    305 
    306 static int snd_ice1712_ak4524_deemphasis_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
    307 {
    308         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
     398        ucontrol->value.enumerated.item[0] = (ak->images[chip][addr] >> shift) & 3;
     399        return 0;
     400}
     401
     402static int snd_ice1712_akm4xxx_deemphasis_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
     403{
     404        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
    309405        int chip = AK_GET_CHIP(kcontrol->private_value);
    310406        int addr = AK_GET_ADDR(kcontrol->private_value);
     
    313409        int change;
    314410       
    315         nval = (nval << shift) | (ice->ak4524.images[chip][addr] & ~(3 << shift));
    316         change = ice->ak4524.images[chip][addr] != nval;
     411        nval = (nval << shift) | (ak->images[chip][addr] & ~(3 << shift));
     412        change = ak->images[chip][addr] != nval;
    317413        if (change)
    318                 snd_ice1712_ak4524_write(ice, chip, addr, nval);
     414                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
    319415        return change;
    320416}
     
    324420 */
    325421
    326 int __devinit snd_ice1712_ak4524_build_controls(ice1712_t *ice)
    327 {
    328         int err, idx;
    329         ak4524_t *ak = &ice->ak4524;
    330 
    331         for (idx = 0; idx < ak->num_dacs; ++idx) {
     422int __devinit snd_ice1712_akm4xxx_build_controls(ice1712_t *ice)
     423{
     424        unsigned int idx;
     425        int err;
     426        unsigned int akidx;
     427
     428        for (akidx = 0; akidx < ice->akm_codecs; akidx++) {
     429                akm4xxx_t *ak = &ice->akm[akidx];
     430                for (idx = 0; idx < ak->num_dacs; ++idx) {
    332431                        snd_kcontrol_t ctl;
    333432                        memset(&ctl, 0, sizeof(ctl));
    334433                        strcpy(ctl.id.name, "DAC Volume");
    335                         ctl.id.index = idx;
     434                        ctl.id.index = idx + ak->idx_offset * 2;
    336435                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
    337                         ctl.info = snd_ice1712_ak4524_volume_info;
     436                        ctl.info = snd_ice1712_akm4xxx_volume_info;
    338437                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
    339                         ctl.get = snd_ice1712_ak4524_volume_get;
    340                         ctl.put = snd_ice1712_ak4524_volume_put;
    341                 switch (ak->type) {
    342                 case SND_AK4524:
    343                         ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 6, 0); /* register 6 & 7 */
    344                         break;
    345                 case SND_AK4528:
    346                         ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
    347                         break;
    348                 case SND_AK4529: {
    349                         int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb; /* registers 2-7 and b,c */
    350                         ctl.private_value = AK_COMPOSE(0, val, 0);
    351                         break;
    352                 }
    353                 }
    354                         ctl.private_data = ice;
     438                        ctl.get = snd_ice1712_akm4xxx_volume_get;
     439                        ctl.put = snd_ice1712_akm4xxx_volume_put;
     440                        switch (ak->type) {
     441                        case SND_AK4524:
     442                                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127); /* register 6 & 7 */
     443                                break;
     444                        case SND_AK4528:
     445                                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127); /* register 4 & 5 */
     446                                break;
     447                        case SND_AK4529: {
     448                                int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb; /* registers 2-7 and b,c */
     449                                ctl.private_value = AK_COMPOSE(0, val, 0, 255) | AK_INVERT;
     450                                break;
     451                        }
     452                        case SND_AK4355:
     453                                ctl.private_value = AK_COMPOSE(0, idx + 4, 0, 255); /* register 4-9, chip #0 only */
     454                                break;
     455                        case SND_AK4381:
     456                                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255); /* register 3 & 4 */
     457                                break;
     458                        default:
     459                                return -EINVAL;
     460                        }
     461                        ctl.private_data = ak;
    355462                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
    356463                                return err;
    357464                }
    358         for (idx = 0; idx < ak->num_adcs && ak->type == SND_AK4524; ++idx) {
     465                for (idx = 0; idx < ak->num_adcs && ak->type == SND_AK4524; ++idx) {
    359466                        snd_kcontrol_t ctl;
    360467                        memset(&ctl, 0, sizeof(ctl));
     
    362469                        ctl.id.index = idx;
    363470                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
    364                         ctl.info = snd_ice1712_ak4524_volume_info;
     471                        ctl.info = snd_ice1712_akm4xxx_volume_info;
    365472                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
    366                         ctl.get = snd_ice1712_ak4524_volume_get;
    367                         ctl.put = snd_ice1712_ak4524_volume_put;
    368                 ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
    369                         ctl.private_data = ice;
     473                        ctl.get = snd_ice1712_akm4xxx_volume_get;
     474                        ctl.put = snd_ice1712_akm4xxx_volume_put;
     475                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127); /* register 4 & 5 */
     476                        ctl.private_data = ak;
    370477                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
    371478                                return err;
     
    374481                        ctl.id.index = idx;
    375482                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
    376                         ctl.info = snd_ice1712_ak4524_ipga_gain_info;
     483                        ctl.info = snd_ice1712_akm4xxx_ipga_gain_info;
    377484                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
    378                         ctl.get = snd_ice1712_ak4524_ipga_gain_get;
    379                         ctl.put = snd_ice1712_ak4524_ipga_gain_put;
    380                 ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
    381                         ctl.private_data = ice;
     485                        ctl.get = snd_ice1712_akm4xxx_ipga_gain_get;
     486                        ctl.put = snd_ice1712_akm4xxx_ipga_gain_put;
     487                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 0); /* register 4 & 5 */
     488                        ctl.private_data = ak;
    382489                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
    383490                                return err;
    384491                }
    385         for (idx = 0; idx < ak->num_dacs/2; idx++) {
     492                for (idx = 0; idx < ak->num_dacs/2; idx++) {
    386493                        snd_kcontrol_t ctl;
    387494                        memset(&ctl, 0, sizeof(ctl));
    388495                        strcpy(ctl.id.name, "Deemphasis");
    389                         ctl.id.index = idx;
     496                        ctl.id.index = idx + ak->idx_offset;
    390497                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
    391                         ctl.info = snd_ice1712_ak4524_deemphasis_info;
     498                        ctl.info = snd_ice1712_akm4xxx_deemphasis_info;
    392499                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
    393                         ctl.get = snd_ice1712_ak4524_deemphasis_get;
    394                         ctl.put = snd_ice1712_ak4524_deemphasis_put;
    395                 switch (ak->type) {
    396                 case SND_AK4524:
    397                 case SND_AK4528:
    398                         ctl.private_value = AK_COMPOSE(idx, 3, 0); /* register 3 */
    399                         break;
    400                 case SND_AK4529: {
    401                         int shift = idx == 3 ? 6 : (2 - idx) * 2;
    402                         ctl.private_value = AK_COMPOSE(0, 8, shift); /* register 8 with shift */
    403                         break;
    404                 }
    405                 }
    406                         ctl.private_data = ice;
     500                        ctl.get = snd_ice1712_akm4xxx_deemphasis_get;
     501                        ctl.put = snd_ice1712_akm4xxx_deemphasis_put;
     502                        switch (ak->type) {
     503                        case SND_AK4524:
     504                        case SND_AK4528:
     505                                ctl.private_value = AK_COMPOSE(idx, 3, 0, 0); /* register 3 */
     506                                break;
     507                        case SND_AK4529: {
     508                                int shift = idx == 3 ? 6 : (2 - idx) * 2;
     509                                ctl.private_value = AK_COMPOSE(0, 8, shift, 0); /* register 8 with shift */
     510                                break;
     511                        }
     512                        case SND_AK4355:
     513                                ctl.private_value = AK_COMPOSE(idx, 3, 0, 0);
     514                                break;
     515                        case SND_AK4381:
     516                                ctl.private_value = AK_COMPOSE(idx, 1, 1, 0);
     517                                break;
     518                        }
     519                        ctl.private_data = ak;
    407520                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
    408521                                return err;
    409522                }
    410         return 0;
    411 }
    412 
    413 
     523        }
     524        return 0;
     525}
     526
     527
  • GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/delta.c

    r215 r224  
    190190static int delta_spdif_default_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol)
    191191{
    192         unsigned long flags;
    193192        unsigned int val;
    194193        int change;
    195194
    196195        val = snd_cs8403_encode_spdif_bits(&ucontrol->value.iec958);
    197         spin_lock_irqsave(&ice->reg_lock, flags);
     196        spin_lock_irq(&ice->reg_lock);
    198197        change = ice->spdif.cs8403_bits != val;
    199198        ice->spdif.cs8403_bits = val;
    200199        if (change && ice->playback_pro_substream == NULL) {
    201                 spin_unlock_irqrestore(&ice->reg_lock, flags);
     200                spin_unlock_irq(&ice->reg_lock);
    202201                snd_ice1712_delta_cs8403_spdif_write(ice, val);
    203202        } else {
    204                 spin_unlock_irqrestore(&ice->reg_lock, flags);
     203                spin_unlock_irq(&ice->reg_lock);
    205204        }
    206205        return change;
     
    214213static int delta_spdif_stream_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol)
    215214{
    216         unsigned long flags;
    217215        unsigned int val;
    218216        int change;
    219217
    220218        val = snd_cs8403_encode_spdif_bits(&ucontrol->value.iec958);
    221         spin_lock_irqsave(&ice->reg_lock, flags);
     219        spin_lock_irq(&ice->reg_lock);
    222220        change = ice->spdif.cs8403_stream_bits != val;
    223221        ice->spdif.cs8403_stream_bits = val;
    224222        if (change && ice->playback_pro_substream != NULL) {
    225                 spin_unlock_irqrestore(&ice->reg_lock, flags);
     223                spin_unlock_irq(&ice->reg_lock);
    226224                snd_ice1712_delta_cs8403_spdif_write(ice, val);
    227225        } else {
    228                 spin_unlock_irqrestore(&ice->reg_lock, flags);
     226                spin_unlock_irq(&ice->reg_lock);
    229227        }
    230228        return change;
     
    235233 * AK4524 on Delta 44 and 66 to choose the chip mask
    236234 */
    237 static int delta_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
    238 {
    239         snd_ice1712_save_gpio_status(ice, saved);
    240         ice->ak4524.cs_mask =
    241         ice->ak4524.cs_addr = chip == 0 ? ICE1712_DELTA_CODEC_CHIP_A :
    242                                           ICE1712_DELTA_CODEC_CHIP_B;
     235static int delta_ak4524_start(akm4xxx_t *ak, int chip)
     236{
     237        snd_ice1712_save_gpio_status(ak->chip);
     238        ak->cs_mask =
     239        ak->cs_addr = chip == 0 ? ICE1712_DELTA_CODEC_CHIP_A :
     240                                  ICE1712_DELTA_CODEC_CHIP_B;
    243241        return 0;
    244242}
     
    247245 * AK4524 on Delta1010LT to choose the chip address
    248246 */
    249 static int delta1010lt_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
    250 {
    251         snd_ice1712_save_gpio_status(ice, saved);
    252         ice->ak4524.cs_mask = ICE1712_DELTA_1010LT_CS;
    253         ice->ak4524.cs_addr = chip << 4;
     247static int delta1010lt_ak4524_start(akm4xxx_t *ak, int chip)
     248{
     249        snd_ice1712_save_gpio_status(ak->chip);
     250        ak->cs_mask = ICE1712_DELTA_1010LT_CS;
     251        ak->cs_addr = chip << 4;
    254252        return 0;
    255253}
     
    258256 * change the rate of AK4524 on Delta 44/66, AP, 1010LT
    259257 */
    260 static void delta_ak4524_set_rate_val(ice1712_t *ice, unsigned int rate)
     258static void delta_ak4524_set_rate_val(akm4xxx_t *ak, unsigned int rate)
    261259{
    262260        unsigned char tmp, tmp2;
     261        ice1712_t *ice = ak->chip;
    263262
    264263        if (rate == 0)  /* no hint - S/PDIF input is master, simply return */
     
    277276
    278277        /* do it again */
    279         snd_ice1712_ak4524_reset(ice, 1);
     278        snd_ice1712_akm4xxx_reset(ak, 1);
    280279        down(&ice->gpio_mutex);
    281280        tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ~ICE1712_DELTA_DFS;
     
    284283        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
    285284        up(&ice->gpio_mutex);
    286         snd_ice1712_ak4524_reset(ice, 0);
     285        snd_ice1712_akm4xxx_reset(ak, 0);
    287286}
    288287
     
    299298
    300299/* set up */
    301 static void delta_setup_spdif(ice1712_t *ice, snd_pcm_substream_t * substream)
     300static void delta_setup_spdif(ice1712_t *ice, int rate)
    302301{
    303302        unsigned long flags;
     
    309308        if (tmp & 0x01)         /* consumer */
    310309                tmp &= (tmp & 0x01) ? ~0x06 : ~0x18;
    311         switch (substream->runtime->rate) {
     310        switch (rate) {
    312311        case 32000: tmp |= (tmp & 0x01) ? 0x04 : 0x00; break;
    313312        case 44100: tmp |= (tmp & 0x01) ? 0x00 : 0x10; break;
     
    328327 */
    329328
     329static akm4xxx_t akm_audiophile __devinitdata = {
     330        .type = SND_AK4528,
     331        .num_adcs = 2,
     332        .num_dacs = 2,
     333        .caddr = 2,
     334        .cif = 0,
     335        .data_mask = ICE1712_DELTA_AP_DOUT,
     336        .clk_mask = ICE1712_DELTA_AP_CCLK,
     337        .cs_mask = ICE1712_DELTA_AP_CS_CODEC,
     338        .cs_addr = ICE1712_DELTA_AP_CS_CODEC,
     339        .cs_none = 0,
     340        .add_flags = ICE1712_DELTA_AP_CS_DIGITAL,
     341        .mask_flags = 0,
     342        .ops = {
     343                .set_rate_val = delta_ak4524_set_rate_val
     344        }
     345};
     346
     347static akm4xxx_t akm_delta410 __devinitdata = {
     348        .type = SND_AK4529,
     349        .num_adcs = 2,
     350        .num_dacs = 8,
     351        .caddr = 0,
     352        .cif = 0,
     353        .data_mask = ICE1712_DELTA_AP_DOUT,
     354        .clk_mask = ICE1712_DELTA_AP_CCLK,
     355        .cs_mask = ICE1712_DELTA_AP_CS_CODEC,
     356        .cs_addr = ICE1712_DELTA_AP_CS_CODEC,
     357        .cs_none = 0,
     358        .add_flags = ICE1712_DELTA_AP_CS_DIGITAL,
     359        .mask_flags = 0,
     360        .ops = {
     361                .set_rate_val = delta_ak4524_set_rate_val
     362        }
     363};
     364
     365static akm4xxx_t akm_delta1010lt __devinitdata = {
     366        .type = SND_AK4524,
     367        .num_adcs = 8,
     368        .num_dacs = 8,
     369        .caddr = 2,
     370        .cif = 0, /* the default level of the CIF pin from AK4524 */
     371        .data_mask = ICE1712_DELTA_1010LT_DOUT,
     372        .clk_mask = ICE1712_DELTA_1010LT_CCLK,
     373        .cs_mask = 0,
     374        .cs_addr = 0, /* set later */
     375        .cs_none = ICE1712_DELTA_1010LT_CS_NONE,
     376        .add_flags = 0,
     377        .mask_flags = 0,
     378        .ops = {
     379                .start = delta1010lt_ak4524_start,
     380                .set_rate_val = delta_ak4524_set_rate_val
     381        }
     382};
     383
     384static akm4xxx_t akm_delta44 __devinitdata = {
     385        .type = SND_AK4524,
     386        .num_adcs = 4,
     387        .num_dacs = 4,
     388        .caddr = 2,
     389        .cif = 0, /* the default level of the CIF pin from AK4524 */
     390        .data_mask = ICE1712_DELTA_CODEC_SERIAL_DATA,
     391        .clk_mask = ICE1712_DELTA_CODEC_SERIAL_CLOCK,
     392        .cs_mask = 0,
     393        .cs_addr = 0, /* set later */
     394        .cs_none = 0,
     395        .add_flags = 0,
     396        .mask_flags = 0,
     397        .ops = {
     398                .start = delta_ak4524_start,
     399                .set_rate_val = delta_ak4524_set_rate_val
     400        }
     401};
     402
    330403static int __devinit snd_ice1712_delta_init(ice1712_t *ice)
    331404{
    332405        int err;
    333         ak4524_t *ak;
     406        akm4xxx_t *ak;
    334407
    335408        /* determine I2C, DACs and ADCs */
     
    369442        case ICE1712_SUBDEVICE_DELTA66:
    370443                ice->spdif.ops.open = delta_open_spdif;
    371                 ice->spdif.ops.setup = delta_setup_spdif;
     444                ice->spdif.ops.setup_rate = delta_setup_spdif;
    372445                ice->spdif.ops.default_get = delta_spdif_default_get;
    373446                ice->spdif.ops.default_put = delta_spdif_default_put;
     
    379452        }
    380453
     454        /* no analog? */
     455        switch (ice->eeprom.subvendor) {
     456        case ICE1712_SUBDEVICE_DELTA1010:
     457        case ICE1712_SUBDEVICE_DELTADIO2496:
     458                return 0;
     459        }
     460
    381461        /* second stage of initialization, analog parts and others */
    382         ak = &ice->ak4524;
     462        ak = ice->akm = kmalloc(sizeof(akm4xxx_t), GFP_KERNEL);
     463        if (! ak)
     464                return -ENOMEM;
     465        ice->akm_codecs = 1;
     466
    383467        switch (ice->eeprom.subvendor) {
    384468        case ICE1712_SUBDEVICE_AUDIOPHILE:
     469                snd_ice1712_akm4xxx_init(ak, &akm_audiophile, ice);
     470                break;
    385471        case ICE1712_SUBDEVICE_DELTA410:
    386                 ak->num_adcs = ak->num_dacs = 2;
    387                 ak->type = SND_AK4528;
    388                 if (ice->eeprom.subvendor == ICE1712_SUBDEVICE_DELTA410) {
    389                         ak->num_dacs = 8;
    390                         ak->type = SND_AK4529;
    391                 }
    392                 ak->cif = 0; /* the default level of the CIF pin from AK4528/4529 */
    393                 ak->data_mask = ICE1712_DELTA_AP_DOUT;
    394                 ak->clk_mask = ICE1712_DELTA_AP_CCLK;
    395                 ak->cs_mask = ak->cs_addr = ICE1712_DELTA_AP_CS_CODEC; /* select AK4528/4529 codec */
    396                 ak->cs_none = 0;
    397                 ak->add_flags = ICE1712_DELTA_AP_CS_DIGITAL; /* assert digital high */
    398                 ak->mask_flags = 0;
    399                 ak->ops.set_rate_val = delta_ak4524_set_rate_val;
    400                 snd_ice1712_ak4524_init(ice);
     472                snd_ice1712_akm4xxx_init(ak, &akm_delta410, ice);
    401473                break;
    402474        case ICE1712_SUBDEVICE_DELTA1010LT:
    403                 ak->num_adcs = ak->num_dacs = 8;
    404                 ak->type = SND_AK4524;
    405                 ak->cif = 0; /* the default level of the CIF pin from AK4524 */
    406                 ak->data_mask = ICE1712_DELTA_1010LT_DOUT;
    407                 ak->clk_mask = ICE1712_DELTA_1010LT_CCLK;
    408                 ak->cs_mask = ak->cs_addr = 0; /* set later */
    409                 ak->cs_none = ICE1712_DELTA_1010LT_CS_NONE;
    410                 ak->add_flags = 0;
    411                 ak->mask_flags = 0;
    412                 ak->ops.start = delta1010lt_ak4524_start;
    413                 ak->ops.set_rate_val = delta_ak4524_set_rate_val;
    414                 snd_ice1712_ak4524_init(ice);
     475                snd_ice1712_akm4xxx_init(ak, &akm_delta1010lt, ice);
    415476                break;
    416477        case ICE1712_SUBDEVICE_DELTA66:
    417478        case ICE1712_SUBDEVICE_DELTA44:
    418                 ak->num_adcs = ak->num_dacs = 4;
    419                 ak->type = SND_AK4524;
    420                 ak->cif = 0; /* the default level of the CIF pin from AK4524 */
    421                 ak->data_mask = ICE1712_DELTA_CODEC_SERIAL_DATA;
    422                 ak->clk_mask = ICE1712_DELTA_CODEC_SERIAL_CLOCK;
    423                 ak->cs_mask = ak->cs_addr = 0; /* set later */
    424                 ak->cs_none = 0;
    425                 ak->add_flags = 0;
    426                 ak->mask_flags = 0;
    427                 ak->ops.start = delta_ak4524_start;
    428                 ak->ops.set_rate_val = delta_ak4524_set_rate_val;
    429                 snd_ice1712_ak4524_init(ice);
    430                 break;
     479                snd_ice1712_akm4xxx_init(ak, &akm_delta44, ice);
     480                break;
     481        default:
     482                snd_BUG();
     483                return -EINVAL;
    431484        }
    432485
     
    509562        case ICE1712_SUBDEVICE_DELTA44:
    510563        case ICE1712_SUBDEVICE_DELTA66:
    511                 err = snd_ice1712_ak4524_build_controls(ice);
     564                err = snd_ice1712_akm4xxx_build_controls(ice);
    512565                if (err < 0)
    513566                        return err;
  • GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ews.c

    r215 r224  
    8484        unsigned char mask;
    8585
    86         snd_ice1712_save_gpio_status(ice, (unsigned char *)&bus->private_value);
     86        snd_ice1712_save_gpio_status(ice);
    8787        /* set RW high */
    8888        mask = ICE1712_EWX2496_RW;
     
    101101{
    102102        ice1712_t *ice = snd_magic_cast(ice1712_t, bus->private_data, return);
    103         snd_ice1712_restore_gpio_status(ice, (unsigned char *)&bus->private_value);
     103        snd_ice1712_restore_gpio_status(ice);
    104104}
    105105
     
    113113        if (data)
    114114                mask |= ICE1712_EWX2496_SERIAL_DATA; /* write SDA */
    115         ice->gpio_direction &= ~(ICE1712_EWX2496_SERIAL_CLOCK|ICE1712_EWX2496_SERIAL_DATA);
    116         ice->gpio_direction |= mask;
    117         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->gpio_direction);
     115        ice->gpio.direction &= ~(ICE1712_EWX2496_SERIAL_CLOCK|ICE1712_EWX2496_SERIAL_DATA);
     116        ice->gpio.direction |= mask;
     117        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->gpio.direction);
    118118        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~mask);
    119119}
     
    156156
    157157/* start callback for EWS88MT, needs to select a certain chip mask */
    158 static int ews88mt_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
    159 {
     158static int ews88mt_ak4524_start(akm4xxx_t *ak, int chip)
     159{
     160        ice1712_t *ice = ak->chip;
    160161        unsigned char tmp;
    161162        /* assert AK4524 CS */
    162163        if (snd_ice1712_ews88mt_chip_select(ice, ~(1 << chip) & 0x0f) < 0)
    163164                return -EINVAL;
    164         snd_ice1712_save_gpio_status(ice, saved);
     165        snd_ice1712_save_gpio_status(ice);
    165166        tmp = ICE1712_EWS88_SERIAL_DATA |
    166167                ICE1712_EWS88_SERIAL_CLOCK |
    167168                ICE1712_EWS88_RW;
    168169        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
    169                           ice->gpio_direction | tmp);
     170                          ice->gpio.direction | tmp);
    170171        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
    171172        return 0;
     
    173174
    174175/* stop callback for EWS88MT, needs to deselect chip mask */
    175 static void ews88mt_ak4524_stop(ice1712_t *ice, unsigned char *saved)
    176 {
    177         snd_ice1712_restore_gpio_status(ice, saved);
     176static void ews88mt_ak4524_stop(akm4xxx_t *ak)
     177{
     178        ice1712_t *ice = ak->chip;
     179        snd_ice1712_restore_gpio_status(ice);
    178180        udelay(1);
    179181        snd_ice1712_ews88mt_chip_select(ice, 0x0f);
     
    181183
    182184/* start callback for EWX24/96 */
    183 static int ewx2496_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
    184 {
     185static int ewx2496_ak4524_start(akm4xxx_t *ak, int chip)
     186{
     187        ice1712_t *ice = ak->chip;
    185188        unsigned char tmp;
    186         snd_ice1712_save_gpio_status(ice, saved);
     189        snd_ice1712_save_gpio_status(ice);
    187190        tmp =  ICE1712_EWX2496_SERIAL_DATA |
    188191                ICE1712_EWX2496_SERIAL_CLOCK |
     
    190193                ICE1712_EWX2496_RW;
    191194        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
    192                           ice->gpio_direction | tmp);
     195                          ice->gpio.direction | tmp);
    193196        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
    194197        return 0;
     
    196199
    197200/* start callback for DMX 6fire */
    198 static int dmx6fire_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
    199 {
     201static int dmx6fire_ak4524_start(akm4xxx_t *ak, int chip)
     202{
     203        ice1712_t *ice = ak->chip;
    200204        unsigned char tmp;
    201         snd_ice1712_save_gpio_status(ice, saved);
    202         tmp = ice->ak4524.cs_mask = ice->ak4524.cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
     205        snd_ice1712_save_gpio_status(ice);
     206        tmp = ak->cs_mask = ak->cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
    203207        tmp |= ICE1712_6FIRE_SERIAL_DATA |
    204208                ICE1712_6FIRE_SERIAL_CLOCK |
    205209                ICE1712_6FIRE_RW;
    206210        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
    207                           ice->gpio_direction | tmp);
     211                          ice->gpio.direction | tmp);
    208212        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
    209213        return 0;
     
    222226        switch (ice->eeprom.subvendor) {
    223227        case ICE1712_SUBDEVICE_EWS88MT:
     228        case ICE1712_SUBDEVICE_EWS88MT_NEW:
    224229                snd_runtime_check(snd_i2c_sendbytes(ice->cs8404, &bits, 1) == 1, goto _error);
    225230                break;
     
    246251static int ews88_spdif_default_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol)
    247252{
    248         unsigned long flags;
    249253        unsigned int val;
    250254        int change;
    251255
    252256        val = snd_cs8404_encode_spdif_bits(&ucontrol->value.iec958);
    253         spin_lock_irqsave(&ice->reg_lock, flags);
     257        spin_lock_irq(&ice->reg_lock);
    254258        change = ice->spdif.cs8403_bits != val;
    255259        ice->spdif.cs8403_bits = val;
    256260        if (change && ice->playback_pro_substream == NULL) {
    257                 spin_unlock_irqrestore(&ice->reg_lock, flags);
     261                spin_unlock_irq(&ice->reg_lock);
    258262                snd_ice1712_ews_cs8404_spdif_write(ice, val);
    259263        } else {
    260                 spin_unlock_irqrestore(&ice->reg_lock, flags);
     264                spin_unlock_irq(&ice->reg_lock);
    261265        }
    262266        return change;
     
    270274static int ews88_spdif_stream_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol)
    271275{
    272         unsigned long flags;
    273276        unsigned int val;
    274277        int change;
    275278
    276279        val = snd_cs8404_encode_spdif_bits(&ucontrol->value.iec958);
    277         spin_lock_irqsave(&ice->reg_lock, flags);
     280        spin_lock_irq(&ice->reg_lock);
    278281        change = ice->spdif.cs8403_stream_bits != val;
    279282        ice->spdif.cs8403_stream_bits = val;
    280283        if (change && ice->playback_pro_substream != NULL) {
    281                 spin_unlock_irqrestore(&ice->reg_lock, flags);
     284                spin_unlock_irq(&ice->reg_lock);
    282285                snd_ice1712_ews_cs8404_spdif_write(ice, val);
    283286        } else {
    284                 spin_unlock_irqrestore(&ice->reg_lock, flags);
     287                spin_unlock_irq(&ice->reg_lock);
    285288        }
    286289        return change;
     
    295298
    296299/* set up SPDIF for EWS88MT / EWS88D */
    297 static void ews88_setup_spdif(ice1712_t *ice, snd_pcm_substream_t * substream)
     300static void ews88_setup_spdif(ice1712_t *ice, int rate)
    298301{
    299302        unsigned long flags;
     
    305308        if (tmp & 0x10)         /* consumer */
    306309                tmp &= (tmp & 0x01) ? ~0x06 : ~0x60;
    307         switch (substream->runtime->rate) {
     310        switch (rate) {
    308311        case 32000: tmp |= (tmp & 0x01) ? 0x02 : 0x00; break;
    309312        case 44100: tmp |= (tmp & 0x01) ? 0x06 : 0x40; break;
     
    321324
    322325/*
     326 */
     327static akm4xxx_t akm_ews88mt __devinitdata = {
     328        .num_adcs = 8,
     329        .num_dacs = 8,
     330        .type = SND_AK4524,
     331        .caddr = 2,
     332        .cif = 1, /* CIF high */
     333        .data_mask = ICE1712_EWS88_SERIAL_DATA,
     334        .clk_mask = ICE1712_EWS88_SERIAL_CLOCK,
     335        .cs_mask = 0,
     336        .cs_addr = 0,
     337        .cs_none = 0, /* no chip select on gpio */
     338        .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
     339        .mask_flags = 0,
     340        .ops = {
     341                .start = ews88mt_ak4524_start,
     342                .stop = ews88mt_ak4524_stop
     343        }
     344};
     345
     346static akm4xxx_t akm_ewx2496 __devinitdata = {
     347        .num_adcs = 2,
     348        .num_dacs = 2,
     349        .type = SND_AK4524,
     350        .caddr = 2,
     351        .cif = 1, /* CIF high */
     352        .data_mask = ICE1712_EWS88_SERIAL_DATA,
     353        .clk_mask = ICE1712_EWS88_SERIAL_CLOCK,
     354        .cs_mask = ICE1712_EWX2496_AK4524_CS,
     355        .cs_addr = ICE1712_EWX2496_AK4524_CS,
     356        .cs_none = 0,
     357        .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
     358        .mask_flags = 0,
     359        .ops = {
     360                .start = ewx2496_ak4524_start
     361        }
     362};
     363
     364static akm4xxx_t akm_6fire __devinitdata = {
     365        .num_adcs = 6,
     366        .num_dacs = 6,
     367        .type = SND_AK4524,
     368        .caddr = 2,
     369        .cif = 1, /* CIF high */
     370        .data_mask = ICE1712_6FIRE_SERIAL_DATA,
     371        .clk_mask = ICE1712_6FIRE_SERIAL_CLOCK,
     372        .cs_mask = 0,
     373        .cs_addr = 0, /* set later */
     374        .cs_none = 0,
     375        .add_flags = ICE1712_6FIRE_RW, /* set rw bit high */
     376        .mask_flags = 0,
     377        .ops = {
     378                .start = dmx6fire_ak4524_start
     379        }
     380};
     381
     382
     383/*
    323384 * initialize the chip
    324385 */
     
    327388{
    328389        int err;
    329         ak4524_t *ak;
     390        akm4xxx_t *ak;
    330391
    331392        /* set the analog DACs */
     
    335396                break; 
    336397        case ICE1712_SUBDEVICE_EWS88MT:
     398        case ICE1712_SUBDEVICE_EWS88MT_NEW:
    337399                ice->num_total_dacs = 8;
    338400                break;
     
    361423                break;
    362424        case ICE1712_SUBDEVICE_EWS88MT:
     425        case ICE1712_SUBDEVICE_EWS88MT_NEW:
    363426                if ((err = snd_i2c_device_create(ice->i2c, "CS8404", ICE1712_EWS88MT_CS8404_ADDR, &ice->cs8404)) < 0)
    364427                        return err;
     
    383446                        return err;
    384447                break;
    385 #if 0 // XXX not working...
    386448        case ICE1712_SUBDEVICE_DMX6FIRE:
    387449                if ((err = snd_ice1712_init_cs8427(ice, ICE1712_6FIRE_CS8427_ADDR)) < 0)
    388450                        return err;
    389 #endif
     451                break;
    390452        case ICE1712_SUBDEVICE_EWS88MT:
     453        case ICE1712_SUBDEVICE_EWS88MT_NEW:
    391454        case ICE1712_SUBDEVICE_EWS88D:
    392455                /* set up CS8404 */
    393456                ice->spdif.ops.open = ews88_open_spdif;
    394                 ice->spdif.ops.setup = ews88_setup_spdif;
     457                ice->spdif.ops.setup_rate = ews88_setup_spdif;
    395458                ice->spdif.ops.default_get = ews88_spdif_default_get;
    396459                ice->spdif.ops.default_put = ews88_spdif_default_put;
     
    402465        }
    403466
     467        /* no analog? */
     468        switch (ice->eeprom.subvendor) {
     469        case ICE1712_SUBDEVICE_EWS88D:
     470                return 0;
     471        }
     472
    404473        /* analog section */
    405         ak = &ice->ak4524;
     474        ak = ice->akm = kmalloc(sizeof(akm4xxx_t), GFP_KERNEL);
     475        if (! ak)
     476                return -ENOMEM;
     477        ice->akm_codecs = 1;
     478
    406479        switch (ice->eeprom.subvendor) {
    407480        case ICE1712_SUBDEVICE_EWS88MT:
    408                 ak->num_adcs = ak->num_dacs = 8;
    409                 ak->type = SND_AK4524;
    410                 ak->cif = 1; /* CIF high */
    411                 ak->data_mask = ICE1712_EWS88_SERIAL_DATA;
    412                 ak->clk_mask = ICE1712_EWS88_SERIAL_CLOCK;
    413                 ak->cs_mask = ak->cs_addr = ak->cs_none = 0; /* no chip select on gpio */
    414                 ak->add_flags = ICE1712_EWS88_RW; /* set rw bit high */
    415                 ak->mask_flags = 0;
    416                 ak->ops.start = ews88mt_ak4524_start;
    417                 ak->ops.stop = ews88mt_ak4524_stop;
    418                 snd_ice1712_ak4524_init(ice);
     481        case ICE1712_SUBDEVICE_EWS88MT_NEW:
     482                snd_ice1712_akm4xxx_init(ak, &akm_ews88mt, ice);
    419483                break;
    420484        case ICE1712_SUBDEVICE_EWX2496:
    421                 ak->num_adcs = ak->num_dacs = 2;
    422                 ak->type = SND_AK4524;
    423                 ak->cif = 1; /* CIF high */
    424                 ak->data_mask = ICE1712_EWS88_SERIAL_DATA;
    425                 ak->clk_mask = ICE1712_EWS88_SERIAL_CLOCK;
    426                 ak->cs_mask = ak->cs_addr = ICE1712_EWX2496_AK4524_CS;
    427                 ak->cs_none = 0;
    428                 ak->add_flags = ICE1712_EWS88_RW; /* set rw bit high */
    429                 ak->mask_flags = 0;
    430                 ak->ops.start = ewx2496_ak4524_start;
    431                 snd_ice1712_ak4524_init(ice);
     485                snd_ice1712_akm4xxx_init(ak, &akm_ewx2496, ice);
    432486                break;
    433487        case ICE1712_SUBDEVICE_DMX6FIRE:
    434                 ak->num_adcs = ak->num_dacs = 6;
    435                 ak->type = SND_AK4524;
    436                 ak->cif = 1; /* CIF high */
    437                 ak->data_mask = ICE1712_6FIRE_SERIAL_DATA;
    438                 ak->clk_mask = ICE1712_6FIRE_SERIAL_CLOCK;
    439                 ak->cs_mask = ak->cs_addr = 0; /* set later */
    440                 ak->cs_none = 0;
    441                 ak->add_flags = ICE1712_6FIRE_RW; /* set rw bit high */
    442                 ak->mask_flags = 0;
    443                 ak->ops.start = dmx6fire_ak4524_start;
    444                 snd_ice1712_ak4524_init(ice);
     488                snd_ice1712_akm4xxx_init(ak, &akm_6fire, ice);
    445489                break;
    446490        }
     
    472516        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    473517        unsigned char mask = kcontrol->private_value & 0xff;
    474         unsigned char saved[2];
    475518       
    476         snd_ice1712_save_gpio_status(ice, saved);
     519        snd_ice1712_save_gpio_status(ice);
    477520        ucontrol->value.enumerated.item[0] = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & mask ? 1 : 0;
    478         snd_ice1712_restore_gpio_status(ice, saved);
     521        snd_ice1712_restore_gpio_status(ice);
    479522        return 0;
    480523}
     
    484527        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    485528        unsigned char mask = kcontrol->private_value & 0xff;
    486         unsigned char saved[2];
    487529        int val, nval;
    488530
     
    490532                return -EPERM;
    491533        nval = ucontrol->value.enumerated.item[0] ? mask : 0;
    492         snd_ice1712_save_gpio_status(ice, saved);
     534        snd_ice1712_save_gpio_status(ice);
    493535        val = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
    494536        nval |= val & ~mask;
    495537        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, nval);
    496         snd_ice1712_restore_gpio_status(ice, saved);
     538        snd_ice1712_restore_gpio_status(ice);
    497539        return val != nval;
    498540}
     
    851893static int __devinit snd_ice1712_ews_add_controls(ice1712_t *ice)
    852894{
    853         int err, idx;
     895        unsigned int idx;
     896        int err;
    854897        snd_kcontrol_t *kctl;
    855898       
     
    863906        case ICE1712_SUBDEVICE_EWX2496:
    864907        case ICE1712_SUBDEVICE_EWS88MT:
     908        case ICE1712_SUBDEVICE_EWS88MT_NEW:
    865909        case ICE1712_SUBDEVICE_DMX6FIRE:
    866                 err = snd_ice1712_ak4524_build_controls(ice);
     910                err = snd_ice1712_akm4xxx_build_controls(ice);
    867911                if (err < 0)
    868912                        return err;
     
    873917        switch (ice->eeprom.subvendor) {
    874918        case ICE1712_SUBDEVICE_EWX2496:
    875                 for (idx = 0; idx < sizeof(snd_ice1712_ewx2496_controls)/sizeof(snd_ice1712_ewx2496_controls[0]); idx++) {
     919                for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_ewx2496_controls); idx++) {
    876920                        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ewx2496_controls[idx], ice));
    877921                        if (err < 0)
     
    880924                break;
    881925        case ICE1712_SUBDEVICE_EWS88MT:
     926        case ICE1712_SUBDEVICE_EWS88MT_NEW:
    882927                for (idx = 0; idx < 8; idx++) {
    883928                        kctl = snd_ctl_new1(&snd_ice1712_ews88mt_input_sense, ice);
     
    892937                break;
    893938        case ICE1712_SUBDEVICE_EWS88D:
    894                 for (idx = 0; idx < sizeof(snd_ice1712_ews88d_controls)/sizeof(snd_ice1712_ews88d_controls[0]); idx++) {
     939                for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_ews88d_controls); idx++) {
    895940                        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88d_controls[idx], ice));
    896941                        if (err < 0)
     
    899944                break;
    900945        case ICE1712_SUBDEVICE_DMX6FIRE:
    901                 for (idx = 0; idx < sizeof(snd_ice1712_6fire_controls)/sizeof(snd_ice1712_6fire_controls[0]); idx++) {
     946                for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_6fire_controls); idx++) {
    902947                        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_6fire_controls[idx], ice));
    903948                        if (err < 0)
     
    914959        {
    915960                ICE1712_SUBDEVICE_EWX2496,
    916                 "TerraTec EWX 24/96",
     961                "TerraTec EWX24/96",
    917962                snd_ice1712_ews_init,
    918963                snd_ice1712_ews_add_controls,
     
    920965        {
    921966                ICE1712_SUBDEVICE_EWS88MT,
    922                 "TerraTec EWS 88MT",
     967                "TerraTec EWS88MT",
     968                snd_ice1712_ews_init,
     969                snd_ice1712_ews_add_controls,
     970        },
     971        {
     972                ICE1712_SUBDEVICE_EWS88MT_NEW,
     973                "TerraTec EWS88MT",
    923974                snd_ice1712_ews_init,
    924975                snd_ice1712_ews_add_controls,
     
    926977        {
    927978                ICE1712_SUBDEVICE_EWS88D,
    928                 "TerraTec EWS 88D",
     979                "TerraTec EWS88D",
    929980                snd_ice1712_ews_init,
    930981                snd_ice1712_ews_add_controls,
     
    932983        {
    933984                ICE1712_SUBDEVICE_DMX6FIRE,
    934                 "TerraTec DMX 6Fire",
     985                "TerraTec DMX6Fire",
    935986                snd_ice1712_ews_init,
    936987                snd_ice1712_ews_add_controls,
  • GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ews.h

    r212 r224  
    3434#define ICE1712_SUBDEVICE_EWX2496       0x3b153011
    3535#define ICE1712_SUBDEVICE_EWS88MT       0x3b151511
     36#define ICE1712_SUBDEVICE_EWS88MT_NEW   0x3b152511
    3637#define ICE1712_SUBDEVICE_EWS88D        0x3b152b11
    3738#define ICE1712_SUBDEVICE_DMX6FIRE      0x3b153811
     
    7778
    7879#define ICE1712_6FIRE_PCF9554_ADDR      (0x40>>1)
    79 #define ICE1712_6FIRE_CS8427_ADDR       (0x22>>1)
     80#define ICE1712_6FIRE_CS8427_ADDR       (0x22)
    8081
    8182#endif /* __SOUND_EWS_H */
  • GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1712.c

    r215 r224  
    3333 *      is stored in the local file and called from registration
    3434 *      function from card_info struct.
     35 *
     36 *  2002.11.26  James Stafford <jstafford@ampltd.com>
     37 *      Added support for VT1724 (Envy24HT)
     38 *      I have left out support for 176.4 and 192 KHz for the moment.
     39 *  I also haven't done anything with the internal S/PDIF transmitter or the MPU-401
     40 *
     41 *  2003.02.20  Taksahi Iwai <tiwai@suse.de>
     42 *      Split vt1724 part to an independent driver.
     43 *      The GPIO is accessed through the callback functions now.
    3544 */
    3645
     
    96105
    97106static struct pci_device_id snd_ice1712_ids[] __devinitdata = {
    98         { PCI_VENDOR_ID_ICE, PCI_DEVICE_ID_ICE_1712, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* ICE1712 */
     107        { PCI_VENDOR_ID_ICE, PCI_DEVICE_ID_ICE_1712, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },   /* ICE1712 */
    99108        { 0, }
    100109};
     
    113122 */
    114123 
     124/* check whether the clock mode is spdif-in */
    115125static inline int is_spdif_master(ice1712_t *ice)
    116126{
     
    240250}
    241251
     252/*
     253 * consumer ac97 digital mix
     254 */
    242255static int snd_ice1712_digmix_route_ac97_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
    243256{
     
    252265{
    253266        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    254         unsigned long flags;
    255267       
    256         spin_lock_irqsave(&ice->reg_lock, flags);
    257268        ucontrol->value.integer.value[0] = inb(ICEMT(ice, MONITOR_ROUTECTRL)) & ICE1712_ROUTE_AC97 ? 1 : 0;
    258         spin_unlock_irqrestore(&ice->reg_lock, flags);
    259269        return 0;
    260270}
     
    264274        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    265275        unsigned char val, nval;
    266         unsigned long flags;
    267276       
    268         spin_lock_irqsave(&ice->reg_lock, flags);
     277        spin_lock_irq(&ice->reg_lock);
    269278        val = inb(ICEMT(ice, MONITOR_ROUTECTRL));
    270279        nval = val & ~ICE1712_ROUTE_AC97;
    271280        if (ucontrol->value.integer.value[0]) nval |= ICE1712_ROUTE_AC97;
    272281        outb(nval, ICEMT(ice, MONITOR_ROUTECTRL));
    273         spin_unlock_irqrestore(&ice->reg_lock, flags);
     282        spin_unlock_irq(&ice->reg_lock);
    274283        return val != nval;
    275284}
     
    284293
    285294
    286 
    287295/*
    288  * set gpio direction, write mask and data
     296 * gpio operations
    289297 */
    290 void snd_ice1712_gpio_write_bits(ice1712_t *ice, int mask, int bits)
    291 {
    292         ice->gpio_direction |= mask;
    293         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->gpio_direction);
    294         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~mask);
    295         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, mask & bits);
    296 }
    297 
    298 /*
    299  */
    300 void snd_ice1712_save_gpio_status(ice1712_t *ice, unsigned char *tmp)
    301 {
    302         down(&ice->gpio_mutex);
    303         tmp[0] = ice->gpio_direction;
    304         tmp[1] = ice->gpio_write_mask;
    305 }
    306 
    307 void snd_ice1712_restore_gpio_status(ice1712_t *ice, unsigned char *tmp)
    308 {
    309         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, tmp[0]);
    310         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, tmp[1]);
    311         ice->gpio_direction = tmp[0];
    312         ice->gpio_write_mask = tmp[1];
    313         up(&ice->gpio_mutex);
     298static void snd_ice1712_set_gpio_dir(ice1712_t *ice, unsigned int data)
     299{
     300        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, data);
     301}
     302
     303static void snd_ice1712_set_gpio_mask(ice1712_t *ice, unsigned int data)
     304{
     305        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, data);
     306}
     307
     308static unsigned int snd_ice1712_get_gpio_data(ice1712_t *ice)
     309{
     310        return snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
     311}
     312
     313static void snd_ice1712_set_gpio_data(ice1712_t *ice, unsigned int val)
     314{
     315        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, val);
    314316}
    315317
     
    370372}
    371373
    372 static void setup_cs8427(ice1712_t *ice, snd_pcm_substream_t * substream)
    373 {
    374         snd_cs8427_iec958_pcm(ice->cs8427, substream->runtime->rate);
     374static void setup_cs8427(ice1712_t *ice, int rate)
     375{
     376        snd_cs8427_iec958_pcm(ice->cs8427, rate);
    375377}
    376378
     
    388390        ice->spdif.ops.open = open_cs8427;
    389391        ice->spdif.ops.close = close_cs8427;
    390         ice->spdif.ops.setup = setup_cs8427;
     392        ice->spdif.ops.setup_rate = setup_cs8427;
    391393        return 0;
    392394}
     
    556558static int snd_ice1712_playback_prepare(snd_pcm_substream_t * substream)
    557559{
    558         unsigned long flags;
    559560        ice1712_t *ice = snd_pcm_substream_chip(substream);
    560561        snd_pcm_runtime_t *runtime = substream->runtime;
     
    571572        if (rate > 0x000fffff)
    572573                rate = 0x000fffff;
    573         spin_lock_irqsave(&ice->reg_lock, flags);
     574        spin_lock(&ice->reg_lock);
    574575        outb(0, ice->ddma_port + 15);
    575576        outb(ICE1712_DMA_MODE_WRITE | ICE1712_DMA_AUTOINIT, ice->ddma_port + 0x0b);
     
    584585        snd_ice1712_write(ice, ICE1712_IREG_PBK_LEFT, 0);
    585586        snd_ice1712_write(ice, ICE1712_IREG_PBK_RIGHT, 0);
    586         spin_unlock_irqrestore(&ice->reg_lock, flags);
     587        spin_unlock(&ice->reg_lock);
    587588        return 0;
    588589}
     
    590591static int snd_ice1712_playback_ds_prepare(snd_pcm_substream_t * substream)
    591592{
    592         unsigned long flags;
    593593        ice1712_t *ice = snd_pcm_substream_chip(substream);
    594594        snd_pcm_runtime_t *runtime = substream->runtime;
     
    608608        ice->playback_con_virt_addr[substream->number] = runtime->dma_addr;
    609609        chn = substream->number * 2;
    610         spin_lock_irqsave(&ice->reg_lock, flags);
     610        spin_lock(&ice->reg_lock);
    611611        snd_ice1712_ds_write(ice, chn, ICE1712_DSC_ADDR0, runtime->dma_addr);
    612612        snd_ice1712_ds_write(ice, chn, ICE1712_DSC_COUNT0, period_size);
     
    620620                snd_ice1712_ds_write(ice, chn + 1, ICE1712_DSC_VOLUME, 0);
    621621        }
    622         spin_unlock_irqrestore(&ice->reg_lock, flags);
     622        spin_unlock(&ice->reg_lock);
    623623        return 0;
    624624}
     
    626626static int snd_ice1712_capture_prepare(snd_pcm_substream_t * substream)
    627627{
    628         unsigned long flags;
    629628        ice1712_t *ice = snd_pcm_substream_chip(substream);
    630629        snd_pcm_runtime_t *runtime = substream->runtime;
     
    639638        if (runtime->channels == 2)
    640639                tmp &= ~0x02;
    641         spin_lock_irqsave(&ice->reg_lock, flags);
     640        spin_lock(&ice->reg_lock);
    642641        outl(ice->capture_con_virt_addr = runtime->dma_addr, ICEREG(ice, CONCAP_ADDR));
    643642        outw(buf_size, ICEREG(ice, CONCAP_COUNT));
     
    645644        snd_ice1712_write(ice, ICE1712_IREG_CAP_COUNT_LO, period_size & 0xff);
    646645        snd_ice1712_write(ice, ICE1712_IREG_CAP_CTRL, tmp);
    647         spin_unlock_irqrestore(&ice->reg_lock, flags);
     646        spin_unlock(&ice->reg_lock);
    648647        snd_ac97_set_rate(ice->ac97, AC97_PCM_LR_ADC_RATE, runtime->rate);
    649648        return 0;
     
    763762        snd_pcm_runtime_t *runtime = substream->runtime;
    764763        ice1712_t *ice = snd_pcm_substream_chip(substream);
    765         unsigned long flags;
    766764        u32 tmp;
    767765
    768766        ice->playback_con_substream_ds[substream->number] = substream;
    769767        runtime->hw = snd_ice1712_playback_ds;
    770         spin_lock_irqsave(&ice->reg_lock, flags);
     768        spin_lock_irq(&ice->reg_lock);
    771769        tmp = inw(ICEDS(ice, INTMASK)) & ~(1 << (substream->number * 2));
    772770        outw(tmp, ICEDS(ice, INTMASK));
    773         spin_unlock_irqrestore(&ice->reg_lock, flags);
     771        spin_unlock_irq(&ice->reg_lock);
    774772        return 0;
    775773}
     
    799797{
    800798        ice1712_t *ice = snd_pcm_substream_chip(substream);
    801         unsigned long flags;
    802799        u32 tmp;
    803800
    804         spin_lock_irqsave(&ice->reg_lock, flags);
     801        spin_lock_irq(&ice->reg_lock);
    805802        tmp = inw(ICEDS(ice, INTMASK)) | (3 << (substream->number * 2));
    806803        outw(tmp, ICEDS(ice, INTMASK));
    807         spin_unlock_irqrestore(&ice->reg_lock, flags);
     804        spin_unlock_irq(&ice->reg_lock);
    808805        ice->playback_con_substream_ds[substream->number] = NULL;
    809806        return 0;
     
    967964                unsigned int old;
    968965                snd_pcm_substream_t *s = substream;
     966
    969967                do {
    970968                        if (s == ice->playback_pro_substream) {
     
    995993/*
    996994 */
    997 static void snd_ice1712_set_pro_rate(ice1712_t *ice, unsigned int rate, int do_not_lock)
     995static void snd_ice1712_set_pro_rate(ice1712_t *ice, unsigned int rate, int force)
    998996{
    999997        unsigned long flags;
    1000998        unsigned char val;
    1001         int old_lock_value;
     999        unsigned int i;
    10021000
    10031001        spin_lock_irqsave(&ice->reg_lock, flags);
    1004         old_lock_value = PRO_RATE_LOCKED;
    1005         if (do_not_lock)
    1006                 PRO_RATE_LOCKED = 0;
    10071002        if (inb(ICEMT(ice, PLAYBACK_CONTROL)) & (ICE1712_CAPTURE_START_SHADOW|
    10081003                                                  ICE1712_PLAYBACK_PAUSE|
     
    10111006                return;
    10121007        }
    1013         if (!is_pro_rate_locked(ice))
    1014                 goto __unlock;
     1008        if (!force && is_pro_rate_locked(ice)) {
     1009                spin_unlock_irqrestore(&ice->reg_lock, flags);
     1010                return;
     1011        }
    10151012
    10161013        switch (rate) {
    </