1/********************************************************************* 2 * 3 * Filename: irlmp_frame.c 4 * Version: 0.9 5 * Description: IrLMP frame implementation 6 * Status: Experimental. 7 * Author: Dag Brattli <dagb@cs.uit.no> 8 * Created at: Tue Aug 19 02:09:59 1997 9 * Modified at: Mon Dec 13 13:41:12 1999 10 * Modified by: Dag Brattli <dagb@cs.uit.no> 11 * 12 * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no> 13 * All Rights Reserved. 14 * Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com> 15 * 16 * This program is free software; you can redistribute it and/or 17 * modify it under the terms of the GNU General Public License as 18 * published by the Free Software Foundation; either version 2 of 19 * the License, or (at your option) any later version. 20 * 21 * Neither Dag Brattli nor University of Tromsø admit liability nor 22 * provide warranty for any of this software. This material is 23 * provided "AS-IS" and at no charge. 24 * 25 ********************************************************************/ 26 27#include <linux/skbuff.h> 28#include <linux/kernel.h> 29 30#include <net/irda/irda.h> 31#include <net/irda/irlap.h> 32#include <net/irda/timer.h> 33#include <net/irda/irlmp.h> 34#include <net/irda/irlmp_frame.h> 35#include <net/irda/discovery.h> 36 37static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap, 38 __u8 slsap, int status, hashbin_t *); 39 40inline void irlmp_send_data_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap, 41 int expedited, struct sk_buff *skb) 42{ 43 skb->data[0] = dlsap; 44 skb->data[1] = slsap; 45 46 if (expedited) { 47 pr_debug("%s(), sending expedited data\n", __func__); 48 irlap_data_request(self->irlap, skb, TRUE); 49 } else 50 irlap_data_request(self->irlap, skb, FALSE); 51} 52 53/* 54 * Function irlmp_send_lcf_pdu (dlsap, slsap, opcode,skb) 55 * 56 * Send Link Control Frame to IrLAP 57 */ 58void irlmp_send_lcf_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap, 59 __u8 opcode, struct sk_buff *skb) 60{ 61 __u8 *frame; 62 63 IRDA_ASSERT(self != NULL, return;); 64 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); 65 IRDA_ASSERT(skb != NULL, return;); 66 67 frame = skb->data; 68 69 frame[0] = dlsap | CONTROL_BIT; 70 frame[1] = slsap; 71 72 frame[2] = opcode; 73 74 if (opcode == DISCONNECT) 75 frame[3] = 0x01; /* Service user request */ 76 else 77 frame[3] = 0x00; /* rsvd */ 78 79 irlap_data_request(self->irlap, skb, FALSE); 80} 81 82/* 83 * Function irlmp_input (skb) 84 * 85 * Used by IrLAP to pass received data frames to IrLMP layer 86 * 87 */ 88void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb, 89 int unreliable) 90{ 91 struct lsap_cb *lsap; 92 __u8 slsap_sel; /* Source (this) LSAP address */ 93 __u8 dlsap_sel; /* Destination LSAP address */ 94 __u8 *fp; 95 96 IRDA_ASSERT(self != NULL, return;); 97 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); 98 IRDA_ASSERT(skb->len > 2, return;); 99 100 fp = skb->data; 101 102 /* 103 * The next statements may be confusing, but we do this so that 104 * destination LSAP of received frame is source LSAP in our view 105 */ 106 slsap_sel = fp[0] & LSAP_MASK; 107 dlsap_sel = fp[1]; 108 109 /* 110 * Check if this is an incoming connection, since we must deal with 111 * it in a different way than other established connections. 112 */ 113 if ((fp[0] & CONTROL_BIT) && (fp[2] == CONNECT_CMD)) { 114 pr_debug("%s(), incoming connection, source LSAP=%d, dest LSAP=%d\n", 115 __func__, slsap_sel, dlsap_sel); 116 117 /* Try to find LSAP among the unconnected LSAPs */ 118 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, CONNECT_CMD, 119 irlmp->unconnected_lsaps); 120 121 /* Maybe LSAP was already connected, so try one more time */ 122 if (!lsap) { 123 pr_debug("%s(), incoming connection for LSAP already connected\n", 124 __func__); 125 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0, 126 self->lsaps); 127 } 128 } else 129 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0, 130 self->lsaps); 131 132 if (lsap == NULL) { 133 pr_debug("IrLMP, Sorry, no LSAP for received frame!\n"); 134 pr_debug("%s(), slsap_sel = %02x, dlsap_sel = %02x\n", 135 __func__, slsap_sel, dlsap_sel); 136 if (fp[0] & CONTROL_BIT) { 137 pr_debug("%s(), received control frame %02x\n", 138 __func__, fp[2]); 139 } else { 140 pr_debug("%s(), received data frame\n", __func__); 141 } 142 return; 143 } 144 145 /* 146 * Check if we received a control frame? 147 */ 148 if (fp[0] & CONTROL_BIT) { 149 switch (fp[2]) { 150 case CONNECT_CMD: 151 lsap->lap = self; 152 irlmp_do_lsap_event(lsap, LM_CONNECT_INDICATION, skb); 153 break; 154 case CONNECT_CNF: 155 irlmp_do_lsap_event(lsap, LM_CONNECT_CONFIRM, skb); 156 break; 157 case DISCONNECT: 158 pr_debug("%s(), Disconnect indication!\n", 159 __func__); 160 irlmp_do_lsap_event(lsap, LM_DISCONNECT_INDICATION, 161 skb); 162 break; 163 case ACCESSMODE_CMD: 164 pr_debug("Access mode cmd not implemented!\n"); 165 break; 166 case ACCESSMODE_CNF: 167 pr_debug("Access mode cnf not implemented!\n"); 168 break; 169 default: 170 pr_debug("%s(), Unknown control frame %02x\n", 171 __func__, fp[2]); 172 break; 173 } 174 } else if (unreliable) { 175 /* Optimize and bypass the state machine if possible */ 176 if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY) 177 irlmp_udata_indication(lsap, skb); 178 else 179 irlmp_do_lsap_event(lsap, LM_UDATA_INDICATION, skb); 180 } else { 181 /* Optimize and bypass the state machine if possible */ 182 if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY) 183 irlmp_data_indication(lsap, skb); 184 else 185 irlmp_do_lsap_event(lsap, LM_DATA_INDICATION, skb); 186 } 187} 188 189/* 190 * Function irlmp_link_unitdata_indication (self, skb) 191 * 192 * 193 * 194 */ 195#ifdef CONFIG_IRDA_ULTRA 196void irlmp_link_unitdata_indication(struct lap_cb *self, struct sk_buff *skb) 197{ 198 struct lsap_cb *lsap; 199 __u8 slsap_sel; /* Source (this) LSAP address */ 200 __u8 dlsap_sel; /* Destination LSAP address */ 201 __u8 pid; /* Protocol identifier */ 202 __u8 *fp; 203 unsigned long flags; 204 205 IRDA_ASSERT(self != NULL, return;); 206 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); 207 IRDA_ASSERT(skb->len > 2, return;); 208 209 fp = skb->data; 210 211 /* 212 * The next statements may be confusing, but we do this so that 213 * destination LSAP of received frame is source LSAP in our view 214 */ 215 slsap_sel = fp[0] & LSAP_MASK; 216 dlsap_sel = fp[1]; 217 pid = fp[2]; 218 219 if (pid & 0x80) { 220 pr_debug("%s(), extension in PID not supp!\n", 221 __func__); 222 return; 223 } 224 225 /* Check if frame is addressed to the connectionless LSAP */ 226 if ((slsap_sel != LSAP_CONNLESS) || (dlsap_sel != LSAP_CONNLESS)) { 227 pr_debug("%s(), dropping frame!\n", __func__); 228 return; 229 } 230 231 /* Search the connectionless LSAP */ 232 spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags); 233 lsap = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps); 234 while (lsap != NULL) { 235 /* 236 * Check if source LSAP and dest LSAP selectors and PID match. 237 */ 238 if ((lsap->slsap_sel == slsap_sel) && 239 (lsap->dlsap_sel == dlsap_sel) && 240 (lsap->pid == pid)) 241 { 242 break; 243 } 244 lsap = (struct lsap_cb *) hashbin_get_next(irlmp->unconnected_lsaps); 245 } 246 spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags); 247 248 if (lsap) 249 irlmp_connless_data_indication(lsap, skb); 250 else { 251 pr_debug("%s(), found no matching LSAP!\n", __func__); 252 } 253} 254#endif /* CONFIG_IRDA_ULTRA */ 255 256/* 257 * Function irlmp_link_disconnect_indication (reason, userdata) 258 * 259 * IrLAP has disconnected 260 * 261 */ 262void irlmp_link_disconnect_indication(struct lap_cb *lap, 263 struct irlap_cb *irlap, 264 LAP_REASON reason, 265 struct sk_buff *skb) 266{ 267 IRDA_ASSERT(lap != NULL, return;); 268 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;); 269 270 lap->reason = reason; 271 lap->daddr = DEV_ADDR_ANY; 272 273 /* FIXME: must do something with the skb if any */ 274 275 /* 276 * Inform station state machine 277 */ 278 irlmp_do_lap_event(lap, LM_LAP_DISCONNECT_INDICATION, NULL); 279} 280 281/* 282 * Function irlmp_link_connect_indication (qos) 283 * 284 * Incoming LAP connection! 285 * 286 */ 287void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr, 288 __u32 daddr, struct qos_info *qos, 289 struct sk_buff *skb) 290{ 291 /* Copy QoS settings for this session */ 292 self->qos = qos; 293 294 /* Update destination device address */ 295 self->daddr = daddr; 296 IRDA_ASSERT(self->saddr == saddr, return;); 297 298 irlmp_do_lap_event(self, LM_LAP_CONNECT_INDICATION, skb); 299} 300 301/* 302 * Function irlmp_link_connect_confirm (qos) 303 * 304 * LAP connection confirmed! 305 * 306 */ 307void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos, 308 struct sk_buff *skb) 309{ 310 IRDA_ASSERT(self != NULL, return;); 311 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); 312 IRDA_ASSERT(qos != NULL, return;); 313 314 /* Don't need use the skb for now */ 315 316 /* Copy QoS settings for this session */ 317 self->qos = qos; 318 319 irlmp_do_lap_event(self, LM_LAP_CONNECT_CONFIRM, NULL); 320} 321 322/* 323 * Function irlmp_link_discovery_indication (self, log) 324 * 325 * Device is discovering us 326 * 327 * It's not an answer to our own discoveries, just another device trying 328 * to perform discovery, but we don't want to miss the opportunity 329 * to exploit this information, because : 330 * o We may not actively perform discovery (just passive discovery) 331 * o This type of discovery is much more reliable. In some cases, it 332 * seem that less than 50% of our discoveries get an answer, while 333 * we always get ~100% of these. 334 * o Make faster discovery, statistically divide time of discovery 335 * events by 2 (important for the latency aspect and user feel) 336 * o Even is we do active discovery, the other node might not 337 * answer our discoveries (ex: Palm). The Palm will just perform 338 * one active discovery and connect directly to us. 339 * 340 * However, when both devices discover each other, they might attempt to 341 * connect to each other following the discovery event, and it would create 342 * collisions on the medium (SNRM battle). 343 * The "fix" for that is to disable all connection requests in IrLAP 344 * for 100ms after a discovery indication by setting the media_busy flag. 345 * Previously, we used to postpone the event which was quite ugly. Now 346 * that IrLAP takes care of this problem, just pass the event up... 347 * 348 * Jean II 349 */ 350void irlmp_link_discovery_indication(struct lap_cb *self, 351 discovery_t *discovery) 352{ 353 IRDA_ASSERT(self != NULL, return;); 354 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); 355 356 /* Add to main log, cleanup */ 357 irlmp_add_discovery(irlmp->cachelog, discovery); 358 359 /* Just handle it the same way as a discovery confirm, 360 * bypass the LM_LAP state machine (see below) */ 361 irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_PASSIVE); 362} 363 364/* 365 * Function irlmp_link_discovery_confirm (self, log) 366 * 367 * Called by IrLAP with a list of discoveries after the discovery 368 * request has been carried out. A NULL log is received if IrLAP 369 * was unable to carry out the discovery request 370 * 371 */ 372void irlmp_link_discovery_confirm(struct lap_cb *self, hashbin_t *log) 373{ 374 IRDA_ASSERT(self != NULL, return;); 375 IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); 376 377 /* Add to main log, cleanup */ 378 irlmp_add_discovery_log(irlmp->cachelog, log); 379 380 /* Propagate event to various LSAPs registered for it. 381 * We bypass the LM_LAP state machine because 382 * 1) We do it regardless of the LM_LAP state 383 * 2) It doesn't affect the LM_LAP state 384 * 3) Faster, slimer, simpler, ... 385 * Jean II */ 386 irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_ACTIVE); 387} 388 389#ifdef CONFIG_IRDA_CACHE_LAST_LSAP 390static inline void irlmp_update_cache(struct lap_cb *lap, 391 struct lsap_cb *lsap) 392{ 393 /* Prevent concurrent read to get garbage */ 394 lap->cache.valid = FALSE; 395 /* Update cache entry */ 396 lap->cache.dlsap_sel = lsap->dlsap_sel; 397 lap->cache.slsap_sel = lsap->slsap_sel; 398 lap->cache.lsap = lsap; 399 lap->cache.valid = TRUE; 400} 401#endif 402 403/* 404 * Function irlmp_find_handle (self, dlsap_sel, slsap_sel, status, queue) 405 * 406 * Find handle associated with destination and source LSAP 407 * 408 * Any IrDA connection (LSAP/TSAP) is uniquely identified by 409 * 3 parameters, the local lsap, the remote lsap and the remote address. 410 * We may initiate multiple connections to the same remote service 411 * (they will have different local lsap), a remote device may initiate 412 * multiple connections to the same local service (they will have 413 * different remote lsap), or multiple devices may connect to the same 414 * service and may use the same remote lsap (and they will have 415 * different remote address). 416 * So, where is the remote address ? Each LAP connection is made with 417 * a single remote device, so imply a specific remote address. 418 * Jean II 419 */ 420static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap_sel, 421 __u8 slsap_sel, int status, 422 hashbin_t *queue) 423{ 424 struct lsap_cb *lsap; 425 unsigned long flags; 426 427 /* 428 * Optimize for the common case. We assume that the last frame 429 * received is in the same connection as the last one, so check in 430 * cache first to avoid the linear search 431 */ 432#ifdef CONFIG_IRDA_CACHE_LAST_LSAP 433 if ((self->cache.valid) && 434 (self->cache.slsap_sel == slsap_sel) && 435 (self->cache.dlsap_sel == dlsap_sel)) 436 { 437 return self->cache.lsap; 438 } 439#endif 440 441 spin_lock_irqsave(&queue->hb_spinlock, flags); 442 443 lsap = (struct lsap_cb *) hashbin_get_first(queue); 444 while (lsap != NULL) { 445 /* 446 * If this is an incoming connection, then the destination 447 * LSAP selector may have been specified as LM_ANY so that 448 * any client can connect. In that case we only need to check 449 * if the source LSAP (in our view!) match! 450 */ 451 if ((status == CONNECT_CMD) && 452 (lsap->slsap_sel == slsap_sel) && 453 (lsap->dlsap_sel == LSAP_ANY)) { 454 /* This is where the dest lsap sel is set on incoming 455 * lsaps */ 456 lsap->dlsap_sel = dlsap_sel; 457 break; 458 } 459 /* 460 * Check if source LSAP and dest LSAP selectors match. 461 */ 462 if ((lsap->slsap_sel == slsap_sel) && 463 (lsap->dlsap_sel == dlsap_sel)) 464 break; 465 466 lsap = (struct lsap_cb *) hashbin_get_next(queue); 467 } 468#ifdef CONFIG_IRDA_CACHE_LAST_LSAP 469 if(lsap) 470 irlmp_update_cache(self, lsap); 471#endif 472 spin_unlock_irqrestore(&queue->hb_spinlock, flags); 473 474 /* Return what we've found or NULL */ 475 return lsap; 476} 477