[deliverable/linux.git] / drivers / staging / i4l / pcbit / capi.c

/*
 * CAPI encoder/decoder for
 * Portugal Telecom CAPI 2.0
 *
 * Copyright (C) 1996 Universidade de Lisboa
 *
 * Written by Pedro Roque Marques (roque@di.fc.ul.pt)
 *
 * This software may be used and distributed according to the terms of
 * the GNU General Public License, incorporated herein by reference.
 *
 * Not compatible with the AVM Gmbh. CAPI 2.0
 *
 */

/*
 *        Documentation:
 *        - "Common ISDN API - Perfil Português - Versão 2.1",
 *           Telecom Portugal, Fev 1992.
 *        - "Common ISDN API - Especificação de protocolos para
 *           acesso aos canais B", Inesc, Jan 1994.
 */

/*
 *        TODO: better decoding of Information Elements
 *              for debug purposes mainly
 *              encode our number in CallerPN and ConnectedPN
 */

#include <linux/string.h>
#include <linux/kernel.h>

#include <linux/types.h>
#include <linux/slab.h>
#include <linux/mm.h>

#include <linux/skbuff.h>

#include <asm/io.h>
#include <asm/string.h>

#include <linux/isdnif.h>

#include "pcbit.h"
#include "edss1.h"
#include "capi.h"


/*
 *  Encoding of CAPI messages
 *
 */

int capi_conn_req(const char *calledPN, struct sk_buff **skb, int proto)
{
	ushort len;

	/*
	 * length
	 *   AppInfoMask - 2
	 *   BC0         - 3
	 *   BC1         - 1
	 *   Chan        - 2
	 *   Keypad      - 1
	 *   CPN         - 1
	 *   CPSA        - 1
	 *   CalledPN    - 2 + strlen
	 *   CalledPSA   - 1
	 *   rest...     - 4
	 *   ----------------
	 *   Total        18 + strlen
	 */

	len = 18 + strlen(calledPN);

	if (proto == ISDN_PROTO_L2_TRANS)
		len++;

	if ((*skb = dev_alloc_skb(len)) == NULL) {

		printk(KERN_WARNING "capi_conn_req: alloc_skb failed\n");
		return -1;
	}

	/* InfoElmMask */
	*((ushort *)skb_put(*skb, 2)) = AppInfoMask;

	if (proto == ISDN_PROTO_L2_TRANS)
	{
		/* Bearer Capability - Mandatory*/
		*(skb_put(*skb, 1)) = 3;        /* BC0.Length		*/
		*(skb_put(*skb, 1)) = 0x80;     /* Speech		*/
		*(skb_put(*skb, 1)) = 0x10;     /* Circuit Mode		*/
		*(skb_put(*skb, 1)) = 0x23;     /* A-law		*/
	} else {
		/* Bearer Capability - Mandatory*/
		*(skb_put(*skb, 1)) = 2;        /* BC0.Length		*/
		*(skb_put(*skb, 1)) = 0x88;     /* Digital Information	*/
		*(skb_put(*skb, 1)) = 0x90;     /* BC0.Octect4		*/
	}

	/* Bearer Capability - Optional*/
	*(skb_put(*skb, 1)) = 0;        /* BC1.Length = 0                    */

	*(skb_put(*skb, 1)) = 1;        /* ChannelID.Length = 1              */
	*(skb_put(*skb, 1)) = 0x83;     /* Basic Interface - Any Channel     */

	*(skb_put(*skb, 1)) = 0;        /* Keypad.Length = 0                 */


	*(skb_put(*skb, 1)) = 0;        /* CallingPN.Length = 0              */
	*(skb_put(*skb, 1)) = 0;        /* CallingPSA.Length = 0             */

	/* Called Party Number */
	*(skb_put(*skb, 1)) = strlen(calledPN) + 1;
	*(skb_put(*skb, 1)) = 0x81;
	memcpy(skb_put(*skb, strlen(calledPN)), calledPN, strlen(calledPN));

	/* '#' */

	*(skb_put(*skb, 1)) = 0;       /* CalledPSA.Length = 0     */

	/* LLC.Length  = 0; */
	/* HLC0.Length = 0; */
	/* HLC1.Length = 0; */
	/* UTUS.Length = 0; */
	memset(skb_put(*skb, 4), 0, 4);

	return len;
}

int capi_conn_resp(struct pcbit_chan *chan, struct sk_buff **skb)
{

	if ((*skb = dev_alloc_skb(5)) == NULL) {

		printk(KERN_WARNING "capi_conn_resp: alloc_skb failed\n");
		return -1;
	}

	*((ushort *)skb_put(*skb, 2)) = chan->callref;
	*(skb_put(*skb, 1)) = 0x01;  /* ACCEPT_CALL */
	*(skb_put(*skb, 1)) = 0;
	*(skb_put(*skb, 1)) = 0;

	return 5;
}

int capi_conn_active_req(struct pcbit_chan *chan, struct sk_buff **skb)
{
	/*
	 * 8 bytes
	 */

	if ((*skb = dev_alloc_skb(8)) == NULL) {

		printk(KERN_WARNING "capi_conn_active_req: alloc_skb failed\n");
		return -1;
	}

	*((ushort *)skb_put(*skb, 2)) = chan->callref;

#ifdef DEBUG
	printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
#endif

	*(skb_put(*skb, 1)) = 0;       /*  BC.Length = 0;          */
	*(skb_put(*skb, 1)) = 0;       /*  ConnectedPN.Length = 0  */
	*(skb_put(*skb, 1)) = 0;       /*  PSA.Length              */
	*(skb_put(*skb, 1)) = 0;       /*  LLC.Length = 0;         */
	*(skb_put(*skb, 1)) = 0;       /*  HLC.Length = 0;         */
	*(skb_put(*skb, 1)) = 0;       /*  UTUS.Length = 0;        */

	return 8;
}

