Ignore:
Timestamp:
Oct 23, 2006, 11:07:11 PM (19 years ago)
Author:
vladest
Message:

SB code update
HDA code update
Some other updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • GPL/trunk/alsa-kernel/pci/emu10k1/emumpu401.c

    r34 r84  
    3131static inline unsigned char mpu401_read(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *mpu, int idx)
    3232{
    33         if (emu->audigy)
    34                 return (unsigned char)snd_emu10k1_ptr_read(emu, mpu->port + idx, 0);
    35         else
    36                 return inb(emu->port + mpu->port + idx);
     33    if (emu->audigy)
     34        return (unsigned char)snd_emu10k1_ptr_read(emu, mpu->port + idx, 0);
     35    else
     36        return inb(emu->port + mpu->port + idx);
    3737}
    3838
    3939static inline void mpu401_write(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *mpu, int data, int idx)
    4040{
    41         if (emu->audigy)
    42                 snd_emu10k1_ptr_write(emu, mpu->port + idx, 0, data);
    43         else
    44                 outb(data, emu->port + mpu->port + idx);
     41    if (emu->audigy)
     42        snd_emu10k1_ptr_write(emu, mpu->port + idx, 0, data);
     43    else
     44        outb(data, emu->port + mpu->port + idx);
    4545}
    4646
    … …  
    5959static void mpu401_clear_rx(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *mpu)
    6060{
    61         int timeout = 100000;
    62         for (; timeout > 0 && mpu401_input_avail(emu, mpu); timeout--)
    63                 mpu401_read_data(emu, mpu);
     61    int timeout = 100000;
     62    for (; timeout > 0 && mpu401_input_avail(emu, mpu); timeout--)
     63        mpu401_read_data(emu, mpu);
    6464#ifdef CONFIG_SND_DEBUG
    65         if (timeout <= 0)
    66                 snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n", mpu401_read_stat(emu, mpu));
     65    if (timeout <= 0)
     66        snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n", mpu401_read_stat(emu, mpu));
    6767#endif
    6868}
    … …  
    7070/*
    7171
    72  */
     72*/
    7373
    7474static void do_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, unsigned int status)
    7575{
    76         unsigned char byte;
    77 
    78         if (midi->rmidi == NULL) {
    79                 snd_emu10k1_intr_disable(emu, midi->tx_enable | midi->rx_enable);
    80                 return;
    81         }
    82 
    83         spin_lock(&midi->input_lock);
    84         if ((status & midi->ipr_rx) && mpu401_input_avail(emu, midi)) {
    85                 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
    86                         mpu401_clear_rx(emu, midi);
    87                 } else {
    88                         byte = mpu401_read_data(emu, midi);
    89                         spin_unlock(&midi->input_lock);
    90                         if (midi->substream_input)
    91                                 snd_rawmidi_receive(midi->substream_input, &byte, 1);
    92                         spin_lock(&midi->input_lock);
    93                 }
    94         }
    95         spin_unlock(&midi->input_lock);
    96 
    97         spin_lock(&midi->output_lock);
    98         if ((status & midi->ipr_tx) && mpu401_output_ready(emu, midi)) {
    99                 if (midi->substream_output &&
    100                     snd_rawmidi_transmit(midi->substream_output, &byte, 1) == 1) {
    101                         mpu401_write_data(emu, midi, byte);
    102                 } else {
    103                         snd_emu10k1_intr_disable(emu, midi->tx_enable);
    104                 }
    105         }
    106         spin_unlock(&midi->output_lock);
     76    unsigned char byte;
     77
     78    if (midi->rmidi == NULL) {
     79        snd_emu10k1_intr_disable(emu, midi->tx_enable | midi->rx_enable);
     80        return;
     81    }
     82
     83    spin_lock(&midi->input_lock);
     84    if ((status & midi->ipr_rx) && mpu401_input_avail(emu, midi)) {
     85        if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
     86            mpu401_clear_rx(emu, midi);
     87        } else {
     88            byte = mpu401_read_data(emu, midi);
     89            if (midi->substream_input)
     90                snd_rawmidi_receive(midi->substream_input, &byte, 1);
     91        }
     92    }
     93    spin_unlock(&midi->input_lock);
     94
     95    spin_lock(&midi->output_lock);
     96    if ((status & midi->ipr_tx) && mpu401_output_ready(emu, midi)) {
     97        if (midi->substream_output &&
     98            snd_rawmidi_transmit(midi->substream_output, &byte, 1) == 1) {
     99            mpu401_write_data(emu, midi, byte);
     100        } else {
     101            snd_emu10k1_intr_disable(emu, midi->tx_enable);
     102        }
     103    }
     104    spin_unlock(&midi->output_lock);
    107105}
    108106
    109107static void snd_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, unsigned int status)
    110108{
    111         do_emu10k1_midi_interrupt(emu, &emu->midi, status);
     109    do_emu10k1_midi_interrupt(emu, &emu->midi, status);
    112110}
    113111
    114112static void snd_emu10k1_midi_interrupt2(struct snd_emu10k1 *emu, unsigned int status)
    115113{
    116         do_emu10k1_midi_interrupt(emu, &emu->midi2, status);
    117 }
    118 
    119 static void snd_emu10k1_midi_cmd(struct snd_emu10k1 * emu, struct snd_emu10k1_midi *midi, unsigned char cmd, int ack)
    120 {
    121         unsigned long flags;
    122         int timeout, ok;
    123 
    124         spin_lock_irqsave(&midi->input_lock, flags);
    125         mpu401_write_data(emu, midi, 0x00);
    126         /* mpu401_clear_rx(emu, midi); */
    127 
    128         mpu401_write_cmd(emu, midi, cmd);
    129         if (ack) {
    130                 ok = 0;
    131                 timeout = 10000;
    132                 while (!ok && timeout-- > 0) {
    133                         if (mpu401_input_avail(emu, midi)) {
    134                                 if (mpu401_read_data(emu, midi) == MPU401_ACK)
    135                                         ok = 1;
    136                         }
    137                 }
    138                 if (!ok && mpu401_read_data(emu, midi) == MPU401_ACK)
    139                         ok = 1;
    140         } else {
    141                 ok = 1;
    142         }
    143         spin_unlock_irqrestore(&midi->input_lock, flags);
    144         if (!ok)
    145                 snd_printk(KERN_ERR "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
    146                            cmd, emu->port,
    147                            mpu401_read_stat(emu, midi),
    148                            mpu401_read_data(emu, midi));
    149 }
    150 
    151 static int snd_emu10k1_midi_input_open(snd_rawmidi_substream_t * substream)
    152 {
    153         struct snd_emu10k1 *emu;
    154         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
    155         unsigned long flags;
    156 
    157         emu = midi->emu;
    158         snd_assert(emu, return -ENXIO);
    159         spin_lock_irqsave(&midi->open_lock, flags);
    160         midi->midi_mode |= EMU10K1_MIDI_MODE_INPUT;
    161         midi->substream_input = substream;
    162         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
    163                 spin_unlock_irqrestore(&midi->open_lock, flags);
    164                 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1);
    165                 snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1);
    166         } else {
    167                 spin_unlock_irqrestore(&midi->open_lock, flags);
    168         }
    169         return 0;
    170 }
    171 
    172 static int snd_emu10k1_midi_output_open(snd_rawmidi_substream_t * substream)
    173 {
    174         struct snd_emu10k1 *emu;
    175         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
    176         unsigned long flags;
    177 
    178         emu = midi->emu;
    179         snd_assert(emu, return -ENXIO);
    180         spin_lock_irqsave(&midi->open_lock, flags);
    181         midi->midi_mode |= EMU10K1_MIDI_MODE_OUTPUT;
    182         midi->substream_output = substream;
    183         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
    184                 spin_unlock_irqrestore(&midi->open_lock, flags);
    185                 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1);
    186                 snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1);
    187         } else {
    188                 spin_unlock_irqrestore(&midi->open_lock, flags);
    189         }
    190         return 0;
    191 }
    192 
    193 static int snd_emu10k1_midi_input_close(snd_rawmidi_substream_t * substream)
    194 {
    195         struct snd_emu10k1 *emu;
    196         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
    197         unsigned long flags;
    198 
    199         emu = midi->emu;
    200         snd_assert(emu, return -ENXIO);
    201         spin_lock_irqsave(&midi->open_lock, flags);
    202         snd_emu10k1_intr_disable(emu, midi->rx_enable);
    203         midi->midi_mode &= ~EMU10K1_MIDI_MODE_INPUT;
    204         midi->substream_input = NULL;
    205         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
    206                 spin_unlock_irqrestore(&midi->open_lock, flags);
    207                 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
    208         } else {
    209                 spin_unlock_irqrestore(&midi->open_lock, flags);
    210         }
    211         return 0;
    212 }
    213 
    214 static int snd_emu10k1_midi_output_close(snd_rawmidi_substream_t * substream)
    215 {
    216         struct snd_emu10k1 *emu;
    217         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
    218         unsigned long flags;
    219 
    220         emu = midi->emu;
    221         snd_assert(emu, return -ENXIO);
    222         spin_lock_irqsave(&midi->open_lock, flags);
    223         snd_emu10k1_intr_disable(emu, midi->tx_enable);
    224         midi->midi_mode &= ~EMU10K1_MIDI_MODE_OUTPUT;
    225         midi->substream_output = NULL;
    226         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
    227                 spin_unlock_irqrestore(&midi->open_lock, flags);
    228                 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
    229         } else {
    230                 spin_unlock_irqrestore(&midi->open_lock, flags);
    231         }
    232         return 0;
    233 }
    234 
    235 static void snd_emu10k1_midi_input_trigger(snd_rawmidi_substream_t * substream, int up)
    236 {
    237         struct snd_emu10k1 *emu;
    238         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
    239         emu = midi->emu;
    240         snd_assert(emu, return);
    241 
    242         if (up)
    243                 snd_emu10k1_intr_enable(emu, midi->rx_enable);
    244         else
    245                 snd_emu10k1_intr_disable(emu, midi->rx_enable);
    246 }
    247 
    248 static void snd_emu10k1_midi_output_trigger(snd_rawmidi_substream_t * substream, int up)
    249 {
    250         struct snd_emu10k1 *emu;
    251         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
    252         unsigned long flags;
    253 
    254         emu = midi->emu;
    255         snd_assert(emu, return);
    256 
    257         if (up) {
    258                 int max = 4;
    259                 unsigned char byte;
    260        
    261                 /* try to send some amount of bytes here before interrupts */
    262                 spin_lock_irqsave(&midi->output_lock, flags);
    263                 while (max > 0) {
    264                         if (mpu401_output_ready(emu, midi)) {
    265                                 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT) ||
    266                                     snd_rawmidi_transmit(substream, &byte, 1) != 1) {
    267                                         /* no more data */
    268                                         spin_unlock_irqrestore(&midi->output_lock, flags);
    269                                         return;
    270                                 }
    271                                 mpu401_write_data(emu, midi, byte);
    272                                 max--;
    273                         } else {
    274                                 break;
    275                         }
    276                 }
    277                 spin_unlock_irqrestore(&midi->output_lock, flags);
    278                 snd_emu10k1_intr_enable(emu, midi->tx_enable);
    279         } else {
    280                 snd_emu10k1_intr_disable(emu, midi->tx_enable);
    281         }
     114    do_emu10k1_midi_interrupt(emu, &emu->midi2, status);
     115}
     116
     117static int snd_emu10k1_midi_cmd(struct snd_emu10k1 * emu, struct snd_emu10k1_midi *midi, unsigned char cmd, int ack)
     118{
     119    unsigned long flags;
     120    int timeout, ok;
     121
     122    spin_lock_irqsave(&midi->input_lock, flags);
     123    mpu401_write_data(emu, midi, 0x00);
     124    /* mpu401_clear_rx(emu, midi); */
     125
     126    mpu401_write_cmd(emu, midi, cmd);
     127    if (ack) {
     128        ok = 0;
     129        timeout = 10000;
     130        while (!ok && timeout-- > 0) {
     131            if (mpu401_input_avail(emu, midi)) {
     132                if (mpu401_read_data(emu, midi) == MPU401_ACK)
     133                    ok = 1;
     134            }
     135        }
     136        if (!ok && mpu401_read_data(emu, midi) == MPU401_ACK)
     137            ok = 1;
     138    } else {
     139        ok = 1;
     140    }
     141    spin_unlock_irqrestore(&midi->input_lock, flags);
     142    if (!ok) {
     143        snd_printk(KERN_ERR "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
     144                   cmd, emu->port,
     145                   mpu401_read_stat(emu, midi),
     146                   mpu401_read_data(emu, midi));
     147        return 1;
     148    }
     149    return 0;
     150}
     151
     152static int snd_emu10k1_midi_input_open(struct snd_rawmidi_substream *substream)
     153{
     154    struct snd_emu10k1 *emu;
     155    struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
     156    unsigned long flags;
     157
     158    emu = midi->emu;
     159    snd_assert(emu, return -ENXIO);
     160    spin_lock_irqsave(&midi->open_lock, flags);
     161    midi->midi_mode |= EMU10K1_MIDI_MODE_INPUT;
     162    midi->substream_input = substream;
     163    if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
     164        spin_unlock_irqrestore(&midi->open_lock, flags);
     165        if (snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1))
     166            goto error_out;
     167        if (snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1))
     168            goto error_out;
     169    } else {
     170        spin_unlock_irqrestore(&midi->open_lock, flags);
     171    }
     172    return 0;
     173
     174    error_out:
     175        return -EIO;
     176}
     177
     178static int snd_emu10k1_midi_output_open(struct snd_rawmidi_substream *substream)
     179{
     180    struct snd_emu10k1 *emu;
     181    struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
     182    unsigned long flags;
     183
     184    emu = midi->emu;
     185    snd_assert(emu, return -ENXIO);
     186    spin_lock_irqsave(&midi->open_lock, flags);
     187    midi->midi_mode |= EMU10K1_MIDI_MODE_OUTPUT;
     188    midi->substream_output = substream;
     189    if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
     190        spin_unlock_irqrestore(&midi->open_lock, flags);
     191        if (snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1))
     192            goto error_out;
     193        if (snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1))
     194            goto error_out;
     195    } else {
     196        spin_unlock_irqrestore(&midi->open_lock, flags);
     197    }
     198    return 0;
     199
     200    error_out:
     201        return -EIO;
     202}
     203
     204static int snd_emu10k1_midi_input_close(struct snd_rawmidi_substream *substream)
     205{
     206    struct snd_emu10k1 *emu;
     207    struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
     208    unsigned long flags;
     209    int err = 0;
     210
     211    emu = midi->emu;
     212    snd_assert(emu, return -ENXIO);
     213    spin_lock_irqsave(&midi->open_lock, flags);
     214    snd_emu10k1_intr_disable(emu, midi->rx_enable);
     215    midi->midi_mode &= ~EMU10K1_MIDI_MODE_INPUT;
     216    midi->substream_input = NULL;
     217    if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
     218        spin_unlock_irqrestore(&midi->open_lock, flags);
     219        err = snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
     220    } else {
     221        spin_unlock_irqrestore(&midi->open_lock, flags);
     222    }
     223    return err;
     224}
     225
     226static int snd_emu10k1_midi_output_close(struct snd_rawmidi_substream *substream)
     227{
     228    struct snd_emu10k1 *emu;
     229    struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
     230    unsigned long flags;
     231    int err = 0;
     232
     233    emu = midi->emu;
     234    snd_assert(emu, return -ENXIO);
     235    spin_lock_irqsave(&midi->open_lock, flags);
     236    snd_emu10k1_intr_disable(emu, midi->tx_enable);
     237    midi->midi_mode &= ~EMU10K1_MIDI_MODE_OUTPUT;
     238    midi->substream_output = NULL;
     239    if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
     240        spin_unlock_irqrestore(&midi->open_lock, flags);
     241        err = snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
     242    } else {
     243        spin_unlock_irqrestore(&midi->open_lock, flags);
     244    }
     245    return err;
     246}
     247
     248static void snd_emu10k1_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
     249{
     250    struct snd_emu10k1 *emu;
     251    struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
     252    emu = midi->emu;
     253    snd_assert(emu, return);
     254
     255    if (up)
     256        snd_emu10k1_intr_enable(emu, midi->rx_enable);
     257    else
     258        snd_emu10k1_intr_disable(emu, midi->rx_enable);
     259}
     260
     261static void snd_emu10k1_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
     262{
     263    struct snd_emu10k1 *emu;
     264    struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
     265    unsigned long flags;
     266
     267    emu = midi->emu;
     268    snd_assert(emu, return);
     269
     270    if (up) {
     271        int max = 4;
     272        unsigned char byte;
     273
     274        /* try to send some amount of bytes here before interrupts */
     275        spin_lock_irqsave(&midi->output_lock, flags);
     276        while (max > 0) {
     277            if (mpu401_output_ready(emu, midi)) {
     278                if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT) ||
     279                    snd_rawmidi_transmit(substream, &byte, 1) != 1) {
     280                    /* no more data */
     281                    spin_unlock_irqrestore(&midi->output_lock, flags);
     282                    return;
     283                }
     284                mpu401_write_data(emu, midi, byte);
     285                max--;
     286            } else {
     287                break;
     288            }
     289        }
     290        spin_unlock_irqrestore(&midi->output_lock, flags);
     291        snd_emu10k1_intr_enable(emu, midi->tx_enable);
     292    } else {
     293        snd_emu10k1_intr_disable(emu, midi->tx_enable);
     294    }
    282295}
    283296
    284297/*
    285298
    286  */
    287 
    288 #ifdef TARGET_OS2
    289 static snd_rawmidi_ops_t snd_emu10k1_midi_output =
    290 {
    291         snd_emu10k1_midi_output_open,
    292         snd_emu10k1_midi_output_close,
    293         snd_emu10k1_midi_output_trigger,0
     299*/
     300
     301static struct snd_rawmidi_ops snd_emu10k1_midi_output =
     302{
     303    .open =             snd_emu10k1_midi_output_open,
     304    .close =    snd_emu10k1_midi_output_close,
     305    .trigger =  snd_emu10k1_midi_output_trigger,
    294306};
    295307
    296 static snd_rawmidi_ops_t snd_emu10k1_midi_input =
    297 {
    298         snd_emu10k1_midi_input_open,
    299         snd_emu10k1_midi_input_close,
    300         snd_emu10k1_midi_input_trigger,0
     308static struct snd_rawmidi_ops snd_emu10k1_midi_input =
     309{
     310    .open =             snd_emu10k1_midi_input_open,
     311    .close =    snd_emu10k1_midi_input_close,
     312    .trigger =  snd_emu10k1_midi_input_trigger,
    301313};
    302 #else
    303 static snd_rawmidi_ops_t snd_emu10k1_midi_output =
    304 {
    305         open:           snd_emu10k1_midi_output_open,
    306         close:          snd_emu10k1_midi_output_close,
    307         trigger:        snd_emu10k1_midi_output_trigger,
    308 };
    309 
    310 static snd_rawmidi_ops_t snd_emu10k1_midi_input =
    311 {
    312         open:           snd_emu10k1_midi_input_open,
    313         close:          snd_emu10k1_midi_input_close,
    314         trigger:        snd_emu10k1_midi_input_trigger,
    315 };
    316 #endif
    317 
    318 static void snd_emu10k1_midi_free(snd_rawmidi_t *rmidi)
    319 {
    320         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)rmidi->private_data;
    321         midi->interrupt = NULL;
    322         midi->rmidi = NULL;
     314
     315static void snd_emu10k1_midi_free(struct snd_rawmidi *rmidi)
     316{
     317    struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)rmidi->private_data;
     318    midi->interrupt = NULL;
     319    midi->rmidi = NULL;
    323320}
    324321
    325322static int __devinit emu10k1_midi_init(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, int device, char *name)
    326323{
    327         snd_rawmidi_t *rmidi;
    328         int err;
    329 
    330         if ((err = snd_rawmidi_new(emu->card, name, device, 1, 1, &rmidi)) < 0)
    331                 return err;
    332         midi->emu = emu;
    333         spin_lock_init(&midi->open_lock);
    334         spin_lock_init(&midi->input_lock);
    335         spin_lock_init(&midi->output_lock);
    336         strcpy(rmidi->name, name);
    337         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_emu10k1_midi_output);
    338         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_emu10k1_midi_input);
    339         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
    340                              SNDRV_RAWMIDI_INFO_INPUT |
    341                              SNDRV_RAWMIDI_INFO_DUPLEX;
    342         rmidi->private_data = midi;
    343         rmidi->private_free = snd_emu10k1_midi_free;
    344         midi->rmidi = rmidi;
    345         return 0;
     324    struct snd_rawmidi *rmidi;
     325    int err;
     326
     327    if ((err = snd_rawmidi_new(emu->card, name, device, 1, 1, &rmidi)) < 0)
     328        return err;
     329    midi->emu = emu;
     330    spin_lock_init(&midi->open_lock);
     331    spin_lock_init(&midi->input_lock);
     332    spin_lock_init(&midi->output_lock);
     333    strcpy(rmidi->name, name);
     334    snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_emu10k1_midi_output);
     335    snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_emu10k1_midi_input);
     336    rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
     337        SNDRV_RAWMIDI_INFO_INPUT |
     338        SNDRV_RAWMIDI_INFO_DUPLEX;
     339    rmidi->private_data = midi;
     340    rmidi->private_free = snd_emu10k1_midi_free;
     341    midi->rmidi = rmidi;
     342    return 0;
    346343}
    347344
    348345int __devinit snd_emu10k1_midi(struct snd_emu10k1 *emu)
    349346{
    350         struct snd_emu10k1_midi *midi = &emu->midi;
    351         int err;
    352 
    353         if ((err = emu10k1_midi_init(emu, midi, 0, "EMU10K1 MPU-401 (UART)")) < 0)
    354                 return err;
    355 
    356         midi->tx_enable = INTE_MIDITXENABLE;
    357         midi->rx_enable = INTE_MIDIRXENABLE;
    358         midi->port = MUDATA;
    359         midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
    360         midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
    361         midi->interrupt = snd_emu10k1_midi_interrupt;
    362         return 0;
     347    struct snd_emu10k1_midi *midi = &emu->midi;
     348    int err;
     349
     350    if ((err = emu10k1_midi_init(emu, midi, 0, "EMU10K1 MPU-401 (UART)")) < 0)
     351        return err;
     352
     353    midi->tx_enable = INTE_MIDITXENABLE;
     354    midi->rx_enable = INTE_MIDIRXENABLE;
     355    midi->port = MUDATA;
     356    midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
     357    midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
     358    midi->interrupt = snd_emu10k1_midi_interrupt;
     359    return 0;
    363360}
    364361
    365362int __devinit snd_emu10k1_audigy_midi(struct snd_emu10k1 *emu)
    366363{
    367         struct snd_emu10k1_midi *midi;
    368         int err;
    369 
    370         midi = &emu->midi;
    371         if ((err = emu10k1_midi_init(emu, midi, 0, "Audigy MPU-401 (UART)")) < 0)
    372                 return err;
    373 
    374         midi->tx_enable = INTE_MIDITXENABLE;
    375         midi->rx_enable = INTE_MIDIRXENABLE;
    376         midi->port = A_MUDATA1;
    377         midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
    378         midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
    379         midi->interrupt = snd_emu10k1_midi_interrupt;
    380 
    381         midi = &emu->midi2;
    382         if ((err = emu10k1_midi_init(emu, midi, 1, "Audigy MPU-401 #2")) < 0)
    383                 return err;
    384 
    385         midi->tx_enable = INTE_A_MIDITXENABLE2;
    386         midi->rx_enable = INTE_A_MIDIRXENABLE2;
    387         midi->port = A_MUDATA2;
    388         midi->ipr_tx = IPR_A_MIDITRANSBUFEMPTY2;
    389         midi->ipr_rx = IPR_A_MIDIRECVBUFEMPTY2;
    390         midi->interrupt = snd_emu10k1_midi_interrupt2;
    391         return 0;
    392 }
     364    struct snd_emu10k1_midi *midi;
     365    int err;
     366
     367    midi = &emu->midi;
     368    if ((err = emu10k1_midi_init(emu, midi, 0, "Audigy MPU-401 (UART)")) < 0)
     369        return err;
     370
     371    midi->tx_enable = INTE_MIDITXENABLE;
     372    midi->rx_enable = INTE_MIDIRXENABLE;
     373    midi->port = A_MUDATA1;
     374    midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
     375    midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
     376    midi->interrupt = snd_emu10k1_midi_interrupt;
     377
     378    midi = &emu->midi2;
     379    if ((err = emu10k1_midi_init(emu, midi, 1, "Audigy MPU-401 #2")) < 0)
     380        return err;
     381
     382    midi->tx_enable = INTE_A_MIDITXENABLE2;
     383    midi->rx_enable = INTE_A_MIDIRXENABLE2;
     384    midi->port = A_MUDATA2;
     385    midi->ipr_tx = IPR_A_MIDITRANSBUFEMPTY2;
     386    midi->ipr_rx = IPR_A_MIDIRECVBUFEMPTY2;
     387    midi->interrupt = snd_emu10k1_midi_interrupt2;
     388    return 0;
     389}
Note: See TracChangeset for help on using the changeset viewer.