Changeset 224


Ignore:
Timestamp:
Jul 26, 2007, 7:21:09 AM (18 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

  • TabularUnified 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;

  • TabularUnified 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}

  • TabularUnified 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

  • TabularUnified 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);

  • TabularUnified 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/**

  • TabularUnified 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");

  • TabularUnified 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

  • TabularUnified 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

  • TabularUnified 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

  • TabularUnified 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,

  • TabularUnified 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 *

  • TabularUnified 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 */

  • TabularUnified 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>

  • TabularUnified 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"

  • TabularUnified 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

  • TabularUnified 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

  • TabularUnified 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 = {

  • TabularUnified 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/*

  • TabularUnified 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 = {

  • TabularUnified 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 = {

  • TabularUnified 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]);

  • TabularUnified 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);

  • TabularUnified 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)

  • TabularUnified 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        }

  • TabularUnified 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 */

  • TabularUnified 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

  • TabularUnified 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);

  • TabularUnified 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}

  • TabularUnified 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);

  • TabularUnified 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;

  • TabularUnified 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;

  • TabularUnified 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));

  • TabularUnified 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)

  • TabularUnified 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);

  • TabularUnified 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;

  • TabularUnified 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;

  • TabularUnified 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)

  • TabularUnified 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++;

  • TabularUnified 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

  • TabularUnified 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);

  • TabularUnified 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;

  • TabularUnified 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}

  • TabularUnified 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 &&

  • TabularUnified 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");

  • TabularUnified 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}

  • TabularUnified 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{

  • TabularUnified 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

  • TabularUnified 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;

  • TabularUnified 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,

  • TabularUnified 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 */

  • TabularUnified 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) {
    … …  
    10341031        }
    10351032        outb(val, ICEMT(ice, RATE));
    1036         PRO_RATE_LOCKED = old_lock_value;
    1037 
    1038       __unlock:
     1033
    10391034        spin_unlock_irqrestore(&ice->reg_lock, flags);
    10401035
    1041         if (ice->ak4524.ops.set_rate_val)
    1042                 ice->ak4524.ops.set_rate_val(ice, rate);
     1036        for (i = 0; i < ice->akm_codecs; i++) {
     1037                if (ice->akm[i].ops.set_rate_val)
     1038                        ice->akm[i].ops.set_rate_val(&ice->akm[i], rate);
     1039        }
    10431040}
    10441041
    10451042static int snd_ice1712_playback_pro_prepare(snd_pcm_substream_t * substream)
    10461043{
    1047         unsigned long flags;
    10481044        ice1712_t *ice = snd_pcm_substream_chip(substream);
    10491045
    10501046        ice->playback_pro_size = snd_pcm_lib_buffer_bytes(substream);
    1051         snd_ice1712_set_pro_rate(ice, substream->runtime->rate, 0);
    1052         spin_lock_irqsave(&ice->reg_lock, flags);
     1047        spin_lock(&ice->reg_lock);
    10531048        outl(substream->runtime->dma_addr, ICEMT(ice, PLAYBACK_ADDR));
    10541049        outw((ice->playback_pro_size >> 2) - 1, ICEMT(ice, PLAYBACK_SIZE));
    10551050        outw((snd_pcm_lib_period_bytes(substream) >> 2) - 1, ICEMT(ice, PLAYBACK_COUNT));
    1056                 spin_unlock_irqrestore(&ice->reg_lock, flags);
    1057 
    1058         if (ice->spdif.ops.setup)
    1059                 ice->spdif.ops.setup(ice, substream);
    1060 
    1061         return 0;
     1051        spin_unlock(&ice->reg_lock);
     1052
     1053        return 0;
     1054}
     1055
     1056static int snd_ice1712_playback_pro_hw_params(snd_pcm_substream_t * substream,
     1057                                              snd_pcm_hw_params_t * hw_params)
     1058{
     1059        ice1712_t *ice = snd_pcm_substream_chip(substream);
     1060
     1061        snd_ice1712_set_pro_rate(ice, params_rate(hw_params), 0);
     1062        if (ice->spdif.ops.setup_rate)
     1063                ice->spdif.ops.setup_rate(ice, params_rate(hw_params));
     1064        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
    10621065}
    10631066
    10641067static int snd_ice1712_capture_pro_prepare(snd_pcm_substream_t * substream)
    10651068{
    1066         unsigned long flags;
    10671069        ice1712_t *ice = snd_pcm_substream_chip(substream);
    10681070
    10691071        ice->capture_pro_size = snd_pcm_lib_buffer_bytes(substream);
    1070         snd_ice1712_set_pro_rate(ice, substream->runtime->rate, 0);
    1071         spin_lock_irqsave(&ice->reg_lock, flags);
     1072        spin_lock(&ice->reg_lock);
    10721073        outl(substream->runtime->dma_addr, ICEMT(ice, CAPTURE_ADDR));
    10731074        outw((ice->capture_pro_size >> 2) - 1, ICEMT(ice, CAPTURE_SIZE));
    10741075        outw((snd_pcm_lib_period_bytes(substream) >> 2) - 1, ICEMT(ice, CAPTURE_COUNT));
    1075         spin_unlock_irqrestore(&ice->reg_lock, flags);
    1076         return 0;
     1076        spin_unlock(&ice->reg_lock);
     1077        return 0;
     1078}
     1079
     1080static int snd_ice1712_capture_pro_hw_params(snd_pcm_substream_t * substream,
     1081                                             snd_pcm_hw_params_t * hw_params)
     1082{
     1083        ice1712_t *ice = snd_pcm_substream_chip(substream);
     1084
     1085        snd_ice1712_set_pro_rate(ice, params_rate(hw_params), 0);
     1086        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
    10771087}
    10781088
    … …  
    12031213        .close =        snd_ice1712_playback_pro_close,
    12041214        .ioctl =        snd_pcm_lib_ioctl,
    1205         .hw_params =    snd_ice1712_hw_params,
     1215        .hw_params =    snd_ice1712_playback_pro_hw_params,
    12061216        .hw_free =      snd_ice1712_hw_free,
    12071217        .prepare =      snd_ice1712_playback_pro_prepare,
    … …  
    12141224        .close =        snd_ice1712_capture_pro_close,
    12151225        .ioctl =        snd_pcm_lib_ioctl,
    1216         .hw_params =    snd_ice1712_hw_params,
     1226        .hw_params =    snd_ice1712_capture_pro_hw_params,
    12171227        .hw_free =      snd_ice1712_hw_free,
    12181228        .prepare =      snd_ice1712_capture_pro_prepare,
    … …  
    12871297{
    12881298        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    1289         unsigned long flags;
    12901299        int index = kcontrol->private_value;
    12911300       
    1292         spin_lock_irqsave(&ice->reg_lock, flags);
     1301        spin_lock_irq(&ice->reg_lock);
    12931302        ucontrol->value.integer.value[0] = !((ice->pro_volumes[index] >> 15) & 1);
    12941303        ucontrol->value.integer.value[1] = !((ice->pro_volumes[index] >> 31) & 1);
    1295         spin_unlock_irqrestore(&ice->reg_lock, flags);
     1304        spin_unlock_irq(&ice->reg_lock);
    12961305        return 0;
    12971306}
    … …  
    12991308static int snd_ice1712_pro_mixer_switch_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
    13001309{
    1301         unsigned long flags;
    13021310        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    13031311        int index = kcontrol->private_value;
    … …  
    13061314        nval = (ucontrol->value.integer.value[0] ? 0 : 0x00008000) |
    13071315               (ucontrol->value.integer.value[1] ? 0 : 0x80000000);
    1308         spin_lock_irqsave(&ice->reg_lock, flags);
     1316        spin_lock_irq(&ice->reg_lock);
    13091317        nval |= ice->pro_volumes[index] & ~0x80008000;
    13101318        change = nval != ice->pro_volumes[index];
    13111319        ice->pro_volumes[index] = nval;
    13121320        snd_ice1712_update_volume(ice, index);
    1313         spin_unlock_irqrestore(&ice->reg_lock, flags);
     1321        spin_unlock_irq(&ice->reg_lock);
    13141322        return change;
    13151323}
    … …  
    13271335{
    13281336        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    1329         unsigned long flags;
    13301337        int index = kcontrol->private_value;
    13311338       
    1332         spin_lock_irqsave(&ice->reg_lock, flags);
     1339        spin_lock_irq(&ice->reg_lock);
    13331340        ucontrol->value.integer.value[0] = (ice->pro_volumes[index] >> 0) & 127;
    13341341        ucontrol->value.integer.value[1] = (ice->pro_volumes[index] >> 16) & 127;
    1335         spin_unlock_irqrestore(&ice->reg_lock, flags);
     1342        spin_unlock_irq(&ice->reg_lock);
    13361343        return 0;
    13371344}
    … …  
    13391346static int snd_ice1712_pro_mixer_volume_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
    13401347{
    1341         unsigned long flags;
    13421348        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    13431349        int index = kcontrol->private_value;
    … …  
    13461352        nval = (ucontrol->value.integer.value[0] & 127) |
    13471353               ((ucontrol->value.integer.value[1] & 127) << 16);
    1348         spin_lock_irqsave(&ice->reg_lock, flags);
     1354        spin_lock_irq(&ice->reg_lock);
    13491355        nval |= ice->pro_volumes[index] & ~0x007f007f;
    13501356        change = nval != ice->pro_volumes[index];
    13511357        ice->pro_volumes[index] = nval;
    13521358        snd_ice1712_update_volume(ice, index);
    1353         spin_unlock_irqrestore(&ice->reg_lock, flags);
     1359        spin_unlock_irq(&ice->reg_lock);
    13541360        return change;
    13551361}
    13561362
    13571363
    1358 static int __init snd_ice1712_build_pro_mixer(ice1712_t *ice)
     1364static int __devinit snd_ice1712_build_pro_mixer(ice1712_t *ice)
    13591365{
    13601366        snd_card_t * card = ice->card;
    … …  
    14361442        int err;
    14371443
    1438         if (!(ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97)) {
     1444        if (ice_has_con_ac97(ice)) {
    14391445                ac97_t ac97;
    14401446                memset(&ac97, 0, sizeof(ac97));
    … …  
    14511457                }
    14521458        }
    1453         /* hmm.. can we have both consumer and pro ac97 mixers? */
    1454         if (! (ice->eeprom.aclink & ICE1712_CFG_PRO_I2S)) {
     1459
     1460        if (! (ice->eeprom.data[ICE_EEP1_ACLINK] & ICE1712_CFG_PRO_I2S)) {
    14551461                ac97_t ac97;
    14561462                memset(&ac97, 0, sizeof(ac97));
    … …  
    14731479 */
    14741480
     1481static inline unsigned int eeprom_double(ice1712_t *ice, int idx)
     1482{
     1483        return (unsigned int)ice->eeprom.data[idx] | ((unsigned int)ice->eeprom.data[idx + 1] << 8);
     1484}
     1485
    14751486static void snd_ice1712_proc_read(snd_info_entry_t *entry,
    14761487                                  snd_info_buffer_t * buffer)
    … …  
    14791490        unsigned int idx;
    14801491
    1481         snd_iprintf(buffer, "ICE1712\n\n");
     1492        snd_iprintf(buffer, "%s\n\n", ice->card->longname);
    14821493        snd_iprintf(buffer, "EEPROM:\n");
     1494
    14831495        snd_iprintf(buffer, "  Subvendor        : 0x%x\n", ice->eeprom.subvendor);
    14841496        snd_iprintf(buffer, "  Size             : %i bytes\n", ice->eeprom.size);
    14851497        snd_iprintf(buffer, "  Version          : %i\n", ice->eeprom.version);
    1486         snd_iprintf(buffer, "  Codec            : 0x%x\n", ice->eeprom.codec);
    1487         snd_iprintf(buffer, "  ACLink           : 0x%x\n", ice->eeprom.aclink);
    1488         snd_iprintf(buffer, "  I2S ID           : 0x%x\n", ice->eeprom.i2sID);
    1489         snd_iprintf(buffer, "  S/PDIF           : 0x%x\n", ice->eeprom.spdif);
     1498        snd_iprintf(buffer, "  Codec            : 0x%x\n", ice->eeprom.data[ICE_EEP1_CODEC]);
     1499        snd_iprintf(buffer, "  ACLink           : 0x%x\n", ice->eeprom.data[ICE_EEP1_ACLINK]);
     1500        snd_iprintf(buffer, "  I2S ID           : 0x%x\n", ice->eeprom.data[ICE_EEP1_I2SID]);
     1501        snd_iprintf(buffer, "  S/PDIF           : 0x%x\n", ice->eeprom.data[ICE_EEP1_SPDIF]);
    14901502        snd_iprintf(buffer, "  GPIO mask        : 0x%x\n", ice->eeprom.gpiomask);
    14911503        snd_iprintf(buffer, "  GPIO state       : 0x%x\n", ice->eeprom.gpiostate);
    14921504        snd_iprintf(buffer, "  GPIO direction   : 0x%x\n", ice->eeprom.gpiodir);
    1493         snd_iprintf(buffer, "  AC'97 main       : 0x%x\n", ice->eeprom.ac97main);
    1494         snd_iprintf(buffer, "  AC'97 pcm        : 0x%x\n", ice->eeprom.ac97pcm);
    1495         snd_iprintf(buffer, "  AC'97 record     : 0x%x\n", ice->eeprom.ac97rec);
    1496         snd_iprintf(buffer, "  AC'97 record src : 0x%x\n", ice->eeprom.ac97recsrc);
     1505        snd_iprintf(buffer, "  AC'97 main       : 0x%x\n", eeprom_double(ice, ICE_EEP1_AC97_MAIN_LO));
     1506        snd_iprintf(buffer, "  AC'97 pcm        : 0x%x\n", eeprom_double(ice, ICE_EEP1_AC97_PCM_LO));
     1507        snd_iprintf(buffer, "  AC'97 record     : 0x%x\n", eeprom_double(ice, ICE_EEP1_AC97_REC_LO));
     1508        snd_iprintf(buffer, "  AC'97 record src : 0x%x\n", ice->eeprom.data[ICE_EEP1_AC97_RECSRC]);
    14971509        for (idx = 0; idx < 4; idx++)
    1498                 snd_iprintf(buffer, "  DAC ID #%i        : 0x%x\n", idx, ice->eeprom.dacID[idx]);
     1510                snd_iprintf(buffer, "  DAC ID #%i        : 0x%x\n", idx, ice->eeprom.data[ICE_EEP1_DAC_ID + idx]);
    14991511        for (idx = 0; idx < 4; idx++)
    1500                 snd_iprintf(buffer, "  ADC ID #%i        : 0x%x\n", idx, ice->eeprom.adcID[idx]);
    1501         for (idx = 0x1c; idx < ice->eeprom.size && idx < 0x1c + sizeof(ice->eeprom.extra); idx++)
    1502                 snd_iprintf(buffer, "  Extra #%02i        : 0x%x\n", idx, ice->eeprom.extra[idx - 0x1c]);
     1512                snd_iprintf(buffer, "  ADC ID #%i        : 0x%x\n", idx, ice->eeprom.data[ICE_EEP1_ADC_ID + idx]);
     1513        for (idx = 0x1c; idx < ice->eeprom.size; idx++)
     1514                snd_iprintf(buffer, "  Extra #%02i        : 0x%x\n", idx, ice->eeprom.data[idx]);
     1515
     1516        snd_iprintf(buffer, "\nRegisters:\n");
     1517        snd_iprintf(buffer, "  PSDOUT03         : 0x%04x\n", (unsigned)inw(ICEMT(ice, ROUTE_PSDOUT03)));
     1518        snd_iprintf(buffer, "  CAPTURE          : 0x%08x\n", inl(ICEMT(ice, ROUTE_CAPTURE)));
     1519        snd_iprintf(buffer, "  SPDOUT           : 0x%04x\n", (unsigned)inw(ICEMT(ice, ROUTE_SPDOUT)));
     1520        snd_iprintf(buffer, "  RATE             : 0x%02x\n", (unsigned)inb(ICEMT(ice, RATE)));
    15031521}
    15041522
    … …  
    15071525        snd_info_entry_t *entry;
    15081526
    1509         if ((entry = snd_info_create_card_entry(ice->card, "ice1712", ice->card->proc_root)) != NULL) {
    1510                 entry->content = SNDRV_INFO_CONTENT_TEXT;
    1511                 entry->private_data = ice;
    1512                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
    1513                 entry->c.text.read_size = 2048;
    1514                 entry->c.text.read = snd_ice1712_proc_read;
    1515                 if (snd_info_register(entry) < 0) {
    1516                         snd_info_free_entry(entry);
    1517                         entry = NULL;
    1518                 }
    1519         }
    1520         ice->proc_entry = entry;
    1521 }
    1522 
    1523 static void snd_ice1712_proc_done(ice1712_t * ice)
    1524 {
    1525         if (ice->proc_entry) {
    1526                 snd_info_unregister(ice->proc_entry);
    1527                 ice->proc_entry = NULL;
    1528         }
     1527        if (! snd_card_proc_new(ice->card, "ice1712", &entry))
     1528                snd_info_set_text_ops(entry, ice, snd_ice1712_proc_read);
    15291529}
    15301530
    … …  
    15361536{
    15371537        uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
    1538         uinfo->count = 32;
     1538        uinfo->count = sizeof(ice1712_eeprom_t);
    15391539        return 0;
    15401540}
    … …  
    15441544        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    15451545       
    1546         memcpy(ucontrol->value.bytes.data, &ice->eeprom, 32);
     1546        memcpy(ucontrol->value.bytes.data, &ice->eeprom, sizeof(ice->eeprom));
    15471547        return 0;
    15481548}
    … …  
    15851585static snd_kcontrol_new_t snd_ice1712_spdif_default __devinitdata =
    15861586{
    1587         .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
    1588         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
     1587        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
     1588        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
    15891589        .info =         snd_ice1712_spdif_info,
    15901590        .get =          snd_ice1712_spdif_default_get,
    … …  
    16361636static snd_kcontrol_new_t snd_ice1712_spdif_maskc __devinitdata =
    16371637{
    1638         .access =               SNDRV_CTL_ELEM_ACCESS_READ,
    1639         .iface =                SNDRV_CTL_ELEM_IFACE_MIXER,
    1640         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
     1638        .access =       SNDRV_CTL_ELEM_ACCESS_READ,
     1639        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
     1640        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
    16411641        .info =         snd_ice1712_spdif_info,
    16421642        .get =          snd_ice1712_spdif_maskc_get,
    … …  
    16451645static snd_kcontrol_new_t snd_ice1712_spdif_maskp __devinitdata =
    16461646{
    1647         .access =               SNDRV_CTL_ELEM_ACCESS_READ,
    1648         .iface =                SNDRV_CTL_ELEM_IFACE_MIXER,
    1649         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
     1647        .access =       SNDRV_CTL_ELEM_ACCESS_READ,
     1648        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
     1649        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
    16501650        .info =         snd_ice1712_spdif_info,
    16511651        .get =          snd_ice1712_spdif_maskp_get,
    … …  
    16721672static snd_kcontrol_new_t snd_ice1712_spdif_stream __devinitdata =
    16731673{
    1674         .access =               SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
    1675         .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
    1676         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
     1674        .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
     1675        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
     1676        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
    16771677        .info =         snd_ice1712_spdif_info,
    16781678        .get =          snd_ice1712_spdif_stream_get,
    … …  
    16941694        unsigned char mask = kcontrol->private_value & 0xff;
    16951695        int invert = (kcontrol->private_value & (1<<24)) ? 1 : 0;
    1696         unsigned char saved[2];
    16971696       
    1698         snd_ice1712_save_gpio_status(ice, saved);
    1699         ucontrol->value.integer.value[0] = (snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & mask ? 1 : 0) ^ invert;
    1700         snd_ice1712_restore_gpio_status(ice, saved);
     1697        snd_ice1712_save_gpio_status(ice);
     1698        ucontrol->value.integer.value[0] = (snd_ice1712_gpio_read(ice) & mask ? 1 : 0) ^ invert;
     1699        snd_ice1712_restore_gpio_status(ice);
    17011700        return 0;
    17021701}
    … …  
    17071706        unsigned char mask = kcontrol->private_value & 0xff;
    17081707        int invert = (kcontrol->private_value & (1<<24)) ? mask : 0;
    1709         unsigned char saved[2];
    1710         int val, nval;
     1708        unsigned int val, nval;
    17111709
    17121710        if (kcontrol->private_value & (1 << 31))
    17131711                return -EPERM;
    17141712        nval = (ucontrol->value.integer.value[0] ? mask : 0) ^ invert;
    1715         snd_ice1712_save_gpio_status(ice, saved);
    1716         val = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
     1713        snd_ice1712_save_gpio_status(ice);
     1714        val = snd_ice1712_gpio_read(ice);
    17171715        nval |= val & ~mask;
    1718         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, nval);
    1719         snd_ice1712_restore_gpio_status(ice, saved);
     1716        if (val != nval)
     1717                snd_ice1712_gpio_write(ice, nval);
     1718        snd_ice1712_restore_gpio_status(ice);
    17201719        return val != nval;
    17211720}
    … …  
    17901789        } else {
    17911790                PRO_RATE_DEFAULT = xrate[ucontrol->value.integer.value[0] % 13];
     1791                spin_unlock_irq(&ice->reg_lock);
    17921792                snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 1);
     1793                spin_lock_irq(&ice->reg_lock);
    17931794        }
    17941795        change = inb(ICEMT(ice, RATE)) != oval;
     1796        spin_unlock_irq(&ice->reg_lock);
    17951797
    17961798        if ((oval & ICE1712_SPDIF_MASTER) != (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER)) {
    … …  
    18001802                }
    18011803                /* notify ak4524 chip as well */
    1802                 if (is_spdif_master(ice) && ice->ak4524.ops.set_rate_val)
    1803                         ice->ak4524.ops.set_rate_val(ice, 0);
     1804                if (is_spdif_master(ice)) {
     1805                        unsigned int i;
     1806                        for (i = 0; i < ice->akm_codecs; i++) {
     1807                                if (ice->akm[i].ops.set_rate_val)
     1808                                        ice->akm[i].ops.set_rate_val(&ice->akm[i], 0);
     1809                        }
     1810                }
    18041811        }
    18051812
    … …  
    19061913        int idx = kcontrol->id.index;
    19071914        unsigned int val, cval;
     1915
     1916        spin_lock_irq(&ice->reg_lock);
    19081917        val = inw(ICEMT(ice, ROUTE_PSDOUT03));
     1918        cval = inl(ICEMT(ice, ROUTE_CAPTURE));
     1919        spin_unlock_irq(&ice->reg_lock);
     1920
    19091921        val >>= ((idx % 2) * 8) + ((idx / 2) * 2);
    19101922        val &= 3;
    1911         cval = inl(ICEMT(ice, ROUTE_CAPTURE));
    19121923        cval >>= ((idx / 2) * 8) + ((idx % 2) * 4);
    19131924        if (val == 1 && idx < 2)
    … …  
    19391950                nval = 0; /* pcm */
    19401951        shift = ((idx % 2) * 8) + ((idx / 2) * 2);
     1952        spin_lock_irq(&ice->reg_lock);
    19411953        val = old_val = inw(ICEMT(ice, ROUTE_PSDOUT03));
    19421954        val &= ~(0x03 << shift);
    … …  
    19451957        if (change)
    19461958                outw(val, ICEMT(ice, ROUTE_PSDOUT03));
     1959        spin_unlock_irq(&ice->reg_lock);
    19471960        if (nval < 2) /* dig mixer of pcm */
    19481961                return change;
    19491962
    19501963        /* update CAPTURE */
     1964        spin_lock_irq(&ice->reg_lock);
    19511965        val = old_val = inl(ICEMT(ice, ROUTE_CAPTURE));
    19521966        shift = ((idx / 2) * 8) + ((idx % 2) * 4);
    … …  
    19641978                outl(val, ICEMT(ice, ROUTE_CAPTURE));
    19651979        }
     1980        spin_unlock_irq(&ice->reg_lock);
    19661981        return change;
    19671982}
    … …  
    19942009       
    19952010        /* update SPDOUT */
     2011        spin_lock_irq(&ice->reg_lock);
    19962012        val = old_val = inw(ICEMT(ice, ROUTE_SPDOUT));
    19972013        if (ucontrol->value.enumerated.item[0] >= 11)
    … …  
    20192035        if (change)
    20202036                outw(val, ICEMT(ice, ROUTE_SPDOUT));
     2037        spin_unlock_irq(&ice->reg_lock);
    20212038        return change;
    20222039}
    … …  
    20512068{
    20522069        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    2053         unsigned long flags;
    20542070       
    2055         spin_lock_irqsave(&ice->reg_lock, flags);
    20562071        ucontrol->value.integer.value[0] = inb(ICEMT(ice, MONITOR_RATE));
    2057         spin_unlock_irqrestore(&ice->reg_lock, flags);
    20582072        return 0;
    20592073}
    … …  
    20612075static int snd_ice1712_pro_volume_rate_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
    20622076{
    2063         unsigned long flags;
    20642077        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    20652078        int change;
    20662079
    2067         spin_lock_irqsave(&ice->reg_lock, flags);
     2080        spin_lock_irq(&ice->reg_lock);
    20682081        change = inb(ICEMT(ice, MONITOR_RATE)) != ucontrol->value.integer.value[0];
    20692082        outb(ucontrol->value.integer.value[0], ICEMT(ice, MONITOR_RATE));
    2070         spin_unlock_irqrestore(&ice->reg_lock, flags);
     2083        spin_unlock_irq(&ice->reg_lock);
    20712084        return change;
    20722085}
    … …  
    20922105{
    20932106        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    2094         unsigned long flags;
    20952107        int idx;
    20962108       
    2097         spin_lock_irqsave(&ice->reg_lock, flags);
     2109        spin_lock_irq(&ice->reg_lock);
    20982110        for (idx = 0; idx < 22; idx++) {
    20992111                outb(idx, ICEMT(ice, MONITOR_PEAKINDEX));
    21002112                ucontrol->value.integer.value[idx] = inb(ICEMT(ice, MONITOR_PEAKDATA));
    21012113        }
    2102         spin_unlock_irqrestore(&ice->reg_lock, flags);
     2114        spin_unlock_irq(&ice->reg_lock);
    21032115        return 0;
    21042116}
    … …  
    21312143{
    21322144        int dev = 0xa0;         /* EEPROM device address */
    2133         unsigned int idx;
     2145        unsigned int i;
    21342146
    21352147        if ((inb(ICEREG(ice, I2C_CTRL)) & ICE1712_I2C_EEPROM) == 0) {
    … …  
    21422154                                (snd_ice1712_read_i2c(ice, dev, 0x03) << 24);
    21432155        ice->eeprom.size = snd_ice1712_read_i2c(ice, dev, 0x04);
    2144         if (ice->eeprom.size < 28) {
     2156        if (ice->eeprom.size > 32) {
    21452157                snd_printk("invalid EEPROM (size = %i)\n", ice->eeprom.size);
    21462158                return -EIO;
    … …  
    21492161        if (ice->eeprom.version != 1) {
    21502162                snd_printk("invalid EEPROM version %i\n", ice->eeprom.version);
    2151                 return -EIO;
    2152         }
    2153         ice->eeprom.codec = snd_ice1712_read_i2c(ice, dev, 0x06);
    2154         ice->eeprom.aclink = snd_ice1712_read_i2c(ice, dev, 0x07);
    2155         ice->eeprom.i2sID = snd_ice1712_read_i2c(ice, dev, 0x08);
    2156         ice->eeprom.spdif = snd_ice1712_read_i2c(ice, dev, 0x09);
    2157         ice->eeprom.gpiomask = snd_ice1712_read_i2c(ice, dev, 0x0a);
    2158         ice->eeprom.gpiostate = snd_ice1712_read_i2c(ice, dev, 0x0b);
    2159         ice->eeprom.gpiodir = snd_ice1712_read_i2c(ice, dev, 0x0c);
    2160         ice->eeprom.ac97main = (snd_ice1712_read_i2c(ice, dev, 0x0d) << 0) |
    2161                                (snd_ice1712_read_i2c(ice, dev, 0x0e) << 8);
    2162         ice->eeprom.ac97pcm = (snd_ice1712_read_i2c(ice, dev, 0x0f) << 0) |
    2163                               (snd_ice1712_read_i2c(ice, dev, 0x10) << 8);
    2164         ice->eeprom.ac97rec = (snd_ice1712_read_i2c(ice, dev, 0x11) << 0) |
    2165                               (snd_ice1712_read_i2c(ice, dev, 0x12) << 8);
    2166         ice->eeprom.ac97recsrc = snd_ice1712_read_i2c(ice, dev, 0x13) << 0;
    2167         for (idx = 0; idx < 4; idx++) {
    2168                 ice->eeprom.dacID[idx] = snd_ice1712_read_i2c(ice, dev, 0x14 + idx);
    2169                 ice->eeprom.adcID[idx] = snd_ice1712_read_i2c(ice, dev, 0x18 + idx);
    2170         }
    2171         for (idx = 0x1c; idx < ice->eeprom.size && idx < 0x1c + sizeof(ice->eeprom.extra); idx++)
    2172                 ice->eeprom.extra[idx - 0x1c] = snd_ice1712_read_i2c(ice, dev, idx);
     2163                /* return -EIO; */
     2164        }
     2165        for (i = 0; i < ice->eeprom.size; i++)
     2166                ice->eeprom.data[i] = snd_ice1712_read_i2c(ice, dev, i + 6);
     2167
     2168        ice->eeprom.gpiomask = ice->eeprom.data[ICE_EEP1_GPIO_MASK];
     2169        ice->eeprom.gpiostate = ice->eeprom.data[ICE_EEP1_GPIO_STATE];
     2170        ice->eeprom.gpiodir = ice->eeprom.data[ICE_EEP1_GPIO_DIR];
     2171
    21732172        return 0;
    21742173}
    … …  
    21822181        outb(ICE1712_NATIVE, ICEREG(ice, CONTROL));
    21832182        udelay(200);
    2184         pci_write_config_byte(ice->pci, 0x60, ice->eeprom.codec);
    2185         pci_write_config_byte(ice->pci, 0x61, ice->eeprom.aclink);
    2186         pci_write_config_byte(ice->pci, 0x62, ice->eeprom.i2sID);
    2187         pci_write_config_byte(ice->pci, 0x63, ice->eeprom.spdif);
     2183        pci_write_config_byte(ice->pci, 0x60, ice->eeprom.data[ICE_EEP1_CODEC]);
     2184        pci_write_config_byte(ice->pci, 0x61, ice->eeprom.data[ICE_EEP1_ACLINK]);
     2185        pci_write_config_byte(ice->pci, 0x62, ice->eeprom.data[ICE_EEP1_I2SID]);
     2186        pci_write_config_byte(ice->pci, 0x63, ice->eeprom.data[ICE_EEP1_SPDIF]);
    21882187        if (ice->eeprom.subvendor != ICE1712_SUBDEVICE_STDSP24) {
    2189                 ice->gpio_write_mask = ice->eeprom.gpiomask;
    2190                 ice->gpio_direction = ice->eeprom.gpiodir;
     2188                ice->gpio.write_mask = ice->eeprom.gpiomask;
     2189                ice->gpio.direction = ice->eeprom.gpiodir;
    21912190                snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ice->eeprom.gpiomask);
    21922191                snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->eeprom.gpiodir);
    21932192                snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, ice->eeprom.gpiostate);
    21942193        } else {
    2195                 ice->gpio_write_mask = 0xc0;
    2196                 ice->gpio_direction = 0xff;
     2194                ice->gpio.write_mask = 0xc0;
     2195                ice->gpio.direction = 0xff;
    21972196                snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, 0xc0);
    21982197                snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, 0xff);
    … …  
    22002199        }
    22012200        snd_ice1712_write(ice, ICE1712_IREG_PRO_POWERDOWN, 0);
    2202         if (!(ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97)) {
     2201        if (!(ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97)) {
    22032202                outb(ICE1712_AC97_WARM, ICEREG(ice, AC97_CMD));
    22042203                udelay(100);
    … …  
    22102209        return 0;
    22112210}
    2212 
    22132211
    22142212int __devinit snd_ice1712_spdif_build_controls(ice1712_t *ice)
    … …  
    22512249        if (err < 0)
    22522250                return err;
     2251
    22532252        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_rate_locking, ice));
    22542253        if (err < 0)
    … …  
    22572256        if (err < 0)
    22582257                return err;
     2258
    22592259        for (idx = 0; idx < ice->num_total_dacs; idx++) {
    22602260                kctl = snd_ctl_new1(&snd_ice1712_mixer_pro_analog_route, ice);
    … …  
    22662266                        return err;
    22672267        }
     2268
    22682269        for (idx = 0; idx < 2; idx++) {
    22692270                kctl = snd_ctl_new1(&snd_ice1712_mixer_pro_spdif_route, ice);
    … …  
    22752276                        return err;
    22762277        }
     2278
    22772279        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_pro_volume_rate, ice));
    22782280        if (err < 0)
    … …  
    22812283        if (err < 0)
    22822284                return err;
     2285
    22832286        return 0;
    22842287}
    … …  
    22932296        /* --- */
    22942297      __hw_end:
    2295         snd_ice1712_proc_done(ice);
    22962298        if (ice->irq >= 0) {
    22972299                synchronize_irq(ice->irq);
    … …  
    23142316                kfree_nocheck(ice->res_profi_port);
    23152317        }
     2318        if (ice->akm)
     2319                kfree(ice->akm);
    23162320        snd_magic_kfree(ice);
    23172321        return 0;
    … …  
    23532357        spin_lock_init(&ice->reg_lock);
    23542358        init_MUTEX(&ice->gpio_mutex);
     2359        ice->gpio.set_mask = snd_ice1712_set_gpio_mask;
     2360        ice->gpio.set_dir = snd_ice1712_set_gpio_dir;
     2361        ice->gpio.set_data = snd_ice1712_set_gpio_data;
     2362        ice->gpio.get_data = snd_ice1712_get_gpio_data;
     2363
    23552364        ice->spdif.cs8403_bits =
    23562365                ice->spdif.cs8403_stream_bits = (0x01 | /* consumer format */
    … …  
    23952404                return -EIO;
    23962405        }
     2406       
    23972407        ice->irq = pci->irq;
    23982408
    … …  
    24072417
    24082418        /* unmask used interrupts */
    2409         outb((ice->eeprom.codec & ICE1712_CFG_2xMPU401) == 0 ? ICE1712_IRQ_MPU2 : 0 |
    2410              (ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97) ? ICE1712_IRQ_PBKDS | ICE1712_IRQ_CONCAP | ICE1712_IRQ_CONPBK : 0,
     2419        outb((ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_2xMPU401) == 0 ? ICE1712_IRQ_MPU2 : 0 |
     2420             (ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97) ? ICE1712_IRQ_PBKDS | ICE1712_IRQ_CONCAP | ICE1712_IRQ_CONPBK : 0,
    24112421             ICEREG(ice, IRQMASK));
    24122422        outb(0x00, ICEMT(ice, IRQ));
    … …  
    24882498        }
    24892499       
    2490         if (!(ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97))
     2500        if (ice_has_con_ac97(ice))
    24912501                if ((err = snd_ice1712_pcm(ice, pcm_dev++, NULL)) < 0) {
    24922502                        snd_card_free(card);
    … …  
    25112521        }
    25122522
    2513         if (!(ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97))
     2523        if (ice_has_con_ac97(ice))
    25142524                if ((err = snd_ice1712_pcm_ds(ice, pcm_dev++, NULL)) < 0) {
    25152525                        snd_card_free(card);
    … …  
    25262536        }
    25272537
    2528         if (ice->eeprom.codec & ICE1712_CFG_2xMPU401)
     2538                if (ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_2xMPU401)
    25292539                if ((err = snd_mpu401_uart_new(card, 1, MPU401_HW_ICE1712,
    25302540                                               ICEREG(ice, MPU2_CTRL), 1,

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1712.h

    r215 r224  
    215215
    216216typedef struct _snd_ice1712 ice1712_t;
    217 typedef struct snd_ak4524 ak4524_t;
     217typedef struct snd_ak4xxx akm4xxx_t;
    218218
    219219typedef struct {
    220220        unsigned int subvendor; /* PCI[2c-2f] */
    221221        unsigned char size;     /* size of EEPROM image in bytes */
    222         unsigned char version;  /* must be 1 */
    223         unsigned char codec;    /* codec configuration PCI[60] */
    224         unsigned char aclink;   /* ACLink configuration PCI[61] */
    225         unsigned char i2sID;    /* PCI[62] */
    226         unsigned char spdif;    /* S/PDIF configuration PCI[63] */
    227         unsigned char gpiomask; /* GPIO initial mask, 0 = write, 1 = don't */
    228         unsigned char gpiostate; /* GPIO initial state */
    229         unsigned char gpiodir;  /* GPIO direction state */
    230         unsigned short ac97main;
    231         unsigned short ac97pcm;
    232         unsigned short ac97rec;
    233         unsigned char ac97recsrc;
    234         unsigned char dacID[4]; /* I2S IDs for DACs */
    235         unsigned char adcID[4]; /* I2S IDs for ADCs */
    236         unsigned char extra[4];
     222        unsigned char version;  /* must be 1 (or 2 for vt1724) */
     223        unsigned char data[32];
     224        unsigned int gpiomask;
     225        unsigned int gpiostate;
     226        unsigned int gpiodir;
    237227} ice1712_eeprom_t;
    238228
    239 struct snd_ak4524 {
    240         int num_adcs;                   /* AK4524 or AK4528 ADCs */
    241         int num_dacs;                   /* AK4524 or AK4528 DACs */
    242         unsigned char images[4][16];
    243         unsigned char ipga_gain[4][2];
    244         /* */
     229enum {
     230        ICE_EEP1_CODEC = 0,     /* 06 */
     231        ICE_EEP1_ACLINK,        /* 07 */
     232        ICE_EEP1_I2SID,         /* 08 */
     233        ICE_EEP1_SPDIF,         /* 09 */
     234        ICE_EEP1_GPIO_MASK,     /* 0a */
     235        ICE_EEP1_GPIO_STATE,    /* 0b */
     236        ICE_EEP1_GPIO_DIR,      /* 0c */
     237        ICE_EEP1_AC97_MAIN_LO,  /* 0d */
     238        ICE_EEP1_AC97_MAIN_HI,  /* 0e */
     239        ICE_EEP1_AC97_PCM_LO,   /* 0f */
     240        ICE_EEP1_AC97_PCM_HI,   /* 10 */
     241        ICE_EEP1_AC97_REC_LO,   /* 11 */
     242        ICE_EEP1_AC97_REC_HI,   /* 12 */
     243        ICE_EEP1_AC97_RECSRC,   /* 13 */
     244        ICE_EEP1_DAC_ID,        /* 14 */
     245        ICE_EEP1_DAC_ID1,
     246        ICE_EEP1_DAC_ID2,
     247        ICE_EEP1_DAC_ID3,
     248        ICE_EEP1_ADC_ID,        /* 18 */
     249        ICE_EEP1_ADC_ID1,
     250        ICE_EEP1_ADC_ID2,
     251        ICE_EEP1_ADC_ID3
     252};
     253       
     254#define ice_has_con_ac97(ice)   (!((ice)->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97))
     255
     256
     257struct snd_ak4xxx {
     258        unsigned int num_adcs;          /* AK4524 or AK4528 ADCs */
     259        unsigned int num_dacs;          /* AK4524 or AK4528 DACs */
     260        unsigned char images[4][16];    /* saved register image */
     261        unsigned char ipga_gain[4][2];  /* saved register image for IPGA (AK4528) */
     262        ice1712_t *chip;
     263        /* template should fill the following fields */
     264        unsigned int idx_offset;        /* control index offset */
    245265        enum {
    246                 SND_AK4524, SND_AK4528, SND_AK4529
     266                SND_AK4524, SND_AK4528, SND_AK4529, SND_AK4355, SND_AK4381
    247267        } type;
    248         unsigned int cif: 1;
    249         unsigned char data_mask;
    250         unsigned char clk_mask;
    251         unsigned char cs_mask;
    252         unsigned char cs_addr;
    253         unsigned char cs_none;
    254         unsigned char add_flags;
    255         unsigned char mask_flags;
    256         struct snd_ak4524_ops {
    257                 int (*start)(ice1712_t *, unsigned char *, int);
    258                 void (*stop)(ice1712_t *, unsigned char *);
    259                 void (*set_rate_val)(ice1712_t *, unsigned int);
     268        unsigned int cif: 1;            /* CIF mode */
     269        unsigned char caddr;            /* C0 and C1 bits */
     270        unsigned int data_mask;         /* DATA gpio bit */
     271        unsigned int clk_mask;          /* CLK gpio bit */
     272        unsigned int cs_mask;           /* bit mask for select/deselect address */
     273        unsigned int cs_addr;           /* bits to select address */
     274        unsigned int cs_none;           /* bits to deselect address */
     275        unsigned int add_flags;         /* additional bits at init */
     276        unsigned int mask_flags;        /* total mask bits */
     277        struct snd_akm4xxx_ops {
     278                int (*start)(akm4xxx_t *ak, int chip);
     279                void (*stop)(akm4xxx_t *ak);
     280                void (*set_rate_val)(akm4xxx_t *ak, unsigned int rate);
    260281        } ops;
    261282};
    … …  
    268289        struct snd_ice1712_spdif_ops {
    269290                void (*open)(ice1712_t *, snd_pcm_substream_t *);
    270                 void (*setup)(ice1712_t *, snd_pcm_substream_t *);
     291                void (*setup_rate)(ice1712_t *, int rate);
    271292                void (*close)(ice1712_t *, snd_pcm_substream_t *);
    272293                void (*default_get)(ice1712_t *, snd_ctl_elem_value_t * ucontrol);
    … …  
    293314        unsigned long profi_port;
    294315        struct resource *res_profi_port;
    295 
    296         unsigned int config;    /* system configuration */
    297316
    298317        struct pci_dev *pci;
    … …  
    316335
    317336        spinlock_t reg_lock;
    318         struct semaphore gpio_mutex;
    319337        snd_info_entry_t *proc_entry;
    320338
    … …  
    322340
    323341        unsigned int pro_volumes[20];
    324         int omni: 1;                    /* Delta Omni I/O */
    325         int num_total_dacs;             /* total DACs */
     342        unsigned int omni: 1;           /* Delta Omni I/O */
     343        unsigned int vt1724: 1;
     344        unsigned int num_total_dacs;    /* total DACs */
    326345        unsigned char hoontech_boxbits[4];
    327346        unsigned int hoontech_config;
    328347        unsigned short hoontech_boxconfig[4];
    329 
    330         struct snd_ak4524 ak4524;
     348        unsigned int cur_rate;          /* current rate */
     349
     350        unsigned int akm_codecs;
     351        akm4xxx_t *akm;
    331352        struct snd_ice1712_spdif spdif;
    332353
    … …  
    336357        snd_i2c_device_t *i2cdevs[2];   /* additional i2c devices */
    337358       
    338         unsigned char gpio_direction, gpio_write_mask;
     359        struct ice1712_gpio {
     360                unsigned int direction;         /* current direction bits */
     361                unsigned int write_mask;        /* current mask bits */
     362                unsigned int saved[2];          /* for ewx_i2c */
     363                /* operators */
     364                void (*set_mask)(ice1712_t *ice, unsigned int data);
     365                void (*set_dir)(ice1712_t *ice, unsigned int data);
     366                void (*set_data)(ice1712_t *ice, unsigned int data);
     367                unsigned int (*get_data)(ice1712_t *ice);
     368        } gpio;
     369        struct semaphore gpio_mutex;
    339370};
    340371
    … …  
    342373
    343374
     375/*
     376 * gpio access functions
     377 */
     378static inline void snd_ice1712_gpio_set_dir(ice1712_t *ice, unsigned int bits)
     379{
     380        ice->gpio.set_dir(ice, bits);
     381}
     382
     383static inline void snd_ice1712_gpio_set_mask(ice1712_t *ice, unsigned int bits)
     384{
     385        ice->gpio.set_mask(ice, bits);
     386}
     387
     388static inline void snd_ice1712_gpio_write(ice1712_t *ice, unsigned int val)
     389{
     390        ice->gpio.set_data(ice, val);
     391}
     392
     393static inline unsigned int snd_ice1712_gpio_read(ice1712_t *ice)
     394{
     395        return ice->gpio.get_data(ice);
     396}
     397
     398/*
     399 * save and restore gpio status
     400 * The access to gpio will be protected by mutex, so don't forget to
     401 * restore!
     402 */
     403static inline void snd_ice1712_save_gpio_status(ice1712_t *ice)
     404{
     405        down(&ice->gpio_mutex);
     406        ice->gpio.saved[0] = ice->gpio.direction;
     407        ice->gpio.saved[1] = ice->gpio.write_mask;
     408}
     409
     410static inline void snd_ice1712_restore_gpio_status(ice1712_t *ice)
     411{
     412        ice->gpio.set_dir(ice, ice->gpio.saved[0]);
     413        ice->gpio.set_mask(ice, ice->gpio.saved[1]);
     414        ice->gpio.direction = ice->gpio.saved[0];
     415        ice->gpio.write_mask = ice->gpio.saved[1];
     416        up(&ice->gpio_mutex);
     417}
     418
     419/* for bit controls */
    344420#define ICE1712_GPIO(xiface, xname, xindex, mask, invert, xaccess) \
    345421{ .iface = xiface, .name = xname, .access = xaccess, .info = snd_ice1712_gpio_info, \
    … …  
    351427int snd_ice1712_gpio_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
    352428
    353 void snd_ice1712_gpio_write_bits(ice1712_t *ice, int mask, int bits);
    354 void snd_ice1712_save_gpio_status(ice1712_t *ice, unsigned char *tmp);
    355 void snd_ice1712_restore_gpio_status(ice1712_t *ice, unsigned char *tmp);
    356 
     429/*
     430 * set gpio direction, write mask and data
     431 */
     432static inline void snd_ice1712_gpio_write_bits(ice1712_t *ice, unsigned int mask, unsigned int bits)
     433{
     434        ice->gpio.direction |= mask;
     435        snd_ice1712_gpio_set_dir(ice, ice->gpio.direction);
     436        snd_ice1712_gpio_set_mask(ice, ~mask);
     437        snd_ice1712_gpio_write(ice, mask & bits);
     438}
    357439
    358440int snd_ice1712_spdif_build_controls(ice1712_t *ice);
    359441
    360 void snd_ice1712_ak4524_write(ice1712_t *ice, int chip, unsigned char addr, unsigned char data);
    361 void snd_ice1712_ak4524_reset(ice1712_t *ice, int state);
    362 void snd_ice1712_ak4524_init(ice1712_t *ice);
    363 int snd_ice1712_ak4524_build_controls(ice1712_t *ice);
     442void snd_ice1712_akm4xxx_write(akm4xxx_t *ice, int chip, unsigned char addr, unsigned char data);
     443void snd_ice1712_akm4xxx_reset(akm4xxx_t *ice, int state);
     444void snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *template, ice1712_t *ice);
     445int snd_ice1712_akm4xxx_build_controls(ice1712_t *ice);
    364446
    365447int snd_ice1712_init_cs8427(ice1712_t *ice, int addr);

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/makefile.os2

    r212 r224  
    1414#===================================================================
    1515FILE1    = ak4524.obj delta.obj ews.obj hoontech.obj ice1712.obj
    16 FILE2    =
     16FILE2    = ice1724.obj revo.obj
    1717FILE3    =
    1818FILE4    =

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/korg1212/korg1212.c

    r212 r224  
    2121
    2222#include <sound/driver.h>
    23 #include <asm/io.h>
    2423#include <linux/delay.h>
    2524#include <linux/init.h>
     25#include <linux/interrupt.h>
    2626#include <linux/pci.h>
    2727#include <linux/slab.h>
     28#include <linux/wait.h>
     29
    2830#include <sound/core.h>
    2931#include <sound/info.h>
    … …  
    3436#include <sound/initval.h>
    3537
     38#include <asm/io.h>
     39
    3640// ----------------------------------------------------------------------------
    3741// Debug Stuff
    … …  
    3943#define K1212_DEBUG_LEVEL               0
    4044#define K1212_DEBUG_PRINTK              printk
     45//#define K1212_DEBUG_PRINTK(x...)      printk("<0>" x)
    4146
    4247// ----------------------------------------------------------------------------
    … …  
    175180#define kPlayBufferFrames       1024
    176181
    177 #define K1212_CHANNELS          16
     182#define K1212_ANALOG_CHANNELS   2
     183#define K1212_SPDIF_CHANNELS    2
     184#define K1212_ADAT_CHANNELS     8
     185#define K1212_CHANNELS          (K1212_ADAT_CHANNELS + K1212_ANALOG_CHANNELS)
     186#define K1212_MIN_CHANNELS      1
     187#define K1212_MAX_CHANNELS      K1212_CHANNELS
    178188#define K1212_FRAME_SIZE        (sizeof(KorgAudioFrame))
    179189#define K1212_MAX_SAMPLES       (kPlayBufferFrames*kNumBuffers)
    180 #define K1212_PERIODS           (K1212_BUF_SIZE/K1212_BLOCK_SIZE)
    181 #define K1212_PERIOD_BYTES      (K1212_BLOCK_SIZE)
    182 #define K1212_BLOCK_SIZE        (K1212_FRAME_SIZE*kPlayBufferFrames)
    183 #define K1212_BUF_SIZE          (K1212_BLOCK_SIZE*kNumBuffers)
     190#define K1212_PERIODS           (kNumBuffers)
     191#define K1212_PERIOD_BYTES      (K1212_FRAME_SIZE*kPlayBufferFrames)
     192#define K1212_BUF_SIZE          (K1212_PERIOD_BYTES*kNumBuffers)
     193#define K1212_ANALOG_BUF_SIZE   (K1212_ANALOG_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)
     194#define K1212_SPDIF_BUF_SIZE    (K1212_SPDIF_CHANNELS * 3 * kPlayBufferFrames * kNumBuffers)
     195#define K1212_ADAT_BUF_SIZE     (K1212_ADAT_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)
     196#define K1212_MAX_BUF_SIZE      (K1212_ANALOG_BUF_SIZE + K1212_ADAT_BUF_SIZE)
    184197
    185198#define k1212MinADCSens     0x7f
    … …  
    311324
    312325struct _snd_korg1212 {
     326        snd_card_t *card;
    313327        struct pci_dev *pci;
    314         snd_card_t *card;
    315         snd_pcm_t *pcm16;
     328        snd_pcm_t *pcm;
    316329        int irq;
    317330
    … …  
    359372        u32 * idRegPtr;              // address of the device and vendor ID registers
    360373
    361 
    362374        size_t periodsize;
    363         size_t currentBuffer;
     375        int channels;
     376        int currentBuffer;
    364377
    365378        snd_pcm_substream_t *playback_substream;
    366379        snd_pcm_substream_t *capture_substream;
    367         snd_info_entry_t * proc_entry;
    368380
    369381        CardState cardState;
    … …  
    381393        u16 leftADCInSens;           // ADC left channel input sensitivity
    382394        u16 rightADCInSens;          // ADC right channel input sensitivity
     395
     396        int opencnt;                    // Open/Close count
     397        int setcnt;                     // SetupForPlay count
     398        int playcnt;                    // TriggerPlay count
     399
    383400};
    384401
    … …  
    404421
    405422static struct pci_device_id snd_korg1212_ids[] __devinitdata = {
    406         { 0x10b5, 0x906d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
    407         { 0, }
     423        {
     424                .vendor    = 0x10b5,
     425                .device    = 0x906d,
     426                .subvendor = PCI_ANY_ID,
     427                .subdevice = PCI_ANY_ID,
     428        },
     429        { 0, },
    408430};
    409431
    … …  
    456478                            };
    457479
    458 snd_korg1212rc rc;
    459 
     480static snd_korg1212rc rc;
    460481
    461482MODULE_DEVICE_TABLE(pci, snd_korg1212_ids);
    … …  
    514535#endif /* not used */
    515536
    516 void TickDelay(int time)
    517 {
    518         udelay(time);
    519 }
    520 
    521537#define SetBitInWord(theWord,bitPosition)       (*theWord) |= (0x0001 << bitPosition)
    522538#define SetBitInDWord(theWord,bitPosition)      (*theWord) |= (0x00000001 << bitPosition)
    … …  
    529545        u32 retryCount;
    530546        u16 mailBox3Lo;
    531 
    532         if (korg1212->outDoorbellPtr) {
     547        snd_korg1212rc rc = K1212_CMDRET_Success;
     548
     549        if (!korg1212->outDoorbellPtr) {
     550#if K1212_DEBUG_LEVEL > 1
     551                K1212_DEBUG_PRINTK("K1212_DEBUG: CardUninitialized\n");
     552#endif
     553                return K1212_CMDRET_CardUninitialized;
     554        }
     555
    533556#if K1212_DEBUG_LEVEL > 0
    534557                K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- 0x%08x 0x%08x [%s]\n", doorbellVal, mailBox0Val, stateName[korg1212->cardState]);
    535558#endif
    536559                for (retryCount = 0; retryCount < MAX_COMMAND_RETRIES; retryCount++) {
    537 
    538560                        writel(mailBox3Val, korg1212->mailbox3Ptr);
    539561                        writel(mailBox2Val, korg1212->mailbox2Ptr);
    … …  
    545567                        // the reboot command will not give an acknowledgement.
    546568                        // --------------------------------------------------------------
    547                         switch (doorbellVal) {
    548                                 case K1212_DB_RebootCard:
    549                                 case K1212_DB_BootFromDSPPage4:
    550                                 case K1212_DB_StartDSPDownload:
    551                                         return K1212_CMDRET_Success;
    552                                 default:
     569                if ( doorbellVal == K1212_DB_RebootCard ||
     570                        doorbellVal == K1212_DB_BootFromDSPPage4 ||
     571                        doorbellVal == K1212_DB_StartDSPDownload ) {
     572                        rc = K1212_CMDRET_Success;
    553573                                        break;
    554574                        }
    … …  
    559579                        // low byte is equal to the doorbell value, then it ack'd.
    560580                        // --------------------------------------------------------------
    561                         TickDelay(COMMAND_ACK_DELAY);
     581                udelay(COMMAND_ACK_DELAY);
    562582                        mailBox3Lo = readl(korg1212->mailbox3Ptr);
    563583                        if (mailBox3Lo & COMMAND_ACK_MASK) {
    564584                                if ((mailBox3Lo & DOORBELL_VAL_MASK) == (doorbellVal & DOORBELL_VAL_MASK)) {
    565                                         korg1212->cmdRetryCount += retryCount;
    566                                         return K1212_CMDRET_Success;
    567                                 }
     585#if K1212_DEBUG_LEVEL > 1
     586                                K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- Success\n");
     587#endif
     588                                rc = K1212_CMDRET_Success;
     589                                break;
    568590                        }
    569591                }
    570                 korg1212->cmdRetryCount += retryCount;
    571                 return K1212_CMDRET_NoAckFromCard;
    572         } else {
    573                 return K1212_CMDRET_CardUninitialized;
    574         }
     592        }
     593                                        korg1212->cmdRetryCount += retryCount;
     594
     595        if (retryCount >= MAX_COMMAND_RETRIES) {
     596#if K1212_DEBUG_LEVEL > 1
     597                K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- NoAckFromCard\n");
     598#endif
     599                rc = K1212_CMDRET_NoAckFromCard;
     600        }
     601
     602        return rc;
    575603}
    576604
    577605static void snd_korg1212_WaitForCardStopAck(korg1212_t *korg1212)
    578606{
    579         unsigned long endtime = jiffies + 20 * HZ;
    580 
    581 #if K1212_DEBUG_LEVEL > 0
    582         K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck [%s]\n", stateName[korg1212->cardState]);
     607        u32 endtime = jiffies + 2 * HZ;
     608
     609#if K1212_DEBUG_LEVEL > 0
     610        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck.in [%s] %lu %lu\n", stateName[korg1212->cardState], jiffies, korg1212->inIRQ);
    583611#endif
    584612
    … …  
    587615
    588616        do {
    589                 if (readl(&korg1212->sharedBufferPtr->cardCommand) == 0)
     617                if (readl(&korg1212->sharedBufferPtr->cardCommand) == 0) {
     618#if K1212_DEBUG_LEVEL > 0
     619                        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck.out [%s] %lu %lu\n", stateName[korg1212->cardState], jiffies, korg1212->inIRQ);
     620#endif
    590621                        return;
     622                }
    591623                if (!korg1212->inIRQ)
    592624                        schedule();
    593         } while (jiffies < endtime);
    594 
     625        } while (time_before(jiffies, endtime));
     626
     627#if K1212_DEBUG_LEVEL > 0
     628        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck.out TO [%s] %lu %lu\n", stateName[korg1212->cardState], jiffies, korg1212->inIRQ);
     629#endif
    595630        writel(0, &korg1212->sharedBufferPtr->cardCommand);
    596631}
    … …  
    598633static void snd_korg1212_TurnOnIdleMonitor(korg1212_t *korg1212)
    599634{
    600         TickDelay(INTERCOMMAND_DELAY);
     635        udelay(INTERCOMMAND_DELAY);
    601636        korg1212->idleMonitorOn = 1;
    602637        rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
    … …  
    634669{
    635670#if K1212_DEBUG_LEVEL > 0
    636         K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s]\n", stateName[korg1212->cardState]);
    637 #endif
     671        K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n", stateName[korg1212->cardState], korg1212->opencnt);
     672#endif
     673        if (korg1212->opencnt++ == 0)
    638674        snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
    639675        return 1;
    … …  
    643679{
    644680#if K1212_DEBUG_LEVEL > 0
    645         K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s]\n", stateName[korg1212->cardState]);
    646 #endif
     681        K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s] %d\n", stateName[korg1212->cardState], korg1212->opencnt);
     682#endif
     683
     684        if (--(korg1212->opencnt))
     685                return 0;
    647686
    648687        if (korg1212->cardState == K1212_STATE_SETUP) {
    … …  
    669708{
    670709#if K1212_DEBUG_LEVEL > 0
    671         K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s]\n", stateName[korg1212->cardState]);
    672 #endif
     710        K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->setcnt);
     711#endif
     712
     713        if (korg1212->setcnt++)
     714                return 0;
    673715
    674716        snd_korg1212_setCardState(korg1212, K1212_STATE_SETUP);
    … …  
    680722#endif
    681723        if (rc != K1212_CMDRET_Success) {
    682                 return 0;
    683         }
    684724        return 1;
    685725}
     726        return 0;
     727}
    686728
    687729static int snd_korg1212_TriggerPlay(korg1212_t * korg1212)
    688730{
    689731#if K1212_DEBUG_LEVEL > 0
    690         K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s]\n", stateName[korg1212->cardState]);
    691 #endif
     732        K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->playcnt);
     733#endif
     734
     735        if (korg1212->playcnt++)
     736                return 0;
    692737
    693738        snd_korg1212_setCardState(korg1212, K1212_STATE_PLAYING);
    … …  
    699744
    700745        if (rc != K1212_CMDRET_Success) {
    701                 return 0;
    702         }
    703746        return 1;
    704747}
     748        return 0;
     749}
    705750
    706751static int snd_korg1212_StopPlay(korg1212_t * korg1212)
    707752{
    708753#if K1212_DEBUG_LEVEL > 0
    709         K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s]\n", stateName[korg1212->cardState]);
    710 #endif
     754        K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->playcnt);
     755#endif
     756
     757        if (--(korg1212->playcnt))
     758                return 0;
     759
     760        korg1212->setcnt = 0;
    711761
    712762        if (korg1212->cardState != K1212_STATE_ERRORSTOP) {
    … …  
    715765        }
    716766        snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
    717         return 1;
     767        return 0;
    718768}
    719769
    … …  
    795845        korg1212->clkRate = rate;
    796846
    797         TickDelay(INTERCOMMAND_DELAY);
     847        udelay(INTERCOMMAND_DELAY);
    798848        rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,
    799849                                          ClockSourceSelector[korg1212->clkSrcRate],
    … …  
    862912        // ----------------------------------------------------------------------------
    863913        writel(0, korg1212->mailbox3Ptr);
    864         TickDelay(LOADSHIFT_DELAY);
     914        udelay(LOADSHIFT_DELAY);
    865915
    866916        // ----------------------------------------------------------------------------
    … …  
    903953                ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS);
    904954                writew(controlValue, korg1212->sensRegPtr);                          // load/shift goes low
    905                 TickDelay(LOADSHIFT_DELAY);
     955                udelay(LOADSHIFT_DELAY);
    906956
    907957                for (bitPosition = 15; bitPosition >= 0; bitPosition--) {       // for all the bits
    … …  
    922972                        ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
    923973                        writew(controlValue, korg1212->sensRegPtr);                       // clock goes low
    924                         TickDelay(SENSCLKPULSE_WIDTH);
     974                        udelay(SENSCLKPULSE_WIDTH);
    925975                        SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
    926976                        writew(controlValue, korg1212->sensRegPtr);                       // clock goes high
    927                         TickDelay(SENSCLKPULSE_WIDTH);
     977                        udelay(SENSCLKPULSE_WIDTH);
    928978                }
    929979
    … …  
    936986                SetBitInWord(&controlValue, SET_SENS_LOADSHIFT_BITPOS);
    937987                writew(controlValue, korg1212->sensRegPtr);                   // load shift goes high - clk low
    938                 TickDelay(SENSCLKPULSE_WIDTH);
     988                udelay(SENSCLKPULSE_WIDTH);
    939989
    940990                if (clkIs48K)
    … …  
    942992
    943993                writew(controlValue, korg1212->sensRegPtr);                   // set/clear data bit
    944                 TickDelay(ONE_RTC_TICK);
     994                udelay(ONE_RTC_TICK);
    945995                SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
    946996                writew(controlValue, korg1212->sensRegPtr);                   // clock goes high
    947                 TickDelay(SENSCLKPULSE_WIDTH);
     997                udelay(SENSCLKPULSE_WIDTH);
    948998                ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
    949999                writew(controlValue, korg1212->sensRegPtr);                   // clock goes low
    950                 TickDelay(SENSCLKPULSE_WIDTH);
     1000                udelay(SENSCLKPULSE_WIDTH);
    9511001        }
    9521002
    … …  
    9561006        // ----------------------------------------------------------------------------
    9571007        for (count = 0; count < 10; count++)
    958                 TickDelay(SENSCLKPULSE_WIDTH);
     1008                udelay(SENSCLKPULSE_WIDTH);
    9591009
    9601010        if (monModeSet) {
    … …  
    10041054#endif
    10051055
    1006         TickDelay(INTERCOMMAND_DELAY);
     1056        udelay(INTERCOMMAND_DELAY);
    10071057
    10081058        rc = snd_korg1212_Send1212Command(korg1212,
    … …  
    10221072        // Initialize the routing and volume tables, then update the card's state.
    10231073        // --------------------------------------------------------------------------------
    1024         TickDelay(INTERCOMMAND_DELAY);
     1074        udelay(INTERCOMMAND_DELAY);
    10251075
    10261076        for (channel = 0; channel < kAudioChannels; channel++) {
    … …  
    10321082        snd_korg1212_WriteADCSensitivity(korg1212);
    10331083
    1034         TickDelay(INTERCOMMAND_DELAY);
     1084        udelay(INTERCOMMAND_DELAY);
    10351085        rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,
    10361086                                          ClockSourceSelector[korg1212->clkSrcRate],
    … …  
    10481098        wake_up_interruptible(&korg1212->wait);
    10491099}
    1050 
    10511100
    10521101static void snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs)
    … …  
    10851134                // ------------------------------------------------------------------------
    10861135                case K1212_ISRCODE_DMAERROR:
    1087 #if K1212_DEBUG_LEVEL > 0
     1136#if K1212_DEBUG_LEVEL > 1
    10881137                        K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DMAE count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]);
    10891138#endif
    10901139                        writel(0, &korg1212->sharedBufferPtr->cardCommand);
     1140                        snd_korg1212_setCardState(korg1212, K1212_STATE_ERRORSTOP);
    10911141                        break;
    10921142
    … …  
    10961146                // ------------------------------------------------------------------------
    10971147                case K1212_ISRCODE_CARDSTOPPED:
    1098 #if K1212_DEBUG_LEVEL > 0
     1148#if K1212_DEBUG_LEVEL > 1
    10991149                        K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ CSTP count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]);
    11001150#endif
    … …  
    11031153
    11041154                default:
    1105 #if K1212_DEBUG_LEVEL > 1
     1155#if K1212_DEBUG_LEVEL > 3
    11061156                        K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DFLT count - %ld, %x, cpos=%d [%s].\n", korg1212->irqcount, doorbellValue,
    11071157                                korg1212->currentBuffer, stateName[korg1212->cardState]);
    … …  
    11631213static snd_pcm_hardware_t snd_korg1212_playback_info =
    11641214{
    1165         .info =               (SNDRV_PCM_INFO_MMAP |
     1215        .info =              (SNDRV_PCM_INFO_MMAP |
    11661216                              SNDRV_PCM_INFO_MMAP_VALID |
    11671217                              SNDRV_PCM_INFO_INTERLEAVED),
    … …  
    11711221        .rate_min =           44100,
    11721222        .rate_max =           48000,
    1173         .channels_min =       K1212_CHANNELS,
    1174         .channels_max =       K1212_CHANNELS,
    1175         .buffer_bytes_max =   K1212_BUF_SIZE,
    1176         .period_bytes_min =   K1212_PERIOD_BYTES,
    1177         .period_bytes_max =   K1212_PERIOD_BYTES,
     1223        .channels_min =       K1212_MIN_CHANNELS,
     1224        .channels_max =       K1212_MAX_CHANNELS,
     1225        .buffer_bytes_max =   K1212_MAX_BUF_SIZE,
     1226        .period_bytes_min =   K1212_MIN_CHANNELS * 2 * kPlayBufferFrames,
     1227        .period_bytes_max =   K1212_MAX_CHANNELS * 2 * kPlayBufferFrames,
    11781228        .periods_min =        K1212_PERIODS,
    11791229        .periods_max =        K1212_PERIODS,
    … …  
    11831233static snd_pcm_hardware_t snd_korg1212_capture_info =
    11841234{
    1185         .info =               (SNDRV_PCM_INFO_MMAP |
     1235        .info =              (SNDRV_PCM_INFO_MMAP |
    11861236                              SNDRV_PCM_INFO_MMAP_VALID |
    11871237                              SNDRV_PCM_INFO_INTERLEAVED),
    … …  
    11911241        .rate_min =           44100,
    11921242        .rate_max =           48000,
    1193         .channels_min =       K1212_CHANNELS,
    1194         .channels_max =       K1212_CHANNELS,
    1195         .buffer_bytes_max =   K1212_BUF_SIZE,
    1196         .period_bytes_min =   K1212_PERIOD_BYTES,
    1197         .period_bytes_max =   K1212_PERIOD_BYTES,
     1243        .channels_min =       K1212_MIN_CHANNELS,
     1244        .channels_max =       K1212_MAX_CHANNELS,
     1245        .buffer_bytes_max =   K1212_MAX_BUF_SIZE,
     1246        .period_bytes_min =   K1212_MIN_CHANNELS * 2 * kPlayBufferFrames,
     1247        .period_bytes_max =   K1212_MAX_CHANNELS * 2 * kPlayBufferFrames,
    11981248        .periods_min =        K1212_PERIODS,
    11991249        .periods_max =        K1212_PERIODS,
    … …  
    12011251};
    12021252
     1253static int snd_korg1212_silence(korg1212_t *korg1212, int pos, int count, int offset, int size)
     1254{
     1255        KorgAudioFrame * dst =  korg1212->playDataBufsPtr[0].bufferData + pos;
     1256        int i;
     1257
     1258#if K1212_DEBUG_LEVEL > 2
     1259        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_silence pos=%d offset=%d size=%d count=%d\n", pos, offset, size, count);
     1260#endif
     1261        snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
     1262
     1263        for (i=0; i < count; i++) {
     1264#if K1212_DEBUG_LEVEL > 0
     1265                if ( (void *) dst < (void *) korg1212->playDataBufsPtr ||
     1266                     (void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) {
     1267                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_silence KERNEL EFAULT dst=%p iter=%d\n", dst, i);
     1268                        return -EFAULT;
     1269                }
     1270#endif
     1271                memset((void*) dst + offset, 0, size);
     1272                dst++;
     1273        }
     1274
     1275        return 0;
     1276}
     1277
     1278static int snd_korg1212_copy_to(korg1212_t *korg1212, void *dst, int pos, int count, int offset, int size)
     1279{
     1280        KorgAudioFrame * src =  korg1212->recordDataBufsPtr[0].bufferData + pos;
     1281        int i, rc;
     1282
     1283#if K1212_DEBUG_LEVEL > 2
     1284        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to pos=%d offset=%d size=%d\n", pos, offset, size);
     1285#endif
     1286        snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
     1287
     1288        for (i=0; i < count; i++) {
     1289#if K1212_DEBUG_LEVEL > 0
     1290                if ( (void *) src < (void *) korg1212->recordDataBufsPtr ||
     1291                     (void *) src > (void *) korg1212->recordDataBufsPtr[8].bufferData ) {
     1292                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i);
     1293                        return -EFAULT;
     1294                }
     1295#endif
     1296                rc = copy_to_user((void*) dst + offset, src, size);
     1297                if (rc) {
     1298#if K1212_DEBUG_LEVEL > 0
     1299                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to USER EFAULT src=%p dst=%p iter=%d\n", src, dst, i);
     1300#endif
     1301                        return -EFAULT;
     1302                }
     1303                src++;
     1304                dst += size;
     1305        }
     1306
     1307        return 0;
     1308}
     1309
     1310static int snd_korg1212_copy_from(korg1212_t *korg1212, void *src, int pos, int count, int offset, int size)
     1311{
     1312        KorgAudioFrame * dst =  korg1212->playDataBufsPtr[0].bufferData + pos;
     1313        int i, rc;
     1314
     1315#if K1212_DEBUG_LEVEL > 2
     1316        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from pos=%d offset=%d size=%d count=%d\n", pos, offset, size, count);
     1317#endif
     1318
     1319        snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
     1320
     1321        for (i=0; i < count; i++) {
     1322#if K1212_DEBUG_LEVEL > 0
     1323                if ( (void *) dst < (void *) korg1212->playDataBufsPtr ||
     1324                     (void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) {
     1325                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i);
     1326                        return -EFAULT;
     1327                }
     1328#endif
     1329                rc = copy_from_user((void*) dst + offset, src, size);
     1330                if (rc) {
     1331#if K1212_DEBUG_LEVEL > 0
     1332                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from USER EFAULT src=%p dst=%p iter=%d\n", src, dst, i);
     1333#endif
     1334                        return -EFAULT;
     1335                }
     1336                dst++;
     1337                src += size;
     1338        }
     1339
     1340        return 0;
     1341}
     1342
    12031343static void snd_korg1212_free_pcm(snd_pcm_t *pcm)
    12041344{
    … …  
    12091349#endif
    12101350
    1211         korg1212->pcm16 = NULL;
    1212 }
    1213 
    1214 static unsigned int period_bytes[] = { K1212_PERIOD_BYTES };
    1215 
    1216 #define PERIOD_BYTES sizeof(period_bytes) / sizeof(period_bytes[0])
    1217 
    1218 static snd_pcm_hw_constraint_list_t hw_constraints_period_bytes = {
    1219         .count = PERIOD_BYTES,
    1220         .list = period_bytes,
    1221         .mask = 0
    1222 };
     1351        korg1212->pcm = NULL;
     1352}
    12231353
    12241354static int snd_korg1212_playback_open(snd_pcm_substream_t *substream)
    … …  
    12321362#endif
    12331363
     1364        snd_pcm_set_sync(substream);    // ???
     1365
    12341366        spin_lock_irqsave(&korg1212->lock, flags);
    12351367
    1236         snd_korg1212_OpenCard(korg1212);
    1237 
    1238         snd_pcm_set_sync(substream);    // ???
    1239 
    1240         runtime->hw = snd_korg1212_playback_info;
     1368        snd_korg1212_OpenCard(korg1212);
     1369
    12411370        runtime->dma_area = (char *) korg1212->playDataBufsPtr;
    12421371        runtime->dma_bytes = K1212_BUF_SIZE;
    … …  
    12441373        korg1212->playback_substream = substream;
    12451374        korg1212->periodsize = K1212_PERIODS;
     1375        korg1212->channels = K1212_CHANNELS;
    12461376
    12471377        spin_unlock_irqrestore(&korg1212->lock, flags);
    12481378
    1249         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, K1212_BUF_SIZE, K1212_BUF_SIZE);
    1250         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
     1379        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, kPlayBufferFrames, kPlayBufferFrames);
    12511380        return 0;
    12521381}
     1382
    12531383
    12541384static int snd_korg1212_capture_open(snd_pcm_substream_t *substream)
    … …  
    12621392#endif
    12631393
     1394        snd_pcm_set_sync(substream);    // ???
     1395
    12641396        spin_lock_irqsave(&korg1212->lock, flags);
    12651397
    1266         snd_korg1212_OpenCard(korg1212);
    1267 
    1268         snd_pcm_set_sync(substream);    // ???
     1398        snd_korg1212_OpenCard(korg1212);
    12691399
    12701400        runtime->hw = snd_korg1212_capture_info;
    … …  
    12741404        korg1212->capture_substream = substream;
    12751405        korg1212->periodsize = K1212_PERIODS;
     1406        korg1212->channels = K1212_CHANNELS;
    12761407
    12771408        spin_unlock_irqrestore(&korg1212->lock, flags);
    12781409
    1279         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, K1212_BUF_SIZE, K1212_BUF_SIZE);
    1280         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
     1410        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, kPlayBufferFrames, kPlayBufferFrames);
    12811411        return 0;
    12821412}
    … …  
    12911421#endif
    12921422
     1423        snd_korg1212_silence(korg1212, 0, K1212_MAX_SAMPLES, 0, korg1212->channels * 2);
     1424
    12931425        spin_lock_irqsave(&korg1212->lock, flags);
    12941426
    … …  
    13221454}
    13231455
    1324 static int snd_korg1212_channel_info(snd_pcm_substream_t *substream,
    1325                                     snd_pcm_channel_info_t *info)
    1326 {
    1327         int chn = info->channel;
    1328 
    1329         // snd_assert(info->channel < kAudioChannels + 1, return -EINVAL);
    1330 
    1331         info->offset = 0;
    1332         // if (chn < k16BitChannels) {
    1333                 info->first = chn * 16;
    1334         // } else {
    1335         //         info->first = k16BitChannels * 16 + (chn - k16BitChannels - 1) * 32;
    1336         // }
    1337         info->step = sizeof(KorgAudioFrame) * 8;
    1338 
    1339 #if K1212_DEBUG_LEVEL > 0
    1340                 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_channel_info %d:, offset=%ld, first=%d, step=%d\n", chn, info->offset, info->first, info->step);
    1341 #endif
    1342 
    1343         return 0;
    1344 }
    1345 
    13461456static int snd_korg1212_ioctl(snd_pcm_substream_t *substream,
    13471457                             unsigned int cmd, void *arg)
    … …  
    13501460                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_ioctl: cmd=%d\n", cmd);
    13511461#endif
     1462
    13521463        if (cmd == SNDRV_PCM_IOCTL1_CHANNEL_INFO ) {
    13531464                snd_pcm_channel_info_t *info = arg;
    1354                 return snd_korg1212_channel_info(substream, info);
     1465                info->offset = 0;
     1466                info->first = info->channel * 16;
     1467                info->step = 256;
     1468#if K1212_DEBUG_LEVEL > 0
     1469                K1212_DEBUG_PRINTK("K1212_DEBUG: channel_info %d:, offset=%ld, first=%d, step=%d\n", info->channel, info->offset, info->first, info->step);
     1470#endif
     1471                return 0;
    13551472        }
    13561473
    … …  
    13741491                return err;
    13751492        }
    1376 
     1493/*
    13771494        if (params_format(params) != SNDRV_PCM_FORMAT_S16_LE) {
    13781495                spin_unlock_irqrestore(&korg1212->lock, flags);
    13791496                return -EINVAL;
    13801497        }
    1381 
    1382         korg1212->periodsize = K1212_BLOCK_SIZE;
     1498*/
     1499        korg1212->channels = params_channels(params);
     1500        korg1212->periodsize = K1212_PERIOD_BYTES;
    13831501
    13841502        spin_unlock_irqrestore(&korg1212->lock, flags);
    … …  
    13911509        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
    13921510        unsigned long flags;
     1511        int rc;
    13931512
    13941513#if K1212_DEBUG_LEVEL > 0
    … …  
    13981517        spin_lock_irqsave(&korg1212->lock, flags);
    13991518
    1400         snd_korg1212_SetupForPlay(korg1212);
    1401 
    1402         korg1212->currentBuffer = -1;
     1519        rc = snd_korg1212_SetupForPlay(korg1212);
     1520        korg1212->currentBuffer = 0;
    14031521
    14041522        spin_unlock_irqrestore(&korg1212->lock, flags);
    1405         return 0;
     1523
     1524        return rc ? -EINVAL : 0;
    14061525}
    14071526
    … …  
    14101529{
    14111530        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
     1531        int rc;
    14121532
    14131533#if K1212_DEBUG_LEVEL > 0
    … …  
    14171537        switch (cmd) {
    14181538                case SNDRV_PCM_TRIGGER_START:
    1419                         korg1212->running = 1;
    1420                         snd_korg1212_TriggerPlay(korg1212);
     1539/*
     1540                        if (korg1212->running) {
     1541#if K1212_DEBUG_LEVEL > 1
     1542                                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger: Already running?\n");
     1543#endif
    14211544                        break;
     1545                        }
     1546*/
     1547                        korg1212->running++;
     1548                        rc = snd_korg1212_TriggerPlay(korg1212);
     1549                        break;
    14221550
    14231551                case SNDRV_PCM_TRIGGER_STOP:
    1424                         korg1212->running = 0;
    1425                         snd_korg1212_StopPlay(korg1212);
     1552/*
     1553                        if (!korg1212->running) {
     1554#if K1212_DEBUG_LEVEL > 1
     1555                                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger: Already stopped?\n");
     1556#endif
     1557                                break;
     1558                        }
     1559*/
     1560                        korg1212->running--;
     1561                        rc = snd_korg1212_StopPlay(korg1212);
    14261562                        break;
    14271563
    14281564                default:
    1429                         return -EINVAL;
    1430         }
    1431         return 0;
    1432 }
    1433 
    1434 static snd_pcm_uframes_t snd_korg1212_pointer(snd_pcm_substream_t *substream)
     1565                        rc = 1;
     1566                        break;
     1567        }
     1568        return rc ? -EINVAL : 0;
     1569}
     1570
     1571static snd_pcm_uframes_t snd_korg1212_playback_pointer(snd_pcm_substream_t *substream)
    14351572{
    14361573        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
    14371574        snd_pcm_uframes_t pos;
    14381575
    1439         if (korg1212->currentBuffer < 0)
    1440                 return 0;
    1441 
    14421576        pos = korg1212->currentBuffer * kPlayBufferFrames;
    14431577
    1444 #if K1212_DEBUG_LEVEL > 1
    1445                 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_pointer [%s] %ld\n", stateName[korg1212->cardState], pos);
     1578#if K1212_DEBUG_LEVEL > 2
     1579        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_pointer [%s] %ld\n",
     1580                        stateName[korg1212->cardState], pos);
     1581#endif
     1582
     1583        return pos;
     1584}
     1585
     1586static snd_pcm_uframes_t snd_korg1212_capture_pointer(snd_pcm_substream_t *substream)
     1587{
     1588        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
     1589        snd_pcm_uframes_t pos;
     1590
     1591        pos = korg1212->currentBuffer * kPlayBufferFrames;
     1592
     1593#if K1212_DEBUG_LEVEL > 2
     1594        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_pointer [%s] %ld\n",
     1595                        stateName[korg1212->cardState], pos);
    14461596#endif
    14471597
    … …  
    14561606{
    14571607        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
    1458         KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;
    1459 
    1460 #if K1212_DEBUG_LEVEL > 0
     1608
     1609#if K1212_DEBUG_LEVEL > 2
    14611610                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_copy [%s] %ld %ld\n", stateName[korg1212->cardState], pos, count);
    14621611#endif
    14631612 
    1464         snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
    1465 
    1466         return copy_from_user(dst, src, count * K1212_FRAME_SIZE) ? -EFAULT : 0;
     1613        return snd_korg1212_copy_from(korg1212, src, pos, count, 0, korg1212->channels * 2);
     1614
     1615}
     1616
     1617static int snd_korg1212_playback_silence(snd_pcm_substream_t *substream,
     1618                           int channel, /* not used (interleaved data) */
     1619                           snd_pcm_uframes_t pos,
     1620                           snd_pcm_uframes_t count)
     1621{
     1622        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
     1623
     1624#if K1212_DEBUG_LEVEL > 0
     1625                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_silence [%s]\n", stateName[korg1212->cardState]);
     1626#endif
     1627
     1628        return snd_korg1212_silence(korg1212, pos, count, 0, korg1212->channels * 2);
    14671629}
    14681630
    … …  
    14741636{
    14751637        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
    1476         KorgAudioFrame * src = korg1212->recordDataBufsPtr[0].bufferData + pos;
    1477 
    1478 #if K1212_DEBUG_LEVEL > 0
     1638
     1639#if K1212_DEBUG_LEVEL > 2
    14791640                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_copy [%s] %ld %ld\n", stateName[korg1212->cardState], pos, count);
    14801641#endif
    14811642
    1482         snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
    1483 
    1484         return copy_to_user(dst, src, count * K1212_FRAME_SIZE) ? -EFAULT : 0;
    1485 }
    1486 
    1487 static int snd_korg1212_playback_silence(snd_pcm_substream_t *substream,
    1488                            int channel, /* not used (interleaved data) */
    1489                            snd_pcm_uframes_t pos,
    1490                            snd_pcm_uframes_t count)
    1491 {
    1492         korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
    1493         KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;
    1494 
    1495 #if K1212_DEBUG_LEVEL > 0
    1496                 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_silence [%s]\n", stateName[korg1212->cardState]);
    1497 #endif
    1498 
    1499         snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
    1500 
    1501         memset(dst, 0, count * K1212_FRAME_SIZE);
    1502 
    1503         return 0;
     1643        return snd_korg1212_copy_to(korg1212, dst, pos, count, 0, korg1212->channels * 2);
    15041644}
    15051645
    … …  
    15111651        .prepare =      snd_korg1212_prepare,
    15121652        .trigger =      snd_korg1212_trigger,
    1513         .pointer =      snd_korg1212_pointer,
     1653        .pointer =      snd_korg1212_playback_pointer,
    15141654        .copy =         snd_korg1212_playback_copy,
    15151655        .silence =      snd_korg1212_playback_silence,
    … …  
    15231663        .prepare =      snd_korg1212_prepare,
    15241664        .trigger =      snd_korg1212_trigger,
    1525         .pointer =      snd_korg1212_pointer,
     1665        .pointer =      snd_korg1212_capture_pointer,
    15261666        .copy =         snd_korg1212_capture_copy,
    15271667};
    … …  
    15481688        u->value.integer.value[0] = korg1212->volumePhase[i];
    15491689
    1550         if (i >= 8) 
     1690        if (i >= 8)
    15511691                u->value.integer.value[1] = korg1212->volumePhase[i+1];
    15521692
    … …  
    16961836        i = kcontrol->private_value;
    16971837
    1698         if (u->value.enumerated.item[0] != korg1212->sharedBufferPtr->volumeData[i]) {
     1838        if (u->value.enumerated.item[0] != (unsigned) korg1212->sharedBufferPtr->volumeData[i]) {
    16991839                korg1212->sharedBufferPtr->routeData[i] = u->value.enumerated.item[0];
    17001840                change = 1;
    … …  
    17021842
    17031843        if (i >= 8) {
    1704                 if (u->value.enumerated.item[1] != korg1212->sharedBufferPtr->volumeData[i+1]) {
     1844                if (u->value.enumerated.item[1] != (unsigned) korg1212->sharedBufferPtr->volumeData[i+1]) {
    17051845                        korg1212->sharedBufferPtr->routeData[i+1] = u->value.enumerated.item[1];
    17061846                        change = 1;
    … …  
    17131853}
    17141854
    1715 static int snd_korg1212_control_analog_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     1855static int snd_korg1212_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    17161856{
    17171857        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
    … …  
    17221862}
    17231863
    1724 static int snd_korg1212_control_analog_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
     1864static int snd_korg1212_control_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
    17251865{
    17261866        korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
    … …  
    17371877}
    17381878
    1739 static int snd_korg1212_control_analog_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
     1879static int snd_korg1212_control_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
    17401880{
    17411881        korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
    … …  
    18481988                .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
    18491989                .name =         "ADC Attenuation",
    1850                 .info =         snd_korg1212_control_analog_info,
    1851                 .get =          snd_korg1212_control_analog_get,
    1852                 .put =          snd_korg1212_control_analog_put,
     1990                .info =         snd_korg1212_control_info,
     1991                .get =          snd_korg1212_control_get,
     1992                .put =          snd_korg1212_control_put,
    18531993        }
    18541994};
    … …  
    18682008        snd_iprintf(buffer, " (index #%d)\n", korg1212->card->number + 1);
    18692009        snd_iprintf(buffer, "\nGeneral settings\n");
    1870         snd_iprintf(buffer, "    period size: %d bytes\n", K1212_BLOCK_SIZE);
     2010        snd_iprintf(buffer, "    period size: %d bytes\n", K1212_PERIOD_BYTES);
    18712011        snd_iprintf(buffer, "     clock mode: %s\n", clockSourceName[korg1212->clkSrcRate] );
    18722012        snd_iprintf(buffer, "  left ADC Sens: %d\n", korg1212->leftADCInSens );
    … …  
    18862026}
    18872027
    1888 static void __init snd_korg1212_proc_init(korg1212_t *korg1212)
     2028static void __devinit snd_korg1212_proc_init(korg1212_t *korg1212)
    18892029{
    18902030        snd_info_entry_t *entry;
    18912031
    1892         if ((entry = snd_info_create_card_entry(korg1212->card, "korg1212", korg1212->card->proc_root)) != NULL) {
    1893                 entry->content = SNDRV_INFO_CONTENT_TEXT;
    1894                 entry->private_data = korg1212;
    1895                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
    1896                 entry->c.text.read_size = 256;
    1897                 entry->c.text.read = snd_korg1212_proc_read;
    1898                 if (snd_info_register(entry) < 0) {
    1899                         snd_info_free_entry(entry);
    1900                         entry = NULL;
    1901                 }
    1902         }
    1903         korg1212->proc_entry = entry;
    1904 }
    1905 
    1906 static void snd_korg1212_proc_done(korg1212_t * korg1212)
    1907 {
    1908         if (korg1212->proc_entry) {
    1909                 snd_info_unregister(korg1212->proc_entry);
    1910                 korg1212->proc_entry = NULL;
    1911         }
    1912 }
    1913 
    1914 static int __init snd_korg1212_create(korg1212_t *korg1212)
    1915 {
    1916         struct pci_dev *pci = korg1212->pci;
     2032        if (! snd_card_proc_new(korg1212->card, "korg1212", &entry))
     2033                snd_info_set_text_ops(entry, korg1212, snd_korg1212_proc_read);
     2034}
     2035
     2036static int
     2037snd_korg1212_free(korg1212_t *korg1212)
     2038{
     2039        snd_korg1212_TurnOffIdleMonitor(korg1212);
     2040
     2041        if (korg1212->irq >= 0) {
     2042                synchronize_irq(korg1212->irq);               
     2043                snd_korg1212_DisableCardInterrupts(korg1212);
     2044                free_irq(korg1212->irq, (void *)korg1212);
     2045                korg1212->irq = -1;
     2046        }
     2047       
     2048        if (korg1212->iobase != 0) {
     2049                iounmap((void *)korg1212->iobase);
     2050                korg1212->iobase = 0;
     2051        }
     2052       
     2053        if (korg1212->res_iomem != NULL) {
     2054                release_resource(korg1212->res_iomem);
     2055                kfree_nocheck(korg1212->res_iomem);
     2056                korg1212->res_iomem = NULL;
     2057        }
     2058       
     2059        if (korg1212->res_ioport != NULL) {
     2060                release_resource(korg1212->res_ioport);
     2061                kfree_nocheck(korg1212->res_ioport);
     2062                korg1212->res_ioport = NULL;
     2063        }
     2064       
     2065        if (korg1212->res_iomem2 != NULL) {
     2066                release_resource(korg1212->res_iomem2);
     2067                kfree_nocheck(korg1212->res_iomem2);
     2068                korg1212->res_iomem2 = NULL;
     2069        }
     2070
     2071        // ----------------------------------------------------
     2072        // free up memory resources used for the DSP download.
     2073        // ----------------------------------------------------
     2074        if (korg1212->dspMemPtr) {
     2075                snd_free_pci_pages(korg1212->pci, korg1212->dspCodeSize,
     2076                                   korg1212->dspMemPtr, (dma_addr_t)korg1212->dspMemPhy);
     2077                korg1212->dspMemPhy = 0;
     2078                korg1212->dspMemPtr = 0;
     2079                korg1212->dspCodeSize = 0;
     2080        }
     2081
     2082#ifndef K1212_LARGEALLOC
     2083
     2084        // ------------------------------------------------------
     2085        // free up memory resources used for the Play/Rec Buffers
     2086        // ------------------------------------------------------
     2087        if (korg1212->playDataBufsPtr) {
     2088                snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
     2089                                   korg1212->playDataBufsPtr, (dma_addr_t)korg1212->PlayDataPhy);
     2090                korg1212->PlayDataPhy = 0;
     2091                korg1212->playDataBufsPtr = NULL;
     2092        }
     2093
     2094        if (korg1212->recordDataBufsPtr) {
     2095                snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
     2096                                   korg1212->recordDataBufsPtr, (dma_addr_t)korg1212->RecDataPhy);
     2097                korg1212->RecDataPhy = 0;
     2098                korg1212->recordDataBufsPtr = NULL;
     2099        }
     2100
     2101#endif
     2102
     2103        // ----------------------------------------------------
     2104        // free up memory resources used for the Shared Buffers
     2105        // ----------------------------------------------------
     2106        if (korg1212->sharedBufferPtr) {
     2107                snd_free_pci_pages(korg1212->pci, (u32) sizeof(KorgSharedBuffer),
     2108                                   korg1212->sharedBufferPtr, (dma_addr_t)korg1212->sharedBufferPhy);
     2109                korg1212->sharedBufferPhy = 0;
     2110                korg1212->sharedBufferPtr = NULL;
     2111        }
     2112       
     2113        snd_magic_kfree(korg1212);
     2114        return 0;
     2115}
     2116
     2117static int snd_korg1212_dev_free(snd_device_t *device)
     2118{
     2119        korg1212_t *korg1212 = snd_magic_cast(korg1212_t, device->device_data, return -ENXIO);
     2120#if K1212_DEBUG_LEVEL > 0
     2121        K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing device\n");
     2122#endif
     2123        return snd_korg1212_free(korg1212);
     2124}
     2125
     2126static int __devinit snd_korg1212_create(snd_card_t * card, struct pci_dev *pci,
     2127                                         korg1212_t ** rchip)
     2128
     2129{
    19172130        int err;
    1918         int i;
     2131        unsigned int i;
    19192132        unsigned ioport_size, iomem_size, iomem2_size;
    19202133        dma_addr_t phys_addr;
     2134        korg1212_t * korg1212;
     2135
     2136        static snd_device_ops_t ops = {
     2137                .dev_free = snd_korg1212_dev_free,
     2138        };
     2139
     2140        * rchip = NULL;
     2141        if ((err = pci_enable_device(pci)) < 0)
     2142                return err;
     2143
     2144        korg1212 = snd_magic_kcalloc(korg1212_t, 0, GFP_KERNEL);
     2145        if (korg1212 == NULL)
     2146                return -ENOMEM;
     2147
     2148        korg1212->card = card;
     2149        korg1212->pci = pci;
     2150
     2151        init_waitqueue_head(&korg1212->wait);
     2152        spin_lock_init(&korg1212->lock);
    19212153
    19222154        korg1212->irq = -1;
    … …  
    19252157        korg1212->inIRQ = 0;
    19262158        korg1212->running = 0;
     2159        korg1212->opencnt = 0;
     2160        korg1212->playcnt = 0;
     2161        korg1212->setcnt = 0;
    19272162        snd_korg1212_setCardState(korg1212, K1212_STATE_UNINITIALIZED);
    19282163        korg1212->idleMonitorOn = 0;
    … …  
    19332168        for (i=0; i<kAudioChannels; i++)
    19342169                korg1212->volumePhase[i] = 0;
    1935 
    1936         if ((err = pci_enable_device(pci)) < 0)
    1937                 return err;
    19382170
    19392171        korg1212->iomem = pci_resource_start(korg1212->pci, 0);
    … …  
    19592191        korg1212->res_iomem = request_mem_region(korg1212->iomem, iomem_size, "korg1212");
    19602192        if (korg1212->res_iomem == NULL) {
    1961                 snd_printk("unable to grab region 0x%lx-0x%lx\n",
     2193                snd_printk(KERN_ERR "unable to grab region 0x%lx-0x%lx\n",
    19622194                           korg1212->iomem, korg1212->iomem + iomem_size - 1);
    19632195                return -EBUSY;
    … …  
    19662198        korg1212->res_ioport = request_region(korg1212->ioport, ioport_size, "korg1212");
    19672199        if (korg1212->res_ioport == NULL) {
    1968                 snd_printk("unable to grab region 0x%lx-0x%lx\n",
     2200                snd_printk(KERN_ERR "unable to grab region 0x%lx-0x%lx\n",
    19692201                           korg1212->ioport, korg1212->ioport + ioport_size - 1);
    19702202                return -EBUSY;
    … …  
    19732205        korg1212->res_iomem2 = request_mem_region(korg1212->iomem2, iomem2_size, "korg1212");
    19742206        if (korg1212->res_iomem2 == NULL) {
    1975                 snd_printk("unable to grab region 0x%lx-0x%lx\n",
     2207                snd_printk(KERN_ERR "unable to grab region 0x%lx-0x%lx\n",
    19762208                           korg1212->iomem2, korg1212->iomem2 + iomem2_size - 1);
    19772209                return -EBUSY;
    … …  
    19792211
    19802212        if ((korg1212->iobase = (unsigned long) ioremap(korg1212->iomem, iomem_size)) == 0) {
    1981                 snd_printk("unable to remap memory region 0x%lx-0x%lx\n", korg1212->iobase,
     2213                snd_printk(KERN_ERR "unable to remap memory region 0x%lx-0x%lx\n", korg1212->iobase,
    19822214                           korg1212->iobase + iomem_size - 1);
    19832215                return -EBUSY;
    … …  
    19892221
    19902222        if (err) {
    1991                 snd_printk("unable to grab IRQ %d\n", pci->irq);
     2223                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
    19922224                return -EBUSY;
    19932225        }
    … …  
    19952227        korg1212->irq = pci->irq;
    19962228
    1997         init_waitqueue_head(&korg1212->wait);
    1998         spin_lock_init(&korg1212->lock);
    19992229        pci_set_master(korg1212->pci);
    20002230
    … …  
    20402270
    20412271        if (korg1212->sharedBufferPtr == NULL) {
    2042                 snd_printk("can not allocate shared buffer memory (%d bytes)\n", sizeof(KorgSharedBuffer));
     2272                snd_printk(KERN_ERR "can not allocate shared buffer memory (%d bytes)\n", sizeof(KorgSharedBuffer));
    20432273                return -ENOMEM;
    20442274        }
    … …  
    20562286
    20572287        if (korg1212->playDataBufsPtr == NULL) {
    2058                 snd_printk("can not allocate play data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
     2288                snd_printk(KERN_ERR "can not allocate play data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
    20592289                return -ENOMEM;
    20602290        }
    … …  
    20692299
    20702300        if (korg1212->recordDataBufsPtr == NULL) {
    2071                 snd_printk("can not allocate record data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
     2301                snd_printk(KERN_ERR "can not allocate record data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
    20722302                return -ENOMEM;
    20732303        }
    … …  
    20972327
    20982328        if (korg1212->dspMemPtr == NULL) {
    2099                 snd_printk("can not allocate dsp code memory (%d bytes)\n", korg1212->dspCodeSize);
     2329                snd_printk(KERN_ERR "can not allocate dsp code memory (%d bytes)\n", korg1212->dspCodeSize);
    21002330                return -ENOMEM;
    21012331        }
    … …  
    21172347        mdelay(CARD_BOOT_DELAY_IN_MS);
    21182348
    2119         if (snd_korg1212_downloadDSPCode(korg1212))
     2349        if (snd_korg1212_downloadDSPCode(korg1212)) 
    21202350                return -EBUSY;
    21212351
    … …  
    21332363               korg1212->AdatTimeCodePhy, LowerWordSwap(korg1212->AdatTimeCodePhy));
    21342364
    2135         if ((err = snd_pcm_new(korg1212->card, "korg1212", 0, 1, 1, &korg1212->pcm16)) < 0)
     2365        if ((err = snd_pcm_new(korg1212->card, "korg1212", 0, 1, 1, &korg1212->pcm)) < 0)
    21362366                return err;
    21372367
    2138         korg1212->pcm16->private_data = korg1212;
    2139         korg1212->pcm16->private_free = snd_korg1212_free_pcm;
    2140         strcpy(korg1212->pcm16->name, "korg1212");
    2141 
    2142         snd_pcm_set_ops(korg1212->pcm16, SNDRV_PCM_STREAM_PLAYBACK, &snd_korg1212_playback_ops);
    2143         snd_pcm_set_ops(korg1212->pcm16, SNDRV_PCM_STREAM_CAPTURE, &snd_korg1212_capture_ops);
    2144 
    2145         korg1212->pcm16->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
     2368        korg1212->pcm->private_data = korg1212;
     2369        korg1212->pcm->private_free = snd_korg1212_free_pcm;
     2370        strcpy(korg1212->pcm->name, "korg1212");
     2371
     2372        snd_pcm_set_ops(korg1212->pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_korg1212_playback_ops);
     2373       
     2374        snd_pcm_set_ops(korg1212->pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_korg1212_capture_ops);
     2375
     2376        korg1212->pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
     2377
     2378        //snd_pcm_lib_preallocate_pages_for_all(korg1212->pcm,
     2379        //                      K1212_MAX_BUF_SIZE, K1212_MAX_BUF_SIZE, GFP_KERNEL);
    21462380
    21472381        for (i = 0; i < K1212_CONTROL_ELEMENTS; i++) {
    … …  
    21532387        snd_korg1212_proc_init(korg1212);
    21542388
     2389        if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, korg1212, &ops)) < 0) {
     2390                snd_korg1212_free(korg1212);
     2391                return err;
     2392        }
     2393       
     2394        * rchip = korg1212;
    21552395        return 0;
    21562396
    2157 }
    2158 
    2159 static void
    2160 snd_korg1212_free(void *private_data)
    2161 {
    2162         korg1212_t *korg1212 = (korg1212_t *)private_data;
    2163 
    2164         if (korg1212 == NULL) {
    2165                 return;
    2166         }
    2167 
    2168         snd_korg1212_proc_done(korg1212);
    2169 
    2170         snd_korg1212_TurnOffIdleMonitor(korg1212);
    2171 
    2172         snd_korg1212_DisableCardInterrupts(korg1212);
    2173 
    2174         if (korg1212->irq >= 0) {
    2175                 free_irq(korg1212->irq, (void *)korg1212);
    2176                 korg1212->irq = -1;
    2177         }
    2178         if (korg1212->iobase != 0) {
    2179                 iounmap((void *)korg1212->iobase);
    2180                 korg1212->iobase = 0;
    2181         }
    2182         if (korg1212->res_iomem != NULL) {
    2183                 release_resource(korg1212->res_iomem);
    2184                 kfree_nocheck(korg1212->res_iomem);
    2185                 korg1212->res_iomem = NULL;
    2186         }
    2187         if (korg1212->res_ioport != NULL) {
    2188                 release_resource(korg1212->res_ioport);
    2189                 kfree_nocheck(korg1212->res_ioport);
    2190                 korg1212->res_ioport = NULL;
    2191         }
    2192         if (korg1212->res_iomem2 != NULL) {
    2193                 release_resource(korg1212->res_iomem2);
    2194                 kfree_nocheck(korg1212->res_iomem2);
    2195                 korg1212->res_iomem2 = NULL;
    2196         }
    2197 
    2198         // ----------------------------------------------------
    2199         // free up memory resources used for the DSP download.
    2200         // ----------------------------------------------------
    2201         if (korg1212->dspMemPtr) {
    2202                 snd_free_pci_pages(korg1212->pci, korg1212->dspCodeSize,
    2203                                    korg1212->dspMemPtr, (dma_addr_t)korg1212->dspMemPhy);
    2204                 korg1212->dspMemPhy = 0;
    2205                 korg1212->dspMemPtr = 0;
    2206                 korg1212->dspCodeSize = 0;
    2207         }
    2208 
    2209 #ifndef K1212_LARGEALLOC
    2210 
    2211         // ------------------------------------------------------
    2212         // free up memory resources used for the Play/Rec Buffers
    2213         // ------------------------------------------------------
    2214         if (korg1212->playDataBufsPtr) {
    2215                 snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
    2216                                    korg1212->playDataBufsPtr, (dma_addr_t)korg1212->PlayDataPhy);
    2217                 korg1212->PlayDataPhy = 0;
    2218                 korg1212->playDataBufsPtr = NULL;
    2219         }
    2220 
    2221         if (korg1212->recordDataBufsPtr) {
    2222                 snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
    2223                                    korg1212->recordDataBufsPtr, (dma_addr_t)korg1212->RecDataPhy);
    2224                 korg1212->RecDataPhy = 0;
    2225                 korg1212->recordDataBufsPtr = NULL;
    2226         }
    2227 
    2228 #endif
    2229 
    2230         // ----------------------------------------------------
    2231         // free up memory resources used for the Shared Buffers
    2232         // ----------------------------------------------------
    2233         if (korg1212->sharedBufferPtr) {
    2234                 snd_free_pci_pages(korg1212->pci, (u32) sizeof(KorgSharedBuffer),
    2235                                    korg1212->sharedBufferPtr, (dma_addr_t)korg1212->sharedBufferPhy);
    2236                 korg1212->sharedBufferPhy = 0;
    2237                 korg1212->sharedBufferPtr = NULL;
    2238         }
    22392397}
    22402398
    … …  
    22422400 * Card initialisation
    22432401 */
    2244 
    2245 static void snd_korg1212_card_free(snd_card_t *card)
    2246 {
    2247 #if K1212_DEBUG_LEVEL > 0
    2248         K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing card\n");
    2249 #endif
    2250         snd_korg1212_free(card->private_data);
    2251 }
    22522402
    22532403static int __devinit
    … …  
    22672417                return -ENOENT;
    22682418        }
    2269         if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE,
    2270                                  sizeof(korg1212_t))) == NULL)
     2419        card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
     2420        if (card == NULL)
    22712421                return -ENOMEM;
    22722422
    2273         card->private_free = snd_korg1212_card_free;
    2274         korg1212 = (korg1212_t *)card->private_data;
    2275         korg1212->card = card;
    2276         korg1212->pci = pci;
    2277 
    2278         if ((err = snd_korg1212_create(korg1212)) < 0) {
     2423        if ((err = snd_korg1212_create(card, pci, &korg1212)) < 0) {
    22792424                snd_card_free(card);
    22802425                return err;
    … …  
    22942439                return err;
    22952440        }
    2296         pci_set_drvdata(pci, card);
     2441        pci_set_drvdata(pci, korg1212);
    22972442        dev++;
    22982443        return 0;
    … …  
    23012446static void __devexit snd_korg1212_remove(struct pci_dev *pci)
    23022447{
    2303         snd_card_free(pci_get_drvdata(pci));
     2448        korg1212_t *korg1212 = pci_get_drvdata(pci);
     2449        snd_card_free(korg1212->card);
    23042450        pci_set_drvdata(pci, NULL);
    23052451}

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/rme96.c

    r212 r224  
    2525
    2626#include <sound/driver.h>
    27 #include <asm/io.h>
    2827#include <linux/delay.h>
    2928#include <linux/init.h>
     29#include <linux/interrupt.h>
    3030#include <linux/pci.h>
    3131#include <linux/slab.h>
     32
    3233#include <sound/core.h>
    3334#include <sound/info.h>
    … …  
    3839#define SNDRV_GET_ID
    3940#include <sound/initval.h>
     41
     42#include <asm/io.h>
    4043
    4144/* note, two last pcis should be equal, it is not a bug */
    … …  
    255258        snd_pcm_t          *adat_pcm;
    256259        struct pci_dev     *pci;
    257         snd_info_entry_t   *proc_entry;
    258260        snd_kcontrol_t     *spdif_ctl;
    259261} rme96_t;
    … …  
    303305snd_rme96_capture_pointer(snd_pcm_substream_t *substream);
    304306
    305 static void __init
     307static void __devinit
    306308snd_rme96_proc_init(rme96_t *rme96);
    307 
    308 static void
    309 snd_rme96_proc_done(rme96_t *rme96);
    310309
    311310static int
    … …  
    313312                          rme96_t *rme96);
    314313
     314static int
     315snd_rme96_getinputtype(rme96_t *rme96);
     316
    315317static inline unsigned int
    316318snd_rme96_playback_ptr(rme96_t *rme96)
    … …  
    325327        return (readl(rme96->iobase + RME96_IO_GET_REC_POS)
    326328                & RME96_RCR_AUDIO_ADDR_MASK) >> rme96->capture_frlog;
     329}
     330
     331static int
     332snd_rme96_ratecode(int rate)
     333{
     334    switch (rate) {
     335    case 32000: return SNDRV_PCM_RATE_32000;
     336    case 44100: return SNDRV_PCM_RATE_44100;
     337    case 48000: return SNDRV_PCM_RATE_48000;
     338    case 64000: return SNDRV_PCM_RATE_64000;
     339    case 88200: return SNDRV_PCM_RATE_88200;
     340    case 96000: return SNDRV_PCM_RATE_96000;
     341    }
     342    return 0;
    327343}
    328344
    … …  
    667683
    668684        if (!(rme96->wcreg & RME96_WCR_MASTER) &&
     685            snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
    669686            (rate = snd_rme96_capture_getrate(rme96, &dummy)) > 0)
    670687        {
    … …  
    972989                             snd_pcm_hw_params_t *params)
    973990{
    974         unsigned long flags;
     991        unsigned long flags;       
    975992        rme96_t *rme96 = _snd_pcm_substream_chip(substream);
    976         int err;
     993        int err, rate, dummy;
    977994
    978995        if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params))) < 0)
    979996                return err;
    980997        spin_lock_irqsave(&rme96->lock, flags);
    981         if ((err = snd_rme96_playback_setrate(rme96, params_rate(params))) < 0) {
     998        if (!(rme96->wcreg & RME96_WCR_MASTER) &&
     999            snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
     1000            (rate = snd_rme96_capture_getrate(rme96, &dummy)) > 0)
     1001        {
     1002                /* slave clock */
     1003                if ((int)params_rate(params) != rate) {
     1004                        spin_unlock_irqrestore(&rme96->lock, flags);
     1005                        return -EIO;                   
     1006                }
     1007        } else if ((err = snd_rme96_playback_setrate(rme96, params_rate(params))) < 0) {
    9821008                spin_unlock_irqrestore(&rme96->lock, flags);
    9831009                return err;
    … …  
    10221048        unsigned long flags;
    10231049        rme96_t *rme96 = _snd_pcm_substream_chip(substream);
    1024         int err, isadat;
     1050        snd_pcm_runtime_t *runtime = substream->runtime;
     1051        int err, isadat, rate;
    10251052       
    10261053        if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params))) < 0)
    … …  
    10381065                        return err;
    10391066                }
    1040         } else if (params_rate(params) != snd_rme96_capture_getrate(rme96, &isadat)) {
    1041                 spin_unlock_irqrestore(&rme96->lock, flags);
    1042                 return -EBUSY;
     1067        } else if ((rate = snd_rme96_capture_getrate(rme96, &isadat)) > 0) {
     1068                if ((int)params_rate(params) != rate) {
     1069                        spin_unlock_irqrestore(&rme96->lock, flags);
     1070                        return -EIO;                   
     1071                }
     1072                if ((isadat && runtime->hw.channels_min == 2) ||
     1073                    (!isadat && runtime->hw.channels_min == 8))
     1074                {
     1075                        spin_unlock_irqrestore(&rme96->lock, flags);
     1076                        return -EIO;
     1077                }
    10431078        }
    10441079        snd_rme96_setframelog(rme96, params_channels(params), 0);
    … …  
    11601195{
    11611196        unsigned long flags;
     1197        int rate, dummy;
    11621198        rme96_t *rme96 = _snd_pcm_substream_chip(substream);
    11631199        snd_pcm_runtime_t *runtime = substream->runtime;
    … …  
    11661202
    11671203        spin_lock_irqsave(&rme96->lock, flags);
     1204        if (rme96->playback_substream != NULL) {
     1205                spin_unlock_irqrestore(&rme96->lock, flags);
     1206                return -EBUSY;
     1207        }
    11681208        rme96->wcreg &= ~RME96_WCR_ADAT;
    11691209        writel(rme96->wcreg, rme96->iobase + RME96_IO_CONTROL_REGISTER);
    … …  
    11731213        spin_unlock_irqrestore(&rme96->lock, flags);
    11741214
    1175         runtime->hw = snd_rme96_playback_spdif_info;   
     1215        runtime->hw = snd_rme96_playback_spdif_info;
     1216        if (!(rme96->wcreg & RME96_WCR_MASTER) &&
     1217            snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
     1218            (rate = snd_rme96_capture_getrate(rme96, &dummy)) > 0)
     1219        {
     1220                /* slave clock */
     1221                runtime->hw.rates = snd_rme96_ratecode(rate);
     1222                runtime->hw.rate_min = rate;
     1223                runtime->hw.rate_max = rate;
     1224        }       
    11761225        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
    11771226        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
    … …  
    11881237{
    11891238        unsigned long flags;
    1190         int isadat;
     1239        int isadat, rate;
    11911240        rme96_t *rme96 = _snd_pcm_substream_chip(substream);
    11921241        snd_pcm_runtime_t *runtime = substream->runtime;
    11931242
    1194         rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER);
    1195         if (snd_rme96_capture_getrate(rme96, &isadat) < 0) {
    1196                 /* no input */
    1197                 return -EIO;
    1198         }
    1199         if (isadat) {
    1200                 /* ADAT input */
    1201                 return -EBUSY;
    1202         }
    12031243        snd_pcm_set_sync(substream);
    12041244
    1205         spin_lock_irqsave(&rme96->lock, flags);
     1245        runtime->hw = snd_rme96_capture_spdif_info;
     1246        if (snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
     1247            (rate = snd_rme96_capture_getrate(rme96, &isadat)) > 0)
     1248        {
     1249                if (isadat) {
     1250                        return -EIO;
     1251                }
     1252                runtime->hw.rates = snd_rme96_ratecode(rate);
     1253                runtime->hw.rate_min = rate;
     1254                runtime->hw.rate_max = rate;
     1255        }
     1256       
     1257        spin_lock_irqsave(&rme96->lock, flags);
     1258        if (rme96->capture_substream != NULL) {
     1259                spin_unlock_irqrestore(&rme96->lock, flags);
     1260                return -EBUSY;
     1261        }
    12061262        rme96->capture_substream = substream;
    12071263        rme96->capture_ptr = 0;
    12081264        spin_unlock_irqrestore(&rme96->lock, flags);
    12091265       
    1210         runtime->hw = snd_rme96_capture_spdif_info;
    1211        
    12121266        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
    12131267        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
    … …  
    12201274{
    12211275        unsigned long flags;
     1276        int rate, dummy;
    12221277        rme96_t *rme96 = _snd_pcm_substream_chip(substream);
    1223         snd_pcm_runtime_t *runtime = substream->runtime;
     1278        snd_pcm_runtime_t *runtime = substream->runtime;       
    12241279       
    12251280        snd_pcm_set_sync(substream);
    12261281
    12271282        spin_lock_irqsave(&rme96->lock, flags);
     1283        if (rme96->playback_substream != NULL) {
     1284                spin_unlock_irqrestore(&rme96->lock, flags);
     1285                return -EBUSY;
     1286        }
    12281287        rme96->wcreg |= RME96_WCR_ADAT;
    12291288        writel(rme96->wcreg, rme96->iobase + RME96_IO_CONTROL_REGISTER);
    … …  
    12341293       
    12351294        runtime->hw = snd_rme96_playback_adat_info;
     1295        if (!(rme96->wcreg & RME96_WCR_MASTER) &&
     1296            snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
     1297            (rate = snd_rme96_capture_getrate(rme96, &dummy)) > 0)
     1298        {
     1299                /* slave clock */
     1300                runtime->hw.rates = snd_rme96_ratecode(rate);
     1301                runtime->hw.rate_min = rate;
     1302                runtime->hw.rate_max = rate;
     1303        }       
    12361304        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
    12371305        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
    … …  
    12431311{
    12441312        unsigned long flags;
    1245         int isadat;
     1313        int isadat, rate;
    12461314        rme96_t *rme96 = _snd_pcm_substream_chip(substream);
    12471315        snd_pcm_runtime_t *runtime = substream->runtime;
    12481316
    1249         rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER);
    1250         if (snd_rme96_capture_getrate(rme96, &isadat) < 0) {
    1251                 /* no input */
    1252                 return -EIO;
    1253         }
    1254         if (!isadat) {
    1255                 /* S/PDIF input */
    1256                 return -EBUSY;
    1257         }
    12581317        snd_pcm_set_sync(substream);
    12591318
     1319        runtime->hw = snd_rme96_capture_adat_info;
     1320        if (snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG) {
     1321                /* makes no sense to use analog input. Note that analog
     1322                   expension cards AEB4/8-I are RME96_INPUT_INTERNAL */
     1323                return -EIO;
     1324        }
     1325        if ((rate = snd_rme96_capture_getrate(rme96, &isadat)) > 0) {
     1326                if (!isadat) {
     1327                        return -EIO;
     1328                }
     1329                runtime->hw.rates = snd_rme96_ratecode(rate);
     1330                runtime->hw.rate_min = rate;
     1331                runtime->hw.rate_max = rate;
     1332        }
     1333       
    12601334        spin_lock_irqsave(&rme96->lock, flags);
     1335        if (rme96->capture_substream != NULL) {
     1336                spin_unlock_irqrestore(&rme96->lock, flags);
     1337                return -EBUSY;
     1338        }
    12611339        rme96->capture_substream = substream;
    12621340        rme96->capture_ptr = 0;
    12631341        spin_unlock_irqrestore(&rme96->lock, flags);
    12641342
    1265         runtime->hw = snd_rme96_capture_adat_info;
    12661343        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
    12671344        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
    … …  
    12771354
    12781355        spin_lock_irqsave(&rme96->lock, flags);
     1356        if (RME96_ISPLAYING(rme96)) {
     1357                snd_rme96_playback_stop(rme96);
     1358        }
    12791359        rme96->playback_substream = NULL;
    12801360        rme96->playback_periodsize = 0;
    … …  
    12961376       
    12971377        spin_lock_irqsave(&rme96->lock, flags);
     1378        if (RME96_ISRECORDING(rme96)) {
     1379                snd_rme96_capture_stop(rme96);
     1380        }
    12981381        rme96->capture_substream = NULL;
    12991382        rme96->capture_periodsize = 0;
    … …  
    15561639                rme96->areg &= ~RME96_AR_DAC_EN;
    15571640                writel(rme96->areg, rme96->iobase + RME96_IO_ADDITIONAL_REG);
    1558                 snd_rme96_proc_done(rme96);
    15591641                free_irq(rme96->irq, (void *)rme96);
    15601642                rme96->irq = -1;
    … …  
    15871669}
    15881670
    1589 static int __init
     1671static int __devinit
    15901672snd_rme96_create(rme96_t *rme96)
    15911673{
    … …  
    17831865        } else if (rme96->wcreg & RME96_WCR_MASTER) {
    17841866                snd_iprintf(buffer, "  clock mode: master\n");
     1867        } else if (snd_rme96_getinputtype(rme96) == RME96_INPUT_ANALOG) {
     1868                snd_iprintf(buffer, "  clock mode: slave (master anyway due to analog input setting)\n");
     1869        } else if (snd_rme96_capture_getrate(rme96, &n) < 0) {
     1870                snd_iprintf(buffer, "  clock mode: slave (master anyway due to no valid signal)\n");
    17851871        } else {
    17861872                snd_iprintf(buffer, "  clock mode: slave\n");
    … …  
    18361922}
    18371923
    1838 static void __init
     1924static void __devinit
    18391925snd_rme96_proc_init(rme96_t *rme96)
    18401926{
    18411927        snd_info_entry_t *entry;
    18421928
    1843         if ((entry = snd_info_create_card_entry(rme96->card, "rme96", rme96->card->proc_root)) != NULL) {
    1844                 entry->content = SNDRV_INFO_CONTENT_TEXT;
    1845                 entry->private_data = rme96;
    1846                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
    1847                 entry->c.text.read_size = 256;
    1848                 entry->c.text.read = snd_rme96_proc_read;
    1849                 if (snd_info_register(entry) < 0) {
    1850                         snd_info_free_entry(entry);
    1851                         entry = NULL;
    1852                 }
    1853         }
    1854         rme96->proc_entry = entry;
    1855 }
    1856 
    1857 static void
    1858 snd_rme96_proc_done(rme96_t * rme96)
    1859 {
    1860         if (rme96->proc_entry) {
    1861                 snd_info_unregister(rme96->proc_entry);
    1862                 rme96->proc_entry = NULL;
    1863         }
     1929        if (! snd_card_proc_new(rme96->card, "rme96", &entry))
     1930                snd_info_set_text_ops(entry, rme96, snd_rme96_proc_read);
    18641931}
    18651932
    … …  
    19532020        rme96_t *rme96 = _snd_kcontrol_chip(kcontrol);
    19542021        unsigned long flags;
    1955         int items = 3;
     2022        unsigned int items = 3;
    19562023       
    19572024        spin_lock_irqsave(&rme96->lock, flags);
    … …  
    20252092       
    20262093        spin_lock_irqsave(&rme96->lock, flags);
    2027         change = val != snd_rme96_getinputtype(rme96);
     2094        change = (int)val != snd_rme96_getinputtype(rme96);
    20282095        snd_rme96_setinputtype(rme96, val);
    20292096        spin_unlock_irqrestore(&rme96->lock, flags);
    … …  
    20662133        val = ucontrol->value.enumerated.item[0] % 3;
    20672134        spin_lock_irqsave(&rme96->lock, flags);
    2068         change = val != snd_rme96_getclockmode(rme96);
     2135        change = (int)val != snd_rme96_getclockmode(rme96);
    20692136        snd_rme96_setclockmode(rme96, val);
    20702137        spin_unlock_irqrestore(&rme96->lock, flags);
    … …  
    21072174        val = ucontrol->value.enumerated.item[0] % 4;
    21082175        spin_lock_irqsave(&rme96->lock, flags);
    2109         change = val != snd_rme96_getattenuation(rme96);
     2176
     2177        change = (int)val != snd_rme96_getattenuation(rme96);
    21102178        snd_rme96_setattenuation(rme96, val);
    21112179        spin_unlock_irqrestore(&rme96->lock, flags);
    … …  
    21482216        val = ucontrol->value.enumerated.item[0] % 4;
    21492217        spin_lock_irqsave(&rme96->lock, flags);
    2150         change = val != snd_rme96_getmontracks(rme96);
     2218        change = (int)val != snd_rme96_getmontracks(rme96);
    21512219        snd_rme96_setmontracks(rme96, val);
    21522220        spin_unlock_irqrestore(&rme96->lock, flags);

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/hammerfall_mem.c

    r215 r224  
    2626    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    2727
    28     hammerfall_mem.c,v 1.5 2002/11/04 09:11:42 perex Exp
     28    hammerfall_mem.c,v 1.8 2003/02/25 13:35:44 perex Exp
    2929
    3030
    … …  
    156156                        rbuf->flags |= HAMMERFALL_BUF_USED;
    157157                        rbuf->pci = pcidev;
    158                         MOD_INC_USE_COUNT;
    159158                        *dmaaddr = rbuf->addr;
    160159                        return rbuf->buf;
    … …  
    173172                rbuf = &hammerfall_buffers[i];
    174173                if (rbuf->buf == addr && rbuf->pci == pcidev) {
    175                         MOD_DEC_USE_COUNT;
    176174                        rbuf->flags &= ~HAMMERFALL_BUF_USED;
    177175                        return;
    … …  
    182180}
    183181
    184 static void __exit hammerfall_free_buffers (void)
     182static void hammerfall_free_buffers (void)
    185183
    186184{

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/hdsp.c

    r215 r224  
    6868MODULE_LICENSE("GPL");
    6969MODULE_CLASSES("{sound}");
    70 MODULE_DEVICES("{{RME,Hammerfall-DSP},");
     70MODULE_DEVICES("{{RME,Hammerfall-DSP}}");
    7171
    7272typedef enum {
    … …  
    455455       
    456456        for (i = 0; i < timeout; i++)
    457                 if ((hdsp_read (hdsp, HDSP_fifoStatus) & 0xff) <= count)
     457                if ((int)(hdsp_read (hdsp, HDSP_fifoStatus) & 0xff) <= count)
    458458                        return 0;
    459459
    … …  
    839839                if (!snd_rawmidi_transmit_empty (hmidi->output)) {
    840840                        if ((n_pending = snd_hdsp_midi_output_possible (hmidi->hdsp, hmidi->id)) > 0) {
    841                                 if (n_pending > sizeof (buf))
     841                                if (n_pending > (int)sizeof (buf))
    842842                                        n_pending = sizeof (buf);
    843843                               
    … …  
    873873        if ((n_pending = snd_hdsp_midi_input_available (hmidi->hdsp, hmidi->id)) > 0) {
    874874                if (hmidi->input) {
    875                         if (n_pending > sizeof (buf)) {
     875                        if (n_pending > (int)sizeof (buf)) {
    876876                                n_pending = sizeof (buf);
    877877                        }
    … …  
    12791279        val = ucontrol->value.integer.value[0] & 1;
    12801280        spin_lock_irqsave(&hdsp->lock, flags);
    1281         change = val != hdsp_spdif_out(hdsp);
     1281        change = (int)val != hdsp_spdif_out(hdsp);
    12821282        hdsp_set_spdif_output(hdsp, val);
    12831283        spin_unlock_irqrestore(&hdsp->lock, flags);
    … …  
    13941394        val = ucontrol->value.enumerated.item[0] % max;
    13951395        spin_lock_irqsave(&hdsp->lock, flags);
    1396         change = val != hdsp_sync_pref(hdsp);
     1396        change = (int)val != hdsp_sync_pref(hdsp);
    13971397        hdsp_set_sync_pref(hdsp, val);
    13981398        spin_unlock_irqrestore(&hdsp->lock, flags);
    … …  
    14981498        val = ucontrol->value.integer.value[0] & 1;
    14991499        spin_lock_irqsave(&hdsp->lock, flags);
    1500         change = val != hdsp_line_out(hdsp);
     1500        change = (int)val != hdsp_line_out(hdsp);
    15011501        hdsp_set_line_output(hdsp, val);
    15021502        spin_unlock_irqrestore(&hdsp->lock, flags);
    … …  
    15671567
    15681568        spin_lock_irqsave(&hdsp->lock, flags);
    1569         if ((change = gain != hdsp_read_gain(hdsp, addr)))
     1569        change = gain != hdsp_read_gain(hdsp, addr);
     1570        if (change)
    15701571                hdsp_write_gain(hdsp, addr, gain);
    15711572        spin_unlock_irqrestore(&hdsp->lock, flags);
    … …  
    16291630
    16301631        spin_lock_irqsave(&hdsp->lock, flags);
    1631         if ((change = gain != hdsp_read_gain(hdsp, addr)))
     1632        change = gain != hdsp_read_gain(hdsp, addr);
     1633        if (change)
    16321634                hdsp_write_gain(hdsp, addr, gain);
    16331635        spin_unlock_irqrestore(&hdsp->lock, flags);
    … …  
    18011803int snd_hdsp_create_controls(snd_card_t *card, hdsp_t *hdsp)
    18021804{
    1803         int idx, err, limit;
     1805        unsigned int idx, limit;
     1806        int err;
    18041807        snd_kcontrol_t *kctl;
    18051808
    … …  
    23002303        channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
    23012304        snd_assert(channel_buf != NULL, return -EIO);
    2302         copy_from_user(channel_buf + pos * 4, src, count * 4);
     2305        if (copy_from_user(channel_buf + pos * 4, src, count * 4))
     2306                return -EFAULT;
    23032307        return count;
    23042308}
    … …  
    23142318        channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
    23152319        snd_assert(channel_buf != NULL, return -EIO);
    2316         copy_to_user(dst, channel_buf + pos * 4, count * 4);
     2320        if (copy_to_user(dst, channel_buf + pos * 4, count * 4))
     2321                return -EFAULT;
    23172322        return count;
    23182323}
    … …  
    23882393                 */
    23892394
    2390                 if (params_rate(params) != hdsp_system_sample_rate(hdsp)) {
     2395                if ((int)params_rate(params) != hdsp_system_sample_rate(hdsp)) {
    23912396                        spin_unlock_irq(&hdsp->lock);
    23922397                        _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
    … …  
    25642569        .channels_min =         10,
    25652570        .channels_max =         HDSP_MAX_CHANNELS,
    2566         .buffer_bytes_max =     1024*1024,
    2567         .period_bytes_min =     1,
    2568         .period_bytes_max =     1024*1024,
     2571        .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
     2572        .period_bytes_min =     (64 * 4) *10,
     2573        .period_bytes_max =     (8192 * 4) * HDSP_MAX_CHANNELS,
    25692574        .periods_min =          2,
    25702575        .periods_max =          2,
    … …  
    25892594        .channels_min =         10,
    25902595        .channels_max =         HDSP_MAX_CHANNELS,
    2591         .buffer_bytes_max =     1024*1024,
    2592         .period_bytes_min =     1,
    2593         .period_bytes_max =     1024*1024,
     2596        .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
     2597        .period_bytes_min =     (64 * 4) * 10,
     2598        .period_bytes_max =     (8192 * 4) * HDSP_MAX_CHANNELS,
    25942599        .periods_min =          2,
    25952600        .periods_max =          2,
    … …  
    26242629        if (r->min > 48000) {
    26252630                snd_interval_t t = {
    2626                         min: hdsp->ds_channels,
    2627                         max: hdsp->ds_channels,
    2628                         integer: 1,
     2631                        .min = hdsp->ds_channels,
     2632                        .max = hdsp->ds_channels,
     2633                        .integer = 1,
    26292634                };
    26302635                return snd_interval_refine(c, &t);
    26312636        } else if (r->max < 64000) {
    26322637                snd_interval_t t = {
    2633                         min: hdsp->ss_channels,
    2634                         max: hdsp->ss_channels,
    2635                         integer: 1,
     2638                        .min = hdsp->ss_channels,
     2639                        .max = hdsp->ss_channels,
     2640                        .integer = 1,
    26362641                };
    26372642                return snd_interval_refine(c, &t);
    … …  
    26482653        if (c->min >= hdsp->ss_channels) {
    26492654                snd_interval_t t = {
    2650                         min: 32000,
    2651                         max: 48000,
    2652                         integer: 1,
     2655                        .min = 32000,
     2656                        .max = 48000,
     2657                        .integer = 1,
    26532658                };
    26542659                return snd_interval_refine(r, &t);
    26552660        } else if (c->max <= hdsp->ds_channels) {
    26562661                snd_interval_t t = {
    2657                         min: 64000,
    2658                         max: 96000,
    2659                         integer: 1,
     2662                        .min = 64000,
     2663                        .max = 96000,
     2664                        .integer = 1,
    26602665                };
    26612666                return snd_interval_refine(r, &t);
    … …  
    29672972        switch (rev & 0xff) {
    29682973        case 0xa:
     2974        case 0xb:
     2975        case 0x64:
    29692976                /* hdsp_initialize_firmware() will reset this */
    29702977                hdsp->card_name = "RME Hammerfall DSP";

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/rme9652.c

    r212 r224  
    2222
    2323#include <sound/driver.h>
    24 #include <asm/io.h>
    2524#include <linux/delay.h>
    2625#include <linux/init.h>
     26#include <linux/interrupt.h>
    2727#include <linux/pci.h>
    2828#include <linux/slab.h>
     29
    2930#include <sound/core.h>
    3031#include <sound/control.h>
    … …  
    3435#define SNDRV_GET_ID
    3536#include <sound/initval.h>
     37
     38#include <asm/current.h>
     39#include <asm/io.h>
    3640
    3741static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
    … …  
    260264        snd_pcm_t *pcm;
    261265        struct pci_dev *pci;
    262         snd_info_entry_t *proc_entry;
    263266        snd_kcontrol_t *spdif_ctl;
    264267
    … …  
    312315
    313316static struct pci_device_id snd_rme9652_ids[] __devinitdata = {
    314         {0x10ee, 0x3fc4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},     /* RME Digi9652 */
    315         {0,}
     317        {
     318                .vendor    = 0x10ee,
     319                .device    = 0x3fc4,
     320                .subvendor = PCI_ANY_ID,
     321                .subdevice = PCI_ANY_ID,
     322        },      /* RME Digi9652 */
     323        { 0, },
    316324};
    317325
    … …  
    367375{
    368376        int status;
    369         int offset, frag;
     377        unsigned int offset, frag;
    370378        snd_pcm_uframes_t period_size = rme9652->period_bytes / 4;
    371379        snd_pcm_sframes_t delta;
    … …  
    382390        delta = rme9652->prev_hw_offset - offset;
    383391        delta &= 0xffff;
    384         if (delta <= rme9652->max_jitter * 4)
     392        if (delta <= (snd_pcm_sframes_t)rme9652->max_jitter * 4)
    385393                offset = rme9652->prev_hw_offset;
    386394        else
    … …  
    10941102        val = ucontrol->value.integer.value[0] & 1;
    10951103        spin_lock_irqsave(&rme9652->lock, flags);
    1096         change = val != rme9652_spdif_out(rme9652);
     1104        change = (int)val != rme9652_spdif_out(rme9652);
    10971105        rme9652_set_spdif_output(rme9652, val);
    10981106        spin_unlock_irqrestore(&rme9652->lock, flags);
    … …  
    11811189        val = ucontrol->value.enumerated.item[0] % 3;
    11821190        spin_lock_irqsave(&rme9652->lock, flags);
    1183         change = val != rme9652_sync_mode(rme9652);
     1191        change = (int)val != rme9652_sync_mode(rme9652);
    11841192        rme9652_set_sync_mode(rme9652, val);
    11851193        spin_unlock_irqrestore(&rme9652->lock, flags);
    … …  
    12781286        val = ucontrol->value.enumerated.item[0] % max;
    12791287        spin_lock_irqsave(&rme9652->lock, flags);
    1280         change = val != rme9652_sync_pref(rme9652);
     1288        change = (int)val != rme9652_sync_pref(rme9652);
    12811289        rme9652_set_sync_pref(rme9652, val);
    12821290        spin_unlock_irqrestore(&rme9652->lock, flags);
    … …  
    15921600int snd_rme9652_create_controls(snd_card_t *card, rme9652_t *rme9652)
    15931601{
    1594         int idx, err;
     1602        unsigned int idx;
     1603        int err;
    15951604        snd_kcontrol_t *kctl;
    15961605
    … …  
    17901799}
    17911800
    1792 static void __init snd_rme9652_proc_init(rme9652_t *rme9652)
     1801static void __devinit snd_rme9652_proc_init(rme9652_t *rme9652)
    17931802{
    17941803        snd_info_entry_t *entry;
    17951804
    1796         if ((entry = snd_info_create_card_entry(rme9652->card, "rme9652", rme9652->card->proc_root)) !=
    1797             NULL) {
    1798                 entry->content = SNDRV_INFO_CONTENT_TEXT;
    1799                 entry->private_data = rme9652;
    1800                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
    1801                 entry->c.text.read_size = 256;
    1802                 entry->c.text.read = snd_rme9652_proc_read;
    1803                 if (snd_info_register(entry) < 0) {
    1804                         snd_info_free_entry(entry);
    1805                         entry = NULL;
    1806                 }
    1807         }
    1808         rme9652->proc_entry = entry;
    1809 }
    1810 
    1811 static void snd_rme9652_proc_done(rme9652_t *rme9652)
    1812 {
    1813         if (rme9652->proc_entry) {
    1814                 snd_info_unregister(rme9652->proc_entry);
    1815                 rme9652->proc_entry = NULL;
    1816         }
     1805        if (! snd_card_proc_new(rme9652->card, "rme9652", &entry))
     1806                snd_info_set_text_ops(entry, rme9652, snd_rme9652_proc_read);
    18171807}
    18181808
    … …  
    18461836        if (rme9652->irq >= 0)
    18471837                rme9652_stop(rme9652);
    1848         snd_rme9652_proc_done(rme9652);
    18491838        snd_rme9652_free_buffers(rme9652);
    18501839
    … …  
    18601849}
    18611850
    1862 static int __init snd_rme9652_initialize_memory(rme9652_t *rme9652)
     1851static int __devinit snd_rme9652_initialize_memory(rme9652_t *rme9652)
    18631852{
    18641853        void *pb, *cb;
    … …  
    21052094                 */
    21062095
    2107                 if (params_rate(params) !=
     2096                if ((int)params_rate(params) !=
    21082097                    rme9652_adat_sample_rate(rme9652)) {
    21092098                        spin_unlock_irq(&rme9652->lock);
    … …  
    22762265        .channels_min =         10,
    22772266        .channels_max =         26,
    2278         .buffer_bytes_max =     1024*1024,
    2279         .period_bytes_min =     1,
    2280         .period_bytes_max =     1024*1024,
     2267        .buffer_bytes_max =     RME9652_CHANNEL_BUFFER_BYTES * 26,
     2268        .period_bytes_min =     (64 * 4) * 10,
     2269        .period_bytes_max =     (8192 * 4) * 26,
    22812270        .periods_min =          2,
    22822271        .periods_max =          2,
    … …  
    22992288        .channels_min =         10,
    23002289        .channels_max =         26,
    2301         .buffer_bytes_max =     1024*1024,
    2302         .period_bytes_min =     1,
    2303         .period_bytes_max =     1024*1024,
     2290        .buffer_bytes_max =     RME9652_CHANNEL_BUFFER_BYTES *26,
     2291        .period_bytes_min =     (64 * 4) * 10,
     2292        .period_bytes_max =     (8192 * 4) * 26,
    23042293        .periods_min =          2,
    23052294        .periods_max =          2,
    … …  
    23382327        snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
    23392328        if (r->min > 48000) {
    2340 #ifdef TARGET_OS2
    2341                 snd_interval_t t = {0};
    2342                 t.min = rme9652->ds_channels;
    2343                 t.max = rme9652->ds_channels;
    2344                 t.integer = 1;
    2345 #else
    23462329                snd_interval_t t = {
    2347                         min: rme9652->ds_channels,
    2348                         max: rme9652->ds_channels,
    2349                         integer: 1,
     2330                        .min = rme9652->ds_channels,
     2331                        .max = rme9652->ds_channels,
     2332                        .integer = 1,
    23502333                };
    2351 #endif
    23522334                return snd_interval_refine(c, &t);
    23532335        } else if (r->max < 88200) {
    2354 #ifdef TARGET_OS2
    2355                 snd_interval_t t = {0};
    2356                 t.min = rme9652->ss_channels;
    2357                 t.max = rme9652->ss_channels;
    2358                 t.integer = 1;
    2359 #else
    23602336                snd_interval_t t = {
    2361                         min: rme9652->ss_channels,
    2362                         max: rme9652->ss_channels,
    2363                         integer: 1,
     2337                        .min = rme9652->ss_channels,
     2338                        .max = rme9652->ss_channels,
     2339                        .integer = 1,
    23642340                };
    2365 #endif
    23662341                return snd_interval_refine(c, &t);
    23672342        }
    … …  
    23772352        if (c->min >= rme9652->ss_channels) {
    23782353                snd_interval_t t = {
    2379 #ifdef TARGET_OS2
    2380                         44100,
    2381                         48000,
    2382                         0, 0, 1, 0,
    2383 #else
    2384                         min: 44100,
    2385                         max: 48000,
    2386                         integer: 1,
    2387 #endif
     2354                        .min = 44100,
     2355                        .max = 48000,
     2356                        .integer = 1,
    23882357                };
    23892358                return snd_interval_refine(r, &t);
    23902359        } else if (c->max <= rme9652->ds_channels) {
    23912360                snd_interval_t t = {
    2392 #ifdef TARGET_OS2
    2393                         88200,
    2394                         96000,
    2395                         0, 0, 1, 0,
    2396 #else
    2397                         min: 88200,
    2398                         max: 96000,
    2399                         integer: 1,
    2400 #endif
     2361                        .min = 88200,
     2362                        .max = 96000,
     2363                        .integer = 1,
    24012364                };
    24022365                return snd_interval_refine(r, &t);
    … …  
    25422505};
    25432506
    2544 static int __init snd_rme9652_create_pcm(snd_card_t *card,
     2507static int __devinit snd_rme9652_create_pcm(snd_card_t *card,
    25452508                                         rme9652_t *rme9652)
    25462509{
    … …  
    25662529}
    25672530
    2568 static int __init snd_rme9652_create(snd_card_t *card,
     2531static int __devinit snd_rme9652_create(snd_card_t *card,
    25692532                                     rme9652_t *rme9652,
    25702533                                     int precise_ptr)
    … …  
    27612724
    27622725static struct pci_driver driver = {
    2763         .name ="RME Digi9652 (Hammerfall)",
     2726        .name     = "RME Digi9652 (Hammerfall)",
    27642727        .id_table = snd_rme9652_ids,
    2765         .probe = snd_rme9652_probe,
    2766         .remove = __devexit_p(snd_rme9652_remove),
     2728        .probe    = snd_rme9652_probe,
     2729        .remove  = __devexit_p(snd_rme9652_remove),
    27672730};
    27682731

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/sonicvibes.c

    r212 r224  
    2424
    2525#include <sound/driver.h>
    26 #include <asm/io.h>
    2726#include <linux/delay.h>
    2827#include <linux/init.h>
     28#include <linux/interrupt.h>
    2929#include <linux/pci.h>
    3030#include <linux/slab.h>
     31#include <linux/gameport.h>
     32
    3133#include <sound/core.h>
    3234#include <sound/pcm.h>
    … …  
    3739#define SNDRV_GET_ID
    3840#include <sound/initval.h>
    39 #ifndef LINUX_2_2
    40 #include <linux/gameport.h>
    41 #endif
     41
     42#include <asm/io.h>
    4243
    4344MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
    … …  
    252253
    253254        spinlock_t reg_lock;
    254         snd_info_entry_t *proc_entry;
    255255
    256256        unsigned int p_dma_size;
    … …  
    260260        snd_kcontrol_t *master_volume;
    261261
    262 #ifndef LINUX_2_2
     262#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
    263263        struct gameport gameport;
    264264#endif
    … …  
    272272MODULE_DEVICE_TABLE(pci, snd_sonic_ids);
    273273
    274 #ifdef TARGET_OS2
    275274static ratden_t sonicvibes_adc_clock = {
    276         4000 * 65536,
    277         48000UL * 65536,
    278         1,
    279         65536,
     275        .num_min = 4000 * 65536,
     276        .num_max = 48000UL * 65536,
     277        .num_step = 1,
     278        .den = 65536,
    280279};
    281280static snd_pcm_hw_constraint_ratdens_t snd_sonicvibes_hw_constraints_adc_clock = {
    282         1,
    283         &sonicvibes_adc_clock,
     281        .nrats = 1,
     282        .rats = &sonicvibes_adc_clock,
    284283};
    285 #else
    286 static ratden_t sonicvibes_adc_clock = {
    287         num_min: 4000 * 65536,
    288         num_max: 48000UL * 65536,
    289         num_step: 1,
    290         den: 65536,
    291 };
    292 static snd_pcm_hw_constraint_ratdens_t snd_sonicvibes_hw_constraints_adc_clock = {
    293         nrats: 1,
    294         rats: &sonicvibes_adc_clock,
    295 };
    296 #endif
    297284
    298285/*
    … …  
    11371124        snd_card_t *card;
    11381125        snd_kcontrol_t *kctl;
    1139         int idx, err;
     1126        unsigned int idx;
     1127        int err;
    11401128
    11411129        snd_assert(sonic != NULL && sonic->card != NULL, return -EINVAL);
    … …  
    11921180        snd_info_entry_t *entry;
    11931181
    1194         if ((entry = snd_info_create_card_entry(sonic->card, "sonicvibes", sonic->card->proc_root)) != NULL) {
    1195                 entry->content = SNDRV_INFO_CONTENT_TEXT;
    1196                 entry->private_data = sonic;
    1197                 entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
    1198                 entry->c.text.read_size = 256;
    1199                 entry->c.text.read = snd_sonicvibes_proc_read;
    1200                 if (snd_info_register(entry) < 0) {
    1201                         snd_info_free_entry(entry);
    1202                         entry = NULL;
    1203                 }
    1204         }
    1205         sonic->proc_entry = entry;
    1206 }
    1207 
    1208 static void snd_sonicvibes_proc_done(sonicvibes_t * sonic)
    1209 {
    1210         if (sonic->proc_entry) {
    1211                 snd_info_unregister(sonic->proc_entry);
    1212                 sonic->proc_entry = NULL;
    1213         }
     1182        if (! snd_card_proc_new(sonic->card, "sonicvibes", &entry))
     1183                snd_info_set_text_ops(entry, sonic, snd_sonicvibes_proc_read);
    12141184}
    12151185
    … …  
    12231193static int snd_sonicvibes_free(sonicvibes_t *sonic)
    12241194{
    1225 #ifndef LINUX_2_2
     1195#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
    12261196        if (sonic->gameport.io)
    12271197                gameport_unregister_port(&sonic->gameport);
    12281198#endif
    1229         snd_sonicvibes_proc_done(sonic);
    12301199        pci_write_config_dword(sonic->pci, 0x40, sonic->dmaa_port);
    12311200        pci_write_config_dword(sonic->pci, 0x48, sonic->dmac_port);
    … …  
    14551424        snd_card_t *card = sonic->card;
    14561425        snd_rawmidi_str_t *dir;
    1457         int idx, err;
     1426        unsigned int idx;
     1427        int err;
    14581428
    14591429        mpu->private_data = sonic;
    … …  
    15271497                return err;
    15281498        }
    1529 #ifndef LINUX_2_2
     1499#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
    15301500        sonic->gameport.io = sonic->game_port;
    15311501        gameport_register_port(&sonic->gameport);

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/trident/trident_main.c

    r210 r224  
    2929
    3030#include <sound/driver.h>
    31 #include <asm/io.h>
    3231#include <linux/delay.h>
    3332#include <linux/init.h>
     33#include <linux/interrupt.h>
    3434#include <linux/pci.h>
    3535#include <linux/slab.h>
    3636#include <linux/vmalloc.h>
     37#ifndef TARGET_OS2 //TODO: Implement linux/gameport.h
     38#include <linux/gameport.h>
     39#endif /* !TARGET_OS2 */
     40
    3741#include <sound/core.h>
    3842#include <sound/info.h>
    … …  
    4044#include <sound/trident.h>
    4145#include <sound/asoundef.h>
     46
     47#include <asm/io.h>
     48
     49#define chip_t trident_t
    4250
    4351static int snd_trident_pcm_mixer_build(struct snd_trident *trident, struct snd_trident_voice* voice, snd_pcm_substream_t *substream);
    … …  
    10151023    if (voice->memblk)
    10161024        voice->LBA = voice->memblk->offset;
     1025        else
     1026                voice->LBA = runtime->dma_addr;
     1027        outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
    10171028
    10181029    // set ESO
    … …  
    24192430static snd_kcontrol_new_t snd_trident_spdif_default __devinitdata =
    24202431{
    2421         .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
    2422         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
     2432        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
     2433        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
    24232434        .info =         snd_trident_spdif_default_info,
    24242435        .get =          snd_trident_spdif_default_get,
    … …  
    39954006EXPORT_SYMBOL(snd_trident_write_voice_regs);
    39964007EXPORT_SYMBOL(snd_trident_clear_voices);
     4008#ifdef CONFIG_PM
     4009EXPORT_SYMBOL(snd_trident_suspend);
     4010EXPORT_SYMBOL(snd_trident_resume);
     4011#endif
    39974012/* trident_memory.c symbols */
    39984013EXPORT_SYMBOL(snd_trident_synth_alloc);

  • TabularUnified GPL/branches/alsa-resync1/alsa-kernel/pci/ymfpci/ymfpci_main.c

    r210 r224  
    2626
    2727#include <sound/driver.h>
    28 #include <asm/io.h>
    2928#include <linux/delay.h>
    3029#include <linux/init.h>
     30#include <linux/interrupt.h>
    3131#include <linux/pci.h>
     32#include <linux/sched.h>
    3233#include <linux/slab.h>
    3334#include <linux/vmalloc.h>
     35
    3436#include <sound/core.h>
    3537#include <sound/control.h>
    … …  
    3840#include <sound/asoundef.h>
    3941#include <sound/mpu401.h>
     42
     43#include <asm/io.h>
     44
    4045#ifdef TARGET_OS2
    4146#include <sound/timer.h>
    … …  
    13161321{
    13171322        .access =       SNDRV_CTL_ELEM_ACCESS_READ,
    1318         .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
    1319         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
     1323        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
     1324        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
    13201325        .info =         snd_ymfpci_spdif_mask_info,
    13211326        .get =          snd_ymfpci_spdif_mask_get,
Note: See TracChangeset for help on using the changeset viewer.