int capi_conn_active_resp(struct pcbit_chan *chan, struct sk_buff **skb)
{
	/*
	 * 2 bytes
	 */

	if ((*skb = dev_alloc_skb(2)) == NULL) {

		printk(KERN_WARNING "capi_conn_active_resp: alloc_skb failed\n");
		return -1;
	}

	*((ushort *)skb_put(*skb, 2)) = chan->callref;

	return 2;
}


int capi_select_proto_req(struct pcbit_chan *chan, struct sk_buff **skb,
			  int outgoing)
{

	/*
	 * 18 bytes
	 */

	if ((*skb = dev_alloc_skb(18)) == NULL) {

		printk(KERN_WARNING "capi_select_proto_req: alloc_skb failed\n");
		return -1;
	}

	*((ushort *)skb_put(*skb, 2)) = chan->callref;

	/* Layer2 protocol */

	switch (chan->proto) {
	case ISDN_PROTO_L2_X75I:
		*(skb_put(*skb, 1)) = 0x05;            /* LAPB */
		break;
	case ISDN_PROTO_L2_HDLC:
		*(skb_put(*skb, 1)) = 0x02;
		break;
	case ISDN_PROTO_L2_TRANS:
		/*
		 *	Voice (a-law)
		 */
		*(skb_put(*skb, 1)) = 0x06;
		break;
	default:
#ifdef DEBUG
		printk(KERN_DEBUG "Transparent\n");
#endif
		*(skb_put(*skb, 1)) = 0x03;
		break;
	}

	*(skb_put(*skb, 1)) = (outgoing ? 0x02 : 0x42);    /* Don't ask */
	*(skb_put(*skb, 1)) = 0x00;

	*((ushort *) skb_put(*skb, 2)) = MRU;


	*(skb_put(*skb, 1)) = 0x08;           /* Modulo */
	*(skb_put(*skb, 1)) = 0x07;           /* Max Window */

	*(skb_put(*skb, 1)) = 0x01;           /* No Layer3 Protocol */

	/*
	 * 2 - layer3 MTU       [10]
	 *   - Modulo           [12]
	 *   - Window
	 *   - layer1 proto     [14]
	 *   - bitrate
	 *   - sub-channel      [16]
	 *   - layer1dataformat [17]
	 */

	memset(skb_put(*skb, 8), 0, 8);

	return 18;
}


int capi_activate_transp_req(struct pcbit_chan *chan, struct sk_buff **skb)
{

	if ((*skb = dev_alloc_skb(7)) == NULL) {

		printk(KERN_WARNING "capi_activate_transp_req: alloc_skb failed\n");
		return -1;
	}

	*((ushort *)skb_put(*skb, 2)) = chan->callref;


	*(skb_put(*skb, 1)) = chan->layer2link; /* Layer2 id */
	*(skb_put(*skb, 1)) = 0x00;             /* Transmit by default */

	*((ushort *) skb_put(*skb, 2)) = MRU;

	*(skb_put(*skb, 1)) = 0x01;             /* Enables reception*/

	return 7;
}

int capi_tdata_req(struct pcbit_chan *chan, struct sk_buff *skb)
{
	ushort data_len;


	/*
	 * callref      - 2
	 * layer2link   - 1
	 * wBlockLength - 2
	 * data         - 4
	 * sernum       - 1
	 */

	data_len = skb->len;

	if (skb_headroom(skb) < 10)
	{
		printk(KERN_CRIT "No headspace (%u) on headroom %p for capi header\n", skb_headroom(skb), skb);
	}
	else
	{
		skb_push(skb, 10);
	}

	*((u16 *) (skb->data)) = chan->callref;
	skb->data[2] = chan->layer2link;
	*((u16 *) (skb->data + 3)) = data_len;

	chan->s_refnum = (chan->s_refnum + 1) % 8;
	*((u32 *) (skb->data + 5)) = chan->s_refnum;

	skb->data[9] = 0;                           /* HDLC frame number */

	return 10;
}

int capi_tdata_resp(struct pcbit_chan *chan, struct sk_buff **skb)

{
	if ((*skb = dev_alloc_skb(4)) == NULL) {

		printk(KERN_WARNING "capi_tdata_resp: alloc_skb failed\n");
		return -1;
	}

	*((ushort *)skb_put(*skb, 2)) = chan->callref;

	*(skb_put(*skb, 1)) = chan->layer2link;
	*(skb_put(*skb, 1)) = chan->r_refnum;

	return (*skb)->len;
}

int capi_disc_req(ushort callref, struct sk_buff **skb, u_char cause)
{

	if ((*skb = dev_alloc_skb(6)) == NULL) {

		printk(KERN_WARNING "capi_disc_req: alloc_skb failed\n");
		return -1;
	}

	*((ushort *)skb_put(*skb, 2)) = callref;

	*(skb_put(*skb, 1)) = 2;                  /* Cause.Length = 2; */
	*(skb_put(*skb, 1)) = 0x80;
	*(skb_put(*skb, 1)) = 0x80 | cause;

	/*
	 * Change it: we should send 'Sic transit gloria Mundi' here ;-)
	 */

	*(skb_put(*skb, 1)) = 0;                   /* UTUS.Length = 0;  */

	return 6;
}

int capi_disc_resp(struct pcbit_chan *chan, struct sk_buff **skb)
{
	if ((*skb = dev_alloc_skb(2)) == NULL) {

		printk(KERN_WARNING "capi_disc_resp: alloc_skb failed\n");
		return -1;
	}

	*((ushort *)skb_put(*skb, 2)) = chan->callref;

	return 2;
}


/*
 *  Decoding of CAPI messages
 *
 */

int capi_decode_conn_ind(struct pcbit_chan *chan,
			 struct sk_buff *skb,
			 struct callb_data *info)
{
	int CIlen, len;

	/* Call Reference [CAPI] */
	chan->callref = *((ushort *)skb->data);
	skb_pull(skb, 2);

#ifdef DEBUG
	printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
#endif

	/* Channel Identification */

	/* Expect
	   Len = 1
	   Octect 3 = 0100 10CC - [ 7 Basic, 4 , 2-1 chan ]
	*/

	CIlen = skb->data[0];
#ifdef DEBUG
	if (CIlen == 1) {

		if (((skb->data[1]) & 0xFC) == 0x48)
			printk(KERN_DEBUG "decode_conn_ind: chan ok\n");
		printk(KERN_DEBUG "phyChan = %d\n", skb->data[1] & 0x03);
	}
	else
		printk(KERN_DEBUG "conn_ind: CIlen = %d\n", CIlen);
#endif
	skb_pull(skb, CIlen + 1);

	/* Calling Party Number */
	/* An "additional service" as far as Portugal Telecom is concerned */

	len = skb->data[0];

	if (len > 0) {
		int count = 1;

#ifdef DEBUG
		printk(KERN_DEBUG "CPN: Octect 3 %02x\n", skb->data[1]);
#endif
		if ((skb->data[1] & 0x80) == 0)
			count = 2;

		if (!(info->data.setup.CallingPN = kmalloc(len - count + 1, GFP_ATOMIC)))
			return -1;

		skb_copy_from_linear_data_offset(skb, count + 1,
						 info->data.setup.CallingPN,
						 len - count);
		info->data.setup.CallingPN[len - count] = 0;

	}
	else {
		info->data.setup.CallingPN = NULL;
		printk(KERN_DEBUG "NULL CallingPN\n");
	}

	skb_pull(skb, len + 1);

	/* Calling Party Subaddress */
	skb_pull(skb, skb->data[0] + 1);

	/* Called Party Number */

	len = skb->data[0];

	if (len > 0) {
		int count = 1;

		if ((skb->data[1] & 0x80) == 0)
			count = 2;

		if (!(info->data.setup.CalledPN = kmalloc(len - count + 1, GFP_ATOMIC)))
			return -1;

		skb_copy_from_linear_data_offset(skb, count + 1,
						 info->data.setup.CalledPN,
						 len - count);
		info->data.setup.CalledPN[len - count] = 0;

	}
	else {
		info->data.setup.CalledPN = NULL;
		printk(KERN_DEBUG "NULL CalledPN\n");
	}

	skb_pull(skb, len + 1);

	/* Called Party Subaddress */
	skb_pull(skb, skb->data[0] + 1);

	/* LLC */
	skb_pull(skb, skb->data[0] + 1);

	/* HLC */
	skb_pull(skb, skb->data[0] + 1);

	/* U2U */
	skb_pull(skb, skb->data[0] + 1);

	return 0;
}

/*
 *  returns errcode
 */

int capi_decode_conn_conf(struct pcbit_chan *chan, struct sk_buff *skb,
			  int *complete)
{
	int errcode;

	chan->callref = *((ushort *)skb->data);     /* Update CallReference */
	skb_pull(skb, 2);

	errcode = *((ushort *) skb->data);   /* read errcode */
	skb_pull(skb, 2);

	*complete = *(skb->data);
	skb_pull(skb, 1);

	/* FIX ME */
	/* This is actually a firmware bug */
	if (!*complete)
	{
		printk(KERN_DEBUG "complete=%02x\n", *complete);
		*complete = 1;
	}


	/* Optional Bearer Capability */
	skb_pull(skb, *(skb->data) + 1);

	/* Channel Identification */
	skb_pull(skb, *(skb->data) + 1);

	/* High Layer Compatibility follows */
	skb_pull(skb, *(skb->data) + 1);

	return errcode;
}

int capi_decode_conn_actv_ind(struct pcbit_chan *chan, struct sk_buff *skb)
{
	ushort len;
#ifdef DEBUG
	char str[32];
#endif

	/* Yet Another Bearer Capability */
	skb_pull(skb, *(skb->data) + 1);


	/* Connected Party Number */
	len = *(skb->data);

#ifdef DEBUG
	if (len > 1 && len < 31) {
		skb_copy_from_linear_data_offset(skb, 2, str, len - 1);
		str[len] = 0;
		printk(KERN_DEBUG "Connected Party Number: %s\n", str);
	}
	else
		printk(KERN_DEBUG "actv_ind CPN len = %d\n", len);
#endif

	skb_pull(skb, len + 1);

	/* Connected Subaddress */
	skb_pull(skb, *(skb->data) + 1);

	/* Low Layer Capability */
	skb_pull(skb, *(skb->data) + 1);

	/* High Layer Capability */
	skb_pull(skb, *(skb->data) + 1);

	return 0;
}

int capi_decode_conn_actv_conf(struct pcbit_chan *chan, struct sk_buff *skb)
{
	ushort errcode;

	errcode = *((ushort *)skb->data);
	skb_pull(skb, 2);

	/* Channel Identification
	   skb_pull(skb, skb->data[0] + 1);
	*/
	return errcode;
}


int capi_decode_sel_proto_conf(struct pcbit_chan *chan, struct sk_buff *skb)
{
	ushort errcode;

	chan->layer2link = *(skb->data);
	skb_pull(skb, 1);

	errcode = *((ushort *)skb->data);
	skb_pull(skb, 2);

	return errcode;
}

int capi_decode_actv_trans_conf(struct pcbit_chan *chan, struct sk_buff *skb)
{
	ushort errcode;

	if (chan->layer2link != *(skb->data))
		printk("capi_decode_actv_trans_conf: layer2link doesn't match\n");

	skb_pull(skb, 1);

	errcode = *((ushort *)skb->data);
	skb_pull(skb, 2);

	return errcode;
}

int capi_decode_disc_ind(struct pcbit_chan *chan, struct sk_buff *skb)
{
	ushort len;
#ifdef DEBUG
	int i;
#endif
	/* Cause */

	len = *(skb->data);
	skb_pull(skb, 1);

#ifdef DEBUG

	for (i = 0; i < len; i++)
		printk(KERN_DEBUG "Cause Octect %d: %02x\n", i + 3,
		       *(skb->data + i));
#endif

	skb_pull(skb, len);

	return 0;
}

#ifdef DEBUG
int capi_decode_debug_188(u_char *hdr, ushort hdrlen)
{
	char str[64];
	int len;

	len = hdr[0];

	if (len < 64 && len == hdrlen - 1) {
		memcpy(str, hdr + 1, hdrlen - 1);
		str[hdrlen - 1] = 0;
		printk("%s\n", str);
	}
	else
		printk("debug message incorrect\n");

	return 0;
}
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* CAPI encoder/decoder for
	3	* Portugal Telecom CAPI 2.0
	4	*
	5	* Copyright (C) 1996 Universidade de Lisboa
475be4d8	6	*
1da177e4 LT	7	* Written by Pedro Roque Marques (roque@di.fc.ul.pt)
1da177e4 LT	8	*
475be4d8	9	* This software may be used and distributed according to the terms of
1da177e4 LT	10	* the GNU General Public License, incorporated herein by reference.
	11	*
	12	* Not compatible with the AVM Gmbh. CAPI 2.0
	13	*
	14	*/
	15
	16	/*
	17	* Documentation:
96de0e25	18	* - "Common ISDN API - Perfil Português - Versão 2.1",
1da177e4	19	* Telecom Portugal, Fev 1992.
96de0e25	20	* - "Common ISDN API - Especificação de protocolos para
1da177e4 LT	21	* acesso aos canais B", Inesc, Jan 1994.
	22	*/
	23
	24	/*
	25	* TODO: better decoding of Information Elements
	26	* for debug purposes mainly
	27	* encode our number in CallerPN and ConnectedPN
	28	*/
	29
1da177e4 LT	30	#include <linux/string.h>
	31	#include <linux/kernel.h>
	32
	33	#include <linux/types.h>
	34	#include <linux/slab.h>
	35	#include <linux/mm.h>
	36
	37	#include <linux/skbuff.h>
	38
	39	#include <asm/io.h>
	40	#include <asm/string.h>
	41
	42	#include <linux/isdnif.h>
	43
	44	#include "pcbit.h"
	45	#include "edss1.h"
	46	#include "capi.h"
	47
	48
	49	/*
	50	* Encoding of CAPI messages
	51	*
	52	*/
	53
475be4d8	54	int capi_conn_req(const char calledPN, struct sk_buff *skb, int proto)
1da177e4	55	{
475be4d8 JP	56	ushort len;
	57
	58	/*
	59	* length
	60	* AppInfoMask - 2
	61	* BC0 - 3
	62	* BC1 - 1
	63	* Chan - 2
	64	* Keypad - 1
	65	* CPN - 1
	66	* CPSA - 1
	67	* CalledPN - 2 + strlen
	68	* CalledPSA - 1
	69	* rest... - 4
	70	* ----------------
	71	* Total 18 + strlen
	72	*/
	73
	74	len = 18 + strlen(calledPN);
1da177e4 LT	75
	76	if (proto == ISDN_PROTO_L2_TRANS)
	77	len++;
	78
	79	if ((*skb = dev_alloc_skb(len)) == NULL) {
475be4d8 JP	80
475be4d8 JP	81	printk(KERN_WARNING "capi_conn_req: alloc_skb failed\n");
1da177e4 LT	82	return -1;
	83	}
	84
475be4d8 JP	85	/* InfoElmMask */
475be4d8 JP	86	((ushort )skb_put(*skb, 2)) = AppInfoMask;
1da177e4 LT	87
	88	if (proto == ISDN_PROTO_L2_TRANS)
	89	{
	90	/* Bearer Capability - Mandatory*/
	91	(skb_put(skb, 1)) = 3; /* BC0.Length */
	92	(skb_put(skb, 1)) = 0x80; /* Speech */
	93	(skb_put(skb, 1)) = 0x10; /* Circuit Mode */
	94	(skb_put(skb, 1)) = 0x23; /* A-law */
aec8755d	95	} else {
1da177e4 LT	96	/* Bearer Capability - Mandatory*/
	97	(skb_put(skb, 1)) = 2; /* BC0.Length */
	98	(skb_put(skb, 1)) = 0x88; /* Digital Information */
	99	(skb_put(skb, 1)) = 0x90; /* BC0.Octect4 */
	100	}
	101
475be4d8 JP	102	/* Bearer Capability - Optional*/
475be4d8 JP	103	(skb_put(skb, 1)) = 0; /* BC1.Length = 0 */
1da177e4	104
475be4d8 JP	105	(skb_put(skb, 1)) = 1; /* ChannelID.Length = 1 */
475be4d8 JP	106	(skb_put(skb, 1)) = 0x83; /* Basic Interface - Any Channel */
1da177e4	107
475be4d8	108	(skb_put(skb, 1)) = 0; /* Keypad.Length = 0 */
1da177e4	109
1da177e4	110
475be4d8 JP	111	(skb_put(skb, 1)) = 0; /* CallingPN.Length = 0 */
475be4d8 JP	112	(skb_put(skb, 1)) = 0; /* CallingPSA.Length = 0 */
1da177e4	113
475be4d8 JP	114	/* Called Party Number */
	115	(skb_put(skb, 1)) = strlen(calledPN) + 1;
	116	(skb_put(skb, 1)) = 0x81;
	117	memcpy(skb_put(*skb, strlen(calledPN)), calledPN, strlen(calledPN));
1da177e4	118
475be4d8	119	/* '#' */
1da177e4	120
475be4d8	121	(skb_put(skb, 1)) = 0; /* CalledPSA.Length = 0 */
1da177e4	122
475be4d8 JP	123	/* LLC.Length = 0; */
	124	/* HLC0.Length = 0; */
	125	/* HLC1.Length = 0; */
	126	/* UTUS.Length = 0; */
	127	memset(skb_put(*skb, 4), 0, 4);
	128
	129	return len;
1da177e4 LT	130	}
1da177e4 LT	131
475be4d8	132	int capi_conn_resp(struct pcbit_chan chan, struct sk_buff *skb)
1da177e4	133	{
475be4d8	134
1da177e4	135	if ((*skb = dev_alloc_skb(5)) == NULL) {
475be4d8	136
1da177e4 LT	137	printk(KERN_WARNING "capi_conn_resp: alloc_skb failed\n");
	138	return -1;
	139	}
	140
475be4d8 JP	141	((ushort )skb_put(*skb, 2)) = chan->callref;
	142	(skb_put(skb, 1)) = 0x01; /* ACCEPT_CALL */
	143	(skb_put(skb, 1)) = 0;
	144	(skb_put(skb, 1)) = 0;
1da177e4	145
475be4d8	146	return 5;
1da177e4 LT	147	}
1da177e4 LT	148
475be4d8	149	int capi_conn_active_req(struct pcbit_chan chan, struct sk_buff *skb)
1da177e4	150	{
475be4d8 JP	151	/*
	152	* 8 bytes
	153	*/
	154
1da177e4	155	if ((*skb = dev_alloc_skb(8)) == NULL) {
475be4d8	156
1da177e4 LT	157	printk(KERN_WARNING "capi_conn_active_req: alloc_skb failed\n");
	158	return -1;
	159	}
	160
475be4d8	161	((ushort )skb_put(*skb, 2)) = chan->callref;
1da177e4 LT	162
1da177e4 LT	163	#ifdef DEBUG
475be4d8	164	printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
1da177e4 LT	165	#endif
1da177e4 LT	166
475be4d8 JP	167	(skb_put(skb, 1)) = 0; /* BC.Length = 0; */
	168	(skb_put(skb, 1)) = 0; /* ConnectedPN.Length = 0 */
	169	(skb_put(skb, 1)) = 0; /* PSA.Length */
	170	(skb_put(skb, 1)) = 0; /* LLC.Length = 0; */
	171	(skb_put(skb, 1)) = 0; /* HLC.Length = 0; */
	172	(skb_put(skb, 1)) = 0; /* UTUS.Length = 0; */
1da177e4 LT	173
	174	return 8;
	175	}
	176
475be4d8	177	int capi_conn_active_resp(struct pcbit_chan chan, struct sk_buff *skb)
1da177e4	178	{
475be4d8 JP	179	/*
	180	* 2 bytes
	181	*/
	182
1da177e4	183	if ((*skb = dev_alloc_skb(2)) == NULL) {
475be4d8	184
1da177e4 LT	185	printk(KERN_WARNING "capi_conn_active_resp: alloc_skb failed\n");
	186	return -1;
	187	}
	188
475be4d8	189	((ushort )skb_put(*skb, 2)) = chan->callref;
1da177e4	190
475be4d8	191	return 2;
1da177e4 LT	192	}
	193
	194
475be4d8 JP	195	int capi_select_proto_req(struct pcbit_chan chan, struct sk_buff *skb,
475be4d8 JP	196	int outgoing)
1da177e4 LT	197	{
1da177e4 LT	198
475be4d8 JP	199	/*
	200	* 18 bytes
	201	*/
1da177e4 LT	202
1da177e4 LT	203	if ((*skb = dev_alloc_skb(18)) == NULL) {
475be4d8	204
1da177e4 LT	205	printk(KERN_WARNING "capi_select_proto_req: alloc_skb failed\n");
	206	return -1;
	207	}
	208
475be4d8	209	((ushort )skb_put(*skb, 2)) = chan->callref;
1da177e4	210
475be4d8	211	/* Layer2 protocol */
1da177e4	212
475be4d8 JP	213	switch (chan->proto) {
	214	case ISDN_PROTO_L2_X75I:
	215	(skb_put(skb, 1)) = 0x05; /* LAPB */
	216	break;
	217	case ISDN_PROTO_L2_HDLC:
	218	(skb_put(skb, 1)) = 0x02;
	219	break;
1da177e4	220	case ISDN_PROTO_L2_TRANS:
475be4d8	221	/*
1da177e4 LT	222	* Voice (a-law)
	223	*/
	224	(skb_put(skb, 1)) = 0x06;
	225	break;
475be4d8 JP	226	default:
	227	#ifdef DEBUG
	228	printk(KERN_DEBUG "Transparent\n");
1da177e4	229	#endif
475be4d8 JP	230	(skb_put(skb, 1)) = 0x03;
	231	break;
	232	}
	233
	234	(skb_put(skb, 1)) = (outgoing ? 0x02 : 0x42); /* Don't ask */
	235	(skb_put(skb, 1)) = 0x00;
	236
	237	((ushort ) skb_put(*skb, 2)) = MRU;
	238
	239
	240	(skb_put(skb, 1)) = 0x08; /* Modulo */
	241	(skb_put(skb, 1)) = 0x07; /* Max Window */
	242
	243	(skb_put(skb, 1)) = 0x01; /* No Layer3 Protocol */
	244
	245	/*
	246	* 2 - layer3 MTU [10]
	247	* - Modulo [12]
	248	* - Window
	249	* - layer1 proto [14]
	250	* - bitrate
	251	* - sub-channel [16]
	252	* - layer1dataformat [17]
	253	*/
	254
	255	memset(skb_put(*skb, 8), 0, 8);
	256
	257	return 18;
1da177e4 LT	258	}
	259
	260
	261	int capi_activate_transp_req(struct pcbit_chan chan, struct sk_buff *skb)
	262	{
	263
	264	if ((*skb = dev_alloc_skb(7)) == NULL) {
475be4d8	265
1da177e4 LT	266	printk(KERN_WARNING "capi_activate_transp_req: alloc_skb failed\n");
	267	return -1;
	268	}
	269
475be4d8	270	((ushort )skb_put(*skb, 2)) = chan->callref;
1da177e4	271
1da177e4	272
475be4d8 JP	273	(skb_put(skb, 1)) = chan->layer2link; /* Layer2 id */
475be4d8 JP	274	(skb_put(skb, 1)) = 0x00; /* Transmit by default */
1da177e4	275
475be4d8	276	((ushort ) skb_put(*skb, 2)) = MRU;
1da177e4	277
475be4d8 JP	278	(skb_put(skb, 1)) = 0x01; /* Enables reception*/
	279
	280	return 7;
1da177e4 LT	281	}
1da177e4 LT	282
475be4d8	283	int capi_tdata_req(struct pcbit_chan chan, struct sk_buff skb)
1da177e4 LT	284	{
1da177e4 LT	285	ushort data_len;
1da177e4	286
475be4d8 JP	287
	288	/*
	289	* callref - 2
1da177e4	290	* layer2link - 1
475be4d8	291	* wBlockLength - 2
1da177e4 LT	292	* data - 4
	293	* sernum - 1
	294	*/
475be4d8	295
1da177e4 LT	296	data_len = skb->len;
1da177e4 LT	297
475be4d8	298	if (skb_headroom(skb) < 10)
1da177e4 LT	299	{
	300	printk(KERN_CRIT "No headspace (%u) on headroom %p for capi header\n", skb_headroom(skb), skb);
	301	}
	302	else
475be4d8	303	{
1da177e4 LT	304	skb_push(skb, 10);
	305	}
	306
	307	((u16 ) (skb->data)) = chan->callref;
	308	skb->data[2] = chan->layer2link;
	309	((u16 ) (skb->data + 3)) = data_len;
	310
	311	chan->s_refnum = (chan->s_refnum + 1) % 8;
	312	((u32 ) (skb->data + 5)) = chan->s_refnum;
	313
	314	skb->data[9] = 0; /* HDLC frame number */
	315
	316	return 10;
	317	}
	318
475be4d8 JP	319	int capi_tdata_resp(struct pcbit_chan chan, struct sk_buff *skb)
475be4d8 JP	320
1da177e4 LT	321	{
1da177e4 LT	322	if ((*skb = dev_alloc_skb(4)) == NULL) {
475be4d8	323
1da177e4 LT	324	printk(KERN_WARNING "capi_tdata_resp: alloc_skb failed\n");
	325	return -1;
	326	}
	327
475be4d8	328	((ushort )skb_put(*skb, 2)) = chan->callref;
1da177e4	329
475be4d8 JP	330	(skb_put(skb, 1)) = chan->layer2link;
475be4d8 JP	331	(skb_put(skb, 1)) = chan->r_refnum;
1da177e4	332
475be4d8	333	return (*skb)->len;
1da177e4 LT	334	}
	335
	336	int capi_disc_req(ushort callref, struct sk_buff **skb, u_char cause)
	337	{
	338
	339	if ((*skb = dev_alloc_skb(6)) == NULL) {
475be4d8	340
1da177e4 LT	341	printk(KERN_WARNING "capi_disc_req: alloc_skb failed\n");
	342	return -1;
	343	}
	344
475be4d8	345	((ushort )skb_put(*skb, 2)) = callref;
1da177e4	346
475be4d8 JP	347	(skb_put(skb, 1)) = 2; /* Cause.Length = 2; */
	348	(skb_put(skb, 1)) = 0x80;
	349	(skb_put(skb, 1)) = 0x80 \| cause;
1da177e4	350
475be4d8 JP	351	/*
	352	* Change it: we should send 'Sic transit gloria Mundi' here ;-)
	353	*/
1da177e4	354
475be4d8	355	(skb_put(skb, 1)) = 0; /* UTUS.Length = 0; */
1da177e4	356
475be4d8	357	return 6;
1da177e4 LT	358	}
	359
	360	int capi_disc_resp(struct pcbit_chan chan, struct sk_buff *skb)
	361	{
	362	if ((*skb = dev_alloc_skb(2)) == NULL) {
475be4d8	363
1da177e4 LT	364	printk(KERN_WARNING "capi_disc_resp: alloc_skb failed\n");
	365	return -1;
	366	}
	367
475be4d8	368	((ushort )skb_put(*skb, 2)) = chan->callref;
1da177e4	369
475be4d8	370	return 2;
1da177e4 LT	371	}
	372
	373
	374	/*
	375	* Decoding of CAPI messages
	376	*
	377	*/
	378
475be4d8 JP	379	int capi_decode_conn_ind(struct pcbit_chan *chan,
	380	struct sk_buff *skb,
	381	struct callb_data *info)
1da177e4	382	{
475be4d8	383	int CIlen, len;
1da177e4	384
475be4d8 JP	385	/* Call Reference [CAPI] */
	386	chan->callref = ((ushort )skb->data);
	387	skb_pull(skb, 2);
1da177e4 LT	388
1da177e4 LT	389	#ifdef DEBUG
475be4d8	390	printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
1da177e4 LT	391	#endif
1da177e4 LT	392
475be4d8	393	/* Channel Identification */
1da177e4	394
475be4d8 JP	395	/* Expect
	396	Len = 1
	397	Octect 3 = 0100 10CC - [ 7 Basic, 4 , 2-1 chan ]
	398	*/
1da177e4	399
475be4d8	400	CIlen = skb->data[0];
1da177e4	401	#ifdef DEBUG
475be4d8	402	if (CIlen == 1) {
1da177e4	403
475be4d8 JP	404	if (((skb->data[1]) & 0xFC) == 0x48)
	405	printk(KERN_DEBUG "decode_conn_ind: chan ok\n");
	406	printk(KERN_DEBUG "phyChan = %d\n", skb->data[1] & 0x03);
	407	}
1da177e4 LT	408	else
	409	printk(KERN_DEBUG "conn_ind: CIlen = %d\n", CIlen);
	410	#endif
475be4d8	411	skb_pull(skb, CIlen + 1);
1da177e4	412
475be4d8 JP	413	/* Calling Party Number */
475be4d8 JP	414	/* An "additional service" as far as Portugal Telecom is concerned */
1da177e4	415
475be4d8	416	len = skb->data[0];
1da177e4 LT	417
	418	if (len > 0) {
	419	int count = 1;
475be4d8	420
1da177e4 LT	421	#ifdef DEBUG
	422	printk(KERN_DEBUG "CPN: Octect 3 %02x\n", skb->data[1]);
	423	#endif
	424	if ((skb->data[1] & 0x80) == 0)
	425	count = 2;
475be4d8	426
1da177e4 LT	427	if (!(info->data.setup.CallingPN = kmalloc(len - count + 1, GFP_ATOMIC)))
1da177e4 LT	428	return -1;
475be4d8	429
d626f62b ACM	430	skb_copy_from_linear_data_offset(skb, count + 1,
	431	info->data.setup.CallingPN,
	432	len - count);
1da177e4 LT	433	info->data.setup.CallingPN[len - count] = 0;
	434
	435	}
	436	else {
	437	info->data.setup.CallingPN = NULL;
	438	printk(KERN_DEBUG "NULL CallingPN\n");
	439	}
	440
	441	skb_pull(skb, len + 1);
	442
475be4d8 JP	443	/* Calling Party Subaddress */
475be4d8 JP	444	skb_pull(skb, skb->data[0] + 1);
1da177e4	445
475be4d8	446	/* Called Party Number */
1da177e4	447
475be4d8	448	len = skb->data[0];
1da177e4 LT	449
	450	if (len > 0) {
	451	int count = 1;
475be4d8	452
1da177e4 LT	453	if ((skb->data[1] & 0x80) == 0)
1da177e4 LT	454	count = 2;
475be4d8	455
1da177e4 LT	456	if (!(info->data.setup.CalledPN = kmalloc(len - count + 1, GFP_ATOMIC)))
1da177e4 LT	457	return -1;
475be4d8	458
d626f62b ACM	459	skb_copy_from_linear_data_offset(skb, count + 1,
	460	info->data.setup.CalledPN,
	461	len - count);
1da177e4 LT	462	info->data.setup.CalledPN[len - count] = 0;
	463
	464	}
	465	else {
	466	info->data.setup.CalledPN = NULL;
	467	printk(KERN_DEBUG "NULL CalledPN\n");
	468	}
	469
	470	skb_pull(skb, len + 1);
	471
475be4d8 JP	472	/* Called Party Subaddress */
475be4d8 JP	473	skb_pull(skb, skb->data[0] + 1);
1da177e4	474
475be4d8 JP	475	/* LLC */
475be4d8 JP	476	skb_pull(skb, skb->data[0] + 1);
1da177e4	477
475be4d8 JP	478	/* HLC */
475be4d8 JP	479	skb_pull(skb, skb->data[0] + 1);
1da177e4	480
475be4d8 JP	481	/* U2U */
475be4d8 JP	482	skb_pull(skb, skb->data[0] + 1);
1da177e4	483
475be4d8	484	return 0;
1da177e4 LT	485	}
	486
	487	/*
	488	* returns errcode
	489	*/
	490
475be4d8 JP	491	int capi_decode_conn_conf(struct pcbit_chan chan, struct sk_buff skb,
475be4d8 JP	492	int *complete)
1da177e4	493	{
475be4d8 JP	494	int errcode;
	495
	496	chan->callref = ((ushort )skb->data); /* Update CallReference */
	497	skb_pull(skb, 2);
	498
	499	errcode = ((ushort ) skb->data); /* read errcode */
	500	skb_pull(skb, 2);
1da177e4	501
475be4d8 JP	502	complete = (skb->data);
475be4d8 JP	503	skb_pull(skb, 1);
1da177e4	504
475be4d8 JP	505	/* FIX ME */
	506	/* This is actually a firmware bug */
	507	if (!*complete)
	508	{
	509	printk(KERN_DEBUG "complete=%02x\n", *complete);
	510	*complete = 1;
	511	}
1da177e4	512
1da177e4	513
475be4d8 JP	514	/* Optional Bearer Capability */
475be4d8 JP	515	skb_pull(skb, *(skb->data) + 1);
1da177e4	516
475be4d8 JP	517	/* Channel Identification */
475be4d8 JP	518	skb_pull(skb, *(skb->data) + 1);
1da177e4	519
475be4d8 JP	520	/* High Layer Compatibility follows */
475be4d8 JP	521	skb_pull(skb, *(skb->data) + 1);
1da177e4	522
475be4d8	523	return errcode;
1da177e4 LT	524	}
1da177e4 LT	525
475be4d8	526	int capi_decode_conn_actv_ind(struct pcbit_chan chan, struct sk_buff skb)
1da177e4	527	{
475be4d8	528	ushort len;
1da177e4	529	#ifdef DEBUG
475be4d8	530	char str[32];
1da177e4 LT	531	#endif
1da177e4 LT	532
475be4d8 JP	533	/* Yet Another Bearer Capability */
475be4d8 JP	534	skb_pull(skb, *(skb->data) + 1);
1da177e4	535
475be4d8 JP	536
	537	/* Connected Party Number */
	538	len = *(skb->data);
1da177e4 LT	539
	540	#ifdef DEBUG
	541	if (len > 1 && len < 31) {
d626f62b	542	skb_copy_from_linear_data_offset(skb, 2, str, len - 1);
1da177e4 LT	543	str[len] = 0;
	544	printk(KERN_DEBUG "Connected Party Number: %s\n", str);
	545	}
	546	else
	547	printk(KERN_DEBUG "actv_ind CPN len = %d\n", len);
	548	#endif
	549
475be4d8	550	skb_pull(skb, len + 1);
1da177e4	551
475be4d8 JP	552	/* Connected Subaddress */
475be4d8 JP	553	skb_pull(skb, *(skb->data) + 1);
1da177e4	554
475be4d8 JP	555	/* Low Layer Capability */
475be4d8 JP	556	skb_pull(skb, *(skb->data) + 1);
1da177e4	557
475be4d8 JP	558	/* High Layer Capability */
475be4d8 JP	559	skb_pull(skb, *(skb->data) + 1);
1da177e4	560
475be4d8	561	return 0;
1da177e4 LT	562	}
1da177e4 LT	563
475be4d8	564	int capi_decode_conn_actv_conf(struct pcbit_chan chan, struct sk_buff skb)
1da177e4	565	{
475be4d8 JP	566	ushort errcode;
	567
	568	errcode = ((ushort )skb->data);
	569	skb_pull(skb, 2);
	570
	571	/* Channel Identification
	572	skb_pull(skb, skb->data[0] + 1);
	573	*/
	574	return errcode;
1da177e4 LT	575	}
	576
	577
	578	int capi_decode_sel_proto_conf(struct pcbit_chan chan, struct sk_buff skb)
	579	{
475be4d8	580	ushort errcode;
1da177e4	581
475be4d8 JP	582	chan->layer2link = *(skb->data);
475be4d8 JP	583	skb_pull(skb, 1);
1da177e4	584
475be4d8 JP	585	errcode = ((ushort )skb->data);
	586	skb_pull(skb, 2);
	587
	588	return errcode;
1da177e4 LT	589	}
	590
	591	int capi_decode_actv_trans_conf(struct pcbit_chan chan, struct sk_buff skb)
	592	{
475be4d8	593	ushort errcode;
1da177e4	594
475be4d8 JP	595	if (chan->layer2link != *(skb->data))
475be4d8 JP	596	printk("capi_decode_actv_trans_conf: layer2link doesn't match\n");
1da177e4	597
475be4d8	598	skb_pull(skb, 1);
1da177e4	599
475be4d8 JP	600	errcode = ((ushort )skb->data);
475be4d8 JP	601	skb_pull(skb, 2);
1da177e4	602
475be4d8	603	return errcode;
1da177e4 LT	604	}
	605
	606	int capi_decode_disc_ind(struct pcbit_chan chan, struct sk_buff skb)
	607	{
475be4d8	608	ushort len;
1da177e4	609	#ifdef DEBUG
475be4d8	610	int i;
1da177e4	611	#endif
475be4d8 JP	612	/* Cause */
	613
	614	len = *(skb->data);
	615	skb_pull(skb, 1);
1da177e4 LT	616
	617	#ifdef DEBUG
	618
475be4d8 JP	619	for (i = 0; i < len; i++)
	620	printk(KERN_DEBUG "Cause Octect %d: %02x\n", i + 3,
	621	*(skb->data + i));
1da177e4 LT	622	#endif
1da177e4 LT	623
475be4d8	624	skb_pull(skb, len);
1da177e4	625
475be4d8	626	return 0;
1da177e4 LT	627	}
1da177e4 LT	628
1da177e4 LT	629	#ifdef DEBUG
	630	int capi_decode_debug_188(u_char *hdr, ushort hdrlen)
	631	{
475be4d8 JP	632	char str[64];
475be4d8 JP	633	int len;
1da177e4	634
475be4d8	635	len = hdr[0];
1da177e4	636
475be4d8 JP	637	if (len < 64 && len == hdrlen - 1) {
	638	memcpy(str, hdr + 1, hdrlen - 1);
	639	str[hdrlen - 1] = 0;
	640	printk("%s\n", str);
	641	}
	642	else
	643	printk("debug message incorrect\n");
1da177e4	644
475be4d8 JP	645	return 0;
	646	}
	647	#endif