/* $Id: message.c,v 1.5.8.2 2001/09/23 22:24:59 kai Exp $
 *
 * functions for sending and receiving control messages
 *
 * Copyright (C) 1996  SpellCaster Telecommunications Inc.
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 * For more information, please contact gpl-info@spellcast.com or write:
 *
 *     SpellCaster Telecommunications Inc.
 *     5621 Finch Avenue East, Unit #3
 *     Scarborough, Ontario  Canada
 *     M1B 2T9
 *     +1 (416) 297-8565
 *     +1 (416) 297-6433 Facsimile
 */
#include <linux/sched.h>
#include "includes.h"
#include "hardware.h"
#include "message.h"
#include "card.h"

/*
 * receive a message from the board
 */
int receivemessage(int card, RspMessage *rspmsg)
{
        DualPortMemory *dpm;
        unsigned long flags;

        if (!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -EINVAL;
        }

        pr_debug("%s: Entered receivemessage\n",
                 sc_adapter[card]->devicename);

        /*
         * See if there are messages waiting
         */
        if (inb(sc_adapter[card]->ioport[FIFO_STATUS]) & RF_HAS_DATA) {
                /*
                 * Map in the DPM to the base page and copy the message
                 */
                spin_lock_irqsave(&sc_adapter[card]->lock, flags);
                outb((sc_adapter[card]->shmem_magic >> 14) | 0x80,
                     sc_adapter[card]->ioport[sc_adapter[card]->shmem_pgport]);
                dpm = (DualPortMemory *) sc_adapter[card]->rambase;
                memcpy_fromio(rspmsg, &(dpm->rsp_queue[dpm->rsp_tail]),
                              MSG_LEN);
                dpm->rsp_tail = (dpm->rsp_tail + 1) % MAX_MESSAGES;
                inb(sc_adapter[card]->ioport[FIFO_READ]);
                spin_unlock_irqrestore(&sc_adapter[card]->lock, flags);
                /*
                 * Tell the board that the message is received
                 */
                pr_debug("%s: Received Message seq:%d pid:%d time:%d cmd:%d "
                         "cnt:%d (type,class,code):(%d,%d,%d) "
                         "link:%d stat:0x%x\n",
                         sc_adapter[card]->devicename,
                         rspmsg->sequence_no,
                         rspmsg->process_id,
                         rspmsg->time_stamp,
                         rspmsg->cmd_sequence_no,
                         rspmsg->msg_byte_cnt,
                         rspmsg->type,
                         rspmsg->class,
                         rspmsg->code,
                         rspmsg->phy_link_no,
                         rspmsg->rsp_status);

                return 0;
        }
        return -ENOMSG;
}

/*
 * send a message to the board
 */
int sendmessage(int card,
                unsigned int procid,
                unsigned int type,
                unsigned int class,
                unsigned int code,
                unsigned int link,
                unsigned int data_len,
                unsigned int *data)
{
        DualPortMemory *dpm;
        ReqMessage sndmsg;
        unsigned long flags;

        if (!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -EINVAL;
        }

        /*
         * Make sure we only send CEPID messages when the engine is up
         * and CMPID messages when it is down
         */
        if (sc_adapter[card]->EngineUp && procid == CMPID) {
                pr_debug("%s: Attempt to send CM message with engine up\n",
                         sc_adapter[card]->devicename);
                return -ESRCH;
        }

        if (!sc_adapter[card]->EngineUp && procid == CEPID) {
                pr_debug("%s: Attempt to send CE message with engine down\n",
                         sc_adapter[card]->devicename);
                return -ESRCH;
        }

        memset(&sndmsg, 0, MSG_LEN);
        sndmsg.msg_byte_cnt = 4;
        sndmsg.type = type;
        sndmsg.class = class;
        sndmsg.code = code;
        sndmsg.phy_link_no = link;

        if (data_len > 0) {
                if (data_len > MSG_DATA_LEN)
                        data_len = MSG_DATA_LEN;
                memcpy(&(sndmsg.msg_data), data, data_len);
                sndmsg.msg_byte_cnt = data_len + 8;
        }

        sndmsg.process_id = procid;
        sndmsg.sequence_no = sc_adapter[card]->seq_no++ % 256;

        /*
         * wait for an empty slot in the queue
         */
        while (!(inb(sc_adapter[card]->ioport[FIFO_STATUS]) & WF_NOT_FULL))
                udelay(1);

        /*
         * Disable interrupts and map in shared memory
         */
        spin_lock_irqsave(&sc_adapter[card]->lock, flags);
        outb((sc_adapter[card]->shmem_magic >> 14) | 0x80,
             sc_adapter[card]->ioport[sc_adapter[card]->shmem_pgport]);
        dpm = (DualPortMemory *) sc_adapter[card]->rambase;     /* Fix me */
        memcpy_toio(&(dpm->req_queue[dpm->req_head]), &sndmsg, MSG_LEN);
        dpm->req_head = (dpm->req_head + 1) % MAX_MESSAGES;
        outb(sndmsg.sequence_no, sc_adapter[card]->ioport[FIFO_WRITE]);
        spin_unlock_irqrestore(&sc_adapter[card]->lock, flags);

        pr_debug("%s: Sent Message seq:%d pid:%d time:%d "
                 "cnt:%d (type,class,code):(%d,%d,%d) "
                 "link:%d\n ",
                 sc_adapter[card]->devicename,
                 sndmsg.sequence_no,
                 sndmsg.process_id,
                 sndmsg.time_stamp,
                 sndmsg.msg_byte_cnt,
                 sndmsg.type,
                 sndmsg.class,
                 sndmsg.code,
                 sndmsg.phy_link_no);

        return 0;
}

int send_and_receive(int card,
                     unsigned int procid,
                     unsigned char type,
                     unsigned char class,
                     unsigned char code,
                     unsigned char link,
                     unsigned char data_len,
                     unsigned char *data,
                     RspMessage *mesgdata,
                     int timeout)
{
        int retval;
        int tries;

        if (!IS_VALID_CARD(card)) {
                pr_debug("Invalid param: %d is not a valid card id\n", card);
                return -EINVAL;
        }

        sc_adapter[card]->want_async_messages = 1;
        retval = sendmessage(card, procid, type, class, code, link,
                             data_len, (unsigned int *) data);

        if (retval) {
                pr_debug("%s: SendMessage failed in SAR\n",
                         sc_adapter[card]->devicename);
                sc_adapter[card]->want_async_messages = 0;
                return -EIO;
        }

        tries = 0;
        /* wait for the response */
        while (tries < timeout) {
                schedule_timeout_interruptible(1);

                pr_debug("SAR waiting..\n");

                /*
                 * See if we got our message back
                 */
                if ((sc_adapter[card]->async_msg.type == type) &&
                    (sc_adapter[card]->async_msg.class == class) &&
                    (sc_adapter[card]->async_msg.code == code) &&
                    (sc_adapter[card]->async_msg.phy_link_no == link)) {

                        /*
                         * Got it!
                         */
                        pr_debug("%s: Got ASYNC message\n",
                                 sc_adapter[card]->devicename);
                        memcpy(mesgdata, &(sc_adapter[card]->async_msg),
                               sizeof(RspMessage));
                        sc_adapter[card]->want_async_messages = 0;
                        return 0;
                }

                tries++;
        }

        pr_debug("%s: SAR message timeout\n", sc_adapter[card]->devicename);
        sc_adapter[card]->want_async_messages = 0;
        return -ETIME;
}