/********************************************************************* * * Filename: irlmp_frame.c * Version: 0.9 * Description: IrLMP frame implementation * Status: Experimental. * Author: Dag Brattli <dagb@cs.uit.no> * Created at: Tue Aug 19 02:09:59 1997 * Modified at: Mon Dec 13 13:41:12 1999 * Modified by: Dag Brattli <dagb@cs.uit.no> * * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no> * 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. * * Neither Dag Brattli nor University of Tromsø admit liability nor * provide warranty for any of this software. This material is * provided "AS-IS" and at no charge. * ********************************************************************/ #include <linux/skbuff.h> #include <linux/kernel.h> #include <net/irda/irda.h> #include <net/irda/irlap.h> #include <net/irda/timer.h> #include <net/irda/irlmp.h> #include <net/irda/irlmp_frame.h> #include <net/irda/discovery.h> static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap, __u8 slsap, int status, hashbin_t *); inline void irlmp_send_data_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap, int expedited, struct sk_buff *skb) { skb->data[0] = dlsap; skb->data[1] = slsap; if (expedited) { pr_debug("%s(), sending expedited data\n", __func__); irlap_data_request(self->irlap, skb, TRUE); } else irlap_data_request(self->irlap, skb, FALSE); } /* * Function irlmp_send_lcf_pdu (dlsap, slsap, opcode,skb) * * Send Link Control Frame to IrLAP */ void irlmp_send_lcf_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap, __u8 opcode, struct sk_buff *skb) { __u8 *frame; IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); IRDA_ASSERT(skb != NULL, return;); frame = skb->data; frame[0] = dlsap | CONTROL_BIT; frame[1] = slsap; frame[2] = opcode; if (opcode == DISCONNECT) frame[3] = 0x01; /* Service user request */ else frame[3] = 0x00; /* rsvd */ irlap_data_request(self->irlap, skb, FALSE); } /* * Function irlmp_input (skb) * * Used by IrLAP to pass received data frames to IrLMP layer * */ void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb, int unreliable) { struct lsap_cb *lsap; __u8 slsap_sel; /* Source (this) LSAP address */ __u8 dlsap_sel; /* Destination LSAP address */ __u8 *fp; IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); IRDA_ASSERT(skb->len > 2, return;); fp = skb->data; /* * The next statements may be confusing, but we do this so that * destination LSAP of received frame is source LSAP in our view */ slsap_sel = fp[0] & LSAP_MASK; dlsap_sel = fp[1]; /* * Check if this is an incoming connection, since we must deal with * it in a different way than other established connections. */ if ((fp[0] & CONTROL_BIT) && (fp[2] == CONNECT_CMD)) { pr_debug("%s(), incoming connection, source LSAP=%d, dest LSAP=%d\n", __func__, slsap_sel, dlsap_sel); /* Try to find LSAP among the unconnected LSAPs */ lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, CONNECT_CMD, irlmp->unconnected_lsaps); /* Maybe LSAP was already connected, so try one more time */ if (!lsap) { pr_debug("%s(), incoming connection for LSAP already connected\n", __func__); lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0, self->lsaps); } } else lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0, self->lsaps); if (lsap == NULL) { pr_debug("IrLMP, Sorry, no LSAP for received frame!\n"); pr_debug("%s(), slsap_sel = %02x, dlsap_sel = %02x\n", __func__, slsap_sel, dlsap_sel); if (fp[0] & CONTROL_BIT) { pr_debug("%s(), received control frame %02x\n", __func__, fp[2]); } else { pr_debug("%s(), received data frame\n", __func__); } return; } /* * Check if we received a control frame? */ if (fp[0] & CONTROL_BIT) { switch (fp[2]) { case CONNECT_CMD: lsap->lap = self; irlmp_do_lsap_event(lsap, LM_CONNECT_INDICATION, skb); break; case CONNECT_CNF: irlmp_do_lsap_event(lsap, LM_CONNECT_CONFIRM, skb); break; case DISCONNECT: pr_debug("%s(), Disconnect indication!\n", __func__); irlmp_do_lsap_event(lsap, LM_DISCONNECT_INDICATION, skb); break; case ACCESSMODE_CMD: pr_debug("Access mode cmd not implemented!\n"); break; case ACCESSMODE_CNF: pr_debug("Access mode cnf not implemented!\n"); break; default: pr_debug("%s(), Unknown control frame %02x\n", __func__, fp[2]); break; } } else if (unreliable) { /* Optimize and bypass the state machine if possible */ if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY) irlmp_udata_indication(lsap, skb); else irlmp_do_lsap_event(lsap, LM_UDATA_INDICATION, skb); } else { /* Optimize and bypass the state machine if possible */ if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY) irlmp_data_indication(lsap, skb); else irlmp_do_lsap_event(lsap, LM_DATA_INDICATION, skb); } } /* * Function irlmp_link_unitdata_indication (self, skb) * * * */ #ifdef CONFIG_IRDA_ULTRA void irlmp_link_unitdata_indication(struct lap_cb *self, struct sk_buff *skb) { struct lsap_cb *lsap; __u8 slsap_sel; /* Source (this) LSAP address */ __u8 dlsap_sel; /* Destination LSAP address */ __u8 pid; /* Protocol identifier */ __u8 *fp; unsigned long flags; IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); IRDA_ASSERT(skb->len > 2, return;); fp = skb->data; /* * The next statements may be confusing, but we do this so that * destination LSAP of received frame is source LSAP in our view */ slsap_sel = fp[0] & LSAP_MASK; dlsap_sel = fp[1]; pid = fp[2]; if (pid & 0x80) { pr_debug("%s(), extension in PID not supp!\n", __func__); return; } /* Check if frame is addressed to the connectionless LSAP */ if ((slsap_sel != LSAP_CONNLESS) || (dlsap_sel != LSAP_CONNLESS)) { pr_debug("%s(), dropping frame!\n", __func__); return; } /* Search the connectionless LSAP */ spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags); lsap = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps); while (lsap != NULL) { /* * Check if source LSAP and dest LSAP selectors and PID match. */ if ((lsap->slsap_sel == slsap_sel) && (lsap->dlsap_sel == dlsap_sel) && (lsap->pid == pid)) { break; } lsap = (struct lsap_cb *) hashbin_get_next(irlmp->unconnected_lsaps); } spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags); if (lsap) irlmp_connless_data_indication(lsap, skb); else { pr_debug("%s(), found no matching LSAP!\n", __func__); } } #endif /* CONFIG_IRDA_ULTRA */ /* * Function irlmp_link_disconnect_indication (reason, userdata) * * IrLAP has disconnected * */ void irlmp_link_disconnect_indication(struct lap_cb *lap, struct irlap_cb *irlap, LAP_REASON reason, struct sk_buff *skb) { IRDA_ASSERT(lap != NULL, return;); IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;); lap->reason = reason; lap->daddr = DEV_ADDR_ANY; /* FIXME: must do something with the skb if any */ /* * Inform station state machine */ irlmp_do_lap_event(lap, LM_LAP_DISCONNECT_INDICATION, NULL); } /* * Function irlmp_link_connect_indication (qos) * * Incoming LAP connection! * */ void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr, __u32 daddr, struct qos_info *qos, struct sk_buff *skb) { /* Copy QoS settings for this session */ self->qos = qos; /* Update destination device address */ self->daddr = daddr; IRDA_ASSERT(self->saddr == saddr, return;); irlmp_do_lap_event(self, LM_LAP_CONNECT_INDICATION, skb); } /* * Function irlmp_link_connect_confirm (qos) * * LAP connection confirmed! * */ void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos, struct sk_buff *skb) { IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); IRDA_ASSERT(qos != NULL, return;); /* Don't need use the skb for now */ /* Copy QoS settings for this session */ self->qos = qos; irlmp_do_lap_event(self, LM_LAP_CONNECT_CONFIRM, NULL); } /* * Function irlmp_link_discovery_indication (self, log) * * Device is discovering us * * It's not an answer to our own discoveries, just another device trying * to perform discovery, but we don't want to miss the opportunity * to exploit this information, because : * o We may not actively perform discovery (just passive discovery) * o This type of discovery is much more reliable. In some cases, it * seem that less than 50% of our discoveries get an answer, while * we always get ~100% of these. * o Make faster discovery, statistically divide time of discovery * events by 2 (important for the latency aspect and user feel) * o Even is we do active discovery, the other node might not * answer our discoveries (ex: Palm). The Palm will just perform * one active discovery and connect directly to us. * * However, when both devices discover each other, they might attempt to * connect to each other following the discovery event, and it would create * collisions on the medium (SNRM battle). * The "fix" for that is to disable all connection requests in IrLAP * for 100ms after a discovery indication by setting the media_busy flag. * Previously, we used to postpone the event which was quite ugly. Now * that IrLAP takes care of this problem, just pass the event up... * * Jean II */ void irlmp_link_discovery_indication(struct lap_cb *self, discovery_t *discovery) { IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); /* Add to main log, cleanup */ irlmp_add_discovery(irlmp->cachelog, discovery); /* Just handle it the same way as a discovery confirm, * bypass the LM_LAP state machine (see below) */ irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_PASSIVE); } /* * Function irlmp_link_discovery_confirm (self, log) * * Called by IrLAP with a list of discoveries after the discovery * request has been carried out. A NULL log is received if IrLAP * was unable to carry out the discovery request * */ void irlmp_link_discovery_confirm(struct lap_cb *self, hashbin_t *log) { IRDA_ASSERT(self != NULL, return;); IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); /* Add to main log, cleanup */ irlmp_add_discovery_log(irlmp->cachelog, log); /* Propagate event to various LSAPs registered for it. * We bypass the LM_LAP state machine because * 1) We do it regardless of the LM_LAP state * 2) It doesn't affect the LM_LAP state * 3) Faster, slimer, simpler, ... * Jean II */ irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_ACTIVE); } #ifdef CONFIG_IRDA_CACHE_LAST_LSAP static inline void irlmp_update_cache(struct lap_cb *lap, struct lsap_cb *lsap) { /* Prevent concurrent read to get garbage */ lap->cache.valid = FALSE; /* Update cache entry */ lap->cache.dlsap_sel = lsap->dlsap_sel; lap->cache.slsap_sel = lsap->slsap_sel; lap->cache.lsap = lsap; lap->cache.valid = TRUE; } #endif /* * Function irlmp_find_handle (self, dlsap_sel, slsap_sel, status, queue) * * Find handle associated with destination and source LSAP * * Any IrDA connection (LSAP/TSAP) is uniquely identified by * 3 parameters, the local lsap, the remote lsap and the remote address. * We may initiate multiple connections to the same remote service * (they will have different local lsap), a remote device may initiate * multiple connections to the same local service (they will have * different remote lsap), or multiple devices may connect to the same * service and may use the same remote lsap (and they will have * different remote address). * So, where is the remote address ? Each LAP connection is made with * a single remote device, so imply a specific remote address. * Jean II */ static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap_sel, __u8 slsap_sel, int status, hashbin_t *queue) { struct lsap_cb *lsap; unsigned long flags; /* * Optimize for the common case. We assume that the last frame * received is in the same connection as the last one, so check in * cache first to avoid the linear search */ #ifdef CONFIG_IRDA_CACHE_LAST_LSAP if ((self->cache.valid) && (self->cache.slsap_sel == slsap_sel) && (self->cache.dlsap_sel == dlsap_sel)) { return self->cache.lsap; } #endif spin_lock_irqsave(&queue->hb_spinlock, flags); lsap = (struct lsap_cb *) hashbin_get_first(queue); while (lsap != NULL) { /* * If this is an incoming connection, then the destination * LSAP selector may have been specified as LM_ANY so that * any client can connect. In that case we only need to check * if the source LSAP (in our view!) match! */ if ((status == CONNECT_CMD) && (lsap->slsap_sel == slsap_sel) && (lsap->dlsap_sel == LSAP_ANY)) { /* This is where the dest lsap sel is set on incoming * lsaps */ lsap->dlsap_sel = dlsap_sel; break; } /* * Check if source LSAP and dest LSAP selectors match. */ if ((lsap->slsap_sel == slsap_sel) && (lsap->dlsap_sel == dlsap_sel)) break; lsap = (struct lsap_cb *) hashbin_get_next(queue); } #ifdef CONFIG_IRDA_CACHE_LAST_LSAP if(lsap) irlmp_update_cache(self, lsap); #endif spin_unlock_irqrestore(&queue->hb_spinlock, flags); /* Return what we've found or NULL */ return lsap; }