~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/irda/irlan/irlan_common.c

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  */
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 
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  */
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  */
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 */
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  */
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 
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  */
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 
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(&notify);
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, &notify);
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 
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  */
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  */
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  */
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  */
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  */
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 
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  */
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  */
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  */
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  */
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  */
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  */
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 
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  */
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  */
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  */
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  */
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  */
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 */
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 */
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  */
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 
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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp