release/src-rt-6.x/linux/linux-2.6/drivers/isdn/sc/message.c

   1 /* $Id: message.c,v 1.5.8.2 2001/09/23 22:24:59 kai Exp $
   2  *
   3  * functions for sending and receiving control messages
   4  *
   5  * Copyright (C) 1996  SpellCaster Telecommunications Inc.
   6  *
   7  * This software may be used and distributed according to the terms
   8  * of the GNU General Public License, incorporated herein by reference.
   9  *
  10  * For more information, please contact gpl-info@spellcast.com or write:
  11  *
  12  *     SpellCaster Telecommunications Inc.
  13  *     5621 Finch Avenue East, Unit #3
  14  *     Scarborough, Ontario  Canada
  15  *     M1B 2T9
  16  *     +1 (416) 297-8565
  17  *     +1 (416) 297-6433 Facsimile
  18  */
  19 #include <linux/sched.h>
  20 #include "includes.h"
  21 #include "hardware.h"
  22 #include "message.h"
  23 #include "card.h"
  24
  25 /*
  26  * receive a message from the board
  27  */
  28 int receivemessage(int card, RspMessage *rspmsg)
  29 {
  30         DualPortMemory *dpm;
  31         unsigned long flags;
  32
  33         if (!IS_VALID_CARD(card)) {
  34                 pr_debug("Invalid param: %d is not a valid card id\n", card);
  35                 return -EINVAL;
  36         }
  37
  38         pr_debug("%s: Entered receivemessage\n",
  39                         sc_adapter[card]->devicename);
  40
  41         /*
  42          * See if there are messages waiting
  43          */
  44         if (inb(sc_adapter[card]->ioport[FIFO_STATUS]) & RF_HAS_DATA) {
  45                 /*
  46                  * Map in the DPM to the base page and copy the message
  47                  */
  48                 spin_lock_irqsave(&sc_adapter[card]->lock, flags);
  49                 outb((sc_adapter[card]->shmem_magic >> 14) | 0x80,
  50                         sc_adapter[card]->ioport[sc_adapter[card]->shmem_pgport]);
  51                 dpm = (DualPortMemory *) sc_adapter[card]->rambase;
  52                 memcpy_fromio(rspmsg, &(dpm->rsp_queue[dpm->rsp_tail]),
  53                         MSG_LEN);
  54                 dpm->rsp_tail = (dpm->rsp_tail+1) % MAX_MESSAGES;
  55                 inb(sc_adapter[card]->ioport[FIFO_READ]);
  56                 spin_unlock_irqrestore(&sc_adapter[card]->lock, flags);
  57                 /*
  58                  * Tell the board that the message is received
  59                  */
  60                 pr_debug("%s: Received Message seq:%d pid:%d time:%d cmd:%d "
  61                                 "cnt:%d (type,class,code):(%d,%d,%d) "
  62                                 "link:%d stat:0x%x\n",
  63                                         sc_adapter[card]->devicename,
  64                                         rspmsg->sequence_no,
  65                                         rspmsg->process_id,
  66                                         rspmsg->time_stamp,
  67                                         rspmsg->cmd_sequence_no,
  68                                         rspmsg->msg_byte_cnt,
  69                                         rspmsg->type,
  70                                         rspmsg->class,
  71                                         rspmsg->code,
  72                                         rspmsg->phy_link_no,
  73                                         rspmsg->rsp_status);
  74
  75                 return 0;
  76         }
  77         return -ENOMSG;
  78 }
  79
  80 /*
  81  * send a message to the board
  82  */
  83 int sendmessage(int card,
  84                 unsigned int procid,
  85                 unsigned int type,
  86                 unsigned int class,
  87                 unsigned int code,
  88                 unsigned int link,
  89                 unsigned int data_len,
  90                 unsigned int *data)
  91 {
  92         DualPortMemory *dpm;
  93         ReqMessage sndmsg;
  94         unsigned long flags;
  95
  96         if (!IS_VALID_CARD(card)) {
  97                 pr_debug("Invalid param: %d is not a valid card id\n", card);
  98                 return -EINVAL;
  99         }
 100
 101         /*
 102          * Make sure we only send CEPID messages when the engine is up
 103          * and CMPID messages when it is down
 104          */
 105         if(sc_adapter[card]->EngineUp && procid == CMPID) {
 106                 pr_debug("%s: Attempt to send CM message with engine up\n",
 107                         sc_adapter[card]->devicename);
 108                 return -ESRCH;
 109         }
 110
 111         if(!sc_adapter[card]->EngineUp && procid == CEPID) {
 112                 pr_debug("%s: Attempt to send CE message with engine down\n",
 113                         sc_adapter[card]->devicename);
 114                 return -ESRCH;
 115         }
 116
 117         memset(&sndmsg, 0, MSG_LEN);
 118         sndmsg.msg_byte_cnt = 4;
 119         sndmsg.type = type;
 120         sndmsg.class = class;
 121         sndmsg.code = code;
 122         sndmsg.phy_link_no = link;
 123
 124         if (data_len > 0) {
 125                 if (data_len > MSG_DATA_LEN)
 126                         data_len = MSG_DATA_LEN;
 127                 memcpy(&(sndmsg.msg_data), data, data_len);
 128                 sndmsg.msg_byte_cnt = data_len + 8;
 129         }
 130
 131         sndmsg.process_id = procid;
 132         sndmsg.sequence_no = sc_adapter[card]->seq_no++ % 256;
 133
 134         /*
 135          * wait for an empty slot in the queue
 136          */
 137         while (!(inb(sc_adapter[card]->ioport[FIFO_STATUS]) & WF_NOT_FULL))
 138                 udelay(1);
 139
 140         /*
 141          * Disable interrupts and map in shared memory
 142          */
 143         spin_lock_irqsave(&sc_adapter[card]->lock, flags);
 144         outb((sc_adapter[card]->shmem_magic >> 14) | 0x80,
 145                 sc_adapter[card]->ioport[sc_adapter[card]->shmem_pgport]);
 146         dpm = (DualPortMemory *) sc_adapter[card]->rambase;     /* Fix me */
 147         memcpy_toio(&(dpm->req_queue[dpm->req_head]),&sndmsg,MSG_LEN);
 148         dpm->req_head = (dpm->req_head+1) % MAX_MESSAGES;
 149         outb(sndmsg.sequence_no, sc_adapter[card]->ioport[FIFO_WRITE]);
 150         spin_unlock_irqrestore(&sc_adapter[card]->lock, flags);
 151
 152         pr_debug("%s: Sent Message seq:%d pid:%d time:%d "
 153                         "cnt:%d (type,class,code):(%d,%d,%d) "
 154                         "link:%d\n ",
 155                                 sc_adapter[card]->devicename,
 156                                 sndmsg.sequence_no,
 157                                 sndmsg.process_id,
 158                                 sndmsg.time_stamp,
 159                                 sndmsg.msg_byte_cnt,
 160                                 sndmsg.type,
 161                                 sndmsg.class,
 162                                 sndmsg.code,
 163                                 sndmsg.phy_link_no);
 164
 165         return 0;
 166 }
 167
 168 int send_and_receive(int card,
 169                 unsigned int procid,
 170                 unsigned char type,
 171                 unsigned char class,
 172                 unsigned char code,
 173                 unsigned char link,
 174                 unsigned char data_len,
 175                 unsigned char *data,
 176                 RspMessage *mesgdata,
 177                 int timeout)
 178 {
 179         int retval;
 180         int tries;
 181
 182         if (!IS_VALID_CARD(card)) {
 183                 pr_debug("Invalid param: %d is not a valid card id\n", card);
 184                 return -EINVAL;
 185         }
 186
 187         sc_adapter[card]->want_async_messages = 1;
 188         retval = sendmessage(card, procid, type, class, code, link,
 189                         data_len, (unsigned int *) data);
 190
 191         if (retval) {
 192                 pr_debug("%s: SendMessage failed in SAR\n",
 193                         sc_adapter[card]->devicename);
 194                 sc_adapter[card]->want_async_messages = 0;
 195                 return -EIO;
 196         }
 197
 198         tries = 0;
 199         /* wait for the response */
 200         while (tries < timeout) {
 201                 schedule_timeout_interruptible(1);
 202
 203                 pr_debug("SAR waiting..\n");
 204
 205                 /*
 206                  * See if we got our message back
 207                  */
 208                 if ((sc_adapter[card]->async_msg.type == type) &&
 209                     (sc_adapter[card]->async_msg.class == class) &&
 210                     (sc_adapter[card]->async_msg.code == code) &&
 211                     (sc_adapter[card]->async_msg.phy_link_no == link)) {
 212
 213                         /*
 214                          * Got it!
 215                          */
 216                         pr_debug("%s: Got ASYNC message\n",
 217                                 sc_adapter[card]->devicename);
 218                         memcpy(mesgdata, &(sc_adapter[card]->async_msg),
 219                                 sizeof(RspMessage));
 220                         sc_adapter[card]->want_async_messages = 0;
 221                         return 0;
 222                 }
 223
 224                 tries++;
 225         }
 226
 227         pr_debug("%s: SAR message timeout\n", sc_adapter[card]->devicename);
 228         sc_adapter[card]->want_async_messages = 0;
 229         return -ETIME;
 230 }