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

/* $Id: packet.c,v 1.5.8.1 2001/09/23 22:24:59 kai Exp $
 *
 * 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 "includes.h"
#include "hardware.h"
#include "message.h"
#include "card.h"

int sndpkt(int devId, int channel, int ack, struct sk_buff *data)
{
	LLData	ReqLnkWrite;
	int status;
	int card;
	unsigned long len;

	card = get_card_from_id(devId);

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

	pr_debug("%s: sndpkt: frst = 0x%lx nxt = %d  f = %d n = %d\n",
		 sc_adapter[card]->devicename,
		 sc_adapter[card]->channel[channel].first_sendbuf,
		 sc_adapter[card]->channel[channel].next_sendbuf,
		 sc_adapter[card]->channel[channel].free_sendbufs,
		 sc_adapter[card]->channel[channel].num_sendbufs);

	if (!sc_adapter[card]->channel[channel].free_sendbufs) {
		pr_debug("%s: out of TX buffers\n",
			 sc_adapter[card]->devicename);
		return -EINVAL;
	}

	if (data->len > BUFFER_SIZE) {
		pr_debug("%s: data overflows buffer size (data > buffer)\n",
			 sc_adapter[card]->devicename);
		return -EINVAL;
	}

	ReqLnkWrite.buff_offset = sc_adapter[card]->channel[channel].next_sendbuf *
		BUFFER_SIZE + sc_adapter[card]->channel[channel].first_sendbuf;
	ReqLnkWrite.msg_len = data->len; /* sk_buff size */
	pr_debug("%s: writing %d bytes to buffer offset 0x%lx\n",
		 sc_adapter[card]->devicename,
		 ReqLnkWrite.msg_len, ReqLnkWrite.buff_offset);
	memcpy_toshmem(card, (char *)ReqLnkWrite.buff_offset, data->data, ReqLnkWrite.msg_len);

	/*
	 * sendmessage
	 */
	pr_debug("%s: sndpkt size=%d, buf_offset=0x%lx buf_indx=%d\n",
		 sc_adapter[card]->devicename,
		 ReqLnkWrite.msg_len, ReqLnkWrite.buff_offset,
		 sc_adapter[card]->channel[channel].next_sendbuf);

	status = sendmessage(card, CEPID, ceReqTypeLnk, ceReqClass1, ceReqLnkWrite,
			     channel + 1, sizeof(LLData), (unsigned int *)&ReqLnkWrite);
	len = data->len;
	if (status) {
		pr_debug("%s: failed to send packet, status = %d\n",
			 sc_adapter[card]->devicename, status);
		return -1;
	}
	else {
		sc_adapter[card]->channel[channel].free_sendbufs--;
		sc_adapter[card]->channel[channel].next_sendbuf =
			++sc_adapter[card]->channel[channel].next_sendbuf ==
			sc_adapter[card]->channel[channel].num_sendbufs ? 0 :
			sc_adapter[card]->channel[channel].next_sendbuf;
		pr_debug("%s: packet sent successfully\n", sc_adapter[card]->devicename);
		dev_kfree_skb(data);
		indicate_status(card, ISDN_STAT_BSENT, channel, (char *)&len);
	}
	return len;
}

