source: sbliveos2/trunk/sblive/cardmo.c

/* $Id: cardmo.c 142 2000-04-23 14:55:46Z ktk $ */


/*     
 **********************************************************************
 *     cardmo.c - MIDI UART output HAL for emu10k1 driver 
 *     Copyright 1999, 2000 Creative Labs, Inc. 
 * 
 ********************************************************************** 
 * 
 *     Date                 Author          Summary of changes 
 *     ----                 ------          ------------------ 
 *     October 20, 1999     Bertrand Lee    base code release 
 *     November 2, 1999     Alan Cox        cleaned up
 * 
 ********************************************************************** 
 * 
 *     This program is free software; you can redistribute it and/or 
 *     modify it under the terms of the GNU General Public License as 
 *     published by the Free Software Foundation; either version 2 of 
 *     the License, or (at your option) any later version. 
 * 
 *     This program is distributed in the hope that it will be useful, 
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *     GNU General Public License for more details. 
 * 
 *     You should have received a copy of the GNU General Public 
 *     License along with this program; if not, write to the Free 
 *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 
 *     USA. 
 * 
 ********************************************************************** 
 */

#include "hwaccess.h"
#include "cardmo.h"

/* Installs the IRQ handler for the MPU out port               *
 * and initialize parameters                                    */

int emu10k1_mpuout_open(struct emu10k1_card *card, struct midi_openinfo *openinfo)
{
        struct emu10k1_mpuout *card_mpuout = card->mpuout;

        DPF(2, "emu10k1_mpuout_open()\n");

        if (!(card_mpuout->status & FLAGS_AVAILABLE))
                return CTSTATUS_INUSE;

        /* Copy open info and mark channel as in use */
        card_mpuout->intr = 0;
        card_mpuout->openinfo = *openinfo;
        card_mpuout->status &= ~FLAGS_AVAILABLE;
        card_mpuout->laststatus = 0x80;
        card_mpuout->firstmidiq = NULL;
        card_mpuout->lastmidiq = NULL;

        emu10k1_mpu_reset(card);
        emu10k1_mpu_acquire(card);

        return CTSTATUS_SUCCESS;
}

int emu10k1_mpuout_close(struct emu10k1_card *card)
{
        struct emu10k1_mpuout *card_mpuout = card->mpuout;
        struct midi_queue *midiq;
        struct midi_hdr *midihdr;
        unsigned long flags;

        DPF(2, "emu10k1_mpuout_close()\n");

        emu10k1_irq_disable(card, INTE_MIDITXENABLE);

        spin_lock_irqsave(&card_mpuout->lock, flags);

        while (card_mpuout->firstmidiq != NULL) {
                midiq = card_mpuout->firstmidiq;
                midihdr = (struct midi_hdr *) midiq->refdata;

                card_mpuout->firstmidiq = midiq->next;

                kfree(midihdr->data);
                kfree(midihdr);
                kfree(midiq);
        }

        card_mpuout->lastmidiq = NULL;

        emu10k1_mpu_release(card);

        card_mpuout->status |= FLAGS_AVAILABLE;

        spin_unlock_irqrestore(&card_mpuout->lock, flags);

        return CTSTATUS_SUCCESS;
}

/* If there isn't enough buffer space, reject Midi Buffer.     *
* Otherwise, disable TX, create object to hold Midi            *
*  uffer, update buffer flags and other parameters             *
* before enabling TX again.                                    */

