[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / isdn / sc / message.c

/* $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;
}
Commit	Line	Data
1da177e4 LT	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	*/
e8edc6e0	19	#include <linux/sched.h>
1da177e4 LT	20	#include "includes.h"
	21	#include "hardware.h"
	22	#include "message.h"
	23	#include "card.h"
	24
1da177e4 LT	25	/*
	26	* receive a message from the board
	27	*/
475be4d8	28	int receivemessage(int card, RspMessage *rspmsg)
1da177e4 LT	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	}
475be4d8	37
1da177e4	38	pr_debug("%s: Entered receivemessage\n",
475be4d8	39	sc_adapter[card]->devicename);
1da177e4 LT	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,
475be4d8	50	sc_adapter[card]->ioport[sc_adapter[card]->shmem_pgport]);
1da177e4	51	dpm = (DualPortMemory *) sc_adapter[card]->rambase;
475be4d8 JP	52	memcpy_fromio(rspmsg, &(dpm->rsp_queue[dpm->rsp_tail]),
	53	MSG_LEN);
	54	dpm->rsp_tail = (dpm->rsp_tail + 1) % MAX_MESSAGES;
1da177e4 LT	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 "
475be4d8 JP	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);
1da177e4 LT	74
	75	return 0;
	76	}
	77	return -ENOMSG;
	78	}
475be4d8	79
1da177e4 LT	80	/*
	81	* send a message to the board
	82	*/
	83	int sendmessage(int card,
	84	unsigned int procid,
475be4d8 JP	85	unsigned int type,
475be4d8 JP	86	unsigned int class,
1da177e4	87	unsigned int code,
475be4d8 JP	88	unsigned int link,
	89	unsigned int data_len,
	90	unsigned int *data)
1da177e4 LT	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	*/
475be4d8	105	if (sc_adapter[card]->EngineUp && procid == CMPID) {
1da177e4	106	pr_debug("%s: Attempt to send CM message with engine up\n",
475be4d8	107	sc_adapter[card]->devicename);
1da177e4 LT	108	return -ESRCH;
	109	}
	110
475be4d8	111	if (!sc_adapter[card]->EngineUp && procid == CEPID) {
1da177e4	112	pr_debug("%s: Attempt to send CE message with engine down\n",
475be4d8	113	sc_adapter[card]->devicename);
1da177e4 LT	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,
475be4d8	145	sc_adapter[card]->ioport[sc_adapter[card]->shmem_pgport]);
1da177e4	146	dpm = (DualPortMemory ) sc_adapter[card]->rambase; / Fix me */
475be4d8 JP	147	memcpy_toio(&(dpm->req_queue[dpm->req_head]), &sndmsg, MSG_LEN);
475be4d8 JP	148	dpm->req_head = (dpm->req_head + 1) % MAX_MESSAGES;
1da177e4 LT	149	outb(sndmsg.sequence_no, sc_adapter[card]->ioport[FIFO_WRITE]);
1da177e4 LT	150	spin_unlock_irqrestore(&sc_adapter[card]->lock, flags);
475be4d8	151
1da177e4	152	pr_debug("%s: Sent Message seq:%d pid:%d time:%d "
475be4d8 JP	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
1da177e4 LT	165	return 0;
	166	}
	167
	168	int send_and_receive(int card,
475be4d8 JP	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)
1da177e4 LT	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;
475be4d8 JP	188	retval = sendmessage(card, procid, type, class, code, link,
	189	data_len, (unsigned int *) data);
	190
1da177e4 LT	191	if (retval) {
1da177e4 LT	192	pr_debug("%s: SendMessage failed in SAR\n",
475be4d8	193	sc_adapter[card]->devicename);
1da177e4 LT	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) {
24763c48	201	schedule_timeout_interruptible(1);
475be4d8	202
1da177e4 LT	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",
475be4d8	217	sc_adapter[card]->devicename);
1da177e4	218	memcpy(mesgdata, &(sc_adapter[card]->async_msg),
475be4d8	219	sizeof(RspMessage));
1da177e4 LT	220	sc_adapter[card]->want_async_messages = 0;
	221	return 0;
	222	}
	223
475be4d8	224	tries++;
1da177e4 LT	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	}