void rcvpkt(int card, RspMessage *rcvmsg)
{
	LLData newll;
	struct sk_buff *skb;

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

	switch (rcvmsg->rsp_status) {
	case 0x01:
	case 0x02:
	case 0x70:
		pr_debug("%s: error status code: 0x%x\n",
			 sc_adapter[card]->devicename, rcvmsg->rsp_status);
		return;
	case 0x00:
		if (!(skb = dev_alloc_skb(rcvmsg->msg_data.response.msg_len))) {
			printk(KERN_WARNING "%s: rcvpkt out of memory, dropping packet\n",
			       sc_adapter[card]->devicename);
			return;
		}
		skb_put(skb, rcvmsg->msg_data.response.msg_len);
		pr_debug("%s: getting data from offset: 0x%lx\n",
			 sc_adapter[card]->devicename,
			 rcvmsg->msg_data.response.buff_offset);
		memcpy_fromshmem(card,
				 skb_put(skb, rcvmsg->msg_data.response.msg_len),
				 (char *)rcvmsg->msg_data.response.buff_offset,
				 rcvmsg->msg_data.response.msg_len);
		sc_adapter[card]->card->rcvcallb_skb(sc_adapter[card]->driverId,
						     rcvmsg->phy_link_no - 1, skb);

	case 0x03:
		/*
		 * Recycle the buffer
		 */
		pr_debug("%s: buffer size : %d\n",
			 sc_adapter[card]->devicename, BUFFER_SIZE);
/*		memset_shmem(card, rcvmsg->msg_data.response.buff_offset, 0, BUFFER_SIZE); */
		newll.buff_offset = rcvmsg->msg_data.response.buff_offset;
		newll.msg_len = BUFFER_SIZE;
		pr_debug("%s: recycled buffer at offset 0x%lx size %d\n",
			 sc_adapter[card]->devicename,
			 newll.buff_offset, newll.msg_len);
		sendmessage(card, CEPID, ceReqTypeLnk, ceReqClass1, ceReqLnkRead,
			    rcvmsg->phy_link_no, sizeof(LLData), (unsigned int *)&newll);
	}

}

