1 /*********************************************************************
2 *
3 * Filename: irlan_common.c
4 * Version: 0.9
5 * Description: IrDA LAN Access Protocol Implementation
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sun Aug 31 20:14:37 1997
9 * Modified at: Sun Dec 26 21:53:10 1999
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 *
12 * Copyright (c) 1997, 1999 Dag Brattli <dagb@cs.uit.no>,
13 * All Rights Reserved.
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 * Neither Dag Brattli nor University of Tromsø admit liability nor
21 * provide warranty for any of this software. This material is
22 * provided "AS-IS" and at no charge.
23 *
24 ********************************************************************/
25
26 #include <linux/module.h>
27
28 #include <linux/kernel.h>
29 #include <linux/string.h>
30 #include <linux/gfp.h>
31 #include <linux/init.h>
32 #include <linux/errno.h>
33 #include <linux/proc_fs.h>
34 #include <linux/sched.h>
35 #include <linux/seq_file.h>
36 #include <linux/random.h>
37 #include <linux/netdevice.h>
38 #include <linux/etherdevice.h>
39 #include <linux/rtnetlink.h>
40 #include <linux/moduleparam.h>
41 #include <linux/bitops.h>
42
43 #include <asm/byteorder.h>
44
45 #include <net/irda/irda.h>
46 #include <net/irda/irttp.h>
47 #include <net/irda/irlmp.h>
48 #include <net/irda/iriap.h>
49 #include <net/irda/timer.h>
50
51 #include <net/irda/irlan_common.h>
52 #include <net/irda/irlan_client.h>
53 #include <net/irda/irlan_provider.h>
54 #include <net/irda/irlan_eth.h>
55 #include <net/irda/irlan_filter.h>
56
57
58 /* extern char sysctl_devname[]; */
59
60 /*
61 * Master structure
62 */
63 static LIST_HEAD(irlans);
64
65 static void *ckey;
66 static void *skey;
67
68 /* Module parameters */
69 static bool eth; /* Use "eth" or "irlan" name for devices */
70 static int access = ACCESS_PEER; /* PEER, DIRECT or HOSTED */
71
72 #ifdef CONFIG_PROC_FS
73 static const char *const irlan_access[] = {
74 "UNKNOWN",
75 "DIRECT",
76 "PEER",
77 "HOSTED"
78 };
79
80 static const char *const irlan_media[] = {
81 "UNKNOWN",
82 "802.3",
83 "802.5"
84 };
85
86 extern struct proc_dir_entry *proc_irda;
87
88 static int irlan_seq_open(struct inode *inode, struct file *file);
89
90 static const struct file_operations irlan_fops = {
91 .owner = THIS_MODULE,
92 .open = irlan_seq_open,
93 .read = seq_read,
94 .llseek = seq_lseek,
95 .release = seq_release,
96 };
97
98 extern struct proc_dir_entry *proc_irda;
99 #endif /* CONFIG_PROC_FS */
100
101 static struct irlan_cb __init *irlan_open(__u32 saddr, __u32 daddr);
102 static void __irlan_close(struct irlan_cb *self);
103 static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
104 __u8 value_byte, __u16 value_short,
105 __u8 *value_array, __u16 value_len);
106 static void irlan_open_unicast_addr(struct irlan_cb *self);
107 static void irlan_get_unicast_addr(struct irlan_cb *self);
108 void irlan_close_tsaps(struct irlan_cb *self);
109
110 /*
111 * Function irlan_init (void)
112 *
113 * Initialize IrLAN layer
114 *
115 */
irlan_init(void)116 static int __init irlan_init(void)
117 {
118 struct irlan_cb *new;
119 __u16 hints;
120
121 #ifdef CONFIG_PROC_FS
122 { struct proc_dir_entry *proc;
123 proc = proc_create("irlan", 0, proc_irda, &irlan_fops);
124 if (!proc) {
125 printk(KERN_ERR "irlan_init: can't create /proc entry!\n");
126 return -ENODEV;
127 }
128 }
129 #endif /* CONFIG_PROC_FS */
130
131 hints = irlmp_service_to_hint(S_LAN);
132
133 /* Register with IrLMP as a client */
134 ckey = irlmp_register_client(hints, &irlan_client_discovery_indication,
135 NULL, NULL);
136 if (!ckey)
137 goto err_ckey;
138
139 /* Register with IrLMP as a service */
140 skey = irlmp_register_service(hints);
141 if (!skey)
142 goto err_skey;
143
144 /* Start the master IrLAN instance (the only one for now) */
145 new = irlan_open(DEV_ADDR_ANY, DEV_ADDR_ANY);
146 if (!new)
147 goto err_open;
148
149 /* The master will only open its (listen) control TSAP */
150 irlan_provider_open_ctrl_tsap(new);
151
152 /* Do some fast discovery! */
153 irlmp_discovery_request(DISCOVERY_DEFAULT_SLOTS);
154
155 return 0;
156
157 err_open:
158 irlmp_unregister_service(skey);
159 err_skey:
160 irlmp_unregister_client(ckey);
161 err_ckey:
162 #ifdef CONFIG_PROC_FS
163 remove_proc_entry("irlan", proc_irda);
164 #endif /* CONFIG_PROC_FS */
165
166 return -ENOMEM;
167 }
168
irlan_cleanup(void)169 static void __exit irlan_cleanup(void)
170 {
171 struct irlan_cb *self, *next;
172
173 irlmp_unregister_client(ckey);
174 irlmp_unregister_service(skey);
175
176 #ifdef CONFIG_PROC_FS
177 remove_proc_entry("irlan", proc_irda);
178 #endif /* CONFIG_PROC_FS */
179
180 /* Cleanup any leftover network devices */
181 rtnl_lock();
182 list_for_each_entry_safe(self, next, &irlans, dev_list) {
183 __irlan_close(self);
184 }
185 rtnl_unlock();
186 }
187
188 /*
189 * Function irlan_open (void)
190 *
191 * Open new instance of a client/provider, we should only register the
192 * network device if this instance is ment for a particular client/provider
193 */
irlan_open(__u32 saddr,__u32 daddr)194 static struct irlan_cb __init *irlan_open(__u32 saddr, __u32 daddr)
195 {
196 struct net_device *dev;
197 struct irlan_cb *self;
198
199 /* Create network device with irlan */
200 dev = alloc_irlandev(eth ? "eth%d" : "irlan%d");
201 if (!dev)
202 return NULL;
203
204 self = netdev_priv(dev);
205 self->dev = dev;
206
207 /*
208 * Initialize local device structure
209 */
210 self->magic = IRLAN_MAGIC;
211 self->saddr = saddr;
212 self->daddr = daddr;
213
214 /* Provider access can only be PEER, DIRECT, or HOSTED */
215 self->provider.access_type = access;
216 if (access == ACCESS_DIRECT) {
217 /*
218 * Since we are emulating an IrLAN sever we will have to
219 * give ourself an ethernet address!
220 */
221 dev->dev_addr[0] = 0x40;
222 dev->dev_addr[1] = 0x00;
223 dev->dev_addr[2] = 0x00;
224 dev->dev_addr[3] = 0x00;
225 get_random_bytes(dev->dev_addr+4, 1);
226 get_random_bytes(dev->dev_addr+5, 1);
227 }
228
229 self->media = MEDIA_802_3;
230 self->disconnect_reason = LM_USER_REQUEST;
231 init_timer(&self->watchdog_timer);
232 init_timer(&self->client.kick_timer);
233 init_waitqueue_head(&self->open_wait);
234
235 skb_queue_head_init(&self->client.txq);
236
237 irlan_next_client_state(self, IRLAN_IDLE);
238 irlan_next_provider_state(self, IRLAN_IDLE);
239
240 if (register_netdev(dev)) {
241 pr_debug("%s(), register_netdev() failed!\n",
242 __func__);
243 self = NULL;
244 free_netdev(dev);
245 } else {
246 rtnl_lock();
247 list_add_rcu(&self->dev_list, &irlans);
248 rtnl_unlock();
249 }
250
251 return self;
252 }
253 /*
254 * Function __irlan_close (self)
255 *
256 * This function closes and deallocates the IrLAN client instances. Be
257 * aware that other functions which calls client_close() must
258 * remove self from irlans list first.
259 */
__irlan_close(struct irlan_cb * self)260 static void __irlan_close(struct irlan_cb *self)
261 {
262 ASSERT_RTNL();
263 IRDA_ASSERT(self != NULL, return;);
264 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
265
266 del_timer_sync(&self->watchdog_timer);
267 del_timer_sync(&self->client.kick_timer);
268
269 /* Close all open connections and remove TSAPs */
270 irlan_close_tsaps(self);
271
272 if (self->client.iriap)
273 iriap_close(self->client.iriap);
274
275 /* Remove frames queued on the control channel */
276 skb_queue_purge(&self->client.txq);
277
278 /* Unregister and free self via destructor */
279 unregister_netdevice(self->dev);
280 }
281
282 /* Find any instance of irlan, used for client discovery wakeup */
irlan_get_any(void)283 struct irlan_cb *irlan_get_any(void)
284 {
285 struct irlan_cb *self;
286
287 list_for_each_entry_rcu(self, &irlans, dev_list) {
288 return self;
289 }
290 return NULL;
291 }
292
293 /*
294 * Function irlan_connect_indication (instance, sap, qos, max_sdu_size, skb)
295 *
296 * Here we receive the connect indication for the data channel
297 *
298 */
irlan_connect_indication(void * instance,void * sap,struct qos_info * qos,__u32 max_sdu_size,__u8 max_header_size,struct sk_buff * skb)299 static void irlan_connect_indication(void *instance, void *sap,
300 struct qos_info *qos,
301 __u32 max_sdu_size,
302 __u8 max_header_size,
303 struct sk_buff *skb)
304 {
305 struct irlan_cb *self;
306 struct tsap_cb *tsap;
307
308 self = instance;
309 tsap = sap;
310
311 IRDA_ASSERT(self != NULL, return;);
312 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
313 IRDA_ASSERT(tsap == self->tsap_data,return;);
314
315 self->max_sdu_size = max_sdu_size;
316 self->max_header_size = max_header_size;
317
318 pr_debug("%s: We are now connected!\n", __func__);
319
320 del_timer(&self->watchdog_timer);
321
322 /* If you want to pass the skb to *both* state machines, you will
323 * need to skb_clone() it, so that you don't free it twice.
324 * As the state machines don't need it, git rid of it here...
325 * Jean II */
326 if (skb)
327 dev_kfree_skb(skb);
328
329 irlan_do_provider_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL);
330 irlan_do_client_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL);
331
332 if (self->provider.access_type == ACCESS_PEER) {
333 /*
334 * Data channel is open, so we are now allowed to
335 * configure the remote filter
336 */
337 irlan_get_unicast_addr(self);
338 irlan_open_unicast_addr(self);
339 }
340 /* Ready to transfer Ethernet frames (at last) */
341 netif_start_queue(self->dev); /* Clear reason */
342 }
343
irlan_connect_confirm(void * instance,void * sap,struct qos_info * qos,__u32 max_sdu_size,__u8 max_header_size,struct sk_buff * skb)344 static void irlan_connect_confirm(void *instance, void *sap,
345 struct qos_info *qos,
346 __u32 max_sdu_size,
347 __u8 max_header_size,
348 struct sk_buff *skb)
349 {
350 struct irlan_cb *self;
351
352 self = instance;
353
354 IRDA_ASSERT(self != NULL, return;);
355 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
356
357 self->max_sdu_size = max_sdu_size;
358 self->max_header_size = max_header_size;
359
360 /* TODO: we could set the MTU depending on the max_sdu_size */
361
362 pr_debug("%s: We are now connected!\n", __func__);
363 del_timer(&self->watchdog_timer);
364
365 /*
366 * Data channel is open, so we are now allowed to configure the remote
367 * filter
368 */
369 irlan_get_unicast_addr(self);
370 irlan_open_unicast_addr(self);
371
372 /* Open broadcast and multicast filter by default */
373 irlan_set_broadcast_filter(self, TRUE);
374 irlan_set_multicast_filter(self, TRUE);
375
376 /* Ready to transfer Ethernet frames */
377 netif_start_queue(self->dev);
378 self->disconnect_reason = 0; /* Clear reason */
379 wake_up_interruptible(&self->open_wait);
380 }
381
382 /*
383 * Function irlan_client_disconnect_indication (handle)
384 *
385 * Callback function for the IrTTP layer. Indicates a disconnection of
386 * the specified connection (handle)
387 */
irlan_disconnect_indication(void * instance,void * sap,LM_REASON reason,struct sk_buff * userdata)388 static void irlan_disconnect_indication(void *instance,
389 void *sap, LM_REASON reason,
390 struct sk_buff *userdata)
391 {
392 struct irlan_cb *self;
393 struct tsap_cb *tsap;
394
395 pr_debug("%s(), reason=%d\n", __func__ , reason);
396
397 self = instance;
398 tsap = sap;
399
400 IRDA_ASSERT(self != NULL, return;);
401 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
402 IRDA_ASSERT(tsap != NULL, return;);
403 IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
404
405 IRDA_ASSERT(tsap == self->tsap_data, return;);
406
407 pr_debug("IrLAN, data channel disconnected by peer!\n");
408
409 /* Save reason so we know if we should try to reconnect or not */
410 self->disconnect_reason = reason;
411
412 switch (reason) {
413 case LM_USER_REQUEST: /* User request */
414 pr_debug("%s(), User requested\n", __func__);
415 break;
416 case LM_LAP_DISCONNECT: /* Unexpected IrLAP disconnect */
417 pr_debug("%s(), Unexpected IrLAP disconnect\n", __func__);
418 break;
419 case LM_CONNECT_FAILURE: /* Failed to establish IrLAP connection */
420 pr_debug("%s(), IrLAP connect failed\n", __func__);
421 break;
422 case LM_LAP_RESET: /* IrLAP reset */
423 pr_debug("%s(), IrLAP reset\n", __func__);
424 break;
425 case LM_INIT_DISCONNECT:
426 pr_debug("%s(), IrLMP connect failed\n", __func__);
427 break;
428 default:
429 net_err_ratelimited("%s(), Unknown disconnect reason\n",
430 __func__);
431 break;
432 }
433
434 /* If you want to pass the skb to *both* state machines, you will
435 * need to skb_clone() it, so that you don't free it twice.
436 * As the state machines don't need it, git rid of it here...
437 * Jean II */
438 if (userdata)
439 dev_kfree_skb(userdata);
440
441 irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
442 irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
443
444 wake_up_interruptible(&self->open_wait);
445 }
446
irlan_open_data_tsap(struct irlan_cb * self)447 void irlan_open_data_tsap(struct irlan_cb *self)
448 {
449 struct tsap_cb *tsap;
450 notify_t notify;
451
452 IRDA_ASSERT(self != NULL, return;);
453 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
454
455 /* Check if already open */
456 if (self->tsap_data)
457 return;
458
459 irda_notify_init(¬ify);
460
461 notify.data_indication = irlan_eth_receive;
462 notify.udata_indication = irlan_eth_receive;
463 notify.connect_indication = irlan_connect_indication;
464 notify.connect_confirm = irlan_connect_confirm;
465 notify.flow_indication = irlan_eth_flow_indication;
466 notify.disconnect_indication = irlan_disconnect_indication;
467 notify.instance = self;
468 strlcpy(notify.name, "IrLAN data", sizeof(notify.name));
469
470 tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, ¬ify);
471 if (!tsap) {
472 pr_debug("%s(), Got no tsap!\n", __func__);
473 return;
474 }
475 self->tsap_data = tsap;
476
477 /*
478 * This is the data TSAP selector which we will pass to the client
479 * when the client ask for it.
480 */
481 self->stsap_sel_data = self->tsap_data->stsap_sel;
482 }
483
irlan_close_tsaps(struct irlan_cb * self)484 void irlan_close_tsaps(struct irlan_cb *self)
485 {
486 IRDA_ASSERT(self != NULL, return;);
487 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
488
489 /* Disconnect and close all open TSAP connections */
490 if (self->tsap_data) {
491 irttp_disconnect_request(self->tsap_data, NULL, P_NORMAL);
492 irttp_close_tsap(self->tsap_data);
493 self->tsap_data = NULL;
494 }
495 if (self->client.tsap_ctrl) {
496 irttp_disconnect_request(self->client.tsap_ctrl, NULL,
497 P_NORMAL);
498 irttp_close_tsap(self->client.tsap_ctrl);
499 self->client.tsap_ctrl = NULL;
500 }
501 if (self->provider.tsap_ctrl) {
502 irttp_disconnect_request(self->provider.tsap_ctrl, NULL,
503 P_NORMAL);
504 irttp_close_tsap(self->provider.tsap_ctrl);
505 self->provider.tsap_ctrl = NULL;
506 }
507 self->disconnect_reason = LM_USER_REQUEST;
508 }
509
510 /*
511 * Function irlan_ias_register (self, tsap_sel)
512 *
513 * Register with LM-IAS
514 *
515 */
irlan_ias_register(struct irlan_cb * self,__u8 tsap_sel)516 void irlan_ias_register(struct irlan_cb *self, __u8 tsap_sel)
517 {
518 struct ias_object *obj;
519 struct ias_value *new_value;
520
521 IRDA_ASSERT(self != NULL, return;);
522 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
523
524 /*
525 * Check if object has already been registered by a previous provider.
526 * If that is the case, we just change the value of the attribute
527 */
528 if (!irias_find_object("IrLAN")) {
529 obj = irias_new_object("IrLAN", IAS_IRLAN_ID);
530 irias_add_integer_attrib(obj, "IrDA:TinyTP:LsapSel", tsap_sel,
531 IAS_KERNEL_ATTR);
532 irias_insert_object(obj);
533 } else {
534 new_value = irias_new_integer_value(tsap_sel);
535 irias_object_change_attribute("IrLAN", "IrDA:TinyTP:LsapSel",
536 new_value);
537 }
538
539 /* Register PnP object only if not registered before */
540 if (!irias_find_object("PnP")) {
541 obj = irias_new_object("PnP", IAS_PNP_ID);
542 #if 0
543 irias_add_string_attrib(obj, "Name", sysctl_devname,
544 IAS_KERNEL_ATTR);
545 #else
546 irias_add_string_attrib(obj, "Name", "Linux", IAS_KERNEL_ATTR);
547 #endif
548 irias_add_string_attrib(obj, "DeviceID", "HWP19F0",
549 IAS_KERNEL_ATTR);
550 irias_add_integer_attrib(obj, "CompCnt", 1, IAS_KERNEL_ATTR);
551 if (self->provider.access_type == ACCESS_PEER)
552 irias_add_string_attrib(obj, "Comp#01", "PNP8389",
553 IAS_KERNEL_ATTR);
554 else
555 irias_add_string_attrib(obj, "Comp#01", "PNP8294",
556 IAS_KERNEL_ATTR);
557
558 irias_add_string_attrib(obj, "Manufacturer",
559 "Linux-IrDA Project", IAS_KERNEL_ATTR);
560 irias_insert_object(obj);
561 }
562 }
563
564 /*
565 * Function irlan_run_ctrl_tx_queue (self)
566 *
567 * Try to send the next command in the control transmit queue
568 *
569 */
irlan_run_ctrl_tx_queue(struct irlan_cb * self)570 int irlan_run_ctrl_tx_queue(struct irlan_cb *self)
571 {
572 struct sk_buff *skb;
573
574 if (irda_lock(&self->client.tx_busy) == FALSE)
575 return -EBUSY;
576
577 skb = skb_dequeue(&self->client.txq);
578 if (!skb) {
579 self->client.tx_busy = FALSE;
580 return 0;
581 }
582
583 /* Check that it's really possible to send commands */
584 if ((self->client.tsap_ctrl == NULL) ||
585 (self->client.state == IRLAN_IDLE))
586 {
587 self->client.tx_busy = FALSE;
588 dev_kfree_skb(skb);
589 return -1;
590 }
591 pr_debug("%s(), sending ...\n", __func__);
592
593 return irttp_data_request(self->client.tsap_ctrl, skb);
594 }
595
596 /*
597 * Function irlan_ctrl_data_request (self, skb)
598 *
599 * This function makes sure that commands on the control channel is being
600 * sent in a command/response fashion
601 */
irlan_ctrl_data_request(struct irlan_cb * self,struct sk_buff * skb)602 static void irlan_ctrl_data_request(struct irlan_cb *self, struct sk_buff *skb)
603 {
604 /* Queue command */
605 skb_queue_tail(&self->client.txq, skb);
606
607 /* Try to send command */
608 irlan_run_ctrl_tx_queue(self);
609 }
610
611 /*
612 * Function irlan_get_provider_info (self)
613 *
614 * Send Get Provider Information command to peer IrLAN layer
615 *
616 */
irlan_get_provider_info(struct irlan_cb * self)617 void irlan_get_provider_info(struct irlan_cb *self)
618 {
619 struct sk_buff *skb;
620 __u8 *frame;
621
622 IRDA_ASSERT(self != NULL, return;);
623 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
624
625 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER,
626 GFP_ATOMIC);
627 if (!skb)
628 return;
629
630 /* Reserve space for TTP, LMP, and LAP header */
631 skb_reserve(skb, self->client.max_header_size);
632 skb_put(skb, 2);
633
634 frame = skb->data;
635
636 frame[0] = CMD_GET_PROVIDER_INFO;
637 frame[1] = 0x00; /* Zero parameters */
638
639 irlan_ctrl_data_request(self, skb);
640 }
641
642 /*
643 * Function irlan_open_data_channel (self)
644 *
645 * Send an Open Data Command to provider
646 *
647 */
irlan_open_data_channel(struct irlan_cb * self)648 void irlan_open_data_channel(struct irlan_cb *self)
649 {
650 struct sk_buff *skb;
651 __u8 *frame;
652
653 IRDA_ASSERT(self != NULL, return;);
654 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
655
656 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
657 IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3") +
658 IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "DIRECT"),
659 GFP_ATOMIC);
660 if (!skb)
661 return;
662
663 skb_reserve(skb, self->client.max_header_size);
664 skb_put(skb, 2);
665
666 frame = skb->data;
667
668 /* Build frame */
669 frame[0] = CMD_OPEN_DATA_CHANNEL;
670 frame[1] = 0x02; /* Two parameters */
671
672 irlan_insert_string_param(skb, "MEDIA", "802.3");
673 irlan_insert_string_param(skb, "ACCESS_TYPE", "DIRECT");
674 /* irlan_insert_string_param(skb, "MODE", "UNRELIABLE"); */
675
676 /* self->use_udata = TRUE; */
677
678 irlan_ctrl_data_request(self, skb);
679 }
680
irlan_close_data_channel(struct irlan_cb * self)681 void irlan_close_data_channel(struct irlan_cb *self)
682 {
683 struct sk_buff *skb;
684 __u8 *frame;
685
686 IRDA_ASSERT(self != NULL, return;);
687 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
688
689 /* Check if the TSAP is still there */
690 if (self->client.tsap_ctrl == NULL)
691 return;
692
693 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
694 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN"),
695 GFP_ATOMIC);
696 if (!skb)
697 return;
698
699 skb_reserve(skb, self->client.max_header_size);
700 skb_put(skb, 2);
701
702 frame = skb->data;
703
704 /* Build frame */
705 frame[0] = CMD_CLOSE_DATA_CHAN;
706 frame[1] = 0x01; /* One parameter */
707
708 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
709
710 irlan_ctrl_data_request(self, skb);
711 }
712
713 /*
714 * Function irlan_open_unicast_addr (self)
715 *
716 * Make IrLAN provider accept ethernet frames addressed to the unicast
717 * address.
718 *
719 */
irlan_open_unicast_addr(struct irlan_cb * self)720 static void irlan_open_unicast_addr(struct irlan_cb *self)
721 {
722 struct sk_buff *skb;
723 __u8 *frame;
724
725 IRDA_ASSERT(self != NULL, return;);
726 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
727
728 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
729 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
730 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
731 IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
732 GFP_ATOMIC);
733 if (!skb)
734 return;
735
736 /* Reserve space for TTP, LMP, and LAP header */
737 skb_reserve(skb, self->max_header_size);
738 skb_put(skb, 2);
739
740 frame = skb->data;
741
742 frame[0] = CMD_FILTER_OPERATION;
743 frame[1] = 0x03; /* Three parameters */
744 irlan_insert_byte_param(skb, "DATA_CHAN" , self->dtsap_sel_data);
745 irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
746 irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");
747
748 irlan_ctrl_data_request(self, skb);
749 }
750
751 /*
752 * Function irlan_set_broadcast_filter (self, status)
753 *
754 * Make IrLAN provider accept ethernet frames addressed to the broadcast
755 * address. Be careful with the use of this one, since there may be a lot
756 * of broadcast traffic out there. We can still function without this
757 * one but then _we_ have to initiate all communication with other
758 * hosts, since ARP request for this host will not be answered.
759 */
irlan_set_broadcast_filter(struct irlan_cb * self,int status)760 void irlan_set_broadcast_filter(struct irlan_cb *self, int status)
761 {
762 struct sk_buff *skb;
763 __u8 *frame;
764
765 IRDA_ASSERT(self != NULL, return;);
766 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
767
768 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
769 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
770 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BROADCAST") +
771 /* We may waste one byte here...*/
772 IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
773 GFP_ATOMIC);
774 if (!skb)
775 return;
776
777 /* Reserve space for TTP, LMP, and LAP header */
778 skb_reserve(skb, self->client.max_header_size);
779 skb_put(skb, 2);
780
781 frame = skb->data;
782
783 frame[0] = CMD_FILTER_OPERATION;
784 frame[1] = 0x03; /* Three parameters */
785 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
786 irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST");
787 if (status)
788 irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");
789 else
790 irlan_insert_string_param(skb, "FILTER_MODE", "NONE");
791
792 irlan_ctrl_data_request(self, skb);
793 }
794
795 /*
796 * Function irlan_set_multicast_filter (self, status)
797 *
798 * Make IrLAN provider accept ethernet frames addressed to the multicast
799 * address.
800 *
801 */
irlan_set_multicast_filter(struct irlan_cb * self,int status)802 void irlan_set_multicast_filter(struct irlan_cb *self, int status)
803 {
804 struct sk_buff *skb;
805 __u8 *frame;
806
807 IRDA_ASSERT(self != NULL, return;);
808 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
809
810 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
811 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
812 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") +
813 /* We may waste one byte here...*/
814 IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "NONE"),
815 GFP_ATOMIC);
816 if (!skb)
817 return;
818
819 /* Reserve space for TTP, LMP, and LAP header */
820 skb_reserve(skb, self->client.max_header_size);
821 skb_put(skb, 2);
822
823 frame = skb->data;
824
825 frame[0] = CMD_FILTER_OPERATION;
826 frame[1] = 0x03; /* Three parameters */
827 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
828 irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST");
829 if (status)
830 irlan_insert_string_param(skb, "FILTER_MODE", "ALL");
831 else
832 irlan_insert_string_param(skb, "FILTER_MODE", "NONE");
833
834 irlan_ctrl_data_request(self, skb);
835 }
836
837 /*
838 * Function irlan_get_unicast_addr (self)
839 *
840 * Retrieves the unicast address from the IrLAN provider. This address
841 * will be inserted into the devices structure, so the ethernet layer
842 * can construct its packets.
843 *
844 */
irlan_get_unicast_addr(struct irlan_cb * self)845 static void irlan_get_unicast_addr(struct irlan_cb *self)
846 {
847 struct sk_buff *skb;
848 __u8 *frame;
849
850 IRDA_ASSERT(self != NULL, return;);
851 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
852
853 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
854 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
855 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
856 IRLAN_STRING_PARAMETER_LEN("FILTER_OPERATION",
857 "DYNAMIC"),
858 GFP_ATOMIC);
859 if (!skb)
860 return;
861
862 /* Reserve space for TTP, LMP, and LAP header */
863 skb_reserve(skb, self->client.max_header_size);
864 skb_put(skb, 2);
865
866 frame = skb->data;
867
868 frame[0] = CMD_FILTER_OPERATION;
869 frame[1] = 0x03; /* Three parameters */
870 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
871 irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
872 irlan_insert_string_param(skb, "FILTER_OPERATION", "DYNAMIC");
873
874 irlan_ctrl_data_request(self, skb);
875 }
876
877 /*
878 * Function irlan_get_media_char (self)
879 *
880 *
881 *
882 */
irlan_get_media_char(struct irlan_cb * self)883 void irlan_get_media_char(struct irlan_cb *self)
884 {
885 struct sk_buff *skb;
886 __u8 *frame;
887
888 IRDA_ASSERT(self != NULL, return;);
889 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
890
891 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
892 IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3"),
893 GFP_ATOMIC);
894
895 if (!skb)
896 return;
897
898 /* Reserve space for TTP, LMP, and LAP header */
899 skb_reserve(skb, self->client.max_header_size);
900 skb_put(skb, 2);
901
902 frame = skb->data;
903
904 /* Build frame */
905 frame[0] = CMD_GET_MEDIA_CHAR;
906 frame[1] = 0x01; /* One parameter */
907
908 irlan_insert_string_param(skb, "MEDIA", "802.3");
909 irlan_ctrl_data_request(self, skb);
910 }
911
912 /*
913 * Function insert_byte_param (skb, param, value)
914 *
915 * Insert byte parameter into frame
916 *
917 */
irlan_insert_byte_param(struct sk_buff * skb,char * param,__u8 value)918 int irlan_insert_byte_param(struct sk_buff *skb, char *param, __u8 value)
919 {
920 return __irlan_insert_param(skb, param, IRLAN_BYTE, value, 0, NULL, 0);
921 }
922
irlan_insert_short_param(struct sk_buff * skb,char * param,__u16 value)923 int irlan_insert_short_param(struct sk_buff *skb, char *param, __u16 value)
924 {
925 return __irlan_insert_param(skb, param, IRLAN_SHORT, 0, value, NULL, 0);
926 }
927
928 /*
929 * Function insert_string (skb, param, value)
930 *
931 * Insert string parameter into frame
932 *
933 */
irlan_insert_string_param(struct sk_buff * skb,char * param,char * string)934 int irlan_insert_string_param(struct sk_buff *skb, char *param, char *string)
935 {
936 int string_len = strlen(string);
937
938 return __irlan_insert_param(skb, param, IRLAN_ARRAY, 0, 0, string,
939 string_len);
940 }
941
942 /*
943 * Function insert_array_param(skb, param, value, len_value)
944 *
945 * Insert array parameter into frame
946 *
947 */
irlan_insert_array_param(struct sk_buff * skb,char * name,__u8 * array,__u16 array_len)948 int irlan_insert_array_param(struct sk_buff *skb, char *name, __u8 *array,
949 __u16 array_len)
950 {
951 return __irlan_insert_param(skb, name, IRLAN_ARRAY, 0, 0, array,
952 array_len);
953 }
954
955 /*
956 * Function insert_param (skb, param, value, byte)
957 *
958 * Insert parameter at end of buffer, structure of a parameter is:
959 *
960 * -----------------------------------------------------------------------
961 * | Name Length[1] | Param Name[1..255] | Val Length[2] | Value[0..1016]|
962 * -----------------------------------------------------------------------
963 */
__irlan_insert_param(struct sk_buff * skb,char * param,int type,__u8 value_byte,__u16 value_short,__u8 * value_array,__u16 value_len)964 static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
965 __u8 value_byte, __u16 value_short,
966 __u8 *value_array, __u16 value_len)
967 {
968 __u8 *frame;
969 __u8 param_len;
970 __le16 tmp_le; /* Temporary value in little endian format */
971 int n=0;
972
973 if (skb == NULL) {
974 pr_debug("%s(), Got NULL skb\n", __func__);
975 return 0;
976 }
977
978 param_len = strlen(param);
979 switch (type) {
980 case IRLAN_BYTE:
981 value_len = 1;
982 break;
983 case IRLAN_SHORT:
984 value_len = 2;
985 break;
986 case IRLAN_ARRAY:
987 IRDA_ASSERT(value_array != NULL, return 0;);
988 IRDA_ASSERT(value_len > 0, return 0;);
989 break;
990 default:
991 pr_debug("%s(), Unknown parameter type!\n", __func__);
992 return 0;
993 }
994
995 /* Insert at end of sk-buffer */
996 frame = skb_tail_pointer(skb);
997
998 /* Make space for data */
999 if (skb_tailroom(skb) < (param_len+value_len+3)) {
1000 pr_debug("%s(), No more space at end of skb\n", __func__);
1001 return 0;
1002 }
1003 skb_put(skb, param_len+value_len+3);
1004
1005 /* Insert parameter length */
1006 frame[n++] = param_len;
1007
1008 /* Insert parameter */
1009 memcpy(frame+n, param, param_len); n += param_len;
1010
1011 /* Insert value length (2 byte little endian format, LSB first) */
1012 tmp_le = cpu_to_le16(value_len);
1013 memcpy(frame+n, &tmp_le, 2); n += 2; /* To avoid alignment problems */
1014
1015 /* Insert value */
1016 switch (type) {
1017 case IRLAN_BYTE:
1018 frame[n++] = value_byte;
1019 break;
1020 case IRLAN_SHORT:
1021 tmp_le = cpu_to_le16(value_short);
1022 memcpy(frame+n, &tmp_le, 2); n += 2;
1023 break;
1024 case IRLAN_ARRAY:
1025 memcpy(frame+n, value_array, value_len); n+=value_len;
1026 break;
1027 default:
1028 break;
1029 }
1030 IRDA_ASSERT(n == (param_len+value_len+3), return 0;);
1031
1032 return param_len+value_len+3;
1033 }
1034
1035 /*
1036 * Function irlan_extract_param (buf, name, value, len)
1037 *
1038 * Extracts a single parameter name/value pair from buffer and updates
1039 * the buffer pointer to point to the next name/value pair.
1040 */
irlan_extract_param(__u8 * buf,char * name,char * value,__u16 * len)1041 int irlan_extract_param(__u8 *buf, char *name, char *value, __u16 *len)
1042 {
1043 __u8 name_len;
1044 __u16 val_len;
1045 int n=0;
1046
1047 /* get length of parameter name (1 byte) */
1048 name_len = buf[n++];
1049
1050 if (name_len > 254) {
1051 pr_debug("%s(), name_len > 254\n", __func__);
1052 return -RSP_INVALID_COMMAND_FORMAT;
1053 }
1054
1055 /* get parameter name */
1056 memcpy(name, buf+n, name_len);
1057 name[name_len] = '\0';
1058 n+=name_len;
1059
1060 /*
1061 * Get length of parameter value (2 bytes in little endian
1062 * format)
1063 */
1064 memcpy(&val_len, buf+n, 2); /* To avoid alignment problems */
1065 le16_to_cpus(&val_len); n+=2;
1066
1067 if (val_len >= 1016) {
1068 pr_debug("%s(), parameter length to long\n", __func__);
1069 return -RSP_INVALID_COMMAND_FORMAT;
1070 }
1071 *len = val_len;
1072
1073 /* get parameter value */
1074 memcpy(value, buf+n, val_len);
1075 value[val_len] = '\0';
1076 n+=val_len;
1077
1078 pr_debug("Parameter: %s ", name);
1079 pr_debug("Value: %s\n", value);
1080
1081 return n;
1082 }
1083
1084 #ifdef CONFIG_PROC_FS
1085
1086 /*
1087 * Start of reading /proc entries.
1088 * Return entry at pos,
1089 * or start_token to indicate print header line
1090 * or NULL if end of file
1091 */
irlan_seq_start(struct seq_file * seq,loff_t * pos)1092 static void *irlan_seq_start(struct seq_file *seq, loff_t *pos)
1093 {
1094 rcu_read_lock();
1095 return seq_list_start_head(&irlans, *pos);
1096 }
1097
1098 /* Return entry after v, and increment pos */
irlan_seq_next(struct seq_file * seq,void * v,loff_t * pos)1099 static void *irlan_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1100 {
1101 return seq_list_next(v, &irlans, pos);
1102 }
1103
1104 /* End of reading /proc file */
irlan_seq_stop(struct seq_file * seq,void * v)1105 static void irlan_seq_stop(struct seq_file *seq, void *v)
1106 {
1107 rcu_read_unlock();
1108 }
1109
1110
1111 /*
1112 * Show one entry in /proc file.
1113 */
irlan_seq_show(struct seq_file * seq,void * v)1114 static int irlan_seq_show(struct seq_file *seq, void *v)
1115 {
1116 if (v == &irlans)
1117 seq_puts(seq, "IrLAN instances:\n");
1118 else {
1119 struct irlan_cb *self = list_entry(v, struct irlan_cb, dev_list);
1120
1121 IRDA_ASSERT(self != NULL, return -1;);
1122 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
1123
1124 seq_printf(seq,"ifname: %s,\n",
1125 self->dev->name);
1126 seq_printf(seq,"client state: %s, ",
1127 irlan_state[ self->client.state]);
1128 seq_printf(seq,"provider state: %s,\n",
1129 irlan_state[ self->provider.state]);
1130 seq_printf(seq,"saddr: %#08x, ",
1131 self->saddr);
1132 seq_printf(seq,"daddr: %#08x\n",
1133 self->daddr);
1134 seq_printf(seq,"version: %d.%d,\n",
1135 self->version[1], self->version[0]);
1136 seq_printf(seq,"access type: %s\n",
1137 irlan_access[self->client.access_type]);
1138 seq_printf(seq,"media: %s\n",
1139 irlan_media[self->media]);
1140
1141 seq_printf(seq,"local filter:\n");
1142 seq_printf(seq,"remote filter: ");
1143 irlan_print_filter(seq, self->client.filter_type);
1144 seq_printf(seq,"tx busy: %s\n",
1145 netif_queue_stopped(self->dev) ? "TRUE" : "FALSE");
1146
1147 seq_putc(seq,'\n');
1148 }
1149 return 0;
1150 }
1151
1152 static const struct seq_operations irlan_seq_ops = {
1153 .start = irlan_seq_start,
1154 .next = irlan_seq_next,
1155 .stop = irlan_seq_stop,
1156 .show = irlan_seq_show,
1157 };
1158
irlan_seq_open(struct inode * inode,struct file * file)1159 static int irlan_seq_open(struct inode *inode, struct file *file)
1160 {
1161 return seq_open(file, &irlan_seq_ops);
1162 }
1163 #endif
1164
1165 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
1166 MODULE_DESCRIPTION("The Linux IrDA LAN protocol");
1167 MODULE_LICENSE("GPL");
1168
1169 module_param(eth, bool, 0);
1170 MODULE_PARM_DESC(eth, "Name devices ethX (0) or irlanX (1)");
1171 module_param(access, int, 0);
1172 MODULE_PARM_DESC(access, "Access type DIRECT=1, PEER=2, HOSTED=3");
1173
1174 module_init(irlan_init);
1175 module_exit(irlan_cleanup);
1176
1177