int emu10k1_mpuout_add_buffer(struct emu10k1_card *card, struct midi_hdr *midihdr)
{
        struct emu10k1_mpuout *card_mpuout = card->mpuout;
        struct midi_queue *midiq;
        unsigned long flags;

        DPF(2, "emu10k1_mpuout_add_buffer()\n");

        if (card_mpuout->state == CARDMIDIOUT_STATE_SUSPEND)
                return CTSTATUS_SUCCESS;

        midihdr->flags |= MIDIBUF_INQUEUE;
        midihdr->flags &= ~MIDIBUF_DONE;

        if ((midiq = (struct midi_queue *) kmalloc(sizeof(struct midi_queue), GFP_KERNEL)) == NULL) {
                /* Message lost */
                return CTSTATUS_NOMEMORY;
        }

        midiq->next = NULL;
        midiq->qtype = 1;
        midiq->length = midihdr->bufferlength;
        midiq->sizeLeft = midihdr->bufferlength;
        midiq->midibyte = midihdr->data;

        midiq->refdata = (unsigned long) midihdr;

        spin_lock_irqsave(&card_mpuout->lock, flags);

        if (card_mpuout->firstmidiq == NULL) {
                card_mpuout->firstmidiq = midiq;
                card_mpuout->lastmidiq = midiq;
        } else {
                (card_mpuout->lastmidiq)->next = midiq;
                card_mpuout->lastmidiq = midiq;
        }

        card_mpuout->intr = 0;

        emu10k1_irq_enable(card, INTE_MIDITXENABLE);

        spin_unlock_irqrestore(&card_mpuout->lock, flags);

        return CTSTATUS_SUCCESS;
}

void emu10k1_mpuout_bh(unsigned long refdata)
{
        struct emu10k1_card *card = (struct emu10k1_card *) refdata;
        struct emu10k1_mpuout *card_mpuout = card->mpuout;
        int cByteSent = 0;
        int status;
        struct midi_queue *midiq;
        struct midi_queue *doneq = NULL;
        unsigned long flags;

        spin_lock_irqsave(&card_mpuout->lock, flags);

        while (card_mpuout->firstmidiq != NULL) {
                midiq = card_mpuout->firstmidiq;

                while (cByteSent < 4 && midiq->sizeLeft) {
                        status = emu10k1_mpu_write_data(card, *midiq->midibyte);

                        if (status == CTSTATUS_SUCCESS) {
                                ++cByteSent;
                                --midiq->sizeLeft;
                                ++midiq->midibyte;
                        } else {
                                DPF(2, "emu10k1_mpuoutDpcCallback error!!\n");
                        }
                }

                if (midiq->sizeLeft == 0) {
                        if (doneq == NULL)
                                doneq = midiq;
                        card_mpuout->firstmidiq = midiq->next;
                } else
                        break;
        }

        if (card_mpuout->firstmidiq == NULL)
                card_mpuout->lastmidiq = NULL;

        if (doneq != NULL) {
                while (doneq != card_mpuout->firstmidiq) {
                        unsigned long callback_msg[3];

                        midiq = doneq;
                        doneq = midiq->next;

                        if (midiq->qtype) {
                                callback_msg[0] = 0;
                                callback_msg[1] = midiq->length;
                                callback_msg[2] = midiq->refdata;

                                emu10k1_midi_callback(ICARDMIDI_OUTLONGDATA, card_mpuout->openinfo.refdata, callback_msg);
                        } else if (((u8) midiq->refdata) < 0xF0 && ((u8) midiq->refdata) > 0x7F)
                                card_mpuout->laststatus = (u8) midiq->refdata;

                        kfree(midiq);
                }
        }

        if ((card_mpuout->firstmidiq != NULL) || cByteSent) {
                card_mpuout->intr = 0;
                emu10k1_irq_enable(card, INTE_MIDITXENABLE);
        }

        spin_unlock_irqrestore(&card_mpuout->lock, flags);

        return;
}

int emu10k1_mpuout_irqhandler(struct emu10k1_card *card)
{
        struct emu10k1_mpuout *card_mpuout = card->mpuout;

        DPF(4, "emu10k1_mpuout_irqhandler\n");

        card_mpuout->intr = 1;
        emu10k1_irq_disable(card, INTE_MIDITXENABLE);

        tasklet_hi_schedule(&card_mpuout->tasklet);

        return CTSTATUS_SUCCESS;
}