forked from Minki/linux
cd354f1ae7
After Al Viro (finally) succeeded in removing the sched.h #include in module.h recently, it makes sense again to remove other superfluous sched.h includes. There are quite a lot of files which include it but don't actually need anything defined in there. Presumably these includes were once needed for macros that used to live in sched.h, but moved to other header files in the course of cleaning it up. To ease the pain, this time I did not fiddle with any header files and only removed #includes from .c-files, which tend to cause less trouble. Compile tested against 2.6.20-rc2 and 2.6.20-rc2-mm2 (with offsets) on alpha, arm, i386, ia64, mips, powerpc, and x86_64 with allnoconfig, defconfig, allmodconfig, and allyesconfig as well as a few randconfigs on x86_64 and all configs in arch/arm/configs on arm. I also checked that no new warnings were introduced by the patch (actually, some warnings are removed that were emitted by unnecessarily included header files). Signed-off-by: Tim Schmielau <tim@physik3.uni-rostock.de> Acked-by: Russell King <rmk+kernel@arm.linux.org.uk> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
369 lines
9.9 KiB
C
369 lines
9.9 KiB
C
/*********************************************************************
|
|
*
|
|
* Filename: ircomm_ttp.c
|
|
* Version: 1.0
|
|
* Description: Interface between IrCOMM and IrTTP
|
|
* Status: Stable
|
|
* Author: Dag Brattli <dagb@cs.uit.no>
|
|
* Created at: Sun Jun 6 20:48:27 1999
|
|
* Modified at: Mon Dec 13 11:35:13 1999
|
|
* Modified by: Dag Brattli <dagb@cs.uit.no>
|
|
*
|
|
* Copyright (c) 1999 Dag Brattli, All Rights Reserved.
|
|
* Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
********************************************************************/
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <net/irda/irda.h>
|
|
#include <net/irda/irlmp.h>
|
|
#include <net/irda/iriap.h>
|
|
#include <net/irda/irttp.h>
|
|
|
|
#include <net/irda/ircomm_event.h>
|
|
#include <net/irda/ircomm_ttp.h>
|
|
|
|
static int ircomm_ttp_data_indication(void *instance, void *sap,
|
|
struct sk_buff *skb);
|
|
static void ircomm_ttp_connect_confirm(void *instance, void *sap,
|
|
struct qos_info *qos,
|
|
__u32 max_sdu_size,
|
|
__u8 max_header_size,
|
|
struct sk_buff *skb);
|
|
static void ircomm_ttp_connect_indication(void *instance, void *sap,
|
|
struct qos_info *qos,
|
|
__u32 max_sdu_size,
|
|
__u8 max_header_size,
|
|
struct sk_buff *skb);
|
|
static void ircomm_ttp_flow_indication(void *instance, void *sap,
|
|
LOCAL_FLOW cmd);
|
|
static void ircomm_ttp_disconnect_indication(void *instance, void *sap,
|
|
LM_REASON reason,
|
|
struct sk_buff *skb);
|
|
static int ircomm_ttp_data_request(struct ircomm_cb *self,
|
|
struct sk_buff *skb,
|
|
int clen);
|
|
static int ircomm_ttp_connect_request(struct ircomm_cb *self,
|
|
struct sk_buff *userdata,
|
|
struct ircomm_info *info);
|
|
static int ircomm_ttp_connect_response(struct ircomm_cb *self,
|
|
struct sk_buff *userdata);
|
|
static int ircomm_ttp_disconnect_request(struct ircomm_cb *self,
|
|
struct sk_buff *userdata,
|
|
struct ircomm_info *info);
|
|
|
|
/*
|
|
* Function ircomm_open_tsap (self)
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
int ircomm_open_tsap(struct ircomm_cb *self)
|
|
{
|
|
notify_t notify;
|
|
|
|
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
|
|
|
|
/* Register callbacks */
|
|
irda_notify_init(¬ify);
|
|
notify.data_indication = ircomm_ttp_data_indication;
|
|
notify.connect_confirm = ircomm_ttp_connect_confirm;
|
|
notify.connect_indication = ircomm_ttp_connect_indication;
|
|
notify.flow_indication = ircomm_ttp_flow_indication;
|
|
notify.disconnect_indication = ircomm_ttp_disconnect_indication;
|
|
notify.instance = self;
|
|
strlcpy(notify.name, "IrCOMM", sizeof(notify.name));
|
|
|
|
self->tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT,
|
|
¬ify);
|
|
if (!self->tsap) {
|
|
IRDA_DEBUG(0, "%sfailed to allocate tsap\n", __FUNCTION__ );
|
|
return -1;
|
|
}
|
|
self->slsap_sel = self->tsap->stsap_sel;
|
|
|
|
/*
|
|
* Initialize the call-table for issuing commands
|
|
*/
|
|
self->issue.data_request = ircomm_ttp_data_request;
|
|
self->issue.connect_request = ircomm_ttp_connect_request;
|
|
self->issue.connect_response = ircomm_ttp_connect_response;
|
|
self->issue.disconnect_request = ircomm_ttp_disconnect_request;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function ircomm_ttp_connect_request (self, userdata)
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
static int ircomm_ttp_connect_request(struct ircomm_cb *self,
|
|
struct sk_buff *userdata,
|
|
struct ircomm_info *info)
|
|
{
|
|
int ret = 0;
|
|
|
|
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
|
|
|
|
/* Don't forget to refcount it - should be NULL anyway */
|
|
if(userdata)
|
|
skb_get(userdata);
|
|
|
|
ret = irttp_connect_request(self->tsap, info->dlsap_sel,
|
|
info->saddr, info->daddr, NULL,
|
|
TTP_SAR_DISABLE, userdata);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Function ircomm_ttp_connect_response (self, skb)
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
static int ircomm_ttp_connect_response(struct ircomm_cb *self,
|
|
struct sk_buff *userdata)
|
|
{
|
|
int ret;
|
|
|
|
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
|
|
|
|
/* Don't forget to refcount it - should be NULL anyway */
|
|
if(userdata)
|
|
skb_get(userdata);
|
|
|
|
ret = irttp_connect_response(self->tsap, TTP_SAR_DISABLE, userdata);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Function ircomm_ttp_data_request (self, userdata)
|
|
*
|
|
* Send IrCOMM data to IrTTP layer. Currently we do not try to combine
|
|
* control data with pure data, so they will be sent as separate frames.
|
|
* Should not be a big problem though, since control frames are rare. But
|
|
* some of them are sent after connection establishment, so this can
|
|
* increase the latency a bit.
|
|
*/
|
|
static int ircomm_ttp_data_request(struct ircomm_cb *self,
|
|
struct sk_buff *skb,
|
|
int clen)
|
|
{
|
|
int ret;
|
|
|
|
IRDA_ASSERT(skb != NULL, return -1;);
|
|
|
|
IRDA_DEBUG(2, "%s(), clen=%d\n", __FUNCTION__ , clen);
|
|
|
|
/*
|
|
* Insert clen field, currently we either send data only, or control
|
|
* only frames, to make things easier and avoid queueing
|
|
*/
|
|
IRDA_ASSERT(skb_headroom(skb) >= IRCOMM_HEADER_SIZE, return -1;);
|
|
|
|
/* Don't forget to refcount it - see ircomm_tty_do_softint() */
|
|
skb_get(skb);
|
|
|
|
skb_push(skb, IRCOMM_HEADER_SIZE);
|
|
|
|
skb->data[0] = clen;
|
|
|
|
ret = irttp_data_request(self->tsap, skb);
|
|
if (ret) {
|
|
IRDA_ERROR("%s(), failed\n", __FUNCTION__);
|
|
/* irttp_data_request already free the packet */
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Function ircomm_ttp_data_indication (instance, sap, skb)
|
|
*
|
|
* Incoming data
|
|
*
|
|
*/
|
|
static int ircomm_ttp_data_indication(void *instance, void *sap,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct ircomm_cb *self = (struct ircomm_cb *) instance;
|
|
|
|
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
|
|
|
|
IRDA_ASSERT(self != NULL, return -1;);
|
|
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;);
|
|
IRDA_ASSERT(skb != NULL, return -1;);
|
|
|
|
ircomm_do_event(self, IRCOMM_TTP_DATA_INDICATION, skb, NULL);
|
|
|
|
/* Drop reference count - see ircomm_tty_data_indication(). */
|
|
dev_kfree_skb(skb);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void ircomm_ttp_connect_confirm(void *instance, void *sap,
|
|
struct qos_info *qos,
|
|
__u32 max_sdu_size,
|
|
__u8 max_header_size,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct ircomm_cb *self = (struct ircomm_cb *) instance;
|
|
struct ircomm_info info;
|
|
|
|
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
|
|
|
|
IRDA_ASSERT(self != NULL, return;);
|
|
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;);
|
|
IRDA_ASSERT(skb != NULL, return;);
|
|
IRDA_ASSERT(qos != NULL, goto out;);
|
|
|
|
if (max_sdu_size != TTP_SAR_DISABLE) {
|
|
IRDA_ERROR("%s(), SAR not allowed for IrCOMM!\n",
|
|
__FUNCTION__);
|
|
goto out;
|
|
}
|
|
|
|
info.max_data_size = irttp_get_max_seg_size(self->tsap)
|
|
- IRCOMM_HEADER_SIZE;
|
|
info.max_header_size = max_header_size + IRCOMM_HEADER_SIZE;
|
|
info.qos = qos;
|
|
|
|
ircomm_do_event(self, IRCOMM_TTP_CONNECT_CONFIRM, skb, &info);
|
|
|
|
out:
|
|
/* Drop reference count - see ircomm_tty_connect_confirm(). */
|
|
dev_kfree_skb(skb);
|
|
}
|
|
|
|
/*
|
|
* Function ircomm_ttp_connect_indication (instance, sap, qos, max_sdu_size,
|
|
* max_header_size, skb)
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
static void ircomm_ttp_connect_indication(void *instance, void *sap,
|
|
struct qos_info *qos,
|
|
__u32 max_sdu_size,
|
|
__u8 max_header_size,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct ircomm_cb *self = (struct ircomm_cb *)instance;
|
|
struct ircomm_info info;
|
|
|
|
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
|
|
|
|
IRDA_ASSERT(self != NULL, return;);
|
|
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;);
|
|
IRDA_ASSERT(skb != NULL, return;);
|
|
IRDA_ASSERT(qos != NULL, goto out;);
|
|
|
|
if (max_sdu_size != TTP_SAR_DISABLE) {
|
|
IRDA_ERROR("%s(), SAR not allowed for IrCOMM!\n",
|
|
__FUNCTION__);
|
|
goto out;
|
|
}
|
|
|
|
info.max_data_size = irttp_get_max_seg_size(self->tsap)
|
|
- IRCOMM_HEADER_SIZE;
|
|
info.max_header_size = max_header_size + IRCOMM_HEADER_SIZE;
|
|
info.qos = qos;
|
|
|
|
ircomm_do_event(self, IRCOMM_TTP_CONNECT_INDICATION, skb, &info);
|
|
|
|
out:
|
|
/* Drop reference count - see ircomm_tty_connect_indication(). */
|
|
dev_kfree_skb(skb);
|
|
}
|
|
|
|
/*
|
|
* Function ircomm_ttp_disconnect_request (self, userdata, info)
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
static int ircomm_ttp_disconnect_request(struct ircomm_cb *self,
|
|
struct sk_buff *userdata,
|
|
struct ircomm_info *info)
|
|
{
|
|
int ret;
|
|
|
|
/* Don't forget to refcount it - should be NULL anyway */
|
|
if(userdata)
|
|
skb_get(userdata);
|
|
|
|
ret = irttp_disconnect_request(self->tsap, userdata, P_NORMAL);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Function ircomm_ttp_disconnect_indication (instance, sap, reason, skb)
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
static void ircomm_ttp_disconnect_indication(void *instance, void *sap,
|
|
LM_REASON reason,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct ircomm_cb *self = (struct ircomm_cb *) instance;
|
|
struct ircomm_info info;
|
|
|
|
IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
|
|
|
|
IRDA_ASSERT(self != NULL, return;);
|
|
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;);
|
|
|
|
info.reason = reason;
|
|
|
|
ircomm_do_event(self, IRCOMM_TTP_DISCONNECT_INDICATION, skb, &info);
|
|
|
|
/* Drop reference count - see ircomm_tty_disconnect_indication(). */
|
|
if(skb)
|
|
dev_kfree_skb(skb);
|
|
}
|
|
|
|
/*
|
|
* Function ircomm_ttp_flow_indication (instance, sap, cmd)
|
|
*
|
|
* Layer below is telling us to start or stop the flow of data
|
|
*
|
|
*/
|
|
static void ircomm_ttp_flow_indication(void *instance, void *sap,
|
|
LOCAL_FLOW cmd)
|
|
{
|
|
struct ircomm_cb *self = (struct ircomm_cb *) instance;
|
|
|
|
IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
|
|
|
|
IRDA_ASSERT(self != NULL, return;);
|
|
IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;);
|
|
|
|
if (self->notify.flow_indication)
|
|
self->notify.flow_indication(self->notify.instance, self, cmd);
|
|
}
|
|
|
|
|