Changeset 215


Ignore:
Timestamp:
Jul 16, 2007, 2:45:34 AM (18 years ago)
Author:
Brendan Oakley
Message:

Merged to Alsa 0.9.0rc6

Location:
GPL/branches/alsa-resync1/alsa-kernel
Files:
34 deleted
20 edited

Legend:

Unmodified
Added
Removed

  • GPL/branches/alsa-resync1/alsa-kernel/core/pcm_sgbuf.c

    r212 r215  
    6767        sgbuf->table = kmalloc(sizeof(struct snd_sg_page) * tblsize, GFP_KERNEL);
    6868        if (! sgbuf->table) {
    69                 snd_pcm_sgbuf_free(substream);
     69                snd_pcm_sgbuf_delete(substream);
    7070                return -ENOMEM;
    7171        }
    … …  
    159159/*
    160160 * get the page pointer on the given offset
    161  * used as the page callback of pcm ops
    162  */
    163 void *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset)
     161 */
     162static void *sgbuf_get_addr(snd_pcm_substream_t *substream, unsigned long offset)
    164163{
    165164        struct snd_sg_buf *sgbuf;
    … …  
    172171        return sgbuf->table[idx].buf;
    173172}
     173
     174/*
     175 * get the page struct at the given offset
     176 * used as the page callback of pcm ops
     177 */
     178struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset)
     179{
     180        void *addr = sgbuf_get_addr(substream, offset);
     181        if (addr)
     182                return virt_to_page(addr);
     183        else
     184                return 0;
     185}
    174186#endif
     187
    175188/*
    176189 * do copy_from_user to the sg buffer
    … …  
    185198        len = PAGE_SIZE - hwoff;
    186199        for (;;) {
    187                 addr = snd_pcm_sgbuf_ops_page(substream, p);
     200                addr = sgbuf_get_addr(substream, p);
    188201                if (! addr)
    189202                        return -EFAULT;
    … …  
    215228        len = PAGE_SIZE - hwoff;
    216229        for (;;) {
    217                 addr = snd_pcm_sgbuf_ops_page(substream, p);
     230                addr = sgbuf_get_addr(substream, p);
    218231                if (! addr)
    219232                        return -EFAULT;
    … …  
    247260        page_len = bytes_to_samples(substream->runtime, PAGE_SIZE);
    248261        for (;;) {
    249                 addr = snd_pcm_sgbuf_ops_page(substream, p);
     262                addr = sgbuf_get_addr(substream, p);
    250263                if (! addr)
    251264                        return -EFAULT;

  • GPL/branches/alsa-resync1/alsa-kernel/drivers/mtpav.c

    r212 r215  
    685685                spin_lock_init(&ncrd->spinlock);
    686686
     687                init_timer(&ncrd->timer);
    687688                ncrd->card = NULL;
    688689                ncrd->irq = -1;

  • GPL/branches/alsa-resync1/alsa-kernel/drivers/serial-u16550.c

    r212 r215  
    888888        uart->rstatus = 0;
    889889    memset(uart->prev_status, 0x80, sizeof(unsigned char) * SNDRV_SERIAL_MAX_OUTS);
     890        init_timer(&uart->buffer_timer);
    890891    uart->buffer_timer.function = snd_uart16550_buffer_timer;
    891892    uart->buffer_timer.data = (unsigned long)uart;

  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/adriver.h

    • Property svn:eol-style set to native

  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/core.h

    r212 r215  
    262262#define kcalloc(n, size, flags) snd_hidden_kcalloc(n, size, flags)
    263263#define kfree(obj) snd_hidden_kfree(obj)
    264 #define kfree_nocheck(obj) snd_wrapper_kfree(obj)
    265264#define vmalloc(size) snd_hidden_vmalloc(size)
    266265#define vfree(obj) snd_hidden_vfree(obj)
    267266#define kstrdup(s, flags)  snd_hidden_kstrdup(s, flags)
    268267#else
     268#define kmalloc_nocheck(size, flags) kmalloc(size, flags)
     269#define vmalloc_nocheck(size) vmalloc(size)
    269270#define kfree_nocheck(obj) kfree(obj)
    270271#endif

  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/cs4231.h

    r212 r215  
    2727#include "timer.h"
    2828
     29#ifdef CONFIG_SBUS
     30#define SBUS_SUPPORT
     31#include <asm/sbus.h>
     32#endif
     33
     34#if defined(CONFIG_PCI) && defined(CONFIG_SPARC64)
     35#define EBUS_SUPPORT
     36#include <linux/pci.h>
     37#include <asm/ebus.h>
     38#endif
     39
     40#if !defined(SBUS_SUPPORT) && !defined(EBUS_SUPPORT)
     41#define LEGACY_SUPPORT
     42#endif
     43
    2944/* IO ports */
    3045
    31 #define CS4231P(chip, x)        ((chip)->port + c_d_c_CS4231##x)
     46#define CS4231P(x)              (c_d_c_CS4231##x)
    3247
    3348#define c_d_c_CS4231REGSEL      0
    … …  
    222237struct _snd_cs4231 {
    223238        unsigned long port;             /* base i/o port */
     239#ifdef LEGACY_SUPPORT
    224240        struct resource *res_port;
    225241        unsigned long cport;            /* control base i/o port (CS4236) */
    … …  
    228244        int dma1;                       /* playback DMA */
    229245        int dma2;                       /* record DMA */
     246#endif
    230247        unsigned short version;         /* version of CODEC chip */
    231248        unsigned short mode;            /* see to CS4231_MODE_XXXX */
    232249        unsigned short hardware;        /* see to CS4231_HW_XXXX */
    233250        unsigned short hwshare;         /* shared resources */
    234         unsigned short single_dma:1;    /* forced single DMA mode (GUS 16-bit daughter board) or dma1 == dma2 */
     251        unsigned short single_dma:1,    /* forced single DMA mode (GUS 16-bit daughter board) or dma1 == dma2 */
     252                       ebus_flag:1;     /* SPARC: EBUS present */
     253
     254#ifdef EBUS_SUPPORT
     255        struct ebus_dma_info eb2c;
     256        struct ebus_dma_info eb2p;
     257#endif
     258
     259#if defined(SBUS_SUPPORT) || defined(EBUS_SUPPORT)
     260        union {
     261#ifdef SBUS_SUPPORT
     262                struct sbus_dev         *sdev;
     263#endif
     264#ifdef EBUS_SUPPORT
     265                struct pci_dev          *pdev;
     266#endif
     267        } dev_u;
     268        unsigned int p_periods_sent;
     269        unsigned int c_periods_sent;
     270#endif
    235271
    236272        snd_card_t *card;
    … …  
    246282        int calibrate_mute;
    247283        int sw_3d_bit;
     284#ifdef LEGACY_SUPPORT
    248285        unsigned int p_dma_size;
    249286        unsigned int c_dma_size;
     287#endif
    250288
    251289        spinlock_t reg_lock;
    … …  
    256294        void (*set_playback_format) (cs4231_t *chip, snd_pcm_hw_params_t *hw_params, unsigned char pdfr);
    257295        void (*set_capture_format) (cs4231_t *chip, snd_pcm_hw_params_t *hw_params, unsigned char cdfr);
     296        void (*trigger) (cs4231_t *chip, unsigned int what, int start);
    258297#ifdef CONFIG_PM
    259298        void (*suspend) (cs4231_t *chip);
    … …  
    261300#endif
    262301        void *dma_private_data;
     302#ifdef LEGACY_SUPPORT
    263303        int (*claim_dma) (cs4231_t *chip, void *dma_private_data, int dma);
    264304        int (*release_dma) (cs4231_t *chip, void *dma_private_data, int dma);
     305#endif
    265306};
    266307

  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/pcm_sgbuf.h

    r32 r215  
    110110int snd_pcm_sgbuf_ops_copy_capture(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t hwoff, void *buf, snd_pcm_uframes_t count);
    111111int snd_pcm_sgbuf_ops_silence(snd_pcm_substream_t *substream, int channel, snd_pcm_uframes_t hwoff, snd_pcm_uframes_t count);
    112 void *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset);
     112struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset);
    113113
    114114

  • GPL/branches/alsa-resync1/alsa-kernel/include/sound/uda1341.h

    • Property svn:eol-style set to native

  • GPL/branches/alsa-resync1/alsa-kernel/isa/cs423x/cs4231_lib.c

    r212 r215  
    125125 */
    126126
     127#if !defined(EBUS_SUPPORT) && !defined(SBUS_SUPPORT)
     128#define __CS4231_INLINE__ inline
     129#else
     130#define __CS4231_INLINE__ /* nothing */
     131#endif
     132
     133static __CS4231_INLINE__ void cs4231_outb(cs4231_t *chip, u8 offset, u8 val)
     134{
     135#ifdef EBUS_SUPPORT
     136        if (chip->ebus->flag) {
     137                writeb(val, chip->port + (offset << 2));
     138        } else {
     139#endif
     140#ifdef SBUS_SUPPORT
     141                sbus_writeb(val, chip->port + (offset << 2));
     142#endif
     143#ifdef EBUS_SUPPORT
     144        }
     145#endif
     146#ifdef LEGACY_SUPPORT
     147        outb(val, chip->port + offset);
     148#endif
     149}
     150
     151static __CS4231_INLINE__ u8 cs4231_inb(cs4231_t *chip, u8 offset)
     152{
     153#ifdef EBUS_SUPPORT
     154        if (chip->ebus_flag) {
     155                return readb(chip->port + (offset << 2));
     156        } else {
     157#endif
     158#ifdef SBUS_SUPPORT
     159                return sbus_writeb(chip->port + (offset << 2));
     160#endif
     161#ifdef EBUS_SUPPORT
     162        }
     163#endif
     164#ifdef LEGACY_SUPPORT
     165        return inb(chip->port + offset);
     166#endif
     167}
     168
    127169void snd_cs4231_outm(cs4231_t *chip, unsigned char reg,
    128170                     unsigned char mask, unsigned char value)
    … …  
    132174
    133175        for (timeout = 250;
    134              timeout > 0 && (inb(CS4231P(chip, REGSEL)) & CS4231_INIT);
     176             timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
    135177             timeout--)
    136178                udelay(100);
    137179#ifdef CONFIG_SND_DEBUG
    138         if (inb(CS4231P(chip, REGSEL)) & CS4231_INIT)
     180        if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
    139181                snd_printk("outm: auto calibration time out - reg = 0x%x, value = 0x%x\n", reg, value);
    140182#endif
    … …  
    143185                chip->image[reg] |= value;
    144186        } else {
    145                 outb(chip->mce_bit | reg, CS4231P(chip, REGSEL));
     187                cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
    146188                mb();
    147189                tmp = (chip->image[reg] & mask) | value;
    148                 outb(tmp, CS4231P(chip, REG));
     190                cs4231_outb(chip, CS4231P(REG), tmp);
    149191                chip->image[reg] = tmp;
    150192                mb();
    … …  
    157199
    158200        for (timeout = 250;
    159              timeout > 0 && (inb(CS4231P(chip, REGSEL)) & CS4231_INIT);
     201             timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
    160202             timeout--)
    161203                udelay(10);
    162         outb(chip->mce_bit | reg, CS4231P(chip, REGSEL));
    163         outb(value, CS4231P(chip, REG));
     204        cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
     205        cs4231_outb(chip, CS4231P(REG), value);
    164206        mb();
    165207}
    … …  
    170212
    171213        for (timeout = 250;
    172              timeout > 0 && (inb(CS4231P(chip, REGSEL)) & CS4231_INIT);
     214             timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
    173215             timeout--)
    174216                udelay(100);
    175217#ifdef CONFIG_SND_DEBUG
    176         if (inb(CS4231P(chip, REGSEL)) & CS4231_INIT)
     218        if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
    177219                snd_printk("out: auto calibration time out - reg = 0x%x, value = 0x%x\n", reg, value);
    178220#endif
    179         outb(chip->mce_bit | reg, CS4231P(chip, REGSEL));
    180         outb(value, CS4231P(chip, REG));
     221        cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
     222        cs4231_outb(chip, CS4231P(REG), value);
    181223        chip->image[reg] = value;
    182224        mb();
    … …  
    191233
    192234        for (timeout = 250;
    193              timeout > 0 && (inb(CS4231P(chip, REGSEL)) & CS4231_INIT);
     235             timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
    194236             timeout--)
    195237                udelay(100);
    196238#ifdef CONFIG_SND_DEBUG
    197         if (inb(CS4231P(chip, REGSEL)) & CS4231_INIT)
     239        if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
    198240                snd_printk("in: auto calibration time out - reg = 0x%x\n", reg);
    199241#endif
    200         outb(chip->mce_bit | reg, CS4231P(chip, REGSEL));
     242        cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
    201243        mb();
    202         return inb(CS4231P(chip, REG));
     244        return cs4231_inb(chip, CS4231P(REG));
    203245}
    204246
    205247void snd_cs4236_ext_out(cs4231_t *chip, unsigned char reg, unsigned char val)
    206248{
    207         outb(chip->mce_bit | 0x17, CS4231P(chip, REGSEL));
    208         outb(reg | (chip->image[CS4236_EXT_REG] & 0x01), CS4231P(chip, REG));
    209         outb(val, CS4231P(chip, REG));
     249        cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | 0x17);
     250        cs4231_outb(chip, CS4231P(REG), reg | (chip->image[CS4236_EXT_REG] & 0x01));
     251        cs4231_outb(chip, CS4231P(REG), val);
    210252        chip->eimage[CS4236_REG(reg)] = val;
    211253#if 0
    … …  
    216258unsigned char snd_cs4236_ext_in(cs4231_t *chip, unsigned char reg)
    217259{
    218         outb(chip->mce_bit | 0x17, CS4231P(chip, REGSEL));
    219         outb(reg | (chip->image[CS4236_EXT_REG] & 0x01), CS4231P(chip, REG));
     260        cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | 0x17);
     261        cs4231_outb(chip, CS4231P(REG), reg | (chip->image[CS4236_EXT_REG] & 0x01));
    220262#if 1
    221         return inb(CS4231P(chip, REG));
     263        return cs4231_inb(chip, CS4231P(REG));
    222264#else
    223265        {
    224266                unsigned char res;
    225                 res = inb(CS4231P(chip, REG));
     267                res = cs4231_inb(chip, CS4231P(REG));
    226268                printk("ext in : reg = 0x%x, val = 0x%x\n", reg, res);
    227269                return res;
    … …  
    234276void snd_cs4231_debug(cs4231_t *chip)
    235277{
    236         printk("CS4231 REGS:      INDEX = 0x%02x  ", inb(CS4231P(chip, REGSEL)));
    237         printk("                 STATUS = 0x%02x\n", inb(CS4231P(chip, STATUS)));
     278        printk("CS4231 REGS:      INDEX = 0x%02x  ", cs4231_inb(chip, CS4231P(REGSEL)));
     279        printk("                 STATUS = 0x%02x\n", cs4231_inb(chip, CS4231P(STATUS)));
    238280        printk("  0x00: left input      = 0x%02x  ", snd_cs4231_in(chip, 0x00));
    239281        printk("  0x10: alt 1 (CFIG 2)  = 0x%02x\n", snd_cs4231_in(chip, 0x10));
    … …  
    282324        /* huh.. looks like this sequence is proper for CS4231A chip (GUS MAX) */
    283325        for (timeout = 5; timeout > 0; timeout--)
    284                 inb(CS4231P(chip, REGSEL));
     326                cs4231_inb(chip, CS4231P(REGSEL));
    285327        /* end of cleanup sequence */
    286328        for (timeout = 250;
    287              timeout > 0 && (inb(CS4231P(chip, REGSEL)) & CS4231_INIT);
     329             timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
    288330             timeout--)
    289331                udelay(10);
    … …  
    296338
    297339        spin_lock_irqsave(&chip->reg_lock, flags);
    298         for (timeout = 250; timeout > 0 && (inb(CS4231P(chip, REGSEL)) & CS4231_INIT); timeout--)
     340        for (timeout = 250; timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT); timeout--)
    299341                udelay(100);
    300342#ifdef CONFIG_SND_DEBUG
    301         if (inb(CS4231P(chip, REGSEL)) & CS4231_INIT)
     343        if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
    302344                snd_printk("mce_up - auto calibration time out (0)\n");
    303345#endif
    304346        chip->mce_bit |= CS4231_MCE;
    305         timeout = inb(CS4231P(chip, REGSEL));
     347        timeout = cs4231_inb(chip, CS4231P(REGSEL));
    306348        if (timeout == 0x80)
    307349                snd_printk("mce_up [0x%lx]: serious init problem - codec still busy\n", chip->port);
    308350        if (!(timeout & CS4231_MCE))
    309                 outb(chip->mce_bit | (timeout & 0x1f), CS4231P(chip, REGSEL));
     351                cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
    310352        spin_unlock_irqrestore(&chip->reg_lock, flags);
    311353}
    … …  
    323365#endif
    324366#ifdef CONFIG_SND_DEBUG
    325         if (inb(CS4231P(chip, REGSEL)) & CS4231_INIT)
    326                 snd_printk("mce_down [0x%lx] - auto calibration time out (0)\n", CS4231P(chip, REGSEL));
     367        if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
     368                snd_printk("mce_down [0x%lx] - auto calibration time out (0)\n", (long)CS4231P(REGSEL));
    327369#endif
    328370        chip->mce_bit &= ~CS4231_MCE;
    329         timeout = inb(CS4231P(chip, REGSEL));
    330         outb(chip->mce_bit | (timeout & 0x1f), CS4231P(chip, REGSEL));
     371        timeout = cs4231_inb(chip, CS4231P(REGSEL));
     372        cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
    331373        if (timeout == 0x80)
    332374                snd_printk("mce_down [0x%lx]: serious init problem - codec still busy\n", chip->port);
    … …  
    365407#endif
    366408        time = HZ / 10;
    367         while (inb(CS4231P(chip, REGSEL)) & CS4231_INIT) {
     409        while (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT) {
    368410                spin_unlock_irqrestore(&chip->reg_lock, flags);
    369411                if (time <= 0) {
    … …  
    378420#if 0
    379421        printk("(4) jiffies = %li\n", jiffies);
    380         snd_printk("mce_down - exit = 0x%x\n", inb(CS4231P(chip, REGSEL)));
     422        snd_printk("mce_down - exit = 0x%x\n", cs4231_inb(chip, CS4231P(REGSEL)));
    381423#endif
    382424}
    … …  
    404446
    405447#if 0
    406         printk("codec trigger!!! - what = %i, enable = %i, status = 0x%x\n", what, enable, inb(CS4231P(card, STATUS)));
     448        printk("codec trigger!!! - what = %i, enable = %i, status = 0x%x\n", what, enable, cs4231_inb(chip, CS4231P(STATUS)));
    407449#endif
    408450
    … …  
    424466                } while (s != substream);
    425467                spin_lock(&chip->reg_lock);
    426                 if (cmd == SNDRV_PCM_TRIGGER_START)
     468                if (cmd == SNDRV_PCM_TRIGGER_START) {
    427469                        chip->image[CS4231_IFACE_CTRL] |= what;
    428                 else
     470                        if (chip->trigger)
     471                                chip->trigger(chip, what, 1);
     472                } else {
    429473                        chip->image[CS4231_IFACE_CTRL] &= ~what;
     474                        if (chip->trigger)
     475                                chip->trigger(chip, what, 0);
     476                }
    430477                snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
    431478                spin_unlock(&chip->reg_lock);
    … …  
    714761                       CS4231_TIMER_IRQ);
    715762        snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
    716         outb(0, CS4231P(chip, STATUS)); /* clear IRQ */
    717         outb(0, CS4231P(chip, STATUS)); /* clear IRQ */
     763        cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
     764        cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
    718765        chip->image[CS4231_PIN_CTRL] |= CS4231_IRQ_ENABLE;
    719766        snd_cs4231_out(chip, CS4231_PIN_CTRL, chip->image[CS4231_PIN_CTRL]);
    … …  
    744791        spin_lock_irqsave(&chip->reg_lock, flags);
    745792        snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
    746         outb(0, CS4231P(chip, STATUS)); /* clear IRQ */
    747         outb(0, CS4231P(chip, STATUS)); /* clear IRQ */
     793        cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
     794        cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
    748795        chip->image[CS4231_PIN_CTRL] &= ~CS4231_IRQ_ENABLE;
    749796        snd_cs4231_out(chip, CS4231_PIN_CTRL, chip->image[CS4231_PIN_CTRL]);
    … …  
    766813        /* clear IRQ again */
    767814        snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
    768         outb(0, CS4231P(chip, STATUS)); /* clear IRQ */
    769         outb(0, CS4231P(chip, STATUS)); /* clear IRQ */
     815        cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
     816        cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
    770817        spin_unlock_irqrestore(&chip->reg_lock, flags);
    771818
    … …  
    830877}
    831878
     879#ifdef LEGACY_SUPPORT
    832880static int snd_cs4231_playback_prepare(snd_pcm_substream_t * substream)
    833881{
    … …  
    851899        return 0;
    852900}
     901#endif /* LEGACY_SUPPORT */
    853902
    854903static int snd_cs4231_capture_hw_params(snd_pcm_substream_t * substream,
    … …  
    872921}
    873922
     923#ifdef LEGACY_SUPPORT
    874924static int snd_cs4231_capture_prepare(snd_pcm_substream_t * substream)
    875925{
    … …  
    895945        return 0;
    896946}
     947#endif
    897948
    898949static void snd_cs4231_overrange(cs4231_t *chip)
    … …  
    941992}
    942993
     994#ifdef LEGACY_SUPPORT
    943995static snd_pcm_uframes_t snd_cs4231_playback_pointer(snd_pcm_substream_t * substream)
    944996{
    … …  
    9621014        return bytes_to_frames(substream->runtime, ptr);
    9631015}
     1016#endif /* LEGACY_SUPPORT */
    9641017
    9651018/*
    … …  
    9671020 */
    9681021
    969 static int snd_cs4231_probe(cs4231_t *chip)
     1022int snd_cs4231_probe(cs4231_t *chip)
    9701023{
    9711024        unsigned long flags;
    … …  
    9801033        for (i = 0; i < 50; i++) {
    9811034                mb();
    982                 if (inb(CS4231P(chip, REGSEL)) & CS4231_INIT)
     1035                if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
    9831036                        udelay(2000);
    9841037                else {
    … …  
    10211074        }
    10221075        spin_lock_irqsave(&chip->reg_lock, flags);
    1023         inb(CS4231P(chip, STATUS));     /* clear any pendings IRQ */
    1024         outb(0, CS4231P(chip, STATUS));
     1076        cs4231_inb(chip, CS4231P(STATUS));      /* clear any pendings IRQ */
     1077        cs4231_outb(chip, CS4231P(STATUS), 0);
    10251078        mb();
    10261079        spin_unlock_irqrestore(&chip->reg_lock, flags);
    … …  
    11901243                runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE;
    11911244
     1245#ifdef LEGACY_SUPPORT
    11921246        snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.buffer_bytes_max);
    11931247        snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.period_bytes_max);
    … …  
    11971251                        return err;
    11981252        }
     1253#endif
    11991254
    12001255        if ((err = snd_cs4231_open(chip, CS4231_MODE_PLAY)) < 0) {
     1256#ifdef LEGACY_SUPPORT
    12011257                if (chip->release_dma)
    12021258                        chip->release_dma(chip, chip->dma_private_data, chip->dma1);
     1259#endif
    12031260                snd_free_pages(runtime->dma_area, runtime->dma_bytes);
    12041261                return err;
    12051262        }
    12061263        chip->playback_substream = substream;
     1264#if defined(SBUS_SUPPORT) || defined(EBUS_SUPPORT)
     1265        chip->p_periods_sent = 0;
     1266#endif
    12071267        snd_pcm_set_sync(substream);
    12081268        chip->rate_constraint(runtime);
    … …  
    12231283                runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE;
    12241284
     1285#ifdef LEGACY_SUPPORT
     1286        snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.buffer_bytes_max);
     1287        snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.period_bytes_max);
     1288
    12251289        if (chip->claim_dma) {
    12261290                if ((err = chip->claim_dma(chip, chip->dma_private_data, chip->dma2)) < 0)
    12271291                        return err;
    12281292        }
    1229 
    1230         snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.buffer_bytes_max);
    1231         snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.period_bytes_max);
     1293#endif
    12321294
    12331295        if ((err = snd_cs4231_open(chip, CS4231_MODE_RECORD)) < 0) {
     1296#ifdef LEGACY_SUPPORT
    12341297                if (chip->release_dma)
    12351298                        chip->release_dma(chip, chip->dma_private_data, chip->dma2);
     1299#endif
    12361300                snd_free_pages(runtime->dma_area, runtime->dma_bytes);
    12371301                return err;
    12381302        }
    12391303        chip->capture_substream = substream;
     1304#if defined(SBUS_SUPPORT) || defined(EBUS_SUPPORT)
     1305        chip->c_periods_sent = 0;
     1306#endif
    12401307        snd_pcm_set_sync(substream);
    12411308        chip->rate_constraint(runtime);
    … …  
    13021369        snd_cs4231_busy_wait(chip);
    13031370        chip->mce_bit &= ~CS4231_MCE;
    1304         timeout = inb(CS4231P(chip, REGSEL));
    1305         outb(chip->mce_bit | (timeout & 0x1f), CS4231P(chip, REGSEL));
     1371        timeout = cs4231_inb(chip, CS4231P(REGSEL));
     1372        cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
    13061373        if (timeout == 0x80)
    13071374                snd_printk("down [0x%lx]: serious init problem - codec still busy\n", chip->port);
    … …  
    13351402#endif /* CONFIG_PM */
    13361403
     1404#ifdef LEGACY_SUPPORT
     1405
    13371406static int snd_cs4231_free(cs4231_t *chip)
    13381407{
    … …  
    13731442        return snd_cs4231_free(chip);   
    13741443}
     1444
     1445#endif /* LEGACY_SUPPORT */
    13751446
    13761447const char *snd_cs4231_chip_id(cs4231_t *chip)
    … …  
    13931464}
    13941465
    1395 int snd_cs4231_create(snd_card_t * card,
    1396                       unsigned long port,
    1397                       unsigned long cport,
    1398                       int irq, int dma1, int dma2,
     1466static int snd_cs4231_new(snd_card_t * card,
    13991467                      unsigned short hardware,
    14001468                      unsigned short hwshare,
    14011469                      cs4231_t ** rchip)
    14021470{
    1403         static snd_device_ops_t ops = {
    1404                 .dev_free =     snd_cs4231_dev_free,
    1405         };
    14061471        cs4231_t *chip;
    1407         int err;
    14081472
    14091473        *rchip = NULL;
    … …  
    14111475        if (chip == NULL)
    14121476                return -ENOMEM;
    1413         chip->irq = -1;
    1414         chip->dma1 = -1;
    1415         chip->dma2 = -1;
    14161477        chip->hardware = hardware;
    14171478        chip->hwshare = hwshare;
    1418 
    1419         if ((chip->res_port = request_region(port, 4, "CS4231")) == NULL) {
    1420                 snd_cs4231_free(chip);
    1421                 return -EBUSY;
    1422         }
    1423         chip->port = port;
    1424         if ((long)cport >= 0 && (chip->res_cport = request_region(cport, 8, "CS4232 Control")) == NULL) {
    1425                 snd_cs4231_free(chip);
    1426                 return -ENODEV;
    1427         }
    1428         chip->cport = cport;
    1429         if (!(hwshare & CS4231_HWSHARE_IRQ) && request_irq(irq, snd_cs4231_interrupt, SA_INTERRUPT, "CS4231", (void *) chip)) {
    1430                 snd_cs4231_free(chip);
    1431                 return -EBUSY;
    1432         }
    1433         chip->irq = irq;
    1434         if (!(hwshare & CS4231_HWSHARE_DMA1) && request_dma(dma1, "CS4231 - 1")) {
    1435                 snd_cs4231_free(chip);
    1436                 return -EBUSY;
    1437         }
    1438         chip->dma1 = dma1;
    1439         if (!(hwshare & CS4231_HWSHARE_DMA2) && dma1 != dma2 && dma2 >= 0 && request_dma(dma2, "CS4231 - 2")) {
    1440                 snd_cs4231_free(chip);
    1441                 return -EBUSY;
    1442         }
    1443         if (dma1 == dma2 || dma2 < 0) {
    1444                 chip->single_dma = 1;
    1445                 chip->dma2 = chip->dma1;
    1446         } else
    1447                 chip->dma2 = dma2;
    14481479
    14491480        spin_lock_init(&chip->reg_lock);
    … …  
    14561487        memcpy(&chip->image, &snd_cs4231_original_image, sizeof(snd_cs4231_original_image));
    14571488
     1489        *rchip = chip;
     1490        return 0;
     1491}
     1492
     1493#ifdef LEGACY_SUPPORT
     1494
     1495int snd_cs4231_create(snd_card_t * card,
     1496                      unsigned long port,
     1497                      unsigned long cport,
     1498                      int irq, int dma1, int dma2,
     1499                      unsigned short hardware,
     1500                      unsigned short hwshare,
     1501                      cs4231_t ** rchip)
     1502{
     1503        static snd_device_ops_t ops = {
     1504                .dev_free =     snd_cs4231_dev_free,
     1505        };
     1506        cs4231_t *chip;
     1507        int err;
     1508
     1509        err = snd_cs4231_new(card, hardware, hwshare, &chip);
     1510        if (err < 0)
     1511                return err;
     1512       
     1513        chip->irq = -1;
     1514        chip->dma1 = -1;
     1515        chip->dma2 = -1;
     1516
     1517        if ((chip->res_port = request_region(port, 4, "CS4231")) == NULL) {
     1518                snd_cs4231_free(chip);
     1519                return -EBUSY;
     1520        }
     1521        chip->port = port;
     1522        if ((long)cport >= 0 && (chip->res_cport = request_region(cport, 8, "CS4232 Control")) == NULL) {
     1523                snd_cs4231_free(chip);
     1524                return -ENODEV;
     1525        }
     1526        chip->cport = cport;
     1527        if (!(hwshare & CS4231_HWSHARE_IRQ) && request_irq(irq, snd_cs4231_interrupt, SA_INTERRUPT, "CS4231", (void *) chip)) {
     1528                snd_cs4231_free(chip);
     1529                return -EBUSY;
     1530        }
     1531        chip->irq = irq;
     1532        if (!(hwshare & CS4231_HWSHARE_DMA1) && request_dma(dma1, "CS4231 - 1")) {
     1533                snd_cs4231_free(chip);
     1534                return -EBUSY;
     1535        }
     1536        chip->dma1 = dma1;
     1537        if (!(hwshare & CS4231_HWSHARE_DMA2) && dma1 != dma2 && dma2 >= 0 && request_dma(dma2, "CS4231 - 2")) {
     1538                snd_cs4231_free(chip);
     1539                return -EBUSY;
     1540        }
     1541        if (dma1 == dma2 || dma2 < 0) {
     1542                chip->single_dma = 1;
     1543                chip->dma2 = chip->dma1;
     1544        } else
     1545                chip->dma2 = dma2;
     1546
    14581547        /* global setup */
    14591548        if (snd_cs4231_probe(chip) < 0) {
    … …  
    14861575        return 0;
    14871576}
     1577
     1578#endif /* LEGACY_SUPPORT */
    14881579
    14891580static snd_pcm_ops_t snd_cs4231_playback_ops = {
    … …  
    15411632        strcpy(pcm->name, snd_cs4231_chip_id(chip));
    15421633
     1634#ifdef LEGACY_SUPPORT
    15431635        snd_pcm_lib_preallocate_isa_pages_for_all(pcm, 64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
     1636#else
     1637#  ifdef EBUS_SUPPORT
     1638        if (chip->ebus_flag) {
     1639                snd_pcm_lib_preallocate_pci_pages_for_all(chip->dev_u.pdev, pcm,
     1640                                                          64*1024, 128*1024);
     1641        } else {
     1642#  endif
     1643#  ifdef SBUS_SUPPORT
     1644                snd_pcm_lib_preallocate_sbus_pages_for_all(chip->dev_u.sdev, pcm,
     1645                                                           64*1024, 128*1024);
     1646#  endif
     1647#  ifdef EBUS_SUPPORT
     1648        }
     1649#  endif
     1650#endif
    15441651
    15451652        chip->pcm = pcm;

  • GPL/branches/alsa-resync1/alsa-kernel/isa/es18xx.c

    r212 r215  
    155155#define ES18XX_PM_GPO0  0x01
    156156#define ES18XX_PM_GPO1  0x02
    157 #define ES18XX_PM_PDR   0x03
    158 #define ES18XX_PM_ANA   0x04
    159 #define ES18XX_PM_FM    0x06
    160 #define ES18XX_PM_SUS   0x08
     157#define ES18XX_PM_PDR   0x04
     158#define ES18XX_PM_ANA   0x08
     159#define ES18XX_PM_FM    0x020
     160#define ES18XX_PM_SUS   0x080
    161161
    162162typedef struct _snd_es18xx es18xx_t;

  • GPL/branches/alsa-resync1/alsa-kernel/isa/sb/emu8000_pcm.c

    r212 r215  
    116116 */
    117117static void
    118 snd_emu8000_write_wait(emu8000_t *emu)
     118snd_emu8000_write_wait(emu8000_t *emu, int can_schedule)
    119119{
    120120        while ((EMU8000_SMALW_READ(emu) & 0x80000000) != 0) {
    121                 set_current_state(TASK_INTERRUPTIBLE);
    122                 schedule_timeout(1);
    123                 if (signal_pending(current))
    124                         break;
     121                if (can_schedule) {
     122                        set_current_state(TASK_INTERRUPTIBLE);
     123                        schedule_timeout(1);
     124                        if (signal_pending(current))
     125                                break;
     126                }
    125127        }
    126128}
    … …  
    458460        emu8000_t *emu = rec->emu;
    459461
    460         snd_emu8000_write_wait(emu);
     462        snd_emu8000_write_wait(emu, 1);
    461463        if (voice == -1) {
    462464                unsigned short *buf = src;
    … …  
    495497        emu8000_t *emu = rec->emu;
    496498
    497         snd_emu8000_write_wait(emu);
     499        snd_emu8000_write_wait(emu, 1);
    498500        if (voice == -1 && rec->voices == 1)
    499501                voice = 0;
    … …  
    525527        unsigned short *buf = src;
    526528
    527         snd_emu8000_write_wait(emu);
     529        snd_emu8000_write_wait(emu, 1);
    528530        EMU8000_SMALW_WRITE(emu, pos + rec->loop_start[0]);
    529531        if (rec->voices > 1)
    … …  
    554556        emu8000_t *emu = rec->emu;
    555557
    556         snd_emu8000_write_wait(emu);
     558        snd_emu8000_write_wait(emu, 1);
    557559        EMU8000_SMALW_WRITE(emu, rec->loop_start[0] + pos);
    558560        if (rec->voices > 1)
    … …  
    646648
    647649                /* clear loop blanks */
    648                 snd_emu8000_write_wait(rec->emu);
     650                snd_emu8000_write_wait(rec->emu, 0);
    649651                EMU8000_SMALW_WRITE(rec->emu, rec->offset);
    650652                for (i = 0; i < LOOP_BLANK_SIZE; i++)

  • GPL/branches/alsa-resync1/alsa-kernel/pci/cs46xx/dsp_spos_scb_lib.c

    r76 r215  
    792792                {
    793793                        /* E */ 0x8000,0x8000,
    794                         /* F */ 0x8000,0x8000
     794                        /* F */ 0xffff,0xffff
    795795                }
    796796        };
    … …  
    981981                0x18000000,                     /* Phi increment for approx 32k operation */
    982982                0x8000,0x8000,                  /* Volume controls are unused at this time */
    983                 0x8000,0x8000
     983                0xffff,0xffff
    984984        };
    985985 
    … …  
    13581358                }
    13591359
    1360                 /* cs46xx_dsp_set_src_sample_rate(chip,src_scb,sample_rate); */
     1360                if (pcm_channel_id != DSP_IEC958_CHANNEL ||
     1361                    !(ins->spdif_status_out & DSP_SPDIF_STATUS_AC3_MODE))
     1362                        cs46xx_dsp_set_src_sample_rate(chip,src_scb,sample_rate);
    13611363
    13621364                ins->nsrc_scb ++;

  • GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ak4524.c

    r212 r215  
    22 *   ALSA driver for ICEnsemble ICE1712 (Envy24)
    33 *
    4  *   AK4524 / AK4528 interface
     4 *   AK4524 / AK4528 / AK4529 interface
    55 *
    66 *      Copyright (c) 2000 Jaroslav Kysela <perex@suse.cz>
    … …  
    6868        addr &= 0x07;
    6969        /* build I2C address + data byte */
     70        /* assume C1=1, C0=0 */
    7071        addrdata = 0xa000 | (addr << 8) | data;
    7172        for (idx = 15; idx >= 0; idx--) {
    … …  
    8182        }
    8283
     84        if (ak->type == SND_AK4524) {
    8385        if ((addr != 0x04 && addr != 0x05) || (data & 0x80) == 0)
    8486                ak->images[chip][addr] = data;
    8587        else
    8688                ak->ipga_gain[chip][addr-4] = data;
     89        }
    8790
    8891        if (ak->cs_mask == ak->cs_addr) {
    … …  
    113116        ak4524_t *ak = &ice->ak4524;
    114117       
     118        switch (ak->type) {
     119        case SND_AK4524:
     120        case SND_AK4528:
    115121        for (chip = 0; chip < ak->num_dacs/2; chip++) {
    116122                snd_ice1712_ak4524_write(ice, chip, 0x01, state ? 0x00 : 0x03);
    117123                if (state)
    118124                        continue;
    119                 for (reg = 0x04; reg < (ak->is_ak4528 ? 0x06 : 0x08); reg++)
     125                        /* DAC volumes */
     126                        for (reg = 0x04; reg < (ak->type == SND_AK4528 ? 0x06 : 0x08); reg++)
    120127                        snd_ice1712_ak4524_write(ice, chip, reg, ak->images[chip][reg]);
    121                 if (ak->is_ak4528)
     128                        if (ak->type == SND_AK4528)
    122129                        continue;
     130                        /* IPGA */
    123131                for (reg = 0x04; reg < 0x06; reg++)
    124132                        snd_ice1712_ak4524_write(ice, chip, reg, ak->ipga_gain[chip][reg-4]);
     133                }
     134                break;
     135        case SND_AK4529:
     136                /* FIXME: needed for ak4529? */
     137                break;
    125138        }
    126139}
    … …  
    131144void __devinit snd_ice1712_ak4524_init(ice1712_t *ice)
    132145{
    133         static unsigned char inits[] = {
     146        static unsigned char inits_ak4524[] = {
    134147                0x00, 0x07, /* 0: all power up */
    135148                0x01, 0x00, /* 1: ADC/DAC reset */
    … …  
    145158                0xff, 0xff
    146159        };
    147         int chip, idx;
    148         unsigned char *ptr, reg, data;
     160        static unsigned char inits_ak4528[] = {
     161                0x00, 0x07, /* 0: all power up */
     162                0x01, 0x00, /* 1: ADC/DAC reset */
     163                0x02, 0x60, /* 2: 24bit I2S */
     164                0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */
     165                0x01, 0x03, /* 1: ADC/DAC enable */
     166                0x04, 0x00, /* 4: ADC left muted */
     167                0x05, 0x00, /* 5: ADC right muted */
     168                0xff, 0xff
     169        };
     170        static unsigned char inits_ak4529[] = {
     171                0x09, 0x01, /* 9: ATS=0, RSTN=1 */
     172                0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
     173                0x00, 0x08, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
     174                0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
     175                0x02, 0xff, /* 2: LOUT1 muted */
     176                0x03, 0xff, /* 3: ROUT1 muted */
     177                0x04, 0xff, /* 4: LOUT2 muted */
     178                0x05, 0xff, /* 5: ROUT2 muted */
     179                0x06, 0xff, /* 6: LOUT3 muted */
     180                0x07, 0xff, /* 7: ROUT3 muted */
     181                0x0b, 0xff, /* B: LOUT4 muted */
     182                0x0c, 0xff, /* C: ROUT4 muted */
     183                0x08, 0x55, /* 8: deemphasis all off */
     184                0xff, 0xff
     185        };
     186        int chip, num_chips;
     187        unsigned char *ptr, reg, data, *inits;
    149188        ak4524_t *ak = &ice->ak4524;
    150189
    151         for (chip = idx = 0; chip < ak->num_dacs/2; chip++) {
     190        switch (ak->type) {
     191        case SND_AK4524:
     192                inits = inits_ak4524;
     193                num_chips = ak->num_dacs / 2;
     194                break;
     195        case SND_AK4528:
     196                inits = inits_ak4528;
     197                num_chips = ak->num_dacs / 2;
     198                break;
     199        case SND_AK4529:
     200        default:
     201                inits = inits_ak4529;
     202                num_chips = 1;
     203                break;
     204        }
     205
     206        for (chip = 0; chip < num_chips; chip++) {
    152207                ptr = inits;
    153208                while (*ptr != 0xff) {
    154209                        reg = *ptr++;
    155210                        data = *ptr++;
    156                         if (ak->is_ak4528) {
    157                                 if (reg > 5)
    158                                         continue;
    159                                 if (reg >= 4 && (data & 0x80))
    160                                         continue;
    161                         }
    162                         if (reg == 0x03 && ak->is_ak4528)
    163                                 data = 0x0d;    /* deemphasis off, turn LR highpass filters on */
    164211                        snd_ice1712_ak4524_write(ice, chip, reg, data);
    165212                }
    166213        }
    167214}
     215
     216
     217#define AK_GET_CHIP(val)                (((val) >> 8) & 0xff)
     218#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))
    168221
    169222static int snd_ice1712_ak4524_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    … …  
    179232{
    180233        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    181         int chip = kcontrol->private_value / 8;
    182         int addr = kcontrol->private_value % 8;
     234        int chip = AK_GET_CHIP(kcontrol->private_value);
     235        int addr = AK_GET_ADDR(kcontrol->private_value);
    183236        ucontrol->value.integer.value[0] = ice->ak4524.images[chip][addr];
    184237        return 0;
    … …  
    188241{
    189242        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    190         int chip = kcontrol->private_value / 8;
    191         int addr = kcontrol->private_value % 8;
     243        int chip = AK_GET_CHIP(kcontrol->private_value);
     244        int addr = AK_GET_ADDR(kcontrol->private_value);
    192245        unsigned char nval = ucontrol->value.integer.value[0];
    193246        int change = ice->ak4524.images[chip][addr] != nval;
    … …  
    209262{
    210263        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    211         int chip = kcontrol->private_value / 8;
    212         int addr = kcontrol->private_value % 8;
     264        int chip = AK_GET_CHIP(kcontrol->private_value);
     265        int addr = AK_GET_ADDR(kcontrol->private_value);
    213266        ucontrol->value.integer.value[0] = ice->ak4524.ipga_gain[chip][addr-4] & 0x7f;
    214267        return 0;
    … …  
    218271{
    219272        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    220         int chip = kcontrol->private_value / 8;
    221         int addr = kcontrol->private_value % 8;
     273        int chip = AK_GET_CHIP(kcontrol->private_value);
     274        int addr = AK_GET_ADDR(kcontrol->private_value);
    222275        unsigned char nval = (ucontrol->value.integer.value[0] % 37) | 0x80;
    223276        int change = ice->ak4524.ipga_gain[chip][addr] != nval;
    … …  
    244297{
    245298        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    246         int chip = kcontrol->id.index;
    247         ucontrol->value.enumerated.item[0] = ice->ak4524.images[chip][3] & 3;
     299        int chip = AK_GET_CHIP(kcontrol->private_value);
     300        int addr = AK_GET_ADDR(kcontrol->private_value);
     301        int shift = AK_GET_SHIFT(kcontrol->private_value);
     302        ucontrol->value.enumerated.item[0] = (ice->ak4524.images[chip][addr] >> shift) & 3;
    248303        return 0;
    249304}
    … …  
    252307{
    253308        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    254         int chip = kcontrol->id.index;
    255         unsigned char nval = ucontrol->value.enumerated.item[0];
     309        int chip = AK_GET_CHIP(kcontrol->private_value);
     310        int addr = AK_GET_ADDR(kcontrol->private_value);
     311        int shift = AK_GET_SHIFT(kcontrol->private_value);
     312        unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
    256313        int change;
    257         nval |= (nval & 3) | (ice->ak4524.images[chip][3] & ~3);
    258         change = ice->ak4524.images[chip][3] != nval;
     314       
     315        nval = (nval << shift) | (ice->ak4524.images[chip][addr] & ~(3 << shift));
     316        change = ice->ak4524.images[chip][addr] != nval;
    259317        if (change)
    260                 snd_ice1712_ak4524_write(ice, chip, 3, nval);
     318                snd_ice1712_ak4524_write(ice, chip, addr, nval);
    261319        return change;
    262320}
    … …  
    281339                        ctl.get = snd_ice1712_ak4524_volume_get;
    282340                        ctl.put = snd_ice1712_ak4524_volume_put;
    283                 if (ak->is_ak4528)
    284                                 ctl.private_value = (idx / 2) * 8 + (idx % 2) + 4; /* register 4 & 5 */
    285                         else
    286                                 ctl.private_value = (idx / 2) * 8 + (idx % 2) + 6; /* register 6 & 7 */
     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                }
    287354                        ctl.private_data = ice;
    288355                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
    289356                                return err;
    290357                }
    291         for (idx = 0; idx < ak->num_adcs && !ak->is_ak4528; ++idx) {
     358        for (idx = 0; idx < ak->num_adcs && ak->type == SND_AK4524; ++idx) {
    292359                        snd_kcontrol_t ctl;
    293360                        memset(&ctl, 0, sizeof(ctl));
    … …  
    299366                        ctl.get = snd_ice1712_ak4524_volume_get;
    300367                        ctl.put = snd_ice1712_ak4524_volume_put;
    301                         ctl.private_value = (idx / 2) * 8 + (idx % 2) + 4; /* register 4 & 5 */
     368                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
    302369                        ctl.private_data = ice;
    303370                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
    … …  
    311378                        ctl.get = snd_ice1712_ak4524_ipga_gain_get;
    312379                        ctl.put = snd_ice1712_ak4524_ipga_gain_put;
    313                         ctl.private_value = (idx / 2) * 8 + (idx % 2) + 4; /* register 4 & 5 */
     380                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
    314381                        ctl.private_data = ice;
    315382                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
    … …  
    326393                        ctl.get = snd_ice1712_ak4524_deemphasis_get;
    327394                        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                }
    328406                        ctl.private_data = ice;
    329407                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)

  • GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/delta.c

    r212 r215  
    258258 * change the rate of AK4524 on Delta 44/66, AP, 1010LT
    259259 */
    260 static void delta_ak4524_set_rate_val(ice1712_t *ice, unsigned char val)
     260static void delta_ak4524_set_rate_val(ice1712_t *ice, unsigned int rate)
    261261{
    262262        unsigned char tmp, tmp2;
     263
     264        if (rate == 0)  /* no hint - S/PDIF input is master, simply return */
     265                return;
    263266
    264267        /* check before reset ak4524 to avoid unnecessary clicks */
    … …  
    268271        tmp2 = tmp;
    269272        tmp2 &= ~ICE1712_DELTA_DFS;
    270         if (val == 15 || val == 11 || val == 7)
     273        if (rate > 48000)
    271274                tmp2 |= ICE1712_DELTA_DFS;
    272275        if (tmp == tmp2)
    … …  
    276279        snd_ice1712_ak4524_reset(ice, 1);
    277280        down(&ice->gpio_mutex);
    278         tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
    279         if (val == 15 || val == 11 || val == 7) {
     281        tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ~ICE1712_DELTA_DFS;
     282        if (rate > 48000)
    280283                tmp |= ICE1712_DELTA_DFS;
    281         } else {
    282                 tmp &= ~ICE1712_DELTA_DFS;
    283         }
    284284        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
    285285        up(&ice->gpio_mutex);
    … …  
    338338                ice->num_total_dacs = 2;
    339339                break;
     340        case ICE1712_SUBDEVICE_DELTA410:
     341                ice->num_total_dacs = 8;
     342                break;
    340343        case ICE1712_SUBDEVICE_DELTA44:
    341344        case ICE1712_SUBDEVICE_DELTA66:
    … …  
    351354        switch (ice->eeprom.subvendor) {
    352355        case ICE1712_SUBDEVICE_AUDIOPHILE:
     356        case ICE1712_SUBDEVICE_DELTA410:
    353357        case ICE1712_SUBDEVICE_DELTA1010LT:
    354358                if ((err = snd_i2c_bus_create(ice->card, "ICE1712 GPIO 1", NULL, &ice->i2c)) < 0) {
    … …  
    379383        switch (ice->eeprom.subvendor) {
    380384        case ICE1712_SUBDEVICE_AUDIOPHILE:
     385        case ICE1712_SUBDEVICE_DELTA410:
    381386                ak->num_adcs = ak->num_dacs = 2;
    382                 ak->is_ak4528 = 1;
    383                 ak->cif = 0; /* the default level of the CIF pin from AK4524 */
     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 */
    384393                ak->data_mask = ICE1712_DELTA_AP_DOUT;
    385394                ak->clk_mask = ICE1712_DELTA_AP_CCLK;
    386                 ak->cs_mask = ak->cs_addr = ICE1712_DELTA_AP_CS_CODEC; /* select AK4528 codec */
     395                ak->cs_mask = ak->cs_addr = ICE1712_DELTA_AP_CS_CODEC; /* select AK4528/4529 codec */
    387396                ak->cs_none = 0;
    388397                ak->add_flags = ICE1712_DELTA_AP_CS_DIGITAL; /* assert digital high */
    … …  
    393402        case ICE1712_SUBDEVICE_DELTA1010LT:
    394403                ak->num_adcs = ak->num_dacs = 8;
     404                ak->type = SND_AK4524;
    395405                ak->cif = 0; /* the default level of the CIF pin from AK4524 */
    396406                ak->data_mask = ICE1712_DELTA_1010LT_DOUT;
    … …  
    407417        case ICE1712_SUBDEVICE_DELTA44:
    408418                ak->num_adcs = ak->num_dacs = 4;
     419                ak->type = SND_AK4524;
    409420                ak->cif = 0; /* the default level of the CIF pin from AK4524 */
    410421                ak->data_mask = ICE1712_DELTA_CODEC_SERIAL_DATA;
    … …  
    472483        case ICE1712_SUBDEVICE_DELTA66:
    473484        case ICE1712_SUBDEVICE_AUDIOPHILE:
     485        case ICE1712_SUBDEVICE_DELTA410:
     486        case ICE1712_SUBDEVICE_DELTA1010LT:
    474487                err = snd_ice1712_spdif_build_controls(ice);
    475488                if (err < 0)
    … …  
    491504        /* ak4524 controls */
    492505        switch (ice->eeprom.subvendor) {
     506        case ICE1712_SUBDEVICE_DELTA1010LT:
    493507        case ICE1712_SUBDEVICE_AUDIOPHILE:
     508        case ICE1712_SUBDEVICE_DELTA410:
    494509        case ICE1712_SUBDEVICE_DELTA44:
    495510        case ICE1712_SUBDEVICE_DELTA66:
    … …  
    539554        },
    540555        {
     556                ICE1712_SUBDEVICE_DELTA410,
     557                "M Audio Delta 410",
     558                snd_ice1712_delta_init,
     559                snd_ice1712_delta_add_controls,
     560        },
     561        {
    541562                ICE1712_SUBDEVICE_DELTA1010LT,
    542563                "M Audio Delta 1010LT",

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

    r212 r215  
    3838#define ICE1712_SUBDEVICE_DELTA44       0x121433d6
    3939#define ICE1712_SUBDEVICE_AUDIOPHILE    0x121434d6
     40#define ICE1712_SUBDEVICE_DELTA410      0x121438d6
    4041#define ICE1712_SUBDEVICE_DELTA1010LT   0x12143bd6
    4142
    … …  
    107108/* 0x80 = CODEC_CHIP_B */
    108109
    109 /* MidiMan M-Audio Audiophile definitions */
     110/* MidiMan M-Audio Audiophile/Delta410 definitions */
     111/* thanks to Kristof Pelckmans <Kristof.Pelckmans@antwerpen.be> for Delta410 info */
    110112/* 0x01 = DFS */
    111113#define ICE1712_DELTA_AP_CCLK   0x02    /* SPI clock */
    … …  
    115117#define ICE1712_DELTA_AP_CS_DIGITAL 0x10 /* CS8427 chip select */
    116118                                        /* low signal = select */
    117 #define ICE1712_DELTA_AP_CS_CODEC 0x20  /* AK4528 chip select */
     119#define ICE1712_DELTA_AP_CS_CODEC 0x20  /* AK4528 (audiophile), AK4529 (Delta410) chip select */
    118120                                        /* low signal = select */
    119121

  • GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ews.c

    r212 r215  
    407407        case ICE1712_SUBDEVICE_EWS88MT:
    408408                ak->num_adcs = ak->num_dacs = 8;
     409                ak->type = SND_AK4524;
    409410                ak->cif = 1; /* CIF high */
    410411                ak->data_mask = ICE1712_EWS88_SERIAL_DATA;
    … …  
    419420        case ICE1712_SUBDEVICE_EWX2496:
    420421                ak->num_adcs = ak->num_dacs = 2;
     422                ak->type = SND_AK4524;
    421423                ak->cif = 1; /* CIF high */
    422424                ak->data_mask = ICE1712_EWS88_SERIAL_DATA;
    … …  
    431433        case ICE1712_SUBDEVICE_DMX6FIRE:
    432434                ak->num_adcs = ak->num_dacs = 6;
     435                ak->type = SND_AK4524;
    433436                ak->cif = 1; /* CIF high */
    434437                ak->data_mask = ICE1712_6FIRE_SERIAL_DATA;

  • GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1712.c

    r212 r215  
    105105static int snd_ice1712_build_controls(ice1712_t *ice);
    106106
     107static int PRO_RATE_LOCKED = 0;
     108static int PRO_RATE_RESET = 1;
     109static unsigned int PRO_RATE_DEFAULT = 44100;
     110
    107111/*
    108112 *  Basic I/O
    109113 */
     114 
     115static inline int is_spdif_master(ice1712_t *ice)
     116{
     117        return (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER) ? 1 : 0;
     118}
     119
     120static inline int is_pro_rate_locked(ice1712_t *ice)
     121{
     122        return is_spdif_master(ice) || PRO_RATE_LOCKED;
     123}
    110124
    111125static inline void snd_ice1712_ds_write(ice1712_t * ice, u8 channel, u8 addr, u32 data)
    … …  
    981995/*
    982996 */
    983 static void snd_ice1712_set_pro_rate(ice1712_t *ice, snd_pcm_substream_t *substream)
     997static void snd_ice1712_set_pro_rate(ice1712_t *ice, unsigned int rate, int do_not_lock)
    984998{
    985999        unsigned long flags;
    986         unsigned int rate;
    9871000        unsigned char val;
     1001        int old_lock_value;
    9881002
    9891003        spin_lock_irqsave(&ice->reg_lock, flags);
    990         if ((inb(ICEMT(ice, PLAYBACK_CONTROL)) & (ICE1712_CAPTURE_START_SHADOW|
     1004        old_lock_value = PRO_RATE_LOCKED;
     1005        if (do_not_lock)
     1006                PRO_RATE_LOCKED = 0;
     1007        if (inb(ICEMT(ice, PLAYBACK_CONTROL)) & (ICE1712_CAPTURE_START_SHADOW|
    9911008                                                  ICE1712_PLAYBACK_PAUSE|
    992                                                   ICE1712_PLAYBACK_START)) ||
    993             (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER)) {
     1009                                                 ICE1712_PLAYBACK_START)) {
    9941010                spin_unlock_irqrestore(&ice->reg_lock, flags);
    9951011                return;
    9961012        }
    997         rate = substream->runtime->rate;
     1013        if (!is_pro_rate_locked(ice))
     1014                goto __unlock;
     1015
    9981016        switch (rate) {
    9991017        case 8000: val = 6; break;
    … …  
    10161034        }
    10171035        outb(val, ICEMT(ice, RATE));
     1036        PRO_RATE_LOCKED = old_lock_value;
     1037
     1038      __unlock:
    10181039        spin_unlock_irqrestore(&ice->reg_lock, flags);
    10191040
    10201041        if (ice->ak4524.ops.set_rate_val)
    1021                 ice->ak4524.ops.set_rate_val(ice, val);
     1042                ice->ak4524.ops.set_rate_val(ice, rate);
    10221043}
    10231044
    … …  
    10281049
    10291050        ice->playback_pro_size = snd_pcm_lib_buffer_bytes(substream);
    1030         snd_ice1712_set_pro_rate(ice, substream);
     1051        snd_ice1712_set_pro_rate(ice, substream->runtime->rate, 0);
    10311052        spin_lock_irqsave(&ice->reg_lock, flags);
    10321053        outl(substream->runtime->dma_addr, ICEMT(ice, PLAYBACK_ADDR));
    … …  
    10471068
    10481069        ice->capture_pro_size = snd_pcm_lib_buffer_bytes(substream);
    1049         snd_ice1712_set_pro_rate(ice, substream);
     1070        snd_ice1712_set_pro_rate(ice, substream->runtime->rate, 0);
    10501071        spin_lock_irqsave(&ice->reg_lock, flags);
    10511072        outl(substream->runtime->dma_addr, ICEMT(ice, CAPTURE_ADDR));
    … …  
    11521173        ice1712_t *ice = snd_pcm_substream_chip(substream);
    11531174
     1175        if (PRO_RATE_RESET)
     1176                snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 0);
    11541177        ice->playback_pro_substream = NULL;
    11551178        if (ice->spdif.ops.close)
    … …  
    11631186        ice1712_t *ice = snd_pcm_substream_chip(substream);
    11641187
     1188        if (PRO_RATE_RESET)
     1189                snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 0);
    11651190        ice->capture_pro_substream = NULL;
    11661191        return 0;
    … …  
    14961521}
    14971522
    1498 static void __exit snd_ice1712_proc_done(ice1712_t * ice)
     1523static void snd_ice1712_proc_done(ice1712_t * ice)
    14991524{
    15001525        if (ice->proc_entry) {
    … …  
    15331558/*
    15341559 */
    1535 static int snd_ice1712_spdif_default_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     1560static int snd_ice1712_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    15361561{
    15371562        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
    … …  
    15621587        .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
    15631588        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
    1564         .info =         snd_ice1712_spdif_default_info,
     1589        .info =         snd_ice1712_spdif_info,
    15651590        .get =          snd_ice1712_spdif_default_get,
    15661591        .put =          snd_ice1712_spdif_default_put
    15671592};
    1568 
    1569 static int snd_ice1712_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    1570 {
    1571         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
    1572         uinfo->count = 1;
    1573         return 0;
    1574 }
    15751593
    15761594static int snd_ice1712_spdif_maskc_get(snd_kcontrol_t * kcontrol,
    … …  
    16211639        .iface =                SNDRV_CTL_ELEM_IFACE_MIXER,
    16221640        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
    1623         .info =         snd_ice1712_spdif_mask_info,
     1641        .info =         snd_ice1712_spdif_info,
    16241642        .get =          snd_ice1712_spdif_maskc_get,
    16251643};
    … …  
    16301648        .iface =                SNDRV_CTL_ELEM_IFACE_MIXER,
    16311649        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
    1632         .info =         snd_ice1712_spdif_mask_info,
     1650        .info =         snd_ice1712_spdif_info,
    16331651        .get =          snd_ice1712_spdif_maskp_get,
    16341652};
    1635 
    1636 static int snd_ice1712_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    1637 {
    1638         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
    1639         uinfo->count = 1;
    1640         return 0;
    1641 }
    16421653
    16431654static int snd_ice1712_spdif_stream_get(snd_kcontrol_t * kcontrol,
    … …  
    16641675        .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
    16651676        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
    1666         .info =         snd_ice1712_spdif_stream_info,
     1677        .info =         snd_ice1712_spdif_info,
    16671678        .get =          snd_ice1712_spdif_stream_get,
    16681679        .put =          snd_ice1712_spdif_stream_put
    … …  
    17101721}
    17111722
    1712 static int snd_ice1712_pro_spdif_master_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     1723/*
     1724 *  rate
     1725 */
     1726static int snd_ice1712_pro_internal_clock_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     1727{
     1728        static char *texts[] = {
     1729                "8000",         /* 0: 6 */
     1730                "9600",         /* 1: 3 */
     1731                "11025",        /* 2: 10 */
     1732                "12000",        /* 3: 2 */
     1733                "16000",        /* 4: 5 */
     1734                "22050",        /* 5: 9 */
     1735                "24000",        /* 6: 1 */
     1736                "32000",        /* 7: 4 */
     1737                "44100",        /* 8: 8 */
     1738                "48000",        /* 9: 0 */
     1739                "64000",        /* 10: 15 */
     1740                "88200",        /* 11: 11 */
     1741                "96000",        /* 12: 7 */
     1742                "IEC958 Input", /* 13: -- */
     1743        };
     1744        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
     1745        uinfo->count = 1;
     1746        uinfo->value.enumerated.items = 14;
     1747        if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
     1748                uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
     1749        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
     1750        return 0;
     1751}
     1752
     1753static int snd_ice1712_pro_internal_clock_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1754{
     1755        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
     1756        static unsigned char xlate[16] = {
     1757                9, 6, 3, 1, 7, 4, 0, 12, 8, 5, 2, 11, 255, 255, 255, 10
     1758        };
     1759        unsigned char val;
     1760       
     1761        spin_lock_irq(&ice->reg_lock);
     1762        if (is_spdif_master(ice)) {
     1763                ucontrol->value.enumerated.item[0] = 13;
     1764        } else {
     1765                val = xlate[inb(ICEMT(ice, RATE)) & 15];
     1766                if (val == 255) {
     1767                        snd_BUG();
     1768                        val = 0;
     1769                }
     1770                ucontrol->value.enumerated.item[0] = val;
     1771        }
     1772        spin_unlock_irq(&ice->reg_lock);
     1773        return 0;
     1774}
     1775
     1776static int snd_ice1712_pro_internal_clock_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1777{
     1778        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
     1779        static unsigned int xrate[13] = {
     1780                8000, 9600, 11025, 12000, 1600, 22050, 24000,
     1781                32000, 44100, 48000, 64000, 88200, 96000
     1782        };
     1783        unsigned char oval;
     1784        int change = 0;
     1785
     1786        spin_lock_irq(&ice->reg_lock);
     1787        oval = inb(ICEMT(ice, RATE));
     1788        if (ucontrol->value.enumerated.item[0] == 13) {
     1789                outb(oval | ICE1712_SPDIF_MASTER, ICEMT(ice, RATE));
     1790        } else {
     1791                PRO_RATE_DEFAULT = xrate[ucontrol->value.integer.value[0] % 13];
     1792                snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 1);
     1793        }
     1794        change = inb(ICEMT(ice, RATE)) != oval;
     1795
     1796        if ((oval & ICE1712_SPDIF_MASTER) != (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER)) {
     1797                /* change CS8427 clock source too */
     1798                if (ice->cs8427) {
     1799                        snd_ice1712_cs8427_set_input_clock(ice, is_spdif_master(ice));
     1800                }
     1801                /* 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        }
     1805
     1806        return change;
     1807}
     1808
     1809static snd_kcontrol_new_t snd_ice1712_pro_internal_clock = __devinitdata {
     1810        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     1811        .name = "Multi Track Internal Clock",
     1812        .info = snd_ice1712_pro_internal_clock_info,
     1813        .get = snd_ice1712_pro_internal_clock_get,
     1814        .put = snd_ice1712_pro_internal_clock_put
     1815};
     1816
     1817static int snd_ice1712_pro_rate_locking_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
    17131818{
    17141819        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
    … …  
    17191824}
    17201825
    1721 static int snd_ice1712_pro_spdif_master_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
    1722 {
    1723         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    1724         unsigned long flags;
    1725        
    1726         spin_lock_irqsave(&ice->reg_lock, flags);
    1727         ucontrol->value.integer.value[0] = inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER ? 1 : 0;
    1728         spin_unlock_irqrestore(&ice->reg_lock, flags);
    1729         return 0;
    1730 }
    1731 
    1732 static int snd_ice1712_pro_spdif_master_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
    1733 {
    1734         unsigned long flags;
    1735         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
    1736         int nval, change;
    1737 
    1738         nval = ucontrol->value.integer.value[0] ? ICE1712_SPDIF_MASTER : 0;
    1739         spin_lock_irqsave(&ice->reg_lock, flags);
    1740         nval |= inb(ICEMT(ice, RATE)) & ~ICE1712_SPDIF_MASTER;
    1741         change = inb(ICEMT(ice, RATE)) != nval;
    1742         outb(nval, ICEMT(ice, RATE));
    1743         spin_unlock_irqrestore(&ice->reg_lock, flags);
    1744 
    1745         if (ice->cs8427) {
    1746                 /* change CS8427 clock source too */
    1747                 snd_ice1712_cs8427_set_input_clock(ice, ucontrol->value.integer.value[0]);
    1748         }
    1749 
     1826static int snd_ice1712_pro_rate_locking_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1827{
     1828        ucontrol->value.integer.value[0] = PRO_RATE_LOCKED ? 1 : 0;
     1829        return 0;
     1830}
     1831
     1832static int snd_ice1712_pro_rate_locking_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1833{
     1834        int change = 0;
     1835
     1836        change = PRO_RATE_LOCKED ? 1 : 0 != ucontrol->value.integer.value[0] ? 1 : 0;
     1837        PRO_RATE_LOCKED = ucontrol->value.integer.value[0] ? 1 : 0;
    17501838        return change;
    17511839}
    17521840
    1753 static snd_kcontrol_new_t snd_ice1712_pro_spdif_master __devinitdata = {
     1841static snd_kcontrol_new_t snd_ice1712_pro_rate_locking __devinitdata = {
    17541842        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    1755         .name = "Multi Track IEC958 Master",
    1756         .info = snd_ice1712_pro_spdif_master_info,
    1757         .get = snd_ice1712_pro_spdif_master_get,
    1758         .put = snd_ice1712_pro_spdif_master_put
     1843        .name = "Multi Track Rate Locking",
     1844        .info = snd_ice1712_pro_rate_locking_info,
     1845        .get = snd_ice1712_pro_rate_locking_get,
     1846        .put = snd_ice1712_pro_rate_locking_put
     1847};
     1848
     1849static int snd_ice1712_pro_rate_reset_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
     1850{
     1851        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
     1852        uinfo->count = 1;
     1853        uinfo->value.integer.min = 0;
     1854        uinfo->value.integer.max = 1;
     1855        return 0;
     1856}
     1857
     1858static int snd_ice1712_pro_rate_reset_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1859{
     1860        ucontrol->value.integer.value[0] = PRO_RATE_RESET ? 1 : 0;
     1861        return 0;
     1862}
     1863
     1864static int snd_ice1712_pro_rate_reset_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
     1865{
     1866        int change = 0;
     1867
     1868        change = PRO_RATE_LOCKED ? 1 : 0 != ucontrol->value.integer.value[0] ? 1 : 0;
     1869        PRO_RATE_RESET = ucontrol->value.integer.value[0] ? 1 : 0;
     1870        return change;
     1871}
     1872
     1873static snd_kcontrol_new_t snd_ice1712_pro_rate_reset __devinitdata = {
     1874        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     1875        .name = "Multi Track Rate Reset",
     1876        .info = snd_ice1712_pro_rate_reset_info,
     1877        .get = snd_ice1712_pro_rate_reset_get,
     1878        .put = snd_ice1712_pro_rate_reset_put
    17591879};
    17601880
    … …  
    21282248        if (err < 0)
    21292249                return err;
    2130         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_spdif_master, ice));
     2250        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_internal_clock, ice));
     2251        if (err < 0)
     2252                return err;
     2253        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_rate_locking, ice));
     2254        if (err < 0)
     2255                return err;
     2256        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_rate_reset, ice));
    21312257        if (err < 0)
    21322258                return err;
    … …  
    22982424/*
    22992425 *
    2300  * Registraton
     2426 * Registration
    23012427 *
    23022428 */

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

    r212 r215  
    240240        int num_adcs;                   /* AK4524 or AK4528 ADCs */
    241241        int num_dacs;                   /* AK4524 or AK4528 DACs */
    242         unsigned char images[4][8];
     242        unsigned char images[4][16];
    243243        unsigned char ipga_gain[4][2];
    244244        /* */
    245         unsigned int is_ak4528: 1;      /* AK4524 or AK4528 */
     245        enum {
     246                SND_AK4524, SND_AK4528, SND_AK4529
     247        } type;
    246248        unsigned int cif: 1;
    247249        unsigned char data_mask;
    … …  
    255257                int (*start)(ice1712_t *, unsigned char *, int);
    256258                void (*stop)(ice1712_t *, unsigned char *);
    257                 void (*set_rate_val)(ice1712_t *, unsigned char);
     259                void (*set_rate_val)(ice1712_t *, unsigned int);
    258260        } ops;
    259261};

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

    • Property svn:eol-style set to native
    r212 r215  
    2626    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    2727
    28     hammerfall_mem.c,v 1.4 2002/10/21 18:28:25 perex Exp
     28    hammerfall_mem.c,v 1.5 2002/11/04 09:11:42 perex Exp
    2929
    3030
    … …  
    3838#include <sound/driver.h>
    3939#endif
    40 #include <linux/config.h>
    4140#include <linux/version.h>
    4241#include <linux/module.h>

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

    • Property svn:eol-style set to native
    r212 r215  
    950950        if (up) {
    951951                if (!hmidi->istimer) {
     952                        init_timer(&hmidi->timer);
    952953                        hmidi->timer.function = snd_hdsp_midi_output_timer;
    953954                        hmidi->timer.data = (unsigned long) hmidi;
Note: See TracChangeset for help on using the changeset viewer.