net/irda/irda_device.c

Name: Public Git Hosting - davej-history.git/blob - net/irda/irda_device.c
Rating: 4.4 (3946 reviews)
 1 /*********************************************************************
 2  *
 3  * Filename: irda_device.c
 4  * Version: 0.5
 5  * Description: Abstract device driver layer and helper functions
 6  * Status: Experimental.
 7  * Author: Dag Brattli <dagb@cs.uit.no>
 8  * Created at: Wed Sep 2 20:22:08 1998
 9  * Modified at: Tue Aug 24 14:31:13 1999
 10  * Modified by: Dag Brattli <dagb@cs.uit.no>
 11  * Modified at: Fri May 28 3:11 CST 1999
 12  * Modified by: Horst von Brand <vonbrand@sleipnir.valparaiso.cl>
 13  *
 14  * Copyright (c) 1998-1999 Dag Brattli, All Rights Reserved.
 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/config.h>
 28 #include <linux/string.h>
 29 #include <linux/proc_fs.h>
 30 #include <linux/skbuff.h>
 31 #include <linux/if.h>
 32 #include <linux/if_ether.h>
 33 #include <linux/if_arp.h>
 34 #include <linux/netdevice.h>
 35 #include <linux/init.h>
 36 #include <linux/tty.h>
 37 #include <linux/kmod.h>
 38 #include <linux/wireless.h>
 39 #include <linux/spinlock.h>
 40
 41 #include <asm/ioctls.h>
 42 #include <asm/segment.h>
 43 #include <asm/uaccess.h>
 44 #include <asm/dma.h>
 45
 46 #include <net/pkt_sched.h>
 47
 48 #include <net/irda/irda_device.h>
 49 #include <net/irda/irlap_frame.h>
 50 #include <net/irda/timer.h>
 51 #include <net/irda/wrapper.h>
 52
 53 externintirtty_init(void);
 54 externintpc87108_init(void);
 55 externintw83977af_init(void);
 56 externintesi_init(void);
 57 externinttekram_init(void);
 58 externintactisys_init(void);
 59 externintgirbil_init(void);
 60
 61 static hashbin_t *irda_device = NULL;
 62 static hashbin_t *dongles = NULL;
 63
 64 /* Netdevice functions */
 65 static intirda_device_net_rebuild_header(struct sk_buff *skb);
 66 static intirda_device_net_hard_header(struct sk_buff *skb,
 67 struct net_device *dev,
 68 unsigned short type,void*daddr,
 69 void*saddr,unsigned len);
 70 static intirda_device_net_set_config(struct net_device *dev,struct ifmap *map);
 71 static intirda_device_net_change_mtu(struct net_device *dev,int new_mtu);
 72 static intirda_device_net_ioctl(struct net_device *dev,struct ifreq *rq,int cmd);
 73 #ifdef CONFIG_PROC_FS
 74 intirda_device_proc_read(char*buf,char**start, off_t offset,int len,
 75 int unused);
 76
 77 #endif/* CONFIG_PROC_FS */
 78
 79 int __init irda_device_init(void)
 80 {
 81 /* Allocate master array */
 82  irda_device =hashbin_new( HB_LOCAL);
 83 if(irda_device == NULL) {
 84 WARNING("IrDA: Can't allocate irda_device hashbin!\n");
 85 return-ENOMEM;
 86 }
 87
 88  dongles =hashbin_new(HB_LOCAL);
 89 if(dongles == NULL) {
 90 printk(KERN_WARNING
 91 "IrDA: Can't allocate dongles hashbin!\n");
 92 return-ENOMEM;
 93 }
 94
 95 /*
 96  * Call the init function of the device drivers that has not been
 97  * compiled as a module
 98  */
 99 #ifdef CONFIG_IRTTY_SIR
 100 irtty_init();
 101 #endif
 102 #ifdef CONFIG_WINBOND_FIR
 103 w83977af_init();
 104 #endif
 105 #ifdef CONFIG_NSC_FIR
 106 pc87108_init();
 107 #endif
 108 #ifdef CONFIG_TOSHIBA_FIR
 109 toshoboe_init();
 110 #endif
 111 #ifdef CONFIG_SMC_IRCC_FIR
 112 ircc_init();
 113 #endif
 114 #ifdef CONFIG_ESI_DONGLE
 115 esi_init();
 116 #endif
 117 #ifdef CONFIG_TEKRAM_DONGLE
 118 tekram_init();
 119 #endif
 120 #ifdef CONFIG_ACTISYS_DONGLE
 121 actisys_init();
 122 #endif
 123 #ifdef CONFIG_GIRBIL_DONGLE
 124 girbil_init();
 125 #endif
 126 #ifdef CONFIG_LITELINK_DONGLE
 127 litelink_init();
 128 #endif
 129 #ifdef CONFIG_AIRPORT_DONGLE
 130 airport_init();
 131 #endif
 132 return0;
 133 }
 134
 135 voidirda_device_cleanup(void)
 136 {
 137 DEBUG(4, __FUNCTION__ "()\n");
 138
 139 ASSERT(irda_device != NULL,return;);
 140
 141 hashbin_delete(dongles, NULL);
 142 hashbin_delete(irda_device, (FREE_FUNC) irda_device_close);
 143 }
 144
 145 /*
 146  * Function irda_device_open (self)
 147  *
 148  * Open a new IrDA port device
 149  *
 150  */
 151 intirda_device_open(struct irda_device *self,char*name,void*priv)
 152 {
 153 int result;
 154 int i=0;
 155
 156 /* Allocate memory if needed */
 157 if(self->rx_buff.truesize >0) {
 158  self->rx_buff.head = ( __u8 *)kmalloc(self->rx_buff.truesize,
 159  self->rx_buff.flags);
 160 if(self->rx_buff.head == NULL)
 161 return-ENOMEM;
 162
 163 memset(self->rx_buff.head,0, self->rx_buff.truesize);
 164 }
 165 if(self->tx_buff.truesize >0) {
 166  self->tx_buff.head = ( __u8 *)kmalloc(self->tx_buff.truesize,
 167  self->tx_buff.flags);
 168 if(self->tx_buff.head == NULL) {
 169 kfree(self->rx_buff.head);
 170 return-ENOMEM;
 171 }
 172
 173 memset(self->tx_buff.head,0, self->tx_buff.truesize);
 174 }
 175
 176  self->magic = IRDA_DEVICE_MAGIC;
 177
 178  self->rx_buff.in_frame = FALSE;
 179  self->rx_buff.state = OUTSIDE_FRAME;
 180  self->tx_buff.data = self->tx_buff.head;
 181  self->rx_buff.data = self->rx_buff.head;
 182
 183 /* Initialize timers */
 184 init_timer(&self->media_busy_timer);
 185
 186  self->lock = SPIN_LOCK_UNLOCKED;
 187
 188 /* A pointer to the low level implementation */
 189  self->priv = priv;
 190
 191 /* Initialize IrDA net device */
 192 do{
 193 sprintf(self->name,"%s%d","irda", i++);
 194 }while(dev_get(self->name) != NULL);
 195
 196  self->netdev.name = self->name;
 197  self->netdev.priv = (void*) self;
 198  self->netdev.next = NULL;
 199
 200 if((result =register_netdev(&self->netdev)) !=0) {
 201 DEBUG(0, __FUNCTION__ "(), register_netdev() failed!\n");
 202 return-1;
 203 }
 204
 205 /*
 206  * Make the description for the device. self->netdev.name will get
 207  * a name like "irda0" and the self->descriptin will get a name
 208  * like "irda0 <-> irtty0"
 209  */
 210 strncpy(self->description, self->name,5);
 211 strcat(self->description," <-> ");
 212 strncat(self->description, name,23);
 213
 214 hashbin_insert(irda_device, (QUEUE *) self, (int) self, NULL);
 215
 216 /* Open network device */
 217 dev_open(&self->netdev);
 218
 219 MESSAGE("IrDA: Registered device %s\n", self->name);
 220
 221 irda_device_set_media_busy(self, FALSE);
 222
 223 return0;
 224 }
 225
 226 /*
 227  * Function irda_device_close (self)
 228  *
 229  * Close this instance of the irda_device, just deallocate buffers
 230  *
 231  */
 232 void__irda_device_close(struct irda_device *self)
 233 {
 234 DEBUG(4, __FUNCTION__ "()\n");
 235
 236 ASSERT(self != NULL,return;);
 237 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return;);
 238
 239 /* We do this test to know if the device has been registered at all */
 240 if(self->netdev.type == ARPHRD_IRDA) {
 241 dev_close(&self->netdev);
 242
 243 /* Remove netdevice */
 244 unregister_netdev(&self->netdev);
 245 }
 246
 247 /* Stop timers */
 248 del_timer(&self->media_busy_timer);
 249
 250 if(self->tx_buff.head)
 251 kfree(self->tx_buff.head);
 252
 253 if(self->rx_buff.head)
 254 kfree(self->rx_buff.head);
 255
 256  self->magic =0;
 257 }
 258
 259 /*
 260  * Function irda_device_close (self)
 261  *
 262  * Close the device
 263  *
 264  */
 265 voidirda_device_close(struct irda_device *self)
 266 {
 267 DEBUG(4, __FUNCTION__ "()\n");
 268
 269 ASSERT(self != NULL,return;);
 270 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return;);
 271
 272 /* We are not using any dongle anymore! */
 273 if(self->dongle)
 274  self->dongle->close(self);
 275
 276 hashbin_remove(irda_device, (int) self, NULL);
 277
 278 __irda_device_close(self);
 279 }
 280
 281 /*
 282  * Function irda_device_set_media_busy (self, status)
 283  *
 284  * Called when we have detected that another station is transmiting
 285  * in contention mode.
 286  */
 287 voidirda_device_set_media_busy(struct irda_device *self,int status)
 288 {
 289 DEBUG(4, __FUNCTION__ "(%s)\n", status ?"TRUE":"FALSE");
 290
 291 ASSERT(self != NULL,return;);
 292 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return;);
 293
 294 if(status) {
 295  self->media_busy = TRUE;
 296 irda_device_start_mbusy_timer(self);
 297 DEBUG(4,"Media busy!\n");
 298 }else{
 299  self->media_busy = FALSE;
 300 del_timer(&self->media_busy_timer);
 301 }
 302 }
 303
 304 /*
 305  * Function __irda_device_change_speed (self, speed)
 306  *
 307  * When this function is called, we will have a process context so its
 308  * possible for us to sleep, wait or whatever :-)
 309  */
 310 static void__irda_device_change_speed(struct irda_device *self,int speed)
 311 {
 312 int n =0;
 313
 314 ASSERT(self != NULL,return;);
 315 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return;);
 316
 317 /*
 318  * Is is possible to change speed yet? Wait until the last byte
 319  * has been transmitted.
 320  */
 321 if(!self->wait_until_sent) {
 322 ERROR("IrDA: wait_until_sent() "
 323 "has not implemented by the IrDA device driver!\n");
 324 return;
 325 }
 326
 327 /* Make sure all transmitted data has actually been sent */
 328  self->wait_until_sent(self);
 329
 330 /* Make sure nobody tries to transmit during the speed change */
 331 while(irda_lock((void*) &self->netdev.tbusy) == FALSE) {
 332 WARNING(__FUNCTION__ "(), device locked!\n");
 333  current->state = TASK_INTERRUPTIBLE;
 334 schedule_timeout(MSECS_TO_JIFFIES(10));
 335
 336 if(n++ >10) {
 337 WARNING(__FUNCTION__ "(), breaking loop!\n");
 338 return;
 339 }
 340 }
 341
 342 /* Change speed of dongle */
 343 if(self->dongle)
 344  self->dongle->change_speed(self, speed);
 345
 346 /* Change speed of IrDA port */
 347 if(self->change_speed) {
 348  self->change_speed(self, speed);
 349
 350 /* Update the QoS value only */
 351  self->qos.baud_rate.value = speed;
 352 }
 353  self->netdev.tbusy = FALSE;
 354 }
 355
 356 /*
 357  * Function irda_device_change_speed (self, speed)
 358  *
 359  * Change the speed of the currently used irda_device
 360  *
 361  */
 362 inlinevoidirda_device_change_speed(struct irda_device *self,int speed)
 363 {
 364 ASSERT(self != NULL,return;);
 365 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return;);
 366
 367 irda_execute_as_process(self,
 368 (TODO_CALLBACK) __irda_device_change_speed,
 369  speed);
 370 }
 371
 372 inlineintirda_device_is_media_busy(struct irda_device *self)
 373 {
 374 ASSERT(self != NULL,return FALSE;);
 375 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return FALSE;);
 376
 377 return self->media_busy;
 378 }
 379
 380 inlineintirda_device_is_receiving(struct irda_device *self)
 381 {
 382 ASSERT(self != NULL,return FALSE;);
 383 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return FALSE;);
 384
 385 if(self->is_receiving)
 386 return self->is_receiving(self);
 387 else
 388 return FALSE;
 389 }
 390
 391 inlinestruct qos_info *irda_device_get_qos(struct irda_device *self)
 392 {
 393 ASSERT(self != NULL,return NULL;);
 394 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return NULL;);
 395
 396 return&self->qos;
 397 }
 398
 399 static struct enet_statistics *irda_device_get_stats(struct net_device *dev)
 400 {
 401 struct irda_device *priv = (struct irda_device *) dev->priv;
 402
 403 return&priv->stats;
 404 }
 405
 406 /*
 407  * Function irda_device_setup (dev)
 408  *
 409  * This function should be used by low level device drivers in a similar way
 410  * as ether_setup() is used by normal network device drivers
 411  */
 412 intirda_device_setup(struct net_device *dev)
 413 {
 414 struct irda_device *self;
 415
 416 ASSERT(dev != NULL,return-1;);
 417
 418  self = (struct irda_device *) dev->priv;
 419
 420 ASSERT(self != NULL,return-1;);
 421 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return-1;);
 422
 423  dev->get_stats = irda_device_get_stats;
 424  dev->rebuild_header = irda_device_net_rebuild_header;
 425  dev->set_config = irda_device_net_set_config;
 426  dev->change_mtu = irda_device_net_change_mtu;
 427 /* dev->hard_header = irda_device_net_hard_header; */
 428  dev->do_ioctl = irda_device_net_ioctl;
 429  dev->hard_header_len =0;
 430  dev->addr_len =0;
 431
 432  dev->type = ARPHRD_IRDA;
 433  dev->tx_queue_len =8;/* Window size + 1 s-frame */
 434
 435 memset(dev->broadcast,0xff,4);
 436
 437  dev->mtu =2048;
 438  dev->tbusy =1;
 439
 440 dev_init_buffers(dev);
 441
 442  dev->flags = IFF_NOARP;
 443
 444 return0;
 445 }
 446
 447 intirda_device_net_open(struct net_device *dev)
 448 {
 449 struct irda_device *self;
 450
 451 ASSERT(dev != NULL,return-1;);
 452
 453  self = dev->priv;
 454
 455 ASSERT(self != NULL,return0;);
 456 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return-1;);
 457
 458 /* Ready to play! */
 459  dev->tbusy =0;
 460  dev->interrupt =0;
 461  dev->start =1;
 462
 463 /*
 464  * Open new IrLAP layer instance, now that everything should be
 465  * initialized properly
 466  */
 467  self->irlap =irlap_open(self);
 468
 469 /* It's now safe to initilize the saddr */
 470 memcpy(self->netdev.dev_addr, &self->irlap->saddr,4);
 471
 472 return0;
 473 }
 474
 475 intirda_device_net_close(struct net_device *dev)
 476 {
 477 struct irda_device *self;
 478
 479 ASSERT(dev != NULL,return-1;);
 480
 481  self = dev->priv;
 482
 483 ASSERT(self != NULL,return0;);
 484 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return-1;);
 485
 486 /* Stop device */
 487  dev->tbusy =1;
 488  dev->start =0;
 489
 490 /* Stop and remove instance of IrLAP */
 491 if(self->irlap)
 492 irlap_close(self->irlap);
 493  self->irlap = NULL;
 494
 495 return0;
 496 }
 497
 498 /*
 499  * Function irda_device_net_rebuild_header (buff, dev, dst, skb)
 500  *
 501  *
 502  *
 503  */
 504 static intirda_device_net_rebuild_header(struct sk_buff *skb)
 505 {
 506 DEBUG(4, __FUNCTION__ "()\n");
 507
 508 return0;
 509 }
 510
 511 static intirda_device_net_hard_header(struct sk_buff *skb,struct net_device *dev,
 512 unsigned short type,void*daddr,
 513 void*saddr,unsigned len)
 514 {
 515 DEBUG(0, __FUNCTION__ "()\n");
 516
 517  skb->mac.raw = skb->data;
 518 /* skb_push(skb,PPP_HARD_HDR_LEN); */
 519 /* return PPP_HARD_HDR_LEN; */
 520
 521 return0;
 522 }
 523
 524 static intirda_device_net_set_config(struct net_device *dev,struct ifmap *map)
 525 {
 526 DEBUG(0, __FUNCTION__ "()\n");
 527
 528 return0;
 529 }
 530
 531 static intirda_device_net_change_mtu(struct net_device *dev,int new_mtu)
 532 {
 533 DEBUG(0, __FUNCTION__ "()\n");
 534
 535 return0;
 536 }
 537
 538
 539 #define SIOCSDONGLE SIOCDEVPRIVATE
 540 static intirda_device_net_ioctl(struct net_device *dev,/* ioctl device */
 541 struct ifreq *rq,/* Data passed */
 542 int cmd)/* Ioctl number */
 543 {
 544 unsigned long flags;
 545 int ret =0;
 546 #ifdef WIRELESS_EXT
 547 struct iwreq *wrq = (struct iwreq *) rq;
 548 #endif
 549 struct irda_device *self;
 550
 551 DEBUG(4, __FUNCTION__ "()\n");
 552
 553 ASSERT(dev != NULL,return-1;);
 554
 555  self = (struct irda_device *) dev->priv;
 556
 557 ASSERT(self != NULL,return-1;);
 558 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return-1;);
 559
 560 DEBUG(0,"%s: ->irda_device_net_ioctl(cmd=0x%X)\n", dev->name, cmd);
 561
 562 /* Disable interrupts & save flags */
 563 save_flags(flags);
 564 cli();
 565
 566 /* Look what is the request */
 567 switch(cmd) {
 568 #ifdef WIRELESS_EXT
 569 case SIOCGIWNAME:
 570 /* Get name */
 571 strcpy(wrq->u.name, self->name);
 572 break;
 573 case SIOCSIWNWID:
 574 /* Set domain */
 575 if(wrq->u.nwid.on) {
 576
 577 }break;
 578 case SIOCGIWNWID:
 579 /* Read domain*/
 580 /* wrq->u.nwid.nwid = domain; */
 581 /* wrq->u.nwid.on = 1; */
 582 break;
 583 case SIOCGIWENCODE:
 584 /* Get scramble key */
 585 /* wrq->u.encoding.code = scramble_key; */
 586 /* wrq->u.encoding.method = 1; */
 587 break;
 588 case SIOCSIWENCODE:
 589 /* Set scramble key */
 590 /* scramble_key = wrq->u.encoding.code; */
 591 break;
 592 case SIOCGIWRANGE:
 593 /* Basic checking... */
 594 if(wrq->u.data.pointer != (caddr_t)0) {
 595 struct iw_range range;
 596
 597 /* Verify the user buffer */
 598  ret =verify_area(VERIFY_WRITE, wrq->u.data.pointer,
 599 sizeof(struct iw_range));
 600 if(ret)
 601 break;
 602
 603 /* Set the length (useless : its constant...) */
 604  wrq->u.data.length =sizeof(struct iw_range);
 605
 606 /* Set information in the range struct */
 607  range.throughput =1.6*1024*1024;/* don't argue on this ! */
 608  range.min_nwid =0x0000;
 609  range.max_nwid =0x01FF;
 610
 611  range.num_channels = range.num_frequency =0;
 612
 613  range.sensitivity =0x3F;
 614  range.max_qual.qual =255;
 615  range.max_qual.level =255;
 616  range.max_qual.noise =0;
 617
 618 /* Copy structure to the user buffer */
 619 copy_to_user(wrq->u.data.pointer, &range,
 620 sizeof(struct iw_range));
 621 }
 622 break;
 623 case SIOCGIWPRIV:
 624 /* Basic checking... */
 625 #if 0
 626 if(wrq->u.data.pointer != (caddr_t)0) {
 627 struct iw_priv_args priv[] =
 628 {/* cmd, set_args, get_args, name */
 629 { SIOCGIPSNAP, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED |0,
 630 sizeof(struct site_survey),
 631 "getsitesurvey"},
 632 };
 633
 634 /* Verify the user buffer */
 635  ret =verify_area(VERIFY_WRITE, wrq->u.data.pointer,
 636 sizeof(priv));
 637 if(ret)
 638 break;
 639
 640 /* Set the number of ioctl available */
 641  wrq->u.data.length =1;
 642
 643 /* Copy structure to the user buffer */
 644 copy_to_user(wrq->u.data.pointer, (u_char *) priv,
 645 sizeof(priv));
 646 }
 647 #endif
 648 break;
 649 #endif
 650 case SIOCSDONGLE:/* Set dongle */
 651 /* Initialize dongle */
 652 irda_device_init_dongle(self, (int) rq->ifr_data);
 653 break;
 654 default:
 655  ret = -EOPNOTSUPP;
 656 }
 657
 658 restore_flags(flags);
 659
 660 return ret;
 661 }
 662
 663 /*
 664  * Function irda_device_txqueue_empty (irda_device)
 665  *
 666  * Check if there is still some frames in the transmit queue for this
 667  * device. Maybe we should use: q->q.qlen == 0.
 668  *
 669  */
 670 intirda_device_txqueue_empty(struct irda_device *self)
 671 {
 672 ASSERT(self != NULL,return-1;);
 673 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return-1;);
 674
 675 if(skb_queue_len(&self->netdev.qdisc->q))
 676 return FALSE;
 677
 678 return TRUE;
 679 }
 680
 681 /*
 682  * Function irda_device_init_dongle (self, type)
 683  *
 684  * Initialize attached dongle. Warning, must be called with a process
 685  * context!
 686  */
 687 voidirda_device_init_dongle(struct irda_device *self,int type)
 688 {
 689 struct dongle_q *node;
 690
 691 ASSERT(self != NULL,return;);
 692 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return;);
 693
 694 #ifdef CONFIG_KMOD
 695 /* Try to load the module needed */
 696 switch(type) {
 697 case ESI_DONGLE:
 698 MESSAGE("IrDA: Initializing ESI dongle!\n");
 699 request_module("esi");
 700 break;
 701 case TEKRAM_DONGLE:
 702 MESSAGE("IrDA: Initializing Tekram dongle!\n");
 703 request_module("tekram");
 704 break;
 705 case ACTISYS_DONGLE:/* FALLTHROUGH */
 706 case ACTISYS_PLUS_DONGLE:
 707 MESSAGE("IrDA: Initializing ACTiSYS dongle!\n");
 708 request_module("actisys");
 709 break;
 710 case GIRBIL_DONGLE:
 711 MESSAGE("IrDA: Initializing GIrBIL dongle!\n");
 712 request_module("girbil");
 713 break;
 714 case LITELINK_DONGLE:
 715 MESSAGE("IrDA: Initializing Litelink dongle!\n");
 716 request_module("litelink");
 717 break;
 718 case AIRPORT_DONGLE:
 719 MESSAGE("IrDA: Initializing Airport dongle!\n");
 720 request_module("airport");
 721 break;
 722 default:
 723 ERROR("Unknown dongle type!\n");
 724 return;
 725 }
 726 #endif/* CONFIG_KMOD */
 727
 728  node =hashbin_find(dongles, type, NULL);
 729 if(!node) {
 730 ERROR("IrDA: Unable to find requested dongle\n");
 731 return;
 732 }
 733
 734 /* Check if we're already using a dongle */
 735 if(self->dongle) {
 736  self->dongle->close(self);
 737 }
 738
 739 /* Set the dongle to be used by this driver */
 740  self->dongle = node->dongle;
 741
 742 /* Now initialize the dongle! */
 743  node->dongle->open(self, type);
 744  node->dongle->qos_init(self, &self->qos);
 745
 746 /* Reset dongle */
 747  node->dongle->reset(self);
 748
 749 /* Set to default baudrate */
 750 irda_device_change_speed(self,9600);
 751 }
 752
 753 /*
 754  * Function irda_device_register_dongle (dongle)
 755  *
 756  *
 757  *
 758  */
 759 intirda_device_register_dongle(struct dongle *dongle)
 760 {
 761 struct dongle_q *new;
 762
 763 /* Check if this dongle has been registred before */
 764 if(hashbin_find(dongles, dongle->type, NULL)) {
 765 MESSAGE(__FUNCTION__ "(), Dongle already registered\n");
 766 return0;
 767 }
 768
 769 /* Make new IrDA dongle */
 770 new= (struct dongle_q *)kmalloc(sizeof(struct dongle_q), GFP_KERNEL);
 771 if(new== NULL)
 772 return-1;
 773
 774 memset(new,0,sizeof(struct dongle_q));
 775 new->dongle = dongle;
 776
 777 /* Insert IrDA dongle into hashbin */
 778 hashbin_insert(dongles, (QUEUE *)new, dongle->type, NULL);
 779
 780 return0;
 781 }
 782
 783 /*
 784  * Function irda_device_unregister_dongle (dongle)
 785  *
 786  *
 787  *
 788  */
 789 voidirda_device_unregister_dongle(struct dongle *dongle)
 790 {
 791 struct dongle_q *node;
 792
 793  node =hashbin_remove(dongles, dongle->type, NULL);
 794 if(!node) {
 795 ERROR(__FUNCTION__ "(), dongle not found!\n");
 796 return;
 797 }
 798 kfree(node);
 799 }
 800
 801 /*
 802  * Function irda_device_set_raw_mode (self, status)
 803  *
 804  *
 805  *
 806  */
 807 intirda_device_set_raw_mode(struct irda_device* self,int status)
 808 {
 809 DEBUG(2, __FUNCTION__ "()\n");
 810
 811 ASSERT(self != NULL,return-1;);
 812 ASSERT(self->magic == IRDA_DEVICE_MAGIC,return-1;);
 813
 814 if(self->set_raw_mode == NULL) {
 815 ERROR(__FUNCTION__ "(), set_raw_mode not impl. by "
 816 "device driver\n");
 817 return-1;
 818 }
 819
 820  self->raw_mode = status;
 821  self->set_raw_mode(self, status);
 822
 823 return0;
 824 }
 825
 826 /*
 827  * Function setup_dma (idev, buffer, count, mode)
 828  *
 829  * Setup the DMA channel
 830  *
 831  */
 832 voidsetup_dma(int channel,char*buffer,int count,int mode)
 833 {
 834 unsigned long flags;
 835
 836  flags =claim_dma_lock();
 837
 838 disable_dma(channel);
 839 clear_dma_ff(channel);
 840 set_dma_mode(channel, mode);
 841 set_dma_addr(channel,virt_to_bus(buffer));
 842 set_dma_count(channel, count);
 843 enable_dma(channel);
 844
 845 release_dma_lock(flags);
 846 }
 847
 848 #ifdef CONFIG_PROC_FS
 849
 850 intirda_device_print_flags(struct irda_device *idev,char*buf)
 851 {
 852 int len=0;
 853
 854  len +=sprintf( buf+len,"\t");
 855
 856 if(idev->netdev.flags & IFF_UP)
 857  len +=sprintf( buf+len,"UP ");
 858 if(!idev->netdev.tbusy)
 859  len +=sprintf( buf+len,"RUNNING ");
 860
 861 if(idev->flags & IFF_SIR)
 862  len +=sprintf( buf+len,"SIR ");
 863 if(idev->flags & IFF_MIR)
 864  len +=sprintf( buf+len,"MIR ");
 865 if(idev->flags & IFF_FIR)
 866  len +=sprintf( buf+len,"FIR ");
 867 if(idev->flags & IFF_PIO)
 868  len +=sprintf( buf+len,"PIO ");
 869 if(idev->flags & IFF_DMA)
 870  len +=sprintf( buf+len,"DMA ");
 871 if(idev->flags & IFF_SHM)
 872  len +=sprintf( buf+len,"SHM ");
 873 if(idev->flags & IFF_DONGLE)
 874  len +=sprintf( buf+len,"DONGLE ");
 875
 876  len +=sprintf( buf+len,"\n");
 877
 878 return len;
 879 }
 880
 881 /*
 882  * Function irda_device_proc_read (buf, start, offset, len, unused)
 883  *
 884  * Give some info to the /proc file system
 885  *
 886  */
 887 intirda_device_proc_read(char*buf,char**start, off_t offset,int len,
 888 int unused)
 889 {
 890 struct irda_device *self;
 891 unsigned long flags;
 892
 893 save_flags(flags);
 894 cli();
 895
 896  len =0;
 897
 898  self = (struct irda_device *)hashbin_get_first(irda_device);
 899 while( self != NULL) {
 900  len +=sprintf(buf+len,"\n%s,", self->name);
 901  len +=sprintf(buf+len,"\tbinding: %s\n",
 902  self->description);
 903
 904  len +=irda_device_print_flags(self, buf+len);
 905  len +=sprintf(buf+len,"\tbps\tmaxtt\tdsize\twinsize\taddbofs\tmintt\tldisc\n");
 906
 907  len +=sprintf(buf+len,"\t%d\t",
 908  self->qos.baud_rate.value);
 909  len +=sprintf(buf+len,"%d\t",
 910  self->qos.max_turn_time.value);
 911  len +=sprintf(buf+len,"%d\t",
 912  self->qos.data_size.value);
 913  len +=sprintf(buf+len,"%d\t",
 914  self->qos.window_size.value);
 915  len +=sprintf(buf+len,"%d\t",
 916  self->qos.additional_bofs.value);
 917  len +=sprintf(buf+len,"%d\t",
 918  self->qos.min_turn_time.value);
 919  len +=sprintf(buf+len,"%d",
 920  self->qos.link_disc_time.value);
 921  len +=sprintf(buf+len,"\n");
 922
 923  self = (struct irda_device *)hashbin_get_next(irda_device);
 924 }
 925 restore_flags(flags);
 926
 927 return len;
 928 }
 929
 930 #endif/* CONFIG_PROC_FS */
 931