net/irda/ircomm/ircomm_core.c

   1 /*********************************************************************
   2  *
   3  * Filename:      ircomm_core.c
   4  * Version:       1.0
   5  * Description:   IrCOMM service interface
   6  * Status:        Experimental.
   7  * Author:        Dag Brattli <dagb@cs.uit.no>
   8  * Created at:    Sun Jun  6 20:37:34 1999
   9  * Modified at:   Tue Dec 21 13:26:41 1999
  10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  11  *
  12  *     Copyright (c) 1999 Dag Brattli, All Rights Reserved.
  13  *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
  14  *
  15  *     This program is free software; you can redistribute it and/or
  16  *     modify it under the terms of the GNU General Public License as
  17  *     published by the Free Software Foundation; either version 2 of
  18  *     the License, or (at your option) any later version.
  19  *
  20  *     This program is distributed in the hope that it will be useful,
  21  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  23  *     GNU General Public License for more details.
  24  *
  25  *     You should have received a copy of the GNU General Public License
  26  *     along with this program; if not, write to the Free Software
  27  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  28  *     MA 02111-1307 USA
  29  *
  30  ********************************************************************/
  31
  32 #include <linux/module.h>
  33 #include <linux/proc_fs.h>
  34 #include <linux/seq_file.h>
  35 #include <linux/init.h>
  36
  37 #include <net/irda/irda.h>
  38 #include <net/irda/irmod.h>
  39 #include <net/irda/irlmp.h>
  40 #include <net/irda/iriap.h>
  41 #include <net/irda/irttp.h>
  42 #include <net/irda/irias_object.h>
  43
  44 #include <net/irda/ircomm_event.h>
  45 #include <net/irda/ircomm_lmp.h>
  46 #include <net/irda/ircomm_ttp.h>
  47 #include <net/irda/ircomm_param.h>
  48 #include <net/irda/ircomm_core.h>
  49
  50 static int __ircomm_close(struct ircomm_cb *self);
  51 static void ircomm_control_indication(struct ircomm_cb *self,
  52                                       struct sk_buff *skb, int clen);
  53
  54 #ifdef CONFIG_PROC_FS
  55 extern struct proc_dir_entry *proc_irda;
  56 static int ircomm_seq_open(struct inode *, struct file *);
  57
  58 static const struct file_operations ircomm_proc_fops = {
  59         .owner          = THIS_MODULE,
  60         .open           = ircomm_seq_open,
  61         .read           = seq_read,
  62         .llseek         = seq_lseek,
  63         .release        = seq_release,
  64 };
  65 #endif /* CONFIG_PROC_FS */
  66
  67 hashbin_t *ircomm = NULL;
  68
  69 static int __init ircomm_init(void)
  70 {
  71         ircomm = hashbin_new(HB_LOCK);
  72         if (ircomm == NULL) {
  73                 IRDA_ERROR("%s(), can't allocate hashbin!\n", __FUNCTION__);
  74                 return -ENOMEM;
  75         }
  76
  77 #ifdef CONFIG_PROC_FS
  78         { struct proc_dir_entry *ent;
  79 <<<<<<< HEAD:net/irda/ircomm/ircomm_core.c
  80         ent = create_proc_entry("ircomm", 0, proc_irda);
  81         if (ent)
  82                 ent->proc_fops = &ircomm_proc_fops;
  83 =======
  84         ent = proc_create("ircomm", 0, proc_irda, &ircomm_proc_fops);
  85         if (!ent) {
  86                 printk(KERN_ERR "ircomm_init: can't create /proc entry!\n");
  87                 return -ENODEV;
  88         }
  89 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:net/irda/ircomm/ircomm_core.c
  90         }
  91 #endif /* CONFIG_PROC_FS */
  92
  93         IRDA_MESSAGE("IrCOMM protocol (Dag Brattli)\n");
  94
  95         return 0;
  96 }
  97
  98 static void __exit ircomm_cleanup(void)
  99 {
 100         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 101
 102         hashbin_delete(ircomm, (FREE_FUNC) __ircomm_close);
 103
 104 #ifdef CONFIG_PROC_FS
 105         remove_proc_entry("ircomm", proc_irda);
 106 #endif /* CONFIG_PROC_FS */
 107 }
 108
 109 /*
 110  * Function ircomm_open (client_notify)
 111  *
 112  *    Start a new IrCOMM instance
 113  *
 114  */
 115 struct ircomm_cb *ircomm_open(notify_t *notify, __u8 service_type, int line)
 116 {
 117         struct ircomm_cb *self = NULL;
 118         int ret;
 119
 120         IRDA_DEBUG(2, "%s(), service_type=0x%02x\n", __FUNCTION__ ,
 121                    service_type);
 122
 123         IRDA_ASSERT(ircomm != NULL, return NULL;);
 124
 125         self = kzalloc(sizeof(struct ircomm_cb), GFP_ATOMIC);
 126         if (self == NULL)
 127                 return NULL;
 128
 129         self->notify = *notify;
 130         self->magic = IRCOMM_MAGIC;
 131
 132         /* Check if we should use IrLMP or IrTTP */
 133         if (service_type & IRCOMM_3_WIRE_RAW) {
 134                 self->flow_status = FLOW_START;
 135                 ret = ircomm_open_lsap(self);
 136         } else
 137                 ret = ircomm_open_tsap(self);
 138
 139         if (ret < 0) {
 140                 kfree(self);
 141                 return NULL;
 142         }
 143
 144         self->service_type = service_type;
 145         self->line = line;
 146
 147         hashbin_insert(ircomm, (irda_queue_t *) self, line, NULL);
 148
 149         ircomm_next_state(self, IRCOMM_IDLE);
 150
 151         return self;
 152 }
 153
 154 EXPORT_SYMBOL(ircomm_open);
 155
 156 /*
 157  * Function ircomm_close_instance (self)
 158  *
 159  *    Remove IrCOMM instance
 160  *
 161  */
 162 static int __ircomm_close(struct ircomm_cb *self)
 163 {
 164         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 165
 166         /* Disconnect link if any */
 167         ircomm_do_event(self, IRCOMM_DISCONNECT_REQUEST, NULL, NULL);
 168
 169         /* Remove TSAP */
 170         if (self->tsap) {
 171                 irttp_close_tsap(self->tsap);
 172                 self->tsap = NULL;
 173         }
 174
 175         /* Remove LSAP */
 176         if (self->lsap) {
 177                 irlmp_close_lsap(self->lsap);
 178                 self->lsap = NULL;
 179         }
 180         self->magic = 0;
 181
 182         kfree(self);
 183
 184         return 0;
 185 }
 186
 187 /*
 188  * Function ircomm_close (self)
 189  *
 190  *    Closes and removes the specified IrCOMM instance
 191  *
 192  */
 193 int ircomm_close(struct ircomm_cb *self)
 194 {
 195         struct ircomm_cb *entry;
 196
 197         IRDA_ASSERT(self != NULL, return -EIO;);
 198         IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EIO;);
 199
 200         IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
 201
 202         entry = hashbin_remove(ircomm, self->line, NULL);
 203
 204         IRDA_ASSERT(entry == self, return -1;);
 205
 206         return __ircomm_close(self);
 207 }
 208
 209 EXPORT_SYMBOL(ircomm_close);
 210
 211 /*
 212  * Function ircomm_connect_request (self, service_type)
 213  *
 214  *    Impl. of this function is differ from one of the reference. This
 215  *    function does discovery as well as sending connect request
 216  *
 217  */
 218 int ircomm_connect_request(struct ircomm_cb *self, __u8 dlsap_sel,
 219                            __u32 saddr, __u32 daddr, struct sk_buff *skb,
 220                            __u8 service_type)
 221 {
 222         struct ircomm_info info;
 223         int ret;
 224
 225         IRDA_DEBUG(2 , "%s()\n", __FUNCTION__ );
 226
 227         IRDA_ASSERT(self != NULL, return -1;);
 228         IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;);
 229
 230         self->service_type= service_type;
 231
 232         info.dlsap_sel = dlsap_sel;
 233         info.saddr = saddr;
 234         info.daddr = daddr;
 235
 236         ret = ircomm_do_event(self, IRCOMM_CONNECT_REQUEST, skb, &info);
 237
 238         return ret;
 239 }
 240
 241 EXPORT_SYMBOL(ircomm_connect_request);
 242
 243 /*
 244  * Function ircomm_connect_indication (self, qos, skb)
 245  *
 246  *    Notify user layer about the incoming connection
 247  *
 248  */
 249 void ircomm_connect_indication(struct ircomm_cb *self, struct sk_buff *skb,
 250                                struct ircomm_info *info)
 251 {
 252         int clen = 0;
 253
 254         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 255
 256         /* Check if the packet contains data on the control channel */
 257         if (skb->len > 0)
 258                 clen = skb->data[0];
 259
 260         /*
 261          * If there are any data hiding in the control channel, we must
 262          * deliver it first. The side effect is that the control channel
 263          * will be removed from the skb
 264          */
 265         if (self->notify.connect_indication)
 266                 self->notify.connect_indication(self->notify.instance, self,
 267                                                 info->qos, info->max_data_size,
 268                                                 info->max_header_size, skb);
 269         else {
 270                 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__ );
 271         }
 272 }
 273
 274 /*
 275  * Function ircomm_connect_response (self, userdata, max_sdu_size)
 276  *
 277  *    User accepts connection
 278  *
 279  */
 280 int ircomm_connect_response(struct ircomm_cb *self, struct sk_buff *userdata)
 281 {
 282         int ret;
 283
 284         IRDA_ASSERT(self != NULL, return -1;);
 285         IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;);
 286
 287         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 288
 289         ret = ircomm_do_event(self, IRCOMM_CONNECT_RESPONSE, userdata, NULL);
 290
 291         return ret;
 292 }
 293
 294 EXPORT_SYMBOL(ircomm_connect_response);
 295
 296 /*
 297  * Function connect_confirm (self, skb)
 298  *
 299  *    Notify user layer that the link is now connected
 300  *
 301  */
 302 void ircomm_connect_confirm(struct ircomm_cb *self, struct sk_buff *skb,
 303                             struct ircomm_info *info)
 304 {
 305         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 306
 307         if (self->notify.connect_confirm )
 308                 self->notify.connect_confirm(self->notify.instance,
 309                                              self, info->qos,
 310                                              info->max_data_size,
 311                                              info->max_header_size, skb);
 312         else {
 313                 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__ );
 314         }
 315 }
 316
 317 /*
 318  * Function ircomm_data_request (self, userdata)
 319  *
 320  *    Send IrCOMM data to peer device
 321  *
 322  */
 323 int ircomm_data_request(struct ircomm_cb *self, struct sk_buff *skb)
 324 {
 325         int ret;
 326
 327         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 328
 329         IRDA_ASSERT(self != NULL, return -EFAULT;);
 330         IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EFAULT;);
 331         IRDA_ASSERT(skb != NULL, return -EFAULT;);
 332
 333         ret = ircomm_do_event(self, IRCOMM_DATA_REQUEST, skb, NULL);
 334
 335         return ret;
 336 }
 337
 338 EXPORT_SYMBOL(ircomm_data_request);
 339
 340 /*
 341  * Function ircomm_data_indication (self, skb)
 342  *
 343  *    Data arrived, so deliver it to user
 344  *
 345  */
 346 void ircomm_data_indication(struct ircomm_cb *self, struct sk_buff *skb)
 347 {
 348         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 349
 350         IRDA_ASSERT(skb->len > 0, return;);
 351
 352         if (self->notify.data_indication)
 353                 self->notify.data_indication(self->notify.instance, self, skb);
 354         else {
 355                 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__ );
 356         }
 357 }
 358
 359 /*
 360  * Function ircomm_process_data (self, skb)
 361  *
 362  *    Data arrived which may contain control channel data
 363  *
 364  */
 365 void ircomm_process_data(struct ircomm_cb *self, struct sk_buff *skb)
 366 {
 367         int clen;
 368
 369         IRDA_ASSERT(skb->len > 0, return;);
 370
 371         clen = skb->data[0];
 372
 373         /*
 374          * Input validation check: a stir4200/mcp2150 combinations sometimes
 375          * results in frames with clen > remaining packet size. These are
 376          * illegal; if we throw away just this frame then it seems to carry on
 377          * fine
 378          */
 379         if (unlikely(skb->len < (clen + 1))) {
 380                 IRDA_DEBUG(2, "%s() throwing away illegal frame\n",
 381                            __FUNCTION__ );
 382                 return;
 383         }
 384
 385         /*
 386          * If there are any data hiding in the control channel, we must
 387          * deliver it first. The side effect is that the control channel
 388          * will be removed from the skb
 389          */
 390         if (clen > 0)
 391                 ircomm_control_indication(self, skb, clen);
 392
 393         /* Remove control channel from data channel */
 394         skb_pull(skb, clen+1);
 395
 396         if (skb->len)
 397                 ircomm_data_indication(self, skb);
 398         else {
 399                 IRDA_DEBUG(4, "%s(), data was control info only!\n",
 400                            __FUNCTION__ );
 401         }
 402 }
 403
 404 /*
 405  * Function ircomm_control_request (self, params)
 406  *
 407  *    Send control data to peer device
 408  *
 409  */
 410 int ircomm_control_request(struct ircomm_cb *self, struct sk_buff *skb)
 411 {
 412         int ret;
 413
 414         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 415
 416         IRDA_ASSERT(self != NULL, return -EFAULT;);
 417         IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EFAULT;);
 418         IRDA_ASSERT(skb != NULL, return -EFAULT;);
 419
 420         ret = ircomm_do_event(self, IRCOMM_CONTROL_REQUEST, skb, NULL);
 421
 422         return ret;
 423 }
 424
 425 EXPORT_SYMBOL(ircomm_control_request);
 426
 427 /*
 428  * Function ircomm_control_indication (self, skb)
 429  *
 430  *    Data has arrived on the control channel
 431  *
 432  */
 433 static void ircomm_control_indication(struct ircomm_cb *self,
 434                                       struct sk_buff *skb, int clen)
 435 {
 436         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 437
 438         /* Use udata for delivering data on the control channel */
 439         if (self->notify.udata_indication) {
 440                 struct sk_buff *ctrl_skb;
 441
 442                 /* We don't own the skb, so clone it */
 443                 ctrl_skb = skb_clone(skb, GFP_ATOMIC);
 444                 if (!ctrl_skb)
 445                         return;
 446
 447                 /* Remove data channel from control channel */
 448                 skb_trim(ctrl_skb, clen+1);
 449
 450                 self->notify.udata_indication(self->notify.instance, self,
 451                                               ctrl_skb);
 452
 453                 /* Drop reference count -
 454                  * see ircomm_tty_control_indication(). */
 455                 dev_kfree_skb(ctrl_skb);
 456         } else {
 457                 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__ );
 458         }
 459 }
 460
 461 /*
 462  * Function ircomm_disconnect_request (self, userdata, priority)
 463  *
 464  *    User layer wants to disconnect the IrCOMM connection
 465  *
 466  */
 467 int ircomm_disconnect_request(struct ircomm_cb *self, struct sk_buff *userdata)
 468 {
 469         struct ircomm_info info;
 470         int ret;
 471
 472         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 473
 474         IRDA_ASSERT(self != NULL, return -1;);
 475         IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;);
 476
 477         ret = ircomm_do_event(self, IRCOMM_DISCONNECT_REQUEST, userdata,
 478                               &info);
 479         return ret;
 480 }
 481
 482 EXPORT_SYMBOL(ircomm_disconnect_request);
 483
 484 /*
 485  * Function disconnect_indication (self, skb)
 486  *
 487  *    Tell user that the link has been disconnected
 488  *
 489  */
 490 void ircomm_disconnect_indication(struct ircomm_cb *self, struct sk_buff *skb,
 491                                   struct ircomm_info *info)
 492 {
 493         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 494
 495         IRDA_ASSERT(info != NULL, return;);
 496
 497         if (self->notify.disconnect_indication) {
 498                 self->notify.disconnect_indication(self->notify.instance, self,
 499                                                    info->reason, skb);
 500         } else {
 501                 IRDA_DEBUG(0, "%s(), missing handler\n", __FUNCTION__ );
 502         }
 503 }
 504
 505 /*
 506  * Function ircomm_flow_request (self, flow)
 507  *
 508  *
 509  *
 510  */
 511 void ircomm_flow_request(struct ircomm_cb *self, LOCAL_FLOW flow)
 512 {
 513         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 514
 515         IRDA_ASSERT(self != NULL, return;);
 516         IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;);
 517
 518         if (self->service_type == IRCOMM_3_WIRE_RAW)
 519                 return;
 520
 521         irttp_flow_request(self->tsap, flow);
 522 }
 523
 524 EXPORT_SYMBOL(ircomm_flow_request);
 525
 526 #ifdef CONFIG_PROC_FS
 527 static void *ircomm_seq_start(struct seq_file *seq, loff_t *pos)
 528 {
 529         struct ircomm_cb *self;
 530         loff_t off = 0;
 531
 532         spin_lock_irq(&ircomm->hb_spinlock);
 533
 534         for (self = (struct ircomm_cb *) hashbin_get_first(ircomm);
 535              self != NULL;
 536              self = (struct ircomm_cb *) hashbin_get_next(ircomm)) {
 537                 if (off++ == *pos)
 538                         break;
 539
 540         }
 541         return self;
 542 }
 543
 544 static void *ircomm_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 545 {
 546         ++*pos;
 547
 548         return (void *) hashbin_get_next(ircomm);
 549 }
 550
 551 static void ircomm_seq_stop(struct seq_file *seq, void *v)
 552 {
 553         spin_unlock_irq(&ircomm->hb_spinlock);
 554 }
 555
 556 static int ircomm_seq_show(struct seq_file *seq, void *v)
 557 {
 558         const struct ircomm_cb *self = v;
 559
 560         IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -EINVAL; );
 561
 562         if(self->line < 0x10)
 563                 seq_printf(seq, "ircomm%d", self->line);
 564         else
 565                 seq_printf(seq, "irlpt%d", self->line - 0x10);
 566
 567         seq_printf(seq,
 568                    " state: %s, slsap_sel: %#02x, dlsap_sel: %#02x, mode:",
 569                    ircomm_state[ self->state],
 570                    self->slsap_sel, self->dlsap_sel);
 571
 572         if(self->service_type & IRCOMM_3_WIRE_RAW)
 573                 seq_printf(seq, " 3-wire-raw");
 574         if(self->service_type & IRCOMM_3_WIRE)
 575                 seq_printf(seq, " 3-wire");
 576         if(self->service_type & IRCOMM_9_WIRE)
 577                 seq_printf(seq, " 9-wire");
 578         if(self->service_type & IRCOMM_CENTRONICS)
 579                 seq_printf(seq, " Centronics");
 580         seq_putc(seq, '\n');
 581
 582         return 0;
 583 }
 584
 585 static const struct seq_operations ircomm_seq_ops = {
 586         .start  = ircomm_seq_start,
 587         .next   = ircomm_seq_next,
 588         .stop   = ircomm_seq_stop,
 589         .show   = ircomm_seq_show,
 590 };
 591
 592 static int ircomm_seq_open(struct inode *inode, struct file *file)
 593 {
 594         return seq_open(file, &ircomm_seq_ops);
 595 }
 596 #endif /* CONFIG_PROC_FS */
 597
 598 MODULE_AUTHOR("Dag Brattli <dag@brattli.net>");
 599 MODULE_DESCRIPTION("IrCOMM protocol");
 600 MODULE_LICENSE("GPL");
 601
 602 module_init(ircomm_init);
 603 module_exit(ircomm_cleanup);