Subversion Repositories test_project

/* $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;

}