int setup_buffers(int card, int c)
{
	unsigned int nBuffers, i, cBase;
	unsigned int buffer_size;
	LLData	RcvBuffOffset;

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

	/*
	 * Calculate the buffer offsets (send/recv/send/recv)
	 */
	pr_debug("%s: setting up channel buffer space in shared RAM\n",
		 sc_adapter[card]->devicename);
	buffer_size = BUFFER_SIZE;
	nBuffers = ((sc_adapter[card]->ramsize - BUFFER_BASE) / buffer_size) / 2;
	nBuffers = nBuffers > BUFFERS_MAX ? BUFFERS_MAX : nBuffers;
	pr_debug("%s: calculating buffer space: %d buffers, %d big\n",
		 sc_adapter[card]->devicename,
		 nBuffers, buffer_size);
	if (nBuffers < 2) {
		pr_debug("%s: not enough buffer space\n",
			 sc_adapter[card]->devicename);
		return -1;
	}
	cBase = (nBuffers * buffer_size) * (c - 1);
	pr_debug("%s: channel buffer offset from shared RAM: 0x%x\n",
		 sc_adapter[card]->devicename, cBase);
	sc_adapter[card]->channel[c - 1].first_sendbuf = BUFFER_BASE + cBase;
	sc_adapter[card]->channel[c - 1].num_sendbufs = nBuffers / 2;
	sc_adapter[card]->channel[c - 1].free_sendbufs = nBuffers / 2;
	sc_adapter[card]->channel[c - 1].next_sendbuf = 0;
	pr_debug("%s: send buffer setup complete: first=0x%lx n=%d f=%d, nxt=%d\n",
		 sc_adapter[card]->devicename,
		 sc_adapter[card]->channel[c - 1].first_sendbuf,
		 sc_adapter[card]->channel[c - 1].num_sendbufs,
		 sc_adapter[card]->channel[c - 1].free_sendbufs,
		 sc_adapter[card]->channel[c - 1].next_sendbuf);

	/*
	 * Prep the receive buffers
	 */
	pr_debug("%s: adding %d RecvBuffers:\n",
		 sc_adapter[card]->devicename, nBuffers / 2);
	for (i = 0; i < nBuffers / 2; i++) {
		RcvBuffOffset.buff_offset =
			((sc_adapter[card]->channel[c - 1].first_sendbuf +
			  (nBuffers / 2) * buffer_size) + (buffer_size * i));
		RcvBuffOffset.msg_len = buffer_size;
		pr_debug("%s: adding RcvBuffer #%d offset=0x%lx sz=%d bufsz:%d\n",
			 sc_adapter[card]->devicename,
			 i + 1, RcvBuffOffset.buff_offset,
			 RcvBuffOffset.msg_len, buffer_size);
		sendmessage(card, CEPID, ceReqTypeLnk, ceReqClass1, ceReqLnkRead,
			    c, sizeof(LLData), (unsigned int *)&RcvBuffOffset);
	}
	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/* $Id: packet.c,v 1.5.8.1 2001/09/23 22:24:59 kai Exp $
	2	*
	3	* Copyright (C) 1996 SpellCaster Telecommunications Inc.
	4	*
	5	* This software may be used and distributed according to the terms
	6	* of the GNU General Public License, incorporated herein by reference.
	7	*
	8	* For more information, please contact gpl-info@spellcast.com or write:
	9	*
	10	* SpellCaster Telecommunications Inc.
	11	* 5621 Finch Avenue East, Unit #3
	12	* Scarborough, Ontario Canada
	13	* M1B 2T9
	14	* +1 (416) 297-8565
	15	* +1 (416) 297-6433 Facsimile
	16	*/
	17
	18	#include "includes.h"
	19	#include "hardware.h"
	20	#include "message.h"
	21	#include "card.h"
	22
186fd777	23	int sndpkt(int devId, int channel, int ack, struct sk_buff *data)
1da177e4 LT	24	{
	25	LLData ReqLnkWrite;
	26	int status;
	27	int card;
	28	unsigned long len;
	29
	30	card = get_card_from_id(devId);
	31
475be4d8	32	if (!IS_VALID_CARD(card)) {
1da177e4 LT	33	pr_debug("invalid param: %d is not a valid card id\n", card);
	34	return -ENODEV;
	35	}
	36
76fd0209	37	pr_debug("%s: sndpkt: frst = 0x%lx nxt = %d f = %d n = %d\n",
475be4d8 JP	38	sc_adapter[card]->devicename,
	39	sc_adapter[card]->channel[channel].first_sendbuf,
	40	sc_adapter[card]->channel[channel].next_sendbuf,
	41	sc_adapter[card]->channel[channel].free_sendbufs,
	42	sc_adapter[card]->channel[channel].num_sendbufs);
1da177e4	43
475be4d8	44	if (!sc_adapter[card]->channel[channel].free_sendbufs) {
1da177e4	45	pr_debug("%s: out of TX buffers\n",
475be4d8	46	sc_adapter[card]->devicename);
1da177e4 LT	47	return -EINVAL;
	48	}
	49
475be4d8	50	if (data->len > BUFFER_SIZE) {
1da177e4	51	pr_debug("%s: data overflows buffer size (data > buffer)\n",
475be4d8	52	sc_adapter[card]->devicename);
1da177e4 LT	53	return -EINVAL;
	54	}
	55
	56	ReqLnkWrite.buff_offset = sc_adapter[card]->channel[channel].next_sendbuf *
	57	BUFFER_SIZE + sc_adapter[card]->channel[channel].first_sendbuf;
	58	ReqLnkWrite.msg_len = data->len; /* sk_buff size */
76fd0209	59	pr_debug("%s: writing %d bytes to buffer offset 0x%lx\n",
475be4d8 JP	60	sc_adapter[card]->devicename,
475be4d8 JP	61	ReqLnkWrite.msg_len, ReqLnkWrite.buff_offset);
1da177e4 LT	62	memcpy_toshmem(card, (char *)ReqLnkWrite.buff_offset, data->data, ReqLnkWrite.msg_len);
	63
	64	/*
	65	* sendmessage
	66	*/
76fd0209	67	pr_debug("%s: sndpkt size=%d, buf_offset=0x%lx buf_indx=%d\n",
475be4d8 JP	68	sc_adapter[card]->devicename,
	69	ReqLnkWrite.msg_len, ReqLnkWrite.buff_offset,
	70	sc_adapter[card]->channel[channel].next_sendbuf);
1da177e4 LT	71
1da177e4 LT	72	status = sendmessage(card, CEPID, ceReqTypeLnk, ceReqClass1, ceReqLnkWrite,
475be4d8	73	channel + 1, sizeof(LLData), (unsigned int *)&ReqLnkWrite);
1da177e4	74	len = data->len;
475be4d8	75	if (status) {
1da177e4	76	pr_debug("%s: failed to send packet, status = %d\n",
475be4d8	77	sc_adapter[card]->devicename, status);
1da177e4 LT	78	return -1;
	79	}
	80	else {
	81	sc_adapter[card]->channel[channel].free_sendbufs--;
	82	sc_adapter[card]->channel[channel].next_sendbuf =
	83	++sc_adapter[card]->channel[channel].next_sendbuf ==
	84	sc_adapter[card]->channel[channel].num_sendbufs ? 0 :
	85	sc_adapter[card]->channel[channel].next_sendbuf;
475be4d8	86	pr_debug("%s: packet sent successfully\n", sc_adapter[card]->devicename);
1da177e4	87	dev_kfree_skb(data);
475be4d8	88	indicate_status(card, ISDN_STAT_BSENT, channel, (char *)&len);
1da177e4 LT	89	}
	90	return len;
	91	}
	92
	93	void rcvpkt(int card, RspMessage *rcvmsg)
	94	{
	95	LLData newll;
	96	struct sk_buff *skb;
	97
475be4d8	98	if (!IS_VALID_CARD(card)) {
1da177e4 LT	99	pr_debug("invalid param: %d is not a valid card id\n", card);
	100	return;
	101	}
	102
475be4d8	103	switch (rcvmsg->rsp_status) {
1da177e4 LT	104	case 0x01:
	105	case 0x02:
	106	case 0x70:
	107	pr_debug("%s: error status code: 0x%x\n",
475be4d8	108	sc_adapter[card]->devicename, rcvmsg->rsp_status);
1da177e4	109	return;
475be4d8 JP	110	case 0x00:
475be4d8 JP	111	if (!(skb = dev_alloc_skb(rcvmsg->msg_data.response.msg_len))) {
1da177e4	112	printk(KERN_WARNING "%s: rcvpkt out of memory, dropping packet\n",
475be4d8	113	sc_adapter[card]->devicename);
1da177e4 LT	114	return;
	115	}
	116	skb_put(skb, rcvmsg->msg_data.response.msg_len);
76fd0209	117	pr_debug("%s: getting data from offset: 0x%lx\n",
475be4d8 JP	118	sc_adapter[card]->devicename,
475be4d8 JP	119	rcvmsg->msg_data.response.buff_offset);
1da177e4	120	memcpy_fromshmem(card,
475be4d8 JP	121	skb_put(skb, rcvmsg->msg_data.response.msg_len),
	122	(char *)rcvmsg->msg_data.response.buff_offset,
	123	rcvmsg->msg_data.response.msg_len);
1da177e4	124	sc_adapter[card]->card->rcvcallb_skb(sc_adapter[card]->driverId,
475be4d8	125	rcvmsg->phy_link_no - 1, skb);
1da177e4 LT	126
	127	case 0x03:
	128	/*
475be4d8 JP	129	* Recycle the buffer
475be4d8 JP	130	*/
1da177e4	131	pr_debug("%s: buffer size : %d\n",
475be4d8	132	sc_adapter[card]->devicename, BUFFER_SIZE);
1da177e4 LT	133	/* memset_shmem(card, rcvmsg->msg_data.response.buff_offset, 0, BUFFER_SIZE); */
	134	newll.buff_offset = rcvmsg->msg_data.response.buff_offset;
	135	newll.msg_len = BUFFER_SIZE;
76fd0209	136	pr_debug("%s: recycled buffer at offset 0x%lx size %d\n",
475be4d8 JP	137	sc_adapter[card]->devicename,
475be4d8 JP	138	newll.buff_offset, newll.msg_len);
1da177e4	139	sendmessage(card, CEPID, ceReqTypeLnk, ceReqClass1, ceReqLnkRead,
475be4d8	140	rcvmsg->phy_link_no, sizeof(LLData), (unsigned int *)&newll);
1da177e4 LT	141	}
	142
	143	}
	144
	145	int setup_buffers(int card, int c)
	146	{
	147	unsigned int nBuffers, i, cBase;
	148	unsigned int buffer_size;
	149	LLData RcvBuffOffset;
	150
475be4d8	151	if (!IS_VALID_CARD(card)) {
1da177e4 LT	152	pr_debug("invalid param: %d is not a valid card id\n", card);
	153	return -ENODEV;
	154	}
	155
	156	/*
	157	* Calculate the buffer offsets (send/recv/send/recv)
	158	*/
	159	pr_debug("%s: setting up channel buffer space in shared RAM\n",
475be4d8	160	sc_adapter[card]->devicename);
1da177e4 LT	161	buffer_size = BUFFER_SIZE;
	162	nBuffers = ((sc_adapter[card]->ramsize - BUFFER_BASE) / buffer_size) / 2;
	163	nBuffers = nBuffers > BUFFERS_MAX ? BUFFERS_MAX : nBuffers;
	164	pr_debug("%s: calculating buffer space: %d buffers, %d big\n",
475be4d8 JP	165	sc_adapter[card]->devicename,
	166	nBuffers, buffer_size);
	167	if (nBuffers < 2) {
1da177e4	168	pr_debug("%s: not enough buffer space\n",
475be4d8	169	sc_adapter[card]->devicename);
1da177e4 LT	170	return -1;
	171	}
	172	cBase = (nBuffers * buffer_size) * (c - 1);
	173	pr_debug("%s: channel buffer offset from shared RAM: 0x%x\n",
475be4d8 JP	174	sc_adapter[card]->devicename, cBase);
	175	sc_adapter[card]->channel[c - 1].first_sendbuf = BUFFER_BASE + cBase;
	176	sc_adapter[card]->channel[c - 1].num_sendbufs = nBuffers / 2;
	177	sc_adapter[card]->channel[c - 1].free_sendbufs = nBuffers / 2;
	178	sc_adapter[card]->channel[c - 1].next_sendbuf = 0;
76fd0209	179	pr_debug("%s: send buffer setup complete: first=0x%lx n=%d f=%d, nxt=%d\n",
475be4d8 JP	180	sc_adapter[card]->devicename,
	181	sc_adapter[card]->channel[c - 1].first_sendbuf,
	182	sc_adapter[card]->channel[c - 1].num_sendbufs,
	183	sc_adapter[card]->channel[c - 1].free_sendbufs,
	184	sc_adapter[card]->channel[c - 1].next_sendbuf);
1da177e4 LT	185
	186	/*
	187	* Prep the receive buffers
	188	*/
	189	pr_debug("%s: adding %d RecvBuffers:\n",
475be4d8 JP	190	sc_adapter[card]->devicename, nBuffers / 2);
	191	for (i = 0; i < nBuffers / 2; i++) {
	192	RcvBuffOffset.buff_offset =
	193	((sc_adapter[card]->channel[c - 1].first_sendbuf +
	194	(nBuffers / 2) * buffer_size) + (buffer_size * i));
1da177e4	195	RcvBuffOffset.msg_len = buffer_size;
76fd0209	196	pr_debug("%s: adding RcvBuffer #%d offset=0x%lx sz=%d bufsz:%d\n",
475be4d8 JP	197	sc_adapter[card]->devicename,
	198	i + 1, RcvBuffOffset.buff_offset,
	199	RcvBuffOffset.msg_len, buffer_size);
1da177e4	200	sendmessage(card, CEPID, ceReqTypeLnk, ceReqClass1, ceReqLnkRead,
475be4d8 JP	201	c, sizeof(LLData), (unsigned int *)&RcvBuffOffset);
475be4d8 JP	202	}
1da177e4 LT	203	return 0;
1da177e4 LT	204	}