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  */
receivemessage(int card,RspMessage * rspmsg)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  */
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)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 
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)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 }
231